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

ADD Phase 2

Browse Source
This commit is contained in:
Rémi Heredero 2024-11-19 12:01:17 +01:00 committed by GitHub
commit 171c43b653
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
31 changed files with 2534 additions and 12 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
.github/workflows/build-test.yml vendored
View File

@ -1,6 +1,5 @@
name: Build test application name: Build test application
on: on:
pull_request:
push: push:
jobs: jobs:
@ -13,10 +12,11 @@ jobs:
strategy: strategy:
matrix: matrix:
target: [DISCO_H747I] target: [DISCO_H747I]
profile: [debug, release] profile: [debug]
tests: [ tests: [
tests-simple-test-always-succeed, tests-bike-computer-sensor-device,
tests-simple-test-ptr-test, tests-bike-computer-speedometer,
tests-bike-computer-bike-system,
] ]

2
.gitignore vendored
View File

@ -4,3 +4,5 @@ projectfiles
*.py* *.py*
BUILD BUILD
mbed-os mbed-os
DISCO_h747i
advdembsof_library

1
DISCO_H747I.lib Normal file
View File

@ -0,0 +1 @@
https://github.com/SergeAyer/DISCO_H747I/#2b367efbbf0d66205403647c0d0227808d0529ed

77
README.md
View File

@ -5,4 +5,81 @@ AdvEmbSoft/HESSO-Master/2024
# BikeComputer # BikeComputer
This is a project done in the course of AdvEmbSoft during the master's degree. It contains a program for spinning bikes. This is a project done in the course of AdvEmbSoft during the master's degree. It contains a program for spinning bikes.
# Configuration
## Libraries
Add disco libraries :
```terminal
mbed add https://github.com/SergeAyer/DISCO_H747I.git
```
Add sensor libraries :
```terminal
mbed add https://github.com/SergeAyer/advdembsof_library.git
```
Test sensor libraries :
```terminal
mbed test -m DISCO_H747I -t GCC_ARM -n advdembsof_library-tests-sensors-hdc1000 --compile --run
```
## Run static scheduling
On `.mbedignore` put at the end of the file
```
static_scheduling_with_event/*
```
On main.cpp include `"static_scheduling/bike_system.hpp"` and use :
```cpp
static_scheduling::BikeSystem bikeSystem;
bikeSystem.start();
```
## Run static scheduling with event queue
On `.mbedignore` put at the end of the file :
```
static_scheduling_with_event/*
```
On main.cpp include `"static_scheduling/bike_system.hpp"` and use :
```cpp
static_scheduling::BikeSystem bikeSystem;
bikeSystem.startWithEventQueue();
```
## Run static scheduling with event scheduling
On `.mbedignore` put at the end of the file
```
static_scheduling/*
```
On main.cpp include `"static_scheduling_with_event/bike_system.hpp"` and use :
```cpp
static_scheduling_with_event::BikeSystem bikeSystem;
bikeSystem.start();
```
# Some questions
## Question 1
`If you print CPU statistics at the end of every major cycle (in the super-loop), what CPU usage do you observe? How can you explain the observed CPU uptime?`
We observe a 100% usage because on each CPU cycle it compare if time is done.
## Question 2
`If you run the program after the change from busy wait to sleep calls, what CPU usage do you observe? How can you explain the observed CPU uptime?`
We can observe only a usage of 75% because the CPU is more on Idle with Thread sleep.
## Question 3
`If you run the static_scheduling_with_event program, what CPU usage do you observe? How can you explain the observed CPU uptime?`
We observe a light usage of 1% of CPU. The CPU is now sleeping all the time and doing small task only on event.
## Question 4
`When you run multiple tests for computing the response time of the reset event, what do you observe? Is there an improvement as compared to the static_scheduling::BikeSystem implementation?`
` - If you do not press long enough on the push button, the event may be missed and no reset happens.`
`Based on the program itself and on the task scheduling, explain these two behaviors. Explain also why such behaviors may be problematic.`
We notice, that we miss such less event when is event driven (or not at all). But with a static scheduling the response time is still long because the reset task is call with a certain period.

159
TESTS/bike-computer/bike-system/main.cpp Normal file
View File

@ -0,0 +1,159 @@
// 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 main.cpp
* @author Serge Ayer <serge.ayer@hefr.ch>
*
* @brief Bike computer test suite: scheduling
*
* @date 2023-08-26
* @version 0.1.0
***************************************************************************/
#include <chrono>
#include "static_scheduling/bike_system.hpp"
#include "static_scheduling_with_event/bike_system.hpp"
#include "greentea-client/test_env.h"
#include "mbed.h"
#include "task_logger.hpp"
#include "unity/unity.h"
#include "utest/utest.h"
using namespace utest::v1;
// test_bike_system handler function
static void test_bike_system() {
// create the BikeSystem instance
static_scheduling::BikeSystem bikeSystem;
// run the bike system in a separate thread
Thread thread;
thread.start(callback(&bikeSystem, &static_scheduling::BikeSystem::start));
// let the bike system run for 20 secs
ThisThread::sleep_for(20s);
// stop the bike system
bikeSystem.stop();
// check whether scheduling was correct
// Order is kGearTaskIndex, kSpeedTaskIndex, kTemperatureTaskIndex,
// kResetTaskIndex, kDisplayTask1Index, kDisplayTask2Index
constexpr std::chrono::microseconds taskComputationTimes[] = {
100000us, 200000us, 100000us, 100000us, 200000us, 100000us};
constexpr std::chrono::microseconds taskPeriods[] = {
800000us, 400000us, 1600000us, 800000us, 1600000us, 1600000us};
// allow for 2 msecs offset
uint64_t deltaUs = 2000;
for (uint8_t taskIndex = 0; taskIndex < advembsof::TaskLogger::kNbrOfTasks;
taskIndex++) {
TEST_ASSERT_UINT64_WITHIN(
deltaUs,
taskPeriods[taskIndex].count(),
bikeSystem.getTaskLogger().getPeriod(taskIndex).count());
TEST_ASSERT_UINT64_WITHIN(
deltaUs,
taskComputationTimes[taskIndex].count(),
bikeSystem.getTaskLogger().getComputationTime(taskIndex).count());
}
}
// test_bike_system_event_queue handler function
static void test_bike_system_event_queue() {
// create the BikeSystem instance
static_scheduling::BikeSystem bikeSystem;
// run the bike system in a separate thread
Thread thread;
thread.start(callback(&bikeSystem, &static_scheduling::BikeSystem::startWithEventQueue));
// let the bike system run for 20 secs
ThisThread::sleep_for(20s);
// stop the bike system
bikeSystem.stop();
// check whether scheduling was correct
// Order is kGearTaskIndex, kSpeedTaskIndex, kTemperatureTaskIndex,
// kResetTaskIndex, kDisplayTask1Index, kDisplayTask2Index
// When we use the event queue, we do not check the computation time
constexpr std::chrono::microseconds taskPeriods[] = {
800000us, 400000us, 1600000us, 800000us, 1600000us, 1600000us};
// allow for 2 msecs offset (with EventQueue)
uint64_t deltaUs = 2000;
for (uint8_t taskIndex = 0; taskIndex < advembsof::TaskLogger::kNbrOfTasks;
taskIndex++) {
TEST_ASSERT_UINT64_WITHIN(
deltaUs,
taskPeriods[taskIndex].count(),
bikeSystem.getTaskLogger().getPeriod(taskIndex).count());
}
}
// test_bike_system_with_event handler function
static void test_bike_system_with_event() {
// create the BikeSystem instance
static_scheduling_with_event::BikeSystem bikeSystem;
// run the bike system in a separate thread
Thread thread;
thread.start(callback(&bikeSystem, &static_scheduling_with_event::BikeSystem::start));
// let the bike system run for 20 secs
ThisThread::sleep_for(20s);
// stop the bike system
bikeSystem.stop();
// check whether scheduling was correct
// Order is kGearTaskIndex, kSpeedTaskIndex, kTemperatureTaskIndex,
// kResetTaskIndex, kDisplayTask1Index, kDisplayTask2Index
// When we use event handling, we do not check the computation time
constexpr std::chrono::microseconds taskPeriods[] = {
800000us, 400000us, 1600000us, 800000us, 1600000us, 1600000us};
// allow for 2 msecs offset (with EventQueue)
uint64_t deltaUs = 2000;
for (uint8_t taskIndex = 0; taskIndex < advembsof::TaskLogger::kNbrOfTasks;
taskIndex++) {
TEST_ASSERT_UINT64_WITHIN(
deltaUs,
taskPeriods[taskIndex].count(),
bikeSystem.getTaskLogger().getPeriod(taskIndex).count());
}
}
static utest::v1::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
// name of our Python file)
GREENTEA_SETUP(180, "default_auto");
return greentea_test_setup_handler(number_of_cases);
}
// List of test cases in this file
static Case cases[] = {
Case("test bike system", test_bike_system),
Case("test bike system with event queue", test_bike_system_event_queue),
Case("test bike system with event handling", test_bike_system_with_event),
};
static Specification specification(greentea_setup, cases);
int main() { return !Harness::run(specification); }

69
TESTS/bike-computer/sensor-device/main.cpp Normal file
View File

@ -0,0 +1,69 @@
// 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 main.cpp
* @author Serge Ayer <serge.ayer@hefr.ch>
*
* @brief Bike computer test suite: sensor device
*
* @date 2023-08-26
* @version 0.1.0
***************************************************************************/
#include "greentea-client/test_env.h"
#include "hdc1000.hpp"
#include "mbed.h"
#include "sensor_device.hpp"
#include "unity/unity.h"
#include "utest/utest.h"
using namespace utest::v1;
// test_hdc1000 test handler function
static control_t test_sensor_device(const size_t call_count) {
// create the SensorDevice instance
bike_computer::SensorDevice sensorDevice;
bool rc = sensorDevice.init();
TEST_ASSERT_TRUE(rc);
float temperature = sensorDevice.readTemperature();
static constexpr float kTemperatureRange = 20.0f;
static constexpr float kMeanTemperature = 15.0f;
TEST_ASSERT_FLOAT_WITHIN(kTemperatureRange, kMeanTemperature, temperature);
float humidity = sensorDevice.readHumidity();
static constexpr float kHumidityRange = 40.0f;
static constexpr float kMeanHumidity = 50.0f;
TEST_ASSERT_FLOAT_WITHIN(kHumidityRange, kMeanHumidity, humidity);
// execute the test only once and move to the next one, without waiting
return CaseNext;
}
static utest::v1::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
// name of our Python file)
GREENTEA_SETUP(60, "default_auto");
return greentea_test_setup_handler(number_of_cases);
}
// List of test cases in this file
static Case cases[] = {Case("test sensor device", test_sensor_device)};
static Specification specification(greentea_setup, cases);
int main() { return !Harness::run(specification); }

354
TESTS/bike-computer/speedometer/main.cpp Normal file
View File

@ -0,0 +1,354 @@
// 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 main.cpp
* @author Serge Ayer <serge.ayer@hefr.ch>
*
* @brief Bike computer test suite: speedometer device
*
* @date 2023-08-26
* @version 0.1.0
***************************************************************************/
#include <chrono>
#include "common/constants.hpp"
#include "common/speedometer.hpp"
#include "greentea-client/test_env.h"
#include "mbed.h"
#include "static_scheduling/gear_device.hpp"
#include "unity/unity.h"
#include "utest/utest.h"
using namespace utest::v1;
// allow for 0.1 km/h difference
static constexpr float kAllowedSpeedDelta = 0.1f;
// allow for 1m difference
static constexpr float kAllowedDistanceDelta = 1.0f / 1000.0;
// function called by test handler functions for verifying the current speed
void check_current_speed(const std::chrono::milliseconds& pedalRotationTime,
uint8_t traySize,
uint8_t gearSize,
float wheelCircumference,
float currentSpeed) {
// compute the number of pedal rotation per hour
uint32_t milliSecondsPerHour = 1000 * 3600;
float pedalRotationsPerHour = static_cast<float>(milliSecondsPerHour) /
static_cast<float>(pedalRotationTime.count());
// compute the expected speed in km / h
// first compute the distance in meter for each pedal turn
float trayGearRatio = static_cast<float>(traySize) / static_cast<float>(gearSize);
float distancePerPedalTurn = trayGearRatio * wheelCircumference;
float expectedSpeed = (distancePerPedalTurn / 1000.0f) * pedalRotationsPerHour;
printf(" Expected speed is %f, current speed is %f\n", expectedSpeed, currentSpeed);
TEST_ASSERT_FLOAT_WITHIN(kAllowedSpeedDelta, expectedSpeed, currentSpeed);
}
// compute the traveled distance for a time interval
float compute_distance(const std::chrono::milliseconds& pedalRotationTime,
uint8_t traySize,
uint8_t gearSize,
float wheelCircumference,
const std::chrono::milliseconds& travelTime) {
// compute the number of pedal rotation during travel time
// both times are expressed in ms
float pedalRotations = static_cast<float>(travelTime.count()) /
static_cast<float>(pedalRotationTime.count());
// compute the distance in meter for each pedal turn
float trayGearRatio = static_cast<float>(traySize) / static_cast<float>(gearSize);
float distancePerPedalTurn = trayGearRatio * wheelCircumference;
// distancePerPedalTurn is expressed in m, divide per 1000 for a distance in km
return (distancePerPedalTurn * pedalRotations) / 1000.0;
}
// function called by test handler functions for verifying the distance traveled
void check_distance(const std::chrono::milliseconds& pedalRotationTime,
uint8_t traySize,
uint8_t gearSize,
float wheelCircumference,
const std::chrono::milliseconds& travelTime,
float distance) {
// distancePerPedalTurn is expressed in m, divide per 1000 for a distance in km
float expectedDistance = compute_distance(
pedalRotationTime, traySize, gearSize, wheelCircumference, travelTime);
printf(" Expected distance is %f, current distance is %f\n",
expectedDistance,
distance);
TEST_ASSERT_FLOAT_WITHIN(kAllowedDistanceDelta, expectedDistance, distance);
}
// test the speedometer by modifying the gear
static control_t test_gear_size(const size_t call_count) {
// create a timer
Timer timer;
// start the timer
timer.start();
// create a speedometer instance
bike_computer::Speedometer speedometer(timer);
// get speedometer constant values (for this test)
const auto traySize = speedometer.getTraySize();
const auto wheelCircumference = speedometer.getWheelCircumference();
const auto pedalRotationTime = speedometer.getCurrentPedalRotationTime();
for (uint8_t gearSize = bike_computer::kMinGearSize;
gearSize <= bike_computer::kMaxGearSize;
gearSize++) {
// set the gear
printf("Testing gear size %d\n", gearSize);
speedometer.setGearSize(gearSize);
// get the current speed
auto currentSpeed = speedometer.getCurrentSpeed();
// check the speed against the expected one
check_current_speed(
pedalRotationTime, traySize, gearSize, wheelCircumference, currentSpeed);
}
// execute the test only once and move to the next one, without waiting
return CaseNext;
}
// test the speedometer by modifying the pedal rotation speed
static control_t test_rotation_speed(const size_t call_count) {
// create a timer
Timer timer;
// start the timer
timer.start();
// create a speedometer instance
bike_computer::Speedometer speedometer(timer);
// set the gear size
speedometer.setGearSize(bike_computer::kMaxGearSize);
// get speedometer constant values
const auto traySize = speedometer.getTraySize();
const auto wheelCircumference = speedometer.getWheelCircumference();
const auto gearSize = speedometer.getGearSize();
// first test increasing rotation speed (decreasing rotation time)
auto pedalRotationTime = speedometer.getCurrentPedalRotationTime();
while (pedalRotationTime > bike_computer::kMinPedalRotationTime) {
// decrease the pedal rotation time
pedalRotationTime -= bike_computer::kDeltaPedalRotationTime;
speedometer.setCurrentRotationTime(pedalRotationTime);
// get the current speed
const auto currentSpeed = speedometer.getCurrentSpeed();
// check the speed against the expected one
check_current_speed(
pedalRotationTime, traySize, gearSize, wheelCircumference, currentSpeed);
}
// second test decreasing rotation speed (increasing rotation time)
pedalRotationTime = speedometer.getCurrentPedalRotationTime();
while (pedalRotationTime < bike_computer::kMaxPedalRotationTime) {
// increase the pedal rotation time
pedalRotationTime += bike_computer::kDeltaPedalRotationTime;
speedometer.setCurrentRotationTime(pedalRotationTime);
// get the current speed
const auto currentSpeed = speedometer.getCurrentSpeed();
// check the speed against the expected one
check_current_speed(
pedalRotationTime, traySize, gearSize, wheelCircumference, currentSpeed);
}
// execute the test only once and move to the next one, without waiting
return CaseNext;
}
// test the speedometer by modifying the pedal rotation speed
static control_t test_distance(const size_t call_count) {
// create a timer
Timer timer;
// create a speedometer instance
bike_computer::Speedometer speedometer(timer);
// set the gear size
speedometer.setGearSize(bike_computer::kMaxGearSize);
// get speedometer constant values
const auto traySize = speedometer.getTraySize();
const auto wheelCircumference = speedometer.getWheelCircumference();
auto gearSize = speedometer.getGearSize();
auto pedalRotationTime = speedometer.getCurrentPedalRotationTime();
// test different travel times
const std::chrono::milliseconds travelTimes[] = {500ms, 1000ms, 5s, 10s};
const uint8_t nbrOfTravelTimes = sizeof(travelTimes) / sizeof(travelTimes[0]);
// start the timer (for simulating bike start)
timer.start();
// first check travel distance without changing gear and rotation speed
std::chrono::milliseconds totalTravelTime = std::chrono::milliseconds::zero();
for (uint8_t index = 0; index < nbrOfTravelTimes; index++) {
// run for the travel time and get the distance
ThisThread::sleep_for(travelTimes[index]);
// get the distance traveled
const auto distance = speedometer.getDistance();
// accumulate travel time
totalTravelTime += travelTimes[index];
// check the distance vs the expected one
check_distance(pedalRotationTime,
traySize,
gearSize,
wheelCircumference,
totalTravelTime,
distance);
}
// now change gear at each time interval
auto expectedDistance = speedometer.getDistance();
for (uint8_t index = 0; index < nbrOfTravelTimes; index++) {
// update the gear size
gearSize++;
speedometer.setGearSize(gearSize);
// run for the travel time and get the distance
ThisThread::sleep_for(travelTimes[index]);
// compute the expected distance for this time segment
float distance = compute_distance(pedalRotationTime,
traySize,
gearSize,
wheelCircumference,
travelTimes[index]);
expectedDistance += distance;
// get the distance traveled
const auto traveledDistance = speedometer.getDistance();
printf(" Expected distance is %f, current distance is %f\n",
expectedDistance,
traveledDistance);
TEST_ASSERT_FLOAT_WITHIN(
kAllowedDistanceDelta, expectedDistance, traveledDistance);
}
// now change rotation speed at each time interval
expectedDistance = speedometer.getDistance();
for (uint8_t index = 0; index < nbrOfTravelTimes; index++) {
// update the rotation speed
pedalRotationTime += bike_computer::kDeltaPedalRotationTime;
speedometer.setCurrentRotationTime(pedalRotationTime);
// run for the travel time and get the distance
ThisThread::sleep_for(travelTimes[index]);
// compute the expected distance for this time segment
float distance = compute_distance(pedalRotationTime,
traySize,
gearSize,
wheelCircumference,
travelTimes[index]);
expectedDistance += distance;
// get the distance traveled
const auto traveledDistance = speedometer.getDistance();
printf(" Expected distance is %f, current distance is %f\n",
expectedDistance,
traveledDistance);
TEST_ASSERT_FLOAT_WITHIN(
kAllowedDistanceDelta, expectedDistance, traveledDistance);
}
// execute the test only once and move to the next one, without waiting
return CaseNext;
}
// test the speedometer by modifying the pedal rotation speed
static control_t test_reset(const size_t call_count) {
// create a timer instance
Timer timer;
// create a speedometer instance
bike_computer::Speedometer speedometer(timer);
// set the gear size
speedometer.setGearSize(bike_computer::kMinGearSize);
// get speedometer constant values
const auto traySize = speedometer.getTraySize();
const auto wheelCircumference = speedometer.getWheelCircumference();
const auto gearSize = speedometer.getGearSize();
const auto pedalRotationTime = speedometer.getCurrentPedalRotationTime();
// start the timer (for simulating bike start)
timer.start();
// travel for 1 second
const auto travelTime = 1000ms;
ThisThread::sleep_for(travelTime);
// check the expected distaance traveled
const auto expectedDistance = compute_distance(
pedalRotationTime, traySize, gearSize, wheelCircumference, travelTime);
// get the distance traveled
auto traveledDistance = speedometer.getDistance();
printf(" Expected distance is %f, current distance is %f\n",
expectedDistance,
traveledDistance);
TEST_ASSERT_FLOAT_WITHIN(kAllowedDistanceDelta, expectedDistance, traveledDistance);
// reset the speedometer
speedometer.reset();
// traveled distance should now be zero
traveledDistance = speedometer.getDistance();
printf(" Expected distance is %f, current distance is %f\n", 0.0f, traveledDistance);
TEST_ASSERT_FLOAT_WITHIN(kAllowedDistanceDelta, 0.0f, traveledDistance);
// execute the test only once and move to the next one, without waiting
return CaseNext;
}
static utest::v1::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
// name of our Python file)
GREENTEA_SETUP(180, "default_auto");
return greentea_test_setup_handler(number_of_cases);
}
// List of test cases in this file
static Case cases[] = {
Case("test speedometer gear size change", test_gear_size),
Case("test speedometer rotation speed change", test_rotation_speed),
Case("test speedometer distance", test_distance),
Case("test speedometer reset", test_reset)};
static Specification specification(greentea_setup, cases);
int main() { return !Harness::run(specification); }

1
advdembsof_library.lib Normal file
View File

@ -0,0 +1 @@
https://github.com/SergeAyer/advdembsof_library/#c0687fc795de83780fa9e7e935c9f465d697cc2a

60
common/constants.hpp Normal file
View File

@ -0,0 +1,60 @@
// 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 constants.hpp
* @author Serge Ayer <serge.ayer@hefr.ch>
*
* @brief Constants definition used for implementing the bike system
*
* @date 2023-08-20
* @version 1.0.0
***************************************************************************/
#pragma once
#include <stdint.h>
#include "mbed.h"
namespace bike_computer {
// gear related constants
static constexpr uint8_t kMinGear = 1;
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 - kMaxGear;
// pedal related constants
// When compiling and linking with gcc, we get a link error when using static
// constexpr. The error is related to template instantiation.
// definition of pedal rotation initial time (corresponds to 80 turn / min)
static constexpr std::chrono::milliseconds kInitialPedalRotationTime = 750ms;
// definition of pedal minimal rotation time (corresponds to 160 turn / min)
static constexpr std::chrono::milliseconds kMinPedalRotationTime = 375ms;
// definition of pedal maximal rotation time (corresponds to 10 turn / min)
static constexpr std::chrono::milliseconds kMaxPedalRotationTime = 1500ms;
// definition of pedal rotation time change upon acceleration/deceleration
static constexpr std::chrono::milliseconds kDeltaPedalRotationTime = 25ms;
static constexpr uint32_t kNbrOfSteps = static_cast<uint32_t>(
(
bike_computer::kMaxPedalRotationTime - bike_computer::kMinPedalRotationTime
).count() / bike_computer::kDeltaPedalRotationTime.count()
);
} // namespace bike_computer

21
common/sensor_device.cpp Normal file
View File

@ -0,0 +1,21 @@
#include "sensor_device.hpp"
namespace bike_computer {
SensorDevice::SensorDevice() : _hdc1000(I2C_SDA, I2C_SCL, STMOD_11)
{}
bool SensorDevice::init() {
return this->_hdc1000.probe();
}
float SensorDevice::readTemperature(void) {
return this->_hdc1000.getTemperature();
}
float SensorDevice::readHumidity(void) {
return this->_hdc1000.getHumidity();
}
} // bike_computer

49
common/sensor_device.hpp Normal file
View File

@ -0,0 +1,49 @@
// 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 sensor_device.hpp
* @author Serge Ayer <serge.ayer@hefr.ch>
*
* @brief SensorDevice header file (static scheduling)
*
* @date 2023-08-20
* @version 1.0.0
***************************************************************************/
#pragma once
#include "hdc1000.hpp"
#include "mbed.h"
namespace bike_computer {
class SensorDevice {
public:
// constructor
SensorDevice();
// method for initializing the device
bool init();
// methods used for
float readTemperature(void);
float readHumidity(void);
private:
// data members
advembsof::HDC1000 _hdc1000;
};
} // namespace bike_computer

144
common/speedometer.cpp Normal file
View File

@ -0,0 +1,144 @@
// 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 speedometer_device.cpp
* @author Serge Ayer <serge.ayer@hefr.ch>
*
* @brief WheelCounterDevice implementation (static scheduling)
*
* @date 2023-08-20
* @version 1.0.0
***************************************************************************/
#include "speedometer.hpp"
#include "static_scheduling/gear_device.hpp"
#include <chrono>
#include <ratio>
// from disco_h747i/wrappers
#include "joystick.hpp"
#include "mbed_trace.h"
#if MBED_CONF_MBED_TRACE_ENABLE
#define TRACE_GROUP "Speedometer"
#endif // MBED_CONF_MBED_TRACE_ENABLE
namespace bike_computer {
Speedometer::Speedometer(Timer& timer) : _timer(timer) {
// update _lastTime
_lastTime = _timer.elapsed_time();
}
void Speedometer::setCurrentRotationTime(
const std::chrono::milliseconds& currentRotationTime) {
if (_pedalRotationTime != currentRotationTime) {
// compute distance before changing the rotation time
computeDistance();
// change pedal rotation time
_pedalRotationTime = currentRotationTime;
// compute speed with the new pedal rotation time
computeSpeed();
}
}
void Speedometer::setGearSize(uint8_t gearSize) {
if (_gearSize != gearSize) {
// compute distance before chaning the gear size
computeDistance();
// change gear size
_gearSize = gearSize;
// compute speed with the new gear size
computeSpeed();
}
}
float Speedometer::getCurrentSpeed() const { return _currentSpeed; }
float Speedometer::getDistance() {
// make sure to update the distance traveled
computeDistance();
return _totalDistance;
}
void Speedometer::reset() {
// TODO : done
this->_totalDistanceMutex.lock();
this->_totalDistance = 0.0f;
this->_totalDistanceMutex.unlock();
}
#if defined(MBED_TEST_MODE)
uint8_t Speedometer::getGearSize() const { return _gearSize; }
float Speedometer::getWheelCircumference() const { return kWheelCircumference; }
float Speedometer::getTraySize() const { return kTraySize; }
std::chrono::milliseconds Speedometer::getCurrentPedalRotationTime() const {
return _pedalRotationTime;
}
#endif // defined(MBED_TEST_MODE)
void Speedometer::computeSpeed() {
// For computing the speed given a rear gear (braquet), one must divide the size of
// the tray (plateau) by the size of the rear gear (pignon arrière), and then multiply
// the result by the circumference of the wheel. Example: tray = 50, rear gear = 15.
// Distance run with one pedal turn (wheel circumference = 2.10 m) = 50/15 * 2.1 m
// = 6.99m If you ride at 80 pedal turns / min, you run a distance of 6.99 * 80 / min
// ~= 560 m / min = 33.6 km/h
// TODO : done
//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);
float pedal_rotation_per_hour = ms_in_hour / static_cast<float>(_pedalRotationTime.count());
float gear_ratio = static_cast<float>(kTraySize) / static_cast<float>(this->_gearSize);
float wheel_dist_km = static_cast<float>(this->kWheelCircumference) / 1000.0;
this->_currentSpeed = gear_ratio * wheel_dist_km * pedal_rotation_per_hour;
}
void Speedometer::computeDistance() {
// For computing the speed given a rear gear (braquet), one must divide the size of
// the tray (plateau) by the size of the rear gear (pignon arrière), and then multiply
// the result by the circumference of the wheel. Example: tray = 50, rear gear = 15.
// Distance run with one pedal turn (wheel circumference = 2.10 m) = 50/15 * 2.1 m
// = 6.99m If you ride at 80 pedal turns / min, you run a distance of 6.99 * 80 / min
// ~= 560 m / min = 33.6 km/h. We then multiply the speed by the time for getting the
// distance traveled.
// TODO : done
Speedometer::computeSpeed();
// compute distance
const std::chrono::microseconds timeNow = _timer.elapsed_time();
const std::chrono::microseconds timeDiff = timeNow - _lastTime;
constexpr float ms_in_hour = static_cast<float>(3600 * 1000);
float traveled_dist = _currentSpeed * timeDiff.count() / (ms_in_hour*1000.0/*μs*/);
this->_totalDistanceMutex.lock();
this->_totalDistance += traveled_dist;
this->_totalDistanceMutex.unlock();
_lastTime = _timer.elapsed_time();
}
} // namespace bike_computer

91
common/speedometer.hpp Normal file
View File

@ -0,0 +1,91 @@
// 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 speedometer_device.hpp
* @author Serge Ayer <serge.ayer@hefr.ch>
*
* @brief WheelCounterDevice header file (static scheduling)
*
* @date 2023-08-20
* @version 1.0.0
***************************************************************************/
#pragma once
#include "constants.hpp"
#include "mbed.h"
namespace bike_computer {
class Speedometer {
public:
explicit Speedometer(Timer& timer); // NOLINT(runtime/references)
// method used for setting the current pedal rotation time
void setCurrentRotationTime(const std::chrono::milliseconds& currentRotationTime);
// method used for setting/getting the current gear
void setGearSize(uint8_t gearSize);
// method called for getting the current speed (expressed in km / h)
float getCurrentSpeed() const;
// method called for getting the current traveled distance (expressed in km)
float getDistance();
// method called for resetting the traveled distance
void reset();
// methods used for tests only
#if defined(MBED_TEST_MODE)
uint8_t getGearSize() const;
float getWheelCircumference() const;
float getTraySize() const;
std::chrono::milliseconds getCurrentPedalRotationTime() const;
void setOnResetCallback(mbed::Callback<void()> cb);
#endif // defined(MBED_TEST_MODE)
private:
// private methods
void computeSpeed();
void computeDistance();
// definition of task period time
static constexpr std::chrono::milliseconds kTaskPeriod = 400ms;
// definition of task execution time
static constexpr std::chrono::microseconds kTaskRunTime = 200000us;
// constants related to speed computation
static constexpr float kWheelCircumference = 2.1f;
static constexpr uint8_t kTraySize = 50;
std::chrono::microseconds _lastTime = std::chrono::microseconds::zero();
std::chrono::milliseconds _pedalRotationTime = kInitialPedalRotationTime;
// data members
Timer& _timer;
LowPowerTicker _ticker;
float _currentSpeed = 0.0f;
Mutex _totalDistanceMutex;
float _totalDistance = 0.0f;
uint8_t _gearSize = 1;
Thread _thread;
#if defined(MBED_TEST_MODE)
mbed::Callback<void()> _cb;
#endif
};
} // namespace bike_computer

22
main.cpp
View File

@ -6,19 +6,25 @@
#if !MBED_TEST_MODE #if !MBED_TEST_MODE
#include "mbed.h" // NOLINT #include "mbed.h" // NOLINT
#include "mbed_trace.h"
//#include "static_scheduling/bike_system.hpp"
#include "static_scheduling_with_event/bike_system.hpp"
// Blinking rate in milliseconds #if defined(MBED_CONF_MBED_TRACE_ENABLE)
#define BLINKING_RATE 500ms #define TRACE_GROUP "MAIN"
#endif // MBED_CONF_MBED_TRACE_ENAB
int main() { int main() {
// Initialise the digital pin LED1 as an output #if defined(MBED_CONF_MBED_TRACE_ENABLE)
mbed_trace_init();
#endif
DigitalOut led(LED1); // static_scheduling::BikeSystem bikeSystem;
// bikeSystem.start();
// bikeSystem.startWithEventQueue();
while (true) { static_scheduling_with_event::BikeSystem bikeSystem;
led = !led; bikeSystem.start();
ThisThread::sleep_for(BLINKING_RATE);
}
} }
#endif // MBED_TEST_MODE #endif // MBED_TEST_MODE

1
mbed_app.json
View File

@ -14,6 +14,7 @@
"platform.stdio-baud-rate": 115200, "platform.stdio-baud-rate": 115200,
"platform.default-serial-baud-rate": 115200, "platform.default-serial-baud-rate": 115200,
"platform.stdio-buffered-serial": true, "platform.stdio-buffered-serial": true,
"platform.all-stats-enabled": true,
"target.printf_lib":"minimal-printf", "target.printf_lib":"minimal-printf",
"platform.minimal-printf-enable-floating-point": true, "platform.minimal-printf-enable-floating-point": true,
"platform.minimal-printf-set-floating-point-max-decimals": 2 "platform.minimal-printf-set-floating-point-max-decimals": 2

308
static_scheduling/bike_system.cpp Normal file
View File

@ -0,0 +1,308 @@
// 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 bike_system.cpp
* @author Serge Ayer <serge.ayer@hefr.ch>
* @author Rémi Heredero <remi@heredero.ch>
* @author Yann Sierro <yannsierro.pro@gmail.com>
*
* @brief Bike System implementation (static scheduling)
*
* @date 2023-11-15
* @version 1.1.0
***************************************************************************/
#include "bike_system.hpp"
#include <chrono>
#include "mbed_trace.h"
#if MBED_CONF_MBED_TRACE_ENABLE
#define TRACE_GROUP "BikeSystem"
#endif // MBED_CONF_MBED_TRACE_ENABLE
namespace static_scheduling {
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 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() :
_gearDevice(_timer),
_pedalDevice(_timer),
_resetDevice(_timer),
_speedometer(_timer),
_cpuLogger(_timer)
{
}
void BikeSystem::start() {
tr_info("Starting Super-Loop without event handling");
init();
while (true) {
auto startTime = _timer.elapsed_time();
gearTask(); // 100ms : 0ms -> 100ms
speedDistanceTask(); // 200ms : 100ms -> 300ms
displayTask1(); // 200ms : 300ms -> 500ms
speedDistanceTask(); // 200ms : 500ms -> 700ms
resetTask(); // 100ms : 700ms -> 800ms
gearTask(); // 100ms : 800ms -> 900ms
speedDistanceTask(); // 200ms : 900ms -> 1100ms
temperatureTask(); // 100ms : 1100ms -> 1200ms
displayTask2(); // 100ms : 1200ms -> 1300ms
speedDistanceTask(); // 200ms : 1300ms -> 1500ms
resetTask(); // 100ms : 1500ms -> 1600ms
// register the time at the end of the cyclic schedule period and print the
// elapsed time for the period
std::chrono::microseconds endTime = _timer.elapsed_time();
const auto cycle =
std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime);
tr_debug("Repeating cycle time is %" PRIu64 " milliseconds", cycle.count());
// TODO: implement loop exit when applicable
// Done
bool fStop = false;
core_util_atomic_load(&fStop);
if (fStop) {
break;
}
#if !defined(MBED_TEST_MODE)
_cpuLogger.printStats();
#endif
}
}
void BikeSystem::startWithEventQueue() {
tr_info("Starting Super-Loop with event handling");
init();
EventQueue eventQueue;
Event<void()> gearEvent(&eventQueue, callback(this, &BikeSystem::gearTask));
gearEvent.delay(kGearTaskDelay);
gearEvent.period(kGearTaskPeriod);
gearEvent.post();
Event<void()> speedDistanceEvent(&eventQueue, callback(this, &BikeSystem::speedDistanceTask));
speedDistanceEvent.delay(kSpeedDistanceTaskDelay);
speedDistanceEvent.period(kSpeedDistanceTaskPeriod);
speedDistanceEvent.post();
Event<void()> display1Event(&eventQueue, callback(this, &BikeSystem::displayTask1));
display1Event.delay(kDisplayTask1Delay);
display1Event.period(kDisplayTask1Period);
display1Event.post();
Event<void()> resetEvent(&eventQueue, callback(this, &BikeSystem::resetTask));
resetEvent.delay(kResetTaskDelay);
resetEvent.period(kResetTaskPeriod);
resetEvent.post();
Event<void()> temperatureEvent(&eventQueue, callback(this, &BikeSystem::temperatureTask));
temperatureEvent.delay(kTemperatureTaskDelay);
temperatureEvent.period(kTemperatureTaskPeriod);
temperatureEvent.post();
Event<void()> display2Event(&eventQueue, callback(this, &BikeSystem::displayTask2));
display2Event.delay(kDisplayTask2Delay);
display2Event.period(kDisplayTask2Period);
display2Event.post();
#if !defined(MBED_TEST_MODE)
Event<void()> cpuEvent(&eventQueue, callback(this, &BikeSystem::cpuTask));
cpuEvent.delay(kCPUTaskDelay);
cpuEvent.period(kCPUTaskPeriod);
cpuEvent.post();
#endif
eventQueue.dispatch_forever();
}
void BikeSystem::stop() { core_util_atomic_store_bool(&_stopFlag, true); }
#if defined(MBED_TEST_MODE)
const advembsof::TaskLogger& BikeSystem::getTaskLogger() { return _taskLogger; }
#endif // defined(MBED_TEST_MODE)
void BikeSystem::init() {
// start the timer
_timer.start();
// initialize the lcd display
disco::ReturnCode rc = _displayDevice.init();
if (rc != disco::ReturnCode::Ok) {
tr_error("Failed to initialized the lcd display: %d", static_cast<int>(rc));
}
// initialize the sensor device
bool present = _sensorDevice.init();
if (!present) {
tr_error("Sensor not present or initialization failed");
}
// enable/disable task logging
_taskLogger.enable(true);
}
void BikeSystem::gearTask() {
// gear task
auto taskStartTime = _timer.elapsed_time();
// no need to protect access to data members (single threaded)
_currentGear = _gearDevice.getCurrentGear();
_currentGearSize = _gearDevice.getCurrentGearSize();
_taskLogger.logPeriodAndExecutionTime(
_timer, advembsof::TaskLogger::kGearTaskIndex, taskStartTime
);
}
void BikeSystem::speedDistanceTask() {
// speed and distance task
auto taskStartTime = _timer.elapsed_time();
const auto pedalRotationTime = _pedalDevice.getCurrentRotationTime();
_speedometer.setCurrentRotationTime(pedalRotationTime);
_speedometer.setGearSize(_currentGearSize);
// no need to protect access to data members (single threaded)
_currentSpeed = _speedometer.getCurrentSpeed();
_traveledDistance = _speedometer.getDistance();
_taskLogger.logPeriodAndExecutionTime(
_timer, advembsof::TaskLogger::kSpeedTaskIndex, taskStartTime
);
}
void BikeSystem::temperatureTask() {
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());
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;
// }
_taskLogger.logPeriodAndExecutionTime(
_timer, advembsof::TaskLogger::kTemperatureTaskIndex, taskStartTime);
}
void BikeSystem::resetTask() {
auto taskStartTime = _timer.elapsed_time();
if (_resetDevice.checkReset()) {
std::chrono::microseconds responseTime =
_timer.elapsed_time() - _resetDevice.getPressTime();
tr_info("Reset task: response time is %" PRIu64 " usecs", responseTime.count());
_speedometer.reset();
}
_taskLogger.logPeriodAndExecutionTime(
_timer, advembsof::TaskLogger::kResetTaskIndex, taskStartTime);
}
void BikeSystem::displayTask1() {
auto taskStartTime = _timer.elapsed_time();
_displayDevice.displayGear(_currentGear);
_displayDevice.displaySpeed(_currentSpeed);
_displayDevice.displayDistance(_traveledDistance);
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;
// }
_taskLogger.logPeriodAndExecutionTime(
_timer, advembsof::TaskLogger::kDisplayTask1Index, taskStartTime);
}
void BikeSystem::displayTask2() {
auto taskStartTime = _timer.elapsed_time();
_displayDevice.displayTemperature(_currentTemperature);
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);
}
void BikeSystem::cpuTask() {
_cpuLogger.printStats();
}
} // namespace static_scheduling

106
static_scheduling/bike_system.hpp Normal file
View File

@ -0,0 +1,106 @@
// 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 bike_system.hpp
* @author Serge Ayer <serge.ayer@hefr.ch>
*
* @brief Bike System header file (static scheduling)
*
* @date 2023-08-20
* @version 1.0.0
***************************************************************************/
#pragma once
// from advembsof
#include "display_device.hpp"
#include "task_logger.hpp"
#include "cpu_logger.hpp"
// from common
#include "sensor_device.hpp"
#include "speedometer.hpp"
// local
#include "gear_device.hpp"
#include "pedal_device.hpp"
#include "reset_device.hpp"
namespace static_scheduling {
class BikeSystem {
public:
// constructor
BikeSystem();
// make the class non copyable
BikeSystem(BikeSystem&) = delete;
BikeSystem& operator=(BikeSystem&) = delete;
// method called in main() for starting the system
void start();
// method called in main() for starting the sysytem with the event queue
void startWithEventQueue();
// method called for stopping the system
void stop();
#if defined(MBED_TEST_MODE)
const advembsof::TaskLogger& getTaskLogger();
#endif // defined(MBED_TEST_MODE)
private:
// private methods
void init();
void gearTask();
void speedDistanceTask();
void temperatureTask();
void resetTask();
void displayTask1();
void displayTask2();
void cpuTask();
// stop flag, used for stopping the super-loop (set in stop())
bool _stopFlag = false;
// timer instance used for loggint task time and used by ResetDevice
Timer _timer;
// data member that represents the device for manipulating the gear
GearDevice _gearDevice;
uint8_t _currentGear = bike_computer::kMinGear;
uint8_t _currentGearSize = bike_computer::kMinGearSize;
// data member that represents the device for manipulating the pedal rotation
// speed/time
PedalDevice _pedalDevice;
float _currentSpeed = 0.0f;
float _traveledDistance = 0.0f;
// data member that represents the device used for resetting
ResetDevice _resetDevice;
// data member that represents the device display
advembsof::DisplayDevice _displayDevice;
// data member that represents the device for counting wheel rotations
bike_computer::Speedometer _speedometer;
// data member that represents the sensor device
bike_computer::SensorDevice _sensorDevice;
float _currentTemperature = 0.0f;
// used for logging task info
advembsof::TaskLogger _taskLogger;
// cpu logger to measure cpu usage
advembsof::CPULogger _cpuLogger;
};
} // namespace static_scheduling

83
static_scheduling/gear_device.cpp Normal file
View File

@ -0,0 +1,83 @@
// 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 gear_device.cpp
* @author Serge Ayer <serge.ayer@hefr.ch>
*
* @brief Gear Device implementation (static scheduling)
*
* @date 2023-08-20
* @version 1.0.0
***************************************************************************/
#include "gear_device.hpp"
// from disco_h747i/wrappers
#include <chrono>
#include "joystick.hpp"
#include "mbed_trace.h"
#if MBED_CONF_MBED_TRACE_ENABLE
#define TRACE_GROUP "GearDevice"
#endif // MBED_CONF_MBED_TRACE_ENABLE
namespace static_scheduling {
// definition of task execution time
static constexpr std::chrono::microseconds kTaskRunTime = 100000us;
GearDevice::GearDevice(Timer& timer) : _timer(timer) {}
uint8_t GearDevice::getCurrentGear() {
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();
switch (joystickState) {
case disco::Joystick::State::UpPressed:
if (_currentGear < bike_computer::kMaxGear) {
_currentGear++;
}
hasChanged = true;
break;
case disco::Joystick::State::DownPressed:
if (_currentGear > bike_computer::kMinGear) {
_currentGear--;
}
hasChanged = true;
break;
default:
break;
}
}
elapsedTime = _timer.elapsed_time() - initialTime;
}
return _currentGear;
}
uint8_t GearDevice::getCurrentGearSize() const {
// simulate task computation by waiting for the required task run time
// wait_us(kTaskRunTime.count());
return bike_computer::kMaxGearSize - _currentGear;
}
} // namespace static_scheduling

50
static_scheduling/gear_device.hpp Normal file
View File

@ -0,0 +1,50 @@
// 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 gear_device.hpp
* @author Serge Ayer <serge.ayer@hefr.ch>
*
* @brief Gear Device header file (static scheduling)
*
* @date 2023-08-20
* @version 1.0.0
***************************************************************************/
#pragma once
#include "constants.hpp"
#include "mbed.h"
namespace static_scheduling {
class GearDevice {
public:
explicit GearDevice(Timer& timer); // NOLINT(runtime/references)
// make the class non copyable
GearDevice(GearDevice&) = delete;
GearDevice& operator=(GearDevice&) = delete;
// method called for updating the bike system
uint8_t getCurrentGear();
uint8_t getCurrentGearSize() const;
private:
// data members
uint8_t _currentGear = bike_computer::kMinGear;
Timer& _timer;
};
} // namespace static_scheduling

72
static_scheduling/pedal_device.cpp Normal file
View File

@ -0,0 +1,72 @@
/****************************************************************************
* @file pedal_device.cpp
* @author Rémi Heredero <remi@heredero.ch>
* @author Yann Sierro <yannsierro.pro@gmail.com>
*
* @brief Pedal Device implementation (static scheduling)
* @date 2024-11-09
* @version 0.1.0
****************************************************************************/
#include "pedal_device.hpp"
// from disco_h747i/wrappers
#include <chrono>
#include "joystick.hpp"
#include "mbed_trace.h"
#if MBED_CONF_MBED_TRACE_ENABLE
#define TRACE_GROUP "PedalDevice"
#endif // MBED_CONF_MBED_TRACE_ENABLE
namespace static_scheduling {
static constexpr std::chrono::microseconds kTaskRunTime = 200000us;
PedalDevice::PedalDevice(Timer& timer) : _timer(timer) {}
std::chrono::milliseconds PedalDevice::getCurrentRotationTime() {
// TODO
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();
switch (joystickState) {
case disco::Joystick::State::LeftPressed:
if (_pedalRotationTime < bike_computer::kMaxPedalRotationTime) {
decreaseRotationSpeed();
hasChanged = true;
}
break;
case disco::Joystick::State::DownPressed:
if (_pedalRotationTime > bike_computer::kMinPedalRotationTime) {
decreaseRotationSpeed();
hasChanged = true;
}
break;
default:
break;
}
}
elapsedTime = _timer.elapsed_time() - initialTime;
}
return _pedalRotationTime;
}
void PedalDevice::increaseRotationSpeed() {
_pedalRotationTime -= bike_computer::kDeltaPedalRotationTime;
}
void PedalDevice::decreaseRotationSpeed() {
_pedalRotationTime += bike_computer::kDeltaPedalRotationTime;
}
}

54
static_scheduling/pedal_device.hpp Normal file
View File

@ -0,0 +1,54 @@
// 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.hpp
* @author Serge Ayer <serge.ayer@hefr.ch>
*
* @brief Pedal System header file (static scheduling)
*
* @date 2023-08-20
* @version 1.0.0
***************************************************************************/
#pragma once
#include "constants.hpp"
#include "mbed.h"
namespace static_scheduling {
class PedalDevice {
public:
explicit PedalDevice(Timer& timer); // NOLINT(runtime/references)
// make the class non copyable
PedalDevice(PedalDevice&) = delete;
PedalDevice& operator=(PedalDevice&) = delete;
// method called for updating the bike system
std::chrono::milliseconds getCurrentRotationTime();
private:
// private methods
void increaseRotationSpeed();
void decreaseRotationSpeed();
// data members
std::chrono::milliseconds _pedalRotationTime =
bike_computer::kInitialPedalRotationTime;
Timer& _timer;
};
} // namespace static_scheduling

63
static_scheduling/reset_device.cpp Normal file
View File

@ -0,0 +1,63 @@
/****************************************************************************
* @file reset_device.cpp
* @author Rémi Heredero <remi@heredero.ch>
* @author Yann Sierro <yannsierro.pro@gmail.com>
*
* @brief Reset Device implementation (static scheduling)
* @date 2024-11-12
* @version 0.1.0
****************************************************************************/
#include "reset_device.hpp"
// from disco_h747i/wrappers
#include <chrono>
#include "joystick.hpp"
#include "mbed_trace.h"
#if defined(TARGET_DISCO_H747I)
#define PUSH_BUTTON BUTTON1
static constexpr uint8_t kPolarityPressed = 1;
#endif
#if MBED_CONF_MBED_TRACE_ENABLE
#define TRACE_GROUP "ResetDevice"
#endif // MBED_CONF_MBED_TRACE_ENABLE
namespace static_scheduling {
static constexpr std::chrono::microseconds kTaskRunTime = 100000us;
ResetDevice::ResetDevice(Timer& timer) : _timer(timer), _resetButton(PUSH_BUTTON) {
_resetButton.rise(callback(this, &ResetDevice::onRise));
}
bool ResetDevice::checkReset() {
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 isPressed = false;
while (elapsedTime < kTaskRunTime) {
if(!isPressed) {
isPressed = _resetButton.read() == kPolarityPressed;
}
elapsedTime = _timer.elapsed_time() - initialTime;
}
return isPressed;
}
std::chrono::microseconds ResetDevice::getPressTime() {
return _pressTime;
}
void ResetDevice::onRise() {
_pressTime = _timer.elapsed_time();
}
}

56
static_scheduling/reset_device.hpp Normal file
View File

@ -0,0 +1,56 @@
// 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.hpp
* @author Serge Ayer <serge.ayer@hefr.ch>
*
* @brief ResetDevice header file (static scheduling)
*
* @date 2023-08-20
* @version 1.0.0
***************************************************************************/
#pragma once
#include "mbed.h"
namespace static_scheduling {
class ResetDevice {
public:
explicit ResetDevice(Timer& timer); // NOLINT(runtime/references)
// make the class non copyable
ResetDevice(ResetDevice&) = delete;
ResetDevice& operator=(ResetDevice&) = delete;
// method called for checking the reset status
bool checkReset();
// for computing the response time
std::chrono::microseconds getPressTime();
private:
// called when the button is pressed
void onRise();
// data members
// instance representing the reset button
InterruptIn _resetButton;
Timer& _timer;
std::chrono::microseconds _pressTime;
};
} // namespace static_scheduling

255
static_scheduling_with_event/bike_system.cpp Normal file
View File

@ -0,0 +1,255 @@
// 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 bike_system.cpp
* @author Serge Ayer <serge.ayer@hefr.ch>
* @author Rémi Heredero <remi@heredero.ch>
* @author Yann Sierro <yannsierro.pro@gmail.com>
*
* @brief Bike System implementation (static scheduling)
*
* @date 2023-11-15
* @version 1.1.0
***************************************************************************/
#include "bike_system.hpp"
#include <chrono>
#include "mbed_trace.h"
#if MBED_CONF_MBED_TRACE_ENABLE
#define TRACE_GROUP "BikeSystem"
#endif // MBED_CONF_MBED_TRACE_ENABLE
namespace static_scheduling_with_event {
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 = 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 = 1200ms;
static constexpr std::chrono::milliseconds kCPUTaskComputationTime = 100ms;
BikeSystem::BikeSystem() :
_gearDevice(),
_pedalDevice(),
_resetDevice(callback(this, &BikeSystem::onReset)),
_speedometer(_timer),
_cpuLogger(_timer)
{
}
void BikeSystem::start() {
tr_info("Starting Super-Loop with event handling");
init();
EventQueue eventQueue;
Event<void()> gearEvent(&eventQueue, callback(this, &BikeSystem::gearTask));
gearEvent.delay(kGearTaskDelay);
gearEvent.period(kGearTaskPeriod);
gearEvent.post();
Event<void()> speedDistanceEvent(&eventQueue, callback(this, &BikeSystem::speedDistanceTask));
speedDistanceEvent.delay(kSpeedDistanceTaskDelay);
speedDistanceEvent.period(kSpeedDistanceTaskPeriod);
speedDistanceEvent.post();
Event<void()> display1Event(&eventQueue, callback(this, &BikeSystem::displayTask1));
display1Event.delay(kDisplayTask1Delay);
display1Event.period(kDisplayTask1Period);
display1Event.post();
Event<void()> resetEvent(&eventQueue, callback(this, &BikeSystem::resetTask));
resetEvent.delay(kResetTaskDelay);
resetEvent.period(kResetTaskPeriod);
resetEvent.post();
Event<void()> temperatureEvent(&eventQueue, callback(this, &BikeSystem::temperatureTask));
temperatureEvent.delay(kTemperatureTaskDelay);
temperatureEvent.period(kTemperatureTaskPeriod);
temperatureEvent.post();
Event<void()> display2Event(&eventQueue, callback(this, &BikeSystem::displayTask2));
display2Event.delay(kDisplayTask2Delay);
display2Event.period(kDisplayTask2Period);
display2Event.post();
#if !defined(MBED_TEST_MODE)
Event<void()> cpuEvent(&eventQueue, callback(this, &BikeSystem::cpuTask));
cpuEvent.delay(kCPUTaskDelay);
cpuEvent.period(kCPUTaskPeriod);
cpuEvent.post();
#endif
eventQueue.dispatch_forever();
}
void BikeSystem::onReset() {
_resetTime = _timer.elapsed_time();
core_util_atomic_store_bool(&_resetFlag, true);
}
void BikeSystem::stop() { core_util_atomic_store_bool(&_stopFlag, true); }
#if defined(MBED_TEST_MODE)
const advembsof::TaskLogger& BikeSystem::getTaskLogger() { return _taskLogger; }
#endif // defined(MBED_TEST_MODE)
void BikeSystem::init() {
// start the timer
_timer.start();
// initialize the lcd display
disco::ReturnCode rc = _displayDevice.init();
if (rc != disco::ReturnCode::Ok) {
tr_error("Failed to initialized the lcd display: %d", static_cast<int>(rc));
}
// initialize the sensor device
bool present = _sensorDevice.init();
if (!present) {
tr_error("Sensor not present or initialization failed");
}
// enable/disable task logging
_taskLogger.enable(true);
}
void BikeSystem::gearTask() {
// gear task
auto taskStartTime = _timer.elapsed_time();
// no need to protect access to data members (single threaded)
_currentGear = _gearDevice.getCurrentGear();
_currentGearSize = _gearDevice.getCurrentGearSize();
_taskLogger.logPeriodAndExecutionTime(
_timer, advembsof::TaskLogger::kGearTaskIndex, taskStartTime
);
}
void BikeSystem::speedDistanceTask() {
auto taskStartTime = _timer.elapsed_time();
const auto pedalRotationTime = _pedalDevice.getCurrentRotationTime();
_speedometer.setCurrentRotationTime(pedalRotationTime);
_speedometer.setGearSize(_currentGearSize);
_currentSpeed = _speedometer.getCurrentSpeed();
_traveledDistance = _speedometer.getDistance();
_taskLogger.logPeriodAndExecutionTime(
_timer, advembsof::TaskLogger::kSpeedTaskIndex, taskStartTime
);
}
void BikeSystem::temperatureTask() {
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());
ThisThread::sleep_for(
std::chrono::duration_cast<std::chrono::milliseconds>(
kTemperatureTaskComputationTime - (_timer.elapsed_time() - taskStartTime)
)
);
_taskLogger.logPeriodAndExecutionTime(
_timer, advembsof::TaskLogger::kTemperatureTaskIndex, taskStartTime);
}
void BikeSystem::resetTask() {
auto taskStartTime = _timer.elapsed_time();
if (core_util_atomic_load_bool(&_resetFlag)) {
std::chrono::microseconds responseTime = _timer.elapsed_time() - _resetTime;
tr_info("Reset task: response time is %" PRIu64 " usecs", responseTime.count());
_speedometer.reset();
core_util_atomic_store_bool(&_resetFlag, false);
}
_taskLogger.logPeriodAndExecutionTime(
_timer, advembsof::TaskLogger::kResetTaskIndex, taskStartTime);
}
void BikeSystem::displayTask1() {
auto taskStartTime = _timer.elapsed_time();
_displayDevice.displayGear(_currentGear);
_displayDevice.displaySpeed(_currentSpeed);
_displayDevice.displayDistance(_traveledDistance);
ThisThread::sleep_for(
std::chrono::duration_cast<std::chrono::milliseconds>(
kDisplayTask1ComputationTime - (_timer.elapsed_time() - taskStartTime)
)
);
_taskLogger.logPeriodAndExecutionTime(
_timer, advembsof::TaskLogger::kDisplayTask1Index, taskStartTime);
}
void BikeSystem::displayTask2() {
auto taskStartTime = _timer.elapsed_time();
_displayDevice.displayTemperature(_currentTemperature);
ThisThread::sleep_for(
std::chrono::duration_cast<std::chrono::milliseconds>(
kDisplayTask2ComputationTime - (_timer.elapsed_time() - taskStartTime)
)
);
_taskLogger.logPeriodAndExecutionTime(
_timer, advembsof::TaskLogger::kDisplayTask2Index, taskStartTime);
}
void BikeSystem::cpuTask() {
_cpuLogger.printStats();
}
} // namespace static_scheduling

111
static_scheduling_with_event/bike_system.hpp Normal file
View File

@ -0,0 +1,111 @@
// 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 bike_system.hpp
* @author Serge Ayer <serge.ayer@hefr.ch>
*
* @brief Bike System header file (static scheduling)
*
* @date 2023-08-20
* @version 1.0.0
***************************************************************************/
#pragma once
// from advembsof
#include "display_device.hpp"
#include "task_logger.hpp"
#include "cpu_logger.hpp"
// from common
#include "sensor_device.hpp"
#include "speedometer.hpp"
// local
#include "gear_device.hpp"
#include "pedal_device.hpp"
#include "reset_device.hpp"
namespace static_scheduling_with_event {
class BikeSystem {
public:
// constructor
BikeSystem();
// make the class non copyable
BikeSystem(BikeSystem&) = delete;
BikeSystem& operator=(BikeSystem&) = delete;
// method called in main() for starting the system
void start();
// method called in main() for starting the sysytem with the event queue
void startWithEventQueue();
// method called for stopping the system
void stop();
#if defined(MBED_TEST_MODE)
const advembsof::TaskLogger& getTaskLogger();
#endif // defined(MBED_TEST_MODE)
private:
// private methods
void init();
void onReset();
void gearTask();
void speedDistanceTask();
void temperatureTask();
void resetTask();
void displayTask1();
void displayTask2();
void cpuTask();
// stop flag, used for stopping the super-loop (set in stop())
bool _stopFlag = false;
std::chrono::microseconds _resetTime = std::chrono::microseconds::zero();
volatile bool _resetFlag = false;
// timer instance used for loggint task time and used by ResetDevice
Timer _timer;
// data member that represents the device for manipulating the gear
GearDevice _gearDevice;
uint8_t _currentGear = bike_computer::kMinGear;
uint8_t _currentGearSize = bike_computer::kMinGearSize;
// data member that represents the device for manipulating the pedal rotation
// speed/time
PedalDevice _pedalDevice;
float _currentSpeed = 0.0f;
float _traveledDistance = 0.0f;
// data member that represents the device used for resetting
ResetDevice _resetDevice;
// data member that represents the device display
advembsof::DisplayDevice _displayDevice;
// data member that represents the device for counting wheel rotations
bike_computer::Speedometer _speedometer;
// data member that represents the sensor device
bike_computer::SensorDevice _sensorDevice;
float _currentTemperature = 0.0f;
// used for logging task info
advembsof::TaskLogger _taskLogger;
// cpu logger to measure cpu usage
advembsof::CPULogger _cpuLogger;
};
} // namespace static_scheduling

69
static_scheduling_with_event/gear_device.cpp Normal file
View File

@ -0,0 +1,69 @@
// 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 gear_device.cpp
* @author Serge Ayer <serge.ayer@hefr.ch>
* @author Rémi Heredero <remi@heredero.ch>
* @author Yann Sierro <yannsierro.pro@gmail.com>
*
* @brief Gear Device implementation (static scheduling)
*
* @date 2023-11-17
* @version 1.1.0
***************************************************************************/
#include "gear_device.hpp"
// from disco_h747i/wrappers
#include <chrono>
#include "joystick.hpp"
#include "mbed_trace.h"
#if MBED_CONF_MBED_TRACE_ENABLE
#define TRACE_GROUP "GearDevice"
#endif // MBED_CONF_MBED_TRACE_ENABLE
namespace static_scheduling_with_event {
GearDevice::GearDevice() {
disco::Joystick::getInstance().setUpCallback(
callback(this, &GearDevice::onUp));
disco::Joystick::getInstance().setDownCallback(
callback(this, &GearDevice::onDown));
}
uint8_t GearDevice::getCurrentGear() {
return core_util_atomic_load_u8(&_currentGear);
}
uint8_t GearDevice::getCurrentGearSize() const {
return bike_computer::kMaxGearSize - core_util_atomic_load_u8(&_currentGear);
}
void GearDevice::onUp() {
if (_currentGear < bike_computer::kMaxGear) {
core_util_atomic_incr_u8(&_currentGear, 1);
}
}
void GearDevice::onDown() {
if (_currentGear > bike_computer::kMinGear) {
core_util_atomic_decr_u8(&_currentGear, 1);
}
}
} // namespace static_scheduling

54
static_scheduling_with_event/gear_device.hpp Normal file
View File

@ -0,0 +1,54 @@
// 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 gear_device.hpp
* @author Serge Ayer <serge.ayer@hefr.ch>
* @author Rémi Heredero <remi@heredero.ch>
* @author Yann Sierro <yannsierro.pro@gmail.com>
*
* @brief Gear Device header file (static scheduling)
*
* @date 2023-11-17
* @version 1.1.0
***************************************************************************/
#pragma once
#include "constants.hpp"
#include "mbed.h"
namespace static_scheduling_with_event {
class GearDevice {
public:
explicit GearDevice(); // NOLINT(runtime/references)
// make the class non copyable
GearDevice(GearDevice&) = delete;
GearDevice& operator=(GearDevice&) = delete;
// method called for updating the bike system
uint8_t getCurrentGear();
uint8_t getCurrentGearSize() const;
void onUp();
void onDown();
private:
// data members
volatile uint8_t _currentGear = bike_computer::kMinGear;
};
} // namespace static_scheduling

62
static_scheduling_with_event/pedal_device.cpp Normal file
View File

@ -0,0 +1,62 @@
/****************************************************************************
* @file pedal_device.cpp
* @author Rémi Heredero <remi@heredero.ch>
* @author Yann Sierro <yannsierro.pro@gmail.com>
*
* @brief Pedal Device implementation (static scheduling)
* @date 2024-11-17
* @version 1.1.0
****************************************************************************/
#include "pedal_device.hpp"
// from disco_h747i/wrappers
#include <chrono>
#include "joystick.hpp"
#include "mbed_trace.h"
#if MBED_CONF_MBED_TRACE_ENABLE
#define TRACE_GROUP "PedalDevice"
#endif // MBED_CONF_MBED_TRACE_ENABLE
namespace static_scheduling_with_event {
PedalDevice::PedalDevice() {
disco::Joystick::getInstance().setLeftCallback(
callback(this, &PedalDevice::onLeft)
);
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();
}
}

60
static_scheduling_with_event/pedal_device.hpp Normal file
View File

@ -0,0 +1,60 @@
// 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.hpp
* @author Serge Ayer <serge.ayer@hefr.ch>
* @author Rémi Heredero <remi@heredero.ch>
* @author Yann Sierro <yannsierro.pro@gmail.com>
*
* @brief Pedal System header file (static scheduling)
*
* @date 2023-11-17
* @version 1.1.0
***************************************************************************/
#pragma once
#include "constants.hpp"
#include "mbed.h"
namespace static_scheduling_with_event {
class PedalDevice {
public:
PedalDevice(); // NOLINT(runtime/references)
// make the class non copyable
PedalDevice(PedalDevice&) = delete;
PedalDevice& operator=(PedalDevice&) = delete;
// method called for updating the bike system
std::chrono::milliseconds getCurrentRotationTime();
private:
// private methods
void onLeft();
void onRight();
void increaseRotationSpeed();
void decreaseRotationSpeed();
// data members
volatile uint32_t _currentStep = static_cast<uint32_t>(
(
bike_computer::kInitialPedalRotationTime - bike_computer::kMinPedalRotationTime
).count() / bike_computer::kDeltaPedalRotationTime.count()
);
};
} // namespace static_scheduling

36
static_scheduling_with_event/reset_device.cpp Normal file
View File

@ -0,0 +1,36 @@
/****************************************************************************
* @file reset_device.cpp
* @author Rémi Heredero <remi@heredero.ch>
* @author Yann Sierro <yannsierro.pro@gmail.com>
*
* @brief Reset Device implementation (static scheduling with event)
* @date 2024-11-17
* @version 1.1.0
****************************************************************************/
#include "reset_device.hpp"
// from disco_h747i/wrappers
#include <chrono>
#include "joystick.hpp"
#include "mbed_trace.h"
#if defined(TARGET_DISCO_H747I)
#define PUSH_BUTTON BUTTON1
static constexpr uint8_t kPolarityPressed = 1;
#endif
#if MBED_CONF_MBED_TRACE_ENABLE
#define TRACE_GROUP "ResetDevice"
#endif // MBED_CONF_MBED_TRACE_ENABLE
namespace static_scheduling_with_event {
ResetDevice::ResetDevice(Callback<void()> cb) : _resetButton(PUSH_BUTTON) {
_resetButton.fall(cb);
}
}

48
static_scheduling_with_event/reset_device.hpp Normal file
View File

@ -0,0 +1,48 @@
// 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.hpp
* @author Serge Ayer <serge.ayer@hefr.ch>
* @author Rémi Heredero <remi@heredero.ch>
* @author Yann Sierro <yannsierro.pro@gmail.com>
*
* @brief ResetDevice header file (static scheduling with event)
*
* @date 2023-11-17
* @version 1.1.0
***************************************************************************/
#pragma once
#include "mbed.h"
namespace static_scheduling_with_event {
class ResetDevice {
public:
explicit ResetDevice(Callback<void()> cb); // NOLINT(runtime/references)
// make the class non copyable
ResetDevice(ResetDevice&) = delete;
ResetDevice& operator=(ResetDevice&) = delete;
private:
// data members
// instance representing the reset button
InterruptIn _resetButton;
};
} // namespace static_scheduling