Apprenez à programmer les cartes ESP32 ou ESP8266 avec MicroPython pour publier les relevés de température DS18B20 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.
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.
- L’ESP demande des relevés de température au capteur de température DS18B20 ;
- Les relevés de température sont publiés dans le esp/ds18b20/température sujet;
- Node-RED est abonné à ce sujet ;
- Node-RED reçoit les lectures de température et les affiche sur une jauge/un graphique ;
- 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
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.
Vous pouvez utiliser n’importe quel autre courtier MQTT, y compris un courtier MQTT cloud. Nous vous montrerons comment faire cela dans le code plus tard.
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 !
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()
A. Télécharger la bibliothèque umqttsimple avec uPyCraft IDE
1. Créez un nouveau fichier en appuyant sur le Nouveau fichier bouton.
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.
4. Appelez ce nouveau fichier « umqttsimple.py » et appuyez sur d’accord.
5. Clique le Télécharger et exécuter bouton.
6. Le fichier doit être enregistré sur le appareil dossier avec le nom « umqttsimple.py» comme le montre la figure ci-dessous.
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…
3. Sélectionnez enregistrer dans « Périphérique MicroPython » :
4. Nommez votre fichier comme umqttsimple.py et appuyez sur le bouton OK :
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 :
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 DS18B20
Câbler le Capteur de température DS18B20 à la carte de développement ESP32 comme indiqué dans le schéma suivant.
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 DS18B20
Si vous utilisez un ESP8266 NodeMCU, suivez plutôt le schéma suivant.
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 les relevés de température sur le esp/ds18b20/température sujet toutes les 5 secondes.
# Complete project details at https://Raspberryme.com/micropython-mqtt-publish-ds18b10-esp32-esp8266/
import time
from umqttsimple import MQTTClient
import ubinascii
import machine
import micropython
import network
import esp
from machine import Pin
import onewire
import ds18x20
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
#mqtt_server="192.168.1.106"
client_id = ubinascii.hexlify(machine.unique_id())
topic_pub_temp = b'esp/ds18b20/temperature'
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')
ds_pin = machine.Pin(4)
ds_sensor = ds18x20.DS18X20(onewire.OneWire(ds_pin))
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:
roms = ds_sensor.scan()
ds_sensor.convert_temp()
time.sleep_ms(750)
for rom in roms:
temp = ds_sensor.read_temp(rom)
# uncomment for Fahrenheit
temp = temp * (9/5) + 32.0
if (isinstance(temp, float) or (isinstance(temp, int))):
temp = (b'{0:3.1f},'.format(temp))
return temp
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 = read_sensor()
print(temp)
client.publish(topic_pub_temp, temp)
last_message = time.time()
except OSError as e:
restart_and_reconnect()
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 onewire
import ds18x20Dans 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 le sujet dans lequel vous souhaitez que votre ESP publie. Dans notre exemple, il publiera la température sur le esp/ds18b20/température sujet.
topic_pub_temp = b'esp/ds18b20/temperature'Ensuite, créez les variables suivantes :
last_message = 0
message_interval = 5le 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')Créer une instance pour le capteur de température DS18B20 sur GPIO 4.
ds_pin = machine.Pin(4)
ds_sensor = ds18x20.DS18X20(onewire.OneWire(ds_pin))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 clientSi 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 DS18B20
Nous avons créé une fonction appelée read_sensor() qui renvoie la température actuelle du capteur DS18B20 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:
roms = ds_sensor.scan()
ds_sensor.convert_temp()
time.sleep_ms(750)
for rom in roms:
temp = ds_sensor.read_temp(rom)
# uncomment for Fahrenheit
temp = temp * (9/5) + 32.0
if (isinstance(temp, float) or (isinstance(temp, int))):
temp = (b'{0:3.1f},'.format(temp))
return temp
else:
return('Invalid sensor readings.')
except OSError as e:
return('Failed to read sensor.')En savoir plus sur l’obtention des lectures du capteur de température DS18B20 : MicroPython : capteur de température DS18B20 avec ESP32 et ESP8266
Publication de messages MQTT
Dans la boucle while, nous publions de nouvelles lectures de température toutes les 5 secondes.
Tout d’abord, vérifiez s’il est temps d’obtenir de nouvelles lectures :
if (time.time() - last_message) > message_interval:Si c’est le cas, demandez une nouvelle lecture de température à la sonde DS18B20 en appelant le read_sensor() une fonction. La température est enregistrée sur le température variable.
temp = read_sensor()Enfin, publiez la température 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)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 10 secondes sur le esp/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 à 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:1880L’interface Node-RED devrait s’ouvrir. Faites glisser un MQTT dans les nœuds, un nœud de jauge et un nœud de graphique 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/ds18b20/température sujet.
Cliquez sur le nœud de la jauge et modifiez ses propriétés.
Ensuite, modifiez le nœud du graphique :
Câblez vos nœuds comme indiqué ci-dessous :
Enfin, déployez votre flux (appuyez sur le bouton en haut à droite).
Alternativement, vous pouvez aller à Menu > Importer et copiez ce qui suit dans votre Presse-papiers pour créer votre flux Node-RED.
[{"id":"3eb4b485.bb948c","type":"mqtt in","z":"b01416d3.f69f38","name":"","topic":"esp/ds18b20/temperature","qos":"1","datatype":"auto","broker":"8db3fac0.99dd48","x":930,"y":120,"wires":[["706fecd4.6f91a4","47ed6377.491d6c"]]},{"id":"706fecd4.6f91a4","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":1190,"y":100,"wires":[]},{"id":"47ed6377.491d6c","type":"ui_chart","z":"b01416d3.f69f38","name":"","group":"2b7ac01b.fc984","order":4,"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":1190,"y":160,"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":"DS18B20","tab":"53b8c8f9.cfbe48","order":1,"disp":true,"width":"6","collapse":false},{"id":"2b7ac01b.fc984","type":"ui_group","z":"","name":"SENSORS","tab":"99ab8dc5.f435c","disp":true,"width":"6","collapse":false},{"id":"53b8c8f9.cfbe48","type":"ui_tab","z":"","name":"Home","icon":"dashboard","order":2,"disabled":false,"hidden":false},{"id":"99ab8dc5.f435c","type":"ui_tab","z":"","name":"HTTP","icon":"dashboard","order":1,"disabled":false,"hidden":false}]
Manifestation
Accédez à votre adresse IP Raspberry Pi suivie de :1880/ui.
http://raspberry-pi-ip-address:1880/uiVous devriez avoir accès aux lectures actuelles des capteurs sur le tableau de bord (jauge et graphique).
C’est ça! Vos cartes ESP32 ou ESP8266 publient les lectures de température DS18B20 sur Node-RED via MQTT à l’aide de MicroPython.
Conclusion
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 d’un capteur de température DS18B20 avec l’ESP32 et l’ESP8266 à l’aide de MicroPython dans un sujet 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 de température DS18B20, vous pouvez utiliser n’importe quel autre capteur comme le capteur DHT11 ou DHT22 ou le capteur BME280.
Apprenez-en plus sur MicroPython avec notre livre électronique : Programmation MicroPython à l’aide d’ESP32/ESP8266.