Kippschalter als Input verwenden mit Kontrollleuchte

Hi liebe Arduino Fans

Ich habe eigenlich oft von nix neh Ahnung, davon aber jede Menge. Darum mach ich aber einfach mal. :innocent:
Bin also blutige Anfängerin.
So auch hier! Um was gehts?

Vor einigen Wochen kam mir die Idee eine Bewässerung mit Bodenfeuchte für meine Blumenbank. Nun stehe ich etwas auf dem Schlauch.

Aufbau:

Kurz die Sensoren sollten, die Relais schalten (6V) und die Pume.

Nun möchte ich aber einzelne Sensor-Linien bei nichtgebrauch mit einem Kippschalter auschalten. Meine Idee...

(Der Teil der noch oben Integriert wurde.)

Irgendwie haut das aber nicht so ganz hin. Einmal geschalten, reagiert es nicht mehr, oder Unvorhergesehen.

Hier noch mein versuch dem ganzen Leben einzuhauchen.
bin un jeden Tipp froh, so Quasi als Starthilfe :sunglasses:

Na ja mit viel Motivation aber keiner Ahnung wo könnte der Fehler liegen und wo soll ich mit der uche beginnen?

int SensorBF_A0 = A0;
int SensorBF_A1 = A1;
int SensorBF_A2 = A2;
int SensorBF_A3 = A3;
int SensorBF_A4 = A4;

int Wert_sensor_A0 =A0;
int Wert_sensor_A1 =A1;
int Wert_sensor_A2 =A2;
int Wert_sensor_A3 =A3;
int Wert_sensor_A4 =A4;

int VentilRelay0 =2;
int VentilRelay1 =3;
int VentilRelay2 =4;
int VentilRelay3 =5;
int VentilRelay4 =6;

int PumpRelay =7;

int SchalterA0=8;
int SchalterA1=9;
int SchalterA2=10;
int SchalterA3=11;
int SchalterA4=12;

//int Spühlen=13;


void setup() {

  Serial.begin(9600);
  pinMode(PumpRelay,OUTPUT);
  pinMode(VentilRelay0,OUTPUT);
  pinMode(VentilRelay1,OUTPUT);
  pinMode(VentilRelay2,OUTPUT);
  pinMode(VentilRelay3,OUTPUT);
  pinMode(VentilRelay4,OUTPUT);

  pinMode(SchalterA0,INPUT_PULLUP);
  pinMode(SchalterA1,INPUT_PULLUP);
  pinMode(SchalterA2,INPUT_PULLUP);
  pinMode(SchalterA3,INPUT_PULLUP);
  pinMode(SchalterA4,INPUT_PULLUP);

  //pinMode(Spühlen,INPUT);

}

void loop() {

  // Platz 1 

  if (digitalRead(SchalterA0) == false){

    Wert_sensor_A0= analogRead(SensorBF_A0 );
    Serial.print("- A0: ");
    Serial.println(Wert_sensor_A0);

    if (Wert_sensor_A0 <= 350){
      digitalWrite (VentilRelay0,LOW);
      Serial.println("Kein Wässern");
    }
    else
    {
      digitalWrite(PumpRelay,HIGH);
      Serial.println("Pumpe Ein /");
      delay(1000);
      digitalWrite(VentilRelay0,HIGH);
      Serial.print(" Ventil 1 offen /");
      delay(2000);
      digitalWrite(PumpRelay,LOW);
      digitalWrite (VentilRelay0,LOW);
      Serial.println("Pumpe Aus");
    }

  } 
  else 
  {
  Serial.println ("Kein Sensor A0 Vorhanden");
  }

  // Platz 2


  if (digitalRead(SchalterA1) ==  false){

    Wert_sensor_A1= analogRead(SensorBF_A1 );
    Serial.print("- A1: ");
    Serial.println(Wert_sensor_A1);

    if (Wert_sensor_A1 <= 350){
      digitalWrite (VentilRelay1,LOW);
      Serial.println("Kein Wässern");
    }
    else
    {
      digitalWrite(PumpRelay,HIGH);
      Serial.println("Pumpe Ein /");
      delay(1000);
      digitalWrite(VentilRelay1,HIGH);
      Serial.print(" Ventil 2 offen /");
      delay(2000);
      digitalWrite(PumpRelay,LOW);
      digitalWrite (VentilRelay1,LOW);
      Serial.println("Pumpe Aus");
    }

  }
  else 
  {
  Serial.println ("Kein Sensor A1 Vorhanden");
  }

  // Platz 3


  if (digitalRead(SchalterA2) ==  false){

    Wert_sensor_A2= analogRead(SensorBF_A2 );
    Serial.print("- A2: ");
    Serial.println(Wert_sensor_A2);

    if (Wert_sensor_A2 <= 350){
      digitalWrite (VentilRelay2,LOW);
      Serial.println("Kein Wässern");
    }
    else
    {
      digitalWrite(PumpRelay,HIGH);
      Serial.println("Pumpe Ein /");
      delay(1000);
      digitalWrite(VentilRelay2,HIGH);
      Serial.print(" Ventil 3 offen /");
      delay(2000);
      digitalWrite(PumpRelay,LOW);
      digitalWrite (VentilRelay2,LOW);
      Serial.println("Pumpe Aus");
    }

  }
  else 
  {
   Serial.println ("Kein Sensor A2 Vorhanden");
  }

  // Platz 4

  if (digitalRead(SchalterA3) ==  false){

    Wert_sensor_A3= analogRead(SensorBF_A3 );
    Serial.print("- A3: ");
    Serial.println(Wert_sensor_A3);

    if (Wert_sensor_A3 <= 350){
      digitalWrite (VentilRelay3,LOW);
      Serial.println(" Kein Wässern ");
    }
    else
    {
      digitalWrite(PumpRelay,HIGH);
      Serial.println("Pumpe Ein /");
      delay(1000);
      digitalWrite(VentilRelay3,HIGH);
      Serial.print(" Ventil 4 offen /");
      delay(2000);
      digitalWrite(PumpRelay,LOW);
      digitalWrite (VentilRelay3,LOW);
      Serial.println("Pumpe Aus");
    }

  }
  else 
  {
   Serial.println ("Kein Sensor A3 Vorhanden");
  }

  //Platz 5 


  if (digitalRead(SchalterA4) ==  false){

    Wert_sensor_A4= analogRead(SensorBF_A4 );
    Serial.print("- A4: ");
    Serial.println(Wert_sensor_A4);

    if (Wert_sensor_A4 <= 350){
      digitalWrite (VentilRelay4,LOW);
      Serial.println("Kein Wässern");
    }
    else
    {
      digitalWrite(PumpRelay,HIGH);
      Serial.println("Pumpe Ein /");
      delay(1000);
      digitalWrite(VentilRelay4,HIGH);
      Serial.print(" Ventil 5 offen /");
      delay(2000);
      digitalWrite(PumpRelay,LOW);
      digitalWrite (VentilRelay4,LOW);
      Serial.println("Pumpe Aus");
    }
  }
  else 
  {
    Serial.println ("Kein Sensor A4 Vorhanden");
  }

 Serial.println("Neuer Durchlauf");
  delay(10000);
}

Danke für eure Mühe! :kissing_heart:

E liebs Griessli
Chatzebuseli

Hallo,
wie und hast du denn die Kippschalter eingebaut ?
Ich sehe da nichts von.

Hallo chatzebuseli

Einfach die Kippschalter in die Stromversorgung für die Pumpen einbauen.

da ich keinen Brechreiz von Tinkercad bekomme, habe ich mir dein Diagramm angeschaut.
Arduino wird nicht mit 6V funktionieren. bevor du 2 Arduinos, 40 Pumpen, 80 Relays und 120 Kippschalter zusammen baust, baue 1 "Kanal": Kippschalter, MOSFET, Pumpe.

const byte ASV[5][3] = { // Analog Pin, SchalterPin, VentilPin
  {A0, 2, 8},
  {A1, 3, 9},
  {A2, 4, 10},
  {A3, 5, 11},
  {A4, 6, 12}
};
const byte PumpRelay = 7;

void setup() {
  Serial.begin(115200);
  pinMode(PumpRelay, OUTPUT);
  for (int i = 0; i < 5; i++) {
    pinMode(ASV[i][1], INPUT_PULLUP);
    pinMode(ASV[i][2], OUTPUT);
  }
}

void loop() {
  Serial.println("Neuer Durchlauf");
  for (int i = 0; i < 5; i++) {
    if (!digitalRead(ASV[i][1])) {

      int sensorWert = analogRead(ASV[i][0]);
      Serial.print("- A");
      Serial.print(i);
      Serial.print(": ");
      Serial.println(sensorWert);

      if (sensorWert <= 350) {
        digitalWrite (ASV[i][2], LOW);
        Serial.println("Kein Wässern");
      }
      else
      {
        digitalWrite(PumpRelay, HIGH);
        Serial.print("Pumpe Ein, ");
        delay(1000);
        digitalWrite(ASV[i][2], HIGH);
        Serial.print("Ventil 1 offen, ");
        delay(2000);
        digitalWrite(PumpRelay, LOW);
        digitalWrite (ASV[i][2], LOW);
        Serial.println("Pumpe Aus");
      }
    }
    else
    {
      Serial.print ("Kein Schalter ");
      Serial.print (i);
      Serial.println (" vorhanden");
    }
  }
  delay(10000);
}

Ja, kein Wunder.
Du willst z.B. A0 doppelt benutzen, einmal für den Schalter und einmal für den Sensor!?
Das wird so keiner.

Ansonsten ist deine loop ein if else Grab.
Das ist mindestens unangenehm, sicher auch Fehlerträchtig.

Der Schalter muß zwischen Eingang und Masse geschaltet sein, so daß er im Off-Zustand geschlossen ist und der Eingang Massepotential bekommt. Die LED muß weg.

Wie gesagt kannst Du den Schalter auch in Reihe zum Magnetventil schalten, sodaß dieses einfach nicht anzieht. Damit hast Du aber keine Kontrolle ob etwas abgescahltet ist.

Ich würde Dir raten lernen wie man mit Arrays arbeitet. Da kann man das mehrfache wiederholen des Auslesend er Schalter und Sensoren und ansteuern der Ventile sparen.
Auch würde ich die Logik der Bewässerung überdenken da nach dem bewässern der Sensor sicher keinen Feuchtigkeitsänderung sehen wird und somit einige Bewässerungszyklen durchlaufen bovor der Sensor endlich etwas Feuchtigkeit sieh. So reskierst Du nur eine Überschwämmung.

Grüße Uwe

[OT]
Die hatte ich ganz ohne Elektronik heute Nachmittag nach einem Platzregen bei meinen Balkonpflanzen. Die musste ich alle erst mal ausgießen, bevor sie sich beschweren, dass sie keine Wasserpflanzen sind.

Gruß Tommy

Hallo Lieber Uwe

Danke für deine Überlegungen! Du sagst also die LED muss Weg. Werd ich auf jedenfall mal probieren!

Die einzelnen Magnetventile einfach auszuschalten, ja hab ich mir auch schon überlegt. :thinking:

Ehrlich gesagt... es ist nicht dass was ich haben will, und hier kommt viel von nix Ahnung, irgendwie muss das doch gehen. Aber ja klar dennoch Danke für den Hinweis und er wird sicher als Plan B noch nicht verworfen!

Thema Array.....! Ok ich habe die Hausaufgaben verstanden! Das Kapitel mit den Array im Buch wird auf nächstes mal noch mal stdiert! :sweat_smile:

Und ja das mit der Überschwemmung, stimm ich dir zu. Da muss ich so oder so noch mal über die Logik nachdenken, da geht auch noch was. Ich dachte das ich da hald relativ lange Breaks oder so mach, um dem ganzen ne gewisse Trägheit zu geben. Auch habe ich mir überlegt die Werte z.B. erst nach dem 3 mal Trocken innerhalb 1h oder so. Noch aber keine konkreten Gedanken zur softwearseitige Lösung dazu gemacht, da der Focus erstmal auf dem Zusammenspiel der Hardwear liegt.

Aber hey vor 3 Monaten war ich gerade mal so in der Lage an der, Taschenlampe die Batterien zu wechseln! Nun krieg ich es doch schon Fertig mit einem Relais meine Werkstadt zu fluten.

Also soweit erst mal gaaaanz :heart: -lichen Dank für deine Inputs.
E ganz e liebs Griessli

Chatzebuseli

Hi
Das SchalterA0 sollte eigendlich eine Variabel sein. Die Bennenungen sind altlasten von VBA Programmierungen.... :innocent:

Wie meinst du das also? In der Realität auf dem Bord ist nur ein Draht der vom bord Weg geht. Der integer SensorBF_A0 Benennt den Port ( ok kann man streiten ob Sinvoll) und den Wert_sensor_A0 ist das eigendliche Value von dem Port also der Ausgelesene Wert.

Gerne genauere Erklährung ich verstehe nicht genau was du meinst?

E liebs Griessli
Chatzebuseli

Hi kolaha

Wow! Danke für eine Mühe !!!!
Ich erlaube mir Dir zu deinem Code noch eineige Fragen zu stellen.... denn ich möchte lernen und nicht einfach Copy -Past etwas übernehmen.

const byte ASV[5][3] = { // Analog Pin, SchalterPin, VentilPin
  {A0, 2, 8},               // 1.
  {A1, 3, 9},
  {A2, 4, 10},
  {A3, 5, 11},
  {A4, 6, 12}
}
const byte PumpRelay = 7;

void setup() {
  Serial.begin(115200);               //2.
  pinMode(PumpRelay, OUTPUT);
  for (int i = 0; i < 5; i++) {
    pinMode(ASV[i][1], INPUT_PULLUP);
    pinMode(ASV[i][2], OUTPUT);
  }
}

void loop() {
  Serial.println("Neuer Durchlauf");
  for (int i = 0; i < 5; i++) {
    if (!digitalRead(ASV[i][1])) {

      int sensorWert = analogRead(ASV[i][0]);
      Serial.print("- A");                      
      Serial.print(i);                           
      Serial.print(": ");                       
      Serial.println(Wert_sensor_A0);

      if (sensorWert <= 350) {
        digitalWrite (ASV[i][2], LOW);
        Serial.println("Kein Wässern");
      }
      else
      {
        digitalWrite(PumpRelay, HIGH);
        Serial.print("Pumpe Ein, ");
        delay(1000);
        digitalWrite(ASV[i][2], HIGH);
        Serial.print("Ventil 1 offen, ");
        delay(2000);
        digitalWrite(PumpRelay, LOW);
        digitalWrite (ASV[i][2], LOW);
        Serial.println("Pumpe Aus");
      }
    }
    else
    {
      Serial.print ("Kein Schalter ");
      Serial.print (i);
      Serial.println (" vorhanden");
    }
  }
  delay(10000);
}
  1. Gehe ich Richtig in der Ahnnahme, dass du das wie es Uwe weiter unten erklährt hat, mit einer Array gelöst hast, um fehleränfälige if-Schleifen zu vermeiden?

  2. Warum nimmst du eine so Hohen Übertragungsrate?
    Serial Print ist hier eher Datenmüll von meinem Versuchen herauszufinen wie as Programm durchlaufen wird.

P.S. Ich habe mal VBA -Projekte gemacht, dies hier aber, ist für mich absolut neu.

E liebs Griessli
Chatzebuseli

  1. Ja. eigentlich für mich würde es noch kürzer sein:
const byte ASV[3] = { // Analog Pin, SchalterPin, VentilPin
  A0, 2, 8               // 1.
}

weil Pinnummerierung ist steigend, so dass dann:

  for (int i = 0; i < 5; i++) {
    pinMode(ASV[1] + i, INPUT_PULLUP);
    pinMode(ASV[2] + i, OUTPUT);
  }
  1. 115200 ist z.Z. sehr verbreitet, 9600 ist archaik

n.g. VB ist mir auch nicht fremd

Alles gut, ich glaube ich habe da was übersehen.
Sind zu viele if und A0, das macht mich blind
z.b. verstehe ich nicht warum ein Sensor, ein Schalter und ein Ventil A0 heißen soll.

Tja.....

Das ist ein ganz wichtiger Schritt Richtung Übersichtlichkeit.

const byte ASV[5][3] = { // Analog Pin, SchalterPin, VentilPin
  {A0, 2, 8},               // 1.
  {A1, 3, 9},
  {A2, 4, 10},
  {A3, 5, 11},
  {A4, 6, 12}
}

Allerdings:
Das ist so nicht wirklich in Ordnung.
Da sich ja die Bedeutung der einzelnen Pins unterscheidet.

aber in Gegensatz lässt sich einfacher neue Zeile/n einfügen oder löschen

Naja....

Umgebaut, aber Funktion ungetestet

class PumpDingen
{
  private:
    const byte sensor;
    const byte schalter;
    const byte ventil;

  public:
    PumpDingen(const byte sensor, const byte schalter, const byte ventil): sensor(sensor), schalter(schalter), ventil(ventil) {}

    void init()
    {
      pinMode(schalter, INPUT_PULLUP);
      pinMode(ventil,   OUTPUT);
    }
    void run(const byte pumpe)
    {
      if (!digitalRead(schalter))
      {

        int sensorWert = analogRead(sensor);
        Serial.print(sensor);
        Serial.print(": ");
        Serial.println(sensorWert);

        if (sensorWert <= 350)
        {
          digitalWrite (ventil, LOW);
          Serial.println("Kein Wässern");
        }
        else
        {
          digitalWrite(pumpe, HIGH);
          Serial.print("Pumpe Ein, ");
          delay(1000);
          digitalWrite(ventil, HIGH);
          Serial.print("Ventil  offen, ");
          delay(2000);
          digitalWrite(pumpe, LOW);
          digitalWrite (ventil, LOW);
          Serial.println("Pumpe Aus");
        }
      }
      else
      {
        Serial.print ("Kein Schalter an Pin ");
        Serial.print (schalter);
        Serial.println (" vorhanden");
      }
    }
};

PumpDingen pumpDingen[]
{
  // Analog Pin, SchalterPin, VentilPin
  {A0, 2, 8},
  {A1, 3, 9},
  {A2, 4, 10},
  {A3, 5, 11},
  {A4, 6, 12},
};

const byte PumpRelay = 7;

void setup()
{
  Serial.begin(115200);
  pinMode(PumpRelay, OUTPUT);
  for (PumpDingen &p : pumpDingen) p.init();
}

void loop()
{
  Serial.println("Neuer Durchlauf");
  for (PumpDingen &p : pumpDingen) p.run(PumpRelay);
  delay(10000);
}
1 Like
const byte ASV[5][3] = { // Analog Pin, SchalterPin, VentilPin
  {A0, 2, 8},
  {A1, 3, 9},
  {A2, 4, 10},
  {A3, 5, 11},
  {A4, 6, 12}
};
const byte PumpRelay = 7;

void setup() {
  pinMode(PumpRelay, OUTPUT);
  for (int i = 0; i < 5; i++) {
    pinMode(ASV[i][1], INPUT_PULLUP);
    pinMode(ASV[i][2], OUTPUT);
  }
}

void loop() {
  for (int i = 0; i < 5; i++) {
    if (!digitalRead(ASV[i][1])) {
      int sensorWert = analogRead(ASV[i][0]);
      if (sensorWert <= 350)digitalWrite (ASV[i][2], LOW);
      else {
        digitalWrite(PumpRelay, HIGH);
        delay(1000);
        digitalWrite(ASV[i][2], HIGH);
        delay(2000);
        digitalWrite(PumpRelay, LOW);
        digitalWrite (ASV[i][2], LOW);
      }
    }
  }
  delay(10000);
}

in diesem Fall dreht die Pumpe umsonst

Lieber combie, Lieber kolaha

Erst mal gaaaaanz :heart:-lichen Dank für eure Mühe.
Das schaue ich mir diese Codes liebend gerne die Tage ganz genau an, heute ist schon Spät.
Ich glaube es im Grunde auch verstanden zu haben. Hausaufgaben habt Ihr mir auf jedenfall gegeben. :wink:

E liebs Griessli
Chatzebuseli

Nichts anderes erwarte ich von dir.

:japanese_ogre: :japanese_ogre: :japanese_ogre:

Kann ich nicht nachvollziehen, das Intialisieren einer zusätzlichen Instanz geht auch mit einer Struktur/Klasse "einfach" mit einer Zeile.

Aber viel mehr: nimmt man eine Struktur / Klasse ist die Verwendung jeder einzelnen Variable eindeutig.

Bei mehrdimensionalen Arrays muss man sich genau merken welche Dimension für welche Variable verwendet (was ja per se schon wieder gegen ein mehrdimensionales Array spricht).

digitalWrite(ASV[i][2], HIGH);

Dimension 2 ist was? 1,2, 3 ... aja, der VentilPin gem. Kommentar.

Bei Strukturen/Klasen kommen keine Missverständnisse auf:

digitalWrite(ventil, HIGH);

ventil. ok es ist der Pin vom Ventil.

Ich finde sowas ist leichter lesbar und künftig auch leichter wartbar.

1 Like

Hi Leute...

Also ich hab mich da noch mal ran gesetzt.
Irgendwie bin ich nicht wirklich weiter gekommen!

Was hab ich gemacht!

Erst mal hab ich Uwe's Rat befolgt und die LED aus dem Stromkreis des Kippschalters wieder rausgeholt. Dann den Kippschlter direkt mit Ground verbunden.
Warum darf genau darf da denn keine LED dazwischen sitzen? Wird da dann quasi zuviel Strom "verbrannt"um den Eingang noch HIGH zu schalten? Verstehe ich das Richtig?

Das an allen 5 Sensorreihen.
Das mal zur Hardwear.

Das mit der Softwear ging komplett schief!!!
Egal wie der Schalter steht.
Auffallend ist das nix passiert.

Lasse ich allerdings, das ganze ohne die Schalter laufen mit unten stehendem Code, wird schön eines nach den Anderen durchgeschalten.

Und ja es funktioniert sogar mit angebautem Ventil und laufender Pumpe die auch Wasser fördert. Dabei ist mir aber aufgefallen das das Ventil nur sauber schaltet wenn der Arduino zusätzlich am PC hängt.

Code ohne Schalter für einzelne Sensor - Reien. Der zwar noch immer genau so Stümperhaft ist, aber macht was er soll.

int SensorBF_A0 = A0;
int SensorBF_A1 = A1;
int SensorBF_A2 = A2;
int SensorBF_A3 = A3;
int SensorBF_A4 = A4;

int Wert_sensor_A0 =A0;
int Wert_sensor_A1 =A1;
int Wert_sensor_A2 =A2;
int Wert_sensor_A3 =A3;
int Wert_sensor_A4 =A4;

int VentilRelay0 =2;
int VentilRelay1 =3;
int VentilRelay2 =4;
int VentilRelay3 =5;
int VentilRelay4 =6;

int PumpRelay =7;

int SchalterA0=8;
int SchalterA1=9;
int SchalterA2=10;
int SchalterA3=11;
int SchalterA4=12;

//int Spühlen=13;


void setup() {

  Serial.begin(9600);
  pinMode(PumpRelay,OUTPUT);
  pinMode(VentilRelay0,OUTPUT);
  pinMode(VentilRelay1,OUTPUT);
  pinMode(VentilRelay2,OUTPUT);
  pinMode(VentilRelay3,OUTPUT);
  pinMode(VentilRelay4,OUTPUT);

 

  

}

void loop() {

  // Platz 1 

 

    Wert_sensor_A0= analogRead(SensorBF_A0 );
    Serial.print("- A0: ");
    Serial.println(Wert_sensor_A0);

    if (Wert_sensor_A0 <= 350){
      digitalWrite (VentilRelay0,LOW);
      Serial.println("Kein Wässern");
    }
    else
    {
      digitalWrite(PumpRelay,HIGH);
      Serial.println("Pumpe Ein /");
      delay(1000);
      digitalWrite(VentilRelay0,HIGH);
      Serial.print(" Ventil 1 offen /");
      delay(2000);
      digitalWrite(PumpRelay,LOW);
      digitalWrite (VentilRelay0,LOW);
      Serial.println("Pumpe Aus");
    }

 

  // Platz 2


  

    Wert_sensor_A1= analogRead(SensorBF_A1 );
    Serial.print("- A1: ");
    Serial.println(Wert_sensor_A1);

    if (Wert_sensor_A1 <= 350){
      digitalWrite (VentilRelay1,LOW);
      Serial.println("Kein Wässern");
    }
    else
    {
      digitalWrite(PumpRelay,HIGH);
      Serial.println("Pumpe Ein /");
      delay(1000);
      digitalWrite(VentilRelay1,HIGH);
      Serial.print(" Ventil 2 offen /");
      delay(2000);
      digitalWrite(PumpRelay,LOW);
      digitalWrite (VentilRelay1,LOW);
      Serial.println("Pumpe Aus");
    }

  

  // Platz 3


  

    Wert_sensor_A2= analogRead(SensorBF_A2 );
    Serial.print("- A2: ");
    Serial.println(Wert_sensor_A2);

    if (Wert_sensor_A2 <= 350){
      digitalWrite (VentilRelay2,LOW);
      Serial.println("Kein Wässern");
    }
    else
    {
      digitalWrite(PumpRelay,HIGH);
      Serial.println("Pumpe Ein /");
      delay(1000);
      digitalWrite(VentilRelay2,HIGH);
      Serial.print(" Ventil 3 offen /");
      delay(2000);
      digitalWrite(PumpRelay,LOW);
      digitalWrite (VentilRelay2,LOW);
      Serial.println("Pumpe Aus");
    }

 

  // Platz 4

 

    Wert_sensor_A3= analogRead(SensorBF_A3 );
    Serial.print("- A3: ");
    Serial.println(Wert_sensor_A3);

    if (Wert_sensor_A3 <= 350){
      digitalWrite (VentilRelay3,LOW);
      Serial.println(" Kein Wässern ");
    }
    else
    {
      digitalWrite(PumpRelay,HIGH);
      Serial.println("Pumpe Ein /");
      delay(1000);
      digitalWrite(VentilRelay3,HIGH);
      Serial.print(" Ventil 4 offen /");
      delay(2000);
      digitalWrite(PumpRelay,LOW);
      digitalWrite (VentilRelay3,LOW);
      Serial.println("Pumpe Aus");
    }

  
  //Platz 5 


  

    Wert_sensor_A4= analogRead(SensorBF_A4 );
    Serial.print("- A4: ");
    Serial.println(Wert_sensor_A4);

    if (Wert_sensor_A4 <= 350){
      digitalWrite (VentilRelay4,LOW);
      Serial.println("Kein Wässern");
    }
    else
    {
      digitalWrite(PumpRelay,HIGH);
      Serial.println("Pumpe Ein /");
      delay(1000);
      digitalWrite(VentilRelay4,HIGH);
      Serial.print(" Ventil 5 offen /");
      delay(2000);
      digitalWrite(PumpRelay,LOW);
      digitalWrite (VentilRelay4,LOW);
      Serial.println("Pumpe Aus");
    }
  

 Serial.println("Neuer Durchlauf");
 Serial.println();
  delay(10000);
}

Morgen werde ich mal auf einem Breadbord nochmal einfach eine einzelne Sensorlinie aufbauen. Also Quasi alles noch mal von vorne.

Natürlich darf da eine LED sitzen, welche mit dem Schalter angeht.
Aber nicht irgendwie "dazwischen"