STM32 independent watchdog

At first, LED1 is on and LED2 is off. If KEY1 is pressed at regular intervals, LED2 will flash continuously because the independent watchdog resets the system. If KEY1 is pressed intermittently, LED2 will not flash, indicating that it has not been reset.

experiment platform:

Color screen development board based on STM32F103C8T6

Steps:

1) Write 0X5555 to IWDG_KR.
Through this step, we cancel the write protection of IWDG_PR and IWDG_RLR, so that these two registers can be operated later.
Set the values ​​of IWDG_PR and IWDG_RLR.
These two steps set the watchdog frequency division coefficient and the reload value. From this, we can know the feeding time of the watchdog (that is
, the watchdog overflow time), which is calculated as follows:
Tout=((4×2^prer) ×rlr)/40
, where Tout is the watchdog overflow time (in ms); prer is the watchdog clock prescaler value (IWDG_PR value),
ranging from 0 to 7; rlr is the watchdog reload value (IWDG_RLR value);
for example, if we set the prer value to 4 and the rlr value to 625, we can get Tout=64×625/40=1000ms, so
the watchdog overflow time is 1s. As long as you write 0XAAAA to IWDG_KR once within one second, the watchdog will not be reset (of course, writing multiple times is also possible). Here we need to remind everyone that the watchdog clock is not an accurate
40Khz, so it is best not to feed the dog too late, otherwise, the watchdog may be reset.

2) Write 0XAAAA to IWDG_KR.
This command will cause STM32 to reload the value of IWDG_RLR into the watchdog counter. This command can also be used
to feed the watchdog.
3) Write 0XCCCC to IWDG_KR.
This command starts the STM32 watchdog. Note that once IWDG is enabled, it cannot be turned off! If you want to turn it off
, you can only restart it, and you cannot turn on IWDG after restarting, otherwise the problem will remain. So here I remind you that if you don’t
use IWDG, don’t turn it on to avoid trouble.
Through the above 3 steps, we can start the STM32 watchdog. After enabling the watchdog,
you must feed the watchdog at intervals in the program, otherwise it will cause the program to reset. Using this, we use an LED light to indicate
whether the program is restarted to verify the independent watchdog of STM32.

Part of the program code:

     watchdong.h

#ifndef WATCHDOG_H
#define WATCHDOG_H
void WatchDog_Init(u8, u16);//Declare the watchdog initialization function
void WatchDog_Feed(void);//Declare the dog feeding function
#endif

    watchdong.c

#include "common.h"
#include "watchdog.h"
//Watchdog initialization, parameters: prer-frequency division, reld-counter reload value
void WatchDog_Init(u8 prer, u16 reld)
{
   IWDG->KR=0x5555; //Allow access to PR and RLR registers
   IWDG->PR=prer;   //Set frequency division
   IWDG->RLR=reld; //Set counter initial value
   IWDG->KR=0xaaaa;  //Initial initial value
   IWDG->KR=0xcccc;   //Start watchdog timer
}

//Feed the dog
void WatchDog_Feed(void)
{
 IWDG->KR=0xaaaa;
}
This code has two functions. void IWDG_Init(u8 prer, u16 rlr) is the independent watchdog initialization function, which is to
initialize the independent watchdog according to the steps described above. This function has two parameters, which are used to set the pre-scaling number and the reload
register value. Through these two parameters, you can roughly know the time period of the watchdog reset. The calculation method
is described in detail above, so I won’t say more here.
void IWDG_Feed(void) function, this function is used to feed the dog, because the STM32 dog feeding only needs to write
0XAAAA to the key value register,

    Main function
#include
#include"common.h"
#include"led.h"
#include"key.h"
#include"watchdog.h"
int main(void)
{
 u8 temp2;
 Stm32_Clock_Init(9);    //System clock setting
 delay_init(72);     //Delay initialization
 LED_Init();     //LED initialization
 KEY_Init();
 WatchDog_Init(4,625);  //Watchdog initialization
 LED1=1;
 LED2=0;
 while(1)
 {
   temp2=KEY_Scan(); //Read key value
   if(temp2==1)
    WatchDog_Feed();  //Feed the dog
  
 }
}