IoT Menjadi Mudah: ESP-MicroPython-MQTT-ThingSpeak: 12 Langkah

2024 Pengarang: John Day | [email protected]. Terakhir diubah: 2024-01-30 09:56

Dalam tutorial saya sebelumnya, MicroPython di ESP menggunakan Jupyter, kami belajar cara menginstal dan menjalankan MicroPython di perangkat ESP. Menggunakan Notebook Jupyter sebagai lingkungan pengembangan kami, kami juga belajar cara membaca dari sensor (Suhu, Kelembaban, dan Luminositas), Kami menggunakan beberapa protokol dan metode komunikasi, Analog, Digital, 1-Wire dan I2C, yang terakhir ini untuk menampilkan hasil tangkapan kami data pada layar OLED.

Sekarang, pada tutorial ini menggunakan protokol MQTT, kita akan mendapatkan semua data yang diambil, mengirimkannya ke layanan IoT, ThingSpeak.com dan ke Aplikasi seluler (Thingsview), tempat kita dapat masuk dan bermain dengan data.

Di sini, diagram blok proyek kami:

Langkah 1: BoM - Bill of Material

1. NodeMCU - US$8,39
2. Sensor Suhu dan Kelembaban Relatif DHT22 - USD 9,95
3. Sensor Suhu Tahan Air DS18B20 - USD 5,95
4. Layar OLED SSD1366- USD 8,99 (opsional)
5. LDR (1x)
6. LED (1x) (Opsional)
7. Tombol Tekan (1x)
8. Resistor 4K7 ohm (2x)
9. Resistor 10K ohm (1x)
10. Resistor 220 ohm (1x)

Langkah 2: Hw

Hw yang akan kita gunakan di sini pada dasarnya sama dengan yang digunakan pada tutorial: Micropython di ESP Menggunakan Jupyter. Lihat untuk semua koneksi HW.

Pengecualian adalah Servo, bahwa kami tidak akan digunakan dalam proyek ini.

Di atas Anda dapat melihat HW lengkap. Hubungkan perangkat seperti yang ditunjukkan di sana.

Langkah 3: Micropython, REPL, Jupyter

Anda harus memiliki juru bahasa Micropython yang dimuat di perangkat ESP Anda. Setelah dimuat, Anda harus memprogram ESP Anda menggunakan salah satu cara/IDE yang tersedia, seperti:

• REPL
• Buku Catatan Jupyter
• mu
• ESPCut (hanya Windows)
• … dll

Pada tutorial saya, Micropython di ESP Menggunakan Jupyter, saya merinci cara mengunduh dan menginstal juru bahasa MicroPython, ESPTool untuk mengelola perangkat ESP dan cara menggunakan Notebook Jupyter sebagai Lingkungan Pengembangan. Jangan ragu untuk menggunakan apa yang lebih nyaman bagi Anda.

Saya biasanya membuat semua pengembangan di Jupyter Notebook, dan setelah saya mendapatkan kode akhir, saya menyalinnya ke Geany dan memuatnya di ESP saya menggunakan Ampy.

Langkah 4: Sensor

Mari instal perpustakaan, definisikan GPIO, buat objek, fungsi untuk semua sensor satu per satu:

A. DHT (Suhu dan Kelembaban)

Mari Instal perpustakaan DHT dan buat objek:

dari dht impor DHT22

dari mesin impor Pin dht22 = DHT22(Pin(12))

Sekarang, buat fungsi untuk membaca sensor DHT:

def readDht():

dht22.measure() mengembalikan dht22.temperature(), dht22.humidity() Uji fungsi DHT

cetak (bacaDht())

Hasilnya harus misalnya:

(17.7, 43.4)

B. DS18B20 (Suhu Eksternal)

Mari Instal perpustakaan dan buat objek:

impor onewire, ds18x20

import time # Tentukan pin mana perangkat 1-kawat akan dihubungkan ==> pin 2 (D4) dat = Pin(2) # buat objek onewire ds = ds18x20. DS18X20(onewire. OneWire(dat)) Pindai perangkat di bu

sensor = ds.scan()

print('perangkat yang ditemukan:', sensor)

Hasil cetakan tidak terlalu penting, yang kita perlukan adalah sensor pertama yang terdeteksi: sensor[0]. Dan sekarang, kita dapat membangun sebuah fungsi untuk membaca data sensor:

def readDs():

ds.convert_temp() waktu.sleep_ms(750) mengembalikan ds.read_temp(sensors[0])

Itu selalu penting untuk menguji sensor menggunakan fungsi yang dibuat

cetak(bacaDs()) Jika Anda mendapatkan nilai suhu, kode Anda benar

17.5

C. LDR (Luminositas)

LDR akan menggunakan pin analog ESP kita (hanya satu untuk ESP8266 dan beberapa untuk ESP32).

Lihat tutorial ESP32 saya untuk detailnya.

Sama seperti yang dilakukan sebelumnya:

# impor perpustakaan

dari mesin impor ADC # Tentukan objek adc = ADC(0) Fungsi sederhana: adc.read() dapat digunakan untuk membaca nilai ADC. Tapi ingat bahwa ADC internal akan mengubah tegangan antara 0 dan 3,3V dalam nilai digital koresponden, bervariasi dari 0 hingga 1023. Setelah kita tertarik pada "Luminositas", kita akan menganggap cahaya Max sebagai nilai maksimum yang ditangkap dari sensor (di case 900) dan cahaya minimum yang dalam kasus saya adalah 40. Memiliki nilai-nilai itu, kita dapat "memetakan" nilai dari 40 hingga 900 dalam 0 hingga 100% luminositas. Untuk itu, kita akan membuat fungsi baru

def readLdr():

lumPerct = (adc.read()-40)*(10/86) # konversi dalam persentase ("peta") pengembalian putaran(lumPerct)

Anda harus menguji fungsi menggunakan print (readLDR()). Hasilnya harus berupa bilangan bulat antara o dan 100.

D. Tombol Tekan (Input Digital)

Di sini kita menggunakan Push-Button sebagai sensor digital, tetapi itu bisa menjadi "gema" dari aktuator (Pompa yang dihidupkan / dimatikan, misalnya).

# tentukan pin 13 sebagai input dan aktifkan resistor Pull-up internal:

button = Pin(13, Pin. IN, Pin. PULL_UP) # Fungsi untuk membaca status tombol: def readBut(): return button.value()

Anda dapat menguji tombol membaca fungsi print(readBut()). Tanpa menekan hasilnya harus "1". Menekan tombol, hasilnya harus "0"

Langkah 5: Menangkap dan Menampilkan Semua Data Sensor Secara Lokal

Sekarang kita telah membuat satu fungsi untuk setiap sensor, mari buat yang terakhir yang akan membaca semuanya secara bersamaan:

def colectData():

temp, hum, = readDht() extTemp = readDs() lum = readLdr() butSts = readBut() mengembalikan temp, hum, extTemp, lum, butSts Sekarang jika Anda menggunakan

cetak(colectData())

Akan menghasilkan tuple yang mencakup semua data yang diambil dari sensor:

(17.4, 45.2, 17.3125, 103, 1)

Kami juga dapat secara opsional, menampilkan data tersebut pada tampilan lokal:

# impor perpustakaan dan buat objek i2c

dari mesin import I2C i2c = I2C(scl=Pin(5), sda=Pin(4)) # import library dan buat objek oled import ssd1306 i2c = I2C(scl=Pin(5), sda=Pin(4)) oled = ssd1306. SSD1306_I2C(128, 64, i2c, 0x3c) # buat fungsi: def displayData(temp, hum, extTemp, lum, butSts): oled.fill(0) oled.text("Temp: " + str(temp) + "oC", 0, 4) oled.text("Hum: " + str(hum) + "%", 0, 16) oled.text("ExtTemp: " + str(extTemp) + "oC", 0, 29) oled.text("Lumin: " + str(lum) + "%", 0, 43) oled.text("Tombol: " + str(butSts), 0, 57) oled.show() # menampilkan data menggunakan fungsi displayData(temp, hum, extTemp, lum, butSts)

Sebagai pilihan, saya juga akan menyertakan LED menjadi ON ketika kita mulai membaca sensor, mati setelah data tersebut ditampilkan. Melakukan hal ini akan membantu untuk mengonfirmasi bahwa program tersebut berfungsi ketika ESP terputus dari PC dan berjalan secara otomatis.

Jadi, fungsi utamanya adalah:

# Fungsi utama untuk membaca semua sensor

def main(): # menampilkan data dengan fungsi led.on() temp, hum, extTemp, lum, butSts = colectData() displayData(temp, hum, extTemp, lum, butSts) led.off()

Jadi, dengan menjalankan main(), kita akan mendapatkan data sensor yang ditampilkan pada OLED seperti yang ditunjukkan pada gambar.

Langkah 6: Menjalankan Kode Stasiun Lokal di Start-up ESP

Kami dapat memiliki semua yang dikembangkan sejauh ini pada satu file untuk dieksekusi oleh ESP kami.

Mari kita buka editor teks apa saja dan lewati semua kode:

# impor perpustakaan umum

dari mesin impor Pin waktu impor # tentukan pin 0 sebagai output led = Pin(0, Pin. OUT) # DHT dari dht import DHT22 dht22 = DHT22(Pin(12)) # Berfungsi untuk membaca DHT def readDht(): dht22.measure () return dht22.temperature(), dht22.humidity() # DS18B20 import onewire, ds18x20 # Tentukan pin mana perangkat 1-kawat akan terhubung ==> pin 2 (D4) dat = Pin(2) # Buat onewire objek ds = ds18x20. DS18X20(onewire. OneWire(dat)) # memindai perangkat di bus sensor = ds.scan() # berfungsi untuk membaca DS18B20 def readDs(): ds.convert_temp() time.sleep_ms(750) return round(ds.read_temp(sensors[0]), 1) # LDR dari mesin impor ADC # Tentukan objek adc = ADC(0) #fungsi untuk membaca luminositas def readLdr(): lumPerct = (adc.read()-40) *(10/86) # konversi dalam persentase ("peta") putaran balik(lumPerct) # tentukan pin 13 sebagai input dan aktifkan resistor Pull-up internal: tombol = Pin(13, Pin. IN, Pin. PULL_UP) # Fungsi untuk membaca status tombol: def readBut(): return button.value() # Fungsi untuk membaca semua data: def cole ctData(): temp, hum, = readDht() extTemp = readDs() lum = readLdr() butSts = readBut() mengembalikan temp, hum, extTemp, lum, butSts # mengimpor perpustakaan dan membuat objek i2c dari mesin impor I2C i2c = I2C(scl=Pin(5), sda=Pin(4)) # impor library dan buat objek oled impor ssd1306 i2c = I2C(scl=Pin(5), sda=Pin(4)) oled = ssd1306. SSD1306_I2C(128, 64, i2c, 0x3c) # membuat fungsi: def displayData(temp, hum, extTemp, lum, butSts): oled.fill(0) oled.text("Temp: " + str(temp) + "oC", 0, 4) oled.text("Hum: " + str(hum) + "%", 0, 16) oled.text("ExtTemp: " + str(extTemp) + "oC", 0, 29) oled. text("Lumin: " + str(lum) + "%", 0, 43) oled.text("Button: " + str(butSts), 0, 57) oled.show() # Fungsi utama untuk membaca semua sensor def main(): # menampilkan data dengan fungsi led.on() temp, hum, extTemp, lum, butSts = colectData() displayData(temp, hum, extTemp, lum, butSts) led.off() '''- ----- jalankan fungsi utama --------''' main()

Simpan, misalnya sebagai localData.py.

Untuk menjalankan kode ini langsung di terminal Anda, Anda memerlukan Ampy.

Pertama, di Terminal, beri tahu Ampy port Serial kami:

ekspor AMPY_PORT=/dev/tty. SLAB_USBtoUART

Sekarang, kita dapat melihat file-file yang ada di dalam direktori root ESP kita:

ampy l

Sebagai tanggapan, kita akan mendapatkan boot.py, yaitu file pertama yang akan berjalan di sistem.

Sekarang, mari kita gunakan Ampy untuk memuat skrip python LocalData.py sebagai /main.py, sehingga skrip akan berjalan tepat setelah boot:

ampy put localData.py /main/py

Jika kita menggunakan perintah amp ls sekarang, Anda akan melihat 2 file di dalam ESP.: boot.py dan main.py

Mengatur ulang ESP Anda, akan membuat program localData.py berjalan secara otomatis, menampilkan data sensor pada layar.

Layar cetak Terminal di atas menunjukkan apa yang telah kami lakukan.

Dengan kode di atas, tampilan hanya akan ditampilkan sekali, tetapi kita dapat mendefinisikan loop pada fungsi main(), yang akan menampilkan data pada setiap interval waktu yang ditentukan (PUB_TIME_SEC), dan misalnya, sampai kita menekan tombol:

# loop mendapatkan data sampai tombol ditekan

while button.value(): led.on() temp, hum, extTemp, lum, butSts = colectData() displayData(temp, hum, extTemp, lum, butSts) led.off() time.sleep(PUB_TIME_SEC)

Variabel PUB_TIME_SEC harus dideklarasikan pada saat Anda menginginkan sampel Anda.

Untuk meningkatkan lebih banyak kode kami, akan baik untuk menginformasikan bahwa kami akan keluar dari loop, untuk itu kami akan mendefinisikan 2 fungsi umum baru, satu untuk menghapus tampilan dan satu lagi untuk mengedipkan LED pada beberapa kali.

# Hapus tampilan:

def displayClear(): oled.fill(0) oled.show() # membuat fungsi blink def blinkLed(num): for i in range(0, num): led.on() sleep(0.5) led.off() tidur(0.5)

Jadi, sekarang kita bisa, menulis ulang fungsi main() kita:

sementara button.value():

led.on() temp, hum, extTemp, lum, butSts = colectData() displayData(temp, hum, extTemp, lum, butSts) led.off() time.sleep(PUB_TIME_SEC) blinkLed(3) displayClear()

Kode terakhir dapat diunduh dari GitHub saya: localData.py dan juga Notebook Jupyter yang digunakan untuk pengembangan kode lengkap: Pengembangan Data Lokal Jupyter.

Langkah 7: Menghubungkan ESP ke WiFi Lokal

Modul jaringan digunakan untuk mengkonfigurasi koneksi WiFi. Ada dua antarmuka WiFi, satu untuk stasiun (saat ESP8266 terhubung ke router) dan satu lagi untuk titik akses (untuk perangkat lain yang terhubung ke ESP8266). Di sini, ESP kita akan terhubung ke jaringan lokal. Mari kita panggil perpustakaan dan tentukan kredensial jaringan kita:

jaringan impor

WiFi_SSID = "SSID ANDA" WiFi_PASS = "PASSWORD ANDA"

Fungsi di bawah ini dapat digunakan untuk menghubungkan ESP ke jaringan lokal Anda:

def do_connect():

wlan = network. WLAN(network. STA_IF) wlan.active(True) if not wlan.isconnected(): print('connecting to network…') wlan.connect(WiFi_SSID, WiFi_SSID) while not wlan.isconnected(): lulus print('konfigurasi jaringan:', wlan.ifconfig())

Menjalankan fungsi, Anda bisa mendapatkan alamat IP sebagai hasilnya:

lakukan_koneksi()

Hasilnya akan menjadi:

konfigurasi jaringan: ('10.0.1.2', '255.255.255.0', '10.0.1.1', '10.0.1.1')

Apakah, dalam kasus saya, 10.0.1.2, adalah alamat IP ESP.

Langkah 8: The ThingSpeak

Pada titik ini, kami belajar cara menangkap data dari semua sensor, menampilkannya di OLED kami. Sekarang, saatnya untuk melihat cara mengirim data tersebut ke platform IoT, ThingSpeak.

Mari kita mulai!

Pertama, Anda harus memiliki akun di ThinkSpeak.com. Selanjutnya, ikuti petunjuk untuk membuat Saluran dan catat ID Saluran dan Tulis Kunci API Anda.

Di atas Anda dapat melihat 5 bidang yang akan digunakan di Saluran kami.

Langkah 9: Protokol MQTT dan Koneksi ThingSpeak

MQTT adalah arsitektur publish/subscribe yang dikembangkan terutama untuk menghubungkan bandwidth dan perangkat yang dibatasi daya melalui jaringan nirkabel. Ini adalah protokol sederhana dan ringan yang berjalan di atas soket TCP/IP atau WebSockets. MQTT melalui WebSockets dapat diamankan dengan SSL. Arsitektur publish/subscribe memungkinkan pesan didorong ke perangkat klien tanpa perangkat perlu terus melakukan polling ke server.

Pialang MQTT adalah titik pusat komunikasi, dan bertanggung jawab untuk mengirimkan semua pesan antara pengirim dan penerima yang sah. Klien adalah perangkat apa pun yang terhubung ke broker dan dapat mempublikasikan atau berlangganan topik untuk mengakses informasi. Topik berisi informasi perutean untuk broker. Setiap klien yang ingin mengirim pesan memublikasikannya ke topik tertentu, dan setiap klien yang ingin menerima pesan berlangganan topik tertentu. Pialang mengirimkan semua pesan dengan topik yang cocok kepada klien yang sesuai.

ThingSpeak™ memiliki broker MQTT di URL mqtt.thingspeak.com dan port 1883. Broker ThingSpeak mendukung publikasi MQTT dan berlangganan MQTT.

Dalam kasus kami, kami akan menggunakan: MQTT Publish

Gambar tersebut menjelaskan struktur topik. Kunci API Tulis diperlukan untuk memublikasikan. Pialang mengakui permintaan CONNECT yang benar dengan CONNACK.

Protokol MQTT didukung di perpustakaan bawaan di binari Micropython -- protokol ini dapat digunakan untuk mengirim data dari ESP8266 Anda, melalui WIFI, ke basis data cloud gratis.

Mari kita gunakan perpustakaan umqtt.simple:

dari umqtt.simple impor MQTTClient

Dan mengetahui ID SERVER kami, dimungkinkan untuk membuat objek klien MQTT kami:

SERVER = "mqtt.thingspeak.com"

klien = MQTTClient("umqtt_klien", SERVER)

Sekarang, dengan memiliki kredensial ThingSpeak Anda:

CHANNEL_ID = "ID SALURAN ANDA"

WRITE_API_KEY = "KUNCI ANDA DI SINI"

Mari kita buat "Topik" MQTT kita:

topik = "saluran/" + CHANNEL_ID + "/publish/" + WRITE_API_KEY

Mari dapatkan data kita untuk dikirim ke ThingSpeak IoT Service, menggunakan fungsi yang dibuat dan mengaitkan responsnya dengan variabel data tertentu:

temp, hum, extTemp, lum, butSts = colectData()

Dengan variabel tersebut diperbarui, kami dapat membuat "MQTT Payload" kami:

payload = "field1="+str(temp)+"&field2="+str(hum)+"&field3="+str(extTemp)+"&field4="+str(lum)+"&field5="+str(butSts)

Dan itu saja! Kami siap mengirim data ke ThinsSpeak, cukup menggunakan 3 baris kode di bawah ini:

klien.koneksi()

client.publish(topik, payload) client.disconnect()

Sekarang, jika Anda membuka halaman saluran (seperti milik saya di atas), Anda akan melihat bahwa masing-masing dari 5 bidang akan memiliki data yang terkait dengan sensor Anda.

Langkah 10: Pencatat Data Sensor

Sekarang, kita tahu bahwa hanya dengan beberapa baris kode dimungkinkan untuk mengunggah data ke layanan IoT, mari kita buat fungsi loop untuk melakukannya secara otomatis pada interval waktu yang teratur (mirip dengan apa yang telah kita lakukan dengan "Data lokal ").

Menggunakan variabel yang sama (PUB_TIME_SEC), yang dideklarasikan sebelumnya, fungsi utama sederhana untuk terus mengambil data, mencatatnya di saluran kami adalah:

sementara Benar:

temp, hum, extTemp, lum, butSts = colectData() payload = "field1="+str(temp)+"&field2="+str(hum)+"&field3="+str(extTemp)+"&field4="+ str(lum)+"&field5="+str(butSts) client.connect() client.publish(topic, payload) client.disconnect() time.sleep(PUB_TIME_SEC)

Perhatikan bahwa hanya "payload" yang harus diperbarui, setelah "topik" terkait dengan kredensial saluran kami dan tidak akan berubah.

Mencari halaman saluran ThingSpeak Anda, Anda akan mengamati bahwa data akan dimuat terus-menerus ke setiap bidang. Anda dapat menutupi LDR, meletakkan tangan Anda pada sensor suhu/hum, menekan tombol, dll. dan melihat bagaimana saluran akan secara otomatis "mencatat" data tersebut untuk analisis di masa mendatang.

Biasanya, untuk Data Logging, kita harus mencoba menggunakan daya seminimal mungkin, jadi kita tidak akan menggunakan LED atau tampilan lokal. Juga, adalah umum dengan perangkat ESP, menempatkannya pada "tidur nyenyak", di mana mikroprosesor akan berada pada kondisi energi minimum sampai saatnya untuk menangkap data dan mengirimkannya ke platform IoT.

Tapi, setelah di sini idenya dipelajari, mari sertakan juga tampilan dan LED seperti yang kita lakukan sebelumnya. Melakukan itu, fungsi "logger" kami akan menjadi:

sementara button.value():

led.on() temp, hum, extTemp, lum, butSts = colectData() displayData(temp, hum, extTemp, lum, butSts) led.off() temp, hum, extTemp, lum, butSts = colectData() payload = "field1="+str(temp)+"&field2="+str(hum)+"&field3="+str(extTemp)+"&field4="+str(lum)+"&field5="+str(butSts) klien.connect() client.publish(topic, payload) client.disconnect() time.sleep(PUB_TIME_SEC) blinkLed(3) displayClear()

Skrip microPython lengkap dapat ditemukan di sini: dataLoggerTS_EXT.py dan notebook Jupyter yang digunakan untuk pengembangan juga dapat ditemukan di sini: IoT ThingSpeak Data Logger EXT.ipynb.

Untuk mengunggah skrip di ESP, di terminal Anda gunakan perintah:

ampy put dataLoggerTS.py /main.py

Dan tekan tombol ESP - reset. Anda akan memiliki ESP yang menangkap data dan mencatatnya di ThingSpeak.com hingga bagian bawah terus ditekan (tunggu LED berkedip 3 kali dan OLED mati).

Langkah 11: Aplikasi ThingView

Data yang dicatat dapat dilihat langsung di situs ThingSpeak.com atau melalui APP, misalnya, ThingsView!

ThingView adalah APLIKASI yang dikembangkan oleh CINETICA, yang memungkinkan Anda untuk memvisualisasikan saluran ThingSpeak Anda dengan cara yang mudah, cukup masukkan ID saluran dan Anda siap untuk pergi.

Untuk saluran publik, aplikasi akan menghormati pengaturan jendela Anda: warna, skala waktu, jenis bagan, dan jumlah hasil. Versi saat ini mendukung bagan garis dan kolom, bagan spline ditampilkan sebagai bagan garis.

Untuk saluran pribadi, data akan ditampilkan menggunakan pengaturan default, karena tidak ada cara untuk membaca pengaturan jendela pribadi hanya dengan kunci API.

APLIKASI ThingView dapat diunduh untuk ANDROID dan IPHONE.

Langkah 12: Kesimpulan

Seperti biasa, saya berharap proyek ini dapat membantu orang lain menemukan jalan mereka ke dunia elektronik yang menarik!

Untuk detail dan kode akhir, silakan kunjungi penyimpanan GitHub saya: IoT_TS_MQTT

Untuk proyek lainnya, silakan kunjungi blog saya: MJRoBot.org

Saludos dari selatan dunia!

Sampai jumpa di instruksi saya berikutnya!

Terima kasih, Marcelo