; 
; Author: Hans Summers G0UPL
; Update: 29-Nov-06
; Function: LCD test
;

.include "tn2313def.inc"			; Define chip particulars

.def	pwmdir	= r2				; Holds direction PWM was stepped in
.def	actual	= r3				; Holds the Actual flag
.def	heating = r4				; Timer to allow the heater time to heat up!
.def	pwmstep = r5				; PWM step size
.def	pwml	= r6				; PWM low byte
.def	pwmh	= r7				; PWM high byte
.def	lcdstat	= r8				; LCD busy/wait status
.def	longtime= r9				; Long timer for powerup
.def	toggle	= r10				; for toggle value
.def	tVal	= r11				; Timer0 value
.def	tValLast= r12				; Timer0 value last time
.def	wreg	= r16				; General use working register
.def	leadzero= r17				; Display longitude leading zeros flag
.def	byteA0	= r18				; byteA0..byteA4 for binary to bcd conversion.
.def	byteA1	= r19
.def	byteA2	= r20
.def	byteA3	= r21
.def	byteA4	= r22
.def	temp 	= r23				; Temporary register
.def	test	= r24				; test register
.def	nmeacnt = r25				; NMEA parsing state

.equ	lcdrs	= PD6				; LCD rs pin connected to PD6
.equ	lcdrw	= PD5				; LCD r/w pin connected to PD5
.equ	lcde	= PD4				; LCD e pin connected to PD4
.equ	valid	= PD3				; Valid output signal is PD3
.equ	line1   = 0x80				; 1st row of LCD
.equ	line2   = 0xC0				; 2nd row of LCD

.cseg

.org $0000

rjmp reset		; $0000 Reset
rjmp int0h		; $0001 External Interrupt0
reti			; $0002 External Interrupt1
reti			; $0003 Timer1 Capture
reti    		; $0004 Timerl CompareA
reti			; $0005 Timer1 Overflow
reti			; $0006 Timer0 Overflow
rjmp usart0Rx	; $0007 USART0 RX Complete
reti			; $0008 USART0 UDR Empty
reti			; $0009 USART0 TX Complete
reti			; $000A Analog Comparator
reti			; $000B Pin Change Interrupt
reti			; $000C Timerl Compare B
reti    		; $000D Timer0 Compare A
reti			; $000E Timer0 Compare B
reti			; $000F USI Start
reti			; $0010 USI Overflow
reti			; $0011 EEPROM Ready
reti			; $0012 Watchdog Overflow

.equ ASCII_0 = 48
.equ ASCII_A = 65
.equ ASCII_SPC = 32
.equ ASCII_DOT = 46
.equ ASCII_COMMA = 44						; ASCII comma

.equ STEPLARGE = 128
.equ STEPMEDIUM = 16
.equ STEPSMALL = 1

message1:
.db	"GPS 10MHz reference",0
message2:
.db	"Hans Summers G0UPL, 2007 ",0

nmea:						; 
.db "GPRMC ######    # #### ##    #2##### ##    #", 0, 0
;.db "GPGSA # #2## ## ## ## ## ## ## ## ##", 0
;.db "GPGGA                   ########################2########################", 0

lcd:
.db "##:##:## a    ##o##.##'#"
lcdfreq:
.db "xyyyyyyyyy d @@#o##.##'#", 0, 0
;.db "# # ## ## ## ## ## ## ## ## ##############################", 0, 0
;.db "################################################", 0, 0

; 38528

reset:
		ldi		wreg, RAMEND
		out		SPL, wreg			; Init Stack Pointer

		rcall	longdelay			; Delay some time

		rcall	lcdinit				; Initialize LCD module
		rcall	lcdclr				; Clear the LCD

		ldi		nmeacnt, 0			; Load NMEA count register with zero

		ldi		wreg, 64 			; (1<<INT0)
        out     GIMSK, wreg     	; General INT mask bits
        ldi     wreg, 0b00000010   	; INT1,INT0 rising edge
        out     MCUCR, wreg

		ldi		wreg, 0				; set baud rate to 9600 baud at 10 MHz crystal freq
		out		UBRRH, wreg
		ldi		wreg, 64
		out		UBRRL, wreg

		ldi		wreg, 0b10010010	; enable receiver but not transmitter
		out		UCSRB, wreg

		ldi		wreg, 0b00000110 	; Set frame format: 8N1
		out		UCSRC, wreg

		ldi		wreg, 1				; start counter 0
		out		TCCR0B, wreg

		ldi		wreg, 0b00100011	; set PWM modes
		out		TCCR1A, wreg

		ldi		wreg, 0b00011001	; set PWM mode and clk prescale = 1
		out		TCCR1B, wreg

		ldi		wreg, 255			; set counter max to 65535
		out		OCR1AH, wreg
		out		OCR1AL, wreg

		ldi		wreg, 255			
		mov		heating, wreg
		
		ldi		wreg, STEPLARGE
		mov		pwmstep, wreg

		ldi		wreg, 128			; write PWM value
		mov		pwmh, wreg
		out		OCR1BH, pwmh
		out		OCR1BL, pwml

again:	
		rcall 	display	

		sei

again2:	
		rjmp	again2

usart0RxRet:
		clr		nmeacnt				; Clearing the nmeacnt flag finishes parsing of this NMEA string
		reti

usart0Rx:
		in		wreg, UDR			; Get the incoming USART byte

		cpi		nmeacnt, 0			; Carry on if we're already inside an NMEA sentence
		brne	usart0Rx1

		cpi		wreg, '$'			; Look for the $ start of an NMEA sentence
		brne	usart0RxRet

		ldi		XH, high(2 * nmea)	; Point X at the beginning of the NMEA template
		ldi		XL, low(2 * nmea)	
		ldi		YH, high(2 * lcd)	; Point Y at the beginning of the LCD template
		ldi		YL, low(2 * lcd)	

		ldi		wreg, line1			; Set LCD address to line 1
		rcall	lcdcmd

		inc		nmeacnt				; Set nmeacnt flag to 1 to indicate we're inside a sentence now

		reti

usart0Rx1:
		cpi		nmeacnt, 6			; The nmeacnt flag is 1..5 to indicate checking for sentence type
		brge	usart0Rx2

		mov		ZL, XL
		mov		ZH, XH
		lpm							; Load next character of NMEA template
		adiw	XL, 1				; Increase the X register
		cp		wreg, r0			; Compare with the incoming character (looking for sentence type e.g. GPRMC
		brne	usart0RxRet
		inc		nmeacnt
		reti

usart0Rx2:
		cpi		nmeacnt, 6
		brne	usart0Rx2a
		ldi		wreg, 64 			;(1<<INT0)
        out     GIMSK, wreg     	; General INT mask bits
		inc		nmeacnt
usart0Rx2a:
		clr		leadzero			; Clear the leading zero flag
		mov		ZL, XL
		mov		ZH, XH
		lpm							; Load next character of NMEA template
		adiw	XL, 1				; Increase the X register
		mov		temp, r0
		cpi		temp, 0				; Finish the NMEA sentence parsing when I get to end of NMEA template (0)
		breq	usart0RxRet
		cpi		temp, '#'			; Only display the incoming USART character if the template holds # at this posn
		brne	usart0Rx5
		mov		temp, wreg

usart0Rx3:
		mov		ZL, YL				
		mov		ZH, YH
		lpm							; Load next character of LCD template
		adiw	YL, 1				; Increase the Y register
		mov		wreg, r0
		cpi		wreg, '#'			; Go ahead and write the incoming NMEA character if the LCD template has # here
		breq	usart0Rx4
		cpi		wreg, '@'
		breq	usart0Rx3b
		cpi		wreg, 'o'
		brne	usart0Rx3a
		ldi		wreg, 0xdf
usart0Rx3a:
		cpi		wreg, 'a'
		brne	usart0Rx3f
		mov		actual, temp
		ldi		temp, ASCII_SPC
		rjmp	usart0Rx4
usart0Rx3f:
		cpi		wreg, 'd'
		brne	usart0Rx3g
		ldi		wreg, 1
		cp		pwmdir, wreg
		brne	usart0Rx3h
		ldi		wreg, ASCII_DOT
		rjmp	usart0Rx3d
usart0Rx3h:
		ldi		wreg, ASCII_SPC
		rjmp	usart0Rx3d
usart0Rx3g:
		cpi		wreg, 'y'
		breq	usart0Rx3e
		cpi		wreg, 'x'
		brne	usart0Rx3d
		rcall	dispfreq
		rjmp	usart0Rx3
usart0Rx3d:
		rcall	lcdput				; But otherwise, if the LCD template has non-#, display characters e.g. : etc
usart0Rx3e:
		rjmp	usart0Rx3			; Loop back until I get to a #

usart0Rx3b:							; Check for leading zeros in the longitude. temp has the NMEA character still
		cpi		temp, '0'
		brne	usart0Rx3c
		cpi		leadzero, 0
		brne	usart0Rx4
		ldi		temp, ' '
		rjmp	usart0Rx4

usart0Rx3c:
		inc		leadzero

usart0Rx4:
		mov		wreg, temp			; Display incoming NMEA character
		rcall	lcdput
		reti

usart0Rx5:
		cpi		temp, '2'			; Look for a 2 in the NMEA template string
		brne	usart0Rx6			; That means, move to LCD line 2
		ldi		wreg, line2			; Set LCD address to line 2
		rcall	lcdcmd

usart0Rx6:
		reti

dispspcs:
		cbi		PORTD, valid		; Clear the valid signal

		push	temp
		ldi		temp, 9
dispspcs1:
		ldi		wreg, ASCII_SPC
		rcall	lcdput
		dec		temp
		brpl	dispspcs1
		pop		temp
		ret

dispfreq:
		ldi		wreg, ASCII_A
		cp		actual, wreg
		brne	dispspcs

		ldi		wreg, STEPSMALL
		cp		pwmstep, wreg
		brne	dispfreq1

		sbi		PORTD, valid		; Set VALID output
		rjmp	dispfreq2

dispfreq1:
		cbi		PORTD, valid		; Reset VALID output

dispfreq2:
		rcall	Conv32bit2bcd

		mov		wreg, R21
		swap	wreg
		andi	wreg, 15
		add		wreg, temp
		rcall	lcdput

		mov		wreg, R21
		andi	wreg, 15
		add		wreg, temp
		rcall	lcdput

		ldi		wreg, ASCII_COMMA
		rcall	lcdput

		mov		wreg, R20
		swap	wreg
		andi	wreg, 15
		add		wreg, temp
		rcall	lcdput

		mov		wreg, R20
		andi	wreg, 15
		add		wreg, temp
		rcall	lcdput

		mov		wreg, R19
		swap	wreg
		andi	wreg, 15
		add		wreg, temp
		rcall	lcdput

		ldi		wreg, ASCII_COMMA
		rcall	lcdput

		mov		wreg, R19
		andi	wreg, 15
		add		wreg, temp
		rcall	lcdput

		mov		wreg, R18
		swap	wreg
		andi	wreg, 15
		add		wreg, temp
		rcall	lcdput

		mov		wreg, R18
		andi	wreg, 15
		add		wreg, temp
		rcall	lcdput

		ret

int0h:	
		in		tVal, TCNT0
		mov		wreg, tVal

		sub		wreg, tValLast
		mov		tValLast, tVal

		cpi		wreg, 128			; Compare to ideal 128 (10.000000MHz)
		brne	int0h0

		ldi		temp, 0				; Check if the heating is 0, indicating the OCXO is hot
		cp		temp, heating
		brne	int0h0

		ldi		temp, STEPSMALL		; Check if the pwm step is small
		cp		temp, pwmstep
		breq	int0h0
									; If all of that was Ok, then adjust pwmstep now
		ldi		temp, STEPMEDIUM
		cp		temp, pwmstep
		breq	int0h0a

		mov		pwmstep, temp
		ldi		temp, 255
		mov		heating, temp
		rjmp	int0h0

int0h0a:
		ldi		temp, STEPSMALL
		mov		pwmstep, temp

int0h0:
		cpi		wreg, 128
		brsh	int0h1

		ldi		temp, 0
		add		pwml, pwmstep
		adc		pwmh, temp

		inc		temp
		mov		pwmdir, temp

		rjmp	int0h15		

int0h1:	
		ldi		temp, 0
		sub		pwml, pwmstep
		sbc		pwmh, temp
		mov		pwmdir, temp
		
int0h15:
		out		OCR1BH, pwmh
		out		OCR1BL, pwml

int0h2:
		ldi		R18, low(38528)
		ldi		R19, high(38528)
		ldi		R20, 152
		ldi		R21, 0

		ldi		temp, STEPSMALL		; If we are with small pwmstep, then display 10.000000 exactly always
		cp		pwmstep, temp
		breq	int0h3

		ldi		temp, 0
		add		R18, wreg
		adc		R19, temp
		adc		R20, temp
		adc		R21, temp

		ldi		wreg, 128
		sub		R18, wreg
		sbc		R19, temp
		sbc		R20, temp
		sbc		R21, temp

int0h3:
		ldi		temp, 0
		cp		heating, temp
		breq	int0h4
		dec		heating

int0h4:
		reti

display:
		ldi		wreg, line1			; Set address to line 1
		rcall	lcdcmd
									; Write starting message line 1 to the LCD
		ldi		ZH, high(2 * message1)	
		ldi		ZL, low(2 * message1)	
		rcall	loadbyte

		ldi		wreg, line2			; Set address to line 2
		rcall	lcdcmd
									; Write starting message line 2 to the LCD
		ldi		ZH, high(2 * message2)	
		ldi		ZL, low(2 * message2)	
		rcall	loadbyte

		rcall	longdelay			; Wait some time	
;		rcall	lcdclr				; Clear the LCD

		ret
									; Clear entire LCD and delay for a bit
lcdclr:
		ldi		wreg, 1				; Clear LCD command
		rcall	lcdcmd
		ldi		wreg, 255			; Delay 15 mS for clear command
		rcall	delay
		ret
									; Initialize LCD module
lcdinit:

		ldi		wreg, 0				; Setup port pins
		out		PORTB, wreg			; Pull all pins low
		out		PORTD,wreg			; Pull all pins low
		ldi		wreg,0x1f			; All pins are outputs
		out		DDRB, wreg
		ldi 	wreg, 0xf8
		out		DDRD, wreg
		ldi		wreg, 255			; Wait at least 15 mS at power up
		rcall	delay
		ldi		wreg, 3				; Function set
		out		PORTB, wreg
		sbi		PORTD, lcde			; Toggle enable line
		cbi		PORTD, lcde
		ldi		wreg, 65			; Wait at least 4.1 mS
		rcall	delay
		ldi		wreg, 3				; Function set
		out		PORTB, wreg
		sbi		PORTD, lcde			; Toggle enable line
		cbi		PORTD, lcde
		ldi		wreg, 2				; Wait at least 100 uS
		rcall	delay
		ldi		wreg, 3				; Function set
		out		PORTB, wreg
		sbi		PORTD, lcde			; Toggle enable line
		cbi		PORTD, lcde
		ldi		wreg, 2				; Function set, 4 line interface
		out		PORTB, wreg
		sbi		PORTD, lcde			; Toggle enable line
		cbi		PORTD, lcde
		ldi		wreg, 0x10			; Make 4 data lines inputs
		out		DDRB, wreg
									; At this point, the normal 4 wire command routine can be used
		ldi		wreg, 0b00100000	; Function set, 4 wire, 2 line, 5x7 font
		rcall	lcdcmd
		ldi		wreg, 0b00001100	; Display on,  cursor off, blink off
		rcall	lcdcmd
		ldi		wreg, 0b00000110	; Address increment, no scrolling
		rcall	lcdcmd

		ret
									; Wait for LCD to go unbusy
lcdwait:
		ldi		wreg, 0x10			; Make 4 data lines inputs
		out		DDRB, wreg
		sbi		PORTD, lcdrw		; Set r/w pin to read
		cbi		PORTD, lcdrs		; Set register select to command
waitloop:
		sbi		PORTD, lcde			; Toggle enable line
		cbi		PORTD, lcde
		in		lcdstat, PINB		; Read busy flag
		sbi		PORTD, lcde			; Toggle enable line
		cbi		PORTD, lcde
		sbrc	lcdstat, 3			; Loop until done
		rjmp	waitloop

		ret
									; Send command in wreg to LCD
lcdcmd:
		mov		test, wreg
		rcall	lcdwait
		ldi 	wreg, 0x0
		cbi		PORTD, lcdrw
		ldi		wreg, 0x1f
		out 	DDRB, wreg
		mov		wreg, test
		mov		test, wreg
		swap	wreg
		andi	wreg,0x0f
		out		portB, wreg
		sbi		PORTD, lcde			; Toggle enable line
		cbi		PORTD, lcde
		mov		wreg, test
		andi	wreg, 0x0f			; Strip off upper bits
		out		PORTB, wreg			; Put on port
		sbi		PORTD, lcde			; Toggle enable line
		cbi		PORTD, lcde
		ldi		wreg, 0x10			; Make 4 data lines inputs
		out		DDRB, wreg
		ret		
									; Send character data in wreg to LCD
lcdput:
		mov		test, wreg			; Save character
		rcall	lcdwait				; Wait for LCD to be ready
		ldi 	wreg, 0x0
		cbi		PORTD, lcdrw
		ldi		wreg, 0x1f			; Make all port D pins outputs
		out		DDRB, wreg
		mov		wreg, test			; Get character back
		mov		test, wreg			; Save another copy
		swap	wreg				; Get upper nibble
		andi	wreg, 0x0f			; Strip off upper bits
		out		PORTB, wreg			; Put on port
		sbi		PORTD, lcdrs		; Register select set for data

		sbi		PORTD, lcde			; Toggle enable line
		cbi		PORTD, lcde
		mov		wreg, test			; Recall character
		andi	wreg, 0x0f			; Strip off upper bits
		out		PORTB, wreg			; Put on port

		sbi		PORTD, lcde			; Toggle enable line
		cbi		PORTD, lcde
		ldi		wreg, 0x10			; Make 4 data lines inputs
		out		DDRB, wreg
		ret

notaslongdelay:
		ldi		wreg, 50
		mov		longtime, wreg
		ldi 	wreg, 255
		rjmp 	puwait

longdelay:
		ldi		wreg, 180
		mov		longtime, wreg
		ldi		wreg, 255	
puwait:
		rcall	delay
		dec		longtime
		brne	puwait
		ret

									; Delay n*64 microseconds using timer 0, delay time passed in wreg
delay:	
		ldi 	test,255
cagain:	dec		test
		brne 	cagain
		dec 	wreg
		brne 	delay
		ret

loadbyte:
		lpm
	
		tst		r0					; Check if we've reached the end of the message
		breq	return				; If so, quit

		mov		wreg, r0
		cpi		wreg, 'o'
		brne	loadbyte1
		ldi		wreg, 0xdf
loadbyte1:
		rcall	lcdput				; Echo received char

		adiw	ZL,1				; Increase Z registers
		rjmp	loadbyte

return:	ret							; return

Conv32bit2bcd:						; Input: r18.19,20.21 (binary); out: r18,19,20,21,22 (bcd)
									; Listed above as lsB first, msB last.
		push	r16					; Save registers not needed for 
		push	r17
		push	r23					; input or output.
		push	r24
	
		rcall	Bin4BCD				; Do the conversion

		mov	r18,r20
		mov	r19,r21
		mov	r20,r22
		mov	r21,r23
		mov	r22,r24
		
		pop	r24						; Restore saved registers.
		pop	r23
		pop	r17
		pop	r16

		ret

;******** 32 bit binary to packed BCD routines from Atmel application note *************
; Call bin4bcd			r18r19r20r21       >>>         r20r21r22r23r24


Bin2BCD20:      mov     r16,r20       ;for compatibility with Math32
                mov     r17,r21       ;
Bin2BCD16:      ldi     r22,0xff      ;initialize digit 4
binBCD_4:       inc     r22           ;
                subi    r16,low(10000);subiw fbin,10000
                sbci    r17,high(10000)
                brcc    binBCD_4        ;
                ldi     r21,0x9f      ;initialize digits 3 and 2


binBCD_3:       subi    r21,0x10      ;
                subi    r16,low(-1000);subiw fbin,1000
                sbci    r17,high(-1000)
                brcs    binBCD_3        ;
binBCD_2:       inc     r21           ;
                subi    r16,low(100)  ;subiw fbin,100
                sbci    r17,high(100) ;
                brcc    binBCD_2        ;
                ldi     r20,0xa0      ;initialize digits 1 and 0
binBCD_1:       subi    r20,0x10      ;
                subi    r16,-10       ;subi fbin,10
                brcs    binBCD_1        ;
                add     r20,r16     ;
binBCD_ret:     ret                     


;* r18:r19:r20:r21  >>>  r20:r21:r22:r23:r24  <== this one.
;*           hex                              dec
;*       r18r19r20r21       >>>         r20r21r22r23r24

Bin4BCD:  
	      		rcall   Bin2BCD20       ;
                clr     r23           ;initial highest bytes of result
                ldi     r24,0xfe      ;
binBCD_loop:    subi    r20,-0x33     ;add 0x33 to digits 1 and 0
                sbrs    r20,3         ;if bit 3 clear
                subi    r20,0x03      ;       sub 3
                sbrs    r20,7         ;if bit 7 clear
                subi    r20,0x30      ;       sub $30
                subi    r21,-0x33     ;add 0x33 to digits 3 and 2
                sbrs    r21,3         ;if bit 3 clear
                subi    r21,0x03      ;       sub 3
                sbrs    r21,7         ;if bit 7 clear
                subi    r21,0x30      ;       sub $30
                subi    r22,-0x33     ;add 0x33 to digits 5 and 4
                sbrs    r22,3         ;if bit 3 clear
                subi    r22,0x03      ;       sub 3
                sbrs    r22,7         ;if bit 7 clear
                subi    r22,0x30      ;       sub $30
                lsl     r18           ;
                rol     r19           ;shift lower word
                rol     r20           ;through all bytes
                rol     r21           ;
                rol     r22           ;
                rol     r23           ;
                rol     r24           ;
                brmi    binBCD_loop     ;7 shifts w/o correction of MSD
                rol     r17           ;since Bin2BCD r17 = 0xff
                brcc    binBCD_ret 	;shoot      ;  so as to do 16_lsl in total
                subi    r23,-0x33     ;add 0x33 to digits 7 and 6
                sbrs    r23,3         ;if bit 3 clear
                subi    r23,0x03      ;       sub 3
                sbrs    r23,7         ;if bit 7 clear
                subi    r23,0x30      ;       sub $30
                subi    r24,-0x03     ;add 0x03 to digit 8 only
                sbrs    r24,3         ;if bit 3 clear
                subi    r24,0x03      ;       sub 3
                rjmp    binBCD_loop     ;