Łatwość IoT: ESP-MicroPython-MQTT-ThingSpeak: 12 kroków

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:30

W moim poprzednim samouczku, MicroPython na ESP przy użyciu Jupyter, dowiedzieliśmy się, jak zainstalować i uruchomić MicroPython na urządzeniu ESP. Używając Jupyter Notebook jako naszego środowiska programistycznego, nauczyliśmy się również czytać z czujników (temperatury, wilgotności i jasności). Używamy kilku protokołów i metod komunikacji, analogowych, cyfrowych, 1-Wire i I2C, ta ostatnia do wyświetlania przechwyconych dane na wyświetlaczu OLED.

Teraz, w tym samouczku wykorzystującym protokół MQTT, otrzymamy wszystkie przechwycone dane, wysyłając je do usługi IoT, ThingSpeak.com oraz do aplikacji mobilnej (Thingsview), gdzie możemy logować się i bawić się danymi.

Tutaj schemat blokowy naszego projektu:

Krok 1: BoM - zestawienie materiałów

1. NodeMCU - 8,39 USD
2. Czujnik temperatury i wilgotności względnej DHT22 - 9,95 USD
3. Wodoodporny czujnik temperatury DS18B20 - 5,95 USD
4. Wyświetlacz OLED SSD1366 – 8,99 USD (opcjonalnie)
5. LDR (1x)
6. Diody LED (1x) (opcjonalnie)
7. Przycisk (1x)
8. Rezystor 4K7 omów (2x)
9. Rezystor 10K omów (1x)
10. Rezystor 220 omów (1x)

Krok 2: Hw

Hw, którego tutaj użyjemy, jest zasadniczo taki sam, jak w samouczku: Micropython na ESP przy użyciu Jupyter. Odwołaj się do wszystkich połączeń sprzętowych.

Wyjątkiem jest Servo, którego nie będziemy używać w tym projekcie.

Powyżej możesz zobaczyć pełne HW. Podłącz urządzenia, jak pokazano tam.

Krok 3: Micropython, REPL, Jupyter

Musisz mieć zainstalowany interpreter Micropython na swoim urządzeniu ESP. Po załadowaniu powinieneś zaprogramować ESP przy użyciu dowolnych dostępnych sposobów/IDE, takich jak:

• REPL
• Notatnik Jupytera
• Mu
• ESPcut (tylko Windows)
• …itp

W moim samouczku, Micropython na ESP Korzystanie z Jupyter, szczegółowo opisałem, jak pobrać i zainstalować interpreter MicroPython, ESPTool do zarządzania urządzeniami ESP i jak używać Jupyter Notebook jako środowiska programistycznego. Zapraszam do korzystania z tego, co jest dla Ciebie wygodniejsze.

Zwykle robię cały program na Jupyter Notebook, a kiedy otrzymam ostateczny kod, kopiuję go do Geany i ładuję na moim ESP za pomocą Ampy.

Krok 4: Czujniki

Zainstalujmy biblioteki, zdefiniujmy GPIO, stwórzmy obiekty, funkcje dla wszystkich czujników z osobna:

A. DHT (temperatura i wilgotność)

Zainstalujmy bibliotekę DHT i stwórzmy obiekt:

z importu dht DHT22

z importu maszyny Pin dht22 = DHT22(Pin(12))

Teraz utwórz funkcję odczytu czujnika DHT:

def przeczytajDht():

dht22.measure() return dht22.temperature(), dht22.humidity() Testuj funkcję DHT

drukuj (odczytajDht())

Wynik powinien być na przykład:

(17.7, 43.4)

B. DS18B20 (temperatura zewnętrzna)

Zainstalujmy biblioteki i stwórzmy obiekt:

importuj onewire, ds18x20

import time # Zdefiniuj, który pin będzie podłączony do urządzenia 1-wire ==> pin 2 (D4) dat = Pin(2) # utwórz obiekt onewire ds = ds18x20. DS18X20(onewire. OneWire(dat)) Skanuj w poszukiwaniu urządzeń w bu

czujniki = ds.skan()

print('znalezione urządzenia:', czujniki)

Wydrukowany wynik nie jest tak naprawdę ważny, potrzebny nam będzie pierwszy wykryty czujnik: sensory[0]. A teraz możemy zbudować funkcję odczytu danych z czujników:

def readDs():

ds.convert_temp() time.sleep_ms(750) return ds.read_temp(sensors[0])

Zawsze ważne jest, aby przetestować czujnik za pomocą utworzonej funkcji

print(odczytajDs()) Jeśli uzyskasz wartość temperatury, Twój kod jest poprawny

17.5

C. LDR (jasność)

LDR będzie wykorzystywał pin analogowy naszego ESP (w przypadku ESP8266 jest to tylko jeden, a w ESP32 kilka).

Zapoznaj się z moim samouczkiem ESP32, aby uzyskać szczegółowe informacje.

Tak samo jak wcześniej:

# importuj bibliotekę

z maszyny import ADC # Zdefiniuj obiekt aDC = ADC(0) Do odczytania wartości ADC można użyć prostej funkcji: adc.read(). Pamiętaj jednak, że wewnętrzny ADC przekształci napięcia z zakresu od 0 do 3,3 V w odpowiednie wartości cyfrowe, zmieniające się od 0 do 1023. Gdy już zainteresujemy się „Jasnością”, uznamy Max light za maksymalną wartość przechwyconą z czujnika (w moim przypadku 900) i minimalne światło, które w moim przypadku wynosi 40. Mając te wartości możemy "mapować" wartość od 40 do 900 w 0 do 100% jasności. W tym celu stworzymy nową funkcję

def przeczytajLdr():

lumPerct = (adc.read()-40)*(10/86) # konwersja w procentach ("mapa") return round(lumPerct)

Powinieneś przetestować funkcję używając print (readLDR()). Wynik powinien być liczbą całkowitą od o do 100.

D. Przycisk (wejście cyfrowe)

Tutaj używamy przycisku jako czujnika cyfrowego, ale może to być „echo” siłownika (na przykład pompa, która została włączona/wyłączona).

# zdefiniuj pin 13 jako wejście i aktywuj wewnętrzny rezystor podciągający:

button = Pin(13, Pin. IN, Pin. PULL_UP) # Funkcja odczytu stanu przycisku: def readBut(): return button.value()

Możesz przetestować przycisk czytający funkcję print(readBut()). Bez naciśnięcia wynik powinien wynosić „1”. Po naciśnięciu przycisku wynik powinien wynosić „0”

Krok 5: Przechwytywanie i wyświetlanie lokalnie wszystkich danych czujnika

Teraz, gdy stworzyliśmy jedną funkcję dla każdego czujnika, stwórzmy ostatnią, która odczyta je wszystkie jednocześnie:

def zbierajDane():

temp, hum, = readDht() extTemp = readDs() lum = readLdr() aleSts = readBut() return temp, hum, extTemp, lum, aleSts Teraz, jeśli używasz

print(collectData())

Spowoduje to powstanie krotki zawierającej wszystkie przechwycone dane z czujników:

(17.4, 45.2, 17.3125, 103, 1)

Możemy również opcjonalnie pokazać te dane na lokalnym wyświetlaczu:

# zaimportuj bibliotekę i utwórz obiekt i2c

z maszyny importuj I2C i2c = I2C(scl=Pin(5), sda=Pin(4)) # importuj bibliotekę i utwórz obiekt oled import ssd1306 i2c = I2C(scl=Pin(5), sda=Pin(4)) oled = ssd1306. SSD1306_I2C(128, 64, i2c, 0x3c) # utwórz funkcję: 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("Przycisk: " + str(aleSts), 0, 57) oled.show() # wyświetlanie danych za pomocą funkcji displayData(temp, hum, extTemp, lum, butSts)

Opcjonalnie dodam również diodę, która będzie się świecić, gdy zaczniemy odczytywać czujniki, a gaśnie po wyświetleniu tych danych. Pomoże to potwierdzić, że program działa, gdy ESP jest odłączony od komputera i działa automatycznie.

Tak więc „główną funkcją byłoby:

# Główna funkcja odczytu wszystkich czujników

def main(): # wyświetlanie danych za pomocą funkcji led.on() temp, hum, extTemp, lum, butSts = colectData() displayData(temp, hum, extTemp, lum, butSts) led.off()

Tak więc, wykonując main(), otrzymamy dane z czujnika wyświetlane na OLED, jak pokazano na rysunku.

Krok 6: Uruchamianie kodu stacji lokalnej podczas uruchamiania ESP

Wszystko, co do tej pory zostało opracowane, możemy mieć w jednym pliku do wykonania przez naszego ESP.

Otwórzmy dowolny edytor tekstu i wklejmy w nim cały kod:

# importuj biblioteki ogólne

z maszyny import Pin import time # zdefiniuj pin 0 jako wyjście led = Pin(0, Pin. OUT) # DHT z dht import DHT22 dht22 = DHT22(Pin(12)) # Funkcja odczytu DHT def readDht(): dht22.measure () return dht22.temperature(), dht22.humidity() # DS18B20 import onewire, ds18x20 # Określ, który pin będzie podłączony do urządzenia 1-wire ==> pin 2 (D4) dat = Pin(2) # Utwórz onewire obiekt ds = ds18x20. DS18X20(onewire. OneWire(dat)) # skanowanie w poszukiwaniu urządzeń na czujnikach magistrali = ds.scan() # funkcja odczytu DS18B20 def readDs(): ds.convert_temp() time.sleep_ms(750) return round(ds.read_temp(sensors[0]), 1) # LDR z maszyny zaimportuj ADC # Zdefiniuj obiekt adc = ADC(0) #funkcja odczytu jasności def readLdr(): lumPerct = (adc.read()-40) *(10/86) # przelicz procentowo ("mapa") return round(lumPerct) # zdefiniuj pin 13 jako wejście i aktywuj wewnętrzny rezystor podciągający: przycisk = Pin(13, Pin. IN, Pin. PULL_UP) # Funkcja odczytu stanu przycisku: def readBut(): return button.value() # Funkcja odczytu wszystkich danych: def cole ctData(): temp, hum, = readDht() extTemp = readDs() lum = readLdr() butSts = readBut() return temp, hum, extTemp, lum, butSts # importuj bibliotekę i twórz obiekt i2c z maszyny import I2C i2c = I2C(scl=Pin(5), sda=Pin(4)) # importuj bibliotekę i utwórz obiekt oled import ssd1306 i2c = I2C(scl=Pin(5), sda=Pin(4)) oled = ssd1306. SSD1306_I2C(128, 64, i2c, 0x3c) # utwórz funkcję: 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("Przycisk: " + str(butSts), 0, 57) oled.show() # Główna funkcja do odczytu wszystkich czujników def main(): # wyświetlanie danych za pomocą funkcji led.on() temp, hum, extTemp, lum, butSts = colectData() displayData(temp, hum, extTemp, lum, butSts) led.off() '''- ----- uruchom funkcję główną --------''' main()

Zapisz go, na przykład jako localData.py.

Aby uruchomić ten kod bezpośrednio na swoim terminalu, będziesz potrzebować Ampy.

Najpierw na Terminalu poinformujmy Ampy o naszym porcie szeregowym:

eksportuj AMPY_PORT=/dev/tty. SLAB_USBtoUART

Teraz możemy zobaczyć pliki znajdujące się w naszym katalogu głównym ESP:

duże ls

W odpowiedzi otrzymamy boot.py, czyli pierwszy plik, który będzie działał w systemie.

Teraz użyjmy Ampy, aby załadować nasz python Script LocalData.py jako /main.py, aby skrypt uruchomił się zaraz po uruchomieniu:

ampy umieścić localData.py /main/py

Jeśli użyjemy teraz polecenia amp ls, zobaczysz 2 pliki wewnątrz ESP.: boot.py i main.py

Zresetowanie ESP spowoduje, że program localData.py uruchomi się automatycznie, wyświetlając dane czujnika na wyświetlaczu.

Powyższy ekran drukowania Terminala pokazuje, co zrobiliśmy.

W powyższym kodzie, wyświetlacz pokaże się tylko raz, ale możemy zdefiniować pętlę na funkcji main(), która będzie wyświetlać dane w każdym zdefiniowanym przedziale czasu (PUB_TIME_SEC) i np. do momentu naciśnięcia przycisku:

# pętla pobierania danych do momentu naciśnięcia przycisku

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

Zmienna PUB_TIME_SEC musi być zadeklarowana do czasu, w którym chcesz otrzymać próbki.

Aby jeszcze bardziej ulepszyć nasz kod, dobrze byłoby poinformować, że wyjdziemy z pętli, w tym celu zdefiniujemy 2 nowe funkcje ogólne, jedną do czyszczenia wyświetlacza i drugą do migania diody określoną liczbę razy.

# Wyraźny wyświetlacz:

def displayClear(): oled.fill(0) oled.show() # utwórz funkcję migania def blinkLed(num): dla i w zakresie(0, num): led.on() sleep(0.5) led.off() sen(0.5)

Możemy więc teraz przepisać naszą funkcję main():

podczas gdy button.value():

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

Ostateczny kod można pobrać z mojego GitHub: localData.py oraz Jupyter Notebook służący do tworzenia pełnego kodu: Jupyter Local Data Development.

Krok 7: Podłączanie ESP do lokalnego Wi-Fi

Moduł sieciowy służy do konfiguracji połączenia WiFi. Istnieją dwa interfejsy WiFi, jeden dla stacji (gdy ESP8266 łączy się z routerem) i jeden dla punktu dostępowego (dla innych urządzeń, które łączą się z ESP8266). Tutaj nasz ESP zostanie podłączony do sieci lokalnej. Zadzwońmy do biblioteki i zdefiniujmy nasze poświadczenia sieciowe:

importuj sieć

WiFi_SSID = "TWÓJ SSID" WiFi_PASS = "TWOJE HASŁO"

Poniższa funkcja może być wykorzystana do podłączenia ESP do sieci lokalnej:

def do_connect():

wlan = network. WLAN(network. STA_IF) wlan.active(True) if not wlan.isconnected(): print('łączenie z siecią…') wlan.connect(WiFi_SSID, WiFi_SSID) while not wlan.isconnected(): pass print('konfiguracja sieci:', wlan.ifconfig())

Uruchamiając funkcję można w rezultacie uzyskać adres IP:

do_connect()

Rezultatem będzie:

konfiguracja sieci: („10.0.1.2”, „255.255.255.0”, „10.0.1.1”, „10.0.1.1”)

Był, w moim przypadku, 10.0.1.2, to adres IP ESP.

Krok 8: Rzecz Mówi

W tym momencie nauczyliśmy się przechwytywać dane ze wszystkich czujników, wyświetlając je na naszym OLED. Teraz nadszedł czas, aby zobaczyć, jak przesłać te dane na platformę IoT, ThingSpeak.

Zaczynajmy!

Po pierwsze, musisz mieć konto na ThinkSpeak.com. Następnie postępuj zgodnie z instrukcjami, aby utworzyć kanał i zanotuj swój identyfikator kanału i zapisz klucz API.

Powyżej możesz zobaczyć 5 pól, które będą używane na naszym kanale.

Krok 9: Protokół MQTT i połączenie ThingSpeak

MQTT to architektura publikowania/subskrybowania, która została opracowana głównie w celu łączenia urządzeń o ograniczonej przepustowości i mocy w sieciach bezprzewodowych. Jest to prosty i lekki protokół, który działa przez gniazda TCP/IP lub WebSockets. MQTT przez WebSockets można zabezpieczyć za pomocą SSL. Architektura publikowania/subskrybowania umożliwia wypychanie komunikatów do urządzeń klienckich bez konieczności ciągłego odpytywania przez urządzenie serwera.

Broker MQTT jest centralnym punktem komunikacji i odpowiada za wysyłanie wszystkich wiadomości między nadawcami a pełnoprawnymi odbiorcami. Klient to dowolne urządzenie, które łączy się z brokerem i może publikować lub subskrybować tematy w celu uzyskania dostępu do informacji. Temat zawiera informacje o routingu dla brokera. Każdy klient, który chce wysyłać wiadomości, publikuje je w określonym temacie, a każdy klient, który chce otrzymywać wiadomości, subskrybuje określony temat. Broker dostarcza wszystkie komunikaty z pasującym tematem do odpowiednich klientów.

ThingSpeak™ ma brokera MQTT pod adresem URL mqtt.thingspeak.com i portem 1883. Broker ThingSpeak obsługuje zarówno publikowanie MQTT, jak i subskrypcję MQTT.

W naszym przypadku użyjemy: MQTT Publish

Rysunek opisuje strukturę tematu. Do publikacji wymagany jest klucz API Write. Broker potwierdza prawidłowe żądanie CONNECT za pomocą CONNACK.

Protokół MQTT jest obsługiwany we wbudowanej bibliotece w plikach binarnych Micropython - ten protokół może być używany do wysyłania danych z twojego ESP8266, przez WIFI, do bezpłatnej bazy danych w chmurze.

Wykorzystajmy bibliotekę umqtt.simple:

z umqtt.simple importuj MQTTClient

Znając nasz SERVER ID, możliwe jest stworzenie naszego obiektu klienta MQTT:

SERWER = "mqtt.thingspeak.com"

klient = MQTTClient("umqtt_client", SERWER)

Teraz, mając pod ręką swoje dane uwierzytelniające ThingSpeak:

CHANNEL_ID = "ID TWOJEGO KANAŁU"

WRITE_API_KEY = "TUTAJ TWÓJ KLUCZ"

Stwórzmy nasz „Temat” MQTT:

temat = "kanały/" + CHANNEL_ID + "/publish/" + WRITE_API_KEY

Przekażmy nasze dane do usługi ThingSpeak IoT Service, korzystając z utworzonej funkcji i powiążmy jej odpowiedź z określonymi zmiennymi danych:

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

Po zaktualizowaniu tych zmiennych możemy stworzyć nasz "MQTT Payload":

ładunek = "field1="+str(temp)+"&field2="+str(hum)+"&field3="+str(extTemp)+"&field4="+str(lum)+"&field5="+str(aleSts)

I to wszystko! Jesteśmy gotowi do wysłania danych do ThinsSpeak, używając po prostu 3 linii kodu poniżej:

klient.connect()

client.publish(temat, ładunek) client.disconnect()

Teraz, jeśli wejdziesz na stronę swojego kanału (jak moja powyżej), zobaczysz, że każde z 5 pól będzie zawierało dane związane z czujnikami.

Krok 10: Rejestrator danych czujnika

Teraz, gdy wiemy, że za pomocą zaledwie kilku linijek kodu można przesłać dane do usługi IoT, stwórzmy funkcję pętli, która zrobi to automatycznie w regularnych odstępach czasu (podobnie jak w przypadku „Dane lokalne ).

Korzystając z tej samej zmiennej (PUB_TIME_SEC), wcześniej zadeklarowanej, prostej funkcji main do ciągłego przechwytywania danych, rejestrowania ich na naszym kanale byłoby:

podczas gdy prawda:

temp, hum, extTemp, lum, aleSts = colectData() payload = "field1="+str(temp)+"&field2="+str(hum)+"&field3="+str(extTemp)+"&field4="+ str(lum)+"&field5="+str(butSts) client.connect() client.publish(temat, payload) client.disconnect() time.sleep(PUB_TIME_SEC)

Pamiętaj, że tylko „ładunek” musi zostać zaktualizowany, gdy „temat” będzie powiązany z danymi logowania naszego kanału i nie ulegnie zmianie.

Szukając swojej strony kanału ThingSpeak, zauważysz, że dane będą ładowane w sposób ciągły do każdego pola. Możesz zakryć LDR, położyć rękę na czujnikach temp/hum, nacisnąć przycisk itp. i zobaczyć, jak kanał będzie automatycznie „logował” te dane do przyszłej analizy.

Zwykle do rejestracji danych powinniśmy starać się zużywać jak najmniej energii, aby nie używać diody LED ani wyświetlacza lokalnie. Często zdarza się również, że urządzenia ESP wprowadzają je w „głęboki sen”, w którym mikroprocesor będzie w stanie minimalnej energii, dopóki nie nadejdzie czas na przechwytywanie danych i wysyłanie ich na platformę IoT.

Ale kiedy już pomysł się uczy, uwzględnijmy również wyświetlacz i diodę LED, tak jak to robiliśmy wcześniej. W ten sposób naszą funkcją „loggera” będzie:

podczas gdy 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(aleSts) client.connect() client.publish(topic, payload) client.disconnect() time.sleep(PUB_TIME_SEC) blinkLed(3) displayClear()

Kompletny skrypt microPython można znaleźć tutaj: dataLoggerTS_EXT.py, a notatnik Jupyter, który został użyty do rozwoju można również znaleźć tutaj: IoT ThingSpeak Data Logger EXT.ipynb.

Aby wgrać skrypt na ESP, na swoim terminalu użyj polecenia:

ampy umieścić dataLoggerTS.py /main.py

I naciśnij przycisk ESP - reset. Będziesz mieć ESP przechwytujące dane i rejestrujące je na ThingSpeak.com, dopóki spód nie zostanie naciśnięty (poczekaj, aż dioda LED zamiga 3 razy i wyłączy się OLED).

Krok 11: Aplikacja ThingView

Zarejestrowane dane można przeglądać bezpośrednio na stronie ThingSpeak.com lub za pośrednictwem aplikacji, na przykład ThingsView!

ThingView to aplikacja opracowana przez CINETICA, która umożliwia łatwą wizualizację kanałów ThingSpeak, wystarczy wpisać ID kanału i gotowe.

W przypadku kanałów publicznych aplikacja będzie respektować ustawienia systemu Windows: kolor, skalę czasu, typ wykresu i liczbę wyników. Obecna wersja obsługuje wykresy liniowe i kolumnowe, wykresy spline są wyświetlane jako wykresy liniowe.

W przypadku kanałów prywatnych dane będą wyświetlane przy użyciu ustawień domyślnych, ponieważ nie ma możliwości odczytania ustawień prywatnych okien tylko za pomocą klucza API.

Aplikację ThingView można pobrać na ANDROID i IPHONE.

Krok 12: Wniosek

Jak zawsze mam nadzieję, że ten projekt pomoże innym odnaleźć drogę do ekscytującego świata elektroniki!

Aby uzyskać szczegółowe informacje i ostateczny kod, odwiedź mój depozyt na GitHub: IoT_TS_MQTT

Więcej projektów znajdziesz na moim blogu: MJRoBot.org

Saludo z południa świata!

Do zobaczenia w mojej następnej instrukcji!

Dziękuję Ci, Marcelo