;
                NAME    serial
        ;
        ;*************************************************************
        ;*              8051 serial port routines                    *
        ;*                                                           *
        ;*      Received characters are put into a circular buffer.  *
        ;*                                                           *
        ;*  Written by:  Dennis Benson       August 30, 1990         *
        ;*  Last Revision:  August 30, 1990                          *
        ;*                                                           *
        ;*  Company:  Electro-Biology Inc.                           *
        ;*            6 Upper Pond Road                              *
        ;*            Parsippany, N.J 07054                          *
        ;*            (201)-299-9022  EXT 2256                       *
        ;*                                                           *
        ;*  Definitions:                                             *
        ;*      keybuff  -  serial keyboard buffer (local)           *
        ;*                    internal register banks 2-3 (10h-1fh)  *
        ;*      kbfrd    -  keyboard read pointer (local)            *
        ;*      kbfwrt   -  keyboard write pointer  (local)          *
        ;*                                                           *
        ;*  Note: assumes register bank 0 all the time.....          *
        ;*                                                           *
        ;*************************************************************
        ;
nul             EQU     00h             ; nul character equate
        ;
keybuff         DATA    10h             ; keyboard buffer at 10h - 1fh (local)
        ;
kbfwrt          DATA    30h             ; keybd write pointer (local)
kbfrd           DATA    31h             ; keybd buff read pntr (local)
        ;
        ;
serial_seg      SEGMENT         CODE
RSEG            serial_seg
        ;
PUBLIC          serial_int              ; interrupt handler
PUBLIC          ser_send, ser_msg, mser_msg
PUBLIC          getkey, getkey1, purge
        ;
        ;*************************************************************
        ;*  Serial interrupt handler routine                         *
        ;*                                                           *
        ;*  Destroys: nothing                                        *
        ;*  Returns: nothing                                         *
        ;*  Updates: kbfrd, kbfwrt, and character buffer             *
        ;*                                                           *
        ;*  NOTE: The PSW should be already be pushed on the stack.  *
        ;*                                                           *
        ;*              ORG     0023h                                *
        ;*              push    psw                                  *
        ;*              ljmp    serial_int                           *
        ;*                                                           *
        ;*************************************************************
        ;
serial_int:     jbc     ri,got_ri       ; check for character in buffer
                pop     psw             ; restore the flags
                reti
        ;
got_ri:         push    acc             ; save the acc
                push    00h
                mov     a,kbfwrt        ; get the write pointer value
                inc     a               ; see if right behind read pointer
                cjne    a,#20h,rollok
                mov     a,#keybuff
rollok:         cjne    a,kbfrd,keyptok ; if so then do not accept
                sjmp    keyexit
        ;
keyptok:        mov     r0,kbfwrt       ; load the keyboard pointer
                mov     a,sbuf          ; get the character waiting
                mov     @r0,a           ; save the character
                inc     kbfwrt          ; increment the write pointer
                mov     a,kbfwrt
                cjne    a,#20h,keyexit  ; if write not at end of buffer then ok
                mov     kbfwrt,#keybuff ; else roll write (keybd buff 10h-1fh)
keyexit:        pop     00h
                pop     acc
                pop     psw
                reti
        ;
        ;*************************************************************
        ;*  Serial port buffer routines                              *
        ;*                                                           *
        ;*  getkey: Get a character from the serial buffer if one    *
        ;*    not available then wait for one.                       *
        ;*                                                           *
        ;*     Invocation:  lcall  getkey                            *
        ;*     Destroys: acc, flags                                  *
        ;*     Returns: character waiting in acc                     *
        ;*     Updates: kbfrd, kbfwrt, and character buffer          *
        ;*                                                           *
        ;*  getkey1: Same as sgetkey but does not wait for a         *
        ;*    character if one not available.                        *
        ;*                                                           *
        ;*     Invocation:  lcall  getkey1                           *
        ;*     Destroys: acc, flags                                  *
        ;*     Returns: cy = 0 and character waiting in acc          *
        ;*              cy = 1 if no character waiting               *
        ;*     Updates: kbfrd, kbfwrt, and character buffer          *
        ;*                                                           *
        ;*  purge: reset serial port buffer pointers.                *
        ;*                                                           *
        ;*     Invocation:  lcall  purge                             *
        ;*     Destroys: nothing                                     *
        ;*     Returns: nothing                                      *
        ;*     Updates: kbfrd, kbfwrt  (set to beggnining of buffer) *
        ;*                                                           *
        ;*************************************************************
        ;
getkey:         mov     a,kbfrd         ; get read pointer
                cjne    a,kbfwrt,getchar  ; compare to write pointer
                sjmp    getkey          ; if equal then wait for one
        ;
getchar:        push    00h
                mov     r0,kbfrd        ; load the keyboard read pointer
                mov     a,@r0           ; get character
                push    acc             ; save the character
                inc     kbfrd
                mov     a,kbfrd
                cjne    a,#20h,kbfrd_ok ; check for end of keybuff
                mov     kbfrd,#keybuff  ; reset read pointer to beginning
kbfrd_ok:       pop     acc             ; get the character back
                pop     00h
                clr     c               ; clear the carry flag
                ret                     ; return
        ;
getkey1:        mov     a,kbfrd         ; get read pointer
                cjne    a,kbfwrt,getchar ; compare to write pointer
                setb    c               ; set the carry if no character found
                ret                     ; if none available return
        ;
purge:          mov     kbfrd,#keybuff
                mov     kbfwrt,#keybuff
                ret
        ;
        ;*************************************************************
        ;*  Serial port transmit routines                            *
        ;*                                                           *
        ;*  ser_send: send character in acc out serial port          *
        ;*                                                           *
        ;*     Invocation:  mov    a,#'A'                            *
        ;*                  lcall  ser_send                          *
        ;*                                                           *
        ;*     Destroys: acc and flags                               *
        ;*     Returns: nothing                                      *
        ;*                                                           *
        ;*  ser_msg: Send serial message from program rom            *
        ;*                                                           *
        ;*     Invocation:  mov    dptr,#message                     *
        ;*                  lcall  ser_msg                           *
        ;*                  ........                                 *
        ;*        message:  DB   'Hello' , nul                       *
        ;*                                                           *
        ;*     Destroys: acc, dptr and flags                         *
        ;*     Returns: nothing                                      *
        ;*                                                           *
        ;*  mser_msg: Send serial message from external data memory  *
        ;*            Same as ser_msg but message is in external     *
        ;*             data memory                                   *
        ;*                                                           *
        ;*     Destroys: acc, dptr and flags                         *
        ;*     Returns: nothing                                      *
        ;*                                                           *
        ;*************************************************************
        ;
ser_send:       jnb     ti,$            ; wait for transmitt ready
                clr     ti
                mov     sbuf,a          ; send character
                ret
        ;
ser_msg:        clr     a
                movc    a,@a+dptr       ; get the character to send
                cjne    a,#nul,$+4
                ret
        ;
                jnb     ti,$            ; wait for transmitt ready
                clr     ti
                mov     sbuf,a          ; send character
                inc     dptr            ; next character
                sjmp    ser_msg         ; get next character
        ;
mser_msg:       movx    a,@dptr         ; get the character to send
                cjne    a,#nul,$+4
                ret
        ;
                jnb     ti,$            ; wait for transmitt ready
                clr     ti
                mov     sbuf,a          ; send character
                inc     dptr            ; next character
                sjmp    mser_msg        ; get next character
        ;
        ;*************************************************************
        ;
                END