Dans ce guide, vous apprendrez à utiliser le module de capteur BME680 avec l’ESP32 et l’ESP8266 pour obtenir des lectures de température, d’humidité, de pression et de gaz (qualité de l’air) à 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 BME680 :
Présentation du 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.
Mesures du BME680
Le BME680 est un capteur numérique 4 en 1 qui mesure :
- Température
- Humidité
- Pression barométrique
- Gaz : Composés organiques volatils (COV) comme l’éthanol et le monoxyde de carbone
Capteur de gaz
Le BME680 contient un capteur MOX (oxyde métallique) qui détecte les COV dans l’air. Ce capteur vous donne une idée qualitative de la somme des COV/contaminants dans l’air ambiant – ce n’est pas spécifique pour une molécule de gaz spécifique.
Les capteurs MOX sont composés d’une surface en oxyde métallique, d’une puce de détection pour mesurer les changements de conductivité et d’un élément chauffant. Il détecte les COV par adsorption de molécules d’oxygène sur sa couche sensible. Le BME680 réagit à la plupart des COV polluant l’air intérieur (à l’exception du CO2).
Lorsque le capteur entre en contact avec les gaz réducteurs, les molécules d’oxygène réagissent et augmentent la conductivité à travers la surface. En tant que signal brut, le BME680 émet des valeurs de résistance. Ces valeurs changent en raison des variations des concentrations de COV :
- Plus haute concentration de COV » Inférieur la résistance
- Inférieur concentration de COV » Plus haute la résistance
Les réactions qui se produisent à la surface du capteur (donc la résistance) sont influencées par des paramètres autres que la concentration en COV comme la température et l’humidité.
Informations pertinentes concernant le capteur de gaz
Le capteur de gaz vous donne une idée qualitative des gaz COV dans l’air ambiant. Ainsi, vous pouvez obtenir des tendances, comparer vos résultats et voir si la qualité de l’air augmente ou diminue. Pour obtenir des mesures précises, vous devez étalonner le capteur par rapport à des sources connues et créer une courbe d’étalonnage.
Lorsque vous obtenez le capteur pour la première fois, il est recommandé de le faire fonctionner pendant 48 heures avant de commencer à collecter des données «réelles». Après cela, il est également recommandé de faire fonctionner le capteur pendant 30 minutes avant d’obtenir une lecture de gaz.
Précision BME680
Voici la précision des capteurs de température, d’humidité et de pression du BME680 :
Capteur | Précision |
Température | +/- 1,0 ºC |
Humidité | +/- 3% |
Pression | +/- 1 hPa |
Plage de fonctionnement du BME680
Le tableau suivant indique la plage de fonctionnement des capteurs de température, d’humidité et de pression du BME680.
Capteur | Opération Varier |
Température | -40 à 85 ºC |
Humidité | 0 à 100 % |
Pression | 300 à 1100 hPa |
Brochage du BME680
Voici le brochage du BME680 :
VCC | Alimente le capteur |
GND | GND commun |
SCL | Broche SCL pour la communication I2C Broche SCK pour la communication SPI |
SDA | Broche SDA pour la communication I2C Broche SDI (MOSI) pour la communication SPI |
SDO | Broche SDO (MISO) pour la communication SPI |
CS | Broche de sélection de puce pour la communication SPI |
Interface BME680
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 – BME680 Température, humidité, pression et qualité de l’air gazeux
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/micropython-bme680-esp32-esp8266/
from machine import Pin, I2C
from time import sleep
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))
bme = BME680_I2C(i2c=i2c)
while True:
try:
temp = str(round(bme.temperature, 2)) + ' C'
#temp = (bme.temperature) * (9/5) + 32
#temp = str(round(temp, 2)) + 'F'
hum = str(round(bme.humidity, 2)) + ' %'
pres = str(round(bme.pressure, 2)) + ' hPa'
gas = str(round(bme.gas/1000, 2)) + ' KOhms'
print('Temperature:', temp)
print('Humidity:', hum)
print('Pressure:', pres)
print('Gas:', gas)
print('-------')
except OSError as e:
print('Failed to read sensor.')
sleep(5)
Comment fonctionne le code
Tout d’abord, vous devez importer les bibliothèques nécessaires, y compris le BME680 module que vous avez importé précédemment.
from machine import Pin, I2C
from time import sleep
from bme680 import *
Ré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))
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))
Dans le tandis que boucle, créez un BME680 objet appelé bme avec les broches I2C définies précédemment :
bme = BME680_I2C(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 = str(round(bme.temperature, 2)) + ' C'
#temp = (bme.temperature) * (9/5) + 32
#temp = str(round(temp, 2)) + 'F'
hum = str(round(bme.humidity, 2)) + ' %'
pres = str(round(bme.pressure, 2)) + ' hPa'
gas = str(round(bme.gas/1000, 2)) + ' KOhms'
Enfin, imprimez les lectures sur la coque :
print('Temperature: ', temp)
print('Humidity: ', hum)
print('Pressure: ', pres)
print('Gas:', gas)
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 BME680 doivent être affichées toutes les 5 secondes.
Afficher les lectures du BME680 sur le serveur Web
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-bme680-esp32-esp8266/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-bme680-esp32-esp8266/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
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 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.