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

69
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,14 +390,15 @@ 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
@@ -390,14 +406,25 @@ extern "C" void RTC_WKUP_IRQHandler()
CLR(RTC->CR, RTC_CR_WUTE);
}
extern "C" void RTC_ALARM_IRQHandler()
{
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()
{
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;
};

2
firmware/Makefile
View File

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

82
firmware/Test/clock.cpp Normal file
View File

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

50
firmware/Test/fail.cpp Normal file
View File

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

26
firmware/Test/no_start.cpp Normal file
View File

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

51
firmware/Test/pass.cpp Normal file
View File

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

109
firmware/Test/stop.cpp Normal file
View File

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

26
firmware/Test/test.cpp Normal file
View File

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

28
firmware/Test/test.h Normal file
View File

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

49
firmware/Test/timeout.cpp Normal file
View File

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

72
test/src/tr_test/test.py
View File

@@ -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,11 +40,13 @@ 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():
@@ -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()