ESP8266 NodeMCU MQTT – Publier les lectures du capteur BME680 (Arduino)

Découvrez comment publier les lectures des capteurs BME680 (température, humidité, pression et qualité de l’air gazeux) via MQTT avec le NodeMCU ESP8266 sur n’importe quelle plate-forme prenant en charge MQTT ou n’importe quel client MQTT. Par exemple, nous publierons les lectures des capteurs sur le tableau de bord Node-RED et l’ESP8266 sera programmé à l’aide de l’IDE Arduino.

Lecture recommandée: Qu’est-ce que MQTT et comment ça marche

Aperçu du projet

Le diagramme suivant montre une vue d’ensemble de haut niveau du projet que nous allons construire.

• L’ESP8266 demande des lectures de capteur au capteur BME680.
• Les relevés de température sont publiés dans le esp/bme680/température sujet;
• Les mesures d’humidité sont publiées dans le esp/bme680/humiditésujet;
• Les relevés de pression sont publiés dans le esp/bme680/pression sujet;
• Les relevés de gaz sont publiés dans le esp/bme680/gaz sujet;
• Node-RED est abonné à ces sujets ;
• Node-RED reçoit les lectures des capteurs et les affiche ensuite sur les jauges et les champs de texte ;
• Vous pouvez recevoir les lectures sur n’importe quelle autre plate-forme prenant en charge MQTT et gérer les lectures comme vous le souhaitez.

Conditions préalables

Avant de poursuivre ce didacticiel, assurez-vous de vérifier les prérequis suivants.

EDI Arduino

Nous allons programmer l’ESP8266 à l’aide de l’IDE Arduino, alors assurez-vous que le module complémentaire ESP8266 est installé.

Courtier MQTT

Pour utiliser MQTT, vous avez besoin d’un courtier. Nous utiliserons Courtier Moustique installé sur un Raspberry Pi. Lisez Comment installer Mosquitto Broker sur Raspberry Pi.

Vous pouvez utiliser n’importe quel autre broker MQTT, y compris un broker cloud MQTT. Nous vous montrerons comment faire cela dans le code plus tard.

Si vous n’êtes pas familier avec MQTT, assurez-vous de lire notre tutoriel d’introduction : Qu’est-ce que MQTT et comment ça marche.

Bibliothèques MQTT

Pour utiliser MQTT avec l’ESP8266, nous utiliserons le Bibliothèque cliente MQTT asynchrone.

Installation de la bibliothèque cliente MQTT asynchrone

1. Cliquez ici pour télécharger la bibliothèque client Async MQTT. Vous devriez avoir un dossier .zip dans votre Téléchargements dossier
2. Décompressez le dossier .zip et vous devriez obtenir async-mqtt-client-maître dossier
3. Renommez votre dossier de async-mqtt-client-maître à async_mqtt_client
4. Bouge le async_mqtt_client dossier dans le dossier des bibliothèques d’installation de votre IDE Arduino
5. Enfin, rouvrez votre IDE Arduino

Alternativement, vous pouvez aller à Esquisser > Inclure la bibliothèque > Ajouter . ZIP *: FRANÇAIS bibliothèque et sélectionnez la bibliothèque que vous venez de télécharger.

Installation de la bibliothèque TCP asynchrone

Pour utiliser MQTT avec l’ESP, vous avez également besoin du Bibliothèque ESPAsyncTCP.

1. Cliquez ici pour télécharger la bibliothèque client ESPAsyncTCP. Vous devriez avoir un dossier .zip dans votre Téléchargements dossier
2. Décompressez le dossier .zip et vous devriez obtenir ESPAsyncTCP-maître dossier
3. Renommez votre dossier de ESPAsyncTCP-maître à ESPAsyncTCP
4. Bouge le ESPAsyncTCP dossier dans le dossier des bibliothèques d’installation de votre IDE Arduino
5. Enfin, rouvrez votre IDE Arduino

Alternativement, vous pouvez aller à Esquisser > Inclure la bibliothèque > Ajouter . ZIP *: FRANÇAIS bibliothèque et sélectionnez la bibliothèque que vous venez de télécharger.

Bibliothèques de capteurs BME680

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

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

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

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

3. Recherchez « Capteur unifié Adafruit« dans le champ 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.

Pour en savoir plus sur le capteur BME680, lisez notre guide : ESP8266 avec capteur BME680 utilisant Arduino IDE (pression, température, humidité).

Pièces requises

Pour 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 !

Diagramme schématique

Câblez le BME680 à l’ESP8266 comme indiqué dans le schéma suivant avec la broche SDA connectée à GPIO 4 et la broche SCL connectée à GPIO 5.

Code

Copiez le code suivant dans votre IDE Arduino. Pour que cela fonctionne pour vous, vous devez insérer vos informations d’identification réseau ainsi que les détails du courtier MQTT.

/*
  Rui Santos
  Complete project details at https://Raspberryme.com/esp8266-nodemcu-mqtt-publish-bme680-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 <ESP8266WiFi.h>
#include <Ticker.h>
#include <AsyncMqttClient.h>
#include <Wire.h>
#include <SPI.h>
#include <Adafruit_Sensor.h>
#include "Adafruit_BME680.h"

#define WIFI_SSID "REPLACE_WITH_YOUR_SSID"
#define WIFI_PASSWORD "REPLACE_WITH_YOUR_PASSWORD"

// Raspberry Pi Mosquitto MQTT Broker
#define MQTT_HOST IPAddress(192, 168, 1, XXX)
// For a cloud MQTT broker, type the domain name
//#define MQTT_HOST "example.com"
#define MQTT_PORT 1883

// Temperature MQTT Topics
#define MQTT_PUB_TEMP "esp/bme680/temperature"
#define MQTT_PUB_HUM  "esp/bme680/humidity"
#define MQTT_PUB_PRES "esp/bme680/pressure"
#define MQTT_PUB_GAS  "esp/bme680/gas"

/*#define BME_SCK 14
#define BME_MISO 12
#define BME_MOSI 13
#define BME_CS 15*/

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

// Variables to hold sensor readings
float temperature;
float humidity;
float pressure;
float gasResistance;

AsyncMqttClient mqttClient;
Ticker mqttReconnectTimer;

WiFiEventHandler wifiConnectHandler;
WiFiEventHandler wifiDisconnectHandler;
Ticker wifiReconnectTimer;

unsigned long previousMillis = 0;   // Stores last time temperature was published
const long interval = 10000;        // Interval at which to publish sensor readings

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;
}

void connectToWifi() {
  Serial.println("Connecting to Wi-Fi...");
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
}

void onWifiConnect(const WiFiEventStationModeGotIP& event) {
  Serial.println("Connected to Wi-Fi.");
  connectToMqtt();
}

void onWifiDisconnect(const WiFiEventStationModeDisconnected& event) {
  Serial.println("Disconnected from Wi-Fi.");
  mqttReconnectTimer.detach(); // ensure we don't reconnect to MQTT while reconnecting to Wi-Fi
  wifiReconnectTimer.once(2, connectToWifi);
}

void connectToMqtt() {
  Serial.println("Connecting to MQTT...");
  mqttClient.connect();
}

void onMqttConnect(bool sessionPresent) {
  Serial.println("Connected to MQTT.");
  Serial.print("Session present: ");
  Serial.println(sessionPresent);
}

void onMqttDisconnect(AsyncMqttClientDisconnectReason reason) {
  Serial.println("Disconnected from MQTT.");

  if (WiFi.isConnected()) {
    mqttReconnectTimer.once(2, connectToMqtt);
  }
}

/*void onMqttSubscribe(uint16_t packetId, uint8_t qos) {
  Serial.println("Subscribe acknowledged.");
  Serial.print("  packetId: ");
  Serial.println(packetId);
  Serial.print("  qos: ");
  Serial.println(qos);
}

void onMqttUnsubscribe(uint16_t packetId) {
  Serial.println("Unsubscribe acknowledged.");
  Serial.print("  packetId: ");
  Serial.println(packetId);
}*/

void onMqttPublish(uint16_t packetId) {
  Serial.print("Publish acknowledged.");
  Serial.print("  packetId: ");
  Serial.println(packetId);
}

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

  if (!bme.begin()) {
    Serial.println(F("Could not find a valid BME680 sensor, check wiring!"));
    while (1);
  }
  
  wifiConnectHandler = WiFi.onStationModeGotIP(onWifiConnect);
  wifiDisconnectHandler = WiFi.onStationModeDisconnected(onWifiDisconnect);
  
  mqttClient.onConnect(onMqttConnect);
  mqttClient.onDisconnect(onMqttDisconnect);
  //mqttClient.onSubscribe(onMqttSubscribe);
  //mqttClient.onUnsubscribe(onMqttUnsubscribe);
  mqttClient.onPublish(onMqttPublish);
  mqttClient.setServer(MQTT_HOST, MQTT_PORT);
  // If your broker requires authentication (username and password), set them below
  //mqttClient.setCredentials("REPlACE_WITH_YOUR_USER", "REPLACE_WITH_YOUR_PASSWORD");
  connectToWifi();
  
  // 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() {
  unsigned long currentMillis = millis();
  // Every X number of seconds (interval = 10 seconds) 
  // it publishes a new MQTT message
  if (currentMillis - previousMillis >= interval) {
    // Save the last time a new reading was published
    previousMillis = currentMillis;
    
    getBME680Readings();
    Serial.println();
    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);
    
    // Publish an MQTT message on topic esp/bme680/temperature
    uint16_t packetIdPub1 = mqttClient.publish(MQTT_PUB_TEMP, 1, true, String(temperature).c_str());
    Serial.printf("Publishing on topic %s at QoS 1, packetId: %i", MQTT_PUB_TEMP, packetIdPub1);
    Serial.printf("Message: %.2f n", temperature);

    // Publish an MQTT message on topic esp/bme680/humidity
    uint16_t packetIdPub2 = mqttClient.publish(MQTT_PUB_HUM, 1, true, String(humidity).c_str());
    Serial.printf("Publishing on topic %s at QoS 1, packetId %i: ", MQTT_PUB_HUM, packetIdPub2);
    Serial.printf("Message: %.2f n", humidity);

    // Publish an MQTT message on topic esp/bme680/pressure
    uint16_t packetIdPub3 = mqttClient.publish(MQTT_PUB_PRES, 1, true, String(pressure).c_str());
    Serial.printf("Publishing on topic %s at QoS 1, packetId %i: ", MQTT_PUB_PRES, packetIdPub3);
    Serial.printf("Message: %.2f n", pressure);

    // Publish an MQTT message on topic esp/bme680/gas
    uint16_t packetIdPub4 = mqttClient.publish(MQTT_PUB_GAS, 1, true, String(gasResistance).c_str());
    Serial.printf("Publishing on topic %s at QoS 1, packetId %i: ", MQTT_PUB_GAS, packetIdPub4);
    Serial.printf("Message: %.2f n", gasResistance);
  }
}

Afficher le code brut

Comment fonctionne le code

La section suivante importe toutes les bibliothèques requises.

#include <ESP8266WiFi.h>
#include <Ticker.h>
#include <AsyncMqttClient.h>
#include <Wire.h>
#include <SPI.h>
#include <Adafruit_Sensor.h>
#include "Adafruit_BME680.h"

Incluez vos informations d’identification réseau sur les lignes suivantes.

#define WIFI_SSID "REPLACE_WITH_YOUR_SSID"
#define WIFI_PASSWORD "REPLACE_WITH_YOUR_PASSWORD"

Insérez l’adresse IP du Raspberry Pi, afin que l’ESP8266 se connecte à votre courtier.

#define MQTT_HOST IPAddress(192, 168, 1, 106)

Si vous utilisez un courtier cloud MQTT, insérez le nom de domaine du courtier, par exemple :

#define MQTT_HOST "example.com"

Définissez le port MQTT.

#define MQTT_PORT 1883

La température, l’humidité et la pression seront publiées sur les sujets suivants :

#define MQTT_PUB_TEMP "esp/bme680/temperature"
#define MQTT_PUB_HUM  "esp/bme680/humidity"
#define MQTT_PUB_PRES "esp/bme680/pressure"
#define MQTT_PUB_GAS  "esp/bme680/gas"

Initialiser un Adafruit_BME680 objet appelé bme.

Adafruit_BME680 bme;

le Température, humidité, pression, et gazrésistance les variables contiendront toutes les lectures de capteur du capteur BME680.

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

Créé un AsyncMqttClientAsyncMqttClient objet appelé mqttClient pour gérer le client MQTT et les minuteurs pour se reconnecter à votre courtier et routeur MQTT lorsqu’il se déconnecte.

AsyncMqttClient mqttClient;
Ticker mqttReconnectTimer;

WiFiEventHandler wifiConnectHandler;
WiFiEventHandler wifiDisconnectHandler;
Ticker wifiReconnectTimer;

Ensuite, créez des variables de minuterie auxiliaires pour publier les lectures toutes les 10 secondes. Vous pouvez modifier le temps de retard sur le intervalle variable.

unsigned long previousMillis = 0;
const long interval = 10000;

Fonctions MQTT : connexion au Wi-Fi, connexion au MQTT et événements Wi-Fi

Nous n’avons ajouté aucun commentaire aux fonctions définies dans la section de code suivante. Ces fonctions sont fournies avec la bibliothèque Async Mqtt Client. Les noms des fonctions sont assez explicites.

Par exemple, le connectToWifi() connecte votre ESP8266 à votre routeur :

void connectToWifi() {
  Serial.println("Connecting to Wi-Fi...");
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
}

le connectToMqtt() connecte votre ESP8266 à votre broker MQTT :

void connectToMqtt() {
  Serial.println("Connecting to MQTT…");
  mqttClient.connect();
}

le onWifiConnect() et onWifiDisconnect() sont responsables de la gestion des événements Wi-Fi. Par exemple, après une connexion réussie avec le routeur et le courtier MQTT, il imprime l’adresse IP ESP8266. D’autre part, si la connexion est perdue, il démarre un minuteur et tente de se reconnecter.

void onWifiConnect(const WiFiEventStationModeGotIP& event) {
  Serial.println("Connected to Wi-Fi.");
  connectToMqtt();
}

void onWifiDisconnect(const WiFiEventStationModeDisconnected& event) {
  Serial.println("Disconnected from Wi-Fi.");
  mqttReconnectTimer.detach();
  wifiReconnectTimer.once(2, connectToWifi);
}

le onMqttConnect() La fonction s’exécute après le démarrage d’une session avec le courtier.

void onMqttConnect(bool sessionPresent) {
  Serial.println("Connected to MQTT.");
  Serial.print("Session present: ");
  Serial.println(sessionPresent);
}

Fonctions MQTT : déconnecter et publier

Si l’ESP8266 perd la connexion avec le courtier MQTT, il appelle le onMqttDisconnect fonction qui imprime ce message dans le moniteur série.

void onMqttDisconnect(AsyncMqttClientDisconnectReason reason) {
  Serial.println("Disconnected from MQTT.");

  if (WiFi.isConnected()) {
    mqttReconnectTimer.once(2, connectToMqtt);
  }
}

Lorsque vous publiez un message dans un sujet MQTT, le onMqttPublish() fonction est appelée. Il imprime l’identifiant du paquet dans le moniteur série.

void onMqttPublish(uint16_t packetId) {
  Serial.println("Publish acknowledged.");
  Serial.print("  packetId: ");
  Serial.println(packetId);
}

Fondamentalement, toutes ces fonctions que nous venons de mentionner sont des fonctions de rappel. Ils sont donc exécutés de manière asynchrone.

mettre en place()

Passons maintenant à la mettre en place(). Initialisez le capteur BME680.

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

Les deux lignes suivantes attribuent des rappels qui géreront ce qui se passe lorsque l’ESP se connecte ou se déconnecte de votre connexion Wi-Fi.

wifiConnectHandler = WiFi.onStationModeGotIP(onWifiConnect);
wifiDisconnectHandler = WiFi.onStationModeDisconnected(onWifiDisconnect);

Enfin, affectez toutes les fonctions de rappel. Cela signifie que ces fonctions seront exécutées automatiquement en cas de besoin. Par exemple, lorsque l’ESP8266 se connecte au courtier, il appelle automatiquement le onMqttConnect() fonction, et ainsi de suite.

mqttClient.onConnect(onMqttConnect);
mqttClient.onDisconnect(onMqttDisconnect);
//mqttClient.onSubscribe(onMqttSubscribe);
//mqttClient.onUnsubscribe(onMqttUnsubscribe);
mqttClient.onPublish(onMqttPublish);
mqttClient.setServer(MQTT_HOST, MQTT_PORT);

Authentification du courtier

Si votre courtier requiert une authentification, décommentez la ligne suivante et insérez vos informations d’identification (nom d’utilisateur et mot de passe).

mqttClient.setCredentials("REPlACE_WITH_YOUR_USER", "REPLACE_WITH_YOUR_PASSWORD");

Connectez-vous au Wi-Fi.

connectToWifi();

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

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

boucler()

Dans le boucler(), vous créez une minuterie qui vous permet d’obtenir de nouvelles lectures du capteur BME680 et de les publier sur le sujet correspondant toutes les 10 secondes.

unsigned long currentMillis = millis();
// Every X number of seconds (interval = 10 seconds) 
// it publishes a new MQTT message
if (currentMillis - previousMillis >= interval) {
  // Save the last time a new reading was published
  previousMillis = currentMillis;
   
  getBME680Readings();
  Serial.println();
  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);

En savoir plus sur l’obtention de lectures du capteur BME680 : ESP8266 avec le guide des capteurs de température, d’humidité et de pression BME680.

Publication dans des rubriques

Pour publier les lectures sur les sujets MQTT correspondants, utilisez les lignes suivantes :

uint16_t packetIdPub1 = mqttClient.publish(MQTT_PUB_TEMP, 1, true, String(temperature).c_str());
uint16_t packetIdPub2 = mqttClient.publish(MQTT_PUB_HUM, 1, true, String(humidity).c_str());
uint16_t packetIdPub3 = mqttClient.publish(MQTT_PUB_PRES, 1, true, String(pressure).c_str());
uint16_t packetIdPub4 = mqttClient.publish(MQTT_PUB_GAS, 1, true, String(gasResistance).c_str());

En gros, utilisez le publier() méthode sur la mqttClient objet de publier des données sur un sujet. le publier() La méthode accepte les arguments suivants, dans l’ordre :

• Rubrique MQTT (const char*)
• QoS (uint8_t) : qualité de service – elle peut être de 0, 1 ou 2
• retenir l’indicateur (bool): conserver l’indicateur
• charge utile (const char*) – dans ce cas, la charge utile correspond à la lecture du capteur

La QoS (qualité de service) est un moyen de garantir que le message est délivré. Il peut s’agir de l’un des niveaux suivants :

• 0: le message sera délivré une fois ou pas du tout. Le message n’est pas acquitté. Il n’y a aucune possibilité de messages en double ;
• 1: le message sera délivré au moins une fois, mais peut être délivré plus d’une fois ;
• 2: le message est toujours livré exactement une fois ;
• En savoir plus sur la qualité de service MQTT.

Téléchargement du code

Avec votre Raspberry Pi allumé et exécutant le courtier Mosquitto MQTT, téléchargez le code sur votre ESP8266.

Ouvrez le moniteur série à un débit en bauds de 115200 et vous verrez que l’ESP8266 commence à publier des messages sur les sujets que nous avons définis précédemment.

Préparation du tableau de bord Node-RED

L’ESP8266 publie des lectures de capteurs toutes les 10 secondes sur quatre sujets MQTT. Désormais, vous pouvez utiliser n’importe quel tableau de bord prenant en charge MQTT ou tout autre appareil prenant en charge MQTT pour vous abonner à ces rubriques et recevoir les lectures.

À titre d’exemple, nous allons créer un flux simple à l’aide de Node-RED pour vous abonner à ces sujets et afficher les lectures sur les jauges.

Si vous n’avez pas installé Node-RED, suivez les tutoriels suivants :

Avec Node-RED en cours d’exécution sur votre Raspberry Pi, accédez à l’adresse IP de votre Raspberry Pi suivie de :1880.

http://raspberry-pi-ip-address:1880

L’interface Node-RED devrait s’ouvrir. Faites glisser quatre nœuds d’entrée MQTT, deux nœuds de jauge et deux nœuds de champ de texte vers le flux.

Cliquez sur le nœud MQTT et modifiez ses propriétés.

Le champ Serveur fait référence au courtier MQTT. Dans notre cas, le courtier MQTT est le Raspberry Pi, il est donc défini sur localhost:1883. Si vous utilisez un courtier Cloud MQTT, vous devez modifier ce champ.

Insérez le sujet auquel vous souhaitez vous abonner et la QoS. Ce nœud MQTT précédent est abonné au esp/bme680/température sujet.

Cliquez sur l’autre MQTT dans les nœuds et modifiez ses propriétés avec le même serveur, mais pour les autres sujets : esp/bme680/humidité, esp/bme680/pression, et esp/bme680/gaz.

Cliquez sur les nœuds de la jauge et modifiez ses propriétés pour chaque lecture. Le nœud suivant est défini pour les relevés de température. Modifiez les autres nœuds du graphique pour les relevés d’humidité.

Câblez vos nœuds comme indiqué ci-dessous :

Enfin, déployez votre flux (appuyez sur le bouton dans le coin supérieur droit).

Alternativement, vous pouvez aller à Menu > Importer et copiez ce qui suit dans votre Presse-papiers pour créer votre flux Node-RED.

[{"id":"3b7f947c.9759ec","type":"mqtt in","z":"254c9c97.f85b34","name":"","topic":"esp/bme680/temperature","qos":"1","datatype":"auto","broker":"8db3fac0.99dd48","x":470,"y":2640,"wires":[["b87b21c3.96672"]]},{"id":"b87b21c3.96672","type":"ui_gauge","z":"254c9c97.f85b34","name":"","group":"37de8fe8.46846","order":2,"width":0,"height":0,"gtype":"gage","title":"Temperature","label":"ºC","format":"{{value}}","min":0,"max":"40","colors":["#00b500","#f7df09","#ca3838"],"seg1":"","seg2":"","x":690,"y":2640,"wires":[]},{"id":"f92248f4.545778","type":"mqtt in","z":"254c9c97.f85b34","name":"","topic":"esp/bme680/humidity","qos":"1","datatype":"auto","broker":"8db3fac0.99dd48","x":460,"y":2700,"wires":[["4114a401.5ac69c"]]},{"id":"4114a401.5ac69c","type":"ui_gauge","z":"254c9c97.f85b34","name":"","group":"37de8fe8.46846","order":2,"width":0,"height":0,"gtype":"gage","title":"Humidity","label":"%","format":"{{value}}","min":"30","max":"100","colors":["#53a4e6","#1d78a9","#4e38c9"],"seg1":"","seg2":"","x":680,"y":2700,"wires":[]},{"id":"ad51f895.2c2848","type":"mqtt in","z":"254c9c97.f85b34","name":"","topic":"esp/bme680/pressure","qos":"1","datatype":"auto","broker":"8db3fac0.99dd48","x":460,"y":2760,"wires":[["3a95123b.66405e"]]},{"id":"c074e688.198b78","type":"mqtt in","z":"254c9c97.f85b34","name":"","topic":"esp/bme680/gas","qos":"1","datatype":"auto","broker":"8db3fac0.99dd48","x":440,"y":2820,"wires":[["d3539c06.00a17"]]},{"id":"3a95123b.66405e","type":"ui_text","z":"254c9c97.f85b34","group":"37de8fe8.46846","order":2,"width":0,"height":0,"name":"","label":"Pressure","format":"{{msg.payload}} hPa","layout":"row-spread","x":680,"y":2760,"wires":[]},{"id":"d3539c06.00a17","type":"ui_text","z":"254c9c97.f85b34","group":"37de8fe8.46846","order":3,"width":0,"height":0,"name":"","label":"Gas","format":"{{msg.payload}} KOhm","layout":"row-spread","x":670,"y":2820,"wires":[]},{"id":"8db3fac0.99dd48","type":"mqtt-broker","z":"","name":"","broker":"localhost","port":"1883","clientid":"","usetls":false,"compatmode":false,"keepalive":"60","cleansession":true,"birthTopic":"","birthQos":"0","birthPayload":"","closeTopic":"","closeQos":"0","closePayload":"","willTopic":"","willQos":"0","willPayload":""},{"id":"37de8fe8.46846","type":"ui_group","z":"","name":"BME680","tab":"53b8c8f9.cfbe48","order":1,"disp":true,"width":"6","collapse":false},{"id":"53b8c8f9.cfbe48","type":"ui_tab","z":"","name":"Home","icon":"dashboard","order":5,"disabled":false,"hidden":false}]

Afficher le code brut

Manifestation

Accédez à votre adresse IP Raspberry Pi suivie de :1880/ui.

http://raspberry-pi-ip-address:1880/ui

Vous devriez avoir accès aux lectures actuelles du capteur BME680 sur le tableau de bord. Vous pouvez utiliser d’autres nœuds de type tableau de bord pour afficher les lectures de différentes manières.

C’est ça! Votre carte ESP publie les relevés de température, d’humidité, de pression et de résistance au gaz BME680 sur Node-RED via MQTT.

Conclusion

MQTT est un excellent protocole de communication pour échanger de petites quantités de données entre appareils. Dans ce didacticiel, vous avez appris à publier des lectures de température, d’humidité, de pression et de résistance aux gaz à partir d’un capteur environnemental BME680 avec l’ESP8266 sur différents sujets MQTT. Ensuite, vous pouvez utiliser n’importe quel appareil ou plate-forme domotique pour vous abonner à ces sujets et recevoir les lectures.

Au lieu d’un capteur BME680, vous pouvez utiliser n’importe quel autre capteur comme un DS18B20 capteur de température, un DHT22 capteur de température et d’humidité ou un BME280 capteur de température, d’humidité et de pression :

Nous espérons que vous avez trouvé ce tutoriel utile. Si vous souhaitez en savoir plus sur l’ESP8266, consultez nos ressources :

Merci d’avoir lu.