Merge multi-tasking and bootloader from /develop

ADD multi-tasking and bootloader

.mbedignore

@@ -15,3 +15,4 @@ mbed-os/features/frameworks/mbed-client-cli/*
 mbed-os/features/frameworks/COMPONENT_FPGA_CI_TEST_SHIELD/*
 mbed-os/platform/randlib/*
 mbed-os/storage/kvstore/*
+mbed-os-bootloader/*

.pre-commit-config.yaml

@@ -22,5 +22,5 @@ repos:
       - id: cppcheck
         name: cppcheck
         require_serial: true
-        entry: cppcheck --enable=all --suppress=missingInclude --suppress=missingIncludeSystem --suppress=unusedFunction --inline-suppr -i mbed-os --std=c++14 --error-exitcode=1
+        entry: cppcheck --enable=all --suppress=missingInclude --suppress=missingIncludeSystem --inline-suppr -i mbed-os --std=c++14 --error-exitcode=1
         language: system

TESTS/bike-computer/bike-system/main.cpp

@@ -261,8 +261,8 @@ static void test_reset_multi_tasking_bike_system() {
         TEST_ASSERT_TRUE(responseTime.count() <= kMaxExpectedResponseTime.count());
 
         // jitter of 20us is accepted
-        constexpr uint64_t kDeltaUs = 3;
-        constexpr std::chrono::microseconds kMaxExpectedJitter(2);
+        constexpr uint64_t kDeltaUs = 4;
+        constexpr std::chrono::microseconds kMaxExpectedJitter(3);
         if (i > 0) {
             auto jitter = responseTime - lastResponseTime;
             tr_info("Reset task: jitter is %lld usecs\n", std::abs(jitter.count()));

common/constants.hpp

@@ -36,7 +36,7 @@ static constexpr uint8_t kMaxGear = 9;
 // smallest gear (= 1) corresponds to a gear size of 20
 // when the gear increases, the gear size descreases
 static constexpr uint8_t kMaxGearSize = 20;
-static constexpr uint8_t kMinGearSize = kMaxGearSize - kMinGear;
+static constexpr uint8_t kMinGearSize = kMaxGearSize - kMaxGear;
 
 // pedal related constants
 // When compiling and linking with gcc, we get a link error when using static

common/speedometer.cpp

@@ -25,10 +25,9 @@
 #include "speedometer.hpp"
 
 #include <chrono>
+#include <cstddef>
 #include <ratio>
 
-#include "static_scheduling/gear_device.hpp"
-
 // from disco_h747i/wrappers
 #include "joystick.hpp"
 #include "mbed_trace.h"
@@ -81,7 +80,9 @@ float Speedometer::getDistance() {
 
 void Speedometer::reset() {
 #if defined(MBED_TEST_MODE)
-    _cbOnReset();
+    if (_cbOnReset != NULL) {
+        _cbOnReset();
+    }
 #endif
 
     this->_totalDistanceMutex.lock();

common/speedometer.hpp

@@ -55,7 +55,7 @@ class Speedometer {
     float getTraySize() const;
     std::chrono::milliseconds getCurrentPedalRotationTime() const;
     void setOnResetCallback(mbed::Callback<void()> cb);
-    mbed::Callback<void()> _cbOnReset;
+    mbed::Callback<void()> _cbOnReset = NULL;
 #endif  // defined(MBED_TEST_MODE)
 
    private:
@@ -80,7 +80,7 @@ class Speedometer {
     float _currentSpeed = 0.0f;
     Mutex _totalDistanceMutex;
     float _totalDistance = 0.0f;
-    uint8_t _gearSize    = bike_computer::kMinGearSize;
+    uint8_t _gearSize    = bike_computer::kMaxGearSize;
 
 #if defined(MBED_TEST_MODE)
     mbed::Callback<void()> _cb;

main.cpp

@@ -7,8 +7,9 @@
 
 #include "mbed.h"        // NOLINT
 #include "mbed_trace.h"  // NOLINT
-// #include "static_scheduling_with_event/bike_system.hpp"
-#include "multi_tasking/bike_system.hpp"
+// #include "static_scheduling/bike_system.hpp"
+#include "static_scheduling_with_event/bike_system.hpp"
+// #include "multi_tasking/bike_system.hpp"
 
 #if defined(MBED_CONF_MBED_TRACE_ENABLE)
 #define TRACE_GROUP "MAIN"
@@ -21,11 +22,12 @@ int main() {
 
     // static_scheduling::BikeSystem bikeSystem;
     // bikeSystem.start();
-    // static_scheduling_with_event::BikeSystem bikeSystem;
-    // bikeSystem.start();
 
-    multi_tasking::BikeSystem bikeSystem;
+    static_scheduling_with_event::BikeSystem bikeSystem;
     bikeSystem.start();
+
+    // multi_tasking::BikeSystem bikeSystem;
+    // bikeSystem.start();
 }
 
 #endif  // MBED_TEST_MODE

mbed-os-bootloader/.clang-format

@@ -0,0 +1,12 @@
+---
+BasedOnStyle: Google
+IndentWidth: 4
+---
+Language: Cpp
+ColumnLimit: 90
+AlignConsecutiveAssignments: true
+DerivePointerAlignment: false
+PointerAlignment: Left
+BinPackArguments: false
+BinPackParameters: false
+IndentAccessModifiers: false

mbed-os-bootloader/.gitignore

@@ -0,0 +1,8 @@
+.build
+.mbed
+projectfiles
+*.py*
+mbed-os
+BUILD
+!BUILD/DISCO_H747I/GCC_ARM/mbed-os-bootloader.bin
+

mbed-os-bootloader/.mbedignore

@@ -0,0 +1,17 @@
+mbed-os/drivers/device_key/*
+mbed-os/drivers/source/usb/USBMSD.cpp
+mbed-os/drivers/source/SFDP.cpp
+mbed-os/connectivity/cellular/*
+mbed-os/connectivity/drivers/*
+mbed-os/connectivity/FEATURE_BLE/*
+mbed-os/connectivity/libraries/*
+mbed-os/connectivity/lorawan/*
+mbed-os/connectivity/lwipstack/*
+mbed-os/connectivity/nanostack/*
+mbed-os/connectivity/netsocket/*
+mbed-os/connectivity/nfc/*
+mbed-os/features/FEATURE_BOOTLOADER/*
+mbed-os/features/frameworks/mbed-client-cli/*
+mbed-os/features/frameworks/COMPONENT_FPGA_CI_TEST_SHIELD/*
+mbed-os/platform/randlib/*
+mbed-os/storage/kvstore/*

mbed-os-bootloader/.pre-commit-config.yaml

@@ -0,0 +1,26 @@
+files: ^main.cpp
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.3.0
+    hooks:
+      - id: check-yaml
+        args: [--allow-multiple-documents]
+      - id: end-of-file-fixer
+      - id: trailing-whitespace
+  - repo: https://github.com/pre-commit/mirrors-clang-format
+    rev: "v14.0.6"
+    hooks:
+      - id: clang-format
+  - repo: https://github.com/cpplint/cpplint
+    rev: "1.6.1"
+    hooks:
+      - id: cpplint
+        name: cpplint
+        entry: cpplint --linelength=90 --filter=-build/include_subdir,-whitespace/indent,-build/namespaces,-build/c++11
+  - repo: local
+    hooks:
+      - id: cppcheck
+        name: cppcheck
+        require_serial: true
+        entry: cppcheck --enable=all --suppress=missingInclude --inline-suppr -i mbed-os --std=c++14 --error-exitcode=1
+        language: system

mbed-os-bootloader/main.cpp

@@ -0,0 +1,35 @@
+#include "mbed.h"
+
+#include "mbed_trace.h"
+#if MBED_CONF_MBED_TRACE_ENABLE
+#define TRACE_GROUP "bootloader"
+#endif // MBED_CONF_MBED_TRACE_ENABLE
+
+#if MBED_CONF_MBED_TRACE_ENABLE
+static UnbufferedSerial g_uart(CONSOLE_TX, CONSOLE_RX);
+
+// Function that directly outputs to an unbuffered serial port in blocking mode.
+static void boot_debug(const char *s) {
+    size_t len = strlen(s);
+    g_uart.write(s, len);
+    g_uart.write("\r\n", 2);
+}
+#endif
+
+int main() {
+#if MBED_CONF_MBED_TRACE_ENABLE
+    mbed_trace_init();
+    mbed_trace_print_function_set(boot_debug);
+#endif // MBED_CONF_MBED_TRACE_ENABLE
+
+    tr_debug("BikeComputer bootloader\r\n");
+
+    // at this stage we directly branch to the main application
+    void *sp = *((void **) POST_APPLICATION_ADDR + 0);  // NOLINT(readability/casting)
+    void *pc = *((void **) POST_APPLICATION_ADDR + 1);  // NOLINT(readability/casting)
+    tr_debug("Starting application at address 0x%08x (sp 0x%08x, pc 0x%08x)\r\n", POST_APPLICATION_ADDR, (uint32_t) sp, (uint32_t) pc);
+
+    mbed_start_application(POST_APPLICATION_ADDR);
+
+    return 0;
+}

mbed-os-bootloader/mbed-os.lib

@@ -0,0 +1 @@
+https://github.com/ARMmbed/mbed-os.git#17dc3dc2e6e2817a8bd3df62f38583319f0e4fed

mbed-os-bootloader/mbed_app.json

@@ -0,0 +1,28 @@
+{
+    "macros": [
+      "MBED_CONF_MBED_TRACE_FEA_IPV6=0"
+    ],
+    "config": {
+      "main-stack-size": {
+       "value": 4096
+      }
+    },
+    "target_overrides": {
+      "*": {
+        "mbed-trace.enable": false,
+        "platform.stdio-convert-newlines": true,
+        "platform.stdio-baud-rate": 115200,
+        "platform.default-serial-baud-rate": 115200,
+        "platform.stdio-buffered-serial": true,
+        "platform.all-stats-enabled": true,
+        "target.printf_lib":"minimal-printf",
+        "platform.minimal-printf-enable-floating-point": true,
+        "platform.minimal-printf-set-floating-point-max-decimals": 2
+      },
+      "DISCO_H747I": {
+        "target.restrict_size": "0x20000",
+        "mbed-trace.enable": true,
+        "mbed-trace.max-level": "TRACE_LEVEL_DEBUG"
+      }
+    }
+  }

mbed_app.json

@@ -2,7 +2,7 @@
   "macros": ["MBED_CONF_MBED_TRACE_FEA_IPV6=0"],
   "config": {
     "main-stack-size": {
-      "value": 6144
+      "value": 8192
     }
   },
   "target_overrides": {
@@ -19,7 +19,9 @@
     },
     "DISCO_H747I": {
       "mbed-trace.enable": true,
-      "mbed-trace.max-level": "TRACE_LEVEL_DEBUG"
+      "mbed-trace.max-level": "TRACE_LEVEL_DEBUG",
+      "target.bootloader_img": "./mbed-os-bootloader/BUILD/DISCO_H747I/GCC_ARM/mbed-os-bootloader.bin",
+      "target.app_offset": "0x20000"
     }
   }
 }

multi_tasking/bike_system.cpp

@@ -39,27 +39,16 @@
 
 namespace multi_tasking {
 
-static constexpr std::chrono::milliseconds kGearTaskPeriod          = 800ms;
-static constexpr std::chrono::milliseconds kGearTaskDelay           = 0ms;
-static constexpr std::chrono::milliseconds kGearTaskComputationTime = 100ms;
-static constexpr std::chrono::milliseconds kSpeedDistanceTaskPeriod = 400ms;
-static constexpr std::chrono::milliseconds kSpeedDistanceTaskDelay  = 0ms;  // 0 or 100ms
+static constexpr std::chrono::milliseconds kGearTaskComputationTime          = 100ms;
 static constexpr std::chrono::milliseconds kSpeedDistanceTaskComputationTime = 200ms;
 static constexpr std::chrono::milliseconds kDisplayTask1Period               = 1600ms;
 static constexpr std::chrono::milliseconds kDisplayTask1Delay                = 300ms;
 static constexpr std::chrono::milliseconds kDisplayTask1ComputationTime      = 200ms;
-static constexpr std::chrono::milliseconds kResetTaskPeriod                  = 800ms;
-static constexpr std::chrono::milliseconds kResetTaskDelay                   = 700ms;
-static constexpr std::chrono::milliseconds kResetTaskComputationTime         = 100ms;
 static constexpr std::chrono::milliseconds kTemperatureTaskPeriod            = 1600ms;
 static constexpr std::chrono::milliseconds kTemperatureTaskDelay             = 1100ms;
 static constexpr std::chrono::milliseconds kTemperatureTaskComputationTime   = 100ms;
-static constexpr std::chrono::milliseconds kDisplayTask2Period               = 1600ms;
-static constexpr std::chrono::milliseconds kDisplayTask2Delay                = 1200ms;
-static constexpr std::chrono::milliseconds kDisplayTask2ComputationTime      = 100ms;
 static constexpr std::chrono::milliseconds kCPUTaskPeriod                    = 1600ms;
 static constexpr std::chrono::milliseconds kCPUTaskDelay                     = 0ms;
-static constexpr std::chrono::milliseconds kCPUTaskComputationTime           = 0ms;
 
 BikeSystem::BikeSystem()
     : _timer(),

multi_tasking/bike_system.hpp

@@ -138,7 +138,7 @@ class BikeSystem {
     //////////////////////////////////////////////////////////////
     // shared resources between the main thread and the isr thread
     uint8_t _currentGear     = bike_computer::kMinGear;
-    uint8_t _currentGearSize = bike_computer::kMinGearSize;
+    uint8_t _currentGearSize = bike_computer::kMaxGearSize;
     //////////////////////////////////////////////////////////////
 
     // data member that represents the device for manipulating the pedal rotation

static_scheduling/bike_system.cpp

@@ -61,7 +61,10 @@ BikeSystem::BikeSystem()
     : _gearDevice(_timer),
       _pedalDevice(_timer),
       _resetDevice(_timer),
+      _displayDevice(),
       _speedometer(_timer),
+      _sensorDevice(),
+      _taskLogger(),
       _cpuLogger(_timer) {}
 
 void BikeSystem::start() {
@@ -205,29 +208,18 @@ void BikeSystem::speedDistanceTask() {
         _timer, advembsof::TaskLogger::kSpeedTaskIndex, taskStartTime);
 }
 
-void BikeSystem::temperatureTask() {
+void BikeSystem::displayTask1() {
     auto taskStartTime = _timer.elapsed_time();
 
-    tr_warn("Tick1 %" PRIu64, _timer.elapsed_time().count());
-
-    // no need to protect access to data members (single threaded)
-    _currentTemperature = _sensorDevice.readTemperature();
-
-    tr_warn("Tick2 %" PRIu64, _timer.elapsed_time().count());
+    _displayDevice.displayGear(_currentGear);
+    _displayDevice.displaySpeed(_currentSpeed);
+    _displayDevice.displayDistance(_traveledDistance);
 
     ThisThread::sleep_for(std::chrono::duration_cast<std::chrono::milliseconds>(
-        kTemperatureTaskComputationTime - (_timer.elapsed_time() - taskStartTime)));
-
-    // simulate task computation by waiting for the required task computation time
-
-    //    std::chrono::microseconds elapsedTime =
-    //    std::chrono::microseconds::zero(); while (elapsedTime <
-    //    kTemperatureTaskComputationTime) {
-    //        elapsedTime = _timer.elapsed_time() - taskStartTime;
-    //    }
+        kDisplayTask1ComputationTime - (_timer.elapsed_time() - taskStartTime)));
 
     _taskLogger.logPeriodAndExecutionTime(
-        _timer, advembsof::TaskLogger::kTemperatureTaskIndex, taskStartTime);
+        _timer, advembsof::TaskLogger::kDisplayTask1Index, taskStartTime);
 }
 
 void BikeSystem::resetTask() {
@@ -243,27 +235,17 @@ void BikeSystem::resetTask() {
     _taskLogger.logPeriodAndExecutionTime(
         _timer, advembsof::TaskLogger::kResetTaskIndex, taskStartTime);
 }
-
-void BikeSystem::displayTask1() {
+void BikeSystem::temperatureTask() {
     auto taskStartTime = _timer.elapsed_time();
 
-    _displayDevice.displayGear(_currentGear);
-    _displayDevice.displaySpeed(_currentSpeed);
-    _displayDevice.displayDistance(_traveledDistance);
+    // no need to protect access to data members (single threaded)
+    _currentTemperature = _sensorDevice.readTemperature();
 
     ThisThread::sleep_for(std::chrono::duration_cast<std::chrono::milliseconds>(
-        kDisplayTask1ComputationTime - (_timer.elapsed_time() - taskStartTime)));
-
-    // simulate task computation by waiting for the required task computation time
-
-    //    std::chrono::microseconds elapsedTime =
-    //    std::chrono::microseconds::zero(); while (elapsedTime <
-    //    kDisplayTask1ComputationTime) {
-    //        elapsedTime = _timer.elapsed_time() - taskStartTime;
-    //    }
+        kTemperatureTaskComputationTime - (_timer.elapsed_time() - taskStartTime)));
 
     _taskLogger.logPeriodAndExecutionTime(
-        _timer, advembsof::TaskLogger::kDisplayTask1Index, taskStartTime);
+        _timer, advembsof::TaskLogger::kTemperatureTaskIndex, taskStartTime);
 }
 
 void BikeSystem::displayTask2() {
@@ -274,13 +256,6 @@ void BikeSystem::displayTask2() {
     ThisThread::sleep_for(std::chrono::duration_cast<std::chrono::milliseconds>(
         kDisplayTask2ComputationTime - (_timer.elapsed_time() - taskStartTime)));
 
-    // simulate task computation by waiting for the required task computation time
-
-    //    std::chrono::microseconds elapsedTime =
-    //    std::chrono::microseconds::zero(); while (elapsedTime <
-    //    kDisplayTask2ComputationTime) {
-    //        elapsedTime = _timer.elapsed_time() - taskStartTime;
-    //    }
     _taskLogger.logPeriodAndExecutionTime(
         _timer, advembsof::TaskLogger::kDisplayTask2Index, taskStartTime);
 }

static_scheduling/bike_system.hpp

@@ -80,7 +80,7 @@ class BikeSystem {
     // data member that represents the device for manipulating the gear
     GearDevice _gearDevice;
     uint8_t _currentGear     = bike_computer::kMinGear;
-    uint8_t _currentGearSize = bike_computer::kMinGearSize;
+    uint8_t _currentGearSize = bike_computer::kMaxGearSize;
     // data member that represents the device for manipulating the pedal rotation
     // speed/time
     PedalDevice _pedalDevice;

static_scheduling/pedal_device.cpp

@@ -37,7 +37,7 @@ namespace static_scheduling {
 
 static constexpr std::chrono::microseconds kTaskRunTime = 200000us;
 
-PedalDevice::PedalDevice(Timer& timer) : _timer(timer) {}
+PedalDevice::PedalDevice(Timer& timer) : _timer(timer), _pedalRotationTime(0) {}
 
 std::chrono::milliseconds PedalDevice::getCurrentRotationTime() {
     std::chrono::microseconds initialTime = _timer.elapsed_time();

static_scheduling/pedal_device.hpp

@@ -46,9 +46,9 @@ class PedalDevice {
     void decreaseRotationSpeed();
 
     // data members
+    Timer& _timer;
     std::chrono::milliseconds _pedalRotationTime =
         bike_computer::kInitialPedalRotationTime;
-    Timer& _timer;
 };
 
 }  // namespace static_scheduling

static_scheduling/reset_device.cpp

@@ -43,7 +43,8 @@ namespace static_scheduling {
 
 static constexpr std::chrono::microseconds kTaskRunTime = 100000us;
 
-ResetDevice::ResetDevice(Timer& timer) : _timer(timer), _resetButton(PUSH_BUTTON) {
+ResetDevice::ResetDevice(Timer& timer)
+    : _resetButton(PUSH_BUTTON), _timer(timer), _pressTime(0) {
     _resetButton.rise(callback(this, &ResetDevice::onRise));
 }
 

static_scheduling_with_event/bike_system.cpp

@@ -67,7 +67,10 @@ BikeSystem::BikeSystem()
     : _gearDevice(),
       _pedalDevice(),
       _resetDevice(callback(this, &BikeSystem::onReset)),
+      _displayDevice(),
       _speedometer(_timer),
+      _sensorDevice(),
+      _taskLogger(),
       _cpuLogger(_timer) {}
 
 void BikeSystem::start() {
@@ -176,21 +179,18 @@ void BikeSystem::speedDistanceTask() {
         _timer, advembsof::TaskLogger::kSpeedTaskIndex, taskStartTime);
 }
 
-void BikeSystem::temperatureTask() {
+void BikeSystem::displayTask1() {
     auto taskStartTime = _timer.elapsed_time();
 
-    // tr_warn("Tick1 %" PRIu64, _timer.elapsed_time().count());
-
-    // no need to protect access to data members (single threaded)
-    _currentTemperature = _sensorDevice.readTemperature();
-
-    // tr_warn("Tick2 %" PRIu64, _timer.elapsed_time().count());
+    _displayDevice.displayGear(_currentGear);
+    _displayDevice.displaySpeed(_currentSpeed);
+    _displayDevice.displayDistance(_traveledDistance);
 
     ThisThread::sleep_for(std::chrono::duration_cast<std::chrono::milliseconds>(
-        kTemperatureTaskComputationTime - (_timer.elapsed_time() - taskStartTime)));
+        kDisplayTask1ComputationTime - (_timer.elapsed_time() - taskStartTime)));
 
     _taskLogger.logPeriodAndExecutionTime(
-        _timer, advembsof::TaskLogger::kTemperatureTaskIndex, taskStartTime);
+        _timer, advembsof::TaskLogger::kDisplayTask1Index, taskStartTime);
 }
 
 void BikeSystem::resetTask() {
@@ -208,18 +208,17 @@ void BikeSystem::resetTask() {
         _timer, advembsof::TaskLogger::kResetTaskIndex, taskStartTime);
 }
 
-void BikeSystem::displayTask1() {
+void BikeSystem::temperatureTask() {
     auto taskStartTime = _timer.elapsed_time();
 
-    _displayDevice.displayGear(_currentGear);
-    _displayDevice.displaySpeed(_currentSpeed);
-    _displayDevice.displayDistance(_traveledDistance);
+    // no need to protect access to data members (single threaded)
+    _currentTemperature = _sensorDevice.readTemperature();
 
     ThisThread::sleep_for(std::chrono::duration_cast<std::chrono::milliseconds>(
-        kDisplayTask1ComputationTime - (_timer.elapsed_time() - taskStartTime)));
+        kTemperatureTaskComputationTime - (_timer.elapsed_time() - taskStartTime)));
 
     _taskLogger.logPeriodAndExecutionTime(
-        _timer, advembsof::TaskLogger::kDisplayTask1Index, taskStartTime);
+        _timer, advembsof::TaskLogger::kTemperatureTaskIndex, taskStartTime);
 }
 
 void BikeSystem::displayTask2() {

static_scheduling_with_event/bike_system.hpp

@@ -85,7 +85,7 @@ class BikeSystem {
     // data member that represents the device for manipulating the gear
     GearDevice _gearDevice;
     uint8_t _currentGear     = bike_computer::kMinGear;
-    uint8_t _currentGearSize = bike_computer::kMinGearSize;
+    uint8_t _currentGearSize = bike_computer::kMaxGearSize;
     // data member that represents the device for manipulating the pedal rotation
     // speed/time
     PedalDevice _pedalDevice;