Pada artikel ini, Arduino Indonesia akan membahas tentang cara memprogram papan ESP32 atau ESP8266 dengan MicroPython untuk menerbitkan pembacaan sensor DHT11 atau DHT22 (suhu dan kelembaban) 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 dan kelembaban dari sensor DHT11 atau DHT22.
2. Data suhu diterbitkan (published) ke topik esp/dht/temperature.
3. Data kelembaban diterbitkan ke topik esp/dht/humidity.
4. Node-RED berlangganan (subscribe) ke topik-topik tersebut.
5. Node-RED menerima data sensor dan menampilkannya pada dashboard.
6. 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.
Komponen yang Diperlukan
Untuk tutorial ini, Anda memerlukan komponen-komponen berikut:
- ESP32 atau ESP8266
- DHT11 atau DHT22
- Resistor 4.7k Ohm (untuk DHT22)
- Papan Raspberry Pi
- Kartu MicroSD – 16GB Class10
- Catu Daya Raspberry Pi (5V 2.5A)
- Kabel jumper
- Papan breadboard
Baca juga: MicroPython OLED SSD1306 ESP32/ESP8266 - Cara Scroll Text dan Menggambar Bentuk
Library umqttsimple
Untuk menggunakan MQTT dengan ESP32/ESP8266 dan MicroPython, kami akan menggunakan library 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 ini.
Sekarang, Anda dapat menggunakan fungsi-fungsi library 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….
Jika menu "Save as…" tidak muncul, pastikan Anda telah mengatur Thonny IDE dengan benar.
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 DHT11/DHT22
Hubungkan sensor DHT22 atau DHT11 ke papan pengembangan ESP32 seperti yang ditunjukkan pada diagram skematik berikut.
Dalam contoh ini, kami menghubungkan pin data DHT ke GPIO 14. Namun, Anda dapat menggunakan pin digital lain yang sesuai.
Skematik: ESP8266 NodeMCU dengan DHT11/DHT22
Jika Anda menggunakan ESP8266 NodeMCU, ikuti diagram berikut.
Dalam contoh ini, kami menghubungkan pin data DHT ke GPIO 14 (D5). Namun, Anda dapat menggunakan pin digital lain yang sesuai.
Kode Program
Setelah mengunggah library ke ESP32 atau ESP8266, salin kode berikut ke file main.py. Kode ini akan menerbitkan (publish) data suhu dan kelembaban ke topik esp/dht/temperature dan esp/dht/humidity setiap 5 detik.
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()
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 dht
esp.osdebug(None)
import gc
gc.collect()
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-topik di mana ESP Anda akan menerbitkan data. Dalam contoh kami, ESP akan menerbitkan:
- Suhu ke topik esp/dht/temperature
- Kelembaban ke topik esp/dht/humidity
topic_pub_temp = b'esp/dht/temperature'
topic_pub_hum = b'esp/dht/humidity'
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')
Inisialisasi sensor DHT dengan membuat instance dht pada GPIO 14 sebagai berikut:
sensor = dht.DHT22(Pin(4))
Jika Anda menggunakan sensor DHT11, hapus komentar pada baris berikut, dan komentari baris sebelumnya:
sensor = dht.DHT11(Pin(4))
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 DHT
Kami membuat fungsi bernama read_sensor() yang mengembalikan suhu dan kelembaban terkini dari sensor DHT, serta menangani pengecualian jika gagal membaca sensor.
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.')
Menerbitkan (Publish) Pesan MQTT
Di dalam perulangan while, kami menerbitkan pembacaan suhu dan kelembaban baru setiap 5 detik.
Pertama, kami memeriksa apakah sudah waktunya untuk mendapatkan pembacaan baru:
if (time.time() - last_message) > message_interval:
Jika ya, minta pembacaan baru dari sensor DHT dengan memanggil fungsi read_sensor(). Suhu disimpan dalam variabel temp dan kelembaban dalam variabel hum.
temp, hum = read_sensor()
Terakhir, terbitkan pembacaan tersebut dengan menggunakan metode publish() pada objek client. Metode publish() menerima argumen berupa topik dan pesan, seperti berikut:
client.publish(topic_pub_temp, temp)
client.publish(topic_pub_hum, hum)
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 dan kelembaban setiap 5 detik ke topik esp/dht/temperature dan esp/dht/humidity. Anda dapat menggunakan dashboard apa pun yang mendukung MQTT, atau perangkat lain yang mendukung MQTT, untuk berlangganan (subscribe) ke topik-topik tersebut dan menerima datanya.
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 dua node "mqtt in" dan dua node "gauge" 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/dht/temperature.
Klik pada node mqtt in lainnya dan edit propertinya dengan server yang sama, namun untuk topik lain: `esp/dht/humidity`.
Klik pada node gauge dan edit propertinya untuk setiap jenis pembacaan. Node berikut diatur untuk pembacaan suhu. Edit node gauge lainnya untuk pembacaan kelembaban.
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":"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}]
Demonstrasi
Buka alamat IP Raspberry Pi Anda diikuti dengan :1880/ui.
http://raspberry-pi-ip-address:1880/ui
Anda akan mendapatkan akses ke pembacaan suhu dan kelembaban DHT terkini di Dashboard. Anda dapat menggunakan node tipe dashboard lainnya untuk menampilkan data dengan cara yang berbeda.
Selesai! Kini papan ESP32 atau ESP8266 Anda telah menerbitkan pembacaan suhu dan kelembaban dari DHT ke Node-RED via MQTT menggunakan MicroPython.
Baca juga: Tutorial MicroPython ESP32 - WiFi Manager (Kompatibel ESP8266)
Siap Belajar & Bangun Proyek IoT?
KLIK GAMBAR DI BAWAH INI UNTUK BELI TRAINER KIT ESP32
 |
| Klik gambar untuk pembelian |
Dalam praktik, hasil dan kendala yang ditemui bisa berbeda tergantung perangkat, konfigurasi, versi library, dan sistem yang digunakan.
- Diskusi umum dan tanya jawab praktik: https://t.me/edukasielektronika
- Kendala spesifik dan kasus tertentu: http://bit.ly/Chatarduino
0 on: "Tutorial MicroPython MQTT - Cara Publish Data Sensor DHT11/DHT22 di ESP32 & ESP8266"