Ein Lauftext, bei dem man selber laufen muss


von Ralf Beesner.
Elektronik-Labor   Projekte   AVR 



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.
 


Elektronik-Labor   Projekte   AVR