IoT Made Ease: ESP-MicroPython-MQTT-Thing Μιλήστε: 12 βήματα

2024 Συγγραφέας: John Day | [email protected]. Τελευταία τροποποίηση: 2024-01-30 08:35

Στο προηγούμενο σεμινάριό μου, MicroPython στο ESP χρησιμοποιώντας το Jupyter, μάθαμε πώς να εγκαθιστούμε και να τρέχουμε το MicroPython σε μια συσκευή ESP. Χρησιμοποιώντας το Jupyter Notebook ως περιβάλλον ανάπτυξης, μάθαμε επίσης πώς να διαβάζουμε από αισθητήρες (Θερμοκρασία, Υγρασία και Φωτεινότητα), χρησιμοποιούμε πολλά πρωτόκολλα και μεθόδους επικοινωνίας, Αναλογικά, Digitalηφιακά, 1-Wire και I2C, αυτό το τελευταίο για να εμφανίσουμε τη λήψη δεδομένα σε μια οθόνη OLED.

Τώρα, σε αυτό το σεμινάριο χρησιμοποιώντας ένα πρωτόκολλο MQTT, θα λάβουμε όλα τα δεδομένα που έχουν καταγραφεί, στέλνοντάς τα σε μια υπηρεσία IoT, ThingSpeak.com και σε μια εφαρμογή για κινητά (Thingsview), όπου μπορούμε να συνδεθούμε και να παίξουμε με δεδομένα.

Εδώ, το μπλοκ διάγραμμα του έργου μας:

Βήμα 1: BoM - Bill of Material

1. NodeMCU - 8,39 δολάρια ΗΠΑ
2. Αισθητήρας θερμοκρασίας και σχετικής υγρασίας DHT22 - 9,95 USD
3. Αδιάβροχος αισθητήρας θερμοκρασίας DS18B20 - 5,95 USD
4. OLED Display SSD1366- 8,99 USD (προαιρετικό)
5. LDR (1x)
6. LED (1x) (προαιρετικό)
7. Κουμπί ώθησης (1x)
8. Αντίσταση 4K7 ohm (2x)
9. Αντίσταση 10K ohm (1x)
10. Αντίσταση 220 ohm (1x)

Βήμα 2: The Hw

Το Hw που θα χρησιμοποιήσουμε βασικά είναι το ίδιο που χρησιμοποιείται στο σεμινάριο: Micropython στο ESP Using Jupyter. Ανατρέξτε σε αυτό για όλες τις συνδέσεις HW.

Η εξαίρεση είναι το Servo, που δεν θα χρησιμοποιηθούμε σε αυτό το έργο.

Παρακάτω μπορείτε να δείτε ολόκληρο το HW. Συνδέστε τις συσκευές όπως φαίνεται εκεί.

Βήμα 3: Micropython, REPL, Jupyter

Πρέπει να έχετε έναν διερμηνέα Micropython φορτωμένο στη συσκευή σας ESP. Μόλις φορτωθεί, θα πρέπει να προγραμματίσετε το 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 DHT22

από εισαγωγή μηχανής Pin dht22 = DHT22 (Pin (12))

Τώρα, δημιουργήστε μια λειτουργία για να διαβάσετε τον αισθητήρα DHT:

def readDht ():

dht22.measure () return dht22.temperature (), dht22.humidity () Δοκιμάστε τη λειτουργία DHT

εκτύπωση (readDht ())

Το αποτέλεσμα πρέπει να είναι για παράδειγμα:

(17.7, 43.4)

Β. DS18B20 (Εξωτερική θερμοκρασία)

Ας εγκαταστήσουμε τις βιβλιοθήκες και να δημιουργήσουμε ένα αντικείμενο:

εισαγωγή onewire, 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])

Είναι πάντα σημαντικό να δοκιμάσετε τον αισθητήρα χρησιμοποιώντας τη συνάρτηση που δημιουργήσατε

εκτύπωση (readDs ()) Εάν λάβετε μια τιμή θερμοκρασίας, ο κωδικός σας είναι σωστός

17.5

C. LDR (Φωτεινότητα)

Το LDR θα χρησιμοποιήσει τον αναλογικό πείρο του ESP μας (είναι μόνο ένας στην περίπτωση του ESP8266 και αρκετοί στο ESP32).

Ανατρέξτε στο σεμινάριο ESP32 για λεπτομέρειες.

Όπως και πριν:

# εισαγωγή βιβλιοθήκης

από εισαγωγή μηχανής ADC # Ορισμός αντικειμένου adc = ADC (0) Μια απλή συνάρτηση: adc.read () μπορεί να χρησιμοποιηθεί για την ανάγνωση της τιμής ADC. Αλλά θυμηθείτε ότι το εσωτερικό ADC θα μετατρέψει τάσεις μεταξύ 0 και 3.3V σε αντίστοιχες ψηφιακές τιμές, που κυμαίνονται από 0 έως 1023. Μόλις μας ενδιαφέρει το "Luminosity", θα θεωρήσουμε το Max φως ως τη μέγιστη τιμή λήψης από τον αισθητήρα (στο θήκη 900) και ελάχιστο φως που στην περίπτωσή μου είναι 40. Έχοντας αυτές τις τιμές μπορούμε να "χαρτογραφήσουμε" την τιμή από 40 έως 900 σε 0 έως 100% της φωτεινότητας. Για αυτό, θα δημιουργήσουμε μια νέα συνάρτηση

def readLdr ():

lumPerct = (adc.read ()-40)*(10/86) # μετατροπή σε ποσοστό ("χάρτης") γύρος επιστροφής (lumPerct)

Θα πρέπει να δοκιμάσετε τη λειτουργία χρησιμοποιώντας εκτύπωση (readLDR ()). Το αποτέλεσμα θα πρέπει να είναι ένας ακέραιος αριθμός μεταξύ o και 100.

D. Push-Button (Inηφιακή είσοδος)

Εδώ χρησιμοποιούμε ένα Push-Button ως ψηφιακό αισθητήρα, αλλά θα μπορούσε να είναι μια «ηχώ» ενός ενεργοποιητή (Μια αντλία που ήταν ενεργοποιημένη/απενεργοποιημένη, για παράδειγμα).

# ορίστε τον πείρο 13 ως είσοδο και ενεργοποιήστε μια εσωτερική αντίσταση έλξης:

κουμπί = Pin (13, Pin. IN, Pin. PULL_UP) # Λειτουργία ανάγνωσης κατάσταση κουμπιού: def readBut (): κουμπί επιστροφής. τιμή ()

Μπορείτε να δοκιμάσετε το κουμπί που διαβάζει τη λειτουργία εκτύπωσης (readBut ()). Πιέζοντας το αποτέλεσμα, πρέπει να είναι "1". Πατώντας το κουμπί, το αποτέλεσμα πρέπει να είναι "0"

Βήμα 5: Καταγραφή και εμφάνιση τοπικά όλων των δεδομένων αισθητήρα

Τώρα που έχουμε δημιουργήσει μία συνάρτηση για κάθε αισθητήρα, ας δημιουργήσουμε την τελευταία που θα τις διαβάζει όλες ταυτόχρονα:

def colectData ():

temp, βουητό, = readDht () extTemp = readDs () lum = readLdr () butSts = readBut () επιστροφή θερμοκρασίας, βουητό, extTemp, lum, butSts Τώρα αν χρησιμοποιείτε

εκτύπωση (colectData ())

Θα οδηγήσει σε μια πλειάδα που περιλαμβάνει όλα τα δεδομένα που έχουν ληφθεί από τους αισθητήρες:

(17.4, 45.2, 17.3125, 103, 1)

Μπορούμε επίσης προαιρετικά να εμφανίσουμε αυτά τα δεδομένα σε μια τοπική οθόνη:

# εισαγωγή βιβλιοθήκης και δημιουργία αντικειμένου i2c

από εισαγωγή μηχανής I2C i2c = I2C (scl = Καρφίτσα (5), sda = Καρφίτσα (4)) # εισαγωγή βιβλιοθήκης και δημιουργία αντικειμένου oled import 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 ("Κουμπί:" + 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 time time import # define pin 0 as output output = Pin (0, Pin. OUT) # DHT from dht import DHT22 dht22 = DHT22 (Pin (12)) # Λειτουργία ανάγνωσης DHT def readDht (): dht22.measure () return dht22.temperature (), dht22.humidity () # DS18B20 import onewire, ds18x20 # Ορίστε σε ποια καρφίτσα θα συνδεθεί η συσκευή 1 καλωδίου ==> pin 2 (D4) dat = Pin (2) # Δημιουργήστε το onewire αντικείμενο 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) # λειτουργία για ανάγνωση φωτεινότητας def readLdr (): lumPerct = (adc.read ()-40) *(10/86) # μετατροπή σε ποσοστό ("χάρτης") γύρος επιστροφής (lumPerct) # ορίστε τον ακροδέκτη 13 ως είσοδο και ενεργοποιήστε μια εσωτερική αντίσταση έλξης: κουμπί = Καρφίτσα (13, Pin. IN, Pin. PULL_UP) # Λειτουργία για ανάγνωση κατάσταση κουμπιού: def readBut (): button return.value () # Λειτουργία ανάγνωσης όλων των δεδομένων: def cole ctData (): temp, hum, = readDht () extTemp = readDs () lum = readLdr () butSts = readBut () return temp, hum, extTemp, lum, butSts # βιβλιοθήκη εισαγωγής και δημιουργία αντικειμένου i2c από εισαγωγή μηχανής I2C i2c = I2C (scl = Pin (5), sda = Pin (4)) # εισαγωγή βιβλιοθήκης και δημιουργία αντικειμένου oled import 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 () ""- ----- εκτελέστε την κύρια λειτουργία -------- "" main ()

Αποθηκεύστε το, για παράδειγμα ως localData.py.

Για να εκτελέσετε αυτόν τον κώδικα απευθείας στο τερματικό σας θα χρειαστείτε το Ampy.

Αρχικά, στο Terminal ας ενημερώσουμε την Ampy τη σειριακή μας θύρα:

εξαγωγή AMPY_PORT =/dev/tty. SLAB_USBtoUART

Τώρα, μπορούμε να δούμε τα αρχεία που βρίσκονται μέσα στον ριζικό κατάλογο ESP:

ampy ls

Ως απάντηση, θα λάβουμε το boot.py, αυτό είναι το πρώτο αρχείο που θα τρέξει στο σύστημα.

Τώρα, ας χρησιμοποιήσουμε την Ampy για να φορτώσουμε το Python Script LocalData.py ως /main.py, οπότε το σενάριο θα τρέξει αμέσως μετά την εκκίνηση:

ampy βάλτε localData.py /main /py

Εάν χρησιμοποιούμε την εντολή amp ls τώρα, θα δείτε 2 αρχεία μέσα στο ESP.: 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): led.on () sleep (0.5) led.off () ύπνος (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

Η μονάδα δικτύου χρησιμοποιείται για τη διαμόρφωση της σύνδεσης 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 ('Connect to network…') wlan.connect (WiFi_SSID, WiFi_SSID) ενώ δεν wlan.isconnected (): pass εκτύπωση ('network config:', 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, ήταν η διεύθυνση IP ESP.

Βήμα 8: Το ThingSpeak

Σε αυτό το σημείο, μάθαμε πώς να συλλαμβάνουμε δεδομένα από όλους τους αισθητήρες, εμφανίζοντάς τους στο OLED μας. Τώρα, ήρθε η ώρα να δούμε πώς να στείλουμε αυτά τα δεδομένα σε μια πλατφόρμα IoT, το ThingSpeak.

Ας ξεκινήσουμε!

Πρώτον, πρέπει να έχετε λογαριασμό στο ThinkSpeak.com. Στη συνέχεια, ακολουθήστε τις οδηγίες για να δημιουργήσετε ένα κανάλι και λάβετε υπόψη το αναγνωριστικό καναλιού και το κλειδί 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 υποστηρίζεται σε μια ενσωματωμένη βιβλιοθήκη στα δυαδικά αρχεία Micropython-αυτό το πρωτόκολλο μπορεί να χρησιμοποιηθεί για την αποστολή δεδομένων από το ESP8266, μέσω WIFI, σε μια δωρεάν βάση δεδομένων cloud.

Ας χρησιμοποιήσουμε την απλή βιβλιοθήκη umqtt.s:

από το umqtt.simple import MQTTClient

Και γνωρίζοντας το SERVER ID μας, είναι δυνατό να δημιουργήσουμε το αντικείμενο πελάτη MQTT:

SERVER = "mqtt.thingspeak.com"

client = MQTTClient ("umqtt_client", SERVER)

Τώρα, διαθέτοντας τα διαπιστευτήριά σας ThingSpeak:

CHANNEL_ID = "YOUR CHANNEL ID"

WRITE_API_KEY = "ΤΟ ΚΛΕΙΔΙ ΣΟΥ ΕΔΩ"

Ας δημιουργήσουμε το "Θέμα" του MQTT:

topic = "κανάλια/" + CHANNEL_ID + "/δημοσίευση/" + WRITE_API_KEY

Ας στείλουμε τα δεδομένα μας στην υπηρεσία ThingSpeak IoT, χρησιμοποιώντας τη συνάρτηση που δημιουργήθηκε και συσχετίσουμε την απόκριση με συγκεκριμένες μεταβλητές δεδομένων:

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

Με αυτές τις μεταβλητές ενημερωμένες, μπορούμε να δημιουργήσουμε το "MQTT Payload":

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 (topic, payload) 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 () ωφέλιμο φορτίο = "field1 ="+str (temp)+"& field2 ="+str (hum)+"& field3 ="+str (extTemp)+"& field4 ="+str (lum)+"& field5 ="+str (butSts) πελάτης.connect () client.publish (topic, payload) client.disconnect () time.sleep (PUB_TIME_SEC) blinkLed (3) displayClear ()

Μπορείτε να βρείτε εδώ το πλήρες σενάριο microPython: dataLoggerTS_EXT.py και το σημειωματάριο Jupyter που χρησιμοποιήθηκε για ανάπτυξη: IoT ThingSpeak Data Logger EXT.ipynb.

Για να ανεβάσετε το σενάριο στο ESP, στο τερματικό σας χρησιμοποιήστε την εντολή:

ampy put dataLoggerTS.py /main.py

Και πατήστε το κουμπί ESP - επαναφορά. Θα έχετε το ESP να καταγράφει δεδομένα και να τα καταγράφει στο ThingSpeak.com μέχρι να κρατηθεί πατημένο το κάτω μέρος (περιμένετε να αναβοσβήνει η λυχνία LED 3 φορές και το OLED να απενεργοποιηθεί).

Βήμα 11: Η εφαρμογή ThingView

Τα δεδομένα που καταγράφονται μπορούν να προβληθούν απευθείας στον ιστότοπο ThingSpeak.com ή μέσω μιας εφαρμογής, για παράδειγμα, ThingsView!

Το ThingView είναι μια εφαρμογή που αναπτύχθηκε από τη CINETICA, η οποία σας επιτρέπει να απεικονίσετε τα κανάλια σας ThingSpeak με έναν εύκολο τρόπο, απλώς εισάγετε το αναγνωριστικό καναλιού και είστε έτοιμοι να ξεκινήσετε.

Για δημόσια κανάλια, η εφαρμογή θα σέβεται τις ρυθμίσεις των παραθύρων σας: χρώμα, χρονοδιάγραμμα, τύπο γραφήματος και τον αριθμό των αποτελεσμάτων. Η τρέχουσα έκδοση υποστηρίζει γραφήματα γραμμών και στηλών, τα γραφήματα spline εμφανίζονται ως γραφήματα γραμμών.

Για ιδιωτικά κανάλια, τα δεδομένα θα εμφανίζονται χρησιμοποιώντας τις προεπιλεγμένες ρυθμίσεις, καθώς δεν υπάρχει τρόπος ανάγνωσης των ρυθμίσεων ιδιωτικών παραθύρων μόνο με το κλειδί API.

Μπορείτε να κατεβάσετε την εφαρμογή ThingView για ANDROID και IPHONE.

Βήμα 12: Συμπέρασμα

Όπως πάντα, ελπίζω ότι αυτό το έργο μπορεί να βοηθήσει άλλους να βρουν τον δρόμο τους στον συναρπαστικό κόσμο των ηλεκτρονικών!

Για λεπτομέρειες και τελικό κώδικα, επισκεφθείτε το αποθετήριο GitHub: IoT_TS_MQTT

Για περισσότερα έργα, επισκεφθείτε το ιστολόγιό μου: MJRoBot.org

Saludos από τον νότο του κόσμου!

Τα λέμε στο επόμενο διδακτικό μου!

Σας ευχαριστώ, Μαρσέλο