; erstmal die geschwindigkeit und die fahrtrichtung ins register b
mov bh, 127
mov bl, 127

anfang:
; erstma holen wir uns den parport ins haus und schreiben es nach ax.
mov dx, 889
in ax, dx
; ax nach dx kopieren
mov cx, ax
links:
mov dx, cx
; wenn dx and-verknpft mit 32 0 ergibt(11001111 AND 00100000 = 0), dann ist die taste fr nach
; links gedrckt.
; jetzt noch das bit auf null setzen, dass, wenn zurueck zu ueberpruef
; gesprungen wird, das ganze nicht nochmal kommt
; (11001111 OR 00100000 = 11101111)
and dx, 00100000b
cmp dx, 0b
jne rechts
	; unsere fahrtrichtung ins register a kopieren
	mov al, bh
	; 2 hinzufgen
	sub al, 3
	; wenn al < 2, dann zu weiter springen
	cmp al, 3
	jb rechts
	; sonst zurckkopieren
	mov bh, al

; wieder ax nach dx kopiern, dann das selbe spiel mit 64 und rechts
rechts:
mov dx, cx
and dx, 01000000b
cmp dx, 0b
jne vorne
	; unsere fahrtrichtung ins register a kopieren
	mov al, bh
	; 2 hinzufgen
	add al, 3
	; wenn al > 253, dann zu weiter springen
	cmp al, 252	
	ja vorne
	; sonst zurckkopieren
	mov bh, al	

; mit 16 und vorne
vorne
mov dx, cx
and dx, 00010000b
cmp dx, 0b
jne hinten
	; unsere geschwindigkeit ins register a kopieren
	mov al, bl
	; wenn al > 253, dann zu weiter springen
	cmp al, 253
	ja hinten
	; 2 hinzufgen
	add al, 2
	; sonst zurckkopieren, und weiter pruefen
	mov bl, al

; 8 und hinten
hinten:
mov dx, cx
and dx, 00001000b
cmp dx, 0b
jne weiter
	; unsere geschwindigkeit ins register a kopieren
	mov al, bl
	; 2 hinzufgen
	sub al, 2
	; wenn al < 2, dann zu weiter springen
	jb weiter
	; sonst zurckkopieren
	mov bl, al

;; Das Carry-Flag lschen, sonst sorgt das spter fr verwirrung
clc
; register bl: geschwindigkeit bh: fahrtrichtung. 127 = gradeaus
; bzw stehen. < 127 = links bzw rckwrts

weiter:
; --------------------------LINKS-RECHTS----------------------------------

; hier ist das echte gedrehe. erstmal den wert berechnen, den wir zhlen 
; mssen, um zur richtigen richtung zu drehen, und zwar sind das zwischen 1
; und 2 millisekunden, also zwischen 560 und 1120. 
; wir haben das register a und d zur verfgung, beide mit den vollen 4 byte.
; zuerst mal den linksrechts-wert mal 141( 560 / 255 * 64 )
; dann kommt bei lr=0 0ms, bei lr=255 1ms raus
; mal 255, wg den servos. spaeter nochmal mal 2
mov al, bh
mov cl, 255
mul cl
; jetzt liegt in ax der sleepwert * 64, d.h. das ganze muss um 6 bit nach rechts
; verschoben werden, dass der tatsaechliche sleep-wert rauskommt.
shr ax, 6
; jetzt steht in ax, irgendwas zwischen 0 und 560. es soll aber etwas zwischen
; 560 und 1120 rein, also nochmal 560 dazu
; Naja, doch nicht 560, die servos sin ein bisschen eigenartig...
add ax, 400
; noch mal zwei, vorhin hat alles in ein byte passen muessen, jetz nich mehr.
; also einfach nach links verschieben
; wiegesagt, die servos...
shl ax, 1
; soviel muessen wir jetzt zaehlen, also los gehts!

; jetzt steht in ax der wert, den wir sleepen muessen, um auf den
; entsprechenden winkel zu lenken, also los gehts.
; erst ax ins zaehlregister, ecx schreiben, dann parport datapin 1 an
; und dann sinnlos loopen. hinterher parport wieder aus.
mov cx, ax
; Die Adresse vom Parport ist 888
mov dx, 888
mov ax, 0
mov al, 1b
out dx, al
call sleep
mov al, 0
out dx, al


;-----------------------VORNE-HINTEN-------------------------

; jetzt den vh-wert mal 141( 560 / 255 * 64 )
; dann kommt bei vh=0 0ms, bei vh=255 1ms raus
mov ax, 0
mov al, bl
mov cl, 220
mul cl
; jetzt liegt in ax der sleepwert * 64, d.h. das ganze muss um 6 bit nach rechts
shr ax, 6
; jetzt steht in ax, irgendwas zwischen 0 und 560. es soll aber etwas zwischen
; 560 und 1120 rein, also nochmal 560 dazu
add ax, 350
; das ganze nochmal mal zwei, also eins nach links
shl ax, 1
; soviel muessen wir jetzt zaehlen, also los gehts!

; jetzt steht in ax der wert, den wir sleepen muessen, um auf den
; entsprechenden winkel zu lenken, also los gehts.
; erst ax ins zaehlregister, ecx schreiben, dann parport datapin 1 an
; und dann sinnlos loopen. hinterher parport wieder aus.
mov cx, ax
; Die Adresse vom Parport ist 888
mov dx, 888
mov ax, 0
mov al, 10b
out dx, al
; einfach unsere Prozedur aufrufen, die zaehlt das ganze dann ab.
call sleep
mov al, 0
out dx, al


;Nun noch 17 (20 - 3) ms warten...
mov ecx, 16800
call sleep

; jetzt 1 ins register a schreiben, dann interrupt 22 aufrufen, wenn der 
; interrupt a mit zero berschreibt, ist kein zeichen auf der tastatur 
; gedrckt, und wir fangen von vorne an.
mov ah, 01h
int 16h
jz anfang
; wenn nicht zero, dann taste gedrckt -> taste holen, dass sie nicht
; strt, d.h. hinterher in der cmdline steht, dann ende
mov ah, 0h
int 16h
mov ax, 4c00h
int 21h


;------------------------FUNKTIONEN-----------------------------------
sleep:
	dosleep:
		loop dosleep
	ret