; **************************************************************
; * Include-Datei fuer die UART-Kommandozeilen-Verarbeitung bei*
; * Akkuload (C)2005 by Gerh.Schmidt info@avr-asm-tutorial.net *
; **************************************************************
;
; Stellt die folgenden Routinen fuer die externe Verwendung bereit:
;
; Routine          Register Funktion
; --------------------------------------------------------------
; UartInit         rmp      Initiiere den UART-Empfaenger und
;                           Sender
; UartSendChar              Sendet das Zeichen in rmp ueber
;                           das UART
; UartSendOpenText rmp,R0,Z Sendet die Eroeffnungsmeldung beim
;                           Programmstart
; UartDec5         X,rmp    Sendet die Binaerzahl in R3:R2 in
; UartDec4                  Dezimalformat, R0>0: zeige
; UartDec3                  fuehrende Nullen an
; UartDec2
;
; UartSendN5       X,rmp    Sendet die Binaerzahl in R3:R2 in
; UartSendN4                Dezimalformat mit fester Laenge,
; UartSendN3                R0>0: zeigt fuehrende Nullen an
; UartSendN2
;
; UartHexB         rmp      Sendet das Hex Byte in rmp ueber das
;                           UART
; UartHex16        rmp,R0,Z Sendet 16 Bytes mit Adresse ab Z
;                           ueber das UART
; --------------------------------------------------------------
;
;
; Init UART
;
.EQU cUbrr = fClock/16/baud - 1 ; Baudratengenerator-Konstante
;
UartInit:
	ldi rmp,HIGH(cUbrr) ; Init UART Baudratengenerator
	out UBRRH,rmp
	ldi rmp,LOW(cUbrr)
	out UBRRL,rmp
	ldi rmp,(1<<RXEN)|(1<<TXEN) ; Enable RX und TX
	out UCSRB,rmp
	ldi rmp,(1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0) ; 8N1
	out UCSRC,rmp
	in rmp,UDR; Loesche Rx-Zeilenpuffer
	in rmp,UDR
	in rmp,UDR
	ldi rmp,LOW(sUartRxBs) ; Setze Pufferzeiger an Anfang
	sts sUartRxBp,rmp
	clr rmp ; Init aktuellen Kanal
	sts sUartCurCh,rmp
	clr rFlg ; Loesche Flag
	ldi rmp,(1<<RXEN)|(1<<TXEN)|(1<<RXCIE) ; RX-Interrupts
	out UCSRB,rmp
	clr rmp
	clr ZH
	clr ZL
UartInit1:
	sbiw ZL,1
	brne UartInit1
	dec rmp
	brne UartInit1
	ret
;
;
; **************** Subroutinen ********************************
;
; Sende das Zeichen in rmp an das UART
;
UartSendChar:
	sbis UCSRA,UDRE ; warte auf leeres Senderegister
	rjmp UartSendChar
	out UDR,rmp ; sende das Zeichen in rmp
	ret
;
; Sende den Text im Flash (Z zeigt darauf) an das UART
;
UartSendZ:
	lpm ; lese naechstes Zeichen aus dem Flash
	adiw ZL,1
	tst R0 ; Null-Zeichen?
	brne UartSendR0 ; Nein, sende
	ret
UartSendR0:
	mov rmp,R0 ; kopiere Zeichen
	rcall UartSendChar ; sende Zeichen
	rjmp UartSendZ ; naechstes Zeichen
;
; Sende Eroeffnungstext
;
UartSendOpenText:
	ldi ZH,HIGH(2*UartTxtOpening) ; Zeiger Z auf Text
	ldi ZL,LOW(2*UartTxtOpening)
	rcall UartSendZ ; Sende den Text ab Z
	lds R2,sEANm ; lese Anzahl der gespeicherten Akku-Id's
	clr R3
	clr R0
	rcall UartSendN2 ; sende Anzahl Id's
	ldi rmp,cCr ; Ende der Zeile
	rcall UartSendChar
	ldi rmp,cLf
	rjmp UartSendChar
;
; Subtrahiere wiederholt und sende Zeichen wenn R0>0
;
UartSubt:
	clr rmp ; Ergebnisregister
UartSubt1:
	sub R2,XL ; subtrahiere LSB
	sbc R3,XH ; subtrahiere MSB
	brcs UartSubt2
	inc rmp
	rjmp UartSubt1
UartSubt2:
	add R2,XL ; addiere wieder
	adc R3,XH
	add R0,rmp
	breq UartSubt3
	subi rmp,-'0' ; addiere ASCII-Null
	rcall UartSendChar
UartSubt3:
	ret
;
; Sende eine Biaerzahl ueber das UART, Zahl ist in R3:R2
;
UartSendNmbr:
	clr R0
UartDec5:
	ldi XH,HIGH(10000)
	ldi XL,LOW(10000)
	rcall UartSubt
UartDec4:
	ldi XH,HIGH(1000)
	ldi XL,LOW(1000)
	rcall UartSubt
UartDec3:
	clr XH
	ldi XL,100
	rcall UartSubt
UartDec2:
	clr XH
	ldi XL,10
	rcall UartSubt
	ldi rmp,'0'
	add rmp,R2
	rjmp UartSendChar
;
; Sende eine feste Anzahl Dezimalziffern
;
UartSubN:
	clr rmp ; Ergebnisregister
UartSubN1:
	sub R2,XL ; subtrahiere LSB
	sbc R3,XH ; subtrahiere MSB
	brcs UartSubN2
	inc rmp
	rjmp UartSubN1
UartSubN2:
	add R2,XL ; addiere wieder
	adc R3,XH
	add R0,rmp
	subi rmp,-'0' ; addiere ASCII-Null
	tst R0
	brne UartSubN3
	ldi rmp,' '
UartSubN3:
	rjmp UartSendChar
;
; Sende eine Zahl in R3:R2 mit fester Laenge
;
UartSendN5:
	ldi XH,HIGH(10000)
	ldi XL,LOW(10000)
	rcall UartSubN
UartSendN4:
	ldi XH,HIGH(1000)
	ldi XL,LOW(1000)
	rcall UartSubN
UartSendN3:
	clr XH
	ldi XL,100
	rcall UartSubN
UartSendN2:
	clr XH
	ldi XL,10
	rcall UartSubN
	ldi rmp,'0'
	add rmp,R2
	rjmp UartSendChar
;
; Sendet ein Byte in rmp in Hex ueber das UART
;
UartHexB:
	push rmp ; sichere Byte
	swap rmp
	rcall UartHexN
	pop rmp ; stelle Bye wieder her
UartHexN:
	andi rmp,0x0F
	cpi rmp,10
	brcs UartHexN1
	subi rmp,-7
UartHexN1:
	subi rmp,-'0'
	rjmp UartSendChar
;
; UartHex16 sendet 16 Bytes in Hex ab Z
;
UartHex16:
	mov rmp,ZH
	rcall UartHexB
	mov rmp,ZL
	rcall UartHexB
	ldi rmp,16
	mov R0,rmp
UartHex16a:
	ldi rmp,' ';
	rcall UartSendChar
	ld rmp,Z+
	rcall UartHexB
	dec R0
	brne UartHex16a
	ldi rmp,cCr
	rcall UartSendChar
	ldi rmp,cLf
	rcall UartSendChar
	rjmp UartSendCursor
;
; UART Kommandozeile bearbeitet, stelle RX-Puffer wieder her, sende Cursor
;
UartRxRet:
	ldi rmp,LOW(sUartRxBs) ; Setze Pufferzeiger auf Anfang
	sts sUartRxBp,rmp
	cbr rFlg,(1<<bUartRxLine) ; loesche Zeilenflagge
UartSendCursor:
	ldi rmp,'A' ; sende aktuellen Kanal
	rcall UartSendChar
	lds rmp,sUartCurCh
	subi rmp,-'1' ; addiere ASCII-Eins
	rcall UartSendChar
	ldi rmp,'>' ; sende Cursor
	rjmp UartSendChar
;
; Uebeliest fuehrende Nullen, Gleichheitszeichen, Anfuehrungszeichen und Komma
; kehrt mit gesetztem Carry zurueck und Fehlermeldung in Z zurueck, wenn
; vorzeitig das Ende der Zeile erreicht wird
;
UartSkipLeading:
	lds R1,sUartRxBp ; lese Ende der Eingabezeile
UartSkipLeading1:
	cp XL,R1
	brcs UartSkipLeading2 ; nicht am Ende
	ldi ZH,HIGH(2*UartTxtUnexEol) ; Fehl�rmeldung
	ldi ZL,LOW(2*UartTxtUnexEol)
	sec ; setze Carry
	ret
UartSkipLeading2:
	ld rmp,X+ ; lese Zeichen von der Zeile
	cpi rmp,'=' ; Gleichheitszeichen?
	breq UartSkipLeading1
	cpi rmp,',' ; Komma?
	breq UartSkipLeading1
	cpi rmp,' ' ; Leerzeichen?
	breq UartSkipLeading1
	cpi rmp,'"' ; Anfuehrungszeichen?
	breq UartSkipLeading1
	sbiw XL,1
	clc ; kein Ende der Zeile
	ret
;
; Hole naechste Ziffer einer Dezimalzahl, Carry gesetzt bei Zeilenende, Zero
; gesetzt bei Ende der Zahl
;
UartGetDigit:
	lds R1,sUartRxBp ; lese Ende der Eingabezeile
	cp XL,R1
	brcs UartGetDigit1 ; nicht am Ende
	ldi ZH,HIGH(2*UartTxtUnexEol) ; Fehlermeldung
	ldi ZL,LOW(2*UartTxtUnexEol)
	sec ; setze Carry
	ret
UartGetDigit1:
	ld rmp,X+ ; lese Ziffer
	cpi rmp,' ' ; Leerzeichen, Ende der Zahl?
	breq UartGetDigitEnd
	cpi rmp,cCr ; Ende der Zeile?
	breq UartGetDigitEnd
	cpi rmp,',' ; Komma?
	breq UartGetDigitEnd
	subi rmp,'0' ; mache Binarziffer
	brcs UartGetDigitIll
	cpi rmp,10 ; zu gross?
	brcc UartGetDigitIll
	clc ; alles ok
	clz
	ret
UartGetDigitIll:
	ldi ZH,HIGH(2*UartTxtNmbrErr) ; Ungueltiges Zeichen in der Zahl
	ldi ZL,LOW(2*UartTxtNmbrErr)
	sec ; setze Carry fuer Fehler
UartGetDigitEnd:
	ret
;
; Hole Dezimalzahl von der Empfangszeile
;
UartGetDec:
	rcall UartSkipLeading
	brcs UartGetDec3 ; Kehre mit gesetztem Carry zurueck, wenn Fehler
	clr R2 ; Resultat LSB
	clr R3 ; Resultat MSB
UartGetDec1:
	rcall UartGetDigit ; lese die naechst Ziffer
	brcs UartGetDec3 ; kehre mit gesetztem Carry zurueck, Fehler
	breq UartGetDec4 ; Ende der Zahl erreicht
	mov R0,R2 ; Kopiere Zwischenergebnis
	mov R1,R3
	add R2,R2 ; Ergebnis*2
	adc R3,R3
	brcs UartGetDec2 ; Zahlenueberlauf
	add R2,R2 ; Ergebnis*4
	adc R3,R3
	brcs UartGetDec2 ; Zahlenueberlauf
	add R2,R0 ; Ergebnis*5
	adc R3,R1
	brcs UartGetDec2 ; Zahlenueberlauf
	add R2,R2 ; Ergebnis*10
	adc R3,R3
	brcs UartGetDec2 ; Zalenueberlauf
	add R2,rmp ; addiere Ziffer
	ldi rmp,0
	adc R3,rmp
	brcc UartGetDec1 ; Kein Zahlenueberlauf, naechste Ziffer
UartGetDec2:
	ldi ZH,HIGH(2*UartTxtNmbrOvf) ; Zahlenueberlauf
	ldi ZL,LOW(2*UartTxtNmbrOvf)
	sec ; Carry setzen
UartGetDec3: ; Zahlenfehler
	ret
UartGetDec4: ; Zahl ist ok und komplett
	clc ; Carry loeschen
	ret
;
; ****************** Empfangszeile **********************
;
; Eine vollstaendge Emfangszeile empfangen, antworte
;
UartRxLine:
	ldi rmp,LOW(UartRxRet) ; Rueckkehradresse UartRxRet auf Stapel
	push rmp
	ldi rmp,HIGH(UartRxRet)
	push rmp
	ldi ZH,HIGH(2*UartCmds) ; Z zeigt auf Befehlsliste
	ldi ZL,LOW(2*UartCmds)
UartRxLine1:
	lpm ; Ende der Befehlsliste?
	mov rmp,R0 ; FF signalisiert Ende der Liste
	cpi rmp,0xFF
	brne UartRxLine3
UartRxLine2: ; Ende der Befehlsliste, unbekannter Befehl
	ldi ZH,HIGH(2*UartTxtUnkCmd) ; Sende Fehlermeldung
	ldi ZL,LOW(2*UartTxtUnkCmd)
	rjmp UartSendZ
UartRxLine3: ; beginne Vergleich
	ldi XH,HIGH(sUartRxBs) ; X auf emfangene Zeile
	ldi XL,LOW(sUartRxBs)
UartRxLine4:
	lds rmp,sUartRxBp ; Pufferzeiger lesen
	cp XL,rmp ; Ende des Puffers erreicht?
	brcs UartRxLine7 ; nein, weiter
UartRxLine5: ; ueberspringe diesen Befehl, gehe zum naechsten
	lpm ; lese naechstes Befehlszeichen
	adiw ZL,1 ; Z auf naechstes Zeichen
	mov rmp,R0 ; Endezeichen fuer Befehl?
	cpi rmp,'#' ; Endzeichen erreicht?
	brne UartRxLine5 ; nein
	lpm ; Ist das naechste Zeichen ein Leerzeichen?
	mov rmp,R0
	cpi rmp,' '
	brne UartRxLine6 ; nein
	adiw ZL,1
UartRxLine6:
	adiw ZL,7 ; springe ueber die Adressen
	rjmp UartRxLine1 ; naechster Befehl
UartRxLine7:
	lpm ; lese Zeichen aus Flash
	mov rmp,R0 ; kopiere
	cpi rmp,'#' ; Ende des Befehls?
	breq UartRxLine8 ; ja
	ld rmp,X+ ; lese naechstes Zeichen aus Puffer
	sbr rmp,0x20 ; in Kleinbuchstabe
	cp rmp,R0 ; Vergleich des Zeichens
	brne UartRxLine5 ; nicht gleich, springe zum naechsten Befehl
	adiw ZL,1 ; naechstes Zeichen
	rjmp UartRxLine4 ; naechstes Zeichen im Puffer pruefen
UartRxLine8:
	adiw ZL,1 ; Leerzeichen hinter #?
	lpm
	mov rmp,R0
	cpi rmp,' '
	brne UartRxLine9 ; nein
	adiw ZL,1 ; ja
UartRxLine9:
	lds rmp,sUartRxBp ; Ende des Puffers erreicht?
	cpc XL,rmp
	brcc UartRxLine2
	ld rmp,X+ ; lese naechstes Zeichen aus Puffer
	cpi rmp,cCr ; Ende der Zeile?
	brne UartRxLine10 ; mit Parameter
	; Befehl ohne Parameter
	adiw ZL,5 ; Zeige Z auf Addresse
	lpm ; lese LSB
	push R0 ; auf Stapel
	adiw ZL,1 ; lese MSB
	lpm
	push R0 ; auf Stapel
	clc ; keine Parameter
	ret ; springe zum Befehl
UartRxLine10: ; Befehlszeile mit Parameter
	cpi rmp,'=' ; Parameter?
	brne UartRxLine5 ; Nein, suche naechsten Befehl
	lpm ; lese Anzahl Parameter
	tst R0
	brne UartRxLine11 ; Befehl hat Parameter
	ldi ZH,HIGH(2*UartTxtParaErr) ; Fehlermeldung
	ldi ZL,LOW(2*UartTxtParaErr)
	rjmp UartSendZ
UartRxLine11: ; Kommadozeilenparameter
	rcall UartGetDec ; hole Dezimalzahl
	brcc UartRxLine17 ; Zahl ist ok
	rjmp UartSendZ ; Fehlermeldung
UartRxLine17:
	adiw ZL,1 ; lese LSB minimum Parameter
	lpm
	adiw ZL,1
	cp R2,R0 ; vergleiche LSB
	lpm ; lese MSB minimum Parameter
	cpc R3,R0 ; vergleiche MB
	brcs UartRxLine18
	adiw ZL,1 ; lese LSB maximum Parameter
	lpm
	adiw ZL,1
	sec ; Setze Carry fuer Max+1
	cpc R2,R0 ; vergleiche LSB
	lpm ; lese MSB max Parameter
	cpc R3,R0 ; vergleiche MSB
	brcs UartRxLine19 ; Zahl ist ok
UartRxLine18: ; Zahl au�rhalb des zulaessigen Bereichs
	ldi ZH,HIGH(2*UartTxtNmbrOor)
	ldi ZL,LOW(2*UartTxtNmbrOor)
	rjmp UartSendZ
UartRxLine19: ; lese Adresse und springe
	adiw ZL,1 ; lese LSB
	lpm
	push R0 ; LSB auf Stapel
	adiw ZL,1 ; lese MSB
	lpm
	push R0 ; MSB auf Stapel
	sec ; setze Carry, Parameter
	ret ; springe an Befehlsadresse
;
; ***************** Befehle *********************************
;
; UART-Befehl HILFE
;
UartHelp:
	ldi ZH,HIGH(2*UartTxtHelp) ; Hilfetext
	ldi ZL,LOW(2*UartTxtHelp)
	rjmp UartSendZ
;
; UART-Befehl RESTART
;
UartRestart:
	pop rmp ; Loesche Ruecksprungadresse
	pop rmp
	jmp 0 ; starte neu
;
; UART-Befehl Kanal
;
UartChannel:
	brcc UartChannel1
	dec R2
	sts sUartCurCh,R2
UartChannel1: ; gib aktuellen Kanal aus
	ldi ZH,HIGH(2*UartTxtCurrCh)
	ldi ZL,LOW(2*UartTxtCurrCh)
	rcall UartSendZ
	lds rmp,sUartCurCh ; lese aktuellen Kanal
	subi rmp,-'1' ; addiere ASCII-Eins
	rcall UartSendChar
	adiw ZL,1 ; vervollstaendige Ausgabe
	rjmp UartSendZ
;
; Holt die aktuelle Akku-Id-Adresse des Kanals
;
UartGetAkkuId:
	ldi ZH,HIGH(sAdcAI1) ; Z auf Akku-Id 1
	ldi ZL,LOW(sAdcAI1)
	lds rmp,sUartCurCh
	add ZL,rmp
	add ZL,rmp
	ret
;
; Setze die Akku-Id des aktuellen Kanals
;
UartAkkuId:
	brcc UartAkkuId1
	rcall UartGetAkkuId
	st Z,R2
	lds R0,sUartCurCh
	call IdSetPar
UartAkkuId1:
	ldi ZH,HIGH(2*UartTxtAkkuId)
	ldi ZL,LOW(2*UartTxtAkkuId)
	rcall UartSendZ
	rcall UartGetAkkuId
	ld R2,Z
	clr R3
	clr R0
	rcall UartDec2
	ldi rmp,cCr
	rcall UartSendChar
	ldi rmp,cLf
	rcall UartSendChar
	rjmp UartOutSettings
;
; Zeiger rmp auf das Entladebit
;
UartUnloadBit:
	lds R0,sUartCurCh
	ldi rmp,0x10
UartUnloadBit1:
	tst R0
	breq UartUnloadBit2
	lsl rmp
	dec R0
	rjmp UartUnloadBit1
UartUnloadBit2:
;
; Zeige mit X auf das PWM-Register
;
UartChannX:
	clr XH ; Zeiger MSB is Null
	ldi XL,cPwm1S ; LSB auf LSB der PWM von Kanal Eins
	lds R0,sUartCurCh ; addiere Kanal
	add XL,R0
	ret
;
; Aktuelle UART Parameteradresse in X
;
UartGetChPar:
	lds R1,sUartCurCh ; lese Kanal
	lsl R1 ; *2
	lsl R1 ; *4
	lsl R1 ; *8
	ldi XH,HIGH(sCh1UV) ; Basisaddresse Entladespannung
	ldi XL,LOW(sCh1UV)
	add XL,R1 ; addieren
	brcc UartGetChPar1
	inc XH
UartGetChPar1:
	ret
;
; Hole Adresse des Kanalstatus-Textes in Z
;
UartGetChAct:
	ldi ZH,HIGH(2*UartTxtAct)
	ldi ZL,LOW(2*UartTxtAct)
	lds R1,sUartCurCh ; aktueller Kanal
	lds rmp,sState ; Kanalstatus
UartGetChAct1:
	tst R1
	breq UartGetChAct2
	lsr rmp
	lsr rmp
	dec R1
	rjmp UartGetChAct1
UartGetChAct2:
	andi rmp,0x03 ; isoliere Bits
	breq UartGetChAct4
UartGetChAct3:
	lpm
	adiw ZL,1
	tst R0
	brne UartGetChAct3
	dec rmp
	rjmp UartGetChAct2
UartGetChAct4:
	ret
;
; Setze die Entladespannung
;
UartSetU:
	brcc UartSetU1
	rcall UartGetChPar ; Adresse in X
	st X+,R2 ; speichere Parameter dort
	st X,R3
UartSetU1:
	rjmp UartOutSettings
;
; Setze den Ladestrom dieses Kanals
;
UartSetI:
	brcc UartSetI1
	rcall UartGetChPar ; Adresse in X
	adiw XL,2 ; Ladestrom ist der zweite Parameter
	st X+,R2 ; speichere die empfangene Zahl dort
	st X,R3
UartSetI1:
	rjmp UartOutSettings
;
; Setze die Kapazitaet
;
UartSetW:
	brcc UartSetW1 ; kein Parameter angegeben
	rcall UartGetChPar ; hole Adresse in X
	adiw XL,4 ; Kapazitaet ist der dritte Parameter
	st X+,R2 ; speichern der empfangenen Zahl
	st X,R3
UartSetW1:
	rjmp UartOutSettings
;
; Setze den Erhaltungsstrom
;
UartSetM:
	brcc UartSetM1
	rcall UartGetChPar ; Adresse in X
	adiw XL,6 ; vierte Variable
	st X+,R2 ; speichern des Parameters
	st X,R3
UartSetM1:
	rjmp UartOutSettings
;
; Setze den Status auf den Wert in rmp
; Anfang: rmp Bit 1 und 0 = Aktivitaetsflags
;
UartSetState:
	lds R0,sUartCurCh ; Kanal nach R0
	lds R2,sState ; statusbits nach R2
	mov R3,rmp ; OR-Maske in R3 speichern
	ldi rmp,0xFC ; Maske fuer AND erstellen
	mov R1,rmp
	mov rmp,R3 ; Original wieder herstellen
UartSetState1:
	tst R0 ; Kanal erreicht?
	breq UartSetState2
	sec ; naechste Kanal
	rol R1
	sec
	rol R1
	lsl rmp ; Soll-Statusbits zwei links schieben
	lsl rmp
	lsr R2 ; Ist-Status-Bits zwei rechts
	lsr R2
	dec R0
	rjmp UartSetState1
UartSetState2:
	lds R0,sState
	and R0,R1 ; beide Bits loeschen 
	or R0,rmp ; neue Bts setzen
	sts sState,R0
	mov rmp,R2 ; vorherigen Status pruefen 
	andi rmp,0x03 ; isoliere Statusbits
	cp rmp,R3 ; Status veraendert?
	breq UartSetState4 ; nein, ueberspringe Korrektur
	lds R0,sUartCurCh ; R0 ist aktueller Kanal
	cpi rmp,0x02 ; vorher im Ladezustand?
	brne UartSetState3 ; inaktiv, Entladen oder Erhaltungsladen
	call EpStore ; geladene Kapazitaet im EEPROM speichern
	sec
UartSetState3: ; loesche akkumulierte Kapazitaet, wenn inaktiv oder Laden
	call ClearCap ; Kapazitaet in Kanal R0 loeschen
UartSetState4:
	rjmp UartOutSettings
;
; Setze Statusbits auf AUS
;
UartClear:
	ldi rmp,0x00
	rjmp UartSetState
;
; Setze das Entladebit und loesche die PWM
;
UartUnload:
	rcall UartUnloadBit
	or rPwmOut,rmp
	clr rmp
	st X,rmp
	ldi ZH,HIGH(2*UartTxtUnload)
	ldi ZL,LOW(2*UartTxtUnload)
	rcall UartSendZ
	ldi rmp,0x01 ; Entladeflagge
	rjmp UartSetState
;
; Statusbits auf Erhaltungsladung
;
UartMaint:
	ldi rmp,0x03
	rjmp UartSetState
;
; Starte Ladevorgang
;
UartLoad:
	ldi rmp,0x02
	rjmp UartSetState
;
; Gib alle Einstellungen im Kanal auf dem UART aus
;
UartOutSettings:
	ldi rmp,4 ; R4 ist Zaehler
	mov R4,rmp
	ldi ZH,HIGH(2*UartTxtSettings)
	ldi ZL,LOW(2*UartTxtSettings)
	rcall UartSendZ
	lds R1,sUartCurCh
	ldi rmp,'1'
	add rmp,R1
	rcall UartSendChar
	rcall UartSendZ
	ldi XH,HIGH(sAdcAI1) ; Schreibe Id
	ldi XL,LOW(sAdcAI1)
	lds rmp,sUartCurCh
	add XL,rmp
	add XL,rmp
	ld R2,X
	clr R3
	rcall UartSendNmbr
	rcall UartSendZ
	push ZH
	push ZL
	rcall UartGetChAct ; schreibe Statustext
	rcall UartSendZ
	pop ZL
	pop ZH
	rcall UartSendZ
	rcall UartGetChPar ; schreibe alle Parameter
UartOutSettings1:
	ld R2,X+
	ld R3,X+
	push XH
	push XL
	rcall UartSendNmbr
	rcall UartSendZ
	pop XL
	pop XH
	dec R4
	brne UartOutSettings1
	ret
;
; Texte fuer die Ausgabe der Einstellungen
;
UartTxtSettings:
.DB "Ch ",0
.DB ": Id=",0
.DB ", Status=",0
.DB ", U= ",0
.DB "mV, I= ",0
.DB "mA, C= ",0
.DB "mAh, Im= ",0
.DB "mA",$0D,$0A,$00,$00
;
; Aktivitaetsstatus des Kanals
;
UartTxtAct:
.DB "abgeschaltet ",0
.DB "Entladen ",0
.DB "Laden",0
.DB "Erhaltung",0
;
; Schalte Monitoring um
;
UartMoniOn:
	ldi rmp,1<<bUMoni ; Moniflag-Maske
	eor rFlgD,rmp ; umschalten
	ldi ZH,HIGH(2*UartTxtMoniOff) ; Monitor aus ausgeben
	ldi ZL,LOW(2*UartTxtMoniOff)
	sbrs rFlgD,bUMoni
	rjmp UartMoniOn1
	ldi ZH,HIGH(2*UartTxtMoniOn) ; Monitor an ausgeben
	ldi ZL,LOW(2*UartTxtMoniOn)
	rcall UartSendZ
	rjmp DispTimeUd ; Systemzeit ueber UART ausgeben
UartMoniOn1: ; Monitoring umgeschaltet
	rjmp UartSendZ
;
; Setze die PWM eines Kanals
;
UartPwm:
	brcc UartPwm1
	rcall UartUnloadBit
	st X,R2 ; setze aktuellen Kanalwert
	com rmp 
	and rPwmOut,rmp ; PWM-Ausgabe setzen
UartPwm1:
	ldi ZH,HIGH(2*UartTxtPwm) ; Text fuer PEWM-Ausgabe
	ldi ZL,LOW(2*UartTxtPwm)
	rcall UartSendZ
	rcall UartUnloadBit ; Entladebit lesen
	ld R2,X
	clr R3
	rcall UartSendNmbr
	adiw ZL,1
	rjmp UartSendZ
;
; Neue Akku-Id erzeugen
;
UartNew:
	brcs UartNew2 ; erster parameter ok
	ldi ZH,HIGH(2*UartTxtNewParamErr) ; Parameterfehler
	ldi ZL,LOW(2*UartTxtNewParamErr)
UartNew1: ; Fehlermeldung in Z
	rjmp UartSendZ
UartNew2:
	lds rmp,sEANm ; Anzahl an Id's lesen
	cpi rmp,cEepMax+1 ; mt Maximalzahl vergleichen
	brcc UartNew8 ; zu viele Id's
	ldi ZH,HIGH(sEAId) ; Z auf Puffer setzen
	ldi ZL,LOW(sEAId)
	lds rmp,sEANm ; Zahl der Id's lesen
	inc rmp ; naechste Akku-Id
	st Z,rmp ; in Puffer
	adiw ZL,2 ; zeige auf Kapazitaet
	st Z+,R2 ; Kapazitaet in R3:R2 in Puffer
	st Z,R3
	sbiw ZL,2 ; auf Akkutyp zeigen
	rcall UartGetDec ; Groesze aus Zeile lesen
	brcs UartNew1 ; Fehler
	tst R3 ; Groesze pruefen
	brne UartNew3 ; MSB>0, falsch
	mov rmp,R2
	cpi rmp,4 ; Groesze kleiner 4?
	brcs UartNew4 ; ja, ok
UartNew3: ; falsche Groesze
	ldi ZH,HIGH(2*UartTxtNewSize) ; Fehlermeldung
	ldi ZL,LOW(2*UartTxtNewSize)
	rjmp UartSendZ
UartNew4:
	subi rmp,-0xA0 ; A0 zu Groesze addieren $$!!$$
	st Z,rmp ; Groesze speichern
	adiw ZL,3 ; auf Anzahl Ladevorgaenge zeigen
	rcall UartGetDec ; Anzahl Ladevorgaenge aus Zeile
	brcs UartNew1 ; Fehler
	st Z+,R2 ; in Puffer speichern
	st Z+,R3
	clr rmp
	st Z+,rmp ; Restkapazitaet loeschen
	st Z+,rmp
	rcall UartSkipLeading ; ueber Trennzeichen hinweglesen
	brcs UartNew1 ; Fehler
	ldi rmp,8 ; 8 Byte Text lesen
	mov R0,rmp
UartNew5:
	ld rmp,X+ ; lese Textzeichen
	cpi rmp,'"' ; Ende des Texts?
	breq UartNew6 ; ja
	cpi rmp,cCr ; Ende der Zeile?
	breq UartNew6 ; ja
	st Z+,rmp ; Zeichen in Puffer speichern
	dec R0 ; Zeichenzaehler
	brne UartNew5 ; naechstes Zeichen
	rjmp UartNew7 ; Rest ueberlesen
UartNew6:
	tst R0 ; Anzahl Zeichen auf 8 auffuellen
	breq UartNew7
	ldi rmp,' '
	st Z+,rmp
	dec R0
	rjmp UartNew6
UartNew7:
	call EpWrite ; Puffer ins EEPROM schreiben
	lds rmp,sEANm ; Anzahl Id's erhoehen
	inc rmp
	sts sEANm,rmp ; und speichern
	ldi ZH,HIGH(2*UartTxtList) ; Header
	ldi ZL,LOW(2*UartTxtList)
	rcall UartSendZ
	lds rmp,sEAId ; Anzahl Id's ausgeben
	rjmp UartList1
UartNew8: ; Fehler zu viele Id's
	ldi ZH,HIGH(2*UartTxtNewMany)
	ldi ZL,LOW(2*UartTxtNewMany)
	rjmp UartSendZ
;
; Auflisten der gespecherten Akku-Id's
;
UartList:
	ldi ZH,HIGH(2*UartTxtList) ; Header
	ldi ZL,LOW(2*UartTxtList)
	rcall UartSendZ
	clr R6 ; R6 ist Zaehler
UartList1:
	inc R6
	lds R0,sEANm ; lese Anzahl Id's
	sec
	cpc R6,R0 ; Ende der Liste?
	brcc UartList3
	mov rmp,R6
	call EpRead ; Id in rmp aus EEPROM lesen
	ldi ZH,HIGH(sEAId) ; Z auf Puffer
	ldi ZL,LOW(sEAId)
	ld R2,Z+ ; kopiere Id-Nummer
	clr R3
	clr R0
	rcall UartSendN2
	ldi rmp,' '
	rcall UartSendChar
	ld rmp,Z+ ; Schreibe Akkugroesze
	rcall UartHexB
	ldi rmp,' '
	rcall UartSendChar
	ld R2,Z+ ; Schreibe Nennkapazitaet
	ld R3,Z+
	clr R0
	rcall UartSendN5
	ldi rmp,' '
	rcall UartSendChar
	ld R2,Z+ ; Schreibe Anzahl Volladungen
	ld R3,Z+
	clr R0
	rcall UartSendN5
	ldi rmp,' '
	rcall UartSendChar
	ld R2,Z+ ; Schreibe Restkapazitaet
	ld R3,Z+
	clr R0
	rcall UartSendN5
	ldi rmp,' '
	rcall UartSendChar
	ldi rmp,8
	mov R1,rmp
UartList2:
	ld rmp,Z+ ; Lese Text
	rcall UartSendChar
	dec R1
	brne UartList2
	ldi rmp,cCr
	rcall UartSendChar
	ldi rmp,cLf
	rcall UartSendChar
	rjmp UartList1 ; und weiter
UartList3:
	ret
;
; ***************** Tabellen ************************
;
; Befehle, Parameter und Adresstabelle fuer UART-Befehle
;
UartCmds:
.DB "hilfe# ",0 ; HILFE.-Befehl, keine Parameter
.DW 0,0,UartHelp
.DB "a# ",1 ; Akku Kanalwahl
.DW 1,4,UartChannel
.DB "n# ",1 ; Akku-Id
.DW 0,32,UartAkkuId
.DB "u# ",1 ; Entlade-Abschaltspannung
.DW 700,1200,UartSetU
.DB "i# ",1 ; Ladestrom  in mA
.DW 5,350,UartSetI
.DB "c# ",1 ; Kapazitaet in mAh
.DW 10,2500,UartSetW
.DB "m# ",1 ; Erhaltungsstrom in mA
.DW 5,100,UartSetM
.DB "aus# ",0 ; Kanal abschalten
.DW 0,0,UartClear
.DB "entladen#",0 ; Entladen
.DW 0,0,UartUnload
.DB "laden# ",0 ; Laden
.DW 0,0,UartLoad
.DB "erhalten#",0 ; Erhalten
.DW 0,0,UartMaint
.DB "monitor# ",0 ; Monitor ein/aus
.DW 0,0,UartMoniOn
.DB "pwm# ",1 ; PWM-Wert setzen
.DW 0,255,UartPwm
.DB "neu# ",1 ; neue Akku-Id erzeugen
.DW 100,9000,UartNew
.DB "liste# ",0 ; Liste der gespeicherten Akkus
.DW 0,0,UartList
.DB "neustart#",0 ; RESTART-Befehl, keine Parameter
.DW 0,0,UartRestart
.DW $FFFF ; Ende der Befehlsliste
;
; UART Texte
;
UartTxtHelp:
.DB "Akkuload Befehlsliste:",$0D,$0A
.DB "<hilfe>, kein param: diese Liste. ",$0D,$0A
.DB "<a> oder <a=x>, param x (1..4): lese/setze Kanalnummer. ",$0D,$0A
.DB "<n> oder <n=x>, param x (1..32): lese/setze Akku-Id.",$0D,$0A
.DB "<u> oder <u=x>, param x (700..1200): lese/setze Entladespannung.",$0D,$0A
.DB "<i> oder <i=x>, param x (5..175): lese/setze Ladestrom in mA. ",$0D,$0A
.DB "<c> oder <c=x>, param x (10..9999): lese/setze Kapazitaet in mAh. ",$0D,$0A
.DB "<m> oder <m=x>, param x (5..100): lese/setze Erhaltungsstrom in mA",$0D,$0A
.DB "<aus>, kein param: schalte Kanal ab.",$0D,$0A
.DB "<entlade>, kein param: schalte Entladen ein.",$0D,$0A
.DB "<lade>, kein param: starte laden. ",$0D,$0A
.DB "<erhalten>, kein param: schalte Erhaltungsladung ein. ",$0D,$0A
.DB "<monitor>, kein param: schalte monitoring ein/aus.",$0D,$0A
.DB "<pwm> oder <pwm=x>, param x (0..255): setze PWM-Wert. ",$0D,$0A
.DB "<neu=Kapazitaet, Groesze, Ladungen, Text> erzeugt neue Id,",$0D,$0A
.DB "   Kapazitaet 100..9000, Groesze 0..3, Ladungen 0..65535, Text frei.",$0D,$0A
.DB "<liste>, kein param: Liste aller gespeicherten Akku-Id's. ",$0D,$0A
.DB "<neustart>, kein param: Neustart des Controllers.",$0D,$0A,$00
;
UartTxtOpening:
.DB "                                              "
.DB $0C,$0C,$0D,$0A
.DB "Akkulader (C)2005 by info@avr-asm-tutorial.net",$0D,$0A
.DB "----------------------------------------------",$0D,$0A
.DB "Gespeicherte Akku-Id's : ",$00
.DB "Gib 'hilfe' <RETURN> fuer Menue ein.",$0D,$0A
;
UartTxtUnkCmd:
.DB "Unbekannter Befehl!",$0D,$0A,$00
;
UartTxtParaErr:
.DB "Befehl hat keine Parameter!",$0D,$0A,$00
;
UartTxtUnexEol:
.DB "Unerwartetes Ende der Zeile! ",$0D,$0A,$00
;
UartTxtNmbrErr:
.DB "Unzulaessiges Zeichen in Zahl! ",$0D,$0A,$00
;
UartTxtNmbrOvf:
.DB "Zahlenueberlauf! ",$0D,$0A,$00
;
UartTxtNmbrOor:
.DB "Zahl ausserhalb des zulaessigen Bereichs!",$0D,$0A,$00
;
UartTxtCurrCh:
.DB "Derzeitiger Akkukanal ist : ",$00,$20
.DB " ",$0D,$0A,$00
;
UartTxtPwm:
.DB "Derzeitiger PWM-Wert ist : ",$00
.DB " ",$0D,$0A,$00
;
UartTxtUnload:
.DB "Entladen eingeschaltet.",$0D,$0A,$00
;
UartTxtMoniOff:
.DB "Monitoring ist aus.",$0D,$0A,$00
;
UartTxtMoniOn:
.DB "Monitoring ist an. ",$0D,$0A,$00
;
UartTxtList:
.DB "Id Gr Kapaz Ladg. _Rest Text____",$0D,$0A,$00,$00
;
UartTxtAkkuId:
.DB "Aktuelle Id ist ",$00,$00
;
UartTxtNewParamErr:
.DB "Vermisse alle Parameter! ",$0D,$0A,$00
;
UartTxtNewSize:
.DB "Ungueltige Groesze!",$0D,$0A,$00
;
UartTxtNewMany:
.DB "Zu viele Akku-Id's! ",$0D,$0A,$00,$00
;
;
; Ende der UART-Include-Datei
;