Embedded Files
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
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 &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
Page updated
Google Sites
Report abuse