Componentes · 13 min de lectura

INA219 con Arduino: medir corriente, voltaje y potencia

Sensor de corriente INA219 con Arduino, ESP32 y Pico: shunt de 0,1 Ω, límite de 26 V/3,2 A, calibración, medición de panel solar y batería, y diferencia con ACS712.

El INA219 es la forma más práctica de medir corriente, voltaje y potencia a la vez en proyectos con Arduino. Este pequeño chip de Texas Instruments calcula digitalmente la corriente a través de una resistencia shunt conectada en serie con tu circuito, el voltaje del lado de la carga y la potencia, que es el producto de ambos, y envía el resultado por un bus I2C de solo dos cables. Los módulos habituales llevan un shunt de 0,1 Ω, y con él el sensor puede medir en una línea de hasta 26 V corrientes de unos ±3,2 A en pasos de aproximadamente 0,1 mA.

Si quieres saber cuánta potencia produce un panel solar a lo largo del día, en cuántas horas un ESP32 agotará la batería de tu proyecto o cuánta corriente consume un motor bajo carga, este es el sensor que buscas. En este artículo aprenderás paso a paso la lógica de la resistencia shunt, los rangos de medición, el cálculo de calibración, código funcional para Arduino Uno, ESP32 y Raspberry Pi Pico, y la diferencia con el ACS712.

¿Qué es el INA219 y cómo funciona?

La base del INA219 es la ley de Ohm. En el camino de la corriente se coloca una resistencia de precisión de valor muy pequeño (shunt); al pasar corriente, entre sus extremos aparece una pequeña caída de tensión proporcional a ella. Con un shunt de 0,1 Ω, si pasa 1 A caen 100 mV según V = I × R, y si pasan 250 mA caen 25 mV. La etapa de ganancia programable (PGA) y el ADC de 12 bits del chip leen esa tensión de milivoltios y la guardan en el registro de tensión del shunt en pasos de 10 µV. Además, el chip mide la tensión entre el extremo del shunt del lado de la carga (Vin−) y GND con una resolución de 4 mV; es el bus voltage, o voltaje de línea. Cuando escribes el valor correcto en el registro de calibración, el INA219 calcula internamente la corriente y la potencia, y el microcontrolador no tiene que dividir ni multiplicar. Como el shunt se coloca entre el positivo de la fuente y la carga, se llama medición high-side; así la masa de la carga no se altera. La corriente se mide en ambos sentidos: la que fluye de Vin+ a Vin− aparece como positiva y la del sentido contrario, como negativa.

CaracterísticaValor
ChipTexas Instruments INA219 (versiones A y B)
ComunicaciónI2C / SMBus, compatible con modo rápido de 400 kHz
Alimentación (VCC)3,0–5,5 V
Voltaje de línea medible0–26 V (el rango del registro se elige entre 16 V o 32 V)
Rango de tensión del shunt±40, ±80, ±160 o ±320 mV (se elige con la PGA)
Shunt del módulo0,1 Ω (lleva impreso R100)
Corriente máxima (con 0,1 Ω)Aprox. ±3,2 A
ADC12 bits, tiempo de conversión de 532 µs, promedio interno de hasta 128 muestras
PrecisiónINA219B: error máximo del 0,5 % en todo el rango de temperatura (1 % en la versión A)
Dirección I2C0x40 (0x41, 0x44, 0x45 con los puentes A0/A1)

Resistencia shunt y rango de medición

La corriente máxima que puede medir el INA219 depende del valor del shunt y del ajuste de la PGA: I_max = V_shunt,max / R_shunt. En un rango estrecho las tensiones pequeñas se leen con menos error, y en un rango amplio puedes llegar a corrientes mayores. La potencia que disipa el shunt se calcula con P = I² × R: a 3,2 A un shunt de 0,1 Ω convierte en calor cerca de 1 W, y la caída de 320 mV también reduce la tensión que recibe la carga. Para corrientes mayores se puede cambiar el shunt por uno menor, como 0,01 Ω, pero las pistas de cobre y los bornes del módulo suelen estar diseñados para unos 3 A. Con corrientes muy pequeñas, un shunt de 1 Ω divide el paso por diez: 10 µV / 1 Ω = 10 µA. Con el shunt de 0,1 Ω del módulo, las cuatro opciones son estas:

Ajuste de PGARango de tensión del shuntCorriente máxima (0,1 Ω)¿Cuándo usarlo?
/1±40 mV±400 mASensores, placas de microcontrolador, circuitos de baja corriente
/2±80 mV±800 mATiras LED cortas, un solo servomotor
/4±160 mV±1,6 AMotores DC pequeños, minibombas
/8 (por defecto)±320 mV±3,2 APanel solar, motores, uso general

Conexión del INA219: Arduino Uno, ESP32 y Pico

Pin del INA219Arduino UnoESP32Raspberry Pi PicoFunción
VCC5V3V33V3(OUT), pin 36Alimentación del chip
GNDGNDGNDGNDMasa común (también debe unirse al negativo de la carga)
SCLA5GPIO 22GP5 (pin 7)Línea de reloj I2C
SDAA4GPIO 21GP4 (pin 6)Línea de datos I2C
Vin+Positivo de la fuentePositivo de la fuentePositivo de la fuenteExtremo por donde entra la corriente
Vin−Positivo de la cargaPositivo de la cargaPositivo de la cargaExtremo por donde sale la corriente

Piensa en el camino de la corriente como una cadena: positivo de la fuente, Vin+, shunt, Vin−, positivo de la carga, negativo de la carga y, por último, negativo de la fuente. El INA219 entra en esta cadena en serie, igual que un amperímetro. El negativo de la fuente, el negativo de la carga y el pin GND del módulo deben unirse sí o sí; de lo contrario, aunque la corriente se vea bien, la medición del voltaje de línea no tendrá sentido (más detalles en el artículo sobre la masa común). En el Uno también puedes usar los pines SDA/SCL de la esquina superior de la placa en lugar de A4/A5; son la misma línea. La mayoría de los módulos ya traen resistencias pull-up I2C, así que no necesitas añadir ninguna. Si en ESP32 y Pico alimentas el módulo desde 3V3, esos pull-up también suben a 3,3 V y los pines quedan a salvo.

No conectes el INA219 en paralelo a los dos extremos de una pila o un adaptador como si fuera el rango de voltímetro de un multímetro. Entre Vin+ y Vin− solo hay 0,1 Ω, así que la fuente queda en cortocircuito y el shunt y las pistas de cobre se queman en segundos. Además, no apliques más de 26 V a los terminales Vin y no uses nunca el módulo en la red eléctrica (220 V AC): el INA219 es un chip de medición DC sin aislamiento.

Paso a paso: primera medición con Arduino Uno

  1. Abre el Gestor de bibliotecas del IDE de Arduino, busca la biblioteca Adafruit INA219 y acepta también la dependencia Adafruit BusIO que te pida durante la instalación. Si no estás familiarizado con instalar bibliotecas, echa un vistazo al artículo cómo añadir bibliotecas.
  2. Conecta los pines VCC, GND, SDA y SCL del módulo al Uno como indica la tabla.
  3. Elige la carga que quieres medir: por ejemplo, un LED rojo con una resistencia de 220 Ω alimentado por una pila de 9 V, o un motor DC pequeño. Conecta el positivo de la pila a Vin+ y Vin− al positivo de la carga.
  4. Conecta el negativo de la pila tanto al negativo de la carga como al pin GND del INA219; así el Uno, la pila y la carga comparten la masa común.
  5. Sube el código, abre el Monitor Serie a 115200 baudios y compara la corriente que lees con la de un multímetro conectado en 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}
FunciónValor que devuelve
ina219.begin()Devuelve true si encuentra el sensor; también inicia el bus I2C
getShuntVoltage_mV()Tensión en el shunt (mV)
getBusVoltage_V()Tensión entre Vin− y GND, es decir, la que ve la carga (V)
getCurrent_mA()Corriente calculada según la calibración (mA), negativa en sentido contrario
getPower_mW()Producto de la corriente por el voltaje de línea (mW)
bus_V + shunt_mV / 1000Tensión de la propia fuente, antes del shunt (V)

En el ejemplo del LED rojo con resistencia de 220 Ω y pila de 9 V, la corriente sale en torno a (9 − 2) / 220 ≈ 32 mA; en el shunt caen unos 3,2 mV y la potencia total del circuito es 9 V × 32 mA ≈ 290 mW. Podrás ver en directo cómo, a medida que la pila se desgasta, el voltaje baja hasta 8 V y la corriente disminuye en consecuencia. Es normal ver valores pequeños de 0,1–0,5 mA sin carga conectada; se deben al pequeño offset de la entrada del chip y no significan que la medición esté mal.

Calibración: la clave de una medición correcta

Al encender el INA219, el registro de calibración vale cero; por eso, aunque puedes leer enseguida la tensión del shunt y del bus, los registros de corriente y potencia se quedan en cero. El valor de calibración se obtiene con dos fórmulas del datasheet: primero se calcula Current_LSB = corriente máxima esperada / 32768 y se redondea a un número cómodo; después se obtiene Cal = 0,04096 / (Current_LSB × R_shunt). El paso del registro de potencia es siempre 20 veces Current_LSB. Con el shunt de 0,1 Ω del módulo y 3,2 A, Current_LSB = 3,2 / 32768 ≈ 97,7 µA, que redondeado queda en 100 µA; Cal = 0,04096 / (0,0001 × 0,1) = 4096 y el paso de potencia es 2 mW. La biblioteca de Adafruit ofrece tres perfiles listos que hacen este cálculo por ti:

FunciónRango de líneaRango del shuntCorriente máximaPaso de corriente
setCalibration_32V_2A() (por defecto)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

Los "32 V" de la tabla son solo el rango del registro; el límite real del chip sigue siendo 26 V. Si cambiaste el shunt, los perfiles listos darán resultados erróneos. La solución más sencilla es calcular tú mismo la corriente: corriente (mA) = getShuntVoltage_mV() / R_shunt (Ω). Por ejemplo, si con un shunt de 1 Ω lees 15 mV, la corriente es 15 mA. Si quieres afinar con una referencia fiable, usa la fórmula de corrección del datasheet: Cal_nuevo = Cal × (corriente que muestra el multímetro / corriente que muestra el INA219). Si el multímetro marca 500 mA y el INA219 495 mA, escribes 4096 × 500 / 495 ≈ 4137. Como el registro de calibración se borra al cortar la alimentación, la biblioteca de Adafruit reescribe el valor antes de cada lectura de corriente; si escribes tu propio código, debes volver a enviar la calibración cada vez que inicies el sensor. La escritura directa en el registro la verás en la sección de la Pico.

Medir el consumo de batería con ESP32: contador de mAh y mWh

Para saber cuánto durará una batería, importa más el consumo total que la corriente instantánea. La carga total es la acumulación de la corriente en el tiempo: si en cada medición multiplicas la corriente (mA) por el tiempo transcurrido (horas) y lo sumas, obtienes mAh; haciendo lo mismo con la potencia, obtienes mWh. El siguiente código usa los pines I2C por defecto del ESP32 (SDA 21, SCL 22), elige el perfil 32V_1A para un paso más fino y actualiza el total cada medio segundo. Como no usa ninguna función dependiente de la versión, compila sin cambios con el core de Arduino para ESP32 2.x y 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}

Por ejemplo, si un nodo sensor consume en promedio 45 mA, una batería 18650 de 2500 mAh durará teóricamente 2500 / 45 ≈ 55 horas; en la práctica, por las pérdidas de conversión y porque la batería no se descarga por completo, es realista contar con el 70–80 % de eso. Puedes hacer este cálculo rápidamente con la calculadora de duración de batería. En las pruebas de deep sleep ten cuidado: con un shunt de 0,1 Ω el paso real es de unos 0,1 mA, así que una corriente de reposo del orden de microamperios aparece como cero. La mayoría de las placas de desarrollo consumen varios mA incluso dormidas por el chip USB-serie y el regulador, y el INA219 lo muestra sin problema. Para ver los unos 10 µA de reposo de un módulo ESP32 desnudo, hace falta un shunt de 1–10 Ω; en ese caso la corriente máxima baja entre 320 mA y 32 mA, así que no podrás medir la corriente en vigilia con el mismo ajuste.

Raspberry Pi Pico y MicroPython: INA219 con registros

En MicroPython, manejar el INA219 directamente con sus registros, sin ninguna biblioteca, es fácil y muy instructivo. El valor 0x399F que escribimos en el registro de configuración (0x00) selecciona rango de 32 V, PGA /8, resolución de 12 bits y modo de medición continua; es además el valor por defecto del chip al arrancar. Después se escribe 4096 en el registro de calibración (0x05). La tensión del shunt (0x01) y la corriente (0x04) son números de 16 bits con signo; en el registro de voltaje de línea (0x02) el valor se lee descartando los 3 bits inferiores y multiplicando por 4 mV. Si guardas el código con Thonny como main.py, la Pico empezará a medir en cada arranque. Si cambiaste el shunt, basta con actualizar R_SHUNT y CURRENT_LSB; Cal se calcula automáticamente. Si eres nuevo en MicroPython, el artículo fundamentos de MicroPython es un buen punto de partida.

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)

Medición de panel solar y carga de batería

En proyectos con panel solar, el INA219 se conecta entre el positivo del panel y el circuito de carga o la carga, y muestra la potencia real que el panel genera en ese momento. Recuerda que solo verás la potencia de la etiqueta con una carga adecuada: sin carga la corriente es cero y el voltaje es el de circuito abierto (Voc). Un panel pequeño de 6 V y 2 W entrega unos 330 mA a pleno sol; con cielo nublado ese valor puede caer a una décima parte. Registrando las mediciones cada minuto puedes calcular la producción diaria de energía en Wh, ver el efecto del ángulo del panel o comparar un panel fijo con un sistema de seguimiento solar. Los paneles vendidos como "12 V" tienen una tensión en circuito abierto de 21–22 V; eso sigue siendo seguro para el INA219, pero si conectas dos paneles en serie superas el límite de 26 V. En sistemas con panel y batería, si colocas el INA219 entre la batería y el circuito, con Vin+ hacia la batería y Vin− hacia el circuito, aprovechas la medición bidireccional: la corriente aparece positiva cuando la batería alimenta el circuito y negativa cuando se carga. Así también puedes ver cuánta corriente entrega realmente a la batería un módulo de carga como el TP4056.

¿INA219 o ACS712?

Módulo sensor de corriente ACS712 de efecto Hall
Sensor de corriente ACS712: funciona por efecto Hall, da una salida analógica y también puede medir corriente AC; el INA219, en cambio, mide corriente, voltaje y potencia DC de forma digital.
CaracterísticaINA219ACS712 (5 A)
Principio de mediciónResistencia shunt + ADCEfecto Hall
SalidaDigital (I2C)Voltaje analógico (VCC/2 con corriente cero)
Qué mideCorriente, voltaje y potenciaSolo corriente
Tipo de corrienteSolo DCAC y DC
Rango±3,2 A (con shunt de 0,1 Ω), hasta 26 V±5 A (también hay versiones de 20 A y 30 A)
ResoluciónAprox. 0,1 mA185 mV/A; con el ADC del Uno, paso de unos 26 mA
AislamientoNoSí (2,1 kV RMS)
Alimentación3,0–5,5 V5 V

En resumen, en circuitos DC de menos de unos pocos amperios, en la medición de baterías y paneles solares y en proyectos de microcontrolador de bajo consumo, el INA219 es mucho más preciso y práctico; además no gasta pines analógicos y se pueden conectar hasta cuatro sensores en la misma línea I2C. Vigilar la corriente AC de la red, superar los 5 A o querer aislamiento eléctrico entre el circuito medido y el microcontrolador es terreno del ACS712; para más detalles, echa un vistazo al artículo del sensor de corriente ACS712. Si necesitas tensiones superiores a 26 V o más resolución, se elige el INA226 de la misma familia (36 V, 16 bits), y para reunir tres canales en un solo chip, el INA3221. Si quieres ver el voltaje medido en un rango más amplio, el método del divisor de tensión del artículo del voltímetro con Arduino es también un buen complemento.

Ideas de proyectos con el INA219

  • Medidor de potencia USB: pasa la línea de 5 V de un cable USB por el INA219 y muestra en una pantalla OLED cuántos mA consume el cargador del móvil o una placa Arduino.
  • Registrador de energía solar: mide la potencia del panel con un ESP32 cada minuto, guárdala en una tarjeta SD y calcula la producción diaria en Wh.
  • Probador de capacidad de baterías: descarga una batería 18650 con una carga de resistencia fija hasta 3,0 V y averigua su capacidad real con los mAh acumulados (ver qué son los mAh).
  • Alarma de esfuerzo del motor: detén el motor DC cuando su corriente se duplique respecto a lo normal; ideal para detectar que una rueda se ha atascado en un coche robot.
  • Protección contra funcionamiento en seco de bombas: cuando se acaba el agua, la corriente de la minibomba baja de forma notable; detecta esa caída y apaga la bomba para alargar su vida.
  • Indicador para fuente de laboratorio: muestra en directo el voltaje, la corriente y la potencia de salida de una fuente regulable en una pantalla LCD I2C.

Errores comunes y cómo solucionarlos

SíntomaCausa probableSolución
Mensaje "INA219 no encontrado"SDA/SCL invertidos, VCC sin conectar o dirección distintaRevisa los cables y busca la dirección con un escáner I2C (0x40–0x45)
La corriente sale negativaVin+ y Vin− están intercambiadosConecta la fuente a Vin+ y la carga a Vin−, o invierte el signo en el software
Corriente correcta, voltaje 0 o absurdoEl negativo de la carga y el GND del INA219 no son comunesUne los GND de la fuente, la carga y el módulo
La corriente es siempre 0Carga sin conectar, módulo en paralelo o corriente por debajo del paso mínimoRevisa la conexión en serie; para corrientes muy pequeñas usa un shunt mayor
El valor se queda clavado en torno a 3,2 ASe superó el rango de tensión del shuntReduce la carga o usa un shunt menor y calcula tú mismo la corriente
Los valores saltan continuamenteMotor o LED controlado por PWM, ruido en los cablesHaz un promedio, aumenta el número de muestras internas, aplica un filtro por software
El módulo se calentó o se quemóConexión en paralelo (cortocircuito) o corriente superior a 3 AConecta siempre el módulo en serie y usa un fusible en la línea
En cargas que cambian rápido, como un motor o un LED controlado por PWM, una sola lectura puede engañar, porque una conversión de 532 µs puede coincidir con el instante en que el pulso está encendido o apagado. Si activas el modo de promedio interno del INA219, el chip acumula 128 muestras durante unos 68 ms y da una corriente media mucho más estable: en el código de la Pico basta con escribir 0x3FFF en lugar de 0x399F. En Arduino también sirve promediar 10–20 lecturas o usar los métodos de filtrado de datos de sensores.

Con un único módulo pequeño, el INA219 le da a tu proyecto voltímetro, amperímetro y vatímetro a la vez; detrás de muchas ideas, del panel solar a la duración de la batería, de la protección del motor al medidor de potencia USB, hay una buena medición. En la app de BlueGrays encontrarás, paso a paso y con esquema y código, proyectos como un voltímetro digital con pantalla LCD, ESP32 deep sleep, un registrador de temperatura y riego inteligente; añadiéndoles el INA219 podrás empezar a medir su consumo de inmediato.

Preguntas frecuentes

¿Cuántos amperios puede medir como máximo el INA219?

Con el shunt de 0,1 Ω de los módulos comunes, el INA219 mide hasta unos ±3,2 A, porque el límite de tensión del shunt del chip es ±320 mV. Si cambias el shunt por uno menor, como 0,01 Ω, el rango teórico sube a 32 A; pero como las pistas de cobre y los bornes del módulo no están pensados para esa corriente, tendrías que sacar el shunt y los cables gruesos fuera de la placa.

¿Se puede medir corriente AC con el INA219?

No. El INA219 está diseñado para circuitos DC y la tensión en sus terminales debe estar entre 0 y 26 V; conectarlo a la red quemaría el chip y además es peligroso para tu vida. Para corriente AC se usan sensores Hall aislados como el ACS712 o transformadores de corriente como el SCT-013.

¿Cómo se cambia la dirección I2C del INA219?

Los puentes de soldadura A0 y A1 del módulo fijan la dirección: con ambos abiertos es 0x40, con solo A0 cerrado 0x41, con solo A1 cerrado 0x44 y con ambos cerrados 0x45. En el código basta con indicar la dirección así: Adafruit_INA219 ina219(0x41); De este modo puedes conectar hasta cuatro INA219 distintos a la misma línea I2C.

¿Cuál es la diferencia entre el INA219 y el INA226?

El INA226 es el miembro más avanzado de la misma familia: el voltaje de línea llega hasta 36 V y, gracias a su ADC de 16 bits, tiene una resolución mucho mayor. El INA219 es más barato y más habitual, y su soporte en bibliotecas de Arduino es muy amplio. Para proyectos de aficionado por debajo de 26 V y unos pocos amperios, el INA219 es más que suficiente.

¿El INA219 funciona a 3,3 V?

Sí, el rango de alimentación del INA219 es de 3,0–5,5 V. En el ESP32 y la Raspberry Pi Pico, alimentar el módulo desde el pin 3V3 hace que las líneas I2C también se mantengan a 3,3 V. La tensión de alimentación no limita la línea medida; un INA219 alimentado a 3,3 V puede seguir midiendo una línea de hasta 26 V.

¿Por qué el INA219 muestra una pequeña corriente incluso sin carga?

La entrada del shunt del chip tiene un offset de unas decenas de microvoltios; con un shunt de 0,1 Ω eso equivale a una lectura pequeña, de 0,1–0,5 mA. Puedes eliminar esa desviación guardando el valor leído sin carga y restándolo de las mediciones posteriores, o promediando varias mediciones.

Ver todos los proyectos
Voltímetro digital con pantalla LCD
AR-56Intermedio
Premium

Voltímetro digital con pantalla LCD

Descubre cuánto voltaje da una pila o un adaptador con un medidor hecho por ti. Un divisor de dos resistencias baja la tensión alta a un nivel que la placa puede leer, y el Arduino calcula el valor…

4.5(27)
36
Modo de suspensión profunda del ESP32 — Ahorro de batería (OLED + contador en RTC RAM)
ES-33Avanzado
Premium

Modo de suspensión profunda del ESP32 — Ahorro de batería (OLED + contador en RTC RAM)

El modo Deep Sleep del ESP32 apaga la CPU y la mayoría de los periféricos y reduce el consumo a unos 10µA, algo clave para dispositivos IoT con batería. Este proyecto usa tres fuentes de activación: un temporizador (15 s), un pin externo (EXT0, el botón en GPIO 33) y un pin táctil (T0/GPIO 4). Los contadores marcados con RTC_DATA_ATTR se conservan durante el deep sleep.

4.3(10)
16
Registrador de Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avanzado
Premium

Registrador de Temperatura ESP32 (DHT22 + DS1307 RTC + microSD + OLED)

¡Monta con el ESP32 un registrador de temperatura y humedad con hora! Un sensor DHT22 lee la temperatura y la humedad una vez por minuto, y cada lectura se guarda en una tarjeta microSD en formato CSV con la hora real del módulo RTC DS1307. La pantalla OLED muestra en vivo y con letra grande la última temperatura, la humedad, la marca de tiempo y el total de registros.

4.7(7)
12
Uso de la pantalla LCD con I2C
AR-32Principiante
Premium

Uso de la pantalla LCD con I2C

Dale a tu Arduino su propia pantalla y haz que escriba su primer mensaje. La pantalla LCD de dos líneas se conecta con solo unos pocos cables; primero aparece un saludo en la línea de arriba, luego…

4.8(53)
70
Pantalla LCD I2C para ESP32 (16x2)
ES-17Intermedio
Premium

Pantalla LCD I2C para ESP32 (16x2)

En este proyecto conectamos una pantalla LCD de caracteres 16x2 al ESP32 por I2C para mostrar texto. Con I2C bastan 2 pines de datos (SDA y SCL), en lugar de los 6+ pines de una conexión paralela clásica. El código escribe un mensaje fijo en la primera línea y un contador que sube cada segundo en la segunda. Al arrancar, un escáner I2C muestra la dirección de la pantalla en el Serial Monitor (normalmente 0x27 o 0x3F).

4.9(23)
40
Estación de riego inteligente
AR-83Avanzado
Premium

Estación de riego inteligente

Un jardinero que riega solo tus plantas para que no se sequen mientras estás de vacaciones.

5.0(42)
57
Iluminación Inteligente ESP32 (PIR + LDR + Relé + OLED)
ES-37Avanzado
Premium

Iluminación Inteligente ESP32 (PIR + LDR + Relé + OLED)

Con un ESP32, un sensor de movimiento PIR, un sensor de luz LDR y un módulo de relé convertimos el pasillo, el baño o la despensa de tu casa en iluminación inteligente. Si ya hay luz, la lámpara no se enciende aunque haya movimiento, así no gasta energía de día. La luz se queda encendida 30 segundos y el tiempo se alarga solo mientras siga habiendo movimiento.

4.3(6)
11