MicroPython : BME680 avec ESP32/ESP8266 (température, humidité, pression, gaz)

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

Afficher le code brut

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)

Afficher le code brut

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())

Afficher le code brut

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')

Afficher le code brut

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 :

1. bme680.py
2. boot.py
3. 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.