ESP32 : Capteur environnemental BME680 utilisant Arduino IDE

Le BME680 est un capteur numérique environnemental qui mesure le gaz, la pression, l’humidité et la température. Dans ce guide, vous apprendrez à utiliser le module de capteur BME680 avec la carte ESP32 à l’aide de l’IDE Arduino. Le capteur communique avec un microcontrôleur à l’aide des protocoles de communication I2C ou SPI.

Vous apprendrez à câbler le capteur à la carte ESP32, à installer les bibliothèques requises, à utiliser un simple croquis pour afficher les lectures du capteur dans le moniteur série et à créer un serveur Web pour surveiller votre capteur à distance.

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 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 – il n’est pas spécifique à 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 (sauf le 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 génère des valeurs de résistance. Ces valeurs changent en raison des variations des concentrations de COV :

• Concentration plus élevée de COV » Résistance plus faible
• Faible concentration de COV » Résistance supérieure

Les réactions qui se produisent sur 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 après avoir commencé à 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 :

Plage de fonctionnement du BME680

Le tableau suivant indique la plage de fonctionnement des capteurs de température, d’humidité et de pression pour le BME680.

Brochage BME680

Voici le brochage du BME680 :

Interface BME680

Le BME680 prend en charge les interfaces I2C et SPI.

BME680 I2C

Pour utiliser le protocole de communication I2C, utilisez les broches suivantes :

GPIO 22 (SCL) et GPIO 21 (SDA) sont les broches ESP32 I2C par défaut. Vous pouvez utiliser d’autres broches tant que vous les définissez correctement sur le code.

Lecture recommandée : ESP32 I2C Communication : Set Pins, Multiple Bus Interfaces and Peripherals (Arduino IDE)

BME680 SPI

Pour utiliser le protocole de communication SPI, utilisez les broches suivantes :

Ce sont les broches ESP32 SPI par défaut. Vous pouvez utiliser d’autres broches tant que vous les définissez correctement dans le code.

Pièces requises

Pour terminer ce tutoriel, vous avez besoin des pièces suivantes :

Vous pouvez utiliser les liens précédents ou accéder directement à MakerAdvisor.com/tools pour trouver toutes les pièces pour vos projets au meilleur prix !

Schéma – ESP32 avec BME680

Le BME680 peut communiquer à l’aide des protocoles de communication I2C ou SPI.

ESP32 avec BME680 utilisant I2C

Suivez le diagramme schématique suivant pour câbler le BME680 à l’ESP32 en utilisant les broches I2C par défaut.

ESP32 avec BME680 utilisant SPI

Alternativement, vous pouvez utiliser le protocole de communication SPI à la place. Dans ce cas, suivez le diagramme schématique suivant pour câbler le BME680 à l’ESP32 en utilisant les broches SPI par défaut.

Lecture recommandée : Référence de brochage ESP32 : Quelles broches GPIO devez-vous utiliser ?

Préparation de l’IDE Arduino

Nous allons programmer la carte ESP32 à l’aide de l’IDE Arduino. Assurez-vous donc que le module complémentaire ESP32 est installé. Suivez le tutoriel suivant :

Vous devez également installer la bibliothèque Adafruit BME680 et la bibliothèque Adafruit Unified Sensor.

Installation de la bibliothèque BME680

Pour obtenir des lectures du module de capteur BME680, nous utiliserons le Bibliothèque Adafruit_BME680. Suivez les étapes suivantes pour installer la bibliothèque dans votre IDE Arduino :

Ouvrez votre IDE Arduino et accédez à Sketch> Inclure la bibliothèque> Gérer les bibliothèques. Le gestionnaire de bibliothèque devrait s’ouvrir.

Recherchez « adafruit bme680 » dans la zone de recherche et installez la bibliothèque.

Installation de la bibliothèque Adafruit_Sensor

Pour utiliser la bibliothèque BME680, vous devez également installer le Bibliothèque Adafruit_Sensor. Suivez les étapes suivantes pour installer la bibliothèque dans votre IDE Arduino :

Accédez à Sketch > Inclure la bibliothèque > Gérer les bibliothèques et tapez « Adafruit Unified Sensor » dans la zone de recherche. Faites défiler vers le bas pour trouver la bibliothèque et installez-la.

Après avoir installé les bibliothèques, redémarrez votre IDE Arduino.

Code – Lecture BME680 Gaz, Pression, Humidité et Température

Pour lire le gaz, la pression, la température et l’humidité, nous utiliserons un exemple de croquis de la bibliothèque.

Après avoir installé la bibliothèque BME680 et la bibliothèque Adafruit_Sensor, ouvrez l’IDE Arduino et accédez à Fichier > Exemples > Bibliothèque Adafruit BME680 > bme680async.

/***
  Read Our Complete Guide: https://Raspberryme.com/esp32-bme680-sensor-arduino/
  Designed specifically to work with the Adafruit BME680 Breakout ----> http://www.adafruit.com/products/3660 These sensors use I2C or SPI to communicate, 2 or 4 pins are required to interface. Adafruit invests time and resources providing this open source code, please support Adafruit and open-source hardware by purchasing products from Adafruit! Written by Limor Fried & Kevin Townsend for Adafruit Industries. BSD license, all text above must be included in any redistribution
***/

#include <Wire.h>
#include <SPI.h>
#include <Adafruit_Sensor.h>
#include "Adafruit_BME680.h"

/*#define BME_SCK 18
#define BME_MISO 19
#define BME_MOSI 23
#define BME_CS 5*/

#define SEALEVELPRESSURE_HPA (1013.25)

Adafruit_BME680 bme; // I2C
//Adafruit_BME680 bme(BME_CS); // hardware SPI
//Adafruit_BME680 bme(BME_CS, BME_MOSI, BME_MISO, BME_SCK);

void setup() {
  Serial.begin(115200);
  while (!Serial);
  Serial.println(F("BME680 async test"));

  if (!bme.begin()) {
    Serial.println(F("Could not find a valid BME680 sensor, check wiring!"));
    while (1);
  }

  // Set up oversampling and filter initialization
  bme.setTemperatureOversampling(BME680_OS_8X);
  bme.setHumidityOversampling(BME680_OS_2X);
  bme.setPressureOversampling(BME680_OS_4X);
  bme.setIIRFilterSize(BME680_FILTER_SIZE_3);
  bme.setGasHeater(320, 150); // 320*C for 150 ms
}

void loop() {
  // Tell BME680 to begin measurement.
  unsigned long endTime = bme.beginReading();
  if (endTime == 0) {
    Serial.println(F("Failed to begin reading :("));
    return;
  }
  Serial.print(F("Reading started at "));
  Serial.print(millis());
  Serial.print(F(" and will finish at "));
  Serial.println(endTime);

  Serial.println(F("You can do other work during BME680 measurement."));
  delay(50); // This represents parallel work.
  // There's no need to delay() until millis() >= endTime: bme.endReading()
  // takes care of that. It's okay for parallel work to take longer than
  // BME680's measurement time.

  // Obtain measurement results from BME680. Note that this operation isn't
  // instantaneous even if milli() >= endTime due to I2C/SPI latency.
  if (!bme.endReading()) {
    Serial.println(F("Failed to complete reading :("));
    return;
  }
  Serial.print(F("Reading completed at "));
  Serial.println(millis());

  Serial.print(F("Temperature = "));
  Serial.print(bme.temperature);
  Serial.println(F(" *C"));

  Serial.print(F("Pressure = "));
  Serial.print(bme.pressure / 100.0);
  Serial.println(F(" hPa"));

  Serial.print(F("Humidity = "));
  Serial.print(bme.humidity);
  Serial.println(F(" %"));

  Serial.print(F("Gas = "));
  Serial.print(bme.gas_resistance / 1000.0);
  Serial.println(F(" KOhms"));

  Serial.print(F("Approx. Altitude = "));
  Serial.print(bme.readAltitude(SEALEVELPRESSURE_HPA));
  Serial.println(F(" m"));

  Serial.println();
  delay(2000);
}

Afficher le code brut

Nous avons apporté quelques modifications au croquis pour le rendre entièrement compatible avec l’ESP32.

Comment fonctionne le code

Continuez à lire cette section pour savoir comment fonctionne le code, ou passez à la Manifestation section.

Bibliothèques

Le code commence par inclure les bibliothèques nécessaires : la bibliothèque wire pour utiliser I2C, la bibliothèque SPI (si vous souhaitez utiliser SPI au lieu d’I2C), les bibliothèques Adafruit_Sensor et Adafruit_BME680 pour s’interfacer avec le capteur BME680.

#include <Wire.h>
#include <SPI.h>
#include <Adafruit_Sensor.h>
#include "Adafruit_BME680.h"

Communication SPI

Nous préférons utiliser le protocole de communication I2C avec le capteur. Cependant, le code est préparé si vous souhaitez utiliser SPI. Il vous suffit de décommenter les lignes de code suivantes qui définissent les broches SPI.

/*#define BME_SCK 18
#define BME_MISO 19
#define BME_MOSI 23
#define BME_CS 15*/

Pression au niveau de la mer

Une variable appelée SEALEVELPRESSURE_HPA est créée.

#define SEALEVELPRESSURE_HPA (1013.25)

Cette variable enregistre la pression au niveau de la mer en hectopascal (équivaut à milibar). Cette variable permet d’estimer l’altitude pour une pression donnée en la comparant à la pression au niveau de la mer. Cet exemple utilise la valeur par défaut, mais pour des résultats précis, remplacez la valeur par la pression actuelle au niveau de la mer à votre emplacement.

I2C

Cet exemple utilise le protocole de communication I2C par défaut. La ligne suivante crée un objet Adafruit_BME680 appelé bme sur les broches ESP32 I2C par défaut : GPIO 22 (SCL), GPIO 21 (SDA).

Adafruit_BME680 bme; // I2C

Pour utiliser SPI, vous devez commenter cette ligne précédente et décommenter la ligne suivante.

//Adafruit_BME680 bme(BME_CS, BME_MOSI, BME_MISO, BME_SCK); // software SPI

installation()

Dans le setup() démarrer une communication série.

Serial.begin(115200);

Initialiser le capteur BME680

Initialisez le capteur BME680 :

if (!bme.begin()) {
  Serial.println(F("Could not find a valid BME680 sensor, check wiring!"));
  while (1);
}

Configurez les paramètres suivants (suréchantillonnage, filtre et réchauffeur de gaz) pour le capteur.

// Set up oversampling and filter initialization
bme.setTemperatureOversampling(BME680_OS_8X);
bme.setHumidityOversampling(BME680_OS_2X);
bme.setPressureOversampling(BME680_OS_4X);
bme.setIIRFilterSize(BME680_FILTER_SIZE_3);
bme.setGasHeater(320, 150); // 320*C for 150 ms

Pour augmenter la résolution des données brutes du capteur, il prend en charge le suréchantillonnage. Nous utiliserons les paramètres de suréchantillonnage par défaut, mais vous pouvez les modifier.

• setTemperatureOversampling() : définit le suréchantillonnage de la température.
• setHumidityOversampling() : définit le suréchantillonnage de l’humidité.
• setPressureOversampling() : définit le suréchantillonnage de la pression.

Ces méthodes peuvent accepter l’un des paramètres suivants :

• BME680_OS_NONE : désactiver la lecture ;
• BME680_OS_1X
• BME680_OS_2X
• BME680_OS_4X
• BME680_OS_8X
• BME680_OS_16X

Le capteur BME680 intègre un filtre IIR interne pour réduire les variations à court terme des valeurs de sortie du capteur causées par des perturbations externes. La méthode setIIRFilterSize() définit le filtre IIR. Il accepte la taille du filtre en paramètre :

• BME680_FILTER_SIZE_0 (pas de filtrage)
• BME680_FILTER_SIZE_1
• BME680_FILTER_SIZE_3
• BME680_FILTER_SIZE_7
• BME680_FILTER_SIZE_15
• BME680_FILTER_SIZE_31
• BME680_FILTER_SIZE_63
• BME680_FILTER_SIZE_127

Le capteur de gaz intègre un réchauffeur. Définissez le profil du réchauffeur à l’aide de la méthode setGasHeater() qui accepte comme arguments :

• la température du réchauffeur (en degrés centigrades)
• le temps pendant lequel le chauffage doit être allumé (en millisecondes)

Nous utiliserons les paramètres par défaut : 320 ºC pendant 150 ms.

boucle()

Dans la boucle (), nous obtiendrons des mesures du capteur BME680.

Tout d’abord, dites au capteur de démarrer une lecture asynchrone avec bme.beginReading(). Cela renvoie l’heure à laquelle la lecture serait prête.

// Tell BME680 to begin measurement.
unsigned long endTime = bme.beginReading();
if (endTime == 0) {
  Serial.println(F("Failed to begin reading :("));
  return;
}
Serial.print(F("Reading started at "));
Serial.print(millis());
Serial.print(F(" and will finish at "));
Serial.println(endTime);

Ensuite, appelez la méthode endReading() pour terminer une lecture asynchrone. Si la lecture asynchrone est toujours en cours, bloquer jusqu’à la fin.

if (!bme.endReading()) {
  Serial.println(F("Failed to complete reading :("));
  return;
}

Après cela, nous pouvons obtenir les lectures comme suit:

• bme.temperature : renvoie la lecture de la température
• bme.pressure : renvoie la lecture de la pression
• bme.humidity : renvoie la lecture de l’humidité
• bme.gas_resistance : renvoie la résistance au gaz

Serial.print(F("Temperature = "));
Serial.print(bme.temperature);
Serial.println(F(" *C"));

Serial.print(F("Pressure = "));
Serial.print(bme.pressure / 100.0);
Serial.println(F(" hPa"));

Serial.print(F("Humidity = "));
Serial.print(bme.humidity);
Serial.println(F(" %"));

Serial.print(F("Gas = "));
Serial.print(bme.gas_resistance / 1000.0);
Serial.println(F(" KOhms"));

Serial.print(F("Approx. Altitude = "));
Serial.print(bme.readAltitude(SEALEVELPRESSURE_HPA));
Serial.println(F(" m"));

Pour plus d’informations sur les méthodes de la bibliothèque, consultez le Adafruit_BME6Référence de classe 80.

Manifestation

Téléchargez le code sur votre carte ESP32. Allez dans Outils > Carte et sélectionnez la carte ESP32 que vous utilisez. Allez dans Outils > Port et sélectionnez le port auquel votre carte est connectée. Ensuite, cliquez sur le bouton de téléchargement.

Ouvrez le moniteur série à un débit en bauds de 115200, appuyez sur le bouton RST intégré. Les mesures du capteur seront affichées.

Code – Serveur Web ESP32 avec BME680

Dans cette section, nous fournissons un exemple de serveur Web que vous pouvez créer avec l’ESP32 pour afficher les lectures BME680.

Installation de bibliothèques – Serveur Web asynchrone

Pour construire le serveur Web, vous devez installer les bibliothèques suivantes. Cliquez sur les liens ci-dessous pour télécharger les bibliothèques.

Ces bibliothèques ne peuvent pas être installées via le gestionnaire de bibliothèque Arduino, vous devez donc copier les fichiers de bibliothèque dans le dossier Bibliothèques d’installation Arduino. Alternativement, dans votre IDE Arduino, vous pouvez aller à Sketch> Inclure la bibliothèque> Ajouter une bibliothèque .zip et sélectionner les bibliothèques que vous venez de télécharger.

Code

Ensuite, téléchargez le code suivant sur votre carte (tapez votre SSID et votre mot de passe).

/*********
  Rui Santos
  Complete project details at https://Raspberryme.com/esp32-bme680-sensor-arduino/
  
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files.
  
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
*********/

#include <Wire.h>
#include <SPI.h>
#include <Adafruit_Sensor.h>
#include "Adafruit_BME680.h"
#include <WiFi.h>
#include "ESPAsyncWebServer.h"

// Replace with your network credentials
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

//Uncomment if using SPI
/*#define BME_SCK 18
#define BME_MISO 19
#define BME_MOSI 23
#define BME_CS 5*/

Adafruit_BME680 bme; // I2C
//Adafruit_BME680 bme(BME_CS); // hardware SPI
//Adafruit_BME680 bme(BME_CS, BME_MOSI, BME_MISO, BME_SCK);

float temperature;
float humidity;
float pressure;
float gasResistance;

AsyncWebServer server(80);
AsyncEventSource events("/events");

unsigned long lastTime = 0;  
unsigned long timerDelay = 30000;  // send readings timer

void getBME680Readings(){
  // Tell BME680 to begin measurement.
  unsigned long endTime = bme.beginReading();
  if (endTime == 0) {
    Serial.println(F("Failed to begin reading :("));
    return;
  }
  if (!bme.endReading()) {
    Serial.println(F("Failed to complete reading :("));
    return;
  }
  temperature = bme.temperature;
  pressure = bme.pressure / 100.0;
  humidity = bme.humidity;
  gasResistance = bme.gas_resistance / 1000.0;
}

String processor(const String& var){
  getBME680Readings();
  //Serial.println(var);
  if(var == "TEMPERATURE"){
    return String(temperature);
  }
  else if(var == "HUMIDITY"){
    return String(humidity);
  }
  else if(var == "PRESSURE"){
    return String(pressure);
  }
 else if(var == "GAS"){
    return String(gasResistance);
  }
}

const char index_html[] PROGMEM = R"rawliteral(
<!DOCTYPE HTML><html>
<head>
  <title>BME680 Web Server</title>
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.7.2/css/all.css" integrity="sha384-fnmOCqbTlWIlj8LyTjo7mOUStjsKC4pOpQbqyi7RrhN7udi9RwhKkMHpvLbHG9Sr" crossorigin="anonymous">
  <link rel="icon" href="data:,">
  <style>
    html {font-family: Arial; display: inline-block; text-align: center;}
    p {  font-size: 1.2rem;}
    body {  margin: 0;}
    .topnav { overflow: hidden; background-color: #4B1D3F; color: white; font-size: 1.7rem; }
    .content { padding: 20px; }
    .card { background-color: white; box-shadow: 2px 2px 12px 1px rgba(140,140,140,.5); }
    .cards { max-width: 700px; margin: 0 auto; display: grid; grid-gap: 2rem; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); }
    .reading { font-size: 2.8rem; }
    .card.temperature { color: #0e7c7b; }
    .card.humidity { color: #17bebb; }
    .card.pressure { color: #3fca6b; }
    .card.gas { color: #d62246; }
  </style>
</head>
<body>
  <div class="topnav">
    <h3>BME680 WEB SERVER</h3>
  </div>
  <div class="content">
    <div class="cards">
      <div class="card temperature">
        <h4><i class="fas fa-thermometer-half"></i> TEMPERATURE</h4><p><span class="reading"><span id="temp">%TEMPERATURE%</span> &deg;C</span></p>
      </div>
      <div class="card humidity">
        <h4><i class="fas fa-tint"></i> HUMIDITY</h4><p><span class="reading"><span id="hum">%HUMIDITY%</span> &percnt;</span></p>
      </div>
      <div class="card pressure">
        <h4><i class="fas fa-angle-double-down"></i> PRESSURE</h4><p><span class="reading"><span id="pres">%PRESSURE%</span> hPa</span></p>
      </div>
      <div class="card gas">
        <h4><i class="fas fa-wind"></i> GAS</h4><p><span class="reading"><span id="gas">%GAS%</span> K&ohm;</span></p>
      </div>
    </div>
  </div>
<script>
if (!!window.EventSource) {
 var source = new EventSource('/events');
 
 source.addEventListener('open', function(e) {
  console.log("Events Connected");
 }, false);
 source.addEventListener('error', function(e) {
  if (e.target.readyState != EventSource.OPEN) {
    console.log("Events Disconnected");
  }
 }, false);
 
 source.addEventListener('message', function(e) {
  console.log("message", e.data);
 }, false);
 
 source.addEventListener('temperature', function(e) {
  console.log("temperature", e.data);
  document.getElementById("temp").innerHTML = e.data;
 }, false);
 
 source.addEventListener('humidity', function(e) {
  console.log("humidity", e.data);
  document.getElementById("hum").innerHTML = e.data;
 }, false);
 
 source.addEventListener('pressure', function(e) {
  console.log("pressure", e.data);
  document.getElementById("pres").innerHTML = e.data;
 }, false);
 
 source.addEventListener('gas', function(e) {
  console.log("gas", e.data);
  document.getElementById("gas").innerHTML = e.data;
 }, false);
}
</script>
</body>
</html>)rawliteral";

void setup() {
  Serial.begin(115200);

  // Set the device as a Station and Soft Access Point simultaneously
  WiFi.mode(WIFI_AP_STA);
  
  // Set device as a Wi-Fi Station
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Setting as a Wi-Fi Station..");
  }
  Serial.print("Station IP Address: ");
  Serial.println(WiFi.localIP());
  Serial.println();

  // Init BME680 sensor
  if (!bme.begin()) {
    Serial.println(F("Could not find a valid BME680 sensor, check wiring!"));
    while (1);
  }
  // Set up oversampling and filter initialization
  bme.setTemperatureOversampling(BME680_OS_8X);
  bme.setHumidityOversampling(BME680_OS_2X);
  bme.setPressureOversampling(BME680_OS_4X);
  bme.setIIRFilterSize(BME680_FILTER_SIZE_3);
  bme.setGasHeater(320, 150); // 320*C for 150 ms

  // Handle Web Server
  server.on("/", HTTP_GET, [](AsyncWebServerRequest *request){
    request->send_P(200, "text/html", index_html, processor);
  });

  // Handle Web Server Events
  events.onConnect([](AsyncEventSourceClient *client){
    if(client->lastId()){
      Serial.printf("Client reconnected! Last message ID that it got is: %u\n", client->lastId());
    }
    // send event with message "hello!", id current millis
    // and set reconnect delay to 1 second
    client->send("hello!", NULL, millis(), 10000);
  });
  server.addHandler(&events);
  server.begin();
}

void loop() {
  if ((millis() - lastTime) > timerDelay) {
    getBME680Readings();
    Serial.printf("Temperature = %.2f ºC \n", temperature);
    Serial.printf("Humidity = %.2f % \n", humidity);
    Serial.printf("Pressure = %.2f hPa \n", pressure);
    Serial.printf("Gas Resistance = %.2f KOhm \n", gasResistance);
    Serial.println();

    // Send Events to the Web Server with the Sensor Readings
    events.send("ping",NULL,millis());
    events.send(String(temperature).c_str(),"temperature",millis());
    events.send(String(humidity).c_str(),"humidity",millis());
    events.send(String(pressure).c_str(),"pressure",millis());
    events.send(String(gasResistance).c_str(),"gas",millis());
    
    lastTime = millis();
  }
}

Afficher le code brut

Manifestation

Après le téléchargement, ouvrez le moniteur série à un débit en bauds de 115200 pour obtenir l’adresse IP ESP32.

Ouvrez un navigateur et tapez l’adresse IP. Vous devriez avoir accès au serveur Web avec les dernières lectures de capteur. Vous pouvez accéder au serveur Web sur votre ordinateur, tablette ou smartphone dans votre réseau local.

Les lectures sont mises à jour automatiquement sur le serveur Web à l’aide des événements envoyés par le serveur.

Nous n’expliquerons pas le fonctionnement du serveur Web dans ce didacticiel. Nous avons rédigé ce guide dédié au serveur web BME680 avec la carte ESP32.

Conclusion

Le module de capteur BME680 est un capteur numérique 4 en 1 qui combine des capteurs de gaz, de pression, de température et d’humidité. Le BME680 contient un capteur MOX qui détecte la présence de la plupart des gaz COV. Ce capteur vous donne une idée qualitative de la somme des COV/contaminants dans l’air ambiant. Pour cette raison, le BME680 peut être utilisé pour surveiller la qualité de l’air intérieur.

Si vous utilisez un ESP8266, lisez ESP8266 NodeMCU : capteur environnemental BME680 utilisant l’IDE Arduino (gaz, pression, humidité, température).

Nous espérons que vous avez trouvé ce guide de démarrage utile. Nous avons des guides pour d’autres capteurs populaires :

En savoir plus sur l’ESP32 avec nos ressources :

Merci d’avoir lu.

Cette vidéo vous emmène dans l’histoire de Raspberry Pi :