8x 5x7 LED Matrix

Hallo zusammen,
ich beschäftige mich seit ein paar Wo. mit dem Arduino UNO. Bis jetzt bin ich total begeistert. Die Standartgeschichten sind einfach zu verstehen.
Jetzt habe ich mir vorgenommen ein Display aus 8 5x7 DotMatrix LED's zu bastelln.
Kann mir jemand sagen wo ich einen ansatzt finde wie man so etwas realisieren kann?
Alles was ich bis her gefunden habe ist entweder in engl. oder nur bedingt Dokumentiert.

Wichtigster Punkt IMO: haben die Displays einen Speicher?

Ohne Speicher dürften die Displays im Multiplex-Betrieb flackern. Auf jeden Fall geht es dann nicht ohne zusätzliche Hardware, da die Arduino Ausgänge den notwendigen Strom nicht liefern können.

Es gibt Treiber, die das Multiplexen erledigen. i.d.R. wird da der MAX2719/2721 genommen:

Die kann man kaskadieren

Am besten erst mal eine Matrix nehmen und dann erweitern. Aber die Arduino Libraries dafür gibt es fertig. Die Module gibt es auch fertig. Da muss man dann schon fast nichts mehr machen.

Hallo,

in meiner Lehrzeit haben wir das mit dem 4511 o.ä. gemacht. Der verlinkte von Sereni ist um Welten moderner.
Zum einlesen in das Thema suche mal nach "7 segement multiplexen" oder nach "bcd to 7 segement decoder". Dann sollte das Prinzip klar werden. BCD war damals schon zum Leitungen einsparen da. Ist auch schon wieder überholt.

Ganz ohne ginge das auch. Nur dann muß der Takt sehr hoch sein gegen flimmern. Wenn du dann die loop erweiterst mit Code, war alles für die Katz. Deshalb unbedingt Treiber verwenden. Die sollten alle Speicher haben. Also der letzte Ausgangsportzustand bleibt erhalten bis vorn ein neuer reinkommt.

Kommt auch darauf an was man will. Wenn man was lernen möchte ist es nicht verkehrt mal eine kleine Matrix selbst gebaut zu haben:
https://www.mikrocontroller.net/articles/LED-Matrix

2 Schieberegister + Treiber ist da auch eine Option für eine einzelne Matrix. Aber bei 8 Stück wird das sehr problematisch. Und man hat dann damit zu tun die Low-Level Routinen zu programmieren (was aber nicht schwer ist wenn man weiß was man tut), während man sich bei fertigen Treibern auf die größeren Effekte konzentrieren kann. Wobei es da auch schon Libraries gibt die Dinge wie Scrollen fertig implementiert haben.

Muß es 5x7 sein, geht auch 8x8? Hier ein Beispiel. Diese Platinen gibt es fertig und man muß nur noch das Programm schreiben. Oder mal hier schauen.

Serenifly:
... MAX2719/2721 ...

Du meinst max7219 :wink:

Wenn es Dir um basteln und lernen geht, sind alle bereits genannten Tips super.

Wenn es um schnelle Ergebnisse geht, kann man über solche fertigen Matrix Elemente nachdenken. Die lassen sich auch (fast) beliebig kaskadieren. 8x32 und 16x16 sind gängige Größen.

Vorteile: Plug&Play, sehr hell (kein Multiplexing), keine weitere Elektronik nötig
Nachteile: Preis, hoher Strombedarf, Farbtiefe auf 24 Bit limitiert

Wenn Dich fertige Multiplex-Lösungen interessieren, google mal nach Colors Shield, Rainbowduino und Colorduino.

Gruß,

Helmuth

Helmuth,
manche verstehen under Led etwas, das rot leuchtet.
Gibt wohl auch gelbe , grüne und gegen Aufpreis auch blaue oder gar weisse. :wink:

Vielen Dank für die vielen Tip's.
habe die letzten Tage ein wenig rumgespielt und habe mich jetzt festgelegt.
Als Schieberegister möchte ich den CD4094 verwenden.
Im genauen möchte ich eine Zeitanzeige erstellen. Diese soll aus 2 Reihen mit je vier Elementen bestehen.
In der ersten Zeile soll ein Countdown angezeigt werden und in der zweiten vier Buchstaben. Im Besten Fall soll die Farbe der Zeichen zwischen grün, rot und gelb wechseln.
Die Frage die sich mir jetzt stellt ist ob ich die Schieberegister besser kaskadieren oder einzeln ansteuern soll.
Welche Vor- oder Nachteile ergeben sich hierraus?

Die Frage die sich mir jetzt stellt ist ob ich die Schieberegister besser kaskadieren oder einzeln ansteuern soll.
Welche Vor- oder Nachteile ergeben sich hierraus?

Die Frage kommt mir falsch vor ....

Darum auch eine "andere" Antwort: Die Daten per SPI raus schieben.

Wenn ich das mit dem Max2719 richtig aus dem Datenblatt rauslese ist dieser für 7-Segmentanzeigen gedacht. Sollte dieser jedoch wie ein LCD Display ansteuerbar sein so währe das ja wirklich viel zu einfach.
lt. Datenblatt sind 8 Anzeigen ansteuerbar was im entefekt ja nur eine Frage der Anordnung bedeutet.

Wesentlich ist das Flackern, das während des Änderns der Schieberegister entsteht. Bei kaskadierten Registern dauert das Flackern länger, da mehr Bits durchgeschoben werden müssen.

Es gibt aber auch Schieberegister mit einem zusätzlichen Ausgangspuffer, der dieses Flackern praktisch eliminiert. Dann ist es egal, wie durchgeschoben wird, wenn anschließend die Ausgänge auf einen Schlag geändert werden.

Wieso rückst Du nicht mit den genauen LED Bausteinen raus, die Du verwenden möchtest?

combie:
Die Frage kommt mir falsch vor ....

Darum auch eine "andere" Antwort: Die Daten per SPI raus schieben.

Um erlich zu sein habe ich das mit dem SPI BUS noch nicht richtig verstanden. Ist halt alles noch Neuland für mich. Habe mir dieses Thema für später aufgehoben. Aber vieleicht...

Das geht:
http://playground.arduino.cc/Main/LedControl

Ein MAX2719/2721 kann 8 Zifferen steuern. Jedes Ziffer hat 8 LEDs (7 Segmente + Punkt). Also geht maximal eine 8x8 Matrix.

Gibt hier auch fertigen Code für 5x7 mit Scrollendem Text:

SPI ist nichts anderes als ein Bus mit 8 Bit Schieberegistern. Man spart sich dabei die Bitfummelei mit Takt und Daten für das Shiften der 8 Einzelbits.

Zum experimentieren habe ich mir den TC 12-11 RT :: Dot-Matrix-Display, 5x7 Pkt., 8,0mm, rot, Kathode
http://www.reichelt.de/TC-12-11-RT/3/index.html?&ACTION=3&LA=446&ARTICLE=31585&artnr=TC+12-11+RT&SEARCH=tc+12-11
rausgesucht.
Der ist zwar nur in rot aber zum testen vieleicht nicht ganz ungeeignet.
Ehe ich mich aber jetzt in den vielen Möglichkeiten verrenne die ihr mir schon aufgezeigt habt erst mal ganz simpel eine Anzeige 2x CD4094.
Daten in das schiebergister nach einander zu schieben ist nicht das Problem. Sieht bei mir momentan so aus:
int freigabe1 = 11;
int tackt1 = 12;
int bit1 = 13;

void setup() {
// put your setup code here, to run once:

pinMode(freigabe1,OUTPUT);
pinMode(tackt1,OUTPUT);
pinMode(bit1,OUTPUT);

}

void loop() {
// put your main code here, to run repeatedly:
for(int i = 10; i >0; i--)
{
digitalWrite(tackt1,LOW);
digitalWrite(freigabe1,LOW);
digitalWrite(bit1,LOW);
digitalWrite(tackt1,HIGH);
}

for(int l = 4; l >0; l--)
{
digitalWrite(tackt1,LOW);
digitalWrite(freigabe1,HIGH);
digitalWrite(bit1,HIGH);
digitalWrite(tackt1,HIGH);
delay(1000);
digitalWrite(tackt1,LOW);
digitalWrite(freigabe1,HIGH);
digitalWrite(bit1,LOW);
digitalWrite(tackt1,HIGH);
delay(1000);
}
}

Der nähste Schritt währe für mich jetzt eine Zeichenfolge zu übertragen. Hier bin ich noch unsicher wie ich das lösen muss. Sicherlich ist eine Schleife möglich ich bin mir aber Sicher das es auch einfacher gehen muss.

Wenn dir das überhaupt nicht klar ist mit du mit einem fertigen Treiber und einer fertigen Bibliothek besser dran. Und mit delay() wird das schon mal gar nichts.

Das Stichwort ist Multiplexen:
https://www.mikrocontroller.net/articles/LED-Matrix#Multiplexbetrieb
Aber das muss blockierungsfrei programmiert werden!! Ein Interrupt muss es nicht sein. Das geht auf dem Arduino auch per millis()/BlinkWithoutDelay

Ein richtiger LED Treiber ist auch vom Strom her besser. Wenn man eine LED Zeile so mit Schieberegistern aufbaut muss man unbedingt einen Zeilen-Treiber mit Transistoren bauen. Das geht, aber auch da solltest du in etwa wissen was du machen musst.

Momentan geht es mir mehr um das Verstehen und um die Möglichkeiten die sich mir bieten. Das delay nur zum Testen geeignet ist und nicht für eine genaue Zeitwiedergabe ist soweit klar für mich. Diese Anzeige ist für mich immer wieder ein Mass was ich mir gesetzt habe. So habe ich dies schon in C auf mehreren PC's(Netzwerk) zu laufen. Auch mit dem Arduino habe ich eine fertige Anzeige mit vier 7-Segment und Block-LED's erstellt. Jetzt möchte ich wissen ob es nicht Sinnvoller ist mit einer Matrix zu arbeiten. Das Grundprinzip ist mir soweit(hoffentlich) vertraut. Durch sehr schnelles ansteuern der einzelnen Punkte(LED) wird dem Auge, welches ca. 25 Wiederhlungen pro Minute wahrnehmen kann, ein "Bild" vorgegaukelt.

habe nun folgenden Testcode geschrieben:
//für Zeilen
int freigabe1 = 11;//CD4094 PIN1
int tackt1 = 12;//CD4094 PIN3
int bit1 = 13;//CD4094 PIN2
int zeile1[8] = {1,1,1,1,0,1,1,1};//von rechts nach links = Zeihle1, Zeihle2 … letzte zeihen wird nicht benötig

//für spalten
int freigabe2 = 8;//CD4094 PIN1
int tackt2 = 9;//CD4094 PIN3
int bit2 = 10;//CD4094 PIN2
int spalte1[8] = {1,0,1,0,0,1,0,0};//von rechts nach links = Spalte1, Spalte2 … letzte 3 Zeichen werden nicht benötig

void setup()
{
pinMode(freigabe1,OUTPUT);
pinMode(tackt1,OUTPUT);
pinMode(bit1,OUTPUT);
pinMode(freigabe2,OUTPUT);
pinMode(tackt2,OUTPUT);
pinMode(bit2,OUTPUT);
}

void Zeile1()
{
digitalWrite(freigabe1, LOW);
for(int i=0; i<8;i++)
{
digitalWrite(tackt1,LOW);
digitalWrite(bit1,zeile1*);*

  • digitalWrite(tackt1,HIGH);*
  • }*
    digitalWrite(freigabe1, HIGH);
    }
    void Spalte1()
    {
    digitalWrite(freigabe2, LOW);
  • for(int j=0; j<8;j++)*
  • {*
  • digitalWrite(tackt2,LOW);*
  • digitalWrite(bit2,spalte1[j]);*
  • digitalWrite(tackt2,HIGH);*
  • }*
    digitalWrite(freigabe2, HIGH);
    }
    void loop()
    {
    Zeile1();
    Spalte1();
    }
    somit kann ich zumindestens sagen das die Schieberegister und die Verdrahtung passt.
    Ich tuhe mich allerdings gerade schwer mit dem verschachteln. bis jetzt nutze ich Array’s werde aber eine Matrix benötigen um zeichen darzustellen. kann mir da jemand sagen wie ich hier herrangehen soll?

Du könntest deinen Code in die Codetags setzen, dann ist er im Forum leichter zu lesen.

Warum verwendest du nicht shiftout()?