g32r4xx_ddl_rtc.h

Go to the documentation of this file.

 
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef G32R4XX_DDL_RTC_H
#define G32R4XX_DDL_RTC_H
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* Includes ------------------------------------------------------------------*/
#include "g32r4xx.h"

 
#if defined(RTC)

 
/* Private types -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private constants ---------------------------------------------------------*/
/* Masks Definition */
#define RTC_INIT_MASK      RTC_CSTS_CFGMFLG
#define RTC_CSTS_INITEN    RTC_CSTS_CFGMFLG
#define RTC_RSF_MASK       ((uint32_t)~(RTC_CSTS_INITEN | RTC_CSTS_RSYNCFLG))

 
/* Private macros ------------------------------------------------------------*/
#if defined(USE_FULL_DDL_DRIVER)
#endif /*USE_FULL_DDL_DRIVER*/
 
/* Exported types ------------------------------------------------------------*/
#if defined(USE_FULL_DDL_DRIVER)

typedef struct
{
    uint32_t Prescaler;    
} DDL_RTC_InitTypeDef;

typedef struct
{
    uint32_t TimerCounter;    
} DDL_RTC_TimeTypeDef;

typedef struct
{
    uint32_t AlarmTime;   
} DDL_RTC_AlarmTypeDef;

#endif /* USE_FULL_DDL_DRIVER */
 
/* Exported constants --------------------------------------------------------*/
 
#if defined(USE_FULL_DDL_DRIVER)
 
#endif /* USE_FULL_DDL_DRIVER */

#define DDL_RTC_CALIB_OUTPUT_NONE  0x00000000U  

#define DDL_RTC_CLOCK_SOURCE_NONE        (0x00000000UL)                       
#define DDL_RTC_CLOCK_SOURCE_LSE         (PMU_CR_RTCSEL_0)                    
#define DDL_RTC_CLOCK_SOURCE_LSI         (PMU_CR_RTCSEL_1)                    
#define DDL_RTC_CLOCK_SOURCE_HSE_DIV_32  (PMU_CR_RTCSEL_1 | PMU_CR_RTCSEL_0)  

 
/* Exported macro ------------------------------------------------------------*/


#define DDL_RTC_WriteReg(__INSTANCE__,  __REG__, __VALUE__) WRITE_REG(__INSTANCE__->__REG__, (__VALUE__))

#define DDL_RTC_ReadReg(__INSTANCE__,  __REG__) READ_REG(__INSTANCE__->__REG__)

 
/* Exported functions --------------------------------------------------------*/

__STATIC_INLINE void DDL_RTC_SetPrescaler(RTC_TypeDef* RTCx, uint32_t Prescaler)
{
    MODIFY_REG(RTCx->PSCRLDH, RTC_PSCRLD_PSCRLDH, (Prescaler >> 16U));
    MODIFY_REG(RTCx->PSCRLDL, RTC_PSCRLD_PSCRLDL, (Prescaler & 0xFFFFU));
}

__STATIC_INLINE uint32_t RTC_GetPrescalerRemainderValue(RTC_TypeDef* RTCx)
{
    return (uint32_t)((READ_BIT(RTCx->DIVH, RTC_DIVH_DIVH) << 16U) + READ_BIT(RTCx->DIVL, RTC_DIVL_DIVL));
}

__STATIC_INLINE void DDL_RTC_SetClkSource(uint32_t Source)
{
    MODIFY_REG(PMU->CR, PMU_CR_RTCSEL, Source);
}

__STATIC_INLINE uint32_t DDL_RTC_GetClkSource(void)
{
    return (uint32_t)(READ_BIT(PMU->CR, PMU_CR_RTCSEL));
}

__STATIC_INLINE void DDL_RTC_EnableInitMode(RTC_TypeDef* RTCx)
{
    /* Set the Initialization mode */
    MODIFY_REG(RTCx->CSTS, RTC_INIT_MASK, RTC_CSTS_INITEN);
}

__STATIC_INLINE void DDL_RTC_DisableInitMode(RTC_TypeDef* RTCx)
{
    /* Exit Initialization mode */
    MODIFY_REG(RTCx->CSTS, RTC_INIT_MASK, (uint32_t)~RTC_CSTS_INITEN);
}

__STATIC_INLINE void DDL_RTC_EnableClk(void)
{
    SET_BIT(PMU->CR, PMU_CR_RTCEN);
}

__STATIC_INLINE void DDL_RTC_DisableClk(void)
{
    CLEAR_BIT(PMU->CR, PMU_CR_RTCEN);
}



__STATIC_INLINE void DDL_RTC_SetTime(RTC_TypeDef* RTCx, uint32_t TimerCounter)
{
    WRITE_REG(RTCx->CNTH, ((TimerCounter >> 16U) & 0xFFFFU));
    WRITE_REG(RTCx->CNTL, (TimerCounter & 0xFFFFU));
}

__STATIC_INLINE uint32_t DDL_RTC_GetTime(RTC_TypeDef* RTCx)
{
    uint16_t cnt_high;
    uint16_t cnt_low;
 
    cnt_high = READ_BIT(RTCx->CNTH, RTC_CNT_CNTH);
    cnt_low  = READ_BIT(RTCx->CNTL, RTC_CNT_CNTL);
 
    return ((uint32_t)cnt_high << 16U) | (uint32_t)cnt_low;
}



__STATIC_INLINE void DDL_RTC_SetAlarm(RTC_TypeDef* RTCx, uint32_t Time)
{
    MODIFY_REG(RTCx->ALRH, RTC_ALRH_ALRH, ((Time >> 16U) & 0xFFFFU));
    MODIFY_REG(RTCx->ALRL, RTC_ALRL_ALRL, (Time & 0xFFFFU));
}

__STATIC_INLINE uint32_t DDL_RTC_GetAlarm(RTC_TypeDef* RTCx)
{
    return (uint32_t)((READ_BIT(RTCx->ALRH, RTC_ALRH_ALRH) << 16U) + READ_BIT(RTCx->ALRL, RTC_ALRL_ALRL));
}



__STATIC_INLINE uint32_t DDL_RTC_IsActiveFlag_SEC(RTC_TypeDef* RTCx)
{
    return ((READ_BIT(RTCx->CSTS, RTC_CSTS_SECFLG) == (RTC_CSTS_SECFLG)) ? 1UL : 0UL);
}

__STATIC_INLINE void DDL_RTC_ClearFlag_SEC(RTC_TypeDef* RTCx)
{
    CLEAR_BIT(RTCx->CSTS, RTC_CSTS_SECFLG);
}

__STATIC_INLINE uint32_t DDL_RTC_IsActiveFlag_ALR(RTC_TypeDef* RTCx)
{
    return ((READ_BIT(RTCx->CSTS, RTC_CSTS_ALRFLG) == (RTC_CSTS_ALRFLG)) ? 1UL : 0UL);
}

__STATIC_INLINE void DDL_RTC_ClearFlag_ALR(RTC_TypeDef* RTCx)
{
    CLEAR_BIT(RTCx->CSTS, RTC_CSTS_ALRFLG);
}

__STATIC_INLINE uint32_t DDL_RTC_IsActiveFlag_OVR(RTC_TypeDef* RTCx)
{
    return ((READ_BIT(RTCx->CSTS, RTC_CSTS_OVRFLG) == (RTC_CSTS_OVRFLG)) ? 1UL : 0UL);
}

__STATIC_INLINE void DDL_RTC_ClearFlag_OVR(RTC_TypeDef* RTCx)
{
    CLEAR_BIT(RTCx->CSTS, RTC_CSTS_OVRFLG);
}

__STATIC_INLINE uint32_t DDL_RTC_IsActiveFlag_RS(RTC_TypeDef* RTCx)
{
    return ((READ_BIT(RTCx->CSTS, RTC_CSTS_RSYNCFLG) == (RTC_CSTS_RSYNCFLG)) ? 1UL : 0UL);
}

__STATIC_INLINE void DDL_RTC_ClearFlag_RS(RTC_TypeDef* RTCx)
{
    WRITE_REG(RTCx->CSTS, (~((RTC_CSTS_RSYNCFLG | RTC_CSTS_INITEN) & 0x0000FFFFU) | (RTCx->CSTS & RTC_CSTS_INITEN)));
}

__STATIC_INLINE uint32_t DDL_RTC_IsActiveFlag_CFGM(RTC_TypeDef* RTCx)
{
    return ((READ_BIT(RTCx->CSTS, RTC_CSTS_CFGMFLG) == (RTC_CSTS_CFGMFLG)) ? 1UL : 0UL);
}

__STATIC_INLINE uint32_t DDL_RTC_IsActiveFlag_OCFLG(RTC_TypeDef* RTCx)
{
    return ((READ_BIT(RTCx->CSTS, RTC_CSTS_OCFLG) == (RTC_CSTS_OCFLG)) ? 1UL : 0UL);
}



__STATIC_INLINE void DDL_RTC_EnableIT_SEC(RTC_TypeDef* RTCx)
{
    SET_BIT(RTCx->CTRL, RTC_CTRL_SECIEN);
}

__STATIC_INLINE void DDL_RTC_DisableIT_SEC(RTC_TypeDef* RTCx)
{
    CLEAR_BIT(RTCx->CTRL, RTC_CTRL_SECIEN);
}

__STATIC_INLINE uint32_t DDL_RTC_IsEnabledIT_SEC(RTC_TypeDef* RTCx)
{
    return ((READ_BIT(RTCx->CTRL, RTC_CTRL_SECIEN) == (RTC_CTRL_SECIEN)) ? 1UL : 0UL);
}

__STATIC_INLINE void DDL_RTC_EnableIT_ALR(RTC_TypeDef* RTCx)
{
    SET_BIT(RTCx->CTRL, RTC_CTRL_ALRIEN);
}

__STATIC_INLINE void DDL_RTC_DisableIT_ALR(RTC_TypeDef* RTCx)
{
    CLEAR_BIT(RTCx->CTRL, RTC_CTRL_ALRIEN);
}

__STATIC_INLINE uint32_t DDL_RTC_IsEnabledIT_ALR(RTC_TypeDef* RTCx)
{
    return ((READ_BIT(RTCx->CTRL, RTC_CTRL_ALRIEN) == (RTC_CTRL_ALRIEN)) ? 1UL : 0UL);
}

__STATIC_INLINE void DDL_RTC_EnableIT_OVR(RTC_TypeDef* RTCx)
{
    SET_BIT(RTCx->CTRL, RTC_CTRL_OVRIEN);
}

__STATIC_INLINE void DDL_RTC_DisableIT_OVR(RTC_TypeDef* RTCx)
{
    CLEAR_BIT(RTCx->CTRL, RTC_CTRL_OVRIEN);
}

__STATIC_INLINE uint32_t DDL_RTC_IsEnabledIT_OVR(RTC_TypeDef* RTCx)
{
    return ((READ_BIT(RTCx->CTRL, RTC_CTRL_OVRIEN) == (RTC_CTRL_OVRIEN)) ? 1UL : 0UL);
}

 
#if defined(USE_FULL_DDL_DRIVER)
 
ErrorStatus DDL_RTC_DeInit(RTC_TypeDef* RTCx);
ErrorStatus DDL_RTC_Init(RTC_TypeDef* RTCx, DDL_RTC_InitTypeDef* RTC_InitStruct);
void        DDL_RTC_StructInit(DDL_RTC_InitTypeDef* RTC_InitStruct);
ErrorStatus DDL_RTC_TIME_Init(RTC_TypeDef* RTCx, DDL_RTC_TimeTypeDef* RTC_TimeStruct);
void        DDL_RTC_TIME_StructInit(DDL_RTC_TimeTypeDef* RTC_TimeStruct);
ErrorStatus DDL_RTC_ALM_Init(RTC_TypeDef* RTCx, DDL_RTC_AlarmTypeDef* RTC_AlarmStruct);
void        DDL_RTC_ALM_StructInit(DDL_RTC_AlarmTypeDef* RTC_AlarmStruct);
ErrorStatus DDL_RTC_EnterInitMode(RTC_TypeDef* RTCx);
ErrorStatus DDL_RTC_ExitInitMode(RTC_TypeDef* RTCx);
ErrorStatus DDL_RTC_WaitForSynchro(RTC_TypeDef* RTCx);
ErrorStatus DDL_RTC_WaitForOperationComplete(RTC_TypeDef* RTCx);

#endif /* USE_FULL_DDL_DRIVER */


 
#endif /* defined(RTC) */

 
#ifdef __cplusplus
}
#endif
 
#endif /* G32R4XX_DDL_RTC_H */