Легкость в использовании Интернета вещей: ESP-MicroPython-MQTT-ThingSpeak: 12 шагов

2024 Автор: John Day | [email protected]. Последнее изменение: 2024-01-30 11:51

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

Теперь, в этом руководстве с использованием протокола MQTT, мы получим все захваченные данные, отправив их в службу IoT, ThingSpeak.com и в мобильное приложение (Thingsview), где мы сможем регистрировать данные и играть с ними.

Вот блок-схема нашего проекта:

Шаг 1: BoM - Спецификация материалов

1. NodeMCU - 8,39 доллара США
2. Датчик температуры и относительной влажности DHT22 - 9,95 долларов США.
3. Водонепроницаемый датчик температуры DS18B20 - 5,95 долларов США.
4. OLED-дисплей SSD1366 - 8,99 долларов США (опционально)
5. LDR (1x)
6. Светодиоды (1x) (опционально)
7. Кнопка (1x)
8. Резистор 4K7 Ом (2х)
9. Резистор 10 кОм (1x)
10. Резистор 220 Ом (1x)

Шаг 2: Hw

Hw, который мы будем здесь использовать, в основном тот же, что и в учебнике: Micropython на ESP с использованием Jupyter. Обращайтесь к нему для всех подключений HW.

Исключением является сервопривод, который мы не будем использовать в этом проекте.

Выше вы можете увидеть полную версию HW. Подключите устройства, как показано на рисунке.

Шаг 3: Micropython, REPL, Jupyter

На вашем устройстве ESP должен быть загружен интерпретатор Micropython. После загрузки вы должны запрограммировать свой 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 () return dht22.temperature (), dht22.humidity () Проверить функцию DHT

печать (readDht ())

Результат должен быть например:

(17.7, 43.4)

B. DS18B20 (внешняя температура)

Установим библиотеки и создадим объект:

импортный однопроводной, ds18x20

время импорта # Определите, к какому выводу будет подключено 1-проводное устройство ==> контакт 2 (D4) dat = Pin (2) # создайте объект onewire 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.

То же, что и раньше:

# импорт библиотеки

from machine import ADC # Определить объект adc = ADC (0) Простая функция: adc.read () может использоваться для чтения значения АЦП. Но помните, что внутренний АЦП будет преобразовывать напряжения от 0 до 3,3 В в соответствующие цифровые значения, изменяющиеся от 0 до 1023. Как только нас интересует «Яркость», мы будем рассматривать Максимальный свет как максимальное значение, полученное датчиком (в моем случае case 900) и минимальный свет, который в моем случае равен 40. Имея эти значения, мы можем «отобразить» значение от 40 до 900 в диапазоне от 0 до 100% яркости. Для этого мы создадим новую функцию

def readLdr ():

lumPerct = (adc.read () - 40) * (10/86) # преобразовать в процент ("карта") return round (lumPerct)

Вы должны протестировать функцию с помощью print (readLDR ()). Результат должен быть целым числом от 0 до 100.

D. Кнопка (цифровой вход)

Здесь мы используем кнопку в качестве цифрового датчика, но это может быть «эхо» исполнительного механизма (например, насоса, который был включен / выключен).

# определите контакт 13 как вход и активируйте внутренний подтягивающий резистор:

button = Pin (13, Pin. IN, Pin. PULL_UP) # Функция для чтения состояния кнопки: def readBut (): return button.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

from machine import 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 () # отображать данные с помощью функции 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 как выход led = Pin (0, Pin. OUT) # DHT from dht import DHT22 dht22 = DHT22 (Pin (12)) # Функция для чтения DHT def readDht (): dht22.measure () return dht22.temperature (), dht22.humidity () # DS18B20 import onewire, ds18x20 # Определите, к какому выводу будет подключено 1-проводное устройство ==> вывод 2 (D4) dat = Pin (2) # Создайте однопроводной object ds = ds18x20. DS18X20 (onewire. OneWire (dat)) # сканирование устройств на шине sensor = ds.scan () # функция для чтения DS18B20 def readDs (): ds.convert_temp () time.sleep_ms (750) return round (ds.read_temp (sizes [0]), 1) # LDR из машинного импорта ADC # Определить объект adc = ADC (0) # функция для чтения яркости def readLdr (): lumPerct = (adc.read () - 40) * (10/86) # преобразовать в проценты ("map") return round (lumPerct) # определить вывод 13 как вход и активировать внутренний подтягивающий резистор: button = Pin (13, Pin. IN, Pin. PULL_UP) # Функция для чтения состояния кнопки: def readBut (): return button.value () # Функция для чтения всех данных: def cole ctData (): temp, hum, = readDht () extTemp = readDs () lum = readLdr () butSts = readBut () return 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) и, например, до тех пор, пока мы не нажмем кнопку:

# цикл получения данных до нажатия кнопки

в то время как 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): for i in range (0, num): led.on () sleep (0.5) led.off () сон (0,5)

Итак, теперь мы можем переписать нашу функцию main ():

пока 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 к локальному Wi-Fi

Сетевой модуль используется для настройки 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 (): print ('подключение к сети …') wlan.connect (WiFi_SSID, WiFi_SSID) без wlan.isconnected (): пройти 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-экране. Теперь пора посмотреть, как отправить эти данные на платформу Интернета вещей, ThingSpeak.

Давай начнем!

Во-первых, у вас должна быть учетная запись на ThinkSpeak.com. Затем следуйте инструкциям по созданию канала и запишите свой идентификатор канала и ключ 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 записи необходим для публикации. Посредник подтверждает правильный запрос CONNECT с помощью CONNACK.

Протокол MQTT поддерживается встроенной библиотекой в двоичных файлах Micropython - этот протокол можно использовать для отправки данных с вашего ESP8266 через WIFI в бесплатную облачную базу данных.

Воспользуемся библиотекой umqtt.simple:

из umqtt.simple import MQTTClient

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

СЕРВЕР = "mqtt.thingspeak.com"

client = MQTTClient ("umqtt_client", СЕРВЕР)

Теперь, имея под рукой учетные данные ThingSpeak:

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

WRITE_API_KEY = "ВАШ КЛЮЧ ЗДЕСЬ"

Давайте создадим нашу MQTT «Тема»:

topic = "каналы /" + CHANNEL_ID + "/ publish /" + WRITE_API_KEY

Давайте с помощью созданной функции отправим наши данные в ThingSpeak IoT Service и свяжем ее ответ с конкретными переменными данных:

темп, шум, extTemp, lum, butSts = colectData ()

После обновления этих переменных мы можем создать нашу «полезную нагрузку MQTT»:

payload = "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: Регистратор данных датчика

Теперь, когда мы знаем, что с помощью всего нескольких строк кода можно загружать данные в службу Интернета вещей, давайте создадим функцию цикла, которая будет делать это автоматически через определенный интервал времени (аналогично тому, что мы сделали с «Локальными данными» ).

Используя ту же переменную (PUB_TIME_SEC), объявленную ранее, простая основная функция для непрерывного сбора данных и их регистрации на нашем канале будет:

в то время как True:

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.

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

пока 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 (тема, полезная нагрузка) 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 до тех пор, пока нижняя часть не будет нажата (подождите, пока светодиодный индикатор не мигнет 3 раза и не выключится OLED).

Шаг 11: приложение ThingView

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

ThingView - это приложение, разработанное CINETICA, которое позволяет вам легко визуализировать ваши каналы ThingSpeak, просто введите идентификатор канала, и вы готовы к работе.

Для общедоступных каналов приложение будет учитывать ваши настройки Windows: цвет, шкалу времени, тип диаграммы и количество результатов. Текущая версия поддерживает линейные и столбчатые диаграммы, сплайн-диаграммы отображаются в виде линейных диаграмм.

Для частных каналов данные будут отображаться с использованием настроек по умолчанию, поскольку нет возможности прочитать настройки частных окон только с помощью ключа API.

Приложение ThingView можно загрузить для ANDROID и IPHONE.

Шаг 12: Заключение

Как всегда, я надеюсь, что этот проект поможет другим найти свой путь в захватывающий мир электроники!

Для получения подробной информации и окончательного кода посетите мой депозитарий GitHub: IoT_TS_MQTT

Чтобы узнать больше о проектах, посетите мой блог: MJRoBot.org

Салудо с юга мира!

Увидимся в моем следующем инструктаже!

Спасибо, Марсело