Internetas palengvino: ESP-MicroPython-MQTT-ThingSpeak: 12 žingsnių

2024 Autorius: John Day | [email protected]. Paskutinį kartą keistas: 2024-01-30 10:47

Ankstesnėje pamokoje, „MicroPython on ESP“naudojant „Jupyter“, sužinojome, kaip įdiegti ir paleisti „MicroPython“ESP įrenginyje. Naudodami „Jupyter“nešiojamąjį kompiuterį kaip savo kūrimo aplinką, mes taip pat išmokome skaityti iš jutiklių (temperatūra, drėgmė ir šviesumas). Mes naudojame kelis ryšio protokolus ir metodus, analoginius, skaitmeninius, 1 laidų ir I2C. duomenis OLED ekrane.

Dabar šioje pamokoje, naudojant MQTT protokolą, gausime visus užfiksuotus duomenis, siunčiant juos į „IoT“paslaugą „ThingSpeak.com“ir į programą mobiliesiems („Thingsview“), kur galime prisijungti ir žaisti su duomenimis.

Čia yra mūsų projekto blokinė schema:

1 žingsnis: „BoM - Bill of Material“

1. „NodeMCU“- 8,39 USD
2. DHT22 temperatūros ir santykinio drėgmės jutiklis - 9,95 USD
3. Atsparus vandeniui temperatūros jutiklis DS18B20 - 5,95 USD
4. OLED ekranas SSD1366- 8,99 USD (pasirenkama)
5. LDR (1x)
6. Šviesos diodai (1x) (pasirenkama)
7. Mygtukas (1x)
8. Rezistorius 4K7 omų (2x)
9. Rezistorius 10K omų (1x)
10. Rezistorius 220 omų (1x)

2 žingsnis: Hw

„Hw“, kurį mes čia naudosime, iš esmės yra tas pats, kas naudojamas pamokoje: „Micropython on ESP Using Jupyter“. Informaciją apie visus HW prijungimus rasite čia.

Išimtis yra „Servo“, kad mes nebūsime naudojami šiame projekte.

Viršuje galite pamatyti visą HW. Prijunkite įrenginius, kaip parodyta ten.

3 žingsnis: „Micropython“, „REPL“, „Jupyter“

ESP įrenginyje turite turėti „Micropython“vertėją. Įkėlę turėtumėte užprogramuoti savo ESP naudodami bet kurį iš galimų būdų/IDE, pavyzdžiui:

• REPL
• Užrašų knygelė „Jupyter“
• Mu
• „ESPCut“(tik „Windows“)
• … Ir tt

Savo pamokoje „Micropython on ESP“Naudodamas „Jupyter“išsamiai aprašiau, kaip atsisiųsti ir įdiegti „MicroPython“vertėją, „ESPTool“ESP įrenginiams valdyti ir kaip naudoti „Jupyter Notebook“kaip kūrimo aplinką. Nesivaržykite naudoti tai, kas jums patogiau.

Paprastai viską kuriu „Jupyter Notebook“ir, gavęs galutinį kodą, nukopijuoju juos į „Geany“ir įkeliu į savo ESP naudodami „Ampy“.

4 žingsnis: jutikliai

Įdiekime bibliotekas, apibrėžkime GPIO, kurkime objektus, funkcijas visiems jutikliams atskirai:

A. DHT (temperatūra ir drėgmė)

Įdiekime DHT biblioteką ir sukursime objektą:

iš dht importo DHT22

iš mašinos importavimo Smeigtukas dht22 = DHT22 (kaištis (12))

Dabar sukurkite DHT jutiklio nuskaitymo funkciją:

def readDht ():

dht22.measure () grįžti dht22.temperatūra (), dht22.humidity () Išbandykite DHT funkciją

spausdinti (skaitytiDht ())

Rezultatas turėtų būti, pavyzdžiui:

(17.7, 43.4)

B. DS18B20 (išorinė temperatūra)

Įdiekime bibliotekas ir sukursime objektą:

importuoti onewire, ds18x20

importavimo laikas # Nustatykite, kuris kištukas bus prijungtas prie vieno laido ==> kaištis 2 (D4) dat = kaištis (2) # sukurkite „onewire“objektą ds = ds18x20. DS18X20 (onewire. OneWire (dat)) Ieškokite įrenginių bu

jutikliai = ds.scan ()

spausdinti („rasti įrenginiai:“, jutikliai)

Išspausdintas rezultatas nėra labai svarbus, mums reikės pirmo aptikto jutiklio: jutiklių [0]. Ir dabar mes galime sukurti jutiklių duomenų nuskaitymo funkciją:

def readDs ():

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

Visada svarbu išbandyti jutiklį naudojant sukurtą funkciją

spausdinti (skaityti (skaityti) () Jei gaunate temperatūros vertę, jūsų kodas yra teisingas

17.5

C. LDR (šviesumas)

LDR naudos analoginį mūsų ESP kaištį (tai tik vienas ESP8266 atveju ir keli ESP32).

Išsamesnės informacijos ieškokite mano ESP32 vadovėlyje.

Tas pats kaip ir anksčiau:

# importuoti biblioteką

iš mašinos importo ADC # Apibrėžkite objektą adc = ADC (0) Paprasta funkcija: adc.read () gali būti naudojama ADC vertei nuskaityti. Tačiau atminkite, kad vidinis ADC konvertuos įtampą tarp 0 ir 3,3 V atitinkamomis skaitmeninėmis reikšmėmis, kurios svyruoja nuo 0 iki 1023. Kai mus domina „Šviesumas“, „Max light“laikysime maksimalia jutiklio užfiksuota verte (mano 900 atvejis) ir minimali šviesa, kuri mano atveju yra 40. Turėdami šias vertes, mes galime „susieti“vertę nuo 40 iki 900, esant 0–100% šviesumo. Tam mes sukursime naują funkciją

def readLdr ():

lumPerct = (adc.read ()-40)*(10/86) # konvertuoti procentais ("žemėlapis") grąžinimo turas (lumPerct)

Turėtumėte išbandyti funkciją naudodami spausdinimą (readLDR ()). Rezultatas turėtų būti sveikasis skaičius nuo o iki 100.

D. Mygtukas (skaitmeninis įėjimas)

Čia mes naudojame mygtuką kaip skaitmeninį jutiklį, tačiau tai gali būti pavaros „aidas“(pavyzdžiui, siurblys, kuris buvo įjungtas/išjungtas).

# apibrėžkite kaištį 13 kaip įvestį ir įjunkite vidinį ištraukimo rezistorių:

mygtukas = smeigtukas (13, PIN. IN, PIN. PULL_UP) # Mygtuko būsenos skaitymo funkcija: def readBut (): grįžimo mygtukas.value ()

Galite patikrinti mygtuką, nuskaitantį spausdinimo funkciją (skaitytiBut ()). Paspaudus/be rezultato rezultatas turėtų būti „1“. Paspaudus mygtuką, rezultatas turėtų būti „0“

5 veiksmas: visų jutiklių duomenų fiksavimas ir rodymas vietoje

Dabar, kai sukūrėme po vieną funkciją kiekvienam jutikliui, sukurkime paskutinę, kuri skaitys juos visus vienu metu:

def colectData ():

temp, hum, = readDht () extTemp = readDs () lum = readLdr () butSts = readBut () grąžinimo temperatūra, hum, extTemp, lum, butSts Dabar, jei naudojate

spausdinti (colectData ())

Bus gautas rinkinys, apimantis visus jutiklių užfiksuotus duomenis:

(17.4, 45.2, 17.3125, 103, 1)

Taip pat pasirinktinai galime rodyti šiuos duomenis vietiniame ekrane:

# importuokite biblioteką ir sukurkite objektą „i2c“

iš mašinos importavimo I2C i2c = I2C (scl = kaištis (5), sda = kaištis (4)) # importo biblioteka ir sukurkite objektą jūs importuojate ssd1306 i2c = I2C (scl = kaištis (5), sda = kaištis (4)) esate = ssd1306. SSD1306_I2C (128, 64, i2c, 0x3c) # sukurti funkciją: 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 () # rodyti duomenis naudojant funkciją displayData (temp, hum, extTemp, lum, butSts)

Kaip pasirinkimą taip pat įtraukiu šviesos diodą, kuris turi būti įjungtas, kai pradedame skaityti jutiklius, o po to, kai rodomi šie duomenys, išsijungia. Tai padės patvirtinti, kad programa veikia, kai ESP yra atjungtas nuo kompiuterio ir veikia automatiškai.

Taigi, pagrindinė funkcija būtų:

# Pagrindinė funkcija skaityti visus jutiklius

def main (): # rodyti duomenis su funkcija led.on () temp, hum, extTemp, lum, butSts = colectData () displayData (temp, hum, extTemp, lum, butSts) led.off ()

Taigi, vykdydami pagrindinį (), mes gausime jutiklio duomenis, rodomus OLED, kaip parodyta paveikslėlyje.

6 veiksmas: paleiskite vietinės stoties kodą paleidžiant ESP

Visa tai, kas iki šiol buvo sukurta, galime turėti viename faile, kurį turės vykdyti mūsų ESP.

Atidarykime bet kurį teksto rengyklę ir įveskite visą kodą:

# importuoti bendras bibliotekas

iš mašinos importavimo Kaiščio importavimo laikas # apibrėžkite kaištį 0 kaip išvesties LED = kaištis (0, kaištis. OUT) # DHT iš dht importo DHT22 dht22 = DHT22 (kaištis (12)) # Funkcija skaityti DHT def read () return dht22.temperature (), dht22.humidity () # DS18B20 importuoti onewire, ds18x20 # Nustatykite, kuris kištukas bus prijungtas prie 1 laido ==> 2 kontaktas (D4) dat = Pin (2) # Sukurkite vieną laidą objektas ds = ds18x20. DS18X20 (onewire. OneWire (dat)) # nuskaityti įrenginius magistralės jutikliuose = ds.scan () # funkcija skaityti DS18B20 def readDs (): ds.convert_temp () time.sleep_ms (750) return apvalus (ds.read_temp (jutikliai [0]), 1) # LDR iš mašinos importo ADC # Apibrėžkite objektą adc = ADC (0) # funkcija, kad nuskaitytumėte šviesumą def readLdr (): lumPerct = (adc.read ()-40) *(10/86) # konvertuoti procentais („žemėlapis“) grąžinimo ratas (lumPerct) # apibrėžti kaištį 13 kaip įvestį ir suaktyvinti vidinį ištraukimo rezistorių: mygtukas = kaištis (13, kaištis IN, kaištis. PULL_UP) # Funkcija skaitymo mygtuko būsenai: def readBut (): grįžimo mygtukas.value () # Funkcija skaityti visus duomenis: def cole ctData (): temp, hum, = readDht () extTemp = readDs () lum = readLdr () butSts = readBut () grąžinti temp, hum, extTemp, lum, butSts # importo biblioteką ir sukurti objektą i2c iš mašinos importo I2C i2c = I2C (scl = smeigtukas (5), sda = kaištis (4)) # importo biblioteka ir sukuriamas objektas oled importas ssd1306 i2c = I2C (scl = kaištis (5), sda = kaištis (4)) oled = ssd1306. SSD1306_I2C (128, 64, i2c, 0x3c) # sukurti funkciją: 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 () # Pagrindinė funkcija skaityti visus jutiklius def main (): # rodyti duomenis su funkcija led.on () temp, hum, extTemp, lum, butSts = colectData () displayData (temp, hum, extTemp, lum, butSts) led.off () ""-- ----- paleisti pagrindinę funkciją -------- '' 'main ()

Išsaugokite jį, pavyzdžiui, kaip localData.py.

Norėdami paleisti šį kodą tiesiogiai savo terminale, jums reikės „Ampy“.

Pirma, terminale pranešime „Ampy“mūsų nuosekliajam prievadui:

eksportuoti AMPY_PORT =/dev/tty. SLAB_USBtoUART

Dabar galime pamatyti failus, esančius mūsų ESP šakniniame kataloge:

ampy ls

Kaip atsakymą gausime boot.py, tai yra pirmasis failas, kuris bus paleistas sistemoje.

Dabar naudokime „Ampy“, norėdami įkelti „python“scenarijų „LocalData.py“kaip /main.py, todėl scenarijus bus paleistas iškart po įkrovos:

ampy įdėti localData.py /main /py

Jei dabar naudosime komandą amp ls, ESP viduje pamatysite 2 failus: boot.py ir main.py

Iš naujo nustatžius ESP, programa localData.py bus paleista automatiškai, ekrane rodant jutiklio duomenis.

Aukščiau pateiktas terminalo spausdinimo ekranas rodo, ką mes padarėme.

Naudojant aukščiau esantį kodą, ekranas bus rodomas tik vieną kartą, tačiau galime apibrėžti pagrindinės () funkcijos ciklą, kuriame bus rodomi duomenys apie kiekvieną apibrėžtą laiko intervalą (PUB_TIME_SEC) ir, pavyzdžiui, kol nepaspausime mygtuko:

# kilpa gauti duomenis, kol nepaspaudžiamas mygtukas

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

Kintamasis PUB_TIME_SEC turi būti deklaruotas iki to laiko, kai norite gauti pavyzdžių.

Norint labiau patobulinti mūsų kodą, būtų gerai informuoti, kad išeisime iš ciklo, todėl nustatysime 2 naujas bendrąsias funkcijas: vieną, skirtą ekrano išvalymui, o kitą, kad tam tikrą skaičių kartų mirksėtų šviesos diodas.

# Aiškus ekranas:

def displayClear (): oled.fill (0) oled.show () # sukurkite mirksėjimo funkciją def blink LED) miegas (0,5)

Taigi, dabar galime perrašyti savo pagrindinę () funkciją:

o mygtukas.value ():

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

Galutinį kodą galima atsisiųsti iš „GitHub“: localData.py, taip pat „Jupyter“užrašų knygelės, naudojamos visam kodui sukurti: „Jupyter Local Data Development“.

7 veiksmas: prijunkite ESP prie vietinio „WiFi“

Tinklo modulis naudojamas konfigūruoti „WiFi“ryšį. Yra dvi „WiFi“sąsajos, viena stotiui (kai ESP8266 jungiasi prie maršrutizatoriaus) ir viena prieigos taškui (kitiems įrenginiams prisijungti prie ESP8266). Čia mūsų ESP bus prijungtas prie vietinio tinklo. Paskambinkime bibliotekai ir apibrėžkime tinklo kredencialus:

importo tinklas

WiFi_SSID = "JŪSŲ SSID" WiFi_PASS = "JŪSŲ Slaptažodis"

Šią funkciją galima naudoti norint prijungti ESP prie vietinio tinklo:

def do_connect ():

wlan = tinklas. WLAN (tinklas. STA_IF) wlan.active (tiesa) jei ne wlan.isconnected (): print ('prisijungimas prie tinklo …') wlan.connect (WiFi_SSID, WiFi_SSID), o ne wlan.isconnected (): pass spausdinti („tinklo konfigūracija:“, wlan.ifconfig ())

Vykdydami funkciją, galite gauti IP adresą:

do_connect ()

Rezultatas bus toks:

tinklo konfigūracija: ('10.0.1.2 ',' 255.255.255.0 ', '10.0.1.1', '10.0.1.1 ')

Mano atveju, 10.0.1.2 yra ESP IP adresas.

8 žingsnis: „ThingSpeak“

Šiuo metu mes išmokome užfiksuoti duomenis iš visų jutiklių ir rodyti juos savo OLED. Dabar atėjo laikas pamatyti, kaip nusiųsti šiuos duomenis į interneto platformą „ThingSpeak“.

Pradėkime!

Pirma, jūs turite turėti paskyrą „ThinkSpeak.com“. Tada vykdykite instrukcijas, kad sukurtumėte kanalą, ir atkreipkite dėmesį į kanalo ID ir „Write API Key“.

Viršuje galite pamatyti 5 laukus, kurie bus naudojami mūsų kanale.

9 veiksmas: MQTT protokolas ir „ThingSpeak“ryšys

„MQTT“yra paskelbimo/prenumeratos architektūra, sukurta pirmiausia siekiant sujungti pralaidumą ir ribotos galios įrenginius belaidžiais tinklais. Tai paprastas ir lengvas protokolas, veikiantis per TCP/IP lizdus arba „WebSockets“. MQTT per „WebSockets“gali būti apsaugotas naudojant SSL. Paskelbimo/prenumeratos architektūra leidžia pranešimus perkelti į kliento įrenginius, įrenginiui nereikia nuolat apklausti serverio.

MQTT brokeris yra pagrindinis komunikacijos taškas ir yra atsakingas už visų pranešimų siuntimą tarp siuntėjų ir teisėtų gavėjų. Klientas yra bet koks įrenginys, jungiantis prie tarpininko ir galintis paskelbti ar užsiprenumeruoti temas, kad galėtų pasiekti informaciją. Temoje yra brokerio maršruto informacija. Kiekvienas klientas, norintis siųsti pranešimus, skelbia juos tam tikra tema, o kiekvienas klientas, norintis gauti pranešimus, užsisako tam tikrą temą. Tarpininkas pristato visus pranešimus atitinkančia tema atitinkamiems klientams.

„ThingSpeak ™“turi MQTT tarpininką URL adresu mqtt.thingspeak.com ir prievadas 1883. „ThingSpeak“tarpininkas palaiko ir MQTT paskelbimą, ir MQTT prenumeratą.

Mūsų atveju naudosime: „MQTT Publish“

Paveikslėlyje aprašoma temos struktūra. Norint paskelbti, reikalingas „Write API Key“. Brokeris patvirtina teisingą CONNECT užklausą su CONNACK.

MQTT protokolas palaikomas integruotoje „Micropython“dvejetainių failų bibliotekoje-šis protokolas gali būti naudojamas siųsti duomenis iš jūsų ESP8266 per WIFI į nemokamą debesų duomenų bazę.

Naudokime umqtt.simple biblioteką:

iš umqtt.simple importuoti MQTTClient

Ir žinant mūsų SERVER ID, galima sukurti mūsų MQTT kliento objektą:

TARNYVAS = "mqtt.thingspeak.com"

klientas = MQTTClient ("umqtt_client", SERVER)

Dabar turėdami „ThingSpeak“kredencialus:

CHANNEL_ID = "JŪSŲ KANALO ID"

WRITE_API_KEY = "JŪSŲ RAKTAS ČIA"

Sukurkime savo MQTT „Temą“:

tema = "kanalai/" + CHANNEL_ID + "/paskelbti/" + WRITE_API_KEY

Leiskite, kad mūsų duomenys būtų siunčiami į „ThingSpeak IoT Service“, naudojant sukurtą funkciją, ir susiesime jos atsaką su konkrečiais duomenų kintamaisiais:

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

Atnaujinę šiuos kintamuosius, galime sukurti „MQTT naudingąją apkrovą“:

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

Štai ir viskas! Esame pasirengę siųsti duomenis į „ThinsSpeak“paprasčiausiai naudodami toliau pateiktas 3 kodo eilutes:

client.connect ()

client.publish (tema, naudingoji apkrova) client.disconnect ()

Dabar, eidami į savo kanalo puslapį (kaip mano aukščiau), pamatysite, kad kiekviename iš 5 laukų bus duomenys, susiję su jūsų jutikliais.

10 veiksmas: jutiklių duomenų kaupiklis

Dabar, kai žinome, kad naudojant tik kelias kodo eilutes galima įkelti duomenis į „IoT“paslaugą, sukurkime ciklo funkciją, kuri tai atliktų automatiškai reguliariai (panašiai, kaip tai darėme su „Vietiniai duomenys“) ).

Naudojant tą patį kintamąjį (PUB_TIME_SEC), paskelbtą anksčiau, paprasta pagrindinė funkcija nepertraukiamai fiksuoti duomenis, registruoti juos mūsų kanale būtų:

nors tiesa:

temp, hum, extTemp, lum, butSts = colectData () naudingoji apkrova = "field1 ="+str (temp)+"& field2 ="+str (hum)+"& field3 ="+str (extTemp)+"& field4 ="+ str (lum)+"& field5 ="+str (butSts) client.connect () client.publish (tema, naudingoji apkrova) client.disconnect () time.sleep (PUB_TIME_SEC)

Atminkite, kad tik „naudingoji apkrova“turi būti atnaujinta, kai „tema“bus susijusi su mūsų kanalo kredencialais ir nesikeis.

Ieškodami „ThingSpeak“kanalo puslapio pastebėsite, kad duomenys bus nuolat įkeliami į kiekvieną lauką. Galite uždengti LDR, uždėti ranką ant temperatūros/humo jutiklių, paspausti mygtuką ir pan. Ir pamatyti, kaip kanalas automatiškai „užregistruos“tuos duomenis būsimai analizei.

Paprastai duomenų registravimui turėtume stengtis naudoti kuo mažiau energijos, todėl nenaudosime šviesos diodo ar ekrano vietoje. Be to, tai įprasta naudojant ESP įrenginius, padėkite juos „giliai miegoti“, kai mikroprocesorius veiks minimalios energijos būsenoje, kol ateis laikas surinkti duomenis ir išsiųsti juos į daiktų interneto platformą.

Bet kai tik idėja mokosi, įtraukime ekraną ir šviesos diodą, kaip tai darėme anksčiau. Tai atlikus, mūsų „registravimo“funkcija bus:

o mygtukas.value ():

led.on () temp, hum, extTemp, lum, butSts = colectData () displayData (temp, hum, extTemp, lum, butSts) led.off () temp, hum, extTemp, lum, butSts = colectData () naudingoji apkrova = "field1 ="+str (temp)+"& field2 ="+str (hum)+"& field3 ="+str (extTemp)+"& field4 ="+str (lum)+"& field5 ="+str (butSts) klientas.connect () client.publish (tema, naudingoji apkrova) client.disconnect () time.sleep (PUB_TIME_SEC) mirksiLed (3) displayClear ()

Visą „microPython“scenarijų rasite čia: dataLoggerTS_EXT.py ir „Jupyter“užrašų knygelę, kuri buvo naudojama kūrimui, taip pat rasite čia: „IoT ThingSpeak Data Logger EXT.ipynb“.

Norėdami įkelti scenarijų į ESP, savo terminale naudokite komandą:

ampy įdėti dataLoggerTS.py /main.py

Ir paspauskite ESP - atstatymo mygtuką. Turėsite ESP fiksuoti duomenis ir juos registruoti „ThingSpeak.com“, kol apačia bus laikoma nuspausta (palaukite, kol šviesos diodas sumirksės 3 kartus ir OLED išsijungs).

11 veiksmas: „ThingView“programa

Įregistruotus duomenis galima peržiūrėti tiesiogiai „ThingSpeak.com“svetainėje arba per APP, pvz., „ThingsView“!

„ThingView“yra „CINETICA“sukurta APP, leidžianti lengvai vizualizuoti „ThingSpeak“kanalus, tiesiog įveskite kanalo ID ir būsite pasiruošę eiti.

Viešųjų kanalų atveju programa atsižvelgs į jūsų „Windows“nustatymus: spalvą, laiko skalę, diagramos tipą ir rezultatų skaičių. Dabartinė versija palaiko linijų ir stulpelių diagramas, spline diagramos rodomos kaip linijų diagramos.

Privačių kanalų duomenys bus rodomi naudojant numatytuosius nustatymus, nes nėra galimybės nuskaityti privačių langų nustatymų tik naudojant API raktą.

„ThingView“APP galima atsisiųsti iš „Android“ir „IPHONE“.

12 žingsnis: Išvada

Kaip visada, tikiuosi, kad šis projektas gali padėti kitiems rasti kelią į jaudinantį elektronikos pasaulį!

Norėdami gauti daugiau informacijos ir galutinį kodą, apsilankykite mano „GitHub“saugykloje: IoT_TS_MQTT

Norėdami gauti daugiau projektų, apsilankykite mano tinklaraštyje: MJRoBot.org

Saludos iš pasaulio pietų!

Iki pasimatymo mano kitoje pamokoje!

Ačiū, Marcelo