Problem mit einfacher 3x3 Schaltermatrix

[Joachim J (Gast)]

Hallo zusammen,

ich möchte mir ein paar Port PINs sparen und 9 Schalter mit einer 3x3 
Matrix abfragen. Ich habe hier im Forum und im Web auch einige Beispiele 
gefunden und die Matrix entsprechend zusammengelötet. 1N4148 Dioden sind 
in Reihe zu den Schaltern gelötet, keine weiteren Widerstände. Wenn ich 
die Matrix ohne AVR (in diesem Fall ein Mega 8) mit LEDs teste, sieht 
alles richtig aus. Lasse ich den AVR die Matrix auslesen kommt nur 
Blödsinn bei rum.

Wie das Programm arbeitet:
Die 3 Eingänge haben PullUps aktiviert. Die Ausgänge sind anfangs alle 
1. Jetzt wird ein ein Ausgang auf 0 gesetzt. Alle Eingänge, die über 
Schalter mit dem Ausgang verbunden sind, sollen in der Theorie jetzt auf 
0 bzw. GND gezogen werden. In der Praxis bzw. als Ergebnis im Code 
siehts leider anders aus. Wenn ich parallel zu den Ein- und Ausgängen 
LEDs über ULN2803 anschließe, leuchten diese auch wieder richtig. Das 
Ergebnis mit angeschlossenen LEDs sieht auch wieder anders aus als ohne. 
In beiden Fällen aber falsch.

Was kann ich nochmal überprüfen um den Fehler zu finden?

Gruß
Joachim

[Mike (Gast)]

Joachim J schrieb:
> Alle Eingänge, die über Schalter mit dem Ausgang verbunden sind, sollen
> in der Theorie jetzt auf 0 bzw. GND gezogen werden. In der Praxis bzw.
> als Ergebnis im Code siehts leider anders aus.

Dann ist entweder an der Theorie praktisch etwas falsch oder 
Schaltplan/Programm setzen das gewünschte theoretische Verhalten nicht 
richtig in die Praxis um.

Kurz: Zeige deinen Schaltplan und dein Programm

[Max H. (hartl192)]

Hat es vllt. etwas mit dem Prellen der Tasten zu tun?

[Joachim J (Gast)]

Deinem Wunsch komme ich sofort nach :-)

Initialisierung der Schalter:

//Ausgänge für DIP Schalter Matrix
DDRD |=(1<<DDD2)|(1<<DDD3)|(1<<DDD4);        
//Eingänge für DIP Schalter Matrix
DDRD &=~((1<<DDD5)|(1<<DDD6)|(1<<DDD7));      
//Pull-Ups an Port D5 bis D7 aktivieren
PORTD |= (1<<PD5)|(1<<PD6)|(1<<PD7);        
//Ausgänge auf 1 setzen, Abfrage der Schalter ist invertiert
PORTD |= (1<<PD2)|(1<<PD3)|(1<<PD4);

Abfrage der Schalter:

PORTD |= ((1<<PD2)|(1<<PD3)|(1<<PD4));//Ausgänge auf High

//-------- ersten 3 bits --------
PORTD &= ~(1<<PD2); //Ausgang PD2, für die ersten 3 bits auf low

Pin_status = bit_is_set(PIND, 5) ? 0 : 1; 
temp_DMXadress|=(Pin_status<<0);

Pin_status = bit_is_set(PIND, 6) ? 0 : 1; 
temp_DMXadress|=(Pin_status<<1);

Pin_status = bit_is_set(PIND, 7) ? 0 : 1; 
temp_DMXadress|=(Pin_status<<2);

//-------- zweiten 3 bits --------
PORTD |= ((1<<PD2)|(1<<PD3)|(1<<PD4));//Ausgänge auf High
PORTD&=~(1<<PD3);
Pin_status = bit_is_set(PIND, 5) ? 0 : 1;
temp_DMXadress|=(Pin_status<<3);

Pin_status = bit_is_set(PIND, 6) ? 0 : 1;
temp_DMXadress|=(Pin_status<<4);
  
Pin_status = bit_is_set(PIND, 7) ? 0 : 1;
temp_DMXadress|=(Pin_status<<5);


//-------- dritten 3 bits, zu Testzwecken 9. weggelassen --------
PORTD |= ((1<<PD2)|(1<<PD3)|(1<<PD4));//Ausgänge auf High
PORTD&=~(1<<PD4);

Pin_status = bit_is_set(PIND, 5) ? 0 : 1;
temp_DMXadress|=(Pin_status<<6);
  
Pin_status = bit_is_set(PIND, 6) ? 0 : 1;
temp_DMXadress|=(Pin_status<<7);

Gruß
Joachim

[Joachim J (Gast)]

Zum Thema prellen: Die Schalter "lege ich einmal um" und dann wars das. 
Prellen kann man hier vernachlässigen.

[Tlol (Gast)]

Joachim J schrieb:
>

> //Ausgänge auf 1 setzen, Abfrage der Schalter ist invertiert
> PORTD |= (1<<PD2)|(1<<PD3)|(1<<PD4);
>

Kommentar erzeugt Endlosschleife bei mir.

Code ist nicht komplett.

[Joachim J (Gast)]

Hallo,

was genau meinst du mit "Kommentar erzeugt Endlosschleife bei mir." ?

Der Code der Abfrage liegt in read_dips(), der Rest in der Main. Ich 
habe mir die Ergebnisse dann per RS232 ausgegeben.

Gruß
Joachim

[Peter D. (peda)]

Joachim J schrieb:
> Pin_status = bit_is_set(PIND, 5) ? 0 : 1;
> temp_DMXadress|=(Pin_status<<0);
>
> Pin_status = bit_is_set(PIND, 6) ? 0 : 1;
> temp_DMXadress|=(Pin_status<<1);
>
> Pin_status = bit_is_set(PIND, 7) ? 0 : 1;
> temp_DMXadress|=(Pin_status<<2);

Das ist ja von hinten durch die Brust ins Auge.
Wie wärs einfach mit:

  temp_DMXadress |= 0x07 & (~PIND >> 5);

Und davor natürlich noch mindestens ein NOP, da die Eingänge im 
vorherigen Zyklus gelatcht werden.

[Joachim J (Gast)]

Hallo Peter,

mit einer großzügingen Menge an _delay_ms gehts. :-) Danke!
Die Abfrage geschieht nur einmal und ist alles andere als zeitkritisch.

Kannst du mir vielleicht auch noch etwas näher erklären warum es da 
"klemmt" oder mir sagen wo ich das nachlesen kann? So tief bin ich noch 
nicht in AVR und C und das "latchen" ist mir als Fehler noch nicht 
untergekommen.

Gruß
Joachim

[Uwe (de0508)]

Hallo Joachim,

das "latchen" steht im Datenblatt deines µC, nicht direkt zu finden, 
aber als Anmerkung ist es vorhanden.

Und bedeutet, etwas salopp geschrieben: eine Portänderung, z.B. PullUP 
"on", dauert länger, als bis zum Ende des Befehls.

[H.Joachim S. (crazyhorse)]

9 Taster bekommt man auch an einem einzigen Analogeingang sauber 
ausgewertet.
Nachteil: man braucht auch 9 Widerstände.

[Elekto Nick (Gast)]

Könntest Du erklären, wie das geht?
Danke

[oldmax (Gast)]

Hi
Nun, es ist nicht selten der Fall, das die negative Logik durch die 
0-Abfrage bedingt durch den Pullup etwas Verwirrung bringt.Aus diesem 
Grund lege ich Eingänge immer in logischer Lage zum Schalter in 
Variablen ab. treu nach dem EVA-Prinzip. Einlesen - Verarbeiten - 
Ausgeben. Da ich C nicht beherrsche, versuche ich es einfach mal zu 
erläutern. Du selektierst Reihe 1 durch Ausgabe einer 0. Anschließend 
liest du deie Eingänge ein, drehst die Bits, maskierst die relevanten 
Bits aus und legst das Ergebnis in Variable Input_1 ab. In Asembler in 
etwas so:

Read_IO:
  In     r16, PortD
  ORI    r16, 0b00011100   ; Alle Reihen auf "1"
  ANDI   r16, 0b11111011   ; selektiere Reihe 1
  OUT    PortD, r16
  In     r16, PortD     ; Eingänge lesen
  COM    r16
  ANDI   r16, 0b11100000   ; Eingänge ausmaskieren
  ROR    r16
  SWAP   r16               ; Eingänge auf bits 0 bis 2 schieben
  STS    Input_1, r16      ; und in Variable Input_1 ablegen
  In     r16, PortD
  ORI    r16, 0b00011100   ; Alle Reihen auf "1"
  ANDI   r16, 0b11110111   ; selektiere Reihe 2
  OUT    PortD, r16
  In     r16, PortD     ; Eingänge lesen
  COM    r16
  ANDI   r16, 0b11100000   ; Eingänge ausmaskieren
  ROR    r16
  SWAP   r16               ; Eingänge auf bits 0 bis 2 schieben
  STS    Input_2, r16      ; und in Variable Input_2 ablegen
  In     r16, PortD
  ORI    r16, 0b00011100   ; Alle Reihen auf "1"
  ANDI   r16, 0b11101111  ; selektiere Reihe 3
  OUT    PortD, r16
  In     r16, PortD     ; Eingänge lesen
  COM    r16
  ANDI   r16, 0b11100000   ; Eingänge ausmaskieren
  ROR    r16
  SWAP   r16               ; Eingänge auf bits 0 bis 2 schieben
  STS    Input_3, r16      ; und in Variable Input_3 ablegen
RET

Sieht zwar gewaltig aus, ist es aber nicht. Ich habe nun das tganze 
Programm, um den Inhalt von Input 1-3 auszuwerten und genau nach der 
Logik: Ist ein Taster gedrückt, dann ist das Bit "1". Bei einer 
Taktfrequenz von 1 MHz braucht diese Routine rd. 30 µs. Noch eine 
Bemerkung zur Entprellung. Da in den Variablen Input_1 bis Input_3 die 
aktuellen Eingänge liegen, kannst du mit einem EOR (Exclusiv-Oder) und 
einem alten Wert feststellen, ob eine Änderung eingetreten ist, oder ob 
die Eingänge eine Zeitlang stabil waren

Debounce_IO:
  LDS   r16, Input_1    ; Akt. Eingänge
  LDS   r17, Old_In_1   ; Stand beim letzten Durchlauf
  EOR   r17, r16        ; Ergebnis in r17
  BREQ  Chk_Time        ; ist gleich,  Entprellzeit prüfen, evtl.reduzieren
  STS   Old_In_1, r16   ; aktuelle Eingänge ablegen
  LDS   r17, 50         ; Entprellzeit neu setzen
  STS   Deb_Time_1, r17 ; und merken
  RJMP  Row_2
  LDS   r17, Deb_Time_1 ; Restzeit laden
  CPI   r17, 0          ; schon abgelaufen?
  BREQ  Row_2
  DEC   r17             ; Zeit reduzieren
  STS   Deb_Time_1, r17 ; und merken
  BRNE  BREQ            ; Zeit nicht abgelaufen, dann weiter
  STS   Akt_In_1, r16   ; r16 hat noch den gültigen Wert der Eingänge
Row_2:                  ; nächste Reihe prüfen und entprellen
  ....
Row_3:
  ....
RET

Auch hierist genau berechenbar, wie lange die Entprellroutine bei einem 
Durchlauf braucht. Etwa 60 µs.
Die Bits in akt_In_x sind nun entprellte gültige Signale. Sicherlich 
wird es dir keine große Mühen machen, diese Programmteile in C 
nachzubauen.
Gruß oldmax