ESP32 MQTT – Publier les lectures de température DS18B20 (Arduino IDE)

ESP32 MQTT - Publier les lectures de température DS18B20 (Arduino IDE)

Découvrez comment publier les relevés de température DS18B20 via MQTT avec l’ESP32 sur n’importe quelle plate-forme prenant en charge MQTT ou tout autre 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 DS18B20 Lectures de température 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.

ESP32 MQTT Publier les lectures de température DS18B20 Comment ça marche et aperçu du projet
  • L’ESP32 demande des relevés de température au capteur DS18B20. Les lectures sont publiées dans le esp32/ds18b20/température sujet;
  • Node-RED est abonné au esp32/ds18b20/température sujet. Ainsi, il reçoit les lectures de température DS18B20 et affiche les lectures dans une jauge/tableau ;
  • 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 de température DS18B20

Pour interfacer avec le capteur de température DS18B20, vous devez installer le Bibliothèque One Wire de Paul Stoffregen et le Bibliothèque de température de Dallas. Suivez les étapes suivantes pour installer ces bibliothèques.

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. Tapez « un fil” dans le champ de recherche et installez la bibliothèque OneWire de Paul Stoffregen.

Installer la bibliothèque OneWire de Paul Stoffregen dans l'IDE Arduino

3. Ensuite, recherchez « Dallas” et installez la bibliothèque DallasTemperature de Miles Burton.

Installer la bibliothèque DallasTemperature de Miles Burton dans Arduino IDE

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

Pour en savoir plus sur le capteur de température DS18B20, lisez notre guide : Capteur de température ESP32 DS18B20 avec Arduino IDE (Single, Multiple, Web Server).

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 !

1644426730 413 ESP32 MQTT Publier les lectures de temperature DS18B20 Arduino

Diagramme schématique

Câblez le DS18B20 à l’ESP32 comme indiqué dans le schéma suivant avec la broche de données DS18B20 connectée à GPIO 4.

Schéma de principe du capteur de température ESP32 DS18B20 connecté GPIO 4

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-ds18b20-temperature-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 <WiFi.h>
extern "C" {
  #include "freertos/FreeRTOS.h"
  #include "freertos/timers.h"
}
#include <AsyncMqttClient.h>
#include <OneWire.h>
#include <DallasTemperature.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 Topic
#define MQTT_PUB_TEMP "esp32/ds18b20/temperature"

// GPIO where the DS18B20 is connected to
const int oneWireBus = 4;          
// Setup a oneWire instance to communicate with any OneWire devices
OneWire oneWire(oneWireBus);
// Pass our oneWire reference to Dallas Temperature sensor 
DallasTemperature sensors(&oneWire);
// Temperature value
float temp;

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.println("Publish acknowledged.");
  Serial.print("  packetId: ");
  Serial.println(packetId);
}

void setup() {
  // Start the DS18B20 sensor
  sensors.begin();
  
  Serial.begin(115200);
  Serial.println();
  Serial.println();

  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 temperature readings
    sensors.requestTemperatures(); 
    // Temperature in Celsius degrees
    temp = sensors.getTempCByIndex(0);
    // Temperature in Fahrenheit degrees
    //temp = sensors.getTempFByIndex(0);
    
    // Publish an MQTT message on topic esp32/ds18b20/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: ", MQTT_PUB_TEMP);
    Serial.println(packetIdPub1);
    Serial.printf("Message: %.2f /n", sensors.getTempCByIndex(0));
  }
}

Afficher le code brut

Comment fonctionne le code

La section suivante importe toutes les bibliothèques requises.

#include <WiFi.h>
extern "C" {
  #include "freertos/FreeRTOS.h"
  #include "freertos/timers.h"
}
#include <AsyncMqttClient.h>
#include <OneWire.h>
#include <DallasTemperature.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

Nous publierons la température sur le esp32/ds18b20/température sujet. Si vous voulez changer de sujet, changez-le sur la ligne suivante.

#define MQTT_PUB_TEMP "esp32/ds18b20/temperature"

Vous pouvez créer plus de sujets si vous le souhaitez.

Configurez votre DS18B20 sur les lignes suivantes. Dans notre cas, il est lié à GPIO 4. Vous pouvez le connecter à n’importe quel autre GPIO.

// GPIO where the DS18B20 is connected to
const int oneWireBus = 4;
// Setup a oneWire instance to communicate with any OneWire devices
OneWire oneWire(oneWireBus);
// Pass our oneWire reference to Dallas Temperature sensor
DallasTemperature sensors(&oneWire);

le temp La variable contiendra la valeur de température du capteur de température DS18B20.

float temp;

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, 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 DS18B20 et démarrez la communication série.

sensors.begin();
Serial.begin(115200);

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 de publier de nouveaux relevés de température dans esp32/d18b20/température sujet 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 temperature readings
  sensors.requestTemperatures(); 
  // Temperature in Celsius degrees
  temp = sensors.getTempCByIndex(0);

Si vous préférez la température en Fahrenheit, décommentez la ligne suivante :

//temp = sensors.getTempFByIndex(0);

En savoir plus sur le capteur de température DS18B20 : ESP32 avec guide du capteur de température DS18B20.

Publication dans des rubriques

Pour publier un message sur un sujet MQTT, utilisez la ligne suivante :

uint16_t packetIdPub1 = mqttClient.publish(MQTT_PUB_TEMP, 1, true, String(temp).c_str());

Si vous souhaitez publier plus de lectures sur différents sujets, vous pouvez dupliquer cette ligne précédente le boucler().

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

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.

ESP32 Arduino IDE Serial Monitor MQTT Publier la démonstration de débogage des lectures de capteurs

Préparation du tableau de bord Node-RED

L’ESP32 publie des relevés de température toutes les 10 secondes sur le esp32/ds18b20/température sujet. 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 à ce sujet et recevoir les lectures.

À titre d’exemple, nous allons créer un flux simple à l’aide de Node-RED pour vous abonner à ce sujet et afficher les lectures sur une jauge ou un graphique.

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 un nœud d’entrée MQTT, un nœud de graphique et un nœud de jauge vers le flux.

Node-RED Faites glisser les nœuds MQTT dans la jauge de graphique

Cliquez sur le nœud MQTT et modifiez ses propriétés comme suit :

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.

Définissez les propriétés suivantes pour le nœud de jauge.

Nœud de jauge ESP32 Nœud de température de publication-flux RED

Modifiez le nœud du graphique comme suit :

Nœud de graphique ESP32 Nœud de température de publication-flux RED

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

ESP32 MQTT Publier le flux de température Node-RED

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

1644426731 454 ESP32 MQTT Publier les lectures de temperature DS18B20 Arduino

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/ds18b20/temperature","qos":"1","datatype":"auto","broker":"8db3fac0.99dd48","x":380,"y":280,"wires":[["3042e15e.80a4ee","4c53cb0f.3e6084"]]},{"id":"3042e15e.80a4ee","type":"ui_gauge","z":"b01416d3.f69f38","name":"","group":"2b7ac01b.fc984","order":0,"width":0,"height":0,"gtype":"gage","title":"Temperature","label":"ºC","format":"{{value}}","min":0,"max":"40","colors":["#00b500","#e6e600","#ca3838"],"seg1":"","seg2":"","x":650,"y":240,"wires":[]},{"id":"4c53cb0f.3e6084","type":"ui_chart","z":"b01416d3.f69f38","name":"","group":"2b7ac01b.fc984","order":1,"width":0,"height":0,"label":"Temperature","chartType":"line","legend":"false","xformat":"HH:mm:ss","interpolate":"linear","nodata":"","dot":false,"ymin":"","ymax":"","removeOlder":1,"removeOlderPoints":"","removeOlderUnit":"3600","cutout":0,"useOneColor":false,"colors":["#1f77b4","#aec7e8","#ff7f0e","#2ca02c","#98df8a","#d62728","#ff9896","#9467bd","#c5b0d5"],"useOldStyle":false,"outputs":1,"x":650,"y":320,"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":"2b7ac01b.fc984","type":"ui_group","z":"","name":"DS18B20 Temperature Sensor","tab":"99ab8dc5.f435c","disp":true,"width":"6","collapse":false},{"id":"99ab8dc5.f435c","type":"ui_tab","z":"","name":"Home","icon":"dashboard","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 des capteurs sur le tableau de bord (jauge et graphique).

Tableau de bord du tableau de bord ESP32 MQTT Publier Température Node-RED

C’est ça! Votre carte ESP32 publie les lectures des capteurs 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 des lectures de température DS18B20 avec l’ESP32 sur un sujet MQTT. Ensuite, vous pouvez utiliser n’importe quel appareil ou plate-forme domotique pour vous abonner à ce sujet et recevoir les lectures.

Au lieu d’un Capteur de température DS18B20vous pouvez utiliser n’importe quel autre capteur et vous pouvez également publier sur plusieurs sujets en même temps.

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.