IoT Eade Ease: ESP-MicroPython-MQTT-Thing Flisni: 12 hapa

2024 Autor: John Day | [email protected]. E modifikuara e fundit: 2024-01-30 12:19

Në mësimin tim të mëparshëm, MicroPython në ESP duke përdorur Jupyter, mësuam se si të instaloni dhe ekzekutoni MicroPython në një pajisje ESP. Duke përdorur Jupyter Notebook si mjedisin tonë të zhvillimit, ne gjithashtu mësuam se si të lexojmë nga sensorët (Temperatura, Lagështia dhe Shkëlqimi), Ne përdorim disa protokolle dhe metoda komunikimi, Analog, Digital, 1-Wire dhe I2C, ky i fundit për të shfaqur kapjen tonë të dhëna në një ekran OLED.

Tani, në këtë tutorial duke përdorur një protokoll MQTT, ne do të marrim të gjitha të dhënat e kapura, duke i dërguar ato në një shërbim IoT, ThingSpeak.com dhe në një aplikacion celular (Thingsview), ku mund të regjistrohemi dhe të luajmë me të dhëna.

Këtu, diagrami i bllokut të projektit tonë:

Hapi 1: BM - Fatura e Materialit

1. NodeMCU - 8.39 dollarë amerikanë
2. Sensori i temperaturës dhe lagështisë relative DHT22 - 9.95 dollarë
3. Sensor i temperaturës i papërshkueshëm nga uji DS18B20 - 5.95 dollarë
4. OLED Display SSD1366- 8.99 USD (opsionale)
5. LDR (1x)
6. LED (1x) (Opsionale)
7. Butoni i shtytjes (1x)
8. Rezistenca 4K7 ohm (2x)
9. Rezistencë 10K Ohm (1x)
10. Rezistencë 220 ohm (1x)

Hapi 2: The Hw

Hw që ne do të përdorim këtu në thelb është e njëjta e përdorur në tutorial: Micropython në ESP Duke përdorur Jupyter. Referojuni asaj për të gjitha lidhjet HW.

Përjashtim është Servo, që ne nuk do të përdorim në këtë projekt.

Më sipër mund të shihni HW të plotë. Lidhni pajisjet siç tregohet atje.

Hapi 3: Mikropitoni, REPL, Jupyter

Duhet të keni një përkthyes Micropython të ngarkuar në pajisjen tuaj ESP. Pasi të jetë ngarkuar, duhet të programoni ESP -në tuaj duke përdorur ndonjë nga mënyrat/IDE -të në dispozicion, si:

• RIPARIM
• Fletore Jupyter
• Mu
• ESPCut (vetëm për Windows)
• … Etj

Në tutorialin tim, Micropython në ESP Duke përdorur Jupyter, unë detajova se si të shkarkoni dhe instaloni përkthyesin MicroPython, ESPTool për të menaxhuar pajisjet ESP dhe si të përdorni Jupyter Notebook si një mjedis zhvillimi. Mos ngurroni të përdorni atë që është më e rehatshme për ju.

Unë zakonisht i bëj të gjitha zhvillimet në Jupyter Notebook, dhe sapo të marr kodin përfundimtar, i kopjoj në Geany dhe e ngarkoj në ESP duke përdorur Ampy.

Hapi 4: Sensorët

Le të instalojmë bibliotekat, të përcaktojmë GPIO, të krijojmë objekte, funksione për të gjithë sensorët individualisht:

A. DHT (Temperatura dhe Lagështia)

Le të instalojmë bibliotekën DHT dhe të krijojmë një objekt:

nga importi DHT DHT22

nga importi i makinës Pin dht22 = DHT22 (Pin (12))

Tani, krijoni një funksion për të lexuar sensorin DHT:

def readDht ():

dht22.masë () kthim dht22.temperaturë (), dht22. lagështi () Testoni funksionin DHT

print (lexoDht ())

Rezultati duhet të jetë për shembull:

(17.7, 43.4)

B. DS18B20 (Temperatura e jashtme)

Le të instalojmë bibliotekat dhe të krijojmë një objekt:

importoni një tel, ds18x20

koha e importit # Përcaktoni se në cilën pin do të lidhet pajisja me 1 tela ==> pin 2 (D4) dat = Pin (2) # krijoni objektin onewire ds = ds18x20. DS18X20 (onewire. OneWire (dat)) Skanoni për pajisjet në bu

sensorë = ds.scan ()

print ('pajisjet e gjetura:', sensorë)

Rezultati i shtypur nuk është vërtet i rëndësishëm, ajo që do të na duhet është sensori i parë i zbuluar: sensorët [0]. Dhe tani, ne mund të ndërtojmë një funksion për të lexuar të dhënat e sensorit:

def readDs ():

ds.convert_temp () time.sleep_ms (750) kthehu ds.read_temp (sensorë [0])

Alwaysshtë gjithmonë e rëndësishme të testoni sensorin duke përdorur funksionin e krijuar

print (lexoDs ()) Nëse merrni një vlerë të temperaturës, kodi juaj është i saktë

17.5

C. LDR (Shkëlqimi)

LDR do të përdorë pinin analog të ESP -së tonë (është vetëm një në rastin e ESP8266 dhe disa në ESP32).

Referojuni udhëzimit tim ESP32 për detaje.

Njësoj si më parë:

# importo bibliotekën

nga importi i makinës ADC # Përcakto objektin adc = ADC (0) Një funksion i thjeshtë: adc.read () mund të përdoret për të lexuar vlerën ADC. Por mbani mend se ADC e brendshme do të konvertojë tensione midis 0 dhe 3.3V në vlerat digjitale korresponduese, që ndryshojnë nga 0 në 1023. Pasi të jemi të interesuar për "Ndriçueshmëri", ne do ta konsiderojmë dritën Max si vlerën maksimale të kapur nga sensori (në tim rasti 900) dhe drita minimale që në rastin tim është 40. Duke pasur ato vlera ne mund të "hartojmë" vlerën nga 40 në 900 në 0 deri në 100% të shkëlqimit. Për këtë, ne do të krijojmë një funksion të ri

def readLdr ():

lumPerct = (adc.read ()-40)*(10/86) # konverto në përqindje ("hartë") raundin e kthimit (lumPerct)

Ju duhet të testoni funksionin duke përdorur print (lexoLDR ()). Rezultati duhet të jetë një numër i plotë midis o dhe 100.

D. Push-Button (Input dixhital)

Këtu ne po përdorim një Push-Button si një sensor dixhital, por mund të jetë një "jehonë" e një aktivizuesi (Një pompë që ishte ndezur/fikur, për shembull).

# përcaktoni pinin 13 si një hyrje dhe aktivizoni një rezistencë të brendshme tërheqëse:

butoni = Pin (13, Pin. IN, Pin. PULL_UP) # Funksioni për të lexuar gjendjen e butonit: def readBut (): butoni i kthimit.vlera ()

Mund ta provoni butonin duke lexuar funksionin print (readBut ()). Pa shtypur rezultatin duhet të jetë "1". Duke shtypur butonin, rezultati duhet të jetë "0"

Hapi 5: Kapja dhe shfaqja në nivel lokal e të dhënave të sensorit

Tani që kemi krijuar një funksion për secilin sensor, le të krijojmë atë të fundit që do t'i lexojë të gjithë në të njëjtën kohë:

def colectData ():

temp, hum, = readDht () extTemp = readDs () lum = readLdr () butSts = readBut () ktheu temp, hum, extTemp, lum, butSts Tani nëse përdorni

print (colectData ())

Do të rezultojë në një tufë që përfshin të gjitha të dhënat e kapura nga sensorët:

(17.4, 45.2, 17.3125, 103, 1)

Ne gjithashtu mund të zgjedhim, t'i tregojmë ato të dhëna në një ekran lokal:

# importoni bibliotekën dhe krijoni objektin i2c

nga importi i makinës I2C i2c = I2C (scl = Pin (5), sda = Pin (4)) # importoni bibliotekën dhe krijoni import të objektit të importuar ssd1306 i2c = I2C (scl = Pin (5), sda = Pin (4)) oled = ssd1306. SSD1306_I2C (128, 64, i2c, 0x3c) # krijoni një funksion: 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 ("Butoni:" + str (butSts), 0, 57) oled.show () # shfaq të dhënat duke përdorur funksionin displayData (temp, hum, extTemp, lum, butSts)

Si opsion, unë gjithashtu do të përfshijë LED që të jetë ON kur fillojmë të lexojmë sensorë, duke u fikur pasi të shfaqen të dhënat. Bërja e kësaj do të ndihmojë për të konfirmuar që programi po punon kur kemi ESP të shkyçur nga kompjuteri dhe të funksionojë automatikisht.

Pra, funksioni kryesor do të ishte:

# Funksioni kryesor për të lexuar të gjithë sensorët

def main (): # shfaq të dhëna me një funksion led.on () temp, hum, extTemp, lum, butSts = colectData () displayData (temp, hum, extTemp, lum, butSts) led.off ()

Pra, duke ekzekutuar main (), ne do të marrim të dhënat e sensorit të shfaqur në OLED siç tregohet në figurë.

Hapi 6: Drejtimi i Kodit të Stacionit Lokal në fillimin e ESP

Ne mund të kemi gjithçka që është zhvilluar deri më tani në një skedar të vetëm për t'u ekzekutuar nga ESP -ja jonë.

Le të hapim çdo redaktues teksti dhe të kalojmë në të të gjithë kodin:

# importoni biblioteka të përgjithshme

nga importi i makinës Pin koha e importit # përcaktoni pin 0 si dalje led = Pin (0, Pin. OUT) # DHT nga dht import DHT22 dht22 = DHT22 (Pin (12)) # Funksioni për të lexuar DHT def readDht (): dht22.measure () kthehu dht22.temperatura (), dht22.humidity () # DS18B20 importo onewire, ds18x20 # Përcaktoni se në cilën pin do të lidhet pajisja me 1 tela ==> pin 2 (D4) dat = Pin (2) # Krijoni tela objekt ds = ds18x20. DS18X20 (onewire. OneWire (dat)) # skanoni për pajisjet në sensorët e autobusit = ds.scan () # funksion për të lexuar DS18B20 def readDs (): ds.convert_temp () time.sleep_ms (750) kthim i rrumbullakët (ds.read_temp (sensorë [0]), 1) # LDR nga importi i makinës ADC # Përcaktoni objektin adc = ADC (0) #funksioni për të lexuar shkëlqimin def readLdr (): lumPerct = (adc.read ()-40) *(10/86) # konverto në përqindje ("harta") kthehu rrotull (lumPerct) # përcakto pinin 13 si hyrje dhe aktivizo një rezistencë të brendshme tërheqëse: butoni = Pin (13, Pin. IN, Pin. PULL_UP) # Funksioni për të lexuar gjendjen e butonit: def readBut (): button return.value () # Funksioni për të lexuar të gjitha të dhënat: def cole ctData (): temp, hum, = readDht () extTemp = readDs () lum = readLdr () butSts = readBut () kthejeni temp, hum, extTemp, lum, butSts # importoni bibliotekën dhe krijoni objekt i2c nga importi i makinës I2C i2c = I2C (scl = Pin (5), sda = Pin (4)) # importoni bibliotekën dhe krijoni importimin e objektit me ssd1306 i2c = I2C (scl = Pin (5), sda = Pin (4)) oled = ssd1306. SSD1306_I2C (128, 64, i2c, 0x3c) # krijoni një funksion: 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. tekst ("Lumin:" + str (lum) + "%", 0, 43) oled.text ("Button:" + str (butSts), 0, 57) oled.show () # Funksioni kryesor për të lexuar të gjithë sensorët def main (): # shfaq të dhëna me një funksion led.on () temp, hum, extTemp, lum, butSts = colectData () displayData (temp, hum, extTemp, lum, butSts) led.off () ""- ----- drejto funksionin kryesor -------- "" main ()

Ruajeni atë, për shembull si localData.py.

Për të ekzekutuar këtë kod direkt në terminalin tuaj do t'ju duhet Ampy.

Së pari, në Terminal le të informojmë Ampy portin tonë Serial:

eksportoni AMPY_PORT =/dev/tty. SLAB_USBtoUART

Tani, ne mund të shohim skedarët që janë brenda drejtorisë sonë rrënjësore ESP:

amp ls

Si përgjigje, ne do të marrim boot.py, kjo është skedari i parë që do të funksionojë në sistem.

Tani, le të përdorim Ampy për të ngarkuar Python Script LocalData.py si /main.py, kështu që skenari do të funksionojë menjëherë pas nisjes:

ampy vendos localData.py /main /py

Nëse përdorim komandën amp ls tani, do të shihni 2 skedarë brenda ESP.: boot.py dhe main.py

Rivendosja e ESP -së tuaj, do ta bëjë programin localData.py të funksionojë automatikisht, duke shfaqur të dhënat e sensorit në ekran.

Ekrani i printimit të mësipërm i Terminalit tregon atë që kemi bërë.

Me kodin e mësipërm, ekrani do të shfaqet vetëm një herë, por ne mund të përcaktojmë një lak në funksionin kryesor (), i cili do të tregojë të dhëna në çdo interval kohor të përcaktuar (PUB_TIME_SEC), dhe për shembull, derisa të shtypim butonin:

# lak po merr të dhëna derisa të shtypet butoni

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

Ndryshorja PUB_TIME_SEC duhet të deklarohet në kohën kur dëshironi mostrat tuaja.

Për të përmirësuar më shumë kodin tonë, do të ishte mirë të informoni se do të dalim nga laku, për këtë ne do të përcaktojmë 2 funksione të reja të përgjithshme, një për pastrimin e ekranit dhe tjetri për të ndezur LED në një numër të caktuar herë.

# Ekran i qartë:

def displayClear (): oled.fill (0) oled.show () # krijo një funksion blink def blinkLed (num): për i në rang (0, num): led.on () fle (0.5) led.off () gjumë (0.5)

Pra, tani mund të rishkruajmë funksionin tonë kryesor ():

ndërsa butoni.vlera ():

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

Kodi përfundimtar mund të shkarkohet nga GitHub im: localData.py dhe gjithashtu Fletorja Jupyter e përdorur për zhvillimin e kodit të plotë: Zhvillimi i të dhënave lokale Jupyter.

Hapi 7: Lidhja e ESP me WiFi lokal

Moduli i rrjetit përdoret për të konfiguruar lidhjen WiFi. Ekzistojnë dy ndërfaqe WiFi, një për stacionin (kur ESP8266 lidhet me një ruter) dhe një për pikën e hyrjes (që pajisjet e tjera të lidhen me ESP8266). Këtu, ESP -ja jonë do të lidhet me rrjetin lokal. Le të telefonojmë bibliotekën dhe të përcaktojmë kredencialet tona të rrjetit:

rrjeti i importit

WiFi_SSID = "SSID -i YT" WiFi_PASS = "FJALA JUAJ"

Funksioni më poshtë mund të përdoret për të lidhur ESP me rrjetin tuaj lokal:

def do_connect ():

wlan = network. WLAN (network. STA_IF) wlan.active (E vërtetë) nëse jo wlan.cisconnected (): print ('duke u lidhur me rrjetin …') wlan.connect (WiFi_SSID, WiFi_SSID) ndërsa nuk wlan.isconnected (): pass print ('konfigurimi i rrjetit:', wlan.ifconfig ())

Duke ekzekutuar funksionin, mund të merrni si rezultat adresën IP:

do_connect ()

Rezultati do të jetë:

konfigurimi i rrjetit: ('10.0.1.2 ',' 255.255.255.0 ', '10.0.1.1', '10.0.1.1 ')

Në rastin tim, 10.0.1.2, ishte adresa IP e ESP.

Hapi 8: ThingSpeak

Në këtë pikë, ne mësuam se si të kapim të dhëna nga të gjithë sensorët, duke i shfaqur ato në OLED -in tonë. Tani, është koha për të parë se si t'i dërgoni ato të dhëna në një platformë IoT, ThingSpeak.

Le të fillojmë!

Së pari, duhet të keni një llogari në ThinkSpeak.com. Tjetra, ndiqni udhëzimet për të krijuar një kanal dhe mbani shënim ID -në tuaj të kanalit dhe shkruani çelësin API.

Më sipër mund të shihni 5 fushat që do të përdoren në Kanalin tonë.

Hapi 9: Protokolli MQTT dhe Lidhja ThingSpeak

MQTT është një arkitekturë publikimi/abonimi që është zhvilluar kryesisht për të lidhur gjerësinë e brezit dhe pajisjet e kufizuara nga fuqia mbi rrjetet pa tel. Shtë një protokoll i thjeshtë dhe i lehtë që kalon nëpër bazat TCP/IP ose WebSockets. MQTT mbi WebSockets mund të sigurohet me SSL. Arkitektura e publikimit/regjistrimit mundëson që mesazhet të shtyhen në pajisjet e klientit pa pasur nevojë që pajisja të anketojë vazhdimisht serverin.

Ndërmjetësi MQTT është pika qendrore e komunikimit dhe është përgjegjëse për shpërndarjen e të gjitha mesazheve midis dërguesve dhe marrësve të ligjshëm. Një klient është çdo pajisje që lidhet me ndërmjetësin dhe mund të publikojë ose të regjistrohet në tema për të hyrë në informacion. Një temë përmban informacionin e drejtimit për ndërmjetësin. Çdo klient që dëshiron të dërgojë mesazhe i publikon ato në një temë të caktuar, dhe secili klient që dëshiron të marrë mesazhe regjistrohet në një temë të caktuar. Ndërmjetësi i dërgon të gjithë mesazhet me temën që përputhet tek klientët përkatës.

ThingSpeak ™ ka një ndërmjetës MQTT në URL mqtt.thingspeak.com dhe portin 1883. Ndërmjetësi ThingSpeak mbështet të dy botimet MQTT dhe pajtimin MQTT.

Në rastin tonë, ne do të përdorim: MQTT Publish

Figura përshkruan strukturën e temës. Çelësi i shkrimit të API -së kërkohet të publikohet. Ndërmjetësi pranon një kërkesë të saktë LIDHJE me CONNACK.

Protokolli MQTT mbështetet në një bibliotekë të integruar në binaret Micropython-ky protokoll mund të përdoret për të dërguar të dhëna nga ESP8266 tuaj, përmes WIFI, në një bazë të dhënash cloud falas.

Le të përdorim bibliotekën e thjeshtë umqtt.s:

nga umqtt. import i thjeshtë MQTTClient

Dhe duke ditur ID -në tonë SERVER, është e mundur të krijoni objektin tonë të klientit MQTT:

SERVER = "mqtt.thingspeak.com"

klient = MQTTClient ("umqtt_client", SERVER)

Tani, duke pasur kredencialet tuaja ThingSpeak në dorë:

CHANNEL_ID = "ID -ja juaj e kanalit"

WRITE_API_KEY = "KRYESORE JUAJ KETU"

Le të krijojmë "Temën" tonë MQTT:

tema = "kanale/" + CHANNEL_ID + "/publiko/" + WRITE_API_KEY

Le të dërgojmë të dhënat tona në Shërbimin ThingSpeak IoT, duke përdorur funksionin e krijuar dhe të lidhim përgjigjen e tij me ndryshore të veçanta të të dhënave:

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

Me ato ndryshore të përditësuara, ne mund të krijojmë "MQTT Payload" tonë:

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

Dhe kjo eshte! Ne jemi gati të dërgojmë të dhëna në ThinsSpeak, thjesht duke përdorur 3 rreshtat e kodit më poshtë:

client.connect ()

client.publish (tema, ngarkesa) client.disconnect ()

Tani, nëse shkoni në faqen e kanalit tuaj (si e imja më lart) do të shihni që secila nga 5 fushat do të ketë të dhëna që lidhen me sensorët tuaj.

Hapi 10: Regjistruesi i të dhënave të sensorit

Tani, që e dimë se vetëm me disa rreshta kodi është e mundur të ngarkoni të dhëna në një shërbim IoT, le të krijojmë një funksion loop për ta bërë atë automatikisht në një interval të rregullt kohor (i ngjashëm me atë që kemi bërë me "Të dhënat lokale ").

Duke përdorur të njëjtën ndryshore (PUB_TIME_SEC), të deklaruar më parë, një funksion i thjeshtë kryesor për të kapur vazhdimisht të dhëna, regjistrimi i tyre në kanalin tonë do të ishte:

ndërsa e vërtetë:

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)

Vini re se vetëm "ngarkesa" duhet të azhurnohet, pasi "tema" lidhet me kredencialet e kanalit tonë dhe nuk do të ndryshojë.

Duke kërkuar për faqen tuaj të kanalit ThingSpeak, do të vini re se të dhënat do të ngarkohen vazhdimisht në secilën fushë. Ju mund të mbuloni LDR, vendosni dorën në sensorët e temperaturës/zhurmës, shtypni butonin, etj. Dhe shihni se si kanali do të "regjistrojë" automatikisht ato të dhëna për analiza të ardhshme.

Zakonisht, për Regjistrimin e të Dhënave, ne duhet të përpiqemi të përdorim sa më pak energji të jetë e mundur, kështu që, ne nuk do të përdorim LED ose ekran në vend. Gjithashtu, është e zakonshme me pajisjet ESP, vendosini në "gjumë të thellë", ku mikroprocesori do të jetë në gjendjen e tij të energjisë minimale derisa të jetë koha për të kapur të dhëna dhe për t'i dërguar ato në platformën IoT.

Por, sapo ideja po mëson, le të përfshijmë gjithashtu ekranin dhe LED -in siç bëmë më parë. Duke vepruar kështu, funksioni ynë "logger" do të jetë:

ndërsa butoni.vlera ():

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) klient.lidhu () klienti.publikoj (temën, ngarkesën) klientin.shkëput () kohën.gjumë (PUB_TIME_SEC) blinkLed (3) ekranClear ()

Skenari i plotë i microPython mund të gjendet këtu: dataLoggerTS_EXT.py dhe fletorja Jupyter që u përdor për zhvillim mund të gjenden gjithashtu këtu: IoT ThingSpeak Data Logger EXT.ipynb.

Për të ngarkuar skenarin në ESP, në terminalin tuaj përdorni komandën:

ampy vendos dataLoggerTS.py /main.py

Dhe shtypni butonin ESP - reset. Ju do të keni ESP të kapë të dhënat dhe t'i regjistrojë ato në ThingSpeak.com derisa pjesa e poshtme të mbahet e shtypur (prisni që LED të ndizet 3 herë dhe OLED të fiket).

Hapi 11: Aplikacioni ThingView

Të dhënat e regjistruara mund të shihen drejtpërdrejt në faqen e ThingSpeak.com ose përmes një APP, për shembull, ThingsView!

ThingView është një APP e zhvilluar nga CINETICA, që ju mundëson të vizualizoni kanalet tuaja ThingSpeak në një mënyrë të lehtë, thjesht futni ID -në e kanalit dhe jeni gati për të shkuar.

Për kanalet publike, aplikacioni do të respektojë cilësimet e dritareve tuaja: ngjyra, afati kohor, lloji i grafikut dhe numri i rezultateve. Versioni aktual mbështet tabelat e linjave dhe kolonave, tabelat me shtrirje shfaqen si tabela të linjës.

Për kanalet private, të dhënat do të shfaqen duke përdorur cilësimet e paracaktuara, pasi nuk ka asnjë mënyrë për të lexuar cilësimet e dritareve private vetëm me çelësin API.

Aplikacioni ThingView mund të shkarkohet për ANDROID dhe IPHONE.

Hapi 12: Përfundim

Si gjithmonë, shpresoj se ky projekt mund të ndihmojë të tjerët të gjejnë rrugën e tyre në botën emocionuese të elektronikës!

Për detaje dhe kodin përfundimtar, ju lutemi vizitoni depozitimin tim GitHub: IoT_TS_MQTT

Për më shumë projekte, ju lutemi vizitoni blogun tim: MJRoBot.org

Saludos nga jugu i botës!

Shihemi në udhëzimin tim të ardhshëm!

Faleminderit, Marcelo