IoT Made Ease: ESP-MicroPython-MQTT-ThingSpeak: 12 trin

2024 Forfatter: John Day | [email protected]. Sidst ændret: 2024-01-30 08:28

I min tidligere tutorial, MicroPython på ESP ved hjælp af Jupyter, lærte vi, hvordan man installerer og kører MicroPython på en ESP -enhed. Ved hjælp af Jupyter Notebook som vores udviklingsmiljø lærte vi også at læse fra sensorer (temperatur, luftfugtighed og lysstyrke). Vi bruger flere kommunikationsprotokoller og metoder, Analog, Digital, 1-Wire og I2C, denne sidste til at vise vores fangede data på et OLED -display.

Nu, på denne vejledning ved hjælp af en MQTT -protokol, får vi alle fangede data og sender dem til en IoT -service, ThingSpeak.com og til en mobilapp (Thingsview), hvor vi kan logge og lege med data.

Her er blokdiagrammet for vores projekt:

Trin 1: BoM - regning af materiale

1. NodeMCU - 8,39 US $
2. DHT22 temperatur- og relativ luftfugtighedssensor - USD 9,95
3. DS18B20 Vandtæt temperatursensor - USD 5,95
4. OLED Display SSD1366- USD 8,99 (valgfrit)
5. LDR (1x)
6. LED'er (1x) (valgfrit)
7. Trykknap (1x)
8. Modstand 4K7 ohm (2x)
9. Modstand 10K ohm (1x)
10. Modstand 220 ohm (1x)

Trin 2: Hw

Den Hw, som vi grundlæggende vil bruge her, er den samme, der blev brugt på selvstudiet: Micropython på ESP Brug af Jupyter. Se den for alle HW -forbindelser.

Undtagelsen er Servoen, at vi ikke vil blive brugt i dette projekt.

Ovenfor kan du se hele HW. Tilslut enhederne som vist der.

Trin 3: Micropython, REPL, Jupyter

Du skal have en Micropython -tolk indlæst på din ESP -enhed. Når den er indlæst, skal du programmere din ESP ved hjælp af alle tilgængelige tilgængelige måder/IDE'er, f.eks.:

• REPL
• Jupyter notesbog
• Mu
• ESPCut (kun Windows)
• … etc

På min vejledning, Micropython på ESP Ved hjælp af Jupyter, forklarede jeg, hvordan man downloader og installerer MicroPython -tolk, ESPTool til at administrere ESP -enheder, og hvordan man bruger Jupyter Notebook som et udviklingsmiljø. Brug gerne det, der er mere behageligt for dig.

Jeg laver normalt al udvikling på Jupyter Notebook, og når jeg får den sidste kode, kopierer jeg dem til Geany og indlæser den på min ESP ved hjælp af Ampy.

Trin 4: Sensorer

Lad os installere bibliotekerne, definere GPIO, oprette objekter, funktioner for alle sensorer individuelt:

A. DHT (temperatur og fugtighed)

Lad os installere DHT -biblioteket og oprette et objekt:

fra dht import DHT22

fra maskineimport Pin dht22 = DHT22 (Pin (12))

Opret nu en funktion til at læse DHT -sensor:

def readDht ():

dht22.measure () return dht22.temperature (), dht22.fugtighed () Test DHT -funktion

print (readDht ())

Resultatet skal f.eks. Være:

(17.7, 43.4)

B. DS18B20 (ekstern temperatur)

Lad os installere bibliotekerne og oprette et objekt:

import onewire, ds18x20

importtid # Definer, hvilken pin 1-wire-enheden skal tilsluttes ==> pin 2 (D4) dat = Pin (2) # opret onewire-objektet ds = ds18x20. DS18X20 (onewire. OneWire (dat)) Scan efter enheder på bu

sensorer = ds.scan ()

print ('fundet enheder:', sensorer)

Det udskrevne resultat er ikke rigtig vigtigt, hvad vi får brug for er den første registrerede sensor: sensorer [0]. Og nu kan vi bygge en funktion til at læse sensordata:

def readDs ():

ds.convert_temp () time.sleep_ms (750) returnerer ds.read_temp (sensorer [0])

Det er altid vigtigt at teste sensoren ved hjælp af den oprettede funktion

print (readDs ()) Hvis du får en temperaturværdi, er din kode korrekt

17.5

C. LDR (lysstyrke)

LDR'en bruger den analoge pin i vores ESP (den er kun en i tilfælde af ESP8266 og flere til ESP32).

Se min ESP32 -vejledning for detaljer.

Samme som gjort før:

# importbibliotek

fra maskineimport ADC # Definer objekt adc = ADC (0) En simpel funktion: adc.read () kan bruges til at aflæse ADC -værdien. Men husk, at den interne ADC vil konvertere spændinger mellem 0 og 3,3V i korrespondent digitale værdier, der varierer fra 0 til 1023. Når vi er interesseret i "Luminosity", vil vi betragte Max light som den maksimale registrerede værdi fra sensoren (i min case 900) og minimum lys, der i mit tilfælde er 40. Med disse værdier kan vi "kortlægge" værdien fra 40 til 900 i 0 til 100% af lysstyrken. Til det vil vi oprette en ny funktion

def readLdr ():

lumPerct = (adc.read ()-40)*(10/86) # konverter i procent ("kort") returrunde (lumPerct)

Du bør teste funktionen ved hjælp af print (readLDR ()). Resultatet skal være et heltal mellem o og 100.

D. Tryk-knap (digital indgang)

Her bruger vi en trykknap som en digital sensor, men det kan være et "ekko" af en aktuator (for eksempel en pumpe, der blev tændt/slukket).

# definer pin 13 som en input og aktiver en intern pull-up modstand:

knap = Pin (13, Pin. IN, Pin. PULL_UP) # Funktion til at læse knaptilstand: def readBut (): return -knap. værdi ()

Du kan teste knappen, der læser funktionsudskrivningen (readBut ()). Uden at trykke på resultatet skal være "1". Ved at trykke på knappen skal resultatet være "0"

Trin 5: Registrering og visning lokalt af alle sensordata

Nu hvor vi har oprettet en funktion til hver sensor, lad os oprette den sidste, der vil læse dem alle på samme tid:

def colectData ():

temp, hum, = readDht () extTemp = readDs () lum = readLdr () butSts = readBut () return temp, hum, extTemp, lum, butSts Nu hvis du bruger

print (colectData ())

Vil resultere i en tuple, der indeholder alle indfangede data fra sensorer:

(17.4, 45.2, 17.3125, 103, 1)

Vi kan også valgfrit vise disse data på et lokalt display:

# importer bibliotek og opret objekt i2c

fra maskineimport I2C i2c = I2C (scl = Pin (5), sda = Pin (4)) # importbibliotek og opret objekt oled import ssd1306 i2c = I2C (scl = Pin (5), sda = Pin (4)) oled = ssd1306. SSD1306_I2C (128, 64, i2c, 0x3c) # opret en funktion: 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 () # vis data ved hjælp af funktionen displayData (temp, hum, extTemp, lum, butSts)

Som en valgmulighed vil jeg også inkludere LED'en, der skal være TÆNDT, når vi begynder at læse sensorer og slukker, når dataene vises. Hvis du gør dette, hjælper det med at bekræfte, at programmet fungerer, når ESP'en er afbrudt fra pc'en og kører automatisk.

Så hovedfunktionen ville være:

# Hovedfunktion til at læse alle sensorer

def main (): # visningsdata med en funktion led.on () temp, hum, extTemp, lum, butSts = colectData () displayData (temp, hum, extTemp, lum, butSts) led.off ()

Så når vi udfører main (), får vi sensordata vist på OLED som vist på billedet.

Trin 6: Kørsel af den lokale stationskode ved ESP-opstart

Vi kan have alt det, der er udviklet indtil nu, på en enkelt fil, der skal eksekveres af vores ESP.

Lad os åbne en hvilken som helst teksteditor og forbi den hele kode:

# importer generelle biblioteker

fra maskine import Pin import tid # definer pin 0 som output led = Pin (0, Pin. OUT) # DHT fra dht import DHT22 dht22 = DHT22 (Pin (12)) # Funktion til at læse DHT def readDht (): dht22.measure () returner dht22.temperatur (), dht22.humidity () # DS18B20 import onewire, ds18x20 # Definer hvilken pin 1-wire enheden skal tilsluttes ==> pin 2 (D4) dat = Pin (2) # Opret onewire objekt ds = ds18x20. DS18X20 (onewire. OneWire (dat)) # scan efter enheder på bussensorerne = ds.scan () # funktion til at læse DS18B20 def readDs (): ds.convert_temp () time.sleep_ms (750) retur runde (ds.read_temp (sensorer [0]), 1) # LDR fra maskineimport ADC # Definer objekt adc = ADC (0) # funktion til at læse lysstyrke def readLdr (): lumPerct = (adc.read ()-40) *(10/86) # konverter i procent ("kort") returrunde (lumPerct) # definer pin 13 som input og aktiver en intern Pull-up-modstand: knap = Pin (13, Pin. IN, Pin. PULL_UP) # Funktion til at læse knapstilstand: def readBut (): return -knap. Værdi () # Funktion til at læse alle data: def cole ctData (): temp, hum, = readDht () extTemp = readDs () lum = readLdr () butSts = readBut () return temp, hum, extTemp, lum, butSts # import library og opret objekt i2c fra maskineimport I2C i2c = I2C (scl = Pin (5), sda = Pin (4)) # import bibliotek og opret objekt oled import ssd1306 i2c = I2C (scl = Pin (5), sda = Pin (4)) oled = ssd1306. SSD1306_I2C (128, 64, i2c, 0x3c) # opret en funktion: 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. tekst ("Lumin:" + str (lum) + "%", 0, 43) oled.text ("Knap:" + str (butSts), 0, 57) oled.show () # Hovedfunktion til at læse alle sensorer def main (): # displaydata med en funktion led.on () temp, hum, extTemp, lum, butSts = colectData () displayData (temp, hum, extTemp, lum, butSts) led.off () '' '-- ----- kør hovedfunktion -------- '' 'main ()

Gem det, f.eks. Som localData.py.

For at køre denne kode direkte på din terminal skal du bruge Ampy.

Lad os først informere Ampy om vores serielle port på Terminal:

eksporter AMPY_PORT =/dev/tty. SLAB_USBtoUART

Nu kan vi se de filer, der er inde i vores ESP -rodmappe:

ampy ls

Som svar får vi boot.py, det er den første fil, der kører i systemet.

Lad os nu bruge Ampy til at indlæse vores python Script LocalData.py som /main.py, så scriptet kører lige efter opstart:

ampy satte localData.py /main /py

Hvis vi bruger kommandoforstærkeren ls nu, vil du se 2 filer inde i ESP’en: boot.py og main.py

Nulstilling af din ESP vil få programmet localData.py til at køre automatisk og vise sensordata på displayet.

Ovenstående terminaludskrivningsskærm viser, hvad vi har gjort.

Med ovenstående kode vises displayet kun én gang, men vi kan definere en loop på hovedfunktionen (), der viser data om hvert defineret tidsinterval (PUB_TIME_SEC), og for eksempel indtil vi trykker på knappen:

# loop få data, indtil der trykkes på knappen

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

Variablen PUB_TIME_SEC skal angives inden det tidspunkt, du ønsker dine prøver.

For at forbedre vores kode mere, ville det være godt at informere om, at vi vil gå ud af sløjfen, for det vil vi definere 2 nye generelle funktioner, en for at rydde displayet og en anden for at blinke LED'en et bestemt antal gange.

# Tydeligt display:

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 () søvn (0,5)

Så vi kan nu omskrive vores vigtigste () funktion:

mens knappen. værdi ():

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

Den endelige kode kan downloades fra min GitHub: localData.py og også Jupyter Notebook, der bruges til udvikling af fuld kode: Jupyter Local Data Development.

Trin 7: Tilslutning af ESP til lokal WiFi

Netværksmodulet bruges til at konfigurere WiFi -forbindelsen. Der er to WiFi -grænseflader, en til stationen (når ESP8266 opretter forbindelse til en router) og en til adgangspunktet (for andre enheder, der skal oprette forbindelse til ESP8266). Her vil vores ESP blive forbundet til det lokale netværk. Lad os ringe til biblioteket og definere vores netværksoplysninger:

import netværk

WiFi_SSID = "DIT SSID" WiFi_PASS = "DIT KODEORD"

Funktionen herunder kan bruges til at forbinde ESP til dit lokale netværk:

def do_connect ():

wlan = network. WLAN (network. STA_IF) wlan.active (True) hvis ikke wlan.isconnected (): print ('forbindelse til netværk …') wlan.connect (WiFi_SSID, WiFi_SSID) mens ikke wlan.isconnected (): print print ('netværkskonfiguration:', wlan.ifconfig ())

Når du kører funktionen, kan du få IP -adressen som følge heraf:

do_connect ()

Resultatet bliver:

netværkskonfiguration: ('10.0.1.2 ',' 255.255.255.0 ', '10.0.1.1', '10.0.1.1 ')

I mit tilfælde var 10.0.1.2 ESP IP -adressen.

Trin 8: The ThingSpeak

På dette tidspunkt lærte vi at fange data fra alle sensorer og vise dem på vores OLED. Nu er det tid til at se, hvordan man sender disse data til en IoT -platform, ThingSpeak.

Lad os begynde!

Først skal du have en konto på ThinkSpeak.com. Følg derefter instruktionerne for at oprette en kanal og notere dit kanal -id og skrive API -nøgle.

Ovenfor kan du se de 5 felter, der vil blive brugt på vores kanal.

Trin 9: MQTT -protokol og ThingSpeak -forbindelse

MQTT er en publish/subscribe-arkitektur, der primært er udviklet til at forbinde båndbredde og strømbegrænsede enheder over trådløse netværk. Det er en enkel og let protokol, der kører over TCP/IP -sockets eller WebSockets. MQTT over WebSockets kan sikres med SSL. Udgiv/abonner -arkitekturen gør det muligt at skubbe meddelelser til klientenhederne, uden at enheden kontinuerligt behøver at polle serveren.

MQTT -mægleren er det centrale kommunikationspunkt, og den har ansvaret for at sende alle meddelelser mellem afsenderne og de retmæssige modtagere. En klient er enhver enhed, der opretter forbindelse til mægleren og kan offentliggøre eller abonnere på emner for at få adgang til oplysningerne. Et emne indeholder routingsoplysninger for mægleren. Hver klient, der ønsker at sende meddelelser, udgiver dem til et bestemt emne, og hver klient, der ønsker at modtage beskeder, abonnerer på et bestemt emne. Mægleren leverer alle meddelelser med det matchende emne til de relevante klienter.

ThingSpeak ™ har en MQTT -mægler på URL -adressen mqtt.thingspeak.com og port 1883. ThingSpeak -mægleren understøtter både MQTT -udgivelse og MQTT -abonnement.

I vores tilfælde vil vi bruge: MQTT Publish

Figuren beskriver emnestrukturen. Skriv API -nøglen skal udgives. Mægleren anerkender en korrekt CONNECT -forespørgsel med CONNACK.

MQTT-protokollen understøttes i et indbygget bibliotek i Micropython-binarierne-denne protokol kan bruges til at sende data fra din ESP8266, over WIFI, til en gratis clouddatabase.

Lad os bruge umqtt.simple -biblioteket:

fra umqtt.simple import MQTTClient

Og ved at kende vores SERVER ID, er det muligt at oprette vores MQTT -klientobjekt:

SERVER = "mqtt.thingspeak.com"

klient = MQTTClient ("umqtt_client", SERVER)

Nu har du dine ThingSpeak -legitimationsoplysninger til rådighed:

CHANNEL_ID = "DIT KANAL -ID"

WRITE_API_KEY = "DIN NØGLE HER"

Lad os oprette vores MQTT "Emne":

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

Lad os få vores data sendt til ThingSpeak IoT Service ved hjælp af den oprettede funktion og knytte dens svar til specifikke datavariabler:

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

Med disse variabler opdateret, kan vi oprette vores "MQTT nyttelast":

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

Og det er det! Vi er klar til at sende data til ThinsSpeak ved blot at bruge de 3 linjer med kode herunder:

client.connect ()

client.publish (emne, nyttelast) client.disconnect ()

Hvis du nu går til din kanalside (som min ovenfor), vil du se, at hvert af de 5 felter har data relateret til dine sensorer.

Trin 10: Sensordatalogger

Når vi nu ved, at det kun er få linjer med kode, det er muligt at uploade data til en IoT -tjeneste, lad os oprette en loop -funktion for at gøre det automatisk med et regelmæssigt tidsinterval (svarende til det, vi har gjort med "Lokale data ").

Ved hjælp af den samme variabel (PUB_TIME_SEC), der blev erklæret før, ville en simpel hovedfunktion til løbende at indsamle data, logge dem på vores kanal være:

mens det er sandt:

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

Bemærk, at kun "nyttelast" skal opdateres, når "emne" er relateret til vores kanaloplysninger og ikke ændres.

Når du leder efter din ThingSpeak -kanalside, vil du bemærke, at dataene indlæses kontinuerligt i hvert felt. Du kan dække LDR'en, lægge hånden på temp/hum -sensorer, trykke på knappen osv. Og se, hvordan kanalen automatisk "logger" disse data til fremtidig analyse.

Normalt, for datalogning, bør vi prøve at bruge så mindre strøm som muligt, så vi ville ikke bruge LED'en eller displayet lokalt. Det er også almindeligt med ESP -enheder, sæt dem på "dyb søvn", hvor mikroprocessoren vil være på sin tilstand af minimal energi, indtil det er tid til at indsamle data og sende dem til IoT -platformen.

Men når ideen her er ved at lære, skal vi også inkludere display og LED som vi gjorde før. Hvis du gør det, vil vores "logger" -funktion være:

mens knappen. værdi ():

led.on () temp, hum, extTemp, lum, butSts = colectData () displayData (temp, hum, extTemp, lum, butSts) led.off () temp, hum, extTemp, lum, butSts = colectData () nyttelast = "field1 ="+str (temp)+"& field2 ="+str (hum)+"& field3 ="+str (extTemp)+"& field4 ="+str (lum)+"& field5 ="+str (butSts) klient.connect () client.publish (emne, nyttelast) client.disconnect () time.sleep (PUB_TIME_SEC) blinkLed (3) displayClear ()

Det komplette microPython -script kan findes her: dataLoggerTS_EXT.py og Jupyter -notesbogen, der blev brugt til udvikling, kan også findes her: IoT ThingSpeak Data Logger EXT.ipynb.

For at uploade scriptet til ESP skal du bruge kommandoen på din terminal:

ampy put dataLoggerTS.py /main.py

Og tryk på ESP - reset -knappen. Du får ESP til at fange data og logge dem på ThingSpeak.com, indtil bunden holdes nede (vent på, at LED'en blinker 3 gange, og OLED'en slukkes).

Trin 11: ThingView -appen

De loggede data kan ses direkte på ThingSpeak.com -webstedet eller via en APP, f.eks. ThingsView!

ThingView er en APP udviklet af CINETICA, der giver dig mulighed for at visualisere dine ThingSpeak -kanaler på en nem måde, bare indtast kanal -id'et, og du er klar til at gå.

For offentlige kanaler vil programmet respektere dine vinduesindstillinger: farve, tidsskala, diagramtype og antal resultater. Den nuværende version understøtter linie- og søjlediagrammer, spline -diagrammerne vises som stregdiagrammer.

For private kanaler vises dataene ved hjælp af standardindstillingerne, da der ikke er mulighed for at læse de private vinduesindstillinger med API -nøglen.

ThingView -appen kan downloades til ANDROID og IPHONE.

Trin 12: Konklusion

Som altid håber jeg, at dette projekt kan hjælpe andre med at finde vej til den spændende elektronikverden!

For detaljer og endelig kode, besøg venligst mit GitHub -depot: IoT_TS_MQTT

For flere projekter, besøg min blog: MJRoBot.org

Saludos fra den sydlige del af verden!

Vi ses i min næste instruerbare!

Tak skal du have, Marcelo