ALPAKA/rtos2-utils
1
0
Fork 0
mirror of https://git.intern.spaceteamaachen.de/ALPAKA/rtos2-utils.git synced 2025-06-10 01:55:59 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

cleanup: removed deprecated rtos watchdog

Browse Source
This commit is contained in:
CarlWachter 2024-11-03 12:50:06 +01:00
parent 345c74bdab
commit ee81a9c64f
4 changed files with 0 additions and 209 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
README.md
View File

@ -25,16 +25,6 @@ Mainly defers to the TACOS CAN module, but provides a simple interface for sendi
Expandable for isotp.
## Watchdog
The watchdog task waits for signals sent either from its heartbeat timer or manually via `sta::notifyWatchdog`
and passes the event flags to the `sta::watchdogEventHandler` function. This function must be implemented by the application.
Configuration:
* `#define STA_RTOS_WATCHDOG_ENABLE`: Enable module
* `#define STA_RTOS_WATCHDOG_TIMER_PERIOD <period_ticks>`: Set period in ticks of heartbeat timer (default: 1000)
# STA-Core Interfaces
The library provides implementations for the following interfaces using CMSIS-RTOS2 functionality:

92
include/sta/rtos/system/watchdog.hpp
View File

@ -1,92 +0,0 @@
/**
* @file
* @brief Implementation of watchdog system task.
*/
#ifndef STA_RTOS_SYSTEM_WATCHDOG_HPP
#define STA_RTOS_SYSTEM_WATCHDOG_HPP
/**
* @defgroup STA_RTOS_Watchdog Watchdog task
* @ingroup STA_RTOS_API
* @brief Watchdog system task.
*
* Check @ref STA_RTOS_BuildConfig for configuration options.
*/
#ifdef DOXYGEN
/**
* @brief Enable module.
*
* @ingroup STA_RTOS_BuildConfig
*/
# define STA_RTOS_WATCHDOG_ENABLE
#endif // DOXYGEN
/**
* @def STA_RTOS_SYSTEM_WATCHDOG_TIMER_PERIOD
* @brief Set period in ticks of heartbeat timer.
*
* @ingroup STA_RTOS_BuildConfig
*/
#ifndef STA_RTOS_SYSTEM_WATCHDOG_TIMER_PERIOD
# define STA_RTOS_SYSTEM_WATCHDOG_TIMER_PERIOD 1000
#endif // !STA_RTOS_SYSTEM_WATCHDOG_TIMER_PERIOD
#include <sta/config.hpp>
#ifdef STA_RTOS_WATCHDOG_ENABLE
#include <cstdint>
// Watchdog task flags
//
/**
* @brief Watchdog heartbeat flag.
*
* @ingroup STA_RTOS_Watchdog
*/
#define STA_WATCHDOG_FLAG_HEARTBEAT 0x00001000U
namespace sta
{
namespace rtos
{
/**
* @brief Initialize system watchdog.
*
* @ingroup STA_RTOS_Watchdog
*/
void initWatchdog();
/**
* @brief Send notification to watchdog task.
*
* @ingroup STA_RTOS_Watchdog
*/
void notifyWatchdog(uint32_t flags);
/**
* @brief Handler for watchdog events.
*
* Must be implemented by application.
*
* @param arg Watchdog task argument
* @param flags Event flags
*
* @ingroup STA_RTOS_Watchdog
*/
void watchdogEventHandler(void * arg, uint32_t flags);
} // namespace rtos
} // namespace sta
#endif // STA_RTOS_WATCHDOG_ENABLE
#endif // STA_RTOS_SYSTEM_WATCHDOG_HPP

6
src/system/startup.cpp
View File

@ -1,6 +1,4 @@
#include <sta/rtos/system/events.hpp>
#include <sta/rtos/system/watchdog.hpp>
namespace sta
{
@ -13,10 +11,6 @@ namespace sta
initSystemEvents();
#endif // STA_RTOS_SYSTEM_EVENTS_ENABLE
#ifdef STA_RTOS_WATCHDOG_ENABLE
initWatchdog();
#endif // STA_RTOS_WATCHDOG_ENABLE
}
} // namespace rtos
} // namespace sta

101
src/system/watchdog.cpp
View File

@ -1,101 +0,0 @@
#include <sta/rtos/system/watchdog.hpp>
#ifdef STA_RTOS_WATCHDOG_ENABLE
#include <sta/debug/assert.hpp>
#include <sta/debug/debug.hpp>
#include <sta/lang.hpp>
#include <sta/rtos/defs.hpp>
#include <sta/rtos/system/events.hpp>
#include <cmsis_os2.h>
#include <FreeRTOS.h>
namespace
{
StaticTask_t watchdogCB;
StaticTimer_t watchdogTimerCB;
osThreadId_t watchdogTaskHandle = nullptr;
osTimerId_t watchdogTimerHandle = nullptr;
// Static stack memory
uint32_t stackBuffer[256];
}
extern "C"
{
void watchdogTask(void * arg);
void watchdogTimerCallback(void *);
}
namespace sta
{
namespace rtos
{
void initWatchdog()
{
// Create thread using static allocation
const osThreadAttr_t taskAttributes = {
.name = "sysWatchdog",
.cb_mem = &watchdogCB,
.cb_size = sizeof(watchdogCB),
.stack_mem = &stackBuffer[0],
.stack_size = sizeof(stackBuffer),
.priority = (osPriority_t) osPriorityLow,
};
watchdogTaskHandle = osThreadNew(watchdogTask, NULL, &taskAttributes);
STA_ASSERT_MSG(watchdogTaskHandle != nullptr, "System watchdog task initialization failed");
// Create timer using static allocation
const osTimerAttr_t timerAttributes = {
.name = "sysWatchdogTimer",
.attr_bits = 0, // Reserved, must be set to 0
.cb_mem = &watchdogTimerCB,
.cb_size = sizeof(watchdogTimerCB)
};
watchdogTimerHandle = osTimerNew(watchdogTimerCallback, osTimerPeriodic, nullptr, &timerAttributes);
STA_ASSERT_MSG(watchdogTimerHandle != nullptr, "System watchdog timer initialization failed");
osTimerStart(watchdogTimerHandle, STA_RTOS_SYSTEM_WATCHDOG_TIMER_PERIOD);
}
void notifyWatchdog(uint32_t flags)
{
STA_ASSERT_MSG(watchdogTaskHandle != nullptr, "System watchdog not initialized");
osThreadFlagsSet(watchdogTaskHandle, flags);
}
} // namespace rtos
} // namespace sta
void watchdogTask(void * arg)
{
sta::rtos::waitForStartupEvent();
while (true)
{
// Wait for any flag to be set
uint32_t flags = osThreadFlagsWait(STA_RTOS_THREAD_FLAGS_VALID_BITS, osFlagsWaitAny, osWaitForever);
// Call event handler
sta::rtos::watchdogEventHandler(arg, flags);
}
}
void watchdogTimerCallback(void *)
{
// Notify watchdog task to send heartbeat message
// Required because blocking in a timer callback is not allowed
osThreadFlagsSet(watchdogTaskHandle, STA_WATCHDOG_FLAG_HEARTBEAT);
}
#endif // STA_RTOS_WATCHDOG_ENABLE