Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

NRF_51_DK - adapt lp/us ticker drivers to the new standards #5629

Merged
merged 9 commits into from Apr 27, 2018
Merged

NRF_51_DK - adapt lp/us ticker drivers to the new standards #5629

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
9 commits
Select commit Hold shift + click to select a range
aee099c
NRF5 - make us ticker to be driven by high speed 1MHz timer
mprse Nov 30, 2017
d700144
Enable us/lp ticker support for NRF51_DK board
mprse Jan 18, 2018
bab5e60
Update lp ticker to be consistent with the new standards.
mprse Jan 19, 2018
098a30a
tests-mbed_drivers-timerevent: perform test only if USTICKER support …
mprse Mar 6, 2018
21058a4
tests-mbed_hal-lp_ticker: run sleep test only if SLEEP support is en…
mprse Mar 6, 2018
6c6e36f
tests-mbed_drivers-lp_ticker: Adapt tolerance for new Ticker driver
mprse Mar 9, 2018
467f6e2
tests-mbed_drivers-timer: Adapt tolerance for new Ticker driver
mprse Mar 9, 2018
b832022
Rename DEVICE_LOWPOWERTIMER to DEVICE_LPTICKER.
mprse Mar 28, 2018
de4bcba
tests-mbed_hal-common_tickers: increase overflow protection limit
mprse Apr 23, 2018
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Jump to
Jump to file
Failed to load files.
Diff view
Diff view
11 changes: 6 additions & 5 deletions TESTS/mbed_drivers/lp_ticker/main.cpp
View file
Open in desktop
Expand Up @@ -33,8 +33,9 @@ static const int test_timeout = 10;
/* Due to poor accuracy of LowPowerTicker on many platforms
there is no sense to tune tolerance value as it was in Ticker tests.

Tolerance value is set to 2000us to cover this diversity */
#define TOLERANCE_US 2000
Tolerance value is set to 500us for measurement inaccuracy + 5% tolerance
for LowPowerTicker. */
#define TOLERANCE_US(DELAY) (500 + DELAY / 20)


volatile uint32_t ticker_callback_flag;
Expand Down Expand Up @@ -117,7 +118,7 @@ void test_multi_call_time(void)
while(!ticker_callback_flag);
time_diff = gtimer.read_us();

TEST_ASSERT_UINT32_WITHIN(TOLERANCE_US, MULTI_TICKER_TIME_MS * 1000, time_diff);
TEST_ASSERT_UINT32_WITHIN(TOLERANCE_US(MULTI_TICKER_TIME_MS * 1000), MULTI_TICKER_TIME_MS * 1000, time_diff);
}
}

Expand Down Expand Up @@ -167,7 +168,7 @@ void test_attach_time(void)
ticker.detach();
const int time_diff = gtimer.read_us();

TEST_ASSERT_UINT64_WITHIN(TOLERANCE_US, DELAY_US, time_diff);
TEST_ASSERT_UINT64_WITHIN(TOLERANCE_US(DELAY_US), DELAY_US, time_diff);
}

/** Test single callback time via attach_us
Expand All @@ -189,7 +190,7 @@ void test_attach_us_time(void)
ticker.detach();
const int time_diff = gtimer.read_us();

TEST_ASSERT_UINT64_WITHIN(TOLERANCE_US, DELAY_US, time_diff);
TEST_ASSERT_UINT64_WITHIN(TOLERANCE_US(DELAY_US), DELAY_US, time_diff);
}

// Test cases
Expand Down
115 changes: 52 additions & 63 deletions TESTS/mbed_drivers/timer/main.cpp
View file
Open in desktop
Expand Up @@ -30,35 +30,24 @@ using namespace utest::v1;

extern uint32_t SystemCoreClock;

/* Macro to define delta based on CPU clock frequency.
*
* Note that some extra time is counted by the timer.
* Additional time is caused by the function calls and
* additional operations performed by wait and
* stop functions before in fact timer is stopped. This may
* add additional time to the counted result.
*
* To take in to account this extra time we introduce DELTA
* value based on CPU clock (speed):
* DELTA = TOLERANCE_FACTOR / SystemCoreClock * US_FACTOR
*
* e.g.
* For K64F DELTA = (30000 / 120000000) * 1000000 = 250[us]
* For NUCLEO_F070RB DELTA = (30000 / 48000000) * 1000000 = 625[us]
* For NRF51_DK DELTA = (30000 / 16000000) * 1000000 = 1875[us]
*/
#define US_PER_SEC 1000000
#define US_PER_MSEC 1000
#define TOLERANCE_FACTOR 30000.0f
#define US_FACTOR 1000000.0f
#define MSEC_PER_SEC 1000

static const int delta_sys_clk_us = ((int) (TOLERANCE_FACTOR / (float)SystemCoreClock * US_FACTOR));

/* When test performs time measurement using Timer in sequence, then measurement error accumulates
* in the successive attempts. */
#define DELTA_US(i) (delta_sys_clk_us * i)
#define DELTA_S(i) ((float)delta_sys_clk_us * i / US_PER_SEC)
#define DELTA_MS(i) (1 + ( (i * delta_sys_clk_us) / US_PER_MSEC))
/*
* Define tolerance as follows:
* tolerance = 500 us + 2% of measured time
*
* e.g.
* 1 ms delay: tolerance = 520 us
* 10 ms delay: tolerance = 700 us
* 100 ms delay: tolerance = 2500 us
* 1000 ms delay: tolerance = 20500 us
*
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This new way of defining tolerance seems like a pretty big change from the previous model, will have to check with the relevant people in the team

* */
#define DELTA_US(delay_ms) (500 + delay_ms * US_PER_MSEC / 50)
#define DELTA_MS(delay_ms) (1 + (delay_ms * US_PER_MSEC / 50 / US_PER_MSEC))
#define DELTA_S(delay_ms) (0.000500f + (((float)delay_ms) / MSEC_PER_SEC / 50))

#define TICKER_FREQ_1MHZ 1000000
#define TICKER_BITS 32
Expand Down Expand Up @@ -417,10 +406,10 @@ void test_timer_time_accumulation_os_ticker()
p_timer->stop();

/* Check results - totally 10 ms have elapsed. */
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(1), 0.010f, p_timer->read());
TEST_ASSERT_INT32_WITHIN(DELTA_MS(1), 10, p_timer->read_ms());
TEST_ASSERT_INT32_WITHIN(DELTA_US(1), 10000, p_timer->read_us());
TEST_ASSERT_UINT64_WITHIN(DELTA_US(1), 10000, p_timer->read_high_resolution_us());
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(10), 0.010f, p_timer->read());
TEST_ASSERT_INT32_WITHIN(DELTA_MS(10), 10, p_timer->read_ms());
TEST_ASSERT_INT32_WITHIN(DELTA_US(10), 10000, p_timer->read_us());
TEST_ASSERT_UINT64_WITHIN(DELTA_US(10), 10000, p_timer->read_high_resolution_us());

/* Wait 50 ms - this is done to show that time elapsed when
* the timer is stopped does not have influence on the
Expand All @@ -439,10 +428,10 @@ void test_timer_time_accumulation_os_ticker()
p_timer->stop();

/* Check results - totally 30 ms have elapsed. */
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(2), 0.030f, p_timer->read());
TEST_ASSERT_INT32_WITHIN(DELTA_MS(2), 30, p_timer->read_ms());
TEST_ASSERT_INT32_WITHIN(DELTA_US(2), 30000, p_timer->read_us());
TEST_ASSERT_UINT64_WITHIN(DELTA_US(2), 30000, p_timer->read_high_resolution_us());
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(30), 0.030f, p_timer->read());
TEST_ASSERT_INT32_WITHIN(DELTA_MS(30), 30, p_timer->read_ms());
TEST_ASSERT_INT32_WITHIN(DELTA_US(30), 30000, p_timer->read_us());
TEST_ASSERT_UINT64_WITHIN(DELTA_US(30), 30000, p_timer->read_high_resolution_us());

/* Wait 50 ms - this is done to show that time elapsed when
* the timer is stopped does not have influence on the
Expand All @@ -460,10 +449,10 @@ void test_timer_time_accumulation_os_ticker()
p_timer->stop();

/* Check results - totally 60 ms have elapsed. */
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(3), 0.060f, p_timer->read());
TEST_ASSERT_INT32_WITHIN(DELTA_MS(3), 60, p_timer->read_ms());
TEST_ASSERT_INT32_WITHIN(DELTA_US(3), 60000, p_timer->read_us());
TEST_ASSERT_UINT64_WITHIN(DELTA_US(3), 60000, p_timer->read_high_resolution_us());
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(60), 0.060f, p_timer->read());
TEST_ASSERT_INT32_WITHIN(DELTA_MS(60), 60, p_timer->read_ms());
TEST_ASSERT_INT32_WITHIN(DELTA_US(60), 60000, p_timer->read_us());
TEST_ASSERT_UINT64_WITHIN(DELTA_US(60), 60000, p_timer->read_high_resolution_us());

/* Wait 50 ms - this is done to show that time elapsed when
* the timer is stopped does not have influence on the
Expand All @@ -482,10 +471,10 @@ void test_timer_time_accumulation_os_ticker()
p_timer->stop();

/* Check results - totally 1060 ms have elapsed. */
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(4), 1.060f, p_timer->read());
TEST_ASSERT_INT32_WITHIN(DELTA_MS(4), 1060, p_timer->read_ms());
TEST_ASSERT_INT32_WITHIN(DELTA_US(4), 1060000, p_timer->read_us());
TEST_ASSERT_UINT64_WITHIN(DELTA_US(4), 1060000, p_timer->read_high_resolution_us());
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(1060), 1.060f, p_timer->read());
TEST_ASSERT_INT32_WITHIN(DELTA_MS(1060), 1060, p_timer->read_ms());
TEST_ASSERT_INT32_WITHIN(DELTA_US(1060), 1060000, p_timer->read_us());
TEST_ASSERT_UINT64_WITHIN(DELTA_US(1060), 1060000, p_timer->read_high_resolution_us());
}

/* This test verifies if reset() function resets the timer
Expand All @@ -511,10 +500,10 @@ void test_timer_reset_os_ticker()
p_timer->stop();

/* Check results - totally 10 ms elapsed. */
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(1), 0.010f, p_timer->read());
TEST_ASSERT_INT32_WITHIN(DELTA_MS(1), 10, p_timer->read_ms());
TEST_ASSERT_INT32_WITHIN(DELTA_US(1), 10000, p_timer->read_us());
TEST_ASSERT_UINT64_WITHIN(DELTA_US(1), 10000, p_timer->read_high_resolution_us());
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(10), 0.010f, p_timer->read());
TEST_ASSERT_INT32_WITHIN(DELTA_MS(10), 10, p_timer->read_ms());
TEST_ASSERT_INT32_WITHIN(DELTA_US(10), 10000, p_timer->read_us());
TEST_ASSERT_UINT64_WITHIN(DELTA_US(10), 10000, p_timer->read_high_resolution_us());

/* Reset the timer - previous measured time should be lost now. */
p_timer->reset();
Expand All @@ -529,10 +518,10 @@ void test_timer_reset_os_ticker()
p_timer->stop();

/* Check results - 20 ms elapsed since the reset. */
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(1), 0.020f, p_timer->read());
TEST_ASSERT_INT32_WITHIN(DELTA_MS(1), 20, p_timer->read_ms());
TEST_ASSERT_INT32_WITHIN(DELTA_US(1), 20000, p_timer->read_us());
TEST_ASSERT_UINT64_WITHIN(DELTA_US(1), 20000, p_timer->read_high_resolution_us());
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(20), 0.020f, p_timer->read());
TEST_ASSERT_INT32_WITHIN(DELTA_MS(20), 20, p_timer->read_ms());
TEST_ASSERT_INT32_WITHIN(DELTA_US(20), 20000, p_timer->read_us());
TEST_ASSERT_UINT64_WITHIN(DELTA_US(20), 20000, p_timer->read_high_resolution_us());
}

/* This test verifies if reset() function resets the timer
Expand Down Expand Up @@ -613,10 +602,10 @@ void test_timer_start_started_timer_os_ticker()
p_timer->stop();

/* Check results - 30 ms have elapsed since the first start. */
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(2), 0.030f, p_timer->read());
TEST_ASSERT_INT32_WITHIN(DELTA_MS(2), 30, p_timer->read_ms());
TEST_ASSERT_INT32_WITHIN(DELTA_US(2), 30000, p_timer->read_us());
TEST_ASSERT_UINT64_WITHIN(DELTA_US(2), 30000, p_timer->read_high_resolution_us());
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(30), 0.030f, p_timer->read());
TEST_ASSERT_INT32_WITHIN(DELTA_MS(30), 30, p_timer->read_ms());
TEST_ASSERT_INT32_WITHIN(DELTA_US(30), 30000, p_timer->read_us());
TEST_ASSERT_UINT64_WITHIN(DELTA_US(30), 30000, p_timer->read_high_resolution_us());
}

/* This test verifies if calling start() for already
Expand Down Expand Up @@ -650,10 +639,10 @@ void test_timer_start_started_timer_user_ticker()
p_timer->stop();

/* Check results - 30 ms have elapsed since the first start. */
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(2), 0.030f, p_timer->read());
TEST_ASSERT_INT32_WITHIN(DELTA_MS(2), 30, p_timer->read_ms());
TEST_ASSERT_INT32_WITHIN(DELTA_US(2), 30000, p_timer->read_us());
TEST_ASSERT_UINT64_WITHIN(DELTA_US(2), 30000, p_timer->read_high_resolution_us());
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(30), 0.030f, p_timer->read());
TEST_ASSERT_INT32_WITHIN(DELTA_MS(30), 30, p_timer->read_ms());
TEST_ASSERT_INT32_WITHIN(DELTA_US(30), 30000, p_timer->read_us());
TEST_ASSERT_UINT64_WITHIN(DELTA_US(30), 30000, p_timer->read_high_resolution_us());
}

/* This test verifies Timer float operator.
Expand All @@ -677,7 +666,7 @@ void test_timer_float_operator_os_ticker()
p_timer->stop();

/* Check result - 10 ms elapsed. */
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(1), 0.010f, (float)(*p_timer));
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(10), 0.010f, (float)(*p_timer));
}

/* This test verifies Timer float operator.
Expand Down Expand Up @@ -732,10 +721,10 @@ void test_timer_time_measurement()
p_timer->stop();

/* Check results. */
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(1), (float)wait_val_us / 1000000, p_timer->read());
TEST_ASSERT_INT32_WITHIN(DELTA_MS(1), wait_val_us / 1000, p_timer->read_ms());
TEST_ASSERT_INT32_WITHIN(DELTA_US(1), wait_val_us, p_timer->read_us());
TEST_ASSERT_UINT64_WITHIN(DELTA_US(1), wait_val_us, p_timer->read_high_resolution_us());
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(wait_val_us / US_PER_MSEC), (float)wait_val_us / US_PER_SEC, p_timer->read());
TEST_ASSERT_INT32_WITHIN(DELTA_MS(wait_val_us / US_PER_MSEC), wait_val_us / US_PER_MSEC, p_timer->read_ms());
TEST_ASSERT_INT32_WITHIN(DELTA_US(wait_val_us / US_PER_MSEC), wait_val_us, p_timer->read_us());
TEST_ASSERT_UINT64_WITHIN(DELTA_US(wait_val_us / US_PER_MSEC), wait_val_us, p_timer->read_high_resolution_us());
}

utest::v1::status_t test_setup(const size_t number_of_cases) {
Expand Down
4 changes: 4 additions & 0 deletions TESTS/mbed_drivers/timerevent/main.cpp
View file
Open in desktop
Expand Up @@ -23,6 +23,10 @@

using namespace utest::v1;

#if !DEVICE_USTICKER
#error [NOT_SUPPORTED] test not supported
#endif

#define TEST_DELAY_US 50000ULL

class TestTimerEvent: public TimerEvent {
Expand Down
2 changes: 1 addition & 1 deletion TESTS/mbed_hal/common_tickers/main.cpp
View file
Open in desktop
Expand Up @@ -40,7 +40,7 @@

#define NUM_OF_CYCLES 100000

#define US_TICKER_OV_LIMIT 20000
#define US_TICKER_OV_LIMIT 35000
#define LP_TICKER_OV_LIMIT 4000

using namespace utest::v1;
Expand Down
4 changes: 4 additions & 0 deletions TESTS/mbed_hal/lp_ticker/main.cpp
View file
Open in desktop
Expand Up @@ -87,6 +87,7 @@ void lp_ticker_info_test()
TEST_ASSERT(p_ticker_info->bits >= 12);
}

#if DEVICE_SLEEP
/* Test that the ticker continues operating in deep sleep mode. */
void lp_ticker_deepsleep_test()
{
Expand Down Expand Up @@ -115,6 +116,7 @@ void lp_ticker_deepsleep_test()

TEST_ASSERT_EQUAL(1, intFlag);
}
#endif

/* Test that the ticker does not glitch backwards due to an incorrectly implemented ripple counter driver. */
void lp_ticker_glitch_test()
Expand All @@ -141,7 +143,9 @@ utest::v1::status_t test_setup(const size_t number_of_cases)

Case cases[] = {
Case("lp ticker info test", lp_ticker_info_test),
#if DEVICE_SLEEP
Case("lp ticker sleep test", lp_ticker_deepsleep_test),
#endif
Case("lp ticker glitch test", lp_ticker_glitch_test)
};

Expand Down