¿Alguna vez has querido crear tu propia estación meteorológica de bajo consumo de energía? En este artículo, te mostraremos cómo utilizar el ESP8266 y el sensor BME280 junto con MicroPython para construir un registrador de datos de estación meteorológica eficiente y fácil de implementar. ¡Sigue leyendo para descubrir cómo puedes monitorear el clima con este proyecto!
Este proyecto muestra cómo construir un registrador de datos que publique valores de temperatura, humedad y presión en una hoja de cálculo de Google Sheets cada 10 minutos utilizando un ESP8266 12-E. Entre lecturas del sensor, el ESP está en modo de suspensión profunda y solo consume 7μA. La placa ESP se programa usando MicroPython y utilizamos el servicio webhooks IFTTT para integrar el proyecto con Google Sheets.
Este proyecto también es compatible con el ESP32. Todo lo que necesitas hacer es realizar algunos cambios en el código (te mostraremos lo que necesitas).
A lo largo de este proyecto aprenderás los siguientes conceptos:
- Lea la temperatura, la humedad y la presión con BME280 y ESP8266/ESP32 usando MicroPython;
- Realice solicitudes de publicación HTTP en MicroPython para enviar valores de sensores a un servicio de terceros;
- Utilice los servicios de webhook IFTTT para almacenar valores de sensores en una hoja de cálculo de Google Sheets.
- Ponga el ESP8266/ESP32 en modo de suspensión profunda y despiértelo con un temporizador;
- Obtenga más información sobre el sueño profundo en MicroPython:
- ESP8266 Fuentes de sueño profundo y despertar
- Fuentes ESP32 Deep Sleep y Wake Up
Firmware de MicroPython
Para seguir este tutorial, necesitará el firmware MicroPython actualizado en su ESP32 o ESP8266. También necesitarás un IDE para escribir el código y subirlo a tu placa. Recomendamos utilizar Thonny IDE o uPyCraft IDE:
- IDE de Thonny:
- Instalación y primeros pasos con Thonny IDE
- Actualización del firmware MicroPython con esptool.py
- IDE de UpyCraft:
- Instale uPyCraft IDE (Windows, Mac OS X, Linux)
- Flashear/cargar firmware MicroPython a ESP32 y ESP8266
Creando su cuenta IFTTT
En este proyecto, publicamos los valores de los sensores en una hoja de cálculo de Google Sheets. Para ello utilizamos los servicios de webhook de IFTTT. Entonces necesitas crear una cuenta gratuita con IFTTT.
Al sitio web oficial ifttt.comingrese su dirección de correo electrónico y complete su cuenta para comenzar.
Creando un subprograma
A continuación necesitas crear un nuevo subprograma. Siga los siguientes pasos para crear un nuevo subprograma:
1) Ir a «Mis subprogramas«y cree un nuevo subprograma haciendo clic en «Nuevo subprograma» botón.
2) Clickea en el «El“palabra que es azul, como se resalta en la imagen a continuación.
3) Estás buscando «Ganchos web” y seleccione el Ganchos web Símbolo.
4) Selecciona el «Recibir una solicitud web» desencadenar.
5) Dale un nombre al evento. En este caso utilizamos “bme_280_valores medidos”Y recomendamos usar exactamente el mismo nombre de evento que se muestra en la imagen a continuación. Luego haga clic en “Crear disparadores» botón.
6) Presione el «El«, continuar.
7) Estás buscando «Hojas de cálculo de Google”servicio y seleccione el Hojas de cálculo de Google Símbolo.
8vo) Si aún no se ha conectado al servicio Google Sheets, deberá hacer clic en «Conectar» botón.
9) Selecciona el «Agregar una fila a la tabla«Acción.
10) Luego complete los campos de acción. Asigne un nombre a la tabla y deje los demás campos como predeterminados. Finalmente haga clic en “Crear acción» botón.
11) Su subprograma debe crearse después de completar el «Finalizar» botón.
Probando su subprograma
Antes de continuar con el proyecto, es muy importante probar primero su subprograma. Siga los siguientes pasos para probar su subprograma.
1) Ir a Página de servicio de webhooksy haga clic en “documentación» botón.
2) Aparecerá una página como la siguiente imagen. La página mostrará su clave API única. No debes compartir tu clave API única con nadie.
Llénalo «Cómo desencadenar un evento”Sección como se muestra a continuación: está resaltada con rectángulos rojos. Luego haga clic en “intentalo» botón.
Nota: Guarde su clave API IFTTT, ya que la necesitará más adelante en este proyecto.
3) El evento debería activarse exitosamente y recibirá un mensaje verde como se muestra a continuación que dice «El evento fue desencadenado“.
4) Vaya a su Google Drive. El servicio IFTTT debe tener una carpeta llamada «IFTTT» con el «MakerWebooks/bme280”carpeta en ella. En esta carpeta encontrará el Bme_280_Valores medidos Hoja de cálculo.
5) Abra la hoja de cálculo. Ahora deberías tener los valores que ingresaste anteriormente para probar el subprograma.
Continúe leyendo este tutorial para aprender cómo integrar el servicio IFTTT Google Sheets en su ESP8266 o ESP32.
Piezas requeridas
Aquí hay una lista de las piezas que necesitará para construir el circuito para este proyecto:
- ESP8266-12-E – leer Las mejores placas de desarrollo Wi-Fi ESP8266
- Adaptador ESP8266 12E
- programador FTDI
- [Alternative] placa ESP32 – leer Comparación de placas de desarrollo ESP32
- Módulo de sensores BME280
- [Optional] Circuito regulador de voltaje para baterías LiPo y Li-ion
- Cables de puente
- tablero de circuitos
Para este proyecto estamos utilizando el ESP8266 12-E porque consume menos energía en modo de suspensión profunda (no tiene programador incorporado). Tu puedes tener uno tambien ESP8266 NodoMCU kit o un Placa de desarrollo ESP32.
Puedes utilizar los enlaces anteriores o ir directamente MakerAdvisor.com/tools ¡Para encontrar todas las piezas para tus proyectos al mejor precio!
Cargando código al chip ESP8266 12-E
Para cargar código al ESP-12E, se debe establecer una conexión en serie entre su ESP8266 y un programador FTDI, como se muestra en el esquema a continuación.
- RX-TX
- TX-RX
- VCC – VCC
- VCC-DE
- masa – masa
- Tierra – GPIO15
- Tierra – GPIO0
Si desea obtener más información sobre los pines ESP12 E y su uso, puede leer nuestra guía de referencia de distribución de pines ESP8266.
Instalación de la biblioteca BME280
La biblioteca para leer desde el sensor BME280 no forma parte del firmware estándar de MicroPython. Entonces necesitas cargar la biblioteca en tu placa ESP8266/ESP32.
En uPyCraft IDE, cree un nuevo archivo presionando Botón nuevo archivo (1). Copie el código de la biblioteca BME280 en él. El código de la biblioteca BME280 se puede encontrar en el siguiente enlace:
Guarde el archivo presionando Botón guardar (2).
Nombra este nuevo archivo “BME280.py» y presione DE ACUERDO.
presione eso Descargar y ejecutar Botón.
Nota: Si tiene problemas para cargar un nuevo script en su placa ESP, es posible que deba actualizar el firmware MicroPython en su placa: Flashear/Cargar firmware MicroPython a ESP. Cuando ESP está en modo de suspensión profunda, no puede cargar nuevos scripts. Asegúrese de restablecer su tablero y presione inmediatamente el botón de detener en uPyCraft IDE para reactivarlo y poder acceder a los scripts guardados y cargar otros nuevos.
El archivo debe estar en la carpeta del dispositivo llamada «BME280.py“, como se destaca en la imagen a continuación.
Ahora puede utilizar las funciones de la biblioteca en su código importando la biblioteca.
código
Después de cargar el BME280.py Archivo en su ESP8266 o ESP32, copie el siguiente código en el arranque.py Archivo. El arranque.py El archivo se ejecuta una vez en el arranque (es decir, cada vez que ESP8266/ESP32 se activa).
# Complete project details at https://RandomNerdTutorials.com
import machine
from machine import Pin, I2C
import BME280
import network
import urequests
from time import sleep
import esp
esp.osdebug(None)
import gc
gc.collect()
ssid = 'REPLACE_WITH_YOUR_SSID'
password = 'REPLACE_WITH_YOUR_PASSWORD'
api_key = 'REPLACE_WITH_YOUR_IFTTT_API_KEY'
ms_sleep_time = 600000
station = network.WLAN(network.STA_IF)
station.active(True)
station.connect(ssid, password)
while station.isconnected() == False:
pass
print('Connection successful')
print(station.ifconfig())
def deep_sleep(msecs) :
# configure RTC.ALARM0 to be able to wake the device
rtc = machine.RTC()
rtc.irq(trigger=rtc.ALARM0, wake=machine.DEEPSLEEP)
# set RTC.ALARM0 to fire after X milliseconds (waking the device)
rtc.alarm(rtc.ALARM0, msecs)
# put the device to sleep
machine.deepsleep()
# ESP8266 - Pin assignement
i2c = I2C(scl=Pin(5),sda=Pin(4), freq=10000)
# ESP32 - Pin assignement
#i2c = I2C(scl=Pin(22),sda=Pin(21), freq=10000)
try:
bme = BME280.BME280(i2c=i2c)
temp = bme.temperature
hum = bme.humidity
pres = bme.pressure
# uncomment for temperature in Fahrenheit
#temp = (bme.read_temperature()/100) * (9/5) + 32
#temp = str(round(temp, 2)) + 'F'
sensor_readings = {'value1':temp[:-1], 'value2':hum[:-1], 'value3':pres[:-3]}
print(sensor_readings)
request_headers = {'Content-Type': 'application/json'}
request = urequests.post(
'http://maker.ifttt.com/trigger/bme280/with/key/' + api_key,
json=sensor_readings,
headers=request_headers)
print(request.text)
request.close()
except OSError as e:
print('Failed to read/publish sensor readings.')
sleep(10)
#ESP8266
deep_sleep(ms_sleep_time)
#ESP32
#machine.deepsleep(ms_sleep_time)
Antes de cargar el código en su placa, debe proporcionar sus propias credenciales de red y una clave API IFTTT única. Continúe leyendo para aprender cómo hacer esto.
Cómo funciona el código
Echemos un vistazo rápido al código y veamos cómo funciona.
Importando bibliotecas
Empiece por importar los módulos necesarios. Para interactuar con los GPIO y leer datos del sensor a través de la comunicación I2C, debe usar el Bolígrafo Y I2C clases de la máquina Módulo. También importas el completo máquina Módulo para poder utilizar funciones relacionadas con el sueño profundo.
import machine
from machine import Pin, I2C
Tienes que BME280 Biblioteca que subiste previamente al tablero.
import BME280
Para conectarse a su red, debe red Módulo.
import network
Usted necesita que Peticiones Biblioteca. Esta biblioteca le permite realizar solicitudes HTTP. En este ejemplo, solicitamos a los servicios IFTTT que publiquen los valores del sensor en una hoja de cálculo de Google Sheets.
import urequests
Finalmente importe eldormir función de la Tiempo Módulo para poder agregar retrasos al código.
from time import sleep
Configuración de sus credenciales de red
Debes poner tu SSID y contraseña en las siguientes variables:
ssid = 'REPLACE_WITH_YOUR_SSID'
password = 'REPLACE_WITH_YOUR_PASSWORD'
Incluyendo su clave API IFTTT
Pegue su clave API única del servicio Webhooks IFTTT en la siguiente línea:
api_key = 'REPLACE_WITH_YOUR_WEBHOOKS_IFTTT_API_KEY'
Configurar el tiempo de sueño
En este ejemplo, hemos establecido el tiempo de suspensión en 10 minutos (600.000 milisegundos). Esto significa que cada 10 minutos el ESP se activa, recopila las mediciones y las publica en su hoja de cálculo de Google Sheets. El período de descanso será en ms_sleep_time Variable en milisegundos:
ms_sleep_time = 600000
Advertencia: Si establece un período de tiempo muy corto, puede exceder el límite de solicitudes establecido por los servicios IFTTT.
Conexión a la red
Las siguientes líneas conectan el ESP8266/ESP32 a su enrutador e imprimen la dirección IP del ESP:
station = network.WLAN(network.STA_IF)
station.active(True)
station.connect(ssid, password)
while station.isconnected() == False:
pass
print('Connection successful')
print(station.ifconfig())
Función de sueño profundo (ESP8266)
Luego crea una función llamada sueño profundo() que acepta como argumento la cantidad de milisegundos que el ESP8266 debe estar en modo de suspensión profunda.
def deep_sleep(msecs) :
# configure RTC.ALARM0 to be able to wake the device
rtc = machine.RTC()
rtc.irq(trigger=rtc.ALARM0, wake=machine.DEEPSLEEP)
# set RTC.ALARM0 to fire after X milliseconds (waking the device)
rtc.alarm(rtc.ALARM0, msecs)
# put the device to sleep
machine.deepsleep()
Nota: Si está utilizando un ESP32, no necesita crear/usar esta función.
Lectura de temperatura, humedad y presión.
Luego crea uno I2C Instancia llamada i2c. Lo necesitará para establecer una conexión I2C con el sensor BME280. Pase los pines SCL y SDA y una frecuencia como argumentos. No te preocupes por la frecuencia, un valor de 10000 Hz funciona bien para este sensor.
Los pines I2C estándar del ESP8266 son GPIO5 (SLC) y GPIO4 (ADS).
i2c = I2C(scl=Pin(5),sda=Pin(4), freq=10000)
Los pines I2C estándar ESP32 son GPIO22 (SCL) y GPIO21 (ADS). Comente la línea anterior y descomente la siguiente línea si está utilizando una placa ESP32.
#i2c = I2C(scl=Pin(22),sda=Pin(21), freq=10000)
Entonces usa intentarExcepto declaraciones. En el intentar Leemos las instrucciones del sensor y enviamos una solicitud de publicación HTTP a los servicios IFTTT.
La temperatura estará en el temperatura variable, la humedad en el zumbido variable, y la presión sobre el Prensa Variable.
try:
bme = BME280.BME280(i2c=i2c)
temp = bme.temperature
hum = bme.humidity
pres = bme.pressure
Descomente las siguientes líneas si desea obtener la temperatura en grados Fahrenheit.
# uncomment for temperature in Fahrenheit
#temp = (bme.read_temperature()/100) * (9/5) + 32
#temp = str(round(temp, 2)) + 'F'
Luego guarde los valores del sensor en formato JSON. Valores de los sensores Variable. Esto es necesario para realizar la solicitud HTTP POST a IFTTT.
sensor_readings = {'value1':temp[:-1], 'value2':hum[:-1], 'value3':pres[:-3]}
La biblioteca BME280 devuelve las mediciones con unidades (C para temperatura, % para humedad y hpa para presión). Para que sea más fácil analizar los datos más adelante, eliminamos las unidades agregando [:-1] para eliminar el último carácter de la cadena. [:-3] para imprimir, los últimos tres caracteres se eliminan de la cadena (hpa).
Solicitud de publicación HTTP
Una solicitud HTTP POST general en MicroPython usando el Peticiones La biblioteca tiene el siguiente formato:
request= requests.post(<your_url>, json=<json_data>, headers=<headers>)
El primer parámetro es la URL en la que realiza la solicitud. Como vimos en el subprograma IFTTT, necesitamos usar la siguiente URL (en el Clave API se reemplaza con su propia clave API):
http://maker.ifttt.com/trigger/bme_280_readings/with/key/your_api_key
El parámetro JSON debe contener datos en formato JSON. En nuestro caso eso es todo. Valores de los sensores Variable:
json=sensor_readings
El titulares El parámetro contiene información sobre la solicitud. Para nuestra solicitud, los encabezados deberían verse así:
request_headers = {'Content-Type': 'application/json'}
Finalmente presentamos la solicitud con el Oficina de correos() Método con la información que definimos antes:
request = urequests.post(
'http://maker.ifttt.com/trigger/bme_280_readings/with/key/' + api_key,
json=sensor_readings,
headers=request_headers)
Finalmente, imprima la solicitud y cierre la conexión:
print(request.text)
request.close()
Si falla la lectura de los datos del sensor o la publicación de los valores del sensor, excepto Se ejecuta la instrucción e imprimimos el mensaje «Los valores del sensor no se pudieron leer/publicar».
except OSError as e:
print('Failed to read/publish sensor readings.')
Las declaraciones Except en MicroPython evitan que su placa falle en caso de error.
Ve a dormir
Después de realizar la solicitud HTTP POST, ponemos el ESP8266/ESP32 en modo de suspensión profunda. Utilice la siguiente línea si está utilizando un ESP8266:
deep_sleep(sleep_time_ms)
Comente la línea anterior y descomente la siguiente línea si usa un ESP32:
#machine.deepsleep(ms_sleep_time)
Para usar el sueño profundo con el ESP32 con temporizador de activación, solo necesitamos sueño profundo() Método y pasa el tiempo de sueño en milisegundos como argumento.
Estructura del circuito
El sensor BME280 que utilizamos se comunica mediante el protocolo de comunicación I2C.
Dependiendo de la placa que esté utilizando, siga uno de los siguientes esquemas.
ESP8266-12-E
Importante: Solo después de cargar el código se debe conectar GPIO16 al pin RST. Esta conexión es necesaria para que el ESP8266 se active por sí solo.
Nota: Si está utilizando un ESP8266 12-E, le recomendamos usarlo un adaptador para usarlo con una placa de pruebas y simplificar el cableado. Alternativamente, también puedes hacer una placa de circuito en casa como lo hicimos nosotros. Utilizamos la técnica del grabado.
ESP8266 NodoMCU kit
Si está utilizando un kit ESP8266 NodeMCU, también debe conectar el pin RST a GPIO 16 (D0) después de cargar el código.
ESP32
Si está utilizando un ESP32, sólo necesita cablear el circuito como se muestra en el esquema:
demostración
Después de cargar los archivos requeridos a su tablero en el siguiente orden:
- BME280.py
- arranque.py
El ESP8266/ESP32 comienza a publicar los valores del sensor en la hoja de cálculo de Google Sheets.
el consumo de energía
Cuando el ESP8266 12-E está en modo de suspensión profunda, consume entre 7 y 8 uA.
Cuando el ESP8266 se activa y se conecta a WiFi, el consumo de energía puede ser de hasta 80 mA.
Si utiliza una placa de desarrollo ESP, habrá un mayor consumo de energía durante el sueño profundo.
Alimentando el ESP8266/ESP32 con baterías
Si construye este proyecto con el chip ESP8266 12E, consumirá muy poca energía (alrededor de 7uA) en modo de sueño profundo. Puedes alimentarlo con baterías y te durarán varios meses (o incluso años dependiendo de la capacidad).
Planeamos crear una segunda parte de este proyecto utilizando un circuito alimentado por batería. Mientras tanto, puedes leer este tutorial para alimentar el ESP usando baterías LiPo y Li-ion.
Envolver
En este proyecto, aprendió a crear un registrador de datos que publica los valores del sensor en una hoja de cálculo de Google Sheets. En las instrucciones, aprendió a usar BME280, realizar solicitudes HTTP POST y usar Deep Sleep con ESP8266/ESP32 usando MicroPython.
Esperamos que este proyecto te haya resultado interesante. Usted también puede estar interesado en:
- [eBook] Programación MicroPython con ESP32 y ESP8266
- Fuentes de activación y suspensión profunda ESP8266 (MicroPython)
- Fuentes de activación y suspensión profunda ESP32 (MicroPython)
- Servidor web ESP32 con BME280 – mini estación meteorológica (Arduino IDE)
- ESP32 publica valores de sensores en Google Sheets (compatible con ESP8266) (Arduino IDE)
Gracias por leer.
Registrador de datos de estación meteorológica de bajo consumo con ESP8266 y BME280
Este proyecto muestra cómo construir un registrador de datos que publica lecturas de temperatura, humedad y presión cada 10 minutos en una hoja de cálculo de Google Sheets utilizando un ESP8266 12-E. Entre las lecturas de sensores, el ESP está en modo de suspensión profunda y solo consume 7μA. La placa ESP está programada utilizando MicroPython y utilizamos el servicio de Webhooks de IFTTT para integrar el proyecto con Google Sheets.
Preguntas Frecuentes
-
¿Cuáles son los conceptos que aprenderé en este proyecto?
En este proyecto aprenderás a leer temperatura, humedad y presión con el BME280 y ESP8266/ESP32 utilizando MicroPython, realizar solicitudes HTTP en MicroPython para enviar lecturas de sensores a un servicio de terceros, utilizar los servicios de Webhooks de IFTTT para guardar lecturas de sensores en una hoja de cálculo de Google Sheets, poner el ESP8266/ESP32 en modo de suspensión profunda y despertarlo con un temporizador.
-
¿Cómo puedo flashear el firmware de MicroPython en mi ESP32 o ESP8266?
Puedes utilizar Thonny IDE o uPyCraft IDE para flashear el firmware de MicroPython en tu placa ESP32 o ESP8266. Puedes encontrar más información detallada sobre cómo hacerlo en los siguientes enlaces: Thonny IDE, uPyCraft IDE.
-
¿Cómo creo una cuenta en IFTTT para usar los Webhooks?
Debes crear una cuenta gratuita en IFTTT en su sitio web oficial. Simplemente ingresa tu correo electrónico y completa tu cuenta para comenzar: ifttt.com.
-
¿Cuáles son los componentes necesarios para construir este proyecto?
Los componentes necesarios incluyen un ESP8266 12-E, un adaptador para el ESP8266, un programador FTDI, un módulo de sensor BME280, cables jumper, una protoboard, entre otros. Puedes encontrar una lista detallada de las partes en este proyecto y dónde adquirirlas al mejor precio en MakerAdvisor.com.
Para obtener más detalles sobre la implementación de este proyecto, te recomendamos seguir las instrucciones detalladas proporcionadas en la fuente original de inspiración: Random Nerd Tutorials.
¡Interesante proyecto! Me gustaría saber más sobre cómo se configura y se utiliza el registrador de datos. ¡Gracias por compartir!
¡Suena genial este proyecto! Me encantaría aprender más sobre cómo funciona y cómo puedo hacer uno yo también. Gracias por la información. ¡Saludos!