Klagarge/BikeComputer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Activity

ADD modification from issue

Browse Source
This commit is contained in:
fastium 2024-12-30 17:38:02 +01:00
commit 4c9a0e25a7
23 changed files with 449 additions and 429 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
.pre-commit-config.yaml
View File

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

22
TESTS/bike-computer/bike-system/main.cpp
View File

@ -24,16 +24,16 @@
#include <chrono> #include <chrono>
#include "static_scheduling/bike_system.hpp"
#include "static_scheduling_with_event/bike_system.hpp"
#include "greentea-client/test_env.h" #include "greentea-client/test_env.h"
#include "mbed.h" #include "mbed.h"
#include "static_scheduling/bike_system.hpp"
#include "static_scheduling_with_event/bike_system.hpp"
#include "task_logger.hpp" #include "task_logger.hpp"
#include "unity/unity.h" #include "unity/unity.h"
#include "utest/utest.h" #include "utest/utest.h"
using namespace utest::v1; namespace utest {
namespace v1 {
// test_bike_system handler function // test_bike_system handler function
static void test_bike_system() { static void test_bike_system() {
@ -80,7 +80,8 @@ static void test_bike_system_event_queue() {
// run the bike system in a separate thread // run the bike system in a separate thread
Thread thread; Thread thread;
thread.start(callback(&bikeSystem, &static_scheduling::BikeSystem::startWithEventQueue)); thread.start(
callback(&bikeSystem, &static_scheduling::BikeSystem::startWithEventQueue));
// let the bike system run for 20 secs // let the bike system run for 20 secs
ThisThread::sleep_for(20s); ThisThread::sleep_for(20s);
@ -139,9 +140,9 @@ static void test_bike_system_with_event() {
} }
} }
static utest::v1::status_t greentea_setup(const size_t number_of_cases) { static status_t greentea_setup(const size_t number_of_cases) {
// Here, we specify the timeout (60s) and the host test (a built-in host test or the // Here, we specify the timeout (60s) and the host test (a built-in host test
// name of our Python file) // or the name of our Python file)
GREENTEA_SETUP(180, "default_auto"); GREENTEA_SETUP(180, "default_auto");
return greentea_test_setup_handler(number_of_cases); return greentea_test_setup_handler(number_of_cases);
@ -156,4 +157,7 @@ static Case cases[] = {
static Specification specification(greentea_setup, cases); static Specification specification(greentea_setup, cases);
int main() { return !Harness::run(specification); } }; // namespace v1
}; // namespace utest
int main() { return !utest::v1::Harness::run(utest::v1::specification); }

13
TESTS/bike-computer/sensor-device/main.cpp
View File

@ -29,7 +29,8 @@
#include "unity/unity.h" #include "unity/unity.h"
#include "utest/utest.h" #include "utest/utest.h"
using namespace utest::v1; namespace utest {
namespace v1 {
// test_hdc1000 test handler function // test_hdc1000 test handler function
static control_t test_sensor_device(const size_t call_count) { static control_t test_sensor_device(const size_t call_count) {
@ -53,9 +54,9 @@ static control_t test_sensor_device(const size_t call_count) {
return CaseNext; return CaseNext;
} }
static utest::v1::status_t greentea_setup(const size_t number_of_cases) { static status_t greentea_setup(const size_t number_of_cases) {
// Here, we specify the timeout (60s) and the host test (a built-in host test or the // Here, we specify the timeout (60s) and the host test (a built-in host test
// name of our Python file) // or the name of our Python file)
GREENTEA_SETUP(60, "default_auto"); GREENTEA_SETUP(60, "default_auto");
return greentea_test_setup_handler(number_of_cases); return greentea_test_setup_handler(number_of_cases);
@ -65,5 +66,7 @@ static utest::v1::status_t greentea_setup(const size_t number_of_cases) {
static Case cases[] = {Case("test sensor device", test_sensor_device)}; static Case cases[] = {Case("test sensor device", test_sensor_device)};
static Specification specification(greentea_setup, cases); static Specification specification(greentea_setup, cases);
}; // namespace v1
}; // namespace utest
int main() { return !Harness::run(specification); } int main() { return !utest::v1::Harness::run(utest::v1::specification); }

21
TESTS/bike-computer/speedometer/main.cpp
View File

@ -32,13 +32,14 @@
#include "unity/unity.h" #include "unity/unity.h"
#include "utest/utest.h" #include "utest/utest.h"
using namespace utest::v1;
// allow for 0.1 km/h difference // allow for 0.1 km/h difference
static constexpr float kAllowedSpeedDelta = 0.1f; static constexpr float kAllowedSpeedDelta = 0.1f;
// allow for 1m difference // allow for 1m difference
static constexpr float kAllowedDistanceDelta = 1.0f / 1000.0; static constexpr float kAllowedDistanceDelta = 1.0f / 1000.0;
namespace utest {
namespace v1 {
// function called by test handler functions for verifying the current speed // function called by test handler functions for verifying the current speed
void check_current_speed(const std::chrono::milliseconds& pedalRotationTime, void check_current_speed(const std::chrono::milliseconds& pedalRotationTime,
uint8_t traySize, uint8_t traySize,
@ -75,7 +76,8 @@ float compute_distance(const std::chrono::milliseconds& pedalRotationTime,
float trayGearRatio = static_cast<float>(traySize) / static_cast<float>(gearSize); float trayGearRatio = static_cast<float>(traySize) / static_cast<float>(gearSize);
float distancePerPedalTurn = trayGearRatio * wheelCircumference; float distancePerPedalTurn = trayGearRatio * wheelCircumference;
// distancePerPedalTurn is expressed in m, divide per 1000 for a distance in km // distancePerPedalTurn is expressed in m, divide per 1000 for a distance in
// km
return (distancePerPedalTurn * pedalRotations) / 1000.0; return (distancePerPedalTurn * pedalRotations) / 1000.0;
} }
@ -86,7 +88,8 @@ void check_distance(const std::chrono::milliseconds& pedalRotationTime,
float wheelCircumference, float wheelCircumference,
const std::chrono::milliseconds& travelTime, const std::chrono::milliseconds& travelTime,
float distance) { float distance) {
// distancePerPedalTurn is expressed in m, divide per 1000 for a distance in km // distancePerPedalTurn is expressed in m, divide per 1000 for a distance in
// km
float expectedDistance = compute_distance( float expectedDistance = compute_distance(
pedalRotationTime, traySize, gearSize, wheelCircumference, travelTime); pedalRotationTime, traySize, gearSize, wheelCircumference, travelTime);
printf(" Expected distance is %f, current distance is %f\n", printf(" Expected distance is %f, current distance is %f\n",
@ -334,9 +337,9 @@ static control_t test_reset(const size_t call_count) {
return CaseNext; return CaseNext;
} }
static utest::v1::status_t greentea_setup(const size_t number_of_cases) { static status_t greentea_setup(const size_t number_of_cases) {
// Here, we specify the timeout (60s) and the host test (a built-in host test or the // Here, we specify the timeout (60s) and the host test (a built-in host test
// name of our Python file) // or the name of our Python file)
GREENTEA_SETUP(180, "default_auto"); GREENTEA_SETUP(180, "default_auto");
return greentea_test_setup_handler(number_of_cases); return greentea_test_setup_handler(number_of_cases);
@ -350,5 +353,7 @@ static Case cases[] = {
Case("test speedometer reset", test_reset)}; Case("test speedometer reset", test_reset)};
static Specification specification(greentea_setup, cases); static Specification specification(greentea_setup, cases);
}; // namespace v1
}; // namespace utest
int main() { return !Harness::run(specification); } int main() { return !utest::v1::Harness::run(utest::v1::specification); }

14
TESTS/simple-test/always-succeed/main.cpp
View File

@ -27,7 +27,8 @@
#include "unity/unity.h" #include "unity/unity.h"
#include "utest/utest.h" #include "utest/utest.h"
using namespace utest::v1; namespace utest {
namespace v1 {
// test handler function // test handler function
static control_t always_succeed(const size_t call_count) { static control_t always_succeed(const size_t call_count) {
@ -38,9 +39,9 @@ static control_t always_succeed(const size_t call_count) {
return CaseNext; return CaseNext;
} }
static utest::v1::status_t greentea_setup(const size_t number_of_cases) { static status_t greentea_setup(const size_t number_of_cases) {
// Here, we specify the timeout (60s) and the host test (a built-in host test or the // Here, we specify the timeout (60s) and the host test (a built-in host test
// name of our Python file) // or the name of our Python file)
GREENTEA_SETUP(60, "default_auto"); GREENTEA_SETUP(60, "default_auto");
return greentea_test_setup_handler(number_of_cases); return greentea_test_setup_handler(number_of_cases);
@ -51,4 +52,7 @@ static Case cases[] = {Case("always succeed test", always_succeed)};
static Specification specification(greentea_setup, cases); static Specification specification(greentea_setup, cases);
int main() { return !Harness::run(specification); } }; // namespace v1
}; // namespace utest
int main() { return !utest::v1::Harness::run(utest::v1::specification); }

67
TESTS/simple-test/test-ptr/main.cpp
View File

@ -24,12 +24,14 @@
* @version 0.2.0 * @version 0.2.0
***************************************************************************/ ***************************************************************************/
#include "greentea-client/test_env.h" #include "greentea-client/test_env.h" // NOLINT
#include "mbed.h" #include "mbed.h" // NOLINT
#include "unity/unity.h" #include "unity/unity.h" // NOLINT
#include "utest/utest.h" #include "utest/utest.h" // NOLINT
namespace utest {
namespace v1 {
using namespace utest::v1;
struct Test { struct Test {
Test() { Test() {
_instanceCount++; _instanceCount++;
@ -48,7 +50,8 @@ struct Test {
uint32_t Test::_instanceCount = 0; uint32_t Test::_instanceCount = 0;
/** /**
* Test that a shared pointer correctly manages the lifetime of the underlying raw pointer * Test that a shared pointer correctly manages the lifetime of the underlying
* raw pointer
*/ */
void test_single_sharedptr_lifetime() { void test_single_sharedptr_lifetime() {
// Sanity-check value of counter // Sanity-check value of counter
@ -66,8 +69,8 @@ void test_single_sharedptr_lifetime() {
} }
/** /**
* Test that multiple instances of shared pointers correctly manage the reference count * Test that multiple instances of shared pointers correctly manage the
* to release the object at the correct point * reference count to release the object at the correct point
*/ */
void test_instance_sharing() { void test_instance_sharing() {
std::shared_ptr<Test> shared_ptr1(nullptr); std::shared_ptr<Test> shared_ptr1(nullptr);
@ -97,8 +100,8 @@ void test_instance_sharing() {
} }
/********************** /**********************
* UNIQUE PTR EXERCISE * * UNIQUE PTR EXERCISE *
**********************/ **********************/
/* /*
* Check normal lifetime on a unique_ptr * Check normal lifetime on a unique_ptr
@ -114,7 +117,7 @@ void test_single_unique_ptr_lifetime() {
TEST_ASSERT_EQUAL(Test::kMagicNumber, p1->_value); TEST_ASSERT_EQUAL(Test::kMagicNumber, p1->_value);
const uint32_t number = 42; const uint32_t number = 42;
p1->_value = number; p1->_value = number;
TEST_ASSERT_EQUAL(number, p1->_value); TEST_ASSERT_EQUAL(number, p1->_value);
p1.reset(); p1.reset();
@ -132,12 +135,12 @@ void test_unique_ptr_transfer() {
TEST_ASSERT_EQUAL(0, Test::_instanceCount); TEST_ASSERT_EQUAL(0, Test::_instanceCount);
{ {
//create p1 // create p1
std::unique_ptr<Test> p1 = std::make_unique<Test>(); std::unique_ptr<Test> p1 = std::make_unique<Test>();
TEST_ASSERT_EQUAL(Test::kMagicNumber, p1->_value); TEST_ASSERT_EQUAL(Test::kMagicNumber, p1->_value);
TEST_ASSERT_EQUAL(1, Test::_instanceCount); TEST_ASSERT_EQUAL(1, Test::_instanceCount);
//transfer p1 to p2 // transfer p1 to p2
std::unique_ptr<Test> p2 = std::move(p1); std::unique_ptr<Test> p2 = std::move(p1);
TEST_ASSERT_EQUAL(Test::kMagicNumber, p2->_value); TEST_ASSERT_EQUAL(Test::kMagicNumber, p2->_value);
TEST_ASSERT_EQUAL(1, Test::_instanceCount); TEST_ASSERT_EQUAL(1, Test::_instanceCount);
@ -145,7 +148,7 @@ void test_unique_ptr_transfer() {
p2.reset(); p2.reset();
TEST_ASSERT_EQUAL(0, Test::_instanceCount); TEST_ASSERT_EQUAL(0, Test::_instanceCount);
TEST_ASSERT(!p1); TEST_ASSERT(!p1); // cppcheck-suppress accessMoved
TEST_ASSERT(!p2); TEST_ASSERT(!p2);
} }
@ -160,13 +163,13 @@ void test_unique_ptr_release() {
TEST_ASSERT_EQUAL(0, Test::_instanceCount); TEST_ASSERT_EQUAL(0, Test::_instanceCount);
{ {
//create p1 // create p1
std::unique_ptr<Test> p1 = std::make_unique<Test>(); std::unique_ptr<Test> p1 = std::make_unique<Test>();
TEST_ASSERT_EQUAL(Test::kMagicNumber, p1->_value); TEST_ASSERT_EQUAL(Test::kMagicNumber, p1->_value);
TEST_ASSERT_EQUAL(1, Test::_instanceCount); TEST_ASSERT_EQUAL(1, Test::_instanceCount);
//transfer and release p1 to p2 // transfer and release p1 to p2
Test * p2 = p1.release(); Test* p2 = p1.release();
TEST_ASSERT_EQUAL(Test::kMagicNumber, p2->_value); TEST_ASSERT_EQUAL(Test::kMagicNumber, p2->_value);
TEST_ASSERT_EQUAL(1, Test::_instanceCount); TEST_ASSERT_EQUAL(1, Test::_instanceCount);
@ -192,21 +195,21 @@ void test_unique_ptr_swap() {
const uint32_t number1 = 65; const uint32_t number1 = 65;
const uint32_t number2 = 42; const uint32_t number2 = 42;
//create p1 // create p1
std::unique_ptr<Test> p1 = std::make_unique<Test>(); std::unique_ptr<Test> p1 = std::make_unique<Test>();
TEST_ASSERT_EQUAL(Test::kMagicNumber, p1->_value); TEST_ASSERT_EQUAL(Test::kMagicNumber, p1->_value);
TEST_ASSERT_EQUAL(1, Test::_instanceCount); TEST_ASSERT_EQUAL(1, Test::_instanceCount);
p1->_value = number1; p1->_value = number1;
TEST_ASSERT_EQUAL(number1, p1->_value); TEST_ASSERT_EQUAL(number1, p1->_value);
//create p2 // create p2
std::unique_ptr<Test> p2 = std::make_unique<Test>(); std::unique_ptr<Test> p2 = std::make_unique<Test>();
TEST_ASSERT_EQUAL(Test::kMagicNumber, p2->_value); TEST_ASSERT_EQUAL(Test::kMagicNumber, p2->_value);
TEST_ASSERT_EQUAL(2, Test::_instanceCount); TEST_ASSERT_EQUAL(2, Test::_instanceCount);
p2->_value = number2; p2->_value = number2;
TEST_ASSERT_EQUAL(number2, p2->_value); TEST_ASSERT_EQUAL(number2, p2->_value);
//swap // swap
p1.swap(p2); p1.swap(p2);
TEST_ASSERT_EQUAL(number1, p2->_value); TEST_ASSERT_EQUAL(number1, p2->_value);
@ -223,14 +226,13 @@ void test_unique_ptr_swap() {
TEST_ASSERT_EQUAL(0, Test::_instanceCount); TEST_ASSERT_EQUAL(0, Test::_instanceCount);
} }
/******************* /*******************
* RAW PTR EXERCISE * * RAW PTR EXERCISE *
*******************/ *******************/
/** /**
* Test that a shared pointer correctly manages the lifetime of the underlying raw pointer * Test that a shared pointer correctly manages the lifetime of the underlying
* raw pointer
*/ */
void test_single_raw_ptr_lifetime() { void test_single_raw_ptr_lifetime() {
// Sanity-check value of counter // Sanity-check value of counter
@ -242,12 +244,12 @@ void test_single_raw_ptr_lifetime() {
TEST_ASSERT_EQUAL(1, Test::_instanceCount); TEST_ASSERT_EQUAL(1, Test::_instanceCount);
TEST_ASSERT_EQUAL(Test::kMagicNumber, t1._value); TEST_ASSERT_EQUAL(Test::kMagicNumber, t1._value);
Test * p1 = &t1; Test* p1 = &t1;
TEST_ASSERT_EQUAL(1, Test::_instanceCount); TEST_ASSERT_EQUAL(1, Test::_instanceCount);
TEST_ASSERT_EQUAL(Test::kMagicNumber, p1->_value); TEST_ASSERT_EQUAL(Test::kMagicNumber, p1->_value);
const uint32_t number1 = 42; const uint32_t number1 = 42;
p1->_value = number1; p1->_value = number1;
TEST_ASSERT_EQUAL(number1, p1->_value); TEST_ASSERT_EQUAL(number1, p1->_value);
TEST_ASSERT_EQUAL(number1, t1._value); TEST_ASSERT_EQUAL(number1, t1._value);
@ -260,9 +262,9 @@ void test_single_raw_ptr_lifetime() {
TEST_ASSERT_EQUAL(0, Test::_instanceCount); TEST_ASSERT_EQUAL(0, Test::_instanceCount);
} }
static utest::v1::status_t greentea_setup(const size_t number_of_cases) { static status_t greentea_setup(const size_t number_of_cases) {
// Here, we specify the timeout (60s) and the host test (a built-in host test or the // Here, we specify the timeout (60s) and the host test (a built-in host test
// name of our Python file) // or the name of our Python file)
GREENTEA_SETUP(60, "default_auto"); GREENTEA_SETUP(60, "default_auto");
return greentea_test_setup_handler(number_of_cases); return greentea_test_setup_handler(number_of_cases);
} }
@ -285,4 +287,7 @@ static Case cases[] = {
static Specification specification(greentea_setup, cases); static Specification specification(greentea_setup, cases);
int main() { return !Harness::run(specification); } }; // namespace v1
}; // namespace utest
int main() { return !utest::v1::Harness::run(utest::v1::specification); }

4
common/speedometer.cpp
View File

@ -110,7 +110,7 @@ void Speedometer::computeSpeed() {
// TODO : done // TODO : done
//Distance run with one pedal turn = tray size / rear gear size * circumference of the wheel //Distance run with one pedal turn = tray size / rear gear size * circumference of the wheel
constexpr float ms_in_hour = static_cast<float>(3600 * 1000); constexpr float ms_in_hour = static_cast<float>(3600 * 1000);
float pedal_rotation_per_hour = ms_in_hour / static_cast<float>(_pedalRotationTime.count()); float pedal_rotation_per_hour = ms_in_hour / std::chrono::duration_cast<std::chrono::milliseconds>(_pedalRotationTime).count();
float gear_ratio = static_cast<float>(kTraySize) / static_cast<float>(this->_gearSize); float gear_ratio = static_cast<float>(kTraySize) / static_cast<float>(this->_gearSize);
float wheel_dist_km = static_cast<float>(this->kWheelCircumference) / 1000.0; float wheel_dist_km = static_cast<float>(this->kWheelCircumference) / 1000.0;
this->_currentSpeed = gear_ratio * wheel_dist_km * pedal_rotation_per_hour; this->_currentSpeed = gear_ratio * wheel_dist_km * pedal_rotation_per_hour;
@ -141,4 +141,4 @@ void Speedometer::computeDistance() {
_lastTime = _timer.elapsed_time(); _lastTime = _timer.elapsed_time();
} }
} // namespace bike_computer } // namespace bike_computer

182
static_scheduling/bike_system.cpp
View File

@ -35,38 +35,34 @@
namespace static_scheduling { namespace static_scheduling {
static constexpr std::chrono::milliseconds kGearTaskPeriod = 800ms; static constexpr std::chrono::milliseconds kGearTaskPeriod = 800ms;
static constexpr std::chrono::milliseconds kGearTaskDelay = 0ms; static constexpr std::chrono::milliseconds kGearTaskDelay = 0ms;
static constexpr std::chrono::milliseconds kGearTaskComputationTime = 100ms; static constexpr std::chrono::milliseconds kGearTaskComputationTime = 100ms;
static constexpr std::chrono::milliseconds kSpeedDistanceTaskPeriod = 400ms; static constexpr std::chrono::milliseconds kSpeedDistanceTaskPeriod = 400ms;
static constexpr std::chrono::milliseconds kSpeedDistanceTaskDelay = 0ms; // 0 or 100ms static constexpr std::chrono::milliseconds kSpeedDistanceTaskDelay = 0ms; // 0 or 100ms
static constexpr std::chrono::milliseconds kSpeedDistanceTaskComputationTime = 200ms; static constexpr std::chrono::milliseconds kSpeedDistanceTaskComputationTime = 200ms;
static constexpr std::chrono::milliseconds kDisplayTask1Period = 1600ms; static constexpr std::chrono::milliseconds kDisplayTask1Period = 1600ms;
static constexpr std::chrono::milliseconds kDisplayTask1Delay = 300ms; static constexpr std::chrono::milliseconds kDisplayTask1Delay = 300ms;
static constexpr std::chrono::milliseconds kDisplayTask1ComputationTime = 200ms; static constexpr std::chrono::milliseconds kDisplayTask1ComputationTime = 200ms;
static constexpr std::chrono::milliseconds kResetTaskPeriod = 800ms; static constexpr std::chrono::milliseconds kResetTaskPeriod = 800ms;
static constexpr std::chrono::milliseconds kResetTaskDelay = 700ms; static constexpr std::chrono::milliseconds kResetTaskDelay = 700ms;
static constexpr std::chrono::milliseconds kResetTaskComputationTime = 100ms; static constexpr std::chrono::milliseconds kResetTaskComputationTime = 100ms;
static constexpr std::chrono::milliseconds kTemperatureTaskPeriod = 1600ms; static constexpr std::chrono::milliseconds kTemperatureTaskPeriod = 1600ms;
static constexpr std::chrono::milliseconds kTemperatureTaskDelay = 1100ms; static constexpr std::chrono::milliseconds kTemperatureTaskDelay = 1100ms;
static constexpr std::chrono::milliseconds kTemperatureTaskComputationTime = 100ms; static constexpr std::chrono::milliseconds kTemperatureTaskComputationTime = 100ms;
static constexpr std::chrono::milliseconds kDisplayTask2Period = 1600ms; static constexpr std::chrono::milliseconds kDisplayTask2Period = 1600ms;
static constexpr std::chrono::milliseconds kDisplayTask2Delay = 1200ms; static constexpr std::chrono::milliseconds kDisplayTask2Delay = 1200ms;
static constexpr std::chrono::milliseconds kDisplayTask2ComputationTime = 100ms; static constexpr std::chrono::milliseconds kDisplayTask2ComputationTime = 100ms;
static constexpr std::chrono::milliseconds kCPUTaskPeriod = 1600ms; static constexpr std::chrono::milliseconds kCPUTaskPeriod = 1600ms;
static constexpr std::chrono::milliseconds kCPUTaskDelay = 0ms; static constexpr std::chrono::milliseconds kCPUTaskDelay = 0ms;
static constexpr std::chrono::milliseconds kCPUTaskComputationTime = 0ms; static constexpr std::chrono::milliseconds kCPUTaskComputationTime = 0ms;
BikeSystem::BikeSystem()
BikeSystem::BikeSystem() : : _gearDevice(_timer),
_gearDevice(_timer), _pedalDevice(_timer),
_pedalDevice(_timer), _resetDevice(_timer),
_resetDevice(_timer), _speedometer(_timer),
_speedometer(_timer), _cpuLogger(_timer) {}
_cpuLogger(_timer)
{
}
void BikeSystem::start() { void BikeSystem::start() {
tr_info("Starting Super-Loop without event handling"); tr_info("Starting Super-Loop without event handling");
@ -76,19 +72,17 @@ void BikeSystem::start() {
while (true) { while (true) {
auto startTime = _timer.elapsed_time(); auto startTime = _timer.elapsed_time();
gearTask(); // 100ms : 0ms -> 100ms gearTask(); // 100ms : 0ms -> 100ms
speedDistanceTask(); // 200ms : 100ms -> 300ms speedDistanceTask(); // 200ms : 100ms -> 300ms
displayTask1(); // 200ms : 300ms -> 500ms displayTask1(); // 200ms : 300ms -> 500ms
speedDistanceTask(); // 200ms : 500ms -> 700ms speedDistanceTask(); // 200ms : 500ms -> 700ms
resetTask(); // 100ms : 700ms -> 800ms resetTask(); // 100ms : 700ms -> 800ms
gearTask(); // 100ms : 800ms -> 900ms gearTask(); // 100ms : 800ms -> 900ms
speedDistanceTask(); // 200ms : 900ms -> 1100ms speedDistanceTask(); // 200ms : 900ms -> 1100ms
temperatureTask(); // 100ms : 1100ms -> 1200ms temperatureTask(); // 100ms : 1100ms -> 1200ms
displayTask2(); // 100ms : 1200ms -> 1300ms displayTask2(); // 100ms : 1200ms -> 1300ms
speedDistanceTask(); // 200ms : 1300ms -> 1500ms speedDistanceTask(); // 200ms : 1300ms -> 1500ms
resetTask(); // 100ms : 1500ms -> 1600ms resetTask(); // 100ms : 1500ms -> 1600ms
// register the time at the end of the cyclic schedule period and print the // register the time at the end of the cyclic schedule period and print the
// elapsed time for the period // elapsed time for the period
@ -97,35 +91,32 @@ void BikeSystem::start() {
std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime); std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime);
tr_debug("Repeating cycle time is %" PRIu64 " milliseconds", cycle.count()); tr_debug("Repeating cycle time is %" PRIu64 " milliseconds", cycle.count());
// TODO: implement loop exit when applicable
// Done
bool fStop = false; bool fStop = false;
core_util_atomic_load(&fStop); core_util_atomic_load(&fStop);
if (fStop) { if (fStop) {
break; break;
} }
#if !defined(MBED_TEST_MODE) #if !defined(MBED_TEST_MODE)
_cpuLogger.printStats(); _cpuLogger.printStats();
#endif #endif
} }
} }
void BikeSystem::startWithEventQueue() { void BikeSystem::startWithEventQueue() {
tr_info("Starting Super-Loop with event handling"); tr_info("Starting Super-Loop with event handling");
init(); init();
EventQueue eventQueue; EventQueue eventQueue;
Event<void()> gearEvent(&eventQueue, callback(this, &BikeSystem::gearTask)); Event<void()> gearEvent(&eventQueue, callback(this, &BikeSystem::gearTask));
gearEvent.delay(kGearTaskDelay); gearEvent.delay(kGearTaskDelay);
gearEvent.period(kGearTaskPeriod); gearEvent.period(kGearTaskPeriod);
gearEvent.post(); gearEvent.post();
Event<void()> speedDistanceEvent(&eventQueue, callback(this, &BikeSystem::speedDistanceTask)); Event<void()> speedDistanceEvent(&eventQueue,
callback(this, &BikeSystem::speedDistanceTask));
speedDistanceEvent.delay(kSpeedDistanceTaskDelay); speedDistanceEvent.delay(kSpeedDistanceTaskDelay);
speedDistanceEvent.period(kSpeedDistanceTaskPeriod); speedDistanceEvent.period(kSpeedDistanceTaskPeriod);
speedDistanceEvent.post(); speedDistanceEvent.post();
@ -140,7 +131,8 @@ void BikeSystem::startWithEventQueue() {
resetEvent.period(kResetTaskPeriod); resetEvent.period(kResetTaskPeriod);
resetEvent.post(); resetEvent.post();
Event<void()> temperatureEvent(&eventQueue, callback(this, &BikeSystem::temperatureTask)); Event<void()> temperatureEvent(&eventQueue,
callback(this, &BikeSystem::temperatureTask));
temperatureEvent.delay(kTemperatureTaskDelay); temperatureEvent.delay(kTemperatureTaskDelay);
temperatureEvent.period(kTemperatureTaskPeriod); temperatureEvent.period(kTemperatureTaskPeriod);
temperatureEvent.post(); temperatureEvent.post();
@ -150,14 +142,14 @@ void BikeSystem::startWithEventQueue() {
display2Event.period(kDisplayTask2Period); display2Event.period(kDisplayTask2Period);
display2Event.post(); display2Event.post();
#if !defined(MBED_TEST_MODE) #if !defined(MBED_TEST_MODE)
Event<void()> cpuEvent(&eventQueue, callback(this, &BikeSystem::cpuTask)); Event<void()> cpuEvent(&eventQueue, callback(this, &BikeSystem::cpuTask));
cpuEvent.delay(kCPUTaskDelay); cpuEvent.delay(kCPUTaskDelay);
cpuEvent.period(kCPUTaskPeriod); cpuEvent.period(kCPUTaskPeriod);
cpuEvent.post(); cpuEvent.post();
#endif #endif
eventQueue.dispatch_forever(); eventQueue.dispatch_forever();
} }
void BikeSystem::stop() { core_util_atomic_store_bool(&_stopFlag, true); } void BikeSystem::stop() { core_util_atomic_store_bool(&_stopFlag, true); }
@ -195,8 +187,7 @@ void BikeSystem::gearTask() {
_currentGearSize = _gearDevice.getCurrentGearSize(); _currentGearSize = _gearDevice.getCurrentGearSize();
_taskLogger.logPeriodAndExecutionTime( _taskLogger.logPeriodAndExecutionTime(
_timer, advembsof::TaskLogger::kGearTaskIndex, taskStartTime _timer, advembsof::TaskLogger::kGearTaskIndex, taskStartTime);
);
} }
void BikeSystem::speedDistanceTask() { void BikeSystem::speedDistanceTask() {
@ -207,12 +198,11 @@ void BikeSystem::speedDistanceTask() {
_speedometer.setCurrentRotationTime(pedalRotationTime); _speedometer.setCurrentRotationTime(pedalRotationTime);
_speedometer.setGearSize(_currentGearSize); _speedometer.setGearSize(_currentGearSize);
// no need to protect access to data members (single threaded) // no need to protect access to data members (single threaded)
_currentSpeed = _speedometer.getCurrentSpeed(); _currentSpeed = _speedometer.getCurrentSpeed();
_traveledDistance = _speedometer.getDistance(); _traveledDistance = _speedometer.getDistance();
_taskLogger.logPeriodAndExecutionTime( _taskLogger.logPeriodAndExecutionTime(
_timer, advembsof::TaskLogger::kSpeedTaskIndex, taskStartTime _timer, advembsof::TaskLogger::kSpeedTaskIndex, taskStartTime);
);
} }
void BikeSystem::temperatureTask() { void BikeSystem::temperatureTask() {
@ -225,18 +215,16 @@ void BikeSystem::temperatureTask() {
tr_warn("Tick2 %" PRIu64, _timer.elapsed_time().count()); tr_warn("Tick2 %" PRIu64, _timer.elapsed_time().count());
ThisThread::sleep_for( ThisThread::sleep_for(std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::duration_cast<std::chrono::milliseconds>( kTemperatureTaskComputationTime - (_timer.elapsed_time() - taskStartTime)));
kTemperatureTaskComputationTime - (_timer.elapsed_time() - taskStartTime)
)
);
// simulate task computation by waiting for the required task computation time // simulate task computation by waiting for the required task computation time
// std::chrono::microseconds elapsedTime = std::chrono::microseconds::zero(); // std::chrono::microseconds elapsedTime =
// while (elapsedTime < kTemperatureTaskComputationTime) { // std::chrono::microseconds::zero(); while (elapsedTime <
// elapsedTime = _timer.elapsed_time() - taskStartTime; // kTemperatureTaskComputationTime) {
// } // elapsedTime = _timer.elapsed_time() - taskStartTime;
// }
_taskLogger.logPeriodAndExecutionTime( _taskLogger.logPeriodAndExecutionTime(
_timer, advembsof::TaskLogger::kTemperatureTaskIndex, taskStartTime); _timer, advembsof::TaskLogger::kTemperatureTaskIndex, taskStartTime);
@ -263,18 +251,16 @@ void BikeSystem::displayTask1() {
_displayDevice.displaySpeed(_currentSpeed); _displayDevice.displaySpeed(_currentSpeed);
_displayDevice.displayDistance(_traveledDistance); _displayDevice.displayDistance(_traveledDistance);
ThisThread::sleep_for( ThisThread::sleep_for(std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::duration_cast<std::chrono::milliseconds>( kDisplayTask1ComputationTime - (_timer.elapsed_time() - taskStartTime)));
kDisplayTask1ComputationTime - (_timer.elapsed_time() - taskStartTime)
)
);
// simulate task computation by waiting for the required task computation time // simulate task computation by waiting for the required task computation time
// std::chrono::microseconds elapsedTime = std::chrono::microseconds::zero(); // std::chrono::microseconds elapsedTime =
// while (elapsedTime < kDisplayTask1ComputationTime) { // std::chrono::microseconds::zero(); while (elapsedTime <
// elapsedTime = _timer.elapsed_time() - taskStartTime; // kDisplayTask1ComputationTime) {
// } // elapsedTime = _timer.elapsed_time() - taskStartTime;
// }
_taskLogger.logPeriodAndExecutionTime( _taskLogger.logPeriodAndExecutionTime(
_timer, advembsof::TaskLogger::kDisplayTask1Index, taskStartTime); _timer, advembsof::TaskLogger::kDisplayTask1Index, taskStartTime);
@ -285,24 +271,20 @@ void BikeSystem::displayTask2() {
_displayDevice.displayTemperature(_currentTemperature); _displayDevice.displayTemperature(_currentTemperature);
ThisThread::sleep_for( ThisThread::sleep_for(std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::duration_cast<std::chrono::milliseconds>( kDisplayTask2ComputationTime - (_timer.elapsed_time() - taskStartTime)));
kDisplayTask2ComputationTime - (_timer.elapsed_time() - taskStartTime)
)
);
// simulate task computation by waiting for the required task computation time // simulate task computation by waiting for the required task computation time
// std::chrono::microseconds elapsedTime = std::chrono::microseconds::zero(); // std::chrono::microseconds elapsedTime =
// while (elapsedTime < kDisplayTask2ComputationTime) { // std::chrono::microseconds::zero(); while (elapsedTime <
// elapsedTime = _timer.elapsed_time() - taskStartTime; // kDisplayTask2ComputationTime) {
// } // elapsedTime = _timer.elapsed_time() - taskStartTime;
// }
_taskLogger.logPeriodAndExecutionTime( _taskLogger.logPeriodAndExecutionTime(
_timer, advembsof::TaskLogger::kDisplayTask2Index, taskStartTime); _timer, advembsof::TaskLogger::kDisplayTask2Index, taskStartTime);
} }
void BikeSystem::cpuTask() { void BikeSystem::cpuTask() { _cpuLogger.printStats(); }
_cpuLogger.printStats();
}
} // namespace static_scheduling } // namespace static_scheduling

8
static_scheduling/bike_system.hpp
View File

@ -25,9 +25,9 @@
#pragma once #pragma once
// from advembsof // from advembsof
#include "cpu_logger.hpp"
#include "display_device.hpp" #include "display_device.hpp"
#include "task_logger.hpp" #include "task_logger.hpp"
#include "cpu_logger.hpp"
// from common // from common
#include "sensor_device.hpp" #include "sensor_device.hpp"
@ -79,12 +79,12 @@ class BikeSystem {
Timer _timer; Timer _timer;
// data member that represents the device for manipulating the gear // data member that represents the device for manipulating the gear
GearDevice _gearDevice; GearDevice _gearDevice;
uint8_t _currentGear = bike_computer::kMinGear; uint8_t _currentGear = bike_computer::kMinGear;
uint8_t _currentGearSize = bike_computer::kMinGearSize; uint8_t _currentGearSize = bike_computer::kMinGearSize;
// data member that represents the device for manipulating the pedal rotation // data member that represents the device for manipulating the pedal rotation
// speed/time // speed/time
PedalDevice _pedalDevice; PedalDevice _pedalDevice;
float _currentSpeed = 0.0f; float _currentSpeed = 0.0f;
float _traveledDistance = 0.0f; float _traveledDistance = 0.0f;
// data member that represents the device used for resetting // data member that represents the device used for resetting
ResetDevice _resetDevice; ResetDevice _resetDevice;
@ -103,4 +103,4 @@ class BikeSystem {
advembsof::CPULogger _cpuLogger; advembsof::CPULogger _cpuLogger;
}; };
} // namespace static_scheduling } // namespace static_scheduling

2
static_scheduling/gear_device.cpp
View File

@ -80,4 +80,4 @@ uint8_t GearDevice::getCurrentGearSize() const {
return bike_computer::kMaxGearSize - _currentGear; return bike_computer::kMaxGearSize - _currentGear;
} }
} // namespace static_scheduling } // namespace static_scheduling

2
static_scheduling/gear_device.hpp
View File

@ -47,4 +47,4 @@ class GearDevice {
Timer& _timer; Timer& _timer;
}; };
} // namespace static_scheduling } // namespace static_scheduling

110
static_scheduling/pedal_device.cpp
View File

@ -1,12 +1,25 @@
// Copyright 2022 Haute école d'ingénierie et d'architecture de Fribourg
//
// 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.
/**************************************************************************** /****************************************************************************
* @file pedal_device.cpp * @file pedal_device.cpp
* @author Rémi Heredero <remi@heredero.ch> * @author Rémi Heredero <remi@heredero.ch>
* @author Yann Sierro <yannsierro.pro@gmail.com> * @author Yann Sierro <yannsierro.pro@gmail.com>
* *
* @brief Pedal Device implementation (static scheduling) * @brief Pedal Device implementation (static scheduling)
* @date 2024-11-09 * @date 2024-11-09
* @version 0.1.0 * @version 0.1.0
****************************************************************************/ ****************************************************************************/
#include "pedal_device.hpp" #include "pedal_device.hpp"
@ -22,51 +35,50 @@
namespace static_scheduling { namespace static_scheduling {
static constexpr std::chrono::microseconds kTaskRunTime = 200000us; static constexpr std::chrono::microseconds kTaskRunTime = 200000us;
PedalDevice::PedalDevice(Timer& timer) : _timer(timer) {} PedalDevice::PedalDevice(Timer& timer) : _timer(timer) {}
std::chrono::milliseconds PedalDevice::getCurrentRotationTime() {
std::chrono::microseconds initialTime = _timer.elapsed_time();
std::chrono::microseconds elapsedTime = std::chrono::microseconds::zero();
// we bound the change to one increment/decrement per call
bool hasChanged = false;
while (elapsedTime < kTaskRunTime) {
if (!hasChanged) {
disco::Joystick::State joystickState =
disco::Joystick::getInstance().getState();
std::chrono::milliseconds PedalDevice::getCurrentRotationTime() { switch (joystickState) {
// TODO case disco::Joystick::State::LeftPressed:
std::chrono::microseconds initialTime = _timer.elapsed_time(); if (_pedalRotationTime < bike_computer::kMaxPedalRotationTime) {
std::chrono::microseconds elapsedTime = std::chrono::microseconds::zero(); decreaseRotationSpeed();
// we bound the change to one increment/decrement per call hasChanged = true;
bool hasChanged = false; }
while (elapsedTime < kTaskRunTime) { break;
if (!hasChanged) {
disco::Joystick::State joystickState = disco::Joystick::getInstance().getState();
switch (joystickState) { case disco::Joystick::State::DownPressed:
case disco::Joystick::State::LeftPressed: if (_pedalRotationTime > bike_computer::kMinPedalRotationTime) {
if (_pedalRotationTime < bike_computer::kMaxPedalRotationTime) { decreaseRotationSpeed();
decreaseRotationSpeed(); hasChanged = true;
hasChanged = true; }
} break;
break;
case disco::Joystick::State::DownPressed: default:
if (_pedalRotationTime > bike_computer::kMinPedalRotationTime) { break;
decreaseRotationSpeed(); }
hasChanged = true; }
} elapsedTime = _timer.elapsed_time() - initialTime;
break;
default:
break;
}
}
elapsedTime = _timer.elapsed_time() - initialTime;
}
return _pedalRotationTime;
} }
return _pedalRotationTime;
void PedalDevice::increaseRotationSpeed() {
_pedalRotationTime -= bike_computer::kDeltaPedalRotationTime;
}
void PedalDevice::decreaseRotationSpeed() {
_pedalRotationTime += bike_computer::kDeltaPedalRotationTime;
}
} }
void PedalDevice::increaseRotationSpeed() {
_pedalRotationTime -= bike_computer::kDeltaPedalRotationTime;
}
void PedalDevice::decreaseRotationSpeed() {
_pedalRotationTime += bike_computer::kDeltaPedalRotationTime;
}
} // namespace static_scheduling

2
static_scheduling/pedal_device.hpp
View File

@ -51,4 +51,4 @@ class PedalDevice {
Timer& _timer; Timer& _timer;
}; };
} // namespace static_scheduling } // namespace static_scheduling

76
static_scheduling/reset_device.cpp
View File

@ -1,12 +1,26 @@
// Copyright 2022 Haute école d'ingénierie et d'architecture de Fribourg
//
// 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.
/**************************************************************************** /****************************************************************************
* @file reset_device.cpp * @file reset_device.cpp
* @author Rémi Heredero <remi@heredero.ch> * @author Rémi Heredero <remi@heredero.ch>
* @author Yann Sierro <yannsierro.pro@gmail.com> * @author Yann Sierro <yannsierro.pro@gmail.com>
* *
* @brief Reset Device implementation (static scheduling) * @brief Reset Device implementation (static scheduling)
* @date 2024-11-12 * @date 2024-11-12
* @version 0.1.0 * @version 0.1.0
****************************************************************************/ ****************************************************************************/
#include "reset_device.hpp" #include "reset_device.hpp"
@ -21,43 +35,35 @@
static constexpr uint8_t kPolarityPressed = 1; static constexpr uint8_t kPolarityPressed = 1;
#endif #endif
#if MBED_CONF_MBED_TRACE_ENABLE #if MBED_CONF_MBED_TRACE_ENABLE
#define TRACE_GROUP "ResetDevice" #define TRACE_GROUP "ResetDevice"
#endif // MBED_CONF_MBED_TRACE_ENABLE #endif // MBED_CONF_MBED_TRACE_ENABLE
namespace static_scheduling { namespace static_scheduling {
static constexpr std::chrono::microseconds kTaskRunTime = 100000us; static constexpr std::chrono::microseconds kTaskRunTime = 100000us;
ResetDevice::ResetDevice(Timer& timer) : _timer(timer), _resetButton(PUSH_BUTTON) { ResetDevice::ResetDevice(Timer& timer) : _timer(timer), _resetButton(PUSH_BUTTON) {
_resetButton.rise(callback(this, &ResetDevice::onRise)); _resetButton.rise(callback(this, &ResetDevice::onRise));
} }
bool ResetDevice::checkReset() { bool ResetDevice::checkReset() {
std::chrono::microseconds initialTime = _timer.elapsed_time(); std::chrono::microseconds initialTime = _timer.elapsed_time();
std::chrono::microseconds elapsedTime = std::chrono::microseconds::zero(); std::chrono::microseconds elapsedTime = std::chrono::microseconds::zero();
// we bound the change to one increment/decrement per call // we bound the change to one increment/decrement per call
bool isPressed = false; bool isPressed = false;
while (elapsedTime < kTaskRunTime) { while (elapsedTime < kTaskRunTime) {
if(!isPressed) { if (!isPressed) {
isPressed = _resetButton.read() == kPolarityPressed; isPressed = _resetButton.read() == kPolarityPressed;
} }
elapsedTime = _timer.elapsed_time() - initialTime; elapsedTime = _timer.elapsed_time() - initialTime;
}
return isPressed;
}
std::chrono::microseconds ResetDevice::getPressTime() {
return _pressTime;
} }
void ResetDevice::onRise() { return isPressed;
_pressTime = _timer.elapsed_time(); }
}
std::chrono::microseconds ResetDevice::getPressTime() { return _pressTime; }
void ResetDevice::onRise() { _pressTime = _timer.elapsed_time(); }
} } // namespace static_scheduling

2
static_scheduling/reset_device.hpp
View File

@ -53,4 +53,4 @@ class ResetDevice {
std::chrono::microseconds _pressTime; std::chrono::microseconds _pressTime;
}; };
} // namespace static_scheduling } // namespace static_scheduling

128
static_scheduling_with_event/bike_system.cpp
View File

@ -35,59 +35,55 @@
namespace static_scheduling_with_event { namespace static_scheduling_with_event {
static constexpr std::chrono::milliseconds kGearTaskPeriod = 800ms; static constexpr std::chrono::milliseconds kGearTaskPeriod = 800ms;
static constexpr std::chrono::milliseconds kGearTaskDelay = 0ms; static constexpr std::chrono::milliseconds kGearTaskDelay = 0ms;
static constexpr std::chrono::milliseconds kGearTaskComputationTime = 100ms; static constexpr std::chrono::milliseconds kGearTaskComputationTime = 100ms;
static constexpr std::chrono::milliseconds kSpeedDistanceTaskPeriod = 400ms; static constexpr std::chrono::milliseconds kSpeedDistanceTaskPeriod = 400ms;
static constexpr std::chrono::milliseconds kSpeedDistanceTaskDelay = 100ms; static constexpr std::chrono::milliseconds kSpeedDistanceTaskDelay = 100ms;
static constexpr std::chrono::milliseconds kSpeedDistanceTaskComputationTime = 200ms; static constexpr std::chrono::milliseconds kSpeedDistanceTaskComputationTime = 200ms;
static constexpr std::chrono::milliseconds kDisplayTask1Period = 1600ms; static constexpr std::chrono::milliseconds kDisplayTask1Period = 1600ms;
static constexpr std::chrono::milliseconds kDisplayTask1Delay = 300ms; static constexpr std::chrono::milliseconds kDisplayTask1Delay = 300ms;
static constexpr std::chrono::milliseconds kDisplayTask1ComputationTime = 200ms; static constexpr std::chrono::milliseconds kDisplayTask1ComputationTime = 200ms;
static constexpr std::chrono::milliseconds kResetTaskPeriod = 800ms; static constexpr std::chrono::milliseconds kResetTaskPeriod = 800ms;
static constexpr std::chrono::milliseconds kResetTaskDelay = 700ms; static constexpr std::chrono::milliseconds kResetTaskDelay = 700ms;
static constexpr std::chrono::milliseconds kResetTaskComputationTime = 100ms; static constexpr std::chrono::milliseconds kResetTaskComputationTime = 100ms;
static constexpr std::chrono::milliseconds kTemperatureTaskPeriod = 1600ms; static constexpr std::chrono::milliseconds kTemperatureTaskPeriod = 1600ms;
static constexpr std::chrono::milliseconds kTemperatureTaskDelay = 1100ms; static constexpr std::chrono::milliseconds kTemperatureTaskDelay = 1100ms;
static constexpr std::chrono::milliseconds kTemperatureTaskComputationTime = 100ms; static constexpr std::chrono::milliseconds kTemperatureTaskComputationTime = 100ms;
static constexpr std::chrono::milliseconds kDisplayTask2Period = 1600ms; static constexpr std::chrono::milliseconds kDisplayTask2Period = 1600ms;
static constexpr std::chrono::milliseconds kDisplayTask2Delay = 1200ms; static constexpr std::chrono::milliseconds kDisplayTask2Delay = 1200ms;
static constexpr std::chrono::milliseconds kDisplayTask2ComputationTime = 100ms; static constexpr std::chrono::milliseconds kDisplayTask2ComputationTime = 100ms;
static constexpr std::chrono::milliseconds kCPUTaskPeriod = 1600ms; static constexpr std::chrono::milliseconds kCPUTaskPeriod = 1600ms;
static constexpr std::chrono::milliseconds kCPUTaskDelay = 1200ms; static constexpr std::chrono::milliseconds kCPUTaskDelay = 1200ms;
static constexpr std::chrono::milliseconds kCPUTaskComputationTime = 100ms; static constexpr std::chrono::milliseconds kCPUTaskComputationTime = 100ms;
BikeSystem::BikeSystem()
BikeSystem::BikeSystem() : : _gearDevice(),
_gearDevice(), _pedalDevice(),
_pedalDevice(), _resetDevice(callback(this, &BikeSystem::onReset)),
_resetDevice(callback(this, &BikeSystem::onReset)), _speedometer(_timer),
_speedometer(_timer), _cpuLogger(_timer) {}
_cpuLogger(_timer)
{
}
void BikeSystem::start() { void BikeSystem::start() {
tr_info("Starting Super-Loop with event handling"); tr_info("Starting Super-Loop with event handling");
init(); init();
EventQueue eventQueue; EventQueue eventQueue;
Event<void()> gearEvent(&eventQueue, callback(this, &BikeSystem::gearTask)); Event<void()> gearEvent(&eventQueue, callback(this, &BikeSystem::gearTask));
gearEvent.delay(kGearTaskDelay); gearEvent.delay(kGearTaskDelay);
gearEvent.period(kGearTaskPeriod); gearEvent.period(kGearTaskPeriod);
gearEvent.post(); gearEvent.post();
Event<void()> speedDistanceEvent(&eventQueue, callback(this, &BikeSystem::speedDistanceTask)); Event<void()> speedDistanceEvent(&eventQueue,
callback(this, &BikeSystem::speedDistanceTask));
speedDistanceEvent.delay(kSpeedDistanceTaskDelay); speedDistanceEvent.delay(kSpeedDistanceTaskDelay);
speedDistanceEvent.period(kSpeedDistanceTaskPeriod); speedDistanceEvent.period(kSpeedDistanceTaskPeriod);
speedDistanceEvent.post(); speedDistanceEvent.post();
@ -102,7 +98,8 @@ void BikeSystem::start() {
resetEvent.period(kResetTaskPeriod); resetEvent.period(kResetTaskPeriod);
resetEvent.post(); resetEvent.post();
Event<void()> temperatureEvent(&eventQueue, callback(this, &BikeSystem::temperatureTask)); Event<void()> temperatureEvent(&eventQueue,
callback(this, &BikeSystem::temperatureTask));
temperatureEvent.delay(kTemperatureTaskDelay); temperatureEvent.delay(kTemperatureTaskDelay);
temperatureEvent.period(kTemperatureTaskPeriod); temperatureEvent.period(kTemperatureTaskPeriod);
temperatureEvent.post(); temperatureEvent.post();
@ -112,14 +109,14 @@ void BikeSystem::start() {
display2Event.period(kDisplayTask2Period); display2Event.period(kDisplayTask2Period);
display2Event.post(); display2Event.post();
#if !defined(MBED_TEST_MODE) #if !defined(MBED_TEST_MODE)
Event<void()> cpuEvent(&eventQueue, callback(this, &BikeSystem::cpuTask)); Event<void()> cpuEvent(&eventQueue, callback(this, &BikeSystem::cpuTask));
cpuEvent.delay(kCPUTaskDelay); cpuEvent.delay(kCPUTaskDelay);
cpuEvent.period(kCPUTaskPeriod); cpuEvent.period(kCPUTaskPeriod);
cpuEvent.post(); cpuEvent.post();
#endif #endif
eventQueue.dispatch_forever(); eventQueue.dispatch_forever();
} }
void BikeSystem::onReset() { void BikeSystem::onReset() {
@ -162,8 +159,7 @@ void BikeSystem::gearTask() {
_currentGearSize = _gearDevice.getCurrentGearSize(); _currentGearSize = _gearDevice.getCurrentGearSize();
_taskLogger.logPeriodAndExecutionTime( _taskLogger.logPeriodAndExecutionTime(
_timer, advembsof::TaskLogger::kGearTaskIndex, taskStartTime _timer, advembsof::TaskLogger::kGearTaskIndex, taskStartTime);
);
} }
void BikeSystem::speedDistanceTask() { void BikeSystem::speedDistanceTask() {
@ -173,29 +169,25 @@ void BikeSystem::speedDistanceTask() {
_speedometer.setCurrentRotationTime(pedalRotationTime); _speedometer.setCurrentRotationTime(pedalRotationTime);
_speedometer.setGearSize(_currentGearSize); _speedometer.setGearSize(_currentGearSize);
_currentSpeed = _speedometer.getCurrentSpeed(); _currentSpeed = _speedometer.getCurrentSpeed();
_traveledDistance = _speedometer.getDistance(); _traveledDistance = _speedometer.getDistance();
_taskLogger.logPeriodAndExecutionTime( _taskLogger.logPeriodAndExecutionTime(
_timer, advembsof::TaskLogger::kSpeedTaskIndex, taskStartTime _timer, advembsof::TaskLogger::kSpeedTaskIndex, taskStartTime);
);
} }
void BikeSystem::temperatureTask() { void BikeSystem::temperatureTask() {
auto taskStartTime = _timer.elapsed_time(); auto taskStartTime = _timer.elapsed_time();
//tr_warn("Tick1 %" PRIu64, _timer.elapsed_time().count()); // tr_warn("Tick1 %" PRIu64, _timer.elapsed_time().count());
// no need to protect access to data members (single threaded) // no need to protect access to data members (single threaded)
_currentTemperature = _sensorDevice.readTemperature(); _currentTemperature = _sensorDevice.readTemperature();
//tr_warn("Tick2 %" PRIu64, _timer.elapsed_time().count()); // tr_warn("Tick2 %" PRIu64, _timer.elapsed_time().count());
ThisThread::sleep_for( ThisThread::sleep_for(std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::duration_cast<std::chrono::milliseconds>( kTemperatureTaskComputationTime - (_timer.elapsed_time() - taskStartTime)));
kTemperatureTaskComputationTime - (_timer.elapsed_time() - taskStartTime)
)
);
_taskLogger.logPeriodAndExecutionTime( _taskLogger.logPeriodAndExecutionTime(
_timer, advembsof::TaskLogger::kTemperatureTaskIndex, taskStartTime); _timer, advembsof::TaskLogger::kTemperatureTaskIndex, taskStartTime);
@ -223,11 +215,8 @@ void BikeSystem::displayTask1() {
_displayDevice.displaySpeed(_currentSpeed); _displayDevice.displaySpeed(_currentSpeed);
_displayDevice.displayDistance(_traveledDistance); _displayDevice.displayDistance(_traveledDistance);
ThisThread::sleep_for( ThisThread::sleep_for(std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::duration_cast<std::chrono::milliseconds>( kDisplayTask1ComputationTime - (_timer.elapsed_time() - taskStartTime)));
kDisplayTask1ComputationTime - (_timer.elapsed_time() - taskStartTime)
)
);
_taskLogger.logPeriodAndExecutionTime( _taskLogger.logPeriodAndExecutionTime(
_timer, advembsof::TaskLogger::kDisplayTask1Index, taskStartTime); _timer, advembsof::TaskLogger::kDisplayTask1Index, taskStartTime);
@ -238,18 +227,13 @@ void BikeSystem::displayTask2() {
_displayDevice.displayTemperature(_currentTemperature); _displayDevice.displayTemperature(_currentTemperature);
ThisThread::sleep_for( ThisThread::sleep_for(std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::duration_cast<std::chrono::milliseconds>( kDisplayTask2ComputationTime - (_timer.elapsed_time() - taskStartTime)));
kDisplayTask2ComputationTime - (_timer.elapsed_time() - taskStartTime)
)
);
_taskLogger.logPeriodAndExecutionTime( _taskLogger.logPeriodAndExecutionTime(
_timer, advembsof::TaskLogger::kDisplayTask2Index, taskStartTime); _timer, advembsof::TaskLogger::kDisplayTask2Index, taskStartTime);
} }
void BikeSystem::cpuTask() { void BikeSystem::cpuTask() { _cpuLogger.printStats(); }
_cpuLogger.printStats();
}
} // namespace static_scheduling } // namespace static_scheduling_with_event

10
static_scheduling_with_event/bike_system.hpp
View File

@ -25,9 +25,9 @@
#pragma once #pragma once
// from advembsof // from advembsof
#include "cpu_logger.hpp"
#include "display_device.hpp" #include "display_device.hpp"
#include "task_logger.hpp" #include "task_logger.hpp"
#include "cpu_logger.hpp"
// from common // from common
#include "sensor_device.hpp" #include "sensor_device.hpp"
@ -78,18 +78,18 @@ class BikeSystem {
bool _stopFlag = false; bool _stopFlag = false;
std::chrono::microseconds _resetTime = std::chrono::microseconds::zero(); std::chrono::microseconds _resetTime = std::chrono::microseconds::zero();
volatile bool _resetFlag = false; volatile bool _resetFlag = false;
// timer instance used for loggint task time and used by ResetDevice // timer instance used for loggint task time and used by ResetDevice
Timer _timer; Timer _timer;
// data member that represents the device for manipulating the gear // data member that represents the device for manipulating the gear
GearDevice _gearDevice; GearDevice _gearDevice;
uint8_t _currentGear = bike_computer::kMinGear; uint8_t _currentGear = bike_computer::kMinGear;
uint8_t _currentGearSize = bike_computer::kMinGearSize; uint8_t _currentGearSize = bike_computer::kMinGearSize;
// data member that represents the device for manipulating the pedal rotation // data member that represents the device for manipulating the pedal rotation
// speed/time // speed/time
PedalDevice _pedalDevice; PedalDevice _pedalDevice;
float _currentSpeed = 0.0f; float _currentSpeed = 0.0f;
float _traveledDistance = 0.0f; float _traveledDistance = 0.0f;
// data member that represents the device used for resetting // data member that represents the device used for resetting
ResetDevice _resetDevice; ResetDevice _resetDevice;
@ -108,4 +108,4 @@ class BikeSystem {
advembsof::CPULogger _cpuLogger; advembsof::CPULogger _cpuLogger;
}; };
} // namespace static_scheduling } // namespace static_scheduling_with_event

13
static_scheduling_with_event/gear_device.cpp
View File

@ -38,17 +38,12 @@
namespace static_scheduling_with_event { namespace static_scheduling_with_event {
GearDevice::GearDevice() { GearDevice::GearDevice() {
disco::Joystick::getInstance().setUpCallback( disco::Joystick::getInstance().setUpCallback(callback(this, &GearDevice::onUp));
callback(this, &GearDevice::onUp)); disco::Joystick::getInstance().setDownCallback(callback(this, &GearDevice::onDown));
disco::Joystick::getInstance().setDownCallback(
callback(this, &GearDevice::onDown));
} }
uint8_t GearDevice::getCurrentGear() { uint8_t GearDevice::getCurrentGear() { return core_util_atomic_load_u8(&_currentGear); }
return core_util_atomic_load_u8(&_currentGear);
}
uint8_t GearDevice::getCurrentGearSize() const { uint8_t GearDevice::getCurrentGearSize() const {
return bike_computer::kMaxGearSize - core_util_atomic_load_u8(&_currentGear); return bike_computer::kMaxGearSize - core_util_atomic_load_u8(&_currentGear);
@ -66,4 +61,4 @@ void GearDevice::onDown() {
} }
} }
} // namespace static_scheduling } // namespace static_scheduling_with_event

4
static_scheduling_with_event/gear_device.hpp
View File

@ -33,7 +33,7 @@ namespace static_scheduling_with_event {
class GearDevice { class GearDevice {
public: public:
explicit GearDevice(); // NOLINT(runtime/references) GearDevice(); // NOLINT(runtime/references)
// make the class non copyable // make the class non copyable
GearDevice(GearDevice&) = delete; GearDevice(GearDevice&) = delete;
@ -51,4 +51,4 @@ class GearDevice {
volatile uint8_t _currentGear = bike_computer::kMinGear; volatile uint8_t _currentGear = bike_computer::kMinGear;
}; };
} // namespace static_scheduling } // namespace static_scheduling_with_event

97
static_scheduling_with_event/pedal_device.cpp
View File

@ -1,12 +1,26 @@
// Copyright 2022 Haute école d'ingénierie et d'architecture de Fribourg
//
// 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.
/**************************************************************************** /****************************************************************************
* @file pedal_device.cpp * @file pedal_device.cpp
* @author Rémi Heredero <remi@heredero.ch> * @author Rémi Heredero <remi@heredero.ch>
* @author Yann Sierro <yannsierro.pro@gmail.com> * @author Yann Sierro <yannsierro.pro@gmail.com>
* *
* @brief Pedal Device implementation (static scheduling) * @brief Pedal Device implementation (static scheduling)
* @date 2024-11-17 * @date 2024-11-17
* @version 1.1.0 * @version 1.1.0
****************************************************************************/ ****************************************************************************/
#include "pedal_device.hpp" #include "pedal_device.hpp"
@ -22,41 +36,34 @@
namespace static_scheduling_with_event { namespace static_scheduling_with_event {
PedalDevice::PedalDevice() { PedalDevice::PedalDevice() {
disco::Joystick::getInstance().setLeftCallback( disco::Joystick::getInstance().setLeftCallback(callback(this, &PedalDevice::onLeft));
callback(this, &PedalDevice::onLeft) disco::Joystick::getInstance().setRightCallback(
); callback(this, &PedalDevice::onRight));
disco::Joystick::getInstance().setRightCallback(
callback(this, &PedalDevice::onRight)
);
}
std::chrono::milliseconds PedalDevice::getCurrentRotationTime() {
uint32_t currentStep = core_util_atomic_load_u32(&_currentStep);
return bike_computer::kMinPedalRotationTime + currentStep * bike_computer::kDeltaPedalRotationTime;
}
void PedalDevice::increaseRotationSpeed() {
uint32_t currentStep = core_util_atomic_load_u32(&_currentStep);
if (currentStep > 0) {
core_util_atomic_decr_u32(&_currentStep, 1);
}
}
void PedalDevice::decreaseRotationSpeed() {
uint32_t currentStep = core_util_atomic_load_u32(&_currentStep);
if (currentStep < bike_computer::kNbrOfSteps) {
core_util_atomic_incr_u32(&_currentStep, 1);
}
}
void PedalDevice::onLeft() {
decreaseRotationSpeed();
}
void PedalDevice::onRight() {
increaseRotationSpeed();
}
} }
std::chrono::milliseconds PedalDevice::getCurrentRotationTime() {
uint32_t currentStep = core_util_atomic_load_u32(&_currentStep);
return bike_computer::kMinPedalRotationTime +
currentStep * bike_computer::kDeltaPedalRotationTime;
}
void PedalDevice::increaseRotationSpeed() {
uint32_t currentStep = core_util_atomic_load_u32(&_currentStep);
if (currentStep > 0) {
core_util_atomic_decr_u32(&_currentStep, 1);
}
}
void PedalDevice::decreaseRotationSpeed() {
uint32_t currentStep = core_util_atomic_load_u32(&_currentStep);
if (currentStep < bike_computer::kNbrOfSteps) {
core_util_atomic_incr_u32(&_currentStep, 1);
}
}
void PedalDevice::onLeft() { decreaseRotationSpeed(); }
void PedalDevice::onRight() { increaseRotationSpeed(); }
} // namespace static_scheduling_with_event

9
static_scheduling_with_event/pedal_device.hpp
View File

@ -51,10 +51,9 @@ class PedalDevice {
// data members // data members
volatile uint32_t _currentStep = static_cast<uint32_t>( volatile uint32_t _currentStep = static_cast<uint32_t>(
( (bike_computer::kInitialPedalRotationTime - bike_computer::kMinPedalRotationTime)
bike_computer::kInitialPedalRotationTime - bike_computer::kMinPedalRotationTime .count() /
).count() / bike_computer::kDeltaPedalRotationTime.count() bike_computer::kDeltaPedalRotationTime.count());
);
}; };
} // namespace static_scheduling } // namespace static_scheduling_with_event

40
static_scheduling_with_event/reset_device.cpp
View File

@ -1,12 +1,26 @@
// Copyright 2022 Haute école d'ingénierie et d'architecture de Fribourg
//
// 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.
/**************************************************************************** /****************************************************************************
* @file reset_device.cpp * @file reset_device.cpp
* @author Rémi Heredero <remi@heredero.ch> * @author Rémi Heredero <remi@heredero.ch>
* @author Yann Sierro <yannsierro.pro@gmail.com> * @author Yann Sierro <yannsierro.pro@gmail.com>
* *
* @brief Reset Device implementation (static scheduling with event) * @brief Reset Device implementation (static scheduling with event)
* @date 2024-11-17 * @date 2024-11-17
* @version 1.1.0 * @version 1.1.0
****************************************************************************/ ****************************************************************************/
#include "reset_device.hpp" #include "reset_device.hpp"
@ -21,16 +35,14 @@
static constexpr uint8_t kPolarityPressed = 1; static constexpr uint8_t kPolarityPressed = 1;
#endif #endif
#if MBED_CONF_MBED_TRACE_ENABLE #if MBED_CONF_MBED_TRACE_ENABLE
#define TRACE_GROUP "ResetDevice" #define TRACE_GROUP "ResetDevice"
#endif // MBED_CONF_MBED_TRACE_ENABLE #endif // MBED_CONF_MBED_TRACE_ENABLE
namespace static_scheduling_with_event { namespace static_scheduling_with_event {
ResetDevice::ResetDevice(Callback<void()> cb) : _resetButton(PUSH_BUTTON) { ResetDevice::ResetDevice(Callback<void()> cb) : _resetButton(PUSH_BUTTON) {
_resetButton.fall(cb); _resetButton.fall(cb);
} }
} // namespace static_scheduling_with_event
}

3
static_scheduling_with_event/reset_device.hpp
View File

@ -39,10 +39,9 @@ class ResetDevice {
ResetDevice& operator=(ResetDevice&) = delete; ResetDevice& operator=(ResetDevice&) = delete;
private: private:
// data members // data members
// instance representing the reset button // instance representing the reset button
InterruptIn _resetButton; InterruptIn _resetButton;
}; };
} // namespace static_scheduling } // namespace static_scheduling_with_event