Composants · 13 min de lecture

Capteur INA219 Arduino : mesurer courant, tension et puissance

Comment brancher le capteur de courant INA219 sur Arduino, ESP32 et Pico ? Shunt 0,1 Ω, limite 26 V/3,2 A, calibration, panneau solaire, batterie et ACS712.

L'INA219 est le moyen le plus pratique de mesurer en même temps le courant, la tension et la puissance dans tes projets Arduino. Cette petite puce de Texas Instruments calcule numériquement le courant via une résistance shunt placée en série dans ton circuit, la tension côté charge et la puissance, qui est le produit des deux, puis envoie le résultat par un simple bus I2C à deux fils. Les modules courants embarquent un shunt de 0,1 Ω : le capteur mesure alors sur une ligne jusqu'à 26 V un courant allant jusqu'à environ ±3,2 A, par pas d'environ 0,1 mA.

Si tu te demandes combien de puissance produit un panneau solaire dans la journée, en combien d'heures ton projet ESP32 va vider sa batterie ou quel courant un moteur consomme en charge, c'est exactement le capteur qu'il te faut. Dans cet article, tu vas découvrir pas à pas la logique du shunt, les plages de mesure, le calcul de calibration, des codes fonctionnels pour Arduino Uno, ESP32 et Raspberry Pi Pico, et la différence avec l'ACS712.

Qu'est-ce que l'INA219 et comment fonctionne-t-il ?

Le principe de l'INA219 repose sur la loi d'Ohm. On place une résistance de précision de très faible valeur (le shunt) sur le trajet du courant ; quand le courant la traverse, une petite chute de tension proportionnelle au courant apparaît à ses bornes. Avec un shunt de 0,1 Ω, 1 A donne 100 mV et 250 mA donnent 25 mV selon V = I × R. L'amplificateur à gain programmable (PGA) et le CAN 12 bits de la puce lisent cette tension de l'ordre du millivolt et l'écrivent dans le registre de tension du shunt par pas de 10 µV. La puce mesure aussi la tension entre la borne côté charge du shunt (Vin−) et la masse (GND) avec une résolution de 4 mV : c'est la tension du bus (bus voltage). Dès que la bonne valeur est écrite dans le registre de calibration, l'INA219 calcule lui-même le courant et la puissance, sans que le microcontrôleur ait à diviser ou multiplier. Comme le shunt se place entre le plus de l'alimentation et la charge, on parle de mesure high-side : la masse de la charge n'est pas perturbée. Le courant est mesuré dans les deux sens : positif de Vin+ vers Vin−, négatif dans le sens inverse.

CaractéristiqueValeur
PuceTexas Instruments INA219 (versions A et B)
CommunicationI2C / SMBus, mode rapide 400 kHz pris en charge
Alimentation (VCC)3,0–5,5 V
Tension de ligne mesurable0–26 V (plage de registre de 16 V ou 32 V au choix)
Plage de tension du shunt±40, ±80, ±160 ou ±320 mV (choisie via le PGA)
Shunt du module0,1 Ω (marqué R100)
Courant maximal (avec 0,1 Ω)Environ ±3,2 A
CAN12 bits, conversion en 532 µs, moyenne interne jusqu'à 128 échantillons
PrécisionINA219B : erreur max 0,5 % sur toute la plage de température (1 % pour la version A)
Adresse I2C0x40 (0x41, 0x44, 0x45 avec les ponts A0/A1)

Résistance shunt et plage de mesure

Le courant maximal que l'INA219 peut mesurer dépend de la valeur du shunt et du réglage du PGA : I_max = V_shunt,max / R_shunt. Sur une plage étroite, les petites tensions sont lues avec moins d'erreur ; sur une plage large, tu peux monter à des courants plus élevés. La puissance dissipée par le shunt se calcule avec P = I² × R : à 3,2 A, un shunt de 0,1 Ω transforme environ 1 W en chaleur, et la chute de 320 mV réduit aussi la tension reçue par la charge. Pour des courants plus forts, on peut remplacer le shunt par une valeur plus faible comme 0,01 Ω, mais les pistes en cuivre fines et les borniers du module sont généralement prévus pour environ 3 A. Pour de très petits courants, un shunt de 1 Ω divise le pas par dix : 10 µV / 1 Ω = 10 µA. Avec le shunt de 0,1 Ω du module, tu as quatre choix :

Réglage PGAPlage de tension du shuntCourant max (0,1 Ω)Quand l'utiliser ?
/1±40 mV±400 mACapteurs, cartes à microcontrôleur, circuits à faible courant
/2±80 mV±800 mAPetits rubans LED, un servomoteur
/4±160 mV±1,6 APetits moteurs DC, mini pompes
/8 (par défaut)±320 mV±3,2 APanneau solaire, moteurs, usage général

Branchement de l'INA219 : Arduino Uno, ESP32 et Pico

Broche INA219Arduino UnoESP32Raspberry Pi PicoRôle
VCC5V3V33V3(OUT), broche 36Alimentation de la puce
GNDGNDGNDGNDMasse commune (à relier aussi au moins de la charge)
SCLA5GPIO 22GP5 (broche 7)Horloge I2C
SDAA4GPIO 21GP4 (broche 6)Données I2C
Vin+Plus de la sourcePlus de la sourcePlus de la sourceBorne d'entrée du courant
Vin−Plus de la chargePlus de la chargePlus de la chargeBorne de sortie du courant

Imagine le chemin du courant comme une chaîne : plus de la source, Vin+, shunt, Vin−, plus de la charge, moins de la charge et enfin moins de la source. L'INA219 s'insère dans cette chaîne en série, exactement comme un ampèremètre. Le moins de la source, le moins de la charge et la broche GND du module doivent absolument être reliés ; sinon, même si le courant semble correct, la mesure de la tension du bus n'a aucun sens (plus de détails dans l'article sur la masse commune). Sur l'Uno, tu peux aussi utiliser les broches SDA/SCL en haut de la carte à la place de A4/A5 : c'est le même bus. La plupart des modules ont déjà les résistances de pull-up I2C, donc aucune résistance supplémentaire n'est nécessaire. Sur ESP32 et Pico, si tu alimentes le module en 3V3, ces pull-up tirent aussi vers 3,3 V et tes broches restent protégées.

Ne branche jamais en parallèle l'INA219 aux deux bornes d'une pile ou d'un adaptateur, comme on le ferait avec un voltmètre. Il n'y a que 0,1 Ω entre Vin+ et Vin− : la source serait court-circuitée et le shunt et les pistes en cuivre brûleraient en quelques secondes. N'applique pas non plus plus de 26 V sur les bornes Vin et n'utilise jamais le module sur le secteur (220 V AC) : l'INA219 est une puce de mesure DC non isolée.

Pas à pas : première mesure avec l'Arduino Uno

  1. Dans l'IDE Arduino, ouvre le Gestionnaire de bibliothèques, cherche la bibliothèque Adafruit INA219 et accepte aussi la dépendance Adafruit BusIO demandée à l'installation. Si l'installation de bibliothèques ne t'est pas familière, consulte l'article ajouter une bibliothèque.
  2. Branche les broches VCC, GND, SDA et SCL du module sur l'Uno comme dans le tableau.
  3. Choisis la charge à mesurer : par exemple une LED rouge avec une résistance de 220 Ω sur une pile de 9 V, ou un petit moteur DC. Relie le plus de la pile à Vin+ et Vin− au plus de la charge.
  4. Relie le moins de la pile à la fois au moins de la charge et à la broche GND de l'INA219 ; ainsi l'Uno, la pile et la charge partagent la même masse.
  5. Téléverse le code, ouvre le Moniteur série à 115200 bauds et compare le courant lu avec celui d'un multimètre branché en série.
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}
FonctionValeur renvoyée
ina219.begin()Renvoie true si le capteur est trouvé ; démarre aussi le bus I2C
getShuntVoltage_mV()Tension aux bornes du shunt (mV)
getBusVoltage_V()Tension entre Vin− et GND, c'est-à-dire celle vue par la charge (V)
getCurrent_mA()Courant calculé selon la calibration (mA), négatif dans le sens inverse
getPower_mW()Produit du courant par la tension du bus (mW)
bus_V + shunt_mV / 1000Tension propre de la source, avant le shunt (V)

Dans l'exemple de la LED rouge avec une résistance de 220 Ω sur une pile de 9 V, le courant est d'environ (9 − 2) / 220 ≈ 32 mA ; le shunt chute d'environ 3,2 mV et la puissance totale du circuit est de 9 V × 32 mA ≈ 290 mW. Tu peux suivre en direct la tension qui descend à 8 V quand la pile fatigue, et le courant qui baisse en conséquence. Quand aucune charge n'est branchée, il est normal de voir de petites valeurs de 0,1 à 0,5 mA : elles viennent du petit offset à l'entrée de la puce et ne signifient pas que la mesure est défaillante.

Calibration : la clé d'une mesure juste

À la mise sous tension, le registre de calibration de l'INA219 vaut zéro ; tu peux donc lire tout de suite la tension du shunt et celle du bus, mais les registres de courant et de puissance restent à zéro. La valeur de calibration se trouve avec deux formules de la fiche technique : on calcule d'abord Current_LSB = courant max attendu / 32768 et on l'arrondit à un nombre pratique, puis Cal = 0,04096 / (Current_LSB × R_shunt). Le pas du registre de puissance vaut toujours 20 fois Current_LSB. Avec le shunt de 0,1 Ω du module et 3,2 A, Current_LSB = 3,2 / 32768 ≈ 97,7 µA, arrondi à 100 µA ; Cal = 0,04096 / (0,0001 × 0,1) = 4096 et le pas de puissance est de 2 mW. La bibliothèque Adafruit propose trois profils prêts à l'emploi qui font ce calcul à ta place :

FonctionPlage de lignePlage du shuntCourant maxPas de courant
setCalibration_32V_2A() (par défaut)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

Le « 32 V » du tableau n'est que la plage du registre ; la vraie limite de la puce reste 26 V. Si tu as changé le shunt, les profils prêts à l'emploi donneront des résultats faux. La solution la plus simple est de calculer le courant toi-même : courant (mA) = getShuntVoltage_mV() / R_shunt (Ω). Par exemple, avec un shunt de 1 Ω et 15 mV lus, le courant est de 15 mA. Pour un réglage fin avec une référence fiable, utilise la formule de correction de la fiche technique : Cal_nouveau = Cal × (courant affiché par le multimètre / courant affiché par l'INA219). Si le multimètre indique 500 mA et l'INA219 495 mA, tu écris 4096 × 500 / 495 ≈ 4137. Comme le registre de calibration est remis à zéro à la coupure de l'alimentation, la bibliothèque Adafruit réécrit la valeur avant chaque lecture de courant ; si tu écris ton propre code, tu dois renvoyer la calibration à chaque démarrage du capteur. Tu verras l'écriture directe dans le registre dans la partie Pico.

Mesurer la consommation d'une batterie avec l'ESP32 : compteur mAh et mWh

Pour savoir combien de temps une batterie va tenir, la consommation totale compte plus que le courant instantané. La charge totale est l'accumulation du courant dans le temps : si, à chaque mesure, tu multiplies le courant (mA) par le temps écoulé (en heures) et que tu additionnes, tu obtiens des mAh ; avec la puissance, tu obtiens des mWh. Le code ci-dessous utilise les broches I2C par défaut de l'ESP32 (SDA 21, SCL 22), choisit le profil 32V_1A pour un pas plus fin et met à jour le total toutes les demi-secondes. Comme il n'utilise aucune fonction dépendant de la version, il compile sans modification avec l'ESP32 Arduino core 2.x et 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}

Par exemple, si un nœud de capteurs consomme en moyenne 45 mA, une batterie 18650 de 2500 mAh tient théoriquement 2500 / 45 ≈ 55 heures ; en pratique, à cause des pertes de conversion et d'une batterie jamais vidée complètement, il est réaliste de compter 70 à 80 % de cette valeur. Tu peux faire ce calcul rapidement avec le calculateur d'autonomie de batterie. Fais attention lors des tests de deep sleep : avec un shunt de 0,1 Ω, le vrai pas est d'environ 0,1 mA, donc un courant de veille de l'ordre du microampère s'affiche comme zéro. La plupart des cartes de développement consomment quelques mA même en veille à cause de la puce USB-série et du régulateur, et l'INA219 les montre sans problème. Pour voir le courant de veille d'environ 10 µA d'un module ESP32 nu, il faut un shunt de 1 à 10 Ω ; le courant maximal tombe alors entre 320 mA et 32 mA, donc tu ne peux pas mesurer le courant à l'état actif avec le même réglage.

Raspberry Pi Pico et MicroPython : l'INA219 par les registres

En MicroPython, piloter l'INA219 directement par ses registres, sans aucune bibliothèque, est à la fois facile et très instructif. La valeur 0x399F écrite dans le registre de configuration (0x00) choisit la plage 32 V, le PGA /8, la résolution 12 bits et le mode de mesure continue ; c'est aussi la valeur par défaut de la puce au démarrage. On écrit ensuite 4096 dans le registre de calibration (0x05). La tension du shunt (0x01) et le courant (0x04) sont des entiers signés de 16 bits ; pour le registre de tension du bus (0x02), on lit la valeur en retirant les 3 bits de poids faible puis en multipliant par 4 mV. Si tu enregistres le code sous le nom main.py avec Thonny, le Pico commence à mesurer à chaque mise sous tension. Si tu as changé le shunt, il suffit de mettre à jour R_SHUNT et CURRENT_LSB ; Cal est calculé automatiquement. Si tu débutes en MicroPython, l'article bases de MicroPython est un bon point de départ.

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)

Mesure d'un panneau solaire et de la charge d'une batterie

Dans les projets de panneaux solaires, l'INA219 se place entre le plus du panneau et le circuit de charge ou la charge, et affiche la puissance réellement produite à cet instant. N'oublie pas que tu ne vois la puissance indiquée sur l'étiquette que sous une charge adaptée : sans charge, le courant est nul et la tension est égale à la tension en circuit ouvert (Voc). Un petit panneau de 6 V et 2 W délivre environ 330 mA en plein soleil ; par temps nuageux, cette valeur peut tomber au dixième. En enregistrant les mesures chaque minute, tu peux calculer la production d'énergie journalière en Wh, voir l'effet de l'inclinaison du panneau ou comparer un panneau fixe à un système de suivi solaire. La tension en circuit ouvert des panneaux vendus comme « 12 V » est d'environ 21–22 V ; c'est encore sans danger pour l'INA219, mais si tu mets deux panneaux en série, tu dépasses la limite de 26 V. Dans un système panneau + batterie, si tu places l'INA219 entre la batterie et le circuit, avec Vin+ côté batterie et Vin− côté circuit, tu profites de la mesure bidirectionnelle : le courant est positif quand la batterie alimente le circuit et négatif pendant la charge. Tu peux ainsi suivre le courant réellement fourni à la batterie par un module de charge comme le TP4056.

INA219 ou ACS712 ?

Module capteur de courant ACS712 à effet Hall
Capteur de courant ACS712 : il fonctionne par effet Hall, donne une sortie analogique et peut aussi mesurer le courant AC ; l'INA219, lui, mesure numériquement le courant, la tension et la puissance en DC.
CaractéristiqueINA219ACS712 (5 A)
Principe de mesureRésistance shunt + CANEffet Hall
SortieNumérique (I2C)Tension analogique (VCC/2 à courant nul)
Grandeurs mesuréesCourant, tension et puissanceCourant uniquement
Type de courantDC uniquementAC et DC
Plage±3,2 A (avec shunt 0,1 Ω), jusqu'à 26 V±5 A (versions 20 A et 30 A aussi disponibles)
RésolutionEnviron 0,1 mA185 mV/A ; environ 26 mA par pas avec le CAN de l'Uno
IsolationAucuneOui (2,1 kV RMS)
Alimentation3,0–5,5 V5 V

En résumé, pour les circuits DC de moins de quelques ampères, la mesure de piles et de panneaux solaires et les projets de microcontrôleurs à faible courant, l'INA219 est bien plus précis et pratique ; de plus, il n'occupe aucune broche analogique et jusqu'à quatre capteurs peuvent partager le même bus I2C. Surveiller le courant AC du secteur, dépasser 5 A ou vouloir une isolation électrique entre le circuit mesuré et le microcontrôleur, c'est le domaine de l'ACS712 ; pour plus de détails, consulte l'article capteur de courant ACS712. Si tu as besoin de tensions supérieures à 26 V ou d'une résolution plus élevée, choisis l'INA226 de la même famille (36 V, 16 bits) ; pour réunir trois canaux dans une seule puce, l'INA3221. Si tu veux voir la tension mesurée sur une plage plus large, la méthode du pont diviseur de l'article voltmètre Arduino est aussi un bon complément.

Idées de projets avec l'INA219

  • Wattmètre USB : fais passer la ligne 5 V d'un câble USB par l'INA219 et affiche sur un écran OLED le courant tiré par un chargeur de téléphone ou une carte Arduino.
  • Enregistreur d'énergie solaire : mesure la puissance du panneau chaque minute avec l'ESP32, enregistre-la sur une carte SD et calcule la production journalière en Wh.
  • Testeur de capacité de batterie : décharge une batterie 18650 avec une charge à résistance fixe jusqu'à 3,0 V et trouve sa vraie capacité grâce aux mAh accumulés (voir qu'est-ce que le mAh).
  • Alarme de surcharge moteur : arrête le moteur DC quand son courant double par rapport à la normale ; idéal pour détecter une roue bloquée sur un robot.
  • Protection contre le fonctionnement à sec d'une pompe : quand l'eau manque, le courant de la mini pompe chute nettement ; détecte cette baisse et coupe la pompe pour prolonger sa durée de vie.
  • Afficheur d'alimentation de laboratoire : affiche en direct la tension, le courant et la puissance de sortie d'une alimentation réglable sur un écran LCD I2C.

Erreurs fréquentes et solutions

SymptômeCause possibleSolution
Message « INA219 introuvable »SDA/SCL inversés, VCC non branché ou adresse différenteVérifie les câbles, trouve l'adresse avec un scanner I2C (0x40–0x45)
Le courant s'affiche négatifVin+ et Vin− inversésBranche la source sur Vin+ et la charge sur Vin−, ou inverse le signe dans le code
Courant correct, tension à 0 ou absurdeLe moins de la charge et le GND de l'INA219 ne sont pas communsRelie les GND de la source, de la charge et du module
Le courant reste toujours à 0Charge non branchée, module branché en parallèle ou courant inférieur au pasVérifie le montage en série ; pour de très petits courants, utilise un shunt plus grand
La valeur reste bloquée autour de 3,2 ALa plage de tension du shunt est dépasséeRéduis la charge ou utilise un shunt plus petit et calcule le courant toi-même
Les valeurs sautent sans cesseMoteur ou LED piloté en PWM, bruit sur les câblesFais une moyenne, augmente le nombre d'échantillons internes, applique un filtre logiciel
Le module a chauffé ou grilléBranchement en parallèle (court-circuit) ou courant supérieur à 3 ABranche toujours le module en série et mets un fusible sur la ligne
Avec une charge qui varie vite, comme un moteur ou une LED pilotés en PWM, une seule lecture est trompeuse, car une conversion de 532 µs peut tomber sur la phase active ou inactive de l'impulsion. Si tu actives le mode de moyenne interne de l'INA219, la puce accumule 128 échantillons sur environ 68 ms et donne un courant moyen bien plus stable : dans le code du Pico, il suffit d'écrire 0x3FFF à la place de 0x399F. Côté Arduino, il est utile de faire la moyenne de 10 à 20 lectures ou d'utiliser les méthodes de filtrage des données de capteur.

Avec un seul petit module, l'INA219 apporte à ton projet un voltmètre, un ampèremètre et un wattmètre à la fois ; du panneau solaire à l'autonomie de batterie, de la protection moteur au wattmètre USB, une mesure fiable est à la base de nombreuses idées. Dans l'application BlueGrays, tu trouveras pas à pas, avec schémas et codes, des projets comme le voltmètre numérique à écran LCD, l'ESP32 en deep sleep, l'enregistreur de température et l'arrosage intelligent, et tu pourras y ajouter l'INA219 pour mesurer leur consommation dès maintenant.

Questions fréquentes

Combien d'ampères l'INA219 peut-il mesurer au maximum ?

Avec le shunt de 0,1 Ω des modules prêts à l'emploi, l'INA219 mesure jusqu'à environ ±3,2 A, car la limite de tension du shunt de la puce est de ±320 mV. Si tu remplaces le shunt par une résistance plus faible comme 0,01 Ω, la plage théorique monte à 32 A ; mais comme les pistes en cuivre et les borniers du module ne supportent pas ce courant, tu dois déporter le shunt et utiliser des câbles épais hors de la carte.

Peut-on mesurer du courant AC avec l'INA219 ?

Non. L'INA219 est conçu pour les circuits DC et la tension à ses bornes doit rester entre 0 et 26 V ; le brancher au secteur détruit la puce et présente un danger mortel. Pour le courant AC, on utilise des capteurs à effet Hall isolés comme l'ACS712 ou des transformateurs de courant comme le SCT-013.

Comment changer l'adresse I2C de l'INA219 ?

Les ponts de soudure A0 et A1 du module déterminent l'adresse : 0x40 quand les deux sont ouverts, 0x41 avec seulement A0 fermé, 0x44 avec seulement A1 fermé et 0x45 avec les deux fermés. Dans le code, il suffit d'indiquer l'adresse avec Adafruit_INA219 ina219(0x41); Tu peux ainsi brancher quatre INA219 différents sur le même bus I2C.

Quelle est la différence entre l'INA219 et l'INA226 ?

L'INA226 est le membre plus évolué de la même famille : la tension de ligne monte jusqu'à 36 V et sa résolution est bien meilleure grâce à son CAN 16 bits. L'INA219 est moins cher et plus répandu, avec une très large prise en charge par les bibliothèques Arduino. Pour des projets de loisir sous 26 V et quelques ampères, l'INA219 est largement suffisant.

L'INA219 fonctionne-t-il en 3,3 V ?

Oui, la plage d'alimentation de l'INA219 est de 3,0 à 5,5 V. Sur ESP32 et Raspberry Pi Pico, alimenter le module par la broche 3V3 garde aussi les lignes I2C à 3,3 V. La tension d'alimentation ne limite pas la ligne mesurée : un INA219 alimenté en 3,3 V peut quand même mesurer une ligne jusqu'à 26 V.

Pourquoi l'INA219 affiche-t-il un petit courant même sans charge ?

L'entrée shunt de la puce présente un offset de quelques dizaines de microvolts ; avec un shunt de 0,1 Ω, cela correspond à une petite lecture de 0,1 à 0,5 mA. Tu peux éliminer cet écart en enregistrant la valeur lue sans charge pour la soustraire des mesures suivantes, ou en faisant la moyenne de plusieurs mesures.

Voir tous les projets
Voltmètre numérique avec écran LCD
AR-56Intermédiaire
Premium

Voltmètre numérique avec écran LCD

Découvre quelle tension fournit une pile ou un adaptateur avec un appareil de mesure fait maison.

4.5(27)
36
Mode veille profonde de l'ESP32 — Économie de batterie (OLED + compteur RAM RTC)
ES-33Avancé
Premium

Mode veille profonde de l'ESP32 — Économie de batterie (OLED + compteur RAM RTC)

Le mode Deep Sleep de l'ESP32 coupe le CPU et la plupart des périphériques et réduit la consommation à environ 10µA, un point clé pour les objets IoT sur batterie. Ce projet utilise trois sources de réveil : un minuteur (15 s), une broche externe (EXT0, le bouton sur GPIO 33) et une broche tactile (T0/GPIO 4). Les compteurs marqués RTC_DATA_ATTR sont conservés pendant le deep sleep.

4.3(10)
16
Enregistreur de Température ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avancé
Premium

Enregistreur de Température ESP32 (DHT22 + DS1307 RTC + microSD + OLED)

Construis avec l'ESP32 un enregistreur de température et d'humidité horodaté ! Un capteur DHT22 mesure la température et l'humidité une fois par minute, et chaque mesure est enregistrée sur une carte microSD au format CSV avec l'heure réelle du module RTC DS1307. L'écran OLED affiche en direct, en grands caractères, la dernière température, l'humidité, l'horodatage et le nombre d'enregistrements.

4.7(7)
12
Utilisation de l'écran LCD avec I2C
AR-32Débutant
Premium

Utilisation de l'écran LCD avec I2C

Offre un écran à ton Arduino et fais-lui écrire son premier message. L'écran LCD à deux lignes se branche avec seulement quelques fils ; un bonjour s'affiche sur la ligne du haut, puis un deuxième…

4.8(53)
70
Écran LCD I2C ESP32 (16x2)
ES-17Intermédiaire
Premium

Écran LCD I2C ESP32 (16x2)

Dans ce projet, on relie un écran LCD 16x2 caractères à l'ESP32 en I2C pour afficher du texte. Grâce à l'I2C, 2 broches de données (SDA et SCL) suffisent, au lieu des 6+ broches d'un branchement parallèle classique. Le code affiche un message fixe sur la première ligne et un compteur qui augmente chaque seconde sur la deuxième. Au démarrage, un scanner I2C écrit l'adresse de l'écran dans le Serial Monitor (souvent 0x27 ou 0x3F).

4.9(23)
40
Station d'irrigation intelligente
AR-83Avancé
Premium

Station d'irrigation intelligente

Un jardinier qui arrose tes plantes tout seul pour qu'elles ne sèchent pas pendant tes vacances.

5.0(42)
57
Éclairage Intelligent ESP32 (PIR + LDR + Relais + OLED)
ES-37Avancé
Premium

Éclairage Intelligent ESP32 (PIR + LDR + Relais + OLED)

Avec un ESP32, un capteur de mouvement PIR, un capteur de lumière LDR et un module relais, on transforme ton couloir, tes toilettes ou ton cellier en éclairage intelligent. Si la pièce est déjà claire, la lumière reste éteinte malgré le mouvement : pas de gaspillage d'énergie en journée. La lumière reste allumée 30 secondes et la durée se prolonge automatiquement tant que le mouvement continue.

4.3(6)
11