Kemudahan dibuat IoT: ESP-MicroPython-MQTT-ThingSpeak: 12 Langkah

2024 Pengarang: John Day | [email protected]. Diubah suai terakhir: 2024-01-30 11:09

Dalam tutorial saya sebelumnya, MicroPython pada ESP menggunakan Jupyter, kami belajar cara memasang dan menjalankan MicroPython pada peranti ESP. Dengan menggunakan Jupyter Notebook sebagai persekitaran pengembangan kami, kami juga belajar membaca dari sensor (Suhu, Kelembapan, dan Luminositi), Kami menggunakan beberapa protokol dan kaedah komunikasi, Analog, Digital, 1-Wire dan I2C, yang terakhir ini untuk menampilkan rakaman kami data pada paparan OLED.

Sekarang, pada tutorial ini menggunakan protokol MQTT, kita akan mendapatkan semua data yang ditangkap, mengirimkannya ke perkhidmatan IoT, ThingSpeak.com dan ke Aplikasi mudah alih (Thingsview), di mana kita dapat log dan bermain dengan data.

Di sini, gambarajah blok projek kami:

Langkah 1: BoM - Bil Bahan

1. NodeMCU - US $ 8.39
2. Sensor Suhu dan Kelembapan Relatif DHT22 - USD 9,95
3. Sensor Suhu Kalis Air DS18B20 - USD 5,95
4. Paparan OLED SSD1366- USD 8.99 (pilihan)
5. LDR (1x)
6. LED (1x) (Pilihan)
7. Butang Tekan (1x)
8. Perintang 4K7 ohm (2x)
9. Perintang 10K ohm (1x)
10. Perintang 220 ohm (1x)

Langkah 2: The Hw

Hw yang akan kita gunakan di sini pada dasarnya adalah sama yang digunakan dalam tutorial: Micropython pada ESP Menggunakan Jupyter. Rujuknya untuk semua sambungan HW.

Pengecualian adalah Servo, bahawa kita tidak akan digunakan dalam projek ini.

Di atas anda dapat melihat HW penuh. Sambungkan peranti seperti yang ditunjukkan di sana.

Langkah 3: Micropython, REPL, Jupyter

Anda mesti memuatkan jurubahasa Micropython pada peranti ESP anda. Setelah dimuat, anda harus memprogramkan ESP anda dengan menggunakan cara / IDE yang ada, seperti:

• REPL
• Buku nota Jupyter
• Mu
• ESPCut (Windows sahaja)
• … dan lain-lain

Pada tutorial saya, Micropython pada ESP Menggunakan Jupyter, saya memperincikan cara memuat turun dan memasang juru bahasa MicroPython, ESPTool untuk menguruskan peranti ESP dan cara menggunakan Jupyter Notebook sebagai Persekitaran Pembangunan. Jangan ragu untuk menggunakan apa yang lebih selesa untuk anda.

Saya biasanya membuat semua pembangunan di Jupyter Notebook, dan setelah saya mendapat kod terakhir, saya menyalinnya ke Geany dan memuatkannya pada ESP saya menggunakan Ampy.

Langkah 4: Sensor

Mari pasang perpustakaan, tentukan GPIO, buat objek, fungsi untuk semua sensor secara individu:

A. DHT (Suhu dan Kelembapan)

Mari Pasang perpustakaan DHT dan buat objek:

dari dht import DHT22

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

Sekarang, buat fungsi untuk membaca sensor DHT:

def readDht ():

dht22. ukuran () kembali dht22. suhu (), dht22. kelembapan () Uji fungsi DHT

cetak (bacaDht ())

Hasilnya seperti:

(17.7, 43.4)

B. DS18B20 (Suhu Luar)

Mari Pasang perpustakaan dan buat objek:

import onewire, ds18x20

masa import # Tentukan pin mana peranti 1-wayar akan disambungkan ==> pin 2 (D4) dat = Pin (2) # buat objek onewire ds = ds18x20. DS18X20 (onewire. OneWire (dat)) Imbas peranti di bu

sensor = ds.scan ()

cetak ('peranti dijumpai:', sensor)

Hasil cetak tidak terlalu penting, apa yang kita perlukan adalah sensor pertama yang dikesan: sensor [0]. Dan sekarang, kita dapat membina fungsi untuk membaca data sensor:

def readDs ():

ds.convert_temp () time.sleep_ms (750) kembali ds.read_temp (sensor [0])

Selalu penting untuk menguji sensor menggunakan fungsi yang dibuat

cetak (readDs ()) Sekiranya anda mendapat nilai suhu, kod anda betul

17.5

C. LDR (Luminositi)

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

Rujuk tutorial ESP32 saya untuk maklumat lanjut.

Sama seperti yang dilakukan sebelum ini:

# pustaka import

dari mesin import ADC # Tentukan objek adc = ADC (0) Fungsi mudah: adc.read () boleh digunakan untuk membaca nilai ADC. Tetapi ingat bahawa ADC dalaman akan menukar voltan antara 0 dan 3.3V dalam nilai digital koresponden, yang bervariasi dari 0 hingga 1023. Setelah kita berminat dengan "Luminosity", kita akan menganggap cahaya Max sebagai nilai maksimum yang ditangkap dari sensor (pada saya kes 900) dan cahaya minimum yang dalam kes saya adalah 40. Memiliki nilai-nilai tersebut kita dapat "memetakan" nilai dari 40 hingga 900 dalam 0 hingga 100% cahaya. Untuk itu, kami akan membuat fungsi baru

def readLdr ():

lumPerct = (adc.read () - 40) * (10/86) # tukar dalam peratusan ("peta") pusingan pulangan (lumPerct)

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

D. Tombol Tekan (Input Digital)

Di sini kita menggunakan Push-Button sebagai sensor digital, tetapi ia boleh menjadi "gema" penggerak (Pam yang dihidupkan / dimatikan, misalnya).

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

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

Anda boleh menguji butang membaca fungsi cetak (readBut ()). W / o menekan hasilnya hendaklah "1". Menekan butang, hasilnya mestilah "0"

Langkah 5: Menangkap dan Memaparkan Data Sensor Secara Lokal

Sekarang setelah kita membuat satu fungsi untuk setiap sensor, mari buat yang terakhir yang akan membaca semuanya pada masa yang sama:

def colectData ():

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

cetak (colectData ())

Akan menghasilkan tuple yang merangkumi semua data yang ditangkap dari sensor:

(17.4, 45.2, 17.3125, 103, 1)

Kami juga dapat, secara opsional, menunjukkan data tersebut pada paparan tempatan:

# import perpustakaan dan buat objek i2c

dari mesin import I2C i2c = I2C (scl = Pin (5), sda = Pin (4)) # pustaka import dan buat objek objek impor 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 ("Button:" + str (butSts), 0, 57) oled.show () # paparkan data menggunakan fungsi displayData (temp, hum, extTemp, lum, butSts)

Sebagai pilihan, saya juga akan menyertakan LED menjadi AKTIF ketika kita mula membaca sensor, mati setelah data dipaparkan. Melakukan ini akan membantu untuk mengesahkan bahawa program ini berfungsi apabila kita telah memutuskan sambungan ESP dari PC dan berjalan secara automatik.

Oleh itu, fungsi utama adalah:

# Fungsi utama untuk membaca semua sensor

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

Jadi, dengan menjalankan utama (), kita akan mendapatkan data sensor yang dipaparkan di OLED seperti yang ditunjukkan dalam gambar.

Langkah 6: Menjalankan Kod Stesen Tempatan pada Permulaan ESP

Kita boleh memiliki semua yang dikembangkan setakat ini pada satu fail untuk dilaksanakan oleh ESP kita.

Mari buka mana-mana penyunting teks dan abaikan semua kod:

# mengimport perpustakaan am

dari mesin import Pin import time # tentukan pin 0 sebagai output output = Pin (0, Pin. OUT) # DHT dari dht import DHT22 dht22 = DHT22 (Pin (12)) # Fungsi untuk membaca DHT def readDht (): dht22.measure () return dht22.temperature (), dht22.humidity () # DS18B20 import onewire, ds18x20 # Tentukan pin mana peranti 1-wayar akan disambungkan ==> pin 2 (D4) dat = Pin (2) # Buat onewire objek ds = ds18x20. DS18X20 (onewire. OneWire (dat)) # scan untuk peranti pada sensor bas = ds.scan () # fungsi untuk membaca DS18B20 def readDs (): ds.convert_temp () time.sleep_ms (750) return bulat (ds.read_temp (sensor [0]), 1) # LDR dari mesin import ADC # Tentukan objek adc = ADC (0) #fungsi untuk membaca luminositi def readLdr (): lumPerct = (adc.read () - 40) * (10/86) # ubah dalam peratusan ("peta") putaran kembali (lumPerct) # tentukan pin 13 sebagai input dan aktifkan resistor Pull-up dalaman: butang = Pin (13, Pin. IN, Pin. PULL_UP) # Fungsi untuk membaca keadaan butang: def readBut (): return button.value () # Fungsi untuk membaca semua data: def cole ctData (): temp, hum, = readDht () extTemp = readDs () lum = readLdr () butSts = readBut () return temp, hum, extTemp, lum, butSts # import library dan buat objek i2c dari mesin import I2C i2c = I2C (scl = Pin (5), sda = Pin (4)) # pustaka import dan buat objek yang diimport 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. teks ("Lumin:" + str (lum) + "%", 0, 43) oled.text ("Button:" + str (butSts), 0, 57) oled.show () # Fungsi utama untuk membaca semua sensor def main (): # data paparan dengan fungsi led.on () temp, hum, extTemp, lum, butSts = colectData () displayData (temp, hum, extTemp, lum, butSts) led.off () "" - ----- jalankan fungsi utama -------- '' '' utama ()

Simpannya, sebagai contoh sebagai localData.py.

Untuk menjalankan kod ini terus di terminal anda, anda memerlukan Ampy.

Pertama, di Terminal mari maklumkan kepada Ampy port Serial kami:

eksport AMPY_PORT = / dev / tty. SLAB_USBtoUART

Sekarang, kita dapat melihat fail yang ada di dalam direktori root ESP kami:

ampy ls

Sebagai tindak balas, kami akan mendapat boot.py, itu adalah fail pertama yang akan dijalankan dalam sistem.

Sekarang, mari gunakan Ampy untuk memuat Skrip LocalData.py python kami sebagai /main.py, sehingga skrip akan berjalan sejurus selepas boot:

ampy meletakkan localData.py / main / py

Sekiranya kita menggunakan perintah sekarang, anda akan melihat 2 fail di dalam ESP: boot.py dan main.py

Menetapkan semula ESP anda, akan menjadikan program localData.py berjalan secara automatik, memaparkan data sensor di paparan.

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

Dengan kod di atas, paparan akan ditunjukkan hanya sekali, tetapi kita dapat menentukan fungsi loop pada main (), yang akan menunjukkan data pada setiap selang waktu yang ditentukan (PUB_TIME_SEC), dan misalnya, hingga kita menekan butang:

# gelung mendapatkan data sehingga butang ditekan

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

Pemboleh ubah PUB_TIME_SEC mesti dinyatakan pada masa yang anda mahukan sampel anda.

Untuk meningkatkan lagi kod kami, ada baiknya kami memaklumkan bahawa kami akan keluar dari lingkaran, untuk itu kami akan menentukan 2 fungsi umum baru, satu untuk membersihkan paparan dan satu lagi untuk mengedipkan LED pada beberapa kali.

# Paparan yang jelas:

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

Oleh itu, kita sekarang boleh menulis semula fungsi () utama kita:

sambil butang. nilai ():

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

Kod akhir boleh dimuat turun dari GitHub saya: localData.py dan juga Jupyter Notebook yang digunakan untuk pengembangan kod penuh: Pembangunan Data Tempatan Jupyter.

Langkah 7: Menyambungkan ESP ke WiFi Tempatan

Modul rangkaian digunakan untuk mengkonfigurasi sambungan WiFi. Terdapat dua antara muka WiFi, satu untuk stesen (ketika ESP8266 menyambung ke penghala) dan satu lagi untuk titik akses (untuk peranti lain untuk menyambung ke ESP8266). Di sini, ESP kami akan disambungkan ke rangkaian tempatan. Mari panggil perpustakaan dan tentukan kelayakan rangkaian kami:

rangkaian import

WiFi_SSID = "SSID ANDA" WiFi_PASS = "KATA LALUAN ANDA"

Fungsi di bawah ini dapat digunakan untuk menghubungkan ESP ke rangkaian tempatan anda:

def do_connect ():

wlan = network. WLAN (network. STA_IF) wlan.active (True) jika tidak wlan.isconnected (): print ('connect to network …') wlan.connect (WiFi_SSID, WiFi_SSID) sementara tidak wlan.isconnected (): lulus cetak ('konfigurasi rangkaian:', wlan.ifconfig ())

Menjalankan fungsi, anda dapat memperoleh alamat IP:

do_connect ()

Hasilnya akan:

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

Sekiranya saya, 10.0.1.2, adalah alamat IP ESP.

Langkah 8: The ThingSpeak

Pada ketika ini, kami belajar bagaimana menangkap data dari semua sensor, memaparkannya di OLED kami. Sekarang, inilah masanya untuk melihat bagaimana mengirim data tersebut ke platform IoT, the ThingSpeak.

Mari kita mulakan!

Pertama, anda mesti mempunyai akaun di ThinkSpeak.com. Seterusnya, ikuti arahan untuk membuat Saluran dan perhatikan ID Saluran anda dan Tulis Kunci API.

Di atas anda dapat melihat 5 medan yang akan digunakan di Saluran kami.

Langkah 9: Protokol MQTT dan ThingSpeak Connection

MQTT adalah seni bina penerbitan / langganan yang dibangunkan terutamanya untuk menyambungkan lebar jalur dan peranti dengan kuasa melalui rangkaian tanpa wayar. Ini adalah protokol sederhana dan ringan yang berjalan di atas soket TCP / IP atau WebSockets. MQTT melalui WebSockets dapat diamankan dengan SSL. Senibina penerbitan / langganan membolehkan mesej didorong ke peranti pelanggan tanpa peranti perlu terus melakukan tinjauan ke pelayan.

Broker MQTT adalah pusat komunikasi, dan bertanggungjawab untuk menghantar semua mesej antara pengirim dan penerima yang sah. Pelanggan adalah mana-mana peranti yang menghubungkan dengan broker dan boleh menerbitkan atau melanggan topik untuk mengakses maklumat. Topik mengandungi maklumat penghalaan untuk broker. Setiap pelanggan yang ingin mengirim mesej menerbitkannya ke topik tertentu, dan setiap pelanggan yang ingin menerima mesej melanggan topik tertentu. Broker menyampaikan semua mesej dengan topik yang sesuai kepada klien yang sesuai.

ThingSpeak ™ mempunyai broker MQTT di URL mqtt.thingspeak.com dan port 1883. Broker ThingSpeak menyokong penerbitan MQTT dan langganan MQTT.

Dalam kes kami, kami akan menggunakan: MQTT Publish

Rajah menggambarkan struktur topik. Kunci API Tulis diperlukan untuk menerbitkan. Broker mengakui permintaan CONNECT yang betul dengan CONNACK.

Protokol MQTT disokong di perpustakaan terbina dalam dalam binari Micropython - protokol ini boleh digunakan untuk menghantar data dari ESP8266 anda, melalui WIFI, ke pangkalan data awan percuma.

Mari gunakan perpustakaan umqtt.simple:

dari umqtt.simple MQTTClient import

Dan dengan mengetahui ID SERVER kami, adalah mungkin untuk membuat objek klien MQTT kami:

SERVER = "mqtt.thingspeak.com"

pelanggan = MQTTClient ("umqtt_client", SERVER)

Sekarang, mempunyai kelayakan ThingSpeak anda:

CHANNEL_ID = "ID SALURAN ANDA"

WRITE_API_KEY = "KUNCI ANDA DI SINI"

Mari buat "Topik" MQTT kami:

topic = "saluran /" + CHANNEL_ID + "/ terbitkan /" + WRITE_API_KEY

Mari sampaikan data kami ke ThingSpeak IoT Service, menggunakan fungsi yang dibuat dan kaitkan tindak balasnya dengan pemboleh ubah data tertentu:

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

Dengan pemboleh ubah tersebut dikemas kini, kami dapat membuat "MQTT Payload" kami:

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

Dan itu sahaja! Kami bersedia untuk menghantar data ke ThinsSpeak, hanya dengan menggunakan 3 baris kod di bawah:

client.connect ()

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

Sekarang, jika anda pergi ke halaman saluran anda (seperti halaman saya di atas), anda akan melihat bahawa setiap satu daripada 5 bidang tersebut mempunyai data yang berkaitan dengan sensor anda.

Langkah 10: Pencatat Data Sensor

Sekarang, kita tahu bahawa hanya dengan beberapa baris kod yang memungkinkan untuk memuat naik data ke perkhidmatan IoT, mari buat fungsi gelung untuk melakukannya secara automatik pada selang waktu biasa (serupa dengan apa yang telah kita lakukan dengan "Data tempatan ").

Menggunakan pemboleh ubah yang sama (PUB_TIME_SEC), yang dinyatakan sebelumnya, fungsi utama yang mudah untuk menangkap data secara berterusan, mencatatnya di saluran kami adalah:

Walaupun Betul:

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 bahawa hanya "muatan" yang mesti dikemas kini, sekali "topik" berkaitan dengan kelayakan saluran kami dan tidak akan berubah.

Mencari halaman saluran ThingSpeak anda, anda akan melihat bahawa data akan dimuat secara berterusan ke setiap bidang. Anda boleh menutup LDR, meletakkan sensor temp / hum, menekan butang, dan lain-lain dan melihat bagaimana saluran akan "log" data tersebut secara automatik untuk analisis masa depan.

Biasanya, untuk Pembalakan Data, kita harus berusaha menggunakan kekuatan yang kurang mungkin, jadi, kita tidak akan menggunakan LED atau paparan secara tempatan. Ia juga biasa berlaku pada peranti ESP, letakkan pada "tidur nyenyak", di mana mikropemproses akan berada pada keadaan tenaga minimum sehingga tiba masanya untuk menangkap data dan menghantarnya ke platform IoT.

Tetapi, setelah ideanya dipelajari, mari kita juga menyertakan paparan dan LED seperti yang kita lakukan sebelumnya. Melakukannya, fungsi "logger" kami adalah:

sambil butang. nilai ():

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

Skrip microPython lengkap boleh didapati di sini: dataLoggerTS_EXT.py dan buku nota Jupyter yang digunakan untuk pembangunan juga boleh didapati di sini: IoT ThingSpeak Data Logger EXT.ipynb.

Untuk memuat naik skrip di ESP, di terminal anda gunakan arahan:

ampy meletakkan dataLoggerTS.py /main.py

Dan tekan butang set semula ESP. Anda akan mempunyai data menangkap ESP dan memasukkannya ke ThingSpeak.com sehingga bahagian bawah terus ditekan (tunggu LED berkelip 3 kali dan OLED dimatikan).

Langkah 11: Aplikasi ThingView

Data yang dicatat dapat dilihat secara langsung di laman ThingSpeak.com atau melalui aplikasi, misalnya, ThingsView!

ThingView adalah aplikasi yang dikembangkan oleh CINETICA, yang membolehkan anda memvisualisasikan saluran ThingSpeak anda dengan cara yang mudah, cukup masukkan ID saluran dan anda sudah bersedia untuk pergi.

Untuk saluran awam, aplikasi akan menghormati tetapan tetingkap anda: warna, skala waktu, jenis carta dan jumlah hasil. Versi semasa menyokong carta garis dan lajur, carta spline dipaparkan sebagai carta garis.

Untuk saluran peribadi, data akan ditampilkan menggunakan tetapan lalai, kerana tidak ada cara untuk membaca tetapan tetingkap peribadi dengan kunci API saja.

Aplikasi ThingView boleh dimuat turun untuk ANDROID dan IPHONE.

Langkah 12: Kesimpulannya

Seperti biasa, saya harap projek ini dapat membantu orang lain memasuki dunia elektronik yang menarik!

Untuk perincian dan kod akhir, sila lawati penyimpanan GitHub saya: IoT_TS_MQTT

Untuk lebih banyak projek, sila lawati blog saya: MJRoBot.org

Saludos dari selatan dunia!

Jumpa anda dalam arahan saya seterusnya!

Terima kasih, Marcelo