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.
| Eigenschaft | Wert |
|---|---|
| Chip | Texas Instruments INA219 (Versionen A und B) |
| Kommunikation | I2C / SMBus, Fast Mode bis 400 kHz |
| Versorgung (VCC) | 3,0–5,5 V |
| Messbare Busspannung | 0–26 V (Registerbereich 16 V oder 32 V wählbar) |
| Shunt-Spannungsbereich | ±40, ±80, ±160 oder ±320 mV (per PGA) |
| Shunt auf dem Modul | 0,1 Ω (Aufdruck R100) |
| Maximaler Strom (mit 0,1 Ω) | Etwa ±3,2 A |
| ADC | 12 Bit, Wandlungszeit 532 µs, bis zu 128 Samples interne Mittelung |
| Genauigkeit | INA219B: max. 0,5 % Fehler über den ganzen Temperaturbereich (A-Version: 1 %) |
| I2C-Adresse | 0x40 (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-Einstellung | Shunt-Spannungsbereich | Max. Strom (0,1 Ω) | Wann? |
|---|---|---|---|
| /1 | ±40 mV | ±400 mA | Sensoren, Mikrocontroller-Boards, Schaltungen mit geringem Strom |
| /2 | ±80 mV | ±800 mA | Kurze LED-Streifen, einzelner Servomotor |
| /4 | ±160 mV | ±1,6 A | Kleine DC-Motoren, Minipumpen |
| /8 (Standard) | ±320 mV | ±3,2 A | Solarpanel, Motoren, allgemeine Nutzung |
INA219 anschließen: Arduino Uno, ESP32 und Pico
| INA219-Pin | Arduino Uno | ESP32 | Raspberry Pi Pico | Funktion |
|---|---|---|---|---|
| VCC | 5V | 3V3 | 3V3(OUT), Pin 36 | Versorgung des Chips |
| GND | GND | GND | GND | Gemeinsame Masse (muss auch mit dem Minus der Last verbunden sein) |
| SCL | A5 | GPIO 22 | GP5 (Pin 7) | I2C-Taktleitung |
| SDA | A4 | GPIO 21 | GP4 (Pin 6) | I2C-Datenleitung |
| Vin+ | Plus der Quelle | Plus der Quelle | Plus der Quelle | Eingang des Stroms |
| Vin− | Plus der Last | Plus der Last | Plus der Last | Ausgang 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.
Schritt für Schritt: erste Messung mit dem Arduino Uno
- Ö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.
- Verbinde VCC, GND, SDA und SCL des Moduls wie in der Tabelle mit dem Uno.
- 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.
- 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.
- Lade den Code hoch, öffne den Serial Monitor mit 115200 Baud und vergleiche den gelesenen Strom mit einem in Reihe geschalteten Multimeter.
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}| Funktion | Rü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 / 1000 | Spannung 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:
| Funktion | Busbereich | Shunt-Bereich | Max. Strom | Stromschritt |
|---|---|---|---|---|
| setCalibration_32V_2A() (Standard) | 32 V | ±320 mV | ≈3,2 A | 0,1 mA |
| setCalibration_32V_1A() | 32 V | ±320 mV | ≈1,3 A | 0,04 mA |
| setCalibration_16V_400mA() | 16 V | ±40 mV | ≈400 mA | 0,05 mA |
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.
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.
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?

| Eigenschaft | INA219 | ACS712 (5 A) |
|---|---|---|
| Messprinzip | Shunt-Widerstand + ADC | Hall-Effekt |
| Ausgang | Digital (I2C) | Analoge Spannung (bei null Strom VCC/2) |
| Gemessene Größen | Strom, Spannung und Leistung | Nur Strom |
| Stromart | Nur DC | AC und DC |
| Bereich | ±3,2 A (mit 0,1-Ω-Shunt), bis 26 V | ±5 A (auch 20-A- und 30-A-Versionen) |
| Auflösung | Etwa 0,1 mA | 185 mV/A; mit dem Uno-ADC etwa 26 mA Schrittweite |
| Isolation | Keine | Ja (2,1 kV RMS) |
| Versorgung | 3,0–5,5 V | 5 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
| Symptom | Mögliche Ursache | Lösung |
|---|---|---|
| Meldung „INA219 nicht gefunden“ | SDA/SCL vertauscht, VCC nicht angeschlossen oder andere Adresse | Kabel prüfen, Adresse mit einem I2C-Scanner finden (0x40–0x45) |
| Strom wird negativ angezeigt | Vin+ und Vin− vertauscht | Quelle an Vin+, Last an Vin− anschließen oder das Vorzeichen in der Software umkehren |
| Strom stimmt, Spannung 0 oder unsinnig | Minus der Last und GND des INA219 nicht gemeinsam | GND von Quelle, Last und Modul verbinden |
| Strom immer 0 | Last nicht angeschlossen, Modul parallel geschaltet oder Strom unter dem Schrittwert | Reihenschaltung prüfen; für sehr kleine Ströme einen größeren Shunt verwenden |
| Wert bleibt bei etwa 3,2 A hängen | Shunt-Spannungsbereich überschritten | Last verringern oder einen kleineren Shunt nehmen und den Strom selbst berechnen |
| Werte springen ständig | PWM-gesteuerter Motor oder LED, Kabelrauschen | Mittelwert bilden, interne Samplezahl erhöhen, Software-Filter verwenden |
| Modul wurde heiß oder ist durchgebrannt | Parallelschaltung (Kurzschluss) oder Strom über 3 A | Modul immer in Reihe schalten und in die Leitung eine Sicherung setzen |
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.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
Digitales Voltmeter mit LCD-Anzeige
Finde mit einem selbstgebauten Messgerät heraus, wie viel Spannung eine Batterie oder ein Netzteil liefert.

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.

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.

Verwendung des LCD-Bildschirms mit I2C
Gib deinem Arduino ein eigenes Display und lass es seine erste Nachricht schreiben.

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

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

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.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

