Délai très long () possible?

J'essaie de faire une petite porte qui s'ouvre et se ferme qui devrait s'ouvrir ou se fermer toutes les 12 heures. Je me demandais si je pouvais juste faire un petit script en boucle avec un delay () pendant 12 heures, delay (43 200 000 000); J'imagine? Cependant, je n'ai aucune idée si c'est possible et / ou recommandable. Certains commentaires / alternatives (si nécessaire) seraient bien :)

La méthode d'horloge en temps réel est le moyen le plus précis, mais sinon, utilisez millis

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

Cela retardera jusqu'à env. 4294967295ms (2 ^ 32-1) ou 49 jours, après quoi la minuterie rattrapera la valeur destartMillis

delay()a ses utilisations, mais pour de longs retards ce n'est pas bon. Il indique simplement au microcontrôleur de ne rien faire pour les xcycles d'horloge. Pendant ce temps, votre Arduino ne peut rien faire d'autre.

Votre meilleur pari serait d'utiliser une chose appelée horloge en temps réel (RTC). Ces puces sont spécialement conçues pour garder une trace du temps, et vous pouvez les connecter à votre Arduino en toute simplicité. Voici un exemple de la façon dont vous pouvez le faire.

Vous pouvez utiliser l'interruption du chien de garde et faire dormir votre MCU en attendant et économiser de l'énergie.

Mais notez que vous n'économiserez de l'énergie que si votre carte le sauvegarde également. Cela signifie que vous devez avoir un régulateur de tension de repos faible au lieu des régulateurs habituels qui équipent les cartes Arduino les plus courantes, telles que l'Uno. Sinon, peu importe si votre MCU économise de l'énergie si votre carte ne le fait pas.

Voici le code (non testé):

#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.
}

Le code que j'ai copié provient de cette page: Arduino basse consommation utilisant la minuterie de surveillance .

Avez-vous un sommeil (int secondes non signé) disponible?

Sinon, cela vous permettrait de retarder () très longtemps:

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);
      }
   }
}

Cela fonctionnera:

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

        delay(1000);
        p++;

}

J'utilise juste des boucles quand je ne veux pas faire de trucs entre les deux:

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
    }
  }
}