Die Tasten-programmierbare Steuerung TPS
TPS 2: Der Programmiermodus
TPS 3: Rechnen mit Variablen
TPS 4: Sprünge und Verzweigungen
Mini-TPS mit ATmega8
Die
Idee ist einfach: Ein kleiner Steuercomputer soll ohne PC oder
Programmiergerät nur über ein paar Tasten programmiert werden
können. Der Befehlsvorrat soll so einfach sein, dass man ihn
im Kopf behalten kann um notfalls ganz ohne Unterlagen ein
Steuerprogramm zu entwickeln. Damit alles möglichst klein und
überschaubar ist, soll es ein 4-Bit-System werden. Es gibt vier
digitale Ausgänge, vier digitale Eingänge, intern
verarbeitete Daten haben eine Breite von vier Bit, und auch die Befehle
sind nur mit vier Bit kodiert, d.h. es gibt maximal 16 Befehle, die man
sich merken muss.
Bei der Programmeingabe hat man ein Display
aus vier LEDs, das abwechselnd Befehle und Daten anzeigen soll. Zur
Eingabe braucht man zwei Tasten. S1 dient zur Eingabe von Daten, S2 zum
Programmieren. Außerdem muss es noch eine Reset-Taste geben, mit
der man wahlweise das Programm startet oder den Programmiermodus
einschaltet.
Dieser kleine Steuercomputer kann ganz
unterschiedliche Aufgaben erfüllen, von der Alarmanlage bis zur
automatischen Akku-Ladestation oder zum Solarregler. Die Idee ist mir
im Urlaub gekommen. Ich hatte keinen PC dabei, aber so ein kleines
Platinchen passt in jede Reisetasche. Da könnte man mal dies und
das eintippen und dabei seinen Geist trainieren. Tipp, teripp, tiptipp,
schon ist ein kleines Reaktionsspiel programmiert. Oder man könnte
einen Programmierwettbewerb veranstalten, wer löst eine Aufgabe
mit den wenigsten Programmschritten...
Bisher gibt es nur die
Idee und eine grobe Aufstellung der wichtigsten Befehle. Etwas
ähnliches habe ich vor einiger Zeit schon einmal entwickelt: Den
Umwelt-Spion mit mehreren Sensoren und einer einfachen
Interpretersprache (Spion-Basic). Später kam dann noch der
Kosmos-Mikrocontroller mit seinem Kosmos-Basic. Beides waren
8-Bit-Systme, die über den PC programmiert werden mussten. Diesmal
will ich es noch einfacher halten, also nur vier Bit und direkte
Programmeingabe. Die ganze Entwicklung soll hier in allen Phasen
vorgestellt werden. Damit kann dann jeder noch seine eigenen Befehle
hinzufügen und das System an eigene Bedürfnisse anpassen.
Wie
fängt man am besten an? Man könnte natürlich erst mal
einen Controller nehmen, auf eine Lochrasterplatine setzen und mit den
nötigen drei Tastern und vier LEDs verbinden. Aber im Moment ist
noch nicht einmal klar, welcher Controller es am Ende werden soll.
Deshalb habe ich mich dafür entscheiden, die ersten Schritte auf
dem STK500 zu entwickeln. Zufällig war gerade ein ATmega168 in der
Fassung, mit dem wird jetzt erst mal gearbeitet. Und es sollen die
Tasten und die LEDs auf dem STK500 verwendet werden. Zwei Kabel
verbinden den Port D mit den LEDs. Verwendet wird D0 bis D4. Weil die
LEDs bei diesem System gegen VCC geschaltet sind, muss die Ausgabe in
dieser Entwicklungsphase invertiert werden.
Die Firmware soll
in Bascom entwickelt werden. Im ersten Schritt soll der Interpreter mit
nur drei Befehlen (Portausgabe, Wartezeit, Sprungbefehl) angefangen
werden. Den Programmiermodus gibt es noch nicht, aber dafür wird
das erste Miniprogramm mit nur fünf Programmschritten direkt ins
EEPROM geschrieben.
Die ersten drei Befehle lauten:
1: Direkte Portausgabe 0...15
2: Wartezeit 0...15
(1, 2, 5, 10, 20, 50, 100, 200, 500, 1000, 2000, 5000, 10000, 20000, 30000, 60000 ms)
3: Sprung zurück 0...15
Jeder
dieser Befehle hat direkt eingegebene 4-Bit-Daten. Zusammen mit den
Daten wird jeweils ein Byte belegt. In hexadezimaler Schreibweise
stellt daher das obere Nibble den Befehl und das untere die Daten dar.
Das erste Testprogramm erzeugt einen einfachen Wechselblinker:
&H11 Portausgabe 1
&H29 Wartezeit 1 s
&H18 Portausgabe 8
&H29 Wartezeit 1 s
&H34 Sprung 4 zurück
Download: TPS1
'--------------------------------------------------------------
' Tasten-programmierbare Steuerung TPS
' Test 1: Interpreter, die ersten drei Befehle
'--------------------------------------------------------------
$regfile = "m168def.dat"
$crystal = 11059200
$hwstack = 32
$swstack = 64
$framesize = 64
Dim Adr As Byte
Dim Eebyte As Byte
Dim Dat As Byte
Dim Kom As Byte
Ddrd = &HFF 'D0...D1 Outputs
Portd = &H0F 'STK500 invertiert
Portc = &H0F 'C0..C3 Inputs mit Pullup
S1 Alias Pinc.3 'Dateneingabe
S2 Alias Pinc.0 'Programmieren
Waitms 200
Dat = &H11 : Writeeeprom Dat , 0 'Dout=1
Dat = &H29 : Writeeeprom Dat , 1 '1000 ms
Dat = &H18 : Writeeeprom Dat , 2 'Dout=8
Dat = &H29 : Writeeeprom Dat , 3 '1000 ms
Dat = &H34 : Writeeeprom Dat , 4 'Adr = Adr - 4
Waitms 200
If S2 = 0 Then
Goto Programmieren
Else
Ausfuehren:
Adr = 0
Do
Readeeprom Eebyte , Adr
Adr = Adr + 1
Dat = Eebyte And 15
Kom = Eebyte / 16
If Kom = 1 Then '1: Direkte Portausgabe
Portd = 255 - Dat 'invertierte Portausgabe wegen STK500
End If
If Kom = 2 Then '2: Wartezeit
If Dat = 0 Then Waitms 1
If Dat = 1 Then Waitms 2
If Dat = 2 Then Waitms 5
If Dat = 3 Then Waitms 10
If Dat = 4 Then Waitms 20
If Dat = 5 Then Waitms 50
If Dat = 6 Then Waitms 100
If Dat = 7 Then Waitms 200
If Dat = 8 Then Waitms 500
If Dat = 9 Then Waitms 1000
If Dat = 10 Then Waitms 2000
If Dat = 11 Then Waitms 5000
If Dat = 12 Then Waitms 10000
If Dat = 13 Then Waitms 20000
If Dat = 14 Then Waitms 30000
If Dat = 15 Then Waitms 60000
End If
If Kom = 3 Then '3: Sprung - relativ
Adr = Adr - 1
Adr = Adr - Dat
End If
Loop
End If
Programmieren:
Do
Loop
End
Und
tatsächlich, es blinkt. Fertig ist der Mini-Interpreter mit nur
drei Befehlen. Damit kann man schon viele unterschiedliche Programme
schreiben, vom Lauflicht bis zur Schrittmotorsteuerung.
weiter
