Sehr lange Verzögerung () möglich?

Ich versuche, eine kleine Tür zu öffnen und zu schließen, die sich alle 12 Stunden öffnen oder schließen sollte. Ich habe mich gefragt, ob ich nur ein kleines Schleifenskript mit einer Verzögerung () für 12 Stunden und einer Verzögerung (43 200 000 000) erstellen könnte. Ich vermute? Ich habe jedoch keine Ahnung, ob dies möglich und / oder empfehlenswert ist. Einige Rückmeldungen / Alternativen (falls erforderlich) wären nett :)

Die Echtzeituhrmethode ist die genaueste Methode, wird aber ansonsten verwendet millis

unsigned long startMillis = millis();
while (millis() - startMillis < LONG_DELAY_MS);

Dies verzögert sich bis zu ca. 4294967295ms (2 ^ 32-1) oder 49 Tage, danach holt der Timer den Wert von aufstartMillis

delay()hat seine Verwendung, aber für lange Verzögerungen ist es nicht gut. Es weist den Mikrocontroller einfach an, nichts für xTaktzyklen zu tun . Während dieser Zeit kann Ihr Arduino nichts anderes tun.

Am besten verwenden Sie eine sogenannte Echtzeituhr (RTC). Diese Chips wurden speziell entwickelt, um die Zeit im Auge zu behalten, und Sie können sie problemlos mit Ihrem Arduino verbinden. Hier ist ein Beispiel, wie Sie das tun können.

Sie können den Watchdog-Interrupt verwenden und Ihre MCU während des Wartens in den Ruhezustand versetzen und Strom sparen.

Beachten Sie jedoch, dass Sie nur dann Strom sparen, wenn Ihr Board dies auch spart. Das bedeutet, dass Sie anstelle der üblichen Regler, mit denen die gängigsten Arduino-Boards wie das Uno ausgestattet sind, einen Regler für niedrige Ruhespannung benötigen. Ansonsten spielt es keine Rolle, ob Ihre MCU Energie spart, wenn Ihr Board dies nicht tut.

Hier ist der Code (ungetestet):

#include <avr/sleep.h>
// This variable is made volatile because it is changed inside an interrupt function
volatile int sleep_count = 0; // Keep track of how many sleep cycles have been completed.
const int interval = 720; // Interval in minutes between waking and doing tasks.
const int sleep_total = (interval*60)/8; // Approximate number of sleep cycles 
// needed before the interval defined above elapses. Not that this does integer math.

void setup(void) {
    watchdogOn(); // Turn on the watch dog timer.
    // Disable the ADC by setting the ADEN bit (bit 7) to zero.
    ADCSRA = ADCSRA & B01111111;
    // Disable the analog comparator by setting the ACD bit (bit 7) to one.
    ACSR = B10000000;
    // Disable digital input buffers on all analog input pins by setting bits 0-5 to one.
    DIDR0 = DIDR0 | B00111111;
}

void loop(void) {
    goToSleep(); // ATmega328 goes to sleep for about 8 seconds
    // and continues to execute code when it wakes up
    if (sleep_count == sleep_total) {
        // CODE TO BE EXECUTED PERIODICALLY
    }
}

void goToSleep() {
    set_sleep_mode(SLEEP_MODE_PWR_DOWN); // Set sleep mode.
    sleep_enable(); // Enable sleep mode.
    sleep_mode(); // Enter sleep mode.
    // After waking from watchdog interrupt the code continues
    // to execute from this point.
    sleep_disable(); // Disable sleep mode after waking.
}

void watchdogOn() {
    // Clear the reset flag, the WDRF bit (bit 3) of MCUSR.
    MCUSR = MCUSR & B11110111;
    // Set the WDCE bit (bit 4) and the WDE bit (bit 3) of WDTCSR. 
    WDTCSR = WDTCSR | B00011000; 
    // Set the watchdog timeout prescaler value to 1024 K 
    // which will yeild a time-out interval of about 8.0 s.
    WDTCSR = B00100001;
    // Enable the watchdog timer interupt.
    WDTCSR = WDTCSR | B01000000;
    MCUSR = MCUSR & B11110111;
}

ISR(WDT_vect) 
{
    sleep_count ++; // keep track of how many sleep cycles have been completed.
}

Der Code, den ich kopiert habe, stammt von dieser Seite: Arduino mit geringem Stromverbrauch unter Verwendung des Watchdog-Timers .

Haben Sie einen Schlaf (vorzeichenlose int Sekunden) zur Verfügung?

Wenn nicht, können Sie () sehr lange verzögern ():

for (unsigned int bigloop=0; bigloop<65535; bigloop++)
{
   for (unsigned int smallloop=0; smallloop<65535; smallloop++)
   {
      for (unsigned int tinyloop=0; tinyloop<65535; tinyloop++)
      {
         delay(65535);
      }
   }
}

Das wird funktionieren:

longDelayInSeconds = 120; //two minutes;   
while (p < longDelayInSeconds) {

        delay(1000);
        p++;

}

Ich benutze nur for-Schleifen, wenn ich nichts dazwischen machen möchte:

for (int Hours = 0; Hours < 12; Hours++) {            //Creates 12 hours
  for (int Minutes = 0; Minutes < 60; Minutes++) {    //Creates 1 hour
    for (int Seconds = 0; Seconds < 60; Seconds++) {  //Creates 1 minute
      delay(1000);                                    //Creates 1 second
    }
  }
}