El modo del ESP8266 deep sleep (sueño profundo) consigue que este SoC o microcontrolador, consiga un consumo de unos 20 µA. Y wow, esto te puede parecer una pasada y un bajo consumo.
Sin embargo, que un dispositivo se considere de bajo consumo o no, depende exclusivamente de la aplicación y no tanto del propio consumo.
Me explico.
Imagínate un proyecto con un Arduino o un ESP8266 con un consumo medio del orden de 100 µA (0,1 mA). Si utilizas una batería de 2.000 mAh y haciendo un cálculo rápido supone una duración de 833 días más o menos.
Esto viene a ser unos 2,3 años de funcionando sin tener que cambiar la batería. Ojo, que esto es un caso ideal. Una batería de 2.000 mAh jamás entregará esa energía ni en el mejor de los casos.
Lo que vengo a decir es que un consumo de 100 µA está bien para una batería de 2.000 mAh pero si la batería es de 100 mAh, la duración será entorno a unos 46 días que es bastante menos que 833.
Esto puede ser un inconveniente o no. Si por ejemplo se puede acceder fácilmente al dispositivo y puedes cambiar las pilas o baterías con comodidad, no será mucho problema hacerlo una vez cada mes y medio.
Ahora, ¿qué pasa si ese dispositivo no es tan accesible? Imagínate una aplicación que controla los movimientos de un ave. Un águila por ejemplo.
En esta situación, tener que cambiar la batería cada 46 días o cada 833 días puede ser un gran inconveniente. Lo ideal sería que durara toda la vida del águila ¿no crees?
Lo que quiero decir con todo esto es que el concepto de bajo consumo no está atado a un valor concreto de intensidad o de potencia. El bajo consumo está ligado al tipo de aplicación que quieras desarrollar.
Dicho esto, en este artículo hablaré de cómo calcular el consumo de un microcontrolador, cómo saber la vida útil de una batería, los modos de ahorro de energía de un ESP8266 y la importancia del modo ESP8266 deep sleep.
Ponte cómodo que empezamos.
Indice de contenidos
- 1 Cómo medir el consumo de un microcontrolador como el ESP8266
- 2 Cómo alimentar una placa NodeMCU o Wemos D1 Mini basada en un ESP8266
- 3 Cómo determinar la duración de una batería recargable
- 4 Cuánto consume un ESP8266
- 5 ESP8266 deep sleep, ejemplo básico
- 6 Comparativa placas prototipado basadas en el ESP8266
- 7 Consumo de un ESP-01 y ESP-12
- 8 Consumo de una placa NodeMCU
- 9 Consumo de una placa Wemos D1 Mini
- 10 Conclusiones ESP8266 deep sleep
Cómo medir el consumo de un microcontrolador como el ESP8266
La energía total que consume un microcontrolador como el ESP8266 puede dividirse en dos: energía dinámica y energía estática.
Todo esto tiene que ver con cómo funcionan los circuitos integrados basados en CMOS. Pero esto se sale fuera de este artículo.
Lo importante, y con lo que quiero que te quedes, es que hay dos tipos de energía.
La energía dinámica es aquella energía que consume un microcontrolador cuando está activo y cuando mediante la programación, accedemos a componentes analógicos como ADC, osciladores, módulo WiFi, etc…
El mero hecho de llamar a la función analogRead(…) o WiFi.begin(…) en un ESP8266 produce un consumo energético que en ocasiones, es bastante elevado.
Por el contrario, la energía estática es aquella energía que consume el microcontrolador cuando está en estado de reposo (o en standby). En este estado, aunque esté conectado a la fuente de energía, tiene un bajo consumo.
Por lo tanto, para saber cuánto consume un microcontrolador como el ESP8266, se suman dos intensidades obteniendo lo que se conoce como intensidad promedio.
Ipromedio = Iestática + Idinámica
En realidad lo que representa esta ecuación es la suma entre la media de la intensidad en reposo y la media de intensidad en activo durante un periodo de tiempo.
La intensidad promedio es una estimación del consumo del ESP8266, o cualquier microcontrolador, durante un periodo de tiempo. Pero no deja de ser eso, una estimación.
Si el dispositivo se encuentra mucho más tiempo en reposo que activo, la intensidad promedio baja. En caso contrario, cuando está más activo que en reposo, la intensidad promedio aumenta.
Por lo tanto, si quieres tener un bajo consumo con tus dispositivos, debes hacer que esté el mayor tiempo posible en estado de reposo y que solo esté activo lo extrictamente necesario.
Lo típico es que un ESP8266 mida algún tipo de magnitud como la temperatura con un DS18B20 o un sensor infrarrojo MLX90614, envíe la información a través de la red WiFi y luego entre en modo de reposo durante un periodo largo de tiempo, dependiendo de cada aplicación.
Así es como se consigue que el ESP8266 tenga un bajo consumo.
Y con esto más o menos ha quedado claro en qué consume la energía un ESP8266 pero ¿cuánto consume realmente un ESP8266?
Antes de responder a esta pregunta hay que tener claro cómo alimentar una placa de prototipado como NodeMCU o Wemos basadas en el ESP8266.
Cómo alimentar una placa NodeMCU o Wemos D1 Mini basada en un ESP8266
Por fin has terminado de montar y programar tu proyecto basado en las placas NodeMCU o Wemos las cuales incorporan un módulo ESP8266. Ha quedado genial e incluso se lo has enseñado a tu cuñado para fardar.
Y llega la hora de la verdad. Necesitas alimentar tu proyecto y donde tienes pensado dejarlo no hay una toma de corriente así que te aventuras a utilizar una pila o batería.
Lo primero que te debes plantear es ¿dónde se conecta la batería en un ESP8266?
En las placas típicas como NodeMCU y Wemos hay tres formas de alimentar un ESP8266:
- A través del USB: sin duda alguna es la mejor opción de alimentar una placa si estás programando un ESP8266. Sin embargo, si vas a utilizar una batería o pila no es una buena opción por dos razones. La primera es que no es sencillo hacer las conexiones por el USB. La segunda razón es que si alimentas por el USB un ESP8266 estarás desperdiciando energía a través del regulador de tensión. Eso sí, gracias al regulador podrás alimentar la placa con más de 3,6V (máximo de voltaje que admite un ESP8266 como veremos luego).
- A través del pin Vin o 5V: esta opción es más sencilla a la hora de conectar un cable ya que se puede hacer a través de los pines de la placa. Sin embargo, ocurre lo mismo que a través del puerto USB ya que también pasa por el regulador produciendo un consumo extra.
- A través del pin 3V3: en principio este pin debería estar conectado directamente al pin de alimentación del ESP8266 pero la realidad es que no es así. Me he encontrado con muchas placas que pasan por el regulador de tensión si alimentas por el pin de 3V3. Luego lo veremos.
No he encontrado grandes diferencias de consumo cuando se alimenta por el pin de 5V o de 3,3V sin embargo, todo hace pensar que de alguna manera el pin de 5V está conectado al regulador de tensión.
Para que el ESP8266 funcione si se alimenta por el pin de 5V necesita un voltaje de más de 4,5V y eso es debido al regulador de tensión. Sin embargo por el pin de 3V3 esto no sucede.
Por lo tanto, un posible esquema de conexión con el pin de alimentación podría ser este.
Ojo, que este esquema puede no ser cierto ya que dependerá de cada fabricante.
Antes de conectar tu batería o pila a la placa es importante conocer el rango de voltaje que admite un ESP8266. Porque aunque veas muchos componentes dispersos por la placa, no hay que perder el foco de lo que estamos haciendo.
Todos esos componentes de las placas de prototipado están puestos ahí por un motivo: programar un microcontrolador. En concreto en este caso es el ESP8266. Esto determina cómo se debe alimentar cualquier placa basada en el ESP8266.
En la hoja de características técnicas puedes ver el voltaje de operación e incluso el consumo medio del ESP8266.
El voltaje de operación está entre 2,5V y 3,6V. Cualquier voltaje por debajo de este rango hará que el ESP8266 no funcione correctamente y cualquier voltaje por encima, podrá dañarlo.
También nos informa que el consumo medio es de 80 mA. Esto incluye la corriente estática y dinámica que hemos visto antes.
Por lo tanto, necesitas una fuente de alimentación (pila o batería) que proporcione un voltaje entre 2,5V y 3,6V. Deberá ir conectado al pin 3V3 y no te olvides de conectar el polo negativo de la pila o batería al pin GND de la placa.
Bien, vamos avanzando. Ya tenemos todo conectado y ahora te surje otra duda ¿cuánto puede durar una batería?
Esto depende de muchos factores pero los dos más importantes, son la capacidad de la batería y el consumo de tu proyecto.
Cómo determinar la duración de una batería recargable
Con esta sección no pretendo crear cátedra. Lo único que quiero hacer es dar una visión aproximada de cómo calcular la vida útil de una batería recargable.
Esto se puede saber utilizando un fórmula muy simple donde se tiene en cuenta la capacidad de la batería y el consumo medio del ESP8266. Ojo, que es una aproximación.
Lo primero que tenemos que saber es la capacidad de la batería. Normalmente viene escrito en alguna parte o en las especificaciones técnicas.
Por ejemplo, las baterías LiPo lo traen impreso en un lado.
Estas baterías suministran 3,7V y se salen fuera del rango de voltaje del ESP8266 (de 2,5V a 3,6V). No se deben conectar al pin de 3V3 a no ser que utilices un regulador de tensión. Si utilizas un voltaje mayor del rango recomendado, seguramente no dañes el ESP8266 pero el consumo, por alguna extraña razón, se dispara si te pasas un poco por arriba del voltaje máximo.
Las baterías Li-FePo4 también suelen traer escrito la capacidad en algún lado.
Elegir una batería u otra depende del tipo de aplicación. Las que mejor funcionan y mejor resultado dan son las Li-FePo4 aunque también son las más caras. Puedes encontrar todas estas baterías en Amazon.
El tema de las baterías y pilas da para otro artículo y se sale fuera de este tutorial así que continuemos.
Creo que lo mejor es ver un caso práctico de cómo calcular la duración de una batería recargable.
Imagínate que tienes una batería con una capacidad de 3.200 mAh. Esta medida indica que la batería puede proporcionar 3.200 mA en una hora (3,2 A) antes de quedarse agotada. Vamos, antes de quedarse seca como la mojama.
Por lo tanto, si consumes menos intensidad significa que la batería dura más porque tarda más en descargarse. Más o menos es así como funcionan las baterías y las pilas.
Bien, pues si sabes la intensidad promedio, puedes calcular la vida útil de la batería usando la siguiente fórmula:
Duración (horas) = (Capacidad batería (mAh) / Ipromedio) x 0,7
Vuelvo a repetir que esto es una aproximación e incluso se podría calcular el peor de los casos si en vez de utilizar la intensidad promedio se utiliza la intensidad dinámica.
El factor de 0,7 que se aplica a la capacidad de la batería es debido a que hay factores externos que afectan a la vida útil de la propia batería y por lo tanto, es difícil que una batería entregue el 100% de su capacidad.
Entonces, si tomamos el consumo medio de 80 mA de un ESP8266 como indica la hoja de características técnicas, la duración de una batería con una capacidad de 3.200 mAh sería
Duración (horas) = (3.200 / 80) x 0,7 = 28 horas
Esto viene a ser un día y cuatro horas, un tiempo realmente insuficiente comparado con otros dispositivos que pueden durar meses e incluso años.
Pero eso es debido a que un consumo de 80 mA, aunque parezca poco, es mucho para un dispositivo de bajo consumo. Si por ejemplo pretendes que tu batería dure un mes con este consumo, debería tener una capacidad de
Capacidad batería (mAh) = (Duración (horas) x Ipromedio)/0,7 = 720 x 80 / 0,7 = 82.285 mAh
Vamos, una batería bien hermosa.
Por lo tanto, si quieres aumentar la duración de la batería, es complicado (y caro) ampliar la capacidad de la batería. En estas situaciones lo más práctico para conseguir un bajo consumo con un ESP8266 es reducir el consumo dinámico y aumentar el consumo estático o en reposo.
En la siguiente sección vamos a ver cómo se puede hacer esto con un ESP8266 gracias a los modos de bajo consumo como el ESP8266 deep sleep.
Cuánto consume un ESP8266
El ESP8266 fue diseñado con un sistema de gestión de energía avanzado que opera en diferentes modos de consumo. En concreto puede funcionar en 4 modos. 1 modo activo y 4 modos de bajo consumo:
- Modo activo: el módulo WiFi está encendido y puede recibir, transmitir y escuchar. Obviamente, es el modo en el que más energía se consume.
- Modo modem suspendido o modem sleep: es el modo predeterminado del ESP8266 aunque solo se habilita cuando está conectado a un punto de acceso. Cuando entra en este modo la CPU está en funcionamiento pero el módulo WiFi se desactiva. Es posible activarlo y desactivarlo de forma automática.
- Modo sueño ligero o light sleep: en este modo se realizan las mismas funciones que en el modo modem suspendido pero también apaga el reloj del sistema y suspende la CPU. Ojo, que no apaga la CPU, la deja suspendida.
- Modo sueño profundo o deep sleep: en este modo solo el RTC está activo y esto permite al ESP8266 mantener la hora y contar el tiempo. El resto de componentes están apagados. Es el modo en el que menos energía se consume.
El consumo en cada modo depende del uso que se haga. Por ejemplo, en el modo activo el consumo es menor si no se utiliza WiFi que si se utiliza.
Lo mismo para el resto de modos salvo para el modo ESP8266 deep sleep donde el consumo se mantiene constante hasta que se despierta.
En la siguiente tabla puedes ver los consumos medios en cada uno de los modos del ESP8266.
| Modo | Consumo |
|---|---|
| Activo | Entre 56 mA y 170 mA |
| Modem sleep | 15 mA |
| Light sleep | 0,9 mA |
| Deep sleep | 20 µA |
Datos obtenidos del datasheet del ESP8266
Modos bajo consumo del ESP8266
Los modos modem sleep (modem suspendido) y light sleep (sueño ligero) son útiles cuando necesitas que el ESP8266 siga funcionando pero con solo algunas opciones activas.
Se pueden configurar fácilmente gracias a la función setSleepMode().
|
1 |
WiFi.setSleepMode(modo); |
Donde:
- modo: es el modo de ahorro de operación que quieres utilizar. Puede tomar 3 valores posibles.
- WIFI_NONE_SLEEP: para poner mono activo, sin ahorro de energía.
- WIFI_LIGHT_SLEEP: para poner modo sueño ligero.
- WIFI_MODEM_SLEEP: para poner modo modem suspendido.
Sin embargo, si realmente quieres hacer un dispositivo de bajo consumo debes utilizar el modo del ESP8266 deep sleep o sueño profundo.
Utilizando el modo ESP8266 deep sleep, la ejecución del código de un proyecto que funcione con pilas o baterías podría seguir estos pasos:
- Realiza una acción como leer un sensor y enviar los datos a una plataforma del IoT como ThingSpeak.
- Activar el modo de bajo consumo del ESP8266 deep sleep durante un tiempo configurado.
- Despertar el ESP8266.
Para poder utilizar el modo del ESP8266 deep sleep hay que utilizar la función deepSleep().
|
1 |
ESP.deepSleep(tiempo); |
Donde:
- tiempo: es el tiempo en microsegundos (µs) que se mantendrá el modo ESP8266 deep sleep. Algo curioso es que según la documentación oficial, el modo ESP8266 deep sleep solo puede durar unos 4.300 millones de µs lo que viene a ser unos 71 minutos. Este es el máximo de tiempo que puede estar en sueño profundo.
Bien, ahora vamos a ver cómo implementar el modo ESP8266 deep sleep en la práctica con el caso más básico.
ESP8266 deep sleep, ejemplo básico
El proceso que sigue la ejecución de código que hemos visto antes es la siguiente:
- Realizar una acción
- Modo ESP8266 deep sleep
- Despertar
Las dos primeras partes del proceso se realizan a nivel de programación pero la tercera, se hace a través de los pines GPIO 16 (D0) y el pin RST (reset).
El esquema eléctrico para NodeMCU y Wemos D1 Mini sería el siguiente.
Solo hay que conectar el pin RST con el pin GPIO 16 (D0) para que en el modo ESP8266 deep sleep pueda despertar el microcontrolador..
La explicación de esta conexión es que el pin GPIO 16 es un pin especial y se suele etiquetar como WAKE (despertar).
Cuando el ESP8266 se despierta del modo ESP8266 deep sleep hace que el pin GPIO 16, que está siempre en estado HIGH, pase a estado LOW.
Por otra parte, el pin RST siempre está en estado HIGH. Cuando recibe una señal LOW reinicia el microcontrolador.
Por lo tanto, cuando se despierta del modo ESP8266 deep sleep se reinicia el microcontrolador y vuelve al principio del proceso, realizar una acción y luego entrar en modo sueño profundo durante el tiempo configurado.
Código ESP8266 deep sleep
El código sería el siguiente.
|
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 |
/* Ejemplo de funcionamiento básico del modo ESP8266 deep sleep */ void setup() { Serial.begin(115200); // Esperara a que se inicie el monitor serie while (!Serial) { } /* Aquí iría el código para obtener los valores de un sensor y enviar la información alguna plataforma en la nube por ejemplo. Lo que viene a continuación es una simulación. */ Serial.println(" "); Serial.println("Temperatura: 25,5ºC"); delay(1000); Serial.println("Conectando red WiFi..."); delay(1000); Serial.println("Enviando información a ThingSpeak"); delay(1000); Serial.println("Modo ESP8266 deep sleep durante 10 segundos"); ESP.deepSleep(20e6); // 10e6 es 10.000.000 microsegundos Serial.println("Esto nunca se mostrará por el monitor serie"); } void loop() { } |
Antes de cargar el código desconecta el pin RST del pin GPIO 16 ya que esto no permite que el código se cargue en la placa desde el IDE de Arduino.
Carga el código, abre el monitor serie y cuando empiece a ejecutarse el programa, conecta el pin RST al GPIO 16. Esto hará que tras 10 segundos en el modo ESP8266 deep sleep se despierte.
En el monitor serie aparecerá algo parecido a esto.
Puedes comprobar cómo cada 10 segundos se reinicia y empieza la ejecución desde el principio del programa.
Todo el código que está después de llamar a la función ESP.deepSleep(20e6), no se ejecuta ya que una vez entra en el modo ESP8266 deep sleep, el microcontrolador se duerme y deja de ejecutar las siguientes sentencias. Cuando se despierta, empieza por el principio del código.
Y así de sencillo es utilizar el modo ESP8266 deep sleep donde se consiguen unos consumos entorno a los 20 µA.
Sin embargo, una pregunta que me he hecho con los años ha sido
Placas como NodeMCU o Wemos D1 mini ¿son capaces de alcanzar estos consumos tan bajos?
La respuesta es no. En la siguiente sección te presento una comparativa entre diferentes placas todas ellas basadas en el ESP8266.
Comparativa placas prototipado basadas en el ESP8266
Una de las incógnitas que quiero resolver con esta última sección del artículo es si todas las placas que hay en el mercado (o un gran número de ellas) son capaces de alcanzar los 20 µA del modo ESP8266 deep sleep.
Para poder hacer esta investigación he utilizado las siguientes herramientas:
- Medidor de consumo Current Ranger.
- Fuente de alimentación Eventek DC 0-30V / 0-10A
- Aislador y protector USB para Current Ranger
Las placas y módulos que he utilizado han sido las siguientes:
- NodeMCU clon
- NodeMCU Amica
- Wemos D1 Mini clon
- Wemos D1 Mini Wavgat
- Wemos D1 Mini Lolin
- Módulo ESP-12
- Módulo ESP-01
El esquema de conexión de todas las herramientas y componentes sería el siguiente.
La alimentación de las placas NodeMCU y Wemos se hace a través del pin 3V3 de las placas. La toma de tierra de la fuente a un pin GND de la placa.
En la parte del PC, he creado un script en Python que recoge las medidas que se obtienen del Current Ranger a través del puerto serie.
Debido a que en el modo ESP8266 deep sleep la diferencia es de 1.000 veces menor (en modo activo consume miliamperios y en modo ESP8266 deep sleep consume microamperios), el Current Ranger dispone de un modo que cambia de escala automáticamente.
Todo esto queda registrado en un archivo CSV que posteriormente trato adecuadamente para obtener las gráficas y así poder sacar mis propias conclusiones.
Pero antes veamos el código con el que vamos a probar todas las placas basadas en el ESP8266.
Código para medición consumo del ESP8266
El código para probar el consumo de un ESP8266 es el siguiente.
|
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 |
// Incluir la librería ESP8266WiFi #include <ESP8266WiFi.h> #include <ESP8266HTTPClient.h> #include <WiFiClient.h> // Parámetros de la red WiFi char ssid[] = "TU-SSID"; // Tu SSID de red (nombre de la red WiFi) char pass[] = "TU-PASS"; // Contraseña de tu red WiFi void setup() { Serial.begin(9600); Serial.println(""); Serial.println("INICIO"); // Establecer modo estación WiFi.mode(WIFI_STA); // Conexión con red WiFi WiFi.begin(ssid, pass); Serial.println("INICIO WIFI"); Serial.println(millis()); // Ahora esperamos hasta que la conexión se ha establecido while (WiFi.status() != WL_CONNECTED) { delay(500); } Serial.println(millis()); Serial.println("FIN WIFI"); Serial.println("INICIO WIFICLIENT"); Serial.println(millis()); // Petición HTTP WiFiClient client; HTTPClient http; if (http.begin(client, "http://jigsaw.w3.org/HTTP/connection.html")) { int httpCode = http.GET(); if (httpCode > 0) { if (httpCode == HTTP_CODE_OK || httpCode == HTTP_CODE_MOVED_PERMANENTLY) { String payload = http.getString(); } } http.end(); } else { Serial.println("ERROR WIFICLIENT"); } Serial.println(millis()); Serial.println("FIN WIFICLIENT"); delay(1000); Serial.println("INICIO ESP8266 DEEP SLEEP"); delay(1000); Serial.end(); Serial.println(millis()); // Entra en modo ESP8266 deep sleep durante 10 segundos ESP.deepSleep(10e6); } void loop() { } |
Es un código muy sencillo que hace las siguientes operaciones.
Se establece el modo estación y se inicia la conexión con la red WiFi. Esta parte es donde más va a consumir el ESP8266.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
Serial.begin(9600); Serial.println(""); Serial.println("INICIO"); // Establecer modo estación WiFi.mode(WIFI_STA); // Conexión con red WiFi WiFi.begin(ssid, pass); Serial.println("INICIO WIFI"); Serial.println(millis()); // Ahora esperamos hasta que la conexión se ha establecido while (WiFi.status() != WL_CONNECTED) { delay(500); } Serial.println(millis()); Serial.println("FIN WIFI"); |
La siguiente parte del código hace una petición HTTP.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
Serial.println("INICIO WIFICLIENT"); Serial.println(millis()); // Petición HTTP WiFiClient client; HTTPClient http; if (http.begin(client, "http://jigsaw.w3.org/HTTP/connection.html")) { int httpCode = http.GET(); if (httpCode > 0) { if (httpCode == HTTP_CODE_OK || httpCode == HTTP_CODE_MOVED_PERMANENTLY) { String payload = http.getString(); } } http.end(); } else { Serial.println("ERROR WIFICLIENT"); } Serial.println(millis()); Serial.println("FIN WIFICLIENT"); |
La última parte hace que el microcontrolador entre en modo ESP8266 deep sleep.
|
1 2 3 4 5 6 7 |
Serial.println("INICIO esp8266 DEEP SLEEP"); delay(1000); Serial.end(); Serial.println(millis()); // Entra en modo ESP8266 deep sleep durante 10 segundos ESP.deepSleep(10e6); |
Como puedes ver en el código he utilizado llamadas a la función Serial.println() para enviar información por el monitor serie, en realidad no hay una conexión entre el puerto serie del ESP8266 y el ordenador.
Esto es debido a que en las pruebas realizadas, al conectar un FTDI a los pines RX y Tx, se producía un consumo extra debido a alguna corriente parásita.
Es del orden de cientos de microamperios y por este motivo, en las pruebas finales, he decidido no incluir esta parte en el esquema de conexión.
A continuación te muestro los resultados obtenidos divididos por placas y por modo de funcionamiento: modo activo y modo ESP8266 deep sleep.
Vamos a empezar por los módulos ESP-01 y ESP-12
Consumo de un ESP-01 y ESP-12
El módulo ESP-01 fue el primer módulo que venía con un ESP8266. Es el origen de todo lo que ha vendido después.
Uno de los grandes inconvenientes es que no está accesible el pin GPIO 16 a través de los módulos. Esto imposibilita poder conectar este pin con el RST siendo así imposible despertar al microcontrolador.
Sin embargo, si que se puede acceder al pin GPIO 16 através del propio ESP8266. Se puede conectar un cable del pin GPIO 16 al pin RST directamente.
Ojo, que si lo sueldas directamente hay alguna ocasión donde al intentar subir el código fallará y tendrás que desconectarlo, mejor poner un pulsador para desconectar el pin GPIO 16 del RST.
No es una tarea sencilla pero se puede hacer.
Necesitas un FTDI o conversor serie USB para cargar un progrma.
El módulo ESP-12 es el módulo que llevan gran parte de las placas basadas en Wemos D1 Mini y NodeMCU.
Para poder programarlo hay que utilizar un FTDI y poner el ESP8266 en modo carga de programa.
Todo esto se sale fuera de este tutorial y lo dejo para un próximo artículo.
Lo importante son las pruebas de consumo. Empezamos con el consumo del ESP-01 y ESP-12 en modo activo.
Consumo modo activo ESP-01 y ESP-12
Se puede ver que más o menos el consumo medio ronda los 67 mA y cabe destacar que el ESP-01 (rojo) tiene unos picos de consumo de 80 mA.
En la siguiente tabla tienes un resumen de los datos.
| ESP-01 | ESP-12 | |
|---|---|---|
| Mínimo | 65,26 mA | 70,9 mA |
| Máximo | 80,57 mA | 63,65 mA |
| Media | 67,41 mA | 66,93 mA |
Consumo modo ESP8266 deep sleep ESP-01 ESP-12
Aquí es donde está la gran diferencia entre estos dos módulos, en el consumo en el modo ESP8266 deep sleep.
Mientras que el ESP-01 consume 365 µA, el ESP-12 consigue un bajo consumo de 18 µA. Todo un logro.
En la siguiente tabla tienes un resumen de los datos más relevantes.
| ESP-01 | ESP-12 | |
|---|---|---|
| Mínimo | 364 µA | 16 µA |
| Máximo | 365 µA | 19 µA |
| Media | 365 µA | 18 µA |
A continuación vamos con la comparativa entre placas NodeMCU.
Consumo de una placa NodeMCU
He utilizado dos placas NodeMCU v2 de distintos fabricantes. Hay una placa de la marca Amica y otra que no tiene el nombre del fabricante. A esta última la he llamado clon.
En todas ellas se utiliza el regulador de tensión AMS1117. Y aunque el pin 3V3 no tendría que pasar por dicho regulador, la realidad es que los consumos en modo ESP8266 deep sleep se disparan.
Esto hace sospechar que realmente el pin 3V3 está conectado al regulador de tensión.
Veamos los resultados.
Consumo modo activo NodeMCU
En el modo activo no hay grandes diferencias con los módulos ESP-01 y ESP-12 aunque el consumo medio aumenta en torno a 10 mA.
| NodeMCU Amica | NodeMCU clon | |
|---|---|---|
| Mínimo | 74,12 mA | 74,93 mA |
| Máximo | 79,76 mA | 78,96 mA |
| Media | 76,17 mA | 76,27 mA |
Consumo modo ESP8266 deep sleep NodeMCU
Aquí es donde realmente encontramos la diferencia con los módulos y con las placas Wemos, como veremos después. Pasa de consumir µA a consumir mA en el modo ESP8266 deep sleep.
Y esto es algo inaceptable si quiere alimentar una placa NodeMCU con una pila o batería.
| NodeMCU Amica | NodeMCU clon | |
|---|---|---|
| Mínimo | 8,06 mA | 8,06 mA |
| Máximo | 8,86 mA | 8,06 mA |
| Media | 8,84 mA | 8,06 mA |
Consumo de una placa Wemos D1 Mini
Las placas Wemos D1 Mini son de mis favoritas. Son pequeñas, se pueden acoplar shields fácilmente y además, como veremos a continuación, con la placa Lolin se consiguen unos consumos en modo ESP8266 deep sleep muy buenos.
Sin tener en cuenta los módulos ESP-01 y ESP-12, son la mejor elección que puedes hacer.
He probado 3 placas de diferentes marcas: Wavgat, Lolin y otra sin marca que he llamado clon. Muy original :)
Los resultados obtenidos son los siguientes.
Consumo modo activo Wemos D1 Mini
Todas las placas Wemos D1 Mini tienen un consumo medio parecido sin embargo, se pueden apreciar picos de consumo tanto en la placa Wavgat como en la clon.
Esto puede ser debido al propio ruido en la medición y no suponen un consumo excesivo.
Estos son los datos obtenidos de la gráfica anterior.
| Wemos D1 Mini clon | Wemos D1 Mini Lolin | Wemos D1 Mini Wavgat | |
|---|---|---|---|
| Mínimo | 65,26 mA | 63,65 mA | 66,87 mA |
| Máximo | 88,62 mA | 66,06 mA | 94,26 mA |
| Media | 69,53 mA | 65,04 mA | 69,47 mA |
Consumo modo ESP8266 deep sleep Wemos D1 Mini
Las grandes diferencias de estas tres placas las encontramos en el modo ESP8266 deep sleep ya que se consiguen consumos algo dispares.
Esto es debido a que la placa Wemos D1 Mini clon y Wavgat utilizan el regulador de tensión 4A2D. La placa Lolin utiliza un regulador S2RH que parece ser un clon del LP2983.
De aquí la diferencia de consumo. Incluso puede que la placa Lolin se salte el regulador y alimente directamente el ESP8266 a través del pin 3V3.
Los datos obtenidos son los siguientes.
| Wemos D1 Mini clon | Wemos D1 Mini Lolin | Wemos D1 Mini Wavgat | |
|---|---|---|---|
| Mínimo | 144 µA | 75 µA | 206 µA |
| Máximo | 147 µA | 80 µA | 214 µA |
| Media | 156 µA | 78 µA | 209 µA |
Conclusiones ESP8266 deep sleep
He vivido obsesionado con los consumos del ESP8266 durante mucho tiempo. Siempre he sido un fiel defensor de poder utilizar los módulos ESP-01 y ESP-12 y las placas Wemos D1 Mini y NodeMCU con baterías o pilas.
Pero nunca había tenido la posibilidad de saber el consumo real aproximado de cada placa basada en el ESP8266 hasta que he adquirido un Current Ranger.
Una cosa es lo que aparece en la hoja de características técnicas y otra bien diferente la realidad.
El módulo con el que más bajo consumo se ha conseguido ha sido el módulo ESP-12 consiguiendo una media de 18 µA en modo ESP8266 deep sleep y de 66,93 mA en modo activo.
Esto nos permite utilizar el módulo ESP-12 con baterías y conseguir una duración de meses e incluso, si haces un uso extensivo del modo deep sleep, se podría alargar hasta un año.
Todo está en cómo lo programes y los requerimientos de tu proyecto.
Por otro lado, si tu opción es utilizar una placa porque te resulta más sencillo, te recomiendo utilizar una Wemos D1 Mini de la marca Lolin. Con diferencia son las que menos consumen.
En modo ESP8266 deep sleep consume 78 µA y en modo activo 65,04 mA.
Y con esto me despido. Espero te haya gustado el artículo y cualquier duda, pregunta o comentario, lo puedes hacer aquí abajo.