lpc_rtc.c 36 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998
  1. /**********************************************************************
  2. * $Id$ lpc_rtc.c 2011-06-02
  3. *//**
  4. * @file lpc_rtc.c
  5. * @brief Contains all functions support for RTC firmware library
  6. * on LPC
  7. * @version 1.0
  8. * @date 02. June. 2011
  9. * @author NXP MCU SW Application Team
  10. *
  11. * Copyright(C) 2011, NXP Semiconductor
  12. * All rights reserved.
  13. *
  14. ***********************************************************************
  15. * Software that is described herein is for illustrative purposes only
  16. * which provides customers with programming information regarding the
  17. * products. This software is supplied "AS IS" without any warranties.
  18. * NXP Semiconductors assumes no responsibility or liability for the
  19. * use of the software, conveys no license or title under any patent,
  20. * copyright, or mask work right to the product. NXP Semiconductors
  21. * reserves the right to make changes in the software without
  22. * notification. NXP Semiconductors also make no representation or
  23. * warranty that such application will be suitable for the specified
  24. * use without further testing or modification.
  25. * Permission to use, copy, modify, and distribute this software and its
  26. * documentation is hereby granted, under NXP Semiconductors'
  27. * relevant copyright in the software, without fee, provided that it
  28. * is used in conjunction with NXP Semiconductors microcontrollers. This
  29. * copyright, permission, and disclaimer notice must appear in all copies of
  30. * this code.
  31. **********************************************************************/
  32. /* Peripheral group ----------------------------------------------------------- */
  33. /** @addtogroup RTC
  34. * @{
  35. */
  36. #ifdef __BUILD_WITH_EXAMPLE__
  37. #include "lpc_libcfg.h"
  38. #else
  39. #include "lpc_libcfg_default.h"
  40. #endif /* __BUILD_WITH_EXAMPLE__ */
  41. #ifdef _RTC
  42. /* Includes ------------------------------------------------------------------- */
  43. #include "lpc_rtc.h"
  44. #include "lpc_clkpwr.h"
  45. /* Public Functions ----------------------------------------------------------- */
  46. /** @addtogroup RTC_Public_Functions
  47. * @{
  48. */
  49. /********************************************************************//**
  50. * @brief Initializes the RTC peripheral.
  51. * @param[in] RTCx RTC peripheral selected, should be LPC_RTC
  52. * @return None
  53. *********************************************************************/
  54. void RTC_Init (LPC_RTC_TypeDef *RTCx)
  55. {
  56. /* Set up clock and power for RTC module */
  57. CLKPWR_ConfigPPWR (CLKPWR_PCONP_PCRTC, ENABLE);
  58. // Clear all register to be default
  59. RTCx->ILR = 0x00;
  60. RTCx->CCR = 0x00;
  61. RTCx->CIIR = 0x00;
  62. RTCx->AMR = 0xFF;
  63. RTCx->CALIBRATION = 0x00;
  64. }
  65. /*********************************************************************//**
  66. * @brief De-initializes the RTC peripheral registers to their
  67. * default reset values.
  68. * @param[in] RTCx RTC peripheral selected, should be LPC_RTC
  69. * @return None
  70. **********************************************************************/
  71. void RTC_DeInit(LPC_RTC_TypeDef *RTCx)
  72. {
  73. RTCx->CCR = 0x00;
  74. // Disable power and clock for RTC module
  75. CLKPWR_ConfigPPWR (CLKPWR_PCONP_PCRTC, DISABLE);
  76. }
  77. /*********************************************************************//**
  78. * @brief Reset clock tick counter in RTC peripheral
  79. * @param[in] RTCx RTC peripheral selected, should be LPC_RTC
  80. * @return None
  81. **********************************************************************/
  82. void RTC_ResetClockTickCounter(LPC_RTC_TypeDef *RTCx)
  83. {
  84. RTCx->CCR |= RTC_CCR_CTCRST;
  85. RTCx->CCR &= (~RTC_CCR_CTCRST) & RTC_CCR_BITMASK;
  86. }
  87. /*********************************************************************//**
  88. * @brief Start/Stop RTC peripheral
  89. * @param[in] RTCx RTC peripheral selected, should be LPC_RTC
  90. * @param[in] NewState New State of this function, should be:
  91. * - ENABLE: The time counters are enabled
  92. * - DISABLE: The time counters are disabled
  93. * @return None
  94. **********************************************************************/
  95. void RTC_Cmd (LPC_RTC_TypeDef *RTCx, FunctionalState NewState)
  96. {
  97. if (NewState == ENABLE)
  98. {
  99. RTCx->CCR |= RTC_CCR_CLKEN;
  100. }
  101. else
  102. {
  103. RTCx->CCR &= (~RTC_CCR_CLKEN) & RTC_CCR_BITMASK;
  104. }
  105. }
  106. /*********************************************************************//**
  107. * @brief Enable/Disable Counter increment interrupt for each time type
  108. * in RTC peripheral
  109. * @param[in] RTCx RTC peripheral selected, should be LPC_RTC
  110. * @param[in] CntIncrIntType: Counter Increment Interrupt type,
  111. * an increment of this type value below will generates
  112. * an interrupt, should be:
  113. * - RTC_TIMETYPE_SECOND
  114. * - RTC_TIMETYPE_MINUTE
  115. * - RTC_TIMETYPE_HOUR
  116. * - RTC_TIMETYPE_DAYOFWEEK
  117. * - RTC_TIMETYPE_DAYOFMONTH
  118. * - RTC_TIMETYPE_DAYOFYEAR
  119. * - RTC_TIMETYPE_MONTH
  120. * - RTC_TIMETYPE_YEAR
  121. * @param[in] NewState New State of this function, should be:
  122. * - ENABLE: Counter Increment interrupt for this
  123. * time type are enabled
  124. * - DISABLE: Counter Increment interrupt for this
  125. * time type are disabled
  126. * @return None
  127. **********************************************************************/
  128. void RTC_CntIncrIntConfig (LPC_RTC_TypeDef *RTCx, uint32_t CntIncrIntType, \
  129. FunctionalState NewState)
  130. {
  131. if (NewState == ENABLE)
  132. {
  133. switch (CntIncrIntType)
  134. {
  135. case RTC_TIMETYPE_SECOND:
  136. RTCx->CIIR |= RTC_CIIR_IMSEC;
  137. break;
  138. case RTC_TIMETYPE_MINUTE:
  139. RTCx->CIIR |= RTC_CIIR_IMMIN;
  140. break;
  141. case RTC_TIMETYPE_HOUR:
  142. RTCx->CIIR |= RTC_CIIR_IMHOUR;
  143. break;
  144. case RTC_TIMETYPE_DAYOFWEEK:
  145. RTCx->CIIR |= RTC_CIIR_IMDOW;
  146. break;
  147. case RTC_TIMETYPE_DAYOFMONTH:
  148. RTCx->CIIR |= RTC_CIIR_IMDOM;
  149. break;
  150. case RTC_TIMETYPE_DAYOFYEAR:
  151. RTCx->CIIR |= RTC_CIIR_IMDOY;
  152. break;
  153. case RTC_TIMETYPE_MONTH:
  154. RTCx->CIIR |= RTC_CIIR_IMMON;
  155. break;
  156. case RTC_TIMETYPE_YEAR:
  157. RTCx->CIIR |= RTC_CIIR_IMYEAR;
  158. break;
  159. }
  160. }
  161. else
  162. {
  163. switch (CntIncrIntType)
  164. {
  165. case RTC_TIMETYPE_SECOND:
  166. RTCx->CIIR &= (~RTC_CIIR_IMSEC) & RTC_CIIR_BITMASK;
  167. break;
  168. case RTC_TIMETYPE_MINUTE:
  169. RTCx->CIIR &= (~RTC_CIIR_IMMIN) & RTC_CIIR_BITMASK;
  170. break;
  171. case RTC_TIMETYPE_HOUR:
  172. RTCx->CIIR &= (~RTC_CIIR_IMHOUR) & RTC_CIIR_BITMASK;
  173. break;
  174. case RTC_TIMETYPE_DAYOFWEEK:
  175. RTCx->CIIR &= (~RTC_CIIR_IMDOW) & RTC_CIIR_BITMASK;
  176. break;
  177. case RTC_TIMETYPE_DAYOFMONTH:
  178. RTCx->CIIR &= (~RTC_CIIR_IMDOM) & RTC_CIIR_BITMASK;
  179. break;
  180. case RTC_TIMETYPE_DAYOFYEAR:
  181. RTCx->CIIR &= (~RTC_CIIR_IMDOY) & RTC_CIIR_BITMASK;
  182. break;
  183. case RTC_TIMETYPE_MONTH:
  184. RTCx->CIIR &= (~RTC_CIIR_IMMON) & RTC_CIIR_BITMASK;
  185. break;
  186. case RTC_TIMETYPE_YEAR:
  187. RTCx->CIIR &= (~RTC_CIIR_IMYEAR) & RTC_CIIR_BITMASK;
  188. break;
  189. }
  190. }
  191. }
  192. /*********************************************************************//**
  193. * @brief Enable/Disable Alarm interrupt for each time type
  194. * in RTC peripheral
  195. * @param[in] RTCx RTC peripheral selected, should be LPC_RTC
  196. * @param[in] AlarmTimeType: Alarm Time Interrupt type,
  197. * an matching of this type value below with current time
  198. * in RTC will generates an interrupt, should be:
  199. * - RTC_TIMETYPE_SECOND
  200. * - RTC_TIMETYPE_MINUTE
  201. * - RTC_TIMETYPE_HOUR
  202. * - RTC_TIMETYPE_DAYOFWEEK
  203. * - RTC_TIMETYPE_DAYOFMONTH
  204. * - RTC_TIMETYPE_DAYOFYEAR
  205. * - RTC_TIMETYPE_MONTH
  206. * - RTC_TIMETYPE_YEAR
  207. * @param[in] NewState New State of this function, should be:
  208. * - ENABLE: Alarm interrupt for this
  209. * time type are enabled
  210. * - DISABLE: Alarm interrupt for this
  211. * time type are disabled
  212. * @return None
  213. **********************************************************************/
  214. void RTC_AlarmIntConfig (LPC_RTC_TypeDef *RTCx, uint32_t AlarmTimeType, \
  215. FunctionalState NewState)
  216. {
  217. if (NewState == ENABLE)
  218. {
  219. switch (AlarmTimeType)
  220. {
  221. case RTC_TIMETYPE_SECOND:
  222. RTCx->AMR &= (~RTC_AMR_AMRSEC) & RTC_AMR_BITMASK;
  223. break;
  224. case RTC_TIMETYPE_MINUTE:
  225. RTCx->AMR &= (~RTC_AMR_AMRMIN) & RTC_AMR_BITMASK;
  226. break;
  227. case RTC_TIMETYPE_HOUR:
  228. RTCx->AMR &= (~RTC_AMR_AMRHOUR) & RTC_AMR_BITMASK;
  229. break;
  230. case RTC_TIMETYPE_DAYOFWEEK:
  231. RTCx->AMR &= (~RTC_AMR_AMRDOW) & RTC_AMR_BITMASK;
  232. break;
  233. case RTC_TIMETYPE_DAYOFMONTH:
  234. RTCx->AMR &= (~RTC_AMR_AMRDOM) & RTC_AMR_BITMASK;
  235. break;
  236. case RTC_TIMETYPE_DAYOFYEAR:
  237. RTCx->AMR &= (~RTC_AMR_AMRDOY) & RTC_AMR_BITMASK;
  238. break;
  239. case RTC_TIMETYPE_MONTH:
  240. RTCx->AMR &= (~RTC_AMR_AMRMON) & RTC_AMR_BITMASK;
  241. break;
  242. case RTC_TIMETYPE_YEAR:
  243. RTCx->AMR &= (~RTC_AMR_AMRYEAR) & RTC_AMR_BITMASK;
  244. break;
  245. }
  246. }
  247. else
  248. {
  249. switch (AlarmTimeType)
  250. {
  251. case RTC_TIMETYPE_SECOND:
  252. RTCx->AMR |= (RTC_AMR_AMRSEC);
  253. break;
  254. case RTC_TIMETYPE_MINUTE:
  255. RTCx->AMR |= (RTC_AMR_AMRMIN);
  256. break;
  257. case RTC_TIMETYPE_HOUR:
  258. RTCx->AMR |= (RTC_AMR_AMRHOUR);
  259. break;
  260. case RTC_TIMETYPE_DAYOFWEEK:
  261. RTCx->AMR |= (RTC_AMR_AMRDOW);
  262. break;
  263. case RTC_TIMETYPE_DAYOFMONTH:
  264. RTCx->AMR |= (RTC_AMR_AMRDOM);
  265. break;
  266. case RTC_TIMETYPE_DAYOFYEAR:
  267. RTCx->AMR |= (RTC_AMR_AMRDOY);
  268. break;
  269. case RTC_TIMETYPE_MONTH:
  270. RTCx->AMR |= (RTC_AMR_AMRMON);
  271. break;
  272. case RTC_TIMETYPE_YEAR:
  273. RTCx->AMR |= (RTC_AMR_AMRYEAR);
  274. break;
  275. }
  276. }
  277. }
  278. /*********************************************************************//**
  279. * @brief Set current time value for each time type in RTC peripheral
  280. * @param[in] RTCx RTC peripheral selected, should be LPC_RTC
  281. * @param[in] Timetype: Time Type, should be:
  282. * - RTC_TIMETYPE_SECOND
  283. * - RTC_TIMETYPE_MINUTE
  284. * - RTC_TIMETYPE_HOUR
  285. * - RTC_TIMETYPE_DAYOFWEEK
  286. * - RTC_TIMETYPE_DAYOFMONTH
  287. * - RTC_TIMETYPE_DAYOFYEAR
  288. * - RTC_TIMETYPE_MONTH
  289. * - RTC_TIMETYPE_YEAR
  290. * @param[in] TimeValue Time value to set
  291. * @return None
  292. **********************************************************************/
  293. void RTC_SetTime (LPC_RTC_TypeDef *RTCx, uint32_t Timetype, uint32_t TimeValue)
  294. {
  295. switch ( Timetype)
  296. {
  297. case RTC_TIMETYPE_SECOND:
  298. if(TimeValue <= RTC_SECOND_MAX)
  299. RTCx->SEC = TimeValue & RTC_SEC_MASK;
  300. break;
  301. case RTC_TIMETYPE_MINUTE:
  302. if(TimeValue <= RTC_MINUTE_MAX)
  303. RTCx->MIN = TimeValue & RTC_MIN_MASK;
  304. break;
  305. case RTC_TIMETYPE_HOUR:
  306. if(TimeValue <= RTC_HOUR_MAX)
  307. RTCx->HOUR = TimeValue & RTC_HOUR_MASK;
  308. break;
  309. case RTC_TIMETYPE_DAYOFWEEK:
  310. if(TimeValue <= RTC_DAYOFWEEK_MAX)
  311. RTCx->DOW = TimeValue & RTC_DOW_MASK;
  312. break;
  313. case RTC_TIMETYPE_DAYOFMONTH:
  314. if((TimeValue >= RTC_DAYOFMONTH_MIN)&&(TimeValue <= RTC_DAYOFMONTH_MAX))
  315. RTCx->DOM = TimeValue & RTC_DOM_MASK;
  316. break;
  317. case RTC_TIMETYPE_DAYOFYEAR:
  318. if((TimeValue >= RTC_DAYOFYEAR_MIN)&&(TimeValue <= RTC_DAYOFYEAR_MAX))
  319. RTCx->DOY = TimeValue & RTC_DOY_MASK;
  320. break;
  321. case RTC_TIMETYPE_MONTH:
  322. if((TimeValue >= RTC_MONTH_MIN)&&(TimeValue <= RTC_MONTH_MAX))
  323. RTCx->MONTH = TimeValue & RTC_MONTH_MASK;
  324. break;
  325. case RTC_TIMETYPE_YEAR:
  326. if(TimeValue <= RTC_YEAR_MAX)
  327. RTCx->YEAR = TimeValue & RTC_YEAR_MASK;
  328. break;
  329. }
  330. }
  331. /*********************************************************************//**
  332. * @brief Get current time value for each type time type
  333. * @param[in] RTCx RTC peripheral selected, should be LPC_RTC
  334. * @param[in] Timetype: Time Type, should be:
  335. * - RTC_TIMETYPE_SECOND
  336. * - RTC_TIMETYPE_MINUTE
  337. * - RTC_TIMETYPE_HOUR
  338. * - RTC_TIMETYPE_DAYOFWEEK
  339. * - RTC_TIMETYPE_DAYOFMONTH
  340. * - RTC_TIMETYPE_DAYOFYEAR
  341. * - RTC_TIMETYPE_MONTH
  342. * - RTC_TIMETYPE_YEAR
  343. * @return Value of time according to specified time type
  344. **********************************************************************/
  345. uint32_t RTC_GetTime(LPC_RTC_TypeDef *RTCx, uint32_t Timetype)
  346. {
  347. switch (Timetype)
  348. {
  349. case RTC_TIMETYPE_SECOND:
  350. return (RTCx->SEC & RTC_SEC_MASK);
  351. case RTC_TIMETYPE_MINUTE:
  352. return (RTCx->MIN & RTC_MIN_MASK);
  353. case RTC_TIMETYPE_HOUR:
  354. return (RTCx->HOUR & RTC_HOUR_MASK);
  355. case RTC_TIMETYPE_DAYOFWEEK:
  356. return (RTCx->DOW & RTC_DOW_MASK);
  357. case RTC_TIMETYPE_DAYOFMONTH:
  358. return (RTCx->DOM & RTC_DOM_MASK);
  359. case RTC_TIMETYPE_DAYOFYEAR:
  360. return (RTCx->DOY & RTC_DOY_MASK);
  361. case RTC_TIMETYPE_MONTH:
  362. return (RTCx->MONTH & RTC_MONTH_MASK);
  363. case RTC_TIMETYPE_YEAR:
  364. return (RTCx->YEAR & RTC_YEAR_MASK);
  365. default:
  366. return (0);
  367. }
  368. }
  369. /*********************************************************************//**
  370. * @brief Set full of time in RTC peripheral
  371. * @param[in] RTCx RTC peripheral selected, should be LPC_RTC
  372. * @param[in] pFullTime Pointer to a RTC_TIME_Type structure that
  373. * contains time value in full.
  374. * @return None
  375. **********************************************************************/
  376. void RTC_SetFullTime (LPC_RTC_TypeDef *RTCx, RTC_TIME_Type *pFullTime)
  377. {
  378. RTCx->DOM = pFullTime->DOM & RTC_DOM_MASK;
  379. RTCx->DOW = pFullTime->DOW & RTC_DOW_MASK;
  380. RTCx->DOY = pFullTime->DOY & RTC_DOY_MASK;
  381. RTCx->HOUR = pFullTime->HOUR & RTC_HOUR_MASK;
  382. RTCx->MIN = pFullTime->MIN & RTC_MIN_MASK;
  383. RTCx->SEC = pFullTime->SEC & RTC_SEC_MASK;
  384. RTCx->MONTH = pFullTime->MONTH & RTC_MONTH_MASK;
  385. RTCx->YEAR = pFullTime->YEAR & RTC_YEAR_MASK;
  386. }
  387. /*********************************************************************//**
  388. * @brief Get full of time in RTC peripheral
  389. * @param[in] RTCx RTC peripheral selected, should be LPC_RTC
  390. * @param[in] pFullTime Pointer to a RTC_TIME_Type structure that
  391. * will be stored time in full.
  392. * @return None
  393. **********************************************************************/
  394. void RTC_GetFullTime (LPC_RTC_TypeDef *RTCx, RTC_TIME_Type *pFullTime)
  395. {
  396. pFullTime->DOM = RTCx->DOM & RTC_DOM_MASK;
  397. pFullTime->DOW = RTCx->DOW & RTC_DOW_MASK;
  398. pFullTime->DOY = RTCx->DOY & RTC_DOY_MASK;
  399. pFullTime->HOUR = RTCx->HOUR & RTC_HOUR_MASK;
  400. pFullTime->MIN = RTCx->MIN & RTC_MIN_MASK;
  401. pFullTime->SEC = RTCx->SEC & RTC_SEC_MASK;
  402. pFullTime->MONTH = RTCx->MONTH & RTC_MONTH_MASK;
  403. pFullTime->YEAR = RTCx->YEAR & RTC_YEAR_MASK;
  404. }
  405. /*********************************************************************//**
  406. * @brief Set alarm time value for each time type
  407. * @param[in] RTCx RTC peripheral selected, should be LPC_RTC
  408. * @param[in] Timetype: Time Type, should be:
  409. * - RTC_TIMETYPE_SECOND
  410. * - RTC_TIMETYPE_MINUTE
  411. * - RTC_TIMETYPE_HOUR
  412. * - RTC_TIMETYPE_DAYOFWEEK
  413. * - RTC_TIMETYPE_DAYOFMONTH
  414. * - RTC_TIMETYPE_DAYOFYEAR
  415. * - RTC_TIMETYPE_MONTH
  416. * - RTC_TIMETYPE_YEAR
  417. * @param[in] ALValue Alarm time value to set
  418. * @return None
  419. **********************************************************************/
  420. void RTC_SetAlarmTime (LPC_RTC_TypeDef *RTCx, uint32_t Timetype, uint32_t ALValue)
  421. {
  422. switch (Timetype)
  423. {
  424. case RTC_TIMETYPE_SECOND:
  425. if(ALValue <= RTC_SECOND_MAX)
  426. RTCx->ALSEC = ALValue & RTC_SEC_MASK;
  427. break;
  428. case RTC_TIMETYPE_MINUTE:
  429. if(ALValue <= RTC_MINUTE_MAX)
  430. RTCx->ALMIN = ALValue & RTC_MIN_MASK;
  431. break;
  432. case RTC_TIMETYPE_HOUR:
  433. if(ALValue <= RTC_HOUR_MAX)
  434. RTCx->ALHOUR = ALValue & RTC_HOUR_MASK;
  435. break;
  436. case RTC_TIMETYPE_DAYOFWEEK:
  437. if(ALValue <= RTC_DAYOFWEEK_MAX)
  438. RTCx->ALDOW = ALValue & RTC_DOW_MASK;
  439. break;
  440. case RTC_TIMETYPE_DAYOFMONTH:
  441. if((ALValue >= RTC_DAYOFMONTH_MIN)&&(ALValue <= RTC_DAYOFMONTH_MAX))
  442. RTCx->ALDOM = ALValue & RTC_DOM_MASK;
  443. break;
  444. case RTC_TIMETYPE_DAYOFYEAR:
  445. if((ALValue >= RTC_DAYOFYEAR_MIN)&&(ALValue <= RTC_DAYOFYEAR_MAX))
  446. RTCx->ALDOY = ALValue & RTC_DOY_MASK;
  447. break;
  448. case RTC_TIMETYPE_MONTH:
  449. if((ALValue >= RTC_MONTH_MIN)&&(ALValue <= RTC_MONTH_MAX))
  450. RTCx->ALMON = ALValue & RTC_MONTH_MASK;
  451. break;
  452. case RTC_TIMETYPE_YEAR:
  453. if(ALValue <= RTC_YEAR_MAX)
  454. RTCx->ALYEAR = ALValue & RTC_YEAR_MASK;
  455. break;
  456. }
  457. }
  458. /*********************************************************************//**
  459. * @brief Get alarm time value for each time type
  460. * @param[in] RTCx RTC peripheral selected, should be LPC_RTC
  461. * @param[in] Timetype: Time Type, should be:
  462. * - RTC_TIMETYPE_SECOND
  463. * - RTC_TIMETYPE_MINUTE
  464. * - RTC_TIMETYPE_HOUR
  465. * - RTC_TIMETYPE_DAYOFWEEK
  466. * - RTC_TIMETYPE_DAYOFMONTH
  467. * - RTC_TIMETYPE_DAYOFYEAR
  468. * - RTC_TIMETYPE_MONTH
  469. * - RTC_TIMETYPE_YEAR
  470. * @return Value of Alarm time according to specified time type
  471. **********************************************************************/
  472. uint32_t RTC_GetAlarmTime (LPC_RTC_TypeDef *RTCx, uint32_t Timetype)
  473. {
  474. switch (Timetype)
  475. {
  476. case RTC_TIMETYPE_SECOND:
  477. return (RTCx->ALSEC & RTC_SEC_MASK);
  478. case RTC_TIMETYPE_MINUTE:
  479. return (RTCx->ALMIN & RTC_MIN_MASK);
  480. case RTC_TIMETYPE_HOUR:
  481. return (RTCx->ALHOUR & RTC_HOUR_MASK);
  482. case RTC_TIMETYPE_DAYOFWEEK:
  483. return (RTCx->ALDOW & RTC_DOW_MASK);
  484. case RTC_TIMETYPE_DAYOFMONTH:
  485. return (RTCx->ALDOM & RTC_DOM_MASK);
  486. case RTC_TIMETYPE_DAYOFYEAR:
  487. return (RTCx->ALDOY & RTC_DOY_MASK);
  488. case RTC_TIMETYPE_MONTH:
  489. return (RTCx->ALMON & RTC_MONTH_MASK);
  490. case RTC_TIMETYPE_YEAR:
  491. return (RTCx->ALYEAR & RTC_YEAR_MASK);
  492. default:
  493. return (0);
  494. }
  495. }
  496. /*********************************************************************//**
  497. * @brief Set full of alarm time in RTC peripheral
  498. * @param[in] RTCx RTC peripheral selected, should be LPC_RTC
  499. * @param[in] pFullTime Pointer to a RTC_TIME_Type structure that
  500. * contains alarm time value in full.
  501. * @return None
  502. **********************************************************************/
  503. void RTC_SetFullAlarmTime (LPC_RTC_TypeDef *RTCx, RTC_TIME_Type *pFullTime)
  504. {
  505. RTCx->ALDOM = pFullTime->DOM & RTC_DOM_MASK;
  506. RTCx->ALDOW = pFullTime->DOW & RTC_DOW_MASK;
  507. RTCx->ALDOY = pFullTime->DOY & RTC_DOY_MASK;
  508. RTCx->ALHOUR = pFullTime->HOUR & RTC_HOUR_MASK;
  509. RTCx->ALMIN = pFullTime->MIN & RTC_MIN_MASK;
  510. RTCx->ALSEC = pFullTime->SEC & RTC_SEC_MASK;
  511. RTCx->ALMON = pFullTime->MONTH & RTC_MONTH_MASK;
  512. RTCx->ALYEAR = pFullTime->YEAR & RTC_YEAR_MASK;
  513. }
  514. /*********************************************************************//**
  515. * @brief Get full of alarm time in RTC peripheral
  516. * @param[in] RTCx RTC peripheral selected, should be LPC_RTC
  517. * @param[in] pFullTime Pointer to a RTC_TIME_Type structure that
  518. * will be stored alarm time in full.
  519. * @return None
  520. **********************************************************************/
  521. void RTC_GetFullAlarmTime (LPC_RTC_TypeDef *RTCx, RTC_TIME_Type *pFullTime)
  522. {
  523. pFullTime->DOM = RTCx->ALDOM & RTC_DOM_MASK;
  524. pFullTime->DOW = RTCx->ALDOW & RTC_DOW_MASK;
  525. pFullTime->DOY = RTCx->ALDOY & RTC_DOY_MASK;
  526. pFullTime->HOUR = RTCx->ALHOUR & RTC_HOUR_MASK;
  527. pFullTime->MIN = RTCx->ALMIN & RTC_MIN_MASK;
  528. pFullTime->SEC = RTCx->ALSEC & RTC_SEC_MASK;
  529. pFullTime->MONTH = RTCx->ALMON & RTC_MONTH_MASK;
  530. pFullTime->YEAR = RTCx->ALYEAR & RTC_YEAR_MASK;
  531. }
  532. /*********************************************************************//**
  533. * @brief Check whether if specified Location interrupt in
  534. * RTC peripheral is set or not
  535. * @param[in] RTCx RTC peripheral selected, should be LPC_RTC
  536. * @param[in] IntType Interrupt location type, should be:
  537. * - RTC_INT_COUNTER_INCREASE: Counter Increment Interrupt
  538. * block generated an interrupt.
  539. * - RTC_INT_ALARM: Alarm generated an
  540. * interrupt.
  541. * @return New state of specified Location interrupt in RTC peripheral
  542. * (SET or RESET)
  543. **********************************************************************/
  544. IntStatus RTC_GetIntPending (LPC_RTC_TypeDef *RTCx, uint32_t IntType)
  545. {
  546. return ((RTCx->ILR & IntType) ? SET : RESET);
  547. }
  548. /*********************************************************************//**
  549. * @brief Clear specified Location interrupt pending in
  550. * RTC peripheral
  551. * @param[in] RTCx RTC peripheral selected, should be LPC_RTC
  552. * @param[in] IntType Interrupt location type, should be:
  553. * - RTC_INT_COUNTER_INCREASE: Clear Counter Increment
  554. * Interrupt pending.
  555. * - RTC_INT_ALARM: Clear alarm interrupt pending
  556. * @return None
  557. **********************************************************************/
  558. void RTC_ClearIntPending (LPC_RTC_TypeDef *RTCx, uint32_t IntType)
  559. {
  560. RTCx->ILR |= IntType;
  561. }
  562. /*********************************************************************//**
  563. * @brief Enable/Disable calibration counter in RTC peripheral
  564. * @param[in] RTCx RTC peripheral selected, should be LPC_RTC
  565. * @param[in] NewState New State of this function, should be:
  566. * - ENABLE: The calibration counter is enabled and counting
  567. * - DISABLE: The calibration counter is disabled and reset to zero
  568. * @return None
  569. **********************************************************************/
  570. void RTC_CalibCounterCmd(LPC_RTC_TypeDef *RTCx, FunctionalState NewState)
  571. {
  572. if (NewState == ENABLE)
  573. {
  574. RTCx->CCR &= (~RTC_CCR_CCALEN) & RTC_CCR_BITMASK;
  575. }
  576. else
  577. {
  578. RTCx->CCR |= RTC_CCR_CCALEN;
  579. }
  580. }
  581. /*********************************************************************//**
  582. * @brief Configures Calibration in RTC peripheral
  583. * @param[in] RTCx RTC peripheral selected, should be LPC_RTC
  584. * @param[in] CalibValue Calibration value, should be in range from
  585. * 0 to 131,072
  586. * @param[in] CalibDir Calibration Direction, should be:
  587. * - RTC_CALIB_DIR_FORWARD: Forward calibration
  588. * - RTC_CALIB_DIR_BACKWARD: Backward calibration
  589. * @return None
  590. **********************************************************************/
  591. void RTC_CalibConfig(LPC_RTC_TypeDef *RTCx, uint32_t CalibValue, uint8_t CalibDir)
  592. {
  593. RTCx->CALIBRATION = ((CalibValue) & RTC_CALIBRATION_CALVAL_MASK) \
  594. | ((CalibDir == RTC_CALIB_DIR_BACKWARD) ? RTC_CALIBRATION_LIBDIR : 0);
  595. }
  596. /*********************************************************************//**
  597. * @brief Write value to General purpose registers
  598. * @param[in] RTCx RTC peripheral selected, should be LPC_RTC
  599. * @param[in] Channel General purpose registers Channel number,
  600. * should be in range from 0 to 4.
  601. * @param[in] Value Value to write
  602. * @return None
  603. * Note: These General purpose registers can be used to store important
  604. * information when the main power supply is off. The value in these
  605. * registers is not affected by chip reset.
  606. **********************************************************************/
  607. void RTC_WriteGPREG (LPC_RTC_TypeDef *RTCx, uint8_t Channel, uint32_t Value)
  608. {
  609. uint32_t *preg;
  610. preg = (uint32_t *)&RTCx->GPREG0;
  611. preg += Channel;
  612. *preg = Value;
  613. }
  614. /*********************************************************************//**
  615. * @brief Read value from General purpose registers
  616. * @param[in] RTCx RTC peripheral selected, should be LPC_RTC
  617. * @param[in] Channel General purpose registers Channel number,
  618. * should be in range from 0 to 4.
  619. * @return Read Value
  620. * Note: These General purpose registers can be used to store important
  621. * information when the main power supply is off. The value in these
  622. * registers is not affected by chip reset.
  623. **********************************************************************/
  624. uint32_t RTC_ReadGPREG (LPC_RTC_TypeDef *RTCx, uint8_t Channel)
  625. {
  626. uint32_t *preg;
  627. uint32_t value;
  628. preg = (uint32_t *)&RTCx->GPREG0;
  629. preg += Channel;
  630. value = *preg;
  631. return (value);
  632. }
  633. /*********************************************************************//**
  634. * @brief Initialize an variable of type RTC_ER_CONFIG_Type.
  635. * @param[in] pConfig The address of input variable.
  636. * @return None
  637. **********************************************************************/
  638. void RTC_ER_InitConfigStruct(RTC_ER_CONFIG_Type* pConfig)
  639. {
  640. uint32_t tmp;
  641. if(pConfig == NULL)
  642. return;
  643. for(tmp = 0; tmp < RTC_ER_INPUT_CHANNEL_NUM; tmp++)
  644. {
  645. pConfig->InputChannel[tmp].EventOnPosEdge = FALSE;
  646. pConfig->InputChannel[tmp].GPClear= FALSE;
  647. pConfig->InputChannel[tmp].IntWake= FALSE;
  648. }
  649. pConfig->Clk = 64;
  650. }
  651. /*********************************************************************//**
  652. * @brief Initialize Event Monitor/Recorder
  653. * @param[in] pConfig Configuration
  654. * @return SUCCESS/ERROR
  655. * Note: The RTC Module must be intialized before initializing this module.
  656. **********************************************************************/
  657. Status RTC_ER_Init(RTC_ER_CONFIG_Type* pConfig)
  658. {
  659. if(pConfig == NULL)
  660. return ERROR;
  661. if((LPC_RTC->CCR & RTC_CCR_CLKEN) == 0)
  662. return ERROR;
  663. /* EV0 */
  664. if(pConfig->InputChannel[0].EventOnPosEdge)
  665. LPC_RTC->ERCONTROL |= RTC_ERCTRL_EV0_POS_EDGE;
  666. else
  667. LPC_RTC->ERCONTROL &= ~RTC_ERCTRL_EV0_POS_EDGE;
  668. if(pConfig->InputChannel[0].IntWake)
  669. LPC_RTC->ERCONTROL |= RTC_ERCTRL_EV0_INTWAKE_ENABLE;
  670. else
  671. LPC_RTC->ERCONTROL &= ~RTC_ERCTRL_EV0_INTWAKE_ENABLE;
  672. if(pConfig->InputChannel[0].GPClear)
  673. LPC_RTC->ERCONTROL |= RTC_ERCTRL_EV0_GPCLEAR_ENABLE;
  674. else
  675. LPC_RTC->ERCONTROL &= ~RTC_ERCTRL_EV0_GPCLEAR_ENABLE;
  676. /* EV1 */
  677. if(pConfig->InputChannel[1].EventOnPosEdge)
  678. LPC_RTC->ERCONTROL |= RTC_ERCTRL_EV1_POS_EDGE;
  679. else
  680. LPC_RTC->ERCONTROL &= ~RTC_ERCTRL_EV1_POS_EDGE;
  681. if(pConfig->InputChannel[1].IntWake)
  682. LPC_RTC->ERCONTROL |= RTC_ERCTRL_EV1_INTWAKE_ENABLE;
  683. else
  684. LPC_RTC->ERCONTROL &= ~RTC_ERCTRL_EV1_INTWAKE_ENABLE;
  685. if(pConfig->InputChannel[1].GPClear)
  686. LPC_RTC->ERCONTROL |= RTC_ERCTRL_EV1_GPCLEAR_ENABLE;
  687. else
  688. LPC_RTC->ERCONTROL &= ~RTC_ERCTRL_EV1_GPCLEAR_ENABLE;
  689. /* EV2 */
  690. if(pConfig->InputChannel[2].EventOnPosEdge)
  691. LPC_RTC->ERCONTROL |= RTC_ERCTRL_EV2_POS_EDGE;
  692. else
  693. LPC_RTC->ERCONTROL &= ~RTC_ERCTRL_EV2_POS_EDGE;
  694. if(pConfig->InputChannel[2].IntWake)
  695. LPC_RTC->ERCONTROL |= RTC_ERCTRL_EV2_INTWAKE_ENABLE;
  696. else
  697. LPC_RTC->ERCONTROL &= ~RTC_ERCTRL_EV2_INTWAKE_ENABLE;
  698. if(pConfig->InputChannel[2].GPClear)
  699. LPC_RTC->ERCONTROL |= RTC_ERCTRL_EV2_GPCLEAR_ENABLE;
  700. else
  701. LPC_RTC->ERCONTROL &= ~RTC_ERCTRL_EV2_GPCLEAR_ENABLE;
  702. /* Sample Clock */
  703. LPC_RTC->ERCONTROL &= ~RTC_ERCTRL_MODE_MASK;
  704. switch(pConfig->Clk)
  705. {
  706. case 0:
  707. LPC_RTC->ERCONTROL |= RTC_ERCTRL_MODE_CLK_DISABLE;
  708. break;
  709. case 16:
  710. LPC_RTC->ERCONTROL |= RTC_ERCTRL_MODE_16HZ;
  711. break;
  712. case 64:
  713. LPC_RTC->ERCONTROL |= RTC_ERCTRL_MODE_64HZ;
  714. break;
  715. case 1000:
  716. LPC_RTC->ERCONTROL |= RTC_ERCTRL_MODE_1KHZ;
  717. break;
  718. default:
  719. return ERROR;
  720. }
  721. return SUCCESS;
  722. }
  723. /*********************************************************************//**
  724. * @brief Enable/Disable a input channel for Event Monitor/Recorder
  725. * @param[in] channel Channel Number. It should be 0~2
  726. * @param[in]state ENABLE/DISABLE
  727. * @return SUCCESS/ERROR
  728. **********************************************************************/
  729. Status RTC_ER_Cmd(uint8_t channel, FunctionalState state)
  730. {
  731. switch(channel)
  732. {
  733. case 0:
  734. if(state)
  735. LPC_RTC->ERCONTROL |= RTC_ERCTRL_EV0_INPUT_ENABLE;
  736. else
  737. LPC_RTC->ERCONTROL &= ~RTC_ERCTRL_EV0_INPUT_ENABLE;
  738. break;
  739. case 1:
  740. if(state)
  741. LPC_RTC->ERCONTROL |= RTC_ERCTRL_EV1_INPUT_ENABLE;
  742. else
  743. LPC_RTC->ERCONTROL &= ~RTC_ERCTRL_EV1_INPUT_ENABLE;
  744. break;
  745. case 2:
  746. if(state)
  747. LPC_RTC->ERCONTROL |= RTC_ERCTRL_EV2_INPUT_ENABLE;
  748. else
  749. LPC_RTC->ERCONTROL &= ~RTC_ERCTRL_EV2_INPUT_ENABLE;
  750. break;
  751. default:
  752. return ERROR;
  753. }
  754. return SUCCESS;
  755. }
  756. /*********************************************************************//**
  757. * @brief Get event count on a given channel.
  758. * @param[in] channel Channel Number. It should be 0~2
  759. * @return counter
  760. **********************************************************************/
  761. uint8_t RTC_ER_GetEventCount(uint8_t channel)
  762. {
  763. uint8_t count = 0;
  764. switch(channel)
  765. {
  766. case 0:
  767. count = RTC_ER_EV0_COUNTER(LPC_RTC->ERCOUNTERS);
  768. break;
  769. case 1:
  770. count = RTC_ER_EV1_COUNTER(LPC_RTC->ERCOUNTERS);
  771. break;
  772. case 2:
  773. count = RTC_ER_EV2_COUNTER(LPC_RTC->ERCOUNTERS);
  774. break;
  775. default:
  776. break;
  777. }
  778. return count;
  779. }
  780. /*********************************************************************//**
  781. * @brief Get Event Monirot/Recorder Status.
  782. * @param[in] None
  783. * @return Status. It can includes:
  784. * RTC_ER_EVENTS_ON_EV0_FLG
  785. * RTC_ER_EVENTS_ON_EV1_FLG
  786. * RTC_ER_EVENTS_ON_EV2_FLG
  787. * RTC_ER_STATUS_GP_CLEARED_FLG
  788. * RTC_ER_STATUS_WAKEUP_REQ_PENDING
  789. **********************************************************************/
  790. uint32_t RTC_ER_GetStatus(void)
  791. {
  792. return LPC_RTC->ERSTATUS;
  793. }
  794. /*********************************************************************//**
  795. * @brief Clear Event Monitor/recoder status register.
  796. * @param[in] status Status Flag. It should be:
  797. * RTC_ER_EVENTS_ON_EV0_FLG
  798. * RTC_ER_EVENTS_ON_EV1_FLG
  799. * RTC_ER_EVENTS_ON_EV2_FLG
  800. * RTC_ER_STATUS_GP_CLEARED_FLG
  801. * RTC_ER_STATUS_WAKEUP_REQ_PENDING
  802. * @return None
  803. **********************************************************************/
  804. void RTC_ER_ClearStatus(uint32_t status)
  805. {
  806. LPC_RTC->ERSTATUS |= status;
  807. }
  808. /*********************************************************************//**
  809. * @brief Check whether a Wakup request is pending or not.
  810. * @param[in] None
  811. * @return TRUE/FALSE
  812. **********************************************************************/
  813. Bool RTC_ER_WakupReqPending(void)
  814. {
  815. if(LPC_RTC->ERSTATUS & RTC_ER_STATUS_WAKEUP_REQ_PENDING)
  816. return TRUE;
  817. else
  818. return FALSE;
  819. }
  820. /*********************************************************************//**
  821. * @brief Check whether RTC General Purpose registed has been cleared or not.
  822. * @param[in] None
  823. * @return TRUE/FALSE
  824. **********************************************************************/
  825. Bool RTC_ER_GPCleared(void)
  826. {
  827. if(LPC_RTC->ERSTATUS & RTC_ER_STATUS_GP_CLEARED_FLG)
  828. return TRUE;
  829. else
  830. return FALSE;
  831. }
  832. /*********************************************************************//**
  833. * @brief Get the timestamp of the fist event on a given channel.
  834. * @param[in] channel Channel number (It should be 0~2)
  835. * @param[in] pTimeStamp point to the buffer
  836. * @return SUCCESS/ERROR
  837. **********************************************************************/
  838. Status RTC_ER_GetFirstTimeStamp(uint8_t channel, RTC_ER_TIMESTAMP_Type* pTimeStamp)
  839. {
  840. if(pTimeStamp == NULL)
  841. return ERROR;
  842. switch(channel)
  843. {
  844. case 0:
  845. if((LPC_RTC->ERSTATUS & (1<<RTC_ER_STATUS_EV0_BIT)) == 0)
  846. return ERROR;
  847. pTimeStamp->SEC = RTC_ER_TIMESTAMP_SEC(LPC_RTC->ERFIRSTSTAMP0);
  848. pTimeStamp->MIN= RTC_ER_TIMESTAMP_MIN(LPC_RTC->ERFIRSTSTAMP0);
  849. pTimeStamp->HOUR= RTC_ER_TIMESTAMP_HOUR(LPC_RTC->ERFIRSTSTAMP0);
  850. pTimeStamp->DOY = RTC_ER_TIMESTAMP_DOY(LPC_RTC->ERFIRSTSTAMP0);
  851. break;
  852. case 1:
  853. if((LPC_RTC->ERSTATUS & (1<<RTC_ER_STATUS_EV1_BIT)) == 0)
  854. return ERROR;
  855. pTimeStamp->SEC = RTC_ER_TIMESTAMP_SEC(LPC_RTC->ERFIRSTSTAMP1);
  856. pTimeStamp->MIN= RTC_ER_TIMESTAMP_MIN(LPC_RTC->ERFIRSTSTAMP1);
  857. pTimeStamp->HOUR= RTC_ER_TIMESTAMP_HOUR(LPC_RTC->ERFIRSTSTAMP1);
  858. pTimeStamp->DOY = RTC_ER_TIMESTAMP_DOY(LPC_RTC->ERFIRSTSTAMP1);
  859. break;
  860. case 2:
  861. if((LPC_RTC->ERSTATUS & (1<<RTC_ER_STATUS_EV2_BIT)) == 0)
  862. return ERROR;
  863. pTimeStamp->SEC = RTC_ER_TIMESTAMP_SEC(LPC_RTC->ERFIRSTSTAMP2);
  864. pTimeStamp->MIN= RTC_ER_TIMESTAMP_MIN(LPC_RTC->ERFIRSTSTAMP2);
  865. pTimeStamp->HOUR= RTC_ER_TIMESTAMP_HOUR(LPC_RTC->ERFIRSTSTAMP2);
  866. pTimeStamp->DOY = RTC_ER_TIMESTAMP_DOY(LPC_RTC->ERFIRSTSTAMP2);
  867. break;
  868. default:
  869. break;
  870. }
  871. return SUCCESS;
  872. }
  873. /*********************************************************************//**
  874. * @brief Get the timestamp of the last event on a given channel.
  875. * @param[in] channel Channel number (It should be 0~2)
  876. * @param[in] pTimeStamp point to the buffer
  877. * @return SUCCESS/ERROR
  878. **********************************************************************/
  879. Status RTC_ER_GetLastTimeStamp(uint8_t channel, RTC_ER_TIMESTAMP_Type* pTimeStamp)
  880. {
  881. if(pTimeStamp == NULL)
  882. return ERROR;
  883. switch(channel)
  884. {
  885. case 0:
  886. if((LPC_RTC->ERSTATUS & (1<<RTC_ER_STATUS_EV0_BIT)) == 0)
  887. return ERROR;
  888. pTimeStamp->SEC = RTC_ER_TIMESTAMP_SEC(LPC_RTC->ERLASTSTAMP0);
  889. pTimeStamp->MIN= RTC_ER_TIMESTAMP_MIN(LPC_RTC->ERLASTSTAMP0);
  890. pTimeStamp->HOUR= RTC_ER_TIMESTAMP_HOUR(LPC_RTC->ERLASTSTAMP0);
  891. pTimeStamp->DOY = RTC_ER_TIMESTAMP_DOY(LPC_RTC->ERLASTSTAMP0);
  892. break;
  893. case 1:
  894. if((LPC_RTC->ERSTATUS & (1<<RTC_ER_STATUS_EV1_BIT)) == 0)
  895. return ERROR;
  896. pTimeStamp->SEC = RTC_ER_TIMESTAMP_SEC(LPC_RTC->ERLASTSTAMP1);
  897. pTimeStamp->MIN= RTC_ER_TIMESTAMP_MIN(LPC_RTC->ERLASTSTAMP1);
  898. pTimeStamp->HOUR= RTC_ER_TIMESTAMP_HOUR(LPC_RTC->ERLASTSTAMP1);
  899. pTimeStamp->DOY = RTC_ER_TIMESTAMP_DOY(LPC_RTC->ERLASTSTAMP1);
  900. break;
  901. case 2:
  902. if((LPC_RTC->ERSTATUS & (1<<RTC_ER_STATUS_EV2_BIT)) == 0)
  903. return ERROR;
  904. pTimeStamp->SEC = RTC_ER_TIMESTAMP_SEC(LPC_RTC->ERLASTSTAMP2);
  905. pTimeStamp->MIN= RTC_ER_TIMESTAMP_MIN(LPC_RTC->ERLASTSTAMP2);
  906. pTimeStamp->HOUR= RTC_ER_TIMESTAMP_HOUR(LPC_RTC->ERLASTSTAMP2);
  907. pTimeStamp->DOY = RTC_ER_TIMESTAMP_DOY(LPC_RTC->ERLASTSTAMP2);
  908. break;
  909. default:
  910. break;
  911. }
  912. return SUCCESS;
  913. }
  914. /**
  915. * @}
  916. */
  917. #endif /*_RTC*/
  918. /**
  919. * @}
  920. */
  921. /* --------------------------------- End Of File ------------------------------ */