drv_rtc.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384
  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. /* ★ P3-8: RTC_WriteTimeCounter() 无论成功失败原来都返回 RT_EOK,
  95. 上层(如 setSystemTime / 参数下发校时)会以为写成功了。判一下返回值。 */
  96. if (RTC_WriteTimeCounter(&RTC_Handler, time_stamp) != HAL_OK)
  97. {
  98. LOG_E("RTC_WriteTimeCounter failed");
  99. return -RT_ERROR;
  100. }
  101. return RT_EOK;
  102. }
  103. static void rt_rtc_init(void)
  104. {
  105. #ifndef SOC_SERIES_STM32H7
  106. __HAL_RCC_PWR_CLK_ENABLE();
  107. #endif
  108. RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  109. #ifdef BSP_RTC_USING_LSI
  110. RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSI;
  111. RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
  112. RCC_OscInitStruct.LSEState = RCC_LSE_OFF;
  113. RCC_OscInitStruct.LSIState = RCC_LSI_ON;
  114. #else
  115. RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_LSE;
  116. RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
  117. RCC_OscInitStruct.LSEState = RCC_LSE_ON;
  118. RCC_OscInitStruct.LSIState = RCC_LSI_OFF;
  119. #endif
  120. /* ★ P3-8: LSE 起振超时 时 HAL_RCC_OscConfig() 返回 HAL_TIMEOUT 并**静默回退到 LSI**,
  121. 原来返回值被丢掉 -> 日志上看不出 RTC 用的是哪个时钟源,
  122. 现场表现为"时间偶尔走慢/重启后丢时间"却查不到原因。 */
  123. if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  124. {
  125. #ifndef BSP_RTC_USING_LSI
  126. LOG_E("LSE oscillator start FAILED, RTC has fallen back to LSI (time accuracy degraded)");
  127. #else
  128. LOG_E("LSI oscillator start FAILED");
  129. #endif
  130. }
  131. else
  132. {
  133. #ifdef BSP_RTC_USING_LSI
  134. LOG_D("rtc clock source: LSI");
  135. #else
  136. LOG_D("rtc clock source: LSE");
  137. #endif
  138. }
  139. }
  140. static rt_err_t rt_rtc_config(struct rt_device *dev)
  141. {
  142. RCC_PeriphCLKInitTypeDef PeriphClkInitStruct = {0};
  143. HAL_PWR_EnableBkUpAccess();
  144. PeriphClkInitStruct.PeriphClockSelection = RCC_PERIPHCLK_RTC;
  145. #ifdef BSP_RTC_USING_LSI
  146. PeriphClkInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSI;
  147. #else
  148. PeriphClkInitStruct.RTCClockSelection = RCC_RTCCLKSOURCE_LSE;
  149. #endif
  150. HAL_RCCEx_PeriphCLKConfig(&PeriphClkInitStruct);
  151. /* Enable RTC Clock */
  152. __HAL_RCC_RTC_ENABLE();
  153. RTC_Handler.Instance = RTC;
  154. if (HAL_RTCEx_BKUPRead(&RTC_Handler, RTC_BKP_DR1) != BKUP_REG_DATA)
  155. {
  156. LOG_I("RTC hasn't been configured, please use <date> command to config.");
  157. #if defined(SOC_SERIES_STM32F1)
  158. RTC_Handler.Init.OutPut = RTC_OUTPUTSOURCE_NONE;
  159. RTC_Handler.Init.AsynchPrediv = RTC_AUTO_1_SECOND;
  160. #elif defined(SOC_SERIES_STM32F0)
  161. /* set the frequency division */
  162. #ifdef BSP_RTC_USING_LSI
  163. RTC_Handler.Init.AsynchPrediv = 0XA0;
  164. RTC_Handler.Init.SynchPrediv = 0xFA;
  165. #else
  166. RTC_Handler.Init.AsynchPrediv = 0X7F;
  167. RTC_Handler.Init.SynchPrediv = 0x0130;
  168. #endif /* BSP_RTC_USING_LSI */
  169. RTC_Handler.Init.HourFormat = RTC_HOURFORMAT_24;
  170. RTC_Handler.Init.OutPut = RTC_OUTPUT_DISABLE;
  171. RTC_Handler.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;
  172. RTC_Handler.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
  173. #elif defined(SOC_SERIES_STM32F2) || defined(SOC_SERIES_STM32F4) || defined(SOC_SERIES_STM32F7) || defined(SOC_SERIES_STM32L4) || defined(SOC_SERIES_STM32H7)
  174. /* set the frequency division */
  175. #ifdef BSP_RTC_USING_LSI
  176. RTC_Handler.Init.AsynchPrediv = 0X7D;
  177. #else
  178. RTC_Handler.Init.AsynchPrediv = 0X7F;
  179. #endif /* BSP_RTC_USING_LSI */
  180. RTC_Handler.Init.SynchPrediv = 0XFF;
  181. RTC_Handler.Init.HourFormat = RTC_HOURFORMAT_24;
  182. RTC_Handler.Init.OutPut = RTC_OUTPUT_DISABLE;
  183. RTC_Handler.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;
  184. RTC_Handler.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
  185. #endif
  186. if (HAL_RTC_Init(&RTC_Handler) != HAL_OK)
  187. {
  188. return -RT_ERROR;
  189. }
  190. }
  191. return RT_EOK;
  192. }
  193. static rt_err_t rt_rtc_control(rt_device_t dev, int cmd, void *args)
  194. {
  195. rt_err_t result = RT_EOK;
  196. #ifdef RT_USING_ALARM
  197. struct rt_rtc_wkalarm *p_wkalarm = RT_NULL;
  198. #endif
  199. RT_ASSERT(dev != RT_NULL);
  200. switch (cmd)
  201. {
  202. case RT_DEVICE_CTRL_RTC_GET_TIME:
  203. *(rt_uint32_t *)args = get_rtc_timestamp();
  204. LOG_D("RTC: get rtc_time %x\n", *(rt_uint32_t *)args);
  205. break;
  206. case RT_DEVICE_CTRL_RTC_SET_TIME:
  207. if (set_rtc_time_stamp(*(rt_uint32_t *)args) != RT_EOK) {
  208. // 错误处理
  209. result = -RT_ERROR;
  210. }
  211. #ifdef RT_USING_ALARM
  212. rt_alarm_update(&rtc_device.parent, 1);
  213. #endif
  214. LOG_D("RTC: set rtc_time %x\n", *(rt_uint32_t *)args);
  215. break;
  216. #ifdef RT_USING_ALARM
  217. case RT_DEVICE_CTRL_RTC_GET_ALARM:
  218. args = &rtc_device.wkalarm;
  219. LOG_D("GET_ALARM %d:%d:%d",rtc_device.wkalarm.tm_hour,
  220. rtc_device.wkalarm.tm_min,rtc_device.wkalarm.tm_sec);
  221. break;
  222. case RT_DEVICE_CTRL_RTC_SET_ALARM:
  223. LOG_D("RT_DEVICE_CTRL_RTC_SET_ALARM");
  224. p_wkalarm = (struct rt_rtc_wkalarm *)args;
  225. if (p_wkalarm != RT_NULL)
  226. {
  227. rtc_device.wkalarm.enable = p_wkalarm->enable;
  228. rtc_device.wkalarm.tm_hour = p_wkalarm->tm_hour;
  229. rtc_device.wkalarm.tm_min = p_wkalarm->tm_min;
  230. rtc_device.wkalarm.tm_sec = p_wkalarm->tm_sec;
  231. rtc_alarm_time_set(&rtc_device);
  232. }
  233. else
  234. {
  235. result = -RT_ERROR;
  236. LOG_E("RT_DEVICE_CTRL_RTC_SET_ALARM error!!");
  237. }
  238. LOG_D("SET_ALARM %d:%d:%d",p_wkalarm->tm_hour,
  239. p_wkalarm->tm_min,p_wkalarm->tm_sec);
  240. break;
  241. #endif
  242. }
  243. return result;
  244. }
  245. #ifdef RT_USING_DEVICE_OPS
  246. const static struct rt_device_ops rtc_ops =
  247. {
  248. RT_NULL,
  249. RT_NULL,
  250. RT_NULL,
  251. RT_NULL,
  252. RT_NULL,
  253. rt_rtc_control
  254. };
  255. #endif
  256. static rt_err_t rt_hw_rtc_register(rt_device_t device, const char *name, rt_uint32_t flag)
  257. {
  258. RT_ASSERT(device != RT_NULL);
  259. rt_rtc_init();
  260. if (rt_rtc_config(device) != RT_EOK)
  261. {
  262. return -RT_ERROR;
  263. }
  264. #ifdef RT_USING_DEVICE_OPS
  265. device->ops = &rtc_ops;
  266. #else
  267. device->init = RT_NULL;
  268. device->open = RT_NULL;
  269. device->close = RT_NULL;
  270. device->read = RT_NULL;
  271. device->write = RT_NULL;
  272. device->control = rt_rtc_control;
  273. #endif
  274. device->type = RT_Device_Class_RTC;
  275. device->rx_indicate = RT_NULL;
  276. device->tx_complete = RT_NULL;
  277. device->user_data = RT_NULL;
  278. /* register a character device */
  279. return rt_device_register(device, name, flag);
  280. }
  281. int rt_hw_rtc_init(void)
  282. {
  283. rt_err_t result;
  284. result = rt_hw_rtc_register(&rtc, "rtc", RT_DEVICE_FLAG_RDWR);
  285. if (result != RT_EOK)
  286. {
  287. LOG_E("rtc register err code: %d", result);
  288. return result;
  289. }
  290. #ifdef RT_USING_ALARM
  291. rt_rtc_alarm_init();
  292. #endif
  293. LOG_D("rtc init success");
  294. return RT_EOK;
  295. }
  296. #ifdef RT_USING_ALARM
  297. void rt_rtc_alarm_enable(void)
  298. {
  299. HAL_RTC_SetAlarm_IT(&RTC_Handler,&salarmstructure,RTC_FORMAT_BIN);
  300. HAL_RTC_GetAlarm(&RTC_Handler,&salarmstructure,RTC_ALARM_A,RTC_FORMAT_BIN);
  301. LOG_D("alarm read:%d:%d:%d", salarmstructure.AlarmTime.Hours,
  302. salarmstructure.AlarmTime.Minutes,
  303. salarmstructure.AlarmTime.Seconds);
  304. HAL_NVIC_SetPriority(RTC_Alarm_IRQn, 0x02, 0);
  305. HAL_NVIC_EnableIRQ(RTC_Alarm_IRQn);
  306. }
  307. void rt_rtc_alarm_disable(void)
  308. {
  309. HAL_RTC_DeactivateAlarm(&RTC_Handler, RTC_ALARM_A);
  310. HAL_NVIC_DisableIRQ(RTC_Alarm_IRQn);
  311. }
  312. static int rt_rtc_alarm_init(void)
  313. {
  314. return RT_EOK;
  315. }
  316. static rt_err_t rtc_alarm_time_set(struct rt_rtc_device* p_dev)
  317. {
  318. if (p_dev->wkalarm.enable)
  319. {
  320. salarmstructure.Alarm = RTC_ALARM_A;
  321. salarmstructure.AlarmTime.Hours = p_dev->wkalarm.tm_hour;
  322. salarmstructure.AlarmTime.Minutes = p_dev->wkalarm.tm_min;
  323. salarmstructure.AlarmTime.Seconds = p_dev->wkalarm.tm_sec;
  324. LOG_D("alarm set:%d:%d:%d", salarmstructure.AlarmTime.Hours,
  325. salarmstructure.AlarmTime.Minutes,
  326. salarmstructure.AlarmTime.Seconds);
  327. rt_rtc_alarm_enable();
  328. }
  329. return RT_EOK;
  330. }
  331. void HAL_RTC_AlarmAEventCallback(RTC_HandleTypeDef *hrtc)
  332. {
  333. //LOG_D("rtc alarm isr.\n");
  334. rt_alarm_update(&rtc_device.parent, 1);
  335. }
  336. void RTC_Alarm_IRQHandler(void)
  337. {
  338. rt_interrupt_enter();
  339. HAL_RTC_AlarmIRQHandler(&RTC_Handler);
  340. rt_interrupt_leave();
  341. }
  342. #endif
  343. INIT_APP_EXPORT(rt_hw_rtc_init);
  344. #endif /* BSP_USING_ONCHIP_RTC */