Anfängerquellcode zum Thema Array

[Jeti]

Hallo an alle!

Ich habe mich mal wieder vor meine kleine Platine gesetzt und wollte mir zur Übung und zum verdeutlichen ein kleines Programm mit Array´s schreiben. Ziel des Programmes PortA als Eingang des IC in ein Array zu quetschen und das dann mit einem vorgegebenen Array zu vergleichen. Stimmen die beiden Arrays überein sollen 8 LED´s die am PortB sind blinken.

Leider tut sich gar nichts und ich bin mir nicht sicher wo der Fehler liegt. Ich habe jetzt schon eine ganze Weile rumprobiert aber es will nicht wirklich klappen. Ich kopiere hier mal den Code. Ich bin mir sicher das das für jeden anderen voll Offensichtlich ist warum das nicht funktionieren will .

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
#include <avr/io.h>
#include <util/delay.h>




int main(void)
{    
    
    #define Ausgang DDRB
    #define Eingang DDRA
    #define LED1 PB0
    #define LED2 PB1
    #define LED3 PB2
    #define LED4 PB3
    #define LED5 PB4
    #define LED6 PB5
    #define LED7 PB6
    #define LED8 PB7
    #define LEDS PORTB
    int n;
    
    Ausgang=0xFF;
    Eingang=0x0;
    
    LEDS=0b11111111;
    
    int v[8];
    v[0]=1;
    v[1]=0;
    v[2]=1;
    v[3]=0;
    v[4]=1;
    v[5]=0;
    v[6]=1;
    v[7]=0;
    int p[8];
    int x;
    int z;
    
    while(1)
    {    
        z=0;
        for (x=0; x<8;x++){
            p[x]=PINA&(1<<(PINA+x));
        }

        for (n=0; n<8; n++){    
            if(v[n]==p[n]){
                z++;
            }
            if (z==7)
            {    LEDS=0b11111111;
                _delay_ms(1000);
                LEDS=0b00000000;
                _delay_ms(1000);
            }
            else
            LEDS=0b00000000;       
        }
    }            
}
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Gruß und vielen Lieben Dank
Jeti

[ichbinsisyphos]

Erstens wirds dich vielleicht freuen, dass man arrays so initialisieren kann:

int v[8] = {1,0,1,0,1,0,1,0};

Ich erkenn keine sonstigen offensichtlichen Fehler, aber was tut das hier?

p[x]=PINA&(1<<(PINA+x));

PINA ist entweder 0 oder 1? dann wird die Zahl 1 um Eingang plus den Zähler (zw 0 und 8 ) linksverschoben, in welchem Fall sollte das gleich dem Eingang zwischen 0 und 1 sein können?

[Jeti]

das mit dem Arrays initialisieren ist gut . Dann kann ich mir das nächstes mal Sparen.

Das
p[x]=PINA&(1<<(PINA+x));
soll eigentlich nacheinander jeden einzelnen Pin von PortA abfragen und den dann in ein weiteres Array speichern. Also beim ersten schleifendurchlauf soll quasi
p[0]=PINA&(1<<(PINA0)); sein, das also der Wert von PINA0 ins Array gespeichert wird.

Ist da ein Denkfehler dabei?

Gruß

[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.