Az IoT megkönnyítette: ESP-MicroPython-MQTT-Thing Beszéd: 12 lépés

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:41

Korábbi oktatóanyagomban, a MicroPython -on az ESP -n a Jupyter használatával, megtanultuk, hogyan kell telepíteni és futtatni a MicroPython -t egy ESP -eszközön. A Jupyter Notebook fejlesztői környezetünkként azt is megtanultuk, hogyan kell olvasni az érzékelőkről (hőmérséklet, páratartalom és fényesség). Számos kommunikációs protokollt és módszert használunk, analóg, digitális, 1 vezetékes és I2C, ez utóbbi a rögzített képek megjelenítéséhez adatok az OLED kijelzőn.

Most ezen az oktatóanyagon, amely egy MQTT protokollt használ, megkapjuk az összes rögzített adatot, elküldve azokat egy IoT -szolgáltatáshoz, a ThingSpeak.com -hoz és egy mobilalkalmazáshoz (Thingsview), ahol naplózhatunk és játszhatunk az adatokkal.

Íme a projektünk tömbvázlata:

1. lépés: BoM - Bill of Material

1. NodeMCU - 8,39 USD
2. DHT22 hőmérséklet- és relatív páratartalom -érzékelő - 9,95 USD
3. DS18B20 vízálló hőmérséklet -érzékelő - 5,95 USD
4. OLED kijelző SSD1366- 8,99 USD (opcionális)
5. LDR (1x)
6. LED -ek (1x) (opcionális)
7. Nyomógomb (1x)
8. Ellenállás 4K7 ohm (2x)
9. Ellenállás 10K ohm (1x)
10. Ellenállás 220 ohm (1x)

2. lépés: A Hw

Az itt használt Hw alapvetően ugyanaz, mint az oktatóanyagban: Micropython az ESP -n a Jupyter használatával. Lásd az összes HW csatlakozást.

Kivétel a Servo, hogy ebben a projektben nem fogunk használni.

Fent a teljes HW látható. Csatlakoztassa az eszközöket az ott látható módon.

3. lépés: Micropython, REPL, Jupyter

Az ESP eszközön telepítve kell lennie a Micropython tolmácsnak. A betöltés után programoznia kell az ESP -t a rendelkezésre álló módok/IDE -k bármelyikével, például:

• REPL
• Jupyter notebook
• Mu
• ESPCut (csak Windows)
• … Stb

A bemutatómon, a Micropython on ESP -n a Jupyter használatával részletesen leírtam, hogyan kell letölteni és telepíteni a MicroPython tolmácsot, az ESPTool -t az ESP -eszközök kezeléséhez, és hogyan használhatom a Jupyter Notebookot fejlesztői környezetként. Nyugodtan használja azt, ami kényelmesebb az Ön számára.

Általában minden fejlesztést a Jupyter Notebookon végzek, és miután megkapom a végső kódot, átmásolom őket a Geany -ba, és betöltöm az ESP -re az Ampy segítségével.

4. lépés: Érzékelők

Telepítsük a könyvtárakat, határozzuk meg a GPIO -t, hozzunk létre objektumokat, funkciókat minden érzékelőhöz egyenként:

A. DHT (hőmérséklet és páratartalom)

Telepítsük a DHT könyvtárat, és hozzunk létre egy objektumot:

a dht import DHT22 -ből

a gép importálásából Dht22 pin = DHT22 (Pin (12))

Most hozzon létre egy funkciót a DHT érzékelő olvasásához:

def readDht ():

dht22.measure () visszatér dht22.temperature (), dht22.humidity () Tesztelje a DHT funkciót

nyomtatás (readDht ())

Az eredménynek például a következőnek kell lennie:

(17.7, 43.4)

B. DS18B20 (külső hőmérséklet)

Telepítsük a könyvtárakat és hozzunk létre egy objektumot:

onewire importálása, ds18x20

importálási idő # Határozza meg, hogy az 1 vezetékes eszközt melyik tűhöz kell csatlakoztatni ==> pin 2 (D4) dat = Pin (2) # hozza létre a onewire objektumot ds = ds18x20. DS18X20 (onewire. OneWire (dat)) Eszközök keresése a bu

érzékelők = ds.scan ()

print ('talált eszközök:', érzékelők)

A nyomtatott eredmény nem igazán fontos, szükségünk lesz az első észlelt érzékelőre: érzékelőkre [0]. És most létrehozhatunk egy funkciót az érzékelő adatok olvasására:

def readDs ():

ds.convert_temp () time.sleep_ms (750) return ds.read_temp (érzékelők [0])

Mindig fontos az érzékelő tesztelése a létrehozott funkció használatával

nyomtatás (readDs ()) Ha megkapja a hőmérséklet értékét, akkor a kód helyes

17.5

C. LDR (fényesség)

Az LDR az ESP analóg csapját fogja használni (az ESP8266 esetében csak egy, az ESP32 esetén több).

Részletekért tekintse meg az ESP32 bemutatómat.

Ugyanaz, mint korábban:

# import könyvtár

gép importálásából ADC # Objektum definiálása adc = ADC (0) Egy egyszerű funkció: az adc.read () használható az ADC érték olvasásához. De ne feledje, hogy a belső ADC átalakítja a 0 és 3,3 V közötti feszültségeket a megfelelő digitális értékekben, 0 és 1023 között. Ha érdekel a "Fényerő", akkor a Max fényt tekintjük az érzékelő által rögzített maximális értéknek (az én 900. eset) és a minimális fény, ami esetemben 40. Ezen értékek birtokában 40 és 900 között „leképezhetjük” az értéket a fényesség 0–100% -ában. Ehhez új funkciót hozunk létre

def readLdr ():

lumPerct = (adc.read ()-40)*(10/86) # százalékos konvertálás ("map") visszatérési kör (lumPerct)

A funkciót a print (readLDR ()) használatával kell tesztelnie. Az eredménynek o és 100 közötti egész számnak kell lennie.

D. Nyomógomb (digitális bemenet)

Itt egy nyomógombot használunk digitális érzékelőként, de ez lehet egy működtető "visszhangja" (például egy szivattyú, amelyet BE/KI kapcsoltak).

# határozza meg a 13. tűt bemenetként, és aktiválja a belső felhúzó ellenállást:

gomb = Pin (13, Pin. IN, Pin. PULL_UP) # Funkció a gomb állapotának olvasására: def readBut (): return button.value ()

Tesztelheti a nyomtatás funkciót olvasó gombot (readBut ()). A gomb megnyomása nélkül az eredménynek "1" -nek kell lennie. A gomb megnyomásával az eredménynek "0" -nak kell lennie

5. lépés: Az összes érzékelőadat rögzítése és helyi megjelenítése

Most, hogy minden érzékelőhöz létrehoztunk egy funkciót, hozzuk létre az utolsót, amely egyszerre olvassa el mindegyiket:

def colectData ():

temp, hum, = readDht () extTemp = readDs () lum = readLdr () butSts = readBut () visszatérési hőmérséklet, hum, extTemp, lum, butSts Most ha használ

nyomtatás (colectData ())

Ennek eredményeként egy sor lesz, amely tartalmazza az érzékelők összes rögzített adatát:

(17.4, 45.2, 17.3125, 103, 1)

Opcionálisan megjeleníthetjük ezeket az adatokat egy helyi kijelzőn:

# importálja a könyvtárat és hozza létre az i2c objektumot

a gép importálásából I2C i2c = I2C (scl = Pin (5), sda = Pin (4)) # import könyvtár és objektum létrehozása oled import ssd1306 i2c = I2C (scl = Pin (5), sda = Pin (4)) oled = ssd1306. SSD1306_I2C (128, 64, i2c, 0x3c) # függvény létrehozása: 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 () # adatok megjelenítése a display funkció használatával Adatok (temp, hum, extTemp, lum, butSts)

Opcióként a LED -et is bekapcsolom, amikor elkezdjük olvasni az érzékelőket, majd kikapcsol, miután az adatok megjelennek. Ez segít megerősíteni, hogy a program működik -e, amikor az ESP -t leválasztjuk a számítógépről, és automatikusan fut.

Tehát a fő funkció a következő lenne:

# Fő funkció az összes érzékelő leolvasásához

def main (): # megjeleníti az adatokat egy led funkcióval.on () temp, hum, extTemp, lum, butSts = colectData () displayData (temp, hum, extTemp, lum, butSts) led.off ()

Tehát a main () végrehajtásával megkapjuk az érzékelő adatait az OLED -en, a képen látható módon.

6. lépés: A helyi állomás kód futtatása az ESP indításakor

Mindent, amit eddig kifejlesztettünk, egyetlen fájlban rendelkezhetünk, amelyet az ESP végrehajt.

Nyissunk meg bármilyen szövegszerkesztőt, és rajta minden kódot:

# általános könyvtárak importálása

gép importálásából Pin import time # definiálja a 0 pin -t kimeneti ledként = Pin (0, Pin. OUT) # DHT from dht import DHT22 dht22 = DHT22 (Pin (12)) # DHT olvasási funkció def readDht (): dht22.measure () return dht22.temperature (), dht22.humidity () # DS18B20 import onewire, ds18x20 # Határozza meg, hogy az 1 vezetékes eszközt melyik tűhöz kell csatlakoztatni ==> pin 2 (D4) dat = Pin (2) # Onewire létrehozása objektum ds = ds18x20. forduló (ds.read_temp (érzékelők [0])), 1) # LDR a gépimportálásból ADC # Objektum definiálása adc = ADC (0) #funkció a fényesség leolvasásához def readLdr (): lumPerct = (adc.read ()-40) *(10/86) # százalékos konvertálás ("térkép") visszatérési forduló (lumPerct) # a 13. tüskét határozza meg bemenetként, és aktiválja a belső felhúzó ellenállást: gomb = Tű (13, Pin. IN, Pin. PULL_UP) # Funkció olvasni a gomb állapotát: def readBut (): return button.value () # Funkció az összes adat olvasásához: def cole ctData (): temp, hum, = readDht () extTemp = readDs () lum = readLdr () butSts = readBut () visszatérési hőmérséklet, hum, extTemp, lum, butSts # import könyvtár és i2c objektum létrehozása a gépimportálásból I2C i2c = I2C (scl = Pin (5), sda = Pin (4)) # import könyvtár és objektum létrehozása oled import ssd1306 i2c = I2C (scl = Pin (5), sda = Pin (4)) oled = ssd1306. SSD1306_I2C (128, 64, i2c, 0x3c) # függvény létrehozása: 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 () # Fő funkció az összes érzékelő olvasásához def main (): # megjeleníti az adatokat egy led funkcióval. on () temp, hum, extTemp, lum, butSts = colectData () displayData (temp, hum, extTemp, lum, butSts) led.off () ""-- ----- futtassa a fő funkciót -------- '' 'main ()

Mentse el, például localData.py néven.

Ha ezt a kódot közvetlenül a terminálon szeretné futtatni, szüksége lesz az Ampy -re.

Először is, a terminálon tájékoztassuk Ampyt a soros portunkról:

export AMPY_PORT =/dev/tty. SLAB_USBtoUART

Most láthatjuk az ESP gyökérkönyvtárában található fájlokat:

ampy ls

Válaszként a boot.py fájlt kapjuk, ez az első fájl, amely a rendszerben fut.

Most használjuk az Ampy -t a python Script LocalData.py betöltésére /main.py néven, így a szkript közvetlenül a rendszerindítás után fog futni:

ampy put localData.py /main /py

Ha most az amp ls parancsot használjuk, akkor 2 fájlt fog látni az ESP -n belül: boot.py és main.py

Ha visszaállítja az ESP -t, a localData.py program automatikusan elindul, és megjeleníti az érzékelő adatait.

A fenti terminál nyomtatási képernyő azt mutatja, hogy mit tettünk.

A fenti kóddal a kijelző csak egyszer jelenik meg, de meghatározhatunk egy hurkot a main () függvényen, amely minden meghatározott időintervallum (PUB_TIME_SEC) adatait jeleníti meg, és például amíg nem nyomjuk meg a gombot:

# hurok adatok lekérése, amíg a gombot le nem nyomja

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

A PUB_TIME_SEC változót deklarálni kell a minták kívánt időpontjáig.

A kód további fokozása érdekében jó lenne tájékoztatni arról, hogy kilépünk a ciklusból, ehhez két új általános funkciót definiálunk, az egyiket a kijelző törléséhez, a másikat, hogy bizonyos számú alkalommal villogjon a LED.

# Tiszta kijelző:

def displayClear (): oled.fill (0) oled.show () # villogási funkciót hoz létre) alvás (0,5)

Tehát most újraírhatjuk a fő () függvényünket:

while 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 ()

A végső kód letölthető a GitHub -ból: localData.py, valamint a Jupyter Notebook, amelyet a teljes kód kifejlesztéséhez használtak: Jupyter Local Data Development.

7. lépés: Az ESP csatlakoztatása a helyi WiFi -hez

A hálózati modul a WiFi kapcsolat konfigurálására szolgál. Két WiFi interfész van, az egyik az állomás számára (amikor az ESP8266 útválasztóhoz csatlakozik), a másik pedig a hozzáférési ponthoz (más eszközökhöz, amelyek az ESP8266 -hoz csatlakoznak). Itt az ESP a helyi hálózathoz kapcsolódik. Hívjuk fel a könyvtárat, és határozzuk meg a hálózati hitelesítő adatainkat:

importáló hálózat

WiFi_SSID = "AZ SSID" WiFi_PASS = "A JELSZÓ"

Az alábbi funkcióval csatlakoztathatja az ESP -t a helyi hálózathoz:

def do_connect ():

wlan = network. WLAN (network. STA_IF) wlan.active (True) ha nem wlan.isconnected (): print ('csatlakozás a hálózathoz …') wlan.connect (WiFi_SSID, WiFi_SSID), míg nem wlan.isconnected (): pass print ('hálózati konfiguráció:', wlan.ifconfig ())

A funkció futtatása eredményeként megkaphatja az IP -címet:

do_connect ()

Az eredmény a következő lesz:

hálózati konfiguráció: ('10.0.1.2 ',' 255.255.255.0 ', '10.0.1.1', '10.0.1.1 ')

Esetemben a 10.0.1.2 volt az ESP IP -címe.

8. lépés: A ThingSpeak

Ezen a ponton megtanultuk, hogyan lehet adatokat rögzíteni minden érzékelőből, és megjeleníteni azokat OLED -ünkön. Itt az ideje, hogy lássuk, hogyan küldhetjük el ezeket az adatokat egy IoT platformra, a ThingSpeak -re.

Kezdjük!

Először is rendelkeznie kell fiókkal a ThinkSpeak.com webhelyen. Ezután kövesse az utasításokat a csatorna létrehozásához, és vegye figyelembe a csatornaazonosítót és az Write API -kulcsot.

Fent látható az 5 mező, amelyet a csatornán használunk.

9. lépés: MQTT protokoll és ThingSpeak kapcsolat

Az MQTT egy közzétételi/előfizetési architektúra, amelyet elsősorban a sávszélesség és a korlátozott teljesítményű eszközök vezeték nélküli hálózatokon keresztül történő összekapcsolására fejlesztettek ki. Ez egy egyszerű és könnyű protokoll, amely TCP/IP vagy WebSockets aljzatokon fut. Az MQTT a WebSockets -en keresztül SSL -sel védhető. A közzététel/előfizetés architektúra lehetővé teszi az üzenetek kliens eszközökre történő továbbítását anélkül, hogy az eszköznek folyamatosan le kellene kérdeznie a szervert.

Az MQTT bróker a kommunikáció központi pontja, és feladata az összes üzenet elküldése a feladók és a jogosultak között. Az ügyfél minden olyan eszköz, amely csatlakozik a brókerhez, és közzétehet vagy feliratkozhat témákra az információk eléréséhez. Egy témakör tartalmazza a közvetítő útválasztási információit. Minden ügyfél, amely üzeneteket szeretne küldeni, közzéteszi azokat egy bizonyos témában, és minden ügyfél, amely üzeneteket szeretne kapni, feliratkozik egy bizonyos témára. A bróker minden üzenetet a megfelelő témával eljuttat a megfelelő ügyfelekhez.

A ThingSpeak ™ rendelkezik MQTT brókerrel az mqtt.thingspeak.com és az 1883. URL címen. A ThingSpeak bróker támogatja mind az MQTT közzétételt, mind az MQTT előfizetést.

Esetünkben a következőket használjuk: MQTT Publish

Az ábra a téma felépítését írja le. A Write API -kulcs szükséges a közzétételhez. A bróker nyugtázza a helyes CONNECTkérést a CONNACK segítségével.

Az MQTT protokollt a Micropython bináris fájlok egy beépített könyvtára támogatja-ez a protokoll használható adatok küldésére az ESP8266-ból, WIFI-n keresztül, egy ingyenes felhőalapú adatbázisba.

Használjuk az umqtt.simple könyvtárat:

from umqtt.simple import MQTTClient

A SZERVER azonosítónk ismeretében pedig létre lehet hozni MQTT kliens objektumunkat:

SZERVER = "mqtt.thingspeak.com"

kliens = MQTTClient ("umqtt_client", SERVER)

Most, ha kéznél vannak a ThingSpeak hitelesítő adatai:

CHANNEL_ID = "AZ Ön CSATORNA -azonosítója"

WRITE_API_KEY = "A KULCSA ITT"

Hozzuk létre az MQTT "témát":

topic = "csatornák/" + CHANNEL_ID + "/közzététel/" + WRITE_API_KEY

A létrehozott függvény használatával küldjük el adatainkat a ThingSpeak IoT Service szolgáltatásba, és társítsuk a válaszukat bizonyos adatváltozókhoz:

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

Ezeknek a változóknak a frissítésével létrehozhatjuk az "MQTT hasznos terhelésünket":

hasznos terhelés = "field1 ="+str (temp)+"& field2 ="+str (hum)+"& field3 ="+str (extTemp)+"& field4 ="+str (lum)+"& field5 ="+str (butSts)

És ez az! Készen állunk arra, hogy adatokat küldjünk a ThinsSpeak -nek, egyszerűen az alábbi 3 kódsor használatával:

client.connect ()

client.publish (téma, hasznos terhelés) client.disconnect ()

Most, ha felmegy a csatornaoldalára (mint az enyém fent), látni fogja, hogy az 5 mező mindegyike tartalmaz adatokat az érzékelőiről.

10. lépés: Érzékelő adatgyűjtő

Most, hogy tudjuk, hogy csak néhány sornyi kóddal lehet adatokat feltölteni egy IoT -szolgáltatásba, hozzunk létre egy ciklusfüggvényt, amely automatikusan elvégzi azt rendszeres időközönként (hasonlóan a helyi adatokhoz ).

Ugyanazt a változót (PUB_TIME_SEC) használva, amelyet korábban deklaráltunk, egyszerű fő funkció az adatok folyamatos rögzítésére, naplózására csatornánkon:

míg igaz:

temp, hum, extTemp, lum, butSts = colectData () hasznos terhelés = "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)

Ne feledje, hogy csak a "hasznos terhelést" kell frissíteni, ha a "téma" kapcsolódik a csatornánk hitelesítési adataihoz, és nem változik.

A ThingSpeak csatornaoldalát keresve észre fogja venni, hogy az adatok folyamatosan töltődnek be minden mezőbe. Lefedheti az LDR -t, ráteszi a kezét a hőmérséklet/hum érzékelőkre, megnyomhatja a gombot stb., És megnézheti, hogy a csatorna automatikusan "naplózza" ezeket az adatokat a későbbi elemzéshez.

Általában az adatnaplózáshoz a lehető legkevesebb energiát kell használnunk, ezért nem használjuk a LED -et vagy a kijelzőt helyben. Ezenkívül gyakori az ESP -eszközök esetében, helyezze őket "mély alvásba", ahol a mikroprocesszor a minimális energiaállapotban lesz, amíg el nem érkezik az adatok rögzítésének és az IoT platformra küldésének ideje.

De ha már itt az ötlet tanul, vegyük bele a kijelzőt és a LED -et is, mint korábban. Ennek során a "naplózó" funkciónk a következő lesz:

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 () payload = "field1 ="+str (temp)+"& field2 ="+str (hum)+"& field3 ="+str (extTemp)+"& field4 ="+str (lum)+"& field5 ="+str (butSts) kliens.connect () client.publish (topic, payload) client.disconnect () time.sleep (PUB_TIME_SEC) villog LED (3) displayClear ()

A teljes microPython szkript itt található: dataLoggerTS_EXT.py és a fejlesztéshez használt Jupyter notebook itt is megtalálható: IoT ThingSpeak Data Logger EXT.ipynb.

A szkript ESP -re történő feltöltéséhez használja a terminált a következő paranccsal:

ampy put dataLoggerTS.py /main.py

És nyomja meg az ESP - reset gombot. Az ESP rögzíti az adatokat, és naplózza őket a ThingSpeak.com webhelyen, amíg az alját nyomva tartja (várja meg, amíg a LED háromszor felvillan, és az OLED kikapcsol).

11. lépés: A ThingView alkalmazás

A naplózott adatok megtekinthetők közvetlenül a ThingSpeak.com webhelyen vagy egy APP -n keresztül, például a ThingsView!

A ThingView a CINETICA által kifejlesztett APP, amely lehetővé teszi a ThingSpeak csatornák egyszerű megjelenítését, csak írja be a csatornaazonosítót, és készen áll az indulásra.

Nyilvános csatornák esetén az alkalmazás figyelembe veszi az ablakbeállításokat: szín, időskála, diagramtípus és az eredmények száma. A jelenlegi verzió támogatja a vonal- és oszlopdiagramokat, a spline -diagramok vonaldiagramként jelennek meg.

Privát csatornák esetén az adatok az alapértelmezett beállításokkal jelennek meg, mivel a privát ablakok beállításait csak az API kulccsal lehet kiolvasni.

A ThingView APP letölthető androidra és IPHONE -ra.

12. lépés: Következtetés

Mint mindig, remélem, hogy ez a projekt segíthet másoknak is eligazodni az elektronika izgalmas világában!

A részletekért és a végső kódért keresse fel GitHub letéteményemet: IoT_TS_MQTT

További projektekért látogasson el a blogomra: MJRoBot.org

Üdvözlet a világ déli részéről!

Találkozunk a következő tanításomban!

Köszönöm, Marcelo