; **************************************************************
; * Akkulader Version 0.1 for ATmega16 @ 8 MHz Takt            *
; * (C)2005 by Gerh.Schmidt info@avr-asm-tutorial.net          *
; **************************************************************
;
.INCLUDE "m16def.inc"
;
; Konstanten
;
.EQU fclock = 8000000 ; Processortaktfrequenz
.EQU baud = 9600 ; Serielle Schnittstelle Baudrate
.EQU cUartTime = 5 ; Alle 5 Minuten die Systemzeit an das UART
.EQU cKeyRep = 5 ; Anzahl Durchläufe bis Tastendruck akzeptiert wird
.EQU cUnlVol = 1000 ; Standard-Entladespannung in mV
;
; Register Definitionen
;
; R0 wird für diverse Operationen verwendet
; R1:R0 Als Doppelregister bei Rechenoperationen verwendet
; R3:R2 dto.
; R6:R5:R4 Dreifachregister bei Rechenoperationen
.DEF rKeyLst = R7 ; Letzte gedrückte Taste
.DEF rKeyRep = R8 ; Zähler für Tastenwiederholung
;.DEF rAdcV  = R9  ; Betriebsspannungsmaske für ADC
.DEF rPwmC  = R10 ; PWM Zähler
.DEF rPwm1S = R11 ; PWM Schaltwert für Kanal 1
.EQU cPwm1S = 11  ; (Pointerwert für Kanal 1)
.DEF rPwm2S = R12 ; PWM Schaltwert für Kanal 2
.DEF rPwm3S = R13 ; PWM Schaltwert für Kanal 3
.DEF rPwm4S = R14 ; PWM Schaltwert für Kanal 4
.DEF rSreg  = R15 ; Sicherung von SREG bei Interrupts
.DEF rmp    = R16 ; Multipurpose Register
.DEF rimp   = R17 ; Multipurpose Register bei Interrupts
.DEF rimp1  = R18 ; Multipurpose Register bei Interrupts
.DEF rFlg   = R19 ; Multipurpose Flag Register (siehe unten)
.DEF rFlgD  = R20 ; Anzeige Flag Register (siehe unten)
.DEF rPwmOut= R21 ; Wert für die PWM-Ausgabe
; Frei R22..R23
.DEF rChCL = R24 ; Kanalzähler für ADC-Messungen, LSB
.DEF rChCH = R25 ; dto., MSB
; X (R27:R26) für verschiedene Zwecke außerhalb von Interrupts
; Y (R29:R28) bei Interrupts für Messauswertung verwendet
; Z (R31:R30) für verschiedene Zwecke außerhalb von Interrupts
;
; Bit-Definitionen für rFlg
.EQU bUartRxLine = 7 ; Eine vollständige Zeile über UART empfangen
.EQU bLcdOk = 6 ; LCD-Anzeige angeschlossen und ok
; nicht benutzt: Bits 3, 4 und 5
.EQU bMin = 2 ; Timer hat 1 Minute erreicht
.EQU b32m = 1 ; Timer Interrupt 4 Secunden, 32 ADC-Messungen komplett
.EQU b64Hz = 0 ; Timer Interrupt 64 Hz Tick
;
; Bit-Definitionen für das Anzeigeflag rFlgD
;
.EQU bUHex = 7 ; Zeige Ergebnisse in Hex über UART an (Debug)
.EQU bUMoni = 6 ; Zeige aktive Kanäle über UART an
.EQU bURdy = 5 ; Ergebnisse komplett für die UART-Ausgabe
.EQU bLRdy = 4 ; Ergebnisse komplett für die LCD-Ausgabe
.EQU bLcd3 = 3 ; Zeile 4 der LCD ist frei verwendbar
.EQU bLcd2 = 2 ; Zeile 3 der LCD ist frei verwendbar
.EQU bLcd1 = 1 ; Zeile 2 der LCD ist frei verwendbar
.EQU bLcd0 = 0 ; Zeile 1 der LCD ist frei verwendbar
;
;
; Berechnete Konstanten
;
.EQU cTC1Prsc = 8 ; TC1 Vorteiler-Wert
.EQU cTC1Div = fClock / cTC1Prsc / 64 ; 64 Interrupts pro Sekunde
.EQU cTC1CompB = 50 ; Timer-Wert für den Start der ADC-Umwandlung
.EQU cStartAdc = (1<<ADEN)|(1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0); ADC Enable, Clock=128
.EQU cRestartAdc = cStartAdc | (1<<ADSC) ; Starte ADC-Umwandlung
.EQU cAdcV = 1<<REFS0 ; ADC-Referenzspannung auf 5V
.EQU cEepMax = 512/16 ; Maximale Anzahl gespeicherter Akku-Id's im EEPROM
.EQU cCr = $0D ; Wagenrücklauf-Zeichen für UART
.EQU cLf = $0A ; Zeilenvorschub-Zeichen für UART
;
; SRAM Positionen
;
; UART SRAM Variablen
.EQU sUartRxBp = $0060 ; UART Rx Pufferzeiger
.EQU sUartRxBs = $0061 ; Uart Rx Pufferanfang
.EQU sUartRxBe = $007E ; Uart Rx Pufferende
.EQU sUartCurCh = $007F ; Aktueller Kanal für UART-Ein-/Ausgabe
; Sollwerte der Ladekanäle
.EQU sCh1UV = $0080 ; Kanal 1, Entladespannung Abschaltwert
.EQU sCh1LC = $0082 ; Kanal 1, Ladestrom in mA
.EQU sCh1LW = $0084 ; Kanal 1, Ladekapazität in mAh
.EQU sCh1MC = $0086 ; Kanal 1, Erhaltungsladestrom in mA
.EQU sCh2UV = $0088 ; Kanal 2, dto.
.EQU sCh2LC = $008A ; Kanal 2, dto.
.EQU sCh2LW = $008C ; Kanal 2, dto.
.EQU sCh2MC = $008E ; Kanal 2, dto.
.EQU sCh3UV = $0090 ; Kanal 3, dto.
.EQU sCh3LC = $0092 ; Kanal 3, dto.
.EQU sCh3LW = $0094 ; Kanal 3, dto.
.EQU sCh3MC = $0096 ; Kanal 3, dto.
.EQU sCh4UV = $0098 ; Kanal 4, dto.
.EQU sCh4LC = $009A ; Kanal 4, dto.
.EQU sCh4LW = $009C ; Kanal 4, dto.
.EQU sCh4MC = $009E ; Kanal 4, dto.
; Messwerte vom ADC
.EQU sAdcE1 = $00A0 ; ADC Messergebnisse, geradzahlige Kanäle (Akkus)
.EQU sAdcO1 = $00A8 ; dto., ungeradzahlige Kanäle (Ladewiderstand)
.EQU sAdcE4 = $00B0 ; ADC Summe für 4 Sekunden, geradzahlige Kanäle
.EQU sAdcO4 = $00B8 ; dto., ungeradzahlige Kanäle
.EQU sAdcU  = $00C0 ; berechnete Spannungen, geradzahlige und ungeradzahlige
.EQU sAdcI  = $00D0 ; berechnete Ladeströme in mA
.EQU sAdcC  = $00D8 ; berechnete Kapazitäten in mAh (LSB,MSB)
.EQU sAdcLL1= $00E0 ; berechnete Kapazitäten in mAh (LLSB), Kanal 1
.EQU sAdcAI1= $00E1 ; Akku Id, Kanal 1
; Kanalsteuerung
.EQU sState = $00E8 ; Aktueller Status der Kanäle, Bits 44332211
		; 00=abgeschaltet, 01:entladen, 10:laden, 11:erhalten
.EQU sTimeM = $00E9 ; Systemzeit, Minuten (0, 15, 30, 45)
.EQU sTimeH = $00EA ; dto., Stunden
.EQU sTimeD = $00EB ; dto., Tage
.EQU sLcdCs = $00EC ; LCD Cursor Position
; Tasteneingabe
.EQU sKeyNC = $00ED ; Dezimalzahl Eingabeposition
.EQU sKeyNW = $00EE ; Dezimalzahl Ein- und Ausgabewort
.EQU sKeyNM = $00F0 ; Dezimalzahl Maximalwert
.EQU sKeyJR = $00F2 ; Sprungadresse für Dezimalzahleingabeende
.EQU sKeyJS = $00F4 ; Sprungadresse bei Abbruch der Dezimalzahleingabe
.EQU sKeyJ1 = $00F6 ; Sprungadresse bei Taste 1 gedrückt
.EQU sKeyJ2 = $00F8 ; dto., Taste 2
.EQU sKeyJ3 = $00FA ; dto., Taste 3
.EQU sKeyCh = $00FC ; Aktueller Kanal für Tasteneingabe (0, 1..4)
; LED-Ausgabe
.EQU sLedC  = $00FD ; LED-Zähler
.EQU sLed1  = $00FE ; LED Kanal 1 Vergleichswert
.EQU sLed2  = $00FF ; dto., Kanal 2
.EQU sLed3  = $0100 ; dto., Kanal 3
.EQU sLed4  = $0101 ; dto., Kanal 4
; EEPROM-Lese- und Schreibpuffer
.EQU sEepB  = $0102 ; EEPROM Puffer für einen Akku-ID-Record, 16 Bytes
.EQU sEAId  = $0102 ; EEPROM Akku Id
.EQU sESize = $0103 ; EEPROM Akkugröße = A0..A3 (Mignon, Baby, AA, AAA)
.EQU sENCL  = $0104 ; EEPROM Nennkapazität LSB
.EQU sENCM  = $0105 ; dto., MSB
.EQU sENLL  = $0106 ; EEPROM Anzahl der Volladungen, LSB
.EQU sENLM  = $0107 ; dto., MSB
.EQU sENRL  = $0108 ; EEPROM Restkapazität in mAh, LSB
.EQU sENRM  = $0109 ; dto., MSB
.EQU sEATxt = $010A ; Textteil der Akku-Definition
.EQU sENul  = $0112 ; Null-Zeichen als Stopwert
.EQU sEANm  = $0113 ; Anzahl der im EEPROM gespeicherten korrekten IDs
;
; Nächste freie SRAM-Position: $0114
;
;
; Reset- und Interrupt-Vektoren
; (Vektoren beim ATmega16 sind Doppelworte!)
;
.CSEG
.ORG $0000
	rjmp main ; Reset Vektor
	nop
	reti ; INT0 Vektor
	nop
	reti ; INT1 Vektor
	nop
	reti ; TC2Comp Vektor
	nop
	reti ; TC2Ovf Vektor
	nop
	reti ; TC1Capt Vektor
	nop
	rjmp TC1CmpAIsr ; TC1CompA Vektor
	nop
	rjmp TC1CmpBIsr ; TC1CompB Vektor
	nop
	reti ; TC1Ovf Vektor
	nop
	rjmp TC0OvfIsr ; TC0Ovf Vektor
	nop
	reti ; SPI, STC Vektor
	nop
	rjmp SioRxCIsr; USARTRxC Vektor
	nop
	reti ; USARTUdre Vektor
	nop
	reti ; USARTTxc Vektor
	nop
	reti ; ADC Vektor
	nop
	reti ; EE_RDY Vektor
	nop
	reti ; ANA_COMP Vektor
	nop
	reti ; TWI Vektor
	nop
	reti ; INT2 Vektor
	nop
	reti ; TC0Comp Vektor
	nop
	reti ; SPM_RDY Vektor
	nop
;
; TC1 Compare A Int Serviceroutine
; (Liest das Resultat einer ADC-Messung und speichert es)
;
TC1CmpAIsr:
	in rSreg,SREG ; Sichere SREG
	sbr rFlg,1<<b64Hz ; Setze 64 Tick Flagge
	mov rimp,rChCL ; Prüfe Zähler
	andi rimp,1 ; ungerader oder gerader Kanal?
	brne TC1CmpAIsrO ; ungerader Kanal
	; Gerader Kanal
	mov rimp,rChCL ; Prüfe Zähler
	andi rimp,0xF8 ; Isoliere Zähler ohne die Kanalnummer
	brne TC1CmpAIsrE1 ; Kein Neustart
	; TC1 hat 32 Messungen beendet, startet neu
	in rimp,ADCL ; Lese ADC LSB
	st Y,rimp ; Speichere im SRAM
	in rimp,ADCH ; Lese ADC MSB
	std Y+1,rimp ; Speichere im SRAM
	rjmp TC1CmpAIsrE3
TC1CmpAIsrE1: ; kein Neustart
	cpi rimp,0xF8 ; letzte Messung im aktuellen Kanal?
	breq TC1CmpAIsrE2 ; Ja, addiere die letzte Messung
	; Normale Messung, addiere zur Summe
	in rimp1,ADCL ; Lese Ergebnis vom ADC, LSB
	ld rimp,Y ; Lese bisherige Summe aus SRAM
	add rimp,rimp1 ; Addiere Ergebnis
	st Y,rimp ; Speichere im SRAM
	in rimp1,ADCH ; Lese Ergebnis vom ADC, MSB
	ldd rimp,Y+1 ; lese gespeicherte Summe im SRAM, MSB
	adc rimp,rimp1 ; Addiere Messergebnis zur Summe
	std Y+1,rimp ; Speichere MSB im SRAM
	rjmp TC1CmpAIsrE3
TC1CmpAIsrE2: ; die letzte Messung der Messreihe
	in rimp1,ADCL ; Lese Ergebnis vom ADC, LSB
	ld rimp,Y ; Lese gespeicherte Summe, LSB
	add rimp,rimp1 ; Addiere zum Ergebnis
	std Y+16,rimp ; Speichere den Summenwert im SRAM, LSB
	in rimp1,ADCH ; Lese Ergebnis vom ADC, MSB
	ldd rimp,Y+1 ; Lese gespeicherte Summe, MSB
	adc rimp,rimp1 ; Addiere zum Ergebnis MSB
	std Y+17,rimp ; Speichere den Summenwert im SRAM, MSB
TC1CmpAIsrE3:
	adiw rChCL,1 ; Erhöhe den Kanalzähler
	mov rimp,rChCL ; Kopiere LSB des Kanalzählers
	andi rimp,0x07 ; isoliere Kanalnummer des nächsten Kanals
	ori rimp,cAdcV ; Setze die Referenzspannungsbits
	out ADMUX,rimp ; Wähle den nächsten MUX-Kanal des ADC an
	out SREG,rSreg ; Stelle SREG wieder her
	reti
;
TC1CmpAIsrO: ; ungerader Kanal
	mov rimp,rChCL ; Kopiere LSB Kanalzähler
	andi rimp,0xF8 ; isoliere alles bis auf die Kanalnummer
	brne TC1CmpAIsrO1 ; kein Neustart
	; TC1 hat 32 Messungen beendet, startet neu
	in rimp,ADCL ; Lese ADC, LSB
	std Y+8,rimp ; Speichere im SRAM (überschreibt alte Summe)
	in rimp,ADCH ; Lese ADC, MSB
	std Y+9,rimp ; Speichere im SRAM (überschreibt alte Summe)
	rjmp TC1CmpAIsrO3
TC1CmpAIsrO1: ; ungerader Kanal, kein Neustart
	cpi rimp,0xF8 ; Letzte Messung im Kanal?
	breq TC1CmpAIsrO2 ; Ja, addiere den letzten Wert
	; Normale Messung, addiere zur Summe und speichere
	in rimp1,ADCL ; Lese ADC, LSB
	ldd rimp,Y+8 ; Lese gespeicherte Summe aus SRAM, LSB
	add rimp,rimp1 ; addiere zum Ergebnis, LSB
	std Y+8,rimp ; Speichere Summe im SRAM, LSB
	in rimp1,ADCH ; Lese ADC, MSB
	ldd rimp,Y+9 ; Lese gespeicherte Summe aus SRAM, MSB
	adc rimp,rimp1 ; addiere zum Ergebnis, MSB
	std Y+9,rimp ; Speichere Summe im SRAM, MSB
	rjmp TC1CmpAIsrO3
TC1CmpAIsrO2: ; Ungerader Kanal, letzte Messung im Kanal
	in rimp1,ADCL ; Lese ADC, LSB
	ldd rimp,Y+8 ; Lese bisherige Summe, LSB
	add rimp,rimp1 ; Addiere zum Ergebnis, LSB
	std Y+24,rimp ; Speichere das letzte Summenergebnis, LSB
	in rimp1,ADCH ; Lese ADC, MSB
	ldd rimp,Y+9 ; Lese bisherige Summe, MSB
	adc rimp,rimp1 ; addiere zum Ergebnis, MSB
	std Y+25,rimp ; Speichere das letzte Summenergebnis, MSB
TC1CmpAIsrO3:
	adiw YL,2 ; zeige auf nächste Position im SRAM
	adiw rChCL,1 ; nächster Kanal
	mov rimp,rChCL ; Kopiere Zähler, LSB
	andi rimp,0x07 ; Isoliere nächsten Kanal
	brne TC1CmpAIsrO4 ; Nicht Kanal 1
	ldi YH,HIGH(sAdcE1) ; Setze Pointer zurück auf Kanal 1
	ldi YL,LOW(sAdcE1)
TC1CmpAIsrO4:
	ori rimp,cAdcV ; Setze die Referenzspannungs-Bits
	out ADMUX,rimp ; Wähle nächsten ADC-MUX-Kanal
	tst rChCL ; Alles am Anfang?
	brne TC1CmpAIsrO5 ; nein
	sbr rFlg,1<<b32m ; Setze die Flagge für 32 Zyklen komplett
TC1CmpAIsrO5:
	out SREG,rSreg ; Stelle SREG wieder her
	reti
;
; TC1 Compare B Interrupt Serviceroutine
;
TC1CmpBIsr:
	sbi ADCSR,ADSC ; Starte ADC-Messzyklus
	reti
;
; TC0 Overflow Interrupt Serviceroutine
;
Tc0OvfIsr:
	in rsreg,SREG ; Sichere SREG
	inc rPwmC ; Erhöhe PWM-Zähler
	brne Tc0OvfIsr1 ; nicht Null, weiter
	mov rimp,rPwmOut ; Kopiere die bisherige Kanalausgabe
	andi rimp,0xF0 ; Erhalte die vier obersten Bits (Entladebits)
	mov rPwmOut,rimp ; Setze die Kanalausgabe auf Null
	ldi rimp,0xF0 ; Maskiere die vier obersten Bits
	eor rimp,rPwmOut ; Invertiere die vier obersten Bits
	swap rimp ; vertausche die oberen und unteren Bits
	or rPwmOut,rimp ; Setze die Kanalausgabe (1 für aktive Kanäle)
TC0OvfIsr1:
	cp rPwmC,rPwm1S ; Vergleiche den Kanalzähler mit Sollwert Kanal 1
	brne TC0OvfIsr2 ; nicht gleich, springe
	cbr rPwmOut,1 ; PWM-Bit für Kanal 1 abschalten
TC0OvfIsr2:
	cp rPwmC,rPwm2S ; Vergleiche den Kanalzähler mit Sollwert Kanal 2
	brne TC0OvfIsr3 ; nicht gleich, springe
	cbr rPwmOut,2 ; PWM-Bit für Kanal 2 abschalten
TC0OvfIsr3:
	cp rPwmC,rPwm3S ; Vergleiche den Kanalzähler mit Sollwert Kanal 3
	brne TC0OvfIsr4 ; nicht gleich, springe
	cbr rPwmOut,4 ; PWM-Bit für Kanal 3 abschalten
TC0OvfIsr4:
	cp rPwmC,rPwm4s ; Vergleiche den Kanalzähler mit Sollwert Kanal 4
	brne TC0OvfIsr5 ; nicht gleich, springe
	cbr rPwmOut,8 ; PWM-Bit für Kanal 4 abschalten
TC0OvfIsr5:
	out PORTC,rPwmOut ; Auf Port C ausgeben
	out SREG,rsreg ; Stelle SREG wieder her
	reti
;
; Uart RxC Interrupt Serviceroutine
;
SioRxCIsr:
	in rSreg,SREG ; Sichere SReg
	in rimp,UCSRA ; Lese UART Fehlerbits
	andi rimp,(1<<FE)|(1<<DOR)|(1<<PE) ; Isoliere Fehler-Bits
	in rimp,UDR ; Lese empfangenes Zeichen vom UART
	breq SioRxCIsr1 ; kein Fehler, springe
	ldi rimp,'*' ; Zeige einen Empfangsfehler an
	sbrs rFlg,bUartRxLine ; Ist der Zeilenpuffer blockiert?
	out UDR,rimp ; Echo des Zeichens an UART
	rjmp SioRxCIsr4 ; Ignoriere das Zeichen
SioRxCIsr1:
	sbrc rFlg,bUartRxLine ; Zeilenpuffer blockiert?
	rjmp SioRxCIsr4 ; Ja, ignoriere das Zeichen
	out UDR,rimp ; Echo des Zeichens an UART
	push ZH ; Sichere Z-Register
	push ZL
	ldi ZH,HIGH(sUartRxBs) ; Position für nächstes Zeichen, MSB
	lds ZL,sUartRxBp ; dto., LSB
	st Z+,rimp ; speichere Zeichen im Puffer
	cpi ZL,LOW(sUartRxBe+1) ; Ende des Puffers erreicht?
	brcc SioRxCIsr2 ; Pufferüberlauf
	sts sUartRxBp,ZL ; Speichere nächste Pufferposition
SioRxCIsr2:
	cpi rimp,cCr ; Wagenrücklauf?
	brne SioRxCIsr3 ; Nein, mach weiter
	ldi rimp,cLf ; Echo Zeilenvorschub an UART
	out UDR,rimp ; in Ausgaberegister des UART
	sbr rFlg,(1<<bUartRxLine) ; Setze Zeile-Komplett-Flag
SioRxCIsr3:
	pop ZL ; Stelle Z-Register wieder her
	pop ZH
SioRxCIsr4:
	out SREG,rSreg ; Stelle SREG wieder her
	reti ; Return vom Interrupt
;
;*************************** Hauptprogram *******************
;
; Beginn des Hauptprogramms, Init der Hardware und der SRAM-Variablen
;
main:
	ldi rmp,HIGH(RAMEND) ; Stelle Stapelzeiger ein
	out SPH,rmp
	ldi rmp,LOW(RAMEND)
	out SPL,rmp
	; Initiiere Register und SRAM
	clr rFlg ; Flaggen löschen
	clr rFlgD ; Anzeigeflaggen löschen
	ldi rFlgD,0x0F ; LCD-Zeilenzugriff ermöglichen
	; Initiiere die Ports
	clr rmp ; Port A alle Bits Eingang
	out DDRA,rmp
	ldi rmp,0xFF ; Port C alle Bits Ausgang
	out DDRC,rmp
	ldi rmp,0xF2 ; Port D Bits 7..4 und 1 als Ausgänge
	out DDRD,rmp
	; Initiiere die Tasten
	rcall KeyInit ; Init-Routine für Tasten aufrufen
	; Initiiere die LEDs
	rcall KeyLedInit ; Init-Routine für die LEDs aufrufen
	; Statusflaggen und Systemzeit initiieren
	clr rmp
	ldi ZH,HIGH(sState) ; Statusflagge
	ldi ZL,LOW(sState)
	st Z+,rmp ; sState
	st Z+,rmp ; sTimeM
	st Z+,rmp ; sTimeH
	st Z+,rmp ; sTimeD
	st Z+,rmp ; LCD-Cursorposition
	ldi ZH,HIGH(sAdcC) ; Initiiere mAh-Werte
	ldi ZL,LOW(sAdcC)
	ldi rmp,16 ; 16 Bytes löschen
	clr R0
main1:
	st Z+,R0 ; Position Null setzen
	dec rmp ; nächste Position
	brne main1 ; noch welche
	ldi ZH,HIGH(sCh1UV) ; Initiiere Akku Sollwerte
	ldi ZL,LOW(sCh1UV)
	ldi rmp,32
main2:
	st Z+,R0 ; auf Null setzen
	dec rmp ; nächste Position 
	brne main2 ; noch welche
	sts sUartCurCh,R0 ; Setze UART Kanal auf Null
	; Initiiere die EEPROM Liste der Akku-Id's
	rcall EpInit ; rufe EEPROM-Init-Routine auf
	; Initiiere den UART
	call UartInit ; Initiiere UART-Empfang und -Senden
	call UartSendOpenText ; Sende den Eröffnungstext
	call UartSendCursor ; Sende den Cursor über den UART
	; Initiiere die LCD-Anzeige
	rcall LcdInit ; Rufe die LCD-Init-Routine auf
	; Initiiere die PWM-Kanäle
	clr rPwm1S ; Setze den Anfangswert für Kanal 1
	clr rPwm2S ; Setze den Anfangswert für Kanal 2
	clr rPwm3S ; Setze den Anfangswert für Kanal 3
	clr rPwm4S ; Setze den Anfangswert für Kanal 4
	clr rPwmOut ; PWM-Ausgabe deaktivieren
	; Initiiere die Timer 0 und 1
	ldi rmp,HIGH(cTC1Div) ; TC1: Teiler für das 64 Hz-Signal
	out OCR1AH,rmp ; MSB zuerst!
	ldi rmp,LOW(cTC1Div)
	out OCR1AL,rmp ; LSB zuletzt!
	ldi rmp,HIGH(cTC1CompB) ; MSB zuerst!
	out OCR1BH,rmp
	ldi rmp,LOW(cTC1CompB) ; LSB zuletzt!
	out OCR1BL,rmp
	clr rmp ; TC1: TC1-Mode: keine Ausgabe, kein PWM
	out TCCR1A,rmp
	ldi rmp,(1<<WGM12)|(1<<CS11) ; TC1: CTC und Vorteiler = 8
	out TCCR1B,rmp
	ldi rmp,(1<<TOIE0)|(1<<OCIE1A)|(1<<OCIE1B) ; TC0 Überlauf und TC1CompA/B Int
	out TIMSK,rmp
	ldi rmp,1<<CS00 ; Setze TC0 Vorteiler auf 1
	out TCCR0,rmp
	; Initiiere den ADC
	ldi YH,HIGH(sAdcE1) ; Y ist der ADC-Ergebnis-Zeiger
	ldi YL,LOW(sAdcE1)
	clr rChCH ; Setze Kanalzähler für ADC auf Null
	clr rChCL
	ldi rmp,cAdcV ; Setze ADC-Referenzspannung und MUX auf Kanal 0
	out ADMUX,rmp
	ldi rmp,cStartAdc ; Starte ADC, Taktvorteiler=128, keine Interrupts
	out ADCSR,rmp
	sei ; Ermögliche Interrupts
loop:	; Hauptprogramm-Schleife
	; Keinen SLEEP-Mode hier benutzen, da das den ADC-Ablauf stört
	tst rFlg ; Irgendeine Flagge gesetzt?
	breq loop ; nein, starte Schleife neu, bis was passiert
	ldi rmp,LOW(loop) ; Schleifenanfang als Rücksprungadresse auf den Stapel
	push rmp
	ldi rmp,HIGH(loop)
	push rmp
	; Prüfe die 64 Hz Tick Flagge von Timer 0
	sbrc rFlg,b64Hz ; ein Tick?
	rjmp Tick64Hz ; lese Tasten und werte sie aus
	; Prüfe ob 32 Messzyklen komplett sind und 4 Sekunden vorüber sind
	sbrc rFlg,b32m ; Prüfe 32 Messungen und 4 Sekunden vorüber
	rjmp Adc32m ; Springe zur Messauswertung
	; Prüfe ob Hexadezimalwerte über das UART ausgegeben werden sollen (Debug)
	sbrc rFlgD,bURdy ; Werte Flagge aus
	rjmp DisplHex ; Gib Hexwerte über das UART aus (Debug)
	; Prüfe ob Ergebnisse über die LCD-Anzeige ausgegeben werden können
	sbrc rFlgD,bLRdy ; Prüfe LCD-Werte fertig
	rjmp DisplLcd ; rufe LCD-Anzeige-Routine auf
	; Prüfe ob eine Minute vorüber ist
	sbrc rFlg,bMin ; Werte Minuten-Flagge aus
	rjmp Minute ; Springe zur Minutenausgabe
	; Prüfe ob eine über das UART empfangene Zeile komplett ist
	sbrs rFlg,bUartRxLine ; Werte Rx-Zeile-Komplett-Flagge aus
	ret ; nein
	jmp UartRxLine ; ja, beantworte empfangene UART-Zeile
;
; Ein 64 Hz Tick
;
Tick64Hz:
	cbr rFlg,1<<b64Hz ; Setze Flagge zurück
	rcall KeyLeds ; rufe die LED-Auswertungsroutine auf
	rjmp Keys ; rufe die Tastenauswertung auf
;
; Binde die Berechnungsroutinen ein
;
.INCLUDE "akkucalc.asm"
;
; Binde die Tastenauswertungsroutinen ein
;
.INCLUDE "akkukey.asm"
;
; Binde die LCD-Anzeigenroutinen ein
;
.INCLUDE "akkulcd.asm"
;
; Binde die UART-Routinen ein
;
.INCLUDE "akkuuart.asm"
;
; Ende des Code-Segments
;
; EEPROM-Segment, Initiiere meine Akkus
;
.ESEG
;
; Akku-Id-Definition:
;   Byte 1: Id-Nummer, muss von 1 an in fortgesetzter Reihenfolge sein
;   Byte 2: Bauart der Zelle, A0(Mono), A1(Baby), A2(AA), A3(AAA)
;   Byte 2 und 3: Nennkapazität in mAh, LSB and MSB
;   Byte 4 and 5: Anzahl der Volladungen mit Nennkapazitär, LSB and MSB
;   Byte 6 and 7: Ladekapazität, verbleibende mAh der letzten Ladung
;   Byte 8 to 16: Textbeschreibung der Zelle, exakt 8 Buchstaben lang
;
; Akku 1: AAA, NiMH, Conrad 250185
.DB 0x01,0xA3
.DW 500,4,0
.DB "ConradMH"
;
; Akku 2: AAA, NiMH, Conrad 250185
.DB 0x02,0xA3
.DW 500,4,0
.DB "ConradMH"
;
; Akku 3: AAA, NiMH, Conrad 250185
.DB 0x03,0xA3
.DW 500,4,0
.DB "ConradMH"
;
; Akku 4: AAA, NiMH, Conrad 250185
.DB 0x04,0xA3
.DW 500,4,0
.DB "ConradMH"
;
; Akku 5: AA, NiMH, Pixcell Camera
.DB 0x05,0xA2
.DW 1800,10,0
.DB "PixcelMH"
;
; Akku 6: AA, NiMH, Pixcell Camera
.DB 0x06,0xA2
.DW 1800,10,0
.DB "PixcelMH"
;
; Akku 7: AA, NiMH, Pixcell Camera
.DB 0x07,0xA2
.DW 1800,10,0
.DB "PixcelMH"
;
; Akku 8: AA, NiMH, Pixcell Camera
.DB 0x08,0xA2
.DW 1800,10,0
.DB "PixcelMH"
;
; Akku 9: AA, NiMH, Conrad Voltcraft
.DB 0x09,0xA2
.DW 1700,6,0
.DB "VoltcrMH"
;
; Akku 10: AA, NiMH, Conrad Voltcraft
.DB 0x0A,0xA2
.DW 1700,6,0
.DB "VoltcrMH"
;
; Akku 11: AA, NiMH, Conrad Voltcraft
.DB 0x0B,0xA2
.DW 1700,6,0
.DB "VoltcrMH"
;
; Akku 12: AA, NiMH, Conrad Voltcraft
.DB 0x0C,0xA2
.DW 1700,6,0
.DB "VoltcrMH"
;
; Ende der Akkumulator Id-Definitionen
;