Ein Lauftext, bei dem man selber laufen muss
LEDs
an einen Mikrocontroller zu hängen und blinken zu lassen, finde
ich nicht sonderlich spannend. Außer, sie blinken sehr schnell
... Ich hatte vor längerer Zeit im Katalog eines
Elektronik-Versenders eine Warnleuchte gesehen, die mit einer LED-
Zeile das Wort
"HELP" in die Nacht schrieb, wenn man damit herumwedelte. Der
Schriftzug entstand also durch die Trägheit des Betrachter-Auges;
die Leuchte stellte in rascher Abfolge immer nur eine Spalte des
Schriftzuges dar. Das müsste man doch nachbauen können
.....
Erste Versuche
Im Web fand ich unter
www.zipfelmaus.com/led-flitzer eine recht aufwendige Lösung mit
einem ATmega8, einem Beschleunigungssensor und einem USB-Seriell-Chip.
Das kryptische C-Gelumpe habe ich erst gar nicht zu verstehen versucht
;-) Allerdings gab es eine Headerdatei font.h, welche die
Buchstabenmatrix enthielt, und die habe ich mir ausgeliehen und in
Data- Zeilen umgebaut. Die Kernkomponente - das Zerlegen des Strings in
Einzelbuchstaben und die spaltenweise Darstellung auf der LED- Zeile -
ließ sich sehr einfach in Basic programmieren.
Die
verwendete Hardware war zunächst ein ATtiny24 im 14-poligen DIL-
Gehäuse, den ich noch herumliegen hatte (eigentlich finde ich den
schön, weil er deutlich mehr IOs hat als die "8-Beiner", aber noch
recht kompakt ist und sich auf Lochraster-Platinen gut verarbeiten
lässt. Aber kein Mensch baut mit den Dingern, und wer weiss,
wie lange es die noch bei Reichelt gibt).
An
Port A hingen 8
LEDs mit Vorwiderständen, und an PB2 ein Starttaster, der
den Low- Tech- Ersatz für den Beschleunigungssensor bilden sollte.
Die 8*5 - Schrift schien mir sehr "fett" in der Darstellung, weil die
Buchstaben-Elemente immer 2 LEDs breit waren, und das Programm war nur
600 Bytes gross. Damit lag eine ATtiny13- Lösung in "Reichweite".
Ich habe daher die Data- Zeilen für eine 5*5 - Darstellung
umgebaut und die Anwendung auf den ATtiny13 portiert.
Attiny13-Lösungen
Alle
5 Ports des Attiny 13 sind mit LEDs plus Vorwiderständen
beschaltet. Als Starttaster muss daher mal wieder der Reset-Taster
herhalten. Das Programm läuft nach einem Reset nur ein mal durch;
dann wird der Mikrocontroller in den Powerdown geschickt und wacht erst
durch einen Reset wieder auf. Man muss also das Gerät von
rechts nach links bewegen, zu Beginn kurz den Reset antippen, und nach
100 msec ( in denen man Arm und Gerät beschleunigt hat) läuft
dann die Ausgabe des Strings ein mal ab.
Um
die Anforderungen an die Feinmotorik etwas zu senken, ist der Reset-
Taster über einen Hochpass an den Reset-Eingang angeschlossen.
Eigentlich würde der Reset- Zustand erst beendet, wenn man den
Taster loslässt, aber dank des Hochpasses kann man den Resetknopf
während der gesamten Bewegung gedrückt halten.
Die
Schaltung ist auf Streifenraster-Platine aufgebaut und kann auf die
Rückseite eines Halters für 3 Mignonzellen geschraubt werden,
wenn man keine Lithium- Batterie bzw. keinen Mini-Akku verwenden
möchte. Die Leuchtdioden sind abgewinkelt, damit sie in Richtung
der Schmalseite strahlen.
Das Programm besteht aus nur 2 Schleifen; die äußere fischt die
Einzelbuchstaben aus dem String, die innere sorgt für die spaltenweise
Darstellung des Buchstabens.
T13-lauftext-2.bas
stellt einen festen Einzeltext dar. Da mein Arm zu kurz für
längere Texte ist, habe ich in der Version T13-lauftext3.bas
mehrere Texte angelegt, zwischen denen nach jedem Reset zyklisch
umgeschaltet wird. Da ich nur grüne LEDs hatte und
grün die Vereinsfarbe des hiesigen zur Zeit recht
erfolglosen) Kickervereins ist, habe ich den Text zwei
fußballverrückten Kollegen gewidmet ;-)
Download: Quelltexte und Hexfiles (Update 6.3.11) : Lauftext.zip
'
' Lauftext, bei dem man selber laufen muss ;-)
'
' Start durch Reset- Taster
' LED- Zeile aus 5 LEDs mit je 150 Ohm Vorwiderstand an PB0 bis PB4
' die Buchstaben werden in einer Matrix 5*5 dargestellt.
' die Text- Darstellung entsteht, wenn man die LED- Zeile schnell bewegt
'
'----------------------------------------------------------
$regfile = "attiny13.dat"
$crystal = 1200000
$hwstack = 32
$swstack = 8
$framesize = 0
Acsr.acd = 1 ' Analogen Komparator ausschalten
Ddrb = &B0001_1111 ' alle Ports Ausgänge
Portb = &B0000_0000 ' alle Ports 0
Enable Interrupts
Dim Leuchtstring As String * 14 ' String darf max. 13 Zeichen lang sein
Dim Leuchtzeichen As String * 1
Dim Leuchtbyte As Byte At Leuchtzeichen Overlay
Dim Leuchtspalte As Byte
Dim N As Byte
Dim M As Byte
Const T1 = 8 ' Blinkdauer pro Spalte
Const T2 = 5 * T1 ' Zeitdauer für ein Leerzeichen (ASCII 32)
Const T3 = 1 * T1 ' etwas Abstand zwischen den Einzelzeichen
Leuchtstring = "BREMEN" ' darzustellender Textstring
'----------------------------------------------------------
Do
Waitms 100
For N = 1 To Len(leuchtstring)
Leuchtzeichen = Mid(leuchtstring , N , 1)
' Leuchtbyte = Asc(leuchtzeichen) ' auskommentiert, weil durch Overlay- Variable ersetzt
If Leuchtbyte = 32 Then ' Leerzeichen -> 40 msec Nichtstun
Portb = 0
Waitms T2
Goto Leer
End If
Leuchtbyte = Leuchtbyte - 64 ' Ascii- Grossbuchstaben beginnen bei 65
Leuchtbyte = Leuchtbyte * 5 ' Buchstabenbeginn jeweils bei jeder 5. Data- Zeile
For M = 1 To 5 ' Buchstaben spaltenweise darstellem
Leuchtspalte = Lookup(leuchtbyte , Bitmatrix)
Portb = Leuchtspalte
Leuchtbyte = Leuchtbyte + 1 ' nächste Data- Zeile ansteuern
Waitms T1
Next M
Portb = 0
Waitms T3
Leer:
Next N
Powerdown
Loop
'----------------------------------------------------------
Bitmatrix:
' (@ : Test - ergibt fallende Treppe)
' Data &B00001
' Data &B00010
' Data &B00100
' Data &B01000
' Data &B10000
' (@ : Test - ergibt Punkt)
Data &B01100
Data &B01100
Data &B00000
Data &B00000
Data &B00000
'A:
Data &B11000
Data &B00110
Data &B00101
Data &B00110
Data &B11000
'B:
Data &B11111
Data &B10101
Data &B10101
Data &B01010
Data &B00000
'C:
Data &B01110
Data &B10001
Data &B10001
Data &B10001
Data &B00000
'D:
Data &B11111
Data &B10001
Data &B10001
Data &B01110
Data &B00000
'E:
Data &B11111
Data &B10101
Data &B10101
Data &B10101
Data &B00000
'F:
Data &B11111
Data &B00101
Data &B00101
Data &B00101
Data &B00000
'G:
Data &B01110
Data &B10001
Data &B10100
Data &B01100
Data &B00000
'H:
Data &B11111
Data &B00100
Data &B00100
Data &B11111
Data &B00000
'I:
Data &B00000
Data &B11111
Data &B00000
Data &B00000
Data &B00000
'J:
Data &B10000
Data &B10000
Data &B01111
Data &B00000
Data &B00000
'K:
Data &B11111
Data &B00100
Data &B01010
Data &B10001
Data &B00000
'L:
Data &B11111
Data &B10000
Data &B10000
Data &B10000
Data &B00000
'M:
Data &B11111
Data &B00010
Data &B00100
Data &B00010
Data &B11111
'N:
Data &B11111
Data &B00010
Data &B00100
Data &B01000
Data &B11111
'O:
Data &B01110
Data &B10001
Data &B10001
Data &B01110
Data &B00000
'P:
Data &B11111
Data &B00101
Data &B00101
Data &B00010
Data &B00000
'Q:
Data &B01110
Data &B10001
Data &B11001
Data &B11110
Data &B00000
'R:
Data &B11111
Data &B00101
Data &B01101
Data &B10010
Data &B00000
'S:
Data &B10011
Data &B10101
Data &B10101
Data &B01001
Data &B00000
'T:
Data &B00001
Data &B00001
Data &B11111
Data &B00001
Data &B00001
'U:
Data &B01111
Data &B10000
Data &B10000
Data &B01111
Data &B00000
'V:
Data &B00011
Data &B01000
Data &B10000
Data &B01000
Data &B00011
'W:
Data &B00111
Data &B11000
Data &B00111
Data &B11000
Data &B00111
'X:
Data &B10001
Data &B01010
Data &B00100
Data &B01010
Data &B10001
'Y:
Data &B00011
Data &B00100
Data &B10000
Data &B00100
Data &B00011
'Z:
Data &B10001
Data &B11001
Data &B10101
Data &B10011
Data &B00000
Erweiterung mit einem Trägheitschalter, von Paul Preuß
Der
LED-Lauftext hat mir so gut gefallen, dass ich ihn gleich
nachbauen musste. Und mir kam auch gleich eine Anwendung in den
Sinn. Dafür musste der
Text aber über längere Zeit stabil angezeigt werden, was mit
der einfachen
Lösung nur mit Timings einfach nicht funktionieren wollte. Das
heißt, so lange
man das Gerät hin und her wackelt sollte der Text angezeigt
werden.
Daher habe
ich mir einen einfachen Schalter gebaut, der immer am Umkehrpunkt einen
Pin des Prozessor nach Masse zeiht. Daher weiß er wann er den Text ausgeben
muss. Der Schalter besteht aus einem einseitig geschlossenen Messingröhrchen
mit einer Kugellagerkugel darin. An der offenen Seite des Röhrchen ist ein
Blech mit geringem Abstand eingelötet. Wenn die Kugel, durch die Trägheit, auf
das Blech kracht werden Röhrchen und Blech elektrisch miteinander verbunden.
Damit es funktioniert, muss die Laufrichtung der Kugel natürlich senkrecht
zur LED-Zeile stehen. Um den Schalter zu entprellen, braucht man die
Abfrage des Selben nur sinnvoll in den Quelltext einzubinden.
Pseudocode:
MainLoop
{
loop1:
Schalter geschlossen?
nein-> goto loop1
delayms(50)
Text ausgeben
loop2:
Schalter geöffnet?
nein-> goto loop2
}
Das
delayms(50) braucht man, um das Gerät wieder zu beschleunigen, sonst wird statt
des ersten Zeichens nur ein Strich dargestellt. Das ganze funktioniert wirklich
sehr gut und wenn man das richtige "Armtiming" raus hat, steht
der Text wie angenagelt.
Ein Problem
gibt es natürlich. Man braucht einen zusätzlichen Einganspin. Man kann,
entsprechendes Programmiergerät vorausgesetzt, den Reset-Pin deaktivieren und
als Eingang nehmen, oder man muss leider einen Prozessor mit mehr I/O's
benutzen.
Neigungschalter-Ergänzung von Ralf Beesner
Ich
hatte einen runden Conrad- Neigungsschalter (Best- Nr. 700444-62) und
einen rechteckigen (Best-Nr. 185258-62) in der Junkbox. Der runde ist
fast genauso aufgebaut wie der pfiffige Selbstbau- Rollkugelschalter
von Paul Preuß (der rechteckige Conrad- Schalter ist nicht so gut
geeignet).
Nach meinem Eindruck ist es allerdings
unnötig, den Reseteingang "wegzuflashen" und sich damit aus dem
Controller "auszusperren". Ich habe den Neigungsschalter einfach
parallel zum Resettaster gelötet. Das Kontaktprellen löst
zwar Mehrfach- Resets aus, aber das ist unschädlich. Ist der
Schalter dauernd geschlossen (wenn die Platine auf dem Rücken
liegt), sorgt der Hochpass dafür, dass kein Dauerreset
ausgelöst wird; der Controller geht trotzdem in Powerdown; es
fließt lediglich ein kleiner Strom von ca. 100 µA über
den 47 kOhm- Widerstand R7.
Der Neigungsschalter ist bewusst
schräg eingelötet, damit eine gewisse Mindestbeschleunigung
erforderlich wird, die die Kugel "bergauf" treiben muss. Da ich damit
etwas schneller wedele als beim händischen Auslösen des
Resets, wird die Schrift zu sehr in die Länge gezogen. Ich habe
daher die Konstante T1 von 8 ms auf 4 ms herabgesetzt.
Ein weiterer Nachbautip:
Die
meisten Leuchtdioden haben einen recht geringen Öffnungswinkel -
wenn die LEDs beim "Wedeln" nicht genau auf den Betrachter ausgerichtet
sind, führt das zu störenden Helligkeitsschwankungen. Sehr
gut geeignet sind rote diffuse 3mm-OSRAM- LEDs 3386
(Reichelt-Bestell-Nr. LS 3386); sie weisen einen Öffnungswinkel
von 100 Grad auf. Außerdem sollte man die LEDs so montieren, dass
sie nicht über den Platinenrand hinausragen, dann sind sie besser
gegen Verbiegen geschützt.