; ******************************************************************
; * Include routine for akkuload, calculation and display routines *
; * (C)2005 by Gerh.Schmidt, info@avr-asm-tutorial.net             *
; ******************************************************************
;
; ************** EEPROM Init, Read and Write ******************
;
; Initialises the Eeprom storage of akkus
;
EpInit:
	clr ZH ; Z is Eeprom read pointer
	clr ZL
	clr R0 ; R0 is counter
EpInit1:
	sbic EECR,EEWE ; wait for write end
	rjmp EpInit1 ; wait because write bit is set
	inc R0 ; next akku
	ldi rmp,cEepMax+1 ; check if beyond last id
	cp R0,rmp ; compare with max number
	brcc EpInit4
	out EEARL,ZL ; set EEPROM read adress
	out EEARH,ZH
	sbi EECR,EERE ; set read enable
EpInit2:
	sbic EECR,EERE ; wait for read ok
	rjmp EpInit2 ; wait on
	in rmp,EEDR ; read akku number
	cp rmp,R0 ; compare with akku number
	brne EpInit4 ; not correct, skip further read
	adiw ZL,1 ; next byte
	out EEARL,ZL ; set EEPROM read adress
	out EEARH,ZH
	sbi EECR,EERE ; set read enable
EpInit3:
	sbic EECR,EERE ; wait for read ok
	rjmp EpInit3 ; wait on
	in rmp,EEDR ; read id byte
	cpi rmp,0xA0 ; must be between A0 and A3
	brcs EpInit4 ; smaller than A0, skip further read
	cpi rmp,0xA4
	brcc EpInit4 ; greater than A3, skip further read
	adiw ZL,15 ; next EEPROM location
	rjmp EpInit1
EpInit4:
	dec R0 ; store number of akkus
	sts sEaNm,R0
	ret
;
; Read the Eeprom content of akku Id in rmp to the buffer
;
EpRead:
	dec rmp ; starts with id=1
	mov ZL,rmp ; copy to Z
	clr ZH
	lsl ZL ; *2
	rol ZH
	lsl ZL ; *4
	rol ZH
	lsl ZL ; *8
	rol ZH
	lsl ZL ; *16
	rol ZH
	ldi XH,HIGH(sEepB) ; X is buffer adress counter
	ldi XL,LOW(sEepB)
EpRead1:
	sbic EECR,EEWE ; wait for end of write, if necessary
	rjmp EpRead1
	out EEARH,ZH ; output read adress
	out EEARL,ZL
	sbi EECR,EERE ; set read enable
EpRead2:
	sbic EECR,EERE ; wait for end of read
	rjmp EpRead2
	in rmp,EEDR ; read byte
	st X+,rmp ; store in buffer
	adiw ZL,1 ; next byte in EEPROM
	mov rmp,ZL ; test for end
	andi rmp,0x0F ; check last four bits clear
	brne EpRead1 ; read another byte
	ret
;
; Write the buffer content to the EEPROM
;
EpWrite:
	ldi XH,HIGH(sEepB) ; X is buffer adress counter
	ldi XL,LOW(sEepB)
	ld rmp,X ; read id number
	dec rmp ; starts with id=1
	mov ZL,rmp ; copy to Z
	clr ZH
	lsl ZL ; *2
	rol ZH
	lsl ZL ; *4
	rol ZH
	lsl ZL ; *8
	rol ZH
	lsl ZL ; *16
	rol ZH
EpWrite1:
	sbic EECR,EEWE ; wait for end of write, if necessary
	rjmp EpWrite1
	out EEARH,ZH ; output write adress
	out EEARL,ZL
	ld rmp,X+ ; read byte from buffer
	out EEDR,rmp ; write to data register
	cli ; stop interrupts
	sbi EECR,EEMWE ; set write mode enable
	sbi EECR,EEWE ; set write enable
	sei ; enable interrupts
	adiw ZL,1 ; next byte in EEPROM
	mov rmp,ZL ; test for end
	andi rmp,0x0F ; check last four bits clear
	brne EpWrite1 ; write another byte
	ret
;
; Check Akku Id and add current to stored akku in Eeprom
; R0 is channel, preserves R0 and R1!
;
EpStore:
	rcall GetAkkuId ; read id of the current channel
	tst rmp ; id=0?
	breq EpStore4 ; yes, return
	lds ZL,sEANm ; read the number of id's in EEPROM
	sec ; set carry
	cpc rmp,ZL ; compare with (number of id's+1)
	brcc EpStore4 ; greater than number of id's
	rcall EpRead ; read the EEPROM id to buffer
	ldi ZH,HIGH(sAdcC) ; point to measured capacity
	ldi ZL,LOW(sAdcC)
	add ZL,R0 ; add channel number
	add ZL,R0
	ld XL,Z+ ; read loaded capacity to X
	ld XH,Z
	lds ZL,sENRL ; read rest capacity from buffer to Z
	lds ZH,sENRM
	add ZL,XL ; add loaded capacity
	adc ZH,XH
	lds XL,sENCL ; read nominal capacity to X
	lds XH,sENCM
	clr rmp ; clear counter
EpStore1:
	cp ZL,XL ; compare accumulated capacity in Z with nominal in X
	cpc ZH,XH
	brcs EpStore2 ; number of loads ready
	sub ZL,XL ; subtract nominal capacity
	sbc ZH,XH
	inc rmp
	rjmp EpStore1
EpStore2: ; number of loads is in rmp
	sts sENRL,ZL ; store rest capacity in buffer
	sts sENRM,ZH
	tst rmp ; a full load?
	breq EpStore3
	lds ZL,sENLL ; read number of loads
	add ZL,rmp
	sts sENLL,ZL ; store number of loads
	brcc EpStore3 ; no carry
	lds ZL,sENLM ; inc MSB
	inc ZL
	sts sENLM,ZL
EpStore3: ; buffer is ready, write
	rcall EpWrite ; write the buffer to EEPROM
EpStore4:
	ret
;
; *** Convert measured voltages to decimal voltages and currents ***
;
; Convert ADC value of 32 cycles to binary voltage
; sd32e in R3:R2, result in R3:R2, uses R6:R5:R4
; Reference voltage is 5V, U[mV] = s32 * 39 / 256
;
Adc2mV:
	mov R4,R2 ; copy s32 to R6:R5:R4
	mov R5,R3
	clr R6
	lsl R4 ; * 2
	rol R5
	rol R6
	lsl R4 ; * 4
	rol R5
	rol R6
	lsl R4 ; * 8
	rol R5
	rol R6
	mov R0,R4 ; copy to rmp:R1:R0
	mov R1,R5
	mov rmp,R6
	lsl R4 ; * 16
	rol R5
	rol R6
	lsl R4 ; * 32
	rol R5
	rol R6
	add R4,R0 ; * 40
	adc R5,R1
	adc R6,rmp
	clr rmp
	sub R4,R2 ; * 39
	sbc R5,R3
	sbc R6,rmp
	mov R2,R5 ; / 256
	mov R3,R6
	ldi rmp,0x80 ; round
	add rmp,R4
	clr rmp
	adc R2,rmp
	adc R3,rmp
	ret
;
; Negative to positive/positive to negative
;
Negative:
	neg R2 ; Two's complement
	clr rmp
	sbc rmp,R3
	mov R3,rmp
	ret
;
; Convert mV difference to mA
; mV in R3:R2, result in R3:R2
; Adc voltage reference is 5V
; mA = 11.84 * (s32odd - s32even) / 256
;
mV2mA:
	ldi rmp,0x80 ; test negative
	and rmp,R3
	mov R0,rmp ; remember sign flag
	breq mV2mA1 ; not negative
	; convert negative to positive
	rcall negative
mV2mA1:
	mov R4,R2 ; copy to R6:R5:R4
	mov R5,R3
	clr R6
	lsl R4 ; * 2
	rol R5
	rol R6
	add R4,R2 ; * 3
	adc R5,R3
	clr rmp
	adc R6,rmp
	lsl R4 ; * 6
	rol R5
	rol R6
	lsl R4 ; * 12
	rol R5
	rol R6
	lsr R3 ; R3:R2 / 2
	ror R2
	lsr R3 ; R3:R2 / 4
	ror R2
	lsr R3 ; R3:R2 / 8
	ror R2
	sub R4,R2 ; * 11.88
	sbc R5,R3
	sbc R6,rmp
mV2mA3:
	mov R2,R5 ; move the result to R3:R2, dividing by 256
	mov R3,R6
	ldi rmp,0x80 ; round result
	add rmp,R4
	clr rmp
	adc R2,rmp
	adc R3,rmp
	tst R0 ; check negative
	breq mV2mA4
	rjmp negative
mV2mA4:
	ret
;
; Convert mA to mAh
; Input: R6:R5:R4 has the current as 256*I
; output: R3:R2 has the mAh as 256*mAh
;
mA2mAh:
	mov R1,R4 ; copy the current to R3:R2:R1
	mov R2,R5
	mov R3,R6
	lsr R3 ; divide the current by 2
	ror R2
	ror R1
	lsr R3 ; divide the current by 4
	ror R2
	ror R1
	; The current in mA, multiplied by 64, is now in R3:R2:R1
	clr rmp
	add R1,R5 ; add the original current to yield 65 * I
	adc R2,R6
	adc R3,rmp
	; The current in mA, multiplied by 65, is now in R3:R2:R1
	lsl R4 ; now multiply the original current by 8
	rol R5
	rol R6
	lsl R4 ; * 4
	rol R5
	rol R6
	lsl R4 ; * 8
	rol R5
	rol R6
	clr rmp ; round this up
	rol R4 ; upmost bit into carry
	adc R5,rmp
	adc R6,rmp
	add R1,R5 ; now at 8*I to 65*I to get 73*I
	adc R2,R6
	adc R3,rmp
	; The result of 73*I/256 is now in R3:R2
	; This number is equal to the mAh, multiplied by 256,
	; that were stored in the accu in the last 4 seconds 
	ret
;
; ********* 32 Measurement of voltages are completed *******
;
; ADC completed 32 measurements
;
Adc32m:
	cbr rFlg,1<<b32m ; clear 4s flag
	mov rmp,rChCH ; check MSB timer
	andi rmp,0x0F ; check lower nibble if 15 has been reached
	cpi rmp,15
	brcs Adc32m1 ; no, go on
	sbr rFlg,1<<bMin ; set minute flag
	ldi rmp,1 ; correct lower nibble
	add rChCH,rmp
	mov rmp,rChCH ; check upper nibble
	andi rmp,0xF0 ; 15 minutes reached?
	cpi rmp,0xF0 ; upper nibble = 15?
	brne Adc32m1 ; no, jump
	ldi rmp,0x10 ; correct MSB
	add rChCH,rmp
	; 15 minutes are over here
Adc32m1: ; calculate all voltages
	ldi ZH,HIGH(sAdcE4); Z points to measured values
	ldi ZL,LOW(sAdcE4)
Adc32m2:
	ld R2,Z ; copy the measured value to R3:R2
	ldd R3,Z+1
	rcall Adc2mV ; convert to mV
	std Z+16,R2 ; store in SRam
	std Z+17,R3
	adiw ZL,2
	cpi ZL,LOW(sAdcE4+16) ; end reached?
	brcs Adc32m2
	; calculate all currents and loaded capacities
	ldi ZH,HIGH(sAdcE4) ; Z points to measured values
	ldi ZL,LOW(sAdcE4)
Adc32m3:
	ld R0,Z ; Load even measure sum LSB to R0
	ldd R1,Z+1 ; dto., MSB to R1
	ldd R2,Z+8 ; Load odd measure LSB to R2
	ldd R3,Z+9 ; dto., MSB
	sub R2,R0 ; subtract LSB
	sbc R3,R1 ; dto., MSB
	rcall mV2mA ; calculate current
	std Z+32,R2 ; store current in Sram, LSB
	std Z+33,R3 ; dto., MSB
	rcall mA2mAh ; calculate the mAh from the mA
	ldd rmp,Z+48 ; read LLSB of capacity to rmp
	ldd R0,Z+40 ; read LSB to R0
	ldd R1,Z+41 ; read MSB to R1
	add rmp,R2 ; add LLSB
	adc R0,R3 ; add LSB
	clr R3 ; add MSB
	adc R1,R3
	std Z+48,rmp ; store LLSB in Sram
	std Z+40,R0 ; store LSB in Sram
	std Z+41,R1 ; store MSB in Sram
	adiw ZL,2
	cpi ZL,LOW(sAdcE4+8) ; at end?
	brcs Adc32m3 ; again until four times
	sbr rFlgD,(1<<bURdy)|(1<<bLRdy) ; set result ready flags
	ret
;
; *********** Check current channel states and change them ******
;
; add channel in R0 as displacement to address in Z
;
ChAdrs:
	mov rmp,R0 ; channel to rmp
	lsl rmp ; * 2
	lsl rmp ; * 4
	lsl rmp ; * 8
	add ZL,rmp ; to correct address
	ret
;
; Returns the akku id of the current channel in R0 in rmp
;
GetAkkuId:
	ldi ZH,HIGH(sAdcAI1) ; Z is adress of the channel
	ldi ZL,LOW(sAdcAI1)
	add ZL,R0 ; add channel number
	add ZL,R0
	ld rmp,Z ; read channel id
	ret
;
; Set the parameters for the selected accu id
; Expects channel in R0
;
IdSetPar:
	rcall GetAkkuId ; read the accu id in the channel
	tst rmp ; = Null?
	breq IdSetPar1
	lds R1,sEANm ; read number of accu id's
	sec
	cpc rmp,R1 ; compare with max number
	brcc IdSetPar1
	rcall EpRead ; read the accu info into buffer
	lds R2,sENCL ; read capacity, LSB
	lds R3,sENCM ; dto., MSB
	ldi ZH,HIGH(sCh1UV) ; point Z to channel values
	ldi ZL,LOW(sCh1UV)
	rcall ChAdrs
	ldi rmp,LOW(cUnlVol) ; set unload voltage to default
	st Z+,rmp
	ldi rmp,HIGH(cUnlVol)
	st Z+,rmp
	mov R4,R2 ; calculate load current
	mov R5,R3
	lsr R5
	ror R4
	lsr R5
	ror R4
	lsr R5
	ror R4
	st Z+,R4 ; store load current
	st Z+,R5
	add R2,R4 ; calculate load capacity
	adc R3,R5
	st Z+,R2 ; store load capacity
	st Z+,R3
	lsl R2 ; calculate maintain current
	rol R3
	st Z+,R3
	clr rmp
	st Z+,rmp
IdSetPar1:
	ret
;
; Pwm address of current channel to Z
;
PwmAdrs:
	ldi ZH,HIGH(cPwm1S) ; inactive channel
	ldi ZL,LOW(cPwm1S)
	add ZL,R0 ; address of channel
	ret
;
; Set pwm value for channel in R0 to rmp, clear unload bit of channel
;
PwmSet:
	ldi ZL,0xEF ; channel unload bit for channel 0
	mov ZH,R0 ; copy channel number
PwmSet1:
	tst ZH ; ok?
	breq PwmSet2 ; yes
	sec ; set carry to roll in
	rol ZL ; next higher bit
	dec ZH ; dec channel number
	rjmp PwmSet1 ; again
PwmSet2:
	and rPwmOut,ZL ; clear unload bit of channel
	rcall PwmAdrs ; Pwm address of current channel to Z
	st Z,rmp ; set pwm value for channel
	ret
;
; Set channel (in R0) state to value in rmp
;
ChSet:
	ldi ZL,0xFC ; channel mask bits
	mov ZH,R0 ; copy channel number
ChSet1:
	tst ZH ; channel reached?
	breq ChSet2 ; yes
	sec ; set carry for mask rol
	rol ZL ; next channel
	rol ZL
	lsl rmp ; shift rmp left
	lsl rmp
	dec ZH ; next channel
	rjmp ChSet1 ; again
ChSet2:
	lds ZH,sState ; load state bits
	and ZH,ZL ; clear channel activity bits
	or ZH,rmp ; set desired activity bits for channel
	sts sState,ZH ; set new state
	ret
;
; Switch channel in R0 (from Unload) to Load
;
ToLoad:
	ldi rmp,0x02 ; set channel mask to loading
	rcall ChSet ; set state
	ldi rmp,150 ; set pwm to medium voltage
	rcall PwmSet
	rjmp ClearCap ; clear capacity of channel
;
; Clear the capacity of the channel in R0
;
ClearCap:
	ldi ZH,HIGH(sAdcC) ; point to loaded capacity
	ldi ZL,LOW(sAdcC)
	add ZL,R0
	add ZL,R0
	clr rmp
	std Z+8,rmp ; clear LLSB
	st Z+,rmp ; clear LSB
	st Z,rmp
	ret
;
; Compare current in the channel and correct, if necessary
; Expects channel in R0, pointer to the desired current in Z
;
ChCurrent: ; Check current too high or too small and correct
	rcall ChAdrs ; correct address in Z to point to desired
	ld R2,Z+ ; load desired current to R3:R2
	ld R3,Z
	ldi ZH,HIGH(sAdcI) ; point Z to measured current
	ldi ZL,LOW(sAdcI)
	add ZL,R0 ; to correct channel
	add ZL,R0
	ld R4,Z+ ; copy load current to R5:R4
	ld R5,Z
	sub R4,R2 ; subtract from desired current
	sbc R5,R3
	breq ChCurrent3 ; current is correct
	brcs ChCurrent1 ; current is too small, increase
	rcall PwmAdrs ; current too high, decrease
	ld rmp,Z ; read pwm value
	dec rmp
	brne ChCurrent2
	inc rmp
	rjmp ChCurrent2
ChCurrent1:
	rcall PwmAdrs
	ld rmp,Z ; read pwm value
	inc rmp ; increase
	brne ChCurrent2
	dec rmp
ChCurrent2:
	st Z,rmp ; set new pwm value
ChCurrent3:
	ret
;
; Check the states of the channels and change, if conditions are met
;
ChckStates:
	clr R0 ; channel 0
	lds R1,sState ; read the states
ChckStates1:
	mov rmp,R1 ; copy state of channel
	andi rmp,0x03
	cpi rmp,1 ; state = 0?
	brcc ChckStates2 ; state = 1 or higher
	clr rmp ; set inactive channel
	rcall PwmSet
	rjmp ChckStates6
ChckStates2:
	brne ChckStates3 ; state=2 or higher
	ldi ZH,HIGH(sCh1UV) ; Unloading, point Z to threshold voltage
	ldi ZL,LOW(sCh1UV)
	rcall ChAdrs
	ld R2,Z+ ; threshold voltage to R3:R2
	ld R3,Z
	ldi ZH,HIGH(sAdcU) ; last measured voltage
	ldi ZL,LOW(sAdcU)
	add ZL,R0 ; address of channel
	add ZL,R0
	ld R4,Z+ ; measured voltage to R4:R5
	ld R5,Z
	sub R4,R2 ; measured voltage > threshold voltage?
	sbc R5,R3
	brcc ChckStates6 ; no, go on
	rcall ToLoad
	rjmp ChckStates6
ChckStates3: ; state is 2 or higher
	cpi rmp,2 ; is channel loading?
	brne ChckStates5
	ldi ZH,HIGH(sCh1LW) ; point to max. work
	ldi ZL,LOW(sCh1LW)
	rcall ChAdrs ; calculate channel adress
	ld R2,Z+ ; max work to R3:R2
	ld R3,Z
	ldi ZH,HIGH(sAdcC) ; Z to selected capacity
	ldi ZL,LOW(sAdcC)
	add ZL,R0 ; correct channel address
	add ZL,R0
	ld R4,Z+ ; current work to R4:R3
	ld R5,Z
	sub R4,R2 ; capacity reached?
	sbc R5,R3
	brcs ChckStates4 ; no, go on loading
	ldi rmp,0x03 ; set maintain state
	rcall ChSet
	ldi rmp,100 ; set pwm small
	rcall PwmSet
	rcall EpStore ; add capacity to the stored akku
	rjmp ChckStates6
ChckStates4:
	ldi ZH,HIGH(sCh1LC) ; point Z to load current
	ldi ZL,LOW(sCh1LC)
	rcall ChCurrent ; correct current to that value
	rjmp ChckStates6
ChckStates5: ; channel is maintained
	ldi ZH,HIGH(sCh1MC) ; maintain current
	ldi ZL,LOW(sCh1MC)
	rcall ChCurrent ; correct current to that value
ChckStates6:
	lsr R1 ; channel mask next channel
	lsr R1
	inc R0 ; next channel
	mov rmp,R0 ; channel = 5?
	cpi rmp,5
	brcc ChckStates7 ; yes, stop
	rjmp ChckStates1 ; go on
ChckStates7:
	ret
;
; Display result in hex on Uart
;
DisplHex:
	cbr rFlgD,1<<bURdy ; clear display flag
	rcall ChckStates ; check the states of the channels
	sbrs rFlgD,bUHex ; is the display flag set?
	ret ; jump over display outout in hex
	ldi ZH,HIGH(sAdcE4) ; display results hex
	ldi ZL,LOW(sAdcE4)
	rjmp UartHex16 ; write the raw results of the measurements
;
; Display all voltages in Line 1 of the LCD
;
DispVtg:
	ldi rmp,0 ; Lcd to line 1
	rcall LcdLine
	ldi XH,HIGH(sAdcU) ; X as pointer to values
	ldi XL,LOW(sAdcU)
	ldi rmp,'U'
DispVtg1:
	rcall LcdChar
	ld R2,X+ ; read value, LSB
	ld R3,X+ ; dto., MSB
	ldi rmp,LOW(10000) ; cannot exceed 10,000 mV
	cp R2,rmp ; too high?
	ldi rmp,HIGH(10000)
	cpc R3,rmp
	brcs DispVtg2
	ldi rmp,'E' ; too big
	rcall LcdChar
	rcall LcdR0
	rcall LcdR0
	rcall LcdR0
	rjmp DispVtg3
DispVtg2:
	clr R0 ; suppress leading zeros
	rcall LcdDec4
DispVtg3:
	ldi rmp,' '
	cpi XL,LOW(sAdcU+8) ; end reached?
	brcs DispVtg1 ; again
	ret
;
; Display currents on line 2
;
DispCurr:
	ldi rmp,1 ; Lcd Line 2
	rcall LcdLine ; set line
	ldi XH,HIGH(sAdcI) ; point to currents
	ldi XL,LOW(sAdcI)
	ldi rmp,'I'
DispCurr1:
	rcall LcdChar
	ld R2,X+ ; read current, LSB
	ld R3,X+ ; dto., MSB
	mov rmp,R2 ; zero?
	or rmp,R3
	ldi rmp,' '
	breq DispCurr2
	mov rmp,R3 ; test if negative
	rol rmp ; bit 7 of MSB
	ldi rmp,'+' ; load +
	brcc DispCurr2 ; not negative
	rcall negative
	ldi rmp,'-' ; load -
DispCurr2:
	rcall LcdChar
	clr R0 ; suppress leading zeros
	rcall LcdDec3 ; display positive number
	ldi rmp,' '
	cpi XL,LOW(sAdcI+8) ; end?
	brcs DispCurr1
	ret
;
; Display mAh in Line 3
;
DispmAh:
	ldi rmp,2 ; line 3
	rcall LcdLine
	ldi XH,HIGH(sAdcC) ; point X to mAh
	ldi XL,LOW(sAdcC)
	ldi rmp,'C'
DispmAh1:
	rcall LcdChar ; write sign
	ld R2,X+ ; read mAh LSB
	ld R3,X+ ; read mAh MSB
	mov rmp,R3 ; negative?
	rol rmp ; sign to carry
	brcc DispmAh2
	rcall negative
DispmAh2:
	clr R0 ; suppress leading zeros
	rcall LcdDec4 ; write number to LCD
	ldi rmp,' '
	cpi XL,LOW(sAdcC+8) ; check end
	brcs DispmAh1
	ret
;
; Display result 
;
DisplLcd:
	cbr rFlgD,1<<bLRdy ; clear the display flag
	sbrs rFlg,bLcdOk ; Jump over, if Lcd is ok
	ret
	sbrs rFlgD,bLcd3 ; Check if line 4 is accessible
	rjmp DisplLcd1 ; jump over line 4 output
DisplLcd1:
	sbrc rFlgD,bLcd0 ; check if line 1 is free for voltage
	rcall DispVtg ; display voltages
	sbrc rFlgD,bLcd1 ; check if line 2 is free for current
	rcall DispCurr ; display current
	sbrc rFlgD,bLcd2 ; check if line 3 is free for mAh
	rcall DispmAh ; display mAh
	rjmp LcdCursor
;
; Update system time
;
Time:
	ldi ZH,HIGH(sTimeM)
	ldi ZL,LOW(sTimeM)
	ld rmp,Z ; add a minute
	inc rmp
	st Z,rmp
	cpi rmp,60
	brcs Time1
	clr rmp ; new hour
	st Z+,rmp
	ld rmp,Z ; inc hours
	inc rmp
	st Z,rmp
	cpi rmp,24
	brcs Time1
	clr rmp ; new day
	st Z+,rmp
	ld rmp,Z ; inc days
	inc rmp
	st Z,rmp
	cpi rmp,100
	brcs Time1
	clr rmp
	st Z,rmp
Time1:
	ret
;
; Monitor results on the Uart
;
Monitor:
	lds R1,sState ; read the status byte to R1
	clr R5 ; channel counter
Monitor1:
	mov rmp,R1
	andi rmp,0x03 ; isolate activity bits
	brne Monitor3
Monitor2:
	lsr R1 ; next channel
	lsr R1
	inc R5
	ldi rmp,4
	cp R5,rmp
	brcs Monitor1
	ret
Monitor3: ; output the channel
	ldi rmp,'1' ; send channel number
	add rmp,R5
	rcall UartSendChar
	ldi rmp,':'
	rcall UartSendChar
	ldi rmp,' '
	rcall UartSendChar
	ldi rmp,'N'
	rcall UartSendChar
	ldi rmp,'='
	rcall UartSendChar
	ldi ZH,HIGH(sAdcAI1) ; point Z to Id
	ldi ZL,LOW(sAdcAI1)
	add ZL,R5
	add ZL,R5
	ld R2,Z
	clr R3
	rcall UartSendNmbr
	ldi rmp,','
	rcall UartSendChar
	ldi rmp,' '
	rcall UartSendChar
	ldi rmp,'S'
	rcall UartSendChar
	ldi rmp,'='
	rcall UartSendChar
	mov rmp,R1
	andi rmp,0x03
	subi rmp,-'0'
	rcall UartSendChar
	ldi rmp,','
	rcall UartSendChar
	ldi rmp,' '
	rcall UartSendChar
	ldi ZH,HIGH(sAdcU) ; point Z to the measuring value
	ldi ZL,LOW(sAdcU)
	add ZL,R5
	add ZL,R5
	ld R2,Z+ ; read voltage
	ld R3,Z+
	rcall UartSendNmbr
	ldi rmp,'m'
	rcall UartSendChar
	ldi rmp,'V'
	rcall UartSendChar
	ldi rmp,','
	rcall UartSendChar
	ldi rmp,' '
	rcall UartSendChar
	ldi ZH,HIGH(sAdcI) ; point Z to current
	ldi ZL,LOW(sAdcI)
	add ZL,R5
	add ZL,R5
	ld R2,Z+
	ld R3,Z
	mov rmp,R3 ; negative cuurent?
	rol rmp
	brcc Monitor4
	rcall Negative
	ldi rmp,'-'
	rcall UartSendChar
Monitor4:
	rcall UartSendNmbr
	ldi rmp,'m'
	rcall UartSendChar
	ldi rmp,'A'
	rcall UartSendChar
	ldi rmp,','
	rcall UartSendChar
	ldi rmp,' '
	rcall UartSendChar
	ldi ZH,HIGH(sAdcC) ; point to work
	ldi ZL,LOW(sAdcC)
	add ZL,R5
	add ZL,R5
	ld R2,Z+
	ld R3,Z
	rcall UartSendNmbr
	ldi rmp,'m'
	rcall UartSendChar
	ldi rmp,'A'
	rcall UartSendChar
	ldi rmp,'h'
	rcall UartSendChar
	ldi rmp,cCr
	rcall UartSendChar
	ldi rmp,cLf
	rcall UartSendChar
	rjmp Monitor2
;
; Display time on LCD, if enabled
;
DisplTimeL:
	sbrs rFlg,bLcdOk ; Check if Lcd is ok
	ret
	sbrs rFlgD,bLcd3 ; Check if line 4 is free
	ret
	ldi rmp,3 ; set Lcd to line 4
	mov R1,rmp ; three numbers to display
	rcall LcdLine ; Line 4
	ldi XH,HIGH(sTimeD+1) ; display days
	ldi XL,LOW(sTimeD+1)
DisplTimeL1:
	ld R2,-X ; read number
	clr R3 ; clear MSB
	mov R0,R1 ; prevent suppressing leading zeros
	rcall LcdDec2 ; output two digits
	mov rmp,R1
	cpi rmp,1 ; output : ?
	breq DisplTimeL2 ; don't display :
	ldi rmp,':' ; display :
	rcall LcdChar
DisplTimeL2:
	dec R1 ; all time info sent?
	brne DisplTimeL1 ; no, again a number
	ldi rmp,' '
	rcall LcdChar
	rjmp LcdCursor
;
; Display time over Uart
;
DispTimeU:
	ldi rmp,cUartTime ; minutes per time display
	mov R0,rmp
	lds rmp,sTimeM ; read minutes
DispTimeU1:
	tst rmp ; zero?
	breq DispTimeUd
	sub rmp,R0 ; subtract cUartTime
	brcc DispTimeU1 ; no carry, check again
	ret ; carry, don't display
;
; Displays time over Uart directly
;
DispTimeUd:
	ldi rmp,'T' ; display time over Uart
	rcall UartSendChar
	ldi rmp,'='
	rcall UartSendChar
	ldi rmp,3 ; three times
	mov R1,rmp
	ldi ZH,HIGH(sTimeD+1) ; point Z at Days
	ldi ZL,LOW(sTimeD+1)
DispTimeUd1:
	ld R2,-Z ; read a number
	clr R3
	mov R0,R1 ; don't suppress leading zeroes
	rcall UartDec2
	mov rmp,R1 ; check display :
	cpi rmp,1
	breq DispTimeUd2 ; don't display :
	ldi rmp,':'
	rcall UartSendChar
DispTimeUd2:
	dec R1
	brne DispTimeUd1 ; next number
	ldi rmp,cCr ; Carriage return
	rcall UartSendChar
	ldi rmp,cLf ; Line feed
	rjmp UartSendChar
;
; A minute is over, display results if flag is set
;
Minute:
	cbr rFlg,1<<bMin ; clear the flag
	rcall Time ; update system time
	rcall DisplTimeL
	sbrs rFlgD,bUMoni ; jump if monitor flag is on
	ret ; nothing else to do
	rcall DispTimeU ; display time over Uart
	rjmp Monitor ; monitor results
;
; end of akkucalc include file
;