Dauerkalender

Automatische Regenwasseranlage mit Arduino

Eine ähnliche Steuerung für Regentonnen haben wir bereits konstruiert. Sie wurde ausschließlich mithilfe von Relais realisiert. Eine Lösung für alle, die sich für programmierbare Steuerungen nicht besonders begeistern. Sie ist unter diesem Link zu finden:

In dem aktuellen Versuch basiert die Steuerung auf einem Mikrocontroller. Zum Einsatz kommt Arduino UNO. Dank Einsetzung eines Mikrocontrollers ist man bei Gestaltung einer solchen Steuerung flexibler, spätere Änderungen bzw. Erweiterungen können problemlos durchgeführt werden.
Die Aufgaben, die die Steuerung zu erledigen hat, sind ähnlich wie die bei der Relais-Steuerung beschriebenen.
Sie soll grundsätzlich dafür sorgen, dass eine Haupt-Regentonne stets mit Wasser gefüllt ist. Die zweite Aufgabe bezieht sich auf den Wasseraustausch. Wenn es regnet, die Regentonne jedoch bereits voll mit Wasser gefüllt ist, soll ein kontinuierliches Wasseraustausch stattfinden. Das alte Wasser soll schrittweise aus der Regentonne abgelassen und mit einem neuen ersetzt werden. Kurz um: Die Regentonne soll nicht nur mit Wasser befüllt werden, es soll auch dafür gesorgt werden, dass das Wasser möglichst frisch ist.
Unsere Regenwasseranlage besteht aus zwei Behälter. Ein kleines Auffangbecken, möglichst mit einem Filter ausgestattet, wird direkt unter einer Hausrinne positioniert. Die eigentliche große Regentonne kann in einem Abstand auf einem weniger sichtbaren Platz aufgestellt werden. Beide Wasserbehälter sind mit einem Schlauch miteinander verbunden. Um das Wassermanagement problemlos durchzuführen zu können, wird die Anlage mit vier Geräten ausgestattet. Beide Behälter verfügen jeweils über einen Wassersensor, mit dem der maximale Wasserstand gemeldet wird. Zusätzlich gibt es eine Wasserpumpe, die das Wasser aus dem Auffangbecken in die Regentonne fordert. Die große Regentonne verfügt darüber hinaus noch über ein Ventil, das es ermöglicht, das Wasser abzulassen.

Prinzip

Es regnet. Mit dem Niveauschalter S5 erkennt die Steuerung, dass Auffangbecken voll mit Wasser gefüllt ist. Wenn die Regentonne noch nicht voll ist, wird die Pumpe P1 eingeschaltet und das Wasser aus dem Auffangbehälter in die Regentonne befördert.
Wenn beide Behälter voll sind (Niveauschalter S5 und S6), wird Wasseraustauschvorgang aktiviert. Ventil Y1 wird geöffnet und Wasser aus der Regentonne teilweise abgelassen. Anschließend wird das Ventil wieder geschlossen und die Pumpe P1 eingeschaltet. Frisches Wasser gelangt in die Regentonne.

Wasser-Volumen

Damit Wasseraustausch auch richtig funktioniert, die Regentonne immer voll bleibt und die Pumpe nicht zu oft ein- und ausgeschaltet wird, muss das Wasservolumen für den Wasseraustauschvorgang angepasst werden. Wenn nicht alle Daten zur Verfügung stehen, kann das Volumen empirisch bestimmt werden. Es muss sichergestellt werden, dass die Wassermenge, die von der Pumpe P1 in die Regentonne befördert wird, ungefähr gleich der Wassermenge ist, die mit dem Ventil Y1 abgelassen wird. Die Pumpe P1 und das Ventil Y1 werden im Programm für eine bestimmte Zeit aktiviert. Diese Zeiten müssen bei der ersten Inbetriebnahme der Anlage bestimmt und im Programm eingegeben werden. Es stehen für sie zwei separate Variablen zur Verfügung: „Pumpe_Zeit_in_ms“ und „Ventil_Zeit_in_ms“.

Schaltplan

Hand-Betrieb

Sofern die Steuerung mit dem Schalter S1 aktiviert wurde, kann man mit dem Schalter S2 auf Hand-Betrieb umschalten. In dem Hand-Betrieb können alle Komponenten der Anlage auf ihre Betriebstüchtigkeit geprüft werden. Mit Taster S3 kann das Ventil manuell ein- bzw. ausgeschaltet werden. Mit dem Taster S4 kann die Pumpe P1 getestet werden. Bei Betätigen der Niveauschalter S5 und S6 gehen die zuständigen Anzeige-LEDs ein bzw. aus.

Selbsthaltung

Um unnötige Stromaufnahme zu vermeiden, verfügt die Schaltung über ein automatisches AUS-Mechanismus. Die Steuerung wird aktiv, wenn im Regenfall der Niveauschalter S5 „Auffangbecken voll“ meldet. In diesem Fall wird der Transistor T1 leitend und das Relais K1 angezogen. Über sein Schließer-Kontakt wird Arduino mit Strom versorgt. Nach kurzer Anlaufphase wird das Programm gestartet und der Ausgang D2 gesetzt. Damit bleibt der Transistor T1 weiterhin leitend, auch wenn der Niveauschalter S5 wieder abfällt. So übernimmt Arduino selbst seine Spannungsversorgung. Der Ausgang D2 wird erst dann zurückgesetzt und die Schaltung komplett abgeschaltet, wenn über längere Zeit keine Aktivitäten des Niveauschalters S5 stattgefunden haben.

Spannungsteiler

Da die Versorgungsspannung 12 V beträgt, Arduino jedoch nur mit 5 V-Signalen arbeiten kann, muss eine Potenzialanpassung durchgeführt werden. Dies übernehmen zwei Spannungsteiler, die 12 V auf 5 V reduzieren. Der erste Spannungsteiler bilden die Widerstände R3 und R4 (Signal Hand-Betrieb, Eingang D3), der zweite besteht aus den Widerständen R13 und R14 (Signal Auffangbecken voll, Eingang A0). In beiden Fällen bestehen die Spannungsteiler aus 14 kOhm und 10kOhm - Widerständen. Die Berechnung der einzelnen Widerstände kann mit unserem E-Rechner durchgeführt werden.

Relais

In der Schaltung werden laut Plan Relais mit nur einem Schließer benötigt. In der Testschaltung kommen Relais mit zwei Wechsler zum Einsatz. Für die Funktionalität der Schaltung hat das keine Bedeutung. Bei Verwendung von Relais soll man an die Freilaufdioden, die eine wichtige Schutzfunktion haben, unbedingt denken. In unserer Schaltung sind das die Dioden D3, D4 und D5.

Transistor

In der Schaltung kommen drei NPN-Transistoren BD135 zum Einsatz. Sie können Abnehmer bis zu 1,5 A mit Strom versorgen. Bei den kleinen Relais, die in der Testschaltung verwendet werden, handelt es sich um Relais mit geringer Stromaufnahme. Hier können die Transistoren ohne Kühlkörper bedenklos arbeiten. Bei größeren Relais oder Leistungsschützen müssen die Transistoren u.U. mit Kühlkörper versehen werden.

Programm

unsigned long Ventil_Zeit_in_ms = 10000;         // Hier müssen passende Zeiten 
unsigned long Pumpe_Zeit_in_ms = 10000;           // eingetragen werden.
unsigned long Ruhezeit = 10000;

int Selbsthaltung = 2;                           // Zuordnung der Anschlußpins
int Hand = 3;
int LED_Hand_Betrieb = 4;
int LED_Auto_Betrieb = 5;
int LED_Niveau_Auffangbecken_Max = 6;
int LED_Niveau_Regentonne_Max = 7;
int LED_Abflussventil = 8;
int LED_Wasserpumpe = 9;
int Taster_Ventil_Ein = 10;
int Taster_Pumpe_Ein = 11;
int Ventil_Ein = 12;
int Pumpe_Ein = A2;
int Niveau_Auffangbecken_Max = A0;
int Niveau_Regentonne_Max = A1;

int Status;                                  // 0 - Handbetrieb
                                             // 1 - Automatik
                                             // 2 - Ruhezeit, keine Aktivitäten
                                             // 3 - Regentonne füllen
                                             // 4 - (Wassertausch) Wasser ablassen

unsigned long Zeit_Start;                    // Zeitvariablen
unsigned long Zeit_Aktuell;

// ***************************************************************************************
void setup() {

  pinMode(Selbsthaltung, OUTPUT);
  pinMode(Hand, INPUT);
  pinMode(LED_Hand_Betrieb, OUTPUT);
  pinMode(LED_Auto_Betrieb, OUTPUT);
  pinMode(LED_Niveau_Auffangbecken_Max, OUTPUT);
  pinMode(LED_Niveau_Regentonne_Max, OUTPUT);
  pinMode(LED_Abflussventil, OUTPUT);
  pinMode(LED_Wasserpumpe, OUTPUT);
  pinMode(Taster_Ventil_Ein, INPUT_PULLUP);
  pinMode(Taster_Pumpe_Ein, INPUT_PULLUP);
  pinMode(Ventil_Ein, OUTPUT);
  pinMode(Pumpe_Ein, OUTPUT);
  pinMode(Niveau_Auffangbecken_Max, INPUT);
  pinMode(Niveau_Regentonne_Max, INPUT_PULLUP);
}

// ***************************************************************************************
void LED_Anzeige () {

    // LED ANZEIGE VENTIL Y1 --------------------------------------------------
    if (digitalRead(Ventil_Ein) == HIGH) {
        digitalWrite (LED_Abflussventil, HIGH);
    } else {
        digitalWrite (LED_Abflussventil, LOW);
    }
    // LED ANZEIGE PUMPE P1 ---------------------------------------------------
    if (digitalRead(Pumpe_Ein) == HIGH) {
        digitalWrite (LED_Wasserpumpe, HIGH);
    } else {
        digitalWrite (LED_Wasserpumpe, LOW);
    }    
    // LED ANZEIGE BETRIEB ----------------------------------------------------
    if (digitalRead(Hand) == LOW) {
        digitalWrite (LED_Hand_Betrieb, LOW);
        digitalWrite (LED_Auto_Betrieb, HIGH);
    } else {
        digitalWrite (LED_Hand_Betrieb, HIGH);
        digitalWrite (LED_Auto_Betrieb, LOW);      
    }
    // LED ANZEIGE NIVEAUSCHALTER ---------------------------------------------
    if (digitalRead(Niveau_Auffangbecken_Max) == HIGH) {
        digitalWrite (LED_Niveau_Auffangbecken_Max, HIGH);
    } else {
        digitalWrite (LED_Niveau_Auffangbecken_Max, LOW);
    }
    if (digitalRead(Niveau_Regentonne_Max) == LOW) {
        digitalWrite (LED_Niveau_Regentonne_Max, HIGH);
    } else {
        digitalWrite (LED_Niveau_Regentonne_Max, LOW);
    }    
}

// ***************************************************************************************
void loop() {

    // SELBSTHALTUNG EIN ------------------------------------------------------
    if (digitalRead(Niveau_Auffangbecken_Max) == HIGH) {
        digitalWrite (Selbsthaltung, HIGH);
    }

    // HAND BETRIEB -----------------------------------------------------------
    if (digitalRead(Hand) == HIGH) {
        Status = 0;                                       // Handbetrieb

        if (digitalRead(Taster_Ventil_Ein) == LOW) {      // Ventil manuell e/a
            digitalWrite (Ventil_Ein, HIGH);
        } else {
            digitalWrite (Ventil_Ein, LOW);
        }
        if (digitalRead(Taster_Pumpe_Ein) == LOW) {        // Pumpe manuell e/a
            digitalWrite (Pumpe_Ein, HIGH);
        } else {
            digitalWrite (Pumpe_Ein, LOW);
        }
    } 

    // AUTOMATIK --------------------------------------------------------------
    if (digitalRead(Hand) == LOW && Status == 0) {
        Status = 1;                                            // Automatik
    }

    if (Status == 1) {
        if (digitalRead(Niveau_Auffangbecken_Max) == HIGH) {   // Becken Voll?
            if (digitalRead(Niveau_Regentonne_Max) == LOW) {   // Regentonne voll?
                Status = 4;                                    // Wasser ablassen
                Zeit_Start = millis();                         // Zeitmessung Start
            }
        }
    } 

    if (Status == 1) {
        if (digitalRead(Niveau_Auffangbecken_Max) == HIGH) {   // Becken Voll?
            if (digitalRead(Niveau_Regentonne_Max) == HIGH) {  // Regentonne nicht voll?
                Status = 3;                                    // Regentonne füllen
                Zeit_Start = millis();                         // Zeitmessung Start
            }
        }
    }

    if (Status == 1) {
        if (digitalRead(Niveau_Auffangbecken_Max) == LOW) {    // Becken nicht Voll?
            Status = 2;                                        // Kein Regen, Abschaltung
            Zeit_Start = millis();                             // Zeitmessung Start
        }
    }

    // RegenTonne füllen ------------------------------------------------------
    if (Status == 3) {
        digitalWrite (Pumpe_Ein, HIGH);                         // Pumpe Ein
        Zeit_Aktuell = millis();                                // Zeitmessung
        if ((Zeit_Aktuell - Zeit_Start >= Pumpe_Zeit_in_ms) or  // Zeit abgelaufen?
            digitalRead(Niveau_Regentonne_Max) == LOW) {        // Regentonne voll?
                Status = 1;                                     // Status zurücksetzen
                digitalWrite (Pumpe_Ein, LOW);                  // Pumpe Aus
            }
    }

    // Wasser ablassen --------------------------------------------------------
    if (Status == 4) {
        digitalWrite (Ventil_Ein, HIGH);                        // Ventil öffnen
        Zeit_Aktuell = millis();                                // Zeitmessung
        if (Zeit_Aktuell - Zeit_Start >= Ventil_Zeit_in_ms) {   // Zeit abgelaufen?
              Status = 1;                                       // Status zurücksetzen
              digitalWrite (Ventil_Ein, LOW);                   // Ventil schließen
        }
    }

    // Automatische Abschaltung (Selbsthaltung AUS) ---------------------------
    if (Status == 2) {
        Zeit_Aktuell = millis();                                // Zeitmessung
        if (Zeit_Aktuell - Zeit_Start >= Ruhezeit) {            // Zeit abgelaufen?
              digitalWrite (Selbsthaltung, LOW);                // Selbsthaltung Aus
        }
        if (digitalRead(Niveau_Auffangbecken_Max) == HIGH) {    // Es regnet wieder
            Status = 1;
        }
    }    
    LED_Anzeige ();                                             // LED Anzeige
}       
// ***************************************************************************************

Testschaltung

Kurzvideo

Weitere Themen: