diff --git a/firmware/Bsp/Drivers/LowPower.cpp b/firmware/Bsp/Drivers/LowPower.cpp index e01933b..8a2e5d0 100644 --- a/firmware/Bsp/Drivers/LowPower.cpp +++ b/firmware/Bsp/Drivers/LowPower.cpp @@ -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++; diff --git a/firmware/Bsp/Drivers/RtcDriver.cpp b/firmware/Bsp/Drivers/RtcDriver.cpp index 18ffb10..43986d3 100644 --- a/firmware/Bsp/Drivers/RtcDriver.cpp +++ b/firmware/Bsp/Drivers/RtcDriver.cpp @@ -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 + +} diff --git a/firmware/Bsp/Drivers/RtcDriver.h b/firmware/Bsp/Drivers/RtcDriver.h index 4714e1f..9ffead4 100644 --- a/firmware/Bsp/Drivers/RtcDriver.h +++ b/firmware/Bsp/Drivers/RtcDriver.h @@ -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; }; diff --git a/firmware/Makefile b/firmware/Makefile index 9ea6657..7122f41 100644 --- a/firmware/Makefile +++ b/firmware/Makefile @@ -83,7 +83,7 @@ S_SOURCES := $(call find_important, $(SOURCEDIR), '*.s') SPP_SOURCES := Bsp/Mcu/$(DEVICE_TYPE).S SOURCES = $(C_SOURCES) $(S_SOURCES) $(SPP_SOURCES) $(CPP_SOURCES) -APPS := ./Application/main ./Test/basic ./Test/clock +APPS := ./Application/main ./Test/pass ./Test/fail ./Test/timeout ./Test/clock ./Test/stop ./Test/no_start APP_ELFS = $(addsuffix .elf, $(APPS)) APP_MAPS = $(addsuffix .map, $(APPS)) APP_BINS = $(addsuffix .bin, $(APPS)) diff --git a/firmware/Test/clock.cpp b/firmware/Test/clock.cpp new file mode 100644 index 0000000..1d7f549 --- /dev/null +++ b/firmware/Test/clock.cpp @@ -0,0 +1,82 @@ +/* + * Copyright (C) 2020 Max Regan + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#include "printf.h" + +#include "Bsp/Drivers/GpioDriver.h" +#include "Bsp/Drivers/RtcDriver.h" +#include "Bsp/Drivers/UsartDriver.h" +#include "Bsp/LowPowerTaskScheduler.h" +#include "Bsp/macros.h" + +#include "test.h" + +#include "Mcu.h" + +using BSP::Time; +using BSP::ReturnCode; +using BSP::SystemTimer; + +static BSP::Schedule::LowPowerTaskScheduler<1> g_sched; +static BSP::UsartDriver g_test_uart(USART1, g_sched); +static BSP::GpioDriver g_gpioa(GPIOA); +static BSP::GpioPin g_test_pin(g_gpioa, 6); + +[[noreturn]] void main() { + + g_gpioa.enable(); + g_test_pin.configure_alternate_function(1); + g_test_uart.init(); + + g_test_uart.tx_blocking(test_start_text); + + BSP::RtcDriver::init(); + SystemTimer::set_timer(BSP::RtcDriver::get_system_timer()); + BSP::LowPower::init(); + + BSP::time_t now; + + ReturnCode rc = SystemTimer::get_time(now); + if (rc != ReturnCode::OK) { + g_test_uart.tx_blocking("Failed while getting initial time\r\n"); + g_test_uart.tx_blocking(test_fail_text); + TEST_SPIN(); + } + + BSP::time_t end = now + Time::seconds(10); + g_test_uart.tx_blocking("GO\r\n"); + char buffer[40] = { 0 }; + while (now < end) { + snprintf(buffer, sizeof(buffer), "%lld\r\n", BSP::Time::to_micros(now)); + g_test_uart.tx_blocking(buffer); + rc = SystemTimer::get_time(now); + if (rc != ReturnCode::OK) { + g_test_uart.tx_blocking("Failed while waiting for time to pass\r\n"); + g_test_uart.tx_blocking(test_fail_text); + TEST_SPIN(); + } + } + + g_test_uart.tx_blocking("STOP\r\n"); + g_test_uart.tx_blocking(test_pass_text); + + TEST_SPIN(); +} diff --git a/firmware/Test/fail.cpp b/firmware/Test/fail.cpp new file mode 100644 index 0000000..a751d25 --- /dev/null +++ b/firmware/Test/fail.cpp @@ -0,0 +1,50 @@ +/* + * Copyright (C) 2020 Max Regan + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#include "printf.h" + +#include "Bsp/LowPowerTaskScheduler.h" +#include "Bsp/Drivers/GpioDriver.h" +#include "Bsp/Drivers/UsartDriver.h" +#include "Bsp/macros.h" + +#include "test.h" + +#include "Mcu.h" + +using BSP::Time; + +static BSP::Schedule::LowPowerTaskScheduler<1> g_sched; +static BSP::UsartDriver g_test_uart(USART1, g_sched); +static BSP::GpioDriver g_gpioa(GPIOA); +static BSP::GpioPin g_test_pin(g_gpioa, 6); + +[[noreturn]] void main() { + + g_gpioa.enable(); + g_test_pin.configure_alternate_function(1); + g_test_uart.init(); + + g_test_uart.tx_blocking(test_start_text); + g_test_uart.tx_blocking("Causing test failure...\r\n"); + g_test_uart.tx_blocking(test_fail_text); + TEST_SPIN(); +} diff --git a/firmware/Test/no_start.cpp b/firmware/Test/no_start.cpp new file mode 100644 index 0000000..b028072 --- /dev/null +++ b/firmware/Test/no_start.cpp @@ -0,0 +1,26 @@ +/* + * Copyright (C) 2020 Max Regan + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#include "test.h" + +[[noreturn]] void main() { + TEST_SPIN(); +} diff --git a/firmware/Test/pass.cpp b/firmware/Test/pass.cpp new file mode 100644 index 0000000..4545796 --- /dev/null +++ b/firmware/Test/pass.cpp @@ -0,0 +1,51 @@ +/* + * Copyright (C) 2020 Max Regan + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#include "printf.h" + +#include "Bsp/LowPowerTaskScheduler.h" +#include "Bsp/Drivers/GpioDriver.h" +#include "Bsp/Drivers/UsartDriver.h" +#include "Bsp/macros.h" + +#include "test.h" + +#include "Mcu.h" + +using BSP::Time; + +static BSP::Schedule::LowPowerTaskScheduler<1> g_sched; +static BSP::UsartDriver g_test_uart(USART1, g_sched); +static BSP::GpioDriver g_gpioa(GPIOA); +static BSP::GpioPin g_test_pin(g_gpioa, 6); + +[[noreturn]] void main() { + + g_gpioa.enable(); + g_test_pin.configure_alternate_function(1); + g_test_uart.init(); + + g_test_uart.tx_blocking(test_start_text); + g_test_uart.tx_blocking("Test is executing...\r\n"); + g_test_uart.tx_blocking(test_pass_text); + + TEST_SPIN(); +} diff --git a/firmware/Test/stop.cpp b/firmware/Test/stop.cpp new file mode 100644 index 0000000..8c7b482 --- /dev/null +++ b/firmware/Test/stop.cpp @@ -0,0 +1,109 @@ +/* + * Copyright (C) 2020 Max Regan + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#include "printf.h" + +#include "Bsp/Drivers/GpioDriver.h" +#include "Bsp/Drivers/RtcDriver.h" +#include "Bsp/Drivers/UsartDriver.h" +#include "Bsp/Drivers/LowPower.h" +#include "Bsp/LowPowerTaskScheduler.h" +#include "Bsp/macros.h" + +#include "test.h" + +#include "Mcu.h" + +using BSP::Time; +using BSP::ReturnCode; +using BSP::SystemTimer; +using BSP::time_t; + +static BSP::Schedule::LowPowerTaskScheduler<1> g_sched; +static BSP::UsartDriver g_test_uart(USART1, g_sched); +static BSP::GpioDriver g_gpioa(GPIOA); +static BSP::GpioPin g_test_pin(g_gpioa, 6); + +static time_t get_time() { + time_t time; + ReturnCode rc = SystemTimer::get_time(time); + if (rc != ReturnCode::OK) { + g_test_uart.tx_blocking("Failed while getting the time\r\n"); + g_test_uart.tx_blocking(test_fail_text); + TEST_SPIN(); + } + return time; +} + +static void stop_for(time_t delay) { + + ReturnCode rc = BSP::RtcDriver::set_wakeup_in(delay); + if (rc != ReturnCode::OK) { + g_test_uart.tx_blocking("Failed to set wakeup delay\r\n"); + g_test_uart.tx_blocking(test_fail_text); + TEST_SPIN(); + } + + + uint32_t pre_wakeups = BSP::RtcDriver::get_wakeup_count(); + uint32_t pre_alarms = BSP::RtcDriver::get_alarm_count(); + time_t before = get_time(); + + BSP::LowPower::stop(); + + time_t after = get_time(); + uint32_t post_wakeups = BSP::RtcDriver::get_wakeup_count(); + uint32_t post_alarms = BSP::RtcDriver::get_alarm_count(); + + static char buffer[128]; + snprintf(buffer, sizeof(buffer), + "Requested=%lld Actual=%lld Wakeups=%d Alarms=%d\r\n", + Time::to_millis(delay), + Time::to_millis(after - before), + post_wakeups - pre_wakeups, + post_alarms - pre_alarms); + + g_test_uart.tx_blocking(buffer); +} + +[[noreturn]] void main() { + + BSP::RtcDriver::init(); + SystemTimer::set_timer(BSP::RtcDriver::get_system_timer()); + BSP::LowPower::init(); + + g_gpioa.enable(); + g_test_pin.configure_alternate_function(1); + g_test_uart.init(); + + g_test_uart.tx_blocking(test_start_text); + + for (uint32_t delay_millis = 1; delay_millis <= 1024; delay_millis *= 2) { + stop_for(Time::millis(delay_millis)); + } + + stop_for(Time::seconds(10)); + stop_for(Time::seconds(60)); + + g_test_uart.tx_blocking(test_pass_text); + + TEST_SPIN(); +} diff --git a/firmware/Test/test.cpp b/firmware/Test/test.cpp new file mode 100644 index 0000000..288b96a --- /dev/null +++ b/firmware/Test/test.cpp @@ -0,0 +1,26 @@ +/* + * Copyright (C) 2020 Max Regan + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#include "test.h" + +const char *test_start_text = "TEST_BEGIN\r\n"; +const char *test_fail_text = "TEST_FAIL\r\n"; +const char *test_pass_text = "TEST_PASS\r\n"; diff --git a/firmware/Test/test.h b/firmware/Test/test.h new file mode 100644 index 0000000..0ab6072 --- /dev/null +++ b/firmware/Test/test.h @@ -0,0 +1,28 @@ +/* + * Copyright (C) 2020 Max Regan + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#pragma once + +extern const char *test_start_text; +extern const char *test_fail_text; +extern const char *test_pass_text; + +#define TEST_SPIN() do {} while (1) diff --git a/firmware/Test/timeout.cpp b/firmware/Test/timeout.cpp new file mode 100644 index 0000000..00aecc5 --- /dev/null +++ b/firmware/Test/timeout.cpp @@ -0,0 +1,49 @@ +/* + * Copyright (C) 2020 Max Regan + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#include "printf.h" + +#include "Bsp/LowPowerTaskScheduler.h" +#include "Bsp/Drivers/GpioDriver.h" +#include "Bsp/Drivers/UsartDriver.h" +#include "Bsp/macros.h" + +#include "test.h" + +#include "Mcu.h" + +using BSP::Time; + +static BSP::Schedule::LowPowerTaskScheduler<1> g_sched; +static BSP::UsartDriver g_test_uart(USART1, g_sched); +static BSP::GpioDriver g_gpioa(GPIOA); +static BSP::GpioPin g_test_pin(g_gpioa, 6); + +[[noreturn]] void main() { + + g_gpioa.enable(); + g_test_pin.configure_alternate_function(1); + g_test_uart.init(); + + g_test_uart.tx_blocking(test_start_text); + g_test_uart.tx_blocking("Causing test timeout...\r\n"); + TEST_SPIN(); +} diff --git a/test/src/tr_test/test.py b/test/src/tr_test/test.py index 063c967..e0d967a 100755 --- a/test/src/tr_test/test.py +++ b/test/src/tr_test/test.py @@ -28,9 +28,10 @@ import pylink import time import os import sys +import re PYTEST_DIR = os.path.dirname(os.path.abspath(__file__)) -DEFAULT_FW_DIR = os.path.abspath(PYTEST_DIR + "../../../../firmware/") +DEFAULT_FW_DIR = os.path.abspath(PYTEST_DIR + "../../../../firmware/") SAMPLE_TIME_MS = 2500 SAMPLES_PER_SEC = 12000000 DRIVER = "fx2lafw" @@ -39,18 +40,20 @@ TEST_START_TEXT = b"TEST_BEGIN\r\n" TEST_PASS_TEXT = b"TEST_PASS\r\n" TEST_FAIL_TEXT = b"TEST_FAIL\r\n" + @pytest.fixture def logger(): logging.basicConfig() return logging.getLogger(__name__) + @pytest.fixture def context_factory(): def create_context(fw_rel_path: str, - mcu: str="STM32L412RB", - addr: int=0x8000000, - leave_halted: bool=False): + mcu: str = "STM32L412RB", + addr: int = 0x8000000, + leave_halted: bool = False): proc = subprocess.run(["make", "BOARD=devboard", fw_rel_path], cwd=DEFAULT_FW_DIR, @@ -72,7 +75,6 @@ def context_factory(): jlink.disable_dialog_boxes() jlink.set_tif(pylink.enums.JLinkInterfaces.SWD) jlink.connect(mcu) - #jlink.set_reset_strategy(pylink.enums.JLinkResetStrategyCortexM3.HALT_AFTER_BTL) fw = DEFAULT_FW_DIR + "/" + fw_rel_path logging.info("Flashing {}...".format(fw)) jlink.flash_file(fw, addr) @@ -80,7 +82,9 @@ def context_factory(): assert jlink.halted() jlink.reset(halt=True) - serial_dev = serial.Serial(port=ports[0].device, baudrate=115200, timeout=1) + serial_dev = serial.Serial(port=ports[0].device, + baudrate=115200, + timeout=1) if leave_halted: return serial_dev, jlink @@ -89,7 +93,9 @@ def context_factory(): while True: try: logging.info("Waiting for firmware to start...") - assert serial_dev.read_until(TEST_START_TEXT).endswith(TEST_START_TEXT), \ + assert serial_dev \ + .read_until(TEST_START_TEXT) \ + .endswith(TEST_START_TEXT), \ "Timed out starting test firmware application" logging.debug("Test execution started") except serial.serialutil.SerialException: @@ -99,20 +105,43 @@ def context_factory(): return create_context -def test_basic(context_factory, logger): - serial_dev, jlink = context_factory("Test/basic.bin") +def test_meta_pass(context_factory, logger): + serial_dev, jlink = context_factory("Test/pass.bin") text = serial_dev.read_until(TEST_PASS_TEXT) print("Got serial output: {}".format(text)) assert text.endswith(TEST_PASS_TEXT) +def test_meta_fail(context_factory, logger): + serial_dev, jlink = context_factory("Test/fail.bin") + text = serial_dev.read_until(TEST_PASS_TEXT) + print("Got serial output: {}".format(text)) + assert not text.endswith(TEST_PASS_TEXT) + + +def test_meta_timeout(context_factory, logger): + serial_dev, jlink = context_factory("Test/timeout.bin") + text = serial_dev.read_until(TEST_PASS_TEXT) + assert not text.endswith(TEST_PASS_TEXT) + + +def test_meta_nostart(context_factory, logger): + with pytest.raises(AssertionError): + serial_dev, jlink = context_factory("Test/no_start.bin") + + def test_watch(context_factory, logger): - serial_dev, jlink = context_factory("Application/main.bin", leave_halted=True) + serial_dev, jlink = context_factory("Application/main.bin", + leave_halted=True) jlink.reset(halt=False) + def test_clock(context_factory, logger): serial_dev, jlink = context_factory("Test/clock.bin") - serial_dev.timeout = 1.5 + EXPECTED_RUNTIME = 10 + TOLERANCE = .1 + + serial_dev.timeout = EXPECTED_RUNTIME * 1.2 START_MARKER = b"GO\r\n" END_MARKER = b"STOP\r\n" @@ -133,10 +162,37 @@ def test_clock(context_factory, logger): # accurate. Add support via sigrok. assert start_text.endswith(START_MARKER) assert end_text.endswith(END_MARKER) - assert delta < 1.1 and delta > .9 + assert (delta - EXPECTED_RUNTIME) < TOLERANCE + + +def test_stop(context_factory, logger): + serial_dev, jlink = context_factory("Test/stop.bin") + serial_dev.timeout = 65 + + pattern = re.compile("Requested=(\\d*) Actual=(\\d*)") + while True: + line = serial_dev.readline() + if line == TEST_PASS_TEXT: + break + + line = line.decode("ascii", errors="ignore") + print(line.strip()) + match = pattern.match(line) + assert match + req = int(match.group(1)) + actual = int(match.group(2)) + delta = req - actual + + if req < 32000: + assert abs(delta < req * (2.0 / 100.0)) or (delta <= 1) + else: + # Delays > 32sec have reduced resolution (1 sec) + assert abs(delta) < 1000 + def main(): pytest.main(sys.argv) + if __name__ == "__main__": main()