Skip to content

Commit 34b61d1

Browse files
0xc01700xc0170
authored
Merge pull request #5523 from ARMmbed/release-candidate
Release candidate for mbed-os-5.6.5
2 parents 78474a5 + 2550c88 commit 34b61d1

File tree

427 files changed

+128944
-758
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

427 files changed

+128944
-758
lines changed

‎TESTS/events/queue/main.cpp

Lines changed: 4 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -22,7 +22,10 @@
2222

2323
using namespace utest::v1;
2424

25-
#define TEST_EQUEUE_SIZE 1024
25+
// TEST_EQUEUE_SIZE was reduced below 1024B to fit this test to devices with small RAM (RAM <= 16kB)
26+
// additionally TEST_EQUEUE_SIZE was expressed in EVENTS_EVENT_SIZE to increase readability
27+
// (for more details about EVENTS_EVENT_SIZE see EventQueue constructor)
28+
#define TEST_EQUEUE_SIZE (18*EVENTS_EVENT_SIZE)
2629

2730
// flag for called
2831
volatile bool touched = false;

‎TESTS/mbed_drivers/lp_timer/main.cpp

Lines changed: 50 additions & 47 deletions
Original file line numberDiff line numberDiff line change
@@ -48,19 +48,22 @@ extern uint32_t SystemCoreClock;
4848
* DELTA = TOLERANCE_FACTOR / SystemCoreClock * US_FACTOR
4949
*
5050
* e.g.
51-
* For K64F DELTA = (40000 / 120000000) * 1000000 = 333[us]
52-
* For NUCLEO_F070RB DELTA = (40000 / 48000000) * 1000000 = 833[us]
53-
* For NRF51_DK DELTA = (40000 / 16000000) * 1000000 = 2500[us]
51+
* For K64F DELTA = (80000 / 120000000) * 1000000 = 666[us]
52+
* For NUCLEO_F070RB DELTA = (80000 / 48000000) * 1000000 = 1666[us]
53+
* For NRF51_DK DELTA = (80000 / 16000000) * 1000000 = 5000[us]
5454
*/
5555
#define US_PER_SEC 1000000
56-
#define TOLERANCE_FACTOR 40000.0f
56+
#define US_PER_MSEC 1000
57+
#define TOLERANCE_FACTOR 80000.0f
5758
#define US_FACTOR 1000000.0f
5859

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

61-
#define DELTA_US delta_sys_clk_us
62-
#define DELTA_S ((float)delta_sys_clk_us/US_PER_SEC)
63-
#define DELTA_MS 1
62+
/* When test performs time measurement using Timer in sequence, then measurement error accumulates
63+
* in the successive attempts. */
64+
#define DELTA_US(i) (delta_sys_clk_us * i)
65+
#define DELTA_S(i) ((float)delta_sys_clk_us * i / US_PER_SEC)
66+
#define DELTA_MS(i) (1 + ( (i * delta_sys_clk_us) / US_PER_MSEC))
6467

6568
/* This test verifies if low power timer is stopped after
6669
* creation.
@@ -75,19 +78,19 @@ void test_lptimer_creation()
7578

7679
/* Check results. */
7780
TEST_ASSERT_EQUAL_FLOAT(0, lp_timer.read());
78-
TEST_ASSERT_EQUAL(0, lp_timer.read_ms());
79-
TEST_ASSERT_EQUAL(0, lp_timer.read_us());
80-
TEST_ASSERT_EQUAL(0, lp_timer.read_high_resolution_us());
81+
TEST_ASSERT_EQUAL_INT32(0, lp_timer.read_ms());
82+
TEST_ASSERT_EQUAL_INT32(0, lp_timer.read_us());
83+
TEST_ASSERT_EQUAL_UINT64(0, lp_timer.read_high_resolution_us());
8184

8285
/* Wait 10 ms.
8386
* After that operation timer read routines should still return 0. */
8487
wait_ms(10);
8588

8689
/* Check results. */
8790
TEST_ASSERT_EQUAL_FLOAT(0, lp_timer.read());
88-
TEST_ASSERT_EQUAL(0, lp_timer.read_ms());
89-
TEST_ASSERT_EQUAL(0, lp_timer.read_us());
90-
TEST_ASSERT_EQUAL(0, lp_timer.read_high_resolution_us());
91+
TEST_ASSERT_EQUAL_INT32(0, lp_timer.read_ms());
92+
TEST_ASSERT_EQUAL_INT32(0, lp_timer.read_us());
93+
TEST_ASSERT_EQUAL_UINT64(0, lp_timer.read_high_resolution_us());
9194
}
9295

9396
/* This test verifies if read(), read_us(), read_ms(),
@@ -115,10 +118,10 @@ void test_lptimer_time_accumulation()
115118
lp_timer.stop();
116119

117120
/* Check results - totally 10 ms have elapsed. */
118-
TEST_ASSERT_FLOAT_WITHIN(DELTA_S, 0.010f, lp_timer.read());
119-
TEST_ASSERT_INT32_WITHIN(DELTA_MS, 10, lp_timer.read_ms());
120-
TEST_ASSERT_INT32_WITHIN(DELTA_US, 10000, lp_timer.read_us());
121-
TEST_ASSERT_UINT64_WITHIN(DELTA_US, 10000, lp_timer.read_high_resolution_us());
121+
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(1), 0.010f, lp_timer.read());
122+
TEST_ASSERT_INT32_WITHIN(DELTA_MS(1), 10, lp_timer.read_ms());
123+
TEST_ASSERT_INT32_WITHIN(DELTA_US(1), 10000, lp_timer.read_us());
124+
TEST_ASSERT_UINT64_WITHIN(DELTA_US(1), 10000, lp_timer.read_high_resolution_us());
122125

123126
/* Wait 50 ms - this is done to show that time elapsed when
124127
* the timer is stopped does not have influence on the
@@ -137,10 +140,10 @@ void test_lptimer_time_accumulation()
137140
lp_timer.stop();
138141

139142
/* Check results - totally 30 ms have elapsed. */
140-
TEST_ASSERT_FLOAT_WITHIN(2 * DELTA_S, 0.030f, lp_timer.read());
141-
TEST_ASSERT_INT32_WITHIN(DELTA_MS, 30, lp_timer.read_ms());
142-
TEST_ASSERT_INT32_WITHIN(2 * DELTA_US, 30000, lp_timer.read_us());
143-
TEST_ASSERT_UINT64_WITHIN(2 * DELTA_US, 30000, lp_timer.read_high_resolution_us());
143+
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(2), 0.030f, lp_timer.read());
144+
TEST_ASSERT_INT32_WITHIN(DELTA_MS(2), 30, lp_timer.read_ms());
145+
TEST_ASSERT_INT32_WITHIN(DELTA_US(2), 30000, lp_timer.read_us());
146+
TEST_ASSERT_UINT64_WITHIN(DELTA_US(2), 30000, lp_timer.read_high_resolution_us());
144147

145148
/* Wait 50 ms - this is done to show that time elapsed when
146149
* the timer is stopped does not have influence on the
@@ -158,10 +161,10 @@ void test_lptimer_time_accumulation()
158161
lp_timer.stop();
159162

160163
/* Check results - totally 60 ms have elapsed. */
161-
TEST_ASSERT_FLOAT_WITHIN(3 * DELTA_S, 0.060f, lp_timer.read());
162-
TEST_ASSERT_INT32_WITHIN(DELTA_MS, 60, lp_timer.read_ms());
163-
TEST_ASSERT_INT32_WITHIN(3 * DELTA_US, 60000, lp_timer.read_us());
164-
TEST_ASSERT_UINT64_WITHIN(3 * DELTA_US, 60000, lp_timer.read_high_resolution_us());
164+
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(3), 0.060f, lp_timer.read());
165+
TEST_ASSERT_INT32_WITHIN(DELTA_MS(3), 60, lp_timer.read_ms());
166+
TEST_ASSERT_INT32_WITHIN(DELTA_US(3), 60000, lp_timer.read_us());
167+
TEST_ASSERT_UINT64_WITHIN(DELTA_US(3), 60000, lp_timer.read_high_resolution_us());
165168

166169
/* Wait 50 ms - this is done to show that time elapsed when
167170
* the timer is stopped does not have influence on the
@@ -179,11 +182,11 @@ void test_lptimer_time_accumulation()
179182
/* Stop the timer. */
180183
lp_timer.stop();
181184

182-
/* Check results - totally 5060 ms have elapsed. */
183-
TEST_ASSERT_FLOAT_WITHIN(4 * DELTA_S, 1.060f, lp_timer.read());
184-
TEST_ASSERT_INT32_WITHIN(DELTA_MS, 1060, lp_timer.read_ms());
185-
TEST_ASSERT_INT32_WITHIN(4 * DELTA_US, 1060000, lp_timer.read_us());
186-
TEST_ASSERT_UINT64_WITHIN(4 * DELTA_US, 1060000, lp_timer.read_high_resolution_us());
185+
/* Check results - totally 1060 ms have elapsed. */
186+
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(4), 1.060f, lp_timer.read());
187+
TEST_ASSERT_INT32_WITHIN(DELTA_MS(4), 1060, lp_timer.read_ms());
188+
TEST_ASSERT_INT32_WITHIN(DELTA_US(4), 1060000, lp_timer.read_us());
189+
TEST_ASSERT_UINT64_WITHIN(DELTA_US(4), 1060000, lp_timer.read_high_resolution_us());
187190
}
188191

189192
/* This test verifies if reset() function resets the
@@ -209,10 +212,10 @@ void test_lptimer_reset()
209212
lp_timer.stop();
210213

211214
/* Check results - totally 10 ms elapsed. */
212-
TEST_ASSERT_FLOAT_WITHIN(DELTA_S, 0.010f, lp_timer.read());
213-
TEST_ASSERT_INT32_WITHIN(DELTA_MS, 10, lp_timer.read_ms());
214-
TEST_ASSERT_INT32_WITHIN(DELTA_US, 10000, lp_timer.read_us());
215-
TEST_ASSERT_UINT64_WITHIN(DELTA_US, 10000, lp_timer.read_high_resolution_us());
215+
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(1), 0.010f, lp_timer.read());
216+
TEST_ASSERT_INT32_WITHIN(DELTA_MS(1), 10, lp_timer.read_ms());
217+
TEST_ASSERT_INT32_WITHIN(DELTA_US(1), 10000, lp_timer.read_us());
218+
TEST_ASSERT_UINT64_WITHIN(DELTA_US(1), 10000, lp_timer.read_high_resolution_us());
216219

217220
/* Reset the timer - previous measured time should be lost now. */
218221
lp_timer.reset();
@@ -227,10 +230,10 @@ void test_lptimer_reset()
227230
lp_timer.stop();
228231

229232
/* Check results - 20 ms elapsed since the reset. */
230-
TEST_ASSERT_FLOAT_WITHIN(DELTA_S, 0.020f, lp_timer.read());
231-
TEST_ASSERT_INT32_WITHIN(DELTA_MS, 20, lp_timer.read_ms());
232-
TEST_ASSERT_INT32_WITHIN(DELTA_US, 20000, lp_timer.read_us());
233-
TEST_ASSERT_UINT64_WITHIN(DELTA_US, 20000, lp_timer.read_high_resolution_us());
233+
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(1), 0.020f, lp_timer.read());
234+
TEST_ASSERT_INT32_WITHIN(DELTA_MS(1), 20, lp_timer.read_ms());
235+
TEST_ASSERT_INT32_WITHIN(DELTA_US(1), 20000, lp_timer.read_us());
236+
TEST_ASSERT_UINT64_WITHIN(DELTA_US(1), 20000, lp_timer.read_high_resolution_us());
234237
}
235238

236239
/* This test verifies if calling start() for already
@@ -260,10 +263,10 @@ void test_lptimer_start_started_timer()
260263
lp_timer.stop();
261264

262265
/* Check results - 30 ms have elapsed since the first start. */
263-
TEST_ASSERT_FLOAT_WITHIN(2 * DELTA_S, 0.030f, lp_timer.read());
264-
TEST_ASSERT_INT32_WITHIN(DELTA_MS, 30, lp_timer.read_ms());
265-
TEST_ASSERT_INT32_WITHIN(2 * DELTA_US, 30000, lp_timer.read_us());
266-
TEST_ASSERT_UINT64_WITHIN(2 * DELTA_US, 30000, lp_timer.read_high_resolution_us());
266+
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(2), 0.030f, lp_timer.read());
267+
TEST_ASSERT_INT32_WITHIN(DELTA_MS(2), 30, lp_timer.read_ms());
268+
TEST_ASSERT_INT32_WITHIN(DELTA_US(2), 30000, lp_timer.read_us());
269+
TEST_ASSERT_UINT64_WITHIN(DELTA_US(2), 30000, lp_timer.read_high_resolution_us());
267270
}
268271

269272
/* This test verifies low power timer float operator.
@@ -287,7 +290,7 @@ void test_lptimer_float_operator()
287290
lp_timer.stop();
288291

289292
/* Check result - 10 ms elapsed. */
290-
TEST_ASSERT_FLOAT_WITHIN(DELTA_S, 0.010f, (float )(lp_timer));
293+
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(1), 0.010f, (float )(lp_timer));
291294
}
292295

293296
/* This test verifies if time counted by the low power timer is
@@ -313,10 +316,10 @@ void test_lptimer_time_measurement()
313316
lp_timer.stop();
314317

315318
/* Check results - wait_val_us us have elapsed. */
316-
TEST_ASSERT_FLOAT_WITHIN(DELTA_S, (float )wait_val_us / 1000000, lp_timer.read());
317-
TEST_ASSERT_INT32_WITHIN(DELTA_MS, wait_val_us / 1000, lp_timer.read_ms());
318-
TEST_ASSERT_INT32_WITHIN(DELTA_US, wait_val_us, lp_timer.read_us());
319-
TEST_ASSERT_UINT64_WITHIN(DELTA_US, wait_val_us, lp_timer.read_high_resolution_us());
319+
TEST_ASSERT_FLOAT_WITHIN(DELTA_S(1), (float )wait_val_us / 1000000, lp_timer.read());
320+
TEST_ASSERT_INT32_WITHIN(DELTA_MS(1), wait_val_us / 1000, lp_timer.read_ms());
321+
TEST_ASSERT_INT32_WITHIN(DELTA_US(1), wait_val_us, lp_timer.read_us());
322+
TEST_ASSERT_UINT64_WITHIN(DELTA_US(1), wait_val_us, lp_timer.read_high_resolution_us());
320323
}
321324

322325
utest::v1::status_t test_setup(const size_t number_of_cases)

0 commit comments

Comments
 (0)