In diesem Tutorial lernst du, wie du die Batteriespannung bei batteriebetriebenen Projekten überwachen kannst, damit du die Batterie rechtzeitig wieder aufladen kannst.
Bei fast allen batteriebetriebenen Projekten, sei es Wetter-Datenlogger, Überwachungskameras oder Roboter, möchtest du in der Regel den Ladezustand der Batterie kennen. Am besten erhältst du eine Warnung, wenn die Batterie nachgeladen werden muss.
Das verhindert eine Tiefentladung der Batterie, die zu irreversiblen Schäden oder einer verkürzten Lebensdauer führen kann. Außerdem hilft die Überwachung der Spannung, Probleme mit der Stromversorgung zu erkennen, wie fehlerhafte Verbindungen oder unzureichende Stromquellen.
In den folgenden Abschnitten zeige ich dir zwei Beispiele zur Überwachung der Batteriespannung. Fangen wir mit den benötigten Bauteilen an.
Benötigte Bauteile
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Nachfolgend findest du die für dieses Projekt benötigten Bauteile. Anstelle des kleineren 16×2 LCD Displays könntest du auch ein größeres 20×4 LCD Display verwenden. Achte nur darauf, dass es eine I2C-Schnittstelle hat und nicht die ebenfalls häufig verwendete SPI-Schnittstelle.
Arduino Uno
Dupont-Kabelset
Breadboard
USB-Kabel für Arduino UNO
Trimmer-Kit
LCD-Display
Verwendung des Analog-Digital-Wandlers (ADC)
Wir wollen die Spannung unserer Batterie messen, um zu wissen, wann wir sie nachladen müssen. Dafür verwenden wir einen analogen Eingangspin. Zuvor sprechen wir kurz über den Analog-to-Digital Converter (ADC), der hinter dem analogen Pin sitzt und die ganze Arbeit erledigt.
Der Analog-Digital-Wandler (ADC) ist eine integrierte Funktion in vielen Mikrocontrollern, darunter Arduino, ESP8266 und ESP32, die es ermöglicht, analoge Spannungen zu messen und in digitale Werte umzuwandeln. Der ADC arbeitet, indem er die analoge Spannung in regelmäßigen Abständen abtastet und dann in diskrete digitale Werte quantisiert. Dieser Prozess umfasst mehrere Schritte:
Abtastung
Der ADC nimmt zu einem bestimmten Zeitpunkt eine Momentaufnahme der analogen Spannung auf. Die Abtastrate bestimmt, wie häufig der ADC diese Momentaufnahmen macht. Eine höhere Abtastrate liefert eine genauere Darstellung des analogen Signals. Zum Beispiel tastet der ADC eines Arduino UNO etwa 15.000 Mal pro Sekunde ab.
Quantisierung
Nach der Abtastung weist der ADC der analogen Spannung einen digitalen Wert zu. Dies geschieht, indem der Spannungsbereich in eine bestimmte Anzahl diskreter Stufen unterteilt wird. Die Anzahl der Stufen hängt von der Auflösung des ADC ab. Der Arduino Uno hat eine 10-Bit-Auflösung (0-1023).
Umwandlung
Der ADC wandelt die analoge Spannung in einen digitalen Wert um, indem er die abgetastete Spannung mit einer Referenzspannung vergleicht und den entsprechenden digitalen Wert basierend auf den Quantisierungsstufen bestimmt. Sei hier sehr vorsichtig! Der maximale Eingangsspannungsbereich ist begrenzt. Beim Arduino liegt er bei 0-5V! Wenn du diesen Bereich überschreitest, beschädigst du den ADC!
Ausgabe
Nach Abschluss der Umwandlung gibt der ADC den digitalen Wert aus, der vom Mikrocontroller gelesen werden kann. Beachte, dass die Genauigkeit der ADC-Umwandlung von Faktoren wie Auflösung, Referenzspannung, Temperatur und Rauschpegel abhängt.
Verwendung eines Spannungsteilers
Wie oben gelernt, ist der Eingangsspannungsbereich für den analogen Pin beim Arduino Uno auf 0-5V beschränkt. Wenn du dein Board jedoch mit einer Batterie betreibst, ist die Batteriespannung typischerweise höher (intern wird sie durch einen Spannungsregler auf einen geeigneten Wert reduziert). Der Arduino kann Versorgungsspannungen von 6 bis 20 Volt aufnehmen, aber der analoge Pin erlaubt nur 0-5 Volt.
Das bedeutet, wir können die Batterie nicht direkt an einen analogen Eingang anschließen, da die Spannung höher als erlaubt ist! Eine gängige Methode, die Eingangsspannung auf einen messbaren Bereich zu reduzieren, ist die Verwendung eines Voltage Divider.
Dieser besteht aus zwei in Reihe geschalteten Widerständen, wobei die Batteriespannung an der Verbindung zwischen den Widerständen gemessen wird. Der Spannungsteiler reduziert die Batteriespannung auf ein Niveau, das sicher vom Analog-Digital-Wandler (ADC) des Mikrocontrollers gemessen werden kann.
Das folgende Bild zeigt einen Spannungsteiler mit zwei Widerständen R1 und R2. Der Pluspol der Batterie wird mit Vin verbunden und die reduzierte Spannung wird an Vout gemessen.
Der Spannungsteiler funktioniert nach dem Prinzip der Spannungsaufteilung. Durch die Verwendung von zwei Widerständen mit bekannten Werten teilt die Schaltung die Eingangsspannung proportional auf. Die Spannung an der Verbindung zwischen den Widerständen kann mit der Spannungsteilerformel berechnet werden:
Vout = Vin * (R2 / (R1 + R2))
Wobei:
Voutist die Ausgangsspannung an der Verbindung zwischen den Widerständen.Vinist die Eingangsspannung (Batteriespannung).R1undR2sind die Widerstandswerte der beiden Widerstände.
Auswahl der Widerstandswerte
Wir wissen jetzt, was ein Spannungsteiler ist und wie die Spannungen und Widerstandswerte zusammenhängen. Obwohl die Formel für alle Widerstandswerte gilt, solltest du in der Praxis eher größere Werte wählen.
Der Grund ist, dass der Spannungsteiler kontinuierlich Strom von der Batterie zieht, was den Gesamtstromverbrauch deines Projekts beeinflussen kann. Je höher die Widerstandswerte sind, desto geringer ist der Stromverbrauch. Andererseits, wenn die Widerstandswerte zu hoch sind, ist der Strom zu gering, um vom ADC genau gemessen zu werden.
Lass uns ein Beispiel mit typischen Widerstandswerten machen. Wenn wir einen Wert für R1 wählen, können wir R2 wie folgt berechnen:
R2 = (Vout / Vin) * R1
Zum Beispiel, wenn wir für R1 einen Widerstand von 10kΩ wählen und eine Batteriespannung von 12V mit einem ADC messen wollen, dessen maximale Eingangsspannung 5V beträgt, erhalten wir für R2 einen Wert von 4167Ω:
R2 = (5V / 12V) * 10000Ω = 4167Ω
Verwendung eines Potentiometers als Spannungsteiler
Während der Spannungsteiler mit zwei Widerständen gut funktioniert, ist es etwas umständlich, die richtigen Werte zu berechnen, und die Lösung ist starr. Wir können nicht einfach auf eine Batterie mit anderer Spannung wechseln, sobald der Spannungsteiler gebaut ist.
Eine einfachere und flexiblere Lösung ist die Verwendung eines Potentiometers. Es funktioniert genau gleich, aber da ein Potentiometer im Grunde ein variabler Spannungsteiler ist, können wir ihn an Änderungen der Vin anpassen. Unten siehst du einen Spannungsteiler mit einem 500KΩ Potentiometer, das in den folgenden Schaltungen verwendet wird.
Wir müssen nur sicherstellen, dass Vout die maximale Spannung des analogen Eingangs und des angeschlossenen ADC nicht überschreitet. Schau dir auch unser Tutorial zu How use Arduino to control an LED with a Potentiometer für mehr Details zu Potentiometern an.
Das Anschließen des Spannungsteilers an einen Arduino zur Messung der Batteriespannung ist sehr einfach. Das folgende Schaltbild zeigt die Schaltung:
Der Spannungsteiler läuft parallel zur Batterie und sein Ausgang (2) ist mit dem analogen Eingang (A0) des Arduino verbunden.
Spannungsteiler mit Arduino auf Breadboard
Lass uns diese Schaltung auf einem Breadboard mit einem Arduino Uno und einer 9V-Batterie als Stromversorgung aufbauen. Das Bild unten zeigt die komplette Schaltung. Aber bevor du die Teile verbindest, lies bitte weiter! Es gibt wichtige Details zu beachten!
Beginne damit, die Plus- und Minuspole der 9V-Batterie mit den positiven und negativen Stromschienen des Breadboards zu verbinden. Verbinde dann die positive und negative Stromschiene mit den Pins des Trimmers/Potentiometers wie oben gezeigt (blaue und rote Kabel), aber verbinde noch nicht das gelbe Kabel.
Bevor du etwas anderes anschließt, stelle sicher, dass der Ausgang des Spannungsteilers unter 5V liegt! Schließe ein Multimeter an Masse und den Spannungsteiler wie unten gezeigt an und überprüfe das!
Wenn alles in Ordnung ist, kannst du den Ausgang Vout des Spannungsteilers mit dem analogen Eingang A0 des Arduino (gelbes Kabel) verbinden. Der Eingang an A0 muss immer unter 5V liegen, auch bei einer brandneuen, frischen Batterie!
Zum Schluss verbinden wir die negative Stromschiene mit GND und die positive Stromschiene mit VIN des Arduino (rote und blaue Kabel). Sei auch hier vorsichtig! VIN is not protected against reversed polarity. Achte darauf, dass der Pluspol der Batterie mit VIN (rotes Kabel) verbunden ist.
Es ist in Ordnung, eine Batterie an VIN eines Arduino Uno anzuschließen und gleichzeitig das USB-Kabel für Upload oder serielle Überwachung an den Computer anzuschließen (see discussion here). Das gilt aber möglicherweise nicht für andere Boards!
Fertiges Projekt
Hier ein Bild des fertigen Projekts. Beachte, dass ich tatsächlich eine wiederaufladbare 9V Battery verwende. Ich finde sie sehr praktisch und auf lange Sicht kosteneffizient für Arduino-Projekte, da ich nicht ständig neue Batterien kaufen muss.
Beispiel 1: Niedrige Batteriewarnung mit Arduino
In diesem Abschnitt schreiben wir den Code für unseren Batteriespannungsmonitor. Schau dir den Code unten kurz an, bevor wir ins Detail gehen.
// Warn if battery voltage drops below a certain threshold
// Voltage is measured at A0
// Built-in LED switches on if voltage is too low
const int threshold = 300;
void setup() {
Serial.begin(9600);
pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
int value = analogRead(A0);
Serial.println(value);
int warn = value < threshold ? HIGH : LOW;
digitalWrite(LED_BUILTIN, warn);
delay(1000);
}
Im obigen Code überwachen wir die Spannung einer an Pin A0 angeschlossenen Batterie. Wenn die Spannung unter einen bestimmten Schwellenwert fällt, leuchtet die eingebaute LED auf dem Arduino-Board als Warnung auf. Die Schleife läuft kontinuierlich und überprüft ständig die Batteriespannung und aktualisiert den LED-Status entsprechend.
Lass uns den Code in seine Teile zerlegen.
Konstanten und Variablen
Der Code beginnt mit der Definition der Konstanten threshold, die den minimalen Spannungsschwellenwert für die Batterie angibt.
const int threshold = 300;
Setup-Funktion
In der setup() Funktion initialisieren wir die serielle Kommunikation mit einer Baudrate von 9600, was uns erlaubt, Daten zum Computer zu senden, um sie zu debuggen. Wir setzen auch den Modus der eingebauten LED (LED_BUILTIN) auf OUTPUT, da wir sie steuern werden.
void setup() {
Serial.begin(9600);
pinMode(LED_BUILTIN, OUTPUT);
}
Loop-Funktion
Die loop() Funktion enthält die Hauptlogik des Programms. Zuerst lesen wir den analogen Wert von Pin A0, der die Batteriespannung repräsentiert. Dann geben wir diesen Wert zur Fehlerbehebung im seriellen Monitor aus.
void loop() {
int value = analogRead(A0);
Serial.println(value);
Beachte, dass dieser Wert nicht skaliert ist und zwar proportional zu den gemessenen Spannungen ist, aber keine Messung in Volt darstellt.
Als Nächstes prüfen wir, ob der Wert unter dem Schwellenwert liegt, indem wir value mit threshold vergleichen. Wenn der Wert unter dem Schwellenwert liegt, setzen wir die Variable warn auf HIGH, was bedeutet, dass die LED eingeschaltet werden soll. Andernfalls setzen wir warn auf LOW, was bedeutet, dass die LED ausgeschaltet werden soll.
int warn = value < threshold ? HIGH : LOW;
Beachte, dass der Schwellenwert ebenfalls nicht in Volt angegeben ist. Die tatsächliche Einheit der Messung ist hier nicht relevant. Wir wollen nur feststellen, ob die Batterie basierend auf dem gemessenen Wert und dem gesetzten Schwellenwert nachgeladen werden muss.
Schließlich verwenden wir die digitalWrite() Funktion, um den Zustand der eingebauten LED basierend auf dem Wert von warn zu steuern. Wenn warn gleich HIGH ist, leuchtet die LED; andernfalls ist sie aus.
digitalWrite(LED_BUILTIN, warn);
Wir fügen eine Verzögerung von 1000 ms (1 Sekunde) hinzu, um eine Pause zwischen den Schleifendurchläufen zu schaffen.
delay(1000); }
Das war’s! Das Programm überwacht kontinuierlich die Batteriespannung und warnt den Benutzer, wenn sie unter den festgelegten Schwellenwert fällt, indem es die eingebaute LED einschaltet. Du kannst den Schwellenwert beliebig anpassen. Er hängt von deiner Batterie und deinem Board ab, wann du vor niedrigem Batteriestand warnen möchtest.
Beispiel 2: Batteriespannungsmessung mit Arduino
Im vorherigen Beispiel haben wir signalisiert, wenn die Spannung unter einen bestimmten Schwellenwert gefallen ist, ohne die tatsächliche Spannung zu berücksichtigen. In diesem Beispiel messen wir die tatsächliche Spannung und zeigen sie in Volt auf einem LCD-Display an.
Anschluss des LCD-Displays
Die Schaltung bleibt im Wesentlichen gleich wie im vorherigen Beispiel. Wir fügen nur das LCD-Display hinzu. Das folgende Bild zeigt die komplette Verkabelung.
Um das LCD-Display hinzuzufügen, verbinde zuerst VCC und GND des Displays mit 5V und GND des Arduino (rote und blaue Kabel). Dann verbinde SCL mit A5 und SDA mit A4.
Wenn du mehr Details brauchst, schau dir unser Tutorial zu How to control a character I2C LCD with Arduino. an. Ich habe dieses 20×2 LCD auch in einem Tutorial zu How to use the MQ-7 Gas Sensor with an LCD display and Arduino verwendet, schau dir das bei Bedarf auch an.
Das fertige Projekt sieht so aus:
Code zur Spannungsmessung
Unten findest du den entsprechenden Code zum Auslesen und Anzeigen der Batteriespannung. Schau ihn dir zuerst an, um einen groben Überblick zu bekommen, wir erklären den Code im Folgenden im Detail.
// Measure battery voltage at A0
// and displaying on 20x2 LCD display
#include "LiquidCrystal_I2C.h"
const double maxV = 9; // 9V max
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x3F, 20, 4);
void setup() {
lcd.init();
lcd.backlight();
}
void loop() {
int value = analogRead(A0);
double voltage = value * maxV/1023.0;
lcd.clear();
lcd.setCursor(1, 0);
lcd.print("Voltage:");
lcd.setCursor(10, 0);
lcd.print(voltage);
lcd.setCursor(14, 0);
lcd.print("V");
delay(1000);
}
Um den Code im Detail zu verstehen, schauen wir uns seine Teile an. Wir beginnen mit den Konstanten und Variablen.
Konstanten und Variablen
Zuerst definieren wir die Konstante maxV, die die maximale Batteriespannung angibt. In diesem Fall ist sie auf 9V gesetzt. Wenn du eine andere Batterie (6V, 12V, …) verwendest, musst du diesen Wert anpassen!
const double maxV = 9; // 9V max
Bibliothek und LCD-Initialisierung
Wir binden die LiquidCrystal_I2C.h Bibliothek ein, die Funktionen zur Steuerung des LCD-Displays bereitstellt. Du musst sie installieren, falls noch nicht geschehen. Siehe unser Tutorial zu How to control a character I2C LCD with Arduino für Details.
Dann erstellen wir eine Instanz der LiquidCrystal_I2C Klasse und initialisieren sie mit der I2C-Adresse des LCD-Displays (0x3F) sowie der Anzahl der Spalten und Zeilen (20 und 4). Eine weitere gängige I2C-Adresse für LCD-Displays ist 0x27. Wenn 0x3F bei dir nicht funktioniert, versuche 0x27 oder verwende einen I2C scanner, um die korrekte Adresse deines Displays zu finden.
#include "LiquidCrystal_I2C.h"
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x3F, 20, 4);
void setup() {
lcd.init();
lcd.backlight();
}
Loop-Funktion
In der loop() Funktion lesen wir zuerst den analogen Wert von Pin A0 mit der analogRead() Funktion aus. Dieser Wert ist proportional zur Batteriespannung. Wir berechnen dann die Spannung, indem wir den analogen Wert mit der maximalen Spannung multiplizieren und durch den maximalen Bereich des analogen Eingangs (1023) teilen.
void loop() {
int value = analogRead(A0);
double voltage = value * maxV/1023.0;
Anschließend löschen wir das LCD-Display mit der clear() Funktion und setzen den Cursor, um die Spannung anzuzeigen. Wir geben den Spannungswert mit der print() Funktion auf dem LCD aus. Zum Schluss fügen wir die Einheit „V“ hinzu, um anzuzeigen, dass der Wert in Volt ist.
lcd.clear();
lcd.setCursor(1, 0);
lcd.print("Voltage:");
lcd.setCursor(10, 0);
lcd.print(voltage);
lcd.setCursor(14, 0);
lcd.print("V");
Wir fügen eine Verzögerung von 1000 ms (1 Sekunde) mit der delay() Funktion hinzu, um die Aktualisierungsrate der Batteriespannung auf dem LCD zu steuern.
delay(1000); }
Das war’s! Wir haben den Code zum Auslesen und Anzeigen der Spannung, müssen das System aber noch für genaue Messungen kalibrieren.
Kalibrierung des Batteriespannungsmonitors
Die Kalibrierung ist einfach. Trenne zuerst die Batterie von deinem Projekt und verbinde sie stattdessen mit einem Multimeter. Messe die Batteriespannung. Im Beispiel unten messen wir 8,92V.
Dann verbinde die Batterie wieder mit dem Arduino-Projekt. Jetzt drehe sehr langsam den Trimmer, bis das Display eine Spannung anzeigt, die möglichst nah an der gemessenen liegt. Damit ist die Kalibrierung abgeschlossen.
Beachte, dass die Auflösung des gerade gebauten Spannungsmessers relativ niedrig ist (1023 Schritte) und dass der ADC im Arduino Uno nicht perfekt linear ist. Dieses Projekt eignet sich also nicht für hochpräzise Spannungsmessungen, ist aber ideal, um die Batteriespannung zu überwachen.
Beispiel 3: Spannungsmessung mit CPUVolt für Arduino
In den beiden vorherigen Beispielen haben wir einen Spannungsteiler verwendet, um eine Spannung zu erzeugen, die an einem analogen Eingang gemessen werden kann, um den Batteriestand zu überwachen. Der Vorteil eines Spannungsteilers ist, dass er für praktisch alle Mikrocontroller (Arduino, ESP32, ESP8622, …) funktioniert. Der Nachteil ist, dass du zusätzliche Hardware (Widerstände) für den Spannungsteiler benötigst.
Wenn du einen ATMega-Prozessor (Atmel) wie bei Arduino verwendest, gibt es eine coole kleine Bibliothek namens CPUVolt, mit der du den Batteriestand überwachen kannst, ohne einen Spannungsteiler zu benötigen. Um die CPUVolt-Bibliothek zu installieren, gehe zum GitHub-Repo unter https://github.com/ripred/CPUVolt und klicke auf „Code“ und dann „Download ZIP“.
Installiere die heruntergeladene Datei CPUVolt-main.zip mit der Arduino IDE über Sketch -> Include Library -> Add .ZIP Library … :
Jetzt sind wir bereit, die Schaltung aufzubauen und den Code zu schreiben.
Verkabelung zur Batterieladungsmessung
Die Verkabelung zur Messung und Anzeige des Batteriestands ist im Wesentlichen dieselbe wie in Beispiel 2. Wir lassen nur den Spannungsteiler weg und brauchen das Breadboard nicht mehr. Siehe Bild unten.
Wir verbinden die Batterie mit VIN und GND und das LCD-Display mit SDA und SCL wie zuvor. Achte nur auf die Spannung am VIN-Pin. Je nach verwendetem Arduino-Board variiert die maximal zulässige Spannung (Link)! Beim Arduino Uno liegt sie zwischen 7V und 12V.
In den meisten batteriebetriebenen Projekten benötigst oder möchtest du vielleicht kein LCD-Display verwenden. Es ist aber hilfreich, um die Batteriestandsmessung zu kalibrieren.
Code zur Batterieladungsmessung
// Measuring battery charge levels
#include "CPUVolt.h"
#include "LiquidCrystal_I2C.h"
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x3F, 20, 4);
void setup() {
lcd.init();
lcd.backlight();
}
void loop() {
lcd.clear();
// 5209 -> 9V, 4935 -> 6V
float pct = readPercent(4935, 5209);
lcd.setCursor(1, 0);
lcd.print("Percent:");
lcd.setCursor(10, 0);
lcd.print(pct);
long mv = readVcc();
lcd.setCursor(1, 1);
lcd.print("Voltage:");
lcd.setCursor(10, 1);
lcd.print(mv);
delay(1000);
Im obigen Code messen wir den Batteriestand und zeigen ihn mit der CPUVolt-Bibliothek und der LiquidCrystal_I2C-Bibliothek auf einem LCD-Bildschirm an.
Um den Code im Detail zu verstehen, schauen wir uns seine Teile an.
Bibliothekseinbindung
Wir beginnen mit dem Einbinden der notwendigen Bibliotheken für unser Projekt. Wir binden die „CPUVolt.h“-Bibliothek ein, um den Batteriestand zu messen, und die „LiquidCrystal_I2C.h“-Bibliothek, um das LCD-Display zu steuern.
#include "CPUVolt.h" #include "LiquidCrystal_I2C.h"
LCD-Initialisierung
In der setup() Funktion initialisieren wir das LCD-Display. Wir rufen die init() Funktion auf, um das LCD zu initialisieren, und die backlight() Funktion, um die Hintergrundbeleuchtung einzuschalten.
void setup() {
lcd.init();
lcd.backlight();
}
Hauptschleife
In der loop() Funktion führen wir die Hauptoperationen unseres Programms aus. Wir beginnen damit, das LCD-Display mit der clear() Funktion zu löschen.
void loop() {
lcd.clear();
}
Messung des Batteriestands
Anschließend messen wir den Batteriestand mit der readPercent() Funktion aus der CPUVolt-Bibliothek. Wir übergeben die minimalen und maximalen Spannungswerte unserer Batterie als Parameter. Der zurückgegebene Wert wird in der Variablen pct gespeichert.
// 5209 -> 9V, 4935 -> 6V float pct = readPercent(4935, 5209);
Hier kalibrierst du den Batteriestand. In meinem Fall habe ich den Arduino mit 9V betrieben, was mir einen Wert von 5209 mV für 100% Ladung gab, und mit 6V, was einen Wert von 4935 mV ergab, was 0% Ladung entspricht.
Anzeige des Batteriestands
Wir zeigen dann den Batteriestand auf dem LCD-Display an. Wir setzen die Cursorposition mit der setCursor() Funktion und geben den Text „Percent:“ sowie den Wert von pct mit der print() Funktion aus.
lcd.setCursor(1, 0);
lcd.print("Percent:");
lcd.setCursor(10, 0);
lcd.print(pct);
Batteriespannungsmessung
Als Nächstes messen wir die Batteriespannung mit der readVcc() Funktion aus der CPUVolt-Bibliothek. Der zurückgegebene Wert wird in der Variablen mv (Millivolt) gespeichert.
long mv = readVcc();
Anzeige der Batteriespannung
Wir zeigen dann die Batteriespannung auf dem LCD-Display an. Wir setzen die Cursorposition und geben den Text „Voltage:“ sowie den Wert von mv mit den Funktionen setCursor() und print() aus.
lcd.setCursor(1, 1);
lcd.print("Voltage:");
lcd.setCursor(10, 1);
lcd.print(mv);
Verzögerung
Zum Schluss fügen wir eine Verzögerung von 1 Sekunde mit der delay() Funktion hinzu, um die Aktualisierungsrate des LCD-Displays zu steuern.
delay(1000);
Genauigkeit und Empfindlichkeit
Während die CPUVolt-Bibliothek funktioniert, ist die Genauigkeit oder Empfindlichkeit sehr begrenzt. In meinem Fall konnte ich die Versorgungsspannung von 9V auf 6,4V senken und der angezeigte Batteriestand blieb bei 100%. Von 6,4V bis 6V fiel der angezeigte Ladestand dann schnell auf 0%.
Für praktische Anwendungen würde ich eine linearere Empfindlichkeit bevorzugen, bei der die angezeigten Prozente früher zu sinken beginnen und eine bessere Schätzung der verbleibenden Batterielebensdauer liefern. Wenn du aber schnell eine Niedrigbatteriewarnung ohne zusätzlichen Spannungsteiler brauchst, ist die CPUVolt-Bibliothek super.
Fazit
Die Überwachung der Batteriespannung ist für batteriebetriebene Projekte entscheidend, um optimale Leistung zu gewährleisten und unerwartete Abschaltungen zu vermeiden. In diesem Blogbeitrag haben wir zwei Beispiele zur Überwachung der Batteriespannung mit Arduino vorgestellt.
Ein Beispiel ist ein einfaches Warnsystem, das bei niedrigem Batteriestand alarmiert. Das andere misst die Batteriespannung und zeigt sie auf einem LCD-Display an.
In beiden Fällen haben wir eine Spannungsteiler-Schaltung verwendet, die es ermöglicht, die Batteriespannung auf einen Bereich zu skalieren, der vom Mikrocontroller gemessen werden kann. Diese Methode bietet mehr Flexibilität hinsichtlich des Spannungsbereichs, erfordert jedoch zusätzliche Bauteile und eine sorgfältige Auswahl der Widerstandswerte.
Abschließend habe ich gezeigt, wie du die CPUVolt-Bibliothek verwenden kannst, um den Batteriestand ohne externen Spannungsteiler zu überwachen.
Für eine genaue Überwachung der Batteriespannung ist es wichtig, Faktoren wie Temperaturkompensation, Rauschfilterung und Stabilität der Stromversorgung zu berücksichtigen. Wenn du diese Faktoren einbeziehst, erhältst du zuverlässige und konsistente Messwerte.
Zusammenfassend ist die Überwachung der Batteriespannung für batteriebetriebene Projekte unerlässlich. Durch die Wahl der richtigen Überwachungsmethode, das Testen und Kalibrieren des Systems sowie die Implementierung einer Niedrigbatteriewarnung kannst du optimale Leistung und Zuverlässigkeit für deine Projekte sicherstellen.
Also, leg los und überwache die Batteriespannung in deinen Projekten!
Häufig gestellte Fragen
Hier sind einige häufig gestellte Fragen zur Überwachung der Batteriespannung bei batteriebetriebenen Projekten:
F: Warum ist es wichtig, die Batteriespannung zu überwachen?
A: Die Überwachung der Batteriespannung ist entscheidend, weil sie dir erlaubt, den Ladezustand der Batterie zu verfolgen. So kannst du erkennen, wann die Batterie fast leer ist und nachgeladen oder ersetzt werden muss. Das verhindert unerwartete Abschaltungen und sorgt für die Zuverlässigkeit deines Projekts.
F: Wie funktioniert die Methode mit dem Analog-Digital-Wandler (ADC)?
A: Bei der ADC-Methode wird die Batteriespannung an einen analogen Eingangspin des Mikrocontrollers angeschlossen. Der Mikrocontroller wandelt die analoge Spannung in einen digitalen Wert um, der im Code gelesen und verarbeitet werden kann. Durch die Zuordnung des digitalen Werts zum tatsächlichen Spannungsbereich kannst du die Batteriespannung genau überwachen.
F: Was ist eine Spannungsteiler-Schaltung?
A: Ein Spannungsteiler ist eine einfache Schaltung aus zwei in Reihe geschalteten Widerständen. Indem du die Batteriespannung über einen der Widerstände legst, erzeugst du eine Ausgangsspannung, die einen Bruchteil der Batteriespannung darstellt. Diese Ausgangsspannung kann gemessen und zur Überwachung der Batteriespannung verwendet werden.
F: Wie kann ich das Überwachungssystem testen und kalibrieren?
A: Um das Überwachungssystem zu testen und zu kalibrieren, kannst du eine bekannte Spannungsquelle, wie ein Multimeter, verwenden, um die gemessene Spannung mit der tatsächlichen Spannung zu vergleichen. Das Anpassen der Widerstände im Spannungsteiler oder das Anwenden von Kalibrierfaktoren auf die ADC-Werte kann die Genauigkeit verbessern.
F: Welche Tipps gibt es für eine genaue Batteriespannungsüberwachung?
A: Für eine genaue Überwachung der Batteriespannung beachte folgende Tipps:
- Verwende stabile und genaue Spannungsreferenzen zur Kalibrierung.
- Minimiere Störungen und Rauschen in der Messschaltung.
- Berücksichtige Spannungsabfälle über Bauteile und Verbindungen.
- Setze geeignete Energiemanagement-Techniken ein, um die Batterielebensdauer zu verlängern.
- Teste und kalibriere das Überwachungssystem regelmäßig, um die Genauigkeit zu erhalten.
Wenn du diese Tipps befolgst, erreichst du eine zuverlässigere und genauere Batteriespannungsüberwachung für deine Projekte.
Diese häufig gestellten Fragen sollten dir ein besseres Verständnis der Batteriespannungsüberwachung für deine batteriebetriebenen Projekte geben. Wenn du weitere Fragen hast, stelle sie gerne im Kommentarbereich unten.
