exmachina-dev
diff --git a/‎.github/issue_template.md
+1-1 b/‎.github/issue_template.md
+1-1
diff --git a/‎.gitignore
+1 b/‎.gitignore
+1
diff --git a/‎.travis.yml
+25-7 b/‎.travis.yml
+25-7
diff --git a/‎CONTRIBUTING.md
+1-1 b/‎CONTRIBUTING.md
+1-1
diff --git a/‎Jenkinsfile
+1-2 b/‎Jenkinsfile
+1-2
diff --git a/‎TESTS/events/queue/main.cpp
+24-8 b/‎TESTS/events/queue/main.cpp
+24-8
diff --git a/‎TESTS/events/timing/main.cpp
+15 b/‎TESTS/events/timing/main.cpp
+15
diff --git a/‎TESTS/host_tests/timing_drift_auto.py
+103-74 b/‎TESTS/host_tests/timing_drift_auto.py
+103-74
@@ -19,7 +19,7 @@ GCC_ARM|ARM|IAR
 **mbed-cli version:** 
 (`mbed --version`)
 
-**meed-os sha:**
+**mbed-os sha:**
 (`git log -n1 --oneline`)
 
 **DAPLink version:**
 
@@ -5,6 +5,7 @@ dist
 
 # MANIFEST file
 MANIFEST
+doxygen_objdb_*
 
 # Private settings
 mbed_settings.py
 
@@ -2,6 +2,22 @@ python:
   - "2.7"
 
 script:
+  - mkdir BUILD
+# Assert that the Doxygen build produced no warnings.
+# The strange command below asserts that the Doxygen command had an
+# output of zero length
+  - |
+    doxygen doxyfile_options 2>&1 | tee BUILD/doxygen.out && [ ! -s BUILD/doxygen.out ]
+# Assert that all binary libraries are named correctly
+# The strange command below asserts that there are exactly 0 libraries that do
+# not start with lib
+  - |
+    find "(" -name "*.a" -or -name "*.ar" ")" -and -not -name "lib*" | tee BUILD/badlibs | sed -e "s/^/Bad library name found: /" && [ ! -s BUILD/badlibs ]
+# Assert that all assebler files are named correctly
+# The strange command below asserts that there are exactly 0 libraries that do
+# end with .s
+  - |
+    find  -name "*.s" | tee BUILD/badasm | sed -e "s/^/Bad Assembler file name found: /" && [ ! -s BUILD/badasm ]
   - make -C events/equeue test clean
   - PYTHONPATH=. python tools/test/config_test/config_test.py
   - PYTHONPATH=. python tools/test/build_api/build_api_test.py
@@ -12,15 +28,17 @@ script:
   - python tools/project.py -S
   - python tools/build_travis.py
 before_install:
-  - sudo add-apt-repository -y ppa:terry.guo/gcc-arm-embedded
+  - sudo add-apt-repository -y ppa:team-gcc-arm-embedded/ppa
+  - sudo add-apt-repository -y ppa:libreoffice/libreoffice-4-2
   - sudo apt-get update -qq
-  - sudo apt-get install -qq gcc-arm-none-eabi --force-yes
+  - sudo apt-get install -qq gcc-arm-embedded doxygen --force-yes
   # Print versions we use
   - arm-none-eabi-gcc --version
   - python --version
+  - doxygen --version
 install:
-  - sudo pip install -r requirements.txt
-  - sudo pip install pytest
-  - sudo pip install pylint
-  - sudo pip install hypothesis
-  - sudo pip install mock
+  - pip install -r requirements.txt
+  - pip install pytest
+  - pip install pylint
+  - pip install hypothesis
+  - pip install mock
@@ -5,7 +5,7 @@ All changes in code base should originate from GitHub Issues and take advantage
 Guidelines from this document are created to help new and existing contributors understand process workflow and align to project rules before pull request is submitted. It explains how a participant should do things like format code, test fixes, and submit patches.
 
 ## Where to get more information?
-You can for example read more in our ```docs``` section in [ARMmbed/mbed-os/doc](https://github.com/ARMmbed/mbed-os/tree/master/docs) directory.
+You can read more on our [documentation page](https://docs.mbed.com/docs/mbed-os-handbook/en/latest/cont/contributing/).
 
 # How to contribute
 We really appreciate your contributions! We are Open Source project and we need your help. We want to keep it as easy as possible to contribute changes that get things working in your environment. There are a few guidelines that we need contributors to follow so that we can have a chance of keeping on top of things.
 
@@ -24,8 +24,7 @@ def parallelSteps = mbed.createParalleSteps("mbed-os", targets, toolchains)
 mbed.compile(parallelSteps)
 
 def testApps = [
-  "mbed-os-cliapp",
-  "mbed-client-testapp"
+  "mbed-os-cliapp"
   ]
 
 // buildTestApps accepts array of test application names and a mbed-os branch or PR reference as parameters
 
@@ -1,3 +1,18 @@
+/* mbed Microcontroller Library
+ * Copyright (c) 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.
+ */
 #include "mbed_events.h"
 #include "mbed.h"
 #include "rtos.h"
@@ -7,6 +22,7 @@
 
 using namespace utest::v1;
 
+#define TEST_EQUEUE_SIZE 1024
 
 // flag for called
 volatile bool touched = false;
@@ -43,7 +59,7 @@ void func0() {
 
 #define SIMPLE_POSTS_TEST(i, ...)                           \
 void simple_posts_test##i() {                               \
-    EventQueue queue;                                       \
+    EventQueue queue(TEST_EQUEUE_SIZE);                     \
                                                             \
     touched = false;                                        \
     queue.call(func##i,##__VA_ARGS__);                      \
@@ -78,7 +94,7 @@ template <int N>
 void call_in_test() {
     Timer tickers[N];
 
-    EventQueue queue;
+    EventQueue queue(TEST_EQUEUE_SIZE);
 
     for (int i = 0; i < N; i++) {
         tickers[i].start();
@@ -92,7 +108,7 @@ template <int N>
 void call_every_test() {
     Timer tickers[N];
 
-    EventQueue queue;
+    EventQueue queue(TEST_EQUEUE_SIZE);
 
     for (int i = 0; i < N; i++) {
         tickers[i].start();
@@ -103,7 +119,7 @@ void call_every_test() {
 }
 
 void allocate_failure_test() {
-    EventQueue queue;
+    EventQueue queue(TEST_EQUEUE_SIZE);
     int id;
 
     for (int i = 0; i < 100; i++) {
@@ -119,7 +135,7 @@ void no() {
 
 template <int N>
 void cancel_test1() {
-    EventQueue queue;
+    EventQueue queue(TEST_EQUEUE_SIZE);
 
     int ids[N];
 
@@ -164,7 +180,7 @@ void count0() {
 
 void event_class_test() {
     counter = 0;
-    EventQueue queue(2048);
+    EventQueue queue(TEST_EQUEUE_SIZE);
 
     Event<void(int, int, int, int, int)> e5(&queue, count5);
     Event<void(int, int, int, int)> e4(&queue, count5, 1);
@@ -187,7 +203,7 @@ void event_class_test() {
 
 void event_class_helper_test() {
     counter = 0;
-    EventQueue queue(2048);
+    EventQueue queue(TEST_EQUEUE_SIZE);
 
     Event<void()> e5 = queue.event(count5, 1, 1, 1, 1, 1);
     Event<void()> e4 = queue.event(count4, 1, 1, 1, 1);
@@ -210,7 +226,7 @@ void event_class_helper_test() {
 
 void event_inference_test() {
     counter = 0;
-    EventQueue queue(2048);
+    EventQueue queue(TEST_EQUEUE_SIZE);
 
     queue.event(count5, 1, 1, 1, 1, 1).post();
     queue.event(count5, 1, 1, 1, 1).post(1);
 
@@ -1,3 +1,18 @@
+/* mbed Microcontroller Library
+ * Copyright (c) 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.
+ */
 #include "mbed_events.h"
 #include "mbed.h"
 #include "rtos.h"
 
@@ -16,91 +16,120 @@
 """
 
 from mbed_host_tests import BaseHostTest
+import time
 
 
-class TimingDriftTest(BaseHostTest):
-    """ This test is reading single characters from stdio
-        and measures time between their occurrences.
+class TimingDriftSync(BaseHostTest):
+    """
+    This works as master-slave fashion
+    1) Device says its booted up and ready to run the test, wait for host to respond
+    2) Host sends the message to get the device current time i.e base time
+
+    #
+    # *
+    #   *                   |
+    #<---* DUT<- base_time  | - round_trip_base_time ------
+    #   *                   |                              |
+    # *                    -                               |
+    #                      -                               |
+    #                       |                              |
+    #                       |                              |
+    #                       | - measurement_stretch        | - nominal_time
+    #                       |                              |
+    #                       |                              |
+    #                      -                               |
+    # *                    -                               |
+    #   *                   |                              |
+    #<---* DUT <-final_time | - round_trip_final_time------
+    #   *                   |
+    # *                    -
+    #
+    #
+    # As we increase the measurement_stretch, the error because of transport delay diminishes.
+    # The values of measurement_stretch is propotional to round_trip_base_time(transport delays)
+    # by factor time_measurement_multiplier.This multiplier is used is 80 to tolerate 2 sec of
+    # transport delay and test time ~ 180 secs
+    #
+    # Failure in timing can occur if we are ticking too fast or we are ticking too slow, hence we have
+    # min_range and max_range. if we cross on either side tests would be marked fail. The range is a function of
+    # tolerance/acceptable drift currently its 5%.
+    #
+
     """
     __result = None
-    
-    # This is calculated later: average_drift_max * number of tick events
-    total_drift_max = None
-    
-    average_drift_max = 0.05
-    ticks = []
-    start_time = None
-    finish_time = None
-    dut_seconds_passed = None
-    total_time = None
-    total_drift = None
-    average_drift = None
-    
-    def _callback_result(self, key, value, timestamp):
-        # We should not see result data in this test
-        self.__result = False
-
-    def _callback_end(self, key, value, timestamp):
-        """ {{end;%s}}} """
-        self.log("Received end event, timestamp: %f" % timestamp)
-        self.notify_complete(result=self.result(print_stats=True))
-
-
-    def _callback_tick(self, key, value, timestamp):
-        """ {{tick;%d}}} """
-        self.log("tick! %f" % timestamp)
-        self.ticks.append((key, value, timestamp))
+    mega = 1000000.0
+    max_measurement_time = 180
 
+    # this value is obtained for measurements when there is 0 transport delay and we want accurancy of 5%
+    time_measurement_multiplier = 80
 
-    def setup(self):
-        self.register_callback("end", self._callback_end)
-        self.register_callback('tick', self._callback_tick)
+    def _callback_timing_drift_check_start(self, key, value, timestamp):
+        self.round_trip_base_start = timestamp
+        self.send_kv("base_time", 0)
 
+    def _callback_base_time(self, key, value, timestamp):
+        self.round_trip_base_end = timestamp
+        self.device_time_base = float(value)
+        self.round_trip_base_time = self.round_trip_base_end - self.round_trip_base_start
 
-    def result(self, print_stats=True):        
-        self.dut_seconds_passed = len(self.ticks) - 1
-        
-        if self.dut_seconds_passed < 1:
-            if print_stats:
-                self.log("FAIL: failed to receive at least two tick events")
-            self.__result = False
-            return self.__result
-
-        self.total_drift_max = self.dut_seconds_passed * self.average_drift_max
-
-        self.start_time = self.ticks[0][2]
-        self.finish_time = self.ticks[-1][2]
-        self.total_time = self.finish_time - self.start_time
-        self.total_drift = self.total_time - self.dut_seconds_passed
-        self.average_drift = self.total_drift / self.dut_seconds_passed
-        
-        if print_stats:
-            self.log("Start: %f" % self.start_time)
-            self.log("Finish: %f" % self.finish_time)
-            self.log("Total time taken: %f" % self.total_time)
-        
-            total_drift_ratio_string = "Total drift/Max total drift: %f/%f"
-            self.log(total_drift_ratio_string % (self.total_drift,
-                                                 self.total_drift_max))
-                                                 
-            average_drift_ratio_string = "Average drift/Max average drift: %f/%f"
-            self.log(average_drift_ratio_string % (self.average_drift,
-                                                   self.average_drift_max))
-        
-
-        if abs(self.total_drift) > self.total_drift_max:
-            if print_stats:
-                self.log("FAIL: Total drift exceeded max total drift")
-            self.__result = False
-        elif self.average_drift > self.average_drift_max:
-            if print_stats:
-                self.log("FAIL: Average drift exceeded max average drift")
-            self.__result = False
+        self.log("Device base time {}".format(value))
+        measurement_stretch = (self.round_trip_base_time * self.time_measurement_multiplier) + 5
+
+        if measurement_stretch > self.max_measurement_time:
+            self.log("Time required {} to determine device timer is too high due to transport delay, skipping".format(measurement_stretch))
         else:
+            self.log("sleeping for {} to measure drift accurately".format(measurement_stretch))
+            time.sleep(measurement_stretch)
+        self.round_trip_final_start = time.time()
+        self.send_kv("final_time", 0)
+
+    def _callback_final_time(self, key, value, timestamp):
+        self.round_trip_final_end = timestamp
+        self.device_time_final = float(value)
+        self.round_trip_final_time = self.round_trip_final_end - self.round_trip_final_start
+        self.log("Device final time {} ".format(value))
+
+        # compute the test results and send to device
+        results = "pass" if self.compute_parameter() else "fail"
+        self.send_kv(results, "0")
+
+    def setup(self):
+        self.register_callback('timing_drift_check_start', self._callback_timing_drift_check_start)
+        self.register_callback('base_time', self._callback_base_time)
+        self.register_callback('final_time', self._callback_final_time)
+
+    def compute_parameter(self, failure_criteria=0.05):
+        t_max = self.round_trip_final_end - self.round_trip_base_start
+        t_min = self.round_trip_final_start - self.round_trip_base_end
+        t_max_hi = t_max * (1 + failure_criteria)
+        t_max_lo = t_max * (1 - failure_criteria)
+        t_min_hi = t_min * (1 + failure_criteria)
+        t_min_lo = t_min * (1 - failure_criteria)
+        device_time = (self.device_time_final - self.device_time_base) / self.mega
+
+        self.log("Compute host events")
+        self.log("Transport delay 0: {}".format(self.round_trip_base_time))
+        self.log("Transport delay 1: {}".format(self.round_trip_final_time))
+        self.log("DUT base time : {}".format(self.device_time_base))
+        self.log("DUT end time  : {}".format(self.device_time_final))
+
+        self.log("min_pass : {} , max_pass : {} for {}%%".format(t_max_lo, t_min_hi, failure_criteria * 100))
+        self.log("min_inconclusive : {} , max_inconclusive : {}".format(t_min_lo, t_max_hi))
+        self.log("Time reported by device: {}".format(device_time))
+
+        if t_max_lo <= device_time <= t_min_hi:
+            self.log("Test passed !!!")
             self.__result = True
-        
+        elif t_min_lo <= device_time <= t_max_hi:
+            self.log("Test inconclusive due to transport delay, retrying")
+            self.__result = False
+        else:
+            self.log("Time outside of passing range. Timing drift seems to be present !!!")
+            self.__result = False
         return self.__result
 
+    def result(self):
+        return self.__result
 
     def teardown(self):
-        pass
+        pass
Original file line number	Diff line number	Diff line change
`@@ -24,8 +24,7 @@ def parallelSteps = mbed.createParalleSteps("mbed-os", targets, toolchains)`
`24`	`24`	`mbed.compile(parallelSteps)`
`25`	`25`
`26`	`26`	`def testApps = [`
`27`		`- "mbed-os-cliapp",`
`28`		`- "mbed-client-testapp"`
	`27`	`+ "mbed-os-cliapp"`
`29`	`28`	`]`
`30`	`29`
`31`	`30`	`// buildTestApps accepts array of test application names and a mbed-os branch or PR reference as parameters`