Ce didacticiel est un guide étape par étape qui explique comment créer un serveur Web autonome ESP32 ou ESP8266 NodeMCU qui affiche les lectures du capteur BME680 à l’aide du micrologiciel MicroPython. Nous allons créer un serveur Web ESP32/ESP8266 qui est mobile et accessible avec n’importe quel appareil avec un navigateur sur votre réseau local.
Si vous voulez savoir comment fonctionne un module relais, lisez notre Guide MicroPython : BME680 avec ESP32 et ESP8266 (Température, Humidité, Pression, Gaz).
Nous avons des guides similaires utilisant Arduino IDE :
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.
Module de capteur environnemental BME680
Le BME680 est un capteur environnemental qui combine des capteurs de gaz, de pression, d’humidité et de température. Le capteur de gaz peut détecter une large gamme de gaz comme les composés organiques volatils (COV). Pour cette raison, le BME680 peut être utilisé dans le contrôle de la qualité de l’air intérieur.
Le BME680 prend en charge les interfaces I2C et SPI.
BME680 I2C
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 :
| BME680 | 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 BME680 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 BME680
La bibliothèque à lire depuis le capteur BME680 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 bme680.py).
# Spaces, comments and some functions have been removed from the original file to save memory
# Original source: https://github.com/adafruit/Adafruit_CircuitPython_BME680/blob/master/adafruit_bme680.py
import time
import math
from micropython import const
from ubinascii import hexlify as hex
try:
import struct
except ImportError:
import ustruct as struct
_BME680_CHIPID = const(0x61)
_BME680_REG_CHIPID = const(0xD0)
_BME680_BME680_COEFF_ADDR1 = const(0x89)
_BME680_BME680_COEFF_ADDR2 = const(0xE1)
_BME680_BME680_RES_HEAT_0 = const(0x5A)
_BME680_BME680_GAS_WAIT_0 = const(0x64)
_BME680_REG_SOFTRESET = const(0xE0)
_BME680_REG_CTRL_GAS = const(0x71)
_BME680_REG_CTRL_HUM = const(0x72)
_BME280_REG_STATUS = const(0xF3)
_BME680_REG_CTRL_MEAS = const(0x74)
_BME680_REG_CONFIG = const(0x75)
_BME680_REG_PAGE_SELECT = const(0x73)
_BME680_REG_MEAS_STATUS = const(0x1D)
_BME680_REG_PDATA = const(0x1F)
_BME680_REG_TDATA = const(0x22)
_BME680_REG_HDATA = const(0x25)
_BME680_SAMPLERATES = (0, 1, 2, 4, 8, 16)
_BME680_FILTERSIZES = (0, 1, 3, 7, 15, 31, 63, 127)
_BME680_RUNGAS = const(0x10)
_LOOKUP_TABLE_1 = (2147483647.0, 2147483647.0, 2147483647.0, 2147483647.0, 2147483647.0,
2126008810.0, 2147483647.0, 2130303777.0, 2147483647.0, 2147483647.0,
2143188679.0, 2136746228.0, 2147483647.0, 2126008810.0, 2147483647.0,
2147483647.0)
_LOOKUP_TABLE_2 = (4096000000.0, 2048000000.0, 1024000000.0, 512000000.0, 255744255.0, 127110228.0,
64000000.0, 32258064.0, 16016016.0, 8000000.0, 4000000.0, 2000000.0, 1000000.0,
500000.0, 250000.0, 125000.0)
def _read24(arr):
ret = 0.0
for b in arr:
ret *= 256.0
ret += float(b & 0xFF)
return ret
class Adafruit_BME680:
def __init__(self, *, refresh_rate=10):
self._write(_BME680_REG_SOFTRESET, [0xB6])
time.sleep(0.005)
chip_id = self._read_byte(_BME680_REG_CHIPID)
if chip_id != _BME680_CHIPID:
raise RuntimeError('Failed 0x%x' % chip_id)
self._read_calibration()
self._write(_BME680_BME680_RES_HEAT_0, [0x73])
self._write(_BME680_BME680_GAS_WAIT_0, [0x65])
self.sea_level_pressure = 1013.25
self._pressure_oversample = 0b011
self._temp_oversample = 0b100
self._humidity_oversample = 0b010
self._filter = 0b010
self._adc_pres = None
self._adc_temp = None
self._adc_hum = None
self._adc_gas = None
self._gas_range = None
self._t_fine = None
self._last_reading = 0
self._min_refresh_time = 1000 / refresh_rate
@property
def pressure_oversample(self):
return _BME680_SAMPLERATES[self._pressure_oversample]
@pressure_oversample.setter
def pressure_oversample(self, sample_rate):
if sample_rate in _BME680_SAMPLERATES:
self._pressure_oversample = _BME680_SAMPLERATES.index(sample_rate)
else:
raise RuntimeError("Invalid")
@property
def humidity_oversample(self):
return _BME680_SAMPLERATES[self._humidity_oversample]
@humidity_oversample.setter
def humidity_oversample(self, sample_rate):
if sample_rate in _BME680_SAMPLERATES:
self._humidity_oversample = _BME680_SAMPLERATES.index(sample_rate)
else:
raise RuntimeError("Invalid")
@property
def temperature_oversample(self):
return _BME680_SAMPLERATES[self._temp_oversample]
@temperature_oversample.setter
def temperature_oversample(self, sample_rate):
if sample_rate in _BME680_SAMPLERATES:
self._temp_oversample = _BME680_SAMPLERATES.index(sample_rate)
else:
raise RuntimeError("Invalid")
@property
def filter_size(self):
return _BME680_FILTERSIZES[self._filter]
@filter_size.setter
def filter_size(self, size):
if size in _BME680_FILTERSIZES:
self._filter = _BME680_FILTERSIZES[size]
else:
raise RuntimeError("Invalid")
@property
def temperature(self):
self._perform_reading()
calc_temp = (((self._t_fine * 5) + 128) / 256)
return calc_temp / 100
@property
def pressure(self):
self._perform_reading()
var1 = (self._t_fine / 2) - 64000
var2 = ((var1 / 4) * (var1 / 4)) / 2048
var2 = (var2 * self._pressure_calibration[5]) / 4
var2 = var2 + (var1 * self._pressure_calibration[4] * 2)
var2 = (var2 / 4) + (self._pressure_calibration[3] * 65536)
var1 = (((((var1 / 4) * (var1 / 4)) / 8192) *
(self._pressure_calibration[2] * 32) / 8) +
((self._pressure_calibration[1] * var1) / 2))
var1 = var1 / 262144
var1 = ((32768 + var1) * self._pressure_calibration[0]) / 32768
calc_pres = 1048576 - self._adc_pres
calc_pres = (calc_pres - (var2 / 4096)) * 3125
calc_pres = (calc_pres / var1) * 2
var1 = (self._pressure_calibration[8] * (((calc_pres / 8) * (calc_pres / 8)) / 8192)) / 4096
var2 = ((calc_pres / 4) * self._pressure_calibration[7]) / 8192
var3 = (((calc_pres / 256) ** 3) * self._pressure_calibration[9]) / 131072
calc_pres += ((var1 + var2 + var3 + (self._pressure_calibration[6] * 128)) / 16)
return calc_pres/100
@property
def humidity(self):
self._perform_reading()
temp_scaled = ((self._t_fine * 5) + 128) / 256
var1 = ((self._adc_hum - (self._humidity_calibration[0] * 16)) -
((temp_scaled * self._humidity_calibration[2]) / 200))
var2 = (self._humidity_calibration[1] *
(((temp_scaled * self._humidity_calibration[3]) / 100) +
(((temp_scaled * ((temp_scaled * self._humidity_calibration[4]) / 100)) /
64) / 100) + 16384)) / 1024
var3 = var1 * var2
var4 = self._humidity_calibration[5] * 128
var4 = (var4 + ((temp_scaled * self._humidity_calibration[6]) / 100)) / 16
var5 = ((var3 / 16384) * (var3 / 16384)) / 1024
var6 = (var4 * var5) / 2
calc_hum = (((var3 + var6) / 1024) * 1000) / 4096
calc_hum /= 1000
if calc_hum > 100:
calc_hum = 100
if calc_hum < 0:
calc_hum = 0
return calc_hum
@property
def altitude(self):
pressure = self.pressure
return 44330 * (1.0 - math.pow(pressure / self.sea_level_pressure, 0.1903))
@property
def gas(self):
self._perform_reading()
var1 = ((1340 + (5 * self._sw_err)) * (_LOOKUP_TABLE_1[self._gas_range])) / 65536
var2 = ((self._adc_gas * 32768) - 16777216) + var1
var3 = (_LOOKUP_TABLE_2[self._gas_range] * var1) / 512
calc_gas_res = (var3 + (var2 / 2)) / var2
return int(calc_gas_res)
def _perform_reading(self):
if (time.ticks_diff(self._last_reading, time.ticks_ms()) * time.ticks_diff(0, 1)
< self._min_refresh_time):
return
self._write(_BME680_REG_CONFIG, [self._filter << 2])
self._write(_BME680_REG_CTRL_MEAS,
[(self._temp_oversample << 5)|(self._pressure_oversample << 2)])
self._write(_BME680_REG_CTRL_HUM, [self._humidity_oversample])
self._write(_BME680_REG_CTRL_GAS, [_BME680_RUNGAS])
ctrl = self._read_byte(_BME680_REG_CTRL_MEAS)
ctrl = (ctrl & 0xFC) | 0x01
self._write(_BME680_REG_CTRL_MEAS, [ctrl])
new_data = False
while not new_data:
data = self._read(_BME680_REG_MEAS_STATUS, 15)
new_data = data[0] & 0x80 != 0
time.sleep(0.005)
self._last_reading = time.ticks_ms()
self._adc_pres = _read24(data[2:5]) / 16
self._adc_temp = _read24(data[5:8]) / 16
self._adc_hum = struct.unpack('>H', bytes(data[8:10]))[0]
self._adc_gas = int(struct.unpack('>H', bytes(data[13:15]))[0] / 64)
self._gas_range = data[14] & 0x0F
var1 = (self._adc_temp / 8) - (self._temp_calibration[0] * 2)
var2 = (var1 * self._temp_calibration[1]) / 2048
var3 = ((var1 / 2) * (var1 / 2)) / 4096
var3 = (var3 * self._temp_calibration[2] * 16) / 16384
self._t_fine = int(var2 + var3)
def _read_calibration(self):
coeff = self._read(_BME680_BME680_COEFF_ADDR1, 25)
coeff += self._read(_BME680_BME680_COEFF_ADDR2, 16)
coeff = list(struct.unpack('<hbBHhbBhhbbHhhBBBHbbbBbHhbb', bytes(coeff[1:39])))
coeff = [float(i) for i in coeff]
self._temp_calibration = [coeff[x] for x in [23, 0, 1]]
self._pressure_calibration = [coeff[x] for x in [3, 4, 5, 7, 8, 10, 9, 12, 13, 14]]
self._humidity_calibration = [coeff[x] for x in [17, 16, 18, 19, 20, 21, 22]]
self._gas_calibration = [coeff[x] for x in [25, 24, 26]]
self._humidity_calibration[1] *= 16
self._humidity_calibration[1] += self._humidity_calibration[0] % 16
self._humidity_calibration[0] /= 16
self._heat_range = (self._read_byte(0x02) & 0x30) / 16
self._heat_val = self._read_byte(0x00)
self._sw_err = (self._read_byte(0x04) & 0xF0) / 16
def _read_byte(self, register):
return self._read(register, 1)[0]
def _read(self, register, length):
raise NotImplementedError()
def _write(self, register, values):
raise NotImplementedError()
class BME680_I2C(Adafruit_BME680):
def __init__(self, i2c, address=0x77, debug=False, *, refresh_rate=10):
self._i2c = i2c
self._address = address
self._debug = debug
super().__init__(refresh_rate=refresh_rate)
def _read(self, register, length):
result = bytearray(length)
self._i2c.readfrom_mem_into(self._address, register & 0xff, result)
if self._debug:
print("t${:x} read ".format(register), " ".join(["{:02x}".format(i) for i in result]))
return result
def _write(self, register, values):
if self._debug:
print("t${:x} write".format(register), " ".join(["{:02x}".format(i) for i in values]))
for value in values:
self._i2c.writeto_mem(self._address, register, bytearray([value & 0xFF]))
register += 1
Suivez les instructions suivantes pour l’IDE que vous utilisez :
- A. Téléchargez la bibliothèque BME680 avec IDE uPyCraft
- B. Téléchargez la bibliothèque BME680 avec Thonny IDE
A. Télécharger la bibliothèque BME680 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 BME680 dans ce fichier. le Le code de la bibliothèque BME680 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 « bme680.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 « bme680.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 BME680 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 BME680 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 Web Server – BME680 Température, humidité, pression et qualité de l’air du gaz
Maintenant que vous savez comment obtenir la température, l’humidité, la pression et le gaz du capteur BME680, 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 :
- bme680.py: c’est le fichier qui contient toutes les méthodes pour utiliser le capteur BME680. 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/micropython-bme680-esp32-esp8266/
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()
from bme680 import *
# ESP32 - Pin assignment
i2c = I2C(scl=Pin(22), sda=Pin(21))
# ESP8266 - Pin assignment
#i2c = I2C(scl=Pin(5), sda=Pin(4))
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(22), sda=Pin(21))Si vous utilisez l’ESP8266, commentez la ligne précédente et décommentez ce qui suit :
i2c = I2C(scl=Pin(5), sda=Pin(4))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/micropython-bme680-esp32-esp8266/
def web_page():
bme = BME680_I2C(i2c=i2c)
html = """<html><head><title>ESP with BME680</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="icon" href="https://www.raspberryme.com/micropython-esp32-esp8266-bme680-web-server/data:,"><style>body { text-align: center; font-family: "Trebuchet MS", Arial;}
table { border-collapse: collapse; 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 BME680</h1>
<table><tr><th>MEASUREMENT</th><th>VALUE</th></tr>
<tr><td>Temp. Celsius</td><td><span class="sensor">""" + str(round(bme.temperature, 2)) + """ C</span></td></tr>
<tr><td>Temp. Fahrenheit</td><td><span class="sensor">""" + str(round((bme.temperature) * (9/5) + 32, 2)) + """ F</span></td></tr>
<tr><td>Pressure</td><td><span class="sensor">""" + str(round(bme.pressure, 2)) + """ hPa</span></td></tr>
<tr><td>Humidity</td><td><span class="sensor">""" + str(round(bme.humidity, 2)) + """ %</span></td></tr>
<tr><td>Gas</td><td><span class="sensor">""" + str(round(bme.gas/1000, 2)) + """ KOhms</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 :
def web_page():
bme = BME680_I2C(i2c=i2c)
html = """<html><head><title>ESP with BME680</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="icon" href="https://www.raspberryme.com/micropython-esp32-esp8266-bme680-web-server/data:,"><style>body { text-align: center; font-family: "Trebuchet MS", Arial;}
table { border-collapse: collapse; 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 BME680</h1>
<table><tr><th>MEASUREMENT</th><th>VALUE</th></tr>
<tr><td>Temp. Celsius</td><td><span class="sensor">""" + str(round(bme.temperature, 2)) + """ C</span></td></tr>
<tr><td>Temp. Fahrenheit</td><td><span class="sensor">""" + str(round((bme.temperature) * (9/5) + 32, 2)) + """ F</span></td></tr>
<tr><td>Pressure</td><td><span class="sensor">""" + str(round(bme.pressure, 2)) + """ hPa</span></td></tr>
<tr><td>Humidity</td><td><span class="sensor">""" + str(round(bme.humidity, 2)) + """ %</span></td></tr>
<tr><td>Gas</td><td><span class="sensor">""" + str(round(bme.gas/1000, 2)) + """ KOhms</span></td></tr></body></html>"""
return htmlEnsuite, 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 le réponse variable:
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 :
- bme680.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.114). 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 meta dans le HTML tags, 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.