Utilisez AVR Watchdog comme un ISR normal

J'essaie de comprendre la minuterie du chien de garde de la série ATTinyX5. Donc, les choses que j'ai lues donnaient l'impression que vous pouviez l'utiliser pour que le programme fasse quelque chose de spécifique jamais N secondes mais n'a jamais vraiment montré comment. D'autres ont fait croire qu'il ne ferait que réinitialiser la puce à moins que quelque chose dans le code réinitialise son compte entre-temps (ce qui semble être l'utilisation "normale").

Existe-t-il un moyen d'utiliser le WDT comme vous le feriez pour TIMER1_COMPA_vect ou similaire. J'ai remarqué qu'il a un mode de temporisation de 1 seconde et j'aimerais vraiment pouvoir l'utiliser pour que quelque chose se produise toutes les 1 seconde dans mon code (et de préférence dormir entre les deux).

Pensées?

* Mise à jour: * Depuis qu'on lui a demandé, je fais référence à la section 8.4 de la fiche technique ATTinyX5 . Non pas que je le comprenne bien, c'est mon problème ...

Vous le pouvez très certainement. Selon la fiche technique, le temporisateur de surveillance peut être configuré pour réinitialiser le MCU ou provoquer une interruption lors de son déclenchement. Il semble que vous soyez plus intéressé par la possibilité d'interruption.

Le WDT est en fait plus facile à configurer qu'un minuteur normal pour la même raison qu'il est moins utile: moins d'options. Il fonctionne sur une horloge de 128 kHz calibrée en interne, ce qui signifie que sa synchronisation n'est pas affectée par la vitesse d'horloge principale du MCU. Il peut également continuer à fonctionner pendant les modes de sommeil les plus profonds pour fournir une source de réveil.

Je vais passer en revue quelques exemples de fiches techniques ainsi que du code que j'ai utilisé (en C).

Fichiers et définitions inclus

Pour commencer, vous souhaiterez probablement inclure les deux fichiers d'en-tête suivants pour que les choses fonctionnent:

#include <avr/wdt.h>        // Supplied Watch Dog Timer Macros 
#include <avr/sleep.h>      // Supplied AVR Sleep Macros

En outre, j'utilise la macro <_BV (BIT)> qui est définie dans l'un des en-têtes AVR standard comme suit (qui pourrait être plus familiale pour vous):

#define _BV(BIT)   (1<<BIT)

Début du code

Lorsque le MCU est démarré pour la première fois, vous initialisez généralement les E / S, configurez des temporisateurs, etc. une boucle instable.

if(MCUSR & _BV(WDRF)){            // If a reset was caused by the Watchdog Timer...
    MCUSR &= ~_BV(WDRF);                 // Clear the WDT reset flag
    WDTCSR |= (_BV(WDCE) | _BV(WDE));   // Enable the WD Change Bit
    WDTCSR = 0x00;                      // Disable the WDT
}

Configuration WDT

Ensuite, après avoir configuré le reste de la puce, refaites le WDT. La configuration du WDT nécessite une "séquence chronométrée", mais c'est vraiment facile à faire ...

// Set up Watch Dog Timer for Inactivity
WDTCSR |= (_BV(WDCE) | _BV(WDE));   // Enable the WD Change Bit
WDTCSR =   _BV(WDIE) |              // Enable WDT Interrupt
           _BV(WDP2) | _BV(WDP1);   // Set Timeout to ~1 seconds

Bien sûr, vos interruptions doivent être désactivées pendant ce code. Assurez-vous de les réactiver par la suite!

cli();    // Disable the Interrupts
sei();    // Enable the Interrupts

Routine de service d'interruption WDT La prochaine chose dont vous devez vous soucier est la manipulation de l'ISR WDT. Cela se fait comme tel:

ISR(WDT_vect)
{
  sleep_disable();          // Disable Sleep on Wakeup
  // Your code goes here...
  // Whatever needs to happen every 1 second
  sleep_enable();           // Enable Sleep Mode
}

Veille MCU

Plutôt que de mettre le MCU en veille à l'intérieur du WDT ISR, je recommande simplement d'activer le mode veille à la fin de l'ISR, puis de laisser le programme MAIN mettre le MCU en veille. De cette façon, le programme quitte réellement l'ISR avant de s'endormir, et il se réveillera et retournera directement dans l'ISR WDT.

// Enable Sleep Mode for Power Down
set_sleep_mode(SLEEP_MODE_PWR_DOWN);    // Set Sleep Mode: Power Down
sleep_enable();                     // Enable Sleep Mode  
sei();                              // Enable Interrupts 

/****************************
 *  Enter Main Program Loop  *
 ****************************/
 for(;;)
 {
   if (MCUCR & _BV(SE)){    // If Sleep is Enabled...
     cli();                 // Disable Interrupts
     sleep_bod_disable();   // Disable BOD
     sei();                 // Enable Interrupts
     sleep_cpu();           // Go to Sleep

 /****************************
  *   Sleep Until WDT Times Out  
  *   -> Go to WDT ISR   
  ****************************/

   }
 }

Selon la fiche technique, c'est possible. Vous pouvez même activer les deux, une interruption et la réinitialisation. Si les deux sont activés, le premier délai d'attente du chien de garde déclenchera l'interruption, ce qui provoquera la désactivation du bit d'activation d'interruption (interruption désactivée). Le prochain timeout réinitialisera alors votre CPU. Si vous activez l'interruption directement après son exécution, le prochain délai d'attente ne déclenchera (à nouveau) qu'une interruption.

Vous pouvez également simplement activer l'interruption et ne pas activer la réinitialisation du tout. Vous devrez régler le bit WDIE à chaque fois que l'interruption s'est déclenchée.

C'est beaucoup plus facile que suggéré ci-dessus et ailleurs.

Tant que le WDTONfusible n'est pas programmé (il n'est pas programmé par défaut), alors il vous suffit de ...

1. Définissez le bit d'activation d'interruption du chien de garde et le délai d'expiration dans le registre de contrôle du chien de garde.
2. Activez les interruptions.

Voici un exemple de code qui exécutera un ISR une fois toutes les 16 ms ...

ISR(WDT_vect) {
   // Any code here will get called each time the watchdog expires
}

void main(void) {
   WDTCR =  _BV(WDIE);    // Enable WDT interrupt, leave existing timeout (default 16ms) 
   sei();                                           // Turn on global interrupts
   // Put any code you want after here.
   // You can also go into deep sleep here and as long as 
   // global interrupts are eneabled, you will get woken 
   // up when the watchdog timer expires
   while (1);
}

C'est vraiment ça. Étant donné que nous n'activons jamais la réinitialisation du chien de garde, nous n'avons jamais à jouer avec les séquences chronométrées pour la désactiver. L'indicateur d'interruption du chien de garde est automatiquement effacé lorsque l'ISR est appelé.

Si vous souhaitez une période différente de chaque 1 seconde, vous pouvez utiliser ces valeurs ici pour définir les bits appropriés dans WDTCR...

Notez que vous devez exécuter la séquence chronométrée pour modifier le délai d'expiration. Voici le code qui définit le délai d'attente à 1 seconde ...

   WDTCR = _BV(WDCE) | _BV(WDE);                   // Enable changes
   WDTCR = _BV(WDIE) | _BV( WDP2) | _BV( WDP1);    // Enable WDT interrupt, change timeout to 1 second