Merge pull request #7518 from ARMmbed/release-candidate

 Release candidate for mbed-os-5.9.3

Author: 0xc0170

.astyleignore

@@ -11,6 +11,7 @@ features/FEATURE_BLE/targets
 features/FEATURE_LWIP/lwip-interface/lwip
 features/unsupported/
 features/FEATURE_COMMON_PAL/
+hal/storage_abstraction
 FEATURE_NANOSTACK/coap-service
 FEATURE_NANOSTACK/sal-stack-nanostack
 rtos/TARGET_CORTEX/rtx5

TESTS/mbed_drivers/lp_timer/main.cpp

@@ -55,6 +55,18 @@ extern uint32_t SystemCoreClock;
 #define DELTA_MS(delay_ms) (1 + ((delay_ms) * US_PER_MSEC / 20 / US_PER_MSEC))
 #define DELTA_S(delay_ms) (0.000500f + (((float)(delay_ms)) / MSEC_PER_SEC / 20))
 
+void busy_wait_us(int us)
+{
+    const ticker_data_t *const ticker = get_us_ticker_data();
+    uint32_t start = ticker_read(ticker);
+    while ((ticker_read(ticker) - start) < (uint32_t)us);
+}
+
+void busy_wait_ms(int ms)
+{
+    busy_wait_us(ms * US_PER_MSEC);
+}
+
 /* This test verifies if low power timer is stopped after
  * creation.
  *
@@ -74,7 +86,7 @@ void test_lptimer_creation()
 
     /* Wait 10 ms.
      * After that operation timer read routines should still return 0. */
-    wait_ms(10);
+    busy_wait_ms(10);
 
     /* Check results. */
     TEST_ASSERT_EQUAL_FLOAT(0, lp_timer.read());
@@ -102,7 +114,7 @@ void test_lptimer_time_accumulation()
     lp_timer.start();
 
     /* Wait 10 ms. */
-    wait_ms(10);
+    busy_wait_ms(10);
 
     /* Stop the timer. */
     lp_timer.stop();
@@ -116,15 +128,15 @@ void test_lptimer_time_accumulation()
     /* Wait 50 ms - this is done to show that time elapsed when
      * the timer is stopped does not have influence on the
      * timer counted time. */
-    wait_ms(50);
+    busy_wait_ms(50);
 
     /* ------ */
 
     /* Start the timer. */
     lp_timer.start();
 
     /* Wait 20 ms. */
-    wait_ms(20);
+    busy_wait_ms(20);
 
     /* Stop the timer. */
     lp_timer.stop();
@@ -145,7 +157,7 @@ void test_lptimer_time_accumulation()
     lp_timer.start();
 
     /* Wait 30 ms. */
-    wait_ms(30);
+    busy_wait_ms(30);
 
     /* Stop the timer. */
     lp_timer.stop();
@@ -159,15 +171,15 @@ void test_lptimer_time_accumulation()
     /* Wait 50 ms - this is done to show that time elapsed when
      * the timer is stopped does not have influence on the
      * timer time. */
-    wait_ms(50);
+    busy_wait_ms(50);
 
     /* ------ */
 
     /* Start the timer. */
     lp_timer.start();
 
     /* Wait 1 sec. */
-    wait_ms(1000);
+    busy_wait_ms(1000);
 
     /* Stop the timer. */
     lp_timer.stop();
@@ -196,7 +208,7 @@ void test_lptimer_reset()
     lp_timer.start();
 
     /* Wait 10 ms. */
-    wait_ms(10);
+    busy_wait_ms(10);
 
     /* Stop the timer. */
     lp_timer.stop();
@@ -214,7 +226,7 @@ void test_lptimer_reset()
     lp_timer.start();
 
     /* Wait 20 ms. */
-    wait_ms(20);
+    busy_wait_ms(20);
 
     /* Stop the timer. */
     lp_timer.stop();
@@ -241,13 +253,13 @@ void test_lptimer_start_started_timer()
     lp_timer.start();
 
     /* Wait 10 ms. */
-    wait_ms(10);
+    busy_wait_ms(10);
 
     /* Now start timer again. */
     lp_timer.start();
 
     /* Wait 20 ms. */
-    wait_ms(20);
+    busy_wait_ms(20);
 
     /* Stop the timer. */
     lp_timer.stop();
@@ -274,7 +286,7 @@ void test_lptimer_float_operator()
     lp_timer.start();
 
     /* Wait 10 ms. */
-    wait_ms(10);
+    busy_wait_ms(10);
 
     /* Stop the timer. */
     lp_timer.stop();
@@ -302,7 +314,7 @@ void test_lptimer_time_measurement()
     lp_timer.start();
 
     /* Wait <wait_val_us> us. */
-    wait_us(wait_val_us);
+    busy_wait_us(wait_val_us);
 
     /* Stop the timer. */
     lp_timer.stop();

TESTS/mbed_hal/common_tickers/main.cpp

@@ -52,6 +52,7 @@ unsigned int ticker_overflow_delta;
 
 /* Auxiliary function to count ticker ticks elapsed during execution of N cycles of empty while loop.
  * Parameter <step> is used to disable compiler optimisation. */
+MBED_NOINLINE
 uint32_t count_ticks(uint32_t cycles, uint32_t step)
 {
     register uint32_t reg_cycles = cycles;

TESTS/mbed_hal/lp_ticker/main.cpp

@@ -29,13 +29,38 @@ using namespace utest::v1;
 
 volatile int intFlag = 0;
 
+#define US_PER_MS 1000
+
 #define TICKER_GLITCH_TEST_TICKS 1000
 
 #define TICKER_INT_VAL 500
 #define TICKER_DELTA 10
 
 #define LP_TICKER_OV_LIMIT 4000
 
+/* Flush serial buffer before deep sleep
+ *
+ * Since deepsleep() may shut down the UART peripheral, we wait for some time
+ * to allow for hardware serial buffers to completely flush.
+ *
+ * Take NUMAKER_PFM_NUC472 as an example:
+ * Its UART peripheral has 16-byte Tx FIFO. With baud rate set to 9600, flush
+ * Tx FIFO would take: 16 * 8 * 1000 / 9600 = 13.3 (ms). So set wait time to
+ * 20ms here for safe.
+ *
+ * This should be replaced with a better function that checks if the
+ * hardware buffers are empty. However, such an API does not exist now,
+ * so we'll use the busy_wait_ms() function for now.
+ */
+#define SERIAL_FLUSH_TIME_MS    20
+
+void busy_wait_ms(int ms)
+{
+    const ticker_data_t *const ticker = get_us_ticker_data();
+    uint32_t start = ticker_read(ticker);
+    while ((ticker_read(ticker) - start) < (uint32_t)(ms * US_PER_MS));
+}
+
 /* Since according to the ticker requirements min acceptable counter size is
  * - 12 bits for low power timer - max count = 4095,
  * then all test cases must be executed in this time windows.
@@ -72,11 +97,6 @@ void ticker_event_handler_stub(const ticker_data_t * const ticker)
     lp_ticker_disable_interrupt();
 }
 
-void wait_cycles(volatile unsigned int cycles)
-{
-    while (cycles--);
-}
-
 /* Test that the ticker has the correct frequency and number of bits. */
 void lp_ticker_info_test()
 {
@@ -97,8 +117,10 @@ void lp_ticker_deepsleep_test()
 
     lp_ticker_init();
 
-    /* Wait for green tea UART transmission before entering deep-sleep mode. */
-    wait_cycles(400000);
+    /* Give some time Green Tea to finish UART transmission before entering
+     * deep-sleep mode.
+     */
+    busy_wait_ms(SERIAL_FLUSH_TIME_MS);
 
     overflow_protect();
 

TESTS/mbed_platform/stats_sys/main.cpp

@@ -32,6 +32,7 @@ void test_sys_info()
     mbed_stats_sys_t stats;
     mbed_stats_sys_get(&stats);
 
+    TEST_ASSERT_NOT_EQUAL(0, stats.os_version);
 #if defined(__CORTEX_M)
     TEST_ASSERT_NOT_EQUAL(0, stats.cpu_id);
 #endif

TESTS/mbedmicro-rtos-mbed/kernel_tick_count/main.cpp

@@ -0,0 +1,119 @@
+/* mbed Microcontroller Library
+ * Copyright (c) 2018-2018 ARM Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "greentea-client/test_env.h"
+#include "utest/utest.h"
+#include "unity/unity.h"
+
+#include "rtos/Kernel.h"
+#include "mbed.h"
+
+
+using utest::v1::Case;
+
+#define TEST_REPEAT_COUNT   1000
+#define NUM_WAIT_TICKS      1000
+
+// all in [us]
+#define ONE_SECOND          1000000
+#define SMALL_DELTA         1500        // 0.15%
+#define BIG_DELTA           15000       // 1.5%
+
+/** Test if kernel ticker frequency is 1kHz
+
+    Given a RTOS kernel ticker
+    When check it frequency
+    Then the the frequency is 1kHz
+ */
+void test_frequency()
+{
+    uint32_t freq = osKernelGetTickFreq();
+    TEST_ASSERT_EQUAL_UINT32_MESSAGE(1000, freq, "Expected SysTick frequency is 1kHz");
+}
+
+/** Test if kernel ticker increments by one
+
+    Given a RTOS kernel ticker
+    When perform subsequent calls of @a rtos::Kernel::get_ms_count
+    Then subsequent reads should not differ by more than one
+ */
+void test_increment(void)
+{
+    for (uint32_t i = 0; i < TEST_REPEAT_COUNT; i++) {
+        const uint64_t start = rtos::Kernel::get_ms_count();
+        while (true) {
+            uint64_t diff = rtos::Kernel::get_ms_count() - start;
+            if (diff != 0) {
+                TEST_ASSERT_EQUAL_UINT64(1, diff);
+                break;
+            }
+        }
+    }
+}
+
+/** Test if kernel ticker interval is 1ms
+
+    Given a RTOS kernel ticker
+    When perform subsequent calls of @a rtos::Kernel::get_ms_count
+    Then the ticker interval should be 1ms
+ */
+void test_interval()
+{
+    uint64_t start, stop;
+    Timer timer;
+
+    start = rtos::Kernel::get_ms_count();
+    // wait for tick
+    do {
+        stop = rtos::Kernel::get_ms_count();
+    } while ((stop - start) == 0);
+    timer.start();
+    start = stop;
+
+    // wait for NUM_WAIT_TICKS ticks
+    do {
+        stop = rtos::Kernel::get_ms_count();
+    } while ((stop - start) != NUM_WAIT_TICKS);
+    timer.stop();
+    TEST_ASSERT_EQUAL_UINT64(NUM_WAIT_TICKS, (stop - start));
+
+#if defined(NO_SYSTICK) || defined(MBED_TICKLESS)
+    // On targets with NO_SYSTICK/MBED_TICKLESS enabled, systick is emulated by lp_ticker what makes it less accurate
+    // for more details https://os.mbed.com/docs/latest/reference/tickless.html
+    TEST_ASSERT_UINT64_WITHIN(BIG_DELTA, ONE_SECOND, timer.read_high_resolution_us());
+#else
+    TEST_ASSERT_UINT64_WITHIN(SMALL_DELTA, ONE_SECOND, timer.read_high_resolution_us());
+#endif
+}
+
+// Test cases
+Case cases[] = {
+    Case("Test kernel ticker frequency", test_frequency),
+    Case("Test if kernel ticker increments by one", test_increment),
+    Case("Test if kernel ticker interval is 1ms", test_interval)
+};
+
+utest::v1::status_t greentea_test_setup(const size_t number_of_cases)
+{
+    GREENTEA_SETUP(10, "timing_drift_auto");
+    return utest::v1::greentea_test_setup_handler(number_of_cases);
+}
+
+utest::v1::Specification specification(greentea_test_setup, cases);
+
+int main()
+{
+    return !utest::v1::Harness::run(specification);
+}