; *******************************************************************
; * Include Routine fuer Akkuload, Berechnungs- und Anzeigeroutinen *
; * (C)2005 by Gerh.Schmidt, info@avr-asm-tutorial.net              *
; *******************************************************************
;
; ************** EEPROM Init, Lesen und Schreiben ******************
;
; Initiiert den EEPROM-Speicher und stellt gespeicherte Id's fest
;
EpInit:
	clr ZH ; Z ist EEPROM-Lesezeiger
	clr ZL
	clr R0 ; R0 ist Z�ler
EpInit1:
	sbic EECR,EEWE ; Warte auf Schreib-Ende
	rjmp EpInit1 ; Warte weil Schreib-Bit gesetzt
	inc R0 ; n�hste Akku-Id
	ldi rmp,cEepMax+1 ; Maximalanzahl Id's
	cp R0,rmp ; vergleiche
	brcc EpInit4 ; Ende erreicht
	out EEARL,ZL ; EEPROM-Leseadresse setzen
	out EEARH,ZH
	sbi EECR,EERE ; EEPROM-Lesebit setzen
EpInit2:
	sbic EECR,EERE ; warte auf Lesen ok
	rjmp EpInit2 ; warte weiter
	in rmp,EEDR ; Lese Akku-Id-Nummer
	cp rmp,R0 ; vergleiche mit aktueller Nummer
	brne EpInit4 ; nicht richtig, beende
	adiw ZL,1 ; n�hstes Byte im EEPROM
	out EEARL,ZL ; EEPROM-Lese-Adresse setzen
	out EEARH,ZH
	sbi EECR,EERE ; Read Enable setzen
EpInit3:
	sbic EECR,EERE ; warte auf Lesen ok
	rjmp EpInit3 ; warte weiter
	in rmp,EEDR ; Lese Typangabe
	cpi rmp,0xA0 ; muss zwischen hex A0 und A3 sein
	brcs EpInit4 ; kleiner als A0, beenden
	cpi rmp,0xA4 ; gr�er als A3?
	brcc EpInit4 ; gr�er als A3, beenden
	adiw ZL,15 ; n�hste EEPROM-Position
	rjmp EpInit1 ; weiter
EpInit4:
	dec R0 ; speichere Anzahl korrekter Akku-Id's
	sts sEaNm,R0
	ret
;
; Lese den EEPROM-Inhalt der Akku-Id in rmp in den SRAM-Puffer
;
EpRead:
	dec rmp ; Startet mit Id=1
	mov ZL,rmp ; Kopiere nach Z
	clr ZH ; MSB auf Null, Adresse mit 16 multiplizieren
	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 ist SRAM-Puffer-Zeiger
	ldi XL,LOW(sEepB)
EpRead1:
	sbic EECR,EEWE ; warte auf Schreibende
	rjmp EpRead1
	out EEARH,ZH ; gib EEPROM-Adresse aus
	out EEARL,ZL
	sbi EECR,EERE ; Setze Read Enable
EpRead2:
	sbic EECR,EERE ; Warte auf Lese-Ende
	rjmp EpRead2
	in rmp,EEDR ; Lese Byte
	st X+,rmp ; Speichere im SRAM-Puffer
	adiw ZL,1 ; n�hstes Byte im EEPROM
	mov rmp,ZL ; Teste auf Ende
	andi rmp,0x0F ; letzte vier Bits = Null?
	brne EpRead1 ; Lese weiteres Byte
	ret
;
; Schreibe den Pufferinhalt im SRAM in das EEPROM
;
EpWrite:
	ldi XH,HIGH(sEepB) ; X ist der SRAM-Puffer-Zeiger
	ldi XL,LOW(sEepB)
	ld rmp,X ; Lese die ID-Nummer
	dec rmp ; Id's starten mit Id=1
	mov ZL,rmp ; Kopiere nach Z
	clr ZH ; MSB leeren, EEPROM-Adresse mit 16 multiplizieren
	lsl ZL ; *2
	rol ZH
	lsl ZL ; *4
	rol ZH
	lsl ZL ; *8
	rol ZH
	lsl ZL ; *16
	rol ZH
EpWrite1:
	sbic EECR,EEWE ; warte auf Schreibende
	rjmp EpWrite1
	out EEARH,ZH ; gib EEPROM-Schreibadresse aus
	out EEARL,ZL
	ld rmp,X+ ; Lese Byte aus SRAM-Puffer
	out EEDR,rmp ; Schreibe ins EEPROM-Datenregister
	cli ; Stop Interrupts
	sbi EECR,EEMWE ; Setze Schreibmode Enable
	sbi EECR,EEWE ; Setze Write Enable
	sei ; erm�liche Interrupts wieder
	adiw ZL,1 ; n�hste Adresse im EEPROM
	mov rmp,ZL ; Test auf Ende
	andi rmp,0x0F ; Letzte vier Bits = Null?
	brne EpWrite1 ; Schreibe noch weiter Bytes
	ret
;
; Prfe Akku-Id und addiere die Ladekapazit� zur gespeicherten Id im EEPROM
; R0 ist der Kanal, erh�t denm Inhalt von R0 und R1!
;
EpStore:
	rcall GetAkkuId ; Lese die Id des aktuellen Kanals
	tst rmp ; Id=0?
	breq EpStore4 ; ja, beende
	lds ZL,sEANm ; Lese die Anzahl Id's im EEPROM
	sec ; setze Carry-Flagge
	cpc rmp,ZL ; vergleiche mit (Anzahl der Id's+1)
	brcc EpStore4 ; gr�er als die Anzahl der gespeicherten Id's
	rcall EpRead ; lese die gew�lte Id in das SRAM
	ldi ZH,HIGH(sAdcC) ; Zeiger auf die gemessene Ladekapazit� in mAh
	ldi ZL,LOW(sAdcC)
	add ZL,R0 ; addiere Kanal zur Adresse
	add ZL,R0
	ld XL,Z+ ; gemessene Ladekapazit� in X lesen
	ld XH,Z
	lds ZL,sENRL ; Restkapazit� vom Puffer nach Z lesen
	lds ZH,sENRM
	add ZL,XL ; gemessene Ladekapazit� addieren
	adc ZH,XH
	lds XL,sENCL ; Nennkapazit� des Akkus in X
	lds XH,sENCM
	clr rmp ; Z�ler fr Anzahl Volladungen leeren
EpStore1:
	cp ZL,XL ; Restkapazit� in Z mit Nennkapazit� in X vergleichen
	cpc ZH,XH
	brcs EpStore2 ; Restkapazit� kleiner als Nennkapazit�
	sub ZL,XL ; subtrahiere Nennkapazit�
	sbc ZH,XH
	inc rmp ; Erh�e Anzahl der Volladungen
	rjmp EpStore1 ; weiter
EpStore2: ; Anzahl der Volladungen ist in rmp, Restkapazit� in Z
	sts sENRL,ZL ; Restkapazit� im SRAM-Puffer speichern
	sts sENRM,ZH
	tst rmp ; eine volle Ladung oder mehr?
	breq EpStore3 ; nein
	lds ZL,sENLL ; Lese Anzahl Volladungen aus SRAM-Puffer
	add ZL,rmp ; addiere zur Anzahl Volladungen
	sts sENLL,ZL ; Speichere LSB der Anzahl Volladungen
	brcc EpStore3 ; kein �ertrag
	lds ZL,sENLM ; erh�e MSB der Anzahl Volladungen
	inc ZL
	sts sENLM,ZL ; speichere MSB der Anzahl Volladungen
EpStore3: ; SRAM-Puffer ist komplett, speichere
	rcall EpWrite ; Schreibe den Puffer ins EEPROM
EpStore4:
	ret
;
; *** Wandle die gemessenen Spannungen in dezimal und berechne Strom dezimal ***
;
; Wandle die Summe aus 32 ADC-Messungen in bin�e Spannung um
; Die Summe sd32e ist in R3:R2, das Ergebnis in R3:R2, verwendet R6:R5:R4
; Referenzspannung ist 5V, Umrechnung: U[mV] = s32e * 39 / 256
;
Adc2mV:
	mov R4,R2 ; Kopiere s32e nach R6:R5:R4 und multipliziere mit 8
	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 ; Kopiere Zwischenergebnis in rmp:R1:R0, multipliziere mit 32
	mov R1,R5
	mov rmp,R6
	lsl R4 ; * 16
	rol R5
	rol R6
	lsl R4 ; * 32
	rol R5
	rol R6
	add R4,R0 ; * 40, addiere 8-fach und 32-fach = 40-fach
	adc R5,R1
	adc R6,rmp
	clr rmp
	sub R4,R2 ; * 39, ziehe Ausgangswert einmal ab = 39-fach
	sbc R5,R3
	sbc R6,rmp
	mov R2,R5 ; / 256, Kopiere die beiden obersten Bytes ins Ergebnis (=/256)
	mov R3,R6
	ldi rmp,0x80 ; runde das Ergebnis
	add rmp,R4
	clr rmp
	adc R2,rmp
	adc R3,rmp
	ret
;
; Negativen in positiven bzw. positiven in negativen Wert umwandeln (R3:R2)
;
Negative:
	neg R2 ; Zweierkomplement
	clr rmp
	sbc rmp,R3
	mov R3,rmp
	ret
;
; Umrechnung der Differenzspannung ber dem Widerstand (in mV) in Strom (mA)
; mV Differenz in R3:R2, Ergebnis in R3:R2
; ADC Referenzspannung ist 5V
; Umrechnung: mA = 11.84 * (s32ungerade - s32gerade) / 256
;
mV2mA:
	ldi rmp,0x80 ; teste ob Spannungsdifferenz negativ
	and rmp,R3
	mov R0,rmp ; Speichere Vorzeichen
	breq mV2mA1 ; nicht negativ
	; wandle negativ in positiv um
	rcall negative
mV2mA1:
	mov R4,R2 ; kopiere nach R6:R5:R4
	mov R5,R3
	clr R6
	lsl R4 ; * 2, multipliziere mit zwei
	rol R5
	rol R6
	add R4,R2 ; * 3, addiere Ausgangswert = * 3
	adc R5,R3
	clr rmp
	adc R6,rmp
	lsl R4 ; * 6, multipliziere mit zwei = * 6
	rol R5
	rol R6
	lsl R4 ; * 12, multipliziere mit zwei = * 12
	rol R5
	rol R6
	lsr R3 ; R3:R2 / 2, dividiere Ausgangswert / 8
	ror R2
	lsr R3 ; R3:R2 / 4
	ror R2
	lsr R3 ; R3:R2 / 8
	ror R2
	sub R4,R2 ; * 11.88, subtrahiere ein Achtel
	sbc R5,R3
	sbc R6,rmp
mV2mA3:
	mov R2,R5 ; kopiere Ergebnis nach R3:R2, teilen durch 256
	mov R3,R6
	ldi rmp,0x80 ; runde Ergebnis
	add rmp,R4
	clr rmp
	adc R2,rmp
	adc R3,rmp
	tst R0 ; prfe negativ
	breq mV2mA4 ; nein
	rjmp negative ; wandle in negativ um
mV2mA4:
	ret
;
; Rechne Strom in mA in Kapazit� in mAh um
; Anfang: R6:R5:R4 enth�t den Strom als 256*I(mA)
; Ende: R3:R2 ist die Ladekapazit� ber 4 Sekunden als 256*mAh
;
mA2mAh:
	mov R1,R4 ; Kopiere den Ausgangswert nach R3:R2:R1
	mov R2,R5
	mov R3,R6
	lsr R3 ; dividiere den Strom durch 2
	ror R2
	ror R1
	lsr R3 ; ... durch 4
	ror R2
	ror R1
	; Der Strom in mA, multipliziert mit 64, ist jetzt in R3:R2:R1
	clr rmp
	add R1,R5 ; addiere den Original-Strom, um 65 * I zu erhalten
	adc R2,R6
	adc R3,rmp
	; Der Strom in mA, multipliziert mit 65, ist jetzt in R3:R2:R1
	lsl R4 ; Multiplikation des Ausgangsstroms mit 8
	rol R5
	rol R6
	lsl R4 ; * 4
	rol R5
	rol R6
	lsl R4 ; * 8
	rol R5
	rol R6
	clr rmp ; Runden
	rol R4 ; oberstes Bit ins Carry
	adc R5,rmp
	adc R6,rmp
	add R1,R5 ; addiere 8*I zu 65*I = 73*I
	adc R2,R6
	adc R3,rmp
	; Das Ergebnis von 73*I/256 ist jetzt in R3:R2
	; Diese Zahl ist gleich der Ladekapazit� in mAh, multipliziert mit 256,
	; die in den vergangenen vier Sekunden in den Akku geladen wurden
	ret
;
; ********* 32 Messungen der Spannung sind komplett *******
;
; ADC hat 32 Messungen durchgefhrt und aufsummiert
;
Adc32m:
	cbr rFlg,1<<b32m ; l�che die 4s Flagge
	mov rmp,rChCH ; prfe das MSB des Messz�lers
	andi rmp,0x0F ; prfe ob das niedrige Nibble 15 erreicht hat
	cpi rmp,15
	brcs Adc32m1 ; nein, mach weiter
	sbr rFlg,1<<bMin ; setze die Minuten-Flagge
	ldi rmp,1 ; korrigiere das niedrige Nibble des MSB des Messz�lers
	add rChCH,rmp ; addiere eine Eins
	mov rmp,rChCH ; Prfe das obere Nibble des MSB des Messz�lers
	andi rmp,0xF0 ; 15 Minuten erreicht?
	cpi rmp,0xF0 ; oberes Nibble = 15?
	brne Adc32m1 ; nein, mach weiter
	ldi rmp,0x10 ; korrigiere MSB
	add rChCH,rmp ; addiere 10
	; 15 Minuten sind hier vorber, wird nicht weiter ausgewertet
Adc32m1: ; berechne alle Spannungen
	ldi ZH,HIGH(sAdcE4); Z zeigt auf die gemessenen Werte
	ldi ZL,LOW(sAdcE4)
Adc32m2:
	ld R2,Z ; Kopiere den Messwert nach R3:R2
	ldd R3,Z+1
	rcall Adc2mV ; rechne in mV um
	std Z+16,R2 ; speichere Ergebnis im SRAM
	std Z+17,R3
	adiw ZL,2 ; der n�hste gemessene Wert
	cpi ZL,LOW(sAdcE4+16) ; Ende erreicht?
	brcs Adc32m2
	; Berechne Str�e und Ladekapazit�en
	ldi ZH,HIGH(sAdcE4) ; Z zeigt auf die gemessenen Werte
	ldi ZL,LOW(sAdcE4)
Adc32m3:
	ld R0,Z ; Kopiere die Summe des geraden Messkanals LSB nach R0
	ldd R1,Z+1 ; dto., MSB nach R1
	ldd R2,Z+8 ; Kopiere die Summe des ungeraden Messkanals LSB nach R2
	ldd R3,Z+9 ; dto., MSB nach R3
	sub R2,R0 ; subtrahiere LSB
	sbc R3,R1 ; dto., MSB
	rcall mV2mA ; berechne den Strom in mA
	std Z+32,R2 ; Speichere den Strom im SRAM, LSB
	std Z+33,R3 ; dto., MSB
	rcall mA2mAh ; berechne die mAh aus dem Strom in mA
	ldd rmp,Z+48 ; lese das LLSB der mAh in rmp
	ldd R0,Z+40 ; lese LSB mAh nach R0
	ldd R1,Z+41 ; lese MSB mAh nach R1
	add rmp,R2 ; addiere das LLSB
	adc R0,R3 ; addiere das LSB
	clr R3 ; add das MSB
	adc R1,R3
	std Z+48,rmp ; speichere das LLSB im SRAM
	std Z+40,R0 ; speichere das LSB im SRAM
	std Z+41,R1 ; speichere MSB im SRAM
	adiw ZL,2 ; n�hster Kanal
	cpi ZL,LOW(sAdcE4+8) ; am Ende?
	brcs Adc32m3 ; weiter insgesamt vier mal
	sbr rFlgD,(1<<bURdy)|(1<<bLRdy) ; Setze die Ergebnis-fertig-Flaggen
	ret
;
; ******* Vergleiche den aktuellen Kanal-Status mit dem Sollwert und �dere ****
;
; Addiere den Kanal in R0 zur Adresse in Z
;
ChAdrs:
	mov rmp,R0 ; Kanal in rmp kopieren
	lsl rmp ; * 2
	lsl rmp ; * 4
	lsl rmp ; * 8
	add ZL,rmp ; und zur Basisadresse in Z addieren
	ret
;
; Gibt die Akku-Id vom Kanal in R0 in rmp zurck
;
GetAkkuId:
	ldi ZH,HIGH(sAdcAI1) ; Z ist die Adresse des Kanals
	ldi ZL,LOW(sAdcAI1)
	add ZL,R0 ; addiere Kanal
	add ZL,R0
	ld rmp,Z ; Lese Id
	ret
;
; Setzt die Sollwerte fr die gew�lte Akku-Id
; Erwartet den Kanal in R0
;
IdSetPar:
	rcall GetAkkuId ; Lese die Akku-Id des Kanals
	tst rmp ; = Null?
	breq IdSetPar1 ; ja, tue nichts
	lds R1,sEANm ; Lese die Anzahl gespeicherter Id's
	sec
	cpc rmp,R1 ; vergleiche mit der maximalen Anzahl Id's
	brcc IdSetPar1 ; zu gro� tu nichts
	rcall EpRead ; Lese die Akku-Id in den SRAM-Puffer
	lds R2,sENCL ; Lese die Nennkapazit�, LSB
	lds R3,sENCM ; dto., MSB
	ldi ZH,HIGH(sCh1UV) ; Z auf die Sollwerte des Kanals setzen
	ldi ZL,LOW(sCh1UV)
	rcall ChAdrs ; Adresse des Kanals
	ldi rmp,LOW(cUnlVol) ; Setze die Entladespannung auf Defaultwert
	st Z+,rmp
	ldi rmp,HIGH(cUnlVol)
	st Z+,rmp
	mov R4,R2 ; Berechne den Ladestrom aus der Nennkapazit�
	mov R5,R3
	lsr R5
	ror R4
	lsr R5
	ror R4
	lsr R5
	ror R4
	st Z+,R4 ; setze den Sollwert Ladestrom
	st Z+,R5
	add R2,R4 ; Berechne die Ladekapazit� aus der Nennkapazit�
	adc R3,R5
	st Z+,R2 ; Speichere den Sollwert Ladekapazit�
	st Z+,R3
	lsl R2 ; Berechne den Erhaltungsstrom aus der Nennkapazit�
	rol R3
	st Z+,R3 ; Speichere den Sollwert Erhaltungsstrom
	clr rmp
	st Z+,rmp
IdSetPar1:
	ret
;
; Berechne die PWM-Adresse des aktuellen Kanals in R0 in Z
;
PwmAdrs:
	ldi ZH,HIGH(cPwm1S) ; Z auf Sollwert von Kanal 1
	ldi ZL,LOW(cPwm1S)
	add ZL,R0 ; Addiere aktuellen Kanal in R0 zur Adresse
	ret
;
; Setze den PWM-Wert in Kanal R0 auf den Wert in rmp und l�che das Unload-Bit
;
PwmSet:
	ldi ZL,0xEF ; Unload-Bit fr Kanal 0
	mov ZH,R0 ; Kopiere Kanal
PwmSet1:
	tst ZH ; ok?
	breq PwmSet2 ; ja
	sec ; Setze Carry-Bit vor dem Rollen
	rol ZL ; n�hsth�eres Bit
	dec ZH ; n�hster Kanal
	rjmp PwmSet1 ; und wieder von vorn
PwmSet2:
	and rPwmOut,ZL ; l�che das Unload-Bit des Kanals
	rcall PwmAdrs ; Hole die PWM-Adresse des aktuellen Kanals nach Z
	st Z,rmp ; Setze den PWM-Wert fr den Kanal
	ret
;
; Setze den Kanal(in R0)status auf den Wert in rmp
;
ChSet:
	ldi ZL,0xFC ; Kanalmaske
	mov ZH,R0 ; kopiere Kanal
ChSet1:
	tst ZH ; Kanal erreicht?
	breq ChSet2 ; ja, raus
	sec ; Setze Carry-Bit fr das Rollen
	rol ZL ; n�hste Kanalmaske
	rol ZL
	lsl rmp ; schiebe rmp links
	lsl rmp
	dec ZH ; n�hster Kanal
	rjmp ChSet1 ; und wiederholen
ChSet2:
	lds ZH,sState ; Lese Statusbits
	and ZH,ZL ; l�che Statusbits des Kanals
	or ZH,rmp ; Setze die Statusbits des Kanals
	sts sState,ZH ; neuen Status speichern
	ret
;
; Schalte den Kanal in R0 (von Entladen) auf Laden
;
ToLoad:
	ldi rmp,0x02 ; Statusbits fr Laden
	rcall ChSet ; Setze Status des Kanals in R0
	ldi rmp,150 ; Setze die PWM auf eine mittlere Spannung
	rcall PwmSet ; Setze PWM des aktuellen Kanals
	rjmp ClearCap ; L�che den Kapazit�swert des Kanals
;
; L�che den Kapazit�swert des Kanals in R0
;
ClearCap:
	ldi ZH,HIGH(sAdcC) ; Zeiger auf die Kapazit� des Kanals
	ldi ZL,LOW(sAdcC)
	add ZL,R0
	add ZL,R0
	clr rmp
	std Z+8,rmp ; l�che LLSB
	st Z+,rmp ; l�che LSB
	st Z,rmp ; l�che MSB
	ret
;
; Vergleiche den Strom im Kanal mit dem Sollwert und korrigiere die PWM
; Erwartet den Kanal in R0 und den Zeiger auf den Sollwert in Z
;
ChCurrent: ; Prfe Strom zu hoch/zu niedrig und korrigiere
	rcall ChAdrs ; Adresse in Z auf korrekten Kanal-Sollwert
	ld R2,Z+ ; Sollstrom nach R3:R2 laden
	ld R3,Z
	ldi ZH,HIGH(sAdcI) ; Z auf gemessenen Strom setzen
	ldi ZL,LOW(sAdcI)
	add ZL,R0 ; Adresse des Kanals
	add ZL,R0
	ld R4,Z+ ; Ladestrom nach R5:R4 kopieren
	ld R5,Z
	sub R4,R2 ; vom Sollwert subtrahieren
	sbc R5,R3
	breq ChCurrent3 ; Strom ist korrekt, raus
	brcs ChCurrent1 ; Strom ist zu niedrig, erh�e PWM
	rcall PwmAdrs ; Strom zu hoch, erniedrige PWM
	ld rmp,Z ; Lese PWM-Wert
	dec rmp ; niedriger setzen
	brne ChCurrent2 ; ausgeben, wenn nicht Null
	inc rmp ; Null erreicht, bleibe bei 1
	rjmp ChCurrent2 ; ausgeben
ChCurrent1: ; Strom zu niedrig, erh�en
	rcall PwmAdrs ; Adresse des PWM-Registers holen
	ld rmp,Z ; PWM-Wert lesen
	inc rmp ; erh�en
	brne ChCurrent2 ; kein �erlauf
	dec rmp ; �erlauf, wieder auf FF setzen
ChCurrent2: ; neuen PWM-Wert speichern
	st Z,rmp ; neuen PWM-Wert setzen
ChCurrent3: ; fertig
	ret
;
; Prfe die Ist- und Sollwerte der Kan�e
;
ChckStates:
	clr R0 ; Kanal 0
	lds R1,sState ; Statusbits holen
ChckStates1:
	mov rmp,R1 ; Status kopieren
	andi rmp,0x03 ; Statusbits des Kanals isolieren
	cpi rmp,1 ; Status inaktiv = 0?
	brcc ChckStates2 ; Status = 1 oder h�er
	clr rmp ; Kanal inaktiv
	rcall PwmSet ; Setze PWM auf Null
	rjmp ChckStates6 ; n�hster Kanal
ChckStates2: ; Status = 1..3
	brne ChckStates3 ; Status=2 oder h�er
	ldi ZH,HIGH(sCh1UV) ; Entladen, Z auf Schwellwertspannung
	ldi ZL,LOW(sCh1UV)
	rcall ChAdrs ; Adresse des Kanals
	ld R2,Z+ ; Entladespannung in R3:R2
	ld R3,Z
	ldi ZH,HIGH(sAdcU) ; Z auf letzte gemessene Spannung
	ldi ZL,LOW(sAdcU)
	add ZL,R0 ; Adresse des Kanals
	add ZL,R0
	ld R4,Z+ ; gemessene Spannung in R4:R5
	ld R5,Z
	sub R4,R2 ; gemessene Spannung < Sollwert
	sbc R5,R3
	brcc ChckStates6 ; nein, n�hster Kanal
	rcall ToLoad ; starte Ladevorgang
	rjmp ChckStates6 ; n�hster Kanal
ChckStates3: ; Status ist 2 oder h�er
	cpi rmp,2 ; Laden?
	brne ChckStates5 ; nein, Erhaltungsladung
	ldi ZH,HIGH(sCh1LW) ; Z auf Ladekapazit�-Sollwert
	ldi ZL,LOW(sCh1LW)
	rcall ChAdrs ; Kanaladresse
	ld R2,Z+ ; Sollwert Ladekapazit� in R3:R2
	ld R3,Z
	ldi ZH,HIGH(sAdcC) ; Z auf Istwert Ladekapazit�
	ldi ZL,LOW(sAdcC)
	add ZL,R0 ; Kanaladresse
	add ZL,R0
	ld R4,Z+ ; Istwert Ladekapazit� in R4:R3
	ld R5,Z
	sub R4,R2 ; Istwert - Sollwert
	sbc R5,R3
	brcs ChckStates4 ; noch nicht erreicht, weiter laden
	ldi rmp,0x03 ; Ende erreicht, setze Status auf Erhaltungsladung
	rcall ChSet
	ldi rmp,100 ; setze PWM auf niedrigen Wert
	rcall PwmSet
	rcall EpStore ; Addiere die Ladekapazit� zur Id im EEPROM
	rjmp ChckStates6 ; n�hster Kanal
ChckStates4: ; Sollwert Kapazit� nicht erreicht, prfe Strom
	ldi ZH,HIGH(sCh1LC) ; Z auf Sollwert Ladestrom
	ldi ZL,LOW(sCh1LC)
	rcall ChCurrent ; Korrigiere Ladestrom, wenn n�ig
	rjmp ChckStates6 ; n�hster Kanal
ChckStates5: ; Erhaltungsladung
	ldi ZH,HIGH(sCh1MC) ; Z auf Stromsollwert fr Erhaltungsladung
	ldi ZL,LOW(sCh1MC)
	rcall ChCurrent ; Korrigiere Ladestrom, wenn n�ig
ChckStates6: ; n�hster Kanal
	lsr R1 ; Maske fr n�hsten Kanal
	lsr R1
	inc R0 ; n�hster Kanal
	mov rmp,R0 ; Kanal = 5?
	cpi rmp,5
	brcc ChckStates7 ; ja, fertig
	rjmp ChckStates1 ; weiter
ChckStates7: ; fertig
	ret
;
; Prft den Kanalstatus, zeigt das Ergebnis in Hex ber das UART an (Debug)
;
DisplHex:
	cbr rFlgD,1<<bURdy ; Display-Flagge l�chen
	rcall ChckStates ; Kanalstatus checken
	sbrs rFlgD,bUHex ; Hexanzeige-Flagge gesetzt?
	ret ; nein, fertig
	ldi ZH,HIGH(sAdcE4) ; Ergebnis in Hex anzeigen
	ldi ZL,LOW(sAdcE4)
	rjmp UartHex16 ; Roh-Messwerte in Hex ausgeben
;
; Spannungen in Zeile 1 des LCD-Displays anzeigen
;
DispVtg:
	ldi rmp,0 ; LCD auf Zeile 1
	rcall LcdLine
	ldi XH,HIGH(sAdcU) ; X als Zeiger auf die Spannungen
	ldi XL,LOW(sAdcU)
	ldi rmp,'U' ; Zeichen U ausgeben
DispVtg1:
	rcall LcdChar ; Zeichen in rmp ausgeben
	ld R2,X+ ; Spannung lesen, LSB
	ld R3,X+ ; dto., MSB
	ldi rmp,LOW(10000) ; mit 10000 mV vergleichen
	cp R2,rmp ; zu hoch?
	ldi rmp,HIGH(10000)
	cpc R3,rmp
	brcs DispVtg2 ; Spannung in Ordnung
	ldi rmp,'E' ; zu gro�
	rcall LcdChar ; EEEEE ausgeben
	rcall LcdR0
	rcall LcdR0
	rcall LcdR0
	rjmp DispVtg3
DispVtg2: ; Spannung ok
	clr R0 ; fhrende Nullen unterdrcken
	rcall LcdDec4 ; vier Dezimalstellen ausgeben
DispVtg3:
	ldi rmp,' ' ; Blank ausgeben
	cpi XL,LOW(sAdcU+8) ; Ende erreicht?
	brcs DispVtg1 ; wiederholen
	ret
;
; Str�e in Zeile 2 der LCD anzeigen
;
DispCurr:
	ldi rmp,1 ; LCD-Zeile 2
	rcall LcdLine ; Zeile ansteuern
	ldi XH,HIGH(sAdcI) ; X auf Str�e setzen
	ldi XL,LOW(sAdcI)
	ldi rmp,'I' ; Stromsymbol ausgeben
DispCurr1:
	rcall LcdChar ; Zeichen in rmp an LCD-Display
	ld R2,X+ ; lese Strom, LSB
	ld R3,X+ ; dto., MSB
	mov rmp,R2 ; Null?
	or rmp,R3
	ldi rmp,' ' ; Leerzeichen ausgeben
	breq DispCurr2 ; Null, leer
	mov rmp,R3 ; testen ob negativ
	rol rmp ; Bit 7 des MSB
	ldi rmp,'+' ; +Zeichen in rmp laden
	brcc DispCurr2 ; nicht negativ
	rcall negative ; Wert in positiven Wert wandeln
	ldi rmp,'-' ; -Zeichen in rmp
DispCurr2: ; Vorzeichen ausgeben
	rcall LcdChar ; Vorzeichen an LCD
	clr R0 ; fhrende Nullen unterdrcken
	rcall LcdDec3 ; dreistellige Dezimalzahl ausgeben
	ldi rmp,' ' ; Leerzeichen
	cpi XL,LOW(sAdcI+8) ; Ende?
	brcs DispCurr1 ; nein, n�hster Kanal
	ret
;
; Ladekapazit� in mAh in Zeile 3 der LCD ausgeben
;
DispmAh:
	ldi rmp,2 ; Zeile 3
	rcall LcdLine ; LCD auf Zeile setzen
	ldi XH,HIGH(sAdcC) ; X auf mAh setzen
	ldi XL,LOW(sAdcC)
	ldi rmp,'C' ; C ausgeben
DispmAh1:
	rcall LcdChar ; Zeichen in rmp an LCD ausgeben
	ld R2,X+ ; lesen mAh LSB
	ld R3,X+ ; lesen mAh MSB
	mov rmp,R3 ; negativ?
	rol rmp ; Vorzeichen in Carry
	brcc DispmAh2 ; positiv
	rcall negative ; negativ, umwandeln
DispmAh2:
	clr R0 ; fhrende Nullen unterdrcken
	rcall LcdDec4 ; vierstellig an LCD ausgeben
	ldi rmp,' ' ; Leerzeichen
	cpi XL,LOW(sAdcC+8) ; Ende?
	brcs DispmAh1 ; nein, n�hster Kanal
	ret
;
; Ergebnisse auf LCD anzeigen
;
DisplLcd:
	cbr rFlgD,1<<bLRdy ; Flagge l�chen
	sbrs rFlg,bLcdOk ; LCD vorhanden?
	ret ; nein, zurck
	sbrs rFlgD,bLcd3 ; Zeile 4 verfgbar?
	rjmp DisplLcd1 ; jump over line 4 output
	; Ausgaben in Zeile 4, hier nicht benutzt
DisplLcd1:
	sbrc rFlgD,bLcd0 ; Zeile 1 der LCD ok fr Ausgabe?
	rcall DispVtg ; Spannungen anzeigen
	sbrc rFlgD,bLcd1 ; Zeile 2 der LCD verfgbar?
	rcall DispCurr ; Str�e anzeigen
	sbrc rFlgD,bLcd2 ; Zeile 3 der LCD verfgbar?
	rcall DispmAh ; Ladekapazit� anzeigen
	rjmp LcdCursor ; Cursor der LCD setzen
;
; Systemzeit eine Minute h�er setzen
;
Time:
	ldi ZH,HIGH(sTimeM) ; Z auf Minutenwert
	ldi ZL,LOW(sTimeM)
	ld rmp,Z ; eine Minute addieren
	inc rmp
	st Z,rmp
	cpi rmp,60 ; Stunde erreicht?
	brcs Time1 ; nein, fertig
	clr rmp ; Minuten auf Null
	st Z+,rmp
	ld rmp,Z ; n�hste Stunde
	inc rmp
	st Z,rmp
	cpi rmp,24 ; n�hster Tag?
	brcs Time1 ; nein, fertig
	clr rmp ; Stunde auf Null
	st Z+,rmp
	ld rmp,Z ; n�hster Tag
	inc rmp
	st Z,rmp
	cpi rmp,100 ; �erlauf?
	brcs Time1 ; nein, weiter
	clr rmp ; Tag auf Null
	st Z,rmp
Time1:
	ret
;
; Ergebnisse ber UART ausgeben
;
Monitor:
	lds R1,sState ; Statusbits in R1
	clr R5 ; R5 ist Kanalz�ler
Monitor1:
	mov rmp,R1 ; Status nach rmp kopieren
	andi rmp,0x03 ; Statusbits isolieren
	brne Monitor3 ; Status>0
Monitor2: ; Status = Clear, nichts ausgeben
	lsr R1 ; n�hster Kanal
	lsr R1
	inc R5 ; Kanalzahl
	ldi rmp,4
	cp R5,rmp ; Ende?
	brcs Monitor1 ; nein, weiter
	ret
Monitor3: ; Status > 0, ausgeben
	ldi rmp,'1' ; Sende Kanalnummer
	add rmp,R5
	rcall UartSendChar
	ldi rmp,':' ; Sende :
	rcall UartSendChar
	ldi rmp,' '
	rcall UartSendChar
	ldi rmp,'N' ; Sende Id
	rcall UartSendChar
	ldi rmp,'='
	rcall UartSendChar
	ldi ZH,HIGH(sAdcAI1) ; Z auf 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' ; Sende Status
	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) ; Sende Spannung, Z auf Spannung
	ldi ZL,LOW(sAdcU)
	add ZL,R5
	add ZL,R5
	ld R2,Z+ ; lese Spannung
	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) ; Sende Strom, Z auf Strom
	ldi ZL,LOW(sAdcI)
	add ZL,R5
	add ZL,R5
	ld R2,Z+
	ld R3,Z
	mov rmp,R3 ; negativ?
	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) ; Sende Kapazit�, Z auf Kapazit�
	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 ; n�hster Kanal
;
; Zeit auf LCD ausgeben
;
DisplTimeL:
	sbrs rFlg,bLcdOk ; Lcd ok?
	ret
	sbrs rFlgD,bLcd3 ; Zeile 4 verfgbar?
	ret
	ldi rmp,3 ; Zeile 4 setzen
	mov R1,rmp ; drei Zahlen darzustellen
	rcall LcdLine ; Line 4
	ldi XH,HIGH(sTimeD+1) ; X auf Zeit in Tagen
	ldi XL,LOW(sTimeD+1)
DisplTimeL1:
	ld R2,-X ; Zeit lesen
	clr R3 ; MSB l�chen
	mov R0,R1 ; fhrende Nullen anzeigen
	rcall LcdDec2 ; zwei Digits ausgeben
	mov rmp,R1
	cpi rmp,1 ; : ausgeben?
	breq DisplTimeL2 ; nein
	ldi rmp,':' ; : anzeigen
	rcall LcdChar
DisplTimeL2:
	dec R1 ; alle gesendet?
	brne DisplTimeL1 ; nein, n�hste Zahl
	ldi rmp,' ' ; Leerzeichen anh�gen
	rcall LcdChar
	rjmp LcdCursor ; Cursor setzen
;
; Zeit prfen und ber UART ausgeben
;
DispTimeU:
	ldi rmp,cUartTime ; Minutenintervall der Ausgabe
	mov R0,rmp
	lds rmp,sTimeM ; Minuten lesen
DispTimeU1:
	tst rmp ; Null?
	breq DispTimeUd
	sub rmp,R0 ; subtrahiere Intervall
	brcc DispTimeU1 ; nicht Null, weiter prfen
	ret ; nicht ausgeben
;
; Zeitausgabe ber UART
;
DispTimeUd:
	ldi rmp,'T' ; Zeit ausgeben
	rcall UartSendChar
	ldi rmp,'='
	rcall UartSendChar
	ldi rmp,3 ; drei Werte
	mov R1,rmp
	ldi ZH,HIGH(sTimeD+1) ; Z auf Tage
	ldi ZL,LOW(sTimeD+1)
DispTimeUd1:
	ld R2,-Z ; Zahl lesen
	clr R3
	mov R0,R1 ; fhrende Nullen nicht unterdrcken
	rcall UartDec2
	mov rmp,R1 ; : ausgeben?
	cpi rmp,1
	breq DispTimeUd2 ; nein
	ldi rmp,':'
	rcall UartSendChar
DispTimeUd2:
	dec R1
	brne DispTimeUd1 ; n�hste Zahl
	ldi rmp,cCr ; Wagenrcklauf
	rcall UartSendChar
	ldi rmp,cLf ; Zeilenvorschub
	rjmp UartSendChar
;
; Eine Minute ist vergangen, Ausgabe wenn enabled
;
Minute:
	cbr rFlg,1<<bMin ; Flagge l�chen
	rcall Time ; Systemzeit um eine Minute erh�en
	rcall DisplTimeL ; anzeigen
	sbrs rFlgD,bUMoni ; Monitor-Flagge auswerten
	ret ; nichts weiter zu tun
	rcall DispTimeU ; Zeit ber UART ausgeben
	rjmp Monitor ; Ergebnisse ber UART ausgeben
;
; Ende von akkucalc
;