【内核和外设学习营】十里看门狗实验

发布于 2018-09-05 09:45:57 浏览：3373 订阅该版

6 个回答

hyz_rtt 2018-09-05

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

[i=s] 本帖最后由 hyz_rtt 于 2018-9-6 19:43 编辑 [/i]

发帖完善
1、实验要求：
要求硬件上：至少有一路 GPIO， 能够用来接 LED 灯，有一路串口用来做 msh shell 终端
      软件上：BSP 中已经实现如下驱动：串口驱动，PIN 驱动,看门狗驱动
2、准备工作：
硬件：野火霸天虎stm32407开发板
软件：rtt3.1.0 stm32f4xxhal、env0.7.1
3、示例代码#include <rtthread.h>

```
#include <rtthread.h>
#include <rtdevice.h>

/*******************************宏定义**************************************/
//按键引脚
#define KEY1       34
//RGB灯引脚号
#define LED_Green  19
#define LED_Blue   20
//RGB灯共阳极接到电源，电平0亮，电平1灭
#define LED_ON(x)  rt_pin_write(x ,0)
#define LED_OFF(x) rt_pin_write(x ,1)

/*******************************定义全局变量*********************************/
struct rt_device *wdg_dev = NULL;

/*******************************示例函数**************************************/
//iwdg_test线程入口函数
void IWDG_TEST_Entery(void *parameter)
{
        //按键1引脚设为输入模式
        rt_pin_mode(KEY1, PIN_MODE_INPUT);
        //Green、Blue灯引脚设为开漏输出模式
        rt_pin_mode(LED_Green,PIN_MODE_OUTPUT);
        rt_pin_mode(LED_Blue,PIN_MODE_OUTPUT);
        
        //打印初始信息和操作信息
        rt_kprintf("\r\n //************************************************\r\n");        
        rt_kprintf("\r\n         Original States of LED                    \r\n");
        rt_kprintf("\r\n         LED_Green is OFF                          \r\n");
        rt_kprintf("\r\n         LED_Blue  is ON                           \r\n");        
        rt_kprintf("\r\n         Please press KEY1 to change LED's state   \r\n");        
        rt_kprintf("\r\n ************************************************//\r\n");        
        
        //默认状态Green灯处于熄灭状态，高电平灭
  LED_OFF(LED_Green);
        //默认状态Blue灯处于点亮状态，低电平亮
  LED_ON(LED_Blue);
        
        while(1)
  {
      if(rt_pin_read(KEY1)==1)//倘若按键1按下
      {
                                rt_kprintf("\r\n KEY1 is pressed:Feed Dog \r\n");
       //喂狗（刷新看门狗RT_DEVICE_CTRL_WDT_KEEPALIVE）
       rt_device_control(wdg_dev, RT_DEVICE_CTRL_WDT_KEEPALIVE, NULL);
                         rt_kprintf("\r\n LED_Green is ON \r\n");
                         rt_kprintf("\r\n LED_Blue  is OFF \r\n");
                         //并点亮绿灯关闭蓝灯                                
       LED_ON(LED_Green);
                         LED_OFF(LED_Blue);
      }
  }
}
//看门狗初始化函数
int iwdg_test(void)
{
   rt_thread_t  tid;
   rt_err_t     result  = RT_EOK;
   rt_uint32_t  timeout = 3000; /*超时时间设为3000ms=3s*/
   wdg_dev = rt_device_find("iwdg");
      if (!wdg_dev)
      {
       return -RT_EIO;
      } 
                        wdg_dev->open(wdg_dev, NULL);
      /* 设定看门狗溢出时间*/
      result = rt_device_control(wdg_dev, RT_DEVICE_CTRL_WDT_SET_TIMEOUT, &timeout);
      if (result != RT_EOK)
      {
         return -RT_EIO;
      } 
                        /*创建用户线程，并指定iwdg_test_entry */
      tid = rt_thread_create("iwdg_test",IWDG_TEST_Entery, RT_NULL,
                              512, 11, 20);
      if (tid != RT_NULL)
          rt_thread_startup(tid);
       /* 启动看门狗，启动命令RT_DEVICE_CTRL_WDT_START*/
      rt_device_control(wdg_dev, RT_DEVICE_CTRL_WDT_START, NULL);
      return 0;
}
//自动初始化
//INIT_APP_EXPORT(iwdg_test);
//导出到MSH命令
MSH_CMD_EXPORT(iwdg_test, WatchDog test.);
```

4、实验步骤
env配置芯片型号stm32f407ZG、外部时钟源HSE25M、串口驱动、PIN驱动、看门狗驱动
5、实验结果：见原帖，按时喂狗（前两张图片），没按时喂狗（第三张图片）
6、遇到的问题：通过env配置的RTC底层驱动编译报错。
7、解决方法：可能是例程里调用驱动的原因，然后就把底层驱动换成群里的驱动，就可以正常使用了。
下面使更换的底层驱动drv_iwg.c的代码

```
#include <rtthread.h>
#include <rtdevice.h>
#include "board.h"
IWDG_HandleTypeDef IWDG_Handler;

rt_err_t iwdg_init(rt_watchdog_t *wdt)
{ 
    IWDG_HandleTypeDef *_IWDG_Handler = wdt->parent.user_data;

HAL_IWDG_Init(_IWDG_Handler);                
        
    return RT_EOK;
}

rt_err_t wdg_control(rt_watchdog_t *wdt, int cmd, void *arg)
{
    rt_err_t result = RT_EOK;
    IWDG_HandleTypeDef *_IWDG_Handler = wdt->parent.user_data; 
    rt_uint32_t *timeout = arg;

switch (cmd)
    {
        case RT_DEVICE_CTRL_WDT_START:
            __HAL_IWDG_START(_IWDG_Handler);                
        break;

case RT_DEVICE_CTRL_WDT_STOP:             
            result = -RT_ERROR; 
        break;

case RT_DEVICE_CTRL_WDT_KEEPALIVE:
            HAL_IWDG_Refresh(_IWDG_Handler);
        break;

case RT_DEVICE_CTRL_WDT_GET_TIMELEFT:
            *timeout = _IWDG_Handler->Init.Prescaler/40*(_IWDG_Handler->Init.Reload - _IWDG_Handler->Instance->KR); 
        break;

case RT_DEVICE_CTRL_WDT_SET_TIMEOUT:
            if((*timeout)<409)
            {
                _IWDG_Handler->Init.Prescaler = IWDG_PRESCALER_4;             
                _IWDG_Handler->Init.Reload = 40*(*timeout)/4;                
            }
            else if((*timeout) < 819)
            {
                _IWDG_Handler->Init.Prescaler = IWDG_PRESCALER_8;            
                _IWDG_Handler->Init.Reload = 40*(*timeout)/8;                
            }
            else if((*timeout) < 1638)
            {
                _IWDG_Handler->Init.Prescaler = IWDG_PRESCALER_16;             
                _IWDG_Handler->Init.Reload = 40*(*timeout)/16;                
            }
            else if((*timeout) < 3276)
            {
                _IWDG_Handler->Init.Prescaler = IWDG_PRESCALER_32;             
                _IWDG_Handler->Init.Reload = 40*(*timeout)/32;                
            }
            else if((*timeout) < 65520)
            {
                _IWDG_Handler->Init.Prescaler = IWDG_PRESCALER_64;             /* ??IWDG???? */
                _IWDG_Handler->Init.Reload = 40*(*timeout)/64;                /* ???? */
            }
            else if((*timeout) < 13104)
            {
                _IWDG_Handler->Init.Prescaler = IWDG_PRESCALER_128;            
                _IWDG_Handler->Init.Reload = 40*(*timeout)/128;                
            }
            else if((*timeout) < 26208)
            {
                _IWDG_Handler->Init.Prescaler = IWDG_PRESCALER_256;             
                _IWDG_Handler->Init.Reload = 40*(*timeout)/256;                
            }
            else result = -RT_ERROR;
            HAL_IWDG_Init(_IWDG_Handler);
        break;

case RT_DEVICE_CTRL_WDT_GET_TIMEOUT:
            *timeout = _IWDG_Handler->Init.Prescaler/40*_IWDG_Handler->Init.Reload; 
        break;

default:
        break;
    }
    return result;
}

static const struct rt_watchdog_ops wdg_ops =
{
        NULL,
    wdg_control
};

rt_watchdog_t wdg;

int rt_hw_iwdg_init(void)
{
    int ret = RT_EOK;

IWDG_Handler.Instance = IWDG;

wdg.ops = &wdg_ops;
    ret = rt_hw_watchdog_register(&wdg, "iwdg", NULL, &IWDG_Handler);

return ret;
}
INIT_DEVICE_EXPORT(rt_hw_iwdg_init);
```