Arduino mit Batterie betreiben: 9V, AA, 18650 und der Vin-Pin

Einen Arduino mit Batterie zu betreiben ist der erste Schritt, dein Projekt vom USB-Kabel des Computers zu befreien und daraus ein Roboterauto, einen Sensor im Garten oder ein Gerät für die Hosentasche zu machen. Die kurze Antwort: Am sichersten betreibst du einen Arduino Uno mit Batterien, indem du ein 7–12 V Paket (6×AA oder zwei 18650-Zellen in Reihe) an die Hohlbuchse oder den Vin-Pin anschließt oder eine Powerbank in die USB-Buchse steckst. Der 5V-Pin sollte nur mit einer sauberen 5-V-Quelle genutzt werden, die du gemessen und eingestellt hast, denn dieser Pin umgeht den Spannungsregler und alle Schutzschaltungen des Boards.

Eine falsche Stromversorgung steckt hinter vielen rätselhaften Problemen, die Einsteiger erleben: ein Board, das sich bei jeder Servobewegung neu startet, ein 9V-Block, der nach wenigen Stunden leer ist, eine Powerbank, die nach ein paar Sekunden abschaltet, oder ein Regler, der zu heiß zum Anfassen wird. In dieser Anleitung lernst du jeden Eingang kennen, über den du einen Arduino versorgen kannst, welche Batterie wohin gehört, warum Motoren eine eigene Quelle brauchen und wie du Stromaufnahme und Laufzeit berechnest. Am Ende schauen wir uns auch an, was beim Batteriebetrieb von ESP32 und Raspberry Pi Pico anders ist.

5 Wege, einen Arduino mit Strom zu versorgen

Im Arduino Uno gibt es zwei getrennte Versorgungswege. Die 5 V vom USB-Anschluss laufen über eine selbstrückstellende 500-mA-Sicherung (Polyfuse) und einen kleinen MOSFET-Schalter direkt auf die 5-V-Schiene des Boards. Die Spannung von der Hohlbuchse geht zuerst durch eine Verpolungsschutzdiode, liegt an diesem Punkt am Vin-Pin an und wird dann von einem LDO-Regler der 1117-Familie auf 5 V heruntergeregelt. Die 3,3 V erzeugt ein zweiter, kleiner Regler aus dieser 5-V-Schiene. Ein Komparator auf dem Board überwacht Vin: Steigt Vin über etwa 6,6 V, trennt er die USB-Versorgung automatisch ab, sodass sich die Quellen nicht in die Quere kommen, selbst wenn Netzteil und USB gleichzeitig angeschlossen sind.

Versorgung über USB: die 500-mA-Grenze

USB ist die einfachste und am besten geschützte Art, einen Arduino zu versorgen. Ein USB-2.0-Port am Computer liefert höchstens 500 mA; die Polyfuse des Uno erwärmt sich und unterbricht den Stromkreis, wenn der Gesamtstrom darüber liegt, und schaltet nach dem Abkühlen von selbst wieder zu. Das Board selbst verbraucht etwa 45–50 mA, damit bleiben rund 400 mA, die sich Sensoren, LEDs und Module teilen. Ein Handy-Ladegerät oder eine Powerbank funktionieren an derselben USB-Buchse; der einzige Unterschied ist, dass die Spannung an dünnen, langen Kabeln auf bis zu 4,6 V sinken kann. Solange das Board über USB läuft, geht jedes Milliampere, das du aus dem 5V-Pin ziehst, von diesem 500-mA-Budget ab. Deshalb löst ein Servo oder LED-Streifen an der USB-Versorgung die Sicherung aus, und auch der USB-Port des Computers kann sich zum eigenen Schutz abschalten.

Hohlbuchse und Vin-Pin: warum 7–12 V?

Der 5-V-Regler auf dem Board ist ein linearer LDO und braucht am Eingang etwa 1–1,2 V mehr als am Ausgang, um sauber zu arbeiten. Rechnest du den Spannungsabfall von 0,7–1 V an der Schutzdiode der Hohlbuchse dazu, brauchst du mindestens 7 V an der Buchse, damit die 5 V stabil bleiben. Mit einer 6-V-Quelle sackt die 5-V-Schiene auf 4,2–4,5 V ab; das Board scheint zu laufen, aber Analogwerte driften und Module verhalten sich seltsam. Am oberen Ende ist Wärme das Problem: Ein Linearregler verheizt die überschüssige Spannung. Die Verlustleistung berechnest du mit P = (Vin − 5 V) × I. Als Faustregel gilt: Lass den Regler nicht mehr als 1 W verheizen; ab da wird das kleine SOT-223-Gehäuse zu heiß zum Anfassen und schaltet sich irgendwann selbst ab.

Der Vin-Pin ist Eingang und Ausgang zugleich. Versorgst du das Board über die Hohlbuchse, liegt an Vin die Buchsenspannung minus etwa 0,7–1 V an; damit kannst du eine kleine 9–12-V-Last speisen. Da im Strompfad aber eine 1-A-Schutzdiode sitzt, solltest du große Lasten wie Motoren direkt aus der Quelle versorgen und nicht über Vin. Schließt du einen Batteriehalter an den Vin-Pin an, ist diese Schutzdiode außen vor: Der Regler arbeitet weiterhin, aber wenn du Plus und Minus vertauschst, schützt nichts mehr das Board. Beim neueren Uno R4 Minima und R4 WiFi akzeptieren Hohlbuchse und Vin 6–24 V, und statt eines Linearreglers arbeitet dort ein Schaltregler (Buck), weshalb sie selbst bei 12 V nicht überhitzen. Mehr dazu im Beitrag Arduino Uno R4.

5V-Pin: Wann kann man den Regler sicher umgehen?

Der 5V-Pin ist direkt mit der Versorgungsschiene des ATmega328P und der übrigen Chips auf dem Board verbunden. Speist du hier ein, umgehst du den Regler, die Verpolungsschutzdiode und die USB-Sicherung. Deshalb rät auch Arduinos eigene Dokumentation davon ab, über die Pins 5V und 3.3V einzuspeisen. Richtig gemacht hat es trotzdem Vorteile: Ohne Spannungsabfall und Wärmeverlust im Regler hält die Batterie länger, und du kannst deinen Modulen mehr Strom geben. Es gibt nur eine Bedingung: Die Quelle muss geregelt und gemessen sein. Der ATmega328P ist für höchstens 5,5 V ausgelegt, 6 V sind sein absolutes Maximum; schon ein kurzer Moment darüber kann den Chip dauerhaft beschädigen.

• Erst messen: Prüfe den Ausgang der Quelle mit dem Multimeter, bevor du sie an den Arduino anschließt; er muss zwischen 4,8 und 5,2 V liegen.
• Keine nackten Batterien: Vier frische AA-Alkalizellen erreichen 6,4 V und überschreiten die Grenze. Schließe an den 5V-Pin nur den Ausgang eines Reglers, Buck- oder Boost-Moduls an.
• Vorsicht bei gleichzeitigem USB: Steckst du USB ein, während du über den 5V-Pin versorgst, werden zwei 5-V-Quellen über das Board miteinander verbunden; trenne die externe Versorgung am besten, während du hochlädst.
• Kondensator ergänzen: Ein Elko mit 100–470 µF an der externen 5-V-Leitung nahe am Board glättet Spannungseinbrüche bei plötzlichen Stromspitzen (Was ist ein Kondensator?).
• Fertige Lösungen: Reglermodule mit 7805 (Spannungsregler 7805), ein auf 5,0 V eingestellter LM2596 oder für das Steckbrett das MB102-Netzteilmodul liefern saubere 5 V.

3.3V-Pin: Wie viel Strom darfst du entnehmen?

Der 3.3V-Pin des Uno ist kein Versorgungseingang, sondern der Ausgang eines kleinen Reglers, und seine offizielle Grenze liegt bei 50 mA. Das reicht für Module, die nur einige zehn Milliampere brauchen, etwa einen BME280, einen MPU6050 oder einen RC522-RFID-Leser. Module mit hohen Spitzenströmen überfordern ihn aber: Der nRF24L01+PA+LNA mit Antenne zieht beim Senden über 100 mA, das ESP-01-WLAN-Modul hat Spitzen von mehreren hundert Milliampere und das SIM800L verlangt Stromstöße bis 2 A. Für den nRF24L01+PA+LNA und das ESP-01 nimmst du ein separates AMS1117-3,3-V-Reglermodul, das aus der 5-V-Schiene versorgt wird. Das SIM800L arbeitet dagegen nicht mit 3,3 V, sondern mit 3,4–4,4 V und überschreitet die 1-A-Grenze des AMS1117; versorge es aus einer einzelnen Li-Ion-Zelle oder einem auf 4,0 V eingestellten Buck-Modul, das mindestens 2 A liefert. Beim Arduino Nano und seinen Klonen kommt der 3.3V-Pin oft aus dem USB-Seriell-Chip und ist noch schwächer als beim Uno; auch dort ist ein eigener Regler die sicherere Wahl. Mehr zur Versorgung von Funkmodulen findest du in der nRF24L01-Anleitung.

Batterieoptionen: 9V-Block, AA, 18650 und Powerbank

Der klassische 9V-Block wird wegen seines Clips mit Hohlstecker am häufigsten empfohlen, ist aber die ineffizienteste Wahl. Er enthält sechs winzige Zellen, deshalb hat er nur etwa 400–600 mAh und einen hohen Innenwiderstand; kommen zu den 50 mA des Uno ein Servo oder ein paar LEDs dazu, fällt die Spannung schnell unter 7 V und das Board beginnt neu zu starten. Bei einem Board mit Linearregler bestimmt die mAh-Angabe der Batterie direkt die Laufzeit, die überschüssigen Volt werden nur zu Wärme. Deshalb hält ein 6×AA-Halter mit denselben 9 V etwa viermal so lange wie ein 9V-Block. Die Kapazitätsangaben erklären wir ausführlich im Beitrag Was bedeutet mAh?.

AA-Mignonzellen sind billig und überall erhältlich, aber die Anzahl muss stimmen. Der häufigste Fehler sind 4×AA: 6 V sind für die Hohlbuchse zu wenig, weil nach Diode und Regler nur etwa 4,2 V auf der 5-V-Schiene ankommen, und am 5V-Pin wären es mit frischen Zellen 6,4 V, also über der Grenze. Richtig sind ein 6×AA-Paket (9 V) an der Hohlbuchse und ein 3×AA-Paket (4,5 V) direkt am 5V-Pin. Ein Uno mit 16 MHz an 3×AA wird instabil, sobald eine Zelle unter 1,25 V fällt, daher kannst du nicht die ganze Kapazität nutzen. Wiederaufladbare NiMH-Akkus liefern 1,2 V pro Zelle, darum sind 4×NiMH (4,8 V) ebenfalls beliebt für den 5V-Pin; frisch geladene Zellen können in den ersten Minuten aber über 5,5 V liegen.

18650-Li-Ion-Akku und Aufwärtswandler

Die 18650 ist eine wiederaufladbare Lithium-Ionen-Zelle mit 18 mm Durchmesser und 65 mm Länge, wie sie in Laptop-Akkus und Powerbanks steckt. Ihre Nennspannung beträgt 3,7 V; voll geladen misst sie 4,2 V, leer etwa 3,0 V. Die echte Kapazität liegt zwischen 2000 und 3500 mAh; Zellen mit Aufdrucken wie 6800 oder 9900 mAh sind fast immer Fälschungen. Für einen Arduino lässt sich eine einzelne 18650 auf zwei Arten nutzen: Mit einem Aufwärtswandler (Boost, etwa einem MT3608-Modul oder einer fertigen 18650-Powerbank-Platine) hebst du 3,7 V auf 5 V an und speist USB oder den 5V-Pin, oder du schaltest zwei Zellen in Reihe und steckst den 2S-Akku (7,4 V) an die Hohlbuchse. Die zweite Variante ist für den Uno die ausgewogenste: Ab 8,4 V bleibt die Spannung im Wohlfühlbereich des Reglers, bis sie auf 3,5 V pro Zelle (7 V gesamt) sinkt. Denk beim Boost-Wandler daran, dass der Strom aus der Batterie höher ist als am Ausgang: Eine Schaltung, die 200 mA bei 5 V braucht, zieht bei 88 Prozent Wirkungsgrad etwa 307 mA aus einer 3,7-V-Zelle.

• Schutzschaltung ist Pflicht: Eine Li-Ion-Zelle unter 3,0 V zu entladen verkürzt ihre Lebensdauer und kann gefährlich sein. Verwende geschützte Zellen oder eine Schutzplatine (BMS).
• TP4056 nur für eine Zelle: Das TP4056-Modul lädt nur eine einzelne Zelle (1S) auf 4,2 V. Lade einen 2S-Akku in Reihe niemals mit einem TP4056, sondern mit einer 2S-BMS-Ladeschaltung oder einem Balancer-Ladegerät. Details zum Anschluss findest du im Beitrag TP4056-Lademodul.
• Vorsicht vor Kurzschlüssen: Eine 18650 kann im Kurzschluss Dutzende Ampere liefern; lass keine blanken Drähte liegen und setze eine Sicherung und einen Schalter in die Batterieleitung.
• Boost einstellen: Schließe einstellbare Module wie den MT3608 erst an den Arduino an, wenn ihr Ausgang auf 5,0 V eingestellt ist.
• Keine Zellen mischen: Verwende in einem Reihenpaket Zellen gleicher Marke, Kapazität und gleichen Ladezustands.

Warum schaltet sich die Powerbank von selbst ab?

Eine Powerbank ist ein fertiges Paket mit Lithiumzellen, Ladeschaltung, Schutz und 5-V-Boost, daher ist sie der bequemste Weg, einen Arduino mit Akku zu betreiben: USB-Kabel einstecken, fertig. Die meisten Powerbanks überwachen jedoch den Ausgangsstrom, damit sie abschalten können, wenn das Handy voll ist, und kappen den Ausgang innerhalb von 10–60 Sekunden, sobald der Strom unter 50–100 mA fällt. Ein Nano mit 20 mA oder ein Uno mit 50 mA bleibt unter dieser Schwelle, also läuft das Board eine Weile und geht dann still aus. Es gibt zwei Auswege: eine Powerbank mit Schwachstrommodus wählen (bei manchen Modellen per Doppelklick auf die Taste) oder den Arduino in regelmäßigen Abständen kurz eine Last ziehen lassen. Für die zweite Methode schließt du einen Widerstand mit 47 Ω, 1 W von der 5-V-Schiene an den Kollektor eines NPN-Transistors (BC337 oder 2N2222) an, den Emitter an GND und die Basis über einen 1-kΩ-Widerstand an Pin D7. Schaltet der Transistor durch, zieht der Widerstand etwa 5 V / 47 Ω ≈ 106 mA, und die Powerbank erkennt eine Last. Die Werte kannst du mit dem Ohmsches-Gesetz-Rechner selbst nachrechnen.

1// Powerbank uyanık tutma / powerbank keep-alive
2// D7 -> 1 kΩ -> NPN beyzi, kolektör -> 47 Ω -> 5V / D7 -> 1 kΩ -> NPN base, collector -> 47 Ω -> 5V
3const int LOAD_PIN = 7;
4const unsigned long PERIOD_MS = 8000;  // her 8 saniyede bir / every 8 seconds
5const unsigned long PULSE_MS = 300;    // 300 ms yük / 300 ms of load
6
7unsigned long pulseStart = 0;
8bool loadOn = false;
9
10void setup() {
11  pinMode(LOAD_PIN, OUTPUT);
12  digitalWrite(LOAD_PIN, LOW);
13}
14
15void loop() {
16  unsigned long now = millis();
17  if (!loadOn && now - pulseStart >= PERIOD_MS) {
18    digitalWrite(LOAD_PIN, HIGH);   // ~106 mA çek / draw ~106 mA
19    loadOn = true;
20    pulseStart = now;
21  }
22  if (loadOn && now - pulseStart >= PULSE_MS) {
23    digitalWrite(LOAD_PIN, LOW);    // yükü kapat / switch the load off
24    loadOn = false;
25  }
26  // projenin kodu burada, delay() kullanmadan / your project code here, without delay()
27}

Weil der Code mit millis() statt delay() arbeitet, blockiert er den Rest deines Projekts nicht; diesen Ansatz erklären wir ausführlich im Beitrag millis() statt delay(). Alle 8 Sekunden für 300 ms 106 mA zu ziehen bedeutet im Mittel nur etwa 4 mA zusätzlich. Schaltet deine Powerbank trotzdem ab, verkürze die Periode auf 5 Sekunden oder verlängere den Impuls auf 500 ms; jedes Modell nutzt eine andere Schwelle und Wartezeit.

Eigene Versorgung für Motoren und Servos, gemeinsame Masse

Motoren und Servos sind die Lasten, die beim Batteriebetrieb eines Arduino die meisten Probleme machen. Ein Servo zieht in dem Moment, in dem er losläuft, einen Stromstoß von mehreren hundert Milliampere, und DC-Motoren brauchen beim Anlaufen oder Blockieren ein Vielfaches ihres Normalstroms. Dieser Stoß kann die 5-V-Schiene kurz einbrechen lassen; fällt die Spannung tief genug, greift der Unterspannungsschutz (Brown-out) des ATmega328P und das Board startet neu. Außerdem stören die Bürstengeräusche der Motoren die Sensorwerte. Die Regel ist einfach: Versorge über den 5V-Pin des Arduino höchstens ein kleines Servo und betreibe alle anderen Motoren aus einer eigenen Quelle. Wie Servos und DC-Motoren funktionieren, erfährst du in Servomotor und DC-Motor mit L298N steuern.

1. Wähle eine eigene Quelle für die Motoren: 5–6 V für Servos (4×AA NiMH oder ein auf 5–6 V eingestellter LM2596), für DC-Motoren einen Akku passend zur Motorspannung (z. B. 2S 18650).
2. Verbinde den Pluspol der Quelle nur mit den roten Servokabeln oder dem Leistungseingang des Motortreibers, nicht mit dem 5V-Pin des Arduino.
3. Versorge den Arduino über seinen eigenen Eingang: Du kannst denselben 2S-Akku auch an die Hohlbuchse anschließen, solange der Motorstrom nicht durch den Regler des Arduino fließt.
4. Verbinde den Minuspol (GND) der Quelle mit dem GND-Pin des Arduino. Ohne gemeinsame Masse funktioniert das Steuersignal nicht.
5. Schließe das orange oder gelbe Signalkabel des Servos an einen Digitalpin des Arduino an (z. B. D9); die Servo-Bibliothek funktioniert auch an Pins ohne PWM-Kennzeichnung.
6. Setze einen Elko mit 470–1000 µF nahe an den Servos an deren Versorgung; achte auf die Polung.
7. Beim L298N speist du die Motorspannung an der 12V-Klemme ein; liegt sie über 12 V, zieh den 5V-EN-Jumper ab und versorge den Arduino aus einer eigenen Quelle.

Wie berechnet man Stromaufnahme und Laufzeit?

Bei einem batteriebetriebenen Projekt lautet die eigentliche Frage: "Wie lange hält es durch?". Die Grundformel ist einfach: Laufzeit (Stunden) = Kapazität (mAh) × 0,85 / Durchschnittsstrom (mA). Der Faktor 0,85 berücksichtigt, dass eine Batterie nie ihre volle Nennkapazität liefert: Bei hohem Strom und Kälte sinkt die Kapazität, die Schaltung hört auf, bevor die Batterie ganz leer ist, und Wandler verursachen Verluste. Bei Batterien, deren Spannung früh einbricht, etwa dem 9V-Block, ist 0,7 realistischer. Verbringt dein Projekt die meiste Zeit im Schlaf, berechne zuerst den Durchschnittsstrom: Durchschnittsstrom = (Aktivstrom × Aktivzeit + Schlafstrom × Schlafzeit) / Gesamtzeit. Statt das von Hand zu rechnen, kannst du den Akkulaufzeit-Rechner nutzen; gib Kapazität, Wach- und Schlafstrom sowie das Weckintervall ein, und er zeigt die Laufzeit in Stunden, Tagen oder Monaten.

Messen ist immer besser als schätzen. Stell dein Multimeter auf den Strombereich (mA) und schalte es in Reihe zwischen Batterie und Schaltung, dann siehst du den echten Verbrauch; wie das geht, zeigen wir in Multimeter richtig benutzen. Ist der Wert höher als erwartet, schau zuerst auf den Eigenverbrauch des Boards: Beim Uno ziehen der USB-Seriell-Chip (ATmega16U2), die Power-LED und der Regler mehr als 30 mA, selbst wenn der ATmega328P schläft. Für lange Akkulaufzeiten greift man deshalb zu Boards ohne USB-Chip wie dem Arduino Pro Mini; ein Pro Mini ohne Power-LED und Regler kommt im Schlafmodus auf Mikroampere herunter.

Schritt für Schritt: dein Projekt auf Batteriebetrieb umstellen

1. Miss mit dem Multimeter den durchschnittlichen und den Spitzenstrom, während das Projekt über USB läuft, auch während sich Servo oder Motor bewegen.
2. Trenne Lasten mit hohem Strom wie Motoren, Servos und LED-Streifen ab und plane eine eigene Quelle dafür.
3. Wähle den Eingang des Boards: beim Uno ein 7–12-V-Paket an die Hohlbuchse oder geregelte 5 V an USB bzw. den 5V-Pin, beim Pico 1,8–5,5 V an VSYS.
4. Berechne die nötige Kapazität für die gewünschte Laufzeit oder nutze den Akkulaufzeit-Rechner.
5. Setze einen Ein/Aus-Schalter in die Plusleitung der Batterie; stell sicher, dass Li-Ion-Akkus eine Schutzplatine (BMS) haben.
6. Lade den Code per USB hoch, zieh dann USB ab und teste mit Batterie; prüfe mit dem Multimeter die Spannung am 5V-Pin, während sich das Servo bewegt.
7. Überwache die Batteriespannung im Code und warne, wenn sie unter einen bestimmten Wert fällt (Code unten).

Batteriespannung mit dem Arduino messen

Statt zu raten, wann die Batterie leer ist, kannst du ihre Spannung messen. Die Analogeingänge des Arduino lesen höchstens 5 V, also kannst du einen 2S-Akku mit bis zu 8,4 V nicht direkt an A0 anschließen; du brauchst einen Spannungsteiler. Zwei Widerstände mit 100 kΩ und 10 kΩ teilen die Spannung durch 11: Aus 8,4 V werden an A0 etwa 0,76 V. Da die 5-V-Schiene des Boards mit schwächer werdender Batterie driften kann, misst du genauer gegen die interne 1,1-V-Referenz, die nicht von der Versorgungsspannung abhängt. Die Widerstandswerte für deinen Akku findest du mit dem Spannungsteiler-Rechner, mehr zum Thema im Beitrag Spannungsteiler.

1// 2S Li-ion paket gerilimini ölçme / measuring a 2S Li-ion pack voltage
2// Pil+ -> 100k -> A0 -> 10k -> GND / pack+ -> 100k -> A0 -> 10k -> GND
3const int BAT_PIN = A0;
4const int LED_PIN = 13;      // pil zayıf uyarısı / low-battery warning
5const float R1 = 100000.0;   // üst direnç / top resistor
6const float R2 = 10000.0;    // alt direnç / bottom resistor
7const float VREF = 1.1;      // dahili referans, multimetreyle düzelt / internal reference, calibrate with a multimeter
8const float LOW_V = 6.6;     // 2S için alt sınır (3,3 V/hücre) / low limit for 2S (3.3 V per cell)
9
10void setup() {
11  Serial.begin(9600);
12  pinMode(LED_PIN, OUTPUT);
13  analogReference(INTERNAL);   // 1,1 V referans (Uno/Nano) / 1.1 V reference (Uno/Nano)
14  analogRead(BAT_PIN);         // ilk ölçümü at / discard the first reading
15  delay(10);
16}
17
18void loop() {
19  long sum = 0;
20  for (int i = 0; i < 16; i++) {   // 16 ölçümün ortalaması / average of 16 readings
21    sum += analogRead(BAT_PIN);
22    delay(2);
23  }
24  float pinV = (sum / 16.0) * VREF / 1024.0;
25  float batV = pinV * (R1 + R2) / R2;
26
27  Serial.print("Pil / Battery: ");
28  Serial.print(batV, 2);
29  Serial.println(" V");
30
31  digitalWrite(LED_PIN, batV < LOW_V ? HIGH : LOW);   // zayıfsa LED yanar / LED on when low
32  delay(2000);
33}

Schließe das obere Ende des Teilers hinter dem Ein/Aus-Schalter an den Pluspol der Batterie an, damit der Teiler die Batterie nicht leert, während das Gerät aus ist. Die interne 1,1-V-Referenz kann von Chip zu Chip um etwa ±10 % abweichen: Vergleiche die mit dem Multimeter gemessene Batteriespannung mit dem Wert im seriellen Monitor und korrigiere VREF entsprechend (z. B. auf 1,08). Der Teiler zieht ständig etwa 76 µA, was die Akkulaufzeit praktisch nicht beeinflusst. Der Code ist für Uno und Nano; beim Mega heißt die Referenz INTERNAL1V1. Die Schwelle von 6,6 V entspricht 3,3 V pro Zelle; dann sind die Zellen fast leer, und unter 3,0 V pro Zelle nehmen sie Schaden. Hängt der Akku an der Hohlbuchse, sackt die 5-V-Schiene schon ab etwa 7 V ab, daher ist auch LOW_V = 7,0 sinnvoll.

ESP32 mit Batterie betreiben

ESP32-Entwicklungsboards arbeiten mit 3,3 V und lassen sich auf drei Arten versorgen: über die USB-Buchse, den 5V-Pin (bei manchen Boards VIN) oder direkt über den 3V3-Pin. Espressif verlangt ausdrücklich, dass diese Wege nicht gleichzeitig genutzt werden, sondern immer nur einer. Spannung am 5V-Pin läuft durch den 3,3-V-LDO-Regler des Boards (bei den meisten Klonen ein AMS1117), während der 3V3-Pin nur geregelte 3,0–3,6 V verträgt. Beim Senden über WLAN zieht der ESP32 Spitzen bis 240 mA, daher braucht er eine Quelle, die mindestens 500 mA liefern kann; sonst startet er mit dem Fehler "Brownout detector was triggered" neu (Details im Beitrag Brownout-Fehler). Schließe eine einzelne 18650 nicht direkt an den 3V3-Pin an: Mit 4,2 V im vollen Zustand überschreitet sie die Grenze. Auch der 5V-Pin passt nicht gut, denn der AMS1117 braucht etwa 1,1 V Spannungsabfall, und mit sinkender Zellspannung fällt der Ausgang unter 3,3 V. Richtig sind: 18650 mit 5-V-Boost an den 5V-Pin, ein Low-Dropout-Regler für 3,3 V, der mindestens 500 mA liefert, oder ein ESP32-Board mit eingebautem Li-Ion-Lader. Entscheidend für die Laufzeit ist aber, dass der ESP32 die meiste Zeit im Tiefschlaf (Deep Sleep) verbringt; der Chip zieht darin etwa 10 µA, aber USB-Seriell-Chip, LED und Regler auf Entwicklungsboards können das in den Milliamperebereich treiben. Daher kommt der Unterschied zwischen 3 Monaten und 18 Tagen in der Tabelle oben; mehr dazu in ESP32 Deep Sleep.

1// ESP32: 18650 gerilimini ölç, sonra derin uykuya geç / measure the 18650, then deep sleep
2// Pil+ -> 100k -> GPIO34 -> 100k -> GND / cell+ -> 100k -> GPIO34 -> 100k -> GND
3const int BAT_PIN = 34;                         // yalnız giriş, ADC1 / input-only, ADC1
4const uint64_t SLEEP_US = 60ULL * 1000000ULL;   // 60 saniye / 60 seconds
5
6void setup() {
7  Serial.begin(115200);
8  uint32_t mv = 0;
9  for (int i = 0; i < 16; i++) {
10    mv += analogReadMilliVolts(BAT_PIN);        // kalibre milivolt / calibrated millivolts
11  }
12  float batV = (mv / 16.0) * 2.0 / 1000.0;      // bölücü yarıya indirir / the divider halves it
13  Serial.printf("Pil / Battery: %.2f V\n", batV);
14
15  if (batV < 3.3) {
16    Serial.println("Pil zayif / Battery low");  // işi atla, pili koru / skip the work, protect the cell
17  } else {
18    // sensörü oku, Wi-Fi ile gönder / read the sensor, send over Wi-Fi
19  }
20
21  esp_sleep_enable_timer_wakeup(SLEEP_US);      // 60 sn sonra uyan / wake up after 60 s
22  Serial.flush();
23  esp_deep_sleep_start();                       // loop() hiç çalışmaz / loop() never runs
24}
25
26void loop() {
27}

Bei jedem Aufwachen misst der Code die Batteriespannung, erledigt seine Arbeit und geht mit einem 60-Sekunden-Timer wieder schlafen; da ein ESP32 nach dem Tiefschlaf das Programm von vorn startet, läuft loop() nie. GPIO 34 ist ein reiner Eingangs-Pin an ADC1 und funktioniert auch bei aktivem WLAN, während die ADC2-Pins nicht zusammen mit WLAN nutzbar sind. analogReadMilliVolts() nutzt die Werkskalibrierung des Chips und gibt direkt Millivolt zurück. Der Teiler aus 100 kΩ + 100 kΩ macht aus 4,2 V 2,1 V und zieht nur 21 µA; ist die Messung unruhig, setze einen 100-nF-Kondensator zwischen GPIO 34 und GND. Für deine ersten Schritte mit dem ESP32 ist Was ist der ESP32? ein guter Einstieg.

Raspberry Pi Pico mit Batterie betreiben

Der Raspberry Pi Pico gehört zu den einfachsten Boards für den Batteriebetrieb, denn statt eines Linearreglers sitzt auf ihm ein Buck-Boost-Schaltregler. Gib dem VSYS-Pin irgendeine Spannung zwischen 1,8 und 5,5 V, und das Board wandelt sie effizient in 3,3 V um; es läuft sogar weiter, wenn der Eingang unter 3,3 V fällt. So kannst du 2 oder 3 AA-Zellen, eine einzelne 18650 oder einen einzelligen LiPo ohne Zusatzmodul direkt zwischen VSYS und GND anschließen. Aufpassen musst du nur beim gleichzeitigen USB-Betrieb: Die 5 V von USB (VBUS) sind über eine Schottky-Diode mit VSYS verbunden; hängt die Batterie direkt an VSYS und du steckst USB ein, versucht USB Strom in die Batterie zu drücken. Raspberry Pi empfiehlt, die Batterie über eine eigene Schottky-Diode (z. B. 1N5817) an VSYS anzuschließen. Der 3V3-Pin liefert externen Schaltungen höchstens etwa 300 mA, und wenn du den Pin 3V3_EN auf GND ziehst, schaltest du den Regler und damit das ganze Board ab. Einen Überblick über das Board gibt dir Was ist der Raspberry Pi Pico?.

1from machine import ADC, Pin
2import time
3
4vsys = ADC(29)            # VSYS/3 ölçer (Pico) / measures VSYS/3 (Pico)
5usb = Pin(24, Pin.IN)     # USB takılıysa 1 / 1 when USB is connected
6CONV = 3.3 / 65535        # ham değeri volta çevir / raw value to volts
7
8while True:
9    total = 0
10    for _ in range(16):   # 16 ölçümün ortalaması / average of 16 readings
11        total += vsys.read_u16()
12    volts = total / 16 * CONV * 3   # kart içindeki bölücü 3'e böler / on-board divider divides by 3
13    source = "USB" if usb.value() else "Pil / Battery"
14    print("{}: VSYS = {:.2f} V".format(source, volts))
15    if not usb.value() and volts < 3.3:   # 3xAA ya da 18650 için alt sınır / low limit for 3xAA or a 18650
16        print("Pil zayif! / Battery low!")
17    time.sleep(5)

Beim Pico misst GP29 über einen Teiler auf dem Board ein Drittel von VSYS, während GP24 bei eingestecktem USB 1 liest. So erfährst du ohne zusätzliche Bauteile sowohl die Batteriespannung als auch, ob das Board über USB oder die Batterie läuft. Hast du die Batterie wie empfohlen über eine Schottky-Diode angeschlossen, liegt der gemessene VSYS-Wert etwa 0,2–0,3 V unter der Batteriespannung. Die Messung setzt eine ADC-Referenz von 3,3 V voraus; dank des Buck-Boost-Reglers bleibt diese Referenz stabil, auch wenn die Batterie schwächer wird. Beim Pico W teilen sich GP29 und GP24 Leitungen mit dem Funkchip, daher läuft dieser Code dort nicht unverändert; den USB-Status liest du dort mit Pin("WL_GPIO2"). Um die Laufzeit zu verlängern, nutze zwischen den Messungen machine.lightsleep() statt time.sleep().

Projektideen mit Batteriebetrieb

• Bluetooth-gesteuertes Roboterauto: Versorge Motoren und Arduino aus einem 2S-18650-Akku; Details im Beitrag Arduino-Auto bauen.
• Hindernis-ausweichender Roboter: Verhindere Resets, indem du die Motoren über den L298N aus einer eigenen Leitung und den Arduino über die Hohlbuchse versorgst (Hindernis-Roboter).
• Voltmeter mit Batterieanzeige: Zeig den über einen Spannungsteiler gemessenen Wert auf einem LCD an (Arduino-Voltmeter bauen).
• Bodenfeuchte-Station im Garten: Halte einen ESP32 im Tiefschlaf, miss einmal pro Stunde die Bodenfeuchte und betreibe ihn monatelang mit einer einzigen 18650.
• Mobiler GPS-Logger: Zeichne deine Wanderroute mit einem NEO-6M-GPS und einer Powerbank auf.
• Pico-Nachtlicht mit Batterie: Ein über VSYS aus 3×AA versorgter Pico schaltet LEDs ein, sobald es dunkel wird.

Häufige Fehler und ihre Lösungen

Die richtige Stromversorgung ist die halbe Miete für ein stabiles Projekt: Wähle den passenden Eingang, versorge Motoren getrennt, verbinde die Massen und berechne die Akkulaufzeit von Anfang an. Wenn du bereit bist, ein batteriebetriebenes Projekt zu bauen, schau dir in der BlueGrays-App das Bluetooth-Auto mit L298N, den Hindernis-Roboter, die smarte Bewässerungsstation, das digitale Voltmeter mit LCD und das ESP32-Deep-Sleep-Projekt zum Energiesparen an; jedes erklärt Schaltplan, Verkabelung und Code Schritt für Schritt.