Ausführliche Installationsanleitung der Poolarino® Poolsteuerung

Du kannst entweder die manuelle Anleitung befolgen und die Poolsteuerung händisch auf deinem Raspberry Pi installieren, oder du erstellst dir einen Account im Forum und kannst anschließend die Poolsteuerung als fertiges Image für deinen Raspberry Pi hier herunterladen und sparst dir die gesamte händische Arbeit.

Vorbereiten des Raspberry Pi

Wir beginnen mit der Vorbereitung des Raspberry Pi. Hierzu installiert ihr euch ein Programm wie bspw. Etcher und ladet das passende 64Bit Ubuntu Image 20.04.01 LTS für euren Raspi herunter. Das Image wird entpackt und dann mit Etcher auf die SD-Karte geschrieben. Anschließend müsst ihr die SD-Karte einmal herausnehmen und wieder in euren PC stecken. Nun öffnet ihr mit dem Explorer das Dateiverzeichnis der Karte und sucht nach der Datei usercfg.txt. In der Datei ergänzt ihr dann unter den ersten 3 Zeilen die Zeile dtoverlay=w1-gpio. Speichern, schließen und danach kommt die SD-Karte in den Raspberry Pi und wir sind auch schon mit der Vorbereitung fertig. Nun noch Strom ran, Netzwerk rein und los gehts.

Das Backend - Installation der benötigten Komponenten

Verbindung zum Raspberry Pi per SSH aufbauen

Habt ihr den ersten Schritt erledigt, solltet ihr euch nun mit dem Raspberry Pi verbinden können. Ich nutze hierfür auf meinem Windows-Rechner Putty. Um die IP-Adresse herauszufinden, die der Pi mutmaßlich vom DHCP bekommen hat, könnt ihr einfach ein Programm wie bspw. Advanced IP-Scanner installieren und dort nach einem Suchlauf nach dem Raspberry Pi Ausschau halten. Die SSH-Zugangsdaten für den Raspi lauten standardmäßig als Benutzername: ubuntu und als Passwort ubuntu. Ihr müsst das Passwort beim ersten Login in eines eurer Wahl abändern. War dies erfolgreich, beendet sich eure Session. Nach einer erneuten Verbindung solltet ihr nun mit dem Raspi verbunden sein. Ruft mit htop den Prozessmanager auf und schaut, wie die Auslastung des Raspberry Pis ist. In der Regel macht dieser direkt nach der frischen Installation Updates im Hintergrund, diese sollten wir zunächst abwarten. Die Updates sind beendet, wenn die CPU-Auslastung (ganz oben die 4 Balken) bei 0 - 2% Auslastung sind und nicht mehr ausschlagen (kann so 20 - 25 Minuten dauern). Ist dies der Fall, einmal rebooten (sudo reboot) und schon geht's im nächsten Schritt weiter.

Installation von Node auf dem Raspberry Pi

Die Installation von Node und npm ist schnell erledigt, ihr gebt zuerst den Befehl curl -sL https://deb.nodesource.com/setup_12.x | sudo -E bash - ein und anschließend sudo apt install nodejs -y. Ist die Installation erfolgreich, gehts weiter im nächsten Schritt.

Installation der Build-Tools

Wir benötigen noch Build-Tools für später und installieren diese, indem wir zunächst auf den root-user wechseln mit sudo -i und anschließend sudo apt-get install gcc g++ make -y eingeben. Mit einem exit landen wir wieder in unserer normalen User-Session.

Setzen der passenden Zeitzone

Ihr müsst für die Poolsteuerung auf jeden Fall noch die korrekte Zeitzone setzen. Hierzu gebt ihr einfach sudo timedatectl set-timezone Europe/Berlin ein und startet den Raspberry Pi anschließend einmal durch die Eingabe von sudo reboot neu.

Installation von Mongo-DB auf dem Raspberry Pi

Damit das Backend auf dem Raspberry Pi lauffähig wird, benötigen wir eine Datenbank. Hierfür installieren wir nun Mongo-DB und gehen dafür wie folgt vor:

1. Gebt folgenden Befehl ein: wget -qO - https://www.mongodb.org/static/pgp/server-4.4.asc | sudo apt-key add -. War dies erfolgreich, erhaltet ihr ein "Ok" in der Konsole zurück.
2. Anschließend gebt ihr noch folgenden Befehl ein: echo "deb [ arch=amd64,arm64 ] https://repo.mongodb.org/apt/ubuntu focal/mongodb-org/4.4 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-4.4.list und führt dann mit sudo apt-get update ein update der Paketquellen durch.
3. Mit sudo apt-get install -y mongodb-org installiert ihr dann die Mongo-Datenbank.

   
   

   1. sudo systemctl status mongod.service prüft den korrekt installierten Service, dieser sollte auf inactive stehen.
   2. sudo systemctl start mongod.service startet den Service, die Datenbank läuft und wir können sie benutzen.
   3. Wir müssen den Service noch in den Autostart mit aufnehmen, das machen wir mit sudo systemctl enable mongod.service.
4. Um zu prüfen, ob die Installation erfolgreich war, könnt ihr sudo systemctl status mongod.service eingeben und solltet in Zeile 3 unter "Active" ein grünes active (running) sehen. Wir verlassen das Fenster mit STRG + C und machen mit dem nächsten Schritt weiter.

Herunterladen der Poolarino® Poolsteuerung

Um weiter fortfahren zu können, müssen wir uns das Repository auf unseren Raspberry Pi Clonen. Hierzu geben wir zunächst cd .. ein (wir sollten jetzt im Verzeichnis /home sein) und verwenden anschließend den Befehl sudo git clone https://github.com/tamsch/poolarino.git. Nachdem wir das Repository nun heruntergeladen haben, müssen wir die notwendigen Bibliotheken für die Poolsteuerung nachladen. Hierzu manövrieren wir uns in das Repository mit cd poolarino_poolcontrol und geben anschließend sudo -i gefolgt von cd ../home/poolarino_poolcontrol/ und sudo npm i ein. Der Raspberry installiert nun die notwendigen Pakete nach. Sobald die Installation abgeschlossen ist, müssen wir noch einmal npm audit fix eingeben und die älteren Pakete noch kurz upgraden. Mit exit verlassen wir die root-session und machen normal weiter. Wir können noch das angular-src Verzeichnis löschen, dieses wird hier nicht benötigt. Dazu geben wir sudo rm -r angular-src/ ein.

Das Backend Teil 2 - Konfiguration der Datenbankverbindung auf dem Raspberry Pi

Einrichten der Mongo-Datenbank auf dem Raspberry Pi

Nachdem wir nun alles vorbereitet haben, müssen wir unsere Datenbank konfigurieren. Das heißt wir müssen eine Datenbank anlegen und einen Benutzer mit entsprechenden Rechten hinzufügen. Hierzu verbinden wir uns zunächst mit unserer Mongo-Datenbank indem wir in die Konsole mongo eingeben. Nun sind wir mit unserem Mongo-DB-Server verbunden und können arbeiten. Durch die Eingabe von use pool verbinden wir uns mit der temporären Datenbank pool. Um diese Datenbank persistent im System zu hinterlegen, erstellen wir einen Benutzer mit Lese- und Schreibrechten. Hierzu gebt ihr db.createUser({user: "pool", pwd: "pool", roles: ["readWrite"]}) ein, wodurch wir den Benutzer anlegen und die Datenbank persistent machen. Durch das Drücken von STRG + C beenden wir die Mongo-Konsole und sind wieder in der Hauptkonsole.

Konfigurieren der Datenbankanbindung der Poolarino® Poolsteuerung

Unsere Datenbank haben wir soweit aufgesetzt und vorbereitet. Nun müssen wir noch unsere Poolsteuerung mit der Datenbank verbinden. Hierzu geben wir sudo nano ~/../poolarino_poolcontrol/config/database.js ein, was uns in ein leeres Fenster bringt. Mit diesem Befehl haben wir quasi eine neue Javascript-Datei erzeugt, in welcher wir nun die Datenbankverbindung wie folgt definieren: module.exports = {database: 'mongodb://pool:pool@127.0.0.1:27017/pool' , secret:'deinscret'}. Durch das Drücken der Tastenkombination STRG + O speichern wir unsere Änderung und mit STRG + X verlassen wir wieder unsere Textdatei.

Starten des Backends der Poolsteuerung

Zur Verwaltung der Poolsteuerung empfiehlt sich etwas wie der ProcessManager. Diesen installieren wir mit sudo npm install -g pm2. Damit pm2 auch beim Starten des Raspberry Pi direkt mit ausgeführt wird, geben wir noch sudo pm2 startup ein. Wir manövrieren in unser Backend-Verzeichnis mit cd poolarino_poolcontrol/ und führen unser Backend mit sudo pm2 start app.js aus. Das wars, unser Backend ist nun einsatzbereit!

Installation eines Webservers auf dem Raspberry Pi

Nachdem das Backend fertig ist, müssen wir nun noch etwas für das Frontend vorbereiten. Hierfür benötigen wir einen Webserver, welchen wir mit sudo apt-get install -y lighttpd installieren.

Das Frontend - Vorbereiten der Poolsteuerung

Konfiguration der Temperatursensoren für die Poolsteuerung

Um die Temperatursensoren in Betrieb zu nehmen, müsst ihr noch die IDs der jeweiligen Sensoren in der Software anpassen. Nachdem ihr die Temperaturensoren also mit dem Raspi verbunden habt, gebt ihr cd /sys/bus/w1/devices/ ein. Hier könnt ihr mit dem Befehl ls die Sensor-IDs ausgeben lassen. Die IDs der Temperaturesensoren könnt ihr dann ebenfalls ganz einfach inklusive einer Bezeichnung in dem Einstellungsmenü der Poolsteuerung hinterlegen.

Das Bauen des Frontends für Poolsteuerung

Das Frontend ist etwas schwergewichtiger als das Backend. Für die Vorbereitung empfiehlt sich ein Windows oder Mac-Rechner (oder Laptop) mit normaler Hardware. Der Raspberry Pi dürfte beim Compilen gut ins Schwitzen kommen! Wir laden uns also das ZIP-File herunter von https://github.com/tamsch/poolarino, entpacken dieses und beginnen mit der Vorbereitung des Frontends. Hierzu ruft ihr unter Windows das Terminal (cmd) auf und führt dieses als Administrator aus. Im Terminal angekommen manövriert ihr mit cd wieder in das Downloadverzeichnis der Poolsteuerung, genauer gesagt in das Unterverzeichnis angular-src. Dort angekommen installieren wir nun die benötigten Pakete mit dem Befehl npm i. Sollte das nicht funktionieren, müsst ihr zunächst Node auch lokal auf eurer Maschine installieren. Für Windows und Mac gibt es dafür fertige Installer hier -> https://nodejs.org/en/download/. Wir verwenden in dieser Anleitung Node in der Version 12.X.

Damit das Frontend und Backend nachher sauber zusammenarbeiten, benötigen wir noch ein paar kleine Einstellungen. Zum Einen muss in der /poolarino_poolcontrol/angular-src/src/app/app.module.ts Datei unter allowedDomains die IP-Adresse eures Raspberry Pis hinterlegt werden, auf welchem das Frontend läuft. Zum Anderen müsst ihr in der /poolarino_poolcontrol/angular-src/src/environments/environment.prod.ts unter serverUrlebenfalls die IP-Adresse des Raspberry Pis (bzw. des Gerätes, auf dem das Backend liegt) hinterlegen. Macht ihr dies nicht, wird die Kommunikation zwischen Front- und Backend nicht sauber laufen.

Ist npm i erfolgreich durchgelaufen, führen wir noch ein npm audit fix aus um die Pakete zu updaten. Nun benötigen wir zusätzlich die Angular CLI und installieren diese mit npm i -g @angular/cli. Nachdem die Angular-CLI installiert ist, müssen wir uns das Frontend bauen. Das machen wir mit ng build --prod. Ist der Build-Prozess abgeschlossen, haben wir einen neuen Ordner dist/poolarino, in welchem sich unsere kompilierte Anwendung befindet. Die hierin enthaltenen Dateien müssen wir nun allesamt auf unseren Raspberry Pi verschieben. Um dies zu tun installieren wir uns das Programm FileZilla (oder ein anderes FTP-Programm) auf unserem lokalen Computer. Damit wir uns aber mit dem Raspberry Pi verbinden können, müssen wir noch einen FTP-Zugriff einrichten. Hierzu gehen wir wie folgt vor:

1. Verbinden auf den Raspberry Pi wieder mit Putty.
2. Eingabe des Befehls sudo apt-get install pure-ftpd -y
3. Wir legen nun eine Gruppe für FTP-User an mit dem Befehl sudo groupadd ftpgroup.
4. Jetzt legen wir den FTP-Benutzer Alias mit sudo useradd ftpuser -g ftpgroup -s /sbin/nologin -d /dev/null an.
5. Nun geben wir die Benutzerrechte für den Webserver-Ordner an unseren ftpuser mit dem Befehl sudo chown -R ftpuser:ftpgroup /var/www/html ab.
6. Jetzt legen wir noch einen virtuellen Benutzer für unseren FTP-Zugriff an sudo pure-pw useradd upload -u ftpuser -g ftpgroup -d /var/www/html -m. Nach dem Abschicken dieses Befehls werdet ihr aufgefordert, euch ein Passwort für den neuen Benutzer auszudenken. Ich habe poolarino eingegeben, das noch einmal bestätigt und der Benutzer wurde angelegt.
7. Jetzt noch das Folgende jeweils eingeben:
   1. sudo pure-pw mkdb
   2. sudo ln -s /etc/pure-ftpd/conf/PureDB /etc/pure-ftpd/auth/60puredb
   3. sudo service pure-ftpd restart
8. und der FTP-Zugang ist eingerichtet.
9. Jetzt starten wir unser Programm wie bspw. FileZilla, klicken auf Datei -> Servermanager, dann unten auf Neuer Server, geben bei Server die IP-Adresse des Raspberry Pis ein, auf dem unser Frontend liegt und wählen bei Verbindungsart Normal aus. Bei Benutzername geben wir upload und bei Passwort das von uns überlegte Passwort ein.
10. Mit einem Klick auf Verbinden sind wir dann direkt auf unserem Raspberry-Pi und können Dateien von unserem Computer übertragen, was wir auch gleich tun.
11. Wir verschieben alle Dateien aus dem dist/ Ordner auf unseren Raspberry Pi und können das Frontend dann im Browser über die IP-Adresse des Raspberry Pis sofort aufrufen. Falls das mit dem Aufrufen nicht klappt, sollte man eventuell kurz den lighttpd-Service mit dem Befehl sudo systemctl restart lighttpd.service neu starten.

Fertig - Die Poolarino® Poolsteuerung ist installiert

Wenn wir jetzt die IP-Adresse des Raspberry Pis in unserem lokalen Browser aufrufen, sollten wir die Poolsteuerung sehen. Bitte beachten: Die Anzeige ist optimiert auf ein Layout von 800x480 Pixeln. Auf einem normalen Desktop-PC könnte das ganze daher etwas defekt erscheinen.

Konfiguration der Wettervorschau in der Poolsteuerung

Um das Wetter zu konfigurieren könnt ihr euch an diesem Artikel orientieren -> Konfiguration des Wetters für die Poolsteuerung

Abschließende Worte

Ich hoffe, dass ihr mit der detaillierten Anleitung mehr anfangen könnt, als mit den paar Zeilen aus dem ersten Wurf! Sollte es im Ablauf zu Fehlern kommen oder etwas unklar sein, meldet Euch gerne! Für Kritik hab ich auch immer ein offenes Ohr!