16bit -> 2*8bit und 2*8bit -> 16bit

[Markus C. (ljmarkus)]

Guten Morgen,

komme mit der umrechnung nicht klar. Hoffe Ihr könnt mir helfen.

AVR M8515 und CVAVR


16bit Zahl in 2 8bit zerlegen:

Sender:
Adresse ist 16bit

Data[0] = Adresse >> 8;
Data[1] = (char) Adresse;
-------------------------------------------

Empfänger:
Adresse ist wieder 16bit

Adresse = Data[0]<<8 + Data[1];



nur leider stimmt das Ergebnis nicht. Wo liegt mein Fehler ?


Danke, Markus

[Läubi .. (laeubi)]

Was heißt den "stimmt nicht"?.
Sende/Empfangsreihengfolge ggf falsch?

[Markus C. (ljmarkus)]

wenn ich Adresse 1 sende reagiert der Empfänger auf keiner Adresse.
Sende ich den Wert 256 dann reagiert der Empfäner auf 256.
Sende ich den Wert 257 dann reagiert der Empfäger immer noch auf 256

[ROFL (Gast)]

evtl. mal einen "Angst-cast" ausprobieren und maskieren:

Adresse = ((int)(Data[0])<<8) | ((int)(Data[1]) & 0x00ff);

[Markus C. (ljmarkus)]

@ROFL

supi, danke, so funktioniert es.


mfg,
Markus

[Matthias L. (Gast)]

Das ist kein Angstcast, das muss einfach vorher sein:

Adresse =   (  (uint16_t) Data[0] << 8 )
          | (  (uint16_t) Data[1]      );

Wobei man einen der beiden Casts weglassen kann.

[eProfi (Gast)]

Das Problem ist die Priorität von << und +.

Der Compiler rechnet nämlich die Zeile
Adresse = Data[0]<<8 + Data[1];

so:
Adresse = Data[0]<<(8 + Data[1]);

Du brauchst nur eine Klammer, nämlich so:
Adresse = (Data[0]<<8) + Data[1];

Richtig rechnet er ohne Klammer so:
Adresse = Data[0]*256 + Data[1];

Denn hier gilt PvS (Punkt vor Strich).



Da auf einem 8-bit-Rechner das ganze Geschiebe überflüssig ist, würde 
ich eine union empfehlen. Habe ich ja schon oft genug hier gepostet.

[Detlev T. (detlevt)]

Klammern sind notwendig, weil die Addition eine höhere Priorität als der 
Shift-Operator hat. Auf einem 8-Bit-Rechner sollte man zudem 
sicherstellen, dass die Shift-Operation nicht in 8 Bit ausgeführt wird, 
weil sonst die Bits im Nirwana verschwinden. Ein expliziter Cast auf 
16-Bit ist sicher nicht falsch.

Halbwegs ordentliche Compiler sind in der Lage, einen Shift um 8-Bits 
einen Kopierbefehl zu optimieren. Ein explizites Handling mit 
union-Datentypen ist daher meist überflüssig.