1. MSRBASIC Version 4.0
Messen Steuern Regeln
Mit Erweiterungen der Version 4.2
ELZET 80 Mikrocomputer GmbH & Co,KG
52062 Aachen
www.elzet80.de
-1-

2. Alle Informationen in diesem Handbuch werden ohne Rücksicht auf
einen eventuellen Patentschutz veröffentlicht. Warennamen werden
ohne Gewährleistung der freien Verwendbarkeit benutzt.
MSRBASIC Version 4.0 basiert auf MSRBASIC wie es am Lehrstuhl für
Steuerungs- und Regelungstechnik an der Technischen Universität
München (Prof. Dr-Ing. G. Schmidt) mit Version 3.0 definiert wurde.
Der von ELZET 80 Mikrocomputer erworbene Quelltext dieser Version
wurde völlig überarbeitet, mit neuen Features versehen und
Kundenwünschen angepasst.
MSRBASIC ist ein mit großem Aufwand sorgfältig hergestelltes
Qualitätsprodukt. Das illegale Kopieren und Vertreiben dieses
Produktes stellt daher einen Diebstahl geistigen Eigentums dar und
wird urheberrechtlich verfolgt.
Dieses Handbuch basiert auf Unterlagen der LLSR an der TU München.
Es wurde um die zusätzlichen Befehle der ELZET 80 Version erweitert.
Bei der Zusammenstellung von Texten und Abbildungen und bei der
Programmierung von MSRBASIC wurde mit größter Sorgfalt vorgegangen.
Trotzdem können Fehler nicht völlig ausgeschlossen werden. Daher
kann ELZET 80 Mikrocomputer im Namen der Autoren für Fehler
jeglicher Art und deren Folgen werde eine juristische Verantwortung
noch irgendeine Haftung übernehmen.
Alle Rechte vorbehalten, auch für die fotomechanische Wiedergabe und
der Speicherung in elektronischen Medien.
2. erweiterte Ausgabe 1992
(C) LLSR, TU München und ELZET 80 Mikrocomputer Aachen 1989
-2-

3. 1. Vorwort
. . . . . . . . . . . . . . . . . . . . . . . . . . . . -15-
2. Allgemeines . . . . . . . . . . . . . . . . . . . . . . . . -16-
2.1 Sinn und Zweck von MSRBASIC . . . . . . . . . . . . . -16-
2.2 Anweisungen, Datentypen und Sonstiges . . . . . . . . -17-
2.2.1 Anweisungen . . . . . . . . . . . . . . . . . -17-
2.2.2 Buchstaben . . . . . . . . . . . . . . . . . . -17-
2.2.3 Datentypen . . . . . . . . . . . . . . . . . . -17-
2.2.4 Datenstrukturen . . . . . . . . . . . . . . . -17-
2.2.5 Editor . . . . . . . . . . . . . . . . . . . . -17-
2.2.6 Felder . . . . . . . . . . . . . . . . . . . . -18-
2.2.7 Funktionen . . . . . . . . . . . . . . . . . . -18-
2.2.8 Kanalnummern . . . . . . . . . . . . . . . . . -18-
2.2.9 Kommandos . . . . . . . . . . . . . . . . . . -18-
2.2.10 Kommentare . . . . . . . . . . . . . . . . . -18-
2.2.11 Operatoren . . . . . . . . . . . . . . . . . -19-
2.2.12 Programm . . . . . . . . . . . . . . . . . . -19-
2.2.13 Starten des Interpreters . . . . . . . . . . -19-
2.2.14 Transparent-Betrieb . . . . . . . . . . . . . -20-
2.2.15 Variable . . . . . . . . . . . . . . . . . . -20-
2.2.16 Zahlenbereich . . . . . . . . . . . . . . . . -21-
3. Editor-Funktionen . . . . . . . . . . . . . . . . . . . . . -21-
3.1 Übersicht . . . . . . . . . . . . . . . . . . . . . . -21-
3.2 Funktionsbeschreibung . . . . . . . . . . . . . . . . -21-
3.3 Änderung vorhandener Programmzeilen . . . . . . . . . -22-
4. Echzeitspezifische Sprachmittel . . . . . . . . . . . . . . -24-
4.1 Übersicht . . . . . . . . . . . . . . . . . . . . . . -24-
4.1.1 MSRBASIC-Echtzeitkonzept . . . . . . . . . . . -24-
4.1.2 Organisation und Handhabung . . . . . . . . . -26-
4.1.3 Beispiel: "Meßwerterfassung" . . . . . . . . . -27-
4.1.4 Listing "MESSDEM.BAS" . . . . . . . . . . . . -28-
4.1.5 Empfehlungen und Warnungen . . . . . . . . . . -29-
5. Zusammenfassung der echtzeitspezifischen Befehle . . . . . . -30-
5.1 DEFINE . . . . . . . . . . . . . . . . . . . . . . . -31-
5.2 START . . . . . . . . . . . . . . . . . . . . . . . . -33-
5.3 SUSPEND . . . . . . . . . . . . . . . . . . . . . . . -34-
5.4 ACTIVATE . . . . . . . . . . . . . . . . . . . . . . -35-
5.5 WAIT . . . . . . . . . . . . . . . . . . . . . . . . -36-
5.6 TRACE . . . . . . . . . . . . . . . . . . . . . . . . -39-
5.7 NOTRACE . . . . . . . . . . . . . . . . . . . . . . . -39-
5.8 TASKLIST . . . . . . . . . . . . . . . . . . . . . . -41-
5.9 SEQLIST . . . . . . . . . . . . . . . . . . . . . . . -42-
5.10 Logikfunktionen . . . . . . . . . . . . . . . . . . -43-
5.10.1 NOT(X) . . . . . . . . . . . . . . . . . . . -43-
5.10.2 BIT(N,X) . . . . . . . . . . . . . . . . . . -43-
5.10.3 Boolsche Ausdrücke . . . . . . . . . . . . . -44-
5.11 Prozeß Ein-/Ausgabe-Funktionen . . . . . . . . . . . -45-
5.11.1 Skalare Prozeß-Eingabe-Funktionen . . . . . . -46-
5.11.1.1 ADC(n) . . . . . . . . . . . . . . . -46-
5.11.1.2 DIN(n) . . . . . . . . . . . . . . . -47-
5.11.1.3 GET(pp) . . . . . . . . . . . . . . . -49-
5.11.1.4 CNT(n) . . . . . . . . . . . . . . . -50-
5.11.2 Skalare Prozeß-Ausgabe-Funktionen . . . . . . -51-
5.11.2.1 DAC(n) . . . . . . . . . . . . . . . -51-
5.11.2.2 DOUT(n) . . . . . . . . . . . . . . . -53-
5.11.2.3 PUT(pp) . . . . . . . . . . . . . . . -55-
-3-

4. 5.11.2.4 CNT(n) . . . . . . . . . . . . . . . -56-
5.11.3 Vektor Ein/Ausgabe-Funktionen . . . . . . . . -57-
5.11.3.1 MADC(MO) . . . . . . . . . . . . . . -57-
5.11.3.2 MDAC(SO) . . . . . . . . . . . . . . -57-
5.11.3.3 MDIN(MD) . . . . . . . . . . . . . . -57-
5.11.3.4 MDOUT(SD) . . . . . . . . . . . . . . -57-
5.11.4 Abfrage der Prozeßkonfiguration . . . . . . . -58-
5.11.4.1 NDAC . . . . . . . . . . . . . . . . -58-
5.11.4.2 NADC . . . . . . . . . . . . . . . . -58-
5.11.4.3 NDOUT . . . . . . . . . . . . . . . . -58-
5.11.4.4 NDIN . . . . . . . . . . . . . . . . -58-
5.11.4.5 NCNT . . . . . . . . . . . . . . . . -58-
5.12 Zeitgeberfunktionen . . . . . . . . . . . . . . . . -59-
5.12.1 TDOWN . . . . . . . . . . . . . . . . . . . . -59-
5.12.2 TUP . . . . . . . . . . . . . . . . . . . . . -59-
5.12.3 Zeitfaktor "TIMEFAC" . . . . . . . . . . . . -59-
5.12.4 24 Bit-Zeitgeber (nur TSM) . . . . . . . . . -59-
5.12.4.1 MSRTIMER . . . . . . . . . . . . . . -60-
5.12.4.2 MSTIMDIF . . . . . . . . . . . . . . -60-
5.12.5 Kalender und Uhrzeit . . . . . . . . . . . . -60-
5.12.5.1 TIME$ . . . . . . . . . . . . . . . . -60-
5.12.5.2 DATE$ . . . . . . . . . . . . . . . . -61-
5.12.5.3 DOW$ . . . . . . . . . . . . . . -61-
5.13 Reglerfunktionen . . . . . . . . . . . . . . . . . . -62-
5.13.1 Allgemeines . . . . . . . . . . . . . . . . . -62-
5.13.2 P/PID-Einzelregler . . . . . . . . . . . . . -63-
5.13.3 Vektor P/PID-Regler . . . . . . . . . . . . . -63-
5.14 Speicherfunktionen . . . . . . . . . . . . . . . . . -65-
5.14.1 PEEK(N) . . . . . . . . . . . . . . . . . . . -65-
5.15 Hintergrundspeicher . . . . . . . . . . . . . . . . -66-
5.15.1 BGMEMDIM . . . . . . . . . . . . . . . . . . -67-
5.15.2 BGMEM Wahlfreier Zugriff . . . . . . . . . . -67-
5.15.2.1 BGMEMPUTR . . . . . . . . . . . . . . -67-
5.15.2.2 BGMEMGETR . . . . . . . . . . . . . . -68-
5.15.3 BGMEM Queue-Zugriff . . . . . . . . . . . . . -70-
5.15.3.1 BGMEMPUTQ . . . . . . . . . . . . . . -70-
5.15.3.2 BGMEMGETQ . . . . . . . . . . . . . . -71-
5.15.4 BGMEM Stackzugriff . . . . . . . . . . . . . -72-
5.15.4.1 BGMEMPUSH . . . . . . . . . . . . . . -72-
5.15.4.2 BGMEMPOP . . . . . . . . . . . . . . -73-
5.15.5 BGMEM Sonderfunktionen . . . . . . . . . . . -74-
5.15.5.1 BGMEMSS . . . . . . . . . . . . . . . -74-
5.15.5.2 BGMEMCLEAR . . . . . . . . . . . . . -76-
5.15.5.3 BGMEMFRE . . . . . . . . . . . . . . -77-
5.16 Logical Units (Serienschnittstellen) . . . . . . . . -78-
5.16.1 LUMODE . . . . . . . . . . . . . . . . . . . -78-
5.16.2 LUOPEN . . . . . . . . . . . . . . . . -78-
5.16.3 LUAVAIL . . . . . . . . . . . . . . . . . . . -79-
5.17 Linkadapter . . . . . . . . . . . . . . . . . . . . -79-
5.18 BITBUS-Anschluß . . . . . . . . . . . . . . . . . . -80-
5.18.1 Allgemeines . . . . . . . . . . . . . . . . . -80-
5.18.2 Datenaustausch vom PC . . . . . . . . . . . . -80-
5.18.3 Datenaustausch aus MSRBASIC . . . . . . . . . -83-
5.18.3.1 BITZFLAG . . . . . . . . . . . . . . -83-
5.18.3.2 BITRB . . . . . . . . . . . . . . . . -83-
5.18.3.3 BITRW . . . . . . . . . . . . . . . . -83-
5.18.3.3 BITRH . . . . . . . . . . . . . . . . -84-
5.18.3.4 BITRS$ . . . . . . . . . . . . . . . -84-
5.18.3.5 BITWB . . . . . . . . . . . . . . . . -84-
-4-

5. 5.18.3.6 BITWW . . . . . . . . . . . . . . . . -85-
5.18.3.7 BITWH . . . . . . . . . . . . . . . . -85-
5.18.3.8 BITWS$ . . . . . . . . . . . . . . . -85-
5.19 Fahrtregler (POS) . . . . . . . . . . . . . . . . . -87-
5.19.1 Allgemeines . . . . . . . . . . . . . . -87-
5.19.2 POS . . . . . . . . . . . . . . . . . . . . . -87-
5.19.3 POSTYPE . . . . . . . . . . . . . . . . . . . -87-
5.19.4 POSSRN . . . . . . . . . . . . . . . . . . . -88-
5.19.5 FRDEF . . . . . . . . . . . . . . . . . . . . -88-
5.19.6 FRSETP . . . . . . . . . . . . . . . . . . . -88-
5.19.7 FRSETKP . . . . . . . . . . . . . . . . . . . -88-
5.19.8 FRSETKI(ki) . . . . . . . . . . . . . . . . . -89-
5.19.9 FRLSFAHRT . . . . . . . . . . . . . . . . . . -89-
5.19.10 FRLDFAHRT . . . . . . . . . . . . . . . . . -89-
5.19.11 FRSTAT . . . . . . . . . . . . . . . . . . . -89-
5.19.12 FRERROR . . . . . . . . . . . . . . . . . . -90-
6. Ein-/Ausgabe-Sprachmittel . . . . . . . . . . . . . . . . . -91-
6.1 Übersicht . . . . . . . . . . . . . . . . . . . . . . -91-
6.1.1 Fenstertechnik . . . . . . . . . . . . . . . . -92-
6.1.2 Fenster-Programmierung . . . . . . . . . . . . -93-
6.1.2.1 Fenster einschalten . . . . . . . . . -93-
6.1.2.2 Fenster ausschalten . . . . . . . . . -93-
6.1.2.3 Cursor positionieren . . . . . . . . . -93-
6.1.2.4 Masken-Dateien ausgeben . . . . . . . -93-
6.1.2.5 Abfragen des oberen Fensters . . . . . -93-
6.1.3 Beispiel zur Fenstertechnik . . . . . . . . . -93-
6.2 Ein- / Ausgabe-Anweisungen . . . . . . . . . . . . . -95-
6.2.1 INPUT . . . . . . . . . . . . . . . . . . . . -95-
6.2.2 PRINT . . . . . . . . . . . . . . . . . . . . -97-
6.2.2.1 Tabellierung . . . . . . . . . . . . . -97-
6.2.2.2 Cursor-Positionierung . . . . . . . . -97-
6.2.2.3 Formatierung . . . . . . . . . . . . . -97-
6.3 Schnittstellenfunktionen . . . . . . . . . . . . . -100-
6.3.1 EOF(n) . . . . . . . . . . . . . . . . . . . -100-
6.3.2 INCHAR$(n) . . . . . . . . . . . . . . . . . -100-
6.3.3 STATUS(n) . . . . . . . . . . . . . . . . . -101-
6.3.4 COMMAND(n) . . . . . . . . . . . . . . . . . -101-
7. Standardsprachmittel . . . . . . . . . . . . . . . . . . . -102-
7.1 Programmfluß-Steuerung . . . . . . . . . . . . . . -102-
7.1.1 FOR . . . . . . . . . . . . . . . . . . . . -102-
7.1.2 NEXT . . . . . . . . . . . . . . . . . . . . -104-
7.1.3 GOSUB . . . . . . . . . . . . . . . . . . . -105-
7.1.4 RETURN . . . . . . . . . . . . . . . . . . . -106-
7.1.5 GOTO . . . . . . . . . . . . . . . . . . . . -107-
7.1.6 IF . . . . . . . . . . . . . . . . . . . . . -108-
7.1.7 STOP . . . . . . . . . . . . . . . . . . . . -110-
7.1.8 END . . . . . . . . . . . . . . . . . . . . -111-
7.2 Rechen- /Speicheranweisungen . . . . . . . . . . . -112-
7.2.1 DIM . . . . . . . . . . . . . . . . . . . . -112-
7.2.2 LET . . . . . . . . . . . . . . . . . . . . -114-
7.2.3 MAT . . . . . . . . . . . . . . . . . . . . -116-
7.2.4 VEC . . . . . . . . . . . . . . . . . . . . -117-
7.2.5 POKE . . . . . . . . . . . . . . . . . . . . -119-
7.3 Kommentare . . . . . . . . . . . . . . . . . . . . -120-
7.3.1 REM . . . . . . . . . . . . . . . . . . . . -120-
7.4 Dateibefehle . . . . . . . . . . . . . . . . . . . -121-
7.5 Standardfunktionen . . . . . . . . . . . . . . . . -122-
7.5.1 ABS(X) . . . . . . . . . . . . . . . . . . . -122-
-5-

6. 7.5.2 ACN(X) . . . . . . . . . . . . . . . . . . . -122-
7.5.3 ASN(X) . . . . . . . . . . . . . . . . . . . -122-
7.5.4 ATN(X) . . . . . . . . . . . . . . . . . . . -122-
7.5.5 COS(X) . . . . . . . . . . . . . . . . . . . -122-
7.5.6 EXP(X) . . . . . . . . . . . . . . . . . . . -122-
7.5.7 INT(X) . . . . . . . . . . . . . . . . . . . -122-
7.5.8 LN(X) . . . . . . . . . . . . . . . . . . . -122-
7.5.9 LOG(X) . . . . . . . . . . . . . . . . . . . -122-
7.5.10 SIN(X) . . . . . . . . . . . . . . . . . . -122-
7.5.11 SQR(X) . . . . . . . . . . . . . . . . . . -122-
7.5.12 TAN(X) . . . . . . . . . . . . . . . . . . -122-
7.6 Stringfunktionen . . . . . . . . . . . . . . . . . -123-
7.6.1 CHR$(X) . . . . . . . . . . . . . . . . . . -123-
7.6.2 VAL(X$) . . . . . . . . . . . . . . . . . . -123-
7.6.3 LEN(X$) . . . . . . . . . . . . . . . . . . -123-
7.6.4 LEFT$(Q$,N) . . . . . . . . . . . . . . . . -123-
7.6.5 MID$(QS,N,M) . . . . . . . . . . . . . . . . -123-
7.6.6 RIGHT$(Q$,N) . . . . . . . . . . . . . . . . -123-
7.6.7 INSTR({N,}Q$,S$) . . . . . . . . . . . . . . -123-
7.6.8 ASC(x$) . . . . . . . . . . . . . . . . . . -124-
7.6.9 FTOI$ . . . . . . . . . . . . . . . . . . . -124-
7.6.19 FTOIB . . . . . . . . . . . . . . . . . . . -125-
7.7 Sonstiges . . . . . . . . . . . . . . . . . . . . . -126-
7.7.1 USR . . . . . . . . . . . . . . . . . . . . -126-
7.7.2 CALL . . . . . . . . . . . . . . . . . . . . -128-
7.7.3 ONERROR . . . . . . . . . . . . . . . . . . -130-
8. Kommandos . . . . . . . . . . . . . . . . . . . . . . . . -131-
8.1 AUTO . . . . . . . . . . . . . . . . . . . . . . . -131-
8.2 CLS . . . . . . . . . . . . . . . . . . . . . . . . -132-
8.3 FREEZE . . . . . . . . . . . . . . . . . . . . . . -133-
8.4 LIST . . . . . . . . . . . . . . . . . . . . . . . -134-
8.5 LOAD . . . . . . . . . . . . . . . . . . . . . . . -135-
8.6 NEW . . . . . . . . . . . . . . . . . . . . . . . . -136-
8.7 NOFREEZE . . . . . . . . . . . . . . . . . . . . . -136-
8.8 MFREE . . . . . . . . . . . . . . . . . . . . . . . -136-
8.9 RUN . . . . . . . . . . . . . . . . . . . . . . . . -136-
8.10 SAVE . . . . . . . . . . . . . . . . . . . . . . . -136-
8.11 SYSTEM . . . . . . . . . . . . . . . . . . . -137-
8.12 VCL . . . . . . . . . . . . . . . . . . . . . . . -137-
9. Programmiertips . . . . . . . . . . . . . . . . . . . . . -138-
9.1 Systemanalyse und Programm-Konzeption . . . . . . . -138-
9.1.1 Analyse der erforderlichen Parallität . . . -138-
9.1.2 Restriktive Auslastung . . . . . . . . . . . -139-
9.2 Programm-Implementierung . . . . . . . . . . . . . -140-
9.2.1 Anlagenorientierte Modularisierung . . . . . -140-
9.3 Übersichtlichkeit der Programme . . . . . . . . . . -141-
10. Hardware-Anpassung und EPROM-startende Systeme . . . . -143-
10.1 Allgemeines . . . . . . . . . . . . . . . . . . . -143-
10.2 Hardware-Anpassung . . . . . . . . . . . . . . . . -143-
10.2.1 Portadressen . . . . . . . . . . . . . . . -144-
10.3 EPROM-startende Systeme . . . . . . . . . . . . . -145-
10.3.1 PROMIT . . . . . . . . . . . . . . . . . . -146-
10.4.2 PROMIT bei Z280 Systemen . . . . . . . . . -147-
10.4 Programme in EEPROM . . . . . . . . . . . . -149-
10.5 Entwicklungshilfen . . . . . . . . . . . . . . . . -150-
-6-

7. 11. Fehlermeldungen . . . . . . . . . . . . . . . . . . . . . -151-
12. Stichwortverzeichnis . . . . . . . . . . . . . . . . . . -153-
13. Anhang
Erweiterungen des MSR-Basic für Z280 CPU (TSM/ECB)
1. Neuerungen bei MSR-Basic V4.2,00 . . . . . . . . . . . . .
. . . . . . .
1.1. IF-ELSE-ENDIF . . . . . . . . . . . . . . . . . . . .
. . . . . . .
1.2. ONERROR Änderung. . . . . . . . . . . . . . . . . . .
. . . . . . .
1.3. INPUT Anweisung . . . . . . . . . . . . . . . . . . .
. . . . . . .
1.4. SEQSTATE und TASKSTATE Funktionen . . . . . . . . . .
. . . . . . .
1.5. FORBID und PERMIT Anweisungen . . . . . . . . . . . .
. . . . . . .
1.6. Logische Operatoren AND und OR. . . . . . . . . . . .
. . . . . . .
1.7. STDSET. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . .
2. Hintergrundspeicher für MSR-Basic. . . . . . . . . . . . .
. . . . . . .
2.1. Einrichten eines Hintergrundspeichers . . . . . . . .
. . . . . . .
2.2. Wahlfreie Zugriff (Random Acess). . . . . . . . . . .
. . . . . . .
2.3. Zugriff auf Queues. . . . . . . . . . . . . . . . . .
. . . . . . .
2.4. Zugriff auf Stacks . . . . . . . . . . . . . . . . .
. . . . . . .
2.5. Hilfsfunktionen . . . . . . . . . . . . . . . . . . .
. . . . . . .
2.6. Flash-EPROM Hintergrundspeicher . . . . . . . . . . .
. . . . . . .
2.7. Neue E/A-Funktionen für TSM-8AD8
3. Programmspeicherung in Flash-EPROM . . . . . . . . . . . .
. . . . . . .
4. CNT-Zähler und EVCTR Funktion . . . . . . . . . . . . . .
. . . . . . .
5. Neue Timer Funktionen. . . . . . . . . . . . . . . . . . .
. . . . . . .
6. MODEM-Hilfsfunktionen. . . . . . . . . . . . . . . . . . .
. . . . . . .
6.1 LUMODE Funktion. . . . . . . . . . . . . . . . . . . .
. . . . . . .
6.2 LUOPEN Funktion. . . . . . . . . . . . . . . . . . . .
. . . . . . .
6.3 LUAVAIL Funktion . . . . . . . . . . . . . . . . . . .
. . . . . . .
7. LINKADAPTER. . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . .
-7-

8. 8. Bemerkungen zur Programmspeicherung in ein EPROM . . . . .
. . . . . . .
9. Fahrtregelung mit Gleichstrommotoren . . . . . . . . . . .
. . . . . . .
10. BITBUS Komunikation. . . . . . . . . . . . . . . . . . . .
. . . . . . .
11. Neue, zusätzliche Funktionen . . . . . . . . . . . . . . .
. . . . . . .
12. Programmerhalt
1. Neuerungen beim MSR-Basic V4.2,00
In allen früheren MSR-Basic Versionen unterscheidet man
zwischen Hauptprogramm, Sequenen und Tasks.
Dabei war durch den unübersichtlichen Schedule-Mechanismus
nicht vorhersehbar welchen zeitlichen Anteil dem Hauptprogramm
zugewiesen wird.
Also das Hauprogramm eignete sich lediglich zur Definition von
Sequenzen und Task und dessen Start.
In der Version V4.2 wurde das Hauptrogramm einer Sequenz gleichgestellt.
Das bedeutet, daß das Hauptrogramm immer den gleichen
zeitlichen Anteil zur Ausführung bekommt wie andere definierte
Sequenzen, oder auch in WAIT-Zustand übergehen kann, was
früher nicht möglich war.
Die Numerierung der Sequenzen ist gleichgeblieben (#1..#25).
Dazugekommen ist die Sequenz #0, also das Hauptprogramm.
Ein GOSUB führte dazu, daß der Schedule Mechanismus außer
Kraft gesetzt wurde, bis das Unterprogramm beendet war. Also,
wenn z.B. eine Sequenz ein GOSUB ausführte, wurden alle Task
und Sequenzen angehalten !!!!!
Das schränkte die Anwendung von Unterprogrammem sehr ein, aber
hatte dabei eine nützliche Eigenschaft das es möglich war
durch ein Unterprogramm z.B. Impulse mit fester Länge zu
erzeugen ohne alle Task/Sequenzen anzuhalten und wieder zu
aktivieren. In der neuen Version darf ein man Unterprogramme
verwenden ohne das der Scheduler angehalten wird, weil jede
Task/Sequenz ein eigenes GOSUB-Stack besitzt. Lediglich dürfen
Unterprogramme nicht beliebig andere Unterprogramme aufrufen.
Die Schachtelungstiefe ist auf 4 begrenzt oder auf 3 wenn man
ONERROR Anweisung benutzt. Es muß immer die Aufrufmöglichkeit
eines ONERROR-Unterprogramms bestehen.
Den Scheduler anzuhalten ist weiterhin möglich, aber nicht
mehr durch den GOSUB-Trick sondern durch neue Anweisung
FORBID. Die ebenfalls neue Anweisung PERMIT löst die Schedule-
Sperre wieder auf.
Die Ausdruckanalyse lief bis jetzt auch nicht immer korrekt.
Ein Funktionsaufruf der als Parameter wiederum eine Funktion
hatte führte manchmal zu falschen Ergebnissen. Ganz besonders
die Stringfunktionen machten diesen Fehler. Bei der neuen
Version würde die Ausdruckanalyse ebenfalls umgeschrieben.
Die Ausdruckanalyse hat nicht mehr den iterativen sondern
recursiven Charakter. Diese Analyse unterscheidet neben
Gleitkomma und Stringausdrücken auch Festkommausdrücke (long-
integer). Das bedeutet daß Summen und Produkten von
Funktionen, System-Variablen und Integer-Konstanten viel
schneller berechnet werden. Leider sind noch keine
-8-

9. Festkommavariablen möglich so daß
bei einer Variablenzuweisung ein Festkommaausdruck in
Gleitkommawert umgewandelt werden muß, oder das Vorhandensein
einer Variable im Ausdruck, den Ausdruck automatisch den
Gleitkommatyp gibt.
!!! ACHTUNG !!!
Durch die Festkommaarithmetik können unerwünschte Nebeneffekte
auftreten die früher nicht bekannt waren.
Eine Konstante ohne einem Dezimalpunkt ist ein
Festkommaausdruck, daher ist z.B. (1/10) auch ein Festkommaausdruck.
Weist man einer Gleitkommavarible den Wert (1/10) zu, so
bekommt sie den
Wert (0) zugewiesen!!!.
Man sollte in solchen Fällen explizit statt (1/10), (0.1)
eingeben oder wenigstens eine Gleitkommakonstante verwenden
z.B. (1/10.0) oder (1.0/10).
1.1 IF-ELSE-ENDIF
Neben einem einzeiligen IF...THEN...ELSE... Konstrukt ist ab
Version V4.2
das mehrzeilige IF.../ELSE.../ENDIF Block möglich.
Beispiel:
100 IF a=1 ' Kein THEN also ENDIF muß folgen!
110 a = a-1
120 b = b+1
130 ELSE
140 a = 1
150 b = b+2
160 ENDIF
1.2 ONERROR Änderung
Ab Version V4.2 wird das Scheduling während des Ausführung
eines Unterprogramms nicht mehr angehalten.
Das bedeutet daß bei der Ausführung eines ONERROR-
Unterprgramms die Möglichkeit bestehen würde daß ONERROR-
Unterprogramm vom mehren Tasks oder Sequenzen nebenläufig
ausgeführt würde. Der Interpreter würde es zwar
korrekt ausführen, aber für jede Anwendung wäre es ziemlich problematisch.
Daher wird vor jeder Ausführung eines ONERROR-Unterprogramms
automatisch die FORBID Anweisung ausgeführt. Das Bedeutet daß
ein ONERROR-Unterprogramm nicht durch eine TASK oder Sequenz
unterbrochen wird was wiederum ein Aufruf vom ONERROR-
Unterprogramm auslösen könnte.
Weiterhin ist eine Termination sichergestellt wenn ein Fehler
in einem ONERROR-Unterprogramm selbst ausgelöst wird.
Im Handbuch wird nicht beschrieben das die Möglichkeit die
Fehlernummer auszulesen (ERRVAR Variable).
In ERRVAR wird die Fehlernummer gespeichert bevor das ONERROR Unterprogram
ausgeführt wird.
Ein Beispiel für ONERROR-Unterprogramm.
1000 REM **** ONERROR-Unterprogramm ***********************************
1010 PRINT "*** FEHLER #";ERRVAR
-9-

10. ...
... Eventuelle Aktionen, abhängig vom Fehlernummer
...
1280 PERMIT
1290 RETURN
Der Befehl PERMIT hebt die Schedule-Sperre wieder auf.
PERMIT sollte in einem solchen Unterprgramm immer kurz vor
RETURN Anweisung stehen.
1.3 INPUT Anweisung
Die INPUT Anweisung war schon immer ein Bestandteil von MSR-
Basic. Leider war seine Anwendung in einem Multitasking
Programm nur bedingt brauchbar, weil das Schedule Mechanismus
bis zu Eingabe von <RETURN>
angehalten würde.
Ab Version V4.2 ist eine neu konzipierte INPUT Anweisung
verfügbar
die wenig zum Wünschen übrig läßt.
Beim ausführen von INPUT Anweisung geht die ausführende
Sequenz in ein
Wait-Zustand über.
Das bedeutet das die Tasks weiterhin eine INPUT Anweisung
nicht Ausführen dürfen. Das Hauptprogramm wird ab Version V4.2
wie eine Sequenz behandelt, also es gibt ja auch keine
Einschränkung bezüglich der Anwendung.
Der WAIT-Zustand in die eine Sequenz übergeht kann optional
zeitlich überwacht werden. Damit kann man leicht verhindern
daß eine Sequenz ewig auf eine Eingabe wartet. Des weiteren,
man kann optional, das Fehlerbehandlung bei der Eingabe selbst
gestalten. Also, man kann das standard Mechanismus wo die
INPUT-Anweisung, nach vorherigen Meldung: "INPUT Fehler",
wiederholt wird, durch eigene Fehlerbehandlung ersetzen.
Weiterhin ist es jetzt auch möglich Bildschirmausgaben zu
machen während in einem anderem Teil des Bildschirms eine
INPUT-Zeile editiert wird.
Diese nebenläufige Bildschirmausgabe wird jedoch nur dann
funktionieren wenn man kein Semikolon am Ende der PRINT-
Anweisung verwendet.
Die neue Syntax lautet:
INPUT [ ON(Kanal ] [ [Y,X] ] [ MAX Wert ] <Variablenliste> [
ELSE Anweisung]
Unter <Variablenliste> ist eine oder mehrere, durch Komma
getrennte numerische oder Stringvariablen gemeint.
Die Eingabe sollte bei mehreren Variablen auch durch Komma
getrennt werden.
Bei Numerischen Variablen ist nur eine Numerische Darstellung
einer Zahl erlaubt und sollte einer Stringvariable das
Kommazeichen auch zugewiesen werden so kann die Eingabe in
Anführungsstriche geklammert werden.
Beispieleingabe für Variablenliste <a,a,a$>:
-10-

11. >1111.0, 222,"Komma,Komma"<
Unvollständige Eingaben oder unkorrekte Numerische Darstellung
führen zu einem Fehlerfall!
Die Optionen:
[ ON(Kanal) ]
Soll die Eingabe auf einem anderem Kanal erfolgen als LU(0),
so ist diese Option zu wählen. So werden bei "INPUT ON(2) a"
alle Eingaben und Ausgaben auf LU(2) erfolgen.
[ [Y,X] ]
Stellt den Cursor auf eine bestimmte Y,X Position des
Bildschirms. Auf dieser Position kann man dann die Werte eingeben.
Obwohl andere Sequenzen oder Task Bildschirmausgaben parallel
dazu machen wird die eingestellte Position beibehalten.
Vorausgesetzt daß PRINT-Anweisungen ohne Semikolon verwendet werden!.
[ MAX Wert ]
Die INPUT-Anweisung wird Zeitlich überwacht. Durch <Wert>
bestimmt man wieviel Sekunden maximal das Eingabegerät ruhen
darf. Die INPUT Anweisung selber kann vielfaches davon aktiv
bleiben, aber einzelne Pausen bei der Eingabe dürfen den Limit
nicht überschreiten.
[ ELSE Anweisung ]
Programmabschnitt nach <ELSE> wird nicht berücksichtigt wenn
die Eingabe erfolgreich abgeschlossen würde. Würde die
Zeitliche überwachung aktiviert und überschritten oder die
Eingabe falsch oder unvollständig gemacht so wird keine
Fehlermeldung ausgegeben und die INPUT-Anweisung wiederholt,
sonder dieser Programmabschnitt ausgeführt.
Zweckmäßig sollte dort eine GOTO Anweisung stehen, aber auch
andere Anweisungen sind zulässig.
Beispiel für eine INPUT-Anweisung mit Optionen:
11000 PRINT "Geben Sie Bitte Name,Vorname und Alter ein: ";
11010 INPUT MAX 10 Name$,Vorname$,Alter ELSE GOTO 11110
1.4 SEQSTATE und TASKSTATE Funktionen
Es ist manchmal nützlich zu wissen ob eine Sequenz oder Task
aktiv ist.
Zwar ließ sich daß immer durch Benutzung von Variablen
realisieren, doch jetzt ist es bequemer und sicherer.
Als Parameter gibt man eine Sequenz oder Tasknummer und
bekommt zurück
ein Zustandswert, der folgende Bedeutung hat:
-11-

12. 0: Sequenz oder Task nicht Aktiv.
1: Sequenz oder Task ist aktiv
2: Nur bei Sequenzen. Sequenz ist aktiv und wartet auf ein
Zustand
(WAIT oder INPUT Anweisung gerade in Bearbeitung).
Beispiel: Von einer Sequenz soll ein TASK gestartet werden,
die Sequenz selber hat dann nichts zu tun und soll solange in
Wartezustand übergehen.
1000 START TASK 1
1010 WAIT FOR TASKSTATE(1) = 0
1020 PRINT "O.K."
1.5 FORBID und PERMIT Anweisungen
Das Multitasking bringt viele Vorteile mit sich. Es gibt
jedoch Anwendungen bei denen für kurze Zeit das
Schedulemechanismus sehr stört.
Z.B. bei Erzeugung von Programmgesteurten Impulsen oder bei
einem Fehlerfall wo alle TASK/SEQUENZ Aktionen kurz angehalten
werden sollen.
Zwar ließ es sich immer mit SUSPEND TASK ALL und SUSPEND SEQ ALL
alle Tasks und Sequenzen anzuhalten, aber dadurch war nur der
Hauptprogramm blieb dann aktiv und es war nicht mehr möglich
den ursprünglichen Zustand herzustellen. ACTIVATE TASK ALL
würde alle TASKs aktivieren unabhängig davon ob sie vorher
schon mal aktiv waren oder nicht.
Bei Ausführung der FORBID Anweisung wird also wirklich das
Schedulemechanismus angehalten. Nach dieser Anweisung wird
ausschließlich der Programmteil, der diese Anweisung enthalten
hat, ausgeführt.
Die Anweisung PERMIT hebt die Sperre wieder auf, und alles
kehrt zum ursprünglichen Zustand.
Wie schon erwähnt, es gibt ein Sonderfall wo die FORBID
Anweisung automatisch ausgeführt wird. Und zwar vor der
Ausführung eines ONERROR Unterprogramms.
Daher sollte man in der Regel nicht vergessen ein PERMIT
Anweisung auszuführen vor einer RETURN Anweisung des Unterprogramms.
Noch ein schlechtes Beispiel zur Warnung:
1000 a = 0
1010 FORBID
1020 WAIT FOR a>0
1030 PERMIT
Wie man leicht erkennen kann ist dieser Beispiel das Ende
eines Programms.
Obwohl vorher alles schalten und walten vermag tut sich
bereits nach der dritten Zeile nichts mehr. Dieser Teil einer
Sequenz wird nach der FORBID Anweisung der einziger
ausgeführte Programmteil, und geht sofort in ein WAIT-Zustand
der nie beendet wird!!!
1.6 Logische Operatoren AND und OR
Eine Einschränkung bei MSR-Basic war das fehlen der bekannten
AND oder OR Operatoren. Nun gilt diese Einschränkung nicht mehr.
-12-

13. Diese Operatoren sind z.Z. nur als logische Operatoren die
zusammen mit Relationen in einer IF oder WAIT Anweisung
verwendet werden können, nicht aber für eine Verknüpfung
zweier Werte bitweise. Das macht nur ein Sinn mit
Ganzzahligenwerten und solange keine Ganzzahlige Variable
eingeführt sind
würde es nur wenig ausgenutzt werden können.
Die Rangfolge dieser Operatoren ist nach der Relationen und
beliebige Klammerung ist erlaubt.
Beispiel:
1000 IF DIN(NotAus) OR (DIN(Vent1) = 0 AND DIN(Vent2) = 0)
1010 PRINT "Notschalter EIN, oder beide Ventile ausgeschaltet!!"
1020 ENDIF
1.7 STDSET Anweisung
Die neue Anweisung STDSET soll der allgemeiner Voreinstellung dienen.
Bis jetzt ist nur der Format bei Ausgabe von numerischen
Werten voreinstellbar, und die Syntax lautet:
STDSET AS xxx wobei xxx die Formatbeschreibung ist die sonst
hinter AS erlaubt ist.
Sollen in einem Programm nur Werte in sechsstelligen
Festkommaformat ausgegeben werden so braucht man nicht mehr
hinter jeder PRINT Anweisung
"AS 6I" einzugeben wenn man am Programmanfang mit "STDSET AS
6I" dieses Format eingestellt hat.
Ein weiteres Nutzen dieser Anweisung ist es, daß damit auch
die STR$ Funktion beeinflußt wird. Bis jetzt lieferte diese
Funktion einen String welcher gleich war mit Ausgaben der
PRINT Anweisung ohne <AS xxx> Formatangabe.
Meist müsste ein solcher String weiterbearbeitet werden z.B.
wenn man nur die
zwei Vorkommaziffer benötigte.
Nun, jetzt kann man das Format einstellen und dieses Format
wird auch für die STR$ Funktion verwendet.
Beispiel:
Ein Programm soll über LU(2) Steuersequenzen ausgeben. Eine
Sequenz besteht aus einem <ESC> Zeichen gefolgt von einer
Befehlsbuchstabe,Parameter und <CR> Zeichen. Der Parameter
besteht immer aus zwei Hexadezimalziffern.
10000 PRINT ON(2) CHR$(&H1B)$; ' <ESC> Zeichen
10010 PRINT ON(2) Cmd$; ' Kommandobuchstabe
10020 STDSET AS 02H ' Format = 2 Stellen, Hexadezimal
10030 PRINT ON (2) STR$(Wert); ' Parameter ausgeben
10040 STDSET AS 6I ' wieder Normale Einstellung
10050 PRINT ON (2) CHR$(&H0D); ' Abschlusszeichen <CR>
2. Hintergrundspeicher für MSR-Basic
MSR-Basic wurde ursprünglich für den Betrieb mit sehr wenig
Hauptspeicher entwickelt. Es kann meist ein Bereich von 32
KByte für MSR-Programme und Daten genutzt werden. Um in
Applikationen der Meßwerterfassung auch mit größeren
Datenmengen umgehen zu können, wurde für den Prozessor Z280
eine Erweiterung des MSR-Basic vorgenommen. Die neuen
Funktionen erlauben die Einrichtung und das Einfügen/Entfernen
-13-

14. von Daten aus einem Hintergrundspeicher.
Ein Hintergrundspeicher kann als Feld von Datenstrukturen
aufgefaßt werden.
Es können auch mehrere Hintergrundspeicher definiert werden,
deren Datenstruktur unabhängig voneinander sind.
Auf den Hintergrundspeicher kann direkt (wahlfrei), als Stack
oder als Queuezugegriffen werden. Alle Zugriffsarten können
auch gemischt werden, was besonderes dann sinnvoll ist, wenn
die Daten eines Stacks oder Queue verarbeitet werden sollen,
ohne sie aus dem Hintergrund zu entfernen.
Es können maximal 8 Hintergrundspeicher definiert werden,
deren Größe nur durch den verfügbaren Speicherplat Seite 187
-14-

15. 1. Vorwort
Entsprechend den vielfältigen Einsatzmöglichkeiten richtet sich
MSRBASIC an einen weiten Kreis von Anwendern.
Das vorliegende MSRBASIC-Handbuch stellt hinsichtlich Darstellung
und Umfang einen Kompromiß dar.
Diejenigen MSRBASIC-Befehle, die zum Standard-Sprachumfang gehören
werden sehr knapp beschrieben, während MSRBASIC-spezifische
Echtzeit-Befehle in der gebotenen Ausführlichkeit behandelt werden.
Die Methodik der Darstellung ist vom Ziel geprägt, das jeweilige
Grundprinzip der einzelnen MSRBASIC-Befehle knapp und allgemein zu
vermitteln, andererseits durch praktische Beispiel
Anwendungshinweise für den MSRBereich zu liefern.
Aus diesem Grund werden die Befehle nicht in ihrer alphabetischen
Reihenfolge beschrieben, sondern im Rahmen funktionell verwandter
Befehle, wie z.B.
- Echtzeitbefehle
- Programmflußsteuerbefehle
- Zeichen-Ein/Ausgabe-Befehle
-15-

16. 2. Allgemeines
2.1 Sinn und Zweck von MSRBASIC
Der MSRBASIC-Interpreter ist konzipiert für die flexible
Implementation von Meß- Steuer- und Regelalgorithmen auf EPROM-
startenden Mikrorechnern (Stand-Alone-Systeme) der Z80-Familie.
Die Programm-Entwicklung erfolgt mit dem Hilfsprogramm MSRSHELL auf
einem PC (XT, AT) über eine RS232-Verbindung mit dem EPROM-
startenden Zielrechner (MOPS xAx, xDx oder PC-EXPander mit CPU-S
oder CPU85SC) erfolgen.
MSRBASIC bietet für das genannte Einsatzgebiet neben dem üblichen
algorithmisch logischen Kern einer höheren Programmiersprache
spezielle Sprachmittel an, die die Formulierung von
- nebenläufigen Programmen (Multitasking),
- hardwareabhängigen Prozeßzugriffen,
- Zeitgebern
- PI(D)-Reglerfunktionen,
- Matrix-Vektor-Operationen
- Kommunikationsfunktionen
erlauben.
Neben diesen sprachlichen Fähigkeiten, die MSRBASIC als Echtzeit-
Sprache ausweisen, verfügt der MSRBASIC-Interpreter (im Sinne eines
Programmiersystemes) über eine Reihe von Eigenschaften, die nicht
nur die Erstellung, sondern auch die Fehlersuche, Wartung und (Re-
)Dokumentation von MSR-Anwender-programmen unterstützt:
- Integrität von Ziel- und Entwicklungssystem
- integrierter serieller Hostanschluß
(zum Programme laden, Daten versenden und entgegen-
nehmen, Betrieb als intelligentes Terminal)
- strukturorientiertes Ausdrucken von Programmen
- Befehlsanzeige vor Ausführung zum Programmtest (Trace)
- Anzeige des momentanen Programmzeigerstandes bei SE-
QUENZEN (Aufspüren von Deadlocksituationen)
- Fehlermeldung mit Quellzeilen-Auslisten
- E/A-Simulator-Betriebsart
Weitere für Realzeit-Mikrorechner notwendige Eigenschaften sind
- EPROM-fähiger Zwischencode
- Autoload- und Autostartfunktion
Für den MSRBASIC-Interpreter ergibt sich damit ein breites
Einsatzspektrum:
- Einsatz in autonomen Regel- und Steuergeräten,
insbesondere bei verfahrenstechnischen Anwendungen
- Einsatz als Kontroller zusammen mit intelligenten
Peripheriegeräten zur Experimentsteuerung
- Einsatz bei Maschinensteuerungen
- Einsatz als Meßwerterfassungs- und Protokolliersystem
- Einsatz zur Ausbildung
Die Summe dieser Eigenschaften machen MSRBASIC zu einem Instrument,
-16-

17. das für viel Anwender (Steuerungs- und Regelungs-techniker,
Verfahrenstechniker, Chemiker, Physiker, Mediziner u.A.) eine
wertvolle Hilfe darstellt.
Das vorliegende Handbuch will in konzentrierter, aber hinreichend
ausführlicher Form den Anwender bei der Handhabung des MSRBASIC-
Interpreters unterstützen.
Es setzt eine gewisse Vertrautheit mit der Grundsprache BASIC voraus
und legt daher das Hauptgewicht auf die Behandlung der
echtzeitspezifischen Fähigkeiten von MSRBASIC.
2.2 Anweisungen, Datentypen und Sonstiges
In diesem Kapitel werden zunächst - im Sinne einer Übersicht - in
alphabetischer Ordnung kurz einige allgemeine MSRBASIC-
Eigenschaften behandelt, bevor im zweiten Teil ausführlich das
MSRBASIC-Echtzeitkonzept erläutert wird.
2.2.1 Anweisungen
Ein MSRBASIC-Programm besteht aus einer eindeutigen Folge von
Anweisungen (Statements). Jede Programmanweisung beginnt mit einer
Zeilennummer (1..65565), die die Lage der Zeile innerhalb des
Programms festlegt.
Einige Anweisungen können auch direkt ("direct mode"), d.h. quasi
als Kommando eingegeben werden.
Diese Eigenschaft ist insbesondere beim Echtzeitbetrieb von großer
Bedeutung, da während der Programmausführung auf alle Variablen mit
Hilfe von PRINT- und (LET-)Anweisungen zugegriffen werden kann.
2.2.2 Buchstaben
MSRBASIC läßt die Verwendung von Klein- und Großbuchstaben zu. Bei
Schlüsselwörtern (Kommandos, Anweisungen, Funktionen, Trennwörter
und Systemvariablen) werden Kleinbuchstaben intern in Großbuchstaben
umgewandelt. D.H. Eingaben wie "THEN", "then" oder "Then" werden
intern als "THEN" behandelt.
Dagegen werden Kleinbuchstaben in Variablennamen NICHT wie
Großbuchstaben behandelt, d.h.
ZEIT$
und sind zwei unterschiedliche Variable !
Zeit$
2.2.3 Datentypen
MSRBASIC kennt die Datentypen REAL und STRING. Integer-Zahlen werden
intern als Gleitkommagröße behandelt. Der Datentyp ergibt sich
implizit aus dem Programm.
2.2.4 Datenstrukturen
Als Datenstrukturen sind ein- oder zweidimensionale Felder (s.d) vom
Type REAL oder STRING möglich.
2.2.5 Editor
-17-

18. Bei der Eingabe eines Kommandos, einer Programmzeile oder eines
Wertes (Zahl oder Text) ist ein Zeileneditor wirksam, d.h. daß
innerhalb der momentanen Eingabezeile der Cursor bewegt, Zeichen
eingefügt und gelöscht werden können.
Einzelheiten siehe Kapitel "Editor".
2.2.6 Felder
Es können ein- und zweidimensionale Felder für die Datentypen REAL
und STRING benutzt werden. Der Index beginnt grundsätzlich bei 0
(NULL). Sofern der verfügbare Anwenderspeicher es zuläßt, können
numerische Vektoren bis zur Dimension 8191 (8k) und Matrizen bis zur
Ordnung 126x126 vereinbart werden. Stringfelder können maximal 255
Elemente aufweisen.
2.2.7 Funktionen
Neben den BASIC-Standardfunktionen wie SIN, SQR bzw. CHR$ MID$ usw.
werden folgende Typen von anwendungsbezogenen Funktionen zur
Verfügung gestellt:
- Auf und Abwärts-Zeitgeber
- Zugriffe auf analoge und digitale Prozeßperipherie
- Komplette Reglerblöcke (PI,PID)
- Status- und Kommandofunktionen für die seriellen Kanäle
- Kommunikationsfunktionen
2.2.8 Kanalnummern
Die Ein-/Ausgabe von Zeichen und Texten erfolgt durch Befehle wie
PRINT und INPUT die um einen "ON(kanalnummer)"-Zweig erweitert
werden können. Je nach (Hardware-)Konfiguration werden damit neben
der Konsole und dem Drucker auch Ein-Ausgabegeräte wie z.B. LCD-
Anzeigen, Matrixtastaturen, weitere RS232-Schnittstellen usw.
erreichbar.
Es stehen die Kanalnummern 0..9 zur Verfügung. Bei den EPROM-
startenden Systemen ist Kanal (0) (falls vorhanden) immer die
Konsole. Kanal (1) ist als Druckerkanal vorgesehen.
Die unbelegten Kanäle können zum Anschluß von Standardperipherie
genutzt werden, eignen sich aber auch vorzüglich zur Anbindung
komplexerere Schnittstellen wie z.B. IEC-Bus oder DFÜ-Kanäle.
In den EPROM-startenden Systemen mit (optionalem) EEPROM-Anschluß
erfolgt die "Programmierung" D des EEPROMS ebenfalls über einen "ON-
ng"
Kanal" (siehe hierzu das Kapitel Hardware-Anpassung).
2.2.9 Kommandos
Die Kommandos im MSRBASIC sind Anweisungen an den Interpreter. Sie
dienen entweder Editierzwecken (LIST, SAVE, LOAD, NEW) oder der
Festlegung der Betriebsart (RUN, FREEZE, SYS).
2.2.10 Kommentare
Kommentarzeilen werden durch "REM" eingeleitet. Sie dienen der
Kommentierung von Programmsegmenten.
-18-

19. 2.2.11 Operatoren
In MSRBASIC stehen folgende Operatoren zur Verfügung:
Skalare Operatoren
a) Rechenoperatoren:
Wertigkeit
Potenzoperator: ^ 3
Multiplikation: * 2
Division: / 2
Addition: + 1
Subtraktion: - 1
b) Vergleichsoperatoren:
größer: >
kleiner: <
gleich: =
größer-gleich: => oder >=
kleiner-gleich: =< oder <=
ungleich: <> oder ><
c) Stringoperatoren
Verkettung: +
Matrix-Operatoren
Multiplikation: * 2
Element-Multipl.: . 2
Addition: + 1
Subtraktion: - 1
2.2.12 Programm
MSRBASIC kennt drei Typen von Programmen:
Das Rahmen- oder Grundprogramm entspricht dem üblichen BASIC-
Programm. Es wird über das RUN-Kommando oder einen unmittelbaren
GOTO-Befehl gestartet. Die Beendigung des Programmes erfolgt über
die entsprechenden Anweisungen (RETURN, STOP, END), über die
Fehlermeldungen oder durch ein Abbruch-Kommando vom der Konsole aus
(Eingabe von CNTRL-C).
Der zweite MSRBASIC-Programmtyp heißt TASK und wird zyklisch vom
Echtzeitbetriebssystem gestartet. (siehe nächsten Abschnitt). Sollen
alle zyklischen Programme angehalten und nicht mehr neu gestartet
werden, CNTRL-D einzugeben.
Der dritte MSRBASIC- Programmtype ist die SEQuenz. auch sie wird vom
Echtzeitbetriebssystem gestartet (s.u.). Das Anhalten aller
Sequenzen geschieht durch die Eingabe von CNTRL-A.
2.2.13 Starten des Interpreters
Sofern im BASIC-Programmspeicher ein intaktes Programm vorhanden
ist, führt MSRBASIC automatisch einen AUTO-Warmstart durch, d.h. die
Anwendervariablen werden nicht gelöscht, das Programm wird ab der
ersten Programmzeile ausgeführt.
Hinweis:
-19-

20. Bei jedem Neustart prüft MSRBASIC ob im (u.U. auch geschützten CMOS-
RAM) ein "sinnvolles" Programm steht. Ist dies der Fall, so wird
dieses Programm ausgeführt, evtl. Fehler werden spätestens bei der
Interpretation erkannt. Wurde der Neustart z.B. durch einen
Stromausfall oder ein gezieltes An- und Abschalten verursacht, so
muß die (anwenderseitige) Neuinitialisierung von Parametern umgangen
werden. Dies geschieht am einfachsten durch Verwendung einer
(benutzerdefinierten) Variablen:
100 REM beim ersten Kaltstart werden alle Variablen
110 REM auf NULL gesetzt, es gilt also beim Kaltstart
120 IF IniFlg <> 0 THEN GOTO 200
130 REM Initialisierung von Variablen beim Warmstart
140 LET A=123
150 DIM X1(16), A(X,Y)
:
: und was sonst noch gemacht werden muß...
: Achtung: Bausteine wie PIO, CIO usw.
: nach jedem RESET neu initialisieren!
: ... dann IniFlg <> 0 setzten
:
190 IniFlg=55
200 REM *** Hier gehts bei Warmstart weiter ***
:
Bei Kaltstart erfolgt eine Initialisierung der Echtzeituhr, des
Taskumschalters und des Arbeitspeichers, sowie eine
konfigurationsabhängige Kaltinitialisierung der Prozeß-Ein/Ausgabe.
In der Regel bedeutet dies z.B. für die binären Stellsignale ein
Schalten in den stromlosen Zustand.
Bei Warmstart wird die Echtzeituhr initialisiert und das ACTIVE-Bit
aller TASKS und SEQuenzen zurückgesetzt, um einen definierten Neu-
bzw. Wiederstart zu gewährleisten. Außerdem wird eine
konfigurationsabhängige Warminitialisierung der Prozess-Ein/Ausgabe
vorgenommen. Dies bedeutet z.B. für die binären Stellsignale, daß
die E/A-Bausteine in Ausgaberichtung neu programmiert werden.
In EPROM-startenden (Stand-Alone-)Systemen gibt es noch zwei weitere
Startvarianten, nämlich den Autostart eines in (E)EPROM abgelegten
Anwenderprogrammes bzw. das automatische Laden eines Programmes von
einem voreinstellbaren seriellen Kanal und anschließende Starten.
2.2.14 Transparent-Betrieb (virtuelles Terminal)
MSRBASIC unterstützt für die SAVE-, LOAD und LIST-Kommandos den
Datenverkehr von und zu einem übergeordneten Rechner (Host). Bei
Ausführung dieser Kommandos geht der Interpreter vorübergehend in
den Transparent-Betrieb, d.h. der Host-Rechner empfängt die nach dem
Kommando eingegebenen Zeichen und das MSRBASIC-Terminal zeigt die
Antworten des Host. Erst die Eingabe eines speziellen Fluchtsymboles
(CNTRL-A) veranlaßt dann die Ausführung des Kommandos.
2.2.15 Variable
Ein MSRBASIC-Programm kann maximal 255 verschiedene Variable
aufweisen. Es gibt vier Arten von Variablen, nämlich Skalare und
Felder jeweils vom Typ REAL oder STRING.
Jede Variable trägt einen Namen der maximal sechs Zeichen lang sein
-20-

21. kann. Das erste Zeichen muß ein Buchstaben sein, als folgende
Zeichen sind Buchstaben, Ziffern und der Unterstrich "_" erlaubt.
Aus Gründen der Kompatibilität zu Microsoft-Basic sind auch die
Zeichen "%" und "#" zugelassen.
Stringvariable (Zeichenkettenvariable) sind durch ein "$"-Zeichen
zusätzlich zum Variablennamen gekennzeichnet.
Beispiele: A_min, a0$, Azeich(2), ESC$, X$(1,2)
Die maximale Länge von Stringvariablen wird bei der MSRBASIC-
Konfiguration festgelegt (Voreinstellung: 40 Zeichen). Stringfelder
weisen als Elemente Stringvariable auf. Die Namen der Wochentage
können z.B. in ein Stringfeld abgespeichert werden:
DIM WO$(7)
WO$(1)="Montag"
2.2.16 Zahlenbereich
Die größte Zahl die von MSRBASIC verarbeitet wird, ist 4.61168E+18,
die kleinste 6.46235E-27. Tritt bei einer arithmetischen Operation
ein Überlauf auf, erfolgt eine Fehlermeldung. Dagegen wird bei einem
Unterlauf das Ergebnis automatisch zu Null gesetzt. Es können
Integer- (Ganzzahl-), Festkomma- und Gleitkommazahlen mit und ohne
Exponent eingegeben werden. Es dürfen jedoch nicht mehr als sieben
Stellen (bei entsprechender Genauigkeit) eingegeben werden.
Darüberhinaus ist es möglich HEX(Sedezimal-)Werte im Bereich
0000..FFFF ein- bzw. auszugeben.
Die Syntax für die Eingabe lautet:
&Hnnnn mit nnnn = 0..FFFF
Die entsprechende Ausgabe erfolgt über die "PRINT..AS.."-Anweisung
3. Editor-Funktionen
3.1 Übersicht
In MSRBASIC stehen bei der Eingabe von Programmzeilen komfortable
Editierfunktionen zur Verfügung.Eine weitere Komfortsteigerung
bringt die erweiterte Syntaxprüfung bei der Programmzeilen-Eingabe,
die fehlende Klammern oder Anführungszeichen sofort entdeckt. Damit
werden MSRBASIC- Programme auch sicherer, da syntaxbedingte
Laufzeitfehler verringert werden.
3.2 Funktionsbeschreibung
Bei der Eingabe einer Programmzeile (oder von INPUT aus) ist
grundsätzlich der "Einfüge-Modus" in Kraft.
Folgende Editierfunktionen stehen zur Verfügung:
64444444444;44444444444444444444444444444444444444444444444447
5Taste 5 Funktion 5
:4444444444>4444444444444444444444444444444444444444444444444<
5 5 5
5CNTRL-A 5 Cursor eine Position nach links 5
5CNTRL-F 5 Cursor eine Position nach rechts 5
-21-

22. 5DEL,BS 5 Zeichen links vom Cursor löschen 5
5CNTRL-G 5 Zeichen unter dem Cursor löschen 5
5CNTRL-X 5 ganze Zeile löschen 5
5CR 5 Eingabe beenden 5
5CNTRL-C 5 Eingabe abbrechen 5
5CNTRL-B 5 Cursor zum Ende/Anfang der Zeile positionieren 5
5 5 5
94444444444=44444444444444444444444444444444444444444444444448
Alle andere Steuerzeichen werden ignoriert.
3.3 Änderung vorhandener Programmzeilen
Um bereits vorhandene Programmzeilen mit Hilfe der oben
beschriebenen Editorfunktionen zu ändern, ist die entsprechende
Zeile durch
"# <Zeilennummer>"
oder "SAVE <Zeilennummer>"
bzw. "LIST <Zeilennumer>"
anzuwählen.
Bei allen genannten Aufrufen wird die angewählte Zeile ausgelistet,
der Cursor bleibt jedoch am Ende der Zeile stehen. Mit CNTRL-A
(Drücken der Tasten CNTRL und "A" gleichzeitig wird der Cursor, ohne
die "darunter" liegenden Zeichen zu löschen, nach links bewegt. Mit
CNTRL-F kann der Cursor nach rechts, bis zum Zeilenende bewegt
werden.
Im Editiermodus ist die Eingabe immer auf "Einfügen" geschaltet,
d.h. ab der momentanen Cursorposition kann neuer Text geschrieben
werden; evtl. rechts vom Cursor stehender Text wird automatisch
weiter nach rechts verschoben. Soll ein Zeichen gelöscht werden kann
dies mit CNTRL-G geschehen, wenn das Zeichen "unter" dem Cursor
gelöscht werden soll, mit DEL, BS (oder CNTRL-H) können die Zeichen
rechts vom Cursor gelöscht werden. Der rechts vom Cursor
verbleibende Text wird aufgerückt.
Mit CNTRL-B kann der Cursor vom Zeilenende zum Zeilenanfang (und
zurück) positioniert werden.
Mit CR (möglich an jeder beliebigen Cursorposition) wird die
bearbeitete Zeile übernommen. Dies bedeutet gleichzeitig, wenn beim
Editieren die Zeilennummer gelöscht wurde, daß auch die ganze Zeile
gelöscht wird.
Soll (auch nach bereits vorgenommener Änderung) der "alte"
Zeileninhalt doch übernommen werden, kann die zu editierende Zeile
mit CNTRL-C unverändert verlassen werden.
Nach Abschluß der Bearbeitung der laufenden Zeile zeigt das LIST-
Kommando in dieser Betriebsart die nächste Zeile in der gleichen
Weise an. Durch Eingabe von CNTRL-C wird der Editiermodus verlassen.
Hinweis:
Syntaxfehler: Werden bei der Programmeingabe Syntaxfehler
erkannt, wird die fehlerhafte Zeile nach der
Fehlermeldung "Syntax-Fehler" automatisch im
-22-

23. Editier-Modus zur Fehlerkorrektur angeboten.
FREEZE-Betrieb: Im Echtzeitbetrieb sind die Editiermöglich-
keiten unterbunden.
-23-

24. 4. Echzeitspezifische Sprachmittel
4.1 Übersicht
Um die Echtzeitmöglichkeiten von MSRBASIC angemessen einsetzen zu
können, ist es neben der Kenntnis der Einzelbefehle vor allem
notwendig, sich mit dem im folgenden beschriebenen Grundkonzept
vertraut zu machen.
4.1.1 MSRBASIC-Echtzeitkonzept
Die MSRBASIC-Echzeit-Philosophie wird deutlich, wenn man
Automatisierungsaufgaben bei industriellen Prozessen hinsichtlich
ihres Zeitverhaltens unterteilt. Im wesentlichen lassen sich hierbei
zwei Grundtypen von Verarbeitsfunktionen erkennen:
1. immer oder zeitweise im Eingriff befindliche
"zeitkontinuierliche" Funktionen wie z.B. lineare
Regelung, Überwachung und Verriegelung, Filterung u.a.m.
2. Zeit- oder prozeßgeführte Ablaufsteuerungen, in denen
sich ein ereignisdiskreter Prozeßablauf widerspiegelt,
wie z.B. aufeinanderfolgende Bearbeitungsschritte an
einer Werkbank, das Anfahren einer bestimmten Position
oder das Abwarten einer Grenzwertüberschreitung.
Diesem Dualismus trägt MSRBASIC im Gegensatz zu vielen
Echtzeitsprachen durch das explizite Bereitstellen von zwei
nebenläufigen Programmtypen Rechnung, nämlich TASK für zyklisch zu
startenden Programme und SEQuenz für Ablaufsteuerungs-Programmteile.
Bei reinen Regelungsanwendungen werden nur TASKs verwendet, während
z.B. bei der zeitgesteuerten Änderung der Sollwerte, etwa beim
Abfahren eines Temperaturprofils, die Sollwertvariable der Regeltask
durch eine SEQuenz zu bestimmten Zeiten verändert wird. Anderseits
sind rein ereignis-orientierte (Fertigungs-, Montage- u.a.) Prozesse
durch parallele Abläufe gekennzeichnet, da sich oft mehrere
Werkstücke in aufeinanderfolgenden Sektionen einer gemeinsam
gesteuerten Bearbeitungsmaschine befinden.
Solche zeitgleichen Abläufe werden durch verbale Spezifi-kationen,
Petri-Netze oder Funktionspläne beschrieben oder dargestellt. Diese
Beschreibungsformen lassen sich sehr leicht in MSRBASIC-SEQuenzen
übertragen, denn es sind gleichzeitig mehrere aktive SEQuenzen
zulässig. Bei gleichzeitig lauffähigen SEQuenzen wird ggf. die
Prozessorzeit aufgeteilt.
Die grundlegend unterschiedliche Aufgabenstellung von TASKs und
SEQuenzen muß auch vom Programmierer berücksichtigt werden:
TASKs sollen automatisch gestartet und möglichst in einem Zug
abgearbeitet werden, um ihrer quasikontinuierlichen Funktion
gerecht zu werden. Ideal wäre für sie eine unendliche kurze
Ausführungszeit und eine unendlich hohe Aufruffrequenz.
644444444444444444444444444444444444444L4444444444444444444447
5 kontinuierliche * ereignisorientierte5
5 MSR-Funktionen * MSR-Funktionen 5
-24-

25. :4444444444L444444444444444444444444444P444444444444444444444<
5Beispiel * Regelungen * Ablaufsteuerungen 5
5 * Überwachung-Verriegelung * mit Wartebedingungen5
:4444444444P444444444444444444444444444P444444444444444444444<
5grafische * Signalflußplan * Funktionsplan 5
5 * * 5
:4444444444P444444444444444444444444444P444444444444444444444<
5Dar- * * Petri-Netz 5
5stellungs-* * 5
5form * +--------+ * ! 5
5 * Xe ! ! Xa * ! +--- 5
5 *--- ! ! --- * ! ! 5
5 * ! ! * +-----+--+-+ 5
5 * / ! ! / * ! ! 5
5 *--- ! ! --- * +-----+----+ 5
5 * ! ! * ! 5
5 * +--------+ * ! +--- 5
5 * * ! ! 5
5 * * +-----+--+-+ 5
5 * * ! ! 5
5 * * +----------+ 5
5 * * 5
:4444444444P444444444444444444444444444P444444444444444444444<
5MSRBASIC * TASK * SEQuenz 5
5Prg.Typ * * 5
5 * * 5
94444444444N444444444444444444444444444N4444444444444444444448
Schaubild 4.1 Einteilung der MSR-Funktionen
Dagegen hängt die Ausführungsgeschwindigkeit einer SEQuenz
kaum von der Rechengeschwindigkeit des Prozessors, sondern vom
Zustand des technischen Prozesses ab.
Die für eine SEQuenz typische Abhängigkeit der Programmfortsetzung
vom Prozeßzustand wird allgemein als "Weiterschaltbedingung"
bezeichnet. Hierzu bietet MSRBASIC ein spezielles Sprachmittel,
nämlich die WAIT-Anweisung (s.d.) an. Im Vergleich zur IF-Anweisung
bietet sie eine der Gegebenheit besser angepasste Formulierung, die
deutlich macht, daß das Ablaufsteuerungsprogramm bei der
Weiterschaltbedingung verharren soll, bis diese erfüllt ist.
Eine spezielle, für technische Einsätze aber fast unumgängliche
Eigenschaft der WAIT-Anweisung ist die integrierte Überwachung der
Wartezeit mit der Möglichkeit zur Ausnahmebehandlung. Damit können
Fehler im technischen Prozess erkannt und abgefangen werden. Dies
wird bei MSRBASIC durch die Erweiterung der Anweisung auf
WAIT MAX <zeit> ..
ermöglicht.
Die WAIT-Anweisung erleichtert auch die interne Verwaltung der
verschiedene quasiparallelen Programme. Sie bietet im Gegensatz zur
IF-Anweisung dem Echtzeitbetriebssystem eine elegante Möglichkeit,
die laufende SEQuenz zu unterbrechen und die Ausführung anderer
Echtzeitprogramme zu veranlassen.
Im folgenden Abschnitt wird summarisch erläutert, wie der Anwender
-25-

26. die MSRBASIC-Echtzeitmittel handhabt.
4.1.2 Organisation und Handhabung des Echtzeitbetriebes
In MSRBASIC Version 4.0 kann der Anwender bis zu 5 zyklische
Programme (TASKs) und bis zu 25 Ablaufsteuerungen (SEQuenzen)
nebenläufig (quasigleichzeitig) betreiben. Hierzu stehen ihm als
Sprachmittel die Anweisungen WAIT, DEFINE, START, ACTIVATE und
SUSPEND (s.u.) zur Verfügung. Der Echtzeitbetrieb ist durch folgende
Eigenschaften gekennzeichnet:
- TASKs werden als normale BASIC-Unterprogramme geschrieben
und über die DEFINE-Anweisung durch Angabe der Nummer
(Gleichzeitig auch Priorität), des Aufruf-Zeitintervalls
und der Startzeilennummer in die Echtzeitverwaltung
integriert.
- SEQuenzen werden ebenfalls als Unterprogramme geschrieben
und durch Angabe der Nummer und der Startzeile in die
Sequenzverwaltung eingegliedert.
- Die START bzw. ACTIVATE-Anweisung gibt die zyklische
Bearbeitung von TASKs bzw. die einmalige Ausführung von
SEQuenzen frei.
- Mit der SUSPEND-Anweisung können TASKs und SEQuenzen
gezielt aus der Bearbeitung durch das Betriebssystem
herausgenommen werden.
- Höher priore TASKs können aktive Programme niederer
Priorität (= TASKs, SEQuenzen oder das
Hintergrundprogramm) unterbrechen, wobei das laufende
Statement noch bearbeitet wird, um inkonsistente Daten zu
vermeiden.
- Die Quasinebenläufigkeit der SEQuenzen orientiert sich an
den einzelnen Schritten der Ablaufsteuerung. Dies
bedeutet, daß eine SEQuenz solange Rechenzeit inan-spruch
nimmt, bis sie auf die nächste Weiterschaltbedingung
(WAIT) stößt (s.d.), also einen Ablaufschritt ausgeführt
hat, oder ein bestimmtes Rechenzeitintervall (10ms)
erbraucht hat. Erst danach wird auf die nächste SEQuenz
umgeschaltet bis alle SEQuenzen auf die Erfüllung ihrer
momentanen Weiterschaltbedingung warten. Diese werden vom
Echtzeitbetriebssystem zyklisch unter Beachtung der
Priorität überprüft.
- Werden keine Echtzeitprogramme ausgeführt, steht der
MSRBASIC-Interpreter für das Rahmenprogramm, Kommandos
und direkte Anweisungen zur Verfügung.
- Da alle Variablen global gültig sind, kann der Benutzer
auch ohne spezielles Kommunikationsprogramm während des
Echtzeitbetriebes auf alle Variablen mit Hilfe der LET /
PRINT-Anweisung zugreifen.
- Der Datenaustausch zwischen den Echtzeitprozessen
geschieht ebenfalls über die globalen gültigen Variablen.
Damit sind alle Voraussetzungen für einen flexiblen Echtzeitbetrieb
erfüllt, wobei MSRBASIC durch eine Reihe echtzeitorientierter
-26-

27. Fehlersuch-Hilfen (SEQLIST, TASKLIST, TRACE SEQ, TRACE TASK) von
vorneherein eine hohe Transparenz gewährleistet.
4.1.3 Beispiel: "Meßwerterfassung"
Als einfaches Beispiel soll eine typische Meßwerterfassungsaufgabe
betrachtet werden, bei der die Sprungantwort einer Regelstrecke
aufgenomen werden soll:
+--------------+
! Regelstrecke !
DAC(1)------>! !------> ADC(1)
! !
+--------------+
Bild 4.2 Konfiguration "Identifikation einer Regelstrecke"
Diese Aufgabe gliedert sich in mehrere Phasen:
1. Initialisierung von Meßaufbau und Regelstrecke
2. Aufnahme der Meßwerte
3. Verarbeiten der Meßwerte (Filtern, Archivieren)
Das nachfolgende Programm "MESSDEM.BAS" zeigt eine mögliche
Implementierung dieser Aufgabe.
Der Initialisierungsteil (Zeilen 100..190) enthält als wesentlichen
Teil die Deklaration der verwendeten Echtzeitprogramme (SEQ1, TASK1)
und startet SEQ1.
Das Hauptprogramm (Zeilen 1000..1200) weist genau die oben
beschriebene Ablaufstruktur auf und wird als SEQuenz ausgeführt.
Entsprechend dem zweigleisigen MSRBASIC-Echtzeitkonzept ist es in der
Phase 2 naheliegend, das zyklische Einlesen, Filtern (PT1) und Ablegen
von Meßwerten einer TASK zuzuordnen.
Diese TASK (Zeilen 2000..2060) wird zu Beginn der Phase 2 von der
SEQuenz zur zyklischen Bearbeitung freigegeben (AKTIVATE TASK1) und
bei Erfüllung eines bestimmten Kriteriums (hier: alle n Meßwerte
eingelesen) wieder gesperrt (SUSPEND TASK1).
In der letzten Phase werden die Meßwerte auf eine Datei abgespeichert.
-27-

28. 4.1.4 Listing "MESSDEM.BAS"
100 REM **** MESSDEM.BAS ****
105 PRINT "Wieviele Messwerte";
110 INPUT N
120 DIM X(N),TDOWN(1)
130 PRINT "Tastzeit TS in Sekunden";
140 INPUT TS
145 PRINT "Zeitkonstante des Vorfilters";
150 INPUT TF
155 REM Filtertastrate ist um Faktor 10 groesser
160 TSF=TS/10, A=EXP(-TSF/TF), B=1-A
170 DEFINE TASK1, TSF, 2000, SEQ1, 1000
180 START SEQ1
190 STOP Initialisierung
1000 REM **** Sequenz 1 steuert das Experiment ****
1010 REM zunaechst Stellsignal 0 ausgeben
1020 DAC(1)=0
1040 WAIT 5 <=0
1050 DAC(1)=1, NZ=N, I=1, TDOWN(1)=TSF
1060 START TASK1
1070 PRINT "Messung gestartet"
1080 WAIT FOR NZ=0
1090 SUSPEND TASK1
1100 PRINT "Messung beendet"
1110 PRINT "In welcher Datei sollen die Messwerte "
1120 PRINT " abgespeichert werden";
1130 INPUT FN$
1140 OPEN FN$,10,0
1150 REM Abspeicherungsschleife
1160 FOR I=1 TO N
1170 PRINT ON(10) X(I) AS 10F3
1180 NEXT I
1190 PRINT" Experiment beendet"
1200 RETURN Sequenz 1
2000 REM **** TASK1 misst zyklisch den Streckenausgang ****
2010 X=A*X+B*ADC(1)
2020 IF TDOWN(1)>0 THEN RETURN
2040 TDOWN(1)=TS
2050 X(I)=X, I=I+1, NZ=NZ-1
2060 RETURN Task
-28-

29. 4.1.5 Empfehlungen und Warnungen
Die MSRBASIC-Echtzeitfähigkeiten müssen mit Maß und Ziel angewandt
werden, um ein stabiles, verklemmungsfreies Echtzeit-Anwenderprogramm
zu gewährleisten. Insbesondere darf die leichte Handhabbarkeit und
Flexibilität des Multitasking nicht zu einer übertriebenen
Parallelisierung des Anwenderprogrammes führen.
Grundvoraussetzung für ein tragfähiges Echtzeit-Programm ist eine
klare Spezifikation und ein darauf abgestimmtes Programmkonzept.
Hierbei sollten einerseits Funktionen (z.B. Regler gleicher Tastzeit,
streng sequentielle Aktionen), die nicht unbedingt parallel laufen
müssen, durchaus in einer TASK oder SEQuenz zusammengefaßt werden.
Andererseits sollten insbesondere bei ereignisorientierten
Rechenprozessen (Ablauf-steuerungen) alle Ereignisse und Aktionen, die
parallel statt-finden können, auf jeweils eine SEQuenz abgebildet
werden. Hierbei leistet eine Darstellung der Aufgabe in Form eines
Petri-Netzes wertvolle Hilfe, da es den Grad an jeweils not-wendiger
Parallelität strukturell ausweist.
Als weitere Grundregel bei der Konstruktion von Echtzeitsystemen
sollte man bei der Auslegung der Abtastzeit eher restriktiv vorgehen,
um der Gefahr einer auch nur partiellen Überlastung des Rechners
vorzubeugen.
Als Faustregel für "Durchlauf-"zeiten kann man von einer
Bearbeitungszeit von 1..2 ms, bei komplexen Anweisungen auch bis zu
10ms pro Programmzeile rechnen. Damit ergibt es sich aber auch, daß
Wartebedingungen im us-Bereich unrealistisch sind. TASK's mit
Aufrufintervall von 10ms werden andere Programme deutlich "bremsen"
wenn nicht gar völlig totlegen.
-29-

30. 5. Zusammenfassung der echtzeitspezifischen Befehle
Diese Zusammenfassung beschreibt alle Befehle und Funktionen, die
nicht im Standard-Sprachumfang enthalten sind oder vom dort-igen
Gebrauch abweichen.
Bei der Syntax-Beschreibung werden folgende Abkürzungen ver-wendet:
{ } die geschweifte Klammer umfaßt Optionen
Beispiel: DEF{INE} es kann sowohl DEF
als auch DEFINE geschrieben werden.
< > Die spitze Klammer umfasst in der Syntax-
beschreibung nicht nennbare Daten.
Beispiel: <zn> für Zeilennummer
| Dieses Zeichen trennt Wahlmöglichkeiten
Beispiel: TASK|SEQ Es kann TASK oder SEQ
verwendet werden.
{,...} Wiederholungsschleife d.h. der angegebene Teil
kann mehrfach definiert werden.
zn Zeilennummer
sz Startzeile
pp Portadresse (Bereich 0..255)
n Nummer (allgemein)
i Intervall
cr Zeilenende
-30-

31. 5.1 DEFINE
Syntaxdiagramm:
Aufruf:<zn> DEF{INE} {TASK <n>,<i>}|{SEQ <n>},<sz>{,....} <cr>
Funktionsbeschreibung:
Die einzubindenden TASKs oder SEQuenzen werden dem
Echzeitbetriebssystem unter Angabe ihrer Kenndaten
n = Nummer und gleichzeitig Priorität
1..5 bei TASK's und 1..25 bei SEQuenzen
sz = Startzeile
und bei TASK's
i = Aufrufintervall
mit dieser Anweisung bekanntgegeben.
Bei TASKs beträgt das Aufrufintervall maximal 2.54s. Alle Zeitangaben
werden auf 10ms-Stufung abgerundet.
Beispiele:
1000 DEF TASK 1,T1,2000,TASK 2,2*T1,2200,SEQ 1 3000
oder besser lesbar ..
100 NotAus = 1, Regler = 2, t_reg = 5
:
1000 DEF SEQ NotAus,2000,TASK Regler,t_reg,4000
Hinweise:
Die höchste Priorität hat jeweils die TASK bzw. SEQuenz mit der
niedersten Nummer.
Werden Namen verwendet, müssen sie vorher als Variable vorbelegt
werden, z.B.
NotAus = 1
Regler = 1
t_reg = 5
Achtung: Zeilennummern sind nicht als Variable einsetzbar!
Soll eine TASK mit einer größeren Abtastzeit als 2.54s aufgerufen
werden, bietet MSRBASIC über die Timer-Funktion TDOWN folgende
-31-

32. Lösungsmöglichkeit:
100 REM *** Initialisierung ***
120 DEF TASK 1, 2, 1000
130 DIM TDOWN(1)
140 TA=60, TDOWN(1)=1
150 ACTIVATE TASK 1
:
:
1000 REM *** TASK 1
1010 IF TDOWN(1)>0 THEN RETURN
1020 TDOWN(1)=TDOWN(1)+TA
1030 REM .. Ab hier beginnt die TASK eigentlich ..
Diese Lösung bietet die Gewähr, daß selbst bei TASK-Ausführungs-zeiten
>2s keine grob falschen Fehler in den Aufrufintervallen entstehen.
Fehler:
05 TASK bzw SEQ mit der gewünschten Startzeile existiert nicht
13 Nummer von TASK bzw. SEQ ist zu groß oder Zeitintervall
größer als 2.54s
-32-

33. 5.2 START
Syntaxdiagramm:
Aufruf: <zn> START {TASK|SEQ} {ALL|<n>} {,....} <cr>
Funktion:
Die im Argument der Startanweisung angegebenen TASKs werden zur
zyklischen Bearbeitung durch das Betriebssystem freigegeben. Die
Bearbeitung wird grundsätzlich bei der ersten Programmzeile
aufgenommen.
Der START-Aufruf kann für alle (ALL) TASK's bzw. SEQuenzen oder
gezielt für eine Einzelne (mit Nummer <n>) erfolgen.
Beispiel:
100 START TASK ALL, SEQ 1
oder
100 START TASK 1, TASK 2, SEQ 1
Fehler:
26 TASK bzw. SEQ noch nicht definiert
40 Interpreter nicht im Echtzeitbetrieb (FREEZE-Mode)
-33-

34. 5.3 SUSPEND
Syntaxdiagramm:
Aufruf: <zn> SUS{PEND} {TASK|SEQ} {ALL|<n>} {,...} <cr>
Funktion:
Die SUSPEND-Anweisung ermöglicht das Stillegen einzelner (mit
Nummernangabe <n>) oder aller (ALL) TASKs bzw. SEQuenzen.
Hierbei wird die SEQuenzbearbeitung an der momentanen Stelle (in der
Regel an einer WAIT-Anweisung) sofort abgebrochen, wobei evtl.
aktivierte Überwachungs-Zeitgeber (WAIT-MAX-Funktion) ebenfalls
eingefroren werden, um bei Re-Aktivierung (siehe ACTIVATE) eine
sachfremde Fehlerbehandlung (...ELSE...) zu vermeiden.
Die Stillegung von TASKs bedeutet, daß eine laufende TASK zu Ende
gebracht wird, jedoch kein Neustart erfolgt.
Um bei Programmierfehlern eine schnelle Abbruchmöglichkeit
bereitzustellen, können in der Kommandobetriebsart mit CNTRL-D alle
TASKs und mit CNTRL-A alle SEQuenzen stillgelegt werden. Sofern dies
aufgrund von Endlosschleifen nicht ausreichen sollte, kann über CNTRL-
C ein endgültiger Programmabbruch erzwungen werden.
Beispiel:
1000 SUSPEND TASK ALL, SEQ 1
Fehler:
26 TASK bzw. SEQ noch nicht definiert
40 Interpreter nicht im Echtzeitbetrieb (FREEZE-Mode)
-34-

35. 5.4 ACTIVATE
Syntaxdiagramm:
Aufruf:<zn> ACT{IVATE} {TASK|SEQ} {ALL|<n>{,<sz>}} {,...} <cr>
Funktion:
Die im Argument der ACTIVATE-Anweisung (mit Nummer <n> und Startzeile
<sz> oder ALL) angegeben TASKs werden zur zyklischen Bearbeitung durch
das Betriebssystem freigegeben. Die Bearbeitung der angegebenen
SEQuenzen wird im Gegensatz zur START-Anweisung immer in der aktuellen
Zeile fortgesetzt. Dies ist entweder die erste Zeile der SEQuenz,
falls sie noch nicht bearbeitet, oder bereits einmal komplett
durchlaufen wurde.
Falls aber die SEQuenz durch eine SUSPEND-Anweisung (oder durch ein
CNTRL-A) abgebrochen wurde, bewirkt die ACTIVATE-Anweisung eine
Wiederaufnahme der SEQuenz-Bearbeitung an der unterbrochenen Stelle.
Beispiel:
100 ACTIVATE TASK Regler, SEQ NotAus,2050
Fehler:
05 gewünsche Startzeile existiert nicht
26 TASK bzw. SEQ noch nicht definiert
40 Interpreter nicht im real-time-mode (FREEZE-mode)
-35-

36. 5.5 WAIT
Syntaxdiagramm:
Aufruf:
a) <zn> WAIT
<Zeit>
b) <zn> WAIT
FOR <Bedingung>
c) <zn> WAIT
MAX <Zeit> FOR <Bedingung>
d) <zn> WAIT
MAX <Zeit> FOR <Bedingung> ELSE <zn>
|<Anweisung>
e) <zn> WAIT FOR <b1>,...<bn> THEN <zn1>,..<znn>
f) <zn> WAIT MAX <Zeit> FOR <b1>,..<bn> THEN
<zn1>,..<znn>...
... ELSE <Anweisung>
mit bn = Übergangsbedingung(en)
Funktion:
Die WAIT-Anweisung dient im Rahmen von SEQuenzen zur Formulierung von
Weiterschaltbedingungen. In der Form a)..d) unterstützt sie die in der
Praxis besonders häufigen linearen Ablauf-steuerungsstrukturen.
Im allgemeinsten Fall kann jedoch eine Ablaufsteuerung aus einem
Zustand in mehrere Folgezustände übergehen. Hierbei sind
Zustandsgrafen ein geeignetes Darstellungsmittel wie folgendes
Diagramm zeigt:
+)))))))))))))),
B21 * * B31
+)))))))))))))>1 X1 /<)))))))))))),
* * * *
* .))))))))))))))- *
* *
* *
* *
* *
B12 * *B13
+))))))v)))))))), +))))))))v)))))))),
* * * *
* X2 /<)))))))))))))))))))))))>1 X3 *
* * B32 B23 * *
.)))))))))))))))- .)))))))))))))))))-
Bild: Zustandsdiagramm für eine Steuerung mit 3 Zuständen
Dieser Zustand kann mit der Form e) und f) der WAIT-Anweisung
formuliert werden. Hierbei bestimmen bei der internen zyklischen
Prüfung der Weiterschaltbedingungen die erste erfüllte Bedingung
-36-

37. <bn> die Zeilennummer <szi>, bei welcher die SEQuenz fortgesetzt
wird. Ist die Weiterschaltbedingung innerhalb einer vorgegebenen
Überwachungszeit (MAX ...) erfüllt, wird wie bei der IF-Anweisung
das Programm mit der nächsten Zeile fortgesetzt, ansonsten erfolgt
eine programmierbare Fehlerbehandlung, die mit ELSE eingeleitet
wird.
Hinweis:
Der Zeit-Takt ist auf 1s voreingestellt. Dieser Wert kann mit den
Funktionen TDOWN und TUP verändert werden (siehe dort).
In Unterprogrammen ist WAIT nicht erlaubt.
-37-

38. Beispiele:
zu a)
1000 REM *** 10 Minuten warten ***
1020 WAIT 10*60
zu d)
2000 REM Weiterschaltbedingungen mit Zeitüberwachung
2010 WAIT MAX 100 FOR ADC(1)>X0 ELSE 3000
:
3000 PRINT "Füllstand nicht rechtzeitig erreicht"
3010 REM *** Einlaßventil schließen ***
3020 DOUT(1)=0
3030 STOP
zu d)
4000 REM *** Boolsche Bedingung ***
4010 WAIT MAX 10 FOR DIN(1)*(DIN(6)+NOT(DIN(7)) >=1 ELSE
zu b)
5000 WAIT FOR DIN (Hand) + DIN (NotAus)
ist äquivalent zu:
5000 WAIT FOR DIN (Hand) + DIN (NotAus) > 0
Fehler:
14 unerlaubte Relation im Bedingungsteil
27 WAIT wurde ausserhalb einer SEQuenz benutzt
39 WAIT in GOSUB-Unterprogrammen nicht erlaubt
-38-

39. 5.6 TRACE
Syntaxdiagramm:
Aufruf: <zn> TR{ACE} {SEQ{<n>}|TASK}
Funktion:
Beim Einschalten des TRACE-Modus wird beim Programmablauf jede Zeile
vor ihrer Ausführung auf der Konsole aufgelistet. Außerdem werden
bei der Ausführung einer INPUT-Anweisung auf einem nicht-interaktiv
konfigurierten Kanal die eingegebenen Zeichen auf der Konsole
angezeigt.
Folgende Varianten sind möglich:
a) Auslisten aller Befehle (TRACE ohne Zusatz)
b) Auslisten aller SEQuenz-Anweisungen (TRACE SEQ)
c) Auslisten aller TASK-Aneisungen (TRACE TASK)
d) Ein- und Ausschalten einzelner SEQuenzen (TRACE SEQ <sz>)
Hinweis:
Die Variante b) des TRACE-Befehls ist insbesondere dann vorteilhaft,
wenn man nur den in einer SEQuenz implementierten übrgeordneten
Ablauf verfolgen will, nicht jedoch die unterlagerten, zyklischen
TASK-Module.
Durch die Variante d) läßt sich TRACE auch dann noch sinnvoll
nutzen, wenn viele SEQuenzen aktiv sind.
Wird eine SEQuenz im TRACE-Modus ausgelistet, dann erscheint die
SEQuenz-Nummer an der linken Seite der Zeile (wie bei SEQLIST).
Beispiel:
Der folgende Ausschnitt des TRACE-Laufes von drei SEQuenzen zeigt
anschaulich die für diesen Programmtyp wirksame Multitasking-
Strategie nach dem round-robin-Prinzip
S01: 1230 DOUT(1)=1
S02: 2210 DOUT(5)=0, DOUT(6)=0
S03: 3240 Presse=0
S01: 1240 WAIT MAX 10 FOR DIN(1)=0 ELSE 4010
S02: 2220 Fix1=1 : Fix2=0
S03: 3250 WAIT MAX 5 FOR DIN(19)=1 ELSE 6120
S02: 2230 WAIT FOR Fix3=0
5.7 NOTRACE
Syntaxdiagramm:
-39-

40. Aufruf: <zn> NOTR{ACE} {SEQ|TASK}
Funktion:
Abschalten des TRACE-Modus, global oder fuer TASKs bzw. SEQuenzen
-40-

41. 5.8 TASKLIST
Syntaxdiagramm:
Aufruf: <zn> TASKLIST|TL
Funktion:
Auslisten der Startzeile, der Priorität und des Zustandes aller
TASKs.
Die TASKLIST-Anweisung zeigt in jeder Zeile die Nummer und den
Status der ausgelisteten TASKs an.
Beispiel:
T01: 1000 REM Regler
T02: s 2000 REM Speicher
* *
* *
* .)))) Status: s = suspendiert
.))))))))))) TASK-Nummern
-41-

42. 5.9 SEQLIST
Syntaxdiagramm:
Aufruf: <zn> SEQLIST|SL {<n>}
Funktion:
Auslisten des momentanen Programmzählerstandes aller SEQuenzen. Die
SEQLIST-Anweisung zeigt in jeder Zeile die Nummer und den Status der
ausgelisteten SEQuenz an.
Beispiel:
a) SL
S01: s 1210 WAIT FOR DIN(HAND)=1
S02: s 2190 REM -- ABFAHRSEQUENZ --
S03: s 3050 WAIT MAX 60 FOR DIN(XSilo5)=0 ELSE 3100
^ ^
! !
! +---- Status: s=suspendiert
+--------- SEQuenz-Nummer
b) SL Fuell
S09: 4070 WAIT MAX 10*60 FOR DIN(xS3max) ELSE 4430
READY
Hinweise:
a) Die SEQLIST-Anweisung läßt sich für eine zyklisch aufgerufene
Steuerungs-Zustandsübersicht verwenden
b) Das Bedienpersonal kann durch Betätigen einer Taste die
SEQLIST-Funktion zur Fehlersuche aufrufen; besonders wertvoll
ist dies bei der Fehlersuche in gegenseitig verriegelten
Ablaufsteuerungesprogrammen. Liegt z.B. eine Verklemmung vor,
d.h. einige SEQuenzen warten vergeblich auf die gegenseitige
Erfüllung einer Weiterschaltbedingung, so listet SEQLIST die
fraglichen WAIT-Anweisungen aus. Durch manuelles Prüfen der
Weiterschaltbedingung kann dann in der Regel rasch die
Fehlerursache gefunden werden.
-42-

43. 5.10 Logikfunktionen
5.10.1 NOT(X)
Funktion:
NOT(X) liefert den Wert "1", wenn X=0 ist, ist X<>0 wird "0"
zurückgegeben.
Beispiel:
100 REM *** Benutzung von NOT(x)
110 vent1 = 1, tast1 = 1, tast2 = 2, tast3 = 3
:
200 DOUT(vent1)=DIN(tast1)*DIN(tast2)+NOT(DIN(tast3))
:
5.10.2 BIT(N,X)
Funktion:
BIT(N,X) wandelt X in eine 16-Bit-Zahl (-32768 < X < 32767) und
liefert eine "1" wenn das N-te Bit (0..15) gesetzt (=1) ist, ist das
N-te Bit nicht gesetzt (=0) wird eine "0" zurückgegeben.
Beispiel:
100 REM *** BIT-Test ***
110 ready = 4, port = &H40
:
200 x = GET(port)
210 IF BIT(x,ready) THEN 300 ELSE 200
:
300 REM Port ist bereit: jetzt Aktion ...
-43-

44. 5.10.3 Boolsche Ausdrücke
Die Boolschen Operatoren AND und OR können auf die arithmetischen
Operatoren "*" und "+" zurückgeführt werden, wobei deren Rangfolge
auch bei boolschen Verknüpfungen gilt (siehe Kapitel Operatoren).
Beispiel:
a) Funktionsplan
+))))),
X2 ))))))))))))))))))))))))))))))))))))>0 *
+))))), * >= *
X1 )))))))))))))))))))))))>1 * * /))))> Y2
+))))), * * * *
X3 )))))))))>1 * * & /)))))>1 *
* >= * * * .)))))-
* /))))))>1 *
* * .)))))-
X4 )))))))))>0 *
.)))))-
b) MSRBASIC-Formulierung:
100 REM *** Boolsche Verknüpfung AND und OR
110 DOUT(2) = DIN(1)*(DIN(3) + NOT(DIN(4)) + NOT(DIN(2)
Hinweis:
Die boolsche Verknüpfung ist nur bei den boolschen "Ergebnissen" "0"
und "1" möglich. Das maskieren von HEX-Werten z.B.
&H00C5 * &H0080
mit dem erwarteten Ergebnis &H0080, funktioniert hier nicht! Um BIT-
Werte zu testen muß die Funktion BIT(n,x) verwendet werden.
-44-

45. 5.11 Prozeß Ein-/Ausgabe-Funktionen
Die Ein-/Ausgabe von beliebigen Daten verteilt sich in BASIC auf zwei
klar zu trennende Bereiche:
a) Die Ein-/Ausgabe über die Konsole, den Drucker und alternative,
meist seriellen Zusatzkanäle (AUX).
Diese Kanäle werden über die Standard-Funktionen INPUT und
PRINT, LIST, LOAD und SAVE usw. angesprochen.
Die dazugehörenden Kanäle sind fest in das Betriebssystem
eingebunden; der Benutzer braucht sich im Normalfall nicht darum
zu kümmern.
b) Im Sprachumfang von Standard-BASIC nicht definierte Ein-
Ausgabekanäle (Ports) die (falls überhaupt) über die Funktionen
INPORT bzw. OUTPORT angesprochen werden.
Die entsprechenden Kanäle (Ports) sind üblicherweise nicht in
das Betriebssystem eingebunden, der Benutzer muß sich um die
Verwendbarkeit der Kanäle selbst kümmern.
Bei der Prozeß-Ein-/Ausgabe kommt eigentlich nur der Fall (b) in
Frage. Das bedeutet aber: der Programmierer muß genaue Kenntnis über
die verwendeten Ein-/Ausgabe-Bausteine haben, er muß wissen wie diese
zu initialisieren sind, welche Wandelzeiten, welche Statusbits usw. zu
berücksichtigen sind. Dazu kommen noch die Probleme mit der Normierung
und "Lage" bzw. Bedeutung der einzelnen Bits z.B. in einem 12-Bit AD-
Wandler usw....
In MSRBASIC wurde dieses Problem umgangen, indem entsprechende
Funktionseinheiten wie AD-/DA-Wandler, BIT-Ein-Ausgabe-Kanäle und
Zähler bereits softwaremäßig in den Interpreter eingebunden werden. Da
nicht ALLES und JEDES eingebunden werden kann, bedeutet dies natürlich
auch eine Beschränkung in der Anzahl der Kanäle und der Art der
Funktionseinheiten. MSRBASIC ist daher vor allem in diesem Bereich
konfigurationsabhängig (siehe Kapitel Hardware-Anpassung).
Der Zugriff auf die eingebundene Zusatzperipherie erfolgt über
MSRBASIC-typische Funktionen die nachfolgend beschrieben sind.
-45-

46. 5.11.1 Skalare Prozeß-Eingabe-Funktionen
5.11.1.1 ADC(n)
Funktion:
Einlesen eines 16-Bit-Wertes vom Analogkanal (n). Die Anzahl (wieviele
Kanäle) und Art (wieviel Bit Auflösung) der Kanäle sowie die
Skalierung (0..n oder -n..+n) ist konfigurationsabhängig.
Beispiel:
100 REM *** AD-Wert einlesen ***
110 ofen1 = 3
:
200 temp1 = ADC(ofen1)
210 IF temp1 > 100 THEN ..... ELSE ....
Hardware:
Für ECB-Systeme sind bis zu 4 Systemkarten Typ ECB-16AD12B(C)
eingebunden. Damit sind max. 64 AD-Eingskanäle ansprechbar.
Die Kartenadressen müssen wie folgt eingestellt sein:
Kanal 1..16 Adresse 0B0H
Kanal 17..32 Adresse 0B4H
Kanal 33..48 Adresse 0B8H
Kanal 49..64 Adresse 0BCH
Bei TSM-Systemen werden die Module (TSM-16AD12) automatisch erkannt.
Das Modul mit der niedrigesten Adresse beginnt mit Kanal 1..16, das
Modul mit der höchsten Adresse endet mit Kanal 49..64. Die
Moduladressen müßen nicht aufeinanderfolgend ein-gestellt werden!
Bei Kleincomputern der MPS-Serie entfällt eine spezielle Einstellung
(falls ein ADC überhaupt vorhanden ist), da alle Bausteine auf festen
Adressen sind.
-46-

47. 5.11.1.2 DIN(n)
Funktion:
Einlesen des Binärkanals (n). Die Art (TTL, 24Volt usw.) und die
Anzahl der Kanäle ist konfigurationsabhängig. Die eingelesenen Werte
betragen "0" oder "1".
Hinweis:
Es ist zu beachten, daß mit (n) jeweils ein BIT eines (hardwaremäßig
vorgegebenen) Eingangports adressiert wird.
Beispiel:
100 REM *** Binaerwert einlesen ***
110 NotEin = 1, Alarm = 2, Ein = 0
:
200 X = DIN(NotEin)
205 REM ** Wenn NotEin dann Alarm
210 IF X = 0 THEN DOUT(Alarm) = Ein
:
Hardware:
Für ECB-Systeme sind bis zu 8 Systemkarten eingebunden.Damit sind max.
128 digitale Eingangskanäle ansprechbar.
Es können folgende Systemkarten verwendet werden:
8* ECB-24VB, ECB-24V=, ECB-24-VK
Die Kartenadressen müssen wie folgt eingestellt sein:
Kanal 1..16 Adresse 080H
Kanal 17..32 Adresse 082H
Kanal 33..48 Adresse 084H
Kanal 49..64 Adresse 086H
Kanal 65..80 Adresse 088H
Kanal 81..96 Adresse 08AH
Kanal 97..112 Adresse 08CH
Kanal113..128 Adresse 08DH
Bei Verwendung der Systemkarte ECB-OP32IN (Nur Eingang) können nur die
geradzahligen Kartenadressen genutzt werden.
Die ECB-Systemkarten können auch gemischt verwendet werden, solange
sich die Adressen nicht überschneiden. Es ist nicht möglich, z.B. eine
ECB-Relaiskarte auf einer bestimmten Adresse als Ausgang zu verwenden
und, unter der gleichen Adresse, die ECB-OP32IN-Karte als Eingang.
Der Schaltzustand der Relaiskarte ECB-REL16R kann unter einer der oben
angegebenen Adresse zurückgelesen werden.
Bei TSM-Systemen werden die Module TSM-8E24, TSM-8E230 und TSM-32E24
automatisch erkannt. Das Modul mit der niedrigsten Adresse beginnt mit
Kanal 8..16(32). Die Kanalnummern 1..8 sind für die Eingänge auf dem
CPU-Modul reserviert.
-47-

48. Die Adressen der Ausgangsmodule müssen nicht aufeinanderfolgend
eingestellt werden!
Bei Kleincomputern der MPS-Serie entfällt eine spezielle Einstellung
(falls ein digitaler Eingang überhaupt vorhanden ist), da alle
Bausteine auf festen Adressen sind.
-48-

49. 5.11.1.3 GET(pp)
Funktion:
Einlesen des Eingabeports (pp). Diese Funktion entspricht der Funktion
INPORT(pp) im Standard-BASIC. Der eingelesene Wert liegt zwischen 0
und 255 (00H..FFH).
Hinweis:
Es ist zu beachten, daß diese Funktion den angegebenen Eingangsport
mit allen Einschränkungen direkt einliest. Der Programmierer muß auf
eine evtl. notwendige Initialisierung des Eingabeports selbst achten
und muß die zurückgelesenen Daten selbst interpretieren!
Beispiel:
100 REM *** Lesen eines Ports nach Statusabfrage
100 Basis = &H80
:
200 stat = GET(Basis)
205 REM pruefen ob ein Zeichen vorliegt
210 stat = BIT(2,stat)
220 IF stat = 0 THEN 200
225 REM JA .. Zeichen liegt vor
230 char = GET(Basis+1)
240 REM Im Beispiel Zeichen als ASCII auf Konsole
250 PRINT char$(char);
-49-

50. 5.11.1.4 CNT(n)
Funktion:
Einlesen eines Zählerkanals (n). Die Art (8 oder 16-Bit Zähler) und
die Anzahl der vorhandenen Zählerkanäle sind konfigurationsabhängig.
Beispiel:
100 REM *** Zaehlerbeispiel ***
110 max = 1024
:
200 count = CNT(0)
210 IF count < max THEN 1000
220 REM Zaehler zuruecksetzen
230 CNT(0) = 0
240 REM ... und jetzt reagieren auf Ueberlauf
:
1000 REM Hierher wenn "Endstand noch nicht erreicht"
Hardware:
Bei TSM sind die 8 Digital-Eingänge auf der CPU-Baugruppe wahlweise
als 24-Volt-Eingang oder als Zähler zugelassen. Die CNT-Funktion
liefert die anliegende Frequenz und die DIN-Funktion den anliegenden
Pegel zurück. Die Bezeichnung der Kanäle ist CNT(1)..CNT(8) bzw.
DIN(1)..DIN(8).
Die Zähler können recht hohe sowie unsymetrische Frequenzen erfassen,
die hauptsächlich durch die Eingangsbeschaltung (intern, extern,
Filter, Optokopler u.Ä.) begrenzt sind. Die Torzeit beträgt bei allen
Zählern 100 ms; zurückgegeben wird die anliegende Frequenz/10.
Für ECB-Systeme und MPS-Einplatinencomputer bitte gesondert anfragen.
-50-

51. 5.11.2 Skalare Prozeß-Ausgabe-Funktionen
Die Prozeß-Ausgabe-Funktionen sind das jeweilige Gegenstück zu den
oben genannten Eingabe-Funktionen. Im Gegensatz zu diesen stehen sie
aber immer auf der linken Seite von Zuweisungen.
5.11.2.1 DAC(n)
Funktion:
Dies ist die Umkehrung der Funktion ADC(n). Es wird ein 16-Bit
(Digital-) Wert auf den Analogkanal (n) ausgegeben. Die Art (Auflösung
8 oder 16-Bit) und die Anzahl der Kanäle sowie die Skalierung ist
konfigurationsabhängig.
Hinweis:
Es erfolgt keine Fehlermeldung wenn versucht wird ein 16-Bit-Wert auf
einen 8-Bit-Kanal auszugeben. Ausgegeben wird in diesem Falle der
untere 8-Bit-Wert (Bereich 0..255) !
Beispiel:
100 REM *** Beispiel einer Analog-Ausgabe
110 Vent1 = 1, ESch1 =1 ESch2 = 2
:
190 REM Pruefen auf Endbedingung
200 x = GET(ESch2)
210 IF x = 1 THEN 300
220 REM Ventil 1 langsam oeffnen bis ESch2 = 1
230 temp=1
240 DAC(Vent1) = temp
250 temp = temp+1
260 x = GET(ESch2)
270 IF x = 0 THEN 250
290 REM wenn ESch2 schaltet ...
300 REM Ventil 1 langsam schliessen bis ESch1 = 1
310 temp=254
320 DAC(Vent1)=temp
330 temp=temp-1
340 x = GET(ESch1)
350 IF x = 0 THEN 320
360 GOTO 220
:
Hardware:
Für ECB-Systeme sind bis zu 4 Systemkarten Typ ECB-4DA12 ein-gebunden.
Damit sind max. 16 DA-Ausgangskanäle ansprechbar.
Die Kartenadressen müssen wie folgt eingestellt sein:
Kanal 1..4 Adresse 0C0H
Kanal 5..8 Adresse 0C4H
Kanal 9..12 Adresse 0C8H
Kanal 13..16 Adresse 0CCH
Bei TSM-Systemen werden die Module (TSM-2DA12) automatisch erkannt.
Das Modul mit der niedrigsten Adresse beginnt mit
Kanal 1..2. Die Moduladressen müßen nicht aufeinanderfolgend
eingestellt werden!
-51-

52. Bei Kleincomputern der MPS-Serie entfällt eine spezielle Einstellung
(falls ein DAC überhaupt vorhanden ist), da alle Bausteine auf festen
Adressen sind.
-52-