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

2024 Forfatter: John Day | [email protected]. Sist endret: 2024-01-30 11:23

I min forrige opplæring, MicroPython på ESP ved hjelp av Jupyter, lærte vi hvordan vi installerer og kjører MicroPython på en ESP -enhet. Ved å bruke Jupyter Notebook som vårt utviklingsmiljø lærte vi også å lese fra sensorer (temperatur, fuktighet og lysstyrke). Vi bruker flere kommunikasjonsprotokoller og metoder, Analog, Digital, 1-Wire og I2C, denne siste for å vise våre fangede data på en OLED -skjerm.

Nå, på denne opplæringen ved hjelp av en MQTT -protokoll, får vi alle fangede data og sender dem til en IoT -tjeneste, ThingSpeak.com og til en mobilapp (Thingsview), hvor vi kan logge og leke med data.

Her er blokkdiagrammet for prosjektet vårt:

Trinn 1: BoM - materialregning

1. NodeMCU - 8,39 dollar
2. DHT22 temperatur- og relativ fuktighetssensor - USD 9,95
3. DS18B20 vanntett temperatursensor - USD 5,95
4. OLED Display SSD1366- USD 8,99 (valgfritt)
5. LDR (1x)
6. Lysdioder (1x) (valgfritt)
7. Trykknapp (1x)
8. Motstand 4K7 ohm (2x)
9. Motstand 10K ohm (1x)
10. Motstand 220 ohm (1x)

Trinn 2: Hw

Hw som vi skal bruke her er i utgangspunktet det samme som ble brukt på opplæringen: Micropython på ESP Using Jupyter. Se den for alle HW -tilkoblinger.

Unntaket er Servoen, at vi ikke skal brukes i dette prosjektet.

Over kan du se hele HW. Koble til enhetene som vist der.

Trinn 3: Micropython, REPL, Jupyter

Du må ha en Micropython -tolk lastet på ESP -enheten. Når den er lastet inn, bør du programmere ESP -en din på en hvilken som helst tilgjengelig måte/IDE som er tilgjengelig, for eksempel:

• REPL
• Jupyter Notebook
• Mu
• ESPCut (bare Windows)
• … etc

I min opplæring, Micropython på ESP Ved hjelp av Jupyter, forklarte jeg hvordan du laster ned og installerer MicroPython -tolk, ESPTool for å administrere ESP -enheter og hvordan du bruker Jupyter Notebook som et utviklingsmiljø. Bruk gjerne det som er mer behagelig for deg.

Jeg gjør vanligvis all utvikling på Jupyter Notebook, og når jeg får den endelige koden, kopierer jeg dem til Geany og laster den på ESP -en min ved hjelp av Ampy.

Trinn 4: Sensorer

La oss installere bibliotekene, definere GPIO, lage objekter, funksjoner for alle sensorer individuelt:

A. DHT (temperatur og fuktighet)

La oss installere DHT -biblioteket og lage et objekt:

fra dht import DHT22

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

Lag nå en funksjon for å lese DHT -sensor:

def readDht ():

dht22.measure () retur dht22.temperatur (), dht22.fuktighet () Test DHT -funksjonen

print (readDht ())

Resultatet skal for eksempel være:

(17.7, 43.4)

B. DS18B20 (ekstern temperatur)

La oss installere bibliotekene og lage et objekt:

importere onewire, ds18x20

importtid # Definer hvilken pinne 1-lederenheten skal tilkobles ==> pin 2 (D4) dat = Pin (2) # lag onewire-objektet ds = ds18x20. DS18X20 (onewire. OneWire (dat)) Søk etter enheter på bu

sensorer = ds.scan ()

print ('funnet enheter:', sensorer)

Det trykte resultatet er egentlig ikke viktig. Det vi trenger er den første sensoren: sensorer [0]. Og nå kan vi bygge en funksjon for å lese sensordata:

def readDs ():

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

Det er alltid viktig å teste sensoren ved hjelp av den opprettede funksjonen

print (readDs ()) Hvis du får en temperaturverdi, er koden riktig

17.5

C. LDR (lysstyrke)

LDR vil bruke den analoge pinnen til ESP -en vår (den er bare én for ESP8266 og flere for ESP32).

Se min ESP32 -opplæring for detaljer.

Samme som gjort før:

# importbibliotek

fra maskinimport ADC # Definer objekt adc = ADC (0) En enkel funksjon: adc.read () kan brukes til å lese ADC -verdien. Men husk at den interne ADC vil konvertere spenninger mellom 0 og 3.3V i korrespondent digitale verdier, som varierer fra 0 til 1023. Når vi er interessert i "Luminosity", vil vi betrakte Max light som maksimal fanget verdi fra sensoren (i min case 900) og minimumslys som i mitt tilfelle er 40. Med disse verdiene kan vi "kartlegge" verdien fra 40 til 900 i 0 til 100% av lysstyrken. For det vil vi lage en ny funksjon

def readLdr ():

lumPerct = (adc.read ()-40)*(10/86) # konvertere i prosent ("kart") returrunde (lumPerct)

Du bør teste funksjonen ved å bruke print (readLDR ()). Resultatet skal være et heltall mellom o og 100.

Trykknapp (digital inngang)

Her bruker vi en trykknapp som en digital sensor, men det kan være et "ekko" av en aktuator (for eksempel en pumpe som ble slått PÅ/AV).

# definer pin 13 som en inngang og aktiver en intern Pull-up-motstand:

knapp = Pin (13, Pin. IN, Pin. PULL_UP) # Funksjon for å lese knappestatus: def readBut (): retur -knapp. verdi ()

Du kan teste knappen som leser funksjonsutskriften (readBut ()). Uten å trykke på resultatet skal være "1". Ved å trykke på knappen skal resultatet være "0"

Trinn 5: Fange og vise lokalt alle sensordata

Nå som vi har opprettet en funksjon for hver sensor, la oss lage den siste som vil lese dem alle samtidig:

def colectData ():

temp, hum, = readDht () extTemp = readDs () lum = readLdr () butSts = readBut () returtemp, hum, extTemp, lum, butSts Nå hvis du bruker

print (colectData ())

Vil resultere i en tupel som inkluderer alle fangede data fra sensorer:

(17.4, 45.2, 17.3125, 103, 1)

Vi kan også valgfritt vise disse dataene på en lokal skjerm:

# importer bibliotek og lag objekt i2c

fra maskinimport I2C i2c = I2C (scl = Pin (5), sda = Pin (4)) # importbibliotek og opprett objekt oled import ssd1306 i2c = I2C (scl = Pin (5), sda = Pin (4)) oled = ssd1306. SSD1306_I2C (128, 64, i2c, 0x3c) # opprett en funksjon: 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 () # vise data ved hjelp av funksjonen displayData (temp, hum, extTemp, lum, butSts)

Som et alternativ vil jeg også inkludere lysdioden for å være PÅ når vi begynner å lese sensorer, og gå AV etter at dataene vises. Dette vil bidra til å bekrefte at programmet fungerer når vi har ESP koblet fra PC og kjører automatisk.

Så hovedfunksjonen ville være:

# Hovedfunksjon for å lese alle sensorer

def main (): # display data with a function led.on () temp, hum, extTemp, lum, butSts = colectData () displayData (temp, hum, extTemp, lum, butSts) led.off ()

Så når vi kjører main (), får vi sensordataene vist på OLED som vist på bildet.

Trinn 6: Kjøre Local Station Code ved ESP-oppstart

Vi kan ha alt som er utviklet så langt på en enkelt fil som skal kjøres av vår ESP.

La oss åpne en hvilken som helst tekstredigerer og fortid på den hele koden:

# importer generelle biblioteker

fra maskinimport Pinimporttid # definere pin 0 som output led = Pin (0, Pin. OUT) # DHT fra dht import DHT22 dht22 = DHT22 (Pin (12)) # Funksjon for å lese DHT def readDht (): dht22.measure () returner dht22.temperatur (), dht22.humidity () # DS18B20 import onewire, ds18x20 # Definer hvilken pinne 1-wire enheten skal kobles til ==> pin 2 (D4) dat = Pin (2) # Lag onewire objekt ds = ds18x20. DS18X20 (onewire. OneWire (dat)) # søk etter enheter på bussensorene = ds.scan () # funksjon for å lese DS18B20 def readDs (): ds.convert_temp () time.sleep_ms (750) retur runde (ds.read_temp (sensorer [0]), 1) # LDR fra maskinimport ADC # Definer objekt adc = ADC (0) #funksjon for å lese lysstyrke def readLdr (): lumPerct = (adc.read ()-40) *(10/86) # konvertere i prosent ("kart") returrunde (lumPerct) # definere pinne 13 som en inngang og aktivere en intern Pull-up-motstand: knapp = Pin (13, Pin. IN, Pin. PULL_UP) # Funksjon for å lese knappestatus: def readBut (): retur -knapp. Verdi () # Funksjon for å lese alle data: def cole ctData (): temp, hum, = readDht () extTemp = readDs () lum = readLdr () butSts = readBut () retur temp, hum, extTemp, lum, butSts # import bibliotek og opprett objekt i2c fra maskinimport I2C i2c = I2C (scl = Pin (5), sda = Pin (4)) # import bibliotek og opprett objekt oled import ssd1306 i2c = I2C (scl = Pin (5), sda = Pin (4)) oled = ssd1306. SSD1306_I2C (128, 64, i2c, 0x3c) # opprett en funksjon: 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 ("Knapp:" + str (butSts), 0, 57) oled.show () # Hovedfunksjon for å lese alle sensorer def main (): # display data with a function led.on () temp, hum, extTemp, lum, butSts = colectData () displayData (temp, hum, extTemp, lum, butSts) led.off () '' '-- ----- kjøre hovedfunksjon -------- '' 'main ()

Lagre den, for eksempel som localData.py.

For å kjøre denne koden direkte på terminalen din trenger du Ampy.

Først, på Terminal, la oss informere Ampy om vår serielle port:

eksporter AMPY_PORT =/dev/tty. SLAB_USBtoUART

Nå kan vi se filene som er inne i ESP -rotkatalogen:

ampy ls

Som et svar får vi boot.py, det er den første filen som kjøres i systemet.

La oss nå bruke Ampy til å laste inn python -skriptet LocalData.py som /main.py, så skriptet vil kjøre like etter oppstart:

ampy sette localData.py /main /py

Hvis vi bruker kommandoforsterkeren ls nå, vil du se 2 filer inne i ESP: boot.py og main.py

Hvis du tilbakestiller ESP, vil programmet localData.py kjøre automatisk og vise sensordataene som vises.

Terminalutskriftsskjermen ovenfor viser hva vi har gjort.

Med koden ovenfor vil displayet bare bli vist én gang, men vi kan definere en sløyfe på hovedfunksjonen (), som vil vise data for hvert definert tidsintervall (PUB_TIME_SEC), og for eksempel til vi trykker på knappen:

# sløyfe for å få data til du trykker 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)

Variabelen PUB_TIME_SEC må deklareres innen du vil ha prøvene dine.

For å forbedre koden vår, er det godt å informere om at vi vil gå ut av sløyfen, for det vil vi definere 2 nye generelle funksjoner, en for å slette displayet og en annen for å blinke LED -en på et bestemt antall ganger.

# Klar skjerm:

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

Så vi kan nå skrive om vår hovedfunksjon ():

while -knapp. verdi ():

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 koden kan lastes ned fra min GitHub: localData.py og også Jupyter Notebook som brukes til utvikling av full kode: Jupyter Local Data Development.

Trinn 7: Koble ESP til lokal WiFi

Nettverksmodulen brukes til å konfigurere WiFi -tilkoblingen. Det er to WiFi -grensesnitt, ett for stasjonen (når ESP8266 kobles til en ruter) og ett for tilgangspunktet (for andre enheter for å koble til ESP8266). Her vil vår ESP bli koblet til det lokale nettverket. La oss ringe biblioteket og definere våre nettverksopplysninger:

importnettverk

WiFi_SSID = "DIN SSID" WiFi_PASS = "DITT PASSORD"

Funksjonen nedenfor kan brukes til å koble ESP til ditt lokale nettverk:

def do_connect ():

wlan = network. WLAN (network. STA_IF) wlan.active (True) hvis ikke wlan.isconnected (): print ('koble til nettverk …') wlan.connect (WiFi_SSID, WiFi_SSID) mens ikke wlan.isconnected (): pass print ('nettverkskonfigurasjon:', wlan.ifconfig ())

Når du kjører funksjonen, kan du få IP -adressen som et resultat:

do_connect ()

Resultatet blir:

nettverkskonfigurasjon: ('10.0.1.2 ',' 255.255.255.0 ', '10.0.1.1', '10.0.1.1 ')

I mitt tilfelle var 10.0.1.2 ESP IP -adressen.

Trinn 8: The ThingSpeak

På dette tidspunktet lærte vi hvordan vi kan fange data fra alle sensorer og vise dem på OLED -en vår. Nå er det på tide å se hvordan du sender disse dataene til en IoT -plattform, ThingSpeak.

La oss begynne!

Først må du ha en konto på ThinkSpeak.com. Følg deretter instruksjonene for å opprette en kanal og noter deg kanal -ID -en og skrive API -nøkkelen.

Over kan du se de 5 feltene som skal brukes på kanalen vår.

Trinn 9: MQTT -protokoll og ThingSpeak -tilkobling

MQTT er en publiser/abonner-arkitektur som først og fremst er utviklet for å koble båndbredde og strømbegrensede enheter over trådløse nettverk. Det er en enkel og lett protokoll som kjører over TCP/IP -kontakter eller WebSockets. MQTT over WebSockets kan sikres med SSL. Publiser/abonner -arkitekturen gjør det mulig å skyve meldinger til klientenhetene uten at enheten trenger å polle serveren kontinuerlig.

MQTT -megleren er det sentrale kommunikasjonspunktet, og den har ansvaret for å sende alle meldinger mellom avsenderne og de rettmessige mottakerne. En klient er enhver enhet som kobles til megleren og kan publisere eller abonnere på emner for å få tilgang til informasjonen. Et emne inneholder ruteinformasjon for megleren. Hver klient som ønsker å sende meldinger, publiserer dem til et bestemt emne, og hver klient som ønsker å motta meldinger, abonnerer på et bestemt emne. Megleren leverer alle meldinger med det matchende emnet til de riktige klientene.

ThingSpeak ™ har en MQTT -megler på URL -adressen mqtt.thingspeak.com og port 1883. ThingSpeak -megleren støtter både MQTT -publisering og MQTT -abonnement.

I vårt tilfelle vil vi bruke: MQTT Publish

Figuren beskriver emnestrukturen. Write API -nøkkelen kreves for å publisere. Megleren erkjenner en korrekt CONNECT -forespørsel med CONNACK.

MQTT-protokollen støttes i et innebygd bibliotek i Micropython-binærene-denne protokollen kan brukes til å sende data fra ESP8266, over WIFI, til en gratis skydatabase.

La oss bruke umqtt.simple -biblioteket:

fra umqtt. enkel import MQTTClient

Og når vi kjenner vår SERVER -ID, er det mulig å lage vårt MQTT -klientobjekt:

SERVER = "mqtt.thingspeak.com"

klient = MQTTClient ("umqtt_client", SERVER)

Nå, ha ThingSpeak -legitimasjonen din tilgjengelig:

CHANNEL_ID = "DIN KANAL ID"

WRITE_API_KEY = "DIN NØKKEL HER"

La oss lage vårt MQTT "emne":

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

La oss få dataene våre til å bli sendt til ThingSpeak IoT Service, ved hjelp av den opprettede funksjonen og knytte svaret til spesifikke datavariabler:

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

Med disse variablene oppdatert kan vi lage vår "MQTT nyttelast":

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

Og det er det! Vi er klare til å sende data til ThinsSpeak, bare ved å bruke de tre kodelinjene nedenfor:

client.connect ()

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

Hvis du går til kanalsiden din (som min ovenfor), vil du se at hvert av de fem feltene vil ha data relatert til sensorene dine.

Trinn 10: Sensordatalogger

Nå som vi vet at med bare noen få kodelinjer er det mulig å laste opp data til en IoT -tjeneste, la oss lage en loopfunksjon for å gjøre det automatisk med jevne mellomrom (i likhet med det vi har gjort med "Lokale data ").

Ved å bruke den samme variabelen (PUB_TIME_SEC), erklært før, ville en enkel hovedfunksjon for kontinuerlig å fange data, logge dem på kanalen vår:

mens det er sant:

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

Vær oppmerksom på at bare "nyttelasten" må oppdateres, når "emnet" er relatert til kanalens legitimasjon og vil ikke endres.

Når du ser etter ThingSpeak -kanalsiden din, vil du se at dataene vil bli lastet kontinuerlig til hvert felt. Du kan dekke LDR, legge hånden på temp/hum -sensorer, trykke på knappen osv. Og se hvordan kanalen automatisk "logger" disse dataene for fremtidig analyse.

Vanligvis, for datalogging, bør vi prøve å bruke så lite strøm som mulig, så vi ville ikke bruke LED -en eller skjermen lokalt. Det er også vanlig med ESP -enheter, legg dem på "dyp søvn", der mikroprosessoren vil være på sin minimale energitilstand til det er på tide å fange data og sende dem til IoT -plattformen.

Men når ideen er i ferd med å lære, kan vi også inkludere displayet og LED -en som vi gjorde før. Hvis du gjør det, vil vår "logger" -funksjon være:

while -knapp. verdi ():

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

Det komplette microPython -skriptet finner du her: dataLoggerTS_EXT.py og Jupyter -notatboken som ble brukt til utvikling kan også finnes her: IoT ThingSpeak Data Logger EXT.ipynb.

For å laste opp skriptet til ESP, bruk kommandoen på terminalen:

ampy sette dataLoggerTS.py /main.py

Og trykk på ESP - reset -knappen. Du vil få ESP til å fange data og logge dem på ThingSpeak.com til bunnen holdes inne (vent til LED -en blinker 3 ganger og OLED -en slås av).

Trinn 11: ThingView -appen

Dataene som er logget kan vises direkte på ThingSpeak.com -nettstedet eller via en APP, for eksempel ThingsView!

ThingView er en APP utviklet av CINETICA, som lar deg visualisere ThingSpeak -kanalene dine på en enkel måte. Bare skriv inn kanal -ID og du er klar til å gå.

For offentlige kanaler vil programmet respektere Windows -innstillingene dine: farge, tidsskala, diagramtype og antall resultater. Den nåværende versjonen støtter linje- og kolonnediagrammer, splinediagrammer vises som linjediagrammer.

For private kanaler vil dataene bli vist ved hjelp av standardinnstillingene, da det ikke er mulig å lese innstillingene for private vinduer bare med API -nøkkelen.

ThingView -appen kan lastes ned for ANDROID og IPHONE.

Trinn 12: Konklusjon

Som alltid håper jeg at dette prosjektet kan hjelpe andre å finne veien inn i den spennende elektronikkverdenen!

For detaljer og siste kode, vennligst besøk mitt GitHub -depot: IoT_TS_MQTT

For flere prosjekter, vennligst besøk bloggen min: MJRoBot.org

Hilsener fra den sørlige verden!

Se deg i min neste instruerbare!

Takk skal du ha, Marcelo