uint16 in uint8 schreiben

[Großes F. (112)]

hallo nochmal

wenn ich einen volatile uint8_t Wert_1,
und dazu einen volatile uint16_t Wert_2 besitze,


kann ich dann mich darauf verlassen, dass ein Anweisung

Wert_1=Wert_2;

zuverlässig das HighByte oder das LowByte ignoriert ohne dabei im Rest 
meines Programms Unsinn anzustellen?

Wert_2 sind z.B. Millisekunden und sollen nur als Prüfwert an eine 1 
Byte Variable übergeben werden, um somit Pseudozufallszahlen als Prüfung 
zu erhalten

[Stefan B. (stefan)]

Es macht dem Zufall nichts aus, dass bis zu 65536 mögliche Werte in 
Wert_2 auf nur 256 mögliche Werte in Wert_1 abgebildet werden?

Ich schätze (*), dass wegen des volatile ein 16-Bit Lesezugriff auf die 
Variable Wert_2 erfolgt. Highbyte und Lowbyte von Wert_2 werden aber 
nicht geändert. Wenn doch eine Änderung erfolgt, dann vielleicht 
aufgrund eines parallel laufenden Interrupts mit Schreibzugriff. In 
diesem Fall sollte der Lesezugriff sowieso atomar erfolgen wie im 
Artikel Interrupt erklärt.

(*) Genau kann man das mit dem Disassemblerlisting klären.

[pridul75 (Gast)]

Das ist so:

uint8_t  Wert1;
uint16_t Wert2;


Bei der Zuweisung

Wert1 = Wert2;

wird nur das untere Byte übernommen.

Beispiel:

uint8_t Wert1;
uint16_t Wert2 = 256;

Wert1 = Wert2;

Wert1 ist dann 0.

(Bei 257 wäre Wert1 gleich 1 :-))


Das ganze nennt man implizite Zuweisung. Die C-Regeln führen dann zum 
oben beschriebenen Verhalten.

Schöner wäre es, Du würdest das Casting auch kenntlich machen:

Wert1 = (uint8_t)Wert2;

Dann wäre das auch für Dich in einiger Zeit noch klar, dass hier bei der
Zuweisung Informationen verloren gehen (können).
Manche Compiler meckern da auch (einfach mal höchste Warning-Stufe 
einschalten), was hilfreich ist, Fehler gleich zu Beginn zu finden.
Außerdem wäre es sinnvoll, wenn Du Deine Variablen Typzusätze im Namen 
hinzufügst.

Beispiel:

uint8_t Wert1_uint8;

Oder wie auch immer Du möchtest. Dann kannst Du ebenfalls schneller 
sehen,
was hier passiert.


Meine Musterlösung wäre dann irgendwie sowas:

uint8_t Wert1_uint8;
uint16_t Wert2_uint16 = 256;

Wert1_uint8 = (uint8_t)Wert2_uint16;


Ich selber nennen die Typen aber anders (u8, u16, u32, s8, s16, s32, 
usw.).

u8 Variable_u8;
u16 Variable_u16 = 256;

Variable_u8 = (u8)Variable_u16;


Und so weiter...

[pridul75 (Gast)]

Das heißt dann nebenbei "explizite Zuweisung".