Basis · 17 min leestijd

Wat betekent mAh? Batterijcapaciteit, Wh en gebruiksduur uitgelegd

Wat betekent mAh en wat is het verschil met Wh? Meet de stroom van je Arduino-project, bereken de gebruiksduur en vergelijk AA-, 9V-, 18650- en LiPo-cellen.

Wat betekent mAh? Kort gezegd is mAh (milliampère-uur) de eenheid van capaciteit die aangeeft hoeveel elektrische lading een batterij opslaat. 1 mAh betekent een stroom van 1 milliampère die 1 uur lang vloeit. Een batterij van 2000 mAh kan in theorie dus een schakeling van 20 mA 100 uur lang voeden, of een schakeling van 200 mA 10 uur lang. Dat getal alleen is echter niet genoeg: de spanning van de batterij, de stroom die je trekt, de temperatuur en de regelaar tussen batterij en schakeling veranderen de echte gebruiksduur enorm.

Als je een project op batterijen bouwt met een Arduino, ESP32 of Raspberry Pi Pico, is de eerste vraag altijd dezelfde: hoeveel uur of dagen gaat deze batterij mee? In deze gids leer je wat mAh en Wh betekenen, wat de echte capaciteit is van AA-, 9V-, 18650- en LiPo-batterijen, hoe je de stroomopname van je project meet met een multimeter en een INA219, hoe je de gebruiksduur met een formule berekent, hoe je batterijen in serie en parallel schakelt, wat de C-waarde is en waarom een 9V-batterij een slechte keuze is, alles met echte cijfers.

18650 Li-ion oplaadbare batterij
Een 18650 Li-ion-cel: 3,6–3,7 V nominaal en een echte capaciteit van 2000–3500 mAh, wat neerkomt op ongeveer 7–13 Wh aan energie.

Wat betekent mAh? Batterijcapaciteit uitgelegd

Stroom wordt gemeten in ampère (A) en capaciteit in ampère-uur (Ah). Voor kleine batterijen gebruiken we het milliampère-uur, een duizendste daarvan: 1 Ah = 1000 mAh. Natuurkundig is het elektrische lading; 1 mAh is gelijk aan 3,6 coulomb. Fabrikanten meten de capaciteit bij een bepaalde ontlaadstroom tot een bepaalde eindspanning. Naarmate de stroom stijgt, gaat er meer spanning verloren over de inwendige weerstand van de batterij, kan de chemische reactie het niet bijhouden en wordt de eindspanning eerder bereikt, waardoor dezelfde batterij bij hoge stroom minder mAh levert. Ook kou verlaagt de capaciteit; alkalinebatterijen worden onder 0 °C merkbaar zwakker. De tabel hieronder laat zien hoe de stroom die je trekt de capaciteit van een AA-alkalinebatterij verandert, op basis van gegevens van Energizer (tot 0,8 V, bij 21 °C).

Continue stroomCa. capaciteitCa. gebruiksduur
25 mA3000 mAh120 uur
100 mA2500 mAh25 uur
250 mA2000 mAh8 uur
500 mA1500 mAh3 uur

Het verschil is opvallend: als je de stroom 20 keer verhoogt, daalt de gebruiksduur niet 20 keer maar 40 keer. Beschouw de mAh op het label dus als het best denkbare geval. In echte projecten komt er nog een verlies bij: de schakeling stopt voordat de batterij helemaal leeg is. De regelaar van de Arduino Uno kan geen 5 V meer vasthouden zodra de ingang onder 7 V zakt, en een enkele lithiumcel moet rond 3,0–3,3 V worden afgekapt om de levensduur niet te verkorten. De energie die dan nog in de batterij zit, wordt nooit gebruikt.

Wat betekent Wh? mAh versus Wh

mAh vertelt je alleen de hoeveelheid lading; voor de energie van de batterij moet je met de spanning vermenigvuldigen. De eenheid van energie is de wattuur (Wh) en de formule is: Wh = mAh × V / 1000. Een 18650-cel van 3,7 V en 3000 mAh bevat bijvoorbeeld 3,7 × 3 = 11,1 Wh. Een AA-batterij van 2500 mAh komt op papier uit op 1,5 × 2,5 = 3,75 Wh, maar omdat de gemiddelde spanning van een alkalinecel tijdens het ontladen daalt naar 1,2–1,3 V, is het echte getal ongeveer 3 Wh. Daarom is het misleidend om batterijen met verschillende spanningen alleen op mAh te vergelijken: een 9V-batterij van 550 mAh lijkt veel kleiner dan een AA van 2500 mAh, maar met ongeveer 4 Wh bevat hij iets meer energie. Welke het langst meegaat in jouw project, hangt af van het type regelaar ertussen; dat zie je in het gedeelte over gebruiksduur. Om snel het verband tussen vermogen en stroom (P = V × I) uit te rekenen, kun je de rekenmachine voor de wet van Ohm gebruiken.

De mAh die op een powerbank staat, verwijst naar de lithiumcellen van 3,6–3,7 V erin. Een powerbank van 10000 mAh bevat ongeveer 37 Wh; omdat ongeveer 15% daarvan verloren gaat bij het opvoeren naar 5 V op de USB-uitgang, krijg je bij 5 V maar 6000–6500 mAh. Het is ook waarom luchtvaartmaatschappijen de limiet voor powerbanks in de handbagage op 100 Wh stellen en niet in mAh.

Vergelijkingstabel van AA-, 9V-, 18650- en LiPo-batterijen

BatterijNominale spanningTypische capaciteitEnergieComfortabele stroomOplaadbaar?
AAA-alkaline1,5 V1000–1200 mAh≈1,3 WhLaag (≈100 mA)Nee
AA-alkaline1,5 V2000–3000 mAh (hangt af van de stroom)≈3 WhGemiddeld (efficiënt tot ≈250 mA)Nee
AA NiMH1,2 V1900–2500 mAh≈2,5 WhHoog (enkele A)Ja
9V-alkaline9 V400–600 mAh≈4 WhLaag (≈50 mA)Nee
CR2032-knoopcel3 V≈235 mAh≈0,7 WhZeer laag (µA tot enkele mA)Nee
18650 Li-ion3,6–3,7 V2000–3500 mAh7–13 WhHoog (5–30 A afhankelijk van de cel)Ja
1S LiPo (bijv. 1000 mAh)3,7 VModellen van 100 tot 5000 mAh≈3,7 WhVolgens de C-waarde op het labelJa
Powerbank van 10000 mAh5 V (USB)≈6000 mAh (bij 5 V)≈37 Wh1–3 AJa

Houd bij het lezen van de tabel in gedachten: lithiumcellen zoals 18650's en LiPo's slaan per gewicht de meeste energie op; één 18650 bevat bijna de totale energie van vier AA-alkalinebatterijen bij ongeveer de helft van het gewicht. Alkalinebatterijen zijn goed voor apparaten met lage stroom die lang op de plank liggen, omdat ze per jaar maar enkele procenten van hun capaciteit verliezen; bij belastingen met hoge stroom, zoals motoren of servo's, stort hun spanning echter snel in. Oplaadbare NiMH-cellen leveren ondanks hun lage 1,2 V gemakkelijk hoge stroom, en het type met lage zelfontlading (LSD) blijft maandenlang opgeladen. Een CR2032-knoopcel is alleen voor kloksmodules en slapende sensoren die op microampère-niveau werken; hij kan nooit een ESP32 voeden die verbinding maakt met wifi.

AA-batterij
AA-batterij: het alkalinetype is 1,5 V en 2000–3000 mAh, het oplaadbare NiMH-type is 1,2 V en 1900–2500 mAh; de capaciteit varieert sterk met de stroom die je trekt.

Waarom is een 9V-batterij een slechte keuze?

De rechthoekige 9V-batterij komt veel voor in starterskits omdat de drukknoopaansluiting direct in de DC-jack van de Arduino past, maar hij is een van de slechtste opties voor een Arduino-project op batterijen. Hij bevat zes kleine cellen in serie, dus zijn capaciteit is slechts 400–600 mAh. Volgens de gegevens van Energizer levert een 9V-alkalinebatterij die tot 4,8 V wordt ontladen ongeveer 600 mAh bij 10 mA, 570 mAh bij 25 mA en slechts 450 mAh bij 50 mA. De regelaar van de Arduino Uno heeft daarentegen minstens 7 V op de DC-jack nodig; onder belasting zakt de batterijspanning daar binnen een paar uur onder en kan de resterende energie niet worden gebruikt. Daarom werkt een Uno die ongeveer 50 mA trekt meestal maar een paar uur op een 9V-batterij, vaak 4–8 uur.

  • Lage capaciteit: slechts 400–600 mAh tegenover 2000–2500 mAh voor een 6×AA-houder, wat bij dezelfde 9 V meer dan vier keer minder gebruiksduur betekent.
  • Hoge inwendige weerstand: wanneer een servo gaat bewegen of een relais schakelt, stort de spanning meteen in en reset de Arduino.
  • Verlies in de regelaar: de lineaire regelaar van de Uno zet het verschil van 4 V tussen 9 V en 5 V om in warmte; bij 50 mA gaat ongeveer 0,2 W van de 0,45 W die uit de batterij wordt getrokken verloren.
  • Dure energie: de kosten per Wh liggen duidelijk hoger dan bij AA-batterijen, en oplaadbare NiMH-9V-batterijen zakken naar slechts 170–300 mAh.
  • Waar hij wel goed werkt: een 9V-batterij is prima in rookmelders, multimeters of apparaten die een paar mA trekken en lang stilstaan. Kies voor een Arduino een 6×AA-houder, een 2S 18650-pakket of een powerbank; de details staan in Een Arduino voeden met een batterij.

De stroomopname van je Arduino-project meten

Om de gebruiksduur van een batterij te berekenen, moet je eerst weten hoeveel stroom je project trekt. Meten is beter dan gokken, omdat het eigen verbruik van het board, de power-led's en de regelaars vaak meer stroom trekken dan de sensoren. De eenvoudigste manier is een multimeter in serie tussen de batterij en de schakeling aan te sluiten. Voor projecten met een slaap-/wakkercyclus geeft een stroomsensor zoals de INA219 betere resultaten, omdat die korte stroompieken en het echte gemiddelde vastlegt. Voor details over de bereiken en aansluitingen van de multimeter, zie Een multimeter gebruiken.

  1. Schakel de schakeling uit; steek de rode meetpen in de mA-aansluiting van de multimeter en de zwarte meetpen in COM. Denk je dat de stroom boven 200 mA kan komen, begin dan met de 10A-aansluiting.
  2. Draai de keuzeschakelaar naar gelijkstroom (A⎓), en naar het bereik van 200 mA als de meter geen automatische bereikkeuze heeft.
  3. Koppel de pluskabel van de batterij los van de schakeling; houd de rode meetpen tegen de pluspool van de batterij en de zwarte meetpen tegen de positieve ingang van de schakeling. Zo loopt alle stroom door de multimeter.
  4. Zet de schakeling aan en lees de waarde af. Meet apart terwijl een servo beweegt, terwijl wifi verbinding maakt of terwijl een relais bekrachtigd is, en noteer de stroom voor elke toestand.
  5. Als de slaapstroom op microampère-niveau ligt, schakel dan over naar het µA-bereik. In dit bereik krijgt het board mogelijk niet genoeg stroom om op te starten; overbrug de meetpennen met een jumperdraad tijdens het opstarten en verwijder die zodra het board slaapt.
  6. Vul de gemeten stromen, samen met de tijd die in elke toestand wordt doorgebracht, in de formule voor de gemiddelde stroom hieronder in.
Houd de multimeter bij het meten van stroom nooit direct over de batterijpolen (parallel): in de mA-aansluiting is de multimeter praktisch een kortsluiting, de zekering springt en bij lithiumbatterijen gaat er een gevaarlijk grote stroom lopen. Ook kan de interne shunt van de meter in het mA-bereik een spanningsval van een paar honderd millivolt veroorzaken; een ESP32 waarvan de stroom naar 250 mA springt tijdens het verbinden met wifi, kan daardoor resetten. Gebruik in zulke gevallen de 10A-aansluiting.
Board of moduleTypische stroomOpmerking
Arduino Uno R345–50 mARond 30 mA, zelfs in slaapstand (USB-chip, regelaar, led)
Arduino Nano (CH340)≈20 mADe power-led gebruikt enkele mA
Arduino Pro Mini 3.3 V / 8 MHzEnkele mAµA-niveau in slaapstand zodra de led en de regelaar zijn verwijderd
ESP32 DevKit, wifi uit40–70 mAHangt af van de CPU-frequentie
ESP32 DevKit, wifi verbonden80–130 mA gemiddeldPieken van 240 mA en meer tijdens het zenden
ESP32 deep sleep (kale module)≈10 µAOp een ontwikkelboard vaak enkele mA
Raspberry Pi Pico (MicroPython)20–25 mAMerkbaar hoger op de Pico W met wifi aan
LED (220 Ω, 5 V)10–15 mAHangt af van de helderheid
16x2 I2C LCD20–30 mAVooral de achtergrondverlichting
0,96" OLED (SSD1306)10–25 mAHangt af van hoeveel pixels branden
SG90 servo5–10 mA in rust, 100–250 mA tijdens het bewegen0,5 A of meer bij blokkeren
HC-SR04-afstandssensor≈15 mATijdens het meten
5V-relaismodule (bekrachtigd)70–80 mAZolang de spoel bekrachtigd is
NEO-6M GPS40–50 mATijdens het zoeken naar satellieten

Stroom en gebruikte mAh meten met een INA219

De INA219 is een kleine I2C-module voor stroom- en spanningsmeting. Hij meet de spanning over de shuntweerstand van 0,1 Ω op het board met een resolutie van 12 bit en leest stromen tot ongeveer ±3,2 A in schakelingen tot 26 V met een resolutie van circa 0,1 mA. Het standaard I2C-adres is 0x40. Je schakelt de module in serie in de positieve lijn van de te meten schakeling: de plus van de batterij gaat naar Vin+ en Vin− gaat naar de positieve ingang van de schakeling. De Arduino die meet, wordt gevoed via USB en zijn GND is verbonden met de GND van de geteste schakeling. Je hebt alleen de bibliotheek Adafruit INA219 uit de Library Manager van de Arduino IDE nodig. De INA219 kan slaapstromen op microampère-niveau niet oplossen; meet die met het µA-bereik van een multimeter.

INA219-pinArduino UnoESP32Raspberry Pi Pico
VCC5V3V33V3(OUT)
GNDGNDGNDGND
SDAA4GPIO 21GP4
SCLA5GPIO 22GP5
Vin+Plus van de batterij (+)Plus van de batterij (+)Plus van de batterij (+)
Vin−Positieve ingang van de geteste schakelingPositieve ingang van de geteste schakelingPositieve ingang van de geteste schakeling
Min van de batterij (−)GND (gemeenschappelijk)GND (gemeenschappelijk)GND (gemeenschappelijk)
C++ (Arduino IDE)
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}

De code leest elke 10 milliseconden de stroom uit en telt de producten stroom × tijd op om de gebruikte mAh te krijgen; zo worden korte stroompulsen, zoals een wifi-transmissie of een servobeweging, in het gemiddelde meegenomen. Eén keer per seconde stuurt de code de batterijspanning, de gemiddelde stroom tot nu toe, de gebruikte capaciteit en de geschatte gebruiksduur (gebaseerd op 85% van de nominale capaciteit) naar de Serial Monitor. Laat hem minstens één volledige werkcyclus draaien, bijvoorbeeld lang genoeg om een complete slaap- en wakkercyclus te omvatten. Gebruik voor belastingen boven 1 A setCalibration_32V_2A(). Dezelfde code werkt ongewijzigd op de ESP32 met GPIO 21 en 22; voor hulp met de Serial Monitor, zie Arduino Serial Monitor.

De gebruiksduur berekenen: capaciteit / stroom × rendement

Als je de gemiddelde stroom kent, is de basisformule eenvoudig: Gebruiksduur (uur) = Capaciteit (mAh) / Gemiddelde stroom (mA) × Rendement. Een rendementsfactor van 0,85 is een goed beginpunt; die houdt rekening met capaciteit die verloren gaat bij hoge stroom en in de kou, met de schakeling die stopt voordat de batterij helemaal leeg is en met veroudering van de batterij. Deze formule geldt als er geen regelaar tussen batterij en schakeling zit, of een lineaire (de 5V-regelaar van de Uno, AMS1117, 7805), want in een lineaire regelaar is de ingangsstroom gelijk aan de uitgangsstroom en wordt het spanningsverschil warmte. Gebruik je een schakelende omvormer zoals een boost- of buckmodule, reken dan met energie: Gebruiksduur (uur) = Batterijenergie (Wh) × Rendement / Belastingsvermogen (W). Het rendement is hier het rendement van de omvormer van 85–90% vermenigvuldigd met het bruikbare deel van de batterij; 0,75–0,8 is realistisch.

ScenarioGemiddelde stroom of vermogenBatterijBerekeningCa. gebruiksduur
Uno + sensor, 6×AA-houder op de DC-jack55 mAAA-alkaline, 2500 mAh2500 / 55 × 0,85≈39 uur
Dezelfde Uno op een 9V-alkalinebatterij55 mA9V, ≈450 mAh450 / 55 × 0,85≈7 uur (in de praktijk minder)
Nano + DHT11 + OLED, 3×AA op de 5V-pin35 mAAA-alkaline, 2500 mAh2500 / 35 × 0,85≈61 uur
ESP32 DevKit altijd op wifi, 18650 + 5V-boost5 V × 110 mA = 0,55 W18650, 3000 mAh (11,1 Wh)11,1 × 0,8 / 0,55≈16 uur
Pico op VSYS met 3×AA NiMH≈0,1 W3 × 1,2 V × 2000 mAh = 7,2 Wh7,2 × 0,8 / 0,1≈58 uur

Voor projecten die slapen en wakker worden, heb je eerst de gemiddelde stroom nodig: Gemiddelde stroom = (Stroom wakker × Tijd wakker + Slaapstroom × Slaaptijd) / Totale tijd. Een kale ESP32-module die elke 10 minuten 5 seconden wakker wordt met 120 mA en de resterende 595 seconden slaapt met 10 µA (0,01 mA), komt bijvoorbeeld gemiddeld uit op (120 × 5 + 0,01 × 595) / 600 ≈ 1,01 mA. Met een 18650 van 3000 mAh is dat 3000 / 1,01 × 0,85 ≈ 2520 uur, ongeveer 3,5 maanden. Draait dezelfde code op een ontwikkelboard dat in slaap 5 mA trekt, dan stijgt het gemiddelde naar 5,96 mA en daalt de gebruiksduur naar ongeveer 18 dagen. In plaats van dit met de hand te doen, kun je de rekenmachine voor batterijduur gebruiken; vul gewoon de capaciteit, de stromen in wakker en slaap en het wekinterval in. Zodra de gemiddelde stroom onder 0,1 mA komt, wordt ook de zelfontlading van de batterij een bepalende factor: een Li-ion-cel verliest ongeveer 2–3% van zijn capaciteit per maand.

ESP32: de wakkere tijd meten om de batterijduur te schatten

Het verbruik van de ESP32 varieert met een factor duizenden, afhankelijk van de werkmodus. Volgens de datasheet van Espressif trekt de chip tot 240 mA tijdens het zenden via wifi, ongeveer 100 mA tijdens het ontvangen, 20–68 mA met wifi uit (modem sleep), ongeveer 0,8 mA in light sleep en slechts 10 µA in deep sleep. Wat de batterijduur echt bepaalt, is dus de tijd dat het board wakker is: verbinding maken met wifi duurt vaak 1–3 seconden, en de energie die in die paar seconden wordt gebruikt, is meer dan in uren slaap. De onderstaande code slaat bij elk ontwaken in het RTC-geheugen op hoe lang het board wakker bleef en berekent met de stromen die je hebt gemeten de gemiddelde stroom en de geschatte batterijduur.

C++ (Arduino IDE)
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}

Bij het eerste ontwaken slaat de code alleen de tijd op; bij elk volgend ontwaken berekent en print hij met de vorige wakkere tijd de gemiddelde stroom en de batterijduur in dagen. Meet ACTIVE_MA en SLEEP_MA op je eigen board met een multimeter en vul ze in. millis() telt de bootloadertijd bij het opstarten niet mee, dus een marge van 0,1–0,3 seconden bij de wakkere tijd geeft een realistischer resultaat. Voor details over slaapmodi en wekbronnen, zie ESP32 deep sleep, en voor herstartproblemen die je op batterijvoeding kunt tegenkomen, zie ESP32 brownout-fout.

Batterijen in serie en parallel schakelen

Als je batterijen in serie schakelt (de plus van de ene aan de min van de volgende), tellen de spanningen op en blijft de capaciteit (mAh) gelijk: vier AA-batterijen van 1,5 V en 2500 mAh in serie geven 6 V, 2500 mAh. Als je ze parallel schakelt (pluspolen samen, minpolen samen), blijft de spanning gelijk en tellen de capaciteiten op: twee 18650's van 3000 mAh parallel geven 3,7 V, 6000 mAh. In beide gevallen groeit de totale energie (Wh) met het aantal cellen. Bij lithiumpakketten wordt deze opbouw geschreven met de letters S (serie) en P (parallel); 2S2P betekent bijvoorbeeld een pakket van vier cellen, opgebouwd uit twee parallelle paren die in serie zijn geschakeld.

Configuratie (18650 van 3000 mAh)Spanning (nominaal / vol)CapaciteitEnergieTypisch gebruik
1S1P3,7 V / 4,2 V3000 mAh11,1 WhESP32, Pico, Arduino via boost
1S2P3,7 V / 4,2 V6000 mAh22,2 WhESP32-sensorstation voor langdurig gebruik
2S1P7,4 V / 8,4 V3000 mAh22,2 WhArduino DC-jack, robotauto
2S2P7,4 V / 8,4 V6000 mAh44,4 WhRobots met motoren
3S1P11,1 V / 12,6 V3000 mAh33,3 Wh12V-ledstrip, 5 V via buck
  • Gebruik identieke cellen: gebruik in een serie- of parallelpakket batterijen van hetzelfde merk, dezelfde capaciteit, leeftijd en laadtoestand; een zwakkere cel raakt eerder leeg dan de andere en wordt overbelast.
  • Maak de spanningen gelijk voordat je parallel schakelt: voordat je Li-ion-cellen parallel schakelt, mag het spanningsverschil ertussen niet meer dan 0,1 V bedragen; anders pompt de volle cel een grote, ongecontroleerde stroom in de lege.
  • Lithiumpakketten in serie hebben bescherming nodig: gebruik voor 2S en grotere pakketten een BMS-print met balancering die elke cel bewaakt. Een serieel pakket kun je niet laden met een TP4056-module voor één cel.
  • Meng geen oplaadbare en wegwerpcellen: stop geen alkaline- en NiMH-batterijen in hetzelfde pakket; hun spanningen en inwendige weerstanden verschillen.
  • Parallel schakelen verdeelt de belasting: in een 1S2P-pakket draagt elke cel de helft van de stroom, dus een parallel pakket gaat langer mee en blijft bij hoge stroom koeler.

Wat is de C-waarde?

De C-waarde geeft aan hoe snel een batterij wordt ontladen of geladen in verhouding tot zijn capaciteit. 1C is de stroom die de batterij in 1 uur leegmaakt en is numeriek gelijk aan zijn capaciteit: voor een batterij van 2000 mAh is 1C = 2 A, 0,5C = 1 A en 20C = 40 A. De tijd uitrekenen is ook makkelijk: bij 2C is de batterij na ongeveer 30 minuten leeg, bij 0,2C na 5 uur. Waarden zoals 25C of 50C op drone- en RC-LiPo's geven de maximale continue ontlaadstroom aan; een LiPo van 1000 mAh en 25C kan 25 A leveren. Bij 18650-cellen wordt dit meestal direct in ampère opgegeven: cellen met hoge capaciteit van 3500 mAh leveren 8–10 A, terwijl high-drain-cellen van 2500–3000 mAh continu 15–30 A leveren. Voor laden geldt een strengere regel: de standaard laadstroom voor lithiumcellen ligt rond 0,5C en is hoogstens 1C. Een TP4056-module die met 1 A laadt, is prima voor een 18650 van 2000 mAh, maar jaagt een kleine LiPo van 300 mAh met ongeveer 3C op; in dat geval moet je de Rprog-weerstand van de module aanpassen om de laadstroom te verlagen.

C-waarde1000 mAh LiPo3000 mAh 18650Ca. tijd
0,2C200 mA600 mA5 uur
0,5C500 mA1,5 A2 uur
1C1 A3 A1 uur
2C2 A6 A30 minuten
10C10 A30 A (alleen high-drain-cellen)6 minuten

Batterijcapaciteit meten met een Raspberry Pi Pico (MicroPython)

18650-cellen met het label 9900 mAh zijn bijna altijd namaak; de originele 18650's met de hoogste capaciteit op de markt zitten rond 3500–3600 mAh. De enige manier om de echte capaciteit van een batterij te vinden, is hem te ontladen via een bekende belasting en de stroom in de tijd op te tellen. Met een Raspberry Pi Pico, een belastingsweerstand en een MOSFET bouw je een eenvoudige capaciteitstester die precies dat doet: de Pico schakelt de belasting in met de MOSFET, meet de batterijspanning via een spanningsdeler, berekent de stroom met I = V / R en koppelt de belasting los zodra de spanning de eindwaarde bereikt. Je kunt de waarden van de deler controleren met de rekenmachine voor spanningsdelers, en voor details over de bedrading van de MOSFET, zie Een MOSFET gebruiken.

OnderdeelAansluitingDoel
Plus van de batterij (+)Naar één uiteinde van de belastingsweerstand en naar de bovenste weerstand van de delerDe batterij die wordt getest
Belastingsweerstand van 10 Ω, 5 WAndere kant naar de drain van de MOSFETTrekt ongeveer 420 mA bij 4,2 V
Logic-level N-kanaal-MOSFET (bijv. IRLZ44N)Source → GND, gate → 220 Ω → GP15, 100 kΩ tussen gate en GNDSchakelt de belasting in en uit
Spanningsdeler van 100 kΩ + 100 kΩPlus van de batterij → 100 kΩ → GP26 → 100 kΩ → GNDSchaalt 4,2 V terug naar 2,1 V voor de ADC
Min van de batterij (−)Pico GNDGemeenschappelijke massa
Raspberry Pi PicoNaar de computer via USBMeten, loggen en uitvoer in Thonny
MicroPython
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

Elke 30 seconden meet de code de batterijspanning onder belasting, berekent de stroom en telt de gebruikte mAh en Wh op; hij print de resultaten naar de Thonny-console en slaat ze ook op in het bestand desarj.csv in het flashgeheugen van de Pico. Dat bestand kun je later openen in Excel om de ontlaadcurve te tekenen (Arduino-gegevens naar Excel sturen). Met de belasting van 10 Ω duurt het testen van een 18650 van 3000 mAh ongeveer 8–9 uur. Voor nauwkeurige resultaten meet je de belastingsweerstand met een multimeter en voer je die in als R_LOAD; vergelijk daarna de batterijspanning met een multimeterwaarde en pas de DIV-factor aan. Om een AA NiMH te testen, verlaag je CUTOFF naar 1.0 V en de belastingsweerstand naar 4,7 Ω. Bij 4,2 V zet de belastingsweerstand ongeveer 1,8 W om in warmte; kies een weerstand van minstens 5 W, houd hem uit de buurt van brandbare oppervlakken en laat de test niet onbeheerd draaien. Als je nog niet weet hoe je MicroPython op de Pico installeert, begin dan met Wat is de Raspberry Pi Pico?.

Projectideeën met batterijberekeningen

  • Tuinsensor die maandenlang werkt: houd een ESP32 in deep sleep, meet één keer per uur de bodemvochtigheid en breng de gemiddelde stroom onder 1 mA.
  • Voltmeter met batterijmeter: meet de batterijspanning en toon die als percentage op een LCD (Een Arduino-voltmeter bouwen).
  • Het juiste pakket voor een robotauto: meet de motorstroom en bereken hoeveel minuten een 2S 18650-pakket meegaat (Een Arduino-robotauto bouwen).
  • Logger voor stroomverbruik: schrijf INA219-metingen naar een SD-kaart om het dagelijkse energieprofiel van een apparaat op te bouwen (SD-kaartmodule).
  • Teststation voor 18650-capaciteit: voeg een OLED-display toe aan de Pico-tester en toon de mAh live.
  • Weerstation op batterijen: laat een ESP32 die elke 10 minuten DHT11-gegevens verstuurt maandenlang draaien op één 18650.

Veelgemaakte fouten en hoe je ze oplost

FoutGevolgOplossing
Batterijen met verschillende spanningen alleen op mAh vergelijkenVerkeerde batterijkeuzeReken om naar Wh: mAh × V / 1000
Rekenen op de volledige nominale capaciteitGebruiksduur 15–40% korter dan verwachtGebruik de factor 0,85 en verlaag die verder bij hoge stroom
Het eigen verbruik van het board vergetenEen Uno trekt zelfs slapend rond 30 mA; de batterij gaat uren mee in plaats van dagenGebruik een Pro Mini of een kale module en verwijder de power-led
Stroompieken niet metenReset (brownout) bij wifi-verbinding of servobewegingMeet met een INA219 en plaats een condensator van 470 µF op de voeding
De mAh-formule gebruiken bij een schakelende omvormerDe schatting wijkt 30–50% afReken met energie (Wh) en vermogen (W)
Een Arduino voeden met een 9V-batterijEen batterij die na een paar uur leeg is, plus resetsGebruik 6×AA, een 2S 18650-pakket of een powerbank
Een Li-ion-cel verder ontladen dan 3,0 VBlijvend capaciteitsverlies en risico op opzwellenBeschermde cel of BMS, eindspanning in software
18650's kopen met onrealistische mAh-waardenOngeveer een derde van de opgegeven capaciteitDoe een capaciteitstest en kies bekende merken
De effectiefste manieren om de batterijduur te verlengen zijn: de wakkere tijd verkorten, de processor laten slapen, een board kiezen zonder power-led of USB-chip, de lineaire regelaar vervangen door een regelaar met een ruststroom van enkele microampère of door een efficiënte omvormer, en sensoren alleen tijdens metingen voeden via een pin of een MOSFET. In de meeste projecten leveren deze stappen veel meer op dan een grotere batterij kopen.

Je weet nu wat het verschil is tussen mAh en Wh, hoe je de stroom van je project meet en hoe je uitrekent hoeveel uur of dagen een batterij meegaat. Bekijk als volgende stap Een Arduino voeden met een batterij en Een 18650 laden met een TP4056. In de BlueGrays-app vind je projecten op batterijen, zoals energiebesparing met ESP32 deep sleep, een digitale voltmeter met een LCD, een met Bluetooth bestuurde robotauto en een robot die obstakels ontwijkt, elk met stap-voor-stap schakelschema's en code.

Veelgestelde vragen

Wat betekent mAh op een batterij?

mAh (milliampère-uur) is de eenheid van capaciteit die aangeeft hoeveel elektrische lading een batterij opslaat. Een batterij van 1000 mAh kan in theorie 1000 mA gedurende 1 uur leveren of 100 mA gedurende 10 uur. De echte gebruiksduur hangt af van de stroom die je trekt, de temperatuur en de spanning waarbij je schakeling stopt.

Wat is het verschil tussen mAh en Wh?

mAh meet lading, Wh meet energie. Wh wordt berekend als mAh × V / 1000, dus een batterij van 3,7 V en 3000 mAh bevat 11,1 Wh. Als je batterijen met verschillende spanningen vergelijkt, geeft Wh een veel nauwkeuriger beeld.

Is een batterij met meer mAh beter?

Bij batterijen met dezelfde spanning en hetzelfde type betekent meer mAh een langere gebruiksduur. Bij apparaten met hoge stroom spelen echter ook de inwendige weerstand en de C-waarde een rol. 18650-cellen met onrealistische waarden zoals 9900 mAh zijn bijna altijd namaak.

Hoe bereken ik hoe lang een batterij meegaat?

Gebruik Gebruiksduur (uur) = Capaciteit (mAh) / Gemiddelde stroom (mA) × 0,85. Een batterij van 2500 mAh voedt bijvoorbeeld een schakeling die 50 mA trekt ongeveer 42 uur. Zit er een boost- of buckomvormer tussen, reken dan met Wh en W.

Kan ik een Arduino voeden met een 9V-batterij?

Het werkt voor korte tests, maar het wordt niet aanbevolen voor permanente projecten. Een 9V-alkalinebatterij bevat slechts 400–600 mAh en voedt een Arduino Uno meestal maar een paar uur; bij belastingen zoals servo's zakt de spanning en reset het board. Een 6×AA-houder, een 2S 18650-pakket of een powerbank gaat veel langer mee.

Wat betekent de C-waarde van een batterij?

De C-waarde drukt de ontlaad- of laadstroom uit ten opzichte van de capaciteit van de batterij; 1C is de stroom die de batterij in 1 uur leegmaakt. Voor een batterij van 2000 mAh is 1C = 2 A en 0,5C = 1 A. Waarden zoals 25C op LiPo-batterijen geven de maximale continue ontlaadstroom aan.

Alle projecten bekijken
Temperatuur en luchtvochtigheid met DHT11
AR-55Gemiddeld

Temperatuur en luchtvochtigheid met DHT11

Hoe warm is je kamer, en is de lucht vochtig of droog? De DHT11-sensor meet temperatuur en luchtvochtigheid en de Arduino schrijft de waarden op een lcd-scherm met twee regels, dat om de paar…

4.7(47)
83
Led laten knipperen met ESP32
ES-1Beginner

Led laten knipperen met ESP32

Leert je het basisgebruik van een GPIO-uitgang met de ESP32. Door een led via een digitale pin aan en uit te zetten krijgen we een knippereffect. Dit is de ESP32-versie van het klassieke blinkproject op de Arduino UNO; de basiscommando's in de Arduino-omgeving zijn hetzelfde, maar de pinindeling en de 3,3 V-GPIO-niveaus van de ESP32 verschillen van die van de Arduino UNO.

4.7(37)
107
ESP32 Deep Sleep: batterij sparen (OLED + RTC RAM-teller)
ES-33Gevorderd
Premium

ESP32 Deep Sleep: batterij sparen (OLED + RTC RAM-teller)

De Deep Sleep-modus van de ESP32 schakelt de CPU en de meeste randapparatuur uit, waardoor het stroomverbruik daalt tot ongeveer 10µA; dat is cruciaal voor IoT-apparaten op batterijen. Dit project gebruikt drie wekbronnen: een timer (15 s), een externe pin (EXT0, de knop op GPIO 33) en een touchpin (T0/GPIO 4). Tellers met RTC_DATA_ATTR blijven behouden tijdens deep sleep.

4.3(10)
16
Digitale voltmeter met lcd-scherm
AR-56Gemiddeld
Premium

Digitale voltmeter met lcd-scherm

Ontdek hoeveel spanning een batterij of voedingsadapter geeft met een meter die je zelf hebt gebouwd.

4.5(27)
36
Auto met Bluetooth-besturing en L298N
AR-80Gevorderd
Premium

Auto met Bluetooth-besturing en L298N

Verander je telefoon in een afstandsbediening en bestuur je eigen robotauto. De Arduino ontvangt via een Bluetooth-module commando's van een afstandsbedieningsapp op je telefoon en laat de wielen…

5.0(39)
66
Obstakelvermijdende robot
AR-81Gevorderd
Premium

Obstakelvermijdende robot

Zin om een slim voertuig te bouwen dat zelf zijn weg vindt? De obstakelvermijdende robot scant voortdurend zijn omgeving dankzij de ultrasone sensor voorop.

5.0(38)
49
ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Gevorderd
Premium

ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)

Bouw met de ESP32 een temperatuur- en vochtigheidslogger met tijdstempel! Een DHT22-sensor meet elke minuut temperatuur en luchtvochtigheid en elke meting wordt als CSV op een microSD-kaart opgeslagen, met de actuele tijd van de DS1307 RTC-module. Het OLED-display toont in grote letters live de laatste temperatuur, vochtigheid, tijdstempel en het totale aantal records.

4.7(7)
12