MicroPython : MQTT publie DHT11/DHT22 avec ESP32/ESP8266

MicroPython : MQTT publie DHT11/DHT22 avec ESP32/ESP8266

Apprenez à programmer les cartes ESP32 ou ESP8266 avec MicroPython pour publier les lectures des capteurs DHT11 ou DHT22 (température et humidité) via MQTT sur n’importe quelle plate-forme prenant en charge MQTT ou tout client MQTT. À titre d’exemple, nous publierons les lectures des capteurs sur le tableau de bord Node-RED.

MicroPython MQTT publie les relevés de température et d'humidité du capteur DHT11 DHT22 avec ESP32 ESP8266

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

Noter: ce tutoriel est compatible avec les cartes de développement ESP32 et ESP8266.

Aperçu du projet

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

DHT ESP32 ESP8266 Présentation du projet MicroPython MQTT
  • L’ESP demande des lectures de température et d’humidité du capteur DHT11 ou DHT22 ;
  • Les relevés de température sont publiés dans le esp/dht/température sujet;
  • Les relevés d’humidité sont publiés dans le esp/dht/humidité 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 remplir les conditions préalables suivantes :

Pour suivre ce tutoriel, vous avez besoin du firmware MicroPython installé dans vos cartes ESP32 ou ESP8266. Vous avez également besoin d’un IDE pour écrire et télécharger le code sur votre carte. Nous vous suggérons d’utiliser Thonny IDE ou uPyCraft IDE :

Courtier MQTT

Courtier Mosquitto MQTT

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

Si vous n’êtes pas familier avec MQTT, assurez-vous de lire notre didacticiel d’introduction : Qu’est-ce que MQTT et comment cela fonctionne

Pièces requises

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

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

1641477615 991 MicroPython MQTT publie DHT11DHT22 avec ESP32ESP8266

Bibliothèque umqtttsimple

Pour utiliser MQTT avec l’ESP32/ESP8266 et MicroPython, nous utiliserons le umqttsimplebibliothèque .py. Suivez les instructions suivantes pour l’IDE que vous utilisez :

  • A. Télécharger la bibliothèque umqttsimple avec uPyCraft IDE
  • B. Télécharger la bibliothèque umqttsimple avec Thonny IDE
try:
    import usocket as socket
except:
    import socket
import ustruct as struct
from ubinascii import hexlify

class MQTTException(Exception):
    pass

class MQTTClient:

    def __init__(self, client_id, server, port=0, user=None, password=None, keepalive=0,
                 ssl=False, ssl_params={}):
        if port == 0:
            port = 8883 if ssl else 1883
        self.client_id = client_id
        self.sock = None
        self.server = server
        self.port = port
        self.ssl = ssl
        self.ssl_params = ssl_params
        self.pid = 0
        self.cb = None
        self.user = user
        self.pswd = password
        self.keepalive = keepalive
        self.lw_topic = None
        self.lw_msg = None
        self.lw_qos = 0
        self.lw_retain = False

    def _send_str(self, s):
        self.sock.write(struct.pack("!H", len(s)))
        self.sock.write(s)

    def _recv_len(self):
        n = 0
        sh = 0
        while 1:
            b = self.sock.read(1)[0]
            n |= (b & 0x7f) << sh
            if not b & 0x80:
                return n
            sh += 7

    def set_callback(self, f):
        self.cb = f

    def set_last_will(self, topic, msg, retain=False, qos=0):
        assert 0 <= qos <= 2
        assert topic
        self.lw_topic = topic
        self.lw_msg = msg
        self.lw_qos = qos
        self.lw_retain = retain

    def connect(self, clean_session=True):
        self.sock = socket.socket()
        addr = socket.getaddrinfo(self.server, self.port)[0][-1]
        self.sock.connect(addr)
        if self.ssl:
            import ussl
            self.sock = ussl.wrap_socket(self.sock, **self.ssl_params)
        premsg = bytearray(b"x10")
        msg = bytearray(b"x04MQTTx04x02")

        sz = 10 + 2 + len(self.client_id)
        msg[6] = clean_session << 1
        if self.user is not None:
            sz += 2 + len(self.user) + 2 + len(self.pswd)
            msg[6] |= 0xC0
        if self.keepalive:
            assert self.keepalive < 65536
            msg[7] |= self.keepalive >> 8
            msg[8] |= self.keepalive & 0x00FF
        if self.lw_topic:
            sz += 2 + len(self.lw_topic) + 2 + len(self.lw_msg)
            msg[6] |= 0x4 | (self.lw_qos & 0x1) << 3 | (self.lw_qos & 0x2) << 3
            msg[6] |= self.lw_retain << 5

        i = 1
        while sz > 0x7f:
            premsg[i] = (sz & 0x7f) | 0x80
            sz >>= 7
            i += 1
        premsg[i] = sz

        self.sock.write(premsg, i + 2)
        self.sock.write(msg)
        #print(hex(len(msg)), hexlify(msg, ":"))
        self._send_str(self.client_id)
        if self.lw_topic:
            self._send_str(self.lw_topic)
            self._send_str(self.lw_msg)
        if self.user is not None:
            self._send_str(self.user)
            self._send_str(self.pswd)
        resp = self.sock.read(4)
        assert resp[0] == 0x20 and resp[1] == 0x02
        if resp[3] != 0:
            raise MQTTException(resp[3])
        return resp[2] & 1

    def disconnect(self):
        self.sock.write(b"xe0")
        self.sock.close()

    def ping(self):
        self.sock.write(b"xc0")

    def publish(self, topic, msg, retain=False, qos=0):
        pkt = bytearray(b"x30")
        pkt[0] |= qos << 1 | retain
        sz = 2 + len(topic) + len(msg)
        if qos > 0:
            sz += 2
        assert sz < 2097152
        i = 1
        while sz > 0x7f:
            pkt[i] = (sz & 0x7f) | 0x80
            sz >>= 7
            i += 1
        pkt[i] = sz
        #print(hex(len(pkt)), hexlify(pkt, ":"))
        self.sock.write(pkt, i + 1)
        self._send_str(topic)
        if qos > 0:
            self.pid += 1
            pid = self.pid
            struct.pack_into("!H", pkt, 0, pid)
            self.sock.write(pkt, 2)
        self.sock.write(msg)
        if qos == 1:
            while 1:
                op = self.wait_msg()
                if op == 0x40:
                    sz = self.sock.read(1)
                    assert sz == b"x02"
                    rcv_pid = self.sock.read(2)
                    rcv_pid = rcv_pid[0] << 8 | rcv_pid[1]
                    if pid == rcv_pid:
                        return
        elif qos == 2:
            assert 0

    def subscribe(self, topic, qos=0):
        assert self.cb is not None, "Subscribe callback is not set"
        pkt = bytearray(b"x82")
        self.pid += 1
        struct.pack_into("!BH", pkt, 1, 2 + 2 + len(topic) + 1, self.pid)
        #print(hex(len(pkt)), hexlify(pkt, ":"))
        self.sock.write(pkt)
        self._send_str(topic)
        self.sock.write(qos.to_bytes(1, "little"))
        while 1:
            op = self.wait_msg()
            if op == 0x90:
                resp = self.sock.read(4)
                #print(resp)
                assert resp[1] == pkt[2] and resp[2] == pkt[3]
                if resp[3] == 0x80:
                    raise MQTTException(resp[3])
                return

    # Wait for a single incoming MQTT message and process it.
    # Subscribed messages are delivered to a callback previously
    # set by .set_callback() method. Other (internal) MQTT
    # messages processed internally.
    def wait_msg(self):
        res = self.sock.read(1)
        self.sock.setblocking(True)
        if res is None:
            return None
        if res == b"":
            raise OSError(-1)
        if res == b"xd0":  # PINGRESP
            sz = self.sock.read(1)[0]
            assert sz == 0
            return None
        op = res[0]
        if op & 0xf0 != 0x30:
            return op
        sz = self._recv_len()
        topic_len = self.sock.read(2)
        topic_len = (topic_len[0] << 8) | topic_len[1]
        topic = self.sock.read(topic_len)
        sz -= topic_len + 2
        if op & 6:
            pid = self.sock.read(2)
            pid = pid[0] << 8 | pid[1]
            sz -= 2
        msg = self.sock.read(sz)
        self.cb(topic, msg)
        if op & 6 == 2:
            pkt = bytearray(b"x40x02")
            struct.pack_into("!H", pkt, 2, pid)
            self.sock.write(pkt)
        elif op & 6 == 4:
            assert 0

    # Checks whether a pending message from server is available.
    # If not, returns immediately with None. Otherwise, does
    # the same processing as wait_msg.
    def check_msg(self):
        self.sock.setblocking(False)
        return self.wait_msg()

Afficher le code brut

A. Télécharger la bibliothèque umqttsimple avec uPyCraft IDE

1. Créez un nouveau fichier en appuyant sur le Nouveau fichier bouton.

1641477615 232 MicroPython MQTT publie DHT11DHT22 avec ESP32ESP8266

2. Copiez le umqttsimple le code de la bibliothèque dedans. Vous pouvez accéder au umqttsimple code de la bibliothèque dans le lien suivant :

3. Enregistrez le fichier en appuyant sur le Sauvegarder bouton.

1641477615 298 MicroPython MQTT publie DHT11DHT22 avec ESP32ESP8266

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

1641477615 754 MicroPython MQTT publie DHT11DHT22 avec ESP32ESP8266

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

1641477615 277 MicroPython MQTT publie DHT11DHT22 avec ESP32ESP8266

6. Le fichier doit être enregistré sur le appareil dossier avec le nom « umqttsimple.py» comme le montre la figure ci-dessous.

1641477615 41 MicroPython MQTT publie DHT11DHT22 avec ESP32ESP8266

Maintenant, vous pouvez utiliser les fonctionnalités de la bibliothèque dans votre code en important la bibliothèque.

B. Télécharger la bibliothèque umqttsimple avec Thonny IDE

1. Copiez le code de la bibliothèque dans un nouveau fichier. le Le code de la bibliothèque umqttsimple peut être trouvé ici.

2. Aller à Déposer > Enregistrer sous…

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

Si le menu « Enregistrer sous… » est manquant, vérifiez que vous avez correctement configuré Thonny IDE comme dans le tutoriel suivant :

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

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

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

bibliothèque umqttsimple nouveau fichier MicroPython Thonny IDE

Et c’est tout. La bibliothèque a été téléchargée sur votre tableau. Pour vous assurer qu’il a été téléchargé avec succès, accédez à Fichier > Enregistrer sous… et sélectionnez le périphérique MicroPython. Votre fichier doit y figurer :

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

Après avoir téléchargé la bibliothèque sur votre tableau, vous pouvez utiliser les fonctionnalités de la bibliothèque dans votre code en important la bibliothèque.

Schéma : ESP32 avec DHT11/DHT22

Câblez le capteur DHT22 ou DHT11 à la carte de développement ESP32 comme indiqué dans le schéma suivant.

Schéma de circuit MicroPython Schéma ESP32 avec DHT11 DHT22

Dans cet exemple, nous connectons la broche de données DHT à GPIO 14. Cependant, vous pouvez utiliser n’importe quelle autre broche numérique appropriée.

Apprenez à utiliser les GPIO ESP32 avec notre guide : Référence de brochage ESP32 : Quelles broches GPIO devriez-vous utiliser ?

Schéma : ESP8266 NodeMCU avec DHT11/DHT22

Si vous utilisez un ESP8266 NodeMCU, suivez plutôt le schéma suivant.

Schéma de circuit MicroPython Schéma ESP8266 NodeMCU avec DHT11 DHT22

Dans cet exemple, nous connectons la broche de données DHT à GPIO 14 (D5). Cependant, vous pouvez utiliser n’importe quelle autre broche numérique appropriée.

Apprenez à utiliser les GPIO ESP8266 avec notre guide : Référence de brochage ESP8266 : Quelles broches GPIO devriez-vous utiliser ?

Code

Après avoir téléchargé la bibliothèque sur l’ESP32 ou l’ESP8266, copiez le code suivant dans le main.py déposer. Il publie la température et l’humidité sur le esp/dht/température et esp/dht/humidité sujets toutes les 5 secondes.

# Complete project details at https://Raspberryme.com/micropython-mqtt-publish-dht11-dht22-esp32-esp8266/

import time
from umqttsimple import MQTTClient
import ubinascii
import machine
import micropython
import network
import esp
from machine import Pin
import dht
esp.osdebug(None)
import gc
gc.collect()

ssid = 'REPLACE_WITH_YOUR_SSID'
password = 'REPLACE_WITH_YOUR_PASSWORD'
mqtt_server="192.168.1.XXX"
#EXAMPLE IP ADDRESS or DOMAIN NAME
#mqtt_server="192.168.1.106"

client_id = ubinascii.hexlify(machine.unique_id())

topic_pub_temp = b'esp/dht/temperature'
topic_pub_hum = b'esp/dht/humidity'

last_message = 0
message_interval = 5

station = network.WLAN(network.STA_IF)

station.active(True)
station.connect(ssid, password)

while station.isconnected() == False:
  pass

print('Connection successful')

sensor = dht.DHT22(Pin(14))
#sensor = dht.DHT11(Pin(14))

def connect_mqtt():
  global client_id, mqtt_server
  client = MQTTClient(client_id, mqtt_server)
  #client = MQTTClient(client_id, mqtt_server, user=your_username, password=your_password)
  client.connect()
  print('Connected to %s MQTT broker' % (mqtt_server))
  return client

def restart_and_reconnect():
  print('Failed to connect to MQTT broker. Reconnecting...')
  time.sleep(10)
  machine.reset()

def read_sensor():
  try:
    sensor.measure()
    temp = sensor.temperature()
    # uncomment for Fahrenheit
    #temp = temp * (9/5) + 32.0
    hum = sensor.humidity()
    if (isinstance(temp, float) and isinstance(hum, float)) or (isinstance(temp, int) and isinstance(hum, int)):
      temp = (b'{0:3.1f},'.format(temp))
      hum =  (b'{0:3.1f},'.format(hum))
      return temp, hum
    else:
      return('Invalid sensor readings.')
  except OSError as e:
    return('Failed to read sensor.')

try:
  client = connect_mqtt()
except OSError as e:
  restart_and_reconnect()

while True:
  try:
    if (time.time() - last_message) > message_interval:
      temp, hum = read_sensor()
      print(temp)
      print(hum)
      client.publish(topic_pub_temp, temp)
      client.publish(topic_pub_hum, hum)
      last_message = time.time()
  except OSError as e:
    restart_and_reconnect()

Afficher le code brut

Comment fonctionne le code

Importez les bibliothèques suivantes :

import time
from umqttsimple import MQTTClient
import ubinascii
import machine
import micropython
import network
import esp
from machine import Pin
import dht
esp.osdebug(None)
import gc
gc.collect()

Dans les variables suivantes, vous devez entrer vos informations d’identification réseau et l’adresse IP de votre courtier.

ssid = 'REPLACE_WITH_YOUR_SSID'
password = 'REPLACE_WITH_YOUR_PASSWORD'
mqtt_server="REPLACE_WITH_YOUR_MQTT_BROKER_IP"

Par exemple, l’adresse IP de notre courtier est : 192.168.1.106.

mqtt_server="192.168.1.106"

Noter: lisez ce tutoriel pour voir comment obtenir l’adresse IP de votre courtier.

Pour créer un client MQTT, nous devons obtenir l’ID unique ESP. C’est ce que nous faisons dans la ligne suivante (elle est enregistrée sur le identité du client variable).

client_id = ubinascii.hexlify(machine.unique_id())

Ensuite, créez les sujets dans lesquels vous souhaitez que votre ESP publie. Dans notre exemple, il publiera la température sur le esp/dht/température sujet et humidité sur le esp/dht/humidité sujet.

topic_pub_temp = b'esp/dht/temperature'
topic_pub_hum = b'esp/dht/humidity'

Ensuite, créez les variables suivantes :

last_message = 0
message_interval = 5

le Dernier message La variable sera conservée la dernière fois qu’un message a été envoyé. le intervalle_message est le temps entre chaque message envoyé. Ici, nous le réglons sur 5 secondes (cela signifie qu’un nouveau message sera envoyé toutes les 5 secondes). Vous pouvez le changer si vous voulez.

Après cela, connectez l’ESP à votre réseau local.

station = network.WLAN(network.STA_IF)

station.active(True)
station.connect(ssid, password)

while station.isconnected() == False:
  pass

print('Connection successful')

Initialisez le capteur DHT en créant un dht exemple sur GPIO 4 comme suit:

sensor = dht.DHT22(Pin(4))

Si vous utilisez un capteur DHT11, décommentez la ligne suivante et commentez la précédente :

sensor = dht.DHT11(Pin(4))

Connectez-vous au courtier MQTT

le connect_mqtt() La fonction crée un client MQTT et se connecte à votre courtier.

def connect_mqtt():
  global client_id, mqtt_server
  client = MQTTClient(client_id, mqtt_server)
  #client = MQTTClient(client_id, mqtt_server, user=your_username, password=your_password)
  client.connect()
  print('Connected to %s MQTT broker' % (mqtt_server))
  return client

Si votre courtier MQTT requiert un nom d’utilisateur et un mot de passe, vous devez utiliser la ligne suivante pour transmettre le nom d’utilisateur et le mot de passe de votre courtier comme arguments.

client = MQTTClient(client_id, mqtt_server, user=your_username, password=your_password)

Redémarrer et se reconnecter

le restart_and_reconnect() La fonction réinitialise la carte ESP32/ESP8266. Cette fonction sera appelée si nous ne sommes pas en mesure de publier les lectures via MQTT au cas où le courtier se déconnecterait.

def restart_and_reconnect():
  print('Failed to connect to MQTT broker. Reconnecting...')
  time.sleep(10)
  machine.reset()

Lire le capteur DHT

Nous avons créé une fonction appelée read_sensor() qui renvoie la température et l’humidité actuelles du capteur DHT et gère toutes les exceptions, au cas où nous ne serions pas en mesure d’obtenir des lectures du capteur.

def read_sensor():
  try:
    sensor.measure()
    temp = sensor.temperature()
    hum = sensor.humidity()
    if (isinstance(temp, float) and isinstance(hum, float)) or (isinstance(temp, int) and isinstance(hum, int)):
      temp = (b'{0:3.1f},'.format(temp))
      hum =  (b'{0:3.1f},'.format(hum))

      # uncomment for Fahrenheit
      #temp = temp * (9/5) + 32.0
      return temp, hum
    else:
      return('Invalid sensor readings.')
  except OSError as e:
    return('Failed to read sensor.')

Publication de messages MQTT

Dans la boucle while, nous publions de nouvelles lectures de température et d’humidité toutes les 5 secondes.

Tout d’abord, nous vérifions s’il est temps d’obtenir de nouvelles lectures :

if (time.time() - last_message) > message_interval:

Si c’est le cas, demandez de nouvelles lectures au capteur DHT en appelant le read_sensor() une fonction. La température est enregistrée sur le température variable et l’humidité est enregistrée sur le Hum variable.

temp, hum = read_sensor()

Enfin, publiez les lectures en utilisant le publier() méthode sur le client objet. le publier() La méthode accepte comme arguments le sujet et le message, comme suit :

client.publish(topic_pub_temp, temp)
client.publish(topic_pub_hum, hum)

Enfin, mettez à jour l’heure à laquelle le dernier message a été envoyé :

last_message = time.time()

Si l’ESP32 ou l’ESP8266 se déconnecte du courtier et que nous ne sommes pas en mesure de publier les lectures, appelez le restart_and_reconnect() fonction pour réinitialiser la carte ESP et essayer de vous reconnecter au courtier.

except OSError as e:
  restart_and_reconnect()

Après avoir téléchargé le code, vous devriez obtenir de nouvelles lectures de capteur sur la coque toutes les 5 secondes.

Maintenant, passez à la section suivante pour préparer Node-RED à recevoir les lectures que l’ESP publie.

Préparation du tableau de bord Node-RED

L’ESP32 ou l’ESP8266 publie des relevés de température toutes les 5 secondes sur le esp/dht/température et esp/dht/humidité 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 sujets 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 :

Après avoir exécuté Node-RED sur votre Raspberry Pi, accédez à votre adresse IP Raspberry Pi suivie de :1880.

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

L’interface Node-RED devrait s’ouvrir. Faites glisser deux MQTT dans les nœuds et deux nœuds de jauge vers le flux.

ESP32 DHT11 DHT22 Arduino IDE

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

MQTT In Node ESP32 ESP8266 Publier Température Humidité 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 esp/dht/température sujet.

Cliquez sur l’autre MQTT dans le nœud et modifiez ses propriétés avec le même serveur, mais pour l’autre sujet : esp/dht/humidité.

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 lectures de température. Modifiez l’autre nœud du graphique pour les lectures d’humidité.

ESP32 Jauge Température Humidité Node-RED Flow

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

ESP32 ESP8266 MQTT Publier DHT Température Humidité Nœud ROUGE Flux

Enfin, déployez votre flux (appuyez sur le bouton en haut à droite).

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":"59f95d85.b6f0b4","type":"mqtt in","z":"b01416d3.f69f38","name":"","topic":"esp/dht/temperature","qos":"1","datatype":"auto","broker":"8db3fac0.99dd48","x":910,"y":340,"wires":[["2babfd19.559212"]]},{"id":"2babfd19.559212","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":1210,"y":340,"wires":[]},{"id":"b9aa2398.37ca3","type":"mqtt in","z":"b01416d3.f69f38","name":"","topic":"esp/dht/humidity","qos":"1","datatype":"auto","broker":"8db3fac0.99dd48","x":900,"y":420,"wires":[["d0f75e86.1c9ae"]]},{"id":"d0f75e86.1c9ae","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":1200,"y":420,"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 relevés de température et d’humidité DHT actuels 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 ESP8266 MQTT Publier Température Humidité DHT11 DHT22 Node-RED Tableau de bord

C’est ça! Vos cartes ESP32 ou ESP8266 publient des lectures de température et d’humidité DHT sur Node-RED via MQTT à l’aide de MicroPython.

Emballer

MQTT est un excellent protocole de communication pour échanger de petites quantités de données entre les appareils IoT. Dans ce didacticiel, vous avez appris à publier les lectures de température et d’humidité d’un capteur DHT avec l’ESP32 et l’ESP8266 à l’aide de MicroPython 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 DHT11 ou DHT22, vous pouvez utiliser n’importe quel autre capteur comme un capteur de température DS18B20 ou un capteur BME280.

Nous avons d’autres projets/tutoriels liés au capteur DHT qui pourraient également vous plaire :

Apprenez-en plus sur MicroPython avec notre livre électronique : Programmation MicroPython à l’aide d’ESP32/ESP8266.