1
0

alarm.c 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809
  1. /*
  2. * Copyright (c) 2006-2021, RT-Thread Development Team
  3. *
  4. * SPDX-License-Identifier: Apache-2.0
  5. *
  6. * Change Logs:
  7. * Date Author Notes
  8. * 2012-10-27 heyuanjie87 first version.
  9. * 2013-05-17 aozima initial alarm event & mutex in system init.
  10. * 2020-10-15 zhangsz add alarm flags hour minute second.
  11. * 2020-11-09 zhangsz fix alarm set when modify rtc time.
  12. */
  13. #include <rtthread.h>
  14. #include <rtdevice.h>
  15. #include <sys/time.h>
  16. #define RT_RTC_YEARS_MAX 137
  17. #ifdef RT_USING_SOFT_RTC
  18. #define RT_ALARM_DELAY 0
  19. #else
  20. #define RT_ALARM_DELAY 2
  21. #endif
  22. #define RT_ALARM_STATE_INITED 0x02
  23. #define RT_ALARM_STATE_START 0x01
  24. #define RT_ALARM_STATE_STOP 0x00
  25. #if (defined(RT_USING_RTC) && defined(RT_USING_ALARM))
  26. static struct rt_alarm_container _container;
  27. rt_inline rt_uint32_t alarm_mkdaysec(struct tm *time)
  28. {
  29. rt_uint32_t sec;
  30. sec = time->tm_sec;
  31. sec += time->tm_min * 60;
  32. sec += time->tm_hour * 3600;
  33. return (sec);
  34. }
  35. static rt_err_t alarm_set(struct rt_alarm *alarm)
  36. {
  37. rt_device_t device;
  38. struct rt_rtc_wkalarm wkalarm;
  39. rt_err_t ret;
  40. device = rt_device_find("rtc");
  41. if (device == RT_NULL)
  42. {
  43. return (RT_ERROR);
  44. }
  45. if (alarm->flag & RT_ALARM_STATE_START)
  46. wkalarm.enable = RT_TRUE;
  47. else
  48. wkalarm.enable = RT_FALSE;
  49. wkalarm.tm_sec = alarm->wktime.tm_sec;
  50. wkalarm.tm_min = alarm->wktime.tm_min;
  51. wkalarm.tm_hour = alarm->wktime.tm_hour;
  52. ret = rt_device_control(device, RT_DEVICE_CTRL_RTC_SET_ALARM, &wkalarm);
  53. if ((ret == RT_EOK) && wkalarm.enable)
  54. {
  55. ret = rt_device_control(device, RT_DEVICE_CTRL_RTC_GET_ALARM, &wkalarm);
  56. if (ret == RT_EOK)
  57. {
  58. /*
  59. some RTC device like RX8025,it's alarms precision is 1 minute.
  60. in this case,low level RTC driver should set wkalarm->tm_sec to 0.
  61. */
  62. alarm->wktime.tm_sec = wkalarm.tm_sec;
  63. alarm->wktime.tm_min = wkalarm.tm_min;
  64. alarm->wktime.tm_hour = wkalarm.tm_hour;
  65. }
  66. }
  67. return (ret);
  68. }
  69. static void alarm_wakeup(struct rt_alarm *alarm, struct tm *now)
  70. {
  71. rt_uint32_t sec_alarm, sec_now;
  72. rt_bool_t wakeup = RT_FALSE;
  73. time_t timestamp;
  74. sec_alarm = alarm_mkdaysec(&alarm->wktime);
  75. sec_now = alarm_mkdaysec(now);
  76. if (alarm->flag & RT_ALARM_STATE_START)
  77. {
  78. switch (alarm->flag & 0xFF00)
  79. {
  80. case RT_ALARM_ONESHOT:
  81. {
  82. sec_alarm = timegm(&alarm->wktime);
  83. sec_now = timegm(now);
  84. if (((sec_now - sec_alarm) <= RT_ALARM_DELAY) && (sec_now >= sec_alarm))
  85. {
  86. /* stop alarm */
  87. alarm->flag &= ~RT_ALARM_STATE_START;
  88. alarm_set(alarm);
  89. wakeup = RT_TRUE;
  90. }
  91. }
  92. break;
  93. case RT_ALARM_SECOND:
  94. {
  95. alarm->wktime.tm_hour = now->tm_hour;
  96. alarm->wktime.tm_min = now->tm_min;
  97. alarm->wktime.tm_sec = now->tm_sec + 1;
  98. if (alarm->wktime.tm_sec > 59)
  99. {
  100. alarm->wktime.tm_sec = 0;
  101. alarm->wktime.tm_min = alarm->wktime.tm_min + 1;
  102. if (alarm->wktime.tm_min > 59)
  103. {
  104. alarm->wktime.tm_min = 0;
  105. alarm->wktime.tm_hour = alarm->wktime.tm_hour + 1;
  106. if (alarm->wktime.tm_hour > 23)
  107. {
  108. alarm->wktime.tm_hour = 0;
  109. }
  110. }
  111. }
  112. wakeup = RT_TRUE;
  113. }
  114. break;
  115. case RT_ALARM_MINUTE:
  116. {
  117. alarm->wktime.tm_hour = now->tm_hour;
  118. if (alarm->wktime.tm_sec == now->tm_sec)
  119. {
  120. alarm->wktime.tm_min = now->tm_min + 1;
  121. if (alarm->wktime.tm_min > 59)
  122. {
  123. alarm->wktime.tm_min = 0;
  124. alarm->wktime.tm_hour = alarm->wktime.tm_hour + 1;
  125. if (alarm->wktime.tm_hour > 23)
  126. {
  127. alarm->wktime.tm_hour = 0;
  128. }
  129. }
  130. wakeup = RT_TRUE;
  131. }
  132. }
  133. break;
  134. case RT_ALARM_HOUR:
  135. {
  136. if ((alarm->wktime.tm_min == now->tm_min) &&
  137. (alarm->wktime.tm_sec == now->tm_sec))
  138. {
  139. alarm->wktime.tm_hour = now->tm_hour + 1;
  140. if (alarm->wktime.tm_hour > 23)
  141. {
  142. alarm->wktime.tm_hour = 0;
  143. }
  144. wakeup = RT_TRUE;
  145. }
  146. }
  147. break;
  148. case RT_ALARM_DAILY:
  149. {
  150. if (((sec_now - sec_alarm) <= RT_ALARM_DELAY) && (sec_now >= sec_alarm))
  151. wakeup = RT_TRUE;
  152. }
  153. break;
  154. case RT_ALARM_WEEKLY:
  155. {
  156. /* alarm at wday */
  157. if (alarm->wktime.tm_wday == now->tm_wday)
  158. {
  159. sec_alarm += alarm->wktime.tm_wday * 24 * 3600;
  160. sec_now += now->tm_wday * 24 * 3600;
  161. if (sec_now == sec_alarm)
  162. wakeup = RT_TRUE;
  163. }
  164. }
  165. break;
  166. case RT_ALARM_MONTHLY:
  167. {
  168. /* monthly someday generate alarm signals */
  169. if (alarm->wktime.tm_mday == now->tm_mday)
  170. {
  171. if ((sec_now - sec_alarm) <= RT_ALARM_DELAY)
  172. wakeup = RT_TRUE;
  173. }
  174. }
  175. break;
  176. case RT_ALARM_YAERLY:
  177. {
  178. if ((alarm->wktime.tm_mday == now->tm_mday) && \
  179. (alarm->wktime.tm_mon == now->tm_mon))
  180. {
  181. if ((sec_now - sec_alarm) <= RT_ALARM_DELAY)
  182. wakeup = RT_TRUE;
  183. }
  184. }
  185. break;
  186. }
  187. if ((wakeup == RT_TRUE) && (alarm->callback != RT_NULL))
  188. {
  189. timestamp = (time_t)0;
  190. get_timestamp(&timestamp);
  191. alarm->callback(alarm, timestamp);
  192. }
  193. }
  194. }
  195. static void alarm_update(rt_uint32_t event)
  196. {
  197. struct rt_alarm *alm_prev = RT_NULL, *alm_next = RT_NULL;
  198. struct rt_alarm *alarm;
  199. rt_int32_t sec_now, sec_alarm, sec_tmp;
  200. rt_int32_t sec_next = 24 * 3600, sec_prev = 0;
  201. time_t timestamp;
  202. struct tm now;
  203. rt_list_t *next;
  204. rt_mutex_take(&_container.mutex, RT_WAITING_FOREVER);
  205. if (!rt_list_isempty(&_container.head))
  206. {
  207. /* get time of now */
  208. timestamp = time(RT_NULL);
  209. #ifdef _WIN32
  210. _gmtime32_s(&now, &timestamp);
  211. #else
  212. gmtime_r(&timestamp, &now);
  213. #endif
  214. for (next = _container.head.next; next != &_container.head; next = next->next)
  215. {
  216. alarm = rt_list_entry(next, struct rt_alarm, list);
  217. /* check the overtime alarm */
  218. alarm_wakeup(alarm, &now);
  219. }
  220. timestamp = time(RT_NULL);
  221. #ifdef _WIN32
  222. _gmtime32_s(&now, &timestamp);
  223. #else
  224. gmtime_r(&timestamp, &now);
  225. #endif
  226. sec_now = alarm_mkdaysec(&now);
  227. for (next = _container.head.next; next != &_container.head; next = next->next)
  228. {
  229. alarm = rt_list_entry(next, struct rt_alarm, list);
  230. /* calculate seconds from 00:00:00 */
  231. sec_alarm = alarm_mkdaysec(&alarm->wktime);
  232. if (alarm->flag & RT_ALARM_STATE_START)
  233. {
  234. sec_tmp = sec_alarm - sec_now;
  235. if (sec_tmp > 0)
  236. {
  237. /* find alarm after now(now to 23:59:59) and the most recent */
  238. if (sec_tmp < sec_next)
  239. {
  240. sec_next = sec_tmp;
  241. alm_next = alarm;
  242. }
  243. }
  244. else
  245. {
  246. /* find alarm before now(00:00:00 to now) and furthest from now */
  247. if (sec_tmp < sec_prev)
  248. {
  249. sec_prev = sec_tmp;
  250. alm_prev = alarm;
  251. }
  252. }
  253. }
  254. }
  255. /* enable the alarm after now first */
  256. if (sec_next < 24 * 3600)
  257. {
  258. if (alarm_set(alm_next) == RT_EOK)
  259. _container.current = alm_next;
  260. }
  261. else if (sec_prev < 0)
  262. {
  263. /* enable the alarm before now */
  264. if (alarm_set(alm_prev) == RT_EOK)
  265. _container.current = alm_prev;
  266. }
  267. else
  268. {
  269. if (_container.current != RT_NULL)
  270. alarm_set(_container.current);
  271. }
  272. }
  273. rt_mutex_release(&_container.mutex);
  274. }
  275. static rt_uint32_t days_of_year_month(int tm_year, int tm_mon)
  276. {
  277. rt_uint32_t ret, year;
  278. year = tm_year + 1900;
  279. if (tm_mon == 1)
  280. {
  281. ret = 28 + ((!(year % 4) && (year % 100)) || !(year % 400));
  282. }
  283. else if (((tm_mon <= 6) && (tm_mon % 2 == 0)) || ((tm_mon > 6) && (tm_mon % 2 == 1)))
  284. {
  285. ret = 31;
  286. }
  287. else
  288. {
  289. ret = 30;
  290. }
  291. return (ret);
  292. }
  293. static rt_bool_t is_valid_date(struct tm *date)
  294. {
  295. if ((date->tm_year < 0) || (date->tm_year > RT_RTC_YEARS_MAX))
  296. {
  297. return (RT_FALSE);
  298. }
  299. if ((date->tm_mon < 0) || (date->tm_mon > 11))
  300. {
  301. return (RT_FALSE);
  302. }
  303. if ((date->tm_mday < 1) || \
  304. (date->tm_mday > days_of_year_month(date->tm_year, date->tm_mon)))
  305. {
  306. return (RT_FALSE);
  307. }
  308. return (RT_TRUE);
  309. }
  310. static rt_err_t alarm_setup(rt_alarm_t alarm, struct tm *wktime)
  311. {
  312. rt_err_t ret = RT_ERROR;
  313. time_t timestamp;
  314. struct tm *setup, now;
  315. setup = &alarm->wktime;
  316. *setup = *wktime;
  317. timestamp = time(RT_NULL);
  318. #ifdef _WIN32
  319. _gmtime32_s(&now, &timestamp);
  320. #else
  321. gmtime_r(&timestamp, &now);
  322. #endif
  323. /* if these are a "don't care" value,we set them to now*/
  324. if ((setup->tm_sec > 59) || (setup->tm_sec < 0))
  325. setup->tm_sec = now.tm_sec;
  326. if ((setup->tm_min > 59) || (setup->tm_min < 0))
  327. setup->tm_min = now.tm_min;
  328. if ((setup->tm_hour > 23) || (setup->tm_hour < 0))
  329. setup->tm_hour = now.tm_hour;
  330. switch (alarm->flag & 0xFF00)
  331. {
  332. case RT_ALARM_SECOND:
  333. {
  334. alarm->wktime.tm_hour = now.tm_hour;
  335. alarm->wktime.tm_min = now.tm_min;
  336. alarm->wktime.tm_sec = now.tm_sec + 1;
  337. if (alarm->wktime.tm_sec > 59)
  338. {
  339. alarm->wktime.tm_sec = 0;
  340. alarm->wktime.tm_min = alarm->wktime.tm_min + 1;
  341. if (alarm->wktime.tm_min > 59)
  342. {
  343. alarm->wktime.tm_min = 0;
  344. alarm->wktime.tm_hour = alarm->wktime.tm_hour + 1;
  345. if (alarm->wktime.tm_hour > 23)
  346. {
  347. alarm->wktime.tm_hour = 0;
  348. }
  349. }
  350. }
  351. }
  352. break;
  353. case RT_ALARM_MINUTE:
  354. {
  355. alarm->wktime.tm_hour = now.tm_hour;
  356. alarm->wktime.tm_min = now.tm_min + 1;
  357. if (alarm->wktime.tm_min > 59)
  358. {
  359. alarm->wktime.tm_min = 0;
  360. alarm->wktime.tm_hour = alarm->wktime.tm_hour + 1;
  361. if (alarm->wktime.tm_hour > 23)
  362. {
  363. alarm->wktime.tm_hour = 0;
  364. }
  365. }
  366. }
  367. break;
  368. case RT_ALARM_HOUR:
  369. {
  370. alarm->wktime.tm_hour = now.tm_hour + 1;
  371. if (alarm->wktime.tm_hour > 23)
  372. {
  373. alarm->wktime.tm_hour = 0;
  374. }
  375. }
  376. break;
  377. case RT_ALARM_DAILY:
  378. {
  379. /* do nothing but needed */
  380. }
  381. break;
  382. case RT_ALARM_ONESHOT:
  383. {
  384. /* if these are "don't care" value we set them to now */
  385. if (setup->tm_year == RT_ALARM_TM_NOW)
  386. setup->tm_year = now.tm_year;
  387. if (setup->tm_mon == RT_ALARM_TM_NOW)
  388. setup->tm_mon = now.tm_mon;
  389. if (setup->tm_mday == RT_ALARM_TM_NOW)
  390. setup->tm_mday = now.tm_mday;
  391. /* make sure the setup is valid */
  392. if (!is_valid_date(setup))
  393. goto _exit;
  394. }
  395. break;
  396. case RT_ALARM_WEEKLY:
  397. {
  398. /* if tm_wday is a "don't care" value we set it to now */
  399. if ((setup->tm_wday < 0) || (setup->tm_wday > 6))
  400. setup->tm_wday = now.tm_wday;
  401. }
  402. break;
  403. case RT_ALARM_MONTHLY:
  404. {
  405. /* if tm_mday is a "don't care" value we set it to now */
  406. if ((setup->tm_mday < 1) || (setup->tm_mday > 31))
  407. setup->tm_mday = now.tm_mday;
  408. }
  409. break;
  410. case RT_ALARM_YAERLY:
  411. {
  412. /* if tm_mon is a "don't care" value we set it to now */
  413. if ((setup->tm_mon < 0) || (setup->tm_mon > 11))
  414. setup->tm_mon = now.tm_mon;
  415. if (setup->tm_mon == 1)
  416. {
  417. /* tm_mon is February */
  418. /* tm_mday should be 1~29.otherwise,it's a "don't care" value */
  419. if ((setup->tm_mday < 1) || (setup->tm_mday > 29))
  420. setup->tm_mday = now.tm_mday;
  421. }
  422. else if (((setup->tm_mon <= 6) && (setup->tm_mon % 2 == 0)) || \
  423. ((setup->tm_mon > 6) && (setup->tm_mon % 2 == 1)))
  424. {
  425. /* Jan,Mar,May,Jul,Aug,Oct,Dec */
  426. /* tm_mday should be 1~31.otherwise,it's a "don't care" value */
  427. if ((setup->tm_mday < 1) || (setup->tm_mday > 31))
  428. setup->tm_mday = now.tm_mday;
  429. }
  430. else
  431. {
  432. /* tm_mday should be 1~30.otherwise,it's a "don't care" value */
  433. if ((setup->tm_mday < 1) || (setup->tm_mday > 30))
  434. setup->tm_mday = now.tm_mday;
  435. }
  436. }
  437. break;
  438. default:
  439. {
  440. goto _exit;
  441. }
  442. }
  443. if ((setup->tm_hour == 23) && (setup->tm_min == 59) && (setup->tm_sec == 59))
  444. {
  445. /*
  446. for insurance purposes, we will generate an alarm
  447. signal two seconds ahead of.
  448. */
  449. setup->tm_sec = 60 - RT_ALARM_DELAY;
  450. }
  451. /* set initialized state */
  452. alarm->flag |= RT_ALARM_STATE_INITED;
  453. ret = RT_EOK;
  454. _exit:
  455. return (ret);
  456. }
  457. /** \brief send a rtc alarm event
  458. *
  459. * \param dev pointer to RTC device(currently unused,you can ignore it)
  460. * \param event RTC event(currently unused)
  461. * \return none
  462. */
  463. void rt_alarm_update(rt_device_t dev, rt_uint32_t event)
  464. {
  465. rt_event_send(&_container.event, 1);
  466. }
  467. /** \brief modify the alarm setup
  468. *
  469. * \param alarm pointer to alarm
  470. * \param cmd control command
  471. * \param arg argument
  472. */
  473. rt_err_t rt_alarm_control(rt_alarm_t alarm, int cmd, void *arg)
  474. {
  475. rt_err_t ret = RT_ERROR;
  476. RT_ASSERT(alarm != RT_NULL);
  477. rt_mutex_take(&_container.mutex, RT_WAITING_FOREVER);
  478. switch (cmd)
  479. {
  480. case RT_ALARM_CTRL_MODIFY:
  481. {
  482. struct rt_alarm_setup *setup;
  483. RT_ASSERT(arg != RT_NULL);
  484. setup = arg;
  485. rt_alarm_stop(alarm);
  486. alarm->flag = setup->flag & 0xFF00;
  487. alarm->wktime = setup->wktime;
  488. ret = alarm_setup(alarm, &alarm->wktime);
  489. }
  490. break;
  491. }
  492. rt_mutex_release(&_container.mutex);
  493. return (ret);
  494. }
  495. /** \brief start an alarm
  496. *
  497. * \param alarm pointer to alarm
  498. * \return RT_EOK
  499. */
  500. rt_err_t rt_alarm_start(rt_alarm_t alarm)
  501. {
  502. rt_int32_t sec_now, sec_old, sec_new;
  503. rt_err_t ret = RT_EOK;
  504. time_t timestamp;
  505. struct tm now;
  506. if (alarm == RT_NULL)
  507. return (RT_ERROR);
  508. rt_mutex_take(&_container.mutex, RT_WAITING_FOREVER);
  509. if (!(alarm->flag & RT_ALARM_STATE_START))
  510. {
  511. if (alarm_setup(alarm, &alarm->wktime) != RT_EOK)
  512. {
  513. ret = RT_ERROR;
  514. goto _exit;
  515. }
  516. timestamp = time(RT_NULL);
  517. #ifdef _WIN32
  518. _gmtime32_s(&now, &timestamp);
  519. #else
  520. gmtime_r(&timestamp, &now);
  521. #endif
  522. alarm->flag |= RT_ALARM_STATE_START;
  523. /* set alarm */
  524. if (_container.current == RT_NULL)
  525. {
  526. ret = alarm_set(alarm);
  527. }
  528. else
  529. {
  530. sec_now = alarm_mkdaysec(&now);
  531. sec_old = alarm_mkdaysec(&_container.current->wktime);
  532. sec_new = alarm_mkdaysec(&alarm->wktime);
  533. if ((sec_new < sec_old) && (sec_new > sec_now))
  534. {
  535. ret = alarm_set(alarm);
  536. }
  537. else if ((sec_new > sec_now) && (sec_old < sec_now))
  538. {
  539. ret = alarm_set(alarm);
  540. }
  541. else if ((sec_new < sec_old) && (sec_old < sec_now))
  542. {
  543. ret = alarm_set(alarm);
  544. }
  545. else
  546. {
  547. ret = RT_EOK;
  548. goto _exit;
  549. }
  550. }
  551. if (ret == RT_EOK)
  552. {
  553. _container.current = alarm;
  554. }
  555. }
  556. _exit:
  557. rt_mutex_release(&_container.mutex);
  558. return (ret);
  559. }
  560. /** \brief stop an alarm
  561. *
  562. * \param alarm pointer to alarm
  563. * \return RT_EOK
  564. */
  565. rt_err_t rt_alarm_stop(rt_alarm_t alarm)
  566. {
  567. rt_err_t ret = RT_EOK;
  568. if (alarm == RT_NULL)
  569. return (RT_ERROR);
  570. rt_mutex_take(&_container.mutex, RT_WAITING_FOREVER);
  571. if (!(alarm->flag & RT_ALARM_STATE_START))
  572. goto _exit;
  573. /* stop alarm */
  574. alarm->flag &= ~RT_ALARM_STATE_START;
  575. if (_container.current == alarm)
  576. {
  577. ret = alarm_set(alarm);
  578. _container.current = RT_NULL;
  579. }
  580. if (ret == RT_EOK)
  581. alarm_update(0);
  582. _exit:
  583. rt_mutex_release(&_container.mutex);
  584. return (ret);
  585. }
  586. /** \brief delete an alarm
  587. *
  588. * \param alarm pointer to alarm
  589. * \return RT_EOK
  590. */
  591. rt_err_t rt_alarm_delete(rt_alarm_t alarm)
  592. {
  593. rt_err_t ret = RT_EOK;
  594. if (alarm == RT_NULL)
  595. return RT_ERROR;
  596. rt_mutex_take(&_container.mutex, RT_WAITING_FOREVER);
  597. /* stop the alarm */
  598. alarm->flag &= ~RT_ALARM_STATE_START;
  599. if (_container.current == alarm)
  600. {
  601. ret = alarm_set(alarm);
  602. _container.current = RT_NULL;
  603. /* set new alarm if necessary */
  604. alarm_update(0);
  605. }
  606. rt_list_remove(&alarm->list);
  607. rt_free(alarm);
  608. rt_mutex_release(&_container.mutex);
  609. return (ret);
  610. }
  611. /** \brief create an alarm
  612. *
  613. * \param flag set alarm mode e.g: RT_ALARM_DAILY
  614. * \param setup pointer to setup infomation
  615. */
  616. rt_alarm_t rt_alarm_create(rt_alarm_callback_t callback, struct rt_alarm_setup *setup)
  617. {
  618. struct rt_alarm *alarm;
  619. if (setup == RT_NULL)
  620. return (RT_NULL);
  621. alarm = rt_malloc(sizeof(struct rt_alarm));
  622. if (alarm == RT_NULL)
  623. return (RT_NULL);
  624. rt_list_init(&alarm->list);
  625. alarm->wktime = setup->wktime;
  626. alarm->flag = setup->flag & 0xFF00;
  627. alarm->callback = callback;
  628. rt_mutex_take(&_container.mutex, RT_WAITING_FOREVER);
  629. rt_list_insert_after(&_container.head, &alarm->list);
  630. rt_mutex_release(&_container.mutex);
  631. return (alarm);
  632. }
  633. /** \brief rtc alarm service thread entry
  634. *
  635. */
  636. static void rt_alarmsvc_thread_init(void *param)
  637. {
  638. rt_uint32_t recv;
  639. _container.current = RT_NULL;
  640. while (1)
  641. {
  642. if (rt_event_recv(&_container.event, 0xFFFF,
  643. RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
  644. RT_WAITING_FOREVER, &recv) == RT_EOK)
  645. {
  646. alarm_update(recv);
  647. }
  648. }
  649. }
  650. struct _alarm_flag
  651. {
  652. const char* name;
  653. rt_uint32_t flag;
  654. };
  655. static const struct _alarm_flag _alarm_flag_tbl[] =
  656. {
  657. {"N", 0xffff}, /* none */
  658. {"O", RT_ALARM_ONESHOT}, /* only alarm onece */
  659. {"D", RT_ALARM_DAILY}, /* alarm everyday */
  660. {"W", RT_ALARM_WEEKLY}, /* alarm weekly at Monday or Friday etc. */
  661. {"Mo", RT_ALARM_MONTHLY}, /* alarm monthly at someday */
  662. {"Y", RT_ALARM_YAERLY}, /* alarm yearly at a certain date */
  663. {"H", RT_ALARM_HOUR}, /* alarm each hour at a certain min:second */
  664. {"M", RT_ALARM_MINUTE}, /* alarm each minute at a certain second */
  665. {"S", RT_ALARM_SECOND}, /* alarm each second */
  666. };
  667. static rt_uint8_t _alarm_flag_tbl_size = sizeof(_alarm_flag_tbl) / sizeof(_alarm_flag_tbl[0]);
  668. static rt_uint8_t get_alarm_flag_index(rt_uint32_t alarm_flag)
  669. {
  670. for (rt_uint8_t index = 0; index < _alarm_flag_tbl_size; index++)
  671. {
  672. alarm_flag &= 0xff00;
  673. if (alarm_flag == _alarm_flag_tbl[index].flag)
  674. {
  675. return index;
  676. }
  677. }
  678. return 0;
  679. }
  680. void rt_alarm_dump(void)
  681. {
  682. rt_list_t *next;
  683. rt_alarm_t alarm;
  684. rt_uint8_t index = 0;
  685. rt_kprintf("| id | YYYY-MM-DD hh:mm:ss | week | flag | en |\n");
  686. rt_kprintf("+----+---------------------+------+------+----+\n");
  687. for (next = _container.head.next; next != &_container.head; next = next->next)
  688. {
  689. alarm = rt_list_entry(next, struct rt_alarm, list);
  690. rt_uint8_t flag_index = get_alarm_flag_index(alarm->flag);
  691. rt_kprintf("| %2d | %04d-%02d-%02d %02d:%02d:%02d | %2d | %2s | %2d |\n",
  692. index++, alarm->wktime.tm_year + 1900, alarm->wktime.tm_mon + 1, alarm->wktime.tm_mday,
  693. alarm->wktime.tm_hour, alarm->wktime.tm_min, alarm->wktime.tm_sec,
  694. alarm->wktime.tm_wday, _alarm_flag_tbl[flag_index].name, alarm->flag & RT_ALARM_STATE_START);
  695. }
  696. rt_kprintf("+----+---------------------+------+------+----+\n");
  697. }
  698. MSH_CMD_EXPORT_ALIAS(rt_alarm_dump, rt_alarm_dump, dump alarm info);
  699. /** \brief initialize alarm service system
  700. *
  701. * \param none
  702. * \return none
  703. */
  704. int rt_alarm_system_init(void)
  705. {
  706. rt_thread_t tid;
  707. rt_list_init(&_container.head);
  708. rt_event_init(&_container.event, "alarmsvc", RT_IPC_FLAG_FIFO);
  709. rt_mutex_init(&_container.mutex, "alarmsvc", RT_IPC_FLAG_PRIO);
  710. tid = rt_thread_create("alarmsvc",
  711. rt_alarmsvc_thread_init, RT_NULL,
  712. 2048, 10, 5);
  713. if (tid != RT_NULL)
  714. rt_thread_startup(tid);
  715. return 0;
  716. }
  717. INIT_PREV_EXPORT(rt_alarm_system_init);
  718. #endif