drv_rtc.c 10.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360
  1. /*
  2. * Copyright (c) 2006-2018, RT-Thread Development Team
  3. *
  4. * SPDX-License-Identifier: Apache-2.0
  5. *
  6. * Change Logs:
  7. * Date Author Notes
  8. * 2018-12-04 balanceTWK first version
  9. */
  10. #include "board.h"
  11. #include<rtthread.h>
  12. #include<rtdevice.h>
  13. #ifdef BSP_USING_ONCHIP_RTC
  14. /*
  15. #ifndef HAL_RTCEx_BKUPRead
  16. #define HAL_RTCEx_BKUPRead(x1, x2) (~BKUP_REG_DATA)
  17. #endif
  18. #ifndef HAL_RTCEx_BKUPWrite
  19. #define HAL_RTCEx_BKUPWrite(x1, x2, x3)
  20. #endif
  21. */
  22. #ifndef RTC_BKP_DR1
  23. #define RTC_BKP_DR1 RT_NULL
  24. #endif
  25. #define DBG_ENABLE
  26. #define DBG_COLOR
  27. #define LOG_TAG "drv.rtc"
  28. #define DBG_LVL DBG_LOG
  29. #include <drv_log.h>
  30. #define BKUP_REG_DATA 0xA0A0
  31. static struct rt_device rtc;
  32. static struct rt_rtc_device rtc_device;
  33. #ifdef RT_USING_ALARM
  34. static rt_err_t rtc_alarm_time_set(struct rt_rtc_device* p_dev);
  35. static int rt_rtc_alarm_init(void);
  36. static RTC_AlarmTypeDef salarmstructure;
  37. #endif
  38. static RTC_HandleTypeDef RTC_Handler;
  39. uint32_t RTC_ReadTimeCounter(RTC_HandleTypeDef *hrtc);
  40. HAL_StatusTypeDef RTC_WriteTimeCounter(RTC_HandleTypeDef *hrtc, uint32_t TimeCounter);
  41. static time_t get_rtc_timestamp(void)
  42. {
  43. // RTC_TimeTypeDef RTC_TimeStruct = {0};
  44. // RTC_DateTypeDef RTC_DateStruct = {0};
  45. // struct tm tm_new;
  46. //
  47. // HAL_RTC_GetTime(&RTC_Handler, &RTC_TimeStruct, RTC_FORMAT_BIN);
  48. // HAL_RTC_GetDate(&RTC_Handler, &RTC_DateStruct, RTC_FORMAT_BIN);
  49. //
  50. // tm_new.tm_sec = RTC_TimeStruct.Seconds;
  51. // tm_new.tm_min = RTC_TimeStruct.Minutes;
  52. // tm_new.tm_hour = RTC_TimeStruct.Hours;
  53. // tm_new.tm_mday = RTC_DateStruct.Date;
  54. // tm_new.tm_mon = RTC_DateStruct.Month - 1;
  55. // tm_new.tm_year = RTC_DateStruct.Year + 100;
  56. //
  57. // LOG_D("get rtc time.");
  58. // return mktime(&tm_new);
  59. return RTC_ReadTimeCounter(&RTC_Handler);
  60. }
  61. static rt_err_t set_rtc_time_stamp(time_t time_stamp)
  62. {
  63. // RTC_TimeTypeDef RTC_TimeStruct = {0};
  64. // RTC_DateTypeDef RTC_DateStruct = {0};
  65. // struct tm *p_tm;
  66. //
  67. // p_tm = localtime(&time_stamp);
  68. // if (p_tm->tm_year < 100)
  69. // {
  70. // return -RT_ERROR;
  71. // }
  72. //
  73. // RTC_TimeStruct.Seconds = p_tm->tm_sec ;
  74. // RTC_TimeStruct.Minutes = p_tm->tm_min ;
  75. // RTC_TimeStruct.Hours = p_tm->tm_hour;
  76. // RTC_DateStruct.Date = p_tm->tm_mday;
  77. // RTC_DateStruct.Month = p_tm->tm_mon + 1 ;
  78. // RTC_DateStruct.Year = p_tm->tm_year - 100;
  79. // RTC_DateStruct.WeekDay = p_tm->tm_wday + 1;
  80. //
  81. // if (HAL_RTC_SetDate(&RTC_Handler, &RTC_DateStruct, RTC_FORMAT_BIN) != HAL_OK)
  82. // {
  83. // return -RT_ERROR;
  84. // }
  85. //
  86. // if (HAL_RTC_SetTime(&RTC_Handler, &RTC_TimeStruct, RTC_FORMAT_BIN) != HAL_OK)
  87. // {
  88. // return -RT_ERROR;
  89. // }
  90. //
  91. //
  92. // LOG_D("set rtc time.");
  93. // HAL_RTCEx_BKUPWrite(&RTC_Handler, RTC_BKP_DR1, BKUP_REG_DATA);
  94. RTC_WriteTimeCounter(&RTC_Handler,time_stamp);
  95. return RT_EOK;
  96. }
  97. static void rt_rtc_init(void)
  98. {
  99. #ifndef SOC_SERIES_STM32H7
  100. __HAL_RCC_PWR_CLK_ENABLE();
  101. #endif
  102. RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  103. #ifdef BSP_RTC_USING_LSI
  104. RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSI;
  105. RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
  106. RCC_OscInitStruct.LSEState = RCC_LSE_OFF;
  107. RCC_OscInitStruct.LSIState = RCC_LSI_ON;
  108. #else
  109. RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSE;
  110. RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
  111. RCC_OscInitStruct.LSEState = RCC_LSE_ON;
  112. RCC_OscInitStruct.LSIState = RCC_LSI_OFF;
  113. #endif
  114. HAL_RCC_OscConfig(&RCC_OscInitStruct);
  115. }
  116. static rt_err_t rt_rtc_config(struct rt_device *dev)
  117. {
  118. RCC_PeriphCLKInitTypeDef PeriphClkInitStruct = {0};
  119. HAL_PWR_EnableBkUpAccess();
  120. PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_RTC;
  121. #ifdef BSP_RTC_USING_LSI
  122. PeriphClkInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSI;
  123. #else
  124. PeriphClkInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSE;
  125. #endif
  126. HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct);
  127. /* Enable RTC Clock */
  128. __HAL_RCC_RTC_ENABLE();
  129. RTC_Handler.Instance = RTC;
  130. if (HAL_RTCEx_BKUPRead(&RTC_Handler, RTC_BKP_DR1) != BKUP_REG_DATA)
  131. {
  132. LOG_I("RTC hasn't been configured, please use <date> command to config.");
  133. #if defined(SOC_SERIES_STM32F1)
  134. RTC_Handler.Init.OutPut = RTC_OUTPUTSOURCE_NONE;
  135. RTC_Handler.Init.AsynchPrediv = RTC_AUTO_1_SECOND;
  136. #elif defined(SOC_SERIES_STM32F0)
  137. /* set the frequency division */
  138. #ifdef BSP_RTC_USING_LSI
  139. RTC_Handler.Init.AsynchPrediv = 0XA0;
  140. RTC_Handler.Init.SynchPrediv = 0xFA;
  141. #else
  142. RTC_Handler.Init.AsynchPrediv = 0X7F;
  143. RTC_Handler.Init.SynchPrediv = 0x0130;
  144. #endif /* BSP_RTC_USING_LSI */
  145. RTC_Handler.Init.HourFormat = RTC_HOURFORMAT_24;
  146. RTC_Handler.Init.OutPut = RTC_OUTPUT_DISABLE;
  147. RTC_Handler.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;
  148. RTC_Handler.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
  149. #elif defined(SOC_SERIES_STM32F2) || defined(SOC_SERIES_STM32F4) || defined(SOC_SERIES_STM32F7) || defined(SOC_SERIES_STM32L4) || defined(SOC_SERIES_STM32H7)
  150. /* set the frequency division */
  151. #ifdef BSP_RTC_USING_LSI
  152. RTC_Handler.Init.AsynchPrediv = 0X7D;
  153. #else
  154. RTC_Handler.Init.AsynchPrediv = 0X7F;
  155. #endif /* BSP_RTC_USING_LSI */
  156. RTC_Handler.Init.SynchPrediv = 0XFF;
  157. RTC_Handler.Init.HourFormat = RTC_HOURFORMAT_24;
  158. RTC_Handler.Init.OutPut = RTC_OUTPUT_DISABLE;
  159. RTC_Handler.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;
  160. RTC_Handler.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
  161. #endif
  162. if (HAL_RTC_Init(&RTC_Handler) != HAL_OK)
  163. {
  164. return -RT_ERROR;
  165. }
  166. }
  167. return RT_EOK;
  168. }
  169. static rt_err_t rt_rtc_control(rt_device_t dev, int cmd, void *args)
  170. {
  171. rt_err_t result = RT_EOK;
  172. #ifdef RT_USING_ALARM
  173. struct rt_rtc_wkalarm *p_wkalarm = RT_NULL;
  174. #endif
  175. RT_ASSERT(dev != RT_NULL);
  176. switch (cmd)
  177. {
  178. case RT_DEVICE_CTRL_RTC_GET_TIME:
  179. *(rt_uint32_t *)args = get_rtc_timestamp();
  180. LOG_D("RTC: get rtc_time %x\n", *(rt_uint32_t *)args);
  181. break;
  182. case RT_DEVICE_CTRL_RTC_SET_TIME:
  183. if (set_rtc_time_stamp(*(rt_uint32_t *)args) != RT_EOK) {
  184. // 错误处理
  185. result = -RT_ERROR;
  186. }
  187. #ifdef RT_USING_ALARM
  188. rt_alarm_update(&rtc_device.parent, 1);
  189. #endif
  190. LOG_D("RTC: set rtc_time %x\n", *(rt_uint32_t *)args);
  191. break;
  192. #ifdef RT_USING_ALARM
  193. case RT_DEVICE_CTRL_RTC_GET_ALARM:
  194. args = &rtc_device.wkalarm;
  195. LOG_D("GET_ALARM %d:%d:%d",rtc_device.wkalarm.tm_hour,
  196. rtc_device.wkalarm.tm_min,rtc_device.wkalarm.tm_sec);
  197. break;
  198. case RT_DEVICE_CTRL_RTC_SET_ALARM:
  199. LOG_D("RT_DEVICE_CTRL_RTC_SET_ALARM");
  200. p_wkalarm = (struct rt_rtc_wkalarm *)args;
  201. if (p_wkalarm != RT_NULL)
  202. {
  203. rtc_device.wkalarm.enable = p_wkalarm->enable;
  204. rtc_device.wkalarm.tm_hour = p_wkalarm->tm_hour;
  205. rtc_device.wkalarm.tm_min = p_wkalarm->tm_min;
  206. rtc_device.wkalarm.tm_sec = p_wkalarm->tm_sec;
  207. rtc_alarm_time_set(&rtc_device);
  208. }
  209. else
  210. {
  211. result = -RT_ERROR;
  212. LOG_E("RT_DEVICE_CTRL_RTC_SET_ALARM error!!");
  213. }
  214. LOG_D("SET_ALARM %d:%d:%d",p_wkalarm->tm_hour,
  215. p_wkalarm->tm_min,p_wkalarm->tm_sec);
  216. break;
  217. #endif
  218. }
  219. return result;
  220. }
  221. #ifdef RT_USING_DEVICE_OPS
  222. const static struct rt_device_ops rtc_ops =
  223. {
  224. RT_NULL,
  225. RT_NULL,
  226. RT_NULL,
  227. RT_NULL,
  228. RT_NULL,
  229. rt_rtc_control
  230. };
  231. #endif
  232. static rt_err_t rt_hw_rtc_register(rt_device_t device, const char *name, rt_uint32_t flag)
  233. {
  234. RT_ASSERT(device != RT_NULL);
  235. rt_rtc_init();
  236. if (rt_rtc_config(device) != RT_EOK)
  237. {
  238. return -RT_ERROR;
  239. }
  240. #ifdef RT_USING_DEVICE_OPS
  241. device->ops = &rtc_ops;
  242. #else
  243. device->init = RT_NULL;
  244. device->open = RT_NULL;
  245. device->close = RT_NULL;
  246. device->read = RT_NULL;
  247. device->write = RT_NULL;
  248. device->control = rt_rtc_control;
  249. #endif
  250. device->type = RT_Device_Class_RTC;
  251. device->rx_indicate = RT_NULL;
  252. device->tx_complete = RT_NULL;
  253. device->user_data = RT_NULL;
  254. /* register a character device */
  255. return rt_device_register(device, name, flag);
  256. }
  257. int rt_hw_rtc_init(void)
  258. {
  259. rt_err_t result;
  260. result = rt_hw_rtc_register(&rtc, "rtc", RT_DEVICE_FLAG_RDWR);
  261. if (result != RT_EOK)
  262. {
  263. LOG_E("rtc register err code: %d", result);
  264. return result;
  265. }
  266. #ifdef RT_USING_ALARM
  267. rt_rtc_alarm_init();
  268. #endif
  269. LOG_D("rtc init success");
  270. return RT_EOK;
  271. }
  272. #ifdef RT_USING_ALARM
  273. void rt_rtc_alarm_enable(void)
  274. {
  275. HAL_RTC_SetAlarm_IT(&RTC_Handler,&salarmstructure,RTC_FORMAT_BIN);
  276. HAL_RTC_GetAlarm(&RTC_Handler,&salarmstructure,RTC_ALARM_A,RTC_FORMAT_BIN);
  277. LOG_D("alarm read:%d:%d:%d", salarmstructure.AlarmTime.Hours,
  278. salarmstructure.AlarmTime.Minutes,
  279. salarmstructure.AlarmTime.Seconds);
  280. HAL_NVIC_SetPriority(RTC_Alarm_IRQn, 0x02, 0);
  281. HAL_NVIC_EnableIRQ(RTC_Alarm_IRQn);
  282. }
  283. void rt_rtc_alarm_disable(void)
  284. {
  285. HAL_RTC_DeactivateAlarm(&RTC_Handler, RTC_ALARM_A);
  286. HAL_NVIC_DisableIRQ(RTC_Alarm_IRQn);
  287. }
  288. static int rt_rtc_alarm_init(void)
  289. {
  290. return RT_EOK;
  291. }
  292. static rt_err_t rtc_alarm_time_set(struct rt_rtc_device* p_dev)
  293. {
  294. if (p_dev->wkalarm.enable)
  295. {
  296. salarmstructure.Alarm = RTC_ALARM_A;
  297. salarmstructure.AlarmTime.Hours = p_dev->wkalarm.tm_hour;
  298. salarmstructure.AlarmTime.Minutes = p_dev->wkalarm.tm_min;
  299. salarmstructure.AlarmTime.Seconds = p_dev->wkalarm.tm_sec;
  300. LOG_D("alarm set:%d:%d:%d", salarmstructure.AlarmTime.Hours,
  301. salarmstructure.AlarmTime.Minutes,
  302. salarmstructure.AlarmTime.Seconds);
  303. rt_rtc_alarm_enable();
  304. }
  305. return RT_EOK;
  306. }
  307. void HAL_RTC_AlarmAEventCallback(RTC_HandleTypeDef *hrtc)
  308. {
  309. //LOG_D("rtc alarm isr.\n");
  310. rt_alarm_update(&rtc_device.parent, 1);
  311. }
  312. void RTC_Alarm_IRQHandler(void)
  313. {
  314. rt_interrupt_enter();
  315. HAL_RTC_AlarmIRQHandler(&RTC_Handler);
  316. rt_interrupt_leave();
  317. }
  318. #endif
  319. INIT_APP_EXPORT(rt_hw_rtc_init);
  320. #endif /* BSP_USING_ONCHIP_RTC */