rtc.c File Reference

RTC functionality for high-precision logging voltage/current meter. More...

#include "rtc.h"
#include <stdint.h>
#include "stm32f1xx_ll_bus.h"
#include "stm32f1xx_ll_rcc.h"
#include "stm32f1xx_ll_pwr.h"
#include "stm32f1xx_ll_rtc.h"
#include "stm32f1xx_ll_exti.h"
#include "stm32f1xx_ll_cortex.h"
#include "util.h"

Go to the source code of this file.

Macros
#define	RTC_TIMEOUT_MS   ((uint32_t)1000)
#define	RTC_ASYNCH_PREDIV   ((uint32_t)0x7FFF)

Functions
static void	RTCcounter_to_dateTime (uint32_t counter)
	Function to convert the RTC counter value to date-time values in the struct. More...
static uint32_t	dateTime_to_RTCcounter (void)
	Function to convert the date-time values in the struct to a corresponding RTC counter value. More...
void	RTC_Init (void)
	Function to initialize the Real Time Clock. More...
void	readFromRTC (void)
	Function to update the RTC data in the struct. More...
void	writeToRTC (void)
	Function to update the RTC values according to the data in the struct. More...

Variables
static uint32_t	Timeout = 0

Detailed Description

RTC functionality for high-precision logging voltage/current meter.

Version

1.0

Author

Brecht Van Eeckhoudt

---

Versions

• v1.0: Initial version.

---

Todo:

Future improvements:

• Init RTC_dateTime_t struct somewhere?
• Use rtc.wday somewhere?

---

License

Copyright (C) 2021 - Brecht Van Eeckhoudt

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

A copy of the GNU General Public License can be found in the LICENSE file along with this source code.

Some methods also use code obtained from examples from STMicroelectronics.

• https://github.com/STMicroelectronics/STM32CubeF1/tree/master/Projects/STM32F103RB-Nucleo/Examples_LL/RTC/RTC_Calendar

Copyright (c) 2020 STMicroelectronics. All rights reserved.

These sections are licensed by ST under BSD 3-Clause license, the "License"; One may not use these example files except in compliance with the License. One may obtain a copy of the License at: opensource.org/licenses/BSD-3-Clause

Some methods also use code obtained from https://github.com/mkdxdx/stm32f103_logger

These seem to be heavily based on https://github.com/LonelyWolf/stm32/blob/master/stm32l-dosfs/RTC.c

Definition in file rtc.c.

Macro Definition Documentation

RTC_ASYNCH_PREDIV

#define RTC_ASYNCH_PREDIV   ((uint32_t)0x7FFF)

ck_apre = LSEFreq / (ASYNC prediv + 1) = 1Hz with LSEFreq = 32768Hz

Definition at line 80 of file rtc.c.

RTC_TIMEOUT_MS

#define RTC_TIMEOUT_MS   ((uint32_t)1000)

Oscillator time-out values

Definition at line 77 of file rtc.c.

Function Documentation

dateTime_to_RTCcounter()

static uint32_t dateTime_to_RTCcounter ( void  )

static

Function to convert the date-time values in the struct to a corresponding RTC counter value.

Note

This is a static method because it's only internally used in this file and called by other methods if necessary.

Returns

The corresponding RTC counter value (uint32_t)

Definition at line 255 of file rtc.c.

{
    uint8_t a;
    uint16_t y;
    uint8_t m;
    uint32_t JDN;
 
    if (rtc.latest == 0)
    {
        a=(14-rtc.month0)/12;
        y=rtc.year0+4800-a;
        m=rtc.month0+(12*a)-3;
 
        JDN=rtc.day0;
        JDN+=(153*m+2)/5;
        JDN+=365*y;
        JDN+=y/4;
        JDN+=-y/100;
        JDN+=y/400;
        JDN = JDN -32045;
        JDN = JDN - JULIAN_DATE_BASE;
        JDN*=86400;
        JDN+=(rtc.hour0*3600);
        JDN+=(rtc.min0*60);
        JDN+=(rtc.sec0);
    }
    else if (rtc.latest == 1)
    {
        a=(14-rtc.month1)/12;
        y=rtc.year1+4800-a;
        m=rtc.month1+(12*a)-3;
 
        JDN=rtc.day1;
        JDN+=(153*m+2)/5;
        JDN+=365*y;
        JDN+=y/4;
        JDN+=-y/100;
        JDN+=y/400;
        JDN = JDN -32045;
        JDN = JDN - JULIAN_DATE_BASE;
        JDN*=86400;
        JDN+=(rtc.hour1*3600);
        JDN+=(rtc.min1*60);
        JDN+=(rtc.sec1);
    }
 
    return (JDN);
}

readFromRTC()

void readFromRTC

(

void

)

Function to update the RTC data in the struct.

Definition at line 309 of file rtc.c.

{
    RTCcounter_to_dateTime(LL_RTC_TIME_Get(RTC));
}

RTC_Init()

void RTC_Init

(

void

)

Function to initialize the Real Time Clock.

Definition at line 97 of file rtc.c.

{
    /* Enable the PWR Clock and access to the backup domain */
    LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_PWR);
    LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_BKP);
    LL_PWR_EnableBkUpAccess();
 
    /* Enable LSE only if disabled.*/
    if (LL_RCC_LSE_IsReady() != 1)
    {
        LL_RCC_ForceBackupDomainReset();
        LL_RCC_ReleaseBackupDomainReset();
        LL_RCC_LSE_Enable();
 
        Timeout = LSE_TIMEOUT_VALUE;
 
        while (LL_RCC_LSE_IsReady() != 1)
        {
            if (LL_SYSTICK_IsActiveCounterFlag()) Timeout --;
 
            if (Timeout == 0) while(1); /* LSE activation error */
        }
    }
 
    /* Set LSE as the clock source for the RTC if not already the case */
    if (LL_RCC_GetRTCClockSource() != LL_RCC_RTC_CLKSOURCE_LSE)
    {
        LL_RCC_SetRTCClockSource(LL_RCC_RTC_CLKSOURCE_LSE);
    }
 
    /* Enable RTC peripheral Clock */
    LL_RCC_EnableRTC();
 
 
    /* Disable RTC registers write protection */
    LL_RTC_DisableWriteProtection(RTC);
 
    /* Enter in initialization mode */
    if (LL_RTC_EnterInitMode(RTC) != 0)
    {
        while(1); /* Initialization Error */
    }
 
    /* Configure RTC prescaler, set Asynch Prediv value according to source clock */
    LL_RTC_SetAsynchPrescaler(RTC, RTC_ASYNCH_PREDIV);
 
    /* RTC_Alarm Interrupt Configuration: EXTI configuration */
    LL_EXTI_EnableIT_0_31(LL_EXTI_LINE_17);
    LL_EXTI_EnableRisingTrig_0_31(LL_EXTI_LINE_17);
 
    /* Configure the NVIC for RTC Alarm */
    NVIC_SetPriority(RTC_IRQn, 0);
    NVIC_EnableIRQ(RTC_IRQn);
 
    /* Enable Second Interrupt */
    LL_RTC_EnableIT_SEC(RTC);
 
    /* Exit of initialization mode */
    LL_RTC_ExitInitMode(RTC);
 
    /* Enable RTC registers write protection */
    LL_RTC_EnableWriteProtection(RTC);
 
 
    /* Signal logic so the hour/min/second fields have to be converted to chars after RTC initialization (~boot) */
    rtc.firstUpdate = 1;
}

RTCcounter_to_dateTime()

static void RTCcounter_to_dateTime ( uint32_t  counter )

static

Function to convert the RTC counter value to date-time values in the struct.

Note

This is a static method because it's only internally used in this file and called by other methods if necessary.

Parameters

[in]

counter

RTC counter-value (uint32_t).

Definition at line 177 of file rtc.c.

{
    unsigned long time;
    unsigned long t1, a, b, c, d, e, m;
    int year = 0;
    int mon = 0;
    int wday = 0;
    int mday = 0;
    int hour = 0;
    int min = 0;
    int sec = 0;
    uint64_t jd = 0;;
    uint64_t jdn = 0;
 
    jd = ((counter+43200)/(86400>>1)) + (2440587<<1) + 1;
    jdn = jd>>1;
 
    time = counter;
    t1 = time/60;
    sec = time - t1*60;
 
    time = t1;
    t1 = time/60;
    min = time - t1*60;
 
    time = t1;
    t1 = time/24;
    hour = time - t1*24;
 
    wday = jdn%7;
 
    a = jdn + 32044;
    b = (4*a+3)/146097;
    c = a - (146097*b)/4;
    d = (4*c+3)/1461;
    e = c - (1461*d)/4;
    m = (5*e+2)/153;
    mday = e - (153*m+2)/5 + 1;
    mon = m + 3 - 12*(m/10);
    year = 100*b + d - 4800 + (m/10);
 
    if (rtc.latest == 0)
    {
        rtc.year1 = year;
        rtc.month1 = mon;
        rtc.day1 = mday;
        rtc.hour1 = hour;
        rtc.min1 = min;
        rtc.sec1 = sec;
        rtc.latest = 1;
    }
    else if (rtc.latest == 1)
    {
        rtc.year0 = year;
        rtc.month0 = mon;
        rtc.day0 = mday;
        rtc.hour0 = hour;
        rtc.min0 = min;
        rtc.sec0 = sec;
        rtc.latest = 0;
    }
 
    rtc.wday = wday;
}

writeToRTC()

void writeToRTC

(

void

)

Function to update the RTC values according to the data in the struct.

Definition at line 319 of file rtc.c.

{
    /* Disable RTC registers write protection */
    LL_RTC_DisableWriteProtection(RTC);
 
    /* Enter in initialization mode */
    if (LL_RTC_EnterInitMode(RTC) != 0)
    {
        while(1); /* Initialization Error */
    }
 
    /* Set time and date according to struct values, which have been converted to onee uint32_t value */
    LL_RTC_TIME_SetCounter(RTC, dateTime_to_RTCcounter());
 
    /* Clear RSF flag */
    LL_RTC_ClearFlag_RS(RTC);
 
    Timeout = RTC_TIMEOUT_MS;
 
    /* Wait until the RTC Time and Date registers (RTC_TR and RTC_DR) are synchronized with RTC APB clock */
    while(LL_RTC_IsActiveFlag_RS(RTC) != 1)
    {
        if (LL_SYSTICK_IsActiveCounterFlag()) Timeout --;
 
        if (Timeout == 0) while(1); /* Initialization Error */
    }
 
    /* Exit of initialization mode */
    if (LL_RTC_ExitInitMode(RTC) != 0)
    {
        while(1); /* Initialization Error */
    }
 
    /* Enable RTC registers write protection */
    LL_RTC_EnableWriteProtection(RTC);
}

Variable Documentation

Timeout

uint32_t Timeout = 0

static

Variable used for Timeout management

Definition at line 85 of file rtc.c.