Ginagawa ang IoT madali: ESP-MicroPython-MQTT-ThingSpeak: 12 Hakbang

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:13

Sa aking nakaraang tutorial, ang MicroPython sa ESP na gumagamit ng Jupyter, natutunan namin kung paano i-install at patakbuhin ang MicroPython sa isang aparatong ESP. Gamit ang Jupyter Notebook bilang aming kapaligiran sa pag-unlad, natutunan din namin kung paano magbasa mula sa mga sensor (Temperatura, Humidity, at Luminosity), Gumagamit kami ng maraming mga protocol at pamamaraan sa komunikasyon, Analog, Digital, 1-Wire at I2C, ang huling ito upang maipakita ang aming nakuha data sa isang OLED display.

Ngayon, sa tutorial na ito gamit ang isang MQTT protocol, makukuha namin ang lahat ng nakuhang data, ipinapadala sila sa isang serbisyo ng IoT, ThingSpeak.com at sa isang mobile App (Thingsview), kung saan maaari kaming mag-log at maglaro ng data.

Dito, ang diagram ng block ng aming proyekto:

Hakbang 1: BoM - Bill of Material

1. NodeMCU - US $ 8.39
2. DHT22 Temperatura at Kamag-anak na Sensor ng Humidity - USD 9.95
3. DS18B20 Waterproof Temperature Sensor - USD 5.95
4. OLED Display SSD1366- USD 8.99 (opsyonal)
5. LDR (1x)
6. Mga LED (1x) (Opsyonal)
7. Push Button (1x)
8. Resistor 4K7 ohm (2x)
9. Resistor 10K ohm (1x)
10. Resistor 220 ohm (1x)

Hakbang 2: Ang Hw

Ang Hw na gagamitin namin dito karaniwang ay ang parehong ginagamit sa tutorial: Micropython sa ESP Paggamit ng Jupyter. Sumangguni dito para sa lahat ng mga koneksyon sa HW.

Ang pagbubukod ay ang Servo, na hindi kami gagamitin sa proyektong ito.

Sa itaas makikita mo ang buong HW. Ikonekta ang mga aparato tulad ng ipinakita doon.

Hakbang 3: Micropython, REPL, Jupyter

Dapat ay mayroon kang isang interpreter ng Micropython na na-load sa iyong aparato sa ESP. Kapag na-load na, dapat mong i-program ang iyong ESP gamit ang alinman sa mga magagamit na paraan / IDE na magagamit, tulad ng:

• REPL
• Jupyter Notebook
• Mu
• ESPCut (Windows lang)
• … atbp

Sa aking tutorial, Micropython sa ESP Gamit ang Jupyter, detalyado ko kung paano mag-download at mag-install ng interpreter ng MicroPython, ESPTool upang pamahalaan ang mga aparato ng ESP at kung paano gamitin ang Jupyter Notebook bilang isang Kapaligiran sa Pag-unlad. Huwag mag-atubiling gamitin kung ano ang mas komportable para sa iyo.

Kadalasan ginagawa ko ang lahat ng pag-unlad sa Jupyter Notebook, at sa sandaling makuha ko ang pangwakas na code, kinopya ko ang mga ito sa Geany at i-load ito sa aking ESP gamit ang Ampy.

Hakbang 4: Mga Sensor

I-install natin ang mga aklatan, tukuyin ang GPIO, lumikha ng mga bagay, pag-andar para sa lahat ng mga sensor nang paisa-isa:

A. DHT (Temperatura at Humidity)

I-install Natin ang DHT library at lumikha ng isang object:

mula sa dht import DHT22

mula sa pag-import ng makina Pin dht22 = DHT22 (Pin (12))

Ngayon, lumikha ng isang pagpapaandar upang mabasa ang sensor ng DHT:

def readDht ():

dht22.measure () ibalik ang dht22.temperature (), dht22.humidity () Subukan ang pagpapaandar ng DHT

i-print (readDht ())

Ang resulta ay dapat na halimbawa:

(17.7, 43.4)

B. DS18B20 (Panlabas na Temperatura)

I-install Natin ang mga aklatan at lumikha ng isang bagay:

i-import ang onewire, ds18x20

oras ng pag-import # Tukuyin kung aling pin ang 1-wire na aparato ay makakonekta ==> pin 2 (D4) dat = Pin (2) # likhain ang onewire object ds = ds18x20. DS18X20 (onewire. OneWire (dat)) I-scan ang mga aparato sa bu

sensor = ds.scan ()

i-print ('mga nahanap na aparato:', sensor)

Ang naka-print na resulta ay hindi totoong mahalaga, ang kakailanganin namin ay ang unang napansin na sensor: mga sensor [0]. At ngayon, makakagawa kami ng isang pagpapaandar upang mabasa ang data ng sensor:

def readDs ():

ds.convert_temp () time.s Sleep_ms (750) bumalik ds.read_temp (sensor [0])

Palaging mahalaga na subukan ang sensor gamit ang nilikha na pag-andar

print (readDs ()) Kung nakakuha ka ng isang halaga ng temperatura, tama ang iyong code

17.5

C. LDR (Liwanag)

Gagamitin ng LDR ang analog pin ng aming ESP (isa lamang ito sa kaso ng ESP8266 at ilan sa ESP32).

Sumangguni sa aking tutorial sa ESP32 para sa mga detalye.

Kapareho ng tapos na dati:

# import library

mula sa machine import ADC # Tukuyin ang object adc = ADC (0) Ang isang simpleng pag-andar: adc.read () ay maaaring magamit upang basahin ang halaga ng ADC. Ngunit tandaan na ang panloob na ADC ay magko-convert ng mga voltages sa pagitan ng 0 at 3.3V sa mga sulat na digital na halaga, na nag-iiba mula 0 hanggang 1023. Kapag interesado kami sa "Luminosity", isasaalang-alang namin ang Max light bilang ang maximum na nakuha na halaga mula sa sensor (sa aking kaso 900) at minimum na ilaw na sa aking kaso ay 40. Ang pagkakaroon ng mga halagang iyon maaari naming "mapa" ang halaga mula 40 hanggang 900 sa 0 hanggang 100% ng ningning. Para doon, lilikha kami ng isang bagong pagpapaandar

def readLdr ():

lumPerct = (adc.read () - 40) * (10/86) # convert sa porsyento ("mapa") return round (lumPerct)

Dapat mong subukan ang pagpapaandar gamit ang print (readLDR ()). Ang resulta ay dapat na isang integer sa pagitan ng o at 100.

D. Push-Button (Digital Input)

Narito gumagamit kami ng isang Push-Button bilang isang digital sensor, ngunit maaaring ito ay isang "echo" ng isang actuator (Isang bomba na naka-ON / OFF, halimbawa).

# tukuyin ang pin 13 bilang isang pag-input at buhayin ang isang panloob na resistor na Pull-up:

button = Pin (13, Pin. IN, Pin. PULL_UP) # Pag-andar upang basahin ang pindutan ng estado: def read But (): return button.value ()

Maaari mong subukan ang pindutan na binabasa ang pagpapa-print ng pag-andar (readBut ()). Ang pagpindot sa resulta ay dapat na "1". Ang pagpindot sa pindutan, ang resulta ay dapat na "0"

Hakbang 5: Pagkuha at Pagpapakita ng Lokal Lahat ng Data ng Sensor

Ngayon na lumikha kami ng isang pagpapaandar para sa bawat sensor, lumikha tayo ng huling makakabasa ng lahat sa kanila nang sabay:

def colectData ():

temp, hum, = readDht () extTemp = readDs () lum = readLdr () butSts = readBut () ibalik ang temp, hum, extTemp, lum, butSts Ngayon kung gumamit ka

print (colectData ())

Magreresulta sa isang tuple na may kasamang lahat ng nakuhang data mula sa mga sensor:

(17.4, 45.2, 17.3125, 103, 1)

Maaari din nating opsyonal, ipakita ang data na iyon sa isang lokal na display:

# import library at lumikha ng object i2c

mula sa pag-import ng makina I2C i2c = I2C (scl = Pin (5), sda = Pin (4)) # import library at lumikha ng object oled import ssd1306 i2c = I2C (scl = Pin (5), sda = Pin (4)) oled = ssd1306. SSD1306_I2C (128, 64, i2c, 0x3c) # lumikha ng isang function: 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 () # ipakita ang data gamit ang function na displayData (temp, hum, extTemp, lum, butSts)

Bilang isang pagpipilian, isasama ko rin ang LED upang maging ON kapag nagsimula kaming magbasa ng mga sensor, MAG-OFF pagkatapos ipakita ang data na iyon. Ang paggawa nito ay makakatulong upang kumpirmahing gumagana ang programa kapag mayroon kaming nakakonekta na ESP mula sa PC at awtomatikong tumatakbo.

Kaya, ang pangunahing pagpapaandar ay:

# Pangunahing pagpapaandar upang mabasa ang lahat ng mga sensor

def main (): # display data with a function led.on () temp, hum, extTemp, lum, butSts = colectData () displayData (temp, hum, extTemp, lum, butSts) led.off ()

Kaya, sa pagpapatupad ng pangunahing (), makukuha namin ang data ng sensor na ipinakita sa OLED tulad ng ipinakita sa larawan.

Hakbang 6: Pagpapatakbo ng Local Station Code sa Start-up ng ESP

Maaari nating makuha ang lahat na nabuo sa ngayon sa isang solong file upang maipatupad ng aming ESP.

Buksan natin ang anumang editor ng teksto at nakaraan dito ang lahat ng code:

# i-import ang pangkalahatang mga aklatan

mula sa pag-import ng machine Pin oras ng pag-import # tukuyin ang pin 0 bilang output led = Pin (0, Pin. OUT) # DHT mula sa dht import DHT22 dht22 = DHT22 (Pin (12)) # Function na basahin ang DHT def readDht (): dht22.measure () bumalik dht22.temperature (), dht22.humidity () # DS18B20 import onewire, ds18x20 # Tukuyin kung aling pin ang 1-wire na aparato ay makakonekta ==> pin 2 (D4) dat = Pin (2) # Lumikha ng onewire object ds = ds18x20. DS18X20 (onewire. OneWire (dat)) # scan para sa mga aparato sa mga sensor ng bus = ds.scan () # function na basahin ang DS18B20 def readDs (): ds.convert_temp () time.s Sleep_ms (750) return bilog (ds.read_temp (sensor [0]), 1) # LDR mula sa pag-import ng makina ADC # Tukuyin ang object adc = ADC (0) #function upang mabasa ang luminosity def readLdr (): lumPerct = (adc.read () - 40) * (10/86) # pag-convert sa porsyento ("mapa") return round (lumPerct) # tukuyin ang pin 13 bilang isang input at buhayin ang isang panloob na resistor na Pull-up: button = Pin (13, Pin. IN, Pin. PULL_UP) # Function to read button state: def read But (): return button.value () # Function to read all data: def cole ctData (): temp, hum, = readDht () extTemp = readDs () lum = readLdr () butSts = readBut () ibalik ang temp, hum, extTemp, lum, ngunitSts # import library at lumikha ng object i2c mula sa pag-import ng makina I2C i2c = I2C (scl = Pin (5), sda = Pin (4)) # import library at lumikha ng object oled import ssd1306 i2c = I2C (scl = Pin (5), sda = Pin (4)) oled = ssd1306. SSD1306_I2C (128, 64, i2c, 0x3c) # lumikha ng isang function: 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. teksto ("Lumin:" + str (lum) + "%", 0, 43) oled.text ("Button:" + str (butSts), 0, 57) oled.show () # Pangunahing pagpapaandar upang mabasa ang lahat ng mga sensor def main (): # display data with a function led.on () temp, hum, extTemp, lum, butSts = colectData () displayData (temp, hum, extTemp, lum, butSts) led.off () "" - ----- patakbuhin ang pangunahing pagpapaandar ---- '' 'pangunahing ()

I-save ito, halimbawa bilang localData.py.

Upang direktang patakbuhin ang code na ito sa iyong terminal kakailanganin mo si Ampy.

Una, sa Terminal ipaalam natin kay Ampy ang aming Serial port:

i-export ang AMPY_PORT = / dev / tty. SLAB_USBtoUART

Ngayon, maaari naming makita ang mga file na nasa loob ng aming direktoryo ng ugat ng ESP:

sapat ls

Bilang isang tugon, makakakuha kami ng boot.py, iyon ang unang file na tatakbo sa system.

Ngayon, gamitin natin ang Ampy upang mai-load ang aming python Script LocalData.py bilang /main.py, kaya tatakbo ang script pagkatapos lamang ng boot:

sapat na ilagay localData.py / main / py

Kung gagamitin namin ang command amp ls ngayon, makakakita ka ng 2 mga file sa loob ng ESP.: boot.py at main.py

Ang pag-reset sa iyong ESP, gagawing awtomatikong tatakbo ang program na localData.py, na ipinapakita ang data ng sensor na ipinapakita.

Ipinapakita ng screen ng print sa itaas ng Terminal kung ano ang aming nagawa.

Sa itaas na code, ipapakita ang display nang isang beses lamang, ngunit maaari naming tukuyin ang isang loop sa pangunahing () pagpapaandar, ipapakita ang data sa bawat tinukoy na agwat ng oras (PUB_TIME_SEC), at halimbawa, hanggang sa pindutin namin ang pindutan:

# loop pagkuha ng data hanggang sa pindutin ang pinindot

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

Ang variable na PUB_TIME_SEC ay dapat ideklara ng oras na nais mo ang iyong mga sample.

Upang mapahusay ang higit pa sa aming code, mainam na ipagbigay-alam na lalabas kami mula sa loop, na tutukuyin namin ang 2 bagong mga pangkalahatang pag-andar, isa para i-clear ang display at isa pa upang magpikit ang LED sa isang tiyak na bilang ng mga beses.

# I-clear ang display:

def displayClear (): oled.fill (0) oled.show () # create a blink function def blinkLed (num): for i in range (0, num): led.on () sleep (0.5) led.off () pagtulog (0.5)

Kaya, maaari na natin ngayon, muling isulat ang aming pangunahing () pagpapaandar:

habang button.value ():

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

Maaaring mai-download ang pangwakas na code mula sa aking GitHub: localData.py at pati na rin ang Jupyter Notebook na ginamit para sa pagbuo ng buong code: Jupyter Local Data Development.

Hakbang 7: Pagkonekta sa ESP sa Lokal na WiFi

Ginagamit ang module ng network upang mai-configure ang koneksyon sa WiFi. Mayroong dalawang mga interface ng WiFi, isa para sa istasyon (kapag kumonekta ang ESP8266 sa isang router) at isa para sa access point (para sa iba pang mga aparato upang kumonekta sa ESP8266). Dito, makokonekta ang aming ESP sa lokal na network. Tumawag tayo sa silid-aklatan at tukuyin ang aming mga kredensyal sa network:

mag-import ng network

WiFi_SSID = "IYONG SSID" WiFi_PASS = "IYONG PASSWORD"

Ang pagpapaandar sa ibaba ay maaaring magamit upang ikonekta ang ESP sa iyong lokal na network:

def do_connect ():

wlan = network. WLAN (network. STA_IF) wlan.active (True) kung hindi wlan.isconnected (): i-print ('pagkonekta sa network…') wlan.connect (WiFi_SSID, WiFi_SSID) habang hindi wlan.isconnected (): pumasa i-print ('network config:', wlan.ifconfig ())

Pagpapatakbo ng pagpapaandar, maaari mong makuha bilang isang resulta ang IP address:

do_connect ()

Ang resulta ay:

network config: ('10.0.1.2 ',' 255.255.255.0 ', '10.0.1.1', '10.0.1.1 ')

Sa aking kaso, 10.0.1.2, ay ang ESP IP address.

Hakbang 8: Ang ThingSpeak

Sa puntong ito, natutunan namin kung paano kumuha ng data mula sa lahat ng mga sensor, ipinapakita ang mga ito sa aming OLED. Ngayon, oras na upang makita kung paano ipadala ang data na iyon sa isang IoT platform, ang ThingSpeak.

Magsimula na tayo!

Una, dapat mayroon kang isang account sa ThinkSpeak.com. Susunod, sundin ang mga tagubilin upang lumikha ng isang Channel at tandaan ang iyong Channel ID at Sumulat ng API Key.

Sa itaas makikita mo ang 5 mga patlang na gagamitin sa aming Channel.

Hakbang 9: MQTT Protocol at ThingSpeak Connection

Ang MQTT ay isang i-publish / mag-subscribe ng arkitektura na pangunahing binuo upang ikonekta ang bandwidth at mga aparato na pinipigilan ng kuryente sa mga wireless network. Ito ay isang simple at magaan na protokol na tumatakbo sa mga socket ng TCP / IP o WebSockets. Ang MQTT sa WebSockets ay maaaring ma-secure sa SSL. Nagbibigay-daan ang arkitektura ng pag-publish / pag-subscribe ng mga mensahe na maitulak sa mga aparato ng client nang hindi kinakailangan ng aparato na patuloy na i-poll ang server.

Ang MQTT broker ay ang sentral na punto ng komunikasyon, at ito ang namamahala sa pagpapadala ng lahat ng mga mensahe sa pagitan ng mga nagpadala at ng mga tamang tagatanggap. Ang isang kliyente ay anumang aparato na kumokonekta sa broker at maaaring mag-publish o mag-subscribe sa mga paksa upang ma-access ang impormasyon. Ang isang paksa ay naglalaman ng impormasyon sa pagruruta para sa broker. Ang bawat kliyente na nais magpadala ng mga mensahe ay inilalathala ang mga ito sa isang tiyak na paksa, at ang bawat kliyente na nais makatanggap ng mga mensahe ay nag-subscribe sa isang tiyak na paksa. Naghahatid ang broker ng lahat ng mga mensahe na may pagtutugma na paksa sa mga naaangkop na kliyente.

Ang ThingSpeak ™ ay mayroong isang MQTT broker sa URL mqtt.thingspeak.com at port 1883. Sinusuportahan ng ThingSpeak broker ang parehong MQTT publish at MQTT subscribe.

Sa aming kaso, gagamitin namin ang: MQTT I-publish

Inilalarawan ng pigura ang istraktura ng paksa. Kinakailangan ang Isulat ang API Key upang mai-publish. Kinikilala ng broker ang isang tamang CONNECTrequest sa CONNACK.

Sinusuportahan ang MQTT protocol sa isang built-in na aklatan sa mga binary ng Micropython - maaaring magamit ang protokol na ito magpadala ng data mula sa iyong ESP8266, sa paglipas ng WIFI, sa isang libreng cloud database.

Gamitin natin ang umqtt.simple library:

mula sa umqtt.simple import MQTTClient

At alam ang aming SERVER ID, posible na lumikha ng aming MQTT client object:

SERVER = "mqtt.thingspeak.com"

client = MQTTClient ("umqtt_client", SERVER)

Ngayon, nasa kamay ang iyong mga kredensyal na ThingSpeak:

CHANNEL_ID = "IYONG CHANNEL ID"

WRITE_API_KEY = "IYONG SUSI DITO"

Lumikha tayo ng aming "Paksa" ng MQTT:

paksa = "mga channel /" + CHANNEL_ID + "/ i-publish /" + WRITE_API_KEY

Makuha natin ang aming data na maipadala sa ThingSpeak IoT Service, gamit ang nilikha na pag-andar at iugnay ang tugon nito sa mga tukoy na variable ng data:

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

Sa mga variable na na-update, makakalikha kami ng aming "MQTT Payload":

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

At yun lang! Handa kaming magpadala ng data sa ThinsSpeak, simpleng paggamit ng 3 mga linya ng code sa ibaba:

client.connect ()

client.publish (paksa, payload) client.disconnect ()

Ngayon, kung pupunta ka sa iyong pahina ng channel (tulad ng minahan sa itaas) makikita mo na ang bawat isa sa 5 mga patlang ay magkakaroon ng data na nauugnay sa iyong mga sensor.

Hakbang 10: Sensor Data Logger

Ngayon, na alam natin na sa ilang mga linya lamang ng code posible na mag-upload ng data sa isang serbisyo ng IoT, gumawa tayo ng isang loop function upang awtomatiko itong gawin sa isang regular na agwat ng oras (katulad ng nagawa natin sa "Lokal na data ").

Gamit ang parehong variable (PUB_TIME_SEC), na idineklara dati, isang simpleng pangunahing pagpapaandar upang patuloy na makuha ang data, ang pag-log sa kanila sa aming channel ay:

habang Totoo:

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 (paksa, payload) client.disconnect () time.s Sleep (PUB_TIME_SEC)

Tandaan na ang "payload" lamang ang dapat na ma-update, sa sandaling ang "paksa" ay nauugnay sa aming kredensyal sa channel at hindi magbabago.

Naghahanap para sa iyong pahina ng channel na ThingSpeak, mapapansin mo na ang data ay patuloy na maglo-load sa bawat patlang. Maaari mong takpan ang LDR, ilagay ang iyong kamay sa mga sensor ng temp / hum, pindutin ang pindutan, atbp at tingnan kung paano awtomatikong "mag-log" ang channel sa mga data na iyon para sa pagtatasa sa hinaharap.

Karaniwan, para sa Pag-log sa Data, dapat naming subukang gumamit ng mas kaunting lakas hangga't maaari, sa gayon, hindi namin gagamitin ang LED o ipakita nang lokal. Gayundin, karaniwan ito sa mga aparato ng ESP, ilagay ang mga ito sa "malalim na pagtulog", kung saan ang microprocessor ay nasa estado ng minimum na enerhiya hanggang sa oras na makuha ang data at ipadala ang mga ito sa IoT platform.

Ngunit, sa sandaling narito ang ideya ay natututo, isama rin natin ang display at LED tulad ng ginawa natin dati. Ang paggawa nito, ang aming "logger" function ay magiging:

habang 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) client.connect () client.publish (paksa, payload) client.disconnect () time.s Sleep (PUB_TIME_SEC) blinkLed (3) displayClear ()

Ang kumpletong script ng microPython ay matatagpuan dito: dataLoggerTS_EXT.py at ang Jupyter notebook na ginamit para sa pagpapaunlad ay matatagpuan din dito: IoT ThingSpeak Data Logger EXT.ipynb.

Upang mai-upload ang script sa ESP, sa iyong terminal gamitin ang utos:

sapat na ilagay ang dataLoggerTS.py /main.py

At pindutin ang pindutan ng pag-reset ng ESP. Magkakaroon ka ng pagkuha ng data ng ESP at mai-log ang mga ito sa ThingSpeak.com hanggang sa ibaba ay pinananatiling pinindot (hintaying kumislap ng 3 beses ang LED at patayin ang OLED).

Hakbang 11: Ang ThingView App

Ang data na naka-log ay maaaring makita nang direkta sa ThingSpeak.com site o sa pamamagitan ng isang APP, halimbawa, ThingsView!

Ang ThingView ay isang APP na binuo ng CINETICA, na nagbibigay-daan sa iyo upang mailarawan ang iyong mga ThingSpeak channel sa isang madaling paraan, ipasok lamang ang channel ID at handa ka nang pumunta.

Para sa mga pampublikong channel, igagalang ng application ang iyong mga setting ng windows: kulay, orasan, uri ng tsart at ang bilang ng mga resulta. Sinusuportahan ng kasalukuyang bersyon ang mga tsart ng linya at haligi, ang mga tsart ng spline ay ipinapakita bilang mga tsart ng linya.

Para sa mga pribadong channel, ipapakita ang data gamit ang mga default na setting, dahil walang paraan upang mabasa ang mga setting ng pribadong windows gamit ang API key lamang.

Ang ThingView APP ay maaaring ma-download para sa ANDROID at IPHONE.

Hakbang 12: Konklusyon

Tulad ng nakasanayan, inaasahan kong ang proyekto na ito ay maaaring makatulong sa iba na mahanap ang kanilang mga paraan sa kapanapanabik na mundo ng electronics!

Para sa mga detalye at pangwakas na code, mangyaring bisitahin ang aking deposito sa GitHub: IoT_TS_MQTT

Para sa higit pang mga proyekto, mangyaring bisitahin ang aking blog: MJRoBot.org

Saludos mula sa timog ng mundo!

Kita tayo sa susunod kong turo!

Salamat, Marcelo