Code: Alles auswählen

DIM Frequenz AS Shared word
DIM OldAddr AS SHARED DWORD

GLOBAL ISRCounter AS WORD

Frequenz = 2000
ClockOn

sleep

ClockOff


SUB ClockOn()

DIM zaehler AS STATIC word
DIM L AS STATIC byte
DIM H AS STATIC byte

  ! mov Word Ptr CS: SaveDS, DS ;store PowerBASIC Data segment
  GetInterruptVector &H08, OldAddr
  SetInterruptVector &H08, CODEPTR32(ClockISR)
  SetInterruptVector &H68, OldAddr

  zaehler = 1193180 / Frequenz
  L = zaehler
  shift right zaehler, 8  
  H = zaehler

  OUT (&H43), &b00110110
  OUT (&H40), L
  OUT (&H40), H
  ISRCounter = Frequenz / 18.2

END SUB


SUB ClockOff()
  SetInterruptVector &H08, OldAddr
  OUT (&H43), &b00110110
  OUT (&H40), 0
  OUT (&H40), 0
END SUB

SUB SetInterruptVector(BYVAL Intr?, BYVAL NewAddr???) LOCAL
  ! push ds ; save DS
  ! mov ah, &H25 ; set AH to 25h (function number)
  ! mov al, Intr? ; set AL to interrupt vector being redirected
  ! lds DX, NewAddr???
  ! int &H21 ; call DOS services
  ! pop ds ; restore DS
END SUB

SUB GetInterruptVector(BYVAL Intr?, VAddr???) LOCAL PUBLIC
  ! push ds ; save DS
  ! push si ; save SI
  ! mov ah, &H35 ; set AH to 35h (function number)
  ! mov al, Intr? ; set AL to interrupt vector
  ! int &H21 ; call DOS services (ES:BX now holds address)
  ! lds si, VAddr??? ; get a pointer to VSeg??
  ! mov ds:[si+2], es ; copy ES (segment address) into VSeg??
  ! mov ds:[si], bx ; copy BX (offset address) into VOff??
  ! pop si ; restore SI
  ! pop ds ; restore DS
END SUB


SUB ISR () PRIVATE

DIM IsrStack AS STATIC STRING * 1024 '1k stack (probably too much)
DIM Counter AS STATIC INTEGER

DIM l AS STATIC word


SaveDS:
! dw 0
SaveSS:
! dw 0
SaveSP:
! dw 0

ClockISR:
! push ax ; save the general registers
! push bx
! push cx
! push dx
! push si
! push di
! push bp
! push ds
! push es
! push bp
! pushf ; save the flags register
! cli ; suspend all maskable interrupts

! mov Word Ptr CS:SaveSS, SS ; save current stack segment
! mov Word Ptr CS:SaveSP, SP ; save current stack pointer
! mov DS, Word Ptr CS:SaveDS ; restore PowerBASIC data segment

' Create a local stack frame
! mov SS, Word Ptr CS:SaveDS ; SS must equal DS for PowerBASIC runtime
! lea BX, IsrStack ; get address of the local stack frame
! add BX, 1024 ; point to the end of the fixed-length string
! mov SP, BX ; set the stack pointer

' ** Your Basic code goes here **
l = inp(888)
bit toggle l, 1
OUT (888), l

IF Counter = 0 THEN
LOCATE 1, 72, 0
COLOR 14,0
PRINT TIME$;
Counter = 18 '18 ticks per second
END IF
DECR Counter

DECR ISRCounter
IF ISRCounter = 0 THEN
  ! sti
  ! int &H68
  ISRCounter = Frequenz / 18.2
ELSE
  OUT (&H20), &H20
END IF


' ** End of Basic code

! mov SP, Word Ptr CS:SaveSP ; restore the original stack segment
! mov SS, Word Ptr CS:SaveSS ; and stack pointer before restoring the registers

! popf ; restore the flags register
! pop bp ; restore the general registers
! pop es
! pop ds
! pop bp
! pop di
! pop si
! pop dx
! pop cx
! pop bx
! pop ax
! sti ; re-enable maskable interrupt processing
! iret ; return from our interrupt handler

END SUB

Code: Alles auswählen

DIM Frequenz AS Shared word
DIM OldAddr AS SHARED DWORD
DIM ISRCounterBase AS SHARED word
DIM ISRCounter AS SHARED word

Frequenz = 1000
ClockOn

sleep

ClockOff


SUB ClockOn()

DIM zaehler AS STATIC word
DIM L AS STATIC byte
DIM H AS STATIC byte

! mov Word Ptr CS: SaveDS, DS ;store PowerBASIC Data segment

zaehler = 1193180 / Frequenz

ISRCounterBase = zaehler
ISRCounter = ISRCounterBase

L = zaehler
shift right zaehler, 8
H = zaehler
OUT (&H43), &b00110110
OUT (&H40), L
OUT (&H40), H

GetInterruptVector &H08, OldAddr
SetInterruptVector &H08, CODEPTR32(ClockISR)
SetInterruptVector &H68, OldAddr

END SUB


SUB ClockOff()

OUT (&H43), &b00110110
OUT (&H40), 0
OUT (&H40), 0
SetInterruptVector &H08, OldAddr

END SUB

SUB SetInterruptVector(BYVAL Intr?, BYVAL NewAddr???) LOCAL
! push ds ; save DS
! mov ah, &H25 ; set AH to 25h (function number)
! mov al, Intr? ; set AL to interrupt vector being redirected
! lds DX, NewAddr???
! int &H21 ; call DOS services
! pop ds ; restore DS
END SUB

SUB GetInterruptVector(BYVAL Intr?, VAddr???) LOCAL PUBLIC
! push ds ; save DS
! push si ; save SI
! mov ah, &H35 ; set AH to 35h (function number)
! mov al, Intr? ; set AL to interrupt vector
! int &H21 ; call DOS services (ES:BX now holds address)
! lds si, VAddr??? ; get a pointer to VSeg??
! mov ds:[si+2], es ; copy ES (segment address) into VSeg??
! mov ds:[si], bx ; copy BX (offset address) into VOff??
! pop si ; restore SI
! pop ds ; restore DS
END SUB


SUB ISR () PRIVATE

DIM IsrStack AS STATIC STRING * 1024 '1k stack (probably too much)
DIM Counter AS STATIC INTEGER

SaveDS:
! dw 0
SaveSS:
! dw 0
SaveSP:
! dw 0

ClockISR:
! push ax ; save the general registers
! push bx
! push cx
! push dx
! push si
! push di
! push bp
! push ds
! push es
! push bp
! pushf ; save the flags register
! cli ; suspend all maskable interrupts

! mov Word Ptr CS:SaveSS, SS ; save current stack segment
! mov Word Ptr CS:SaveSP, SP ; save current stack pointer
! mov DS, Word Ptr CS:SaveDS ; restore PowerBASIC data segment

' Create a local stack frame
! mov SS, Word Ptr CS:SaveDS ; SS must equal DS for PowerBASIC runtime
! lea BX, IsrStack ; get address of the local stack frame
! add BX, 1024 ; point to the end of the fixed-length string
! mov SP, BX ; set the stack pointer

' ** Your Basic code goes here **

l = inp(888)
bit toggle l, 1
OUT (888), l

IF Counter = 0 THEN
LOCATE 1, 72, 0
COLOR 14,0
PRINT TIME$;
Counter = 18 '18 ticks per second
END IF
DECR Counter

  IF ISRCounter = 0 THEN
   ISRCounter = ISRCounterBase
    ! int &H68
  ELSE
    OUT (&H20), &H20
  END IF
  DECR ISRCounter


' ** End of Basic code

! mov SP, Word Ptr CS:SaveSP ; restore the original stack segment
! mov SS, Word Ptr CS:SaveSS ; and stack pointer before restoring the registers

! popf ; restore the flags register
! pop bp ; restore the general registers
! pop es
! pop ds
! pop bp
! pop di
! pop si
! pop dx
! pop cx
! pop bx
! pop ax
! sti ; re-enable maskable interrupt processing
! iret ; return from our interrupt handler

END SUB

Code: Alles auswählen

  GetInterruptVector &H08, OldAddr
  SetInterruptVector &H08, CODEPTR32(ClockISR)

Code: Alles auswählen

DIM OldIntCounterBase AS SHARED DWORD
DIM OldIntCounter AS SHARED DWORD
DIM ISRFrequenz AS SHARED WORD

  GetInterruptVector &H08, OldAddr
  SetInterruptVector &H08, CODEPTR32(ClockISR)
  SetInterruptVector &H68, OldAddr
  
  OldIntCounterBase = 1193180 / ISRFrequenz
  OldIntCounter = OldIntCounterBase

Code: Alles auswählen

** Your Basic code goes here **
  
  IF OldIntCounter = 0 THEN
    OldIntCounter = OldIntCounterBase
    ! int &H68
  END IF
  DECR OldIntCounter

Code: Alles auswählen

--------D-2125-------------------------------
INT 21 - DOS 1+ - SET INTERRUPT VECTOR
	AH = 25h
	AL = interrupt number
	DS:DX -> new interrupt handler
Notes:	this function is preferred over direct modification of the interrupt
	  vector table
	some DOS extenders place an API on this function, as it is not
	  directly meaningful in protected mode
	under DR DOS 5.0-6.0, this function does not use any of the
	  DOS-internal stacks and may thus be called at any time; however,
	  under Novell DOS 7.0 - DR-DOS 7.02, this function was not reentrant.
	  Since 1998/05/29, DR-DOS 7.03 no longer uses any internal stacks and
	  tests for this function much earlier, to allow a minimal stack usage
	  of just two words in addition to the IRET frame, allowing it to be
	  called from INT 21h functions, specificially device drivers.  This
	  fixes the MCS SMB client
	Novell NetWare (except the new DOS Requester) monitors the offset of
	  any INT 24 set, and if equal to the value at startup, substitutes
	  its own handler to allow handling of network errors; this introduces
	  the potential bug that any program whose INT 24 handler offset
	  happens to be the same as COMMAND.COM's will not have its INT 24
	  handler installed
SeeAlso: AX=2501h,AH=35h

--------D-2135-------------------------------
INT 21 - DOS 2+ - GET INTERRUPT VECTOR
	AH = 35h
	AL = interrupt number
Return: ES:BX -> current interrupt handler
Note:	under DR DOS 5.0+, this function does not use any of the DOS-internal
	  stacks and may thus be called at any time
SeeAlso: AH=25h,AX=2503h

Code: Alles auswählen

USES CRT;
VAR OldInt8 : pointer;
    TimerCounter,
    CallOldTimer : word;

PROCEDURE SetTimer( NewInt8:pointer; MyFreq : word );
VAR MyZaehler:word;
BEGIN
  MyZaehler := 1193180 div MyFreq;
  CallOldTimer := Round( MyFreq / 18.2 );
  TimerCounter := CallOldTimer;
  asm cli end;
  Port[$43] := $36;
  Port[$40] := lo(MyZaehler);
  Port[$40] := hi(MyZaehler);
  GetIntVec(8, OldInt8 );
  SetIntVec($1A, OldInt8 );
  SetintVec(8, NewInt8 );
  asm sti end;
END;
  
PROCEDURE RestoreTimer;
BEGIN
  asm cli end;
  Port[$43] := $36;
  Port[$40] := 0;
  Port[$40] := 0;
  SetIntVec(8, OldInt8 );
  asm sti end;
END;  

PROCEDURE MyTimer; interrupt;
BEGIN
  dec( TimerCounter );
  if TimerCounter = 0 then begin
    TimerCounter := CallOldTimer;
    asm int $1A end;
  end 
  else Port[$20] := $20;
END;

BEGIN
  SetTimer( @MyTimer, 1000 );
  Repeat Until KeyPressed;
  RestoreTimer;
END.