IoT Made Ease: ESP-MicroPython-MQTT-Thing საუბარი: 12 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:18

ჩემს წინა სახელმძღვანელოში, MicroPython ESP– ზე Jupyter– ის გამოყენებით, ჩვენ ვისწავლეთ როგორ დაყენება და გაშვება ESP მოწყობილობაზე. Jupyter Notebook– ის, როგორც ჩვენი განვითარების გარემოს გამოყენებით, ჩვენ ასევე ვისწავლეთ სენსორების კითხვა (ტემპერატურა, ტენიანობა და სიკაშკაშე), ჩვენ ვიყენებთ რამდენიმე საკომუნიკაციო პროტოკოლს და მეთოდს, ანალოგურ, ციფრულ, 1 მავთულს და I2C, ეს უკანასკნელი ჩვენების გადასაღებად მონაცემები OLED ეკრანზე.

ახლა, ამ გაკვეთილზე MQTT პროტოკოლის გამოყენებით, ჩვენ მივიღებთ ყველა დატყვევებულ მონაცემს, გავაგზავნით მათ IoT სერვისზე, ThingSpeak.com– ზე და მობილურ აპლიკაციაში (Thingsview), სადაც შეგვიძლია შევიდეთ და ვითამაშოთ მონაცემებით.

აქ არის ჩვენი პროექტის ბლოკ -დიაგრამა:

ნაბიჯი 1: BoM - Bill of Material

1. NodeMCU - 8.39 აშშ დოლარი
2. DHT22 ტემპერატურისა და ტენიანობის შედარებითი სენსორი - 9.95 აშშ დოლარი
3. DS18B20 წყალგაუმტარი ტემპერატურის სენსორი - 5.95 აშშ დოლარი
4. OLED ეკრანი SSD1366- $ 8.99 (სურვილისამებრ)
5. LDR (1x)
6. LED- ები (1x) (სურვილისამებრ)
7. ღილაკი (1x)
8. რეზისტორი 4K7 ohm (2x)
9. რეზისტორი 10K ohm (1x)
10. რეზისტორი 220 ohm (1x)

ნაბიჯი 2: Hw

Hw, რომელსაც ჩვენ აქ გამოვიყენებთ, იგივეა, რაც გამოიყენება სამეურვეო პროგრამაში: Micropython on ESP Using Jupyter. მიმართეთ მას ყველა HW კავშირისთვის.

გამონაკლისი არის Servo, რომ ჩვენ არ გამოვიყენებთ ამ პროექტში.

ზემოთ თქვენ შეგიძლიათ ნახოთ სრული HW. შეაერთეთ მოწყობილობები, როგორც ნაჩვენებია იქ.

ნაბიჯი 3: მიკროპითონი, REPL, იუპიტერი

თქვენ უნდა გქონდეთ მიკროპითონის თარჯიმანი დატვირთული თქვენს ESP მოწყობილობაზე. დატვირთვის შემდეგ, თქვენ უნდა დაპროგრამდეთ თქვენი ESP ნებისმიერი ხელმისაწვდომი ხერხით/IDE– ით, როგორიცაა:

• REPL
• იუპიტერის რვეული
• მუ
• ESPCut (მხოლოდ Windows)
• … და ა.შ

ჩემს გაკვეთილზე, Micropython on ESP Jupyter გამოყენებით, მე დეტალურად განვიხილავ როგორ გადმოვწერო და დააინსტალირო MicroPython თარჯიმანი, ESPTool ESP მოწყობილობების მართვისთვის და როგორ გამოვიყენო Jupyter Notebook როგორც განვითარების გარემო. თავისუფლად გამოიყენეთ ის, რაც თქვენთვის უფრო კომფორტულია.

მე, როგორც წესი, ყველა განვითარებას ვაკეთებ Jupyter Notebook– ზე და როგორც კი მივიღებ საბოლოო კოდს, ვაკოპირებ მათ Geany– ში და ვტვირთავ ჩემს ESP– ზე Ampy– ს გამოყენებით.

ნაბიჯი 4: სენსორები

მოდით დავაყენოთ ბიბლიოთეკები, განვსაზღვროთ GPIO, შევქმნათ ობიექტები, ფუნქციები ყველა სენსორისთვის ინდივიდუალურად:

A. DHT (ტემპერატურა და ტენიანობა)

მოდით დავაინსტალიროთ DHT ბიბლიოთეკა და შევქმნათ ობიექტი:

dht იმპორტიდან DHT22

აპარატის იმპორტიდან Pin dht22 = DHT22 (პინი (12))

ახლა შექმენით DHT სენსორის წაკითხვის ფუნქცია:

def readDht ():

dht22.measure () return dht22.temperature (), dht22.humidity () შეამოწმეთ DHT ფუნქცია

ბეჭდვა (readDht ())

შედეგი უნდა იყოს მაგალითად:

(17.7, 43.4)

B. DS18B20 (გარე ტემპერატურა)

მოდით დავაყენოთ ბიბლიოთეკები და შევქმნათ ობიექტი:

იმპორტი onewire, ds18x20

იმპორტის დრო # განსაზღვრეთ რომელ პინთან იქნება დაკავშირებული 1 მავთულის მოწყობილობა ==> pin 2 (D4) dat = Pin (2) # შექმენით ერთი ხრახნიანი ობიექტი ds = ds18x20. DS18X20 (onewire. OneWire (dat)) მოწყობილობაზე სკანირება bu

სენსორები = ds.scan ()

ბეჭდვა ("ნაპოვნი მოწყობილობები:", სენსორები)

დაბეჭდილი შედეგი ნამდვილად არ არის მნიშვნელოვანი, ის რაც დაგვჭირდება არის პირველი აღმოჩენილი სენსორი: სენსორები [0]. ახლა კი, ჩვენ შეგვიძლია ავაშენოთ ფუნქცია სენსორის მონაცემების წასაკითხად:

def readDs ():

ds.convert_temp () time.sleep_ms (750) დაბრუნება ds.read_temp (სენსორები [0])

ყოველთვის მნიშვნელოვანია სენსორის შემოწმება შექმნილი ფუნქციის გამოყენებით

ამობეჭდვა (წაკითხვა () თუ თქვენ მიიღებთ ტემპერატურის მნიშვნელობას, თქვენი კოდი სწორია

17.5

C. LDR (სიკაშკაშე)

LDR გამოიყენებს ჩვენი ESP– ის ანალოგიურ პინს (ეს არის მხოლოდ ერთი ESP8266– ის შემთხვევაში და რამდენიმე ESP32– ის შემთხვევაში).

დეტალებისთვის იხილეთ ჩემი ESP32 სახელმძღვანელო.

იგივე რაც ადრე გაკეთდა:

# ბიბლიოთეკის იმპორტი

აპარატის იმპორტიდან ADC # ობიექტის განსაზღვრა adc = ADC (0) მარტივი ფუნქცია: adc.read () შეიძლება გამოყენებულ იქნას ADC მნიშვნელობის წასაკითხად. მაგრამ გახსოვდეთ, რომ შიდა ADC გადააქცევს ძაბვებს 0 -დან 3.3 ვ -მდე შესაბამის ციფრულ მნიშვნელობებში, 0 -დან 1023 -მდე. მას შემდეგ რაც დავინტერესდებით "Luminosity" - ით, ჩვენ გავითვალისწინებთ მაქს სინათლეს, როგორც სენსორის მაქსიმალურ გადაღებულ მნიშვნელობას (ჩემი შემთხვევა 900) და მინიმალური შუქი, რომელიც ჩემს შემთხვევაში არის 40. ამ მნიშვნელობების მქონე ჩვენ შეგვიძლია "დავხატოთ" მნიშვნელობა 40 -დან 900 -მდე 0 -დან 100% -მდე სიკაშკაშეს. ამისათვის ჩვენ შევქმნით ახალ ფუნქციას

def readLdr ():

lumPerct = (adc.read ()-40)*(10/86) # კონვერტირება პროცენტულად ("რუკა") დაბრუნების რაუნდი (lumPerct)

თქვენ უნდა შეამოწმოთ ფუნქცია print (readLDR ()) გამოყენებით. შედეგი უნდა იყოს მთელი რიცხვი o და 100 – ს შორის.

D. Push-Button (ციფრული შეყვანა)

აქ ჩვენ ვიყენებთ Push-Button- ს, როგორც ციფრულ სენსორს, მაგრამ ეს შეიძლება იყოს ამძრავის "ექო" (ტუმბო, რომელიც ჩართული/გამორთული იყო, მაგალითად).

# განსაზღვრეთ პინი 13 როგორც შეყვანა და გაააქტიურეთ შიდა გამწევი რეზისტორი:

ღილაკი = Pin (13, Pin. IN, Pin. PULL_UP) # ღილაკის წაკითხვის ფუნქცია: def readBut (): დაბრუნების ღილაკი. მნიშვნელობა ()

თქვენ შეგიძლიათ შეამოწმოთ ღილაკი კითხულობს ფუნქციის ბეჭდვას (readBut ()). შედეგის დაჭერისას უნდა იყოს "1". ღილაკზე დაჭერით, შედეგი უნდა იყოს "0"

ნაბიჯი 5: ყველა სენსორის მონაცემების ლოკალიზება და ჩვენება

ახლა, როდესაც ჩვენ შევქმენით ერთი ფუნქცია თითოეული სენსორისთვის, მოდით შევქმნათ ბოლო, რომელიც წაიკითხავს ყველა მათგანს ერთდროულად:

def colectData ():

temp, hum, = readDht () extTemp = readDs () lum = readLdr () butSts = readBut () temp, hum, extTemp, lum, butSts ახლა თუ იყენებთ

ბეჭდვა (colectData ())

გამოიწვევს tuple- ს, რომელიც შეიცავს სენსორების ყველა გადაღებულ მონაცემს:

(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 () # მონაცემების ჩვენება ფუნქციის გამოყენებით dataData (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 ()

ამრიგად, ძირითადი () შესრულებისას, ჩვენ მივიღებთ სენსორის მონაცემებს, რომლებიც ნაჩვენებია 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 იმპორტი onewire, ds18x20 # განსაზღვრეთ რომელ პინთან იქნება დაკავშირებული 1 მავთულის მოწყობილობა ==> pin 2 (D4) dat = Pin (2) # შექმენით ერთი სადენი ობიექტი ds = ds18x20. DS18X20 (onewire. OneWire (dat)) # მოწყობილობების სკანირება ავტობუსის სენსორებზე = ds.scan () # ფუნქცია DS18B20 წაკითხვისას def readDs (): ds.convert_temp () დრო. sleep_ms (750) დაბრუნება რაუნდი (ds.read_temp (სენსორები [0]), 1) # LDR მანქანებიდან იმპორტი ADC # ობიექტის განსაზღვრა adc = ADC (0) # ფუნქცია სიკაშკაშის წასაკითხად def readLdr (): lumPerct = (adc.read ()-40) *(10/86) # გადააკეთეთ პროცენტულად ("რუკა") დააბრუნეთ რაუნდი (lumPerct) # განსაზღვრეთ პინ 13, როგორც შეყვანა და გააქტიურეთ შიდა Pull-up resistor: ღილაკი = Pin (13, Pin. IN, Pin. PULL_UP) # ფუნქცია წაკითხვის ღილაკზე ctData (): temp, hum, = readDht () extTemp = readDs () lum = readLdr () butSts = readBut () დაბრუნების temp, 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 ჩვენი პითონის სკრიპტის LocalData.py ჩატვირთვა /main.py, ასე რომ, სკრიპტი გაშვებისთანავე იმუშავებს:

ampy დააყენეთ localData.py /main /py

თუ ჩვენ ვიყენებთ ბრძანებას amp ls, თქვენ ნახავთ 2 ფაილს ESP შიგნით: boot.py და main.py

თქვენი ESP- ის გადატვირთვა გახდის პროგრამას localData.py ავტომატურად, აჩვენებს სენსორის მონაცემებს ეკრანზე.

ზემოხსენებული ტერმინალის ბეჭდვის ეკრანი აჩვენებს იმას, რაც ჩვენ გავაკეთეთ.

ზემოთ მოყვანილი კოდით, ეკრანი ნაჩვენები იქნება მხოლოდ ერთხელ, მაგრამ ჩვენ შეგვიძლია განვსაზღვროთ მარყუჟი main () ფუნქციაზე, რომელიც აჩვენებს მონაცემებს ყოველ განსაზღვრულ დროის ინტერვალზე (PUB_TIME_SEC) და მაგალითად, სანამ არ დააჭერთ ღილაკს:

# მარყუჟი იღებს მონაცემებს სანამ ღილაკს არ დააჭერთ

ხოლო 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): led.on () sleep (0.5) led.off (off)) ძილი (0.5)

ამრიგად, ჩვენ ახლა შეგვიძლია გადავაწეროთ ჩვენი ძირითადი () ფუნქცია:

ხოლო ღილაკი. მნიშვნელობა ():

led.on () temp, hum, extTemp, lum, butSts = colectData () displayData (temp, hum, extTemp, lum, butSts) led.off () time.sleep (PUB_TIME_SEC) blinkLed (3) ჩვენება Clear ()

საბოლოო კოდის გადმოწერა შესაძლებელია ჩემი GitHub: localData.py– დან და ასევე Jupyter Notebook– დან, რომელიც გამოიყენება სრული კოდის შემუშავებისთვის: Jupyter Local Data Development.

ნაბიჯი 7: ESP– ს დაკავშირება ადგილობრივ WiFi– თან

ქსელის მოდული გამოიყენება WiFi კავშირის კონფიგურაციისთვის. არსებობს ორი WiFi ინტერფეისი, ერთი სადგურისთვის (როდესაც ESP8266 უკავშირდება როუტერს) და ერთი წვდომის წერტილისთვის (სხვა მოწყობილობებისთვის ESP8266– თან დასაკავშირებლად). აქ, ჩვენი ESP იქნება დაკავშირებული ადგილობრივ ქსელთან. მოდით მოვუწოდებთ ბიბლიოთეკას და განვსაზღვროთ ჩვენი ქსელის რწმუნებათა სიგელები:

იმპორტის ქსელი

WiFi_SSID = "YYUR SSID" WiFi_PASS = "თქვენი PASSWORD"

ქვემოთ მოყვანილი ფუნქცია შეიძლება გამოყენებულ იქნას ESP თქვენს ადგილობრივ ქსელთან დასაკავშირებლად:

def do_connect ():

wlan = network. WLAN (network. STA_IF) wlan.active (True) თუ არა wlan.isconnected (): ამობეჭდვა ('ქსელთან დაკავშირება …') 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– ის სწორ მოთხოვნას CONNACK– თან.

MQTT პროტოკოლი მხარს უჭერს ჩაშენებულ ბიბლიოთეკაში მიკროპითონის ორობებში-ეს პროტოკოლი შეიძლება გამოყენებულ იქნას თქვენი ESP8266– დან მონაცემების გაგზავნისთვის WIFI– ით, უფასო ღრუბლოვან მონაცემთა ბაზაში.

მოდით გამოვიყენოთ umqtt.simple ბიბლიოთეკა:

umqtt- დან. მარტივი იმპორტი MQTTC კლიენტი

და ვიცით ჩვენი SERVER ID, შესაძლებელია შევქმნათ ჩვენი MQTT კლიენტის ობიექტი:

SERVER = "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) გამოყენებით, ადრე გამოცხადებული, მარტივი ძირითადი ფუნქცია მონაცემების უწყვეტად გადასაღებად, მათ არხზე შესვლისას იქნება:

მართალია:

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)

გაითვალისწინეთ, რომ მხოლოდ "დატვირთვა" უნდა განახლდეს, მას შემდეგ რაც "თემა" დაკავშირებულია ჩვენს არხის ავტორიტეტთან და არ შეიცვლება.

ეძებთ თქვენს ThingSpeak არხის გვერდს, თქვენ შეამჩნევთ, რომ მონაცემები განუწყვეტლივ იტვირთება თითოეულ ველზე. თქვენ შეგიძლიათ დაფაროთ LDR, დაადოთ ხელი ტემპერატურის/ზარის სენსორებს, დააჭიროთ ღილაკს და ა.შ. და ნახოთ როგორ არხი ავტომატურად "ჩაწერს" ამ მონაცემებს მომავალი ანალიზისთვის.

ჩვეულებრივ, მონაცემთა აღრიცხვისთვის, ჩვენ უნდა შევეცადოთ გამოვიყენოთ რაც შეიძლება ნაკლები ენერგია, ასე რომ, ჩვენ არ გამოვიყენებთ LED- ს ან ჩვენებას ადგილობრივად. ასევე, ეს საერთოა ESP მოწყობილობებთან, ჩააყენეთ ისინი "ღრმა ძილში", სადაც მიკროპროცესორი იქნება მინიმალური ენერგიის მდგომარეობაში, სანამ დრო არ იქნება მონაცემების აღების და გაგზავნის IoT პლატფორმაზე.

მაგრამ, ერთხელ აქ იდეა სწავლობს, მოდით ასევე ჩავრთოთ ეკრანი და LED როგორც ადრე. ამით ჩვენი "ლოგერის" ფუნქცია იქნება:

ხოლო ღილაკი. მნიშვნელობა ():

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.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 APP შეგიძლიათ ჩამოტვირთოთ ANDROID და IPHONE.

ნაბიჯი 12: დასკვნა

როგორც ყოველთვის, ვიმედოვნებ, რომ ეს პროექტი სხვებს დაეხმარება იპოვონ გზა ელექტრონიკის ამაღელვებელ სამყაროში!

დეტალებისა და საბოლოო კოდისათვის ეწვიეთ ჩემს GitHub საცავს: IoT_TS_MQTT

მეტი პროექტისთვის ეწვიეთ ჩემს ბლოგს: MJRoBot.org

სალუდო მსოფლიოს სამხრეთიდან!

შევხვდებით ჩემს შემდეგ ინსტრუქტაჟში!

Გმადლობთ, მარსელო