MicroPython : BME280 avec ESP32 et ESP8266 (Pression, Température, Humidité)

MicroPython : BME280 avec ESP32 et ESP8266 (Pression, Température, Humidité)

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.

MicroPython BME280 avec ESP32 et ESP8266 Température, humidité et pression

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.

Capteur de température, d'humidité et de pression BME280

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

MicroPython BME280 avec ESP32 et ESP8266 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 !

MicroPython BME280 avec ESP32 et ESP8266 Pression Temperature Humidite

Schéma – ESP32

Suivez le schéma suivant si vous utilisez une carte ESP32 :

Schéma de câblage du module de capteur ESP32 BME280

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 :

Schéma de câblage du module de capteur ESP8266 BME280

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)

Afficher le code brut

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

Installez la bibliothèque BME280 MicroPython ESP32 ESP8266 uPyCraft IDE étape 1

4. Appelez ce nouveau fichier « BME280.py » et appuyez sur d’accord.

Installez la bibliothèque BME280 MicroPython ESP32 ESP8266 uPyCraft IDE étape 2

5. Clique le Télécharger et exécuter bouton.

Installez la bibliothèque BME280 MicroPython ESP32 ESP8266 uPyCraft IDE étape 3

Le fichier doit être enregistré dans le dossier de l’appareil sous le nom « BME280.py», comme le montre la figure suivante.

Installez la bibliothèque BME280 MicroPython ESP32 ESP8266 uPyCraft IDE étape 4

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…

Thonny IDE ESP32 ESP8266 MicroPython Enregistrer la bibliothèque de fichiers sur l'appareil enregistrer sous

3. Sélectionnez enregistrer dans « Périphérique MicroPython » :

Thonny IDE ESP32 ESP8266 MicroPython Enregistrer la bibliothèque de fichiers sur la sélection de l'appareil

4. Nommez votre fichier comme bme680.py et appuyez sur le bouton OK :

Bibliothèque BME280 nouveau fichier MicroPython Thonny IDE

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 :

Fichier MicroPython de la bibliothèque BME280 créé Thonny IDE

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)

Afficher le code brut

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 BME280

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), 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.pressure

Enfin, 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.

BME280 MicroPython ESP32 ESP8266 Impression des lectures dans Python Shell

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.

Afficher les lectures BME280 sur le serveur Web avec ESP32 ou ESP8266

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

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

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 :

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 :

  1. BME280.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.

1641834015 323 MicroPython BME280 avec ESP32 et ESP8266 Pression Temperature Humidite

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.

Serveur Web BME280 MicroPython avec ESP8266 ou ESP32

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">

Emballer

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.