iwdg

IWDG如何测试”咬狗”

发布于 2021-06-27 16:49:02 浏览：1358 订阅该版

4 个回答

123 认证专家 2021-06-27

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

嵌入式爱好者 2021-06-27

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

123 2021-06-27

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

flashman2002 2021-06-27

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

嵌入式爱好者 2021-06-27

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

```c
/*
 * 程序清单：这是一个独立看门狗设备使用例程
 * 例程导出了 wdt_sample 命令到控制终端
 * 命令调用格式：wdt_sample wdt
 * 命令解释：命令第二个参数是要使用的看门狗设备名称，为空则使用例程默认的看门狗设备。
 * 程序功能：程序通过设备名称查找看门狗设备，然后初始化设备并设置看门狗设备溢出时间。
 *           然后设置空闲线程回调函数，在回调函数里会喂狗。
*/
#include <rthw.h>
#include <rtthread.h>
#include <rtdevice.h>
#include "iwdg.h"
#include "board.h"
#include "mmu.h"

typedef struct {
	volatile unsigned int IWDG_KR;
	volatile unsigned int IWDG_PR;
	volatile unsigned int IWDG_RLR;
	volatile unsigned int IWDG_SR;
	volatile unsigned int IWDG_WINR;
	volatile unsigned int IWDG_EWCR;
	volatile unsigned int IWDG_HWCFGR;
	volatile unsigned int IWDG_VERR;
	volatile unsigned int IWDG_IDR;
	volatile unsigned int IWDG_SIDR;
}IWDG_Type;

struct hw_wdg_device
{
    rt_uint32_t hw_base;
    rt_uint32_t irqno;
};

#ifdef RT_USING_IWDG1
/* watchdog device driver structure */
static struct hw_wdg_device _wdg_device =
{
    0x5C003000,      /* 100ask_stm32mp157 iwdg1 phy addr */
    182,              /* IWDG1 early wake irq */
};
static struct rt_watchdog_device _iwdg1;
#endif

#if 1
#define WDT_DEVICE_NAME    "wdt"    /* 看门狗设备名称 */

static rt_device_t wdg_dev;         /* 看门狗设备句柄 */

static void idle_hook(void)
{
    /* 在空闲线程的回调函数里喂狗 */
    //rt_device_control(wdg_dev, RT_DEVICE_CTRL_WDT_KEEPALIVE, NULL);
    //rt_kprintf("feed the dog!\n ");
}
#endif
#if 1
static rt_err_t watchdog_init(rt_watchdog_t *wdt)
{
	IWDG_Type *iwdg_reg;
	struct hw_wdg_device *iwdg;

RT_ASSERT(wdt != RT_NULL);
#if 1	
	iwdg = (struct hw_wdg_device *)wdt->parent.user_data;
	iwdg_reg = (IWDG_Type *)iwdg->hw_base;

iwdg_reg->IWDG_KR = 0x0000CCCC; /* Enable the IWDG */
	iwdg_reg->IWDG_KR = 0x00005555; /* Enable register access */
	iwdg_reg->IWDG_PR = 0x00000000; /* divider / 4 */
	iwdg_reg->IWDG_RLR = 0x000000FF;
	while(iwdg_reg->IWDG_SR == 0x00000000); /* Wait for the registers to be updated */
	iwdg_reg->IWDG_KR = 0x0000AAAA; /* Refresh the counter with RL[11:0] value, and write-protect registers */
#endif
	return RT_EOK;
	rt_kprintf("Init OK\n");

}

static rt_err_t watchdog_control(rt_watchdog_t *wdt, int cmd, void *arg)
{
	rt_err_t result = RT_EOK;
	#if 0
	rt_uint32_t *timeout = arg;
	IWDG_Type *iwdg_reg;

switch (cmd)
    {
        case RT_DEVICE_CTRL_WDT_START:
            iwdg_reg->IWDG_KR = 0x0000CCCC; /* Enable the IWDG */                
        break;

case RT_DEVICE_CTRL_WDT_STOP:             
            result = -RT_ERROR; 
        break;

case RT_DEVICE_CTRL_WDT_KEEPALIVE:
            iwdg_reg->IWDG_KR = 0x0000AAAA; /* Refresh the counter with RL[11:0] value, and write-protect registers */
        break;

case RT_DEVICE_CTRL_WDT_GET_TIMELEFT:
            *timeout = iwdg_reg->IWDG_PR / 40 * (iwdg_reg->IWDG_RLR - iwdg_reg->IWDG_KR); 
        break;

case RT_DEVICE_CTRL_WDT_SET_TIMEOUT:
			//watchdog_init(wdt);
            if((*timeout)<409)
            {
                iwdg_reg->IWDG_PR = 0x00000000;             
                iwdg_reg->IWDG_RLR = 40 * (*timeout) / 4;                
            }
            else if((*timeout) < 819)
            {
                iwdg_reg->IWDG_PR = 0x00000001;            
                iwdg_reg->IWDG_RLR = 40 * (*timeout) / 8;                
            }
            else if((*timeout) < 1638)
            {
                iwdg_reg->IWDG_PR = 0x00000002;             
                iwdg_reg->IWDG_RLR = 40 * (*timeout) / 16;                
            }
            else if((*timeout) < 3276)
            {
                iwdg_reg->IWDG_PR = 0x00000003;             
                iwdg_reg->IWDG_RLR = 40 * (*timeout) / 32;                
            }
            else if((*timeout) < 65520)
            {
                iwdg_reg->IWDG_PR = 0x00000004;
                iwdg_reg->IWDG_RLR = 40 * (*timeout) / 64;
            }
            else if((*timeout) < 13104)
            {
                iwdg_reg->IWDG_PR = 0x00000005;            
                iwdg_reg->IWDG_RLR = 40 * (*timeout) / 128;                
            }
            else if((*timeout) < 26208)
            {
                iwdg_reg->IWDG_PR = 0x00000006;             
                iwdg_reg->IWDG_RLR = 40 * (*timeout) / 256;                
            }
            else if((*timeout) < 26617)
            {
                iwdg_reg->IWDG_PR = 0x00000007;             
                iwdg_reg->IWDG_RLR = 40 * (*timeout) / 512;                
            }		
            else
            {
				result = -RT_ERROR;
            }
        break;

case RT_DEVICE_CTRL_WDT_GET_TIMEOUT:
            *timeout = iwdg_reg->IWDG_PR / 40 * iwdg_reg->IWDG_RLR; 
        break;

default:
        break;
    }
	#endif	
	return result;
}
#endif
 static const struct rt_watchdog_ops _watchdog_ops =
{
	watchdog_init,
	watchdog_control,
};
#if 1
int rt_hw_watchdog_init(void)
{
	struct hw_wdg_device *wdg;

#ifdef RT_USING_WDT
	_wdg_device.hw_base = (uint32_t)rt_hw_kernel_phys_to_virt((void*)_wdg_device.hw_base, 0x1000);
	wdg = &_wdg_device;

_iwdg1.ops = &_watchdog_ops;

/* register IWDG1 device */
    rt_hw_watchdog_register(&_iwdg1, "wdt",
                          RT_DEVICE_FLAG_RDWR,
                          wdg);	
#endif

return 0;

}
#endif
#if 1
int wdt_sample(int argc, char *argv[])
{
    rt_err_t ret = RT_EOK;
    rt_uint32_t timeout = 1;        /* 溢出时间，单位：秒 */
    char device_name[RT_NAME_MAX];

/* 判断命令行参数是否给定了设备名称 */
    if (argc == 2)
    {
        rt_strncpy(device_name, argv[1], RT_NAME_MAX);
    }
    else
    {
        rt_strncpy(device_name, WDT_DEVICE_NAME, RT_NAME_MAX);
    }
    /* 根据设备名称查找看门狗设备，获取设备句柄 */
    wdg_dev = rt_device_find(device_name);
    if (!wdg_dev)
    {
        rt_kprintf("find %s failed!\n", device_name);
        return RT_ERROR;
    }

/* 设置看门狗溢出时间 */
    ret = rt_device_control(wdg_dev, RT_DEVICE_CTRL_WDT_SET_TIMEOUT, &timeout);
    if (ret != RT_EOK)
    {
        rt_kprintf("set %s timeout failed!\n", device_name);
        return RT_ERROR;
    }
    /* 启动看门狗 */
    ret = rt_device_control(wdg_dev, RT_DEVICE_CTRL_WDT_START, RT_NULL);

if (ret != RT_EOK)
    {
        rt_kprintf("start %s failed!\n", device_name);
        return -RT_ERROR;
    }
    /* 设置空闲线程回调函数 */
    //rt_thread_idle_sethook(idle_hook);

return ret;
}
/* 导出到 msh 命令列表中 */
//MSH_CMD_EXPORT(wdt_sample, wdt sample);
INIT_APP_EXPORT(wdt_sample);

#endif
INIT_BOARD_EXPORT(rt_hw_watchdog_init);

```