8x8-LED-Matrix mit ATMega8 als MAX7219

[Cassio]

Hallo zusammen!

Da ich hier schon seit einiger Zeit ein paar 8x8-LED-Matrix Displays liegen habe, möchte ich diese endlich mal in Betrieb nehmen.

Nun habe ich ein wenig gestöbert und bin dabei auf das MAX7219 gestoßen.

Fein, dachte ich mir! Dieses IC ist genau das, was ich suche.
Man nutzt es wie ein Schieberegister und das IC steuert dann meine Matrix an.
Die Freude war allerdings nur von kurzer Dauer...... bis ich den Preis für ein IC gesehen habe.
Über fünf Euro fand ich dann doch schon ein wenig heftig und so kam mit der Gedanke, diese Arbeit einen Mega8 erledigen zu lassen.
Der ATMega8 kostet in der normalen 28Pin Version nur knapp über ein Euro, ich kann ggf. eigene Wünsche bei der Ansteuerung berücksichtigen und obendrein lerne ich noch etwas.


So, nun habe ich mir mal ein paar Gedanken dazu gemacht und einen ersten Plan sowie eine kaskadierbares Layout gezeichnet.

Schaut es euch doch bitte mal an!
Sollte jemand jetzt schon einige Einwände zu meiner "Hardware-Idee" haben.... die später bei der Programmierung Probleme verursachen könnten.... dann raus mit der Sprache.

Später soll der Mega8 folgende Dinge erledigen:
- Selbstständige Ansteuerung einer 8x8-Matrix
- Entgegennehmen und Weiterreichen der Daten für die Reihen und Spalten (im Hintergrund)
- Auf ein Signal hin werden die angenommenen Daten "gespeichert" und angezeigt
- Jederzeit mit weiteren Anzeigen "endlos" erweiterbar
- Prüfknopf zum Test der 64 LEDs einer Matrixanzeige

Wäre sonst noch etwas von Interesse?

Was dann die Programmierung betrifft, werde ich bestimmt noch die ein oder andere Frage an euch haben.

Soweit erst mal vom Beginn meines kleinen Projektes.

Grüße,
Cassio

 

[Dirk]

Hallo Cassio,

was ich noch interessant finden würde ...

spendiere noch ein weiteres Byte, welches man shiftet, dieses kann man als Kommandobyte verwenden, durch ein Kommando kann man dann zum Beispiel einen Decoder aktivieren (Dezimalzahl, Hexadezimalzahl, Ascii-Zeichen anzeigen...), vielleicht könntest du auch dimmen (Stichwort PWM) oder in gewissen Grenzen die Mutiplexfrequenz per Kommando ändern.

Grüße,
Dirk

 

[Cassio]

Moin Dirk!

Also mit dem Dimmen müsste ich dann tricksen... weil die PWM-Ports schon belegt sind.
Was mir spontan dazu einfällt wäre das PWM-Register abzufragen und bei bestimmten Werten dann einen anderen Port zu togglen.
Kann ich ja mal drüber nachdenken.

Ich habe mir auch gedacht einen "Zeichenvorat" im Mega8 abzulegen.
So muss ich nicht alle Zahlen und Zeichen bitweise übertragen, sondern nur die zugehörige ASCII-Nummer.
Bin mir aber nicht sicher, ob ich da mit der eigentlichen Schieberegisterfunktion in Konflikt stehe.

Wie schon geschrieben..... Momentan ist noch alles offen.
Ich habe nur so meine Gedanken und lediglich der Plan und das Layout wurden schon zu "Papier" gebracht.
Vom Porgrammcode exestiert noch nicht eine Zeile.

Ich wollte erst mal die Hardware herstellen, weil mir langsam durch unfertige Projekte die Steckbretter für Testaufbauten ausgehen.

Gruß,
Cassio

 

[dino03]

Multiplex-Ansteuerung einer LED-Matrix-Anzeige

Hi Cassio,

da willst Du ja was identisches bauen wie ich
Im Bereich Schaltungen hab ich ja folgendes veröffentlicht ...
7-Segment-Display Beispielschaltung Multiplex (z.B. für Uhren)
mit der Betonung auf den Text in der Klammer
Unten auf der Platine ist noch Luft und ich habe zuhause noch 5x7-Anzeigen
mit LEDs rumfliegen (sowas wie "TA 07-11 RT" bei Reichelt). Die sollen da als
Anzeige für Datum/Wochentag und als Termininfo drunter. Also auch so etwas.

Ich mache das aber anders. Ich benutze 74HCT595 als Spaltentreiber in die ich
dann die Daten einschieben kann. Als Zeilentreiber benutze ich dann einen
ULN2803 oder UDN2981. Das ist dann erweiterbar und spart Pins. Pro Spalte
benutze ich 5mA Segmentstrom. Das haben die 7Seg-Anzeigen auch. Die
Zeilen lasse ich dann durchscannen. Also Spalten einschieben, übernehmen,
Zeile für die Spaltendaten anschalten und leuchten lassen. Wärend der
Leuchtzeit gleich die nächste Zeile in die Spaltentreiber einschieben usw.

Das ist von der Software relativ einfach und die 74595 sollten den Strom auch
verkraften. Ich brauch dann nur bei 16 Stellen (16 * 5 = 80 LED-Spalten) also
80 Widerstände und 10x 74595. Wird nen ganz schöner Drahtverhau
Der Strom bei 5mA pro Spalte und 80 Spalten macht dann für den Zeilentreiber
maximal 400mA wenn alle LEDs der Zeile an sind. Also sollte man für die Stromstöße
(eine Zeile voll an, die nächste voll aus) ein paar mehr Elkos verteilen

Das ganze Panel wird dann als Zentraleinheit noch mit ner Grafik-LCD in die
irgendwann-mal-Hausteuerung integriert

Gruß
Dino

 

[dino03]

Also mit dem Dimmen müsste ich dann tricksen... weil die PWM-Ports schon belegt sind.
Was mir spontan dazu einfällt wäre das PWM-Register abzufragen und bei bestimmten Werten dann einen anderen Port zu togglen.
Kann ich ja mal drüber nachdenken.

Da brauchst Du keinen PWM-Ausgang. Das kann man doch über eingeschobene
Dunkelzeiten im Multiplex-Ablauf erzeugen. Also sozusagen ne Soft-PWM als
Abfallprodukt des Multiplex-Betriebs.

Gruß
dino

 

[Cassio]

Moin Dino!

Muss gestehen.... habe den Beitrag nicht vollständig verfolgt.

Die 74595 habe ich hier auch zum testen.
Hatte die gedanklich nur an die Seite gelegt weil ich der Meinung war, die könnten nur 7bit ansteuern.
Da ich aber eine 8x8 habe und mir das MAX7219 von den Funktionen her gefiel, habe ich mich für den "Nachbau" auf Basis des ICs entschieden.

Meine Matrix-Anzeigen 48mm x 48mm habe ich von Pollin..... scheinen aber nicht mehr verfügbar zu sein.
Kann auf die Schnelle nur mal ein Foto von den Anzeigen bei Lieferung mit einstellen...... da kann man auch die Pollin übliche schlechte Verpackung begutachten.

Die Anzeige soll später dann auch so Dinge wir Uhrzeit, Wochentag, Datum, Temperatur, Geburtstage usw. anzeigen.
Letztlich ist das Momentan aber egal.... es dient ja nur zur Übung.

Effektiv bauen wir wohl alle das Gleiche.....
Ob wir nun Uhrzeiten oder Rennzeiten anzeigen lassen möchten.
Das Prinzip ist immer identisch.

Gruß,
Cassio

 

[Cassio]

Das kann man doch über eingeschobene
Dunkelzeiten im Multiplex-Ablauf erzeugen.

Hi Dino!

Hm.... das ist natürlich auch eine Idee.

Damit muss ich mein Layout auch nicht mehr ändern und einen Gesamttransistor integrieren..... hätte sowieso Platzprobleme bekommen.

Ich habe zwar zur Zeit gedanklich keine Dunkelzeiten eingeplant.... weil der Mega8 selbstständig das Multiplexen vorführen soll und im Hintergrund die neuen Daten eingehen.... aber für eine Dimmfunktion ist das natürlich ein guter Ansatz.

Ich behalte das mal im Hinterkopf.

Gruß,
Cassio

 

[dino03]

Hi Cassio,

Die 74595 habe ich hier auch zum testen.
Hatte die gedanklich nur an die Seite gelegt weil ich der Meinung war, die könnten nur 7bit ansteuern.
Da ich aber eine 8x8 habe und mir das MAX7219 von den Funktionen her gefiel, habe ich mich für den "Nachbau" auf Basis des ICs entschieden.

Bei mir steuer ich die 5x7 auch mit den 8Bit-Registern des 74595 an. Das ist
nur ne Softwarefrage. Einfach freimachen von festen Bit-Grenzen

Display 1 Spalte 1 - Register 1 Bit 0
Display 1 Spalte 2 - Register 1 Bit 1
Display 1 Spalte 3 - Register 1 Bit 2
Display 1 Spalte 4 - Register 1 Bit 3
Display 1 Spalte 5 - Register 1 Bit 4
Display 2 Spalte 1 - Register 1 Bit 5
Display 2 Spalte 2 - Register 1 Bit 6
Display 2 Spalte 3 - Register 1 Bit 7
Display 2 Spalte 4 - Register 2 Bit 0

Dann schiebt man eben nur 5Bit pro Anzeigestelle ins Register. Stört die Bits
in der Kette aber nicht. Alles ne Programmfrage

Meine Matrix-Anzeigen 48mm x 48mm habe ich von Pollin..... scheinen aber nicht mehr verfügbar zu sein.
Kann auf die Schnelle nur mal ein Foto von den Anzeigen bei Lieferung mit einstellen...... da kann man auch die Pollin übliche schlechte Verpackung begutachten.

Leider nicht mehr verfügbar. Da hast Du recht.
Über die Verpackung bei Pollin möchte ich nix mehr sagen
Ein Alibi-Blättchen Packpapier über alles gelegt und fertig. Was meinst Du
wohl wie viele Displays ich mit Einschlagstellen durch andere Teile reklamiert
habe. In der letzten Bestellung waren auch Bohrkronen drin Die Displays
haben auch nur zufällig überlebt. Ich hab auch mal ne LiPo-Zelle zum rumbasteln
mitbestellt. Also das die keinen Einschalg mit anschließendem Abfackeln des
Packetes bei der Post hatte ist echt nen Wunder
Ich haab beim letzten Mal echt überlegt zwei Bestellungen zu machen. Eine
mit den unempfindlichen Teilen und eine mit den Displays und sowas. Aber im
Endeffekt habe ich keine Lust für die Blödheit von Pollin beim Verpacken mit
ner 2ten Versandpauschale zu bezahlen. Und wenn die sich die ganzen
kaputten Teile leisten können müssen die das ja wissen. Ich hab die auf jeden
Fall schon ein paar mal drauf hingewiesen das die eigentlich die Displays nur
in nen extra Blatt Packpapier einwickeln müssen. ... Naja egal

Die Anzeige soll später dann auch so Dinge wir Uhrzeit, Wochentag, Datum, Temperatur, Geburtstage usw. anzeigen.
Letztlich ist das Momentan aber egal.... es dient ja nur zur Übung.

Effektiv bauen wir wohl alle das Gleiche.....
Ob wir nun Uhrzeiten oder Rennzeiten anzeigen lassen möchten.
Das Prinzip ist immer identisch.

kann man wohl so sehen

Dunkelsteuerung :

Hm.... das ist natürlich auch eine Idee.

Damit muss ich mein Layout auch nicht mehr ändern und einen Gesamttransistor integrieren..... hätte sowieso Platzprobleme bekommen.

Ich habe zwar zur Zeit gedanklich keine Dunkelzeiten eingeplant.... weil der Mega8 selbstständig das Multiplexen vorführen soll und im Hintergrund die neuen Daten eingehen.... aber für eine Dimmfunktion ist das natürlich ein guter Ansatz.

Ich behalte das mal im Hinterkopf.

Ich wollte das Multiplexing über Timer-Ticks bei mir synchronisieren (wird dann
wohl die erste Timerprogrammierung bei mir) und wenn man mehrere Ticks den
Zeilentreiber ausschaltet, dann wird es im ganzen dunkler.
Also z.B. nen Helligkeitszähler mit 4 Bit (16 Stufen) und beim Stand von 0 wird
die nächste Zeile aktiviert und eingeschaltet. Wenn dann der Heligkeitswert
erreicht ist, wird bei - zB Stand 9 - der Zeilentreiber wieder deaktiviert. Wenn
man die Timerticks mit zB 1ms laufen läßt könnte man daraus auch noch über
nen weiteren Zähler Sekundenticks generieren.

Gruß
Dino

 

[dino03]

Möglichkeit für Character-Tabelle im Flash

Hallo Cassio,

auf die folgende Weise könnte man eine Character-Tabelle im Flash ablegen ...



CodeBox BITCODE

Bei 8 LED-Zeilen => 2048 Bytes im Flash (8x8)

Bei 7 LED-Zeilen => 1792 Bytes im Flash (5x7)



  _________Basis-Adresse im Flash

 //// /  _____LED-Zeile (Mux-Zaehler)

|||| | ///  __________Character

|||| ||||  //// ////

|||| |||| |||| ||||

aaaa aZZZ cccc cccc

                        ____bei 5x7 nicht benutzt

                       /// ______ LED-Spalten

                      ||| /////

                      ||||||||

Chr 0x00          Bit 76543210

                      ||||||||

aaaa a000 0000 0000 - ........

aaaa a001 0000 0000 - ........

aaaa a010 0000 0000 - ........

aaaa a011 0000 0000 - ........

aaaa a100 0000 0000 - ........

aaaa a111 0000 0000 - ........

aaaa a110 0000 0000 - ........



         ___            Flash

Zeile 0 |   | Chr 0x00 0x0000 + Basisadresse

        |   | ...

        |___| Chr 0xFF 0x00FF

Zeile 1 |   | Chr 0x00 0x0100

        |   | ...

        |___| Chr 0xFF 0x01FF

Zeile 2 |   | Chr 0x00 0x0200

        :   : ...

        :   :

        :___:

Zeile 7 |   | Chr 0x00 0x0700

        |   | ...

        |___| Chr 0xFF 0x07FF













Chr 0x20 - Space



aaaa a000 0010 0000 - ........

aaaa a001 0010 0000 - ........

aaaa a010 0010 0000 - ........

aaaa a011 0010 0000 - ........

aaaa a100 0010 0000 - ........

aaaa a111 0010 0000 - ........

aaaa a110 0010 0000 - ........





Chr 0x21 - !



aaaa a000 0010 0001 - .....#..

aaaa a001 0010 0001 - .....#..

aaaa a010 0010 0001 - .....#..

aaaa a011 0010 0001 - .....#..

aaaa a100 0010 0001 - ........

aaaa a111 0010 0001 - ........

aaaa a110 0010 0001 - .....#..





Chr 0x22 - "



aaaa a000 0010 0010 - ....#.#.

aaaa a001 0010 0010 - ....#.#.

aaaa a010 0010 0010 - ....#.#.

aaaa a011 0010 0010 - ........

aaaa a100 0010 0010 - ........

aaaa a111 0010 0010 - ........

aaaa a110 0010 0010 - ........





Chr 0x23 - #



aaaa a000 0010 0011 - ....#.#.

aaaa a001 0010 0011 - ....#.#.

aaaa a010 0010 0011 - ...#####

aaaa a011 0010 0011 - ....#.#.

aaaa a100 0010 0011 - ...#####

aaaa a111 0010 0011 - ....#.#.

aaaa a110 0010 0011 - ....#.#.





Chr 0x24 - $



aaaa a000 0010 0100 - .....#..

aaaa a001 0010 0100 - ....####

aaaa a010 0010 0100 - ...#.#..

aaaa a011 0010 0100 - ....###.

aaaa a100 0010 0100 - .....#.#

aaaa a111 0010 0100 - ...####.

aaaa a110 0010 0100 - .....#..





Chr 0x25 - %



aaaa a000 0010 0101 - ...##...

aaaa a001 0010 0101 - ...##..#

aaaa a010 0010 0101 - ......#.

aaaa a011 0010 0101 - .....#..

aaaa a100 0010 0101 - ....#...

aaaa a111 0010 0101 - ...#..##

aaaa a110 0010 0101 - ......##





Chr 0x26 - &



aaaa a000 0010 0110 - ....##..

aaaa a001 0010 0110 - ...#..#.

aaaa a010 0010 0110 - ...#.#..

aaaa a011 0010 0110 - ....#...

aaaa a100 0010 0110 - ...#.#.#

aaaa a111 0010 0110 - ...#..#.

aaaa a110 0010 0110 - ....##.#





Chr 0x27 - ´



aaaa a000 0010 0111 - ....##..

aaaa a001 0010 0111 - .....#..

aaaa a010 0010 0111 - ....#...

aaaa a011 0010 0111 - ........

aaaa a100 0010 0111 - ........

aaaa a111 0010 0111 - ........

aaaa a110 0010 0111 - ........

Dann kann der Character-Wert (ASCII-Wert) eines Zeichens direkt in die
Adresse eingebaut werden und der Mux-Zähler für die LED-Zeile ist im oberen
Byte der Character-Tabelle angesiedelt. Damit hat man dann weniger
Rechnerei und die Tabelle ist trotzdem relativ kompakt ohne Löcher im Flash
abgelegt.

Problem ist lediglich die Erstellung der Tabelle. Die Zeilen eines Zeichens sind
im Flash 256Byte auseinander abgelegt. Also etwas aufwendiger. Aber das muß
man ja nur einmal erledigen (oder von einem anderen erledigen lassen) und dann
kann man die Tabelle ja bei jedem Programm wieder recyclen

Wenn man noch mehr Platz sparen möchte, dann könnte man das natürlich
noch alles etwas umorganisieren und über eine zweite Pointertabelle unbenutzte
Zeichen ausmaskieren und die Charactertabelle dadurch erheblich verkürzen.
Dafür wird dann die Programmierung erschwert und unübersichtlicher

Gruß
Dino

 

[Cassio]

Hallo Dino!

Mensch, dass ist ja hier wie bei Biolek..... "Ich habe da schon mal etwas vorbereitet....."

Jetzt muss ich deine ganzen ASM-Gedanken nur in BASCOM übersetzen und der Rest ist scheinbar ein Kinderspiel.

OK.... soweit zur Theorie. Die Praxis wird aber noch einige Zeit dauern.

Ich überlege gerade, ob ich für den LOAD und CLK Anschluss nicht lieber die externen Interrupts benutzen sollte.
Nach ersten Überlegungen war ich der Meinung, dass es auch mit jeden anderen Pin störungsfrei funktionieren sollte. Nun bin ich mir aber nicht mehr so sicher.

Heute scheint aber der Kopf dafür wohl keine Freiräume mehr zu haben........

Mal sehen, ob ich nachher dazu noch einen klaren Gedanken fassen kann.

Gruß und Danke erst mal,
Cassio

 

[dino03]

Hi Cassio,

Mensch, dass ist ja hier wie bei Biolek..... "Ich habe da schon mal etwas vorbereitet....."

ist ja noch nicht vorbereitet. Oder ist beim kochen ne Wurst auf den Tisch legen
auch "schon vorbereitet" ?
War lediglich mal mit nem Editor in ner viertel Stunde ein paar Gedanken in
Bytes gepreßt - mehr nicht ...
Wir müssen jetzt nur noch nen Sklaven finden der uns die Bitmuster der
Charactertabelle in den PC tippt ...
AAAAZUUUUUUUBIIIIIIIII !!!! komm doch mal

Gruß
Dino

 

[Cassio]

Hi Dino!

Meinst du eine BASCOM taugliche Tabelle in dieser Art?

Data &B00000000 , &B00000000 , &B00000000 , &B00000000 , &B00000000 ' 32=spc
Data &B00000000 , &B00000000 , &B01011111 , &B00000000 , &B00000000 ' 33=!
Data &B00000000 , &B00000011 , &B00000000 , &B00000011 , &B00000000 ' 34=Bracket
Data &B00010100 , &B01111111 , &B00010100 , &B01111111 , &B00010100 ' 35=#
Data &B00100110 , &B01001001 , &B01111111 , &B01001001 , &B00110010 ' 36=$
Data &B00100011 , &B00010011 , &B00001000 , &B01100100 , &B01100010 ' 37=%
Data &B00110010 , &B01001101 , &B01010010 , &B00100000 , &B00010000 ' 38=&
Data &B00000000 , &B00000000 , &B00000011 , &B00000000 , &B00000000 ' 39='
Data &B00000000 , &B00011100 , &B00100010 , &B01000001 , &B00000000 ' 40=(
Data &B00000000 , &B01000001 , &B00100010 , &B00011100 , &B00000000 ' 41=)
Data &B00101010 , &B00011100 , &B00111110 , &B00011100 , &B00101010 ' 42=*
Data &B00001000 , &B00001000 , &B00111110 , &B00001000 , &B00001000 ' 43=+
Data &B00000000 , &B01011000 , &B00111000 , &B00000000 , &B00000000 ' 44=,
Data &B00001000 , &B00001000 , &B00001000 , &B00001000 , &B00001000 ' 45=-
Data &B00000000 , &B01100000 , &B01100000 , &B00000000 , &B00000000 ' 46=.
Data &B00100000 , &B00010000 , &B00001000 , &B00000100 , &B00000010 ' 47=/
Data &B00111110 , &B01010001 , &B01001001 , &B01000101 , &B00111110 ' 48=0
Data &B00000000 , &B01000010 , &B01111111 , &B01000000 , &B00000000 ' 49=1
Data &B01000010 , &B01100001 , &B01010001 , &B01001001 , &B01000110 ' 50=2
Data &B00100010 , &B01000001 , &B01000001 , &B01001001 , &B00110110 ' 51=3
Data &B00011000 , &B00010100 , &B00010010 , &B01111111 , &B00010000 ' 52=4
Data &B01001111 , &B01001001 , &B01001001 , &B01001001 , &B00110001 ' 53=5
Data &B00111110 , &B01001001 , &B01001001 , &B01001001 , &B00110000 ' 54=6
Data &B00000001 , &B00000001 , &B01110001 , &B00001001 , &B00000111 ' 55=7
Data &B00110110 , &B01001001 , &B01001001 , &B01001001 , &B00110110 ' 56=8
Data &B00000110 , &B01001001 , &B01001001 , &B01001001 , &B00111110 ' 57=9
Data &B00000000 , &B00110110 , &B00110110 , &B00000000 , &B00000000 ' 58=:
Data &B00000000 , &B01011011 , &B00111011 , &B00000000 , &B00000000 ' 59=;
Data &B00001000 , &B00010100 , &B00100010 , &B01000001 , &B00000000 ' 60=<
Data &B00010100 , &B00010100 , &B00010100 , &B00010100 , &B00010100 ' 61==
Data &B00000000 , &B01000001 , &B00100010 , &B00010100 , &B00001000 ' 62=>
Data &B00000010 , &B00000001 , &B01010001 , &B00001001 , &B00000110 ' 63=?
Data &B00111110 , &B01000001 , &B01011001 , &B01010001 , &B00011110 ' 64=@
Data &B01111100 , &B00010010 , &B00010001 , &B00010010 , &B01111100 ' 65=A
Data &B01111111 , &B01001001 , &B01001001 , &B01001001 , &B00110110 ' 66=B
Data &B00111110 , &B01000001 , &B01000001 , &B01000001 , &B00100010 ' 67=C
Data &B01111111 , &B01000001 , &B01000001 , &B01000001 , &B00111110 ' 68=D
Data &B01111111 , &B01001001 , &B01001001 , &B01001001 , &B01000001 ' 69=E
Data &B01111111 , &B00001001 , &B00001001 , &B00001001 , &B00000001 ' 70=F
Data &B00111110 , &B01000001 , &B01001001 , &B01001001 , &B01111001 ' 71=G
Data &B01111111 , &B00001000 , &B00001000 , &B00001000 , &B01111111 ' 72=H
.
.
.
usw.

OK.... muss ich noch etwas bearbeiten, sonst passt es für meine Matrix nicht!

Gruß,
Cassio

 

[dino03]

Hi Cassio,

Meinst du eine BASCOM taugliche Tabelle in dieser Art?

Data &B00000000 , &B00000000 , &B00000000 , &B00000000 , &B00000000 ' 32=spc
Data &B00000000 , &B00000000 , &B01011111 , &B00000000 , &B00000000 ' 33=!
Data &B00000000 , &B00000011 , &B00000000 , &B00000011 , &B00000000 ' 34=Bracket
Data &B00010100 , &B01111111 , &B00010100 , &B01111111 , &B00010100 ' 35=#
Data &B00100110 , &B01001001 , &B01111111 , &B01001001 , &B00110010 ' 36=$
...
..
.
..
...
OK.... muss ich noch etwas bearbeiten, sonst passt es für meine Matrix nicht!

Bei der Tabelle sind die Spalten in einem Byte, bei mir sind es die Zeilen ...



CodeBox BITCODE

Data &B00100110 , &B01001001 , &B01111111 , &B01001001 , &B00110010 ' 36=$

| | | |

V V V V

00100110 - ..#..##.

01001001 - .#..#..#

01111111 - .#######

01001001 - .#..#..#

00110010 - ..##..#.

also liegen bei dir die Zeichen auf dem Gesicht (zuerst die linke Spalte, zum
Schluß die rechte Spalte).
Das mußt Du für meine Ansteuermethode in der Tat noch umarbeiten

Viel Spaß .... AAAAAAZUUUUUUUBIIIIIIII !!!! Herkommen !! aber FLOTTTTT !!

Gruß
Dino

 

[Cassio]

Moin Dino!

Nee nee, das ist ja auch nicht meine Tabelle!

Meine Hardwareplanung sieht auch so aus, dass ich die Spalten mit einer gewissen Taktfrequenz nacheinander durchschalte und die "Zeichenbilder" an den Reihen ausgebe.

Von der Sache mit der abgelegten Tabelle im Mega8 bin ich auch noch nicht so überzeugt.....

Wenn es sonst keine Einwände zur Hardware gibt, dann werde ich in den nächsten Tagen mal die Ätzanlage anwerfen und die Platinen erstellen.
Dann kann ich danach wenigstens meine Programmierung auch gleich testen.

Gruß,
Cassio

 

[dino03]

Hi Cassio,

Nee nee, das ist ja auch nicht meine Tabelle!

denn ruf schon mall den Azubi für deine Tabelle

Meine Hardwareplanung sieht auch so aus, dass ich die Spalten mit einer gewissen Taktfrequenz nacheinander durchschalte und die "Zeichenbilder" an den Reihen ausgebe.

??
Spalten ||||||| (senkrecht)
Zeilen ===== (waagerecht)

also ich schalte dabei die Zeilen durch. Ich schiebe die Daten für eine Zeile in
das 80Bit-Schieberegister aus den 74595 und aktiviere dann die entsprechende
Zeile.

Aber ich glaube, wir reden vom selben und kriegen es mal wieder nicht gepacken
es einheitlich zu erklären

Von der Sache mit der abgelegten Tabelle im Mega8 bin ich auch noch nicht so überzeugt.....

jaja, so eine Character-Tabelle verbrät doch schon einiges an Platz
Aber irgendwo brauchst du die so oder so. Und wenn nicht im Mega8 für
die Anzeige, dann mußt Du die gesamten Grafikdaten zu deiner Matrix
rüberladen. Das wird eine ganz schöne Menge und du mußt dann nicht die
Zeichendaten im RAM halten (ein Byte pro Stelle) sondern die Grafikdaten
(8 Byte pro Stelle). Ich glaube dafür wird das RAM beimm Mega8 nicht reichen.
Shit happens

Wenn es sonst keine Einwände zur Hardware gibt, dann werde ich in den nächsten Tagen mal die Ätzanlage anwerfen und die Platinen erstellen.
Dann kann ich danach wenigstens meine Programmierung auch gleich testen.

denn mal fröhliches planschen und kochen ...

Gruß
Dino

 

[dino03]

Flash sparen über Pointer-Tabelle

Hallo Cassio,

weitere Gedanken ...

Wenn man eine Pointer Tabelle vor die Character-Tabelle setzt kann man
mindestens 640 Byte sparen

Geht folgendermaßen ...

- Chr-Wert(ASCII) als Adresse für die Pointer-Tabelle
- Wert aus der Pointer-Tabelle als neuer Wert für die Adressierung in der
Character-Tabelle
- In der Character-Tabelle sind nur noch 128 Zeichen abgelegt. Das reicht.
da normalerweise nur bis 0x7F verwendet wird. Die Sonderzeichen (äöü,...)
werden über die Pointertabelle im Bereich 0x00..0x1F der Charactertabelle
abgelegt. Der Platz an der Stelle reicht dafür aus und dort ist normalerweise nix.

und schon hat man die Charactertabelle auf die Hälfte eingedampft plus die
neue Pointer-Tabelle mit 256 Byte. Aber insgesammt hat man Bytes gespart.


Gruß
Dino

 

[Cassio]

Hi Dino!

Stopp!
Auszeit!

Lass mich nun erst mal meine Hardware fertig stellen!

Danach werde ich mich um die Ansteuerung kümmern..... ob nun mit Tabelle, oder ohne.

also ich schalte dabei die Zeilen durch. Ich schiebe die Daten für eine Zeile in
das 80Bit-Schieberegister aus den 74595 und aktiviere dann die entsprechende
Zeile.

Tja... kann schon sein, dass wir das Gleiche meinen.
Trotzdem klingt es nach zwei verschiedenen Methoden.

Wenn ich also ein Zeichen darstellen möchte, dann übermittle ich die Daten für die Zeilen und schalte dann die einzelnen Spalten durch.
Damit ist also ggf. immer nur EINE LED je Reihe eingeschaltet.... je nach Symbol, Buchstabe oder Zahl.

Hm, OK.. wir meinen wohl doch das Gleiche!

Gruß,
Cassio

 

[Peacemaker]

HI

Gehts hier noch weiter? ich habe den selben drang den Max durch einen AVR zu erstzen!

cya

 

[dino03]

Hallo,

Gehts hier noch weiter?

scheint sich um das ewige "Zeitproblem" zu handeln
Zum tippen hier im Forum reichts meißt noch. Aber für größere
Bastelaktionen ist die Zeit ein wenig knapp

Gruß
Dino

 

[Grandpa]

Hi Cassio,

Schaut es euch doch bitte mal an!

hast recht - macht nicht unbedingt viel Spass, bis es läuft....


Grüsse,

Michael