Snadné IoT: ESP-MicroPython-MQTT-ThingSpeak: 12 kroků

2024 Autor: John Day | [email protected]. Naposledy změněno: 2024-01-30 08:21

V mém předchozím tutoriálu, MicroPython na ESP pomocí Jupyter, jsme se naučili, jak nainstalovat a spustit MicroPython na zařízení ESP. Pomocí vývojového prostředí Jupyter Notebook jsme se také naučili číst ze senzorů (teplota, vlhkost a svítivost). Používáme několik komunikačních protokolů a metod, Analog, Digital, 1-Wire a I2C, tento poslední k zobrazení našich zachycených data na OLED displeji.

Nyní v tomto kurzu pomocí protokolu MQTT získáme všechna zachycená data a odešleme je do služby IoT, ThingSpeak.com a do mobilní aplikace (Thingsview), kde se můžeme přihlásit a hrát si s daty.

Zde je blokové schéma našeho projektu:

Krok 1: BoM - kusovník

1. NodeMCU - 8,39 USD
2. Snímač teploty a relativní vlhkosti DHT22 - 9,95 USD
3. Vodotěsný teplotní senzor DS18B20 - 5,95 USD
4. OLED Display SSD1366- 8,99 USD (volitelně)
5. LDR (1x)
6. LED diody (1x) (volitelně)
7. Tlačítko (1x)
8. Rezistor 4K7 ohm (2x)
9. Rezistor 10K ohm (1x)
10. Rezistor 220 ohm (1x)

Krok 2: Hw

Hw, který zde v zásadě použijeme, je stejný jako v tutoriálu: Micropython na ESP pomocí Jupyteru. Podívejte se na to pro všechna připojení HW.

Výjimkou je Servo, které v tomto projektu nebudeme používat.

Nahoře vidíte plný HW. Připojte zařízení podle obrázku.

Krok 3: Micropython, REPL, Jupyter

Na svém zařízení ESP musíte mít načtený interpret Micropython. Po načtení byste měli naprogramovat svůj ESP pomocí některého z dostupných způsobů/IDE, které jsou k dispozici, například:

• ODPOVĚĎ
• Notebook Jupyter
• Mu
• ESPCut (pouze Windows)
• … atd

Na svém tutoriálu, Micropython na ESP Pomocí Jupyteru jsem podrobně popsal, jak stáhnout a nainstalovat interpret MicroPython, ESPTool pro správu zařízení ESP a jak používat Jupyter Notebook jako vývojové prostředí. Neváhejte použít to, co je pro vás pohodlnější.

Veškerý vývoj obvykle provádím na Jupyter Notebook a jakmile získám konečný kód, zkopíruji je do Geany a načtu ho na svůj ESP pomocí Ampy.

Krok 4: Senzory

Pojďme nainstalovat knihovny, definovat GPIO, vytvářet objekty, funkce pro všechny senzory jednotlivě:

A. DHT (teplota a vlhkost)

Pojďme nainstalovat knihovnu DHT a vytvořit objekt:

z dht importu DHT22

z importu stroje Pin dht22 = DHT22 (Pin (12))

Nyní vytvořte funkci pro čtení snímače DHT:

def readDht ():

dht22.measure () návrat dht22.temperature (), dht22.humidity () Otestujte funkci DHT

tisk (readDht ())

Výsledkem by měl být například:

(17.7, 43.4)

B. DS18B20 (externí teplota)

Pojďme nainstalovat knihovny a vytvořit objekt:

import onewire, ds18x20

čas importu # Definujte, který pin bude připojeno 1vodičové zařízení ==> pin 2 (D4) dat = Pin (2) # vytvořte objekt onewire ds = ds18x20. DS18X20 (onewire. OneWire (dat)) Vyhledejte zařízení na bu

senzory = ds.scan ()

tisk ('nalezená zařízení:', senzory)

Vytištěný výsledek není ve skutečnosti důležitý, budeme potřebovat první detekovaný senzor: senzory [0]. A nyní můžeme vytvořit funkci pro čtení dat ze senzorů:

def readDs ():

ds.convert_temp () time.sleep_ms (750) návrat ds.read_temp (senzory [0])

Vždy je důležité senzor otestovat pomocí vytvořené funkce

tisk (readDs ()) Pokud získáte hodnotu teploty, je váš kód správný

17.5

C. LDR (svítivost)

LDR bude používat analogový pin našeho ESP (je to pouze jeden v případě ESP8266 a několik pro ESP32).

Podrobnosti najdete v mém tutoriálu k ESP32.

Stejné jako dříve:

# importovat knihovnu

ze stroje importovat ADC # Definovat objekt adc = ADC (0) Ke čtení hodnoty ADC lze použít jednoduchou funkci: adc.read (). Pamatujte však, že interní ADC převede napětí mezi 0 a 3,3 V na odpovídající digitální hodnoty, pohybující se od 0 do 1023. Jakmile nás zajímá „svítivost“, budeme považovat maximální světlo za maximální zachycenou hodnotu ze snímače (v mém případ 900) a minimální světlo, které je v mém případě 40. S těmito hodnotami můžeme „namapovat“hodnotu od 40 do 900 v 0 až 100% svítivosti. Za tímto účelem vytvoříme novou funkci

def readLdr ():

lumPerct = (adc.read ()-40)*(10/86) # převést v procentech („mapa“) zpětné kolo (lumPerct)

Funkci byste měli vyzkoušet pomocí print (readLDR ()). Výsledkem by mělo být celé číslo mezi o a 100.

D. Tlačítko (digitální vstup)

Zde používáme Push-Button jako digitální senzor, ale může to být „ozvěna“aktuátoru (například čerpadlo, které bylo zapnuto/vypnuto).

# definujte pin 13 jako vstup a aktivujte interní Pull-up odpor:

button = Pin (13, Pin. IN, Pin. PULL_UP) # Funkce pro čtení stavu tlačítka: def readBut (): tlačítko return.value ()

Tlačítko můžete vyzkoušet při čtení funkce print (readBut ()). Bez stisknutí výsledku by měl být „1“. Po stisknutí tlačítka by měl být výsledek „0“

Krok 5: Zachycení a lokální zobrazení všech dat senzoru

Nyní, když jsme vytvořili jednu funkci pro každý senzor, vytvořme poslední, který bude číst všechny současně:

def colectData ():

temp, hum, = readDht () extTemp = readDs () lum = readLdr () butSts = readBut () návratová teplota, brum, extTemp, lum, butSts Nyní, pokud používáte

tisk (colectData ())

Výsledkem bude n -tice, která obsahuje všechna zachycená data ze senzorů:

(17.4, 45.2, 17.3125, 103, 1)

Můžeme také volitelně zobrazit tato data na místním displeji:

# importujte knihovnu a vytvořte objekt i2c

z importu stroje I2C i2c = I2C (scl = Pin (5), sda = Pin (4)) # importovat knihovnu a vytvořit objekt oled import ssd1306 i2c = I2C (scl = Pin (5), sda = Pin (4)) oled = ssd1306. SSD1306_I2C (128, 64, i2c, 0x3c) # vytvořit funkci: 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 ("Tlačítko:" + str (butSts), 0, 57) oled.show () # zobrazení dat pomocí funkce displayData (temp, hum, extTemp, lum, butSts)

Volitelně také zahrnu LED diodu, která bude svítit, když začneme číst senzory, zhasne po zobrazení těchto dat. Pomůže to potvrdit, že program funguje, když máme ESP odpojené od počítače a běží automaticky.

„Hlavní funkce by tedy byla:

# Hlavní funkce pro čtení všech senzorů

def main (): # zobrazení dat s funkcí led.on () temp, hum, extTemp, lum, butSts = colectData () displayData (temp, hum, extTemp, lum, butSts) led.off ()

Po provedení příkazu main () získáme data senzorů zobrazená na OLED, jak je znázorněno na obrázku.

Krok 6: Spuštění kódu místní stanice při spuštění ESP

Můžeme mít vše, co bylo dosud vyvinuto na jediném souboru, které má provést náš ESP.

Otevřeme libovolný textový editor a v něm celý kód:

# importovat obecné knihovny

z importu stroje Čas importu PINu # definujte pin 0 jako výstupní LED = Pin (0, Pin. OUT) # DHT z importu dht DHT22 dht22 = DHT22 (Pin (12)) # Funkce ke čtení DHT def readDht (): dht22.measure () return dht22.temperature (), dht22.humidity () # DS18B20 import onewire, ds18x20 # Define which pin the 1-wire device will be connected ==> pin 2 (D4) dat = Pin (2) # Create the onewire objekt ds = ds18x20. DS18X20 (onewire. OneWire (dat)) # skenování zařízení na sběrnici senzory = ds.scan () # funkce pro čtení DS18B20 def readDs (): ds.convert_temp () time.sleep_ms (750) návrat kolo (ds.read_temp (senzory [0]), 1) # LDR z importu stroje ADC # Definujte objekt adc = ADC (0) #funkce pro čtení svítivosti def readLdr (): lumPerct = (adc.read ()-40) *(10/86) # převést v procentech („mapa“) zpětné kolo (lumPerct) # definovat pin 13 jako vstup a aktivovat interní Pull-up odpor: tlačítko = Pin (13, Pin. IN, Pin. PULL_UP) # Funkce pro čtení stavu tlačítka: def readBut (): návratové tlačítko.value () # Funkce pro čtení všech dat: def cole ctData (): temp, hum, = readDht () extTemp = readDs () lum = readLdr () butSts = readBut () návratová teplota, hum, extTemp, lum, butSts # importní knihovna a vytvoření objektu i2c z importu stroje I2C i2c = I2C (scl = Pin (5), sda = Pin (4)) # importovat knihovnu a vytvořit objekt oled import ssd1306 i2c = I2C (scl = Pin (5), sda = Pin (4)) oled = ssd1306. SSD1306_I2C (128, 64, i2c, 0x3c) # vytvořit funkci: 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 ("Tlačítko:" + str (butSts), 0, 57) oled.show () # Hlavní funkce pro čtení všech senzorů def main (): # zobrazení dat s funkcí led.on () temp, hum, extTemp, lum, butSts = colectData () displayData (temp, hum, extTemp, lum, butSts) led.off () '' '- ----- spustit hlavní funkci -------- '' 'main ()

Uložte jej, například jako localData.py.

Ke spuštění tohoto kódu přímo na vašem terminálu budete potřebovat Ampy.

Nejprve na Terminálu informujme Ampy náš sériový port:

export AMPY_PORT =/dev/tty. SLAB_USBtoUART

Nyní můžeme vidět soubory, které jsou uvnitř našeho kořenového adresáře ESP:

ampy ls

Jako odpověď dostaneme boot.py, to je první soubor, který se spustí v systému.

Nyní pomocí Ampy načteme náš python Script LocalData.py jako /main.py, takže skript poběží hned po spuštění:

ampy vložte localData.py /main /py

Pokud nyní použijeme příkaz amp ls, uvidíte v ESP 2 soubory: boot.py a main.py

Resetováním vašeho ESP se program localData.py spustí automaticky a zobrazí data senzorů na displeji.

Výše uvedená obrazovka tisku Terminálu ukazuje, co jsme udělali.

S výše uvedeným kódem se displej zobrazí pouze jednou, ale můžeme definovat smyčku na funkci main (), která bude zobrazovat data o každém definovaném časovém intervalu (PUB_TIME_SEC), a například dokud nestiskneme tlačítko:

# smyčka získává data, dokud není stisknuto tlačítko

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

Proměnná PUB_TIME_SEC musí být deklarována do doby, kdy chcete vzorky.

Abychom náš kód ještě vylepšili, bylo by dobré informovat, že vyjdeme ze smyčky, proto definujeme 2 nové obecné funkce, jednu pro vymazání displeje a druhou pro blikání LED v určitém počtu případů.

# Vymazat displej:

def displayClear (): oled.fill (0) oled.show () # create a blink function def blinkLed (num): for i in range (0, num): led.on () sleep (0.5) led.off () spánek (0,5)

Nyní tedy můžeme přepsat naši hlavní () funkci:

while button.value ():

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

Konečný kód lze stáhnout z mého GitHub: localData.py a také z Jupyter Notebooku použitého pro vývoj plného kódu: Jupyter Local Data Development.

Krok 7: Připojení ESP k místnímu WiFi

Síťový modul slouží ke konfiguraci připojení WiFi. Existují dvě WiFi rozhraní, jedno pro stanici (když se ESP8266 připojuje k routeru) a druhé pro přístupový bod (pro připojení dalších zařízení k ESP8266). Zde bude náš ESP připojen k místní síti. Zavoláme knihovnu a definujeme naše síťová pověření:

importní síť

WiFi_SSID = "VAŠE SSID" WiFi_PASS = "VAŠE HESLO"

K připojení ESP k vaší místní síti lze použít níže uvedenou funkci:

def do_connect ():

wlan = network. WLAN (network. STA_IF) wlan.active (True) if not wlan.isconnected (): print ('connections to network…') wlan.connect (WiFi_SSID, WiFi_SSID) while not wlan.isconnected (): pass print ('network config:', wlan.ifconfig ())

Po spuštění této funkce můžete získat IP adresu:

do_connect ()

Výsledkem bude:

konfigurace sítě: ('10.0.1.2 ',' 255.255.255.0 ', '10.0.1.1', '10.0.1.1 ')

Byly, v mém případě, 10.0.1.2, je IP adresa ESP.

Krok 8: The ThingSpeak

V tomto okamžiku jsme se naučili zachytit data ze všech senzorů a zobrazit je na naší OLED. Nyní je načase zjistit, jak tato data odeslat na platformu IoT, ThingSpeak.

Pojďme začít!

Nejprve musíte mít účet na ThinkSpeak.com. Dále podle pokynů vytvořte kanál a poznamenejte si své ID kanálu a klíč API pro zápis.

Nahoře vidíte 5 polí, která budou použita na našem kanálu.

Krok 9: Protokol MQTT a připojení ThingSpeak

MQTT je architektura pro publikování/předplatné, která je vyvinuta především pro připojení zařízení s omezenou šířkou pásma a omezeným výkonem prostřednictvím bezdrátových sítí. Je to jednoduchý a lehký protokol, který běží přes sokety TCP/IP nebo WebSockets. MQTT přes WebSocket lze zabezpečit pomocí SSL. Architektura publikování/odběru umožňuje zasílání zpráv na klientská zařízení, aniž by zařízení muselo nepřetržitě dotazovat server.

Makléř MQTT je ústředním bodem komunikace a má na starosti odesílání všech zpráv mezi odesílateli a oprávněnými příjemci. Klient je jakékoli zařízení, které se připojuje k makléři a které může publikovat nebo se přihlásit k odběru témat pro přístup k informacím. Téma obsahuje informace o směrování pro makléře. Každý klient, který chce odesílat zprávy, je publikuje na určité téma a každý klient, který chce dostávat zprávy, se přihlásí k určitému tématu. Broker doručí všechny zprávy s odpovídajícím tématem příslušným klientům.

ThingSpeak ™ má zprostředkovatele MQTT na adrese URL mqtt.thingspeak.com a portu 1883. Zprostředkovatel ThingSpeak podporuje jak publikování MQTT, tak předplatné MQTT.

V našem případě použijeme: MQTT Publish

Obrázek popisuje strukturu tématu. K publikování je vyžadován klíč API pro zápis. Makléř uznává správný CONNECTrequest pomocí CONNACK.

Protokol MQTT je podporován vestavěnou knihovnou v binárních souborech Micropython-tento protokol lze použít k odesílání dat z vašeho ESP8266 přes WIFI do bezplatné cloudové databáze.

Pojďme použít knihovnu umqtt.simple:

z umqtt.simple importujte MQTTClient

A když známe naše SERVER ID, je možné vytvořit náš klientský objekt MQTT:

SERVER = "mqtt.thingspeak.com"

client = MQTTClient ("umqtt_client", SERVER)

Nyní máte po ruce své přihlašovací údaje ThingSpeak:

CHANNEL_ID = "VAŠE ID KANÁLU"

WRITE_API_KEY = "VÁŠ KLÍČ ZDE"

Pojďme vytvořit naše „téma“MQTT:

topic = "Channels/" + CHANNEL_ID + "/publish/" + WRITE_API_KEY

Pojďme nechat odeslat naše data do služby ThingSpeak IoT Service pomocí vytvořené funkce a přidružit její odpověď na konkrétní datové proměnné:

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

Po aktualizaci těchto proměnných můžeme vytvořit naše „užitečné zatížení MQTT“:

užitečné zatížení = "field1 ="+str (temp)+"& field2 ="+str (hum)+"& field3 ="+str (extTemp)+"& field4 ="+str (lum)+"& field5 ="+str (butSts)

A to je vše! Jsme připraveni odeslat data do ThinsSpeak, jednoduše pomocí 3 řádků kódu níže:

client.connect ()

client.publish (téma, užitečné zatížení) client.disconnect ()

Nyní, když přejdete na stránku svého kanálu (jako já výše), uvidíte, že každé z 5 polí bude obsahovat data související s vašimi senzory.

Krok 10: Senzorový záznamník dat

Nyní, když víme, že pouze s několika řádky kódu je možné odesílat data do služby IoT, vytvořme funkci smyčky, která to provede automaticky v pravidelném časovém intervalu (podobně jako jsme to udělali u „Místní data ).

Pomocí stejné proměnné (PUB_TIME_SEC), deklarované dříve, jednoduchá hlavní funkce pro nepřetržité zachycování dat, jejich protokolování na našem kanálu by bylo:

zatímco pravda:

temp, hum, extTemp, lum, butSts = colectData () užitečné zatížení = "field1 ="+str (temp)+"& field2 ="+str (hum)+"& field3 ="+str (extTemp)+"& field4 ="+ str (lum)+"& field5 ="+str (butSts) client.connect () client.publish (téma, užitečné zatížení) client.disconnect () time.sleep (PUB_TIME_SEC)

Upozorňujeme, že je nutné aktualizovat pouze „užitečné zatížení“, jakmile bude „téma“souviset s pověřeními našeho kanálu a nezmění se.

Při pohledu na svou stránku kanálu ThingSpeak zjistíte, že data se budou načítat nepřetržitě do každého pole. Můžete zakrýt LDR, přiložit ruku k čidlům teploty/hučení, stisknout tlačítko atd. A podívat se, jak kanál automaticky „zaznamená“tato data pro budoucí analýzu.

Pro protokolování dat bychom se obvykle měli snažit použít co nejméně energie, takže bychom LED diodu nebo displej nepoužívali lokálně. Také je běžné u zařízení ESP, uveďte je do „hlubokého spánku“, kde bude mikroprocesor ve stavu minimální energie, dokud nebude čas zachytit data a odeslat je na platformu IoT.

Ale jakmile se tu myšlenka učí, pojďme také zahrnout displej a LED, jako jsme to udělali dříve. Přitom naše funkce „záznamníku“bude:

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 () užitečné zatížení = "field1 ="+str (temp)+"& field2 ="+str (hum)+"& field3 ="+str (extTemp)+"& field4 ="+str (lum)+"& field5 ="+str (butSts) klient.connect () client.publish (téma, užitečné zatížení) client.disconnect () time.sleep (PUB_TIME_SEC) blinkLed (3) displayClear ()

Kompletní skript microPython najdete zde: dataLoggerTS_EXT.py a notebook Jupyter, který byl použit pro vývoj, najdete také zde: IoT ThingSpeak Data Logger EXT.ipynb.

Chcete -li skript nahrát na ESP, použijte na svém terminálu příkaz:

ampy dát dataLoggerTS.py /main.py

A stiskněte tlačítko ESP - reset. Budete mít ESP zachycovat data a zaznamenávat je na ThingSpeak.com, dokud nebudete držet stisknuté dno (počkejte, až LED 3x zabliká a OLED se vypne).

Krok 11: Aplikace ThingView

Zaznamenaná data lze zobrazit přímo na webu ThingSpeak.com nebo prostřednictvím aplikace, například ThingsView!

ThingView je aplikace vyvinutá společností CINETICA, která vám umožňuje snadnou vizualizaci vašich kanálů ThingSpeak, stačí zadat ID kanálu a jste připraveni jít.

U veřejných kanálů bude aplikace respektovat vaše nastavení oken: barvu, časový rozvrh, typ grafu a počet výsledků. Aktuální verze podporuje řádkové a sloupcové grafy, spline grafy se zobrazují jako spojnicové grafy.

U soukromých kanálů se data zobrazí pomocí výchozího nastavení, protože neexistuje způsob, jak číst nastavení soukromých oken pouze pomocí klíče API.

Aplikaci ThingView lze stáhnout pro Android a IPHONE.

Krok 12: Závěr

Jako vždy doufám, že tento projekt pomůže ostatním najít cestu do vzrušujícího světa elektroniky!

Podrobnosti a konečný kód naleznete v mém depozitáři GitHub: IoT_TS_MQTT

Pro více projektů navštivte můj blog: MJRoBot.org

Saludos z jihu světa!

Uvidíme se v mém dalším pokynu!

Děkuji, Marcelo