ACS712-stroomsensor: meet gelijk- en wisselstroom met Arduino
Zo gebruik je de ACS712-stroomsensor: gevoeligheid 5A/20A/30A, nulpunt van 2,5 V, Arduino-code voor DC en AC RMS, vermogensberekening, ESP32-spanningsdeler en INA219.
De ACS712-stroomsensor is een kleine, goedkope module die met het halleffect meet welke stroom er door een schakeling loopt en die omzet in een spanning die je Arduino kan inlezen. Zonder stroom staat de uitgang op ongeveer 2,5 V; de spanning stijgt als de stroom de ene kant op loopt en daalt als de stroom de andere kant op loopt. Daardoor kun je met één analoge pin zowel gelijkstroom (DC) als wisselstroom (AC) meten. Je gebruikt hem om te zien hoeveel stroom een motor trekt, om een batterij te volgen terwijl die leegloopt, om te detecteren of een apparaat draait of om uit te rekenen hoeveel vermogen een huishoudelijk apparaat verbruikt. Bovendien is het stroompad dat je meet elektrisch gescheiden van de Arduino-kant.
In deze gids leer je stap voor stap wat er in de ACS712 zit, hoe de modellen van 5A, 20A en 30A verschillen en welke je moet kiezen, hoe je de module in serie met je schakeling aansluit, de eerste Arduino-sketch die gelijkstroom meet, hoe je onrustige metingen kalmeert door te middelen, hoe je RMS voor wisselstroom berekent en hoe je vermogen (W) en energie (Wh) uitrekent. Daarna zie je hoe je hem via een spanningsdeler aansluit op de 3,3 V-boards ESP32 en Raspberry Pi Pico, waarom je met netspanning heel voorzichtig moet zijn en waarom de INA219 een betere keuze is voor kleine stromen.

Wat is de ACS712-stroomsensor en hoe werkt hij?
De ACS712 is een chip met 8 pins van Allegro. De stroom die je meet loopt door een dik koperen pad in de chip, van pin 1 en 2 naar pin 3 en 4. Dit pad heeft een weerstand van slechts 1,2 mΩ; zelfs bij 10 A valt er maar 12 mV over en wordt er 0,12 W omgezet in warmte, dus de schakeling die je meet wordt nauwelijks beïnvloed. Als er stroom door deze geleider loopt, ontstaat een magnetisch veld dat evenredig is met de stroom. Een hallsensor recht boven het koperen pad meet dat veld en een versterker in de chip zet het om in een spanning. Meer over de basis lees je in onze gids over hallsensoren.
Er is geen elektrische verbinding tussen het koperen pad met de stroom en de kant die de chip voedt; de enige koppeling is het magnetische veld. Daarom zijn de gemeten lijn en de Arduino van elkaar gescheiden (galvanische scheiding). De uitgangsspanning volgt deze formule: Vout = VCC / 2 + gevoeligheid × I. Als er stroom van IP+ naar IP− loopt, stijgt de uitgang boven 2,5 V; loopt de stroom de andere kant op, dan daalt de uitgang eronder. De ACS712 is ook ratiometrisch: zowel het nulpunt als de gevoeligheid schalen mee met de voedingsspanning. Zakt de voeding naar 4,8 V, dan wordt het nulpunt 2,4 V en daalt de gevoeligheid van het 5A-model van 185 naar ongeveer 178 mV/A.
| Parameter | Waarde |
|---|---|
| Voedingsspanning | 4,5–5,5 V (typisch 5 V) |
| Voedingsstroom | Typisch 10 mA, max. 13 mA |
| Uitgang bij nulstroom | VCC × 0,5 (2,5 V bij 5 V) |
| Weerstand van de geleider | 1,2 mΩ |
| Bandbreedte | 80 kHz (lager met de condensator op de FILTER-pin) |
| Totale uitgangsfout | ±1,5% bij 25 °C |
| Isolatiespanning | 2,4 kV RMS (60 seconden) |
| Uitgangsbelasting | Minimaal 4,7 kΩ, maximaal 10 nF |
| Kortstondige overstroom | 100 A (enkele puls, 100 ms) |
| Bedrijfstemperatuur | −40 tot 85 °C |
| Aansluitingen van de module | VCC, OUT, GND en een schroefklem met 2 aansluitingen |
Modellen 5A, 20A en 30A: gevoeligheid en resolutie
De ACS712 bestaat in drie versies die er aan de buitenkant precies hetzelfde uitzien. Om te weten welke je hebt, lees je de aanduiding op de chip: ELC-05B meet ±5 A, ELC-20A ±20 A en ELC-30A ±30 A. De gevoeligheid geeft aan hoeveel millivolt de uitgang verandert per 1 A stroom. Hoe groter het bereik, hoe lager de gevoeligheid, zodat de uitgang bij de modellen 20A en 30A zelfs bij volle stroom tussen 0,5 en 4,5 V blijft. De tabel hieronder laat ook zien hoeveel milliampère één stap van de 10-bits ADC van de Uno (4,88 mV) bij elk model vertegenwoordigt.
| Model (aanduiding op de chip) | Bereik | Gevoeligheid | Uitgang bij vol bereik | 1 ADC-stap op Uno | Ruis (47 nF-filter) |
|---|---|---|---|---|---|
| ACS712ELCTR-05B | ±5 A | 185 mV/A (180–190) | 1,58–3,43 V | ≈ 26 mA | 21 mV ≈ 0,11 A piek-tot-piek |
| ACS712ELCTR-20A | ±20 A | 100 mV/A (96–104) | 0,50–4,50 V | ≈ 49 mA | 11 mV ≈ 0,11 A piek-tot-piek |
| ACS712ELCTR-30A | ±30 A | 66 mV/A (63–69) | 0,52–4,48 V | ≈ 74 mA | 7 mV ≈ 0,11 A piek-tot-piek |
Uit de tabel volgen twee belangrijke conclusies. Ten eerste is de ruis, uitgedrukt in ampère, bij alle drie de modellen ongeveer 0,1 A; als je het 30A-model gebruikt voor een belasting van 2 A, gooi je twee derde van je resolutie weg. De regel is simpel: kies het kleinste model dat de hoogste stroom die je gaat meten veilig dekt (bij AC de piekwaarde). Het 5A-model past bijvoorbeeld bij een 12 V-gelijkstroommotor die hooguit 2–3 A trekt, en het 20A-model bij een kachel van 1500 W. Ten tweede is de ACS712 niet gemaakt voor kleine stromen: je kunt er geen led mee meten die een paar milliampère trekt, of een ESP32 in deep sleep. Daarvoor is de INA219 aan het einde van deze gids veel beter geschikt.
ACS712-bedrading: Arduino Uno, ESP32 en Pico
De ACS712-module heeft twee kanten. De kant met de schroefklem hoort bij de schakeling die je meet: de stroom moet via de ene klem binnenkomen en via de andere weggaan, dus de module staat in serie met de belasting, net als een ampèremeter. Meestal knip je de plusdraad van de voeding door, sluit je het uiteinde van de voeding aan op de ene kant van de klem en het uiteinde naar de belasting op de andere kant. De kant met drie pins gaat naar de Arduino. De ACS712 werkt alleen op 5 V; bij de ESP32 en Pico voed je de module dus ook vanaf een pin die 5 V levert en lees je de uitgang via een spanningsdeler.
| ACS712-pin | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VCC | 5V | 5V (VIN op sommige boards) | VBUS (pin 40) |
| OUT | A0 | GPIO 34 (via 10k/20k-deler) | GP26 (via 10k/20k-deler) |
| GND | GND | GND | GND |
| Schroefklem | In serie met de belasting | In serie met de belasting | In serie met de belasting |
Behalve de chip zitten er weinig onderdelen op de module: een ontkoppelcondensator op de voedingslijn, een kleine condensator op de FILTER-pin die de bandbreedte bepaalt, de voedingsled (D1) en het bijbehorende weerstandje (R1). De 102 op R1 betekent 1 kΩ; zulke aanduidingen ontcijfer je eenvoudig met de SMD-codecalculator. Omdat de ACS712 gescheiden is, hoef je de min van de gemeten schakeling niet met de GND van de Arduino te verbinden als je alleen stroom meet.
Stap voor stap: gelijkstroom meten met Arduino
- Verbind de VCC-pin van de module met de 5V-pin van de Arduino, GND met GND en OUT met A0. De voedingsled op de print moet gaan branden.
- Knip de plusdraad van de schakeling die je wilt meten door: sluit het uiteinde van de voeding aan op de ene kant van de klem en het uiteinde naar de belasting (bijv. een 12 V-motor of ledstrip) op de andere kant.
- Laat de voeding van de belasting uit en upload de onderstaande sketch. Bij het opstarten meet de sketch het nulpunt terwijl er geen stroom loopt.
- Open de Serial Monitor op 9600 baud; zonder stroom moet de waarde rond 0.00 A blijven en hooguit een paar honderdsten ampère schommelen.
- Zet de voeding van de belasting aan. Als de stroom negatief wordt weergegeven, verwissel dan de twee draden in de klem of vermenigvuldig het resultaat met −1.
- Stel SENSITIVITY in de code in op je model: 0.185 voor 5A, 0.100 voor 20A en 0.066 voor 30A.
1// ACS712 ile DC akım ölçme / DC current measurement with ACS712
2const int SENSOR_PIN = A0; // ACS712 OUT pini / ACS712 OUT pin
3const float SENSITIVITY = 0.185; // V/A: 5A=0.185, 20A=0.100, 30A=0.066
4const float ADC_STEP = 5.0 / 1024.0; // bir ADC basamağı (V) / one ADC step (V)
5const int SAMPLES = 200; // ortalama için örnek sayısı / samples to average
6
7float zeroRaw = 512.0; // akım yokken ham değer / raw value at zero current
8
9// SAMPLES kez okuyup ortalamayı döndürür / reads SAMPLES times and returns the average
10float readAverageRaw() {
11 long sum = 0;
12 for (int i = 0; i < SAMPLES; i++) {
13 sum += analogRead(SENSOR_PIN);
14 }
15 return sum / (float)SAMPLES;
16}
17
18void setup() {
19 Serial.begin(9600);
20 delay(500); // sensörün oturmasını bekle / let the sensor settle
21 zeroRaw = readAverageRaw(); // yük KAPALIYKEN sıfır noktası / zero point with the load OFF
22 Serial.print(F("Sifir noktasi / Zero point: "));
23 Serial.print(zeroRaw * ADC_STEP, 3);
24 Serial.println(F(" V"));
25}
26
27void loop() {
28 float raw = readAverageRaw();
29 float current = (raw - zeroRaw) * ADC_STEP / SENSITIVITY; // amper / amps
30
31 Serial.print(F("Akim / Current: "));
32 Serial.print(current, 2);
33 Serial.println(F(" A"));
34 delay(500);
35}Bij elke meting middelt de sketch 200 analogRead-resultaten; omdat één analogRead op de Uno ongeveer 0,11 ms duurt, is dat zo'n 22 ms. De stroom volgt uit I = (raw − nulpunt) × (5 / 1024) / gevoeligheid. Bij het 5A-model met een nulpunt van 512 is een gemiddelde meting van 550 bijvoorbeeld een verschil van 38 stappen; dat is 38 × 4,88 mV = 185,5 mV, dus de stroom is 185,5 / 185 ≈ 1,00 A. Het nulpunt bij het opstarten meten in plaats van 2,5 V aan te nemen is belangrijk, want de eigen offset van de chip en kleine verschillen op de massalijn van het board verschuiven het met een paar stappen, en die fout komt bij elke meting terug.
Ruis en middelen
De uitgang van de ACS712 blijft schommelen, ook als de stroom constant is. De eerste oorzaak is de eigen ruis van de hallsensor: de fabrikant geeft de ruiswaarden hierboven op met een condensator van 47 nF op de FILTER-pin, wat neerkomt op ongeveer 2 kHz bandbreedte. De meeste modules gebruiken daar echter 1 nF, zoals in het voorbeeldschema van de fabrikant; de bandbreedte stijgt dan naar 80 kHz en de ruis is een paar keer hoger. De tweede oorzaak is de ADC: zelfs bij het 5A-model meet de Uno in stappen van 26 mA, en de laatste stap flikkert altijd op en neer. Willekeurige ruis neemt af met de wortel van het aantal gemiddelde metingen: 16 metingen verkleinen hem tot een kwart, 256 metingen tot een zestiende. Over andere filtermethoden lees je meer in onze gids over het filteren van sensordata.
- Middelen over meerdere metingen: Middel bij DC 100–500 metingen. Als je de metingen over 20 ms uitsmeert, valt ook de 50 Hz-storing van het net weg in het gemiddelde.
- Exponentieel voortschrijdend gemiddelde: Meng elke nieuwe meting door de oude met gefilterd = gefilterd + 0.1 × (nieuw − gefilterd); het gebruikt bijna geen geheugen en geeft een rustige waarde op het display.
- Dode zone: Als je geen waarden zoals 0.03 A wilt zien terwijl er niets is aangesloten, behandel dan resultaten met een absolute waarde onder 0.05 A als 0.
- Hardwarefilter: Als je kunt solderen, plaats dan een condensator van 47 nF parallel aan die op de FILTER-pin om de bandbreedte terug te brengen tot ongeveer 2 kHz; dat is ruim genoeg voor DC en 50 Hz-netstroom.
- Blijf uit de buurt van magnetische velden: De ACS712 is een hallsensor; een magneet, luidspreker of een andere draad met een grote stroom in de buurt verschuift de meting.
- Ververs het nulpunt: Het nulpunt drijft een paar millivolt mee met de temperatuur; meet bij langlopende projecten het nulpunt opnieuw terwijl de belasting uit staat.

Middelen haalt ruis weg, maar verhelpt geen systematische fout. De gevoeligheid kan van chip tot chip een paar procent verschillen; bij het 5A-model ligt hij tussen 180 en 190 mV/A. Voor de beste nauwkeurigheid sluit je een multimeter op het stroombereik in serie aan in dezelfde lijn als de ACS712, stuur je een bekende stroom van bijvoorbeeld 1–2 A door de schakeling en vergelijk je de twee waarden. Toont de multimeter 2.00 A en de Arduino 1.94 A, dan is je correctiefactor 2.00 / 1.94 = 1.031; deel SENSITIVITY in de code door dit getal (0.185 / 1.031 ≈ 0.179) en je metingen komen overeen met de multimeter.
Wisselstroom meten: de RMS-berekening
Netstroom verandert voortdurend van richting: de frequentie is 50 Hz in Europa en het grootste deel van de wereld, en 60 Hz in de VS. Daarom beschrijft de uitgang van de ACS712 een sinusgolf rond 2,5 V waarvan het gemiddelde overeenkomt met nulstroom; draai je de DC-sketch op een AC-belasting, dan krijg je betekenisloze waarden dicht bij 0 A. De grootheid die bij AC telt is de RMS-waarde (effectieve waarde): die is gelijk aan de gelijkstroom die dezelfde warmte zou opwekken en is de waarde die multimeters, zekeringen en typeplaatjes gebruiken. De berekening volgt de naam: trek het nulpunt af van elke meting, kwadrateer (Square), neem het gemiddelde van de kwadraten (Mean) en neem de wortel (Root).
De lengte van het meetvenster is belangrijk; bevat het geen geheel aantal perioden, dan verandert het resultaat telkens een beetje. Eén periode duurt 20 ms bij 50 Hz en 16,7 ms bij 60 Hz. Een venster van 100 ms bevat precies 5 perioden bij 50 Hz en precies 6 bij 60 Hz, dus het werkt goed op beide netten, en de Uno neemt in die tijd ongeveer 900 metingen. Bij een zuivere sinusgolf is de piek 1,414 keer de RMS-waarde, dus je zou ook de piek door √2 kunnen delen. Belastingen zoals telefoonladers, ledlampen of dimmers trekken echter pieken en geen sinusvormige stroom, en met die sluiproute krijg je dan een verkeerd resultaat; de sketch hieronder berekent de ware RMS en is bij zulke belastingen dus veel nauwkeuriger. De piekwaarde moet binnen het bereik van het model blijven:
| Model | Limiet piekstroom | Max. wisselstroom (RMS, sinus) | Ca. vermogen bij 230 V |
|---|---|---|---|
| 5A | ±5 A | 3,5 A | ≈ 800 W |
| 20A | ±20 A | 14,1 A | ≈ 3250 W |
| 30A | ±30 A | 21,2 A | ≈ 4900 W |
1// ACS712 ile AC akım (RMS) ve görünür güç / AC current (RMS) and apparent power with ACS712
2const int SENSOR_PIN = A0;
3const float SENSITIVITY = 0.100; // 20A modül: 100 mV/A / 20A module: 100 mV/A
4const float ADC_STEP = 5.0 / 1024.0;
5const unsigned long WINDOW_MS = 100; // 50 Hz'te 5, 60 Hz'te 6 tam periyot / 5 cycles at 50 Hz, 6 at 60 Hz
6const float MAINS_VOLTAGE = 230.0; // şebeke gerilimi (V) / mains voltage (V)
7
8float noiseRms = 0.0; // yük yokken ölçülen gürültü (A) / noise measured with no load (A)
9
10// Pencere boyunca örnek alır, ortalamayı çıkarıp RMS hesaplar / samples over the window, removes the mean, returns RMS
11float readRmsAmps() {
12 long sum = 0;
13 unsigned long sumSq = 0;
14 unsigned int n = 0;
15 unsigned long start = millis();
16 while (millis() - start < WINDOW_MS) {
17 int d = analogRead(SENSOR_PIN) - 512; // 2,5 V'u sıfıra yaklaştır / shift 2.5 V to about zero
18 sum += d;
19 sumSq += (long)d * d;
20 n++;
21 }
22 float mean = sum / (float)n; // sıfır noktası kayması / zero point offset
23 float variance = sumSq / (float)n - mean * mean; // yalnız AC kısım / AC part only
24 if (variance < 0) variance = 0;
25 return sqrt(variance) * ADC_STEP / SENSITIVITY;
26}
27
28void setup() {
29 Serial.begin(9600);
30 delay(500);
31 noiseRms = readRmsAmps(); // ilk ölçüm yük KAPALIYKEN / first reading with the load OFF
32 Serial.print(F("Gurultu / Noise: "));
33 Serial.print(noiseRms, 3);
34 Serial.println(F(" A"));
35}
36
37void loop() {
38 float irms = readRmsAmps();
39 float sq = irms * irms - noiseRms * noiseRms; // gürültüyü karesel çıkar / subtract noise in quadrature
40 irms = (sq > 0) ? sqrt(sq) : 0.0;
41 float apparentPower = MAINS_VOLTAGE * irms; // VA; dirençli yükte ≈ W / VA; ≈ W for resistive loads
42
43 Serial.print(F("Irms: "));
44 Serial.print(irms, 3);
45 Serial.print(F(" A Guc / Power: "));
46 Serial.print(apparentPower, 1);
47 Serial.println(F(" VA"));
48 delay(1000);
49}Deze sketch slaat het nulpunt niet op als vast getal; in elk venster bepaalt hij het gemiddelde van de metingen en trekt dat af. Wiskundig is dit de wortel van de variantie: RMS² = gemiddelde van de kwadraten − kwadraat van het gemiddelde. Omdat wisselstroom over een geheel aantal perioden gemiddeld nul is, is het gevonden gemiddelde precies de nulpuntfout, en de sketch corrigeert zichzelf ook als die met de temperatuur wegdrijft. De ruis die bij het opstarten met uitgeschakelde belasting is gemeten, wordt kwadratisch afgetrokken, omdat ruis en de echte stroom onafhankelijk zijn en RMS-waarden bij hun kwadraten worden opgeteld. Zonder deze stap zie je spookwaarden zoals 0,1 A en 23 VA terwijl er niets is aangesloten. Een voorbeeld: een strijkijzer van 1000 W trekt bij 230 V ongeveer 4,35 A; de piek van 6,1 A valt buiten het bereik van het 5A-model, dus meet het met het 20A-model.
Een veel veiligere manier om de stroom van een huishoudelijk apparaat te meten is een open stroomtransformator zoals de SCT-013, die je gebruikt zonder een draad door te knippen. Hij klikt om de kabel zoals een stroomtang en maakt nooit metaalcontact met het net. Let er alleen op dat de tang om alleen de fase- of alleen de nuldraad zit; klem je beide samen, dan heffen de velden van de tegengestelde stromen elkaar op en is het resultaat nul. Stroomtransformatoren meten alleen wisselstroom; voor gelijkstroom heb je de ACS712 of de INA219 nodig.
Vermogen (W) en energie (Wh) berekenen
Als je de stroom kent, is vermogen één vermenigvuldiging: P = V × I. Levert een 12 V-batterij een motor die 1,5 A trekt, dan is het vermogen 12 × 1,5 = 18 W; dat kun je dubbelchecken met de calculator voor de wet van Ohm. Energie is vermogen maal tijd: draait de motor van 18 W 2 uur, dan verbruikt hij 36 Wh. De sketch doet dit door bij elke meting het vermogen te vermenigvuldigen met de verstreken tijd en dat op te tellen. Om spanning te meten kun je de module gebruiken die als 0–25 V-spanningssensor wordt verkocht; die bevat een spanningsdeler van 30 kΩ en 7,5 kΩ en deelt de ingangsspanning door 5. Wil je een deler ontwerpen met je eigen weerstandswaarden, gebruik dan de spanningsdelercalculator.
1// ACS712 + gerilim sensörü ile güç (W) ve enerji (Wh) / power (W) and energy (Wh) with ACS712 + voltage sensor
2const int CURRENT_PIN = A0; // ACS712 OUT
3const int VOLTAGE_PIN = A1; // 0-25 V gerilim sensörü S pini / 0-25 V voltage sensor S pin
4const float SENSITIVITY = 0.185; // 5A modül / 5A module (V/A)
5const float DIVIDER_RATIO = 5.0; // (30k + 7,5k) / 7,5k = 5 / divider ratio
6const float ADC_STEP = 5.0 / 1024.0;
7const int SAMPLES = 200;
8
9float zeroRaw = 512.0;
10float energyWh = 0.0; // biriken enerji / accumulated energy
11unsigned long lastMs = 0;
12
13float averageRaw(int pin) {
14 long sum = 0;
15 for (int i = 0; i < SAMPLES; i++) sum += analogRead(pin);
16 return sum / (float)SAMPLES;
17}
18
19void setup() {
20 Serial.begin(9600);
21 delay(500);
22 zeroRaw = averageRaw(CURRENT_PIN); // yük kapalıyken sıfır noktası / zero point with the load off
23 lastMs = millis();
24}
25
26void loop() {
27 float current = (averageRaw(CURRENT_PIN) - zeroRaw) * ADC_STEP / SENSITIVITY;
28 float voltage = averageRaw(VOLTAGE_PIN) * ADC_STEP * DIVIDER_RATIO;
29 float power = voltage * current; // P = V x I (W)
30
31 unsigned long now = millis();
32 energyWh += power * (now - lastMs) / 3600000.0; // W x saat = Wh / W x hours = Wh
33 lastMs = now;
34
35 Serial.print(voltage, 2); Serial.print(F(" V "));
36 Serial.print(current, 2); Serial.print(F(" A "));
37 Serial.print(power, 1); Serial.print(F(" W "));
38 Serial.print(energyWh, 3); Serial.println(F(" Wh"));
39 delay(1000);
40}Omdat de spanningsmodule over de plus en min van de gemeten schakeling wordt aangesloten, moeten de min van de schakeling en de GND van de Arduino deze keer wel met elkaar worden verbonden; waarom dat zo is, lees je in onze gids over gemeenschappelijke massa. Om in te schatten hoeveel uur een batterij meegaat, combineer je de gemiddelde stroom die je meet met de berekeningen voor mAh en Wh of met de batterijduurcalculator. Aan de AC-kant ligt het iets anders: Vrms × Irms is het schijnbaar vermogen, gemeten in VA; het werkelijke vermogen (W) is dat vermenigvuldigd met de arbeidsfactor. Bij resistieve belastingen zoals waterkokers, strijkijzers en gloeilampen is de arbeidsfactor heel dicht bij 1, dus VA ≈ W. Bij motoren, adapters en ledlampen kan hij tussen 0,5 en 0,9 liggen; om het werkelijke vermogen te meten moet je ook tegelijk de spanningsgolf bemonsteren, wat gebeurt met gescheiden spanningssensormodules zoals de ZMPT101B.
ACS712 met ESP32: uitlezen via een spanningsdeler
De ESP32 draait op 3,3 V en zijn analoge ingangen meten tot ongeveer 3,1 V; meer dan 3,6 V op een pin zetten kan het board beschadigen. De ACS712 werkt daarentegen alleen op 5 V en zijn uitgang kan bij de modellen 20A en 30A 4,5 V bereiken en bij overstroom bijna 5 V. Je voedt de sensor dus vanaf de 5V-pin van het ESP32-board (VIN op sommige boards) en laat OUT via een spanningsdeler lopen. 10 kΩ + 20 kΩ is een goede keuze: ga van OUT via 10 kΩ naar de ESP32-pin en vanaf datzelfde punt via 20 kΩ naar GND. De verhouding is 20 / 30 = 0,667 en de totaalwaarde van 30 kΩ voldoet ruimschoots aan de minimale belasting van 4,7 kΩ van de ACS712.
| ACS712-uitgang | Betekenis | Spanning op de ESP32-pin |
|---|---|---|
| 0,50 V | −20 A bij het 20A-model | 0,33 V |
| 2,50 V | Nulstroom | 1,67 V |
| 4,50 V | +20 A bij het 20A-model | 3,00 V |
| 5,00 V | Verzadigd door overstroom | 3,33 V |
In de code zitten twee details. Ten eerste is de ADC van de ESP32 aan de uiteinden niet lineair, dus gebruiken we in plaats van ruwe waarden analogReadMilliVolts(), dat de kalibratiegegevens gebruikt die in de fabriek in de chip zijn geschreven. GPIO 34 zit op ADC1 en werkt terwijl Wi-Fi aan staat; ADC2-pins kun je niet samen met Wi-Fi gebruiken. Ten tweede bestaat het ratiometrische gemak van de Uno hier niet: de ADC-referentie van de ESP32 ligt vast, maar de gevoeligheid van de ACS712 verandert met de 5 V van de USB-poort. De oplossing is een simpele truc: omdat de uitgang zonder stroom gelijk is aan de helft van VCC, vermenigvuldig je het bij het opstarten gemeten nulpunt met 2 om de echte voedingsspanning van de sensor te krijgen en corrigeer je de gevoeligheid daarmee. Omdat dezelfde fout zowel in het nulpunt als in het gemeten signaal zit, compenseert deze methode ook de tolerantie van de deelweerstanden. De sketch meet 100 ms lang en geeft twee resultaten tegelijk terug: kijk naar het eerste getal voor een DC-belasting en naar het tweede voor een netapparaat.
1// ESP32 + ACS712 (10k/20k gerilim bölücüyle) / ESP32 + ACS712 (with a 10k/20k voltage divider)
2const int SENSOR_PIN = 34; // ADC1_CH6, Wi-Fi açıkken de çalışır / works while Wi-Fi is on
3const float DIVIDER = 20.0 / 30.0; // R2 / (R1 + R2) = 20k / 30k
4const float SENS_AT_5V = 185.0; // mV/A: 5A=185, 20A=100, 30A=66
5const unsigned long WINDOW_MS = 100; // 50 Hz'te 5 tam periyot / 5 full cycles at 50 Hz
6
7float zeroMv = 2500.0; // akım yokken sensör çıkışı (mV) / sensor output at zero current (mV)
8float sensMv = SENS_AT_5V; // düzeltilmiş hassasiyet (mV/A) / corrected sensitivity (mV/A)
9
10// Bölücüden önceki gerilimin ortalaması (mV) / average voltage before the divider (mV)
11float averageMv(int samples) {
12 uint32_t sum = 0;
13 for (int i = 0; i < samples; i++) sum += analogReadMilliVolts(SENSOR_PIN);
14 return sum / (float)samples / DIVIDER;
15}
16
17// Pencere boyunca okur: DC (ortalama) ve AC (RMS) akım / reads over the window: DC (mean) and AC (RMS) current
18void measure(float &dcAmps, float &acAmps) {
19 double sum = 0, sumSq = 0;
20 uint32_t n = 0;
21 uint32_t start = millis();
22 while (millis() - start < WINDOW_MS) {
23 double d = analogReadMilliVolts(SENSOR_PIN) / DIVIDER - zeroMv;
24 sum += d;
25 sumSq += d * d;
26 n++;
27 }
28 double mean = sum / n;
29 double variance = sumSq / n - mean * mean;
30 if (variance < 0) variance = 0;
31 dcAmps = mean / sensMv;
32 acAmps = sqrt(variance) / sensMv;
33}
34
35void setup() {
36 Serial.begin(115200);
37 analogReadResolution(12);
38 delay(500);
39 zeroMv = averageMv(1000); // yük KAPALIYKEN / with the load OFF
40 sensMv = SENS_AT_5V * (2.0 * zeroMv) / 5000.0; // oransal düzeltme: VCC = 2 x sıfır / ratiometric fix: VCC = 2 x zero
41 Serial.printf("Sifir / Zero: %.0f mV Hassasiyet / Sensitivity: %.1f mV/A\n", zeroMv, sensMv);
42}
43
44void loop() {
45 float dc, ac;
46 measure(dc, ac);
47 Serial.printf("DC: %.2f A AC (RMS): %.2f A\n", dc, ac);
48 delay(1000);
49}ACS712 met Raspberry Pi Pico en MicroPython
De Raspberry Pi Pico draait ook op 3,3 V, dus de bedrading is hetzelfde als bij de ESP32: sluit VCC van de ACS712 aan op VBUS (pin 40), die 5 V levert zolang de Pico via USB wordt gevoed, en OUT via dezelfde 10k/20k-deler op GP26 (ADC0, pin 31). In MicroPython geeft read_u16() een waarde van 0 tot 65535 terug en is de spanning = raw × 3,3 / 65535. De ADC van de Pico is 12-bits; samen met de deler meet hij op papier in stappen van ongeveer 6,5 mA bij het 5A-model, ruwweg vier keer fijner dan de Uno. De onderstaande code meet het nulpunt bij het opstarten, past de ratiometrische correctie toe en print daarna elke seconde de DC- en AC RMS-stroom.
1from machine import ADC
2import time
3import math
4
5adc = ADC(26) # GP26 = ADC0, fiziksel pin 31 / physical pin 31
6VREF = 3.3 # ADC referansı (V) / ADC reference (V)
7DIVIDER = 20 / 30 # 10k/20k bölücü oranı / 10k/20k divider ratio
8SENS_AT_5V = 0.185 # V/A: 5A=0.185, 20A=0.100, 30A=0.066
9
10
11def read_volts(samples=200):
12 # bölücüden önceki ortalama gerilim / average voltage before the divider
13 total = 0
14 for _ in range(samples):
15 total += adc.read_u16() # 0-65535
16 return total / samples * VREF / 65535 / DIVIDER
17
18
19zero = read_volts(1000) # yük KAPALIYKEN / with the load OFF
20sens = SENS_AT_5V * (2 * zero) / 5.0 # oransal düzeltme / ratiometric correction
21print("Sifir / Zero: {:.3f} V".format(zero))
22
23
24def read_rms(window_ms=100):
25 # 100 ms = 50 Hz'te 5 periyot / 5 cycles at 50 Hz
26 n = 0
27 s = 0.0
28 s2 = 0.0
29 start = time.ticks_ms()
30 while time.ticks_diff(time.ticks_ms(), start) < window_ms:
31 v = adc.read_u16() * VREF / 65535 / DIVIDER - zero
32 s += v
33 s2 += v * v
34 n += 1
35 mean = s / n
36 return math.sqrt(max(s2 / n - mean * mean, 0)) / sens
37
38
39while True:
40 dc = (read_volts() - zero) / sens
41 print("DC: {:.2f} A AC (RMS): {:.2f} A".format(dc, read_rms()))
42 time.sleep(1)ACS712 of INA219?
De INA219 is een stroom- en spanningsbewakingschip van Texas Instruments die via I2C communiceert. In plaats van het halleffect meet hij de spanningsval over een kleine shuntweerstand (op modules meestal 0,1 Ω) waar de stroom doorheen loopt. Populaire modules meten tot ±3,2 A met een resolutie van ongeveer 0,8 mA, lezen zelf de busspanning tot 26 V uit en berekenen het vermogen in de chip. Via één I2C-verbinding krijg je dus spanning, stroom en vermogen tegelijk, zonder gedoe met de ADC, middelen of nulkalibratie. Daar staat tegenover dat hij geen scheiding biedt tussen de gemeten schakeling en de Arduino, geen wisselstroom kan meten en niet boven 26 V kan.
| Eigenschap | ACS712 | INA219-module |
|---|---|---|
| Meetmethode | Halleffect (magnetisch) | Shuntweerstand (0,1 Ω) |
| Stroombereik | ±5 / ±20 / ±30 A | ±3,2 A (afhankelijk van de shunt) |
| Resolutie | 26–74 mA met Uno | ≈ 0,8 mA |
| Wisselstroom | Ja | Nee |
| Spanning en vermogen | Nee (aparte deler nodig) | Ja (tot 26 V) |
| Scheiding | Ja | Nee |
| Interface | Analoge uitgang | I2C (adres 0x40–0x4F) |
| Voeding | Alleen 5 V | 3–5,5 V |
| Het best voor | Motoren, kachels, netapparaten, hoge stroom | Batterijen, zonnepanelen, verbruik van sensoren en boards |
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(9600);
8 if (!ina219.begin()) {
9 Serial.println(F("INA219 bulunamadi / INA219 not found"));
10 while (true) delay(10);
11 }
12 // ina219.setCalibration_16V_400mA(); // küçük akımda daha ince çözünürlük / finer resolution for small currents
13}
14
15void loop() {
16 float busV = ina219.getBusVoltage_V(); // yük tarafındaki gerilim / voltage on the load side
17 float current_mA = ina219.getCurrent_mA(); // akım (mA) / current (mA)
18 float power_mW = ina219.getPower_mW(); // güç (mW) / power (mW)
19
20 Serial.print(busV, 2); Serial.print(F(" V "));
21 Serial.print(current_mA, 1); Serial.print(F(" mA "));
22 Serial.print(power_mW, 0); Serial.println(F(" mW"));
23 delay(1000);
24}Installeer voor de code de bibliotheek Adafruit INA219 via de Library Manager. Sluit de SDA- en SCL-pins van de module aan op A4 en A5 van de Uno; de te meten stroom moet bij VIN+ binnenkomen en bij VIN− richting de belasting vertrekken, en de GND van de INA219 moet gedeeld worden met de gemeten schakeling. Kortom: meet je gelijkstroom van een paar milliampère tot 3 A samen met spanning, kies dan de INA219; heb je grotere stromen, wisselstroom of scheiding nodig, dan is de ACS712 de juiste keuze.
Projectideeën met de ACS712
- Overstroombeveiliging voor een motor: Als een gelijkstroommotor die met een L298N wordt aangestuurd blokkeert, schiet de stroom omhoog; stop de motor en laat een alarm klinken zodra je drempel wordt overschreden.
- Batterij- en zonnepaneelmonitor: Meet laad- en ontlaadstroom met de richting, vermenigvuldig met de spanning, tel de Wh op en toon de resultaten op een OLED-display.
- Slimme stekker: Schakel het stopcontact met een relaismodule, controleer met de ACS712 of het apparaat echt draait en stuur de data via MQTT naar Home Assistant.
- Melding dat de wasmachine klaar is: Als de stroom een paar minuten onder een ingestelde waarde blijft, laat je de ESP32 een bericht via Telegram sturen.
- Alarm voor droogdraaiende pomp: Als het water op is, daalt de stroom die de pomp trekt; detecteer dat en schakel de pomp uit.
- Energielogger: Schrijf elke minuut stroom en vermogen naar een SD-kaart of Google Sheets en maak een grafiek van het dagelijkse verbruik.
- Labvoedingsmeter: Voeg een ACS712 toe aan het project Arduino-voltmeter om een instrument te bouwen dat spanning, stroom en vermogen op één scherm toont.
Veelgemaakte fouten en oplossingen
| Verschijnsel | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| Toont 0,1–0,3 A zonder stroom | De code gaat uit van een nulpunt van 2,5 V of 512 | Meet het nulpunt bij het opstarten met de belasting uit en voeg een kleine dode zone toe |
| Waarde blijft springen | Metingen met één sample, brede bandbreedte van het 1 nF-filter | Middel 100–500 metingen; voeg zo nodig 47 nF toe aan FILTER |
| Stroom wordt negatief gelezen | De stroom loopt andersom door de klem | Verwissel de draden of vermenigvuldig het resultaat met −1 |
| Waarden rond 0 A bij een AC-belasting | DC-code gebruikt; een sinusgolf middelt naar nul | Gebruik de sketch die RMS berekent |
| Waarden altijd een paar procent te hoog of te laag | Verkeerde modelwaarde of tolerantie van de gevoeligheid | Kies 0.185, 0.100 of 0.066 aan de hand van de aanduiding op de chip en kalibreer met een multimeter |
| Ruwe waarde blijft hangen op 0 of 1023 | OUT op de verkeerde pin of verbonden met VCC, stroom buiten het bereik van het model | Controleer de bedrading en gebruik zo nodig een groter model |
| Voeding slaat af, draad wordt heet | Klem parallel aan de voeding aangesloten (kortsluiting) | Sluit de module in serie met de belasting aan |
| Wisselende waarden op ESP32 | Geen deler, een ADC2-pin of ruwe analogRead | Gebruik een 10k/20k-deler, GPIO 34 en analogReadMilliVolts |
| Meting verandert in de buurt van een magneet | De hallsensor pikt het externe magnetische veld op | Houd de module uit de buurt van magneten, luidsprekers en draden met hoge stroom |
De ACS712 is een prima start om stroommeting te leren: met één analoge pin meet je gelijk- en wisselstroom en met een paar regels code krijg je ook vermogen en energie. Kies je het juiste model, meet je het nulpunt, middel je je metingen en kalibreer je met een multimeter, dan krijg je betrouwbare resultaten binnen een paar procent. De basis van analoog uitlezen kun je versterken met onze ADC-gids. In de BlueGrays-app vind je projecten zoals het uitlezen van een analoge sensor, een digitale voltmeter met een LCD, een netlamp schakelen met een relais en een ESP32-datalogger, elk met schakelschema's en code stap voor stap.
Veelgestelde vragen
Hoeveel ampère kan de ACS712 meten en welk model moet ik kiezen?
De ACS712 bestaat in drie modellen die ±5 A, ±20 A en ±30 A meten, met een gevoeligheid van 185, 100 en 66 mV/A. Kies het kleinste model dat de hoogste stroom die je gaat meten dekt (bij AC de piekwaarde); een kleiner model geeft bij dezelfde stroom een grotere uitgangsuitslag en een betere resolutie. Het model herken je aan de aanduiding ELC-05B, ELC-20A of ELC-30A op de chip.
Waarom geeft de ACS712 zonder stroom 2,5 V?
De uitgang begint op de helft van de voedingsspanning, zodat de ACS712 stroom in beide richtingen kan meten. Loopt de stroom de ene kant op, dan stijgt de uitgang boven 2,5 V; loopt hij de andere kant op, dan daalt hij eronder. Is de voeding niet precies 5 V, dan verschuift het nulpunt naar VCC / 2, en daarom is het meten ervan bij het opstarten de beste aanpak.
Kan de ACS712 netstroom meten?
Ja, de chip heeft een isolatiespanning van 2,4 kV RMS; bij 230 V past het 5A-model bij belastingen tot ongeveer 800 W en het 20A-model tot ongeveer 3250 W. De schroefklem en soldeerpunten van de module staan echter onder netspanning, dus bedraad hem alleen met de stekker uit het stopcontact, zet hem in een gesloten behuizing en werk niet alleen als je geen ervaring hebt. Een veiligere optie is een open stroomtransformator zoals de SCT-013, waarvoor je geen draden hoeft door te knippen.
Werkt de ACS712 met een ESP32 of op 3,3 V?
De ACS712 heeft 4,5–5,5 V nodig en geeft op 3,3 V geen correcte resultaten. Voed de module bij de ESP32 en Raspberry Pi Pico vanaf de pin 5V, VIN of VBUS en verbind de uitgang via een spanningsdeler van 10 kΩ + 20 kΩ met de analoge pin. Zo blijft zelfs een uitgang dicht bij 5 V op de pin onder 3,33 V.
Waarom leest de ACS712 zonder stroom geen nul?
Er zijn twee redenen: de code gaat ervan uit dat het nulpunt precies 2,5 V of 512 is, en de sensor heeft zijn eigen ruis. Meet het nulpunt bij het opstarten met de belasting uit, middel 100–500 metingen en voeg een kleine dode zone toe, zoals 0.05 A. Bij AC verwijdert het kwadratisch aftrekken van de ruis de spookstroom die in rust wordt getoond.
ACS712 of INA219: welke is beter?
Het hangt van de toepassing af. De INA219 werkt via I2C en geeft stroom, spanning en vermogen samen met een resolutie van ongeveer 0,8 mA tot ±3,2 A, dus hij is veel nauwkeuriger voor batterijen en kleine gelijkstroomschakelingen. De ACS712 meet tot 30 A, leest ook wisselstroom en scheidt de gemeten schakeling van de Arduino.
Projecten om hierna te bouwen
Alle projecten bekijken
Lichtsterkte meten met een LDR
Wil je zien hoe licht je kamer is, als getal? De LDR, een klein onderdeel dat op licht reageert, meet het licht om je heen en de Arduino schrijft de waarde elke halve seconde naar je computerscherm.

Lichtsterkte meten met de ESP32 en een LDR-module
Volg in de Serial Monitor in realtime de ruwe ADC-waarde van de LDR-module en het relatieve lichtpercentage, berekend uit referentiewaarden voor donker en licht. Dit percentage is geen luxmeting. Je leert hoe de module gekalibreerd wordt. Ideaal om vóór Project 10 te doen, want je gebruikt het om de drempelwaarde te bepalen.

Digitale voltmeter met lcd-scherm
Ontdek hoeveel spanning een batterij of voedingsadapter geeft met een meter die je zelf hebt gebouwd.

230V-lamp laten branden met een drukknop
Zolang je de knop vasthoudt, brandt een echte lamp op netspanning, en zodra je loslaat gaat hij uit.

ESP32 ledhelderheid regelen met een potmeter (analoog → PWM)
In dit project regel je de helderheid van een led analoog met een potmeter. De ADC-pin van de ESP32 leest de spanning van 0–3,3 V van de potmeter; die waarde wordt omgezet in een PWM-signaal (pulsbreedtemodulatie) en naar de led gestuurd. Als je aan de potmeter draait, wordt de led dus geleidelijk helderder en zwakker. Met Arduino Core 3.0+ kun je analogWrite() direct gebruiken; op de ESP32-S2/S3 ligt de ADC-resolutie vast op 12 bit.

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

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.
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

