嵌入式技术william hill官网
直播中

李桂兰

7年用户 1474经验值
私信 关注
[经验]

教你使用RT-Thread开启STM32H7系列的RTC与Alarm组件

背景
  • 【ART-PI】默认没有开启Alarm组件，尝试适配并开启
  • 有部分工程师想使用RT-Thread 基于STM32H7系列的RTC 与 Alarm（闹钟功能）
验证平台
  • Keil MDK5（使用RT-Thread Studio 可以作为参考）
  • 【ART-PI】STM32H750XBH6，使用Pandoro STM32L4系列MCU，同样验证通过
移植方法
  • 只前做过一次基于Apollo3平台的Alarm组件的移植，适配部分与STM32有些不同，直接Copy过去编译，发现编译不过，很正常！！
  • 这次基于STM32H7、STM32L4平台，如果也编译不过去，只需要微调！
1.png
2.png
3.png
4.png
5.png
6.png

回帖（2）

李桂兰

2022-3-16 15:05:19
功能验证
1.png
2.png
3.png
举报

李桂兰

2022-3-16 15:07:21
drv_rtc.c 代码，供参考
  1. #include "board.h"
  2. #include
  3. #include

  5. #ifdef BSP_USING_ONCHIP_RTC

  7. struct rt_rtc_device
  8. {
  9.     struct rt_device        device;
  10. #ifdef RT_USING_ALARM
  11.     struct rt_rtc_wkalarm   wkalarm;
  12. #endif
  13. };

  15. #define DBG_ENABLE
  16. #define DBG_SECTION_NAME    "drv_rtc"
  17. #define DBG_LEVEL           DBG_INFO
  18. #include

  20. static struct rt_rtc_device rtc_device;

  22. #ifdef RT_USING_ALARM
  23. static rt_err_t rtc_alarm_time_set(struct rt_rtc_device* p_dev);
  24. static int rt_rtc_alarm_init(void);
  25. static RTC_AlarmTypeDef salarmstructure;
  26. #endif

  28. #ifndef RTC_BKP_DR1
  29. #define RTC_BKP_DR1 RT_NULL
  30. #endif

  32. #define BKUP_REG_DATA 0xA5A5

  34. static RTC_HandleTypeDef RTC_Handler;

  36. RT_WEAK uint32_t HAL_RTCEx_BKUPRead(RTC_HandleTypeDef *hrtc, uint32_t BackupRegister)
  37. {
  38.     return (~BKUP_REG_DATA);
  39. }

  41. RT_WEAK void HAL_RTCEx_BKUPWrite(RTC_HandleTypeDef *hrtc, uint32_t BackupRegister, uint32_t Data)
  42. {
  43.     return;
  44. }

  46. static time_t get_rtc_timestamp(void)
  47. {
  48.     RTC_TimeTypeDef RTC_TimeStruct = {0};
  49.     RTC_DateTypeDef RTC_DateStruct = {0};
  50.     struct tm tm_new = {0};

  52.     HAL_RTC_GetTime(&RTC_Handler, &RTC_TimeStruct, RTC_FORMAT_BIN);
  53.     HAL_RTC_GetDate(&RTC_Handler, &RTC_DateStruct, RTC_FORMAT_BIN);

  55.     tm_new.tm_sec  = RTC_TimeStruct.Seconds;
  56.     tm_new.tm_min  = RTC_TimeStruct.Minutes;
  57.     tm_new.tm_hour = RTC_TimeStruct.Hours;
  58.     tm_new.tm_mday = RTC_DateStruct.Date;
  59.     tm_new.tm_mon  = RTC_DateStruct.Month - 1;
  60.     tm_new.tm_year = RTC_DateStruct.Year + 100;

  62.     return mktime(&tm_new);
  63. }

  65. static rt_err_t set_rtc_time_stamp(time_t time_stamp)
  66. {
  67.     RTC_TimeTypeDef RTC_TimeStruct = {0};
  68.     RTC_DateTypeDef RTC_DateStruct = {0};
  69.     struct tm *p_tm;

  71.     p_tm = localtime(&time_stamp);
  72.     if (p_tm->tm_year < 100)
  73.     {
  74.         return -RT_ERROR;
  75.     }

  77.     RTC_TimeStruct.Seconds = p_tm->tm_sec ;
  78.     RTC_TimeStruct.Minutes = p_tm->tm_min ;
  79.     RTC_TimeStruct.Hours   = p_tm->tm_hour;
  80.     RTC_DateStruct.Date    = p_tm->tm_mday;
  81.     RTC_DateStruct.Month   = p_tm->tm_mon + 1 ;
  82.     RTC_DateStruct.Year    = p_tm->tm_year - 100;
  83.     RTC_DateStruct.WeekDay = p_tm->tm_wday + 1;

  85.     if (HAL_RTC_SetTime(&RTC_Handler, &RTC_TimeStruct, RTC_FORMAT_BIN) != HAL_OK)
  86.     {
  87.         return -RT_ERROR;
  88.     }
  89.     if (HAL_RTC_SetDate(&RTC_Handler, &RTC_DateStruct, RTC_FORMAT_BIN) != HAL_OK)
  90.     {
  91.         return -RT_ERROR;
  92.     }

  94.     LOG_D("set rtc time.");
  95.     HAL_RTCEx_BKUPWrite(&RTC_Handler, RTC_BKP_DR1, BKUP_REG_DATA);

  97. #ifdef SOC_SERIES_STM32F1
  98.     /* F1 series does't save year/month/date datas. so keep those datas to bkp reg */
  99.     HAL_RTCEx_BKUPWrite(&RTC_Handler, RTC_BKP_DR2, RTC_DateStruct.Year);
  100.     HAL_RTCEx_BKUPWrite(&RTC_Handler, RTC_BKP_DR3, RTC_DateStruct.Month);
  101.     HAL_RTCEx_BKUPWrite(&RTC_Handler, RTC_BKP_DR4, RTC_DateStruct.Date);
  102.     HAL_RTCEx_BKUPWrite(&RTC_Handler, RTC_BKP_DR5, RTC_DateStruct.WeekDay);
  103. #endif

  105.     return RT_EOK;
  106. }

  108. static void rt_rtc_init(void)
  109. {
  110. #if !defined(SOC_SERIES_STM32H7) && !defined(SOC_SERIES_STM32WB)
  111.     __HAL_RCC_PWR_CLK_ENABLE();
  112. #endif

  114.     RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  115. #ifdef BSP_RTC_USING_LSI
  116. #ifdef SOC_SERIES_STM32WB
  117. RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSI1;
  118.     RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
  119.     RCC_OscInitStruct.LSEState = RCC_LSE_OFF;
  120.     RCC_OscInitStruct.LSIState = RCC_LSI_ON;
  121. #else
  122.     RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSI;
  123.     RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
  124.     RCC_OscInitStruct.LSEState = RCC_LSE_OFF;
  125.     RCC_OscInitStruct.LSIState = RCC_LSI_ON;
  126. #endif
  127. #else
  128.     RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSE;
  129.     RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
  130.     RCC_OscInitStruct.LSEState = RCC_LSE_ON;
  131.     RCC_OscInitStruct.LSIState = RCC_LSI_OFF;
  132. #endif
  133.     HAL_RCC_OscConfig(&RCC_OscInitStruct);
  134. }

  136. #ifdef SOC_SERIES_STM32F1
  137. /* update RTC_BKP_DRx*/
  138. static void rt_rtc_f1_bkp_update(void)
  139. {
  140.     RTC_DateTypeDef RTC_DateStruct = {0};

  142.     HAL_PWR_EnableBkUpAccess();
  143.     __HAL_RCC_BKP_CLK_ENABLE();

  145.     RTC_DateStruct.Year    = HAL_RTCEx_BKUPRead(&RTC_Handler, RTC_BKP_DR2);
  146.     RTC_DateStruct.Month   = HAL_RTCEx_BKUPRead(&RTC_Handler, RTC_BKP_DR3);
  147.     RTC_DateStruct.Date    = HAL_RTCEx_BKUPRead(&RTC_Handler, RTC_BKP_DR4);
  148.     RTC_DateStruct.WeekDay = HAL_RTCEx_BKUPRead(&RTC_Handler, RTC_BKP_DR5);
  149.     if (HAL_RTC_SetDate(&RTC_Handler, &RTC_DateStruct, RTC_FORMAT_BIN) != HAL_OK)
  150.     {
  151.         Error_Handler();
  152.     }

  154.     HAL_RTC_GetDate(&RTC_Handler, &RTC_DateStruct, RTC_FORMAT_BIN);
  155.     if (HAL_RTCEx_BKUPRead(&RTC_Handler, RTC_BKP_DR4) != RTC_DateStruct.Date)
  156.     {
  157.         HAL_RTCEx_BKUPWrite(&RTC_Handler, RTC_BKP_DR1, BKUP_REG_DATA);
  158.         HAL_RTCEx_BKUPWrite(&RTC_Handler, RTC_BKP_DR2, RTC_DateStruct.Year);
  159.         HAL_RTCEx_BKUPWrite(&RTC_Handler, RTC_BKP_DR3, RTC_DateStruct.Month);
  160.         HAL_RTCEx_BKUPWrite(&RTC_Handler, RTC_BKP_DR4, RTC_DateStruct.Date);
  161.         HAL_RTCEx_BKUPWrite(&RTC_Handler, RTC_BKP_DR5, RTC_DateStruct.WeekDay);
  162.     }
  163. }
  164. #endif

  166. static rt_err_t rt_rtc_config(struct rt_device *dev)
  167. {
  168.     RCC_PeriphCLKInitTypeDef PeriphClkInitStruct = {0};

  170.     HAL_PWR_EnableBkUpAccess();
  171.     PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_RTC;
  172. #ifdef BSP_RTC_USING_LSI
  173.     PeriphClkInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSI;
  174. #else
  175.     PeriphClkInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSE;
  176. #endif
  177.     HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct);

  179.     /* Enable RTC Clock */
  180.     __HAL_RCC_RTC_ENABLE();

  182.     RTC_Handler.Instance = RTC;
  183.     if (HAL_RTCEx_BKUPRead(&RTC_Handler, RTC_BKP_DR1) != BKUP_REG_DATA)
  184.     {
  185.         LOG_I("RTC hasn't been configured, please use command to config.");

  187. #if defined(SOC_SERIES_STM32F1)
  188.         RTC_Handler.Init.OutPut = RTC_OUTPUTSOURCE_NONE;
  189.         RTC_Handler.Init.AsynchPrediv = RTC_AUTO_1_SECOND;
  190. #elif defined(SOC_SERIES_STM32F0)

  192.         /* set the frequency division */
  193. #ifdef BSP_RTC_USING_LSI
  194.         RTC_Handler.Init.AsynchPrediv = 0XA0;
  195.         RTC_Handler.Init.SynchPrediv = 0xFA;
  196. #else
  197.         RTC_Handler.Init.AsynchPrediv = 0X7F;
  198.         RTC_Handler.Init.SynchPrediv = 0x0130;
  199. #endif /* BSP_RTC_USING_LSI */

  201.         RTC_Handler.Init.HourFormat = RTC_HOURFORMAT_24;
  202.         RTC_Handler.Init.OutPut = RTC_OUTPUT_DISABLE;
  203.         RTC_Handler.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;
  204.         RTC_Handler.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
  205. #elif defined(SOC_SERIES_STM32F2) || defined(SOC_SERIES_STM32F4) || defined(SOC_SERIES_STM32F7) || defined(SOC_SERIES_STM32L4) || defined(SOC_SERIES_STM32H7) || defined (SOC_SERIES_STM32WB)

  207.         /* set the frequency division */
  208. #ifdef BSP_RTC_USING_LSI
  209.         RTC_Handler.Init.AsynchPrediv = 0X7D;
  210. #else
  211.         RTC_Handler.Init.AsynchPrediv = 0X7F;
  212. #endif /* BSP_RTC_USING_LSI */
  213.         RTC_Handler.Init.SynchPrediv = 0XFF;

  215.         RTC_Handler.Init.HourFormat = RTC_HOURFORMAT_24;
  216.         RTC_Handler.Init.OutPut = RTC_OUTPUT_DISABLE;
  217.         RTC_Handler.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;
  218.         RTC_Handler.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
  219. #endif
  220.         if (HAL_RTC_Init(&RTC_Handler) != HAL_OK)
  221.         {
  222.             return -RT_ERROR;
  223.         }
  224.     }
  225. #ifdef SOC_SERIES_STM32F1
  226.     else
  227.     {
  228.         /* F1 series need update by bkp reg datas */
  229.         rt_rtc_f1_bkp_update();
  230.     }
  231. #endif

  233.     return RT_EOK;
  234. }

  236. static rt_err_t rt_rtc_control(rt_device_t dev, int cmd, void *args)
  237. {
  238.     rt_err_t result = RT_EOK;
  239. #ifdef RT_USING_ALARM
  240.     struct rt_rtc_wkalarm *p_wkalarm = RT_NULL;
  241. #endif
  242.     RT_ASSERT(dev != RT_NULL);

  244.     switch (cmd)
  245.     {
  246.     case RT_DEVICE_CTRL_RTC_GET_TIME:
  247.         *(rt_uint32_t *)args = get_rtc_timestamp();
  248.         LOG_D("RTC: get rtc_time %xn", *(rt_uint32_t *)args);
  249.         break;

  251.     case RT_DEVICE_CTRL_RTC_SET_TIME:
  252.         if (set_rtc_time_stamp(*(rt_uint32_t *)args))
  253.         {
  254.             result = -RT_ERROR;
  255.         }
  256. #ifdef RT_USING_ALARM
  257.         rt_alarm_update(&rtc_device.device, 1);
  258. #endif
  259.         LOG_D("RTC: set rtc_time %xn", *(rt_uint32_t *)args);
  260.         break;

  262. #ifdef RT_USING_ALARM
  263.     case RT_DEVICE_CTRL_RTC_GET_ALARM:
  264.         args = &rtc_device.wkalarm;
  265.         LOG_D("GET_ALARM %d:%d:%d",rtc_device.wkalarm.tm_hour,
  266.             rtc_device.wkalarm.tm_min,rtc_device.wkalarm.tm_sec);
  267.         break;

  269.     case RT_DEVICE_CTRL_RTC_SET_ALARM:
  270.         LOG_D("RT_DEVICE_CTRL_RTC_SET_ALARM");
  271.         p_wkalarm = (struct rt_rtc_wkalarm *)args;
  272.         if (p_wkalarm != RT_NULL)
  273.         {
  274.             rtc_device.wkalarm.enable = p_wkalarm->enable;
  275.             rtc_device.wkalarm.tm_hour = p_wkalarm->tm_hour;
  276.             rtc_device.wkalarm.tm_min = p_wkalarm->tm_min;
  277.             rtc_device.wkalarm.tm_sec = p_wkalarm->tm_sec;
  278.             rtc_alarm_time_set(&rtc_device);
  279.         }
  280.         else
  281.         {
  282.             result = -RT_ERROR;
  283.             LOG_E("RT_DEVICE_CTRL_RTC_SET_ALARM error!!");
  284.         }
  285.         LOG_D("SET_ALARM %d:%d:%d",p_wkalarm->tm_hour,
  286.             p_wkalarm->tm_min,p_wkalarm->tm_sec);
  287.         break;
  288. #endif
  289.     }

  291.     return result;
  292. }

  294. #ifdef RT_USING_DEVICE_OPS
  295. const static struct rt_device_ops rtc_ops =
  296. {
  297.     RT_NULL,
  298.     RT_NULL,
  299.     RT_NULL,
  300.     RT_NULL,
  301.     RT_NULL,
  302.     rt_rtc_control
  303. };
  304. #endif

  306. static rt_err_t rt_hw_rtc_register(rt_device_t device, const char *name, rt_uint32_t flag)
  307. {
  308.     RT_ASSERT(device != RT_NULL);

  310.     rt_rtc_init();
  311.     if (rt_rtc_config(device) != RT_EOK)
  312.     {
  313.         return -RT_ERROR;
  314.     }
  315. #ifdef RT_USING_DEVICE_OPS
  316.     device->ops         = &rtc_ops;
  317. #else
  318.     device->init        = RT_NULL;
  319.     device->open        = RT_NULL;
  320.     device->close       = RT_NULL;
  321.     device->read        = RT_NULL;
  322.     device->write       = RT_NULL;
  323.     device->control     = rt_rtc_control;
  324. #endif
  325.     device->type        = RT_Device_Class_RTC;
  326.     device->rx_indicate = RT_NULL;
  327.     device->tx_complete = RT_NULL;
  328.     device->user_data   = RT_NULL;

  330.     /* register a character device */
  331.     return rt_device_register(device, name, flag);
  332. }

  334. int rt_hw_rtc_init(void)
  335. {
  336.     rt_err_t result;

  338.     result = rt_hw_rtc_register(&rtc_device.device, "rtc", RT_DEVICE_FLAG_RDWR);
  339.     if (result != RT_EOK)
  340.     {
  341.         LOG_E("rtc register err code: %dn", result);
  342.         return result;
  343.     }
  344. #ifdef RT_USING_ALARM
  345.     rt_rtc_alarm_init();
  346. #endif
  347.     LOG_D("rtc init successn");
  348.     return RT_EOK;
  349. }

  351. #ifdef RT_USING_ALARM
  352. void rt_rtc_alarm_enable(void)
  353. {
  354.     HAL_RTC_SetAlarm_IT(&RTC_Handler,&salarmstructure,RTC_FORMAT_BIN);
  355.     HAL_RTC_GetAlarm(&RTC_Handler,&salarmstructure,RTC_ALARM_A,RTC_FORMAT_BIN);
  356.     LOG_D("alarm read:%d:%d:%d", salarmstructure.AlarmTime.Hours,
  357.         salarmstructure.AlarmTime.Minutes,
  358.         salarmstructure.AlarmTime.Seconds);
  359.     HAL_NVIC_SetPriority(RTC_Alarm_IRQn, 0x02, 0);
  360.     HAL_NVIC_EnableIRQ(RTC_Alarm_IRQn);
  361. }

  363. void rt_rtc_alarm_disable(void)
  364. {
  365.     HAL_RTC_DeactivateAlarm(&RTC_Handler, RTC_ALARM_A);
  366.     HAL_NVIC_DisableIRQ(RTC_Alarm_IRQn);
  367. }

  369. static int rt_rtc_alarm_init(void)
  370. {
  371.     return RT_EOK;
  372. }

  374. static rt_err_t rtc_alarm_time_set(struct rt_rtc_device* p_dev)
  375. {
  376.     if (p_dev->wkalarm.enable)
  377.     {
  378.         salarmstructure.Alarm = RTC_ALARM_A;
  379.         salarmstructure.AlarmDateWeekDay = RTC_WEEKDAY_MONDAY;
  380.         salarmstructure.AlarmDateWeekDaySel = RTC_ALARMDATEWEEKDAYSEL_WEEKDAY;
  381.         salarmstructure.AlarmMask = RTC_ALARMMASK_DATEWEEKDAY;
  382.         salarmstructure.AlarmSubSecondMask = RTC_ALARMSUBSECONDMASK_NONE;
  383.         salarmstructure.AlarmTime.TimeFormat = RTC_HOURFORMAT12_AM;
  384.         salarmstructure.AlarmTime.Hours = p_dev->wkalarm.tm_hour;
  385.         salarmstructure.AlarmTime.Minutes = p_dev->wkalarm.tm_min;
  386.         salarmstructure.AlarmTime.Seconds = p_dev->wkalarm.tm_sec;
  387.         LOG_D("alarm set:%d:%d:%d", salarmstructure.AlarmTime.Hours,
  388.             salarmstructure.AlarmTime.Minutes,
  389.             salarmstructure.AlarmTime.Seconds);
  390.         rt_rtc_alarm_enable();
  391.     }

  393.     return RT_EOK;
  394. }

  396. void HAL_RTC_AlarmAEventCallback(RTC_HandleTypeDef *hrtc)
  397. {
  398.     //LOG_D("rtc alarm isr.n");
  399.     rt_alarm_update(&rtc_device.device, 1);
  400. }

  402. void RTC_Alarm_IRQHandler(void)
  403. {
  404.     HAL_RTC_AlarmIRQHandler(&RTC_Handler);
  405. }

  407. #endif

  409. INIT_DEVICE_EXPORT(rt_hw_rtc_init);

  411. #endif /* BSP_USING_ONCHIP_RTC */


RTC_Alarm 测试代码，供参考
  1. #include
  2. #include "board.h"
  3. #include
  4. #include

  6. #define RTC_DEBUG

  8. #define DBG_ENABLE
  9. #define DBG_SECTION_NAME    "rtc.test"
  10. #define DBG_LEVEL           DBG_LOG
  11. #include

  13. #ifdef RTC_DEBUG

  15. static struct rt_alarm * p_alarm_sec = RT_NULL;
  16. static struct rt_alarm * p_alarm_min = RT_NULL;
  17. static struct rt_alarm * p_alarm_hour = RT_NULL;
  18. static struct rt_alarm * p_alarm_time = RT_NULL;

  20. static rt_err_t rtc_set_time(time_t timestamp)
  21. {
  22.     /* converts the local time in time to calendar time. */
  23.     rt_device_t rtc_device;
  24.     rt_err_t ret = -RT_ERROR;

  26.     rtc_device = rt_device_find("rtc");

  28.     if (rtc_device == RT_NULL)
  29.     {
  30.         return -RT_ERROR;
  31.     }

  33.     /* update to RTC device. */
  34.     ret = rt_device_control(rtc_device, RT_DEVICE_CTRL_RTC_SET_TIME, ×tamp);

  36.     return ret;
  37. }

  39. static time_t rtc_gettime(void)
  40. {
  41.     static time_t now;
  42.     static struct tm tm;

  44.     now = time(NULL);
  45. #ifdef _WIN32
  46.     _gmtime32_s(&tm, &now);
  47. #else
  48.     gmtime_r(&now, &tm);
  49. #endif

  51.     LOG_D("BJ time:%04d-%02d-%02d %02d:%02d:%02d.%03dn",
  52.                 tm.tm_year + 1900, tm.tm_mon + 1,
  53.                 tm.tm_mday, tm.tm_hour + 8, tm.tm_min,
  54.                 tm.tm_sec, rt_tick_get() % 1000);

  56.     return now;
  57. }

  59. static void alarm_time_cb(rt_alarm_t alarm, time_t timestamp)
  60. {
  61.     LOG_D("alarm_time_cb ok!n");
  62. }

  64. static void alarm_hour_cb(rt_alarm_t alarm, time_t timestamp)
  65. {
  66.     LOG_D("alarm_hour_cb ok!n");
  67. }

  69. static void alarm_minute_cb(rt_alarm_t alarm, time_t timestamp)
  70. {
  71.     LOG_D("alarm_minute_cb ok!n");
  72. }

  74. static void alarm_second_cb(rt_alarm_t alarm, time_t timestamp)
  75. {
  76.     LOG_D("alarm_second_cb ok!n");
  77. }

  79. static struct rt_alarm * rtc_alarm_test_create(rt_alarm_callback_t callback, rt_uint32_t flag, struct tm *p_tm)
  80. {
  81.     struct rt_alarm_setup alarm_setup_test;

  83.     alarm_setup_test.flag = flag;
  84.     alarm_setup_test.wktime.tm_year = p_tm->tm_year;
  85.     alarm_setup_test.wktime.tm_mon = p_tm->tm_mon;
  86.     alarm_setup_test.wktime.tm_mday = p_tm->tm_mday;
  87.     alarm_setup_test.wktime.tm_wday = p_tm->tm_wday;
  88.     alarm_setup_test.wktime.tm_hour = p_tm->tm_hour;
  89.     alarm_setup_test.wktime.tm_min = p_tm->tm_min;
  90.     alarm_setup_test.wktime.tm_sec = p_tm->tm_sec;

  92.     return rt_alarm_create(callback, &alarm_setup_test);
  93. }

  95. static void rtc_alarm_time_create(void)
  96. {
  97.     static time_t now;
  98.     static struct tm tm;

  100.     if (p_alarm_time != RT_NULL)
  101.         return;

  103.     now = time(NULL) + 65;
  104. #ifdef _WIN32
  105.     _gmtime32_s(&tm, &now);
  106. #else
  107.     gmtime_r(&now, &tm);
  108. #endif

  110.     p_alarm_time = rtc_alarm_test_create(alarm_time_cb, RT_ALARM_DAILY, &tm);
  111. }

  113. static void rtc_alarm_time_start(void)
  114. {
  115.     if (p_alarm_time != RT_NULL)
  116.         rt_alarm_start(p_alarm_time);
  117. }

  119. static void rtc_alarm_time_stop(void)
  120. {
  121.     if (p_alarm_time != RT_NULL)
  122.         rt_alarm_stop(p_alarm_time);
  123. }

  125. static void rtc_alarm_time_delete(void)
  126. {
  127.     if (p_alarm_time != RT_NULL)
  128.     {
  129.         if (rt_alarm_delete(p_alarm_time) == RT_EOK)
  130.             p_alarm_time = RT_NULL;
  131.     }
  132. }

  134. static void rtc_alarm_second_create(void)
  135. {
  136.     static time_t now;
  137.     static struct tm tm;

  139.     if (p_alarm_sec != RT_NULL)
  140.         return;

  142.     now = time(NULL) + 1;
  143. #ifdef _WIN32
  144.     _gmtime32_s(&tm, &now);
  145. #else
  146.     gmtime_r(&now, &tm);
  147. #endif

  149.     p_alarm_sec = rtc_alarm_test_create(alarm_second_cb, RT_ALARM_SECOND, &tm);
  150. }

  152. static void rtc_alarm_second_start(void)
  153. {
  154.     if (p_alarm_sec != RT_NULL)
  155.         rt_alarm_start(p_alarm_sec);
  156. }

  158. static void rtc_alarm_second_stop(void)
  159. {
  160.     if (p_alarm_sec != RT_NULL)
  161.         rt_alarm_stop(p_alarm_sec);
  162. }

  164. static void rtc_alarm_second_delete(void)
  165. {
  166.     if (p_alarm_sec != RT_NULL)
  167.     {
  168.         if (rt_alarm_delete(p_alarm_sec) == RT_EOK)
  169.             p_alarm_sec = RT_NULL;
  170.     }
  171. }

  173. static void rtc_alarm_minute_create(void)
  174. {
  175.     static time_t now;
  176.     static struct tm tm;

  178.     if (p_alarm_min != RT_NULL)
  179.         return;

  181.     now = time(NULL) + 60;
  182. #ifdef _WIN32
  183.     _gmtime32_s(&tm, &now);
  184. #else
  185.     gmtime_r(&now, &tm);
  186. #endif

  188.     p_alarm_min = rtc_alarm_test_create(alarm_minute_cb, RT_ALARM_MINUTE, &tm);
  189. }

  191. static void rtc_alarm_minute_start(void)
  192. {
  193.     if (p_alarm_min != RT_NULL)
  194.         rt_alarm_start(p_alarm_min);
  195. }

  197. static void rtc_alarm_minute_stop(void)
  198. {
  199.     if (p_alarm_min != RT_NULL)
  200.         rt_alarm_stop(p_alarm_min);
  201. }

  203. static void rtc_alarm_minute_delete(void)
  204. {
  205.     if (p_alarm_min != RT_NULL)
  206.     {
  207.         if (rt_alarm_delete(p_alarm_min) == RT_EOK)
  208.             p_alarm_min = RT_NULL;
  209.     }
  210. }

  212. static void rtc_alarm_hour_create(void)
  213. {
  214.     static time_t now;
  215.     static struct tm tm;

  217.     if (p_alarm_hour != RT_NULL)
  218.         return;

  220.     now = time(NULL) + 3600;
  221. #ifdef _WIN32
  222.     _gmtime32_s(&tm, &now);
  223. #else
  224.     gmtime_r(&now, &tm);
  225. #endif

  227.     p_alarm_hour = rtc_alarm_test_create(alarm_hour_cb, RT_ALARM_HOUR, &tm);
  228. }

  230. static void rtc_alarm_hour_start(void)
  231. {
  232.     if (p_alarm_hour != RT_NULL)
  233.         rt_alarm_start(p_alarm_hour);
  234. }

  236. static void rtc_alarm_hour_stop(void)
  237. {
  238.     if (p_alarm_hour != RT_NULL)
  239.         rt_alarm_stop(p_alarm_hour);
  240. }

  242. static void rtc_alarm_hour_delete(void)
  243. {
  244.     if (p_alarm_hour != RT_NULL)
  245.     {
  246.         if (rt_alarm_delete(p_alarm_hour) == RT_EOK)
  247.             p_alarm_hour = RT_NULL;
  248.     }
  249. }

  251. void rtc_alarm_start(int argc, char **argv)
  252. {
  253.     int index = 0;

  255.     if (argc >= 2)
  256.     {
  257.         index = atoi(argv[1]);
  258.     }

  260.     switch(index)
  261.     {
  262.         case 0:
  263.             rtc_alarm_hour_start();
  264.             break;
  265.         case 1:
  266.             rtc_alarm_minute_start();
  267.             break;
  268.         case 2:
  269.             rtc_alarm_second_start();
  270.             break;
  271.         case 3:
  272.             rtc_alarm_time_start();
  273.             break;
  274.         default:
  275.             break;
  276.     }
  277. }

  279. void rtc_alarm_stop(int argc, char **argv)
  280. {
  281.     int index = 0;

  283.     if (argc >= 2)
  284.     {
  285.         index = atoi(argv[1]);
  286.     }

  288.     switch(index)
  289.     {
  290.         case 0:
  291.             rtc_alarm_hour_stop();
  292.             break;
  293.         case 1:
  294.             rtc_alarm_minute_stop();
  295.             break;
  296.         case 2:
  297.             rtc_alarm_second_stop();
  298.             break;
  299.         case 3:
  300.             rtc_alarm_time_stop();
  301.             break;
  302.         default:
  303.             break;
  304.     }
  305. }

  307. void rtc_alarm_create(int argc, char **argv)
  308. {
  309.     int index = 0;

  311.     if (argc >= 2)
  312.     {
  313.         index = atoi(argv[1]);
  314.     }

  316.     switch(index)
  317.     {
  318.         case 0:
  319.             rtc_alarm_hour_create();
  320.             break;
  321.         case 1:
  322.             rtc_alarm_minute_create();
  323.             break;
  324.         case 2:
  325.             rtc_alarm_second_create();
  326.             break;
  327.         case 3:
  328.             rtc_alarm_time_create();
  329.             break;
  330.         default:
  331.             break;
  332.     }
  333. }

  335. void rtc_alarm_delete(int argc, char **argv)
  336. {
  337.     int index = 0;

  339.     if (argc >= 2)
  340.     {
  341.         index = atoi(argv[1]);
  342.     }

  344.     switch(index)
  345.     {
  346.         case 0:
  347.             rtc_alarm_hour_delete();
  348.             break;
  349.         case 1:
  350.             rtc_alarm_minute_delete();
  351.             break;
  352.         case 2:
  353.             rtc_alarm_second_delete();
  354.             break;
  355.         case 3:
  356.             rtc_alarm_time_delete();
  357.             break;
  358.         default:
  359.             break;
  360.     }
  361. }

  363. MSH_CMD_EXPORT(rtc_gettime, rtc get time);
  364. MSH_CMD_EXPORT(rtc_alarm_create, rtc alarm_create);
  365. MSH_CMD_EXPORT(rtc_alarm_delete, rtc alarm_delete);
  366. MSH_CMD_EXPORT(rtc_alarm_start, rtc alarm_start);
  367. MSH_CMD_EXPORT(rtc_alarm_stop, rtc alarm_stop);

  369. #endif


总结
RT-Thread RTC alarm组件，配置起来，稍微有点麻烦。
Alarm闹钟功能，使能组件后，还是需要创建闹钟、开启闹钟、停止闹钟、删除闹钟业务代码的配合。
多使用，多总结。

调试记录
  1. msh />rtc
  2. rtc_gettime
  3. rtc_alarm_create
  4. rtc_alarm_delete
  5. rtc_alarm_start
  6. rtc_alarm_stop
  7. msh />rtc_al
  8. rtc_alarm_create
  9. rtc_alarm_delete
  10. rtc_alarm_start
  11. rtc_alarm_stop
  12. msh />rtc_alarm_c
  13. rtc_alarm_create
  14. msh />rtc_alarm_create 0
  15. msh />rtc
  16. rtc_gettime
  17. rtc_alarm_create
  18. rtc_alarm_delete
  19. rtc_alarm_start
  20. rtc_alarm_stop
  21. msh />rtc_al
  22. rtc_alarm_create
  23. rtc_alarm_delete
  24. rtc_alarm_start
  25. rtc_alarm_stop
  26. msh />rtc_alarm_c
  27. rtc_alarm_create
  28. msh />rtc_alarm_create 1
  29. msh />al
  30. alarm_dump
  31. msh />alarm_dump
  32. | id | YYYY-MM-DD hh:mm:ss | week | flag | en |
  33. +----+---------------------+------+------+----+
  34. |  0 | 2000-01-01 08:13:12 |   6  |   M  |  0 |
  35. |  1 | 2000-01-01 09:12:07 |   6  |   H  |  0 |
  36. |  2 | 2000-01-01 08:12:13 |   6  |   S  |  1 |
  37. +----+---------------------+------+------+----+
  38. msh />rt
  39. rtc_gettime
  40. rtc_alarm_create
  41. rtc_alarm_delete
  42. rtc_alarm_start
  43. rtc_alarm_stop
  44. msh />rtc_al
  45. rtc_alarm_create
  46. rtc_alarm_delete
  47. rtc_alarm_start
  48. rtc_alarm_stop
  49. msh />rtc_alarm_st
  50. rtc_alarm_start
  51. rtc_alarm_stop
  52. msh />rtc_alarm_sta
  53. rtc_alarm_start
  54. msh />rtc_alarm_start 0
  55. msh />rtc
  56. rtc_gettime
  57. rtc_alarm_create
  58. rtc_alarm_delete
  59. rtc_alarm_start
  60. rtc_alarm_stop
  61. msh />rtc_al
  62. rtc_alarm_create
  63. rtc_alarm_delete
  64. rtc_alarm_start
  65. rtc_alarm_stop
  66. msh />rtc_alarm_st
  67. rtc_alarm_start
  68. rtc_alarm_stop
  69. msh />rtc_alarm_sta
  70. rtc_alarm_start
  71. msh />rtc_alarm_start 1
  72. msh />al
  73. alarm_dump
  74. msh />alarm_dump
  75. | id | YYYY-MM-DD hh:mm:ss | week | flag | en |
  76. +----+---------------------+------+------+----+
  77. |  0 | 2000-01-01 08:13:12 |   6  |   M  |  1 |
  78. |  1 | 2000-01-01 09:12:07 |   6  |   H  |  1 |
  79. |  2 | 2000-01-01 08:12:29 |   6  |   S  |  1 |
  80. +----+---------------------+------+------+----+
  81. msh />
  82. msh />rtc_al
  83. rtc_alarm_create
  84. rtc_alarm_delete
  85. rtc_alarm_start
  86. rtc_alarm_stop
  87. msh />rtc_alarm_crw
  88. msh />rtc_alarm_cr
  89. rtc_alarm_create
  90. msh />rtc_alarm_create 2
  91. msh />rtc
  92. rtc_gettime
  93. rtc_alarm_create
  94. rtc_alarm_delete
  95. rtc_alarm_start
  96. rtc_alarm_stop
  97. msh />rtc_al
  98. rtc_alarm_create
  99. rtc_alarm_delete
  100. rtc_alarm_start
  101. rtc_alarm_stop
  102. msh />rtc_alarm_star
  103. rtc_alarm_start
  104. msh />rtc_alarm_start 2
  105. msh />[D/rtc.test] alarm_second_cb ok!

  107. [D/rtc.test] alarm_second_cb ok!

  109. [D/rtc.test] alarm_second_cb ok!

  111. [D/rtc.test] alarm_second_cb ok!

  113. rtc
  114. rtc_gettime
  115. rtc_alarm_create
  116. rtc_alarm_delete
  117. rtc_alarm_start
  118. rtc_alarm_stop
  119. msh />rtc_[D/rtc.test] alarm_second_cb ok!

  121. a-[D/rtc.test] alarm_second_cb ok!

  123. msh />rtc_a-[D/rtc.test] alarm_second_cb ok!
  124.                                                                                                                                                            
  125. rtc_alarm_create
  126. rtc_alarm_delete
  127. rtc_alarm_start
  128. rtc_alarm_stop
  129. msh />rtc_alarm_[D/rtc.test] alarm_second_cb ok!

  131. s[D/rtc.test] alarm_second_cb ok!

  133. rtc_alarm_start
  134. rtc_alarm_stop
  135. msh />rtc_alarm_st
  136. rtc_alarm_start
  137. rtc_alarm_stop
  138. msh />rtc_alarm_sto
  139. rtc_alarm_stop
  140. msh />rtc_alarm_stop[D/rtc.test] alarm_second_cb ok!

  142. rtc_alarm_stop
  143. msh />rtc_alarm_stop
  144. rtc_alarm_stop
  145. msh />rtc_alarm_stop 2
  146. msh />al
  147. alarm_dump
  148. msh />alarm_dump
  149. | id | YYYY-MM-DD hh:mm:ss | week | flag | en |
  150. +----+---------------------+------+------+----+
  151. |  0 | 2000-01-01 08:13:05 |   6  |   S  |  0 |
  152. |  1 | 2000-01-01 08:13:12 |   6  |   M  |  1 |
  153. |  2 | 2000-01-01 09:12:07 |   6  |   H  |  1 |
  154. |  3 | 2000-01-01 08:13:11 |   6  |   S  |  1 |
  155. +----+---------------------+------+------+----+
  156. msh />[D/rtc.test] alarm_minute_cb ok!
举报

更多回帖

2 0 0

相关帖子

RT-Thread STM32 RTC
发帖
电子发烧友APP
|投诉反馈|电子发烧友网
© 2021 bbs.elecfans.com
湘ICP备2023018690号
×
20
完善资料，
赚取积分