AZ-Envy - Benachrichtigung per IFTTT versenden

In diesem Beitrag erfährst du, wie man eine Benachrichtigung per IFTTT versendet, wenn die Messwerte am AZ-Envy ein Schwellwert erreichen.

Den AZ-Envy habe ich dir bereits in diversen Beiträgen vorgestellt und gezeigt, wie dieser programmiert wird.

Bezug eines AZ-Envy

Den Mikrocontroller AZ-Envy bekommst du bei der Firma AZ-Delivery für derzeit 9,99 € zzgl. Versandkosten.

Excurs – Was ist der AZ-Envy?

Der AZ-Envy ist ein kleiner ESP8266 mit einem Luftqualitätssensor MQ2 & Temperatur,rel. Luftfeuchtigkeitssensor SHT30 von der Firma AZ-Delivery.

Durch seine kleine Bauform ist dieser gut für Projekte geeignet, welche wenig Platz benötigen.

Alternative zum AZ-Envy

Wenn du keinen AZ-Envy hast, aber trotzdem das kleine Projekt aus diesem Beitrag nachbauen / programmieren möchtest, dann benötigst du:

einen ESP8266,
ein Mikro-USB-Datenkabel,
ein Temperatursensor SHT30,
ein Luftqualitätssensor MQ-2,
diverse Breadboardkabel, sowie
ein 400 Pin Breadboard

Exkurs – Anschluss des AZ-Envy an den Computer zum Programmieren

Der AZ-Envy besitzt eine 6polige Stiftleiste sowie ein Micro-USB-Anschluss. Über den USB-Anschluss bekommt der Mikrocontroller Strom (mehr nicht), über die 6polige Stiftleiste spielen wir mithilfe eines FTDI Moduls den Code vom Computer auf.

FTDI Modul	AZ-Envy
GND	GND
TX	TX
RX	RX

Was ist IFTTT?

Die Abkürzung „IFTTT“ steht für „If this, then that“, also „Wenn dies, dann das“. Du beschreibst also ein Eingangsverhalten und was dann passieren soll. In unserem Fall möchten wir eine Benachrichtigung senden, wenn ein bestimmter Messbereich überschritten / unterschritten wurde.

Du kannst auch mit diesem Service andere Social-Media-Kanäle wie Facebook, Instagram und Twitter ansprechen und so recht einfach deine Nachrichten automatisiert veröffentlichen.

Es gibt 3 Abo-Modelle wobei wir in diesem Beitrag mit der kostenfreien Version auskommen werden. Wir können dann hier nur lediglich 2 Applets einrichten.

Einrichten eines Accounts bei IFTTT

Damit wir den Service IFTTT nutzen können, müssen wir uns zunächst einen Account anlegen. Wie erwähnt ist dieser kostenfrei (kann aber jederzeit höhergestuft werden).

Starten wir zunächst auf der Seite https://ifttt.com/ und wählen oben rechts die Schaltfläche „Get started“.

Du kannst dich hier über vier verschiedene Methoden registrieren, zum einen mit deinem Apple, Facebook oder Google-Konto oder du klickst auf den Link „sign up“ und erstellst dir ein Konto mit deiner E-Mail-Adresse & Passwort.

Erzeugen eines Applets in IFTTT

Für das Erzeugen einer Benachrichtigung müssen wir ein neues Applet einrichten. Wie du dieses machst, erläutere ich dir im nachfolgenden YouTube-Video.

Einrichten & Testen eines Webhooks in IFTTT

Dieses Video auf YouTube ansehen.

Testen des Applets per Postman

Bevor wir uns dem AZ-Envy widmen, testen wir das erzeuge Applet mit der Anwendung Postman. Dieses nützliche Tool kannst du dir unter https://www.postman.com/downloads/ kostenfrei herunterladen.

In Postman kann man ein GET/POST Request an einen Service senden & die Antwort empfangen. Dabei kann man diesen Request komplett konfigurieren und so sehr einfach einen Webservice testen. Wir wollen mit Postman nun ein Webrequest absenden.

Die URL für unser Applet finden wir, so weit wir eingeloggt sind unter https://ifttt.com/maker_webhooks und dann wenn man die Schaltfläche „Documentation“ klickt.

Diesen markierten String kopieren wir nun und fügen diesen in Postman ein. Wir müssen jedoch noch den Platzhalter {event} durch den Namen unseres Events tempAlert ersetzen.

Wenn wir auf die Schaltfläche Send geklickt haben, sollte die Antwort wie folgt aussehen.

Wenn du die entsprechende IFTTT App auf deinem Handy installiert hast, dann erhältst du zusätzlich noch eine Pushnachricht.

Absenden eines Requests vom AZ-Envy

Nachdem wir den Webhook von IFTTT mittels Postman erfolgreich getestet haben, können wir jetzt zum AZ-Envy wechseln und dort den Code schreiben, damit wir vom Mikrocontroller den Webhook ansprechen.

Schritt 1 – Aufbau der WiFi Verbindung

Zunächst bauen wir eine WiFi-Verbindung auf, diese benötigen wir, um den Request an IFTTT zu senden.

Für den Aufbau benötigen wir wiederum die SSID sowie das Passwort für das lokale Wi-Fi Netzwerk. Du kannst natürlich auch einen Hotspot mit deinem Handy aufbauen und somit die Schaltung ortsunabhängig betreiben.

//Bibliothek zur kommunikation mit einem WiFi Netzwerk
#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>
#include <WiFiClient.h>

//Zugangsdaten zum lokalen WiFi-Netzwerk
const char* ssid = "";
const char* password = "";

void setup() {
  //beginn der seriellen Kommunikation mit 9600 baud
  Serial.begin(9600);

  WiFi.begin(ssid, password);
  Serial.println("Aufbau der WiFi Verbindung zu " + ssid);
  //Solange die WiFi Verbindung nicht aufgebaut ist,
  //soll 500ms. gewartet und ein Punkt auf der seriellen Schnittstelle
  //ausgegeben werden.
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("Verbindung erfolgreich aufgebaut!");
  Serial.print("IP-Adresse lautet: ");
  Serial.println(WiFi.localIP());
}

Schritt 2 – Absenden eines Requests

Wenn die WiFi-Verbindung erfolgreich aufgebaut wurde, dann können wir darüber unseren Request an IFTTT senden und somit wiederum eine Benachrichtigung auf unser Endgerät erhalten.

//Adresse des Webhooks
String webhook = "<<Adresse aus der Dokumentation zu den Webhooks>>";

/**
* Funktion zum absenden einer Benachrichtigung.
**/
void sendNotification() {
  //Wenn eine Verbindung zu einem WiFi-Netzwerk besteht, dann...
  if (WiFi.status() == WL_CONNECTED) {
    WiFiClient client;
    HTTPClient http;
    //absenden des Request an IFTTT
    http.begin(client, webhook.c_str());
    //lesen der Antwort
    //HTTP200 - OK
    //> HTTP200 dann fehler
    int httpResponseCode = http.GET();

    Serial.print("HTTP Status Code: ");
    Serial.println(httpResponseCode);
    String payload = http.getString();
    Serial.println(payload);

    http.end();
  }
}

Schritt 3 – Auslesen der Sensordaten und Absenden eines Requests in einem Intervall

Da unser Mikrocontroller mit 16 MHz läuft und dieses, auch wenn es kaum zu glauben ist wahnsinnig schnell ist, müssen wir eine kleine Pause zwischen jedem Absenden einer Benachrichtigung einlegen. Denn wir wollen ja nicht zugespammt werden.

Dieses löse ich, indem zunächst alle 5 Sekunden die Sensordaten gelesen und ausgewertet werden, dann wird geprüft, ob die aktuelle Temperatur größer dem Wert der Konstante MAX_TEMP ist und dann wird noch geprüft, ob wir bereits vor einer Zeit X bereits eine Benachrichtigung gesendet haben.

/**
* Funktion zum auslesen der Temperatur und rel. Luftfeuchtigkeit
* vom SHT30 Sensor.
**/
void readSensorValues() {
  //Wenn die kommunikation per I2C mit dem Sensor
  //erfolgreich war, dann...
  if (sht30.get() == 0) {
    //lesen der Temperatur in Grad Celsius
    temperature = sht30.cTemp;
    //lesen der rel. Luftfeuchtigkeit in %
    humidity = sht30.humidity;
    //ausgeben der Temperatur
    Serial.print("Temperatur: ");
    Serial.print(temperature);
    Serial.println("°C");
    //ausgeben der rel. Luftfeuchtigkeit
    Serial.print("rel. Luftfeuchtigkeit: ");
    Serial.print(humidity);
    Serial.println("%");
  }
}

void loop() {
  //Wenn der letzte Zeitpunkt plus der Pause kleiner als 
  //die Vergangenen Millisekunden ist, dann...
  if ((lastUpdate + PAUSE) < millis()) {
    //lesen der Sensorwerte
    readSensorValues();
    //überschreiben des Zeitstempels mit den aktuellen Millisekunden
    lastUpdate = millis();
    //Wenn die aktuelle Temperatur größer als der Wert der Konstante MAX_TEMP ist UND
    //der Zeitpunkt des letzten absendens einer Benachrichtung plus der Pause kleiner als die aktuellen
    //Millisekunden ist, dann...
    if ((temperature > MAX_TEMP) && (lastSendNotification + PAUSE_SEND_NOTIFICATION) < millis()) {
      //überschreiben des Feldes lastSendNoticifaction mit den aktuellen Millisekunden
      lastSendNotification = millis();
      //absenden einer Benachrichtigung
      sendNotification();
    }
  }
}

Fertiges Programm zum Absenden einer Benachrichtigung via IFTTT vom AZ-Envy

Nachfolgend nun der komplette Code zum Absenden einer Benachrichtigung via IFTTT vom AZ-Envy / ESP8266.

AZ-Envy Programm zum absenden einer Benachrichtigung bei überschreiten einer Temperatur

Den Quellcode habe ich dir mit ausreichend Kommentaren beschrieben. Sollten trotzdem noch Fragen offen bleiben, so kannst du dich gerne per Mail an mich wenden.

//Bibliothek zur kommunikation mit einem WiFi Netzwerk
#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>
#include <WiFiClient.h>

//Bibliothek zum auslesen der Sensorwerte
//vom SHT30 Sensor
#include <WEMOS_SHT3X.h>
//instanziieren eines Objektes vom Typ SHT3X
//mit der I2C Adresse 0x44
SHT3X sht30(0x44);

//Zugangsdaten zum lokalen WiFi-Netzwerk
const char* ssid = "";
const char* password = "";

//Adresse des Webhooks
String webhook = "<<Adresse aus der Dokumentation zu den Webhooks>>";

//Felder für die Temperatur & die rel. Luftfeuchtigkeit
float temperature = 0;
float humidity = 0;

//Konstante für die maximale Temperatur,
//wenn dieser Wert überschritten wird,
//dann soll eine Benachrichtigung gesendet werden
const float MAX_TEMP = 18.0;

//Intervall zum lesen & auswerten des Sensors
int PAUSE = 5000;
long lastUpdate = 0;

//Intervall zum senden einer Benachrichtigung
//Der Sensor wird zunächst alle 5 Sekunden gelesen
//eine Benachrichtigung soll jedoch maximal
//jede Minute gesendet werden
int PAUSE_SEND_NOTIFICATION = 60000;
long lastSendNotification = 0;

void setup() {
  //beginn der seriellen Kommunikation mit 9600 baud
  Serial.begin(9600);

  WiFi.begin(ssid, password);
  Serial.println("Aufbau der WiFi Verbindung zu " + ssid);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("Verbindung erfolgreich aufgebaut!");
  Serial.print("IP-Adresse lautet: ");
  Serial.println(WiFi.localIP());
}

/**
* Funktion zum auslesen der Temperatur und rel. Luftfeuchtigkeit
* vom SHT30 Sensor.
**/
void readSensorValues() {
  //Wenn die kommunikation per I2C mit dem Sensor
  //erfolgreich war, dann...
  if (sht30.get() == 0) {
    //lesen der Temperatur in Grad Celsius
    temperature = sht30.cTemp;
    //lesen der rel. Luftfeuchtigkeit in %
    humidity = sht30.humidity;
    //ausgeben der Temperatur
    Serial.print("Temperatur: ");
    Serial.print(temperature);
    Serial.println("°C");
    //ausgeben der rel. Luftfeuchtigkeit
    Serial.print("rel. Luftfeuchtigkeit: ");
    Serial.print(humidity);
    Serial.println("%");
  }
}

/**
* Funktion zum absenden einer Benachrichtigung.
**/
void sendNotification() {
  //Wenn eine Verbindung zu einem WiFi-Netzwerk besteht, dann...
  if (WiFi.status() == WL_CONNECTED) {
    WiFiClient client;
    HTTPClient http;
    //absenden des Request an IFTTT
    http.begin(client, webhook.c_str());
    //lesen der Antwort
    //HTTP200 - OK
    //> HTTP200 dann fehler
    int httpResponseCode = http.GET();

    Serial.print("HTTP Status Code: ");
    Serial.println(httpResponseCode);
    String payload = http.getString();
    Serial.println(payload);

    http.end();
  }
}

void loop() {
  //Wenn der letzte Zeitpunkt plus der Pause kleiner als 
  //die Vergangenen Millisekunden ist, dann...
  if ((lastUpdate + PAUSE) < millis()) {
    //lesen der Sensorwerte
    readSensorValues();
    //überschreiben des Zeitstempels mit den aktuellen Millisekunden
    lastUpdate = millis();
    //Wenn die aktuelle Temperatur größer als der Wert der Konstante MAX_TEMP ist UND
    //der Zeitpunkt des letzten absendens einer Benachrichtung plus der Pause kleiner als die aktuellen
    //Millisekunden ist, dann...
    if ((temperature > MAX_TEMP) && (lastSendNotification + PAUSE_SEND_NOTIFICATION) < millis()) {
      //überschreiben des Feldes lastSendNoticifaction mit den aktuellen Millisekunden
      lastSendNotification = millis();
      //absenden einer Benachrichtigung
      sendNotification();
    }
  }
}