INA219 Arduino: guida per misurare corrente, tensione e potenza
Come collegare il sensore INA219 ad Arduino, ESP32 e Pico? Shunt da 0,1 Ω, limite 26 V/3,2 A, calibrazione, misure su pannello solare e batteria, e ACS712.
L'INA219 è il modo più pratico per misurare corrente, tensione e potenza insieme nei progetti Arduino. Questo piccolo chip di Texas Instruments calcola in digitale la corrente attraverso una resistenza shunt posta in serie al circuito, la tensione sul lato del carico e la potenza, il loro prodotto, e invia il risultato su due soli fili I2C. I moduli più comuni hanno uno shunt da 0,1 Ω e così il sensore misura una linea fino a 26 V e circa ±3,2 A, con passi di circa 0,1 mA.
Se vuoi sapere quanta potenza produce un pannello solare durante il giorno, in quante ore un ESP32 scarica la batteria o quanta corrente assorbe un motore sotto carico, questo è il sensore che cerchi. In questo articolo vedrai passo dopo passo la logica dello shunt, i campi di misura, il calcolo della calibrazione, il codice per Arduino Uno, ESP32 e Raspberry Pi Pico e la differenza con l'ACS712.
Cos'è l'INA219 e come funziona?
L'INA219 si basa sulla legge di Ohm. Sul percorso della corrente si inserisce una resistenza di precisione di valore molto basso (shunt): quando passa corrente, ai suoi capi nasce una piccola caduta di tensione proporzionale alla corrente. Con uno shunt da 0,1 Ω, 1 A produce 100 mV e 250 mA ne producono 25 mV (V = I × R). L'amplificatore a guadagno programmabile (PGA) e l'ADC a 12 bit del chip leggono questi millivolt e li scrivono nel registro della tensione di shunt con passi da 10 µV. Il chip misura anche la tensione tra il lato carico dello shunt (Vin−) e GND con risoluzione di 4 mV: è la bus voltage. Quando scrivi il valore giusto nel registro di calibrazione, l'INA219 calcola da solo corrente e potenza, senza divisioni o moltiplicazioni sul microcontrollore. Lo shunt sta tra il positivo dell'alimentazione e il carico, per questo si parla di misura high-side: la massa del carico non viene alterata. La corrente è misurata nei due versi: da Vin+ a Vin− è positiva, nel verso opposto è negativa.
| Caratteristica | Valore |
|---|---|
| Chip | Texas Instruments INA219 (versioni A e B) |
| Comunicazione | I2C / SMBus, fast mode a 400 kHz |
| Alimentazione (VCC) | 3,0–5,5 V |
| Tensione di linea misurabile | 0–26 V (campo del registro a scelta: 16 V o 32 V) |
| Campo della tensione di shunt | ±40, ±80, ±160 o ±320 mV (scelto con il PGA) |
| Shunt sul modulo | 0,1 Ω (c'è scritto R100) |
| Corrente massima (con 0,1 Ω) | Circa ±3,2 A |
| ADC | 12 bit, conversione di 532 µs, media interna fino a 128 campioni |
| Precisione | INA219B: errore massimo 0,5% su tutto il campo di temperatura (1% per la versione A) |
| Indirizzo I2C | 0x40 (0x41, 0x44, 0x45 con i ponticelli A0/A1) |
Resistenza shunt e campo di misura
La corrente massima che l'INA219 può misurare dipende dal valore dello shunt e dall'impostazione del PGA: I_max = V_shunt,max / R_shunt. Con un campo stretto leggi piccole tensioni con meno errore, con uno ampio arrivi a correnti maggiori. La potenza dissipata dallo shunt è P = I² × R: a 3,2 A lo shunt da 0,1 Ω trasforma circa 1 W in calore e la caduta di 320 mV riduce anche la tensione che arriva al carico. Per correnti più alte puoi sostituire lo shunt con uno più piccolo, ad esempio 0,01 Ω, ma le piste di rame sottili e i morsetti del modulo sono di solito pensati per circa 3 A. Per correnti molto piccole, uno shunt da 1 Ω rende il passo dieci volte più fine: 10 µV / 1 Ω = 10 µA. Con lo shunt da 0,1 Ω del modulo hai quattro opzioni:
| Impostazione PGA | Campo tensione di shunt | Corrente massima (0,1 Ω) | Quando usarla |
|---|---|---|---|
| /1 | ±40 mV | ±400 mA | Sensori, schede a microcontrollore, circuiti a bassa corrente |
| /2 | ±80 mV | ±800 mA | Brevi strisce LED, un singolo servomotore |
| /4 | ±160 mV | ±1,6 A | Piccoli motori DC, mini pompe |
| /8 (predefinito) | ±320 mV | ±3,2 A | Pannello solare, motori, uso generale |
Collegamento dell'INA219: Arduino Uno, ESP32 e Pico
| Pin INA219 | Arduino Uno | ESP32 | Raspberry Pi Pico | Funzione |
|---|---|---|---|---|
| VCC | 5V | 3V3 | 3V3(OUT), pin 36 | Alimentazione del chip |
| GND | GND | GND | GND | Massa comune (da unire anche al negativo del carico) |
| SCL | A5 | GPIO 22 | GP5 (pin 7) | Linea clock I2C |
| SDA | A4 | GPIO 21 | GP4 (pin 6) | Linea dati I2C |
| Vin+ | Positivo dell'alimentazione | Positivo dell'alimentazione | Positivo dell'alimentazione | Ingresso della corrente |
| Vin− | Positivo del carico | Positivo del carico | Positivo del carico | Uscita della corrente |
Immagina il percorso della corrente come una catena: positivo dell'alimentazione, Vin+, shunt, Vin−, positivo del carico, negativo del carico e infine negativo dell'alimentazione. L'INA219 entra in questa catena in serie, proprio come un amperometro. Il negativo dell'alimentazione, il negativo del carico e il pin GND del modulo devono essere uniti; altrimenti, anche se la corrente sembra giusta, la misura della tensione di linea non ha senso (dettagli nell'articolo sulla massa comune). Su Uno puoi usare anche i pin SDA/SCL vicino all'angolo superiore della scheda al posto di A4/A5: sono le stesse linee. Sulla maggior parte dei moduli le resistenze di pull-up I2C sono già presenti, quindi non servono resistenze extra. Su ESP32 e Pico, alimentando il modulo a 3V3 anche i pull-up salgono a 3,3 V e i pin restano al sicuro.
Passo dopo passo: la prima misura con Arduino Uno
- Nell'IDE di Arduino apri il Gestore librerie, cerca la libreria Adafruit INA219 e accetta anche la dipendenza Adafruit BusIO richiesta durante l'installazione. Se non hai familiarità, leggi l'articolo su come aggiungere una libreria.
- Collega i pin VCC, GND, SDA e SCL del modulo a Uno come nella tabella.
- Scegli il carico da misurare: ad esempio un LED rosso con resistenza da 220 Ω alimentato da una batteria da 9 V, oppure un piccolo motore DC. Collega il positivo della batteria a Vin+ e Vin− al positivo del carico.
- Collega il negativo della batteria sia al negativo del carico sia al pin GND dell'INA219, così Uno, batteria e carico condividono la stessa massa.
- Carica il codice, apri il Serial Monitor a 115200 baud e confronta la corrente letta con quella di un multimetro collegato in serie.
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}| Funzione | Valore restituito |
|---|---|
| ina219.begin() | Restituisce true se il sensore viene trovato; avvia anche il bus I2C |
| getShuntVoltage_mV() | Tensione ai capi dello shunt (mV) |
| getBusVoltage_V() | Tensione tra Vin− e GND, cioè quella vista dal carico (V) |
| getCurrent_mA() | Corrente calcolata in base alla calibrazione (mA), negativa nel verso opposto |
| getPower_mW() | Prodotto di corrente e tensione di linea (mW) |
| bus_V + shunt_mV / 1000 | Tensione della sorgente prima dello shunt (V) |
Nell'esempio del LED rosso con resistenza da 220 Ω e batteria da 9 V la corrente è circa (9 − 2) / 220 ≈ 32 mA; sullo shunt cadono circa 3,2 mV e la potenza totale del circuito è 9 V × 32 mA ≈ 290 mW. Puoi vedere in tempo reale la tensione scendere a 8 V man mano che la batteria si scarica, con la corrente che cala di conseguenza. Se non c'è nessun carico, è normale leggere valori piccoli di 0,1–0,5 mA: dipendono dal piccolo offset all'ingresso del chip e non indicano una misura errata.
Calibrazione: la chiave per una misura corretta
All'accensione il registro di calibrazione dell'INA219 è a zero: puoi leggere subito tensione di shunt e di linea, ma i registri di corrente e potenza restano a zero. Il valore di calibrazione si ricava con due formule del datasheet: prima si calcola Current_LSB = corrente massima attesa / 32768 e lo si arrotonda a un numero comodo, poi Cal = 0,04096 / (Current_LSB × R_shunt). Il passo del registro di potenza è sempre 20 volte Current_LSB. Con lo shunt da 0,1 Ω del modulo e 3,2 A si ottiene Current_LSB = 3,2 / 32768 ≈ 97,7 µA, arrotondato a 100 µA; Cal = 0,04096 / (0,0001 × 0,1) = 4096 e il passo di potenza è 2 mW. La libreria Adafruit offre tre profili pronti che fanno il calcolo al posto tuo:
| Funzione | Campo di linea | Campo di shunt | Corrente massima | Passo di corrente |
|---|---|---|---|---|
| setCalibration_32V_2A() (predefinita) | 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 |
Il "32 V" in tabella è solo il campo del registro; il limite reale del chip resta 26 V. Se hai cambiato lo shunt, i profili pronti danno risultati sbagliati. La soluzione più semplice è calcolare la corrente da solo: corrente (mA) = getShuntVoltage_mV() / R_shunt (Ω). Ad esempio con uno shunt da 1 Ω e 15 mV letti, la corrente è 15 mA. Per una taratura fine con un riferimento affidabile usa la formula di correzione del datasheet: Cal_nuovo = Cal × (corrente del multimetro / corrente dell'INA219). Se il multimetro indica 500 mA e l'INA219 495 mA, scrivi 4096 × 500 / 495 ≈ 4137. Poiché il registro di calibrazione si azzera quando manca l'alimentazione, la libreria Adafruit riscrive il valore prima di ogni lettura di corrente; se scrivi il tuo codice, devi reinviare la calibrazione a ogni avvio del sensore. Vedrai la scrittura diretta dei registri nella sezione sul Pico.
Misurare il consumo della batteria con ESP32: contatore mAh e mWh
Per sapere quanto durerà una batteria conta più il consumo totale che la corrente istantanea. La carica totale è l'accumulo della corrente nel tempo: a ogni misura moltiplichi la corrente (mA) per il tempo trascorso (in ore) e sommi, ottenendo i mAh; la stessa operazione con la potenza dà i mWh. Il codice seguente usa i pin I2C predefiniti dell'ESP32 (SDA 21, SCL 22), sceglie il profilo 32V_1A per un passo più fine e aggiorna il totale ogni mezzo secondo. Non usa funzioni dipendenti dalla versione, quindi compila senza modifiche con ESP32 Arduino core 2.x e 3.x.
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}Ad esempio, se un nodo sensore assorbe in media 45 mA, una batteria 18650 da 2500 mAh dura in teoria 2500 / 45 ≈ 55 ore; in pratica, per le perdite di conversione e perché la batteria non si scarica del tutto, è realistico considerare il 70–80% di questo valore. Puoi fare il calcolo rapidamente con il calcolatore della durata della batteria. Nei test di deep sleep però fai attenzione: con uno shunt da 0,1 Ω il passo reale è circa 0,1 mA, quindi una corrente di sleep nell'ordine dei microampere sembra zero. La maggior parte delle schede di sviluppo assorbe qualche mA anche in sleep a causa del chip USB-seriale e del regolatore, e l'INA219 lo mostra senza problemi. Per vedere la corrente di sleep di circa 10 µA di un modulo ESP32 nudo serve invece uno shunt da 1–10 Ω; in tal caso la corrente massima scende tra 320 mA e 32 mA, quindi la corrente da sveglio non si può misurare con la stessa configurazione.
Raspberry Pi Pico e MicroPython: INA219 con i registri
Con MicroPython pilotare l'INA219 direttamente dai registri, senza librerie, è facile e molto istruttivo. Il valore 0x399F scritto nel registro di configurazione (0x00) seleziona campo 32 V, PGA /8, risoluzione a 12 bit e misura continua; è anche il valore predefinito del chip all'accensione. Poi nel registro di calibrazione (0x05) si scrive 4096. La tensione di shunt (0x01) e la corrente (0x04) sono numeri a 16 bit con segno; nel registro della tensione di linea (0x02) il valore si legge scartando i 3 bit più bassi e moltiplicando per 4 mV. Se salvi il codice con Thonny come main.py, il Pico avvia la misura a ogni accensione. Se hai cambiato lo shunt, basta aggiornare R_SHUNT e CURRENT_LSB: Cal viene calcolato automaticamente. Se sei nuovo a MicroPython, l'articolo basi di MicroPython è un buon inizio.
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)Misura di pannello solare e carica della batteria
Nei progetti con pannello solare l'INA219 si collega tra il positivo del pannello e il circuito di carica o il carico, e mostra la potenza reale che il pannello produce in quel momento. Ricorda che la potenza di targa si vede solo con un carico adatto: senza carico la corrente è zero e la tensione è quella a circuito aperto (Voc). Un piccolo pannello da 6 V 2 W dà circa 330 mA in pieno sole; con il cielo coperto il valore può scendere a un decimo. Registrando le misure ogni minuto puoi calcolare la produzione giornaliera di energia in Wh, vedere l'effetto dell'inclinazione del pannello o confrontare un pannello fisso con un sistema di inseguimento solare. I pannelli venduti come "12 V" hanno una tensione a vuoto di circa 21–22 V: per l'INA219 è ancora sicuro, ma collegando due pannelli in serie superi il limite di 26 V. Nei sistemi con pannello e batteria, se metti l'INA219 tra batteria e circuito con Vin+ verso la batteria e Vin− verso il circuito, sfrutti la misura bidirezionale: la corrente è positiva quando la batteria alimenta il circuito e negativa quando si carica. Così puoi anche vedere quanta corrente un modulo di carica come il TP4056 fornisce davvero alla batteria.
INA219 o ACS712?

| Caratteristica | INA219 | ACS712 (5 A) |
|---|---|---|
| Principio di misura | Resistenza shunt + ADC | Effetto Hall |
| Uscita | Digitale (I2C) | Tensione analogica (VCC/2 a corrente zero) |
| Cosa misura | Corrente, tensione e potenza | Solo corrente |
| Tipo di corrente | Solo DC | AC e DC |
| Campo | ±3,2 A (con shunt da 0,1 Ω), fino a 26 V | ±5 A (esistono anche versioni da 20 A e 30 A) |
| Risoluzione | Circa 0,1 mA | 185 mV/A; con l'ADC di Uno circa 26 mA a passo |
| Isolamento | No | Sì (2,1 kV RMS) |
| Alimentazione | 3,0–5,5 V | 5 V |
In breve, nei circuiti DC sotto qualche ampere, nella misura di batterie e pannelli solari e nei progetti a microcontrollore a bassa corrente l'INA219 è molto più preciso e pratico; inoltre non occupa pin analogici e sullo stesso bus I2C puoi collegarne fino a quattro. Per misurare la corrente AC di rete, superare i 5 A o avere isolamento galvanico tra circuito misurato e microcontrollore, il campo è quello dell'ACS712; per i dettagli leggi l'articolo sul sensore di corrente ACS712. Se servono tensioni oltre 26 V o una risoluzione maggiore, si sceglie l'INA226 della stessa famiglia (36 V, 16 bit), mentre per tre canali in un solo chip c'è l'INA3221. Per vedere la tensione su un campo più ampio, anche il partitore di tensione descritto nell'articolo sul voltmetro Arduino è un buon complemento.
Idee di progetto con l'INA219
- Misuratore di potenza USB: fai passare la linea a 5 V di un cavo USB attraverso l'INA219 e mostra su un display OLED quanti mA assorbe il caricatore di un telefono o una scheda Arduino.
- Registratore di energia solare: misura con un ESP32 la potenza del pannello ogni minuto, salvala su una scheda SD e calcola la produzione giornaliera in Wh.
- Tester di capacità delle batterie: scarica una 18650 con un carico a resistenza fissa fino a 3,0 V e ricava la capacità reale dai mAh accumulati (vedi cosa sono i mAh).
- Allarme di sforzo del motore: ferma il motore DC quando la corrente raddoppia rispetto al normale; ideale per capire se la ruota di un robot è bloccata.
- Protezione pompa a secco: quando finisce l'acqua la corrente della mini pompa cala nettamente; rilevando il calo e spegnendola ne allunghi la vita.
- Indicatore per alimentatore da laboratorio: mostra in tempo reale tensione, corrente e potenza di un alimentatore regolabile su un display LCD I2C.
Errori comuni e come risolverli
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| Messaggio "INA219 non trovato" | SDA/SCL invertiti, VCC non collegato o indirizzo diverso | Controlla i cavi, trova l'indirizzo con uno scanner I2C (0x40–0x45) |
| La corrente risulta negativa | Vin+ e Vin− scambiati | Collega la sorgente a Vin+ e il carico a Vin−, oppure inverti il segno nel software |
| Corrente giusta, tensione 0 o senza senso | Il negativo del carico non è in comune con il GND dell'INA219 | Unisci i GND di sorgente, carico e modulo |
| La corrente è sempre 0 | Carico non collegato, modulo in parallelo o corrente sotto il passo minimo | Controlla il collegamento in serie; per correnti minime usa uno shunt più grande |
| Il valore si blocca intorno a 3,2 A | Campo della tensione di shunt superato | Riduci il carico oppure usa uno shunt più piccolo e calcola la corrente da solo |
| I valori saltano continuamente | Motore o LED pilotato in PWM, rumore sui cavi | Fai la media, aumenta i campioni interni, applica un filtro software |
| Il modulo si è scaldato o bruciato | Collegamento in parallelo (cortocircuito) o corrente oltre 3 A | Collega sempre il modulo in serie e usa un fusibile sulla linea |
Con un solo piccolo modulo l'INA219 aggiunge al tuo progetto voltmetro, amperometro e wattmetro insieme; alla base di molte idee, dal pannello solare alla durata della batteria, dalla protezione dei motori al misuratore USB, c'è una misura corretta. Nell'app BlueGrays trovi passo dopo passo, con schemi e codice, progetti come il voltmetro digitale con LCD, l'ESP32 deep sleep, il registratore di temperatura e l'irrigazione intelligente: aggiungi l'INA219 e inizia subito a misurarne i consumi.
Domande frequenti
Quanti ampere può misurare al massimo l'INA219?
Con lo shunt da 0,1 Ω dei moduli pronti l'INA219 misura fino a circa ±3,2 A, perché il limite di tensione di shunt del chip è ±320 mV. Se sostituisci lo shunt con uno più piccolo, ad esempio 0,01 Ω, il campo teorico sale a 32 A; ma piste e morsetti del modulo non sono adatti a quella corrente, quindi devi spostare lo shunt e i cavi di sezione maggiore fuori dalla scheda.
Con l'INA219 si può misurare la corrente AC?
No. L'INA219 è pensato per circuiti DC e la tensione ai suoi capi deve restare tra 0 e 26 V; collegarlo alla tensione di rete brucia il chip ed è pericoloso per la vita. Per la corrente AC si usano sensori isolati ad effetto Hall come l'ACS712 o trasformatori di corrente come l'SCT-013.
Come si cambia l'indirizzo I2C dell'INA219?
I ponticelli di saldatura A0 e A1 sul modulo definiscono l'indirizzo: con entrambi aperti è 0x40, con solo A0 chiuso 0x41, con solo A1 chiuso 0x44, con entrambi chiusi 0x45. Nel codice basta indicare l'indirizzo con Adafruit_INA219 ina219(0x41);. In questo modo puoi collegare quattro INA219 diversi sullo stesso bus I2C.
Qual è la differenza tra INA219 e INA226?
L'INA226 è il membro più avanzato della famiglia: la tensione di linea arriva a 36 V e grazie all'ADC a 16 bit la risoluzione è molto più alta. L'INA219 costa meno, è più diffuso e ha un supporto di librerie Arduino molto ampio. Nei progetti hobbistici sotto 26 V e pochi ampere l'INA219 è più che sufficiente.
L'INA219 funziona a 3,3 V?
Sì, l'alimentazione dell'INA219 va da 3,0 a 5,5 V. Su ESP32 e Raspberry Pi Pico alimentare il modulo dal pin 3V3 mantiene anche le linee I2C a 3,3 V. La tensione di alimentazione non limita la linea misurata: un INA219 alimentato a 3,3 V può comunque misurare una linea fino a 26 V.
Perché l'INA219 mostra una piccola corrente anche senza carico?
All'ingresso di shunt del chip c'è un offset di qualche decina di microvolt; con uno shunt da 0,1 Ω significa una lettura piccola di 0,1–0,5 mA. Puoi eliminare lo scarto salvando il valore letto senza carico e sottraendolo dalle misure successive, oppure facendo la media di più misure.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Voltmetro digitale con display LCD
Scopri quanta tensione dà una pila o un alimentatore con uno strumento costruito da te.

ESP32 Deep Sleep — Risparmio della batteria (OLED + contatore in RTC RAM)
La modalità Deep Sleep dell'ESP32 spegne la CPU e quasi tutte le periferiche e riduce il consumo a circa 10µA, un aspetto cruciale per i dispositivi IoT a batteria. Il progetto usa tre sorgenti di risveglio: un timer (15 s), un pin esterno (EXT0, il pulsante su GPIO 33) e un pin touch (T0/GPIO 4). I contatori marcati con RTC_DATA_ATTR restano salvati durante il deep sleep.

Data Logger di Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
Costruisci con l'ESP32 un registratore di temperatura e umidità con orario! Un sensore DHT22 legge temperatura e umidità una volta al minuto e ogni lettura viene salvata su una scheda microSD in formato CSV con l'ora reale del modulo RTC DS1307. Il display OLED mostra in tempo reale, a caratteri grandi, l'ultima temperatura, l'umidità, l'orario e il numero totale di registrazioni.

Utilizzo dello schermo LCD con I2C
Regala al tuo Arduino uno schermo tutto suo e fagli scrivere il primo messaggio.

Schermo LCD I2C per ESP32 (16x2)
In questo progetto colleghiamo un display LCD 16x2 a caratteri all'ESP32 tramite I2C per mostrare del testo. Con l'I2C bastano 2 pin dati (SDA e SCL) invece dei 6+ pin di un collegamento parallelo classico. Il codice scrive un messaggio fisso sulla prima riga e un contatore che sale ogni secondo sulla seconda. All'avvio uno scanner I2C stampa l'indirizzo del display sul Serial Monitor (di solito 0x27 o 0x3F).

Stazione di irrigazione intelligente
Un giardiniere che annaffia le tue piante da solo, così non si seccano mentre sei in vacanza.

Illuminazione Intelligente ESP32 (PIR + LDR + Relè + OLED)
Con un ESP32, un sensore di movimento PIR, un sensore di luce LDR e un modulo relè trasformiamo il corridoio, il bagno o la dispensa di casa in un'illuminazione smart. Se l'ambiente è già luminoso, la luce non si accende nemmeno con il movimento, così di giorno non spreca energia. La luce resta accesa 30 secondi e il tempo si allunga in automatico finché il movimento continua.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

