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

Change include paths

Browse Source
This commit is contained in:
Henrik Stickann 2022-05-07 00:24:58 +02:00
parent 941de7e064
commit baef731e1a
22 changed files with 335 additions and 335 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
include/sta/os2/defs.hpp
View File

@ -1,16 +0,0 @@
/**
* @brief Constants and macros for use with CMSIS RTOS2.
*/
#ifndef STA_OS2_DEFS_HPP
#define STA_OS2_DEFS_HPP
// See limits defined in cmsis_os2.c
#define STA_OS2_MAX_BITS_TASK_NOTIFY 31U
#define STA_OS2_MAX_BITS_EVENT_GROUPS 24U
#define STA_OS2_THREAD_FLAGS_VALID_BITS ((1UL << STA_OS2_MAX_BITS_TASK_NOTIFY) - 1U)
#define STA_OS2_EVENT_FLAGS_VALID_BITS ((1UL << STA_OS2_MAX_BITS_EVENT_GROUPS) - 1U)
#endif // STA_OS2_DEFS_HPP

45
include/sta/os2/easy_config.hpp
View File

@ -1,45 +0,0 @@
/**
* @brief Helper for easy system task setup in `<sta/config.hpp>`.
*
* Configuration:
* STA_OS2_SYSTEM_TASKS_ENABLE: Enable all system tasks and required features
* STA_OS2_WATCHDOG_TIMER_NAME: Set watchdog timer handle and callback names based on this
* STA_OS2_WATCHDOG_NAME: Set watchdog task handle and entry function names based on this
*/
#ifndef STA_OS2_EASY_CONFIG_HPP
#define STA_OS2_EASY_CONFIG_HPP
#if !defined(STA_CONFIG_HPP) && !defined(STA_OS2_EASY_CONFIG_NO_WARNING)
#warning "Intended for use in <sta/config.hpp>"
#endif // !STA_CONFIG_HPP && !STA_OS2_EASY_CONFIG_NO_WARNING
#ifdef STA_OS2_SYSTEM_TASKS_ENABLE
// Enable system events used by system tasks
# define STA_OS2_SYSTEM_EVENT_ENABLE
// Enable system tasks
# define STA_OS2_WATCHDOG_ENABLE
# define STA_OS2_STARTUP_ENABLE
#endif // STA_OS2_SYSTEM_TASKS_ENABLE
#define _STA_OS2_CONCAT(a, b) a ## b
#define STA_OS2_MAKE_HANDLE_NAME(name) _STA_OS2_CONCAT(name, Handle)
#define STA_OS2_MAKE_CALLBACK_NAME(name) _STA_OS2_CONCAT(name, Callback)
#define STA_OS2_MAKE_TASK_NAME(name) _STA_OS2_CONCAT(name, Task)
// Use common base name for watchdog timer handle and callback
#ifdef STA_OS2_WATCHDOG_TIMER_NAME
# define STA_OS2_WATCHDOG_TIMER_HANDLE STA_OS2_MAKE_HANDLE_NAME(STA_OS2_WATCHDOG_TIMER_NAME)
# define STA_OS2_WATCHDOG_TIMER_CALLBACK STA_OS2_MAKE_CALLBACK_NAME(STA_OS2_WATCHDOG_TIMER_NAME)
#endif // STA_OS2_WATCHDOG_TIMER_NAME
// Use common base name for watchdog task handle and entry function
#ifdef STA_OS2_WATCHDOG_NAME
# define STA_OS2_WATCHDOG_HANDLE STA_OS2_MAKE_HANDLE_NAME(STA_OS2_WATCHDOG_NAME)
# define STA_OS2_WATCHDOG_ENTRY_FUNCTION STA_OS2_MAKE_TASK_NAME(STA_OS2_WATCHDOG_NAME)
#endif // STA_OS2_WATCHDOG_NAME
#endif // STA_OS2_EASY_CONFIG_HPP

28
include/sta/os2/startup.hpp
View File

@ -1,28 +0,0 @@
/**
* @brief Implementation of startup system task.
*
* Configuration:
* STA_OS2_STARTUP_ENABLE: Enable module
* STA_OS2_STARTUP_ENTRY_FUNCTION: Override name of startup task entry function (default: startupTask)
*/
#ifndef STA_OS2_STARTUP_HPP
#define STA_OS2_STARTUP_HPP
#include <sta/config.hpp>
#ifdef STA_OS2_STARTUP_ENABLE
namespace sta
{
/**
* @brief Extra initialization run at start of startup task.
*
* May be overridden by application if required.
*/
void startupExtras(void * argument);
} // namespace sta
#endif // STA_OS2_STARTUP_ENABLE
#endif // STA_OS2_STARTUP_HPP

42
include/sta/os2/watchdog.hpp
View File

@ -1,42 +0,0 @@
/**
* @brief Implementation of watchdog system task.
*
* Configuration:
* STA_OS2_WATCHDOG_ENABLE: Enable module
* STA_OS2_WATCHDOG_TIMER_PERIOD: Set period in ticks of heartbeat timer (default: 1000)
* STA_OS2_WATCHDOG_TIMER_HANDLE: Override variable name of heartbeat timer handle (default: heartbeatHandle)
* STA_OS2_WATCHDOG_TIMER_CALLBACK: Override name of heartbeat timer callback function (default: heartbeatCallback)
* STA_OS2_WATCHDOG_HANDLE: Override variable name of watchdog task handle (default: watchdogHandle)
* STA_OS2_WATCHDOG_ENTRY_FUNCTION: Override name of watchdog task entry function (default: watchdogTask)
*/
#ifndef STA_OS2_WATCHDOG_HPP
#define STA_OS2_WATCHDOG_HPP
#include <sta/config.hpp>
#ifdef STA_OS2_WATCHDOG_ENABLE
#include <cstdint>
// Watchdog task flags
//
#define STA_WATCHDOG_FLAG_HEARTBEAT 0x00001000U
namespace sta
{
/**
* @brief Start heartbeat timer for watchdog.
*/
void startWatchdogTimer();
/**
* @brief Send notification to watchdog task.
*/
void notifyWatchdog(uint32_t flags);
} // namespace sta
#endif // STA_OS2_WATCHDOG_ENABLE
#endif // STA_OS2_WATCHDOG_HPP

16
include/sta/rtos2/defs.hpp Normal file
View File

@ -0,0 +1,16 @@
/**
* @brief Constants and macros for use with CMSIS RTOS2.
*/
#ifndef STA_RTOS2_DEFS_HPP
#define STA_RTOS2_DEFS_HPP
// See limits defined in cmsis_os2.c
#define STA_RTOS2_MAX_BITS_TASK_NOTIFY 31U
#define STA_RTOS2_MAX_BITS_EVENT_GROUPS 24U
#define STA_RTOS2_THREAD_FLAGS_VALID_BITS ((1UL << STA_RTOS2_MAX_BITS_TASK_NOTIFY) - 1U)
#define STA_RTOS2_EVENT_FLAGS_VALID_BITS ((1UL << STA_RTOS2_MAX_BITS_EVENT_GROUPS) - 1U)
#endif // STA_RTOS2_DEFS_HPP

45
include/sta/rtos2/easy_config.hpp Normal file
View File

@ -0,0 +1,45 @@
/**
* @brief Helper for easy system task setup in `<sta/config.hpp>`.
*
* Configuration:
* STA_OS2_SYSTEM_TASKS_ENABLE: Enable all system tasks and required features
* STA_OS2_WATCHDOG_TIMER_NAME: Set watchdog timer handle and callback names based on this
* STA_OS2_WATCHDOG_NAME: Set watchdog task handle and entry function names based on this
*/
#ifndef STA_RTOS2_EASY_CONFIG_HPP
#define STA_RTOS2_EASY_CONFIG_HPP
#if !defined(STA_CONFIG_HPP) && !defined(STA_RTOS2_EASY_CONFIG_NO_WARNING)
#warning "Intended for use in <sta/config.hpp>"
#endif // !STA_CONFIG_HPP && !STA_RTOS2_EASY_CONFIG_NO_WARNING
#ifdef STA_RTOS2_SYSTEM_TASKS_ENABLE
// Enable system events used by system tasks
# define STA_RTOS2_SYSTEM_EVENT_ENABLE
// Enable system tasks
# define STA_RTOS2_WATCHDOG_ENABLE
# define STA_RTOS2_STARTUP_ENABLE
#endif // STA_RTOS2_SYSTEM_TASKS_ENABLE
#define _STA_RTOS2_CONCAT(a, b) a ## b
#define STA_RTOS2_MAKE_HANDLE_NAME(name) _STA_RTOS2_CONCAT(name, Handle)
#define STA_RTOS2_MAKE_CALLBACK_NAME(name) _STA_RTOS2_CONCAT(name, Callback)
#define STA_RTOS2_MAKE_TASK_NAME(name) _STA_RTOS2_CONCAT(name, Task)
// Use common base name for watchdog timer handle and callback
#ifdef STA_RTOS2_WATCHDOG_TIMER_NAME
# define STA_RTOS2_WATCHDOG_TIMER_HANDLE STA_RTOS2_MAKE_HANDLE_NAME(STA_RTOS2_WATCHDOG_TIMER_NAME)
# define STA_RTOS2_WATCHDOG_TIMER_CALLBACK STA_RTOS2_MAKE_CALLBACK_NAME(STA_RTOS2_WATCHDOG_TIMER_NAME)
#endif // STA_RTOS2_WATCHDOG_TIMER_NAME
// Use common base name for watchdog task handle and entry function
#ifdef STA_RTOS2_WATCHDOG_NAME
# define STA_RTOS2_WATCHDOG_HANDLE STA_RTOS2_MAKE_HANDLE_NAME(STA_RTOS2_WATCHDOG_NAME)
# define STA_RTOS2_WATCHDOG_ENTRY_FUNCTION STA_RTOS2_MAKE_TASK_NAME(STA_RTOS2_WATCHDOG_NAME)
#endif // STA_RTOS2_WATCHDOG_NAME
#endif // STA_RTOS2_EASY_CONFIG_HPP

8
include/sta/os2/mutex.hpp → include/sta/rtos2/mutex.hpp
View File

@ -1,8 +1,8 @@
/**
* @brief CMSIS RTOS2 mutex implementation.
*/
#ifndef STA_OS2_MUTEX_HPP
#define STA_OS2_MUTEX_HPP
#ifndef STA_RTOS2_MUTEX_HPP
#define STA_RTOS2_MUTEX_HPP
#include <sta/intf/mutex.hpp>
@ -14,13 +14,13 @@ namespace sta
/**
* @brief Implementation of `Mutex` interface using CMSIS RTOS2.
*/
class Os2Mutex : public Mutex
class Rtos2Mutex : public Mutex
{
public:
/**
* @param handle CMSIS RTOS2 mutex
*/
Os2Mutex(osMutexId_t * handle);
Rtos2Mutex(osMutexId_t * handle);
void acquire() override;
void release() override;

18
include/sta/os2/queue.hpp → include/sta/rtos2/queue.hpp
View File

@ -1,8 +1,8 @@
/**
* @brief CMSIS RTOS2 queue implementation.
*/
#ifndef STA_OS2_QUEUE_HPP
#define STA_OS2_QUEUE_HPP
#ifndef STA_RTOS2_QUEUE_HPP
#define STA_RTOS2_QUEUE_HPP
#include <sta/assert.hpp>
@ -12,12 +12,12 @@
namespace sta
{
template <typename T>
class Os2Queue
class Rtos2Queue
{
public:
using Message = T;
public:
Os2Queue(osMessageQueueId_t * handle);
Rtos2Queue(osMessageQueueId_t * handle);
bool put(const Message & msg, uint32_t timeout = osWaitForever);
bool get(Message * outMsg, uint32_t timeout = osWaitForever);
@ -33,31 +33,31 @@ namespace sta
namespace sta
{
template <typename T>
Os2Queue<T>::Os2Queue(osMessageQueueId_t * handle)
Rtos2Queue<T>::Rtos2Queue(osMessageQueueId_t * handle)
: handle_{handle}
{
STA_ASSERT(handle != nullptr);
}
template <typename T>
bool Os2Queue<T>::put(const Message & msg, uint32_t timeout /* = osWaitForever */)
bool Rtos2Queue<T>::put(const Message & msg, uint32_t timeout /* = osWaitForever */)
{
return (osOK == osMessageQueuePut(*handle_, &msg, 0, timeout));
}
template <typename T>
bool Os2Queue<T>::get(Message * outMsg, uint32_t timeout /* = osWaitForever */)
bool Rtos2Queue<T>::get(Message * outMsg, uint32_t timeout /* = osWaitForever */)
{
uint8_t prio;
return (osOK == osMessageQueueGet(*handle_, outMsg, &prio, timeout));
}
template <typename T>
uint32 Os2Queue<T>::available() const
uint32 Rtos2Queue<T>::available() const
{
return osMessageQueueGetCount(*handle_);
}
} // namespace sta
#endif // STA_OS2_QUEUE_HPP
#endif // STA_RTOS2_QUEUE_HPP

10
include/sta/os2/signal.hpp → include/sta/rtos2/signal.hpp
View File

@ -1,8 +1,8 @@
/**
* @brief CMSIS RTOS2 signal implementation.
*/
#ifndef STA_OS2_SIGNAL_HPP
#define STA_OS2_SIGNAL_HPP
#ifndef STA_RTOS2_SIGNAL_HPP
#define STA_RTOS2_SIGNAL_HPP
#include <sta/intf/signal.hpp>
@ -14,13 +14,13 @@ namespace sta
/**
* @brief Implementation of `Signal` interface using CMSIS RTOS2.
*/
class Os2Signal : public Signal
class Rtos2Signal : public Signal
{
public:
/**
* @param semaphore CMSIS RTOS2 semaphore
*/
Os2Signal(osSemaphoreId_t * semaphore);
Rtos2Signal(osSemaphoreId_t * semaphore);
void notify() override;
bool peek() override;
@ -33,4 +33,4 @@ namespace sta
} // namespace sta
#endif // STA_OS2_SIGNAL_HPP
#endif // STA_RTOS2_SIGNAL_HPP

28
include/sta/rtos2/startup.hpp Normal file
View File

@ -0,0 +1,28 @@
/**
* @brief Implementation of startup system task.
*
* Configuration:
* STA_RTOS2_STARTUP_ENABLE: Enable module
* STA_RTOS2_STARTUP_ENTRY_FUNCTION: Override name of startup task entry function (default: startupTask)
*/
#ifndef STA_RTOS2_STARTUP_HPP
#define STA_RTOS2_STARTUP_HPP
#include <sta/config.hpp>
#ifdef STA_RTOS2_STARTUP_ENABLE
namespace sta
{
/**
* @brief Extra initialization run at start of startup task.
*
* May be overridden by application if required.
*/
void startupExtras(void * argument);
} // namespace sta
#endif // STA_RTOS2_STARTUP_ENABLE
#endif // STA_RTOS2_STARTUP_HPP

10
include/sta/os2/system_event.hpp → include/sta/rtos2/system_event.hpp
View File

@ -2,14 +2,14 @@
* @brief Implementation of system events.
*
* Configuration:
* STA_OS2_SYSTEM_EVENT_ENABLE: Enable module
* STA_OS2_SYSTEM_EVENT_HANDLE: Override variable name of flag handle (default: systemEventHandle)
* STA_RTOS2_SYSTEM_EVENT_ENABLE: Enable module
* STA_RTOS2_SYSTEM_EVENT_HANDLE: Override variable name of flag handle (default: systemEventHandle)
*/
#ifndef STA_OS2_SYSTEM_EVENT_HPP
#define STA_OS2_SYSTEM_EVENT_HPP
#include <sta/config.hpp>
#ifdef STA_OS2_SYSTEM_EVENT_ENABLE
#ifdef STA_RTOS2_SYSTEM_EVENT_ENABLE
#include <cstdint>
@ -53,6 +53,6 @@ namespace sta
} // namespace sta
#endif // STA_OS2_SYSTEM_EVENT_ENABLE
#endif // STA_RTOS2_SYSTEM_EVENT_ENABLE
#endif // STA_OS2_SYSTEM_EVENT_HPP
#endif // STA_RTOS2_SYSTEM_EVENT_HPP

42
include/sta/rtos2/watchdog.hpp Normal file
View File

@ -0,0 +1,42 @@
/**
* @brief Implementation of watchdog system task.
*
* Configuration:
* STA_RTOS2_WATCHDOG_ENABLE: Enable module
* STA_RTOS2_WATCHDOG_TIMER_PERIOD: Set period in ticks of heartbeat timer (default: 1000)
* STA_RTOS2_WATCHDOG_TIMER_HANDLE: Override variable name of heartbeat timer handle (default: heartbeatHandle)
* STA_RTOS2_WATCHDOG_TIMER_CALLBACK: Override name of heartbeat timer callback function (default: heartbeatCallback)
* STA_RTOS2_WATCHDOG_HANDLE: Override variable name of watchdog task handle (default: watchdogHandle)
* STA_RTOS2_WATCHDOG_ENTRY_FUNCTION: Override name of watchdog task entry function (default: watchdogTask)
*/
#ifndef STA_RTOS2_WATCHDOG_HPP
#define STA_RTOS2_WATCHDOG_HPP
#include <sta/config.hpp>
#ifdef STA_RTOS2_WATCHDOG_ENABLE
#include <cstdint>
// Watchdog task flags
//
#define STA_WATCHDOG_FLAG_HEARTBEAT 0x00001000U
namespace sta
{
/**
* @brief Start heartbeat timer for watchdog.
*/
void startWatchdogTimer();
/**
* @brief Send notification to watchdog task.
*/
void notifyWatchdog(uint32_t flags);
} // namespace sta
#endif // STA_RTOS2_WATCHDOG_ENABLE
#endif // STA_RTOS2_WATCHDOG_HPP

19
src/os2/mutex.cpp
View File

@ -1,19 +0,0 @@
#include <sta/os2/mutex.hpp>
namespace sta
{
Os2Mutex::Os2Mutex(osMutexId_t * handle)
: handle_{handle}
{}
void Os2Mutex::acquire()
{
osMutexAcquire(*handle_, osWaitForever);
}
void Os2Mutex::release()
{
osMutexRelease(*handle_);
}
}

41
src/os2/system_event.cpp
View File

@ -1,41 +0,0 @@
#include <sta/os2/system_event.hpp>
#ifdef STA_OS2_SYSTEM_EVENT_ENABLE
#include <cmsis_os2.h>
#ifndef STA_OS2_SYSTEM_EVENT_HANDLE
# define STA_OS2_SYSTEM_EVENT_HANDLE systemEventHandle
#endif // !STA_OS2_SYSTEM_EVENT_HANDLE
// Access handle from freertos.c
extern osEventFlagsId_t STA_OS2_SYSTEM_EVENT_HANDLE;
namespace sta
{
void signalSystemEvents(uint32_t flags)
{
osEventFlagsSet(STA_OS2_SYSTEM_EVENT_HANDLE, flags);
}
void waitForSystemEvents(uint32_t flags, uint32_t options, uint32_t timeout)
{
osEventFlagsWait(STA_OS2_SYSTEM_EVENT_HANDLE, flags, options | osFlagsNoClear, timeout);
}
void signalStartupEvent()
{
signalSystemEvents(STA_SYSTEM_EVENT_STARTUP);
}
void waitForStartupEvent()
{
waitForSystemEvents(STA_SYSTEM_EVENT_STARTUP, osFlagsWaitAll, osWaitForever);
}
} // namespace sta
#endif // STA_SYSTEM_EVENT_ENABLE

46
src/os2/watchdog/heartbeat.cpp
View File

@ -1,46 +0,0 @@
#include <sta/os2/watchdog.hpp>
#ifdef STA_OS2_WATCHDOG_ENABLE
#include <cmsis_os2.h>
#ifndef STA_OS2_WATCHDOG_TIMER_PERIOD
# define STA_OS2_WATCHDOG_TIMER_PERIOD 1000
#endif // !STA_OS2_WATCHDOG_TIMER_PERIOD
#ifndef STA_OS2_WATCHDOG_TIMER_HANDLE
# define STA_OS2_WATCHDOG_TIMER_HANDLE heartbeatHandle
#endif // !STA_OS2_WATCHDOG_TIMER_HANDLE
#ifndef STA_OS2_WATCHDOG_TIMER_CALLBACK
# define STA_OS2_WATCHDOG_TIMER_CALLBACK heartbeatCallback
#endif // !STA_OS2_WATCHDOG_TIMER_CALLBACK
// Access handles from freertos.c
extern osTimerId_t STA_OS2_WATCHDOG_TIMER_HANDLE;
namespace sta
{
void startWatchdogTimer()
{
osTimerStart(STA_OS2_WATCHDOG_TIMER_HANDLE, STA_OS2_WATCHDOG_TIMER_PERIOD);
}
} // namespace sta
// Declare with C linkage
extern "C"
{
void STA_OS2_WATCHDOG_TIMER_CALLBACK(void *)
{
// Notify watchdog task to send heartbeat message
// Required because blocking in a timer callback is not allowed
sta::notifyWatchdog(STA_WATCHDOG_FLAG_HEARTBEAT);
}
}
#endif // STA_OS2_WATCHDOG_ENABLE

58
src/os2/watchdog/watchdog.cpp
View File

@ -1,58 +0,0 @@
#include <sta/os2/watchdog.hpp>
#ifdef STA_OS2_WATCHDOG_ENABLE
#include <sta/os2/defs.hpp>
#include <sta/os2/system_event.hpp>
#include <main.h>
#include <cmsis_os2.h>
#ifndef STA_OS2_WATCHDOG_HANDLE
# define STA_OS2_WATCHDOG_HANDLE watchdogHandle
#endif // !STA_OS2_WATCHDOG_HANDLE
#ifndef STA_OS2_WATCHDOG_ENTRY_FUNCTION
# define STA_OS2_WATCHDOG_ENTRY_FUNCTION watchdogTask
#endif // !STA_OS2_WATCHDOG_ENTRY_FUNCTION
// Access handle from freertos.c
extern osThreadId_t STA_OS2_WATCHDOG_HANDLE;
namespace sta
{
void notifyWatchdog(uint32_t flags)
{
osThreadFlagsSet(STA_OS2_WATCHDOG_HANDLE, flags);
}
// Handler for watchdog events
extern void watchdogEventHandler(void * arg, uint32_t flags);
} // namespace sta
// Declare with C linkage
extern "C"
{
void STA_OS2_WATCHDOG_ENTRY_FUNCTION(void * arg)
{
sta::waitForStartupEvent();
while (true)
{
// Wait for any flag to be set
uint32_t flags = osThreadFlagsWait(STA_OS2_THREAD_FLAGS_VALID_BITS, osFlagsWaitAny, osWaitForever);
// Call event handler
sta::watchdogEventHandler(arg, flags);
}
}
}
#endif // STA_OS2_WATCHDOG_ENABLE

19
src/rtos2/mutex.cpp Normal file
View File

@ -0,0 +1,19 @@
#include <sta/rtos2/mutex.hpp>
namespace sta
{
Rtos2Mutex::Rtos2Mutex(osMutexId_t * handle)
: handle_{handle}
{}
void Rtos2Mutex::acquire()
{
osMutexAcquire(*handle_, osWaitForever);
}
void Rtos2Mutex::release()
{
osMutexRelease(*handle_);
}
} // namespace sta

12
src/os2/signal.cpp → src/rtos2/signal.cpp
View File

@ -1,28 +1,28 @@
#include <sta/os2/signal.hpp>
#include <sta/rtos2/signal.hpp>
namespace sta
{
Os2Signal::Os2Signal(osSemaphoreId_t * semaphore)
Rtos2Signal::Rtos2Signal(osSemaphoreId_t * semaphore)
: semaphore_{semaphore}
{}
void Os2Signal::notify()
void Rtos2Signal::notify()
{
osSemaphoreRelease(*semaphore_);
}
bool Os2Signal::peek()
bool Rtos2Signal::peek()
{
return (osSemaphoreGetCount(*semaphore_) != 0);
}
bool Os2Signal::test()
bool Rtos2Signal::test()
{
return (osSemaphoreAcquire(*semaphore_, 0) == osOK);
}
void Os2Signal::wait()
void Rtos2Signal::wait()
{
osSemaphoreAcquire(*semaphore_, osWaitForever);
}

22
src/os2/startup.cpp → src/rtos2/startup.cpp
View File

@ -1,20 +1,20 @@
/**
* @brief System startup task.
*/
#include <sta/os2/startup.hpp>
#ifdef STA_OS2_STARTUP_ENABLE
#include <sta/rtos2/startup.hpp>
#ifdef STA_RTOS2_STARTUP_ENABLE
#include <sta/lang.hpp>
#include <sta/hal/init.hpp>
#include <sta/os2/system_event.hpp>
#include <sta/os2/watchdog.hpp>
#include <sta/rtos2/system_event.hpp>
#include <sta/rtos2/watchdog.hpp>
#include <cmsis_os2.h>
#ifndef STA_OS2_STARTUP_ENTRY_FUNCTION
# define STA_OS2_STARTUP_ENTRY_FUNCTION startupTask
#endif // !STA_OS2_STARTUP_ENTRY_FUNCTION
#ifndef STA_RTOS2_STARTUP_ENTRY_FUNCTION
# define STA_RTOS2_STARTUP_ENTRY_FUNCTION startupTask
#endif // !STA_RTOS2_STARTUP_ENTRY_FUNCTION
namespace sta
@ -29,7 +29,7 @@ namespace sta
// Declare with C linkage
extern "C"
{
void STA_OS2_STARTUP_ENTRY_FUNCTION(void * arg)
void STA_RTOS2_STARTUP_ENTRY_FUNCTION(void * arg)
{
// Call further initialization code
sta::startupExtras(arg);
@ -37,10 +37,10 @@ extern "C"
// Initialize HAL
sta::initHAL();
#ifdef STA_OS2_WATCHDOG_ENABLE
#ifdef STA_RTOS2_WATCHDOG_ENABLE
// Start timers
sta::startWatchdogTimer();
#endif // STA_OS2_WATCHDOG_ENABLE
#endif // STA_RTOS2_WATCHDOG_ENABLE
// Wake tasks
sta::signalStartupEvent();
@ -51,4 +51,4 @@ extern "C"
}
#endif // STA_OS2_STARTUP_ENABLE
#endif // STA_RTOS2_STARTUP_ENABLE

41
src/rtos2/system_event.cpp Normal file
View File

@ -0,0 +1,41 @@
#include <sta/rtos2/system_event.hpp>
#ifdef STA_RTOS2_SYSTEM_EVENT_ENABLE
#include <cmsis_os2.h>
#ifndef STA_RTOS2_SYSTEM_EVENT_HANDLE
# define STA_RTOS2_SYSTEM_EVENT_HANDLE systemEventHandle
#endif // !STA_RTOS2_SYSTEM_EVENT_HANDLE
// Access handle from freertos.c
extern osEventFlagsId_t STA_RTOS2_SYSTEM_EVENT_HANDLE;
namespace sta
{
void signalSystemEvents(uint32_t flags)
{
osEventFlagsSet(STA_RTOS2_SYSTEM_EVENT_HANDLE, flags);
}
void waitForSystemEvents(uint32_t flags, uint32_t options, uint32_t timeout)
{
osEventFlagsWait(STA_RTOS2_SYSTEM_EVENT_HANDLE, flags, options | osFlagsNoClear, timeout);
}
void signalStartupEvent()
{
signalSystemEvents(STA_SYSTEM_EVENT_STARTUP);
}
void waitForStartupEvent()
{
waitForSystemEvents(STA_SYSTEM_EVENT_STARTUP, osFlagsWaitAll, osWaitForever);
}
} // namespace sta
#endif // STA_RTOS2_SYSTEM_EVENT_ENABLE

46
src/rtos2/watchdog/heartbeat.cpp Normal file
View File

@ -0,0 +1,46 @@
#include <sta/rtos2/watchdog.hpp>
#ifdef STA_RTOS2_WATCHDOG_ENABLE
#include <cmsis_os2.h>
#ifndef STA_RTOS2_WATCHDOG_TIMER_PERIOD
# define STA_RTOS2_WATCHDOG_TIMER_PERIOD 1000
#endif // !STA_RTOS2_WATCHDOG_TIMER_PERIOD
#ifndef STA_RTOS2_WATCHDOG_TIMER_HANDLE
# define STA_RTOS2_WATCHDOG_TIMER_HANDLE heartbeatHandle
#endif // !STA_RTOS2_WATCHDOG_TIMER_HANDLE
#ifndef STA_RTOS2_WATCHDOG_TIMER_CALLBACK
# define STA_RTOS2_WATCHDOG_TIMER_CALLBACK heartbeatCallback
#endif // !STA_RTOS2_WATCHDOG_TIMER_CALLBACK
// Access handles from freertos.c
extern osTimerId_t STA_RTOS2_WATCHDOG_TIMER_HANDLE;
namespace sta
{
void startWatchdogTimer()
{
osTimerStart(STA_RTOS2_WATCHDOG_TIMER_HANDLE, STA_RTOS2_WATCHDOG_TIMER_PERIOD);
}
} // namespace sta
// Declare with C linkage
extern "C"
{
void STA_RTOS2_WATCHDOG_TIMER_CALLBACK(void *)
{
// Notify watchdog task to send heartbeat message
// Required because blocking in a timer callback is not allowed
sta::notifyWatchdog(STA_WATCHDOG_FLAG_HEARTBEAT);
}
}
#endif // STA_RTOS2_WATCHDOG_ENABLE

58
src/rtos2/watchdog/watchdog.cpp Normal file
View File

@ -0,0 +1,58 @@
#include <sta/rtos2/watchdog.hpp>
#ifdef STA_RTOS2_WATCHDOG_ENABLE
#include <sta/rtos2/defs.hpp>
#include <sta/rtos2/system_event.hpp>
#include <main.h>
#include <cmsis_os2.h>
#ifndef STA_RTOS2_WATCHDOG_HANDLE
# define STA_RTOS2_WATCHDOG_HANDLE watchdogHandle
#endif // !STA_RTOS2_WATCHDOG_HANDLE
#ifndef STA_RTOS2_WATCHDOG_ENTRY_FUNCTION
# define STA_RTOS2_WATCHDOG_ENTRY_FUNCTION watchdogTask
#endif // !STA_RTOS2_WATCHDOG_ENTRY_FUNCTION
// Access handle from freertos.c
extern osThreadId_t STA_RTOS2_WATCHDOG_HANDLE;
namespace sta
{
void notifyWatchdog(uint32_t flags)
{
osThreadFlagsSet(STA_RTOS2_WATCHDOG_HANDLE, flags);
}
// Handler for watchdog events
extern void watchdogEventHandler(void * arg, uint32_t flags);
} // namespace sta
// Declare with C linkage
extern "C"
{
void STA_RTOS2_WATCHDOG_ENTRY_FUNCTION(void * arg)
{
sta::waitForStartupEvent();
while (true)
{
// Wait for any flag to be set
uint32_t flags = osThreadFlagsWait(STA_RTOS2_THREAD_FLAGS_VALID_BITS, osFlagsWaitAny, osWaitForever);
// Call event handler
sta::watchdogEventHandler(arg, flags);
}
}
}
#endif // STA_RTOS2_WATCHDOG_ENABLE