— letzte Überarbeitung der Programmscripte im Februar 2016 —
Anpassung der Log Dateien und Überspielung der Live Daten auf diese Webseite (Aktualisierung alle 10 Minuten)
Nach dem die Version 1 mit der C-Control im Sommer 2013 einem Blitzschlag zum Opfer gefallen war, musste also was neues her.
Die neue Lösung wurde auf Basis des RASPBERRY PI verwirklicht. Am grundsätzlichen Aufbau der Pooltechnik hat sich dabei nichts geändert und ist hier dokumentiert.
Eine Änderung an der Technik gab es dann aber doch, und das ist die Position des Sensors für die Wassertemperatur. Dieser befindet sich jetzt wirklich im Pool, da der lange Kabelweg den Digitalen Sensoren nichts mehr ausmacht. Zudem gibt es die 1-Wire Sensoren extra für solche Anwendungen. Auch nach fast drei Jahren im Wasser arbeitet der Sensor immer noch einwandfrei.
Die aktuellen „live“ Daten meiner Steuerung sind hier zu finden: Poolstatus Kraft
WARNUNG:
Der Nachbau dieser Steuerung ist nicht ganz so einfach wie die Steuerung mit der C-Control und sollte daher nur von Fachlich versierten Personen durchgeführt werden. Kenntnisse in Linux und leichte Programmierkenntnisse sind in jedem Fall nötig. Im Gegensatz zu meiner alten Steuerung mit der C-Control ist hier doch einiges mehr an Fachwissen gefragt. Daher ist jeder für sein tun selbst Verantwortlich!
Beschreibung
Nun, der Umbau auf den Raspberry PI war zunächst nur als schnelle Notlösung gedacht. Doch mit der Zeit erwies diese Entscheidung sich als gar nicht so verkehrt und der „Hunger“ nach mehr wurde immer größer.
Der Raspberry PI ist ein Einplatinencomputer der für diese Aufgabe eigentlich völlig überdimensioniert ist. Aber ich konnte damit diverse Träume umsetzten, die ich schon mit der C-Control hatte. So z.B. die Anbindung an mein Heimnetz und damit die Darstellung von Live Daten auf meiner Homepage. Auch eine Protokollierung der Daten ist jetzt Problemlos möglich.
Preislich ist der Raspberry PI sogar noch günstiger wie die C-Control, daher war diese „Überdimensionierung“ gar nicht so schlimm. Zudem verbraucht er auch noch weniger Strom.
Im wesentlichen besteht die Steuerung aus drei Bestandteilen:
- Zwei Temperaturfühlern DS18B20 für den 1-Wire Bus. Der Dallas 1-Wire Bus ist im Raspberry Pi Projekt sauber umgesetzt und wird dort auch gut dokumentiert.
- Eine Schaltstufe mit zwei Relais zur Steuerung der Pumpe und dem Solarventil. Dabei ist es egal ob man fertige Platinen oder ein kompletten Eigenbau verwendet. Bei mir handelt es sich um die umgebauten Überreste der C-Control. Auch solche Fälle werden in diversen Projekten gut dokumentiert. Ich wählte zum Anschluss der Relaisstufe die GPIO Ausgänge 22 (Solar) und 23 (Pumpe).
- Die Software zur Steuerung. In meinem Fall ist das ein einfaches Shell Script welches als Cron Job alle 10 Minuten aufgerufen wird.
Aber ich musste in der Basisversion auch erst mal einige Einschränkungen gegenüber der C-Control hinnehmen. So hatte ich kein Bedienpult und auch keine lokale Anzeige mehr zur Verfügung. Das habe ich erst mal so hingenommen, und erst später aber über eine Einbindung der Anzeige in einen lokalen Webserver übernommen. Genauso habe ich dann auch das Bedienpult abgebildet.
In 2014 ist noch ein dritter Temperatursensor dazu gekommen, der die Lufttemperatur misst.
Die Darstellung der Temperaturen auf einer lokalen Webseite übernimmt zwar auch der Raspberry PI mit seinem Script. Für die Datenprotokollierung verwende ich die Software „FHEM“. Das hat also mit meiner Steuerung nichts weiter zu tun.
Der Grund für die Trennung dieser Aufgaben war einfach die Umsetzung des 1-Wire Interfaces in „FHEM“ und deren Bedienung. Weiterhin ist damit auch ganz einfach eine grafische Auswertung möglich.
UPDATE Feb. 2016: Die Erstellung über FHEM habe ich wieder deaktivert, da es Leute gibt die ihre Finger nicht von fremden Systemen lassen können. Grundsätzlich hat man also mehrmals versucht meinen FHEM zu hacken und somit komplett zu zerstören.
Also habe ich mich entschlossen den Server vom Netz zu nehmen und die Darstellung über diese Webseite zu erzeugen. Dazu verwende ich jetzt „Gnuplot“ in meinem Script und lade die hieraus erzeugten Grafiken als Bilder auf meine Webseite.
Damit hat sich auch das Script grundsätzlich geändert. Weiter unten dazu mehr.
Benötigt wird also erst mal ein Raspberry PI mit einer entsprechenden Betriebssoftware. Ich verwende Raspian ( http://www.raspbian.org ). Treiber für 1-Wire bringt es Serienmäßig mit, es muss nur aktiviert werden.
Alles wichtige zu dem Bau der Hard- und Software findet sich im Netz. Meine erste Anlaufstelle war https://www.raspiprojekt.de . Unter „Anleitungen -> Hardware“ ist eigentlich alles zu finden was zum Zusammenbau der Steuerung nötig ist.
Als zusätzliche Software zur Steuerung der GPIO Schnittstellen verwende ich „wiringpi“. Damit können die Aus- und Eingänge über Shell, Python oder „C“ Scripte gesteuert werden.
Damit ist der Raspberry PI komplett ausgestattet.
Mein Shell Script sieht so aus, und ist auf dem Raspberry PI unter „/usr/sbin“ abgelegt:
#!/bin/sh
#!/bin/sh# Definition von Variablen
Startzeit=11
Tempdiff=50
Maxtemp=280# Einlesen der Temperaturen von den Sensoren
# — 00080139c5f8 -> im Pool
# — 000801392e7e -> am Dach
# — 0008013921df -> für LuftT_Wasser=$(echo „scale=0; $(grep ‚t=‘ /sys/bus/w1/devices/w1_bus_master1/10-00080139c5f8/w1_slave | awk -F ‚t=‘ ‚{print $2}‘) / 100“ | bc -l)
T_Dach=$(echo „scale=0; $(grep ‚t=‘ /sys/bus/w1/devices/w1_bus_master1/10-000801392e7e/w1_slave | awk -F ‚t=‘ ‚{print $2}‘) / 100“ | bc -l)
T_Luft=$(echo „scale=0; $(grep ‚t=‘ /sys/bus/w1/devices/w1_bus_master1/10-0008013921df/w1_slave | awk -F ‚t=‘ ‚{print $2}‘) / 100“ | bc -l)# Ausgabe der gemessenen Temperaturen
# Bei Start der Scripts mit „/usr/sbin/pool_stg“ wird die Ausgabe in eine Log Datei geschrieben.
# Dabei gibt es pro Monat eine Log Datei.
# Diese Log Datei wird dann per Guplot zur Grafik ausgewertet.# Solar + Pumpenschaltung
# Pumpe 0 = „aus“, 1 = „an“
# Solar 0 = „an“ (Ventil geschlossen) , 1 = „aus“ (Ventil offen)
# Solarventil ist stromlos geschlossen
# S_Manuell für Manuellen BetriebS_Manuell=$(/usr/local/bin/gpio -g read 24)
if [ „$S_Manuell“ -eq „0“ ];
thenif [ „$T_Wasser“ -le „$(echo „scale=0; $T_Dach – $Tempdiff“ | bc)“ ];
then# Pumpe + Solar an wenn Dachtemperatur ausreichend hoch
/usr/local/bin/gpio -g write 23 1
S_Pumpe=1
# Temperaturbegrenzungif [ „$T_Wasser“ -le „$Maxtemp“ ];
then/usr/local/bin/gpio -g write 22 0
S_Solar=0.99
# Solar anelse
/usr/local/bin/gpio -g write 22 1
S_Solar=0.01
# Solar aus wegen Übertemperaturfi
# Pumpe an — Solar an
elseif [ „$Startzeit“ -le „$(date +%H)“ -a „$(date +%H)“ -le „$(echo „scale=0; ($Startzeit + ($T_Wasser / 35))“ | bc)“ ]
then# Pumpe an, wenn Startzeit gekommen und Endzeit noch nicht erreicht
/usr/local/bin/gpio -g write 23 1
/usr/local/bin/gpio -g write 22 1
S_Pumpe=1
S_Solar=0.01
# Pumpe an — Solar auselse
# Alles aus
/usr/local/bin/gpio -g write 23 0
/usr/local/bin/gpio -g write 22 0
S_Pumpe=0
S_Solar=0.01
# Pumpe aus — Solar aus – Magnet aus!fi
fi
else
S_Pumpe=0.5
S_Solar=0.51fi
# —————————————————————————————-
# Log Datei erzeugen
#
# Datum und Zeitstempel , Wasser Temp, Dach Temp, Luft Temp , Status Pumpe , Status Solar
# Zweite Zeile dient als Temp Datei für Web Darstellung
# —————————————————————————————-echo $(date +“%Y-%m-%d_%H:%M:%S“) “ , “ $(echo „scale=1; $T_Wasser / 10″ | bc) “ , “ $(echo „scale=1; $T_Dach / 10″ | bc) “ , “ $(echo „scale=1; $T_Luft / 10″ | bc) “ , “ $S_Pumpe “ , “ $S_Solar >> /var/log/pool/pool_stg-$(date +“%Y-%m“).log
echo $(date +“%d.%m.%Y , %H:%M“) “ , “ $(echo „scale=1; $T_Wasser / 10″ | bc) “ , “ $(echo „scale=1; $T_Dach / 10″ | bc) “ , “ $(echo „scale=1; $T_Luft / 10″ | bc) “ , “ $S_Pumpe “ , “ $S_Solar > /var/log/pool/tmp.log
Das Script muss natürlich an die Seriennummern der verwendeten 1W Sensoren angepasst werden.
Wird das Script aus der Kommandozeile ausgeführt, dann gibt es den passenden Status in die Log Datei „/var/log/pool_stg-$(date +“%Y-%m“).log“ aus.
Bei mir gibt es noch eine Sektion für die Darstellung auf einer Webseite. Diese habe ich weiter unten dargestellt.
Das Script stellt sowohl eine Temperaturdifferenzschaltung, als auch eine Zeitschaltung dar. Die Pumpe läuft also auch ohne Sonne an.
Allerdings erst ab „Startzeit“ (bei mir also 11:00 Uhr) und dann so lange wie es für die anliegende Wassertemperatur nötig ist.
Versteckt ist das ganze in der inneren If Anweisung:
if [ „$Startzeit“ -le „$(date +%H)“ -a „$(date +%H)“ -le „$(echo „scale=0; ($Startzeit + ($T_Wasser / 35))“ | bc)“ ]
Das ist die Zeitsteuerung mit der Abhängigkeit von der Wassertemperatur.
Bei sehr warmen Wasser läuft also auch die Pumpe länger. Das hat zum Vorteil das die im Skimmer platzierte Multi Chlor Tablette entsprechend länger im fließenden Wasser liegt und so mehr Chlor dosiert wird. Damit erspare ich mir lästiges nachdosieren bei warmen Wetter.
Die Formel dafür ist einfach längere Erfahrung mit meinem Pool und stammt schon aus der C-Control Zeit (dort ist es die gleiche Formel). Diese Zeiten kann natürlich für andere Poolanlagen anders sein.
Ist aber die Dachtemperatur 5°C höher wie die Wassertemperatur, dann läuft die Pumpe ebenfalls an.
Das steuert die äussere If Anweisung:
if [ „$T_Wasser“ -le „$(echo „scale=0; $T_Dach – $Tempdiff“ | bc)“ ]; ).
Bei 28°C ist aber Schluss mit Solar, da sonst „Überhitzung“ des Pools droht. Bei über 30°C wirkt herkömmliche Chlor Chemie nicht mehr so gut. Daher begrenze ich die Temperatur.
if [ „$T_Wasser“ -le „$Maxtemp“ ];
Auch wenn das Script irgendwie einfach aussieht, so enthält es eigentlich alle wichtigen Parameter (Zeitsteuerung, Temperaturdifferenz und einfache Chlordosierung).
Damit sind die wesentlichen Funktionen der Steuerung abgedeckt. Bei mir habe ich allerdings noch einige weitere Features verwirklicht, so z.B. die Darstellung der aktuellen Werte auf einer Webseite. Weiterhin die Steuerung über eine Webseite im lokalen Netz. Als Anzeige kann ich jedes Smartphone oder Tablet nutzen.
Im Diagramm sehen die Steruerungsaufzeichnungen wie folgt aus:
Links der Plot ohne Sonne, rechts mit Sonne
Diese Plots wurde mit FHEM und dessen Plot Funktion erzeugt. Seit Feb. 2016 werden diese Plots über Gnuplot erstellt.
Die Erstellung der Webseite wird seit Feb. 2016 nicht mehr im Pool Script vorgenommen. Die Webseite ist hier zu finden
Dafür werden die Grafiken jetzt im Script erzeugt und das wird so realisiert:
# ————————————————————
# Grafik erzeugen
# ————————————————————# —– Tagesplot —-
gnuplot -persist <<PLOT
reset
set title ‚Poolstatus $(date +“%d.%m.%Y“)‘
set timefmt „%Y-%m-%d_%H:%M:%S“
set xdata time
set ytics
set y2tics
set grid y2tics
set ylabel „Status Ausgang“
set y2label „Temperatur in °C“
set yrange [0:3]
set border 10
set datafile separator „,“
set format x „%H:00“
set xrange [„$(date +“%Y-%m-%d_00:01:00″)“:“$(date +“%Y-%m-%d_23:59:00″)“]
set terminal png size 850,300 enhanced font ‚Arial,8‘
set output ‚/var/www/plots/tag-$(date +“%Y-%m-%d“).png‘
plot „/var/log/pool/pool_stg-$(date +“%Y-%m“).log“ using 1:2 axes x1y2 title ‚Wasser‘ with lines,\
„/var/log/pool/pool_stg-$(date +“%Y-%m“).log“ using 1:3 axes x1y2 title ‚Dach‘ with lines,\
„/var/log/pool/pool_stg-$(date +“%Y-%m“).log“ using 1:4 axes x1y2 title ‚Luft‘ with lines,\
„/var/log/pool/pool_stg-$(date +“%Y-%m“).log“ using 1:5 axes x1y1 title ‚Pumpe‘ with lines,\
„/var/log/pool/pool_stg-$(date +“%Y-%m“).log“ using 1:6 axes x1y1 title ‚Solar‘ with lines
quit
PLOT# —- Monatsplot —-
gnuplot -persist <<PLOT
reset
set title ‚Poolstatus $(date +“%m.%Y“)‘
set timefmt „%Y-%m-%d_%H:%M:%S“
set xdata time
set ytics
set y2tics
set grid y2tics
set ylabel „Temperatur in °C“
set y2label „Temperatur in °C“
set border 10
set datafile separator „,“
set format x „%d“
set xrange [„$(date +“%Y-%m-01_00:01:00″)“:“$(date +“%Y-%m-31_23:59:00″)“]
set terminal png size 850,300 enhanced font ‚Arial,8‘
set output ‚/var/www/plots/monat-$(date +“%Y-%m“).png‘
plot „/var/log/pool/pool_stg-$(date +“%Y-%m“).log“ using 1:2 axes x1y2 title ‚Wasser‘ with lines,\
„/var/log/pool/pool_stg-$(date +“%Y-%m“).log“ using 1:3 axes x1y2 title ‚Dach‘ with lines,\
„/var/log/pool/pool_stg-$(date +“%Y-%m“).log“ using 1:4 axes x1y2 title ‚Luft‘ with lines
quit
PLOT
Diese aktuellen Grafiken und Temperaturdaten werden dann per FTP upload auf meinen Webserver hochgeladen. Auch das übernimmt dieses Script. Den Code dazu habe ich um die privaten Daten gekürzt.
# — upload zur Website —
# Kopieren der Daten in den Uploadordner
cp /var/log/pool/tmp.log /var/www/pool/tmp.log
cp /var/www/plots/tag-$(date +“%Y-%m-%d“).png /var/www/pool/tag.png
cp /var/www/plots/monat-$(date +“%Y-%m“).png /var/www/pool/monat.pngcd /var/www/pool
HOST='[ftpserver]‘
USER='[username]‘
PASSWD='[supergeheimes passwort]‘
FILE1=’tmp.log‘
FILE2=’tag.png‘
FILE3=’monat.png‘ftp -n $HOST <