Componenti · 12 min di lettura

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.

CaratteristicaValore
ChipTexas Instruments INA219 (versioni A e B)
ComunicazioneI2C / SMBus, fast mode a 400 kHz
Alimentazione (VCC)3,0–5,5 V
Tensione di linea misurabile0–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 modulo0,1 Ω (c'è scritto R100)
Corrente massima (con 0,1 Ω)Circa ±3,2 A
ADC12 bit, conversione di 532 µs, media interna fino a 128 campioni
PrecisioneINA219B: errore massimo 0,5% su tutto il campo di temperatura (1% per la versione A)
Indirizzo I2C0x40 (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 PGACampo tensione di shuntCorrente massima (0,1 Ω)Quando usarla
/1±40 mV±400 mASensori, schede a microcontrollore, circuiti a bassa corrente
/2±80 mV±800 mABrevi strisce LED, un singolo servomotore
/4±160 mV±1,6 APiccoli motori DC, mini pompe
/8 (predefinito)±320 mV±3,2 APannello solare, motori, uso generale

Collegamento dell'INA219: Arduino Uno, ESP32 e Pico

Pin INA219Arduino UnoESP32Raspberry Pi PicoFunzione
VCC5V3V33V3(OUT), pin 36Alimentazione del chip
GNDGNDGNDGNDMassa comune (da unire anche al negativo del carico)
SCLA5GPIO 22GP5 (pin 7)Linea clock I2C
SDAA4GPIO 21GP4 (pin 6)Linea dati I2C
Vin+Positivo dell'alimentazionePositivo dell'alimentazionePositivo dell'alimentazioneIngresso della corrente
Vin−Positivo del caricoPositivo del caricoPositivo del caricoUscita 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.

Non collegare in parallelo l'INA219 ai capi di una batteria o di un alimentatore come faresti con un voltmetro. Tra Vin+ e Vin− ci sono solo 0,1 Ω: la sorgente va in cortocircuito e shunt e piste bruciano in pochi secondi. Inoltre non applicare ai pin Vin tensioni superiori a 26 V e non usare mai il modulo sulla rete elettrica (220 V AC): l'INA219 è un chip di misura DC non isolato.

Passo dopo passo: la prima misura con Arduino Uno

  1. 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.
  2. Collega i pin VCC, GND, SDA e SCL del modulo a Uno come nella tabella.
  3. 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.
  4. 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.
  5. Carica il codice, apri il Serial Monitor a 115200 baud e confronta la corrente letta con quella di un multimetro collegato in serie.
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}
FunzioneValore 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 / 1000Tensione 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:

FunzioneCampo di lineaCampo di shuntCorrente massimaPasso di corrente
setCalibration_32V_2A() (predefinita)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

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.

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}

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.

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)

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?

ACS712, sensore di corrente ad effetto Hall
Sensore di corrente ACS712: funziona con l'effetto Hall, ha uscita analogica e misura anche la corrente AC; l'INA219 invece misura in digitale corrente, tensione e potenza DC.
CaratteristicaINA219ACS712 (5 A)
Principio di misuraResistenza shunt + ADCEffetto Hall
UscitaDigitale (I2C)Tensione analogica (VCC/2 a corrente zero)
Cosa misuraCorrente, tensione e potenzaSolo corrente
Tipo di correnteSolo DCAC 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)
RisoluzioneCirca 0,1 mA185 mV/A; con l'ADC di Uno circa 26 mA a passo
IsolamentoNoSì (2,1 kV RMS)
Alimentazione3,0–5,5 V5 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

SintomoCausa probabileSoluzione
Messaggio "INA219 non trovato"SDA/SCL invertiti, VCC non collegato o indirizzo diversoControlla i cavi, trova l'indirizzo con uno scanner I2C (0x40–0x45)
La corrente risulta negativaVin+ e Vin− scambiatiCollega la sorgente a Vin+ e il carico a Vin−, oppure inverti il segno nel software
Corrente giusta, tensione 0 o senza sensoIl negativo del carico non è in comune con il GND dell'INA219Unisci i GND di sorgente, carico e modulo
La corrente è sempre 0Carico non collegato, modulo in parallelo o corrente sotto il passo minimoControlla il collegamento in serie; per correnti minime usa uno shunt più grande
Il valore si blocca intorno a 3,2 ACampo della tensione di shunt superatoRiduci il carico oppure usa uno shunt più piccolo e calcola la corrente da solo
I valori saltano continuamenteMotore o LED pilotato in PWM, rumore sui caviFai la media, aumenta i campioni interni, applica un filtro software
Il modulo si è scaldato o bruciatoCollegamento in parallelo (cortocircuito) o corrente oltre 3 ACollega sempre il modulo in serie e usa un fusibile sulla linea
Con carichi che cambiano velocemente, come un motore o un LED pilotati in PWM, una singola lettura inganna, perché una conversione da 532 µs può cadere nell'istante acceso o spento dell'impulso. Attivando la modalità di media interna dell'INA219 il chip raccoglie 128 campioni in circa 68 ms e dà una corrente media molto più stabile: nel codice del Pico basta scrivere 0x3FFF al posto di 0x399F. Lato Arduino aiuta fare la media di 10–20 letture oppure usare i metodi di filtraggio dei dati dei sensori.

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.

Vedi tutti i progetti
Voltmetro digitale con display LCD
AR-56Intermedio
Premium

Voltmetro digitale con display LCD

Scopri quanta tensione dà una pila o un alimentatore con uno strumento costruito da te.

4.5(27)
36
ESP32 Deep Sleep — Risparmio della batteria (OLED + contatore in RTC RAM)
ES-33Avanzato
Premium

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.

4.3(10)
16
Data Logger di Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avanzato
Premium

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.

4.7(7)
12
Utilizzo dello schermo LCD con I2C
AR-32Principiante
Premium

Utilizzo dello schermo LCD con I2C

Regala al tuo Arduino uno schermo tutto suo e fagli scrivere il primo messaggio.

4.8(53)
70
Schermo LCD I2C per ESP32 (16x2)
ES-17Intermedio
Premium

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

4.9(23)
40
Stazione di irrigazione intelligente
AR-83Avanzato
Premium

Stazione di irrigazione intelligente

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

5.0(42)
57
Illuminazione Intelligente ESP32 (PIR + LDR + Relè + OLED)
ES-37Avanzato
Premium

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.

4.3(6)
11