Shelly PM Mini Gen3 via AZ-Visual steuern – So geht’s!

In diesem neuen Beitrag möchte ich dir gerne zeigen wie du mit dem AZ-Visual einen Luftentfeuchter via Shelly steuern kannst. Der AZ-Visual verfügt neben einem SHT30 Sensor noch zusätzlich über eine WiFi Schnittstelle über welche wir via HTTP-Request andere smarte Geräte schalten können.

Shelly PM Mini Gen3 via AZ-Visual steuern – So geht’s!

Dieses Video auf YouTube ansehen.

Bei der Zeitschrift Make findest du den Aufbau eines Taupunkt-Lüftungssystems, mit welchen du intelligent deine Kellerräume lüften kannst, durch diese Schaltung wird bei optimaler Bedingung ein Lüfter aktiviert.

In diesem Beitrag möchte ich dir zunächst zeigen, wie du mit dem AZ-Visual einen Luftentfeuchter aktivierst, wenn die Luftfeuchtigkeit einen bestimmten Schwellwert erreicht.

Den AZ-Visual habe ich dir bereits im Beitrag AZ-Visual im Test: Der kompakte Mikrocontroller mit OLED und Sensoren und den hier verwendeten Shelly PM Mini Gen3 im gleichnamigen Beitrag Shelly 1PM Mini Gen3 in der Wechselschaltung: Einfache Installation und Einrichtung.

Wie soll die Schaltung funktionieren?

Es wird über den SHT30 Sensor die rel. Luftfeuchtigkeit gemessen und bei Überschreiten eines bestimmten Wertes wird ein Signal an den Shelly gesendet, welcher dann den Entlüfter aktiviert bzw. deaktiviert. Auf dem 0,91″ OLED Display zeigen wir den aktuellen Zustand des Shellys sowie die Temperatur und rel. Luftfeuchtigkeit an.

Zusätzliches Feature

Der Pro Breeze Mini Luftentfeuchter verfügt über einen Sensor, der erkennt, wenn der Wasserbehälter voll ist, und das Gerät dann automatisch abschaltet. Der Shelly PM Mini Gen3 bleibt jedoch weiterhin aktiv und kann die Leistungsaufnahme am Ausgang messen, um die aktuelle Leistungsaufnahme des Luftentfeuchters zu überwachen. Auf diese Weise lässt sich der Zustand des Luftentfeuchters erkennen und wir können über eine Szene eine Benachrichtigung senden, wenn der Wasserbehälter voll ist und das Gerät abgeschaltet wurde.

Was wird für den Aufbau der Schaltung benötigt?

Für den Aufbau der Schaltung benötigst du:

Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!

Alternative mit einem Shelly Plug S

Wenn du jedoch die kleine Schaltung Unterputz einrichten möchtest, dann wirst du um einen Shelly Mini nicht herumkommen.

Sicherheitsvorschriften beim Umgang mit hohen Spannungen

Professionelle Hilfe: Bei Unsicherheit oder komplexen Arbeiten hole fachkundige Unterstützung.
Sicherheit vorrangig: Strom kann gefährlich sein. Achte auf deine Sicherheit und die von anderen.
Strom abschalten: Vor Arbeiten an elektrischen Anlagen den Strom ausschalten.
Isolierung nutzen: Verwende isolierte Werkzeuge und berühre keine blanken Leitungen.
Trockene Hände: Arbeite nur mit trockenen Händen an elektrischen Geräten.
Kinder fernhalten: Halte Kinder von Stromquellen fern, um Unfälle zu verhindern.

Aufbau der Schaltung – Shelly mit AZ-Visual und Luftentfeuchter

Der Aufbau ist eigentlich recht einfach, denn an den Shelly wird lediglich die Spannungsversorgung über L & N angeschlossen und an die Schraubklemme O der Anschluss L der Steckdose. Die beiden Anschlüsse N & PE nimmst du von der Hauptleitung ab.

Den Aufbau habe ich in meinem Fall in eine Unterputzdose gepackt.

Probleme mit dem Aufbau

Ein Problem dieser Schaltung ist, da du nicht sicherstellen kannst, ob der Nullleiter (N, blau) oder Leiter (L, braun) geschaltet wird. Das liegt daran, dass du den Schuko-Stecker um 180 Grad gedreht in die Steckdose stecken kannst. Daher empfehle ich dir diesen Aufbau, ohne Stecker zu erstellen und direkt an die Verbindungsstelle zu gehen.

In meinem Aufbau verwende ich einen Stecker, da dieses ja lediglich für die Anschauung im Video bzw. hier auf dem Blog gedacht ist. Im echten, fertigen Aufbau werde ich hier auch direkt in eine Abzweigdose gehen!

Fertiger Aufbau

Der Luftentfeuchter wird in meinem Fall nun an die Steckdose, welche wiederum mit dem Shelly verbunden wurde, angeschlossen. Da der Luftentfeuchter über einen Ein-/Ausschalter verfügt und ich diesen in der Stellung “Ein” belasse, kann ich dieses Gerät jetzt via App steuern.

Einrichten des Shelly 1PM Mini Gen3

Der Shelly muss eigentlich nicht speziell eingerichtet werden, das einzige, was wir hier machen müssen ist, dass dieser mit dem lokalen WiFi-Netzwerk verbunden ist. Wir benötigen hier die IP-Adresse des Shellys welche wir aus den Geräteinformationen auslesen können.

Daten des Shelly ermitteln

Stromverbrauch des Luftentfeuchters

Die Feuchtigkeit, welche der Luft entnommen wird, wird bei dem Gerät in einem 500ml Behälter gesammelt. Dieser reicht je nach Umgebung zwischen zwei und drei Tage.

Wenn der Behälter voll ist, dann leuchte die kleine gelbe LED an der Bezeichnung “full” auf und der Stromverbrauch geht gegen null.

Diesen Zustand können wir am Shelly nun auswerten, da wir den Ausgang auf Aktiv gesetzt haben, aber der Verbraucher keinen Strom zieht.

Einrichten einer Szene zum Benachrichtigen bei Zustand “Behälter voll”

Erstellen wir jetzt erstmal die Szene in der ShellyCloud zum Benachrichtigen, wenn der Behälter des Luftentfeuchters voll ist. Du kannst diese Szene auch via Handy / Tablet erzeugen!

Die nächsten vier Dialoge belasse ich so, denn die Szene soll von Montag bis Sonntag rund um die Uhr aktiv sein.

Programmieren des AZ-Visual zum Ansteuern des Shelly

Wie du den AZ-Visual programmierst, habe ich dir bereits im Beitrag AZ-Visual im Test: Der kompakte Mikrocontroller mit OLED und Sensoren erläutert, dort habe ich dir ebenso gezeigt wie der SHT30 Sensor ausgelesen wird. Diesen Sensor bzw. die Sensorwerte wollen wir jetzt nutzen um den Shelly via HTTP-Request zu aktivieren bzw. zu deaktivieren.

Aufbau einer WiFi-Verbindung

Im ersten Schritt müssen wir eine WiFi-Verbindung zum lokalen Netzwerk aufbauen.

#include <ESP8266WiFi.h>
#include <ESP8266WiFiMulti.h>
#include <ESP8266HTTPClient.h>
#include <WiFiClient.h>
#include "secrets.h"

ESP8266WiFiMulti WiFiMulti;

void setup() {
  Serial.begin(9600);
  createWiFiConnection();
}

void createWiFiConnection() {
  display.clearDisplay();
  display.setCursor(0, 0);
  display.println("connecting to");
  display.setCursor(0, 12);
  display.println(SSID);
  display.display();
  delay(500);
  Serial.print("Aufbau der WiFi-Verbindung zu ");
  Serial.println(SSID);
  WiFi.mode(WIFI_STA);
  WiFiMulti.addAP(SSID, PASSWORD);
  while (WiFiMulti.run() != WL_CONNECTED) {
    Serial.print(".");
    delay(150);
  }
  display.clearDisplay();
  display.setCursor(0, 0);
  display.println("connection successfull...");
  display.setCursor(0, 12);
  display.println(SSID);
  display.display();
  delay(500);
}

In der Datei secrets.h speichere ich die Zugangsdaten für das WiFi-Netzwerk. Du kannst diese beiden Felder auch direkt in die INO-Datei schreiben jedoch kann man so recht einfach diese Datei in seine Projekte kopieren und hat immer die korrekten Daten.

#define SSID "abc"
#define PASSWORD "xyz"

Auslesen der Temperatur & rel. Luftfeuchtigkeit vom SHT30 Sensor

Die Temperatur und die rel. Luftfeuchtigkeit zeigen wir auf dem Display sowie geben wir diese auf der seriellen Schnittstelle aus.

#include <WEMOS_SHT3X.h>

#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

SHT3X sht30(0x44);

Adafruit_SSD1306 display(128, 32, &Wire, -1);

void setup() {
  ...
  Wire.begin();
  ...
  display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS);
  display.display();
  delay(2000);
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
}

void displaySHT30Values() {
  if (sht30.get() == 0) {
    String tempC = String(sht30.cTemp, 2)+"C";
    String relHumidity = String(sht30.humidity, 2)+"%";
    //Ausgabe auf der seriellen Schnittstelle
    Serial.println("Temperatur in Celsius: " + tempC);
    Serial.println("rel. Luftfeuchtigkeit: " + relHumidity);
    //Ausgabe auf dem OLED-Display
    display.setCursor(0, 0);
    display.println("Temp.: " + tempC);
    display.setCursor(0, 12);
    display.println("Luftf.: "+ relHumidity);
  }
}

void loop() {
  display.clearDisplay();
  displaySHT30Values();
  display.display();
  delay(1000);
}

Es werden jetzt die Sensordaten vom SHT30 Sensor auf dem Display sowie im seriellen Monitor der Arduino IDE ausgegeben.

Einrichten eines Schwellwertes für den Wert der rel. Luftfeuchtigkeit

Da wir jetzt die Sensorwerte ermittelt haben wollen wir mit dem Wert der rel. Luftfeuchtigkeit bei überschreiten eines Schwellwertes den Shelly aktivieren. Dazu legen wir uns erst ein Feld an welches diesen Wert enthält, das hat den Vorteil das wir nicht den gesamten Code durchsuchen müssen wenn wir diesen Wert anpassen wollen.

float activeValueHumidity = 40;

float getSht30Humidity(){
  if (sht30.get() == 0) {
    return sht30.humidity;
  }
  return -1;
}

void loop(){
  ...
  if (getSht30Humidity() >= activeValueHumidity) {
    //hier soll der Shelly aktiviert werden
  } else {
   //hier soll der Shelly deaktiviert werden
  }
  ...
}

Ansteuern des Shellys via HTTP-Request

Damit wir den Shelly und damit das daran angebundene Gerät steuern können, benötigen wir die IP-Adresse des Shellys diese bekommen wir entweder aus dem Router oder bequem über die App Shelly Smart Controll und dort über Geräteinformation.

String localShellyAddress = "http://192.168.178.141/rpc/Switch.Set?id=0&";
String parameterActivate = "on=true";
String parameterDeactivate = "on=false";

void loop(){
   ...
   String url = localShellyAddress + parameterDeactivate;
   if (getSht30Humidity() >= activeValueHumidity) {
     url = localShellyAddress + parameterActivate;
   } else {
     url = localShellyAddress + parameterDeactivate;
   }

   //Absenden der Adresse
   String payload = sendRequest(url);

   display.setCursor(0, 22);
   String status = strstr(payload.c_str(), "true") ? "AKTIVIERT" : "DEAKTIVIERT";
   display.println("Status: " + status);
   ...
}


String sendRequest(String url) {
  Serial.println("Absenden der Adresse: ");
  Serial.println(url);

  WiFiClient client;
  HTTPClient http;

  if (http.begin(client, url)) {
    int httpCode = http.GET();
    if (httpCode > 0) {
      if (httpCode == HTTP_CODE_OK || httpCode == HTTP_CODE_MOVED_PERMANENTLY) {
        return http.getString();
      }
    }
    http.end();
  }
  return "";
}

Fertiges Programm

Hier nun das fertige Programm zum Download als ZIP-Datei.

//Einbinden der Bibliotheken
//zum Aufbauen einer Wifi-Verbindung
#include <Arduino.h>
#include <ESP8266WiFi.h>
#include <ESP8266WiFiMulti.h>
#include <ESP8266HTTPClient.h>
#include <WiFiClient.h>
//die Zugangsdaten werden in der Datei secrets.h gespeichert
#include "secrets.h"

//Bibliothek zum auslesen der Sensorwerte des SHT30 Sensors
#include <WEMOS_SHT3X.h>

//Bibliothek zum ansteuern des Displays
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

//Adresse des OLED-Displays
#define SCREEN_ADDRESS 0x3C

//Objektinstanz vom Display mit der Konfiguration erstellen
//Breite: 128 Pixel
//Höhe: 32 Pixel
Adafruit_SSD1306 display(128, 32, &Wire, -1);

//Der SHT30 Sensor ist via I2C Adresse 0x44 angebunden
SHT3X sht30(0x44);

//Objektinstanz für den Aufbau einer WiFi-Verbindung zum Router
ESP8266WiFiMulti WiFiMulti;

//Felder mit Daten für den Request an den Shelly.
//Hier musst du die IP-Adresse auf die deines Gerätes ändern!
String localShellyAddress = "http://192.168.178.141/rpc/Switch.Set?id=0&";
String parameterActivate = "on=true";
String parameterDeactivate = "on=false";

//Schwellwert, für die rel. Luftfeuchtigkeit
float activeValueHumidity = 60;

void setup() {
  //beginn der seriellen Kommunikation mit 9600baud
  Serial.begin(9600);
  //Begin der Wire Kommunikation für den SHT30 Sensor
  Wire.begin();
  //Einrichten des OLED-Displays
  display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS);
  display.display();
  delay(2000);
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  createWiFiConnection();
}

//Funktion zum Aufbauen einer WiFi-Verbindung
void createWiFiConnection() {
  //Anzeigen der Daten auf dem OLED-Display
  display.clearDisplay();
  display.setCursor(0, 0);
  display.println("connecting to");
  display.setCursor(0, 12);
  display.println(SSID);
  display.display();
  delay(500);
  Serial.print("Aufbau der WiFi-Verbindung zu ");
  Serial.println(SSID);
  WiFi.mode(WIFI_STA);
  WiFiMulti.addAP(SSID, PASSWORD);
  //solange die Verbindung noch nicht aufgebaut wurde,
  //wird ein Punkt ausgegeben und eine kleine Pause von 150 ms eingelegt.
  while (WiFiMulti.run() != WL_CONNECTED) {
    Serial.print(".");
    delay(150);
  }
  //Wenn die Verbindung aufgebaut wurde, dann wird dieses wiederum
  //auf dem OLED-Display angezeigt
  display.clearDisplay();
  display.setCursor(0, 0);
  display.println("connection successfull...");
  display.setCursor(0, 12);
  display.println(SSID);
  display.display();
  delay(500);
}

//Auslesen der Sensorwerte vom sHT30 Sensor
void displaySHT30Values() {
  //Anfordern der Sensorwerte,
  //bei erfolg liefert die Funktion 0 andernfalls 1
  if (sht30.get() == 0) {
    //Ablegen der Daten für die Temperatur und rel. Luftfeuchtigkeit
    String tempC = String(sht30.cTemp, 2) + "C";
    String relHumidity = String(sht30.humidity, 2) + "%";
    //Ausgabe auf der seriellen Schnittstelle
    Serial.println("Temperatur in Celsius: " + tempC);
    Serial.println("rel. Luftfeuchtigkeit: " + relHumidity);
    //Ausgabe auf dem OLED-Display
    display.setCursor(0, 0);
    display.println("Temp.: " + tempC);
    display.setCursor(0, 12);
    display.println("Luftf.: " + relHumidity);
  }
}

//Auslesen der rel. Luftfeuchtigkeit
float getSht30Humidity() {
  if (sht30.get() == 0) {
    return sht30.humidity;
  }
  //Wenn der Sensorwert nicht ausgelesen werden konnte,
  //dann soll der Wert -1 geliefert werden.
  return -1;
}

void loop() {
  //leeren des Displays
  display.clearDisplay();
  //Anzeigen der Sensorwerte auf der seriellen Schnittstelle
  //und auf dem Display
  displaySHT30Values();
  //Aufbauen der Adresse zum Shelly, per default erstmal
  //zum deaktivieren des Gerätes
  String url = localShellyAddress + parameterDeactivate;
  //Wenn der Wert der rel. Luftfeuchtigkeit größer /gleich dem Schwellwert ist,
  //dann soll die Adresse mit dem Wert aus dem Feld "parameterActivate"
  //zusammengebaut werden
  if (getSht30Humidity() >= activeValueHumidity) {
    url = localShellyAddress + parameterActivate;
  }
  //Absenden der Adresse
  String payload = sendRequest(url);

  display.setCursor(0, 22);
  String status = strstr(payload.c_str(), "true") ? "AKTIVIERT" : "DEAKTIVIERT";
  display.println("Status: " + status);

  //Absenden der Daten für das Display
  display.display();
  //einlegen einer Pause von 1 Sekunde.
  delay(1000);
}

//Funktion zum Absenden des Requests an den Shelly
//Als Rückgabewert erhalten wir die Antwort vom Shelly
String sendRequest(String url) {
  Serial.println("Absenden der Adresse: ");
  Serial.println(url);

  WiFiClient client;
  HTTPClient http;

  if (http.begin(client, url)) {
    int httpCode = http.GET();
    if (httpCode > 0) {
      if (httpCode == HTTP_CODE_OK || httpCode == HTTP_CODE_MOVED_PERMANENTLY) {
        return http.getString();
      }
    }
    http.end();
  }
  return "";
}