Gidsen · 22 min leestijd

Arduino voeden met een batterij: 9V, AA, 18650 en Vin-pin

Arduino voeden met een batterij: USB of DC-jack (7–12 V), Vin- en 5V-pin, 9V, AA en 18650, aparte servovoeding en de berekening van de batterijduur.

Een Arduino voeden met een batterij is de eerste stap om je project los te maken van de USB-kabel van de computer en er een robotauto, een tuinsensor of een apparaat voor in je zak van te maken. Het korte antwoord: de veiligste manier om een Arduino Uno op batterijen te laten draaien is een pack van 7–12 V (6×AA of twee 18650-cellen in serie) aansluiten op de DC-jack of de Vin-pin, of een powerbank op de USB-poort aansluiten. De 5V-pin gebruik je alleen met een schone 5V-bron die je hebt gemeten en afgesteld, want deze pin omzeilt de regelaar en de beveiliging van het board volledig.

Slechte voeding zit achter veel van de raadselachtige problemen waar beginners tegenaan lopen: een board dat reset zodra de servo beweegt, een 9V-batterij die na een paar uur leeg is, een powerbank die na een paar seconden uitschakelt of een regelaar die te heet is om aan te raken. In deze gids leer je alle ingangen waarmee je een Arduino kunt voeden, welke batterij waar hoort, waarom motoren een eigen voeding nodig hebben en hoe je stroomverbruik en looptijd berekent. Aan het eind kijken we ook hoe het voeden van een ESP32 en een Raspberry Pi Pico op batterijen verschilt.

Voedingsingangen van de Arduino Uno R3: USB, DC-jack en voedingspins
Arduino Uno R3: links de USB-B-poort en de zwarte DC-jack, en langs de onderrand de POWER-header met de pins IOREF, RESET, 3.3V, 5V, GND, GND en Vin.

5 manieren om een Arduino te voeden

In een Arduino Uno lopen twee aparte voedingspaden. De 5 V van USB gaat door een zelfherstellende zekering van 500 mA (polyfuse) en een kleine MOSFET-schakelaar en gaat dan rechtstreeks naar de 5V-rail van het board. De spanning van de DC-jack gaat eerst door een diode tegen omgekeerde polariteit, verschijnt op dat punt op de Vin-pin en wordt daarna door een LDO-regelaar uit de 1117-familie teruggebracht naar 5 V. De 3,3 V wordt uit die 5V-rail gemaakt door een tweede, kleinere regelaar. Een comparator op het board bewaakt Vin: zodra Vin boven ongeveer 6,6 V komt, koppelt hij de USB-voeding automatisch los, zodat de bronnen niet tegen elkaar werken, ook als adapter en USB tegelijk zijn aangesloten.

IngangSpanningBeveiligingWanneer gebruiken
USB (type B)5 VPolyfuse van 500 mAOntwikkelen op je werktafel, telefoonlader, powerbank
DC-jack (5,5×2,1 mm, plus in het midden)7–12 V aanbevolen (grens 6–20 V)Diode tegen omgekeerde polariteit + 5V-regelaarNetadapter, 6×AA, 2S-li-ionpack
Vin-pin7–12 VWel regelaar, geen bescherming tegen omgekeerde polariteitDraden van batterijhouders, shields
5V-pinGemeten 4,8–5,2 VHelemaal geen beveiligingAfgestelde buck-/boostuitgang, geregelde 5V-bron
3.3V-pinAlleen uitgangGeen3,3V-sensoren tot 50 mA
Twijfel je, houd dan deze regel aan: USB op je werktafel, een batterijpack van 7–12 V in de DC-jack in het veld. Gebruik de 5V-pin alleen voor een geregelde 5V-bron die je met een multimeter hebt gecontroleerd. Waar de pins op het board zitten, lees je in de pinout van de Arduino Uno.

USB-voeding: de grens van 500 mA

USB is de eenvoudigste en best beveiligde manier om een Arduino te voeden. Een USB 2.0-poort van een computer levert maximaal 500 mA; de polyfuse van de Uno warmt op en onderbreekt de schakeling als de totale stroom daarboven komt, en maakt vanzelf weer contact als hij is afgekoeld. Het board zelf verbruikt ongeveer 45–50 mA, dus er blijft zo'n 400 mA over voor je sensoren, leds en modules. Een telefoonlader of een powerbank kan dezelfde USB-poort gebruiken; het enige verschil is dat de spanning op dunne, lange kabels kan zakken naar 4,6 V. Zolang het board op USB draait, gaat elke milliampère die je uit de 5V-pin haalt van dat budget van 500 mA af. Daarom laat een servo of ledstrip op USB-voeding de zekering aanslaan, en de poort van de computer kan de verbinding ook verbreken om zichzelf te beschermen.

DC-jack en Vin-pin: waarom 7–12 V?

De 5V-regelaar van het board is een lineaire LDO en heeft aan zijn ingang ongeveer 1–1,2 V meer nodig dan aan zijn uitgang om goed te werken. Tel daar de spanningsval van 0,7–1 V van de beveiligingsdiode op de jack bij op, en je hebt minstens 7 V op de jack nodig voor een stabiele 5 V. Met een bron van 6 V zakt de 5V-rail naar 4,2–4,5 V; het board lijkt dan te werken, maar analoge metingen driften en modules gedragen zich vreemd. Aan de bovenkant is warmte het probleem: een lineaire regelaar zet de extra spanning om in warmte. Het vermogen dat hij verstookt is P = (Vin − 5 V) × I. Als vuistregel laat je de regelaar niet meer dan 1 W dissiperen; daarboven wordt het kleine SOT-223-pakketje te heet om aan te raken en schakelt het uiteindelijk zichzelf uit.

Vin-spanningWarmte bij 100 mAWarmte bij 300 mAOordeel
7 V0,2 W0,6 WMeest efficiënte bereik
9 V0,4 W1,2 WOp de grens bij 300 mA
12 V0,7 W2,1 WAlleen lichte belasting
20 V1,5 W4,5 WNiet aanbevolen, regelaar oververhit

De Vin-pin is zowel ingang als uitgang. Voed je het board via de jack, dan staat op Vin de jackspanning min ongeveer 0,7–1 V, zodat je er een kleine belasting van 9–12 V mee kunt voeden. Maar omdat er een beveiligingsdiode van 1 A in het stroompad zit, moet je grote belastingen zoals motoren rechtstreeks uit de bron voeden en niet via Vin. Sluit je een batterijhouder aan op de Vin-pin, dan wordt die beveiligingsdiode omzeild: de regelaar werkt nog steeds, maar als je plus en min verwisselt, beschermt niets het board. Op de nieuwere Uno R4 Minima en R4 WiFi accepteren de jack en Vin 6–24 V en gebruiken ze een schakelende (buck-)converter in plaats van een lineaire regelaar, zodat ze zelfs bij 12 V niet oververhit raken. Meer details vind je in Arduino Uno R4.

Omgekeerde polariteit is de snelste manier om een Arduino te slopen. Stekkers voor de DC-jack moeten plus in het midden (+) hebben; sommige oude adapters zijn andersom. Voordat je een batterijhouder op de pins Vin en GND aansluit, vertrouw je niet op de kleuren van de draden: controleer de polariteit met een multimeter. Vermoed je dat het board beschadigd is, doe dan de controles uit Is mijn Arduino kapot?.

5V-pin: wanneer is het veilig de regelaar te omzeilen?

De 5V-pin is rechtstreeks verbonden met de voedingsrail van de ATmega328P en de andere chips op het board. Voeden via deze pin slaat de regelaar, de diode tegen omgekeerde polariteit en de USB-zekering over. Daarom raadt de eigen documentatie van Arduino af om via de pins 5V en 3.3V te voeden. Goed gedaan heeft het wel voordelen: er is geen spanningsval of warmteverlies in de regelaar, dus de batterij gaat langer mee en je kunt je modules meer stroom geven. Er is maar één voorwaarde: de bron moet geregeld en gemeten zijn. De ATmega328P is ontworpen voor maximaal 5,5 V en 6 V is zijn absolute maximum; zelfs een kort moment daarboven kan de chip blijvend beschadigen.

  • Eerst meten: controleer de uitgang van de bron met een multimeter voordat je hem op de Arduino aansluit; die moet tussen 4,8 en 5,2 V liggen.
  • Geen kale batterijen: verse 4×AA-alkalinecellen halen 6,4 V en komen boven de grens. Sluit alleen de uitgang van een regelaar-, buck- of boostmodule aan op de 5V-pin.
  • Let op bij tegelijk USB: steek je USB in terwijl je via de 5V-pin voedt, dan worden twee 5V-bronnen via het board aan elkaar gekoppeld; de externe voeding loskoppelen tijdens het uploaden is de veiligste optie.
  • Voeg een condensator toe: een elco van 100–470 µF op de externe 5V-lijn vlak bij het board vlakt dips bij plotselinge stroompieken af (wat is een condensator?).
  • Kant-en-klare opties: regelaarmodules op basis van de 7805 (7805-spanningsregelaar), een LM2596 ingesteld op 5,0 V of de MB102-voedingsmodule voor breadboards geven allemaal een schone 5 V.
Instelbare buck- en boostmodules worden vaak niet op 5 V geleverd maar op een willekeurige spanning (soms boven 12 V). Sluit eerst de batterij aan op de ingang van de module, draai aan de blauwe trimmer tot je multimeter op de uitgang 5,0 V aangeeft, en pas dan sluit je hem aan op de 5V-pin van de Arduino.

3.3V-pin: hoeveel stroom kun je eruit halen?

De 3.3V-pin van de Uno is geen voedingsingang; het is de uitgang van een kleine regelaar en de officiële limiet is 50 mA. Dat is genoeg voor modules die binnen enkele tientallen milliampères blijven, zoals een BME280, een MPU6050 of een RC522-RFID-lezer. Modules met hoge piekstromen gaan er te ver overheen: de nRF24L01+PA+LNA met antenne komt tijdens het zenden boven 100 mA, de ESP-01-wifimodule trekt pieken van enkele honderden milliampères en de SIM800L wil stoten tot 2 A. Gebruik voor de nRF24L01+PA+LNA en de ESP-01 een aparte AMS1117 3,3V-regelaarmodule die uit de 5V-rail wordt gevoed. De SIM800L werkt echter op 3,4–4,4 V in plaats van 3,3 V en overschrijdt de limiet van 1 A van de AMS1117; voed hem met één li-ioncel of met een buckmodule op 4,0 V die minstens 2 A kan leveren. Op de Arduino Nano en zijn klonen wordt de 3.3V-pin vaak gevoed vanuit de USB-serieel-chip en is hij nog zwakker dan op de Uno, dus ook daar is een aparte regelaar de veiligere keuze. Meer over het voeden van draadloze modules vind je in de nRF24L01-gids.

AMS1117 3.3 V-spanningsregelaarmodule
AMS1117 3.3 V-regelaarmodule: geef 5 V op VIN en neem 3,3 V af van VOUT; hij voedt stroomhongerige modules zoals de ESP-01 en nRF24L01 zonder de 3.3V-pin van de Arduino te overbelasten.

Batterijopties: 9V, AA, 18650 en powerbanks

BatterijSpanningCapaciteitAansluiten opLooptijd met een Uno (~50 mA)
9V-alkaline9 V (zakt onder belasting snel naar 7 V)400–600 mAhDC-jack / Vin6–8 uur
6×AA-alkaline9 V2000–2500 mAhDC-jack / Vin~30 uur
4×AA-alkaline6 V (6,4 V nieuw)2000–2500 mAhNiet aanbevolenTe laag voor de jack, te hoog voor de 5V-pin
3×AA-alkaline4,5 V2000–2500 mAh5V-pin~1 dag (onstabiel tegen het einde)
1×18650 + 5 V boost3,0–4,2 V → 5 V2000–3500 mAhUSB of 5V-pin~30 uur (3.000 mAh)
2×18650 in serie (2S)7,4 V (6,0–8,4 V)2000–3500 mAhDC-jack / Vin~2 dagen (3.000 mAh)
Powerbank van 10.000 mAh5 V (USB)~6.000 mAh (bij 5 V)USB~5 dagen (als hij aan blijft)

De klassieke 9V-batterij is de meest aanbevolen optie dankzij de clipaansluiting met hollestekker, maar hij is ook de minst efficiënte. Er zitten zes kleine cellen in, dus de capaciteit is maar zo'n 400–600 mAh en de interne weerstand is hoog; voeg een servo of een paar leds toe aan de 50 mA van de Uno en de spanning zakt al snel onder 7 V, waarna het board begint te resetten. Op een board met een lineaire regelaar bepaalt de mAh-waarde van de batterij direct de looptijd en worden de extra volts gewoon warmte. Daarom gaat een 6×AA-houder, die dezelfde 9 V levert, ongeveer vier keer langer mee dan een 9V-batterij. Capaciteitseenheden leggen we uitgebreid uit in Wat betekent mAh?.

AA-batterijen zijn goedkoop en overal verkrijgbaar, maar je moet het juiste aantal cellen kiezen. De meest gemaakte fout is 4×AA gebruiken: 6 V is niet genoeg voor de jack, want na de spanningsval van diode en regelaar komt er maar ongeveer 4,2 V op de 5V-rail, terwijl dezelfde pack op de 5V-pin met verse cellen 6,4 V geeft, wat boven de limiet ligt. De juiste combinaties zijn een 6×AA (9 V)-pack in de DC-jack en een 3×AA (4,5 V)-pack rechtstreeks op de 5V-pin. Een Uno op 16 MHz met 3×AA wordt onstabiel zodra elke cel onder 1,25 V zakt, dus je kunt niet de volle capaciteit benutten. Oplaadbare NiMH-cellen geven 1,2 V per stuk, dus 4×NiMH (4,8 V) is ook een populaire keuze voor de 5V-pin, maar pas opgeladen cellen kunnen de eerste minuten boven 5,5 V komen.

AA-batterijhouder met draden
AA-batterijhouders zijn er voor 1, 2, 3, 4 en 6 cellen; een houder voor 6 cellen is de juiste keuze voor de DC-jack van de Arduino Uno en een voor 3 cellen voor de 5V-pin. De rode draad is plus, de zwarte draad min.

18650 li-ioncellen en boostconverters

De 18650 is een oplaadbare lithium-ioncel met een diameter van 18 mm en een lengte van 65 mm, die in laptopaccu's en powerbanks wordt gebruikt. De nominale spanning is 3,7 V; hij meet 4,2 V als hij vol is en ongeveer 3,0 V als hij leeg is. De echte capaciteit ligt tussen 2.000 en 3.500 mAh; cellen met het opschrift 6.800 of 9.900 mAh zijn bijna altijd nep. Een enkele 18650 kun je op twee manieren met een Arduino gebruiken: 3,7 V naar 5 V verhogen met een boostconverter (bijvoorbeeld een MT3608-module of een kant-en-klaar 18650-powerbankboard) en daarmee USB of de 5V-pin voeden, of twee cellen in serie zetten en de 2S (7,4 V)-pack op de DC-jack aansluiten. De tweede is de meest evenwichtige optie voor de Uno: vanaf 8,4 V blijft de spanning in het comfortabele bereik van de regelaar tot hij zakt naar 3,5 V per cel (7 V totaal). Als je een boostconverter gebruikt, bedenk dan dat de stroom uit de batterij hoger is dan aan de uitgang: een schakeling die 200 mA bij 5 V nodig heeft, trekt bij een rendement van 88% ongeveer 307 mA uit een cel van 3,7 V.

Oplaadbare 18650 li-ionbatterij
18650 li-ioncellen: 3,7 V nominaal, 4,2 V als ze vol zijn. In Arduino-projecten gebruik je één cel met een boostconverter, of twee cellen in serie (2S, 7,4 V) via de DC-jack.
  • Beveiliging is een must: een li-ioncel ontladen tot onder 3,0 V verkort zijn levensduur en kan gevaarlijk zijn. Gebruik beveiligde cellen of een beveiligingsprint (BMS).
  • TP4056 is voor enkele cellen: de TP4056-module laadt maar één cel (1S) op tot 4,2 V. Laad nooit een 2S-seriepack op met een TP4056; gebruik een 2S-BMS-laadschakeling of een balanceerlader. Bedradingsdetails staan in TP4056-oplaadmodule.
  • Pas op voor kortsluiting: een 18650 kan tientallen ampères leveren in een kortsluiting; laat geen blote draden liggen en voeg een zekering en een schakelaar toe aan de batterijlijn.
  • Boost instellen: sluit instelbare modules zoals de MT3608 niet aan op de Arduino voordat je de uitgang op 5,0 V hebt ingesteld.
  • Meng geen cellen: gebruik in een seriepack cellen van hetzelfde merk, dezelfde capaciteit en hetzelfde laadniveau.
TP4056 li-ionlader-module met beveiliging (USB-C)
TP4056-module met beveiliging: de 18650-cel komt op B+ en B−, de boostconverter of belasting op OUT+ en OUT−. Hij laadt de cel op tot 4,2 V via de USB-C-ingang.

Waarom schakelt mijn powerbank zichzelf uit?

Een powerbank is een kant-en-klaar pack met lithiumcellen, een lader, beveiliging en een 5V-boost, dus het is de minste moeite om een Arduino op batterijen te laten draaien: steek gewoon de USB-kabel erin. De meeste powerbanks bewaken echter de uitgangsstroom, zodat ze kunnen uitschakelen als je telefoon vol is, en ze schakelen de uitgang binnen 10–60 seconden uit zodra de stroom onder 50–100 mA zakt. Een Nano die 20 mA trekt of een Uno die 50 mA trekt blijft onder die drempel, dus het board draait een tijdje en gaat dan stilletjes uit. Er zijn twee manieren om dit te omzeilen: kies een powerbank met een modus voor lage stroom (bij sommige modellen schakel je die in door twee keer op de knop te drukken), of laat de Arduino met regelmatige tussenpozen kort een belasting trekken. Sluit voor de tweede methode een weerstand van 47 Ω, 1 W aan tussen de 5V-rail en de collector van een NPN-transistor (BC337 of 2N2222), de emitter op GND en de basis via een weerstand van 1 kΩ op pin D7. Als de transistor inschakelt, trekt de weerstand ongeveer 5 V / 47 Ω ≈ 106 mA en ziet de powerbank een belasting. Je kunt de waarden zelf controleren met de rekenmachine voor de wet van Ohm.

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

Omdat de code millis() gebruikt in plaats van delay(), blokkeert hij de rest van je project niet; deze aanpak leggen we uitgebreid uit in millis() vs delay(). Elke 8 seconden 300 ms lang 106 mA trekken voegt gemiddeld slechts ongeveer 4 mA toe. Schakelt je powerbank toch nog uit, verkort dan de periode naar 5 seconden of verleng de puls naar 500 ms; elk model gebruikt een andere drempel en time-out.

Aparte voeding voor motoren en servo's, gemeenschappelijke GND

Motoren en servo's zijn de belastingen die de meeste problemen geven als je een Arduino op batterijen voedt. Een servo trekt op het moment dat hij gaat bewegen een stroompiek van enkele honderden milliampères, en gelijkstroommotoren trekken bij het starten of vastlopen een veelvoud van hun normale stroom. Die piek kan de 5V-rail even laten instorten; zakt de spanning ver genoeg, dan grijpt de brown-outdetectie van de ATmega328P in en reset het board zichzelf. Bovendien vervuilt de borstelruis van motoren de sensormetingen. De regel is simpel: voed hooguit één kleine servo uit de 5V-pin van de Arduino en laat elke andere motor op een aparte voeding draaien. Hoe servo's en gelijkstroommotoren werken, lees je bij servomotor en gelijkstroommotor aansturen met de L298N.

BelastingNormale stroomPiekstroomAanbevolen voeding
SG90-microservo100–250 mA0,5 A of meer (bij blokkeren)Eén: 5V van de Arduino; meer: aparte 5 V
MG996R servo0,5–0,9 ATot 2,5 AAparte 5–6 V, minstens 2–3 A per servo
TT-gelijkstroommotor met tandwielkast70–250 mA~1 A (aanloop, blokkeren)L298N of L9110S + aparte pack van 6–9 V
28BYJ-48-stappenmotor~240 mA~240 mAAparte 5 V naar het ULN2003-board
WS2812B-led (per stuk)~20 mA (gemiddelde helderheid)60 mA (volledig wit)Aparte 5 V vanaf 30 leds
Mini-dompelpomp100–200 mAEen veelvoud bij het startenRelais of MOSFET + aparte voeding
  1. Kies een aparte voeding voor de motoren: 5–6 V voor servo's (4×AA NiMH of een LM2596 ingesteld op 5–6 V) en voor gelijkstroommotoren een pack die bij de motorspanning past (bijvoorbeeld 2S 18650).
  2. Sluit de plus van de voeding alleen aan op de rode draden van de servo's of op de voedingsingang van de motordriver; sluit hem niet aan op de 5V-pin van de Arduino.
  3. Voed de Arduino via zijn eigen ingang: je kunt dezelfde 2S-pack ook op de DC-jack aansluiten, zolang de motorstroom niet door de regelaar van de Arduino loopt.
  4. Sluit de min (GND) van de voeding aan op de GND-pin van de Arduino. Zonder een gemeenschappelijke GND werkt het stuursignaal niet.
  5. Sluit de oranje of gele signaaldraad van de servo aan op een van de digitale pins van de Arduino (bijvoorbeeld D9); de Servo-bibliotheek werkt ook op pins zonder PWM-markering.
  6. Plaats een elco van 470–1.000 µF over de servovoeding, dicht bij de servo's; let op de polariteit.
  7. Gebruik je een L298N, sluit de motorvoeding dan aan op de 12V-klem; is de voeding hoger dan 12 V, verwijder dan de 5V-EN-jumper en voed de Arduino uit zijn eigen bron.
LM2596 step-down (buck) spanningsregelaarmodule
LM2596 step-down-module: hij brengt een hogere spanning, zoals een 2S li-ionpack of een adapter van 12 V, efficiënt terug naar 5–6 V, in te stellen met de trimmer, zonder heet te worden; de handigste manier om een aparte voedingslijn voor servo's en ledstrips te maken.
Zo werkt een gemeenschappelijke GND: spanning meet je altijd tussen twee punten. Geeft de signaalpin van de Arduino 5 V af, dan is dat 5 V ten opzichte van de GND van de Arduino, terwijl de servo meet ten opzichte van de GND van zijn eigen voeding. Zijn de twee massa's niet verbonden, dan ziet de servo het signaal als een betekenisloze spanning en trilt hij of beweegt hij helemaal niet. Meer details vind je in Wat is GND?, en om een aparte lijn van 5–6 V te bouwen in de gids LM2596 afstellen.

Hoe bereken je stroom en looptijd?

De echte vraag bij een project op batterijen is: "hoe lang gaat het mee?". De basisformule is eenvoudig: Looptijd (uren) = batterijcapaciteit (mAh) × 0,85 / gemiddelde stroom (mA). De factor 0,85 houdt er rekening mee dat een batterij nooit zijn volledige nominale capaciteit levert: de capaciteit daalt bij hoge stromen en in de kou, de schakeling stopt voordat de batterij helemaal leeg is en converters veroorzaken verliezen. Voor batterijen waarvan de spanning vroeg inzakt, zoals een 9V, is 0,7 realistischer. Slaapt je project het grootste deel van de tijd, bereken dan eerst de gemiddelde stroom: Gemiddelde stroom = (actieve stroom × actieve tijd + slaapstroom × slaaptijd) / totale tijd. In plaats van dit met de hand te doen, kun je de batterijduurcalculator gebruiken; vul de capaciteit, de stromen in wakker en slaapstand en het wekinterval in, en je krijgt de looptijd in uren, dagen of maanden.

ScenarioGemiddelde stroomBatterijLooptijd (ca.)
Uno + I2C-LCD, altijd aan~75 mA2S 18650 (3000 mAh)~34 uur
Nano + sensor + keep-alive voor powerbank~29 mA (25 + 4)Powerbank van 10.000 mAh (~6.000 mAh, 5 V)~7 dagen
ESP32-module: 5 s wakker elke 10 minuten (120 mA), 150 µA in slaap~1,15 mA18650 (3000 mAh)~3 maanden
Dezelfde code, devboard dat 5 mA verbruikt in slaap~6 mA18650 (3000 mAh)~18 dagen
Pico + MicroPython, altijd aan~25 mA3×AA NiMH (2000 mAh)~68 uur

Meten is altijd beter dan gokken. Zet je multimeter op het stroombereik (mA) en sluit hem in serie aan tussen de batterij en de schakeling om het echte verbruik te zien; hoe dat werkt, laten we zien in hoe gebruik je een multimeter. Is de meting hoger dan verwacht, kijk dan eerst naar het eigen verbruik van het board: op de Uno trekken de USB-serieel-chip (ATmega16U2), de voedingsled en de regelaar meer dan 30 mA, ook als de ATmega328P slaapt. Daarom kiezen projecten die lang op batterijen moeten draaien voor boards zonder USB-chip, zoals de Arduino Pro Mini; een Pro Mini waarvan de voedingsled en de regelaar zijn verwijderd, komt in de slaapstand uit op microampères.

Stap voor stap: je project op batterijen laten draaien

  1. Meet terwijl het project op USB draait de gemiddelde en piekstroom met een multimeter; meet ook terwijl de servo of motor beweegt.
  2. Scheid belastingen met hoge stroom, zoals motoren, servo's en ledstrips, en plan er een aparte voeding voor.
  3. Kies de ingang van het board: voor de Uno een pack van 7–12 V in de DC-jack of geregelde 5 V op USB of de 5V-pin; voor de Pico 1,8–5,5 V op VSYS.
  4. Bereken de capaciteit die je nodig hebt voor de gewenste looptijd, of gebruik de batterijduurcalculator.
  5. Voeg een aan/uit-schakelaar toe aan de plus-lijn van de batterij; zorg dat li-ionpacks een beveiligingsprint (BMS) hebben.
  6. Upload de code via USB, haal dan USB los en test op batterijen; controleer met een multimeter de spanning op de 5V-pin terwijl de servo beweegt.
  7. Bewaak de batterijspanning in code en geef een waarschuwing als die onder een ingestelde waarde zakt (code hieronder).

De batterijspanning meten met Arduino

In plaats van te gokken wanneer de batterij leeg is, kun je de spanning meten. De analoge ingangen van de Arduino kunnen maximaal 5 V lezen, dus je kunt een 2S-pack die 8,4 V haalt niet rechtstreeks op A0 aansluiten; je hebt een spanningsdeler nodig. Twee weerstanden van 100 kΩ en 10 kΩ delen de spanning door 11: 8,4 V wordt ongeveer 0,76 V op A0. Omdat de 5V-rail van het board kan driften als de batterij zwakker wordt, is het nauwkeuriger om te meten tegen de interne referentie van 1,1 V, die niet van de voedingsspanning afhangt. Weerstandswaarden voor je eigen pack kies je met de spanningsdelercalculator en meer lees je in spanningsdeler.

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

Sluit de bovenkant van de deler aan op de plus van de batterij na de aan/uit-schakelaar, zodat de deler de batterij niet leegtrekt terwijl het apparaat uit staat. De interne referentie van 1,1 V kan per chip ongeveer ±10% verschillen: vergelijk de batterijspanning die je met een multimeter meet met de Serial Monitor en corrigeer VREF (bijvoorbeeld naar 1.08). De deler trekt de hele tijd ongeveer 76 µA, wat praktisch geen effect heeft op de batterijduur. De code is voor de Uno en Nano; op de Mega heet de referentie INTERNAL1V1. De drempel van 6,6 V komt overeen met 3,3 V per cel; op dat punt zijn de cellen bijna leeg en onder 3,0 V per cel raken ze beschadigd. Voedt de pack de DC-jack, dan begint de 5V-rail bij ongeveer 7 V te zakken, dus LOW_V op 7.0 zetten is ook zinvol.

Een ESP32 voeden met batterijen

ESP32-devboards werken op 3,3 V en kunnen op drie manieren worden gevoed: de USB-poort, de 5V-pin (VIN op sommige boards) of rechtstreeks via de 3V3-pin. Espressif geeft duidelijk aan dat deze opties niet tegelijk mogen worden gebruikt en dat je er maar één moet kiezen. Spanning op de 5V-pin gaat door de 3,3V-LDO-regelaar van het board (op de meeste klonen een AMS1117), terwijl de 3V3-pin alleen geregelde 3,0–3,6 V accepteert. Bij zenden over wifi trekt de ESP32 pieken tot 240 mA, dus hij heeft een voeding nodig die minstens 500 mA kan leveren; anders reset hij met de fout "Brownout detector was triggered" (details in brownout-fout). Sluit een enkele 18650 niet rechtstreeks aan op de 3V3-pin: met 4,2 V als hij vol is, komt hij boven de limiet. De 5V-pin past ook niet goed, want de AMS1117 heeft een spanningsval van ongeveer 1,1 V nodig, dus als de celspanning zakt, daalt de uitgang onder 3,3 V. De juiste opties zijn een 18650 met een 5V-boost op de 5V-pin, een low-dropout 3,3V-regelaar die minstens 500 mA kan leveren, of een ESP32-board met ingebouwde li-ionlader. Wat de batterijduur echt bepaalt, is dat de ESP32 het grootste deel van de tijd in deep sleep doorbrengt; de chip trekt in deze stand ongeveer 10 µA, maar de USB-serieel-chip, led en regelaar op devboards kunnen dat naar het milliampèrebereik duwen. Daar komt het verschil tussen 3 maanden en 18 dagen in de tabel hierboven vandaan; meer details vind je in ESP32 deep sleep.

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

Bij elke wake-up meet de code de batterijspanning, doet zijn werk en gaat weer slapen met een timer van 60 seconden; omdat een ESP32 die uit deep sleep ontwaakt het programma opnieuw vanaf het begin start, wordt loop() nooit uitgevoerd. GPIO 34 is een ADC1-pin die alleen ingang is en werkt terwijl wifi aan staat, terwijl ADC2-pins niet samen met wifi kunnen worden gebruikt. analogReadMilliVolts() gebruikt de fabriekskalibratie van de chip om direct millivolts terug te geven. De deler van 100 kΩ + 100 kΩ brengt 4,2 V terug naar 2,1 V en trekt maar 21 µA; is de meting ruizig, voeg dan een condensator van 100 nF toe tussen GPIO 34 en GND. Voor je eerste stappen met de ESP32 is Wat is de ESP32? een goed startpunt.

Een Raspberry Pi Pico voeden met batterijen

De Raspberry Pi Pico is een van de eenvoudigste boards om op batterijen te laten draaien, omdat hij in plaats van een lineaire regelaar een schakelende buck-boost-regelaar heeft. Geef de VSYS-pin iets tussen 1,8 en 5,5 V en het board zet dat efficiënt om naar 3,3 V; hij blijft werken, ook als de ingang onder 3,3 V zakt. Dat betekent dat je 2 of 3 AA-cellen, een enkele 18650 of een LiPo met één cel zonder extra module direct tussen VSYS en GND kunt aansluiten. Waar je op moet letten is het gebruik samen met USB: de USB 5 V (VBUS) is via een schottkydiode met VSYS verbonden, dus als de batterij rechtstreeks op VSYS zit en je USB insteekt, probeert USB stroom in de batterij te duwen. De oplossing die Raspberry Pi aanraadt, is de batterij via een eigen schottkydiode (bijvoorbeeld een 1N5817) op VSYS aan te sluiten. De 3V3-pin kan hooguit ongeveer 300 mA aan externe schakelingen leveren, en de 3V3_EN-pin naar GND trekken schakelt de regelaar en dus het hele board uit. Voor een overzicht van het board, zie Wat is de Raspberry Pi Pico?.

MicroPython
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)

Op de Pico meet GP29 via een ingebouwde deler een derde van VSYS, terwijl GP24 1 leest als USB is aangesloten. Zonder extra onderdelen kun je dus zowel de batterijspanning vinden als zien of het board op USB of op de batterij draait. Heb je de batterij zoals aanbevolen via een schottkydiode aangesloten, dan leest VSYS ongeveer 0,2–0,3 V onder de batterijspanning. De meting gaat ervan uit dat de ADC-referentie 3,3 V is; dankzij de buck-boost-regelaar blijft die referentie stabiel, ook als de batterij zwakker wordt. Op de Pico W worden GP29 en GP24 gedeeld met de draadloze chip, dus deze code werkt daar niet zoals hij is; daar lees je de USB-status met Pin("WL_GPIO2"). Om de batterijduur te verlengen, gebruik je tussen de metingen machine.lightsleep() in plaats van time.sleep().

Projectideeën op batterijen

  • Robotauto met Bluetooth-besturing: voed zowel de motoren als de Arduino uit een 2S 18650-pack; details in een Arduino-auto bouwen.
  • Robot die obstakels ontwijkt: voorkom resets door de motoren via de L298N op een aparte lijn te voeden en de Arduino via de DC-jack (robot die obstakels ontwijkt).
  • Voltmeter met batterijmeter: toon de waarde die je via een spanningsdeler meet op een LCD (een Arduino-voltmeter bouwen).
  • Vochtstation voor de tuin: houd een ESP32 in deep sleep, meet één keer per uur de bodemvochtigheid en laat hem maandenlang op één 18650 draaien.
  • Draagbare GPS-logger: leg je wandelroute vast met een NEO-6M GPS en een powerbank.
  • Nachtlampje met Pico op batterijen: een Pico die via VSYS uit 3×AA-cellen wordt gevoed, schakelt leds in als het donker wordt in de kamer.

Veelgemaakte fouten en hoe je ze oplost

SymptoomWaarschijnlijke oorzaakOplossing
Het board reset als de servo beweegtDe servostroom laat de 5V-rail instortenVoed de servo apart, voeg een gemeenschappelijke GND en een condensator van 470–1.000 µF toe
De 9V-batterij is na een paar uur leegEen 9V-batterij heeft maar 400–600 mAhGebruik een 6×AA- of 2S 18650-pack
De powerbank schakelt uit na 10–60 secondenDe stroom ligt onder de drempel van de automatische uitschakelingModus voor lage stroom of een keep-alive-puls
De regelaar wordt erg heetHoge ingangsspanning en hoge stroomVerlaag de ingang naar 7–9 V of maak de 5 V met een buckmodule
Analoge metingen driften op batterijvoedingIngang onder 7 V, de 5V-rail zakt inVerhoog de packspanning of gebruik de interne referentie van 1,1 V
Het board wordt heet of gaat niet aanOmgekeerde polariteit, of meer dan 5,5 V op de 5V-pinKoppel de bron los, controleer polariteit en spanning met een multimeter
De ESP32 reset tijdens het verbinden met wifiDe voeding kan de piekstroom niet leveren (brownout)Korte, dikke draden, een condensator van 470 µF, een sterkere voeding
Op de Pico warmt de batterij op als USB is aangeslotenUSB duwt via VSYS stroom in de batterijVoeg een schottkydiode toe aan de batterijlijn
Bouw je een permanent project met lithiumbatterijen, voeg dan een zekering (bijvoorbeeld 2 A) en een schakelaar toe aan de batterijlijn, plaats de cellen in een gesloten maar geventileerde behuizing en laat het project nooit onbeheerd achter tijdens het opladen. Neem een opgezwollen, gedeukte of warme cel direct uit gebruik.

Goede voeding is de helft van wat een project betrouwbaar laat werken: kies de juiste ingang, voed motoren apart, verbind de massa's en reken de batterijduur vanaf het begin uit. Als je klaar bent om een project op batterijen te bouwen, bekijk dan in de BlueGrays-app de L298N-auto met Bluetooth-besturing, de robot die obstakels ontwijkt, het slimme irrigatiestation, de digitale voltmeter met LCD en de ESP32-projecten met deep sleep om batterij te besparen; elk project leidt je stap voor stap door het schakelschema, de bedrading en de code.

Veelgestelde vragen

Kan een Arduino op een 9V-batterij draaien?

Ja, een 9V-batterij kun je aansluiten op de DC-jack of de Vin-pin van de Arduino Uno, en het board draait probleemloos in het bereik van 7–12 V. Een 9V-alkalinebatterij heeft echter maar 400–600 mAh, dus alleen laat hij een Uno ongeveer 6–8 uur draaien, en veel korter zodra je een servo of motor toevoegt. Voor projecten die lang moeten draaien zijn 6×AA of twee 18650-cellen in serie een betere keuze.

Kan ik een Arduino voeden met een powerbank?

Ja; steek de powerbank met een USB-kabel in de USB-poort van de Arduino, en het board wordt beschermd door zijn USB-zekering. Het addertje is dat veel powerbanks belastingen onder 50–100 mA niet herkennen en hun uitgang na korte tijd uitschakelen. Je kunt een model met een modus voor lage stroom kiezen of een keep-alive-schakeling toevoegen die de Arduino om de paar seconden kort een belasting laat trekken.

Kan ik een Arduino voeden met een 12V-adapter?

Ja, 12 V is de bovenkant van het aanbevolen bereik van 7–12 V van de Uno en is veilig via de DC-jack. Maar omdat de lineaire regelaar op het board de extra 6–7 V omzet in warmte, raakt hij oververhit als je meer dan ongeveer 150 mA uit de 5V-rail haalt. Heb je meer stroom nodig, gebruik dan een adapter van 9 V of maak de 5 V met een aparte buckmodule; de Uno R4 draait probleemloos tot 24 V.

Kan ik een Arduino voeden via de 5V-pin?

Dat kan, maar de 5V-pin omzeilt de regelaar, de diode tegen omgekeerde polariteit en de USB-zekering van het board, dus er is helemaal geen beveiliging. Sluit alleen een geregelde bron aan die je met een multimeter hebt gemeten en die tussen 4,8 en 5,2 V blijft (bijvoorbeeld een LM2596 of boostmodule ingesteld op 5,0 V). Een bron boven 5,5 V, of een die verkeerd om is aangesloten, kan de ATmega328P direct vernielen.

Kan een Arduino op een 3,7V-li-ionbatterij draaien?

Een Uno draait niet betrouwbaar rechtstreeks op 3,7 V: dat is te laag voor de DC-jack en niet genoeg voor de 5V-pin. Je moet een enkele cel met een boostconverter naar 5 V verhogen en daarmee USB of de 5V-pin voeden, of twee cellen in serie zetten en de pack van 7,4 V op de DC-jack aansluiten. Een Pro Mini van 3,3 V (op zijn RAW-pin) en een Raspberry Pi Pico (op VSYS) draaien daarentegen probleemloos rechtstreeks op één cel, en een ESP32 ook, met een low-dropout 3,3V-regelaar.

Hoe lang draait een Arduino op batterijen?

Je vindt de looptijd door de capaciteit te delen door de gemiddelde stroom: capaciteit (mAh) × 0,85 / gemiddelde stroom (mA). Een Uno die 50 mA trekt, draait bijvoorbeeld ongeveer 50 uur op een 2S 18650-pack van 3.000 mAh. Een ESP32 met deep sleep kan op dezelfde capaciteit maandenlang meegaan; de batterijduurcalculator in BlueGrays houdt ook rekening met de slaapstroom.

Alle projecten bekijken
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
Een servomotor gebruiken
AR-35Beginner
Premium

Een servomotor gebruiken

De arm van een kleine servomotor draait na elkaar naar drie standen: helemaal naar het begin, precies naar het midden en helemaal naar het einde, en wacht bij elke stop twee seconden.

4.7(48)
67
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
Slim bewateringsstation
AR-83Gevorderd
Premium

Slim bewateringsstation

Een tuinier die je planten zelf water geeft, zodat ze niet uitdrogen terwijl jij op vakantie bent.

5.0(42)
57
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
ESP32-servomotor (bediening met potentiometer)
ES-16Gemiddeld
Premium

ESP32-servomotor (bediening met potentiometer)

In dit project bedien je een SG90-servomotor met een potentiometer. De analoge waarde van de potentiometer zet je om naar het bereik van 0–180 graden en zo stel je de servohoek in. De ESP32Servo-bibliotheek maakt het servosignaal op geschikte GPIO-pinnen van de ESP32 die als uitgang kunnen dienen; dit project gebruikt GPIO 18. Dit is een basismethode voor robotarmen, cameragimbals en automatische deurmechanismen.

4.3(29)
42