M480 BSP V3.05.006
The Board Support Package for M480 Series
rtc.c
Go to the documentation of this file.
1/**************************************************************************/
9#include "NuMicro.h"
10
11
14/*---------------------------------------------------------------------------------------------------------*/
15/* Macro, type and constant definitions */
16/*---------------------------------------------------------------------------------------------------------*/
17#define RTC_GLOBALS
18
19/*---------------------------------------------------------------------------------------------------------*/
20/* Global file scope (static) variables */
21/*---------------------------------------------------------------------------------------------------------*/
22static volatile uint32_t g_u32hiYear, g_u32loYear, g_u32hiMonth, g_u32loMonth, g_u32hiDay, g_u32loDay;
23static volatile uint32_t g_u32hiHour, g_u32loHour, g_u32hiMin, g_u32loMin, g_u32hiSec, g_u32loSec;
24
68{
69 uint32_t u32TimeOutCount = SystemCoreClock; // 1 second timeout
70 RTC->INIT = RTC_INIT_KEY;
71
72 if(RTC->INIT != RTC_INIT_ACTIVE_Msk)
73 {
74 RTC->INIT = RTC_INIT_KEY;
75 while(RTC->INIT != RTC_INIT_ACTIVE_Msk)
76 {
77 if(u32TimeOutCount == 0) return -1;
78 u32TimeOutCount--;
79 }
80 }
81
82 if(sPt == 0)
83 {
84 }
85 else
86 {
87 /* Set RTC date and time */
89 }
90
91 return 0;
92}
93
103void RTC_Close(void)
104{
105 CLK->APBCLK0 &= ~CLK_APBCLK0_RTCCKEN_Msk;
106}
107
116void RTC_32KCalibration(int32_t i32FrequencyX10000)
117{
118 uint64_t u64Compensate;
119 int32_t i32RegInt,i32RegFra ;
120
121 if(!(SYS->CSERVER & 0x1))
122 {
123 u64Compensate = (uint64_t)(0x2710000000000);
124 u64Compensate = (uint64_t)(u64Compensate / (uint64_t)i32FrequencyX10000);
125
126 if(u64Compensate >= (uint64_t)0x400000)
127 {
128 u64Compensate = (uint64_t)0x3FFFFF;
129 }
130
132 RTC->FREQADJ = (uint32_t)u64Compensate;
133 }
134 else
135 {
136 /* Compute Integer and Fraction for RTC register*/
137 i32RegInt = (i32FrequencyX10000/10000) - 32752;
138 i32RegFra = ((((i32FrequencyX10000%10000)) * 64) + 5000) / 10000;
139
140 if(i32RegFra >= 0x40)
141 {
142 i32RegFra = 0x0;
143 i32RegInt++;
144 }
145
146 /* Judge Integer part is reasonable */
147 if ( (i32RegInt < 0) | (i32RegInt > 31) )
148 {
149 return;
150 }
151
153 RTC->FREQADJ = (uint32_t)((i32RegInt<<8) | i32RegFra);
154 }
155
156}
157
177{
178 uint32_t u32Tmp;
179
180 sPt->u32TimeScale = RTC->CLKFMT & RTC_CLKFMT_24HEN_Msk; /* 12/24-hour */
181 sPt->u32DayOfWeek = RTC->WEEKDAY & RTC_WEEKDAY_WEEKDAY_Msk; /* Day of the week */
182
183 /* Get [Date digit] data */
184 g_u32hiYear = (RTC->CAL & RTC_CAL_TENYEAR_Msk) >> RTC_CAL_TENYEAR_Pos;
185 g_u32loYear = (RTC->CAL & RTC_CAL_YEAR_Msk) >> RTC_CAL_YEAR_Pos;
186 g_u32hiMonth = (RTC->CAL & RTC_CAL_TENMON_Msk) >> RTC_CAL_TENMON_Pos;
187 g_u32loMonth = (RTC->CAL & RTC_CAL_MON_Msk) >> RTC_CAL_MON_Pos;
188 g_u32hiDay = (RTC->CAL & RTC_CAL_TENDAY_Msk) >> RTC_CAL_TENDAY_Pos;
189 g_u32loDay = (RTC->CAL & RTC_CAL_DAY_Msk) >> RTC_CAL_DAY_Pos;
190
191 /* Get [Time digit] data */
192 g_u32hiHour = (RTC->TIME & RTC_TIME_TENHR_Msk) >> RTC_TIME_TENHR_Pos;
193 g_u32loHour = (RTC->TIME & RTC_TIME_HR_Msk) >> RTC_TIME_HR_Pos;
194 g_u32hiMin = (RTC->TIME & RTC_TIME_TENMIN_Msk) >> RTC_TIME_TENMIN_Pos;
195 g_u32loMin = (RTC->TIME & RTC_TIME_MIN_Msk) >> RTC_TIME_MIN_Pos;
196 g_u32hiSec = (RTC->TIME & RTC_TIME_TENSEC_Msk) >> RTC_TIME_TENSEC_Pos;
197 g_u32loSec = (RTC->TIME & RTC_TIME_SEC_Msk) >> RTC_TIME_SEC_Pos;
198
199 /* Compute to 20XX year */
200 u32Tmp = (g_u32hiYear * 10ul);
201 u32Tmp += g_u32loYear;
202 sPt->u32Year = u32Tmp + RTC_YEAR2000;
203
204 /* Compute 0~12 month */
205 u32Tmp = (g_u32hiMonth * 10ul);
206 sPt->u32Month = u32Tmp + g_u32loMonth;
207
208 /* Compute 0~31 day */
209 u32Tmp = (g_u32hiDay * 10ul);
210 sPt->u32Day = u32Tmp + g_u32loDay;
211
212 /* Compute 12/24 hour */
213 if(sPt->u32TimeScale == RTC_CLOCK_12)
214 {
215 u32Tmp = (g_u32hiHour * 10ul);
216 u32Tmp += g_u32loHour;
217 sPt->u32Hour = u32Tmp; /* AM: 1~12. PM: 21~32. */
218
219 if(sPt->u32Hour >= 21ul)
220 {
221 sPt->u32AmPm = RTC_PM;
222 sPt->u32Hour -= 20ul;
223 }
224 else
225 {
226 sPt->u32AmPm = RTC_AM;
227 }
228
229 u32Tmp = (g_u32hiMin * 10ul);
230 u32Tmp += g_u32loMin;
231 sPt->u32Minute = u32Tmp;
232
233 u32Tmp = (g_u32hiSec * 10ul);
234 u32Tmp += g_u32loSec;
235 sPt->u32Second = u32Tmp;
236 }
237 else
238 {
239 u32Tmp = (g_u32hiHour * 10ul);
240 u32Tmp += g_u32loHour;
241 sPt->u32Hour = u32Tmp;
242
243 u32Tmp = (g_u32hiMin * 10ul);
244 u32Tmp += g_u32loMin;
245 sPt->u32Minute = u32Tmp;
246
247 u32Tmp = (g_u32hiSec * 10ul);
248 u32Tmp += g_u32loSec;
249 sPt->u32Second = u32Tmp;
250 }
251}
252
272{
273 uint32_t u32Tmp;
274
275 sPt->u32TimeScale = RTC->CLKFMT & RTC_CLKFMT_24HEN_Msk; /* 12/24-hour */
276 sPt->u32DayOfWeek = RTC->WEEKDAY & RTC_WEEKDAY_WEEKDAY_Msk; /* Day of the week */
277
278 /* Get alarm [Date digit] data */
280 g_u32hiYear = (RTC->CALM & RTC_CALM_TENYEAR_Msk) >> RTC_CALM_TENYEAR_Pos;
281 g_u32loYear = (RTC->CALM & RTC_CALM_YEAR_Msk) >> RTC_CALM_YEAR_Pos;
282 g_u32hiMonth = (RTC->CALM & RTC_CALM_TENMON_Msk) >> RTC_CALM_TENMON_Pos;
283 g_u32loMonth = (RTC->CALM & RTC_CALM_MON_Msk) >> RTC_CALM_MON_Pos;
284 g_u32hiDay = (RTC->CALM & RTC_CALM_TENDAY_Msk) >> RTC_CALM_TENDAY_Pos;
285 g_u32loDay = (RTC->CALM & RTC_CALM_DAY_Msk) >> RTC_CALM_DAY_Pos;
286
287 /* Get alarm [Time digit] data */
289 g_u32hiHour = (RTC->TALM & RTC_TALM_TENHR_Msk) >> RTC_TALM_TENHR_Pos;
290 g_u32loHour = (RTC->TALM & RTC_TALM_HR_Msk) >> RTC_TALM_HR_Pos;
291 g_u32hiMin = (RTC->TALM & RTC_TALM_TENMIN_Msk) >> RTC_TALM_TENMIN_Pos;
292 g_u32loMin = (RTC->TALM & RTC_TALM_MIN_Msk) >> RTC_TALM_MIN_Pos;
293 g_u32hiSec = (RTC->TALM & RTC_TALM_TENSEC_Msk) >> RTC_TALM_TENSEC_Pos;
294 g_u32loSec = (RTC->TALM & RTC_TALM_SEC_Msk) >> RTC_TALM_SEC_Pos;
295
296 /* Compute to 20XX year */
297 u32Tmp = (g_u32hiYear * 10ul);
298 u32Tmp += g_u32loYear;
299 sPt->u32Year = u32Tmp + RTC_YEAR2000;
300
301 /* Compute 0~12 month */
302 u32Tmp = (g_u32hiMonth * 10ul);
303 sPt->u32Month = u32Tmp + g_u32loMonth;
304
305 /* Compute 0~31 day */
306 u32Tmp = (g_u32hiDay * 10ul);
307 sPt->u32Day = u32Tmp + g_u32loDay;
308
309 /* Compute 12/24 hour */
310 if(sPt->u32TimeScale == RTC_CLOCK_12)
311 {
312 u32Tmp = (g_u32hiHour * 10ul);
313 u32Tmp += g_u32loHour;
314 sPt->u32Hour = u32Tmp; /* AM: 1~12. PM: 21~32. */
315
316 if(sPt->u32Hour >= 21ul)
317 {
318 sPt->u32AmPm = RTC_PM;
319 sPt->u32Hour -= 20ul;
320 }
321 else
322 {
323 sPt->u32AmPm = RTC_AM;
324 }
325
326 u32Tmp = (g_u32hiMin * 10ul);
327 u32Tmp += g_u32loMin;
328 sPt->u32Minute = u32Tmp;
329
330 u32Tmp = (g_u32hiSec * 10ul);
331 u32Tmp += g_u32loSec;
332 sPt->u32Second = u32Tmp;
333
334 }
335 else
336 {
337 u32Tmp = (g_u32hiHour * 10ul);
338 u32Tmp += g_u32loHour;
339 sPt->u32Hour = u32Tmp;
340
341 u32Tmp = (g_u32hiMin * 10ul);
342 u32Tmp += g_u32loMin;
343 sPt->u32Minute = u32Tmp;
344
345 u32Tmp = (g_u32hiSec * 10ul);
346 u32Tmp += g_u32loSec;
347 sPt->u32Second = u32Tmp;
348 }
349}
350
372{
373 uint32_t u32RegCAL, u32RegTIME;
374
375 if(sPt == 0ul)
376 {
377 }
378 else
379 {
380 /*-----------------------------------------------------------------------------------------------------*/
381 /* Set RTC 24/12 hour setting and Day of the Week */
382 /*-----------------------------------------------------------------------------------------------------*/
384 if(sPt->u32TimeScale == RTC_CLOCK_12)
385 {
386 RTC->CLKFMT &= ~RTC_CLKFMT_24HEN_Msk;
387
388 /*-------------------------------------------------------------------------------------------------*/
389 /* Important, range of 12-hour PM mode is 21 up to 32 */
390 /*-------------------------------------------------------------------------------------------------*/
391 if(sPt->u32AmPm == RTC_PM)
392 {
393 sPt->u32Hour += 20ul;
394 }
395 }
396 else
397 {
398 RTC->CLKFMT |= RTC_CLKFMT_24HEN_Msk;
399 }
400
401 /* Set Day of the Week */
403 RTC->WEEKDAY = sPt->u32DayOfWeek;
404
405 /*-----------------------------------------------------------------------------------------------------*/
406 /* Set RTC Current Date and Time */
407 /*-----------------------------------------------------------------------------------------------------*/
408 u32RegCAL = ((sPt->u32Year - RTC_YEAR2000) / 10ul) << 20;
409 u32RegCAL |= (((sPt->u32Year - RTC_YEAR2000) % 10ul) << 16);
410 u32RegCAL |= ((sPt->u32Month / 10ul) << 12);
411 u32RegCAL |= ((sPt->u32Month % 10ul) << 8);
412 u32RegCAL |= ((sPt->u32Day / 10ul) << 4);
413 u32RegCAL |= (sPt->u32Day % 10ul);
414
415 u32RegTIME = ((sPt->u32Hour / 10ul) << 20);
416 u32RegTIME |= ((sPt->u32Hour % 10ul) << 16);
417 u32RegTIME |= ((sPt->u32Minute / 10ul) << 12);
418 u32RegTIME |= ((sPt->u32Minute % 10ul) << 8);
419 u32RegTIME |= ((sPt->u32Second / 10ul) << 4);
420 u32RegTIME |= (sPt->u32Second % 10ul);
421
422 /*-----------------------------------------------------------------------------------------------------*/
423 /* Set RTC Calender and Time Loading */
424 /*-----------------------------------------------------------------------------------------------------*/
426 RTC->CAL = (uint32_t)u32RegCAL;
428 RTC->TIME = (uint32_t)u32RegTIME;
429 }
430}
431
453{
454 uint32_t u32RegCALM, u32RegTALM;
455
456 if(sPt == 0)
457 {
458 }
459 else
460 {
461 /*-----------------------------------------------------------------------------------------------------*/
462 /* Set RTC 24/12 hour setting and Day of the Week */
463 /*-----------------------------------------------------------------------------------------------------*/
465 if(sPt->u32TimeScale == RTC_CLOCK_12)
466 {
467 RTC->CLKFMT &= ~RTC_CLKFMT_24HEN_Msk;
468
469 /*-------------------------------------------------------------------------------------------------*/
470 /* Important, range of 12-hour PM mode is 21 up to 32 */
471 /*-------------------------------------------------------------------------------------------------*/
472 if(sPt->u32AmPm == RTC_PM)
473 {
474 sPt->u32Hour += 20ul;
475 }
476 }
477 else
478 {
479 RTC->CLKFMT |= RTC_CLKFMT_24HEN_Msk;
480 }
481
482 /*-----------------------------------------------------------------------------------------------------*/
483 /* Set RTC Alarm Date and Time */
484 /*-----------------------------------------------------------------------------------------------------*/
485 u32RegCALM = ((sPt->u32Year - RTC_YEAR2000) / 10ul) << 20;
486 u32RegCALM |= (((sPt->u32Year - RTC_YEAR2000) % 10ul) << 16);
487 u32RegCALM |= ((sPt->u32Month / 10ul) << 12);
488 u32RegCALM |= ((sPt->u32Month % 10ul) << 8);
489 u32RegCALM |= ((sPt->u32Day / 10ul) << 4);
490 u32RegCALM |= (sPt->u32Day % 10ul);
491
492 u32RegTALM = ((sPt->u32Hour / 10ul) << 20);
493 u32RegTALM |= ((sPt->u32Hour % 10ul) << 16);
494 u32RegTALM |= ((sPt->u32Minute / 10ul) << 12);
495 u32RegTALM |= ((sPt->u32Minute % 10ul) << 8);
496 u32RegTALM |= ((sPt->u32Second / 10ul) << 4);
497 u32RegTALM |= (sPt->u32Second % 10ul);
498
500 RTC->CALM = (uint32_t)u32RegCALM;
502 RTC->TALM = (uint32_t)u32RegTALM;
503 }
504}
505
520void RTC_SetDate(uint32_t u32Year, uint32_t u32Month, uint32_t u32Day, uint32_t u32DayOfWeek)
521{
522 uint32_t u32RegCAL;
523
524 u32RegCAL = ((u32Year - RTC_YEAR2000) / 10ul) << 20;
525 u32RegCAL |= (((u32Year - RTC_YEAR2000) % 10ul) << 16);
526 u32RegCAL |= ((u32Month / 10ul) << 12);
527 u32RegCAL |= ((u32Month % 10ul) << 8);
528 u32RegCAL |= ((u32Day / 10ul) << 4);
529 u32RegCAL |= (u32Day % 10ul);
530
531 /* Set Day of the Week */
533 RTC->WEEKDAY = u32DayOfWeek & RTC_WEEKDAY_WEEKDAY_Msk;
534
535 /* Set RTC Calender Loading */
537 RTC->CAL = (uint32_t)u32RegCAL;
538}
539
553void RTC_SetTime(uint32_t u32Hour, uint32_t u32Minute, uint32_t u32Second, uint32_t u32TimeMode, uint32_t u32AmPm)
554{
555 uint32_t u32RegTIME;
556
557 /* Important, range of 12-hour PM mode is 21 up to 32 */
558 if((u32TimeMode == RTC_CLOCK_12) && (u32AmPm == RTC_PM))
559 {
560 u32Hour += 20ul;
561 }
562
563 u32RegTIME = ((u32Hour / 10ul) << 20);
564 u32RegTIME |= ((u32Hour % 10ul) << 16);
565 u32RegTIME |= ((u32Minute / 10ul) << 12);
566 u32RegTIME |= ((u32Minute % 10ul) << 8);
567 u32RegTIME |= ((u32Second / 10ul) << 4);
568 u32RegTIME |= (u32Second % 10ul);
569
570 /*-----------------------------------------------------------------------------------------------------*/
571 /* Set RTC 24/12 hour setting and Day of the Week */
572 /*-----------------------------------------------------------------------------------------------------*/
574 if(u32TimeMode == RTC_CLOCK_12)
575 {
576 RTC->CLKFMT &= ~RTC_CLKFMT_24HEN_Msk;
577 }
578 else
579 {
580 RTC->CLKFMT |= RTC_CLKFMT_24HEN_Msk;
581 }
582
584 RTC->TIME = (uint32_t)u32RegTIME;
585}
586
598void RTC_SetAlarmDate(uint32_t u32Year, uint32_t u32Month, uint32_t u32Day)
599{
600 uint32_t u32RegCALM;
601
602 u32RegCALM = ((u32Year - RTC_YEAR2000) / 10ul) << 20;
603 u32RegCALM |= (((u32Year - RTC_YEAR2000) % 10ul) << 16);
604 u32RegCALM |= ((u32Month / 10ul) << 12);
605 u32RegCALM |= ((u32Month % 10ul) << 8);
606 u32RegCALM |= ((u32Day / 10ul) << 4);
607 u32RegCALM |= (u32Day % 10ul);
608
610
611 /* Set RTC Alarm Date */
612 RTC->CALM = (uint32_t)u32RegCALM;
613}
614
628void RTC_SetAlarmTime(uint32_t u32Hour, uint32_t u32Minute, uint32_t u32Second, uint32_t u32TimeMode, uint32_t u32AmPm)
629{
630 uint32_t u32RegTALM;
631
632 /* Important, range of 12-hour PM mode is 21 up to 32 */
633 if((u32TimeMode == RTC_CLOCK_12) && (u32AmPm == RTC_PM))
634 {
635 u32Hour += 20ul;
636 }
637
638 u32RegTALM = ((u32Hour / 10ul) << 20);
639 u32RegTALM |= ((u32Hour % 10ul) << 16);
640 u32RegTALM |= ((u32Minute / 10ul) << 12);
641 u32RegTALM |= ((u32Minute % 10ul) << 8);
642 u32RegTALM |= ((u32Second / 10ul) << 4);
643 u32RegTALM |= (u32Second % 10ul);
644
645 /*-----------------------------------------------------------------------------------------------------*/
646 /* Set RTC 24/12 hour setting and Day of the Week */
647 /*-----------------------------------------------------------------------------------------------------*/
649 if(u32TimeMode == RTC_CLOCK_12)
650 {
651 RTC->CLKFMT &= ~RTC_CLKFMT_24HEN_Msk;
652 }
653 else
654 {
655 RTC->CLKFMT |= RTC_CLKFMT_24HEN_Msk;
656 }
657
658 /* Set RTC Alarm Time */
660 RTC->TALM = (uint32_t)u32RegTALM;
661}
662
677void RTC_SetAlarmDateMask(uint8_t u8IsTenYMsk, uint8_t u8IsYMsk, uint8_t u8IsTenMMsk, uint8_t u8IsMMsk, uint8_t u8IsTenDMsk, uint8_t u8IsDMsk)
678{
680 RTC->CAMSK = ((uint32_t)u8IsTenYMsk << RTC_CAMSK_MTENYEAR_Pos) |
681 ((uint32_t)u8IsYMsk << RTC_CAMSK_MYEAR_Pos) |
682 ((uint32_t)u8IsTenMMsk << RTC_CAMSK_MTENMON_Pos) |
683 ((uint32_t)u8IsMMsk << RTC_CAMSK_MMON_Pos) |
684 ((uint32_t)u8IsTenDMsk << RTC_CAMSK_MTENDAY_Pos) |
685 ((uint32_t)u8IsDMsk << RTC_CAMSK_MDAY_Pos);
686}
687
702void RTC_SetAlarmTimeMask(uint8_t u8IsTenHMsk, uint8_t u8IsHMsk, uint8_t u8IsTenMMsk, uint8_t u8IsMMsk, uint8_t u8IsTenSMsk, uint8_t u8IsSMsk)
703{
705 RTC->TAMSK = ((uint32_t)u8IsTenHMsk << RTC_TAMSK_MTENHR_Pos) |
706 ((uint32_t)u8IsHMsk << RTC_TAMSK_MHR_Pos) |
707 ((uint32_t)u8IsTenMMsk << RTC_TAMSK_MTENMIN_Pos) |
708 ((uint32_t)u8IsMMsk << RTC_TAMSK_MMIN_Pos) |
709 ((uint32_t)u8IsTenSMsk << RTC_TAMSK_MTENSEC_Pos) |
710 ((uint32_t)u8IsSMsk << RTC_TAMSK_MSEC_Pos);
711}
712
728uint32_t RTC_GetDayOfWeek(void)
729{
730 return (RTC->WEEKDAY & RTC_WEEKDAY_WEEKDAY_Msk);
731}
732
751void RTC_SetTickPeriod(uint32_t u32TickSelection)
752{
754
755 RTC->TICK = (RTC->TICK & ~RTC_TICK_TICK_Msk) | u32TickSelection;
756}
757
775void RTC_EnableInt(uint32_t u32IntFlagMask)
776{
778 RTC->INTEN |= u32IntFlagMask;
779}
780
798void RTC_DisableInt(uint32_t u32IntFlagMask)
799{
801 RTC->INTEN &= ~u32IntFlagMask;
803 RTC->INTSTS = u32IntFlagMask;
804}
805
816{
818
819 RTC->SPRCTL |= RTC_SPRCTL_SPRRWEN_Msk;
820}
821
832{
834
835 RTC->SPRCTL &= ~RTC_SPRCTL_SPRRWEN_Msk;
836}
837
861void RTC_StaticTamperEnable(uint32_t u32TamperSelect, uint32_t u32DetecLevel, uint32_t u32DebounceEn)
862{
863 uint32_t i;
864 uint32_t u32Reg;
865 uint32_t u32TmpReg;
866
868 u32Reg = RTC->TAMPCTL;
869
870 u32TmpReg = ( RTC_TAMPCTL_TAMP0EN_Msk | (u32DetecLevel << RTC_TAMPCTL_TAMP0LV_Pos) |
871 (u32DebounceEn << RTC_TAMPCTL_TAMP0DBEN_Pos) );
872
873 for(i = 0ul; i < MAX_TAMPER_PIN_NUM; i++)
874 {
875 if(u32TamperSelect & (0x1ul << i))
876 {
878 u32Reg |= (u32TmpReg << (i*4ul));
879 }
880 }
881
883 RTC->TAMPCTL = u32Reg;
884
885}
886
902void RTC_StaticTamperDisable(uint32_t u32TamperSelect)
903{
904 uint32_t i;
905 uint32_t u32Reg;
906 uint32_t u32TmpReg;
907
909 u32Reg = RTC->TAMPCTL;
910
911 u32TmpReg = (RTC_TAMPCTL_TAMP0EN_Msk);
912
913 for(i = 0ul; i < MAX_TAMPER_PIN_NUM; i++)
914 {
915 if(u32TamperSelect & (0x1ul << i))
916 {
917 u32Reg &= ~(u32TmpReg << (i*4ul));
918 }
919 }
920
922 RTC->TAMPCTL = u32Reg;
923}
924
949void RTC_DynamicTamperEnable(uint32_t u32PairSel, uint32_t u32DebounceEn, uint32_t u32Pair1Source, uint32_t u32Pair2Source)
950{
951 uint32_t i;
952 uint32_t u32Reg;
953 uint32_t u32TmpReg;
954 uint32_t u32Tamper2Debounce, u32Tamper4Debounce;
955
957 u32Reg = RTC->TAMPCTL;
958
959 u32Tamper2Debounce = u32Reg & RTC_TAMPCTL_TAMP2DBEN_Msk;
960 u32Tamper4Debounce = u32Reg & RTC_TAMPCTL_TAMP4DBEN_Msk;
961
965 u32Reg |= ((u32Pair1Source & 0x1ul) << RTC_TAMPCTL_DYN1ISS_Pos) | ((u32Pair2Source & 0x1ul) << RTC_TAMPCTL_DYN2ISS_Pos);
966
967 if(u32DebounceEn)
968 {
971 }
972 else
973 {
975 }
976
977 for(i = 0ul; i < MAX_PAIR_NUM; i++)
978 {
979 if(u32PairSel & (0x1ul << i))
980 {
981 u32Reg &= ~((RTC_TAMPCTL_TAMP0DBEN_Msk | RTC_TAMPCTL_TAMP1DBEN_Msk) << (i*8ul));
982 u32Reg |= (u32TmpReg << (i*8ul));
983 }
984 }
985
986 if((u32Pair1Source) && (u32PairSel & RTC_PAIR1_SELECT))
987 {
988 u32Reg &= ~RTC_TAMPCTL_TAMP2EN_Msk;
989 u32Reg |= u32Tamper2Debounce;
990 }
991
992 if((u32Pair2Source) && (u32PairSel & RTC_PAIR2_SELECT))
993 {
994 u32Reg &= ~RTC_TAMPCTL_TAMP4EN_Msk;
995 u32Reg |= u32Tamper4Debounce;
996 }
997
999 RTC->TAMPCTL = u32Reg;
1000}
1001
1014void RTC_DynamicTamperDisable(uint32_t u32PairSel)
1015{
1016 uint32_t i;
1017 uint32_t u32Reg;
1018 uint32_t u32TmpReg;
1019 uint32_t u32Tamper2En = 0ul, u32Tamper4En = 0ul;
1020
1022 u32Reg = RTC->TAMPCTL;
1023
1024 if((u32Reg & RTC_TAMPCTL_DYN1ISS_Msk) && (u32PairSel & RTC_PAIR1_SELECT))
1025 {
1026 u32Tamper2En = u32Reg & RTC_TAMPCTL_TAMP2EN_Msk;
1027 }
1028
1029 if((u32Reg & RTC_TAMPCTL_DYN2ISS_Msk) && (u32PairSel & RTC_PAIR2_SELECT))
1030 {
1031 u32Tamper4En = u32Reg & RTC_TAMPCTL_TAMP4EN_Msk;
1032 }
1033
1035
1036 for(i = 0ul; i < MAX_PAIR_NUM; i++)
1037 {
1038 if(u32PairSel & (0x1ul << i))
1039 {
1040 u32Reg &= ~(u32TmpReg << ((i*8ul)));
1041 }
1042 }
1043
1044 u32Reg |= (u32Tamper2En | u32Tamper4En);
1045
1047 RTC->TAMPCTL = u32Reg;
1048}
1049
1078void RTC_DynamicTamperConfig(uint32_t u32ChangeRate, uint32_t u32SeedReload, uint32_t u32RefPattern, uint32_t u32Seed)
1079{
1080 uint32_t u32Reg;
1082 u32Reg = RTC->TAMPCTL;
1083
1085
1086 u32Reg |= (u32ChangeRate) | ((u32SeedReload & 0x1ul) << RTC_TAMPCTL_SEEDRLD_Pos) |
1087 ((u32RefPattern & 0x3ul) << RTC_TAMPCTL_DYNSRC_Pos);
1088
1090 RTC->TAMPSEED = u32Seed; /* need set seed value before re-load seed */
1092 RTC->TAMPCTL = u32Reg;
1093}
1094 /* end of group RTC_EXPORTED_FUNCTIONS */
1096 /* end of group RTC_Driver */
1098 /* end of group Standard_Driver */
1100
1101/*** (C) COPYRIGHT 2016 Nuvoton Technology Corp. ***/
NuMicro peripheral access layer header file.
#define CLK
Definition: M480.h:368
#define RTC
Definition: M480.h:400
#define SYS
Definition: M480.h:367
#define RTC_TALM_MIN_Msk
Definition: rtc_reg.h:1775
#define RTC_TAMPCTL_TAMP0DBEN_Msk
Definition: rtc_reg.h:2090
#define RTC_TAMSK_MTENMIN_Pos
Definition: rtc_reg.h:1867
#define RTC_CAL_TENDAY_Msk
Definition: rtc_reg.h:1748
#define RTC_CAL_TENYEAR_Msk
Definition: rtc_reg.h:1760
#define RTC_TAMPCTL_TAMP2DBEN_Msk
Definition: rtc_reg.h:2111
#define RTC_CALM_DAY_Pos
Definition: rtc_reg.h:1786
#define RTC_CAMSK_MTENMON_Pos
Definition: rtc_reg.h:1885
#define RTC_TAMPCTL_DYNSRC_Msk
Definition: rtc_reg.h:2075
#define RTC_TAMPCTL_DYN2ISS_Pos
Definition: rtc_reg.h:2071
#define RTC_TIME_SEC_Msk
Definition: rtc_reg.h:1727
#define RTC_CAMSK_MDAY_Pos
Definition: rtc_reg.h:1876
#define RTC_TIME_TENSEC_Msk
Definition: rtc_reg.h:1730
#define RTC_TALM_HR_Pos
Definition: rtc_reg.h:1780
#define RTC_TAMPCTL_DYN1ISS_Msk
Definition: rtc_reg.h:2069
#define RTC_TALM_TENMIN_Pos
Definition: rtc_reg.h:1777
#define RTC_TALM_SEC_Pos
Definition: rtc_reg.h:1768
#define RTC_CAL_YEAR_Msk
Definition: rtc_reg.h:1757
#define RTC_TAMPCTL_TAMP2EN_Msk
Definition: rtc_reg.h:2105
#define RTC_TIME_TENSEC_Pos
Definition: rtc_reg.h:1729
#define RTC_CAMSK_MMON_Pos
Definition: rtc_reg.h:1882
#define RTC_TAMPCTL_DYNSRC_Pos
Definition: rtc_reg.h:2074
#define RTC_TAMPCTL_SEEDRLD_Msk
Definition: rtc_reg.h:2078
#define RTC_TAMPCTL_TAMP0LV_Pos
Definition: rtc_reg.h:2086
#define RTC_TAMPCTL_DYN2ISS_Msk
Definition: rtc_reg.h:2072
#define RTC_CAL_MON_Pos
Definition: rtc_reg.h:1750
#define RTC_SPRCTL_SPRRWEN_Msk
Definition: rtc_reg.h:1895
#define RTC_CALM_DAY_Msk
Definition: rtc_reg.h:1787
#define RTC_TALM_TENSEC_Pos
Definition: rtc_reg.h:1771
#define RTC_CAMSK_MYEAR_Pos
Definition: rtc_reg.h:1888
#define RTC_TIME_MIN_Msk
Definition: rtc_reg.h:1733
#define RTC_TAMSK_MSEC_Pos
Definition: rtc_reg.h:1858
#define RTC_TALM_TENMIN_Msk
Definition: rtc_reg.h:1778
#define RTC_CALM_TENYEAR_Msk
Definition: rtc_reg.h:1802
#define RTC_TIME_TENHR_Pos
Definition: rtc_reg.h:1741
#define RTC_CALM_YEAR_Pos
Definition: rtc_reg.h:1798
#define RTC_TAMPCTL_TAMP0EN_Msk
Definition: rtc_reg.h:2084
#define RTC_TIME_HR_Msk
Definition: rtc_reg.h:1739
#define RTC_CAL_TENMON_Pos
Definition: rtc_reg.h:1753
#define RTC_CALM_TENDAY_Pos
Definition: rtc_reg.h:1789
#define RTC_CAL_DAY_Pos
Definition: rtc_reg.h:1744
#define RTC_CLKFMT_24HEN_Msk
Definition: rtc_reg.h:1763
#define RTC_TAMPCTL_TAMP5EN_Msk
Definition: rtc_reg.h:2135
#define RTC_TAMPCTL_DYN1ISS_Pos
Definition: rtc_reg.h:2068
#define RTC_CALM_TENMON_Pos
Definition: rtc_reg.h:1795
#define RTC_TALM_HR_Msk
Definition: rtc_reg.h:1781
#define RTC_CAL_TENMON_Msk
Definition: rtc_reg.h:1754
#define RTC_TAMSK_MTENHR_Pos
Definition: rtc_reg.h:1873
#define RTC_CALM_MON_Msk
Definition: rtc_reg.h:1793
#define RTC_TAMPCTL_TAMP0LV_Msk
Definition: rtc_reg.h:2087
#define RTC_CAL_TENYEAR_Pos
Definition: rtc_reg.h:1759
#define RTC_TIME_TENMIN_Msk
Definition: rtc_reg.h:1736
#define RTC_TAMPCTL_TAMP3EN_Msk
Definition: rtc_reg.h:2114
#define RTC_CAL_MON_Msk
Definition: rtc_reg.h:1751
#define RTC_TAMPCTL_SEEDRLD_Pos
Definition: rtc_reg.h:2077
#define RTC_TAMSK_MMIN_Pos
Definition: rtc_reg.h:1864
#define RTC_TALM_TENSEC_Msk
Definition: rtc_reg.h:1772
#define RTC_TAMPCTL_TAMP0DBEN_Pos
Definition: rtc_reg.h:2089
#define RTC_TAMPCTL_TAMP4DBEN_Msk
Definition: rtc_reg.h:2132
#define RTC_CAL_TENDAY_Pos
Definition: rtc_reg.h:1747
#define RTC_TAMSK_MHR_Pos
Definition: rtc_reg.h:1870
#define RTC_WEEKDAY_WEEKDAY_Msk
Definition: rtc_reg.h:1766
#define RTC_CAL_YEAR_Pos
Definition: rtc_reg.h:1756
#define RTC_CAMSK_MTENYEAR_Pos
Definition: rtc_reg.h:1891
#define RTC_CALM_TENMON_Msk
Definition: rtc_reg.h:1796
#define RTC_CALM_MON_Pos
Definition: rtc_reg.h:1792
#define RTC_TIME_TENMIN_Pos
Definition: rtc_reg.h:1735
#define RTC_INIT_ACTIVE_Msk
Definition: rtc_reg.h:1703
#define RTC_TAMPCTL_TAMP4EN_Msk
Definition: rtc_reg.h:2126
#define RTC_TAMPCTL_TAMP1EN_Msk
Definition: rtc_reg.h:2093
#define RTC_CAMSK_MTENDAY_Pos
Definition: rtc_reg.h:1879
#define RTC_TAMPCTL_DYNPR0EN_Msk
Definition: rtc_reg.h:2102
#define RTC_TIME_HR_Pos
Definition: rtc_reg.h:1738
#define RTC_TIME_MIN_Pos
Definition: rtc_reg.h:1732
#define RTC_TALM_TENHR_Pos
Definition: rtc_reg.h:1783
#define RTC_CALM_TENDAY_Msk
Definition: rtc_reg.h:1790
#define RTC_TALM_SEC_Msk
Definition: rtc_reg.h:1769
#define RTC_TAMPCTL_DYNRATE_Msk
Definition: rtc_reg.h:2081
#define RTC_CAL_DAY_Msk
Definition: rtc_reg.h:1745
#define RTC_TAMSK_MTENSEC_Pos
Definition: rtc_reg.h:1861
#define RTC_CALM_YEAR_Msk
Definition: rtc_reg.h:1799
#define RTC_TIME_SEC_Pos
Definition: rtc_reg.h:1726
#define RTC_TIME_TENHR_Msk
Definition: rtc_reg.h:1742
#define RTC_TALM_TENHR_Msk
Definition: rtc_reg.h:1784
#define RTC_TALM_MIN_Pos
Definition: rtc_reg.h:1774
#define RTC_TAMPCTL_TAMP1DBEN_Msk
Definition: rtc_reg.h:2099
#define RTC_CALM_TENYEAR_Pos
Definition: rtc_reg.h:1801
#define MAX_PAIR_NUM
Definition: rtc.h:91
#define RTC_PAIR1_SELECT
Definition: rtc.h:89
#define MAX_TAMPER_PIN_NUM
Definition: rtc.h:80
#define RTC_CLOCK_12
Definition: rtc.h:38
#define RTC_PAIR2_SELECT
Definition: rtc.h:90
#define RTC_INIT_KEY
Definition: rtc.h:32
#define RTC_PM
Definition: rtc.h:41
#define RTC_AM
Definition: rtc.h:40
#define RTC_YEAR2000
Definition: rtc.h:70
void RTC_EnableInt(uint32_t u32IntFlagMask)
Enable RTC Interrupt.
Definition: rtc.c:775
void RTC_32KCalibration(int32_t i32FrequencyX10000)
Set Frequency Compensation Data.
Definition: rtc.c:116
void RTC_DynamicTamperEnable(uint32_t u32PairSel, uint32_t u32DebounceEn, uint32_t u32Pair1Source, uint32_t u32Pair2Source)
Dynamic Tamper Detect.
Definition: rtc.c:949
uint32_t RTC_GetDayOfWeek(void)
Get Day of the Week.
Definition: rtc.c:728
void RTC_SetDateAndTime(S_RTC_TIME_DATA_T *sPt)
Update Current RTC Date and Time.
Definition: rtc.c:371
void RTC_StaticTamperDisable(uint32_t u32TamperSelect)
Static Tamper Disable.
Definition: rtc.c:902
void RTC_DynamicTamperDisable(uint32_t u32PairSel)
Dynamic Tamper Disable.
Definition: rtc.c:1014
uint32_t u32Month
Definition: rtc.h:118
void RTC_SetAlarmTimeMask(uint8_t u8IsTenHMsk, uint8_t u8IsHMsk, uint8_t u8IsTenMMsk, uint8_t u8IsMMsk, uint8_t u8IsTenSMsk, uint8_t u8IsSMsk)
Set RTC Alarm Time Mask Function.
Definition: rtc.c:702
uint32_t u32AmPm
Definition: rtc.h:125
void RTC_GetAlarmDateAndTime(S_RTC_TIME_DATA_T *sPt)
Get RTC Alarm Date and Time.
Definition: rtc.c:271
void RTC_SetAlarmDateAndTime(S_RTC_TIME_DATA_T *sPt)
Update RTC Alarm Date and Time.
Definition: rtc.c:452
uint32_t u32Hour
Definition: rtc.h:121
void RTC_EnableSpareAccess(void)
Enable Spare Registers Access.
Definition: rtc.c:815
int32_t RTC_Open(S_RTC_TIME_DATA_T *sPt)
Initialize RTC module and start counting.
Definition: rtc.c:67
void RTC_StaticTamperEnable(uint32_t u32TamperSelect, uint32_t u32DetecLevel, uint32_t u32DebounceEn)
Static Tamper Detect.
Definition: rtc.c:861
void RTC_SetDate(uint32_t u32Year, uint32_t u32Month, uint32_t u32Day, uint32_t u32DayOfWeek)
Update RTC Current Date.
Definition: rtc.c:520
void RTC_SetAlarmDateMask(uint8_t u8IsTenYMsk, uint8_t u8IsYMsk, uint8_t u8IsTenMMsk, uint8_t u8IsMMsk, uint8_t u8IsTenDMsk, uint8_t u8IsDMsk)
Set RTC Alarm Date Mask Function.
Definition: rtc.c:677
void RTC_Close(void)
Disable RTC Clock.
Definition: rtc.c:103
uint32_t u32Minute
Definition: rtc.h:122
__STATIC_INLINE void RTC_WaitAccessEnable(void)
Wait RTC Access Enable.
Definition: rtc.h:287
void RTC_SetTime(uint32_t u32Hour, uint32_t u32Minute, uint32_t u32Second, uint32_t u32TimeMode, uint32_t u32AmPm)
Update RTC Current Time.
Definition: rtc.c:553
void RTC_DynamicTamperConfig(uint32_t u32ChangeRate, uint32_t u32SeedReload, uint32_t u32RefPattern, uint32_t u32Seed)
Config dynamic tamper.
Definition: rtc.c:1078
uint32_t u32Day
Definition: rtc.h:119
uint32_t u32DayOfWeek
Definition: rtc.h:120
void RTC_SetAlarmTime(uint32_t u32Hour, uint32_t u32Minute, uint32_t u32Second, uint32_t u32TimeMode, uint32_t u32AmPm)
Update RTC Alarm Time.
Definition: rtc.c:628
void RTC_DisableInt(uint32_t u32IntFlagMask)
Disable RTC Interrupt.
Definition: rtc.c:798
uint32_t u32Year
Definition: rtc.h:117
void RTC_DisableSpareRegister(void)
Disable Spare Register.
Definition: rtc.c:831
void RTC_SetTickPeriod(uint32_t u32TickSelection)
Set RTC Tick Period Time.
Definition: rtc.c:751
void RTC_SetAlarmDate(uint32_t u32Year, uint32_t u32Month, uint32_t u32Day)
Update RTC Alarm Date.
Definition: rtc.c:598
uint32_t u32Second
Definition: rtc.h:123
uint32_t u32TimeScale
Definition: rtc.h:124
void RTC_GetDateAndTime(S_RTC_TIME_DATA_T *sPt)
Get Current RTC Date and Time.
Definition: rtc.c:176
uint32_t SystemCoreClock
Definition: system_M480.c:21