Wieder bewässerung

Hallo zusammen
Mein erster Post, und Neuling in Sache programmieren.
Ich habe auf meinem Balkon im Einsatz eine Bewässerungsanlage vom Gardena. Eigentlich funktioniert alles gut, aber letzte Sommer hat gezeigt das reine Zeitsteuerung reicht nicht. Aus diesem Grund habe mir vorgenommen Arduino arbeiten lassen. Da die Blumen hängen an den wenden sind die Töpfe klein, was erfordert öfter in kleinen Mengen gissen.
Im Forum habe ich ein paar Ideen zusammengebracht, und das Pumpen funktioniert (die Zeiten tue ich später anpassen).
Ich will bei 1-2 pflanzen die Feuchtigkeit kontrollieren und mit jeweils eine minipumpe bewässern.
Was mir fehlt ist eine Status Information solange die Schleife lauft: soll immer nur eine Pumpe laufen. Oder kann andere-bessere Lösung hier?
Andere Frage: kann diese schleife, (oder andere-bessere Lösung) als Unterprogramm verwendet sein um alle pflanzen (muss für jeder pflanze andere Sensor und Pumpe deklariert werden) in der Reihe mit Wasser versorgen?
Habe bei der Suche nichts Ähnliches gefunden, oder vielleicht nicht die richtigen suchanfragen gestellt.

Für ein paar Tipps / links wäre ich sehr dankbar. Gruß

test.txt (1.36 KB)

Wenn Du in der IDE Deinen Sketch mittels +t formatierst, siehst Du schon zu viele Klammern:

/*Da die Töpfe recht klein sind, soll die Pumpe in ein paar kurzen Zyklen,
  gefolgt von Pausen laufen, um das Wasser überlauf verhindern*/

unsigned long time0 = 0;                                              // Variable Laufzeit Pumpe
unsigned long time1 = 0;                                              // Variable Pausezeit Pumpe
int i = 0;                                                            // Variable Zyklen
bool pumpstate = false;                                               // Variable Pumpenstatus
#define    pumpe1ON   500UL                                           // Pumpe Laufzeit
#define    pumpe1OFF 1000UL                                           // Pumpe Pausezeit
const int pump = 13;                                                  // Ausgang Pumpe

void setup() {
  pinMode(pump, OUTPUT);
}

void loop() {
}
while (i < 5) {
  if (!digitalRead(pump) && millis() - time0 >= pumpe1ON ) {
    time1 = millis();
    pumpstate = !pumpstate;
    digitalWrite(pump, pumpstate);
  }
  if (digitalRead(pump) && millis() - time1 >= pumpe1OFF ) {
    time0 = millis();
    pumpstate = !pumpstate;
    pump1();
  }
}
}
void pump1() {
  digitalWrite(pump, pumpstate);
  i++;
}

Bei den Deklarationen hast Du schon eine Menge richtig gemacht, nur frage ich mich, ob i negatriv werden kann.
Da i < 5 reicht auch byte. Also byte i = 0;.

void loop() {
  while (i < 5) {

Eine Schleife in der Schleife, das ist ein Schleifchen zu viel.

Danke für die hinweise. Die Klammer sind verblieben vom einem versuch der Status für die gesamte schleife zu ermitteln. Die habe ich übersehen- „Mea culpa“.
Zu "i": ich bin beim lesen, und versuche zu verstehen, „Arduino-Referenz“. Da habe ich auch bedenken ob alle Parameter und Variablen müssen mit so großer Auflösung deklariert sein. Ich bastle aber grade meinen Sketch aus mehreren zusammen und in erste Linie will erreichen das der lauft, erst danach wird nach neuern Erkenntnissen nachgebessert.
Schleife in schleife: wie ich geschrieben habe, wenn möglich, diesen Teil als Unterprogramm verwenden. Dann wird „loop“ ersetzt. Jetzt will IDE außer loop nichts anderes haben (nicht deklariert).

Ich glaube die Reihenfolge ist falsch. Besser wäre es, erst die Erkenntnisse zu sammeln. Dann wird das Laufen einfacher.

Gruß Tommy

oldmann:
Jetzt will IDE außer loop nichts anderes haben (nicht deklariert).

loop ist sozusagen das Hauptprogramm. setup und loop werden gebraucht.

Tommy56

Will nicht wiedersprechen, aber meisten: Theorie + Praxis = mehr in die Birne.
So oder so, die Theorie hat Vorfahrt!

Nicht zum Trotz: meine Probleme verbleiben.
Suchanfragen wie „Schleife Status“ oder „Unterprogramm Ein, Ausgänge zuweisen“ bringen keine brauchbaren Ergebnisse.

Für ein paar Tipps wäre ich sehr dankbar. Gruß

Es gibt in der IDE viele Beispiele für den Einstieg, mit denen Du lernen und verstehen kannst.
In den meisten Fällen ist ein Einsteigerset (z.B. von Funduino) gut geeignet, um erst mal die Grundkenntnisse zu erwerben.

Ansonsten zeige uns doch mal, was Du schon hast.

Setze Deinen Code bitte in Codetags (</>-Button oben links im Forumseditor oder [code] davor und [/code] dahinter ohne *).

Gruß Tommy

oldmann:
Für ein paar Tipps wäre ich sehr dankbar. Gruß

Fange doch mal mit einem Blumenfeld an. Da Du ganz verschiedene Blumen hast, nutzt Du eine Struktur von Blumen:

struct Blumen                            // Struktur mit Konstanten, Variablen und Methoden
{
  const byte messPin, relaisPin;
  const int trockenWert;
  const unsigned long messIntervall, giessIntervall, nachgiessenIntervall;
  unsigned int messwert;
  unsigned long vorhin, intervall;
  byte schritt;
};

Blumen blumen[]  // Ein Feld der Struktur Blumen
{ // messPin, relaisPin, trockenWert, messIntervall, giessIntervall, nachgiessenIntervall
  {A0, 2, 200, 3000, 500, 5000},
  {A1, 3, 250, 2500, 500, 5000},
  {A2, 4, 250, 2000, 250, 3000}
};

So mag der Compiler das noch nicht, dient nur zum Sortieren der Gedanken.

In der Struktur gibt es mehr Werte, als im Feld festgelegt werden. Diese Werte wären alle 0, könnte man alle in das Feld schreiben, verschwendet aber nur Platz. Nach einem Vorschlag von combie kann man diese auch in einem Constructor1) initialisieren:

struct Blumen                            // Struktur mit Konstanten, Variablen und Methoden
{ Blumen(const byte messPin, const byte relaisPin, const unsigned int trockenWert, const unsigned long messIntervall, const unsigned long giessIntervall, const unsigned long nachgiessenIntervall):
    messPin(messPin), relaisPin(relaisPin), trockenWert(trockenWert), messIntervall(messIntervall), giessIntervall(giessIntervall), nachgiessenIntervall(nachgiessenIntervall), messwert(0), vorhin(0), intervall(0), schritt(0) {}

  const byte messPin, relaisPin;
  const int trockenWert;
  const unsigned long messIntervall, giessIntervall, nachgiessenIntervall;
  unsigned int messwert;
  unsigned long vorhin, intervall;
  byte schritt;
};

Blumen blumen[]  // Ein Feld der Struktur Blumen
{ // messPin, relaisPin, trockenWert, messIntervall, giessIntervall, nachgiessenIntervall
  {A0, 2, 200, 3000, 500, 5000},
  {A1, 3, 250, 2500, 500, 5000},
  {A2, 4, 250, 2000, 250, 3000}
};

void setup() {}

void loop() {}

Schon ist auch der Compiler einverstanden.

Wenn Du auf der OOP-Schiene weitermachen möchtest, benötigst Du nur noch eine Initialisierungs-Methode und eine Methode, die die Arbeit macht:

unsigned long jetzt;                     // Variable für den aktuellen Zeitpunkt

struct Blumen                            // Struktur mit Konstanten, Variablen und Methoden
{ Blumen(const byte messPin, const byte relaisPin, const unsigned int trockenWert, const unsigned long messIntervall, const unsigned long giessIntervall, const unsigned long nachgiessenIntervall):
    messPin(messPin), relaisPin(relaisPin), trockenWert(trockenWert), messIntervall(messIntervall), giessIntervall(giessIntervall), nachgiessenIntervall(nachgiessenIntervall), messwert(0), vorhin(0), intervall(0), schritt(0) {}

  void init()
  { pinMode(relaisPin, OUTPUT);
  }

  void run()
  {  // hier die Funktionalität einfügen!
  }

  const byte messPin, relaisPin;
  const int trockenWert;
  const unsigned long messIntervall, giessIntervall, nachgiessenIntervall;
  unsigned int messwert;
  unsigned long vorhin, intervall;
  byte schritt;
};

Blumen blumen[]  // Ein Feld der Struktur Blumen
{ // messPin, relaisPin, trockenWert, messIntervall, giessIntervall, nachgiessenIntervall
  {A0, 2, 200, 3000, 500, 5000},
  {A1, 3, 250, 2500, 500, 5000},
  {A2, 4, 250, 2000, 250, 3000}
};

void setup()
{ for (Blumen &b : blumen) b.init();  // alle Feldelemente werden nacheinender mit der Methode init abgearbeitet
}

void loop()
{ jetzt = millis();
  for (Blumen &b : blumen) b.run();  // alle Feldelemente werden nacheinender mit der Methode run abgearbeitet
}

Dies soll eine Anregung sein, die Du selbst ausgestaltest. Möglicherweise benötigt man noch andere Werte oder welche von meinen sind überflüssig. Ich habe keinen grünen Daumen :grin:


Anm.:

  1. Bitte im großen C++-Buch nachlesen!

OK
Ich kann zeigen was habe ich bei anderen gefunden und versucht für meine Ideen anpassen.

code

/*  Analog Eingänge A0-Lichtsensor, A1-Feuchtigkeit Sensor Pflanze 1, A2-Feuchtigkeit Sensor Pflanze 2
   Digital Ausgänge D2-Pumpe Pflanze 1, D3-Pumpe Pflanze 2
   Der betrieb soll in die Nacht eingestellt sein.
   Da die pflanzen Töpfe klein sind, soll die Pumpe in ein paar kurzen Zyklen, gefolgt von pausen laufen,
um das Wasser auslaufen verhindern. Weiter soll immer nur eine Pumpe laufen. 
Nicht geprüft weil IDE sagt "'pumpA' was not declared in this scope", als ausschnitt geht */

unsigned long int time0 = 0;                                       // Merker für "Nachtbetrieb"
unsigned long int time1 = 0;                                       // Merker Laufzeit Pumpe 1
unsigned long int time2 = 0;                                       // Merker Pausezeit Pumpe 1
unsigned long int time3 = 0;                                       // Merker Laufzeit Pumpe 2
unsigned long int time4 = 0;                                       // Merker Pausezeit Pumpe 2
int i = 0;                                                         // Variable Zyklen Pumpe 1
int j = 0;                                                         // Variable Zyklen Pumpe 2
int light = A0;                                                    // Lichtsensor am eingang A0
int moist0 = A1;                                                   // Feuchte Pflanze 1
int moist1 = A2;                                                   // Feuchte Pflanze 2
int night = 0;                                                     // Variable für Lichtsensor
int moisture0 = 0;                                                 // Variable Feuchte Pflanze 1
int moisture1 = 0;                                                 // Variable Feuchte Pflanze 2
const int pump1 = 2;                                               // Ausgang Pumpe Pflanze 1
const int pump2 = 3;                                               // Ausgang Pumpe Pflanze 2

#define    pumpON      500UL                                       // Pumpe Laufzeit
#define    pumpOFF    1000UL                                       // Pumpe Pausezeit
#define    nightbreak 1000UL                                       // Interval für nachprüfen Tag-Nacht

bool pumpstate0 = true;                                            // Variable Pumpenstatus Pflanze 1
bool pumpstate1 = true;                                            // Variable Pumpenstatus Pflanze 2
bool waterstate = false;                                           // Variable "Gissen"-Status - true solange lauft eine Pumpe-Schleife
                                                                  // Hier fehlt die lösung

void setup() {
 pinMode(2, OUTPUT);
 pinMode(3, OUTPUT);
}

void loop() {
 night = analogRead(light);
 moisture0 = analogRead(moist0);
 moisture1 = analogRead(moist1);
 static byte step = 0;
 switch (step) {
   case 0:
     if (night < 600) {                                           // Bei Nacht
       time0 = millis();
       step = 3;
     }
     else {
       step = 1;
     }
     break;
   case 1:                                                        // Pflanze 1
     if ((waterstate = true) && (moisture0 < 400)) {
       while (i < 5) {
         if (!digitalRead(pump1) && millis() - time1 >= pumpON ) {
           time2 = millis();
           pumpstate0 = !pumpstate0;
           digitalWrite(pump1, pumpstate0);
         }
         if (digitalRead(pump1) && millis() - time2 >= pumpOFF ) {
           time1 = millis();
           pumpstate0 = !pumpstate0;
           pumpA();
         }
       }
     }
     else {
       step = 2;
     }
     break;
   case 2:                                                        // Pflanze 2
     if ((waterstate = true) && (moisture1 < 400)) {
       while (j < 5) {
         if (!digitalRead(pump2) && millis() - time3 >= pumpON ) {
           time4 = millis();
           pumpstate1 = !pumpstate1;
           digitalWrite(pump2, pumpstate1);
         }
         if (digitalRead(pump2) && millis() - time4 >= pumpOFF ) {
           time3 = millis();
           pumpstate1 = !pumpstate1;
           pumpB();
         }
       }
     }
     else {
       step = 1;
     }
     break;
   case 5:                                                   // Nachtbetrieb
     if (millis() - time0 > nightbreak) {
       step = 0;
     }
     break;
 }

 void pumpA() {
   digitalWrite(pump1, pumpstate0);
   i++;
 }

 void pumpB() {
   digitalWrite(pump2, pumpstate1);
   j++;
 }

/code

agmue

Respekt und vielen Dank für die Anregungen
Wie ich schon gesagt habe, verwende ich auf meinem Balkon eine Anlage die ist bis jetzt mit eine mechanische Zeitschaltuhr gesteuert. Man kann eine elektronische verwenden, man kann Arduino verwenden, man kann…
Ich will mehr haben aber nicht unbedingt alles.
Soll sich der Steuerung relativ einfach realisieren lassen, wird gerne gemacht. Wenn nicht: das Leben geht weiter

Dein Sketch ist fast nicht zu lesen. In einem Mobilgerät überhaupt nicht.

Wenn du möchtest, dass viele deinen Sketch lesen und dir helfen, dann verwende bitte Code-Tags, so wie du auch schon gebeten wurdest.

Verwende dazu die Schaltfläche </> oben links im Editorfenster.
Das kannst du auch nachträglich machen.
Dazu den Sketch markieren und die Schaltfläche klicken.

Damit wird dieser für alle besser lesbar.

Wo gibt zu lesen „Foren-Referenz“??? :o

oldmann:
Wo gibt zu lesen „Foren-Referenz“??? :o

Hier: How to use this forum - please read - Deutsch - Arduino Forum

Danke :-[

Da scheint was nicht zusammen zu passen:

      step = 3;
...
   case 5:                                                   // Nachtbetrieb

oldmann:
Ich will mehr haben aber nicht unbedingt alles.
Soll sich der Steuerung relativ einfach realisieren lassen, wird gerne gemacht. Wenn nicht: das Leben geht weiter

Wie diese Sätze mit meinem Beitrag in Zusammenhang stehen, kann ich zwar nicht erkennen, aber ich stimme Dir zu.

Das ist ein Beweis: ich arbeite daran ;D

Ich habe mich als Neuling deklarieret, aber die Elektronik Grundlagen und Boolesche Algebra sind für mich keine fremdbegriffe. Neu ist für mich einen Sketch schreiben, die Programmiersprache ein bisschen verstehen. Ich lese in diesem Forum seit gewissen Zeit regelmäßig, und bewundere Deine und der anderen, Hilfsbereitschaft und wissen. Was ich gemeint habe (nicht böse sein), das war für mich eine Nummer zu groß. :blush:

Nach einem Vorschlag von combie kann man diese auch in einem Constructor1) initialisieren:

Danke für die Blumen!

Der Testballon hätte von mir sein können, so in etwa...

Denn so teste ich die Lernbereitschaft der Fragenden.
Die gierigen, hungrigen, trennen sich so von jenen, welche sich selber (willkürliche) Grenzen auferlegen.

Dass jeder Grenzen hat, und dass lernen ein (recht langer) Prozess ist, daran besteht kein Zweifel.
Aber die Bereitschaft, zu lernen, kann man so gut spüren.

Suchanfragen wie „Schleife Status" oder „Unterprogramm Ein, Ausgänge zuweisen" bringen keine brauchbaren Ergebnisse.

Kein Wunder...
Suche nach "endlicher Automat".

Ich bastle aber grade meinen Sketch aus mehreren zusammen und in erste Linie will erreichen das der lauft, erst danach wird nach neuern Erkenntnissen nachgebessert.

Aus meiner Sicht die falsche Reihenfolge!
Aber was solls, jeder ist seines Glückes Schmied.

OK bin überredet. Bis zu Frühling gibt noch bisschen Zeit. Ab in der schule. :sob:

Eure Meinung zu obigem Sketch wurde ich aber gerne kennenlernen. 8)

Hi

Du hast Es so gewollt :o
Was mir an Deinem Sketch auffällt:

  • der Sketch selber ist sparsam Kommentiert
  • Variablen wie i und j kann man in einer Schleife lokal nutzen, global wären sprechende Namen besser
  • Datentyp int - sowohl der Lichtsensor wie der Feuchtesensor werden wohl keine negativen Werte bringen, wenn der positive Wertebereich trotzdem ausreichend ist, wird's in Richtung Glaubensfrage gehen, warum kein unsigned benutzt wurde.
    . wenn der Wert wesentlich kleinere Grenzen hat, würde sich byte anbieten (0...255, ist eh unsigned)
  • in setup() beutzt Du 'magc numbers' - mir ist klar, wer '2' und '3' ist, warum benutzt Du nicht die extra dafür angelegten Variablen? Macht auch ein Anpassen einfacher
  • #define durch const Datentyp Variable=wert; ersetzen, damit der Compiler eine Chance hat, die Datentypen ebenfalls mit zu überprüfen
  • time0 ... time4 sprechende Namen geben - ich muß bei jedem Auftauchen von 'time' hochscrollen und schauen, was Das nun wieder sein soll - würde das Lesen einfacher machen
  • dem Helligkeitswert den Namen NACHT aufzubürden wäre mir wohl nicht eingefallen
  • Du setzt step auf 3, hast aber keinen Case dafür

Auf logische Fehler habe ich Deinen Sketch nicht geprüft, ist mir derzeit zu schwere Kost,

MfG

So, habt einiges geändert. Kann aber keine Garantie geben das das jetzt eine leichte Kost ist.
Pause ist um, die Schule geht weiter. :wink:

/* Analog Eingänge A0-Lichtsensor, A1-Feuchtigkeit Sensor Pflanze 1, A2-Feuchtigkeit Sensor Pflanze 2
   Digital Ausgänge D2-Pumpe Pflanze 1, D3-Pumpe Pflanze 2
   Der betrieb soll in die Nacht eingestellt sein.
   Da die pflanzen Töpfe klein sind, soll die Pumpe in ein paar kurzen Zyklen, gefolgt von pausen laufen,
   um das Wasser auslaufen verhindern. Weiter soll immer nur eine Pumpe laufen.
   Alle Zeiten und Sensorwerten für testzwecken. Korrekte werte mussen erst im betrieb ermitelt werden */


unsigned long int nightbreak = 0;                                // Merker für "Nachtbetrieb"
unsigned long int pump0ON = 0;                                   // Merker Laufzeit Pumpe 1
unsigned long int pump0OFF = 0;                                  // Merker Pausezeit Pumpe 1
unsigned long int pump1ON = 0;                                   // Merker Laufzeit Pumpe 2
unsigned long int pump1OFF = 0;                                  // Merker Pausezeit Pumpe 2
const brightness = A0;                                           // Lichtsensor am eingang A0
const moist0 = A1;                                               // Feuchte Pflanze 1
const moist1 = A2;                                               // Feuchte Pflanze 2
unsigned int bright = 0;                                         // Variable für Lichtsensor
unsigned int moisture0 = 0;                                      // Variable Feuchte Pflanze 1
unsigned int moisture1 = 0;                                      // Variable Feuchte Pflanze 2
const pump1 = 2;                                                 // Ausgang Pumpe Pflanze 1
const pump2 = 3;                                                 // Ausgang Pumpe Pflanze 2
bool pumpstate0 = true;                                          // Variable Pumpenstatus Pflanze 1
bool pumpstate1 = true;                                          // Variable Pumpenstatus Pflanze 2

void setup() {
 pinMode(pump1, OUTPUT);
 pinMode(pump2, OUTPUT);
}

void loop() {
 bright = analogRead(brightness);             
 moisture0 = analogRead(moist0);
 moisture1 = analogRead(moist1);
 static byte step = 0;
 switch (step) {
   case 0:
     if (bright < 600) {                                         // Wenn drausen dunkel ist umschalten auf nachbetrieb
       time0 = millis();
       step = 3;
     }
     else {                                                      // Bei tageslicht pflanze 1 überprüffen
       step = 1;
     }
     break;
   case 1:                                                       // Pflanze 1
    byte i = 0;
     if (moisture0 < 400) {                                      // Boden trocken
       while (i < 5) {                                           // Gissen-Pumpe 5-mal kurz laufen lasen
         if (!digitalRead(pump1) && millis() - pump0ON >= 1000 ) {
           pump0OFF = millis();
           pumpstate0 = !pumpstate0;
           digitalWrite(pump1, pumpstate0);
         }
         if (digitalRead(pump1) && millis() - pump0OFF >= 3000 ) {
           pump0ON = millis();
           pumpstate0 = !pumpstate0;
           pumpA();
         }
       }
     }
     else {                                                      // Boden feucht 
       step = 2;                                                 // Weiter zu pflanze 2
     }
     break;
   case 2:                                                       // Pflanze 2
     byte j = 0;
     if (moisture1 < 400) {                                      // Boden trocken
       while (j < 5) {                                           // Gissen-Pumpe 5-mal kurz laufen lasen
         if (!digitalRead(pump2) && millis() - pump1ON >= 1000 ) {
          pump1OFF = millis();
           pumpstate1 = !pumpstate1;
           digitalWrite(pump2, pumpstate1);
         }
         if (digitalRead(pump2) && millis() - pump1OFF >= 3000 ) {
         pump1ON = millis();
           pumpstate1 = !pumpstate1;
           pumpB();
         }
       }
     }
     else {                                                      // Boden feucht
       step = 0;                                                 // Wider an Anfang
     }
     break;
   case 3:                                                       // Nachtbetrieb
     if (millis() - nightbreak > 15000) {                        // In die Nacht je xx min die Helligkeit prüfen
       step = 0;
     }
     break;
 }

 void pumpA() {                                                  // Unterprogramm für Pumpe 1
   digitalWrite(pump1, pumpstate0);
   i++;
 }

 void pumpB() {                                                  // Unterprogramm für Pumpe 2
   digitalWrite(pump2, pumpstate1);
   j++;
 }

Hallo
Ich Hofe das jetzt lässt sich besser verdauen

// Bewaesserung Belegung der Ein und Ausgaenge
const byte brightness = A0;        // Lichtsensor am eingang A0
const byte moisture0 = A1;         // Feuchte Sensor Pflanze 1 am Eingang A1
const byte moisture1 = A2;         // Feuchte Sensor Pflanze 2 am Eingang A2
//
const byte pumpe1 = 2;             // Ausgang Pumpe Pflanze 1
const byte pumpe2 = 3;             // Ausgang Pumpe Pflanze 2
// Zeiten fuer zustaende
const int pumpeEIN = 500;          // Pumpe Laufzeit
const int pumpeAUS = 1000;         // Pumpe Pause
const int schlafen = 10000;        // Interval Helligkeit kontrolle in der nacht
// Variablen fuer Sensoren
unsigned int bright = 0;           // Licht
unsigned int moist0 = 0;           // Feuchte Pflanze 1
unsigned int moist1 = 0;           // Feuchte Pflanze 2
// Merkers fuer millis()
unsigned long int nightbreak = 0;  // Merker fuer "Nachtbetrieb" in die nacht wird je xx min der lichtsensor gelesen
unsigned long int pumpelaufen = 0; // Merker Laufzeit Pumpe
unsigned long int pumpepause = 0;  // Merker Pause Pumpe
// 
bool giessen = false;              // Solange gegossen wird - true
enum zustaende {helligkeit, pflanze1, pflanze2, pumpen, pause, nachtpause};
byte zustand = helligkeit;         // Start zustand
byte zyklenzahl = 0;               // Pumpe zyklenzahl
byte pumpewahl = 0;                // Welche Pumpe soll laufen

void setup () {
// Pins konfiguration
	pinMode(pumpe1, OUTPUT);
	pinMode(pumpe2, OUTPUT);
}

void loop () {
// Sensoren auslesen
	bright = analogRead(brightness);             
    moist0 = analogRead(moisture0);
    moist1 = analogRead(moisture1);
// Giessen false erst wann alle pumpenzyklen abgelaufen	
	if (zyklenzahl < 4) {          
    giessen = true;
    }
    else {
    giessen = false;
	zustand = helligkeit; 
    } 
	switch (zustand) {
		case helligkeit:
		    if (bright < 600) {			// Wenn drausen dunkel ist umschalten auf nachbetrieb
                nightbreak = millis();
                zustand = nachtpause;
		    }
            else {                      // Bei tageslicht feuchte pflanze 1 kontrolle 
                zustand = pflanze1;
            }
	break;
		case nachtpause:                // In der Nacht je x min helligkeit kontrolle
            if (millis() - nightbreak >= schlafen) { 
                zustand = helligkeit;
			}
	break;		
		case pflanze1:
// Pflanze troken und keine Pflanze sonst wird gegossen		
		if ((moist0 < 400) && (giessen = false)) {
			pumpewahl = pumpe1;         // Auswahl der Pumpe
			pumpelaufen = millis();
			zustand = pumpen;           // Giessen
			}
		else {
           	zustand = pflanze2;         // Pflanze feucht die zweite wird kontrolliert
			}
	break;
// Pflanze troken und keine Pflanze sonst wird gegossen
	    case pflanze2:             
		if ((moist1 < 400) && (giessen = false)) {
			pumpewahl = pumpe2;         // Auswahl der Pumpe
			pumpelaufen = millis();
			zustand = pumpen;           // Giessen
			}
		else {
           	zustand = helligkeit;        // Pflanze feucht wieder an Anfang
			}
	break;
	    case pumpen:
// Noch keine 4 Zyklen und pause abgelaufen 
        if ((zyklenzahl < 4) && (millis() - pumpepause >= pumpeAUS)) { 
            pumpelaufen = millis();
            digitalWrite(pumpewahl, HIGH);    // Pumpe einschalten
            zustand = pause;
            }
    break;
        case pause:
// Laufzeit fuer die Pumpe abgelaufen		
        if (millis() - pumpelaufen >= pumpeEIN) {
            digitalWrite(pumpewahl, LOW);     // Pumpe aus
            pumpepause = millis();
            zyklenzahl++;
            zustand = pumpen;
            }
     break;
    }
}

IDE findet keine Fehler. Ich auch ;D