Bring in improved HAL APIs to master

TESTS/events/queue/main.cpp

@@ -20,8 +20,15 @@
 #include "unity.h"
 #include "utest.h"
 
+#if !DEVICE_USTICKER
+  #error [NOT_SUPPORTED] test not supported
+#endif
+
 using namespace utest::v1;
 
+// Assume that tolerance is 5% of measured time.
+#define DELTA(ms) (ms / 20)
+
 // TEST_EQUEUE_SIZE was reduced below 1024B to fit this test to devices with small RAM (RAM <= 16kB)
 // additionally TEST_EQUEUE_SIZE was expressed in EVENTS_EVENT_SIZE to increase readability
 // (for more details about EVENTS_EVENT_SIZE see EventQueue constructor)
@@ -89,7 +96,7 @@ SIMPLE_POSTS_TEST(0)
 
 
 void time_func(Timer *t, int ms) {
-    TEST_ASSERT_INT_WITHIN(5, ms, t->read_ms());
+    TEST_ASSERT_INT_WITHIN(DELTA(ms), ms, t->read_ms());
     t->reset();
 }
 

TESTS/events/timing/main.cpp

@@ -24,6 +24,9 @@
 
 using namespace utest::v1;
 
+#if !DEVICE_USTICKER
+  #error [NOT_SUPPORTED] test not supported
+#endif
 
 // Test delay
 #ifndef TEST_EVENTS_TIMING_TIME

TESTS/host_tests/rtc_reset.py

@@ -0,0 +1,144 @@
+"""
+mbed SDK
+Copyright (c) 2017-2017 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.
+"""
+from __future__ import print_function
+
+from mbed_host_tests import BaseHostTest
+from time import sleep
+
+
+class RtcResetTest(BaseHostTest):
+    """This test checks that a device's RTC keeps count through a reset
+
+    It does this by setting the RTC's time, triggering a reset,
+    delaying and then reading the RTC's time again to ensure
+    that the RTC is still counting.
+    """
+
+    """Start of the RTC"""
+    START_TIME = 50000
+    START_TIME_TOLERANCE = 10
+    """Time to delay after sending reset"""
+    DELAY_TIME = 5.0
+    DELAY_TOLERANCE = 1.0
+    VALUE_PLACEHOLDER = "0"
+
+    def setup(self):
+        """Register callbacks required for the test"""
+        self._error = False
+        generator = self.rtc_reset_test()
+        generator.next()
+
+        def run_gen(key, value, time):
+            """Run the generator, and fail testing if the iterator stops"""
+            if self._error:
+                return
+            try:
+                generator.send((key, value, time))
+            except StopIteration:
+                self._error = True
+
+        for resp in ("start", "read", "ack"):
+            self.register_callback(resp, run_gen)
+
+    def teardown(self):
+        """No work to do here"""
+        pass
+
+    def rtc_reset_test(self):
+        """Generator for running the reset test
+
+        This function calls yield to wait for the next event from
+        the device. If the device gives the wrong response, then the
+        generator terminates by returing which raises a StopIteration
+        exception and fails the test.
+        """
+
+        # Wait for start token
+        key, value, time = yield
+        if key != "start":
+            return
+
+        # Initialize, and set the time
+        self.send_kv("init", self.VALUE_PLACEHOLDER)
+
+        # Wait for ack from the device
+        key, value, time = yield
+        if key != "ack":
+            return
+
+        self.send_kv("write", str(self.START_TIME))
+
+        # Wait for ack from the device
+        key, value, time = yield
+        if key != "ack":
+            return
+
+        self.send_kv("read", self.VALUE_PLACEHOLDER)
+        key, value, time = yield
+        if key != "read":
+            return
+        dev_time_start = int(value)
+
+        # Unitialize, and reset
+        self.send_kv("free", self.VALUE_PLACEHOLDER)
+
+        # Wait for ack from the device
+        key, value, time = yield
+        if key != "ack":
+            return
+
+        self.send_kv("reset", self.VALUE_PLACEHOLDER)
+
+        # No ack after reset
+        sleep(self.DELAY_TIME)
+
+        # Restart the test, and send the sync token
+        self.send_kv("__sync", "00000000-0000-000000000-000000000000")
+        key, value, time = yield
+        if key != "start":
+            return
+
+        # Initialize, and read the time
+        self.send_kv("init", self.VALUE_PLACEHOLDER)
+
+        # Wait for ack from the device
+        key, value, time = yield
+        if key != "ack":
+            return
+
+        self.send_kv("read", self.VALUE_PLACEHOLDER)
+        key, value, time = yield
+        if key != "read":
+            return
+        dev_time_end = int(value)
+
+        # Check result
+        elapsed = dev_time_end - dev_time_start
+        start_time_valid = (self.START_TIME <= dev_time_start <
+                            self.START_TIME + self.START_TIME_TOLERANCE)
+        elapsed_time_valid = elapsed >= self.DELAY_TIME - self.DELAY_TOLERANCE
+        passed = start_time_valid and elapsed_time_valid
+        if not start_time_valid:
+            self.log("FAIL: Expected start time of %i got %i" %
+                     (self.START_TIME, dev_time_start))
+        elif not passed:
+            self.log("FAIL: Delayed for %fs but device "
+                     "reported elapsed time of %fs" %
+                     (self.DELAY_TIME, elapsed))
+        self.send_kv("exit", "pass" if passed else "fail")
+        yield    # No more events expected
+

TESTS/mbed_drivers/lp_ticker/main.cpp

@@ -19,7 +19,7 @@
 #include "unity/unity.h"
 
 
-#if !DEVICE_LOWPOWERTIMER
+#if !DEVICE_LPTICKER
     #error [NOT_SUPPORTED] Low power ticker not supported for this target
 #endif
 
@@ -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 600us for measurement inaccuracy + 5% tolerance
+   for LowPowerTicker. */
+#define TOLERANCE_US(DELAY) (600 + DELAY / 20)
 
 
 volatile uint32_t ticker_callback_flag;
@@ -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);
     }
 }
 
@@ -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
@@ -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

TESTS/mbed_drivers/lp_timeout/main.cpp

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#if !DEVICE_LOWPOWERTIMER
-#error [NOT_SUPPORTED] Low power timer not supported for this target
+#if !DEVICE_LPTICKER
+    #error [NOT_SUPPORTED] Low power timer not supported for this target
 #endif
 
 #include "mbed.h"