Dans ce guide, vous apprendrez à utiliser le module de capteur BME280 avec l’ESP32 et l’ESP8266 pour obtenir des lectures de pression, de température et d’humidité à l’aide du micrologiciel MicroPython. Nous allons créer un exemple simple pour vous familiariser avec le capteur et un serveur Web pour afficher les lectures de votre capteur.
Conditions préalables
Pour suivre ce tutoriel, vous avez besoin du firmware MicroPython installé dans vos cartes ESP32 ou ESP8266. Vous avez également besoin d’un IDE pour écrire et télécharger le code sur votre carte. Nous vous suggérons d’utiliser Thonny IDE ou uPyCraft IDE :
En savoir plus sur MicroPython : eBook de programmation MicroPython avec ESP32 et ESP8266.
Vous aimerez peut-être aussi lire d’autres guides du BME280 :
Présentation du module de capteur BME280
le Module capteur BME280 lit la pression barométrique, la température et l’humidité. Étant donné que la pression change avec l’altitude, vous pouvez également estimer l’altitude. Il existe plusieurs versions de ce module de capteur, mais nous utilisons celle illustrée dans la figure ci-dessous.
Ce capteur communique en utilisant le protocole de communication I2C, le câblage est donc très simple. Vous pouvez utiliser les broches ESP32 ou ESP8266 I2C par défaut, comme indiqué dans le tableau suivant :
| BME280 | ESP32 | ESP8266 |
| Vin | 3.3V | 3.3V |
| GND | GND | GND |
| SCL | GPIO 22 | GPIO 5 (D1) |
| SDA | GPIO 21 | GPIO 4 (D2) |
Pièces requises
Pour ce projet, vous devez câbler le module de capteur BME280 aux broches ESP32 ou ESP8266 I2C. Voici une liste des pièces dont vous avez besoin pour ce tutoriel :
Vous pouvez utiliser les liens précédents ou aller directement sur MakerAdvisor.com/tools pour trouver toutes les pièces pour vos projets au meilleur prix !
Schéma – ESP32
Suivez le schéma suivant si vous utilisez une carte ESP32 :
Lecture recommandée: Guide de référence du brochage ESP32
Schéma – ESP8266
Suivez le schéma suivant si vous utilisez une carte ESP8266 :
Lecture recommandée: Guide de référence du brochage ESP8266
Bibliothèque MicroPython BME280
La bibliothèque à lire à partir du capteur BME280 ne fait pas partie par défaut de la bibliothèque MicroPython standard. Vous devez donc télécharger la bibliothèque suivante sur votre carte ESP32/ESP8266 (enregistrez-la sous le nom 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)
Suivez les instructions suivantes pour l’IDE que vous utilisez :
- A. Téléchargez la bibliothèque BME280 avec IDE uPyCraft
- B. Téléchargez la bibliothèque BME280 avec Thonny IDE
A. Télécharger la bibliothèque BME280 avec uPyCraft IDE
Cette section montre comment télécharger une bibliothèque à l’aide de l’IDE uPyCraft. Si vous utilisez Thonny IDE, lisez la section suivante.
1. Créez un nouveau fichier en appuyant sur le Nouveau fichier bouton (1).
2. Copiez le code de la bibliothèque BME280 dans ce fichier. le Le code de la bibliothèque BME280 peut être trouvé ici.
3. Après avoir copié le code, enregistrez le fichier en appuyant sur la touche Sauvegarder bouton (2).
4. Appelez ce nouveau fichier « BME280.py » et appuyez sur d’accord.
5. Clique le Télécharger et exécuter bouton.
Le fichier doit être enregistré dans le dossier de l’appareil sous le nom « BME280.py», comme le montre la figure suivante.
Maintenant, vous pouvez utiliser les fonctionnalités de la bibliothèque dans votre code en important la bibliothèque.
B. Télécharger la bibliothèque BME280 avec Thonny IDE
Si vous utilisez Thonny IDE, suivez les étapes suivantes :
1. Copiez le code de la bibliothèque dans un nouveau fichier. le Le code de la bibliothèque BME280 peut être trouvé ici.
2. Aller à Déposer > Enregistrer sous…
3. Sélectionnez enregistrer dans « Périphérique MicroPython » :
4. Nommez votre fichier comme bme680.py et appuyez sur le bouton OK :
Et c’est tout. La bibliothèque a été téléchargée sur votre tableau. Pour vous assurer qu’il a été téléchargé avec succès, accédez à Fichier > Enregistrer sous… et sélectionnez le périphérique MicroPython. Votre fichier doit y figurer :
Après avoir téléchargé la bibliothèque sur votre tableau, vous pouvez utiliser les fonctionnalités de la bibliothèque dans votre code en important la bibliothèque.
Code – BME280 Pression, température et humidité
Après avoir téléchargé la bibliothèque sur l’ESP32 ou l’ESP8266, copiez le code suivant dans le main.py ou boot.py déposer. Il imprime simplement la température, l’humidité et la pression dans la coque toutes les 5 secondes.
# Complete project details at https://Raspberryme.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)
Comment fonctionne le code
Tout d’abord, vous devez importer les bibliothèques nécessaires, y compris le BME280 module que vous avez importé précédemment.
from machine import Pin, I2C
from time import sleep
import BME280Réglez les broches I2C. Dans ce cas, nous utilisons les broches I2C par défaut. Si vous utilisez l’ESP32, définissez les broches comme suit :
i2c = I2C(scl=Pin(22), sda=Pin(21), freq=10000)Si vous utilisez l’ESP8266, commentez la ligne précédente et décommentez ce qui suit afin d’avoir :
i2c = I2C(scl=Pin(5), sda=Pin(4), freq=10000)Dans le tandis que boucle, créez un BME280 objet appelé bme avec les broches I2C définies précédemment :
bme = BME280.BME280(i2c=i2c)La lecture de la température, de l’humidité et de la pression est aussi simple que d’utiliser le Température, humidité et pression méthodes sur le bme objet.
temp = bme.temperature
hum = bme.humidity
pres = bme.pressureEnfin, imprimez les lectures sur la coque :
print('Temperature: ', temp)
print('Humidity: ', hum)
print('Pressure: ', pres)Au final, on ajoute un délai de 5 secondes :
sleep(5)Manifestation
Après avoir téléchargé le code sur votre tableau, appuyez sur le bouton RST pour exécuter le code. Les nouvelles lectures du capteur BME280 doivent être affichées toutes les 5 secondes.
Afficher les lectures du BME280 sur le serveur Web
Maintenant que vous savez comment obtenir la pression, la température et l’humidité du capteur BME280, nous allons afficher les lectures du capteur sur un serveur Web auquel vous pouvez accéder sur votre réseau local.
Pour cet exemple, vous avez besoin de trois fichiers :
- BME280.py: c’est le fichier qui contient toutes les méthodes pour utiliser le capteur BME280. C’est le fichier que vous avez téléchargé précédemment.
- boot.py: s’exécute au démarrage de l’appareil et configure plusieurs options de configuration telles que vos informations d’identification réseau, l’importation de bibliothèques, la définition des broches, etc.
- main.py: c’est le script principal où nous allons gérer le serveur Web. Il s’exécute immédiatement après la boot.py.
Noter: Il est recommandé d’inclure les fichiers boot.py et main.py. Cependant, si vous préférez, vous pouvez inclure tout le code dans le fichier main.py.
boot.py
Créez un nouveau fichier dans votre IDE appelé boot.py et copiez le code suivant.
# Complete project details at https://Raspberryme.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())
Ce fichier importe les bibliothèques nécessaires, définit les broches I2C à connecter au capteur et se connecte à votre réseau.
Dans le code, nous utilisons les broches ESP32 I2C :
i2c = I2C(scl=Pin(5), sda=Pin(4), freq=10000)Si vous utilisez l’ESP8266, commentez la ligne précédente et décommentez ce qui suit :
i2c = I2C(scl=Pin(22), sda=Pin(21), freq=10000)Ensuite, insérez vos identifiants réseau dans les variables suivantes :
ssid = 'REPLACE_WITH_YOUR_SSID'
password = 'REPLACE_WITH_YOUR_PASSWORD'main.py
Dans le main.py fichier est l’endroit où nous allons créer le serveur Web et gérer les demandes. Copiez le code suivant dans votre main.py déposer.
# Complete project details at https://Raspberryme.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="https://www.raspberryme.com/micropython-bme280-esp32-esp8266/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')
Ce code crée un serveur de socket qui envoie une page HTML avec les dernières lectures du capteur lorsqu’il reçoit une requête sur l’adresse IP ESP32 ou ESP8266.
Fondamentalement, nous avons une fonction appelée page Web() qui renvoie le code HTML pour créer la page Web avec les dernières lectures du capteur. Ce texte HMTL construit un tableau pour afficher les lectures :
html = """<html><head><meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="icon" href="https://www.raspberryme.com/micropython-bme280-esp32-esp8266/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>"""Ensuite, nous créons un serveur socket qui envoie le code HTML lorsqu’il reçoit une requête. Le texte HTML est ensuite enregistré sur la variable de réponse :
response = web_page()Et envoyé au client :
conn.sendall(response)Nous avons expliqué en détail le fonctionnement de ce type de serveurs Web dans les didacticiels précédents. Donc, si vous voulez apprendre comment cela fonctionne, vous pouvez lire les articles suivants :
Démonstration du serveur Web
Téléchargez tous les fichiers précédents sur votre carte ESP32 ou ESP8266 dans l’ordre suivant :
- BME280.py
- boot.py
- main.py
Si vous ne savez pas comment télécharger du code, vous pouvez lire nos guides de démarrage avec uPyCraft IDE ou Thonny IDE :
Après avoir téléchargé le code, votre adresse IP ESP32 ou ESP8266 doit s’afficher sur le moniteur série.
Ouvrez un navigateur Web sur votre réseau local et saisissez votre adresse IP ESP (dans notre exemple, l’IP est http://192.168.1.71). Vous devriez obtenir une page avec les dernières lectures du capteur, comme illustré dans la figure suivante.
Actualisation automatique de la page Web
Avec le script de serveur Web fourni dans ce projet, vous devez actualiser la page Web pour voir les dernières lectures. Si vous ajoutez la prochaine balise méta à l’intérieur des balises HTML
, votre page Web s’actualisera automatiquement toutes les 10 secondes :<meta http-equiv="refresh" content="10">Conclusion
Nous espérons que vous avez trouvé ce tutoriel utile. Nous avons d’autres projets et tutoriels avec MicroPython qui pourraient vous plaire :
Si vous souhaitez en savoir plus sur la programmation des cartes ESP32 et ESP8266 avec MicroPython, accédez à notre eBook : Programmation MicroPython avec ESP32 et ESP8266.
Merci d’avoir lu.