16bit werte über I2C senden

[Peter (Gast)]

Hallo,

Ich möchte einen 16bit wert über I2C senden. Meine Sendefunktion lautet 
wie folgt

void I2cBigWrite(int bigVal) {  
  Wire.write((byte *)&bigVal, sizeof(int));
}

Und empfangen wird es wie folgt:

uint8_t receivedbyte = Wire.read();
    RS422.print("LOW Byte: ");
    RS422.println(receivedbyte);
    // Read high byte into buffer

    receivedbyte = Wire.read() ;
    RS422.print("HIGH Byte: ");
    RS422.println(received byte);

Wenn ich jedoch bspw den Wert 1000 Sende erhalte ich folgendes:

LOW Byte: 232
HIGH Byte: 255


Wie setze ich das nun zusammen um nachher wieder den Wert 1000 zu 
bekommen?

Vielen Dank!

Grüße

Peter

[Falk B. (falk)]

@ Peter (Gast)

>Wenn ich jedoch bspw den Wert 1000 Sende erhalte ich folgendes:

Wer sendet 1000?

>LOW Byte: 232
>HIGH Byte: 255

232*256 + 255 = 59647

Das kann so oder so niemals 1000 sein.

>Wie setze ich das nun zusammen um nachher wieder den Wert 1000 zu
>bekommen?

Highbyte * 256 + Lowbytes

[Marc V. (Firma: Vescomp) (logarithmus)]

Peter schrieb:
> Wenn ich jedoch bspw den Wert 1000 Sende erhalte ich folgendes:
>
> LOW Byte: 232
> HIGH Byte: 255
>
> Wie setze ich das nun zusammen um nachher wieder den Wert 1000 zu
> bekommen?

 1000d = 3E8h
 E8h = 232d

 Also, LowByte ist richtig, ob und wie und was du da als HighByte
 sendest ist fraglich.
 IdleLine ergibt 255, uberprufe nochmal deine Senderoutine.

[Peter (Gast)]

Okay, habe mal meine Sendefunktion überarbeitet, sie Schluckt jetzt nur 
16bit variablen:

void I2cBigNum(int16_t bigNum){
    byte myArray[2];
    myArray[0] = (bigNum >> 8);
    myArray[1] = bigNum ;
    Wire.write(myArray, 2);
}

Meine Empfängerfunktion ist diese:

    
uint8_t low = Wire.read();
    RS422.print("LOW Byte: ");
    RS422.println(low);
    // Read high byte into buffer

   uint8_t high= Wire.read() ;
    RS422.print("HIGH Byte: ");
    RS422.println(high);

    RS422.print("Gesamtbyte :");
    uint16_t voll= low;
    voll = voll << 8 | high;
    RS422.println(voll);

Das Ergebnis lautet dann jedoch 1023, anstatt 1000... Teste ich es mit 
1050 anstatt 1000 ist das Ergebnis 1279. Gibt es dazu eine Erklärung?

[Marc V. (Firma: Vescomp) (logarithmus)]

Peter schrieb:
> Das Ergebnis lautet dann jedoch 1023, anstatt 1000... Teste ich es mit
> 1050 anstatt 1000 ist das Ergebnis 1279. Gibt es dazu eine Erklärung?

 Ja.
 Jetzt ist dein HighByte OK, aber LowByte nicht.

 Nochmal überarbeiten ;)

 Tip:
 Wie ware es wenn du die beiden Bytes erst empfangst und danach
 ausgibst ?

[Frickelfritze (Gast)]

Peter schrieb:
> Gibt es dazu eine Erklärung?

Die Arduino Help gibt folgendes Besipiel.

void loop()
{
  Wire.requestFrom(2, 6);    // request 6 bytes from slave device #2
  while(Wire.available())    // slave may send less than requested
  {
    char c = Wire.read();    // receive a byte as character
    Serial.print(c);         // print the character
  }
  delay(500);
}

Entscheidend ist wohl dass du deinem AVR erst sagen musst wieviel
du empfangen willst.

Deine jetzige Form verschluckt das zweite Byte vermutlich da
Wire.read() erst ausgerufen wird wenn das 2 Byte schon längst
gesendet wurde.

[Karl (Gast)]

du schickst ein int16_t und möchtest daraus ein uint16_t zusammenbauen. 
Das geht so nicht, weil die int16_t intern als 2er-Komplement 
dargestellt werden. Entweder musst du also wieder ein int16_t als 
Ausgabe verwenden oder das ganze konvertieren.

[Frank E. (Firma: Q3) (qualidat)]

Wie wäre es einfach mit Mod und Div?

[Max (Gast)]

Karl schrieb:
> du schickst ein int16_t und möchtest daraus ein uint16_t zusammenbauen.
> Das geht so nicht, weil die int16_t intern als 2er-Komplement
> dargestellt werden. Entweder musst du also wieder ein int16_t als
> Ausgabe verwenden oder das ganze konvertieren.

Das ist ein guter Hinweis: Wenn du in C++ auf eine `signed` Variable den 
`>>` Operator anwendest, dann wird daraus ein arithmetischer 
Rechtsshift, also mit Sign Extension.
Um sicher zu sein könntest du deine 16-bit Werte erst einmal in einen 
unsigned casten. Ein einfacher `static_cast<uint16_t>()` belässt die 
bits im Speicher unangetastet.
Dann kannst du die bits beliebig verschieben, die Daten senden, am 
anderen Ende wieder unsigned zusammenbauen und erst ganz am Schluss 
wieder zurueck casten: `static_cast<int16_t>()`.

Wuerde mich interessieren, ob das vielleicht dein Problem loest.