LED-Laufschrift-Hack
Ich bin ein großer Fan des Postillon, vor allem auch des dort regelmäßig erscheinenden Newstickers. Es handelt sich dabei um eine stete Quelle von Wortspielen und lustigen Sprüchen. Eines Tages hatte ein Freund von mir die Idee, dass es klasse wäre, eine tragbare LED-Laufschrift zu haben, die kontinuierlich diese Sprüche verbreitet. Primärer Einsatzort sollte natürlich die Disco sein, ein Ort, an dem es durchaus nützlich sein kann, ein wenig aus der Masse herauszustechen. Gesagt, getan. Also wurden zwei LED-Laufschriftmodule bei Ebay erworben, mit dem Ziel, sie für diesen Zweck zu modifizieren.
Teardown und Reverse-Engineering der Laufschrift
Das Öffnen des Moduls war etwas langwierig, da es komplett verschweißt war. Nach einiger Zeit der Bearbeitung mit dem Teppichmesser ließ es sich jedoch öffnen und hielt eine positive Überraschung bereit. Das Modul enthielt einen ATmega88-Mikrocontroller, also einen Controller, mit dem ich schon etliche Erfahrung hatte und für den ich obendrein ein passendes Programmiergerät besaß. Als ich den Resetpin kurz mit Masse verband, ging das Gerät aus, ein Zeichen, dass der Reset-Pin noch funktionierte, der Controller sich also grundsätzlich noch programmieren ließ.
Zunächst wurde mittels Durchgangsprüfer die gesamte Schaltung analysiert und ein Schaltplan erstellt. Neben dem Mikrocontroller befanden sich nur noch ein serielles EEPROM, einige Taster, ein Schalter,
Widerstände, Kondensatoren sowie ein Transistor auf der Platine. Laut Aufdruck hat das EEPROM eine Kapazität von 256 Byte. Wie darin allerdings die 20 Texte mit je 120 Zeichen gespeichert werden sollen,
die das Gerät laut Bedienungsanleitung fassen kann, ist mir rätselhaft. Selbst wenn die 512 Byte des EEPROMs des AVRs dazu kommen und die Texte weniger als ein Byte pro Zeichen nutzen, wird das knapp.
Da jedoch von vorn herein geplant war, ein viel größeres EEPROM einzusetzen, bin ich diesem Rätsel nicht auf den Grund gegangen1. An den I²C-Leitungen,
über die das EEPROM mit dem Controller verbunden ist, sind keine Pull-up-Widerstände, was zwar bei langsamen Datenraten funktionieren kann, aber dennoch die Spezifikation eindeutig verletzt.
Daher wurden nachträglich zwei 10-kOhm-Widerstände eingelötet. Die 7 Taster hängen alle über verschiedene Vorwiderstände an einem AD-Wandler-Eingang, eine elegante Lösung,
um mehrere Taster mit einem Mikrocontroller-Pin auszuwerten. Der Transistor bildet zusammen mit 2 Widerständen eine Pegelwander-Schaltung, die mit dem Rx-Pin (PD0) des Mikrocontrollers verbunden ist. Darüber lassen
sich vermutlich mit Hilfe einer seriellen Schnittstelle Daten in das Gerät übertragen. Der Tx-Pin war allerdings nicht verbunden, weshalb von einer unidirektionalen Verbindung auszugehen ist.
1Ich wurde darauf hingewiesen, dass es sich vermutlich um ein
AT24C128C handelt, welches 128 Kbit fasst.
Der schwierige Teil beim Reverse-Engineering der Laufschrift war, herauszufinden, wie die LEDs angesteuert werden. Mit dem Oszilloskop konnte ich 15 Pins ausmachen (B0-B7, C0-C3, D5-D7), die im Betrieb zyklisch ihre Pegel wechselten, also vermutlich für die LED-Ansteuerung benutzt wurden. Die Frage war, wie diese 15 Pins mit den 203 LEDs (7x29) verbunden waren. Eine klassische Zeilen-Spalten-Matrix schied aus, da sie für 203 LEDs mehr als 15 Pins benötigen würde. Das einzig denkbare war, dass die einzelnen LEDs jeweils direkt mit zwei Pins verbunden waren. Um sie individuell leuchten zu lassen, müsste der Pin an der Anode einen High-Pegel und der an der Kathode einen Low-Pegel ausgeben. Alle anderen Pins müssten dann in einen hochohmigen Zustand versetzt werden, um zu verhindern, dass die anderen LEDs leuchten. Da zwischen zwei Pins immer zwei LEDs antiparallel geschaltet sein können, ließen sich so mit 15 Pins bis zu 210 LEDs individuell ansteuern 15 x 14. Prinzipiell ist die Aufgabe nämlich die gleiche wie die bekannte Frage danach, wie oft angestoßen werden muss, wenn bei einer Gruppe von Personen auf einer Party jeder mit jedem einmal anstößt. Das ganze Verfahren wird übrigens auch Charlieplexing genannt. Herauszufinden, wie genau die LEDs mit den Pins verbunden waren, war allerdings eine aufwändigere Aufgabe.
Pinbelegung der LED-Matrix finden
Zunächst wurde der Controller mit einem Programmiergerät verbunden, so dass ihm eine individuelle Firmware verpasst werden konnte. Der Leseschutz des Controllers war aktiviert, so dass die alte Firmware dabei unwiederbringlich verloren ging. Zusätzlich wurde das Gerät über einen USB-Seriell-Wandler mit dem PC verbunden. Hierfür waren 3 zusätzliche Transistoren und einige Widerstände nötig, um eine Pegelanpassung zu erreichen. Der USB-Seriell-Wandler arbeitete nämlich mit 5 Volt, während der Controller nur mit 3 V betrieben wurde. Um die LEDs nicht zu überlasten, habe ich es vermieden, die Schaltung mit wesentlich mehr als 3 Volt zu versorgen. Beim Programmieren führte das zwischenzeitlich zu Problemen und der falschen Annahme, der Controller wäre kaputtgegangen, denn auch das Programmiergerät arbeitete mit 5-Volt-Pegeln. Aber ab einer Versorgungsspannung von ca. 3,2 Volt ließ sich der Controller zuverlässig programmieren. Nachdem alles verkabelt war, wurde eine kleine Firmware geschrieben, die via UART mit dem PC kommunizieren konnte und so auf dessen Befehl einzelne Pins auf definierte Pegel schaltete. Da nicht sicher war, ob die einzelnen LEDs einen dauerhaften Stromfluss aushalten würden, wurden die Pins immer nur für einige Mikrosekunden aktiv. Gleichzeitig wurde eine PC-Software mit Qt geschrieben, die die Kommunikation mit dem Controller vereinfachte und das Eintragen der Ergebnisse in eine Tabelle unterstützte. Die Zellen der Tabelle standen für die einzelnen LEDs der Matrix. Bei einem Doppelklick in eine Zelle vermerkte das Programm in dieser, welche Pinkombination gerade aktiv war. Diese konnte über zwei Einsteller ausgewählt werden. Die Ergebnisse wurden in eine Textdatei gespeichert und dann durch ein wenig Textersetzung und Formatierungsmakros in ein C-Array verwandelt. Dieses Array konnte etwas verkleinert werden, da sich herausstellte, dass immer zwei benachbarte Spalten der LED-Matrix dieselben Pins nutzen - natürlich mit vertauschter Polarität.
Programmierung der Laufschrift
Nachdem die Verschaltung der LEDs bekannt war, konnte eine eigene Firmware für die Laufschrift entwickelt werden. Es wurde ein Array erstellt, dessen Bits die einzelnen LEDs repräsentieren. Das Programm geht in einer
Endlosschleife durch dieses Array und lässt je nach Zustand der Bits die korrespondierenden LEDs kurz aufblitzen. Welche beiden Pins dafür in welche Zustände gebracht werden müssen,
kann das Programm aus dem zuvor erstellten Array auslesen. Nachdem die LED-Ansteuerung funktionierte, musste nur noch das Array mit sinnvollem Inhalt gefüllt werden. Im Internet fand sich schnell ein
7x5-Pixel großer Font, dessen einzelne Zeichen auch in einem Array gespeichert wurden. Wenn das Muster eines Zeichens aus diesem Array in das Displayarray kopiert wurde, erschien das entsprechende
Zeichen auf dem Display. Die scrollende Bewegung der Laufschrift ließ sich leicht realisieren, indem einfach das Displayarray spaltenweise nach links kopiert wurde. Das Displayarray wurde um die
Breite eines Zeichens (6 Spalten) größer gemacht, als es für die Referenzierung der einzelnen LEDs nötig wäre. In diesen "blinden" Bereich am hinteren Ende des Arrays wurden neue Zeichen kopiert, welche
dann beim Scrollen von rechts nach links in den sichtbaren Bereich wanderten. Die Laufgeschwindigkeit lässt sich durch Tastendrücke
beschleunigen und abbremsen. Für die Auswertung der Tasten musste lediglich der AD-Wandler auf den richtigen Kanal eingestellt und dann ausgewertet werden. Die Wertebereiche,
die zu den einzelnen Tasten gehören, ließen sich leicht anhand der Widerstandswerte berechnen. Das ganze Verfahren erwies sich als sehr zuverlässig.
Download der Tickermeldungen und speichern in das EEPROM
Wie bereits angekündigt wurde das EEPROM dann heruntergelötet und gegen ein größeres getauscht. Das größte, dass ich bekommen konnte, hatte eine Kapazität von 65536 Byte also 512-Kbit. Dies ist zugleich das Maximum an Speicher, das über eine 16-Bit-Adresse ansprechbar ist. EEPROMS mit I²C-Interface sind recht verbreitet und zumindest in der 24C-Serie von Atmel lassen sich alle Bausteine prinzipiell gleich ansteuern. Der Code dafür ist im Internet an vielen Orten zu finden, lässt sich aber auch verhältnismäßig einfach selbst schreiben. Gerade wenn man noch nie mit I²C gearbeitet hat, ist das Ansprechen eines seriellen EEPROMs eine gute Übung. Man kann dafür sowohl das dedizierte I²C-Modul des AVR nutzen, aber auch einfach zwei beliebige Pins nehmen und das Protokoll via Bit-Banging implementieren.Nachdem das EEPROM funktionierte und die Laufschrift die Zeichen aus dem EEPROM anzeigen konnte, ging es nur noch darum, diesen Speicher mit den Tickermeldungen zu füllen. Dafür wurde mit Qt ein kleines Webscraping-Tool erstellt. Wenn man auf der Postillion-Seite nach "Newsticker" sucht, bekommt man immer zahlreiche Tickermeldungen auf einmal angezeigt. Da diese immer von "++++" eingerahmt sind, lassen sie sich sehr einfach aus dem Text der Seite herauslesen. Nachdem ich alle Meldungen (7857) in einer Textdatei gespeichert hatte, wurden davon einige Hundert ausgewählt, die in den Speicher geschrieben werden sollten. Dafür wurde die Firmware soweit angepasst, das jedes Zeichen, dass über die serielle Schnittstelle empfangen wurde, in das EEPROM geschrieben wurde. Natürlich wurde nach jedem Schreiben die Adresse inkrementiert. Zum Schluss wurde ein Qt-Programm erstellt, das den Inhalt dieser Textdatei zeichenweise über die serielle Schnittstelle an das Gerät sendete. Dabei wurde zwischen jedem Zeichen eine Pause von 30 ms eingelegt, um dem Gerät genug Zeit für das Schreiben in das EEPROM zu geben. Zwischen den Meldungen wurde ein Zeilenumbruch-Zeichen ('\n') gesendet, welches von der Laufschrift automatisch durch "+++" ersetzt wird. Zum Schluss wurde ein 0-Zeichen übertragen, das das Gerät beim Erreichen dieses Zeichens dazu veranlasst, wieder von vorne anzufangen.
Abschluss und Fazit
Das Projekt hat nur wenige Abende in Anspruch genommen und das Ergebnis war absolut zufriedenstellend. Es war ein interessanter Mix aus Hardware-Bastelei und verschiedenen Bereichen des Programmierens erforderlich, wodurch die ganze Aufgabe sehr amüsant und abwechslungsreich war. Das Gerät wurde auch schon im "Feld" getestet und erzielte eindeutig die erhoffte Wirkung. Natürlich ist das Teil ziemlich albern, aber es ist ein lustiger Aufhänger, um mit fremden Leuten ins Gespräch zu kommen. Man könnte noch einige Zeit in den Feinschliff investieren, jedoch war das Ganze als schneller Hack geplant und der soll es auch bleiben. Zum Beispiel unterstützt das Gerät noch keine Umlaute, weshalb diese in dem Text mit den Meldungen durch ae, oe und ue ersetzt wurden. Prinzipiell lassen sich mit der Laufschrifft noch ganz andere Anzeigen realisieren weshalb, ich hier die Teile der Software veröffentliche, die für das Ansteuern des Displays nötig sind. Voraussetzung ist natürlich, dass die LED-Module noch eine Weile unverändert bei Ebay zu kaufen sind.