קלות IoT: ESP-MicroPython-MQTT-Thing דיבור: 12 שלבים

2024 מְחַבֵּר: John Day | [email protected]. שונה לאחרונה: 2024-01-30 09:15

במדריך הקודם שלי, MicroPython ב- ESP באמצעות Jupyter, למדנו כיצד להתקין ולהפעיל MicroPython במכשיר ESP. באמצעות Jupyter Notebook כסביבת הפיתוח שלנו, למדנו גם כיצד לקרוא מחיישנים (טמפרטורה, לחות וספיקות), אנו משתמשים במספר פרוטוקולי שיטות ושיטות, אנלוגי, דיגיטלי, 1-Wire ו- I2C, האחרון להציג את הלכידות שלנו נתונים על צג OLED.

כעת, במדריך זה באמצעות פרוטוקול MQTT, נקבל את כל הנתונים שנתפסו, ונשלח אותם לשירות IoT, ThingSpeak.com ולאפליקציה לנייד (Thingsview), שבה נוכל להיכנס ולשחק עם נתונים.

להלן תרשים הבלוקים של הפרויקט שלנו:

שלב 1: BoM - שטר החומר

1. NodeMCU - 8.39 דולר ארה"ב
2. חיישן טמפרטורה ולחות יחסית DHT22 - 9.95 דולר
3. חיישן טמפרטורה עמיד למים DS18B20 - 5.95 דולר
4. תצוגת OLED SSD1366- 8.99 דולר (אופציונלי)
5. LDR (1x)
6. נוריות (1x) (אופציונלי)
7. לחצן לחיצה (1x)
8. התנגדות 4K7 אוהם (2x)
9. התנגדות 10K אוהם (1x)
10. התנגדות 220 אוהם (1x)

שלב 2: Hw

ה- Hw בו נשתמש כאן בעצם הוא אותו שימוש בהדרכה: Micropython ב- ESP Using Jupyter. עיין בו עבור כל חיבורי HW.

היוצא מן הכלל הוא סרוו, שלא נשתמש בו בפרויקט זה.

למעלה אתה יכול לראות את HW המלא. חבר את המכשירים כפי שמוצג שם.

שלב 3: Micropython, REPL, Jupyter

עליך להיות בעל מתורגמן של Micropython במכשיר ה- ESP שלך. לאחר הטעינה, עליך לתכנת את ה- ESP שלך בכל אחת מהדרכים/IDE הזמינות הזמינות, כגון:

• REPL
• מחברת Jupyter
• מו
• ESPCut (Windows בלבד)
• … וכו

במדריך שלי, Micropython ב- ESP באמצעות 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 () החזר dht22.temperature (), dht22.humidity () בדוק את פונקציית DHT

הדפס (readDht ())

התוצאה צריכה להיות למשל:

(17.7, 43.4)

B. DS18B20 (טמפרטורה חיצונית)

בואו להתקין את הספריות וליצור אובייקט:

יבוא onewire, ds18x20

זמן ייבוא # הגדר איזה סיכה המכשיר בעל החוט האחד יתחבר ==> סיכה 2 (D4) dat = פין (2) # צור את האובייקט onewire ds = ds18x20. DS18X20 (onewire. OneWire (dat)) סרוק אחר מכשירים ב- bu

חיישנים = ds.scan ()

print ('התקנים שנמצאו:', חיישנים)

התוצאה המודפסת לא ממש חשובה, מה שנצטרך הוא החיישן הראשון שזוהה: חיישנים [0]. ועכשיו, אנו יכולים לבנות פונקציה לקריאת נתוני חיישן:

def readDs ():

ds.convert_temp () time.sleep_ms (750) החזר ds.read_temp (חיישנים [0])

תמיד חשוב לבדוק את החיישן באמצעות הפונקציה שנוצרה

הדפס (readDs ()) אם אתה מקבל ערך טמפרטורה, הקוד שלך נכון

17.5

ג LDR (בהירות)

ה- LDR ישתמש בסיכה האנלוגית של ה- ESP שלנו (הוא רק אחד במקרה של ESP8266 וכמה ל- ESP32).

עיין במדריך ESP32 שלי לפרטים.

אותו דבר כפי שנעשה קודם לכן:

# ספריית יבוא

מתוך ייבוא מכונה ADC # הגדר אובייקט adc = ADC (0) פונקציה פשוטה: ניתן להשתמש ב- adc.read () לקריאת ערך ה- ADC. אך זכור כי ה- ADC הפנימי ימיר מתח בין 0 ל- 3.3V בערכים דיגיטליים של המתכתבים, המשתנה בין 0 ל- 1023. ברגע שנעניין את "Luminosity", נתייחס למקס אור כערך המרבי שנלכד מהחיישן (אצלי מקרה 900) ואור מינימלי שבמקרה שלי הוא 40. לאחר ערכים אלה נוכל "למפות" את הערך מ -40 עד 900 ב -0 עד 100% מהאור. לשם כך ניצור פונקציה חדשה

def readLdr ():

lumPerct = (adc.read ()-40)*(10/86) # המרה באחוזים ("מפה") סיבוב החזרה (lumPerct)

עליך לבדוק את הפונקציה באמצעות הדפסה (readLDR ()). התוצאה צריכה להיות מספר שלם בין o ל- 100.

ד לחצן (כניסה דיגיטלית)

כאן אנו משתמשים בלחצן לחיצה כחיישן דיגיטלי, אך זה יכול להיות "הד" של מפעיל (משאבה שהופעלה/כבויה, למשל).

# הגדר את סיכה 13 כקלט והפעל נגד הנגינה הפנימית:

כפתור = Pin (13, Pin. IN, Pin. PULL_UP) # פונקציה לקריאת מצב הלחצן: def readBut (): button button.value ()

אתה יכול לבדוק את הכפתור הקריא את הדפסת הפונקציות (readBut ()). ללא לחיצה על התוצאה צריכה להיות "1". לחיצה על הכפתור, התוצאה צריכה להיות "0"

שלב 5: לכידה והצגה מקומית של כל נתוני החיישן

כעת, לאחר שיצרנו פונקציה אחת לכל חיישן, בואו ניצור את האחרונה שתקרא את כולם בו זמנית:

def colectData ():

temp, hum, = readDht () extTemp = readDs () lum = readLdr () butSts = readBut () טמפ 'החזרה, זמזום, extTemp, lum, butSts עכשיו אם אתה משתמש

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

כאופציה, אני אכלול גם את הנורית כדי להיות דולקת כאשר אנו מתחילים לקרוא חיישנים, כבויה לאחר הצגת הנתונים. פעולה זו תעזור לאשר שהתוכנית פועלת כאשר ניתוק ה- ESP מהמחשב פועל אוטומטית.

אז הפונקציה העיקרית תהיה:

# הפונקציה העיקרית לקריאת כל החיישנים

def main (): # נתוני תצוגה עם פונקציה led.on () temp, hum, extTemp, lum, butSts = colectData () displayData (temp, hum, extTemp, lum, butSts) led.off ()

אז, בביצוע main (), נקבל את נתוני החיישן המוצגים ב- OLED כפי שמוצג בתמונה.

שלב 6: הפעלת קוד התחנה המקומית בהפעלה של ESP

כל מה שפותח עד כה יכול להיות על קובץ יחיד שיבוצע על ידי ה- ESP שלנו.

בואו נפתח כל עורך טקסט והעברנו עליו את כל הקוד:

# ייבוא ספריות כלליות

מייבוא מכונה זמן ייבוא פין # הגדר סיכה 0 כפלט led = Pin (0, Pin. OUT) # DHT מיבוא dht DHT22 dht22 = DHT22 (פין (12)) # פונקציה לקריאת DHT def readDht (): dht22.measure () החזר dht22.temperature (), dht22.humidity () # DS18B20 יבוא onewire, ds18x20 # הגדר איזה סיכה המכשיר בעל חוט אחד יתחבר ==> סיכה 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) # פונקציה לקריאת בהירות def readLdr (): lumPerct = (adc.read ()-40) *(10/86) # המרה באחוזים ("מפה") סיבוב החזרה (lumPerct) # הגדירו את סיכה 13 ככניסה והפעילו נגד משיכה פנימי: כפתור = סיכה (13, Pin. IN, Pin. PULL_UP) # מצב כפתור קריאה של פונקציה: def readBut (): לחצן return.value () # פונקציה לקריאת כל הנתונים: def cole ctData (): temp, hum, = readDht () extTemp = readDs () lum = readLdr () butSts = readBut () החזר טמפ, זמזום, 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 () ""- ----- הפעל את הפונקציה הראשית -------- "" main ()

שמור אותו, למשל בתור localData.py.

כדי להריץ קוד זה ישירות במסוף שלך תזדקק ל- Ampy.

ראשית, בטרמינל בואו להודיע לאמפי את הנמל הסידורי שלנו:

ייצא AMPY_PORT =/dev/tty. SLAB_USBtoUART

כעת, אנו יכולים לראות את הקבצים הנמצאים בתוך ספריית השורשים של ESP שלנו:

אמפי ls

כתגובה, נקבל boot.py, זהו הקובץ הראשון שירוץ במערכת.

כעת, בואו נשתמש ב- Ampy כדי לטעון את סקריפט ה- python LocalData.py שלנו כ /main.py, כך שהתסריט יפעל מיד לאחר האתחול:

ampy לשים localData.py /main /py

אם נשתמש במגבר הפקודה 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 פונקציות כלליות חדשות, אחת לניקוי התצוגה ואחת להבהוב הנורית במספר פעמים מסוים.

# תצוגה ברורה:

def displayClear (): oled.fill (0) oled.show () # צור פונקציית מצמוץ def blinkLed (num): עבור i בטווח (0, num): led.on () שינה (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 המשמשת לפיתוח קוד מלא: פיתוח נתונים מקומיים של Jupyter.

שלב 7: חיבור ה- ESP ל- WiFi המקומי

מודול הרשת משמש להגדרת חיבור ה- WiFi. ישנם שני ממשקי WiFi, אחד לתחנה (כאשר ה- ESP8266 מתחבר לנתב) ואחד לנקודת הגישה (למכשירים אחרים להתחבר ל- ESP8266). כאן, ה- ESP שלנו יחובר לרשת המקומית. נתקשר לספרייה ונגדיר את אישורי הרשת שלנו:

רשת יבוא

WiFi_SSID = "SSID שלך" WiFi_PASS = "סיסמתך"

ניתן להשתמש בפונקציה שלהלן לחיבור ה- ESP לרשת המקומית שלך:

def do_connect ():

wlan = network. WLAN (network. STA_IF) wlan.active (נכון) אם לא wlan.isconnected (): הדפסה ('מתחבר לרשת …') wlan.connect (WiFi_SSID, WiFi_SSID) בזמן שאינו wlan.isconnected (): הדפס print ('config 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: The 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 של Write. המתווך מאשר בקשת CONNECT נכונה עם CONNACK.

פרוטוקול MQTT נתמך בספרייה מובנית בקבוצות הבינאריות של Micropython-ניתן להשתמש בפרוטוקול זה כדי לשלוח נתונים מה- ESP8266 שלך, באמצעות WIFI, למסד נתונים בענן בחינם.

בואו נשתמש בספריית umqtt.simple:

מאת umqtt.simport פשוט MQTTClient

ובהכרת מזהה השרת שלנו, אפשר ליצור אובייקט לקוח MQTT שלנו:

SERVER = "mqtt.thingspeak.com"

לקוח = MQTTClient ("umqtt_client", SERVER)

עכשיו, עם אישורי ThingSpeak שלך בהישג יד:

CHANNEL_ID = "מזהה הערוץ שלך"

WRITE_API_KEY = "המפתח שלך כאן"

בואו ניצור את "הנושא" MQTT שלנו:

topic = "ערוצים/" + CHANNEL_ID + "/פרסם/" + WRITE_API_KEY

בואו נשלח את הנתונים שלנו לשירות IoT ThingSpeak, באמצעות הפונקציה שנוצרה ונשייך את תגובתה למשתני נתונים ספציפיים:

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

כאשר המשתנים האלה מעודכנים, אנו יכולים ליצור את "מטען ה- MQTT" שלנו:

מטען = "field1 ="+str (temp)+"& field2 ="+str (hum)+"& field3 ="+str (extTemp)+"& field4 ="+str (lum)+"& field5 ="+str (butSts)

וזה הכל! אנו מוכנים לשלוח נתונים ל- ThinsSpeak, פשוט באמצעות שלוש שורות הקוד שלהלן:

client.connect ()

client.publish (נושא, מטען) client.disconnect ()

עכשיו, אם אתה עובר לדף הערוץ שלך (כמו שלי למעלה) תראה שלכל אחד מחמשת השדות יהיו נתונים הקשורים לחיישנים שלך.

שלב 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 (נושא, מטען) 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 עד ללחוץ על החלק התחתון (המתן עד שהנורית תמצמץ 3 פעמים וכיבוי ה- OLED).

שלב 11: אפליקציית ThingView

ניתן להציג את הנתונים שנרשמו ישירות באתר ThingSpeak.com או באמצעות אפליקציה, למשל, ThingsView!

ThingView הוא אפליקציה שפותחה על ידי CINETICA, המאפשרת לך לדמיין את ערוצי ThingSpeak שלך בצורה קלה, פשוט הזן את מזהה הערוץ ואתה מוכן לצאת לדרך.

עבור ערוצים ציבוריים, היישום יכבד את הגדרות החלונות שלך: צבע, טווח זמן, סוג תרשים ומספר התוצאות. הגרסה הנוכחית תומכת בתרשימי קווים ועמודות, תרשימי הטבלה מוצגים כתרשימי קווים.

עבור ערוצים פרטיים, הנתונים יוצגו באמצעות הגדרות ברירת המחדל, מכיוון שאין דרך לקרוא את הגדרות החלונות הפרטיים באמצעות מפתח ה- API בלבד.

ניתן להוריד את האפליקציה ThingView עבור ANDROID ו- IPHONE.

שלב 12: סיכום

כמו תמיד, אני מקווה שהפרויקט הזה יכול לעזור לאחרים למצוא את דרכם לעולם האלקטרוניקה המרגש!

לפרטים וקוד סופי, בקר במאגר GitHub שלי: IoT_TS_MQTT

לפרויקטים נוספים, בקר בבלוג שלי: MJRoBot.org

כל הכבוד מדרום העולם!

נתראה במדריך הבא שלי!

תודה, מרסלו