Wie der aufmerksame Leser weiß, haben sich in den letzten Monaten einige Dinge in meinem Leben verändert. Daher komme ich lange nicht mehr so viel zum basteln wie in der Vergangenheit, aber die aktuelle Energiekriese hat mich zu folgendem Projekt inspiriert.

Ich bin mal durch das Haus gegangen und habe Steckernetzteile gezählt, bzw. diverse Microcontroller und Raspberrys und war erschrocken, wie viele kleine Verbraucher sich so angesammelt haben – die Meisten davon habe ich ja hier dokumentiert. 🙂

Wild entschlossen habe ich angefangen diese zu hinterfragen und ggf. auch einfach als “unnötig” zu deklarieren. So sind z.B. jetzt alle Spielekonsolen über eine schaltbare Steckdose deaktiviert und viele Dinge die ohnehin wenig oder garnicht benutzt wurden sind entsorgt oder verkauft.

Auch mein Heizungs-Raspberry, der tatsächlich nichts anderes mehr tut als auf das S0 Signal von einem Stromzähler zu hören und 1-Wire Temperatursensoren auszulesen, kam mir doch etwas oversized vor und mit diesem Projekt löse ich ihn durch einen ESP8266 ab. Natürlich bleibt ein Steckernetzteil erhalten, die Stromaufnahme ist aber trotzdem geringer und ich konnte so auch noch die Funktionalität erweitern.

Die Stromzähler

Die Schaltung auf dem Steckbrett

Und los ging die Bastelei! (endlich!) Die Schaltung war auf dem Breadboard schnell zusammen gesteckt. Tatsächlich bin ich bei der Hardware nur über den S0 gestolpert. Bei den Zählern haben die 3.3V des ESP leider nicht ausgereicht für eine zuverlässige Erfassung. Ein Blick ins Datenblatt und es war klar das es mindestens 5V sein müssen. Da mein Steckernetzteil 5V hat, habe ich also für den S0 direkt diese Spannung genommen und mit einem Spannungsteiler die Spannung für die GPIOs angepasst.

S0 Stromzähler Steckbrett
S0 Stromzähler Schaltung

Die Platine sieht in einem kleine 3D-Druck-Gehäuse dann so aus. (Natürlich gibts zu dem Gehäuse auch noch einen Deckel…

S0 Stromzähler mit 1-Wire Temperaturmessung auf Lochrasterplatine

Der Arduino Quellcode

Die Software besteht grundsätzlich aus zwei Teilen. Einmal dem Arduino Sketch für den ESP8266 und einem PHP-Script als Gegenstück, welches auf meinem NAS läuft und die Werte in die Datenbank schreibt.

Der ESP macht folgendes:
1. Per Interrupt auf steigende Flanken auf den 3 GPIOs hören um dann einen Zähler hochzuzählen
2. Nach 60 Sekunden die aktuellen Temperaturen auszulesen
3. Und das alles als JSON an das PHP-Script zu senden

Da mein NAS irgendwie träge ist und der erste Versuch des Datensendens mit einem Fehler abbricht, wiederhole ich als Workaround das Senden einfach so lange, bis es geklappt hat.

#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>
#include <Ticker.h>
#include <OneWire.h>
#include <DallasTemperature.h>

#define INT_PIN1 13
#define INT_PIN2 12
#define INT_PIN3 14

#define temperatureBus 4
#define addressTempVorlauf "28CF8D2905000054"
#define addressTempRuecklauf "281A8C29050000B6"
#define addressTempGruen "28E92729050000DE"
#define addressTempBraun "28F78B2905000084"

Ticker timer;
OneWire oneWire(temperatureBus);
DallasTemperature sensors(&oneWire);

float powerEG, powerOG, powerHeizung = 0;
volatile unsigned long intCounter[3];
int numberTempSensors;
float temperatureVorlauf = -1;
float temperatureRuecklauf = -1;
DeviceAddress tempDeviceAddress;
bool dataReadyToSend = false;
String httpRequestData = "";
WiFiClient client;
HTTPClient http;
bool isReady = false;


void ICACHE_RAM_ATTR isr1()
{
  intCounter[0]++;
}
void ICACHE_RAM_ATTR isr2()
{
  intCounter[1]++;
}
void ICACHE_RAM_ATTR isr3()
{
  intCounter[2]++;
}

String getDeviceAddressAsHex() {
  String result = "";
  char hexVal[2];
  for (uint8_t i = 0; i < 8; i++) {
    hexVal[0] = 0x0;
    hexVal[1] = 0x0;
    sprintf(hexVal, "%02X\0" , tempDeviceAddress[i]);
    result += hexVal;
  }
  return result;
}

bool sendDataToServer()
{
  if (WiFi.status() == WL_CONNECTED) {        
    if (http.begin(client, "http://<ip-vom-nas>/scripts/powermeasurement.php")) {
      http.addHeader("Content-Type", "application/json");
      http.setTimeout(50);
      
      httpRequestData = "{\"powerog\":" + String(powerOG) + ",";
      httpRequestData += "\"powereg\":" + String(powerEG) + ",";
      httpRequestData += "\"powerheizung\":" + String(powerHeizung) + ",";
      httpRequestData += "\"tempvorlauf\":" + String(temperatureVorlauf) + ",";
      httpRequestData += "\"tempruecklauf\":" + String(temperatureRuecklauf) + "}";
      Serial.println("Sending request " + httpRequestData);
      Serial.flush();
  
      int httpResponseCode = http.POST(httpRequestData);
      http.end();                   
      if (httpResponseCode != 200)
      {
        return false;
      }
      return true;
      
    } else  {
      // Serial.println("UNABLE TO CONNECT");
      return false;
    }           
  } else {
    // Serial.println("WiFi Disconnected");
    return false;
  }
}

void readTemperatures() 
{
  sensors.requestTemperatures();
  delay(1000);

  temperatureVorlauf = -1;
  temperatureRuecklauf = -1;
  for (int i = 0; i < numberTempSensors; i++) {    
    if (sensors.getAddress(tempDeviceAddress, i)) {
      float temp = sensors.getTempC(tempDeviceAddress);            
      String deviceAddress = getDeviceAddressAsHex();      
      if (deviceAddress == addressTempVorlauf) {
        temperatureVorlauf = temp;
      } else if (deviceAddress == addressTempRuecklauf) {
        temperatureRuecklauf = temp;
      }
    }    
  } 
}

void onTimerTick()
{
  noInterrupts();
  powerOG = intCounter[0]; powerOG = powerOG * 60 / 2000;
  powerEG = intCounter[1]; powerEG = powerEG * 60 / 2000;
  powerHeizung = intCounter[2]; powerHeizung = powerHeizung * 60 / 1000;

  intCounter[0] = 0;
  intCounter[1] = 0;
  intCounter[2] = 0;
  interrupts();
  
  dataReadyToSend = true;
}

void setup() {
  Serial.begin(115200);
  Serial.println("Init ports");
  
  pinMode(INT_PIN1, INPUT);
  pinMode(INT_PIN2, INPUT);
  pinMode(INT_PIN3, INPUT);

  Serial.println("Starting wifi");
  IPAddress ip(192, 168, X, Y);
  IPAddress gateway(192, 168, X, Z); 
  IPAddress subnet(255, 255, 255, 0); 
  WiFi.config(ip, gateway, subnet);
  WiFi.begin("<ssid>", "<password>");
  WiFi.hostname("esp-stromzaehler");
  Serial.println("Warte auf Verbindung");   
  while (WiFi.status() != WL_CONNECTED)
  {    
    Serial.print(".");
    delay(500);
  }   
  Serial.print("Mit Wlan verbunden. IP Adresse: ");
  Serial.println(WiFi.localIP());
  Serial.flush();

  Serial.println("Starting sensors");
  sensors.begin();
  numberTempSensors = sensors.getDeviceCount();
  Serial.print(numberTempSensors, DEC);
  Serial.println(" Devices found");  
  for (int i = 0; i < numberTempSensors; i++) {
    if (sensors.getAddress(tempDeviceAddress, i)) {
      Serial.print("Found device ");
      Serial.print(i, DEC);
      Serial.print(" at Address ");
      Serial.print(getDeviceAddressAsHex());
      Serial.println();
    } else {
      Serial.print("Found ghost at ");
      Serial.print(i, DEC);
      Serial.println();
    }
  }

  Serial.println("Starting timer");
  timer.attach(60, onTimerTick);
  
  Serial.println("Setting interrupts");
  attachInterrupt(digitalPinToInterrupt(INT_PIN1), isr1, RISING);
  attachInterrupt(digitalPinToInterrupt(INT_PIN2), isr2, RISING);
  attachInterrupt(digitalPinToInterrupt(INT_PIN3), isr3, RISING);
  
  Serial.println("Setup done...");
  isReady = true;
}

void loop() {
  if (isReady == true)
  {
    readTemperatures();
    
    if (dataReadyToSend == true)
    {
      dataReadyToSend = false;
 
      while (sendDataToServer() == false)
      {
        delay(250);
      }
      Serial.println("sending data ok");
    }     
  }
}

Der PHP Quellcode

Und hier noch das bischen PHP (als Quick&Dirty Script), welches die per JSON gesendeten Werte entgegen nimmt, in die MySQL-Datenbank (ebenfalls auf dem NAS) schreibt und dann noch an den Homeserver schickt.

<?php

/*** INIT ***/
date_default_timezone_set ("Europe/Berlin");
$mysql = mysqli_connect("192.168.X.Y", "<benutzer>", "<passwort>");
if (!$mysql) {
    die('Verbindung schlug fehl: ' . mysqli_error());
}
mysqli_select_db ($mysql, "heizung");


/*** Read Data ***/
$postData = file_get_contents('php://input');
if (strlen($postData) < 10) {
	return;
}
$data = json_decode($postData);
if (!is_object($data)) {
	return;
}
$powerOG = $data->powerog;
$powerEG = $data->powereg;
$powerHeizung = $data->powerheizung;
$tempVorlauf = $data->tempvorlauf;
$tempRuecklauf = $data->tempruecklauf;


/*** Temperaturen ***/
// Daten in Datenbank schreiben
$query = "INSERT INTO temperaturen SET datum = NOW(), `fbh-vorlauf` = '" . (floatval($tempVorlauf)) . "', `fbh-ruecklauf` = '" . (floatval($tempRuecklauf)) . "' ";
mysqli_query($mysql, $query);

# Alte Datensaetze loeschen
$query = "DELETE FROM temperaturen WHERE DATE_SUB(now(), INTERVAL 365 DAY) >= datum";
mysqli_query($mysql, $query);


/*** Energie ***/
// neue daten einfügen
$query = "INSERT INTO stromverbrauch SET datum = NOW(), verbrauch = '" . (floatval($powerHeizung)) . "', verbrauch_eg = '" . (floatval($powerEG)) . "', verbrauch_og = '" . (floatval($powerOG)) . "' ";
mysqli_query($mysql, $query);

// alte daten loeschen
$query = "DELETE FROM stromverbrauch WHERE DATE_SUB(now(), INTERVAL 365 DAY) >= datum";
mysqli_query($mysql, $query);


/*** HOMESERVER DATEN ***/
$data = "";
$data .= "WP-Stromverbrauch=\"".(floatval($powerHeizung))."\"\r\n";
$data .= "WP-HK-Vorlauf=\"".(floatval($tempVorlauf))."\"\r\n";
$data .= "WP-HK-Ruecklauf=\"".(floatval($tempRuecklauf))."\"\r\n";
if (($socket = socket_create(AF_INET, SOCK_STREAM, SOL_TCP)) === false) {
    echo "socket_create() fehlgeschlagen: Grund: " . socket_strerror(socket_last_error()) . "\n";
}
$result = socket_connect($socket, "192.168.X.Z", 11108);
if ($result === false) {
    echo "socket_connect() fehlgeschlagen.\nGrund: ($result) " . socket_strerror(socket_last_error($socket)) . "\n";
}
socket_write($socket, $data, strlen($data));
socket_close($socket);

echo "1";
?>

Damit werden jetzt die gemessenen Werte vom ESP in die Datenbank geschrieben und gleichzeitig auch nochmal an den Homeserver geschickt. Dieser nutzt die Infos “ist die Heizung an?” oder “ist die Klimaanlage an?” an verschiedenen Stellen in der programmierten Logik im sinnvolle Entscheidungen zu treffen – und der alte Raspberry ist jetzt ausgemustert.

Wie es manchmal so ist, kann ein einziges Ereignis das ganze Leben verändern. So auch die Geburt meines ersten Kindes. Das ist mit der Grund dafür, warum das basteln aktuell eine etwas niedrigere Priorität bekommen hat.

Aber natürlich gibt das Kind hin und wieder auch Anlass etwas am Haus zu verbessern. Denn aktuell ist Schlaftrainig angesagt und immer wenn abrupt das Nachttischlicht ausgeschaltet wird, ist erstmal “alarm“.

Daher war die Überlegung, das Nachtlicht nicht plötzlich auszuschalten sondern langsam auszudimmen – ähnlich wie bei einem Sonnenuntergang. In der Hoffnung, dass das Kind dadurch nicht erschrickt und das einschlafen leichter fällt.

Natürlich war schon eine kleine Lampe mit LED Leuchtmittel, welches man sogar dimmen könnte, vorhanden und an einer Steckdose angeschlossen. Und tatsächlich sind an meinem Dimmaktor noch zwei Anschlüsse frei. Jedoch hätte ich dazu diese eine schaltbare Steckdose so umverdrahten müssen, das sie eben nicht mehr über einen Schaltaktor läuft sondern über den Dimmaktor. Es wäre die einzige im Haus und irgendwie fühlte sich das nicht richtig an. Zumal ich auch alle anderen Steckdosen im Zimmer auf eine andere Phase (des 5×1.5 welches die Steckdosen speist) hätte umverdrahten müssen – das war mir zu aufwändig.

Stattdessen wollte ich die gleiche Technik nutzen, die auch schon im Garten eingesetzt wird: Zigbee.

Dann habe ich eine Wippe am Lichtschalter so programmiert das die 2-Kanal-Bedienung aktiviert wird, so dass ich einmal einen kurzen und einen langen Tastendruck auslösen kann. Die Idee:
– Der kurze Tastendruck fährt überall im Obergeschoss die Rollos runter, schaltet diverse Lichter aus und bereitet alles zum “Ins Bett gehen” vor.
– Der lange Tastendruck startet dann den Dimmvorgang. Es soll innerhalb von 5 Minuten von der maximalen Helligkeit auf “aus” gedimmt werden.

Meinem Programmierprinzip folgend habe ich in der ETS “nur” Kommunikationsobjekte für die beiden Tastenaktionen gemacht und den Rest mache ich dann im Homeserver durch eine kleine Logik:

Logik im Gira Homeserver zur Steuerung des Sonnenuntergangslichts
Logik zur Steuerung des Sonnenuntergangslichts

Bei der Ausgangsbox “geht ins Bett” werden wie beschrieben Rollos herunter gefahren und die Lichter im Flur ausgeschaltet.

Bei der Ausgangsbox “licht dimmen” bzw “licht reset” wird über “Web-Seiten abfragen” eine URL aufgerufen. Denn schon alleine aus Entwicklungs- und Testgründen (den Homeserver muss man ja bei jeder Änderung neu starten) wollte ich den ganzen Dimmvorgang nicht über Sequenzen oder ähnliches steuern, sondern einfach nur der deCONZ-API mit einem Aufruf mitteilen “stelle das Licht so und so ein und nimm dir dafür 300 Sekunden Zeit”. Das habe ich dann als PHP-Script gelöst, welches einfach auf meinem NAS liegt und auf Knopfdruck vom Homeserver aufgerufen wird.

Aufruf einer Webseite im Gira Homeserver 2
Aufruf einer Webseite im Homeserver 1
Aufruf einer Webseite im Gira Homeserver 2
Aufruf einer Webseite im Homeserver 2

Ich werte im Script noch einen GET-Paramter aus, um die Lampe auch vom gedimmten Zustand wieder auf “ungedimmt” wechseln zu können. Hier mein Script.

<?php
	header("Cache-Control: no-store, no-cache, must-revalidate, max-age=0");
	header("Cache-Control: post-check=0, pre-check=0", false);
	header("Pragma: no-cache");

	class ApiLightStateSet {
		public $bri = 0;
		public $ct = 0;
		public $on = true;
		public $colormode = "ct";
		public $transitiontime = 0;
	}
	
	$apiPath = "http://IP-DES-DECONS-GATEWAYS:8080/api";
	$apiKey = "APIKEY";
	$uid = "LAMPEN-UID";
	
	$apiPath .= "/" . $apiKey . "/lights/" . $uid . "/state";
		
	$action = $_GET["a"];
	if ($action == "dim")
	{		
		setBrightness(254, 362, 0);
		sleep(2);
		setBrightness(0, 362, 0);
		sleep(2);
		setBrightness(254, 362, 0);
		sleep(2);
		setBrightness(0, 500, 3000);
	}
	else if ($action == "res")
	{
		setBrightness(254, 362, 0);
	}
	
	function setBrightness($bri, $ct, $transitiontime)
	{
		$data = new ApiLightStateSet();
		$data->on = ($bri > 0);
		$data->bri = (int)$bri;
		$data->ct = $ct;
		$data->transitiontime = (int)$transitiontime;
		sendApiData($data);
	}
	
	function sendApiData($data)
	{
		global $apiPath;
		if ($data)
			$jsonData = json_encode($data);
		
		$curl = curl_init();
		curl_setopt($curl, CURLOPT_URL, $apiPath);
		curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
		curl_setopt($curl, CURLOPT_CUSTOMREQUEST, 'PUT');
		curl_setopt($curl, CURLOPT_POSTFIELDS, $jsonData);
		curl_setopt($curl, CURLOPT_HTTPHEADER, array('Content-Type: application/json','Content-Length: ' . strlen($jsonData)));
		$response = curl_exec($curl);		
		if ($response)
		{
			$json = json_decode($response);
			var_dump($json);
		}
		curl_close($curl);
	}
?>

Wie man erkennen kann wird beim starten des Dimmens zuerst die Lampe einmal kurz ein- und ausgeschaltet. Das ist die optische Rückmeldung, dass das Dimmen gestartet wurde.

Ergebnis: Das Licht geht nun auf Knopfdruck von hellweiß auf ein ganz dunkles warmweiß und schließlich aus. Das ganze in einer Zeit von ca. 5 Minuten.
Und so wie es aussieht, hilft es dem Kind beim einschlafen.

Vor vielen Jahren habe ich mal eine Stand-Alone Wetterstation mit Außensensor geschenkt bekommen und diese hat eigentlich auch immer gut ihren Dienst getan. Jetzt ist vor ein paar Wochen leider der Außensensor an einem Wasserschaden gestorben. Natürlich funktioniert die Wettervorhersage immer noch, aber ohne Außentemperatur ist das Gerät für mich nicht mehr “vollständig” 😉 – und schon war das nächste Projekt geboren.

Folgende Anforderungen habe ich festgelegt:

  • Möglichst größer Bildschirm (mindestens 7.5″)
  • Batteriebetrieb
  • Anbindung meiner KNX Wetterstation
  • Anzeige von Temperaturen im Haus (zur Kontrolle der Fußbodenheizung)
  • Verlässliche Wettervorhersage
  • Schönes Gehäuse, so dass man es außerhalb des Bastelzimmers aufstellen kann

Lithium Batterien

Egal ob zwei 1,5V Lithium-Batterien in Reihe oder wie in meinem Fall eine CR123(A) 3V Lithium-Batterie: mit Lithium-Batterien läuft die Station super (mit normalen Batterien nicht) und ich nutze sie für µC Anwendungen fast immer. Lithium Batterien halten nämlich ziemlich konstant eine Spannung von 3V. Ab ca. 2,7 V sind dann auch schon über 90% der Kapazität verbraucht und bei ca. 2,55 V ist sie praktisch leer. Auch kurzfristigen großen Strombedarf, wie z.B. bei WLAN oder Bluetooth Betrieb, liefern Lithium-Batterien ohne Probleme. Zusätzlich haben Lithium-Batterien auch noch eine sehr geringe Selbstentladung.

Stromverbrauch

An meinem Labornetzteil habe ich den Stromverbrauch beim Refresh gemessen:
Ingesamt dauert der Vorgang ca. 55 Sekunden.
Maximal werden 137mA gezogen, im Mittel über die 55 Sekunden sind es 41mA.
Im Deepsleep sind es aber immer noch 0,36mA, obwohl der ESP32 eigentlich nur ca. 7µA ziehen sollte. Das liegt wohl an dem Entwicklungsboard. Obwohl ich den ESP32 in Tiefschlaf versetze, scheint auf der Platine noch immer etwas Strom zu ziehen. Vermutlich werde ich die Schaltung nochmal ohne Entwicklungsboard aufbauen müssen.

Labornetzteil zur Strommessung
Labornetzteil zum Messen des Stroms

Bei 0,36mA Standby-Strom komme ich mit den 2500mAh Batterien ungefähr auf 2500mAh/0,36mA=6944h = 289 Tage
Einmal pro Stunde zieht er für eine Minute im Mittel 41mA. Das heißt ich sollte mit einer Batterie ca. 3/4 Jahr hinkommen.
Das reicht für den Anfang, aber ich werde auf jeden Fall noch eine alternative Platine bauen.

Die Software

Elektrik wäre damit (erstmal) erledigt und auch ein Gehäuse musste nicht designed werden. Aber die Software hatte es in sich. Zwar programmiere ich recht oft Microcontroller, jedoch haben die meisten Projekte keine 100 Zeilen. Dieses hier ist eines der umfangreicheren Programme auf Arduino-Basis.

Der Programmablauf ist wie folgt:

  1. WLAN Verbindung herstellen
  2. Wetterbericht von https://openweathermap.org/ holen (REST-API, Ergebnis kommt als JSON, Dienst ist für wenige Abfragen kostenlos)
  3. KNX Daten von Homeserver lesen (ab Firmware 4.7 spricht dieser auch (simples) REST)
  4. Aktuelle Uhrzeit von http://worldtimeapi.org/ holen (wird nur zur Info mit ausgegeben)
  5. Schöne, mit Informationen vollgepackte Oberfläche zeichnen
  6. ESP32 einschlafen lassen

Das Ergebnis sieht dann wie folgt aus.

Wetterstation im 3D Druck Gehäuse mit EInk Bildschirm

Wie immer gibt es das Programm hier: Arduino Wetterstation Code

Beim letzten Starkregen (welcher in Deutschland ja verheerende Schäden angerichtet hat) kam auch bei uns die Kanalisation nicht mehr mit. Gott sei Dank gab es nicht so große Probleme wie anderswo, aber unsere Zisterne ist übergelaufen und dadurch ist mein Sensor in der Zisterne abgesoffen.

Durch Wasser zerstörter Zisternensensor
Durch Wasser zerstörter Zisternen-Sensor

Interessanterweise läuft der ESP8266 noch problemlos, aber die Messung liefert Mondwerte.

Mein Plan ist Elektronik und Sensor wieder zu trennen. Der Sensor wird in der Zisterne versenkt, die Elektronik kommt ins Pumpenhaus.

Wasserstandssensor auf Druckbasis mit Stromschleife
Wasserstandssensor auf Druckbasis mit Stromschleife

Doch wie bringt man einem ESP8266 bei Strom zu messen? Sicher gibt es viele Möglichkeiten, doch ich entscheide mich ganz simpel für einen (passenden) Widerstand, an dem die gewünschte Spannung abfällt.

Wir erinnern uns kurz zurück an die Schule: Da war mal was das hieß “U = I * R”
Und ich möchte das an meinem ADC, wenn der Sensor 20mA liefert eine Spannung von 3.3V anliegt. Das ist die Betriebsspannung meines ESP8266.
Das heißt: R = 3,3V / 0,020A = 165 Ohm -> Ich nehme also einen 150 Ohm Widerstand.
Bei minimaler und maximaler Wassertiefe (= Stromfluss) ergeben sich dann folgende Spannungen.
V = 0,004A * 150 Ohm = 0,6V (minimal)
V = 0,020A * 150 Ohm = 3,0V (maximal)
Das passt also, auch wenn ich nicht den ganzen Messbereich des ADC ausschöpfe!

Jetzt möchte ich den µC noch gegen Spannungen die größer als VCC (=3,3V) + 0.6V sind schützen und den Strom auf unter 0,1mA bringen. Kann ja immer mal passieren das irgendwo ein Kurzschluss entsteht oder beim Aufbau Kabel vertauscht werden.
R= (24V-(3,3V+0,6V)) / 0,0009A = 22333 Ohm -> Ich nehme also einen 27k Widerstand.

So sieht die modifizierte Schaltung nun aus:

Schaltplan des neuen Zisternen-Sensors mit Wasserdrucksensor
Schaltplan des neuen Zisternen-Elektronik mit Wasserdrucksensor.
Wichtig: Die GNDs der beiden Spannungsquellen sind verbunden! (auf dem Schaltplan nicht zu sehen)

Jetzt schaut man sich den Schaltplan an und denkt: Ok, R2 = 27kOhm, das ist also der Schutzwiderstand.
Aber sollte R3 lt. Berechnung nicht 150 Ohm sein? Warum steht im Schaltplan 50 Ohm?
Das liegt daran, das ich in die Falle meines ESP-Moduls getappt bin. Nachdem ich das so gebaut hatte und der ADC irgendwie nichts sinnvolles gemessen hat, habe ich etwas Datenblätter gewälzt und festgestellt, das die “rohen” ESP-Module – wie ich sie verwende – einen Spannungsbereich am ADC von 0-1V erwarten (trotz 3,3V Betriebsspannung). Es gibt Module da ist direkt ein Spannungsteiler eingebaut, bei meinem nackten Modul aber nicht.

Also nochmal neu gerechnet:
R = 1.0V / 0,020A = 50 Ohm -> Ich nehme also einen 51 Ohm Widerstand.
Der Schutzwiderstand bleibt gleich.
Proberechnung:
V = 0,004A * 50 Ohm = 0,2V (minimal)
V = 0,020A * 50 Ohm = 1,0V (maximal) (hier liefert der ADC dann den Wert 1023)

Neue Schaltung auf Lochrasterplatine
Neue Schaltung auf Lochrasterplatine

Man sieht meine geliebte (aber sehr labile) Wurfverkabelung, mit der ich quasi immer arbeite. 😉
Im Hintergrund ist der USB->Seriell Konverter zu sehen (zum Programmieren) und vorne links, unter der Platine ist der Step-Up-Wandler. Die Platine ist jetzt durch das aus- und einlöten diverser Bauteile ganz schön verbraten, aber muss ja auch keinen Schönheitspreis gewinnen.

Ordentlich verpackt in eine Abzweigdose die rumlag sieht es dann so aus.

Schaltung in Abzweigdose
Schaltung in Abzweigdose

Wie man sieht habe ich das Kabel vom Sensor mit einem Hohlstecker versehen, damit ich die Elektronik für Wartungszwecke leicht vom Sensor trennen kann.

Jetzt fehlt noch der angepasste Arduino Sketch:

#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>

const int sensorEnable = 15; // PIN für den Transistor zum aktivieren des Step-Up-Wandlers
const byte sensorPin = A0; // ADC für den sensor
const uint16_t resistor = 51; // Eingesetzter Pull-Down Widerstand
const int maxAdcWennVoll = 472; // Prozentuale Umrechnung

ESP8266WebServer server(80); // Webserver
WiFiClient client;

              
void setup() {
  Serial.begin(115200);

  IPAddress ip(192, 168, X, Y);
  IPAddress gateway(192, 168, X, Z); 
  IPAddress subnet(255, 255, 255, 0); 
  WiFi.config(ip, gateway, subnet);
  WiFi.begin("**netzwerk**", "**geheim**");

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

  Serial.print("Connected, IP address: ");
  Serial.println(WiFi.localIP());  

  server.on("/", handle_normal);
  server.on("/hs", handle_hs);
  server.on("/hs/1", handle_hs);
  server.onNotFound(handle_NotFound);  
  server.begin();
  Serial.println("http server startet");

  pinMode(sensorEnable, OUTPUT);
  digitalWrite(sensorEnable, LOW);
  
  pinMode(sensorPin, INPUT); 
}

void loop() {
  server.handleClient();
}

void handle_NotFound(){
  server.send(404, "text/plain", "Not found");
}

void handle_normal() {
  Serial.println("handle /");
  long pressure = measurePressure();  
  long percent = pressure * 100 / maxAdcWennVoll; //umrechnen auf prozent
  
  String msg = String("<!DOCTYPE html><html>") + 
    "<head><meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">" + 
    "<link rel=\"icon\" href=\"data:,\">" + 
    "<body><h1>Zisterne Measusement Server</h1>" + 
    "<p>Use get parameter hs for homeserver</p>" + 
    "<p>Exampe: /hs/1</p>" + 
    "<br><br><p>Current pressure: " + String(pressure) + "</p>" + 
    "<br><br><p>Current percent: " + String(percent) + "</p>" + 
    "</body></html>\r\n" ;
  server.send(200, "text/html", msg); 
}

void handle_hs() {
  Serial.println("handle /hs");
  long pressure = measurePressure();
  long percent = pressure * 100 / maxAdcWennVoll; //umrechnen auf prozent
  String msg = String("D=" + String(percent) + "\r\n");
  server.send(200, "text/html", msg); 
} 

int measurePressure() {
  Serial.println("setting 24v on");
  digitalWrite(sensorEnable, HIGH);
  delay(5*1000); //auf sensor warten
  
  Serial.println("start measuring");
  int myValue = doMeasure(); 
  Serial.println("done measuring");
  
  Serial.println("setting 24v off");
  digitalWrite(sensorEnable, LOW);
  return myValue;
}

int32_t doMeasure() {
  float minAdc = 0.004 * resistor * 1024;
  float maxAdc = 0.020 * resistor * 1024;
  
  int adc = 0;
  for (byte i = 0; i < 3; i++)
  {
    int m = analogRead(sensorPin);
    Serial.println("adc" + String(m));
    adc += m;    
    delay(10);
  }
  adc = adc / 3;
  int32_t value = (adc - minAdc) * int32_t(1023) / (maxAdc - minAdc);
  if (value > 1023) value = 1023;
  else if (value < 0) value = 0;
  return  value;
}

Ich hoffe das diese Version jetzt rebust genug ist und der China-Sensor auch ein paar Jahre durchhält.

Jetzt soll das hier aber kein 3D Drucker test werden. Davon gibt es schon mehr als genug und ich kann diese einfach nur bestätigen: Druck starten -> wiederkommen -> perfekt 😉

Jetzt sollte mein neuer Drucker aber auch ein neues zu Hause bekommen und nicht einfach nur auf der Werkbank stehen. Gerade der Filamentwechsler soll wohl eine Menge Platz brauchen (noch nicht zusammen gebaut). Und wenn ich ABS oder ASA Drucke, muss ich da auch noch eine Kiste drum rum bauen können und die Abluft irgendwie nach draußen bekommen.

Darum habe ich mich für ein Regal auf Rollen entschieden.

Regal auf Rollen mit 3D Drucker und Filamentrollen
Regal auf Rollen mit 3D Drucker und Filamentrollen

Von unten nach oben ist meine Aufteilung jetzt so: Lager und Ersatzteile, Mülleimer und Werkzeug, Drucker und Rollen in Benutzung, Filamentlager.

Filament Guide für Prusa MK3S
Filament Guide für Prusa MK3S

Dann hatte ich noch eine alte PTZ Webcam herum liegen. Diese habe ich mit Kabelbindern links am Regal befestigt, damit ich den Druck beobachten kann ohne im Raum sein zu müssen.

Kamera und 3D Drucker
Kamera und 3D Drucker

Obwohl, oder vielleicht gerade weil, der Prusa MK3S wirklich solide und robust aufgebaut ist, vibriert das ganze Holzbrett beim verfahren der Y-Achse. Darum habe ich eine Teppichfliese untergelegt, welche die Vibrationen deutlich dämpft.

Für die Halterung der Spulen habe ich mir auch etwas ausgedacht. Diese habe ich auf der rechten Seite mit einer Gewindestange montiert. Da ich viel mit den 3KG Spulen arbeite, war mir eine M8 Stange zu dünn. Daber bin ich auf M12 gegangen.

Zunächste habe ich übliche Stuhlwinkel am Regal festgeschraubt. Auf diese Winkel habe ich dann eine kleine Aufnahme für die Gewindestange geschraubt. Hier gibt es die STL-Datei der Aufnahme.

Stuhlwinkeln und Aufnahme der M12 Gewindestange
Stuhlwinkeln und Aufnahme der M12 Gewindestange
Aufnahme M12 Gewindestange
Aufnahme der M12 Gewindestange

Hier gibt es meine STL-Dateien des Universal Rollenhalters für M12 Stangen. Ich habe 3 Varianten gemacht, kurz, mittel und lang. Für die 3KG Rollen nehme ich die großen, für alle anderen den mittleren.

Universal Rollenhalter mittel
Universal Rollenhalter mittel
Universal Rollenhalter lang
Universal Rollenhalter lang
Universal Rollenhalter nuss
Universal Rollenhalter Nuss
Kugellager für M12 Gewindestangen
Kugellager für M12 Gewindestangen
Rollenhalter ohne Rolle auf Achse
Rollenhalter ohne Rolle auf Achse
Filamentrollen im Regal
Filamentrollen im Regal

Wie schon in den diversen Beiträgen zu meiner Gartenbeleuchtung beschrieben (Es werde Licht (aka. Zigbee und deCONZ), Es werde Licht 2.0 (aka. RGBW Controller und LED Leiste), Es werde Licht 3.0 (aka. Licht Animation erster Versuch)) , baue ich die ganze Ambiente-Beleuchtung im Garten auf ZigBee-Basis auf.

Nachdem mein Rasperry seine SD-Karte zerlegt hatte (ein Dauerproblem bei meinen PIs, was ich jetzt durch Netzwerkboot gelöst habe) habe ich auch mein altes PHP Projekt weggeworfen und durch eine neue Blazor/Razor App ersetzt.

Diese ist sicher noch nicht fertig, aber bietet schon mal die Steuerung einzelner Lampen, Szenensteuerung und vor allem die Möglichkeit zeitgesteuert und automatisch diverse Animationen abzuspielen.

Hier auch mal einige Screenshots der ersten Version.

Zigbee Light Control Konfiguration
Zigbee Light Control Konfiguration
Zigbee Light Control Szenen Übersicht
Zigbee Light Control Szenen Übersicht
Zigbee Light Control Szenen Konfiguration
Zigbee Light Control Szenen Konfiguration
Zigbee Light Control Playlisten Übersicht
Zigbee Light Control Playlisten Übersicht
Zigbee Light Control Playlist Konfiguration
Zigbee Light Control Playlist Konfiguration

Wie ja alle wissen ist das Arbeiten in der Wohnung mit einer Flex oder Kreissäge nicht wirklich zu empfehlen, da die Staub- und Dreckentwicklung enorm ist. Aus diesen Grund wollte ich schon immer eine Werkstatt für die “groben” Arbeiten haben.

In meiner Garage ist auch extra ein Raum dafür abgetrennt, dieser ist jedoch nicht beheizt, so dass das Arbeiten im Winter nur mit dicker Jacke möglich wäre – ein unhaltbarer Zustand! 😉

Infrarot Heizungen

Und da meine Garage nicht, oder nur wenig gedämmt ist, habe ich nach kurzer Recherche ausrechnen können, dass ich ca. 1200-1400 Watt haben sollte.

Infrarotheizung Panael an Decke montiert
Infrarotheizung an Decke montiert
Steckdosen in Werkstatt an der Decke für die Infrarotheizungen
Steckdosen in Werkstatt

Nachdem das geschafft war, ging es an die Steuerung. Diese sollte natürlich über den KNX Bus stattfinden. Ich musste also erstmal die Temperatur der Werkstatt messen und an den Homeserver übertragen.

Temperatur Messung

Um die Temperatur zu messen habe ich den Sensor aus der Garage wiederverwendet. Dieser hat regelmäßig seine Firmware nach dem Tiefschlaf nicht mehr wieder gefunden und leider muss ich sagen, das der eingebaute Lüfter es auch nicht geschafft hat die Temperatur in der Garage spührbar zu reduzieren, also wird der jetzt recycelt.

Ich habe dann eine neue Firmware drauf gespielt die ich vom Zisternen-Sensor übernommen habe und somit von PUSH auf PULL umgestellt.

#include <ESP8266WiFi.h>
#include <ESP8266WebServer.h>
#include <DHT.h>
#define DHTTYPE DHT22

const int DHTPin = 2;
ESP8266WebServer server(80); // Webserver
WiFiClient client;
DHT dht(DHTPin, DHTTYPE);

struct measureData{
  float temp;
  float humi;
};

void setup() {
  Serial.begin(115200);

  IPAddress ip(192, 168, X, Y);
  IPAddress gateway(192, 168, X, Y); 
  IPAddress subnet(255, 255, 255, 0); 
  WiFi.config(ip, gateway, subnet);
  WiFi.begin("<SSID>", "<PASSWORD>");

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

  Serial.print("Connected, IP address: ");
  Serial.println(WiFi.localIP());  

  server.on("/", handle_normal);
  server.on("/hs", handle_hs);
  server.on("/hs/1", handle_hs);
  server.onNotFound(handle_NotFound);  
  server.begin();
  Serial.println("http server startet");

  dht.begin();
  Serial.println("dht startet");
}

void loop() {
  server.handleClient();
}

void handle_NotFound(){
  server.send(404, "text/plain", "Not found");
}

void handle_normal() {
  Serial.println("handle /");
  struct measureData measureData = getMeasureData();
  String msg = String("<!DOCTYPE html><html>") + 
    "<head><meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">" + 
    "<link rel=\"icon\" href=\"data:,\">" + 
    "<body><h1>Werkstatt Temperature Server</h1>" + 
    "<p>Use get parameter hs for homeserver</p>" + 
    "<p>Exampe: /hs/1</p>" + 
    "<br><br><p>Current temp: " + String(measureData.temp) + "</p>" + 
    "<br><p>Current humi: " + String(measureData.humi) + "</p>" + 
    "</body></html>\r\n" ;
  server.send(200, "text/html", msg); 
}

void handle_hs() {
  Serial.println("handle /hs");
  struct measureData measureData = getMeasureData();
  String msg = String("T=" + String(measureData.temp) + "\r\n");
  server.send(200, "text/html", msg); 
} 

struct measureData getMeasureData() {
    float h, t;
    struct measureData measureData;

    delay(4000);
    h = dht.readHumidity();
    t = dht.readTemperature();
    Serial.println(t);
    Serial.println(h);        
        
    if (!isnan(t)) {
      measureData.temp = t;
    }
    if (!isnan(h)) {
      measureData.humi = h;
    }
    return measureData;
}

Und natürlich wollte ich jetzt erstmal prüfen, ob das alles denn auch funktioniert. Dazu habe ich dann den Sensor provisorisch zusammen mit einem Oldschool-Analog-Thermometer in der Werkstatt platziert.

Temperatursensor in Werkstatt
Neuer Temperatursensor in Werkstatt
Thermometer in Werkstatt
Analoges Thermometer in Werkstatt

Und siehe da: Der Sensor vertut sich um gut 2-3 Grad – so geht das aber nicht!

Schaltungsüberarbeitung

Und dann ging die Suche los:
Zunächst einmal habe ich die Schaltung überarbeitet und einen Pull-Up Wiederstand (4.7k) sowie den im Datenblatt des DHT22 aufgeführten 100nF Kondensator eingefügt.

Überarbeitete Sensorschaltung auf Lachrasterplatine Oberseite
Überarbeiteter Sensor Oberseite
Überarbeitete Sensorschaltung auf Lachrasterplatine Unterseite
Überarbeiteter Sensor Unterseite

Ich weiß nicht genau was von den Maßnahmen geholfen hat, aber nachdem ich den überarbeiteten Sensor so in der Werkstatt aufgestellt hatte, deckte sich die Messung 1zu1 mit dem analogen Thermometer.

KNX Anbindung

Die Anbindung an den Homeserver findet auf die gleiche Weise statt, wie schon bei der Zisterne. Ich habe ein KO angelegt und mitteils Webseitenaufruf wird der Wert von der Webseite des ESP gelesen.

Webseitenaufruf IP-Adresse
Webseitenaufruf IP
Webseitenaufruf URL
Webseitenaufruf URL
Webseitenaufruf Werte auslesen
Webseitenaufruf Werte

Der Webseitenaufruf wird dann mittels Logik einmal pro Minute wiederholt.

Die Logik

Und zum Schluß musste noch eine Logik her, welche die gemessene Temperatur mit der Wunschtemperatur vergleicht und unter Berücksichtigung von Pufferwerten dann die Steckdosen für die Heizungen an- bzw abschaltet.

09.10.2022: Ich hatte ein paar Probleme mit der alten Logik, da diese nicht richtig berücksichtigt hat wenn der ESP Temperatursensor einmal ausfällt. Das ist schon 2 oder 3 mal passiert. Dann lief die Heizung in der Vergangenheit ohne Unterbrechungen auf voller Kraft. Die neue Logik berücksichtig das jetzt besser.

Homeserver Logik zur Steuerung der Werkstattheizung

Wie schon angekündigt hat mein letzter Raspberry mit meiner Zigbee-Steuerung seine SD-Karte zerlegt – was ja immer ein Damoklesschwert über dem Kopf eines jeden ist, der die kleinen PCs mit SD-Karte betreibt und dort auch Datenbanken o.ä. drauf laufen lässt.

Da die PIs ab Version 3 aber auch endlich (ordentlich) aus dem Netzwerk booten können, habe ich mich entschieden nach und nach allen PIs die SD-Karte weg zu nehmen und nur noch über das Netzwerk zu arbeiten. Hier ist die kleine Anleitung dazu:

Verwendet wurden:
– QNAP NAS
– Raspberry PI 3 B V1.2

Vorbereitung DHCP Server

  • Damit der PI aus dem Netzwerk booten kann habe ich meinen DHCP Server so konfiguriert, das er immer die gleiche IP vergibt
  • Außerdem habe ich noch folgende DHCP Optionen gesetzt:
  • “Vendor encapsulated options” = Raspberry Pi Boot
  • “TFTP Servername” = 192.168.x.y (das ist die IP vom NAS)
  • “Bootfile Name” = bootcode.bin

Vorbereitung Raspberry Pi

  • Wie üblich mit dem Raspberry Pi Imager eine (neue) SD-Karte beschrieben und das Betriebssystem “Raspberry Pi OS Lite” installiert (ohne grafische Oberfläche)
  • Dann das System hochgefahren und die grundlegende Installation abgeschlossen (raspi-config, usw.)
  • Damit der Pi über das Netzwerk booten kann, muss ein Eintrag in der /boot/config.txt geändert werden (ganz am Ende)
nano /boot/config.txt
program_usb_boot_mode=1
  • Anschließend den PI neu starten und die Zeile wieder entfernen. Die Einstellung bleibt dauerhaft erhalten.
  • Der Erfolg kann nach dem Neustart wie folgt überprüft werden
vcgencmd otp_dump | grep 17
Ergebniss: 17:3020000a

Einrichtung QNAP NAS

  • Als erstes habe ich die Freigabe “Public” per NFS freigegeben. Hier soll später das Root-Dateisystem liegen und auch die Dateien für den Bootvorgang werde ich hier ablegen. Dazu muss der NFS-Dienst ggf. vorher in der Systemsteuerung aktiviert werden.
  • Gastzugang per Samba/Windows wird für “Public” deaktiviert, bzw. auf “kein Zugriff” gestellt
  • Auf der Public-Freigabe erstellle ich einen Ordner “pxeboot”
  • In dem Ordner “pxeboot” erstelle ich dann pro Raspberry einen weiteren Unterordner. Hier z.b. “zigbee”
  • Und in dem Ordner “zigbee” erzeuge ich dann noch einen Ordner “boot”
  • Außerdem brauche ich für den Netzwerkboot noch einen TFTP Server, der auf den QNAP-NAS wie folgt konfiguriert wird
  • Nun starte ich den Pi einmal ohne die SD-Karte neu und schaue in die Log-Datei “Public\pxeroot\opentftpd.log”. Dort steht jetzt drin welche Dateien gefunden/nicht gefunden wurden. Bei der Datei “start.elf” ist auch ein Unterordner zu sehen, der die Seriennummer des PIs darstellt. Diese merke ich mir, denn ich muss im nächsten Schritt einen passenden Symlink anlegen
  • Darum melde ich mich auf der Console des NAS per SSH an und mittels “ln -s /share/Public/pxeroot/zigbee/boot /share/Public/pxeroot/<seriennummer>” erzeuge ich einen Symlink mit der passenden Seriennummer, der in das boot-Verzeichniss des entsprechenden PIs zeigt

Kopieren der Daten

  • Zunächst melde ich mich am Pi an und mounte die NFS-Freigabe. Anschließend kopiere die gesamte Root-Partition auf die NFS-Freigabe
sudo mount.nfs 192.168.X.Y:/Public/pxeroot/zigbee /mnt
sudo rsync -xa --exclude /mnt / /mnt/
  • Nachdem der Kopiervorgang abgeschlossen ist (kann etwas dauern) müssen noch ein paar Dateien angepasst werden.
  • Zunächst “nano /mnt/etc/fstab”. Es wird alles entfernt außer “proc” und die vier tmpfs sowie das NFS-Root werden hinzugefügt
proc /proc proc defaults 0 0
192.168.X.Y:/Public/pxeroot/zigbee	/ 	nfs 	defaults 	0 	0
tmpfs /tmp tmpfs defaults,noatime,nosuid,size=100m 0 0
tmpfs /var/tmp tmpfs defaults,noatime,nosuid,size=30m 0 0
tmpfs /var/log tmpfs defaults,noatime,nosuid,mode=0755,size=100m 0 0
tmpfs /var/run tmpfs defaults,noatime,nosuid,mode=0755,size=2m 0 0
  • Dann fahre ich den Pi herunter und lege die SD-Karte in meinen PC ein (da wo ich diese auch beschrieben habe). Ich kopiere den ganzen Inhalt, also die ganzen .elf-Dateien, config.txt usw. in den Boot-Ordner auf der Netzwerkfreigabe
  • Die Datei “bootcode.bin” jedoch kopiere ich direkt in den Ordner “pxeroot”
  • Dann wird noch die “cmdline.txt” im Boot-Ordner angepasst:
dwc_otg.lpm_enable=0 console=serial0,115200 console=tty1 root=/dev/nfs nfsroot=192.168.X.Y:/Public/pxeroot/zigbee rw vers=3 ip=dhcp rootfstype=nfs smsc95xx.turbo_mode=N elevator=deadline rootwait

Neustart des Raspberry Pi

Jetzt müsste der Pi ohne SD-Karte neu gestartet werden können. Er wird nach ca. 5 Sekunden vom Netzwerk booten und das System wird bis auf eine Fehlermeldung bzgl. der SWAP-Datei ganz normal hoch fahren.

Dann sind noch folgende, abschließende Arbeiten zu tun:

  • Deinstallieren von “dphys-swapfile” und erstellen und einbinden einer manuell erzeugten SWAP-Datei
sudo apt-get remove --purge dphys-swapfile
sudo rm /var/swap
sudo update-rc.d dphys-swapfile remove
 
sudo dd if=/dev/zero of=/var/swap bs=1M count=1024
sudo losetup /dev/loop0 /var/swap
sudo mkswap /dev/loop0
sudo swapon /dev/loop0

vi /etc/rc.local
echo "Swap einbinden"
sleep 3
losetup /dev/loop0 /var/swap
mkswap /dev/loop0
swapon /dev/loop0
  • Außerdem mache ich noch ein bischen Tuning
vi /etc/default/rcS
ASYNCMOUNTNFS=no 

vi /etc/sysctl.conf
vm.min_free_kbytes=12288
  • Dann noch ein abschließender Neustart und die Konfiguration ist abgeschlossen.

Wie schon oft beschrieben statte ich meinen Garten mit einer Ambiente-Beleuchtung auf Zigbee Basis aus.

Hier habe ich den Grillpavillon und die Teichbeleuchtung beschrieben.

In diesem Beitrag soll es nun um die automatische Steuerung gehen, denn das was die deCONZ App so kann, reicht mir leider nicht.

Da ich ja schon einen Rasperry für deCONZ in Betrieb habe, werde ich eine Webseite auf diesem laufen lassen und dann über REST-API mit deCONZ sprechen.

Ziel ist es, das ich “Animationen” abspielen kann. Also Farbübergänge, Helligkeitsübergänge, usw. Hatte hier ja schon mal ein Video gepostet. Es ist ja immerhin Ambiente-Licht. 🙂

Licht Animationen

Ich habe mich also hingesetzt und ein kleines PHP-Projekt mit Symfony geschrieben. Die Bedienung ist aufs Handy ausgelegt und aktuell ist die Funktion nur ganz simpel (und die Oberfläche ist noch nicht wirklich schön).

  • Es können mehrere “Szenen” erstellt werden
  • Innerhalb einer Szene können beliebige Lampen sein
  • Jede Lampe in einer Szene kann verschiedene “Aktionen” ausführen
  • Zwischen den Aktionen können beliebige Zeitintervalle vergehen
  • Am Ende einer Szene wird diese wiederholt, oder zur nächsten Szene gewechselt

Und dann kam wieder mal alles anders, als geplant

Denn der Raspberry, der die deCONZ App ausführt hat seine SD-Karte zerlegt, und damit ist die ganze Arbeit dahin.
Da ich nicht wieder auf SD-Karten setzen will, bringe ich jetzt allen PIs bei vom Netzwerk zu booten (genauer von meinem QNAP NAS) und setze dann die deCONZ App wieder auf.

Meine Steuersoftware werde ich dann übrigens nochmal komplett neu machen, und zwar als Blazor Projekt. Also komplett in C# – doch das ist ein anderer Beitrag…

Wie in den anderen Beträgen schon erwähnt, möchte ich die Ambiente-Beleuchtung meines Gartens mit Zigbee umsetzen, damit ich das Licht (Farbe, Helligkeit, usw) vom Smartphone oder natürlich auch automatisch steuern kann.

Hier habe ich die Installation den Gateways beschrieben und hier die Ambiente-Licht des Grill Pavillons.

In diesem Beitrag soll es jetzt um die Beleuchtung des Teiches gehen.
Für diesen habe ich mir 4 Zigbee GU10 Leuchmittel und 4 Erdspießleuchten (ohne Leuchtmittel) besorgt.
Diese haben blöderweise ein fest eingschweistes (und damit Wasserfestes) Anschlusskabel – was natürlich immer zu kurz ist. Doch dazu gleich.

Erstmal die cleveren Leuchtmitteln in die Lampen einbauen:

Wegen der immer zu kurzen Anschlusskabel muss ich die Kabel irgendwie Wasserfest verlängern. Bei meiner Suche nach einer Lösung vielen mir dann diese IP68 Muffen von Pollin in die Hände, wovon ich umgehend ein paar bestellt habe. Gibt es nicht nur als T-Stück, sondern auch als Verlängerung. Die Fotos sind schon bei der Montage am Teich entstanden.

Damit konnte ich dann mein Anschlusskabel mit den Lampen verbinden. Über KNX schalte ich also jetzt “nur noch” den Strom der Ambientebeleuchtung (per Szene gehen alle Leuchten auf einmal an), die Farbe und Helligkeit steuere ich dann über Zigbee. Auch dafür habe ich mir noch etwas ausgedacht, aber das ist ein anderes Projekt… 😉

So, sieht der fertige Teich jetzt aus.

Teich mit Beleuchtung und Wasserfall
Teich mit Beleuchtung und Wasserfall

(Handy-Foto im dunkeln. Entschuldigt das Bildrauschen und auch die Lichtstimmung kommt nicht richtig rüber)