Code Ansteuerung LED Matrix mit TPIC-6B595

[Roy B. (roy_b)]

Hallo,

ich sitze gerade über dem Code für die Ansteuerung einer LED Matrix.
Deren Spalten hängen an 3 aufgereiten TPIC-6B595 Schieberegistern und 5 
Zeilen werden jeweils über einen PNP Gen VCC gezogen.

Die Hardware funktioniert soweit ich es sagen kann. Das heißt wenn ich 
gemütlich im Code ein Bit Ausgebe und es dann durchschiebe, kann ich 
jede LED einzeln ansteuern.

Da nun aber das normale shiftOut der Arduino IDE recht langsem ist und 
die LEDs dadurch stark flackern, habe ich versucht einen schnelleren 
Coder zu verwenden und gleich auf die Matrix zu zuschneiden.

angelehnt an den Beitrag sus dem Arduinoforum
http://forum.arduino.cc/index.php?topic=181577.15

Fom Prinzip her scheint es zu funktionieren, es gibt nur ein mir 
unerklärliches Phänomen. Egal welches Bit in der Matrix gesetzt werden 
soll, augegeben wird immer dieses Bit und zusätzlich noch das gleiche 
Bit in den nächsten 2 Byte. Das ganze nicht nur innerhald einer Zeile, 
sondern auch Zeilenübergreifend.

Wenn ich mir jetzt mit dem Oszi die Daten und Clock Signale anschaue, 
sehen die sehr gut aus. Das Bitmuster passt. die Pegel sind nicht 
verwaschen.
Die Schieberegister geben auch glatte Pegel aus und die zusätzlich 
leuchtenden werden auch wirklich vom Schieberegister angesteuert, dass 
heißt, wenn ich an deren Ausgängen alles abziehe, zum Messen einen Pull 
Up mit ran halte, kommen saubere Pegel raus.
Ich kann mir das einfach nicht erklären.

Also der Code mit normal shiftOut funktioniert:

const int TastH = 17;       //Taster für Stunden
const int TastM = 16;       //Taster für Minuten
const int TastS = 15;       //Taster für Set
const int UHRSCL = 19;      //SCL zur Realtime Clock
const int UHRSDA = 18;      //SDA zur Realtime Clock
const int BRT = 14;         //Analog A0 für Helligkeitssensor
const int CKCLK = 2;        //Clock eingang von der Realtime Clock
const int dataPin = 11;  //Serial Daten Pin
const int LEDOE = 6;        //Output Enable der Schieberegister
const int clockPin = 13;      //Clock für Schieberegister
const int latchPin = 5;        //Letch enable für die Schieberegister
const int CSEL1 = 4;        //Reihe 1
const int CSEL2 = 7;        //Reihe 2
const int CSEL3 = 8;        //Reihe 3
const int CSEL4 = 9;        //Reihe 4
const int CSEL5 = 10;       //Reihe 5
const int DCF = 3;          //Pin für DCF Signal

byte LEDArray[5][3] = {
  {
    B10000000,
    B00000000,
    B00000000
  },
  {
    B00000000,
    B00000000,
    B00000000
  },
  {
    B00000000,
    B00000000,
    B00000000
  },
  {
    B00000000,
    B00000000,
    B00000000
  },
  {
    B00000000,
    B00000000,
    B00000000
  }
};

void setup() {
 
  pinMode(latchPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(LEDOE, OUTPUT);
  pinMode(CSEL1, OUTPUT);
  pinMode(CSEL2, OUTPUT);
  pinMode(CSEL3, OUTPUT);
  pinMode(CSEL4, OUTPUT);
  pinMode(CSEL5, OUTPUT);
}

void loop() {
  for (int i=0; i<5; i++){
    for (int j=0; j<3; j++){
      shiftOut(dataPin, clockPin, LSBFIRST, LEDArray [i][j]);
    }
    digitalWrite(LEDOE, HIGH);
    switch(i){
      case 0: digitalWrite(CSEL1, HIGH); digitalWrite(CSEL5, LOW); break;
      case 1: digitalWrite(CSEL2, HIGH); digitalWrite(CSEL1, LOW); break;
      case 2: digitalWrite(CSEL3, HIGH); digitalWrite(CSEL2, LOW); break;
      case 3: digitalWrite(CSEL4, HIGH); digitalWrite(CSEL3, LOW); break;
      case 4: digitalWrite(CSEL5, HIGH); digitalWrite(CSEL4, LOW); break;
    }
    digitalWrite(latchPin, LOW);
    digitalWrite(latchPin, HIGH);
    digitalWrite(LEDOE, LOW);
  }
}

Der schnellere nicht:

#define BitMaskCLK 0b00100000  //pin 13 = Clock Pin; Pin 13 ist bit 5 von Port B
#define BitMaskDAT 0b00001000  //pin 11 = Data Pin; Pin 11 ist bit 3 von Port B
#define BitMaskLAT 0b00100000  //pin 5 = Data Pin; Pin 5 ist bit 5 von Port D
#define BitMaskOE 0b01000000   //pin 6 = Data Pin; Pin 6 ist bit 6 von Port D
#define BitMaskR1 0b00010000   //pin 4 = Data Pin; Pin 4 ist bit 4 von Port D
#define BitMaskR2 0b10000000   //pin 7 = Data Pin; Pin 7 ist bit 7 von Port D
#define BitMaskR3 0b00000001   //pin 8 = Data Pin; Pin 8 ist bit 0 von Port B
#define BitMaskR4 0b00000010   //pin 9 = Data Pin; Pin 9 ist bit 1 von Port B
#define BitMaskR5 0b00000100   //pin 10 = Data Pin; Pin 10 ist bit 2 von Port B


const int TastH = 17;       //Taster für Stunden
const int TastM = 16;       //Taster für Minuten
const int TastS = 15;       //Taster für Set
const int UHRSCL = 19;      //SCL zur Realtime Clock
const int UHRSDA = 18;      //SDA zur Realtime Clock
const int BRT = 14;         //Analog A0 für Helligkeitssensor
const int CKCLK = 2;        //Clock eingang von der Realtime Clock
const int dataPin = 11;  //Serial Daten Pin
const int LEDOE = 6;        //Output Enable der Schieberegister
const int clockPin = 13;      //Clock für Schieberegister
const int latchPin = 5;        //Letch enable für die Schieberegister
const int CSEL1 = 4;        //Reihe 1
const int CSEL2 = 7;        //Reihe 2
const int CSEL3 = 8;        //Reihe 3
const int CSEL4 = 9;        //Reihe 4
const int CSEL5 = 10;       //Reihe 5
const int DCF = 3;          //Pin für DCF Signal

byte LEDArray[5][3] = {
  {
    B00000000,
    B0000000,
    B10000000
  },
  {
    B00000000,
    B00000000,
    B00000000
  },
  {
    B00000000,
    B00000000,
    B00000000
  },
  {
    B00000000,
    B00000000,
    B00000000
  },
  {
    B00000000,
    B00000000,
    B00000000
  }
};
void setup() {
 
  pinMode(latchPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(LEDOE, OUTPUT);
  pinMode(CSEL1, OUTPUT);
  pinMode(CSEL2, OUTPUT);
  pinMode(CSEL3, OUTPUT);
  pinMode(CSEL4, OUTPUT);
  pinMode(CSEL5, OUTPUT);
}

void loop() {
  for (int i=0; i<5; i++){
     for (int j=0; j<3; j++){
      byte bitt = 1;   //Variable die speichert, welches Bit wir gerade rausschreiben. Wir fangen beim LSB an.
      while(bitt) //Wenn wir die "1" 7 mal geschoben haben, ist sie vom LSB zum MSB gewandert. Beim 8. Mal ist das Bit dann links rausgeschoben und die Variable 0. Da 0 = false wird die Schleife abgebrochen
      {
        if (LEDArray[i][j] & bitt)  //ist das aktuelle Bit des herauszuschiebenden Wertes gesetzt?
          PORTB |= BitMaskDAT;   //ja: Datenpin HIGH
        else
          PORTB = (PORTB &~BitMaskDAT);  //nein: Datenpin LOW. "PORT &~BitMaskDAT" gibt alle Pins so zurück wie sie waren, außer der der in BitMaskDat gesetzt ist wird 0.
        bitt <<= 1;  //Schiebe die Merkervariable um eins nach links, jetzt ist das nächste Bit dran.
        PORTB |= BitMaskCLK;  // Clockpin auf High
        PORTB ^= BitMaskCLK;  //Toggle den Clockpin. Da er davor HIGH war, wird er jetzt wieder LOW.

      }
      PORTD |= BitMaskOE;  // OE Pin auf High
      PORTD |= BitMaskLAT;  // Latchpin auf High
      PORTD ^= BitMaskLAT;  //Toggle den Latchpin. Da er davor HIGH war, wird er jetzt wieder LOW.
      switch(i){
      case 0: PORTB = (PORTB &~BitMaskR5); PORTD |= BitMaskR1; break;
      case 1: PORTD = (PORTD &~BitMaskR1); PORTD |= BitMaskR2; break;
      case 2: PORTD = (PORTD &~BitMaskR2); PORTB |= BitMaskR3; break;
      case 3: PORTB = (PORTB &~BitMaskR3); PORTB |= BitMaskR4; break;
      case 4: PORTB = (PORTB &~BitMaskR4); PORTB |= BitMaskR5; break;
      }
      PORTD ^= BitMaskOE;  //Toggle den OE Pin. Da er davor HIGH war, wird er jetzt wieder LOW.
    }
  }
}

[Roy B. (roy_b)]

Manchmal sieht man den Wald vor lauter Bäumen nicht, gerade als ich den 
Code nocheinmal Jemandem erklären wollte ist es mir aufgefallen.
Ich habe die Freigabe an die Pins nach jedem Byte gemacht und nicht 
aller drei Byte. Also die ganze Brühe mit OE und Latch innerhalb der 
Schleife mit j und nicht außerhalb.
Für die Nachwelt, wenn Jemand ein Codebeispiel für eine schnelle 
Serielle Ausgabe sucht:

void loop() {
  for (int i=0; i<5; i++){
    for (int j=0; j<3; j++){
      byte bitt = 1;   //Variable die speichert, welches Bit wir gerade rausschreiben. Wir fangen beim LSB an.
      while(bitt) //Wenn wir die "1" 7 mal geschoben haben, ist sie vom LSB zum MSB gewandert. Beim 8. Mal ist das Bit dann links rausgeschoben und die Variable 0. Da 0 = false wird die Schleife abgebrochen
      {
        if (LEDArray[i][j] & bitt)  //ist das aktuelle Bit des herauszuschiebenden Wertes gesetzt?
          PORTB |= BitMaskDAT;   //ja: Datenpin HIGH
        else
          PORTB = (PORTB &~BitMaskDAT);  //nein: Datenpin LOW. "PORT &~BitMaskDAT" gibt alle Pins so zurück wie sie waren, außer der der in BitMaskDat gesetzt ist wird 0.
        bitt <<= 1;  //Schiebe die Merkervariable um eins nach links, jetzt ist das nächste Bit dran.
        PORTB ^= BitMaskCLK;  // Clockpin auf High
        PORTB ^= BitMaskCLK;  //Toggle den Clockpin. Da er davor HIGH war, wird er jetzt wieder LOW.
      }
    }
    PORTD |= BitMaskOE;  // OE Pin auf High
    PORTD |= BitMaskLAT;  // Latchpin auf High
    switch(i){
      case 0: PORTB = (PORTB &~BitMaskR5); PORTD |= BitMaskR1; break;
      case 1: PORTD = (PORTD &~BitMaskR1); PORTD |= BitMaskR2; break;
      case 2: PORTD = (PORTD &~BitMaskR2); PORTB |= BitMaskR3; break;
      case 3: PORTB = (PORTB &~BitMaskR3); PORTB |= BitMaskR4; break;
      case 4: PORTB = (PORTB &~BitMaskR4); PORTB |= BitMaskR5; break;
    }
    PORTD ^= BitMaskLAT;  //Toggle den Latchpin. Da er davor HIGH war, wird er jetzt wieder LOW.
    PORTD ^= BitMaskOE;  //Toggle den OE Pin. Da er davor HIGH war, wird er jetzt wieder LOW.
  }
}

[John (Gast)]

Roy B. schrieb:
> eine schnelle Serielle Ausgabe

Hat der Arduino kein SPI (Hardware)?