Oakland CPM Archive/oakcpm.iso/sigm/vol131/wave.src

Text File | 1984-04-29 | 4.4 KB | 211 lines

* PROCEDURE WAVE(VAR XVALUE,YVALUE:INT_ARRAY;VAR N:INTEGER;MAXN:INTEGER);

* AN EXTERNAL ROUTINE TO FILL ARRAYS X AND Y FROM THE HIPAD,IN STREAM MODE.
* POINT COLLECTING STARTS WHEN THE PEN GOES DOWN.(i.e.CONTROL BYTE = 0F4H)
* A POINT IS REJECTED IF IT IS < 0.2mm TO THE RIGHT OF THE PRECEDING POINT.
* THE PROCEDURE ENDS IF THE PEN COMES UP OR WHEN MAXN POINTS HAVE BEEN READ.

VBYTES    EQU  9    # OF BYTES ON STACK
XVALUE    EQU 16    OFFSETS TO (IX) FOR ADDRESS OF POINTERS
YVALUE    EQU 14    TO TRANSMITTED VARIABLES.
N    EQU 12
MAXN    EQU  9

STAT_RDY EQU 0F7H  STATUS PORT DATA AVAILABLE CODE
STAT_PRT EQU 00AH  ADDRESS OF STATUS PORT
DATA_PRT EQU 008H     "    "   DATA    "

        NAME    WAVE
        ENTRY    WAVE

PASS:        MACRO    ARG    ; STORES THE 16BIT NO. IN DE
                ; IN A LOCATION WHOSE BASE
                ; ADDRESS IS CALCULATED FROM ARG.
                ; & WHOSE OFFSET = 2 x IY
        PUSH    H    ;
        PUSH    B    ; SAVE ALL REGISTERS USED
        PUSH    Y    ;
        MOV H,ARG(IX)    ; GET BASE ADDRESS OF
        MOV L,ARG-1(IX)    ; ARRAY => HL
        DADY    Y    ; OFFSET = 2 * Y
        PUSH    Y
        POP    B    ; OFFSET --> BC
        DSBC    B    ; ADDRESS OF ARRAY[N] = HL-OFFSET
        XCHG        ; ADDRESS => DE : ARG => HL
        MOV A,H        ;
        STAX    D    ;
        DCX    D    ;
        MOV A,L        ;
        STAX    D    ;
        POP    Y
        POP    B
        POP    H
        ENDMAC

WAVE:
        ENTR D,2,0
        JMP START
OLD_X:    DS 2

START:
        PUSH Y         : SAVE IY FOR PASCAL/Z
        MOV B,MAXN(IX)     : GET VALUE OF
        MOV C,MAXN-1(IX) : MAXN => BC.
        LXI H,0
        DSBC B         : MAXN = or > 1 ?
        JM START2     : IF YES THEN START
        PUSH B
        POP Y
        CALL PASS_N     : MAXN --> N
        JMP WAVE_END     : ELSE RETURN.

START2:
        LXI Y,0        : COUNTER FOR POINTS READ.
        CALL W8_4_PEN    : PEN DOWN YET?
        CALL FIRST_PR
LOOP:
        JMP ANYMORE    : DOES N := MAXN YET ?
PROCEED:
        JMP PEN_UP_YET
STILL_DOWN:
        JMP NEXT_PR
WAVE_END:
        CALL PASS_N
        POP Y        : RESTORE ORIGINAL Y FOR PASCAL/Z
        EXIT D,VBYTES

* SUBROUTINES:
* W8_4_PEN:READS DATA PORT UNTIL CONTROL BYTE = F4 : i.e. PEN IS DOWN.

W8_4_PEN:
        CALL STAT_CHK    ;WAIT TILL DATA AVAILABLE
        IN DATA_PRT    ;GET IT
        CPI 0F4H    ;PEN DOWN ?
        JNZ W8_4_PEN    ;NO : KEEP WAITING.
        RET        ;YES!

FIRST_PR:
    CALL X_IN        ;DISCARD THE FIRST
    CALL Y_IN        ;POINT AS IT CAN
    CALL W8_4_PEN        ;BE GARBAGE.
    CALL X_IN        ;GET X[1]
    MOV B,XVALUE(IX)    ;
    MOV C,XVALUE-1(IX)
    MOV A,D
    STA OLD_X        ;SAVE IT TO COMPARE WITH NEXT X
    STAX B            ;& ALSO SEND IT TO PASCAL/Z LAND.
    DCX B
    MOV A,E
    STA OLD_X+1
    STAX B
    CALL Y_IN        ;GET Y[1]
    CALL PASS_Y        ;& SEND IT TO PASCAL/Z LAND.
    INX Y            ;INCREMENT COUNTER
    RET

* ANYMORE CHECKS WHETHER N HAS REACHED MAXN i.e. is array filled
ANYMORE:
    PUSH H
    MOV H,MAXN(IX)
    MOV L,MAXN-1(IX)
    PUSH D
    PUSH Y            ;GET COUNT FROM Y
    POP D            ;TO DE + COMPARE
    DSBC D            ;TO MAXN.
    POP D
    POP H
    JZ WAVE_END
    JMP PROCEED

* PEN_UP_YET:READS DATA PORT,LOOKING FOR CONTROL BYTE = F3
PEN_UP_YET:
        CALL STAT_CHK    ;WAIT FOR DATA
        IN DATA_PRT    ;GET A BYTE
        CPI 0F4H    ;CONTROL BYTE = F4?(PEN STILL DOWN)
        JZ STILL_DOWN
        JMP WAVE_END    ;EXIT IF PEN NOT DOWN

NEXT_PR:
    CALL X_IN        : GET  NEW X => DE
    PUSH D            : & SAVE IT
    LXI H,OLD_X
    MOV B,M
    INX H
    MOV C,M            : GET  OLD_X => BC
    XCHG            : MOVE NEW X => HL
    INX B
    INX B            : ADD 2 TO OLDX
    DSBC B            : NEW_X = or > (OLD_X + 2) ?
    JM TOO_CLOSE        : IF NOT : DON`T WANT IT
    POP D            : IF SO : RESTORE NEW X
    MOV A,D
    STA OLD_X        : SAVE IT TO COMPARE WITH NEXT X
    MOV A,E
    STA OLD_X+1
    CALL PASS_X        : & SEND X & Y
    CALL Y_IN        : TO PASCAL/Z
    CALL PASS_Y        : LAND
    INX Y            : N := N + 1
    JMP LOOP
TOO_CLOSE:
    POP D            : RESTORE STACK
    CALL Y_IN        : CLEAR PORT
    JMP LOOP

* STAT_CHK :CHECKS STATUS PORT
STAT_CHK:
        IN STAT_PRT    ;DATA IN?
        CPI STAT_RDY
        RZ        ;IF SO:GO GET IT.
        JMP STAT_CHK     ;ELSE TRY AGAIN.

* X_IN :GETS CURRENT X VALUE FROM HIPAD INTO DE
X_IN:   CALL STAT_CHK    ;WAIT FOR DATA
    IN DATA_PRT    ;GET 1ST BYTE (X7..X13)
    MOV D,A        ;INTO D
    PUSH D
    CALL STAT_CHK
    POP D
    IN DATA_PRT    ;2ND BYTE (X0..X6)
    MOV E,A        ;INTO E
    SLAR E        ;---|
    SLAR D        ;   |JUSTIFY
    SRAR D        ;   | RIGHT
    SRAR D        ;   | IN DE
    RRAR E        ;---|
    RET

* Y_IN :GETS CURRENT Y VALUE FROM HIPAD INTO HL
Y_IN:   XCHG
    CALL X_IN
    XCHG
    RET

* PASS_X STORES THE 16 BIT # IN DE @ THE LOCATIONS WHOSE START
* ADDRESS'S MSB = XVALUE + (IX) + (2 * (IY) ) : i.e. at X[N]
PASS_X:
    PASS XVALUE
    RET
* PASS_Y STORES THE 16 BIT # IN HL @ THE LOCATIONS WHOSE START
* ADDRESS'S MSB = YVALUE + (IX) + (2 * (IY)) i.e. at Y[N]
PASS_Y:
    XCHG
    PASS YVALUE
    XCHG
    RET

PASS_N:            ; PUT CONTENTS OF IY INTO N.
    PUSH IY
    POP H        ; IY => HL.
    MOV D,N(IX)    : ADDRESS OF N
    MOV E,N-1(IX)    : => DE.
    MOV A,H
    STAX D
    DCX D
    MOV A,L
    STAX D
    RET


            END WAVE