ASYCOM_W.ASM

    PAGE 62,130
;*********************************************************************
;
    NAME        ASYMAS86
;   FUNCTION:   communication-driver ( master )
;           EW-protokoll ( subset of ISO 1745 )
;           Interface for Windows DLL
;
;*********************************************************************
;
; Data communication according to PWM-EW-standard.
;
; Formats:
;
;   SOH ADR POL ENQ             receive poll
;   SOH ADR STX 'TEXT' ETX BCC ENQ  receive message
;   SOH ADR STX 'TEXT' ETX BCC  send text
;
; Bytes ETX, EOT, DLE and SOH are prefixed by 10H ( DLE ) if part of 'text'.
;
; It is not allowed for slaves to send ACK, NAK or EOT before receiving the
; ENQ. Reason is the layout of bus structure for PR3000. The Master will
; send a required ACK, NAK or EOT before end of transmission is detected.
; Dependent on BUSMOD the receiver will be disables during sending a meesage.
; BUSMOD = 1 means: Slaves will echo any character sent by the master, so
; receiver has to be disabled during this time.
;
; Bufferdefinition BUFFER for external use:
;
;  asycom_buf = record          { PASCAL !!! }
;    adr : char;                        { ASCII-Addresse des Teilnehmers }
;    status : byte;                     { Status des Teilnehmers }
;    input_used : integer;              { Buffer-Flag fЃr Input }
;    input_length : integer;            { L„nge des Telegramms }
;    input_buffer : array [0..255] of byte; { Buffer }
;    output_used : integer;             { Buffer-Flag fЃr Output }
;    output_length : integer;           { Lange des Telegramms }
;    output_buffer : array [0..255] of byte; { Buffer }
;    stacnt : byte;                     { interner Z„hler }
;    errcnt : byte;                     { interner Z„hler }
;  end;
;
; Status:
;
;   xxxx x000B = slave is active
;   xxxx x001B = timeout ( no answer from slave due to bad line, baudrate ... )
;   xxxx x010B = retries exceeded during receiving message
;   xxxx x011B = retries exceeded during transmitting message
;   xxxx 1xxxB = message cannot be transfered ( message too long, buffer of
;        slave not empty or badline )
;   xxx1 xxxxB = fatal error reported NFATAL-times, will be set to 0 on first
;        good communication
;
; usage of registers:
;
; ES = pointer to segment aof buffers
; SI = index to current slave

    PAGE

    .model small
    .sall
    .xlist

?PLM=1                          ; 'Pascal' naming
?memS=1             ; medium Memory Modell
include cmacros.inc

    .list
    .data

;-----  DATA DEFINITIONS

staticW RVEC,   RXUREQ          ; receiver-jump-vector
staticW SVEC,   TXUREQ          ; transmitter-jump-vector
staticB BUSMOD, 0           ; mode of bus
staticB LSTCNT, 0           ; last retry count
staticW OLDT,   0, 2            ; address of timer interrupt
staticW OLDC,   0, 2            ; address of COM1 interrupt
staticB IDLE,   0           ; flag idle loop over all slaves
staticB INTNUM, 0           ; number of COM-interrupt
staticW RBR,    0           ; base address of UART
staticB IMASK,  0           ; interrupt-mask
staticW RTYCNT, 0           ; error counter 'retry'
staticW WDGCNT, 0           ; error counter 'watchdog'
staticW OCW1,   0           ; oper.control word on 8259-1
staticW OCW2,   0           ; oper.control word on 8259-2

CHRCNT  LABEL   WORD
    DW  0           ; character-counter to end of buffer
BCC LABEL   BYTE
    DB  0           ; checksum
RETRY   LABEL   BYTE
    DB  0           ; retry-Counter
TIMOUT  LABEL   BYTE
    DB  OFF         ; time-out-Counter
NSLAVES LABEL   BYTE
    DW  0           ; number of installed slaves
SLAVE1  LABEL   WORD
    DW  0           ; pointer to 1. buffer
    DW  0
BUFPNT  LABEL   WORD
    DW  0           ; offset pointer to actual buffer
CURSLV  LABEL   WORD
    DW  0           ; pointer to actual structure
SLVCNT  LABEL   BYTE
    DW  0           ; counter for current slave

    PAGE

    PUBLIC _COM_BUFF

ASYMBL  EQU 256         ; length of buffer

BUFFER  STRUC
ADR DB  0           ; ASCII-code of slave ( R/O )
STATUS  DB  0           ; status of slave ( 0 = available )
PUSE    DB  0           ; status of input buffer ( 0 = empty )
    DB  0           ; filler
PLEN    DW  0           ; number of valid bytes in Buffer
PBF DB  ASYMBL DUP (0)      ; buffer
MUSE    DB  0           ; same for output as for input above
    DB  0           ; filler
MLEN    DW  0
MBF DB  ASYMBL DUP (0)
STACNT  DB  0           ; internal status counter
ERRCNT  DB  0           ; counter for fatal errors
BUFFER  ENDS

_COM_BUFF  DB 16 * SIZE BUFFER DUP (0)  ; for 16 slaves

    PAGE

createSeg   INIT_TEXT, INIT_TEXT, BYTE, PUBLIC, CODE
sBegin      INIT_TEXT
assumes     CS, INIT_TEXT

OFF EQU -1          ; for timeout
ACK EQU 6           ; acknowledge
NAK EQU 15H         ; negative acknowledge
SOH EQU 1           ; start of header
ENQ EQU 5           ; enquiry
STX EQU 2           ; start of text
ETX EQU 3           ; end of text
POL EQU 70H         ; polling
EOT EQU 4           ; end of transmission
DLE EQU 10H         ; prefix

NRETRY  EQU 3           ; number of retries for transmission
NFATAL  EQU 3           ; bad communcations before fatal error
CHRTIM  EQU 2           ; * 55 msec for character-time-out

TIMER   EQU 8           ; TIMER: interrupt number
EOI EQU 20H         ; spec. end of interrupt 4
RXERR   EQU 0EH         ; receiver error mask
RTSON   EQU 1011B           ; OUT2 + RTS + DTR on
EITX    EQU 2           ; enable TX-interrupt only
EIRXTX  EQU 3           ; enable RX- and TX-interrupts

; offsets to UART-base-register:

IER EQU 1           ; interr. enable register
IIR EQU 2           ; interrupt identification register
LCR EQU 3           ; logic control register
MCR EQU 4           ; modem control register
LSR EQU 5           ; line status register

extrn DOS3Call : far

    PAGE

;------------------------------------------------------------------------------
;----- Hardware Interface -----------------------------------------------------
;------------------------------------------------------------------------------

INT1:   PUBLIC  INT1
    PUSH    AX
    PUSH    BX
    PUSH    CX
    PUSH    DX
    PUSH    SI
    PUSH    ES
    PUSH    DS
    MOV AX,_DATA
    MOV DS,AX
    MOV ES,SLAVE1[2]
    MOV SI,CURSLV       ; SI is used to address the buffer
INT1A:  MOV DX,RBR
    ADD DX,IIR          ; interrupt identification
    IN  AL,DX
    TEST    AL,100B         ; receiver ?
    JNZ RXINT
    TEST    AL,010B         ; transmitter ?
    JNZ TXINT
    JMP SHORT IRENDE        ; no Interrupt pending !

TXINT:  CALL    (SVEC)          ; call function via vector
    JMP INT1A

RXINT:  MOV DX,RBR
    ADD DX,LSR
    IN  AL,DX           ; read status
    AND AL,RXERR        ; overrun, parity, framing error
    MOV DX,RBR          ; address of dataregister
    IN  AL,DX           ; get character
    MOV CL,AL
    CALL    (RVEC)          ; call function via vector
    JMP SHORT INT1A

IRENDE: MOV DX,OCW1         ; UART's interrupt controller
    MOV AL,EOI          ; reset interrupt
    OUT DX,AL
    MOV DX,OCW2         ; 2. interrupt controller
    CMP DX,0
    JE  ENDE
    MOV AL,EOI
    OUT DX,AL
ENDE:   STI
    POP DS
    POP ES
    POP SI
    POP DX
    POP CX
    POP BX
    POP AX
    IRET

SIOOT:  MOV DX,RBR          ; send character
    OUT DX,AL
    MOV TIMOUT,CHRTIM       ; activate supervision

RXUREQ: ;STATE: receiver interrupt unrequested
TXUREQ: ;STATE: transmitter interrupt unrequested

    RET

    PAGE
;------------------------------------------------------------------------------
;----- Busmanagement ----------------------------------------------------------
;------------------------------------------------------------------------------

NXTCNF: CMP BUSMOD,1
    JNE NXTCN1
    MOV DX,RBR
    ADD DX,IER
    MOV AL,EITX         ; disable RX-interrupt
    OUT DX,AL
NXTCN1: MOV AL,LSTCNT       ; generate random times to activate
    AND AL,1FH
    MOV ES:[SI].STACNT,AL
    ADD AL,AL
    MOV LSTCNT,AL
    CMP ES:[SI].ERRCNT,NFATAL-1 ; test error-count
    JZ  T2
    INC ES:[SI].ERRCNT      ; update in memory
    RET

T2: OR  ES:[SI].STATUS,10H  ; flag a fatal error
    RET

    PAGE

;----- ZeitЃberwachung

ASYWDG: PUBLIC  ASYWDG
    PUSH    AX
    PUSH    DX
    PUSH    SI
    PUSH    ES
    PUSH    DS
    MOV AX,_DATA
    MOV DS,AX
    MOV ES,SLAVE1[2]        ; Segment des Buffers
    DEC LSTCNT
    CMP TIMOUT,OFF
    JZ  RETURN          ; no supervision of slave
    DEC TIMOUT          ; update counter
    JNZ RETURN          ; still time enough
    MOV RVEC,OFFSET RXUREQ  ; reset vectors
    MOV SVEC,OFFSET NXTSLV  ; in case of pause, slave 1
    MOV SI,CURSLV
    TEST    IDLE,2          ; bit 1: timer for pause
    JNZ T1
    MOV ES:[SI].STATUS,1    ; status = timeout
    CALL    NXTCNF
    INC WDGCNT
T1: MOV IDLE,0
    MOV DX,RBR          ; restart interrupts
    MOV AL,EOT
    OUT DX,AL
RETURN: PUSHF
    CALL    DWORD PTR [OLDT]
    STI
    POP DS
    POP ES
    POP SI
    POP DX
    POP AX
    IRET

    PAGE

;----- Control of slaves

NXTSLV: ;Test conditions and select next slave for polling

    ADD CURSLV,SIZE BUFFER  ; pointer to next slave
    MOV SI,CURSLV
        DEC SLVCNT
    JNE NXTSL1          ; after end of array ?
    MOV AL,NSLAVES
    MOV SLVCNT,AL
    MOV AX,SLAVE1       ; first slave will follow
    MOV CURSLV,AX
    CMP IDLE,0          ; no response for all slaves ?
    MOV IDLE,1          ; then wait some time
    JZ  NXTSL1
    MOV IDLE,2
    MOV TIMOUT,CHRTIM
    RET

NXTSL1: MOV SI,CURSLV
    CMP BYTE PTR ES:[SI].ADR,0  ; buffer active ?
    JE  NXTSLV
    CMP BYTE PTR ES:[SI].STACNT,0
    JZ  NXTSL5          ; this one may be used for polling
    DEC BYTE PTR ES:[SI].STACNT
    JMP NXTSLV

NXTSL5: CMP BYTE PTR ES:[SI].PUSE,0 ; Send poll only if buffer is empty
    JZ  STRPOL          ; else try to send a message
    CMP BYTE PTR ES:[SI].MUSE,0 ; Send meassage only if buffer valid
    JNZ STRM4
    MOV SVEC,OFFSET NXTSLV
    MOV AL,EOT
    JMP SIOOT

STRM4:  JMP STRMSG

    PAGE
;------------------------------------------------------------------------------
;----- Protocoll --------------------------------------------------------------
;------------------------------------------------------------------------------

;----- Polling: Transmitter Status

STRPOL: ; entry to start procedure for one slave
    ; start message ( send 'SOH' )
    ; BUFFER.ADR = code of slave ( ASCII )
    ; NEXT STATE: POLREP + SADRP

    MOV IDLE,0
    MOV RETRY,NRETRY        ; preset retry-counter
    CMP BUSMOD,1        ; enable receiver after sending msg.
    JNE STRP2
    MOV DX,RBR
    ADD DX,IER
    MOV AL,EITX         ; disable RX-interrupts
    OUT DX,AL
    MOV RVEC,OFFSET RXUREQ  ; echo: slave has to wait
    JMP STRP1

STRP2:  MOV RVEC,OFFSET POLREP
STRP1:  MOV SVEC,OFFSET SADRP
    MOV AL,SOH          ; send 'SOH' and start poll-sequence
    JMP SIOOT

SADRP:  ; STATE: send address of selected slave
    ; NEXT STATE: SPOL

    MOV SVEC,OFFSET SPOL    ; next state
    MOV AL,ES:[SI].ADR
    JMP SIOOT           ; send address

SPOL:   ; STATE:    send 'POL' to slave device
    ; NEXT STATE: SENQ

    MOV SVEC,OFFSET SENQ    ; next state
    MOV RVEC,OFFSET POLREP  ; set vectors
    MOV AL,POL
    JMP SIOOT           ; send poll-character

    PAGE

SENQ:   ; switch to slave for poll and message reply
    ; send 'ENQ' to slave device
    ; NEXT STATE: TXUREQ

    MOV SVEC,OFFSET RXENAB  ; next state
    MOV AL,ENQ
    JMP SIOOT           ; send 'ENQ'

RXENAB: CMP BUSMOD,1
    JNE SENQ1
    MOV DX,RBR
    ADD DX,LSR
    MOV AL,0F0H         ; make USART empty, clear errors
    OUT DX,AL
    MOV DX,RBR
    ADD DX,IER
    MOV AL,EIRXTX       ; enable RX-interrupts
    OUT DX,AL
SENQ1:  MOV TIMOUT,CHRTIM       ; activate watchdog
    MOV SVEC,OFFSET TXUREQ
    RET

    PAGE

;-----  Poll: Receiver States

POLREP: ; STATE: waiting for poll request
    ; INPUT: SOH --> NEXT STATE: RADR
    ;    EOT --> MOUT
    ;    other and parity-error --> EXIT

    JNZ RIGNOR          ; ignore character on error
    CMP CL,EOT
    JZ  EXITP2          ; start task if no message comming
    CMP CL,SOH
    JNZ RIGNOR          ; must be 'SOH', else ignore
    MOV RVEC,OFFSET RADR    ; message will continue with address
    MOV TIMOUT,CHRTIM       ; activate watchdog
RIGNOR: RET

RADR:   ;STATE: read address of active slave after poll
    ;INPUT: matching address --> NEXT STATE: RSTX
    ;   other and parity-error --> EXIT

    JNZ EXITP1          ; abort on error, start message output
    CMP CL,ES:[SI].ADR      ; correct address ?
    JNZ EXITP1          ; abort if not, else send message
    MOV RVEC,OFFSET RSTX    ; message will continue with 'STX'
    MOV TIMOUT,CHRTIM       ; activate watchdog
    RET

EXITP2: AND ES:[SI].STATUS,0E8H ; slave is active
    MOV ES:[SI].ERRCNT,0    ; reset error-conter
EXITP1: JMP EXITP

RSTX:   ; STATE: read STX after poll
    ; INPUT: STX --> next state: RTEXT
    ;    EOT --> exit
    ;    other and parity-error --> SNAK

    JNZ SNAK1           ; send 'NAK' and wait for retry
    CMP CL,EOT          ; slave was aborting, send message
    JZ  EXITP1
    CMP CL,STX
    JNZ SNAK1           ; wrong character, retry
    MOV RVEC,OFFSET RTEXT   ; next status
    MOV TIMOUT,CHRTIM       ; activate watchdog
    MOV CHRCNT,ASYMBL       ; init character-counter
    MOV BCC,ETX         ; init BCC
    MOV BUFPNT,0        ; init bufferpointer
    RET

SNAK1:  JMP SNAK

    PAGE

RTEXT:  ; STATE: read message from slave device
    ; INPUT: ETX --> next state: RBCC, RCTL
    ;    EOT --> exit
    ;    parity-error --> SNAK

    JNZ SNAK1           ; send 'NAK', retry
    MOV TIMOUT,CHRTIM       ; activate watchdog
    CMP CL,DLE          ; prefix in text ?
    JZ  ISDLE
    CMP CL,EOT          ; slave is aborting
    JZ  EXITP1
    CMP CL,ETX          ; end of message ?
    JZ  ISETX
RTEXT2: DEC CHRCNT          ; put character to buffer
    JZ  EXITP1          ; abort on buffer-overflow
    XOR BYTE PTR BCC,CL     ; update bcc
    MOV BX,BUFPNT
    MOV ES:[SI+BX].PBF,CL   ; character to buffer
    INC BUFPNT
    RET

ISDLE:  MOV RVEC,OFFSET RDLE    ; ignore cntl-character next interrupt
    XOR BYTE PTR BCC,CL     ; update BCC
    RET

RDLE:   ;STATE: read text-character without testing ETX and EOT

    JNZ SNAK            ; abort on error
    MOV TIMOUT,CHRTIM       ; activate watchdog
    MOV RVEC,OFFSET RTEXT   ; next character will be normally
    JMP RTEXT2          ; read any character after DLE

ISETX:  ;END OF TEXT DETECTED

    MOV RVEC,OFFSET RBCC
    RET

PAGE

RBCC:   ;STATE: read BCC from slave device
    ;INPUT: good BCC --> ACK
    ;   wrong BCC --> NAK

    JNZ SNAK            ; send 'NAK', retry on Character error
    XOR BYTE PTR BCC,CL     ; test bcc
    JNZ SNAK            ; send 'NAK', retry if fault BCC
    MOV ES:[SI].PUSE,1      ; buffer is valid now
    MOV TIMOUT,OFF      ; no supervision
    MOV AX,BUFPNT       ; number of characters in buffer
    MOV ES:[SI].PLEN,AX
    MOV ES:[SI].STATUS,0    ; status is good now
    MOV ES:[SI].ERRCNT,0    ; reset error-conter
    MOV RVEC,OFFSET RXUREQ  ; no further reply requested
    MOV SVEC,OFFSET STRMSG  ; continue with sending message
    MOV AL,ACK          ; send 'ACK'


    JMP SIOOT

SNAK:   ; send 'NAK' if retries may be done
    ;  else exit

    INC RTYCNT          ; count retries
    DEC RETRY
    JZ  PABORT          ; abort if bad communication
    MOV RVEC,OFFSET POLREP  ; set vector
    MOV AL,NAK
    JMP SIOOT           ; send 'NAK'

PABORT: MOV ES:[SI].STATUS,2
    CALL    NXTCNF          ; remove this slave from list to scan

EXITP:  ; set receiver to idle ( RXUREQ ),
    ; set transmitter to idle ( TXUREQ ),
    ; send 'EOT', start message output to slave

    MOV TIMOUT,OFF      ; no supervision
    MOV RVEC,OFFSET RXUREQ  ; next: send a message

    PAGE

;----- Message: Transmitter Status

STRMSG: ; entry from task to start message-output
    ; start message ( send 'SOH' )
    ; BUFFER.ADR = code of slave ( 0...9 )
    ; NEXT STATE: MSGREP + SADRT
    ; set retry-counter
    ; ENTRY: BUFFER.INUSE = 1


    CMP BYTE PTR ES:[SI].MUSE,0 ; something in buffer ?
    JNZ STRM0
    JMP EXITMSG

STRM0:  MOV IDLE,0
    MOV RETRY,NRETRY        ; preset retry-counter
STRM3:  CMP BUSMOD,1        ; enable receiver after sending msg.
    JNE STRM2
    MOV DX,RBR
    ADD DX,IER
    MOV AL,EITX         ; disable RX-interrupts
    OUT DX,AL
    MOV RVEC,OFFSET RXUREQ  ; echo: slave has to wait
    JMP STRM1

STRM2:  MOV RVEC,OFFSET TXTREP
STRM1:  MOV SVEC,OFFSET SADRT
    MOV AL,SOH
    JMP SIOOT

SADRT:  ;STATE: send address of selected slave
    ;NEXT STATE:  SSTX

    MOV SVEC,OFFSET SSTX    ; next state
    MOV AL,ES:[SI].ADR      ; send address
    JMP SIOOT           ; send address

SSTX:   ;STATE: SEND 'STX' TO SLAVE DEVICE
    ;NEXT SLAVE: STEXT

    MOV SVEC,OFFSET STEXT   ; next state
    MOV BCC,ETX         ; init BCC
    MOV AX,ES:[SI].MLEN     ; init number of bytes to send
    MOV CHRCNT,AX
    MOV BUFPNT,0        ; init buffer-pointer
    MOV AL,STX
    JMP SIOOT           ; send 'STX'

    PAGE

STEXT:  ;STATE: Send number of bytes defined in BUFFER.MLEN.
    ;NEXT STATE: SETX

    DEC CHRCNT          ; character counter
    JS  SETX            ; end of text
    MOV BX,BUFPNT
    MOV AL,ES:[SI+BX].MBF   ; character to send
    CMP AL,SOH
    JE  ISCTRL
    CMP AL,DLE
    JE  ISCTRL
    CMP AL,EOT
    JE  ISCTRL
    CMP AL,ETX
    JE  ISCTRL
    INC BUFPNT          ; update pointer
    XOR BCC,AL          ; update BCC
    JMP SIOOT           ; send character

ISCTRL: MOV SVEC,OFFSET SCTL    ; continue after sending DLE normally
    MOV AL,DLE
    XOR BCC,AL          ; update BCC
    JMP SIOOT

SCTL:   ;STATE: send controlcharacter, last character was DLE

    MOV BX,BUFPNT
    MOV AL,ES:[SI+BX].MBF
    INC BUFPNT
    MOV SVEC,OFFSET STEXT
    XOR BCC,AL
    JMP SIOOT

SETX:   ;STATE: send 'ETX' to slvae device
    ;NEXT STATE: SBCC

    MOV SVEC,OFFSET SBCC    ; next state
    MOV AL,ETX
    JMP SIOOT           ; send 'ETX'

SBCC:   ;STATE: send calculated BCC to slave device
    ;NEXT STATE: SENQ

    MOV RVEC,OFFSET TXTREP
    MOV SVEC,OFFSET SENQ    ; next state
    MOV AL,BCC
    JMP SIOOT           ; send check-character

    PAGE

; ----- Message: Receiver States

TXTREP: ; STATE: wait for reply to message-output
    ; INPUT: ACK --> set data accepted, exit
    ;    NAK --> STRMSG ( if reties may be done )
    ;    other and parity-error --> EXIT

    JNZ PIGNOR          ; ignore on error
    CMP CL,EOT
    JE  EXITMSG
    CMP CL,NAK
    JZ  RNAK
    CMP CL,ACK
    JNZ PIGNOR          ; retry
    MOV ES:[SI].MUSE,0      ; buffer is transfered
    MOV ES:[SI].STATUS,0
    MOV ES:[SI].ERRCNT,0    ; reset error-conter
    JMP EXITMSG

PIGNOR: RET

RNAK:   INC RTYCNT          ; count reties
    DEC RETRY           ; more retries ?
    JZ  MABORT
    JMP STRM3           ; set vectors restart message output

MABORT: MOV ES:[SI].STATUS,3    ; retries exceeded
    CALL    NXTCN1          ; remove slave some time

EXITMSG:; set receiver to idle ( RXUREQ ),
    ; set transmitter to idle ( TXUREQ ),
    ; send 'EOT', set valid
    ; ENTRY: B = status of buffer
    ;        0:  buffer empty
    ;        1:  buffer contains message
    ;        -1: slave without valid response

    CMP BUSMOD,1        ; enable receiver after sending msg.
    JNE EXM1
    MOV DX,RBR
    ADD DX,IER
    MOV AL,EITX         ; disable RX-interrupts
    OUT DX,AL
EXM1:   MOV RVEC,OFFSET RXUREQ
    MOV SVEC,OFFSET NXTSLV
    MOV AL,EOT          ; send EOT
    JMP SIOOT

    PAGE
;------------------------------------------------------------------------------
;------ User interface --------------------------------------------------------
;------------------------------------------------------------------------------


;------  void PASCAL apen_asycom
;------  (
;------    int port, int intr, int umask, int cw1, int cw2, int baud,
;------    int form, int slaves, int echo
;------  );

cProc   OPEN_ASYCOM_    <PUBLIC> <SI, ES, CX, BX, DX>
    parmW   PORT            ; port address UART
    parmW   INTR            ; software interrupt
    parmW   UMASK           ; interrupt mask
    parmW   CW1         ; address of interr. controller UART
    parmW   CW2         ; address of other controller
    parmW   BAUD            ; divider value baudrate
    parmW   FORM            ; number of bits
    parmW   SLAVES          ; number of slaves
    parmW   ECHO            ; bus mode
cBegin
    MOV AX,_DATA
    MOV DS,AX           ; <DS> := <CS>
    MOV CX,SLAVES       ; number of slaves
    MOV NSLAVES,CL      ; ignore value in CH
    MOV AX,SEG _COM_BUFF
    MOV SLAVE1[2],AX
    MOV AX,OFFSET _COM_BUFF
    MOV SLAVE1[0],AX
    MOV AH,35H          ; DOS-function 'get vector': TIMER
    MOV AL,TIMER        ; Number of vector
    cCall   DOS3Call
    MOV OLDT[0],BX      ; save old address to continue there
    MOV OLDT[2],ES
    MOV DX,OFFSET ASYWDG    ; <dx> = adresse of new service: TIMER
    MOV AX,SEG ASYWDG       ; <dx> = adresse of new service: TIMER
    MOV DS,AX           ; <DS> := <CS>
    MOV AH,25H          ; new servive address
    MOV AL,TIMER
    cCall   DOS3Call
    MOV AX,_DATA
    MOV DS,AX           ; <DS> := <CS>
        MOV CX,NSLAVES      ; never more than 26 slaves ( A...Z ) !
SETADR: DEC CX          ; set address to NULL
    LES SI,DWORD PTR SLAVE1
    MOV AX,SIZE BUFFER
    IMUL    CX
    ADD SI,AX
    MOV ES:[SI].ADR,0
    MOV ES:[SI].STACNT,0
    MOV ES:[SI].ERRCNT,0
    MOV ES:[SI].PUSE,0
    MOV ES:[SI].MUSE,0
    CMP CX,0
    JNE SETADR
    MOV AX,_DATA
    MOV DS,AX           ; <DS> := <CS>
    MOV AL,INTR         ; AH will be ignored
    MOV INTNUM,AL
    MOV AL,UMASK        ; interrupt mask for OCW1
    MOV IMASK,AL
    MOV AX,CW1          ; address of UART's controller
    MOV OCW1,AX
    MOV AX,CW2          ; address of other interrupt controller
    MOV OCW2,AX
    MOV AH,35H          ; save original vector
    MOV AL,INTNUM
    cCall   DOS3Call
    MOV OLDC[0],BX
    MOV OLDC[2],ES
    MOV AL,INTNUM
    MOV DX,OFFSET INT1
    MOV CX,SEG INT1
    MOV DS,CX
    MOV AH,25H          ; vector will point to driver
    cCall   DOS3Call
    MOV AX,_DATA
    MOV DS,AX           ; <DS> := <CS>
    MOV DX,PORT
    MOV RBR,DX
    ADD DX,LCR          ; set divisor latch access bit
    MOV AL,9BH
    OUT DX,AL
    MOV DX,RBR
    MOV AX,BAUD         ; set baudrate
    OUT DX,AL
    INC DX
    MOV AL,AH
    OUT DX,AL
    MOV DX,RBR          ; set parity ...
    ADD DX,LCR
    MOV AX,FORM         ; AH will be ignored on output
    OUT DX,AL
    CLI
    MOV DX,RBR          ; base address
    ADD DX,MCR          ; modem Port
    MOV AL,RTSON
    OUT DX,AL           ; OUT2 + DTR + RTS on
    MOV DX,RBR          ; base-address
    ADD DX,IER
    MOV AL,EIRXTX       ; enable RX-interrupts
    OUT DX,AL
        MOV CX,ECHO
    MOV BUSMOD,CL       ; set busmode ( 0 for no echo )
    MOV DX,RBR          ; empty UART
    IN  AL,DX
    IN  AL,DX
    IN  AL,DX
    MOV AX,_DATA
    MOV DS,AX           ; <DS> := <CS>
    MOV DX,OCW1
    INC DX          ; set DX to mask register
    IN  AL,DX
    MOV AH,IMASK        ; reset bit to
    AND AL,AH           ; interrupt enable 8259 for 8250
    OUT DX,AL
    LES SI,DWORD PTR SLAVE1 ; start with slave #1 in STRPOL
    MOV CURSLV,SI
        MOV AL,NSLAVES
    MOV SLVCNT,AL       ; init current-slavecounter
    MOV TIMOUT,OFF      ; no supervision
    MOV RVEC,OFFSET RXUREQ
    MOV SVEC,OFFSET NXTSLV
    STI
    MOV AL,EOT          ; send 'EOT' to start poll-sequence
    CALL    SIOOT
cEnd

;------ int PASCAL retry_asycom(void);

cProc   RETRY_ASYCOM <PUBLIC,FAR>
cBegin
    MOV AX,_data
    MOV DS,AX
    MOV AX,RTYCNT       ; read and reset retry counter
    MOV RTYCNT,0
cEnd

;------ int PASCAL watchdog_asycom(void);

cProc   WATCHDOG_ASYCOM <PUBLIC,FAR> <es,si>
cBegin
    MOV AX,_DATA
    MOV DS,AX           ; <DS> := <CS>
    MOV AX,WDGCNT       ; read and reset watchdog counter
    MOV WDGCNT,0
cEnd

;------ void PASCAL close_asycom(void);

cProc   CLOSE_ASYCOM_   <PUBLIC> <DX>
cBegin
    MOV AX,_DATA
    MOV DS,AX           ; <DS> := <CS>
    CLI
    MOV DX,OCW1
    INC DX          ; set DX to mask register
    IN  AL,DX
    MOV AH,IMASK        ; set bit to disable interrupt
    NOT AH
    OR  AL,AH           ; interrupt enable 8259 for 8250
    OUT DX,AL
    MOV TIMOUT,OFF      ; no supervision
    MOV RVEC,OFFSET RXUREQ  ; int vectors
    MOV SVEC,OFFSET TXUREQ
    STI
    MOV DX,OLDT[0]      ; restore interrupt-vector of timer
    MOV DS,OLDT[2]
    MOV AH,25H
    MOV AL,TIMER
    cCall   DOS3Call
    MOV AX,_DATA
    MOV DS,AX           ; <DS> := <CS>
    MOV AL,INTNUM
    MOV DX,OLDC[0]      ; restore interrupt-vector of COM
    MOV DS,OLDC[2]
    MOV AH,25H
    cCall   DOS3Call
    MOV AX,_DATA
    MOV DS,AX           ; <DS> := <CS>
cEnd

sEnd    INIT_TEXT

    end