[TOP TIPP] Automatische Bewässerungssteuerung

[Sun1453]

Moin Zusammen,
nun, da es langsam Sommer wird und draußen der Garten wieder furchtbar trocken ist, ist es an der Zeit meine Bewässerung auf den Wolf umzusetzen.

Hallo Martin,

sehr interessantes Bauwerk deine Bewässerung. Ich kenne in der Bekanntschaft einige die auch sowas umsetzen wollen. Welche Komponeten sind bei dir in der Anlage so verbaut?

[MiniMaxV2]

Die Überlegung war - nix versprochen - dass man eine Art Assistenzseite bauen könnte, in welcher die Nutzer die bekannten Informationen eingeben zu

Hi Stefan,
das klingt vom Ansatz her sehr interessant - ihr benutzt eure Logik-Engine und abstrahiert quasi Anwendungsfälle mit einer eigenen GUI
Und klar, es gibt erstmal anderes wichtigeres, denn letztlich ist die Funktion an sich bereits umsetzbar durch die Anwender
(und ich hatte schon Angst, dass ich mir grade meine Logik zusammen Bau und dann die Lösung vom Wolf kommt )

[MiniMaxV2]

Hi Georg,

danke für das Lob Die Bewässerung ist meine 3. Iteration (an 2 unterschiedlichen Positionen). Hab mich ein wenig im Schwimmbad-Bau bedient.
Zu deinen Fragen:

1. du hast nach der Pumpe und vor dem Wasserverteiler am linken unteren Anschluss ein schrägsitzendes Filterelement das deine Magnetventile nicht verschmutzen oder beschädigt werden

Genau - das ist ein 130Mikronen Filter mit 6m³ Durchsatz. Hält mir Sand und bissel Rost aus dem Grundwasser fern.

2. Der erste obere linke Anschluss ist vermutlich deine Druckanzeige ( im roten Feld vermutlich der vorhandene Druck) die aber elektrisch noch nicht angeschlossen ist.

Ja genau. Das ist ein Drucksensor (mit Anzeige, 24V DC). Da das Bild aus letztem Jahr ist, ist der bereits angeschlossen und die Werte gehen per Wiregate ADC (0-10V) auf den 1-Wire Bus.

3. Der zweite obere Anschluss ist vermutlich ( zu unscharf ) für Entlüftung bei Inbetriebnahme oder für Druckluft zum entwässern zum einwintern.

Das ist ein Druckluft-Anschluss. Wird genutzt zum entwässern im Winter. Enlüftung brauchts da fast nicht - das geht über die Endkreise. Leider ist der Nippel abgerostet im Winter - da muss jetzt ein V4A hin

4. Der untere zweite Anschluss als Reserve oder die normale Hauswasser ( Gartenwasser )

Der ist als Reserve bzw. war ursprünglich als 2. Pumpen-Eingang gedacht. So hätte ich einen zweiten Brunnen in eine andere Wasser Ader bohren können (wir hatten am Alten Brunnen bereits eine Trockenphase vorletztes Jahr). Aber derzeit ist die Planung eher an einem anderen Baum (die Abgänge mit dem Hahn nach unten) anzuschließen.

5. Bei der Pumpe gleich eine Steckdose dazu

Die ist mittlerweile unter einem kleinen "Dach". Läuft auf einen Aktor im Keller.

6. Nähe Pumpe noch für Reserveanschlüsse genug Rohr gelassen oder zum verlängern genug Platz gelassen

Genau - bisher sind es 12 Ventile, 3 Abgänge zu UVs, 2 Einspeisungen. Insgesamt wären 20 Schellen möglich (einfach oder doppelt).

[eib-eg]

Ich finde deine Bauweise sowie die Zusammenstellung und Planung einfach nur genial

[MiniMaxV2]

Hi Robert,
danke dir
Ich bin auch erschlagen, wenn ich eure Logiken sehe Aber wenn man sich ein wenig damit auseinander setzt und versteht, wie StefanK sich das alles so gedacht hat, ist das gar nicht mehr so schwer.

Was ich nicht ganz verstehe: Bei dir sendet die Kreissteuerung die Anforderung an das System, ich vermute, weil du auch einzeln schalten willst - macht Sinn. Wie funktioniert dann das Weiterschalten in der Automatik: passiert das während der Nachlaufzeit, so dass der nächste Kreis eine Anforderung schickt, bevor die Nachlaufzeit zu Ende ist?

Also gedacht ist so, dass durch das Finish Signal der Sequenzer weiterschaltet (Rising Edge Logik als Eingangsgatter). Dabei hört der "alte" Kreis auf eine System Anforderung zu stellen und der "Neue" stellt sie. Prinzipiell funktioniert das ja alles in einem "Takt". Allerdings (ich glaube darauf willst du raus) wird es einen kurzen "Glitch" geben, in der die Anforderung verschwindet und somit dann das System anfängt "runterzufahren". Ich hab es aber eigentlich so geplant, dass spätestens während der Nachlaufzeit dieser Glitch sich stabilisiert und damit dann vom "Nachlauf Pumpe" wieder in "Run" übergangen wird. Da hab ich aber noch nicht den Übergang eingebaut in dem Automaten, da ich erst den Glitch sehen wollte. Wie gesagt ist noch WIP

[MiniMaxV2]

Welche Komponeten sind bei dir in der Anlage so verbaut?

Hi Michael,
Der Verteilerbaum besteht aus 63mm PVC Rohr. Dran sind 1" Anbohrschellen, mit den Hähnen bzw. Ventilen. Zuerst waren Gardena Verbaut, die hab ich aber nach ein zwei Wintern bereits defekt gehabt (die noch dran sind, sind die verbleibenden). Ansonsten sind es Hunter PGV-100 mit 24 AC. Der Sensor ist ein IFM PN2024 - angeschlossen per 0-10V an ein Wiregate ADC. Die Gerieberegner sind RainBird 5004 in Edelstahl, die Sprüher die US-400 von Rainbird mit den 18er VAN Düsen. Ich betreibe die bei gut 2,5-3 Bar damit bissel mehr Raus kommt und der Radius mit 5m gut gewässert wird. In der Erde verlegt sind 1" HDPE Rohre, als Verbinder nutze ich primär die Gardena - die sind einfach genial mit der 1/4 Umdrehung und dicht... Dann hab ich noch einige normale Gartensprenger im Einsatz, Gardena Microdrip mit den Kleinflächendüsen und noch einige Tropfrohre (NoName) auch mit Gardena Kleinflächendüsen kombiniert. Im Keller läuft alles über MDT Schaltaktoren. Ein Trafo für 24V AC und 24V DC.

Der zweite Baum (derzeit in Bau), kommt dann in gleicher Art und Weise, nur dass die Aktoren in eine Außenverteilung kommen (Hager ZAL53).

[MiniMaxV2]

So weiter gehts. Heute hab ich den Sequencer angefangen. Dieser ist "etwas" kompliziert aufgebaut, da ich für jeden Kreis einen Ausgang definieren muss. Ausgänge als Array gibt es ja (leider) nicht

Beim Testen ist dann auch aufgefallen, dass wenn ich zwei Ausgänge einer Logik auf einen Eingang lege, immer der zuletzt gesendete Wert gilt. Dies hat dafür gesorgt, dass bei meiner System Anforderungs Loop die Pumpe immer nach dem ersten Kreis abgeschaltet hat. Ein Oder dazwischen schafft Abhilfe.

Code: Alles auswählen

/**
 * File: Irrigation_Sequencer.twl V1.0 ALPHA 1
 * Logic for Garden irrigation. This module is the sequencer which controls an automatic run of all circuits 
 * Author: Hans Martin
 * 
 */

{
  "Input": [
        ["Start", "(RISING) Trigger to start an automatic irrigation cycle", "$TriggerInpStart", "c"],
        ["Stop", "(RISING) Trigger to stop an automatic irrigation cycle", "$TriggerInpStop", "c"],
        ["Next", "(RISING) Trigger to step to next circuit", "$TriggerInpNext", "c"],

        ["Inhibit", "", "$VAR<Inhibit?>", "c"]
  ],
  "Output": [
        ["Sequencer Active", "(0/1) State of sequencer", "$SequencerActive", "c"],
        ["Sequencer Number", "(R+) Current active output number", "$SequencerNumber", "c"],
        ["Stop", "(RISING) Signal to stop all irrigation circuits", "$SequencerStop", "c"],

        // repeat as many time as desired irrigation circuits
        ["Channel 1", "(0/1) Trigger for irrigation circuit", "$Circuit_1", "c"],
        ["Channel 2", "(0/1) Trigger for irrigation circuit", "$Circuit_2", "c"]
  ],
  "Level": [
        // Inputs
        ["$VAR<Inhibit?>","bool",false],
        ["$TriggerInpStart","bool",false],
        ["$TriggerInpStop","bool",false],
        ["$TriggerInpNext","bool",false],

        // Outputs
        ["$SequencerActive","bool",false], // also used as internal state
        ["$SequencerNumber","int",0],
        ["$SequencerStop","bool",false],

        // Channels
        // Configure number of circuits
        ["$NumberOfSteps","int",2],
        // channel outs - repeat as many irrigation circuits are configured above
        ["$Circuit_1","bool",false],
        ["$Circuit_2","bool",false],

        // Constants
        ["$Konst1", "int", 1],

        // Internals
        ["$CurrentStep","int",0],
        ["$NextStep","int",0],
        ["$StepOverflow", "bool", false],
        ["$TriggerInpStartRising","bool",false],
        ["$TriggerInpStopRising","bool",false],
        ["$TriggerInpNextRising","bool",false],
        ["$TriggerInpStartLast","bool",false],
        ["$TriggerInpStopLast","bool",false],
        ["$TriggerInpNextLast","bool",false]
  ],
  "Module": [
        // calculate rising edges
        ["And", ["$TriggerInpStart","-$TriggerInpStartLast", "-$SequencerActive"], "$TriggerInpStartRising"],
        ["And", ["$TriggerInpStop","-$TriggerInpStopLast", "$SequencerActive"], "$TriggerInpStopRising"],
        ["And", ["$TriggerInpNext","-$TriggerInpNextLast", "$SequencerActive"], "$TriggerInpNextRising"],

        // set last trigger variables
        ["And", ["$TriggerInpStart"], "$TriggerInpStartLast"],
        ["And", ["$TriggerInpStop"], "$TriggerInpStopLast"],
        ["And", ["$TriggerInpNext"], "$TriggerInpNextLast"],

        // calculate start of system
        ["Multiplexer", ["$SequencerActive", "$Konst1"], "$SequencerActive", "$TriggerInpStartRising"],

        // calculate next step
        ["Polynomial", "$Konst1", "$NextStep", ["$CurrentStep", "$Konst1"] ], // ++$CurrentStep
        ["Comparator", "$NextStep", "$StepOverflow", "$NumberOfSteps"],
        ["Multiplexer", ["$NextStep", 0], "$NextStep", "$StepOverflow"],

        // set next step when next was triggered or system was started
        ["Multiplexer", ["$CurrentStep","$NextStep"], "$CurrentStep", "$TriggerInpNextRising"],
        ["Multiplexer", ["$CurrentStep","$NextStep"], "$CurrentStep", "$TriggerInpStartRising"],
        
        // reset current step when stop was issued
        ["Multiplexer", ["$CurrentStep",0], "$CurrentStep", "$TriggerInpStopRising"],
        ["Monoflop","$TriggerInpStopRising", 0, 0,"$Konst1",2],
        
        // write common outputs
        ["Polynomial", 0, "$SequencerNumber", ["$CurrentStep"]],
        ["Multiplexer", [0, "$Konst1"], "$SequencerStop", "$TriggerInpStopRising"],
        ["Multiplexer", [0, "$SequencerActive"], "$SequencerActive", "$CurrentStep"],

        // write circuit outputs
        // copy as many circuit exists. Put a zero in front of $Konst1 for each new step. 
        ["Multiplexer", [0, "$Konst1", 0], "$Circuit_1", "$CurrentStep"],
        ["Multiplexer", [0, 0, "$Konst1", 0], "$Circuit_2", "$CurrentStep"]

  ]
}

Das System Control hab ich auch bearbeitet. Hier ist der Zustandsübergang von 4 nach 3 dazu gekommen.

SystemControlAutomat.png

Code: Alles auswählen

/**
 * File: Irrigation_SystemControl.twl V1.0 ALPHA 2
 * Logic for Garden irrigation. This module is the SystemControl which controls the pump and other related systems (like power supplies).
 * Author: Hans Martin
 * 
 */

{
  "Input": [
        ["System Request", "(0/1) Indicates whether the system should be activated", "$SystemRequest", "c"],
        ["System Forerun", "(T_s) Time how long the system should run before the pump is activated", "$SystemForerun", "u"],
        ["Pump Forerun", "(T_s) Time how long the pump should run before system goes into the OK state", "$PumpForerun", "u"],
        ["System FollowUp", "(T_s) Time how long the system should run after the pump is shut down", "$SystemFollowUp", "u"],
        ["Pump FollowUp", "(T_s) Time how long the pump should run after the request gone", "$PumpFollowUp", "u"],
        ["Inhibit", "", "$VAR<Inhibit?>", "c"]
  ],
  "Output": [
        ["System State","(0/1) Indicates whether the system has a request","$SystemState","c"],
        ["System OK", "(0/1) Indicates that the system is in fully operational state", "$SystemOk", "c"],
        ["System Warning", "(0/1) Indicates that the system is partially operating", "$SystemWarn", "c"],
        ["System Error", "(0/1) Indicates that the system is in faulted state", "$SystemError", "c"],
        ["System", "(0/1) Output to activate the system devices (e.g. power supply)", "$SystemOut", "c"],
        ["Pump", "(0/1) Output to activate the pump", "$PumpOut", "c"]
  ],
  "Level": [
        // Inputs
        ["$VAR<Inhibit?>","bool",false],
        ["$SystemRequest", "bool", false],
        ["$SystemForerun", "float", 0],
        ["$PumpForerun", "float", 0],
        ["$SystemFollowUp", "float", 0],
        ["$PumpFollowUp", "float", 0],

        // Outputs
        ["$SystemState", "bool", false],
        ["$SystemOk", "bool", false],
        ["$SystemWarn", "bool", false],
        ["$SystemError", "bool", false],
        ["$SystemOut", "bool", false],
        ["$PumpOut", "bool", false],
        
        // Consts
        ["$Konst1", "int", 1],
        ["$Konst5", "int", 5],

        //Internals
        ["$State","integer",0],
        ["$InternalSystemWarn", "bool", false]
  ],
  "Module": [
        ["Break", ["$VAR<Inhibit?>"]], // this is a problem! Fix it! (If system is running and inhibit is set, there is no way to reset the system!)
        // build state
        ["Statemachine",
            // 0: System Off
            // 1: System Forerun
            // 2: Pump Forerun
            // 3: Running
            // 4: Pump FollowUp
            // 5: System FollowUp
            [
                // [condition , current state, next state, timeout]
                ["$SystemRequest", 0, 1, "$SystemForerun"], // new request
                ["-$SystemRequest", 1, 0, 0], // request canceled during system forerun
                [0, 1, 2, "$PumpForerun"], // system forerun done
                ["-$SystemRequest", 2, 0, 0], // request canceled during pump forerun
                [0, 2, 3, 0], // pump forerun done, system fully operating
                ["$SystemRequest", 3, 3, 0], // request still true
                ["-$SystemRequest", 3, 4, "$PumpFollowUp"], // pump follow up
                ["$SystemRequest", 4, 3, 0], // request within pump follow up
                [0, 4, 5, "$SystemFollowUp"], //system follow up
                [0, 5, 0, 0] // system off
            ],
            "$State"
        ],

        // map state to output
        ["Comparator", "$State", "$SystemOut", 0], // System Out (only 1 when state > 0)
        ["Multiplexer", [0, 0, "$Konst1", "$Konst1", "$Konst1", 0], "$PumpOut", "$State"], // Pump Out (1 when 5 > state > 1)

        // map state to state outputs
        ["Comparator", "$State", "$SystemState", 0], // SystemState (only 1 when state > 0)
        ["Multiplexer", [0, "$Konst1", "$Konst1", 0, "$Konst1", "$Konst1"], "$InternalSystemWarn", "$State"], // system has warning if not in state 3 and has request
        ["And", ["-$SystemError", "$InternalSystemWarn"], "$SystemWarn"], // system has only warning exposed if no error is active
        ["And", ["-$SystemError", "-$SystemWarn", "$SystemRequest"], "$SystemOk" ] // system is ok if no error and no warning is active and request was made
  ]
}

Die Systemübersicht ist auch um das Oder erweitert

Systemübersicht.jpg

[Robert_Mini]

Hallo Hans-Martin!

Super gemacht und sehr übersichtlich bzw. perfekt dokumentiert.

Zum Problem mit den Ausgängen:
Du kannst Ausgänge (bei den Eingängen klappt das nocht nicht) mit einem ? als optional markieren.
So kannst du die Logik für 8 Kreise fertigstellen und Ausgang 3-8 ausblenden. Der Anwender holt sich dann soviele wie benötigt (max 8).

Sehe ich das richtig:
- Sequenzer und Systemsteuerung braucht man je 1x
- Kreissteuerung je Kreis

In jedem Fall tolle Sache, mein Wolf scharrt schon danach!

Lg
Robert

[MiniMaxV2]

Hi Robert,
danke fürs Lob. Als Entwickler ist man eine gewisse Struktur gewohnt, ich muss Code "Lesen" können wie andere ein Buch. In Hochsprachen erreiche ich das überwiegend durch sprechende Namen der Methoden und Variablen hier müssen halt wieder Kommentare her halten wie in Assembler

Die Eingänge werde ich noch umbauen auf eine Liste (wie die Inhibits), so spare ich mir das Oder vorweg.
Die Idee mit den Optionalen Ausgänge gefällt mir - wird gleich umgesetzt. Nur es werden mehr wie 8 - ich brauche jetzt im aktuellen Zustand 15 Ausgänge

Zu deinen Fragen - genau SystemControl sowie Sequencer werden je 1x gebraucht. Die CircuitControl dann je Kreis.
Mein Plan ist es die Logik die nächsten ein/zwei Wochen im Trockenlauf fertig zu haben und dann die Bewässerung in Betrieb zu nehmen darüber. Da hab ich nur noch ein/zwei Stolpersteine - ich weiß noch nicht, wie der Trigger Datentyp in KNX auf ein Bool im Wolf gemapped wird (ich brauche in den Logiken eine Steigende Flanke als Trigger) der dann wieder zurück gesetzt wird nach kurzer Zeit und dann ist da noch der Projektimport der bei mir nicht geht, da ich Secure Komponenten im Projekt hab und damit ein Passwort. Die beiden Punkte muss ich noch in naher Zukunft lösen

Ich bin gespannt, wie sich die Logik dann bei anderen Verhält bzw. einfügen lässt. Als Entwickler ist es ja immer einfacher

[Robert_Mini]

Hallo Hans-Martin!

Danke für die weiteren Infos. Kann leicht sein, dass ich gleich im Test mitmache .

Zu deinem Problem mit dem Trigger, für den Beschriebenen Fall würde ich das wie folgt machen:
- Trigger 1.017 direkt auf Bool, das passt grundsätzlich, Eingangsoption "c" on change.
- Im Code verarbeitest du die steigende Flanke
- Am Ende des Codes einfach per Latch (Option 0 und fix "True" auf den Trigger des Latch-Eingangs) die Variable des Eingangs mit "false" überschreiben.
- Du siehst dann zawr im Dokmode beim Überschreiben mit 1 an der Oberfläche nie den True Status, da die Logik bei der Ausführung wieder false an die GUI zurückmeldet, aber es funktioniert und ich nutze das bei typischerweise bei "Reset"-Eingängen.

lg
Robert