Akkulaufzeit berechnen

[Fritzler]

Für ein GSM Modul auf Akkubetrieb würde ich gerne die Akkulaufzeit berechnen.
Dabei kann ich per AT Befehl die Akkuspannung und und einen Prozentwert abfragen "percent of capacity remaining", also gehe ich mal davon aus, dass das einigermaßen linear ist?
Die Akkulaufzeit geht dabei durchaus in die Tage bei 1,1Ah/3,7V, soll aber nur in Stunden angezeigt werden.

Erster Gedanke:
Bei ausfallender Netzspannung die Uhrzeit und den Prozentwert merken.
Dann beim auslesen des momentanen Prozentwertes eine Gerade durch den Momentanen Prozentwert und den gespeicherten berechnen.
Daraus lassen sich dann die Stunden bis 5% Akku berechnen.

Zweiter Gedanke:
Genauso wie oben aber nur den ersten Wert merken und dann imemr eine Gerade durchziehen berehcnet doch sehr großzügig einen Durshcnitt.
Daher wird maximal ein Fenster von 5% Abstand der beiden PUnkte zugelassen zum berechnen.

Oder hat da wer ganz andere Ideen?
Von 0:40 Uhr bis 9:40 Uhr ist der Akkustand von 96% auf 91% gesunken

Noch etwas Dampf ablassen:
Welcher D*epp hat da eigentlich beim Programmieren der GSM Modul Firmware gepennt?
Nach dem Aufwecken des GSM Moduls soll man 50ms warten bis zum ersten AT Befehl, ich warte 70ms.
Aber ab und zu (unvorhersehbar) antwortet das GSM Modul wieder im Echo Modus, den ich eigentlich abgestellt hatte...

[uxlaxel]

GSM = nicht nachvollziehbar, wie oft das ding wirklich sendet. (netzauslastung, empfangsqualität, störungen)
weitere störende faktoren sind meines erachtens der meßfehler, die irgendwie (für mich nicht nachvollziehbare) errechnete restkapazität usw.
die akkus altern auch mit sicherheit und das vielleicht viel schneller, als du erwartest.

du kannst das also nur ausprobieren und auf deine erfahrung dann irgendwann vertrauen.

ist es nicht einfacher, bei einer akkuspannung X eine warnung zu senden?

lg axel

[ferdimh]

Ich stand vor einem vergleichbaren Problem bem Redesign von Notebookakkus (unter der Vorgabe, das Ladungszählerkonzept nicht zu benutzen, weil ich den Akku bei Nichtgebrauch wirklich tot schalten wollte).
Meine Lösung war,
1. Bei Konstantstromentladung eine Entladekurve aufnehmen (diese scheint für quasi alle LiIon-Zellen recht ähnlich zu verlaufen, unabhängig vom Alter)
2. Aus dieser eine Zuordnung Akkuspannung->Ladestand erstellen
3. Den Ladestand numerisch differenzieren
4. Glätten!!!!!
5. Aus dLadung/dt und Ladestand die verbleibende Zeit ausrechnen.

Ich habe auch irgendwo noch meine Lade/Entladekurven liegen als Inspirationshilfe. Muss ich nachher mal nach gucken.

[Fritzler]

Das Teil soll ja auch nur einen groben Richtwert anzeigen und GSM is nunmal so, daher habe ich jetzt auch erstmal Variante 2 einprogrammiert.

@ferdimh, kannste gerne mal zeigen, wenn Code existiert dann auch her damit .
Bei dir besteht dann aber das Problem der Akkualterung, dass die Kurve irgendwann nicht mehr stimmt?

Code: Alles auswählen

void akkulaufzeit(uint8_t prozente, uint32_t unixtime){

	static uint8_t arrayfill = 0;
	static struct akkupunkt mess0 = {255, 0};
	static struct akkupunkt mess1;
	static struct akkupunkt mess2;
	static struct akkupunkt	mess3;
	static struct akkupunkt *akkumesspunkte[4] = {&mess0, &mess1, &mess2, &mess3};
	
	//prozente == 255 resettet Akkulaufdauer
	if(255 == prozente){
		arrayfill = 0;
		akkumesspunkte[0]->akkufill = 255;
		return;
	}

	uint8_t nachsehwert = 0;
	if (arrayfill){
		nachsehwert = arrayfill-1;
	}

	if(prozente < akkumesspunkte[nachsehwert]->akkufill){
		if (4 == arrayfill){
			//wenn geringerer Prozentwert eintritt und Array voll 
			//-> Alle Werte eins vorrücken und neuen Wert einfügen
			struct akkupunkt *mess = akkumesspunkte[0];
			mess->akkufill = prozente;
			mess->unixtime = unixtime;
			akkumesspunkte[0] = akkumesspunkte[1];
			akkumesspunkte[1] = akkumesspunkte[2];
			akkumesspunkte[2] = akkumesspunkte[3];
			akkumesspunkte[3] = mess;
		}else{
			//wenn geringerer Prozentwert eintritt und Array nicht voll 
			//-> neuen Wert hinten einfügen 
			akkumesspunkte[arrayfill]->akkufill = prozente;
			akkumesspunkte[arrayfill]->unixtime = unixtime;
			arrayfill++;
		}
		
		//Array hat nur einen Wert -> Vorhersage nicht möglich
		if(1 == arrayfill){
			display_akku(999);
			return;
		}
		
		//Verhätlnisformel aus ersten und letztmöglich Wert
		uint32_t ist_p_fenster = akkumesspunkte[0]->akkufill - akkumesspunkte[arrayfill-1]->akkufill;
		uint32_t ist_t_fenster = akkumesspunkte[arrayfill-1]->unixtime - akkumesspunkte[0]->unixtime;
		uint32_t soll_p_fenster = akkumesspunkte[arrayfill-1]->akkufill - BATLEER;
		
		uint32_t laufseconds = (ist_t_fenster*soll_p_fenster)/ist_p_fenster;
		display_akku(laufseconds/(60*60));
	}
}

[ferdimh]

Mein Versuch über diverse Akkus gemittelt hat ergeben, dass neue und alte Zellen von der Form der Kurve recht ähnlich sind.
Dass die absolute Kapazität anders ist, ist am Ende egal, wenn du nur aus der Geschwindigkeit der Ladestandsänderung die Restlaufzeit extrapolierst.
Meine Implementierung geht am Ende einen Umweg, weil sie als Notebookakku noch eine absolute Kapazität nennen muss, aus der dann das Notebook die Kapazität errechnet.