From c92de22c09f251ee3b6e5678321d911b0851e013 Mon Sep 17 00:00:00 2001 From: fastium Date: Tue, 26 Nov 2024 16:26:41 +0100 Subject: [PATCH] ADD create files for multi tasking and modify the main --- main.cpp | 4 +- multi_tasking/bike_system.cpp | 255 +++++++++++++++++++++++++++++++++ multi_tasking/bike_system.hpp | 111 ++++++++++++++ multi_tasking/gear_device.cpp | 69 +++++++++ multi_tasking/gear_device.hpp | 54 +++++++ multi_tasking/pedal_device.cpp | 62 ++++++++ multi_tasking/pedal_device.hpp | 60 ++++++++ multi_tasking/reset_device.cpp | 36 +++++ multi_tasking/reset_device.hpp | 48 +++++++ 9 files changed, 697 insertions(+), 2 deletions(-) create mode 100644 multi_tasking/bike_system.cpp create mode 100644 multi_tasking/bike_system.hpp create mode 100644 multi_tasking/gear_device.cpp create mode 100644 multi_tasking/gear_device.hpp create mode 100644 multi_tasking/pedal_device.cpp create mode 100644 multi_tasking/pedal_device.hpp create mode 100644 multi_tasking/reset_device.cpp create mode 100644 multi_tasking/reset_device.hpp diff --git a/main.cpp b/main.cpp index f8b2f75..ec5fb49 100644 --- a/main.cpp +++ b/main.cpp @@ -8,7 +8,7 @@ #include "mbed.h" // NOLINT #include "mbed_trace.h" //#include "static_scheduling/bike_system.hpp" -#include "static_scheduling_with_event/bike_system.hpp" +#include "multi_tasking/bike_system.hpp" #if defined(MBED_CONF_MBED_TRACE_ENABLE) #define TRACE_GROUP "MAIN" @@ -23,7 +23,7 @@ int main() { // bikeSystem.start(); // bikeSystem.startWithEventQueue(); - static_scheduling_with_event::BikeSystem bikeSystem; + multi_tasking::BikeSystem bikeSystem; bikeSystem.start(); } diff --git a/multi_tasking/bike_system.cpp b/multi_tasking/bike_system.cpp new file mode 100644 index 0000000..b037753 --- /dev/null +++ b/multi_tasking/bike_system.cpp @@ -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 + * @author Rémi Heredero + * @author Yann Sierro + * + * @brief Bike System implementation (static scheduling) + * + * @date 2023-11-15 + * @version 1.1.0 + ***************************************************************************/ + +#include "bike_system.hpp" + +#include + +#include "mbed_trace.h" +#if MBED_CONF_MBED_TRACE_ENABLE +#define TRACE_GROUP "BikeSystem" +#endif // MBED_CONF_MBED_TRACE_ENABLE + +namespace multi_tasking { + +static constexpr std::chrono::milliseconds kGearTaskPeriod = 800ms; +static constexpr std::chrono::milliseconds kGearTaskDelay = 0ms; +static constexpr std::chrono::milliseconds kGearTaskComputationTime = 100ms; + +static constexpr std::chrono::milliseconds kSpeedDistanceTaskPeriod = 400ms; +static constexpr std::chrono::milliseconds kSpeedDistanceTaskDelay = 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 gearEvent(&eventQueue, callback(this, &BikeSystem::gearTask)); + gearEvent.delay(kGearTaskDelay); + gearEvent.period(kGearTaskPeriod); + gearEvent.post(); + + Event speedDistanceEvent(&eventQueue, callback(this, &BikeSystem::speedDistanceTask)); + speedDistanceEvent.delay(kSpeedDistanceTaskDelay); + speedDistanceEvent.period(kSpeedDistanceTaskPeriod); + speedDistanceEvent.post(); + + Event display1Event(&eventQueue, callback(this, &BikeSystem::displayTask1)); + display1Event.delay(kDisplayTask1Delay); + display1Event.period(kDisplayTask1Period); + display1Event.post(); + + Event resetEvent(&eventQueue, callback(this, &BikeSystem::resetTask)); + resetEvent.delay(kResetTaskDelay); + resetEvent.period(kResetTaskPeriod); + resetEvent.post(); + + Event temperatureEvent(&eventQueue, callback(this, &BikeSystem::temperatureTask)); + temperatureEvent.delay(kTemperatureTaskDelay); + temperatureEvent.period(kTemperatureTaskPeriod); + temperatureEvent.post(); + + Event display2Event(&eventQueue, callback(this, &BikeSystem::displayTask2)); + display2Event.delay(kDisplayTask2Delay); + display2Event.period(kDisplayTask2Period); + display2Event.post(); + + #if !defined(MBED_TEST_MODE) + Event 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(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( + 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( + 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( + kDisplayTask2ComputationTime - (_timer.elapsed_time() - taskStartTime) + ) + ); + + _taskLogger.logPeriodAndExecutionTime( + _timer, advembsof::TaskLogger::kDisplayTask2Index, taskStartTime); +} + +void BikeSystem::cpuTask() { + _cpuLogger.printStats(); +} + +} // namespace static_scheduling diff --git a/multi_tasking/bike_system.hpp b/multi_tasking/bike_system.hpp new file mode 100644 index 0000000..d9de4d0 --- /dev/null +++ b/multi_tasking/bike_system.hpp @@ -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 + * + * @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 multi_tasking { + +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 diff --git a/multi_tasking/gear_device.cpp b/multi_tasking/gear_device.cpp new file mode 100644 index 0000000..2d58274 --- /dev/null +++ b/multi_tasking/gear_device.cpp @@ -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 + * @author Rémi Heredero + * @author Yann Sierro + * + * @brief Gear Device implementation (static scheduling) + * + * @date 2023-11-17 + * @version 1.1.0 + ***************************************************************************/ + +#include "gear_device.hpp" + +// from disco_h747i/wrappers +#include + +#include "joystick.hpp" +#include "mbed_trace.h" + +#if MBED_CONF_MBED_TRACE_ENABLE +#define TRACE_GROUP "GearDevice" +#endif // MBED_CONF_MBED_TRACE_ENABLE + +namespace multi_tasking { + + +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 diff --git a/multi_tasking/gear_device.hpp b/multi_tasking/gear_device.hpp new file mode 100644 index 0000000..156be30 --- /dev/null +++ b/multi_tasking/gear_device.hpp @@ -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 + * @author Rémi Heredero + * @author Yann Sierro + * + * @brief Gear Device header file (static scheduling) + * + * @date 2023-11-17 + * @version 1.1.0 + ***************************************************************************/ + +#pragma once + +#include "constants.hpp" +#include "mbed.h" + +namespace multi_tasking { + +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 diff --git a/multi_tasking/pedal_device.cpp b/multi_tasking/pedal_device.cpp new file mode 100644 index 0000000..350d0ac --- /dev/null +++ b/multi_tasking/pedal_device.cpp @@ -0,0 +1,62 @@ +/**************************************************************************** +* @file pedal_device.cpp +* @author Rémi Heredero +* @author Yann Sierro +* +* @brief Pedal Device implementation (static scheduling) +* @date 2024-11-17 +* @version 1.1.0 +****************************************************************************/ + +#include "pedal_device.hpp" + +// from disco_h747i/wrappers +#include + +#include "joystick.hpp" +#include "mbed_trace.h" + +#if MBED_CONF_MBED_TRACE_ENABLE +#define TRACE_GROUP "PedalDevice" +#endif // MBED_CONF_MBED_TRACE_ENABLE + +namespace multi_tasking { + + 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(); + } + +} diff --git a/multi_tasking/pedal_device.hpp b/multi_tasking/pedal_device.hpp new file mode 100644 index 0000000..7bb60cd --- /dev/null +++ b/multi_tasking/pedal_device.hpp @@ -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 + * @author Rémi Heredero + * @author Yann Sierro + * + * @brief Pedal System header file (static scheduling) + * + * @date 2023-11-17 + * @version 1.1.0 + ***************************************************************************/ + +#pragma once + +#include "constants.hpp" +#include "mbed.h" + +namespace multi_tasking { + +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( + ( + bike_computer::kInitialPedalRotationTime - bike_computer::kMinPedalRotationTime + ).count() / bike_computer::kDeltaPedalRotationTime.count() + ); +}; + +} // namespace static_scheduling diff --git a/multi_tasking/reset_device.cpp b/multi_tasking/reset_device.cpp new file mode 100644 index 0000000..65a6747 --- /dev/null +++ b/multi_tasking/reset_device.cpp @@ -0,0 +1,36 @@ +/**************************************************************************** +* @file reset_device.cpp +* @author Rémi Heredero +* @author Yann Sierro +* +* @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 + +#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 multi_tasking { + + ResetDevice::ResetDevice(Callback cb) : _resetButton(PUSH_BUTTON) { + _resetButton.fall(cb); + } + + +} diff --git a/multi_tasking/reset_device.hpp b/multi_tasking/reset_device.hpp new file mode 100644 index 0000000..0df096f --- /dev/null +++ b/multi_tasking/reset_device.hpp @@ -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 + * @author Rémi Heredero + * @author Yann Sierro + * + * @brief ResetDevice header file (static scheduling with event) + * + * @date 2023-11-17 + * @version 1.1.0 + ***************************************************************************/ + +#pragma once + +#include "mbed.h" + +namespace multi_tasking { + +class ResetDevice { + public: + explicit ResetDevice(Callback 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