Facilitat de l'IoT: ESP-MicroPython-MQTT-ThingSpeak: 12 passos

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:14

Al meu tutorial anterior, MicroPython a ESP mitjançant Jupyter, vam aprendre a instal·lar i executar MicroPython en un dispositiu ESP. Utilitzant Jupyter Notebook com a entorn de desenvolupament, també vam aprendre a llegir a partir de sensors (temperatura, humitat i lluminositat). Utilitzem diversos protocols i mètodes de comunicació, analògics, digitals, 1 cable i I2C, aquest darrer per mostrar els nostres capturats dades en una pantalla OLED.

Ara, en aquest tutorial amb un protocol MQTT, obtindrem totes les dades capturades, les enviarem a un servei IoT, ThingSpeak.com i a una aplicació mòbil (Thingsview), on podrem registrar-nos i jugar amb les dades.

Aquí, el diagrama de blocs del nostre projecte:

Pas 1: BoM: llista de materials

1. NodeMCU: 8,39 dòlars EUA
2. Sensor de temperatura i humitat relativa DHT22: 9,95 USD
3. Sensor de temperatura impermeable DS18B20: 5,95 USD
4. Pantalla OLED SSD1366- 8,99 USD (opcional)
5. LDR (1x)
6. LED (1x) (opcional)
7. Polsador (1x)
8. Resistència 4K7 ohm (2x)
9. Resistència 10K ohm (1x)
10. Resistència de 220 ohm (1x)

Pas 2: el Hw

El Hw que farem servir aquí és bàsicament el mateix que s’utilitza al tutorial: Micropython on ESP Using Jupyter. Consulteu-lo per a totes les connexions HW.

L’excepció és el Servo, que no serem utilitzats en aquest projecte.

A sobre podeu veure la HW completa. Connecteu els dispositius tal com es mostra allà.

Pas 3: Micropython, REPL, Jupyter

Heu de tenir un intèrpret Micropython carregat al vostre dispositiu ESP. Un cop carregat, heu de programar el vostre ESP mitjançant qualsevol de les maneres / IDE disponibles, com ara:

• REPL
• Llibreta Jupyter
• Mu
• ESPCut (només Windows)
• … etc.

Al meu tutorial, Micropython on ESP. Amb Jupyter, he detallat com descarregar i instal·lar l’intèrpret MicroPython, ESPTool per gestionar dispositius ESP i com utilitzar Jupyter Notebook com a entorn de desenvolupament. No dubteu a utilitzar allò que us resulti més còmode.

Normalment faig tot el desenvolupament a Jupyter Notebook i, un cop obtingut el codi final, els copio a Geany i el carrego al meu ESP mitjançant Ampy.

Pas 4: Sensors

Instal·lem les biblioteques, definim GPIO, creem objectes, funcions per a tots els sensors individualment:

A. DHT (temperatura i humitat)

Instal·lem la biblioteca DHT i creem un objecte:

des de la importació DHT DHT22

des de la importació de la màquina Pin dht22 = DHT22 (Pin (12))

Ara, creeu una funció per llegir el sensor DHT:

def readDht ():

dht22.measure () return dht22.temperature (), dht22.humidity () Prova la funció DHT

imprimir (readDht ())

El resultat hauria de ser, per exemple:

(17.7, 43.4)

B. DS18B20 (temperatura externa)

Instal·lem les biblioteques i creem un objecte:

importar un cable, ds18x20

temps d'importació # Definiu quin pin es connectarà el dispositiu d'un fil ==> pin 2 (D4) dat = Pin (2) # create the oneewire object ds = ds18x20. DS18X20 (onewire. OneWire (dat)) Busqueu dispositius al bu

sensors = ds.scan ()

imprimir ("dispositius trobats", sensors)

El resultat imprès no és realment important, el que necessitarem és el primer sensor detectat: els sensors [0]. I ara, podem construir una funció per llegir les dades del sensor:

readDs def ():

ds.convert_temp () time.sleep_ms (750) retorna ds.read_temp (sensors [0])

Sempre és important provar el sensor mitjançant la funció creada

imprimir (readDs ()) Si obteniu un valor de temperatura, el vostre codi és correcte

17.5

C. LDR (lluminositat)

El LDR utilitzarà el pin analògic del nostre ESP (només és un en el cas de l’ESP8266 i diversos a l’ESP32).

Consulteu el meu tutorial ESP32 per obtenir més informació.

Igual que abans:

# biblioteca d'importació

des de la importació de màquina ADC # Define object adc = ADC (0) Una funció senzilla: adc.read () es pot utilitzar per llegir el valor ADC. Però recordeu que l'ADC intern convertirà tensions entre 0 i 3,3 V en valors digitals corresponents, que varien de 0 a 1023. Un cop ens interessi la "Lluminositat", considerarem la llum màxima com el valor màxim capturat del sensor (a la meva 900) i una llum mínima que en el meu cas és 40. Tenint aquests valors podem "assignar" el valor de 40 a 900 en un 0 a 100% de lluminositat. Per a això, crearem una nova funció

def readLdr ():

lumPerct = (adc.read () - 40) * (10/86) # convertir en percentatge ("mapa") tornada de retorn (lumPerct)

Haureu de provar la funció utilitzant print (readLDR ()). El resultat ha de ser un nombre enter entre o i 100.

D. Polsador (entrada digital)

Aquí estem fent servir un polsador com a sensor digital, però pot ser un "eco" d'un actuador (per exemple, una bomba activada / apagada).

# definiu el pin 13 com a entrada i activeu una resistència de tracció interna:

button = Pin (13, Pin. IN, Pin. PULL_UP) # Funció per llegir l'estat del botó: def readBut (): return button.value ()

Podeu provar el botó que llegeix la funció d'impressió (readBut ()). Si no premeu el resultat ha de ser "1". En prémer el botó, el resultat hauria de ser "0"

Pas 5: captura i visualització local de totes les dades del sensor

Ara que hem creat una funció per a cada sensor, creem l'última que llegirà totes al mateix temps:

def colectData ():

temp, hum, = readDht () extTemp = readDs () lum = readLdr () butSts = readBut () return temp, hum, extTemp, lum, butSts Ara si ho fas servir

imprimir (colectData ())

Donarà lloc a una tupla que inclou totes les dades capturades dels sensors:

(17.4, 45.2, 17.3125, 103, 1)

Opcionalment, també podem mostrar aquestes dades en una pantalla local:

# importa la biblioteca i crea l'objecte i2c

des de la importació de màquina I2C i2c = I2C (scl = Pin (5), sda = Pin (4)) # import biblioteca i crea objecte oled import ssd1306 i2c = I2C (scl = Pin (5), sda = Pin (4)) oled = ssd1306. SSD1306_I2C (128, 64, i2c, 0x3c) # crea una funció: 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 ("Botó:" + str (butSts), 0, 57) oled.show () # mostrar dades mitjançant la funció displayData (temp, hum, extTemp, lum, butSts)

Com a opció, també inclouré el LED perquè s’encengui quan comencem a llegir els sensors, que s’apagarà després que es mostrin aquestes dades. Si feu això, ajudareu a confirmar que el programa funciona quan tenim l’ESP desconnectat del PC i s’executa automàticament.

Per tant, la funció principal seria:

# Funció principal per llegir tots els sensors

def main (): # mostra dades amb una funció led.on () temp, hum, extTemp, lum, butSts = colectData () displayData (temp, hum, extTemp, lum, butSts) led.off ()

Per tant, executant main (), obtindrem les dades del sensor que es mostren a OLED tal com es mostra a la imatge.

Pas 6: Execució del codi de l'estació local en iniciar ESP

Podem tenir tot el que s’ha desenvolupat fins ara en un únic fitxer que ha d’executar el nostre ESP.

Obrim qualsevol editor de text i deixem tot el codi:

# importar biblioteques generals

des de la importació de la màquina Pin time time # define pin 0 as led led = Pin (0, Pin. OUT) # DHT from dht import DHT22 dht22 = DHT22 (Pin (12)) # Function to read DHT def readDht (): dht22.measure () return dht22.temperature (), dht22.humidity () # DS18B20 import onewire, ds18x20 # Defineix quin pin es connectarà el dispositiu d'un fil ==> pin 2 (D4) dat = Pin (2) # Crea el onewire objecte ds = ds18x20. DS18X20 (onewire. OneWire (dat)) # escaneig de dispositius al bus sensors = ds.scan () # funció per llegir DS18B20 def readDs (): ds.convert_temp () time.sleep_ms (750) return round (ds.read_temp (sensors [0]), 1) # LDR des de la importació de màquina ADC # Define object adc = ADC (0) #function to read luminosity def readLdr (): lumPerct = (adc.read () - 40) * (10/86) # convertir en percentatge ("mapa") la ronda de retorn (lumPerct) # definir el pin 13 com a entrada i activar una resistència de tracció interna: button = Pin (13, Pin. IN, Pin. PULL_UP) # Funció per llegir l'estat del botó: def readBut (): return button.value () # Funció per llegir totes les dades: def cole ctData (): temp, hum, = readDht () extTemp = readDs () lum = readLdr () butSts = readBut () return temp, hum, extTemp, lum, butSts # import library and create object i2c from machine import I2C i2c = I2C (scl = Pin (5), sda = Pin (4)) # biblioteca d'importació i creació d'objectes oled import ssd1306 i2c = I2C (scl = Pin (5), sda = Pin (4)) oled = ssd1306. SSD1306_I2C (128, 64, i2c, 0x3c) # crea una funció: 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 () # Funció principal per llegir tots els sensors def main (): # mostra dades amb una funció led.on () temp, hum, extTemp, lum, butSts = colectData () displayData (temp, hum, extTemp, lum, butSts) led.off () '' '- ----- executa la funció principal -------- '' 'main ()

Deseu-lo, per exemple, com a localData.py.

Per executar aquest codi directament al vostre terminal necessitareu Ampy.

En primer lloc, a Terminal informem Ampy del nostre port sèrie:

exporta AMPY_PORT = / dev / tty. SLAB_USBtoUART

Ara podem veure els fitxers que hi ha dins del nostre directori arrel ESP:

ampy ls

Com a resposta, obtindrem boot.py, que és el primer fitxer que s’executarà al sistema.

Ara, fem servir Ampy per carregar el nostre script Python LocalData.py com a /main.py, de manera que l'script s'executarà just després de l'arrencada:

ampy posa localData.py / main / py

Si fem servir l’ordre amp ls ara, veureu 2 fitxers dins de l’ESP: boot.py i main.py

En restablir el vostre ESP, el programa localData.py s’executarà automàticament i mostrarà les dades del sensor a la pantalla.

La pantalla d’impressió del terminal anterior mostra el que hem fet.

Amb el codi anterior, la pantalla només es mostrarà una vegada, però podem definir un bucle a la funció main (), que mostrarà les dades de cada interval de temps definit (PUB_TIME_SEC) i, per exemple, fins que premem el botó:

# bucle obtenint dades fins que es prem el botó

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

La variable PUB_TIME_SEC s'ha de declarar en el moment en què desitgeu les vostres mostres.

Per millorar més el nostre codi, estaria bé informar-vos que sortirem del bucle, per això definirem 2 noves funcions generals, una per esborrar la pantalla i una altra per parpellejar el LED un nombre determinat de vegades.

# Esborra la pantalla:

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 () dormir (0,5)

Per tant, ara podem reescriure la nostra funció 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 ()

El codi final es pot descarregar del meu GitHub: localData.py i també del bloc de notes Jupyter utilitzat per al desenvolupament del codi complet: Jupyter Local Data Development.

Pas 7: Connexió de l'ESP a WiFi local

El mòdul de xarxa s’utilitza per configurar la connexió WiFi. Hi ha dues interfícies WiFi, una per a l’estació (quan l’ESP8266 es connecta a un enrutador) i una per al punt d’accés (per a la connexió d’altres dispositius a l’ESP8266). Aquí, el nostre ESP estarà connectat a la xarxa local. Truquem a la biblioteca i definim les nostres credencials de xarxa:

xarxa d’importació

WiFi_SSID = "EL SEU SSID" WiFi_PASS = "LA SEVA CONTRASENYA"

La funció següent es pot utilitzar per connectar l'ESP a la vostra xarxa local:

def do_connect ():

wlan = network. WLAN (network. STA_IF) wlan.active (True) si no wlan.isconnected (): imprimir ('connectar-se a la xarxa …') wlan.connect (WiFi_SSID, WiFi_SSID) mentre no és wlan.isconnected (): pass print ('configuració de xarxa:', wlan.ifconfig ())

Executant la funció, podeu obtenir com a resultat l'adreça IP:

fer_connexió ()

El resultat serà:

configuració de xarxa: ('10.0.1.2 ',' 255.255.255.0 ', '10.0.1.1', '10.0.1.1 ')

Si, en el meu cas, 10.0.1.2, era l'adreça IP ESP.

Pas 8: el ThingSpeak

En aquest moment, vam aprendre a capturar dades de tots els sensors, mostrant-los al nostre OLED. Ara, és hora de veure com enviar aquestes dades a una plataforma IoT, el ThingSpeak.

Anem a començar!

En primer lloc, heu de tenir un compte a ThinkSpeak.com. A continuació, seguiu les instruccions per crear un canal i preneu nota del vostre identificador de canal i de la clau API d'escriptura.

A sobre podeu veure els cinc camps que s'utilitzaran al nostre canal.

Pas 9: protocol MQTT i connexió ThingSpeak

MQTT és una arquitectura de publicació / subscripció que es desenvolupa principalment per connectar amplada de banda i dispositius amb restricció de potència a través de xarxes sense fils. És un protocol senzill i lleuger que s’executa a través de sockets TCP / IP o WebSockets. MQTT mitjançant WebSockets es pot protegir amb SSL. L’arquitectura de publicació / subscripció permet enviar missatges als dispositius client sense que el dispositiu hagi de fer una consulta contínua del servidor.

El broker MQTT és el punt central de comunicació i s’encarrega d’enviar tots els missatges entre els remitents i els receptors legítims. Un client és qualsevol dispositiu que es connecta al corredor i pot publicar o subscriure's a temes per accedir a la informació. Un tema conté la informació d’encaminament del corredor. Cada client que vol enviar missatges els publica a un tema determinat i cada client que vol rebre missatges es subscriu a un tema determinat. El broker lliura tots els missatges amb el tema coincident als clients adequats.

ThingSpeak ™ té un corredor MQTT a l'URL mqtt.thingspeak.com i el port 1883. El corredor ThingSpeak admet la publicació MQTT i la subscripció a MQTT.

En el nostre cas, utilitzarem: MQTT Publish

La figura descriu l'estructura del tema. Per publicar, cal la clau API d’escriptura. El corredor reconeix una sol·licitud de CONNECT correcta amb CONNACK.

El protocol MQTT és compatible amb una biblioteca integrada als fitxers binaris Micropython: aquest protocol es pot utilitzar per enviar dades des del vostre ESP8266, mitjançant WIFI, a una base de dades de núvol lliure.

Utilitzem la biblioteca umqtt.simple:

des de umqtt.simple import MQTTClient

I coneixent el nostre ID de SERVEI, és possible crear el nostre objecte client MQTT:

SERVIDOR = "mqtt.thingspeak.com"

client = MQTTClient ("umqtt_client", SERVER)

Ara, tenint a mà les vostres credencials de ThingSpeak:

CHANNEL_ID = "EL TEU ID DE CANAL"

WRITE_API_KEY = "LA TEVA CLAVE AQUÍ"

Creem el nostre "Tema" MQTT:

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

Aconseguim que les nostres dades s’enviïn al servei IoT de ThingSpeak, mitjançant la funció creada i associem la seva resposta a variables de dades específiques:

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

Amb aquestes variables actualitzades, podem crear la nostra "Càrrega útil MQTT":

càrrega útil = "field1 =" + str (temp) + "& field2 =" + str (hum) + "& field3 =" + str (extTemp) + "& field4 =" + str (lum) + "& field5 =" + str (butSts)

I ja està! Estem preparats per enviar dades a ThinsSpeak, simplement utilitzant les 3 línies de codi següents:

client.connect ()

client.publish (tema, càrrega útil) client.disconnect ()

Ara, si aneu a la pàgina del vostre canal (com la meva anterior), veureu que cadascun dels cinc camps tindrà dades relacionades amb els vostres sensors.

Pas 10: registre de dades del sensor

Ara, ja que sabem que amb només unes poques línies de codi és possible carregar dades a un servei IoT, creem una funció de bucle per fer-la automàticament a un interval de temps regular (similar al que hem fet amb "Dades locals" ").

Utilitzant la mateixa variable (PUB_TIME_SEC), declarada anteriorment, una simple funció principal per capturar contínuament les dades, registrar-les al nostre canal seria:

mentre que és cert:

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 (tema, càrrega útil) client.disconnect () time.sleep (PUB_TIME_SEC)

Tingueu en compte que només cal actualitzar la "càrrega útil", una vegada que el "tema" estigui relacionat amb la credencial del nostre canal i no canviarà.

Buscant la pàgina del canal ThingSpeak, observareu que les dades es carregaran contínuament a cada camp. Podeu cobrir l'LDR, posar la mà als sensors de temperatura / fred, prémer el botó, etc. i veure com el canal automàticament "registrarà" aquestes dades per a futures anàlisis.

Normalment, per al registre de dades, hem d’intentar consumir el mínim d’energia possible, de manera que no faríem servir el LED ni la pantalla localment. A més, és comú amb els dispositius ESP, posar-los en "son profund", on el microprocessador estarà en el seu estat d'energia mínima fins que arribi el moment de capturar dades i enviar-les a la plataforma IoT.

Però, un cop aquí la idea està aprenent, incloguem també la pantalla i el LED com abans. Fent això, la nostra funció "registrador" serà:

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 (tema, càrrega útil) client.disconnect () time.sleep (PUB_TIME_SEC) blinkLed (3) displayClear ()

L'escriptura completa de MicroPython es pot trobar aquí: dataLoggerTS_EXT.py i el bloc de notes Jupyter que es va utilitzar per al desenvolupament també es poden trobar aquí: IoT ThingSpeak Data Logger EXT.ipynb.

Per carregar l'script a ESP, al terminal utilitzeu l'ordre:

ampy va posar dataLoggerTS.py /main.py

I premeu el botó ESP-reset. Tindreu l’ESP capturant dades i registrant-les a ThingSpeak.com fins que es mantingui premut el fons (espereu que el LED parpellegi 3 vegades i l’OLED s’apagui).

Pas 11: l'aplicació ThingView

Les dades registrades es poden visualitzar directament al lloc de ThingSpeak.com o mitjançant una APP, per exemple, ThingsView.

ThingView és una aplicació desenvolupada per CINETICA, que us permet visualitzar els vostres canals de ThingSpeak d’una manera senzilla, només cal que introduïu l’identificador del canal i estigueu a punt.

Per als canals públics, l'aplicació respectarà la configuració de Windows: color, escala de temps, tipus de gràfic i nombre de resultats. La versió actual admet gràfics de línies i columnes, els gràfics de spline es mostren com a gràfics de línies.

Per als canals privats, les dades es mostraran mitjançant la configuració predeterminada, ja que no hi ha manera de llegir la configuració de Windows privada només amb la clau API.

L'aplicació ThingView es pot descarregar per a ANDROID i IPHONE.

Pas 12: Conclusió

Com sempre, espero que aquest projecte pugui ajudar els altres a endinsar-se en l’apassionant món de l’electrònica.

Per obtenir més informació i el codi final, visiteu el meu dipòsit de GitHub: IoT_TS_MQTT

Per obtenir més projectes, visiteu el meu bloc: MJRoBot.org

Saluts del sud del món!

Ens veiem a la meva propera instrucció!

Gràcies, Marcelo