IoT maklik gemaak: ESP-MicroPython-MQTT-ding Spreek: 12 stappe

2025 Outeur: John Day | [email protected]. Laas verander: 2025-01-23 12:53

In my vorige tutoriaal, MicroPython op ESP met Jupyter, het ons geleer hoe om MicroPython op 'n ESP -toestel te installeer en uit te voer. Deur Jupyter Notebook as ons ontwikkelingsomgewing te gebruik, het ons ook geleer hoe om van sensors af te lees (temperatuur, humiditeit en ligsterkte). data op 'n OLED -skerm.

Op hierdie tutoriaal met behulp van 'n MQTT -protokol kry ons alle vasgelegde data en stuur dit na 'n IoT -diens, ThingSpeak.com en na 'n mobiele app (Thingsview), waar ons kan aanmeld en met data kan speel.

Hier is die blokdiagram van ons projek:

Stap 1: BoM - Staatsbrief

1. NodeMCU - US $ 8,39
2. DHT22 Temperatuur- en relatiewe humiditeitsensor - USD 9,95
3. DS18B20 waterdigte temperatuursensor - USD 5,95
4. OLED Display SSD1366- USD 8,99 (opsioneel)
5. LDR (1x)
6. LED's (1x) (opsioneel)
7. Drukknoppie (1x)
8. Weerstand 4K7 ohm (2x)
9. Weerstand 10K ohm (1x)
10. Weerstand 220 ohm (1x)

Stap 2: Die Hw

Die Hw wat ons hier basies sal gebruik, is dieselfde as in die tutoriaal: Micropython op ESP met Jupyter. Raadpleeg dit vir alle HW -verbindings.

Die uitsondering is die Servo, wat ons nie in hierdie projek sal gebruik nie.

Hierbo kan u die volledige HW sien. Koppel die toestelle soos daar aangedui.

Stap 3: Micropython, REPL, Jupyter

U moet 'n Micropython -tolk op u ESP -toestel hê. Sodra dit gelaai is, moet u u ESP programmeer op enige van die beskikbare maniere/IDE's, soos:

• REPL
• Jupyter Notebook
• Mu
• ESPCut (slegs Windows)
• … ens

In my tutoriaal, Micropython op ESP Met behulp van Jupyter, het ek uiteengesit hoe ek MicroPython -tolk, ESPTool kan aflaai en installeer om ESP -toestelle te bestuur en hoe om Jupyter Notebook as ontwikkelingsomgewing te gebruik. Gebruik gerus wat vir u gemakliker is.

Ek ontwikkel gewoonlik alle ontwikkelings op Jupyter Notebook, en sodra ek die finale kode kry, kopieer ek dit na Geany en laai dit op my ESP met behulp van Ampy.

Stap 4: Sensors

Kom ons installeer die biblioteke, definieer GPIO, skep voorwerpe, funksies vir alle sensors individueel:

A. DHT (temperatuur en humiditeit)

Laat ons die DHT -biblioteek installeer en 'n voorwerp skep:

vanaf dht invoer DHT22

vanaf masjieninvoer Pin dht22 = DHT22 (Pin (12))

Skep nou 'n funksie om die DHT -sensor te lees:

def readDht ():

dht22.measure () return dht22.temperature (), dht22. humiditeit () Toets die DHT -funksie

druk (readDht ())

Die resultaat moet byvoorbeeld wees:

(17.7, 43.4)

B. DS18B20 (eksterne temperatuur)

Laat ons die biblioteke installeer en 'n voorwerp skep:

voer een draad in, ds18x20

invoertyd # Definieer watter pen die 1-draads toestel gekoppel sal word ==> pen 2 (D4) dat = pen (2) # skep die onewire-voorwerp ds = ds18x20. DS18X20 (onewire. OneWire (dat)) Soek toestelle op die bu

sensors = ds.scan ()

print ('gevind toestelle:', sensors)

Die gedrukte resultaat is nie regtig belangrik nie; ons benodig die eerste sensor: sensors [0]. En nou kan ons 'n funksie bou om sensordata te lees:

def readDs ():

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

Dit is altyd belangrik om die sensor te toets met behulp van die geskepte funksie

druk (readDs ()) As u 'n temperatuurwaarde kry, is u kode korrek

17.5

C. LDR (helderheid)

Die LDR gebruik die analoog pen van ons ESP (dit is slegs een in die geval van ESP8266 en verskeie na ESP32).

Raadpleeg my ESP32 -tutoriaal vir meer inligting.

Dieselfde as voorheen gedoen:

# invoerbiblioteek

vanaf masjien invoer ADC # Definieer voorwerp adc = ADC (0) 'N Eenvoudige funksie: adc.read () kan gebruik word om die ADC -waarde te lees. Maar onthou dat die interne ADC spannings tussen 0 en 3.3V sal omskakel in korrespondente digitale waardes, wat wissel van 0 tot 1023. As ons eers geïnteresseerd is in 'Luminosity', sal ons Max light beskou as die maksimum vasgelegde waarde van die sensor (in my geval 900) en minimum lig wat in my geval 40 is. Met die waardes kan ons die waarde van 40 tot 900 in 0 tot 100% van die helderheid "in kaart bring". Hiervoor sal ons 'n nuwe funksie skep

def readLdr ():

lumPerct = (adc.read ()-40)*(10/86) # omskakel in persentasie ("kaart") retoerronde (lumPerct)

U moet die funksie toets met behulp van print (readLDR ()). Die resultaat moet 'n heelgetal tussen o en 100 wees.

D. Knoppie (digitale invoer)

Hier gebruik ons 'n drukknop as 'n digitale sensor, maar dit kan 'n 'eggo' van 'n aktuator wees ('n pomp wat byvoorbeeld AAN/UIT was).

# definieer pen 13 as 'n invoer en aktiveer 'n interne optrekweerstand:

knoppie = Pin (13, Pin. IN, Pin. PULL_UP) # Funksie om knoppie toestand te lees: def readBut (): return button.value ()

U kan die knoppie toets om die funksieafdruk te lees (readBut ()). Sonder om op die resultaat te druk, moet dit "1" wees. As u op die knoppie druk, moet die resultaat "0" wees

Stap 5: Vang en vertoon alle sensordata lokaal

Noudat ons een funksie vir elke sensor geskep het, laat ons die laaste een skep wat almal gelyktydig sal lees:

def colectData ():

temp, hum, = readDht () extTemp = readDs () lum = readLdr () butSts = readBut () retour temp, hum, extTemp, lum, butSts Nou as u dit gebruik

print (colectData ())

Dit sal 'n tupel bevat wat alle vasgelegde data van sensors insluit:

(17.4, 45.2, 17.3125, 103, 1)

Ons kan ook die data op 'n plaaslike skerm vertoon:

# voer biblioteek in en skep object i2c

vanaf masjien invoer I2C i2c = I2C (scl = Pin (5), sda = Pin (4)) # invoer biblioteek en skep voorwerp oled import ssd1306 i2c = I2C (scl = Pin (5), sda = Pin (4)) oled = ssd1306. SSD1306_I2C (128, 64, i2c, 0x3c) # skep 'n funksie: 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 () # vertoon data met behulp van die funksie displayData (temp, hum, extTemp, lum, butSts)

As opsie sal ek ook die LED insluit wat aan is wanneer ons sensors begin lees, en gaan af nadat die data vertoon is. As u dit doen, kan u bevestig dat die program werk as ons die ESP van die rekenaar losmaak en outomaties werk.

Die hooffunksie sou dus wees:

# Hooffunksie om alle sensors te lees

def main (): # vertoon data met 'n funksie led.on () temp, hum, extTemp, lum, butSts = colectData () displayData (temp, hum, extTemp, lum, butSts) led.off ()

Dus, by die uitvoering van main (), sal ons die sensorgegevens op OLED vertoon, soos op die foto getoon.

Stap 6: Gebruik die Local Station Code by ESP Start-up

Ons kan alles wat tot dusver ontwikkel is op 'n enkele lêer hê wat deur ons ESP uitgevoer moet word.

Laat ons 'n teksredakteur oopmaak en die hele kode daarin gebruik:

# invoer algemene biblioteke in

vanaf masjieninvoer Pin invoer tyd # definieer pen 0 as uitvoer gelei = Pin (0, Pin. OUT) # DHT vanaf dht invoer DHT22 dht22 = DHT22 (Pin (12)) # Funksie om DHT def readDht (): dht22.meas te lees () retour dht22.temperatuur (), dht22.humidity () # DS18B20 invoer op draad, ds18x20 # Definieer watter pen die 1-draads toestel gekoppel sal word ==> pen 2 (D4) dat = Pin (2) # Skep die draad voorwerp ds = ds18x20. DS18X20 (onewire. OneWire (dat)) # soek na toestelle op die bussensors = ds.scan () # funksie om DS18B20 def readDs (): ds.convert_temp () time.sleep_ms (750) terug te lees rond (ds.read_temp (sensors [0]), 1) # LDR van masjien invoer ADC # Definieer voorwerp adc = ADC (0) # funksie om helderheid def readLdr () te lees: lumPerct = (adc.read ()-40) *(10/86) # omskakel in persentasie ("kaart") terugrond (lumPerct) # definieer pen 13 as 'n invoer en aktiveer 'n interne optrekweerstand: knoppie = Pin (13, Pin. IN, Pin. PULL_UP) # Funksie om die knoppie se toestand te lees: def read But (): return button.value () # Funksie om alle data te lees: def cole ctData (): temp, hum, = readDht () extTemp = readDs () lum = readLdr () butSts = readBut () retour temp, hum, extTemp, lum, butSts # import library en skep voorwerp i2c uit masjien invoer I2C i2c = I2C (scl = Pin (5), sda = Pin (4)) # invoer biblioteek en skep voorwerp oled import ssd1306 i2c = I2C (scl = Pin (5), sda = Pin (4)) oled = ssd1306. SSD1306_I2C (128, 64, i2c, 0x3c) # skep 'n funksie: 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 () # Hooffunksie om alle sensors te lees def main (): # vertoon data met 'n funksie led.on () temp, hum, extTemp, lum, butSts = colectData () displayData (temp, hum, extTemp, lum, butSts) led.off () '' '- ----- voer hooffunksie uit -------- '' 'main ()

Stoor dit, byvoorbeeld as localData.py.

Om hierdie kode direk op u terminale uit te voer, benodig u Ampy.

Eerstens, op Terminal, laat ons Ampy ons Serial -poort inlig:

voer AMPY_PORT =/dev/tty. SLAB_USBtoUART uit

Nou kan ons die lêers in ons ESP -wortelgids sien:

ampy ls

As antwoord kry ons boot.py, dit is die eerste lêer wat in die stelsel uitgevoer word.

Kom ons gebruik Ampy om ons python Script LocalData.py as /main.py te laai, sodat die script net na die opstart sal loop:

ampy plaas localData.py /main /py

As ons nou die command amp ls gebruik, sien u 2 lêers in die ESP: boot.py en main.py

Deur u ESP terug te stel, word die program localData.py outomaties uitgevoer, met die vertoning van die sensordata.

Bogenoemde Terminal -afdrukskerm toon wat ons gedoen het.

Met die bogenoemde kode, sal die skerm slegs een keer vertoon word, maar ons kan 'n lus definieer oor die hooffunksie (), wat data oor elke gedefinieerde tydsinterval (PUB_TIME_SEC) wys, en byvoorbeeld totdat ons op die knoppie druk:

# lus om data te kry totdat die knoppie ingedruk word

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

Die veranderlike PUB_TIME_SEC moet verklaar word teen die tyd dat u u monsters wil hê.

Om ons kode meer te verbeter, is dit goed om in kennis te stel dat ons uit die kringloop sal gaan; daarvoor definieer ons 2 nuwe algemene funksies, een om die skerm skoon te maak en 'n ander om die LED 'n sekere aantal kere te knip.

# Duidelike vertoning:

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

Ons kan dus ons belangrikste () funksie herskryf:

terwyl knoppie.waarde ():

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

Die finale kode kan afgelaai word vanaf my GitHub: localData.py en ook die Jupyter Notebook wat gebruik word vir die ontwikkeling van volledige kode: Jupyter Local Data Development.

Stap 7: Koppel die ESP aan plaaslike WiFi

Die netwerkmodule word gebruik om die WiFi -verbinding op te stel. Daar is twee WiFi -koppelvlakke, een vir die stasie (wanneer die ESP8266 met 'n router verbind word) en een vir die toegangspunt (vir ander toestelle om aan die ESP8266 te koppel). Hier sal ons ESP gekoppel wees aan die plaaslike netwerk. Kom ons skakel die biblioteek en definieer ons netwerkbewyse:

invoer netwerk

WiFi_SSID = "U SSID" WiFi_PASS = "U WOORDWOORD"

Die onderstaande funksie kan gebruik word om die ESP aan u plaaslike netwerk te koppel:

def do_connect ():

wlan = netwerk. WLAN (netwerk. STA_IF) wlan.aktief (waar) indien nie wlan.aansluit (): druk ('maak verbinding met netwerk …') wlan.connect (WiFi_SSID, WiFi_SSID) terwyl dit nie wlan.aansluit (): slaag print ('netwerkopstelling:', wlan.ifconfig ())

As u die funksie uitvoer, kan u die IP -adres kry:

do_connect ()

Die resultaat sal wees:

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

In my geval, 10.0.1.2, was die ESP IP -adres.

Stap 8: The ThingSpeak

Op hierdie stadium het ons geleer hoe om data van alle sensors op te neem en dit op ons OLED te vertoon. Dit is nou tyd om te sien hoe u die data na 'n IoT -platform, die ThingSpeak, kan stuur.

Laat ons begin!

Eerstens moet u 'n rekening by ThinkSpeak.com hê. Volg vervolgens die instruksies om 'n kanaal te skep en let op u kanaal -ID en skryf -API -sleutel.

Hierbo kan u die 5 velde sien wat op ons kanaal gebruik sal word.

Stap 9: MQTT -protokol en ThingSpeak -verbinding

MQTT is 'n publiseer-/intekenargitektuur wat hoofsaaklik ontwikkel is om bandwydte en toestelle met beperkte krag oor draadlose netwerke te verbind. Dit is 'n eenvoudige en ligte protokol wat oor TCP/IP -voetstukke of WebSockets loop. MQTT via WebSockets kan met SSL beveilig word. Met die publiseer/inteken -argitektuur kan boodskappe na die kliëntoestelle gestuur word sonder dat die toestel die bediener deurlopend hoef te peil.

Die MQTT -makelaar is die sentrale kommunikasiepunt en is verantwoordelik vir die versending van alle boodskappe tussen die senders en die regte ontvangers. 'N Kliënt is 'n toestel wat met die makelaar verbind is en onderwerpe kan publiseer of inteken om toegang tot die inligting te verkry. 'N Onderwerp bevat die routeringsinligting vir die makelaar. Elke kliënt wat boodskappe wil stuur, publiseer dit na 'n sekere onderwerp, en elke kliënt wat boodskappe wil ontvang, teken op 'n sekere onderwerp in. Die makelaar lewer alle boodskappe met die ooreenstemmende onderwerp aan die toepaslike kliënte.

ThingSpeak ™ het 'n MQTT -makelaar op die URL mqtt.thingspeak.com en poort 1883. Die ThingSpeak -makelaar ondersteun beide MQTT -publisering en MQTT -intekening.

In ons geval gebruik ons: MQTT Publish

Die figuur beskryf die onderwerpstruktuur. Die skryf -API -sleutel is nodig om te publiseer. Die makelaar erken 'n korrekte CONNECT -versoek by CONNACK.

Die MQTT-protokol word ondersteun in 'n ingeboude biblioteek in die Micropython-binaries-hierdie protokol kan gebruik word om data van u ESP8266, via WIFI, na 'n gratis wolkdatabasis te stuur.

Kom ons gebruik die umqtt.simple -biblioteek:

vanaf umqtt.simple invoer MQTTClient

En as ons ons SERVER ID ken, is dit moontlik om ons MQTT -kliëntvoorwerp te skep:

SERVER = "mqtt.thingspeak.com"

kliënt = MQTTClient ("umqtt_client", SERVER)

Nou, met u ThingSpeak -geloofsbriewe byderhand:

CHANNEL_ID = "U KANAAL -ID"

WRITE_API_KEY = "U SLEUTEL HIER"

Kom ons skep ons MQTT "Onderwerp":

topic = "kanale/" + CHANNEL_ID + "/publiseer/" + WRITE_API_KEY

Laat ons ons data na ThingSpeak IoT Service stuur, met behulp van die funksie wat gemaak is, en die reaksie daarvan koppel aan spesifieke data veranderlikes:

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

Met hierdie veranderlikes opgedateer, kan ons ons 'MQTT Payload' skep:

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

En dit is dit! Ons is gereed om data na ThinsSpeak te stuur, bloot deur die drie kode -reëls hieronder te gebruik:

client.connect ()

client.publish (topic, payload) client.disconnect ()

As u nou na u kanaalbladsy gaan (soos hierbo myne), sal u sien dat elkeen van die 5 velde data bevat wat verband hou met u sensors.

Stap 10: Sensor Data Logger

Noudat ons weet dat dit slegs met 'n paar reëls kode moontlik is om data na 'n IoT -diens op te laai, laat ons 'n lusfunksie skep om dit outomaties gereeld te doen (soortgelyk aan wat ons met 'Plaaslike data' gedoen het) ).

Deur dieselfde veranderlike (PUB_TIME_SEC) te gebruik, wat voorheen verklaar is, sou 'n eenvoudige hooffunksie om data voortdurend op te vang, om dit op ons kanaal aan te meld:

terwyl dit waar is:

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

Let daarop dat slegs die 'payload' opgedateer moet word sodra 'topic' verband hou met ons kanaalbewyse en dit nie verander nie.

Op soek na u ThingSpeak -kanaalbladsy, sal u sien dat die data deurlopend na elke veld gelaai word. U kan die LDR bedek, u hand op temp/hum -sensors sit, op die knoppie druk, ens. En kyk hoe die kanaal outomaties die data sal "aanteken" vir toekomstige analise.

Gewoonlik, vir data -aanmelding, moet ons probeer om so min as moontlik krag te gebruik, daarom gebruik ons nie die LED of plaaslik nie. Dit is ook algemeen met ESP -toestelle, en sit dit op 'diepe slaap', waar die mikroverwerker op sy minimum energie is, totdat dit tyd is om data op te neem en na die IoT -platform te stuur.

Maar as die idee eers hier geleer is, laat ons ook die skerm en LED insluit soos ons voorheen gedoen het. As ons dit doen, sal ons 'logger' funksie wees:

terwyl knoppie.waarde ():

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

Die volledige microPython -skrif kan hier gevind word: dataLoggerTS_EXT.py en die Jupyter -notaboek wat vir ontwikkeling gebruik is, kan ook hier gevind word: IoT ThingSpeak Data Logger EXT.ipynb.

Om die skrif na ESP op te laai, gebruik die opdrag op u terminale:

ampy sit dataLoggerTS.py /main.py

En druk op die ESP - reset knoppie. U sal die ESP hê om data op te neem en dit op ThingSpeak.com aan te meld totdat die onderkant ingedruk gehou word (wag totdat die LED 3 keer knip en die OLED afskakel).

Stap 11: Die ThingView -app

U kan die aangetekende data direk op ThingSpeak.com -webwerf of via 'n APP sien, byvoorbeeld ThingsView!

ThingView is 'n APP wat ontwikkel is deur CINETICA, waarmee u u ThingSpeak -kanale op 'n maklike manier kan visualiseer; voer slegs die kanaal -ID in en u is gereed.

Vir openbare kanale sal die toepassing u vensters se instellings respekteer: kleur, tydskaal, tipe grafiek en die aantal resultate. Die huidige weergawe ondersteun lyn- en kolomgrafieke; die spline -kaarte word as lyngrafieke vertoon.

Vir privaat kanale word die data met behulp van die standaardinstellings vertoon, aangesien daar geen manier is om die privaat vensters -instellings slegs met die API -sleutel te lees nie.

Die ThingView -app kan afgelaai word vir ANDROID en IPHONE.

Stap 12: Gevolgtrekking

Soos altyd, hoop ek dat hierdie projek ander kan help om die opwindende wêreld van elektronika te vind!

Besoek my GitHub -bewaarplek: IoT_TS_MQTT vir besonderhede en finale kode

Besoek my blog vir meer projekte: MJRoBot.org

Groete uit die suide van die wêreld!

Sien jou in my volgende instruksies!

Dankie, Marcelo