Componenten · 19 min leestijd

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.

ACS712-stroomsensormodule (20A-versie)
ACS712-module: de aanduiding ELC-20A op de chip laat zien dat het de versie van 20 ampère is. De groene schroefklem komt in serie met de schakeling die je meet; de pins VCC, OUT en GND gaan naar de Arduino.

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.

ParameterWaarde
Voedingsspanning4,5–5,5 V (typisch 5 V)
VoedingsstroomTypisch 10 mA, max. 13 mA
Uitgang bij nulstroomVCC × 0,5 (2,5 V bij 5 V)
Weerstand van de geleider1,2 mΩ
Bandbreedte80 kHz (lager met de condensator op de FILTER-pin)
Totale uitgangsfout±1,5% bij 25 °C
Isolatiespanning2,4 kV RMS (60 seconden)
UitgangsbelastingMinimaal 4,7 kΩ, maximaal 10 nF
Kortstondige overstroom100 A (enkele puls, 100 ms)
Bedrijfstemperatuur−40 tot 85 °C
Aansluitingen van de moduleVCC, 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)BereikGevoeligheidUitgang bij vol bereik1 ADC-stap op UnoRuis (47 nF-filter)
ACS712ELCTR-05B±5 A185 mV/A (180–190)1,58–3,43 V≈ 26 mA21 mV ≈ 0,11 A piek-tot-piek
ACS712ELCTR-20A±20 A100 mV/A (96–104)0,50–4,50 V≈ 49 mA11 mV ≈ 0,11 A piek-tot-piek
ACS712ELCTR-30A±30 A66 mV/A (63–69)0,52–4,48 V≈ 74 mA7 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-pinArduino UnoESP32Raspberry Pi Pico
VCC5V5V (VIN op sommige boards)VBUS (pin 40)
OUTA0GPIO 34 (via 10k/20k-deler)GP26 (via 10k/20k-deler)
GNDGNDGNDGND
SchroefklemIn serie met de belastingIn serie met de belastingIn serie met de belasting
Sluit de twee schroefklemmen nooit aan over de plus en min van een voeding, dus parallel zoals een voltmeter. De interne geleider is slechts 1,2 mΩ, dus dit is een regelrechte kortsluiting: de voeding perst er zoveel stroom doorheen als hij kan leveren, de batterij of adapter raakt beschadigd en de draden en de module kunnen doorbranden. De gemeten stroom moet altijd door een belasting lopen (een motor, lamp of weerstand).

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

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. Stel SENSITIVITY in de code in op je model: 0.185 voor 5A, 0.100 voor 20A en 0.066 voor 30A.
C++ (Arduino IDE)
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.

Verander bij het uitlezen van de ACS712 op een Arduino Uno de referentie niet met iets als analogReference(INTERNAL); houd de standaardreferentie van 5 V aan. Omdat de ACS712 ratiometrisch is, krimpen zowel de sensoruitgang als de ADC-referentie met dezelfde verhouding mee als de USB-spanning zakt naar 4,8 V; de ruwe waarden blijven gelijk en de 5.0 in de code blijft vanzelf kloppen. De ESP32 en Pico profiteren hier niet van, omdat hun ADC-referentie los staat van de voeding; daar passen we een kleine correctie toe op basis van het nulpunt.

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.
Digitale multimeter met meetsnoeren
Om de ACS712 te kalibreren, sluit je een multimeter op het stroombereik in serie aan in dezelfde lijn en vergelijk je de twee metingen.

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:

ModelLimiet piekstroomMax. wisselstroom (RMS, sinus)Ca. vermogen bij 230 V
5A±5 A3,5 A≈ 800 W
20A±20 A14,1 A≈ 3250 W
30A±30 A21,2 A≈ 4900 W
C++ (Arduino IDE)
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.

Netspanning kan dodelijk zijn. De scheiding in de ACS712-chip is sterk (2,4 kV RMS isolatiespanning), maar bij goedkope modules staan de schroeven van de klem en de soldeerpunten aan de onderkant van de print onder netspanning en liggen ze bloot. Maak verbindingen alleen met de stekker uit het stopcontact, zet de module in een gesloten kunststof behuizing, plaats een zekering in de lijn en raak niets aan terwijl de schakeling onder spanning staat. Netspanning meten terwijl de Arduino via USB op je computer is aangesloten, brengt ook je computer in gevaar als er iets misgaat; de resultaten tonen op een display of draadloos versturen met een ESP32 is veiliger. Heb je geen ervaring met netbedrading, doe dit experiment dan niet alleen; ben je scholier of student, werk dan altijd samen met een volwassene die verstand heeft van elektriciteit.

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.

C++ (Arduino IDE)
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-uitgangBetekenisSpanning op de ESP32-pin
0,50 V−20 A bij het 20A-model0,33 V
2,50 VNulstroom1,67 V
4,50 V+20 A bij het 20A-model3,00 V
5,00 VVerzadigd door overstroom3,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.

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

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

EigenschapACS712INA219-module
MeetmethodeHalleffect (magnetisch)Shuntweerstand (0,1 Ω)
Stroombereik±5 / ±20 / ±30 A±3,2 A (afhankelijk van de shunt)
Resolutie26–74 mA met Uno≈ 0,8 mA
WisselstroomJaNee
Spanning en vermogenNee (aparte deler nodig)Ja (tot 26 V)
ScheidingJaNee
InterfaceAnaloge uitgangI2C (adres 0x40–0x4F)
VoedingAlleen 5 V3–5,5 V
Het best voorMotoren, kachels, netapparaten, hoge stroomBatterijen, zonnepanelen, verbruik van sensoren en boards
C++ (Arduino IDE)
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

VerschijnselWaarschijnlijke oorzaakOplossing
Toont 0,1–0,3 A zonder stroomDe code gaat uit van een nulpunt van 2,5 V of 512Meet het nulpunt bij het opstarten met de belasting uit en voeg een kleine dode zone toe
Waarde blijft springenMetingen met één sample, brede bandbreedte van het 1 nF-filterMiddel 100–500 metingen; voeg zo nodig 47 nF toe aan FILTER
Stroom wordt negatief gelezenDe stroom loopt andersom door de klemVerwissel de draden of vermenigvuldig het resultaat met −1
Waarden rond 0 A bij een AC-belastingDC-code gebruikt; een sinusgolf middelt naar nulGebruik de sketch die RMS berekent
Waarden altijd een paar procent te hoog of te laagVerkeerde modelwaarde of tolerantie van de gevoeligheidKies 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 1023OUT op de verkeerde pin of verbonden met VCC, stroom buiten het bereik van het modelControleer de bedrading en gebruik zo nodig een groter model
Voeding slaat af, draad wordt heetKlem parallel aan de voeding aangesloten (kortsluiting)Sluit de module in serie met de belasting aan
Wisselende waarden op ESP32Geen deler, een ADC2-pin of ruwe analogReadGebruik een 10k/20k-deler, GPIO 34 en analogReadMilliVolts
Meting verandert in de buurt van een magneetDe hallsensor pikt het externe magnetische veld opHoud de module uit de buurt van magneten, luidsprekers en draden met hoge stroom
De eenvoudigste manier om te controleren of je stroomsensor werkt is een bekende belasting gebruiken. Een weerstand van 10 Ω op 12 V trekt volgens de wet van Ohm bijvoorbeeld 1,2 A en zet 14,4 W om in warmte, dus kies een vermogensweerstand van minstens 20–25 W. Meet je dicht bij 1,2 A, dan kloppen je bedrading en code.

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.

Alle projecten bekijken
Lichtsterkte meten met een LDR
AR-11Beginner

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.

4.6(83)
143
Lichtsterkte meten met de ESP32 en een LDR-module
ES-11Beginner

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.

4.6(36)
55
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
230V-lamp laten branden met een drukknop
AR-19Gevorderd
Premium

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.

4.4(30)
38
ESP32 ledhelderheid regelen met een potmeter (analoog → PWM)
ES-13Gemiddeld
Premium

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.

4.5(19)
32
Een lcd-scherm gebruiken met I2C
AR-32Beginner
Premium

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…

4.8(53)
70
ESP32 I2C-LCD-display (16x2)
ES-17Gemiddeld
Premium

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

4.9(23)
40
ESP32-temperatuurlogger (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Gevorderd
Premium

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

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

4.7(7)
12