S32 SDK
rtc_hal.h
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2014 - 2015, Freescale Semiconductor, Inc.
3  * Copyright 2016-2017 NXP
4  * All rights reserved.
5  *
6  * THIS SOFTWARE IS PROVIDED BY NXP "AS IS" AND ANY EXPRESSED OR
7  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
8  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
9  * IN NO EVENT SHALL NXP OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
10  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
11  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
12  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
13  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
14  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
15  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
16  * THE POSSIBILITY OF SUCH DAMAGE.
17  */
18 
19 #ifndef RTC_HAL_H
20 #define RTC_HAL_H
21 #include <stdbool.h>
22 #include "device_registers.h"
23 #include "status.h"
24 
45 /*******************************************************************************
46  * Definitions
47  ******************************************************************************/
52 typedef enum
53 {
54  RTC_INT_1HZ = 0x00U,
55  RTC_INT_2HZ = 0x01U,
56  RTC_INT_4HZ = 0x02U,
57  RTC_INT_8HZ = 0x03U,
58  RTC_INT_16HZ = 0x04U,
59  RTC_INT_32HZ = 0x05U,
60  RTC_INT_64HZ = 0x06U,
61  RTC_INT_128HZ = 0x07U
63 
68 typedef enum
69 {
74 
79 typedef enum
80 {
84 
89 typedef enum
90 {
96 
97 /*******************************************************************************
98  * Code
99  ******************************************************************************/
100 
101 #if defined(__cplusplus)
102 extern "C" {
103 #endif
104 
110 /*****************************************************************************
111  * Methods for RTC Control
112  ****************************************************************************/
113 
121 status_t RTC_HAL_Init(RTC_Type * const base);
122 
130 status_t RTC_HAL_Enable(RTC_Type * const base);
131 
139 status_t RTC_HAL_Disable(RTC_Type * const base);
140 
152 
161 bool RTC_HAL_IsRegisterLocked(const RTC_Type * const base, rtc_lock_register_select_t reg);
162 
163 
174 
175 /*****************************************************************************
176  * Methods for RTC Time Seconds register
177  ****************************************************************************/
178 
186 static inline uint32_t RTC_HAL_GetTimeSecondsRegister(const RTC_Type * const base)
187 {
188  uint32_t tmp = base->TSR;
189  tmp = (tmp & RTC_TSR_TSR_MASK) >> RTC_TSR_TSR_SHIFT;
190  return (uint32_t) (tmp);
191 }
192 
206 status_t RTC_HAL_SetTimeSecondsRegister(RTC_Type * const base, uint32_t seconds);
207 
208 /*****************************************************************************
209  * Methods for RTC Time Prescaler register
210  ****************************************************************************/
211 
219 static inline uint16_t RTC_HAL_GetTimePrescalerRegister(const RTC_Type * const base)
220 {
221  uint32_t tmp = base->TPR;
222  tmp = (tmp & RTC_TPR_TPR_MASK) >> RTC_TPR_TPR_SHIFT;
223  return (uint16_t) (tmp);
224 }
225 
239 status_t RTC_HAL_SetTimePrescalerRegister(RTC_Type * const base, uint16_t value);
240 
241 
242 /*****************************************************************************
243  * Methods for RTC Time Alarm register
244  ****************************************************************************/
245 
253 static inline uint32_t RTC_HAL_GetTimeAlarmRegister(const RTC_Type * const base)
254 {
255  uint32_t tmp = base->TAR;
256  tmp = (tmp & RTC_TAR_TAR_MASK) >> RTC_TAR_TAR_SHIFT;
257  return (uint32_t) (tmp);
258 }
259 
269 static inline void RTC_HAL_SetTimeAlarmRegister(RTC_Type * const base, uint32_t seconds)
270 {
271  base->TAR = seconds;
272 }
273 
274 /*****************************************************************************
275  * Methods for RTC Time Compensation register
276  ****************************************************************************/
277 
295 static inline void RTC_HAL_GetTimeCompensation(const RTC_Type * const base,
296  int8_t * compensationValue,
297  uint8_t * compensationInterval)
298 {
299  uint32_t tmp = base->TCR;
300  (*compensationValue) = (int8_t)((tmp & RTC_TCR_TCR_MASK) >> RTC_TCR_TCR_SHIFT);
301  (*compensationInterval) = (uint8_t)((tmp & RTC_TCR_CIR_MASK) >> RTC_TCR_CIR_SHIFT);
302 }
303 
332 static inline void RTC_HAL_SetTimeCompensation(RTC_Type * const base,
333  int8_t compensationValue,
334  uint8_t compensationInterval)
335 {
336  uint32_t tmp = base->TCR;
338  tmp |= RTC_TCR_TCR(compensationValue);
339  tmp |= RTC_TCR_CIR(compensationInterval);
340  base->TCR = tmp;
341 }
342 
359 static inline void RTC_HAL_GetCurrentTimeCompensation(const RTC_Type * const base,
360  int8_t * compensationValue,
361  uint8_t * compensationInterval)
362 {
363  uint32_t tmp = base->TCR;
364  (*compensationValue) = (int8_t)((tmp & RTC_TCR_TCV_MASK) >> RTC_TCR_TCV_SHIFT);
365  (*compensationInterval) = (uint8_t)((tmp & RTC_TCR_CIC_MASK) >> RTC_TCR_CIC_SHIFT);
366 }
367 
368 /*****************************************************************************
369  * Methods for RTC Control register
370  ****************************************************************************/
371 
384 static inline void RTC_HAL_SetLPOSelect(RTC_Type * const base, rtc_clk_select_t clk_select)
385 {
386  uint32_t tmp = base->CR;
387  tmp &= ~(RTC_CR_LPOS_MASK);
388  tmp |= RTC_CR_LPOS(clk_select);
389  base->CR = tmp;
390 }
391 
404 static inline rtc_clk_select_t RTC_HAL_GetLPOSelect(const RTC_Type * const base)
405 {
406  uint32_t tmp = base->CR;
407  tmp = (tmp & RTC_CR_LPOS_MASK) >> RTC_CR_LPOS_SHIFT;
409 }
410 
420 static inline void RTC_HAL_SetUpdateMode(RTC_Type * const base, bool updateEnable)
421 {
422  uint32_t tmp = base->CR;
423  tmp &= ~(RTC_CR_UM_MASK);
424  tmp |= RTC_CR_UM((updateEnable ? 1UL : 0UL));
425  base->CR = tmp;
426 }
427 
437 static inline bool RTC_HAL_GetUpdateMode(const RTC_Type * const base)
438 {
439  uint32_t tmp = base->CR;
440  tmp = (tmp & RTC_CR_UM_MASK) >> RTC_CR_UM_SHIFT;
441  return ((tmp == 1U) ? true : false);
442 }
443 
454 static inline void RTC_HAL_SetNonSupervisorAccess(RTC_Type * const base, bool enable)
455 {
456  uint32_t tmp = base->CR;
457  tmp &= ~(RTC_CR_SUP_MASK);
458  tmp |= RTC_CR_SUP(enable ? 1UL : 0UL);
459  base->CR = tmp;
460 }
461 
471 static inline bool RTC_HAL_GetNonSupervisorAccess(const RTC_Type * const base)
472 {
473  uint32_t tmp = base->CR;
474  tmp = (tmp & RTC_CR_SUP_MASK) >> RTC_CR_SUP_SHIFT;
475  return ((tmp == 1U) ? true : false);
476 }
477 
484 static inline void RTC_HAL_SetSoftwareReset(RTC_Type * const base)
485 {
486  uint32_t tmp = base->CR;
487  tmp &= ~(RTC_CR_SWR_MASK);
488  tmp |= RTC_CR_SWR(1);
489  base->CR = tmp;
490 }
491 
498 static inline void RTC_HAL_ClearSoftwareReset(RTC_Type * const base)
499 {
500  uint32_t tmp = base->CR;
501  tmp &= ~(RTC_CR_SWR_MASK);
502  base->CR = tmp;
503 }
504 
505 /*****************************************************************************
506  * Methods for RTC Status register
507  ****************************************************************************/
508 
523 static inline void RTC_HAL_SetTimeCounterEnable(RTC_Type * const base, bool enable)
524 {
525  uint32_t tmp = base->SR;
526  tmp &= ~(RTC_SR_TCE_MASK);
527  tmp |= RTC_SR_TCE(enable ? 1UL : 0UL);
528  base->SR = tmp;
529 }
530 
540 static inline bool RTC_HAL_GetTimeCounterEnable(const RTC_Type * const base)
541 {
542  uint32_t tmp = base->SR;
543  tmp = (tmp & RTC_SR_TCE_MASK) >> RTC_SR_TCE_SHIFT;
544  return ((tmp == 1U) ? true : false);
545 }
546 
558 static inline bool RTC_HAL_GetTimeAlarmFlag(const RTC_Type * const base)
559 {
560  uint32_t tmp = base->SR;
561  tmp = (tmp & RTC_SR_TAF_MASK) >> RTC_SR_TAF_SHIFT;
562  return ((tmp == 1U) ? true : false);
563 }
564 
577 static inline bool RTC_HAL_GetTimeOverflowFlag(const RTC_Type * const base)
578 {
579  uint32_t tmp = base->SR;
580  tmp = (tmp & RTC_SR_TOF_MASK) >> RTC_SR_TOF_SHIFT;
581  return ((tmp == 1U) ? true : false);
582 }
583 
598 static inline bool RTC_HAL_GetTimeInvalidFlag(const RTC_Type * const base)
599 {
600  uint32_t tmp = base->SR;
601  tmp = (tmp & RTC_SR_TIF_MASK) >> RTC_SR_TIF_SHIFT;
602  return ((tmp == 1U) ? true : false);
603 }
604 
605 /*****************************************************************************
606  * Methods for RTC Lock register
607  ****************************************************************************/
608 
618 static inline void RTC_HAL_LockRegisterLock(RTC_Type * const base)
619 {
620  uint32_t tmp = base->LR;
621  tmp &= ~(RTC_LR_LRL_MASK);
622  base->LR = tmp;
623 }
624 
634 static inline bool RTC_HAL_GetLockRegisterLock(const RTC_Type * const base)
635 {
636  uint32_t tmp = base->LR;
637  tmp = (tmp & RTC_LR_LRL_MASK) >> RTC_LR_LRL_SHIFT;
638  return ((tmp == 1U) ? false : true);
639 }
640 
650 static inline void RTC_HAL_StatusRegisterLock(RTC_Type * const base)
651 {
652  uint32_t tmp = base->LR;
653  tmp &= ~(RTC_LR_SRL_MASK);
654  base->LR = tmp;
655 }
656 
666 static inline bool RTC_HAL_GetStatusRegisterLock(const RTC_Type * const base)
667 {
668  uint32_t tmp = base->LR;
669  tmp = (tmp & RTC_LR_SRL_MASK) >> RTC_LR_SRL_SHIFT;
670  return ((tmp == 1U) ? false : true);
671 }
672 
682 static inline bool RTC_HAL_GetControlRegisterLock(const RTC_Type * const base)
683 {
684  uint32_t tmp = base->LR;
685  tmp = (tmp & RTC_LR_CRL_MASK) >> RTC_LR_CRL_SHIFT;
686  return ((tmp == 1U) ? false : true);
687 }
688 
698 static inline void RTC_HAL_ControlRegisterLock(RTC_Type * const base)
699 {
700  uint32_t tmp = base->LR;
701  tmp &= ~(RTC_LR_CRL_MASK);
702  base->LR = tmp;
703 }
704 
714 static inline bool RTC_HAL_GetTimeCompensationLock(const RTC_Type * const base)
715 {
716  uint32_t tmp = base->LR;
717  tmp = (tmp & RTC_LR_TCL_MASK) >> RTC_LR_TCL_SHIFT;
718  return ((tmp == 1U) ? false : true);
719 }
720 
731 static inline void RTC_HAL_TimeCompensationLock(RTC_Type * const base)
732 {
733  uint32_t tmp = base->LR;
734  tmp &= ~(RTC_LR_TCL_MASK);
735  base->LR = tmp;
736 }
737 
738 /*****************************************************************************
739  * Methods for RTC Interrupt Enable register
740  ****************************************************************************/
741 
750 static inline void RTC_HAL_SetTimeSecondsIntConf(RTC_Type * const base, rtc_second_int_cfg_t intCfg)
751 {
752  uint32_t tmp = base->IER;
753  tmp &= ~(RTC_IER_TSIC_MASK);
754  tmp |= RTC_IER_TSIC((uint8_t)intCfg);
755  base->IER = tmp;
756 }
757 
766 {
767  rtc_second_int_cfg_t returnValue = RTC_INT_1HZ;
768  uint32_t tmp = base->IER;
769  tmp = (tmp & RTC_IER_TSIC_MASK) >> RTC_IER_TSIC_SHIFT;
770 
771  switch (tmp)
772  {
773  case 0x00U:
774  returnValue = RTC_INT_1HZ;
775  break;
776  case 0x01U:
777  returnValue = RTC_INT_2HZ;
778  break;
779  case 0x02U:
780  returnValue = RTC_INT_4HZ;
781  break;
782  case 0x03U:
783  returnValue = RTC_INT_8HZ;
784  break;
785  case 0x04U:
786  returnValue = RTC_INT_16HZ;
787  break;
788  case 0x05U:
789  returnValue = RTC_INT_32HZ;
790  break;
791  case 0x06U:
792  returnValue = RTC_INT_64HZ;
793  break;
794  case 0x07U:
795  returnValue = RTC_INT_128HZ;
796  break;
797  default:
798  /* This case should not be reached */
799  break;
800  }
801 
802  return returnValue;
803 }
804 
814 static inline void RTC_HAL_SetTimeSecondsIntEnable(RTC_Type * const base, bool enable)
815 {
816  uint32_t tmp = base->IER;
817  tmp &= ~(RTC_IER_TSIE_MASK);
818  tmp |= RTC_IER_TSIE(enable ? 1UL : 0UL);
819  base->IER = tmp;
820 }
821 
831 static inline bool RTC_HAL_GetTimeSecondsIntEnable(const RTC_Type * const base)
832 {
833  uint32_t tmp = base->IER;
834  tmp = (tmp & RTC_IER_TSIE_MASK) >> RTC_IER_TSIE_SHIFT;
835  return ((tmp == 1U) ? true : false);
836 }
837 
847 static inline void RTC_HAL_SetTimeAlarmIntEnable(RTC_Type * const base, bool enable)
848 {
849  uint32_t tmp = base->IER;
850  tmp &= ~(RTC_IER_TAIE_MASK);
851  tmp |= RTC_IER_TAIE(enable ? 1UL : 0UL);
852  base->IER = tmp;
853 }
854 
864 static inline bool RTC_HAL_GetTimeAlarmIntEnable(const RTC_Type * const base)
865 {
866  uint32_t tmp = base->IER;
867  tmp = (tmp & RTC_IER_TAIE_MASK) >> RTC_IER_TAIE_SHIFT;
868  return ((tmp == 1U) ? true : false);
869 }
870 
880 static inline void RTC_HAL_SetTimeOverflowIntEnable(RTC_Type * const base, bool enable)
881 {
882  uint32_t tmp = base->IER;
883  tmp &= ~(RTC_IER_TOIE_MASK);
884  tmp |= RTC_IER_TOIE(enable ? 1UL : 0UL);
885  base->IER = tmp;
886 }
887 
897 static inline bool RTC_HAL_GetTimeOverflowIntEnable(const RTC_Type * const base)
898 {
899  uint32_t tmp = base->IER;
900  tmp = (tmp & RTC_IER_TOIE_MASK) >> RTC_IER_TOIE_SHIFT;
901  return ((tmp == 1U) ? true : false);
902 }
903 
913 static inline void RTC_HAL_SetTimeInvalidIntEnable(RTC_Type * const base, bool enable)
914 {
915  uint32_t tmp = base->IER;
916  tmp &= ~(RTC_IER_TIIE_MASK);
917  tmp |= RTC_IER_TIIE(enable ? 1UL : 0UL);
918  base->IER = tmp;
919 }
920 
930 static inline bool RTC_HAL_GetTimeInvalidIntEnable(const RTC_Type * const base)
931 {
932  uint32_t tmp = base->IER;
933  tmp = (tmp & RTC_IER_TIIE_MASK) >> RTC_IER_TIIE_SHIFT;
934  return ((tmp == 1U) ? true : false);
935 }
936 
939 #if defined(__cplusplus)
940 }
941 #endif
942 
945 #endif /* RTC_HAL_H */
946 /*******************************************************************************
947  * EOF
948  ******************************************************************************/
#define RTC_TAR_TAR_MASK
Definition: S32K144.h:9036
status_t RTC_HAL_ConfigureClockOut(RTC_Type *const base, rtc_clk_out_config_t config)
This function configures the Clock Out pin source.
Definition: rtc_hal.c:293
#define RTC_IER_TAIE_MASK
Definition: S32K144.h:9125
#define RTC_IER_TAIE(x)
Definition: S32K144.h:9128
static rtc_second_int_cfg_t RTC_HAL_GetTimeSecondsIntConf(const RTC_Type *const base)
Get Time Seconds interrupt configuration.
Definition: rtc_hal.h:765
#define RTC_CR_SWR_MASK
Definition: S32K144.h:9058
__IO uint32_t TAR
Definition: S32K144.h:8985
static bool RTC_HAL_GetNonSupervisorAccess(const RTC_Type *const base)
Get Non-Supervisor access mode.
Definition: rtc_hal.h:471
__IO uint32_t IER
Definition: S32K144.h:8990
static void RTC_HAL_LockRegisterLock(RTC_Type *const base)
Lock the Lock Register.
Definition: rtc_hal.h:618
status_t RTC_HAL_Disable(RTC_Type *const base)
Disable RTC instance counter.
Definition: rtc_hal.c:125
#define RTC_TCR_CIR_MASK
Definition: S32K144.h:9045
#define RTC_TPR_TPR_SHIFT
Definition: S32K144.h:9032
#define RTC_TCR_TCR_SHIFT
Definition: S32K144.h:9042
#define RTC_SR_TCE(x)
Definition: S32K144.h:9098
rtc_clk_out_config_t
RTC CLKOUT pin configuration Implements : rtc_clk_out_config_t_Class.
Definition: rtc_hal.h:68
#define RTC_CR_LPOS(x)
Definition: S32K144.h:9077
#define RTC_LR_CRL_MASK
Definition: S32K144.h:9104
__IO uint32_t TPR
Definition: S32K144.h:8984
#define RTC_LR_SRL_MASK
Definition: S32K144.h:9108
static void RTC_HAL_SetTimeSecondsIntConf(RTC_Type *const base, rtc_second_int_cfg_t intCfg)
Configure Time Seconds interrupt.
Definition: rtc_hal.h:750
#define RTC_IER_TSIC_SHIFT
Definition: S32K144.h:9134
rtc_second_int_cfg_t
RTC Seconds interrupt configuration Implements : rtc_second_int_cfg_t_Class.
Definition: rtc_hal.h:52
#define RTC_IER_TSIC(x)
Definition: S32K144.h:9136
__IO uint32_t CR
Definition: S32K144.h:8987
#define RTC_TCR_CIR(x)
Definition: S32K144.h:9048
static bool RTC_HAL_GetLockRegisterLock(const RTC_Type *const base)
Get the Lock Register Lock state.
Definition: rtc_hal.h:634
#define RTC_IER_TOIE_MASK
Definition: S32K144.h:9121
#define RTC_TCR_CIC_SHIFT
Definition: S32K144.h:9054
#define RTC_SR_TIF_SHIFT
Definition: S32K144.h:9084
static void RTC_HAL_SetUpdateMode(RTC_Type *const base, bool updateEnable)
Set Update Mode of the registers when locked.
Definition: rtc_hal.h:420
#define RTC_CR_UM(x)
Definition: S32K144.h:9069
#define RTC_LR_SRL_SHIFT
Definition: S32K144.h:9109
static void RTC_HAL_ControlRegisterLock(RTC_Type *const base)
Lock the Control Register.
Definition: rtc_hal.h:698
#define RTC_SR_TAF_SHIFT
Definition: S32K144.h:9092
static bool RTC_HAL_GetTimeInvalidFlag(const RTC_Type *const base)
Get Time Invalid flag.
Definition: rtc_hal.h:598
#define RTC_TCR_TCR_MASK
Definition: S32K144.h:9041
static void RTC_HAL_SetTimeCompensation(RTC_Type *const base, int8_t compensationValue, uint8_t compensationInterval)
Set Time Compensation.
Definition: rtc_hal.h:332
#define RTC_TCR_TCR(x)
Definition: S32K144.h:9044
#define RTC_SR_TCE_MASK
Definition: S32K144.h:9095
#define RTC_IER_TSIE_MASK
Definition: S32K144.h:9129
static void RTC_HAL_SetTimeSecondsIntEnable(RTC_Type *const base, bool enable)
Enable TimeSeconds interrupt.
Definition: rtc_hal.h:814
__IO uint32_t LR
Definition: S32K144.h:8989
static void RTC_HAL_StatusRegisterLock(RTC_Type *const base)
Lock the Status Register.
Definition: rtc_hal.h:650
#define RTC_IER_TOIE(x)
Definition: S32K144.h:9124
static void RTC_HAL_SetTimeCounterEnable(RTC_Type *const base, bool enable)
Enable or disable the Time counter.
Definition: rtc_hal.h:523
static rtc_clk_select_t RTC_HAL_GetLPOSelect(const RTC_Type *const base)
Get the selected clock source for RTC prescaler.
Definition: rtc_hal.h:404
static void RTC_HAL_SetTimeOverflowIntEnable(RTC_Type *const base, bool enable)
Enable TimeOverflow interrupt.
Definition: rtc_hal.h:880
static uint16_t RTC_HAL_GetTimePrescalerRegister(const RTC_Type *const base)
Get Time Prescaler Register.
Definition: rtc_hal.h:219
#define RTC_CR_SUP_MASK
Definition: S32K144.h:9062
static bool RTC_HAL_GetTimeOverflowIntEnable(const RTC_Type *const base)
Get the TimeAlarm interrupt enable status.
Definition: rtc_hal.h:897
rtc_clk_select_t
RTC clock select Implements : rtc_clk_select_t_Class.
Definition: rtc_hal.h:79
status_t RTC_HAL_ConfigureRegisterLock(RTC_Type *const base, rtc_lock_register_select_t registerToConfig)
This function configures register lock status.
Definition: rtc_hal.c:210
#define RTC_SR_TOF_MASK
Definition: S32K144.h:9087
#define RTC_LR_TCL_SHIFT
Definition: S32K144.h:9101
__IO uint32_t SR
Definition: S32K144.h:8988
#define RTC_IER_TSIE_SHIFT
Definition: S32K144.h:9130
static void RTC_HAL_GetCurrentTimeCompensation(const RTC_Type *const base, int8_t *compensationValue, uint8_t *compensationInterval)
Get TimeCompensation Value and Interval.
Definition: rtc_hal.h:359
__IO uint32_t TSR
Definition: S32K144.h:8983
#define RTC_LR_TCL_MASK
Definition: S32K144.h:9100
#define RTC_LR_LRL_SHIFT
Definition: S32K144.h:9113
static uint32_t RTC_HAL_GetTimeSecondsRegister(const RTC_Type *const base)
Get Time Seconds Register Value.
Definition: rtc_hal.h:186
static void RTC_HAL_SetLPOSelect(RTC_Type *const base, rtc_clk_select_t clk_select)
Select clock source for RTC prescaler.
Definition: rtc_hal.h:384
static void RTC_HAL_SetTimeAlarmRegister(RTC_Type *const base, uint32_t seconds)
Set Time Alarm Register.
Definition: rtc_hal.h:269
#define RTC_TPR_TPR_MASK
Definition: S32K144.h:9031
status_t RTC_HAL_Enable(RTC_Type *const base)
Enable RTC instance counter.
Definition: rtc_hal.c:95
status_t
Status return codes. Common error codes will be a unified enumeration (C enum) that will contain all ...
Definition: status.h:31
static bool RTC_HAL_GetTimeAlarmFlag(const RTC_Type *const base)
Get the Time alarm flag.
Definition: rtc_hal.h:558
#define RTC_IER_TIIE_SHIFT
Definition: S32K144.h:9118
static uint32_t RTC_HAL_GetTimeAlarmRegister(const RTC_Type *const base)
Get Time Alarm Register.
Definition: rtc_hal.h:253
#define RTC_TSR_TSR_MASK
Definition: S32K144.h:9026
#define RTC_LR_CRL_SHIFT
Definition: S32K144.h:9105
#define RTC_TCR_TCV_SHIFT
Definition: S32K144.h:9050
#define RTC_TCR_TCV_MASK
Definition: S32K144.h:9049
#define RTC_TAR_TAR_SHIFT
Definition: S32K144.h:9037
#define RTC_IER_TSIE(x)
Definition: S32K144.h:9132
#define RTC_SR_TOF_SHIFT
Definition: S32K144.h:9088
static bool RTC_HAL_GetTimeSecondsIntEnable(const RTC_Type *const base)
Get the TimeSeconds interrupt enable status.
Definition: rtc_hal.h:831
#define RTC_CR_LPOS_SHIFT
Definition: S32K144.h:9075
#define RTC_TCR_CIC_MASK
Definition: S32K144.h:9053
static bool RTC_HAL_GetTimeInvalidIntEnable(const RTC_Type *const base)
Get the TimeInvalid interrupt enable status.
Definition: rtc_hal.h:930
bool RTC_HAL_IsRegisterLocked(const RTC_Type *const base, rtc_lock_register_select_t reg)
This function gets register lock status.
Definition: rtc_hal.c:258
#define RTC_TSR_TSR_SHIFT
Definition: S32K144.h:9027
static void RTC_HAL_SetNonSupervisorAccess(RTC_Type *const base, bool enable)
Set Non-Supervisor access mode.
Definition: rtc_hal.h:454
static bool RTC_HAL_GetControlRegisterLock(const RTC_Type *const base)
Get the Control Register Lock state.
Definition: rtc_hal.h:682
#define RTC_LR_LRL_MASK
Definition: S32K144.h:9112
status_t RTC_HAL_SetTimeSecondsRegister(RTC_Type *const base, uint32_t seconds)
Set Time Seconds Register.
Definition: rtc_hal.c:151
#define RTC_CR_SUP_SHIFT
Definition: S32K144.h:9063
#define RTC_CR_UM_MASK
Definition: S32K144.h:9066
#define RTC_SR_TAF_MASK
Definition: S32K144.h:9091
static void RTC_HAL_ClearSoftwareReset(RTC_Type *const base)
Clear Software reset flag.
Definition: rtc_hal.h:498
__IO uint32_t TCR
Definition: S32K144.h:8986
static bool RTC_HAL_GetTimeCounterEnable(const RTC_Type *const base)
Get the Time Counter Enable value.
Definition: rtc_hal.h:540
#define RTC_CR_SWR(x)
Definition: S32K144.h:9061
static void RTC_HAL_GetTimeCompensation(const RTC_Type *const base, int8_t *compensationValue, uint8_t *compensationInterval)
Get Time Compensation Value and Interval.
Definition: rtc_hal.h:295
static bool RTC_HAL_GetUpdateMode(const RTC_Type *const base)
Get the Update Mode of the registers when locked.
Definition: rtc_hal.h:437
static void RTC_HAL_SetTimeInvalidIntEnable(RTC_Type *const base, bool enable)
Enable TimeInvalid interrupt.
Definition: rtc_hal.h:913
#define RTC_CR_SUP(x)
Definition: S32K144.h:9065
static bool RTC_HAL_GetTimeCompensationLock(const RTC_Type *const base)
Get the TimeCompensation Register Lock state.
Definition: rtc_hal.h:714
static bool RTC_HAL_GetTimeAlarmIntEnable(const RTC_Type *const base)
Get the TimeAlarm interrupt enable status.
Definition: rtc_hal.h:864
#define RTC_SR_TCE_SHIFT
Definition: S32K144.h:9096
status_t RTC_HAL_Init(RTC_Type *const base)
Initialize RTC instance.
Definition: rtc_hal.c:47
static bool RTC_HAL_GetStatusRegisterLock(const RTC_Type *const base)
Get the Status Register Lock state.
Definition: rtc_hal.h:666
static void RTC_HAL_TimeCompensationLock(RTC_Type *const base)
Lock the TimeCompensation Register.
Definition: rtc_hal.h:731
#define RTC_IER_TOIE_SHIFT
Definition: S32K144.h:9122
static bool RTC_HAL_GetTimeOverflowFlag(const RTC_Type *const base)
Get Time Overflow Flag.
Definition: rtc_hal.h:577
#define RTC_CR_LPOS_MASK
Definition: S32K144.h:9074
#define RTC_IER_TIIE_MASK
Definition: S32K144.h:9117
static void RTC_HAL_SetSoftwareReset(RTC_Type *const base)
Trigger a software reset.
Definition: rtc_hal.h:484
#define RTC_IER_TSIC_MASK
Definition: S32K144.h:9133
#define RTC_IER_TIIE(x)
Definition: S32K144.h:9120
static void RTC_HAL_SetTimeAlarmIntEnable(RTC_Type *const base, bool enable)
Enable TimeAlarm interrupt.
Definition: rtc_hal.h:847
rtc_lock_register_select_t
RTC register lock Implements : rtc_lock_register_select_t_Class.
Definition: rtc_hal.h:89
#define RTC_CR_UM_SHIFT
Definition: S32K144.h:9067
#define RTC_TCR_CIR_SHIFT
Definition: S32K144.h:9046
status_t RTC_HAL_SetTimePrescalerRegister(RTC_Type *const base, uint16_t value)
Set Time Prescaler Register.
Definition: rtc_hal.c:179
#define RTC_IER_TAIE_SHIFT
Definition: S32K144.h:9126
#define RTC_SR_TIF_MASK
Definition: S32K144.h:9083