IoT Made Ease: ESP-MicroPython-MQTT-ThingSpeak: 12 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:44

În tutorialul meu anterior, MicroPython pe ESP folosind Jupyter, am învățat cum să instalăm și să rulăm MicroPython pe un dispozitiv ESP. Folosind Notebook-ul Jupyter ca mediu de dezvoltare, am învățat, de asemenea, cum să citim din senzori (temperatură, umiditate și luminozitate). date pe un ecran OLED.

Acum, pe acest tutorial folosind un protocol MQTT, vom obține toate datele capturate, trimitându-le la un serviciu IoT, ThingSpeak.com și la o aplicație mobilă (Thingsview), unde putem să ne conectăm și să ne jucăm cu date.

Aici, schema bloc a proiectului nostru:

Pasul 1: BoM - Lista materialelor

1. NodeMCU - 8,39 USD
2. Senzor de temperatură și umiditate relativă DHT22 - 9,95 USD
3. Senzor de temperatură impermeabil DS18B20 - 5,95 USD
4. Afișaj OLED SSD1366- 8,99 USD (opțional)
5. LDR (1x)
6. LED-uri (1x) (opțional)
7. Buton (1x)
8. Rezistor 4K7 ohm (2x)
9. Rezistor 10K ohm (1x)
10. Rezistor 220 ohm (1x)

Pasul 2: Hw

Hw-ul pe care îl vom folosi aici este practic același lucru folosit în tutorial: Micropython pe ESP folosind Jupyter. Consultați-l pentru toate conexiunile HW.

Excepția este Servo, că nu vom fi folosiți în acest proiect.

Deasupra puteți vedea HW complet. Conectați dispozitivele așa cum se arată acolo.

Pasul 3: Micropython, REPL, Jupyter

Trebuie să aveți un interpret Micropython încărcat pe dispozitivul dvs. ESP. Odată încărcat, ar trebui să vă programați ESP-ul folosind oricare dintre modurile / IDE disponibile, cum ar fi:

• REPL
• Notebook Jupyter
• Mu
• ESPCut (numai pentru Windows)
• … etc.

În tutorialul meu, Micropython on ESP Folosind Jupyter, am detaliat cum să descarc și să instalez un interpretor MicroPython, ESPTool pentru a gestiona dispozitivele ESP și cum să utilizezi Jupyter Notebook ca mediu de dezvoltare. Simțiți-vă liber să folosiți ceea ce vă este mai confortabil.

De obicei, fac toate dezvoltările pe Jupyter Notebook și, odată ce primesc codul final, le copiez pe Geany și îl încarc pe ESP folosind Ampy.

Pasul 4: senzori

Să instalăm bibliotecile, să definim GPIO, să creăm obiecte, funcții pentru toți senzorii individual:

A. DHT (temperatură și umiditate)

Să instalăm biblioteca DHT și să creăm un obiect:

din DHT import DHT22

de la importul mașinii Pin dht22 = DHT22 (Pin (12))

Acum, creați o funcție pentru a citi senzorul DHT:

read readht ():

dht22.measure () return dht22.temperature (), dht22.humidity () Testați funcția DHT

print (readDht ())

Rezultatul ar trebui să fie, de exemplu:

(17.7, 43.4)

B. DS18B20 (temperatură externă)

Să instalăm bibliotecile și să creăm un obiect:

import onewire, ds18x20

timp de import # Definiți care pin dispozitivul cu 1 fir va fi conectat ==> pin 2 (D4) dat = Pin (2) # creați obiectul onewire ds = ds18x20. DS18X20 (onewire. OneWire (dat)) Căutați dispozitive de pe bu

senzori = ds.scan ()

print („dispozitive găsite:”, senzori)

Rezultatul tipărit nu este foarte important, ceea ce vom avea nevoie este primul senzor detectat: senzorii [0]. Și acum, putem construi o funcție pentru a citi datele senzorului:

readDs def ():

ds.convert_temp () time.sleep_ms (750) returnează ds.read_temp (senzori [0])

Este întotdeauna important să testați senzorul folosind funcția creată

print (readDs ()) Dacă obțineți o valoare a temperaturii, codul dvs. este corect

17.5

C. LDR (Luminozitate)

LDR va utiliza pinul analogic al ESP-ului nostru (este unul singur în cazul ESP8266 și mai multe la ESP32).

Consultați tutorialul meu ESP32 pentru detalii.

La fel ca înainte:

# import bibliotecă

de la importul de mașini ADC # Definirea obiectului adc = ADC (0) O funcție simplă: adc.read () poate fi utilizată pentru a citi valoarea ADC. Dar amintiți-vă că ADC intern va converti tensiunile între 0 și 3,3V în valori digitale corespondente, variind de la 0 la 1023. Odată ce ne interesează „Luminozitatea”, vom considera lumina maximă ca valoarea maximă capturată de la senzor (în 900) și lumină minimă care în cazul meu este de 40. Având acele valori putem „mapa” valoarea de la 40 la 900 în 0 la 100% din luminozitate. Pentru aceasta, vom crea o nouă funcție

read readdr ():

lumPerct = (adc.read () - 40) * (10/86) # converti în procent („hartă”) rundă de întoarcere (lumPerct)

Ar trebui să testați funcția folosind print (readLDR ()). Rezultatul ar trebui să fie un număr întreg între o și 100.

D. Buton (intrare digitală)

Aici folosim un buton Push ca senzor digital, dar ar putea fi un „ecou” al unui actuator (o pompă care a fost pornită / oprită, de exemplu).

# definiți pinul 13 ca intrare și activați un rezistor intern Pull-up:

button = Pin (13, Pin. IN, Pin. PULL_UP) # Funcție pentru citirea stării butonului: def readBut (): return button.value ()

Puteți testa butonul care citește funcția de imprimare (readBut ()). Dacă nu apăsați rezultatul ar trebui să fie „1”. Apăsând butonul, rezultatul ar trebui să fie „0”

Pasul 5: Captarea și afișarea locală a tuturor datelor senzorului

Acum, că am creat o funcție pentru fiecare senzor, să creăm ultima care să le citească pe toate în același timp:

def colectData ():

temp, hum, = readDht () extTemp = readDs () lum = readLdr () butSts = readBut () return temp, hum, extTemp, lum, butSts Acum, dacă folosești

print (colectData ())

Va rezulta un tuplu care include toate datele capturate de la senzori:

(17.4, 45.2, 17.3125, 103, 1)

De asemenea, opțional, putem arăta acele date pe un ecran local:

# importați biblioteca și creați obiectul i2c

din mașina de import I2C i2c = I2C (scl = Pin (5), sda = Pin (4)) # import bibliotecă și creați obiect oled import ssd1306 i2c = I2C (scl = Pin (5), sda = Pin (4)) oled = ssd1306. SSD1306_I2C (128, 64, i2c, 0x3c) # creați o funcție: 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 ("Buton:" + str (butSts), 0, 57) oled.show () # afișați date utilizând funcția displayData (temp, hum, extTemp, lum, butSts)

Ca opțiune, voi include și LED-ul pentru a fi aprins când începem să citim senzorii, oprindu-se după afișarea acestor date. Acest lucru vă va ajuta să confirmați că programul funcționează atunci când ESP este deconectat de la computer și rulează automat.

Deci, „funcția principală ar fi:

# Funcția principală pentru citirea tuturor senzorilor

def main (): # afișează date cu o funcție led.on () temp, hum, extTemp, lum, butSts = colectData () displayData (temp, hum, extTemp, lum, butSts) led.off ()

Deci, executând main (), vom obține datele senzorului afișate pe OLED așa cum se arată în imagine.

Pasul 6: Rularea codului stației locale la pornirea ESP

Putem avea tot ceea ce a fost dezvoltat până acum pe un singur fișier care să fie executat de ESP-ul nostru.

Să deschidem orice editor de text și să trecem pe tot codul:

# import biblioteci generale

din importul de mașină Timp de import pin # definiți pinul 0 ca led de ieșire = Pin (0, Pin. OUT) # DHT din importul DHT DHT22 dht22 = DHT22 (Pin (12)) # Funcția de citit DHT def readDht (): dht22.measure () return dht22.temperature (), dht22.humidity () # DS18B20 import onewire, ds18x20 # Definiți care pin dispozitivul cu 1 fir va fi conectat ==> pin 2 (D4) dat = Pin (2) # Creați onewire obiect ds = ds18x20. DS18X20 (onewire. OneWire (dat)) # scanare pentru dispozitive pe senzori de magistrală = ds.scan () # funcție pentru citirea DS18B20 def readDs (): ds.convert_temp () time.sleep_ms (750) return round (ds.read_temp (senzori [0]), 1) # LDR de la importul de mașini ADC # Definire obiect adc = ADC (0) #funcție pentru citirea luminozității def readLdr (): lumPerct = (adc.read () - 40) * (10/86) # converti în procent („hartă”) rundă de întoarcere (lumPerct) # definește pinul 13 ca intrare și activează un rezistor intern Pull-up: button = Pin (13, Pin. IN, Pin. PULL_UP) # Funcția pentru citirea stării butonului: def readBut (): return button.value () # Funcția pentru citirea tuturor datelor: def cole ctData (): temp, hum, = readDht () extTemp = readDs () lum = readLdr () butSts = readBut () returnează temp, hum, extTemp, lum, butSts # import bibliotecă și creează obiectul i2c din importul mașinii I2C i2c = I2C (scl = Pin (5), sda = Pin (4)) # import bibliotecă și creați obiect oled import ssd1306 i2c = I2C (scl = Pin (5), sda = Pin (4)) oled = ssd1306. SSD1306_I2C (128, 64, i2c, 0x3c) # creați o funcție: 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 ("Buton:" + str (butSts), 0, 57) oled.show () # Funcția principală pentru a citi toți senzorii def main (): # afișează date cu o funcție led.on () temp, hum, extTemp, lum, butSts = colectData () displayData (temp, hum, extTemp, lum, butSts) led.off () '' '- ----- rulează funcția principală -------- '' 'main ()

Salvați-l, de exemplu, ca localData.py.

Pentru a rula acest cod direct pe terminalul dvs., veți avea nevoie de Ampy.

Mai întâi, la Terminal să informăm Ampy portul nostru Serial:

export AMPY_PORT = / dev / tty. SLAB_USBtoUART

Acum, putem vedea fișierele care se află în directorul nostru rădăcină ESP:

ampy ls

Ca răspuns, vom obține boot.py, acesta este primul fișier care va rula în sistem.

Acum, să folosim Ampy pentru a încărca scriptul nostru Python LocalData.py ca /main.py, deci scriptul va rula imediat după pornire:

ampy pune localData.py / main / py

Dacă folosim comanda amp ls acum, veți vedea 2 fișiere în ESP: boot.py și main.py

Resetarea ESP-ului dvs. va face ca programul localData.py să ruleze automat, afișând datele senzorului pe ecran.

Ecranul de imprimare Terminal de mai sus arată ce am făcut.

Cu codul de mai sus, afișajul va fi afișat o singură dată, dar putem defini o buclă pe funcția main (), care va afișa date pentru fiecare interval de timp definit (PUB_TIME_SEC) și, de exemplu, până când apăsăm butonul:

# buclă obținând date până când butonul este apăsat

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

Variabila PUB_TIME_SEC trebuie declarată până când doriți eșantioanele.

Pentru a îmbunătăți mai mult codul nostru, ar fi bine să vă informăm că vom ieși din buclă, pentru aceasta vom defini 2 noi funcții generale, una pentru ștergerea afișajului și alta pentru a clipi LED-ul de un anumit număr de ori.

# Afișaj clar:

display afișat Clear (): oled.fill (0) oled.show () # creați o funcție de clipire def blinkLed (num): pentru i în intervalul (0, num): led.on () sleep (0.5) led.off () somn (0,5)

Deci, acum putem rescrie funcția noastră principală ():

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

Codul final poate fi descărcat de pe GitHub: localData.py și, de asemenea, Jupyter Notebook folosit pentru dezvoltarea codului complet: Jupyter Local Data Development.

Pasul 7: Conectarea ESP la WiFi local

Modulul de rețea este utilizat pentru a configura conexiunea WiFi. Există două interfețe WiFi, una pentru stație (când ESP8266 se conectează la un router) și una pentru punctul de acces (pentru alte dispozitive care se conectează la ESP8266). Aici, ESP-ul nostru va fi conectat la rețeaua locală. Să apelăm biblioteca și să ne definim acreditările de rețea:

rețea de import

WiFi_SSID = "SSID-UL TĂU" WiFi_PASS = "PAROLA TA"

Funcția de mai jos poate fi utilizată pentru a conecta ESP la rețeaua dvs. locală:

def do_connect ():

wlan = network. WLAN (network. STA_IF) wlan.active (True) dacă nu wlan.isconnected (): print ('conectarea la rețea …') wlan.connect (WiFi_SSID, WiFi_SSID) în timp ce nu wlan.isconnected (): pass print ('config rețea:', wlan.ifconfig ())

Executând funcția, puteți obține ca rezultat adresa IP:

face_connect ()

Rezultatul va fi:

configurare rețea: ('10.0.1.2 ',' 255.255.255.0 ', '10.0.1.1', '10.0.1.1 ')

Au fost, în cazul meu, 10.0.1.2, adresa ESP IP.

Pasul 8: The ThingSpeak

În acest moment, am învățat cum să captăm date de la toți senzorii, afișându-le pe OLED-ul nostru. Acum, este timpul să vedem cum să trimiteți acele date către o platformă IoT, ThingSpeak.

Sa incepem!

În primul rând, trebuie să aveți un cont la ThinkSpeak.com. Apoi, urmați instrucțiunile pentru a crea un canal și luați notă de ID-ul dvs. de canal și de scriere a cheii API.

Mai sus puteți vedea cele 5 câmpuri care vor fi utilizate pe canalul nostru.

Pasul 9: Protocol MQTT și conexiune ThingSpeak

MQTT este o arhitectură de publicare / abonare dezvoltată în principal pentru a conecta lățimea de bandă și dispozitivele cu putere limitată prin rețelele fără fir. Este un protocol simplu și ușor care rulează peste socket-uri TCP / IP sau WebSockets. MQTT peste WebSockets poate fi securizat cu SSL. Arhitectura de publicare / abonare permite transmiterea mesajelor către dispozitivele client fără ca dispozitivul să fie nevoie să interogheze continuu serverul.

Brokerul MQTT este punctul central al comunicării și este responsabil cu transmiterea tuturor mesajelor între expeditori și destinatarii de drept. Un client este orice dispozitiv care se conectează la broker și poate publica sau abona subiecte pentru a accesa informațiile. Un subiect conține informații de rutare pentru broker. Fiecare client care dorește să trimită mesaje le publică la un anumit subiect, iar fiecare client care dorește să primească mesaje se abonează la un anumit subiect. Brokerul livrează toate mesajele cu subiectul corespunzător clienților corespunzători.

ThingSpeak ™ are un broker MQTT la adresa URL mqtt.thingspeak.com și portul 1883. Brokerul ThingSpeak acceptă atât publicarea MQTT, cât și abonarea MQTT.

În cazul nostru, vom folosi: MQTT Publish

Figura descrie structura subiectului. Cheia API de scriere este necesară pentru publicare. Brokerul recunoaște o cerere corectă CONNECT cu CONNACK.

Protocolul MQTT este acceptat într-o bibliotecă încorporată în binarele Micropython - acest protocol poate fi utilizat pentru a trimite date de la ESP8266, prin WIFI, la o bază de date cloud gratuită.

Să folosim biblioteca umqtt.simple:

din umqtt.simple import MQTTClient

Și cunoscând ID-ul nostru de SERVER, este posibil să ne creăm obiectul client MQTT:

SERVER = "mqtt.thingspeak.com"

client = MQTTClient ("umqtt_client", SERVER)

Acum, având acreditările ThingSpeak la îndemână:

CHANNEL_ID = "ID-ul Dvs. DE CANAL"

WRITE_API_KEY = "CHEIA TA AICI"

Să creăm „Subiectul” nostru MQTT:

topic = "canale /" + CHANNEL_ID + "/ publica /" + WRITE_API_KEY

Să facem ca datele noastre să fie trimise către ThingSpeak IoT Service, utilizând funcția creată și să asocieze răspunsul acesteia la variabile de date specifice:

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

Cu aceste variabile actualizate, ne putem crea „MQTT Payload”:

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

Si asta e! Suntem gata să trimitem date către ThinsSpeak, folosind pur și simplu cele 3 linii de cod de mai jos:

client.connect ()

client.publish (topic, sarcină utilă) client.disconnect ()

Acum, dacă accesați pagina canalului dvs. (ca a mea de mai sus), veți vedea că fiecare dintre cele 5 câmpuri va avea date legate de senzorii dvs.

Pasul 10: senzor de date logger

Acum, că știm că doar cu câteva linii de cod este posibil să încărcați date într-un serviciu IoT, să creăm o funcție de buclă pentru a o face automat la un interval de timp regulat (similar cu ceea ce am făcut cu „Date locale” ).

Folosind aceeași variabilă (PUB_TIME_SEC), declarată anterior, o funcție principală simplă pentru a capta în mod continuu date, înregistrându-le pe canalul nostru ar fi:

în timp ce este adevărat:

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, load) client.disconnect () time.sleep (PUB_TIME_SEC)

Rețineți că numai „sarcina utilă” trebuie actualizată, odată ce „subiectul” este legat de acreditările canalului nostru și nu se va schimba.

Căutând pagina canalului ThingSpeak, veți observa că datele se vor încărca continuu în fiecare câmp. Puteți acoperi LDR, puteți pune mâna pe senzorii de temperatură / zumzet, apăsați butonul etc. și puteți vedea cum canalul va „înregistra” automat aceste date pentru analize viitoare.

De obicei, pentru înregistrarea datelor, ar trebui să încercăm să utilizăm cât mai puțină energie posibil, deci nu am folosi LED-ul sau afișajul local. De asemenea, este obișnuit cu dispozitivele ESP, puneți-le pe „somn adânc”, unde microprocesorul va fi la starea sa de energie minimă până când este timpul să captați date și să le trimiteți pe platforma IoT.

Dar, odată ce aici ideea învață, să includem și afișajul și LED-ul așa cum am făcut înainte. Făcând acest lucru, funcția noastră „logger” va fi:

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) client.connect () client.publish (topic, load) client.disconnect () time.sleep (PUB_TIME_SEC) blinkLed (3) displayClear ()

Scriptul complet microPython poate fi găsit aici: dataLoggerTS_EXT.py și notebook-ul Jupyter care a fost utilizat pentru dezvoltare pot fi găsite și aici: IoT ThingSpeak Data Logger EXT.ipynb.

Pentru a încărca scriptul pe ESP, pe terminalul dvs. utilizați comanda:

ampy a pus dataLoggerTS.py /main.py

Și apăsați butonul ESP - reset. Veți avea ESP care captează date și le conectează pe ThingSpeak.com până când partea inferioară este menținută apăsată (așteptați ca LED-ul să clipească de 3 ori și OLED-ul să se oprească).

Pasul 11: aplicația ThingView

Datele înregistrate pot fi vizualizate direct pe site-ul ThingSpeak.com sau printr-o aplicație, de exemplu, ThingsView!

ThingView este o aplicație dezvoltată de CINETICA, care vă permite să vizualizați canalele ThingSpeak într-un mod ușor, trebuie doar să introduceți ID-ul canalului și sunteți gata de plecare.

Pentru canalele publice, aplicația va respecta setările Windows: culoare, interval de timp, tip de diagramă și numărul de rezultate. Versiunea curentă acceptă diagrame liniare și coloane, diagramele spline sunt afișate ca diagrame liniare.

Pentru canalele private, datele vor fi afișate folosind setările implicite, deoarece nu există nicio modalitate de a citi setările Windows private numai cu cheia API.

Aplicația ThingView poate fi descărcată pentru ANDROID și IPHONE.

Pasul 12: Concluzie

Ca întotdeauna, sper că acest proiect îi poate ajuta pe ceilalți să își găsească drumul în lumea interesantă a electronicii!

Pentru detalii și cod final, vă rugăm să vizitați depozitarul GitHub: IoT_TS_MQTT

Pentru mai multe proiecte, vă rugăm să vizitați blogul meu: MJRoBot.org

Salude din sudul lumii!

Ne vedem în următorul meu instructabil!

Mulțumesc, Marcelo