Snake Projekt: Matrixansteuerung

[Jan S. (spongebob)]

Moin!
Ich habe mal wieder ein Problem.
Ich bin dabei ein Snake-Spiel zu programmieren.
Dazu habe ich eine LED-Tafel mit 8x16 LEDs aufgebaut.
Die 8 Zeilen werden nacheinander gezeitmultiplext. Dies Multiplexen habe 
ich schon bei verschiedenen Frequenzen versucht.
Vom ding her funktioniert es auch. Wenn ich nun jedoch auf die einzelnen 
Spalten verschiedene LEDs leuchten lassen möchte passiert es mit immer, 
das sich das auf die anderen Zeilen mit auswirkt.
Im folgenden Beispiel versuche ich in der 4. Zeile 8 LEDs leuchten zu 
lassen.
Dabei passiert es jedoch, das die LEDs der anderen Spalten auch dunkel 
leuchten.

volatile int8_t zeile = 0;

/* Interrupt Service Routines (ISRs) */

ISR(TIMER0_COMP_vect)  //Interruptfrequency: 64kHz -> 8kHz pro Zeile 
{
  MUXPORT = zeile;  

    zeile++;
  
  if(zeile == 8)
    zeile = 0;
}    

int main(void)
{
  DDRA = 0xff;
  DDRB = 0x07;
  DDRC = 0xff;
  
  MUXPORT = 0x00;
  
  init_tmr();
  init_intr();
  
  sei();
  
    while(1)
    {
      if (MUXPORT = 0x03)
        PORTC = 0xff;
      else
        PORTC = 0x00;
  }
}

Wenn ich die if-Abfrage in meinem Timer-Interrupt mache funktioniert 
alles.
Aber es muss doch eine Möglichkeit geben Funktionen zu schreiben, die im 
Hauptprogramm verwendet werden können. Sonst ist das ja alles ein 
bisschen unflexibel.

Hoffe es hat jemand einen Tipp, wie ich vorgehen kann. Vielleicht ist ja 
auch schon meine Grundidee fürn A...

Bin für jede Anregung dankbar.

Grüße Jan

[Karl H. (kbuchegg)]

Jan S. schrieb:


> Wenn ich die if-Abfrage in meinem Timer-Interrupt mache funktioniert
> alles.

und dort gehört sie auch hin.

> Aber es muss doch eine Möglichkeit geben Funktionen zu schreiben, die im
> Hauptprogramm verwendet werden können. Sonst ist das ja alles ein
> bisschen unflexibel.

Was dir noch fehlt ist ein Array als Speicherfläche, welches gegenüber 
deinem Hauptprogramm das Display darstellt.
Innerhalb der ISR wird die Hardware aus diesem Array 'gefüttert'.
Und dein Hauptprogramm schaltet eine LED ein/aus, indem es in besagtem 
Array die entsprechenden Bits setzt oder löscht.

[Karl H. (kbuchegg)]

> Dazu habe ich eine LED-Tafel mit 8x16 LEDs aufgebaut.

Wie ist das Hardwaremässig ausgeführt?
Du brauchst an deinem MUXPORT eine Möglichkeit, wie du KEINE Zeile 
leuchten lassen kannst. Das ist dann die erste Aktion innerhalb der ISR: 
die Zeilentreiber abschalten, so dass nichts leuchtet, nichts leuchten 
kann. Egal was du am Port C machst.

Im Prinzip so

volatile uint8_t Pixel[8];    // 8 Zeilen mit jeweils 8 Pixel
uint8_t  zeile;

ISR( ... )
{
  MUXPORT .... alles abschalten

  zeile++;
  if( zeile == 8 )
    zeile = 0;

  PORTC = Pixel[zeile];
  MUXPORT = zeile;
}

void setPixel( uint8_t x, uint8_t y )
{
  Pixel[y] |= ( 1 << x );
}

void clrPixel( uint8_t x, uint8_t y )
{
  Pixel[y] &= ~( 1 << x );
}

void togglePixel( uint8_t x, uint8_t y )
{
  Pixel[y] ^= ( 1 << x );
}


int main()
{
  ...

  for( i = 0; i < 8; ++i )
  {
    setPixel( 0, i );
    _delay_ms( 100 );
  }

  while( 1 )
  {
    for( i = 0; i < 8; ++i )
    {
      togglePixel( i, i );
      _delay_ms( 100 );
    }
  }
}

[Jan S. (spongebob)]

Karl Heinz Buchegger schrieb:
> Was dir noch fehlt ist ein Array als Speicherfläche, welches gegenüber
> deinem Hauptprogramm das Display darstellt.

Das ich auf sowas nicht von selbst komme...
Jetzt funktioniert alles.
Ich habe jetzt ein Array Angelegt, welches werte für die einzelnen 
Zeilen aufnehmen kann.


Mein Code sieht jetzt wie folgt aus:

volatile int8_t zeile = 0;
int16_t matrix[8];

/* Interrupt Service Routines (ISRs) */

ISR(TIMER0_COMP_vect)  //Interruptfrequency: 4MHz 
{  
  MUXPORT = zeile;

  PORTC = matrix[zeile];
  PORTA = (matrix[zeile]>>8);
  
  zeile++;
  
  if(zeile == 8)
    zeile = 0;
}    

int main(void)
{
  DDRA = 0xff;
  DDRB = 0x07;
  DDRC = 0xff;
  
  matrix[ A ] = 0b1110011111011111;
  matrix[ B ] = 0b1001010000010000;
  matrix[ C ] = 0b1001010000010000;
  matrix[ D ] = 0b1001011110011110;
  matrix[ E ] = 0b1001010000010000;
  matrix[ F ] = 0b1001010000010000;
  matrix[ G ] = 0b1001010000010000;
  matrix[ H ] = 0b1110011111011111;
  
  MUXPORT = 0x00;
  
  init_tmr();
  init_intr();
  
  sei();
  
    while(1)
    {

  }
}

keine Angst die "0b000..." geschichten sind nur für die ersten 
Testzwecke.
Wird alles noch hübsch gemacht.
Jetzt kann man ja für alle möglichen dinge funktionen schreiben, welche 
das Array manipulieren.
Das leichte leuchten von einigen umliegenden LEDs ist jetzt so gut wie 
weg. warum das immer noch teilweise entsteht ist mir noch nicht wirklich 
klar.

Karl Heinz Buchegger schrieb:
> Du brauchst an deinem MUXPORT eine Möglichkeit, wie du KEINE Zeile
> leuchten lassen kannst.

Keine Zeile leuchten lassen tue ich einfach indem ich für die zeilen die 
Spalten-Bits auf null setze.

Die Ansteuerung läuft wie folgt.
mit einem Logic Baustein (74237) lasse ich nacheinander die Kathoden der 
LED-Zeilen per Transistor auf Masse ziehen. Die Anoden werden über zwei 
PORT Register gesetzt oder halt nicht.

Danke für die Tipps!!! Hat echt geholfen. Aber ich denke es ist nur eine 
Frage der Zeit wann Ihr wieder was von mir hört ;-)

Grüße Jan

[Karl H. (kbuchegg)]

Jan S. schrieb:


> Das leichte leuchten von einigen umliegenden LEDs ist jetzt so gut wie
> weg. warum das immer noch teilweise entsteht ist mir noch nicht wirklich
> klar.

Weil du hier

ISR(TIMER0_COMP_vect)  //Interruptfrequency: 4MHz 
{  
  MUXPORT = zeile;

  PORTC = matrix[zeile];
  PORTA = (matrix[zeile]>>8);

durch die Zuweisung an MUXPORT die aktuelle Belegung von PORTC und PORTA 
kurzzeitig bereits an die nächste Zeile ausgibst. Du änderst zwar danach 
gleich PORTC und PORTA auf das, was in dieser Zeile angezeigt werden 
soll, aber ein paar µs lang leuchtet da das Muster aus der 
vorhergehenden Zeile. Und das reicht. Man kann tatsächlich derartig 
kurze Zeiten sehen!

Du musst also dafür sorgen, dass zu diesem Zeitpunkt, an dem du die 
nächste zeile aktivierst, garantiert nix mehr leuchtet

> Keine Zeile leuchten lassen tue ich einfach indem ich für die zeilen die
> Spalten-Bits auf null setze.

D.h. wenn du an PORTA bzw. PORTC 0 ausgibst, leuchtet nix?

Dann ist klar, wie der Beginn der ISR aussehen muss

ISR(TIMER0_COMP_vect)  //Interruptfrequency: 4MHz 
{  
  PORTC = 0;
  PORTA = 0;

  MUXPORT = zeile;
  PORTC = matrix[zeile];
  PORTA = (matrix[zeile]>>8);
  ...

WEnn du jetzt am MUXPORT umstellst, leuchtet garantiert nichts mehr. Und 
damit kann es dann auch kein Geisterleuchten mehr geben.

[Karl H. (kbuchegg)]

> ISR(TIMER0_COMP_vect)  //Interruptfrequency: 4MHz

Du hast hier aber nicht wirklich eine Aufruffrequenz von 4Mhz am Timer 
eingestellt. Oder?

1kHz oder 2kHz tuns auch bei einem 8-er Multiplex. Dann kostet dich das 
Multiplexen praktisch gesehen so gut wie keine Rechenzeit.

[Karl H. (kbuchegg)]

> keine Angst die "0b000..." geschichten sind nur für die
> ersten Testzwecke.

:-)
weiß ich doch.
Was ich sagen wollte:
Du machst gute Fortschritte. Es ist schön zu beobachten, wie du deine 
persönlichen Grenzen immer weiter rausschiebst.

[Jan S. (spongebob)]

So, hab das jetzt mal umgebaut mit null-setzen der PORTS und umstellen 
auf 2kHz Interrupt-Frequenz. Kein Geisterleuchten mehr.
Danke fürs Kompliment! Sowas motiviert mich echt sehr!!!

Grüße Jan