c code problem

[jimm (Gast)]

hi
ich programmiere auf ainem atiny proz
ich hab folgenden ausdruck

....

while ((sende_daten(daten) & _BV(3)))
{
;}

....
was bedeutet & _BV(3)
mfg

[Peter (Gast)]

_BV ist bestimmt ein Makro. Schau mal in die Header Files, wie es 
aussieht.

[jimm (Gast)]

und was macht die  & und verknüpfung

[Karl H. (kbuchegg)]

_BV ist ein altes Makro und bedeutet BitValue.

Es geht darum einen Wert zu erhalten, in dem genau ein
bestimmtes Bit gesetzt ist.

Das Makro _BV macht also _BV(3) den binären Wert 0b00000100
also den Wert in dem genau das Bit 3 gesetzt ist und alles
andere 0 ist.

&  ist die binäre UND Operation

  a  b    a und b
  0  0       0
  0  1       0
  1  0       0
  1  1       1

Hinweis: Die C & Operation arbeitet auf alle 8 Bits
gleichzeitig. Jeweils gleichwertige Bits werden mit-
einander UND verknüpft.

In diesem Beispiel wird die Operation benutzt um aus dem
gelesenen Wert das Bit 3 auszumaskieren: Im Ergebnis
ist nur noch der Zustand des Bit 3 relevant. Alle anderen
Bits werden definitiv auf 0 gesetzt.

[jimm (Gast)]

kann ich das aus so schteiben

while ((sende_daten(daten) & 0x03))
{
;}

[JojoS (Gast)]

nein, 0x3 ist 0b00000011 und _BV(3) ist 0b00001000

[jimm (Gast)]

also ich hab das mal so ausprobiert

while ((sende_daten(daten) & 0x03))
{
;}
und bekomme dann nur noch datenmüll
wo kann man das makro eventuell finden
ich muss das ganze auf nen msp430
zum laufen bringen und der
kennt das _BV nicht
mfg

[Karl H. (kbuchegg)]

Nein.

Schreib es dir binär auf:

  0x03   =     0b00000011

  _BV(3) =     0b00000100

Das ist eine gänzlich andere Zahl.

  _BV(3) = 0x04

also
  while ( sende_daten(daten) & 0x04 )

oder

  while ( sende_daten(daten) & ( 1 << 3 ) )

oder eben
  while ( sende_daten(daten) & _BV(3) )


PS: Lerne die 2-er Potenzen auswendig. Wenn du µC programmieren
willst ist das unumgänglich:

              dezimal    hex
  2 hoch 0       1       0x01
  2 hoch 1       2       0x02
     "   2       4       0x04
     "   3       8       0x08
     "   4      16       0x10
     "   5      32       0x20
     "   6      64       0x40
     "   7     128       0x80

[Martin (Gast)]

So kannst dus zB machen:

#define _BV(x)   (1 << x)

[jimm (Gast)]

hi
ich hab jetzt
folgendes eingegeben
und nu geht es
hile ((sende_daten(daten) & 0x08))
{
;}

aber wieso es nun so geht und nicht anders weis ich immer noch net?

[Karl H. (kbuchegg)]

Weil ich einen Fehler gemacht habe:

_BV(3) = 0x08  = 0b00001000

Zähl die Bits von rechts beginnend: 0, 1, 2, 3
und dort muss jetzt eine 1 sein.

Mein PS. von weiter oben gilt immer noch

PS: Lerne die 2-er Potenzen auswendig. Wenn du µC programmieren
willst ist das unumgänglich:

              dezimal    hex      binär
  2 hoch 0       1       0x01     0b00000001
  2 hoch 1       2       0x02     0b00000010
     "   2       4       0x04     0b00000100
     "   3       8       0x08     0b00001000
     "   4      16       0x10     0b00010000
     "   5      32       0x20     0b00100000
     "   6      64       0x40     0b01000000
     "   7     128       0x80     0b10000000

[Hegy (Gast)]

> aber wieso es nun so geht und nicht anders weis ich immer noch net?

deine Schleife in Kurzform sieht so aus:

while((sende_daten(daten) & 0x08))
 ;

Es heißt nix anderes, daß es eine Endlosschleife ist, solange der 
Rückgabewert der Funktion sende_daten(daten) "verundet" mit 0x08 = 1 
ist. Irgendwann wird die Fkt. sende_daten() mit der Übertragung fertig 
sein und dann ist die log. Verknüpfung = 0 und die while-Schleife wird 
beendet.

Anders und ausführlich geschrieben

unsigned short i = 1;

while(i == 1)
{
  i = sende_daten(daten);
  i = i & 0x08;
}

[Simon K. (simon)]

Hegy wrote:
> "verundet" mit 0x08 = 1

Das ist nicht ganz richtig. Anders gesagt: Das kann überhaupt nicht. Das 
niedrigste Bit (was ja den dezimalen Wert 1 ausmacht) wird ausmaskiert.

Richtiger wäre hier:

"verundet" mit 0x08 UNGLEICH 0

[Hegy (Gast)]

.... und da die while-Schleife nur 0 oder nicht-0 kennt würde es 
zum_Verständnis eigentlich passen/reichen. Mir ging es nur darum. Im 
Ursprungstext hatte ich noch die Def's TRUE und FALSE drin, aber um 
nicht zuviel Verwirrung zu stiften habbichs dann weggelassen. Also Fkt() 
& 0x08 = TRUE -> Schleife, Fkt() & 0x08 = FALSE -> Schleife verlassen. 
Wobei die while-Schleife nicht kukkt, ob nun 1 oder 8 als Wert in der 
Klammer steht. Es wir ja nur auf 0 oder nicht-0 verglichen.

Ja, while-Schleifen können kukken :)

[Simon K. (simon)]

Hegy wrote:
> .... und da die while-Schleife nur 0 oder nicht-0 kennt würde es

Das ist quatsch.

while((something & 0x08) == 1)
{...}

wäre zum Beispiel dein obiger Satz. Und diese Bedingung kann einfach 
nicht zutreffen.

> Wobei die while-Schleife nicht kukkt, ob nun 1 oder 8 als Wert in der
> Klammer steht. Es wir ja nur auf 0 oder nicht-0 verglichen.

Das macht sie nur wenn du keinen Vergleichsoperator einbeziehst.

PS: Mit TRUE und FALSE bzw. WAHR und FALSCH gebe ich mich geschlagen ;)