;(C)2008 T O'Brien
;28 Dec 08	Fast ADC read and block store using FAT16 file format


.NOLIST
.INCLUDE "C:\Program Files\Atmel\AVR Tools\AvrAssembler2\Appnotes\m163def.inc"

;**************************
;Set Constants

.EQU baudrate = 12		;corresponds to 19200 at 4 MHz

.EQU secH =     	SRAM_START			;timer seconds
.EQU secL =     	secH + 1

.EQU bcd3 =			secL + 1			;BCD of ADC
.EQU bcd2 =			bcd3 + 1
.EQU bcd1 =			bcd2 + 1
.EQU bcd0 =			bcd1 + 1

.EQU display =  	bcd0 + 1			;sram used for LCD display

.EQU block =		display + 16		;SD card read and write buffer
.EQU blockend = 	block + 511

.EQU Part3 =		blockend + 1		;abs sector partition 1
.EQU Part2 =		Part3 + 1
.EQU Part1 =		Part2 + 1

.EQU SecClu	=		Part1 + 1			;no. sector per cluster (4,8,16,32 or 64 for Fat16)

.EQU ResSecH =		SecClu + 1			;no. reserve sectors
.EQU ResSecL =		ResSecH + 1

.EQU SecFatH =		ResSecL + 1			;no. sectors per Fat
.EQU SecFatL =		SecFatH + 1

.EQU Fat13 =		SecFatL + 1			;abs sector Fat1
.EQU Fat12 = 		Fat13 + 1
.EQU Fat11 = 		Fat12 + 1

.EQU Fat1E3 =		Fat11 + 1			;abs sector Fat1 entry
.EQU Fat1E2 =		Fat1E3 + 1
.EQU Fat1E1 =		Fat1E2 + 1

.EQU Fat1EOSH =		Fat1E1 + 1			;byte offset Fat1 entry (each entry = 2 bytes)
.EQU Fat1EOSL =		Fat1EOSH + 1

.EQU Fat23 =		Fat1EOSL + 1		;abs sector Fat2
.EQU Fat22 =		Fat23 + 1
.EQU Fat21 =		Fat22 + 1

.EQU Dir3 = 		Fat21 + 1			;abs sector Dir
.EQU Dir2 =			Dir3 + 1
.EQU Dir1 =			Dir2 + 1

.EQU DirE3 =	 	Dir1 + 1			;abs sector Dir entry
.EQU DirE2 =		DirE3 + 1
.EQU DirE1 =		DirE2 + 1	

.EQU DirEOSH = 		DirE1 + 1			;Dir entry byte offset (each entry = 32 bytes)
.EQU DirEOSL = 		DirEOSH + 1	

.EQU DirNoH =		DirEOSL + 1			;Dir entry number (0 to 511)
.EQU DirNoL =		DirNoH + 1

.EQU FileLn3 =		DirNoL + 1			;file length (bytes)
.EQU FileLn2 =		FileLn3 + 1
.EQU FileLn1 =		FileLn2 + 1
.EQU FileLn0 =		FileLn1 + 1

.EQU StClH =	 	FileLn0 + 1			;file start cluster number
.EQU StClL =		StClH + 1

.EQU StCl3 =		StClL + 1			;abs addr of start cluster
.EQU StCl2 = 		StCl3 + 1	
.EQU StCl1 =		StCl2 + 1

.EQU noClH =		StCl1 + 1			;no. clusters written
.EQU noClL =		noClH + 1

;***********************
;Define Registers

.DEF bytect3 = 		R2
.DEF bytect2 = 		R3
.DEF bytect1 = 		R4
.DEF bytect0 = 		R5

.DEF a2d =			R6					;adc interrupt temporary storage

.DEF keyflag =		R7					;keypressed roll-over flag

.DEF aug3 =			R8					;SD card block 32 bit address
.DEF aug2 =			R9
.DEF aug1 =			R10

.DEF chr =			R11					;uart character

.DEF sd =			R16					;SD card input/output spi chr

.DEF secctH	=		R17					;sector counter
.DEF secctL	=		R18

.DEF crc =			R19					;SD card crc 
.DEF cmd =			R20					;SD card command 

.DEF statusflag =	R21					;status register
.EQU 				ReadError = 	0	;sd card
.EQU 				WriteError = 	1	;sd card
.EQU 				Overrun = 		2	;adc buffer
.EQU				EraseError = 	3	;sd card
.EQU				noFAT = 		4	;no FAT
.EQU				DirFull = 		5	;No Directory entries available
.EQU				FatFull = 		6	;No Fat entries available
.EQU 				SDFull = 		7	;sd card

.DEF temp0 =   		R22					;general usage temp storage
.DEF temp1 = 		R23					
.DEF temp2 =		R24
.DEF temp3 =		R25

;*******************************************************************************
;Reset and Interrupt Vectors

.CSEG
.ORG 0x0000

	jmp	reset	;reset vector
	jmp	eint0  	;external interrupt request 0 vector
	jmp	eint1  	;external interrupt request 1 vector
	jmp	t2cm  	;timer/counter 2 compare match vector
	jmp	t2o		;timer/counter 2 overflow vector
	jmp	t1ce	;timer/counter 1 capture event vector
	jmp	t1cma	;timer/counter 1 compare match A vector
	jmp	t1cmb	;timer/counter 1 compare match B vector

	jmp	t1o		;timer/counter 1 overflow vector
	jmp	t0o		;timer/counter 0 overflow vector
	jmp	spic	;spi serial transfer complete vector
	jmp	urxc	;UART receive complete vector
	jmp	utxdre	;UART transmit data register empty vector
	jmp	utxc	;UART transmit complete vector
	jmp	adcc	;analog conversion complete vector

	jmp	epromr	;EEPROM ready vector
	jmp	anci	;analouge comparitor interrupt vector
	jmp	twsi	;two wire serial interface vector


;*******************************************************************************
;Interrupt Service Routines


eint0:				;external interrupt 0
	reti

eint1:				;external interrupt 1
	reti

t2cm:				;timer/counter 2 compare match interrupt
	reti

t2o:				;timer/counter 2 overflow interrupt
	reti

t1ce:				;timer/counter 1 capture event interrupt
	reti

t1cma:				;timer/counter 1 compare match a interrupt
	reti

t1cmb:				;timer/counter 1 compare match b interrupt
	reti

t1o:				;timer/counter 1 overflow interrupt
	reti

t0o:				;timer/counter 0 overflow interrupt
	reti

spic:				;spi serial transfer complete interrupt
	reti


;*******************
;UART receive charater interrupt
;gets character, out to LCD, and transmit echo
;
;input: 	UDR
;uses:		-
;returns:	chr
;calls: 	moveLCD
;			sendchrL
;stack		2

urxc:				;UART receive complete interrupt
	push temp0
	in chr, UDR		;read the received chr
	out UDR, chr	;echo chr
	ldi temp0, $4F	;position LCD cursor
	rcall moveLCD	
	mov temp0, chr
	rcall sendchrL
	pop temp0
	reti
;*******************

utxdre:				;UART transmit data register empty interrupt
	reti

utxc:				;UART transmit complete interrupt
	reti


;*******************
;ADC complete interrupt
;
;input: 	ADCL
;			ADCH
;			X: sd card write position in buffer
;modifies 	buflen
;			bufwrite
;			Y: adc write position in buffer		
;returns:	Overrun error in statusflag
;calls: 	-
;stack		1

adcc:							;analog conversion complete vector
	in a2d, ADCL				;store adc data little endian
	st Y+, a2d
	in a2d, ADCH
	st Y+, a2d
	cpi YL, LOW(blockend + 1)	;compare Y with blockend
	brne adc1
	cpi YH, HIGH(blockend + 1)
	brne adc1
	ldi YL, LOW(block)
	ldi YH, HIGH(block)

adc1:
	cp XL, YL
	brne adc2
	cp XH, YH
	brne adc2	
	sbr statusflag, 1<<Overrun	;buffer full
	rjmp error

adc2:
	reti

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

epromr:
	reti					;EEPROM ready vector

anci:
	reti					;analouge comparitor interrupt vector

twsi:
	reti					;two wire serial interface vector



;*******************************************************************************
;Main Program

reset:						;program starts here  
	ldi temp0, HIGH(RAMEND)	;set stack to top of uP SRAM
	out SPH, temp0
	ldi temp0, LOW(RAMEND)
	out SPL, temp0
	
	rcall initHW			;initialise hardware

	rcall initSD			;initialise SD card

	rcall initFAT			;initialise Fat16 variables

main:						;main menu
	rcall clearLCD
	ldi ZL, LOW(msg6<<1)	;send 'Command' message
	ldi ZH, HIGH(msg6<<1)
	rcall sendstrZ
	ldi temp0, $40			;LCD to Line 2 Start
	rcall moveLCD
	ldi ZL, LOW(msg7<<1)	;send 'Read Write Erase' message
	ldi ZH, HIGH(msg7<<1)
	rcall sendstrZ	

	rcall clrkey

main1:
	sbis PIND, PD4			;push button 1		
	rjmp read				

	sbis PIND, PD3			;push button 2
	rjmp write

	sbis PIND, PD2			;push button 3
	rjmp erase	

	sbic PINB, PB2			;SD card removed
	rjmp reset

	sbis PINC, PC4			;debug routine
	rjmp debug
	
	rjmp main1

	
;*******************
;Write File to card

write:
	lds aug1, dir1				;find a free directory entry
	lds aug2, dir2
	lds aug3, dir3

	clr temp1					;temp1 counts directory sectors (max = 31)
	clr secctL					;secct counts directory entries (max = 511)
	clr secctH

write0:
	rcall SDread				;load the Directory

	ldi XL, LOW(block)			;reset the block counter
	ldi XH, HIGH(block)

write1:	
	ld temp0, X
	cpi temp0, $00				;look for $00 in directory 
	breq dirFnd

	inc secctL					;inc the directory entry counter
	brne write2
	inc secctH

write2:
	adiw X, $20					;inc the block offset to the next directory file entry
	cpi XL, LOW(blockend + 1)
	brne write1
	cpi XH, HIGH(blockend + 1)
	brne write1
	
	inc temp1					;inc dir sec counter, maximum = 31
	cpi temp1, 32
	breq noDirSp

	rcall incAug				;increment the directory sector
	rjmp write0

noDirSp:
	sbr statusflag, 1<<DirFull	;write error
	rjmp error

dirFnd:							;unused directory entry found	
	sts DirE3, aug3				;save abs directory entry sector
	sts DirE2, aug2
	sts DirE1, aug1

	sts DirEOSH, XH				;save directory entry offset in current sector 
	sts DirEOSL, XL

	sts DirNoH, secctH			;save the directory entry number 
	sts DirNoL, secctL

	clr secctH					;clear the sector counter
	clr secctL	

	clr	temp2					;cluster counter
	clr temp3

	lds YH, SecFatH				;load sectors per Fat
	lds YL, SecFatL

	lds aug3, Fat13				;check for free Fat entry
	lds aug2, Fat12				;loop through Fat for first $00 entry
	lds aug1, Fat11

findFat:
	rcall SDread				;read Fat1 sector

	ldi XL, LOW(block)
	ldi XH, HIGH(block)

fF1:
	ld temp0, X+
	ld temp1, X+
	cpi temp0, $00
	brne fF2
	cpi temp1, $00
	breq fatFnd

fF2:
	inc temp2					;inc cluster counter
	brne fF2a
	inc temp3
	
fF2a:	
	cpi XL, LOW(blockend + 1)
	brne fF1
	cpi XH, HIGH(blockend + 1)
	brne fF1

	inc secctL					;inc secct and compare with SecFat 
	brne fF3
	inc secctH

fF3:				
	cp secctL, YL
	brne fF4
	cp secctH, YH
	brne fF4

	sbr statusflag, 1<<FatFull	;no Fat entries available
	rjmp error

fF4:	
	rcall incaug
	rjmp findFat
	
fatFnd:							;free Fat entry found
	sts Fat1E3, aug3			;save abs Fat1E sector
	sts Fat1E2, aug2
	sts Fat1E1, aug1

	sbiw X, 2
	sts Fat1EOSH, XH			;save Fat1EOS in Fat1E sector
	sts Fat1EOSL, XL

	sts StClH, temp3			;save the entry cluster number
	sts StClL, temp2	
				
	sbiw temp3:temp2, 2			;calculate start cluster abs addr			
	lds temp0, secclu			;stcl = dir + $4000 + (StCl no. - 2) * SecCl * 512
	clc
	rol temp0
	mul temp2, temp0
	mov aug1, R0
	mov aug2, R1
	mul temp3, temp0
	add aug2, R0 
	adc aug3, R1

	ldi temp0, $40
	add aug1, temp0
	clr temp0
	adc aug2, temp0
	adc aug3, temp0

	lds temp0, dir1
	add aug1, temp0
	lds temp0, dir2
	adc aug2, temp0
	lds temp0, dir3
	adc aug3, temp0

	sts stcl3, aug3
	sts stcl2, aug2
	sts stcl1, aug1

	rcall clearLCD
	ldi ZL, LOW(msg8<<1)		;send 'Writing ' message
	ldi ZH, HIGH(msg8<<1)
	rcall sendstrZ

	ldi ZL, LOW(msgb<<1)		;write a unique file name 'DATAHHHH' to LCD
	ldi ZH, HIGH(msgb<<1)		;point Z to 'DATA'

fn1:
	lpm temp0, Z+
	cpi temp0, $00
	breq fn2					;branch if $00
	rcall sendchrL
	rjmp fn1

fn2:
	lds temp0, dirNoH
	rcall hexLCD
	lds temp0, dirNoL
	rcall hexLCD

	ldi temp0, $40				;LCD to Line 2 Start
	rcall moveLCD
	ldi ZL, LOW(msg9<<1)		;send '---  ---  Exit' message
	ldi ZH, HIGH(msg9<<1)	
	rcall sendstrZ

	ldi XL, LOW(block)			;set sd block pointer, X
	ldi XH, HIGH(block)

	movw Y,X					;set adc block pointer, Y

	rcall ledon
	
	ldi cmd, 25					;cmd25 multi block write card
	ser crc						;set up command registers
	rcall SDcmd

	clr ZL

SDm:
	cpi sd, 0					;get card response, 0 = OK	
	breq SDm1					;jump to write				
	ser sd
	rcall SDtr
	dec ZL
	brne SDm
						
	sbr statusflag, 1<<WriteError	;write error
	rjmp error						;exit

SDm1:	;enable ADC, start conv., free running, interupt en. & prescale division by 16
	ldi temp0, 1<<ADEN|1<<ADSC|1<<ADFR|1<<ADIE|1<<ADPS2
	out ADCSR, temp0

SDm2:							;delay and send start token
	ser sd
	rcall SDtr
	ldi sd, $FC
	rcall SDtr

SDm3:
	cp XL, YL					;wait for data to send from adc
	brne SDm4
	cp XH, YH
	breq SDm3

SDm4:
	ld sd, X+					;write to the card
	rcall SDtr

	ld sd, X+
	rcall SDtr

	cpi	XL, LOW(blockend + 1)	;check X < bufend
	brne SDm3
	cpi XH, HIGH(blockend + 1)
	brne SDm3

	ser sd						;write 2 dummy crc bytes
	rcall SDtr
	ser sd
	rcall SDtr

	ser sd						;get card response
	rcall SDtr
	andi sd, $1F
	cpi sd, $05
	breq SDm5

	sbr statusflag, 1<<WriteError	;write error
	rjmp error						;exit

SDm5:
	ser sd						;loop until sd card not busy
	rcall SDtr
	cpi sd, $00
	breq SDm5

	ldi XL, LOW(block)			;reset X to start of block
	ldi XH, HIGH(block)

	rcall incAug

	sbis PIND, PD2
	rjmp endwrite

	lds temp0, fat23			;compare aug with fat2; if equal, end
	cp aug3, temp0
	brne SDm2
	lds temp0, fat22
	cp aug2, temp0
	brne SDm2
	lds temp0, fat21
	cp aug1, temp0
	brne SDm2
	
endwrite:						;normal exit
	clr temp0					;stop adc
	out ADCSR, temp0				
	
	ser sd						;delay and send stop token
	rcall SDtr
	ldi sd, $FD				
	rcall SDtr
	ser sd					
	rcall SDtr

SDm6:							;loop until sd card not busy
	ser sd		
	rcall SDtr
	cpi sd, $00
	breq SDm6

	rcall ledoff				;aug = end address + 512

	lds temp0, stcl1			;calc no. bytes written = end - stcl
	sub aug1, temp0				;(must be a multiple of 512)
	lds temp0, stcl2
	sbc aug2, temp0
	lds temp0, stcl3
	sbc aug3, temp0

	sts fileln3, aug3
	sts fileln2, aug2
	sts fileln1, aug1

	clc							;calc no. clusters
	ror aug3					;no. sectors = (fileln / 512)
	ror aug2					;no. clusters = (no. sectors - 1) div sec/clu + 1
	ror aug1 

	ldi temp0, 1
	sub aug1, temp0
	clr temp0
	sbc aug2, temp0
	sbc aug3, temp0

	lds XL, secclu

calc:	
	clc
	ror aug3
	ror aug2
	ror aug1

	clc
	ror XL
	cpi XL, 1
	brne calc

	ldi temp0, 1
	add aug1, temp0
	clr temp0
	adc aug2, temp0

	sts noClH, aug2
	sts noClL, aug1

	lds aug3, dirE3				;update dir
	lds aug2, dirE2				;load the directory entry sector
	lds aug1, dirE1

	rcall SDread

	lds XH,	dirEOSH				;X points to directory entry
	lds XL, dirEOSL

	ldi ZL, LOW(msgb<<1)		;write a unique file name 'DATAHHHH.LOG'
	ldi ZH, HIGH(msgb<<1)		;point Z to 'DATA'

filename:
	lpm temp0, Z+
	cpi temp0, $00
	breq filename1				;branch if $00
	st X+, temp0
	rjmp filename

filename1:
	lds temp0, dirNoH
	rcall hex
	st X+, temp0
	st X+, temp1
	lds temp0, dirNoL
	rcall hex
	st X+, temp0
	st X+, temp1

	ldi ZL, LOW(msgc<<1)		;point Z to 'LOG'
	ldi ZH, HIGH(msgc<<1)

filename2:
	lpm temp0, Z+
	cpi temp0, $00
	breq filename3				;branch if $00
	st X+, temp0
	rjmp filename2

filename3:
	adiw X, 15					;update the start cluster
	lds temp0, StClL
	st X+, temp0
	lds temp0, StClH
	st X+, temp0

	clr temp0					;update the file length
	st X+, temp0
	lds temp0, FileLn1
	st X+, temp0
	lds temp0, FileLn2
	st X+, temp0
	lds temp0, FileLn3
	st X+, temp0

	rcall SDwrite

	lds aug3, Fat1E3			;update Fat1 and Fat2
	lds aug2, Fat1E2
	lds aug1, Fat1E1
	
	rcall SDread

	lds XL, Fat1EOSL			;X points to first Fat entry 
	lds XH, Fat1EOSH

	lds YL, stClL				;Y = start cluster number
	lds YH, stClH

	lds ZL, noClL				;Z = no. written clusters
	lds ZH, noClH

fatud2:
	cpi ZH, $00					;if Z = 1 this is the last cluster
	brne fatud3
	cpi ZL, $01
	breq fatud6

fatud3:							;not last cluster
	adiw Y, 1					;increment the pointer to the next cluster
							
	st X+, YL					;store the cluster pointer
	st X+, YH							

	cpi	XL, LOW(blockend + 1)	;check X < buffer
	brne fatud5
	cpi XH, HIGH(blockend + 1)
	brne fatud5

	rcall SDwrite				;write Fat1

	push aug3
	push aug2
	push aug1
	
	lds temp0, secFatL
	lds temp1, secFatH
	clc
	rol temp0
	rol temp1

	add aug1, temp0
	adc aug2, temp1
	clr temp0
	adc aug3, temp0

	rcall SDwrite				;write Fat2

	pop aug1
	pop aug2
	pop aug3

	rcall incAug
	rcall SDread
	ldi XL, LOW(block)
	ldi XH, HIGH(block)
	
fatud5:
	sbiw Z, 1 					;dec Z
	rjmp fatud2

fatud6:
	ser temp0					;store $FFFF in the last cluster to mark eof
	st X+, temp0
	st X+, temp0

	rcall SDwrite				;write Fat1

	lds temp0, secFatL
	lds temp1, secFatH
	clc
	rol temp0
	rol temp1

	add aug1, temp0
	adc aug2, temp1
	clr temp0
	adc aug3, temp0

	rcall SDwrite				;write Fat2

	rjmp main					;all done


;*********************************************************
read:						
	lds aug1, dir1
	lds aug2, dir2
	lds aug3, dir3
	
	rcall SDread				;load the Directory

	ldi XL, LOW(block)
	ldi XH, HIGH(block)

	ld temp0, X
	cpi temp0, $00
	breq nofile					;unused or deleted file found at first directory entry	
	cpi temp0, $05				;jump to no file error
	breq nofile					
	cpi temp0, $E5
	brne rf1
	
nofile:							;display 'No File'
	rcall clearLCD			
	ldi ZL, LOW(msg10<<1)		;send 'No File' message
	ldi ZH, HIGH(msg10<<1)
	rcall sendstrZ
	ldi temp0, $40				;LCD to Line 2 Start
	rcall moveLCD
	ldi ZL, LOW(msg9<<1)		;send '---  ---  Exit' message
	ldi ZH, HIGH(msg9<<1)
	rcall sendstrZ	

	rcall clrkey

nofile1:						
	sbic PIND, PD2				;push button 3
	rjmp nofile1
	rjmp main

rf1:
	clr secctL					;directory sector counter, max = 32

rf2:
	rcall clearLCD			
	ldi ZL, LOW(msg11<<1)		;send 'Read: ' message
	ldi ZH, HIGH(msg11<<1)
	rcall sendstrZ
	
	movw Z, X					;store the file name in the display buffer
	ldi YL, LOW(display)
	ldi YH, HIGH(display)
	ldi temp1, 8

rf2a:
	ld temp0, Z+
	cpi temp0, $20
	breq rf2b
	st Y+, temp0			
	dec temp1
	brne rf2a

rf2b:
	clr temp0					;store a $00 marker at the end of the display buffer
	st Y, temp0

	rcall dispZ					;send display buffer to LCD

	ldi temp0, $40				;LCD to Line 2 Start
	rcall moveLCD
	ldi ZL, LOW(msg12<<1)		;send 'Next Start Exit' message
	ldi ZH, HIGH(msg12<<1)	
	rcall sendstrZ

	rcall clrkey

rf3:
	sbis PIND, PD4				;push button 1		
	rjmp next					;next
	sbis PIND, PD3				;push button 2
	rjmp start					;start
	sbis PIND, PD2				;push button 3
	rjmp rf8					;exit
	rjmp rf3

next:
	adiw X, $20					;inc the block offset to the next directory file entry
	cpi XL, LOW(blockend + 1)
	brne next1
	cpi XH, HIGH(blockend + 1)
	brne next1
	
	inc secctL					;Sector Counter, maximum = 32
	cpi secctL, 32
	brne next0					;Reset to the start of the Directory
	rjmp read

next0:
	rcall incAug				;increment the Directory sector
	
	rcall SDread				;read the next Directory sector

	ldi XL, LOW(block)			;set X to the beginning of the new sector
	ldi XH, HIGH(block)

next1:
	ld temp0, X
	cpi temp0, $00
	brne next1a					;unused or deleted file found at directory entry	
	rjmp read

next1a:
	cpi temp0, $05
	brne next1b					
	rjmp read

next1b:
	cpi temp0, $E5
	brne rf2
	rjmp read

start:
	rcall clearLCD
	ldi ZL, LOW(msg13<<1)		;send 'Reading ' message
	ldi ZH, HIGH(msg13<<1)
	rcall sendstrZ

	rcall dispZ					;send the file name to the LCD

	ldi temp0, $40				;LCD to Line 2 Start
	rcall moveLCD
	ldi ZL, LOW(msg9<<1)		;send '---  ---  Exit' message
	ldi ZH, HIGH(msg9<<1)	
	rcall sendstrZ				

	rcall clrkey
	
	adiw X, $1A					;read the start cluster
	ld temp0, X+
	sts stclL, temp0
	ld temp0, X+
	sts stclH, temp0
	ld temp0, X+
	sts fileln0, temp0			;read the file length (bytes)
	ld temp0, X+
	sts fileln1, temp0
	ld temp0, X+
	sts fileln2, temp0
	ld temp0, X+
	sts fileln3, temp0

	lds XL, stclL				;calculate the SD card sector
	lds XH, stclH
	
	sbiw X, 2					;cluster2 starts immediately after the Directory
	lds YL, SecClu
	mul XL, YL
	mov aug1, R0
	mov aug2, R1
	mul XH, YL
	clr aug3
	add aug2, R0
	adc aug3, R1
	clc
	rol aug1
	rol aug2
	rol aug3					;aug = (start cluster - 2)* sectors/cluster * 512 bytes per sector +
								;length of Directory (512 entries * 32 bytes = $4000)
	ldi temp0, $40			
	add aug1, temp0
	clr temp0
	adc aug2, temp0
	adc aug3, temp0

	lds temp0, dir1
	add aug1, temp0
	lds temp0, dir2
	adc aug2, temp0
	lds temp0, dir3
	adc aug3, temp0				;aug now points to first sector of the file

	clr bytect3					;reset the byte counter
	clr bytect2
	clr bytect1
	clr bytect0

	in temp0, UCSRB				;enable UART transmit, receive and receive interupt
	ori temp0, 1<<RXEN|1<<TXEN|1<<RXCIE	
	out UCSRB, temp0

	rcall ledon

rf4:
	rcall SDread				;read the file into the buffer

	ldi XL, LOW(block)
	ldi XH, HIGH(block)

rf5:
	lds temp0, fileln0			;compare byte counter with file length
	cpse temp0, bytect0
	rjmp rf6	
	lds temp0, fileln1
	cpse temp0, bytect1
	rjmp rf6
	lds temp0, fileln2
	cpse temp0, bytect2
	rjmp rf6
	lds temp0, fileln3
	cpse temp0, bytect3
	rjmp rf6

	rjmp rf8					;all bytes read so exit

rf6:
	ld chr, X+					;send the byte in chr to the UART
	rcall sendchrU

	sbis PIND, PD2				;look for push button 3 for end read
	rjmp rf8
	
	inc bytect0
	brne rf7
	inc bytect1
	brne rf7
	inc bytect2
	brne rf7
	inc bytect3
	breq rf8					;maximum file size read so exit

rf7:	
	cpi XL, LOW(blockend + 1)
	brne rf5
	cpi XH, HIGH(blockend + 1)
	brne rf5

	rcall incAug
	rjmp rf4

rf8:
	rcall ledoff				;all done graceful exit

	in temp0, UCSRB				;disable the UART
	andi temp0, ~(1<<RXEN|1<<TXEN|1<<RXCIE)	
	out UCSRB, temp0

	rjmp main


;*******************
;Erases all files on card
;clears FAT1, FAT2 and Directory to $00

erase:
	rcall clearLCD				;comfirm erase
	ldi ZL, LOW(msg14<<1)		;send 'Erase All Data?' message
	ldi ZH, HIGH(msg14<<1)
	rcall sendstrZ
	ldi temp0, $40				;LCD to Line 2 Start
	rcall moveLCD
	ldi ZL, LOW(msg15<<1)		;send 'Yes   No   Yes' message
	ldi ZH, HIGH(msg15<<1)	
	rcall sendstrZ

	rcall clrkey

erase0:
	sbis PIND, PD3				;push button 2		
	rjmp main			
	sbic PIND, PD2				;push button 3
	rjmp erase0		
	sbic PIND, PD4
	rjmp erase0

	lds aug1, FAT11				;load aug with the address of FAT1
	lds aug2, FAT12
	lds aug3, FAT13

	rcall SDread				;save the first four Fat cluster entries
	lds temp0, block
	sts FileLn0, temp0
	lds temp0, block + 1
	sts FileLn1, temp0
	lds temp0, block + 2
	sts FileLn2, temp0
	lds temp0, block + 3
	sts FileLn3, temp0

	rcall ledon

	ser crc						;send start sector for erase
	ldi cmd, 32	
	rcall SDcmd
	
	clr XL

er0:
	cpi sd, 0					;card read response, 0 = OK	
	breq erase1				
	ser sd
	rcall SDtr
	dec XL
	brne er0

	sbr statusflag, 1<<EraseError	;erase error
	rjmp error

erase1:
	lds aug3, dir3				;calculate end address = Directory + 31 sectors * 512 bytes/sector ($3E00)
	lds aug2, dir2
	lds aug1, dir1
	
	ldi temp0, $3E
	add aug1, temp0
	clr temp0
	adc aug2, temp0
	adc aug3, temp0

	ser crc						;send end sector for erase
	ldi cmd, 33	
	rcall SDcmd

	clr XL	
				
er1:
	cpi sd, 0					;card read response, 0 = OK	
	breq erase2				
	ser sd
	rcall SDtr
	dec XL
	brne er1

	sbr statusflag, 1<<EraseError	;erase error
	rjmp error

erase2:
	rcall clrcmd				;block erase command
	ldi cmd, 38	
	rcall SDcmd

	clr XL

er2:
	cpi sd, $00					;card read response, 0 = OK	
	breq erase3					;jump to read				
	ser sd
	rcall SDtr
	dec XL
	brne er2

	sbr statusflag, 1<<EraseError	;erase error
	rjmp error

erase3:
	ser sd						;loop until sd card not busy
	rcall SDtr
	cpi sd, $00
	breq erase3

	rcall ledoff

	lds aug1, FAT11				;load aug with the address of Fat1
	lds aug2, FAT12
	lds aug3, FAT13

	rcall SDread				

	lds temp0, FileLn0			;restore the first four Fat cluster entries
	sts block, temp0
	lds temp0, FileLn1
	sts block + 1, temp0
	lds temp0, FileLn2
	sts block + 2, temp0
	lds temp0, FileLn3
	sts block + 3, temp0

	rcall SDwrite				;update Fat1

	lds aug1, FAT21				;load aug with the address of Fat2
	lds aug2, FAT22
	lds aug3, FAT23

	rcall SDwrite				;update Fat2
	
	rjmp main
	

;**********
;report and process an unrecoverable error 

error:
	clr temp0					;stop adc
	out ADCSR, temp0

	in temp0, UCSRB				;disable the UART
	andi temp0, ~(1<<RXEN|1<<TXEN|1<<RXCIE)
	out UCSRB, temp0

	rcall clearLCD				;send 'Error: ' message
	ldi ZL, LOW(msg4<<1)	
	ldi ZH, HIGH(msg4<<1)
	rcall sendstrZ
	
	sbrc statusflag, ReadError
	rjmp err0
	sbrc statusflag, WriteError
	rjmp err1
	sbrc statusflag, OverRun
	rjmp err2
	sbrc statusflag, EraseError
	rjmp err3
	sbrc statusflag, noFAT
	rjmp err4
	sbrc statusflag, DirFull
	rjmp err5
	sbrc statusflag, FatFull
	rjmp err6

	ldi ZL, LOW(msg25<<1)		;send 'SD Full' message
	ldi ZH, HIGH(msg25<<1)
	rcall sendstrZ
	rjmp removeSD

err0:
	ldi ZL, LOW(msg18<<1)		;send 'SD Read' message
	ldi ZH, HIGH(msg18<<1)
	rcall sendstrZ
	rjmp removeSD

err1:
	ldi ZL, LOW(msg19<<1)		;send 'SD Write' message
	ldi ZH, HIGH(msg19<<1)
	rcall sendstrZ
	rjmp removeSD

err2:
	ldi ZL, LOW(msg20<<1)		;send 'Buffer' message
	ldi ZH, HIGH(msg20<<1)
	rcall sendstrZ
	rjmp removeSD

err3:
	ldi ZL, LOW(msg21<<1)		;send 'SD Erase' message
	ldi ZH, HIGH(msg21<<1)
	rcall sendstrZ
	rjmp removeSD

err4:
	ldi ZL, LOW(msg22<<1)		;send 'SD Format' message
	ldi ZH, HIGH(msg22<<1)
	rcall sendstrZ
	rjmp removeSD

err5:
	ldi ZL, LOW(msg23<<1)		;send 'Dir Full' message
	ldi ZH, HIGH(msg23<<1)
	rcall sendstrZ
	rjmp removeSD

err6:
	ldi ZL, LOW(msg24<<1)		;send 'Fat Full' message
	ldi ZH, HIGH(msg24<<1)
	rcall sendstrZ 

removeSD:
	sbi PORTB, PB4				;disable SD Card (/CS)

	rcall ledoff

	ldi temp0, $40				;LCD to Line 2 Start
	rcall moveLCD
	ldi ZL, LOW(msg5<<1)		;send 'Remove Card' message
	ldi ZH, HIGH(msg5<<1)
	rcall sendstrZ	

err7:	
	sbis PINB, PB2				;wait for card removal
	rjmp err7

	rjmp reset


;*******************************************************************************
;Subroutines
   
;******************************************
;Initialize Hardware

initHW:

;RTC
	clr temp0 							;disable timer interupts
	out	TIMSK, temp0									
									
	ldi temp0, 1<< AS2
	out ASSR, temp0						;set AS2 for asyncronous clock
 	
	clr temp0							;clear TCNT2 and OCR2
	out TCNT2, temp0
	out OCR2, temp0

	ldi temp0, 1<<CS22|1<<CS20			;set prescale to 128 
	out TCCR2, temp0													

update:									;wait for TCN2UB, OCR2UB and TCR2UB
	in temp0, ASSR
	andi temp0, 1<<TCN2UB|1<<OCR2UB|1<<TCR2UB
	brne update

	ldi temp0, 1<<OCF2|1<<TOV2			;clear TC2 interupt flags
	out TIFR, temp0						;cleared by writing logical 1 to flags
						
	sei									;enable global interupts


;LCD, Push Buttons and LED
									
	ldi temp0, 1<<DDC0|1<<DDC1|1<<DDC2|1<<DDC3|1<<DDC5	;DDC0-3,5 output for 							; 	
	out DDRC, temp0						;LCD D4-7 and LED, DDC4 input for PB4
	
	ldi temp0, 1<<PORTC4				;pull up on PORTC4 for PB4, PORTC0-3,5 low
	out PORTC, temp0									

	ldi temp0, 1<<DDD5|1<<DDD6|1<<DDD7	;DDD5-7 output for LCD R/W, E, RS, 				
	out DDRD, temp0						;DDD2-4 input for PB1-3
	
	ldi temp0, 1<<PD2|1<<PD3|1<<PD4		;pull up on PORTD2-4 for PB1-3, 
	out PORTD, temp0					;PORTD 5-7 ouput low

	clr XL								;delay 30ms for LCD
	clr XH

wait1:
	dec XL
	brne wait1
	dec XH
	brne wait1

	ldi ZL, LOW(LCDinit<<1)				;send LCD init sequence
	ldi ZH, HIGH(LCDinit<<1)
	rcall sendcmdZ
	rcall clearLCD


;UART

	ldi temp0, baudrate					;set up baud rate
	out UBRR, temp0

;A2D
	ldi temp0, 1<<REFS0					;set ADC0 input, right adjusted, AVCC 5V external reference
	out ADMUX, temp0


;SPI
	ldi temp0, 1<<PB3|1<<PB2			;pull up on WP and CD inputs
	out PORTB, temp0
	
	ldi temp0, 1<<DDB7|1<<DDB5|1<<DDB4	;set SCK, MOSI, /CS as outputs, MISO, WP and CD as inputs
	out DDRB, temp0

	ldi temp0, 1<<SPE|1<<MSTR|1<<SPR1|1<<SPR0	;enable SPI as master, clock = 31kHz
	out SPCR, temp0
	
	sbi PORTB, PB4						;disable SD Card (/CS)
	clr statusflag						;clear the statusflag
	ret

	
;******************************************	
;Increment Aug

incAug:						;inc Aug by 512 (1 block)
	inc aug1
	inc aug1
	brne incAug1
	inc aug2
	brne incAug1
	inc aug3	
	
incAug1:
	ret


;*******************
;Key Press

keypress:
	in temp2, PIND
	andi temp2, $1C			;PD2/3/4 mask
	cpi temp2,$1C
	brne clrkey
	sbic PINC, PC4			;wait for a key
	rjmp keypress


;*******************
;Key Debounce

clrkey:						;wait for no keys pressed
	clr temp3

clrkey1:
	in temp2, PIND
	andi temp2, $1C			;PD2/3/4 mask
	cpi temp2, $1C
	brne clrkey				;wait for $FF no keys pressed

	sbis PINC, PC4
	rjmp clrkey

	inc temp3
	brne clrkey1
	ret
	

;*******************
;send chr to UART

sendchrU:	
	sbis UCSRA,UDRE			;wait until UART not busy
	rjmp sendchrU
	out UDR, chr			;send char
	ret


;******************************************
;LCD Display

;*******************
;Clears LCD and resets cursor to $00
;
;input: 	-
;uses:		temp0
;			temp2
;returns:	-
;calls: 	sendbyte
;			wait43
;stack:		-

clearLCD:					;clears LCD and reset cursor
	ldi temp0, $01
	rjmp moveLCD1


;*******************
;Move LCD cursor to temp0
;
;input: 	temp0
;uses:		temp0
;			temp2
;returns:	-
;calls: 	sendbyte
;			wait43
;stack:		2

moveLCD:
	ori temp0, $80

moveLCD1:
	rcall sendbyte

	ldi temp2, 40			;wait for 1.50 ms

wait150:
	rcall wait43
	dec temp2
	brne wait150

	ret


;*******************
;Send asciiZ str in display to LCD at current cursor
;Send cmd terminated by $00 in display buffer to LCD at current cursor
;
;input: 	display
;uses:		temp0
;			X
;returns:	-
;calls: 	sendbyte
;			resetRS
;stack		3

dispZ:
	rcall setRS				;sram at Display

dispcmdZ:	
	ldi ZH, HIGH(display)
	ldi ZL, LOW(display)

dispZ1:
	ld temp0, Z+
	cpi temp0, $00
	breq dispZ2
	rcall sendbyte
	rjmp dispZ1

dispZ2:
	rcall resetRS
	ret


;*******************
;Send asciiZ str in flash at Z to LCD at current cursor
;Send cmd str terminated with $00 in flash at Z to LCD
;
;input: 	Z
;uses:		temp0
;			Z
;returns:	-
;calls: 	setRS
;			sendbyte
;			resetRS
;stack		1

sendstrZ:					;Z points to $00 terminated str in flash
	rcall setRS		

sendcmdZ:
	lpm temp0, Z+
	cpi temp0, $00
	breq send2
	rcall sendbyte
	rjmp sendcmdZ

send2:	
	rcall resetRS
	ret


;*******************
;Send ascii hex of temp0 to LCD at current cursor
;
;input: 	temp0
;uses:		-
;returns:	-
;calls: 	hex
;			sendchrL
;stack		-

hexLCD:						
	rcall hex				;returns ascii in temp0, temp1
	rcall sendchrL
	mov temp0, temp1
	rcall sendchrL
	ret


;*******************
;converts the byte in temp0 to two ascii hexidecimal chrs,
;high byte chr in temp0, low byte chr in temp1

;input: 	temp0
;uses:		temp0
;			temp1
;			temp3
;returns:	temp0
;			temp1
;calls 		-
;stack		-
		
hex:
	mov temp1, temp0
	swap temp0				;get high nibble
	andi temp0, $0F			;mask the high nibble
	cpi temp0, 10
	brlo hex1
	ldi temp3, $07
	add temp0, temp3

hex1:
	ldi temp3, $30
	add temp0, temp3		;temp0 = high byte ascii
	
	andi temp1, $0F			;mask the lower nibble
	cpi temp1, 10
	brlo hex2
	ldi temp3, $07		
	add temp1, temp3

hex2:
	ldi temp3, $30
	add temp1, temp3

	ret 


;*******************
;Send character in temp0 to LCD at current cursor
;
;input: 	temp0
;uses:		-
;returns:	-
;calls: 	setRS
;			sendbyte
;			resetRS
;stack		1

sendchrL:
	rcall setRS	
	rcall sendbyte
	rcall resetRS
	ret


;*******************
;Send byte in temp0 to LCD
;
;input: 	temp0
;uses:		temp3
;returns:	-
;calls: 	sendnibble
;stack		-

sendbyte:
	mov temp3, temp0
	swap temp3
	rcall sendnibble
	mov temp3, temp0
	rcall sendnibble

wait43:
	ldi temp3, 85

wait43a:
	dec temp3
	brne wait43a
	ret


;*******************
;Send lower nibble of temp3 to LCD
;
;input: 	temp3
;modifies:	temp2
;			temp3
;returns:	-
;calls: 	-
;stack		-

sendnibble:					;send low nibble in temp3 
	andi temp3, $0f	
	in temp2, PORTC
	andi temp2, $f0
	or temp3, temp2
	out PORTC, temp3
	in temp3, PORTD
	ori temp3, 1<<PD6
	out PORTD, temp3
	andi temp3, ~(1<<PD6)
	out PORTD, temp3
	ret


;*******************
;Set RS
;
;input: 	-
;modifies:	temp3
;returns:	-
;calls: 	-
;stack		-

setRS:
	in temp3, PORTD
	ori temp3, 1<<PD7	
	out PORTD, temp3
	ret


;*******************
;Reset RS
;
;input: 	-
;modifies:	temp3
;returns:	-
;calls: 	-
;stack		-

resetRS:
	in temp3, PORTD
	andi temp3, ~(1<<PD7)
	out PORTD, temp3
	ret


;******************************************
;SD Card Routines


;*******************
;Initialise SD Card
;Card is inserted, not write protected and initialised
;
;input: 	-
;uses:		temp0
;			Z
;			sd
;			cmd
;			aug1
;			aug2
;			aug3
;			crc

;returns:	-
;calls: 	moveLCD
;			sendstrZ
;			clrLCD
;			SDtr
;			clrcmd
;			SDcmd
;			hexLCD
;			ledon
;stack		-

initSD:
	sbis PINB, PB2				;wait for card insert
	rjmp sd2
	rcall clearLCD
	ldi ZL, LOW(msg1<<1)		;send 'Insert Card' message
	ldi ZH, HIGH(msg1<<1)
	rcall sendstrZ	

sd1:
	sbic PINB, PB2				;wait here for card	
	rjmp sd1
	rcall clearLCD

sd2:
	sbis PINB, PB3				;wait for write enable
	rjmp sd4
	rcall clearLCD
	ldi ZL, LOW(msg2<<1)		;send 'Card Locked' message
	ldi ZH, HIGH(msg2<<1)
	rcall sendstrZ

sd3:
	rjmp removeSD

sd4:							;an unlocked card inserted
	rcall ledon

	ldi temp0, 10

sd5:
	ser sd						;send 80 spi clock pulses
	rcall SDtr
	dec temp0
	brne sd5

	cbi PORTB, PB4				;enable SD (/CS)

	rcall clrcmd				;Cmd0 reset to idle state
	ldi crc, $95
	rcall SDcmd

	cpi sd, 1				
	breq sd6					;SD Card reset, jump to initialise

	rcall clearLCD
	ldi ZL, LOW(msg4<<1)		;send 'Error ' message
	ldi ZH, HIGH(msg4<<1)
	rcall sendstrZ

	ldi ZL, LOW(msg16<<1)		;send 'SD R/S ' message
	ldi ZH, HIGH(msg16<<1)
	rcall sendstrZ

	mov temp0, sd				;send hex error code in sd (from R1)
	rcall hexLCD
	rjmp removeSD				;wait for card removal

sd6:
	rcall clrcmd
	ldi cmd, 1					;Cmd1 initialise card internally

sd7:
	rcall SDcmd
	cpi sd, 0
	brne sd7					;repeat Cmd1 until not busy					
	
	in temp0, SPCR				;enable SPI clock at 2 MHz
	andi temp0, ~(1<<SPR1|1<<SPR0)		
	out SPCR, temp0
	in temp0, SPSR
	ori temp0, 1<<SPI2X
	out SPSR, temp0
	
	rcall ledoff		
	ret


;*******************
;SD card transmit and receive to register sd
;
;input: 	sd
;modifies:	sd
;returns:	sd
;calls: 	-
;stack		0

SDtr:							;SD Card transmit and receive from/to register sd
	out SPDR, sd				;transmit sd on the SPI
SDtr1:
	sbis SPSR, SPIF				;wait for end of SPI transmission
	rjmp SDtr1
	in sd, SPDR					;read the received SPI byte
	ret


;*******************
;SD card cmd transmit
;
;input: 	sd
;			cmd
;			aug3
;			aug2
;			aug1
;			crc
;uses:		sd
;returns:	sd
;calls: 	SDtr
;stack		-

SDcmd:							;SD card command
	ser sd
	rcall SDtr
	mov sd, cmd
	andi sd, $7F
	ori sd, $40
	rcall SDtr
	mov sd, aug3
	rcall SDtr
	mov sd, aug2	
	rcall SDtr
	mov sd, aug1	
	rcall SDtr
	clr sd	
	rcall SDtr
	mov sd, crc
	rcall SDtr
	ser sd
	rcall SDtr				
	ser sd
	rcall SDtr
	ret


;*******************
;Read SD Card Sector at address aug3-1 to block
;
;input: 	aug3
;			aug2
;			aug1
;uses:		cmd
;			crc
;			sd
;			X
;returns:	block
;			statusflag, ReadError
;calls: 	SDtr
;stack		-

SDread:
	rcall ledon
								;SD address in aug0 to 3
	ldi cmd, 17					;Cmd17 read card
	ser crc						;set up command registers
	rcall SDcmd	

	clr XL

SDr0:
	cpi sd, $00					;card read response, 0 = OK	
	breq SDr1					;jump to read				
	ser sd
	rcall SDtr
	dec XL
	brne SDr0

	sbr statusflag, 1<<ReadError	;read error
	rjmp error

SDr1:
	ser sd						;wait for start token
	rcall SDtr
	cpi sd, $FE					;start token
	brne SDr1

	ldi XH, HIGH(block)			;set up sram pointer
	ldi XL, LOW(block)

SDr2:
	ser sd						;read 512 data bytes
	rcall SDtr
	st X+, sd
	cpi	XL, LOW(blockend + 1)
	brne SDr2
	cpi XH, HIGH(blockend + 1)
	brne SDr2

	ser sd						;read the crc
	rcall SDtr				
	ser sd
	rcall SDtr

	rcall ledoff
	ret


;*******************
;Write SD Card Sector at address aug0-3 from block
;
;input: 	aug3
;			aug2
;			aug1
;			aug0
;			block
;uses:		cmd
;			crc
;			sd
;			X
;returns:	statusflag, WriteError1
;			statusflag, WriteError2
;calls: 	SDtr
;stack		-

SDwrite:
	rcall ledon
								;SD address in aug0 to 3
	ldi cmd, 24					;Cmd24 write card
	ser crc						;set up command registers
	rcall SDcmd

	clr XL

SDw0:
	cpi sd, 0					;card read response, 0 = OK	
	breq SDw1					;jump to write				
	ser sd
	rcall SDtr
	dec XL
	brne SDw0
			
	sbr statusflag, 1<<WriteError	;write error
	rjmp error

SDw1:
	ser sd						;send start token
	rcall SDtr
	ldi sd, $FE
	rcall SDtr

	ldi XH, HIGH(block)			;set up sram pointer
	ldi XL, LOW(block)

SDw2:
	ld sd, X+					;write to the card
	rcall SDtr

	cpi	XL, LOW(blockend + 1)
	brne SDw2
	cpi XH, HIGH(blockend + 1)
	brne SDw2

	ser sd						;write 2 dummy bytes for crc
	rcall SDtr
	ser sd
	rcall SDtr

	ser sd						;get card response
	rcall SDtr
	andi sd, $1F
	cpi sd, $05
	breq SDw3

	sbr statusflag, 1<<WriteError	;write error
	rjmp error

SDw3:
	ser sd						;loop until not busy (write complete)
	rcall SDtr
	cpi sd, $00
	breq SDw3

	rcall ledoff
	ret


;*******************
;Clear the SD card command registers
;
;input: 	-
;modifies:	cmd
;			aug3
;			aug2
;			aug1
;			crc
;returns:	-
;calls: 	-
;stack		0

clrcmd:							;clear the command registers
	clr cmd
	clr aug3
	clr aug2
	clr aug1
	ser crc
	ret


;******************************************
;red LED control routines
;
;input: 	-
;modifies:	-
;returns:	-	
;calls 		-
;stack		0

ledon:
	sbi PORTC, PC5			;red led on
	ret

ledoff:
	cbi PORTC, PC5			;red led off
	ret

ledtoggle:
	sbis PORTC, PC5
	rjmp ledon 
	rjmp ledoff


;*******************************************************************************
;Fat OS subroutines


;FatInit						;confirm FAT16
								;assumes: 	2 FATs
								;			512 bytes/Sector
								;			512 * 32 byte entries per directory
								;			sequential continuous files

								;gets:	sectors per cluster, SecClu
								;	 	reserve sectors,	 ResSec
								;		sectors per fat,	 SecFAT
								;		Partition entry
								;	 	FAT1 entry
								;		FAT2 entry
								;		Directory entry

initFAT:
	rcall clrcmd				;reset aug address to 0

	rcall SDread				;read sector 0

	rcall fat16					;check for Master Boot Record (MBR)

	sbrs statusflag, noFAT		;skip if first sector is not MBR 
	rjmp fos1					
									
	ldi XH, HIGH(block + $1C6)	;first sector is Partition Boot Record
	ldi XL, LOW(block + $1C6)	;read Primary Partition Boot Record	
	ld aug1, X+					;set up sram pointer to
	ld aug2, X+					;partition1 sector address * 512
	ld aug3, X
	clc
	rol aug1
	rol aug2
	rol aug3

	rcall SDread				;read the partition boot record

	rcall fat16
	
	sbrc statusflag, NoFAT
	rjmp error

fos1:							;we have Fat16 format and partition1 
	sts Part3, aug3				;save the partition address
	sts Part2, aug2
	sts Part1, aug1

	ldi XH, HIGH(block + $0D)	;save sectors per cluster
	ldi XL, LOW(block + $0D)	;must be 4, 8, 16, 32 or 64 for Fat16	
	ld temp0, X+
	sts SecClu, temp0			

	ld temp0, X+				;save reserve sectors
	sts ResSecL, temp0
	ld temp0, X+
	sts ResSecH, temp0

	ldi XH, HIGH(block + $16)	;save sectors per Fat
	ldi XL, LOW(block + $16)
	ld temp0, X+
	sts SecFatL, temp0
	ld temp0, X+
	sts SecFatH, temp0

	lds aug1, ResSecL			;calculate and save Fat1
	lds aug2, ResSecH			;multiply Res * 512
	clr aug3
	clc
	rol aug1
	rol	aug2
	rol aug3

	lds temp0, Part1			;add to Partition	
	add aug1, temp0
	lds temp0, Part2
	adc aug2, temp0
	lds temp0, Part3
	adc aug3, temp0

	sts Fat11, aug1
	sts Fat12, aug2
	sts Fat13, aug3

	lds temp0, SecFatL			;calculate and save FAT2 = FAT1 + Sec/Fat * 512
	lds temp1, SecFatH
	clr XL
	clc
	rol temp0
	rol temp1
	rol XL

	add aug1, temp0
	adc aug2, temp1
	adc aug3, XL

	sts Fat21, aug1
	sts Fat22, aug2
	sts Fat23, aug3

	add aug1, temp0				;calculate and save Directory = FAT2 + Sec/Fat * 512
	adc aug2, temp1
	adc aug3, XL

	sts dir1, aug1
	sts dir2, aug2
	sts dir3, aug3

	ret


;*******************		
;looks for 'FAT16' in block at offset $36

;input: 	block
;modifies:	X
;			Z
;			temp0
;			temp1
;output:	statusflag, notFat
;calls 		-
;stack		0

fat16:							;check for 'FAT16' at block offset $36
	cbr statusflag, 1<<noFAT

	ldi ZL, LOW(msga<<1)		;point Z to 'FAT16'
	ldi ZH, HIGH(msga<<1)
	
	ldi XL, LOW(block + $36)	;set up sram pointer to block + $36, 'FAT16'	
	ldi XH, HIGH(block + $36)

fat16a:
	lpm temp0, Z+
	cpi temp0, $00
	breq fat16b					;branch if 0 = FAT16 found
	ld temp1, X+
	cp temp0, temp1
	breq fat16a

	sbr statusflag, 1<<noFAT	;no FAT found return

fat16b:
	ret


;*******************************************************************************
;Flash Constants

msg1:	.DB "Insert Card",$00
msg2:	.DB "Card Locked",$00

msg4:	.DB	"Error: ",$00
msg5:	.DB	"Remove Card",$00
msg6:	.DB "Command",$00     
msg7:	.DB "Read Write Erase",$00,$00
msg8:	.DB "Writing ",$00, $00
msg9:	.DB "---  ---   Exit",$00
msg10:	.DB "No File",$00
msg11:	.DB "Read: ",$00,$00
msg12:	.DB "Next Start Exit",$00
msg13:	.DB "Reading ",$00,$00
msg14:	.DB "Erase All Data?",$00
msg15:	.DB "Yes   No   Yes",$00,$00
msg16:	.DB "SD R/S ",$00
msg17:	.DB "---  ---  Reset",$00

msg18:	.DB "SD Read",$00
msg19:	.DB "SD Write",$00,$00
msg20:	.DB	"Buffer",$00,$00
msg21:	.DB "SD Erase",$00,$00
msg22:	.DB "SD Format",$00 
msg23:	.DB "Dir Full",$00,$00
msg24:	.DB "Fat Full",$00,$00
msg25:	.DB "SD Full",$00

msg26:	.DB "Sector: ",$00,$00 
msg27:	.DB "Next Read Reset",$00

msga:	.DB "FAT16",$00
msgb:	.DB "DATA",$00,$00
msgc:	.DB "LOG",$00

LCDinit: .DB $02, $28, $0C, $00


;*******************************************************************************
;debug routine to dump SD card sectors to RS232

debug:						;main menu
	clr keyflag

db5:
	sbrs keyflag, $00
	rjmp db4

	ldi temp0, $08
	rcall moveLCD

	mov temp0, aug3
	rcall hexLCD
	mov temp0, aug2
	rcall hexLCD
	mov temp0, aug1
	rcall hexLCD
	clr temp0
	rcall hexLCD

	rjmp db0

db4:
	rcall clearLCD
	ldi ZL, LOW(msg26<<1)	;send 'Sector: ' message
	ldi ZH, HIGH(msg26<<1)
	rcall sendstrZ

	mov temp0, aug3
	rcall hexLCD
	mov temp0, aug2
	rcall hexLCD
	mov temp0, aug1
	rcall hexLCD
	clr temp0
	rcall hexLCD

	ldi temp0, $40			;LCD to Line 2 Start
	rcall moveLCD
	ldi ZL, LOW(msg27<<1)	;send 'Next Read Reset' message
	ldi ZH, HIGH(msg27<<1)
	rcall sendstrZ	

db0:						;wait for no keys pressed
	ldi temp0, $02
	clr temp1
	clr temp2
	clr temp3

db1:
	sbis PIND, PD2
	rjmp db0
	sbis PIND, PD3
	rjmp db0
	sbis PINC, PC4
	rjmp db0
	sbis PIND, PD4
	rjmp db2

	inc temp3
	brne db1
	clr keyflag
	rjmp db3
	
db2:

	inc temp1
	brne db1
	sbrc keyflag, $00
	rjmp db3
	inc temp2
	brne db1
	dec temp0
	brne db1

	com keyflag
	
db3:
	sbis PIND, PD4			;push button 1		
	rjmp nextdb				

	sbis PIND, PD3			;push button 2
	rjmp readdb

	sbis PIND, PD2			;push button 3
	rjmp cleardb

	sbis PINC, PC4
	rjmp reset

	rjmp db3

;**********		
nextdb:
	rcall incaug
	rjmp db5


;**********		
cleardb:
	rcall clrcmd
	rjmp debug


;**********
readdb:
	rcall clearLCD
	ldi ZL, LOW(msg13<<1)	;send 'Reading ' message
	ldi ZH, HIGH(msg13<<1)
	rcall sendstrZ	

	mov temp0, aug3
	rcall hexLCD
	mov temp0, aug2
	rcall hexLCD
	mov temp0, aug1
	rcall hexLCD
	clr temp0
	rcall hexLCD
						
	rcall SDread

	in temp0, UCSRB				;enable UART transmit, receive and receive interupt
	ori temp0, 1<<RXEN|1<<TXEN|1<<RXCIE	
	out UCSRB, temp0

	ldi XL, LOW(block)
	ldi XH, HIGH(block)

	clr temp2					;16 chr/line counter

rdb1:
	ld temp0, X+	
	mov temp1, temp0
	cpi temp1, 32
	brlo rdb2	
	cpi temp1, 127
	brsh rdb2
	rjmp rdb3

rdb2:
	ldi temp1, 32

rdb3:	
	mov chr, temp1
	rcall sendchrU				;send asc
	
	rcall hex

	mov chr, temp0				;send hex
	rcall sendchrU
	mov chr, temp1
	rcall sendchrU

	ldi temp0, $20				;space column seperator
	mov chr, temp0
	rcall sendchrU

	inc temp2					;check for eol
	cpi temp2, 16
	brne rdb4

	ldi temp0, $0D				;send LF CR
	mov chr, temp0
	rcall sendchrU
	ldi temp0, $0A
	mov chr, temp0
	rcall sendchrU 
	clr temp2
	
rdb4:
	cpi XL, LOW(blockend + 1)	;check for end of sector
	brne rdb1
	cpi XH, HIGH(blockend + 1)
	brne rdb1

	in temp0, UCSRB				;disable the UART
	andi temp0, ~(1<<RXEN|1<<TXEN|1<<RXCIE)	
	out UCSRB, temp0

	rjmp debug