Panduan ini memberikan pembahasan lengkap tentang penggunaan protokol MQTT pada Raspberry Pi Pico yang diprogram menggunakan MicroPython. MQTT merupakan protokol komunikasi ringan yang banyak digunakan pada sistem Home Automation dan aplikasi IoT untuk menghubungkan berbagai perangkat secara efisien. Dalam tutorial ini, Anda akan mempelajari cara memilih dan mengonfigurasi broker MQTT, serta cara melakukan operasi publish dan subscribe pesan MQTT menggunakan Raspberry Pi Pico.
Pengenalan MQTT
MQTT (Message Queuing Telemetry Transport) adalah protokol komunikasi berbasis messaging yang dirancang untuk perangkat berspesifikasi terbatas dan jaringan dengan bandwidth rendah. Protokol ini sangat ideal untuk kebutuhan pertukaran data antar perangkat IoT secara efisien dan real-time. Mekanisme kerja MQTT menggunakan model publish–subscribe: setiap perangkat dapat melakukan publish pesan pada topik tertentu, dan semua perangkat yang melakukan subscribe pada topik tersebut akan menerima pesan yang dipublikasikan.
Aplikasi utama MQTT mencakup pengiriman perintah untuk mengendalikan output, membaca serta mempublikasikan data dari node sensor, dan berbagai skenario komunikasi IoT lainnya.
Baca juga: Panduan Lengkap Mengirim Email via SMTP pada Raspberry Pi Pico W (MicroPython)
Konsep Dasar MQTT
Dalam protokol MQTT, terdapat beberapa konsep fundamental yang perlu dipahami, yaitu:
- Publish/Subscribe
- Messages
- Topics
- Broker
Publish/Subscribe
Konsep pertama adalah mekanisme publish–subscribe. Pada sistem ini, sebuah perangkat dapat melakukan publish pesan pada topik tertentu, atau melakukan subscribe ke topik tertentu untuk menerima pesan yang dikirimkan oleh perangkat lain melalui topik tersebut.
Sebagai contoh sederhana:
- Perangkat 1 melakukan publish pada suatu topik;
- Perangkat 2 melakukan subscribe pada topik yang sama;
- Maka, Perangkat 2 akan menerima pesan yang dipublikasikan oleh Perangkat 1.
MQTT Messages
Messages adalah data yang dipertukarkan antar perangkat. Isi pesan dapat berupa instruksi untuk mengendalikan output, ataupun data terukur seperti hasil pembacaan sensor dan informasi lainnya.
Topics
Konsep penting berikutnya adalah topics. Topic digunakan untuk menentukan alur pesan—baik untuk menunjukkan minat terhadap pesan yang masuk maupun untuk menentukan lokasi publikasi pesan.
Struktur topic direpresentasikan sebagai rangkaian string yang dipisahkan oleh garis miring (`/`). Setiap garis miring menunjukkan satu level hierarki topik. Misalnya, untuk membuat topik pengendalian lampu pada ruang kerja rumah, Anda dapat menggunakan struktur topik seperti berikut:
Catatan: penamaan topik bersifat case-sensitive, sehingga perbedaan huruf besar dan huruf kecil akan membuat setiap topik dianggap sebagai entitas yang berbeda.
Jika Anda ingin menyalakan lampu di ruang kerja menggunakan MQTT, Anda dapat membayangkan skenario operasional seperti berikut:
- Sebuah perangkat melakukan publish pesan on atau off pada topik `home/office/lamp`.
- Perangkat lain yang berfungsi sebagai pengendali lampu—misalnya Raspberry Pi Pico atau papan mikrokontroler lain—melakukan subscribe pada topik yang sama: `home/office/lamp`.
- Ketika pesan baru dipublikasikan pada topik tersebut, Pico akan menerima instruksi on atau off dan kemudian menjalankan aksi yang sesuai untuk menyalakan atau mematikan lampu.
Perangkat yang melakukan publish dapat berupa mikrokontroler lain atau platform Home Automation yang mendukung MQTT, seperti Node-RED, Home Assistant, Adafruit IO, Domoticz, maupun OpenHAB.
Broker
Broker MQTT bertugas menerima seluruh pesan yang masuk, memfilter pesan berdasarkan topik, menentukan klien mana yang memiliki minat terhadap pesan tersebut, lalu mendistribusikan pesan itu kepada semua klien yang melakukan subscribe pada topik terkait.
Terdapat beberapa opsi broker MQTT yang dapat digunakan, antara lain:
- Cloud MQTT Broker – Anda dapat memanfaatkan layanan broker komersial seperti HiveMQ. Solusi ini tidak memerlukan instalasi atau konfigurasi lokal; cukup membuat akun dan layanan langsung dapat digunakan (solusi ini yang akan digunakan dalam tutorial ini).
- Local MQTT Broker – Anda dapat menginstal broker MQTT secara lokal pada komputer atau Raspberry Pi. Mosquitto MQTT broker yang dijalankan di Raspberry Pi merupakan pilihan populer dalam berbagai proyek IoT skala hobi dan juga menjadi solusi yang paling sering kami gunakan.
- Cloud-Hosted MQTT Broker Mandiri – Alternatif lainnya adalah menginstal broker MQTT pada server cloud milik Anda sendiri, sehingga Anda memiliki kontrol penuh terhadap konfigurasi dan pengelolaan layanan.
Ringkasan:
- MQTT adalah protokol komunikasi yang sangat efektif untuk proyek Internet of Things.
- Dalam MQTT, perangkat dapat melakukan publish pesan pada topik tertentu, dan perangkat lain dapat melakukan subscribe untuk menerima pesan pada topik tersebut.
- Penggunaan MQTT selalu memerlukan keberadaan sebuah broker yang berperan menerima seluruh pesan, memprosesnya, lalu mendistribusikannya kepada perangkat yang berlangganan.
Menyiapkan MQTT Broker
Untuk menggunakan protokol MQTT, Anda memerlukan sebuah broker. Broker bertugas menerima seluruh pesan MQTT yang dipublikasikan dan mendistribusikannya kepada klien yang berlangganan.
Opsi MQTT Broker
Terdapat berbagai solusi broker MQTT yang dapat dipilih. Berikut beberapa opsi yang umum digunakan:
- Mosquitto MQTT Broker pada Raspberry Pi
Merupakan broker open-source yang dapat diinstal secara lokal pada perangkat Raspberry Pi (komputer Raspberry Pi, bukan Pico). Opsi ini sangat populer untuk proyek IoT skala hobi dan telah terbukti stabil pada berbagai implementasi.
- Mosquitto MQTT Broker pada Server Cloud
Pilihan ini memungkinkan broker Anda dapat diakses dari mana saja, ideal bila Anda memerlukan konektivitas jarak jauh yang tidak terbatas pada jaringan lokal.
- HiveMQ Broker
Layanan cloud untuk MQTT yang siap digunakan tanpa instalasi. Anda hanya perlu membuat akun dan memilih paket layanan. Mereka juga menyediakan paket gratis yang cukup untuk sebagian besar proyek IoT berbasis hobi.
Untuk mempermudah proses, panduan ini menggunakan HiveMQ karena Anda tidak perlu melakukan instalasi maupun konfigurasi manual seperti pada Mosquitto. Cukup membuat akun, membuat cluster, dan broker langsung siap digunakan. Namun, jika Anda ingin menggunakan Mosquitto atau broker lain, tidak menjadi masalah kode yang digunakan tetap kompatibel selama Anda memasukkan detail broker dengan benar.
Apa pun broker MQTT yang dipilih, pastikan Anda telah memiliki informasi berupa URL MQTT, username, dan password sebelum melanjutkan ke bagian berikutnya.
Konfigurasi HiveMQ MQTT Broker
Pada bagian ini, Anda akan mempelajari langkah-langkah untuk menyiapkan broker MQTT menggunakan HiveMQ.
1. Buat akun terlebih dahulu. Kunjungi situs hivemq.com lalu klik opsi Start Free.
2. Setelah itu, pilih paket layanan HiveMQ Cloud.
3. Masuk (login) ke akun Anda atau buat akun baru, kemudian lengkapi informasi profil yang diminta.
4. Setelah berhasil masuk, sebuah cluster baru biasanya akan dibuat secara otomatis. Klik Manage Cluster untuk mulai melakukan konfigurasi.
5.Salin Cluster URL dan simpan di tempat yang aman karena informasi ini akan digunakan pada tahap berikutnya.
6. Buka tab Access Management pada bagian atas antarmuka.
7. Isi formulir dengan username dan password. Pastikan kredensial ini dicatat, karena diperlukan untuk menghubungkan perangkat ke MQTT broker. Atur izin akses menjadi Publish dan Subscribe.
8. Terakhir, klik Create Credential untuk menyimpan konfigurasi.
Jika kredensial berhasil dibuat, maka MQTT broker Anda telah selesai dikonfigurasi dan siap digunakan.
Sebelum melanjutkan ke bagian berikutnya, pastikan Anda telah menyiapkan informasi berikut:
- MQTT Server:
- Cluster URL (jika menggunakan HiveMQ)
- Alamat IP atau URL broker MQTT (jika menggunakan layanan lain)
- MQTT Username
- MQTT Password
Menginstal Modul MQTT untuk MicroPython
Untuk menulis program MicroPython yang mendukung komunikasi MQTT, kita akan menggunakan dua modul, yaitu umqtt.simple.py dan umqtt.robust.py. Ikuti langkah-langkah berikut untuk mengunggah modul tersebut ke Raspberry Pi Pico. Dengan Raspberry Pi Pico terhubung ke komputer dan tersambung ke Thonny IDE, buka menu View > Files.
Sebuah panel samping baru akan muncul dan menampilkan seluruh berkas yang berada pada sistem file Raspberry Pi Pico.
Klik kanan pada bagian Raspberry Pi Pico di panel tersebut, kemudian pilih New directory…
Buat direktori baru dengan nama umqtt, lalu klik OK.
Direktori baru tersebut akan muncul pada panel samping kiri.
Klik kanan pada folder umqtt, lalu pilih New file…
Buat berkas baru dengan nama simple.py.”
Salin kode simple.py ke dalam berkas baru tersebut. Kode untuk modul ini dapat Anda ambil dari pustaka resmi umqtt atau repositori MicroPython yang relevan.
# forked from: https://github.com/micropython/micropython-lib/tree/master/micropython/umqtt.simple
import usocket as 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 ssl
self.sock = ssl.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
return op
# 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()
Setelah menyalin kode ke dalam berkas simple.py, simpan perubahan tersebut.
Jika Anda membuka dan mengembangkan folder umqtt, Anda akan melihat bahwa berkas simple.py telah tersimpan di dalamnya.
Klik kanan kembali pada folder umqtt, lalu buat berkas baru dengan memilih New file…
Beri nama berkas tersebut robust.py.”
Salin kode robust.py ke dalam berkas baru tersebut. Kode modul ini dapat diperoleh dari pustaka umqtt atau repositori resmi MicroPython yang menyediakan implementasi modul MQTT.
# forked from: https://github.com/micropython/micropython-lib/tree/master/micropython/umqtt.robust
import utime
from . import simple
class MQTTClient(simple.MQTTClient):
DELAY = 2
DEBUG = False
def delay(self, i):
utime.sleep(self.DELAY)
def log(self, in_reconnect, e):
if self.DEBUG:
if in_reconnect:
print("mqtt reconnect: %r" % e)
else:
print("mqtt: %r" % e)
def reconnect(self):
i = 0
while 1:
try:
return super().connect(False)
except OSError as e:
self.log(True, e)
i += 1
self.delay(i)
def publish(self, topic, msg, retain=False, qos=0):
while 1:
try:
return super().publish(topic, msg, retain, qos)
except OSError as e:
self.log(False, e)
self.reconnect()
def wait_msg(self):
while 1:
try:
return super().wait_msg()
except OSError as e:
self.log(False, e)
self.reconnect()
def check_msg(self, attempts=2):
while attempts:
self.sock.setblocking(False)
try:
return super().wait_msg()
except OSError as e:
self.log(False, e)
self.reconnect()
attempts -= 1
Setelah menyalin kode ke dalam berkas robust.py, simpan perubahan tersebut. Pada tahap ini, folder umqtt seharusnya sudah berisi berkas simple.py dan robust.py.
Modul-modul yang diperlukan untuk komunikasi MQTT telah berhasil diunggah ke Raspberry Pi Pico.
Membuat Berkas Konfigurasi
Selanjutnya, kita akan membuat berkas konfigurasi untuk menyimpan informasi SSID, password Wi-Fi, serta detail broker MQTT seperti URL, username, dan password.
Buat berkas baru bernama config.py di Thonny IDE, kemudian salin kode berikut ke dalamnya:
wifi_ssid = 'REPLACE_WITH_YOUR_SSID'
wifi_password = 'REPLACE_WITH_YOUR_PASSWORD'
mqtt_server = b'MQTT_BROKER_URL'
mqtt_username = b'BROKER_USERNAME'
mqtt_password = b'BROKER_PASSWORD'
Sesuaikan nilai variabel dengan detail konfigurasi milik Anda.
Jika Anda menggunakan broker Mosquitto lokal, cukup masukkan alamat IP broker tanpa menambahkan nomor port. Contohnya:
mqtt_server = b'192.168.1.79'
Setelah itu, buka File > Save As…, pilih Raspberry Pi Pico, lalu simpan berkas tersebut dengan nama config.py (timpa jika sudah ada berkas dengan nama yang sama). Pastikan berkas ini disimpan pada direktori utama Raspberry Pi Pico, not di dalam folder umqtt.
Mempublikasikan Pesan MQTT
Pada contoh berikut, Anda akan mempelajari cara melakukan publish pesan MQTT pada sebuah topik menggunakan Raspberry Pi Pico. Sebagai ilustrasi, kita akan mengirim data suhu, kelembapan, dan tekanan dari sensor BME280. Anda juga dapat menggunakan sensor lain atau nilai acak untuk keperluan pengujian konsep. Sebelum melanjutkan, pastikan bahwa:
- Anda telah menghubungkan sensor BME280 ke Raspberry Pi Pico menggunakan GPIO 4 (SDA) dan GPIO 5 (SCL).
- Anda telah mengunggah modul BME280.py agar Pico dapat berkomunikasi dengan sensor. Ikuti panduan pemasangan pustaka BME280 sesuai tutorial yang direkomendasikan.
Kode berikut mengambil data dari sensor BME280 dan mempublikasikan hasil pembacaannya ke beberapa topik MQTT yang berbeda.
# Rui Santos & Sara Santos - Random Nerd Tutorials
# Complete project details at https://RandomNerdTutorials.com/raspberry-pi-pico-w-mqtt-micropython/
from machine import Pin, I2C
from time import sleep
import network
from umqtt.simple import MQTTClient
import config
import BME280
# Constants for MQTT Topics
MQTT_TOPIC_TEMPERATURE = 'pico/temperature'
MQTT_TOPIC_PRESSURE = 'pico/pressure'
MQTT_TOPIC_HUMIDITY = 'pico/humidity'
# MQTT Parameters
MQTT_SERVER = config.mqtt_server
MQTT_PORT = 0
MQTT_USER = config.mqtt_username
MQTT_PASSWORD = config.mqtt_password
MQTT_CLIENT_ID = b"raspberrypi_picow"
MQTT_KEEPALIVE = 7200
MQTT_SSL = True # set to False if using local Mosquitto MQTT broker
MQTT_SSL_PARAMS = {'server_hostname': MQTT_SERVER}
# Initialize I2C communication
i2c = I2C(id=0, scl=Pin(5), sda=Pin(4), freq=10000)
# Initialize BME280 sensor
bme = BME280.BME280(i2c=i2c, addr=0x76)
def get_sensor_readings():
temp = bme.temperature[:-1]
hum = bme.humidity[:-1]
pres = bme.pressure[:-3]
return temp, hum, pres
def initialize_wifi(ssid, password):
wlan = network.WLAN(network.STA_IF)
wlan.active(True)
# Connect to the network
wlan.connect(ssid, password)
# Wait for Wi-Fi connection
connection_timeout = 10
while connection_timeout > 0:
if wlan.status() >= 3:
break
connection_timeout -= 1
print('Waiting for Wi-Fi connection...')
sleep(1)
# Check if connection is successful
if wlan.status() != 3:
return False
else:
print('Connection successful!')
network_info = wlan.ifconfig()
print('IP address:', network_info[0])
return True
def connect_mqtt():
try:
client = MQTTClient(client_id=MQTT_CLIENT_ID,
server=MQTT_SERVER,
port=MQTT_PORT,
user=MQTT_USER,
password=MQTT_PASSWORD,
keepalive=MQTT_KEEPALIVE,
ssl=MQTT_SSL,
ssl_params=MQTT_SSL_PARAMS)
client.connect()
return client
except Exception as e:
print('Error connecting to MQTT:', e)
raise # Re-raise the exception to see the full traceback
def publish_mqtt(topic, value):
client.publish(topic, value)
print(topic)
print(value)
print("Publish Done")
try:
if not initialize_wifi(config.wifi_ssid, config.wifi_password):
print('Error connecting to the network... exiting program')
else:
# Connect to MQTT broker, start MQTT client
client = connect_mqtt()
while True:
# Read sensor data
temperature, humidity, pressure = get_sensor_readings()
# Publish as MQTT payload
publish_mqtt(MQTT_TOPIC_TEMPERATURE, str(temperature))
publish_mqtt(MQTT_TOPIC_PRESSURE, str(pressure))
publish_mqtt(MQTT_TOPIC_HUMIDITY, str(humidity))
# Delay 10 seconds
sleep(10)
except Exception as e:
print('Error:', e)
Cara Kerja Kode
Pada contoh ini, kita menggunakan beberapa topik MQTT untuk mempublikasikan data sensor, yaitu:
- pico/temperature — untuk data suhu
- pico/humidity — untuk data kelembapan
- pico/pressure — untuk data tekanan udara
Alur kerja untuk mempublikasikan data adalah sebagai berikut:
1. Raspberry Pi Pico terhubung ke jaringan internet.
2. Pico melakukan koneksi ke broker MQTT.
3. Setelah koneksi berhasil, perangkat dapat mengirimkan pesan MQTT secara berkala.
Mari kita lihat penjelasan setiap bagian kode.
Mengimpor Library
Pertama, kita mengimpor pustaka yang diperlukan. Modul Pin dan I2C dari machine digunakan untuk berkomunikasi dengan perangkat keras, sedangkan BME280 digunakan untuk mengakses sensor BME280. Modul network diperlukan untuk koneksi Wi-Fi, dan kelas MQTTClient dari umqtt.simple digunakan untuk menjalankan fungsi-fungsi MQTT.
from machine import Pin, I2C
from time import sleep
import network
from umqtt.simple import MQTTClient
import config
import BME280
Pada variabel berikut, kita mendefinisikan topik MQTT yang akan digunakan sebagai tujuan publikasi pesan (hasil pembacaan sensor).
# Constants for MQTT Topics
MQTT_TOPIC_TEMPERATURE = 'pico/temperature'
MQTT_TOPIC_PRESSURE = 'pico/pressure'
MQTT_TOPIC_HUMIDITY = 'pico/humidity'
Pada bagian berikut, kita menetapkan parameter MQTT yang diperlukan untuk melakukan koneksi ke broker MQTT. Nilai seperti URL server, username, dan password diambil langsung dari berkas config.py.
# MQTT Parameters
MQTT_SERVER = config.mqtt_server
MQTT_PORT = 0
MQTT_USER = config.mqtt_username
MQTT_PASSWORD = config.mqtt_password
MQTT_CLIENT_ID = b"raspberrypi_picow"
MQTT_KEEPALIVE = 7200
MQTT_SSL = True
MQTT_SSL_PARAMS = {'server_hostname': MQTT_SERVER}
Parameter `MQTT_CLIENT_ID` harus berupa identitas unik yang digunakan untuk mengidentifikasi klien MQTT secara individual. Anda bebas memberikan nama apa pun, asalkan tidak sama dengan `client_id` klien lain yang terhubung ke broker Anda. Dalam contoh ini, kami menggunakan `raspberrypi_picow`.
MQTT_CLIENT_ID = b"raspberrypi_picow"
Jika Anda menggunakan broker Mosquitto lokal, atur parameter `MQTT_SSL` menjadi False.
MQTT_SSL = False
Pada bagian berikut, kita melakukan inisialisasi sensor BME280 dan mendefinisikan fungsi `get_sensor_readings()` yang bertugas mengambil data dari sensor tersebut serta mengembalikan nilai suhu, kelembaban, dan tekanan udara.
# Initialize I2C communication
i2c = I2C(id=0, scl=Pin(5), sda=Pin(4), freq=10000)
# Initialize BME280 sensor
bme = BME280.BME280(i2c=i2c, addr=0x76)
def get_sensor_readings():
temp = bme.temperature[:-1]
hum = bme.humidity[:-1]
pres = bme.pressure[:-3]
return temp, hum, pres
Initialize Wi-Fi
Fungsi `initialize_wifi()` bertugas mengonfigurasi dan menghubungkan Raspberry Pi Pico ke jaringan nirkabel. Proses inisialisasi Wi-Fi ini wajib dilakukan agar perangkat dapat terhubung ke broker MQTT dan melakukan pertukaran data secara real-time.
def initialize_wifi(ssid, password):
wlan = network.WLAN(network.STA_IF)
wlan.active(True)
# Connect to the network
wlan.connect(ssid, password)
# Wait for Wi-Fi connection
connection_timeout = 10
while connection_timeout > 0:
if wlan.status() >= 3:
break
connection_timeout -= 1
print('Waiting for Wi-Fi connection...')
sleep(1)
# Check if connection is successful
if wlan.status() != 3:
return False
else:
print('Connection successful!')
network_info = wlan.ifconfig()
print('IP address:', network_info[0])
return True
Connect to MQTT
Fungsi `connect_mqtt()` menangani proses koneksi ke broker MQTT dengan memanfaatkan parameter konfigurasi broker yang telah ditentukan sebelumnya, sehingga perangkat dapat melakukan publikasi dan langganan pesan secara efektif.
def connect_mqtt():
try:
client = MQTTClient(client_id=MQTT_CLIENT_ID,
server=MQTT_SERVER,
port=MQTT_PORT,
user=MQTT_USER,
password=MQTT_PASSWORD,
keepalive=MQTT_KEEPALIVE,
ssl=MQTT_SSL,
ssl_params=MQTT_SSL_PARAMS)
client.connect()
return client
except Exception as e:
print('Error connecting to MQTT:', e)
raise # Re-raise the exception to see the full traceback
Publish MQTT Messages
Fungsi `publish_mqtt()` digunakan untuk mengirim payload ke topik tertentu pada broker MQTT. Cukup berikan nama topik dan data yang akan dikirim sebagai argumen agar pesan dapat dipublikasikan dengan benar.
def publish_mqtt(topic, value):
client.publish(topic, value)
print(topic)
print(value)
print("Publish Done")
Publishing Sensor Readings
Setelah seluruh fungsi dan parameter dikonfigurasi, perangkat dapat mulai terhubung ke jaringan dan broker MQTT untuk mengirim data sensor.
Langkah pertama adalah melakukan koneksi Wi-Fi menggunakan SSID dan kata sandi yang diambil dari berkas `config.py`.
try:
if not initialize_wifi(config.wifi_ssid, config.wifi_password):
print('Error connecting to the network... exiting program')
Jika koneksi Wi-Fi berhasil, langkah berikutnya adalah melakukan inisiasi koneksi ke broker MQTT.
else:
# Connect to MQTT broker, start MQTT client
client = connect_mqtt()
Setelah koneksi berhasil, modul mengambil data terbaru dari sensor dan menyimpannya ke dalam variabel temperature, humidity, dan pressure.
# Read sensor data
temperature, humidity, pressure = get_sensor_readings()
Terakhir, fungsi publish_mqtt() digunakan untuk mengirim data sensor ke topik masing-masing. Karena payload MQTT harus berupa string, nilai pembacaan sensor perlu dikonversi terlebih dahulu menggunakan fungsi str().
# Publish as MQTT payload
publish_mqtt(MQTT_TOPIC_TEMPERATURE, str(temperature))
publish_mqtt(MQTT_TOPIC_PRESSURE, str(pressure))
publish_mqtt(MQTT_TOPIC_HUMIDITY, str(humidity))
Pembacaan sensor diperbarui dan dikirim ke broker setiap interval 10 detik.
sleep(10)
Pengujian Kode
Jalankan skrip tersebut pada Raspberry Pi Pico Anda. Perangkat akan melakukan koneksi ke jaringan dan mulai mengirimkan pesan ke broker setiap 10 detik.
Selanjutnya, kita dapat memverifikasi apakah pesan berhasil diterima oleh klien MQTT yang berlangganan pada topik terkait. HiveMQ menyediakan antarmuka Web Client yang memungkinkan Anda melakukan subscribe dan publish ke berbagai topik untuk keperluan pengujian.
Buka cluster HiveMQ Anda, lalu pilih tab Web Client. Masukkan username dan password MQTT broker Anda, kemudian klik Connect Client.
Langganilah topik yang digunakan Raspberry Pi Pico untuk mengirimkan data. Masukkan pico/temperature, kemudian klik +Subscribe untuk mulai memantau pesan yang diterbitkan.
Ulangi langkah yang sama untuk topik pico/humidity dan pico/pressure.
Setelah berlangganan ke topik-topik tersebut, gulir halaman ke bagian bawah. Anda seharusnya mulai melihat pesan MQTT yang dikirim oleh Raspberry Pi Pico.
Dan itu saja. Anda telah berhasil mempublikasikan pesan MQTT menggunakan Raspberry Pi Pico. Sekarang, Anda dapat menggunakan klien MQTT lain untuk melakukan subscribe pada topik yang sama dan menerima data tersebut. Misalnya, Anda bisa menggunakan Node-RED nodes atau Adafruit IO widget untuk menampilkan data dalam bentuk grafik atau indikator.
Selain itu, perangkat mikrokontroler lain juga dapat berlangganan topik yang sama untuk menerima data bisa berupa Raspberry Pi Pico lain, ESP32, ESP8266, atau papan mikrokontroler lainnya.
Subscribe ke Topik MQTT
Untuk menunjukkan cara melakukan subscribe ke topik MQTT menggunakan Raspberry Pi Pico, kita akan membuat contoh sederhana. Dalam contoh ini, Pico akan melakukan subscribe pada topik pico/le. Kemudian, melalui HiveMQ Web Client, kita akan mempublikasikan pesan ON dan OFF pada topik tersebut. Raspberry Pi Pico akan menerima pesan dan mengendalikan LED sesuai instruksi.
Berikut alur kerja untuk melakukan subscribe ke topik MQTT:
1. Hubungkan Raspberry Pi Pico ke jaringan internet.
2. Lakukan koneksi ke broker MQTT.
3. Subscribe ke topik MQTT yang diinginkan.
4. Buat dan tetapkan fungsi callback yang akan dijalankan setiap kali pesan diterima.
5. Buat loop yang secara terus-menerus memeriksa pesan MQTT baru.
Kode berikut ini melakukan subscribe ke topik pico/led dan mengendalikan LED sesuai dengan pesan yang diterima.
# Rui Santos & Sara Santos - Random Nerd Tutorials
# Complete project details at https://RandomNerdTutorials.com/raspberry-pi-pico-w-mqtt-micropython/
from machine import Pin
from time import sleep
import network
from umqtt.simple import MQTTClient
import config
# Define LED
led = Pin('LED', Pin.OUT)
# Constants for MQTT Topics
MQTT_TOPIC_LED = 'pico/led'
# MQTT Parameters
MQTT_SERVER = config.mqtt_server
MQTT_PORT = 0
MQTT_USER = config.mqtt_username
MQTT_PASSWORD = config.mqtt_password
MQTT_CLIENT_ID = b'raspberrypi_picow'
MQTT_KEEPALIVE = 7200
MQTT_SSL = True # set to False if using local Mosquitto MQTT broker
MQTT_SSL_PARAMS = {'server_hostname': MQTT_SERVER}
# Init Wi-Fi Interface
def initialize_wifi(ssid, password):
wlan = network.WLAN(network.STA_IF)
wlan.active(True)
# Connect to the network
wlan.connect(ssid, password)
# Wait for Wi-Fi connection
connection_timeout = 10
while connection_timeout > 0:
if wlan.status() >= 3:
break
connection_timeout -= 1
print('Waiting for Wi-Fi connection...')
sleep(1)
# Check if connection is successful
if wlan.status() != 3:
return False
else:
print('Connection successful!')
network_info = wlan.ifconfig()
print('IP address:', network_info[0])
return True
# Connect to MQTT Broker
def connect_mqtt():
try:
client = MQTTClient(client_id=MQTT_CLIENT_ID,
server=MQTT_SERVER,
port=MQTT_PORT,
user=MQTT_USER,
password=MQTT_PASSWORD,
keepalive=MQTT_KEEPALIVE,
ssl=MQTT_SSL,
ssl_params=MQTT_SSL_PARAMS)
client.connect()
return client
except Exception as e:
print('Error connecting to MQTT:', e)
# Subcribe to MQTT topics
def subscribe(client, topic):
client.subscribe(topic)
print('Subscribe to topic:', topic)
# Callback function that runs when you receive a message on subscribed topic
def my_callback(topic, message):
# Perform desired actions based on the subscribed topic and response
print('Received message on topic:', topic)
print('Response:', message)
# Check the content of the received message
if message == b'ON':
print('Turning LED ON')
led.value(1) # Turn LED ON
elif message == b'OFF':
print('Turning LED OFF')
led.value(0) # Turn LED OFF
else:
print('Unknown command')
try:
# Initialize Wi-Fi
if not initialize_wifi(config.wifi_ssid, config.wifi_password):
print('Error connecting to the network... exiting program')
else:
# Connect to MQTT broker, start MQTT client
client = connect_mqtt()
client.set_callback(my_callback)
subscribe(client, MQTT_TOPIC_LED)
# Continuously checking for messages
while True:
sleep(5)
client.check_msg()
print('Loop running')
except Exception as e:
print('Error:', e)
Jika Anda menggunakan broker Mosquitto lokal, pastikan parameter `MQTT_SSL` diatur menjadi False.
MQTT_SSL = False
Subscribe ke Topik MQTT
Kita membuat fungsi bernama `subscribe()` yang menerima dua argumen: klien MQTT dan topik yang ingin dijadikan langganan (subscribe).
def subscribe(client, topic):
client.subscribe(topic)
print('Subscribe to topic:', topic)
Fungsi Callback
Kita perlu membuat fungsi callback yang akan dijalankan setiap kali pesan baru diterima pada topik yang telah dilanggan. Argumen topic dan message akan secara otomatis diteruskan ke fungsi saat fungsi tersebut dipanggil.
def my_callback(topic, message):
# Perform desired actions based on the subscribed topic and response
print('Received message on topic:', topic)
print('Response:', message)
# Check the content of the received message
if message == b'ON':
print('Turning LED ON')
led.value(1) # Turn LED ON
elif message == b'OFF':
print('Turning LED OFF')
led.value(0) # Turn LED OFF
else:
print('Unknown command')
Dalam fungsi ini, kita memeriksa isi pesan yang diterima. Jika pesan bernilai ON, maka LED bawaan Raspberry Pi Pico akan dinyalakan.
if message == b'ON':
print('Turning LED ON')
led.value(1) # Turn LED ON
Jika pesan bernilai OFF, LED akan dimatikan.
elif message == b'OFF':
print('Turning LED OFF')
led.value(0) # Turn LED OFF
Apabila pesan yang diterima bukan ON atau OFF, maka akan ditampilkan teks Unknown command.
else:
print('Unknown command')
Koneksi ke Wi-Fi, Broker MQTT, dan Pemantauan Pesan
Untuk melakukan subscribe ke broker MQTT dan secara terus-menerus memantau pesan yang masuk, langkah pertama adalah memastikan Raspberry Pi Pico terhubung ke jaringan internet. Baris kode berikut bertugas melakukan inisialisasi dan koneksi ke jaringan Wi-Fi:
try:
# Initialize Wi-Fi
if not initialize_wifi(config.wifi_ssid, config.wifi_password):
print('Error connecting to the network... exiting program')
Jika koneksi berhasil, Raspberry Pi Pico akan terhubung ke broker MQTT.
client = connect_mqtt()
Selanjutnya, tetapkan fungsi callback menggunakan `set_callback()`, dengan argumen fungsi callback yang telah dibuat sebelumnya, yaitu `my_callback`.
client.set_callback(my_callback)
Kemudian, lakukan subscribe ke topik MQTT. Dalam contoh ini, kita hanya melakukan subscribe pada `MQTT_TOPIC_LED`, namun Anda dapat berlangganan ke beberapa topik sekaligus.
subscribe(client, MQTT_TOPIC_LED)
Buat while loop untuk secara terus-menerus memeriksa pesan yang masuk menggunakan metode `check_msg()`.
while True:
sleep(5)
client.check_msg()
print('Loop running')
Anda juga dapat menambahkan tugas lain dalam loop tersebut. Pada contoh ini, pemeriksaan pesan baru dilakukan setiap lima detik, namun interval dapat disesuaikan tergantung frekuensi penerimaan pesan yang diharapkan.
Pengujian Kode
Jalankan skrip yang telah dibuat pada Raspberry Pi Pico. Perangkat akan terhubung ke jaringan internet dan melakukan subscribe ke topik MQTT yang telah ditentukan.
Selanjutnya, kita akan mempublikasikan beberapa pesan pada topik pico/led untuk mengendalikan LED melalui HiveMQ Web Client.
Buka HiveMQ Web Client pada cluster Anda, masukkan username dan password MQTT broker, lalu klik Connect Client.
Gulir halaman ke bagian Publish Message.
Masukkan pico/led pada kolom Topic Name, kemudian ketik ON pada kolom Message.
Terakhir, klik tombol Publish.
Raspberry Pi Pico akan menerima pesan tersebut dan menyalakan LED bawaan sesuai instruksi.
Kembali ke HiveMQ Web Client dan kirim pesan OFF.
Raspberry Pi Pico akan menerima pesan tersebut dan mematikan LED bawaan.
Anda telah berhasil melakukan subscribe ke topik MQTT dan mengeksekusi tugas sesuai dengan pesan yang diterima. Kini, alih-alih menggunakan HiveMQ Web Client, Anda dapat memanfaatkan platform Home Automation atau IoT lain yang mendukung MQTT untuk membuat antarmuka web dengan tombol atau saklar yang mengirimkan pesan MQTT.
Baca juga: Cara Membuat Web Server Asinkron di Raspberry Pi Pico W 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: "Panduan Lengkap Memulai MQTT di Raspberry Pi Pico W dengan MicroPython"