NVIC_SystemReset

.github/issue_template.md

@@ -0,0 +1,48 @@
+Note: This is just a template, so feel free to use/remove the unnecessary things
+
+### Description
+- Type: Bug | Enhancement | Question
+- Related issue: `#abc`
+- Priority: Blocker | Major | Minor
+
+---------------------------------------------------------------
+## Bug
+
+**Target**
+K64F|??
+
+**Toolchain:**
+GCC_ARM|ARM|IAR
+
+**Toolchain version:**
+
+**mbed-cli version:** 
+(`mbed --version`)
+
+**meed-os sha:**
+(`git log -n1 --oneline`)
+
+**DAPLink version:**
+
+**Expected behavior**
+
+**Actual behavior**
+
+**Steps to reproduce**
+
+----------------------------------------------------------------
+## Enhancement
+
+**Reason to enhance or problem with existing solution**
+
+**Suggested enhancement**
+
+**Pros**
+
+**Cons**
+
+-----------------------------------------------------------------
+
+## Question
+
+**How to?**

.github/pull_request_template.md

@@ -0,0 +1,39 @@
+Notes:
+* Pull requests will not be accepted until the submitter has agreed to the [contributer agreement](https://github.com/ARMmbed/mbed-os/blob/master/CONTRIBUTING.md).
+* This is just a template, so feel free to use/remove the unnecessary things
+
+## Description
+A few sentences describing the overall goals of the pull request's commits.
+
+
+## Status
+**READY/IN DEVELOPMENT/HOLD**
+
+
+## Migrations
+If this PR changes any APIs or behaviors, give a short description of what *API users* should do when this PR is merged.
+
+YES | NO
+
+
+## Related PRs
+List related PRs against other branches:
+
+branch | PR
+------ | ------
+other_pr_production | [link]()
+other_pr_master | [link]()
+
+
+## Todos
+- [ ] Tests
+- [ ] Documentation
+
+
+## Deploy notes
+Notes regarding the deployment of this PR. These should note any
+required changes in the build environment, tools, compilers, etc.
+
+
+## Steps to test or reproduce
+Outline the steps to test or reproduce the PR here.

.pylintrc

@@ -0,0 +1,2 @@
+[Format]
+max-line-length=80

.travis.yml

@@ -3,6 +3,7 @@ python:
 
 script:
   - PYTHONPATH=. python tools/test/config_test/config_test.py
+  - python tools/test/pylint.py
   - py.test tools/test/toolchains/api.py
   - python tools/build_travis.py
 before_install:
@@ -17,3 +18,4 @@ install:
   - sudo pip install prettytable
   - sudo pip install jinja2
   - sudo pip install pytest
+  - sudo pip install pylint

README.md

@@ -8,7 +8,7 @@ mbed OS accelerates the process of creating a connected product by providing a p
 
 Our current release series is mbed OS 5.1:
 
-- [Release Note](https://docs.mbed.com/docs/mbed-os-release-notes/en/latest/5_1/release)
+- [Release Note](https://docs.mbed.com/docs/mbed-os-release-notes/en/latest/5_1/release/)
 
 ## Getting Started for Developers
 
@@ -20,4 +20,4 @@ We have a getting started guide for developers using mbed OS in applications:
 
 We have a getting started guide for contributors working on mbed OS:
 
-- Have a look in the docs directory
+- Have a look in the docs directory

TESTS/host_tests/timing_drift_auto.py

@@ -0,0 +1,106 @@
+"""
+mbed SDK
+Copyright (c) 2011-2013 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 mbed_host_tests import BaseHostTest
+
+
+class TimingDriftTest(BaseHostTest):
+    """ This test is reading single characters from stdio
+        and measures time between their occurrences.
+    """
+    __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))
+
+
+    def setup(self):
+        self.register_callback("end", self._callback_end)
+        self.register_callback('tick', self._callback_tick)
+
+
+    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
+        else:
+            self.__result = True
+
+        return self.__result
+
+
+    def teardown(self):
+        pass

TESTS/mbed_drivers/lp_timeout/main.cpp

@@ -0,0 +1,136 @@
+/* mbed Microcontroller Library
+ * Copyright (c) 2016 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.
+ */
+
+#if !DEVICE_LOWPOWERTIMER
+    #error [NOT_SUPPORTED] Low power timer not supported for this target
+#endif
+
+#include "utest/utest.h"
+#include "unity/unity.h"
+#include "greentea-client/test_env.h"
+
+#include "mbed.h"
+#include "us_ticker_api.h"
+
+using namespace utest::v1;
+
+volatile static bool complete;
+static LowPowerTimeout lpt;
+
+/* Timeouts are quite arbitrary due to large number of boards with varying level of accuracy */
+#define LONG_TIMEOUT (100000)
+#define SHORT_TIMEOUT (600)
+
+void cb_done() {
+    complete = true;
+}
+
+#if DEVICE_SLEEP
+void lp_timeout_1s_deepsleep(void)
+{
+    complete = false;
+
+    /* 
+     * We use here lp_ticker_read() instead of us_ticker_read() for start and 
+     * end because the microseconds timer might be disable during deepsleep.
+     */
+    timestamp_t start = lp_ticker_read();
+    lpt.attach(&cb_done, 1);
+    deepsleep();
+    while (!complete);
+    timestamp_t end = lp_ticker_read();
+
+    /* It takes longer to wake up from deep sleep */
+    TEST_ASSERT_UINT32_WITHIN(LONG_TIMEOUT, 1000000, end - start);
+    TEST_ASSERT_TRUE(complete);
+}
+
+void lp_timeout_1s_sleep(void)
+{
+    complete = false;
+
+    timestamp_t start = us_ticker_read();
+    lpt.attach(&cb_done, 1);
+    sleep();
+    while (!complete);
+    timestamp_t end = us_ticker_read();
+
+    TEST_ASSERT_UINT32_WITHIN(LONG_TIMEOUT, 1000000, end - start);
+    TEST_ASSERT_TRUE(complete);
+}
+#endif /* DEVICE_SLEEP */
+
+void lp_timeout_us(uint32_t delay_us, uint32_t tolerance)
+{
+    complete = false;
+
+    timestamp_t start = us_ticker_read();
+    lpt.attach_us(&cb_done, delay_us);
+    while (!complete);
+    timestamp_t end = us_ticker_read();
+
+    /* Using RTC which is less accurate */
+    TEST_ASSERT_UINT32_WITHIN(tolerance, delay_us, end - start);
+    TEST_ASSERT_TRUE(complete);
+}
+
+void lp_timeout_5s(void)
+{
+    lp_timeout_us(5000000, LONG_TIMEOUT);
+}
+
+void lp_timeout_1s(void)
+{
+    lp_timeout_us(1000000, LONG_TIMEOUT);
+}
+
+void lp_timeout_1ms(void)
+{
+    lp_timeout_us(1000, SHORT_TIMEOUT);
+}
+
+void lp_timeout_500us(void)
+{
+    lp_timeout_us(500, SHORT_TIMEOUT);
+
+}
+
+status_t greentea_failure_handler(const Case *const source, const failure_t reason) {
+    greentea_case_failure_abort_handler(source, reason);
+    return STATUS_CONTINUE;
+}
+
+Case cases[] = {
+    Case("500us LowPowerTimeout", lp_timeout_500us, greentea_failure_handler),
+    Case("1ms LowPowerTimeout", lp_timeout_1ms, greentea_failure_handler),
+    Case("1sec LowPowerTimeout", lp_timeout_1s, greentea_failure_handler),
+    Case("5sec LowPowerTimeout", lp_timeout_5s, greentea_failure_handler),
+#if DEVICE_SLEEP
+    Case("1sec LowPowerTimeout from sleep", lp_timeout_1s_sleep, greentea_failure_handler),
+    Case("1sec LowPowerTimeout from deepsleep", lp_timeout_1s_deepsleep, greentea_failure_handler),
+#endif /* DEVICE_SLEEP */
+};
+
+status_t greentea_test_setup(const size_t number_of_cases) {
+    GREENTEA_SETUP(20, "default_auto");
+    return greentea_test_setup_handler(number_of_cases);
+}
+
+Specification specification(greentea_test_setup, cases, greentea_test_teardown_handler);
+
+int main() {
+    Harness::run(specification);
+}