;Steffen Ast / Joerg Navratil
;Treiber fuer Fischer-Roboter
;Projekt im Fach Robotik II
;Stellt Routinen zur Ansteuerung eines ’Computing Interface’s
;der Firma ’fischertechnik’ bereit
;Version 2.0.0.0 vom 17.01.2003
;HTWK Leipzig Fachbereich Informatik, Mathematik und Naturwissenschaften
;public
; function createRob(LPT, Max1, Max2, Max3, Min3: Word): Word;
; function freeRob: Word;
; function defRob: Word;
; function testRob(Motoren: Word; var Endsch, Geber1, Geber2, Geber3: Word): Word;
;
;;; neu <nicht getestet>                                              ;;;
;;; function readRob(var Endsch, Geber1, Geber2, Geber3: Word): Word; ;;;
;;; neu                                                               ;;;
;
; function openRob: Word;
; function cntlRob(Motoren: Word; var Endsch, Geber1, Geber2, Geber3: Word): Word;
; function closeRob: Word;
;
;private
; procedure isrRob;

.model small
.stack 256
.data
lpt DW 378h
motor DB 0
endschalter DB 0
geber1 DW 0
geber2 DW 0
geber3 DW 0
action DB 0
savedx DW ?
saveds DW ?
rsw DW 0
sw DW 2
wahr4 DB 0;merkt sich letzte Fahrtrichtung des Freiheitsgrates
wahr3 DB 0;0=aus 1=links 2=rechts
wahr2 DB 0
Geber1Last DB 0
Geber2Last DB 0
Geber3Last DB 0
Geber1MAX DW 3000
Geber2MAX DW 1140
Geber3MAX DW 1200
Geber3MIN DW 740

.code

dataOut MACRO
	LOCAL isNull, return
	push cx
	mov ch, 128 ;CH als Vergleichsgroesse Bit 7=1
	and ch, ah ;CH==1 wenn Motor angesteuert werden soll
	jz IsNull ;Motorrichtung ist nicht angewaehlt springe zu Marke
	or al, 4 ;dataOut auf 1 setzen
	jmp return
isNull:
	and al, 251 ;dataOut auf 0 setzen
return:
	pop cx
	ENDM

dataIn MACRO
	LOCAL return
	mov bl, al ;push(BL, AL)
	inc dx ;LPT um 1 erhoehen
	in al, dx ;Datum einschwingen lassen
	in al, dx ;Datum einschwingen lassen
	in al, dx ;eingeschwungenes Datum vom Interface holen
	and al, 128 ;nur Bit 7 wird weiterverarbeitet
	or ah, al ;E(x) wird an die passende Stelle in AH eingefuegt
	rol ah, 1 ;naechste Position in AH an die vorderste Stelle schieben
return:
	dec dx ;LPT wieder auf Datenuebertragung zurueckschalten
	mov al, bl ;AL=pop(BL)
	ENDM

erstwert MACRO
	LOCAL rotat, zur1, zur0, return
	push ax
	push cx
	push dx
	mov cx, 8 ;Zaehlervariable CX auf 8 setzen
	mov ax, 0 ;AX saeubern
	or al, 50 ;loadInH ;triggAus
	out dx, al ;Impuls an Interface, dass Daten angefordert werden
rotat:
	or al, 56 ;clockH ;triggAus
	out dx, al ;E(CX) Auslesezyklus anmelden
	dataIn ;liest E(CX) in AH
	and al, 245 ;loadInL ;clockL
	or al, 48 ;triggAus
	out dx, al ;E(CX) Auslesezyklus beendet
	loop rotat
	mov bl, 4 ;BL als Vergleichsgroesse Bit 2=1
	and bl, ah ;wenn E3==1 dann BL=1 sonst BL=0
	cmp bl, Geber1Last;hat sich E3(t) zu E3(t-1) veraendert
	je zur1 ;wenn nein gehe zu Marke sonst
	xor Geber1Last, 1;toggeln des letzten gespeicherten Geberzustandes
zur1:
	mov bl, 2 ;BL als Vergleichsgroesse Bit 1=1
	and bl, ah ;wenn E2==1 dann BL=1 sonst BL=0
	cmp bl, Geber2Last;hat sich E2(t) zu E2(t-1) veraendert
	je zur0 ;wenn nein gehe zu Marke sonst
	xor Geber2Last, 1;toggeln des letzten gespeicherten Geberzustandes
zur0:
	mov bl, 1 ;BL als Vergleichsgroesse Bit 0=1
	and bl, ah ;wenn E1==1 dann BL=1 sonst BL=0
	cmp bl, Geber3Last;hat sich E1(t) zu E1(t-1) veraendert
	je return ;wenn nein gehe zu Marke sonst
	xor Geber3Last, 1;toggeln des letzten gespeicherten Geberzustandes
return:
	pop dx
	pop cx
	pop ax
	ENDM

eingabe MACRO
	LOCAL rotat, zur6, zur7, notli1, notli2, notli3, rechts1, rechts2,rechts3, setLast1, setLast2, setLast3, return, setre1, setre2,setre3, bearb1, bearb2, raus1, raus2, setast1, setast2, setast3,links1, links2, links3
	push ax
	push cx
	push dx
	mov cx, 5 ;Zaehlervariable CX auf 5 setzen
	mov ax, 0 ;AX saeubern
	or al, 50 ;loadInH ;triggAus
	out dx, al ;Impuls an Interface, dass Daten angefordert werden
	mov bh, motor ;in BH die letzte Motorenansteuerung laden
rotat:
	or al, 56 ;clockH ;triggAus
	out dx, al ;E(3+CX) Auslesezyklus anmelden
	dataIn ;liest E(3+CX) in AH
	and al, 245 ;loadInL ;clockL
	or al, 48 ;triggAus
	out dx, al ;E(3+CX) Auslesezyklus beendet
	loop rotat
	or al, 56 ;clockH ;triggAus
	out dx, al ;E3 Auslesezyklus anmelden
	dataIn ;liest E3 in AH
	and al, 245 ;loadInL ;clockL
	or al, 48 ;triggAus
	out dx, al ;E3 Auslesezyklus beendet
	mov bl, 1 ;BL als Vergleichsgroesse Bit 0=1
	and bl, ah ;wenn E3==1 dann BL=1 sonst BL=0
	cmp bl, Geber1Last;hat sich E3(t) zu E3(t-1) veraendert
	je zur6 ;wenn nein gehe zu Marke sonst
	mov bl, 64 ;BL als Vergleichsgroesse Bit 7=1
	and bl, bh ;!=0 falls M4 links angesteuert
	jnz rechts1 ;springe zu Marke falls M4 rechts angesteuert sonst
	mov bl, 128 ;BL als Vergleichsgroesse Bit 6=1
	and bl, bh ;!=0 falls M4 rechts angesteuert
	jz setast1 ;springe zu Marke falls M4 nicht links angesteuert sonst
links1:
	dec Geber1 ;Geber M4 um 1 verringern
	mov bl, 32 ;BL als Vergleichsgroesse Bit 5=1
	and bl, ah ;kontrolliert ob E8 angesprochen hat
	jz notli1 ;wenn nicht springe zu Marke sonst
	mov Geber1, 0 ;Geber M4 auf 0 setzen
notli1:
	jmp setre1
setast1:
	mov bl, 0
	cmp bl, wahr4
	je setLast1
	mov bl, 1
	cmp bl, wahr4
	je links1
rechts1:
	inc Geber1 ;Geber M4 um 1 erhoehen
	mov si, Geber1Max
	cmp si, Geber1
	jg setre1
	or ah, 1
	jmp setLast1
setre1:
	and ah, 254
setLast1:
	xor Geber1Last, 1;toggeln des letzten gespeicherten Geberzustandes
zur6:
	or al, 56 ;clockH ;triggAus
	out dx, al ;E2 Auslesezyklus anmelden
	dataIn ;liest E2 in AH
	and al, 245 ;loadInL ;clockL
	or al, 48 ;triggAus
	out dx, al ;E2 Auslesezyklus beendet
	mov bl, 1 ;BL als Vergleichsgroesse Bit 0=1
	and bl, ah ;wenn E2==1 dann BL=1 sonst BL=0
	cmp bl, Geber2Last;hat sich E2(t) zu E2(t-1) veraendert
	je zur7 ;wenn nein gehe zu Marke sonst
	mov bl, 16 ;BL als Vergleichsgroesse Bit 5=1
	and bl, bh ;!=0 falls M3 links angesteuert
	jnz rechts2 ;springe zu Marke falls M3 rechts angesteuert sonst
	mov bl, 32 ;BL als Vergleichsgroesse Bit 4=1
	and bl, bh ;!=0 falls M3 rechts angesteuert
	jz setast2 ;springe zu Marke falls M3 nicht links angesteuert sonst
links2:
	dec Geber2 ;Geber M3 um 1 verringern
	mov bl, 32 ;BL als Vergleichsgroesse Bit 5=1
	and bl, ah ;kontrolliert ob E7 angesprochen hat
	jz notli2 ;wenn nicht springe zu Marke sonst
	mov Geber2, 0 ;Geber M4 auf 0 setzen
notli2:
	jmp setre2
setast2:
	mov bl, 0
	cmp bl, wahr3
	je setLast2
	mov bl, 1
	cmp bl, wahr3
	je links2
rechts2:
	inc Geber2 ;Geber M3 um 1 erhoehen
	mov si, Geber2Max
	cmp si, Geber2
	jg setre2
	or ah, 1
	jmp setLast2
setre2:
	and ah, 254
setLast2:
	xor Geber2Last, 1;toggeln des letzten gespeicherten Geberzustandes
zur7:
	or al, 56 ;clockH ;triggAus
	out dx, al ;E1 Auslesezyklus anmelden
	dataIn ;liest E1 in AH
	and al, 245 ;loadInL ;clockL
	or al, 48 ;triggAus
	out dx, al ;E1 Auslesezyklus beendet
	mov bl, 1 ;BL als Vergleichsgroesse Bit 0=1
	and bl, ah ;wenn E1==1 dann BL=1 sonst BL=0
	cmp bl, Geber3Last;hat sich E1(t) zu E1(t-1) veraendert
	je return ;wenn nein gehe zu Marke sonst
	mov bl, 4 ;BL als Vergleichsgroesse Bit 3=1
	and bl, bh ;!=0 falls M2 links angesteuert
	jnz rechts3 ;springe zu Marke falls M2 rechts angesteuert sonst
	mov bl, 8 ;BL als Vergleichsgroesse Bit 2=1
	and bl, bh ;!=0 falls M2 rechts angesteuert
	jz setast3 ;springe zu Marke falls M2 nichtlinks angesteuert sonst
links3:
	dec Geber3 ;Geber M2 um 1 verringern
	mov bl, 32 ;BL als Vergleichsgroesse Bit 5=1
	and bl, ah ;kontrolliert ob E6 angesprochen hat
	jz notli3 ;wenn nicht springe zu Marke sonst
	mov Geber3, 0 ;Geber M2 auf 0 setzen
notli3:
	jmp setre3
setast3:
	mov bl, 0
	cmp bl, wahr2
	je setLast3
	mov bl, 1
	cmp bl, wahr2
	je links3
rechts3:
	inc Geber3 ;Geber M2 um 1 erhoehen
	mov si, Geber3Max
	cmp si, Geber3
	jg setre3
	or ah, 1
	jmp setLast3
setre3:
	and ah, 254
setLast3:
	xor Geber3Last, 1;toggeln des letzten gespeicherten Geberzustandes
return:
	mov endschalter, ah;AH in Variable Endschalter speichern
	pop dx
	pop cx
	pop ax
	ENDM

ausgabe MACRO
	LOCAL isleft1, isleft2, isleft3, isrigth1, isrigth2, isrigth3, tstundr1,tstundr2, tstundr3, tstover1, tstover2, tstover3, behind1, behind1r,behind2, behind2r, behind3, behind3r, isright1, isright2, isright3,greifer, iszu, isauf, tstzu, tstauf, behind4, behind4z
	push ax
	push cx
	push dx
	mov ax, 0 ;AX saeubern
	mov ah, motor ;in AH die letzte Motorenansteuerung laden
	mov bl, endschalter;in BL die letzten Endschalterwerte laden
	and al, 254 ;loadOutL
	or al, 48 ;triggAus
	out dx, al ;Ausgabe der Motordaten ankuendigen
	mov al, 0 ;AL saeubern
	dataOut ;Datenleitung DataOut anpassen
isleft1:
	mov bh, 128 ;BH als Vergleichsgroesse Bit 7=1
	and bh, ah ;BH Bit 7==1 wenn M4 links fahren soll
	jz behind1 ;wenn Bit 7==0 springe zu Marke sonst
tstundr1:
	and bh, bl ;Bit 7==1 wenn Endschalter M4 angefahren
	jz behind1 ;wenn Endschalter nicht angefahren springe zu Marke sonst
	and al, 251 ;dataOut auf 0 setzen
behind1:
	and al, 254 ;loadOutL
	or al, 48 ;triggAus
	out dx, al ;M4 links Ausgabe vorbereiten
	and al, 254 ;loadOutL
	or al, 56 ;clockH ;triggAus
	out dx, al ;einschwingen lassen
	out dx, al ;einschwingen lassen
	out dx, al ;M4 links ausgeben
	and al, 246 ;clockL ;loadOutL
	or al, 48 ;triggAus
	out dx, al ;M4 links Ausgabe beenden
	rol ah, 1 ;naechste Position in AH an die vorderste Stelle schieben
	mov al, 0 ;AL saeubern
	dataOut ;Datenleitung DataOut anpassen
isright1:
	mov bh, 128 ;BH als Vergleichsgroesse Bit 7=1
	and bh, ah ;BH Bit 7==1 wenn M4 rechts fahren soll
	jz behind1r ;wenn Bit 7==0 springe zu Marke sonst
tstover1:
	mov si, geber1 ;M4 Geber-inkrement in SI schreiben
	cmp si, Geber1Max;aktuellen Geberwert mit max Wert vergleichen
	jle behind1r ;wenn Geber<max springe zu Marke sonst
	and al, 251 ;dataOut auf 0 setzen
behind1r:
	and al, 254 ;loadOutL
	or al, 48 ;triggAus
	out dx, al ;M4 rechts Ausgabe vorbereiten
	and al, 254 ;loadOutL
	or al, 56 ;clockH ;triggAus
	out dx, al ;einschwingen lassen
	out dx, al ;einschwingen lassen
	out dx, al ;M4 rechts ausgeben
	and al, 246 ;clockL ;loadOutL
	or al, 48 ;triggAus
	out dx, al ;M4 rechts Ausgabe beenden
	rol ah, 1 ;naechste Position in AH an die vorderste Stelle schieben
	mov al, 0 ;AL saeubern
	dataOut ;Datenleitung DataOut anpassen
isleft2:
	mov bh, 128 ;BH als Vergleichsgroesse Bit 7=1
	and bh, ah ;BH Bit 7==1 wenn M3 links fahren soll
	jz behind2 ;wenn Bit 7==0 springe zu Marke sonst
tstundr2:
	mov bh, 64 ;BH als Vergleichsgroesse Bit 6=1
	and bh, bl ;Bit 6==1 wenn Endschalter M3 angefahren
	jz behind2 ;wenn Endschalter nicht angefahren springe zu Marke sonst
	and al, 251 ;dataOut auf 0 setzen
behind2:
	and al, 254 ;loadOutL
	or al, 48 ;triggAus
	out dx, al ;M3 links Ausgabe vorbereiten
	and al, 254 ;loadOutL
	or al, 56 ;clockH ;triggAus
	out dx, al ;einschwingen lassen
	out dx, al ;einschwingen lassen
	out dx, al ;M3 links ausgeben
	and al, 246 ;clockL ;loadOutL
	or al, 48 ;triggAus
	out dx, al ;M3 links Ausgabe beenden
	rol ah, 1 ;naechste Position in AH an die vorderste Stelle schieben
	mov al, 0 ;AL saeubern
	dataOut ;Datenleitung DataOut anpassen
isright2:
	mov bh, 128 ;BH als Vergleichsgroesse Bit 7=1
	and bh, ah ;BH Bit 7==1 wenn M3 rechts fahren soll
	jz behind2r ;wenn Bit 7==0 springe zu Marke sonst
tstover2:
	mov si, geber2 ;M3 Geber-inkrement in SI schreiben
	cmp si, Geber2Max;aktuellen Geberwert mit max Wert vergleichen
	jle behind2r ;wenn Geber<max springe zu Marke sonst
	and al, 251 ;dataOut auf 0 setzen
behind2r:
	and al, 254 ;loadOutL
	or al, 48 ;triggAus
	out dx, al ;M 3 rechts Ausgabe vorbereiten
	and al, 254 ;loadOutL
	or al, 56 ;clockH ;triggAus
	out dx, al ;einschwingen lassen
	out dx, al ;einschwingen lassen
	out dx, al ;M3 rechts ausgeben
	and al, 246 ;clockL ;loadOutL
	or al, 48 ;triggAus
	out dx, al ;M3 rechts Ausgabe beenden
	rol ah, 1 ;naechste Position in AH an die vorderste Stelle schieben
	mov al, 0 ;AL saeubern
	dataOut ;Datenleitung DataOut anpassen
isleft3:
	mov bh, 128 ;BH als Vergleichsgroesse Bit 7=1
	and bh, ah ;BH Bit 7==1 wenn M2 links fahren soll
	jz behind3 ;wenn Bit 7==0 springe zu Marke sonst
tstundr3:
	mov bh, 32 ;BH als Vergleichsgroesse Bit 5=1
	and bh, bl ;Bit 5==1 wenn Endschalter M2 angefahren
	jz behind3 ;wenn Endschalter nicht angefahren springe zu Marke sonst
	and al, 251 ;dataOut auf 0 setzen
behind3:
	and al, 254 ;loadOutL
	or al, 48 ;triggAus
	out dx, al ;M2 links Ausgabe vorbereiten
	and al, 254 ;loadOutL
	or al, 56 ;clockH ;triggAus
	out dx, al ;einschwingen lassen
	out dx, al ;einschwingen lassen
	out dx, al ;M2 links ausgeben
	and al, 246 ;clockL ;loadOutL
	or al, 48 ;triggAus
	out dx, al ;M2 links Ausgabe beenden
	rol ah, 1 ;naechste Position in AH an die vorderste Stelle schieben
	mov al, 0 ;AL saeubern
	dataOut ;Datenleitung DataOut anpassen
isright3:
	mov bh, 128 ;BH als Vergleichsgroesse Bit 7=1
	and bh, ah ;BH Bit 7==1 wenn M2 rechts fahren soll
	jz behind3r ;wenn Bit 7==0 springe zu Marke sonst
tstover3:
	mov si, geber3 ;M2 Geber-inkrement in SI schreiben
	cmp si, Geber3Max;aktuellen Geberwert mit max Wert vergleichen
	jle behind3r ;wenn Geber<max springe zu Marke sonst
	and al, 251 ;dataOut auf 0 setzen
behind3r:
	and al, 254 ;loadOutL
	or al, 48 ;triggAus
	out dx, al ;M2 rechts Ausgabe vorbereiten
	and al, 254 ;loadOutL
	or al, 56 ;clockH ;triggAus
	out dx, al ;einschwingen lassen
	out dx, al ;einschwingen lassen
	out dx, al ;M2 rechts ausgeben
	and al, 246 ;clockL ;loadOutL
	or al, 48 ;triggAus
	out dx, al ;M2rechts Ausgabe beenden
	rol ah, 1 ;naechste Position in AH an die vorderste Stelle schieben
greifer:
	mov al, 0 ;AL saeubern
	dataOut ;Datenleitung DataOut anpassen
isauf:
	mov bh, 128 ;BH als Vergleichsgroesse Bit 7=1
	and bh, ah ;BH Bit 7==1 wenn M1 auf fahren soll
	jz behind4 ;wenn Bit 7==0 springe zu Marke sonst
tstauf:
	mov bh, 16 ;BH als Vergleichsgroesse Bit 4=1
	and bh, bl ;Bit 4==1 wenn Endschalter M1 angefahren
	jz behind4 ;wenn Endschalter nicht angefahren springe zu Marke sonst
	and al, 251 ;dataOut auf 0 setzen
behind4:
	and al, 254 ;loadOutL
	or al, 48 ;triggAus
	out dx, al ;M1 auf Ausgabe vorbereiten
	and al, 254 ;loadOutL
	or al, 56 ;clockH ;triggAus
	out dx, al ;einschwingen lassen
	out dx, al ;einschwingen lassen
	out dx, al ;M1 auf ausgeben
	and al, 246 ;clockL ;loadOutL
	or al, 48 ;triggAus
	out dx, al ;M1 auf Ausgabe beenden
	rol ah, 1 ;naechste Position in AH an die vorderste Stelle schieben
	mov al, 0 ;AL saeubern
	dataOut ;Datenleitung DataOut anpassen
iszu:
	mov bh, 128 ;BH als Vergleichsgroesse Bit 7=1
	and bh, ah ;BH Bit 7==1 wenn M1 zu fahren soll
	jz behind4z ;wenn Bit 7==0 springe zu Marke sonst
tstzu:
	mov bh, 8 ;BH als Vergleichsgroesse Bit 3=1
	and bh, bl ;Bit 3==1 wenn Endschalter M1 angefahren
	jz behind4z ;wenn Endschalter nicht angefahren springe zu Marke sonst
	and al, 251 ;dataOut auf 0 setzen
behind4z:
	and al, 254 ;loadOutL
	or al, 48 ;triggAus
	out dx, al ;M1 zu Ausgabe vorbereiten
	and al, 254 ;loadOutL
	or al, 56 ;clockH ;triggAus
	out dx, al ;einschwingen lassen
	out dx, al ;einschwingen lassen
	out dx, al ;M1 zu ausgeben
	and al, 246 ;clockL ;loadOutL
	or al, 48 ;triggAus
	out dx, al ;M1 zu Ausgabe beenden
	rol ah, 1 ;naechste Position in AH an die vorderste Stelle schieben
	mov ax, 0 ;AX saeubern
	or al, 49 ;loadOutH ;triggAus
	out dx, al ;Ausgabe der Motordaten abschliessen
	pop dx
	pop cx
	pop ax
	ENDM

; function createRob(LPT, Max1, Max2, Max3, Min3: Word): Word;
createRob PROC FAR
	PUBLIC createRob
	push bp
	mov bp, sp ;Stackpointer auf Blockpointer uebergeben
	mov dx, [bp+14] ;ersten Parameter holen
	mov lpt, dx ;Portadresse speichern
	mov action, 0 ;Schalter fuer ISR ruecksetzen
	mov ax, [bp+12] ;zweiten Parameter holen
	mov Geber1Max, ax;max. Inkrementanzahl fuer M4 festlegen
	mov ax, [bp+6] ;fuenften Parameter holen
	mov Geber3Min, ax;min. Inkrementanzahl fuer M2 festlegen
	mov ax, [bp+8] ;vierten Parameter holen
	mov Geber3Max, ax;max. Inkrementanzahl fuer M2 festlegen
	mov ax, [bp+10] ;dritten Parameter holen
	mov Geber2Max,ax;max. Inkrementanzahl fuer M3 festlegen
	erstwert
	mov wahr4, 0
	mov wahr3, 0
	mov wahr2, 0
	mov ax, 1 ;Rueckgabewert nicht verwendet
	mov sp, bp ;Stackpointer wieder auf Ausgangsposition setzen
	pop bp
	ret 10 ;10 Byte aufraeumen
createRob ENDP

; function freeRob: Word;
freeRob PROC FAR
	PUBLIC freeRob
	push bp
	mov bp, sp ;Stackpointer auf Blockpointer uebergeben
	mov dx, lpt ;Portadresse auf DX laden
	mov action, 0 ;Schalter fuer ISR ruecksetzen
	mov ax, 0000h ;alle Motoren aus
	mov motor, al ;auf Speicherbyte Motoren schreiben
	mov ax, 1 ;Rueckgabewert nicht verwendet
	mov sp, bp ;Stackpointer wieder auf Ausgangsposition setzen
	pop bp
	ret ;0 Byte aufraeumen
freeRob ENDP

; function defRob: Word;
defRob PROC FAR
	PUBLIC defRob
	push bp
	mov bp, sp ;Stackpointer auf Blockpointer uebergeben
	mov dx, lpt ;Portadresse auf DX laden
	mov action, 0 ;Schalter fuer ISR ruecksetzen
	mov ax, 170 ;alle Motoren auf Endanschlag 10101010d
	mov motor, al ;auf Speicherbyte Motoren schreiben
	eingabe ;MACRO Aufruf Sensorabfrage
schleifed:
	mov bl, 240 ;BL als Vergleichsgroesse auf 11110000d setzen
	mov bh, bl ;sichern in BH
	and bl, endschalter;Vergleich ob endschalter 240
	cmp bl, bh ;Vergleich ob alle Endpositionen erreicht
	jne nook ;wenn Endstellung noch nicht erreicht springe zu Marke sonst
	jmp ok ;verlasse Schleife
nook:
	ausgabe ;MACRO Aufruf Motorenansteuern
	eingabe ;MACRO Aufruf Sensorabfrage
	jmp schleifed
	mov ax, 0000h ;alle Motoren aus
	mov motor, al ;auf Speicherbyte Motoren schreiben
ok:
	mov geber1, 0 ;Geber ruecksetzen
	mov geber2, 0
	mov geber3, 0
	erstwert
	mov wahr4, 0
	mov wahr3, 0
	mov wahr2, 0
	mov endschalter, 240
	mov ax, 1 ;Rueckgabewert nicht verwendet
	mov sp, bp ;Stackpointer wieder auf Ausgangsposition setzen
	pop bp
	ret ;0 Byte aufraeumen
defRob ENDP

; function testRob(Motoren: Word; var Endsch, Geber1, Geber2, Geber3: Word): Word;
testRob PROC FAR
	PUBLIC testRob
	push bp
	mov bp, sp ;Stackpointer auf Blockpointer uebergeben
	push ds
	mov dx, lpt ;Portadresse auf DX laden
	mov action, 0 ;Schalter fuer ISR ruecksetzen
	mov ax, [bp+22] ;ersten Parameter holen
	mov motor, al ;auf Speicherbyte Motoren schreiben
	eingabe ;MACRO Aufruf Sensorabfrage
	ausgabe ;MACRO Aufruf Motorenansteuern
	eingabe ;MACRO Aufruf Sensorabfrage
	mov bh, motor ;alte Richtung speichern Beginn
	mov bl, 128
	and bl, bh
	jz die6
	mov wahr4, 1
	jmp die5
die6:
	mov bl, 64
	and bl, bh
	jz null4
	mov wahr4, 2
	jmp die5
null4:
	mov wahr4, 0
die5:
	mov bl, 32
	and bl, bh
	jz die4
	mov wahr3, 1
	jmp die3
die4:
	mov bl, 16
	and bl, bh
	jz null3
	mov wahr3, 2
	jmp die3
null3:
	mov wahr3, 0
die3:
	mov bl, 8
	and bl, bh
	jz die2
	mov wahr2, 1
	jmp die1
die2:
	mov bl, 4
	and bl, bh
	jz null2
	mov wahr2, 2
	jmp die1
null2:
	mov wahr2, 0
die1: 			;alte Richtung speichern Ende
	push es ;alten ES merken
	push ds ;DS auf
	pop es ;ES schreiben
	mov bx, es:geber3;Inkrement von M2 in BX laden
	lds si, [bp+6] ;DS:SI zeigt auf fuenften Parameter
	mov [si], bx ;BX auf DS:SI schreiben
	mov bx, es:geber2;Inkrement von M3 in BX laden
	lds si, [bp+10] ;DS:SI zeigt auf vierten Parameter
	mov [si], bx ;BX auf DS:SI schreiben
	mov bx, es:geber1;Inkrement von M4 in BX laden
	lds si, [bp+14] ;DS:SI zeigt auf dritten Parameter
	mov [si], bx ;BX auf DS:SI schreiben
	xor bx, bx ;BX saeubern
	mov bl, es:endschalter ;gespeicherte Sensordaten auf BL schreiben
	lds si, [bp+18] ;DS:SI zeigt auf zweiten Parameter
	mov [si], bx ;BX auf DS:SI schreiben
	mov ax, 1 ;Rueckgabewert nicht verwendet
	pop es ;alten ES zurueckschreiben
	pop ds
	mov sp, bp ;Stackpointer wieder auf Ausgangsposition setzen
	pop bp
	ret 18 ;18 Byte aufraeumen
testRob ENDP

; function readRob(var Endsch, Geber1, Geber2, Geber3: Word): Word;
readRob	PROC FAR
	PUBLIC readRob
	push bp
	mov bp, sp ;Stackpointer auf Blockpointer uebergeben
	push ds
	mov dx, lpt ;Portadresse auf DX laden
	mov action, 0 ;Schalter fuer ISR ruecksetzen
	eingabe ;MACRO Aufruf Sensorabfrage
	push es ;alten ES merken
	push ds ;DS auf
	pop es ;ES schreiben
	mov bx, es:geber3;Inkrement von M2 in BX laden
	lds si, [bp+6] ;DS:SI zeigt auf fuenften Parameter
	mov [si], bx ;BX auf DS:SI schreiben
	mov bx, es:geber2;Inkrement von M3 in BX laden
	lds si, [bp+10] ;DS:SI zeigt auf vierten Parameter
	mov [si], bx ;BX auf DS:SI schreiben
	mov bx, es:geber1;Inkrement von M4 in BX laden
	lds si, [bp+14] ;DS:SI zeigt auf dritten Parameter
	mov [si], bx ;BX auf DS:SI schreiben
	xor bx, bx ;BX saeubern
	mov bl, es:endschalter ;gespeicherte Sensordaten auf BL schreiben
	lds si, [bp+18] ;DS:SI zeigt auf zweiten Parameter
	mov [si], bx ;BX auf DS:SI schreiben
	mov ax, 1 ;Rueckgabewert nicht verwendet
	pop es ;alten ES zurueckschreiben
	pop ds
	mov sp, bp ;Stackpointer wieder auf Ausgangsposition setzen
	pop bp
	ret 16 ;16 Byte aufraeumen
readRob	ENDP

; function openRob: Word;
openRob PROC FAR
	PUBLIC openRob
	push bp
	mov bp, sp ;Stackpointer auf Blockpointer uebergeben
	push ds
	mov dx, lpt ;Portadresse auf DX laden
saveisr:
	mov ah, 35h ;Interruptadresse holen
	mov al, 1Ch
	int 21h
	mov saveds, es ;und sichern
	mov savedx, bx
newisr:
	mov ah, 25h ;Interruptadresse ueberschreiben
	mov al, 1Ch
	push ds ;DS sichern
	push cs ;CS auf
	pop ds ;DS schreiben
	mov dx, OFFSET isrRob
	int 21h
	pop ds ;ds zurueck schreiben
	mov ax, 0000h ;alle Motoren aus
	mov motor, al ;auf Speicherbyte Motoren schreiben
	mov action, 1 ;Schalter fuer ISR setzen
	mov ax, 1 ;Rueckgabewert nicht verwendet
	pop ds
	mov sp, bp ;Stackpointer wieder auf Ausgangsposition setzen
	pop bp
	ret ;0 Byte aufraeumen
openRob ENDP

; function cntlRob(Motoren: Word; var Endsch, Geber1, Geber2, Geber3: Word): Word;
cntlRob PROC FAR
	PUBLIC cntlRob
	push bp
	mov bp, sp ;Stackpointer auf Blockpointer uebergeben
	push ds
	mov dx, lpt ;Portadresse auf DX laden
	mov action, 1 ;Schalter fuer ISR setzen
	mov ax, [bp+22] ;ersten Parameter holen
	cli ;Interrupts sperren solange Speicher geschrieben oder gelesen wird
	mov motor, al ;auf Speicherbyte Motoren schreiben
	push es ;alten ES merken
	push ds ;DS auf
	pop es ;ES schreiben
	mov bx, es:geber3;Inkrement von M2 in BX laden
	lds si, [bp+6] ;DS:SI zeigt auf fuenften Parameter
	mov [si], bx ;BX auf DS:SI schreiben
	mov bx, es:geber2;Inkrement von M3 in BX laden
	lds si, [bp+10] ;DS:SI zeigt auf vierten Parameter
	mov [si], bx ;BX auf DS:SI schreiben
	mov bx, es:geber1;Inkrement von M4 in BX laden
	lds si, [bp+14] ;DS:SI zeigt auf dritten Parameter
	mov [si], bx ;BX auf DS:SI schreiben
	xor bx, bx ;BX saeubern
	mov bl, es:endschalter ;gespeicherte Sensordaten auf BL schreiben
	sti ;Interrupts freigeben
	lds si, [bp+18] ;DS:SI zeigt auf zweiten Parameter
	mov [si], bx ;BX auf DS:SI schreiben
	mov ax, 1 ;Rueckgabewert nicht verwendet
	pop es ;alten ES zurueckschreiben
	pop ds
	mov sp, bp ;Stackpointer wieder auf Ausgangsposition setzen
	pop bp
	ret 18 ;18 Byte aufraeumen
cntlRob ENDP

; function closeRob: Word;
closeRob PROC FAR
	PUBLIC closeRob
	push bp
	mov bp, sp ;Stackpointer auf Blockpointer uebergeben
	push ds
	mov dx, lpt ;Portadresse auf DX laden
	mov action, 0 ;Schalter fuer ISR ruecksetzen
oldisr:
	mov ah, 25h ;Interruptadr zurueckschreiben
	mov al, 1Ch
	mov dx, savedx ;alte Adresse rueckschreiben
	mov ds, saveds ;altes Datensegment rueckschreiben
	int 21h
	mov ax, 1 ;Rueckgabewert nicht verwendet
	pop ds
	mov sp, bp ;Stackpointer wieder auf Ausgangsposition setzen
	pop bp
	ret ;0 Byte aufraeumen
closeRob ENDP

; Interrupt Service Routine der Robotersteuerung
isrRob PROC FAR
	push ax
	push bx
	push cx
	push dx
	push ds
	push es
	push si
	push di
	push bp
isrinit:
	mov ax, @data ;Datensegment des Programmes laden
	mov ds, ax
	mov ah, 1 ;Aktivierung der ISR durch
	cmp ah, action ;action == 1
	je isrstart ;wenn action==1 dann springe zu Marke sonst
	jmp isrreturn ;verlasse ISR
isrstart:
	mov dx, lpt ;Portadresse auf DX laden
	eingabe ;MACRO Aufruf Sensorabfrage
	ausgabe ;MACRO Aufruf Motorenansteuern
	eingabe ;MACRO Aufruf Sensorabfrage
isrreturn:
	pop bp
	pop di
	pop si
	pop es
	pop ds
	pop dx
	pop cx
	pop bx
	pop ax
	iret ;Ruecksprung aus ISR
isrRob ENDP

end
;Steffen Ast: sast@imn.htwk-leipzig.de