INA219 Arduino-tutorial: stroom, spanning en vermogen meten
Hoe sluit je een INA219-stroomsensor aan op Arduino, ESP32 en Pico? Shunt van 0,1 Ω, limiet 26 V/3,2 A, kalibratie, zonnepaneel- en batterijmetingen, vergelijking met ACS712.
De INA219 is de handigste manier om in Arduino-projecten tegelijk stroom, spanning en vermogen te meten. Deze kleine chip van Texas Instruments berekent digitaal de stroom door een shuntweerstand die in serie met je schakeling staat, de spanning aan de kant van de belasting en het vermogen, het product van die twee. De resultaten stuurt hij via slechts twee I2C-draden. Gangbare modules hebben een shunt van 0,1 Ω, en zo meet de sensor een lijn tot 26 V en stromen tot ongeveer ±3,2 A in stappen van circa 0,1 mA.
Wil je weten hoeveel vermogen een zonnepaneel overdag levert, hoeveel uur een ESP32-project nodig heeft om zijn batterij leeg te trekken, of hoeveel stroom een motor onder belasting trekt? Dan is dit precies de sensor die je nodig hebt. In dit bericht leer je stap voor stap hoe de shunt werkt, wat de meetbereiken zijn, hoe de kalibratie wordt berekend, vind je werkende code voor Arduino Uno, ESP32 en Raspberry Pi Pico en lees je hoe hij verschilt van de ACS712.
Wat is de INA219 en hoe werkt hij?
De INA219 is gebouwd op de wet van Ohm. Een precisieweerstand met een zeer lage waarde (de shunt) staat in het stroompad; als er stroom doorheen loopt, ontstaat er over de weerstand een kleine spanningsval die evenredig is met de stroom. Bij een shunt van 0,1 Ω geeft 1 A 100 mV en 250 mA geeft 25 mV (V = I × R). De programmeerbare versterker (PGA) en de 12-bit ADC van de chip lezen deze spanning op millivoltniveau uit en slaan haar op in het shuntspanningsregister in stappen van 10 µV. De chip meet ook de spanning tussen het uiteinde van de shunt aan de belastingzijde (Vin−) en GND met een resolutie van 4 mV; dit heet de busspanning. Zodra de juiste waarde in het kalibratieregister staat, berekent de INA219 intern stroom en vermogen, zodat de microcontroller niets hoeft te vermenigvuldigen of te delen. Omdat de shunt tussen de plus van de voeding en de belasting zit, heet dit high-side-meting, en de massa van de belasting blijft onaangeroerd. Stroom wordt in beide richtingen gemeten: stroom van Vin+ naar Vin− is positief en stroom in de tegengestelde richting verschijnt als negatief.
| Eigenschap | Waarde |
|---|---|
| Chip | Texas Instruments INA219 (A- en B-versies) |
| Communicatie | I2C / SMBus, fast mode van 400 kHz ondersteund |
| Voeding (VCC) | 3,0–5,5 V |
| Meetbare busspanning | 0–26 V (registerbereik ingesteld op 16 V of 32 V) |
| Bereik shuntspanning | ±40, ±80, ±160 of ±320 mV (te kiezen met de PGA) |
| Shunt op de module | 0,1 Ω (gemarkeerd R100) |
| Maximale stroom (met 0,1 Ω) | Ongeveer ±3,2 A |
| ADC | 12 bit, conversietijd 532 µs, tot 128 samples ingebouwde middeling |
| Nauwkeurigheid | INA219B: maximaal 0,5% fout over het volledige temperatuurbereik (1% bij de A-versie) |
| I2C-adres | 0x40 (0x41, 0x44, 0x45 met de A0/A1-bruggen) |
Shuntweerstand en meetbereik
De maximale stroom die de INA219 kan meten, wordt bepaald door de shuntwaarde en de PGA-instelling: I_max = V_shunt,max / R_shunt. In een smal bereik worden kleine spanningen met minder fout gelezen, terwijl je met een breed bereik grotere stromen haalt. Het vermogen dat de shunt dissipeert is P = I² × R: bij 3,2 A zet een shunt van 0,1 Ω ongeveer 1 W om in warmte, en de spanningsval van 320 mV erover verlaagt ook de spanning die de belasting ontvangt. Voor grotere stromen kun je de shunt vervangen door een kleinere, zoals 0,01 Ω, maar de dunne koperbanen en aansluitklemmen van de module zijn meestal ontworpen voor ongeveer 3 A. Voor heel kleine stromen maakt een shunt van 1 Ω de stap tien keer fijner: 10 µV / 1 Ω = 10 µA. Met de shunt van 0,1 Ω op de module zijn de vier opties:
| PGA-instelling | Bereik shuntspanning | Max. stroom (0,1 Ω) | Wanneer gebruiken |
|---|---|---|---|
| /1 | ±40 mV | ±400 mA | Sensoren, microcontrollerboards, schakelingen met lage stroom |
| /2 | ±80 mV | ±800 mA | Korte ledstrips, één servomotor |
| /4 | ±160 mV | ±1,6 A | Kleine gelijkstroommotoren, minipompen |
| /8 (standaard) | ±320 mV | ±3,2 A | Zonnepanelen, motoren, algemeen gebruik |
INA219-bedrading: Arduino Uno, ESP32 en Pico
| INA219-pin | Arduino Uno | ESP32 | Raspberry Pi Pico | Functie |
|---|---|---|---|---|
| VCC | 5V | 3V3 | 3V3(OUT), pin 36 | Voeding van de chip |
| GND | GND | GND | GND | Gemeenschappelijke massa (moet ook verbonden zijn met de min van de belasting) |
| SCL | A5 | GPIO 22 | GP5 (pin 7) | I2C-klokleiding |
| SDA | A4 | GPIO 21 | GP4 (pin 6) | I2C-dataleiding |
| Vin+ | Plus van de voeding | Plus van de voeding | Plus van de voeding | Waar de stroom binnenkomt |
| Vin− | Plus van de belasting | Plus van de belasting | Plus van de belasting | Waar de stroom uitgaat |
Zie het stroompad als een ketting: plus van de voeding, Vin+, shunt, Vin−, plus van de belasting, min van de belasting en ten slotte min van de voeding. De INA219 sluit je in serie in deze ketting aan, net als een ampèremeter. De min van de voeding, de min van de belasting en de GND-pin van de module moeten allemaal met elkaar verbonden zijn; anders is de meting van de busspanning zinloos, ook al lijkt de stroom te kloppen (zie het bericht over gemeenschappelijke massa voor details). Op de Uno kun je ook de SDA/SCL-pinnen bij de bovenhoek van het board gebruiken in plaats van A4/A5; het zijn dezelfde lijnen. De meeste modules hebben I2C-pull-upweerstanden, dus extra weerstanden zijn niet nodig. Voed je de module op de ESP32 en de Pico vanaf 3V3, dan trekken die pull-ups ook naar 3,3 V en blijven je pins veilig.
Stap voor stap: je eerste meting met Arduino Uno
- Open de Library Manager in de Arduino IDE, zoek de bibliotheek Adafruit INA219 en accepteer de afhankelijkheid Adafruit BusIO wanneer daarom wordt gevraagd. Ben je nieuw met het installeren van bibliotheken, bekijk dan bibliotheken toevoegen.
- Sluit de pinnen VCC, GND, SDA en SCL van de module aan op de Uno, zoals in de tabel.
- Kies de belasting die je wilt meten: bijvoorbeeld een rode led met een weerstand van 220 Ω op een batterij van 9 V, of een kleine gelijkstroommotor. Sluit de plus van de batterij aan op Vin+ en Vin− op de plus van de belasting.
- Sluit de min van de batterij aan op zowel de min van de belasting als de GND-pin van de INA219, zodat de Uno, de batterij en de belasting een gemeenschappelijke massa delen.
- Upload de code, open de Serial Monitor op 115200 baud en vergelijk de stroom die je uitleest met een multimeter die in serie is aangesloten.
1#include <Wire.h>
2#include <Adafruit_INA219.h>
3
4Adafruit_INA219 ina219; // varsayılan adres 0x40 / default address 0x40
5
6void setup() {
7 Serial.begin(115200);
8 if (!ina219.begin()) { // sensörü ve I2C'yi başlat / start sensor and I2C
9 Serial.println(F("INA219 bulunamadi / INA219 not found"));
10 while (1) { delay(10); }
11 }
12 // ina219.setCalibration_32V_1A(); // daha ince adım / finer steps
13 // ina219.setCalibration_16V_400mA(); // küçük akımlar / small currents
14 Serial.println(F("INA219 hazir / ready"));
15}
16
17void loop() {
18 float shunt_mV = ina219.getShuntVoltage_mV(); // şönt üzerindeki gerilim / voltage across the shunt
19 float bus_V = ina219.getBusVoltage_V(); // Vin- ile GND arası / Vin- to GND
20 float current_mA = ina219.getCurrent_mA(); // akım / current
21 float power_mW = ina219.getPower_mW(); // güç / power
22 float source_V = bus_V + shunt_mV / 1000.0; // kaynak gerilimi / source voltage
23
24 Serial.print(F("Kaynak: ")); Serial.print(source_V, 2); Serial.print(F(" V "));
25 Serial.print(F("Yuk: ")); Serial.print(bus_V, 2); Serial.print(F(" V "));
26 Serial.print(F("Sont: ")); Serial.print(shunt_mV, 2); Serial.print(F(" mV "));
27 Serial.print(F("Akim: ")); Serial.print(current_mA, 1); Serial.print(F(" mA "));
28 Serial.print(F("Guc: ")); Serial.print(power_mW, 0); Serial.println(F(" mW"));
29 delay(1000);
30}| Functie | Teruggegeven waarde |
|---|---|
| ina219.begin() | Geeft true terug als de sensor wordt gevonden; start ook de I2C-bus |
| getShuntVoltage_mV() | Spanning over de shunt (mV) |
| getBusVoltage_V() | Spanning tussen Vin− en GND, oftewel de spanning die de belasting ziet (V) |
| getCurrent_mA() | Stroom berekend uit de kalibratie (mA), negatief in tegengestelde richting |
| getPower_mW() | Product van stroom en busspanning (mW) |
| bus_V + shunt_mV / 1000 | De eigen spanning van de bron vóór de shunt (V) |
In het voorbeeld met een batterij van 9 V en een rode led met een weerstand van 220 Ω komt de stroom uit op ongeveer (9 − 2) / 220 ≈ 32 mA; er valt ongeveer 3,2 mV over de shunt en het totale vermogen van de schakeling is 9 V × 32 mA ≈ 290 mW. Naarmate de batterij leegloopt, zie je live de spanning dalen naar 8 V en de stroom meedalen. Kleine waarden zoals 0,1–0,5 mA zonder aangesloten belasting zijn normaal; ze komen van een kleine offset aan de ingang van de chip en betekenen niet dat je meting kapot is.
Kalibratie: de sleutel tot nauwkeurig meten
Als de INA219 opstart, is het kalibratieregister nul; hoewel je de shunt- en busspanning direct kunt uitlezen, blijven het stroom- en vermogensregister dus op nul staan. De kalibratiewaarde volgt uit twee formules in de datasheet: bereken eerst Current_LSB = verwachte maximale stroom / 32768 en rond af op een handig getal, en bepaal dan Cal = 0,04096 / (Current_LSB × R_shunt). De stap van het vermogensregister is altijd 20 keer Current_LSB. Met de shunt van 0,1 Ω op de module en 3,2 A is Current_LSB = 3,2 / 32768 ≈ 97,7 µA, wat afrondt op 100 µA; Cal = 0,04096 / (0,0001 × 0,1) = 4096 en de vermogensstap is 2 mW. De Adafruit-bibliotheek biedt drie kant-en-klare profielen die deze berekening voor je doen:
| Functie | Busbereik | Shuntbereik | Max. stroom | Stroomstap |
|---|---|---|---|---|
| setCalibration_32V_2A() (standaard) | 32 V | ±320 mV | ≈3,2 A | 0,1 mA |
| setCalibration_32V_1A() | 32 V | ±320 mV | ≈1,3 A | 0,04 mA |
| setCalibration_16V_400mA() | 16 V | ±40 mV | ≈400 mA | 0,05 mA |
De "32 V" in de tabel is alleen het registerbereik; de echte limiet van de chip blijft 26 V. Als je de shunt hebt vervangen, geven de kant-en-klare profielen verkeerde resultaten. De eenvoudigste oplossing is de stroom zelf te berekenen: stroom (mA) = getShuntVoltage_mV() / R_shunt (Ω). Lees je bijvoorbeeld 15 mV bij een shunt van 1 Ω, dan is de stroom 15 mA. Om fijn af te stellen op een referentie die je vertrouwt, gebruik je de correctieformule uit de datasheet: Cal_nieuw = Cal × (stroom volgens de multimeter / stroom volgens de INA219). Toont de multimeter 500 mA en de INA219 495 mA, dan schrijf je 4096 × 500 / 495 ≈ 4137. Omdat het kalibratieregister wordt gewist als de voeding wegvalt, schrijft de Adafruit-bibliotheek de waarde vóór elke stroommeting opnieuw; schrijf je je eigen code, dan moet je de kalibratie ook bij elke start van de sensor opnieuw sturen. Rechtstreeks naar het register schrijven zie je in het Pico-gedeelte.
Batterijverbruik met de ESP32: een mAh- en mWh-teller
Om te weten hoe lang een batterij meegaat, telt het totale verbruik zwaarder dan de momentane stroom. De totale lading is de optelsom van de stroom over de tijd: vermenigvuldig bij elke meting de stroom (mA) met de verstreken tijd (uren) en tel op om mAh te krijgen, en doe hetzelfde met het vermogen voor mWh. De onderstaande code gebruikt de standaard I2C-pinnen van de ESP32 (SDA 21, SCL 22), kiest het profiel 32V_1A voor fijnere stappen en werkt de totalen elke halve seconde bij. Omdat er geen versieafhankelijke functies in zitten, compileert hij ongewijzigd met ESP32 Arduino core 2.x en 3.x.
1#include <Wire.h>
2#include <Adafruit_INA219.h>
3
4Adafruit_INA219 ina219(0x40);
5
6float totalmAh = 0.0; // toplam yük / total charge
7float totalmWh = 0.0; // toplam enerji / total energy
8unsigned long lastMs = 0;
9
10void setup() {
11 Serial.begin(115200);
12 Wire.begin(21, 22); // SDA, SCL
13 if (!ina219.begin(&Wire)) {
14 Serial.println("INA219 bulunamadi / not found");
15 while (true) { delay(10); }
16 }
17 ina219.setCalibration_32V_1A(); // 1,3 A'e kadar, 0,04 mA adım / up to 1.3 A, 0.04 mA steps
18 lastMs = millis();
19}
20
21void loop() {
22 unsigned long now = millis();
23 if (now - lastMs >= 500) {
24 float hours = (now - lastMs) / 3600000.0; // geçen süre (saat) / elapsed time (hours)
25 lastMs = now;
26
27 float busV = ina219.getBusVoltage_V();
28 float currentmA = ina219.getCurrent_mA();
29 float powermW = ina219.getPower_mW();
30
31 totalmAh += currentmA * hours; // mA x saat = mAh / mA x hours = mAh
32 totalmWh += powermW * hours; // mW x saat = mWh / mW x hours = mWh
33
34 Serial.printf("%.2f V %.1f mA %.0f mW | %.3f mAh %.2f mWh\n",
35 busV, currentmA, powermW, totalmAh, totalmWh);
36 }
37}Trekt een sensornode bijvoorbeeld gemiddeld 45 mA, dan gaat een 18650-cel van 2500 mAh theoretisch 2500 / 45 ≈ 55 uur mee; in de praktijk is het door conversieverliezen en doordat je de cel niet helemaal leegtrekt realistisch om op 70–80% daarvan te rekenen. Deze berekening doe je snel met de batterijduurcalculator. Wees voorzichtig met deep sleep-tests: met een shunt van 0,1 Ω is de echte stap ongeveer 0,1 mA, dus een slaapstroom op microampèreniveau lijkt nul. De meeste ontwikkelboards trekken door de USB-serialchip en de regelaar zelfs in slaap enkele mA, en dat laat de INA219 gemakkelijk zien. Om de slaapstroom van ongeveer 10 µA van een kale ESP32-module te zien, heb je een shunt van 1–10 Ω nodig; de maximale stroom daalt dan naar tussen 320 mA en 32 mA, dus met dezelfde opstelling kun je de stroom in wakkere toestand niet meten.
Raspberry Pi Pico en MicroPython: de INA219 via zijn registers
In MicroPython is het zowel makkelijk als leerzaam om de INA219 zonder bibliotheek rechtstreeks via zijn registers aan te sturen. De waarde 0x399F die we naar het configuratieregister (0x00) schrijven, kiest het bereik van 32 V, PGA /8, 12-bit resolutie en continue meetmodus; dit is ook de standaardwaarde van de chip bij het opstarten. Daarna wordt 4096 naar het kalibratieregister (0x05) geschreven. De shuntspanning (0x01) en de stroom (0x04) zijn 16-bit getallen met teken; bij het busspanningsregister (0x02) worden de laagste 3 bits weggelaten en wordt de waarde met 4 mV vermenigvuldigd. Sla je de code in Thonny op als main.py, dan begint de Pico bij elke start te meten. Verander je de shunt, dan hoef je alleen R_SHUNT en CURRENT_LSB aan te passen; Cal wordt automatisch berekend. Ben je nieuw met MicroPython, begin dan met het bericht MicroPython-basis.
1from machine import Pin, I2C
2import time
3
4ADDR = 0x40 # A0, A1 boşta / A0, A1 open
5R_SHUNT = 0.1 # ohm, modüldeki R100 / the module's R100
6CURRENT_LSB = 0.0001 # 0,1 mA/bit
7CAL = round(0.04096 / (CURRENT_LSB * R_SHUNT)) # = 4096
8
9i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=400000)
10
11def write_reg(reg, value):
12 i2c.writeto_mem(ADDR, reg, bytes([(value >> 8) & 0xFF, value & 0xFF]))
13
14def read_reg(reg, signed=False):
15 d = i2c.readfrom_mem(ADDR, reg, 2)
16 v = (d[0] << 8) | d[1]
17 if signed and v > 32767: # ikiye tümleyen / two's complement
18 v -= 65536
19 return v
20
21print("Bulunan / found:", [hex(a) for a in i2c.scan()])
22write_reg(0x00, 0x399F) # 32 V, PGA /8, 12 bit, sürekli / 32 V, PGA /8, 12-bit, continuous
23write_reg(0x05, CAL) # kalibrasyon / calibration
24
25while True:
26 shunt_mv = read_reg(0x01, True) * 0.01 # 10 uV/bit
27 bus_v = (read_reg(0x02) >> 3) * 0.004 # 4 mV/bit
28 current_ma = read_reg(0x04, True) * CURRENT_LSB * 1000
29 power_mw = read_reg(0x03) * CURRENT_LSB * 20 * 1000 # güç adımı = 20 x LSB / power step = 20 x LSB
30 print("{:.2f} V {:.2f} mV {:.1f} mA {:.0f} mW".format(bus_v, shunt_mv, current_ma, power_mw))
31 time.sleep(1)Zonnepanelen en het laden van batterijen meten
Bij zonnepaneelprojecten sluit je de INA219 aan tussen de plus van het paneel en de laadschakeling of belasting, en hij toont het echte vermogen dat het paneel op dat moment levert. Bedenk dat je het nominale vermogen alleen onder een geschikte belasting ziet: zonder belasting is de stroom nul en is de spanning de nullastspanning (Voc). Een klein paneel van 6 V en 2 W geeft in volle zon ongeveer 330 mA; op een bewolkte dag kan dat dalen tot een tiende. Door elke minuut een meting te loggen, kun je de dagelijkse energieopbrengst in Wh berekenen, het effect van de hoek van het paneel zien of een vast paneel vergelijken met een zonvolgsysteem. Panelen die als "12 V" worden verkocht, hebben een nullastspanning van ongeveer 21–22 V; dat is nog steeds veilig voor de INA219, maar als je twee panelen in serie zet, overschrijd je de limiet van 26 V. Zet je in systemen met een paneel en een batterij de INA219 tussen de batterij en de schakeling, met Vin+ richting de batterij en Vin− richting de schakeling, dan profiteer je van de meting in twee richtingen: de stroom is positief terwijl de batterij de schakeling voedt en negatief terwijl hij laadt. Zo zie je ook hoeveel stroom een laadmodule zoals de TP4056 echt aan de batterij levert.
INA219 of ACS712?

| Eigenschap | INA219 | ACS712 (5 A) |
|---|---|---|
| Meetprincipe | Shuntweerstand + ADC | Hall-effect |
| Uitgang | Digitaal (I2C) | Analoge spanning (VCC/2 bij nulstroom) |
| Wat hij meet | Stroom, spanning en vermogen | Alleen stroom |
| Soort stroom | Alleen gelijkstroom | Wissel- en gelijkstroom |
| Bereik | ±3,2 A (met shunt van 0,1 Ω), tot 26 V | ±5 A (er bestaan ook versies van 20 A en 30 A) |
| Resolutie | Ongeveer 0,1 mA | 185 mV/A; ongeveer 26 mA per stap met de ADC van de Uno |
| Isolatie | Geen | Ja (2,1 kV RMS) |
| Voeding | 3,0–5,5 V | 5 V |
Kortom: voor gelijkstroomschakelingen onder enkele ampères, voor batterij- en zonnepaneelmetingen en voor microcontrollerprojecten met lage stroom is de INA219 veel nauwkeuriger en praktischer; hij gebruikt bovendien geen analoge pin en tot vier sensoren kunnen dezelfde I2C-bus delen. Wisselstroom aan de netzijde bewaken, boven 5 A uitkomen of elektrische isolatie willen tussen de gemeten schakeling en de microcontroller is het terrein van de ACS712; zie het bericht over de ACS712-stroomsensor voor details. Heb je spanningen boven 26 V of een hogere resolutie nodig, dan is de INA226 (36 V, 16 bit) uit dezelfde familie de betere keuze, en de INA3221 zet drie kanalen op één chip. Wil je de gemeten spanning over een groter bereik zien, dan is de spanningsdelermethode uit het bericht Arduino-voltmeter ook een goede aanvulling.
Projectideeën met de INA219
- USB-vermogensmeter: Leid de 5V-lijn van een USB-kabel door de INA219 en toon op een OLED-display hoeveel mA een telefoonlader of Arduino-board trekt.
- Zonne-energielogger: Meet met een ESP32 elke minuut het vermogen van het paneel, sla het op een SD-kaart op en bereken de dagelijkse opbrengst in Wh.
- Batterijcapaciteitstester: Ontlaad een 18650-cel via een belasting met vaste weerstand tot 3,0 V en bepaal de echte capaciteit uit de opgetelde mAh (zie wat is mAh).
- Alarm bij vastlopen van de motor: Stop de gelijkstroommotor als de stroom verdubbelt; ideaal om een geblokkeerd wiel op robotauto's te herkennen.
- Droogloopbeveiliging van de pomp: Als het water op is, daalt de stroom van een minipomp merkbaar; detecteer die daling en schakel de pomp uit om de levensduur te verlengen.
- Display voor een labvoeding: Toon de uitgangsspanning, stroom en het vermogen van een regelbare voeding live op een I2C-LCD.
Veelgemaakte fouten en hoe je ze oplost
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| Melding "INA219 niet gevonden" | SDA/SCL verwisseld, VCC niet aangesloten of een ander adres | Controleer de draden, zoek het adres met een I2C-scanner (0x40–0x45) |
| Stroom wordt negatief uitgelezen | Vin+ en Vin− zijn verwisseld | Sluit de voeding aan op Vin+ en de belasting op Vin−, of draai het teken om in software |
| Stroom klopt, spanning is 0 of onzin | De min van de belasting en de GND van de INA219 zijn niet gemeenschappelijk | Verbind de GND's van voeding, belasting en module |
| Stroom altijd 0 | Geen belasting aangesloten, module parallel aangesloten of stroom kleiner dan de stapgrootte | Controleer de serieschakeling; gebruik een grotere shunt voor heel kleine stromen |
| Waarde blijft rond 3,2 A hangen | Bereik van de shuntspanning overschreden | Verlaag de belasting of gebruik een kleinere shunt en bereken de stroom zelf |
| Metingen blijven springen | Motor of led met PWM-aansturing, draadruis | Neem een gemiddelde, verhoog het interne aantal samples, pas een softwarefilter toe |
| Module werd heet of brandde door | Parallelle aansluiting (kortsluiting) of stroom boven 3 A | Sluit de module altijd in serie aan en gebruik een zekering op de lijn |
Met één kleine module geeft de INA219 je project in één keer een voltmeter, een ampèremeter en een wattmeter; achter veel ideeën, van zonnepanelen en batterijduur tot motorbeveiliging en USB-vermogensmeters, zit nauwkeurig meten. In de BlueGrays-app vind je projecten zoals een digitale voltmeter met een LCD, ESP32 deep sleep, een temperatuurlogger en slimme bewatering, met schakelschema's en code stap voor stap, en je kunt er de INA219 aan toevoegen en meteen hun verbruik gaan meten.
Veelgestelde vragen
Hoeveel ampère kan de INA219 maximaal meten?
Met de shunt van 0,1 Ω op kant-en-klare modules meet de INA219 tot ongeveer ±3,2 A, omdat de limiet voor de shuntspanning van de chip ±320 mV is. Vervang je de shunt door een kleinere weerstand zoals 0,01 Ω, dan stijgt het theoretische bereik naar 32 A; maar omdat de koperbanen en aansluitklemmen van de module niet voor die stroom gemaakt zijn, zou je de shunt en dikke draden buiten het board moeten brengen.
Kan de INA219 wisselstroom meten?
Nee. De INA219 is ontworpen voor gelijkstroomschakelingen en de spanning op zijn aansluitingen moet binnen 0–26 V blijven; aansluiten op netspanning zou de chip vernietigen en levensgevaarlijk zijn. Voor wisselstroom gebruik je geïsoleerde Hall-sensoren zoals de ACS712 of stroomtransformatoren zoals de SCT-013.
Hoe verander je het I2C-adres van de INA219?
De soldeerbruggen A0 en A1 op de module bepalen het adres: 0x40 als beide open zijn, 0x41 als alleen A0 gesloten is, 0x44 als alleen A1 gesloten is en 0x45 als beide gesloten zijn. In code geef je het adres gewoon op als Adafruit_INA219 ina219(0x41);. Zo kun je vier verschillende INA219's op dezelfde I2C-bus aansluiten.
Wat is het verschil tussen de INA219 en de INA226?
De INA226 is het geavanceerdere lid van dezelfde familie: de busspanning gaat tot 36 V en zijn 16-bit ADC geeft een veel hogere resolutie. De INA219 is goedkoper en gangbaarder, met zeer brede ondersteuning in Arduino-bibliotheken. Voor hobbyprojecten onder 26 V en enkele ampères is de INA219 ruim voldoende.
Werkt de INA219 op 3,3 V?
Ja, het voedingsbereik van de INA219 is 3,0–5,5 V. Voed je de module op de ESP32 en Raspberry Pi Pico vanaf de 3V3-pin, dan blijven ook de I2C-lijnen op 3,3 V. De voedingsspanning beperkt de gemeten lijn niet; een INA219 die op 3,3 V wordt gevoed, kan nog steeds een lijn tot 26 V meten.
Waarom toont de INA219 een kleine stroom, zelfs zonder belasting?
De shuntingang van de chip heeft een offset van enkele tientallen microvolt; bij een shunt van 0,1 Ω betekent dat een kleine uitlezing van 0,1–0,5 mA. Je kunt deze fout wegnemen door de waarde zonder belasting te noteren en die van latere metingen af te trekken, of door meerdere metingen te middelen.
Projecten om hierna te bouwen
Alle projecten bekijken
Digitale voltmeter met lcd-scherm
Ontdek hoeveel spanning een batterij of voedingsadapter geeft met een meter die je zelf hebt gebouwd.

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.

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.

Een lcd-scherm gebruiken met I2C
Geef je Arduino een eigen scherm en laat hem zijn eerste bericht schrijven. Het lcd-scherm met twee regels sluit je aan met maar een paar draden; op de bovenste regel verschijnt een groet, daarna een…

ESP32 I2C-LCD-display (16x2)
In dit project sluit je een 16x2-tekens-LCD via I2C aan op de ESP32 en toon je tekst. Met I2C bedien je het scherm met slechts 2 datapinnen (SDA en SCL), in plaats van de 6+ pinnen die een klassieke parallelle aansluiting verspilt. De code toont op de eerste regel een vaste tekst en op de tweede regel een teller die elke seconde oploopt. Bij het opstarten schrijft een I2C-scanner ook het adres van het display naar de Serial Monitor (meestal 0x27 of 0x3F).

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

ESP32 slimme verlichting (PIR + LDR + relais + OLED)
Met een ESP32, een PIR-bewegingssensor, een LDR-lichtsensor en een relaismodule maak je van je gang, toilet of bijkeuken slimme verlichting. Is het al licht in de ruimte, dan blijft het licht uit, ook bij beweging, zodat overdag geen energie wordt verspild. Het licht blijft 30 seconden aan en de tijd verlengt automatisch zolang er beweging is.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

