rtc.c

Go to the documentation of this file.

 
/* Includes ------------------------------------------------------------------*/
#include "rtc.h"
#include "error_handler.h"
#include "hardware.h"
#include <time.h>
 
/* Private variables ---------------------------------------------------------*/
RTC_HandleTypeDef hrtc;
 
void RtcInit(void)
{
    RTC_TimeTypeDef sTime = {0U};
    RTC_DateTypeDef sDate = {0U};
 
    __HAL_RCC_RTC_ENABLE();
    __HAL_RCC_PWR_CLK_ENABLE();
    HAL_PWR_EnableBkUpAccess();
 
    HAL_NVIC_SetPriority(RTC_Alarm_IRQn, 4U, 0U);
    HAL_NVIC_EnableIRQ(RTC_Alarm_IRQn);
 
    hrtc.Instance            = RTC;
    hrtc.Init.HourFormat     = RTC_HOURFORMAT_24;
    hrtc.Init.AsynchPrediv   = 127U;
    hrtc.Init.SynchPrediv    = 249U;
    hrtc.Init.OutPut         = RTC_OUTPUT_DISABLE;
    hrtc.Init.OutPutRemap    = RTC_OUTPUT_REMAP_NONE;
    hrtc.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;
    hrtc.Init.OutPutType     = RTC_OUTPUT_TYPE_OPENDRAIN;
    if(HAL_RTC_Init(&hrtc) != HAL_OK)
    {
        ErrorHandler();
    }
 
    sTime.Hours          = 11U;
    sTime.Minutes        = 0U;
    sTime.Seconds        = 0U;
    sTime.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;
    sTime.StoreOperation = RTC_STOREOPERATION_RESET;
    if(HAL_RTC_SetTime(&hrtc, &sTime, RTC_FORMAT_BIN) != HAL_OK)
    {
        ErrorHandler();
    }
 
    sDate.WeekDay = RTC_WEEKDAY_WEDNESDAY;
    sDate.Month   = RTC_MONTH_FEBRUARY;
    sDate.Date    = 24U;
    sDate.Year    = 21U;
    if(HAL_RTC_SetDate(&hrtc, &sDate, RTC_FORMAT_BIN) != HAL_OK)
    {
        ErrorHandler();
    }
}
 
uint32_t RtcGetEpoch(void)
{
    RTC_DateTypeDef date;
    RTC_TimeTypeDef time;
    struct tm dateTime;
    static time_t epoch;
 
    HAL_RTC_GetTime(&hrtc, &time, RTC_FORMAT_BIN);
    HAL_RTC_GetDate(&hrtc, &date, RTC_FORMAT_BIN);
 
    dateTime.tm_year  = date.Year + 100U;
    dateTime.tm_mon   = date.Month - 1U;
    dateTime.tm_mday  = date.Date;
    dateTime.tm_hour  = time.Hours;
    dateTime.tm_min   = time.Minutes;
    dateTime.tm_sec   = time.Seconds;
    dateTime.tm_isdst = 0U;
 
    epoch = mktime(&dateTime);
 
    return (uint32_t)epoch;
}
 
void RtcConvertEpochToDatetime(uint32_t epoch,
                               RTC_DateTypeDef* date,
                               RTC_TimeTypeDef* time)
{
    assert_param(date != NULL);
    assert_param(time != NULL);
 
    time_t rawTime     = (time_t)epoch;
    struct tm dateTime = *localtime(&rawTime);
 
    date->Year  = dateTime.tm_year - 100U;
    date->Month = dateTime.tm_mon + 1U;
    date->Date  = dateTime.tm_mday;
    date->WeekDay =
        (dateTime.tm_wday == 0U) ? RTC_WEEKDAY_SUNDAY : dateTime.tm_wday;
 
    time->Hours      = dateTime.tm_hour;
    time->Minutes    = dateTime.tm_min;
    time->Seconds    = dateTime.tm_sec;
    time->SubSeconds = 0U;
}
 
uint8_t RtcSetAlarmFromEpoch(const uint32_t epoch)
{
    static RTC_DateTypeDef date    = {0U};
    static RTC_TimeTypeDef time    = {0U};
    static RTC_AlarmTypeDef sAlarm = {0U};
    uint8_t result                 = 0U;
 
    /* Allow alarms to be set only in the future */
    if(epoch > RtcGetEpoch())
    {
        RtcConvertEpochToDatetime(epoch, &date, &time);
 
        sAlarm.Alarm                    = RTC_ALARM_A;
        sAlarm.AlarmDateWeekDay         = date.Date;
        sAlarm.AlarmDateWeekDaySel      = RTC_ALARMDATEWEEKDAYSEL_DATE;
        sAlarm.AlarmTime.Hours          = time.Hours;
        sAlarm.AlarmTime.Minutes        = time.Minutes;
        sAlarm.AlarmTime.Seconds        = time.Seconds;
        sAlarm.AlarmTime.SubSeconds     = time.SubSeconds;
        sAlarm.AlarmTime.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;
        sAlarm.AlarmTime.StoreOperation = RTC_STOREOPERATION_RESET;
        sAlarm.AlarmMask                = RTC_ALARMMASK_NONE;
        sAlarm.AlarmSubSecondMask       = RTC_ALARMSUBSECONDMASK_ALL;
 
        if(HAL_RTC_SetAlarm_IT(&hrtc, &sAlarm, RTC_FORMAT_BIN) == HAL_OK)
        {
            result = 1U;
        }
    }
    else
    {
        result = 0U;
    }
 
    return result;
}
 
void RtcDeactivateAlarm(void)
{
    HAL_RTC_DeactivateAlarm(&hrtc, RTC_ALARM_A);
}
 
void RtcWaitForClockSynchronization(void)
{
    HAL_RTC_WaitForSynchro(&hrtc);
}