State Machine mit Stop nach fünf Durchgängen

@my_xy_projekt:

Der Sketch funktioniert leider noch nicht. Es hört sich wieder nach dem Fehler an der ohne Software Verzögerung aufgetreten ist.

Der alte Sketch funktionert, ich habe das nochmal getestet um sicher zu gehen, ob sich nicht irgendwein Kabel gelöst hat etc.

Ich habe die Software- Verzögerung zwischen dem Schalten der beiden Relais eingebaut und so funktionert der Sketch tendenziell. Jedoch geht der Arm jetzt ununterbrochen runter und wieder hoch auch ohne, dass der Reed-Schalter von einem Magneten ausgelöst wird.

// Pin - Definitionen
const uint8_t relaisNachOben = 8;
const uint8_t relaisNachUnten = 9;
const uint8_t Relais3 = 10; // unbenutzt
const uint8_t Relais4 = 11; // unbenutzt

const uint8_t Taster = 6;            // manuelle Ausloesung
const uint8_t ReedSchalter = 7;      // Magnetauslöser
const uint8_t EndschalterUnten = 12;
const uint8_t EndschalterOben = 13;

const uint32_t wartezeitUmschalten = 1000; // in ms -> Dem Motor Zeit geben um anzuhalten!

void setup()
{
  // Schnittstelle für den seriellen Monitor
  Serial.begin(9600);
  // Pin's vorbereiten
  pinMode(relaisNachOben, OUTPUT);
  pinMode(relaisNachUnten, OUTPUT);
  pinMode(Relais3, OUTPUT);
  pinMode(Relais4, OUTPUT);
  //Ausgangszustand herstellen
  digitalWrite(relaisNachOben, HIGH);
  digitalWrite(relaisNachUnten, HIGH);
  digitalWrite(Relais3, HIGH);
  digitalWrite(Relais4, HIGH);

  pinMode(ReedSchalter, INPUT_PULLUP);
  pinMode(EndschalterOben, INPUT_PULLUP);
  pinMode(EndschalterUnten, INPUT_PULLUP);
}

void loop()
{
  Verarbeitung();//
}

void Verarbeitung()
{
  enum {warten, wartenUnten, ArmNachOben, ArmOben, wartenOben, ArmNachUnten, ArmUnten};
  static uint8_t zustand = warten;
  static uint8_t zaehler = 0;
  static uint32_t lastmillis = 0;

  switch (zustand)
  {
    case warten:
      if (!digitalRead(Taster) || !digitalRead(ReedSchalter))  // Auslöser
      {
        zaehler = 0;
        lastmillis = millis();
        zustand = wartenUnten;
      }
      else if (digitalRead(EndschalterUnten))  // Wenn nicht an der Startposition
      {
        digitalWrite(relaisNachUnten, LOW);
        delay(30);                             // Software- Verzögerung
        digitalWrite(relaisNachOben, HIGH);
      }
      else                                     // Mach alles aus und warte...
      {
        digitalWrite(relaisNachOben, HIGH);
        delay(30);                             // Software- Verzögerung
        digitalWrite(relaisNachUnten, HIGH);
      }
      break;

    case wartenUnten:
      if (!zaehler)
      {
        if (millis() - lastmillis >= 20000)
        {
          zustand = ArmNachOben;
        }
      }
      else if (millis() - lastmillis >= wartezeitUmschalten)
      {
        zustand = ArmNachOben;
      }
      break;

    case ArmNachOben:
      Serial.println(F("Arm geht nach oben nach Anfangspause"));
      digitalWrite(relaisNachOben, LOW); // Bewegung nach oben
      delay(30);                         // Software- Verzögerung
      digitalWrite(relaisNachUnten, HIGH);
      zustand = ArmOben;
      break;

    case ArmOben:
      if (!digitalRead(EndschalterOben))
      {
        Serial.println(F("Arm ist oben"));
        digitalWrite(relaisNachOben, HIGH);
        delay(30);                         // Software- Verzögerung
        digitalWrite(relaisNachUnten, HIGH);
        lastmillis = millis();
        zustand = wartenOben;
      }
      break;
    case wartenOben:
      if (millis() - lastmillis >= wartezeitUmschalten)
      {
        zustand = ArmNachUnten;
      }
      break;
    case ArmNachUnten:
      Serial.println(F("Arm geht nach unten"));
      digitalWrite(relaisNachUnten, LOW);
      delay(30);                          // Software- Verzögerung
      digitalWrite(relaisNachOben, HIGH);
      zustand = ArmUnten;
      break;
    case ArmUnten:
      if (!digitalRead(EndschalterUnten))
      {
        Serial.println(F("Arm unten"));
        digitalWrite(relaisNachUnten, HIGH);
        delay(30);                        // Software- Verzögerung
        digitalWrite(relaisNachOben, HIGH);
        zaehler++;
        if (zaehler > 5)
        {
          zustand = warten;
        }
        else
        {
          lastmillis = millis();
          zustand = wartenUnten;
        }
      }
      break;
  }
}

Ich dachte erst es würde an einem vergessenen pinMode(Taster,INPUT_PULLUP); liegen, aber das hilft leider nicht...

AAhh - jetzt habe Ich Dein Eingangspost evtl. verstanden....
Du willst den Reed mit dem anderen Arm auslösen ...
Figur 1 wird mit Taste gestartet - ist der Arm oben, wird der Reed von Figur 2 ausgelöst, der Arm von Figur 1 geht wieder runter und wartet darauf das Figur 2 oben ist...

Richtig?

Nein, so meine ich das:

Der Taster bewirkt das Hochfahren des Armes von Figur 1, für die dieser Sketch bestimmt ist. Der Arm von Figur 1 löst hierbei den Reed-Schalter von Figur 2 aus. Bei Figur 2 wird daraufhin der Arm hochgefahren und löst den Reed- Schalter von Figur 1 aus. Dieser Vorgang soll dann 5 Durchgänge laufen und dann dann soll Figur 1 schließlich bei ArmUnten stoppen.

kompiliert fehlerfrei:

// Pin - Definitionen
const uint8_t relaisNachOben = 8;
const uint8_t relaisNachUnten = 9;
const uint8_t Relais3 = 10; // unbenutzt
const uint8_t Relais4 = 11; // unbenutzt

const uint8_t Taster = 6;            // manuelle Ausloesung
const uint8_t ReedSchalter = 7;      // Magnetauslöser
const uint8_t EndschalterUnten = 12;
const uint8_t EndschalterOben = 13;

const uint32_t wartezeitUmschalten = 1000; // in ms -> Dem Motor Zeit geben um anzuhalten!

void setup()
{
  // Schnittstelle für den seriellen Monitor
  Serial.begin(9600);
  // Pin's vorbereiten
  pinMode(relaisNachOben, OUTPUT);
  pinMode(relaisNachUnten, OUTPUT);
  pinMode(Relais3, OUTPUT);
  pinMode(Relais4, OUTPUT);
  //Ausgangszustand herstellen
  digitalWrite(relaisNachOben, HIGH);
  digitalWrite(relaisNachUnten, HIGH);
  digitalWrite(Relais3, HIGH);
  digitalWrite(Relais4, HIGH);

  pinMode(ReedSchalter, INPUT_PULLUP);
  pinMode(EndschalterOben, INPUT_PULLUP);
  pinMode(EndschalterUnten, INPUT_PULLUP);
}

void loop()
{
  Verarbeitung();//
}

void Verarbeitung()
{
  enum {warten, wartenUnten, ArmNachOben, ArmOben, wartenOben, ArmNachUnten, ArmUnten};
  static uint8_t zustand = warten;
  static uint8_t zaehler = 0;
  static uint32_t lastmillis = 0;

  switch (zustand)
  {
    case warten:
      if (!digitalRead(Taster))  // Auslöser
      {
        zaehler = 0;
        lastmillis = millis();
        zustand = wartenUnten;
      }
      else if (digitalRead(EndschalterUnten))  // Wenn nicht an der Startposition
      {
        digitalWrite(relaisNachOben, HIGH);
        digitalWrite(relaisNachUnten, LOW);
      }
      else                                     // Mach alles aus und warte...
      {
        digitalWrite(relaisNachOben, HIGH);
        digitalWrite(relaisNachUnten, HIGH);
      }
      break;

    case wartenUnten:
      if (!zaehler)
      {
        if (millis() - lastmillis >= 20000)
        {
          Serial.println(F("Arm geht nach oben nach Anfangspause"));
          zustand = ArmNachOben;
        }
      }
      else if (!digitalRead(ReedSchalter))
      {
        if (millis() - lastmillis >= 500)
        {
          zustand = ArmNachOben;
        }
      }
      break;
    case ArmNachOben:
      digitalWrite(relaisNachOben, LOW); // Bewegung nach oben
      zustand = ArmOben;
      break;

    case ArmOben:
      if (!digitalRead(EndschalterOben))
      {
        Serial.println(F("Arm ist oben"));
        digitalWrite(relaisNachOben, HIGH);
        lastmillis = millis();
        zustand = wartenOben;
      }
      break;
    case wartenOben:
      if (millis() - lastmillis >= wartezeitUmschalten)
      {
        zustand = ArmNachUnten;
      }
      break;
    case ArmNachUnten:
      Serial.println(F("Arm geht nach unten"));
      digitalWrite(relaisNachUnten, LOW);
      zustand = ArmUnten;
      break;
    case ArmUnten:
      if (!digitalRead(EndschalterUnten))
      {
        Serial.println(F("Arm unten"));
        digitalWrite(relaisNachUnten, HIGH);
        zaehler++;
        if (zaehler > 5)
        {
          zustand = warten;
        }
        else
        {
          lastmillis = millis();
          zustand = wartenUnten;
        }
      }
      break;
  }
}

Ob der das tut kann ich nicht probieren - ich hab kein Board bei...
Evtl. fehlen ein paar serielle Ausgaben. wenn was nicht geht wirds evtl. schwer.

Danke, funktionert aber leider noch nicht, ich probieren noch ein bisschen rum;)

Was bewirkt denn das if (millis() - lastmillis >= 500)?

Der wartet da, bis die Zeit vorbei ist.
lastmillis wird beim beenden des vorherigen Schritt mit millis() gefüllt.
Das ist die Zwangspause, die Du brauchst um den Motor umzudrehen.

Aber ich sehe, wo das Problem sein könnte. In der Zeit, wo gewartet wird, ist der Reed nicht mehr eingeschaltet...
Der Zustand muss also gespeichert werden.
Mach ich...

Eigenartig.
Ich sehe in #14, das Du den selbst gelöst hast....

Dann neu:
in void Verarbeitung noch vor dem switch hinzufügen:

  static bool reedUnten = false;

Das case ändern:

    case wartenUnten:
      if (!zaehler)
      {
        if (millis() - lastmillis >= 20000)
        {
          Serial.println(F("Arm geht nach oben nach Anfangspause"));
          zustand = ArmNachOben;
        }
      }
      else if (!digitalRead(ReedSchalter))
      {
        reedUnten = true;
      }
      if (millis() - lastmillis >= 500 && reedUnten)
      {
        zustand = ArmNachOben;
        reedUnten = false;
      }
      break;

Jetzt sieht der Sketch so aus, aber funktionert leider immer noch nicht wie gewollt:(

// Pin - Definitionen
const uint8_t relaisNachOben = 8;
const uint8_t relaisNachUnten = 9;
const uint8_t Relais3 = 10; // unbenutzt
const uint8_t Relais4 = 11; // unbenutzt

const uint8_t Taster = 6;            // manuelle Ausloesung
const uint8_t ReedSchalter = 7;      // Magnetauslöser
const uint8_t EndschalterUnten = 12;
const uint8_t EndschalterOben = 13;

const uint32_t wartezeitUmschalten = 4000; // regelt die Zeit, die der Arm oben stehen bleibt

void setup()
{
  // Schnittstelle für den seriellen Monitor
  Serial.begin(9600);
  // Pin's vorbereiten
  pinMode(relaisNachOben, OUTPUT);
  pinMode(relaisNachUnten, OUTPUT);
  pinMode(Relais3, OUTPUT);
  pinMode(Relais4, OUTPUT);
  //Ausgangszustand herstellen
  digitalWrite(relaisNachOben, HIGH);
  digitalWrite(relaisNachUnten, HIGH);
  digitalWrite(Relais3, HIGH);
  digitalWrite(Relais4, HIGH);

  pinMode(ReedSchalter, INPUT_PULLUP);
  pinMode(EndschalterOben, INPUT_PULLUP);
  pinMode(EndschalterUnten, INPUT_PULLUP);
  pinMode(Taster, INPUT_PULLUP);
}

void loop()
{
  Verarbeitung();//
}

void Verarbeitung()
{
  enum {warten, wartenUnten, ArmNachOben, ArmOben, wartenOben, ArmNachUnten, ArmUnten};
  static uint8_t zustand = warten;   // Anfangszustand ist Warten
  static uint8_t zaehler = 0;        // Variable für Schleifenzähler
  static uint32_t lastmillis = 0;    // Variable Zeitmerker
  static bool reedUnten = false;     // Zustand für ReedSchalter

  switch (zustand)
  {
    case warten:
      if (!digitalRead(Taster))  // wenn der Taster gedrückt wird...
      {
        zaehler = 0;             // Zähler wird 0 gesetzt
        lastmillis = millis();   // Zeitmerker für Anfangspause
        zustand = wartenUnten;   // nächster Zustand
      }
      else if (digitalRead(EndschalterUnten))  // Wenn nicht an der Startposition, d.h wenn der Stecker gezogen wurde während der Bewegung dann fahre ich damit an die Referenzposition
      {
        digitalWrite(relaisNachUnten, LOW);
        delay(30);                            // Software- Verzögerung
        digitalWrite(relaisNachOben, HIGH);

      }
      else                                     // Wenn der Taster gedrückt ist...Mach alles aus und warte...
      {
        digitalWrite(relaisNachOben, HIGH);
        delay(30);                           // Software- Verzögerung
        digitalWrite(relaisNachUnten, HIGH);
      }
      break;

    case wartenUnten:
      if (!zaehler)                // Wenn der Zähler 0 ist
      {
        if (millis() - lastmillis >= 20000) // und 20 Sekunden vergangen sind
        {
          Serial.println(F("Arm geht nach oben nach Anfangspause"));
          zustand = ArmNachOben;  // nächster Zustand
        }
      }
      else if (!digitalRead(ReedSchalter))   // Wenn der Zähler ungleich 0 ist und der ReedSchalter auslöst
      {
        reedUnten = true;                    // gespeicherter Zustand für ReedSchalter
      }
      if (millis() - lastmillis >= 20000 && reedUnten)    // Anfangspause
      {
        zustand = ArmNachOben;            // nächster Zustand
        reedUnten = false;                // gespeicherter Zustand für ReedSchalter
      }
      break;

    case ArmNachOben:
      digitalWrite(relaisNachOben, LOW); // Bewegung nach oben
      delay (30);                        // Software- Verzögerung
      digitalWrite(relaisNachUnten, HIGH);
      zustand = ArmOben;                // nächster Zustand
      break;

    case ArmOben:
      if (!digitalRead(EndschalterOben)) // Wenn der Endschalter oben gedrückt wird
      {
        Serial.println(F("Arm ist oben"));
        digitalWrite(relaisNachOben, HIGH);
        delay(30);
        digitalWrite(relaisNachUnten, HIGH);
        lastmillis = millis();
        zustand = wartenOben;            // nächster Zustand
      }
      break;

    case wartenOben:
      if (millis() - lastmillis >= wartezeitUmschalten)     // regelt die Zeit, die der Arm oben stehen bleibt
      {
        zustand = ArmNachUnten;
      }
      break;

    case ArmNachUnten:
      Serial.println(F("Arm geht nach unten"));
      digitalWrite(relaisNachUnten, LOW);
      delay(30);                      // Software- Verzögerung
      digitalWrite(relaisNachOben, HIGH);
      zustand = ArmUnten;            // nächster Zustand
      break;

    case ArmUnten:
      if (!digitalRead(EndschalterUnten))   // Wenn der EndschalterUnten gedrückt wird
      {
        Serial.println(F("Arm unten"));
        digitalWrite(relaisNachUnten, HIGH);
        delay(30);            // Software- Verzögerung
        digitalWrite(relaisNachOben, HIGH);
        zaehler++;                         // Schleifenzaehler- Variable wird eins größer
        if (zaehler > 5)                   // wenn zaehler über 5 dann wechsel in
        {
          zustand = warten;                // Zustand Warten
        }
        else                               // wenn nicht
        {
          lastmillis = millis();
          zustand = wartenUnten;           // nach wartenUnten
        }
      }
      break;
  }
}

Und wie dann?
Ich sehe nicht, was da passiert! Und wenn Du willst, das ich das nachbaue, dann muss ich Dich enttäuschen.

Also beschreibe, was nicht oder falsch geht.

@my_xy_projekt:

Sorry für meine schlechte Beschreibung des Fehlers. Es lag an einer zu kurzen Software- Verzögerung für die Schütze! Ich dachte 30ms würden ausreichen, weil im Datenblatt steht, dass die Schütze, die ich gegeneinander verriegelt habe einen Schließverzug von 15- 19ms und einen Öffnerverzug von 8- 25ms haben. Mit 500ms Software- Verzögerung funktioniert jetzt alles gut!

Ich habe im Sketch noch folgendes verändert:
Der Taster startet die Bewegung des Armes jetzt ohne Anfangspause, das ist besser so. Nach jedem Auslösen des Reed- Schalters von Figur 1 gibt es eine Anfangspause von 20000ms. Mir kam die Zeit der Anfangspause jedoch sehr lange vor und tatsächlich sind es 30000ms. Woran liegt das?

Danke für Deine Hilfe my_xy_projekt!

So sieht der Sketch jetzt aus:

// 30 ms sind zu knapp für die Software Verzögerung für die gegenseitig verriegelten Schütze, mit 500 geht es, vielleicht geht es auch mit weniger ich sollte es jedoch einfach so stehen lassen!
// Die Bewegung des Armes erfolgt erst nach 30000 ms nach dem Auslösen des Reed- Schalters
// Mit einem Drücken des Tasters zwischen den Durchgängen passiert nichts, das ist aber auch gut so.
// Die Bewegung des Armes stoppt am oberen Punkt für 4000ms, so wie es sein soll!
// Pin - Definitionen
const uint8_t relaisNachOben = 8;
const uint8_t relaisNachUnten = 9;
const uint8_t Relais3 = 10; // unbenutzt
const uint8_t Relais4 = 11; // unbenutzt

const uint8_t Taster = 6;            // manuelle Ausloesung
const uint8_t ReedSchalter = 7;      // Magnetauslöser
const uint8_t EndschalterUnten = 12;
const uint8_t EndschalterOben = 13;

const uint32_t wartezeitUmschalten = 4000; // regelt die Zeit, die der Arm oben stehen bleibt

void setup()
{
  // Schnittstelle für den seriellen Monitor
  Serial.begin(9600);
  // Pin's vorbereiten
  pinMode(relaisNachOben, OUTPUT);
  pinMode(relaisNachUnten, OUTPUT);
  pinMode(Relais3, OUTPUT);
  pinMode(Relais4, OUTPUT);
  //Ausgangszustand herstellen
  digitalWrite(relaisNachOben, HIGH);
  digitalWrite(relaisNachUnten, HIGH);
  digitalWrite(Relais3, HIGH);
  digitalWrite(Relais4, HIGH);

  pinMode(ReedSchalter, INPUT_PULLUP);
  pinMode(EndschalterOben, INPUT_PULLUP);
  pinMode(EndschalterUnten, INPUT_PULLUP);
  pinMode(Taster, INPUT_PULLUP);
}

void loop()
{
  Verarbeitung();
}

void Verarbeitung()
{
  enum {warten, wartenUnten, ArmNachOben, ArmOben, wartenOben, ArmNachUnten, ArmUnten};
  static uint8_t zustand = warten;   // Anfangszustand ist Warten
  static uint8_t zaehler = 0;        // Variable für Schleifenzähler
  static uint32_t lastmillis = 0;    // Variable Zeitmerker
  static bool reedUnten = false;     // Zustand für ReedSchalter

  switch (zustand)
  {
    case warten:
      if (!digitalRead(Taster))  // wenn der Taster gedrückt wird...
      {
        zaehler = 0;             // Zähler wird 0 gesetzt
        zustand = wartenUnten;   // nächster Zustand
      }
      else if (digitalRead(EndschalterUnten))  // Wenn nicht an der Startposition, d.h wenn der Stecker gezogen wurde während der Bewegung dann fahre ich damit an die Referenzposition
      {
        digitalWrite(relaisNachUnten, LOW);
        delay(500);                            // Software- Verzögerung
        digitalWrite(relaisNachOben, HIGH);
      }
      else                                     // Wenn der Taster gedrückt ist...Mach alles aus und warte...
      {
        digitalWrite(relaisNachOben, HIGH);
        delay(500);                           // Software- Verzögerung
        digitalWrite(relaisNachUnten, HIGH);
      }
      break;

    case wartenUnten:
      if (!zaehler)                // Wenn der Zähler 0 ist
      {
        Serial.println(F("Arm geht nach oben"));
        zustand = ArmNachOben;  // nächster Zustand
      }

      else if (!digitalRead(ReedSchalter))   // Wenn der Zähler ungleich 0 ist und der ReedSchalter auslöst
      {
        lastmillis = millis();
        reedUnten = true;                    // wird reedUnten wahr
      }
      if (millis() - lastmillis >= 20000 && reedUnten)    // wenn die Anfangspause vergangen ist und reedUnten wahr ist
      {
        zustand = ArmNachOben;            // nächster Zustand
        reedUnten = false;                // gespeicherten Zustand für ReedSchalter zurücksetzen
      }
      break;

    case ArmNachOben:
      digitalWrite(relaisNachOben, LOW); // Bewegung nach oben
      delay (500);                        // Software- Verzögerung
      digitalWrite(relaisNachUnten, HIGH);
      zustand = ArmOben;                // nächster Zustand
      break;

    case ArmOben:
      if (!digitalRead(EndschalterOben)) // Wenn der Endschalter oben gedrückt wird
      {
        Serial.println(F("Arm ist oben"));
        digitalWrite(relaisNachOben, HIGH);
        delay(500);
        digitalWrite(relaisNachUnten, HIGH);
        lastmillis = millis();
        zustand = wartenOben;            // nächster Zustand
      }
      break;

    case wartenOben:
      if (millis() - lastmillis >= wartezeitUmschalten)     // regelt die Zeit, die der Arm oben stehen bleibt
      {
        zustand = ArmNachUnten;
      }
      break;

    case ArmNachUnten:
      Serial.println(F("Arm geht nach unten"));
      digitalWrite(relaisNachUnten, LOW);
      delay(500);                      // Software- Verzögerung
      digitalWrite(relaisNachOben, HIGH);
      zustand = ArmUnten;            // nächster Zustand
      break;

    case ArmUnten:
      if (!digitalRead(EndschalterUnten))   // Wenn der EndschalterUnten gedrückt wird
      {
        Serial.println(F("Arm unten"));
        digitalWrite(relaisNachUnten, HIGH);
        delay(500);            // Software- Verzögerung
        digitalWrite(relaisNachOben, HIGH);
        zaehler++;                         // Schleifenzaehler- Variable wird eins größer
        if (zaehler > 3)                   // wenn zaehler über 3 dann wechsel in
        {
          zustand = warten;                // Zustand Warten
        }
        else                               // wenn nicht
        {
          lastmillis = millis();
          zustand = wartenUnten;           // nach wartenUnten
        }
      }
      break;
  }
}

Kleiner Tip: Deine Zustände sind Abläufe, so ist das nicht gedacht! Alle Ausgaben sollen dann erfolgen, wenn der Automat von einem Zustand in einen anderen übergeht. D.h. die Ausgänge werden für die Bewegung ArmNachOben schon gesetzt, bevor der Zustand in ArmNachOben übergeht. Es ist nicht besonders sinnvoll, wenn Du in ArmNachOben nur die Bewegung startest und in den nächsten Zustand übergehst, ohne vorher oder hinterher auf irgendeine Bedingung zu warten. Dieser Code gehört in wartenUnten.

Als Strickmuster: jeder Zustand wartet auf eine oder mehrere Bedingungen. Wenn eine erfüllt ist, wird eine Aktion gestartet oder beendet und zum nächsten zugehörigen Zustand übergegangen.

Als Diagramm: Zustände als Kreise, mit Pfeilen zu möglichen Folgezuständen. Über jedem Pfeil steht die Bedingung, die diesen Übergang startet, und darunter die Aktion (Ausgabe...), die beim Übergang ausgeführt wird.

Bei dieser Änderung sollte Dir eigentlich aufgefallen sein, wie oft die 500 neu eingetragen werden muß. Viel einfacher geht das mit einer Konstanten die nur einmal definiert wird und dann für alle Zeiten in jedem dieser delay() verwendet wird.

Das delay macht da keinen Sinn.
Der PIN ist schon HIGH.

Danke für Eure Antworten!

@DrDiettrich: Das mit dem Diagramm hört sich gut an, das werde ich mal skizzieren. Für den ursprünglichen Sketch, den ich hier gepostet habe, habe ich auch so ein Diagramm erstellt und mich beim Programmieren daran entlang gehangelt, deswegen enthielt er auch diesen void loop()- Teil:

Ich habe gestern auch versucht meinen ursprünglichen Sketch umzuschreiben und den weiteren Zustand Pause, wie Du in #7 geschrieben hast einzubinden.

Leider ist in dem switch- case?-statement so der Wurm drin, dass ich irgendwann aufgegeben habe. Könnte mir bitte jemand die switch- case- Anweisung im alten Sketch korrigieren und die richtig stellen? Und vielleicht auch die Aufzählung der Zustände mit enum? Ich glaube, ich könnte den Rest dann alleine hinkriegen.

Jetzt nochmal zum neuen Sketch:

Kann hier bitte jmd. Bezug zu nehmen?

Jetzt nochmal eine ganz andere Frage:

Ich finde das Programmieren eine sehr spannende Angelegenheit und bin überrascht wie viele Möglichkeiten es gibt Abläufe zu gestalten. Leider bin ich auch totaler Laie und mich strengt das Programmieren sehr an. Ich mache gerade mein Diplom in freier Kunst und muss aufpassen, dass ich mich nicht zu lange damit beschäftige. Gibt es eine Plattform wo man Programme in Auftrag geben kann?

Hier im Forum unter Community/Jobs and Paid Consultancy Englisch. Früher Gigs & Collaborations. Aber wundere Dich nicht, wenn Du zuerst nach dem Budget gefragt wirst.

Gruß Tommy