Bauteile · 11 Min. Lesezeit

INA219 Arduino: Strom, Spannung und Leistung messen

INA219 mit Arduino, ESP32 und Pico anschließen: 0,1-Ω-Shunt, Grenzen 26 V/3,2 A, Kalibrierung, Solarpanel- und Akkumessung sowie Unterschied zum ACS712.

Der INA219 ist der praktischste Weg, in Arduino-Projekten Strom, Spannung und Leistung gleichzeitig zu messen. Dieser kleine Chip von Texas Instruments berechnet digital den Strom über einen in Reihe geschalteten Shunt-Widerstand, die Spannung auf der Lastseite und die Leistung als Produkt aus beiden. Das Ergebnis schickt er über nur zwei I2C-Leitungen. Typische Module haben einen 0,1-Ω-Shunt und messen damit auf einer Leitung mit bis zu 26 V Ströme von etwa ±3,2 A in Schritten von rund 0,1 mA.

Wenn du wissen willst, wie viel Leistung ein Solarpanel über den Tag liefert, wie viele Stunden dein ESP32-Projekt mit dem Akku durchhält oder wie viel Strom ein Motor unter Last zieht, ist das genau der richtige Sensor. In diesem Beitrag lernst du Schritt für Schritt das Shunt-Prinzip, die Messbereiche, die Kalibrierung, funktionierenden Code für Arduino Uno, ESP32 und Raspberry Pi Pico sowie den Unterschied zum ACS712 kennen.

Was ist der INA219 und wie funktioniert er?

Die Grundlage des INA219 ist das Ohmsche Gesetz. In den Strompfad wird ein sehr kleiner Präzisionswiderstand (Shunt) gesetzt; fließt Strom, fällt an ihm eine kleine, zum Strom proportionale Spannung ab. Bei 1 A über 0,1 Ω sind das nach U = I × R genau 100 mV, bei 250 mA sind es 25 mV. Der programmierbare Verstärker (PGA) und der 12-Bit-ADC im Chip lesen diese Millivolt-Spannung und legen sie in 10-µV-Schritten im Shunt-Spannungsregister ab. Außerdem misst der Chip die Spannung zwischen dem lastseitigen Ende des Shunts (Vin−) und GND mit 4 mV Auflösung; das ist die Bus-Spannung. Sobald du den richtigen Wert ins Kalibrierungsregister schreibst, berechnet der INA219 Strom und Leistung selbst, der Mikrocontroller muss weder dividieren noch multiplizieren. Weil der Shunt zwischen Pluspol der Quelle und Last liegt, spricht man von High-Side-Messung; die Masse der Last bleibt dadurch unangetastet. Der Strom wird in beide Richtungen gemessen: Von Vin+ nach Vin− ist er positiv, in Gegenrichtung negativ.

EigenschaftWert
ChipTexas Instruments INA219 (Versionen A und B)
KommunikationI2C / SMBus, Fast Mode bis 400 kHz
Versorgung (VCC)3,0–5,5 V
Messbare Busspannung0–26 V (Registerbereich 16 V oder 32 V wählbar)
Shunt-Spannungsbereich±40, ±80, ±160 oder ±320 mV (per PGA)
Shunt auf dem Modul0,1 Ω (Aufdruck R100)
Maximaler Strom (mit 0,1 Ω)Etwa ±3,2 A
ADC12 Bit, Wandlungszeit 532 µs, bis zu 128 Samples interne Mittelung
GenauigkeitINA219B: max. 0,5 % Fehler über den ganzen Temperaturbereich (A-Version: 1 %)
I2C-Adresse0x40 (mit Brücken A0/A1: 0x41, 0x44, 0x45)

Shunt-Widerstand und Messbereich

Den größten messbaren Strom bestimmen Shunt-Wert und PGA-Einstellung: I_max = U_Shunt,max / R_Shunt. Im engen Bereich werden kleine Spannungen genauer gelesen, im weiten Bereich kommst du auf größere Ströme. Die Verlustleistung des Shunts ergibt sich aus P = I² × R: Bei 3,2 A setzt ein 0,1-Ω-Shunt etwa 1 W in Wärme um, und der Spannungsabfall von 320 mV verringert die Spannung an der Last. Für größere Ströme kannst du den Shunt gegen einen kleineren Wert wie 0,01 Ω tauschen, doch die dünnen Kupferbahnen und Klemmen des Moduls sind meist für etwa 3 A ausgelegt. Bei sehr kleinen Strömen macht ein 1-Ω-Shunt die Schritte zehnmal feiner: 10 µV / 1 Ω = 10 µA. Mit dem 0,1-Ω-Shunt des Moduls hast du vier Optionen:

PGA-EinstellungShunt-SpannungsbereichMax. Strom (0,1 Ω)Wann?
/1±40 mV±400 mASensoren, Mikrocontroller-Boards, Schaltungen mit geringem Strom
/2±80 mV±800 mAKurze LED-Streifen, einzelner Servomotor
/4±160 mV±1,6 AKleine DC-Motoren, Minipumpen
/8 (Standard)±320 mV±3,2 ASolarpanel, Motoren, allgemeine Nutzung

INA219 anschließen: Arduino Uno, ESP32 und Pico

INA219-PinArduino UnoESP32Raspberry Pi PicoFunktion
VCC5V3V33V3(OUT), Pin 36Versorgung des Chips
GNDGNDGNDGNDGemeinsame Masse (muss auch mit dem Minus der Last verbunden sein)
SCLA5GPIO 22GP5 (Pin 7)I2C-Taktleitung
SDAA4GPIO 21GP4 (Pin 6)I2C-Datenleitung
Vin+Plus der QuellePlus der QuellePlus der QuelleEingang des Stroms
Vin−Plus der LastPlus der LastPlus der LastAusgang des Stroms

Stell dir den Strompfad wie eine Kette vor: Plus der Quelle, Vin+, Shunt, Vin−, Plus der Last, Minus der Last und zuletzt Minus der Quelle. Der INA219 sitzt wie ein Amperemeter in Reihe in dieser Kette. Minus der Quelle, Minus der Last und der GND-Pin des Moduls müssen unbedingt verbunden sein; sonst ist die Busspannungsmessung sinnlos, auch wenn der Strom stimmt (Details im Beitrag zur gemeinsamen Masse). Beim Uno kannst du statt A4/A5 auch die SDA/SCL-Pins an der oberen Ecke des Boards nutzen; es ist dieselbe Leitung. Bei den meisten Modulen sind I2C-Pull-up-Widerstände schon vorhanden, du brauchst also keine zusätzlichen. Versorgst du das Modul beim ESP32 und Pico mit 3V3, ziehen diese Pull-ups ebenfalls auf 3,3 V, und die Pins bleiben sicher.

Schließe den INA219 niemals wie ein Voltmeter parallel an die beiden Pole einer Batterie oder eines Netzteils an. Zwischen Vin+ und Vin− liegen nur 0,1 Ω, die Quelle wird kurzgeschlossen, und Shunt und Kupferbahnen verbrennen in Sekunden. Lege außerdem nie mehr als 26 V an die Vin-Anschlüsse und benutze das Modul niemals an der Netzspannung (230 V AC): Der INA219 ist ein nicht isolierter Gleichstrom-Messchip.

Schritt für Schritt: erste Messung mit dem Arduino Uno

  1. Öffne in der Arduino IDE den Bibliotheksverwalter, suche die Bibliothek Adafruit INA219 und akzeptiere bei der Installation auch die Abhängigkeit Adafruit BusIO. Wenn du dich mit Bibliotheken noch nicht auskennst, lies den Beitrag Bibliothek hinzufügen.
  2. Verbinde VCC, GND, SDA und SCL des Moduls wie in der Tabelle mit dem Uno.
  3. Wähle die Last, die du messen willst: zum Beispiel eine rote LED mit 220-Ω-Widerstand an einer 9-V-Batterie oder einen kleinen DC-Motor. Verbinde den Pluspol der Batterie mit Vin+ und Vin− mit dem Plus der Last.
  4. Verbinde den Minuspol der Batterie sowohl mit dem Minus der Last als auch mit dem GND-Pin des INA219, damit Uno, Batterie und Last dieselbe Masse teilen.
  5. Lade den Code hoch, öffne den Serial Monitor mit 115200 Baud und vergleiche den gelesenen Strom mit einem in Reihe geschalteten Multimeter.
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(115200);
8  if (!ina219.begin()) {                // sensörü ve I2C'yi başlat / start sensor and I2C
9    Serial.println(F("INA219 bulunamadi / INA219 not found"));
10    while (1) { delay(10); }
11  }
12  // ina219.setCalibration_32V_1A();    // daha ince adım / finer steps
13  // ina219.setCalibration_16V_400mA(); // küçük akımlar / small currents
14  Serial.println(F("INA219 hazir / ready"));
15}
16
17void loop() {
18  float shunt_mV   = ina219.getShuntVoltage_mV();  // şönt üzerindeki gerilim / voltage across the shunt
19  float bus_V      = ina219.getBusVoltage_V();     // Vin- ile GND arası / Vin- to GND
20  float current_mA = ina219.getCurrent_mA();       // akım / current
21  float power_mW   = ina219.getPower_mW();         // güç / power
22  float source_V   = bus_V + shunt_mV / 1000.0;    // kaynak gerilimi / source voltage
23
24  Serial.print(F("Kaynak: ")); Serial.print(source_V, 2);   Serial.print(F(" V  "));
25  Serial.print(F("Yuk: "));    Serial.print(bus_V, 2);      Serial.print(F(" V  "));
26  Serial.print(F("Sont: "));   Serial.print(shunt_mV, 2);   Serial.print(F(" mV  "));
27  Serial.print(F("Akim: "));   Serial.print(current_mA, 1); Serial.print(F(" mA  "));
28  Serial.print(F("Guc: "));    Serial.print(power_mW, 0);   Serial.println(F(" mW"));
29  delay(1000);
30}
FunktionRückgabewert
ina219.begin()Gibt true zurück, wenn der Sensor gefunden wird; startet auch den I2C-Bus
getShuntVoltage_mV()Spannung am Shunt (mV)
getBusVoltage_V()Spannung zwischen Vin− und GND, also die an der Last anliegende Spannung (V)
getCurrent_mA()Anhand der Kalibrierung berechneter Strom (mA), bei Gegenrichtung negativ
getPower_mW()Produkt aus Strom und Busspannung (mW)
bus_V + shunt_mV / 1000Spannung der Quelle vor dem Shunt (V)

Bei der roten LED mit 220-Ω-Widerstand an 9 V ergibt sich ein Strom von etwa (9 − 2) / 220 ≈ 32 mA; am Shunt fallen rund 3,2 mV ab, und die Gesamtleistung der Schaltung beträgt 9 V × 32 mA ≈ 290 mW. Du kannst live beobachten, wie die Spannung bei schwächer werdender Batterie auf 8 V sinkt und der Strom entsprechend abnimmt. Ohne angeschlossene Last sind kleine Werte von 0,1–0,5 mA normal; sie stammen vom kleinen Offset am Eingang des Chips und bedeuten nicht, dass die Messung defekt ist.

Kalibrierung: der Schlüssel zur genauen Messung

Beim Einschalten ist das Kalibrierungsregister des INA219 null; Shunt- und Busspannung kannst du deshalb sofort lesen, Strom- und Leistungsregister bleiben aber null. Den Kalibrierwert findest du mit zwei Formeln aus dem Datenblatt: Zuerst berechnest du Current_LSB = erwarteter Maximalstrom / 32768 und rundest auf eine handliche Zahl, dann Cal = 0,04096 / (Current_LSB × R_Shunt). Die Schrittweite des Leistungsregisters ist immer das 20-Fache von Current_LSB. Mit dem 0,1-Ω-Shunt des Moduls und 3,2 A ergibt sich Current_LSB = 3,2 / 32768 ≈ 97,7 µA, gerundet 100 µA; Cal = 0,04096 / (0,0001 × 0,1) = 4096 und die Leistungsschrittweite beträgt 2 mW. Die Adafruit-Bibliothek bietet drei fertige Profile, die diese Rechnung für dich übernehmen:

FunktionBusbereichShunt-BereichMax. StromStromschritt
setCalibration_32V_2A() (Standard)32 V±320 mV≈3,2 A0,1 mA
setCalibration_32V_1A()32 V±320 mV≈1,3 A0,04 mA
setCalibration_16V_400mA()16 V±40 mV≈400 mA0,05 mA

Die „32 V“ in der Tabelle sind nur der Registerbereich; die tatsächliche Grenze des Chips bleibt 26 V. Hast du den Shunt getauscht, liefern die fertigen Profile falsche Ergebnisse. Am einfachsten rechnest du den Strom selbst: Strom (mA) = getShuntVoltage_mV() / R_Shunt (Ω). Liest du bei einem 1-Ω-Shunt zum Beispiel 15 mV, beträgt der Strom 15 mA. Für die Feinabstimmung mit einer vertrauenswürdigen Referenz nutzt du die Korrekturformel aus dem Datenblatt: Cal_neu = Cal × (Strom laut Multimeter / Strom laut INA219). Zeigt das Multimeter 500 mA und der INA219 495 mA, schreibst du 4096 × 500 / 495 ≈ 4137. Weil das Kalibrierungsregister bei Spannungsverlust zurückgesetzt wird, schreibt die Adafruit-Bibliothek den Wert vor jeder Strommessung neu; wenn du eigenen Code schreibst, solltest du die Kalibrierung bei jedem Start des Sensors ebenfalls erneut senden. Das direkte Schreiben ins Register siehst du im Pico-Abschnitt.

Akkuverbrauch mit dem ESP32 messen: mAh- und mWh-Zähler

Um zu wissen, wie lange ein Akku hält, zählt weniger der Momentanstrom als der Gesamtverbrauch. Die Gesamtladung ist die Summe des Stroms über die Zeit: Multiplizierst du bei jeder Messung den Strom (mA) mit der vergangenen Zeit (Stunden) und addierst, erhältst du mAh; mit der Leistung erhältst du auf dieselbe Weise mWh. Der folgende Code nutzt die Standard-I2C-Pins des ESP32 (SDA 21, SCL 22), wählt für feinere Schritte das Profil 32V_1A und aktualisiert die Summe alle 500 ms. Da er keine versionsabhängige Funktion verwendet, lässt er sich mit dem ESP32 Arduino Core 2.x und 3.x ohne Änderung kompilieren.

C++ (Arduino IDE)
1#include <Wire.h>
2#include <Adafruit_INA219.h>
3
4Adafruit_INA219 ina219(0x40);
5
6float totalmAh = 0.0;              // toplam yük / total charge
7float totalmWh = 0.0;              // toplam enerji / total energy
8unsigned long lastMs = 0;
9
10void setup() {
11  Serial.begin(115200);
12  Wire.begin(21, 22);              // SDA, SCL
13  if (!ina219.begin(&Wire)) {
14    Serial.println("INA219 bulunamadi / not found");
15    while (true) { delay(10); }
16  }
17  ina219.setCalibration_32V_1A();  // 1,3 A'e kadar, 0,04 mA adım / up to 1.3 A, 0.04 mA steps
18  lastMs = millis();
19}
20
21void loop() {
22  unsigned long now = millis();
23  if (now - lastMs >= 500) {
24    float hours = (now - lastMs) / 3600000.0;   // geçen süre (saat) / elapsed time (hours)
25    lastMs = now;
26
27    float busV      = ina219.getBusVoltage_V();
28    float currentmA = ina219.getCurrent_mA();
29    float powermW   = ina219.getPower_mW();
30
31    totalmAh += currentmA * hours;   // mA x saat = mAh / mA x hours = mAh
32    totalmWh += powermW * hours;     // mW x saat = mWh / mW x hours = mWh
33
34    Serial.printf("%.2f V  %.1f mA  %.0f mW  |  %.3f mAh  %.2f mWh\n",
35                  busV, currentmA, powermW, totalmAh, totalmWh);
36  }
37}

Zieht ein Sensorknoten im Mittel zum Beispiel 45 mA, hält ein 18650-Akku mit 2500 mAh theoretisch 2500 / 45 ≈ 55 Stunden; wegen Wandlungsverlusten und der nicht vollständigen Entladung des Akkus sind in der Praxis 70–80 % davon realistisch. Diese Rechnung machst du schnell mit dem Akkulaufzeit-Rechner. Bei Tests im Deep Sleep ist Vorsicht geboten: Mit dem 0,1-Ω-Shunt beträgt die echte Schrittweite etwa 0,1 mA, sodass ein Schlafstrom im Mikroampere-Bereich wie null aussieht. Die meisten Entwicklungsboards ziehen wegen USB-Seriell-Chip und Regler selbst im Schlaf einige mA, und das zeigt der INA219 problemlos an. Um den Schlafstrom eines nackten ESP32-Moduls von rund 10 µA zu sehen, brauchst du dagegen einen Shunt von 1–10 Ω; dann sinkt der maximale Strom auf 320 mA bis 32 mA, sodass du den Strom im Wachzustand nicht mit derselben Einstellung messen kannst.

Raspberry Pi Pico und MicroPython: INA219 über Register

In MicroPython ist es einfach und sehr lehrreich, den INA219 ganz ohne Bibliothek direkt über seine Register anzusteuern. Der Wert 0x399F, den wir ins Konfigurationsregister (0x00) schreiben, wählt den 32-V-Bereich, PGA /8, 12 Bit Auflösung und kontinuierlichen Messmodus; das ist zugleich der Standardwert des Chips beim Einschalten. Danach wird 4096 ins Kalibrierungsregister (0x05) geschrieben. Shunt-Spannung (0x01) und Strom (0x04) sind vorzeichenbehaftete 16-Bit-Zahlen; beim Busspannungsregister (0x02) werden die untersten 3 Bit verworfen und der Wert mit 4 mV multipliziert. Speicherst du den Code in Thonny als main.py, beginnt der Pico bei jedem Einschalten mit der Messung. Hast du den Shunt getauscht, genügt es, R_SHUNT und CURRENT_LSB anzupassen; Cal wird automatisch berechnet. Wenn du neu bei MicroPython bist, ist der Beitrag MicroPython-Grundlagen ein guter Einstieg.

MicroPython
1from machine import Pin, I2C
2import time
3
4ADDR = 0x40                       # A0, A1 boşta / A0, A1 open
5R_SHUNT = 0.1                     # ohm, modüldeki R100 / the module's R100
6CURRENT_LSB = 0.0001              # 0,1 mA/bit
7CAL = round(0.04096 / (CURRENT_LSB * R_SHUNT))   # = 4096
8
9i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=400000)
10
11def write_reg(reg, value):
12    i2c.writeto_mem(ADDR, reg, bytes([(value >> 8) & 0xFF, value & 0xFF]))
13
14def read_reg(reg, signed=False):
15    d = i2c.readfrom_mem(ADDR, reg, 2)
16    v = (d[0] << 8) | d[1]
17    if signed and v > 32767:      # ikiye tümleyen / two's complement
18        v -= 65536
19    return v
20
21print("Bulunan / found:", [hex(a) for a in i2c.scan()])
22write_reg(0x00, 0x399F)   # 32 V, PGA /8, 12 bit, sürekli / 32 V, PGA /8, 12-bit, continuous
23write_reg(0x05, CAL)      # kalibrasyon / calibration
24
25while True:
26    shunt_mv = read_reg(0x01, True) * 0.01               # 10 uV/bit
27    bus_v = (read_reg(0x02) >> 3) * 0.004                # 4 mV/bit
28    current_ma = read_reg(0x04, True) * CURRENT_LSB * 1000
29    power_mw = read_reg(0x03) * CURRENT_LSB * 20 * 1000  # güç adımı = 20 x LSB / power step = 20 x LSB
30    print("{:.2f} V  {:.2f} mV  {:.1f} mA  {:.0f} mW".format(bus_v, shunt_mv, current_ma, power_mw))
31    time.sleep(1)

Solarpanel und Akkuladung messen

Bei Solarprojekten wird der INA219 zwischen den Pluspol des Panels und den Laderegler bzw. die Last geschaltet und zeigt die tatsächlich erzeugte Leistung. Denk daran, dass du die Nennleistung vom Etikett nur unter einer passenden Last siehst: Ohne Last ist der Strom null und die Spannung entspricht der Leerlaufspannung (Voc). Ein kleines 6-V-Panel mit 2 W liefert bei voller Sonne etwa 330 mA; bei bewölktem Himmel kann dieser Wert auf ein Zehntel fallen. Wenn du die Messwerte jede Minute speicherst, kannst du die Tagesenergie in Wh berechnen, den Einfluss des Panelwinkels sehen oder ein festes Panel mit einem Solar-Tracker vergleichen. Die Leerlaufspannung von als „12 V“ verkauften Panels liegt bei etwa 21–22 V; das ist für den INA219 noch sicher, aber schaltest du zwei Panels in Reihe, überschreitest du die 26-V-Grenze. In Systemen aus Panel und Akku nutzt du die Messung in beide Richtungen, wenn du den INA219 mit Vin+ zum Akku und Vin− zur Schaltung zwischen Akku und Schaltung setzt: Speist der Akku die Schaltung, ist der Strom positiv, beim Laden negativ. So kannst du auch beobachten, wie viel Strom ein Lademodul wie das TP4056 tatsächlich in den Akku liefert.

INA219 oder ACS712?

ACS712-Hall-Effekt-Stromsensormodul
ACS712-Stromsensor: arbeitet mit dem Hall-Effekt, liefert einen analogen Ausgang und kann auch Wechselstrom messen; der INA219 misst dagegen Gleichstrom, Spannung und Leistung digital.
EigenschaftINA219ACS712 (5 A)
MessprinzipShunt-Widerstand + ADCHall-Effekt
AusgangDigital (I2C)Analoge Spannung (bei null Strom VCC/2)
Gemessene GrößenStrom, Spannung und LeistungNur Strom
StromartNur DCAC und DC
Bereich±3,2 A (mit 0,1-Ω-Shunt), bis 26 V±5 A (auch 20-A- und 30-A-Versionen)
AuflösungEtwa 0,1 mA185 mV/A; mit dem Uno-ADC etwa 26 mA Schrittweite
IsolationKeineJa (2,1 kV RMS)
Versorgung3,0–5,5 V5 V

Kurz gesagt: Bei DC-Schaltungen unter einigen Ampere, bei Solarpanel- und Akkumessungen und bei Mikrocontroller-Projekten mit geringem Strom ist der INA219 deutlich genauer und praktischer; außerdem belegt er keinen Analogpin, und du kannst bis zu vier Sensoren am selben I2C-Bus betreiben. Wechselstrom auf der Netzseite zu überwachen, über 5 A zu gehen oder eine galvanische Trennung zwischen gemessener Schaltung und Mikrocontroller zu wollen, ist dagegen das Gebiet des ACS712; Details findest du im Beitrag ACS712-Stromsensor. Brauchst du Spannungen über 26 V oder eine höhere Auflösung, wähle den INA226 (36 V, 16 Bit) aus derselben Familie, und für drei Kanäle in einem Chip den INA3221. Willst du die gemessene Spannung in einem größeren Bereich sehen, ist auch der Spannungsteiler aus dem Beitrag Arduino-Voltmeter eine gute Ergänzung.

Projektideen mit dem INA219

  • USB-Leistungsmesser: Führe die 5-V-Leitung eines USB-Kabels durch den INA219 und zeige auf einem OLED-Display an, wie viele mA ein Handy-Ladevorgang oder ein Arduino-Board zieht.
  • Solarenergie-Logger: Miss die Leistung des Panels jede Minute mit dem ESP32, speichere sie auf einer SD-Karte und berechne die tägliche Wh-Erzeugung.
  • Akkukapazitätstester: Entlade einen 18650-Akku mit einer Last mit festem Widerstand bis 3,0 V und bestimme aus den aufsummierten mAh die echte Kapazität (siehe Was bedeutet mAh?).
  • Motor-Überlastalarm: Stoppe den DC-Motor, wenn sein Strom auf das Doppelte des Normalwerts steigt; ideal, um bei Roboterfahrzeugen ein blockiertes Rad zu erkennen.
  • Trockenlaufschutz für Pumpen: Ist das Wasser alle, sinkt der Strom der Minipumpe deutlich; erkenne diesen Abfall und schalte die Pumpe ab, um ihre Lebensdauer zu verlängern.
  • Anzeige für ein Labornetzteil: Zeige Ausgangsspannung, Strom und Leistung eines einstellbaren Netzteils live auf einem I2C-LCD an.

Häufige Fehler und ihre Lösungen

SymptomMögliche UrsacheLösung
Meldung „INA219 nicht gefunden“SDA/SCL vertauscht, VCC nicht angeschlossen oder andere AdresseKabel prüfen, Adresse mit einem I2C-Scanner finden (0x40–0x45)
Strom wird negativ angezeigtVin+ und Vin− vertauschtQuelle an Vin+, Last an Vin− anschließen oder das Vorzeichen in der Software umkehren
Strom stimmt, Spannung 0 oder unsinnigMinus der Last und GND des INA219 nicht gemeinsamGND von Quelle, Last und Modul verbinden
Strom immer 0Last nicht angeschlossen, Modul parallel geschaltet oder Strom unter dem SchrittwertReihenschaltung prüfen; für sehr kleine Ströme einen größeren Shunt verwenden
Wert bleibt bei etwa 3,2 A hängenShunt-Spannungsbereich überschrittenLast verringern oder einen kleineren Shunt nehmen und den Strom selbst berechnen
Werte springen ständigPWM-gesteuerter Motor oder LED, KabelrauschenMittelwert bilden, interne Samplezahl erhöhen, Software-Filter verwenden
Modul wurde heiß oder ist durchgebranntParallelschaltung (Kurzschluss) oder Strom über 3 AModul immer in Reihe schalten und in die Leitung eine Sicherung setzen
Bei schnell wechselnden Lasten wie einem per PWM gesteuerten Motor oder einer LED ist eine einzelne Messung irreführend, weil eine Wandlung von 532 µs genau in die Ein- oder Aus-Phase des Pulses fallen kann. Aktivierst du die interne Mittelung des INA219, sammelt der Chip 128 Samples über etwa 68 ms und liefert einen deutlich stabileren Durchschnittsstrom: Im Pico-Code schreibst du dafür statt 0x399F einfach 0x3FFF. Auf der Arduino-Seite hilft es, 10–20 Messungen zu mitteln oder die Methoden aus dem Beitrag Sensordaten filtern zu nutzen.

Mit einem einzigen kleinen Modul bekommt dein Projekt Voltmeter, Amperemeter und Wattmeter in einem; hinter vielen Ideen, vom Solarpanel über die Akkulaufzeit bis zum Motorschutz und USB-Leistungsmesser, steckt eine genaue Messung. In der BlueGrays-App findest du Projekte wie ein digitales Voltmeter mit LCD, ESP32 Deep Sleep, Temperatur-Logger und intelligente Bewässerung Schritt für Schritt mit Schaltplan und Code; mit dem INA219 kannst du bei ihnen sofort den Verbrauch messen.

Häufige Fragen

Wie viel Ampere kann der INA219 maximal messen?

Mit dem 0,1-Ω-Shunt der fertigen Module misst der INA219 bis etwa ±3,2 A, denn die Shunt-Spannungsgrenze des Chips liegt bei ±320 mV. Tauschst du den Shunt gegen einen kleineren Widerstand wie 0,01 Ω, steigt der theoretische Bereich auf 32 A; da Kupferbahnen und Klemmen des Moduls dafür nicht ausgelegt sind, musst du Shunt und dicke Kabel dann außerhalb der Platine verlegen.

Kann man mit dem INA219 Wechselstrom messen?

Nein. Der INA219 ist für Gleichstromkreise gedacht, und die Spannung an seinen Eingängen muss im Bereich 0–26 V bleiben; an Netzspannung würde er nicht nur durchbrennen, es wäre auch lebensgefährlich. Für Wechselstrom nutzt man isolierte Hall-Sensoren wie den ACS712 oder Stromwandler wie den SCT-013.

Wie ändert man die I2C-Adresse des INA219?

Die Lötbrücken A0 und A1 auf dem Modul legen die Adresse fest: Beide offen ergibt 0x40, nur A0 geschlossen 0x41, nur A1 geschlossen 0x44, beide geschlossen 0x45. Im Code gibst du die Adresse einfach mit Adafruit_INA219 ina219(0x41); an. So kannst du vier verschiedene INA219 am selben I2C-Bus betreiben.

Was ist der Unterschied zwischen INA219 und INA226?

Der INA226 ist das fortschrittlichere Mitglied derselben Familie: Die Busspannung reicht bis 36 V, und dank 16-Bit-ADC ist die Auflösung deutlich höher. Der INA219 ist günstiger und weiter verbreitet, auch die Arduino-Bibliotheksunterstützung ist sehr breit. Für Hobbyprojekte unter 26 V und mit einigen Ampere reicht der INA219 völlig aus.

Funktioniert der INA219 mit 3,3 V?

Ja, der Versorgungsbereich des INA219 beträgt 3,0–5,5 V. Beim ESP32 und Raspberry Pi Pico sorgt die Versorgung des Moduls über den 3V3-Pin dafür, dass auch die I2C-Leitungen auf 3,3 V bleiben. Die Versorgungsspannung begrenzt die gemessene Leitung nicht; ein mit 3,3 V betriebener INA219 kann trotzdem eine Leitung mit bis zu 26 V messen.

Warum zeigt der INA219 auch ohne Last einen kleinen Strom an?

Am Shunt-Eingang des Chips liegt ein Offset von einigen zehn Mikrovolt; mit dem 0,1-Ω-Shunt entspricht das einem kleinen Messwert von 0,1–0,5 mA. Du kannst diese Abweichung beseitigen, indem du den ohne Last gelesenen Wert speicherst und von späteren Messungen abziehst oder indem du mehrere Messungen mittelst.

Alle Projekte ansehen
Digitales Voltmeter mit LCD-Anzeige
AR-56Mittel
Premium

Digitales Voltmeter mit LCD-Anzeige

Finde mit einem selbstgebauten Messgerät heraus, wie viel Spannung eine Batterie oder ein Netzteil liefert.

4.5(27)
36
ESP32 Deep Sleep – Batteriesparmodus (OLED + RTC-RAM-Zähler)
ES-33Fortgeschritten
Premium

ESP32 Deep Sleep – Batteriesparmodus (OLED + RTC-RAM-Zähler)

Im Deep-Sleep-Modus schaltet der ESP32 die CPU und die meisten Peripheriegeräte ab und senkt den Strom auf etwa 10µA, entscheidend für batteriebetriebene IoT-Geräte. Das Projekt nutzt drei Weckquellen: einen Timer (15 s), einen externen Pin (EXT0, Taster an GPIO 33) und einen Touch-Pin (T0/GPIO 4). Mit RTC_DATA_ATTR markierte Zähler bleiben im Deep Sleep erhalten.

4.3(10)
16
ESP32 Temperatur-Datenlogger (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Fortgeschritten
Premium

ESP32 Temperatur-Datenlogger (DHT22 + DS1307 RTC + microSD + OLED)

Bau mit dem ESP32 einen zeitgesteuerten Temperatur- und Feuchtigkeitslogger! Ein DHT22 misst einmal pro Minute Temperatur und Luftfeuchtigkeit; jeder Wert landet mit einem Zeitstempel des RTC-Moduls DS1307 im CSV-Format auf einer microSD-Karte. Das OLED zeigt live und in großer Schrift die letzte Temperatur, die Luftfeuchtigkeit, den Zeitstempel und die Zahl der Einträge.

4.7(7)
12
Verwendung des LCD-Bildschirms mit I2C
AR-32Anfänger
Premium

Verwendung des LCD-Bildschirms mit I2C

Gib deinem Arduino ein eigenes Display und lass es seine erste Nachricht schreiben.

4.8(53)
70
ESP32 I2C-LCD-Display (16×2)
ES-17Mittel
Premium

ESP32 I2C-LCD-Display (16×2)

In diesem Projekt schließen wir ein 16x2-Zeichen-LCD über I2C an den ESP32 an und zeigen Text an. Dank I2C reichen 2 Datenpins (SDA und SCL) statt der 6+ Pins einer klassischen Parallelverbindung. Der Code schreibt eine feste Nachricht in die erste Zeile und einen sekündlich steigenden Zähler in die zweite. Beim Start gibt ein I2C-Scanner die Adresse des Displays im Serial Monitor aus (meist 0x27 oder 0x3F).

4.9(23)
40
Intelligente Bewässerungsstation
AR-83Fortgeschritten
Premium

Intelligente Bewässerungsstation

Ein Gärtner, der deine Pflanzen von selbst gießt, damit sie im Urlaub nicht vertrocknen.

5.0(42)
57
ESP32 Intelligente Beleuchtung (PIR + LDR + Relais + OLED)
ES-37Fortgeschritten
Premium

ESP32 Intelligente Beleuchtung (PIR + LDR + Relais + OLED)

Mit ESP32, PIR-Bewegungssensor, LDR-Lichtsensor und Relaismodul machen wir aus Flur, Bad oder Vorratskammer eine smarte Beleuchtung. Ist es hell, bleibt das Licht trotz Bewegung aus, so brennt es tagsüber nicht umsonst und spart Energie. Das Licht bleibt 30 Sekunden an; solange Bewegung erkannt wird, verlängert sich die Zeit automatisch.

4.3(6)
11