zcy
/
tinySA
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

git-svn-id: svn://svn.code.sf.net/p/chibios/svn/trunk@3413 35acf78f-673a-0410-8e92-d51de3d6d3f4

master
gdisirio 2011-10-01 08:04:14 +00:00
parent d2fa0e3fde
commit 2950a0a7b8
8 changed files with 346 additions and 306 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
os/hal/include/rtc.h
View File

@ -35,6 +35,18 @@
/* Driver constants. */ /* Driver constants. */
/*===========================================================================*/ /*===========================================================================*/
/**
* @name Date/Time bit masks
* @{
*/
#define RTC_TIME_SECONDS_MASK 0x0000001F /* @brief Seconds mask. */
#define RTC_TIME_MINUTES_MASK 0x000007E0 /* @brief Minutes mask. */
#define RTC_TIME_HOURS_MASK 0x0000F800 /* @brief Hours mask. */
#define RTC_DATE_DAYS_MASK 0x001F0000 /* @brief Days mask. */
#define RTC_DATE_MONTHS_MASK 0x01E00000 /* @brief Months mask. */
#define RTC_DATE_YEARS_MASK 0xFE000000 /* @brief Years mask. */
/** @} */
/*===========================================================================*/ /*===========================================================================*/
/* Driver pre-compile time settings. */ /* Driver pre-compile time settings. */
/*===========================================================================*/ /*===========================================================================*/
@ -53,9 +65,9 @@
typedef struct RTCDriver RTCDriver; typedef struct RTCDriver RTCDriver;
/** /**
* @brief Type of an RTC callback. * @brief Type of a structure representing an RTC time stamp.
*/ */
typedef void (*rtccb_t)(RTCDriver *rtcp); typedef struct RTCTime RTCTime;
#include "rtc_lld.h" #include "rtc_lld.h"
@ -71,14 +83,17 @@ typedef void (*rtccb_t)(RTCDriver *rtcp);
extern "C" { extern "C" {
#endif #endif
void rtcInit(void); void rtcInit(void);
void rtcSetTime(RTCDriver *rtcp, const RTCTime *timespec);
void rtcGetTime(RTCDriver *rtcp, RTCTime *timespec);
#if RTC_ALARMS > 0
void rtcSetAlarm(RTCDriver *rtcp,
rtcalarm_t alarm,
const RTCAlarm *alarmspec);
void rtcGetAlarm(RTCDriver *rtcp, rtcalarm_t alarm, RTCAlarm *alarmspec);
#endif
#if RTC_SUPPORTS_CALLBACKS #if RTC_SUPPORTS_CALLBACKS
void rtcSetCallback(RTCDriver *rtcp, rtccb_t overflowcb, void rtcSetCallback(RTCDriver *rtcp, rtccb_t callback);
rtccb_t secondcb, rtccb_t alarmcb); #endif
#endif /* RTC_SUPPORTS_CALLBACKS */
void rtcSetTime(RTCDateTime *timespec);
void rtcGetTime(RTCDateTime *timespec);
void rtcSetAlarm(RTCDateTime *timespec);
void rtcGetAlarm(RTCDateTime *timespec);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

341
os/hal/platforms/STM32/RTCv1/rtc_lld.c
View File

@ -29,16 +29,16 @@
#include "ch.h" #include "ch.h"
#include "hal.h" #include "hal.h"
#if HAL_USE_RTC || defined(__DOXYGEN__) #if HAL_USE_RTC || defined(__DOXYGEN__)
/*===========================================================================*/ /*===========================================================================*/
/* Driver exported variables. */ /* Driver exported variables. */
/*===========================================================================*/ /*===========================================================================*/
/** @brief RTC driver identifier.*/ /**
RTCDriver RTCD; * @brief RTC driver identifier.
*/
RTCDriver RTCD1;
/*===========================================================================*/ /*===========================================================================*/
/* Driver local variables. */ /* Driver local variables. */
@ -55,33 +55,37 @@ RTCDriver RTCD;
* *
* @notapi * @notapi
*/ */
#if RTC_SUPPORTS_CALLBACKS static void rtc_lld_serve_interrupt(RTCDriver *rtcp) {
static void rtc_lld_serve_interrupt(RTCDriver *rtcp){
chSysLockFromIsr(); chSysLockFromIsr();
if ((RTC->CRH & RTC_CRH_SECIE) && \ if ((RTC->CRH & RTC_CRH_SECIE) && (RTC->CRL & RTC_CRL_SECF)) {
(RTC->CRL & RTC_CRL_SECF) && \ rtcp->rtc_cb(rtcp, RTC_EVENT_SECOND);
(rtcp->second_cb != NULL)){
rtcp->second_cb(rtcp);
RTC->CRL &= ~RTC_CRL_SECF; RTC->CRL &= ~RTC_CRL_SECF;
} }
if ((RTC->CRH & RTC_CRH_ALRIE) && \ if ((RTC->CRH & RTC_CRH_ALRIE) && (RTC->CRL & RTC_CRL_ALRF)) {
(RTC->CRL & RTC_CRL_ALRF) && \ rtcp->rtc_cb(rtcp, RTC_EVENT_ALARM);
(rtcp->alarm_cb != NULL)){
rtcp->alarm_cb(rtcp);
RTC->CRL &= ~RTC_CRL_ALRF; RTC->CRL &= ~RTC_CRL_ALRF;
} }
if ((RTC->CRH & RTC_CRH_OWIE) && \ if ((RTC->CRH & RTC_CRH_OWIE) && (RTC->CRL & RTC_CRL_OWF)) {
(RTC->CRL & RTC_CRL_OWF) && \ rtcp->rtc_cb(rtcp, RTC_EVENT_OVERFLOW);
(rtcp->overflow_cb != NULL)){
rtcp->overflow_cb(rtcp);
RTC->CRL &= ~RTC_CRL_OWF; RTC->CRL &= ~RTC_CRL_OWF;
} }
chSysUnlockFromIsr(); chSysUnlockFromIsr();
} }
#endif /* RTC_SUPPORTS_CALLBACKS */
/**
* @brief Waits for the previous registers write to finish.
*
* @notapi
*/
static void rtc_lld_wait_write(void) {
/* Waits registers write completion.*/
while (!(RTC->CRL & RTC_CRL_RTOFF))
;
}
/*===========================================================================*/ /*===========================================================================*/
/* Driver interrupt handlers. */ /* Driver interrupt handlers. */
@ -89,18 +93,18 @@ static void rtc_lld_serve_interrupt(RTCDriver *rtcp){
/** /**
* @brief RTC interrupt handler. * @brief RTC interrupt handler.
*
* @isr * @isr
*/ */
#if RTC_SUPPORTS_CALLBACKS
CH_IRQ_HANDLER(RTC_IRQHandler) { CH_IRQ_HANDLER(RTC_IRQHandler) {
CH_IRQ_PROLOGUE(); CH_IRQ_PROLOGUE();
rtc_lld_serve_interrupt(&RTCD);
rtc_lld_serve_interrupt(&RTCD1);
CH_IRQ_EPILOGUE(); CH_IRQ_EPILOGUE();
} }
#endif /* RTC_SUPPORTS_CALLBACKS */
/*===========================================================================*/ /*===========================================================================*/
/* Driver exported functions. */ /* Driver exported functions. */
/*===========================================================================*/ /*===========================================================================*/
@ -108,226 +112,207 @@ CH_IRQ_HANDLER(RTC_IRQHandler) {
/** /**
* @brief Enable access to registers and initialize RTC if BKP domain * @brief Enable access to registers and initialize RTC if BKP domain
* was previously reseted. * was previously reseted.
*
* @note: Cold start time of LSE oscillator on STM32 platform * @note: Cold start time of LSE oscillator on STM32 platform
* takes about 3 seconds. * takes about 3 seconds.
* *
* @notapi * @notapi
*/ */
void rtc_lld_init(void){ void rtc_lld_init(void){
uint32_t preload = 0; uint32_t preload;
rccEnableBKPInterface(FALSE); rccEnableBKPInterface(FALSE);
/* enable access to BKP registers */ /* Enables access to BKP registers.*/
PWR->CR |= PWR_CR_DBP; PWR->CR |= PWR_CR_DBP;
/* select clock source */
RCC->BDCR |= STM32_RTC; /* If the RTC is not enabled then performs a reset of the backup domain.*/
if (!(RCC->BDCR & RCC_BDCR_RTCEN)) {
RCC->BDCR = RCC_BDCR_BDRST;
RCC->BDCR = 0;
}
#if STM32_RTC == STM32_RTC_LSE #if STM32_RTC == STM32_RTC_LSE
if (! ((RCC->BDCR & RCC_BDCR_RTCEN) || (RCC->BDCR & RCC_BDCR_LSEON))){ if (!(RCC->BDCR & RCC_BDCR_LSEON)) {
RCC->BDCR |= RCC_BDCR_LSEON; RCC->BDCR |= RCC_BDCR_LSEON;
while(!(RCC->BDCR & RCC_BDCR_LSERDY)) while (!(RCC->BDCR & RCC_BDCR_LSERDY))
; ;
RCC->BDCR |= RCC_BDCR_RTCEN; }
} preload = STM32_LSECLK - 1;
preload = STM32_LSECLK - 1;
#elif STM32_RTC == STM32_RTC_LSI #elif STM32_RTC == STM32_RTC_LSI
RCC->CSR |= RCC_CSR_LSION; /* TODO: Move the LSI clock initialization in the HAL low level driver.*/
while(!(RCC->CSR & RCC_CSR_LSIRDY)) RCC->CSR |= RCC_CSR_LSION;
; while (!(RCC->CSR & RCC_CSR_LSIRDY))
/* According to errata sheet we must wait additional 100 uS for stabilization */ ;
uint32_t tmo = (STM32_SYSCLK / 1000000 ) * 100; /* According to errata sheet we must wait additional 100 uS for
while(tmo--) stabilization.
; TODO: Change this code, software loops are not reliable.*/
RCC->BDCR |= RCC_BDCR_RTCEN; uint32_t tmo = (STM32_SYSCLK / 1000000) * 100;
preload = STM32_LSICLK - 1; while (tmo--)
;
preload = STM32_LSICLK - 1;
#elif STM32_RTC == STM32_RTC_HSE #elif STM32_RTC == STM32_RTC_HSE
preload = (STM32_HSICLK / 128) - 1; preload = (STM32_HSICLK / 128) - 1;
#else
#error "RTC clock source not selected"
#endif #endif
/* Selects clock source (previously enabled and stabilized.*/
RCC->BDCR = (RCC->BDCR & ~RCC_BDCR_RTCSEL) | STM32_RTC;
/* RTC enabled regardless its previous status.*/
RCC->BDCR |= RCC_BDCR_RTCEN;
/* Ensure that RTC_CNT and RTC_DIV contain actual values after enabling /* Ensure that RTC_CNT and RTC_DIV contain actual values after enabling
* clocking on APB1, because these values only update when APB1 functioning.*/ clocking on APB1, because these values only update when APB1
RTC->CRL &= ~(RTC_CRL_RSF); functioning.*/
RTC->CRL = 0;
while (!(RTC->CRL & RTC_CRL_RSF)) while (!(RTC->CRL & RTC_CRL_RSF))
; ;
/* Write preload register only if its value changed */ /* Write preload register only if its value differs.*/
if (preload != ((((uint32_t)(RTC->PRLH)) << 16) + RTC->PRLL)){ if (preload != ((((uint32_t)(RTC->PRLH)) << 16) + (uint32_t)RTC->PRLL)) {
while(!(RTC->CRL & RTC_CRL_RTOFF))
;
RTC->CRL |= RTC_CRL_CNF; /* switch on configure mode */ rtc_lld_wait_write();
RTC->PRLH = (uint16_t)((preload >> 16) & 0b1111); /* write preloader */
/* Enters configuration mode and writes PRLx registers then leaves the
configuration mode.*/
RTC->CRL |= RTC_CRL_CNF;
RTC->PRLH = (uint16_t)(preload >> 16);
RTC->PRLL = (uint16_t)(preload & 0xFFFF); RTC->PRLL = (uint16_t)(preload & 0xFFFF);
RTC->CRL &= ~RTC_CRL_CNF; /* switch off configure mode */ RTC->CRL &= ~RTC_CRL_CNF;
while(!(RTC->CRL & RTC_CRL_RTOFF)) /* wait for completion */
;
} }
/* disable all interrupts and clear all even flags just to be safe */ /* All interrupts initially disabled.*/
RTC->CRH &= ~(RTC_CRH_OWIE | RTC_CRH_ALRIE | RTC_CRH_SECIE); RTC->CRH = 0;
RTC->CRL &= ~(RTC_CRL_SECF | RTC_CRL_ALRF | RTC_CRL_OWF);
#if RTC_SUPPORTS_CALLBACKS /* Callback initially disabled.*/
RTCD.alarm_cb = NULL; RTCD1.rtc_cb = NULL;
RTCD.overflow_cb = NULL;
RTCD.second_cb = NULL;
#endif /* RTC_SUPPORTS_CALLBACKS */
} }
/** /**
* @brief Enables and disables callbacks on the fly. * @brief Set current time.
* @note Fractional part will be silently ignored. There is no possibility
* to change it on STM32F1xx platform.
* *
* @details Pass callback function(s) in argument(s) to enable callback(s). * @param[in] rtcp pointer to RTC driver structure
* Pass NULL to disable callback. * @param[in] timespec pointer to a @p RTCTime structure
*
* @pre To use this function you must set @p RTC_SUPPORTS_CALLBACKS
* to @p TRUE.
*
* @param[in] rtcp pointer to RTC driver structure.
* @param[in] overflowcb overflow callback function.
* @param[in] secondcb every second callback function.
* @param[in] alarmcb alarm callback function.
* *
* @notapi * @notapi
*/ */
#if RTC_SUPPORTS_CALLBACKS void rtc_lld_set_time(RTCDriver *rtcp, const RTCTime *timespec) {
void rtc_lld_set_callback(RTCDriver *rtcp, rtccb_t overflowcb,
rtccb_t secondcb, rtccb_t alarmcb){
uint16_t isr_flags = 0; (void)rtcp;
if (overflowcb != NULL){ rtc_lld_wait_write();
rtcp->overflow_cb = *overflowcb;
isr_flags |= RTC_CRH_OWIE;
}
else{
rtcp->overflow_cb = NULL;
isr_flags &= ~RTC_CRH_OWIE;
}
if (alarmcb != NULL){ RTC->CRL |= RTC_CRL_CNF;
rtcp->alarm_cb = *alarmcb; RTC->CNTH = (uint16_t)(timespec->tv_sec >> 16);
isr_flags |= RTC_CRH_ALRIE;
}
else{
rtcp->alarm_cb = NULL;
isr_flags &= ~RTC_CRH_ALRIE;
}
if (secondcb != NULL){
rtcp->second_cb = *secondcb;
isr_flags |= RTC_CRH_SECIE;
}
else{
rtcp->second_cb = NULL;
isr_flags &= ~RTC_CRH_SECIE;
}
if(isr_flags != 0){
NVICEnableVector(RTC_IRQn, CORTEX_PRIORITY_MASK(STM32_RTC_IRQ_PRIORITY));
RTC->CRH |= isr_flags;
}
else{
NVICDisableVector(RTC_IRQn);
RTC->CRH = 0;
}
}
#endif /* RTC_SUPPORTS_CALLBACKS */
/**
* @brief Set current time.
*
* @param[in] timespec pointer to variable storing time.
*
* @note Fractional part will be silently ignored. There is no possibility
* to change it on STM32F1xx platform.
* @notapi
*/
void rtc_lld_set_time(RTCDateTime *timespec){
while(!(RTC->CRL & RTC_CRL_RTOFF))
;
RTC->CRL |= RTC_CRL_CNF; /* switch on configure mode */
RTC->CNTH = (uint16_t)((timespec->tv_sec >> 16) & 0xFFFF);
RTC->CNTL = (uint16_t)(timespec->tv_sec & 0xFFFF); RTC->CNTL = (uint16_t)(timespec->tv_sec & 0xFFFF);
RTC->CRL &= ~RTC_CRL_CNF; /* switch off configure mode */ RTC->CRL &= ~RTC_CRL_CNF;
while(!(RTC->CRL & RTC_CRL_RTOFF)) /* wait for completion */
;
} }
/** /**
* @brief Get current time. * @brief Get current time.
* *
* @param[in] msec pointer to variable for storing fractional part of * @param[in] rtcp pointer to RTC driver structure
* time (milliseconds). * @param[out] timespec pointer to a @p RTCTime structure
* *
* @notapi * @notapi
*/ */
inline void rtc_lld_get_time(RTCDateTime *timespec){ void rtc_lld_get_time(RTCDriver *rtcp, RTCTime *timespec) {
uint32_t time_frac = 0; uint32_t time_frac;
time_frac = (((uint32_t)RTC->DIVH) << 16) + (RTC->DIVL);
timespec->tv_msec = (uint16_t)(((STM32_LSECLK - time_frac) * 1000) / STM32_LSECLK); (void)rtcp;
time_frac = (((uint32_t)RTC->DIVH) << 16) + (uint32_t)RTC->DIVL;
timespec->tv_msec = (uint16_t)(((STM32_LSECLK - time_frac) * 1000) /
STM32_LSECLK);
timespec->tv_sec = (RTC->CNTH << 16) + RTC->CNTL; timespec->tv_sec = (RTC->CNTH << 16) + RTC->CNTL;
} }
/** /**
* @brief Set alarm time. * @brief Set alarm time.
*
* @param[in] timespec pointer to variable storing time of alarm.
*
* @note Fractional part will be silently ignored. There is no possibility
* to change it on STM32F1xx platform.
* *
* @note Default value after BKP domain reset is 0xFFFFFFFF * @note Default value after BKP domain reset is 0xFFFFFFFF
* *
* @param[in] rtcp pointer to RTC driver structure
* @param[in] alarm alarm identifier
* @param[in] alarmspec pointer to a @p RTCAlarm structure
*
* @notapi * @notapi
*/ */
void rtc_lld_set_alarm(RTCDateTime *timespec){ void rtc_lld_set_alarm(RTCDriver *rtcp,
rtcalarm_t alarm,
const RTCAlarm *alarmspec) {
while(!(RTC->CRL & RTC_CRL_RTOFF)) (void)rtcp;
; (void)alarm;
RTC->CRL |= RTC_CRL_CNF; /* switch on configure mode */ rtc_lld_wait_write();
RTC->ALRH = (uint16_t)((timespec->tv_sec >> 16) & 0xFFFF);
RTC->ALRL = (uint16_t)(timespec->tv_sec & 0xFFFF);
RTC->CRL &= ~RTC_CRL_CNF; /* switch off configure mode */
#if !(RTC_SUPPORTS_CALLBACKS) /* Enters configuration mode and writes ALRHx registers then leaves the
RTC->CRL &= ~RTC_CRL_ALRF; configuration mode.*/
RTC->CRH |= RTC_CRH_ALRIE; RTC->CRL |= RTC_CRL_CNF;
#endif /* !(RTC_SUPPORTS_CALLBACKS) */ if (alarmspec != NULL) {
RTC->ALRH = (uint16_t)(alarmspec->tv_sec >> 16);
while(!(RTC->CRL & RTC_CRL_RTOFF)) /* wait for completion */ RTC->ALRL = (uint16_t)(alarmspec->tv_sec & 0xFFFF);
; }
else {
RTC->ALRH = 0;
RTC->ALRL = 0;
}
RTC->CRL &= ~RTC_CRL_CNF;
} }
/** /**
* @brief Get current alarm time. * @brief Get current alarm.
* @note If an alarm has not been set then the returned alarm specification
* is not meaningful.
* *
* @param[in] timespec pointer to variable storing time of alarm. * @note Default value after BKP domain reset is 0xFFFFFFFF.
* *
* @note Fractional part will be silently ignored. There is no possibility * @param[in] rtcp pointer to RTC driver structure
* to change it on STM32F1xx platform. * @param[in] alarm alarm identifier
* * @param[out] alarmspec pointer to a @p RTCAlarm structure
* @note Default value after BKP domain reset is 0xFFFFFFFF
* *
* @notapi * @notapi
*/ */
inline void rtc_lld_get_alarm(RTCDateTime *timespec){ void rtc_lld_get_alarm(RTCDriver *rtcp,
timespec->tv_sec = ((RTC->ALRH << 16) + RTC->ALRL); rtcalarm_t alarm,
RTCAlarm *alarmspec) {
(void)rtcp;
(void)alarm;
alarmspec->tv_sec = ((RTC->ALRH << 16) + RTC->ALRL);
} }
/**
* @brief Enables or disables RTC callbacks.
* @details This function enables or disables callbacks, use a @p NULL pointer
* in order to disable a callback.
*
* @param[in] rtcp pointer to RTC driver structure
* @param[in] callback callback function pointer or @p NULL
*
* @notapi
*/
void rtc_lld_set_callback(RTCDriver *rtcp, rtccb_t callback) {
if (callback != NULL) {
rtcp->rtc_cb = callback;
NVICEnableVector(RTC_IRQn, CORTEX_PRIORITY_MASK(STM32_RTC_IRQ_PRIORITY));
/* Interrupts are enabled only after setting up the callback, this
way there is no need to check for the NULL callback pointer inside
the IRQ handler.*/
RTC->CRL &= ~(RTC_CRL_OWF | RTC_CRL_ALRF | RTC_CRL_SECF);
RTC->CRH |= RTC_CRH_OWIE | RTC_CRH_ALRIE | RTC_CRH_SECIE;
}
else {
NVICDisableVector(RTC_IRQn);
RTC->CRL = 0;
RTC->CRH = 0;
}
}
#endif /* HAL_USE_RTC */ #endif /* HAL_USE_RTC */

109
os/hal/platforms/STM32/RTCv1/rtc_lld.h
View File

@ -35,17 +35,19 @@
/* Driver constants. */ /* Driver constants. */
/*===========================================================================*/ /*===========================================================================*/
/**
* @brief This RTC implementation supports callbacks.
*/
#define RTC_SUPPORTS_CALLBACKS TRUE
/**
* @brief One alarm comparator available.
*/
#define RTC_ALARMS 1
/*===========================================================================*/ /*===========================================================================*/
/* Driver pre-compile time settings. */ /* Driver pre-compile time settings. */
/*===========================================================================*/ /*===========================================================================*/
/**
* @brief Switch to TRUE if you need callbacks from RTC. Switch to FALSE
* if you need only time keeping.
* @note Default is true.
*/
#if !defined(RTC_SUPPORTS_CALLBACKS) || defined(__DOXYGEN__)
#define RTC_SUPPORTS_CALLBACKS TRUE
#endif
/*===========================================================================*/ /*===========================================================================*/
/* Derived constants and error checks. */ /* Derived constants and error checks. */
@ -55,46 +57,71 @@
#error "RTC not present in the selected device" #error "RTC not present in the selected device"
#endif #endif
#if !(STM32_RTC == STM32_RTC_LSE) && !(STM32_RTC == STM32_RTC_LSI) && \
!(STM32_RTC == STM32_RTC_HSE)
#error "invalid source selected for RTC clock"
#endif
/*===========================================================================*/ /*===========================================================================*/
/* Driver data structures and types. */ /* Driver data structures and types. */
/*===========================================================================*/ /*===========================================================================*/
/** /**
* @brief Structure representing an RTC time value. * @brief Type of a structure representing an RTC alarm stamp.
*/ */
typedef struct { typedef struct RTCAlarm RTCAlarm;
/**
* @brief Type of an RTC alarm.
*/
typedef uint32_t rtcalarm_t;
/**
* @brief Type of an RTC event.
*/
typedef enum {
RTC_EVENT_SECOND = 0, /** Triggered every second. */
RTC_EVENT_ALARM = 1, /** Triggered on alarm. */
RTC_EVENT_OVERFLOW = 2 /** Triggered on counter overflow. */
} rtcevent_t;
/**
* @brief Type of a generic RTC callback.
*/
typedef void (*rtccb_t)(RTCDriver *rtcp, rtcevent_t event);
/**
* @brief Structure representing an RTC time stamp.
*/
struct RTCTime {
/** /**
* @brief Seconds sins UNIX epoch. * @brief Seconds since UNIX epoch.
*/ */
uint32_t tv_sec; uint32_t tv_sec;
/** /**
* @brief Fractional part. * @brief Fractional part.
*/ */
uint32_t tv_msec; uint32_t tv_msec;
}RTCDateTime; };
/** /**
* @brief Structure representing an RTC driver. * @brief Structure representing an RTC alarm specification.
* @note This driver is dummy when callbacks disabled. */
struct RTCAlarm {
/**
* @brief Seconds since UNIX epoch.
*/
uint32_t tv_sec;
};
/**
* @brief Structure representing an RTC driver.
*/ */
struct RTCDriver{ struct RTCDriver{
#if RTC_SUPPORTS_CALLBACKS
/** /**
* @brief Overflow callback. Set it to NULL if not used. * @brief Callback pointer.
*/ */
rtccb_t overflow_cb; rtccb_t rtc_cb;
/**
* @brief Every second callback. Set it to NULL if not used.
*/
rtccb_t second_cb;
/**
* @brief Alarm callback. Set it to NULL if not used.
*/
rtccb_t alarm_cb;
#endif /* RTC_SUPPORTS_CALLBACKS */
}; };
/*===========================================================================*/ /*===========================================================================*/
@ -105,27 +132,29 @@ struct RTCDriver{
/* External declarations. */ /* External declarations. */
/*===========================================================================*/ /*===========================================================================*/
extern RTCDriver RTCD; #if !defined(__DOXYGEN__)
extern RTCDriver RTCD1;
#endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
void rtc_lld_init(void); void rtc_lld_init(void);
void rtc_lld_set_callback(RTCDriver *rtcp, rtccb_t overflow_cb, void rtc_lld_set_time(RTCDriver *rtcp, const RTCTime *timespec);
rtccb_t second_cb, rtccb_t alarm_cb); void rtc_lld_get_time(RTCDriver *rtcp, RTCTime *timespec);
void rtc_lld_set_alarm(RTCDriver *rtcp,
void rtc_lld_set_time(RTCDateTime *timespec); rtcalarm_t alarm,
void rtc_lld_get_time(RTCDateTime *timespec); const RTCAlarm *alarmspec);
void rtc_lld_get_alarm(RTCDriver *rtcp,
void rtc_lld_get_alarm(RTCDateTime *timespec); rtcalarm_t alarm,
void rtc_lld_set_alarm(RTCDateTime *timespec); RTCAlarm *alarmspec);
void rtc_lld_set_callback(RTCDriver *rtcp, rtccb_t callback);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* HAL_USE_RTC */ #endif /* HAL_USE_RTC */
#endif /* _RTC_LLD_H_ */ #endif /* _RTC_LLD_H_ */
/** @} */ /** @} */

12
os/hal/platforms/STM32F1xx/stm32_rcc.h
View File

@ -214,8 +214,8 @@
* *
* @api * @api
*/ */
#define rccEnableBKPInterface(lp) \ #define rccEnableBKPInterface(lp) \
rccEnableAPB1((RCC_APB1ENR_BKPEN | RCC_APB1ENR_PWREN), lp); rccEnableAPB1((RCC_APB1ENR_BKPEN | RCC_APB1ENR_PWREN), lp)
/** /**
* @brief Disables BKP interface clock. * @brief Disables BKP interface clock.
@ -225,22 +225,22 @@
* *
* @api * @api
*/ */
#define rccDisableBKPInterface(lp) \ #define rccDisableBKPInterface(lp) \
rccDisableAPB1((RCC_APB1ENR_BKPEN | RCC_APB1ENR_PWREN), lp); rccDisableAPB1((RCC_APB1ENR_BKPEN | RCC_APB1ENR_PWREN), lp)
/** /**
* @brief Resets the Backup Domain interface. * @brief Resets the Backup Domain interface.
* *
* @api * @api
*/ */
#define rccResetBKPInterface() rccResetAPB1(RCC_APB1ENR_BKPRST); #define rccResetBKPInterface() rccResetAPB1(RCC_APB1ENR_BKPRST)
/** /**
* @brief Resets the entire Backup Domain. * @brief Resets the entire Backup Domain.
* *
* @api * @api
*/ */
#define rccResetBKP() (RCC->BDCR |= RCC_BDCR_BDRST); #define rccResetBKP() (RCC->BDCR |= RCC_BDCR_BDRST)
/** @} */ /** @} */
/** /**

4
os/hal/platforms/STM32L1xx/hal_lld.h
View File

@ -514,11 +514,11 @@
#if (STM32_LSECLK < 1000) || (STM32_LSECLK > 1000000) #if (STM32_LSECLK < 1000) || (STM32_LSECLK > 1000000)
#error "STM32_LSECLK outside acceptable range (1...1000KHz)" #error "STM32_LSECLK outside acceptable range (1...1000KHz)"
#endif #endif
#else /* !#if STM32_LSE_ENABLED */ #else /* !STM32_LSE_ENABLED */
#if STM_RTCCLK == STM32_LSECLK #if STM_RTCCLK == STM32_LSECLK
#error "required LSE clock is not enabled" #error "required LSE clock is not enabled"
#endif #endif
#endif /* !#if STM32_LSE_ENABLED */ #endif /* !STM32_LSE_ENABLED */
/* PLL related checks.*/ /* PLL related checks.*/
#if STM32_USB_CLOCK_ENABLED || \ #if STM32_USB_CLOCK_ENABLED || \

103
os/hal/src/rtc.c
View File

@ -52,88 +52,107 @@
/*===========================================================================*/ /*===========================================================================*/
/** /**
* @brief Enable access to registers and initialize RTC if BKP domain * @brief RTC Driver initialization.
* was previously reset.
* @note This function is implicitly invoked by @p halInit(), there is * @note This function is implicitly invoked by @p halInit(), there is
* no need to explicitly initialize the driver. * no need to explicitly initialize the driver.
* *
* @init * @init
*/ */
void rtcInit(void) { void rtcInit(void) {
rtc_lld_init(); rtc_lld_init();
} }
#if RTC_SUPPORTS_CALLBACKS || defined(__DOXYGEN__)
/**
* @brief Enables or disables callbacks.
* @details This function enables or disables callbacks, use a @p NULL pointer
* in order to disable a callback.
* @pre To use this function you must set @p RTC_SUPPORTS_CALLBACKS
* to @p TRUE.
*
* @param[in] rtcp pointer to RTC driver structure
* @param[in] overflowcb overflow callback function
* @param[in] secondcb every second callback function
* @param[in] alarmcb alarm callback function
*/
void rtcSetCallback(RTCDriver *rtcp, rtccb_t overflowcb,
rtccb_t secondcb, rtccb_t alarmcb) {
chDbgCheck((rtcp != NULL), "rtcSetCallback");
rtc_lld_set_callback(rtcp, overflowcb, secondcb, alarmcb);
}
#endif /* RTC_SUPPORTS_CALLBACKS */
/** /**
* @brief Set current time. * @brief Set current time.
* *
* @param[in] timespec pointer to a @p RTCDateTime structure * @param[in] rtcp pointer to RTC driver structure
* @param[in] timespec pointer to a @p RTCTime structure
*
* @api
*/ */
void rtcSetTime(RTCDateTime *timespec) { void rtcSetTime(RTCDriver *rtcp, const RTCTime *timespec) {
chDbgCheck((timespec != NULL), "rtcSetTime"); chDbgCheck((rtcp != NULL) && (timespec != NULL), "rtcSetTime");
rtc_lld_set_time(timespec); rtc_lld_set_time(rtcp, timespec);
} }
/** /**
* @brief Get current time. * @brief Get current time.
* *
* @param[in] timespec pointer to a @p RTCDateTime structure * @param[in] rtcp pointer to RTC driver structure
* @param[out] timespec pointer to a @p RTCTime structure
*
* @api
*/ */
void rtcGetTime(RTCDateTime *timespec) { void rtcGetTime(RTCDriver *rtcp, RTCTime *timespec) {
chDbgCheck((timespec != NULL), "rtcGetTime"); chDbgCheck((rtcp != NULL) && (timespec != NULL), "rtcGetTime");
rtc_lld_get_time(timespec);
rtc_lld_get_time(rtcp, timespec);
} }
#if (RTC_ALARMS > 0) || defined(__DOXYGEN__)
/** /**
* @brief Set alarm time. * @brief Set alarm time.
* *
* @param[in] timespec pointer to a @p RTCDateTime structure * @param[in] rtcp pointer to RTC driver structure
* @param[in] alarm alarm identifier
* @param[in] alarmspec pointer to a @p RTCAlarm structure or @p NULL
*
* @api
*/ */
void rtcSetAlarm(RTCDateTime *timespec) { void rtcSetAlarm(RTCDriver *rtcp,
rtcalarm_t alarm,
const RTCAlarm *alarmspec) {
chDbgCheck((timespec != NULL), "rtcSetAlarm"); chDbgCheck((rtcp != NULL) && (alarm < RTC_ALARMS), "rtcSetAlarm");
rtc_lld_set_alarm(timespec); rtc_lld_set_alarm(rtcp, alarm, alarmspec);
} }
/** /**
* @brief Get current alarm. * @brief Get current alarm.
* @note If an alarm has not been set then the returned alarm specification
* is not meaningful.
* *
* @param[in] timespec pointer to a @p RTCDateTime structure * @param[in] rtcp pointer to RTC driver structure
* @param[in] alarm alarm identifier
* @param[out] alarmspec pointer to a @p RTCAlarm structure
*
* @api
*/ */
void rtcGetAlarm(RTCDateTime *timespec){ void rtcGetAlarm(RTCDriver *rtcp,
rtcalarm_t alarm,
RTCAlarm *alarmspec) {
chDbgCheck((timespec != NULL), "rtcGetAlarm"); chDbgCheck((rtcp != NULL) && (alarm < RTC_ALARMS) && (alarmspec != NULL),
"rtcGetAlarm");
rtc_lld_get_alarm(timespec); rtc_lld_get_alarm(rtcp, alarm, alarmspec);
} }
#endif /* RTC_ALARMS > 0 */
#if RTC_SUPPORTS_CALLBACKS || defined(__DOXYGEN__)
/**
* @brief Enables or disables RTC callbacks.
* @details This function enables or disables callbacks, use a @p NULL pointer
* in order to disable a callback.
*
* @param[in] rtcp pointer to RTC driver structure
* @param[in] callback callback function pointer or @p NULL
*
* @api
*/
void rtcSetCallback(RTCDriver *rtcp, rtccb_t callback) {
chDbgCheck((rtcp != NULL), "rtcSetCallback");
rtc_lld_set_callback(rtcp, callback);
}
#endif /* RTC_SUPPORTS_CALLBACKS */
#endif /* HAL_USE_RTC */ #endif /* HAL_USE_RTC */
/** @} */ /** @} */

6
testhal/STM32F1xx/RTC/Makefile
View File

@ -12,7 +12,7 @@ ifeq ($(USE_OPT),)
# If all calls to a given function are integrated, and the function is declared static, then the function is normally not output as assembler code in its own right. # If all calls to a given function are integrated, and the function is declared static, then the function is normally not output as assembler code in its own right.
# Enabled at level '-O3'. # Enabled at level '-O3'.
USE_OPT = -O0 -ggdb -fomit-frame-pointer -falign-functions=16 USE_OPT = -O2 -ggdb -fomit-frame-pointer -falign-functions=16
#USE_OPT = -O1 -ggdb -fomit-frame-pointer -falign-functions=16 -fno-inline #USE_OPT = -O1 -ggdb -fomit-frame-pointer -falign-functions=16 -fno-inline
#USE_OPT = -O2 -ggdb -fomit-frame-pointer -falign-functions=16 -fno-strict-aliasing #USE_OPT = -O2 -ggdb -fomit-frame-pointer -falign-functions=16 -fno-strict-aliasing
#USE_OPT = -O3 -ggdb -fomit-frame-pointer -falign-functions=16 #USE_OPT = -O3 -ggdb -fomit-frame-pointer -falign-functions=16
@ -86,7 +86,6 @@ CSRC = $(PORTSRC) \
$(CHIBIOS)/os/various/evtimer.c \ $(CHIBIOS)/os/various/evtimer.c \
$(CHIBIOS)/os/various/syscalls.c \ $(CHIBIOS)/os/various/syscalls.c \
main.c \ main.c \
# C++ sources that can be compiled in ARM or THUMB mode depending on the global # C++ sources that can be compiled in ARM or THUMB mode depending on the global
# setting. # setting.
@ -215,6 +214,3 @@ ifeq ($(USE_FWLIB),yes)
endif endif
include $(CHIBIOS)/os/ports/GCC/ARMCMx/rules.mk include $(CHIBIOS)/os/ports/GCC/ARMCMx/rules.mk

44
testhal/STM32F1xx/RTC/main.c
View File

@ -21,14 +21,11 @@
#include "ch.h" #include "ch.h"
#include "hal.h" #include "hal.h"
RTCTime timespec;
RTCDateTime timespec; RTCAlarm alarmspec;
RTCDateTime alarmspec;
#define TEST_ALARM_WAKEUP FALSE #define TEST_ALARM_WAKEUP FALSE
#if TEST_ALARM_WAKEUP #if TEST_ALARM_WAKEUP
/* sleep indicator thread */ /* sleep indicator thread */
@ -64,38 +61,37 @@ int main(void) {
return 0; return 0;
} }
#else /* TEST_ALARM_WAKEUP */ #else /* TEST_ALARM_WAKEUP */
static void my_overflowcb(RTCDriver *rtcp){ static void my_cb(RTCDriver *rtcp, rtcevent_t event) {
(void)rtcp;
palTogglePad(IOPORT3, GPIOC_LED);
}
static void my_secondcb(RTCDriver *rtcp){
(void)rtcp; (void)rtcp;
//palTogglePad(IOPORT3, GPIOC_LED);
}
static void my_alarmcb(RTCDriver *rtcp){ switch (event) {
(void)rtcp; case RTC_EVENT_OVERFLOW:
palTogglePad(IOPORT3, GPIOC_LED); palTogglePad(GPIOC, GPIOC_LED);
rtcGetTime(&timespec); break;
alarmspec.tv_sec = timespec.tv_sec + 10; case RTC_EVENT_SECOND:
rtcSetAlarm(&alarmspec); //palTogglePad(GPIOC, GPIOC_LED);
break;
case RTC_EVENT_ALARM:
palTogglePad(GPIOC, GPIOC_LED);
rtcGetTime(&RTCD1, &timespec);
alarmspec.tv_sec = timespec.tv_sec + 10;
rtcSetAlarm(&RTCD1, 0, &alarmspec);
break;
}
} }
int main(void) { int main(void) {
halInit(); halInit();
chSysInit(); chSysInit();
rtcGetTime(&timespec); rtcGetTime(&RTCD1, &timespec);
alarmspec.tv_sec = timespec.tv_sec + 10; alarmspec.tv_sec = timespec.tv_sec + 10;
rtcSetAlarm(&alarmspec); rtcSetAlarm(&RTCD1, 0, &alarmspec);
rtcSetCallback(&RTCD, my_overflowcb, my_secondcb, my_alarmcb); rtcSetCallback(&RTCD1, my_cb);
while (TRUE){ while (TRUE){
chThdSleepMilliseconds(500); chThdSleepMilliseconds(500);
} }