IoT atviegloja: ESP-MicroPython-MQTT-ThingSpeak: 12 soļi

2024 Autors: John Day | [email protected]. Pēdējoreiz modificēts: 2024-01-30 10:55

Iepriekšējā apmācībā, MicroPython par ESP, izmantojot Jupyter, mēs uzzinājām, kā instalēt un palaist MicroPython ESP ierīcē. Izmantojot Jupyter piezīmjdatoru kā mūsu izstrādes vidi, mēs arī iemācījāmies lasīt no sensoriem (temperatūra, mitrums un spilgtums). Mēs izmantojam vairākus sakaru protokolus un metodes, analogo, digitālo, 1 vadu un I2C, pēdējo, lai parādītu mūsu uzņemtos datus OLED displejā.

Tagad šajā apmācībā, izmantojot MQTT protokolu, mēs iegūsim visus iegūtos datus, nosūtot tos uz IoT pakalpojumu ThingSpeak.com un uz mobilo lietotni (Thingsview), kur mēs varam reģistrēties un spēlēties ar datiem.

Šeit ir mūsu projekta blokshēma:

1. solis: BoM - materiālu saraksts

1. NodeMCU - 8,39 ASV dolāri
2. DHT22 temperatūras un relatīvā mitruma sensors - USD 9,95
3. Ūdensnecaurlaidīgs temperatūras sensors DS18B20 - USD 5,95
4. OLED displejs SSD1366- USD 8,99 (pēc izvēles)
5. LDR (1x)
6. LED (1x) (pēc izvēles)
7. Spiedpoga (1x)
8. Rezistors 4K7 omi (2x)
9. Rezistors 10K omi (1x)
10. Rezistors 220 omi (1x)

2. solis: Hw

Hw, ko mēs šeit izmantosim, būtībā ir tas pats, kas izmantots apmācībā: Micropython par ESP, izmantojot Jupyter. Skatiet to visiem HW savienojumiem.

Izņēmums ir Servo, ka mēs netiksim izmantoti šajā projektā.

Augšpusē varat redzēt pilnu HW. Pievienojiet ierīces, kā parādīts tur.

3. solis: Micropython, REPL, Jupyter

ESP ierīcē jābūt ielādētam Micropython tulkam. Pēc ielādes jums jāprogrammē ESP, izmantojot jebkuru no pieejamajiem veidiem/IDE, piemēram:

• REPL
• Jupyter piezīmju grāmatiņa
• Mu
• ESPCut (tikai Windows)
• … Utt

Savā apmācībā Micropython par ESP Izmantojot Jupyter, es detalizēti aprakstīju, kā lejupielādēt un instalēt MicroPython tulku, ESPTool, lai pārvaldītu ESP ierīces un kā izmantot Jupyter piezīmjdatoru kā izstrādes vidi. Jūtieties brīvi izmantot to, kas jums ir ērtāks.

Parasti visu izstrādi veicu Jupyter piezīmjdatorā, un, tiklīdz esmu ieguvis galīgo kodu, nokopēju tos uz Geany un ielādēju to savā ESP, izmantojot Ampy.

4. solis: sensori

Instalēsim bibliotēkas, definēsim GPIO, izveidosim objektus, funkcijas visiem sensoriem atsevišķi:

A. DHT (temperatūra un mitrums)

Instalēsim DHT bibliotēku un izveidosim objektu:

no dht importa DHT22

no mašīnas importēšanas Pin dht22 = DHT22 (Pin (12))

Tagad izveidojiet funkciju DHT sensora nolasīšanai:

def readDht ():

dht22.measure () atgriežas dht22.temperatūra (), dht22. mitrums () Pārbaudiet DHT funkciju

drukāt (lasītDht ())

Rezultātam vajadzētu būt, piemēram:

(17.7, 43.4)

B. DS18B20 (ārējā temperatūra)

Instalēsim bibliotēkas un izveidosim objektu:

importēt onewire, ds18x20

importēšanas laiks # Nosakiet, kura tapa tiks pievienota 1 vadu ierīcei ==> pin 2 (D4) dat = Pin (2) # izveidojiet onewire objektu ds = ds18x20. DS18X20 (onewire. OneWire (dat)) Meklējiet ierīces bu

sensori = ds.scan ()

drukāt ('atrastās ierīces:', sensori)

Izdrukātajam rezultātam nav īsti nozīmes, mums būs vajadzīgs pirmais atklātais sensors: sensori [0]. Un tagad mēs varam izveidot funkciju sensoru datu nolasīšanai:

def readDs ():

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

Vienmēr ir svarīgi pārbaudīt sensoru, izmantojot izveidoto funkciju

drukāt (lasītDs ()) Ja iegūstat temperatūras vērtību, jūsu kods ir pareizs

17.5

C. LDR (spožums)

LDR izmantos mūsu ESP analogo tapu (tas ir tikai viens ESP8266 gadījumā un vairāki - ESP32).

Sīkāku informāciju skatiet manā ESP32 apmācībā.

Līdzīgi kā iepriekš:

# importēt bibliotēku

no mašīnas importēšanas ADC # Definēt objektu adc = ADC (0) Vienkārša funkcija: adc.read () var izmantot, lai nolasītu ADC vērtību. Bet atcerieties, ka iekšējais ADC pārveidos spriegumus no 0 līdz 3,3 V atbilstošās digitālajās vērtībās, kas svārstās no 0 līdz 1023. Tiklīdz mūs interesēs “Spilgtums”, mēs uzskatīsim Max gaismu par maksimālo uztverto vērtību no sensora (manā 900. gadījums) un minimālais apgaismojums, kas manā gadījumā ir 40. Ņemot šīs vērtības, mēs varam "kartēt" vērtību no 40 līdz 900 0 līdz 100% spožuma. Šim nolūkam mēs izveidosim jaunu funkciju

def readLdr ():

lumPerct = (adc.read ()-40)*(10/86) # konvertēt procentos ("karte") atgriešanās kārta (lumPerct)

Jums jāpārbauda funkcija, izmantojot druku (readLDR ()). Rezultātam jābūt veselam skaitlim no o līdz 100.

D. Spiedpoga (digitālā ievade)

Šeit mēs izmantojam spiedpogu kā digitālo sensoru, taču tas varētu būt izpildmehānisma “atbalss” (piemēram, sūknis, kas tika ieslēgts/izslēgts).

# definējiet tapu 13 kā ieeju un aktivizējiet iekšējo uzvilkšanas rezistoru:

poga = Pin (13, Pin. IN, Pin. PULL_UP) # Funkcija pogas stāvokļa lasīšanai: def readBut (): atgriešanās poga.value ()

Jūs varat pārbaudīt pogu, kas nolasa funkciju print (readBut ()). Bez nospiešanas rezultātam jābūt "1". Nospiežot pogu, rezultātam jābūt "0"

5. darbība: visu sensora datu uztveršana un lokāla parādīšana

Tagad, kad esam izveidojuši vienu funkciju katram sensoram, izveidosim pēdējo, kas visus nolasīs vienlaikus:

def colectData ():

temp, hum, = readDht () extTemp = readDs () lum = readLdr () butSts = readBut () atgriešanās temp, hum, extTemp, lum, butSts Tagad, ja jūs izmantojat

drukāt (colectData ())

Tiks izveidota karte, kas ietver visus uztvertos datus no sensoriem:

(17.4, 45.2, 17.3125, 103, 1)

Pēc izvēles mēs varam arī parādīt šos datus vietējā displejā:

# importējiet bibliotēku un izveidojiet objektu i2c

no mašīnas importēšanas I2C i2c = I2C (scl = Pin (5), sda = Pin (4)) # importēt bibliotēku un izveidot objektu oled import ssd1306 i2c = I2C (scl = Pin (5), sda = Pin (4)) oled = ssd1306. SSD1306_I2C (128, 64, i2c, 0x3c) # izveidot funkciju: 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 () # parādīt datus, izmantojot funkciju displayData (temp, hum, extTemp, lum, butSts)

Kā opciju es iekļaušu arī gaismas diodi, kas jāieslēdz, kad mēs sākam lasīt sensorus, un pēc šo datu parādīšanas tie izslēdzas. Tas palīdzēs apstiprināt, ka programma darbojas, kad ESP ir atvienots no datora un darbojas automātiski.

Tātad galvenā funkcija būtu:

# Galvenā funkcija visu sensoru nolasīšanai

def main (): # displeja dati ar funkciju led.on () temp, hum, extTemp, lum, butSts = colectData () displayData (temp, hum, extTemp, lum, butSts) led.off ()

Tātad, izpildot galveno (), mēs iegūsim sensoru datus, kas parādīti OLED, kā parādīts attēlā.

6. darbība. Vietējās stacijas koda palaišana ESP palaišanas laikā

Mēs varam iegūt visu, kas līdz šim ir izstrādāts, vienā failā, kas jāizpilda mūsu ESP.

Atvērsim jebkuru teksta redaktoru un visu to kodu:

# importēt vispārējās bibliotēkas

no mašīnas importēšanas Pin importēšanas laiks # definējiet tapu 0 kā izvades LED = Pin (0, Pin. OUT) # DHT no dht importēšanas DHT22 dht22 = DHT22 (Pin (12)) # Funkcija, lai lasītu DHT def readDht (): dht22.measure () atgriezt dht22.temperature (), dht22.humidity () # DS18B20 importēt onewire, ds18x20 # Nosakiet, kura tapa tiks pievienota 1 vadu ierīcei ==> pin 2 (D4) dat = Pin (2) # Izveidojiet vienu vadu objekts ds = ds18x20. DS18X20 (onewire. OneWire (dat)) # ierīču meklēšana kopnes sensoros = ds.scan () # funkcija, lai lasītu DS18B20 def readDs (): ds.convert_temp () time.sleep_ms (750) return kārta (ds.read_temp (sensori [0])), 1) # LDR no mašīnas importēšanas ADC # Definēt objektu adc = ADC (0) #funkcija, lai nolasītu spilgtumu def readLdr (): lumPerct = (adc.read ()-40) *(10/86) # konvertēt procentos ("karte") atgriešanās kārta (lumPerct) # definējiet tapu 13 kā ievadi un aktivizējiet iekšējo uzvilkšanas rezistoru: poga = tapa (13, Pin. IN, Pin. PULL_UP) # Funkcija, lai lasītu pogas stāvokli: def readBut (): atgriešanās poga. Vērtība () # Funkcija visu datu nolasīšanai: def cole ctData (): temp, hum, = readDht () extTemp = readDs () lum = readLdr () butSts = readBut () atgriezt temp, hum, extTemp, lum, butSts # importēt bibliotēku un izveidot objektu i2c no mašīnas importēšanas I2C i2c = I2C (scl = Pin (5), sda = Pin (4)) # importēt bibliotēku un izveidot objektu oled import ssd1306 i2c = I2C (scl = Pin (5), sda = Pin (4)) oled = ssd1306. SSD1306_I2C (128, 64, i2c, 0x3c) # izveidot funkciju: 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 () # Galvenā funkcija visu sensoru nolasīšanai def main (): # displeja dati ar funkciju led.on () temp, hum, extTemp, lum, butSts = colectData () displayData (temp, hum, extTemp, lum, butSts) led.off () ""-- ----- palaist galveno funkciju -------- '' 'main ()

Saglabājiet to, piemēram, kā localData.py.

Lai palaistu šo kodu tieši savā terminālī, jums būs nepieciešams Ampy.

Pirmkārt, terminālī informēsim Ampy mūsu seriālo portu:

eksportēt AMPY_PORT =/dev/tty. SLAB_USBtoUART

Tagad mēs varam redzēt failus, kas atrodas mūsu ESP saknes direktorijā:

ampy ls

Kā atbildi mēs saņemsim boot.py, tas ir pirmais fails, kas darbosies sistēmā.

Tagad izmantosim Ampy, lai ielādētu mūsu python Script LocalData.py kā /main.py, tāpēc skripts tiks palaists tūlīt pēc sāknēšanas:

ampy ielieciet localData.py /main /py

Ja mēs tagad izmantojam komandu amp ls, ESP iekšpusē redzēsit 2 failus: boot.py un main.py

Atiestatot ESP, programma localData.py tiks palaista automātiski, parādot displejā sensora datus.

Iepriekš redzamais termināļa drukas ekrāns parāda mūsu paveikto.

Izmantojot iepriekš minēto kodu, displejs tiks parādīts tikai vienu reizi, bet mēs varam definēt cilpu galvenajā () funkcijā, kas parādīs datus par katru noteikto laika intervālu (PUB_TIME_SEC) un, piemēram, līdz mēs nospiežam pogu:

# cilpa iegūst datus, līdz tiek nospiesta poga

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

Mainīgais PUB_TIME_SEC ir jādeklarē līdz brīdim, kad vēlaties iegūt savus paraugus.

Lai vairāk uzlabotu mūsu kodu, būtu labi informēt, ka mēs iziesim no cilpas, tāpēc mēs definēsim 2 jaunas vispārīgas funkcijas, vienu displeja notīrīšanai un otru, lai noteiktu laiku mirgo LED.

# Skaidrs displejs:

def displayClear (): oled.fill (0) oled.show () # izveidot mirgošanas funkciju def blinkLed (num): i diapazonā (0, num): led.on () miega (0,5) led.off () gulēt (0,5)

Tagad mēs varam pārrakstīt savu galveno () funkciju:

kamēr button.value ():

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

Galīgo kodu var lejupielādēt no mana GitHub: localData.py un arī Jupyter piezīmju grāmatiņas, ko izmanto pilnīga koda izstrādei: Jupyter Local Data Development.

7. darbība: pievienojiet ESP vietējam WiFi

Tīkla modulis tiek izmantots, lai konfigurētu WiFi savienojumu. Ir divas WiFi saskarnes, viena stacijai (kad ESP8266 izveido savienojumu ar maršrutētāju) un otra - piekļuves punktam (citām ierīcēm, lai izveidotu savienojumu ar ESP8266). Šeit mūsu ESP tiks savienots ar vietējo tīklu. Zvanīsim uz bibliotēku un definēsim tīkla akreditācijas datus:

importa tīkls

WiFi_SSID = "JŪSU SSID" WiFi_PASS = "JŪSU PAROLE"

Tālāk norādīto funkciju var izmantot, lai savienotu ESP ar vietējo tīklu:

def do_connect ():

wlan = network. WLAN (network. STA_IF) wlan.active (True) ja nav wlan.isconnected (): print ('pieslēdzas tīklam …') wlan.connect (WiFi_SSID, WiFi_SSID), kamēr nav wlan.isconnected (): pass drukāt ('tīkla konfigurācija:', wlan.ifconfig ())

Palaižot funkciju, jūs varat iegūt IP adresi:

do_connect ()

Rezultāts būs šāds:

tīkla konfigurācija: ('10.0.1.2 ',' 255.255.255.0 ', '10.0.1.1', '10.0.1.1 ')

Vai manā gadījumā 10.0.1.2 ir ESP IP adrese.

8. darbība: ThingSpeak

Šajā brīdī mēs uzzinājām, kā iegūt datus no visiem sensoriem, parādot tos mūsu OLED. Tagad ir pienācis laiks redzēt, kā nosūtīt šos datus uz IoT platformu ThingSpeak.

Sāksim!

Pirmkārt, jums ir jābūt kontam vietnē ThinkSpeak.com. Pēc tam izpildiet norādījumus, lai izveidotu kanālu, un ņemiet vērā jūsu kanāla ID un rakstīšanas API atslēgu.

Iepriekš redzami 5 lauki, kas tiks izmantoti mūsu kanālā.

9. darbība: MQTT protokols un ThingSpeak savienojums

MQTT ir publicēšanas/abonēšanas arhitektūra, kas galvenokārt izstrādāta, lai bezvadu tīklos savienotu joslas platumu un ierobežotas jaudas ierīces. Tas ir vienkāršs un viegls protokols, kas darbojas pa TCP/IP ligzdām vai WebSockets. MQTT, izmantojot WebSockets, var nodrošināt, izmantojot SSL. Publicēšanas/abonēšanas arhitektūra ļauj ziņojumus nosūtīt uz klienta ierīcēm bez ierīces nepārtrauktas aptaujas serverī.

MQTT brokeris ir centrālais saziņas punkts, un tas ir atbildīgs par visu ziņojumu nosūtīšanu starp sūtītājiem un likumīgajiem saņēmējiem. Klients ir jebkura ierīce, kas izveido savienojumu ar brokeri un var publicēt vai abonēt tēmas, lai piekļūtu informācijai. Tēma satur starpnieka maršrutēšanas informāciju. Katrs klients, kurš vēlas sūtīt ziņojumus, publicē tos noteiktā tēmā, un katrs klients, kurš vēlas saņemt ziņas, abonē noteiktu tēmu. Brokeris piegādā visus ziņojumus ar atbilstošu tēmu attiecīgajiem klientiem.

ThingSpeak ™ ir MQTT starpnieks vietnēs URL mqtt.thingspeak.com un portā 1883. ThingSpeak brokeris atbalsta gan MQTT publicēšanu, gan MQTT abonēšanu.

Mūsu gadījumā mēs izmantosim: MQTT Publish

Attēlā ir aprakstīta tēmas struktūra. Lai publicētu, ir nepieciešama rakstīšanas API atslēga. Brokeris apstiprina pareizu CONNECT pieprasījumu, izmantojot CONNACK.

MQTT protokols tiek atbalstīts iebūvētajā bibliotēkā Micropython bināros failos-šo protokolu var izmantot, lai nosūtītu datus no jūsu ESP8266, izmantojot WIFI, uz bezmaksas mākoņa datu bāzi.

Izmantosim umqtt.simple bibliotēku:

no umqtt.simple importēt MQTTClient

Un, zinot mūsu SERVER ID, ir iespējams izveidot mūsu MQTT klienta objektu:

SERVERIS = "mqtt.thingspeak.com"

klients = MQTTClient ("umqtt_client", SERVER)

Tagad, paņemot rokās ThingSpeak akreditācijas datus:

CHANNEL_ID = "JŪSU KANĀLA ID"

WRITE_API_KEY = "JŪSU ATSLĒGA ŠEIT"

Izveidosim savu MQTT "Tēmu":

topic = "kanāli/" + CHANNEL_ID + "/publicēt/" + WRITE_API_KEY

Ļaujiet mūsu datiem nosūtīt ThingSpeak IoT pakalpojumu, izmantojot izveidoto funkciju, un saistīt tā atbildi ar konkrētiem datu mainīgajiem:

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

Atjauninot šos mainīgos, mēs varam izveidot savu "MQTT Payload":

lietderīgā slodze = "field1 ="+str (temp)+"& field2 ="+str (hum)+"& field3 ="+str (extTemp)+"& field4 ="+str (lum)+"& field5 ="+str (butSts)

Un tas arī viss! Mēs esam gatavi nosūtīt datus uz ThinsSpeak, vienkārši izmantojot 3 tālāk norādītās koda rindiņas.

client.connect ()

client.publish (tēma, lietderīgā slodze) client.disconnect ()

Tagad, dodoties uz savu kanāla lapu (kā mans iepriekš), jūs redzēsit, ka katrā no 5 laukiem būs dati, kas saistīti ar jūsu sensoriem.

10. solis: Sensora datu reģistrētājs

Tagad, kad mēs zinām, ka tikai ar dažām koda rindām ir iespējams augšupielādēt datus IoT pakalpojumā, izveidosim cilpas funkciju, lai to veiktu automātiski noteiktā laika intervālā (līdzīgi tam, ko esam darījuši ar vietējiem datiem) ).

Izmantojot to pašu mainīgo (PUB_TIME_SEC), kas deklarēts iepriekš, vienkārša galvenā funkcija datu nepārtrauktai uztveršanai, to reģistrēšana mūsu kanālā būtu šāda:

kamēr taisnība:

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)

Ņemiet vērā, ka ir jāatjaunina tikai lietderīgā slodze, tiklīdz tēma ir saistīta ar mūsu kanāla akreditācijas datiem un nemainās.

Meklējot ThingSpeak kanāla lapu, jūs ievērosiet, ka dati tiks nepārtraukti ielādēti katrā laukā. Jūs varat aizsegt LDR, uzlikt roku uz temperatūras/dūkoņa sensoriem, nospiest pogu utt. Un redzēt, kā kanāls automātiski "reģistrēs" šos datus turpmākai analīzei.

Parasti datu reģistrēšanai mums jācenšas izmantot pēc iespējas mazāk enerģijas, tāpēc mēs neizmantojam gaismas diodi vai displeju lokāli. Tāpat tas ir ierasts ar ESP ierīcēm, ievietojiet tās "dziļā miegā", kur mikroprocesors būs minimālā enerģijas stāvoklī, līdz būs pienācis laiks uztvert datus un nosūtīt tos uz IoT platformu.

Bet, kad šī ideja ir mācīšanās, iekļausim arī displeju un LED, kā mēs to darījām iepriekš. To darot, mūsu "reģistrētāja" funkcija būs:

kamēr 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) klients.connect () client.publicize (topic, payload) client.disconnect () time.sleep (PUB_TIME_SEC) mirgoLed (3) displayClear ()

Pilnu microPython skriptu var atrast šeit: dataLoggerTS_EXT.py un piezīmjdatoru Jupyter, kas tika izmantots izstrādei, var atrast arī šeit: IoT ThingSpeak Data Logger EXT.ipynb.

Lai augšupielādētu skriptu ESP, terminālī izmantojiet komandu:

ampy ielieciet dataLoggerTS.py /main.py

Un nospiediet ESP - atiestatīšanas pogu. Jums būs ESP, kas uztver datus un reģistrē tos vietnē ThingSpeak.com, līdz apakšdaļa tiek turēta nospiesta (pagaidiet, līdz gaismas diode mirgo 3 reizes un OLED izslēdzas).

11. darbība: lietotne ThingView

Reģistrētos datus var apskatīt tieši vietnē ThingSpeak.com vai izmantojot APP, piemēram, ThingsView!

ThingView ir CINETICA izstrādāta APP, kas ļauj viegli vizualizēt ThingSpeak kanālus, vienkārši ievadiet kanāla ID un esat gatavs darbam.

Publiskajos kanālos lietojumprogramma ņems vērā jūsu Windows iestatījumus: krāsu, laika grafiku, diagrammas veidu un rezultātu skaitu. Pašreizējā versija atbalsta līniju un kolonnu diagrammas, spline diagrammas tiek parādītas kā līniju diagrammas.

Privātajiem kanāliem dati tiks parādīti, izmantojot noklusējuma iestatījumus, jo nav iespējams nolasīt privāto logu iestatījumus tikai ar API atslēgu.

ThingView APP var lejupielādēt Android un IPHONE ierīcēm.

12. solis. Secinājums

Kā vienmēr, es ceru, ka šis projekts var palīdzēt citiem atrast ceļu aizraujošajā elektronikas pasaulē!

Lai iegūtu sīkāku informāciju un gala kodu, lūdzu, apmeklējiet manu GitHub depozitāriju: IoT_TS_MQTT

Lai iegūtu vairāk projektu, lūdzu, apmeklējiet manu emuāru: MJRoBot.org

Sveicieni no pasaules dienvidiem!

Uz tikšanos manā nākamajā pamācībā!

Paldies, Marselo