Discover Top Posts Tagged with #air-qpro

air-Q pro API: Sensordaten abrufen und Geräte automatisch steuern

Der air-Q pro ist nicht nur ein präziser Luftanalysator, sondern auch ein echtes Multitalent im Smart Home. Dank der Unterstützung für Amazon Alexa und Google Home lässt er sich bequem per Sprache in bestehende Systeme integrieren. Doch wenn es um echte Automatisierung geht – etwa das gezielte Schalten von Geräten bei bestimmten Luftwerten – stößt man mit den Standardschnittstellen schnell an Grenzen. https://youtu.be/R6a6Pkl6tpY Die Lösung? Die offene API des air-Q pro. Damit kannst du ganz gezielt auf Sensordaten wie Luftfeuchtigkeit, CO₂ oder VOC zugreifen und auf diese Werte reagieren – automatisch, direkt und ohne Cloud-Zwänge. Im Beitrag „Luftqualität live: air-Q pro Daten via REST abrufen und anzeigen“ habe ich bereits gezeigt, wie man diese Daten abrufen kann – allerdings war der Code dort etwas komplex und eher für Fortgeschrittene gedacht. Hier zeige ich dir eine einfache und direkte Methode, wie du z. B. deinen elektrischen Luftentfeuchter automatisch aktivierst, sobald ein bestimmter Luftfeuchtigkeitswert überschritten wird. Ich verwende dafür: - den Pro Breeze PB-02 Luftentfeuchter, der über einen klassischen Ein-/Ausschalter verfügt (kein Taster!) - und den Shelly Plug S Gen3, einen kompakten, WLAN-fähigen Schalter, der sich perfekt für solche Automationen eignet – ganz ohne zusätzliche Verkabelung.

Pro Breeze Mini Luftentfeuchter

Shelly Outdoor Plug S Gen3

Shelly Plug S So wird aus einem reinen Luftsensor ein aktives Steuerungselement in deinem Smart Home – ganz ohne IFTTT oder Cloud-Abo. Transparenzhinweis: Das in diesem Beitrag verwendete Gerät air-Q pro wurde mir von der Corant GmbH kostenfrei für ein Review zur Verfügung gestellt. Die Bewertung und Umsetzung erfolgten unabhängig. Nach Abschluss der Beitragsreihe wird das Gerät an den Hersteller zurückgesendet.

Ablauf der Automatisierung

Die Automatisierung basiert auf einem einfachen, aber effektiven Prinzip: Der Shelly Plug S Gen3 agiert autonom, indem er in regelmäßigen Abständen die aktuellen Sensordaten vom air-Q pro abruft und selbst entscheidet, ob das angeschlossene Gerät – in meinem Fall ein Luftentfeuchter – ein- oder ausgeschaltet werden soll. Der Ablauf im Detail: - 🛰 Daten abrufen: Der Shelly ruft über ein eigenes Shelly Script in definierten Intervallen die Sensordaten von der air-Q Cloud API ab. Die Daten werden im JSON-Format geliefert und enthalten unter anderem Temperatur, Luftfeuchtigkeit, CO₂, VOC u. v. m. - 📊 Grenzwert prüfen: Das Script prüft, ob ein bestimmter Sensorwert – z. B. die relative Luftfeuchtigkeit – eine vordefinierte Schwelle überschreitet (z. B. > 65 %). - ⚡ Relais schalten: Wenn die Schwelle überschritten wird, aktiviert der Shelly automatisch das Relais – der Luftentfeuchter startet. Sinkt der Wert wieder unter die Schwelle, wird das Relais deaktiviert, und der Entfeuchter schaltet sich ab.

Ablauf - Abruf der Daten vom air-Q pro via API Schnittstelle 💡 Vorteil: Diese Logik läuft komplett lokal auf dem Shelly, ohne dass ein separates Gateway, IFTTT oder ein Smarthome-System erforderlich ist.

API-Zugang einrichten: API-Key und deviceId

Bevor der Shelly die Sensordaten vom air-Q pro abrufen kann, benötigst du zwei Dinge: API-Key generieren Der API-Key ist erforderlich, um autorisiert auf die air-Q Cloud API zugreifen zu können. So erstellst du ihn Schritt für Schritt: - Melde dich unter 👉 https://my.air-q.com mit deinem air-Q Konto an - Öffne direkt die Seite 👉 https://my.air-q.com/api-keys - Vergib einen eindeutigen Schlüsselnamen – z. B. „Shelly-Integration“ - Klicke auf „Generate“, um den Key zu erstellen - Der generierte API-Key wird einmalig angezeigt - Kopiere ihn über die kleine Schaltfläche neben dem Textfeld - Bestätige den Dialog mit „OK“ – der Key ist nun aktiv

📌 Wichtig: Der Key wird nur einmal angezeigt – speichere ihn direkt sicher ab. Du kannst ihn später nicht mehr einsehen, nur löschen und neu generieren. deviceId aus dem air-Q Webfrontend auslesen Die deviceId ist die eindeutige Kennung deines air-Q Geräts – sie wird benötigt, um gezielt Daten über die API abzufragen. So findest du die deviceId direkt im Gerät: - Ermittle die IP-Adresse deines air-Q (z. B. über die Geräteübersicht deines Routers) - Öffne die IP-Adresse im Browser, z. B. http://192.168.1.123 - Gib das beim Setup vergebene Gerätekennwort ein - Standard: airqsetup - Klicke im linken Menü auf „Geräteinfos“ - Scrolle nach unten bis zum Abschnitt „id“ - Kopiere die angezeigte Zeichenkette - Speichere sie – du benötigst sie gleich im Skript

✅ Jetzt hast du sowohl den API-Key als auch die deviceId – damit bist du bereit, um den Datenabruf über die API im Shelly-Skript umzusetzen.

Test mit Postman: API-Zugriff ohne Shelly prüfen

Bevor wir das Skript auf dem Shelly Plug S einrichten, lohnt es sich, die API-Anfrage zunächst mit Postman zu testen. Das ist besonders praktisch, um zu prüfen, ob der API-Key korrekt ist und die deviceId stimmt – ganz ohne mögliche Fehlerquellen durch das Shelly-Skript. So geht’s: - Öffne Postman und erstelle eine neue Anfrage - Wähle als Methode GET - Gib als URL folgende Adresse ein (mit deiner deviceId): https://air-q-cloud.de/open_api/v2/devices//sensordata/latest - Wechsle zum Tab „Headers“ - Füge dort den API-Key ein: - Key: Api-Key - Value: dein generierter API-Key - Klicke auf „Send“

Ergebnis: Wenn alles korrekt ist, erhältst du als Antwort ein JSON-Objekt, das die aktuellsten Sensordaten deines air-Q pro enthält – z. B. Temperatur, Luftfeuchtigkeit, CO₂, VOC, etc. {"deviceid":"17a939b6aec50bd8f7e0d60ecb24d141","id":1720737583,"status":"","datetime":"2025-08-19T16:54:20+00:00","timestamp":1755622460000,"uptime":48010,"temperature":22.713,"ch2o_m10":31.1,"co":0.18696,"co2":1364.8,"dco2dt":26.35,"dewpt":15.981,"dhdt":0.15,"health":828,"humidity":64.97,"humidity_abs":13.194,"no2":28.65,"o3":6.5,"performance":302,"pm1":2,"pm10":3.1,"pm2_5":2.2,"pressure":995.13,"sound":50.18,"sound_max":55.1,"tvoc":231,"typps":2.6} So kannst du bequem prüfen, ob dein Setup korrekt ist, bevor du das Shelly-Skript ausführst.

Wechsel zum Shelly

Nachdem der API-Zugriff auf den air-Q pro in Postman erfolgreich getestet wurde, geht es nun an die eigentliche Umsetzung auf dem Shelly Plug S Gen3. Ich verwende bewusst dieses Modell, da es den Vorteil eines integrierten Schuko-/Euro-Steckers bietet. So kannst du einen Verbraucher – wie z. B. einen Luftentfeuchter – direkt anschließen, ganz ohne zusätzliche Verkabelung. Der Plug S Gen3 ist für 230 V / 12 A (bis zu 2500 W) ausgelegt und eignet sich damit hervorragend für klassische Haushaltsgeräte.

Shelly Outdoor Plug S Gen3 & Shelly Plug S MTR Gen3 Zugriff auf das Webfrontend Um das Shelly Script einzurichten, benötigen wir das Webinterface des Geräts. Dieses erreichst du über die IP-Adresse deines Shelly im lokalen Netzwerk. So findest du die IP-Adresse: - Über deinen Router (z. B. Fritzbox → Heimnetz → Netzwerk → Geräte) - Alternativ über die Shelly Cloud App, wenn dein Gerät dort eingebunden ist Gib die IP-Adresse deines Shelly Plug S in die Adresszeile deines Browsers ein, z. B.: http://192.168.178.112 Du gelangst nun zum lokalen Webinterface deines Shelly. Wähle dort im linken Menü den Punkt „Scripts“ aus. Anschließend klickst du auf „Create script“, um ein neues Shelly Script zu erstellen.

Shelly Webfrontend Das Shelly Script im Detail: Luftentfeuchter automatisch aktivieren Nachfolgend findest du das vollständige Script, das auf einem Shelly Plug S Gen3 ausgeführt wird. Es fragt in regelmäßigen Abständen die aktuelle Luftfeuchtigkeit vom air-Q pro über die offizielle API ab und schaltet den angeschlossenen Luftentfeuchter automatisch ein oder aus, abhängig vom gemessenen Wert. Das Skript ist so aufgebaut, dass es leicht angepasst werden kann – beispielsweise für andere Sensorwerte wie CO₂ oder TVOC sowie für andere Shelly-Geräte mit Relaisfunktion. // Grenzwert für Luftfeuchtigkeit – ab diesem Wert wird das Relais aktiviert const ACTIVATION_HUMIDITY = 50; // API-Verbindungsdaten: deviceId, URL-Template und API-Key const CONNECTION_DATA = { deviceId: "abc", url: "https://air-q-cloud.de/open_api/v2/devices/viceId%/sensordata/latest", apikey: "def" }; // Abfrageintervall in Millisekunden (600.000 ms = 10 Minuten) const POLLING_INTERVAL = 600000; // Ziel-URL wird durch Ersetzen des Platzhalters viceId% erzeugt let targetUrl = CONNECTION_DATA.url.replace("viceId%", CONNECTION_DATA.deviceId); // Parameter für HTTP-Anfrage an die air-Q API let parameter = { method: "GET", url: targetUrl, headers: { "Content-Type": "application/json", "Api-Key": CONNECTION_DATA.apikey } }; // Funktion zum Schalten des Relais function toggleRelais(status) { let shellyParameter = { id: 0, // ID des zu steuernden Schalters (i. d. R. 0 bei einfachen Geräten) on: status // true = einschalten, false = ausschalten }; Shelly.call("Switch.Set", shellyParameter); } // Hauptfunktion: Luftfeuchtigkeit vom air-Q abrufen und ggf. Relais schalten function receiveAirQData() { Shelly.call("HTTP.Request", parameter, function(result, error_code, error_message) { if (error_code != 0) { print("Fehler beim Senden der Daten: " + error_message); // Fehler beim Request } else { print("Daten erfolgreich gesendet."); let json = JSON.parse(result.body); // JSON-Antwort verarbeiten let humidity = json.humidity; print("rel. Luftfeuchtigkeit: " + humidity + "%"); toggleRelais(humidity > ACTIVATION_HUMIDITY); // Vergleich & Schaltvorgang } }); } // Wiederholung der Abfrage alle POLLING_INTERVAL Millisekunden Timer.set(POLLING_INTERVAL, true, receiveAirQData); Read the full article

#air-Qpro #Shelly #SmartHome

Luftqualität messen und reagieren: air-Q pro + IFTTT im Praxisbeispiel

Der air-Q pro sieht auf den ersten Blick aus wie ein moderner Luftsensor – schlicht, stylisch, kompakt. Doch was in ihm steckt, geht weit über klassische CO₂-Messgeräte hinaus. Über die bunten LEDs an allen Seiten kann man sich die aktuellen Luftwerte zwar anzeigen lassen – wenn auch auf etwas kryptische Weise. Aber das wirklich coole Feature liegt etwas versteckt: IFTTT. Neben Amazon Alexa und Google Home taucht es eher unauffällig auf der Verpackung auf – und doch steckt genau hier das größte Potenzial für alle, die mehr aus ihren Sensordaten machen wollen. Automatisch auf schlechte Luft reagieren, Warnungen verschicken oder smarte Geräte im Haus steuern – ganz ohne Programmierkenntnisse. https://youtu.be/fIAeu1MS8sU In diesem Beitrag zeige ich dir, wie du mit wenigen Klicks eine E-Mail-Benachrichtigung bei schlechter Luftqualität einrichtest – als ersten Schritt in Richtung vollautomatisiertes Smart Home mit dem air-Q pro.

air-Q pro - Ansicht von der Seite

air-Q pro - Ansicht von Oben

air-Q pro - Ansicht von Unten Transparenz-Hinweis: Das in diesem Beitrag vorgestellte Gerät wurde mir von der Corant GmbH kostenfrei für ein Review zur Verfügung gestellt. Die Inhalte und Meinungen in diesem Beitrag basieren auf meinen eigenen Erfahrungen und wurden nicht beeinflusst. Nach Abschluss der Beitragsreihe sende ich das Gerät an den Hersteller zurück.

Was ist IFTTT – und warum ist das so praktisch?

IFTTT steht für „If This Then That“ – also: „Wenn dies passiert, dann das.“ Ein Dienst, der es dir erlaubt, Aktionen zwischen verschiedenen Geräten und Plattformen zu automatisieren, ganz ohne Programmierkenntnisse. Der große Vorteil: IFTTT verbindet Dienste, die normalerweise nichts voneinander wissen – z. B. ein Luftanalysator mit einer E-Mail-Benachrichtigung, einer Lampe, einem Ventilator, oder einem smarten Shelly-Schalter. Ich habe IFTTT bereits in mehreren meiner Beiträge vorgestellt – z. B. bei der Verbindung von Sensoren mit Shelly-Produkten oder der E-Mail-Benachrichtigung im DIY-Briefkastenprojekt. Die Möglichkeiten sind nahezu grenzenlos, besonders für alle, die ihr Zuhause smarter machen möchten. - Arduino UNO R4 WiFi Push-Benachrichtigungen: Verbindung zu Pushbullet per IFTTT erstellen - AZ-Envy – Benachrichtigung per IFTTT versenden Mit dem air-Q pro wird IFTTT richtig spannend, denn: Der Sensor kann bei Grenzwertüberschreitungen automatisch Aktionen auslösen – etwa: - Eine Warn-E-Mail senden - Ein Lüftungssystem über Shelly aktivieren - Einen Lichtalarm auslösen - Oder auch ein Google Sheet mit Messwerten füllen Und das Beste: Du brauchst dazu keine einzige Zeile Code.

Was wird benötigt?

Um IFTTT mit deinem air-Q pro zu nutzen, brauchst du nur wenige Dinge: - ✅ Einen IFTTT-Account Die Registrierung ist kostenlos und schnell erledigt. Du kannst dich entweder mit Benutzername und Passwort anmelden – oder bequem per Google-, Apple- oder Facebook-Konto. - ✅ Zugangsdaten zu deinem air-Q Konto Diese hast du bereits beim Einrichten des Geräts erstellt. Sie werden benötigt, um den air-Q Service in IFTTT zu aktivieren und auf deine Messwerte zuzugreifen. - ✅ Ein eingerichteter und verbundener air-Q pro, der bereits aktiv Daten sendet Wichtig: Einige Sensoren benötigen nach dem Einschalten eine Aufwärmzeit von mehreren Minuten, bevor sie verwertbare Daten liefern. Erst dann stehen diese auch in IFTTT zur Verfügung.

IFTTT - Login Page

air-Q mit IFTTT verbinden und direkt ein Applet erstellen

Am einfachsten verbindest du dein air-Q Konto mit IFTTT, indem du gleich ein erstes Applet erstellst. Das hat den Vorteil, dass du die Verbindung direkt testen kannst und nicht separat über die Service-Seite gehen musst. Hier zeige ich dir, wie du Schritt für Schritt ein einfaches Applet erstellst, das dir eine E-Mail schickt, sobald ein bestimmter Messwert – z. B. der VOC-Wert – einen Grenzwert überschreitet.

Nachdem du dich erfolgreich bei https://ifttt.com registriert und angemeldet hast, klicke oben rechts auf „Create“, um ein neues Applet zu erstellen. Du befindest dich nun im Applet-Wizard, der dich Schritt für Schritt durch die Erstellung führt. Im ersten Schritt legen wir die Bedingung fest, bei der eine Aktion ausgelöst werden soll. Klicke dazu im Bereich „If This“ auf die Schaltfläche „Add“.

Im nächsten Schritt suchen wir nach dem Service „air-Q“. Gib dazu einfach „air-Q“ in das Suchfeld ein – der Dienst wird dir dann als Kachel mit Logo angezeigt. Klicke auf die air-Q Kachel, um diesen Dienst als Auslöser auszuwählen. Nachdem du den air-Q Service ausgewählt hast, kannst du nun den konkreten Auslöser (Trigger) bestimmen. Für unser Beispiel – eine E-Mail-Benachrichtigung bei einer bestimmten Temperatur – wählen wir die vordefinierte Option „Sensor measurement“ aus. Damit reagiert das Applet auf einen bestimmten Messwert eines Sensors.

Jetzt ist es an der Zeit, deinen air-Q Account mit IFTTT zu verknüpfen. Klicke dazu einfach auf die Schaltfläche „Connect“. Nach dem Klick wirst du zur Login-Seite von air-Q weitergeleitet – dort geht’s im nächsten Schritt weiter. Auf der neu geöffneten Login-Seite gibst du jetzt die Zugangsdaten deines air-Q Kontos ein, die du beim Einrichten deines Geräts erstellt hast. Bestätige den Login anschließend mit einem Klick auf „Sign in“.

Nachdem du dich erfolgreich angemeldet hast, ist die Verbindung zwischen IFTTT und deinem air-Q Konto hergestellt. Du wirst nun zu einer Maske weitergeleitet, in der du den eigentlichen Trigger definierst. Dort findest du: - Eine Dropdown-Liste mit deinen verbundenen Geräten (z. B. „air-Q pro Wohnzimmer“) - Eine zweite Dropdown-Liste mit allen verfügbaren Sensorwerten (z. B. Temperatur, CO₂, VOC usw.) - Eine Auswahlmöglichkeit, um eine Bedingung festzulegen: - größer als (>) - kleiner als ( 28 °C) - Auszuführende Aktion (z. B. E-Mail senden) Wenn alles passt, klicke auf „Finish“, um dein Applet zu speichern und zu aktivieren. Dein Applet ist nun automatisch aktiviert und erscheint in deiner Übersicht. Du kannst es später jederzeit mit dem Schieberegler „Connected“ bequem deaktivieren oder wieder einschalten – ganz ohne es löschen zu müssen. In meinem Fall war die aktuelle Umgebungstemperatur höher als der eingestellte Schwellenwert – und schon wenige Sekunden später kam auch schon die Benachrichtigungs-E-Mail an. So einfach funktioniert die Automatisierung mit air-Q und IFTTT.

Fazit & Ausblick

Mit wenigen Klicks lässt sich der air-Q pro über IFTTT in ein echtes smarthome-fähiges Warnsystem verwandeln – ganz ohne Programmierkenntnisse. In diesem Beispiel habe ich gezeigt, wie einfach sich eine E-Mail-Benachrichtigung einrichten lässt, wenn ein Sensorwert – wie etwa die Temperatur – einen bestimmten Schwellenwert überschreitet. Die Möglichkeiten gehen aber noch viel weiter: Durch die Integration von IFTTT lassen sich smarte Aktionen und Automatisierungen realisieren, die echten Mehrwert schaffen – für Komfort, Sicherheit und Energieeffizienz. Ausblick: Luftentfeuchter automatisch steuern Im nächsten Beitrag zeige ich dir, wie du mithilfe des Luftfeuchtigkeitssensors im air-Q pro und einem smarten Shelly-Schalter deinen elektrischen Luftentfeuchter automatisch einschalten kannst – immer dann, wenn die relative Luftfeuchtigkeit über einen bestimmten Wert steigt. So wird aus Luftanalyse konkrete Aktion – ganz im Sinne eines intelligenten und reaktiven Smart Homes. Read the full article

#air-Q #air-Qpro #automatisierung #IFTTT #SmartHome

Luftqualität live: air-Q pro Daten via REST abrufen und anzeigen

Wer meinen air-Q pro im ausführlichen Review schon kennt, weiß: Das Gerät misst beeindruckend viele Werte – von CO₂ und TVOC über Temperatur und Luftfeuchte bis hin zu Feinstaub, Lärm und Luftdruck. In diesem Beitrag gehen wir den nächsten Schritt: Wir bringen diese Messdaten live auf ein LCD1602-Display – direkt dort, wo du sie brauchst, ohne App und ohne Cloud. Als Anzeige nutze ich mein universelles MakerDisplay. Das Prinzip ist simpel: Der air-Q liefert die Daten, ein kleines Python-Skript holt sie per REST ab, entschlüsselt sie und schickt sie per HTTP ans Display. So rotieren die 13 Messgrößen plus die beiden virtuellen Werte „Gesundheit“ und „Leistung“ nacheinander über zwei Zeilen – kompakt, gut lesbar und jederzeit im Blick. Ziel ist eine pragmatische Lösung für Büro, Werkstatt oder Hobbyraum: einschalten, hinschauen, fertig. Im weiteren Verlauf zeige ich dir Schritt für Schritt, wie die Daten abgeholt, sinnvoll benannt und fürs 16×2-Display aufbereitet werden – inklusive Script und Tipps für die Praxis.

Transparenz-Hinweis: Der air-Q pro wurde mir von der Corant GmbH kostenfrei zur Verfügung gestellt. Dieser Beitrag ist redaktionell unabhängig; es gab keine inhaltlichen Vorgaben und keine Bezahlung. Nach Veröffentlichung des letzten Beitrags zu dieser Reihe sende ich das Testgerät an die Corant GmbH zurück.

air-Q pro - Ansicht von vorn

air-Q pro - Ansicht von Oben

air-Q pro - Ansicht von Unten

Daten vom air-Q pro laden

Der air-Q pro stellt seine Messwerte lokal im Netzwerk bereit—typisch unter http:///data. Der Haken: Die Antwort ist nicht direkt lesbar. Du bekommst ein kurzes JSON, dessen Feld content eine Base64-Zeichenkette enthält. Darin steckt wiederum ein AES-256-CBC-verschlüsseltes JSON mit allen Messwerten.

air-Q pro - verschlüsselte Messdaten

Was bedeutet das konkret?

- HTTP-GET an /data → JSON mit content. - Base64 dekodieren → bekommst Bytes: IV || CIPHERTEXT. - AES-256-CBC entschlüsseln - IV = die ersten 16 Bytes. - Key = aus deinem air-Q-Passwort erzeugt (UTF-8, auf 32 Bytes aufgefüllt/abgeschnitten). - PKCS#7-Padding entfernen, Ergebnis als UTF-8 interpretieren. - JSON parsen → jetzt hast du alle Felder (13 Messgrößen + 2 virtuelle Werte). Warum verschlüsselt? Der Hersteller schützt so die Daten selbst im lokalen Netz. Offiziell ist das nicht dokumentiert; naheliegend sind Datenschutz/Manipulationsschutz. Praktisch heißt das für uns: erst entschlüsseln, dann nutzen. Schnelltest: Encrypted-Antwort ansehen In einer PowerShell Konsole oder unter einem Linux Terminalfenster kann man sich mit curl recht einfach die Daten wie folgt laden: curl http://192.168.178.108/data PowerShell 7.5.2 PS C:Usersstefa> curl http://192.168.178.108/data {"content":"mOcmtRiI43ER8vG1bytSba0UcqWTRJ1BdamyRrrXnfPquIjVXWtIb0f3yYagFGlx7Jx80jAZ...kBgM"} PS C:Usersstefa>

Minimalbeispiel (Python): Abrufen & Entschlüsseln

Voraussetzung: PyCryptodome ist installiert (pip install pycryptodome). Der air-Q liefert die Daten unter http:///data. Das Feld content enthält Base64 + AES-256-CBC-verschlüsseltes JSON. #!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Minimalbeispiel: air-Q pro Daten laden und entschlüsseln. Ergebnis: Vollständiges Messwerte-JSON auf der Konsole. """ import base64 import json import http.client from Crypto.Cipher import AES # Paket: pycryptodome AIRQ_IP = "192.168.178.108" # dict: """Holt das äußere JSON vom air-Q (mit dem Feld 'content').""" conn = http.client.HTTPConnection(ip_adresse, timeout=5) try: conn.request("GET", "/data") resp = conn.getresponse() return json.loads(resp.read()) finally: conn.close() def entschluessle_content(content_b64: str, passwort: str) -> dict: """Base64 → AES-256-CBC entschlüsseln → JSON als dict zurückgeben.""" blob = base64.b64decode(content_b64) iv, ciphertext = blob, blob cipher = AES.new(_erzeuge_aes_schluessel(passwort), AES.MODE_CBC, iv) plaintext = cipher.decrypt(ciphertext) plaintext = _entferne_pkcs7_padding(plaintext) return json.loads(plaintext.decode("utf-8")) if __name__ == "__main__": roh = hole_rohantwort(AIRQ_IP) daten = entschluessle_content(roh, AIRQ_PASSWORT) print(json.dumps(daten, ensure_ascii=False, indent=2)) Auf der Konsole werden nun die entschlüsselten Messdaten im JSON-Format angezeigt.

air-Q pro - Messdaten im JSON-Format

Messwerte ans MakerDisplay senden

Nachdem wir die Daten erfolgreich empfangen und entschlüsselt haben, können wir sie entweder auf dem LCD1602 (MakerDisplay) anzeigen oder parallel als CSV lokal mitschreiben. Beides hat Vorteile: - Display: Live-Überblick, ohne App/Cloud. - CSV: Verlauf auswerten (z. B. in Excel). Darum steuern wir das Verhalten per Parametern – und behalten ein einziges, sauberes Skript. Hinweis: Du musst nur IP-Adresse deines air-Q und dein Geräte-Kennwort (Standard: airqsetup) eintragen. Für die Anzeige trägst du die URL deines MakerDisplays ein (z. B. http://192.168.178.96/anzeige). fertiges Projekt - Messdaten des air-Q pro am LCD1602 Display visualisierenHerunterladen

air-Q-pro Messdaten am LCD1602 Display visualisieren Quellcode #!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Titel: Luftqualität live: air-Q pro Daten via REST abrufen, entschlüsseln und weiterverarbeiten Autor: Stefan Draeger Blogartikel: https://draeger-it.blog/luftqualitaet-live-air-q-pro-daten-via-rest-abrufen-und-anzeigen/ Beschreibung: Dieses Skript lädt Sensordaten vom air-Q pro, entschlüsselt sie (AES-256-CBC) und liefert ein klar strukturiertes Objekt (AirQMessung) zurück. Die Anzeige/Weiterverarbeitung (CSV, LCD) ist bewusst entkoppelt, damit du das Objekt flexibel verwenden kannst. """ from __future__ import annotations import argparse import base64 import csv import http.client from dataclasses import dataclass from datetime import datetime, timezone from pathlib import Path from typing import Any, Dict, Optional import urllib.request from typing import Tuple from Crypto.Cipher import AES # pycryptodome # -------------------------------------------------------------------- # Konfiguration (Defaults für CLI; produktiv per .env/Umgebungsvariablen) # -------------------------------------------------------------------- STANDARD_AIRQ_IP = "192.168.178.108" STANDARD_AIRQ_PASSWORT = "draeger1980" AIRQ_HTTP_PORT = 80 AIRQ_HTTP_PFAD = "/data" AIRQ_HTTP_TIMEOUT_S = 8 AIRQ_HTTP_RETRIES = 3 AES_SCHLUESSEL_LAENGE = 32 AES_BLOCKGROESSE = 16 # -------------------------------------------------------------------- # Domänenmodell # -------------------------------------------------------------------- @dataclass(frozen=True) class AirQMessung: """ Repräsentiert eine Messung des air-Q. - zeitpunkt_local / zeitpunkt_utc: Zeitpunkt (aus 'timestamp' in ms) - device_id, uptime_s: Gerätemetadaten - rohwerte: Original-JSON (entschlüsselt) - werte: deutsch beschriftete, einheitenklare Basiswerte (für CSV/LCD) - status: Warmup-/Hinweistexte je Sensor """ zeitpunkt_local: datetime zeitpunkt_utc: datetime device_id: Optional uptime_s: Optional rohwerte: Dict werte: Dict status: Dict # -------------------------------------------------------------------- # Datenabruf & Entschlüsselung # -------------------------------------------------------------------- def _entferne_pkcs7_padding(daten: bytes) -> bytes: """Entfernt PKCS#7-Padding sicher im Byte-Kontext.""" return daten] def _erzeuge_aes_schluessel(passwort: str) -> bytes: """Erzeugt einen 32-Byte-AES-Schlüssel aus dem Passwort (auffüllen/abschneiden).""" key = passwort.encode("utf-8") return key + b"0" * (AES_SCHLUESSEL_LAENGE - len(key)) if len(key) Dict: """Entschlüsselt den base64-kodierten 'content' des air-Q und liefert das JSON als Dict.""" verschluesselt = base64.b64decode(base64_text) iv, payload = verschluesselt, verschluesselt cipher = AES.new(key=_erzeuge_aes_schluessel(passwort), mode=AES.MODE_CBC, IV=iv) entschluesselt = cipher.decrypt(payload) json_text = _entferne_pkcs7_padding(entschluesselt).decode("utf-8") return json.loads(json_text) def _hole_rohdaten(ip_adresse: str) -> Dict: """ Holt das äußere JSON (mit 'content') fest über http:///data (Port 80). Baut Retries und aussagekräftige Fehler ein. """ last_err: Optional = None for attempt in range(1, AIRQ_HTTP_RETRIES + 1): conn = http.client.HTTPConnection(ip_adresse, port=AIRQ_HTTP_PORT, timeout=AIRQ_HTTP_TIMEOUT_S) try: conn.request("GET", AIRQ_HTTP_PFAD) resp = conn.getresponse() body = resp.read() if resp.status == 200: return json.loads(body) raise RuntimeError(f"HTTP {resp.status} {resp.reason} auf {AIRQ_HTTP_PFAD}") except (socket.timeout, TimeoutError, OSError, RuntimeError, json.JSONDecodeError) as e: last_err = e # kleiner Backoff zwischen den Versuchen time.sleep(0.5 * attempt) finally: try: conn.close() except Exception: pass raise ConnectionError( f"air-Q unter http://{ip_adresse}{AIRQ_HTTP_PFAD} nicht erreichbar (Port 80). " f"Letzter Fehler: {last_err}" ) def hole_airq_objekt(ip_adresse: str, passwort: str) -> Dict: """ EINSTIEGSPUNKT für Datenzugriff: - Holt die Rohantwort - Entschlüsselt 'content' - Gibt das entschlüsselte JSON (als Dict) zurück """ rohdaten = _hole_rohdaten(ip_adresse) return _entschluessle_content(rohdaten, passwort) # -------------------------------------------------------------------- # Normierung & Beschriftung # -------------------------------------------------------------------- # Mapping: JSON-Key -> (deutscher Name, Einheit) MAPPING: Dict]] = { "pm1": ("PM1.0", "µg/m³"), "pm2_5": ("PM2.5", "µg/m³"), "pm10": ("PM10", "µg/m³"), "TypPS": ("Ø Partikelgröße", "µm"), "dewpt": ("Taupunkt", "°C"), "temperature": ("Temperatur", "°C"), "humidity": ("Relative Luftfeuchte", "%"), "humidity_abs":("Absolute Luftfeuchte", "g/m³"), "pressure": ("Luftdruck", "hPa"), "sound": ("Lärmpegel", "dB(A)"), "sound_max": ("Lärmpegel max (2 min)", "dB(A)"), "tvoc": ("TVOC (flüchtige organische Verbindungen)", "ppb"), "co": ("CO (Kohlenmonoxid)", "ppm"), # korrigiert "co2": ("CO₂ (Kohlendioxid)", "ppm"), # korrigiert "health": ("Gesundheitsindex", None), "performance": ("Leistungsindex", None), "dHdt": ("Δ absolute LF", "mg/m³/s"), "dCO2dt": ("Δ CO₂", "ppb/s"), "uptime": ("Betriebszeit", "s"), "measuretime": ("Messdauer letzter Durchlauf", "ms"), "DeviceID": ("Geräte-ID", None), "timestamp": ("Zeitstempel (ms)", "ms"), } def _wert_aus_array_oder_skalar(v: Any) -> Tuple]: """ air-Q liefert häufig . Gibt (basiswert, unsicherheit) zurück. """ if isinstance(v, (list, tuple)) and len(v) >= 1: basis = v unsicherheit = v if len(v) > 1 else None return basis, unsicherheit return v, None def _normalisiere_status(raw) -> Dict: """ Wandelt das 'Status'-Feld in ein Dict um. - Dict: Schlüssel/Werte als Strings - String/Number/sonstiges: {"status": ""} - Liste/Tuple: {"status_0": "...", "status_1": "...", ...} - None: {} """ if raw is None: return {} if isinstance(raw, dict): return {str(k): str(v) for k, v in raw.items()} if isinstance(raw, (list, tuple)): return {f"status_{i}": str(v) for i, v in enumerate(raw)} # alles andere (z. B. "OK") return {"status": str(raw)} def normiere_messung(entschluesselt: Dict) -> AirQMessung: """ Wandelt das entschlüsselte Dict in eine AirQMessung: - Zeit aus 'timestamp' (ms) → UTC + lokale Zeit - deutsch beschriftete, einheitenklare Basiswerte - Statusmeldungen (Warmup etc.) unter 'Status' """ # Zeitstempel (ms) → UTC/local ts_ms = entschluesselt.get("timestamp") if isinstance(ts_ms, (int, float)): ts_utc = datetime.fromtimestamp(ts_ms / 1000, tz=timezone.utc) else: ts_utc = datetime.now(tz=timezone.utc) ts_local = ts_utc.astimezone() # Status-Hinweise status_norm = _normalisiere_status(entschluesselt.get("Status")) # Beschriftete Werte werte: Dict = {} for key, (name_de, einheit) in MAPPING.items(): if key in entschluesselt: basiswert, _unsicherheit = _wert_aus_array_oder_skalar(entschluesselt) label = f"{name_de} ({einheit})" if einheit else name_de werte = basiswert return AirQMessung( zeitpunkt_local=ts_local, zeitpunkt_utc=ts_utc, device_id=str(entschluesselt.get("DeviceID")) if entschluesselt.get("DeviceID") else None, uptime_s=int(entschluesselt.get("uptime")) if entschluesselt.get("uptime") is not None else None, rohwerte=entschluesselt, werte=werte, status=status_norm, ) # -------------------------------------------------------------------- # Weiterverarbeitung (CSV / LCD-Stub) – optional # -------------------------------------------------------------------- def schreibe_csv_zeile(datei: Path, messung: AirQMessung, erstelle_header: bool = True) -> None: """ Schreibt eine Zeile in eine CSV-Datei (Delimiter ';'). - Erstellt optional beim ersten Mal einen Header. - 'zeitpunkt' wird als ISO-String vorangestellt. """ datei.parent.mkdir(parents=True, exist_ok=True) spalten = + sorted(messung.werte.keys()) schreibe_header = (not datei.exists()) and erstelle_header with datei.open("a", newline="", encoding="utf-8") as f: writer = csv.DictWriter(f, fieldnames=spalten, delimiter=";") if schreibe_header: writer.writeheader() zeile = {"zeitpunkt": messung.zeitpunkt_local.isoformat(timespec="seconds")} zeile.update({k: messung.werte.get(k, "") for k in spalten if k != "zeitpunkt"}) writer.writerow(zeile) # ------------------------------------------------------------ # 1) Anzeigezeilen aus Messung erzeugen # ------------------------------------------------------------ def formatiere_lcd_zeilen(messung: AirQMessung) -> Tuple: """ Baut zwei Textzeilen für ein 16x2 LCD. Da dein ESP 'scroll' unterstützt, dürfen die Zeilen länger sein; wir halten sie trotzdem kompakt & gut lesbar. """ # Werte robust lesen (falls mal etwas fehlt) co2 = messung.werte.get("CO₂ (Kohlendioxid) (ppm)") tvoc = messung.werte.get("TVOC (flüchtige organische Verbindungen) (ppb)") temp = messung.werte.get("Temperatur (°C)") rh = messung.werte.get("Relative Luftfeuchte (%)") # Schonend runden/formatieren def fmt(v, nd=0): if v is None or v == "-": return "-" try: return f"{round(float(v), nd)}" except Exception: return str(v) co2_s = fmt(co2, 0) tvoc_s = fmt(tvoc, 0) temp_s = fmt(temp, 1) rh_s = fmt(rh, 1) # Zeile 1 & 2 kompakt – darf länger sein (scroll) zeile1 = f"CO2:{co2_s}ppm TVOC:{tvoc_s}ppb" zeile2 = f"T:{temp_s}C rH:{rh_s}%" return zeile1, zeile2 # ------------------------------------------------------------ # 2) HTTP-POST an den ESP-Endpoint senden # ------------------------------------------------------------ def sende_an_lcd_http(lcd_url: str, zeile1: str, zeile2: str, modus: str = "scroll", anzeigedauer: int = 15, timeout_s: int = 5) -> None: """ Sendet die gewünschten LCD-Zeilen an den ESP (JSON-POST). Erwartet einen Endpoint wie: http://192.168.178.96/anzeige """ payload = { "zeile1": zeile1, "zeile2": zeile2, "modus": modus, # z.B. "scroll", "static", ... "anzeigedauer": anzeigedauer # Sekunden } daten = json.dumps(payload).encode("utf-8") req = urllib.request.Request( url=lcd_url, data=daten, headers={"Content-Type": "application/json"}, method="POST", ) try: with urllib.request.urlopen(req, timeout=timeout_s) as resp: # Antwort bei Bedarf auswerten: _ = resp.read() except HTTPError as e: # Hier gerne auf logging umstellen print(f"HTTP-Fehler beim Senden an LCD ({e.code}): {e.reason}") except URLError as e: print(f"Verbindungsfehler zum LCD: {e.reason}") except Exception as e: print(f"Unerwarteter Fehler beim LCD-POST: {e}") # ------------------------------------------------------------ # 3) Öffentliche Anzeige-Funktion (ersetzt den Stub) # ------------------------------------------------------------ def zeige_auf_lcd_http(messung: AirQMessung, lcd_url: str, modus: str = "scroll", anzeigedauer: int = 15) -> None: """ Erzeugt zwei Anzeigezeilen aus der Messung und sendet sie per HTTP an den ESP-LCD-Service. Read the full article

#air-Qpro #LCD1602 #Luftqualität #REST

Luftqualität messen wie ein Profi: Der air-Q pro im ausführlichen Review

Wer wissen möchte, wie es wirklich um die Luftqualität in den eigenen vier Wänden oder im Büro steht, kommt am air-Q pro kaum vorbei. Der AQ-2000 aus dem Hause Corant GmbH ist ein hochwertiges Luftmessgerät mit insgesamt 13 präzisen Sensoren und zwei zusätzlichen virtuellen Messgrößen. Neben klassischen Werten wie CO₂, Feinstaub und Temperatur erkennt der air-Q pro auch Heizgase sowie brennbare und explosive Gase – ein echter Profi unter den Luftanalysatoren. https://youtu.be/V472VrbFwQQ Mit einem Preis von rund 579 € richtet sich das Gerät an ambitionierte Anwender, die mehr wollen als ein nettes Gadget. Dank Smartphone- und Web-App ist die Bedienung komfortabel, die Auswertung der Messdaten übersichtlich – und sogar eine Integration in Smart-Home-Systeme ist möglich. In diesem Beitrag zeige ich, was der air-Q pro kann, wie einfach (oder komplex) die Einrichtung ist, und ob sich die Investition wirklich lohnt.

air-Q pro - Ansicht von vorn

air-Q pro - Ansicht von der Seite

air-Q pro - Ansicht von Oben

air-Q pro - Ansicht von Unten

air-Q pro - RESET Taster und USB-C Schnittstelle Transparenzhinweis: Dieser Beitrag ist in Zusammenarbeit mit der Corant GmbH entstanden, die mir den air-Q pro Luftanalysator für ein Review zur Verfügung gestellt hat. Die Bewertung und Meinung in diesem Beitrag sind dennoch meine eigenen und wurden nicht durch das Sponsoring beeinflusst. Nach Abschluss des Tests wird das Gerät wieder zurückgesendet.

Was misst der air-Q pro genau? Alle 13 Sensoren im Überblick

Der air-Q pro gehört zu den leistungsstärksten Luftanalysatoren auf dem Markt und bringt insgesamt 13 physikalische Sensoren mit – ergänzt durch zwei virtuelle Messwerte. Damit liefert das Gerät ein umfassendes Bild der Raumluftqualität in Echtzeit. Anders als einfache CO₂-Messgeräte erkennt der air-Q pro auch gesundheitsschädliche Gase, Feinstaub, chemische Belastungen und sogar explosive Stoffe. Folgende Parameter werden mit dem air-Q pro erfasst: - CO₂ (Kohlendioxid) – wichtig für Konzentration und Wohlbefinden - Feinstaub (PM1, PM2.5, PM10) – besonders relevant bei Allergien oder Stadtlage - VOC (flüchtige organische Verbindungen) – entstehen z. B. durch Möbel, Reinigungsmittel - CO (Kohlenmonoxid) – gefährliches, farb- und geruchloses Gas - NO₂ (Stickstoffdioxid) – typisch bei Belastung durch Verkehr - O₂ (Sauerstoffgehalt) – ebenfalls entscheidend für die Atemluft - LPG, Methan & Wasserstoff – zur Erkennung von brennbaren und explosiven Gasen - Luftdruck, Temperatur und Luftfeuchtigkeit – Basiswerte zur Raumluftanalyse Zusätzlich berechnet der air-Q pro mithilfe dieser Rohdaten virtuelle Werte wie den air-Q Gesundheitsindex und einen Luftqualitätsindex, die komplexe Messwerte in leicht verständliche Aussagen umwandeln.

Unboxing: Der erste Eindruck zählt

Der air-Q pro kommt in einer aufgeräumten, hochwertigen Verpackung an – kein unnötiger Schnickschnack, sondern direkt auf den Punkt. Neben dem Gerät selbst liegt ein langes USB-C-Kabel, ein passender Netzadapter sowie eine kurze Anleitung bei. Mehr braucht es nicht, um sofort loszulegen.

Wer den Sensor per Smartphone einrichten möchte (was empfohlen wird), findet direkt in der Anleitung die Hinweise zur passenden air-Q App, die es für Android und iOS kostenlos gibt. Die App führt Schritt für Schritt durch die Inbetriebnahme und sorgt dafür, dass die ersten Messwerte schon nach wenigen Minuten abrufbar sind.

Ein Blick ins Innere: ESP32, MicroSD und modulare Sensorik

Neugierig wie ich bin, habe ich den air-Q pro einmal vorsichtig geöffnet – und wurde positiv überrascht. Im Inneren arbeitet ein ESP32-Mikrocontroller, der in der Maker- und IoT-Welt bestens bekannt ist. Das gesamte System läuft von einer 16 GB MicroSD-Karte, was zukünftige Firmware-Updates oder Erweiterungen erleichtert.

Hauptplatine des air-Q pro von Corant GmbH

RGB LED Ring des air-Q pro Besonders clever: Die insgesamt 13 Sensoren sind modular aufgesteckt und nicht fest verlötet. Im Falle eines Defekts lässt sich ein Sensor also problemlos austauschen – ganz ohne das gesamte Gerät entsorgen zu müssen. Das spart nicht nur Kosten, sondern auch Ressourcen. Für ein Produkt in dieser Preisklasse ist das ein durchdachtes, nachhaltiges Design, das definitiv positiv hervorzuheben ist.

Einrichtung des air-Q pro: App oder Browser – du hast die Wahl

Im Lieferumfang des air-Q pro findest du in der kleinen Schachtel des Netzteils eine bebilderte Schnellstartanleitung, die beide möglichen Wege der Einrichtung beschreibt: - über die air-Q App (für Android und iOS) - oder alternativ über den Webbrowser im lokalen Netzwerk. Ich habe mich für die Einrichtung per Android-Smartphone entschieden. Dazu einfach im Google Play Store nach „air-Q App“ suchen und installieren. Ohne Konto möglich – mit Konto empfehlenswert Ein Konto ist für die Grundeinrichtung zwar nicht zwingend erforderlich, ich empfehle jedoch ausdrücklich, eines anzulegen. Das bietet langfristig Vorteile wie Zugriff auf Verlaufsdaten, Fernzugriff und die Nutzung erweiterter Funktionen (z. B. IFTTT oder API-Zugriffe). Einrichtung per App – mit Hindernis Die App führt dich über einen Setup-Wizard durch die Konfiguration. Die automatische Suche über den aufgedruckten QR-Code auf der Rückseite des Geräts hat bei mir jedoch mehrere Minuten in Anspruch genommen – nach drei erfolglosen Versuchen habe ich abgebrochen. Daraufhin habe ich das Gerät in den Werkszustand zurückgesetzt (RESET-Knopf ca. 15 Sekunden gedrückt halten) und den Vorgang mit einem zuvor erstellten Konto erneut gestartet – diesmal mit Erfolg: Das Gerät wurde sofort erkannt, verbunden und fast vollständig eingerichtet.

Letzter Schritt mit Wiederholungsversuchen Beim letzten Schritt der Konfiguration gab es erneut eine kurze Unterbrechung, das Gerät wurde „nicht gefunden“. Die App startet in diesem Fall jedoch automatisch bis zu 11 Wiederholungsversuche – offenbar ein bekanntes Phänomen, das die Software gut auffängt. Nach wenigen Sekunden war die Verbindung stabil.

Sensorstart & erste Messwerte: Geduld zahlt sich aus

Nach erfolgreicher Einrichtung beginnt der air-Q pro automatisch mit der Analyse der Raumluft. Die Sensoren erfassen dabei verschiedenste Werte – von CO₂ und Feinstaub bis hin zu flüchtigen organischen Verbindungen (VOC), Stickoxiden oder explosiven Gasen.

Allerdings: Nicht alle Sensoren liefern sofort verlässliche Daten. Einige benötigen eine kurze Aufwärmphase, bevor sie genaue Messwerte liefern können. In meinem Fall hat es bis zu 60 Minuten gedauert, bis sämtliche Sensoren vollständig initialisiert und aktiv waren. Die App informiert dabei transparent über den Status – inklusive Hinweisen, welche Sensoren sich noch im Startprozess befinden. Sobald alle Sensoren aktiv sind, erscheinen die Messwerte im Live-Dashboard und werden kontinuierlich aktualisiert.

Fazit & Ausblick: air-Q pro als Herzstück deiner Luftqualitäts-Automation

Nach der Einrichtung zeigt sich schnell: Der air-Q pro ist mehr als nur ein CO₂-Messgerät. Mit seinen 13 Sensoren liefert er umfassende Einblicke in die Raumluftqualität – zuverlässig, detailliert und visuell aufbereitet. Auch wenn die Einrichtung kleine Stolpersteine hatte, funktionierte sie am Ende reibungslos – die App wirkt durchdacht und funktionsstark. Besonders spannend wird es jetzt im nächsten Schritt: die Integration ins Smarthome. Der air-Q pro bietet Schnittstellen zu Amazon Alexa, Google Home und sogar IFTTT – damit ergeben sich viele Möglichkeiten, automatische Abläufe zu definieren, die auf die Luftqualität reagieren. Was kommt als Nächstes? Im nächsten Beitrag zeige ich dir, wie du mit IFTTT ganz einfach eine Automation erstellst, die z. B. bei erhöhtem VOC- oder CO-Wert automatisch einen smarten Shelly-Schalter aktiviert – etwa zum Einschalten einer Lüftung oder eines Warnsignals. So wird aus dem air-Q pro nicht nur ein Messgerät, sondern ein aktiver Bestandteil deines Smart Homes. Read the full article

#air-Qpro #Corant #Luftqualitätsmesser