Hallöchen,
also
value1 = lib_math_mult_s ( signal, WORD_MAX_HALF ) +
WORD_MAX_HALF;
Wie du vermutest, wird hier multipliziert und addiert.
Nehmen wir mal an, ein WORD hätte bei dir 16 Bit. Der Maximalwert eines WORDs ist dann binär 11111111.11111111 (oder dezimal 65535). Die Hälfte davon ist dann 01111111.11111111 (oder dezimal 32767).
Ich vermute mal, daß signal nur die Werte 0 und 1 annehmen kann. Dann bekommt man also entweder 00000000.00000000 als Multiplikationsergebnis oder halt 01111111.11111111 .
Dazu wird dann noch WORD_MAX_HALF addiert, das heißt, die beiden möglichen Ergebnisse sind dann entweder 01111111.11111111 oder 10000000.00000000 .
writeIntDataAtCharAdr( &value1 , &(msgPtr -> einByte.Data2));
Eins der beiden Ergebnisse wird nun offenbar in eine Message-Struktur eingefügt.
void writeIntDataAtCharAdr (unsigned int *dataPtr, unsigned
char *adrPtr)
Dazu bekommt die writeIntDataAtCharAdr zunächst einen Zeiger auf dein value1, sowie einen Zeiger, wohin die Daten geschrieben werden sollen.
{
unsigned char *uCDataPtr;
uCDataPtr = (unsigned char *) dataPtr; *adrPtr = *uCDataPtr;
dataPtr zeigt eigentlich auf eine Variable von Typ int. Angenommen, ein int ist auf deinem System 16 Bit groß (das paßt dann gut zur WORD-Größe von oben).
uCDataPtr = (unsigned char *) dataPtr;
Greift sich von dem int allerdings nur das erste Byte. Je nachdem, wie dein Prozessor die Bytes im Speicher ablegt („byte order“), ist das entweder das erste oder zweite Byte von value1.
Dieses Byte wird dann an die Stelle adrPtr in den Speicher geschrieben.
*(adrPtr + 1) = (unsigned char) (*(dataPtr) >> 8); }
Hier wird jetzt noch das verbleibende, zweite Byte geholt und in den MsgBuffer geschrieben.
Zunächst holt *dataPtr den kompletten Wert von value1. Das wäre also z. B. 01111111.11111111 .
Dieser Wert wird dann 8 binäre Stellen nach rechts verschoben: 00000000.01111111 .
Mit dem Cast (unsigned char) wird dem Compiler gesagt, daß er diesen Wert wie ein Byte behandeln soll. Dadurch wird der obere Teil abgeschnitten und es verbleibt nur 01111111 .
Dieser Wert wird nun in den Inhalt von adrPtr+1 geschrieben.
Soweit ich das sehe, könnte signal vielleicht ein Meßwert sein, der den Wertebereich -1…+1 überstreicht. Durch Multiplikation und Verschiebung wird dieser Wert auf den Bereich 0…65536 skaliert, wobei der Nullpunkt in der Mitte der Skala liegt.
Dieser Wert wird anschließend als zwei separate Bytes in die Msg geschrieben.
Statt mit der Funktion hätte man das auch so machen können:
value1 = lib_math_mult_s ( signal, WORD_MAX_HALF ) + WORD_MAX_HALF;
msgPtr->einByte.Data2 = (unsigned char) value;
msgPtr->einByte.Data3 = (unsigned char) (value >> 8);
Je nachdem, wie die byte order deines Prozessors ist (big endian oder little endian), müssen die beiden letzten Codezeilen auch vertauscht werden.
Um das ganze portabel zu machen, wäre es gut, sich von der Byte-Reihenfolge abzukoppeln, also z. B.
HiByte = (value >> 8) & 0xFF;
LoByte = (value ) & 0xFF;
msgPtr->HighByte = HiByte;
msgPtr->LowByte = LoByte;
Das macht die Sache insofern lesbarer, weil man (1) sieht, daß es sich um eine Hi/Lo-Byte-Trennung handelt und man (2) sofort erkennen kann, welches Byte wohin geht.
Weiterhin viel Spaß beim „controllern“…
Elizar
