IoT Made Ease: ESP-MicroPython-MQTT-Thing Говорете: 12 стъпки

2024 Автор: John Day | [email protected]. Последно модифициран: 2024-01-30 07:52

В предишния ми урок, MicroPython на ESP с помощта на Jupyter, научихме как да инсталираме и стартираме MicroPython на ESP устройство. Използвайки Jupyter Notebook като среда за разработка, ние също се научихме да четем от сензори (температура, влажност и осветеност). Използваме няколко комуникационни протокола и методи, аналогови, цифрови, 1-проводни и I2C, този последен за показване на нашите заснети данни на OLED дисплей.

Сега, в този урок, използващ протокол MQTT, ще получим всички заснети данни, изпращайки ги до услуга на IoT, ThingSpeak.com и до мобилно приложение (Thingsview), където можем да влезем и да играем с данни.

Ето блоковата диаграма на нашия проект:

Стъпка 1: BoM - материална сметка

1. NodeMCU - 8,39 щ.д.
2. DHT22 Сензор за температура и относителна влажност - 9,95 USD
3. DS18B20 Водоустойчив температурен сензор - 5,95 USD
4. OLED дисплей SSD1366- USD 8,99 (по избор)
5. LDR (1x)
6. Светодиоди (1x) (по избор)
7. Бутон (1x)
8. Резистор 4K7 ohm (2x)
9. Резистор 10K ohm (1x)
10. Резистор 220 ома (1x)

Стъпка 2: Hw

Hw, който ще използваме тук, е същият, използван в урока: Micropython на ESP Използване на Jupyter. Обърнете се към него за всички HW връзки.

Изключението е Servo, че няма да бъдем използвани в този проект.

По -горе можете да видите пълния HW. Свържете устройствата, както е показано там.

Стъпка 3: Micropython, REPL, Jupyter

Трябва да имате зареден преводач на Micropython на вашето ESP устройство. След като се зареди, трябва да програмирате вашия ESP, като използвате някой от наличните начини/IDE, като:

• REPL
• Бележник Jupyter
• Му
• ESPCut (само за Windows)
• … и т.н.

В моя урок, Micropython на ESP С помощта на Jupyter, описах подробно как да изтегля и инсталирам интерпретатор на MicroPython, ESPTool за управление на ESP устройства и как да използвам Jupyter Notebook като среда за разработка. Чувствайте се свободни да използвате това, което ви е по -удобно.

Обикновено правя цялото развитие на Jupyter Notebook и след като получа окончателния код, ги копирам в Geany и го зареждам на моя ESP с помощта на Ampy.

Стъпка 4: Сензори

Нека инсталираме библиотеките, определим GPIO, създадем обекти, функции за всички сензори поотделно:

A. DHT (температура и влажност)

Нека инсталираме DHT библиотеката и да създадем обект:

от dht внос DHT22

от машина за внос Pin dht22 = DHT22 (Pin (12))

Сега създайте функция за четене на DHT сензор:

def readDht ():

dht22.measure () връщане dht22.temperature (), dht22.humidity () Тествайте функцията DHT

печат (readDht ())

Резултатът трябва да бъде например:

(17.7, 43.4)

Б. DS18B20 (Външна температура)

Нека инсталираме библиотеките и създадем обект:

внос onewire, ds18x20

време за импортиране # Определете кой щифт ще бъде свързано 1-проводното устройство ==> пин 2 (D4) dat = Пин (2) # създайте обект с едножична връзка ds = ds18x20. DS18X20 (onewire. OneWire (dat)) Сканиране за устройства на бу

сензори = ds.scan ()

print ('намерени устройства:', сензори)

Отпечатаният резултат всъщност не е важен, това, от което се нуждаем, е първият открит сензор: сензори [0]. И сега можем да изградим функция за четене на сензорни данни:

def readDs ():

ds.convert_temp () time.sleep_ms (750) връщане ds.read_temp (сензори [0])

Винаги е важно да тествате сензора, като използвате създадената функция

печат (readDs ()) Ако получите стойност на температурата, вашият код е правилен

17.5

C. LDR (осветеност)

LDR ще използва аналоговия щифт на нашия ESP (той е само един в случая на ESP8266 и няколко към ESP32).

Вижте моя урок за ESP32 за подробности.

Същото като преди:

# библиотека за импортиране

от машинен импорт ADC # Определете обект adc = ADC (0) Една проста функция: adc.read () може да се използва за четене на стойността на ADC. Но не забравяйте, че вътрешният ADC ще преобразува напрежения между 0 и 3.3V в съответните цифрови стойности, вариращи от 0 до 1023. След като се заинтересуваме от „Luminosity“, ще считаме Max light за максималната улавена стойност от сензора (в моя случай 900) и минимална светлина, която в моя случай е 40. Като имаме тези стойности, можем да „картографираме“стойността от 40 до 900 в 0 до 100% светене. За целта ще създадем нова функция

def readLdr ():

lumPerct = (adc.read ()-40)*(10/86) # преобразуване в проценти ("карта") връщане на кръг (lumPerct)

Трябва да тествате функцията с помощта на print (readLDR ()). Резултатът трябва да бъде цяло число между o и 100.

D. Бутон (цифров вход)

Тук използваме бутон като цифров сензор, но това може да бъде "ехо" на задвижващ механизъм (помпа, която беше включена/изключена например).

# дефинирайте щифт 13 като вход и активирайте вътрешен издърпващ се резистор:

button = Pin (13, Pin. IN, Pin. PULL_UP) # Функция за четене на състоянието на бутона: def readBut (): бутон за връщане.value ()

Можете да тествате бутона, който чете функцията print (readBut ()). Без натискане на резултата трябва да бъде "1". Натискането на бутона, резултатът трябва да бъде "0"

Стъпка 5: Заснемане и локално показване на всички сензорни данни

Сега, след като създадохме по една функция за всеки сензор, нека създадем последната, която ще ги чете едновременно:

def colectData ():

temp, hum, = readDht () extTemp = readDs () lum = readLdr () butSts = readBut () връщане temp, hum, extTemp, lum, butSts Сега, ако използвате

печат (colectData ())

Ще доведе до кортеж, който включва всички заснети данни от сензори:

(17.4, 45.2, 17.3125, 103, 1)

Също така по избор можем да покажем тези данни на локален дисплей:

# импортирайте библиотека и създайте обект i2c

от машинен внос I2C i2c = I2C (scl = Pin (5), sda = Pin (4)) # библиотека за импортиране и създаване на обект oled внос ssd1306 i2c = I2C (scl = Pin (5), sda = Pin (4)) oled = ssd1306. SSD1306_I2C (128, 64, i2c, 0x3c) # създайте функция: 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 () # показване на данни с помощта на функцията displayData (temp, hum, extTemp, lum, butSts)

Като опция ще включа и светодиода, който да свети, когато започнем да четем сензори, като ще изгасне, след като се покажат тези данни. Това ще помогне да се потвърди, че програмата работи, когато ESP е изключен от компютъра и работи автоматично.

Така че основната функция ще бъде:

# Основна функция за четене на всички сензори

def main (): # показване на данни с функция led.on () temp, hum, extTemp, lum, butSts = colectData () displayData (temp, hum, extTemp, lum, butSts) led.off ()

Така че, изпълнявайки main (), ще получим сензорните данни, показани на OLED, както е показано на снимката.

Стъпка 6: Стартирайте кода на локалната станция при стартиране на ESP

Можем да имаме всичко, което е разработено досега, върху един файл, за да бъде изпълнен от нашия ESP.

Нека отворим всеки текстов редактор и прехвърлим целия код:

# импортиране на общи библиотеки

от машинно импортиране Време за импортиране на пин # дефинирайте пин 0 като изходен светодиод = Pin (0, Pin. OUT) # DHT от dht внос DHT22 dht22 = DHT22 (Pin (12)) # Функция за четене на DHT def readDht (): dht22.measure () връщане dht22.temperature (), dht22.humidity () # DS18B20 импортиране на едножичен, ds18x20 # Определете кой щифт ще бъде свързано 1-проводното устройство ==> пин 2 (D4) dat = Пин (2) # Създайте едножичен обект ds = ds18x20. DS18X20 (onewire. OneWire (dat)) # сканиране за устройства на сензорите на шината = ds.scan () # функция за четене на DS18B20 def readDs (): ds.convert_temp () time.sleep_ms (750) return кръгла (ds.read_temp (сензори [0]), 1) # LDR от машинен импорт ADC # Определете обект adc = ADC (0) # функция за четене на осветеност def readLdr (): lumPerct = (adc.read ()-40) *(10/86) # преобразуване в проценти ("карта") връщане на кръг (lumPerct) # дефиниране на щифт 13 като вход и активиране на вътрешен издърпващ се резистор: бутон = Pin (13, Pin. IN, Pin. PULL_UP) # Функция за четене на състоянието на бутона: def readBut (): бутон за връщане.value () # Функция за четене на всички данни: def cole ctData (): temp, hum, = readDht () extTemp = readDs () lum = readLdr () butSts = readBut () връщане temp, hum, extTemp, lum, butSts # библиотека за импортиране и създаване на обект i2c от машинен внос I2C i2c = I2C (scl = Pin (5), sda = Pin (4)) # библиотека за импортиране и създаване на обект oled import ssd1306 i2c = I2C (scl = Pin (5), sda = Pin (4)) oled = ssd1306. SSD1306_I2C (128, 64, i2c, 0x3c) # създайте функция: 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 () # Основна функция за четене на всички сензори def main (): # показване на данни с функция led.on () temp, hum, extTemp, lum, butSts = colectData () displayData (temp, hum, extTemp, lum, butSts) led.off () '' ''- ----- изпълни основната функция -------- '' 'main ()

Запазете го, например като localData.py.

За да стартирате този код директно на вашия терминал, ще ви е необходим Ampy.

Първо, на терминала, нека информираме Ampy за нашия сериен порт:

експортиране на AMPY_PORT =/dev/tty. SLAB_USBtoUART

Сега можем да видим файловете, които се намират в нашата основна директория на ESP:

ampy ls

В отговор ще получим boot.py, това е първият файл, който ще се изпълнява в системата.

Сега, нека използваме Ampy, за да заредим нашия python Script LocalData.py като /main.py, така че скриптът ще се изпълнява веднага след зареждането:

ampy постави localData.py /main /py

Ако сега използваме командата amp ls, ще видите 2 файла вътре в ESP.: boot.py и main.py

Нулирането на вашия ESP ще накара програмата localData.py да се стартира автоматично, показвайки сензорните данни на дисплея.

Горният екран за печат на терминала показва какво сме направили.

С горния код дисплеят ще се показва само веднъж, но можем да дефинираме цикъл на функцията main (), която ще показва данни за всеки определен интервал от време (PUB_TIME_SEC) и например, докато не натиснем бутона:

# цикъл за получаване на данни до натискане на бутона

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

Променливата PUB_TIME_SEC трябва да бъде декларирана до момента, в който искате вашите проби.

За да подобрим повече нашия код, би било добре да информираме, че ще излезем от цикъла, за това ще дефинираме 2 нови общи функции, една за изчистване на дисплея и друга за мигане на светодиода определен брой пъти.

# Ясен дисплей:

def displayClear (): oled.fill (0) oled.show () # създаване на мигаща функция def blinkLed (num): за i в обхват (0, num): led.on () sleep (0.5) led.off () сън (0,5)

Така че сега можем да пренапишем нашата функция main ():

while button.value ():

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

Окончателният код може да бъде изтеглен от моя GitHub: localData.py, а също и от Jupyter Notebook, използван за разработване на пълен код: Jupyter Local Data Development.

Стъпка 7: Свързване на ESP към Local WiFi

Мрежовият модул се използва за конфигуриране на WiFi връзката. Има два WiFi интерфейса, един за станцията (когато ESP8266 се свързва с рутер) и един за точката за достъп (за други устройства за свързване към ESP8266). Тук нашият ESP ще бъде свързан към локална мрежа. Нека да извикаме библиотеката и да определим нашите мрежови идентификационни данни:

мрежа за внос

WiFi_SSID = "ВАШИЯТ SSID" WiFi_PASS = "ВАШАТА ПАРОЛА"

Функцията по -долу може да се използва за свързване на ESP към вашата локална мрежа:

def do_connect ():

wlan = network. WLAN (network. STA_IF) wlan.active (True), ако не wlan.isconnected (): печат („свързване към мрежа …“) wlan.connect (WiFi_SSID, WiFi_SSID), докато не е wlan.isconnected (): pass print ('мрежова конфигурация:', wlan.ifconfig ())

Изпълнявайки функцията, в резултат на това можете да получите IP адреса:

do_connect ()

Резултатът ще бъде:

мрежова конфигурация: ('10.0.1.2 ',' 255.255.255.0 ', '10.0.1.1', '10.0.1.1 ')

В моя случай 10.0.1.2 е IP адресът на ESP.

Стъпка 8: ThingSpeak

В този момент научихме как да улавяме данни от всички сензори, показвайки ги на нашия OLED. Сега е време да видим как да изпратим тези данни до IoT платформа, ThingSpeak.

Нека да започнем!

Първо, трябва да имате акаунт в ThinkSpeak.com. След това следвайте инструкциите, за да създадете канал и вземете под внимание идентификатора на канала си и API API за запис.

По -горе можете да видите 5 -те полета, които ще бъдат използвани в нашия канал.

Стъпка 9: MQTT протокол и ThingSpeak връзка

MQTT е архитектура за публикуване/абониране, разработена предимно за свързване на честотна лента и устройства с ограничена мощност през безжични мрежи. Това е прост и лек протокол, който работи през TCP/IP сокети или WebSockets. MQTT през WebSockets може да бъде защитен със SSL. Архитектурата за публикуване/абониране позволява съобщенията да се изпращат до клиентските устройства, без устройството да се нуждае от непрекъснато анкетиране на сървъра.

Брокерът MQTT е централната точка за комуникация и отговаря за изпращането на всички съобщения между изпращачите и законните получатели. Клиент е всяко устройство, което се свързва с брокера и може да публикува или да се абонира за теми за достъп до информацията. Тема съдържа информация за маршрутизиране на брокера. Всеки клиент, който иска да изпраща съобщения, ги публикува в определена тема и всеки клиент, който иска да получава съобщения, се абонира за определена тема. Брокерът доставя всички съобщения със съответстващата тема на съответните клиенти.

ThingSpeak ™ има MQTT брокер на URL адреса mqtt.thingspeak.com и порт 1883. Брокерът ThingSpeak поддържа както MQTT публикуване, така и MQTT абониране.

В нашия случай ще използваме: MQTT Publish

Фигурата описва структурата на темата. API API ключът е необходим за публикуване. Брокерът потвърждава правилна заявка за CONNECT с CONNACK.

Протоколът MQTT се поддържа във вградена библиотека в двоичните файлове на Micropython-този протокол може да се използва за изпращане на данни от вашия ESP8266 през WIFI към безплатна база данни в облак.

Нека използваме библиотеката umqtt.simple:

от umqtt.simple импортиране на MQTTClient

Познавайки нашия SERVER ID, е възможно да създадем нашия клиентски обект MQTT:

SERVER = "mqtt.thingspeak.com"

клиент = MQTTClient ("umqtt_client", SERVER)

Сега, разполагайки с вашите идентификационни данни за ThingSpeak:

CHANNEL_ID = "ИДЕНТОРА НА ВАШИЯ КАНАЛ"

WRITE_API_KEY = "ВАШИЯТ КЛЮЧ ТУК"

Нека създадем нашата „Тема“на MQTT:

topic = "канали/" + CHANNEL_ID + "/публикуване/" + WRITE_API_KEY

Нека да изпратим нашите данни до услугата ThingSpeak IoT, като използваме създадената функция и свържем нейния отговор с конкретни променливи от данни:

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

С актуализирането на тези променливи можем да създадем нашия „MQTT полезен товар“:

полезен товар = "field1 ="+str (temp)+"& field2 ="+str (hum)+"& field3 ="+str (extTemp)+"& field4 ="+str (lum)+"& field5 ="+str (butSts)

И това е! Готови сме да изпращаме данни до ThinsSpeak, просто като използваме 3 -те реда код по -долу:

client.connect ()

client.publish (тема, полезен товар) client.disconnect ()

Сега, ако отидете на страницата на канала си (както моята по -горе), ще видите, че всяко едно от 5 -те полета ще има данни, свързани с вашите сензори.

Стъпка 10: Регистратор на сензорни данни

Сега, когато знаем, че само с няколко реда код е възможно да качваме данни в услуга на IoT, нека създадем циклична функция, която да го прави автоматично през редовен интервал от време (подобно на това, което направихме с „Локални данни ).

Използвайки същата променлива (PUB_TIME_SEC), декларирана по -рано, проста основна функция за непрекъснато улавяне на данни, регистрирането им в нашия канал ще бъде:

докато е вярно:

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 (тема, полезен товар) client.disconnect () time.sleep (PUB_TIME_SEC)

Имайте предвид, че трябва да се актуализира само „полезният товар“, след като „темата“е свързана с идентификационните данни на канала ни и няма да се промени.

Търсейки страницата на канала на ThingSpeak, ще забележите, че данните ще се зареждат непрекъснато във всяко поле. Можете да покриете LDR, да сложите ръка на сензори за темп/шум, да натиснете бутона и т.н. и да видите как каналът автоматично ще „регистрира“тези данни за бъдещ анализ.

Обикновено, за регистриране на данни, трябва да се опитваме да използваме възможно най -малко енергия, така че не бихме използвали светодиода или дисплея локално. Също така, това е често срещано при ESP устройствата, поставяйте ги в "дълбок сън", където микропроцесорът ще бъде в състояние на минимална енергия, докато дойде време за улавяне на данни и изпращането им до платформата на IoT.

Но след като тук идеята се учи, нека също така включим дисплея и светодиода, както направихме преди. Правейки това, нашата функция "регистратор" ще бъде:

while 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) клиент.connect () client.publish (тема, полезен товар) client.disconnect () time.sleep (PUB_TIME_SEC) blinkLed (3) displayClear ()

Пълният скрипт на microPython може да бъде намерен тук: dataLoggerTS_EXT.py и тетрадката Jupyter, използвана за разработка, също могат да бъдат намерени тук: IoT ThingSpeak Data Logger EXT.ipynb.

За да качите скрипта на ESP, на вашия терминал използвайте командата:

ampy постави dataLoggerTS.py /main.py

И натиснете бутона ESP - нулиране. Ще имате ESP да улавя данни и да ги регистрира на ThingSpeak.com, докато дъното не се държи натиснато (изчакайте LED да мига 3 пъти и OLED да се изключи).

Стъпка 11: Приложението ThingView

Регистрираните данни могат да се видят директно на сайта ThingSpeak.com или чрез приложение, например ThingsView!

ThingView е приложение, разработено от CINETICA, което ви позволява да визуализирате вашите канали ThingSpeak по лесен начин, просто въведете идентификатора на канала и сте готови за работа.

За публични канали приложението ще спазва настройките на вашия прозорец: цвят, времеви диапазон, тип диаграма и броя на резултатите. Текущата версия поддържа линейни и колонови диаграми, сплайн диаграмите се показват като линейни диаграми.

За частни канали данните ще се показват с настройките по подразбиране, тъй като няма начин да се четат настройките на частните прозорци само с API ключ.

Приложението ThingView може да бъде изтеглено за ANDROID и IPHONE.

Стъпка 12: Заключение

Както винаги, надявам се този проект да помогне на другите да намерят своя път във вълнуващия свят на електрониката!

За подробности и окончателен код, моля, посетете моя депозитар на GitHub: IoT_TS_MQTT

За повече проекти, моля, посетете моя блог: MJRoBot.org

Поздрави от юга на света!

Ще се видим в следващата ми инструкция!

Благодаря ти, Марсело