Einfache Aquariensteuerung (fertig)

  • Einfacher Aquariencomputer mit Raspberry Pi



    Warum beschreibe ich dieses Projekt? Es gibt doch schon reichlich Anleitungen für Aquarien-computer mit Raspberry Pi!



    Viele der Projekte steigen mit sehr hohen Anforderungen ein. Da soll dann Licht, Temperatur, Heizung, Leitwert, ph-Wert, CO2-Gehalt, Wasserstand, Luftdruck usw. kontrolliert, graphisch aufbereitet, ins Netz gestellt und auf dem Handy per Schieberegler eingestellt werden, natürlich Webcam usw., um nur einiges zu nennen.Auch wenn so ein Pi das wahrscheinlich von seinen Möglichkeiten her locker kann, brechen doch viele der so gestarteten Projekte nach 3 bis 4 Posts ab, weil die Wünsche eben doch größer waren, die Zeit und das Durchhaltevermögen, die nötig sind, um so ein Projekt fertig zu stellen.

    Solche Posts sind frustrierend, und viele interessierte Aquarianer wenden sich vermutlich abgeschreckt ab, weil ihnen so ein Projekt zu kompliziert erscheint. Dabei ist es gar nicht so schwer, einen funktionierenden Anfang zu setzen, auf dem man später aufbauen kann.


    In diesem Beitrag möchte ich ein Aquarienprojekt beschreiben, das auch normal versierte Bastler in überschaubarer Zeit fertigstellen können. Die funktionierende Anlage kann dann natürlich beliebig erweitert werden. Aber wir haben erst mal etwas, das funktioniert!


    Diese Anleitung ist sicher nicht der einzig mögliche oder auch nicht der optimale Weg. Vermutlich gibt es viele Möglichkeiten das anders, besser, vielleicht einfacher zu machen als ich das getan habe, das steht auch nicht im Vordergrund. Ziel war es, einen vernünftigen Funktionsumfang mit überschaubaren Mitteln und in überschaubarer Zeit umzusetzen und das Projekt abzuschließen. Dies Projekt ist nicht nur eine Idee oder ein Wunsch, sondern wurde in überschaubarer Zeit erfolgreich umgesetzt und funktioniert.



    Was soll das Projekt können?



    Wichtig ist immer erst mal, dass wir uns darüber klar werden, was wir am Ende wollen. Wir könnten uns z.B. die Basisanforderungen einer Aquariensteuerung vornehmen:



    3 Lampen unabhängig voneinander ein- und ausschaltenEine Temperaturregelung mit Boden- und Stabheizer darstellen CO2-Zufuhr ein- und ausschaltenEine Dosierpumpe mit Tagesdünger schaltenEine Pumpe für eine Nachfüllautomatik schalten(Futterautomaten klammern wir mal aus, da diese Geräte i.d.R. bereits mit Steuerung kommen, sonst wäre das auch eine Anforderung)

    Daneben wollen wir die Steuerung über externe Computer oder Tablet/Smartphone im Heimnetz ansprechen können (soll kein eigenes Keyboard und Display benötigen).


    Die Steuerung muss fehlersicher sein, d.h. zum Beispiel, dass sie nach einem Stromausfall automatisch wieder in einen stabilen Betriebszustand findet.


    Und wir wollen den „Gesundheitszustand“ der Steuerung im Vorbeigehen erkennen können, ohne dass wir an einem PC einloggt sein müssen (Visuelle Rückmeldung: Steuerungsprogramm läuft und Temperatur ist im Zielbereich).


    Ein so ausgestattetes Becken darf man sicher als technisch auf einem guten Stand bezeichnen. Natürlich kann man so etwas auch mit diskreten Komponenten (einzelnen Zeitschaltuhren und Thermostaten) darstellen, aber eine Pi-Lösung ist am Ende billiger, eleganter und erweiterungsfähig (und macht auch mehr Spaß).




    Was brauchen wir an Material?



    Raspberry Pi (ich habe einen Pi-2), am besten mit GehäuseNetzteil 5V, min 2AEinen USB-WLAN-AdapterEin Adapterkabel HDMI auf DVI (nur nötig, wenn Euer Monitor keinen HDMI-Eingang hat)Eine micro SD-Karte, 8 GB oder mehrEine 8-fach Relais-Zeile von Sainsmart (oder Nachbau)Einen Temperatursensor DS1820 + einen 4.7 kohm WiderstandEinen Satz I/O-Kabel (Stecker weiblich-weiblich)Ein paar LEDs und 330 ohm Widerstände

    Für den Pi gibt es Sets, die alles obige bis auf den Temperatursensor, die Relaiszeile und die I/O-Kabel beinhalten für ca. 70 € im Netz zu kaufen. Alle anderen genannten Teile gibt es ebenfalls beim großen Versandhändler. Abhängig davon, wie lange man warten kann, kommen die Relaiszeile und die T-Sensoren direkt aus China oder aus Europa. Alles zusammen sollte aber für 75 – 90 € zu beschaffen sein.


    Keyboard und Maus setzen wir mal als vorhanden voraus, brauchen wir, ebenso wie das Monitorkabel auch nicht dauerhaft am Pi.




    Was brauchen wir an Werkzeug?


    Ein Lötkolben und Schrumpfschlauch ist hilfreich beim Konfektionieren des T-Sensors oder von Kontroll-LEDs.


    Ein Vielfach-Messgerät wäre gut.


    Daneben das übliche Bastelwerkzeug, Zangen Schraubenzieher etc.




    Welche Kenntnisse sind nötig?


    Um dies Projekt erfolgreich fertig zu stellen, muss man kein Hacker sein, aber man muss sich an neue Dinge herantrauen. Etwas Erfahrung mit Linux ist hilfreich, ebenso darf man keine Angst vor einer Konsole und einigen Terminal-Befehlen haben. Der Python-Code, den ich hier veröffentliche, funktioniert erst mal, aber wenn man ihn für eigene Bedürfnisse anpassen will, dann muss man sich etwas mit der Programmiersprache Python beschäftigen. Ich werde hier natürlich auch nicht alles nochmals beschreiben, was bei der Inbetriebnahme und Konfiguration eines Raspi schon zig mal im Netz steht, aber ich werde die Links zitieren, die bei MIR funktioniert haben (es gibt leider auch ziemlich viel Zeug im Netz, das zumindest mal nicht aktuell ist).


    Etwas Vertrautheit mit Elektronik und einem Lötkolben hilft definitiv. Sonst kann das schwer werden, z.B. den Sensor zu konfektionieren. Und wer am Ende 230 V-Verbraucher an seine Relaiszeile anschließt, muss auf jeden Fall wissen, was er tut! 230 V sind genug, um sich daran ernsthaft zu verletzen oder schlimmeres. Hierzu kann ich nicht mal eben in 5 Zeilen eine Anleitung schreiben. Da muss sich jeder selbst einschätzen, ob er das kann. Im Zweifel immer einen Fachmann befragen!




    Schritt 1: Raspi aufsetzen und starten


    Dies ist im Netz hinreichend beschrieben. Ich habe Raspbian als Betriebssystem benutzt. Als Sofortmaßnahme muss man den Mouse-Lag beseitigen, damit man arbeiten kann, Die ersten Gehversuche habe ich mit dem Raspi mit angeschlossenem Monitor und Keyboard gemacht, später habe ich über VNC auf den Raspi zugegriffen. Zum Modifizieren des Codes benutzen wir Idle3, das bereits im Raspbian vorinstalliert ist.




    Schritt 2: Raspi an den Router anbinden


    Das ist aus zwei Gründen wichtig. Zum einen holt sich der Raspi selber die aktuelle Uhrzeit aus dem Netz und zum zweiten wollen wir ihn später über VNC remote ansprechen. Also erst mal dafür sorgen, dass der Raspi über Kabel oder den WLAN-Stick am Router angemeldet ist. Dann im Betriebssystem die korrekte Zeitzone einstellen, damit localtime uns später die korrekte Zeit im Programm liefert.




    Schritt 3: Temperatursensor konfektionieren und anschließen


    Der Anschluss eines DS1820 ist hier




    sehr gut erklärt. Ich habe den Sensor mit Schrumpfschlauch geschützt. Zur Temperaturmessung im Aquarium wird er dann einfach mit Tesafilm von außen an die Scheibe geklebt und auf der Rückseite mit etwas Schaumfolie isoliert, damit er nur (oder weit überwiegend) von der Temperatur im Becken beeinflusst wird. Wir schließen den Sensor korrekt an und nehmen die Einträge in den Dateien im Betriebssystem so vor, wie im Link oben beschrieben. Wer der Beschreibung im Link gefolgt ist, der weiß dann auch bereits, ob sein Sensor korrekt angesprochen wird.




    Schritt 4 : Sich mit dem Python Code vertraut machen, Schaltzeiten und Temperaturschwellen einstellen.


    Das Programm befindet sich in der angehängten Datei „Aquarium.py“ und ist vollständig kommentiert, sollte also in weiten Bereichen selbsterklärend sein. Welcher GPIO für welche Funktion zuständig ist, steht alles im Source file.


    Was macht das Programm?


    Licht:


    Es sind 3 Lampen vorgesehen. Für jede Lampe sind aktuell 2 Schaltintervalle definiert, d.h. man kann z.B. morgens x Stunden beleuchten, dann eine Pause von einigen Stunden machen und abends wieder für y Stunden beleuchten. Wenn man nur eine Beleuchtungsphase haben will, einfach beide Intervalle gleich einstellen.


    CO2:


    Für das CO2 gilt das Gleiche wie für das Licht, wir schalten ja mit 230 V ein Magnetventil.


    Heizung:


    Für die Heizer werden Schwelltemperaturwerte mit einer Hysterese von ca. 0.3 °C eingestellt, also z.B.




    Heizer an , wenn kälter als 24.0 °CHeizer aus, wenn wärmer als 24.3 °C

    Für den Stabheizer werden die Schaltschwellen ca. 0.2 ° tiefer eingestellt als für den Bodenheizer. Meist ist der Bodenheizer viel schwächer und nicht in der Lage, die Heizung komplett zu übernehmen. Er soll aber immer an sein (wenn es nicht insgesamt zu warm ist). Fällt die Temperatur weiter, obwohl der Bodenheizer an ist, wird der Stabheizer zugeschaltet. Er wird wieder ausgeschaltet, bevor der Bodenheizer seine Abschaltschwelle erreicht, übernimmt also weitgehend die eigentliche Temperaturregelung, während der Bodenheizer immer an ist, aber bei zu hoher Temperatur (beispielsweise im Sommer) natürlich ebenfalls automatisch ausgeschaltet wird.


    Temperatur-Anzeige


    Es werden dazu Temperatur-Warnschwellen definiert. Befindet sich die Temperatur innerhalb der Warnschwellen, wird mittels GPIO 5 eine LED eingeschaltet, ist die Temperatur außerhalb der Warnschwellen, wir die LED ausgeschaltet. Laufen wir am Pi vorbei, können wir also ohne weitere Info anhand der LED sehen, ob die Temperatur in Ordnung ist. Leuchtet sie, ist alles klar, leuchtet sie nicht, müssen wir nachsehen, was los ist. Idealerweise sind die Warnschwellen 0.1°größer/kleiner als die größten/kleinsten Schaltschwellen der Heizer.


    Natürlich werden im Terminal des Pi die aktuellen Temperaturwerte ausgegeben, aber wir gehen davon aus, das nicht ständig ein Display angeschlossen ist, und der Regler soll das auch hinbekommen, ohne dass wir alle 5 Minuten auf ein Display schauen müssen.



    Tagesdünger:


    Einmal am Tag können wir zu einer einstellbaren Zeit eine Dosierpumpe für x (einstellbar) Sekunden einschalten, um Tagesdünger aus einem Kanister zu dosieren.


    Bau der Dosierpumpe ist hier beschrieben





    Nachfüllen:


    Einmal am Tag können wir zu einer einstellbaren Zeit eine Nachfüllpumpe für y (einstellbar) Sekunden einschalten, um verdunstetes Wasser aus einem Kanister zu dosieren.


    Bau der Nachfüllpumpe ist an gleicher Stelle wie die Dosierpumpe beschrieben.



    Ungenutzte Ausgänge:


    Wer kein CO2, bzw. keine Tagesdüngung und Nachfüllung nutzt, kann die Ausgänge einfach ins Leere laufen lassen oder für andere Dinge nutzen (Futterautomat,…)




    Läuft unser Programm?


    Das Programm läuft in einer Endlosschleife mit einer Zykluszeit von ca. 1 sec. Wir wollen natürlich auch im Vorbeigehen sehen können, ob unser Pi „lebt“, d.h. sein Programm brav abarbeitet.


    Das lösen wir dadurch, dass wir mit jedem Schleifendurchlauf eine LED (GPIO 5) an- und ausschalten. Läuft unsere Schleife ordnungsgemäß, blinkt diese LED gleichmäßig mit einer Periode von ca. 1 sec. Läuft unser Programm nicht, blinkt sie nicht. Diese LED ist also ein „health indicator“, ob unser Programm ordnungsgemäß zykelt, ohne dass wir uns dazu auf dem Pi einloggen müssen.




    Festlegen der Schaltzeiten und Temperaturschwellen etc.:


    Alle Variablen werden im Programm „fest“ im Code vorgegeben. Wenn wir sie ändern wollen, wird der Python Code in der Datei Aquarium.py geändert. Nicht sehr elegant? OK, wie oft wollen wir an einem eingelaufenen Becken an diesen Variablen spielen…..? Für den Start ist das m.E komfortabel genug.




    Programmablauf:


    Am Anfang werden die GPIOs definiert und die Variablen gesetzt bzw. initialisiert.


    Danach geht es in eine Endlosschleife, in der folgendes passiert:



    Abfrage, ob die aktuelle Uhrzeit in einem definierten „Ein-Fenster“ liegtWenn ja, Lampe bzw. CO2 einschaltenWenn nein, Lampe bzw. CO2 ausschaltenVariable für den Ausgang dem Schaltzustand entsprechend setzenTemperatur von Sensor auslesenMit den gesetzten Temperaturgrenzen für Boden- und Stabheizer vergleichenWenn zu warm oder zu kalt, Heizer aus- oder einschaltenVariablen mit Schaltzustand entsprechend setzenPrüfung, ob Temperatur im ZielbereichSetzen/Ausschalten der LED für „Temperatur = OK“Abfrage, ob Uhrzeit für Dosierung des Tagesdüngers erreichtWenn ja, Dosierpumpe für die definierte Zeit einschaltenAbfrage, ob die Uhrzeit für die Nachfüllung erreichtWenn ja, Nachfüllpumpe für die definierte Zeit einschaltenAm Ende die Schaltzustände aller Lampen, Heizer und CO2 ausgebenSchaltzustand der „Health-LED“ ändernEine 1/10 Sekunde wartenDie Endlosschleife erneut starten



    Schritt 5 (optional): Test-Setup mit LEDs


    Wer sich ein Komplettset mit einem Breadboard zum Experimentieren gekauft hat, der kann dies mittels des Flachbandkabels anschließen und die GPIO-Ausgänge im Code (das sind GPIO 5,6,12,13,16,19,20, und 21) jeweils mit einer LED (Polung beachten) und 330 ohm Widerstand gegen Masse legen. Dann können wir sehen, welche Ausgänge gerade beschaltet sind (LED an). Auf diese Weise können wir das Programm erst mal im Testmodus laufen lassen und sehen, ob die Einstellungen, die wir vorgenommen haben, funktionieren, das Programm also das macht was wir wollen.




    Schritt 6: Programm starten


    Wir kopieren die Programmdatei ins Verzeichnis /home/pi.


    Dann öffnen wir ein Terminal und geben ein


    python Aquarium.py


    Mit angeschlossenem Temperatursensor und LEDs an den GPIOs startet unser Programm, gibt folgende Daten im 1-Sekunden-Takt aus und schaltet die entsprechenden LEDs.


    13:35


    Lampe 1 an


    Lampe 2 aus


    Lampe 3 aus


    CO2 an


    Temperatur 24.35 °C


    Bodenheizer an


    Stabheizer aus




    Stimmt irgendwas nicht? Dann mal die Parameter im Code prüfen und die Anschlüsse der LEDs, ob das alles richtig gesteckt ist.




    Schritt 7: Anschluss der Relaiszeile


    Um Leistung zu schalten, brauchen wir Relais, die die I/O-Signale des Pi für Verbaucher „nutzbar“ machen. Zum Anschluss der Sainsmart Relaiszeile, die wir hier verwenden, gibt es einen wahren Glaubenskrieg im Netz. Es gibt Leute, die sagen „einfach anschließen und geht“ und solche, die meinen, dass man seinen Raspi zerstört, wenn man das Board nicht über Treiber-Transistoren anschließt. Wirklich verwirrend….


    Was stimmt nun?


    Ich bin dem Beitrag eines Amazon-Kunden gefolgt, der das Board einfach mal wie folgt durchgemessen hat:


    Wenn wir es stand alone an 5V anschließen, passiert erst mal nix, kein Relais schaltet. Dann können wir mal die In-Pins gegen Masse messen, die zeigen 3.0 V (Raspi GPIOs 0 bzw. 3.3 V). Wenn wir dann über ein Amperemeter einen der In-Pins gegen Masse legen, zeigt das Instrument 1.9 mA, das entsprechende Relais schaltet durch und die LED des Eingangs leuchtet. 1.9 mA sind kein Strom, der einen I/O des Raspi zerstört, von daher droht also keine Gefahr.


    Jetzt bleibt noch die Stromversorgung des Boards. Jedes Relais zieht im durchgeschalteten Zustand ca. 90 mA, d.h. wenn alle 8 Relais schalten, zieht das Board ca. 720 mA, also nicht unerheblich Strom. Geht das über das Pi-Netzteil und die on-board Sicherung des Pi? Ich habe das Board einfach über die 5V-Pins des Pi angeschlossen und über mehrere Wochen so betrieben. Mein 2A-Netzteil ist nicht heiß geworden und auch mein Pi lebt noch.


    Daher: Versuch macht klug! Trauen wir doch unseren Beobachtungen. Bei mir funktioniert es fehlerfrei, die Relaiszeile direkt an den Pi anzuschließen. Hierzu sind die I/O-Kabel (weiblich-weiblich) da. 5V an VCC, GND an GND, die Pins IN1 bis IN8 des Relais-Boards mit den ausgewählten GPIO des Raspi verbinden, den Jumper VCCJD-VCC habe ich stecken lassen.


    Wie gesagt, wer Manschetten hat, die Relaiszeile direkt an den Pi zu stecken, der bemüht am Besten mal ein Messgerät und macht sich sein eigenes Bild.


    Nun sind die Eingänge der Relaiszeile invertiert, das heißt, wenn der Eingang auf Masse liegt, schaltet das Relais durch und die zugehörige LED auf dem Relaisboard geht an. Wie gehen wir damit um? Alle Relais sind Umschalter, d.h. wir können in jedem der Schaltzustände Durchgang verkabeln.


    Ich habe den Pi so programmiert und verkabelt, dass meine Verbraucher eingeschaltet sind, wenn das Relais durchgeschaltet hat, also die LED leuchtet und der Eingang auf Masse liegt. Das heißt, wenn ein Verbraucher eingeschaltet werden soll, legen wir den entsprechenden Pin auf Masse (GPIO auf „False“). Warum das am besten ist, klären wir gleich bei den Fehlerzuständen.




    Schritt 8: Fehlerzustände:


    Wenn alles „normal“ läuft, starten wir unser Programm, die Endlosschleife startet und läuft bis in alle Ewigkeit weiter. So die Theorie und der Normalzustand, aber in der Wirklichkeit müssen wir uns mit den Fehlerfällen und deren Auswirkungen beschäftigen, damit es nicht zu unangenehmen Überraschungen kommt.


    Was kann uns alles dazwischen kommen?



    Ein kurzfristiger Stromausfall (hohe Wahrscheinlichkeit)Wenn das passiert, ist der Raspi, die Relaiszeile und alle Verbraucher aus. (Kein Wunder, ist ja kein Strom da….)Wenn der Strom wieder eingeschaltet wird, dann soll der Raspi aber wieder automatisch in den geordneten Betriebszustand zurückkehren und alles ein- und ausschalten wie es soll.Das beschreibe ich gleich noch, wie das gehtDas Netzteil des Pi (und damit auch der Relaiszeile) könnte sterben (mittlere Wahrscheinlichkeit)In diesem Fall müssen alle Verbraucher ausgeschaltet werden (d.h. wenn die Relais abfallen, müssen die Verbraucher AUS sein)Andernfalls bliebe die Heizung an, das Becken würde zu warm mit den entsprechenden Folgen. Außerdem würde sich der komplette Tagesdünger und Nachfüllvorrat in den Kanistern ins Becken entleeren. Das dauerhaft brennende Licht würde den Pflanzen auch auf Dauer nicht gut tun, richtet aber keinen kurzfristigen Schaden an.Die Relaiszeile als Ganzes könnte sterben (mittlere Wahrscheinlichkeit)In diesem Fall gilt das Gleiche wie beim Ausfall des Netzteils des Pi. Der Pi könnte „durchdrehen“ wg. Programmfehler (geringe Wahrscheinlichkeit)In diesem Fall würde unkontrolliert geschaltet.Wg. des eher einfachen Programms ist dies nicht wirklich zu erwarten.Ein Relais könnte im Einschaltzustand kleben (geringe Wahrscheinlichkeit)Wirklich desaströs wäre das nur beim Stabheizer und vielleicht noch beim Tagesdünger.Den Stabheizer fangen wir ab, indem wir den mechanischen Thermostat im Heizer etwas höher als unsere im Pi eingestellten Werte setzen, also z.B. auf 26 °. Eben so, dass er im Normalbetrieb nicht in die Regelung eingreift. Das wäre dann die „Notbremse“ für den Heizer bei klebendem Relais.Das Becken sollte auch so befüllt sein, dass es notfalls noch den gesamten Vorrat aus Nachfüllbehälter und Tagesdünger aufnehmen kann, ohne überzulaufen. (so 10 l Platz lassen).Ein klebendes Relais kann im Übrigen auch bei Zeitschaltuhren und elektrischen Thermostaten auftreten, hier unterscheidet sich unsere Pi-Lösung vom Fehlerrisiko nicht von der konventionellen aus Einzelkomponenten.

    Hier sehen wir aber, das wir alles so programmieren müssen, dass bei sterbendem Pi-Netzteil und/oder Relaiszeile die Verbraucher nicht auf Dauer-Ein geschaltet werden (D.H. GPIO auf low bedeutet Relais durchgeschaltet). 100 % Sicherheit gibt es nicht, aber wir stellen uns so auf, dass die wahrscheinlichsten Fälle korrekt abgefangen sind.


    (Es sei nicht verschwiegen, dass eine Transistor-Treiberstufe vor der Relaiszeile auch die Invertierung dreht, dann wäre bei GPIO True (=high) auch das Relais durchgeschaltet. Das würde einen sterbenden Pi bei gleichzeitig noch lebender Relaiszeile noch besser abfangen. Aber dann dürfen wir auch die Transistorstufe nicht auf dem Steckbrett zusammenstöpseln, das wären m.E. zu viele wackelige Kontaktstellen.)



    Schritt 9: Automatischer Reboot


    Um sicherzustellen, dass wir nach unfreiwilligem Reboot nach einem Stromausfall wieder im Programm landen, habe ich die Variante über einen Eintrag in die Datei /etc/rc.local gewählt.



    Ist hier beschrieben:





    Dort trägt man am Ende der Datei vor „exit 0“ ein:


    python /home/pi/Aquarium.py


    Wenn man jetzt den Pi kurz vom Stromnetz trennt, bootet er nach dem Wiederherstellen der Stromversorgung direkt wieder in unser Programm. Das Booten dauert ca. 30 sec, d.h. während dieser 30 sec. sind unsere GPIOs nicht wirklich in definiertem Zustand. Ich habe beobachtet, dass die LEDs der Relaiszeile so leicht glimmen, aber die Relais nicht durchgeschaltet sind. Die GPIOs sind also in einem undefinierten Zustand, die Relais alle „Aus“. Das ist erst mal gut, aber auch wenn es nicht so wäre, in 30 sec. beim Reboot passiert nicht viel Unheil, wenn wir dann sicher in einem definiertem Zustand im Programm landen.


    Vermoutstropfen dieser Lösung: Das Programm startet bevor die graphische Benutzeroberfläche geladen ist, d.h. wir erhalten keinen Output im Terminal. Unsere „Health-LEDs“ geben aber Auskunft, ob alles OK ist.


    Ich denke, das ist verschmerzbar, wenn wir uns wirklich einloggen und den Output verfolgen wollen und wir stellen fest, dass offenbar ein automatischer Reboot stattfand, machen wir das über die Kommandos:


    sudo killall python


    python Aquarium.py


    Dann sind wir wieder im Terminal unterwegs und erhalten jede Sekunde die Schaltzustände und Temperatur gedruckt.


    Aber Hand aufs Herz: Wir wollen ja einen AUTOMATEN, der unser Becken steuert, und da wollen wir ja (nach einer Einlaufphase) nicht jeden Tag 20 x schauen, ob alles läuft, oder?.


    Im Normalfall starten wir das Programm im Terminal, wenn es keinen Output mehr gibt, dann war da ein Störfall dazwischen.



    Schritt 10: Ansprechen des Pi über VNC


    Wenn der Pi in unserem Heimnetz angemeldet ist, können wir ihn von jedem Rechner (egal ob Windows, Mac, Tablet oder Smartphone oder Linux) über VNC ansprechen und Parameter ändern. Dazu installiert man sich den VNC-Server auf dem Pi und einen VNC-Client auf dem Rechner, mit dem man den Pi ansprechen will. VNC clients gibt es für alle o.g. Geräte. Wie das geht, ist sehr gut hier beschrieben:





    Schritt 11: Inbetriebnahme am Aquarium


    So, wenn alles oben Beschriebene funktioniert und eine Weile im Test auf dem Tisch gelaufen ist, ist es soweit, die Steuerung kann an der echten Hardware am Aquarium installiert werden. Hierzu müssen wir die Komponenten noch in einem Gehäuse oder auf einer Montageplatte montieren und sauber verkabeln Wie gesagt, Vorsicht mit 230 V, sauber arbeiten oder vom Fachmann helfen lassen!


    Wenn wir das Programm im Terminal starten wollen stoppen wir das automatisch im Hintergrund gestartete und starten es im Terminal neu (s.o. Schritt 9)




    Schritt 12: Erweiterung


    Jetzt seid Ihr dran. Die Basics funktionieren, und nun können weitere Ideen hinzukommen. Wichtig war mir, erst mal die Grundfunktionen eines Aquarien-Pi erfolgreich zum Laufen zu bringen. Der Pi ist damit nicht mal zu 2 % seiner Rechenleistung ausgelastet. Also, was immer Euch einfällt, setzt es um!




    Hier der Code (hängt auch noch als Datei an):


    """
    **************************************************************************
    V24
    Aquariensteuerung Lampen/CO2/Tagesdünger/Nachfuellen/Temperatur
    Abends und Morgens
    ==> Aus-an-Zeiten selber einstellbar
    Zeit Variablen muessen im Format hh:mm angeben werden !!!!
    Nachfuell-Zeiten muessen min. 5 Minuten auseinander liegen!



    *************************** Variablen ******************************


    Lampe1 = Boolean, Schaltzustand Lampe1
    Lampe2 = Boolean, Schaltzustand Lampe2
    Lampe3 = Boolean, Schaltzustand Lampe3
    CO2 = Boolean, Schaltzustand CO2
    Duengerpumpe = Boolean, Schaltzustand Tagesduengerpumpe
    Fuellpumpe = Boolean, Schaltzustand Nachfuellpumpe
    Bodenheizer = Boolean, Schaltzustand Bodenheizer
    Stabheizer = Boolean, Schaltzustand Stabheizer
    alive = Boolean, Anzeige, dass Programm läuft


    m1 = Einschaltzeit morgens Lampe 1
    m2 = Ausschaltzeit morgens Lampe 1
    m3 = Einschaltzeit morgens Lampe 2
    m4 = Ausschaltzeit morgens Lampe 2
    m5 = Einschaltzeit morgens Lampe 3
    m6 = Ausschaltzeit morgens Lampe 3
    m7 = Einschaltzeit morgens CO2
    m8 = Ausschaltzeit morgens Co2


    a1 = Einschaltzeit abends Lampe 1
    a2 = Ausschaltzeit abends Lampe 1
    a3 = Einschaltzeit abends Lampe 2
    a4 = Ausschaltzeit abends Lampe 2
    a5 = Einschaltzeit abends Lampe 3
    a6 = Ausschaltzeit abends Lampe 3
    a7 = Einschaltzeit abends CO2
    a8 = Ausschaltzeit abends Co2



    Duengen = Zeitpunkt für Tagesduenger
    Nachfuellen = Zeitpunkt für Nachfuellen


    s1 = Dauer Doesierung Tagesduenger in sec
    s2 = Dauer Nachfuellen ins sec


    temp = Temperaur in °C


    BHL = Bodenheizer Low (ein)
    BHH = Bodenheizer High (aus)


    SHL = Stabheizer Low (ein)
    SHH = Stabheizer High (aus)


    TWH = Temperatur-Warnlevel High
    TWL = Temperatur-Warnlever Low


    ************************ Ende Variablen ******************************


    """


    # ******************** Importierte Module *****************************



    import RPi.GPIO as GPIO
    from time import *
    # from time import localtime
    import sys
    import os


    #import time


    # ******************* Definieren der GPIOs ***************************



    GPIO.setwarnings(False)
    GPIO.setmode(GPIO.BCM)
    GPIO.setup(13, GPIO.OUT) # Lampe1
    GPIO.setup(16, GPIO.OUT) # Lampe2
    GPIO.setup(19, GPIO.OUT) # Lampe3
    GPIO.setup(20, GPIO.OUT) # CO2
    GPIO.setup(21, GPIO.OUT) # Tagesduenger
    GPIO.setup(26, GPIO.OUT) # Nachfuellen
    GPIO.setup(12, GPIO.OUT) # Bodenheizer
    GPIO.setup(6, GPIO.OUT) # Stabheizer
    GPIO.setup(5, GPIO.OUT) # Alive
    GPIO.setup(7, GPIO.OUT) # Temperatur out of range



    # ****************** Beginn Einstellparameter **************************


    # Ein- und Ausschaltzeiten der Lampen


    #Lampe 1
    m1 = "10:0"
    m2 = "14:00"


    #Lampe 2
    m3 = "10:30"
    m4 = "13:30"


    #Lampe 3
    m5 = "11:00"
    m6 = "13:00"


    #CO2
    m7 = "08:00"
    m8 = "21:00"


    #Lampe 1
    a1 = "18:00"
    a2 = "22:00"


    #Lampe 2
    a3 = "18:30"
    a4 = "21:30"


    #Lampe 3
    a5 = "19:00"
    a6 = "21:00"


    #CO2
    a7 = "08:00"
    a8 = "21:00"


    # Tagesduenger
    s1 = 10
    Duengen = "08:00"


    # Nachfuellen
    s2 = 59
    Nachfuellen = "09:00"


    # Temperatur-Schaltpunkte


    BHL = 22.2 # Bodenheizer Low (ein)
    BHH = 22.5 # Bodenheizer High (aus)


    SHL = 21.9 # Stabheizer Low (ein)
    SHH = 22.3 # Stabheizer High (aus)


    TWH = 22.7 # Warnlevel Temperatur High
    TWL = 21.7 # Warnlevel Temperatur Low



    # ************************ Ende Einstellparameter *******************************



    # ************************ Beginn Programm **************************************


    # Initialisieren aller Ausgaenge auf AUS


    GPIO.output(12, True)
    GPIO.output(13, True)
    GPIO.output(16, True)
    GPIO.output(19, True)
    GPIO.output(20, True)
    GPIO.output(21, True)
    GPIO.output(26, True)
    GPIO.output(6, True)
    GPIO.output(5, True)


    # Initialisieren der Variablen


    Lampe1 = False
    Lampe2 = False
    Lampe3 = False
    CO2 = False
    Duengerpumpe = False
    Fuellpumpe = False
    Bodenheizer = False
    Stabheizer = False
    temp = 25
    zeit = strftime("%H:%M", localtime())
    alive = False


    # Endlosschleife


    while True:


    # Auslesen des Tempratursensors
     
    # 1-Wire Slave-Liste lesen
    file = open('/sys/devices/w1_bus_master1/w1_master_slaves')
    w1_slaves = file.readlines()
    file.close()


    # Fuer jeden 1-Wire Slave aktuelle Temperatur ausgeben
    for line in w1_slaves:
    # 1-wire Slave extrahieren
    w1_slave = line.split("\n")[0]
    # 1-wire Slave Datei lesen
    file = open('/sys/bus/w1/devices/' + str(w1_slave) + '/w1_slave')
    filecontent = file.read()
    file.close()


    # Temperaturwerte auslesen und konvertieren
    stringvalue = filecontent.split("\n")[1].split(" ")[9]
    temp = float(stringvalue[2:]) / 1000




    # Auswerten der Zeit und Schalten der Ausgaenge


    # Lampen


    if (zeit >= m1 and zeit<= m2) or (zeit >= a1 and zeit<= a2) :
    GPIO.output(13, False)
    Lampe1= True
       
    else :
    GPIO.output(13, True)
    Lampe1 = False
         
    #sleep(2)
       
    if (zeit >= m3 and zeit<= m4) or (zeit >= a3 and zeit<= a4) :
    GPIO.output(16, False)
    Lampe2 = True
       
    else :
    GPIO.output(16, True)
    Lampe2 = False
         
    #sleep(2)


    if (zeit >= m5 and zeit<= m6) or (zeit >= a5 and zeit<= a6) :
    GPIO.output(19, False)
    Lampe3= True
       
    else :
    GPIO.output(19, True)
    Lampe3 = False



    if (zeit >= m7 and zeit<= m8) or (zeit >= a7 and zeit<= a8) :
    GPIO.output(20, False)
    CO2= True
       
    else :
    GPIO.output(20, True)
    CO2 = False


    # Tagesduenger


    if zeit == Duengen:
    GPIO.output(21, False)
    sleep(s1)
    GPIO.output(21, True)
    print ("Duengen an")
    sleep(60)
                 
    # Nachfuellen



    if zeit == Nachfuellen:
    GPIO.output(26, False)
    print ("Nachfuellen an")
    sleep(s2)
    GPIO.output(26,True)


    sleep(60)


    # Temperatur


    if (temp < BHL) :
    GPIO.output(12, False)
    Bodenheizer = True


    if (temp > BHH) :
    GPIO.output(12, True)
    Bodenheizer = False


    if (temp < SHL) :
    GPIO.output(6, False)
    Stabheizer = True


    if (temp > SHH) :
    GPIO.output(6, True)
    Stabheizer = False


    if (temp >= TWL) and (temp <= TWH) :
    GPIO.output(7, True)
    else:
    GPIO.output(7, False)



    # Output von x Zeilen zum Klaeren des Bildschirms



    zaehler= 10
    while zaehler>0:
    print("*")
    zaehler-=1


    # Ausgabe der Zeit


    zeit =strftime("%H:%M", localtime())
    print (zeit)



    # Ausgabe aller Schaltzustaende
         
    if Lampe1== True:
    print("Lampe 1 an")
    else:
    print("Lampe 1 aus")


    if Lampe2== True:
    print("Lampe 2 an")
    else:
    print("Lampe 2 aus")


    if Lampe3== True:
    print("Lampe 3 an")
    else:
    print("Lampe 3 aus")


    if CO2 == True:
    print("CO2 an")
    else:
    print("CO2 aus")



    # Temperatur ausgeben
    print(str("Temperatur =") + ' %6.2f °C' % temp)


    if Bodenheizer == True:
    print("Bodenheizer an")
    else:
    print("Bodenheizer aus")


    if Stabheizer == True:
    print("Stabheizer an")
    else:
    print("Stabheizer aus")



    if alive == True:
    GPIO.output (5, True)
    alive = False
    print ("x")
    else:
    GPIO.output (5, False)
    alive = True
    print ("+")



    sleep (0.1)
    [/code]

    Files

    • Aquarium.py

      (8 kB, downloaded 72 times, last: )