max/timely-reference
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add a variety of automated tests

Browse Source
This commit is contained in:
Max Regan
2020-04-20 07:32:04 -07:00
parent cd121ffc19
commit e5057da888
13 changed files with 561 additions and 50 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
firmware/Bsp/Drivers/LowPower.cpp
View File

@@ -79,20 +79,20 @@ ReturnCode LowPower::stop()
SET(PWR->CR, PWR_CR_CWUF); // clear wakeup flag
while(PWR->CSR & PWR_CSR_WUF) {};
CLR(PWR->CR, PWR_CR_PDDS); // Enter stop mode when the CPU enters deepsleep
CLR(RCC->CFGR, RCC_CFGR_STOPWUCK); // MSI oscillator is wake-up from stop clock
SET(SCB->SCR, SCB_SCR_SLEEPDEEP_Msk); // low-power mode = stop mode
// Enter stop mode when the CPU enters deepsleep
CLR(PWR->CR, PWR_CR_PDDS);
#elif defined(STM32L4XX)
SET(PWR->SCR, PWR_SCR_CWUF1); // clear wakeup flag
while(PWR->SR1 & PWR_SR1_WUF1) {};
SET_TO(PWR->CR1, PWR_CR1_LPMS, 1 << PWR_CR1_LPMS_Pos); // Enter stop mode 1 when the CPU enters deepsleep
CLR(RCC->CFGR, RCC_CFGR_STOPWUCK); // MSI oscillator is wake-up from stop clock
SET(SCB->SCR, SCB_SCR_SLEEPDEEP_Msk); // low-power mode = stop mode
// Enter stop mode 1 when the CPU enters deepsleep
SET_TO(PWR->CR1, PWR_CR1_LPMS, 1 << PWR_CR1_LPMS_Pos);
#else
#error "Unsupported device type"
#endif
CLR(RCC->CFGR, RCC_CFGR_STOPWUCK); // MSI oscillator is wake-up from stop clock
SET(SCB->SCR, SCB_SCR_SLEEPDEEP_Msk); // low-power mode = stop mode
__WFI(); // enter low-power mode (Wake from interrupt)
wakeups++;

85
firmware/Bsp/Drivers/RtcDriver.cpp
View File

@@ -290,27 +290,21 @@ ReturnCode RtcDriver::set_wakeup_in(BSP::time_t wakeup_delay)
if (delay_cycles == 0) {
return ReturnCode::FAIL;
} else if (delay_cycles < 0x10000) {
} else if (delay_cycles < 0x20000) {
delay_cycles /= 2;
wucksel = 3;
} else if (delay_cycles <= 0x20000) {
} else if (delay_cycles <= 0x40000) {
delay_cycles /= 4;
wucksel = 2;
} else if (delay_cycles <= 0x40000) {
} else if (delay_cycles <= 0x80000) {
delay_cycles /= 8;
wucksel = 1;
} else if (delay_cycles <= 0x80000) {
} else if (delay_cycles <= 0x100000) {
delay_cycles /= 16;
wucksel = 0;
} else {
#if 0
// TODO: implement longer delays using ck_spre as clock source
// TODO: the datasheet text and block diagram disagree- is it using clock_spre or clock_apre?
wucksel = 4;
delay_cycles >>= async_prediv; //
#else
return ReturnCode::FAIL;
#endif
delay_cycles /= 32768;
}
SET_TO(RTC->WUTR, RTC_WUTR_WUT, delay_cycles - 1);
@@ -327,6 +321,9 @@ BSP::time_t RtcDriver::RtcSystemTimer::get_time()
{
uint32_t new_secs, old_secs, ssr;
uint64_t new_timer_ticks, new_millis;
while (!(RTC->ICSR & RTC_ICSR_WUTWF)) {}
do {
__disable_irq();
old_secs = m_seconds;
@@ -343,9 +340,7 @@ BSP::time_t RtcDriver::RtcSystemTimer::get_time()
void RtcDriver::RtcSystemTimer::increment_seconds()
{
__disable_irq();
m_seconds++;
__enable_irq();
}
void RtcDriver::increment_seconds()
@@ -353,7 +348,26 @@ void RtcDriver::increment_seconds()
m_sys_timer.increment_seconds();
}
static uint32_t wakeup_alarms = 0;
uint32_t RtcDriver::m_wakeup_count = 0;
uint32_t RtcDriver::m_alarm_count = 0;
void RtcDriver::increment_wakeup_count()
{
m_wakeup_count++;
}
void RtcDriver::increment_alarm_count()
{
m_alarm_count++;
}
uint32_t RtcDriver::get_wakeup_count() {
return m_wakeup_count;
}
uint32_t RtcDriver::get_alarm_count() {
return m_alarm_count;
}
#if defined(STM32L0XX)
extern "C" void RTC_IRQHandler()
@@ -363,11 +377,12 @@ extern "C" void RTC_IRQHandler()
if (RTC->ISR & RTC_ISR_ALRAF) {
RtcDriver::increment_seconds();
RtcDriver::increment_alarm_count();
CLR(RTC->ISR, RTC_ISR_ALRAF);
}
if (RTC->ISR & RTC_ISR_WUTF) {
wakeup_alarms++;
RtcDriver::increment_wakeup_count();
// Clear the interrupt in the RTC
CLR(RTC->ISR, RTC_ISR_WUTF);
// Disable the Wakeup timer (its periodic, but we use it as a
@@ -375,29 +390,41 @@ extern "C" void RTC_IRQHandler()
CLR(RTC->CR, RTC_CR_WUTE);
}
}
}
#elif defined(STM32L4XX)
extern "C" void RTC_WKUP_IRQHandler()
{
static void irq_handler() {
SET(EXTI->PR1, EXTI_PR1_PIF20);
wakeup_alarms++;
// Clear the interrupt in the RTC
SET(RTC->SCR, RTC_SCR_CWUTF);
// Disable the Wakeup timer (its periodic, but we use it as a
// one-shot timer
CLR(RTC->CR, RTC_CR_WUTE);
if (RTC->SR & RTC_SR_WUTF) {
RtcDriver::increment_wakeup_count();
// Clear the interrupt in the RTC
SET(RTC->SCR, RTC_SCR_CWUTF);
// Disable the Wakeup timer (its periodic, but we use it as a
// one-shot timer
CLR(RTC->CR, RTC_CR_WUTE);
}
if (RTC->SR & RTC_SR_ALRAF) {
SET(EXTI->PR1, EXTI_PR1_PIF18);
RtcDriver::increment_alarm_count();
RtcDriver::increment_seconds();
SET(RTC->SCR, RTC_SCR_CALRAF);
}
}
extern "C" void RTC_WKUP_IRQHandler()
{
irq_handler();
}
extern "C" void RTC_ALARM_IRQHandler()
{
SET(EXTI->PR1, EXTI_PR1_PIF18);
RtcDriver::increment_seconds();
SET(RTC->SCR, RTC_SCR_CALRAF);
}
irq_handler();
}
#else
#error "Unsupported device type"
#endif
}

9
firmware/Bsp/Drivers/RtcDriver.h
View File

@@ -45,6 +45,12 @@ public:
static BSP::ReturnCode get_time(BSP::WallClockTime &tm_bcd);
static BSP::ReturnCode set_time(const BSP::WallClockTime &tm_bcd);
static BSP::ReturnCode set_wakeup_in(BSP::time_t wakeup_delay);
static uint32_t get_wakeup_count();
static uint32_t get_alarm_count();
static void increment_seconds_count();
static void increment_wakeup_count();
static void increment_alarm_count();
private:
@@ -55,7 +61,6 @@ private:
static void enable_periodic_alarm();
static constexpr uint32_t LSE_CLOCK_FREQ = 32768;
static RTC_TypeDef *m_rtc;
class RtcSystemTimer : public BSP::SystemTimerImpl {
@@ -77,6 +82,8 @@ private:
static constexpr uint32_t LSE_CLOCK_FREQ = 32768;
};
static uint32_t m_wakeup_count;
static uint32_t m_alarm_count;
static RtcSystemTimer m_sys_timer;
};