Anfängerquellcode zum Thema Array

[radbruch]

Hallo

Besser wäre es so:

p[x]=PINA&(1<<x); // für x von 0 bis 7

Die 1 wird x-mal nach links geschoben. Oder noch knapper:

char p, v=0b01010101;

p=PINA;
for (n=0; n<8; n++){
if((v & (1<<n)) == (p & (1<<n)){

Gruß

mic

[ichbinsisyphos]

p[x]=PINA&(1<<x); // für x von 0 bis 7

Dann kommt bei Übereinstimmung 2^x ins array, und nicht 1, oder?

[radbruch]

Stimmt. Dann muss wohl eher sowas formuliert werden:

p[x]=(PINA >> x) & 1;

[Jeti]

ich habe das jetzt mal nachvollzogen und habe meinen Code angepasst und siehe da, schon läufts. Jetzt habe ich mir Gedanken darum gemacht wieso das jetzt läuft.
Stimmt das wenn ich mir das wie folgt vorstelle:

Der Code lautet
for(x=0; x<8; x++
{ p[x]=PINA>>x)&1;
}

PortA sei einfach mal 10101010 und X läuft von 0-7. Verglichen wir das mit der Binärzahl 00000001. Bei x=0 wird PortA nicht verändert. Also vergleiche ich

10101010
00000001
-----------
00000000

Das Ergebnis ist also = und wird als Zahl in p[0] gespeichert. Für die nächste Schleife x=1 wird PortA um 1 Verschoben, es vergleicht also wie folgt:

11010101
00000001
-----------
00000001
und Somit kommt in p[1]=1. Und das geht dann halt bis X=7 so weiter.

Stimmt das? Ich glaube ich muss mir in Zukunft öffter diese bildchen malen, da wird einem doch einiges klarer.

Vielen Dank an alle!

[robocat]

Stimmt so
Ausser dass bei den ANSI-C Compilern, die ich kenne, in beide Richtungen (leftshift "<<" und rightshift ">>") Nullen nachgeschoben werden. In deinem Beispiel wurde ein gesetztes Bit nachgeschoben.

Im Endeffekt wird im µC Maschinencode ein SHL daraus, der Befehl ist hier näher beschrieben:
http://andremueller.gmxhome.de/befehle.html

Für die folgenden Bitschiebebefehle gilt die Annahme, dass das höchstwertige Bit am weitesten links in einem Byte/Word etc steht und die Zählung der Bits mit Null beginnt. Dementsprechend steht in einem Byte das höchstwertige Bit an Position 7, das Bit mit dem geringsten Wert an Position 0.
Beim Befehl SHL werden aus dem ersten Operanden so viele Bits nach links herausgeschoben, wie im zweiten Operanden angegeben. Am rechten Ende werden ebenso viele Bits nachgeschoben, die alle nicht gesetzt sind. Das zuletzt herausgeschobene Bit läßt sich im Carry-Flag finden.