IoT Imefanya Urahisi: ESP-MicroPython-MQTT-ThingSema: Hatua 12

2024 Mwandishi: John Day | [email protected]. Mwisho uliobadilishwa: 2024-01-30 12:51

Katika mafunzo yangu ya awali, MicroPython kwenye ESP kutumia Jupyter, tulijifunza jinsi ya kusanikisha na kuendesha MicroPython kwenye kifaa cha ESP. Kutumia Jupyter Notebook kama mazingira yetu ya maendeleo, tulijifunza pia kusoma kutoka kwa sensorer (Joto, Unyevu, na Mwangaza), Tunatumia itifaki kadhaa za mawasiliano na njia, Analog, Digital, 1-Wire na I2C, hii ya mwisho kuonyesha picha zetu zilizonaswa. data kwenye onyesho la OLED.

Sasa, kwenye mafunzo haya kwa kutumia itifaki ya MQTT, tutapata data zote zilizopigwa, tukizituma kwa huduma ya IoT, ThingSpeak.com na kwa App ya rununu (Thingsview), ambapo tunaweza kuingia na kucheza na data.

Hapa, mchoro wa mradi wetu:

Hatua ya 1: BoM - Muswada wa Nyenzo

1. NodeMCU - Dola za Marekani 8.39
2. Joto la DHT22 na Sensorer ya Unyevu wa Jamaa - USD 9.95
3. Sensor ya Joto lisilo na maji la DS18B20 - USD 5.95
4. OLED Onyesha SSD1366- USD 8.99 (hiari)
5. LDR (1x)
6. LEDs (1x) (Hiari)
7. Kitufe cha kushinikiza (1x)
8. Resistor 4K7 ohm (2x)
9. Kizuizi cha 10K ohm (1x)
10. Kizuizi cha 220 ohm (1x)

Hatua ya 2: Hw

Hw ambayo tutatumia hapa kimsingi ni ile ile inayotumika kwenye mafunzo: Micropython kwenye ESP Kutumia Jupyter. Rejea kwa miunganisho yote ya HW.

Isipokuwa ni Servo, kwamba hatutatumiwa katika mradi huu.

Hapo juu unaweza kuona HW kamili. Unganisha vifaa kama ilivyoonyeshwa hapo.

Hatua ya 3: Micropython, REPL, Jupyter

Lazima uwe na mkalimani wa Micropython aliyepakiwa kwenye kifaa chako cha ESP. Mara baada ya kubeba, unapaswa kupanga ESP yako kwa kutumia njia zozote zinazopatikana / IDE zinazopatikana, kama:

• REPL
• Kitabu cha Jupyter
• Mu
• ESPCut (Windows tu)
• … na kadhalika

Kwenye mafunzo yangu, Micropython kwenye ESP Kutumia Jupyter, nilielezea jinsi ya kupakua na kusanidi mkalimani wa MicroPython, ESPTool kusimamia vifaa vya ESP na jinsi ya kutumia Jupyter Notebook kama Mazingira ya Maendeleo. Jisikie huru kutumia kile kinachofaa kwako.

Kawaida mimi hufanya maendeleo yote kwenye Jupyter Notebook, na mara tu nitakapopata nambari ya mwisho, ninainakili kwa Geany na kuipakia kwenye ESP yangu kwa kutumia Ampy.

Hatua ya 4: Sensorer

Wacha tuweke maktaba, tufafanue GPIO, tengeneza vitu, kazi kwa sensorer zote moja kwa moja:

A. DHT (Joto na Unyevu)

Wacha tuweke maktaba ya DHT na tuunde kitu:

kutoka dht kuagiza DHT22

kutoka kwa kuingiza mashine Pin dht22 = DHT22 (Pin (12))

Sasa, tengeneza kazi ya kusoma sensor ya DHT:

soma kusomaDht ():

dht22.pima () kurudi dht22. joto (), dht22. unyevu () Jaribu utendaji wa DHT

chapisha (somaDht ())

Matokeo yanapaswa kuwa kwa mfano:

(17.7, 43.4)

B. DS18B20 (Joto la nje)

Wacha tuweke maktaba na tuunde kitu:

kuagiza onewire, ds18x20

wakati wa kuagiza # Fafanua ni siri gani kifaa cha waya 1 kitaunganishwa ==> pini 2 (D4) dat = Pini (2) # unda kitu chochote ds = ds18x20. DS18X20 (onewire. OneWire (dat)) Tafuta vifaa kwenye bu

sensorer = ds.scan ()

chapa ('vifaa vilivyopatikana:', sensorer)

Matokeo yaliyochapishwa sio muhimu sana, tutakachohitaji ni sensorer ya kwanza kugunduliwa: sensorer [0]. Na sasa, tunaweza kujenga kazi kusoma data ya sensorer:

def readDs ():

ds.convert_temp () wakati. usingizi_ms (750) kurudi ds.read_temp (sensorer [0])

Daima ni muhimu kujaribu sensor kutumia kazi iliyoundwa

chapisha (somaDs ()) Ukipata joto, nambari yako sahihi

17.5

C. LDR (Mwangaza)

LDR itatumia pini ya analog ya ESP yetu (ni moja tu katika kesi ya ESP8266 na kadhaa kwa ESP32).

Rejea mafunzo yangu ya ESP32 kwa maelezo.

Sawa na ilivyofanywa hapo awali:

# kuagiza maktaba

kutoka kwa kuingiza mashine ADC # Fafanua kitu adc = ADC (0) Kazi rahisi: adc.read () inaweza kutumika kusoma thamani ya ADC. Lakini kumbuka kuwa ADC ya ndani itabadilisha voltages kati ya 0 na 3.3V kwa maadili ya dijiti ya mwandishi, tofauti kutoka 0 hadi 1023. Mara tu tunapovutiwa na "Mwangaza", tutazingatia mwangaza wa Max kama kiwango cha juu kabisa cha thamani kutoka kwa sensa (katika yangu kesi 900) na taa ndogo ambayo kwa upande wangu ni 40. Kuwa na maadili hayo tunaweza "kuweka ramani" thamani kutoka 40 hadi 900 katika 0 hadi 100% ya mwangaza. Kwa hilo, tutaunda kazi mpya

soma kusomaLdr ():

lumPerct = (adc.read () - 40) * (10/86) # kubadilisha kwa asilimia ("ramani") kurudi pande zote (lumPerct)

Unapaswa kujaribu kazi hiyo kwa kutumia print (readLDR ()). Matokeo yake yanapaswa kuwa nambari kamili kati ya o na 100.

Kitufe cha kushinikiza (Ingizo la Dijiti)

Hapa tunatumia Kitufe cha kushinikiza kama sensa ya dijiti, lakini inaweza kuwa "mwangwi" wa mtendaji (Pampu iliyowashwa / KUZIMWA, kwa mfano).

# fafanua pini 13 kama pembejeo na uamilishe kipinga cha ndani cha Kuvuta:

kifungo = Pin (13, Pin. IN, Pin. PULL_UP) # Kazi ya kusoma hali ya kifungo: def readBut (): kurudi button.value ()

Unaweza kujaribu kitufe kusoma kazi ya kuchapisha (somaBut ()). W / o kubonyeza matokeo inapaswa kuwa "1". Kubonyeza kitufe, matokeo yanapaswa kuwa "0"

Hatua ya 5: Kukamata na Kuonyesha Takwimu zote za Sensorer

Sasa kwa kuwa tumeunda kazi moja kwa kila sensa, wacha tuunde ya mwisho ambayo itasoma zote kwa wakati mmoja:

def colectData ():

temp, hum, = readDht () extTemp = readDs () lum = somaLdr () butSts = somaLakini () kurudi temp, hum, extTemp, lum, butts Sasa ikiwa unatumia

chapisha (colectData ())

Itasababisha Tuple ambayo inajumuisha data zote zilizonaswa kutoka kwa sensorer:

(17.4, 45.2, 17.3125, 103, 1)

Tunaweza pia kwa hiari, kuonyesha data hizo kwenye onyesho la kawaida:

# kuagiza maktaba na unda kitu i2c

kutoka kwa uingizaji wa mashine I2C i2c = I2C (scl = Pin (5), sda = Pin (4)) # maktaba ya kuagiza na uunda oled import ssd1306 i2c = I2C (scl = Pin (5), sda = Pin (4)) oled = ssd1306. SSD1306_I2C (128, 64, i2c, 0x3c) # tengeneza kazi: 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 ("Kitufe:" + str (butSts), 0, 57) oled. Onyesha () # onyesha data kwa kutumia onyesho la dataData (temp, hum, extTemp, lum, butSts)

Kama chaguo, nitajumuisha pia kuwasha LED wakati tunapoanza kusoma sensorer, KUZIMA baada ya data kuonyeshwa. Kufanya hivi kutasaidia kudhibitisha kuwa programu inafanya kazi wakati tuna ESP iliyokataliwa kutoka kwa PC na inaendesha kiatomati.

Kwa hivyo, kazi kuu itakuwa:

# Kazi kuu kusoma sensorer zote

def main (): # onyesha data na kazi inayoongozwa.on () temp, hum, extTemp, lum, butSts = colectData () displayData (temp, hum, extTemp, lum, butSts) led.off ()

Kwa hivyo, kutekeleza kuu (), tutapata data ya sensorer iliyoonyeshwa kwenye OLED kama inavyoonyeshwa kwenye picha.

Hatua ya 6: Kuendesha Nambari ya Kituo cha Mitaa kwenye Kuanza kwa ESP

Tunaweza kuwa na yote yaliyotengenezwa hadi sasa kwenye faili moja ya kutekelezwa na ESP yetu.

Wacha tufungue kihariri chochote cha maandishi na tupite code yote:

# kuagiza maktaba ya jumla

kutoka kwa kuingiza mashine wakati wa kuagiza Pin # fafanua pini 0 kama pato lililoongozwa = Pin (0, Pin. OUT) # DHT kutoka dht kuagiza DHT22 dht22 = DHT22 (Pin (12)) # Kazi kusoma DHT def readDht (): dht22.measure () kurudi dht22.temperature (), dht22.humidity () # DS18B20 import onewire, ds18x20 # Define which pin the 1-wire device will be connected ==> pin 2 (D4) dat = Pin (2) # Create onewireire kitu ds = ds18x20. DS18X20 (onewire. OneWire (dat)) # tafuta vifaa kwenye sensorer za basi = ds.scan () # kazi kusoma DS18B20 def readDs (): ds.convert_temp () time.sleep_ms (750) kurudi pande zote (ds.read_temp (sensorer [0]), 1) # LDR kutoka kwa kuingiza mashine ADC # Fafanua kitu adc = ADC (0) #utendaji kusoma mwangaza def readLdr (): lumPerct = (adc.read () - 40) * (10/86) # ubadilishe kwa asilimia ("ramani") raundi ya kurudi (lumPerct) # fafanua pini 13 kama pembejeo na uwashe kipinga cha ndani cha Kuvuta: kifungo = Pin (13, Pin. IN, Pin. PULL_UP) # Kazi ya kusoma hali ya kifungo: def readBut (): kurudi button.value () # Kazi kusoma data zote: def cole ctData (): temp, hum, = readDht () extTemp = readDs () lum = readLdr () butSts = readBut () kurudi temp, hum, extTemp, lum, buttsts # kuagiza maktaba na kuunda kitu i2c kutoka kwa kuingiza mashine I2C i2c = I2C (scl = Pin (5), sda = Pin (4)) # kuagiza maktaba na kuunda kitu oled kuagiza ssd1306 i2c = I2C (scl = Pin (5), sda = Pin (4)) oled = ssd1306. SSD1306_I2C (128, 64, i2c, 0x3c) # tengeneza kazi: 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) imechorwa mafuta. maandishi ("Lumin:" + str (lum) + "%", 0, 43) oled.text ("Button:" + str (butSts), 0, 57) oled.show () # Kazi kuu kusoma sensorer zote def main (): # onyesha data na kazi inayoongozwa.on () temp, hum, extTemp, lum, butSts = colectData () displayData (temp, hum, extTemp, lum, butSts) led.off () '' - ----- endesha kazi kuu -------- '' kuu ()

Hifadhi, kwa mfano kama localData.py.

Ili kuendesha nambari hii moja kwa moja kwenye terminal yako utahitaji Ampy.

Kwanza, kwenye Kituo tunamjulisha Ampy bandari yetu ya serial:

kuuza nje AMPY_PORT = / dev / tty. SLAB_USBtoUART

Sasa, tunaweza kuona faili zilizo ndani ya saraka yetu ya mizizi ya ESP:

amps ls

Kama jibu, tutapata boot.py, hiyo ndiyo faili ya kwanza ambayo itaendesha kwenye mfumo.

Sasa, wacha tutumie Ampy kupakia hati yetu ya chatu LocalData.py kama /main.py, kwa hivyo hati itaendesha baada tu ya boot:

ampy weka localData.py / main / py

Ikiwa tutatumia amri amp ls sasa, utaona faili 2 ndani ya ESP.: boot.py na main.py

Kuweka upya ESP yako, kutafanya programu ya localData.py iendeshwe kiatomati, ikionyesha data ya sensa iliyoonyeshwa.

Skrini ya kuchapisha ya Kituo cha hapo juu inaonyesha kile tumefanya.

Na nambari iliyo hapo juu, onyesho litaonyeshwa mara moja tu, lakini tunaweza kufafanua kitanzi kwenye kazi kuu (), ambayo itaonyesha data kwenye kila muda uliowekwa wa muda (PUB_TIME_SEC), na kwa mfano, mpaka bonyeza kitufe:

# kitanzi kupata data mpaka kitufe kinabonyeza

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

PUB_TIME_SEC inayobadilika lazima itangazwe na wakati ambao unataka sampuli zako.

Ili kuongeza nambari yetu zaidi, itakuwa vizuri kuarifu kwamba tutatoka kitanzi, kwa kuwa tutafafanua kazi mbili mpya za jumla, moja ya kusafisha onyesho na nyingine kupepesa LED kwa idadi fulani ya nyakati.

# Onyesha wazi:

def displayClear (): oled.fill (0) oled.show () # unda blink function def blinkLed (num): for i in range (0, num): led.on () lala (0.5) led.off (kulala (0.5)

Kwa hivyo, tunaweza sasa, kuandika tena kazi yetu kuu ():

wakati button.thamani ():

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

Nambari ya mwisho inaweza kupakuliwa kutoka kwa GitHub yangu: localData.py na pia Jupyter Notebook iliyotumiwa kwa utengenezaji wa nambari kamili: Jupyter Local Data Development.

Hatua ya 7: Kuunganisha ESP na WiFi ya Mitaa

Moduli ya mtandao hutumiwa kusanidi unganisho la WiFi. Kuna viunganisho viwili vya WiFi, moja ya kituo (wakati ESP8266 inaunganisha kwa router) na moja ya kituo cha ufikiaji (kwa vifaa vingine kuungana na ESP8266). Hapa, ESP yetu itaunganishwa na mtandao wa ndani. Wacha tuite maktaba na tufafanue sifa zetu za mtandao:

kuagiza mtandao

WiFi_SSID = "SSID YAKO" WiFi_PASS = "NENO LAKO"

Kazi hapa chini inaweza kutumika kuunganisha ESP na mtandao wako wa karibu:

def do_connect ():

wlan = mtandao. WLAN (network. STA_IF) wlan.active (Kweli) ikiwa sio wlan.isconnected (): chapa ('unganisha kwa mtandao …') wlan.connect (WiFi_SSID, WiFi_SSID) wakati sio wlan.isconnected (): kupita chapisha ('usanidi wa mtandao:', wlan.ifconfig ())

Kuendesha kazi, unaweza kupata kama anwani ya IP:

unganisha_)

Matokeo yatakuwa:

usanidi wa mtandao: ('10.0.1.2 ',' 255.255.255.0 ', '10.0.1.1', '10.0.1.1 ')

Kwa upande wangu, 10.0.1.2, ni anwani ya IP ya ESP.

Hatua ya 8: The ThingSpeak

Kwa wakati huu, tulijifunza jinsi ya kunasa data kutoka kwa sensorer zote, kuzionyesha kwenye OLED yetu. Sasa, ni wakati wa kuona jinsi ya kutuma data hizo kwenye jukwaa la IoT, ThingSpeak.

Wacha tuanze!

Kwanza, lazima uwe na akaunti kwenye ThinkSpeak.com. Ifuatayo, fuata maagizo ya kuunda Kituo na utambue Kitambulisho chako cha Kituo na Andika Ufunguo wa API.

Hapo juu unaweza kuona sehemu 5 ambazo zitatumika kwenye Kituo chetu.

Hatua ya 9: Itifaki ya MQTT na Uunganisho wa ThingSpeak

MQTT ni usanifu wa kuchapisha / usajili ambao umetengenezwa haswa kuunganisha upelekaji wa umeme na vifaa vyenye nguvu juu ya mitandao isiyo na waya. Ni itifaki rahisi na nyepesi inayoendesha soketi za TCP / IP au Soketi za Wavuti. MQTT juu ya Wavuti inaweza kulindwa na SSL. Usanifu wa kuchapisha / usajili unawezesha ujumbe kusukumwa kwa vifaa vya mteja bila kifaa kuhitaji kuendelea kuchafua seva.

Dalali wa MQTT ndiye kituo kikuu cha mawasiliano, na inasimamia kupeleka ujumbe wote kati ya watumaji na wapokeaji halali. Mteja ni kifaa chochote kinachounganisha na broker na anaweza kuchapisha au kujisajili kwenye mada kupata habari. Mada ina habari ya uelekezaji kwa broker. Kila mteja anayetaka kutuma ujumbe anazichapisha kwenye mada fulani, na kila mteja anayetaka kupokea ujumbe anajiunga na mada fulani. Dalali hutoa ujumbe wote na mada inayofanana kwa wateja wanaofaa.

ThingSpeak ™ ina broker ya MQTT kwenye URL mqtt.thingspeak.com na bandari 1883. Dalali ya ThingSpeak inasaidia MQTT kuchapisha na MQTT kujisajili.

Kwa upande wetu, tutatumia: MQTT Chapisha

Takwimu inaelezea muundo wa mada. Kitufe cha Andika API kinahitajika kuchapisha. Dalali anakubali ombi sahihi la CONNECT na CONNACK.

Itifaki ya MQTT inasaidiwa katika maktaba iliyojengwa katika binaries ya Micropython - itifaki hii inaweza kutumika kutuma data kutoka kwa ESP8266 yako, juu ya WIFI, kwa hifadhidata ya wingu ya bure.

Wacha tutumie maktaba ya umqtt.simple:

kutoka umqtt.simple kuagiza MQTTClient

Na kujua kitambulisho chetu cha SERVER, inawezekana kuunda kitu chetu cha mteja wa MQTT:

SERVER = "mqtt.thingspeak.com"

mteja = MQTTClient ("umqtt_client", SERVER)

Sasa, ukiwa na hati zako za ThingSpeak mkononi:

CHANNEL_ID = "ID YAKO YA CHANZO"

WRITE_API_KEY = "MUHIMU WAKO HAPA"

Wacha tuunde "Mada" yetu ya MQTT:

mada = "vituo /" + CHANNEL_ID + "/ chapisha /" + WRITE_API_KEY

Wacha tupate data yetu ipelekwe kwa Huduma ya ThingSpeak IoT, kwa kutumia kazi iliyoundwa na ushirikishe majibu yake kwa anuwai ya data:

temp, hum, extTemp, lum, lakini Sts = colectData ()

Pamoja na vigeuzi hivi vimesasishwa, tunaweza kuunda "MQTT Payload" yetu:

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

Na ndio hivyo! Tuko tayari kutuma data kwa ThinsSpeak, kwa kutumia tu mistari 3 ya nambari hapa chini:

mteja.connect ()

mteja.chapisha (mada, malipo ya malipo) mteja.disconnect ()

Sasa, ukienda kwenye ukurasa wako wa kituo (kama changu hapo juu) utaona kuwa kila uwanja kati ya 5 utakuwa na data inayohusiana na sensorer zako.

Hatua ya 10: Logger Data ya Sensor

Sasa, kwa kuwa tunajua kuwa na mistari michache tu ya nambari inawezekana kupakia data kwenye huduma ya IoT, wacha tuunde kazi ya kitanzi kuifanya kiatomati kwa muda wa kawaida (sawa na yale ambayo tumefanya na "data ya Mitaa." ").

Kutumia ubadilishaji sawa (PUB_TIME_SEC), uliotangazwa hapo awali, kazi kuu rahisi kuendelea kukamata data, kuziingilia kwenye kituo chetu itakuwa:

wakati Kweli:

temp, hum, extTemp, lum, butSts = colectData () payload = "field1 =" + str (temp) + "& field2 =" + str (hum) + "& field3 =" + str (extTemp) + "& field4 =" + str (lum) + "& field5 =" + str (butSts) mteja.connect () mteja.chapisha (mada, malipo ya malipo) mteja.disconnect () time.sleep (PUB_TIME_SEC)

Kumbuka kuwa tu "mzigo wa malipo" lazima usasishwe, mara tu "mada" inahusiana na idhini ya kituo chetu na haitabadilika.

Kutafuta ukurasa wako wa kituo cha ThingSpeak, utaona kuwa data itakuwa ikipakia kila uwanja kila wakati. Unaweza kufunika LDR, weka mkono wako kwenye sensorer za temp / hum, bonyeza kitufe, n.k. na uone jinsi kituo hicho kitakavyoweka "kumbukumbu" moja kwa moja data hizo kwa uchambuzi wa baadaye.

Kawaida, kwa Uwekaji wa Takwimu, tunapaswa kujaribu kutumia nguvu kidogo iwezekanavyo, kwa hivyo, hatutatumia LED au kuonyesha ndani. Pia, ni kawaida na vifaa vya ESP, vitie kwenye "usingizi mzito", ambapo microprocessor itakuwa kwenye hali ya kiwango cha chini cha nishati hadi wakati wa kukamata data na kuwapeleka kwenye jukwaa la IoT.

Lakini, mara tu hapa wazo linajifunza, hebu pia tujumuishe onyesho na LED kama tulivyofanya hapo awali. Kufanya hivyo, kazi yetu ya "logger" itakuwa:

wakati button.thamani ():

led () temp, hum, extTemp, lum, butts = colectData () onyeshaData (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) mteja.kuunganisha () mteja.chapisha (mada, malipo) mteja.disconnect () wakati. kulala (PUB_TIME_SEC) blinkLed (3) kuonyeshaClear ()

Hati kamili ya microPython inaweza kupatikana hapa: dataLoggerTS_EXT.py na daftari ya Jupyter ambayo ilitumika kwa maendeleo inaweza pia kupatikana hapa: IoT ThingSpeak Data Logger EXT.ipynb.

Ili kupakia hati kwenye ESP, kwenye terminal yako tumia amri:

kuweka dataLoggerTS.py / main.py

Na bonyeza kitufe cha ESP - upya. Utakuwa na data ya kukamata ESP na kuiweka kwenye ThingSpeak.com hadi chini itakapowekwa chini (subiri LED iangaze mara 3 na OLED imezima).

Hatua ya 11: Programu ya ThingView

Takwimu zilizoingia zinaweza kutazama moja kwa moja kwenye tovuti ya ThingSpeak.com au kupitia APP, kwa mfano, ThingsView!

ThingView ni APP iliyoundwa na CINETICA, ambayo inakuwezesha kuibua njia zako za ThingSpeak kwa njia rahisi, ingiza tu kitambulisho cha kituo na uko tayari kwenda.

Kwa njia za umma, programu itaheshimu mipangilio yako ya windows: rangi, upimaji wa nyakati, aina ya chati na idadi ya matokeo. Toleo la sasa linasaidia chati za safu na safu, chati za spline zinaonyeshwa kama chati za laini.

Kwa vituo vya faragha, data itaonyeshwa kwa kutumia mipangilio chaguomsingi, kwani hakuna njia ya kusoma mipangilio ya faragha ya windows na kitufe cha API tu.

ThingView APP inaweza kupakuliwa kwa ANDROID na IPHONE.

Hatua ya 12: Hitimisho

Kama kawaida, natumahi mradi huu unaweza kusaidia wengine kupata njia yao katika ulimwengu wa kusisimua wa umeme!

Kwa maelezo na nambari ya mwisho, tafadhali tembelea duka langu la GitHub: IoT_TS_MQTT

Kwa miradi zaidi, tafadhali tembelea blogi yangu: MJRoBot.org

Saludos kutoka kusini mwa ulimwengu!

Tukutane kwenye mafunzo yangu yafuatayo!

Asante, Marcelo