IoT lihtsustas: ESP-MicroPython-MQTT-ThingSpeak: 12 sammu

2024 Autor: John Day | [email protected]. Viimati modifitseeritud: 2024-01-30 08:48

Minu eelmises õpetuses, MicroPython ESP -s, kasutades Jupyterit, õppisime MicroPythoni ESP -seadmesse installima ja käitama. Kasutades oma arenduskeskkonnana Jupyteri sülearvutit, õppisime ka anduritelt lugema (temperatuur, niiskus ja heledus). Kasutame mitut suhtlusprotokolli ja -meetodit, analoog-, digitaalset, 1-juhtmelist ja I2C-d, viimast meie jäädvustatud piltide kuvamiseks. andmed OLED -ekraanil.

Nüüd, sellel õpetusel, kasutades MQTT -protokolli, saame kõik jäädvustatud andmed, saates need IoT -teenusesse ThingSpeak.com ja mobiilirakendusse (Thingsview), kus saame andmetega logida ja mängida.

Siin on meie projekti plokkskeem:

1. samm: BoM - materjali arve

1. NodeMCU - 8,39 USA dollarit
2. DHT22 temperatuuri ja suhtelise niiskuse andur - 9,95 USD
3. Veekindel temperatuuriandur DS18B20 - 5,95 USD
4. OLED-ekraan SSD1366- 8,99 USD (valikuline)
5. LDR (1x)
6. LEDid (1x) (valikuline)
7. Nupp (1x)
8. Takisti 4K7 oomi (2x)
9. Takisti 10K oom (1x)
10. Takisti 220 oomi (1x)

2. samm: Hw

Hw, mida me siin põhimõtteliselt kasutame, on sama, mida kasutati õpetuses: Micropython ESP -s Jupyteri kasutamine. Vaadake seda kõigi HW ühenduste kohta.

Erandiks on Servo, et meid selles projektis ei kasutata.

Eespool näete täielikku HW -d. Ühendage seadmed, nagu seal näidatud.

Samm: Micropython, REPL, Jupyter

Teie ESP -seadmesse peab olema laaditud Micropython -tõlk. Pärast laadimist peaksite oma ESP -i programmeerima, kasutades mõnda saadaolevat võimalust/IDE -d, näiteks:

• REPL
• Jupyteri märkmik
• Mu
• ESPCut (ainult Windows)
• … jne

Oma õpetuses, Micropython on ESP, kirjeldasin Jupyterit kasutades üksikasjalikult, kuidas alla laadida ja installida MicroPythoni tõlk, ESPTool ESP -seadmete haldamiseks ja kuidas kasutada Jupyteri sülearvutit arenduskeskkonnana. Kasutage julgelt seda, mis on teile mugavam.

Tavaliselt teen kõik arendused Jupyteri sülearvutis ja kui saan lõpliku koodi, kopeerin need Geany -sse ja laadin selle oma ESP -sse Ampy abil.

4. samm: andurid

Paigaldame teegid, määratleme GPIO, loome objektid, funktsioonid kõigi andurite jaoks eraldi:

A. DHT (temperatuur ja niiskus)

Paigaldame DHT raamatukogu ja loome objekti:

alates dht import DHT22

masina impordist tihvt dht22 = DHT22 (tihvt (12))

Nüüd looge DHT -anduri lugemiseks funktsioon:

def readDht ():

dht22.measure () tagastab dht22.temperature (), dht22.humidity () Testi DHT funktsiooni

print (readDht ())

Tulemuseks peaks olema näiteks:

(17.7, 43.4)

B. DS18B20 (välistemperatuur)

Paigaldame teegid ja loome objekti:

impordi onewire, ds18x20

importimise aeg # Määrake, millise tihvtiga ühendatakse 1-juhtmeline seade ==> pin 2 (D4) dat = Pin (2) # looge onewire-objekt ds = ds18x20. DS18X20 (onewire. OneWire (dat)) Otsige seadmeid bu

andurid = ds.scan ()

print ('leitud seadmed:', andurid)

Trükitud tulemus pole tegelikult oluline, vajame esimest avastatud andurit: andureid [0]. Ja nüüd saame luua andurite andmete lugemise funktsiooni:

def readDs ():

ds.convert_temp () time.sleep_ms (750) return ds.read_temp (andurid [0])

Alati on oluline testida andurit loodud funktsiooni abil

print (readDs ()) Kui saate temperatuuri väärtuse, on teie kood õige

17.5

C. LDR (heledus)

LDR kasutab meie ESP analoognõela (ESP8266 puhul on see ainult üks ja ESP32 puhul mitu).

Üksikasju leiate minu ESP32 õpetusest.

Sama mis varem:

# impordi kogu

masina importimisest ADC # Määrake objekt adc = ADC (0) ADC väärtuse lugemiseks saab kasutada lihtsat funktsiooni: adc.read (). Kuid pidage meeles, et sisemine ADC teisendab vastavate digitaalsete väärtuste pinged vahemikus 0 kuni 3,3 V, mis varieerub vahemikus 0 kuni 1023. Kui oleme huvitatud heledusest, käsitleme sensori maksimaalset väärtust Max light juhtum 900) ja minimaalne valgus, mis minu puhul on 40. Nende väärtuste olemasolul saame väärtuse "kaardistada" vahemikus 40 kuni 900 0 kuni 100% heledusest. Selleks loome uue funktsiooni

def readLdr ():

lumPerct = (adc.read ()-40)*(10/86) # teisendamine protsentides ("kaart") tagasivoor (lumPerct)

Funktsiooni peaksite testima printimise (readLDR ()) abil. Tulemuseks peaks olema täisarv o ja 100 vahel.

D. Nupp (digitaalsisend)

Siin kasutame digitaalse andurina nupuvajutust, kuid see võib olla täiturmehhanismi "kaja" (näiteks pump, mis lülitati sisse/välja).

# määrake sisendiks tihvt 13 ja aktiveerige sisemine tõmbetakistus:

button = Pin (13, Pin. IN, Pin. PULL_UP) # Funktsioon nupu oleku lugemiseks: def readBut (): return button.value ()

Saate testida funktsiooni printimise nuppu (readBut ()). Ilma vajutamiseta peaks tulemus olema "1". Nupule vajutades peaks tulemus olema "0"

5. samm: kõigi anduri andmete jäädvustamine ja lokaalne kuvamine

Nüüd, kui oleme loonud iga anduri jaoks ühe funktsiooni, loome viimase, mis loeb neid kõiki korraga:

def colectData ():

temp, hum, = readDht () extTemp = readDs () lum = readLdr () butSts = readBut () return temp, hum, extTemp, lum, butSts Kui nüüd kasutate

print (colectData ())

Tulemuseks on kogum, mis sisaldab kõiki anduritelt saadud andmeid:

(17.4, 45.2, 17.3125, 103, 1)

Valikuliselt saame neid andmeid näidata ka kohalikul ekraanil:

# impordi raamatukogu ja loo objekt i2c

masina importimisest I2C i2c = I2C (scl = tihvt (5), sda = tihvt (4)) # imporditeek ja objekti loomine oled import ssd1306 i2c = I2C (scl = tihvt (5), sda = tihvt (4)) oled = ssd1306. SSD1306_I2C (128, 64, i2c, 0x3c) # loo funktsioon: 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 () # andmete kuvamine funktsiooni kuva abil Andmed (temp, hum, extTemp, lum, butSts)

Võimalusena lisan ka LED -i, mis põleb, kui hakkame andureid lugema ja kustub pärast andmete kuvamist. See aitab kinnitada, et programm töötab, kui ESP on arvutist lahti ühendatud ja töötab automaatselt.

Niisiis, peamine ülesanne oleks:

# Põhifunktsioon kõigi andurite lugemiseks

def main (): # kuvab andmeid funktsiooniga led.on () temp, hum, extTemp, lum, butSts = colectData () displayData (temp, hum, extTemp, lum, butSts) led.off ()

Niisiis, käivitades main (), saame sensori andmed OLED -ile, nagu pildil näidatud.

6. samm: kohaliku jaama koodi käivitamine ESP käivitamisel

Meil võib olla kõik, mis siiani on välja töötatud, ühes failis, mille meie ESP käivitab.

Avame mis tahes tekstiredaktori ja lisame sellele koodi:

# impordi üldisi raamatukogusid

masina importimisest Pin -impordi aeg # määratlege tihvt 0 väljund -ledina = Pin (0, Pin. OUT) # DHT dht -impordist DHT22 dht22 = DHT22 (Pin (12)) # Funktsioon DHT lugemiseks def readDht (): dht22.measure () return dht22.temperature (), dht22.humidity () # DS18B20 import onewire, ds18x20 # Määrake, millise tihvtiga ühendatakse 1-juhtmeline seade ==> pin 2 (D4) dat = Pin (2) # Onewire loomine objekt ds = ds18x20. DS18X20 (onewire. OneWire (dat)) # seadmete otsimine siinianduritel = ds.scan () # funktsioon DS18B20 lugemiseks def readDs (): ds.convert_temp () time.sleep_ms (750) return ümmargune (ds.read_temp (andurid [0]), 1) # LDR masina impordist *(10/86) # teisendage protsentides ("kaart") tagasivoor (lumPerct) # määrake sisendiks tihvt 13 ja aktiveerige sisemine tõmbetakisti: nupp = tihvt (13, tihvt, tihvt. PULL_UP) # Funktsioon nupu oleku lugemiseks: def readBut (): return button.value () # Funktsioon kõigi andmete lugemiseks: def cole ctData (): temp, hum, = readDht () extTemp = readDs () lum = readLdr () butSts = readBut () tagastab temp, hum, extTemp, lum, butSts # impordib raamatukogu ja loob objekti i2c masina importimisest I2C i2c = I2C (scl = tihvt (5), sda = tihvt (4)) # imporditeek ja objekti loomine oled import ssd1306 i2c = I2C (scl = tihvt (5), sda = tihvt (4)) oled = ssd1306. SSD1306_I2C (128, 64, i2c, 0x3c) # loo funktsioon: 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 () # Põhifunktsioon kõigi andurite lugemiseks def main (): # kuvab andmeid funktsiooniga led.on () temp, hum, extTemp, lum, butSts = colectData () displayData (temp, hum, extTemp, lum, butSts) led.off () ""-- ----- käivitage põhifunktsioon -------- '' 'main ()

Salvestage see näiteks kui localData.py.

Selle koodi otse terminalis käivitamiseks vajate Ampyt.

Esiteks teatame terminalis Ampyle oma jadaporti:

eksport AMPY_PORT =/dev/tty. SLAB_USBtoUART

Nüüd näeme faile, mis asuvad meie ESP juurkataloogis:

ampy ls

Vastuseks saame boot.py, see on esimene süsteemis käivitatav fail.

Kasutame nüüd Ampyt, et laadida meie python Script LocalData.py nimega /main.py, nii et skript käivitatakse kohe pärast alglaadimist:

ampy pane localData.py /main /py

Kui kasutame praegu käsku amp ls, näete ESP -s 2 faili: boot.py ja main.py

ESP lähtestamine käivitab programmi localData.py automaatselt, kuvades ekraanil anduri andmed.

Ülaltoodud terminali prindiekraan näitab, mida oleme teinud.

Ülaltoodud koodi korral kuvatakse ekraani ainult üks kord, kuid me saame määratleda funktsiooni (() funktsioonis tsükli, mis näitab andmeid iga määratletud ajavahemiku (PUB_TIME_SEC) kohta ja näiteks seni, kuni vajutame nuppu:

# silmuse andmete hankimine kuni nupu vajutamiseni

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

Muutuja PUB_TIME_SEC tuleb näidiste esitamise ajaks deklareerida.

Meie koodi paremaks täiustamiseks oleks hea teatada, et läheme ringist välja, selleks määratleme 2 uut üldfunktsiooni, üks ekraani kustutamiseks ja teine LED -i teatud arvu kordi vilkumiseks.

# Selge ekraan:

def displayClear (): oled.fill (0) oled.show () # loo vilkumisfunktsioon def blinkLed (num): i jaoks vahemikus (0, num): led.on () unerežiimis (0,5) led.off () uni (0,5)

Nüüd saame oma põhifunktsiooni () ümber kirjutada:

while button.value ():

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

Lõpliku koodi saab alla laadida minu GitHubist: localData.py ja ka Jupyteri sülearvuti, mida kasutatakse täieliku koodi väljatöötamiseks: Jupyter Local Data Development.

Samm: ühendage ESP kohaliku WiFi -ga

Võrgumoodulit kasutatakse WiFi -ühenduse konfigureerimiseks. WiFi -liideseid on kaks, üks jaama jaoks (kui ESP8266 ühendub ruuteriga) ja teine pääsupunkti jaoks (teiste seadmetega ühenduse loomiseks ESP8266 -ga). Siin ühendatakse meie ESP kohaliku võrguga. Helistame raamatukokku ja määratleme oma võrgumandaadid:

impordivõrk

WiFi_SSID = "SINU SSID" WiFi_PASS = "SINU PAROL"

Allolevat funktsiooni saab kasutada ESP ühendamiseks kohaliku võrguga:

def do_connect ():

wlan = võrk. WLAN (võrk. STA_IF) wlan.aktiivne (tõene) kui mitte wlan.isconnected (): print ('võrku ühendamine …') wlan.connect (WiFi_SSID, WiFi_SSID), samas kui pole wlan.isconnected (): pass print ('võrgu konfiguratsioon:', wlan.ifconfig ())

Funktsiooni käivitamisel saate IP -aadressi:

do_connect ()

Tulemuseks on:

võrgu konfiguratsioon: ('10.0.1.2 ',' 255.255.255.0 ', '10.0.1.1', '10.0.1.1 ')

Minu puhul oli ESP IP -aadress 10.0.1.2.

8. samm: ThingSpeak

Sel hetkel õppisime, kuidas jäädvustada andmeid kõigist anduritest, kuvades need meie OLED -il. Nüüd on aeg näha, kuidas need andmed IoT platvormile ThingSpeak saata.

Alustagem!

Esiteks peab teil olema konto aadressil ThinkSpeak.com. Järgmisena järgige juhiseid kanali loomiseks ning pange tähele oma kanali ID ja kirjutamise API võti.

Eespool näete 5 välja, mida meie kanalil kasutatakse.

9. samm: MQTT -protokoll ja ThingSpeak -ühendus

MQTT on avaldamise/tellimise arhitektuur, mis on välja töötatud peamiselt ribalaiuse ja piiratud võimsusega seadmete ühendamiseks traadita võrkude kaudu. See on lihtne ja kerge protokoll, mis töötab üle TCP/IP -pesade või WebSocketide. MQTT -d WebSocketsi kaudu saab kaitsta SSL -iga. Avaldamise/tellimise arhitektuur võimaldab sõnumeid kliendiseadmetesse edastada, ilma et seade peaks serverit pidevalt küsitlema.

MQTT maakler on keskseks suhtluspunktiks ning see vastutab kõigi sõnumite saatmise eest saatjate ja õigustatud vastuvõtjate vahel. Klient on mis tahes seade, mis loob maakleriga ühenduse ja saab teabele juurdepääsemiseks teemasid avaldada või tellida. Teema sisaldab maakleri marsruutimisteavet. Iga klient, kes soovib sõnumeid saata, avaldab need teatud teemal ja iga klient, kes soovib sõnumeid saada, tellib teatud teema. Maakler edastab kõik vastava teemaga sõnumid vastavatele klientidele.

ThingSpeak ™ -l on MQTT maakler aadressil mqtt.thingspeak.com ja port 1883. ThingSpeak maakler toetab nii MQTT avaldamist kui ka MQTT tellimist.

Meie puhul kasutame järgmist: MQTT Publish

Joonis kirjeldab teema ülesehitust. Avaldamiseks on vajalik Write API võti. Maakler kinnitab CONNACKiga õige CONNECT -taotluse.

MQTT-protokolli toetatakse Micropythoni binaarfailide sisseehitatud raamatukogus-seda protokolli saab kasutada andmete saatmiseks teie ESP8266-lt WIFI kaudu tasuta pilveandmebaasi.

Kasutame umqtt.simple raamatukogu:

alates umqtt.simple import MQTTClient

Ja teades meie SERVER ID -d, on võimalik luua meie MQTT kliendiobjekt:

SERVER = "mqtt.thingspeak.com"

klient = MQTTClient ("umqtt_client", SERVER)

Nüüd, kui teil on ThingSpeaki volikirjad käepärast:

CHANNEL_ID = "TEIE KANALI ID"

WRITE_API_KEY = "SINU VÕTME SIIN"

Loome oma MQTT "teema":

topic = "channels/" + CHANNEL_ID + "/publisize/" + WRITE_API_KEY

Saadame oma andmed ThingSpeak IoT -teenusesse, kasutades loodud funktsiooni, ja seostame selle vastuse konkreetsetele andmemuutujatele:

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

Nende muutujate värskendamisega saame luua oma "MQTT kasulik koormus":

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

Ja see ongi kõik! Oleme valmis ThinsSpeakile andmeid saatma, kasutades lihtsalt alltoodud kolme koodirida:

client.connect ()

client.publish (teema, kasulik koormus) client.disconnect ()

Nüüd, kui lähete oma kanali lehele (nagu minu eespool), näete, et igal viiel väljal on teie anduritega seotud andmed.

Samm 10: Anduri andmete logija

Nüüd, kui me teame, et vaid mõne koodiridaga on võimalik andmeid IoT -teenusesse üles laadida, loome silmusefunktsiooni, et seda automaatselt korrapärase ajavahemiku jooksul teha (sarnaselt sellega, mida oleme teinud kohalike andmetega ).

Kasutades sama muutujat (PUB_TIME_SEC), mis oli varem deklareeritud, oleks lihtne põhifunktsioon andmete pidevaks jäädvustamiseks, nende logimine meie kanalile:

kuigi tõsi:

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

Pange tähele, et ainult "kasulikku koormust" tuleb värskendada, kui "teema" on seotud meie kanali mandaadiga ja see ei muutu.

Otsides oma ThingSpeak kanalilehte, näete, et andmed laaditakse pidevalt igale väljale. Saate katta LDR -i, panna käe temperatuuri/hum -i anduritele, vajutada nuppu jne ja vaadata, kuidas kanal automaatselt need andmed "logib" edaspidiseks analüüsiks.

Tavaliselt peaksime andmete logimise jaoks proovima kasutada võimalikult vähe energiat, nii et me ei kasutaks LED -i ega ekraani kohapeal. Samuti on see tavaline ESP -seadmete puhul, pange need "sügavale unele", kus mikroprotsessor on oma minimaalse energiaga, kuni on aeg andmeid koguda ja need IoT -platvormile saata.

Kuid kui idee siin õpib, lisame ka ekraani ja LED -i nagu varem. Seda tehes on meie "logija" funktsioon järgmine:

while button.value ():

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

Täieliku microPythoni skripti leiate siit: dataLoggerTS_EXT.py ja arenduseks kasutatud Jupyteri märkmiku leiate ka siit: IoT ThingSpeak Data Logger EXT.ipynb.

Skripti ESP -sse üleslaadimiseks kasutage oma terminalis käsku:

ampy pane dataLoggerTS.py /main.py

Ja vajutage ESP - lähtestamise nuppu. ESP salvestab andmed ja logib need saidile ThingSpeak.com, kuni põhja hoitakse all (oodake, kuni LED vilgub 3 korda ja OLED kustub).

Samm: rakendus ThingView

Logitud andmeid saab vaadata otse saidil ThingSpeak.com või APP kaudu, näiteks ThingsView!

ThingView on CINETICA välja töötatud APP, mis võimaldab teil oma ThingSpeak kanaleid hõlpsalt visualiseerida, lihtsalt sisestage kanali ID ja olete valmis minema.

Avalike kanalite puhul võtab rakendus arvesse teie akende seadeid: värvi, ajakava, diagrammi tüüpi ja tulemuste arvu. Praegune versioon toetab joone- ja tulpdiagramme, spline -diagramme kuvatakse joonediagrammidena.

Erakanalite puhul kuvatakse andmed vaikeseadeid kasutades, kuna ainult API võtmega pole võimalik privaatsete akende seadeid lugeda.

Rakenduse ThingView saab alla laadida Androidi ja IPHONE jaoks.

12. samm: järeldus

Nagu alati, loodan, et see projekt aitab teistel leida tee põnevasse elektroonikamaailma!

Üksikasjade ja lõpliku koodi saamiseks külastage minu GitHubi hoidlat: IoT_TS_MQTT

Rohkemate projektide jaoks külastage palun minu ajaveebi: MJRoBot.org

Tervitused maailma lõunaosast!

Kohtumiseni minu järgmises juhendis!

Aitäh, Marcelo