IoT- ը դյուրին դարձավ. ESP-MicroPython-MQTT-Thing Խոսել ՝ 12 քայլ

2024 Հեղինակ: John Day | [email protected]. Վերջին փոփոխված: 2024-01-30 09:48

Իմ նախորդ ձեռնարկում ՝ Jupyter- ի միջոցով MicroPython- ը ESP- ում, մենք սովորեցինք, թե ինչպես տեղադրել և գործարկել MicroPython- ը ESP սարքի վրա: Օգտագործելով Jupyter Notebook- ը ՝ որպես մեր զարգացման միջավայր, մենք սովորեցինք նաև կարդալ սենսորներից (ջերմաստիճան, խոնավություն և լուսավորություն), մենք օգտագործում ենք մի քանի հաղորդակցման արձանագրություններ և մեթոդներ ՝ անալոգային, թվային, 1-լար և I2C, այս վերջինը ՝ մեր գրավածը ցուցադրելու համար: տվյալները OLED էկրանին:

Այժմ, MQTT արձանագրության միջոցով այս ձեռնարկի ընթացքում մենք կստանանք բոլոր գրավված տվյալները ՝ դրանք ուղարկելով IoT ծառայություն, ThingSpeak.com և բջջային հավելված (Thingsview), որտեղ կարող ենք մուտք գործել և խաղալ տվյալների հետ:

Ահա, մեր նախագծի բլոկ -դիագրամը.

Քայլ 1: BoM - նյութի հաշիվ

1. NodeMCU - 8,39 ԱՄՆ դոլար
2. DHT22 peratերմաստիճանի եւ հարաբերական խոնավության ցուցիչ `9.95 ԱՄՆ դոլար
3. DS18B20 Անջրանցիկ ջերմաստիճանի տվիչ - 5.95 ԱՄՆ դոլար
4. OLED էկրան SSD1366- 8.99 ԱՄՆ դոլար (ըստ ցանկության)
5. LDR (1x)
6. LED (1x) (ըստ ցանկության)
7. Կոճակ (1x)
8. Ռեզիստոր 4K7 Օմ (2x)
9. Ռեզիստոր 10K Օմ (1x)
10. Ռեզիստոր 220 օմ (1x)

Քայլ 2: The Hw

The Hw, որը մենք այստեղ կօգտագործենք, հիմնականում նույնն է, ինչ օգտագործվում է ձեռնարկում. Micropython on ESP Using Jupyter. Դիտեք դրան բոլոր HW միացումների համար:

Բացառություն է Servo- ն, որը մենք չենք օգտագործվի այս նախագծում:

Վերևում կարող եք տեսնել HW- ն ամբողջությամբ: Միացրեք սարքերը, ինչպես ցույց է տրված այնտեղ:

Քայլ 3. Միկրոպիթոն, REPL, Jupyter

Ձեր ESP սարքում պետք է տեղադրված լինի Micropython թարգմանիչ: Բեռնելուց հետո դուք պետք է ծրագրավորեք ձեր ESP- ն ՝ օգտագործելով առկա ցանկացած եղանակ/IDE, ինչպես օրինակ ՝

• ՓԱՍՏ
• Jupyter նոթատետր
• Մու
• ESPCut (միայն Windows- ի համար)
• … Եվ այլն

Իմ ձեռնարկում ՝ Micropython on ESP Using Jupyter, ես մանրամասնեցի, թե ինչպես ներբեռնել և տեղադրել MicroPython թարգմանիչ, ESPTool ՝ ESP սարքերը կառավարելու համար և ինչպես օգտագործել Jupyter Notebook- ը որպես զարգացման միջավայր: Ազատորեն օգտագործեք այն, ինչ ձեզ համար ավելի հարմար է:

Ես սովորաբար ամբողջ զարգացումը կատարում եմ Jupyter Notebook- ում և վերջնական կոդը ստանալուց հետո դրանք պատճենում եմ Geany- ում և բեռնում այն իմ ESP- ով ՝ օգտագործելով Ampy:

Քայլ 4: Սենսորներ

Եկեք տեղադրենք գրադարանները, սահմանենք GPIO, ստեղծենք օբյեկտներ, գործառույթներ բոլոր տվիչների համար առանձին:

A. DHT (ջերմաստիճան և խոնավություն)

Եկեք տեղադրենք DHT գրադարանը և ստեղծենք օբյեկտ.

dht import DHT22- ից

մեքենայի ներմուծումից Pin dht22 = DHT22 (Pin (12))

Այժմ ստեղծեք DHT սենսոր կարդալու գործառույթ.

def readDht ():

dht22.measure () վերադարձ dht22.temperature (), dht22.humidity () Փորձարկեք DHT գործառույթը

տպել (readDht ())

Արդյունքը պետք է լինի, օրինակ.

(17.7, 43.4)

B. DS18B20 (արտաքին ջերմաստիճան)

Եկեք տեղադրենք գրադարանները և ստեղծենք օբյեկտ.

ներմուծեք մետաղալար, ds18x20

ներմուծման ժամանակը # Սահմանեք, թե որ քորոցին է միացված լինելու 1-լար սարքը ==> pin 2 (D4) dat = Pin (2) # ստեղծել onewire օբյեկտը ds = ds18x20. DS18X20 (onewire. OneWire (dat)) Սկանավորեք սարքերը bu- ում

տվիչներ = ds.scan ()

տպել («գտնված սարքեր.», տվիչներ)

Տպագրված արդյունքն իրոք կարևոր չէ, այն, ինչ մեզ պետք կլինի, առաջին հայտնաբերված սենսորն է `տվիչներ [0]: Եվ այժմ, մենք կարող ենք կառուցել սենսորային տվյալները կարդալու գործառույթ.

def readDs ():

ds.convert_temp () time.sleep_ms (750) վերադարձնել ds.read_temp (տվիչներ [0])

Միշտ կարեւոր է ստուգել սենսորը `օգտագործելով ստեղծված գործառույթը

տպել (կարդալDs ()) Եթե դուք ստանում եք ջերմաստիճանի արժեք, ձեր ծածկագիրը ճիշտ է

17.5

C. LDR (լուսավորություն)

LDR- ն կօգտագործի մեր ESP- ի անալոգային քորոցը (դա միայն մեկն է ESP8266- ի դեպքում և մի քանիսը ESP32- ի դեպքում):

Մանրամասների համար տես իմ ESP32 ձեռնարկը:

Նույնը, ինչ արվել է նախկինում.

# ներմուծել գրադարան

մեքենայի ներմուծումից ADC # Սահմանել օբյեկտը adc = ADC (0) Պարզ գործառույթ ՝ adc.read () կարող է օգտագործվել ADC արժեքը կարդալու համար: Բայց հիշեք, որ ներքին ADC- ն համապատասխան թվային արժեքներում կփոխարկի 0 -ից 3.3 Վ -ի լարումները ՝ 0 -ից մինչև 1023 -ը: Երբ մեզ հետաքրքրում է «Լուսավորությունը», մենք առավելագույն լույսը կհամարենք որպես սենսորից առավելագույն գրաված արժեք (իմ պատյան 900) և նվազագույն լույս, որն իմ դեպքում 40 է: Այդ արժեքներն ունենալով ՝ մենք կարող ենք 40 -ից 900 արժեքը «քարտեզագրել» լուսավորության 0 -ից 100% -ով: Դրա համար մենք կստեղծենք նոր գործառույթ

def readLdr ():

lumPerct = (adc.read ()-40)*(10/86) # փոխակերպել տոկոսային («քարտեզ») վերադարձի փուլ (lumPerct)

Դուք պետք է փորձարկեք գործառույթը print- ի միջոցով (կարդալLDR ()): Արդյունքը պետք է լինի ամբողջ թիվ o- ի և 100 -ի միջև:

D. Push-Button (թվային մուտքագրում)

Այստեղ մենք օգտագործում ենք Push-Button- ը որպես թվային տվիչ, բայց դա կարող է լինել շարժիչի «արձագանք» (օրինակ ՝ միացված/անջատված պոմպ):

# սահմանեք քորոց 13-ը որպես մուտք և ակտիվացրեք ներքին ձգվող դիմադրությունը.

կոճակ = Pin (13, Pin. IN, Pin. PULL_UP) # Կոճակի ընթերցման գործառույթ. def readBut (): return button.value ()

Դուք կարող եք ստուգել կոճակը, որը կարդում է print գործառույթը (readBut ()): Արդյունքը սեղմելիս պետք է լինի «1»: Կտտացնելով կոճակը ՝ արդյունքը պետք է լինի «0»

Քայլ 5. Սենսորային տվյալների տեղայնացում և ցուցադրում

Այժմ, երբ մենք ստեղծել ենք մեկ գործառույթ յուրաքանչյուր սենսորի համար, եկեք ստեղծենք վերջինը, որը կկարդա բոլորը միաժամանակ.

def colectData ():

temp, hum, = readDht () extTemp = readDs () lum = readLdr () butSts = readBut () վերադարձնել ջերմաստիճանը, hum, extTemp, lum, butSts Այժմ, եթե օգտագործում եք

տպել (colectData ())

Արդյունքում կստեղծվի մի զույգ, որը ներառում է սենսորներից գրված բոլոր տվյալները.

(17.4, 45.2, 17.3125, 103, 1)

Մենք կարող ենք նաև, ըստ ցանկության, այդ տվյալները ցուցադրել տեղական էկրանին.

# ներմուծեք գրադարան և ստեղծեք i2c օբյեկտ

մեքենայից ներմուծում I2C i2c = I2C (scl = Pin (5), sda = Pin (4)) # ներմուծել գրադարան և ստեղծել օբյեկտ oled ներմուծում ssd1306 i2c = I2C (scl = Pin (5), sda = Pin (4)) oled = ssd1306. SSD1306_I2C (128, 64, i2c, 0x3c) # ստեղծել գործառույթ. 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 () # ցուցադրել տվյալները ՝ օգտագործելով displayData գործառույթը (temp, hum, extTemp, lum, butSts)

Որպես տարբերակ, ես նաև կներառեմ, որ LED- ը միացված լինի, երբ սկսում ենք սենսորներ կարդալ, և այդ տվյալները ցուցադրվելուց հետո անջատվում են: Դա անելը կօգնի հաստատել, որ ծրագիրը աշխատում է, երբ ESP- ն անջատված է համակարգչից և ինքնաբերաբար աշխատում է:

Այսպիսով, «հիմնական գործառույթը կլինի.

# Հիմնական գործառույթը `բոլոր սենսորները կարդալու համար

def main (): # ցուցադրել տվյալները led.on () temp, hum, extTemp, lum, butSts = colectData () displayData (temp, hum, extTemp, lum, butSts) led.off ()

Այսպիսով, կատարելով main (), մենք կստանանք OLED- ով ցուցադրվող սենսորների տվյալները, ինչպես ցույց է տրված նկարում:

Քայլ 6. Գործարկեք Տեղական կայանի ծածկագիրը ESP գործարկման ժամանակ

Մենք կարող ենք ունենալ այն ամենը, ինչ մշակվել է մինչ այժմ մեկ ֆայլի վրա, որը պետք է կատարվի մեր ESP- ի կողմից:

Եկեք բացենք ցանկացած տեքստային խմբագիր և դրանով անցնենք բոլոր ծածկագրերը.

# ներմուծել ընդհանուր գրադարաններ

մեքենայից ներմուծում Pin ներմուծման ժամանակը # սահմանել pin 0 -ը որպես ելք led = Pin (0, Pin. OUT) # DHT from dht import DHT22 dht22 = DHT22 (Pin (12)) # DHT կարդալ գործառույթ def readDht (): dht22.measure () վերադարձնել dht22.temperature (), dht22.humidity () # DS18B20 ներմուծել հաղորդալար, ds18x20 # Սահմանել, թե որ կապի հետ է կապված 1-լարի սարքը ==> pin 2 (D4) dat = Pin (2) # Ստեղծել ցանցը օբյեկտ ds = ds18x20. DS18X20 (onewire. OneWire (dat)) # ավտոբուսի սենսորների սարքերի որոնում = ds.scan () # գործառույթ կարդալ DS18B20 def readDs (): ds.convert_temp () time.sleep_ms (750) վերադարձ կլոր (ds.read_temp (տվիչներ [0]), 1) # LDR մեքենայից ներմուծում ADC # Սահմանել օբյեկտը adc = ADC (0) # գործառույթը ՝ լուսավորությունը կարդալու համար defdLdr (): lumPerct = (adc.read ()-40) *(10/86) # փոխակերպել տոկոսով («քարտեզ») վերադառնալ շրջան (lumPerct) # սահմանել PIN 13-ը որպես մուտքագրում և ակտիվացնել ներքին Pull-up resistor: կոճակ = Pin (13, Pin. IN, Pin. PULL_UP) # Կոճակի կարդալ գործառույթը `def readBut (): return button.value () # Բոլոր տվյալները կարդալու գործառույթ. Def cole ctData (): temp, hum, = readDht () extTemp = readDs () lum = readLdr () butSts = readBut () վերադարձնել ջերմաստիճանը, hum, extTemp, lum, butSts # ներմուծել գրադարան և ստեղծել i2c օբյեկտ մեքենայից I2C i2c = I2C (scl = Pin (5), sda = Pin (4)) # ներմուծել գրադարան և ստեղծել օբյեկտով oled ներմուծում ssd1306 i2c = I2C (scl = Pin (5), sda = Pin (4)) oled = ssd1306. SSD1306_I2C (128, 64, i2c, 0x3c) # ստեղծել գործառույթ. 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 () # Բոլոր տվիչները կարդալու հիմնական գործառույթը def main (): # ցուցադրել տվյալները led.on () temp, hum, extTemp, lum, butSts = colectData () displayData (temp, hum, extTemp, lum, butSts) led.off () ""- ----- գործարկել հիմնական գործառույթը -------- "" հիմնական ()

Պահպանեք այն, օրինակ ՝ localData.py- ի տեսքով:

Այս կոդը անմիջապես ձեր տերմինալում գործարկելու համար ձեզ հարկավոր կլինի Ampy:

Նախ, տերմինալում եկեք Ampy- ին տեղեկացնենք մեր Սերիական նավահանգիստը.

արտահանել AMPY_PORT =/dev/tty. SLAB_USBtoUART

Այժմ մենք կարող ենք տեսնել մեր ESP արմատային գրացուցակի ներսում գտնվող ֆայլերը.

ամպի լս

Որպես պատասխան, մենք կստանանք boot.py, դա առաջին ֆայլն է, որը կաշխատի համակարգում:

Այժմ, եկեք օգտագործենք Ampy- ն ՝ մեր python Script LocalData.py- ն որպես /main.py բեռնելու համար, այնպես որ սցենարը կաշխատի բեռնաթափումից անմիջապես հետո.

ampy տեղադրել localData.py /main /py

Եթե մենք այժմ օգտագործում ենք amp ls հրամանը, ESP- ի ներսում կտեսնեք 2 ֆայլ ՝ boot.py և main.py

Ձեր ESP- ի վերականգնումը ծրագիրը localData.py- ին ինքնաբերաբար կաշխատի `ցուցադրելով սենսորի տվյալները ցուցադրված:

Վերը նշված Տերմինալի տպման էկրանը ցույց է տալիս, թե ինչ ենք մենք արել:

Վերոնշյալ ծածկագրով ցուցադրումը կցուցադրվի միայն մեկ անգամ, բայց մենք կարող ենք սահմանել հիմնական () գործառույթի օղակ, որը ցույց կտա տվյալներ յուրաքանչյուր սահմանված ժամանակահատվածի (PUB_TIME_SEC) վերաբերյալ, և, օրինակ, մինչև կոճակը սեղմելը.

# հանգույց ստանում է տվյալներ մինչև կոճակը սեղմելը

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

PUB_TIME_SEC փոփոխականը պետք է հայտարարվի այն ժամանակ, երբ ցանկանում եք ձեր նմուշները:

Մեր ծածկագիրն ավելի բարձրացնելու համար լավ կլիներ տեղեկացնել, որ մենք դուրս կգանք օղակից, դրա համար մենք կսահմանենք 2 նոր ընդհանուր գործառույթ ՝ մեկը էկրանը մաքրելու, իսկ մյուսը ՝ LED- ն որոշակի անգամ թարթելու համար:

# Մաքրել ցուցադրումը.

def displayClear (): oled.fill (0) oled.show () # ստեղծեք թարթման գործառույթ def blinkLed (num). i- ի համար (0, num)) քնել (0.5)

Այսպիսով, մենք այժմ կարող ենք վերաշարադրել մեր հիմնական () գործառույթը.

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

Վերջնական կոդը կարելի է ներբեռնել իմ GitHub: localData.py- ից և նաև Jupyter Notebook- ից, որն օգտագործվում է ամբողջական ծածկագրի մշակման համար. Jupyter Local Data Development:

Քայլ 7: ESP- ի միացում Տեղական WiFi- ին

Networkանցի մոդուլը օգտագործվում է WiFi կապը կազմաձևելու համար: Կան երկու WiFi ինտերֆեյս ՝ մեկը կայանի համար (երբ ESP8266- ը միանում է երթուղիչին) և մեկը մուտքի կետի համար (այլ սարքերի համար ESP8266- ին միանալու համար): Այստեղ մեր ESP- ը միացված կլինի տեղական ցանցին: Եկեք զանգահարենք գրադարան և սահմանենք մեր ցանցի հավատարմագրերը.

ներմուծման ցանց

WiFi_SSID = "YOUR SSID" WiFi_PASS = "YOUR PASSWORD"

Ստորև բերված գործառույթը կարող է օգտագործվել ESP- ը ձեր տեղական ցանցին միացնելու համար.

def do_connect ():

wlan = network. WLAN (network. STA_IF) wlan.active (True) եթե ոչ wlan.isconnected (): print ('ցանցին միանալը …') wlan.connect (WiFi_SSID, WiFi_SSID) մինչդեռ wlan.isconnected (): pass տպել ('ցանցի կազմաձևում', wlan.ifconfig ())

Գործարկելով գործառույթը ՝ արդյունքում կարող եք ստանալ IP հասցեն.

do_connect ()

Արդյունքը կլինի.

ցանցի կազմաձևում ՝ ('10.0.1.2 ',' 255.255.255.0 ', '10.0.1.1', '10.0.1.1 ')

Իմ դեպքում, 10.0.1.2, ESP IP հասցեն էր:

Քայլ 8: ThingSpeak

Այս պահին մենք սովորեցինք, թե ինչպես կարելի է տվյալներ վերցնել բոլոր տվիչներից ՝ դրանք ցուցադրելով մեր OLED- ով: Այժմ, ժամանակն է տեսնել, թե ինչպես կարելի է այդ տվյալները ուղարկել IoT հարթակ ՝ ThingSpeak:

Եկեք սկսենք!

Նախ, դուք պետք է հաշիվ ունենաք ThinkSpeak.com կայքում: Հաջորդը, հետևեք ալիք ստեղծելու հրահանգներին և հաշվի առեք ձեր ալիքի ID- ն և գրեք API բանալին:

Վերևում կարող եք տեսնել 5 դաշտերը, որոնք կօգտագործվեն մեր ալիքում:

Քայլ 9: MQTT արձանագրություն և ThingSpeak միացում

MQTT- ը հրապարակման/բաժանորդագրության ճարտարապետություն է, որը մշակվել է հիմնականում անլար ցանցերի միջոցով թողունակության և էներգիայով սահմանափակ սարքերը միացնելու համար: Դա պարզ և թեթև արձանագրություն է, որն անցնում է TCP/IP վարդակների կամ WebSockets- ի վրայով: MQTT- ը WebSockets- ի միջոցով կարելի է ապահովել SSL- ով: Հրապարակման/բաժանորդագրության ճարտարապետությունը հնարավորություն է տալիս հաղորդագրությունները մղել դեպի հաճախորդի սարքեր ՝ առանց սարքի ՝ սերվերի անընդհատ հարցում կատարելու անհրաժեշտության:

MQTT բրոքերը հաղորդակցության կենտրոնական կետն է, և այն պատասխանատու է ուղարկողների և օրինական ստացողների միջև բոլոր հաղորդագրությունները ուղարկելու համար: Հաճախորդը ցանկացած սարք է, որը միանում է բրոքերին և կարող է տեղեկատվություն մուտք գործելու համար հրապարակել կամ բաժանորդագրվել թեմաներին: Թեման պարունակում է միջնորդի համար երթուղղման տեղեկատվություն: Յուրաքանչյուր հաճախորդ, որը ցանկանում է հաղորդագրություններ ուղարկել, դրանք հրապարակում է որոշակի թեմայի շուրջ, և յուրաքանչյուր հաճախորդ, որը ցանկանում է հաղորդագրություններ ստանալ, բաժանորդագրվում է որոշակի թեմայի: Բրոքերը համապատասխան թեմայով բոլոր հաղորդագրությունները փոխանցում է համապատասխան հաճախորդներին:

ThingSpeak ™- ն ունի MQTT բրոքեր URL mqtt.thingspeak.com և 1883 նավահանգստում: ThingSpeak բրոքերն աջակցում է և MQTT հրապարակմանը, և MQTT բաժանորդագրվելուն:

Մեր դեպքում մենք կօգտագործենք ՝ MQTT Publish

Նկարը նկարագրում է թեմայի կառուցվածքը: Հրապարակման համար անհրաժեշտ է գրել API- ի բանալին: Բրոքերն ընդունում է CONNECT- ի ճիշտ CONNECT հայցը:

MQTT արձանագրությունն աջակցվում է Micropython երկուական ֆայլերի ներկառուցված գրադարանում: Այս արձանագրությունը կարող է օգտագործվել ձեր ESP8266- ից տվյալները WIFI- ով ուղարկելու համար անվճար ամպային տվյալների բազա:

Եկեք օգտագործենք umqtt.simple գրադարանը.

umqtt.simple import MQTTClient- ից

Եվ իմանալով մեր SERVER ID- ն ՝ հնարավոր է ստեղծել մեր MQTT հաճախորդի օբյեկտը.

ՍԵՐՎԵՐ = "mqtt.thingspeak.com"

հաճախորդ = MQTTClient ("umqtt_client", SERVER)

Այժմ, ունենալով ձեր ThingSpeak հավատարմագրերը ձեռքի տակ.

CHANNEL_ID = "ՔՈ ԱԼԻՔԻ ID- ն"

WRITE_API_KEY = "ՔՈ բանալին այստեղ"

Եկեք ստեղծենք մեր MQTT «Թեման».

թեմա = "ալիքներ/" + CHANNEL_ID + "/հրապարակել/" + WRITE_API_KEY

Եկեք մեր տվյալները ուղարկենք ThingSpeak IoT ծառայություն ՝ օգտագործելով ստեղծված գործառույթը և դրա պատասխանը կապենք տվյալների որոշակի փոփոխականների հետ.

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

Այդ փոփոխականների թարմացմամբ մենք կարող ենք ստեղծել մեր «MQTT բեռնվածությունը».

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

Եվ վերջ! Մենք պատրաստ ենք տվյալներ ուղարկել ThinsSpeak- ին ՝ պարզապես օգտագործելով ստորև նշված կոդի 3 տողերը.

client.connect ()

client.publish (թեմա, բեռնվածություն) client.disconnect ()

Այժմ, եթե գնաք ձեր ալիքի էջ (ինչպես իմը վերևում), կտեսնեք, որ 5 դաշտերից յուրաքանչյուրում կլինեն ձեր տվիչների հետ կապված տվյալներ:

Քայլ 10: Տվյալների գրանցման ցուցիչ

Այժմ, երբ մենք գիտենք, որ միայն մի քանի տող կոդով է հնարավոր տվյալների վերբեռնում IoT ծառայություն, եկեք ստեղծենք օղակի գործառույթ ՝ դա ավտոմատ կերպով կատարելու համար ժամանակի կանոնավոր ընդմիջումով (նման է այն, ինչ արել ենք «Տեղական տվյալներ ):

Օգտագործելով նախկինում հայտարարված նույն փոփոխականը (PUB_TIME_SEC) ՝ տվյալների շարունակական գրավման պարզ հիմնական գործառույթը ՝ դրանք մեր ալիքում մուտքագրելը կլինի.

իսկական True:

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 (թեմա, բեռնվածություն) client.disconnect () time.sleep (PUB_TIME_SEC)

Նկատի ունեցեք, որ միայն «բեռնվածությունը» պետք է թարմացվի, երբ «թեման» առնչվի մեր ալիքի հավատարմագրին և չի փոխվի:

Փնտրելով ձեր ThingSpeak ալիքի էջը ՝ կնկատեք, որ տվյալները շարունակաբար կբեռնվեն յուրաքանչյուր դաշտում: Կարող եք ծածկել LDR- ը, ձեռքը դնել ջերմաստիճանի/ձայնի տվիչների վրա, սեղմել կոճակը և այլն և տեսնել, թե ինչպես է ալիքն ինքնաբերաբար «մուտքագրելու» այդ տվյալները հետագա վերլուծության համար:

Սովորաբար, Տվյալների գրանցման համար մենք պետք է փորձենք հնարավորինս քիչ էներգիա օգտագործել, այնպես որ, մենք LED- ը կամ էկրանը տեղական չենք օգտագործի: Բացի այդ, դա սովորական բան է ESP սարքերի համար, դրանք դրեք «խոր քնի» վրա, որտեղ միկրոպրոցեսորը կլինի իր նվազագույն էներգիայի վիճակում, մինչև տվյալները գրավելու և դրանք ուղարկելու IoT հարթակ:

Բայց, երբ այստեղ գաղափարը սովորում է, եկեք ներառենք նաև էկրանը և LED- ն, ինչպես նախկինում էինք: Դա անելով ՝ մեր «անտառահատ» գործառույթը կլինի.

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) հաճախորդ.connect () client.publish (թեմա, բեռնվածություն) client.disconnect () time.sleep (PUB_TIME_SEC) blinkLed (3) displayClear ()

Ամբողջական microPython սցենարը կարելի է գտնել այստեղ ՝ dataLoggerTS_EXT.py և զարգացման համար օգտագործված Jupyter նոթատետրը կարող եք գտնել նաև այստեղ ՝ IoT ThingSpeak Data Logger EXT.ipynb:

ESP- ում սցենարը վերբեռնելու համար ձեր տերմինալում օգտագործեք հրամանը.

ampy դնել dataLoggerTS.py /main.py

Եվ սեղմեք ESP - վերականգնելու կոճակը: Դուք կունենաք ESP- ի տվյալների հավաքում և մուտքագրում դրանք ThingSpeak.com- ում, մինչև ներքևը սեղմված չլինի (սպասեք, որ LED- ը թարթվի 3 անգամ և OLED- ն անջատվի):

Քայլ 11: ThingView հավելվածը

Գրանցված տվյալները կարող են դիտվել անմիջապես ThingSpeak.com կայքում կամ APP- ի միջոցով, օրինակ ՝ ThingsView!

ThingView- ը CINETICA- ի կողմից մշակված ծրագիր է, որը հնարավորություն է տալիս հեշտությամբ պատկերացնել ձեր ThingSpeak ալիքները, պարզապես մուտքագրեք ալիքի ID- ն և պատրաստ եք գնալ:

Հանրային ալիքների համար դիմումը կհարգի ձեր պատուհանների կարգավորումները `գույնը, ժամանակացույցը, գծապատկերի տեսակը և արդյունքների քանակը: Ընթացիկ տարբերակը աջակցում է տողերի և սյունակների գծապատկերներին, ուղղաձիգ գծապատկերները ցուցադրվում են որպես գծապատկերներ:

Անձնական ալիքների դեպքում տվյալները կցուցադրվեն `օգտագործելով կանխադրված կարգավորումները, քանի որ ոչ մի կերպ հնարավոր չէ կարդալ մասնավոր պատուհանների կարգավորումները միայն API ստեղնով:

ThingView ծրագիրը կարելի է ներբեռնել ANDROID- ի և IPHONE- ի համար:

Քայլ 12: Եզրակացություն

Ինչպես միշտ, ես հույս ունեմ, որ այս նախագիծը կարող է օգնել ուրիշներին գտնել իրենց ճանապարհը դեպի էլեկտրոնիկայի հետաքրքիր աշխարհ:

Մանրամասների և վերջնական ծածկագրի համար այցելեք իմ GitHub ավանդապահ ՝ IoT_TS_MQTT

Լրացուցիչ նախագծերի համար այցելեք իմ բլոգը ՝ MJRoBot.org

Սալուդոս աշխարհի հարավից:

Կհանդիպենք իմ հաջորդ հրահանգի մեջ:

Շնորհակալություն, Մարսելո