Hallo,
ich habe das Versuchsboard MK2 von Atmel mit dem Atmega 8.
Ich wollte eine Steuerung zur Dimmung, Farbwechsel für LED's machen. Hab 
das eigentlich schon fertig. Nun ist mir aber ein Fehler aufgefallen.
Ich habe 2 Rastschalter die die Dualzahlen 0-9 abdecken. also alles von 
0000 bis 1001. Davon habe ich 2 stück. Einer läuft auf den D-Ports der 
andere auf den B-Ports. Das C-Register ist als Ausgang definiert. 
Abfagen der Schalterbitkombination mach ich wie folgt:
bsp.

if((PINB&0b00000001 && PIND&0b00001000)==0)

nun hab ich aber auch andere Kombinationen wie:

if((PINB&0b00000011 && PIND&0b00011000)==0)

Sollte nun das 2.te if wahr sein ist auch das erste if wahr, da ja nur 
die 1ser überprüft werden, oder seh ich das falsch? Wenn ja, wie sage 
ich dem Controller das er oben wirklich nur in die IF-Schleife springt, 
wenn an PINB Bit 1 High und Bit 2-7 Low sind.

Danke schonma für die Hilfe

Marcel K. schrieb:
> die IF-Schleife
Ah, ein Klassiker:
http://www.if-schleife.de

Marcel K. schrieb:
> Abfagen der Schalterbitkombination mach ich wie folgt:
>
> if((PINB&0b00000001 && PIND&0b00001000)==0)
> Sollte nun das 2.te if wahr sein ist auch das erste if wahr, da ja
> nur die 1ser überprüft werden, oder seh ich das falsch?
Nein, das stimmt.
> Wenn ja, wie sage ich dem Controller das er oben wirklich nur in die
> IF-Schleife springt, wenn an PINB Bit 1 High und Bit 2-7 Low sind.
Indem du die Nullen auch abfragst, und statt dem Ausmaskieren mit 
einem Wert vergleichst :

uint8_t schalterB, schalterD;


schalterB = PINB&0x0f; // untere 4 Bits einlesen
schalterD = PIND&0x0f;

if (schalterB=1 && schalterD=2) { ... } 

if (schalterB=3 && schalterD=7) { ... } 

Ich würde das aber gleich so machen:

uint8_t schalter;

schalter =  PINB&0x0f;      // Einer-Bits einlesen
schalter += 10*(PIND&0x0f); // Zehner-Bits dazunehmen

if (schalter=12) { ... } 

if (schalter=37) { ... } 

Du musst bei den IFs doppel-istgleichs hinmachen ;-)

Sonst kommt immer überall true raus^^

Simon S. schrieb:
> Du musst bei den IFs doppel-istgleichs hinmachen ;-)
Ach richtig, schlags kaputt...
Zu meiner Entlastung: bei VHDL muss ich das nicht. ;-)

Lothar Miller schrieb:
> uint8_t schalterB, schalterD;
>
> schalterB = PINB&0x0f; // untere 4 Bits einlesen
>
> schalterD = PIND&0x0f;>
>
> if (schalterB=1 && schalterD=2) { ... }
>
> if (schalterB=3 && schalterD=7) { ... }
>
>
> Ich würde das aber gleich so machen:uint8_t schalter;
>
> schalter =  PINB&0x0f;      // Einer-Bits einlesen
>
> schalter += 10*(PIND&0x0f); // Zehner-Bits dazunehmen
>
> if (schalter=12) { ... }
>
> if (schalter=37) { ... }

Danke erstmal für die Superschnellen antworten.
Sollte das funktionieren was ich natürlich hoffe würde ich gerne mehr 
verstehen. Da steht jetzt halt n stück Quelltext, ich werde daraus aber 
nicht schlau. kann mir jemand so bisschen step for step erklären was da 
was ist und was es bedeutet. Bin noch in der Ausbilung. Hoffe ich treffe 
auf verständniss.

mfg marcel

Marcel K. schrieb:
> kann mir jemand so bisschen step for step erklären was da
> was ist und was es bedeutet.
Das steht in jedem noch so gruftigen C-Buch.
Stichwort ist: Bitmanipulation

Aber da kann man gar nicht mal so viel schreiben:

uint8_t schalterB, schalterD;        // zwei Variablen, die die Schalterstellung speichern

                                     // Mit Bitmanipulation die Schalter ausmaskieren
schalterB = PINB&0x0f;               // untere 4 Bits vom Port B einlesen 
schalterD = PIND&0x0f;               // untere 4 Bits vom Port D einlesen

if (schalterB==1 && schalterD==2) {  // Schalter abfragen auf Gleichheit
   ...  
}
if (schalterB==3 && schalterD==7) {
   ...
} 

> Bin noch in der Ausbilung. Hoffe ich treffe auf verständniss.
+d -v +V -s
Mal sehen , ob du das ausknobeln kannst...  ;-)