rtc.c

Go to the documentation of this file.

#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */

/*----- Header-Files -------------------------------------------------------*/
#include <assert.h>                 /* Assertion handling                   */
#include <stm32f4xx.h>              /* Processor STM32F407IG                */
#include <carme.h>                  /* CARME Module                         */
#include <i2c.h>                    /* CARME I2C definitions                */
#include <rtc_ext.h>                /* CARME RTC Ext definitions            */
#include <rtc.h>                    /* CARME RTC definitions                */

/*----- Macros -------------------------------------------------------------*/
#define CARME_RTC_STATE_REG         RTC_BKP_DR0 
#define CARME_RTC_STATE_INIT_OK     0x35AC      
#define CARME_RTC_STATE_TIME_OK     0xA3C5      
/*----- Data types ---------------------------------------------------------*/

/*----- Function prototypes ------------------------------------------------*/

/*----- Data ---------------------------------------------------------------*/

/*----- Implementation -----------------------------------------------------*/
void CARME_RTC_Init(void) {

    RTC_InitTypeDef RTC_InitStruct;
    static CARME_RTC_TIME_t time;

    /* Initialize the external rtc */
    CARME_RTC_Ext_Init();

    /* Enable the PWR clock */
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);

    /* Allow access to RTC */
    PWR_BackupAccessCmd(ENABLE);

    if (RTC_ReadBackupRegister(RTC_BKP_DR0) != 0x32F2) {
        /* RTC configuration */

        /* Enable the LSE OSC */
        RCC_LSEConfig(RCC_LSE_ON);

        /* Wait till LSE is ready */
        while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET)
            ;

        /* Select the RTC Clock Source */
        RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);

        /* Enable the RTC Clock */
        RCC_RTCCLKCmd(ENABLE);

        /* Wait for RTC APB registers synchronization */
        RTC_WaitForSynchro();

        /* Configure the RTC data register and RTC prescaler */
        RTC_InitStruct.RTC_AsynchPrediv = 0x7F;
        RTC_InitStruct.RTC_SynchPrediv = 0xFF;
        RTC_InitStruct.RTC_HourFormat = RTC_HourFormat_24;

        /* Check on RTC init */
        if (RTC_Init(&RTC_InitStruct) == ERROR) {
            for (;;)
                ;
        }
    }

    /* set the rtc from the external rtc on mainboard */
    CARME_RTC_Ext_GetTime(&time);
    if (CARME_RTC_SetTime(&time) == CARME_NO_ERROR) {
        RTC_WriteBackupRegister(RTC_BKP_DR0, 0x32F2);
    }
}

ERROR_CODES CARME_RTC_SetTime(CARME_RTC_TIME_t *time) {

    static RTC_TimeTypeDef RTC_TimeStruct;
    static RTC_DateTypeDef RTC_DateStruct;

    assert(time->year < 100 && time->year >= 0);
    assert(time->month <= 12 && time->month >= 1);
    assert(time->day <= 31 && time->day >= 1);
    assert(time->wday <= 7 && time->wday >= 1);
    assert(time->hour < 24 && time->hour >= 0);
    assert(time->min < 60 && time->min >= 0);
    assert(time->sec < 60 && time->sec >= 0);

    /* set the time */
    RTC_TimeStruct.RTC_Hours = time->hour;
    RTC_TimeStruct.RTC_Minutes = time->min;
    RTC_TimeStruct.RTC_Seconds = time->sec;
    RTC_SetTime(RTC_Format_BIN, &RTC_TimeStruct);

    /* set the date */
    RTC_DateStruct.RTC_Date = time->day;
    RTC_DateStruct.RTC_Month = time->month;
    RTC_DateStruct.RTC_Year = time->year;
    RTC_DateStruct.RTC_WeekDay = time->wday;
    RTC_SetDate(RTC_Format_BIN, &RTC_DateStruct);

    return CARME_NO_ERROR;
}

void CARME_RTC_GetTime(CARME_RTC_TIME_t *time) {

    static RTC_TimeTypeDef RTC_TimeStruct;
    static RTC_DateTypeDef RTC_DateStruct;

    /* get the date and time from the internal rtc */
    RTC_GetTime(RTC_Format_BIN, &RTC_TimeStruct);
    RTC_GetDate(RTC_Format_BIN, &RTC_DateStruct);

    time->year = RTC_DateStruct.RTC_Year;
    time->month = RTC_DateStruct.RTC_Month;
    time->day = RTC_DateStruct.RTC_Date;
    time->wday = RTC_DateStruct.RTC_WeekDay;
    time->hour = RTC_TimeStruct.RTC_Hours;
    time->min = RTC_TimeStruct.RTC_Minutes;
    time->sec = RTC_TimeStruct.RTC_Seconds;
}

#if CARME_RTC_USE_WAKEUP_ISR==1

void CARME_RTC_SetWakeUpInterrupt(CARME_RTC_WAKEUP_t wakeup) {

    NVIC_InitTypeDef NVIC_InitStructure;
    EXTI_InitTypeDef EXTI_InitStructure;
    static uint32_t wakeup_time = 0x7FF;

    if (wakeup == CARME_RTC_WAKEUP_STOP) { /* disable wakeup interrupt */

        RTC_WakeUpCmd(DISABLE);
        RTC_ITConfig(RTC_IT_WUT, DISABLE); /* disable Interrupt */

        /* NVIC disable */
        NVIC_InitStructure.NVIC_IRQChannel = RTC_WKUP_IRQn;
        NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
        NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
        NVIC_InitStructure.NVIC_IRQChannelCmd = DISABLE;
        NVIC_Init(&NVIC_InitStructure);

        /* ext Interrupt 22 disable */
        EXTI_ClearITPendingBit(EXTI_Line22 );
        EXTI_InitStructure.EXTI_Line = EXTI_Line22;
        EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
        EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
        EXTI_InitStructure.EXTI_LineCmd = DISABLE;
        EXTI_Init(&EXTI_InitStructure);
    }
    else { /* enable wakeup interrupt */

        /* initialize NVIC */
        NVIC_InitStructure.NVIC_IRQChannel = RTC_WKUP_IRQn;
        NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
        NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
        NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
        NVIC_Init(&NVIC_InitStructure);

        /* set EXT interrupt 22 for wakeup */
        EXTI_ClearITPendingBit(EXTI_Line22 );
        EXTI_InitStructure.EXTI_Line = EXTI_Line22;
        EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
        EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
        EXTI_InitStructure.EXTI_LineCmd = ENABLE;
        EXTI_Init(&EXTI_InitStructure);

        /* disable wakeup while configuring */
        RTC_WakeUpCmd(DISABLE);

        switch (wakeup) {
        case RTC_WAKEUP_30s:
            wakeup_time = 0xEFFF;
            break;
        case RTC_WAKEUP_10s:
            wakeup_time = 0x4FFF;
            break;
        case RTC_WAKEUP_5s:
            wakeup_time = 0x27FF;
            break;
        case RTC_WAKEUP_1s:
            wakeup_time = 0x7FF;
            break;
        case RTC_WAKEUP_30s:
            wakeup_time = 0x3FF;
            break;
        case RTC_WAKEUP_500ms:
            wakeup_time = 0x1FF;
            break;
        case RTC_WAKEUP_125ms:
            wakeup_time = 0xFF;
            break;
        }

        /* divider 16 => 32,768kHz/16 => 2048 Hz */
        RTC_WakeUpClockConfig(RTC_WakeUpClock_RTCCLK_Div16 );
        RTC_SetWakeUpCounter(wakeup_time);

        RTC_ITConfig(RTC_IT_WUT, ENABLE); /* enable interrupt */
        RTC_WakeUpCmd(ENABLE); /* enable wakeup */

    }
}
#endif

uint32_t get_fattime(void) {

    static CARME_RTC_TIME_t time;

    CARME_RTC_GetTime(&time);

    return (((uint32_t) time.year + 20) << 25)
            | ((uint32_t) time.month << 21)
            | ((uint32_t) time.day << 16)
            | ((uint32_t) time.hour << 11)
            | ((uint32_t) time.min << 5)
            | ((uint32_t) time.sec << 1);
}

#ifdef __cplusplus
}
#endif /* __cplusplus */