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. */
/*===========================================================================*/
/**
* @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. */
/*===========================================================================*/
@ -53,9 +65,9 @@
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"
@ -71,14 +83,17 @@ typedef void (*rtccb_t)(RTCDriver *rtcp);
extern "C" {
#endif
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
void rtcSetCallback(RTCDriver *rtcp, rtccb_t overflowcb,
rtccb_t secondcb, rtccb_t alarmcb);
#endif /* RTC_SUPPORTS_CALLBACKS */
void rtcSetTime(RTCDateTime *timespec);
void rtcGetTime(RTCDateTime *timespec);
void rtcSetAlarm(RTCDateTime *timespec);
void rtcGetAlarm(RTCDateTime *timespec);
void rtcSetCallback(RTCDriver *rtcp, rtccb_t callback);
#endif
#ifdef __cplusplus
}
#endif

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

@ -29,16 +29,16 @@
#include "ch.h"
#include "hal.h"
#if HAL_USE_RTC || defined(__DOXYGEN__)
/*===========================================================================*/
/* Driver exported variables. */
/*===========================================================================*/
/** @brief RTC driver identifier.*/
RTCDriver RTCD;
/**
* @brief RTC driver identifier.
*/
RTCDriver RTCD1;
/*===========================================================================*/
/* Driver local variables. */
@ -55,33 +55,37 @@ RTCDriver RTCD;
*
* @notapi
*/
#if RTC_SUPPORTS_CALLBACKS
static void rtc_lld_serve_interrupt(RTCDriver *rtcp) {
static void rtc_lld_serve_interrupt(RTCDriver *rtcp){
chSysLockFromIsr();
if ((RTC->CRH & RTC_CRH_SECIE) && \
(RTC->CRL & RTC_CRL_SECF) && \
(rtcp->second_cb != NULL)){
rtcp->second_cb(rtcp);
if ((RTC->CRH & RTC_CRH_SECIE) && (RTC->CRL & RTC_CRL_SECF)) {
rtcp->rtc_cb(rtcp, RTC_EVENT_SECOND);
RTC->CRL &= ~RTC_CRL_SECF;
}
if ((RTC->CRH & RTC_CRH_ALRIE) && \
(RTC->CRL & RTC_CRL_ALRF) && \
(rtcp->alarm_cb != NULL)){
rtcp->alarm_cb(rtcp);
if ((RTC->CRH & RTC_CRH_ALRIE) && (RTC->CRL & RTC_CRL_ALRF)) {
rtcp->rtc_cb(rtcp, RTC_EVENT_ALARM);
RTC->CRL &= ~RTC_CRL_ALRF;
}
if ((RTC->CRH & RTC_CRH_OWIE) && \
(RTC->CRL & RTC_CRL_OWF) && \
(rtcp->overflow_cb != NULL)){
rtcp->overflow_cb(rtcp);
if ((RTC->CRH & RTC_CRH_OWIE) && (RTC->CRL & RTC_CRL_OWF)) {
rtcp->rtc_cb(rtcp, RTC_EVENT_OVERFLOW);
RTC->CRL &= ~RTC_CRL_OWF;
}
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. */
@ -89,18 +93,18 @@ static void rtc_lld_serve_interrupt(RTCDriver *rtcp){
/**
* @brief RTC interrupt handler.
*
* @isr
*/
#if RTC_SUPPORTS_CALLBACKS
CH_IRQ_HANDLER(RTC_IRQHandler) {
CH_IRQ_PROLOGUE();
rtc_lld_serve_interrupt(&RTCD);
rtc_lld_serve_interrupt(&RTCD1);
CH_IRQ_EPILOGUE();
}
#endif /* RTC_SUPPORTS_CALLBACKS */
/*===========================================================================*/
/* Driver exported functions. */
/*===========================================================================*/
@ -108,226 +112,207 @@ CH_IRQ_HANDLER(RTC_IRQHandler) {
/**
* @brief Enable access to registers and initialize RTC if BKP domain
* was previously reseted.
*
* @note: Cold start time of LSE oscillator on STM32 platform
* takes about 3 seconds.
*
* @notapi
*/
void rtc_lld_init(void){
uint32_t preload = 0;
uint32_t preload;
rccEnableBKPInterface(FALSE);
/* enable access to BKP registers */
/* Enables access to BKP registers.*/
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 (! ((RCC->BDCR & RCC_BDCR_RTCEN) || (RCC->BDCR & RCC_BDCR_LSEON))){
if (!(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;
#elif STM32_RTC == STM32_RTC_LSI
/* TODO: Move the LSI clock initialization in the HAL low level driver.*/
RCC->CSR |= RCC_CSR_LSION;
while(!(RCC->CSR & RCC_CSR_LSIRDY))
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;
while(tmo--)
/* According to errata sheet we must wait additional 100 uS for
stabilization.
TODO: Change this code, software loops are not reliable.*/
uint32_t tmo = (STM32_SYSCLK / 1000000) * 100;
while (tmo--)
;
RCC->BDCR |= RCC_BDCR_RTCEN;
preload = STM32_LSICLK - 1;
#elif STM32_RTC == STM32_RTC_HSE
preload = (STM32_HSICLK / 128) - 1;
#else
#error "RTC clock source not selected"
#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
* clocking on APB1, because these values only update when APB1 functioning.*/
RTC->CRL &= ~(RTC_CRL_RSF);
clocking on APB1, because these values only update when APB1
functioning.*/
RTC->CRL = 0;
while (!(RTC->CRL & RTC_CRL_RSF))
;
/* Write preload register only if its value changed */
if (preload != ((((uint32_t)(RTC->PRLH)) << 16) + RTC->PRLL)){
while(!(RTC->CRL & RTC_CRL_RTOFF))
;
/* Write preload register only if its value differs.*/
if (preload != ((((uint32_t)(RTC->PRLH)) << 16) + (uint32_t)RTC->PRLL)) {
RTC->CRL |= RTC_CRL_CNF; /* switch on configure mode */
RTC->PRLH = (uint16_t)((preload >> 16) & 0b1111); /* write preloader */
rtc_lld_wait_write();
/* 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->CRL &= ~RTC_CRL_CNF; /* switch off configure mode */
while(!(RTC->CRL & RTC_CRL_RTOFF)) /* wait for completion */
;
RTC->CRL &= ~RTC_CRL_CNF;
}
/* disable all interrupts and clear all even flags just to be safe */
RTC->CRH &= ~(RTC_CRH_OWIE | RTC_CRH_ALRIE | RTC_CRH_SECIE);
RTC->CRL &= ~(RTC_CRL_SECF | RTC_CRL_ALRF | RTC_CRL_OWF);
#if RTC_SUPPORTS_CALLBACKS
RTCD.alarm_cb = NULL;
RTCD.overflow_cb = NULL;
RTCD.second_cb = NULL;
#endif /* RTC_SUPPORTS_CALLBACKS */
}
/**
* @brief Enables and disables callbacks on the fly.
*
* @details Pass callback function(s) in argument(s) to enable callback(s).
* Pass NULL to disable 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.
*
* @notapi
*/
#if RTC_SUPPORTS_CALLBACKS
void rtc_lld_set_callback(RTCDriver *rtcp, rtccb_t overflowcb,
rtccb_t secondcb, rtccb_t alarmcb){
uint16_t isr_flags = 0;
if (overflowcb != NULL){
rtcp->overflow_cb = *overflowcb;
isr_flags |= RTC_CRH_OWIE;
}
else{
rtcp->overflow_cb = NULL;
isr_flags &= ~RTC_CRH_OWIE;
}
if (alarmcb != NULL){
rtcp->alarm_cb = *alarmcb;
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);
/* All interrupts initially disabled.*/
RTC->CRH = 0;
}
/* Callback initially disabled.*/
RTCD1.rtc_cb = NULL;
}
#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.
*
* @param[in] rtcp pointer to RTC driver structure
* @param[in] timespec pointer to a @p RTCTime structure
*
* @notapi
*/
void rtc_lld_set_time(RTCDateTime *timespec){
void rtc_lld_set_time(RTCDriver *rtcp, const RTCTime *timespec) {
while(!(RTC->CRL & RTC_CRL_RTOFF))
;
(void)rtcp;
RTC->CRL |= RTC_CRL_CNF; /* switch on configure mode */
RTC->CNTH = (uint16_t)((timespec->tv_sec >> 16) & 0xFFFF);
rtc_lld_wait_write();
RTC->CRL |= RTC_CRL_CNF;
RTC->CNTH = (uint16_t)(timespec->tv_sec >> 16);
RTC->CNTL = (uint16_t)(timespec->tv_sec & 0xFFFF);
RTC->CRL &= ~RTC_CRL_CNF; /* switch off configure mode */
while(!(RTC->CRL & RTC_CRL_RTOFF)) /* wait for completion */
;
RTC->CRL &= ~RTC_CRL_CNF;
}
/**
* @brief Get current time.
*
* @param[in] msec pointer to variable for storing fractional part of
* time (milliseconds).
* @param[in] rtcp pointer to RTC driver structure
* @param[out] timespec pointer to a @p RTCTime structure
*
* @notapi
*/
inline void rtc_lld_get_time(RTCDateTime *timespec){
uint32_t time_frac = 0;
time_frac = (((uint32_t)RTC->DIVH) << 16) + (RTC->DIVL);
void rtc_lld_get_time(RTCDriver *rtcp, RTCTime *timespec) {
uint32_t time_frac;
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;
}
/**
* @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
*
* @param[in] rtcp pointer to RTC driver structure
* @param[in] alarm alarm identifier
* @param[in] alarmspec pointer to a @p RTCAlarm structure
*
* @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->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 */
rtc_lld_wait_write();
#if !(RTC_SUPPORTS_CALLBACKS)
RTC->CRL &= ~RTC_CRL_ALRF;
RTC->CRH |= RTC_CRH_ALRIE;
#endif /* !(RTC_SUPPORTS_CALLBACKS) */
while(!(RTC->CRL & RTC_CRL_RTOFF)) /* wait for completion */
;
/* Enters configuration mode and writes ALRHx registers then leaves the
configuration mode.*/
RTC->CRL |= RTC_CRL_CNF;
if (alarmspec != NULL) {
RTC->ALRH = (uint16_t)(alarmspec->tv_sec >> 16);
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
* to change it on STM32F1xx platform.
*
* @note Default value after BKP domain reset is 0xFFFFFFFF
* @param[in] rtcp pointer to RTC driver structure
* @param[in] alarm alarm identifier
* @param[out] alarmspec pointer to a @p RTCAlarm structure
*
* @notapi
*/
inline void rtc_lld_get_alarm(RTCDateTime *timespec){
timespec->tv_sec = ((RTC->ALRH << 16) + RTC->ALRL);
void rtc_lld_get_alarm(RTCDriver *rtcp,
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 */

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

@ -35,17 +35,19 @@
/* 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. */
/*===========================================================================*/
/**
* @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. */
@ -55,46 +57,71 @@
#error "RTC not present in the selected device"
#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. */
/*===========================================================================*/
/**
* @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;
/**
* @brief Fractional part.
*/
uint32_t tv_msec;
}RTCDateTime;
};
/**
* @brief Structure representing an RTC alarm specification.
*/
struct RTCAlarm {
/**
* @brief Seconds since UNIX epoch.
*/
uint32_t tv_sec;
};
/**
* @brief Structure representing an RTC driver.
* @note This driver is dummy when callbacks disabled.
*/
struct RTCDriver{
#if RTC_SUPPORTS_CALLBACKS
/**
* @brief Overflow callback. Set it to NULL if not used.
* @brief Callback pointer.
*/
rtccb_t overflow_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 */
rtccb_t rtc_cb;
};
/*===========================================================================*/
@ -105,27 +132,29 @@ struct RTCDriver{
/* External declarations. */
/*===========================================================================*/
extern RTCDriver RTCD;
#if !defined(__DOXYGEN__)
extern RTCDriver RTCD1;
#endif
#ifdef __cplusplus
extern "C" {
#endif
void rtc_lld_init(void);
void rtc_lld_set_callback(RTCDriver *rtcp, rtccb_t overflow_cb,
rtccb_t second_cb, rtccb_t alarm_cb);
void rtc_lld_set_time(RTCDateTime *timespec);
void rtc_lld_get_time(RTCDateTime *timespec);
void rtc_lld_get_alarm(RTCDateTime *timespec);
void rtc_lld_set_alarm(RTCDateTime *timespec);
void rtc_lld_set_time(RTCDriver *rtcp, const RTCTime *timespec);
void rtc_lld_get_time(RTCDriver *rtcp, RTCTime *timespec);
void rtc_lld_set_alarm(RTCDriver *rtcp,
rtcalarm_t alarm,
const RTCAlarm *alarmspec);
void rtc_lld_get_alarm(RTCDriver *rtcp,
rtcalarm_t alarm,
RTCAlarm *alarmspec);
void rtc_lld_set_callback(RTCDriver *rtcp, rtccb_t callback);
#ifdef __cplusplus
}
#endif
#endif /* HAL_USE_RTC */
#endif /* _RTC_LLD_H_ */
/** @} */

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

@ -215,7 +215,7 @@
* @api
*/
#define rccEnableBKPInterface(lp) \
rccEnableAPB1((RCC_APB1ENR_BKPEN | RCC_APB1ENR_PWREN), lp);
rccEnableAPB1((RCC_APB1ENR_BKPEN | RCC_APB1ENR_PWREN), lp)
/**
* @brief Disables BKP interface clock.
@ -226,21 +226,21 @@
* @api
*/
#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.
*
* @api
*/
#define rccResetBKPInterface() rccResetAPB1(RCC_APB1ENR_BKPRST);
#define rccResetBKPInterface() rccResetAPB1(RCC_APB1ENR_BKPRST)
/**
* @brief Resets the entire Backup Domain.
*
* @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)
#error "STM32_LSECLK outside acceptable range (1...1000KHz)"
#endif
#else /* !#if STM32_LSE_ENABLED */
#else /* !STM32_LSE_ENABLED */
#if STM_RTCCLK == STM32_LSECLK
#error "required LSE clock is not enabled"
#endif
#endif /* !#if STM32_LSE_ENABLED */
#endif /* !STM32_LSE_ENABLED */
/* PLL related checks.*/
#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
* was previously reset.
* @brief RTC Driver initialization.
* @note This function is implicitly invoked by @p halInit(), there is
* no need to explicitly initialize the driver.
*
* @init
*/
void rtcInit(void) {
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.
*
* @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.
*
* @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");
rtc_lld_get_time(timespec);
chDbgCheck((rtcp != NULL) && (timespec != NULL), "rtcGetTime");
rtc_lld_get_time(rtcp, timespec);
}
#if (RTC_ALARMS > 0) || defined(__DOXYGEN__)
/**
* @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.
* @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 */
/** @} */

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.
# 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 = -O2 -ggdb -fomit-frame-pointer -falign-functions=16 -fno-strict-aliasing
#USE_OPT = -O3 -ggdb -fomit-frame-pointer -falign-functions=16
@ -87,7 +87,6 @@ CSRC = $(PORTSRC) \
$(CHIBIOS)/os/various/syscalls.c \
main.c \
# C++ sources that can be compiled in ARM or THUMB mode depending on the global
# setting.
CPPSRC =
@ -215,6 +214,3 @@ ifeq ($(USE_FWLIB),yes)
endif
include $(CHIBIOS)/os/ports/GCC/ARMCMx/rules.mk

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

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