Download
Aktuelle Release V5.0: TurboLocator-Setup-latest.exe
(1.2 MB). Das TurboLocator Demo mit 8k Code-Größenlimit ist Freeware. Feedback an
feedback@xellsoft.com.
Setup
Das Setup des Turbo-Locator Installers ist weitgehend selbsterklärend.
Nach dem Start des Programms kann der erste Lokator-Lauf an dem
Beispiel-EXE hellolcd.exe durchgeführt werden. Funktioniert dies, so ist
das Setup erfolgreich durchgeführt.
Code Beispiele und die System-Bibliothek sind im Sys.LIB-ZIP-File über
entsprechenden Windows-Start-Menü-Eintrag nach der Installation erreichbar.
Handbuch
Einführung
Der TurboLocator ist eine Entwicklungssoftware, um
den Output von wohlerprobten Borland 16bit PC Compilern (TurboPascal,
Turbo C++, TASM, ..) auf x86 basierende Embedded Rechner und Raw PC
Umgebungen zu übertragen, in den kein Betriebssystem (DOS) vorhanden ist.
Viel Wert wurde auf ein Softwarekonzept gelegt, das
eine zügige, unkomplizierte und dennoch anspruchsvolle
Anwendungsentwicklung ohne lange Einarbeitungszeit erlaubt. Es besteht die
Möglichkeit, auf der einen Seite sowohl modernste Programmiertechniken (OOP),
als auch auf der anderen Seite Assemblerprogrammierung für höchste
Geschwindigkeitsanforderungen einzusetzen. Ein einfaches aber effektives
Echtzeit-Multitaskingsystem (TurboTASK) erlaubt die Entwirrung komplexer
paralleler Abläufe in x86-Embedded-Umgebungen. Zahlreiche
System-Bibliotheken stehen zur Verfügung.
Als Beispiel-Rechner ist im folgenden oftmals der MT25
Messtechnikrechner (basierend auf NEC V25) angenommen. Die
Systembibliothek für den MT25 ist ebenfalls im Lieferumfang der Software
enthalten (Installations-Menü "System Library") und viele Teile
davon können in beliebigen x86-Umgebungen verwendet werden.
Prinzipielles Vorgehen einer
Programm-Lokation mit dem Turbo-Locator:
-
Erstellen der Software
mit einem der genannten Borland Compiler. Erzeugung eine EXE-Files.
Dabei ggf. Einbindung des speziellen Embedded Start-Codes c0x.obj
aus der mitgelieferten System-Bibliothek, oder ein für das jeweilige
System angepassten Start-Code (bei den Borland C-Compilern ist der
Start-Code für ggf. notwendige Anpassungen mitgeliefert.
-
Der eigentliche
TurboLocator-Lauf: Anwenden von EXELOC.EXE auf das EXE-File (+ggf.
MAP-File). Dies kann sowohl über Commandline (Syntax s.u.) oder über
das bequeme WinMT-GUI durchgeführt werden.
-
Bei ROM-Code: Brennen
des entstandenen BIN- oder HEX-Files.
Bei RAM-Code: Download des DLF-Files an den MTxx - Rechner oder den
jeweiligen Zielrechner mit DLX / WinMT
Bei FLASH-Code: Download des FSH-Files mit DLX / WinMT in den
Ziel-Rechner
Der
Locator EXELOC wandelt ein fertig compiliertes und gelinktes Programm, das
mit den Compilern TurboC/BorlandC, TurboPascal, TurboAssembler erstellt
wurde, in eine EPROM- oder eine download-fähige Datei um. Um diese
Aufgabe auszuführen, benötigt EXELOC neben der EXE-Datei des Programmes
zusätzlich die MAP-Datei, die beim Link-Vorgang erzeugt wird. Die
Erzeugung der MAP-Datei wird je nach Compiler folgendermaßen veranlaßt:
TC/BC-
und TurboPascal-IDE:
Der Schalter Options/Linker/Mapfile muß zumindest auf Segments
stehen.
TurboPascal
Kommandozeile (TPC.EXE):
Der Parameter /GD muß
angegeben werden
Kommandozeile
C/C++ oder reine Assembler-Programme:
Beim Linkvorgang mit dem TurboLinker TLINK
darf der Parameter /x zur
Unterdrückung der MapDatei nicht angegeben werden. Der Parameter /m
für ausführliche Map-Datei ist natürlich zulässig.
EXELOC erkennt automatisch
den Compilertyp und behandelt die EXE-Datei entsprechend.
Anhand
von Beispielen wird nun der Umgang mit EXELOC erklärt. Vorausgesetzt wird
dabei ein bereits fertiggestelltes Programm TEST.EXE (+TEST.MAP). Ein
solches Programm ist z.B. im Verzeichnis SysLib\MT25\PAS\EXAMPLES\
vorbereitet.
Das einfachste Beispiel
eines EXELOC-Aufrufes ist:
EXELOC TEST
(TEST.EXE
sei z.B. ein Turbo-Pascal-Programm)
Dazu muß
EXELOC.EXE im MSDOS-Pfad liegen und die Dateien TEST.EXE und TEST.MAP im
aktuellen Verzeichnis. EXELOC wandelt die Datei TEST.EXE in die download-fähige
Datei TEST.DLF um. Diese Datei kann dann über die serielle Schnittstelle
in den x86/MT25-Computer geladen, und direkt aus dem RAM ausgeführt
werden. Durch den EXELOC-Lauf werden auch die RAM/EPROM-Spezifikationen
festgelegt. Sind - wie in diesem Beispiel - keine Optionen angegeben, so
geht EXELOC von folgenden Defaulteinstellungen aus:
Ziel-Datei-Typ:
Downloadfähige Datei (Endung .DLF)
EPROM-Größe:
32K
(hier nicht benutzt, da Download)
RAM-Größe:
32K
Startsegment
für Programm
und
Daten im RAM:
0040H
Weiter
nimmt EXELOC als Default-Einstellung an, daß das RAM im unteren
Speicherbereich von 00000H bis maximal 7FFFFH liegt und das EPROM im
oberen Speicherbereich FFFFFH bis minimal 80000H, wobei der Reset-Vektor
bei FFFFH:0000H liegt. Diese Werte passen automatisch für den
MT25-Rechner. Für andere Zielumgebungen muss man ggf. anpassen.
Ist der
EXELOC-Vorgang erfolgreich verlaufen, so erscheint folgende Ausgabe:
C:\MT25\PAS\EXAMPLES>EXELOC
TEST
EXELOC
V2.0 TC++/BC++/TPascal
Relocator for x86/NECVxx
relocating
file TEST.EXE -> TEST.DLF
(Binary)
RAM
Size 32K
Source
is TPascal...
Code
and Data segments start at
0040H (para)
Code
length (bytes):
3040
Code
+ const data length (bytes):
3120 (required
eprom size)
Data
+ min.stack lenght (bytes):
4784 (min.
RAM size in eprom applic.)
Stack
length (bytes):
4096
Remaining
heap length (bytes):
23920
EXE-file
relocation OK
Wichtig sind vor allem die
Informationen zu "required eprom size" und "min. RAM size
in eprom applic.", um zu bestimmen, welche Speichergrößen mindest
erforderlich ist, um das fertige Programm vom EPROM aus ablaufen zu
lassen. "Remaining heap length" gibt an, wieviel Speicher bei
der vorgegebenen RAM-Größe auf dem Heap dynamisch allokiert werden können.
Die erste
Einstellung, die bei der Zunahme des Programmcodes durchgeführt werden muß,
ist die Anpassung der RAM-Größe. Dies erfolgt mittels des Parameters /RAMSIZE
(Groß-/Kleinschreibung und Abfolge der Parameter und Argumente spielt
keine Rolle):
EXELOC demoA /ramsize:128
Jetzt
geht EXELOC von einer RAM-Größe von 128KB aus. Die maximal wählbare
RAM-Größe ist 512K. Reicht die angegebene RAM-Größe für Programm und
Daten nicht aus, so erzeugt EXELOC eine entsprechende Fehlermeldung.
Achtung:
Ist die angegebene RAM-Größe größer als die tatsächliche,
ist ein Programm-Absturz sicher. Umgekehrt gibt es keine Probleme, außer,
daß das "verschwiegene" RAM nicht als Heap genutzt werden kann.
Ist das
Programm nun ausgereift, so kann es in ein EPROM abgelegt werden. Dazu muß
es auf andere Weise reloziert werden, damit der Code, die Konstanten und
die initialisierten Daten (bei C/C++) im EPROM, die nicht initialisierten
und (bei C/C++) die Kopien der initialisierten Daten dagegen im RAM
plaziert werden. Die Relokationsart wird mit dem Parameter /ROM auf
EPROM gewechselt. z.B.:
EXELOC TEST /ROM /romsize:64 /ramsize:8
In diesem
Beispiel wurden gleichzeitig die RAM-Größe auf 8K reduziert (reicht bei
vielen EPROM-Anwendungen aus), und die EPROM-Größe mittels des
Parameters /ROMSIZE auf 64K erhöht (maximal sind auch hier 512K möglich).
Es
entsteht diesmal die Datei TEST.BIN. Dies ist eine Binärdatei, die von
vielen PC-basierenden EPROM-Programiergeräten wie z.B. SEP-81, ALL-03A,
EPROP verwertet werden kann. Diese Datei hat bereits die angegeben EPROM-Länge,
und kann 1:1 in ein EPROM übertragen werden. Der ResetVektor (JMP
FFFF:FFF0, der nach Reset zum Code-Start springt) wird automatisch
entsprechend der angegebenen EPROM-Größe generiert.
Wird
statt einer 1:1-Binärdatei eine Intel-HEX-Datei gewünscht, die praktisch
alle EPROM-Programmiergeräte lesen können (auch Programmiergeräte, die
über serielle Schnittstelle angeschlossen werden), so muß zusätzlich
die Option /HEX angegeben werden. Intel-HEX-Dateien sind länger als die
Binärdateien, und benötigen mehr Speicher auf der Festplatte.
Im folgenden sind alle
bereits beschriebenen und weiter noch möglichen Optionen aufgelistet.
Diese werden auch beim Aufruf von EXELOC ohne Argument "Online"
dargestellt.
Die Syntax von EXELOC ist folgende:
EXELOC exename [destination]
[options]
options:
/ROM:
ROM-fähiger Code ( BIN- oder Intel-HEX-Datei ) wird erzeugt.
/ROMSIZE: ROM-Größe wird auf bestimmten Wert (in kByte) gesetzt
/RAMSIZE: RAM-Größe wird auf bestimmten Wert (in kByte) gesetzt
/ROMX :
ResetVektor wird nicht erzeugt; BIN-File-Länge =Länge des Codes;
dadurch können mehrere verschiedene Programme in ein EPROM geladen
werden, oder ein Programm auf mehrere EPROMs verteilt werden.
/HEX: Intel-HEX-Datei wird erzeugt
/DLD: Download-File wird generiert (Default-Einstellung)
/C: Der Code-Start wird an vorgegebner Stelle erzwungen; sinnvoll bei
von MT25 abweichender
Speicherkonfiguration (nur Experten sollten diese Option verwenden)
/D: Der Data-Start wird an angegeb. Pos. erzwungen (nur Experten
sollten diese Option verwenden)
/V: verbose report: detaillierte Information über
Relocations-Prozess für den Experten.
Anmerkungen:
-
Die Endung .EXE muß bei exename nicht angegeben werden
-
Wird destination nicht
angegeben, wird hierfür der Hauptname des EXE-Files plus Endung .DLF,
bzw. .BIN oder .HEX angenommen
-
Alle Fehlermeldungen von EXELOC erfolgen im Klartext
Detail-Dokumentation
zur Embedded x86 Programmentwicklung mit TurboLocator
4.1.
x86 Embedded-
Programmentwicklung
Ein Programm, das auf einem V25-Singlechip-Rechner läuft,
hat im Unterschied zu einem PC-Programm kein DOS oder BIOS unter sich. Das
V25-Programm kann auch nicht auf die vom DOS her bekannte Weise aufgerufen
und in den Speicher geladen werden.
Um dennoch ein Programm für
den Embedded Rechner wie den MT25 mit einem professionellen PC-Compiler
entwickeln zu können, bedarf es also einer Anpassung, um ein solches
Programm EPROM- oder download‑fähig zu machen. Diese Aufgabe übernimmt
das MT25-Entwicklungspaket.
Wie man ein EXE-Programm so
umwandelt, daß es in den EPROM- oder RAM-Speicher des MT25 geladen werden
kann, wird im Kapitel 3 bei der Bedienung des Programmes EXELOC gezeigt.
Aber auch bei der Erstellung
dieses EXE-Programms muß der Programmierer auf das fehlende DOS bzw. BIOS
Rücksicht nehmen. Die Besonderheiten der V25-Programmierung gegenüber
der DOS-Programmierung werden im folgenden für die einzelnen Compiler
beschrieben. Darüber hinaus aber läuft die Programmentwicklung genauso
ab, wie bei der Erstellung eines DOS-Programms gewohnt. Alle Tools,
vorhandene Librarys, usw. können - soweit auf dem Controller sinnvoll -
benutzt werden.
4.2.
Programmentwicklung in TurboPascal
4.2.1.
Einleitung
Die Erstellung eines V25-Programmes mit Turbo Pascal
ist durch die einfache Struktur von Turbo Pascal in vieler Hinsicht
einfacher als in C/C++.
Von den mit Turbo Pascal
mitgelieferten Units kann nur die
System-Unit benutzt werden, die automatisch in jedes Turbo Pascal
Programm eingebunden wird. Die Funktion der Units CRT, DOS, usw. benutzen
DOS/BIOS-Funktionen, die auf dem V25 nicht verfügbar sind und ohnehin
sinnlos wären (Dateiverwaltung, PC-Tastatur, Videokartenfunktionen).
Diese Units dürfen auch nicht eingebunden werden, da bereits bei
Inititialisierung der Units I/O- bzw. DOS /BIOS- Zugriffe erfolgen.
Die objektorientierten
Erweiterungen von Turbo Pascal können ohne Einschränkungen benutzt
werden.
4.2.2.
Compilereinstellungen
Die meisten Optionseinstellungen können, wie auch
unter DOS, je nach Sachlage angepaßt werden. Die im folgenden aufgeführten
Optionseinstellungen sind jedoch bei der V25-Programmierung besonders zu
beachten, und sollten so gesetzt werden wie angegeben. Hier werden die
Schalterangaben für Turbo Pascal 6.0 beschrieben. Für andere Versionen
von Turbo Pascal können die Schaltereinstellungen leicht abweichen oder
die Schalter in anderen Menüs plaziert sein.
IDE-Compiler-Einstellungen:
|
Schalter
|
Einstellung
|
Anmerkung
|
|
Compile/Destination
|
Disk
|
EXE-File muß für
Weiterverarbeitung vorliegen
|
|
Options/Compiler/Numeric processing
|
Emulation=on, 80x87=off
|
Emulator einschalten, da keine FPU im V25
|
|
Options/Compiler/286-Instructions
|
on
|
V25 versteht alle 286-Maschinenbefehle (Real-Mode)
|
|
Options/Compiler/Runtime errors/I/O-Checking
|
off
|
|
|
Options/Compiler/Runtime errors/Range check
|
off
|
nur bei eigenem installierten Error-Handler sinnvoll
|
|
Options/Compiler/Runtime errors/Stack check
|
off
|
nur bei eigenem installierten Error-Handler sinnvoll
|
|
Options/Compiler/Debugging
|
alles off
|
Debug-Information im MT25-RAM/ROM sinnlos; wird aber
notfalls auch von EXELOC weggeschnitten;
|
|
Options/Memory sizes/Stack
size
|
evtl. auf 4K verringern
|
die 16K-Einstellung für DOS
ist meist Verschwendung
|
|
Options/Linker/mapfile
|
mindestens "segments"
|
auch "public" und
"detailed" können gewählt werden
|
|
Options/Debugger/Debugging/Standalone
|
off
|
Debug-Information im MT25-RAM/ROM sinnlos; wird aber
notfalls auch von EXELOC weggeschnitten;
|
|
Options/Directories/Unit
directories
|
um \MT25\PAS\TPU ergänzen
|
MT25-Units müssen gefunden
werden
|
|
Options/Directories/Object
directories
|
um \MT25\PAS\TPU ergänzen
|
OBJ-Dateien für MT25-Units
müssen gefunden werden
|
Anmerkungen:
um in einer Umgebung mit anderen TurboPascal-Projekten die Ordung
zu wahren, ist es empfehlenswert, in Projektverzeichnissen eigene TURBO.TP
und TURBO.DSK-Dateien anzulegen (bei Option/Save options das aktuelle
Verzeichnis angeben), sodaß andere Turbo Pascal-Projekte nicht von den
V25-Einstellungen betroffen werden.
bei Turbo/Borland-Pascal 7.0 (oder höher) muß als Zielplatform Real Mode
verwendet werden. Der Protected Mode ist auf dem V25 nicht verfügbar.
4.2.3.
Das erste Programm
Jedes Programm für den V25 benötigt gewisse
V25-Grundfunktion und -Definitionen. Diese sind in der Unit SYSV25
enthalten, die über das "uses"-Kommando
eingebunden wird. Die Unit SYSV25 befindet sich, wie alle anderen
MT25-Units, im Verzeichnis \MT25\PAS\TPU und wird automatisch von der IDE
gefunden, sofern die oben beschriebenen Directory-Einträge ergänzt
wurden. Diese Unit liegt als PAS-File im Source-Code (mit Ausnahme des
Assembler-Object-Modules) vor.
Die Unit SYSV25 enthält folgende Elemente:
Memory-Definitionen der V25-special-function-register (SFR);
Die Bedeutung der einzelnen Register wird im NEC-V25 Handbuch genau erklärt.
Mit Ausnahme der I/O Port-Register P0, P1, P2, PT, deren Benutzung in
mehreren Beispielen in diesem Handbuch erklärt wird, werden die SFR
jedoch von der MT25-Systemlibrary verwaltet, sodaß der Programmier sich
nur bei der Benutzung spezieller Features mit den SFR befassen muß.
die Prozeduren RL_setIntVec und RL_getIntVec zum Setzen von
Interrupt-Vektoren ( die Prozeduren setIntVec und getIntVec aus der
TP-Unit DOS sind nicht verwendbar (s.o.) )
Definitionen der speziellen V25-Interrupt-Nummern (siehe hierzu
Kapitel über Interrupt-Programmierung)
einige Spezial-Befehle des V25 sowie oft benötigte Abkürzungs-Befehle
wie FINT, BSET, BCLR, CLI, STI
grundlegende Prozeduren für die Prozessoreinstellung und
Systemzeitverwaltung wie RL_initTCPorts, RL_fullSpeed, RL_SysClock,
RL_wait
Prozeduren, welche die spätere nahtlose Einbindung des TurboTASK-Multitasking-Systems
ermöglichen, wie RL_setMTSWVect, MT_yield
einen Standard-ExitProc-Handler, welcher bei irregulärem
Programmabbruch die LED1 (unterhalb der CPU) blinken läßt; dieser wird
automatisch bei Initialisierung der Unit gesetzt
Mit der
SYSV25-Unit kann bereits ein erstes MT25-Programm geschrieben
werden.
Der Hauptausgabeport
P0 wird mit dem Muster $AA (hex) belegt und im Sekundentakt invertiert
(kann bei Anschluß von LED´s sichtbar gemacht werden), gleichzeitig
blinkt die Betriebs-LED mit:
program t25guid1;
uses SYSV25;
{ Basis-Unit für V25-Programme }
begin
RL_initTCPorts;
{ I/O-Ports für MT25-Rechner vorinitialisieren }
RL_fullSpeed;
{ 0 Waitstates und volle Prozessorgeschwindigkeit }
PM0 := 0;
{ Port0 (8-freie I/O-Ausgänge) auf Ausgang schalten }
P0 := $AA;
{ Bit-Muster AN-AUS-AN-AUS-AN-AUS-AN-AUS an Port 0 }
while TRUE do
{ Endlosschleife }
begin
RL_wait(1000);
{ 1000 msek. warten }
P0 := NOT P0;
{ Port P0 (Ausgabeport) invertieren }
BNOT(1,P2);
{ LED-Beleuchtung invertieren }
end;
end.
Nach der Durchführung nachfolgend aufgeführter
Schritte ist das Programm ablauffähig:
Programm mit Compile/Compile (F9) übersetzen; es entsteht eine
EXE- und eine MAP-Datei
EXELOC-Lauf (s.o.)
Downlaod mit Programm DLX (s.o)
Anmerkungen:
Ein Programm für den MT25 darf niemals abgebrochen werden, da eine
Rückkehr zu einem Betriebssystem wie DOS nicht möglich ist (etvl.
Programm mit Endlosschleife abschließen)
Die beiden ersten Befehle (RL_initTCPorts und RL_fullSpeed) sollten
immer ein Programm für den MT25
einleiten
4.2.4.
Die MT25-Systemlibrary für TurboPascal
Die MT25-Systemlibrary
für Turbo Pascal liegt in mehreren Units vor, welche ganz normal über
den USES-Befehl in ein
Anwenderprogramm eingebunden werden. Erst durch die Benutzung dieser
Library geht die Programmierung des MT25 mit allen seinen
Hardwarekomponenten zügig und bequem von statten. Im folgendem werden die
einzelnen Units mit allen Proceduren und Funktionen beschrieben.
Anmerkungen:
bei der Beschreibung der nachfolgenden Library-Funktionen werden
unter dem Kennzeichen MT auch Informationen zur Multithreading-Fähigkeit gegeben: zur
Bedeutung siehe Kapitel TurboTASK
Multitasking-System. Wird MT nicht benutzt, können diese Hinweise einfach
überlesen werden.
oft wird im folgenden der Begriff Funktion in Anlehnung an C als
Oberbegriff von Function und Procedure in Turbo Pascal
verwendet .
4.2.4.1.
Unit SYSV25
Die Unit SYSV25 muß in jedes Programm für den V25
eingebunden werden, und stellt grund-legende Dienste für den V25/MT25 zur
Verfügungung.
Funktionen und Prozeduren:
procedure
RL_initTCPorts;
setzt I/O-Ports für MT25 auf
die korrekte Richtung (Ein- oder Ausgang) und initialisiert die Ports
procedure
RL_FullSpeed;
Prozessor ohne Wait-States laufen lassen. Sollte praktisch immer als
erstes gerufen werden (außer bei "Uralt-EPROMs" mit mehr als
250ns Zugriffszeit)
function
RL_SysClock:longint;
liefert Zeit in Millisekunden seit Programmstart; fängt nach $FFFFFFFF
wieder bei 0 an;
procedure
RL_wait(wtime:longint);
wartet wtime Millisekunden; bei Verwendung von TurboTASK wird die Rechenzeit für andere Tasks benutzt
procedure
RL_SetIntVec(intnr: byte; vector:pointer)
setzt Interrupt-Vector für Interrupt mit Nummer intnr auf
Interruptprocedur mit Adress vector ( DOS-Unit-Procedure SetIntVec darf
nicht benutzt werden)
procedure
RL_GetIntVec(intnr: byte; var vector:pointer)
gibt Interrupt-Vector für Interrupt mit Nummer <intnr> in der
Pointervariable <vector> zurück ( DOS-Unit-Procedure GetIntVec darf
nicht benutzt werden)
procedure
BSET(nr: bits; var location: byte);
procedure
BCLR(nr: bits; var location: byte);
procedure
BNOT(nr: bits; var location: byte);
Bitmanipulationsbefehle zum Setzen, Löschen, Invertieren des Bits
<nr> in der Variable location; Vorteil gegenüber AND / OR / XOR:
Manipulation erfolgt mit einem Maschinenbefehl, sodaß die Bits in
derselben Variable auch von Interrupt-Routinen benutzt werden können.
procedure
FINT;
FINT-Befehl des V25: Quittiert Interruptkontroller nach Beendigung
eines Interrupt;
muß am Ende jeder selbstdefinierten Interruptprozedur gerufen werden,
welche einen V25-internern Interrupt (z.B. INTP0) handled (siehe
T25GUID4.PAS)
procedure
STI;
procedure
CLI;
Äquivalente zu den Assembler-Befehlen cli und sti;
procedure MT_yield;
(MT)
gibt unter TurboTASK den
Rest der aktuellen Zeitscheibe des aufrufenden Tasks für das System frei;
diese Funktion sollte ständig gerufen werden, wenn die Task zur Zeit
nichts zu tun hat (z.B. auf Eingaben oder bestimmte Zustände wartet), um
die Rechenzeit anderen Tasks zukommen zu lassen; läuft TurboTASK
nicht, so ist MT_yield wirkungslos (lediglich return-Befehl); es ist aber
sinnvoll diese Funktione auch ohne TurboTASK
schon zu verwenden, um bei einem späteren Umstieg auf TurboTASK-Multitasking bereits eine Task in den Händen zu haben,
der sparsam mit der Prozessorzeit umgeht.
Diese Prozedur gehört eigentlich zum Befehlssatz der TurboTASK-Routinen, wird aber aus dem eben geschilderten Grund
bereits ohne TurboTASK
angeboten.
procedure RL_setMTSWVect(handler:pointer);
(MT)
setzt Handler für MT_yield;
ist nur für interne Verwendung gedacht (TurboTASK
ruft diese Prozedur)
procedure
RL_init;
initialisiert das Assemblermodul zu SYSV25;
nur für interne Verwendung gedacht (wird bei Unit-Init. gerufen)
procedure
handleAbort;
Standard-Exit-Prozedur (wird bei Unit-Init. gesetzt)
läßt bei irregulärem Programmabbruch die LCD-Beleuchtung blinken;
procedure
RL_clearWatchDog;
Siehe Kapitel 2.3. Watchdog
Anmerkung:
es ist sinnvoll, die Datei SYSV25.PAS - v.a. die
Abort-Procedur - im Quellcode
zu betrachten;
4.2.4.2. Unit
LCD
Die Unit LCD stellt alle Funktionen zur Verfügung um
das Standard LCD-Display von IMT am LCD-Port des MT25 mit einem HD44780-LCD-Controller anzusteuern. Auch andere
LCD-Displays mit diesem Controller können von der Unit LCD angesteuert
werden.
Die
Benutzung einiger wichtiger Funktionen der LCD-Unit zeigt das Demoprogramm
T25GUID2.PAS
MT:
alle Funktionen sind multithreadingfähig. d.h. die Funktionen stören
sich bei gleichzeitiger Ausführung nicht gegenseitig beim Zugriff auf
Hardware (Serialisierung der Hardware-Zugriffe). Vorsicht ist aber
angebracht, wenn z.B. mehrere Threads den HardwareCursor benutzen. (z.B.
LCD_gotoXY mit darauffolgenden LCD_write-Aufrufe). Chaos auf dem LCD ist
dann vorprogrammiert.
Diese Probleme umschiffen einige Funktionen mit erweiterter MT-Fähigkeit
(z.B. LCD_writeXY ), die dafür sorgen, daß verschiedene Bereiche des
LCD-Displays von verschiedenen Threads
benutzt werden können. Besonders die Prozedur LCD_writeXY sollte der
Prozedur LCD_write immer vorgezogen werden.
Funktionen und Prozeduren:
procedure LCD_init;
braucht normalerweise nicht explizit aufgerufen werden, da diese
automatisch bei unit-Initialisierung aufgerufen wird;
procedure LCD_clrScr;
löscht Bildschirm und setzt Cursor an Position 0/0;
procedure LCD_gotoXY(x,y:integer);
versetzt den Hardware-Cursor an die Position x/y;
die linke obere Position hat die Koordinaten 0/0 (im Gegensatz zu gotoxy
in der crt-Unit);
procedure LCD_write(s:string);
schreibt String an aktueller Cursorposition auf den Bildschirm;
procedure LCD_writeXY(x,y:integer;
s:string)
MT:
erweitert MT-fähig
schreibt String s an Position x,y auf den Bildschirm;
die linke obere Position hat die Koordinaten 0/0 (im Gegensatz zu gotoxy
in der crt-Unit);
LCD_putCharXY(x,y:integer;
c:char)
MT:
erweitert MT-fähig
schreibt einzelnes Zeichen c an Position x/y auf Bildschirm;
LCD_clrLine(y:integer);
MT:
erweitert MT-fähig
löscht die Zeile y am Bildschirm komplett; die oberste Zeile
ist die Zeile 0;
procedure LCD_enableBlink;
schaltet Blinken des Cursors ein;
procedure LCD_disableBlink;
schaltet Blinken des Cursors aus;
procedure LCD_showCursor;
macht Cursor sichtbar;
procedure LCD_hideCursor;
macht Cursor unsichtbar;
function LCD_getCurX:integer;
liefert X-Position des Cursors; Umkehrung zu LCD_gotoXY
function LCD_getCurY:integer;
liefert Y-Position des Cursors; Umkehrung zu LCD_gotoXY;
procedure
LCD_setUserChar(charno: byte, bitmap:pointer);
erstellt selbstdefiniertes Zeichen;
<charno> ist die Nummer des selbstdefinierten Zeichens und hat den
Wertebereich 0..15;
dabei sind jedoch die Zeichen 0..7 identisch mit den Zeichen 8..15;
Es stehen also insgesamt 8 verschiedene selbstdefinierbare Zeichen zur
Verfügung.
Die Sonderzeichen können als normale Charakter bei Aufrufen wie
LCD_writeXY in Strings oder Charakters übergeben werden. Sie belgen den
ASCII-Bereich 0..15;
<bitmap> ist ein Zeiger auf eine 8 Byte lange Struktur, welche die
Bitmap-Information für
das Zeichen beinhaltet. Ein Zeichen hat das Format 5x7(8) Punkte. Die 8.
Zeile kann benutzt werden, allerdings wird sie bei Benutzung des
Hardware-Cursors von diesem überlappt.
Die Bitmapstruktur hat folgenden Aufbau (Binärzahlen):
Aufrufbeispiel:
...
const
fnt_haus:array[0..7] of byte=($04,$0A,$11,$15,$11,$11,$15,$1F);
...
LCD_setUserChar(
3, @fnt_haus );
LCD_writeXY(0,0,'User-Char:
'+chr(3) );
Das Demoprogramm T25GUID6 zeigt die Anwendung der selbstdefinierten
Zeichen ausführlich.
procedure LCD_wait;
intern: warten bis LCD für nächste
Operation bereit ist
4.2.4.3. Units
SER0 und SER1
Die beiden Units SER0
und SER1 stellen viele Routinen zur Verfügung, die für die serielle
Kommunikation benötigt werden. Sowohl empfangs- wie senderseitig wird
Puffer-Betrieb zur Verfügung gestellt, sodaß die entsprechenden
Funktionen sofort an das aufrufende Programm
zurückkehren, während der Empfangs- und Sendebetrieb im
Hintergrund von Interrupt-Handlern erledigt wird. Die Puffergröße beträgt
jeweils 128Byte.
SER1: RS232 (auch
Downloadschnittstelle)
SER0: RS232 oder RS485
procedure SERx_putChar(c:char);
sendet ein Zeichen über Puffer-Betrieb;
function SERx_getChar:integer;
gibt nächstes Zeichen aus Empfangspuffer zurück, bzw. -1, wenn
Empfangspuffer leer ist;
procedure SERx_putStr(s:string);
sendet String über Puffer-Betrieb;
procedure SERx_putBlk(p:pointer;
n:word);
sendet Datenblock über Puffer-Betrieb;
n : Länge des Datenblocks in Byte;
p : Pointer auf 1. Byte des Datenblocks;
mit Hilfe dieser Funktion können Datenblöcke größer als 255 Byte übertragen
werden;
procedure
SERx_setBaudRateX(br: integer; brxflags:byte)
(set baudrate extended)
setzt BaudRate und Bit-Einstellungen der seriellen Schnittstelle. Die
Default-Einstellungen sind:
9600Baud, no parity, (even) , 8Bit,
1 Stoppbit
br
: spezifiziert Baudrate; die Konstanten BR_1200 bis BR_115200
sind
vordefiniert;
brxflags
: Bitfeld, über welches die verschiedenen Bit-Einstellungen
gesetzt werden;
folgende Bit-Masken-Konstanten sind (vor-)definiert:
BRXF_2StoppBit
: 2 Stoppbits
BRXF_7Bit
: 7 Bit - Zeichenlänge
BRXF_ParOdd
: ungerade Parität (falls Parity-Betrieb)
BRXF_Parity &n
