Add a variety of automated tests

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
+    // Enter stop mode when the CPU enters deepsleep
-    CLR(RCC->CFGR, RCC_CFGR_STOPWUCK); // MSI oscillator is wake-up from stop clock
+    CLR(PWR->CR, PWR_CR_PDDS);
-    SET(SCB->SCR, SCB_SCR_SLEEPDEEP_Msk); // low-power mode = stop mode
 #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++;

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; //
+        delay_cycles /= 32768;
-#else
-        return ReturnCode::FAIL;
-#endif
     }
 
     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++;
+    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);
+    irq_handler();
-    RtcDriver::increment_seconds();
-    SET(RTC->SCR, RTC_SCR_CALRAF);
-}
-
 }
 #else
 #error "Unsupported device type"
 #endif
+
+}

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;
 };
 

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))

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();
+}

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();
+}

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();
+}

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();
+}

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();
+}

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";

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)

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();
+}

test/src/tr_test/test.py

@@ -28,6 +28,7 @@ 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/")
@@ -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",
+                       mcu: str = "STM32L412RB",
-                       addr: int=0x8000000,
+                       addr: int = 0x8000000,
-                       leave_halted: bool=False):
+                       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):
+def test_meta_pass(context_factory, logger):
-    serial_dev, jlink = context_factory("Test/basic.bin")
+    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()