Anz.	Bezeichnung	Datenblatt
1	Batterie/Spannungsquelle 9V
1	Spannungsregler 7805
1	ATMega8 AVR-Prozessor
5	Transistor BC548C (BC546C-BC550C)
7	Widerstand 470 Ohm
6	Widerstand 10 kOhm
1	Elektrolytkondensator 100 µF/16V
1	Kondensator 100nF
2	Mikrotaster
1	TC07-11 Punktmatrix-Anzeige

Mit 7-Segment-Anzeigen kann man schon recht bequem Ziffern und auch einige Symbole darstellen. Wer mit Mikrokontrollern arbeitet wird schnell etwas mehr brauchen als nur die reine Ausgabe von Zahlen. Eine Möglichkeit sind so genannte Punktmatrix-Anzeigen. Diese Anzeigen haben ein ähnliches Gehäuse wie 7-Segment-Anzeigen. Diese besitzen aber mehr Anschlüsse wodurch es nötig ist, die Anzeige 'Quer' auf dem Steckboard unterzubringen. Ausgestattet sind Punktmatrix-Anzeigen mit einer ganzen Menge von LEDs welche in Spalten und Reihen angeordnet sind. Verdrahtet sind die einzelnen Leuchtdioden in einer Matrixstruktur. Hierdurch muss man nicht jede LED einzeln verdrahten.

In der Abbildung sieht man, wie so eine Matrixstruktur aussieht. Je nachdem welche LED man ansteuern möchte, muss die Betriebsspannung an die entsprechende Zeile, hier gekennzeichnet durch R1 bis R7, und der Minuspol an die entsprechende Spalte, erkennbar durch C1 bis C5, angelegt werden. Natürlich darf der Vorwiderstand nicht vergessen werden. Soll z.B. die Leuchtdiode in Zeile 3 und Spalte 4 aufleuchten, muss die LED-Betriebsspannung an R3 und der Minuspol an C4 angeschlossen werden. Es ist aber ebenso möglich gleich eine komplette Spalte anzusteuern. Hierzu muss man nur die gewünschten Zeilen mit der LED-Betriebsspannung versorgen. Wird jetzt an der gewünschten Spalte das Nullpotential angeschlossen, leuchtet die gewünschte Spalte mit den angesteuerten LEDs auf. Will man nun ein Bild auf dem Display darstellen, muss dafür gesorgt werden, dass die entsprechenden Zeilen mit den Bilddaten zu der dazugehörigen Spalte angelegt werden. Jetzt muss die Spalte kurze Zeit eingeschaltet werden. Anschließend werden die Daten für die nächste Spalte angelegt. Dann wieder die entsprechende Spalte aktiviert usw. Wird dies schnell genug gemacht, sieht der Anwender ein entsprechendes Bild.

Soll ein Matrixdisplay am AVR angeschlossen werden, so sollten die Zeilen an einem Port und die Spalten an einen anderen Port. Die Spalten können wir, aufgrund des größeren Stromes, nicht direkt mit dem AVR verbinden. Hier setzen wir noch Transistoren als Leistungsverstärker ein. Als Nebeneffekt reicht es nun aus, den entsprechenden Port auf '1' zu legen und schon können die entsprechenden LEDs in der Spalte aufleuchten. Will man nun in einer Spalte eine oder mehrere LEDs zum leuchten bringen, muss man das entsprechende LED-Bild an Port D anlegen. In welcher Spalte die Leuchtdioden sich nun befinden, welche aufleuchten sollen, bestimmen die Pins in Port C. Port C Bit 0 steuert die erste Spalte, Port C Bit 1 die zweite Spalte usw. Soll also die erste Spalte angesteuert werden, so muss dem Port C den Wert 1 zugewiesen werden, um Bit 0 des Ports zu aktivieren. Wird Port C den Wert 2 zugewiesen, schaltet der AVR die zweite Spalte frei. Bei einer 4 am Port wird die 3. Spalte aktiv. Usw. Testen wir aber erst einmal die Ansteuerung einer einzigen Spalte mit folgendem kleinen Programm:

Nach dem Übertragen und dem Neustart des AVRs erscheinen auf dem Display mehrere Punkte in der 2. Spalte. Wer den Befehl 'Portd=&B00101100' mit dem Bild des Displays vergleicht, wird eine Übereinstimmung feststellen. Wenn man die Bitfolge im Befehl ändert und dann das Programm zum ATMega überträgt, merkt man schnell wie die einzelnen Bitbilder der aktuell ausgewählten Spalte aufgebaut ist.

In der Grafik wird die Zuordnung des Ports zu den einzelnen Zeilen des Displays dargestellt. Um einige Sicherheit mit dem Ansteuern der einzelnen Bitmuster zu bekommen, sollte man verschiedene Muster ausprobieren. Das Ansteuern einzelner Spalten des Displays mag ja schon recht interessant sein aber wirklich sinnvoll ist dies noch nicht. Um das Display komplett zu verwenden, sollten schon alle Spalten angesteuert werden. Wir können aber immer nur mit einer Spalte zur Zeit arbeiten. Wie steuert man da das ganze Display an? Hierzu schreiben wir unser Programm ein wenig um:

Bevor wir Symbole und Zeichen ausgeben können, werden diverse Variablen benötigt. Dies wird mit den Dim-Anweisungen erreicht:

Dispcol und Dispcnt werden für die Steuerung der der Zeilen und Spalten benötigt. Bitbld enthält das aktuell darzustellende Bitbild. Chradr wo sich das entsprechende Bitbild in der Tabelle befindet. Mit Hilfe von Charnr übergeben wir dem Programm die Nummer des gewünschten Zeichens.

Damit die Ausgabe funktioniert müssen wir die Hilfsvariablen zur Displaysteuerung vorbelegen. Mit der Anweisung 'Charnr=65' legen wir fest, dass wir das 'A' auf dem Display sehen möchten. Da wir in der Tabelle die Ascii-Zeichen definiert haben, kann man entsprechend ein Ascii-Zeichen zuweisen. Welche Nummer zu welchem Zeichen gehört, kann man im Internet leicht heraus finden. In der Tabelle wurde es auch als Bemerkung hinter den entsprechenden Datenblock vermerkt.

Als nächstes tritt das Programm in eine Endlosschleife ein. Als erstes muss die Adresse der Daten der auszugebenden Spalte berechnet werden:

Als erstes wird von unserer gewünschten Zeichennummer 32 abgezogen. Dies ist notwendig da in der Ascii-Tabelle das erste sichtbare Zeichen mit der Zeichennummer 32 beginnt. Unsere Zeichentabelle aber mit Zeichennummer 0.

Da jedes Zeichen in der Zeichentabelle für jede Spalte 1 Datenbyte benötigt, müssen wir für jedes Zeichen mit 5 multiplizieren. Dies macht die Anweisung 'Chradr=Charadr*5'. Nun muss wir noch die endgültige Datenposition mit der aktuellen Spalte addieren um das richtige Datenbyte auslesen zu können.

Nun können wir das aktuelle Bitbild der aktuell aktiven Spalte auslesen. Dies tun wir mit:

Jetzt haben wir schon alle notwendigen Daten zusammen um die Anzeige mit der aktuellen Spalte und dem dazu gehörigen Bitbild anzusteuern:

Diese Befehle dürften schon bekannt sein. In Dispcol ist der Wert für die aktuell geschaltete Spalte vorhanden. Bitbld enthält das Bitbild für die aktuelle Spalte.

Nun müssen wir dafür sorgen, dass die nächste Spalte angezeigt werden kann. Hierzu dienen die letzten beiden Zeilen in der Schleife:

Durch 'Incr Dispcnt' erhöhen wir den Zeiger auf die Bilddaten des aktiven Zeichens. Da dieser Zeiger nur einen Wert von 0 bis 4 haben darf, behelfen wir uns eines mathematischen Tricks. Indem wir immer den Rest einer Division einer Teilung durch 5 der Variablen Dispcnt zuweisen, wird dieser nie größer als 5. Sobald Dispcnt 5 erreicht hat, ergebt die Teilung einen Rest von 0 und dieser wird dann wieder gespeichert.

Die Änderung der Variablen für die Spaltensteuerung ist da schon etwas komplizierter. Hier müssen wir dafür sorgen, dass das Bit, welches dafür sorgt, das die entsprechende Spalte durchgesteuert wird, um 1 nach links verschoben wird. Dies wird durch den Shift-Befehl erreicht. Wenn wir das 6. Bit erreicht haben, also Dispcol den Wert 32 enthält, muss das Bit wieder an die erste Stelle verschoben werden. Das macht die folgende If-Anweisung.

Durch Loop sorgen wir nun, dass das Ganze unendlich wiederholt wird. Aber die meisten möchten doch sicher nicht nur 1 Zeichen sehen, sondern alle die in der Tabelle definiert sind. Dafür ersetzen wir einfach die Do-Loop-Schleife durch folgenden Programmtext:

Hier werden nun alle definierten Zeichen dargestellt. Die Darstellungsroutine für die Zeichen wird pro Symbol 500 mal durchlaufen. Jedes Symbol ist also etwas mehr als eine halbe Sekunde sichtbar.

Wer noch Zeichen selbst definieren möchte, kann diese einfach am Ende der Tabelle hängen. Um sie dann mit obigem Programm zu sehen muss nur der Befehl 'For Charnr=32 To 127' geändert werden. Hat man 1 Zeichen definiert, muss die 127 durch 128 ersetzt werden. Bei mehreren Zeichen entsprechend höher.

Eine Routine die mit Hilfe einer Zeichennummer ein Zeichen/Symbol auf ein Display darstellt, nennt man übrigens Zeichengenerator. Wir werden in anderen Lehrgängen noch Bauteile kennen lernen, die ausschließlich mit Zeichengeneratoren arbeiten.

Das letzte Programm zeigt aber ein Problem ganz deutlich. Das Hauptprogramm muss sich ständig auch um die Darstellung auf dem Display kümmern. Hat man kompliziertere Programme, ist dies ein ziemliches Problem. Dauernd muss immer wieder die Darstellungsroutine aufgerufen werden. In dem Lehrgang Timer - Der AVR und Vater Zeit wurde bereits gezeigt, dass es möglich ist, immer wiederkehrende Aufgaben im Grunde 'nebenbei' zu erledigen. Hierzu muss man nur einen Timer verwenden der per Interrupt in regelmäßigen Abständen eine Unterroutine aufruft. Genau dies können wir für unsere Anzeige gebrauchen. Ersetzen wir einmal den Programmteil bis zur Zeichentabelle durch folgenden Programmteil:

Nach dem Start zeigt das Display wieder den gesamten Zeichenvorat an. Aber dieses mal kann man im Hauptprogramm erkennen, dass wir nur eine Zeichennummer zuweisen. Die Ansteuerung wird im Hintergrund erledigt.

Damit wir die Anzeige im Hintergrund steuern können, müssen wir erst einmal einen Timer initialisieren. Dies wird durch folgende  Programmzeilen erreicht:

Mit der Config-Anweisung wird dafür gesorgt, dass der Timer 48,8 mal in der Sekunde einen Interrupt auslöst. Anschließend wird der Timer mit der Enable-Anweisung aktiviert. Damit unser Programm weiß, welche Routine er aufrufen soll, wenn der Timer einen Interrupt auslöst, wurde die On Timer0-Anweisung eingefügt. Jetzt müssen die Interrupts nur noch mit 'Enable Interrupts' aktiviert werden. Nun wird alle 48,8x in der Sekunde die Routine

ausgeführt. Diese Routine ist die gleiche, welche bereits weiter oben verwendet wurde. Nur mit dem Unterschied, dass wir hier auf den Wartebefehl verzichten können. Die Wartezeit ergibt sich automatisch aus der Laufzeit des Timers.

Nun reicht es einfach aus, das wir der Variablen Charnr den gewünschten Zeichenwert zuweisen und schon zeigt unser Display das entsprechende Symbol. Um die Ansteuerung müssen wir uns im Hauptprogramm nicht weiter kümmern. Dies kann man gut an unserem jetzigen Hauptprogramm sehen:

Hier brauchen wir nur noch die entsprechende Zeichennummer zuweisen. Damit das Symbol einige Zeit sichtbar bleibt ist in der For-Schleife nur ein Wait-Befehl eingebetter.

Nun wollen wir das Ganze noch ein wenig ergänzen und fügen 2 Taster hinzu.

Die beiden Taster werden wieder gegen Null geschaltet, damit wir die AVR-eigenen Pullup-Widerstände verwenden können. Ersetzen wir nun noch die Do-Loop-Schleife durch diesen Programmteil. Neben den zusätzlich Befehlen zur Tasterinitialisierung wird jetzt im Hauptprogramm die Zeichentabelle per Tastersteuerung angezeigt. Mit S1 erhöht man das aktuelle Zeichen um 1. Mit S2 wird die Zeichennummer um 1 verringert.

Das Ansteuern eines Punktmatrixdisplays mit Hilfe eines Zeichengenerators ist ja ganz nett. Aber die volle Leistungsfähigkeit so einer Anzeige kann man erst herausholen, wenn es möglich ist das Display mit Grafikbefehlen anzusteuern. Mit dem nächsten Programm erzeugen wir einen blinkenden Punkt in der 3. Spalte (X=3) und in der 3. Zeile (Y=3). Hier haben wir jetzt ein komplett neues Programm. Den Zeichengenerator und die Zeichentabelle können wir hier nicht mehr gebrauchen.

Um das Display grafisch anzusteuern muss natürlich die Interruptroutine zum Großteil abändern. Als erstes wird die Zeichentabelle ersetzt. Anstelle der Zeichentabelle benötigen wir nun einen Speicher, indem das aktuelle Bild auf dem Display festgehalten wird. Dies wird am Anfang des Programms definiert:

Wir benötigen hier fünf Feldelemente. Für jede Spalte eine Feldvariable. So ein Speicher wird Bildwiederholspeicher genannt und findet man immer dort wo man mit grafischen Displays arbeitet. Auch die Grafikkarte des heimischen PCs besitzt Bildwiederholspeicher. Dieser hat aber ganz andere Dimensionen, wie unsere 'mickrigen' 5 Bytes hier. Moderne Grafikkarten haben 64 MB und mehr.

Um jetzt das aktuelle Bild darzustellen wird die folgende Interruptroutine regelmäßig aufgerufen:

Hier wird jetzt nur bei jedem Aufruf ein Byte aus dem Grafikspeicher ans Display geschickt. Die ganze Berechnung für die Zeichenposition etc. wird hier nicht benötigt. Der Anwender muss nun nur im Hauptprogramm dafür sorgen, dass die Daten im Bildwiederholspeicher entsprechend geändert werden.

Zu diesem Zweck wurden einige Unterroutinen ins Programm eingefügt. Die einfachste ist der CLS-Befehl (CLear Screen, Bildschirmlöschbefehl).

Hier wird einfach der Bildschirmspeicher mit 0 gefühlt.

Schwieriger wird es da schon mit dem Setzbefehl für einzelne Punkte:

Um mit den Unterroutinen kommunizieren zu können, wurden 2 Variablen, X und Y, definiert. Damit übergeben wir der entsprechende Routine die gewünschte Position der anschließend aufgerufen Funktion.

Um nun einen Punkt zu setzen müssen wir erst einmal wissen, welches Bit in unserem Datenbyte die gewünschte Y-Position ist. Da wir einen Wertebereich für Y von 1 bis 7 haben, müssen wir erst einmal 1 abziehen um einen Bereich von 0 bis 6 zu bekommen. Um jetzt das entsprechende Bit zu berechnen muss nur 2 hoch Y gerechnet werden. Nun haben wir den genauen Bitwert des Punktes. Aber wie setzt man damit jetzt einen Punkt in einem Datenbyte?

Dabei hilft uns die Logik. Es reicht aus wenn wir das aktuelle Datenbyte mit der Oder-Funktion mit dem errechneten Wert verknüpfen. Diese kleine Tabelle verdeutlicht dies:

Genau dies wird in der letzten Anweisung der Routine gemacht. Anschließend leuchtet an der gewünschten Position ein Punkt auf. Im jetzigen Hauptprogramm eben in der 3. Spalte und der 3. Zeile.

Ähnlich funktioniert dies auch, wenn man einen Punkt wieder löschen möchte:

Soll ein Punkt gelöscht werden müssen alle Punkte so bleiben wie sie sind. Nur der zu löschende Punkt muss immer 0 sein. Hierzu ist die And-Funktion ganz hilfreich. Es muss aber zusätzlich noch der errechnete Punkt invertiert werden. Hierzu auch eine Tabelle zur Verdeutlichung:

Durch diese Routinen haben wir die wichtigsten Routinen, die wir benötigen um eine umfangreiche Grafikbibliothek zu erstellen. Dies würde hier aber zu weit führen. Des Weiteren ist unser kleines Display nur beschränkt für leistungsfähige Grafikroutinen geeignet. Wer möchte, kann sich ja einmal daran versuchen eine Routine zum zeichnen von Linien zu entwerfen. Ein bekannter Algorithmus ist der Bresenham-Algorithmus. Im Internet gibt es reichlich Informationen darüber.

Zum Abschluss noch ein kleines Hauptprogramm, welches das Display langsam mit Punkten füllt und anschließend wieder löscht: