C-Control als mobiles Programmiergerät

Die C-Control, insbesondere die M-Unit, eignet sich aufgrund ihrer kleinen Dimensionen und des geringen Energieverbrauchs vorzüglich für Mess- und Steueraufgaben im Feld (z.B. Wetterstationen). Nun ergibt sich bei solchen Anwendungen manchmal die Schwierigkeit, ein Software-Update im Feld durchzuführen. Dazu muss ein tragbarer PC mitgeschleppt werden, und wer schon mal sein Glück mit solchen Dingern abseits einer Steckdose versucht hat, weiß dass im entscheidendenden Augenblick die Batterien zumeist auf der Strecke bleiben. Daher haben sich schon mehrere Leute darüber Gedanken gemacht, wie ein mobiler Programmtransfer mit alternativen Mitteln durchgeführt werden kann. Im Download Bereich der C-Control Intern Sammlung von Dietmar Harlos (http://ccintern.dharlos.de) liegt z.B. die Software für einen TI92 Taschenrechner bereit, mit welcher diese Aufgabe bewerkstelligt werden kann. Wer allerdings kein solches Gerät besitzt, kann für einen mobilen Programmtransfer ganz einfach eine weitere C-Control benutzen.

Basierenden auf einigen Informationen aus der Sammlung "C-Control intern" von Dietmar Harlos habe ich ein kleines Programm geschrieben, welches die C-Control zum einen dazu befähigt, ein compiliertes Programm von der C-Control Programmierumgebung am PC zu übernehmen und zum anderen dann auch in die Lage versetzt, dieses übernommene Programm auf weitere C-Controls zu übertragen. Als Hardware sind dazu lediglich eine C-Control und zwei angeschlossene Taster erforderlich.

Zum besseren Verständnis des Programms hier noch einige grundlegende Informationen zur Programmübertragung vom PC an die C-Control:

Während sich die C-Control im "IDLE-LOOP" befindet, d.h. wenn sie mit Strom versorgt ist aber noch keine Programmausführung gestartet wurde, kann sie bestimmte Befehle über die serielle Schnittstelle empfangen und darauf reagieren. Wird z.B. &H01 an die C-Control gesandt, so gibt diese ihre Identität Preis und antwortet etwa: „CCTRL-BASIC Version 1.1 (20.12.96)“. Weitere Details zu diesen Befehlen findet Ihr in der erwähnten Informationssammlung „C-Control Intern“ von Dietmar Harlos.

Für unsere Zwecke ist der Befehl &H02 von vordergründiger Bedeutung, Wird dieses Byte an die C-Control gesandt, bereitet sich diese darauf vor, ein Programm zu empfangen und im externen, seriellen EEPROM abzulegen. Bei der Übertragung des Programms muss jedoch eine präzise Abfolge von Empfang und Quittierung von Bytes eingehalten werden, damit die Sache auch funktioniert. Und so sieht dieser Ablauf im Detail aus:

Der PC (C-Control IDE) sendet das Byte &H02 an die C-Control, worauf sich diese in freudiger Erwartung auf den Empfang einer neuen Software einstellt. Unmittelbar darauf sendet der PC noch ein zweites Byte, welches zusammen mit einem etwas später folgenden dritten Byte die Programmlänge des zu übertragenden Programms angibt. Handelt es sich beispielsweise um ein Programm von 2841 Bytes Länge, wird das zweite Byte &HB sein (und das etwas später folgende dritte Byte &H19), dezimal ausgedrückt wären das 11 und 25. Der Wert einer aus zwei Bytes bestehenden Zahl (Word) wird nämlich folgendermaßen ausgerechnet: Byte1 x 256 + Byte2, in diesem Falle 11 x 256 + 25 = 2841.

Nun aber wieder einen kleinen Schritt zurück, wird sind ja erst noch beim zweiten vom PC versandten Byte. Jetzt muss die C-Control reagieren und dem PC mitteilen, dass sie wach ist und darauf brennt, weitere Bytes von ihm in Empfang zu nehmen. Das macht sie, indem sie ganz einfach das letzte empfangene Byte erwidert, in diesem Falle also &HB an den PC zurückschickt. In überschwänglicher Freude schickt dieser dann sogleich das bereits erwähnte dritte Byte, das wie schon gesagt zusammen mit dem zweiten Byte die Länge des zu übertragenden Programms kennzeichnet. Nach diesem Vorspiel geht alles recht einfach: die C-Control quittiert den Empfang dieses dritten Bytes indem sie wiederum dasselbe Byte zurückschickt, und von jetzt an wird auf die gleiche Manier jedes einzelne Programmbyte vom PC an die C-Control gesandt und von dieser sogleich als Bestätigung zurückgeplappert. Ist die Prozedur durchstanden, sind sowohl PC als auch C-Control maßlos glücklich und ruhen sich erst mal ein wenig aus.

Und so wird die C-Control zum mobilen Programmiergerät:

Der ganze Zauber beruht darauf, dass die C-Control über zwei Taster entweder in den Empfangs- oder in den Übertragungsmodus versetzt wird. Im Empfangsmodus simuliert dann die C-Control genau dasselbe Verhalten, welches sie im „IDLE LOOP“ bei einer Programmübertragung aufweisen würde, und speichert alle eingehenden Bytes als Datei im externen EEPROM ab. Daraufhin kann die C-Control über ein serielles Verbindungskabel an eine andere C-Control angeschlossen werden, um diese zu programmieren. Ist die Verbindung hergestellt, wird über Taste 2 der Übertragungsmodus gestartet. Die C-Control simuliert nun die Programmierumgebung am PC, indem sie die einzelnen Bytes der in der im EEPROM verstauten Datei verschickt, und zwar genau nach dem oben beschriebenen Muster von Versand und Abwarten der Quittierung.

…und so etwa könnte das Programmiergerät aussehen…...passend für jede Hosentasche..

Anmerkungen:

Das unten angeführte Programm ist für das Zusammenspiel von C-Control und der DOS-Programmierumgebung abgestimmt. Unter der Windows-Programmierumgebung ist die Sache nämlich etwas verschieden. Dort beginnt das Vorspiel mit der Aufforderung des PC an die C-Control, sich erst mal auszuweisen (Befehl &H01). Erst wenn die C-Control brav geantwortet hat, beginnt dann die eigentliche Übertragungsprozedur. Also: zum Bespielen der C-Control als mobile Programmiereinheit die DOS-Entwicklungsumgebung benutzen (oder die Software unten entsprechend umschreiben). Übrigens gibt es auf der bereits zitierten "C-Control intern"-Internetsite (http://ccintern.dharlos.de) eine verbesserte DOS Entwicklungsumgebung („erweiterte DOS-IDE”) herunterzuladen, welche auch auf schnellen Rechnern fehlerlos läuft und auch sonst noch einige Verbesserungen aufweist.

NEU: weiter gibt es auf hundertfache Anfrage nun auch eine Programmversion für die Windows-Entwicklungsumgebung!

Hier die Software:

'************************************************************************

'Systemvorausstzungen: c-control mit 2 tastern

'taster1: funktion programm aufnehmen vom pc

'taster2: funktion programm uebertragen zu anderer c-control

'************************************************************************

define taster1 Port[1] 'Taster fuer Programmaufnahme

define taster2 Port[2] 'Taster fuer Programmuebergabe

define proglaenge word

define n word

define wert byte

define bytea byte

define byteb byte

#hauptschleife

if taster1 = OFF then goto einlesen

if taster2 = OFF then goto uebertragen

goto hauptschleife

#einlesen

open# for write

#einlesloop

wait rxd : get wert : print# wert

bytea=wert

put wert

wait rxd : get wert : print# wert

byteb = wert

proglaenge = bytea*256 + byteb

put wert

for n=1 to proglaenge

wait rxd : get wert : print# wert : put wert

next n

close#

end

#uebertragen

open# for read

input# wert

put wert

input# wert

put wert

bytea=wert

wait rxd : get wert

input# wert

put wert

byteb = wert

proglaenge = bytea*256 + byteb

wait rxd : get wert

#weiterauslesen

for n=1 to proglaenge

input# wert

put wert

wait rxd : get wert

next n

close#

end

Software II (Windows-IDE):

- Beim Überarbeiten der Software habe ich auch die Hardware vereinfacht und im Zuge allgemeiner Sparmaßnahmen einen Taster weggelassen. Dafür wurde das Gerät zur besseren Funktionskontrolle mit einer LED ausgestattet. Um das mobile Programmiergerät in den Aufzeichnungsmodus zu versetzen, muss beim Starten zeitgleich mit der Start-Taste auch die Funktionstaste gedrückt werden. Wird die Funktionstaste beim Starten nicht gedrückt, wird durch Drücken der Start-Taste der Übertragungsmodus gestartet.

Der Funktionsablauf sieht nun also folgendermaßen aus:

- Programmaufzeichnung (Übertragen eines Programms von PC auf das mobile Programmiergerät): Funktionstaste und Starttaste zeitgleich drücken. Die LED blinkt nun 3 Mal. Daraufhin kann von der C-Control Entwicklungsumgebung am PC die Übertragung der gewünschten Software gestartet werden (PC und mobiles Programmiergerät müssen natürlich durch den seriellen Kabel verbunden sein). Nach erfolgreicher Übertragung blinkt die LED 5 Mal.

- Programmübertragung (Übertragen eines Programms vom mobilen Programmiergerät auf eine andere C-Control): Programmiergerät mit der zu programmierenden C-Control verbinden und Start-Taste drücken. Die LED blinkt nun 4 Mal. Gleich darauf beginnt die Übertragung der „Huckepack“-Software auf die Ziel C-Control. Nach erfolgreicher Übertragung blinkt die LED 6 Mal.

…und so sieht das Ding nun wirklich aus...ergonomisch als M-Unit in einer Handcreme-Dose verpackt. Der Kabel mit den Krokodilklemmen dient zum Anschluss an eine Batterie. Die 3 Tasten: Funktionstaste, Start und Reset

Hier die Software für die Windows-IDE (läuft auch unter der DOS-IDE):

'************************************************************************

'Systemvorausstzungen: c-control mit 1 Taster und einer LED

'Zur Programmaufnahme Taster bei Start gedrückt halten, zur Programmübertragung nur die Start-Taste betätigen

'Version für DOS und Windows-IDE tauglich

'************************************************************************

define LED Port[1]

define taster Port[2]

define proglaenge word

define n word

define wert byte

define bytea byte

define byteb byte

define blink byte

pause 25

if taster = ON then goto uebertragen

#einlesen

blink=3

gosub blinken

open# for write

#einlesloop

wait rxd : get wert 'warten auf 001

if wert=&H01 then goto windows 'WINDOWS DOS IDE

print# wert

#weiter

wait rxd : get wert : print# wert

bytea=wert

put wert

wait rxd : get wert : print# wert

byteb = wert

proglaenge = bytea*256 + byteb

put wert

for n=1 to proglaenge

wait rxd : get wert : print# wert : put wert

next n

close#

blink=5

gosub blinken

end

#uebertragen

blink=4

gosub blinken

open# for read

input# wert

put wert

input# wert

put wert

bytea=wert

wait rxd : get wert

input# wert

put wert

byteb = wert

proglaenge = bytea*256 + byteb

wait rxd : get wert

#weiterauslesen

for n=1 to proglaenge

input# wert

put wert

wait rxd : get wert

next n

close#

blink=6

gosub blinken

end

#blinken

for n=1 to blink

led=on

pause 25

led=off

pause 25

next n

return

#windows

put &H43 'C

put &H54 'T

put &H52 'R

put &H4C 'L

put &H2D '

put &H42 'B

put &H41 'a

put &H53 's

put &H49 'i

put &H43 'c

put &H20 '

for n=1 to 23 'Hauptsache noch 23 irgendwelche Bytes

put &H43

next n

wait rxd : get wert : print# wert

goto weiter