jz	sendtxBit		; Go send data bit

	cmp	A, txBit5		; tx bit 5 at frame count=14h

	jz	sendtxBit		; Go send data bit.

	cmp	A, txBit6		; tx bit 6 at frame count=17h.

	jz	sendtxBit		; Go send data bit.

	cmp	A, txBit7		; tx bit 7 at frame count=1Ah.

	jz	sendtxBit		; Go send data bit.

	cmp	A, txStop		; tx Stop at frame count=1Dh.

	jz	sendStop		; Go send stop bit.

	cmp	A, txComp		; tx Stop at frame count=20h.

	jz	txEnd			  ; Go send end transmit.

	jmp	check_tx_bit	; Wait for the next interrupt.

;

sendtxBit:

;  Transmit the current data bit and adjust for next pass.

	mov	A, [txData]		  ; Get the current data.

	or	A, txDataMask	  ; Mask out inputs.

	iowr	Port0_Data	  ; Output the current data bit.

	mov	A, [txData]		  ; Get the current data.

	asr	A			          ; Align next data bit.

	mov	[txData], A		  ; Save adjusted data.

	mov	A, FFh		      ; Fill the accumulator.

	mov	[txBitCount], A ; Write to bit counter.

	jmp	check_tx_bit	  ; Wait for next bit time.

;

sendStop:

;  The data has been sent, now send the stop bit.

	mov	A, FFh		      ; Load stop bit.

	iowr	Port0_Data		; Send stop bit.

	jmp	check_tx_bit	  ; Go to end of transmit.

;

txEnd:

;  The last data bit has been sent.

;  Clean up and return. 

	mov	A, 00h		          ; Clear the accumulator.

	mov	[interrupt_mask], A ; Load into the mask.

	iowr	Global_Interrupt	; Disable all interrupts.

	mov	A, 00h		          ; Load tx Start bit.

	mov	[txBitCount], A	    ; Clear tx bit count.

	mov	[txFrameCount], A	  ; Clear tx frame counter.

	mov	[txEnable], A	      ; Clear the tx enadle flag.

	mov	[rxFrameCount], A	  ; Clear rx frame counter.

	pop	A			              ; Restore the accumulator.

	ret				              ; Return to sender.

;

txWait:

;  Wait for the next 128us interrupt.

	mov	A, 02h		          ; Load 128us ISR Enable value.

	iowr	Global_Interrupt	; Enable 128us ISR.

	jmp	txWait		          ; Loop until 128us Interrupt.

;

;************************************************************************

; RX_Data processing:

; This routine will read in a byte of data from the 8051 UART.

; The receive subroutine is entered whenever the One_mSec_ISR occurs if

; rxEnable is set.

; The received data byte is stored in the receive buffer.

; If stop bit is invalid send a framing error to 8051 and discard data.

;************************************************************************

;

rxRoutine:

;

;  A new 128us interrupt has occurred.

;  Check the frame count and send a bit if required.

	push	A		 	          ; Save the accumulator.

	mov	A, [rxFrameCount] ; Get rx frame count.

	cmp	A, rxStart 	      ; Start bit at frame count=01h.

	jz	getrxStart 	      ; Go get Start bit.

	cmp	A, rxBit0 	      ; Data bit 0 at frame count=05h.

	jz	getrxBit 	        ; Go get data bit.

	cmp	A, rxBit1 	      ; Data bit 1 at frame count=09h.

	jz	getrxBit 	        ; Go get data bit under test.

	cmp	A, rxBit2 	      ; Data bit 2 at frame count=0Ch.

	jz	getrxBit 	        ; Go get data bit.

	cmp	A, rxBit3 	      ; Data bit 3 at frame count=0Fh.

	jz	getrxBit 	        ; Go get data bit.

	cmp	A, rxBit4 	      ; Data bit 4 at frame count=12h.

	jz	getrxBit 	        ; Go get data bit.

	cmp	A, rxBit5 	      ; Data bit 5 at frame count=16h.

	jz	getrxBit 	        ; Go get data bit.

	cmp	A, rxBit6 	      ; Data bit 6 at frame count=19h.

	jz	getrxBit 	        ; Go get data bit.

	cmp	A, rxBit7 	      ; Data bit 7 at frame count=1Ch.

	jz	getrxBit 	        ; Go get data bit.

	cmp	A, rxStop	        ; Stop bit at frame count=1Fh.

	jz	getrxStop	        ; Go get stop bit.

	pop	A		              ; Restore the accumulator.

	ret			              ; Return to caller.

;

;  Read the start bit.

getrxStart:

	iord	Port0_Data	    ; Get data.

	and	A, 80h	          ; Isolate rx data bit.

	jnz	rxAbort	          ; Bad start bit? Go abort.

	pop	A		              ; Restore the accumulator.

	ret			              ; Return to caller.

;

;  Start bit is invalid.

rxAbort:

	mov	A, 00h		        ; Clear the accumulator.

	mov	[rxBitCount], A	  ; Clear rx bit count.

	mov	[rxFrameCount], A	; Clear rx frame count.

	pop	A			            ; Restore the accumulator.

	ret				            ; Return to caller.

;

;  Get the current receive data bit and

;  process into the receive register.	

getrxBit:

	iord	Port0_Data		; Get data.

	and	A, 80h		      ; Isolate rx data bit.

	or	[rxData], A		  ; Add new data bit to register.

	mov	A, [rxBitCount]	; Get count.

	cmp	A, lastrxBit	  ; Check for last data bit.

	jz	rxSave		      ; Exit if last bit.

	inc	[rxBitCount]	  ; Bump the receive bit count.

	mov	A, [rxData]		  ; Get new data value.

	asr	A			          ; Shift data down register.

	and	A, 7Fh		      ; Clear data bit 7.

	mov	[rxData], A		  ; Store adjusted data.

	pop	A			          ; Restore the accumulator.

	ret				          ; Return to caller.

;

;  Time to get the stop bit and check for end of string.	

getrxStop:

;	iord	Port0_Data	    ; Get data.

;	and	A, 80h		        ; Isolate rx stop bit.

	mov	A, Ln_Fd		      ; Get Value of ASCII Line Feed.

	cmp	A, [rxData]		    ; Check for end of data.

	jnz	rxEnd			        ; Get next byte.

	mov	A, 00h		        ; Clear the accumulator.

	mov	[rxEnable], A	    ; Clear rx bit count.

	mov	[rxBitCount], A	  ; Clear rx bit count.

	mov	[rxFrameCount], A	; Clear rx frame count.

	pop	A			            ; Restore the accumulator.

	ret				            ; Return to caller.

;

;  Check that the stop bit is real.

;checkFrame:

;	iord	Port0_Data		  ; Get data.

;	and	A, 80h		        ; Isolate rx data bit.

;	jz	sendFrameError	  ; Framing error detected.

;

;  New character is in register, process it.

rxSave:

;

;  Strip out any ASCII Space characters.

	mov	A, Asc_Space	    ; Get Value of ASCII Space.

	cmp	A, [rxData]		    ; Check for end of data.

	jz	Skip_Char		      ; Get next byte.

;

;  Strip out any ASCII Line Feed characters.

	mov	A, Ln_Fd		      ; Get Value of ASCII Line Feed.

	cmp	A, [rxData]		    ; Check for end of data.

	jz	Skip_Char		      ; Get next byte.

;

;  Save the good ASCII characters in the receive buffer.

	mov	A, [rxData]		    ; Get the good byte of data.

	mov	X, [rxBufPtr]	    ; Point to the next buffer entry.

	mov	[X + rxBuf], A	  ; Save data byte in the receive buffer.

	inc	[rxBufPtr]		    ; Increment the receive buffer pointer.

;

;  Character is on cull list, so skip it.

Skip_Char:

;  Return for the next character;

	inc	[rxBitCount]	; Bump the bit count.

	pop	A			        ; Restore the accumulator.

	ret				        ; Return to caller.

;

;  Receive frame is done.

rxEnd:

	mov	A, 00h		        ; Clear the accumulator.

	mov	[rxBitCount], A	  ; Clear rx bit count.

	mov	[rxFrameCount], A	; Clear rx frame count.

	pop	A			            ; Restore the accumulator.

	ret				            ; Return to caller.

;



;************************************************************************

; This is the routine that is called to enable the receive routine.

;************************************************************************

;

;  Set up to receive the return character string.

getSerial:

	mov	A, 80h		        ; Enable the Port 0 Bit 7

	iowr	Port0_Interrupt	; GPIO interrupt.

;

Start_receive:

;  Enable GPIO interrupts.

  mov	A, GPIO_intMask	    ; Get the GPIO interrupt enable mask.

	iowr	Global_Interrupt	; Enable the Port 0 Bit 7 GPIO interrupt.

;

WaitForStart:

;  Wait for the receive GPIO interrupt.

	mov	A, [rxEnable]	; Get the receive enable flag.

	cmp	A, 00h		    ; Did we get an interrupt?

	jz 	WaitForStart	; Hang around if we didn't.

;

Data_receive:

;  Got the start bit. Enable the 128us interrupt and wait.

;	iowr	Watchdog		      ; Clear watchdog timer

	mov	A, 128us_intMask	  ; Set up the 128 us enable.

	iowr	Global_Interrupt	; Enable it.

	mov	A, [rxEnable]	      ; Get the enable flag.

	cmp	A, 00h		          ; Are we still enabled?

	jnz 	Data_receive	    ; Hang around for the interrupt.

;

Xfer_Done:

	ret				;

;

;************************************************************************

; This is the routine that is called to flush the receive buffer.

;************************************************************************

;

Clear_rxBuf:

;  Clear the receive buffer before sending the next command.

	push	A			      ; Save the accumulator.

	push	X			      ; Save the index register.

	mov	A, 00h		    ; Clear the accumulator.

	mov	[rxBufPtr],	A	; Clear the receive buffer pointer.

;

Clear_rxBuf_Next:

;  Loop and clear all 16 bytes of the receive buffer.

	mov	A, [rxBufPtr]	    ; Load the current receive buffer pointer.

	cmp	A, 10h		        ; Have we done 16?

	jz	Clear_rxBuf_Done	; Yes, we are done.

	mov	A, 00h		        ; Clear the accumulator.

	mov	X, [rxBufPtr]	    ; Load the index register.

	mov	[X + rxBuf], A	  ; Clear the current location.

	inc	[rxBufPtr]		    ; Point to the next byte.

	jmp	Clear_rxBuf_Next	; Do it again.

;

Clear_rxBuf_Done:

	pop	X			; Restore the index register.

	pop	A			; Restore the accumulator.

	ret				; Return to sender.

;

;************************************************************************

; This is the routine that is called to wait after receiving the latest

; character string.

;************************************************************************

;

delay1:

	push	A			                ; Save the accumulator.

	mov	A, FFh		              ; Set loop variable.

	mov	[outerDelayOneCount], A ; Store loop variable.

;

outer_delay1_loop:

	mov	A, 10h		              ; Set loop variable for good sync.

	mov	[innerDelayOneCount], A ; Load the loop count.

      mov	A, 00h		          ; Clear the accumulator.

;

inner_delay1_loop:

	iowr	Watchdog		          ; Clear watchdog timer

	dec	[innerDelayOneCount]	  ; Decrement the inner loop counter.

	cmp	A, [innerDelayOneCount]	; Is it empty?

	jnz	inner_delay1_loop	      ; Not, go do it again.

;

	dec	[outerDelayOneCount]    ; Decrement the outer loop counter.

	cmp	A, [outerDelayOneCount] ; Is it empty?

	jnz	outer_delay1_loop	      ; No, go do it again.

;

	pop	A			; Restore the accumulator.

	ret				; Return to caller.

;

;************************************************************************

; This is the routine that is called to wait between commands.

;************************************************************************

;

delay:

	push  A                   ; Save the accumulator.

	mov  A, FFh               ; Set loop variable

	mov  [outerDelayCount], A ; Store loop variable



outer_delay_loop:

	mov  A, FFh	; Set loop variable for good sync   

	mov  [innerDelayCount], A ;

  mov  A, 00h	              ;

;

inner_delay_loop:

	nop	;

	nop	;

	nop	;

	nop	;

	nop	;

	nop	;

	nop	;

	nop	;

	nop	;

	nop	;

	nop	;

	iowr  Watchdog		          ; Clear watchdog timer

	dec   [innerDelayCount]	    ; Decrement the inner count.

	cmp   A, [innerDelayCount]  ; Time up?

	jnz   inner_delay_loop      ; Yes, go to the outer loop.

;

	dec  [outerDelayCount]      ; Decrement the outer count.

	cmp  A, [outerDelayCount]   ; Time up?

	jnz  outer_delay_loop       ; No, go through the loops again.

	pop  A                      ; Restore the accumulator.

	ret				                  ; Return to caller.