Wie uint16_t bitweise verarbeiten

[Guenter B. (gbl)]

Hallo,

ich versuche eine uint16_t Variable bitweise abzutasten und über einen 
Port zu einem andern AVR zu senden. Irgendwie passt das ausgegebene 
Bitmuster nicht zu dem was ich erwarte.

Habe ich einen Denkfehler?

Ich vermute den Fehler beim if-Vergleich.
Ich möchte durch den if-Vergleich herausfinden, ob das geweilige Bit in 
der sbyte-Variable gesetzt ist.

void sendebyte(uint16_t sbyte)
  {
  DDRB=0x01; //schaltet den PIN auf Ausgang
  uint16_t Vergleich=32768; //Schiebevariable auf Bit15 setzen
  uint8_t BitCount = 0;
  for (BitCount=0;BitCount<16;BitCount++)
    {
      if(Vergleich&sbyte)
        puls(); //sendet langen Impuls
      else
        pause(); //sendet kurzen Impuls
    Vergleich=Vergleich/2; //schiebt das Bit das nächste Bit
    }
  DDRB=0x00; //schaltet den PIN wieder auf Eingang
  }

[Rufus Τ. F. (rufus)]

Nö, das ist soweit korrekt.

Allerdings kann man das auch ein bisschen anders schreiben:

uint16_t Vergleich = 1 << 15;
uint8_t BitCount = 0;

for (BitCount = 0; BitCount < 16; BitCount++)
{
  if (Vergleich & sbyte)
    puls(); //sendet langen Impuls
  else
    pause(); //sendet kurzen Impuls
  Vergleich >>= 1;
}

Inhaltlich ist das aber exakt das gleiche, es wird nacheinander Bit 15 
bis Bit 0 von "sbyte" untersucht und entsprechend "puls" oder "pause" 
aufgerufen.

Nur am Rande:
Der Variablenname "sbyte" ist ungeschickt gewählt.

[Guenter B. (gbl)]

Denkfehler meinerseits:

Der Wert wird korrekt ausgegeben.
Nur ich Depp habe ihn falsch ins Binärformat umgerechnet und somit etwas 
anderes erwartet.

Danke für die schnelle Antwort und die Tipps zur Schreibweise.

Gruß

Günter

[W.S. (Gast)]

Rufus Τ. Firefly schrieb:
> Allerdings kann man das auch ein bisschen anders schreiben:

Seh ich auch so:

Vergleich = 1<<15;
while (Vergleich)
{ if (Vergleich & sbyte)
    puls(); //sendet langen Impuls
  else
    pause(); //sendet kurzen Impuls
  Vergleich >>= 1;
}


Oder?

Nebenbei kann ich sowas leiden wie die Pest:
Rufus Τ. Firefly schrieb:
> uint16_t Vergleich = 1 << 15;

Schreib lieber
uint16_t Vergleich;

...
 Vergleich = 1<<15;
 while (....

Glaub's mir, der Compiler macht schon das Richtige draus, ohne daß es im 
Code aufträgt. Es ist ne Sache der Vermeidung von Schusselfehlern, 
direkt vor der Verwendung seine Schleifenvariable zu setzen, weil man 
sonst gar zu häufig bei etwas längeren Funktionen selbiges vergißt (Ich 
hab's ja ganz oben schon gemacht..)


W.S.

[Roland (Gast)]

Mit Atmel habe ich nix am Hut, aber im Prinzip würde ich so vorgehen:

for (i=0;i<16; i++)
{
  Portpin = 0;
  pause (Zeit nach Wunsch)
  Portpin = Variable & 0x0001;
  Variable>>1;
  pause (Zeit nach Wunsch - 2 OPs)
}

Das ganze geht natürlich auch MSB first:

...
  Portpin = Variable & 0x800;
  Variable <<1;
...

Sauberer ist es das Ganze in einen Timer zu schicken, welcher exakt die 
Flanken generiert.

[Roland (Gast)]

Ups. Fehlt ne '0'

Portpin = Variable & 0x8000;

[Simon S. (-schumi-)]

Ich würds so machen:

for(int8_t i=15; i>=0; i-=1)
  (sbyte & (1<<i)) ? puls() : pause();

Ich weis, dass viele Leute das ? nicht so toll finden, aber ich finde es 
bei sehr kurzen Codesequenzen übersichtlicher als auf vier Zeilen 
gestreckt.

Und wer kein >=c99 verwendet, muss das int8_t vor die for-schleife 
setzen.


W.S. schrieb:
> sowas leiden wie die Pest:
> Rufus Τ. Firefly schrieb:
>> uint16_t Vergleich = 1 << 15;
>
> Schreib lieber
> uint16_t Vergleich;
>
> ...
>  Vergleich = 1<<15;
>  while (....
Genau das versuche ich zu vermeiden, da man sonst möglicherweise 
ausversehen die Variable benutzt bevor man sie initialisiert hat. Und je 
nach dem was vorher im RAM stand, bekommt man schwer reproduzierbare 
Ergebnisse.

> Es ist ne Sache der Vermeidung von Schusselfehlern,
> direkt vor der Verwendung seine Schleifenvariable zu setzen, weil man
> sonst gar zu häufig bei etwas längeren Funktionen selbiges vergißt (Ich
> hab's ja ganz oben schon gemacht..)
Ich deklariere meine Variablen erst dort, wo ich sie benötige, 
idealerweise im Schleifenkopf selbst. Nervt, wenn man wieder zum 
Funktionsanfang scrollen muss, nur um nachzusehen, ob die Variable jetzt 
ein int8_t oder ein uint8_t war. Und schön aussehen tut so ein 
Variablenblob am Anfang auch nicht.

[Helmut L. (helmi1)]

Simon S. schrieb:
> Genau das versuche ich zu vermeiden, da man sonst möglicherweise
> ausversehen die Variable benutzt bevor man sie initialisiert hat. Und je
> nach dem was vorher im RAM stand, bekommt man schwer reproduzierbare
> Ergebnisse.

Das sollte ein vernueftiger Compiler schon anmeckern.

[Marius W. (mw1987)]

Simon S. schrieb:
> Ich würds so machen:for(int8_t i=15; i>=0; i-=1)
>   (sbyte & (1<<i)) ? puls() : pause();
> Ich weis, dass viele Leute das ? nicht so toll finden, aber ich finde es
> bei sehr kurzen Codesequenzen übersichtlicher als auf vier Zeilen
> gestreckt.

Ist ganz nett, aber man muss sich bewusst sein, dass der erzeugte Code 
je nach Architektur nicht unbedingt ideal wird. Auf einem AVR wird das 
(1 << i) mangels Barrel-Shifters nicht unbedingt performant.

Gruß
Marius

[Peter D. (peda)]

Ich würds so schreiben:

void sendebyte( uint16_t val )
{
  DDRB=0x01; //schaltet den PIN auf Ausgang
  for( uint8_t i = 16; i--; val <= 1 )
    val & 1<<15 ? puls() : pause();
  DDRB=0x00; //schaltet den PIN wieder auf Eingang
}

[Johann L. (gjlayde)]

Peter Dannegger schrieb:
>   for( uint8_t i = 16; i--; val <= 1 )
______________________________^^^^^^^^
val <<= 1