Pelajari cara memprogram papan ESP32 atau ESP8266 dengan MicroPython untuk menerbitkan pembacaan suhu dari sensor DS18B20 via MQTT ke platform apa pun yang mendukung MQTT atau ke klien MQTT mana pun. Sebagai contoh, kami akan menerbitkan data sensor ke Node-RED Dashboard.
Gambaran Proyek
Diagram berikut menunjukkan gambaran tingkat tinggi dari proyek yang akan kita bangun.
1. ESP membaca data suhu dari sensor DS18B20.
2. Data suhu diterbitkan (published) ke topik esp/ds18b20/temperature.
3. Node-RED berlangganan (subscribe) ke topik tersebut.
4. Node-RED menerima data suhu dan menampilkannya pada gauge atau chart.
5. Anda dapat menerima data di platform lain yang mendukung MQTT dan mengolahnya sesuai kebutuhan.
MQTT Broker
Untuk menggunakan MQTT, Anda memerlukan sebuah broker. Kami akan menggunakan broker Mosquitto yang diinstal pada Raspberry Pi.
Anda juga dapat menggunakan broker MQTT lain, termasuk broker MQTT cloud. Kami akan menunjukkan cara melakukannya dalam kode nanti.
Komponen yang Diperlukan
- ESP32 atau ESP8266
- Sensor Suhu DS18B20
- Resistor 4.7k Ohm
- Papan Raspberry Pi
- Kartu MicroSD – 16GB Class10
- Catu Daya Raspberry Pi (5V 2.5A)
- Kabel jumper
- Papan breadboard
Library umqttsimple
Untuk menggunakan MQTT dengan ESP32/ESP8266 dan MicroPython, kami akan menggunakan pustaka `umqttsimple.py`. Ikuti set instruksi berikut sesuai dengan IDE yang Anda gunakan:
- Unggah Library `umqttsimple` dengan uPyCraft IDE
- Unggah Library `umqttsimple` dengan 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\0\0\0\0\0")
msg = bytearray(b"\x04MQTT\x04\x02\0\0")
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\0")
self.sock.close()
def ping(self):
self.sock.write(b"\xc0\0")
def publish(self, topic, msg, retain=False, qos=0):
pkt = bytearray(b"\x30\0\0\0")
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\0\0\0")
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"\x40\x02\0\0")
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()
Unggah Library umqttsimple dengan uPyCraft IDE
1. Buat file baru dengan menekan tombol New File.
2. Salin kode library `umqttsimple` ke dalamnya.
3. Simpan file dengan menekan tombol Save.
4. Beri nama file baru ini `umqttsimple.py` dan tekan OK.
5. Klik tombol Download and Run.
6. File tersebut akan tersimpan di folder perangkat dengan nama `umqttsimple.py`, seperti yang ditunjukkan pada gambar di bawah.
Sekarang, Anda dapat menggunakan fungsi-fungsi pustaka dalam kode Anda dengan mengimpornya.
Unggah Library umqttsimple dengan Thonny IDE
1. Salin kode library ke dalam file baru.
2. Buka menu File > Save as….
3. Pilih opsi simpan ke "MicroPython device" (Simpan ke perangkat MicroPython).
4. Beri nama file Anda `umqttsimple.py` dan tekan tombol OK.
Selesai. Library telah berhasil diunggah ke papan Anda. Untuk memastikan pengunggahan berhasil, buka File > Save as… dan pilih MicroPython device. File Anda akan terdaftar di sana.
Setelah library berhasil diunggah ke papan ESP, Anda dapat menggunakan fungsinya dalam kode dengan mengimpornya.
Skematik: ESP32 dengan DS18B20
Hubungkan sensor suhu DS18B20 ke papan pengembangan ESP32 seperti yang ditunjukkan pada diagram skematik berikut.
Skematik: ESP8266 NodeMCU dengan DS18B20
Jika Anda menggunakan ESP8266 NodeMCU, ikuti diagram berikut.
Kode
Setelah mengunggah pustaka ke ESP32 atau ESP8266, salin kode berikut ke file `main.py`. Kode ini akan menerbitkan (publish) pembacaan suhu ke topik esp/ds18b20/temperature setiap 5 detik.
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()
Cara Kerja Kode
Impor library-library berikut:
import time
from umqttsimple import MQTTClient
import ubinascii
import machine
import micropython
import network
import esp
from machine import Pin
import onewire
import ds18x20
Pada variabel berikut, Anda perlu memasukkan kredensial jaringan dan alamat IP broker MQTT Anda.
ssid = 'REPLACE_WITH_YOUR_SSID'
password = 'REPLACE_WITH_YOUR_PASSWORD'
mqtt_server = 'REPLACE_WITH_YOUR_MQTT_BROKER_IP'
Sebagai contoh, alamat IP broker kami adalah: 192.168.1.106.
mqtt_server = '192.168.1.106'
Untuk membuat klien MQTT, kita perlu mendapatkan ID unik ESP. Itulah yang kita lakukan pada baris berikut (ID disimpan dalam variabel `client_id`).
client_id = ubinascii.hexlify(machine.unique_id())
Selanjutnya, buat topik di mana ESP Anda akan menerbitkan data. Dalam contoh kami, ESP akan menerbitkan suhu ke topik esp/ds18b20/temperature.
topic_pub_temp = b'esp/ds18b20/temperature'
Kemudian, buat variabel-variabel berikut:
last_message = 0
message_interval = 5
Variabel `last_message` akan menyimpan waktu terakhir sebuah pesan dikirim. `message_interval` adalah interval waktu antara setiap pesan yang dikirim. Di sini, kami mengaturnya menjadi 5 detik (artinya pesan baru akan dikirim setiap 5 detik). Anda dapat mengubahnya sesuai keinginan.
Setelah itu, hubungkan ESP ke jaringan lokal Anda.
station = network.WLAN(network.STA_IF)
station.active(True)
station.connect(ssid, password)
while station.isconnected() == False:
pass
print('Connection successful')
Buat sebuah instance untuk sensor suhu DS18B20 pada GPIO 4.
ds_pin = machine.Pin(4)
ds_sensor = ds18x20.DS18X20(onewire.OneWire(ds_pin))
Menghubungkan ke Broker MQTT
Fungsi `connect_mqtt()` membuat Klien MQTT dan menghubungkannya ke broker Anda.
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
Jika broker MQTT Anda memerlukan username dan password, Anda harus menggunakan baris berikut dan memberikan username serta password broker sebagai argumen.
client = MQTTClient(client_id, mqtt_server, user=your_username, password=your_password)
Restart dan Sambung Ulang
Fungsi `restart_and_reconnect()` me-reset papan ESP32/ESP8266. Fungsi ini akan dipanggil jika kita tidak dapat menerbitkan pembacaan via MQTT (misalnya karena broker terputus).
def restart_and_reconnect():
print('Failed to connect to MQTT broker. Reconnecting...')
time.sleep(10)
machine.reset()
Membaca Sensor DS18B20
Kami membuat fungsi bernama `read_sensor()` yang mengembalikan suhu terkini dari sensor DS18B20, serta menangani pengecualian jika gagal membaca sensor.
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.')
Menerbitkan Pesan MQTT
Di dalam perulangan `while`, kami menerbitkan pembacaan suhu baru setiap 5 detik.
Pertama, periksa apakah sudah waktunya untuk mendapatkan pembacaan baru:
if (time.time() - last_message) > message_interval:
Jika ya, minta pembacaan suhu baru dari sensor DS18B20 dengan memanggil fungsi `read_sensor()`. Suhu disimpan dalam variabel `temp`.
temp = read_sensor()
Terakhir, terbitkan suhu tersebut dengan menggunakan metode `publish()` pada objek `client`. Metode `publish()` menerima argumen berupa topik dan pesan, seperti berikut:
client.publish(topic_pub_temp, temp)
Terakhir, perbarui waktu ketika pesan terakhir dikirim:
last_message = time.time()
Jika ESP32 atau ESP8266 terputus dari broker dan tidak dapat menerbitkan pembacaan, panggil fungsi `restart_and_reconnect()` untuk me-reset papan ESP dan mencoba menyambung kembali ke broker.
except OSError as e:
restart_and_reconnect()
Setelah mengunggah kode, Anda akan mendapatkan pembacaan sensor baru di shell setiap 5 detik.
Sekarang, lanjutkan ke bagian berikutnya untuk menyiapkan Node-RED guna menerima data yang diterbitkan oleh ESP.
Mempersiapkan Dashboard Node-RED
ESP32 atau ESP8266 kini menerbitkan data suhu setiap 5 detik ke topik `esp/ds18b20/temperature`. Anda dapat menggunakan dashboard apa pun yang mendukung MQTT, atau perangkat lain yang mendukung MQTT, untuk berlangganan (subscribe) ke topik tersebut dan menerima datanya.
Sebagai contoh, kami akan membuat alur (flow) sederhana menggunakan Node-RED untuk berlangganan ke topik tersebut dan menampilkan datanya pada gauge. Dengan Node-RED berjalan di Raspberry Pi Anda, buka alamat IP Raspberry Pi diikuti dengan `:1880`.
http://alamat-ip-raspberry-pi:1880
Antarmuka Node-RED akan terbuka. Seret satu node "mqtt in", satu node "gauge", dan satu node "chart" ke dalam alur (flow).
Klik node MQTT dan edit propertinya.
Kolom Server merujuk ke broker MQTT. Dalam kasus kami, broker MQTT adalah Raspberry Pi itu sendiri, sehingga diatur ke `localhost:1883`. Jika Anda menggunakan broker MQTT cloud, Anda harus mengubah kolom tersebut.
Masukkan topik yang ingin Anda langgani dan QoS-nya. Node MQTT ini berlangganan ke topik `esp/ds18b20/temperature`.
Klik pada node gauge dan edit propertinya.
Kemudian, edit node chart.
Hubungkan node-node Anda seperti yang ditunjukkan di bawah:
Terakhir, deploy alur Anda (tekan tombol di sudut kanan atas).
Sebagai alternatif, Anda dapat membuka Menu > Import dan menyalin kode berikut ke Clipboard untuk membuat alur Node-RED Anda.
[{"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}]
Demonstrasi
Buka alamat IP Raspberry Pi Anda diikuti dengan `:1880/ui`.
http://raspberry-pi-ip-address:1880/ui
Anda akan mendapatkan akses ke pembacaan sensor terkini di Dashboard (ditampilkan pada gauge dan chart).
Selesai! Kini papan ESP32 atau ESP8266 Anda telah menerbitkan pembacaan suhu dari DS18B20 ke Node-RED via MQTT menggunakan MicroPython.
Siap Untuk Membuat Proyek Impianmu Menjadi Kenyataan?
Klik di sini untuk chat langsung via WhatsApp dan dapatkan dukungan langsung dari tim ahli kami!
0 on: "Tutorial MicroPython ESP32/ESP8266 - Publish Suhu DS18B20 Real-Time via MQTT"