Quelltext /~heha/messtech/kreuzt.zip/LASER-MP/UMSTEP.ASM

;Schrittmotor-Steuerung für M20-Karte
;LogInt	equ	1		;Jeden Interrupt loggen
	%MACS
	%NOINCL
	%TITLE "Mikroschritt-Motortreiber-VxD"
	%SUBTTL "Programmkopf: Vereinbarungen usw."
	include tvmm2.inc	;Generelles
	include	debug2.inc	;wegen Debugging
	include	vpicd.inc	;Interrupt-Controller
	IDEAL
UMSTEP_Device_ID	equ	3C0Eh	;von Microsoft bestätigt:
;>You have been assigned a device ID of 3C0Eh for your UMSTEP.386 virtual
;>device.  This number is uniquely assigned to this device.
UMSTEP_Major_Ver	equ	1
UMSTEP_Minor_Ver	equ	10

;=============================
;Diese Programmversion arbeitet nach außen voll mit 16-bit-Registern,
;da ein gleichartiges TSR-Programm für 286er denkbar ist (die geringere
;Rechenleistung ist nicht so sehr das Problem).
ifdef DEBUG
	DISPLAY	!Assembliere Debugversion!
endif

Declare_Virtual_Device  UMSTEP, UMSTEP_Major_Ver, UMSTEP_Minor_Ver,\
			UMSTEP_Ctl, UMSTEP_Device_ID,\
			Undefined_Init_Order, UMSTEP_API, UMSTEP_API

;*********************************************************
;*** Obligatorischer VxD-Botschafts-Funktionsverteiler ***
;*********************************************************
VxD_Locked_Code_Seg
BeginProc UMSTEP_Ctl
	Control_Dispatch Device_Init, UMSTEP_Init
	Control_Dispatch System_Exit, UMSTEP_Exit
	Control_Dispatch VM_Not_Executeable, UMSTEP_VMDies
	Control_Dispatch 1bh, UMSTEP_Dynamic_Init
	Control_Dispatch 1ch, UMSTEP_Dynamic_Exit
	clc
	ret
EndProc UMSTEP_Ctl
VxD_Locked_Code_ends

;********************************************************
;*** Residenter Datenbereich und Konstantendefinition ***
;********************************************************

;Folgende Kommandos gibt es:
SM_GetVer	equ	0	;Versionsnummer holen
SM_SetMotor	equ	1	;Motor hinzufügen, Parameter setzen/ändern
				;(AL=ForceAlloc-Flag, ES:BX=Mem)
SM_GetMotor	equ	2	;Motorparameter holen (AL=Handle, ES:BX=Mem)
SM_RemoveMotor	equ	3	;Motor entfernen (AL=Handle)
SM_SetIntFreq	equ	4	;Interruptfrequenz setzen (BX=Frequenz)
SM_GetIntFreq	equ	5	;Interruptfrequenz holen (BX=Frequenz)
SM_Sync		equ	6	;Referenzfahrt
SM_MoveAbs	equ	7	;Absolutbewegung nach CX:DX
SM_MoveRel	equ	8	;Relativbewegung um CX:DX
SM_Stop		equ	9	;Soforthalt
SM_Free		equ	10	;Motorspulen stromfrei schalten
SM_GetPosition	equ	11	;Position (EDX=CX:DX) und Geschwindigkeit
				;(ESI=DI:SI) erfragen, BX=Frequenz)
SM_LastFunc	equ	11
;{Fehlercodes von Isel}
ME_NoError	equ	0;
ME_WrongFunction equ	1;
ME_InMove	equ	4;
ME_SoftEnd	equ	5;
ME_HardEnd	equ	7;
ME_NoRef	equ	9;
;{Eigene Fehlercodes}
ME_InvalHandle	equ	50;
ME_AlreadyAssigned equ	51;
ME_OutOfHandles	equ	52;
ME_OutOfMemory	equ	53;
ME_InvalPointer	equ	54;
ME_InvalPort	equ	55;
ME_InternErr	equ	56;

NomFreq		equ	1024	;Nominale Frequenz

MC_Observe	=0	;Beachte Endschalter bei Normalbewegung
MC_SyncedOnFree	=1	;Synchronisation beim FREE-Kommando halten
MC_AlwaysSynced	=2	;Annahme: Immer synchronisiert!
MC_SyncRequired	=3	;Synchronisation vor MOVE ERFORDERLICH
MC_Signed	=4	;Vorzeichenbehafteter Mikroschritt-DAC
MC_Table	=5	;Tabelle statt Funktion (Dreieck<->Sinus)
MC_Trapeze	=6	;Trapezförmiger Strom (Trapez<->"Kurve")

MF_InMove	=0	;Motor in Bewegung
MF_InSync	=1	;Referenzfahrt erfolgt gerade
MF_Synced	=2	;Referenzfahrt war erfolgreich
MF_HWECheck	=4	;Endschalter angestoßen: Referenzfahrt erforderlich!
MF_NegDir	=7	;Negative Bewegungsrichtung

struc TMotor
;Aufteilung nach konstantem und variablem Teil
;Der konstante Teil kann via GetMotor() abgefragt und SetMotor() gesetzt werden
 Handle		db	?	;Motor-Handle (0=NEUER MOTOR)
 CFlags		db	0	;Konstante Motor-Flags
 HWEMask	db	1	;Hardware-Endschalter-Maske
 HWEXor		db	?	;Hardware-Endschalter-XOR-Bits
 PortHWE	dw	?	;Portadresse HWE
 union
  Ports		dd	?
  struc
   PortA	dw	?	;Portadresse Spule A (Vergleichskriterium!)
   PortB	dw	?	;Portadresse Spule B (Vergleichskriterium!)
  ends
 ends
 CallbackAddr	dd	0	;16:16-Rückrufadresse
 CallbackDS	dw	?	;Datensegment für Callback
 CallbackUser	dd	?	;32-bit-Anwenderdaten
 MaxSpeed	dd	48*65536;Maximalgeschwindigkeit, vzl.
 RefSpeed	dd	12*65536;Referenz-Geschwindigkeit, vzb.!
 MaxAccel	dd	48	;Maximalbeschleunigung, vzl.!
 Refpoint	dd	0	;Referenzpunkt nach Sync
 LeftBound	dd	-MaxLong;Software-Anschläge
 RightBound	dd	MaxLong
;Der Callback wird gerufen mit
;EDX=CX:DX=Anwender-Daten, AL=Handle, AH=Flags, ESI=DI:SI=Position

;Der folgende variable Teil ist für die VxD-interne Benutzung vorgesehen
 HWPos		dw	0	;"Hardware-Position" als Index in Sinustabelle
 union
  Weg		df	0	;6-Byte-Wert als Restwegspeicher
  struc
   WegLo	dd	?
   WegHi	dw	?
  ends
  struc
   WegLoW	dw	?
   WegMid	dd	?
  ends
 ends
 Pos		dd	0	;Aktuelle Position
 Speed		dd	0	;Momentangeschwindigkeit
 CallbackVM	dd	?	;Virtuelle Maschine
 Flags		dd	?	;Variable Motor-Flags
ends TMotor
;Diese Motor-Struktur wird in einer asynchronen Liste verwaltet.
;Das erlaubt die Ansteuerung von max. 31 Motoren gleichzeitig

PMotor	equ	(TMotor ebx)	;Objektzeiger ist immer EBX
TMotor_ConstLongs equ	11
TMotor_VarLongs	equ	6

	%SUBTTL "Handles und Tabellen"
VxD_Locked_Data_Seg
ListHand	dd	0	;Listen-Handle
IrqHand		dd	0	;IRQ-Griff
Frequency	dw	NomFreq	;für Zeitmessungen usw.
upcounter	dd	?

;Sinus-Tabelle OHNE 0- und 1-Punkt, zentriert auf die Mitte zwischen 7F und 80
;Bedingt durch diese seltsame Zentrierung in der Hardware gibt es keinen
;100% stromfreien Zustand der Motorspule.
;Diese Sinustabelle enthält 256 Werte im Bereich 128..255 für den
;1. Quadranten. Die Quadrantenumrechnung erfolgt durch das Programm GetCos
;bzw. GetSin.
SinTab:
	db	128,129,130,131,132,132,133,134,135,135,136,137,138,139,139,140
	db	141,142,142,143,144,145,145,146,147,148,149,149,150,151,152,152
	db	153,154,155,155,156,157,158,158,159,160,161,161,162,163,164,164
	db	165,166,167,167,168,169,170,170,171,172,173,173,174,175,176,176
	db	177,178,178,179,180,181,181,182,183,183,184,185,185,186,187,188
	db	188,189,190,190,191,192,192,193,194,194,195,196,196,197,198,198
	db	199,200,200,201,201,202,203,203,204,205,205,206,206,207,208,208
	db	209,209,210,211,211,212,212,213,214,214,215,215,216,216,217,218
	db	218,219,219,220,220,221,221,222,222,223,223,224,224,225,225,226
	db	226,227,227,228,228,229,229,230,230,231,231,232,232,233,233,233
	db	234,234,235,235,236,236,236,237,237,238,238,238,239,239,239,240
	db	240,241,241,241,242,242,242,243,243,243,244,244,244,245,245,245
	db	245,246,246,246,247,247,247,247,248,248,248,248,249,249,249,249
	db	250,250,250,250,251,251,251,251,251,251,252,252,252,252,252,252
	db	253,253,253,253,253,253,253,254,254,254,254,254,254,254,254,254
	db	254,254,255,255,255,255,255,255,255,255,255,255,255,255,255,255
KurvTab:
	db	128,130,131,133,134,136,138,139,141,142,144,145,147,148,150,151
	db	152,154,155,157,158,159,161,162,163,164,166,167,168,170,171,172
	db	173,174,175,177,178,179,180,181,182,183,184,185,186,188,189,190
	db	191,192,193,193,194,195,196,197,198,199,200,201,202,202,203,204
	db	205,206,207,207,208,209,210,210,211,212,213,213,214,215,216,216
	db	217,218,218,219,219,220,221,221,222,223,223,224,224,225,225,226
	db	226,227,227,228,229,229,230,230,230,231,231,232,232,233,233,234
	db	234,234,235,235,236,236,236,237,237,238,238,238,239,239,239,240
	db	240,240,241,241,241,242,242,242,242,243,243,243,244,244,244,244
	db	245,245,245,245,245,246,246,246,246,247,247,247,247,247,248,248
	db	248,248,248,248,249,249,249,249,249,249,249,250,250,250,250,250
	db	250,250,251,251,251,251,251,251,251,251,251,252,252,252,252,252
	db	252,252,252,252,252,252,252,253,253,253,253,253,253,253,253,253
	db	253,253,253,253,253,253,253,254,254,254,254,254,254,254,254,254
	db	254,254,254,254,254,254,254,254,254,254,254,254,254,254,254,255
	db	255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255

VxD_Locked_Data_Ends

;*****************************
;*** Sinustabellen-Zugriff ***
;*****************************

VxD_Locked_Code_Seg
;Wegen der besonderen Zentrierung der Sinustabelle erfolgt die Quadranten-
;umrechnung hier nicht mit dem sonst üblichen NEG (Zweierkomplement),
;sondern mit NOT (Einerkomplement).
;Bei gesetztem Dreieck-Bit wird das Ergebnis der Dreiecksfunktion geliefert.

proc GetCos	;PE: AX: Winkelargument, Vollwinkel=1024
		;PA: AL: Funktionsergebnis, Zentrierung wie gewünscht
		;VR: AX
	inc	ah
GetSin:
	test	ah,bit 0
	jz	@@1	;1. oder 3. Quadrant
	not	al	;Bit-Komplement bilden
@@1:	BTST	[PMotor.CFlags],bit MC_Table	;Sinus/Dreieck-Schalter
	BT	[dword PMotor.CFlags],MC_Trapeze
	jnz	@@dreieck
	push	ebx
	 lea	ebx,[SinTab]
	 jnc	@@1a
	 lea	ebx,[KurvTab]
@@1a:	 xlat			;Tabellenzugriff
	pop	ebx
	jmp	FlipAL
@@dreieck:
	jc	@@trapez
	stc		;0-->80, 1-->80, 2-->81, 3-->81, 4-->82,...
	rcr	al,1	;FD-->FE, FE-->FF, FF-->FF (Erster Quadrant)
	jmp	FlipAL
@@trapez:
	add	al,80h	;00-->80, 01-->81, ... 7F-->FF,
	jnc	FlipAL
	sbb	al,al	;AL:=FF,   80-->FF, 81-->FF, .. FF-->FF
FlipAL:	test	ah,bit 1	;3./4. Quadrant
	jz	FlipSign	;nein, positiv lassen
	not	al	;ja, 80-->7F, 81-->7E,... FF-->00
FlipSign:
;Das verflixte Viech arbeitet mit Vorzeichen/Betrag!
;Deshalb "Fast-Food-Patch"
	BTST	[PMotor.CFlags],bit MC_Signed
	jz	@@e
	BTST	al,bit 7
	jnz	@@e
	xor	al,7Fh
@@e:	ret
endp GetCos

;*****************************
;*** Portzugriffe auf CMOS ***
;*****************************

proc GetCMOS
;PE: AH=Adresse im CMOS-RAM
;PA: AL=Wert
;VR: AL
	pushf
	 cli
	 xchg	al,ah
	 out	70h,al
	 IO_DELAY
	 xchg	al,ah
	 in	al,71h
	popf
	ret
endp GetCMOS

proc PutCMOS
;PE: AH=Adresse im CMOS-RAM
;    AL=Wert
;VR: -
	pushf
	 cli
	 xchg	al,ah
	 out	70h,al
	 IO_DELAY
	 xchg	al,ah
	 out	71h,al
	popf
	ret
endp PutCMOS

;*******************************
;*** Direkte Motor-Steuerung ***
;*******************************

;Ausschalten des Stroms durch die Spulen
;PE: EBX: Objektzeiger
;VR: AX
proc Motor_Aus
	mov	al,128
	call	FlipSign
	mov	edx,[PMotor.Ports]
	out	dx,al
	shr	edx,16
	out	dx,al
	BRES	[PMotor.Flags],bit MF_Synced
	ret
endp Motor_Aus

;Allokieren des Motors; Spulenstrom sicherheitshalber ausschalten
;PE: EBX: Objektzeiger
;VR: AX
proc Motor_Init
	pushad
	 call	Motor_Aus
	 mov	ah,0bh
	 call	GetCMOS
	 BSET	al,bit 6	;CMOS Interrupt 1024Hz aktivieren
	 call	PutCMOS
	 mov	eax,[IrqHand]
	 VxDcall VPICD_Phys_EOI	;evtl. verklemmten PIC befreien
	popad
	ret
endp Motor_Init

;Motor um vzb. Betrag bewegen, dieser sollte -256..256 nicht überschreiten.
;Dabei wird die Positions-Arbeitszelle mitgeführt
;PE: EAX: vzb. Betrag (möglichst -256..256)
;    EBX: Objektzeiger
;VR: AX
proc motor_move
	BTST	[PMotor.CFlags],bit MC_AlwaysSynced
	jnz	@@0		;Position IMMER mitführen
	BTST	[PMotor.Flags],bit MF_Synced
	jz	@@1		;Position NICHT mitführen, wenn unbekannt
@@0:	add	[PMotor.Pos],eax
@@1:	add	[PMotor.HWPos],ax
	mov	ax,[PMotor.HWPos]
	mov	edx,[PMotor.Ports]
	push	eax
	 call	GetCos
	 out	dx,al
	pop	eax
	call	GetSin
	shr	edx,16
	out	dx,al
	ret
endp motor_move

;Hardware-Endschalter abfragen
;PE: EBX=Objektzeiger
;PA: NZ: Schalter betätigt; AL enthält die gesetzten Bits
;VR: AL,DX
proc TestSchalter
	mov	dx,[PMotor.PortHWE]
	in	al,dx
	xor	al,[PMotor.HWEXor]
	and	al,[PMotor.HWEMask]
	ret
endp TestSchalter

;****************************
;*** Periodische Aktionen ***
;****************************

proc intreffahrt
IFDEF LogInt
Debug_Out "IntSync "
ENDIF
	call	TestSchalter		;Hardware-Endschalter abfragen
	jnz	@@1			;Treffer - Schalter betätigt
	xor	eax,eax
	BTR	[PMotor.Flags],MF_NegDir	;(+) Richtung ZUM Taster
	jc	@@3			;im Wendepunkt 1x aussetzen
@@5:	mov	eax,[PMotor.RefSpeed]
@@3:	call	MoveBySpeed
	ret
@@1:
	BTST	[PMotor.Flags],bit MF_NegDir	;(-) Richtung VOM Taster?
	jnz	@@5			;War's schon: weiter rückwärts!
;neu: kein "Einrütteln" in exakte Position, sondern
;Aufaddieren der Hardware-Position zum Referenzpunkt
	mov	eax,[dword PMotor.HWPos]	;10-Bit-Zahl holen
	shl	eax,22
	sar	eax,22	;Einfachste Möglichkeit der Vorzeichenerweiterung
	add	eax,[PMotor.Refpoint]
	mov	[PMotor.Pos],eax	;Das ist nun die Position
@@br	equ	%((bit MF_InMove) or (bit MF_InSync) or (bit MF_HWECheck))
	BRES	[PMotor.Flags],@@br
	BSET	[PMotor.Flags],bit MF_Synced
	call	InformWindows
	ret
endp intreffahrt

proc intmoveproc
IFDEF LogInt
Debug_Out "IntMove "
ENDIF
	mov	eax,[PMotor.WegLo]
	or	eax,[PMotor.WegMid]	;Nichts mehr tun?
	jz	@@1
	BTST	[PMotor.CFlags],bit MC_Observe ;HWE-Schaltertest?
	jz	@@2
	call	TestSchalter		;Hardware-Endschalter abfragen
	jnz	@@3
@@2:	call	CalcNewSpeed
	call	MoveBySpeed
	ret

@@3:	xor	eax,eax
	mov	[PMotor.WegLo],eax
	mov	[PMotor.WegHi],ax
	mov	[PMotor.Pos],eax
	BRES	[PMotor.Flags],bit MF_Synced
	BSET	[PMotor.Flags],bit MF_HWECheck
@@1:
	mov	[PMotor.Speed],eax
	BRES	[PMotor.Flags],bit MF_InMove ;Bewegungssegment ENDE
	call	InformWindows
	ret
endp intmoveproc

proc intproc		;Das Innere des Timer-Interrupts
	mov	esi,[ListHand]
	cli
	VMMCall	List_Get_First
	sti
	jz	@@e
@@l:	push	esi
	 xchg	ebx,eax		;EBX=Objektzeiger
	 BTST	[PMotor.Flags],bit MF_InMove
	 jz	@@o
	 BTST	[PMotor.Flags],bit MF_InSync
	 jz	@@m
	 call	intreffahrt
	 jmp	@@o
@@m:	 call	intmoveproc
@@o:	 xchg	eax,ebx
	pop	esi
	cli
	VMMCall	List_Get_Next
	sti
	jnz	@@l
@@e:	inc	[upcounter]
	ret
endp intproc

;*******************************
;*** Interruptserviceroutine ***
;*******************************
;Interruptserviceroutine für den CMOS-Tick mit nominell 1024Hz
;PE: EAX=IRQ-Griff
;    EBX=VM-Griff
	align	4
proc CmosIsr
	sti
	pushad
	 mov	ah,0ch
	 call	GetCMOS
	 BTST	al,bit 6	;Ursache=Echtzeituhr?
	 jz	@@chain		;nein->nicht bedienen!
	 call	intproc
	popad
	VxDcall	VPICD_Phys_EOI
	clc			;ISR behandelte IRQ
	ret
@@chain:
;### BEGIN PATCH 15:26 14.04.1999 ###
	int	3
;### END PATCH 15:26 14.04.1999 ###
	Debug_Halt
	popad
	stc			;weiter verketten!
	ret
endp CmosIsr

;*****************************************
;*** Aktions-Anstöße für Sync und Move ***
;*****************************************

proc StartSegment
;PE: EAX=vzb. Differenz
@@rb	equ	%((bit MF_NegDir) or (bit MF_InSync))
;### BEGIN PATCH 15:25 14.04.1999 ###
	pushad
	 mov	ah,0bh
	 call	GetCMOS
	 BRES	al,bit 6
	 call	PutCMOS
	 BSET	al,bit 6	;CMOS Interrupt 1024Hz aktivieren
	 call	PutCMOS
	 mov	eax,[IrqHand]
	 VxDcall VPICD_Phys_EOI	;evtl. verklemmten PIC befreien
	popad
;### END PATCH 15:25 14.04.1999 ###
	BRES	[PMotor.Flags],@@rb	;Positiv annehmen, keine RefFahrt
	sub	eax,[PMotor.Pos]	;Differenz
	jge	@@1
	neg	eax			;Betrag bilden
	BSET	[PMotor.Flags],bit MF_NegDir ;und Richtung merken
@@1:	push	eax
	 xor	eax,eax
	 mov	[PMotor.Speed],eax	;Geschwindigkeit nullsetzen
	 mov	[PMotor.WegLo],eax
	pop	eax
	mov	[PMotor.WegMid],eax	;und Weg entsprechend setzen
	BSET	[PMotor.Flags],bit MF_InMove ;Und LOS!
	ret
endp

proc StartReffahrt
	mov	[PMotor.Speed],0
@@sb	equ	%((bit MF_InMove) or (bit MF_InSync) or (bit MF_NegDir))
	BSET	[PMotor.Flags],@@sb	;ISR werkeln lassen
	ret
endp

;***************************************
;*** Rückruf-Funktionen für Callback ***
;***************************************

proc PostEventProc
	mov	ebx,edx		;geordnete Verhältnisse
	cmp	[PMotor.CallbackAddr],0
	jz	@@e
	Debug_Halt
	Push_Client_State USES_EDI
	VMMCall	Begin_Nest_Exec
	mov	eax,[PMotor.CallbackUser]
	mov	[PClient._EDX],eax
	shr	eax,16
	mov	[PClient._ECX],eax
	mov	eax,[PMotor.Pos]
	mov	[PClient._ESI],eax
	shr	eax,16
	mov	[PClient._EDI],eax
	mov	al,[PMotor.Handle]
	mov	ah,[byte PMotor.Flags]
	mov	[PClient._EAX],eax
	mov	ax,[PMotor.CallbackDS]
	mov	[PClient._DS],ax
	movzx	edx,[word LOW PMotor.CallbackAddr]
	mov	cx,[word HIGH PMotor.CallbackAddr]
	VMMCall	Simulate_Far_Call
	VMMCall	Resume_Exec
	VMMCall	End_Nest_Exec
	Pop_Client_State USES_ESI
@@e:	ret
endp

proc InformWindows c
uses ebx,ecx,edx
	mov	edx,ebx
	mov	eax,High_Pri_Device_Boost
	mov	ebx,[PMotor.CallbackVM]
	LD	ecx,PEF_Wait_For_STI or PEF_Wait_Not_Crit or PEF_Always_Sched
	lea	esi,[PostEventProc]
	VMMCall	Call_Priority_VM_Event
	ret
endp

;***********************************************
;*** Berechnung des Geschwindigkeitsverlaufs ***
;***********************************************

;PE: EAX=vzl. (oder auch vzb.) Geschwindigkeit in Nanoschritten
;    EBX=Objektzeiger
;PA: - Die Momentangeschwindigkeit wird auf EAX gesetzt
;    - Der Rest-Weg wird entsprechend "gekürzt"
;    - Entsprechend der sich daraus ergebenden Nanoschritt-Differenz
;      werden Mikroschritte in die in Flags angegebene Richtung ausgeführt
proc MoveBySpeed
	BT	[PMotor.Flags],MF_NegDir	;Richtungs-Bit nach CY
	pushfd
	 mov	[PMotor.Speed],eax
	 push	edx
	  mov	edx,[PMotor.WegMid]
	  sub	[PMotor.WegLo],eax
	  sbb	[PMotor.WegHi],0	;Restweg verringert sich
	  sub	edx,[PMotor.WegMid]	;Differenz!
	  mov	eax,edx
	 pop	edx
	popfd
	jnc	@@p
	neg	eax
@@p:	call	motor_move
	ret
endp

;Funktion "Bremsweg berechnen"
;PE: EAX: Momentane (angenommene) Geschwindigkeit, vzl., in Nanoschritten
;    EBX: Zeiger auf Bewegungsstruktur (mit vzl. MaxAccel)
;PA: EDX:EAX: Bremsweg (vzl, E(EDX) immer 0)
;VR: EDX,EAX
IFDEF UseLoop
proc Bremsweg c
uses esi
;for(EDX:ESI=0, EAX=Speed; EAX>0; EAX-=MaxAccel) EDX:ESI+=ECX;
	xor	edx,edx
	xor	esi,esi
@@l:	add	ecx,eax
	adc	edx,0
	sub	eax,[PMotor.MaxAccel]
	ja	@@l
	mov	eax,esi
	ret
endp
ELSE
;Variante 2: schleifenlos
proc Bremsweg c
uses esi,edi
	push	eax	;A1
	xor	edx,edx
	div	[PMotor.MaxAccel]
	inc	eax	;N ermitteln = A1/d +1
	push	eax
	mov	edx,eax
	dec	edx
	mul	edx	;N(N+1)
	shr	eax,1	;N(N+1)/2
	mul	[PMotor.MaxAccel]	;EDX:EAX=N(N-1)d/2
	mov	esi,edx
	mov	edi,eax	;nach ESI:EDI
	pop	eax	;N
	pop	edx	;A1
	mul	edx
	sub	eax,edi
	sbb	edx,esi
	ret
endp
ENDIF

;Funktion "Geschwindigkeit berechnen"
;Anhand des noch zurückzulegenden Restwegs (PMotor.Weg) und
;weiterer Parameter wird ein neuer - möglichst maximaler -
;Geschwindigkeitswert ermittelt
;PE: EBX: Zeiger auf Bewegungsstruktur
;PA: EAX: Neue Geschwindigkeit
proc CalcNewSpeed c
uses ecx,edx,esi
	mov	eax,[PMotor.Speed]
	call	Bremsweg		;Daraus Bremsweg ermitteln
	stc
	sbb	eax,[PMotor.WegLo]	;(Bremsweg-=Restweg+1)
	sbb	dx,[PMotor.WegHi]	;Zu lang?
	jnc	@@ReduceSpeed		;wenn Bremsweg>Restweg
	mov	eax,[PMotor.Speed]
	cmp	[PMotor.MaxSpeed],eax	;Zu groß, wenn Höchstgeschwindigkeit
	jc	@@ReduceSpeed		;verringert wurde
	add	eax,[PMotor.MaxAccel]	;Beschleunigen (versuchen)
	MIN	eax,[PMotor.MaxSpeed]	;Höchstgeschwindigkeit!
	mov	esi,eax			;Merken
	cmp	[PMotor.WegHi],0
	jnz	@@1
	MIN	esi,[PMotor.WegLo]	;Extremfall: Sehr kurzer Weg<Accel
@@1:	call	Bremsweg
	stc
	sbb	eax,[PMotor.WegLo]	;Bremsweg wäre zu lang?
	sbb	dx,[PMotor.WegHi]
	jnc	@@NoAccel
	mov	eax,esi		;Beschleunigungs- oder Fahrphase
	jmp	@@e
@@NoAccel:			;(Kurze) Haltephase beim Abbremsen
	mov	eax,[PMotor.Speed]
	jmp	@@e
@@ReduceSpeed:
	mov	eax,[PMotor.Speed]
	sub	eax,[PMotor.MaxAccel]
	ja	@@e		;Stets >0
	mov	eax,[PMotor.WegLo]
@@e:
	ret
endp CalcNewSpeed

	%SUBTTL "V86- und PM-API"
;*********************************************
;*** Testfunktionen mit Fehlercoderückgabe ***
;*********************************************

;Testet, ob HWE betätigt wurde, und ggf. Fehler melden
proc TestHWE
	BTST	[PMotor.Flags],bit MF_HWECheck	;Endschalter betätigt?
	jz	@@e		;nein, okay
	mov	al,ME_HardEnd
	stc
@@e:	ret
endp

;Testet, ob Motor in Bewegung ist, und liefert, wenn ja, CY=1 und AL=Code zurück
proc TestStill
	BTST	[PMotor.Flags],bit MF_InMove	;In Bewegung?
	jz	@@e		;nein, okay
	mov	al,ME_InMove
	stc
@@e:	ret
endp

;Testet, ob Motor gültige Position hat, d.h. ob eine Referenzfahrt
;ausgeführt wurde, und lädt anschließend EAX aus Client_CX:DX
proc TestReferenz
	call	TestStill
	jc	@@e
	BTST	[PMotor.CFlags],bit MC_SyncRequired
	jz	@@w
	BTST	[PMotor.Flags],bit MF_Synced	;Ungültig?
	jnz	@@w		;Gültig!
	mov	al,ME_NoRef
	stc
@@e:	ret
@@w:	mov	ax,[PClient._CX]
	shl	eax,16
	mov	ax,[PClient._DX]
	clc
	ret
endp

proc TestInBounds
	cmp	eax,[PMotor.LeftBound]
	jl	@@e
	cmp	eax,[PMotor.RightBound]
	jg	@@e
	clc
	ret
@@e:	mov	al,ME_SoftEnd
	stc
	ret
endp

;**********************
;*** API-Funktionen ***
;**********************

proc SMGetVer
	mov	[PClient._DX],UMSTEP_Version
	clc
	ret
endp

;*************************************
proc SMSetMotor
;PE: Client_ES:BX=Konstante Motor-Struktur mit
;    Handle=0 für neuen Motor (ggf. Zwangszuweisung bei gleichen Portadressen)
;    Handle<>0: Daten für vorhandenen Motor neu setzen
;    Komponente "Handle" wird ggf. vom VxD verändert
;    Client_AL=0: Bei auffindbarer gleicher Portadresse Fehler!
	Client_Ptr_Flat ebx,ES,BX,USES_EAX
	add	eax,1
	mov	al,ME_InvalPointer
	jc	@@e		;Ungültige Adresse in ES:BX
	mov	al,ME_InvalPort
	cmp	[PMotor.PortA],1
	jc	@@e		;Ungültige PortA-Adresse
	cmp	[PMotor.PortB],1
	jc	@@e		;Ungültige PortB-Adresse
;Erst einmal passenden Listeneintrag suchen
	cli
	mov	esi,[ListHand]
	VMMCall	List_Get_First
	jz	@@o1		;Noch leere Liste
@@l1:	push	eax
	 mov	edi,eax		;Listen-Knoten
	 mov	al,[PMotor.Handle]
	 or	al,al		;Neuer Motor?
	 jz	@@n1
	 cmp	[(TMotor edi).Handle],al	;Gleiches Handle?
	 jne	@@nf
	 jmp	@@e1
@@n1:	;Portadressen vergleichen - bei Gleichheit Fehler oder Zwangszuweisung
	 mov	eax,[PMotor.Ports]
	 cmp	[(TMotor edi).Ports],eax
	 jne	@@nf
	 cmp	[PClient._AL],1	;Fehlermeldung bei gleichen Ports erzwingen?
	 mov	al,ME_AlreadyAssigned
	 jc	@@e2		;ja, raus!
	 mov	al,[(TMotor edi).Handle]
	 mov	[PMotor.Handle],al	;Handle rückmelden bei gleichen Ports
@@e1:	pop	eax
	call	EditNode
	clc
	jmp	@@e
@@e2:
	pop	eax
	jmp	@@e		;raus mit Fehler
@@nf:
	pop	eax
	VMMCall	List_Get_Next
	jnz	@@l1
@@o1:
	cmp	[PMotor.Handle],0	;Null?
	stc
	mov	al,ME_InvalHandle
	jnz	@@e		;Nicht null: Fehler!
	bsf	edx,[HandlesUsed]
	mov	al,ME_OutOfHandles
	jz	@@e		;Fehler - nichts frei!
	btr	[HandlesUsed],edx	;Bit als belegt kennzeichnen
	mov	[PMotor.Handle],dl	;Neues Handle rückmelden
@@2:
	VMMCall	List_Allocate	;Listen-Knoten beschaffen
	push	eax
	 xchg	edi,eax
	 mov	al,ME_OutOfMemory
	 jc	@@e2
	 LD	ecx,TMotor_ConstLongs+TMotor_VarLongs
	 xor	eax,eax
	 rep	stosd		;Gründlich löschen
	pop	eax
	call	EditNode
	mov	ebx,eax
	call	Motor_Init
	VMMCall	List_Attach	;und dann einfügen
	clc
@@e:	sti
	ret
endp

proc GetPMotor
;PE: AL=Handle
;PA: EBX=Zeiger auf Motor-Struktur
;    EDX=Handle (nullerweitert)
;    ESI=Listen-Handle
;    EAX=EBX=Motor-Struktur
;    CY=1: Nicht gefunden, dann AL=Fehlercode ME_
;VR: ESI,EAX,EBX,EDX
	movzx	edx,al
	add	al,-32
	mov	al,ME_InvalHandle
	jc	@@e		;Fehler: Handle>31
	bt	[HandlesUsed],edx
	jc	@@e		;Fehler: Unbenutztes Handle!
	cli
	mov	esi,[ListHand]
	VMMCall	List_Get_First
	jz	@@o1		;Noch leere Liste
@@l1:	mov	ebx,eax
	cmp	[PMotor.Handle],dl
	jz	@@e		;gefunden! CY=0
	VMMCall	List_Get_Next
	jnz	@@l1
@@o1:	mov	al,ME_InternErr
	stc
	sti
@@e:	ret
endp
;*************************************
proc SMGetMotor
;PE: Client_AL=AL=Handle
;    Client_ES:BX=Stückel Speicher
	call	GetPMotor
	jc	@@e		;Fehler: Nicht zu finden!
	Client_Ptr_Flat eax,ES,BX
	mov	edi,eax
	add	eax,1
	mov	al,ME_InvalPointer
	jc	@@e		;Ungültige Adresse in ES:BX
	mov	esi,ebx
	LD	ecx,TMotor_ConstLongs
	rep	movsd		;Daten liefern
	clc
@@e:	ret
endp

;*************************************
proc SMRemoveMotor
;PE: Client_AL=AL=Handle
	call	GetPMotor
	jc	@@e
	call	Motor_Aus	;Motor freischalten
	bts	[HandlesUsed],edx
	mov	eax,ebx
	VMMCall	List_Remove
	mov	al,ME_InternErr
	jc	@@e
	xchg	eax,ebx
	VMMCall	List_Deallocate
	clc
@@e:	ret
endp

;*************************************
proc SMSetIntFreq	;Dummy: Nichts tun!
	mov	ax,[PClient._BX]
	clc
@@e:	ret
endp

;*************************************
proc SMGetIntFreq
	mov	ax,[Frequency]
	mov	[PClient._BX],ax
	clc
@@e:	ret
endp

;*************************************
proc SMSync	;Referenzfahrt
	call	GetPMotor
	jc	@@e
	call	TestStill
	jc	@@e
	call    StartReffahrt
@@e:	ret
endp

;*************************************
proc SMMoveAbs	;Absolutbewegung
	call	GetPMotor
	jc	@@e
	call	TestReferenz
	jc	@@e
	call	TestInBounds
	jc	@@e
	call	StartSegment
@@e:	ret
endp

;*************************************
proc SMMoveRel	;Relativbewegung
	call	GetPMotor
	jc	@@e
	call	TestReferenz
	jc	@@e
	add	eax,[PMotor.Pos]
	call	TestInBounds
	jc	@@e
	call	StartSegment
@@e:	ret
endp

;*************************************
proc SMStop
	call	GetPMotor
	jc	@@e
	btr	[PMotor.Flags],MF_InMove;ISR-Arbeit radikal stoppen
	jnc	@@e
	call	InformWindows		;Callback rufen, wenn in Bewegung!
	clc
@@e:
	ret
endp

;*************************************
proc SMFree	;Motorspulen stromfrei schalten
	call	SMStop
	jc	@@e
	BTST	[PMotor.CFlags],bit MC_SyncedOnFree
	jnz	@@1
	BRES	[PMotor.Flags],bit MF_InSync
@@1:	call	Motor_Aus
	clc
@@e:	ret
endp

;*************************************
proc SMGetPosition	;liefert Position und Geschwindigkeit
	call	GetPMotor
	jc	@@e
	cli		;Ein zusammenhängendes Paar erwischen!
	mov	eax,[PMotor.Pos]
	mov	edx,[PMotor.Speed]
	mov	cl,[byte PMotor.Flags]
	sti
	mov	[PClient._EDX],eax
	shr	eax,16
	mov	[PClient._ECX],eax
	xchg	eax,edx
	mov	[PClient._ESI],eax
	shr	eax,16
	mov	[PClient._EDI],eax
	mov	[PClient._AH],cl
	jmp	SMGetIntFreq
@@e:
	ret
endp

;*************************************

proc EditNode
;PE: EAX=Knoten (Ziel), EBX=User-Struktur(Quelle)
;    Die aktuelle VM wird zur Callback-VM erklärt
	pushad
	 xchg	edi,eax
	 xchg	esi,ebx
	 LD	ecx,TMotor_ConstLongs
	 rep	movsd
	 VMMCall Get_Cur_VM_Handle	;VM-Handle setzen
	 mov	[((TMotor edi)-4*TMotor_ConstLongs).CallbackVM],ebx
	popad
	ret
endp EditNode

VxD_Locked_Code_Ends

;*************************************
;*** Neue API - Funktionsverteiler ***
;*************************************
VxD_Locked_Data_Seg

HandlesUsed	dd	0FFFFFFFEh
;Bitmaske für verwendete Handles
;0=belegt, 1=frei; Bit0 ist immer "belegt"
;Suche freier Bits erfolgt mit BSF

;Unterprogramm-Verteilertabelle
upvt	dd	OFFSET SMGetVer		;Versionsnummer holen
	dd	OFFSET SMSetMotor	;Motor hinzufügen, Parameter setzen
	dd	OFFSET SMGetMotor	;Motorparameter holen
	dd	OFFSET SMRemoveMotor	;Motor entfernen
	dd	OFFSET SMSetIntFreq	;Interruptfrequenz setzen
	dd	OFFSET SMGetIntFreq	;Interruptfrequenz holen
	dd	OFFSET SMSync		;Referenzfahrt
	dd	OFFSET SMMoveAbs	;Absolutbewegung
	dd	OFFSET SMMoveRel	;Relativbewegung
	dd	OFFSET SMStop		;Soforthalt
	dd	OFFSET SMFree		;Motorspulen stromfrei schalten
	dd	OFFSET SMGetPosition	;Position und Geschw. erfragen
VxD_Locked_Data_Ends

VxD_Locked_Code_Seg

BeginProc UMSTEP_Api
	pushad
	mov	ax,[PClient._AX]	;AX laden
	cmp	ah,SM_LastFunc
	ja	@@NoFunc
Debug_Out "ApiCall Fkt=#AH"
	movzx	ecx,ah
	call	[upvt+ecx*4]
	jc	@@err			;Bei Carry AL zurückgeben
	xor	al,al			;sonst 0 = Kein Fehler
	BRES	[PClient._Flags],CF_Mask	;Carry löschen
	jmp	@@NoErr
@@NoFunc:
	mov	al,ME_WrongFunction
@@Err:
	BSET	[PClient._Flags],CF_Mask	;Carry setzen
@@NoErr:
	mov	[PClient._AL],al
	popad
	ret
EndProc UMSTEP_Api

;*********************
;*** Exit-Funktion ***
;*********************
proc UMSTEP_VMDies
;Wenn eine VM stirbt, müssen zugehörige Motoren "entfernt" werden!
	mov	esi,[ListHand]
	mov	edi,ebx		;Aktuelle VM
	pushf
	 cli
@@vorn:	 VMMCall List_Get_First
	 jz	@@o
@@l:	 xchg	ebx,eax
	 cmp	[PMotor.CallbackVM],edi
	 jnz	@@nm
	 call	Motor_Aus	;Freischalten!
	 mov	eax,ebx
	 VMMCall List_Remove
	 xchg	eax,ebx
	 VMMCall List_Deallocate
	 jmp	@@vorn		;Liste noch einmal von vorn durchgehen!
@@nm:	 xchg	eax,ebx
	 VMMCall List_Get_Next
	 jnz	@@l
@@o:	popf
	ret
endp UMSTEP_VMDies


proc UMSTEP_Exit
UMSTEP_Dynamic_Exit:
Debug_Out "UMSTEP_Exit"
	mov	ah,0bh
	call	GetCMOS
	BRES	al,bit 6	;CMOS Interrupt 1024Hz abschalten
	call	PutCMOS
	mov	eax,[IrqHand]
	VxDcall	VPICD_Physically_Mask	;IRQs aus
	VxDcall	VPICD_Force_Default_Behavior
	mov	esi,[ListHand]
	VMMCall List_Destroy
	ret
endp

VxD_Locked_Code_Ends

;******************************
;*** Installations-Funktion ***
;******************************
VxD_IData_Seg
IrqDesc	VPICD_Irq_Descriptor <8,0,OFFSET32 CmosIsr>
VxD_IData_Ends

VxD_ICode_Seg

BeginProc UMSTEP_Init
;* IRQ8 freischalten
;* Portadresse aus SYSTEM.INI holen
;* Ports trappen
;* Motoren zurücksetzen
Debug_Out "UMSTEP_Init"
UMSTEP_Dynamic_Init:
	LD	eax,LF_Async
	LD	ecx,size TMotor
	VMMCall	List_Create
	jc	@@e
	mov	[ListHand],esi
	lea	edi,[IrqDesc]
	VxDcall	VPICD_Virtualize_IRQ
	jc	@@e
	mov	[IrqHand],eax
	VxDcall	VPICD_Physically_Unmask
	mov	ah,0bh
	call	GetCMOS
	BSET	al,bit 6	;CMOS Interrupt 1024Hz laufenlassen
	call	PutCMOS
;	mov	[Frequency],1024	;fest in diesem Programm
	clc
@@e:
	ret
EndProc UMSTEP_Init

VxD_ICode_Ends

	END
Vorgefundene Kodierung: OEM (CP437)1
Umlaute falsch? - Datei sei ANSI-kodiert (CP1252)