Einstieg in Python, Teil 16
IoT und ThingSpeak für Python
IoT-Anwendungen spielen heute in vielen Bereichen wie Smart Home, Industrie, Landwirtschaft und Umweltüberwachung eine wichtige Rolle. Besonders in Verbindung mit der Programmiersprache Python lassen sich Messdaten einfach erfassen, verarbeiten und weiterleiten. Zur Speicherung und Visualisierung der erfassten Daten kann die Cloud-Plattform ThingSpeak genutzt werden. Sie ermöglicht die Übertragung von Sensordaten, deren Speicherung in der Cloud sowie die Darstellung in Form von Diagrammen und Auswertungen. Dieser Beitrag zeigt, wie Raspberry Pi, Python und ThingSpeak zusammenwirken, um eine einfache IoT-Anwendung zur Datenerfassung und -analyse zu realisieren.
IoT & Raspberry Pi – Zwei Ideale Partner
Python eignet sich hervorragend für IoT-Anwendungen, da es wichtige Anforderungen moderner vernetzter Systeme erfüllt. Kompakte Einplatinenrechner können damit auch in platzbeschränkten Umgebungen eingesetzt werden, beispielsweise in Smart-Home-Systemen, Messstationen oder industriellen Prototypen. Gleichzeitig überzeugen die Minirechner durch vergleichsweise geringen Energieverbrauch, wodurch ein dauerhafter Betrieb wirtschaftlich möglich ist.
Ein weiterer Vorteil sind die niedrigen Anschaffungskosten. Im Vergleich zu herkömmlichen Computersystemen unter Windows bieten Python-basierte Systeme bereits für wenig Geld ausreichend Rechenleistung, Netzwerkfunktionen und Schnittstellen für Sensoren und Aktoren. Dadurch können IoT-Projekte kostengünstig umgesetzt und flexibel erweitert werden. Die Kombination aus Python-Programmierung, Energieeffizienz, kompakter Bauform und Wirtschaftlichkeit macht damit insbesondere den Raspberry Pi zu einem idealen Partner für zahlreiche IoT-Anwendungen.
Was ist ThingSpeak?
ThingSpeak ist eine cloudbasierte IoT-Plattform, die speziell für die Erfassung, Speicherung und Auswertung von Sensordaten entwickelt wurde. Sie ermöglicht es, Messwerte von Geräten wie dem Raspberry Pi über das Internet an einen zentralen Cloud-Dienst zu übertragen. Die Daten werden dort in sogenannten Channels gespeichert und können jederzeit abgerufen werden.
Ein besonderer Vorteil von ThingSpeak ist die integrierte Visualisierung der erfassten Daten. Messwerte wie Temperatur, Luftfeuchtigkeit oder Helligkeit lassen sich automatisch in Form von Diagrammen und Zeitreihen darstellen. Dadurch können Veränderungen und Trends schnell erkannt werden. Über eine einfach nutzbare API kann Python die Daten direkt an ThingSpeak senden, wodurch sich die Plattform ideal für IoT-Projekte mit dem Raspberry Pi eignet. Neben der Visualisierung bietet ThingSpeak außerdem Funktionen zur Datenanalyse und Weiterverarbeitung der erfassten Informationen.
Die Voraussetzung zur Verwendung ist lediglich, dass der Raspberry Pi in einem WLAN angemeldet ist. Die Zugangsdaten zu ThingSpeak können über die Website https://thingspeak.mathworks.com/login angefordert werden (Bild 1):

Funktionen von ThingSpeak
ThingSpeak bietet verschiedene Funktionen zur Erfassung, Speicherung, Visualisierung und Analyse von IoT-Daten. Die Plattform ist so aufgebaut, dass Sensordaten einfach aufgenommen und übersichtlich dargestellt werden können. Die grundlegende Organisationseinheit in ThingSpeak ist der sogenannte Channel. Ein Channel dient als Speicherort für die Daten eines Projekts oder einer Anwendung. Jeder Channel besitzt eigene Einstellungen, Zugriffsrechte und einen individuellen API-Schlüssel, über den Daten gesendet oder abgerufen werden können. So lassen sich verschiedene Projekte oder Messsysteme getrennt verwalten.
Innerhalb eines Channels stehen bis zu acht Fields zur Verfügung. Jedes Field speichert eine bestimmte Messgröße, beispielsweise Temperatur, Luftfeuchtigkeit, Luftdruck oder Helligkeit. Werden neue Sensordaten an ThingSpeak übertragen, werden diese den entsprechenden Feldern zugeordnet und zusammen mit einem Zeitstempel gespeichert. Dadurch können mehrere Messwerte gleichzeitig erfasst und ausgewertet werden.
ThingSpeak erstellt aus den gespeicherten Daten automatisch grafische Darstellungen. Die Messwerte werden in Form von Zeitreihen und Diagrammen visualisiert, sodass Entwicklungen und Trends leicht erkennbar sind. Anwender können die Diagramme individuell anpassen und die Daten in Echtzeit überwachen. Dies erleichtert die Analyse von Sensordaten erheblich und ermöglicht eine schnelle Bewertung der Messergebnisse.
Eine besondere Funktion von ThingSpeak ist die Integration von MATLAB Analytics. Damit können die gespeicherten Daten direkt in der Cloud analysiert und verarbeitet werden. Mithilfe von MATLAB-Skripten lassen sich beispielsweise Durchschnittswerte berechnen, Messreihen filtern, Grenzwerte überwachen oder Vorhersagen erstellen. Dadurch wird ThingSpeak nicht nur zu einer Plattform für die Datenspeicherung, sondern auch zu einem leistungsfähigen Werkzeug für die Datenanalyse im IoT-Bereich.
ThingSpeak mit Python: Datenübertragung
Die Kommunikation zwischen einem Raspberry Pi und ThingSpeak erfolgt in der Regel über die Programmiersprache Python. Aufgrund ihrer einfachen Syntax und der großen Anzahl verfügbarer Bibliotheken eignet sich Python hervorragend für IoT-Anwendungen. Mithilfe weniger Programmzeilen können Sensordaten erfasst, verarbeitet und anschließend über das Internet an einen ThingSpeak-Channel übertragen werden.
Die Datenübertragung erfolgt über die REST-API von ThingSpeak. Dazu sendet Python eine HTTP-Anfrage an die Plattform, die den API-Schlüssel sowie die zu übertragenden Messwerte enthält. ThingSpeak speichert diese Werte anschließend automatisch im entsprechenden Channel und stellt sie für die Visualisierung und Analyse bereit.
Vor der Datenübertragung müssen zunächst die benötigten Python-Bibliotheken installiert werden. Für die Kommunikation mit ThingSpeak wird häufig die Bibliothek requests verwendet:
pip install requests
Anschließend wird in ThingSpeak ein eigener Channel erstellt. Für diesen Channel stellt ThingSpeak einen sogenannten Write API Key bereit, der für das Schreiben von Daten benötigt wird. Das folgende Beispiel (DummyTemp.py) zeigt, wie ein Temperaturwert an ThingSpeak gesendet werden kann:
import requests
api_key = "DEIN_WRITE_API_KEY"
temperatur = 22.5
url = "https://api.thingspeak.com/update"
payload = {
"api_key": api_key,
"field1": temperatur
}
response = requests.get(url, params=payload)
print("Serverantwort:", response.text)
In diesem Beispiel wird der Messwert 22.5 an das erste Feld (field1) des Channels übertragen. Die Serverantwort enthält die Datensatznummer des neu gespeicherten Eintrags.
Mehrere Sensordaten übertragen
Häufig werden mehrere Sensorwerte gleichzeitig erfasst. ThingSpeak stellt dafür bis zu acht Felder pro Channel (MultiChannel.py) bereit:
import requests
api_key = "DEIN_WRITE_API_KEY"
temperatur = 22.5
luftfeuchtigkeit = 48.2
payload = {
"api_key": api_key,
"field1": temperatur,
"field2": luftfeuchtigkeit,
}
requests.get(
"https://api.thingspeak.com/update",
params=payload
)
Die Werte werden nun parallel in den Feldern 1 und 2 gespeichert und können anschließend in ThingSpeak als Diagramme dargestellt werden (Bild 2).

Sensordaten automatisch senden
In vielen IoT-Anwendungen sollen Daten regelmäßig und automatisch übertragen werden. Dies lässt sich mit einer Schleife und der Bibliothek time realisieren (SensorData.py):
import requests
import random
import time
api_key = "DEIN_WRITE_API_KEY"
while True:
temperatur = random.uniform(20, 25)
requests.get(
"https://api.thingspeak.com/update",
params={
"api_key": api_key,
"field1": temperatur
}
)
print("Temperatur gesendet:", temperatur)
time.sleep(20)
Das Programm erzeugt alle 20 Sekunden einen neuen Dummy-Messwert und sendet ihn an ThingSpeak. Das Intervall sollte nicht zu kurz gewählt werden, da die kostenlose Version von ThingSpeak eine begrenzte Aktualisierungsrate (15 s) besitzt.
Sensordaten eines Sensors übertragen
Ein typisches IoT-Projekt verwendet natürlich reale Sensordaten. Das folgende Beispiel liest Temperatur und Luftfeuchtigkeit von einem DHT22-AM2302-Sensor aus und übermittelt die Werte an ThingSpeak (HumiTemp.py):
import time, board, requests, adafruit_dht
THINGSPEAK_API_KEY = "DEIN_WRITE_API_KEY"
THINGSPEAK_URL = "https://api.thingspeak.com/update"
dhtDevice = adafruit_dht.DHT22(board.D4, use_pulseio=False) # DHT22 an GPIO4
print("AM2302 / DHT22 Sensor wird ausgelesen...")
print("Drücke Strg+C zum Beenden\n")
def send_to_thingspeak(temperature, humidity):
payload = {"api_key": THINGSPEAK_API_KEY,"field1": temperature,"field2": humidity}
try:
response = requests.post(THINGSPEAK_URL, data=payload, timeout=10 )
if response.status_code == 200 and response.text != "0":
print(f"ThingSpeak Update erfolgreich (Entry-ID: {response.text})")
else:
print(f"ThingSpeak Fehler: {response.status_code}")
except Exception as e:
print(f"Fehler beim Senden an ThingSpeak: {e}")
def read_sensor():
try:
temperature_c = dhtDevice.temperature
humidity = dhtDevice.humidity
if temperature_c is not None and humidity is not None:
print(f"Temperatur: {temperature_c:.1f} °C")
print(f"Luftfeuchtigkeit: {humidity:.1f} %")
send_to_thingspeak(temperature_c, humidity)
return True
else:
print("Fehler: Keine gültigen Messwerte")
return False
except RuntimeError as error:
print(f"RuntimeError: {error.args[0]}")
return False
except Exception as error:
print(f"Fehler: {type(error).__name__} - {error}")
return False
try:
while True:
if read_sensor():
print("-" * 30)
time.sleep(20)
except KeyboardInterrupt:
print("\nProgramm beendet.")
dhtDevice.exit()
Details zur Inbetriebnahme des Sensors finden sich in einem früheren Beitrag („Python & MicroPython: Programmieren lernen für Einsteiger, Teil 9 – Sensoren und Messwerterfassung“). Der Sensor wird in diesem Beispiel an den GPIO-Pin 04 angeschlossen:
dhtDevice = adafruit_dht.DHT22(board.D4, use_pulseio=False) # DHT22 an GPIO4
Nach der Ausführung des Programms erscheinen die Messwerte automatisch im entsprechenden ThingSpeak-Channel.
Im Programm werden zunächst die Python-Bibliotheken adafruit_dht, board, requests und time verwendet. Falls erforderlich, können diese nachinstalliert werden. Die Bibliothek adafruit_dht übernimmt die Kommunikation mit dem Sensor, während requests für die Datenübertragung an ThingSpeak zuständig ist.
Zu Beginn werden der persönliche ThingSpeak-Write-API-Key sowie die URL des Dienstes festgelegt. Anschließend wird der DHT22-Sensor am GPIO4-Pin des Raspberry Pi initialisiert. Nach dem Start des Programms erfolgt die Messung in einer Schleife, die kontinuierlich Temperatur und Luftfeuchtigkeit erfasst. Die Temperatur wird dabei in Grad Celsius ausgelesen. Die aktuellen Werte werden auf der Konsole ausgegeben, sodass die Messdaten direkt verfolgt werden können.
Nach jeder erfolgreichen Messung werden die Daten dann an ThingSpeak übertragen. Dazu erstellt das Programm ein Datenpaket mit dem API-Key sowie den Messwerten für Temperatur und Luftfeuchtigkeit. Diese Werte werden den Feldern field1 und field2 des ThingSpeak-Channels zugeordnet und per HTTP-POST-Anfrage an den Server gesendet. Bei erfolgreicher Übertragung bestätigt ThingSpeak den Empfang durch die Rückgabe einer Datensatznummer (Entry-ID), die auf der Konsole angezeigt wird.
Um einen stabilen Betrieb zu gewährleisten, enthält das Programm eine Fehlerbehandlung. Typische Sensorfehler, wie Zeitüberschreitungen oder fehlerhafte Prüfsummen, werden abgefangen und führen nicht zum Abbruch des Programms. Auch Probleme bei der Netzwerkverbindung oder der Datenübertragung werden erkannt und als Fehlermeldungen ausgegeben.
Nach jeder Messung und Übertragung wartet das System 20 Sekunden, bevor der nächste Messzyklus startet. Diese Wartezeit ist notwendig, da kostenlose ThingSpeak-Konten nur etwa alle 15 Sekunden einen neuen Datensatz akzeptieren (s. o).
Durch die Kombination aus Raspberry Pi, DHT22-Sensor und ThingSpeak entsteht ein einfaches Überwachungssystem für Temperatur und Luftfeuchtigkeit. Die Messwerte werden nicht nur lokal angezeigt, sondern auch dauerhaft in der Cloud gespeichert. Dadurch können sie grafisch dargestellt, ausgewertet oder für weitere Anwendungen im Bereich Smart Home, Umweltüberwachung oder Wetterstationen genutzt werden. Bild 3 zeigt den zeitlichen Verlauf der beiden Messwerte in jeweils einem Y-t-Diagramm.

Vorteile von Python in Verbindung mit ThingSpeak
Die Kombination aus Python und ThingSpeak bietet zahlreiche Vorteile:
- Einfache und verständliche Programmierung
- Direkte Unterstützung von HTTP- und REST-Schnittstellen
- Große Auswahl an Bibliotheken für Sensoren und Hardware
- Schnelle Entwicklung von IoT-Prototypen
- Automatische Visualisierung der Daten in ThingSpeak
- Möglichkeit zur weiteren Analyse mit MATLAB Analytics
Dadurch entsteht eine leistungsfähige und zugleich leicht zugängliche Plattform für IoT-Projekte, bei der Sensordaten vom Raspberry Pi mit wenigen Programmzeilen erfasst, übertragen, gespeichert und ausgewertet werden können.
Ergänzungen, Übungen und Anregungen
- Wie kann man die durchschnittliche Temperatur und Luftfeuchtigkeit eines Tages berechnen und an ThingSpeak ausgeben?
- Ersetzen sie den DHT22-Sensor durch eine DS18X20 Temperatursensor und passen sie das Messprogramm entsprechend an.
- Formatieren sie die ThingSpeak Diagramme als verschiedene Liniendiagramme (Line Charts)
- Geben sie den Temperaturverlauf eines Tages, einer Woche oder eines Monats wieder
- Kann man auch mehrere Kurven in einem Diagramm gemeinsam darstellen?
- Untersuchen Sie mögliche Zusammenhänge zwischen zwei Messgrößen (z. B. Temperatur und Luftfeuchtigkeit) – Automatisierung?
- Sind auch Säulendiagramme (Column Charts) möglich?
- Zeigen Sie die Messwerte als Numerische Displays an!
- Formatieren die Gauge-Anzeige („Tachometer“) mit verschiedenen Farbbereichen,
z. B.
Grün = Normalbereich
Gelb = Warnung
Rot = Kritischer Bereich
Einsatz: Raumklimaüberwachung oder Alarmfunktionen. - Erstellen sie Tages-, Wochen- und Monatsansichten der Daten – vergleichen Sie den Temperaturverlauf eines Tages mit dem einer ganzen Woche
Zusammenfassung und Ausblick
Mit diesem Beitrag wurden erste Schritte in die Welt des Internet of Things (IoT) mit Python unternommen. Am Beispiel des DHT22-Sensors wurde gezeigt, wie ein Raspberry Pi Temperatur- und Luftfeuchtigkeitsdaten erfassen und über die Plattform ThingSpeak in der Cloud speichern kann. Dabei kamen wichtige Python-Konzepte wie Bibliotheken und Funktionen zum Einsatz.
Im nächsten Teil der Reihe verlassen wir die Welt der Sensoren und wenden uns der Bildverarbeitung zu. Im Mittelpunkt steht die Raspberry Pi Kamera, mit der sich Fotos und Videos direkt aus Python heraus aufnehmen lassen. Dabei lernen wir, wie eine Kamera eingerichtet und angesteuert wird, wie Bilder automatisiert gespeichert werden können und welche Möglichkeiten sich für Zeitrafferaufnahmen, Überwachungssysteme oder erste Anwendungen für „Computer Vision“ ergeben. Damit erweitert sich das Spektrum der Raspberry-Pi-Projekte von der Erfassung von Messdaten hin zur Verarbeitung visueller Informationen.
Material
- Raspberry Pi mit Netzteil
- DHT22 Sensor