AVR Freaks

Which compliler you have using?

If AVRGCC then it's for you

For wiki: http://microchipdeveloper.com/8a...
For <avr/wdt.h>: https://www.nongnu.org/avr-libc/...

And https://www.pocketmagic.net/avr-...

#include <avr/io.h>
#include <avr/interrupt.h>

#include <avr/wdt.h> /*Watchdog timer handling*/

int main(void)
{
	/*First step is Enable Watchdog*/
	wdt_enable(WDTO_8S); /*Watchdog Reset after 8Sec*/
			     /*WDTO_15MS , WDTO_30MS..etc for deffernt time*/
				/*for more time*/
			     /*https://www.nongnu.org/avr-libc/user-manual/group__avr__watchdog.html */

	while(1)
	{
		/*Here your code executing*/
		/*Then second step for Watchdog is Reset you Watchdog timer*/
		wdt_reset();
	}
}

+1 to what Mike just said.

But note that in all but the most trivial program watchdog is not something you bolt on at the end when  everything else is done and then you think "I think I'll throw in a bit of last minute protection".

Watchdog should be something you design in from the start and every subsequent design decision is predicated on "how will this interact with the watchdog?"

I use the watchdog in an M328P much as you describe. In my case, I have it as a failsafe for sleep, in case the wakeup event fails to happen while it is sleeping (it could, possibly happen other times, and never wake it up). So, I do turn it on and off. It works fine. 

The important thing to remember about watchdog is that you have to pet it just right. It takes TWO operations (within, I think, 4 MCU clock cycles) to change the operating mode and maybe the timeout interval. 

For a failsafe like this, you really never need to reset it. You start it, just before the operation to be guarded, begins. You stop it when that operation is over. BUT, be very careful about that remote possibility that the watchdog might time out and get hungry. So, you need to make sure that you do, or don't ( depending on the MCU you use ) have the interrupt service routine and that you have the necessary control bits set so that it all does what you want.

Jim

Jack Ganssle has written some nice documentation / tutorials about effective use of watchdog timers.

https://duckduckgo.com/html?q=jack+ganssle+watchdog+tutorial

int main(void) {
    while(1) {
        PORTB = rand();
    }
    PORTB = 0x55;
}

I bet the compiler will even warn you about "unreachable code". There is no way that PORTB = 0x55 line can ever be reached. Of course if I wrote:

int main(void) {
    while(1) {
        PORTB = rand();
        if (somecondition) break;
    }
    PORTB = 0x55;
}

then there is a chance that it could be.

https://www.nongnu.org/avr-libc/user-manual/group__avr__watchdog.html

and specifically this:

Note that for newer devices (ATmega88 and newer, effectively any AVR that has the option to also generate interrupts), the watchdog timer remains active even after a system reset (except a power-on condition), using the fastest prescaler value (approximately 15 ms). It is therefore required to turn off the watchdog early during program startup, the datasheet recommends a sequence like the following:

#include <stdint.h>

#include <avr/wdt.h>

uint8_t mcusr_mirror __attribute__ ((section (".noinit")));

void get_mcusr(void) \
     __attribute__((naked)) \
     __attribute__((section(".init3")));
void get_mcusr(void)
{
    mcusr_mirror = MCUSR;

    MCUSR = 0;

    wdt_disable();

}

Saving the value of MCUSR in mcusr_mirror is only needed if the application later wants to examine the reset source, but in particular, clearing the watchdog reset flag before disabling the watchdog is required, according to the datasheet.

Your 328 is in the aforementioned family of mega88 etc. 

Bottom line - switch it off in early start up code.

EDIT: and now I just read the whole thread and not just the recent posts. So #16 already said this ?!?! If you read that why did you post?

Obviously the first code that runs after power on has to be the code to disable the watchdog in the limited time window available. So, yes, if a bootloader is involved it has to be part of your watchdog strategy. I would implore you to reread this entire thread. The point was already made that watchdog use is something that should be designed in at the very core of your design from the outset. It's not a thing where you can really finish the main project then, as an afterthought, you think "OK, now to add a bit of watchdog" at the end. If you had approached the design like this it would probably have a bearing on whether you use a bootloader at all and, if you do, continuation of watchdog handling would be part of its initial design.

Done, I grabbed USBASP and changed boot loader to optiboot and now watchdog works as expected.

My personal opinion: Not disabling watchdog on watchdog reset may be a bad feature of Atmega328P. Any specific reason why this may be a desired feature for others? I am just a level 0 hobby developer in embedded and may not be able to comment much on this. I have not worked on any other controllers and hence cannot compare with other chips.

The whole point of any watchdog is to prevent against faulty software.

If the watchdog could be disabled by software, then faulty software could (accidentally or otherwise) disable it when it shouldn't.