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

ADD threads dispatcher and drive reset with event

Browse Source
This commit is contained in:
fastium 2024-12-30 16:56:04 +01:00
parent da79a18cd9
commit 69bc8785a8
3 changed files with 56 additions and 144 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

135
multi_tasking/bike_system.cpp
View File

@ -35,104 +35,29 @@
namespace multi_tasking { namespace multi_tasking {
static constexpr std::chrono::milliseconds kGearTaskPeriod = 800ms; BikeSystem::BikeSystem()
static constexpr std::chrono::milliseconds kGearTaskDelay = 0ms; : _gearDevice(),
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(), _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() {
// new thread dedicated for ISRs with its event queue // new thread dedicated for ISRs with its event queue
tr_info("Starting Super-Loop with event handling"); tr_info("Starting Super-Loop with event handling");
init(); init();
EventQueue eventQueue; _isrEventThread.start(callback(this, &BikeSystem::dispatch_isr_events));
_mainEventThread.start(callback(this, &BikeSystem::dispatch_events));
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() { void BikeSystem::onReset() {
_resetTime = _timer.elapsed_time(); Event<void()> resetEvent(&_isrEventQueue, callback(this, &BikeSystem::resetTask));
core_util_atomic_store_bool(&_resetFlag, true); resetEvent.post();
} }
void BikeSystem::stop() { core_util_atomic_store_bool(&_stopFlag, true); }
#if defined(MBED_TEST_MODE) #if defined(MBED_TEST_MODE)
const advembsof::TaskLogger& BikeSystem::getTaskLogger() { return _taskLogger; } const advembsof::TaskLogger& BikeSystem::getTaskLogger() { return _taskLogger; }
#endif // defined(MBED_TEST_MODE) #endif // defined(MBED_TEST_MODE)
@ -166,8 +91,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() {
@ -181,25 +105,21 @@ void BikeSystem::speedDistanceTask() {
_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);
@ -208,14 +128,9 @@ void BikeSystem::temperatureTask() {
void BikeSystem::resetTask() { void BikeSystem::resetTask() {
auto taskStartTime = _timer.elapsed_time(); 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()); tr_info("Reset task: response time is %" PRIu64 " usecs", responseTime.count());
_speedometer.reset(); _speedometer.reset();
core_util_atomic_store_bool(&_resetFlag, false);
}
_taskLogger.logPeriodAndExecutionTime( _taskLogger.logPeriodAndExecutionTime(
_timer, advembsof::TaskLogger::kResetTaskIndex, taskStartTime); _timer, advembsof::TaskLogger::kResetTaskIndex, taskStartTime);
} }
@ -227,11 +142,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);
@ -242,18 +154,17 @@ 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 void BikeSystem::dispatch_isr_events() { _isrEventQueue.dispatch_forever(); }
void BikeSystem::dispatch_events() { _eventQueue.dispatch_forever(); }
} // namespace multi_tasking

23
multi_tasking/bike_system.hpp
View File

@ -26,9 +26,10 @@
// from advembsof // from advembsof
#include "EventQueue.h" #include "EventQueue.h"
#include "display_device.hpp"
#include "task_logger.hpp"
#include "cpu_logger.hpp" #include "cpu_logger.hpp"
#include "display_device.hpp"
#include "mbed.h"
#include "task_logger.hpp"
// from common // from common
#include "sensor_device.hpp" #include "sensor_device.hpp"
@ -75,12 +76,6 @@ class BikeSystem {
void displayTask2(); void displayTask2();
void cpuTask(); 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 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
@ -109,7 +104,15 @@ class BikeSystem {
advembsof::CPULogger _cpuLogger; advembsof::CPULogger _cpuLogger;
// Event queues // Event queues
EventQueue * _isrEventQueue; EventQueue _isrEventQueue;
EventQueue _eventQueue;
// Tread for isr events
Thread _isrEventThread;
Thread _mainEventThread;
void dispatch_isr_events();
void dispatch_events();
}; };
} // namespace static_scheduling } // namespace multi_tasking

24
multi_tasking/reset_device.cpp
View File

@ -1,12 +1,12 @@
/**************************************************************************** /****************************************************************************
* @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 +21,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 multi_tasking { namespace multi_tasking {
ResetDevice::ResetDevice(Callback<void()> cb) : _resetButton(PUSH_BUTTON) { ResetDevice::ResetDevice(Callback<void()> cb) : _resetButton(PUSH_BUTTON) {
_resetButton.fall(cb); _resetButton.fall(cb);
}
} }
} // namespace multi_tasking