Batteriefüllstand ermitteln (bei Battery Shield)

Hallo, ich nutze das Batery Shield mit zwei 18650 3.7 V je 6800mAh Batterien, nun suche ich nach einer Möglichkeit zu ermitteln wann die Batterien dem ende zugehen, hat da schon jemand erfahrung gemacht? das ganze sollte mitteld dem Arduino an einem Digitalen Pin alle 5 Minueten geprüft werden. muss ich da Hardware mässig noch etwas verbauen? Danke für Eure Ideen und lösungsansätze

Schau mal hier.

Das geht aber nur über einen Analogeingang.

Wenn das Wemos Shield gemeint ist, dann kann ich sagen das die messung über einen Analog Input nicht geht.
Habe ich selbst versucht und getestet, bin aber gescheitert.

Der Step Up Wandler bringt zu viele Störungen mit.

Da die Änderung der Batteriespannung ja sehr langsam erfolgt, kann man ja hier einen Tiefpassfilter zwischenschalten. Z.b. 2 * 100 kOhm und 100 uF Elko. Das sollte die Störungen gut ausfiltern

Hallo, Danke für deinen Lösungsansatz, hast du mir noch ein Shema der Verdrahtung? und was für Mosfets ich verwenden muss. Danke

Ja, bin im Moment nicht zu Hause. Wenn ich wieder zu Hause bin, schicke ich dir Schaltung und überarbeiteten Code. Da wird die Messung durch Glättung ( Mittelwertbildung) genauer.

Hallo Thoma,

könntest Du die Schaltung und den Code hier einstellen, daran hätte ich Interesse…

Vielen Dank

Ja, Werd ich machen.

So, Hier erst mal der Code. Über #define AiO legst du fest ob er für den Tonuino Klassic oder die AiO benutzt werden soll.

Code Batterieüberwachung für Tonuino Klassic und Tonuino AiO

// Am Codeanfang bei den Definitionen


// ------------------- Überwachung der Batteriespannung --- TonUINO Classic und AiO ------------------------------------------------
#define BattControl           // Bei AiO muss die Lötbrücke SJ1 geschlossen werden und das modifizierte BSP LGT8FX
                              // mit Unterstützung des AnalogPin A10 installiert werden.
                              // Auf R17 einen 220 kOhm smd Widerstand huckepack auflöten, oder R17 durch einen 65 kOhm
                              // smd Widerstand ersetzen.(Erweiterter Spannungsmessbereich bis 5 V)
                              // Kann beim Classic nur im 3 Tasten-Modus verwendet werden, da AnalogPin A4 im 5 Tastenmodus belegt ist.
                              // Wenn ein anderer Analogpin frei zur Nutzung ist, kann dieser für BattControl verwendet werden.
                              // Vor den BattControlPin einen 100kOhm Widerstand in Reihe schalten (Classic).
//            ___________________________________________________________________________________
  // Festlegung der Spannungswerte für die Batterieüberwachung. Kann hier angepasst werden.

 #ifdef BattControl           // Die Akkuspannung wird überwacht
                              // Hardwareerweiterung erforderlich (Batteriespannung muss bei ausgeschaltetem Tonuino
                              // vom Eingang des Arduino getrennt sein. (Nur TonUINO Classic,MosFet oder Relais)
                              // bei Unterschreiten des BtSchw - Wertes wird eine Warnung ausgegeben
                              // bei Erreichen des BtLeer - Wertes wird der Tonuino ausgeschaltet.
                              // Vor Abschalten erfolgt ein Ausfaden der Lautstärke über 20 Sekunden.
                              // Davon unabhängig schaltet die AiO bei Unterschreiten von 2,8 V über Hardware aus.
                              
  #ifndef AiO                 // TonUINO Classic , Werte gelten für Betrieb mit LiPo und LiIon Akku
  const float BtSchw = 3.2 ;  // Spannungswert für Warnung
  const float BtLeer = 3.0 ;  // Spannungswert für automatische Abschaltung über Software ShutDown.
   #define Bandgap 1104000L   
  #endif                      

  #ifdef AiO                  // AiO, Werte gelten für Betrieb mit LiFePO4 Akku.
  const float BtSchw = 2.95 ; // Spannungswert für Warnung
  const float BtLeer = 2.90 ; // Spannungswert für automatische Abschaltung über Software ShutDown.
  const float correction = 2.495 ; // Korrekturwert für Spannungsteiler (Anpassung der Anzeige an die tatsächliche Batteriespannung)
  #endif                      
 #endif
// ------------------------------------------------------------------------------------------------------------------------------------

#ifndef AiO			  // Pindeklaration für Klassic
#ifdef BattControl
#define VControlPin A4            // Kontrollpin für Batterieüberwachung 
                                  // (Umdeklarierbar, wenn ein anderer Analogpin bei Nichtnutzung frei wird.)
#endif
#endif


#ifdef AiO			  // Pindeklaration für AiO
#ifdef BattControl
#define VControlPin A10           // Kontrollpin für Batterieüberwachung (über Lötbrücke SJ-1 auf AiO Platine verbinden)
#endif
#endif

// ---------------------- Batterieüberwachung ------------------
#ifdef BattControl
#ifdef AiO
const float reference = 2.048;                  // Referenzspannung AiO
const float steps = 4064;                       // Auflösung ADU
#endif

#ifndef AiO
float u_reference = 0.00 ;                      // Referenzspannung TonUINO Klassic wird durch interne Messung ermittelt
#endif

float Vbatt = 3.40;                             // Batteriespannung (Wird bei der Messung auf aktuellen Wert gesetzt)

float VbattGl = 3.20;                           // Geglättete Batteriespannung aus 60 Einzelmessungen,Voreinstellung 3,2V AiO
                                                // Geglättete Batteriespannung aus 10 Einzelmessungen , Classic

const float Vwarning = BtSchw;                  // Voltzahl für Warnung Batteriespannung, bei den #defines festgelegt
const float Vshutdown = BtLeer;                 // Voltzahl für Shutdown, Batterie leer, bei den #defines festgelegt

#ifndef AiO
unsigned long TestIntervall = 6000;             // Testintervall Batterie ,Klassic: 6 Sekunden
#endif
#ifdef AiO
unsigned long TestIntervall = 1000;             // Testintervall Batterie  ,   AiO: 1 Sekunde
#endif

uint8_t countTi = 0;                            // Anzahl der Testintervalle
uint32_t SumValue = 0;                          // Summe der Sensorwerte aller  Testintervalle 

unsigned long Now = 0;                          // millis() im Moment des Auslesens der Batteriespannung
unsigned long lastTest = 0;                     // Zeitpunkt letzte Prüfung der Batteriespannung

bool BattLeer = false;                          // Marker, leere Batterie erkannt, Voreinstellung Nein

#endif  //BattControl


// Ende der Deklarationen für Batteriekontrolle



// Funktionen

// ************************* Spannungsüberwachung der Batterie *********************************

#ifdef BattControl
#ifndef AiO                           // TonUINO Classic
// ************* Funktion zur Ermittlung der genauen Referenzspannung ****************

long readVcc()
{
  long result;
  ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
  delay(2);                // eventuell Zeit verlängern auf 10 ms
  ADCSRA |= _BV(ADSC);
  while (bit_is_set(ADCSRA, ADSC));
  result = ADCL;
  result |= ADCH << 8;
  result = Bandgap / result;       // 1126400L Bandgapspannung
  return result;
}
#endif  // Ende #ifndef AiO

// ************** Batteriespannung in % *** AiO **************************************************

#ifdef AiO  
  uint16_t getBatteryPercent() 
  {      
  int16_t batteryPercent = map((SumValue / 60), 2250, 2700, 10, 100);
  return batteryPercent < 0 ? 0 : batteryPercent;
  }
#endif
// *********** Spannungsmessung der Batteriespannung mit der genauen Referenzspannung *************

void VoltControl()
{
 
// ------------ Batteriespannungsmessung TonUINO Klassic ------------------------ 
#ifndef AiO                                           // TonUINO Klassic
  
  u_reference = readVcc() / 1000.0;                   // Referenzspannung = ausgelesene Referenzspanung /1000  in V

 // Serial.print("Referenzspannung: ");               // Anzeige der Referenzspannung
 // Serial.print( u_reference );
 // Serial.println(" V");

  uint16_t value = analogRead(VControlPin);           // Sensorwert Batteriespannung
 /* 
  Vbatt = value * u_reference / 1024 ;                // Berechnung der genauen Batteriespannung in Volt Einzelmessung
  Serial.print(F("Batt =  "));
  Serial.print ( Vbatt);
  Serial.println (F( " Volt"));
 
*/ 

  SumValue = SumValue + value;                        // Aufsummierte Einzelmessungen
  countTi = countTi +1;
  if (countTi >= 10)                                  // Testzyklenzahl erreicht
  {
    countTi = 0; 

  VbattGl = SumValue * u_reference / 10240 ;          // Berechnung der geglätteten Batteriespannung in Volt
  Serial.print(F("Batterie =  "));
  Serial.print ( VbattGl);
  Serial.println (F( " Volt"));
  
  SumValue = 0;
  
#endif     // Ende #ifndef AiO  (Tonuino Klassic)                      


// ------------ Batteriespannungsmessung AiO ------------------------ 
#ifdef AiO
  
  uint16_t value = analogRead(VControlPin);           // Sensorwert Batteriespannung
/*
  Serial.print(value);                                // Je nach Spannung Wert zwischen 0 und 4064
  Serial.print(" - ");
  Serial.print(value * reference / steps);            // Wert zwischen 0V und Referenzspannung
  Serial.println(" V");

  Vbatt = (value * reference * correction / steps);   // Berechnung der genauen Batteriespannung in Volt, Einzelmessung
  Serial.print(F("B =  "));
  Serial.print(Vbatt);                                
  Serial.println(" V");                               
  Serial.print(getBatteryPercent());
  Serial.println("%");
*/
  
  SumValue = SumValue + value;
  countTi = countTi +1;

  if (countTi >= 60)                                                   // Testzyklenzahl erreicht
  {
    countTi = 0;
    VbattGl = ((SumValue / 60) * reference * correction /  steps );    //Berechnung geglätteter BattspWert
    Serial.println(SumValue / 60);
    Serial.print(F("Batterie =  "));
    Serial.print(VbattGl);                                
    Serial.println(" V");                                 
    Serial.print(getBatteryPercent());
    Serial.println(" %");
    SumValue = 0;
  
  
  // } gemeinsame Schlussklammer für AiO oder Classic weiter unten

#endif          // Ende #ifdef AiO
   // Ende Spannungsmessung AiO


//------------------- Auswertung der gemessenen Spannung ------------------------

  // Spannung für Shutdown
  if (VbattGl <= Vshutdown)                         // wenn Batteriespannung Entladeschlussspannung erreicht
  {
    BattLeer = true;
    Serial.println(F("Batt.leer --> ShutDown"));
    if (isPlaying())                                // Wenn Wiedergabe läuft
    {
      mp3.playAdvertisement(404);                   // Batterie ist leer, schalte mich aus
      delay (500);
    }
    else                                            // Wenn keine Wiedergabe läuft,sofort abschalten
    {
      mp3.playMp3FolderTrack(604);                  // Batterie ist leer, schalte mich aus
      waitForTrackToFinish();
      delay (500);
    }
      ShutDown();                                   // Tonuino abschalten
    
}
  // Spannung für Warnung                           // wenn Batteriespannung Schwellwert für Warnung erreicht
  if (VbattGl <= Vwarning)
  {
    if (BattLeer == false)
    {
      Serial.println(F("Batt.schwach "));

      if (isPlaying())
      {
        mp3.playAdvertisement(401);
      }
      else
      {
        mp3.playMp3FolderTrack(601);
        //waitForTrackToFinish();
        delay (3000);
        mp3.stop();
        if (StdBy == false)
          setstandbyTimer();
      }
    }            
  }              // Ende If <= Warning
 }               //gemeinsame Schlussklammer } Ende If countTi ,(60 AiO ),(10 Classic)
 
}
#endif          // Ende #ifdef BattControl           

//********************************************
// Dies im Setup einfügen

  // ------------------------------------------------------------------------------------
#ifdef BattControl
  pinMode(VControlPin, INPUT);          // Eingang Batteriespannungskontrolle

 #ifdef AiO				// AiO
  analogReference(INTERNAL2V048);       // Festlegung der Referenz
  analogReadResolution(12);             // Auflösung Auslesen
 #endif

#endif






// *******************************************************************************
//                            MAIN-LOOP
// *******************************************************************************
void loop()
{
  do
  {


    // ********************* Intervallmäßiges Prüfen der Batteriespannung ***********************
#ifdef BattControl

    Now = millis();                           // auslesen aktueller Zeitpunkt
    if (Now - lastTest >= TestIntervall)
    {
      lastTest = Now;                         // Speichern letzter Testzeitpunkt
      VoltControl();                          // Batterieprüfung
    }
#endif
//--------------------------------------------------------------------------------------------

Diese Schaltung verwendet einen P-Kanal Mosfet zum Abschalten der Akkuspannung bei ausgeschaltetem Tonuino. Der N-Fet wird zur Ansteuerung des P-Fet benötigt. Die Widerstandswerte sind unkritisch, sollten sich aber in den angegebenen Bereichen bewegen.
Für die Mosfets sollten Typen mit Tresholtspannungen UGSth < 3 V verwendet werden. Der R DS on spielt hier kaum eine Rolle, kann also auch etwas höher sein, einige Ohm.

Diese Schaltung könnte auf die Trennung des Akkus bei ausgeschaltetem Tonuino verzichten, weil die Tiefpassschaltung sehr hochohmig ausgeführt ist. Ein hier fließender Reststrom bewegt sich im Bereich weniger uA .

Beide Schaltungen sind noch nicht getestet, sollten aber funktionieren.
Bei der Schaltung mit Mosfets ist es besser den 100 kOhm Widerstand vom Gate direkt zum Pluspol des Akkus zu schalten, weil sich sonst ein Spannungsteiler mit den zwei 47 kOhm Widerständen bildet, der die Messespannung auf ca die Hälfte reduziert.

1 Like

Hallo Thomas,

vielen Dank für die Mühe.