Dämmerungsschalter mit Zeitkomponente

Griass eich!

Als Arduino Neuling hab ich eine Frage, bei die mir Hr. Goolgle der alte Alleswisser leider auch nicht helfen konnte:

Ich würde gerne was über einen Dämmerungsschalter steuern, das an Sicht findet man ja schnell mal wo als Beispiel. Die gesteuerte Aktion soll jedoch erst dann beginnen, wenn der Schwellwert mindestens z.B. 1 Minute dauerhaft unterschritten wurde. Damit soll verhindert werden, dass ein einfaches Abdecken des Dämmerungsschalters sofort die Aktion startet.

Wer hat einen Tip für mich?

BG Robert alias Voisepp

Wenn Du das mit Arduino lösen willst, musst Du in deinem Sketch einfach, sobald der Schwellwert unterschritten wird den Zeitpunkt merken, an dem dies geschieht (millis()) und einn Merker setzen, dass der Schwellwert unterschritten wurde. wird der schwellwert überschritten, setzt Du den merker wieder zurück. Ist der Merker gesetzt, prüfst Du in jedem Loopdurchgang, ob die gewünschte Zeitkonstante schon abgelaufen ist, und wenn Ja, dann startest du die gesteuerte Aktion. Auch dies Merkst Du Dir in ner Variablen. Wenn nun der Schwellwert wieder überschritten wird, beendest Du die Aktion und setzt die merker wieder zurück.

Hi! Ja danke das klingt logisch, aber leider fehlt mir noch das Wissen wie ich sowas auch umsetzen kann. Falls wer die Zeit und Muße hat, mir da ein Beispiel zu zeigen wär das voll der Hit!

z.B. mit Pin 5 muss 60 Sekunden unter 10 sein, damit es einfach bleibt. Ich weis, ist viel verlangt, aber ich wäre euch sehr dankbar!

In copy&paste inkl. anpassen bin ich meistens gar nich sooo schlecht gg.

Erst mal einen Lichtsensor (kein Dämmerungsschalter) kaufen, den dann in einem einfachen Programm alle 5 Minuten auslesen und mit Serial.println(Ergebnis); auf den PC ausgeben. Wenn dann die Dunkelheit erreicht ist, bei der das Licht angehen soll, schaust du dir die Ergebnis-Werte an, die auf dem PC ausgegeben werden. Dann hast du schon mal den Wert ab wann das Licht angehen soll, oder der Lollladen runter gehen soll, oder was auch immer.

Auf ein Programm in den IDE Beispielen wurdest du schon hingewiesen. Die sind in der Regel gut erklärt, indem hinter den Funktionen immer gleich steht was dort ausgeführt wird. Man sollte einfach jede Zeile dieser Beispielprogramme verstehen, dann ist es nicht schwer diese anzupassen, an die eigenen Wünsche. Es macht auch mehr Spass zu wissen was man in dem Programm in jeder Zeile des Codes macht. Dann hat man selber was erreicht.

Auch im Youtube findest du Videos, in denen ein Programm für bestimmte Funktionen entwickelt und sehr schön erklärt werden. Da weißt du dann auch bei jeder einzelnen Codezeile, was diese genau machen. Ist also auch noch eine Möglichkeit.

Franz

Hallo voisepp,

Ausnahmsweise, weil heute Freitag ist , hier ein fertiges Beispiel, auf Basis Deiner Angaben.

//*** Dämmerungsschalter mit Einschaltverzögerung ***
//***             12-01-2020 by SMC               ***
//***************************************************

// konstanten
const byte DS_PIN = A5;                  // Analogeingang 5 für Dämmerungssensor
const byte ActionLED = LED_BUILTIN;      // Anzeige für das ausführen der Aktion
const uint16_t UntererSchwellwert = 10;  // Wert, ab dem der Sensor dunkel erkennt (musst Du evt. noch etws erhöhen, damit es klappt)
const uint32_t Zeitkonstante = 60000;    // Zeitkonstante 60000 ms = 60 Sek.

// varialblen
bool dunkel = false;                     // Merker für Schwellwertunterschreitung
bool action = false;                     // Merker für ausgelöste Aktion
uint16_t helligkeit = 0;                 // Helligkeit bekommt den an A5 eingelesenen Helligkeitswert
uint32_t dunkel_Start = 0;               // Merker für den Begin der Schwellwerunterschreitung (dunkelphase)

void setup() {
  pinMode(ActionLED, OUTPUT);            // Pin für LED auf Ausgang schalten 
  digitalWrite(ActionLED, 0);            // und Ausgang auf 0, damit LED aus ist.

}

void loop() {
  // put your main code here, to run repeatedly:
  helligkeit = analogRead(DS_PIN);
  if (helligkeit <= UntererSchwellwert)  // Schwellwert unterschritten?
  {
    if (!dunkel)                         // ja. gerade eben unterschritten? (Merker für dunkel noch nicht gesetzt)
    {
      dunkel_Start = millis();           // dann Startzeitpunkt für Dunkelphase merken
      dunkel = true;                     // Merker dass es Dunkel ist  setzen
    }
    else                                 // wenn die Dunkelphase schon läuft
    {
      if (millis() - dunkel_Start > Zeitkonstante)  // ist es schon seit 60 sekunden dunkel?
      {
        if (!action)                     // Aktion bereits ausgeführt?
        {
          Aktion(1);                     // nein , dann Aktion ausführen
          action = true;                 // Merker setzen, dass Action asugeführt 
        }
      }
    }
  }
  else                                    // nein, Schwellwert nicht (mehr) unterschritten
  {
    if (action)                           // ist Aktion gestartet?
    {
      Aktion(0);                          // Aktion beenden
      action = false;                     // Merker für Aktion zurücksetzen
    }
    if (dunkel)                           // ist Dunkelphase gestartet?
    {
      dunkel = false;                     // Merker für Dunkelphase zurücksetzen
    }
  }
}

void Aktion(bool befehl){                 // wenn befehl = 1 wird LED eingeschaltet, wenn befehl = 0 , ausgeschaltet
  digitalWrite (ActionLED , befehl);      // Aktion ist schalten der LED
}

Velleicht kannste was mit anfangen. Zumindest sollte es Dir nen schubs in die richtige Richtung geben.
Die Komentare im Code sollten Dir beim Verständnis helfen.
Eine Rückmeldung Deinerseits würde mich freuen.

LG Stefan

Ich wollte die eigenen Gehirnwindungen des Themenstartes ein wenig anregen. Deshalb nur ein Programm mit dem man erst mal nur einen Messwert vom Sensor jede Minute auf den PC ausgeben kann. Und dann die Programmteile im eigenen Programm benutzen kann.

const int baudrate = 9600;
const byte Sensor01 = A0;      // Pin A0 wird Constant als Sensor01 bezeichnet
int Messwert01 = 0;       // Zum Abfragen des Sensor Messergebnises
byte Merker01 = 0;       // Zum merken des aktuellen Status
unsigned long Sekundenablauf01 = 0; // Zeitabfrage Sensormessung
const unsigned long Pausezeit01 = 60000; // Ablaufzeit Sensormessung 1 Min. (60 Sekunden = 60.000 Millisekunden)

//-------------------------------------------------------------------------------------------------------------
void setup() {

  // Serial Schnittstelle starten
  Serial.begin(baudrate);

  pinMode(Sensor01, INPUT); // Pin A0 für Input aktivieren

}
//-------------------------------------------------------------------------------------------------------------
void loop() {

  //-----------Sensor01 abfragen--------------------------------------------
  if (millis() - Sekundenablauf01 >= Pausezeit01) {  // Testen ob 60 Sekunden abgelaufen sind
    Messwert01 = analogRead(Sensor01);               // Pin von Sensor01 abfragen
    if (Messwert01 > 0) {                            // Ist Messwert vom Sensor vorhanden?
      Serial.println(Messwert01);                    // Messwert auf PC ausgeben
      Sekundenablauf01 = millis();                   // Die 60 Sekunden neu starten 
    }
  }
}

@Franz54 Dein Sketch hat natürlich den Vorteil, dass der TO erst mal sehen kann, was ihm der Dämmerungssensor für Werte zurückliefert.

LG Stefan