LED Matrix Logikproblem

[demmy]

Hallo zusammen,

ich hätte ein kleines Logikproblem mit einer LED-Matrix.

Und zwar würde ich gerne eine 8x8 LED-Matrix über zwei Schieberegister-IC ansteuern.
Die beiden Schieberegister hängen hintereinander. Das 1. ist für die Anoden (Zeilen), das zweite dahinter für die Kathoden (Spalten)
Anbei ist auch noch ein Bild um alles zu veranschaulichen.

Nun zu meinem Problem:

Ich habe mir überlegt, das ich die Spalten in einer Schleife durchrollieren lasse und immer eine Spalte nach der anderen einschalte.
Parallel dazu Hinterlege ich in einer Tabelle den Zeichensatz.

Zeichensatz:
DATA &B10000001, &B01000010, &B00100100, &B00011000, &B00011000, &B00100100, &B01000010, &B10000001 ' X

Dabei entspricht jedes hinterlegte Byte einer Zeile. In meinem Beispiel hier sollte es eine Kreuzlinie sein.

Jetzt war meine Überlegung, Parallel zum durchrollieren der Spalten ziehe ich mir für das gewünschte Zeichen das jeweilige Bit aus dem Byte und
erstelle daraus ein neues Byte, welches dann im Schieberegister der Zeilen ausgegeben wird.

In meinem Beispiel wäre das neue Zeilen-Byte für die Spalte 1 = &B10000001, Spalte 2 = &B01000010 usw.

Somit habe ich den Vorteil, das das Bild Spalte für Spalte von links nach rechts aufgebaut wird. Es können in einer Spalte auch mehrere LED's
gleichzeitig aktiviert sein.

Nur leider ist es nicht so einfach aus der Tabelle von jedem Byte das entsprechende Bit auszulesen und daraus ein neues Byte zu basteln.

Kennt jemand von euch einen einfachen Weg das zu realisieren?

Oder gibt es einen komplett anderen Weg wie ich so eine matrix realisieren kann? Wie würdet Ihr das machen?

Ich bin dankbar für euere Hilfe und Ideen und ich hoffe ich konnte mein Problem verständlich schildern.

Viele Grüße

[Searcher]

Hallo,
bin mir nicht sicher, ob ich Dich richtig verstanden habe.

Die Bitmuster der Zeilen (Zeichensatz) müssen ja nicht unbedingt als Data vorliegen, sondern man kann sie ja auch in ein Bytearray hinterlegen. Dort kann man sie mit ROTATE so anordnen, wie es für die Ausgabe sein soll.

Sollen die Muster in Data: bleiben, kann man sie nach Lookup und vor Ausgabe auch mit ROTATE richtig hinrücken. Rotate akzeptiert als Parameter für shifts auch eine Variable; zB "Spalte".

So würde das Bild durchgerollt werden.

Falls es erst dunkel sein soll und das das Bild dann langsam erscheinen soll, kann man ein Wordarray( 8 ) machen und legt darüber ein Bytearray(16) als Overlay.
dim word_ar( 8 ) as word
dim byte_ar(16) as byte at word_ar overlay

In jedes Wordarrayelement legt man ein Zeichen der Zeile:
Word_ar(1) = &b01000010
Word_ar(2) = &b........
.
Word_ar( 8 ) = &b........

Dann gibt man jedes zweite Bytearrayelement aus.
Byte_ar(2) -> Ausgabe zum Shiftregister
Byte_ar(4) -> Ausgabe zum Shiftregister
.
Byte_ar(16) -> Ausgabe zum Shiftregister

Vor einer neuen Spaltenanzeige kann man mit Rotate auf die Wordarrayelemente die Bits in die Bytearrayelemente, die zur Ausgabe kommen, reinschieben.

Rotate word_ar(1) , right
Rotate word_ar(2) , right
.
Rotate word_ar( 8 ) , right

Rotiert man mehr als 8 Mal, verschwindet das Bild wieder und erscheint erneut mit weiteren Rotates

Gruß
Searcher

[demmy]

Hi,
das was du beschrieben hast ist zwar ein toller Ansatz, aber ich glaube nicht ganz das Problem was ich meinte.
Mir ging es darum das ich jetzt ja quasi die Werte jeder einzelnen Zeile in einer Tabelle oder von mir aus auch in einem Array hinterlegt habe.

Dann sieht das array für das Zeichen "X" z.b. so aus:

Zeile1: &B100000001
Zeile2: &B010000010
Zeile3: &B001000100
Zeile4: &B000101000
Zeile5: &B000101000
Zeile6: &B001000100
Zeile7: &B010000010
Zeile8: &B100000001
________^
Spalte

Ich lasse jetzt Spalte für Spalte durchlaufen. d.h. ich müsste jetzt für die Spalte 1 ein Byte erzeugen aus den Bits, die an der Stelle des Pfeiles in der Tabelle stehen (das wäre von oben nach unten &B10000001). Dieses Byte wird dann ausgegeben. Dann für die 2. Stelle / Spalte. usw. usw.
Um so das bild aufzubauen.
Mir geht es jetzt nicht um einen Effekt um das Zeichen einlaufen zu lassen oder ähnliches, sondern wirklich nur um den Bildaufbau beim Multiplexen.

Gibt es da einen eleganteren Weg um das Zeichen zu hinterlegen oder bzw. das Multiplexen durchzuführen, ohne das ich aus dem Bytearray für jede Zeile ein neues Byte erstellen muss?

Viele Grüße

[Searcher]

Hallo,
warum schreibst Du nicht gleich alle Bits, die durch den Pfeil markiert sind, in ein Byte? Dann steht das Zeichen nicht wie jetzt aufrecht, sondern 90° verdreht.

Ich wüßte jetzt nicht, wie man das sonst einfach machen könnte außer umsortieren der einzelnen Bits mit
Byte.0 = Byte_ar(Zeile1).0
Byte.1 = Byte_ar(Zeile2).0
.
Byte.7 = Byte_ar(Zeile8 ).0
(falls sich die Arrayelemente auch so bitweise ansprechen lassen - noch nicht probiert)

Gruß
Searcher

[demmy]

Mhh stimmt, das bringt mich gerade auf eine Idee!

Was wäre wenn ich die Zeilen anstelle der Spalten durchrollieren lasse? Dann wird das Bild von oben nach unten aufgebaut und nicht von links nach rechts und ich könnte in dem Bytearray zeilenweise das Bild hinterlegen so wie oben beschrieben!
Dann könnte ich das ganze Byte so wie es in der Tabelle hinterlegt ist einfach ins Schieberegister schieben!
Das müsste doch so ohne großen Aufwand funktionieren oder?

Viele Grüße!

[Searcher]

Was wäre wenn ich die Zeilen anstelle der Spalten durchrollieren lasse? ...
Das müsste doch so ohne großen Aufwand funktionieren oder?

Na klar. Du hast ja an den Kathoden und den Anoden Schieberegister. Mußt also sowieso jedes Mal 16 Bit für Zeilenbyte und Spaltenbyte seriell hineinschieben. Welche Reihenfolge ist da ja egal. Ich nehme an die Schieberegister sind kaskadiert also hintereinandergeschaltet.

Gruß
Searcher

[Peter(TOO)]

Hallo,

Mir geht es jetzt nicht um einen Effekt um das Zeichen einlaufen zu lassen oder ähnliches, sondern wirklich nur um den Bildaufbau beim Multiplexen.

Dazu noch ein paar Tipps:

- Damit es nicht gross flimmert solltest du etwa 25Hz Bildfrequenz anstreben. Mit deiner 8x Matrix musst du also mit 200Hz die Zeilen updaten.

- Wenn eine falsche LED auch nur ein paar µs angesteuert wird, ergibt das einen Schatten im Bild. Du musst also sicherstellen, dass beim einschieben der Daten, die die LEDs nicht ansteuern. Also entweder musst du Schieberegister mit Buffer verwenden und nach dem Schieben die Daten in deren Ausgangsbuffer transferieren oder du musst während dem Schieben das Display dunkel tasten.

MfG Peter(TOO)

[demmy]

Ja die Schieberegister sind kaskadiert!

Also bei den von mir verwendeten Schieberegistern gibt es einen Pin mit dem ich die Bits nach dem Schreiben ausgeben lassen kann. Ich denke das ist das was du meinst oder?
Zu der Bildfrequenz hatte ich mir überlegt, einen Timer zu verwenden der alle 20ms das ganze Bild aufbaut. Das wären dann 50 Bildaufbauten / Sekunde.
Das müsste doch ausreichen oder hab ich einen Denkfehler?

Vielen Dank schon mal für euere Hilfe!

Viele Grüße

[Peter(TOO)]

Hallo,

Also bei den von mir verwendeten Schieberegistern gibt es einen Pin mit dem ich die Bits nach dem Schreiben ausgeben lassen kann. Ich denke das ist das was du meinst oder?

Jain, das können nur Tri-State Buffer sein oder halt noch ein zusätzliches Register.
Welche Schieberegister hast du vorgesehen?

Zu der Bildfrequenz hatte ich mir überlegt, einen Timer zu verwenden der alle 20ms das ganze Bild aufbaut. Das wären dann 50 Bildaufbauten / Sekunde.
Das müsste doch ausreichen oder hab ich einen Denkfehler?

Jo.
Es kann immer nur eine einzelne Zeile leuchten.
Du kannst also nicht ein ganzes Bild aufs mal ausgeben.

Wenn du einen 4ms Interrupt erzeugst, kannst du bei jedem Interrupt eine Zeile ausgeben.
Nach 8 Zeilen hast du ein ganzes Bild. Fürs Auge muss jede Zeile gleich lang eingeschaltet sein, damit alle LEDs scheinbar gleich hell leuchten.
Jede Zeile leuchtet dann 1/8 der Zeit, aber entsprechend musst du mit dem LED Strom rauf, sonst hast du einen Dimmer.

Und wie ich schon schrieb, wenn eine LED für ein paar µs aufblitzt, sieht man das mit dem Auge als leichtes glimmen, ergibt eine sehr unschöne Anzeige.

Ich habe schon viele 7-Seg Anzeigen per Software gemultiplext, ist das selbe wie bei dir, nur die LEDs sin anders angeordnet.

Meist direkt von einem I/O-Port angesteuert.
Da muss man erst das Digit ausschalten, dann die Segmente für das nächste ausgeben und dann das nächste Digit einschalten.
Wenn erst das Digit umschaltet und dann die neuen Segmentdaten ausgibt, hat man einen Schatten der vorigen Anzeige auf dem nächsten Digit.
Das sind zwar nur ein paar µs während derer die falschen Daten ausgegeben werden, aber man sieht es ....

Das Schattenproblem hat mich nur bei meinem ersten Versuch überrascht, aber das ist schon über 30 Jahre her.

MfG Peter(TOO)