Finally!
Nachdem wir erst eine Sole-Box gebaut haben, bedampfen wir nun doch.
Lange habe ich mich gewehrt, aber nachdem die Sole-Box dann doch keine dauerhafte Linderung brachte, haben wir entschieden doch zu bedampfen.
Nachdem wir 2 wunderschoene Futterboxen auf Raedern hatten, wollten wir auch den Bedampfer selber bauen. In Wirklichkeit waren diese rollenden Futterboxen urspruenglich allerdings einmal Behaelter fuer Crush-Eis in einer bekannten Plaetzchenfabrik, wo sie ausgesondert wurden und wir sie durch einen Kumpel abgreifen konnten. Also, lebenmittelecht und stark isoliert mit ca. 3 cm dicken Waenden und damit perfekt geeignet.
Teile
Was brauchten wir, ausser den beiden Boxen?
(Liste enthaelt, womit wir arbeiten, keine explizite Kaufempfehlung. Anzahl passend fuer 2 Boxen)
- 2 x WAGNER Dampftapetenablöser SteamForce, Behälter 4 l, Dampfzeit max. 70 min, Gelb, Weiss, 3,7 m Schlauch, 2.000 W, 230 V
- 2 x Aiyraa Tankdurchführung 1/2 Zoll, Schottverschraubung 1/2 Zoll aus Messing mit Silikondichtung, Hochwertige Schlauchdurchführung für Wassertank, Wasserturm, Wasserpumpe und Regentonne
- Noosverl 2 Stücke Reduzierstück 1/4 auf 1/2 Zoll, Reduzierverlängerung 1/4 Zoll außen x 1/2 Zoll innen Messing Gewinde/Messing Fittings
(Passend zum Anschluss an den WAGNER oben) - 2 x Sani-Flex Edelstahlwellrohr DN12 bis DN50, normal gewellt, 1.4404, Meterware, Preis pro Meter, Lnge nach Wunsch, ideal fr Wrmetauscher, DN-Gre: DN12-1/2 Zoll
- 2 Stück 1/2″ Messing Stopfen, Blindstopfen Rohr Endkappe 1/2 Zoll Außengewinde, Messing Rohrstopfen mit Gummiring, Endstopfen Verschlussstopfen für Heizung und Trinkwasseranlage
(Kommen an die Schlauchenden in der Bedampfer-Box) - 4 Stueck H2O-Flex® 1/2″ Anschluss-Set Edelstahlwellrohr DN12 Verschraubung für Solar und Sanitär
Das Meiste davon liegt unter 10,- €. Am teuersten sind natuerlich die WAGNER Dampftapetenablöser mit ca. 50,- € je Stueck und die Sani-Flex Edelstahlwellrohre zu je ca. 25,- €.
Optional, wenn man Internet/WLAN zur Verfuegung hat und gerne etwas cooles Bastelt.
- Raspberry Pi 4 oder 5
- Aideepen 2 Stuck Temperatursensor, 10m Kabel Wasserdicht Temperaturfühler digitaler Edelstahl Temperatursensor kompatibel mit Arduino und Raspberry Pi
- AZDelivery Jumper Wire Kabel 3 x 40 STK. je 20 cm M2M/ F2M / F2F kompatibel mit Arduino und Raspberry Pi
(Benoetigt werden 3 Kabel mit weiblichen Jumper-Steckern, die andere Seite ist egal, die wird abgepitscht) - AZDelivery Widerstände Resistor Kit 525 Stück Widerstand Sortiment, 0 Ohm -1M Ohm
(Benoetigt wird ein 7,4K Ohm Widerstand) - Shelly Plus Plug S Doppelpack – Intelligente Steckdose Funktioniert mit Alexa & Google Home, programmierbare mit Sprachsteuerung, Bluetooth; Wi-Fi-Gerät zur Automatisierung von Geräten
Die Bedampfer-Box
Zuerst wird, passend zur 1/2-Zoll Tankdurchfuehrung, ein Loch in die Box gebohrt.
Durch das Loch stecken wir die Tankdurchfuehrung und verschrauben sie mit den mitgelieferten Verschraubung und Dichtung so, dass man auf beiden Seiten (innen und aussen) genug Gewinde hat um etwas drauf zu schrauben.
Nun wird aussen an der Box das Reduzierstueck 1/2 Zoll auf 1/4 Zoll augeschraubt. Das kommt ebenfalls mit Dichtung.
In das Edelstahlwellrohr werden nun Loecher gebohrt. Ich habe eine gute handbreit Platz gelassen zwischen den Loechern. Danach werden die 1/2 Zoll Schrauben mit einen Ring, vorne und hinten am Wellrohr angebracht. Eine Seite wird nun innen in der Box auf die Tankdurchfuehrung geschraubt, waehrend das Wellrohr auf dem Boden der Box ausgelegt wird. Am ende des Wellrohres wird nun ein Messing Stopfen aufgeschraubt um das Wellrohr zu verschliessen.
Von aussen noch den Schlauch des WAGNER Dampftapetenabloeser an das Reduzierstueck an der Tankdurchfuehrung schrauben.
Nach diesen Arbeiten haben wir den Bedampfer in einen ersten kurzen Testlauf (ohne Deckel) geschickt.
Danach haben wir noch unser Backofen Rost darueber gelegt, um die Installation unten und das Heu zu schuetzen.
Wir packen das Heu in grosse Netze, die dann in den Bedampfer kommen. Oben drauf machen wir die Box mittlerweile mit losem Heu voll, falls Platz frei ist.
Hier der erste Testlauf am Stall mit Heu.
Ready to go…
Was sehr angenehm ist bei unseren Boxen und darueber sollte man sich beim Bau auch gedanken machen, die Boxen haben einen Ablauf! In den Boxen bildet sich natuerlich Kondenswasser. Das muss da auch wieder raus. Eine Moeglichkeit das ohne grossen Aufwand wieder raus zu bekommen ist toll!
Die Steuerung (Premium Bedampfer Version 🙂 und optional)
Und ab hier wird es dann auch wirklich technisch.
Das Thermometer hat (in meinem Fall) ein 10 Meter langes Kabel mit 3 Adern (rot, gelb und schwarz).
Wir nehmen also 3 Jumper Kabel (vorzugsweise in identischen Farben wie die Adern im Thermometer) und verloeten diese mit der gleichfarbigen Ader aus dem Thermometer. Damit bekommt jede Ader im Thermometer einen weiblichen Jumper-Stecker.
Zusaetzlich verbinden wir das rote und das gelbe Kabel mit einem 4700 Ohm Widerstand.
Etwa so:
Nur schoener 😀
Danach haben wir 3 weibliche Jumper-Stecker an unserem Thermometer.
Nun stecken wir diese auf die Pinne im Raspberry Pi 4 oder 5 und zwar wie folgt:
– 3V3 power = rot
– GPIO 4 (CPCLK0) = gelb
– Ground = schwarz
Nun den Raspi in sein Gehaeuse stecken und Kabel an der Seite nach aussen fuehren.
Raspi starten und einrichten.
Zuerst sicherstellen dass Python3 installiert ist:
$ sudo apt-get install python3
$ # Das naechste Kommando installiert die Python Library fuer den Sensor
$ sudo pip3 install w1thermsensor
$ sudo pip3 install Flask
$ sudo raspi-configDas Kommando ‘sudo raspi-config’ ruft ein Menue auf.
Hier gehen wir zu: → Interface Options → 1-Wire → Enable → Yes → OK → Finish → Reboot (ja, rebooten!)
Nach dem reboot wieder anmelden und die Erreichbarkeit des Sensors pruefen
$ w1thermsensor ls
28-000000789abcDer Sensor heisst also irgendwas in der Art: 28-000000789abc
Das heisst, er wird im System gefunden und kann ausgelesen werden.
Man kann nun mit der Einrichtung beginnen.
Als erstes benoetigen wir eine kleine Datenbank mit 3 Tabellen:
$ sudo apt-get install mariadb-server-10.5
$ mysql
MariaDB [none]> CREATE DATABASE `heuBedampfer`
MariaDB [none]> use heuBedampfer;
MariaDB [heuBedampfer]> CREATE TABLE `Bedampfer` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`timestamp` datetime DEFAULT current_timestamp(),
`sensorId` varchar(50) DEFAULT NULL,
`name` varchar(10) DEFAULT NULL,
`temperature` decimal(5,2) DEFAULT NULL,
`avg` decimal(5,2) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB
MariaDB [heuBedampfer]>
MariaDB [heuBedampfer]>
MariaDB [heuBedampfer]> CREATE TABLE `alarm_state` (
`sensor_name` varchar(10) NOT NULL,
`last_alarm_ts` datetime DEFAULT NULL,
`phase_start_ts` datetime DEFAULT NULL,
`updated_at` datetime DEFAULT current_timestamp() ON UPDATE current_timestamp(),
PRIMARY KEY (`sensor_name`)
) ENGINE=InnoDB
MariaDB [heuBedampfer]>
MariaDB [heuBedampfer]>
MariaDB [heuBedampfer]> CREATE TABLE `alarm_log` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`sensor_name` varchar(10) NOT NULL,
`event_type` enum('FIRST_ALARM','REMINDER','END_PHASE') NOT NULL,
`timestamp` datetime DEFAULT current_timestamp(),
`duration_min` int(11) DEFAULT NULL,
`current_temp` decimal(5,2) DEFAULT NULL,
PRIMARY KEY (`id`),
KEY `idx_sensor_ts` (`sensor_name`,`timestamp`)
) ENGINE=InnoDB
MariaDB [heuBedampfer]> GRANT all on heuBedampfer.* to heuBedampfer@'127.0.0.1' identified by 'sUp3rSecure';Damit haben wir eine Datenbank erstellt: heuBedampfer
Sowie 3 Tabellen in dieser Datenbank: Bedampfer, alarm_state, alarm_log
Und einen User ‘heuBedampfer’ mit dem Passwort ‘sUp3rSecure’
(Passwort natuerlich aendern, auch in den scripten in der DB_CONFIG)
Jetzt fragen wir mit einem kleinen python script jede Minute die aktuelle Temperatur des Sensors ab und speichern sie in die Datenbank.
#!/usr/bin/env python3
import os
from glob import glob
from flask import jsonify
# Pfad zu den 1-Wire-Geräten
BASE_DIR = '/sys/bus/w1/devices/'
DEVICE_PATTERN = BASE_DIR + '28-*'
DB_CONFIG = {
'host': '127.0.0.1',
'user': 'heuBedampfer',
'password': 'sUp3rSecure',
'database': 'heuBedampfer',
'charset': 'utf8mb4',
'autocommit': True
}
def insert_data(data):
conn = connect_db()
c = conn.cursor()
try:
avg = data.get('average_temperature')
for sensor in data.get('sensors', []):
c.execute('''
INSERT INTO Bedampfer (sensorId, name, temperature, avg)
VALUES (%s, %s, %s, %s)
''', (
sensor.get('id'),
sensor.get('name'),
sensor.get('temperature'),
avg
))
conn.commit()
finally:
conn.close()
def read_temperature(device_folder):
device_file = device_folder + '/w1_slave'
try:
with open(device_file, 'r') as f:
lines = f.readlines()
if lines[0].strip().endswith('YES'): # CRC OK
temp_str = lines[1].split('t=')[1]
return float(temp_str) / 1000.0
else:
return None
except:
return None
def get_all_sensors():
device_folders = sorted(glob(DEVICE_PATTERN)) # sortiert!
sensors = []
temps = []
for idx, folder in enumerate(device_folders):
sensor_id = os.path.basename(folder)
temp = read_temperature(folder)
name = f"S{idx + 1}"
sensors.append({
"name": name,
"id": sensor_id,
"temperature": round(temp, 2) if temp is not None else None
})
if temp is not None:
temps.append(temp)
average = round(sum(temps) / len(temps), 2) if temps else None
return sensors, average
sensors, average = get_all_sensors()
data = jsonify({
"sensors": sensors,
"average_temperature": average
})
insert_data(data)Das script speichern wir als ~/bin/monitor_temperature.py
Jetzt machen wir die datei ausfuehrbar und legen den cronjob (oder in WIndows-Sprech: ScheduledTask) an.
$ chmod 700 ~/bin/monitor_temperature.pyJetzt per ‘crontab -e’ den crontab editor aufrufen und mindestens die Zeile unter ‘# Heubedampfer’ einfuegen:
# m h dom mon dow command
# Heubedampfer
* * * * * /home/<piUser>/bin/monitor_temperature.py > /dev/nullWir sind soweit.
Die benoetigten Daten werden nun einmal pro Minute in unsere Datenbank geschrieben.
Kommen wir nun zur Ueberwachung!
Wir wollen, dass der Bedampfer automatisch abschaltet und uns Nachrichten senden kann. Dazu benoetigen wir ein 2. Script, was unsere Datenbank verwendet und dort abfragt:
1) Ist der Bedampfer eingeschaltet?
2) Wenn ja, wie heiss ist die Temperatur und liegt diese ueber 80° C?
3) Wenn ebenfalls ja, liegt die Temperatur von ueber 80° C seit 30 Minuten oder laenger an?
4) Wenn ja, sende Telegram Nachricht.
5) Hat die Temperatur 97° C erreicht? –> Bedampfer abschalten –> Telegram Nachricht
Dazu muss als erstes die Shelly WLAN Steckdose eingerichtet werden, worauf ich hier nicht weiter eingehen werde. ChatGPT ist dein Freund. Am besten gebt ihr der Steckdose eine feste IP Adresse und lasst diese nicht von Router dynamisch zuweisen. So koennt ihr sicher sein, dass die Steckdose keine neue IP bekommt und ihr sie nicht mehr erreicht. Ich werde in diesem Beispiel die IP 192.168.1.6 verwenden. Diese muesst ihr durch die IP eurer eigenen Shelly Dose ersetzen, wenn ihr sie im WLAN habt.
Damit das Alertscript Telegram Nachrichten versenden kann, benoetigt man einen Telegram-Bot.
Geht auf euer Handy, oeffnet die Telegram App und sucht den User ‘@BotFather’. Diesem schickt ihr eine erste Nachricht mit dem Inhalt ‘/start’ und folgt den Anweisungen zur Erstellung eures eigenen Bot.
Am Ende bekommt ihr ein sogenanntes Telegram Token das in etwa so aussieht: 123456789101112:AAN7W_KqoR7fdHulUHLuhhluh56Nkhu
Dieses Token muesst ihr irgendwo speichern und duerft es niemandem geben! Es ist quasi Benutzername und Password des Bots, damit er sich bei Telegram anmelden kann.
Wir erstellen nun ein Script und speichern es als ‘~/bin/bedampferAlert.py’
In diesem Script muesst ihr euer Bot Token sowie eure persoenliche Telegram ChatID eintragen, sowie die INTERNAL_SHELLY_IP mit der IP in eurem Netzwerk befuellen.
Bezueglich der Telegram ChatID, das ist quasi der Empfaenger der Nachrichten die der Bot sendet, also eure eigene ID. Man kann, wenn man moechte dass die Nachrichten von mehreren Personen empfangen werden, auch eine Telegram Gruppe erstellen und die ChatID der Telegram Gruppe in den Scripten angeben. Dazu fuegt man sich selbst, den Bot und die weiteren Empfaenger der Gruppe hinzu, macht dem Bot zum ‘Gruppen-Admin’ (wichtig, sonst kann er nichts senden) und gibt die Gruppen ChatID an.
Das alles geht.
Aber zurueck zum Script…
Zuerst die benoetigten Libraries auf dem Raspi installieren
$ sudo pip3 install asyncio pymysql python-telegram-botSollte ich Libraries vergessen haben, einfach mit pip3 installieren.
Jetzt das Script erstellen.
#!/usr/bin/env python3
import asyncio
import pymysql
from datetime import datetime, timedelta
from telegram import Bot
from telegram.error import TelegramError
import requests
import json
import urllib3
# Hier muesst ihr die IP durch die IP eurer Shelly Dose ersetzen
INTERNAL_SHELLY_IP = '192.168.1.6'
# In der naechsten Zeile euer Bot Token zwischen den '' einfuegen
TELEGRAM_TOKEN = ''
# In der naechsten Zeile eure eigene ChatID zwischen den '' einfuegen
TELEGRAM_CHAT_ID = ''
# In den folgenden 4 Zeilen koennt ihr die Schwellwerte beeinflussen
TEMP_THRESHOLD = 80.0
TEMP_TURN_OFF = 97.0
MIN_DURATION_MINUTES = 30
REMINDER_INTERVAL_MINUTES = 10
DB_CONFIG = {
'host': '127.0.0.1',
'user': 'heuBedampfer',
'password': 'sUp3rSecure',
'database': 'heuBedampfer',
'charset': 'utf8mb4'
}
async def send_telegram(text):
try:
bot = Bot(token=TELEGRAM_TOKEN)
await bot.send_message(
chat_id=TELEGRAM_CHAT_ID,
text=text,
parse_mode='HTML'
)
print(f"Telegram gesendet: {text}")
except TelegramError as e:
print(f"Telegram-Fehler: {e}")
except Exception as e:
print(f"Anderer Fehler beim Senden: {e}")
def connect_db():
return pymysql.connect(**DB_CONFIG)
async def get_sensor_state(cursor, sensor_name):
cursor.execute("""
SELECT last_alarm_ts, phase_start_ts
FROM alarm_state
WHERE sensor_name = %s
""", (sensor_name,))
row = cursor.fetchone()
if row:
return {
'last_alarm': row[0],
'phase_start': row[1]
}
return {'last_alarm': None, 'phase_start': None}
async def update_sensor_state(cursor, sensor_name, last_alarm=None, phase_start=None):
cursor.execute("""
INSERT INTO alarm_state (sensor_name, last_alarm_ts, phase_start_ts)
VALUES (%s, %s, %s)
ON DUPLICATE KEY UPDATE
last_alarm_ts = VALUES(last_alarm_ts),
phase_start_ts = VALUES(phase_start_ts),
updated_at = CURRENT_TIMESTAMP
""", (sensor_name, last_alarm, phase_start))
async def log_alarm(cursor, sensor_name, event_type, duration_min=None, current_temp=None):
cursor.execute("""
INSERT INTO alarm_log (sensor_name, event_type, duration_min, current_temp)
VALUES (%s, %s, %s, %s)
""", (sensor_name, event_type, duration_min, current_temp))
async def shelly_action(action):
url = f"http://{INTERNAL_SHELLY_IP}/shelly/relay?turn={action}"
try:
r = requests.get(url, timeout=5, verify=False)
r.raise_for_status()
data = r.json()
return json.dumps({
"status": "success",
"response": data
})
except requests.exceptions.RequestException as e:
return json.dumps({"error": str(e)}), 500
async def check_sensor(cursor, sensor_name):
logdate = datetime.now().strftime("%Y-%m-%dT%H:%M:%S")
# Aktuellste Messung
cursor.execute("""
SELECT timestamp, temperature
FROM Bedampfer
WHERE name = %s
ORDER BY timestamp DESC
LIMIT 1
""", (sensor_name,))
row = cursor.fetchone()
if not row:
print(f"[{logdate}]: {sensor_name}: Keine Daten")
return
#shelly_status = json.loads(await shelly_action('status'))
#print(shelly_status['response']['data']['apower'])
current_ts, current_temp = row
if current_temp is None or current_temp < TEMP_THRESHOLD:
print(f"[{logdate}]: {sensor_name}: {current_temp:.2f} °C < {TEMP_THRESHOLD} → OK")
await update_sensor_state(cursor, sensor_name, None, None)
return
# Letzter Zeitpunkt < 80 °C
cursor.execute("""
SELECT MAX(timestamp)
FROM Bedampfer
WHERE name = %s
AND temperature < %s
AND timestamp <= %s
""", (sensor_name, TEMP_THRESHOLD, current_ts))
last_low_ts_row = cursor.fetchone()
last_low_ts = last_low_ts_row[0] if last_low_ts_row and last_low_ts_row[0] else None
if last_low_ts:
duration_minutes = (current_ts - last_low_ts).total_seconds() / 60
else:
cursor.execute("""
SELECT MIN(timestamp)
FROM Bedampfer
WHERE name = %s
""", (sensor_name,))
first_ts_row = cursor.fetchone()
first_ts = first_ts_row[0] if first_ts_row else current_ts
duration_minutes = (current_ts - first_ts).total_seconds() / 60
print(f"[{logdate}]: {sensor_name}: {current_temp:.2f}° – seit {duration_minutes:.1f} Minuten >= 80 °C")
state = await get_sensor_state(cursor, sensor_name)
last_alarm = state['last_alarm']
phase_start = state['phase_start']
now = datetime.now()
# check power status
try:
shelly_status = json.loads(await shelly_action('status'))
#print(shelly_status['response'])
s_status = shelly_status['response']['status']
s_output = shelly_status['response']['data']['output']
s_power = shelly_status['response']['data']['apower']
except Exception as e:
print(str(e))
shelly_status = None
re_get_status = False
power_string = "Not found"
if current_temp >= TEMP_TURN_OFF:
if shelly_status != None:
if s_output:
print(f"[{logdate}]: {sensor_name}: 97° reached. Turning off!")
await shelly_action('off')
await send_telegram(f"{sensor_name}: {current_temp} >= 97° - Turning off!")
re_get_status = True
# re-get shelly status
if re_get_status:
try:
shelly_status = json.loads(await shelly_action('status'))
s_status = shelly_status['response']['status']
s_output = shelly_status['response']['data']['output']
s_power = shelly_status['response']['data']['apower']
except Exception as e:
print(str(e))
shelly_status = None
if shelly_status != None:
if s_output:
ss = "On"
else:
ss = "Off"
power_string = f"{ss} - {s_power} W"
# Erst-Alarm?
if duration_minutes >= MIN_DURATION_MINUTES and (phase_start is None or phase_start != last_low_ts):
msg = (
f"<b>{sensor_name} Bedampfer: Erst-Alarm</b>\n"
f"≥ {TEMP_THRESHOLD} °C seit {duration_minutes:.0f} Minuten\n"
f"Aktuell: {current_temp:.2f} °C\n"
f"Power-Status: {power_string}\n"
f"Phase-Start: {last_low_ts.strftime('%d.%m.%Y %H:%M') if last_low_ts else 'unbekannt'}"
)
await send_telegram(msg)
await log_alarm(cursor, sensor_name, 'FIRST_ALARM', duration_minutes, current_temp)
await update_sensor_state(cursor, sensor_name, now, last_low_ts)
if shelly_status != None:
if s_output:
await shelly_action('off')
# Erinnerung?
elif duration_minutes >= MIN_DURATION_MINUTES and last_alarm:
time_since_last = (now - last_alarm).total_seconds() / 60
if time_since_last >= REMINDER_INTERVAL_MINUTES:
msg = (
f"<b>{sensor_name} Bedampfer: Erinnerung</b>\n"
f"Immer noch ≥ {TEMP_THRESHOLD} °C seit {duration_minutes:.0f} Minuten\n"
f"Aktuell: {current_temp:.2f} °C\n"
f"Power-Status: {power_string}"
)
await send_telegram(msg)
await log_alarm(cursor, sensor_name, 'REMINDER', duration_minutes, current_temp)
await update_sensor_state(cursor, sensor_name, now, phase_start)
# Phase beendet?
if current_temp < TEMP_THRESHOLD and phase_start:
duration = (current_ts - phase_start).total_seconds() / 60
msg = (
f"<b>{sensor_name} Bedampfer: Phase beendet</b>\n"
f"Dauer ≥ {TEMP_THRESHOLD} °C: {duration:.0f} Minuten"
)
await send_telegram(msg)
await log_alarm(cursor, sensor_name, 'END_PHASE', duration, current_temp)
await update_sensor_state(cursor, sensor_name, None, None)
async def main():
conn = connect_db()
cursor = conn.cursor()
#await send_telegram("Checking...")
try:
await check_sensor(cursor, "S1")
await check_sensor(cursor, "S2")
conn.commit()
except Exception as e:
print("Fehler im Hauptloop:", e)
finally:
cursor.close()
conn.close()
if __name__ == "__main__":
asyncio.run(main())Wofuer jetzt ebenfalls einen cronjob einrichten.
Bei mir laeuft der alle 5 Minuten.
Erst ausfuehrbar machen:
$ chmod 700 ~/bin/bedampferAlert.py
Nun ‘sudo crontab -e’ aufrufen und im editor wieder eine Zeile ergaenzen.
# m h dom mon dow command
# Heubedampfer
* * * * * /home/<piUser>/bin/monitor_temperature.py > /dev/null
*/5 * * * * /home/<piUser>/bin/bedampferAlert.py > /dev/nullThat’s it!
Viel spass damit.
Ich habe zu meinem persoenlichen Vergnuegen noch ein Webinterface gebaut, auf dem ich ebenfalls auf dieser Datenbasis, also aus dieser Datenbank einen netten Graphen gebaut habe, so dass man den Temperaturverlauf auch schoen beobachten kann. Zudem kann man die Boxen damit auch remote ein-/ausschalten oder fuer einen bestimmte Zeitspanne Einschalten oder nach einer bestimmten Zeitspanne einschalten. Das bietet alles die Shelly Steckdose selbst. Man muss es nur ansteuern.
Uns so sieht das dann aus:
Telegram Benachrichtigungen:
