IoT leicht gemacht: ESP-MicroPython-MQTT-ThingSpeak - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:18

In meinem vorherigen Tutorial, MicroPython auf ESP mit Jupyter, haben wir gelernt, wie man MicroPython auf einem ESP-Gerät installiert und ausführt. Mit Jupyter Notebook als Entwicklungsumgebung haben wir auch gelernt, wie man von Sensoren liest (Temperatur, Feuchtigkeit und Helligkeit). Daten auf einem OLED-Display.

In diesem Tutorial, das ein MQTT-Protokoll verwendet, erhalten wir nun alle erfassten Daten und senden sie an einen IoT-Dienst, ThingSpeak.com und an eine mobile App (Thingsview), wo wir uns protokollieren und mit Daten spielen können.

Hier das Blockschaltbild unseres Projekts:

Schritt 1: Stückliste - Stückliste

1. KnotenMCU - 8,39 US-Dollar
2. DHT22 Temperatur- und relativer Luftfeuchtigkeitssensor - USD 9,95
3. DS18B20 Wasserdichter Temperatursensor - USD 5.95
4. OLED-Display SSD1366 – 8,99 USD (optional)
5. LDR (1x)
6. LEDs (1x) (optional)
7. Druckknopf (1x)
8. Widerstand 4K7 Ohm (2x)
9. Widerstand 10K Ohm (1x)
10. Widerstand 220 Ohm (1x)

Schritt 2: Das Hw

Das Hw, das wir hier verwenden werden, ist im Wesentlichen das gleiche, das im Tutorial verwendet wird: Micropython on ESP Using Jupyter. Beziehen Sie sich auf alle HW-Verbindungen.

Die Ausnahme ist der Servo, den wir in diesem Projekt nicht verwenden werden.

Oben sehen Sie die vollständige HW. Schließen Sie die Geräte wie dort gezeigt an.

Schritt 3: Micropython, REPL, Jupyter

Sie müssen einen Micropython-Interpreter auf Ihrem ESP-Gerät geladen haben. Nach dem Laden sollten Sie Ihren ESP mit einer der verfügbaren Methoden/IDEs programmieren, wie zum Beispiel:

• REPL
• Jupyter-Notizbuch
• Mu
• ESPCut (nur Windows)
• … etc

In meinem Tutorial Micropython on ESP Using Jupyter habe ich beschrieben, wie man den MicroPython-Interpreter, ESPTool zum Verwalten von ESP-Geräten herunterlädt und installiert und wie man Jupyter Notebook als Entwicklungsumgebung verwendet. Fühlen Sie sich frei, das zu verwenden, was für Sie bequemer ist.

Normalerweise entwickle ich die gesamte Entwicklung auf Jupyter Notebook, und sobald ich den endgültigen Code habe, kopiere ich ihn nach Geany und lade ihn mit Ampy auf meinen ESP.

Schritt 4: Sensoren

Lassen Sie uns die Bibliotheken installieren, GPIO definieren, Objekte erstellen, Funktionen für alle Sensoren einzeln:

A. DHT (Temperatur und Luftfeuchtigkeit)

Lassen Sie uns die DHT-Bibliothek installieren und ein Objekt erstellen:

von dht importieren DHT22

aus Maschinenimport Pin dht22 = DHT22(Pin(12))

Erstellen Sie nun eine Funktion zum Auslesen des DHT-Sensors:

def readDht():

dht22.measure() gibt dht22.temperature(), dht22.humidity() zurück DHT-Funktion testen

drucken (readDht())

Das Ergebnis sollte zum Beispiel sein:

(17.7, 43.4)

B. DS18B20 (Außentemperatur)

Lassen Sie uns die Bibliotheken installieren und ein Objekt erstellen:

Eindraht importieren, DS18x20

import time # Definieren Sie, an welchem Pin das 1-Wire-Gerät angeschlossen wird ==> Pin 2 (D4) dat = Pin(2) # Erstellen Sie das Onewire-Objekt ds = ds18x20. DS18X20(onewire. OneWire(dat)) Nach Geräten im Bus suchen

Sensoren = ds.scan()

print('Geräte gefunden:', Sensoren)

Das gedruckte Ergebnis ist nicht wirklich wichtig, was wir brauchen, ist der erste erkannte Sensor: Sensoren[0]. Und jetzt können wir eine Funktion zum Lesen von Sensordaten erstellen:

def readDs():

ds.convert_temp() time.sleep_ms(750) Rückgabe ds.read_temp(sensors[0])

Es ist immer wichtig, den Sensor mit der erstellten Funktion zu testen

print(readDs()) Wenn Sie einen Temperaturwert erhalten, ist Ihr Code korrekt

17.5

C. LDR (Leuchtkraft)

Der LDR verwendet den analogen Pin unseres ESP (bei ESP8266 ist es nur einer und bei ESP32 mehrere).

Weitere Informationen finden Sie in meinem ESP32-Tutorial.

Wie zuvor gemacht:

# Bibliothek importieren

vom Maschinenimport ADC # Objekt definieren adc = ADC(0) Eine einfache Funktion: adc.read() kann verwendet werden, um den ADC-Wert zu lesen. Denken Sie jedoch daran, dass der interne ADC Spannungen zwischen 0 und 3,3 V in entsprechende digitale Werte umwandelt, die von 0 bis 1023 variieren Fall 900) und das minimale Licht, das in meinem Fall 40 beträgt. Mit diesen Werten können wir den Wert von 40 bis 900 in 0 bis 100% der Helligkeit "abbilden". Dafür werden wir eine neue Funktion erstellen

def readLdr():

lumPerct = (adc.read()-40)*(10/86) # in Prozent konvertieren ("map") return round(lumPerct)

Sie sollten die Funktion mit print (readLDR()) testen. Das Ergebnis sollte eine ganze Zahl zwischen o und 100 sein.

D. Drucktaste (digitaler Eingang)

Hier verwenden wir einen Taster als digitalen Sensor, aber es könnte ein "Echo" eines Aktors sein (z. B. eine Pumpe, die EIN/AUS geschaltet wurde).

# Pin 13 als Eingang definieren und einen internen Pull-Up-Widerstand aktivieren:

button = Pin(13, Pin. IN, Pin. PULL_UP) # Funktion zum Auslesen des Buttonstatus: def readBut(): return button.value()

Sie können die Schaltfläche testen, indem Sie die Funktion print(readBut()) lesen. Ohne Drücken sollte das Ergebnis "1" sein. Wenn Sie die Taste drücken, sollte das Ergebnis "0" sein

Schritt 5: Lokale Erfassung und Anzeige aller Sensordaten

Nachdem wir nun für jeden Sensor eine Funktion erstellt haben, erstellen wir die letzte, die alle gleichzeitig liest:

def colectData():

temp, hum, = readDht() extTemp = readDs() lum = readLdr() butSts = readBut() return temp, hum, extTemp, lum, butSts Wenn Sie jetzt verwenden

print(colectData())

Ergibt ein Tupel, das alle erfassten Daten von Sensoren enthält:

(17.4, 45.2, 17.3125, 103, 1)

Optional können wir diese Daten auch auf einem lokalen Display anzeigen:

# Bibliothek importieren und Objekt i2c erstellen

from machine import I2C i2c = I2C(scl=Pin(5), sda=Pin(4)) # Bibliothek importieren und Objekt erstellen oled import ssd1306 i2c = I2C(scl=Pin(5), sda=Pin(4)) oled = ssd1306. SSD1306_I2C(128, 64, i2c, 0x3c) # eine Funktion erstellen: def displayData(temp, hum, extTemp, lum, butSts): oled.fill(0) oled.text("Temp: " + str(temp) + "oC", 0, 4) oled.text("Hum: " + str(brum) + "%", 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() # Daten mit der Funktion displayData(temp, hum, extTemp, lum, butSts) anzeigen

Als Option füge ich auch die LED hinzu, die eingeschaltet ist, wenn wir mit dem Lesen der Sensoren beginnen, und erlischt, nachdem diese Daten angezeigt wurden. Auf diese Weise können Sie bestätigen, dass das Programm funktioniert, wenn das ESP vom PC getrennt und automatisch ausgeführt wird.

Die "Hauptfunktion" wäre also:

# Hauptfunktion zum Auslesen aller Sensoren

def main(): # Daten mit einer Funktion anzeigen led.on() temp, hum, extTemp, lum, butSts = colectData() displayData(temp, hum, extTemp, lum, butSts) led.off()

Wenn wir also main() ausführen, werden die Sensordaten auf OLED angezeigt, wie im Bild gezeigt.

Schritt 6: Ausführen des lokalen Stationscodes beim ESP-Start

Wir können alles, was bisher entwickelt wurde, in einer einzigen Datei haben, die von unserem ESP ausgeführt wird.

Lassen Sie uns einen beliebigen Texteditor öffnen und den gesamten Code verwenden:

# allgemeine Bibliotheken importieren

vom Maschinenimport Pinimportzeit # Pin 0 als Ausgang definieren led = Pin(0, Pin. OUT) # DHT von dht import DHT22 dht22 = DHT22(Pin(12)) # Funktion zum Lesen von DHT def readDht(): dht22.measure () return dht22.temperature(), dht22.humidity() # DS18B20 import onewire, ds18x20 # Definieren Sie, an welchem Pin das 1-Wire-Gerät angeschlossen werden soll ==> Pin 2 (D4) dat = Pin(2) # Erstellen Sie den Onewire object ds = ds18x20. DS18X20(onewire. OneWire(dat)) # nach Geräten am Bus suchen Sensoren = ds.scan() # Funktion zum Lesen von DS18B20 def readDs(): ds.convert_temp() time.sleep_ms(750) return round(ds.read_temp(sensors[0]), 1) # LDR vom Maschinenimport ADC # Definiere Objekt adc = ADC(0) #Funktion zum Auslesen der Leuchtkraft def readLdr(): lumPerct = (adc.read()-40) *(10/86) # in Prozent umrechnen ("map") return round(lumPerct) # Pin 13 als Eingang definieren und einen internen Pullup-Widerstand aktivieren: Taste = Pin(13, Pin. IN, Pin. PULL_UP) # Funktion zum Lesen des Schaltflächenstatus: def readBut(): return button.value() # Funktion zum Lesen aller Daten: def cole ctData(): temp, hum, = readDht() extTemp = readDs() lum = readLdr() butSts = readBut() return temp, hum, extTemp, lum, butSts # Bibliothek importieren und Objekt i2c aus Maschine erstellen importieren I2C i2c = I2C(scl=Pin(5), sda=Pin(4)) # Bibliothek importieren und Objekt erstellen oled import ssd1306 i2c = I2C(scl=Pin(5), sda=Pin(4)) oled = ssd1306. SSD1306_I2C(128, 64, i2c, 0x3c) # eine Funktion erstellen: def displayData(temp, hum, extTemp, lum, butSts): oled.fill(0) oled.text("Temp: " + str(temp) + "oC", 0, 4) oled.text("Brum: " + str(brum) + "%", 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() # Hauptfunktion zum Auslesen aller Sensoren def main(): # Daten mit einer Funktion anzeigen led.on() temp, hum, extTemp, lum, butSts = colectData() displayData(temp, hum, extTemp, lum, butSts) led.off() '''- ----- Hauptfunktion ausführen --------''' main()

Speichern Sie es beispielsweise als localData.py.

Um diesen Code direkt auf Ihrem Terminal auszuführen, benötigen Sie Ampy.

Lassen Sie uns zunächst am Terminal Ampy unseren seriellen Port mitteilen:

export AMPY_PORT=/dev/tty. SLAB_USBtoUART

Jetzt können wir die Dateien sehen, die sich in unserem ESP-Stammverzeichnis befinden:

ampy ls

Als Antwort erhalten wir boot.py, das ist die erste Datei, die im System ausgeführt wird.

Lassen Sie uns nun Ampy verwenden, um unser Python-Skript LocalData.py als /main.py zu laden, damit das Skript direkt nach dem Booten ausgeführt wird:

ampy put localData.py /main/py

Wenn wir jetzt den Befehl amp ls verwenden, sehen Sie 2 Dateien im ESP.: boot.py und main.py

Das Zurücksetzen Ihres ESP führt dazu, dass das Programm localData.py automatisch ausgeführt wird und die Sensordaten auf dem Display angezeigt werden.

Der obige Terminal-Druckbildschirm zeigt, was wir getan haben.

Mit dem obigen Code wird die Anzeige nur einmal angezeigt, aber wir können eine Schleife für die main()-Funktion definieren, die Daten zu jedem definierten Zeitintervall (PUB_TIME_SEC) anzeigt, und zum Beispiel bis wir die Taste drücken:

# Schleife zum Abrufen von Daten, bis die Taste gedrückt wird

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

Die Variable PUB_TIME_SEC muss zu dem Zeitpunkt deklariert werden, zu dem Sie Ihre Samples haben möchten.

Um unseren Code weiter zu verbessern, wäre es gut zu informieren, dass wir die Schleife verlassen werden, dafür werden wir 2 neue allgemeine Funktionen definieren, eine zum Löschen des Displays und eine andere zum Blinken der LED mit einer bestimmten Anzahl von Malen.

# Klare Anzeige:

def displayClear(): oled.fill(0) oled.show() # eine Blinkfunktion erstellen def blinkLed(num): für i in range(0, num): led.on() sleep(0.5) led.off() schlafen (0.5)

Also können wir jetzt unsere main()-Funktion neu schreiben:

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()

Der endgültige Code kann von meinem GitHub heruntergeladen werden: localData.py und auch das Jupyter Notebook, das für die Entwicklung des vollständigen Codes verwendet wird: Jupyter Local Data Development.

Schritt 7: Verbinden des ESP mit lokalem WLAN

Das Netzwerkmodul dient zur Konfiguration der WLAN-Verbindung. Es gibt zwei WiFi-Schnittstellen, eine für die Station (wenn sich der ESP8266 mit einem Router verbindet) und eine für den Access Point (für andere Geräte zum Verbinden mit dem ESP8266). Hier wird unser ESP mit dem lokalen Netzwerk verbunden. Rufen wir die Bibliothek auf und definieren unsere Netzwerkanmeldeinformationen:

Netzwerk importieren

WiFi_SSID = "IHRE SSID" WiFi_PASS = "IHR PASSWORT"

Die folgende Funktion kann verwendet werden, um das ESP mit Ihrem lokalen Netzwerk zu verbinden:

def do_connect():

wlan = network. WLAN(network. STA_IF) wlan.active(True) if not wlan.isconnected(): print('connecting to network…') wlan.connect(WiFi_SSID, WiFi_SSID) while not wlan.isconnected(): pass print('Netzwerkkonfiguration:', wlan.ifconfig())

Wenn Sie die Funktion ausführen, erhalten Sie als Ergebnis die IP-Adresse:

do_connect()

Das Ergebnis wird sein:

Netzwerkkonfiguration: ('10.0.1.2', '255.255.255.0', '10.0.1.1', '10.0.1.1')

War in meinem Fall 10.0.1.2, ist die ESP-IP-Adresse.

Schritt 8: Das ThingSpeak

An dieser Stelle haben wir gelernt, wie man Daten von allen Sensoren erfasst und auf unserem OLED anzeigt. Jetzt ist es an der Zeit zu sehen, wie diese Daten an eine IoT-Plattform, das ThingSpeak, gesendet werden.

Lass uns anfangen!

Zunächst müssen Sie ein Konto bei ThinkSpeak.com haben. Folgen Sie als Nächstes den Anweisungen zum Erstellen eines Kanals und notieren Sie sich Ihre Kanal-ID und Ihren API-Schlüssel schreiben.

Oben sehen Sie die 5 Felder, die auf unserem Kanal verwendet werden.

Schritt 9: MQTT-Protokoll und ThingSpeak-Verbindung

MQTT ist eine Publish/Subscribe-Architektur, die in erster Linie entwickelt wurde, um bandbreiten- und leistungsbeschränkte Geräte über drahtlose Netzwerke zu verbinden. Es ist ein einfaches und leichtes Protokoll, das über TCP/IP-Sockets oder WebSockets ausgeführt wird. MQTT über WebSockets kann mit SSL gesichert werden. Die Publish/Subscribe-Architektur ermöglicht das Pushen von Nachrichten an die Clientgeräte, ohne dass das Gerät den Server ständig abfragen muss.

Der MQTT-Broker ist der zentrale Kommunikationspunkt und für den Versand aller Nachrichten zwischen den Absendern und den rechtmäßigen Empfängern verantwortlich. Ein Client ist ein beliebiges Gerät, das eine Verbindung zum Broker herstellt und Themen veröffentlichen oder abonnieren kann, um auf die Informationen zuzugreifen. Ein Thema enthält die Routing-Informationen für den Broker. Jeder Client, der Nachrichten senden möchte, veröffentlicht sie zu einem bestimmten Thema, und jeder Client, der Nachrichten empfangen möchte, abonniert ein bestimmtes Thema. Der Broker liefert alle Nachrichten mit dem passenden Thema an die entsprechenden Clients.

ThingSpeak™ verfügt über einen MQTT-Broker unter der URL mqtt.thingspeak.com und Port 1883. Der ThingSpeak-Broker unterstützt sowohl MQTT-Publishing als auch MQTT-Abonnement.

In unserem Fall verwenden wir: MQTT Publish

Die Abbildung beschreibt die Themenstruktur. Zum Veröffentlichen ist der Write API Key erforderlich. Der Broker quittiert eine korrekte CONNECT-Anfrage mit CONNACK.

Das MQTT-Protokoll wird in einer integrierten Bibliothek in den Micropython-Binärdateien unterstützt - dieses Protokoll kann verwendet werden, um Daten von Ihrem ESP8266 über WIFI an eine kostenlose Cloud-Datenbank zu senden.

Lassen Sie uns die Bibliothek umqtt.simple verwenden:

aus umqtt.simple MQTTClient importieren

Und mit unserer SERVER-ID ist es möglich, unser MQTT-Client-Objekt zu erstellen:

SERVER = "mqtt.thingspeak.com"

client = MQTTClient("umqtt_client", SERVER)

Jetzt haben Sie Ihre ThingSpeak-Anmeldeinformationen zur Hand:

CHANNEL_ID = "IHRE KANAL-ID"

WRITE_API_KEY = "IHR SCHLÜSSEL HIER"

Lassen Sie uns unser MQTT-"Thema" erstellen:

topic = "channels/" + CHANNEL_ID + "/publish/" + WRITE_API_KEY

Lassen Sie uns unsere Daten an ThingSpeak IoT Service senden, indem wir die erstellte Funktion verwenden und ihre Antwort mit bestimmten Datenvariablen verknüpfen:

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

Wenn diese Variablen aktualisiert sind, können wir unsere "MQTT-Nutzlast" erstellen:

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

Und das ist es! Wir sind bereit, Daten an ThinsSpeak zu senden, indem Sie einfach die folgenden 3 Codezeilen verwenden:

client.connect()

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

Wenn Sie nun zu Ihrer Kanalseite gehen (wie meine oben), werden Sie sehen, dass jedes der 5 Felder Daten zu Ihren Sensoren enthält.

Schritt 10: Sensordatenlogger

Nachdem wir nun wissen, dass es mit nur wenigen Codezeilen möglich ist, Daten in einen IoT-Dienst hochzuladen, erstellen wir eine Schleifenfunktion, um dies in regelmäßigen Abständen automatisch durchzuführen (ähnlich wie bei "Lokale Daten". ").

Mit der gleichen Variablen (PUB_TIME_SEC), die zuvor deklariert wurde, wäre eine einfache Hauptfunktion zum kontinuierlichen Erfassen von Daten, die in unserem Kanal protokolliert wird, Folgendes:

während Wahr:

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(topic, payload) client.disconnect() time.sleep(PUB_TIME_SEC)

Beachte, dass nur die "Payload" aktualisiert werden muss, sobald "Thema" mit unseren Kanal-Anmeldeinformationen zusammenhängt und sich nicht ändert.

Wenn Sie nach Ihrer ThingSpeak-Kanalseite suchen, werden Sie feststellen, dass die Daten kontinuierlich in jedes Feld geladen werden. Sie können den LDR abdecken, Ihre Hand auf die Temperatur- / Brummsensoren legen, die Taste drücken usw. und sehen, wie der Kanal diese Daten automatisch für die zukünftige Analyse "protokolliert".

Normalerweise sollten wir für die Datenprotokollierung versuchen, so wenig Strom wie möglich zu verbrauchen, also würden wir die LED oder das Display nicht lokal verwenden. Außerdem ist es bei ESP-Geräten üblich, sie in den "Tiefschlaf" zu versetzen, bei dem der Mikroprozessor in den Zustand minimaler Energie versetzt wird, bis es Zeit ist, Daten zu erfassen und an die IoT-Plattform zu senden.

Aber sobald hier die Idee gelernt ist, lassen Sie uns auch das Display und die LED einbeziehen, wie wir es zuvor getan haben. Dabei ist unsere "Logger"-Funktion:

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

Das vollständige microPython-Skript finden Sie hier: dataLoggerTS_EXT.py und das Jupyter-Notebook, das für die Entwicklung verwendet wurde, finden Sie auch hier: IoT ThingSpeak Data Logger EXT.ipynb.

Um das Skript auf ESP hochzuladen, verwenden Sie auf Ihrem Terminal den Befehl:

ampy put dataLoggerTS.py /main.py

Und drücken Sie die ESP - Reset-Taste. Das ESP erfasst Daten und protokolliert sie auf ThingSpeak.com, bis die Unterseite gedrückt gehalten wird (warten Sie, bis die LED dreimal blinkt und die OLED erlischt).

Schritt 11: Die ThingView-App

Die protokollierten Daten können direkt auf der Website von ThingSpeak.com oder über eine APP, zum Beispiel ThingsView, eingesehen werden!

ThingView ist eine von CINETICA entwickelte APP, mit der Sie Ihre ThingSpeak-Kanäle auf einfache Weise visualisieren können, geben Sie einfach die Kanal-ID ein und schon können Sie loslegen.

Bei öffentlichen Kanälen berücksichtigt die Anwendung Ihre Windows-Einstellungen: Farbe, Zeitskala, Diagrammtyp und Anzahl der Ergebnisse. Die aktuelle Version unterstützt Linien- und Säulendiagramme, die Spline-Diagramme werden als Liniendiagramme dargestellt.

Bei privaten Kanälen werden die Daten mit den Standardeinstellungen angezeigt, da es keine Möglichkeit gibt, die privaten Windows-Einstellungen nur mit dem API-Schlüssel auszulesen.

Die ThingView APP kann für ANDROID und IPHONE heruntergeladen werden.

Schritt 12: Fazit

Wie immer hoffe ich, dass dieses Projekt anderen helfen kann, ihren Weg in die spannende Welt der Elektronik zu finden!

Für Details und den endgültigen Code besuchen Sie bitte mein GitHub-Depot: IoT_TS_MQTT

Für weitere Projekte besuchen Sie bitte meinen Blog: MJRoBot.org

Saludos aus dem Süden der Welt!

Wir sehen uns in meinem nächsten instructable!

Dankeschön, Marcelo