Envimind – Intelligente Sensorik

Dokumentation

Voraussetzungen:

  1. Envimind-Konto: Du benötigst ein registriertes und aktiviertes Konto auf app.envimind.com.
  2. Dein Sensor: Dein physischer Sensor muss in der Lage sein, sich mit dem Netzwerk zu verbinden und MQTT-Nachrichten zu senden.
  3. Sensor-Firmware/Software: Du musst Zugriff auf den Code Deines Sensors haben, um die MQTT-Einstellungen zu konfigurieren.

Schritt 1: Sensor auf der Envimind-Plattform registrieren

Zuerst musst Du Deinen Sensor in der Envimind-Webanwendung bekannt machen. Dadurch erhält der Sensor eine eindeutige Identität und ein spezifisches MQTT-Topic, an das er seine Daten senden muss.

  1. Anmelden: Logge Dich in Dein Konto auf app.envimind.com ein.
  2. Geräteübersicht: Navigiere zum Bereich „Meine Geräte“.
  3. Eigenes Gerät hinzufügen: Klicke auf die Schaltfläche „Eigenes Gerät hinzufügen“.
  4. Namen vergeben: Gib einen aussagekräftigen Namen für Deinen Sensor ein (z.B. „Wohnzimmer ESP32“, „Balkon Wetterstation“).
  5. Speichern: Bestätige die Eingabe. Das System legt das Gerät an und leitet Dich normalerweise zur Detailseite des neuen Geräts weiter.

Wichtig: In diesem Schritt wird noch kein MQTT-Topic von Dir benötigt. Das System generiert das korrekte Topic automatisch, nachdem das Gerät angelegt wurde.

Schritt 2: MQTT-Konfigurationsdaten abrufen

Nachdem das Gerät angelegt wurde, musst Du die spezifischen MQTT-Daten von der Plattform abrufen, die Dein Sensor zum Senden benötigt.

  1. Gerätedetails aufrufen: Gehe zur Detailansicht des Sensors, den Du gerade erstellt hast (entweder direkt nach dem Speichern oder über die Liste „Meine Geräte“).
  2. MQTT-Daten finden: Suche auf der Detailseite nach einem Abschnitt wie „MQTT Konfiguration“ oder „Geräteinformationen“. Dort findest Du die benötigten Angaben:
    • Broker Adresse: mqtt.envimind.com
    • Broker Port: 1883 (Standard-MQTT-Port, unverschlüsselt)
    • MQTT Publish Topic: Dies ist das wichtigste Feld. Es wird vom System generiert und hat typischerweise das Format:
      devices/<Deine_Benutzer_ID>/<Deine_Geräte_ID>/data
      Kopiere dieses Topic exakt! <Deine_Geräte_ID> ist die interne ID (PK), die auch auf der Detailseite angezeigt wird.
    • Username: (leer lassen – keine Authentifizierung erforderlich)
    • Password: (leer lassen – keine Authentifizierung erforderlich)
    • Payload Format: JSON (siehe Schritt 3)

Schritt 3: Sensor-Firmware/Software konfigurieren

Nun musst Du die im vorherigen Schritt erhaltenen Informationen in die Software Deines Sensors eintragen. Die genaue Vorgehensweise hängt stark von Deiner Hardware und der verwendeten Programmiersprache bzw. Bibliothek ab (z.B. Arduino-IDE mit PubSubClient, MicroPython, Python mit paho-mqtt).

Trage die folgenden Werte in Deine Sensor-Konfiguration ein:

  1. MQTT Broker/Server: mqtt.envimind.com
  2. MQTT Port: 1883
  3. MQTT Topic: Das exakte Topic, das Du in Schritt 2 von der Gerätedetailseite kopiert hast (z.B. devices/5/12/data).
  4. Username: Leer lassen oder als leeren String („“) angeben.
  5. Password: Leer lassen oder als leeren String („“) angeben.
  6. Client ID (optional, aber empfohlen): Vergib eine eindeutige Client ID für jeden Sensor, z.B. MeinSensor_Wohnzimmer_<GeräteID>. Dies hilft bei der Fehlersuche auf dem Broker.
  7. Payload (Datenformat):
    Deine Sensordaten müssen als JSON-Objekt (Dictionary) gesendet werden. Die Schlüssel (Keys) im JSON müssen mit den Feldnamen übereinstimmen, die Envimind erwartet.
    • Erwartete Schlüssel (Beispiele):
      temperature, humidity, pressure, co2, voc_index, nox_index, pm1, pm25, pm4, pm10
      • Wichtig: Sende nur die Schlüssel, für die Dein Sensor auch Werte liefert.
      • Der Schlüssel für PM2.5 im JSON sollte pm25 sein (ohne Punkt). Die Plattform wandelt pm2.5 intern um, aber pm25 ist sicherer.
      • Die Werte sollten als Zahlen (Integer oder Float) gesendet werden.
    • Timestamp (optional):
      Du kannst einen timestamp-Schlüssel mit dem Zeitstempel der Messung im ISO 8601 Format hinzufügen (z.B. 2025-04-07T14:52:22Z oder 2025-04-07T16:52:22+02:00). Wenn kein Timestamp gesendet wird, verwendet die Envimind-Plattform den Zeitpunkt des Nachrichteneingangs.
  8. Beispiel JSON-Payload:
    { "temperature": 21.5, "humidity": 45.8, "pressure": 1013.2, "co2": 550, "pm25": 12.3, "timestamp": "2025-04-07T14:52:22Z" }

Schritt 4: Unterstützte Sensortypen festlegen (optional, aber empfohlen)

Damit die Envimind-Plattform weiß, welche Daten von Deinem Sensor zu erwarten sind und wie diese am besten dargestellt werden können, solltest Du die unterstützten Messwerte in den Geräteeinstellungen festlegen.

  1. Gerätedetails: Gehe zur Detailansicht Deines Sensors auf app.envimind.com.
  2. Einstellungen: Klicke auf die Schaltfläche „Einstellungen“.
  3. Unterstützte Sensorwerte: Aktiviere die Checkboxen für alle Messwerte (JSON-Schlüssel), die Dein Sensor tatsächlich sendet (z.B. „Temperatur“, „Luftfeuchtigkeit“, „CO2“).
  4. Speichern: Speichere die Einstellungen.

Schritt 5: Testen und Verifizieren

  1. Sensor starten: Stelle sicher, dass Dein Sensor mit dem Netzwerk verbunden ist und die konfigurierte Firmware läuft.
  2. Daten senden: Lass den Sensor einige Messwerte senden.
  3. Envimind prüfen: Gehe zur Detailseite Deines Sensors auf app.envimind.com.
  4. Chart/Tabelle: Nach kurzer Zeit sollten die ersten Datenpunkte im Diagramm und in der Datentabelle erscheinen. Wähle ggf. einen passenden Zeitraum (z.B. „Letzte Stunde“).

Aktuell unterstütze Werte:

Beschreibung des Werts Name des Felds im SensorData Model Erwarteter Key im JSON Payload
Temperatur temperature temperature
Relative Luftfeuchtigkeit humidity humidity
Luftdruck pressure pressure
Kohlenstoffdioxid (CO₂) co2 co2
Flüchtige organische Verbindungen (VOC – alter Wert) voc voc
Feinstaub PM1 pm1 pm1
Feinstaub PM2.5 pm25 pm2.5
Feinstaub PM4 pm4 pm4
Feinstaub PM10 pm10 pm10
Stickoxide (NOx – alter Wert) nox nox
VOC Index voc_index voc_index
NOx Index nox_index nox_index

Fehlerbehebung (Troubleshooting)

  • Keine Daten kommen an:
    • Topic prüfen: Ist das MQTT-Topic in Deiner Sensor-Firmware exakt dasselbe wie auf der Gerätedetailseite? (Groß-/Kleinschreibung beachten, keine zusätzlichen Leerzeichen.)
    • Broker/Port prüfen: Sind mqtt.envimind.com und Port 1883 korrekt eingetragen?
    • Netzwerk: Kann Dein Sensor das Internet und den MQTT-Broker erreichen? (Firewall-Einstellungen prüfen, Port 1883 muss ausgehend erlaubt sein.)
    • JSON-Format: Ist die Payload ein gültiges JSON-Objekt? Validier Dein JSON z.B. mit einem Online-Tool. Sind die Werte Zahlen?
    • Server-Listener: Läuft der MQTT-Listener auf dem Envimind-Server? (Dies liegt außerhalb Deiner Kontrolle, aber es ist eine mögliche Fehlerquelle.)
    • Client ID: Nutzen mehrere Geräte dieselbe Client ID? Das kann zu Verbindungsproblemen führen.
  • Daten kommen an, aber werden nicht angezeigt:
    • Unterstützte Typen: Hast Du die korrekten Sensortypen in den Geräteeinstellungen auf der Website ausgewählt (Schritt 4)?
    • JSON-Schlüssel: Stimmen die Schlüssel in Deinem JSON exakt mit den erwarteten Schlüsseln überein (z.B. temperature, humidity, pm25)?

Beispiel Code für den Arduino oder ESP32 etc.

Um Daten deines Temperatur und Luftfeuchtigkeistsensors zum Beispiel dem DHT12 an die Envimind Plattform zu übermitteln kannst du folgenden Beispielcode für deinen ESP32 oder Arduino verwenden.

Stelle sicher, dass Du in der Arduino-IDE folgende Bibliotheken installiert hast:
ArduinoJson (zum Erzeugen der JSON-Nachricht)
WiFi (für die Netzwerkverbindung)
PubSubClient (für MQTT)

#include <WiFi.h>
#include <PubSubClient.h>
#include <Wire.h>
#include <ArduinoJson.h>

// WLAN-Konfiguration
const char* ssid = "DEINE_SSID";
const char* wifi_password = "DEIN_WLAN_PASSWORT";

// MQTT-Konfiguration
const char* mqtt_server = "mqtt.envimind.com";
const int mqtt_port = 1883;
const char* mqtt_topic = "devices/DEINE_BENUTZER_ID/DEINE_GERÄTE_ID/data"; // bitte anpassen

WiFiClient espClient;
PubSubClient client(espClient);

// Funktion: WLAN-Verbindung herstellen
void setup_wifi() {
  delay(10);
  Serial.println();
  Serial.print("Verbinde mit ");
  Serial.println(ssid);

  WiFi.begin(ssid, wifi_password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("");
  Serial.println("WLAN verbunden");
  Serial.print("IP-Adresse: ");
  Serial.println(WiFi.localIP());
}

// Funktion: MQTT-Verbindung herstellen
bool reconnect() {
  while (!client.connected()) {
    Serial.print("Versuche MQTT-Verbindung aufzubauen...");
    // Erzeuge eine eindeutige Client-ID
    String clientId = "ESP32Client-";
    clientId += String(random(0xffff), HEX);
    
    if (client.connect(clientId.c_str())) {
      Serial.println("Verbunden");
    } else {
      Serial.print("Fehler, rc=");
      Serial.print(client.state());
      Serial.println(" - erneut in 5 Sekunden versuchen");
      delay(5000);
    }
  }
  return true;
}

// Struktur für Sensordaten
struct DHT12Data {
  float temperature;
  float humidity;
};

// Funktion: DHT12-Daten auslesen über I2C
DHT12Data readDHT12() {
  DHT12Data data;
  // I2C-Adresse des DHT12 ist 0x5C
  Wire.beginTransmission(0x5C);
  Wire.write(0x00); // Startadresse
  Wire.endTransmission();
  
  Wire.requestFrom(0x5C, 5);
  if (Wire.available() >= 5) {
    uint8_t hum_int = Wire.read();
    uint8_t hum_dec = Wire.read();
    uint8_t temp_int = Wire.read();
    uint8_t temp_dec = Wire.read();
    uint8_t checksum = Wire.read();

    uint8_t sum = hum_int + hum_dec + temp_int + temp_dec;
    if (sum == checksum) {
      data.humidity = hum_int + hum_dec * 0.1;
      data.temperature = temp_int + temp_dec * 0.1;
    } else {
      Serial.println("Checksum-Fehler beim Auslesen des DHT12");
      data.humidity = -1;
      data.temperature = -1;
    }
  } else {
    Serial.println("Fehler: Nicht genügend Daten vom DHT12 erhalten");
    data.humidity = -1;
    data.temperature = -1;
  }
  return data;
}

void setup() {
  Serial.begin(115200);
  Wire.begin();
  setup_wifi();
  client.setServer(mqtt_server, mqtt_port);
}

void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();

  // Sensor auslesen
  DHT12Data sensorData = readDHT12();
  
  if (sensorData.temperature != -1 && sensorData.humidity != -1) {
    // JSON-Dokument erstellen
    StaticJsonDocument<200> doc;
    doc["temperature"] = sensorData.temperature;
    doc["humidity"] = sensorData.humidity;
    // Optional: timestamp hinzufügen (falls benötigt)
    // doc["timestamp"] = "2025-04-07T14:52:22Z";

    char jsonBuffer[256];
    serializeJson(doc, jsonBuffer);
    
    Serial.print("Sende Nachricht: ");
    Serial.println(jsonBuffer);
    client.publish(mqtt_topic, jsonBuffer);
  } else {
    Serial.println("Sensorfehler: Daten konnten nicht gelesen werden");
  }
  
  // 10 Sekunden warten bis zur nächsten Messung
  delay(10000);
}