Bewässerungssteuerung für Reitplatz

International Deutsch
1

Hallo zusammen,
ich bin leider komplett neu und beschäftige mich das erste mal so wirklich mit Arduino.

Ich möchte eine Beregnungsanlage für einen Reitplatz ansteuern. Die Ansteuerung der Pumpe sowie der einzelnen von ingesamt 6 Magnetventilen werde ich mit Relais umsetzten.

Meine Hauptfrage liegt bei der Programmierung.
Ich habe 8 verschiedene Taster (einer für Start, einer für Stopp und 6 Stück für die einzelnen Sprinkler)
gerne würde ich zunächst die Auswahl treffen, welche der Sprinkler denn überhaupt angesteuert werden sollen. Nach Betätigung der Start-Taste soll dann der zuerst angewählt angehen und nach einer gewissen Zeit wieder ausgehen, bevor dann der nächste gewählt für eine gewisse Zeit läuft. Wird die Stopp-Taste gedrückt, so wird die Bewässerung sofort unterbrochen.
Bis jetzt ist mein Ansatz für jeden Sprinkler eine eigene Funktion zu schreiben, in welcher der Output HIGH gesetzt wird und nach einem Delay wieder auf LOW.

Wie realisiere ich am Besten das nacheinander starten (Aufrufen) der einzelnen Funktionen bei Drücken des Start Button?

Vielen Dank schonmal im Voraus

2

Im englischen Teil des Forum müssen die Beiträge und Diskussionen in englischer Sprache verfasst werden. Deswegen wurde diese Diskussion in den deutschen Teil des Forums verschoben.

mfg ein Moderator.

3

Schrittkette.
Einstieg: Auswahl der Sprinkler - wird solange wiederholt bis
a) Ausstieg: Starttaste oder Stoptaste
Wenn Start ausgelöst nur
b) Ausstieg: Stoptaste

4

Hallo,
na ja Du musst Dir halt merken das Du schon mal einen der 6 Taster gedrückt hast, Und das dann verriegeln das nicht noch ein zweiter dazu kommt. Wenn Du dann Start drückst weist du welches Ventil geschaltete werden soll. Mit Stop schaltest Du den Merker wieder aus.
Man könnte auch eine numerische Variable auf einen Wert von 1-6 setzen und das nutzen. Dann könnte man eventuell alles in einer Schleife mit Arrays für die Taster, Ventile und dem index 1-6 verarbeiten.
Taster[i]...
Ventil[i]..

Möglichkeiten gibt es reichlich.
Heinz

Nachtrag Soll der Wechsel automatisch erfolgen oder immer nur ein Ventil und dann neue manuelle Auswahl und neu starten ?

5

das Programm soll automatisch laufen. Ich wähle die Reihenfolge aus und drücke Start dann öffnet das eine Ventil für eine gewisse Zeit schaltet ab und dann wird das nächste automatisch geöffnet.

6

Was machen dann die Ventiltaster? Wählen die das erste auszulösende Ventil aus, dann geht es der Reihe nach weiter, oder ist das eine manuelle Eingriffmöglichkeit, um den Abklauf der Reihenfolge zu unterbrechen und auf eine andere Düse zu schalten?

7

Ich habe es so verstanden:

Du drückst die Wahltasten 3,4,2 und danach Start.
Dann werden die Bereiche 3,4,2 in der Reihenfolge bewässert.

Gruß Tommy

8

Aah.. ok, dann ist es ja einfach.
Ein Array wenn die Bewässerungszeiten gleich bleiben.
Ansonsten, entweder zwei Arrays mit Bezug auf den Sprinkler udn die Auswahl, oder ne Structur mit Sprinkler und Zeit als Elemente und die als Array.
Ablauf wie gehabt Schrittkette. Füllen mit Abbruchfunktion Start/Stop und bei Schritt Start nur Abbruch durch Schritt Stop.

Nichts was unmöglich ist...

9

Welchen?

Damit es mal irgendwie losgeht, habe ich ein Programm entworfen, das nach Drücken eines Startknopfes nacheinander sechs Ausgänge für drei Sekunden schaltet. Die Daten für die Pinnummer und die individuelle Zeit stehen in einer Datenstruktur. Getestet mit UNO:

struct Sprinkler
{
  const byte relaisPin;
  const uint32_t beregnungsZeit;  // in Minuten

  void initialisierung()
  {
    digitalWrite(relaisPin, HIGH);  // Relais schalten häufig bei LOW
    pinMode(relaisPin, OUTPUT);
  }
};

const byte anzahlSprinkler = 6;
Sprinkler sprinkler[anzahlSprinkler] =
{ // pin, zeit
  { 8, 3000},
  { 9, 3000},
  {10, 3000},
  {11, 3000},
  {12, 3000},
  {13, 3000}
};

const byte startPin = A0;
const byte stoppPin = A1;

void setup()
{
  Serial.begin(115200);
  delay(500);
  Serial.println("\nStart");
  pinMode(startPin, INPUT_PULLUP);
  pinMode(stoppPin, INPUT_PULLUP);
  for ( Sprinkler s : sprinkler ) s.initialisierung();
}


void loop()
{
  enum Schritt : byte {WARTEN, BEWAESSERN};
  static byte schritt = Schritt::WARTEN;
  switch (schritt)
  {
    case Schritt::WARTEN:
      if (!digitalRead(startPin))
      {
        Serial.println("Anfang");
        bewaessern(true);
        schritt = Schritt::BEWAESSERN;
      }
      break;
    case Schritt::BEWAESSERN:
      if (!bewaessern(false))
      {
        Serial.println("Fertig");
        schritt = Schritt::WARTEN;
      }
      break;
  }
}

bool bewaessern(bool anfang)
{
  uint32_t jetzt = millis();  // ms
  static uint32_t vorhin = jetzt;
  bool aktiv = true;
  bool stopp = !digitalRead(stoppPin);
  static byte abschnitt = 0;
  if (anfang)
  {
    abschnitt = 0;
    vorhin = jetzt;
  }
  if (jetzt - vorhin >= sprinkler[abschnitt].beregnungsZeit || stopp)
  {
    vorhin = jetzt;
    digitalWrite(sprinkler[abschnitt].relaisPin, HIGH);
    abschnitt++;
    if (abschnitt >= anzahlSprinkler || stopp)
    {
      aktiv = false;
      abschnitt = 0;
    }
  } else {
    digitalWrite(sprinkler[abschnitt].relaisPin, LOW);
  }
  return aktiv;
}

Ein UNO dürfte hinsichtlich der Pins schon etwas knapp werden, also sollte ein Portexpander oder ein Mega2560 in Erwägung gezogen werden. Auch wird der Bediener möglicherweise eine Rückmeldung in Form von LEDs oder einem Display benötigen. Sollen die Bewässerungszeiten flexibel einstellbar sein?

10

An einem Analogpin sind 8 Taster kein Problem.

11

Genausowenig wie ein Portexpander ein Problem ist, aber etwas zusätzlicher Aufwand.

Mir geht es um ein einigermaßen vernüftiges Konzept, um danach eine passende Hardware auszuwählen.

12

Genau so ist es gedacht

13

Hallo,
Dann werden die Bereiche 2,3,4 in der aufsteigender Reihenfolge bewässert. Ansonsten sehe ich ein FIFO Register als erforderlich.
Heinz

14

Und jetzt sollen wir das für dich schreiben...
... haste dir gedacht ...?

15

Er will aber 3,4,2. Geht mit einem Array problemlos.

Gruß Tommy

16

Hallo,
nach zwei bis drei grübel, grübel bin ich bei Dir.

Gruß Heinz

17

Bau ein Display dran, damit du irgendein Feedback hast, was das Ding grad tut.
Du könntest da auch einen Timer runterzählen lassen, wie lange ein Sprinkler noch läuft.

Viel Erfolg!

18

6 Taster für die Gruppen,
6 LEDs als Anzeige (EIN, wenn aktiviert, blinken, wenn gerade gewässert wird und aus, wenn deaktiviert oder schon gewässert)
6 Ventilausgänge
2 Taster für Start und Stop.

20 I/Os insgesamt.
Da reicht ein Nano gerade noch.

Nachtrag: wenn man A6 und A7 analog abfragt, kann man sie als Eingänge für 2 der Taster verwenden, dann bleiben D0/D1 noch für die serielle Schnittstelle und zum Programmieren frei.

19

Ich würde das auf einen Pin legen.
Solange wie der Taster nicht aktiviert, ist der PIN ein INPUT_PULLUP.
Und wenn die Taste ausgelöst ist, wird der LOW gezogen und ein OUTPUT.
Die LED nach 5V und der Taster nach GND.

20 
// Forensketch Regner vorprogrammieren
// https://forum.arduino.cc/t/bewasserungssteuerung-fur-reitplatz/1023384/

const byte kreise = 6;
const byte sprinklerPins[kreise] = {7, 8, 9, 10, 11, 12};    // Ausgabe Ventile
const byte tasterPins[kreise] = {A0, A1, A2, A3, A4, A5};    // Eingabe Taster
const byte startPin = 5;
const byte stopPin = 6;
const byte pumpePin = LED_BUILTIN;
const uint32_t pumpZeit = 3000;                              // zeit in ms
enum {abfrage, beregnen, beenden};                           // Ablauf
byte zustand = abfrage;                                      // Vorbelegung

const byte sperrByte = 255;
byte ausgabe[kreise] = {sperrByte};

void setup()
{
  Serial.begin(115200);
  delay(500);
  Serial.println(F("Start..."));
  resetSprinkler();
  digitalWrite(startPin, LOW);
  digitalWrite(stopPin, LOW);
  pinMode(startPin, INPUT_PULLUP);
  pinMode(stopPin, INPUT_PULLUP);
  digitalWrite(pumpePin, LOW);
  pinMode(pumpePin, OUTPUT);
}

void loop()
{
  regner();
}
void resetSprinkler()                                        // stellt Ausgangszustand her
{
  for (byte b = 0; b < kreise; b++)
  {
    digitalWrite(sprinklerPins[b], LOW);
    pinMode(sprinklerPins[b], OUTPUT);
    digitalWrite(tasterPins[b], LOW);
    pinMode(tasterPins[b], INPUT_PULLUP);
    ausgabe[b] = sperrByte;
  }
  digitalWrite(pumpePin, LOW);
}
void regner()
{
  static byte pos = 0;
  static uint32_t startZeit = 0;
  byte taste = sperrByte;
  switch (zustand)
  {
    case abfrage:
      for (byte b = 0; b < kreise; b++)                      // Alles abfragen
      {
        if (!digitalRead(tasterPins[b]))                     // Taste gedrückt?
        {
          taste = b;                                         // merken
          for (byte c = 0; c < kreise; c++)                  // Prüfung
          {
            if (ausgabe[c] == taste)                         // war schon gedrückt?
            { taste = sperrByte; }
          }
          if (taste == b)                                    // vergleich passt?
          {
            digitalWrite(tasterPins[b], LOW);
            pinMode(tasterPins[b], OUTPUT);
            ausgabe[pos] = taste;                            // setzen
            pos++;                                           // nächste vorbereiten
            Serial.print(F("Taste "));
            Serial.print(b);
            Serial.print(F(" an Position "));
            Serial.println(pos);
          }
        }
      }
      if (!digitalRead(stopPin))                             // Abbruch
      {
        Serial.println(F("Stop ausgelöst"));
        zustand = beenden;
      }
      else if ((pos != 0 && !digitalRead(startPin)) ||       // Start
               pos >= kreise)
      {
        Serial.println(F("START"));
        pos = 0;
        startZeit = millis();
        digitalWrite(pumpePin, HIGH);                        // setzen
        digitalWrite(sprinklerPins[ausgabe[pos]], HIGH);
        zustand = beregnen;
      }
      break;
    case beregnen:
      if (millis() - startZeit >= pumpZeit)
      {
        Serial.print(F("Sprinkler "));
        Serial.print(ausgabe[pos]);
        Serial.println(F(" AUS"));
        digitalWrite(sprinklerPins[ausgabe[pos]], LOW);      // löschen
        startZeit = millis();                                // neuen Startpunkt festlegen
        pos++;                                               // nächste Position vorbereiten
        if (ausgabe[pos] == sperrByte ||                     // Abbruchfuktion
            pos >= kreise)
        { zustand = beenden; }
        else
        {
          digitalWrite(sprinklerPins[ausgabe[pos]], HIGH);   // oder neuen PIN setzen
          Serial.print(F("Sprinkler "));
          Serial.print(ausgabe[pos]);
          Serial.println(F(" EIN"));
        }
      }
      break;
    case beenden:
      Serial.println(F("ENDE"));
      pos = 0;
      resetSprinkler();
      zustand = abfrage;
      break;
  }
}