g32r4xx_ddl_rtc.c

Go to the documentation of this file.

#if defined(USE_FULL_DDL_DRIVER)
 
/* Includes ------------------------------------------------------------------*/
#include "g32r4xx_ddl_rtc.h"
#include "g32r4xx_ddl_rcm.h"
#ifdef  USE_FULL_ASSERT
    #include "g32_assert.h"
#else
    #define ASSERT_PARAM(_PARAM_) ((void)0U)
#endif

 
#if defined(RTC)

 
/* Private types -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private constants ---------------------------------------------------------*/
/* Default values used for prescaler */
#define RTC_PRESC_DEFAULT      0x000000FFU
 
/* Values used for timeout */
#define RTC_INITMODE_TIMEOUT         1000U
#define RTC_SYNCHRO_TIMEOUT          1000U
 
/* Private macros ------------------------------------------------------------*/
#define IS_DDL_RTC_PREDIV(__VALUE__)    ((__VALUE__) <= 0xFFFFFU)

/* Private function prototypes -----------------------------------------------*/
/* Exported functions --------------------------------------------------------*/


ErrorStatus DDL_RTC_DeInit(RTC_TypeDef* RTCx)
{
    ErrorStatus status = ERROR;
 
    /* Check the parameter */
    ASSERT_PARAM(IS_RTC_ALL_INSTANCE(RTCx));
 
    /* Set Initialization mode */
    if (DDL_RTC_EnterInitMode(RTCx) != ERROR)
    {
        /* Reset CNT and CTRL registers */
        DDL_RTC_WriteReg(RTCx, CTRL, 0x00000000U);
        DDL_RTC_WriteReg(RTCx, CSTS, 0x00000010U);
 
        DDL_RTC_WriteReg(RTCx, PSCRLDH, 0x00000000U);
        DDL_RTC_WriteReg(RTCx, PSCRLDL, (RTC_PSCRLD_PSCRLDL & 0x8000U));
 
        DDL_RTC_WriteReg(RTCx, CNTH, 0x00000000U);
        DDL_RTC_WriteReg(RTCx, CNTL, 0x00000000U);
 
        DDL_RTC_WriteReg(RTCx, ALRH, (RTC_ALRH_ALRH & 0xFFFFU));
        DDL_RTC_WriteReg(RTCx, ALRL, (RTC_ALRL_ALRL & 0xFFFFU));
 
        /* Exit Initialization mode */
        DDL_RTC_DisableInitMode(RTCx);
 
        /* Wait till the RTC OCF flag is set */
        status = DDL_RTC_WaitForOperationComplete(RTCx);
    }
 
    return status;
}

ErrorStatus DDL_RTC_Init(RTC_TypeDef* RTCx, DDL_RTC_InitTypeDef* RTC_InitStruct)
{
    ErrorStatus status = ERROR;
 
    /* Check the parameters */
    ASSERT_PARAM(IS_RTC_ALL_INSTANCE(RTCx));
    ASSERT_PARAM(IS_DDL_RTC_PREDIV(RTC_InitStruct->Prescaler));
 
    /* Set Initialization mode */
    if (DDL_RTC_EnterInitMode(RTCx) != ERROR)
    {
        /* Configure prescaler factor */
        DDL_RTC_SetPrescaler(RTCx, RTC_InitStruct->Prescaler);
 
        /* Exit Initialization mode */
        DDL_RTC_DisableInitMode(RTCx);
 
        /* Wait till the RTC OCF flag is set */
        status = DDL_RTC_WaitForOperationComplete(RTCx);
 
        status = SUCCESS;
    }
 
    return status;
}

void DDL_RTC_StructInit(DDL_RTC_InitTypeDef* RTC_InitStruct)
{
    /* Set RTC_InitStruct fields to default values */
    RTC_InitStruct->Prescaler = RTC_PRESC_DEFAULT;
}

ErrorStatus DDL_RTC_TIME_Init(RTC_TypeDef* RTCx, DDL_RTC_TimeTypeDef* RTC_TimeStruct)
{
    ErrorStatus status = ERROR;
 
    /* Check the parameters */
    ASSERT_PARAM(IS_RTC_ALL_INSTANCE(RTCx));
 
    /* Enter Initialization mode */
    if (DDL_RTC_EnterInitMode(RTCx) != ERROR)
    {
        DDL_RTC_SetTime(RTCx, RTC_TimeStruct->TimerCounter);
 
        /* Exit Initialization mode */
        DDL_RTC_ExitInitMode(RTCx);
 
        /* Wait till the RTC OCF flag is set */
        status = DDL_RTC_WaitForOperationComplete(RTCx);
 
        status = SUCCESS;
    }
 
    return status;
}

void DDL_RTC_TIME_StructInit(DDL_RTC_TimeTypeDef* RTC_TimeStruct)
{
    /* Time = 0sec */
    RTC_TimeStruct->TimerCounter = 0U;
}

ErrorStatus DDL_RTC_ALM_Init(RTC_TypeDef* RTCx, DDL_RTC_AlarmTypeDef* RTC_AlarmStruct)
{
    ErrorStatus status = ERROR;
 
    /* Check the parameters */
    ASSERT_PARAM(IS_RTC_ALL_INSTANCE(RTCx));
 
    /* Set Initialization mode */
    if (DDL_RTC_EnterInitMode(RTCx) != ERROR)
    {
        DDL_RTC_SetAlarm(RTCx, RTC_AlarmStruct->AlarmTime);
 
        /* Exit Initialization mode */
        DDL_RTC_ExitInitMode(RTCx);
 
        /* Wait till the RTC OCF flag is set */
        status = DDL_RTC_WaitForOperationComplete(RTCx);
 
        status = SUCCESS;
    }
 
    return status;
}

void DDL_RTC_ALM_StructInit(DDL_RTC_AlarmTypeDef* RTC_AlarmStruct)
{
    /* Alarm Time Settings : Time = 0sec */
    RTC_AlarmStruct->AlarmTime = 0U;
}

ErrorStatus DDL_RTC_EnterInitMode(RTC_TypeDef* RTCx)
{
    __IO uint32_t timeout = RTC_INITMODE_TIMEOUT;
    ErrorStatus status = SUCCESS;
    uint32_t tmp = 0U;
 
    /* Check the parameter */
    ASSERT_PARAM(IS_RTC_ALL_INSTANCE(RTCx));
 
    /* Check if the Initialization mode is set */
    if (DDL_RTC_IsActiveFlag_CFGM(RTCx) == 0U)
    {
        /* Set the Initialization mode */
        DDL_RTC_EnableInitMode(RTCx);
 
        /* Wait till RTC is in INIT state and if Time out is reached exit */
        tmp = DDL_RTC_IsActiveFlag_CFGM(RTCx);
        while ((timeout != 0U) && (tmp != 1U))
        {
            timeout--;
            tmp = DDL_RTC_IsActiveFlag_CFGM(RTCx);
            if (timeout == 0U)
            {
                status = ERROR;
            }
        }
    }
    return status;
}

ErrorStatus DDL_RTC_ExitInitMode(RTC_TypeDef* RTCx)
{
    /* Check the parameter */
    ASSERT_PARAM(IS_RTC_ALL_INSTANCE(RTCx));
 
    /* Disable initialization mode */
    DDL_RTC_DisableInitMode(RTCx);
 
    return SUCCESS;
}

ErrorStatus DDL_RTC_WaitForSynchro(RTC_TypeDef* RTCx)
{
    __IO uint32_t timeout = RTC_SYNCHRO_TIMEOUT;
    ErrorStatus status = SUCCESS;
    uint32_t tmp = 0U;
 
    /* Check the parameter */
    ASSERT_PARAM(IS_RTC_ALL_INSTANCE(RTCx));
 
    /* Clear RSF flag */
    DDL_RTC_ClearFlag_RS(RTCx);
 
    /* Wait the registers to be synchronised */
    tmp = DDL_RTC_IsActiveFlag_RS(RTCx);
    while ((timeout != 0U) && (tmp != 1U))
    {
        timeout--;
        tmp = DDL_RTC_IsActiveFlag_RS(RTCx);
        if (timeout == 0U)
        {
            status = ERROR;
        }
    }
 
    return (status);
}

ErrorStatus DDL_RTC_WaitForOperationComplete(RTC_TypeDef* RTCx)
{
    __IO uint32_t timeout = RTC_INITMODE_TIMEOUT;
    ErrorStatus status = SUCCESS;
    uint32_t tmp = 0U;
 
    /* Check the parameter */
    ASSERT_PARAM(IS_RTC_ALL_INSTANCE(RTCx));
 
    /* Clear RSF flag */
    DDL_RTC_ClearFlag_RS(RTCx);
 
    /* Wait for the operation to be completed */
    tmp = DDL_RTC_IsActiveFlag_OCFLG(RTCx);
    while ((timeout != 0U) && (tmp != 1U))
    {
        timeout--;
        tmp = DDL_RTC_IsActiveFlag_OCFLG(RTCx);
        if (timeout == 0U)
        {
            status = ERROR;
        }
    }
 
    return (status);
}
 



 
#endif /* defined(RTC) */

 
#endif /* USE_FULL_DDL_DRIVER */