/*
File:   Serialio.asm

Copyright ©1998, 1999 Larry Barello

Author: Larry Barello
        lbarello@accessone.com

You are allowed to use this file for personal use only.

You may use, embed, modify or distribute the contents
of this file in any way you see fit as long as you 
include this copyright notice in the resulting file.

Any commercial or industrial use including publishing
or distributing in any form requires the written 
authorization of the copyright holder(s).

No guarantees are made about fitness, functionality, 
correctness or performance of this file.  The file is 
supplied on a "AS IS" basis, with no responsibility 
assumed by the author(s) for bug fixes, support, or 
damages of any sort arising from the use of this file. 

Contact the author with problem reports or fixes, 
feature requests or additions and questions.  They 
are welcomed and will be incorporated as time and 
energy permits.

*/
#include        "Registers.inc"
#include        "avrx.inc"

        MODULE  SERIALIO
        
        EXTERN  CPUCLK _IntProlog _Epilog 
        EXTERN  AvrXWaitSemaphore AvrXIntSetSemaphore
        
        PUBLIC  _GetChar PutChar _PrintString
        PUBLIC  UDRE_Interrupt RxC_Interrupt
        PUBLIC  PutCR PutSpace InitSerialIO PushChar
;
; Needed for USART interrupt
;
BAUDRATE = 19200

UCR_INIT  = 1<<TXEN | 1<<RXEN | 1<<RXCIE
UBRR_INIT = (CPUCLK/(16 * BAUDRATE)) - 1

#ifndef SioFlags
        RSEG    DATA
SioFlags:       DS      1
#endif
CharPushed      =       7

        RSEG    AVRXDATA:DATA(0)
RxC_Flag:       DS      MtxSz   
TxIntFlag:      DS      MtxSz

        RSEG    CODE
;+
;------------------------------------------
; PushChar
;
; Set a flag so that the next call to GetChar just returns.
; in effect pushing the last returned charactor to be retrieved
; by the next routine
;-
PushChar:
#ifdef  SioFlags
        sbr     SioFlags, 1<<CharPushed
#else
        push    Xl
        lds     Xl, SioFlags
        sbr     Xl, 1<<CharPushed
        sts     SioFlags, Xl
        pop     Xl
#endif
        ret
;+
;------------------------------------------
; GetChar
;
; Need to make this draw from a buffer so that multiple
; char's can be pushed... and so different input streams
; can be attached to the buffer.
;-
GetChar:
        push    Xl
#ifdef  SioFlags
        mov     Xl, SioFlags
#else
        lds     Xl, SioFlags
#endif
        sbrs    Xl, CharPushed
        rjmp    gc00
        cbr     Xl, 1<<CharPushed
        rjmp    gc01
#ifdef  SioFlags
        mov     SioFlags, Xl
#else
        sts     SioFlags, Xl
#endif
        rjmp    gc01
gc00:
        ldi     Xl, low(RxC_Flag)
        rcall   AvrXWaitSemaphore       ; Wait for a charactor, or flag from System
gc01:
        pop     Xl
        ret
;+
;------------------------------------------
; _GetChar
;
; Special version that echo's
;
; RETURNS:      RxByte (Register)
;-
_GetChar:
        push    Xl
#ifdef  SioFlags
        mov     Xl, SioFlags
#else
        lds     Xl, SioFlags
#endif
        sbrs    Xl, CharPushed
        rjmp    _gc00
        cbr     Xl, 1<<CharPushed
#ifdef  SioFlags
        mov     SioFlags, Xl
#else
        sts     SioFlags, Xl
#endif
        pop     Xl                      ; Just return the previous charactor, no echo
        ret
_gc00:
        ldi     Xl, low(RxC_Flag)
        rcall   AvrXWaitSemaphore       ; Wait for a charactor, or flag from System
        pop     Xl
        mov     TxByte, RxByte
        rjmp    PutChar
       
;+
;------------------------------------------
;
; PutCR
;
; Put a CR to the output stream
;-
PutCR:
        ldi     TxByte, 0x0D
        rjmp    PutChar
;+
;------------------------------------------
;
; PutSpace
;
; Put a space to the output stream
;-
PutSpace:
        ldi     TxByte, ' '
        rjmp    PutChar

;+
;------------------------------------------
;
; PutString
;
; Prints out a string in code memory
;-
_PrintString:
        lpm
        tst     R0
        breq    _ps00
        mov     TxByte, R0
        rcall   PutChar
        adiw    Zl, 1
        rjmp    _PrintString
_ps00:
        ret
;
; InitSerialIO
;
InitSerialIO:
        ldi     R31, UBRR_INIT  ; Usart 
        out     UBRR, R31
        ldi     R31, UCR_INIT
        out     UCR, R31
        sbi     PORTD, PD0      ; Enable pull up on Rx
        ret

;
;-----------------------------------------------
; UDRE_Interrupt
;
; Disables the interrupt (UDR is empty) signal waiting
; process to stuff the UDR
;
UDRE_Interrupt:
        cbi     UCR, UDRIE      ; Disable the interrupt
        
        rcall   _IntProlog
        
        ldi     Xl, low(TxIntFlag)
        rcall   AvrXIntSetSemaphore     ; Signal we are ready for more.
        
        rjmp    _Epilog
        
;
;-----------------------------------------------
; RxC_Interrupt
;
; Reads the USART and flags UserTask, Char In semaphore
;
RxC_Interrupt:
        in      RxByte, UDR     ; Do this first to clear the interrupt

        rcall   _IntProlog

        ldi     Xl, low(RxC_Flag)
        rcall   AvrXIntSetSemaphore

        rjmp    _Epilog
;+
;------------------------------------------
; PutChar
;
; Stuffs "TxByte" into usart.  The usart is double buffered.
; when the data register is full we wait on the semaphore
; until the Usart interrupts indicating the register is ready.
;-
PutChar:
        push    Xl
        sbic    USR, UDRE
        rjmp    pc00
        
        sbi     UCR, UDRIE      ; Enable interrupts and
        ldi     Xl, low(TxIntFlag)
        rcall   AvrXWaitSemaphore; Wait until data register is ready
pc00:
        out     UDR, TxByte

        pop     Xl
        ret
        
        ENDMOD

        MODULE  GETHEX
        PUBLIC  _GetHex GetHexChar GetHexByte GetHexWord IsHex IsWhite

        EXTERN  _GetChar

        RSEG    CODE
;-----------------------------------------
; _GetHex
;
; PASSED:       R24 = Maximum number of digits
; RETURNS:      Y = val, Tbit, R25 = Number of digits entered
; USES:         R24, R25
; STACK:        4
;
_GetHex:
        clr     Yl
        clr     Yh
        clr     R25
gh_00:
        rcall   _GetChar
        rcall   IsHex
        brtc    gh_xx
        cpi     RxByte, '9'+1
        brge    gh_01
        subi    RxByte, '0'
        rjmp    gh_02
gh_01:
        cbr     RxByte, 0x20
        subi    RxByte, 'A'-10
gh_02:
        lsl     Yl
        rol     Yh
        lsl     Yl
        rol     Yh
        lsl     Yl
        rol     Yh
        lsl     Yl
        rol     Yh
        add     Yl, RxByte
        inc     R25
        dec     R24
        brne    gh_00
gh_xx:
        ret


;-----------------------------------------
; GetHexWord
;
GetHexWord:
        ldi     R24, 4
        rjmp    _GetHex
;-----------------------------------------
; GetHexByte
;
GetHexByte:
        ldi     R24, 2
        rjmp    _GetHex

;-----------------------------------------
; GetHexByte
;
GetHexChar:
        ldi     R24, 1
        rjmp    _GetHex

;-----------------------------------------
; IsHex
;
; Tests RxByte for ascii hex char
; Returns: T bit
;
IsHex:
        clt
        cpi     RxByte, '0'
        brlt    ihno
        cpi     RxByte, '9'+1
        brlt    ihyes
        cpi     RxByte, 'A'
        brlt    ihno
        cpi     RxByte, 'F'+1
        brlt    ihyes
        cpi     RxByte, 'a'
        brlt    ihno
        cpi     RxByte, 'f'+1
        brge    ihno
ihyes:  set
ihno:   ret

;-----------------------------------------
; IsWhite
;
; Tests RxByte for space or CR
; Returns: T bit
;
IsWhite:
        clt
        cpi     RxByte, ' '
        breq    ihyes
        cpi     RxByte, 0x0D
        breq    ihyes
        ret

        ENDMOD

        MODULE  PUTHEX
        PUBLIC  _PutHex PutHexByte PutHexWord
        EXTERN  PutChar

        RSEG    CODE
;-----------------------------------------
; _PutHex
; 
; Passed:       Y = Value, R24 = # digits
; RETURN:       Nothing
; USES:         R25, TxByte
; STACK:        2
;
_PutHex:
        ldi     R25, 4          ; Maximum number of digits.
ph00:
        lsl     Yl
        rol     Yh
        rol     TxByte
        lsl     Yl
        rol     Yh
        rol     TxByte
        lsl     Yl
        rol     Yh
        rol     TxByte
        lsl     Yl
        rol     Yh
        rol     TxByte

        cp      R24, R25
        brlt    ph02

        cbr     TxByte, 0xF0
        subi    TxByte, -'0'            ; Addi '0'
        cpi     TxByte, ('9' + 1)       ; if > '9'
        brlt    ph01                    ; subi '9' and add 'A'
        subi    TxByte, ('9' + 1 - 'A')
ph01:   
        rcall   PutChar
ph02:   
        dec     R25
        brne    ph00

        ret
        
;-----------------------------------------
; Put out a hex word
; 
; Passed: Y = word
;
PutHexWord:
        ldi     R24, 4
        rjmp    _PutHex

;-----------------------------------------
; Put out a two ascii hex byte
; Yl = byte
;
PutHexByte:
        ldi     R24, 2
        rjmp    _PutHex

        END