ACS712 Stromsensor: Gleich- und Wechselstrom mit Arduino messen

Der ACS712 Stromsensor ist ein kleines, günstiges Modul, das den Strom in einer Schaltung über den Hall-Effekt erfasst und in eine Spannung umwandelt, die dein Arduino lesen kann. Ohne Strom liegt sein Ausgang bei etwa 2,5 V; fließt der Strom in eine Richtung, steigt die Spannung, fließt er in die andere, sinkt sie. So misst du Gleichstrom (DC) und Wechselstrom (AC) mit einem einzigen Analogpin. Typische Anwendungen: sehen, wie viel Strom ein Motor zieht, die Entladung eines Akkus verfolgen, erkennen, ob ein Gerät läuft, oder die Leistung eines Haushaltsgeräts berechnen. Außerdem ist der gemessene Strompfad galvanisch von der Arduino-Seite getrennt.

In dieser Anleitung lernst du Schritt für Schritt, was im ACS712 steckt, wie sich die Modelle 5A, 20A und 30A unterscheiden und welches du wählen solltest, wie du das Modul in Reihe in deine Schaltung einbaust, den ersten Arduino-Sketch zur Gleichstrommessung, wie du zappelnde Werte per Mittelwertbildung beruhigst, wie du bei Wechselstrom den Effektivwert (RMS) berechnest und wie du Leistung (W) und Energie (Wh) ermittelst. Danach siehst du, wie du ihn über einen Spannungsteiler an den ESP32 und den Raspberry Pi Pico mit 3,3 V anschließt, warum du bei Netzspannung sehr vorsichtig sein musst und warum der INA219 für kleine Ströme die bessere Wahl ist.

Was ist der ACS712 Stromsensor und wie funktioniert er?

Der ACS712 ist ein Chip mit 8 Pins von Allegro. Der gemessene Strom fließt durch einen dicken Kupferpfad im Inneren, von Pin 1 und 2 zu Pin 3 und 4. Dieser Pfad hat nur 1,2 mΩ Widerstand; selbst bei 10 A fallen nur 12 mV ab und es entstehen 0,12 W Wärme, deine Schaltung wird also kaum beeinflusst. Der Strom erzeugt um diesen Leiter ein Magnetfeld, das proportional zum Strom ist. Ein Hall-Sensor direkt über dem Kupferpfad erfasst dieses Feld, und ein Verstärker im Chip macht daraus eine Spannung. Mehr zu den Grundlagen findest du in unserem Artikel über Hall-Sensoren.

Zwischen dem stromführenden Kupferpfad und der Versorgungsseite des Chips gibt es keine elektrische Verbindung; die einzige Kopplung ist das Magnetfeld. Deshalb sind Messkreis und Arduino voneinander getrennt (galvanische Trennung). Die Ausgangsspannung folgt dieser Formel: Vout = VCC / 2 + Empfindlichkeit × I. Fließt der Strom von IP+ nach IP−, steigt der Ausgang über 2,5 V, in Gegenrichtung fällt er darunter. Der ACS712 ist außerdem ratiometrisch: Nullpunkt und Empfindlichkeit ändern sich mit der Versorgungsspannung. Sinkt sie auf 4,8 V, liegt der Nullpunkt bei 2,4 V und die Empfindlichkeit des 5A-Modells fällt von 185 auf etwa 178 mV/A.

Modelle 5A, 20A und 30A: Empfindlichkeit und Auflösung

Den ACS712 gibt es in drei Versionen, die von außen völlig gleich aussehen. Welche du hast, verrät die Aufschrift auf dem Chip: ELC-05B misst ±5 A, ELC-20A ±20 A und ELC-30A ±30 A. Die Empfindlichkeit gibt an, um wie viele Millivolt sich der Ausgang pro 1 A Strom ändert. Je größer der Messbereich, desto kleiner die Empfindlichkeit, damit der Ausgang bei den Modellen 20A und 30A auch beim Maximalstrom zwischen 0,5 und 4,5 V bleibt. Die Tabelle zeigt außerdem, wie viel Milliampere ein Schritt des 10-Bit-ADC des Uno (4,88 mV) beim jeweiligen Modell entspricht.

Aus der Tabelle folgen zwei wichtige Punkte. Erstens liegt das Rauschen in Ampere bei allen drei Modellen bei etwa 0,1 A; nimmst du das 30A-Modell für eine 2-A-Last, verschenkst du zwei Drittel der Auflösung. Die Regel ist einfach: Wähle das kleinste Modell, das den höchsten zu messenden Strom (bei AC den Spitzenwert) sicher abdeckt. Für einen 12-V-Gleichstrommotor mit höchstens 2–3 A passt zum Beispiel das 5A-Modell, für einen 1500-W-Heizlüfter das 20A-Modell. Zweitens ist der ACS712 nicht für kleine Ströme gedacht: Eine LED mit wenigen Milliampere oder einen ESP32 im Tiefschlaf kannst du damit nicht messen. Dafür ist der INA219 am Ende dieser Anleitung viel besser.

ACS712 anschließen: Arduino Uno, ESP32 und Pico

Das ACS712-Modul hat zwei Seiten. Die Seite mit der Schraubklemme gehört zum Messkreis: Der Strom muss an einer Klemme hinein- und an der anderen hinausfließen, das Modul wird also wie ein Amperemeter in Reihe zur Last geschaltet. Meist trennst du die Plusleitung der Stromversorgung auf, führst das Ende vom Netzteil an die eine Seite der Klemme und das Ende zur Last an die andere. Die dreipolige Seite geht zum Arduino. Der ACS712 arbeitet nur mit 5 V; auch am ESP32 und Pico versorgst du das Modul aus einem 5-V-Pin und liest den Ausgang über einen Spannungsteiler.

Außer dem Chip sitzen nur wenige Bauteile auf dem Modul: ein Abblockkondensator an der Versorgung, ein kleiner Kondensator am FILTER-Pin, der die Bandbreite festlegt, die Power-LED (D1) und ihr Vorwiderstand (R1). Die Aufschrift 102 auf R1 bedeutet 1 kΩ; solche Codes entschlüsselst du bequem mit dem SMD-Code-Rechner. Weil der ACS712 galvanisch getrennt ist, musst du den Minuspol des Messkreises nicht mit dem GND des Arduino verbinden, wenn du nur Strom misst.

Schritt für Schritt: Gleichstrom mit dem Arduino messen

1. Verbinde VCC des Moduls mit dem 5V-Pin des Arduino, GND mit GND und OUT mit A0. Die Power-LED auf der Platine sollte leuchten.
2. Trenne die Plusleitung des zu messenden Stromkreises auf: Das Ende vom Netzteil kommt an eine Seite der Klemme, das Ende zur Last (z. B. ein 12-V-Motor oder LED-Streifen) an die andere.
3. Lass die Stromversorgung der Last ausgeschaltet und lade den Sketch unten hoch. Er misst beim Start den Nullpunkt, während kein Strom fließt.
4. Öffne den seriellen Monitor mit 9600 Baud; ohne Strom sollte der Wert bei etwa 0,00 A liegen und höchstens um einige Hundertstel Ampere schwanken.
5. Schalte die Versorgung der Last ein. Ist der Strom negativ, tausche die beiden Kabel an der Klemme oder multipliziere das Ergebnis mit −1.
6. Passe SENSITIVITY im Code an dein Modell an: 0.185 für 5A, 0.100 für 20A und 0.066 für 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}

Für jede Messung mittelt der Sketch 200 analogRead-Ergebnisse; da ein analogRead am Uno etwa 0,11 ms dauert, sind das rund 22 ms. Der Strom ergibt sich aus I = (Rohwert − Null) × (5 / 1024) / Empfindlichkeit. Beispiel: Beim 5A-Modell mit Nullpunkt 512 und einem Mittelwert von 550 beträgt der Unterschied 38 Schritte; das sind 38 × 4,88 mV = 185,5 mV, also 185,5 / 185 ≈ 1,00 A. Den Nullpunkt beim Start zu messen, statt 2,5 V anzunehmen, ist wichtig, denn der Eigen-Offset des Chips und kleine Unterschiede auf der Masseleitung verschieben ihn um einige Schritte, und dieser Fehler steckt sonst in jeder Messung.

Rauschen und Mittelwertbildung

Der Ausgang des ACS712 zappelt auch bei konstantem Strom ständig. Der erste Grund ist das Eigenrauschen des Hall-Sensors: Der Hersteller gibt die Rauschwerte oben mit 47 nF am FILTER-Pin an, also bei etwa 2 kHz Bandbreite. Die meisten Module haben dort jedoch wie die Beispielschaltung des Herstellers nur 1 nF; die Bandbreite steigt auf 80 kHz und das Rauschen ist um ein Mehrfaches höher. Der zweite Grund ist der ADC: Selbst beim 5A-Modell misst der Uno in Schritten von 26 mA, und der letzte Schritt springt immer hin und her. Zufälliges Rauschen sinkt mit der Quadratwurzel der Anzahl gemittelter Werte: 16 Messungen drücken es auf ein Viertel, 256 auf ein Sechzehntel. Weitere Filtermethoden findest du im Artikel Sensordaten filtern.

• Mittelwert aus vielen Messungen: Mittele bei Gleichstrom 100–500 Werte. Verteilst du sie auf 20 ms, hebt sich auch das 50-Hz-Brummen aus dem Netz im Mittel auf.
• Exponentieller gleitender Mittelwert: Mische jeden neuen Wert mit filter = filter + 0,1 × (neu − filter) in den alten; das braucht kaum Speicher und liefert eine ruhige Anzeige.
• Totzone: Willst du ohne Last keine Werte wie 0,03 A sehen, setze Ergebnisse mit einem Betrag unter 0,05 A auf 0.
• Hardwarefilter: Wenn du löten kannst, setze parallel zum Kondensator am FILTER-Pin 47 nF ein und senke die Bandbreite so auf etwa 2 kHz; für Gleichstrom und 50-Hz-Netzstrom reicht das völlig.
• Abstand zu Magnetfeldern: Der ACS712 ist ein Hall-Sensor; ein Magnet, Lautsprecher oder ein anderes Kabel mit hohem Strom in der Nähe verfälscht die Messung.
• Nullpunkt auffrischen: Der Nullpunkt driftet mit der Temperatur um einige Millivolt; miss ihn in lang laufenden Projekten bei ausgeschalteter Last neu.

Mittelwertbildung beseitigt Rauschen, aber keinen systematischen Fehler. Die Empfindlichkeit kann von Chip zu Chip um einige Prozent abweichen; beim 5A-Modell liegt sie zwischen 180 und 190 mV/A. Für die beste Genauigkeit schaltest du ein Multimeter im Strombereich in Reihe in dieselbe Leitung wie den ACS712, lässt einen bekannten Strom von etwa 1–2 A fließen und vergleichst beide Werte. Zeigt das Multimeter 2,00 A und der Arduino 1,94 A, ist dein Korrekturfaktor 2,00 / 1,94 = 1,031; teile SENSITIVITY im Code durch diese Zahl (0,185 / 1,031 ≈ 0,179), dann stimmt deine Messung mit dem Multimeter überein.

Wechselstrom messen: Effektivwert (RMS) berechnen

Netzstrom wechselt ständig die Richtung; in Deutschland und Europa mit 50 Hz, in den USA mit 60 Hz. Deshalb zeichnet der Ausgang des ACS712 eine Sinuskurve um 2,5 V, deren Mittelwert dem Strom null entspricht; lässt du den Gleichstrom-Sketch an einer Wechselstromlast laufen, bekommst du sinnlose Werte nahe 0 A. Bei Wechselstrom zählt der Effektivwert (RMS): Er entspricht dem Gleichstrom, der dieselbe Wärme erzeugt, und ist der Wert, den Multimeter, Sicherungen und Typenschilder verwenden. Die Rechnung folgt dem Namen Root Mean Square: Ziehe von jeder Messung den Nullpunkt ab, quadriere sie (Square), bilde den Mittelwert der Quadrate (Mean) und ziehe die Wurzel (Root).

Die Länge des Messfensters ist wichtig; enthält es keine ganze Zahl von Perioden, schwankt das Ergebnis jedes Mal etwas. Eine Periode dauert bei 50 Hz 20 ms, bei 60 Hz 16,7 ms. Ein Fenster von 100 ms enthält bei 50 Hz genau 5 und bei 60 Hz genau 6 Perioden und funktioniert daher in beiden Netzen; der Uno nimmt in dieser Zeit etwa 900 Messwerte auf. Bei einem reinen Sinus ist der Spitzenwert 1,414-mal so groß wie der Effektivwert, man könnte also auch den Spitzenwert durch √2 teilen. Lasten wie Handyladegeräte, LED-Lampen oder Dimmer ziehen aber spitze, nicht sinusförmige Ströme, und diese Abkürzung liegt dann daneben; der Sketch unten berechnet den echten Effektivwert (True RMS) und ist bei solchen Lasten viel genauer. Der Spitzenwert muss im Messbereich des Modells bleiben:

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}

Dieser Sketch speichert den Nullpunkt nicht als feste Zahl, sondern bestimmt in jedem Fenster den Mittelwert der Messungen und zieht ihn ab. Mathematisch ist das die Wurzel der Varianz: RMS² = Mittelwert der Quadrate − Quadrat des Mittelwerts. Da Wechselstrom über ganze Perioden im Mittel null ist, entspricht der gefundene Mittelwert genau dem Nullpunktfehler und wird automatisch korrigiert, auch wenn er mit der Temperatur driftet. Das beim Start ohne Last gemessene Rauschen wird quadratisch abgezogen, denn Rauschen und echter Strom sind unabhängig und Effektivwerte addieren sich über ihre Quadrate. Ohne diesen Schritt sähest du ohne angeschlossene Last Geisterwerte wie 0,1 A und 23 VA. Ein Beispiel: Ein 1000-W-Bügeleisen zieht bei 230 V etwa 4,35 A; sein Spitzenwert von 6,1 A überschreitet den Bereich des 5A-Modells, also miss es mit dem 20A-Modell.

Viel sicherer misst du den Strom eines Haushaltsgeräts mit einem aufklappbaren Stromwandler wie dem SCT-013, für den du kein Kabel auftrennen musst. Er wird wie eine Stromzange um das Kabel gelegt und hat keinerlei metallischen Kontakt zum Netz. Wichtig ist nur, dass die Zange nur den Außenleiter oder nur den Neutralleiter umschließt; legst du sie um beide, heben sich die Felder der entgegengesetzten Ströme auf und das Ergebnis ist null. Stromwandler messen nur Wechselstrom; für Gleichstrom brauchst du den ACS712 oder den INA219.

Leistung (W) und Energie (Wh) berechnen

Kennst du den Strom, ist die Leistung nur eine Multiplikation: P = U × I. Versorgt ein 12-V-Akku einen Motor mit 1,5 A, beträgt die Leistung 12 × 1,5 = 18 W; nachrechnen kannst du das mit dem Ohmsches-Gesetz-Rechner. Energie ist Leistung mal Zeit: Läuft der 18-W-Motor 2 Stunden, verbraucht er 36 Wh. Der Sketch multipliziert dazu bei jeder Messung die Leistung mit der vergangenen Zeit und summiert auf. Zur Spannungsmessung kannst du das als 0–25-V-Spannungssensor verkaufte Modul nehmen; es enthält einen Spannungsteiler aus 30 kΩ und 7,5 kΩ und teilt die Eingangsspannung durch 5. Möchtest du einen Teiler mit eigenen Widerstandswerten auslegen, nutze den Spannungsteiler-Rechner.

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}

Weil das Spannungsmodul zwischen Plus und Minus des Messkreises hängt, müssen diesmal der Minuspol des Kreises und der GND des Arduino verbunden sein; warum, erfährst du im Artikel über gemeinsame Masse. Um abzuschätzen, wie viele Stunden ein Akku hält, kombinierst du den gemessenen Durchschnittsstrom mit den Rechnungen zu mAh und Wh oder mit dem Akkulaufzeit-Rechner. Bei Wechselstrom ist es etwas anders: Urms × Irms ist die Scheinleistung in VA; die Wirkleistung (W) ist diese mal dem Leistungsfaktor. Bei ohmschen Lasten wie Wasserkocher, Bügeleisen und Glühlampe liegt der Leistungsfaktor sehr nahe bei 1, VA ≈ W ist also in Ordnung. Bei Motoren, Netzteilen und LED-Lampen kann er zwischen 0,5 und 0,9 liegen; für die echte Wirkleistung musst du gleichzeitig auch die Spannungskurve abtasten, wofür galvanisch getrennte Spannungssensor-Module wie der ZMPT101B verwendet werden.

ACS712 am ESP32: Auslesen über einen Spannungsteiler

Der ESP32 arbeitet mit 3,3 V, und seine Analogeingänge messen bis etwa 3,1 V; mehr als 3,6 V an einem Pin können das Board beschädigen. Der ACS712 läuft dagegen nur mit 5 V, und sein Ausgang erreicht bei den Modellen 20A und 30A 4,5 V, bei Überstrom fast 5 V. Deshalb versorgst du den Sensor aus dem 5V-Pin des ESP32-Boards (bei manchen Boards VIN) und führst OUT über einen Spannungsteiler. 10 kΩ + 20 kΩ ist eine gute Wahl: von OUT über 10 kΩ zum ESP32-Pin und vom selben Punkt über 20 kΩ nach GND. Das Teilerverhältnis beträgt 20 / 30 = 0,667, und die Summe von 30 kΩ erfüllt die Mindestlast des ACS712 von 4,7 kΩ locker.

Im Code stecken zwei Details. Erstens ist der ADC des ESP32 an den Rändern nicht linear; statt Rohwerten verwenden wir deshalb analogReadMilliVolts(), das die bei der Fertigung im Chip gespeicherten Kalibrierdaten nutzt. GPIO 34 gehört zu ADC1 und funktioniert auch bei aktivem WLAN; ADC2-Pins sind zusammen mit WLAN nicht nutzbar. Zweitens fehlt hier der ratiometrische Vorteil des Uno: Die ADC-Referenz des ESP32 ist fest, die Empfindlichkeit des ACS712 hängt aber von den 5 V aus dem USB ab. Die Lösung ist ein einfacher Trick: Da der Ausgang ohne Strom genau VCC / 2 beträgt, multiplizierst du den beim Start gemessenen Nullpunkt mit 2, erhältst die tatsächliche Versorgungsspannung des Sensors und korrigierst die Empfindlichkeit entsprechend. Weil derselbe Fehler im Nullpunkt und im Messsignal steckt, gleicht diese Methode auch die Toleranz der Teilerwiderstände aus. Der Sketch tastet 100 ms lang ab und liefert zwei Ergebnisse: Bei einer Gleichstromlast zählt die erste Zahl, bei einem Netzgerät die zweite.

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 am Raspberry Pi Pico mit MicroPython

Auch der Raspberry Pi Pico läuft mit 3,3 V, die Verdrahtung entspricht also der des ESP32: VCC des ACS712 an VBUS (Pin 40), der bei USB-Versorgung 5 V liefert, und OUT über denselben 10k/20k-Teiler an GP26 (ADC0, Pin 31). In MicroPython liefert read_u16() Werte von 0 bis 65535, und es gilt Spannung = Rohwert × 3,3 / 65535. Der ADC des Pico hat 12 Bit; zusammen mit dem Teiler misst er beim 5A-Modell auf dem Papier in Schritten von etwa 6,5 mA, also rund viermal feiner als der Uno. Der Code unten misst beim Start den Nullpunkt, wendet die ratiometrische Korrektur an und gibt dann jede Sekunde den Gleichstrom und den Effektivwert des Wechselstroms aus.

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 oder INA219?

Der INA219 ist ein Strom- und Spannungsmess-Chip von Texas Instruments, der über I2C kommuniziert. Statt des Hall-Effekts misst er den Spannungsabfall an einem kleinen Shunt-Widerstand (auf Modulen meist 0,1 Ω), durch den der Strom fließt. Verbreitete Module messen bis ±3,2 A mit einer Auflösung von etwa 0,8 mA, lesen die Busspannung bis 26 V selbst und berechnen die Leistung im Chip. Über eine einzige I2C-Verbindung bekommst du also Spannung, Strom und Leistung zusammen, ohne dich um ADC, Mittelwert oder Nullpunktkalibrierung zu kümmern. Dafür gibt es keine galvanische Trennung zwischen Messkreis und Arduino, Wechselstrom kann er nicht messen, und über 26 V ist Schluss.

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}

Installiere für den Code die Bibliothek Adafruit INA219 über den Bibliotheksverwalter. Verbinde SDA und SCL des Moduls am Uno mit A4 und A5; der zu messende Strom muss an VIN+ hinein- und an VIN− zur Last hinausfließen, und der GND des INA219 muss mit dem Messkreis verbunden sein. Kurz gesagt: Für Gleichstrom von wenigen Milliampere bis 3 A samt Spannung nimmst du den INA219; brauchst du größere Ströme, Wechselstrom oder galvanische Trennung, ist der ACS712 die richtige Wahl.

Projektideen mit dem ACS712

• Überstromschutz für Motoren: Blockiert ein mit dem L298N angesteuerter Gleichstrommotor, schießt der Strom hoch; stoppe den Motor und gib einen Warnton aus, sobald deine Schwelle überschritten ist.
• Akku- und Solarmonitor: Miss Lade- und Entladestrom samt Richtung, multipliziere mit der Spannung, summiere die Wh und zeige alles auf einem OLED-Display an.
• Smarte Steckdose: Schalte die Steckdose mit einem Relaismodul, prüfe mit dem ACS712, ob das Gerät wirklich läuft, und sende die Daten per MQTT an Home Assistant.
• Waschmaschine-fertig-Meldung: Bleibt der Strom einige Minuten unter einem bestimmten Wert, schickt der ESP32 eine Nachricht über Telegram.
• Trockenlaufschutz für Pumpen: Ist das Wasser alle, sinkt der Strom der Pumpe; erkenne das und schalte die Pumpe ab.
• Energielogger: Schreibe Strom und Leistung einmal pro Minute auf eine SD-Karte oder in Google Tabellen und zeichne den Tagesverbrauch auf.
• Leistungsmesser für die Werkbank: Ergänze das Projekt Arduino-Voltmeter um einen ACS712 und baue ein Messgerät, das Spannung, Strom und Leistung auf einem Display zeigt.

Häufige Fehler und Lösungen

Der ACS712 ist ein toller Einstieg in die Strommessung: Mit einem Analogpin misst du Gleich- und Wechselstrom, mit ein paar Zeilen Code auch Leistung und Energie. Wählst du das passende Modell, misst den Nullpunkt, mittelst die Werte und kalibrierst mit einem Multimeter, bekommst du verlässliche Ergebnisse auf wenige Prozent genau. Die Grundlagen der Analogmessung vertiefst du im ADC-Artikel. In der BlueGrays-App findest du Projekte wie analoges Sensorauslesen, ein digitales Voltmeter mit LCD, das Schalten einer Netzlampe per Relais und einen ESP32-Datenlogger, jeweils mit Schaltplan und Code Schritt für Schritt.