ESP32 MQTT – Publier les lectures du capteur BME280 (Arduino IDE)

ESP32 MQTT - Publier les lectures du capteur BME280 (Arduino IDE)

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

ESP32 MQTT Publier les lectures du capteur BME280 Arduino IDE

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.

BME280 Publish Readings Node-Red MQTT Fonctionnement et aperçu du projet
  • L’ESP32 demande des relevés de température au capteur BME280.
  • Les relevés de température sont publiés dans le esp32/bme280/température sujet;
  • Les mesures d’humidité sont publiées dans le esp32/bme280/humiditésujet;
  • Les relevés de pression sont publiés dans le esp32/bme280/pression sujet;
  • Node-RED est abonné à ces sujets ;
  • Node-RED reçoit les lectures des capteurs et les affiche sur des jauges ;
  • 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’ESP32 à l’aide de l’IDE Arduino, alors assurez-vous que le module complémentaire ESP32 est installé.

Courtier MQTT

Installation du courtier Mosquitto MQTT Raspberry Pi

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’ESP32, 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 dossier Téléchargements
  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 TCP asynchrone.

  1. Cliquez ici pour télécharger la bibliothèque du client TCP asynchrone. Vous devriez avoir un dossier .zip dans votre dossier Téléchargements
  2. Décompressez le dossier .zip et vous devriez obtenir Maître AsyncTCP dossier
  3. Renommez votre dossier de Maître AsyncTCP à AsyncTCP
  4. Bouge le AsyncTCP 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 BME280

Pour obtenir des lectures du module de capteur BME280, nous utiliserons le Bibliothèque Adafruit_BME280. 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 bme280 ” dans la zone de recherche et installez la bibliothèque.

Installation de la bibliothèque BME280 dans l'IDE Arduino

Pour utiliser la bibliothèque BME280, 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.

Installation de la bibliothèque Adafruit Unified Sensor Driver

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

Pour en savoir plus sur le capteur BME280, lisez notre guide : ESP32 avec capteur BME280 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 !

1644322331 644 ESP32 MQTT Publier les lectures du capteur BME280 Arduino

Diagramme schématique

Câblez le BME280 à l’ESP32 comme indiqué dans le schéma suivant avec la broche SDA connectée à GPIO 21 et la broche SCL connectée à GPIO 22.

ESP32 BME280 Température humidité Capteur de pression connecté Schéma de circuit I2C

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/esp32-mqtt-publish-bme280-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 <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>
#include <WiFi.h>
extern "C" {
  #include "freertos/FreeRTOS.h"
  #include "freertos/timers.h"
}
#include <AsyncMqttClient.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 "esp32/bme280/temperature"
#define MQTT_PUB_HUM "esp32/bme280/humidity"
#define MQTT_PUB_PRES "esp32/bme280/pressure"

// BME280 I2C
Adafruit_BME280 bme;
// Variables to hold sensor readings
float temp;
float hum;
float pres;

AsyncMqttClient mqttClient;
TimerHandle_t mqttReconnectTimer;
TimerHandle_t wifiReconnectTimer;

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

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

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

void WiFiEvent(WiFiEvent_t event) {
  Serial.printf("[WiFi-event] event: %d\n", event);
  switch(event) {
    case SYSTEM_EVENT_STA_GOT_IP:
      Serial.println("WiFi connected");
      Serial.println("IP address: ");
      Serial.println(WiFi.localIP());
      connectToMqtt();
      break;
    case SYSTEM_EVENT_STA_DISCONNECTED:
      Serial.println("WiFi lost connection");
      xTimerStop(mqttReconnectTimer, 0); // ensure we don't reconnect to MQTT while reconnecting to Wi-Fi
      xTimerStart(wifiReconnectTimer, 0);
      break;
  }
}

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()) {
    xTimerStart(mqttReconnectTimer, 0);
  }
}

/*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();
  
  // Initialize BME280 sensor 
  if (!bme.begin(0x76)) {
    Serial.println("Could not find a valid BME280 sensor, check wiring!");
    while (1);
  }
  
  mqttReconnectTimer = xTimerCreate("mqttTimer", pdMS_TO_TICKS(2000), pdFALSE, (void*)0, reinterpret_cast<TimerCallbackFunction_t>(connectToMqtt));
  wifiReconnectTimer = xTimerCreate("wifiTimer", pdMS_TO_TICKS(2000), pdFALSE, (void*)0, reinterpret_cast<TimerCallbackFunction_t>(connectToWifi));

  WiFi.onEvent(WiFiEvent);

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

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;
    // New BME280 sensor readings
    temp = bme.readTemperature();
    //temp = 1.8*bme.readTemperature() + 32;
    hum = bme.readHumidity();
    pres = bme.readPressure()/100.0F;
    
    // Publish an MQTT message on topic esp32/BME2800/temperature
    uint16_t packetIdPub1 = mqttClient.publish(MQTT_PUB_TEMP, 1, true, String(temp).c_str());                            
    Serial.printf("Publishing on topic %s at QoS 1, packetId: %i", MQTT_PUB_TEMP, packetIdPub1);
    Serial.printf("Message: %.2f \n", temp);

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

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

Afficher le code brut

Comment fonctionne le code

La section suivante importe toutes les bibliothèques requises.

#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>
#include <WiFi.h>
extern "C" {
  #include "freertos/FreeRTOS.h"
  #include "freertos/timers.h"
}
#include <AsyncMqttClient.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’ESP32 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 "esp32/bme280/temperature"
#define MQTT_PUB_HUM  "esp32/bme280/humidity"
#define MQTT_PUB_PRES "esp32/bme280/pressure"

Initialiser un Adafruit_BME280 objet appelé bme.

Adafruit_BME280 bme;

le temp, Hum et prés les variables contiendront les valeurs de température, d’humidité et de pression du capteur BME280.

float temp;
float hum;
float pres;

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;
TimerHandle_t mqttReconnectTimer;
TimerHandle_t 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;  // Stores last time temperature was published
const long interval = 10000;       // Interval at which to publish sensor readings

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 ESP32 à votre routeur :

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

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

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

le WiFiEvent() fonction est responsable 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 ESP32. D’autre part, si la connexion est perdue, il démarre un minuteur et tente de se reconnecter.

void WiFiEvent(WiFiEvent_t event) {
  Serial.printf("[WiFi-event] event: %d\n", event);
  switch(event) {
    case SYSTEM_EVENT_STA_GOT_IP:
      Serial.println("WiFi connected");
      Serial.println("IP address: ");
      Serial.println(WiFi.localIP());
      connectToMqtt();
      break;
    case SYSTEM_EVENT_STA_DISCONNECTED:
      Serial.println("WiFi lost connection");
      xTimerStop(mqttReconnectTimer, 0);
      xTimerStart(wifiReconnectTimer, 0);
      break;
  }
}

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’ESP32 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()) { 
    xTimerStart(mqttReconnectTimer, 0);
  }
}

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

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

Les deux lignes suivantes créent des minuteries qui permettront à la fois au courtier MQTT et à la connexion Wi-Fi de se reconnecter, au cas où la connexion serait perdue.

mqttReconnectTimer = xTimerCreate("mqttTimer", pdMS_TO_TICKS(2000), pdFALSE, (void*)0, reinterpret_cast<TimerCallbackFunction_t>(connectToMqtt));
wifiReconnectTimer = xTimerCreate("wifiTimer", pdMS_TO_TICKS(2000), pdFALSE, (void*)0, reinterpret_cast<TimerCallbackFunction_t>(connectToWifi));

La ligne suivante attribue une fonction de rappel, donc lorsque l’ESP32 se connecte à votre Wi-Fi, il exécutera le WiFiEvent() fonction pour imprimer les détails décrits précédemment.

WiFi.onEvent(WiFiEvent);

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’ESP32 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");

Enfin, connectez-vous au Wi-Fi.

connectToWifi();

boucler()

Dans le boucler()vous créez une minuterie qui vous permettra d’obtenir de nouvelles lectures du capteur BME280 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;
  // New BME280 sensor readings
  temp = bme.readTemperature();
  //temp = 1.8*bme.readTemperature() + 32;
  hum = bme.readHumidity();
  pres = bme.readPressure()/100.0F;

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

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(temp).c_str());
uint16_t packetIdPub2 = mqttClient.publish(MQTT_PUB_HUM, 1, true, String(hum).c_str());
uint16_t packetIdPub3 = mqttClient.publish(MQTT_PUB_PRES, 1, true, String(pres).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 ESP32.

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

ESP32 Publier les lectures du capteur BME280 Moniteur série MQTT

Préparation du tableau de bord Node-RED

L’ESP32 publie des relevés de température toutes les 10 secondes sur le esp32/bme280/température, esp32/bme280/humiditéet esp32/bme280/pression les sujets. 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 trois nœuds MQTT dans les nœuds et trois nœuds de jauge vers le flux.

Node-RED Faites glisser 6 nœuds MQTT dans les nœuds et les jauges

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

MQTT In Node ESP32 Publier Température Node-RED Flow

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 esp32/bme280/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 : esp32/bme280/humidité et esp32/bme280/pression.

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 autres lectures.

Jauge de température ESP32 Node-RED Flow

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

ESP32 MQTT Publier Température Humidité Pression Nœud-RED Flow

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

Déployer le bouton Node-RED

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

[{"id":"5a45b8da.52b0d8","type":"mqtt in","z":"b01416d3.f69f38","name":"","topic":"esp32/bme280/temperature","qos":"1","datatype":"auto","broker":"8db3fac0.99dd48","x":340,"y":120,"wires":[["3042e15e.80a4ee"]]},{"id":"3042e15e.80a4ee","type":"ui_gauge","z":"b01416d3.f69f38","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":610,"y":120,"wires":[]},{"id":"8ff168f0.0c74a8","type":"mqtt in","z":"b01416d3.f69f38","name":"","topic":"esp32/bme280/humidity","qos":"1","datatype":"auto","broker":"8db3fac0.99dd48","x":320,"y":200,"wires":[["29251f29.6687c"]]},{"id":"29251f29.6687c","type":"ui_gauge","z":"b01416d3.f69f38","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":600,"y":200,"wires":[]},{"id":"681a1588.8506fc","type":"mqtt in","z":"b01416d3.f69f38","name":"","topic":"esp32/bme280/pressure","qos":"1","datatype":"auto","broker":"8db3fac0.99dd48","x":330,"y":280,"wires":[["41164c6.e7b3cb4"]]},{"id":"41164c6.e7b3cb4","type":"ui_gauge","z":"b01416d3.f69f38","name":"","group":"37de8fe8.46846","order":2,"width":0,"height":0,"gtype":"gage","title":"Pressure","label":"hPa","format":"{{value}}","min":"900","max":"1100","colors":["#a346ff","#bd45cb","#7d007d"],"seg1":"","seg2":"","x":600,"y":280,"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":"BME280","tab":"53b8c8f9.cfbe48","order":1,"disp":true,"width":"6","collapse":false},{"id":"53b8c8f9.cfbe48","type":"ui_tab","z":"","name":"Home","icon":"dashboard","order":2,"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 BME280 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.

ESP32 MQTT Publier Température Humidité Pression Node-RED Dashboard

C’est ça! Votre carte ESP32 publie les relevés de température, d’humidité et de pression BME280 sur Node-RED via MQTT.

Emballer

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 les relevés de température, d’humidité et de pression d’un capteur BME280 avec l’ESP32 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 BME280vous pouvez utiliser n’importe quel autre capteur comme un DS18B20 capteur de température (ESP32 MQTT – Publier les relevés de température DS18B20).

Nous espérons que vous avez trouvé ce tutoriel utile. Si vous voulez en savoir plus sur l’ESP32, jetez un œil à nos ressources :

Merci d’avoir lu.