STM32独立看门狗（宠物狗）

一、前言

······在由单片机构成的微型计算机系统中，由于单片机的工作常常会受到来自外界电磁场的干扰，造成程序的跑飞，而陷入死循环，程序的正常运行被打断，由单片机控制的系统无法继续工作，会造成整个系统的陷入停滞状态，发生不可预料的后果，所以出于对单片机运行状态进行实时监测的考虑，便产生了一种专门用于监测单片机程序运行状态的模块或者芯片，俗称“看门狗”(watchdog) ，其主要功能是：能够让CPU复位的一个硬件。

······看门狗（ watchdog timer）,是一个定时器电路, 一般有一个输入,叫喂狗(kicking the dog or service the dog),一个输出到MCU的RST端,MCU正常工作的时候,每隔一段时间输出一个信号到喂狗端,给WDT清零,重载计数值，如果超过规定的时间不喂狗,(一般在程序跑飞时，不在程序正常的状态),WDT 定时超过,就会给出一个复位信号到MCU,使MCU复位. 防止MCU死机.
看门狗的作用就是防止程序发生死循环，或者说程序跑飞。

······STM32 有两个看门狗，一个是独立看门狗另外一个是窗口看门狗， 独立看门狗号称宠物狗，窗口看门狗号称警犬。

······独立看门狗的初始化：初始化看门狗的超时时间，如果在规定的超时时间得不到程序“喂”操作，独立看门狗就立即复位系统。

独立看门狗的喂操作：重新刷新它的计数值，如果计数值减到0的时候，就立即复位CPU，为了防止复位CPU，程序必须每隔一段时间在它减到0之前刷新它的计数值，如此循环。

一、独立看门狗

独立看门狗 (IWDG) 由其专用低速时钟 (LSI) 驱动，因此即便在主时钟发生故障时仍然保持工作状态。

“独立”，这个独立表现在该看门狗有自己的振荡硬件电路，不用依靠于PPL分频的时钟信号，能够独立运行，所以当主时钟受到干扰的时候，独立看门狗还是仍然可以继续工作，如果没有正常喂狗，则会复位CPU。
用到32KHZ，收到的干扰较小，且能够 降低功耗。

1、主要特性
.自由运行递减计数器
.时钟由独立 RC 振荡器提供（可在待机和停止模式下运行）
.当递减计数器值达到 0x000 时产生复位（如果看门狗已激活）

如果要防止看门拘导致CPU复位，在计数值减到0之前，重载计数值就可以,这个动作“喂狗”!

注意：一般避免在while里面喂狗，怕不及时，一般放在定时器中断里面进行喂狗，但是定时器喂狗的计数时间要小于看门狗的计数时间。

2、功能说明

当通过对关键字寄存器 (IWDG_KR) 写入值 0xCCCC 启动独立看门狗时，计数器开始从复位值 0xFFF 递减计数。当计数器计数到终值 (0x000) 时会产生一个复位信号（IWDG 复位）。
任何时候将关键字 0xAAAA 写到 IWWDG_KR 寄存器中， IWDG_RLR 的值就会被重载到计数器，从而避免产生看门狗复位。

3、框图

STM32F4xx英文参考手册.pdf 第700页

4、库函数接口

a.解锁独立看够寄存器保护，对IWDG->KR写入0x5555。

• @brief Enables or disables write access to IWDG_PR and IWDG_RLR registers.
• @param IWDG_WriteAccess: new state of write access to IWDG_PR and IWDG_RLR registers.
• This parameter can be one of the following values:
• @arg IWDG_WriteAccess_Enable: Enable write access to IWDG_PR and IWDG_RLR registers
• @arg IWDG_WriteAccess_Disable: Disable write access to IWDG_PR and IWDG_RLR registers

void IWDG_WriteAccessCmd(uint16_t IWDG_WriteAccess)
{
    
    
  /* Check the parameters */
  assert_param(IS_IWDG_WRITE_ACCESS(IWDG_WriteAccess));
  IWDG->KR = IWDG_WriteAccess;
}

b.设置独立看门狗分频值

• This parameter can be one of the following values:
• @arg IWDG_Prescaler_4: IWDG prescaler set to 4
• @arg IWDG_Prescaler_8: IWDG prescaler set to 8
• @arg IWDG_Prescaler_16: IWDG prescaler set to 16
• @arg IWDG_Prescaler_32: IWDG prescaler set to 32
• @arg IWDG_Prescaler_64: IWDG prescaler set to 64
• @arg IWDG_Prescaler_128: IWDG prescaler set to 128
• @arg IWDG_Prescaler_256: IWDG prescaler set to 256

void IWDG_SetPrescaler(uint8_t IWDG_Prescaler)

c.设置独立看门狗重载值

• @brief Sets IWDG Reload value.
• @param Reload: specifies the IWDG Reload value.
• This parameter must be a number between 0 and 0x0FFF.

void IWDG_SetReload(uint16_t Reload)

d.独立看门狗重载计数值

• @brief Reloads IWDG counter with value defined in the reload register
• (write access to IWDG_PR and IWDG_RLR registers disabled).

void IWDG_ReloadCounter(void)

e.检查是否看门狗复位

为什么需要检查是否看门狗复位呢？用于记录当前系统工作可靠性，方便工程师了解。

• @brief Checks whether the specified RCC flag is set or not.
• @param RCC_FLAG: specifies the flag to check.
• This parameter can be one of the following values:
• @arg RCC_FLAG_HSIRDY: HSI oscillator clock ready
• @arg RCC_FLAG_HSERDY: HSE oscillator clock ready
• @arg RCC_FLAG_PLLRDY: main PLL clock ready
• @arg RCC_FLAG_PLLI2SRDY: PLLI2S clock ready
• @arg RCC_FLAG_PLLSAIRDY: PLLSAI clock ready (only for STM32F42xxx/43xxx devices)
• @arg RCC_FLAG_LSERDY: LSE oscillator clock ready
• @arg RCC_FLAG_LSIRDY: LSI oscillator clock ready
• @arg RCC_FLAG_BORRST: POR/PDR or BOR reset
• @arg RCC_FLAG_PINRST: Pin reset
• @arg RCC_FLAG_PORRST: POR/PDR reset
• @arg RCC_FLAG_SFTRST: Software reset
• @arg RCC_FLAG_IWDGRST: Independent Watchdog reset
• @arg RCC_FLAG_WWDGRST: Window Watchdog reset
• @arg RCC_FLAG_LPWRRST: Low Power reset
• @retval The new state of RCC_FLAG (SET or RESET).

FlagStatus RCC_GetFlagStatus(uint8_t RCC_FLAG)

5、计算超时时间

STM32F4xx中文参考手册.pdf 第495 表85

例如：当前独立看门狗输入时钟源为32KHz，若再经过256分频，此时独立看门狗时钟=32KHz/256=125Hz，表示的是125减到0的时候，一秒钟到达。
同时独立看门狗设置重载值为125，则溢出时间为1S;设置重载值为250，则溢出时间为2S。

#练习
按键实现独立看门狗喂狗。（以STM32F429为例）
bsp_iwdg.c文件

#include "./iwdg/bsp_iwdg.h"   
#include "./led/bsp_led.h"


void iwdg_config(void)
{
    
    
  /* 检查是否由独立看门狗导致的复位，如果发现经常由看门狗导致的复位，那么要检查软硬件问题 */
   if (RCC_GetFlagStatus(RCC_FLAG_IWDGRST) != RESET)
   {
    
    
    /* IWDGRST flag set */
     /* 亮红灯 */
		LED_RED;
    /* Clear reset flags，清除标志位 */
     RCC_ClearFlag();
   }
  else
  {
    
    
   /* IWDGRST flag is not set */
    /* 亮蓝灯 */
   	 LED_BLUE;
  }

	
   /* 独立看门狗寄存器是受到保护的，现在进行解锁动作*/
	IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable);

	//设置看门狗的时钟 40000/64=625HZ  表示的意思就是计数值从625减到1的时候，1秒钟的到达
	IWDG_SetPrescaler(IWDG_Prescaler_64);

   /* 设置重载数值，即超时时间 ，值区间在0-0XFFF，即0-4095
		获得1s的超时时间，即需要满足关系式：40 000 /64 / x =1s
		x= 625 ,x也在0-4095的区间内，所以满足需求
		如果要设置2s为超时时间，那么40000/64/y = 2s   y=625*2=1250
		最大的超时时间：4095/625 = 6.552s
    */   
  	 IWDG_SetReload(625);
 
	/* Reload IWDG counter，重载计数值，就是喂狗，可以写个feed_dog函数封装起来 */
	IWDG_ReloadCounter();

   /* Enable IWDG ，使能看门狗*/
  	 IWDG_Enable();
 

}

也可以封装起来,如下所示
/*
 * 设置 IWDG 的超时时间
 * Tout = prv/40 * rlv (s)
 *      prv可以是[4,8,16,32,64,128,256]
 *		独立看门狗使用LSI作为时钟。
 *		LSI 的频率一般在 30~60KHZ 之间，根据温度和工作场合会有一定的漂移，我
 *		们一般取 40KHZ，所以独立看门狗的定时时间并一定非常精确，只适用于对时间精度
 *		要求比较低的场合。
 *
 * rlv:预分频器值，取值范围为：0-0XFFF
 * 函数调用举例：
 * IWDG_Config(IWDG_Prescaler_64 ,625);  // IWDG 1s 超时溢出 
 *						（64/40）*625 = 1s
 */
void IWDG_Config(uint8_t prv ,uint16_t rlv)
{
    
    	
	// 使能 预分频寄存器PR和重装载寄存器RLR可写
	IWDG_WriteAccessCmd( IWDG_WriteAccess_Enable );
	
	// 设置预分频器值
	IWDG_SetPrescaler( prv );
	
	// 设置重装载寄存器值
	IWDG_SetReload( rlv );
	
	// 把重装载寄存器的值放到计数器中
	IWDG_ReloadCounter();
	
	// 使能 IWDG
	IWDG_Enable();	
}

// 喂狗
void IWDG_Feed(void)
{
    
    
	// 把重装载寄存器的值放到计数器中，喂狗，防止IWDG复位
	// 当计数器的值减到0的时候会产生系统复位
	IWDG_ReloadCounter();
}

bsp_iwdg.h

#ifndef __IWDG_H
#define	__IWDG_H
#include "stm32f4xx.h"
void IWDG_Config(uint8_t prv ,uint16_t rlv);
void IWDG_Feed(void);
void iwdg_config(void);
#endif /* __IWDG_H */

bsp_led.c

#include "./led/bsp_led.h"   

void LED_GPIO_Config(void)
{
    
    		
	/*定义一个GPIO_InitTypeDef类型的结构体*/
	GPIO_InitTypeDef GPIO_InitStructure;

	/*开启LED相关的GPIO外设时钟*/
	RCC_AHB1PeriphClockCmd ( LED1_GPIO_CLK|LED2_GPIO_CLK|LED3_GPIO_CLK|LED4_GPIO_CLK, ENABLE); 

	/*选择要控制的GPIO引脚*/															   
	GPIO_InitStructure.GPIO_Pin = LED1_PIN;	

	/*设置引脚模式为输出模式*/
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;   
    
    /*设置引脚的输出类型为推挽输出*/
    GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
    
    /*设置引脚为上拉模式，默认LED亮*/
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;

	/*设置引脚速率为50MHz */   
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz; 

	/*调用库函数，使用上面配置的GPIO_InitStructure初始化GPIO*/
	GPIO_Init(LED1_GPIO_PORT, &GPIO_InitStructure);	
    
    /*选择要控制的GPIO引脚*/															   
	GPIO_InitStructure.GPIO_Pin = LED2_PIN;	
    GPIO_Init(LED2_GPIO_PORT, &GPIO_InitStructure);	
    
    /*选择要控制的GPIO引脚*/															   
	GPIO_InitStructure.GPIO_Pin = LED3_PIN;	
    GPIO_Init(LED3_GPIO_PORT, &GPIO_InitStructure);	
		
	/*选择要控制的GPIO引脚*/															   
	GPIO_InitStructure.GPIO_Pin = LED4_PIN;	
    GPIO_Init(LED4_GPIO_PORT, &GPIO_InitStructure);	
		
	/*关闭RGB灯*/
	LED_RGBOFF;
		
	/*指示灯默认开启*/
	LED4(ON);
		
}

bsp_led.h

#ifndef __LED_H
#define	__LED_H

#include "stm32f4xx.h"

//引脚定义
/*******************************************************/
//R 红色灯
#define LED1_PIN                  GPIO_Pin_10                 
#define LED1_GPIO_PORT            GPIOH                      
#define LED1_GPIO_CLK             RCC_AHB1Periph_GPIOH

//G 绿色灯
#define LED2_PIN                  GPIO_Pin_11                 
#define LED2_GPIO_PORT            GPIOH                      
#define LED2_GPIO_CLK             RCC_AHB1Periph_GPIOH

//B 蓝色灯
#define LED3_PIN                  GPIO_Pin_12                 
#define LED3_GPIO_PORT            GPIOH                       
#define LED3_GPIO_CLK             RCC_AHB1Periph_GPIOH

//小指示灯
#define LED4_PIN                  GPIO_Pin_11                 
#define LED4_GPIO_PORT            GPIOD                       
#define LED4_GPIO_CLK             RCC_AHB1Periph_GPIOD
/************************************************************/


/** 控制LED灯亮灭的宏，
	* LED低电平亮，设置ON=0，OFF=1
	* 若LED高电平亮，把宏设置成ON=1 ，OFF=0 即可
	*/
#define ON  0
#define OFF 1

/* 带参宏，可以像内联函数一样使用 */
#define LED1(a)	if (a)	\
					GPIO_SetBits(LED1_GPIO_PORT,LED1_PIN);\
					else		\
					GPIO_ResetBits(LED1_GPIO_PORT,LED1_PIN)

#define LED2(a)	if (a)	\
					GPIO_SetBits(LED2_GPIO_PORT,LED2_PIN);\
					else		\
					GPIO_ResetBits(LED2_GPIO_PORT,LED2_PIN)

#define LED3(a)	if (a)	\
					GPIO_SetBits(LED3_GPIO_PORT,LED3_PIN);\
					else		\
					GPIO_ResetBits(LED3_GPIO_PORT,LED3_PIN)
					
#define LED4(a)	if (a)	\
					GPIO_SetBits(LED4_GPIO_PORT,LED4_PIN);\
					else		\
					GPIO_ResetBits(LED4_GPIO_PORT,LED4_PIN)


/* 直接操作寄存器的方法控制IO */
#define	digitalHi(p,i)			{p->BSRRL=i;}			  //设置为高电平		
#define digitalLo(p,i)			{p->BSRRH=i;}				//输出低电平
#define digitalToggle(p,i)		{p->ODR ^=i;}			//输出反转状态


/* 定义控制IO的宏 */
#define LED1_TOGGLE		digitalToggle(LED1_GPIO_PORT,LED1_PIN)
#define LED1_OFF		digitalHi(LED1_GPIO_PORT,LED1_PIN)
#define LED1_ON			digitalLo(LED1_GPIO_PORT,LED1_PIN)

#define LED2_TOGGLE		digitalToggle(LED2_GPIO_PORT,LED2_PIN)
#define LED2_OFF		digitalHi(LED2_GPIO_PORT,LED2_PIN)
#define LED2_ON			digitalLo(LED2_GPIO_PORT,LED2_PIN)

#define LED3_TOGGLE		digitalToggle(LED3_GPIO_PORT,LED3_PIN)
#define LED3_OFF		digitalHi(LED3_GPIO_PORT,LED3_PIN)
#define LED3_ON			digitalLo(LED3_GPIO_PORT,LED3_PIN)

#define LED4_TOGGLE		digitalToggle(LED4_GPIO_PORT,LED4_PIN)
#define LED4_OFF		digitalHi(LED4_GPIO_PORT,LED4_PIN)
#define LED4_ON			digitalLo(LED4_GPIO_PORT,LED4_PIN)


/* 基本混色，后面高级用法使用PWM可混出全彩颜色,且效果更好 */

//红
#define LED_RED  \
					LED1_ON;\
					LED2_OFF\
					LED3_OFF

//绿
#define LED_GREEN		\
					LED1_OFF;\
					LED2_ON\
					LED3_OFF

//蓝
#define LED_BLUE	\
					LED1_OFF;\
					LED2_OFF\
					LED3_ON

					
//黄(红+绿)					
#define LED_YELLOW	\
					LED1_ON;\
					LED2_ON\
					LED3_OFF
//紫(红+蓝)
#define LED_PURPLE	\
					LED1_ON;\
					LED2_OFF\
					LED3_ON

//青(绿+蓝)
#define LED_CYAN \
					LED1_OFF;\
					LED2_ON\
					LED3_ON
					
//白(红+绿+蓝)
#define LED_WHITE	\
					LED1_ON;\
					LED2_ON\
					LED3_ON
					
//黑(全部关闭)
#define LED_RGBOFF	\
					LED1_OFF;\
					LED2_OFF\
					LED3_OFF
					




void LED_GPIO_Config(void);

#endif /* __LED_H */

bsp_key.c

  
#include "./key/bsp_key.h" 

/// 不精确的延时
void Key_Delay(__IO u32 nCount)
{
    
    
	for(; nCount != 0; nCount--);
} 

/**
  * @brief  配置按键用到的I/O口
  * @param  无
  * @retval 无
  */
void Key_GPIO_Config(void)
{
    
    
	GPIO_InitTypeDef GPIO_InitStructure;
	
	/*开启按键GPIO口的时钟*/
	RCC_AHB1PeriphClockCmd(KEY1_GPIO_CLK|KEY2_GPIO_CLK,ENABLE);
	
  /*选择按键的引脚*/
	GPIO_InitStructure.GPIO_Pin = KEY1_PIN; 
  
  /*设置引脚为输入模式*/
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN; 
  
  /*设置引脚不上拉也不下拉*/
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
	
  /*使用上面的结构体初始化按键*/
	GPIO_Init(KEY1_GPIO_PORT, &GPIO_InitStructure);  
  
  
  /*选择按键的引脚*/
	GPIO_InitStructure.GPIO_Pin = KEY2_PIN; 
  
  /*使用上面的结构体初始化按键*/
	GPIO_Init(KEY2_GPIO_PORT, &GPIO_InitStructure);
  
  
}

/**
  * @brief   检测是否有按键按下
  * @param   具体的端口和端口位
  *		@arg GPIOx: x可以是（A...G） 
  *		@arg GPIO_PIN 可以是GPIO_PIN_x（x可以是1...16）
  * @retval  按键的状态
  *		@arg KEY_ON:按键按下
  *		@arg KEY_OFF:按键没按下
  */
uint8_t Key_Scan(GPIO_TypeDef* GPIOx,uint16_t GPIO_Pin)
{
    
    			
	/*检测是否有按键按下 */
	if(GPIO_ReadInputDataBit(GPIOx,GPIO_Pin) == KEY_ON )  
	{
    
    	 
		/*等待按键释放 */
		while(GPIO_ReadInputDataBit(GPIOx,GPIO_Pin) == KEY_ON);   
		return 	KEY_ON;	 
	}
	else
		return KEY_OFF;
}

bsp_key.h

#ifndef __KEY_H
#define	__KEY_H

#include "stm32f4xx.h"

//引脚定义
/*******************************************************/
#define KEY1_PIN                  GPIO_Pin_0                 
#define KEY1_GPIO_PORT            GPIOA                      
#define KEY1_GPIO_CLK             RCC_AHB1Periph_GPIOA

#define KEY2_PIN                  GPIO_Pin_13                 
#define KEY2_GPIO_PORT            GPIOC                      
#define KEY2_GPIO_CLK             RCC_AHB1Periph_GPIOC
/*******************************************************/

 /** 按键按下标置宏
	* 按键按下为高电平，设置 KEY_ON=1， KEY_OFF=0
	* 若按键按下为低电平，把宏设置成KEY_ON=0 ，KEY_OFF=1 即可
	*/
#define KEY_ON	1
#define KEY_OFF	0

void Key_GPIO_Config(void);
uint8_t Key_Scan(GPIO_TypeDef* GPIOx,u16 GPIO_Pin);

#endif /* __LED_H */

main.c

  
#include "stm32f4xx.h"
#include "./led/bsp_led.h"
#include "./key/bsp_key.h" 
#include "./iwdg/bsp_iwdg.h"
static void Delay(__IO u32 nCount); 
/*
现象是：如果1s内没进行按键喂狗，那么CPU复位，1S闪烁一次。
如果1S内喂狗成功，显示绿灯。
 */
int main(void)
{
    
    
	/* LED 端口初始化 */
	LED_GPIO_Config();	 
	Delay(0X8FFFFF);	
    /*初始化按键*/
    Key_GPIO_Config();	
	
	// IWDG 1s 超时溢出
	iwdg_config();
	//while部分是我们在项目中具体需要写的代码，这部分的程序可以用独立看门狗来监控
    //如果我们知道这部分代码的执行时间，比如是500ms，那么我们可以设置独立看门狗的
	//溢出时间是600ms，比500ms多一点，如果要被监控的程序没有跑飞正常执行的话，那么
	//执行完毕之后就会执行喂狗的程序，如果程序跑飞了那程序就会超时，到达不了喂狗的
	//程序，此时就会产生系统复位。但是也不排除程序跑飞了又跑回来了，刚好喂狗了，
	//歪打正着。所以要想更精确的监控程序，可以使用窗口看门狗，窗口看门狗规定必须
	//在规定的窗口时间内喂狗。
	while(1)                            
	{
    
    	   
		if( Key_Scan(KEY1_GPIO_PORT,KEY1_PIN) == KEY_ON  )
		{
    
    
			// 喂狗，如果不喂狗，系统则会复位，复位后亮红灯，如果在1s
			// 时间内准时喂狗的话，则会亮绿灯
				IWDG_ReloadCounter();  
			//喂狗后亮绿灯
				LED_GREEN;
		}
	}
}

static void Delay(__IO uint32_t nCount)	 //简单的延时函数
{
    
    
	for(; nCount != 0; nCount--);
}

不过，最好是在定时器中断进行喂狗！！！！主程序中的事件多了可能来不及处理