Use AVR watchdog like normal ISR

Question

I'm trying to wrap my head around the watchdog timer on the ATtinyX5 series. Things I've read made it seem like you could use it for making the program do something specific ever N seconds, but never really showed how. Others made it seem like it would only reset the chip unless something in code resets its count in the meantime (which seems to be the "normal" usage).

Is there any way of using the WDT like you would TIMER1_COMPA_vect or similar? I noticed that it has a 1 second timeout mode and I would really love to be able to use that to make something happen every second in my code (and preferably sleep inbetween).

Thoughts?

Update: Since it was asked, what I'm referring to is section 8.4 of the ATtinyX5 datasheet. Not that I fully understand it, which is my problem.

Answer 1

You most certainly can. According to the datasheet, the watchdog timer can be setup to reset the MCU or cause an interrupt when it triggers. It seems you are more interested in the interrupt possibility.

The WDT is actually easier to setup than a normal Timer for the same reason it is less useful: fewer options. It runs on an internally calibrated 128kHz clock, meaning its timing is not effected by the main clock speed of the MCU. It can also continue to run during the deepest sleep modes to provide a wake up source.

I will go over a couple of the datasheet examples as well as some code I have used (in C).

Included Files and Definitions

To start, you will probably want to include the following two header files for things to work:

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

Also, I use the Macro <_BV(BIT)> which is defined in one of the standard AVR headers as the following (which might be more familial to you):

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

Beginning of Code

When the MCU is first started, you would typically initialize the I/O, set up timers, etc. Somewhere here is a good time to make sure the WDT didn't cause a reset because it could do it again, keeping your program in an unstable loop.

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
}

WDT Setup

Then, after you have setup the rest of the chip, redo the WDT. Setting up the WDT requires a "timed sequence," but it is really easy to do...

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

Of course, your interrupts should be disabled during this code. Be sure to re-enable them afterwards!

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

WDT Interrupt Service Routine The next thing to worry about is handling the WDT ISR. This is done as such:

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
}

MCU Sleep

Rather than put the MCU to sleep inside of the WDT ISR, I recommend simply enabling the sleep mode at the end of the ISR, then have the MAIN program put the MCU to sleep. That way, the program is actually leaving the ISR before it goes to sleep, and it will wake up and go directly back into the WDT ISR.

// 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   
  ****************************/

   }
 }

Answer 2

According to the datasheet it is possible. You can even enable both, an interrupt and the reset. If both are enabled, the first watchdog timeout will trigger the interrupt which causes the Interrupt Enable bit to be unset (interrupt disabled). The next timeout will then reset your CPU. If you enable the Interrupt directly after it was executed, the next timeout will (again) trigger only an interrupt.

You can also just enable the interrupt and not enable the reset at all. You will have to set the WDIE bit every time the interrupt has triggered.

Answer 3

This is much easier than suggested above and elsewhere.

As long as the WDTON fuse is not programmed (it is not programmed by default), then you need only...

1. Set the watchdog interrupt enable bit and the timeout in the watchdog control register.
2. Enable interrupts.

Here is a code example that will execute an ISR once per 16ms...

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

That is really it. Since we never enable the watchdog reset, we never have to mess around with the timed sequences to disable it. The watchdog interrupt flag automatically gets cleared when the ISR is called.

If you want a period different than every 1 second, you can use these values here to set the apropriate bits in WDTCR...

Note that you do need to execute the timed sequence to change the timeout. Here is code that sets the timeout to 1 second...

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