Come misurare corrente/tensione con il sensore INA219

Questa breakout board prodotta dalla Adafruit monta un sensore di corrente/tensione INA219 che risolverà tutti i vostri problemi di controllo dell’alimentazione.
Invece di lottare con due multimetri , si può semplicemente utilizzare il comodo circuito integrato INA219B prodotto dalla Texas Instruments montato su questo modulo sia per misurare sia la tensione DC sia l’assorbimento di corrente con 1 % di precisione trasmettendo i dati tramite protocollo I2C.

Sul modulo sono già presenti tutti i componenti necessari per il funzionamento dell’integrato INA219B.
E’ disponibile un’apposita libreria per l’utilizzo tramite Arduino.

Downloads:

Indice

Caratteristiche

Utilizzo del chip INA219B;
Resistore di corrente 0,1 ohm 1 % 2W;
Tensione di alimentazione del carico sino a +26 V;
Misura di corrente sino a ± 3.2A , con una risoluzione di ± 0.8mA;
Misure del PCB 23x 20 mm
Questa scheda / chip utilizza indirizzi gli indirizzi I2C 7 bit 0x40 , 0x41 , 0x44 , 0x45 , selezionabile con ponticelli)

Come funziona il sensore

L’integrato si presenta in package SOT23-8 e può essere alimentato con una tensione VS compresa tra 3 e 5V permettendo di misurare la tensione DC, con un valore massimo di +26V con 1 % di precisione trasmettendo i dati al processore tramite il protocollo I2C; è un’interfaccia digitale molto diffusa, utilizzata per la comunicazione a corto raggio tra differenti tipi di circuiti integrati, basata su un bus composto di due soli fili.

Nello schema a blocchi è possibile vedere un amplificatore di precisione che misura la tensione ai capi della resistenza shunt di rilevamento, che nella nostra scheda ha un valore di 0,1 ohm, 1 %.

Poiché la differenza massima d’ingresso dell’amplificatore è ± 320mV significa che può misurare fino a ± 3.2 Ampere.

Con un convertitore interno ADC a 12 bit, la risoluzione è di ± 0.8mA, nella gamma ±3.2°, mentre con il guadagno interno impostato al minimo, la corrente massima misurabile sarà di ±400mA con la risoluzione di 0,1 mA.

Come è fatto il modulo

Il modulo che utilizzata il sensore di corrente/tensione INA219 ha un pin head di sei pin (in modo da poter collegare facilmente questo sensore a una basetta), così come una morsettiera a vite con un passo di 3,5 mm in modo da poter collegare il carico.

Con riferimento allo schema elettrico, la parte principale del circuito è quella che ruota intorno al sensore INA219, al pin 1 e 2, VIN+ e VIN- ed è collegata la resistenza di misura dal valore di 0,1Ω 1%.

L’alimentazione che può variare da un minimo di 3 a un massimo di 5V, è fornita al pin 4 (terminale positivo) e al pin 3 (terminale negativo), dove è presente il condensatore di disaccoppiamento da 100nF.

Pin d’indirizzamento

Tramite il livello logico fornito ai pin 7 e 8 (A0 e A1), viene scelto l’indirizzo della scheda che può essere: 0x40, 0x41, 0x44 , 0x45.

Per modificarlo, occorre eventualmente, depositare una goccia di stagno sui ponticelli SJ1 o SJ2, nel caso non sia selezionato, il valore di default sarà 0x40.

I pin dell’interfaccia I2C sono rappresentati dal pin 5 (SCL – Serial Clock Line) per il clock e 6 (SDA – Serial DAta) per i dati.

Sul connettore d’uscita JP1 sono riportati:

tutti i segnali per l’interfacciamento, sono visibili i due resistori di pull-up da 10kΩ,
i pin d’alimentazione
i pin per il collegamento del sensore al circuito in prova.

Dove trovare il sensore

Il sensore di corrente/tensione INA219 può essere acquistato presso il sito Homotix, il suo costo al momento della pubblicazione di questo sito è di 3,68€.
Se al momento dell’ordine inserirete il codice sconto “ADRIROBOT” avrete diritto ad uno sconto.

Libreria per la gestione modulo

Per utilizzare il sensore di corrente/tensione INA219, occorre installare l’apposita libreria che è disponibile a questo link, oppure utilizzando l’apposita funzione presente nell’IDE che permette la gestione delle Librerie.
La versione più aggiornata è ore la 1.0.9

Funzioni di assegnazione e inizializzazione

Adafruit_INA219 (uint8_t addr = INA219_ADDRESS);

Questa funzione crea l’oggetto Adafruit_INA219 con relativo indirizzo, se questo non è specificato, è utilizzato quello di default (0x40). Se invece si utilizza più di un modulo INA219, occorrerà definire per ognuno, un proprio indirizzo tra quelli disponibili.

void begin (void);

Questa istruzione inizializza la comunicazione I2C con il dispositivo Adafruit_INA219 utilizzando i valori di configurazione predefiniti.

Funzioni di lettura del sensore:

float getBusVoltage_V (void);

Legge la tensione tra GND e V. Questa è la tensione totale vista dal circuito in esame. (Tensione di alimentazione – tensione shunt). Il valore di ritorno è in Volt.

float getShuntVoltage_mV (void);

Legge la tensione tra V e V +. Questa è la caduta di tensione misurata ai capi del resistore shunt. Il valore di ritorno è in millivolt.

float getCurrent_mA (void);

Legge l’attuale corrente ricavata tramite la legge Ohm dalla tensione shunt misurata. Il valore di ritorno è in milliampere.

Un pò di teoria

Per ricavare la tensione della batteria e la corrente assorbita dal carico, occorre far riferimento alla legge di Ohm (dal nome del fisico tedesco George Simon Alfred Ohm): è una legge fisica che mette in relazione la corrente con la tensione in un resistore. Si avrà quindi una relazione di semplice proporzionalità che può essere scritta nel seguente modo:

V = R · I

dove V è la tensione ai capi del resistore (misurata tramite un multimetro impostato come Voltmetro), I è la corrente che lo attraversa (misurata tramite un multimetro impostato come Amperometro), mentre R è il valore ohmico di resistenza.

Conoscendo la corrente I che scorre in un resistore di valore R, mediante la legge di Ohm, possiamo quindi calcolare il valore della tensione V ai capi del resistore. In modo analogo, potremmo ricavare altre incognite, per esempio conoscendo la corrente e la tensione, possiamo calcolare R:

R = V/I

Oppure conoscendo la tensione e la resistenza possiamo calcolare la corrente.

I = V/R

La potenza P si misura in watt (W) ed è il prodotto della tensione V espressa in volt (V) per la corrente I espressa in ampere (A):

P = V · I

Il collegamento

Per testare il dispositivo, si è realizzato un semplice circuito, in cui il sensore è utilizzato per la lettura della tensione di alimentazione, la corrente e la potenza assorbita da un piccolo motore elettrico.

Nell’esempio riportato nella foto, si è utilizzato un Micro Pro prodotto dalla SparkFun, (codice DEV-12640) che è una piccola scheda che monta un processore ATmega32U4, questo fornisce la connettività on-board, per cui non è necessario utilizzare un’interfaccia esterna USB.

Per mostrare i dati letti dal sensore, si è utilizzato un piccolo display monocromo 128 x 32 I2C OLED (20 x 35 mm ) prodotto anch’esso dalla Adafruit che presenta una diagonale di 1″ , ma è molto leggibile dato l’alto contrasto di un display OLED. Per ulteriori informazioni al suo riguardo vedere il link.

Il sensore e il display sono dotati di interfaccia I2C e potranno essere collegati sulla stessa rete. I due moduli hanno un diverso indirizzo che vale 0x40, per il sensore e 0x3C per il display.

Se si utilizza la scheda Arduino UNO, i pin dell’interfaccia I2C sono rappresentati dal pin A4 (SDA) e A5 (SCL) che permettono di realizzare una comunicazione nello standard I2C a due fili, in abbinamento alla libreria Wire.

Abbiamo ancora bisogno di connettere il pin RES del display ad un pin IN/OUT digitale, nel nostro caso al PIN 4, anche se potrà essere diverso, variando il valore indicato nel programma.

Le caratteristiche di alimentazione

Le caratteristiche di alimentazione, sia del modulo sensore sia del display, sono simili e possono variare tra i 3 e 5 V, permettendo di utilizzarli in una varietà di schede di controllo molto vasta.
Per questo, oltre che a schede tipo Arduino UNO, Arduino MEGA2560 e Arduino Leonardo, potranno essere collegati alla scheda Arduino DUE che lavora con logica a 3,3 V.
Utilizzando entrambi i dispositivi, il bus I2C (che usa solo due pin), sono lasciate libere molte porte digitali utilizzabili per altri scopi.

Utilizzo di altri dispositivi I2C

Sarà altresì, possibile inserire altri dispositivi dotati di bus I2C, curando solo che abbiano tutti un indirizzo diverso. Va verificato che i vari dispositivi lavorino tutti con la medesima tensione; in caso contrario, occorrerà inserire dei traslatori di livello.
Uno di questi potrebbe essere il convertitore di livello logico a 4 canali bidirezionale della Adafruit (codice 757). Sarà possibile avere moduli I2C con livelli logici (3,3-5V) diversi, presenti sulla stessa linea del bus.

Il programma di gestione

Il programma di gestione del sensore di corrente/tensione INA219 è molto semplice, il listato è sufficientemente commentato per comprenderne il funzionamento.

Download Sketch

Gestire il modulo sensore e il modulo display sarebbe piuttosto complesso, fortunatamente la stessa Adafruit ha messo a disposizione delle apposite librerie che semplificano la scrittura del programma, possono essere scaricate dal sito del produttore, in particolare sono necessarie:

Per il giusto funzionamento del display, occorrerà modificare all’interno del file Adafruit_SSD1306.h della libreria, la linea che definisce la dimensione del display per cui si dovranno cercare le linee:

#define SSD1306_128_64
//#define SSD1306_128_32

E si dovrà modificarle in:

//#define SSD1306_128_64
#define SSD1306_128_32

Dopo il caricamento delle varie librerie, l’inizializzazione del sensore e del display, il programma legge ciclicamente i dati rilevati dal sensore, mostrandoli sul display OLED.

Codice dello Sketch

//Caricamento delle librerie di comunicazione
#include <SPI.h>
#include <Wire.h>
//Caricamento delle librerie gestione display
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define OLED_RESET 4 //Definizione pin reset display
Adafruit_SSD1306 display(OLED_RESET);
//Caricamento delle librerie gestione sensore 
#include <Adafruit_INA219.h>
//Costruisce un'istanza della Adafruit_INA219
//Se non viene specificato alcun indirizzo, viene utilizzato
//quello di default (0x40). Se si collegano più modulo INA219
//occorre indicare il suo indirizzo per esempio
// Adafruit_INA219 ina219_B(0x41)
Adafruit_INA219 ina219;

void setup()   {                
  //Impostazione modulo INA219
  uint32_t currentFrequency;
  //Inizializza la comunicazione I2C con il dispositivo Adafruit_INA219
  // utilizzando i valori di configurazione predefiniti.
  ina219.begin();
  // Impostazione modulo display con indirizzo I2C addr 0x3C
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  // Cancellazione schermo e buffer
  display.clearDisplay();
  // Messaggio iniziale
  display.setTextSize(1); //Definizione della grandezza del carattere
  display.setTextColor(WHITE);  //Impostazione del colore del testo
  display.setCursor(0,0); //Posizionamento del cursore
  display.println("www.adrirobot.it");
  display.setTextColor(BLACK, WHITE); // Inverte il colore del testo
  display.println("Voltmetro digitale");
  display.display(); // Stampa sul display
  delay(2000); //Pausa per lettura dei valori
}

void loop()
{
  //Definizione variabili
  float shuntvoltage = 0;
  float busvoltage = 0;
  float current_mA = 0;
  float loadvoltage = 0;
  //Acquisizione dei valori dal sensore
  shuntvoltage = ina219.getShuntVoltage_mV();
  //Legge la tensione tra V e V +. Questa è la caduta di tensione
  //misurata ai capi del resistore shunt. Il valore è espresso in mV
  busvoltage = ina219.getBusVoltage_V();
  //Legge la tensione tra GND e V. Questa è la tensione totale vista
  //dal circuito in esame. (Tensione di alimentazione - tensione shunt). 
  //Il valore è in Volt.
  current_mA = ina219.getCurrent_mA();
  //Legge la corrente, ricavata tramite la legge di Ohm
  //dalla tensione shunt misurata. Il valore è in mA.
  loadvoltage = busvoltage + (shuntvoltage / 1000);
  //Calcola la tensione sul carico
  //Stampa dei valori misurati sul display
  display.clearDisplay(); // cancellazione dello schermo
  display.setTextSize(2); //Definizione della grandezza del testo
  display.setTextColor(WHITE); //Impostazione del colore del testo
  display.setCursor(0,0); //Posizionamento del cursore
  // Definizione dei valori con relative unità di misura
  display.print("V:"); 
  display.print(loadvoltage, 2); 
  display.println(" V");
  display.print("A:"); 
  display.print(current_mA,1); 
  display.println(" mA");
  display.display(); // Stampa dei valori sul display
  delay(2000); //Pausa per lettura dei valori
  display.clearDisplay(); // cancellazione dello schermo
  display.setCursor(0,0);  //Posizionamento del cursore
  // Mostra sul display il valore della potenza assorbita
  // ottenuta moltiplicando la corrente per la tensione sul carico
  display.println("Potenza");
  display.print((current_mA*loadvoltage)/1000);  
  display.print(" W");
  display.display(); // Stampa dei valori sul display
  delay(2000); //Pausa per lettura dei valori
}

//Caricamento delle librerie di comunicazione

#include <SPI.h>

#include <Wire.h>

//Caricamento delle librerie gestione display

#include <Adafruit_GFX.h>

#include <Adafruit_SSD1306.h>

#define OLED_RESET 4 //Definizione pin reset display

Adafruit_SSD1306 display(OLED_RESET);

//Caricamento delle librerie gestione sensore

#include <Adafruit_INA219.h>

//Costruisce un'istanza della Adafruit_INA219

//Se non viene specificato alcun indirizzo, viene utilizzato

//quello di default (0x40). Se si collegano più modulo INA219

//occorre indicare il suo indirizzo per esempio

// Adafruit_INA219 ina219_B(0x41)

Adafruit_INA219 ina219;

void setup() {

//Impostazione modulo INA219

uint32_t currentFrequency;

//Inizializza la comunicazione I2C con il dispositivo Adafruit_INA219

// utilizzando i valori di configurazione predefiniti.

ina219.begin();

// Impostazione modulo display con indirizzo I2C addr 0x3C

display.begin(SSD1306_SWITCHCAPVCC, 0x3C);

// Cancellazione schermo e buffer

display.clearDisplay();

// Messaggio iniziale

display.setTextSize(1); //Definizione della grandezza del carattere

display.setTextColor(WHITE); //Impostazione del colore del testo

display.setCursor(0,0); //Posizionamento del cursore

display.println("www.adrirobot.it");

display.setTextColor(BLACK, WHITE); // Inverte il colore del testo

display.println("Voltmetro digitale");

display.display(); // Stampa sul display

delay(2000); //Pausa per lettura dei valori

}

void loop()

{

//Definizione variabili

float shuntvoltage = 0;

float busvoltage = 0;

float current_mA = 0;

float loadvoltage = 0;

//Acquisizione dei valori dal sensore

shuntvoltage = ina219.getShuntVoltage_mV();

//Legge la tensione tra V e V +. Questa è la caduta di tensione

//misurata ai capi del resistore shunt. Il valore è espresso in mV

busvoltage = ina219.getBusVoltage_V();

//Legge la tensione tra GND e V. Questa è la tensione totale vista

//dal circuito in esame. (Tensione di alimentazione - tensione shunt).

//Il valore è in Volt.

current_mA = ina219.getCurrent_mA();

//Legge la corrente, ricavata tramite la legge di Ohm

//dalla tensione shunt misurata. Il valore è in mA.

loadvoltage = busvoltage + (shuntvoltage / 1000);

//Calcola la tensione sul carico

//Stampa dei valori misurati sul display

display.clearDisplay(); // cancellazione dello schermo

display.setTextSize(2); //Definizione della grandezza del testo

display.setTextColor(WHITE); //Impostazione del colore del testo

display.setCursor(0,0); //Posizionamento del cursore

// Definizione dei valori con relative unità di misura

display.print("V:");

display.print(loadvoltage, 2);

display.println(" V");

display.print("A:");

display.print(current_mA,1);

display.println(" mA");

display.display(); // Stampa dei valori sul display

delay(2000); //Pausa per lettura dei valori

display.clearDisplay(); // cancellazione dello schermo

display.setCursor(0,0); //Posizionamento del cursore

// Mostra sul display il valore della potenza assorbita

// ottenuta moltiplicando la corrente per la tensione sul carico

display.println("Potenza");

display.print((current_mA*loadvoltage)/1000);

display.print(" W");

display.display(); // Stampa dei valori sul display

delay(2000); //Pausa per lettura dei valori

}