Llega un momento en la vida de todo Maker que necesita saber cuánto consume su proyecto y en este sentido el sensor de consumo INA219 tiene mucho que decir.
Y aunque es sencillo poder medir el consumo de una placa, un componente o un proyecto completo utilizando un multímetro o tester, el sensor INA219 te permite monitorizar dicho consumo en tiempo real por un largo periodo de tiempo.
Puede ser muy útil para saber el ciclo de descarga de una batería, para saber la energía que queda en una pila o para estimar cuánto van a durar las baterías de tu proyecto.
Atento a lo que viene a continuación porque de una forma muy sencilla serás capaz de medir el consumo de cualquier proyecto electrónico gracias al sensor INA219.
Indice de contenidos
¿Qué es el sensor de tensión INA219?
El sensor INA219 es un chip de Texas Instruments capaz de monitorizar el consumo de energía de un dispositivo. Lo hace midiendo la caída de tensión de una resistencia en derivación o resistencia shunt.
Este tipo de resistencias, al igual que pasa con las resistencias pull-up o pull-down, son resistencias normales como las típicas que encontramos en cualquier kit de Arduino. La única características que las hace algo diferentes es su bajo valor óhmico. Suelen ser resistencias de 0.01Ω, 0.1Ω o 1Ω para disipar la menor potencia posible.
Lo importante de estas resistencias es para qué se utilizan ya que si eres capaz de medir la tensión que cae en la resistencia y al conocer su valor, es fácil saber la corriente que circula a través de ella y de ahí se puede derivar la potencia y el consumo.
Más o menos esto es lo que hace el sensor INA219 para calcular el consumo de un dispositivo. Si quieres profundizar más sobre su funcionamiento te recomiendo que vayas a la hoja de características técnicas.
Como suele ocurrir con muchos sensores y actuadores, el propio nombre del chip da nombre al módulo donde viene integrado.
En este módulo está toda la electrónica necesaria para que de lo único que te preocupes sea de conectar el sensor INA219 a tu Arduino, ESP8266 o ESP32 y lo programes.
Módulo sensor INA219
A simple vista podemos ver las diferentes partes del módulo INA219 que nos permitirán hacer la conexión con el microcontrolador.
Vamos a ver en detalle cada parte del módulo INA219.
Conexión fuente de alimentación
Estos dos pines nos va a servir para poner el módulo INA219 en serie entre la fuente de alimentación y el circuito que queremos comprobar su consumo.
Imagina que quieres medir el consumo de un Arduino UNO. El sensor INA219 debe ir situado entre la fuente y la placa de Arduino como se muestra en el siguiente esquema.
Aunque en el esquema he utilizado una fuente de alimentación regulable de laboratorio, puedes utilizar una batería o cualquier otra fuente de alimentación.
Lo importante es que el Vin+ va conectado al positivo de la fuente. El Vin- se conecta al terminal positivo de la carga o circuito que se quiere comprobar su consumo. Por último, el terminal negativo de la fuente de alimentación y de la carga se conecta a GND común.
Dato importante a tener en cuenta es que el sensor INA219 puede medir una tensión de entre 0V y 26V, suficiente para alimentar cualquier proyecto que utilice Arduino, ESP8266 o ESP32.
La corriente máxima que admite el INA219 es de 3,2A.
Normalmente suele venir con unos bornes de tornillo para una fácil conexión a la fuente de alimentación. Puedes conectar una batería, unas pilas o una fuente externa.
Resistencia shunt
Como ya he explicado, la resistencia en derivación o shunt es donde se medirá la tensión para hacer los cálculos de la corriente y del consumo.
Esta resistencia es una resistencia normal con un valor óhmico lo más bajo posible. En este caso se trata de una resistencia SMD de 0,1Ω con una tolerancia de un 1%.
El sensor INA219 utiliza un ADC interno de 12-bit (4096 valores posibles) consiguiendo una resolución:
Algunas hackers suelen cambiar la resistencia de 0,1Ω por una de 0,01Ω para conseguir un rango mayor de medida y pasar de un máximo de 3,2A a 32A con una resolución de 8mA.
El sensor INA219 permite configurar la ganancia interna del amplificador para medir una corriente máxima de 400mA y conseguir así una resolución de 0,1mA. Esto se puede configurar a nivel de código como veremos más adelante.
Chip INA219
Es el encargado de tomar la medida de tensión en la resistencia shunt para calcular la corriente y el consumo. En la hoja de características podemos ver el diagrama de bloques.
Su descripción se sale fuera de este tutorial. Primero porque no entiendo su funcionamiento eléctrico y segundo porque lo que nos interesa en este momento es utilizar el sensor INA219 de forma sencilla con Arduino, ESP8266 y ESP32.
Si quieres saber cómo funciona internamente te recomiendo que vayas a la hoja de características técnicas del sensor INA219 o a algún blog especializado en electrónica.
Selector dirección I2C
Ya vimos en otro tutorial cómo se pueden comunicar diferentes componentes y microcontroladores utilizando el protocolo de comunicación I2C. Para poder comunicar lo único que se necesita es que cada componente dentro del bus tenga una dirección única.
El sensor INA219 viene configurado con 4 posibles direcciones I2C. Estas direcciones se pueden configurar a través de la unión de contactos nombrados A0 y A1.
Por defecto estos contactos vienen sin unir y esto hace que el sensor INA219 tenga la dirección I2C 0x40. Si necesitas conectar más de un sensor INA219 puedes cambiar la dirección puenteando los diferentes contactos según la siguiente tabla.
| Contacto | Dirección I2C | Puente |
|---|---|---|
| 1 | 0x40 | Contactos no puenteados |
| 2 | 0x41 | Puente contactos A0 |
| 3 | 0x44 | Puente contactos A1 |
| 4 | 0x45 | Puente contactos A0 y A1 |
Para hacer un puente entre los contactos basta con aplicar un poco de estaño con el soldador.
Esto te permite conectar hasta 4 sensores INA219 al mismo bus I2C.
Pines sensor INA219
Los pines del sensor INA219 tienen varias utilidades:
- Alimentación del módulo INA219.
- Comunicación I2C con el microcontrolador.
- Fuente de alimentación.
- Vcc: pin de alimentación del módulo INA219. Admite una tensión de alimentación entre 3V y 5,5V.
- GND: pin conexión a tierra o GND común.
- SCL: señal de reloj I2C.
- SDA: señal de datos I2C.
- Vin+: pin que se conecta al terminal positivo de la fuente de alimentación. Es el mismo punto eléctrico que el pin Vin+ que hemos visto antes.
- Vin-: pin que se conecta al terminal positivo de la carga o circuito que se quiere conocer su consumo. Es el mismo punto eléctrico del pin Vin- que hemos visto antes.
Conexión sensor INA219 con Arduino
La conexión del sensor INA219 con Arduino es bastante sencilla ya que lo único que requiere es conectar los pines de alimentación y los pines de comunicación I2C. Puedes ver como conectarlo con un Arduino UNO en el siguiente esquema eléctrico.
La conexión es muy sencilla. El pin 5V de Arduino se conecta con el pin Vcc del módulo, el pin GND con el pin GND, el pin SCL con el pin A5 y el pin SDA con el pin A4.
Si utilizas otra placa como Arduino MEGA, Arduino Nano, Arduino Pro Mini, ESP8266 o ESP32 debes utilizar los pines I2C correspondientes a cada placa según la siguiente tabla.
| Placa | SDA | SCL |
|---|---|---|
| Arduino MEGA | 20 | 21 |
| Arduino Nano | A4 | A5 |
| Arduino Pro Mini | A4 | A5 |
| ESP8266 | D2 | D1 |
| ESP32 | 21 | 22 |
La alimentación del módulo INA219 se puede hacer tanto con el pin de 3,3V como el de 5V. Las dos tensiones son compatibles.
Conexión INA219 para medir consumo
La parte de control la tenemos solucionada con la conexión del módulo INA219 con Arduino o cualquier placa compatible. Ahora vamos a ver una forma práctica de conectar el circuito o proyecto del que queremos medir el consumo.
Aunque ya hemos visto un diagrama general, en el siguiente esquema eléctrico puedes ver las conexiones de todo el proyecto completo.
El material que vas a necesitar es el siguiente:
- Arduino UNO (o cualquier placa compatible de la que hemos visto)
- Módulo INA219
- Wemos D1 Mini o NodeMCU
- Fuente alimentación USB (o cualquier otro tipo de fuente compatible con tu proyecto)
- Protoboard
- Cables
En la parte del circuito a medir consume puedes conectar cualquier cosa. En mi caso voy a probar el sensor INA219 con un ESP8266 para comprobar su consumo.
Medir consumo ESP8266 con sensor INA219
Una vez ya tenemos conectados todos los componentes vamos a pasar a ver la programación. El objetivo es poder medir el consumo de un ESP8266 cuando se conecta a la red WiFi y hace una consulta a una API como OpenWeather para obtener los datos meteorológicos.
Por lo tanto, por un lado vamos a tener el ESP8266 consultando información de esta API y por otro lado vamos a tener el sensor INA219 conectado a un Arduino UNO obteniendo los datos de consumo.
Lo primero que haremos será configurar el ESP8266 para que se conecte a OpenWeather.
Consultar datos meteorológicos de OpenWeather desde el ESP8266
Te recomiendo que desconectes el ESP8266 del sensor INA219 y que solamente lo alimentes a través del USB, vamos, como hacemos cuando cargamos un código.
Vamos a preparar primero la parte del ESP8266 que consistirá en obtener los datos meteorológicos de la API de OpenWeather, algo que ya hicimos en el tutorial de la pantalla Nextion con ESP8266.
Lo primero que tienes que hacer es obtener el identificador de tu ciudad y la API Key de OpenWeather.
Accede a esta página y descarga el archivo que se llama city.list.json.gz. Es un archivo comprimido y lo puedes descomprimir con el WinRar por ejemplo.
Obtendrás un archivo JSON que se llama city.list.json que son los identificadores de las ciudades de todo el mundo. Lo puedes abrir con el Sublime Text o con cualquier otro editor (vale también el bloc de notas). Busca tu ciudad y apúntate su ID.
Por ejemplo, el ID de Alicante es 6355390. Asegúrate que estás seleccionando el de tu país.
Por otro lado tendrás que crear una cuenta en OpenWeather. Una vez creada entra en la opción My API keys.
Genera una nueva API key. Puedes darle el nombre que quieras, eso no es importante ya que solo sirve para identificarla dentro de las múltiples API keys que puedas tener.
Esto generará una API key que debes guardar y no compartir con nadie. Ni conmigo :)
Cuando generas una nueva API key tarda unos minutos o incluso horas en estar validada. Si al consultar la información sale un error 401 es que todavía no se ha validado.
Sustituye toda esta información y las credenciales de tu red WiFi en el siguiente código.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 |
#include <ESP8266WiFi.h> #include <ESP8266HTTPClient.h> // Configuración red WiFi const char* ssid = "TU-SSID"; // Pon el nombre de tu red WiFi const char* password = "TU-PASS"; // Pon la contraseña de tu red WiFi // Datos OpenWeatherMap String url = "http://api.openweathermap.org/data/2.5/weather"; String idCiudad = "ID-TU-CIUDAD"; String apiKey = "TU-API-KEY-OPENWEATHER"; unsigned long tiempoDeepSleep = 10e6; void setup() { Serial.begin(115200); // Conexión con la red WiFi Serial.print("Conectando con "); Serial.println(ssid); // Configuración en modo estación WiFi.mode(WIFI_STA); // Iniciar conexión con la red WiFi WiFi.begin(ssid, password); while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); } Serial.println(""); Serial.println("Conectado a la WiFi"); // Creamos la URI para hacer la pretición url += "?id="; url += idCiudad; url += "&appid="; url += apiKey; Serial.print("URI petición HTTP: "); Serial.println(url); // Cliente web HTTPClient clienteHttp; // Conexión con el servidor y configuración de la petición clienteHttp.begin(url); // Envío de petición HTTP al servidor int codigoHttp = clienteHttp.GET(); // Si todo ha ido bien devolverá un número positivo mayor que cero if (codigoHttp > 0) { // Mostramos el código de respuesta Serial.print("Codigo HTTP: "); Serial.println(codigoHttp); // Si ha encontrado el recurso en el servidor if (codigoHttp == HTTP_CODE_OK) { Serial.print("Archivo JSON: "); Serial.println(clienteHttp.getString()); } } Serial.println("A dormir"); ESP.deepSleep(tiempoDeepSleep); } void loop() {} |
Este código lo único que hace es:
- Conectarse a la red WiFi de tu casa
- Hace una petición HTTP a la API OpenWeather para obtener los datos meteorológicos de tu ciudad
- Muestra los datos por el monitor serie
- Pone el ESP8266 en modo deep sleep (sueño profundo) para ahorrar energía
Conecta tu placa basada en el ESP8266 y sube el código cambiando los datos de configuración SSID, contraseña, identificador de ciudad y API Key.
No te olvides de una vez cargado el código conectar el pin GPIO16 (D0 en Wemos y NodeMCU) al pin RST porque de otro modo no conseguirá despertarse.
Abre el monitor serie y veras algo parecido a esto.
Con esto ya tenemos configurado el ESP8266 con el código para poder medir su consumo. Esto nos aportará información del consumo del ESP8266 cuando se conecta a la red WiFi, cuando hace una petición HTTP y en el modo de ahorro de energía deep sleep.
Ahora vamos a ver cómo programar Arduino para que nos facilite la información del consumo gracias al sensor INA219.
Programación sensor INA219 con Arduino
Y para programar el sensor INA219 vamos a utilizar la librería de Adafruit que podemos encontrar en GitHub.
Lo primero es instalar la librería de Arduino. Voy a trabajar con la versión Arduino IDE 2.0 aunque con la versión del IDE de Arduino original se hace de la misma forma.
Al instalar la librería te dirá que tiene otras dependencias, es decir, otras librerías que son necesarias para que esta funcione. Te recomiendo que hagas clic en el botón Install all.
Esto instala tanto el código de la librería como los ejemplos. Y para no complicarnos mucho la vida, vamos a utilizar el ejemplo que viene con la librería INA219 de Adafruit.
Está en Examples>AdafruitINA219>getcurrent. Esto abre el siguiente código.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 |
#include <Wire.h> #include <Adafruit_INA219.h> Adafruit_INA219 ina219; void setup(void) { Serial.begin(115200); while (!Serial) { // will pause Zero, Leonardo, etc until serial console opens delay(1); } uint32_t currentFrequency; Serial.println("Hello!"); // Initialize the INA219. // By default the initialization will use the largest range (32V, 2A). However // you can call a setCalibration function to change this range (see comments). if (! ina219.begin()) { Serial.println("Failed to find INA219 chip"); while (1) { delay(10); } } // To use a slightly lower 32V, 1A range (higher precision on amps): //ina219.setCalibration_32V_1A(); // Or to use a lower 16V, 400mA range (higher precision on volts and amps): //ina219.setCalibration_16V_400mA(); Serial.println("Measuring voltage and current with INA219 ..."); } void loop(void) { float shuntvoltage = 0; float busvoltage = 0; float current_mA = 0; float loadvoltage = 0; float power_mW = 0; shuntvoltage = ina219.getShuntVoltage_mV(); busvoltage = ina219.getBusVoltage_V(); current_mA = ina219.getCurrent_mA(); power_mW = ina219.getPower_mW(); loadvoltage = busvoltage + (shuntvoltage / 1000); Serial.print("Bus Voltage: "); Serial.print(busvoltage); Serial.println(" V"); Serial.print("Shunt Voltage: "); Serial.print(shuntvoltage); Serial.println(" mV"); Serial.print("Load Voltage: "); Serial.print(loadvoltage); Serial.println(" V"); Serial.print("Current: "); Serial.print(current_mA); Serial.println(" mA"); Serial.print("Power: "); Serial.print(power_mW); Serial.println(" mW"); Serial.println(""); delay(2000); } |
No hay que hacer nada más, cárgalo a tu placa Arduino UNO y listo.
Consumo de un ESP8266 consultando datos de OpenWeather
Para obtener el consumo del ESP8266 consultando los datos de OpenWeather hay que alimentar el ESP8266 a través del sensor INA219 como hemos visto en el esquema anterior.
A la vez tienes que tener conectado el Arduino UNO a tu ordenador y abrir el monitor serie con el puerto donde está conectado el Arduino UNO. Empezarás a ver el consumo del ESP8266.
Según las especificaciones de Adafruit y de la propia hoja de características técnicas del sensor INA219, las diferentes medidas representan lo siguiente:
- Bus Voltage: es la tensión de la fuente de alimentación.
- Shunt Voltage: es la tensión que cae en la resistencia shunt.
- Load Voltaje: es la tensión a la entrada carga que en este caso es el ESP8266.
- Current: es la corriente que representa el consumo.
- Power: es la potencia que será la corriente por la tensión.
Y con esto doy por finalizado el tutorial sobre el sensor INA219 para poder medir los consumos de nuestros proyectos. Muy importante cuando estás creando proyectos domóticos o del IoT que utilizan pilas y baterías.
Cualquier duda o sugerencia la puedes dejar en los comentarios de aquí abajo.
Muchas gracias por tu atención.