Sich wiederholende Intervalle ohne Delay Verzweiflung

[RobertLeRopp]

(11.12.2019 17:06)Tommy56 schrieb:  Und woher weist Du, ob es Tag oder Nacht ist?
Sind die Nachtpausen gleich lang?

Wir warten dann mal auf die Skizze.

Gruß Tommy

Danke für deine Bemühungen es zu verstehen.

Ich weis leider nicht wie ich euch anhand meines Falles eine Skizze zeichnen soll.

Wie lange die Relais und in welchem Abstand zueinander sie laufen sollen habe ich ja bereits erklärt.

Aber hier nochmals:
Relai1 5 Minuten an, nach Ablauf der 5 Minuten aus
Relai2 5 Minuten an, nach Ablauf der 5 Minuten aus
Relai3 5 Minuten an, nach Ablauf der 5 Minuten aus
Relai3 5 Minuten an, nach Ablauf der 5 Minuten aus
Und nun wie auch immer, einen endlosen Replay der ganzen Sache.
Wie gesagt, jedes Relai nacheinander, nicht gleichzeitig.

Ob es Tag oder Nacht ist wird bei mir über den Wert einer Photodiode festgestellt.

Code:

const int threshold = 100;

void loop() {

int sensorValue = analogRead(A0);

if (sensorValue > threshold) {
//mache etwas
}
else {
//mache etwas anderes
}
}

[Tommy56]

Da solltest Du eine Hysterese einbauen, sonst flattert das am Umschaltpunkt:

Code:

bool isNacht = false;
int sensorValue = analogRead(A0);

if (sensorValue > threshold + 10) {
  isNacht = false;
}
else if (sensorValue < threshold - 10) {
  isNacht = true;
}

Oder umgekehrt, je nach Schaltung.

Gruß Tommy

[MicroBahner]

Das was Du willst ist einfach eine kleine Ablaufsteuerung/Schrittkette. Das Ablaufen der Zeit ist der 'Trigger' um den nächsten Schritt auszuführen. Du musst dir in einer Variable merken in welchem Schritt Du gerade bist, damit Du beim Zeitablauf dann die entsprechenden Aktionen ausführen kannst (Relais aus/ein ) und zum nächsten Schritt schaltest..
Da alles immer nacheinander abläuft, brauchst Du auch nur einen Zeitzähler.

[MicroBahner]

hier ein Ansatz, den Du dann aufbohren kannst:

Code:

const byte relPin[] = {2, 3, 4, 5};
const byte relZahl = sizeof(relPin); // so einfach, da relPin als byte definiert ist
unsigned long previousMillis;
unsigned long aktIntervall;
int interval[] = {3000, 6000, 9000, 12000};
byte schrittNr = relZahl - 1;

void setup() {

  for (int i = 0; i < relZahl; i++) {
    pinMode(relPin[i], OUTPUT);
  }
}

void loop() {
  if (millis() - previousMillis >= aktIntervall) {
    previousMillis = millis();
    byte neuerSchritt = schrittNr+1;
    if ( neuerSchritt >= relZahl ) neuerSchritt = 0;
    digitalWrite( relPin[schrittNr], LOW );
    digitalWrite( relPin[neuerSchritt], HIGH );
    schrittNr = neuerSchritt;
    aktIntervall = interval[schrittNr];
  }
}

[MicroBahner]

Hallo,
jetzt etwas verallgemeinert und mit Kommentaren. Ich hoffe, Du verstehst den Ablauf damit etwas besser. Der Sketch enthält jetzt auch den Ansatz für die Pausenintegration. Falls noch was unklar ist, kannst Du auch gleich hier fragen. Eventuell interessiert es ja auch den einen oder andern Mitleser.

Code:

// Schritte der Schrittkette mit der Pinnummern des angezogenen Relais, oder
// 255 wenn kein Relais aktiv ist ( Pausenschritt )
const byte relPin[] = {2, 255, 3, 4, 5};
const byte schrittZahl = sizeof(relPin); // so einfach möglich, da relPin als byte definiert ist
// Zeitdauer des jeweiligen Schrittes
const int interval[] = {3000, 1000, 2000, 2000, 5000};
byte schrittNr = schrittZahl - 1;   // Nummer des aktiven Schrittes ans Ende setzen
// beim ersten Start von loop wird dann auf den ersten Schritt (Index 0 )
// umgeschaltet

// Variable für die Zeitsteuerung
unsigned long previousMillis = 0;
unsigned long aktIntervall = 0;

void setup() {

  for (int i = 0; i < schrittZahl; i++) {
    pinMode(relPin[i], OUTPUT); // hier könnte man noch prüfen, ob es eine 'echte' Pinnummer ist, aber eigentlich macht pinMode das schon.
  }
}

void loop() {
  // vvvvvvvvvvvvvv  zeitgesteuerte Schrittkette  vvvvvvvvvvvvvvv
  if (millis() - previousMillis >= aktIntervall) {
    // Zeitdauer des aktuellen Schrittes ist abgelaufen
    previousMillis = millis();
    // Index des nächsten Schrittes berechnen, bei Überlauf wieder von vorn
    byte neuerSchritt = schrittNr + 1;
    if ( neuerSchritt >= schrittZahl ) neuerSchritt = 0;

    if ( relPin[schrittNr] < 255  ) {
      //im aktuellen Schritt ist eine Relais an: -> ausschalten
      digitalWrite( relPin[schrittNr], LOW );
    }
    if ( relPin[neuerSchritt] < 255 ) {
      // im Folgeschritt soll ein Relais eingeschaltet werden
      digitalWrite( relPin[neuerSchritt], HIGH );
    } else {
      // im Folgeschritt ist KEIN Relais eingetragen ( Pause )
      // hier kann gegebenenfalls geprüft werden, ob der Schritt übersprungen werden soll
      // ( Tag/Nacht Umschaltung )
    }
    schrittNr = neuerSchritt;           // Schrittnummer aktualisieren
    aktIntervall = interval[schrittNr]; // Zeit für aktuellen Schritt setzen

  } // ^^^^^^^^^^^^^^^ Ende Schrittkette ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

  // Hier können Dinge erledigt werden, die von der Schrittkette unabhängig sind.
}

[RobertLeRopp]

Hallo MicroBahner, tausend dank für deine Zeit

Ich versuche das nun alles zu verstehen und lese mich in die von dir benutzen Funktionen ein.

Was mir noch unklar ist aber sehr wichtig wäre, ist die Serielle Ausgabe, eben die Info welches Relai gerade an ist. Ich habe das schon geschafft aber nur so das der Monitor durchgehen mit der Ausgabe vom aktuellen Relai geflutet wird.

Gibt es die Möglichkeit, pro geschaltetem Relai immer nur die jeweilige Ausgabe einmal zu machen ?

[MicroBahner]

Wenn Du die seriellen Ausgaben in der Schrittkette dort machst, wo auch die digitalen Ausgänge geschaltet werden, dann werden sie auch immer nur zum Schaltzeitpunkt einmalig ausgegeben.
z.B.

Code:

if ( relPin[neuerSchritt] < 255 ) {
      // im Folgeschritt soll ein Relais eingeschaltet werden
      digitalWrite( relPin[neuerSchritt], HIGH );
      Serial.print( "Relais "); Serial.print( relPin[neuerSchritt] ); Serial.println(" EIN");
    } else {

[RobertLeRopp]

(11.12.2019 22:33)MicroBahner schrieb:  Wenn Du die seriellen Ausgaben in der Schrittkette dort machst, wo auch die digitalen Ausgänge geschaltet werden, dann werden sie auch immer nur zum Schaltzeitpunkt einmalig ausgegeben.
z.B.

Code:

if ( relPin[neuerSchritt] < 255 ) {
      // im Folgeschritt soll ein Relais eingeschaltet werden
      digitalWrite( relPin[neuerSchritt], HIGH );
      Serial.print( "Relais "); Serial.print( relPin[neuerSchritt] ); Serial.println(" EIN");
    } else {

Super das klappt.

Ich habe jetzt einige Versuche mit der Variante

Code:

if ( relPin[schrittNr] < 255  ) {
      //im aktuellen Schritt ist eine Relais an: -> ausschalten
      digitalWrite( relPin[schrittNr], LOW );
    }
    if ( relPin[neuerSchritt] < 255 ) {
      // im Folgeschritt soll ein Relais eingeschaltet werden
      digitalWrite( relPin[neuerSchritt], HIGH );
    } else {
      // im Folgeschritt ist KEIN Relais eingetragen ( Pause )
      // hier kann gegebenenfalls geprüft werden, ob der Schritt übersprungen werden soll
      // ( Tag/Nacht Umschaltung )

durchgespielt aber bekomme die Pause absolut nicht ordentlich zum laufen und habe auch keine Idee, wie ich den Tag und Nacht Fall bei

Code:

else

einbauen kann