¿Estás interesado en crear tu propio sistema de monitoreo ambiental con tu ESP32 o ESP8266? En este artículo te enseñaremos cómo utilizar MicroPython junto con el sensor BME280 para medir la presión, temperatura y humedad en tiempo real. ¡Sigue leyendo para aprender a realizar esta interesante y útil implementación!
En esta guía, aprenderá a utilizar el módulo sensor BME280 con ESP32 y ESP8266 para obtener valores de presión, temperatura y humedad utilizando el firmware MicroPython. Crearemos un ejemplo sencillo para que se familiarice con el sensor y un servidor web para mostrar las lecturas del sensor.
requisitos
Para seguir este tutorial, debe tener instalado el firmware MicroPython en sus placas 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:
- Comenzando con uPyCraft IDE
- Instale uPyCraft IDE (Windows, Mac OS X, Linux)
- Flashear/cargar firmware MicroPython a ESP32 y ESP8266
Obtenga más información sobre MicroPython: Programación de MicroPython con ESP32 y ESP8266 eBook.
Quizás también quieras leer otras guías de BME280:
- ESP32 con sensor BME280 usando Arduino IDE
- Servidor web ESP32 con BME280 – estación meteorológica
- ESP8266 con BME280 usando Arduino IDE
- Placa Arduino con BME280
Introducción del módulo de sensor BME280
El Módulo de sensores BME280 Mide la presión del aire, la temperatura y la humedad. Dado que la presión cambia con la altitud, también se puede estimar la altitud. Existen varias versiones de este módulo de sensor, pero usaremos la que se muestra en la imagen a continuación.
Este sensor se comunica mediante el protocolo de comunicación I2C, por lo que el cableado es muy sencillo. Puede utilizar los pines estándar ESP32 o ESP8266 I2C como se muestra en la siguiente tabla:
| BME280 | ESP32 | ESP8266 |
| vino | 3,3 V | 3,3 V |
| Dimensiones | Dimensiones | Dimensiones |
| SCL | GPIO22 | GPIO5 (D1) |
| ASD | GPIO21 | GPIO4 (D2) |
Piezas requeridas
Para este proyecto, necesita conectar el módulo del sensor BME280 a los pines I2C del ESP32 o ESP8266. Aquí hay una lista de las piezas que necesitará para este tutorial:
- Módulo de sensores BME280
- ESP32 o ESP8266 (leer ESP32 frente a ESP8266)
- tablero de circuitos
- Cables de puente
Puedes utilizar los enlaces anteriores o ir directamente MakerAdvisor.com/tools ¡Para encontrar todas las piezas para tus proyectos al mejor precio!
Diagrama de cableado – ESP32
Siga el siguiente diagrama esquemático si está utilizando una placa ESP32:
Recomendaciones de literatura: Guía de referencia de asignación de pines ESP32
Diagrama de circuito – ESP8266
Siga el siguiente esquema si está utilizando una placa ESP8266:
Recomendaciones de literatura: Guía de referencia de asignación de pines ESP8266
Biblioteca BME280 MicroPython
De forma predeterminada, la biblioteca para leer el sensor BME280 no forma parte de la biblioteca estándar de MicroPython. Por lo tanto, debe cargar la siguiente biblioteca en su placa ESP32/ESP8266 (guárdela como BME280.py).
from machine import I2C
import time
# BME280 default address.
BME280_I2CADDR = 0x76
# Operating Modes
BME280_OSAMPLE_1 = 1
BME280_OSAMPLE_2 = 2
BME280_OSAMPLE_4 = 3
BME280_OSAMPLE_8 = 4
BME280_OSAMPLE_16 = 5
# BME280 Registers
BME280_REGISTER_DIG_T1 = 0x88 # Trimming parameter registers
BME280_REGISTER_DIG_T2 = 0x8A
BME280_REGISTER_DIG_T3 = 0x8C
BME280_REGISTER_DIG_P1 = 0x8E
BME280_REGISTER_DIG_P2 = 0x90
BME280_REGISTER_DIG_P3 = 0x92
BME280_REGISTER_DIG_P4 = 0x94
BME280_REGISTER_DIG_P5 = 0x96
BME280_REGISTER_DIG_P6 = 0x98
BME280_REGISTER_DIG_P7 = 0x9A
BME280_REGISTER_DIG_P8 = 0x9C
BME280_REGISTER_DIG_P9 = 0x9E
BME280_REGISTER_DIG_H1 = 0xA1
BME280_REGISTER_DIG_H2 = 0xE1
BME280_REGISTER_DIG_H3 = 0xE3
BME280_REGISTER_DIG_H4 = 0xE4
BME280_REGISTER_DIG_H5 = 0xE5
BME280_REGISTER_DIG_H6 = 0xE6
BME280_REGISTER_DIG_H7 = 0xE7
BME280_REGISTER_CHIPID = 0xD0
BME280_REGISTER_VERSION = 0xD1
BME280_REGISTER_SOFTRESET = 0xE0
BME280_REGISTER_CONTROL_HUM = 0xF2
BME280_REGISTER_CONTROL = 0xF4
BME280_REGISTER_CONFIG = 0xF5
BME280_REGISTER_PRESSURE_DATA = 0xF7
BME280_REGISTER_TEMP_DATA = 0xFA
BME280_REGISTER_HUMIDITY_DATA = 0xFD
class Device:
"""Class for communicating with an I2C device.
Allows reading and writing 8-bit, 16-bit, and byte array values to
registers on the device."""
def __init__(self, address, i2c):
"""Create an instance of the I2C device at the specified address using
the specified I2C interface object."""
self._address = address
self._i2c = i2c
def writeRaw8(self, value):
"""Write an 8-bit value on the bus (without register)."""
value = value & 0xFF
self._i2c.writeto(self._address, value)
def write8(self, register, value):
"""Write an 8-bit value to the specified register."""
b=bytearray(1)
b[0]=value & 0xFF
self._i2c.writeto_mem(self._address, register, b)
def write16(self, register, value):
"""Write a 16-bit value to the specified register."""
value = value & 0xFFFF
b=bytearray(2)
b[0]= value & 0xFF
b[1]= (value>>8) & 0xFF
self.i2c.writeto_mem(self._address, register, value)
def readRaw8(self):
"""Read an 8-bit value on the bus (without register)."""
return int.from_bytes(self._i2c.readfrom(self._address, 1),'little') & 0xFF
def readU8(self, register):
"""Read an unsigned byte from the specified register."""
return int.from_bytes(
self._i2c.readfrom_mem(self._address, register, 1),'little') & 0xFF
def readS8(self, register):
"""Read a signed byte from the specified register."""
result = self.readU8(register)
if result > 127:
result -= 256
return result
def readU16(self, register, little_endian=True):
"""Read an unsigned 16-bit value from the specified register, with the
specified endianness (default little endian, or least significant byte
first)."""
result = int.from_bytes(
self._i2c.readfrom_mem(self._address, register, 2),'little') & 0xFFFF
if not little_endian:
result = ((result << 8) & 0xFF00) + (result >> 8)
return result
def readS16(self, register, little_endian=True):
"""Read a signed 16-bit value from the specified register, with the
specified endianness (default little endian, or least significant byte
first)."""
result = self.readU16(register, little_endian)
if result > 32767:
result -= 65536
return result
def readU16LE(self, register):
"""Read an unsigned 16-bit value from the specified register, in little
endian byte order."""
return self.readU16(register, little_endian=True)
def readU16BE(self, register):
"""Read an unsigned 16-bit value from the specified register, in big
endian byte order."""
return self.readU16(register, little_endian=False)
def readS16LE(self, register):
"""Read a signed 16-bit value from the specified register, in little
endian byte order."""
return self.readS16(register, little_endian=True)
def readS16BE(self, register):
"""Read a signed 16-bit value from the specified register, in big
endian byte order."""
return self.readS16(register, little_endian=False)
class BME280:
def __init__(self, mode=BME280_OSAMPLE_1, address=BME280_I2CADDR, i2c=None,
**kwargs):
# Check that mode is valid.
if mode not in [BME280_OSAMPLE_1, BME280_OSAMPLE_2, BME280_OSAMPLE_4,
BME280_OSAMPLE_8, BME280_OSAMPLE_16]:
raise ValueError(
'Unexpected mode value {0}. Set mode to one of '
'BME280_ULTRALOWPOWER, BME280_STANDARD, BME280_HIGHRES, or '
'BME280_ULTRAHIGHRES'.format(mode))
self._mode = mode
# Create I2C device.
if i2c is None:
raise ValueError('An I2C object is required.')
self._device = Device(address, i2c)
# Load calibration values.
self._load_calibration()
self._device.write8(BME280_REGISTER_CONTROL, 0x3F)
self.t_fine = 0
def _load_calibration(self):
self.dig_T1 = self._device.readU16LE(BME280_REGISTER_DIG_T1)
self.dig_T2 = self._device.readS16LE(BME280_REGISTER_DIG_T2)
self.dig_T3 = self._device.readS16LE(BME280_REGISTER_DIG_T3)
self.dig_P1 = self._device.readU16LE(BME280_REGISTER_DIG_P1)
self.dig_P2 = self._device.readS16LE(BME280_REGISTER_DIG_P2)
self.dig_P3 = self._device.readS16LE(BME280_REGISTER_DIG_P3)
self.dig_P4 = self._device.readS16LE(BME280_REGISTER_DIG_P4)
self.dig_P5 = self._device.readS16LE(BME280_REGISTER_DIG_P5)
self.dig_P6 = self._device.readS16LE(BME280_REGISTER_DIG_P6)
self.dig_P7 = self._device.readS16LE(BME280_REGISTER_DIG_P7)
self.dig_P8 = self._device.readS16LE(BME280_REGISTER_DIG_P8)
self.dig_P9 = self._device.readS16LE(BME280_REGISTER_DIG_P9)
self.dig_H1 = self._device.readU8(BME280_REGISTER_DIG_H1)
self.dig_H2 = self._device.readS16LE(BME280_REGISTER_DIG_H2)
self.dig_H3 = self._device.readU8(BME280_REGISTER_DIG_H3)
self.dig_H6 = self._device.readS8(BME280_REGISTER_DIG_H7)
h4 = self._device.readS8(BME280_REGISTER_DIG_H4)
h4 = (h4 << 24) >> 20
self.dig_H4 = h4 | (self._device.readU8(BME280_REGISTER_DIG_H5) & 0x0F)
h5 = self._device.readS8(BME280_REGISTER_DIG_H6)
h5 = (h5 << 24) >> 20
self.dig_H5 = h5 | (
self._device.readU8(BME280_REGISTER_DIG_H5) >> 4 & 0x0F)
def read_raw_temp(self):
"""Reads the raw (uncompensated) temperature from the sensor."""
meas = self._mode
self._device.write8(BME280_REGISTER_CONTROL_HUM, meas)
meas = self._mode << 5 | self._mode << 2 | 1
self._device.write8(BME280_REGISTER_CONTROL, meas)
sleep_time = 1250 + 2300 * (1 << self._mode)
sleep_time = sleep_time + 2300 * (1 << self._mode) + 575
sleep_time = sleep_time + 2300 * (1 << self._mode) + 575
time.sleep_us(sleep_time) # Wait the required time
msb = self._device.readU8(BME280_REGISTER_TEMP_DATA)
lsb = self._device.readU8(BME280_REGISTER_TEMP_DATA + 1)
xlsb = self._device.readU8(BME280_REGISTER_TEMP_DATA + 2)
raw = ((msb << 16) | (lsb << 8) | xlsb) >> 4
return raw
def read_raw_pressure(self):
"""Reads the raw (uncompensated) pressure level from the sensor."""
"""Assumes that the temperature has already been read """
"""i.e. that enough delay has been provided"""
msb = self._device.readU8(BME280_REGISTER_PRESSURE_DATA)
lsb = self._device.readU8(BME280_REGISTER_PRESSURE_DATA + 1)
xlsb = self._device.readU8(BME280_REGISTER_PRESSURE_DATA + 2)
raw = ((msb << 16) | (lsb << 8) | xlsb) >> 4
return raw
def read_raw_humidity(self):
"""Assumes that the temperature has already been read """
"""i.e. that enough delay has been provided"""
msb = self._device.readU8(BME280_REGISTER_HUMIDITY_DATA)
lsb = self._device.readU8(BME280_REGISTER_HUMIDITY_DATA + 1)
raw = (msb << 8) | lsb
return raw
def read_temperature(self):
"""Get the compensated temperature in 0.01 of a degree celsius."""
adc = self.read_raw_temp()
var1 = ((adc >> 3) - (self.dig_T1 << 1)) * (self.dig_T2 >> 11)
var2 = ((
(((adc >> 4) - self.dig_T1) * ((adc >> 4) - self.dig_T1)) >> 12) *
self.dig_T3) >> 14
self.t_fine = var1 + var2
return (self.t_fine * 5 + 128) >> 8
def read_pressure(self):
"""Gets the compensated pressure in Pascals."""
adc = self.read_raw_pressure()
var1 = self.t_fine - 128000
var2 = var1 * var1 * self.dig_P6
var2 = var2 + ((var1 * self.dig_P5) << 17)
var2 = var2 + (self.dig_P4 << 35)
var1 = (((var1 * var1 * self.dig_P3) >> 8) +
((var1 * self.dig_P2) >> 12))
var1 = (((1 << 47) + var1) * self.dig_P1) >> 33
if var1 == 0:
return 0
p = 1048576 - adc
p = (((p << 31) - var2) * 3125) // var1
var1 = (self.dig_P9 * (p >> 13) * (p >> 13)) >> 25
var2 = (self.dig_P8 * p) >> 19
return ((p + var1 + var2) >> 8) + (self.dig_P7 << 4)
def read_humidity(self):
adc = self.read_raw_humidity()
# print 'Raw humidity = {0:d}'.format (adc)
h = self.t_fine - 76800
h = (((((adc << 14) - (self.dig_H4 << 20) - (self.dig_H5 * h)) +
16384) >> 15) * (((((((h * self.dig_H6) >> 10) * (((h *
self.dig_H3) >> 11) + 32768)) >> 10) + 2097152) *
self.dig_H2 + 8192) >> 14))
h = h - (((((h >> 15) * (h >> 15)) >> 7) * self.dig_H1) >> 4)
h = 0 if h < 0 else h
h = 419430400 if h > 419430400 else h
return h >> 12
@property
def temperature(self):
"Return the temperature in degrees."
t = self.read_temperature()
ti = t // 100
td = t - ti * 100
return "{}.{:02d}C".format(ti, td)
@property
def pressure(self):
"Return the temperature in hPa."
p = self.read_pressure() // 256
pi = p // 100
pd = p - pi * 100
return "{}.{:02d}hPa".format(pi, pd)
@property
def humidity(self):
"Return the humidity in percent."
h = self.read_humidity()
hi = h // 1024
hd = h * 100 // 1024 - hi * 100
return "{}.{:02d}%".format(hi, hd)
Siga las siguientes instrucciones para el IDE que está utilizando:
- A. Cargue la biblioteca BME280 con IDE de UpyCraft
- B. Cargue la biblioteca BME280 con IDE de Thonny
A. Cargue la biblioteca BME280 usando uPyCraft IDE
Esta sección muestra cómo cargar una biblioteca usando uPyCraft IDE. Si está utilizando Thonny IDE, lea la siguiente sección.
1. Crea un nuevo archivo presionando archivo nuevo Botón 1).
2. Copie el código de la biblioteca BME280 a este archivo. El código de la biblioteca BME280 se puede encontrar aquí.
3. Después de copiar el código, guarde el archivo presionando el botón Ahorrar (2).
4. Nombra este nuevo archivo “BME280.py» y presione DE ACUERDO.
5. presione eso Descargar y ejecutar Botón.
El archivo debe estar en la carpeta del dispositivo llamada «BME280.py“, como se destaca en la siguiente imagen.
Ahora puede utilizar las funciones de la biblioteca en su código importando la biblioteca.
B. Cargue la biblioteca BME280 usando Thonny IDE
Si está utilizando Thonny IDE, siga los siguientes pasos:
1. Copie el código de la biblioteca en un archivo nuevo. El código de la biblioteca BME280 se puede encontrar aquí.
2. Ir a archivo > Guardar como…
3. Seleccione «Guardar como»Dispositivo MicroPython«:
4. Nombra tu archivo como BME280.py y presione el botón Aceptar:
Y eso fue todo. La biblioteca se ha subido a tu tablero. Para asegurarse de que se haya cargado correctamente, vaya a Archivo > Guardar como… y seleccione el dispositivo MicroPython. Su archivo debería aparecer allí:
Después de cargar la biblioteca en su tablero, puede usar las funciones de la biblioteca en su código importándola.
Código – BME280 Presión, Temperatura y Humedad
Después de cargar la biblioteca en ESP32 o ESP8266, copie el siguiente código en el principal.py o arranque.py Archivo. Simplemente imprime la temperatura, la humedad y la presión en la carcasa cada 5 segundos.
# Complete project details at https://RandomNerdTutorials.com
from machine import Pin, I2C
from time import sleep
import BME280
# ESP32 - Pin assignment
i2c = I2C(scl=Pin(22), sda=Pin(21), freq=10000)
# ESP8266 - Pin assignment
#i2c = I2C(scl=Pin(5), sda=Pin(4), freq=10000)
while True:
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'
print('Temperature: ', temp)
print('Humidity: ', hum)
print('Pressure: ', pres)
sleep(5)
Cómo funciona el código
Primero, debe importar las bibliotecas requeridas, incluida la BME280 Módulo que importó anteriormente.
from machine import Pin, I2C
from time import sleep
import BME280Configure los pines I2C. En este caso usaremos los pines estándar I2C. Si usa ESP32, configure los pines de la siguiente manera:
i2c = I2C(scl=Pin(22), sda=Pin(21), freq=10000)Si está utilizando ESP8266, comente la línea anterior y descomente la siguiente línea para obtener:
i2c = I2C(scl=Pin(5), sda=Pin(4), freq=10000)En el mientras Bucle, crea uno BME280 Objeto nombrado bme con los pines I2C previamente definidos:
bme = BME280.BME280(i2c=i2c)Leer la temperatura, la humedad y la presión es tan fácil como usar el temperatura, humedad Y Presión métodos en el bme Objeto.
temp = bme.temperature
hum = bme.humidity
pres = bme.pressureFinalmente, imprima las lecturas en el caparazón:
print('Temperature: ', temp)
print('Humidity: ', hum)
print('Pressure: ', pres)Al final añadimos un retraso de 5 segundos:
sleep(5)demostración
Después de cargar el código en su tablero, presione el botón RST para ejecutar el código. Deben aparecer nuevas lecturas del sensor BME280 cada 5 segundos.
Visualización de los valores medidos del BME280 en el servidor web
Ahora que sabe cómo obtener presión, temperatura y humedad del sensor BME280, mostremos los valores del sensor en un servidor web al que puede acceder a través de su red local.
Para este ejemplo necesitas tres archivos:
- BME280.py: Este es el archivo que contiene todos los métodos para utilizar el sensor BME280. Este es el archivo que subiste anteriormente.
- arranque.py: se ejecuta cuando el dispositivo arranca y configura varias opciones de configuración como: Por ejemplo, sus credenciales de red, importación de bibliotecas, configuración de pines, etc.
- principal.py: Este es el script principal en el que gestionamos el servidor web. Será inmediatamente después arranque.py.
Nota: Se recomienda incluir los archivos boot.py y main.py. Sin embargo, también puedes incluir el código completo en el archivo main.py si lo deseas.
arranque.py
En su IDE, cree un nuevo archivo llamado arranque.py y copie el siguiente código.
# Complete project details at https://RandomNerdTutorials.com
try:
import usocket as socket
except:
import socket
from time import sleep
from machine import Pin, I2C
import network
import esp
esp.osdebug(None)
import gc
gc.collect()
import BME280
# ESP32 - Pin assignment
i2c = I2C(scl=Pin(22), sda=Pin(21), freq=10000)
# ESP8266 - Pin assignment
#i2c = I2C(scl=Pin(5), sda=Pin(4), freq=10000)
ssid = 'REPLACE_WITH_YOUR_SSID'
password = 'REPLACE_WITH_YOUR_PASSWORD'
station = network.WLAN(network.STA_IF)
station.active(True)
station.connect(ssid, password)
while station.isconnected() == False:
pass
print('Connection successful')
print(station.ifconfig())
Este archivo importa las bibliotecas requeridas, define los pines I2C para conectarse al sensor y se conecta a su red.
En el código usamos los pines ESP32 I2C:
i2c = I2C(scl=Pin(5), sda=Pin(4), freq=10000)Si está utilizando ESP8266, comente la línea anterior y descomente la siguiente línea:
i2c = I2C(scl=Pin(22), sda=Pin(21), freq=10000)Luego ingrese sus credenciales de red en las siguientes variables:
ssid = 'REPLACE_WITH_YOUR_SSID'
password = 'REPLACE_WITH_YOUR_PASSWORD'principal.py
En el principal.py En este archivo creamos el servidor web y procesamos las solicitudes. Copia el siguiente código en el tuyo. principal.py Archivo.
# Complete project details at https://RandomNerdTutorials.com
def web_page():
bme = BME280.BME280(i2c=i2c)
html = """<html><head><meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="icon" href="data:,"><style>body { text-align: center; font-family: "Trebuchet MS", Arial;}
table { border-collapse: collapse; width:35%; margin-left:auto; margin-right:auto; }
th { padding: 12px; background-color: #0043af; color: white; }
tr { border: 1px solid #ddd; padding: 12px; }
tr:hover { background-color: #bcbcbc; }
td { border: none; padding: 12px; }
.sensor { color:white; font-weight: bold; background-color: #bcbcbc; padding: 1px;
</style></head><body><h1>ESP with BME280</h1>
<table><tr><th>MEASUREMENT</th><th>VALUE</th></tr>
<tr><td>Temp. Celsius</td><td><span class="sensor">""" + str(bme.temperature) + """</span></td></tr>
<tr><td>Temp. Fahrenheit</td><td><span class="sensor">""" + str(round((bme.read_temperature()/100.0) * (9/5) + 32, 2)) + """F</span></td></tr>
<tr><td>Pressure</td><td><span class="sensor">""" + str(bme.pressure) + """</span></td></tr>
<tr><td>Humidity</td><td><span class="sensor">""" + str(bme.humidity) + """</span></td></tr></body></html>"""
return html
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('', 80))
s.listen(5)
while True:
try:
if gc.mem_free() < 102000:
gc.collect()
conn, addr = s.accept()
conn.settimeout(3.0)
print('Got a connection from %s' % str(addr))
request = conn.recv(1024)
conn.settimeout(None)
request = str(request)
print('Content = %s' % request)
response = web_page()
conn.send('HTTP/1.1 200 OKn')
conn.send('Content-Type: text/htmln')
conn.send('Connection: closenn')
conn.sendall(response)
conn.close()
except OSError as e:
conn.close()
print('Connection closed')
Este código crea un servidor de socket que envía una página HTML con los últimos valores del sensor cuando recibe una solicitud a la dirección IP del ESP32 o ESP8266.
Básicamente tenemos una función llamada sitio web() que devuelve el código HTML para crear la página web con los últimos valores del sensor. Este texto HTML crea una tabla para mostrar los valores:
html = """<html><head><meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="icon" href="data:,"><style>body { text-align: center; font-family: "Trebuchet MS", Arial;}
table { border-collapse: collapse; width:35%; margin-left:auto; margin-right:auto; }
th { padding: 12px; background-color: #0043af; color: white; }
tr { border: 1px solid #ddd; padding: 12px; }
tr:hover { background-color: #bcbcbc; }
td { border: none; padding: 12px; }
.sensor { color:white; font-weight: bold; background-color: #bcbcbc; padding: 1px;
</style></head><body><h1>ESP with BME280</h1>
<table><tr><th>MEASUREMENT</th><th>VALUE</th></tr>
<tr><td>Temp. Celsius</td><td><span class="sensor">""" + str(bme.temperature) + """</span></td></tr>
<tr><td>Temp. Fahrenheit</td><td><span class="sensor">""" + str(round((bme.read_temperature()/100.0) * (9/5) + 32, 2)) + """F</span></td></tr>
<tr><td>Pressure</td><td><span class="sensor">""" + str(bme.pressure) + """</span></td></tr>
<tr><td>Humidity</td><td><span class="sensor">""" + str(bme.humidity) + """</span></td></tr>
</body></html>"""Luego creamos un servidor de socket que envía el HTML cuando recibe una solicitud. Luego, el texto HTML se almacena en la variable de respuesta:
response = web_page()Y enviado al cliente:
conn.sendall(response)Hemos explicado detalladamente cómo funciona este tipo de servidor web en tutoriales anteriores. Entonces, si quieres saber cómo funciona, puedes leer los siguientes artículos:
- MicroPython: ESP32/ESP8266 con servidor web DHT11/DHT22
- Servidor web ESP32/ESP8266 MicroPython: salidas de control
Demostración del servidor web
Sube todos los archivos anteriores a tu placa ESP32 o ESP8266 en el siguiente orden:
- BME280.py
- arranque.py
- principal.py
Si no sabe cómo cargar código, puede consultar nuestras guías para comenzar con uPyCraft IDE o Thonny IDE:
- Comenzando con Thonny MicroPython (Python) IDE para ESP32 y ESP8266
- Comenzando con MicroPython en ESP32 y ESP8266 (uPyCraft IDE)
Después de cargar el código, su dirección IP ESP32 o ESP8266 debería aparecer en el monitor serie.
Abra un navegador web en su red local e ingrese su dirección IP ESP (en nuestro ejemplo, la IP es http://192.168.1.71). Debería recibir una página con las últimas lecturas del sensor, como se muestra en la imagen a continuación.
Actualizar sitio web automáticamente
Con el script del servidor web proporcionado en este proyecto, deberá actualizar la página web para mostrar las métricas más recientes. Si desea la siguiente metaetiqueta dentro de las etiquetas HTML Agregue, su sitio web se actualizará automáticamente cada 10 segundos:
<meta http-equiv="refresh" content="10">Envolver
Esperamos que este tutorial te haya resultado útil. Tenemos otros proyectos y tutoriales usando MicroPython que te pueden gustar:
- Registrador de datos de estación meteorológica de bajo consumo que utiliza ESP8266 y BME280 con MicroPython
- MicroPython: pantalla OLED con ESP32 y ESP8266
- MicroPython: ESP32/ESP8266 con servidor web DHT11/DHT22
- MicroPython: LED RGB direccionables WS2812B con ESP32 y ESP8266
Si desea obtener más información sobre la programación de las placas ESP32 y ESP8266 con MicroPython, acceda a nuestro libro electrónico: Programación MicroPython con ESP32 y ESP8266.
Gracias por leer.
MicroPython: BME280 con ESP32 y ESP8266 (presión, temperatura, humedad)
En esta guía aprenderás a utilizar el módulo sensor BME280 con el ESP32 y ESP8266 para obtener lecturas de presión, temperatura y humedad utilizando el firmware MicroPython. Construiremos un ejemplo simple para familiarizarte con el sensor y un servidor web para mostrar tus lecturas de sensor.
Prerrequisitos
Para seguir este tutorial necesitas tener instalado el firmware MicroPython en tus placas ESP32 o ESP8266. También necesitas un IDE para escribir y cargar el código en tu placa. Te sugerimos utilizar Thonny IDE o uPyCraft IDE:
- IDE Thonny: Instalación y primeros pasos con Thonny IDE
- IDE uPyCraft: Inicio con el IDE uPyCraft
Más sobre MicroPython
Quizás también te interese leer otras guías sobre BME280:
- ESP32 con BME280 Sensor utilizando Arduino IDE
- ESP32 Servidor Web con BME280 – Estación Meteorológica
- ESP8266 con BME280 utilizando Arduino IDE
- Placa Arduino con BME280
Introducción al Módulo Sensor BME280
El módulo sensor BME280 lee la presión barométrica, temperatura y humedad. Debido a que la presión cambia con la altitud, también puedes estimar la altitud. Existen varias versiones de este módulo sensor, pero estamos utilizando la que se muestra en la siguiente figura:
Partes necesarias
Para este proyecto necesitas conectar el módulo sensor BME280 a los pines I2C del ESP32 o ESP8266. Aquí hay una lista de las partes necesarias:
- Módulo sensor BME280
- ESP32 o ESP8266
- Protoboard
- Cables de puente
Lectura de BME280 con MicroPython
La biblioteca para leer desde el sensor BME280 no es parte de la biblioteca estándar de MicroPython por defecto. Entonces, necesitas cargar la siguiente biblioteca en tu placa ESP32/ESP8266 (guárdala con el nombre BME280.py).
- Dispositivo
- Registro
- Temperatura
- Presión
- Humedad
Sigue las instrucciones del IDE que estés utilizando para cargar la biblioteca y luego copia el código necesario para obtener las lecturas de presión, temperatura y humedad del sensor BME280.
Funcionamiento del Código y Demonstration
El código en el archivo main.py simplemente imprime la temperatura, humedad y presión en la consola cada 5 segundos después de obtener las lecturas del sensor BME280.
Después de cargar el código en tu placa, al presionar el botón de reinicio (RST) se mostrarán nuevas lecturas del sensor cada 5 segundos en la consola.
Servidor Web – Actualización Automática
Si deseas mostrar las últimas lecturas del sensor BME280 en una página web con actualización automática, puedes seguir las instrucciones proporcionadas para implementar un servidor web que se actualiza cada 10 segundos. La página mostrará automáticamente las últimas lecturas del sensor sin necesidad de recargarla manualmente.
Con estos pasos podrás mostrar las lecturas de presión, temperatura y humedad del sensor BME280 en tiempo real a través de un servidor web que se actualice automáticamente en tu red local.
Esperamos que esta guía te haya sido útil para integrar el sensor BME280 con tus placas ESP32 y ESP8266 utilizando MicroPython. ¡Gracias por leer!
¡Interesante combinación de dispositivos! Me encantaría probarlo en mi proyecto de sensores caseros. ¡Gracias por compartir la información!
¡Increíble! Nunca imaginé que se pudieran medir tantas variables con estos pequeños dispositivos. Definitivamente aprenderé más sobre esto, ¡gracias por la info! 🙌
¡Qué interesante forma de utilizar la tecnología para medir diferentes variables! Definitivamente me anima a experimentar con MicroPython y estos dispositivos. ¡Gracias por el tutorial, seguro lo pondré en práctica pronto! 👍
¡Qué chévere! Me encanta la idea de poder medir presión, temperatura y humedad con estos dispositivos. Definitivamente investigaré más sobre cómo implementarlo en mis proyectos. ¡Gracias por el tutorial!
¡Muy cool! Me encanta la versatilidad de poder tener presión, temperatura y humedad en un solo dispositivo. Definitivamente voy a probarlo en mis proyectos. ¡Gracias por el tutorial! 🌡️