Avr operatoren hilfe

[dani (Gast)]

kann jemand mir klären was dies Befehl macht
while (!(USR & (1<<UDRE)))
 ich verstehe es so :  UDRE  wird gesetzt durch :  (1<<UDRE)
wird dann mit USR  undverknüpft also  UDRE =   00010000
                                                          &
                                      USR =    xxxxxxxx
                                              ---------------
                                               0000x0000

 wenn x=1,dann der code ist 00010000 also (! 00010000 )  =
11101111
und wenn x=0; der Code gleich  00000000  also  (! 00000000 )  =
11111111      ist das richtig so ,

wenn ja dann wie soll ich es hier verstehen  * warten bis Senden

  kann mir jemand es interpretieren ? wann while (!(USR & (1<<UDRE))) 
wahr ist und wann nicht danke


while (!(USR & (1<<UDRE)))  /* warten bis Senden moeglich 
*/
    {
    }

    UDR = 'x';                  /* schreibt das Zeichen x auf die 
Schnittstelle */



UDRE (UART Data Register Empty)

Dieses Bit zeigt an, ob der Sendepuffer bereit ist, um ein zu sendendes 
Zeichen aufzunehmen. Das Bit wird vom AVR gesetzt (1), wenn der 
Sendepuffer leer ist. Es wird gelöscht (0), wenn ein Zeichen im 
Sendedatenregister vorhanden ist und noch nicht in das 
Sendeschieberegister übernommen wurde. Atmel empfiehlt aus 
Kompatibilitätsgründen mit kommenden µC, UDRE auf 0 zu setzen, wenn das 
UCSRA Register beschrieben wird.
Das Bit wird automatisch gelöscht, wenn ein Zeichen in das 
Sendedatenregister geschrieben wird.

[Karl H. (kbuchegg)]

Deine Erklärung ist nicht so unfalsch, wenn auch etwas konfus 
geschrieben.

Das man mittels 1 << UDRE sich eine Bitmaske erzeugt, die genau an der 
Stelle UDRE eine 1 und ansonsten lauter 0-en enthält hast du richtig 
verstanden.
Auch dass diese Maske zusammen mit dem & als Filter benutzt wird um aus 
dem USR Register dieses eine Bit herauszufischen und alle anderen 
definiert auf 0 zu setzen, hast du richtig erkannt

Was du nicht richtig erkannt hast, ist das !
Das ist kein binärer Operator, sondern ein logischer. Aus logisch FALSCH 
wird logisch WAHR und umgekehrt.

Umgangssprachlich bedeutet also
   while (!(USR & (1<<UDRE)))

"wiederhole solange, solange es nicht wahr ist, dass Bit UDRE in USR 
gesetzt ist"

Oder etwas weniger geschwollen:

"solange UDRE in USR nicht gesetzt ist, wiederhole ..."