实现独立看门狗IWDT驱动，创建喂狗线程，实现喂狗功能

发布于 2020-03-27 17:26:02 浏览：6459 订阅该版

69 个回答

BruceTan 2020-03-29

这家伙很懒，什么也没写！

[i=s] 本帖最后由 谭卓琳 于 2020-3-29 23:44 编辑 [/i]

一、开发环境：

1、硬件环境：野火霸道F103开发板

2、软件环境：RT-Thread Nano 源码、ST 3.5固件库、MDK5.25

二、实验步骤：

1、准备一个裸机工程，添加RT-Thread Nano 源码、移植FinSH组件，实现RT_kprintf打印函数。以上操作过程按照老师的视频一步一步进行操作就行啦，这里只把移植以后的工程目录贴上。

![110,0](https://www.rt-thread.org/qa/forum.php?mod=image&aid=14324&size=300x300&key=f8b00198260321fc&nocache=yes&type=fixnone)

2、添加看门狗驱动和喂狗函数。

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

3、创建喂狗线程，这里使用的是何老师经过抽象以后的线程创建方式，使的代码看起来比较简洁。

```
TaskStruct TaskThreads[] = {
                
    {"iwdg_thread", iwdg_thread_entry, RT_NULL, 512, 15, 10},/* 在这里添加喂狗线程 */
    {"led_thread", led_thread_entry, RT_NULL, 512, 15, 10},
    {"msg_process_thread", msg_process_thread_entry, RT_NULL, 512, 2, 10},        
    {"usart2_recv_thread", usart2_recv_thread_entry, RT_NULL, 512, 2, 10},

/*********************************************************/
    //用户添加线程参数
    //例如：{线程名字,线程入口函数,线程入口函数参数,线程栈大小,线程的优先级,线程时间片},
                
    {" ", RT_NULL, RT_NULL, RT_NULL, RT_NULL, RT_NULL},

};
```

4、实现喂狗线程入口函数，实现喂狗操作。

```
void iwdg_thread_entry(void *parameter)
{
    IWDG_Config(IWDG_Prescaler_64 ,1250);  /* IWDG 2s 超时溢出 */
        
    while(1)
    {
        IWDG_Feed();
        rt_thread_mdelay(1000);/* 每隔 1s 进行喂狗操作 */
    }
}
```

5、下载程序，工作一切正常。

![110,0](https://www.rt-thread.org/qa/forum.php?mod=image&aid=14325&size=300x300&key=749f9a8e8139141b&nocache=yes&type=fixnone)

6、将喂狗时间改为2200ms，看门狗溢出，单片机复位，说明之前的喂狗操作是有效的。

![110,0](https://www.rt-thread.org/qa/forum.php?mod=image&aid=14326&size=300x300&key=d284b7ea08dd5c36&nocache=yes&type=fixnone)

三、总结。

第一次使用RTOS，以前代码都是裸机操作。今天是礼拜天，刚好有时间就把第一周的视频都看了，实验也都动手实操了一遍（最后的按键去抖那部分还没实验完哈哈哈），这个培训我最大的收获其实感觉并不仅仅是RTOS，更有触动的是视频里面的一些思路，感觉挺实用的（也可能我是小白），例如所有的头文件都是通过config.h进行管理，这样源文件就不会包含一大堆的头文件了，通过宏定义  EXT  为  extern  和  EXT  为空，来避免全局变量的冲突，并且还把创建线程给封装了一下，使代码更加简洁，忍不住夸一波666呀。希望小伙伴们也能好好学习，天天向上哈哈哈。

风雨潇潇 2020-03-28

这家伙很懒，什么也没写！

[i=s] 本帖最后由 风雨潇潇 于 2020-3-28 13:53 编辑 [/i]

本次学习采用的是朱有鹏老师NBL476的开发板。
使用STM32CUBEMX创建L476的工程，添加需要的外设，USART和IWDG，配置好是时钟，生成Keil工程；
[attach]14272[/attach][attach]14273[/attach]
打开keil工程，导入rtthread的nano包，在工程中添加RTOS；
[attach]14274[/attach]
修改中断文件的函数，注释即可；
在board.c文件中将系统时钟和外设的初始化函数移到rt_hw_board_init()函数中；
[attach]14275[/attach]
同时注释掉主程序里面的初始化函数，因为已经在rt_hw_board_init中初始化过了，
参考官方文档，移植finish控制台工能；
创建两个线程，一个是LED闪烁线程，一个是看门刷新线程，

```
void Iwdg_Init(void)
{
        
        iwdg_thread = rt_thread_create("iwdgThread",
                                                                                                                                        iwdg_thread_entry,
                                                                                                                                        RT_NULL,
                                                                                                                                        256,
                                                                                                                                        2,
                                                                                                                                        10);
        if(iwdg_thread != RT_NULL)
        {
                rt_thread_startup(iwdg_thread);
        }
}

void iwdg_thread_entry(void *parameter)
{
        while(1)
        {
                rt_thread_mdelay(2000);
                rt_kprintf("IWDG_Refresh\n");
                HAL_IWDG_Refresh(&hiwdg);
        }
}
```

[attach]14276[/attach][attach]14277[/attach]

xinmeng_wit 2020-03-28

这家伙很懒，什么也没写！

一、开发环境

1.硬件环境：沁恒无线CH579开发板，基于cortex-m0的mcu芯片。
2.软件环境：keil mdk5

定义了2个线程：
1.led闪烁的线程，1s闪烁一次
2.看门狗喂狗线程，500ms喂狗一次

线程代码如下：

1.led线程：

```
#include "CH57x_common.h"
#include "board.h"
#include "rtthread.h"

//函数申明

static void led_thread_entry(void *parameter);

static rt_thread_t led_thread=RT_NULL;//定义线程控制块

void led_init(void)
{
	GPIOB_ModeCfg(GPIO_Pin_0,GPIO_ModeOut_PP_20mA);
	R32_PB_OUT|=(1<<0);
	GPIOB_ModeCfg(GPIO_Pin_1,GPIO_ModeOut_PP_20mA);
	R32_PB_OUT|=(1<<1);
}

int led_thread_create(void)
{
//led的线程创建
	led_thread=rt_thread_create("led1",
																led_thread_entry,
																RT_NULL,
																512,
																3,
																20);//线程创建

if(led_thread!=RT_NULL)
		rt_thread_startup(led_thread);//启动线程，开始调度
	else
		return -1;
}

static void led_thread_entry(void *parameter)
{
	while(1)
	{
		GPIOB_SetBits(GPIO_Pin_0);
		rt_thread_delay(1000);
		GPIOB_ResetBits(GPIO_Pin_0);
		rt_thread_delay(1000);
		rt_kprintf("System running time:%d s\r\n",rt_tick_get()/RT_TICK_PER_SECOND);
	}
}
```

2.看门狗线程

```
#include "CH57x_common.h"
#include "board.h"
#include "rtthread.h"

void wdt_init(void)
{
	R8_SAFE_ACCESS_SIG=0x57;//解锁安全区域
	R8_SAFE_ACCESS_SIG=0xA8;
	
	R8_RST_WDOG_CTRL|=RB_WDOG_RST_EN;//使能看门狗
	R8_WDOG_COUNT=0;//看门狗计数器清零
}

//函数申明

static void wdt_thread_entry(void *parameter);

static rt_thread_t wdt_thread=RT_NULL;//定义线程控制块

int wdt_thread_create(void)
{
//led的线程创建
	wdt_thread=rt_thread_create("wdt",
																wdt_thread_entry,
																RT_NULL,
																512,
																4,
																20);//线程创建

if(wdt_thread!=RT_NULL)
		rt_thread_startup(wdt_thread);//启动线程，开始调度
	else
		return -1;
}

static void wdt_thread_entry(void *parameter)
{
	wdt_init();
	while(1)
	{
		R8_SAFE_ACCESS_SIG=0x57;//解锁安全区域
		R8_SAFE_ACCESS_SIG=0xA8;
		R8_WDOG_COUNT=0;//看门狗计数器清零		
		rt_thread_delay(500);
	}
}

```

同样，也按照老师的方法实现了rt_kprintf函数的重定向，和finsh组件的实现。

具体运行效果如下：

[attach]14282[/attach]

[attach]14283[/attach]

瑞尧 2020-03-29

这家伙很懒，什么也没写！

[i=s] 本帖最后由 瑞尧 于 2020-3-29 03:18 编辑 [/i]

开发环境：自制开发板（STM32F407ZG）+RTT Studio
根据视频内容配置工程，将finsh控制支持，以及rt_kprintf重定向（虽然studio自带配置，但还是建议跟着视频走一遍，熟悉操作）

使用STM32Cubemx配置iwdg为定时2s刷新

线程：
定义看门狗线程，定时1s喂狗

同时编写一个停止函数修改定时时间，检查看门狗是否能正常工作。

看门狗配置函数：

```
static int rt_hw_iwdg_init(void)
{
    hiwdg.Instance = IWDG;
    hiwdg.Init.Prescaler = IWDG_PRESCALER_32;
    hiwdg.Init.Reload = 2000;
    if (HAL_IWDG_Init(&hiwdg) != HAL_OK)
    {
        Error_Handler();
    }
    return RT_EOK;
}
```

看门狗线程函数：

```
void iwdg_thread_entry(void *parameter)
{
    while(1)
    {
        rt_thread_mdelay(1000);
        if(isStart)
        {
            HAL_IWDG_Refresh(&hiwdg);
            rt_kprintf("feed iwdg ok!\r\n");
        }
    }
}

static int iwdg_Init(void)
{
    rt_thread_t tid = RT_NULL;
    tid = rt_thread_create("iwdg", iwdg_thread_entry, RT_NULL,
                           1024, 20, 10);

if(tid != RT_NULL)
    {
        rt_kprintf("iwdg thread start!\r\n");
        rt_thread_startup(tid);
    }
    return RT_EOK;
}
```

修改溢出时间函数：

```
void stop_iwdg(void)
{
    rt_kprintf("stop feed iwdg!\r\n");
    hiwdg.Instance->RLR = 500;
}
```

运行结果如下：
[attach]14288[/attach]

系统正常运行，并进行正确喂狗。

人为造成看门狗超时溢出，看门狗复位，结果如下：
[attach]14289[/attach]

以上便是本次实验的所有内容。
（PS:本次实验中，所有的配置都采用了自动初始化及MSH-EXPORT操作，本人比较习惯是使用自动初始化，特此推荐。)

MrZhou 2020-03-29

这家伙很懒，什么也没写！

[i=s] 本帖最后由 MrZhou 于 2020-3-29 17:11 编辑 [/i]

一、准备工作
硬件准备：
STM32F103RCT6（本人使用正点原子的MINI板）
ST-LINK
USB转TTL模块
软件准备：
KEIL5 MDK
STM32CubeMX

二、使用STM32CubeMX生成MDK工程
使用STM32CubeMX创建STM32F103RBT6的对应工程，配置时钟源，使能GPIO、UART、IWDT，配置时钟树。
配置预览效果，配置PA8引脚为推挽输出，用于LED灯闪烁。
 [attach]14301[/attach]
STM32F103RBT6的最大主频为72M，配置PLL选择外部时钟。
 [attach]14293[/attach]
生成KEIL MDK工程。
 [attach]14294[/attach]
二、添加RT-Thread Nano到工程
打开MDK工程，添加RT-Thread Nano组件，具体可参考官方《基于Keil MDK移植RT-Thread Nano》文档，链接为[https://www.rt-thread.org/document/site/tutorial/nano/nano-port-keil/an0039-nano-port-keil/](https://www.rt-thread.org/document/site/tutorial/nano/nano-port-keil/an0039-nano-port-keil/)。
主要分为以下几个步骤：
1.        注释掉STM32CubeMX生成的PendSV，HardFault，SysTick。
2.        将main.c中的板级初始化函数，系统时钟配置函数移到board.c中，替换RTT的配置。
3.        移植FinSH，实现rt_hw_console_output()函数。
/* USER CODE BEGIN 1 */
void rt_hw_console_output(const char *str)

```
{
    /* empty console output */
         rt_size_t i = 0, size = 0;
     char a = '\r';

//    __HAL_UNLOCK(&huart1);
        rt_enter_critical();
    size = rt_strlen(str);
    for (i = 0; i < size; i++)
    {
        if (*(str + i) == '\n')
        {
            HAL_UART_Transmit(&huart1, (uint8_t *)&a, 1, 1);
        }
        HAL_UART_Transmit(&huart1, (uint8_t *)(str + i), 1, 1);
    }
        rt_exit_critical();
        
}
```

三、编写代码
主要实现两个功能，LED闪烁和IWDG喂狗。
1.        在main函数中创建两个线程

```
tid1 = rt_thread_create("iwdg", 
                                                        iwdg_thread_entry,
                                                        RT_NULL,
                                                        THREAD_STACK_SIZE,
                                                        THREAD_PRIORITY,
                                                        THREAD_TIMESLICE);
        if(tid1 != RT_NULL)
        {
                rt_thread_startup(tid1);
        }
                
        
        tid2 = rt_thread_create("led", 
                                                led_thread_entry,
                                                RT_NULL,
                                                THREAD_STACK_SIZE,
                                                THREAD_PRIORITY - 1,
                                                THREAD_TIMESLICE);
        
        
        if(tid2 != RT_NULL)
        {
                rt_thread_startup(tid2);
        }
```

2.        LED线程

```
static void led_thread_entry(void *param)
{
        MX_GPIO_Init();
        while(1)
        {
                HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);
                rt_thread_mdelay(500);
                HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);
                rt_thread_mdelay(500);
//                rt_kprintf("hello, led\n");
        }
        
}
```

3.        IWDG线程

```
static void iwdg_thread_entry(void *param)
{
        MX_IWDG_Init();
        while(1)
        {
                HAL_IWDG_Refresh(&hiwdg);
                rt_kprintf("feed iwdg\n");
                rt_thread_mdelay(1000);
       }  
}

```

注意计算iwdg的溢出时间，本文设置的溢出时间约为3.276s，预分频值为32，看门狗时钟为40kHz。
 [attach]14295[/attach]
计算看门狗溢出时间：
1.方式一
分频后的频率：IWDG时钟/分频值 = 40KHz/32 = 1.25KHz
溢出时间：设置的装填值/分频后的频率 = 4095/1.25KHz = 3276ms=3.276s
2.方式二
用户手册的公式给定公式，看门狗溢出时间：Tout=((4×2^prer) ×rlr) /40KHz，其中Tout 为看门狗溢出时间（单位为ms），prer为看门狗时钟预分频值（IWDG_PR 值）， 范围为0~7；rlr 为看门狗的重装载值（IWDG_RLR 的值）。
我们在STM32CubeMX中设置分频值为32，相当于(4×2^prer = 32)，prer = 3，rlr = 4095，故有
Tout=((4×2^prer) ×rlr) /40KHz =((4×2^3) ×4095) /40KHz = 3276ms。
其实也很好理解，看门狗定时器是一个递减的定时器，从给定的计算值递减到0时就会产生看门狗复位（如果不喂狗），我们设置的计数值4095，看门狗计一次数的时间为32/40kHz，故总时间就等于计数值*一次计数的时间。
四、下载验证
现象：
        1.看门狗每1s喂一次狗。
[attach]14296[/attach]
        2.led灯以1Hz的频率闪烁。
[attach]14297[/attach]

至此，RTT中的独立看门狗结束。

赵撵猪 2020-03-29

这家伙很懒，什么也没写！

403463275 2020-03-30

啥都不懂

[i=s] 本帖最后由 403463275 于 2020-3-30 14:01 编辑 [/i]

1.移植RT-Thread Nano过程略去。
2.在Dev文件夹下新建 wdt.c和wdt.h
wdt.h文件内容：

```
#ifndef __WDT_H__
#define __WDT_H__

#include "config.h"

void IWDG_Init(u8 prer,u16 rlr);
void IWDG_Feed(void);

#endif

```

wdt.c文件内容：

```
#include "config.h"
#include "wdt.h"

void IWDG_Init(u8 prer,u16 rlr) 
{        
         IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable);  //使能对寄存器IWDG_PR和IWDG_RLR的写操作
        
        IWDG_SetPrescaler(prer);  //设置IWDG预分频值:设置IWDG预分频值为64
        
        IWDG_SetReload(rlr);  //设置IWDG重装载值
        
        IWDG_ReloadCounter();  //按照IWDG重装载寄存器的值重装载IWDG计数器
        
        IWDG_Enable();  //使能IWDG
}
//喂独立看门狗
void IWDG_Feed(void)
{   
         IWDG_ReloadCounter();                                                                                   
}

```

然后在Task.c文件中进行变量定义
static rt_thread_t wdt_thread;
并添加创建线程并开启线程

```
wdt_thread = rt_thread_create("wdtThread",       /* 线程名字 */
                                wdt_thread_entry,  /* 线程入口函数 */
                                RT_NULL,           /* 线程入口函数参数 */
                                256,               /* 线程栈大小 */
                                2,                 /* 线程的优先级 */
                                10                 /* 线程时间片 */
                                       );
        if(wdt_thread != RT_NULL)
        {
                rt_thread_startup(wdt_thread);
        }
```

线程代码为：

```
void wdt_thread_entry(void *parameter)
{
        IWDG_Init(4,625);    //与分频数为64,重载值为625,溢出时间为1s        
        while(1)
        {
                LedToggle(GPIOA,GPIO_Pin_8);
                IWDG_Feed();//则喂狗
          rt_thread_mdelay(800);        
        }
}
```

验证结果：
GPIOA_8闪烁正常，
注释掉IWDG_Feed();后串口终端每隔1S打印一次版本信息，说明该线程正常运行，且看门狗程序正常运行。
[attach]14333[/attach]
输入list_thread，可以看到线程信息
[attach]14334[/attach]

。。。 2020-03-30

这家伙很懒，什么也没写！

[i=s] 本帖最后由 。。。 于 2020-3-30 14:54 编辑 [/i]

创建独立看门狗驱动以及喂狗函数如下：

```
/*
 * 设置 IWDG 的超时时间
 * Tout = prv/40 * rlv (s)
 *   
 * prv:预分频器值，取值如下：
 *     @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
 *
 * rlv:预分频器值，取值范围为：0-0XFFF
 */
 
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();        
}

跟着何老师学习，创建了喂狗的线程如下：

```
static rt_thread_t tid;

static void IWDG_thread_entry(void *parameter)
{
  while(1)
  {
    rt_thread_mdelay(1500);//喂狗的时间间隔
    IWDG_Feed();//喂狗
    rt_kprintf("\nFeeding dog success\n");//喂狗成功打印出"Feeding dog success"语句
  }
}

void TaskInit(void)
{
tid = rt_thread_create("IWDG_thread",   /*线程名称*/
                        IWDG_thread_entry, /*线程入口函数名*/
                        RT_NULL,      /*线程入口函数参数*/
                        256,      /*线程栈大小*/
                        2,        /*线程的优先级*/
                        10);      /*线程时间片*/

if (tid != RT_NULL)
        rt_thread_startup(tid); 
}
```

仿真中线程查询结果如下图：[attach]14340[/attach]

喂狗超时溢出时间设置为2秒。
当喂狗时间没有超时溢出时，仿真结果如下图：
[attach]14338[/attach]
每一次喂狗成功都会打印出“Feeding dog success”；

调整喂狗时间使得超时溢出，仿真结果如下图：
[attach]14339[/attach]

code_404 2020-03-30

这家伙很懒，什么也没写！

[i=s] 本帖最后由 code_404 于 2020-3-30 15:34 编辑 [/i]

[md]作业一：实现独立看门狗IWDT驱动，创建喂狗线程，实现喂狗功能

rtt_iwdg_task.h

```c
/*
 * File      : rtt_iwdg_task.h
 * This file is header of rtt_iwdg_task.c 
 *
 * Change Logs:
 * Date           Author       Notes
 * 2020-03-30     code_404     
 * ...
 */

#ifndef __RTT_IWDG_TASK_H__
#define __RTT_IWDG_TASK_H__

#include <rtthread.h>
#include "main.h"

#define THREAD_STACKSIZE    512
#define THREAD_PRIORITY     20
#define THREAD_TIMESLICE    5

extern IWDG_HandleTypeDef hiwdg;

void MX_IWDG_Init(void);
static void iwdg_timer_entry(void *parameter);
static void iwdg_thread_entry(void *parameter);
int iwdg_thread_task(void);

#endif /* __RTT_IWDG_TASK_H__ */

```

rtt_iwdg_task.c

```
/*
 * File      : rtt_iwdg_task.c
 * This file is iwdg task that is part of RT-Thread Nano Task ONE 
 *
 * Change Logs:
 * Date           Author       Notes
 * 2020-03-30     code_404     
 * ...
 */
 
#include "rtt_iwdg_task.h"

IWDG_HandleTypeDef hiwdg;

static rt_timer_t  iwdg_timer  = RT_NULL;
static rt_thread_t iwdg_thread = RT_NULL;

/**  
 * @brief        独立看门狗初始化
 * @return       void
 * @note         32分频(pr=3) 重装载值为1250
 *               Tout = {[4*(2^3)]*1250}/40 = 1000ms = 1s
 */
void MX_IWDG_Init(void)
{
  hiwdg.Instance = IWDG;
  hiwdg.Init.Prescaler = IWDG_PRESCALER_32;
  hiwdg.Init.Reload = 1250;
  if (HAL_IWDG_Init(&hiwdg) != HAL_OK)
  {
    Error_Handler();
  }
}

/**  
 * @brief        定时器超时函数
 * @return       void
 * @note         无
 */
static void iwdg_timer_entry(void *parameter)
{
    if(HAL_IWDG_Refresh(&hiwdg) != RT_EOK)
    {
        rt_kprintf(" feed dog failed.\n\n");
    }
    else
    {
        rt_kprintf(" feed success.\n\n");
    }
}

/**  
 * @brief        启动看门狗线程入口函数
 * @return       void
 * @note         无
 */
static void iwdg_thread_entry(void *parameter)
{
    __HAL_IWDG_START(&hiwdg); /**< 启动独立看门狗*/
    rt_thread_delete(iwdg_thread);
}

/**  
 * @brief        创建定时器、启动线程
 * @return       int
 * @note         无
 */
int iwdg_thread_task(void)
{
    rt_err_t timer_res = RT_NULL;
    iwdg_timer = rt_timer_create("iwdg_timer", 
                                  iwdg_timer_entry, 
                                  RT_NULL, 
                                  0, 
                                  RT_TIMER_FLAG_PERIODIC|RT_TIMER_FLAG_SOFT_TIMER);
    if(iwdg_timer != RT_NULL)
    {
        rt_kprintf("iwdg timer created success.\n");
        rt_timer_start(iwdg_timer);
    }
    else
    {
        rt_kprintf("iwdg timer created failed. \n\n");
        return -1;
    }
    
    iwdg_thread = rt_thread_create("iwdg_thread", 
                                    iwdg_thread_entry, 
                                    RT_NULL, 
                                    THREAD_STACKSIZE, 
                                    THREAD_PRIORITY, 
                                    THREAD_TIMESLICE);
    if(iwdg_thread != RT_NULL)
    {
        rt_thread_startup(iwdg_thread);
    }
    else
    {
        rt_kprintf("iwdg thread created failed. error code:%x \n\n", iwdg_thread);
        return -1;
    }
    return 0;
}

/* 导出到finsh中使用 */
MSH_CMD_EXPORT(iwdg_thread_task, iwdg_thread_task);
```[/md]
效果如下：没有开启定时喂狗时系统每隔1s进行重启，如下图
[attach]14347[/attach]开启定时喂狗时系统每隔1s(在0.8ms-3276ms)之间进行喂狗，系统不会重启，如下图[attach]14348[/attach]