Was bedeutet mAh? Akkukapazität, Wh und Laufzeit berechnen

Was bedeutet mAh? Kurz gesagt ist mAh (Milliamperestunde) die Einheit für die Kapazität, also dafür, wie viel elektrische Ladung eine Batterie oder ein Akku speichert. 1 mAh bedeutet, dass ein Strom von 1 Milliampere eine Stunde lang fließt. Ein Akku mit 2000 mAh kann also theoretisch eine Schaltung mit 20 mA Stromaufnahme 100 Stunden lang versorgen oder eine mit 200 mA 10 Stunden lang. Allein reicht dieser Wert aber nicht: Die Spannung, der entnommene Strom, die Temperatur und der Spannungsregler zwischen Akku und Schaltung verändern die tatsächliche Laufzeit erheblich.

Wenn du ein batteriebetriebenes Projekt mit Arduino, ESP32 oder Raspberry Pi Pico baust, lautet die erste Frage immer gleich: Wie viele Stunden oder Tage hält dieser Akku? In dieser Anleitung lernst du, was mAh und Wh bedeuten, wie groß die echte Kapazität von AA-, 9V-, 18650- und LiPo-Zellen ist, wie du den Stromverbrauch deines Projekts mit einem Multimeter und einem INA219 misst, wie du die Laufzeit mit einer Formel berechnest, wie du Akkus in Reihe und parallel schaltest, was die C-Rate ist und warum eine 9V-Batterie eine schlechte Wahl ist, alles mit echten Zahlen.

Was bedeutet mAh? Die Akkukapazität einfach erklärt

Strom wird in Ampere (A) gemessen, die Kapazität in Amperestunden (Ah). Für kleine Batterien verwendet man die Milliamperestunde, ein Tausendstel davon: 1 Ah = 1000 mAh. Physikalisch ist das eine elektrische Ladung; 1 mAh entspricht 3,6 Coulomb. Hersteller messen die Kapazität bei einem bestimmten Entladestrom bis zu einer bestimmten Entladeschlussspannung. Je höher der Strom, desto mehr Spannung fällt am Innenwiderstand ab, die chemische Reaktion kommt nicht mehr hinterher, und die Schlussspannung ist früher erreicht. Deshalb liefert dieselbe Batterie bei hohem Strom weniger mAh. Auch Kälte senkt die Kapazität; Alkalibatterien werden unter 0 °C deutlich schwächer. Die Tabelle zeigt nach den Daten von Energizer, wie der entnommene Strom die Kapazität einer AA-Alkalibatterie verändert (bis 0,8 V, bei 21 °C).

Der Unterschied ist verblüffend: Wenn du den Strom verzwanzigfachst, sinkt die Laufzeit nicht auf ein Zwanzigstel, sondern auf ein Vierzigstel. Betrachte den mAh-Wert auf dem Etikett deshalb als Bestfall. In echten Projekten kommt noch hinzu, dass die Schaltung abschaltet, bevor der Akku ganz leer ist: Der Regler des Arduino Uno kann die 5 V nicht mehr halten, sobald seine Eingangsspannung unter 7 V fällt, und eine einzelne Lithiumzelle sollte bei etwa 3,0–3,3 V abgeschaltet werden, damit ihre Lebensdauer nicht leidet. Die Energie, die dann noch im Akku steckt, wird nie genutzt.

Was bedeutet Wh? Der Unterschied zwischen mAh und Wh

mAh gibt nur die Ladungsmenge an; um die Energie eines Akkus zu bestimmen, musst du mit der Spannung multiplizieren. Die Einheit der Energie ist die Wattstunde (Wh), die Formel lautet: Wh = mAh × V / 1000. Eine 18650-Zelle mit 3,7 V und 3000 mAh speichert zum Beispiel 3,7 × 3 = 11,1 Wh. Eine AA-Batterie mit 2500 mAh kommt rechnerisch auf 1,5 × 2,5 = 3,75 Wh; da die mittlere Spannung einer Alkalizelle während der Entladung aber auf 1,2–1,3 V sinkt, liegt der echte Wert bei etwa 3 Wh. Deshalb führt ein Vergleich von Batterien mit unterschiedlicher Spannung allein über mAh in die Irre: Eine 9V-Batterie mit 550 mAh wirkt viel kleiner als eine AA-Zelle mit 2500 mAh, speichert mit etwa 4 Wh aber sogar etwas mehr Energie. Welche in deinem Projekt länger hält, hängt vom Reglertyp dazwischen ab; das siehst du im Abschnitt zur Laufzeitberechnung. Um den Zusammenhang zwischen Leistung und Strom (P = U × I) schnell auszurechnen, kannst du den Ohmsches-Gesetz-Rechner verwenden.

Vergleichstabelle: AA, 9V, 18650 und LiPo

Beim Lesen der Tabelle gilt: Lithiumzellen wie 18650 und LiPo speichern im Verhältnis zu ihrem Gewicht die meiste Energie; eine einzige 18650-Zelle bringt fast so viel Energie mit wie vier AA-Alkalibatterien zusammen, bei etwa halbem Gewicht. Alkalibatterien eignen sich gut für Geräte mit geringem Strom, die lange im Regal liegen, denn sie verlieren nur wenige Prozent Kapazität pro Jahr; bei hohen Lasten wie Motoren oder Servos bricht ihre Spannung dagegen schnell ein. NiMH-Akkus liefern trotz ihrer niedrigen 1,2 V problemlos hohe Ströme, und die selbstentladungsarme Variante (LSD) bleibt monatelang geladen. Eine CR2032-Knopfzelle ist nur für Uhrenmodule und schlafende Sensoren im Mikroamperebereich gedacht; einen ESP32, der sich mit dem WLAN verbindet, kann sie niemals versorgen.

Warum ist eine 9V-Batterie eine schlechte Wahl?

Der rechteckige 9V-Block taucht oft in Starter-Kits auf, weil sein Clip-Kabel direkt in die DC-Buchse des Arduino passt, doch für ein batteriebetriebenes Arduino-Projekt ist er eine der schlechtesten Optionen. Im Inneren stecken sechs kleine Zellen in Reihe, deshalb beträgt seine Kapazität nur 400–600 mAh. Laut Energizer liefert eine 9V-Alkalibatterie bei Entladung bis 4,8 V etwa 600 mAh bei 10 mA, 570 mAh bei 25 mA und nur noch 450 mAh bei 50 mA. Der Regler des Arduino Uno braucht an der DC-Buchse aber mindestens 7 V; unter Last fällt die Batteriespannung innerhalb weniger Stunden unter diese Grenze, und der Rest der Energie bleibt ungenutzt. Deshalb läuft ein Uno mit rund 50 mA Stromaufnahme an einem 9V-Block meist nur wenige Stunden, oft 4–8 Stunden.

• Geringe Kapazität: nur 400–600 mAh gegenüber 2000–2500 mAh bei einem 6×AA-Pack, also mehr als viermal kürzere Laufzeit bei gleichen 9 V.
• Hoher Innenwiderstand: Wenn ein Servo anläuft oder ein Relais anzieht, bricht die Spannung schlagartig ein und der Arduino startet neu.
• Reglerverluste: Der Linearregler des Uno wandelt die 4 V Differenz zwischen 9 V und 5 V in Wärme um; bei 50 mA gehen von den 0,45 W aus der Batterie etwa 0,2 W verloren.
• Teure Energie: Die Kosten pro Wh liegen deutlich über denen von AA-Batterien, und wiederaufladbare 9V-NiMH-Akkus haben sogar nur 170–300 mAh.
• Wo er gut ist: In Rauchmeldern, Multimetern oder Geräten, die wenige mA ziehen und lange warten, ist ein 9V-Block völlig in Ordnung. Für den Arduino nimm lieber ein 6×AA-Pack, ein 2S-18650-Pack oder eine Powerbank; Details findest du im Artikel Arduino mit Batterie betreiben.

Stromverbrauch deines Arduino-Projekts messen

Um die Akkulaufzeit zu berechnen, musst du zuerst wissen, wie viel Strom dein Projekt zieht. Messen ist besser als Schätzen, denn der Eigenverbrauch des Boards, Power-LEDs und Spannungsregler ziehen oft mehr Strom als die Sensoren. Am einfachsten schaltest du ein Multimeter in Reihe zwischen Akku und Schaltung. Bei Projekten mit Schlaf- und Wachphasen liefert ein Stromsensor wie der INA219 bessere Ergebnisse, weil er kurze Stromspitzen und den echten Mittelwert erfasst. Alles über Messbereiche und Buchsen des Multimeters erfährst du im Artikel Multimeter richtig benutzen.

1. Schalte die Schaltung stromlos; stecke die rote Messleitung in die mA-Buchse und die schwarze in COM. Wenn der Strom 200 mA übersteigen könnte, beginne mit der 10A-Buchse.
2. Stelle den Drehschalter auf Gleichstrom (A⎓) und, falls das Gerät keine automatische Bereichswahl hat, auf den 200-mA-Bereich.
3. Trenne das Pluskabel des Akkus von der Schaltung; halte die rote Messspitze an den Pluspol des Akkus und die schwarze an den Pluseingang der Schaltung. So fließt der gesamte Strom durch das Multimeter.
4. Schalte die Schaltung ein und lies den Wert ab. Miss auch getrennt, während sich ein Servo bewegt, das WLAN verbindet oder ein Relais angezogen ist, und notiere den Strom für jeden Zustand.
5. Liegt der Schlafstrom im Mikroamperebereich, wechsle in den µA-Bereich. Beim Start bekommt das Board in diesem Bereich eventuell nicht genug Strom; überbrücke die Messspitzen beim Einschalten mit einem Jumperkabel und entferne es, sobald das Board schläft.
6. Setze die gemessenen Ströme zusammen mit der Dauer jedes Zustands in die Formel für den mittleren Strom weiter unten ein.

Strom und verbrauchte mAh mit dem INA219 messen

Der INA219 ist ein kleines Strom- und Spannungsmessmodul mit I2C. Er misst den Spannungsabfall am 0,1-Ω-Shunt auf der Platine mit 12 Bit Auflösung und erfasst in Schaltungen bis 26 V Ströme bis etwa ±3,2 A mit einer Auflösung von rund 0,1 mA. Seine Standard-I2C-Adresse ist 0x40. Du schaltest das Modul in Reihe in die Plusleitung der zu messenden Schaltung: Der Pluspol des Akkus kommt an Vin+, Vin− geht an den Pluseingang der Schaltung. Der messende Arduino wird über USB versorgt, und seine GND wird mit der GND der gemessenen Schaltung verbunden. Du brauchst nur die Bibliothek Adafruit INA219 aus dem Bibliotheksverwalter der Arduino IDE. Schlafströme im Mikroamperebereich kann der INA219 nicht auflösen; die misst du mit dem µA-Bereich eines Multimeters.

1// INA219 ile akım, harcanan mAh ve pil ömrü / current, used mAh and battery life with INA219
2#include <Wire.h>
3#include <Adafruit_INA219.h>
4
5Adafruit_INA219 ina219;                    // varsayılan adres 0x40 / default address 0x40
6
7const float CAPACITY_MAH = 2500.0;         // pilin etiket kapasitesi / rated battery capacity
8const float USABLE = 0.85;                 // kullanılabilir oran / usable share
9
10float usedMah = 0;                         // toplam harcanan yük / total charge used
11float secMaMs = 0;                         // son saniyenin mA x ms toplamı / mA x ms of the last second
12unsigned long startMs, lastSample, lastPrint;
13
14void setup() {
15  Serial.begin(9600);
16  if (!ina219.begin()) {
17    Serial.println(F("INA219 bulunamadi / INA219 not found"));
18    while (true) {}
19  }
20  ina219.setCalibration_32V_1A();          // 1 A'e kadar ince ölçüm / finer steps up to 1 A
21  startMs = lastSample = lastPrint = millis();
22}
23
24void loop() {
25  unsigned long now = millis();
26
27  if (now - lastSample >= 10) {            // 10 ms'de bir örnek / one sample every 10 ms
28    float mA = ina219.getCurrent_mA();
29    secMaMs += mA * (now - lastSample);    // akım x süre / current x time
30    lastSample = now;
31  }
32
33  if (now - lastPrint >= 1000) {           // saniyede bir rapor / report once a second
34    lastPrint = now;
35    usedMah += secMaMs / 3600000.0;        // mA x ms -> mAh
36    secMaMs = 0;
37    float avgMa = usedMah / ((now - startMs) / 3600000.0);   // ortalama akım / average current
38    float volts = ina219.getBusVoltage_V() + ina219.getShuntVoltage_mV() / 1000.0;   // pil gerilimi / battery voltage
39
40    Serial.print(F("Pil / Battery: "));
41    Serial.print(volts, 2);
42    Serial.print(F(" V | Ort / Avg: "));
43    Serial.print(avgMa, 1);
44    Serial.print(F(" mA | Harcanan / Used: "));
45    Serial.print(usedMah, 2);
46    Serial.print(F(" mAh"));
47    if (avgMa > 0.5) {
48      Serial.print(F(" | Sure / Runtime: "));
49      Serial.print(CAPACITY_MAH * USABLE / avgMa, 1);   // saat / hours
50      Serial.print(F(" h"));
51    }
52    Serial.println();
53  }
54}

Der Code liest alle 10 Millisekunden den Strom und summiert die Produkte aus Strom × Zeit zu den verbrauchten mAh; so fließen auch kurze Stromimpulse wie eine WLAN-Übertragung oder eine Servobewegung in den Mittelwert ein. Einmal pro Sekunde gibt er die Akkuspannung, den bisherigen mittleren Strom, die verbrauchte Kapazität und die geschätzte Laufzeit bezogen auf 85 % der Nennkapazität im seriellen Monitor aus. Lass die Messung mindestens einen vollständigen Betriebszyklus laufen, zum Beispiel so lange, dass ein ganzer Schlaf- und Wachzyklus erfasst wird. Bei Lasten über 1 A verwendest du setCalibration_32V_2A(). Derselbe Code läuft auf dem ESP32 unverändert an GPIO 21 und 22; Hilfe zum seriellen Monitor findest du im Artikel Arduino Serial Monitor.

Laufzeit berechnen: Kapazität / Strom × Wirkungsgrad

Kennst du den mittleren Strom, ist die Grundformel einfach: Laufzeit (Stunden) = Kapazität (mAh) / mittlerer Strom (mA) × Wirkungsgrad. Als Faktor ist 0,85 ein guter Startwert; er berücksichtigt die Kapazität, die bei hohem Strom und Kälte verloren geht, das Abschalten der Schaltung vor der vollständigen Entladung und die Alterung des Akkus. Diese Formel gilt, wenn zwischen Akku und Schaltung kein Regler oder ein Linearregler sitzt (der 5-V-Regler des Uno, AMS1117, 7805), denn beim Linearregler ist der Eingangsstrom gleich dem Ausgangsstrom und die Spannungsdifferenz wird zu Wärme. Nutzt du einen Schaltregler wie einen Step-up- oder Step-down-Wandler, rechnest du mit der Energie: Laufzeit (Stunden) = Akkuenergie (Wh) × Wirkungsgrad / Leistung der Last (W). Hier ist der Wirkungsgrad das Produkt aus den 85–90 % des Wandlers und dem nutzbaren Anteil des Akkus; 0,75–0,8 ist realistisch.

Bei Projekten, die schlafen und aufwachen, brauchst du zuerst den mittleren Strom: Mittlerer Strom = (Wachstrom × Wachzeit + Schlafstrom × Schlafzeit) / Gesamtzeit. Ein nacktes ESP32-Modul, das alle 10 Minuten für 5 Sekunden mit 120 mA aufwacht und die restlichen 595 Sekunden mit 10 µA (0,01 mA) schläft, kommt zum Beispiel auf (120 × 5 + 0,01 × 595) / 600 ≈ 1,01 mA. Mit einer 3000-mAh-18650-Zelle ergibt das 3000 / 1,01 × 0,85 ≈ 2520 Stunden, also rund 3,5 Monate. Läuft derselbe Code auf einem Entwicklungsboard, das im Schlaf 5 mA zieht, steigt der Mittelwert auf 5,96 mA und die Laufzeit sinkt auf etwa 18 Tage. Statt von Hand zu rechnen, kannst du den Akkulaufzeit-Rechner nutzen; gib einfach Kapazität, Wach- und Schlafstrom sowie das Weckintervall ein. Sinkt der mittlere Strom unter 0,1 mA, wird auch die Selbstentladung entscheidend: Eine Li-Ionen-Zelle verliert pro Monat etwa 2–3 % ihrer Kapazität.

ESP32: Wachzeit messen und Akkulaufzeit schätzen

Der Verbrauch des ESP32 schwankt je nach Betriebsart um das Tausendfache. Laut Datenblatt von Espressif zieht der Chip beim Senden über WLAN bis zu 240 mA, beim Empfangen etwa 100 mA, bei ausgeschaltetem WLAN (Modem Sleep) 20–68 mA, im Light Sleep rund 0,8 mA und im Deep Sleep nur 10 µA. Entscheidend für die Akkulaufzeit ist deshalb die Zeit, die er wach bleibt: Der WLAN-Verbindungsaufbau dauert oft 1–3 Sekunden, und die Energie dieser wenigen Sekunden übersteigt die von Stunden im Schlaf. Der folgende Code speichert bei jedem Aufwachen im RTC-Speicher, wie lange das Board wach war, und berechnet mit deinen gemessenen Strömen den mittleren Strom und die geschätzte Akkulaufzeit.

1// ESP32 derin uyku ve pil ömrü tahmini / ESP32 deep sleep and battery life estimate
2RTC_DATA_ATTR int bootCount = 0;               // derin uykuda silinmez / survives deep sleep
3RTC_DATA_ATTR unsigned long lastAwakeMs = 0;   // önceki uyanık süre / previous awake time
4
5const float ACTIVE_MA = 120.0;      // ölçtüğün uyanık akım / measured awake current
6const float SLEEP_MA = 0.01;        // ölçtüğün uyku akımı (10 µA) / measured sleep current (10 µA)
7const int SLEEP_S = 600;            // 10 dakika uyku / 10 minutes of sleep
8const float CAPACITY_MAH = 3000.0;  // 18650 kapasitesi / 18650 capacity
9const float USABLE = 0.85;          // kullanılabilir oran / usable share
10
11void setup() {
12  Serial.begin(115200);
13  bootCount++;
14
15  // Burada sensörü oku ve veriyi gönder / read the sensor and send the data here
16  delay(500);                       // örnek iş yükü / sample workload
17
18  if (lastAwakeMs > 0) {
19    float awakeS = lastAwakeMs / 1000.0;
20    float avgMa = (ACTIVE_MA * awakeS + SLEEP_MA * SLEEP_S) / (awakeS + SLEEP_S);
21    float days = CAPACITY_MAH * USABLE / avgMa / 24.0;
22    Serial.printf("Uyanis / Wake #%d, uyanik / awake: %.2f s\n", bootCount, awakeS);
23    Serial.printf("Ortalama / Average: %.3f mA, pil omru / battery life: %.0f gun / days\n", avgMa, days);
24  }
25
26  lastAwakeMs = millis();           // bu uyanışın süresi / duration of this wake
27  Serial.flush();
28  esp_sleep_enable_timer_wakeup((uint64_t)SLEEP_S * 1000000ULL);   // mikrosaniye / microseconds
29  esp_deep_sleep_start();           // loop() hiç çalışmaz / loop() never runs
30}
31
32void loop() {
33}

Beim ersten Aufwachen wird nur die Zeit gespeichert; bei jedem weiteren Aufwachen werden mit der vorherigen Wachzeit der mittlere Strom und die Akkulaufzeit in Tagen berechnet und ausgegeben. Miss ACTIVE_MA und SLEEP_MA an deinem eigenen Board mit dem Multimeter und trage sie ein. millis() zählt die Zeit des Bootloaders beim Start nicht mit; ein Aufschlag von 0,1–0,3 Sekunden auf die Wachzeit liefert ein realistischeres Ergebnis. Details zu Schlafmodi und Weckquellen findest du im Artikel ESP32 Deep Sleep, und zu Neustartproblemen im Akkubetrieb im Artikel ESP32 Brownout-Fehler.

Akkus in Reihe und parallel schalten

Schaltest du Akkus in Reihe (Plus des einen an Minus des nächsten), addieren sich die Spannungen, die Kapazität (mAh) bleibt gleich: Vier AA-Batterien mit 1,5 V und 2500 mAh ergeben in Reihe 6 V und 2500 mAh. Schaltest du sie parallel (alle Pluspole zusammen, alle Minuspole zusammen), bleibt die Spannung gleich und die Kapazitäten addieren sich: Zwei 18650-Zellen mit 3000 mAh ergeben parallel 3,7 V und 6000 mAh. In beiden Fällen wächst die Gesamtenergie (Wh) mit der Zahl der Zellen. Bei Lithium-Packs schreibt man diese Anordnung kurz mit den Buchstaben S (seriell) und P (parallel); 2S2P bedeutet zum Beispiel ein Pack aus vier Zellen, bei dem zwei parallele Paare in Reihe geschaltet sind.

• Gleiche Zellen verwenden: Nutze in einem Reihen- oder Parallelpack Zellen gleicher Marke, Kapazität, gleichen Alters und gleichen Ladezustands; eine schwächere Zelle ist früher leer und wird überlastet.
• Spannungen vor dem Parallelschalten angleichen: Bevor du Li-Ionen-Zellen parallel schaltest, sollte ihre Spannungsdifferenz höchstens 0,1 V betragen; sonst drückt die volle Zelle einen großen, unkontrollierten Strom in die leere.
• Lithium-Packs in Reihe brauchen Schutz: Ab 2S verwendest du eine BMS-Platine mit Balancer, die jede Zelle einzeln überwacht. Ein Reihenpack lässt sich nicht mit einem TP4056-Modul laden, das nur eine einzelne Zelle lädt.
• Akkus und Batterien nicht mischen: Setze Alkalibatterien und NiMH-Akkus nicht in dasselbe Pack; Spannung und Innenwiderstand unterscheiden sich.
• Parallelschaltung teilt die Last: Im 1S2P-Pack trägt jede Zelle den halben Strom; ein Parallelpack hält deshalb länger und wird bei hohem Strom weniger warm.

Was ist die C-Rate?

Die C-Rate gibt an, wie schnell ein Akku im Verhältnis zu seiner Kapazität entladen oder geladen wird. 1C ist der Strom, der den Akku in 1 Stunde vollständig entlädt, und entspricht zahlenmäßig der Kapazität: Bei einem 2000-mAh-Akku sind 1C = 2 A, 0,5C = 1 A und 20C = 40 A. Auch die Zeit lässt sich leicht bestimmen: Bei 2C ist der Akku nach etwa 30 Minuten leer, bei 0,2C nach 5 Stunden. Werte wie 25C oder 50C auf LiPos für Drohnen und RC-Modelle geben den maximalen Dauerentladestrom an; ein 1000-mAh-LiPo mit 25C kann 25 A liefern. Bei 18650-Zellen wird dieser Wert meist direkt in Ampere angegeben: Hochkapazitätszellen mit 3500 mAh liefern 8–10 A, Hochstromzellen mit 2500–3000 mAh dauerhaft 15–30 A. Beim Laden ist die Regel strenger: Der übliche Ladestrom für Lithiumzellen liegt bei etwa 0,5C, höchstens bei 1C. Ein TP4056-Modul, das mit 1 A lädt, passt gut zu einer 18650-Zelle mit 2000 mAh, belastet aber einen kleinen 300-mAh-LiPo mit etwa 3C; in diesem Fall musst du den Rprog-Widerstand des Moduls tauschen und den Ladestrom senken.

Akkukapazität mit dem Raspberry Pi Pico messen (MicroPython)

18650-Zellen mit der Aufschrift 9900 mAh sind fast immer Fälschungen; die echten 18650-Zellen mit der höchsten Kapazität liegen bei etwa 3500–3600 mAh. Die tatsächliche Kapazität eines Akkus findest du nur heraus, indem du ihn über eine bekannte Last entlädst und den Strom über die Zeit aufsummierst. Mit einem Raspberry Pi Pico, einem Lastwiderstand und einem MOSFET baust du dafür einen einfachen Kapazitätstester: Der Pico schaltet die Last über den MOSFET zu, misst die Akkuspannung über einen Spannungsteiler, berechnet den Strom mit I = U / R und trennt die Last, sobald die Spannung die Entladeschlussspannung erreicht. Die Teilerwerte kannst du mit dem Spannungsteiler-Rechner prüfen, Details zur MOSFET-Schaltung findest du im Artikel MOSFET am Arduino.

1from machine import ADC, Pin
2import time
3
4adc = ADC(26)                      # GP26: bölücünün orta noktası / divider midpoint
5load = Pin(15, Pin.OUT, value=0)   # GP15: MOSFET kapısı / MOSFET gate
6R_LOAD = 10.0                      # yük direnci, ohm (ölçüp yaz) / load resistor in ohms (measure it)
7DIV = 2.0                          # 100k + 100k bölücü / 100k + 100k divider
8CUTOFF = 3.0                       # Li-ion bitiş gerilimi / Li-ion end voltage
9CONV = 3.3 / 65535                 # ham değeri volta çevir / raw value to volts
10
11def battery_v():
12    total = 0
13    for _ in range(32):            # 32 ölçümün ortalaması / average of 32 readings
14        total += adc.read_u16()
15    return total / 32 * CONV * DIV
16
17mah = 0.0
18mwh = 0.0
19log = open("desarj.csv", "w")      # Pico'nun belleğine kaydedilir / saved to the Pico's flash
20log.write("dakika,volt,mA,mAh\n")
21load.value(1)                      # deşarjı başlat / start the discharge
22start = last = time.ticks_ms()
23
24while True:
25    time.sleep(30)
26    now = time.ticks_ms()
27    hours = time.ticks_diff(now, last) / 3600000
28    last = now
29    v = battery_v()                # yük altındaki gerilim / voltage under load
30    ma = v / R_LOAD * 1000         # I = V / R
31    mah += ma * hours
32    mwh += v * ma * hours
33    minutes = time.ticks_diff(now, start) / 60000
34    print("{:.0f} dk/min  {:.3f} V  {:.0f} mA  {:.0f} mAh  {:.2f} Wh".format(minutes, v, ma, mah, mwh / 1000))
35    log.write("{:.1f},{:.3f},{:.0f},{:.1f}\n".format(minutes, v, ma, mah))
36    log.flush()
37    if v <= CUTOFF:
38        load.value(0)              # yükü ayır, pili koru / disconnect the load, protect the cell
39        log.close()
40        print("Kapasite / Capacity: {:.0f} mAh, {:.2f} Wh".format(mah, mwh / 1000))
41        break

Alle 30 Sekunden misst der Code die Akkuspannung unter Last, berechnet den Strom und summiert die verbrauchten mAh und Wh; die Ergebnisse gibt er in der Thonny-Konsole aus und speichert sie zusätzlich in der Datei desarj.csv im Flash des Pico. Diese Datei kannst du später in Excel öffnen und die Entladekurve zeichnen (Arduino-Daten nach Excel übertragen). Mit der 10-Ω-Last dauert der Test einer 18650-Zelle mit 3000 mAh etwa 8–9 Stunden. Für genaue Ergebnisse misst du den Lastwiderstand mit dem Multimeter und trägst ihn bei R_LOAD ein; dann vergleichst du die Akkuspannung mit dem Multimeter und korrigierst den Faktor DIV. Für einen AA-NiMH-Akku senkst du CUTOFF auf 1,0 V und den Lastwiderstand auf 4,7 Ω. Bei 4,2 V setzt der Lastwiderstand etwa 1,8 W in Wärme um; wähle einen Widerstand mit mindestens 5 W, halte ihn von brennbaren Flächen fern und lass den Test nicht unbeaufsichtigt laufen. Wenn du MicroPython noch nicht auf dem Pico installiert hast, beginne mit Was ist der Raspberry Pi Pico?.

Projektideen mit Akkuberechnung

• Gartensensor, der monatelang läuft: Halte einen ESP32 im Deep Sleep, miss einmal pro Stunde die Bodenfeuchte und drücke den mittleren Strom unter 1 mA.
• Voltmeter mit Akkuanzeige: Miss die Akkuspannung und zeige sie als Prozentwert auf einem LCD an (Arduino-Voltmeter bauen).
• Das richtige Pack fürs Roboterauto: Miss den Motorstrom und berechne, wie viele Minuten ein 2S-18650-Pack hält (Arduino-Roboterauto bauen).
• Stromverbrauchs-Logger: Schreibe INA219-Messwerte auf eine SD-Karte und erstelle das tägliche Energieprofil eines Geräts (SD-Kartenmodul).
• 18650-Kapazitätsteststation: Ergänze den Pico-Tester um ein OLED-Display und zeige die mAh live an.
• Akkubetriebene Wetterstation: Betreibe einen ESP32, der alle 10 Minuten DHT11-Daten sendet, monatelang mit einer einzigen 18650-Zelle.

Häufige Fehler und Lösungen

Jetzt kennst du den Unterschied zwischen mAh und Wh, weißt, wie du den Strom deines Projekts misst und wie viele Stunden oder Tage ein Akku hält. Als Nächstes lohnt sich ein Blick in die Artikel Arduino mit Batterie betreiben und 18650 mit dem TP4056 laden. In der BlueGrays-App findest du akkubetriebene Projekte wie Energiesparen mit ESP32 Deep Sleep, ein digitales Voltmeter mit LCD, ein per Bluetooth gesteuertes Roboterauto und einen Hindernis ausweichenden Roboter, jeweils mit Schritt-für-Schritt-Schaltplänen und Code.