FreeRTOS interface for C++ API of SuperTinyKernel RTOS. More...

Classes
struct	TaskParameters_t
	Parameters passed to xTaskCreate(). More...
struct	TaskStatus_t
struct	StaticTask_t
struct	StaticQueue_t
struct	StaticSemaphore_t
struct	StaticTimer_t
struct	StaticEventGroup_t
struct	StaticStreamBuffer_t
struct	StaticMessageBuffer_t
struct	MemoryRegion_t
struct	TaskParameters_restricted_t
struct	HeapStats_t

Macros
#define	configMAX_PRIORITIES 32U
#define	configMINIMAL_STACK_SIZE 128U
#define	configTICK_RATE_HZ 1000U
#define	configNUM_THREAD_LOCAL_STORAGE_POINTERS 4U
#define	configTASK_NOTIFICATION_ARRAY_ENTRIES 1U
#define	configUSE_QUEUE_SETS 1U
#define	configUSE_MUTEXES 1U
#define	configUSE_TIMERS 1U
#define	configUSE_EVENT_GROUPS 1U
#define	configUSE_STREAM_BUFFERS 1U
#define	configUSE_COUNTING_SEMAPHORES 1U
#define	configUSE_TASK_NOTIFICATIONS 1U
#define	configTOTAL_HEAP_SIZE 10240U
#define	FREERTOS_STK_MAX_TASKS 16U
	Maximum number of concurrent tasks managed by the kernel. Increase if your application creates more tasks simultaneously.
#define	FREERTOS_STK_DEFAULT_STACK_WORDS 256U
	Default stack depth in Words when the caller passes usStackDepth = 0.
#define	FREERTOS_STK_PEND_CALL_QUEUE_SIZE 8U
	Capacity of the static deferred-call queue used by xTimerPendFunctionCall() and xTimerPendFunctionCallFromISR().
#define	portMAX_DELAY ((TickType_t)0xFFFFFFFFUL)
#define	pdTRUE ((BaseType_t)1)
#define	pdFALSE ((BaseType_t)0)
#define	pdPASS (pdTRUE)
#define	pdFAIL (pdFALSE)
#define	errQUEUE_EMPTY ((BaseType_t)0)
#define	errQUEUE_FULL ((BaseType_t)0)
#define	configSTACK_DEPTH_TYPE StackType_t
#define	taskENTER_CRITICAL()
#define	taskEXIT_CRITICAL()
#define	taskDISABLE_INTERRUPTS()
#define	taskENABLE_INTERRUPTS()
#define	taskYIELD()
#define	portYIELD()
#define	taskSCHEDULER_NOT_STARTED ((BaseType_t)0)
#define	taskSCHEDULER_RUNNING ((BaseType_t)1)
#define	taskSCHEDULER_SUSPENDED ((BaseType_t)2)
#define	STATIC_TASK_TCB_SIZE_WORDS
#define	STATIC_QUEUE_TCB_SIZE_WORDS 24U
#define	STATIC_SEMAPHORE_TCB_SIZE_WORDS 8U
#define	STATIC_TIMER_TCB_SIZE_WORDS 16U
#define	STATIC_EVENT_GROUP_TCB_SIZE_WORDS 10U
#define	STATIC_STREAM_BUFFER_TCB_SIZE_WORDS 26U
#define	STATIC_MESSAGE_BUFFER_TCB_SIZE_WORDS 38U
#define	portNUM_CONFIGURABLE_REGIONS 3U
#define	pdMS_TO_TICKS(xTimeInMs)
#define	tskIDLE_PRIORITY ((UBaseType_t)0U)
#define	xTaskHandle TaskHandle_t

Typedefs
typedef uint32_t	TickType_t
typedef long	BaseType_t
typedef unsigned long	UBaseType_t
typedef long	portBASE_TYPE
typedef uintptr_t	StackType_t
typedef void *	TaskHandle_t
typedef void *	QueueHandle_t
typedef void *	SemaphoreHandle_t
typedef void *	TimerHandle_t
typedef void *	EventGroupHandle_t
typedef void *	StreamBufferHandle_t
typedef void *	MessageBufferHandle_t
typedef void *	QueueSetHandle_t
typedef void *	QueueSetMemberHandle_t
typedef void(*	TaskFunction_t) (void *pvParameters)
typedef void(*	TimerCallbackFunction_t) (TimerHandle_t xTimer)
typedef void(*	PendedFunction_t) (void *pvParameter1, uint32_t ulParameter2)
typedef void(*	StreamBufferCallbackFunction_t) (StreamBufferHandle_t xStreamBuffer, BaseType_t *pxHigherPriorityTaskWoken)
typedef uint32_t	EventBits_t

Enumerations
enum	eTaskState { eRunning = 0 , eReady , eBlocked , eSuspended , eDeleted , eInvalid }
	Task execution state, returned by eTaskGetState(). More...
enum	eNotifyAction { eNoAction = 0 , eSetBits , eIncrement , eSetValueWithOverwrite , eSetValueWithoutOverwrite }
	Action applied to a task's notification value by xTaskNotify(). More...

Functions
void	vPortEnterCritical (void)
void	vPortExitCritical (void)
void	taskYIELD_impl (void)
void	vTaskStartScheduler (void)
void	vTaskEndScheduler (void)
	End scheduling (KERNEL_DYNAMIC only). Included for API completeness.
void	vTaskSuspendAll (void)
	Suspend the scheduler (disables preemption; interrupts remain enabled).
BaseType_t	xTaskResumeAll (void)
TickType_t	xTaskGetTickCount (void)
	Return the tick count since the scheduler started.
TickType_t	xTaskGetTickCountFromISR (void)
	Return the tick count from ISR context (ISR-safe).
UBaseType_t	uxTaskGetNumberOfTasks (void)
	Return the number of tasks currently under kernel management.
BaseType_t	xTaskGetSchedulerState (void)
BaseType_t	xTaskCreate (TaskFunction_t pvTaskCode, const char pcName, uint32_t usStackDepth, void pvParameters, UBaseType_t uxPriority, TaskHandle_t *pxCreatedTask)
void	vTaskDelete (TaskHandle_t xTaskToDelete)
	Delete a task. Pass NULL to delete the calling task.
TaskHandle_t	xTaskCreateStatic (TaskFunction_t pvTaskCode, const char pcName, uint32_t ulStackDepth, void pvParameters, UBaseType_t uxPriority, StackType_t puxStackBuffer, StaticTask_t pxTaskBuffer)
BaseType_t	xTaskCreateRestrictedStatic (const TaskParameters_restricted_t pxTaskDefinition, TaskHandle_t pxCreatedTask)
BaseType_t	xTaskCreateRestricted (const TaskParameters_restricted_t pxTaskDefinition, TaskHandle_t pxCreatedTask)
void	vTaskList (char *pcWriteBuffer)
void	vTaskGetRunTimeStats (char *pcWriteBuffer)
void	vTaskSuspend (TaskHandle_t xTaskToSuspend)
	Suspend a task indefinitely. Pass NULL to suspend the calling task.
void	vTaskResume (TaskHandle_t xTaskToResume)
	Resume a previously suspended task.
BaseType_t	xTaskResumeFromISR (TaskHandle_t xTaskToResume)
BaseType_t	xTaskAbortDelay (TaskHandle_t xTask)
void	vTaskDelay (TickType_t xTicksToDelay)
	Block the calling task for a number of ticks.
void	vTaskDelayUntil (TickType_t *pxPreviousWakeTime, TickType_t xTimeIncrement)
BaseType_t	xTaskDelayUntil (TickType_t *pxPreviousWakeTime, TickType_t xTimeIncrement)
void	vTaskPrioritySet (TaskHandle_t xTask, UBaseType_t uxNewPriority)
	Change the priority of a task. Pass NULL xTask for the calling task.
UBaseType_t	uxTaskPriorityGet (TaskHandle_t xTask)
	Query the priority of a task. Pass NULL xTask for the calling task.
UBaseType_t	uxTaskPriorityGetFromISR (TaskHandle_t xTask)
	Query the priority of a task from ISR context (ISR-safe).
eTaskState	eTaskGetState (TaskHandle_t xTask)
	Return the current execution state of a task.
TaskHandle_t	xTaskGetCurrentTaskHandle (void)
	Return the handle of the currently executing task.
TaskHandle_t	xTaskGetHandle (const char *pcNameToQuery)
const char *	pcTaskGetName (TaskHandle_t xTaskToQuery)
	Return the name string of a task.
UBaseType_t	uxTaskGetStackHighWaterMark (TaskHandle_t xTask)
StackType_t	uxTaskGetStackHighWaterMark2 (TaskHandle_t xTask)
UBaseType_t	uxTaskGetSystemState (TaskStatus_t pxTaskStatusArray, UBaseType_t uxArraySize, uint32_t pulTotalRunTime)
QueueHandle_t	xQueueCreate (UBaseType_t uxQueueLength, UBaseType_t uxItemSize)
QueueHandle_t	xQueueCreateStatic (UBaseType_t uxQueueLength, UBaseType_t uxItemSize, uint8_t pucQueueStorage, StaticQueue_t pxStaticQueue)
void	vQueueDelete (QueueHandle_t xQueue)
	Delete a queue and free all associated memory.
BaseType_t	xQueueSend (QueueHandle_t xQueue, const void *pvItemToQueue, TickType_t xTicksToWait)
BaseType_t	xQueueSendToBack (QueueHandle_t xQueue, const void *pvItemToQueue, TickType_t xTicksToWait)
	Post an item to the back of a queue (alias of xQueueSend).
BaseType_t	xQueueSendToFront (QueueHandle_t xQueue, const void *pvItemToQueue, TickType_t xTicksToWait)
BaseType_t	xQueueReceive (QueueHandle_t xQueue, void *pvBuffer, TickType_t xTicksToWait)
BaseType_t	xQueuePeek (QueueHandle_t xQueue, void *pvBuffer, TickType_t xTicksToWait)
BaseType_t	xQueuePeekFromISR (QueueHandle_t xQueue, void *pvBuffer)
UBaseType_t	uxQueueMessagesWaiting (QueueHandle_t xQueue)
	Return the number of items currently in the queue.
UBaseType_t	uxQueueMessagesWaitingFromISR (QueueHandle_t xQueue)
UBaseType_t	uxQueueSpacesAvailable (QueueHandle_t xQueue)
	Return the number of free slots in the queue.
BaseType_t	xQueueReset (QueueHandle_t xQueue)
BaseType_t	xQueueOverwrite (QueueHandle_t xQueue, const void *pvItemToQueue)
BaseType_t	xQueueOverwriteFromISR (QueueHandle_t xQueue, const void pvItemToQueue, BaseType_t pxHigherPriorityTaskWoken)
BaseType_t	xQueueSendFromISR (QueueHandle_t xQueue, const void pvItemToQueue, BaseType_t pxHigherPriorityTaskWoken)
BaseType_t	xQueueReceiveFromISR (QueueHandle_t xQueue, void pvBuffer, BaseType_t pxHigherPriorityTaskWoken)
BaseType_t	xQueueSendToBackFromISR (QueueHandle_t xQueue, const void pvItemToQueue, BaseType_t pxHigherPriorityTaskWoken)
BaseType_t	xQueueSendToFrontFromISR (QueueHandle_t xQueue, const void pvItemToQueue, BaseType_t pxHigherPriorityTaskWoken)
BaseType_t	xQueueIsQueueEmptyFromISR (const QueueHandle_t xQueue)
BaseType_t	xQueueIsQueueFullFromISR (const QueueHandle_t xQueue)
TaskHandle_t	xQueueGetMutexHolder (QueueHandle_t xQueue)
TaskHandle_t	xQueueGetMutexHolderFromISR (QueueHandle_t xQueue)
QueueSetHandle_t	xQueueCreateSet (UBaseType_t uxEventQueueLength)
BaseType_t	xQueueAddToSet (QueueSetMemberHandle_t xQueueOrSemaphore, QueueSetHandle_t xQueueSet)
BaseType_t	xQueueRemoveFromSet (QueueSetMemberHandle_t xQueueOrSemaphore, QueueSetHandle_t xQueueSet)
QueueSetMemberHandle_t	xQueueSelectFromSet (QueueSetHandle_t xQueueSet, TickType_t xTicksToWait)
QueueSetMemberHandle_t	xQueueSelectFromSetFromISR (QueueSetHandle_t xQueueSet)
SemaphoreHandle_t	xSemaphoreCreateBinary (void)
SemaphoreHandle_t	xSemaphoreCreateBinaryStatic (StaticSemaphore_t *pxSemaphoreBuffer)
SemaphoreHandle_t	xSemaphoreCreateCounting (UBaseType_t uxMaxCount, UBaseType_t uxInitialCount)
SemaphoreHandle_t	xSemaphoreCreateCountingStatic (UBaseType_t uxMaxCount, UBaseType_t uxInitialCount, StaticSemaphore_t *pxSemaphoreBuffer)
SemaphoreHandle_t	xSemaphoreCreateMutex (void)
SemaphoreHandle_t	xSemaphoreCreateMutexStatic (StaticSemaphore_t *pxMutexBuffer)
SemaphoreHandle_t	xSemaphoreCreateRecursiveMutex (void)
	Create a recursive mutex (same implementation as xSemaphoreCreateMutex).
SemaphoreHandle_t	xSemaphoreCreateRecursiveMutexStatic (StaticSemaphore_t *pxMutexBuffer)
void	vSemaphoreDelete (SemaphoreHandle_t xSemaphore)
	Delete a semaphore or mutex and free its memory.
BaseType_t	xSemaphoreTake (SemaphoreHandle_t xSemaphore, TickType_t xTicksToWait)
BaseType_t	xSemaphoreTakeFromISR (SemaphoreHandle_t xSemaphore, BaseType_t *pxHigherPriorityTaskWoken)
BaseType_t	xSemaphoreTakeRecursive (SemaphoreHandle_t xMutex, TickType_t xTicksToWait)
	Take a recursive mutex (blocking).
BaseType_t	xSemaphoreGive (SemaphoreHandle_t xSemaphore)
BaseType_t	xSemaphoreGiveRecursive (SemaphoreHandle_t xMutex)
	Give a recursive mutex.
BaseType_t	xSemaphoreGiveFromISR (SemaphoreHandle_t xSemaphore, BaseType_t *pxHigherPriorityTaskWoken)
UBaseType_t	uxSemaphoreGetCount (SemaphoreHandle_t xSemaphore)
TaskHandle_t	xSemaphoreGetMutexHolder (SemaphoreHandle_t xMutex)
TaskHandle_t	xSemaphoreGetMutexHolderFromISR (SemaphoreHandle_t xMutex)
TimerHandle_t	xTimerCreate (const char pcTimerName, TickType_t xTimerPeriodInTicks, UBaseType_t uxAutoReload, void pvTimerID, TimerCallbackFunction_t pxCallbackFunction)
TimerHandle_t	xTimerCreateStatic (const char pcTimerName, TickType_t xTimerPeriodInTicks, UBaseType_t uxAutoReload, void pvTimerID, TimerCallbackFunction_t pxCallbackFunction, StaticTimer_t *pxTimerBuffer)
BaseType_t	xTimerDelete (TimerHandle_t xTimer, TickType_t xTicksToWait)
BaseType_t	xTimerStart (TimerHandle_t xTimer, TickType_t xTicksToWait)
BaseType_t	xTimerStop (TimerHandle_t xTimer, TickType_t xTicksToWait)
BaseType_t	xTimerReset (TimerHandle_t xTimer, TickType_t xTicksToWait)
BaseType_t	xTimerChangePeriod (TimerHandle_t xTimer, TickType_t xNewPeriod, TickType_t xTicksToWait)
BaseType_t	xTimerIsTimerActive (TimerHandle_t xTimer)
void *	pvTimerGetTimerID (TimerHandle_t xTimer)
	Return the application-defined ID stored in a timer.
void	vTimerSetTimerID (TimerHandle_t xTimer, void *pvNewID)
	Set the application-defined ID stored in a timer.
const char *	pcTimerGetName (TimerHandle_t xTimer)
	Return the name string of a timer.
TickType_t	xTimerGetPeriod (TimerHandle_t xTimer)
	Return the period of a timer in ticks.
TickType_t	xTimerGetExpiryTime (TimerHandle_t xTimer)
BaseType_t	xTimerStartFromISR (TimerHandle_t xTimer, BaseType_t *pxHigherPriorityTaskWoken)
BaseType_t	xTimerStopFromISR (TimerHandle_t xTimer, BaseType_t *pxHigherPriorityTaskWoken)
BaseType_t	xTimerResetFromISR (TimerHandle_t xTimer, BaseType_t *pxHigherPriorityTaskWoken)
BaseType_t	xTimerChangePeriodFromISR (TimerHandle_t xTimer, TickType_t xNewPeriod, BaseType_t *pxHigherPriorityTaskWoken)
BaseType_t	xTimerPendFunctionCall (PendedFunction_t xFunctionToPend, void *pvParameter1, uint32_t ulParameter2, TickType_t xTicksToWait)
BaseType_t	xTimerPendFunctionCallFromISR (PendedFunction_t xFunctionToPend, void pvParameter1, uint32_t ulParameter2, BaseType_t pxHigherPriorityTaskWoken)
EventGroupHandle_t	xEventGroupCreate (void)
EventGroupHandle_t	xEventGroupCreateStatic (StaticEventGroup_t *pxEventGroupBuffer)
void	vEventGroupDelete (EventGroupHandle_t xEventGroup)
	Delete an event group and free its memory.
EventBits_t	xEventGroupSetBits (EventGroupHandle_t xEventGroup, EventBits_t uxBitsToSet)
EventBits_t	xEventGroupClearBits (EventGroupHandle_t xEventGroup, EventBits_t uxBitsToClear)
EventBits_t	xEventGroupGetBits (EventGroupHandle_t xEventGroup)
	Return the current event group bits without blocking or modifying them.
EventBits_t	xEventGroupWaitBits (EventGroupHandle_t xEventGroup, EventBits_t uxBitsToWaitFor, BaseType_t xClearOnExit, BaseType_t xWaitForAllBits, TickType_t xTicksToWait)
BaseType_t	xEventGroupSetBitsFromISR (EventGroupHandle_t xEventGroup, EventBits_t uxBitsToSet, BaseType_t *pxHigherPriorityTaskWoken)
EventBits_t	xEventGroupClearBitsFromISR (EventGroupHandle_t xEventGroup, EventBits_t uxBitsToClear)
EventBits_t	xEventGroupSync (EventGroupHandle_t xEventGroup, EventBits_t uxBitsToSet, EventBits_t uxBitsToWaitFor, TickType_t xTicksToWait)
BaseType_t	xTaskNotifyGive (TaskHandle_t xTaskToNotify)
uint32_t	ulTaskNotifyTake (BaseType_t ulClearCountOnExit, TickType_t xTicksToWait)
BaseType_t	xTaskNotify (TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction)
BaseType_t	xTaskNotifyWait (uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait)
BaseType_t	xTaskNotifyFromISR (TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, BaseType_t *pxHigherPriorityTaskWoken)
BaseType_t	xTaskNotifyGiveIndexed (TaskHandle_t xTaskToNotify, UBaseType_t uxIndexToNotify)
uint32_t	ulTaskNotifyTakeIndexed (UBaseType_t uxIndexToWait, BaseType_t ulClearCountOnExit, TickType_t xTicksToWait)
BaseType_t	xTaskNotifyIndexed (TaskHandle_t xTaskToNotify, UBaseType_t uxIndexToNotify, uint32_t ulValue, eNotifyAction eAction)
BaseType_t	xTaskNotifyWaitIndexed (UBaseType_t uxIndexToWait, uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait)
BaseType_t	xTaskNotifyFromISRIndexed (TaskHandle_t xTaskToNotify, UBaseType_t uxIndexToNotify, uint32_t ulValue, eNotifyAction eAction, BaseType_t *pxHigherPriorityTaskWoken)
BaseType_t	xTaskNotifyAndQuery (TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, uint32_t *pulPreviousNotifyValue)
BaseType_t	xTaskNotifyAndQueryIndexed (TaskHandle_t xTaskToNotify, UBaseType_t uxIndexToNotify, uint32_t ulValue, eNotifyAction eAction, uint32_t *pulPreviousNotifyValue)
BaseType_t	xTaskNotifyAndQueryFromISR (TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, uint32_t pulPreviousNotifyValue, BaseType_t pxHigherPriorityTaskWoken)
BaseType_t	xTaskNotifyAndQueryFromISRIndexed (TaskHandle_t xTaskToNotify, UBaseType_t uxIndexToNotify, uint32_t ulValue, eNotifyAction eAction, uint32_t pulPreviousNotifyValue, BaseType_t pxHigherPriorityTaskWoken)
BaseType_t	xTaskNotifyStateClear (TaskHandle_t xTask)
BaseType_t	xTaskNotifyStateClearIndexed (TaskHandle_t xTask, UBaseType_t uxIndexToClear)
uint32_t	ulTaskNotifyValueClear (TaskHandle_t xTask, uint32_t ulBitsToClear)
uint32_t	ulTaskNotifyValueClearIndexed (TaskHandle_t xTask, UBaseType_t uxIndexToClear, uint32_t ulBitsToClear)
void	vTaskSetThreadLocalStoragePointer (TaskHandle_t xTaskToSet, BaseType_t xIndex, void *pvValue)
void *	pvTaskGetThreadLocalStoragePointer (TaskHandle_t xTaskToQuery, BaseType_t xIndex)
StreamBufferHandle_t	xStreamBufferCreate (size_t xBufferSizeBytes, size_t xTriggerLevelBytes)
StreamBufferHandle_t	xStreamBufferCreateStatic (size_t xBufferSizeBytes, size_t xTriggerLevelBytes, uint8_t pucStreamBufferStorageArea, StaticStreamBuffer_t pxStaticStreamBuffer)
void	vStreamBufferDelete (StreamBufferHandle_t xStreamBuffer)
	Delete a stream buffer and free heap resources (if dynamically allocated).
size_t	xStreamBufferSend (StreamBufferHandle_t xStreamBuffer, const void *pvTxData, size_t xDataLengthBytes, TickType_t xTicksToWait)
size_t	xStreamBufferSendFromISR (StreamBufferHandle_t xStreamBuffer, const void pvTxData, size_t xDataLengthBytes, BaseType_t pxHigherPriorityTaskWoken)
size_t	xStreamBufferReceive (StreamBufferHandle_t xStreamBuffer, void *pvRxData, size_t xBufferLengthBytes, TickType_t xTicksToWait)
size_t	xStreamBufferReceiveFromISR (StreamBufferHandle_t xStreamBuffer, void pvRxData, size_t xBufferLengthBytes, BaseType_t pxHigherPriorityTaskWoken)
size_t	xStreamBufferBytesAvailable (StreamBufferHandle_t xStreamBuffer)
	Return the number of bytes currently available to read.
size_t	xStreamBufferSpacesAvailable (StreamBufferHandle_t xStreamBuffer)
	Return the number of free bytes available for writing.
BaseType_t	xStreamBufferIsEmpty (StreamBufferHandle_t xStreamBuffer)
	Return pdTRUE if the stream buffer contains no data.
BaseType_t	xStreamBufferIsFull (StreamBufferHandle_t xStreamBuffer)
	Return pdTRUE if the stream buffer is full (no write space remaining).
BaseType_t	xStreamBufferReset (StreamBufferHandle_t xStreamBuffer)
BaseType_t	xStreamBufferResetFromISR (StreamBufferHandle_t xStreamBuffer, BaseType_t *pxHigherPriorityTaskWoken)
BaseType_t	xStreamBufferSetTriggerLevel (StreamBufferHandle_t xStreamBuffer, size_t xTriggerLevelBytes)
size_t	xStreamBufferGetTriggerLevel (StreamBufferHandle_t xStreamBuffer)
size_t	xStreamBufferNextMessageLengthBytes (StreamBufferHandle_t xStreamBuffer)
StreamBufferHandle_t	xStreamBufferCreateWithCallback (size_t xBufferSizeBytes, size_t xTriggerLevelBytes, StreamBufferCallbackFunction_t pxSendCompletedCallback, StreamBufferCallbackFunction_t pxReceiveCompletedCallback)
StreamBufferHandle_t	xStreamBufferCreateStaticWithCallback (size_t xBufferSizeBytes, size_t xTriggerLevelBytes, uint8_t pucStreamBufferStorageArea, StaticStreamBuffer_t pxStaticStreamBuffer, StreamBufferCallbackFunction_t pxSendCompletedCallback, StreamBufferCallbackFunction_t pxReceiveCompletedCallback)
MessageBufferHandle_t	xMessageBufferCreate (size_t xBufferSizeBytes, size_t xMaxMessageSize)
MessageBufferHandle_t	xMessageBufferCreateStatic (size_t xMaxMessageSize, size_t xMessageCount, uint8_t pucMessageBufferStorageArea, StaticMessageBuffer_t pxStaticMessageBuffer)
MessageBufferHandle_t	xMessageBufferCreateWithCallback (size_t xBufferSizeBytes, size_t xMaxMessageSize, StreamBufferCallbackFunction_t pxSendCompletedCallback, StreamBufferCallbackFunction_t pxReceiveCompletedCallback)
MessageBufferHandle_t	xMessageBufferCreateStaticWithCallback (size_t xMaxMessageSize, size_t xMessageCount, uint8_t pucMessageBufferStorageArea, StaticMessageBuffer_t pxStaticMessageBuffer, StreamBufferCallbackFunction_t pxSendCompletedCallback, StreamBufferCallbackFunction_t pxReceiveCompletedCallback)
void	vMessageBufferDelete (MessageBufferHandle_t xMessageBuffer)
	Delete a message buffer and free heap resources (if dynamically allocated).
size_t	xMessageBufferSend (MessageBufferHandle_t xMessageBuffer, const void *pvTxData, size_t xDataLengthBytes, TickType_t xTicksToWait)
size_t	xMessageBufferSendFromISR (MessageBufferHandle_t xMessageBuffer, const void pvTxData, size_t xDataLengthBytes, BaseType_t pxHigherPriorityTaskWoken)
size_t	xMessageBufferReceive (MessageBufferHandle_t xMessageBuffer, void *pvRxData, size_t xBufferLengthBytes, TickType_t xTicksToWait)
size_t	xMessageBufferReceiveFromISR (MessageBufferHandle_t xMessageBuffer, void pvRxData, size_t xBufferLengthBytes, BaseType_t pxHigherPriorityTaskWoken)
BaseType_t	xMessageBufferIsEmpty (MessageBufferHandle_t xMessageBuffer)
BaseType_t	xMessageBufferIsFull (MessageBufferHandle_t xMessageBuffer)
size_t	xMessageBufferSpacesAvailable (MessageBufferHandle_t xMessageBuffer)
size_t	xMessageBufferNextLengthBytes (MessageBufferHandle_t xMessageBuffer)
BaseType_t	xMessageBufferReset (MessageBufferHandle_t xMessageBuffer)
BaseType_t	xMessageBufferResetFromISR (MessageBufferHandle_t xMessageBuffer, BaseType_t *pxHigherPriorityTaskWoken)
void *	pvPortMalloc (size_t xWantedSize)
void	vPortFree (void *pv)
size_t	xPortGetFreeHeapSize (void)
size_t	xPortGetMinimumEverFreeHeapSize (void)
void	vPortGetHeapStats (HeapStats_t *pxHeapStats)

Detailed Description

FreeRTOS interface for C++ API of SuperTinyKernel RTOS.

Maps standard FreeRTOS C API onto the STK C++ API, allowing existing FreeRTOS-based projects to run on STK with minimal or no application changes.

Supported API groups:

Kernel control (vTaskStartScheduler, taskENTER/EXIT_CRITICAL, xTaskGetTickCount, vTaskDelay, vTaskDelayUntil, xTaskDelayUntil, xTaskGetSchedulerState)
Task management (xTaskCreate, vTaskDelete, vTaskSuspend, vTaskResume, xTaskAbortDelay, vTaskPrioritySet, uxTaskPriorityGet, xTaskGetHandle, xTaskGetCurrentTaskHandle, pcTaskGetName, uxTaskGetStackHighWaterMark, eTaskGetState, uxTaskGetSystemState, xTaskCreateRestricted, xTaskCreateRestrictedStatic, vTaskList, vTaskGetRunTimeStats)
Queue (xQueueCreate, xQueueCreateStatic, vQueueDelete, xQueueSend, xQueueSendToBack, xQueueSendToFront, xQueueReceive, xQueuePeek, xQueuePeekFromISR, xQueueOverwrite, xQueueOverwriteFromISR, uxQueueMessagesWaiting, uxQueueMessagesWaitingFromISR, uxQueueSpacesAvailable, xQueueReset, xQueueSendFromISR, xQueueReceiveFromISR, xQueueSendToBackFromISR, xQueueSendToFrontFromISR, xQueueIsQueueEmptyFromISR, xQueueIsQueueFullFromISR, xQueueGetMutexHolder, xQueueGetMutexHolderFromISR, xQueueCreateSet, xQueueAddToSet, xQueueRemoveFromSet, xQueueSelectFromSet, xQueueSelectFromSetFromISR)
Semaphore / Mutex (xSemaphoreCreateBinary, xSemaphoreCreateBinaryStatic, xSemaphoreCreateCounting, xSemaphoreCreateCountingStatic, xSemaphoreCreateMutex, xSemaphoreCreateMutexStatic, xSemaphoreCreateRecursiveMutex, xSemaphoreCreateRecursiveMutexStatic, vSemaphoreDelete, xSemaphoreTake, xSemaphoreTakeFromISR, xSemaphoreTakeRecursive, xSemaphoreGive, xSemaphoreGiveRecursive, xSemaphoreGiveFromISR, uxSemaphoreGetCount, xSemaphoreGetMutexHolder, xSemaphoreGetMutexHolderFromISR)
Software timers (xTimerCreate, xTimerCreateStatic, xTimerDelete, xTimerStart, xTimerStop, xTimerReset, xTimerChangePeriod, xTimerIsTimerActive, pvTimerGetTimerID, pcTimerGetName, xTimerStartFromISR, xTimerStopFromISR, xTimerResetFromISR, xTimerChangePeriodFromISR, xTimerPendFunctionCall, xTimerPendFunctionCallFromISR)
Event groups (xEventGroupCreate, xEventGroupCreateStatic, vEventGroupDelete, xEventGroupSetBits, xEventGroupClearBits, xEventGroupGetBits, xEventGroupWaitBits, xEventGroupSetBitsFromISR, xEventGroupClearBitsFromISR, xEventGroupSync)
Task notifications (xTaskNotifyGive, ulTaskNotifyTake, xTaskNotify, xTaskNotifyWait, xTaskNotifyFromISR, xTaskNotifyGiveIndexed, ulTaskNotifyTakeIndexed, xTaskNotifyIndexed, xTaskNotifyWaitIndexed, xTaskNotifyFromISRIndexed, xTaskNotifyAndQuery, xTaskNotifyAndQueryIndexed, xTaskNotifyAndQueryFromISR, xTaskNotifyAndQueryFromISRIndexed, xTaskNotifyStateClear, xTaskNotifyStateClearIndexed, ulTaskNotifyValueClear, ulTaskNotifyValueClearIndexed)
Stream buffers (xStreamBufferCreate, xStreamBufferCreateStatic, xStreamBufferCreateWithCallback, xStreamBufferCreateStaticWithCallback, xStreamBufferSend, xStreamBufferReceive, xStreamBufferSendFromISR, xStreamBufferReceiveFromISR, vStreamBufferDelete, xStreamBufferBytesAvailable, xStreamBufferSpacesAvailable, xStreamBufferIsEmpty, xStreamBufferIsFull, xStreamBufferReset, xStreamBufferResetFromISR, xStreamBufferSetTriggerLevel, xStreamBufferGetTriggerLevel, xStreamBufferNextMessageLengthBytes)
Message buffers (xMessageBufferCreate, xMessageBufferCreateStatic, xMessageBufferCreateWithCallback, xMessageBufferCreateStaticWithCallback, xMessageBufferSend, xMessageBufferSendFromISR, xMessageBufferReceive, xMessageBufferReceiveFromISR, vMessageBufferDelete, xMessageBufferIsEmpty, xMessageBufferIsFull, xMessageBufferSpacesAvailable, xMessageBufferReset, xMessageBufferResetFromISR, xMessageBufferNextLengthBytes)

Design notes:

All objects are heap-allocated with operator new/delete. For static deployments replace with a static pool allocator.
One global STK Kernel instance (g_StkKernel) is configured with KERNEL_DYNAMIC | KERNEL_SYNC and SwitchStrategyFP32 (32 fixed-priority levels, same strategy used by the CMSIS wrapper). FreeRTOS priorities (0=lowest .. configMAX_PRIORITIES-1=highest) map directly to STK priority levels 0..configMAX_PRIORITIES-1. configMAX_PRIORITIES must be <= 32 (compile-time assertion in the .cpp). The highest-priority ready task always preempts lower ones, exactly matching FreeRTOS fixed-priority preemptive scheduling semantics.
portMAX_DELAY (0xFFFFFFFF) is translated to stk::WAIT_INFINITE.
Timeout values are in ticks; STK also takes ticks, so no conversion needed when tick resolution is 1 ms (the default PERIODICITY_DEFAULT).
Recursive mutexes are backed by stk::sync::Mutex (always recursive in STK).
Binary semaphores are backed by stk::sync::Semaphore with max_count=1.
Counting semaphores are backed by stk::sync::Semaphore.
Event groups are backed by stk::sync::EventFlags (32-bit, bits 0..23 usable per FreeRTOS convention; bits 24..30 are free, bit 31 is reserved by STK).
Software timers are backed by stk::time::TimerHost.
Task notifications are backed by per-task stk::sync::Semaphore.
Queue sets are backed by a per-set stk::sync::MessageQueue of void* tokens (sizeof(void*) per slot). Member queues and semaphores carry a non-owning back-pointer to their registered set; QueueSetNotify() posts the member handle into the set's token FIFO after every successful send or signal. Type discrimination between FrtosQueue and FrtosSemaphore uses the fact that SemKind (offset 0 in FrtosSemaphore, values 0 or 1) is always < the first byte of a MessageQueue vtable pointer (>= 4).

Limitations / deviations:

Priority inheritance is not supported (STK mutex is always recursive, not priority-inheriting).
configUSE_PREEMPTION is assumed to be 1; cooperative scheduling is not modelled.
Task notifications: indexed API supports slots 0 .. configTASK_NOTIFICATION_ARRAY_ENTRIES-1.
uxTaskGetNumberOfTasks() requires the kernel to be running.

Macro Definition Documentation

◆ configMAX_PRIORITIES

#define configMAX_PRIORITIES 32U

Definition at line 152 of file FreeRTOS.h.

Referenced by FrtosPrioToStkWeight(), and StkWeightToFrtosPrio().

◆ configMINIMAL_STACK_SIZE

#define configMINIMAL_STACK_SIZE 128U

Minimum stack depth in Words.

Definition at line 156 of file FreeRTOS.h.

◆ configNUM_THREAD_LOCAL_STORAGE_POINTERS

#define configNUM_THREAD_LOCAL_STORAGE_POINTERS 4U

Per-task TLS pointer slots.

Definition at line 164 of file FreeRTOS.h.

Referenced by FrtosTask::FrtosTask(), pvTaskGetThreadLocalStoragePointer(), and vTaskSetThreadLocalStoragePointer().

◆ configSTACK_DEPTH_TYPE

#define configSTACK_DEPTH_TYPE StackType_t

Stack depth word type.

Definition at line 271 of file FreeRTOS.h.

Referenced by uxTaskGetStackHighWaterMark2(), and uxTaskGetSystemState().

◆ configTASK_NOTIFICATION_ARRAY_ENTRIES

#define configTASK_NOTIFICATION_ARRAY_ENTRIES 1U

Number of per-task notification slots (indexed API).

Definition at line 168 of file FreeRTOS.h.

Referenced by ResolveNotifyTarget().

◆ configTICK_RATE_HZ

#define configTICK_RATE_HZ 1000U

Definition at line 160 of file FreeRTOS.h.

◆ configTOTAL_HEAP_SIZE

#define configTOTAL_HEAP_SIZE 10240U

Dynamic heap size in bytes.

Definition at line 200 of file FreeRTOS.h.

◆ configUSE_COUNTING_SEMAPHORES

#define configUSE_COUNTING_SEMAPHORES 1U

Include counting semaphore API.

Definition at line 192 of file FreeRTOS.h.

◆ configUSE_EVENT_GROUPS

#define configUSE_EVENT_GROUPS 1U

Include event group API.

Definition at line 184 of file FreeRTOS.h.

◆ configUSE_MUTEXES

#define configUSE_MUTEXES 1U

Include mutex and recursive-mutex API.

Definition at line 176 of file FreeRTOS.h.

Referenced by FrtosSemaphore::FrtosSemaphore().

◆ configUSE_QUEUE_SETS

#define configUSE_QUEUE_SETS 1U

Include queue sets API.

Definition at line 172 of file FreeRTOS.h.

Referenced by FrtosQueue::FrtosQueue(), FrtosQueue::FrtosQueue(), and FrtosSemaphore::FrtosSemaphore().

◆ configUSE_STREAM_BUFFERS

#define configUSE_STREAM_BUFFERS 1U

Include stream buffer and message buffer API.

Definition at line 188 of file FreeRTOS.h.

◆ configUSE_TASK_NOTIFICATIONS

#define configUSE_TASK_NOTIFICATIONS 1U

Include task notification API (xTaskNotify etc.).

Definition at line 196 of file FreeRTOS.h.

◆ configUSE_TIMERS

#define configUSE_TIMERS 1U

Include software timer API.

Definition at line 180 of file FreeRTOS.h.

◆ errQUEUE_EMPTY

#define errQUEUE_EMPTY ((BaseType_t)0)

Definition at line 267 of file FreeRTOS.h.

◆ errQUEUE_FULL

#define errQUEUE_FULL ((BaseType_t)0)

Definition at line 268 of file FreeRTOS.h.

◆ FREERTOS_STK_DEFAULT_STACK_WORDS

#define FREERTOS_STK_DEFAULT_STACK_WORDS 256U

Default stack depth in Words when the caller passes usStackDepth = 0.

Definition at line 215 of file FreeRTOS.h.

Referenced by xTaskCreate().

◆ FREERTOS_STK_MAX_TASKS

#define FREERTOS_STK_MAX_TASKS 16U

Maximum number of concurrent tasks managed by the kernel. Increase if your application creates more tasks simultaneously.

Definition at line 208 of file FreeRTOS.h.

Referenced by uxTaskGetSystemState(), vTaskEndScheduler(), vTaskGetRunTimeStats(), vTaskList(), and xTaskGetHandle().

◆ FREERTOS_STK_PEND_CALL_QUEUE_SIZE

#define FREERTOS_STK_PEND_CALL_QUEUE_SIZE 8U

Capacity of the static deferred-call queue used by xTimerPendFunctionCall() and xTimerPendFunctionCallFromISR().

Each slot holds one PendCall record: one function pointer, one void* parameter, and one uint32_t parameter — typically 12–16 bytes on 32-bit targets. The queue lives in static storage (zero heap), so this value determines RAM consumption at link time rather than runtime.

Choose the maximum number of deferred calls that can be simultaneously in-flight before the TimerHost handler task drains them. A value of 8 is sufficient for most applications; increase it if your ISR rate is high relative to the RTOS tick rate or if several ISRs may pend calls concurrently.

Note: xTimerPendFunctionCall() returns pdFAIL when the queue is full.; xTimerPendFunctionCallFromISR() also returns pdFAIL when full (non-blocking).; Must be >= 1.

Definition at line 238 of file FreeRTOS.h.

◆ pdFAIL

#define pdFAIL (pdFALSE)

Definition at line 266 of file FreeRTOS.h.

Referenced by NotifyApplyAction(), xEventGroupSetBitsFromISR(), xMessageBufferReset(), xMessageBufferResetFromISR(), xQueueAddToSet(), xQueueOverwrite(), xQueueOverwriteFromISR(), xQueuePeek(), xQueuePeekFromISR(), xQueueReceive(), xQueueReceiveFromISR(), xQueueRemoveFromSet(), xQueueReset(), xQueueSend(), xQueueSendFromISR(), xQueueSendToFront(), xQueueSendToFrontFromISR(), xSemaphoreGive(), xSemaphoreGiveFromISR(), xSemaphoreTake(), xSemaphoreTakeFromISR(), xStreamBufferReset(), xStreamBufferResetFromISR(), xTaskAbortDelay(), xTaskCreate(), xTaskCreateRestricted(), xTaskCreateRestrictedStatic(), xTaskNotifyAndQueryIndexed(), xTaskNotifyGiveIndexed(), xTaskNotifyIndexed(), xTaskNotifyWaitIndexed(), xTimerChangePeriod(), xTimerChangePeriodFromISR(), xTimerDelete(), xTimerPendFunctionCall(), xTimerPendFunctionCallFromISR(), xTimerStart(), xTimerStartFromISR(), xTimerStop(), and xTimerStopFromISR().

◆ pdFALSE

#define pdFALSE ((BaseType_t)0)

Definition at line 264 of file FreeRTOS.h.

Referenced by BuildStkFlagsOpts(), xEventGroupSetBitsFromISR(), xMessageBufferIsEmpty(), xMessageBufferIsFull(), xMessageBufferReceive(), xMessageBufferReceiveFromISR(), xMessageBufferResetFromISR(), xMessageBufferSend(), xMessageBufferSendFromISR(), xQueueIsQueueEmptyFromISR(), xQueueIsQueueFullFromISR(), xQueueOverwriteFromISR(), xQueueReceiveFromISR(), xQueueSendFromISR(), xQueueSendToFrontFromISR(), xSemaphoreGiveFromISR(), xSemaphoreTakeFromISR(), xStreamBufferIsEmpty(), xStreamBufferIsFull(), xStreamBufferReceive(), xStreamBufferReceiveFromISR(), xStreamBufferResetFromISR(), xStreamBufferSend(), xStreamBufferSendFromISR(), xStreamBufferSetTriggerLevel(), xTaskAbortDelay(), xTaskDelayUntil(), xTaskNotifyAndQueryFromISRIndexed(), xTaskNotifyFromISRIndexed(), xTaskNotifyStateClearIndexed(), xTaskResumeAll(), xTaskResumeFromISR(), xTimerChangePeriodFromISR(), xTimerIsTimerActive(), xTimerPendFunctionCallFromISR(), xTimerStartFromISR(), and xTimerStopFromISR().

◆ pdMS_TO_TICKS

#define pdMS_TO_TICKS ( xTimeInMs )

Value:

((TickType_t)(xTimeInMs))

TickType_t

uint32_t TickType_t

Definition FreeRTOS.h:256

1 ms tick resolution.

Definition at line 2028 of file FreeRTOS.h.

◆ pdPASS

#define pdPASS (pdTRUE)

Definition at line 265 of file FreeRTOS.h.

Referenced by NotifyApplyAction(), xEventGroupSetBitsFromISR(), xMessageBufferReset(), xMessageBufferResetFromISR(), xQueueAddToSet(), xQueueOverwrite(), xQueueOverwriteFromISR(), xQueuePeek(), xQueuePeekFromISR(), xQueueReceive(), xQueueReceiveFromISR(), xQueueRemoveFromSet(), xQueueReset(), xQueueSend(), xQueueSendFromISR(), xQueueSendToFront(), xQueueSendToFrontFromISR(), xSemaphoreGive(), xSemaphoreGiveFromISR(), xSemaphoreTake(), xSemaphoreTakeFromISR(), xStreamBufferReset(), xStreamBufferResetFromISR(), xTaskAbortDelay(), xTaskCreate(), xTaskCreateRestrictedStatic(), xTaskNotifyAndQueryIndexed(), xTaskNotifyGiveIndexed(), xTaskNotifyIndexed(), xTaskNotifyWaitIndexed(), xTimerChangePeriodFromISR(), xTimerDelete(), xTimerPendFunctionCall(), xTimerPendFunctionCallFromISR(), xTimerStart(), xTimerStartFromISR(), xTimerStop(), and xTimerStopFromISR().

◆ pdTRUE

#define pdTRUE ((BaseType_t)1)

Definition at line 263 of file FreeRTOS.h.

Referenced by BuildStkFlagsOpts(), ulTaskNotifyTakeIndexed(), xMessageBufferIsEmpty(), xMessageBufferIsFull(), xQueueIsQueueEmptyFromISR(), xQueueIsQueueFullFromISR(), xStreamBufferIsEmpty(), xStreamBufferIsFull(), xStreamBufferSetTriggerLevel(), xTaskDelayUntil(), xTaskNotifyStateClearIndexed(), xTaskResumeFromISR(), xTimerCreate(), xTimerCreateStatic(), and xTimerIsTimerActive().

◆ portMAX_DELAY

#define portMAX_DELAY ((TickType_t)0xFFFFFFFFUL)

Block indefinitely.

Definition at line 262 of file FreeRTOS.h.

Referenced by FrtosTimeoutToStk().

◆ portNUM_CONFIGURABLE_REGIONS

#define portNUM_CONFIGURABLE_REGIONS 3U

MPU memory region descriptor used by xTaskCreateRestrictedStatic().

Note: STK does not implement MPU support. This struct is provided for source compatibility only; region fields are accepted but ignored.

Definition at line 558 of file FreeRTOS.h.

◆ portYIELD

#define portYIELD ( )

Value:

taskYIELD_impl()

taskYIELD_impl

void taskYIELD_impl(void)

Definition freertos_stk.cpp:361

Definition at line 397 of file FreeRTOS.h.

◆ STATIC_EVENT_GROUP_TCB_SIZE_WORDS

#define STATIC_EVENT_GROUP_TCB_SIZE_WORDS 10U

Opaque buffer type that the caller must supply for xEventGroupCreateStatic(). Must be at least sizeof(FrtosEventGroup) bytes. Declared as a fixed-size array of uintptr_t to enforce natural alignment without exposing FrtosEventGroup internals.

Definition at line 506 of file FreeRTOS.h.

◆ STATIC_MESSAGE_BUFFER_TCB_SIZE_WORDS

#define STATIC_MESSAGE_BUFFER_TCB_SIZE_WORDS 38U

Opaque buffer type for xMessageBufferCreateStatic() and xMessageBufferCreateStaticWithCallback(). Covers FrtosMessageBuffer (BlockMemoryPool header + envelope MessageQueue header

ownership flags + two StreamBufferCallbackFunction_t pointers) on all supported STK targets. Size is conservative (+2 words vs the pre-callback layout).

Definition at line 528 of file FreeRTOS.h.

◆ STATIC_QUEUE_TCB_SIZE_WORDS

#define STATIC_QUEUE_TCB_SIZE_WORDS 24U

Opaque buffer type that the caller must supply for xQueueCreateStatic(). Must be at least sizeof(StaticQueue_t) bytes. Declared as a fixed-size array of uintptr_t to enforce natural alignment without exposing FrtosQueue internals. Size is conservative: covers FrtosQueue on all supported targets.

Definition at line 474 of file FreeRTOS.h.

◆ STATIC_SEMAPHORE_TCB_SIZE_WORDS

#define STATIC_SEMAPHORE_TCB_SIZE_WORDS 8U

Opaque buffer type that the caller must supply for xSemaphoreCreateBinaryStatic() and related static semaphore/mutex creation functions. Must be at least sizeof(FrtosSemaphore) bytes. Declared as a fixed-size array of uintptr_t to enforce natural alignment without exposing FrtosSemaphore internals. Size is conservative: covers FrtosSemaphore on all supported targets.

Definition at line 485 of file FreeRTOS.h.

◆ STATIC_STREAM_BUFFER_TCB_SIZE_WORDS

#define STATIC_STREAM_BUFFER_TCB_SIZE_WORDS 26U

Opaque buffer type for xStreamBufferCreateStatic() and xStreamBufferCreateStaticWithCallback(). Covers FrtosStreamBuffer (Pipe + trigger level + ownership flags + two StreamBufferCallbackFunction_t pointers) on all supported STK targets. Size is conservative (+2 words vs the pre-callback layout).

Definition at line 517 of file FreeRTOS.h.

◆ STATIC_TASK_TCB_SIZE_WORDS

#define STATIC_TASK_TCB_SIZE_WORDS

Value:

(19U + configNUM_THREAD_LOCAL_STORAGE_POINTERS \

+ (3U * (configTASK_NOTIFICATION_ARRAY_ENTRIES - 1U)))

configTASK_NOTIFICATION_ARRAY_ENTRIES

#define configTASK_NOTIFICATION_ARRAY_ENTRIES

Definition FreeRTOS.h:168

configNUM_THREAD_LOCAL_STORAGE_POINTERS

#define configNUM_THREAD_LOCAL_STORAGE_POINTERS

Definition FreeRTOS.h:164

Opaque buffer type that the caller must supply for xTaskCreateStatic(). Must be at least sizeof(StaticTask_t) bytes; declared as a fixed-size array of uintptr_t so the compiler enforces natural alignment without requiring knowledge of FrtosTask internals. Size is conservative: covers FrtosTask on all supported STK targets.

Definition at line 463 of file FreeRTOS.h.

463#define STATIC_TASK_TCB_SIZE_WORDS (19U + configNUM_THREAD_LOCAL_STORAGE_POINTERS \

464 + (3U * (configTASK_NOTIFICATION_ARRAY_ENTRIES - 1U)))

◆ STATIC_TIMER_TCB_SIZE_WORDS

#define STATIC_TIMER_TCB_SIZE_WORDS 16U

Opaque buffer type that the caller must supply for xTimerCreateStatic(). Must be at least sizeof(FrtosTimer) bytes. Declared as a fixed-size array of uintptr_t to enforce natural alignment without exposing FrtosTimer internals. Size is conservative: covers FrtosTimer (vtable ptr + base + 5 members) on all supported targets.

Definition at line 496 of file FreeRTOS.h.

◆ taskDISABLE_INTERRUPTS

#define taskDISABLE_INTERRUPTS ( )

Value:

vPortEnterCritical()

vPortEnterCritical

void vPortEnterCritical(void)

Definition freertos_stk.cpp:351

Definition at line 394 of file FreeRTOS.h.

◆ taskENABLE_INTERRUPTS

#define taskENABLE_INTERRUPTS ( )

Value:

vPortExitCritical()

vPortExitCritical

void vPortExitCritical(void)

Definition freertos_stk.cpp:356

Definition at line 395 of file FreeRTOS.h.

◆ taskENTER_CRITICAL

#define taskENTER_CRITICAL ( )

Value:

vPortEnterCritical()

Definition at line 392 of file FreeRTOS.h.

◆ taskEXIT_CRITICAL

#define taskEXIT_CRITICAL ( )

Value:

vPortExitCritical()

Definition at line 393 of file FreeRTOS.h.

◆ taskSCHEDULER_NOT_STARTED

#define taskSCHEDULER_NOT_STARTED ((BaseType_t)0)

Scheduler has not yet been started (STATE_INACTIVE / STATE_READY).

Definition at line 427 of file FreeRTOS.h.

Referenced by xTaskGetSchedulerState().

◆ taskSCHEDULER_RUNNING

#define taskSCHEDULER_RUNNING ((BaseType_t)1)

Scheduler is running normally (STATE_RUNNING).

Definition at line 428 of file FreeRTOS.h.

Referenced by xTaskGetSchedulerState().

◆ taskSCHEDULER_SUSPENDED

#define taskSCHEDULER_SUSPENDED ((BaseType_t)2)

Scheduler is suspended via vTaskSuspendAll() (STATE_SUSPENDED).

Definition at line 429 of file FreeRTOS.h.

Referenced by xTaskGetSchedulerState().

◆ taskYIELD

#define taskYIELD ( )

Value:

taskYIELD_impl()

Definition at line 396 of file FreeRTOS.h.

◆ tskIDLE_PRIORITY

#define tskIDLE_PRIORITY ((UBaseType_t)0U)

Idle task priority.

Definition at line 2029 of file FreeRTOS.h.

Referenced by FrtosTask::FrtosTask().

◆ xTaskHandle

#define xTaskHandle TaskHandle_t

Legacy handle alias.

Definition at line 2030 of file FreeRTOS.h.

Typedef Documentation

◆ BaseType_t

typedef long BaseType_t

Definition at line 257 of file FreeRTOS.h.

◆ EventBits_t

typedef uint32_t EventBits_t

Bitmask for event group operations (bits 0..23 per FreeRTOS convention).

Definition at line 380 of file FreeRTOS.h.

◆ EventGroupHandle_t

typedef void* EventGroupHandle_t

Handle for an event group.

Definition at line 314 of file FreeRTOS.h.

◆ MessageBufferHandle_t

typedef void* MessageBufferHandle_t

Handle for a message buffer.

Definition at line 316 of file FreeRTOS.h.

◆ PendedFunction_t

typedef void(* PendedFunction_t) (void *pvParameter1, uint32_t ulParameter2)

Callback for xTimerPendFunctionCall().

Definition at line 328 of file FreeRTOS.h.

◆ portBASE_TYPE

typedef long portBASE_TYPE

Definition at line 259 of file FreeRTOS.h.

◆ QueueHandle_t

typedef void* QueueHandle_t

Handle for a queue.

Definition at line 311 of file FreeRTOS.h.

◆ QueueSetHandle_t

typedef void* QueueSetHandle_t

Definition at line 319 of file FreeRTOS.h.

◆ QueueSetMemberHandle_t

typedef void* QueueSetMemberHandle_t

Definition at line 320 of file FreeRTOS.h.

◆ SemaphoreHandle_t

typedef void* SemaphoreHandle_t

Handle for a semaphore/mutex.

Definition at line 312 of file FreeRTOS.h.

◆ StackType_t

typedef uintptr_t StackType_t

Native-word stack element type, matches stk::Word.

Definition at line 260 of file FreeRTOS.h.

◆ StreamBufferCallbackFunction_t

typedef void(* StreamBufferCallbackFunction_t) (StreamBufferHandle_t xStreamBuffer, BaseType_t *pxHigherPriorityTaskWoken)

Stream / message buffer send-complete and receive-complete callback. Invoked after bytes are successfully written (send) or read (receive) from the buffer. \a xHigherPriorityTaskWoken is always set to pdFALSE by the STK backend; it is included only for FreeRTOS API compatibility. May be NULL (no callback).

Definition at line 336 of file FreeRTOS.h.

◆ StreamBufferHandle_t

typedef void* StreamBufferHandle_t

Handle for a stream buffer.

Definition at line 315 of file FreeRTOS.h.

◆ TaskFunction_t

typedef void(* TaskFunction_t) (void *pvParameters)

Task entry function.

Definition at line 326 of file FreeRTOS.h.

◆ TaskHandle_t

typedef void* TaskHandle_t

Handle for a task.

Definition at line 310 of file FreeRTOS.h.

◆ TickType_t

typedef uint32_t TickType_t

Definition at line 256 of file FreeRTOS.h.

◆ TimerCallbackFunction_t

typedef void(* TimerCallbackFunction_t) (TimerHandle_t xTimer)

Timer expiry callback.

Definition at line 327 of file FreeRTOS.h.

◆ TimerHandle_t

typedef void* TimerHandle_t

Handle for a software timer.

Definition at line 313 of file FreeRTOS.h.

◆ UBaseType_t

typedef unsigned long UBaseType_t

Definition at line 258 of file FreeRTOS.h.

Enumeration Type Documentation

◆ eNotifyAction

enum eNotifyAction

Action applied to a task's notification value by xTaskNotify().

Enumerator
eNoAction	No action; notification sent without modifying the value.
eSetBits	OR ulValue into the notification value.
eIncrement	Increment the notification value by 1 (ulValue ignored).
eSetValueWithOverwrite	Set notification value to ulValue unconditionally.
eSetValueWithoutOverwrite	Set only if the previous notification was consumed.

Definition at line 294 of file FreeRTOS.h.

{
    eNoAction = 0,            
    eSetBits,                 
    eIncrement,               
    eSetValueWithOverwrite,   
    eSetValueWithoutOverwrite 
} eNotifyAction;

◆ eTaskState

enum eTaskState

Task execution state, returned by eTaskGetState().

Enumerator
eRunning	Task is actively executing on the CPU.
eReady	Task is in the ready list, eligible to run.
eBlocked	Task is waiting for an event or timeout.
eSuspended	Task is explicitly suspended via vTaskSuspend().
eDeleted	Task has been deleted but not yet cleaned up.
eInvalid	Invalid / unknown state.

Definition at line 279 of file FreeRTOS.h.

{
    eRunning   = 0, 
    eReady,         
    eBlocked,       
    eSuspended,     
    eDeleted,       
    eInvalid        
} eTaskState;

Function Documentation

◆ eTaskGetState()

eTaskState eTaskGetState ( TaskHandle_t xTask )

Return the current execution state of a task.

Definition at line 1326 of file freertos_stk.cpp.

{
    if (xTask == nullptr)
        return eInvalid;
 
    FrtosTask *t = static_cast<FrtosTask *>(xTask);
 
    if (t->m_state == FrtosTask::State::Deleted)
        return eDeleted;
 
    if (t->m_state == FrtosTask::State::Suspended)
        return eSuspended;
 
    // Check whether this is the currently running task.
    if (static_cast<uintptr_t>(stk::GetTid()) == reinterpret_cast<uintptr_t>(t))
        return eRunning;
 
    return eReady;
}

References FrtosTask::Deleted, eDeleted, eInvalid, eReady, eRunning, eSuspended, stk::GetTid(), FrtosTask::m_state, and FrtosTask::Suspended.

Here is the call graph for this function:

◆ pcTaskGetName()

const char * pcTaskGetName ( TaskHandle_t xTaskToQuery )

Return the name string of a task.

Definition at line 1376 of file freertos_stk.cpp.

{
    if (xTaskToQuery == nullptr)
        return nullptr;
 
    return static_cast<FrtosTask *>(xTaskToQuery)->m_name;
}

◆ pcTimerGetName()

const char * pcTimerGetName ( TimerHandle_t xTimer )

Return the name string of a timer.

Definition at line 2899 of file freertos_stk.cpp.

{
    if (xTimer == nullptr)
        return nullptr;
 
    return static_cast<FrtosTimer *>(xTimer)->m_name;
}

◆ pvPortMalloc()

void * pvPortMalloc ( size_t xWantedSize )

Allocate xWantedSize bytes from the system heap.

Returns: Pointer to the allocated block, or NULL on failure.

Note: Thread-safe if the underlying MemoryAllocator::Allocate is. The default implementation delegates to malloc.

Definition at line 184 of file freertos_stk.cpp.

{
    return stk::memory::MemoryAllocator::Allocate(xWantedSize);
}

References __stk_weak, and stk::memory::MemoryAllocator::Allocate().

Referenced by ObjAlloc(), and ObjAllocArray().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pvTaskGetThreadLocalStoragePointer()

void * pvTaskGetThreadLocalStoragePointer	(	TaskHandle_t	xTaskToQuery,
		BaseType_t	xIndex )

Read a TLS pointer slot for a task.

Parameters

xTaskToQuery	Task handle, or NULL for the calling task.
xIndex	Slot index (0 .. configNUM_THREAD_LOCAL_STORAGE_POINTERS-1).

Returns: Stored pointer, or NULL if the index is out of range.

< Per-task TLS pointer slots.

Definition at line 3663 of file freertos_stk.cpp.

{
    if (xIndex < 0 || static_cast<size_t>(xIndex) >= configNUM_THREAD_LOCAL_STORAGE_POINTERS)
        return nullptr;
 
    // Resolve NULL -> calling task.
    if (xTaskToQuery == nullptr)
        xTaskToQuery = xTaskGetCurrentTaskHandle();
 
    if (xTaskToQuery == nullptr)
        return nullptr;
 
    const FrtosTask *t = static_cast<const FrtosTask *>(xTaskToQuery);
 
    stk::sync::ScopedCriticalSection cs_;
    return t->m_tls[static_cast<size_t>(xIndex)];
}

References configNUM_THREAD_LOCAL_STORAGE_POINTERS, FrtosTask::m_tls, and xTaskGetCurrentTaskHandle().

Here is the call graph for this function:

◆ pvTimerGetTimerID()

void * pvTimerGetTimerID ( TimerHandle_t xTimer )

Return the application-defined ID stored in a timer.

Definition at line 2883 of file freertos_stk.cpp.

{
    if (xTimer == nullptr)
        return nullptr;
 
    return static_cast<FrtosTimer *>(xTimer)->m_timer_id;
}

◆ taskYIELD_impl()

void taskYIELD_impl ( void )

Definition at line 361 of file freertos_stk.cpp.

{
    stk::Yield();
}

References stk::Yield().

Here is the call graph for this function:

◆ ulTaskNotifyTake()

uint32_t ulTaskNotifyTake	(	BaseType_t	ulClearCountOnExit,
		TickType_t	xTicksToWait )

Receive a notification (slot 0), optionally clearing or decrementing the value.

Parameters

ulClearCountOnExit	pdTRUE = clear to 0 on exit, pdFALSE = decrement by 1.
xTicksToWait	Ticks to wait for a notification.

Returns: Notification value before the clear/decrement, or 0 on timeout.

Definition at line 3381 of file freertos_stk.cpp.

{
    return ulTaskNotifyTakeIndexed(0U, ulClearCountOnExit, xTicksToWait);
}

References ulTaskNotifyTakeIndexed().

Here is the call graph for this function:

◆ ulTaskNotifyTakeIndexed()

uint32_t ulTaskNotifyTakeIndexed	(	UBaseType_t	uxIndexToWait,
		BaseType_t	ulClearCountOnExit,
		TickType_t	xTicksToWait )

Receive a notification from a specific slot of the calling task.

Parameters

uxIndexToWait	Notification slot index.
ulClearCountOnExit	pdTRUE = clear slot value to 0, pdFALSE = decrement by 1.
xTicksToWait	Ticks to wait.

Returns: Slot value before the clear/decrement, or 0 on timeout or bad index.

Definition at line 3264 of file freertos_stk.cpp.

{
    if (IsIrqContext())
        return 0U;
 
    FrtosTask *t = ResolveNotifyTarget(nullptr, uxIndexToWait);
    if (t == nullptr)
        return 0U;
 
    FrtosTask::NotifySlot &slot = t->m_notify[uxIndexToWait];
 
    if (!slot.sem.Wait(FrtosTimeoutToStk(xTicksToWait)))
        return 0U;
 
    uint32_t val = 0U;
 
    {
        stk::sync::ScopedCriticalSection cs_;
        val = slot.value;
 
        if (ulClearCountOnExit == pdTRUE)
            slot.value = 0U;
        else
        if (slot.value > 0U)
            slot.value--;
    }
 
    return val + 1U; // +1: the semaphore signal itself counts
}

References FrtosTimeoutToStk(), IsIrqContext(), FrtosTask::m_notify, pdTRUE, ResolveNotifyTarget(), FrtosTask::NotifySlot::sem, FrtosTask::NotifySlot::value, and stk::sync::Semaphore::Wait().

Referenced by ulTaskNotifyTake().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ulTaskNotifyValueClear()

uint32_t ulTaskNotifyValueClear	(	TaskHandle_t	xTask,
		uint32_t	ulBitsToClear )

Atomically clear the specified bits in the notification value of slot 0 of a task, and return the value of the notification word before the bits were cleared.

Parameters

xTask	Handle of the task. NULL selects the calling task.
ulBitsToClear	Bitmask of bits to clear (ANDed with complement). Pass 0xFFFFFFFF to clear all bits.

Returns: Notification value before the clear operation, or 0 on bad handle.

Note: ISR-safe.

Definition at line 3616 of file freertos_stk.cpp.

{
    return ulTaskNotifyValueClearIndexed(xTask, 0U, ulBitsToClear);
}

References ulTaskNotifyValueClearIndexed().

Here is the call graph for this function:

◆ ulTaskNotifyValueClearIndexed()

uint32_t ulTaskNotifyValueClearIndexed	(	TaskHandle_t	xTask,
		UBaseType_t	uxIndexToClear,
		uint32_t	ulBitsToClear )

Indexed variant of ulTaskNotifyValueClear.

Parameters

xTask	Handle of the task. NULL selects the calling task.
uxIndexToClear	Notification slot index.
ulBitsToClear	Bitmask of bits to clear.

Returns: Notification value before the clear, or 0 on bad handle / index.

Note: ISR-safe.

Definition at line 3594 of file freertos_stk.cpp.

{
    FrtosTask *t = ResolveNotifyTarget(xTask, uxIndexToClear);
    if (t == nullptr)
        return 0U;
 
    FrtosTask::NotifySlot &slot = t->m_notify[uxIndexToClear];
 
    stk::sync::ScopedCriticalSection cs_;
 
    const uint32_t prev = slot.value;
    slot.value &= ~ulBitsToClear;
 
    return prev;
}

References FrtosTask::m_notify, ResolveNotifyTarget(), and FrtosTask::NotifySlot::value.

Referenced by ulTaskNotifyValueClear().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ uxQueueMessagesWaiting()

UBaseType_t uxQueueMessagesWaiting ( QueueHandle_t xQueue )

Return the number of items currently in the queue.

Definition at line 1796 of file freertos_stk.cpp.

{
    if (xQueue == nullptr)
        return 0U;
 
    return static_cast<UBaseType_t>(
        static_cast<FrtosQueue *>(xQueue)->m_mq.GetCount());
}

References stk::sync::MessageQueue::GetCount(), and FrtosQueue::m_mq.

Here is the call graph for this function:

◆ uxQueueMessagesWaitingFromISR()

UBaseType_t uxQueueMessagesWaitingFromISR ( QueueHandle_t xQueue )

Return the number of items currently in the queue from ISR context.

Note: ISR-safe on targets where a size_t-aligned read is atomic.

Returns: Point-in-time snapshot of the message count.

Definition at line 1805 of file freertos_stk.cpp.

{
    // GetCount() is ISR-safe on targets where a size_t-aligned read is atomic
    // (per the STK MessageQueue documentation).
    if (xQueue == nullptr)
        return 0U;
 
    return static_cast<UBaseType_t>(static_cast<FrtosQueue *>(xQueue)->m_mq.GetCount());
}

References stk::sync::MessageQueue::GetCount(), and FrtosQueue::m_mq.

Here is the call graph for this function:

◆ uxQueueSpacesAvailable()

UBaseType_t uxQueueSpacesAvailable ( QueueHandle_t xQueue )

Return the number of free slots in the queue.

Definition at line 1815 of file freertos_stk.cpp.

{
    if (xQueue == nullptr)
        return 0U;
 
    return static_cast<UBaseType_t>(
        static_cast<FrtosQueue *>(xQueue)->m_mq.GetSpace());
}

References stk::sync::MessageQueue::GetSpace(), and FrtosQueue::m_mq.

Here is the call graph for this function:

◆ uxSemaphoreGetCount()

UBaseType_t uxSemaphoreGetCount ( SemaphoreHandle_t xSemaphore )

Return the current count of a counting semaphore, or 1/0 for a mutex (1 = unlocked, 0 = locked).

Definition at line 2500 of file freertos_stk.cpp.

{
    if (xSemaphore == nullptr)
        return 0U;
 
    FrtosSemaphore *s = static_cast<FrtosSemaphore *>(xSemaphore);
 
    if (s->m_kind == SemKind::Counting)
        return static_cast<UBaseType_t>(s->m_sem->GetCount());
 
#if configUSE_MUTEXES
    // For a mutex, count = 0 means locked, 1 means unlocked.
    return (s->m_mtx->GetOwner() == stk::TID_NONE) ? 1U : 0U;
#else
    return 0U;
#endif
}

References Counting, stk::sync::Semaphore::GetCount(), stk::sync::Mutex::GetOwner(), FrtosSemaphore::m_kind, FrtosSemaphore::m_mtx, FrtosSemaphore::m_sem, and stk::TID_NONE.

Here is the call graph for this function:

◆ uxTaskGetNumberOfTasks()

UBaseType_t uxTaskGetNumberOfTasks ( void )

Return the number of tasks currently under kernel management.

Definition at line 1082 of file freertos_stk.cpp.

{
    stk::sync::ScopedCriticalSection cs_;
    return static_cast<UBaseType_t>(g_StkKernel.GetSwitchStrategy()->GetSize());
}

References g_StkKernel.

◆ uxTaskGetStackHighWaterMark()

UBaseType_t uxTaskGetStackHighWaterMark ( TaskHandle_t xTask )

Return the unused stack depth high-water mark in Words. Pass NULL for the calling task.

Definition at line 1384 of file freertos_stk.cpp.

{
    const FrtosTask *t = (xTask == nullptr) ? reinterpret_cast<const FrtosTask *>(
        static_cast<uintptr_t>(stk::GetTid())) : static_cast<const FrtosTask *>(xTask);
 
    if (t == nullptr)
        return 0U;
 
    return static_cast<UBaseType_t>(t->GetStackHighWaterMark());
}

References FrtosTask::GetStackHighWaterMark(), and stk::GetTid().

Here is the call graph for this function:

◆ uxTaskGetStackHighWaterMark2()

StackType_t uxTaskGetStackHighWaterMark2 ( TaskHandle_t xTask )

Return the unused stack depth high-water mark in Words. Pass NULL for the calling task.

< Stack depth word type.

Definition at line 1395 of file freertos_stk.cpp.

{
    const FrtosTask *t = (xTask == nullptr) ? reinterpret_cast<const FrtosTask *>(
        static_cast<uintptr_t>(stk::GetTid())) : static_cast<const FrtosTask *>(xTask);
 
    if (t == nullptr)
        return 0U;
 
    return static_cast<configSTACK_DEPTH_TYPE>(t->GetStackHighWaterMark());
}

References configSTACK_DEPTH_TYPE, FrtosTask::GetStackHighWaterMark(), and stk::GetTid().

Here is the call graph for this function:

◆ uxTaskGetSystemState()

UBaseType_t uxTaskGetSystemState	(	TaskStatus_t *	pxTaskStatusArray,
		UBaseType_t	uxArraySize,
		uint32_t *	pulTotalRunTime )

Populate an array of TaskStatus_t with a snapshot of every task's state.

Parameters

pxTaskStatusArray	Caller-supplied array of at least uxArraySize elements.
uxArraySize	Capacity of pxTaskStatusArray (should be >= uxTaskGetNumberOfTasks()).
pulTotalRunTime	Receives 0 (STK has no global run-time counter). May be NULL.

Returns: Number of TaskStatus_t entries written. May be less than uxTaskGetNumberOfTasks() if pxTaskStatusArray was too small.

< Stack depth word type.

Definition at line 1406 of file freertos_stk.cpp.

{
    // STK has no global CPU run-time accumulator; report 0 per the FreeRTOS
    // convention for targets that do not implement run-time statistics.
    if (pulTotalRunTime != nullptr)
        *pulTotalRunTime = 0U;
 
    if ((pxTaskStatusArray == nullptr) || (uxArraySize == 0U))
        return 0U;
 
    UBaseType_t filled = 0U;
 
    // Identify the currently running task once, outside the enumeration
    // loop, so the eRunning check is consistent across all entries.
    const uintptr_t running_tid = static_cast<uintptr_t>(stk::GetTid());
 
    g_StkKernel.EnumerateTasksT<FREERTOS_STK_MAX_TASKS>([&](stk::ITask *itask) -> bool
    {
        if (filled >= uxArraySize)
            return false; // array full — stop enumeration
 
        const FrtosTask *t = static_cast<const FrtosTask *>(itask);
        TaskStatus_t    &s = pxTaskStatusArray[filled];
 
        // xHandle — the FrtosTask pointer cast to an opaque handle.
        s.xHandle = static_cast<TaskHandle_t>(const_cast<FrtosTask *>(t));
 
        // pcTaskName — direct pointer into the task's name buffer (not a copy).
        s.pcTaskName = (t->m_name != nullptr) ? t->m_name : "";
 
        // eCurrentState — mirrors eTaskGetState() logic.
        if (t->m_state == FrtosTask::State::Deleted)
            s.eCurrentState = eDeleted;
        else
        if (t->m_state == FrtosTask::State::Suspended)
            s.eCurrentState = eSuspended;
        else
        if (reinterpret_cast<uintptr_t>(t) == running_tid)
            s.eCurrentState = eRunning;
        else
            s.eCurrentState = eReady;
 
        // uxCurrentPriority / uxBasePriority — same value: STK has no
        // priority inheritance so the current and base priority are identical.
        s.uxCurrentPriority = StkWeightToFrtosPrio(t->m_weight);
        s.uxBasePriority    = s.uxCurrentPriority;
 
        // ulRunTimeCounter — always 0 (STK has no per-task CPU accounting).
        s.ulRunTimeCounter = 0U;
 
        // pxStackBase — bottom of the stack array (index 0).
        s.pxStackBase = reinterpret_cast<StackType_t *>(t->m_stack);
 
        // usStackHighWaterMark — minimum observed free Words (watermark scan).
        s.usStackHighWaterMark =
            static_cast<configSTACK_DEPTH_TYPE>(t->GetStackHighWaterMark());
 
        // xTaskNumber — monotonic serial assigned at construction.
        s.xTaskNumber = t->m_task_number;
 
        ++filled;
        return true; // continue enumeration
    });
 
    return filled;
}

References configSTACK_DEPTH_TYPE, FrtosTask::Deleted, TaskStatus_t::eCurrentState, eDeleted, eReady, eRunning, eSuspended, FREERTOS_STK_MAX_TASKS, g_StkKernel, FrtosTask::GetStackHighWaterMark(), stk::GetTid(), FrtosTask::m_name, FrtosTask::m_stack, FrtosTask::m_state, FrtosTask::m_task_number, FrtosTask::m_weight, TaskStatus_t::pcTaskName, TaskStatus_t::pxStackBase, StkWeightToFrtosPrio(), FrtosTask::Suspended, TaskStatus_t::ulRunTimeCounter, TaskStatus_t::usStackHighWaterMark, TaskStatus_t::uxBasePriority, TaskStatus_t::uxCurrentPriority, TaskStatus_t::xHandle, and TaskStatus_t::xTaskNumber.

Here is the call graph for this function:

◆ uxTaskPriorityGet()

UBaseType_t uxTaskPriorityGet ( TaskHandle_t xTask )

Query the priority of a task. Pass NULL xTask for the calling task.

Definition at line 1310 of file freertos_stk.cpp.

{
    const FrtosTask *t = (xTask == nullptr) ? reinterpret_cast<const FrtosTask *>(
        static_cast<uintptr_t>(stk::GetTid())) : static_cast<const FrtosTask *>(xTask);
 
    if (t == nullptr)
        return 0U;
 
    return StkWeightToFrtosPrio(t->m_weight);
}

References stk::GetTid(), FrtosTask::m_weight, and StkWeightToFrtosPrio().

Referenced by uxTaskPriorityGetFromISR().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ uxTaskPriorityGetFromISR()

UBaseType_t uxTaskPriorityGetFromISR ( TaskHandle_t xTask )

Query the priority of a task from ISR context (ISR-safe).

Definition at line 1321 of file freertos_stk.cpp.

{
    return uxTaskPriorityGet(xTask); // same implementation; GetTid() is ISR-safe
}

References uxTaskPriorityGet().

Here is the call graph for this function:

◆ vEventGroupDelete()

void vEventGroupDelete ( EventGroupHandle_t xEventGroup )

Delete an event group and free its memory.

Definition at line 2992 of file freertos_stk.cpp.

{
    if (xEventGroup == nullptr)
        return;
 
    ObjFree(static_cast<FrtosEventGroup *>(xEventGroup));
}

References ObjFree().

Here is the call graph for this function:

◆ vMessageBufferDelete()

void vMessageBufferDelete ( MessageBufferHandle_t xMessageBuffer )

Delete a message buffer and free heap resources (if dynamically allocated).

Definition at line 4206 of file freertos_stk.cpp.

{
    if (xMessageBuffer == nullptr)
        return;
 
    FrtosMessageBuffer *mb = static_cast<FrtosMessageBuffer *>(xMessageBuffer);
 
    ObjFree(mb);
}

References ObjFree().

Here is the call graph for this function:

◆ vPortEnterCritical()

void vPortEnterCritical ( void )

Definition at line 351 of file freertos_stk.cpp.

{
    stk::hw::CriticalSection::Enter();
}

References stk::hw::CriticalSection::Enter().

Here is the call graph for this function:

◆ vPortExitCritical()

void vPortExitCritical ( void )

Definition at line 356 of file freertos_stk.cpp.

{
    stk::hw::CriticalSection::Exit();
}

References stk::hw::CriticalSection::Exit().

Here is the call graph for this function:

◆ vPortFree()

void vPortFree ( void * pv )

Free a block previously returned by pvPortMalloc().

Parameters

pv	Pointer to the block to free. NULL is a no-op.

Note: Thread-safe if the underlying MemoryAllocator::Free is.

Definition at line 189 of file freertos_stk.cpp.

{
    stk::memory::MemoryAllocator::Free(pv);
}

References __stk_weak, and stk::memory::MemoryAllocator::Free().

Referenced by ObjFree(), ObjFreeArray(), and ObjFreeRaw().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ vPortGetHeapStats()

void vPortGetHeapStats ( HeapStats_t * pxHeapStats )

Fill pxHeapStats with a snapshot of the heap statistics.

Fields that require traversal of the internal free-block list are reported conservatively (see HeapStats_t documentation); all other fields are exact.

Parameters

pxHeapStats Pointer to the HeapStats_t structure to fill. NULL is silently ignored.

Definition at line 233 of file freertos_stk.cpp.

{
    if (pxHeapStats == nullptr)
        return;
 
    const stk::memory::MemoryAllocator::Stats snap = s_MemStats;
    const size_t free_now = snap.GetAvailable();
 
    (*pxHeapStats) = {};
 
    // Fields derived directly from s_MemStats accounting.
    pxHeapStats->xAvailableHeapSpaceInBytes      = free_now;
    pxHeapStats->xMinimumEverFreeBytesRemaining  = snap.min_ever_free;
    pxHeapStats->xNumberOfSuccessfulAllocations  = snap.allocate_count;
    pxHeapStats->xNumberOfSuccessfulFrees        = snap.free_count;
 
    // Fields that require free-block-list traversal are unavailable without a
    // block-list allocator (we delegate to malloc).  Report conservative values:
    //   - largest free block  : current free bytes (treat heap as one region)
    //   - smallest free block : 0  (unknown subdivision)
    //   - number of free blocks: 1  (at least one region exists while free > 0)
    pxHeapStats->xSizeOfLargestFreeBlockInBytes  = free_now;
    pxHeapStats->xSizeOfSmallestFreeBlockInBytes = (free_now > 0U) ? 1U : 0U;
    pxHeapStats->xNumberOfFreeBlocks             = (free_now > 0U) ? 1U : 0U;
}

References stk::memory::MemoryAllocator::Stats::allocate_count, stk::memory::MemoryAllocator::Stats::free_count, stk::memory::MemoryAllocator::Stats::GetAvailable(), stk::memory::MemoryAllocator::Stats::min_ever_free, s_MemStats, HeapStats_t::xAvailableHeapSpaceInBytes, HeapStats_t::xMinimumEverFreeBytesRemaining, HeapStats_t::xNumberOfFreeBlocks, HeapStats_t::xNumberOfSuccessfulAllocations, HeapStats_t::xNumberOfSuccessfulFrees, HeapStats_t::xSizeOfLargestFreeBlockInBytes, and HeapStats_t::xSizeOfSmallestFreeBlockInBytes.

Here is the call graph for this function:

◆ vQueueDelete()

void vQueueDelete ( QueueHandle_t xQueue )

Delete a queue and free all associated memory.

Definition at line 1700 of file freertos_stk.cpp.

{
    if (xQueue == nullptr)
        return;
 
    ObjFree(static_cast<FrtosQueue *>(xQueue));
}

References ObjFree().

Here is the call graph for this function:

◆ vSemaphoreDelete()

void vSemaphoreDelete ( SemaphoreHandle_t xSemaphore )

Delete a semaphore or mutex and free its memory.

Definition at line 2380 of file freertos_stk.cpp.

{
    if (xSemaphore == nullptr)
        return;
 
    ObjFree(static_cast<FrtosSemaphore *>(xSemaphore));
}

References ObjFree().

Here is the call graph for this function:

◆ vStreamBufferDelete()

void vStreamBufferDelete ( StreamBufferHandle_t xStreamBuffer )

Delete a stream buffer and free heap resources (if dynamically allocated).

Definition at line 3754 of file freertos_stk.cpp.

{
    if (xStreamBuffer == nullptr)
        return;
 
    FrtosStreamBuffer *sb = static_cast<FrtosStreamBuffer *>(xStreamBuffer);
 
    ObjFree(sb);
}

References ObjFree().

Here is the call graph for this function:

◆ vTaskDelay()

void vTaskDelay ( TickType_t xTicksToDelay )

Block the calling task for a number of ticks.

Definition at line 1273 of file freertos_stk.cpp.

{
    if (IsIrqContext())
        return;
 
    stk::Sleep(FrtosTimeoutToStk(xTicksToDelay));
}

References FrtosTimeoutToStk(), IsIrqContext(), and stk::Sleep().

Here is the call graph for this function:

◆ vTaskDelayUntil()

void vTaskDelayUntil	(	TickType_t *	pxPreviousWakeTime,
		TickType_t	xTimeIncrement )

Block until an absolute tick deadline for drift-free periodic loops. Updates *pxPreviousWakeTime on each call.

Definition at line 1281 of file freertos_stk.cpp.

{
    static_cast<void>(xTaskDelayUntil(pxPreviousWakeTime, xTimeIncrement));
}

References xTaskDelayUntil().

Here is the call graph for this function:

◆ vTaskDelete()

void vTaskDelete ( TaskHandle_t xTaskToDelete )

Delete a task. Pass NULL to delete the calling task.

Definition at line 1191 of file freertos_stk.cpp.

{
    FrtosTask *t = (xTaskToDelete == nullptr) ? static_cast<FrtosTask *>(
        reinterpret_cast<FrtosTask *>(static_cast<uintptr_t>(stk::GetTid()))) :
            static_cast<FrtosTask *>(xTaskToDelete);
 
    if (t == nullptr)
        return;
 
    stk::sync::ScopedCriticalSection cs_;
 
    g_StkKernel.ScheduleTaskRemoval(t);
 
    // Detached tasks are freed when the slot is released.
    // For this wrapper, all tasks are considered detached (no join semantics).
    ObjFree(t);
}

References g_StkKernel, stk::GetTid(), and ObjFree().

Here is the call graph for this function:

◆ vTaskEndScheduler()

void vTaskEndScheduler ( void )

End scheduling (KERNEL_DYNAMIC only). Included for API completeness.

Definition at line 1050 of file freertos_stk.cpp.

{
    g_StkKernel.EnumerateTasksT<FREERTOS_STK_MAX_TASKS>([&](stk::ITask *task) -> bool
    {
        g_StkKernel.ScheduleTaskRemoval(task);
        return true;
    });
 
    stk::Yield();
}

References FREERTOS_STK_MAX_TASKS, g_StkKernel, and stk::Yield().

Here is the call graph for this function:

◆ vTaskGetRunTimeStats()

void vTaskGetRunTimeStats ( char * pcWriteBuffer )

Write a human-readable CPU run-time statistics table into pcWriteBuffer.

Each row contains: task name, absolute run-time counter, and percentage of total run time. Column layout matches the standard FreeRTOS vTaskGetRunTimeStats() output so existing log parsers work unchanged.

Note: STK has no per-task CPU run-time accumulator. This wrapper always emits 0 for both the absolute counter and the percentage, matching the FreeRTOS convention for targets where configGENERATE_RUN_TIME_STATS is not enabled. The function is provided for link compatibility; applications that need real CPU accounting must instrument the target with a free-running hardware counter and replace the two MemoryAllocator definitions in freertos_stk.cpp with the appropriate port-layer calls.

Parameters

pcWriteBuffer Caller-allocated destination buffer. A safe minimum is uxTaskGetNumberOfTasks() * 40 bytes.

Definition at line 1601 of file freertos_stk.cpp.

{
    if (pcWriteBuffer == nullptr)
        return;
 
    // Column header matching FreeRTOS vTaskGetRunTimeStats() output format so
    // that existing log parsers (SystemView, Tracealyzer, custom scripts) find
    // the layout they expect.
    int off = snprintf(pcWriteBuffer, 64U,
        "%-12s %12s %8s\r\n",
        "Task", "Abs Time", "% Time");
 
    if (off < 0) off = 0;
    char *p = pcWriteBuffer + off;
 
    g_StkKernel.EnumerateTasksT<FREERTOS_STK_MAX_TASKS>([&](stk::ITask *itask) -> bool
    {
        const FrtosTask *t    = static_cast<const FrtosTask *>(itask);
        const char      *name = (t->m_name != nullptr) ? t->m_name : "(unnamed)";
 
        // ulRunTimeCounter is always 0: STK has no per-task CPU accounting.
        // Percentage is therefore also 0.  Emit "<1%" only when a non-zero
        // total is available; here total is always 0 so we emit "0%".
        int n = snprintf(p, 48U, "%-12s %12lu %7lu%%\r\n",
                         name,
                         0UL,  // ulRunTimeCounter
                         0UL); // percentage
        if (n > 0) p += n;
 
        return true; // continue enumeration
    });
 
    *p = '\0'; // null-terminate
}

References FREERTOS_STK_MAX_TASKS, g_StkKernel, and FrtosTask::m_name.

◆ vTaskList()

void vTaskList ( char * pcWriteBuffer )

Write a human-readable task-status table into pcWriteBuffer.

Each row contains: name, state letter (X/R/B/S/D), priority, stack high-water mark (Words), and a 1-based task number. Column widths match the standard FreeRTOS vTaskList() output so that existing tools and log parsers work without modification.

Parameters

pcWriteBuffer Caller-allocated destination buffer. Must be large enough for all active tasks. A safe minimum is uxTaskGetNumberOfTasks() * 40 bytes.

Note: The output is a snapshot; it is not thread-safe with respect to concurrent task creation or deletion.

Definition at line 1530 of file freertos_stk.cpp.

{
    if (pcWriteBuffer == nullptr)
        return;
 
    // Write the column header that FreeRTOS vTaskList() produces, so that
    // existing log parsers find what they expect.
    int off = snprintf(pcWriteBuffer, 64U,
        "%-12s %c %4s %6s %4s\r\n",
        "Name", 'S', "Prio", "Stack", "Num");
 
    if (off < 0) off = 0;
    char *p = pcWriteBuffer + off;
 
    // Enumerate all tasks and fill one row per task.
    UBaseType_t task_num = 0U;
 
    g_StkKernel.EnumerateTasksT<FREERTOS_STK_MAX_TASKS>([&](stk::ITask *itask) -> bool
    {
        ++task_num;
        FrtosTask *t = static_cast<FrtosTask *>(itask);
 
        // Determine state letter, matching FreeRTOS convention:
        //   X = Running, R = Ready, B = Blocked, S = Suspended, D = Deleted
        char state_letter;
        if (t->m_state == FrtosTask::State::Deleted)
            state_letter = 'D';
        else
        if (t->m_state == FrtosTask::State::Suspended)
            state_letter = 'S';
        else
        if (static_cast<uintptr_t>(stk::GetTid()) == reinterpret_cast<uintptr_t>(t))
            state_letter = 'X';
        else
            state_letter = 'R';
 
        const char   *name = (t->m_name != nullptr) ? t->m_name : "(unnamed)";
        UBaseType_t   prio = StkWeightToFrtosPrio(t->m_weight);
        size_t        hwm  = t->GetStackHighWaterMark();
 
        int n = snprintf(p, 48U, "%-12s %c %4u %6u %4u\r\n",
                         name, state_letter,
                         static_cast<unsigned>(prio),
                         static_cast<unsigned>(hwm),
                         static_cast<unsigned>(task_num));
        if (n > 0) p += n;
 
        return true; // continue enumeration
    });
 
    *p = '\0'; // null-terminate
}

References FrtosTask::Deleted, FREERTOS_STK_MAX_TASKS, g_StkKernel, FrtosTask::GetStackHighWaterMark(), stk::GetTid(), FrtosTask::m_name, FrtosTask::m_state, FrtosTask::m_weight, StkWeightToFrtosPrio(), and FrtosTask::Suspended.

Here is the call graph for this function:

◆ vTaskPrioritySet()

void vTaskPrioritySet	(	TaskHandle_t	xTask,
		UBaseType_t	uxNewPriority )

Change the priority of a task. Pass NULL xTask for the calling task.

Definition at line 1299 of file freertos_stk.cpp.

{
    FrtosTask *t = (xTask == nullptr) ? reinterpret_cast<FrtosTask *>(
            static_cast<uintptr_t>(stk::GetTid())) : static_cast<FrtosTask *>(xTask);
 
    if (t == nullptr)
        return;
 
    t->m_weight = FrtosPrioToStkWeight(uxNewPriority);
}

References FrtosPrioToStkWeight(), stk::GetTid(), and FrtosTask::m_weight.

Here is the call graph for this function:

◆ vTaskResume()

void vTaskResume ( TaskHandle_t xTaskToResume )

Resume a previously suspended task.

Definition at line 1223 of file freertos_stk.cpp.

{
    if (xTaskToResume == nullptr)
        return;
 
    FrtosTask *t = static_cast<FrtosTask *>(xTaskToResume);
 
    stk::sync::ScopedCriticalSection cs_;
 
    if (t->m_state != FrtosTask::State::Suspended)
        return;
 
    g_StkKernel.ResumeTask(t);
    t->m_state = FrtosTask::State::Ready;
}

References g_StkKernel, FrtosTask::m_state, FrtosTask::Ready, and FrtosTask::Suspended.

◆ vTaskSetThreadLocalStoragePointer()

void vTaskSetThreadLocalStoragePointer	(	TaskHandle_t	xTaskToSet,
		BaseType_t	xIndex,
		void *	pvValue )

Write a TLS pointer slot for a task.

Parameters

xTaskToSet	Task handle, or NULL for the calling task.
xIndex	Slot index (0 .. configNUM_THREAD_LOCAL_STORAGE_POINTERS-1).
pvValue	Value to store.

< Per-task TLS pointer slots.

Definition at line 3640 of file freertos_stk.cpp.

{
    if (xIndex < 0 || static_cast<size_t>(xIndex) >= configNUM_THREAD_LOCAL_STORAGE_POINTERS)
        return;
 
    // Resolve NULL -> calling task.
    if (xTaskToSet == nullptr)
        xTaskToSet = xTaskGetCurrentTaskHandle();
 
    if (xTaskToSet == nullptr)
        return;
 
    FrtosTask *t = static_cast<FrtosTask *>(xTaskToSet);
 
    // A critical section is not strictly required for a pointer-sized store on
    // aligned memory on single-issue cores, but we guard anyway for strict
    // correctness on SMP targets (RP2040, dual-core Cortex-M33).
    stk::sync::ScopedCriticalSection cs_;
    t->m_tls[static_cast<size_t>(xIndex)] = pvValue;
}

References configNUM_THREAD_LOCAL_STORAGE_POINTERS, FrtosTask::m_tls, and xTaskGetCurrentTaskHandle().

Here is the call graph for this function:

◆ vTaskStartScheduler()

void vTaskStartScheduler ( void )

Initialise STK and start the scheduler. Does not return for KERNEL_DYNAMIC until all tasks have exited.

Definition at line 1043 of file freertos_stk.cpp.

{
    EnsureKernelInitialized();
 
    g_StkKernel.Start(); // does not return for KERNEL_DYNAMIC until all tasks exit
}

References EnsureKernelInitialized(), and g_StkKernel.

Here is the call graph for this function:

◆ vTaskSuspend()

void vTaskSuspend ( TaskHandle_t xTaskToSuspend )

Suspend a task indefinitely. Pass NULL to suspend the calling task.

Definition at line 1209 of file freertos_stk.cpp.

{
    FrtosTask *t = (xTaskToSuspend == nullptr) ? static_cast<FrtosTask *>(
        reinterpret_cast<FrtosTask *>(static_cast<uintptr_t>(stk::GetTid()))) :
            static_cast<FrtosTask *>(xTaskToSuspend);
 
    if (t == nullptr)
        return;
 
    bool already = false;
    g_StkKernel.SuspendTask(t, already);
    t->m_state = FrtosTask::State::Suspended;
}

References g_StkKernel, stk::GetTid(), FrtosTask::m_state, and FrtosTask::Suspended.

Here is the call graph for this function:

◆ vTaskSuspendAll()

void vTaskSuspendAll ( void )

Suspend the scheduler (disables preemption; interrupts remain enabled).

Definition at line 1061 of file freertos_stk.cpp.

{
    stk::hw::CriticalSection::Enter();
}

References stk::hw::CriticalSection::Enter().

Here is the call graph for this function:

◆ vTimerSetTimerID()

void vTimerSetTimerID	(	TimerHandle_t	xTimer,
		void *	pvNewID )

Set the application-defined ID stored in a timer.

Definition at line 2891 of file freertos_stk.cpp.

{
    if (xTimer == nullptr)
        return;
 
    static_cast<FrtosTimer *>(xTimer)->m_timer_id = pvNewID;
}

◆ xEventGroupClearBits()

EventBits_t xEventGroupClearBits	(	EventGroupHandle_t	xEventGroup,
		EventBits_t	uxBitsToClear )

Clear one or more bits in an event group (ISR-safe).

Returns: Value of the bits BEFORE clearing.

Definition at line 3010 of file freertos_stk.cpp.

{
    if (xEventGroup == nullptr)
        return 0U;
 
    // STK Clear() returns the value BEFORE clearing - matches FreeRTOS contract.
    uint32_t prev = static_cast<FrtosEventGroup *>(xEventGroup)->m_ef.Clear(uxBitsToClear);
    return StkFlagsToFrtos(prev);
}

References StkFlagsToFrtos().

Here is the call graph for this function:

◆ xEventGroupClearBitsFromISR()

EventBits_t xEventGroupClearBitsFromISR	(	EventGroupHandle_t	xEventGroup,
		EventBits_t	uxBitsToClear )

Clear event group bits from ISR context.

Returns: Value of the bits BEFORE clearing.

Definition at line 3068 of file freertos_stk.cpp.

{
    if (xEventGroup == nullptr)
        return 0U;
 
    uint32_t prev = static_cast<FrtosEventGroup *>(xEventGroup)->m_ef.Clear(
                        static_cast<uint32_t>(uxBitsToClear));
    return StkFlagsToFrtos(prev);
}

References StkFlagsToFrtos().

Here is the call graph for this function:

◆ xEventGroupCreate()

EventGroupHandle_t xEventGroupCreate ( void )

Create an event group (all bits initialised to 0).

Returns: Event group handle, or NULL on failure.

Definition at line 2965 of file freertos_stk.cpp.

{
    if (IsIrqContext())
        return nullptr;
 
    FrtosEventGroup *eg = ObjAlloc<FrtosEventGroup>();
    return static_cast<EventGroupHandle_t>(eg);
}

References IsIrqContext(), and ObjAlloc().

Here is the call graph for this function:

◆ xEventGroupCreateStatic()

EventGroupHandle_t xEventGroupCreateStatic ( StaticEventGroup_t * pxEventGroupBuffer )

Create an event group using caller-supplied storage — no heap allocation.

Parameters

pxEventGroupBuffer Caller-allocated control block (StaticEventGroup_t). Must remain valid for the lifetime of the event group.

Returns: Event group handle. Never NULL if pxEventGroupBuffer is non-NULL.

Definition at line 2974 of file freertos_stk.cpp.

{
    if (pxEventGroupBuffer == nullptr)
        return nullptr;
 
    if (IsIrqContext())
        return nullptr;
 
    static_assert(sizeof(StaticEventGroup_t) >= sizeof(FrtosEventGroup),
        "StaticEventGroup_t is too small to hold FrtosEventGroup. "
        "Increase STATIC_EVENT_GROUP_TCB_SIZE_WORDS in freertos_stk.h.");
 
    FrtosEventGroup *eg = new (pxEventGroupBuffer) FrtosEventGroup();
    eg->m_cb_owned = false; // caller owns the memory; vEventGroupDelete must not delete it
 
    return static_cast<EventGroupHandle_t>(eg);
}

References IsIrqContext(), and FrtosEventGroup::m_cb_owned.

Here is the call graph for this function:

◆ xEventGroupGetBits()

EventBits_t xEventGroupGetBits ( EventGroupHandle_t xEventGroup )

Return the current event group bits without blocking or modifying them.

Definition at line 3021 of file freertos_stk.cpp.

{
    if (xEventGroup == nullptr)
        return 0U;
 
    return static_cast<EventBits_t>(static_cast<FrtosEventGroup *>(xEventGroup)->m_ef.Get());
}

References stk::sync::EventFlags::Get(), and FrtosEventGroup::m_ef.

Here is the call graph for this function:

◆ xEventGroupSetBits()

EventBits_t xEventGroupSetBits	(	EventGroupHandle_t	xEventGroup,
		EventBits_t	uxBitsToSet )

Set one or more bits in an event group (ISR-safe).

Returns: Value of the event group bits after the set operation.

Definition at line 3000 of file freertos_stk.cpp.

{
    if (xEventGroup == nullptr)
        return 0U;
 
    uint32_t result = static_cast<FrtosEventGroup *>(xEventGroup)->m_ef.Set(uxBitsToSet);
    return StkFlagsToFrtos(result);
}

References StkFlagsToFrtos().

Here is the call graph for this function:

◆ xEventGroupSetBitsFromISR()

BaseType_t xEventGroupSetBitsFromISR	(	EventGroupHandle_t	xEventGroup,
		EventBits_t	uxBitsToSet,
		BaseType_t *	pxHigherPriorityTaskWoken )

Set event group bits from ISR context.

Parameters

pxHigherPriorityTaskWoken Set pdTRUE if a context switch is needed.

Returns: pdPASS on success, pdFAIL on invalid bits argument.

Definition at line 3052 of file freertos_stk.cpp.

{
    if (xEventGroup == nullptr)
        return pdFAIL;
 
    uint32_t result = static_cast<FrtosEventGroup *>(xEventGroup)->m_ef.Set(
                          static_cast<uint32_t>(uxBitsToSet));
 
    if (pxHigherPriorityTaskWoken != nullptr)
        *pxHigherPriorityTaskWoken = pdFALSE;
 
    return stk::sync::EventFlags::IsError(result) ? pdFAIL : pdPASS;
}

References stk::sync::EventFlags::IsError(), pdFAIL, pdFALSE, and pdPASS.

Here is the call graph for this function:

◆ xEventGroupSync()

EventBits_t xEventGroupSync	(	EventGroupHandle_t	xEventGroup,
		EventBits_t	uxBitsToSet,
		EventBits_t	uxBitsToWaitFor,
		TickType_t	xTicksToWait )

Task rendezvous / barrier synchronization using an event group.

Atomically sets uxBitsToSet in the event group, then blocks until uxBitsToWaitFor are all set (AND semantics). On success, all bits in uxBitsToWaitFor are atomically cleared before returning.

Note: This is the standard FreeRTOS "event group sync" / barrier primitive. All N participating tasks call xEventGroupSync() with the same uxBitsToWaitFor mask and non-overlapping individual uxBitsToSet masks (one bit per task). The call returns only after every task has set its bit.; The set and the wait are performed without releasing the CPU between them, so no participating task can observe a state in which this task has not yet entered the wait. This matches the FreeRTOS reference implementation guarantee.

Parameters

xEventGroup	Event group handle (must not be NULL).
uxBitsToSet	Bit(s) this task sets to signal it has reached the sync point (must be a subset of uxBitsToWaitFor).
uxBitsToWaitFor	Bitmask of ALL bits that must be set before any participating task is released (AND semantics).
xTicksToWait	Maximum ticks to wait. portMAX_DELAY = wait forever. NO_WAIT (0) performs a non-blocking test.

Returns: Value of the event group bits at the point the condition was met (before the bits were cleared), or 0 if the timeout expired before all bits were set.

Warning: ISR-unsafe (blocking). Not callable from an ISR context.

Definition at line 3125 of file freertos_stk.cpp.

{
    // Contract checks that mirror the FreeRTOS reference implementation.
    if (xEventGroup    == nullptr)  return 0U;
    if (uxBitsToWaitFor == 0U)      return 0U;
    if (IsIrqContext())             return 0U;  // blocking wait is ISR-unsafe
 
    FrtosEventGroup *eg  = static_cast<FrtosEventGroup *>(xEventGroup);
    stk::sync::EventFlags &ef = eg->m_ef;
 
    // Step 1: Set this task's rendezvous bit(s).
    //
    // uxBitsToSet == 0 is legal (observer role: task waits without contributing
    // a bit).  Only call Set() when there is actually something to set.
    if (uxBitsToSet != 0U)
    {
        uint32_t set_result = ef.Set(static_cast<uint32_t>(uxBitsToSet));
 
        // Treat an ERROR_PARAMETER return as a hard usage fault — the caller
        // violated the API (e.g. set bit 31).
        STK_ASSERT(!stk::sync::EventFlags::IsError(set_result));
 
        if (stk::sync::EventFlags::IsError(set_result))
            return 0U;
    }
 
    // Step 2 + 3: Wait for ALL bits in uxBitsToWaitFor, clear them on success.
    //
    // OPT_WAIT_ALL   — AND semantics: all bits must be set simultaneously.
    // OPT_NO_CLEAR is NOT passed — matched bits are cleared atomically inside
    // Wait() when the predicate is first satisfied, exactly matching the
    // FreeRTOS "clear bits on exit" contract for xEventGroupSync().
    const uint32_t opts = stk::sync::EventFlags::OPT_WAIT_ALL;
                          // (OPT_NO_CLEAR absent -> clear on success)
 
    uint32_t result = ef.Wait(static_cast<uint32_t>(uxBitsToWaitFor),
                              opts,
                              FrtosTimeoutToStk(xTicksToWait));
 
    // On timeout or error, return 0 (matches FreeRTOS reference behaviour).
    return StkFlagsToFrtos(result);
}

References FrtosTimeoutToStk(), stk::sync::EventFlags::IsError(), IsIrqContext(), FrtosEventGroup::m_ef, stk::sync::EventFlags::OPT_WAIT_ALL, stk::sync::EventFlags::Set(), STK_ASSERT, StkFlagsToFrtos(), and stk::sync::EventFlags::Wait().

Here is the call graph for this function:

◆ xEventGroupWaitBits()

EventBits_t xEventGroupWaitBits	(	EventGroupHandle_t	xEventGroup,
		EventBits_t	uxBitsToWaitFor,
		BaseType_t	xClearOnExit,
		BaseType_t	xWaitForAllBits,
		TickType_t	xTicksToWait )

Block the calling task until the specified bit condition is met.

Parameters

uxBitsToWaitFor	Bitmask of bits to watch.
xClearOnExit	pdTRUE = atomically clear matched bits on return.
xWaitForAllBits	pdTRUE = AND semantics, pdFALSE = OR semantics.
xTicksToWait	Maximum ticks to block. portMAX_DELAY = wait forever.

Returns: Bits that caused unblocking (before optional clear), or 0 on timeout.

Definition at line 3029 of file freertos_stk.cpp.

{
    if (IsIrqContext() || (xEventGroup == nullptr) || (uxBitsToWaitFor == 0U))
        return 0U;
 
    stk::sync::EventFlags &ef = static_cast<FrtosEventGroup *>(xEventGroup)->m_ef;
 
    uint32_t opts   = BuildStkFlagsOpts(xClearOnExit, xWaitForAllBits);
    uint32_t result = ef.Wait(static_cast<uint32_t>(uxBitsToWaitFor),
                              opts,
                              FrtosTimeoutToStk(xTicksToWait));
 
    // On timeout, FreeRTOS documents that the return value is the flags word
    // at the moment the timeout occurred, not zero.  ef.Get() is a volatile
    // read that is atomic on all supported 32-bit STK targets; no CS needed.
    const EventBits_t snapshot = static_cast<EventBits_t>(ef.Get());
    return StkFlagsToFrtos(result, snapshot);
}

References BuildStkFlagsOpts(), FrtosTimeoutToStk(), stk::sync::EventFlags::Get(), IsIrqContext(), StkFlagsToFrtos(), and stk::sync::EventFlags::Wait().

Here is the call graph for this function:

◆ xMessageBufferCreate()

MessageBufferHandle_t xMessageBufferCreate	(	size_t	xBufferSizeBytes,
		size_t	xMaxMessageSize )

Create a dynamically allocated message buffer.

Parameters

xBufferSizeBytes	Total storage budget. The implementation derives slot count as floor(xBufferSizeBytes / (AlignBlockSize(xMaxMessageSize) sizeof(envelope))).
xMaxMessageSize	Maximum payload size per message in bytes.

Returns: Handle, or NULL on allocation failure.

Definition at line 4086 of file freertos_stk.cpp.

{
    if ((xBufferSizeBytes == 0U) || (xMaxMessageSize == 0U))
        return nullptr;
 
    const size_t count = MsgBufSlotCount(xBufferSizeBytes, xMaxMessageSize);
 
    if (count == 0U)
        return nullptr;
 
    FrtosMessageBuffer *mb = ObjAlloc<FrtosMessageBuffer>(xMaxMessageSize, count);
 
    if (mb == nullptr)
        return nullptr;
 
    if (!mb->m_pool.IsStorageValid() || !mb->m_eq.IsStorageValid())
    {
        ObjFreeRaw(mb);
        return nullptr;
    }
 
    return static_cast<MessageBufferHandle_t>(mb);
}

References stk::memory::BlockMemoryPool::IsStorageValid(), stk::sync::MessageQueue::IsStorageValid(), FrtosMessageBuffer::m_eq, FrtosMessageBuffer::m_pool, MsgBufSlotCount(), ObjAlloc(), and ObjFreeRaw().

Here is the call graph for this function:

◆ xMessageBufferCreateStatic()

MessageBufferHandle_t xMessageBufferCreateStatic	(	size_t	xMaxMessageSize,
		size_t	xMessageCount,
		uint8_t *	pucMessageBufferStorageArea,
		StaticMessageBuffer_t *	pxStaticMessageBuffer )

Create a statically allocated message buffer (no heap).

Parameters

xMaxMessageSize	Maximum payload size per message.
xMessageCount	Maximum number of in-flight messages.
pucMessageBufferStorageArea	Caller-supplied flat buffer of at least xMessageCount * (AlignBlockSize(xMaxMessageSize) + sizeof(envelope)) bytes.
pxStaticMessageBuffer	Caller-supplied TCB (StaticMessageBuffer_t).

Returns: Handle (always non-NULL if arguments are non-NULL).

Definition at line 4111 of file freertos_stk.cpp.

{
    if ((pucMessageBufferStorageArea == nullptr) ||
        (pxStaticMessageBuffer       == nullptr) ||
        (xMaxMessageSize  == 0U) ||
        (xMessageCount    == 0U))
        return nullptr;
 
    const size_t block_size    = stk::memory::BlockMemoryPool::AlignBlockSize(xMaxMessageSize);
    const size_t storage_size  = xMessageCount * (block_size + FrtosMessageBuffer::ENVELOPE_SIZE);
 
    FrtosMessageBuffer *mb = new (pxStaticMessageBuffer)
        FrtosMessageBuffer(xMaxMessageSize, xMessageCount,
                           pucMessageBufferStorageArea, storage_size);
 
    return static_cast<MessageBufferHandle_t>(mb);
}

References stk::memory::BlockMemoryPool::AlignBlockSize(), and FrtosMessageBuffer::ENVELOPE_SIZE.

Here is the call graph for this function:

◆ xMessageBufferCreateStaticWithCallback()

MessageBufferHandle_t xMessageBufferCreateStaticWithCallback	(	size_t	xMaxMessageSize,
		size_t	xMessageCount,
		uint8_t *	pucMessageBufferStorageArea,
		StaticMessageBuffer_t *	pxStaticMessageBuffer,
		StreamBufferCallbackFunction_t	pxSendCompletedCallback,
		StreamBufferCallbackFunction_t	pxReceiveCompletedCallback )

Create a statically-allocated message buffer with optional send/receive callbacks.

Identical to xMessageBufferCreateStatic() but registers per-instance callbacks. Either callback may be NULL.

Parameters

xMaxMessageSize	Maximum payload size per message in bytes.
xMessageCount	Maximum number of in-flight messages.
pucMessageBufferStorageArea	Caller-supplied flat storage buffer.
pxStaticMessageBuffer	Caller-supplied TCB (StaticMessageBuffer_t).
pxSendCompletedCallback	Called after a message is enqueued (or NULL).
pxReceiveCompletedCallback	Called after a message is dequeued (or NULL).

Returns: Handle, or NULL on invalid arguments.

Definition at line 4178 of file freertos_stk.cpp.

{
    if ((pucMessageBufferStorageArea == nullptr) ||
        (pxStaticMessageBuffer       == nullptr) ||
        (xMaxMessageSize  == 0U) ||
        (xMessageCount    == 0U))
        return nullptr;
 
    static_assert(sizeof(StaticMessageBuffer_t) >= sizeof(FrtosMessageBuffer),
        "Increase STATIC_MESSAGE_BUFFER_TCB_SIZE_WORDS in FreeRTOS.h.");
 
    const size_t block_size   = stk::memory::BlockMemoryPool::AlignBlockSize(xMaxMessageSize);
    const size_t storage_size = xMessageCount * (block_size + FrtosMessageBuffer::ENVELOPE_SIZE);
 
    FrtosMessageBuffer *mb = new (pxStaticMessageBuffer)
        FrtosMessageBuffer(xMaxMessageSize, xMessageCount,
                           pucMessageBufferStorageArea, storage_size,
                           pxSendCompletedCallback, pxReceiveCompletedCallback);
 
    return static_cast<MessageBufferHandle_t>(mb);
}

References stk::memory::BlockMemoryPool::AlignBlockSize(), and FrtosMessageBuffer::ENVELOPE_SIZE.

Here is the call graph for this function:

◆ xMessageBufferCreateWithCallback()

MessageBufferHandle_t xMessageBufferCreateWithCallback	(	size_t	xBufferSizeBytes,
		size_t	xMaxMessageSize,
		StreamBufferCallbackFunction_t	pxSendCompletedCallback,
		StreamBufferCallbackFunction_t	pxReceiveCompletedCallback )

Create a heap-allocated message buffer with optional send/receive callbacks.

Identical to xMessageBufferCreate() but registers per-instance callbacks invoked after a message is successfully enqueued (pxSendCompletedCallback) or dequeued (pxReceiveCompletedCallback). Either callback may be NULL. Callbacks fire outside any critical section, after the transfer completes. The xStreamBuffer argument passed to the callback is the MessageBufferHandle_t cast to StreamBufferHandle_t, matching FreeRTOS convention.

Parameters

xBufferSizeBytes	Total storage budget (slot count derived internally).
xMaxMessageSize	Maximum payload size per message in bytes.
pxSendCompletedCallback	Called after a message is enqueued (or NULL).
pxReceiveCompletedCallback	Called after a message is dequeued (or NULL).

Returns: Handle, or NULL on allocation failure.

Definition at line 4144 of file freertos_stk.cpp.

{
    if ((xBufferSizeBytes == 0U) || (xMaxMessageSize == 0U))
        return nullptr;
 
    const size_t block_size = stk::memory::BlockMemoryPool::AlignBlockSize(xMaxMessageSize);
    const size_t slot_cost  = block_size + FrtosMessageBuffer::ENVELOPE_SIZE;
    const size_t count      = xBufferSizeBytes / slot_cost;
 
    if (count == 0U)
        return nullptr;
 
    FrtosMessageBuffer *mb = ObjAlloc<FrtosMessageBuffer>(
        xMaxMessageSize, count,
                           pxSendCompletedCallback, pxReceiveCompletedCallback);
 
    if (mb == nullptr)
        return nullptr;
 
    // Detect heap failure in the envelope buffer allocation performed by the
    // heap constructor (m_eq is backed by a separately ObjAllocArray'd byte array).
    if (!mb->m_eq.IsStorageValid())
    {
        ObjFreeRaw(mb);
        return nullptr;
    }
 
    return static_cast<MessageBufferHandle_t>(mb);
}

References stk::memory::BlockMemoryPool::AlignBlockSize(), FrtosMessageBuffer::ENVELOPE_SIZE, stk::sync::MessageQueue::IsStorageValid(), FrtosMessageBuffer::m_eq, ObjAlloc(), and ObjFreeRaw().

Here is the call graph for this function:

◆ xMessageBufferIsEmpty()

BaseType_t xMessageBufferIsEmpty ( MessageBufferHandle_t xMessageBuffer )

Return pdTRUE if the message buffer contains no messages.

Note: ISR-safe.

Definition at line 4307 of file freertos_stk.cpp.

{
    if (xMessageBuffer == nullptr)
        return pdTRUE;
 
    return static_cast<FrtosMessageBuffer *>(xMessageBuffer)->m_eq.IsEmpty()
           ? pdTRUE : pdFALSE;
}

References pdFALSE, and pdTRUE.

◆ xMessageBufferIsFull()

BaseType_t xMessageBufferIsFull ( MessageBufferHandle_t xMessageBuffer )

Return pdTRUE if no more messages can be enqueued (pool exhausted).

Note: ISR-safe.

Definition at line 4316 of file freertos_stk.cpp.

{
    if (xMessageBuffer == nullptr)
        return pdTRUE;
 
    return static_cast<FrtosMessageBuffer *>(xMessageBuffer)->m_pool.IsFull()
           ? pdTRUE : pdFALSE;
}

References pdFALSE, and pdTRUE.

◆ xMessageBufferNextLengthBytes()

size_t xMessageBufferNextLengthBytes ( MessageBufferHandle_t xMessageBuffer )

Return the byte length of the next message that would be returned by xMessageBufferReceive(), without removing it from the buffer.

Backed by stk::sync::MessageQueue::TryPeek(), which copies the oldest envelope atomically without consuming it. No dequeue-and-reinsert pair is needed; the queue state is left unchanged in a single ISR-safe operation.

Returns: Length in bytes of the oldest pending message, or 0 if the buffer is empty.

Note: ISR-safe.

Definition at line 4522 of file freertos_stk.cpp.

{
    if (xMessageBuffer == nullptr)
        return 0U;
 
    FrtosMessageBuffer *mb = static_cast<FrtosMessageBuffer *>(xMessageBuffer);
 
    // TryPeek copies the oldest envelope without consuming it.  The internal
    // ScopedCriticalSection makes this ISR-safe; no outer CS is required.
    FrtosMessageBuffer::MsgEnvelope env = { 0U, nullptr };
 
    if (!mb->m_eq.TryPeek(&env))
        return 0U; // buffer is empty — nothing to peek at
 
    return env.len;
}

References FrtosMessageBuffer::MsgEnvelope::len, FrtosMessageBuffer::m_eq, and stk::sync::MessageQueue::TryPeek().

Here is the call graph for this function:

◆ xMessageBufferReceive()

size_t xMessageBufferReceive	(	MessageBufferHandle_t	xMessageBuffer,
		void *	pvRxData,
		size_t	xBufferLengthBytes,
		TickType_t	xTicksToWait )

Receive a message from the message buffer (task context, may block).

Parameters

pvRxData	Destination buffer.
xBufferLengthBytes	Capacity of pvRxData; must be >= the oldest message length.
xTicksToWait	Ticks to wait for a message. portMAX_DELAY blocks indefinitely.

Returns: Number of bytes written to pvRxData, or 0 on timeout / size violation.

Warning: ISR-unsafe. Use xMessageBufferReceiveFromISR() from ISR context.

Definition at line 4264 of file freertos_stk.cpp.

{
    if ((xMessageBuffer == nullptr) || (pvRxData == nullptr) || (xBufferLengthBytes == 0U))
        return 0U;
 
    if (IsIrqContext() && (xTicksToWait != 0U))
        return 0U;
 
    FrtosMessageBuffer *mb = static_cast<FrtosMessageBuffer *>(xMessageBuffer);
 
    // 1. Dequeue the next envelope.
    FrtosMessageBuffer::MsgEnvelope env = { 0U, nullptr };
 
    if (!mb->m_eq.Get(&env, FrtosTimeoutToStk(xTicksToWait)))
        return 0U;
 
    // 2. Validate destination capacity.
    if (xBufferLengthBytes < env.len)
    {
        // Destination too small: re-enqueue the envelope so the message is
        // not lost (best-effort; if re-enqueue also fails the message is lost).
        STK_ASSERT(false); // API contract: pvRxData buffer too small
        mb->m_eq.TryPut(&env);
        return 0U;
    }
 
    // 3. Copy payload out and return the block.
    memcpy(pvRxData, env.blk, env.len);
    mb->m_pool.Free(env.blk);
 
    // Fire receive-complete callback outside any critical section.
    if (mb->m_recv_cb != nullptr)
    {
        BaseType_t woken = pdFALSE;
        mb->m_recv_cb(static_cast<StreamBufferHandle_t>(xMessageBuffer), &woken);
    }
 
    return env.len;
}

References FrtosMessageBuffer::MsgEnvelope::blk, stk::memory::BlockMemoryPool::Free(), FrtosTimeoutToStk(), stk::sync::MessageQueue::Get(), IsIrqContext(), FrtosMessageBuffer::MsgEnvelope::len, FrtosMessageBuffer::m_eq, FrtosMessageBuffer::m_pool, FrtosMessageBuffer::m_recv_cb, pdFALSE, STK_ASSERT, and stk::sync::MessageQueue::TryPut().

Here is the call graph for this function:

◆ xMessageBufferReceiveFromISR()

size_t xMessageBufferReceiveFromISR	(	MessageBufferHandle_t	xMessageBuffer,
		void *	pvRxData,
		size_t	xBufferLengthBytes,
		BaseType_t *	pxHigherPriorityTaskWoken )

Receive a message from the message buffer from ISR context (non-blocking).

Attempts to dequeue one envelope without blocking. If an envelope is available and fits in the destination buffer the payload is copied out and the pool block is freed.

Parameters

pvRxData	Destination buffer.
xBufferLengthBytes	Capacity of pvRxData; must be >= the oldest message length.
pxHigherPriorityTaskWoken	Always set to pdFALSE; STK handles scheduling.

Returns: Number of bytes written to pvRxData, or 0 if empty / destination too small.

Warning: ISR-safe (non-blocking).

Definition at line 4451 of file freertos_stk.cpp.

{
    if (pxHigherPriorityTaskWoken != nullptr)
        *pxHigherPriorityTaskWoken = pdFALSE;
 
    if ((xMessageBuffer == nullptr) || (pvRxData == nullptr) || (xBufferLengthBytes == 0U))
        return 0U;
 
    FrtosMessageBuffer *mb = static_cast<FrtosMessageBuffer *>(xMessageBuffer);
 
    // Step 1: non-blocking dequeue of the oldest envelope.
    FrtosMessageBuffer::MsgEnvelope env = { 0U, nullptr };
    if (!mb->m_eq.TryGet(&env))
        return 0U; // buffer empty
 
    // Step 2: validate destination capacity.
    if (xBufferLengthBytes < env.len)
    {
        // Destination too small: put the envelope back at the front so the
        // message is not lost.  TryPutFront retreats the tail pointer under
        // its own CS — identical to Get never having happened.
        STK_ASSERT(false); // API contract: pvRxData buffer too small
        mb->m_eq.TryPutFront(&env);
        return 0U;
    }
 
    // Step 3: copy payload out and release pool block.
    memcpy(pvRxData, env.blk, env.len);
    mb->m_pool.Free(env.blk);
 
    // Fire receive-complete callback outside any critical section.
    // pxHigherPriorityTaskWoken is always pdFALSE per STK convention.
    if (mb->m_recv_cb != nullptr)
    {
        BaseType_t woken = pdFALSE;
        mb->m_recv_cb(static_cast<StreamBufferHandle_t>(xMessageBuffer), &woken);
    }
 
    return env.len;
}

References FrtosMessageBuffer::MsgEnvelope::blk, stk::memory::BlockMemoryPool::Free(), FrtosMessageBuffer::MsgEnvelope::len, FrtosMessageBuffer::m_eq, FrtosMessageBuffer::m_pool, FrtosMessageBuffer::m_recv_cb, pdFALSE, STK_ASSERT, stk::sync::MessageQueue::TryGet(), and stk::sync::MessageQueue::TryPutFront().

Here is the call graph for this function:

◆ xMessageBufferReset()

BaseType_t xMessageBufferReset ( MessageBufferHandle_t xMessageBuffer )

Discard all pending messages, return all blocks to the pool, and reset the envelope queue to the empty state (task context).

Returns: pdPASS always.

Warning: ISR-safe. Prefer xMessageBufferResetFromISR() from interrupt context to properly signal pxHigherPriorityTaskWoken.

Definition at line 4334 of file freertos_stk.cpp.

{
    if (xMessageBuffer == nullptr)
        return pdFAIL;
 
    FrtosMessageBuffer *mb = static_cast<FrtosMessageBuffer *>(xMessageBuffer);
 
    // Drain all pending envelopes and return their blocks to the pool.
    FrtosMessageBuffer::MsgEnvelope env = { 0U, nullptr };
 
    while (mb->m_eq.TryGet(&env))
    {
        if (env.blk != nullptr)
            mb->m_pool.Free(env.blk);
    }
 
    // Reset the envelope queue (wakes any blocked senders).
    mb->m_eq.Reset();
 
    return pdPASS;
}

References FrtosMessageBuffer::MsgEnvelope::blk, stk::memory::BlockMemoryPool::Free(), FrtosMessageBuffer::m_eq, FrtosMessageBuffer::m_pool, pdFAIL, pdPASS, stk::sync::MessageQueue::Reset(), and stk::sync::MessageQueue::TryGet().

Here is the call graph for this function:

◆ xMessageBufferResetFromISR()

BaseType_t xMessageBufferResetFromISR	(	MessageBufferHandle_t	xMessageBuffer,
		BaseType_t *	pxHigherPriorityTaskWoken )

Discard all pending messages and reset the buffer from ISR context.

Drains every pending envelope, frees its pool block, then resets the envelope queue. Wakes any task blocked in xMessageBufferSend() that was waiting for a free slot.

Parameters

pxHigherPriorityTaskWoken Always set to pdFALSE; STK handles scheduling.

Returns: pdPASS always.

Warning: ISR-safe.

Definition at line 4495 of file freertos_stk.cpp.

{
    if (pxHigherPriorityTaskWoken != nullptr)
        *pxHigherPriorityTaskWoken = pdFALSE;
 
    if (xMessageBuffer == nullptr)
        return pdFAIL;
 
    FrtosMessageBuffer *mb = static_cast<FrtosMessageBuffer *>(xMessageBuffer);
 
    // Drain all pending envelopes, returning every pool block before resetting
    // the queue.  All three operations are ISR-safe (ScopedCriticalSection).
    FrtosMessageBuffer::MsgEnvelope env = { 0U, nullptr };
 
    while (mb->m_eq.TryGet(&env))
    {
        if (env.blk != nullptr)
            mb->m_pool.Free(env.blk);
    }
 
    // Reset the envelope queue; wakes any sender blocked on a full pool.
    mb->m_eq.Reset();
 
    return pdPASS;
}

References FrtosMessageBuffer::MsgEnvelope::blk, stk::memory::BlockMemoryPool::Free(), FrtosMessageBuffer::m_eq, FrtosMessageBuffer::m_pool, pdFAIL, pdFALSE, pdPASS, stk::sync::MessageQueue::Reset(), and stk::sync::MessageQueue::TryGet().

Here is the call graph for this function:

◆ xMessageBufferSend()

size_t xMessageBufferSend	(	MessageBufferHandle_t	xMessageBuffer,
		const void *	pvTxData,
		size_t	xDataLengthBytes,
		TickType_t	xTicksToWait )

Send a message into the message buffer (task context, may block).

Parameters

pvTxData	Pointer to message payload.
xDataLengthBytes	Payload size in bytes (must be <= max message size).
xTicksToWait	Ticks to wait for a free block + envelope slot. portMAX_DELAY blocks indefinitely.

Returns: xDataLengthBytes on success, 0 on timeout or size violation.

Warning: ISR-unsafe. Use xMessageBufferSendFromISR() from ISR context.

Definition at line 4216 of file freertos_stk.cpp.

{
    if ((xMessageBuffer == nullptr) || (pvTxData == nullptr) || (xDataLengthBytes == 0U))
        return 0U;
 
    FrtosMessageBuffer *mb = static_cast<FrtosMessageBuffer *>(xMessageBuffer);
 
    if (xDataLengthBytes > mb->m_max_msg_size)
    {
        STK_ASSERT(false); // API contract: message too large for this buffer
        return 0U;
    }
 
    const stk::Timeout stk_timeout = FrtosTimeoutToStk(xTicksToWait);
 
    // 1. Acquire a payload block (blocks until one is free or timeout).
    void *blk = mb->m_pool.TimedAlloc(stk_timeout);
    if (blk == nullptr)
        return 0U;
 
    // 2. Copy payload into the block.
    memcpy(blk, pvTxData, xDataLengthBytes);
 
    // 3. Enqueue the envelope (should always succeed: pool and eq are 1:1,
    //    but guard with NO_WAIT to avoid deadlock if they desync).
    FrtosMessageBuffer::MsgEnvelope env = { xDataLengthBytes, blk };
 
    if (!mb->m_eq.Put(&env, stk::NO_WAIT))
    {
        // Envelope queue unexpectedly full — return block and report failure.
        STK_ASSERT(false);
        mb->m_pool.Free(blk);
        return 0U;
    }
 
    // Fire send-complete callback outside any critical section.
    if (mb->m_send_cb != nullptr)
    {
        BaseType_t woken = pdFALSE;
        mb->m_send_cb(static_cast<StreamBufferHandle_t>(xMessageBuffer), &woken);
    }
 
    return xDataLengthBytes;
}

References stk::memory::BlockMemoryPool::Free(), FrtosTimeoutToStk(), FrtosMessageBuffer::m_eq, FrtosMessageBuffer::m_max_msg_size, FrtosMessageBuffer::m_pool, FrtosMessageBuffer::m_send_cb, stk::NO_WAIT, pdFALSE, stk::sync::MessageQueue::Put(), STK_ASSERT, and stk::memory::BlockMemoryPool::TimedAlloc().

Here is the call graph for this function:

◆ xMessageBufferSendFromISR()

size_t xMessageBufferSendFromISR	(	MessageBufferHandle_t	xMessageBuffer,
		const void *	pvTxData,
		size_t	xDataLengthBytes,
		BaseType_t *	pxHigherPriorityTaskWoken )

Send a message into the message buffer from ISR context (non-blocking).

Attempts a single non-blocking pool allocation followed by a non-blocking envelope enqueue. Returns 0 immediately if either resource is unavailable.

Parameters

pvTxData	Pointer to message payload.
xDataLengthBytes	Payload size (must be <= max message size).
pxHigherPriorityTaskWoken	Always set to pdFALSE; STK handles scheduling.

Returns: xDataLengthBytes on success, 0 if the buffer was full or arguments invalid.

Warning: ISR-safe (non-blocking). Must not be called with a non-zero timeout.

Definition at line 4402 of file freertos_stk.cpp.

{
    if (pxHigherPriorityTaskWoken != nullptr)
        *pxHigherPriorityTaskWoken = pdFALSE;
 
    if ((xMessageBuffer == nullptr) || (pvTxData == nullptr) || (xDataLengthBytes == 0U))
        return 0U;
 
    FrtosMessageBuffer *mb = static_cast<FrtosMessageBuffer *>(xMessageBuffer);
 
    if (xDataLengthBytes > mb->m_max_msg_size)
    {
        STK_ASSERT(false); // API contract: message exceeds max size
        return 0U;
    }
 
    // Step 1: non-blocking pool allocation.
    void *blk = mb->m_pool.TimedAlloc(stk::NO_WAIT);
    if (blk == nullptr)
        return 0U; // pool full — no block consumed, nothing to free
 
    // Step 2: copy payload.
    memcpy(blk, pvTxData, xDataLengthBytes);
 
    // Step 3: non-blocking enqueue.
    FrtosMessageBuffer::MsgEnvelope env = { xDataLengthBytes, blk };
    if (!mb->m_eq.TryPut(&env))
    {
        // Pool and eq are 1:1, so this should never happen.  Defensively free
        // the block to avoid a pool leak and report failure.
        STK_ASSERT(false);
        mb->m_pool.Free(blk);
        return 0U;
    }
 
    // Fire send-complete callback outside any critical section.
    // pxHigherPriorityTaskWoken is always pdFALSE per STK convention.
    if (mb->m_send_cb != nullptr)
    {
        BaseType_t woken = pdFALSE;
        mb->m_send_cb(static_cast<StreamBufferHandle_t>(xMessageBuffer), &woken);
    }
 
    return xDataLengthBytes;
}

References stk::memory::BlockMemoryPool::Free(), FrtosMessageBuffer::m_eq, FrtosMessageBuffer::m_max_msg_size, FrtosMessageBuffer::m_pool, FrtosMessageBuffer::m_send_cb, stk::NO_WAIT, pdFALSE, STK_ASSERT, stk::memory::BlockMemoryPool::TimedAlloc(), and stk::sync::MessageQueue::TryPut().

Here is the call graph for this function:

◆ xMessageBufferSpacesAvailable()

size_t xMessageBufferSpacesAvailable ( MessageBufferHandle_t xMessageBuffer )

Return the number of free envelope slots available for sending.

Note: ISR-safe.

Definition at line 4325 of file freertos_stk.cpp.

{
    if (xMessageBuffer == nullptr)
        return 0U;
 
    // Free pool blocks == available envelope slots (they are 1:1).
    return static_cast<FrtosMessageBuffer *>(xMessageBuffer)->m_pool.GetFreeCount();
}

◆ xPortGetFreeHeapSize()

size_t xPortGetFreeHeapSize ( void )

Return the number of bytes currently available in the heap.

This is a point-in-time snapshot of stk::memory::MemoryAllocator::Stats::GetAvailable() and may not account for in-flight allocations if called from a non-critical context.

Returns: Free bytes remaining.

Definition at line 223 of file freertos_stk.cpp.

{
    return s_MemStats.GetAvailable();
}

References s_MemStats.

◆ xPortGetMinimumEverFreeHeapSize()

size_t xPortGetMinimumEverFreeHeapSize ( void )

Return the minimum number of free heap bytes recorded since system start.

The watermark is updated inside MemoryAllocator::Allocate() after every successful allocation, so it always reflects the worst-case heap pressure observed up to the point of the call.

Returns: Minimum ever free bytes (heap watermark).

Definition at line 228 of file freertos_stk.cpp.

{
    return s_MemStats.min_ever_free;
}

References s_MemStats.

◆ xQueueAddToSet()

BaseType_t xQueueAddToSet	(	QueueSetMemberHandle_t	xQueueOrSemaphore,
		QueueSetHandle_t	xQueueSet )

Register a queue or binary/counting semaphore as a member of a queue set.

The member must be empty at the time it is added. Mutexes are not permitted. A member may belong to at most one set at a time.

Parameters

xQueueOrSemaphore	Handle of the queue or semaphore to add.
xQueueSet	Handle of the target queue set.

Returns: pdPASS on success, pdFAIL if any precondition is violated.

Definition at line 2082 of file freertos_stk.cpp.

{
    if ((xQueueOrSemaphore == nullptr) || (xQueueSet == nullptr))
        return pdFAIL;
 
    FrtosQueueSet *qs = static_cast<FrtosQueueSet *>(xQueueSet);
 
    // Type discrimination between FrtosQueue and FrtosSemaphore via
    // GetSemKindFromHandle(): returns SemKind::None for queues (and any
    // unrecognised handle), SemKind::Counting or SemKind::Mutex for semaphores.
    {
        const SemKind kind = GetSemKindFromHandle(xQueueOrSemaphore);
 
        if (kind != SemKind::None)
        {
            // Semaphore or mutex path.
            FrtosSemaphore *s = static_cast<FrtosSemaphore *>(xQueueOrSemaphore);
 
            // FreeRTOS API contract: mutexes cannot be queue set members.
            if (s->m_kind == SemKind::Mutex)
                return pdFAIL;
 
            STK_ASSERT(s->m_set == nullptr); // must not already belong to a set
            if (s->m_set != nullptr)
                return pdFAIL;
 
            STK_ASSERT(s->m_sem->GetCount() == 0U); // must be empty when added
            if (s->m_sem->GetCount() != 0U)
                return pdFAIL;
 
            s->m_set = qs;
        }
        else
        {
            // Queue path.
            FrtosQueue *q = static_cast<FrtosQueue *>(xQueueOrSemaphore);
 
            STK_ASSERT(q->m_set == nullptr); // must not already belong to a set
            if (q->m_set != nullptr)
                return pdFAIL;
 
            STK_ASSERT(q->m_mq.IsEmpty()); // must be empty when added
            if (!q->m_mq.IsEmpty())
                return pdFAIL;
 
            q->m_set = qs;
        }
    }
 
    return pdPASS;
}

References stk::sync::Semaphore::GetCount(), GetSemKindFromHandle(), stk::sync::MessageQueue::IsEmpty(), FrtosSemaphore::m_kind, FrtosQueue::m_mq, FrtosSemaphore::m_sem, FrtosQueue::m_set, FrtosSemaphore::m_set, Mutex, None, pdFAIL, pdPASS, and STK_ASSERT.

Here is the call graph for this function:

◆ xQueueCreate()

QueueHandle_t xQueueCreate	(	UBaseType_t	uxQueueLength,
		UBaseType_t	uxItemSize )

Create a queue capable of holding uxQueueLength items of uxItemSize bytes.

Returns: Queue handle, or NULL on allocation failure.

Definition at line 1640 of file freertos_stk.cpp.

{
    if (IsIrqContext() || (uxQueueLength == 0U) || (uxItemSize == 0U))
        return nullptr;
 
    if (uxQueueLength > stk::sync::MessageQueue::CAPACITY_MAX)
        return nullptr;
 
    FrtosQueue *q = ObjAlloc<FrtosQueue>(
        static_cast<uint32_t>(uxQueueLength),
        static_cast<uint32_t>(uxItemSize),
        nullptr /* name */);
 
    if (q == nullptr)
        return nullptr;
 
    if (!q->m_mq.IsStorageValid())
    {
        ObjFree(q);
        return nullptr;
    }
 
    return static_cast<QueueHandle_t>(q);
}

References stk::sync::MessageQueue::CAPACITY_MAX, IsIrqContext(), stk::sync::MessageQueue::IsStorageValid(), FrtosQueue::m_mq, ObjAlloc(), and ObjFree().

Here is the call graph for this function:

◆ xQueueCreateSet()

QueueSetHandle_t xQueueCreateSet ( UBaseType_t uxEventQueueLength )

Create a queue set that can supervise up to uxEventQueueLength simultaneous item-available notifications from its member queues and semaphores.

Parameters

uxEventQueueLength Total event capacity. Must be >= the sum of the capacities (uxQueueLength or max_count) of all queues and semaphores that will be added.

Returns: Queue set handle, or NULL on failure.

Definition at line 2063 of file freertos_stk.cpp.

{
    if (IsIrqContext() || (uxEventQueueLength == 0U))
        return nullptr;
 
    if (uxEventQueueLength > stk::sync::MessageQueue::CAPACITY_MAX)
        return nullptr;
 
    FrtosQueueSet *qs = ObjAlloc<FrtosQueueSet>(uxEventQueueLength);
 
    if ((qs == nullptr) || !qs->IsValid())
    {
        ObjFree(qs);
        return nullptr;
    }
 
    return static_cast<QueueSetHandle_t>(qs);
}

References stk::sync::MessageQueue::CAPACITY_MAX, IsIrqContext(), FrtosQueueSet::IsValid(), ObjAlloc(), and ObjFree().

Here is the call graph for this function:

◆ xQueueCreateStatic()

QueueHandle_t xQueueCreateStatic	(	UBaseType_t	uxQueueLength,
		UBaseType_t	uxItemSize,
		uint8_t *	pucQueueStorage,
		StaticQueue_t *	pxStaticQueue )

Create a queue using caller-supplied storage — no heap allocation.

Parameters

uxQueueLength	Maximum number of items the queue can hold (>= 1).
uxItemSize	Size of each item in bytes (>= 1).
pucQueueStorage	Caller-allocated data buffer of at least uxQueueLength * uxItemSize bytes. Must remain valid for the entire lifetime of the queue.
pxStaticQueue	Caller-allocated queue control block (StaticQueue_t). Must remain valid for the entire lifetime of the queue.

Returns: Queue handle. Never NULL if all pointer arguments are non-NULL and uxQueueLength / uxItemSize are within range.

Definition at line 1666 of file freertos_stk.cpp.

{
    // All pointer arguments are mandatory for static allocation.
    if ((pucQueueStorage == nullptr) || (pxStaticQueue == nullptr))
        return nullptr;
 
    if (IsIrqContext() || (uxQueueLength == 0U) || (uxItemSize == 0U))
        return nullptr;
 
    if (uxQueueLength > stk::sync::MessageQueue::CAPACITY_MAX)
        return nullptr;
 
    // Placement-new the FrtosQueue control block into the caller-supplied buffer.
    // Static assert guards against the buffer being too small.
    static_assert(sizeof(StaticQueue_t) >= sizeof(FrtosQueue),
        "StaticQueue_t is too small to hold FrtosQueue. "
        "Increase STATIC_QUEUE_TCB_SIZE_WORDS in freertos_stk.h.");
 
    // Use the external-storage FrtosQueue constructor: no heap allocation for
    // either the control block or the data buffer.
    FrtosQueue *q = new (pxStaticQueue) FrtosQueue(
        static_cast<uint32_t>(uxQueueLength),
        static_cast<uint32_t>(uxItemSize),
        nullptr /* name */,
        pucQueueStorage);
 
    q->m_cb_owned = false; // caller owns the memory; destructor must not delete
 
    return static_cast<QueueHandle_t>(q);
}

References stk::sync::MessageQueue::CAPACITY_MAX, IsIrqContext(), and FrtosQueue::m_cb_owned.

Here is the call graph for this function:

◆ xQueueGetMutexHolder()

TaskHandle_t xQueueGetMutexHolder ( QueueHandle_t xQueue )

Return the handle of the task that currently holds a mutex-semaphore when that semaphore is referenced by a QueueHandle_t alias.

In the FreeRTOS reference implementation mutex semaphores are built on top of the internal queue structure, so xQueueGetMutexHolder() and xSemaphoreGetMutexHolder() are the same function with different handle types. In this STK wrapper the two object types are separate structs:

FrtosQueue — backed by stk::sync::MessageQueue; has no owner field.
FrtosSemaphore — backed by stk::sync::Semaphore (counting) or stk::sync::Mutex (mutex kind). Only the Mutex kind carries an owner and supports STK priority inheritance.

This function accepts a QueueHandle_t and uses the same one-byte type-discriminant (offset 0: SemKind ≤ 1 → semaphore, otherwise → queue) already used by the Queue Set implementation to decide which path to take:

If the handle actually points to a FrtosSemaphore with SemKind::Mutex, the call is forwarded to xSemaphoreGetMutexHolder() and the owning task handle (or NULL if unlocked) is returned.
For a plain FrtosQueue handle, or for a counting/binary semaphore handle, NULL is returned — the owner concept does not apply.

Parameters

xQueue Handle typed as QueueHandle_t. May point to a mutex semaphore in application code that uses the raw queue handle alias (e.g. FreeRTOS+TCP internal usage).

Returns: Handle of the owning task, or NULL if unlocked / not a mutex.

Warning: Not ISR-safe. Use xQueueGetMutexHolderFromISR() from ISR context.

Note: Requires configUSE_MUTEXES == 1.

Definition at line 2006 of file freertos_stk.cpp.

{
    // Resolve to FrtosSemaphore (Mutex kind) or bail out.
    FrtosSemaphore *s = QueueHandleAsMutex(xQueue);
    if (s == nullptr)
        return nullptr;
 
    // Delegate to the semaphore variant which acquires a ScopedCriticalSection
    // to make the TId snapshot consistent with concurrent Unlock() calls.
    return xSemaphoreGetMutexHolder(static_cast<SemaphoreHandle_t>(xQueue));
}

References QueueHandleAsMutex(), and xSemaphoreGetMutexHolder().

Here is the call graph for this function:

◆ xQueueGetMutexHolderFromISR()

TaskHandle_t xQueueGetMutexHolderFromISR ( QueueHandle_t xQueue )

ISR-safe variant of xQueueGetMutexHolder().

Reads the mutex owner field with a single pointer-sized load, which is naturally atomic on all supported STK architectures (Cortex-M and equivalents) without requiring an additional critical section.

Parameters

xQueue Handle typed as QueueHandle_t.

Returns: Handle of the owning task, or NULL if unlocked / not a mutex.

Warning: ISR-safe.

Note: Requires configUSE_MUTEXES == 1.

Definition at line 2018 of file freertos_stk.cpp.

{
    // Resolve to FrtosSemaphore (Mutex kind) or bail out.
    FrtosSemaphore *s = QueueHandleAsMutex(xQueue);
    if (s == nullptr)
        return nullptr;
 
    // Delegate to the ISR-safe semaphore variant which reads GetOwner() via a
    // single pointer-sized atomic load — no additional critical section needed.
    return xSemaphoreGetMutexHolderFromISR(static_cast<SemaphoreHandle_t>(xQueue));
}

References QueueHandleAsMutex(), and xSemaphoreGetMutexHolderFromISR().

Here is the call graph for this function:

◆ xQueueIsQueueEmptyFromISR()

BaseType_t xQueueIsQueueEmptyFromISR ( const QueueHandle_t xQueue )

Query whether a queue is empty from ISR context.

Note: ISR-safe on targets where a size_t-aligned read is atomic (per stk::sync::MessageQueue::IsEmpty() contract).

Returns: pdTRUE if the queue contains no items, pdFALSE otherwise.

Definition at line 1936 of file freertos_stk.cpp.

{
    // IsEmpty() reads m_count which is size_t-aligned; ISR-safe on targets
    // where such a read is atomic (per stk::sync::MessageQueue contract).
    if (xQueue == nullptr)
        return pdTRUE;
 
    return static_cast<const FrtosQueue *>(xQueue)->m_mq.IsEmpty() ? pdTRUE : pdFALSE;
}

References pdFALSE, and pdTRUE.

◆ xQueueIsQueueFullFromISR()

BaseType_t xQueueIsQueueFullFromISR ( const QueueHandle_t xQueue )

Query whether a queue is full from ISR context.

Note: ISR-safe on targets where a size_t-aligned read is atomic (per stk::sync::MessageQueue::IsFull() contract).

Returns: pdTRUE if the queue holds capacity items, pdFALSE otherwise.

Definition at line 1946 of file freertos_stk.cpp.

{
    // IsFull() reads m_count and m_capacity; both are size_t-aligned and
    // m_capacity is const, so the read is ISR-safe on naturally-atomic targets
    // (per stk::sync::MessageQueue contract).
    if (xQueue == nullptr)
        return pdTRUE;
 
    return static_cast<const FrtosQueue *>(xQueue)->m_mq.IsFull() ? pdTRUE : pdFALSE;
}

References pdFALSE, and pdTRUE.

◆ xQueueOverwrite()

BaseType_t xQueueOverwrite	(	QueueHandle_t	xQueue,
		const void *	pvItemToQueue )

Overwrite the value stored in a queue of length 1 (mailbox pattern). If the queue is already full the existing item is discarded before writing.

Note: Intended for length-1 queues only; behaviour is undefined for longer queues.

Returns: pdPASS always (the write always succeeds after the discard).

Definition at line 1833 of file freertos_stk.cpp.

{
    // Mailbox (length-1 queue) overwrite pattern.
    // Reset() atomically discards any existing item and wakes blocked producers,
    // guaranteeing TryPut() will always find a free slot immediately after.
    if ((xQueue == nullptr) || (pvItemToQueue == nullptr))
        return pdFAIL;
 
    FrtosQueue *q = static_cast<FrtosQueue *>(xQueue);
    q->m_mq.Reset();
    q->m_mq.TryPut(pvItemToQueue);
    QueueSetNotify(xQueue, q);
 
    return pdPASS;
}

References FrtosQueue::m_mq, pdFAIL, pdPASS, QueueSetNotify(), stk::sync::MessageQueue::Reset(), and stk::sync::MessageQueue::TryPut().

Here is the call graph for this function:

◆ xQueueOverwriteFromISR()

BaseType_t xQueueOverwriteFromISR	(	QueueHandle_t	xQueue,
		const void *	pvItemToQueue,
		BaseType_t *	pxHigherPriorityTaskWoken )

Overwrite the value stored in a length-1 queue from ISR context.

Parameters

pxHigherPriorityTaskWoken Set pdTRUE if a context switch is needed.

Returns: pdPASS always.

Definition at line 1849 of file freertos_stk.cpp.

{
    // ISR-safe variant of xQueueOverwrite.  Reset() and TryPut() are both
    // ISR-safe per the STK MessageQueue contract.
    if ((xQueue == nullptr) || (pvItemToQueue == nullptr))
        return pdFAIL;
 
    FrtosQueue *q = static_cast<FrtosQueue *>(xQueue);
    q->m_mq.Reset();
    q->m_mq.TryPut(pvItemToQueue);
    QueueSetNotify(xQueue, q);
 
    if (pxHigherPriorityTaskWoken != nullptr)
        *pxHigherPriorityTaskWoken = pdFALSE;
 
    return pdPASS;
}

References FrtosQueue::m_mq, pdFAIL, pdFALSE, pdPASS, QueueSetNotify(), stk::sync::MessageQueue::Reset(), and stk::sync::MessageQueue::TryPut().

Here is the call graph for this function:

◆ xQueuePeek()

BaseType_t xQueuePeek	(	QueueHandle_t	xQueue,
		void *	pvBuffer,
		TickType_t	xTicksToWait )

Peek at the front item without removing it (blocking).

Copies the oldest item into pvBuffer without consuming it, so a subsequent xQueueReceive() will return the same item. The operation is fully atomic — backed by stk::sync::MessageQueue::Peek() which holds an internal critical section for the duration of the copy.

Parameters

xTicksToWait Ticks to wait if the queue is empty. portMAX_DELAY waits indefinitely.

Returns: pdTRUE if an item was peeked, pdFALSE on timeout.

Warning: ISR-safe only with xTicksToWait = 0 (portNO_WAIT). Use xQueuePeekFromISR() for non-blocking ISR access.

Definition at line 1767 of file freertos_stk.cpp.

{
    // Delegates to Peek(), which copies the oldest message without consuming
    // it.  The operation is fully atomic and preserves queue ordering — no
    // Get + Put-back workaround required.
    if ((xQueue == nullptr) || (pvBuffer == nullptr))
        return pdFAIL;
 
    if (IsIrqContext() && (xTicksToWait != 0U))
        return pdFAIL;
 
    return static_cast<FrtosQueue *>(xQueue)->m_mq.Peek(
               pvBuffer, FrtosTimeoutToStk(xTicksToWait))
           ? pdPASS : pdFAIL;
}

References FrtosTimeoutToStk(), IsIrqContext(), pdFAIL, and pdPASS.

Here is the call graph for this function:

◆ xQueuePeekFromISR()

BaseType_t xQueuePeekFromISR	(	QueueHandle_t	xQueue,
		void *	pvBuffer )

Peek at the front item from ISR context without removing it (non-blocking).

Copies the oldest item into pvBuffer atomically without consuming it, backed by stk::sync::MessageQueue::TryPeek() which is ISR-safe.

Returns: pdTRUE if an item was available and peeked, pdFALSE if the queue was empty.

Warning: ISR-safe.

Definition at line 1785 of file freertos_stk.cpp.

{
    // Delegates to TryPeek() (= Peek(NO_WAIT)), which is ISR-safe and copies
    // the oldest message atomically without removing it.
    if ((xQueue == nullptr) || (pvBuffer == nullptr))
        return pdFAIL;
 
    return static_cast<FrtosQueue *>(xQueue)->m_mq.TryPeek(pvBuffer) ? pdPASS : pdFAIL;
}

References pdFAIL, and pdPASS.

◆ xQueueReceive()

BaseType_t xQueueReceive	(	QueueHandle_t	xQueue,
		void *	pvBuffer,
		TickType_t	xTicksToWait )

Receive (dequeue) an item from a queue (blocking).

Returns: pdTRUE on success, pdFALSE on timeout.

Definition at line 1753 of file freertos_stk.cpp.

{
    if ((xQueue == nullptr) || (pvBuffer == nullptr))
        return pdFAIL;
 
    if (IsIrqContext() && (xTicksToWait != 0U))
        return pdFAIL;
 
    return static_cast<FrtosQueue *>(xQueue)->m_mq.Get(pvBuffer, FrtosTimeoutToStk(xTicksToWait))
       ? pdPASS : pdFAIL;
}

References FrtosTimeoutToStk(), IsIrqContext(), pdFAIL, and pdPASS.

Here is the call graph for this function:

◆ xQueueReceiveFromISR()

BaseType_t xQueueReceiveFromISR	(	QueueHandle_t	xQueue,
		void *	pvBuffer,
		BaseType_t *	pxHigherPriorityTaskWoken )

Receive an item from ISR context (non-blocking).

Parameters

pxHigherPriorityTaskWoken Set pdTRUE if a context switch is needed.

Returns: pdTRUE if received, pdFALSE if the queue was empty.

Definition at line 1891 of file freertos_stk.cpp.

{
    if ((xQueue == nullptr) || (pvBuffer == nullptr))
        return pdFAIL;
 
    bool ok = static_cast<FrtosQueue *>(xQueue)->m_mq.TryGet(pvBuffer);
 
    if (pxHigherPriorityTaskWoken != nullptr)
        *pxHigherPriorityTaskWoken = pdFALSE;
 
    return ok ? pdPASS : pdFAIL;
}

References pdFAIL, pdFALSE, and pdPASS.

◆ xQueueRemoveFromSet()

BaseType_t xQueueRemoveFromSet	(	QueueSetMemberHandle_t	xQueueOrSemaphore,
		QueueSetHandle_t	xQueueSet )

Unregister a queue or semaphore from a queue set.

The member must be empty at the time it is removed.

Parameters

xQueueOrSemaphore	Handle of the queue or semaphore to remove.
xQueueSet	Handle of the queue set it currently belongs to.

Returns: pdPASS on success, pdFAIL if the member does not belong to this set or is not empty.

Definition at line 2135 of file freertos_stk.cpp.

{
    if ((xQueueOrSemaphore == nullptr) || (xQueueSet == nullptr))
        return pdFAIL;
 
    {
        const SemKind kind = GetSemKindFromHandle(xQueueOrSemaphore);
 
        if (kind != SemKind::None)
        {
            FrtosSemaphore *s = static_cast<FrtosSemaphore *>(xQueueOrSemaphore);
 
            // API contract: member must belong to this specific set.
            STK_ASSERT(s->m_set == static_cast<FrtosQueueSet *>(xQueueSet));
            if (s->m_set != static_cast<FrtosQueueSet *>(xQueueSet))
                return pdFAIL;
 
            // API contract: semaphore must be empty when removed.
            STK_ASSERT(s->m_sem->GetCount() == 0U);
            if (s->m_sem->GetCount() != 0U)
                return pdFAIL;
 
            s->m_set = nullptr;
        }
        else
        {
            FrtosQueue *q = static_cast<FrtosQueue *>(xQueueOrSemaphore);
 
            STK_ASSERT(q->m_set == static_cast<FrtosQueueSet *>(xQueueSet));
            if (q->m_set != static_cast<FrtosQueueSet *>(xQueueSet))
                return pdFAIL;
 
            // API contract: queue must be empty when removed.
            STK_ASSERT(q->m_mq.IsEmpty());
            if (!q->m_mq.IsEmpty())
                return pdFAIL;
 
            q->m_set = nullptr;
        }
    }
 
    return pdPASS;
}

References stk::sync::Semaphore::GetCount(), GetSemKindFromHandle(), stk::sync::MessageQueue::IsEmpty(), FrtosQueue::m_mq, FrtosSemaphore::m_sem, FrtosQueue::m_set, FrtosSemaphore::m_set, None, pdFAIL, pdPASS, and STK_ASSERT.

Here is the call graph for this function:

◆ xQueueReset()

BaseType_t xQueueReset ( QueueHandle_t xQueue )

Reset a queue to the empty state, discarding all pending items.

Returns: pdPASS.

Definition at line 1824 of file freertos_stk.cpp.

{
    if (xQueue == nullptr)
        return pdFAIL;
 
    static_cast<FrtosQueue *>(xQueue)->m_mq.Reset();
    return pdPASS;
}

References pdFAIL, and pdPASS.

◆ xQueueSelectFromSet()

QueueSetMemberHandle_t xQueueSelectFromSet	(	QueueSetHandle_t	xQueueSet,
		TickType_t	xTicksToWait )

Block until any member of the queue set receives an item, then return the handle of the member that fired.

After xQueueSelectFromSet() returns a non-NULL handle, the caller must call xQueueReceive() or xSemaphoreTake() on that handle to actually consume the item. The set only unblocks once per item deposited; if multiple items arrive before the caller drains them, xQueueSelectFromSet() will return the same member handle multiple times.

Parameters

xQueueSet	Handle of the queue set to wait on.
xTicksToWait	Maximum time to wait. portMAX_DELAY = wait forever, 0 = non-blocking poll.

Returns: Handle of the member that has an item available, or NULL on timeout.

Warning: ISR-safe only with xTicksToWait = 0.

Definition at line 2180 of file freertos_stk.cpp.

{
    if (xQueueSet == nullptr)
        return nullptr;
 
    if (IsIrqContext() && (xTicksToWait != 0U))
        return nullptr;
 
    FrtosQueueSet *qs = static_cast<FrtosQueueSet *>(xQueueSet);
 
    // Block until a member handle arrives in the token FIFO or timeout fires.
    void *handle = nullptr;
    if (!qs->m_token_mq->Get(&handle, FrtosTimeoutToStk(xTicksToWait)))
        return nullptr; // timeout
 
    return static_cast<QueueSetMemberHandle_t>(handle);
}

References FrtosTimeoutToStk(), stk::sync::MessageQueue::Get(), IsIrqContext(), and FrtosQueueSet::m_token_mq.

Here is the call graph for this function:

◆ xQueueSelectFromSetFromISR()

QueueSetMemberHandle_t xQueueSelectFromSetFromISR ( QueueSetHandle_t xQueueSet )

Non-blocking ISR-safe variant of xQueueSelectFromSet.

Returns immediately with the handle of a ready member, or NULL if no member currently has an item available.

Parameters

xQueueSet Handle of the queue set to poll.

Returns: Handle of a ready member, or NULL if no member is ready.

Note: ISR-safe.

Definition at line 2199 of file freertos_stk.cpp.

{
    if (xQueueSet == nullptr)
        return nullptr;
 
    FrtosQueueSet *qs = static_cast<FrtosQueueSet *>(xQueueSet);
 
    // Non-blocking: TryGet() is ISR-safe per the STK MessageQueue contract.
    void *handle = nullptr;
    if (!qs->m_token_mq->TryGet(&handle))
        return nullptr; // set is empty
 
    return static_cast<QueueSetMemberHandle_t>(handle);
}

References FrtosQueueSet::m_token_mq, and stk::sync::MessageQueue::TryGet().

Here is the call graph for this function:

◆ xQueueSend()

BaseType_t xQueueSend	(	QueueHandle_t	xQueue,
		const void *	pvItemToQueue,
		TickType_t	xTicksToWait )

Post an item to the back of a queue (blocking).

Parameters

xTicksToWait Ticks to wait if full. portMAX_DELAY = wait forever.

Returns: pdTRUE on success, pdFALSE on timeout.

Definition at line 1708 of file freertos_stk.cpp.

{
    if ((xQueue == nullptr) || (pvItemToQueue == nullptr))
        return pdFAIL;
 
    if (IsIrqContext() && (xTicksToWait != 0U))
        return pdFAIL;
 
    FrtosQueue *q = static_cast<FrtosQueue *>(xQueue);
 
    if (!q->m_mq.Put(pvItemToQueue, FrtosTimeoutToStk(xTicksToWait)))
        return pdFAIL;
 
    QueueSetNotify(xQueue, q);
    return pdPASS;
}

References FrtosTimeoutToStk(), IsIrqContext(), FrtosQueue::m_mq, pdFAIL, pdPASS, stk::sync::MessageQueue::Put(), and QueueSetNotify().

Referenced by xQueueSendToBack().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ xQueueSendFromISR()

BaseType_t xQueueSendFromISR	(	QueueHandle_t	xQueue,
		const void *	pvItemToQueue,
		BaseType_t *	pxHigherPriorityTaskWoken )

Post an item from ISR context (non-blocking).

Parameters

pxHigherPriorityTaskWoken Set pdTRUE if a context switch is needed.

Returns: pdTRUE if posted, pdFALSE if the queue was full.

Definition at line 1869 of file freertos_stk.cpp.

{
    if ((xQueue == nullptr) || (pvItemToQueue == nullptr))
        return pdFAIL;
 
    FrtosQueue *q = static_cast<FrtosQueue *>(xQueue);
    bool ok = q->m_mq.TryPut(pvItemToQueue);
 
    if (ok)
        QueueSetNotify(xQueue, q);
 
    // STK handles the wake-up internally; the wrapper does not need to
    // request an explicit yield from ISR because SWRR re-evaluates on the
    // next tick.  Set the flag to pdFALSE to avoid spurious portYIELD_FROM_ISR.
    if (pxHigherPriorityTaskWoken != nullptr)
        *pxHigherPriorityTaskWoken = pdFALSE;
 
    return ok ? pdPASS : pdFAIL;
}

References FrtosQueue::m_mq, pdFAIL, pdFALSE, pdPASS, QueueSetNotify(), and stk::sync::MessageQueue::TryPut().

Referenced by xQueueSendToBackFromISR().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ xQueueSendToBack()

BaseType_t xQueueSendToBack	(	QueueHandle_t	xQueue,
		const void *	pvItemToQueue,
		TickType_t	xTicksToWait )

Post an item to the back of a queue (alias of xQueueSend).

Definition at line 1727 of file freertos_stk.cpp.

{
    return xQueueSend(xQueue, pvItemToQueue, xTicksToWait);
}

References xQueueSend().

Here is the call graph for this function:

◆ xQueueSendToBackFromISR()

BaseType_t xQueueSendToBackFromISR	(	QueueHandle_t	xQueue,
		const void *	pvItemToQueue,
		BaseType_t *	pxHigherPriorityTaskWoken )

Post an item to the back of a queue from ISR context (non-blocking). Equivalent to xQueueSendFromISR(); provided for source compatibility with code that explicitly names the insertion end.

Parameters

pxHigherPriorityTaskWoken Set pdTRUE if a context switch is needed.

Returns: pdTRUE if posted, pdFALSE if the queue was full.

Definition at line 1906 of file freertos_stk.cpp.

{
    // Send-to-back from ISR is identical to xQueueSendFromISR: TryPut()
    // appends to the back of the ring buffer.
    return xQueueSendFromISR(xQueue, pvItemToQueue, pxHigherPriorityTaskWoken);
}

References xQueueSendFromISR().

Here is the call graph for this function:

◆ xQueueSendToFront()

BaseType_t xQueueSendToFront	(	QueueHandle_t	xQueue,
		const void *	pvItemToQueue,
		TickType_t	xTicksToWait )

Post an item to the front of a queue (blocking). The item becomes the next item returned by xQueueReceive().

Parameters

xTicksToWait Ticks to wait if full. portMAX_DELAY = wait forever.

Returns: pdTRUE on success, pdFALSE on timeout.

Definition at line 1734 of file freertos_stk.cpp.

{
    if ((xQueue == nullptr) || (pvItemToQueue == nullptr))
        return pdFAIL;
 
    if (IsIrqContext() && (xTicksToWait != 0U))
        return pdFAIL;
 
    FrtosQueue *q = static_cast<FrtosQueue *>(xQueue);
 
    if (!q->m_mq.PutFront(pvItemToQueue, FrtosTimeoutToStk(xTicksToWait)))
        return pdFAIL;
 
    QueueSetNotify(xQueue, q);
    return pdPASS;
}

References FrtosTimeoutToStk(), IsIrqContext(), FrtosQueue::m_mq, pdFAIL, pdPASS, stk::sync::MessageQueue::PutFront(), and QueueSetNotify().

Here is the call graph for this function:

◆ xQueueSendToFrontFromISR()

BaseType_t xQueueSendToFrontFromISR	(	QueueHandle_t	xQueue,
		const void *	pvItemToQueue,
		BaseType_t *	pxHigherPriorityTaskWoken )

Post an item to the front of a queue from ISR context (non-blocking).

The item becomes the next item returned by xQueueReceive() / xQueuePeek(). Backed by stk::sync::MessageQueue::TryPutFront() which retreats the tail pointer atomically under an internal critical section.

Parameters

pxHigherPriorityTaskWoken Always set to pdFALSE; STK handles scheduling.

Returns: pdTRUE if posted, pdFALSE if the queue was full.

Warning: ISR-safe.

Definition at line 1915 of file freertos_stk.cpp.

{
    if ((xQueue == nullptr) || (pvItemToQueue == nullptr))
        return pdFAIL;
 
    FrtosQueue *q = static_cast<FrtosQueue *>(xQueue);
    bool ok = q->m_mq.TryPutFront(pvItemToQueue);
 
    if (ok)
        QueueSetNotify(xQueue, q);
 
    // STK handles the wake-up internally; set the flag to pdFALSE to avoid
    // spurious portYIELD_FROM_ISR.
    if (pxHigherPriorityTaskWoken != nullptr)
        *pxHigherPriorityTaskWoken = pdFALSE;
 
    return ok ? pdPASS : pdFAIL;
}

References FrtosQueue::m_mq, pdFAIL, pdFALSE, pdPASS, QueueSetNotify(), and stk::sync::MessageQueue::TryPutFront().

Here is the call graph for this function:

◆ xSemaphoreCreateBinary()

SemaphoreHandle_t xSemaphoreCreateBinary ( void )

Create a binary semaphore (initial count = 0, max = 1).

Returns: Semaphore handle, or NULL on failure.

Definition at line 2220 of file freertos_stk.cpp.

{
    // Binary semaphore: max count = 1, initial count = 0.
    FrtosSemaphore *s = ObjAlloc<FrtosSemaphore>(
        SemKind::Counting,
        static_cast<uint16_t>(0U),
        static_cast<uint16_t>(1U));
 
    if ((s == nullptr) || (s->m_sem == nullptr))
    {
        ObjFree(s);
        return nullptr;
    }
    return static_cast<SemaphoreHandle_t>(s);
}

References Counting, FrtosSemaphore::m_sem, ObjAlloc(), and ObjFree().

Here is the call graph for this function:

◆ xSemaphoreCreateBinaryStatic()

SemaphoreHandle_t xSemaphoreCreateBinaryStatic ( StaticSemaphore_t * pxSemaphoreBuffer )

Create a binary semaphore using caller-supplied storage — no heap allocation.

Parameters

pxSemaphoreBuffer Caller-allocated control block (StaticSemaphore_t). Must remain valid for the lifetime of the semaphore.

Returns: Semaphore handle. Never NULL if pxSemaphoreBuffer is non-NULL.

Definition at line 2236 of file freertos_stk.cpp.

{
    if (pxSemaphoreBuffer == nullptr)
        return nullptr;
 
    // Static assert guards against the buffer being too small.
    static_assert(sizeof(StaticSemaphore_t) >= sizeof(FrtosSemaphore),
        "StaticSemaphore_t is too small to hold FrtosSemaphore. "
        "Increase STATIC_SEMAPHORE_TCB_SIZE_WORDS in freertos_stk.h.");
 
    // Placement-new the FrtosSemaphore control block into the caller-supplied
    // buffer.  Binary semaphore: max count = 1, initial count = 0.
    // The inner stk::sync::Semaphore is a value type embedded inside
    // FrtosSemaphore, so no additional heap allocation is needed.
    FrtosSemaphore *s = new (pxSemaphoreBuffer) FrtosSemaphore(
        SemKind::Counting,
        static_cast<uint16_t>(0U),
        static_cast<uint16_t>(1U));
 
    if (s->m_sem == nullptr)
    {
        s->~FrtosSemaphore(); // clean up without freeing
        return nullptr;
    }
 
    s->m_cb_owned = false; // caller owns the memory; destructor must not delete
 
    return static_cast<SemaphoreHandle_t>(s);
}

References Counting, FrtosSemaphore::m_cb_owned, FrtosSemaphore::m_sem, and FrtosSemaphore::~FrtosSemaphore().

Here is the call graph for this function:

◆ xSemaphoreCreateCounting()

SemaphoreHandle_t xSemaphoreCreateCounting	(	UBaseType_t	uxMaxCount,
		UBaseType_t	uxInitialCount )

Create a counting semaphore.

Parameters

uxMaxCount	Maximum count value.
uxInitialCount	Initial count value (must be <= uxMaxCount).

Returns: Semaphore handle, or NULL on failure.

Definition at line 2268 of file freertos_stk.cpp.

{
    if (uxMaxCount == 0U || uxInitialCount > uxMaxCount)
        return nullptr;
 
    if (uxMaxCount > stk::sync::Semaphore::COUNT_MAX)
        uxMaxCount = stk::sync::Semaphore::COUNT_MAX;
 
    FrtosSemaphore *s = ObjAlloc<FrtosSemaphore>(
        SemKind::Counting,
        static_cast<uint16_t>(uxInitialCount),
        static_cast<uint16_t>(uxMaxCount));
 
    if ((s == nullptr) || (s->m_sem == nullptr))
    {
        ObjFree(s);
        return nullptr;
    }
    return static_cast<SemaphoreHandle_t>(s);
}

References stk::sync::Semaphore::COUNT_MAX, Counting, FrtosSemaphore::m_sem, ObjAlloc(), and ObjFree().

Here is the call graph for this function:

◆ xSemaphoreCreateCountingStatic()

SemaphoreHandle_t xSemaphoreCreateCountingStatic	(	UBaseType_t	uxMaxCount,
		UBaseType_t	uxInitialCount,
		StaticSemaphore_t *	pxSemaphoreBuffer )

Create a counting semaphore using caller-supplied storage — no heap allocation.

Parameters

uxMaxCount	Maximum count value.
uxInitialCount	Initial count value (must be <= uxMaxCount).
pxSemaphoreBuffer	Caller-allocated control block (StaticSemaphore_t). Must remain valid for the lifetime of the semaphore.

Returns: Semaphore handle. Never NULL if pxSemaphoreBuffer is non-NULL and count arguments are valid.

Definition at line 2290 of file freertos_stk.cpp.

{
    if (pxSemaphoreBuffer == nullptr)
        return nullptr;
 
    if (uxMaxCount == 0U || uxInitialCount > uxMaxCount)
        return nullptr;
 
    if (uxMaxCount > stk::sync::Semaphore::COUNT_MAX)
        uxMaxCount = stk::sync::Semaphore::COUNT_MAX;
 
    static_assert(sizeof(StaticSemaphore_t) >= sizeof(FrtosSemaphore),
        "StaticSemaphore_t is too small to hold FrtosSemaphore. "
        "Increase STATIC_SEMAPHORE_TCB_SIZE_WORDS in freertos_stk.h.");
 
    FrtosSemaphore *s = new (pxSemaphoreBuffer) FrtosSemaphore(
        SemKind::Counting,
        static_cast<uint16_t>(uxInitialCount),
        static_cast<uint16_t>(uxMaxCount));
 
    if (s->m_sem == nullptr)
    {
        s->~FrtosSemaphore();
        return nullptr;
    }
 
    s->m_cb_owned = false;
    return static_cast<SemaphoreHandle_t>(s);
}

References stk::sync::Semaphore::COUNT_MAX, Counting, FrtosSemaphore::m_cb_owned, FrtosSemaphore::m_sem, and FrtosSemaphore::~FrtosSemaphore().

Here is the call graph for this function:

◆ xSemaphoreCreateMutex()

SemaphoreHandle_t xSemaphoreCreateMutex ( void )

Create a mutex.

Note: STK Mutex is always recursive; osMutexRecursive is always effective.

Returns: Mutex handle, or NULL on failure.

Definition at line 2326 of file freertos_stk.cpp.

{
    FrtosSemaphore *s = ObjAlloc<FrtosSemaphore>(
        SemKind::Mutex,
        static_cast<uint16_t>(0U),
        static_cast<uint16_t>(1U));
 
    if ((s == nullptr) || (s->m_mtx == nullptr))
    {
        ObjFree(s);
        return nullptr;
    }
 
    return static_cast<SemaphoreHandle_t>(s);
}

References FrtosSemaphore::m_mtx, Mutex, ObjAlloc(), and ObjFree().

Referenced by xSemaphoreCreateRecursiveMutex().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ xSemaphoreCreateMutexStatic()

SemaphoreHandle_t xSemaphoreCreateMutexStatic ( StaticSemaphore_t * pxMutexBuffer )

Create a mutex using caller-supplied storage — no heap allocation.

Parameters

pxMutexBuffer Caller-allocated control block (StaticSemaphore_t). Must remain valid for the lifetime of the mutex.

Returns: Mutex handle. Never NULL if pxMutexBuffer is non-NULL.

Definition at line 2342 of file freertos_stk.cpp.

{
    if (pxMutexBuffer == nullptr)
        return nullptr;
 
    static_assert(sizeof(StaticSemaphore_t) >= sizeof(FrtosSemaphore),
        "StaticSemaphore_t is too small to hold FrtosSemaphore. "
        "Increase STATIC_SEMAPHORE_TCB_SIZE_WORDS in freertos_stk.h.");
 
    FrtosSemaphore *s = new (pxMutexBuffer) FrtosSemaphore(
        SemKind::Mutex,
        static_cast<uint16_t>(0U),
        static_cast<uint16_t>(1U));
 
    if (s->m_mtx == nullptr)
    {
        s->~FrtosSemaphore();
        return nullptr;
    }
 
    s->m_cb_owned = false;
    return static_cast<SemaphoreHandle_t>(s);
}

References FrtosSemaphore::m_cb_owned, FrtosSemaphore::m_mtx, Mutex, and FrtosSemaphore::~FrtosSemaphore().

Referenced by xSemaphoreCreateRecursiveMutexStatic().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ xSemaphoreCreateRecursiveMutex()

SemaphoreHandle_t xSemaphoreCreateRecursiveMutex ( void )

Create a recursive mutex (same implementation as xSemaphoreCreateMutex).

Definition at line 2366 of file freertos_stk.cpp.

{
    // STK Mutex is always recursive.
    return xSemaphoreCreateMutex();
}

References xSemaphoreCreateMutex().

Here is the call graph for this function:

◆ xSemaphoreCreateRecursiveMutexStatic()

SemaphoreHandle_t xSemaphoreCreateRecursiveMutexStatic ( StaticSemaphore_t * pxMutexBuffer )

Create a recursive mutex using caller-supplied storage — no heap allocation.

Parameters

pxMutexBuffer Caller-allocated control block (StaticSemaphore_t). Must remain valid for the lifetime of the mutex.

Returns: Mutex handle. Never NULL if pxMutexBuffer is non-NULL.

Definition at line 2372 of file freertos_stk.cpp.

{
    // STK Mutex is always recursive; identical to xSemaphoreCreateMutexStatic.
    return xSemaphoreCreateMutexStatic(pxMutexBuffer);
}

References xSemaphoreCreateMutexStatic().

Here is the call graph for this function:

◆ xSemaphoreGetMutexHolder()

TaskHandle_t xSemaphoreGetMutexHolder ( SemaphoreHandle_t xMutex )

Return the handle of the task that currently holds a mutex.

Reads the owner field of the underlying stk::sync::Mutex under a ScopedCriticalSection so the snapshot is consistent even if a concurrent Unlock() is in progress.

Parameters

xMutex Handle of a mutex created by xSemaphoreCreateMutex() or xSemaphoreCreateRecursiveMutex(). Passing a counting or binary semaphore handle always returns NULL.

Returns: Handle of the owning task, or NULL if the mutex is unlocked or xMutex is not a mutex kind.

Warning: Not ISR-safe. Use xSemaphoreGetMutexHolderFromISR() from ISR context.

Definition at line 2520 of file freertos_stk.cpp.

{
    // Returns the task that currently owns the mutex, or NULL if the mutex
    // is unlocked or xMutex is not a mutex-kind semaphore.
    //
    // FreeRTOS documents this function as not ISR-safe and requiring the
    // scheduler to be running.  We guard it with a ScopedCriticalSection
    // so that the TId snapshot is consistent: if Unlock() is executing
    // concurrently, we see either the old owner or TID_NONE, never a torn
    // pointer.
    //
    // TId -> TaskHandle_t: STK stores task pointers as TId values via
    //   TId = static_cast<TId>(reinterpret_cast<uintptr_t>(task_ptr))
    // so the inverse is:
    //   task_ptr = reinterpret_cast<FrtosTask *>(static_cast<uintptr_t>(tid))
    // TID_NONE maps to nullptr (TaskHandle_t == nullptr means "no owner").
    if (xMutex == nullptr)
        return nullptr;
 
    FrtosSemaphore *s = static_cast<FrtosSemaphore *>(xMutex);
 
    if (s->m_kind != SemKind::Mutex)
        return nullptr; // not a mutex — owner concept does not apply
 
    stk::sync::ScopedCriticalSection cs_;
 
    const stk::TId owner = s->m_mtx->GetOwner();
 
    if (owner == stk::TID_NONE)
        return nullptr; // mutex is currently unlocked
 
    return reinterpret_cast<TaskHandle_t>(static_cast<uintptr_t>(owner));
}

References stk::sync::Mutex::GetOwner(), FrtosSemaphore::m_kind, FrtosSemaphore::m_mtx, Mutex, and stk::TID_NONE.

Referenced by xQueueGetMutexHolder().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ xSemaphoreGetMutexHolderFromISR()

TaskHandle_t xSemaphoreGetMutexHolderFromISR ( SemaphoreHandle_t xMutex )

Return the handle of the task that currently holds a mutex (ISR-safe).

Reads the owner field of the underlying stk::sync::Mutex with a single pointer-sized load, which is naturally atomic on all supported STK architectures (Cortex-M and equivalents). No additional critical section is acquired beyond what the caller already holds.

Parameters

xMutex Handle of a mutex. Passing a non-mutex semaphore returns NULL.

Returns: Handle of the owning task, or NULL if the mutex is unlocked or xMutex is not a mutex kind.

Warning: ISR-safe.

Definition at line 2554 of file freertos_stk.cpp.

{
    // ISR-safe variant.  GetOwner() reads a single TId (pointer-sized, aligned)
    // which is an atomic read on all supported STK architectures, so no
    // ScopedCriticalSection is needed here beyond what the caller already holds.
    // We still validate the handle and the semaphore kind before touching the
    // mutex state.
    if (xMutex == nullptr)
        return nullptr;
 
    FrtosSemaphore *s = static_cast<FrtosSemaphore *>(xMutex);
 
    if (s->m_kind != SemKind::Mutex)
        return nullptr;
 
    const stk::TId owner = s->m_mtx->GetOwner();
 
    if (owner == stk::TID_NONE)
        return nullptr;
 
    return reinterpret_cast<TaskHandle_t>(static_cast<uintptr_t>(owner));
}

References stk::sync::Mutex::GetOwner(), FrtosSemaphore::m_kind, FrtosSemaphore::m_mtx, Mutex, and stk::TID_NONE.

Referenced by xQueueGetMutexHolderFromISR().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ xSemaphoreGive()

BaseType_t xSemaphoreGive ( SemaphoreHandle_t xSemaphore )

Give (release) a semaphore or mutex.

Returns: pdTRUE on success, pdFALSE if max count would be exceeded.

Definition at line 2442 of file freertos_stk.cpp.

{
    if (xSemaphore == nullptr)
        return pdFAIL;
 
    FrtosSemaphore *s = static_cast<FrtosSemaphore *>(xSemaphore);
 
    if (s->m_kind == SemKind::Mutex)
    {
#if configUSE_MUTEXES
        s->m_mtx->Unlock();
        // Mutexes are not eligible for queue sets (FreeRTOS API contract),
        // so no QueueSetNotify call is needed here.
        return pdPASS;
#else
        return pdFAIL;
#endif
    }
    else
    {
        // Guard against overflow: TryWait + Signal pattern.
        if (s->m_sem->GetCount() >= stk::sync::Semaphore::COUNT_MAX)
            return pdFAIL;
 
        s->m_sem->Signal();
        QueueSetNotify(xSemaphore, s);
        return pdPASS;
    }
}

References stk::sync::Semaphore::COUNT_MAX, stk::sync::Semaphore::GetCount(), FrtosSemaphore::m_kind, FrtosSemaphore::m_mtx, FrtosSemaphore::m_sem, Mutex, pdFAIL, pdPASS, QueueSetNotify(), stk::sync::Semaphore::Signal(), and stk::sync::Mutex::Unlock().

Referenced by xSemaphoreGiveRecursive().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ xSemaphoreGiveFromISR()

BaseType_t xSemaphoreGiveFromISR	(	SemaphoreHandle_t	xSemaphore,
		BaseType_t *	pxHigherPriorityTaskWoken )

Give a binary or counting semaphore from ISR context.

Note: Mutex give from ISR is not permitted and returns pdFALSE.

Parameters

pxHigherPriorityTaskWoken Set pdTRUE if a context switch is needed.

Returns: pdTRUE on success, pdFALSE on error or max-count overflow.

Definition at line 2477 of file freertos_stk.cpp.

{
    if (xSemaphore == nullptr)
        return pdFAIL;
 
    FrtosSemaphore *s = static_cast<FrtosSemaphore *>(xSemaphore);
 
    if (s->m_kind == SemKind::Mutex)
        return pdFAIL; // Mutex give from ISR is not permitted.
 
    if (s->m_sem->GetCount() >= stk::sync::Semaphore::COUNT_MAX)
        return pdFAIL;
 
    s->m_sem->Signal();
    QueueSetNotify(xSemaphore, s);
 
    if (pxHigherPriorityTaskWoken != nullptr)
        *pxHigherPriorityTaskWoken = pdFALSE;
 
    return pdPASS;
}

References stk::sync::Semaphore::COUNT_MAX, stk::sync::Semaphore::GetCount(), FrtosSemaphore::m_kind, FrtosSemaphore::m_sem, Mutex, pdFAIL, pdFALSE, pdPASS, QueueSetNotify(), and stk::sync::Semaphore::Signal().

Here is the call graph for this function:

◆ xSemaphoreGiveRecursive()

BaseType_t xSemaphoreGiveRecursive ( SemaphoreHandle_t xMutex )

Give a recursive mutex.

Definition at line 2472 of file freertos_stk.cpp.

{
    return xSemaphoreGive(xMutex);
}

References xSemaphoreGive().

Here is the call graph for this function:

◆ xSemaphoreTake()

BaseType_t xSemaphoreTake	(	SemaphoreHandle_t	xSemaphore,
		TickType_t	xTicksToWait )

Take (acquire) a semaphore or mutex (blocking).

Parameters

xTicksToWait Ticks to wait. portMAX_DELAY = wait forever.

Returns: pdTRUE if acquired, pdFALSE on timeout.

Definition at line 2388 of file freertos_stk.cpp.

{
    if (xSemaphore == nullptr)
        return pdFAIL;
 
    if (IsIrqContext() && (xTicksToWait != 0U))
        return pdFAIL;
 
    FrtosSemaphore *s   = static_cast<FrtosSemaphore *>(xSemaphore);
    stk::Timeout    tmo = FrtosTimeoutToStk(xTicksToWait);
 
    if (s->m_kind == SemKind::Mutex)
    {
#if configUSE_MUTEXES
        return s->m_mtx->TimedLock(tmo) ? pdPASS : pdFAIL;
#else
        return pdFAIL;
#endif
    }
    else
        return s->m_sem->Wait(tmo) ? pdPASS : pdFAIL;
}

References FrtosTimeoutToStk(), IsIrqContext(), FrtosSemaphore::m_kind, FrtosSemaphore::m_mtx, FrtosSemaphore::m_sem, Mutex, pdFAIL, pdPASS, stk::sync::Mutex::TimedLock(), and stk::sync::Semaphore::Wait().

Referenced by xSemaphoreTakeRecursive().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ xSemaphoreTakeFromISR()

BaseType_t xSemaphoreTakeFromISR	(	SemaphoreHandle_t	xSemaphore,
		BaseType_t *	pxHigherPriorityTaskWoken )

Take (acquire) a binary or counting semaphore from ISR context (non-blocking).

Note: Mutex take from ISR is not permitted and returns pdFALSE.

Parameters

pxHigherPriorityTaskWoken Set pdTRUE if a context switch is needed.

Returns: pdTRUE if acquired, pdFALSE if the count was zero.

Definition at line 2411 of file freertos_stk.cpp.

{
    if (xSemaphore == nullptr)
        return pdFAIL;
 
    FrtosSemaphore *s = static_cast<FrtosSemaphore *>(xSemaphore);
 
    // Mutex take from ISR is not permitted — mirrors xSemaphoreGiveFromISR.
    if (s->m_kind == SemKind::Mutex)
        return pdFAIL;
 
    // TryWait() is Wait(NO_WAIT): decrement count if > 0, return immediately.
    // ISR-safe per the STK Semaphore contract.
    bool ok = s->m_sem->TryWait();
 
    // STK handles priority re-evaluation internally on the next tick.
    // Set pdFALSE to avoid spurious portYIELD_FROM_ISR, matching the
    // pattern used by xQueueReceiveFromISR and xSemaphoreGiveFromISR.
    if (pxHigherPriorityTaskWoken != nullptr)
        *pxHigherPriorityTaskWoken = pdFALSE;
 
    return ok ? pdPASS : pdFAIL;
}

References FrtosSemaphore::m_kind, FrtosSemaphore::m_sem, Mutex, pdFAIL, pdFALSE, pdPASS, and stk::sync::Semaphore::TryWait().

Here is the call graph for this function:

◆ xSemaphoreTakeRecursive()

BaseType_t xSemaphoreTakeRecursive	(	SemaphoreHandle_t	xMutex,
		TickType_t	xTicksToWait )

Take a recursive mutex (blocking).

Definition at line 2436 of file freertos_stk.cpp.

{
    // STK Mutex is always recursive; identical to xSemaphoreTake.
    return xSemaphoreTake(xMutex, xTicksToWait);
}

References xSemaphoreTake().

Here is the call graph for this function:

◆ xStreamBufferBytesAvailable()

size_t xStreamBufferBytesAvailable ( StreamBufferHandle_t xStreamBuffer )

Return the number of bytes currently available to read.

Definition at line 3880 of file freertos_stk.cpp.

{
    if (xStreamBuffer == nullptr)
        return 0U;
 
    return static_cast<FrtosStreamBuffer *>(xStreamBuffer)->m_pipe.GetCount();
}

Referenced by xStreamBufferIsEmpty(), and xStreamBufferNextMessageLengthBytes().

Here is the caller graph for this function:

◆ xStreamBufferCreate()

StreamBufferHandle_t xStreamBufferCreate	(	size_t	xBufferSizeBytes,
		size_t	xTriggerLevelBytes )

Create a dynamically allocated stream buffer.

Parameters

xBufferSizeBytes	Total byte capacity of the ring buffer.
xTriggerLevelBytes	Minimum bytes that must be present before a blocking Receive() wakes (1 = wake on any byte).

Returns: Handle, or NULL on allocation failure.

Definition at line 3708 of file freertos_stk.cpp.

{
    if (xBufferSizeBytes == 0U)
        return nullptr;
 
    uint8_t *buf = ObjAllocArray<uint8_t>(xBufferSizeBytes);
    if (buf == nullptr)
        return nullptr;
 
    FrtosStreamBuffer *sb = ObjAlloc<FrtosStreamBuffer>(buf, xBufferSizeBytes, xTriggerLevelBytes);
    if (sb == nullptr)
    {
        ObjFreeArray(buf);
        return nullptr;
    }
 
    sb->m_buf_owned = true;
    sb->m_cb_owned  = true;
 
    return static_cast<StreamBufferHandle_t>(sb);
}

References FrtosStreamBuffer::m_buf_owned, FrtosStreamBuffer::m_cb_owned, ObjAlloc(), ObjAllocArray(), and ObjFreeArray().

Here is the call graph for this function:

◆ xStreamBufferCreateStatic()

StreamBufferHandle_t xStreamBufferCreateStatic	(	size_t	xBufferSizeBytes,
		size_t	xTriggerLevelBytes,
		uint8_t *	pucStreamBufferStorageArea,
		StaticStreamBuffer_t *	pxStaticStreamBuffer )

Create a statically allocated stream buffer (no heap).

Parameters

xBufferSizeBytes	Total byte capacity.
xTriggerLevelBytes	Minimum bytes for Receive() to unblock.
pucStreamBufferStorageArea	Caller-supplied data buffer of at least xBufferSizeBytes bytes.
pxStaticStreamBuffer	Caller-supplied TCB (StaticStreamBuffer_t).

Returns: Handle (always non-NULL if arguments are non-NULL).

Definition at line 3731 of file freertos_stk.cpp.

{
    if ((pucStreamBufferStorageArea == nullptr) ||
        (pxStaticStreamBuffer      == nullptr) ||
        (xBufferSizeBytes == 0U))
        return nullptr;
 
    static_assert(sizeof(StaticStreamBuffer_t) >= sizeof(FrtosStreamBuffer),
        "Increase STATIC_STREAM_BUFFER_TCB_SIZE_WORDS in FreeRTOS.h.");
 
    FrtosStreamBuffer *sb = new (pxStaticStreamBuffer)
        FrtosStreamBuffer(pucStreamBufferStorageArea,
                          xBufferSizeBytes,
                          xTriggerLevelBytes);
 
    // m_buf_owned = false, m_cb_owned = false already set by the ctor
    return static_cast<StreamBufferHandle_t>(sb);
}

◆ xStreamBufferCreateStaticWithCallback()

StreamBufferHandle_t xStreamBufferCreateStaticWithCallback	(	size_t	xBufferSizeBytes,
		size_t	xTriggerLevelBytes,
		uint8_t *	pucStreamBufferStorageArea,
		StaticStreamBuffer_t *	pxStaticStreamBuffer,
		StreamBufferCallbackFunction_t	pxSendCompletedCallback,
		StreamBufferCallbackFunction_t	pxReceiveCompletedCallback )

Create a statically-allocated stream buffer with optional send/receive callbacks.

Identical to xStreamBufferCreateStatic() but registers per-instance callbacks. Either callback may be NULL.

Parameters

xBufferSizeBytes	Capacity of the data buffer in bytes.
xTriggerLevelBytes	Minimum bytes before Receive() unblocks.
pucStreamBufferStorageArea	Caller-supplied data buffer (>= xBufferSizeBytes bytes).
pxStaticStreamBuffer	Caller-supplied TCB (StaticStreamBuffer_t).
pxSendCompletedCallback	Called after bytes are written (or NULL).
pxReceiveCompletedCallback	Called after bytes are read (or NULL).

Returns: Handle, or NULL on invalid arguments.

Definition at line 4020 of file freertos_stk.cpp.

{
    if ((pucStreamBufferStorageArea == nullptr) ||
        (pxStaticStreamBuffer      == nullptr) ||
        (xBufferSizeBytes == 0U))
        return nullptr;
 
    static_assert(sizeof(StaticStreamBuffer_t) >= sizeof(FrtosStreamBuffer),
        "Increase STATIC_STREAM_BUFFER_TCB_SIZE_WORDS in FreeRTOS.h.");
 
    FrtosStreamBuffer *sb = new (pxStaticStreamBuffer)
        FrtosStreamBuffer(pucStreamBufferStorageArea,
                          xBufferSizeBytes,
                          xTriggerLevelBytes,
                          pxSendCompletedCallback,
                          pxReceiveCompletedCallback);
    // m_buf_owned = false, m_cb_owned = false already set by ctor
    return static_cast<StreamBufferHandle_t>(sb);
}

◆ xStreamBufferCreateWithCallback()

StreamBufferHandle_t xStreamBufferCreateWithCallback	(	size_t	xBufferSizeBytes,
		size_t	xTriggerLevelBytes,
		StreamBufferCallbackFunction_t	pxSendCompletedCallback,
		StreamBufferCallbackFunction_t	pxReceiveCompletedCallback )

Create a heap-allocated stream buffer with optional send/receive callbacks.

Identical to xStreamBufferCreate() but registers per-instance callbacks invoked after data is successfully written (pxSendCompletedCallback) or read (pxReceiveCompletedCallback). Either callback may be NULL. Callbacks fire outside any critical section, after the transfer completes.

Parameters

xBufferSizeBytes	Capacity of the data buffer in bytes.
xTriggerLevelBytes	Minimum bytes before Receive() unblocks.
pxSendCompletedCallback	Called after bytes are written (or NULL).
pxReceiveCompletedCallback	Called after bytes are read (or NULL).

Returns: Handle, or NULL on allocation failure.

Definition at line 3988 of file freertos_stk.cpp.

{
    if (xBufferSizeBytes == 0U)
        return nullptr;
 
    uint8_t *buf = ObjAllocArray<uint8_t>(xBufferSizeBytes);
    if (buf == nullptr)
        return nullptr;
 
    FrtosStreamBuffer *sb = ObjAlloc<FrtosStreamBuffer>(
        buf,
        xBufferSizeBytes,
        xTriggerLevelBytes,
        pxSendCompletedCallback,
        pxReceiveCompletedCallback);
 
    if (sb == nullptr)
    {
        ObjFreeArray(buf);
        return nullptr;
    }
 
    sb->m_buf_owned = true;
    sb->m_cb_owned  = true;
 
    return static_cast<StreamBufferHandle_t>(sb);
}

References FrtosStreamBuffer::m_buf_owned, FrtosStreamBuffer::m_cb_owned, ObjAlloc(), ObjAllocArray(), and ObjFreeArray().

Here is the call graph for this function:

◆ xStreamBufferGetTriggerLevel()

size_t xStreamBufferGetTriggerLevel ( StreamBufferHandle_t xStreamBuffer )

Return the trigger level currently set on a stream buffer.

Parameters

xStreamBuffer Handle returned by xStreamBufferCreate[Static][WithCallback]().

Returns: Current trigger level in bytes (always >= 1), or 0 if handle is NULL.

Note: ISR-safe.

Definition at line 3946 of file freertos_stk.cpp.

{
    if (xStreamBuffer == nullptr)
        return 0U;
 
    // m_trigger is a plain size_t written only under ScopedCriticalSection
    // (in xStreamBufferSetTriggerLevel).  A size_t-aligned read is atomic on
    // all Cortex-M targets — same rationale as Pipe::GetCount().
    return static_cast<const FrtosStreamBuffer *>(xStreamBuffer)->m_trigger;
}

◆ xStreamBufferIsEmpty()

BaseType_t xStreamBufferIsEmpty ( StreamBufferHandle_t xStreamBuffer )

Return pdTRUE if the stream buffer contains no data.

Definition at line 3896 of file freertos_stk.cpp.

{
    return (xStreamBufferBytesAvailable(xStreamBuffer) == 0U) ? pdTRUE : pdFALSE;
}

References pdFALSE, pdTRUE, and xStreamBufferBytesAvailable().

Here is the call graph for this function:

◆ xStreamBufferIsFull()

BaseType_t xStreamBufferIsFull ( StreamBufferHandle_t xStreamBuffer )

Return pdTRUE if the stream buffer is full (no write space remaining).

Definition at line 3901 of file freertos_stk.cpp.

{
    return (xStreamBufferSpacesAvailable(xStreamBuffer) == 0U) ? pdTRUE : pdFALSE;
}

References pdFALSE, pdTRUE, and xStreamBufferSpacesAvailable().

Here is the call graph for this function:

◆ xStreamBufferNextMessageLengthBytes()

size_t xStreamBufferNextMessageLengthBytes ( StreamBufferHandle_t xStreamBuffer )

Return the number of bytes available to read from a stream buffer without blocking.

For a stream buffer (pure unframed byte stream) this is equivalent to xStreamBufferBytesAvailable(): the entire readable span is the "next message" because stream buffers carry no length-prefix framing. The function is provided for source compatibility with code written against the FreeRTOS stream/message buffer API where both buffer kinds are used interchangeably.

Parameters

xStreamBuffer Handle returned by xStreamBufferCreate[Static][WithCallback]().

Returns: Number of bytes currently available to read (0 if empty or handle is NULL).

Note: ISR-safe (delegates to Pipe::GetCount() which is ISR-safe on targets where a size_t-aligned read is atomic).

Definition at line 3972 of file freertos_stk.cpp.

{
    // Delegates to xStreamBufferBytesAvailable() which performs the NULL guard
    // and returns Pipe::GetCount() — ISR-safe on all supported targets.
    return xStreamBufferBytesAvailable(xStreamBuffer);
}

References xStreamBufferBytesAvailable().

Here is the call graph for this function:

◆ xStreamBufferReceive()

size_t xStreamBufferReceive	(	StreamBufferHandle_t	xStreamBuffer,
		void *	pvRxData,
		size_t	xBufferLengthBytes,
		TickType_t	xTicksToWait )

Read bytes from the stream buffer, blocking until trigger level is reached.

Parameters

xStreamBuffer	Handle.
pvRxData	Destination buffer.
xBufferLengthBytes	Maximum bytes to read.
xTicksToWait	Ticks to block until at least trigger bytes are available.

Returns: Number of bytes actually read (0 on timeout or empty buffer).

Definition at line 3817 of file freertos_stk.cpp.

{
    if ((xStreamBuffer == nullptr) || (pvRxData == nullptr) || (xBufferLengthBytes == 0U))
        return 0U;
 
    if (IsIrqContext() && (xTicksToWait != 0U))
        return 0U;
 
    FrtosStreamBuffer *sb = static_cast<FrtosStreamBuffer *>(xStreamBuffer);
 
    // ReadBulkTriggered handles all cases in one call:
    //   - NO_WAIT (xTicksToWait == 0): trigger not enforced, returns whatever
    //     is available immediately (guaranteed by CV NO_WAIT fast-path).
    //   - Blocking with trigger: waits until m_trigger bytes are present, then
    //     drains up to xBufferLengthBytes in one atomic CS pass.
    //   - Timeout before trigger: drains whatever arrived, possibly 0.
    const size_t total = sb->m_pipe.ReadBulkTriggered(
        static_cast<uint8_t *>(pvRxData),
        sb->m_trigger,
        xBufferLengthBytes,
        FrtosTimeoutToStk(xTicksToWait));
 
    // Fire receive-complete callback outside any critical section.
    if ((total > 0U) && (sb->m_recv_cb != nullptr))
    {
        BaseType_t woken = pdFALSE;
        sb->m_recv_cb(xStreamBuffer, &woken);
    }
 
    return total;
}

References FrtosTimeoutToStk(), IsIrqContext(), FrtosStreamBuffer::m_pipe, FrtosStreamBuffer::m_recv_cb, FrtosStreamBuffer::m_trigger, pdFALSE, and stk::sync::Pipe::ReadBulkTriggered().

Here is the call graph for this function:

◆ xStreamBufferReceiveFromISR()

size_t xStreamBufferReceiveFromISR	(	StreamBufferHandle_t	xStreamBuffer,
		void *	pvRxData,
		size_t	xBufferLengthBytes,
		BaseType_t *	pxHigherPriorityTaskWoken )

Read bytes from ISR context (non-blocking, NO_WAIT).

Parameters

pxHigherPriorityTaskWoken Always set to pdFALSE.

Returns: Number of bytes actually read.

Definition at line 3852 of file freertos_stk.cpp.

{
    if (pxHigherPriorityTaskWoken != nullptr)
        *pxHigherPriorityTaskWoken = pdFALSE;
 
    if ((xStreamBuffer == nullptr) || (pvRxData == nullptr) || (xBufferLengthBytes == 0U))
        return 0U;
 
    FrtosStreamBuffer *sb = static_cast<FrtosStreamBuffer *>(xStreamBuffer);
 
    const size_t received = sb->m_pipe.TryReadBulk(
        static_cast<uint8_t *>(pvRxData),
        xBufferLengthBytes);
 
    // Fire receive-complete callback outside any critical section.
    // pxHigherPriorityTaskWoken is always pdFALSE per STK convention.
    if ((received > 0U) && (sb->m_recv_cb != nullptr))
    {
        BaseType_t woken = pdFALSE;
        sb->m_recv_cb(xStreamBuffer, &woken);
    }
 
    return received;
}

References FrtosStreamBuffer::m_pipe, FrtosStreamBuffer::m_recv_cb, pdFALSE, and stk::sync::Pipe::TryReadBulk().

Here is the call graph for this function:

◆ xStreamBufferReset()

BaseType_t xStreamBufferReset ( StreamBufferHandle_t xStreamBuffer )

Discard all data and reset the stream buffer to the empty state.

Returns: pdPASS always.

Definition at line 3906 of file freertos_stk.cpp.

{
    if (xStreamBuffer == nullptr)
        return pdFAIL;
 
    static_cast<FrtosStreamBuffer *>(xStreamBuffer)->m_pipe.Reset();
    return pdPASS;
}

References pdFAIL, and pdPASS.

◆ xStreamBufferResetFromISR()

BaseType_t xStreamBufferResetFromISR	(	StreamBufferHandle_t	xStreamBuffer,
		BaseType_t *	pxHigherPriorityTaskWoken )

Reset a stream buffer to empty from ISR context.

Delegates to Pipe::Reset() which holds a ScopedCriticalSection internally. Data in the buffer is discarded; tasks blocked in xStreamBufferSend() that were waiting for space are woken.

Parameters

pxHigherPriorityTaskWoken Always set to pdFALSE; STK handles scheduling.

Returns: pdPASS on success, pdFAIL if the handle is NULL.

Note: ISR-safe.

Definition at line 3932 of file freertos_stk.cpp.

{
    if (pxHigherPriorityTaskWoken != nullptr)
        *pxHigherPriorityTaskWoken = pdFALSE;
 
    if (xStreamBuffer == nullptr)
        return pdFAIL;
 
    // Pipe::Reset() acquires ScopedCriticalSection internally — ISR-safe.
    static_cast<FrtosStreamBuffer *>(xStreamBuffer)->m_pipe.Reset();
    return pdPASS;
}

References pdFAIL, pdFALSE, and pdPASS.

◆ xStreamBufferSend()

size_t xStreamBufferSend	(	StreamBufferHandle_t	xStreamBuffer,
		const void *	pvTxData,
		size_t	xDataLengthBytes,
		TickType_t	xTicksToWait )

Write bytes into the stream buffer.

Parameters

xStreamBuffer	Handle.
pvTxData	Pointer to source data.
xDataLengthBytes	Number of bytes to write.
xTicksToWait	Ticks to wait for space (0 = non-blocking).

Returns: Number of bytes actually written (may be less than requested on timeout).

Definition at line 3764 of file freertos_stk.cpp.

{
    if ((xStreamBuffer == nullptr) || (pvTxData == nullptr) || (xDataLengthBytes == 0U))
        return 0U;
 
    FrtosStreamBuffer *sb = static_cast<FrtosStreamBuffer *>(xStreamBuffer);
 
    const size_t sent = sb->m_pipe.WriteBulk(
        static_cast<const uint8_t *>(pvTxData),
        xDataLengthBytes,
        FrtosTimeoutToStk(xTicksToWait));
 
    // Fire send-complete callback outside any critical section.
    if ((sent > 0U) && (sb->m_send_cb != nullptr))
    {
        BaseType_t woken = pdFALSE;
        sb->m_send_cb(xStreamBuffer, &woken);
    }
 
    return sent;
}

References FrtosTimeoutToStk(), FrtosStreamBuffer::m_pipe, FrtosStreamBuffer::m_send_cb, pdFALSE, and stk::sync::Pipe::WriteBulk().

Here is the call graph for this function:

◆ xStreamBufferSendFromISR()

size_t xStreamBufferSendFromISR	(	StreamBufferHandle_t	xStreamBuffer,
		const void *	pvTxData,
		size_t	xDataLengthBytes,
		BaseType_t *	pxHigherPriorityTaskWoken )

Write bytes from ISR context (non-blocking, NO_WAIT).

Parameters

pxHigherPriorityTaskWoken Always set to pdFALSE (STK handles scheduling).

Returns: Number of bytes actually written.

Definition at line 3789 of file freertos_stk.cpp.

{
    if (pxHigherPriorityTaskWoken != nullptr)
        *pxHigherPriorityTaskWoken = pdFALSE;
 
    if ((xStreamBuffer == nullptr) || (pvTxData == nullptr) || (xDataLengthBytes == 0U))
        return 0U;
 
    FrtosStreamBuffer *sb = static_cast<FrtosStreamBuffer *>(xStreamBuffer);
 
    const size_t sent = sb->m_pipe.TryWriteBulk(
        static_cast<const uint8_t *>(pvTxData),
        xDataLengthBytes);
 
    // Fire send-complete callback outside any critical section.
    // pxHigherPriorityTaskWoken is always pdFALSE per STK convention.
    if ((sent > 0U) && (sb->m_send_cb != nullptr))
    {
        BaseType_t woken = pdFALSE;
        sb->m_send_cb(xStreamBuffer, &woken);
    }
 
    return sent;
}

References FrtosStreamBuffer::m_pipe, FrtosStreamBuffer::m_send_cb, pdFALSE, and stk::sync::Pipe::TryWriteBulk().

Here is the call graph for this function:

◆ xStreamBufferSetTriggerLevel()

BaseType_t xStreamBufferSetTriggerLevel	(	StreamBufferHandle_t	xStreamBuffer,
		size_t	xTriggerLevelBytes )

Change the trigger level for a stream buffer.

Parameters

xTriggerLevelBytes New minimum bytes for Receive() to unblock (>= 1).

Returns: pdTRUE on success, pdFALSE if xTriggerLevelBytes > buffer capacity.

Definition at line 3915 of file freertos_stk.cpp.

{
    if (xStreamBuffer == nullptr)
        return pdFALSE;
 
    FrtosStreamBuffer *sb = static_cast<FrtosStreamBuffer *>(xStreamBuffer);
 
    if (xTriggerLevelBytes > sb->m_pipe.GetCapacity())
        return pdFALSE;
 
    stk::sync::ScopedCriticalSection cs_;
    sb->m_trigger = (xTriggerLevelBytes >= 1U ? xTriggerLevelBytes : 1U);
 
    return pdTRUE;
}

References stk::sync::Pipe::GetCapacity(), FrtosStreamBuffer::m_pipe, FrtosStreamBuffer::m_trigger, pdFALSE, and pdTRUE.

Here is the call graph for this function:

◆ xStreamBufferSpacesAvailable()

size_t xStreamBufferSpacesAvailable ( StreamBufferHandle_t xStreamBuffer )

Return the number of free bytes available for writing.

Definition at line 3888 of file freertos_stk.cpp.

{
    if (xStreamBuffer == nullptr)
        return 0U;
 
    return static_cast<FrtosStreamBuffer *>(xStreamBuffer)->m_pipe.GetSpace();
}

Referenced by xStreamBufferIsFull().

Here is the caller graph for this function:

◆ xTaskAbortDelay()

BaseType_t xTaskAbortDelay ( TaskHandle_t xTask )

Abort a delay that the target task is currently blocked in (vTaskDelay, vTaskDelayUntil, or any timed sync primitive wait). The task is made immediately runnable; its next Wait/Sleep will not be affected.

Returns: pdPASS if the task was in a delayed state and the abort was issued, pdFAIL if the task was not delayed.

Note: ISR-safe (delegates to stk::AbortSleep which is ISR-safe).

Definition at line 1257 of file freertos_stk.cpp.

{
    if (xTask == nullptr)
        return pdFALSE;
 
    // Resolve NULL -> calling task (same convention used throughout the wrapper).
    const stk::TId tid = static_cast<stk::TId>(reinterpret_cast<uintptr_t>(xTask));
 
    const FrtosTask *t = static_cast<const FrtosTask *>(xTask);
    if (t->m_state != FrtosTask::State::Ready)
        return pdFAIL; // suspended or otherwise not in a delay-able state
 
    stk::SleepCancel(tid);
    return pdPASS;
}

References FrtosTask::m_state, pdFAIL, pdFALSE, pdPASS, FrtosTask::Ready, and stk::SleepCancel().

Here is the call graph for this function:

◆ xTaskCreate()

BaseType_t xTaskCreate	(	TaskFunction_t	pvTaskCode,
		const char *	pcName,
		uint32_t	usStackDepth,
		void *	pvParameters,
		UBaseType_t	uxPriority,
		TaskHandle_t *	pxCreatedTask )

Create a new dynamic task.

Parameters

pvTaskCode	Task function pointer.
pcName	Descriptive name for debugging.
usStackDepth	Stack depth in Words (not bytes).
pvParameters	Argument passed to pvTaskCode.
uxPriority	Priority: 0 = lowest, configMAX_PRIORITIES-1 = highest.
pxCreatedTask	Optional: receives the handle of the created task.

Returns: pdPASS on success, pdFAIL if the task could not be created.

Definition at line 1106 of file freertos_stk.cpp.

{
    if (pvTaskCode == nullptr)
        return pdFAIL;
 
    FrtosTask *t = ObjAlloc<FrtosTask>();
    if (t == nullptr)
        return pdFAIL;
 
    t->m_func      = pvTaskCode;
    t->m_argument  = pvParameters;
    t->m_name      = pcName;
    t->m_weight    = FrtosPrioToStkWeight(uxPriority);
 
    // Determine stack size in Words.
    size_t stack_words = (usStackDepth > 0U)
                         ? static_cast<size_t>(usStackDepth)
                         : FREERTOS_STK_DEFAULT_STACK_WORDS;
 
    if (stack_words < FREERTOS_STK_MIN_STACK_WORDS)
        stack_words = FREERTOS_STK_MIN_STACK_WORDS;
 
    t->m_stack = ObjAllocArray<stk::Word>(stack_words);
    if (t->m_stack == nullptr)
    {
        ObjFree(t);
        return pdFAIL;
    }
 
    t->m_stack_size  = stack_words;
    t->m_stack_owned = true;
 
    EnsureKernelInitialized();
 
    g_StkKernel.AddTask(t);
 
    if (pxCreatedTask != nullptr)
        *pxCreatedTask = static_cast<TaskHandle_t>(t);
 
    return pdPASS;
}

References EnsureKernelInitialized(), FREERTOS_STK_DEFAULT_STACK_WORDS, FREERTOS_STK_MIN_STACK_WORDS, FrtosPrioToStkWeight(), g_StkKernel, FrtosTask::m_argument, FrtosTask::m_func, FrtosTask::m_name, FrtosTask::m_stack, FrtosTask::m_stack_owned, FrtosTask::m_stack_size, FrtosTask::m_weight, ObjAlloc(), ObjAllocArray(), ObjFree(), pdFAIL, and pdPASS.

Referenced by xTaskCreateRestricted().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ xTaskCreateRestricted()

BaseType_t xTaskCreateRestricted	(	const TaskParameters_restricted_t *	pxTaskDefinition,
		TaskHandle_t *	pxCreatedTask )

Create a task with optional MPU region descriptors, allocating the TCB and stack from the heap (source-compatible with the FreeRTOS heap variant of xTaskCreateRestricted).

Note: STK does not implement MPU support. This function extracts pvTaskCode, usStackDepth, pvParameters, and uxPriority from pxTaskDefinition and delegates to xTaskCreate(), silently ignoring puxStackBuffer (a heap stack is allocated instead) and the xRegions table. When STK gains MPU support the implementation will be extended to program the region descriptors.

Parameters

pxTaskDefinition	Pointer to a TaskParameters_restricted_t descriptor. Must not be NULL.
pxCreatedTask	Optional: receives the handle of the created task.

Returns: pdPASS on success, pdFAIL if pxTaskDefinition is NULL or heap allocation fails.

Definition at line 1507 of file freertos_stk.cpp.

{
    // Mandatory pointer guard (only pvTaskCode is required; the caller need not
    // supply puxStackBuffer or pxTaskBuffer — both are heap-allocated here).
    if ((pxTaskDefinition == nullptr) ||
        (pxTaskDefinition->pvTaskCode == nullptr))
        return pdFAIL;
 
    // STK does not implement MPU support.  Forward to xTaskCreate() which
    // heap-allocates both the TCB and the task stack, accepting but ignoring
    // the xRegions MPU region table.
    // TODO: program pxTaskDefinition->xRegions into the MPU when STK gains
    //       hardware MPU support.
    return xTaskCreate(
        pxTaskDefinition->pvTaskCode,
        pxTaskDefinition->pcName,
        pxTaskDefinition->usStackDepth,
        pxTaskDefinition->pvParameters,
        pxTaskDefinition->uxPriority,
        pxCreatedTask);
}

References TaskParameters_restricted_t::pcName, pdFAIL, TaskParameters_restricted_t::pvParameters, TaskParameters_restricted_t::pvTaskCode, TaskParameters_restricted_t::usStackDepth, TaskParameters_restricted_t::uxPriority, and xTaskCreate().

Here is the call graph for this function:

◆ xTaskCreateRestrictedStatic()

BaseType_t xTaskCreateRestrictedStatic	(	const TaskParameters_restricted_t *	pxTaskDefinition,
		TaskHandle_t *	pxCreatedTask )

Create a task with caller-supplied static memory and optional MPU region descriptors (source-compatible with xTaskCreateRestricted).

Note: STK does not implement MPU support. This function is a forward- compatibility stub: it extracts the function, stack, priority, and pxTaskBuffer from pxTaskDefinition and delegates to xTaskCreateStatic(), silently ignoring the xRegions table. When STK gains MPU support the implementation will be extended to program the region descriptors.

Parameters

pxTaskDefinition	Pointer to a TaskParameters_restricted_t descriptor. Must not be NULL. puxStackBuffer and pxTaskBuffer inside the struct must also be non-NULL.
pxCreatedTask	Optional: receives the handle of the created task.

Returns: pdPASS on success, pdFAIL if any mandatory pointer is NULL.

Definition at line 1475 of file freertos_stk.cpp.

{
    // Mandatory pointer guard.
    if ((pxTaskDefinition == nullptr) ||
        (pxTaskDefinition->pvTaskCode     == nullptr) ||
        (pxTaskDefinition->puxStackBuffer == nullptr) ||
        (pxTaskDefinition->pxTaskBuffer   == nullptr))
        return pdFAIL;
 
    // STK does not implement MPU support.  Forward to xTaskCreateStatic(),
    // accepting but ignoring the xRegions MPU region table.
    // TODO: program pxTaskDefinition->xRegions into the MPU when STK gains
    //       hardware MPU support.
    TaskHandle_t h = xTaskCreateStatic(
        pxTaskDefinition->pvTaskCode,
        pxTaskDefinition->pcName,
        pxTaskDefinition->usStackDepth,
        pxTaskDefinition->pvParameters,
        pxTaskDefinition->uxPriority,
        pxTaskDefinition->puxStackBuffer,
        pxTaskDefinition->pxTaskBuffer);
 
    if (h == nullptr)
        return pdFAIL;
 
    if (pxCreatedTask != nullptr)
        *pxCreatedTask = h;
 
    return pdPASS;
}

References TaskParameters_restricted_t::pcName, pdFAIL, pdPASS, TaskParameters_restricted_t::puxStackBuffer, TaskParameters_restricted_t::pvParameters, TaskParameters_restricted_t::pvTaskCode, TaskParameters_restricted_t::pxTaskBuffer, TaskParameters_restricted_t::usStackDepth, TaskParameters_restricted_t::uxPriority, and xTaskCreateStatic().

Here is the call graph for this function:

◆ xTaskCreateStatic()

TaskHandle_t xTaskCreateStatic	(	TaskFunction_t	pvTaskCode,
		const char *	pcName,
		uint32_t	ulStackDepth,
		void *	pvParameters,
		UBaseType_t	uxPriority,
		StackType_t *	puxStackBuffer,
		StaticTask_t *	pxTaskBuffer )

Create a task using caller-supplied stack and TCB memory (no heap allocation).

Parameters

pvTaskCode	Task function pointer.
pcName	Descriptive name for debugging.
ulStackDepth	Stack depth in Words (not bytes). Must be >= configMINIMAL_STACK_SIZE.
pvParameters	Argument passed to pvTaskCode.
uxPriority	Priority: 0 = lowest, configMAX_PRIORITIES-1 = highest.
puxStackBuffer	Caller-allocated stack buffer of ulStackDepth Words. Must remain valid for the lifetime of the task.
pxTaskBuffer	Caller-allocated TCB buffer (StaticTask_t). Must remain valid for the lifetime of the task.

Returns: Task handle. Never NULL if all pointer arguments are non-NULL.

Definition at line 1153 of file freertos_stk.cpp.

{
    // All three pointer arguments are mandatory for static allocation.
    if ((pvTaskCode == nullptr) || (puxStackBuffer == nullptr) || (pxTaskBuffer == nullptr))
        return nullptr;
 
    // Placement-new the FrtosTask control block into the caller-supplied TCB
    // buffer.  Static assert guards against the buffer being too small.
    static_assert(sizeof(StaticTask_t) >= sizeof(FrtosTask),
        "StaticTask_t is too small to hold FrtosTask. "
        "Increase STATIC_TASK_TCB_SIZE_WORDS in freertos_stk.h.");
 
    FrtosTask *t = new (pxTaskBuffer) FrtosTask();
 
    t->m_func        = pvTaskCode;
    t->m_argument    = pvParameters;
    t->m_name        = pcName;
    t->m_weight      = FrtosPrioToStkWeight(uxPriority);
    t->m_stack       = static_cast<stk::Word *>(static_cast<void *>(puxStackBuffer));
    t->m_stack_size  = (ulStackDepth >= FREERTOS_STK_MIN_STACK_WORDS)
                       ? static_cast<size_t>(ulStackDepth)
                       : FREERTOS_STK_MIN_STACK_WORDS;
    t->m_stack_owned = false; // caller owns both the stack and the TCB
    t->m_cb_owned    = false; // destructor must not delete — caller owns memory
 
    EnsureKernelInitialized();
 
    g_StkKernel.AddTask(t);
 
    return static_cast<TaskHandle_t>(t);
}

References EnsureKernelInitialized(), FREERTOS_STK_MIN_STACK_WORDS, FrtosPrioToStkWeight(), g_StkKernel, FrtosTask::m_argument, FrtosTask::m_cb_owned, FrtosTask::m_func, FrtosTask::m_name, FrtosTask::m_stack, FrtosTask::m_stack_owned, FrtosTask::m_stack_size, and FrtosTask::m_weight.

Referenced by xTaskCreateRestrictedStatic().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ xTaskDelayUntil()

BaseType_t xTaskDelayUntil	(	TickType_t *	pxPreviousWakeTime,
		TickType_t	xTimeIncrement )

Delay until an absolute tick deadline (FreeRTOS 10.2+ name for vTaskDelayUntil). Updates *pxPreviousWakeTime on each call.

Returns: pdTRUE if the task delayed, pdFALSE if the deadline had already passed before the call was made (the task did not block).

Definition at line 1286 of file freertos_stk.cpp.

{
    if (IsIrqContext() || (pxPreviousWakeTime == nullptr))
        return pdFALSE;
 
    const stk::Ticks wake_at = static_cast<stk::Ticks>(*pxPreviousWakeTime) +
                               static_cast<stk::Ticks>(xTimeIncrement);
 
    *pxPreviousWakeTime = static_cast<TickType_t>(wake_at);
 
    return stk::SleepUntil(wake_at) ? pdTRUE : pdFALSE;
}

References IsIrqContext(), pdFALSE, pdTRUE, and stk::SleepUntil().

Referenced by vTaskDelayUntil().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ xTaskGetCurrentTaskHandle()

TaskHandle_t xTaskGetCurrentTaskHandle ( void )

Return the handle of the currently executing task.

Definition at line 1346 of file freertos_stk.cpp.

{
    if (IsIrqContext())
        return nullptr;
 
    return reinterpret_cast<TaskHandle_t>(static_cast<uintptr_t>(stk::GetTid()));
}

References stk::GetTid(), and IsIrqContext().

Referenced by pvTaskGetThreadLocalStoragePointer(), ResolveNotifyTarget(), and vTaskSetThreadLocalStoragePointer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ xTaskGetHandle()

TaskHandle_t xTaskGetHandle ( const char * pcNameToQuery )

Look up a task handle by name string (O(n) scan).

Returns: Handle of the first matching task, or NULL if not found.

Definition at line 1354 of file freertos_stk.cpp.

{
    if (pcNameToQuery == nullptr)
        return nullptr;
 
    // Enumerate all tasks and compare names.
    TaskHandle_t found = nullptr;
 
    g_StkKernel.EnumerateTasksT<FREERTOS_STK_MAX_TASKS>([&](stk::ITask *task) -> bool
    {
        if ((task->GetTraceName() != nullptr) &&
            (strcmp(task->GetTraceName(), pcNameToQuery) == 0))
        {
            found = static_cast<TaskHandle_t>(task);
            return false; // stop iteration
        }
        return true;
    });
 
    return found;
}

References FREERTOS_STK_MAX_TASKS, and g_StkKernel.

◆ xTaskGetSchedulerState()

BaseType_t xTaskGetSchedulerState ( void )

Return the current state of the FreeRTOS/STK scheduler.

Returns: One of taskSCHEDULER_NOT_STARTED, taskSCHEDULER_RUNNING, or taskSCHEDULER_SUSPENDED.

< Scheduler is running normally (STATE_RUNNING).

< Scheduler is suspended via vTaskSuspendAll() (STATE_SUSPENDED).

< Scheduler has not yet been started (STATE_INACTIVE / STATE_READY).

Definition at line 1088 of file freertos_stk.cpp.

{
    // Map the four STK kernel states onto the three FreeRTOS scheduler states:
    //   STATE_INACTIVE / STATE_READY -> NOT_STARTED  (scheduler never ran)
    //   STATE_RUNNING               -> RUNNING
    //   STATE_SUSPENDED             -> SUSPENDED
    switch (g_StkKernel.GetState())
    {
    case stk::IKernel::KSTATE_RUNNING:   return taskSCHEDULER_RUNNING;
    case stk::IKernel::KSTATE_SUSPENDED: return taskSCHEDULER_SUSPENDED;
    default:                             return taskSCHEDULER_NOT_STARTED;
    }
}

References g_StkKernel, stk::IKernel::KSTATE_RUNNING, stk::IKernel::KSTATE_SUSPENDED, taskSCHEDULER_NOT_STARTED, taskSCHEDULER_RUNNING, and taskSCHEDULER_SUSPENDED.

◆ xTaskGetTickCount()

TickType_t xTaskGetTickCount ( void )

Return the tick count since the scheduler started.

Definition at line 1072 of file freertos_stk.cpp.

{
    return static_cast<TickType_t>(stk::GetTicks());
}

References stk::GetTicks().

Here is the call graph for this function:

◆ xTaskGetTickCountFromISR()

TickType_t xTaskGetTickCountFromISR ( void )

Return the tick count from ISR context (ISR-safe).

Definition at line 1077 of file freertos_stk.cpp.

{
    return static_cast<TickType_t>(stk::GetTicks()); // GetTicks() is ISR-safe
}

References stk::GetTicks().

Here is the call graph for this function:

◆ xTaskNotify()

BaseType_t xTaskNotify	(	TaskHandle_t	xTaskToNotify,
		uint32_t	ulValue,
		eNotifyAction	eAction )

Send a notification to a task (slot 0) with a specific action on its value.

Parameters

ulValue	Value applied according to eAction.
eAction	How ulValue is applied to the task's notification value.

Returns: pdPASS, or pdFAIL if eSetValueWithoutOverwrite and already pending.

Definition at line 3386 of file freertos_stk.cpp.

{
    return xTaskNotifyIndexed(xTaskToNotify, 0U, ulValue, eAction);
}

References xTaskNotifyIndexed().

Here is the call graph for this function:

◆ xTaskNotifyAndQuery()

BaseType_t xTaskNotifyAndQuery	(	TaskHandle_t	xTaskToNotify,
		uint32_t	ulValue,
		eNotifyAction	eAction,
		uint32_t *	pulPreviousNotifyValue )

Send a notification to a task (slot 0) and return the previous notification value before the action was applied.

Parameters

xTaskToNotify	Target task handle (must not be NULL).
ulValue	Value applied according to eAction.
eAction	How ulValue is applied to the notification value.
pulPreviousNotifyValue	Receives the slot value before the action is applied. May be NULL.

Returns: pdPASS, or pdFAIL if eSetValueWithoutOverwrite and notification was already pending.

Note: ISR-safe.

Definition at line 3474 of file freertos_stk.cpp.

{
    return xTaskNotifyAndQueryIndexed(xTaskToNotify, 0U, ulValue, eAction,
                                      pulPreviousNotifyValue);
}

References xTaskNotifyAndQueryIndexed().

Here is the call graph for this function:

◆ xTaskNotifyAndQueryFromISR()

BaseType_t xTaskNotifyAndQueryFromISR	(	TaskHandle_t	xTaskToNotify,
		uint32_t	ulValue,
		eNotifyAction	eAction,
		uint32_t *	pulPreviousNotifyValue,
		BaseType_t *	pxHigherPriorityTaskWoken )

ISR-safe variant of xTaskNotifyAndQuery (slot 0).

Parameters

pxHigherPriorityTaskWoken Always set to pdFALSE (STK handles wake internally).

Note: ISR-safe.

Definition at line 3508 of file freertos_stk.cpp.

{
    return xTaskNotifyAndQueryFromISRIndexed(xTaskToNotify, 0U, ulValue, eAction,
                                             pulPreviousNotifyValue,
                                             pxHigherPriorityTaskWoken);
}

References xTaskNotifyAndQueryFromISRIndexed().

Here is the call graph for this function:

◆ xTaskNotifyAndQueryFromISRIndexed()

BaseType_t xTaskNotifyAndQueryFromISRIndexed	(	TaskHandle_t	xTaskToNotify,
		UBaseType_t	uxIndexToNotify,
		uint32_t	ulValue,
		eNotifyAction	eAction,
		uint32_t *	pulPreviousNotifyValue,
		BaseType_t *	pxHigherPriorityTaskWoken )

ISR-safe indexed variant of xTaskNotifyAndQuery.

Parameters

uxIndexToNotify	Notification slot index.
pxHigherPriorityTaskWoken	Always set to pdFALSE.

Note: ISR-safe.

Definition at line 3487 of file freertos_stk.cpp.

{
    BaseType_t result = xTaskNotifyAndQueryIndexed(xTaskToNotify, uxIndexToNotify,
                                                   ulValue, eAction,
                                                   pulPreviousNotifyValue);
 
    if (pxHigherPriorityTaskWoken != nullptr)
        *pxHigherPriorityTaskWoken = pdFALSE; // STK handles the context switch internally
 
    return result;
}

References pdFALSE, and xTaskNotifyAndQueryIndexed().

Referenced by xTaskNotifyAndQueryFromISR().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ xTaskNotifyAndQueryIndexed()

BaseType_t xTaskNotifyAndQueryIndexed	(	TaskHandle_t	xTaskToNotify,
		UBaseType_t	uxIndexToNotify,
		uint32_t	ulValue,
		eNotifyAction	eAction,
		uint32_t *	pulPreviousNotifyValue )

Indexed variant of xTaskNotifyAndQuery.

Parameters

uxIndexToNotify Notification slot index (0 .. configTASK_NOTIFICATION_ARRAY_ENTRIES-1).

Note: ISR-safe.

Definition at line 3440 of file freertos_stk.cpp.

{
    FrtosTask *t = ResolveNotifyTarget(xTaskToNotify, uxIndexToNotify);
    if (t == nullptr)
        return pdFAIL;
 
    FrtosTask::NotifySlot &slot = t->m_notify[uxIndexToNotify];
    BaseType_t result = pdPASS;
 
    {
        stk::sync::ScopedCriticalSection cs_;
 
        // Snapshot the value *before* the action — this is the only difference
        // from xTaskNotifyIndexed.
        if (pulPreviousNotifyValue != nullptr)
            *pulPreviousNotifyValue = slot.value;
 
        result = NotifyApplyAction(slot, ulValue, eAction);
    }
 
    if (result == pdPASS)
        slot.sem.Signal();
 
    return result;
}

References FrtosTask::m_notify, NotifyApplyAction(), pdFAIL, pdPASS, ResolveNotifyTarget(), FrtosTask::NotifySlot::sem, stk::sync::Semaphore::Signal(), and FrtosTask::NotifySlot::value.

Referenced by xTaskNotifyAndQuery(), and xTaskNotifyAndQueryFromISRIndexed().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ xTaskNotifyFromISR()

BaseType_t xTaskNotifyFromISR	(	TaskHandle_t	xTaskToNotify,
		uint32_t	ulValue,
		eNotifyAction	eAction,
		BaseType_t *	pxHigherPriorityTaskWoken )

Send a notification (slot 0) from ISR context.

Parameters

pxHigherPriorityTaskWoken Set pdTRUE if a context switch is needed (always pdFALSE in STK wrapper).

Definition at line 3402 of file freertos_stk.cpp.

{
    return xTaskNotifyFromISRIndexed(xTaskToNotify, 0U, ulValue, eAction,
                                     pxHigherPriorityTaskWoken);
}

References xTaskNotifyFromISRIndexed().

Here is the call graph for this function:

◆ xTaskNotifyFromISRIndexed()

BaseType_t xTaskNotifyFromISRIndexed	(	TaskHandle_t	xTaskToNotify,
		UBaseType_t	uxIndexToNotify,
		uint32_t	ulValue,
		eNotifyAction	eAction,
		BaseType_t *	pxHigherPriorityTaskWoken )

Send a notification to a specific slot from ISR context.

Parameters

uxIndexToNotify	Notification slot index.
pxHigherPriorityTaskWoken	Always set to pdFALSE (STK handles wake internally).

Definition at line 3358 of file freertos_stk.cpp.

{
    BaseType_t result = xTaskNotifyIndexed(xTaskToNotify, uxIndexToNotify, ulValue, eAction);
 
    if (pxHigherPriorityTaskWoken != nullptr)
        *pxHigherPriorityTaskWoken = pdFALSE;
 
    return result;
}

References pdFALSE, and xTaskNotifyIndexed().

Referenced by xTaskNotifyFromISR().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ xTaskNotifyGive()

BaseType_t xTaskNotifyGive ( TaskHandle_t xTaskToNotify )

Send a notification to a task (slot 0), incrementing its notification value by 1. Equivalent to xTaskNotify(xTaskToNotify, 0, eIncrement).

Returns: pdPASS.

Definition at line 3376 of file freertos_stk.cpp.

{
    return xTaskNotifyGiveIndexed(xTaskToNotify, 0U);
}

References xTaskNotifyGiveIndexed().

Here is the call graph for this function:

◆ xTaskNotifyGiveIndexed()

BaseType_t xTaskNotifyGiveIndexed	(	TaskHandle_t	xTaskToNotify,
		UBaseType_t	uxIndexToNotify )

Send a notification to a specific slot of a task, incrementing the slot's value by 1.

Parameters

uxIndexToNotify Notification slot index (0 .. configTASK_NOTIFICATION_ARRAY_ENTRIES-1).

Returns: pdPASS, or pdFAIL if the index is out of range.

Definition at line 3253 of file freertos_stk.cpp.

{
    FrtosTask *t = ResolveNotifyTarget(xTaskToNotify, uxIndexToNotify);
    if (t == nullptr)
        return pdFAIL;
 
    t->m_notify[uxIndexToNotify].sem.Signal(); // ISR-safe
    return pdPASS;
}

References FrtosTask::m_notify, pdFAIL, pdPASS, ResolveNotifyTarget(), FrtosTask::NotifySlot::sem, and stk::sync::Semaphore::Signal().

Referenced by xTaskNotifyGive().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ xTaskNotifyIndexed()

BaseType_t xTaskNotifyIndexed	(	TaskHandle_t	xTaskToNotify,
		UBaseType_t	uxIndexToNotify,
		uint32_t	ulValue,
		eNotifyAction	eAction )

Send a notification to a specific slot of a task with a chosen action.

Parameters

uxIndexToNotify	Notification slot index.
ulValue	Value applied according to eAction.
eAction	How ulValue is applied to the slot's value.

Returns: pdPASS, or pdFAIL on bad index or eSetValueWithoutOverwrite conflict.

Definition at line 3296 of file freertos_stk.cpp.

{
    FrtosTask *t = ResolveNotifyTarget(xTaskToNotify, uxIndexToNotify);
    if (t == nullptr)
        return pdFAIL;
 
    FrtosTask::NotifySlot &slot = t->m_notify[uxIndexToNotify];
    BaseType_t result = pdPASS;
 
    {
        stk::sync::ScopedCriticalSection cs_;
        result = NotifyApplyAction(slot, ulValue, eAction);
    }
 
    if (result == pdPASS)
        slot.sem.Signal();
 
    return result;
}

References FrtosTask::m_notify, NotifyApplyAction(), pdFAIL, pdPASS, ResolveNotifyTarget(), FrtosTask::NotifySlot::sem, and stk::sync::Semaphore::Signal().

Referenced by xTaskNotify(), and xTaskNotifyFromISRIndexed().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ xTaskNotifyStateClear()

BaseType_t xTaskNotifyStateClear ( TaskHandle_t xTask )

Clear the pending notification state for slot 0 of a task.

If a notification was pending (i.e. the task had been notified but had not yet called xTaskNotifyWait() or ulTaskNotifyTake() to consume it), this function clears the pending state and returns pdTRUE. If no notification was pending it returns pdFALSE.

Parameters

xTask Handle of the task whose notification state is to be cleared. NULL selects the calling task.

Returns: pdTRUE if a notification was pending and has been cleared, pdFALSE if no notification was pending.

Note: ISR-safe.

Definition at line 3577 of file freertos_stk.cpp.

{
    return xTaskNotifyStateClearIndexed(xTask, 0U);
}

References xTaskNotifyStateClearIndexed().

Here is the call graph for this function:

◆ xTaskNotifyStateClearIndexed()

BaseType_t xTaskNotifyStateClearIndexed	(	TaskHandle_t	xTask,
		UBaseType_t	uxIndexToClear )

Indexed variant of xTaskNotifyStateClear.

Parameters

xTask	Handle of the task. NULL selects the calling task.
uxIndexToClear	Notification slot index (0 .. configTASK_NOTIFICATION_ARRAY_ENTRIES-1).

Returns: pdTRUE if a notification was pending, pdFALSE otherwise.

Note: ISR-safe.

Definition at line 3542 of file freertos_stk.cpp.

{
    FrtosTask *t = ResolveNotifyTarget(xTask, uxIndexToClear);
    if (t == nullptr)
        return pdFALSE;
 
    FrtosTask::NotifySlot &slot = t->m_notify[uxIndexToClear];
 
    stk::sync::ScopedCriticalSection cs_;
 
    // Determine whether a notification was pending before we clear anything.
    // A notification is considered "pending" when the semaphore has a count
    // (i.e. Signal() was called but Wait/Take has not yet consumed it) OR
    // when the value-without-overwrite guard flag is set.
    const bool was_pending = (slot.sem.GetCount() != 0U) || slot.pending;
 
    if (was_pending)
    {
        // Drain the semaphore (binary, at most 1 token to consume).
        slot.sem.TryWait();
 
        // Clear the eSetValueWithoutOverwrite pending guard so that a
        // subsequent xTaskNotify(eSetValueWithoutOverwrite) can write a new
        // value without being rejected.
        slot.pending = false;
    }
 
    return was_pending ? pdTRUE : pdFALSE;
}

References stk::sync::Semaphore::GetCount(), FrtosTask::m_notify, pdFALSE, pdTRUE, FrtosTask::NotifySlot::pending, ResolveNotifyTarget(), FrtosTask::NotifySlot::sem, and stk::sync::Semaphore::TryWait().

Referenced by xTaskNotifyStateClear().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ xTaskNotifyWait()

BaseType_t xTaskNotifyWait	(	uint32_t	ulBitsToClearOnEntry,
		uint32_t	ulBitsToClearOnExit,
		uint32_t *	pulNotificationValue,
		TickType_t	xTicksToWait )

Wait for a notification (slot 0), with optional bit-masking on entry and exit.

Parameters

ulBitsToClearOnEntry	Bits cleared before blocking.
ulBitsToClearOnExit	Bits cleared before returning.
pulNotificationValue	Receives the value before the exit-clear (may be NULL).
xTicksToWait	Ticks to wait.

Returns: pdTRUE if notified, pdFALSE on timeout.

Definition at line 3393 of file freertos_stk.cpp.

{
    return xTaskNotifyWaitIndexed(0U, ulBitsToClearOnEntry, ulBitsToClearOnExit,
                                  pulNotificationValue, xTicksToWait);
}

References xTaskNotifyWaitIndexed().

Here is the call graph for this function:

◆ xTaskNotifyWaitIndexed()

BaseType_t xTaskNotifyWaitIndexed	(	UBaseType_t	uxIndexToWait,
		uint32_t	ulBitsToClearOnEntry,
		uint32_t	ulBitsToClearOnExit,
		uint32_t *	pulNotificationValue,
		TickType_t	xTicksToWait )

Wait for a notification on a specific slot of the calling task.

Parameters

uxIndexToWait	Notification slot index.
ulBitsToClearOnEntry	Bits cleared in the slot value before blocking.
ulBitsToClearOnExit	Bits cleared in the slot value before returning.
pulNotificationValue	Receives the slot value before the exit-clear (may be NULL).
xTicksToWait	Ticks to wait.

Returns: pdTRUE if notified, pdFALSE on timeout or bad index.

Definition at line 3319 of file freertos_stk.cpp.

{
    if (IsIrqContext())
        return pdFAIL;
 
    FrtosTask *t = ResolveNotifyTarget(nullptr, uxIndexToWait);
    if (t == nullptr)
        return pdFAIL;
 
    FrtosTask::NotifySlot &slot = t->m_notify[uxIndexToWait];
 
    // Clear entry bits before blocking.
    {
        stk::sync::ScopedCriticalSection cs_;
        slot.value &= ~ulBitsToClearOnEntry;
    }
 
    // Block until notified or timeout.
    if (!slot.sem.Wait(FrtosTimeoutToStk(xTicksToWait)))
        return pdFAIL;
 
    // Read and apply exit-clear.
    {
        stk::sync::ScopedCriticalSection cs_;
 
        if (pulNotificationValue != nullptr)
            *pulNotificationValue = slot.value;
 
        slot.value  &= ~ulBitsToClearOnExit;
        slot.pending = false;
    }
 
    return pdPASS;
}

References FrtosTimeoutToStk(), IsIrqContext(), FrtosTask::m_notify, pdFAIL, pdPASS, FrtosTask::NotifySlot::pending, ResolveNotifyTarget(), FrtosTask::NotifySlot::sem, FrtosTask::NotifySlot::value, and stk::sync::Semaphore::Wait().

Referenced by xTaskNotifyWait().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ xTaskResumeAll()

BaseType_t xTaskResumeAll ( void )

Resume a previously suspended scheduler.

Returns: pdTRUE if a context switch is pending, pdFALSE otherwise.

Definition at line 1066 of file freertos_stk.cpp.

{
    stk::hw::CriticalSection::Exit();
    return pdFALSE; // no pending switch tracked at wrapper level
}

References stk::hw::CriticalSection::Exit(), and pdFALSE.

Here is the call graph for this function:

◆ xTaskResumeFromISR()

BaseType_t xTaskResumeFromISR ( TaskHandle_t xTaskToResume )

Resume a previously suspended task from ISR context.

Returns: pdTRUE if the task was successfully resumed.

Definition at line 1239 of file freertos_stk.cpp.

{
    if (xTaskToResume == nullptr)
        return pdFALSE;
 
    FrtosTask *t = static_cast<FrtosTask *>(xTaskToResume);
 
    stk::sync::ScopedCriticalSection cs_;
 
    if (t->m_state != FrtosTask::State::Suspended)
        return pdFALSE;
 
    g_StkKernel.ResumeTask(t);
    t->m_state = FrtosTask::State::Ready;
 
    return pdTRUE;
}

References g_StkKernel, FrtosTask::m_state, pdFALSE, pdTRUE, FrtosTask::Ready, and FrtosTask::Suspended.

◆ xTimerChangePeriod()

BaseType_t xTimerChangePeriod	(	TimerHandle_t	xTimer,
		TickType_t	xNewPeriod,
		TickType_t	xTicksToWait )

Change the period of a timer and restart it immediately.

Returns: pdPASS on success.

Definition at line 2687 of file freertos_stk.cpp.

{
    if ((xTimer == nullptr) || (xNewPeriod == 0U))
        return pdFAIL;
 
    FrtosTimer *t = static_cast<FrtosTimer *>(xTimer);
    t->m_period   = xNewPeriod;
 
    return xTimerStart(xTimer, xTicksToWait);
}

References FrtosTimer::m_period, pdFAIL, and xTimerStart().

Here is the call graph for this function:

◆ xTimerChangePeriodFromISR()

BaseType_t xTimerChangePeriodFromISR	(	TimerHandle_t	xTimer,
		TickType_t	xNewPeriod,
		BaseType_t *	pxHigherPriorityTaskWoken )

Change the period of a timer and restart it from ISR context.

Parameters

xNewPeriod	New timer period in ticks (must be > 0).
pxHigherPriorityTaskWoken	Always set to pdFALSE.

Returns: pdPASS on success, pdFAIL if the command queue is full or arguments are invalid.

Definition at line 2761 of file freertos_stk.cpp.

{
    if (pxHigherPriorityTaskWoken != nullptr)
        *pxHigherPriorityTaskWoken = pdFALSE;
 
    if ((xTimer == nullptr) || (xNewPeriod == 0U) || (g_TimerHost == nullptr))
        return pdFAIL;
 
    FrtosTimer *t = static_cast<FrtosTimer *>(xTimer);
    t->m_period   = xNewPeriod;
 
    // Restart with the new period, taking effect immediately.
    uint32_t period = t->m_auto_reload ? static_cast<uint32_t>(xNewPeriod) : 0U;
 
    return g_TimerHost->Restart(*t, static_cast<uint32_t>(xNewPeriod), period) ? pdPASS : pdFAIL;
}

References g_TimerHost, FrtosTimer::m_auto_reload, FrtosTimer::m_period, pdFAIL, pdFALSE, and pdPASS.

◆ xTimerCreate()

TimerHandle_t xTimerCreate	(	const char *	pcTimerName,
		TickType_t	xTimerPeriodInTicks,
		UBaseType_t	uxAutoReload,
		void *	pvTimerID,
		TimerCallbackFunction_t	pxCallbackFunction )

Create a software timer.

Parameters

pcTimerName	Name for debugging.
xTimerPeriodInTicks	Period in ticks (must be > 0).
uxAutoReload	pdTRUE = periodic, pdFALSE = one-shot.
pvTimerID	Application-defined value stored in the timer.
pxCallbackFunction	Callback invoked on expiry.

Returns: Timer handle, or NULL on failure.

Definition at line 2585 of file freertos_stk.cpp.

{
    if (IsIrqContext() || (pxCallbackFunction == nullptr) || (xTimerPeriodInTicks == 0U))
        return nullptr;
 
    if (!FrtosTimer::EnsureTimerHost())
        return nullptr;
 
    FrtosTimer *t = ObjAlloc<FrtosTimer>(
        pcTimerName,
        xTimerPeriodInTicks,
        (uxAutoReload == pdTRUE),
        pvTimerID,
        pxCallbackFunction);
 
    return static_cast<TimerHandle_t>(t);
}

References FrtosTimer::EnsureTimerHost(), IsIrqContext(), ObjAlloc(), and pdTRUE.

Here is the call graph for this function:

◆ xTimerCreateStatic()

TimerHandle_t xTimerCreateStatic	(	const char *	pcTimerName,
		TickType_t	xTimerPeriodInTicks,
		UBaseType_t	uxAutoReload,
		void *	pvTimerID,
		TimerCallbackFunction_t	pxCallbackFunction,
		StaticTimer_t *	pxTimerBuffer )

Create a software timer using caller-supplied storage — no heap allocation.

Parameters

pcTimerName	Name for debugging.
xTimerPeriodInTicks	Period in ticks (must be > 0).
uxAutoReload	pdTRUE = periodic, pdFALSE = one-shot.
pvTimerID	Application-defined value stored in the timer.
pxCallbackFunction	Callback invoked on expiry.
pxTimerBuffer	Caller-allocated control block (StaticTimer_t). Must remain valid for the lifetime of the timer.

Returns: Timer handle. Never NULL if pxTimerBuffer is non-NULL, pxCallbackFunction is non-NULL and xTimerPeriodInTicks > 0.

Definition at line 2607 of file freertos_stk.cpp.

{
    if (pxTimerBuffer == nullptr)
        return nullptr;
 
    if (IsIrqContext() || (pxCallbackFunction == nullptr) || (xTimerPeriodInTicks == 0U))
        return nullptr;
 
    if (!FrtosTimer::EnsureTimerHost())
        return nullptr;
 
    static_assert(sizeof(StaticTimer_t) >= sizeof(FrtosTimer),
        "StaticTimer_t is too small to hold FrtosTimer. "
        "Increase STATIC_TIMER_TCB_SIZE_WORDS in freertos_stk.h.");
 
    // Placement-new the FrtosTimer into the caller-supplied buffer.
    FrtosTimer *t = new (pxTimerBuffer) FrtosTimer(
        pcTimerName,
        xTimerPeriodInTicks,
        (uxAutoReload == pdTRUE),
        pvTimerID,
        pxCallbackFunction);
 
    t->m_cb_owned = false; // caller owns the memory; xTimerDelete must not delete it
 
    return static_cast<TimerHandle_t>(t);
}

References FrtosTimer::EnsureTimerHost(), IsIrqContext(), FrtosTimer::m_cb_owned, and pdTRUE.

Here is the call graph for this function:

◆ xTimerDelete()

BaseType_t xTimerDelete	(	TimerHandle_t	xTimer,
		TickType_t	xTicksToWait )

Delete a software timer and free its memory.

Returns: pdPASS.

Definition at line 2640 of file freertos_stk.cpp.

{
    if (xTimer == nullptr)
        return pdFAIL;
 
    FrtosTimer *t = static_cast<FrtosTimer *>(xTimer);
 
    if ((g_TimerHost != nullptr) && t->IsActive())
        g_TimerHost->Stop(*t);
 
    ObjFree(t);
    return pdPASS;
}

References g_TimerHost, stk::time::TimerHost::Timer::IsActive(), ObjFree(), pdFAIL, and pdPASS.

Here is the call graph for this function:

◆ xTimerGetExpiryTime()

TickType_t xTimerGetExpiryTime ( TimerHandle_t xTimer )

Return the absolute tick count at which the timer will next expire. Returns 0 if the timer is not currently running.

Definition at line 2915 of file freertos_stk.cpp.

{
    if ((xTimer == nullptr) || (g_TimerHost == nullptr))
        return 0U;
 
    FrtosTimer *t = static_cast<FrtosTimer *>(xTimer);
    return t->IsActive() ? static_cast<TickType_t>(t->GetDeadline()) : 0U;
}

References g_TimerHost, stk::time::TimerHost::Timer::GetDeadline(), and stk::time::TimerHost::Timer::IsActive().

Here is the call graph for this function:

◆ xTimerGetPeriod()

TickType_t xTimerGetPeriod ( TimerHandle_t xTimer )

Return the period of a timer in ticks.

Definition at line 2907 of file freertos_stk.cpp.

{
    if (xTimer == nullptr)
        return 0U;
 
    return static_cast<FrtosTimer *>(xTimer)->m_period;
}

◆ xTimerIsTimerActive()

BaseType_t xTimerIsTimerActive ( TimerHandle_t xTimer )

Query whether a timer is currently active (running).

Returns: pdTRUE if active, pdFALSE if stopped or expired.

Definition at line 2875 of file freertos_stk.cpp.

{
    if (xTimer == nullptr)
        return pdFALSE;
 
    return static_cast<FrtosTimer *>(xTimer)->IsActive() ? pdTRUE : pdFALSE;
}

References pdFALSE, and pdTRUE.

◆ xTimerPendFunctionCall()

BaseType_t xTimerPendFunctionCall	(	PendedFunction_t	xFunctionToPend,
		void *	pvParameter1,
		uint32_t	ulParameter2,
		TickType_t	xTicksToWait )

Defer execution of a function to the timer-task context (task-context variant).

Writes a PendCall record {xFunctionToPend, pvParameter1, ulParameter2} into the static g_PendCallPipe (PipeT<PendCall, FREERTOS_STK_PEND_CALL_QUEUE_SIZE>). The TimerHost handler task drains the pipe on each wake cycle and invokes every callback directly — no heap allocation is performed, no self-deleting timer object is created.

Note: Requires the TimerHost to have been started (at least one timer created or xTimerPendFunctionCall called after vTaskStartScheduler). If the TimerHost has not yet been initialized this function initializes it implicitly, matching FreeRTOS behaviour.; If the static pipe is full this function blocks for up to xTicksToWait ticks waiting for a free slot (PipeT::Write blocking semantics). Pass 0 for a non-blocking attempt.

Parameters

xFunctionToPend	Callback to invoke in the timer-task context. Signature: void cb(void *pvParam1, uint32_t ulParam2).
pvParameter1	First argument forwarded to the callback.
ulParameter2	Second argument forwarded to the callback.
xTicksToWait	Ticks to wait if the pipe is full. portMAX_DELAY blocks indefinitely.

Returns: pdPASS on success, pdFAIL if the pipe was full and the timeout expired.

Warning: ISR-unsafe. Use xTimerPendFunctionCallFromISR() from interrupt context.

Definition at line 2816 of file freertos_stk.cpp.

{
    // API contract: must not be called from ISR context.
    if (IsIrqContext())
        return pdFAIL;
 
    if (xFunctionToPend == nullptr)
        return pdFAIL;
 
    // Ensure the TimerHost (and hence the drainer's scheduling context) exists.
    if (!FrtosTimer::EnsureTimerHost())
        return pdFAIL;
 
    // Write the call record into the static pipe (blocking with timeout).
    // PipeT::Write() acquires a ScopedCriticalSection internally.
    const PendCall call = { xFunctionToPend, pvParameter1, ulParameter2 };
    if (!g_PendCallPipe.Write(call, FrtosTimeoutToStk(xTicksToWait)))
        return pdFAIL;
 
    // (Re-)start the singleton drainer so it wakes within 1 tick.
    // EnsurePendDrainer() constructs the drainer on first call and
    // calls TimerHost::Restart() which is task-safe.
    EnsurePendDrainer();
 
    return pdPASS;
}

References EnsurePendDrainer(), FrtosTimer::EnsureTimerHost(), FrtosTimeoutToStk(), g_PendCallPipe, IsIrqContext(), pdFAIL, and pdPASS.

Here is the call graph for this function:

◆ xTimerPendFunctionCallFromISR()

BaseType_t xTimerPendFunctionCallFromISR	(	PendedFunction_t	xFunctionToPend,
		void *	pvParameter1,
		uint32_t	ulParameter2,
		BaseType_t *	pxHigherPriorityTaskWoken )

Defer execution of a function to the timer-task context (ISR-safe variant).

Identical in effect to xTimerPendFunctionCall() but safe to call from an interrupt service routine. The call record is written into a static PipeT<PendCall, FREERTOS_STK_PEND_CALL_QUEUE_SIZE> with NO_WAIT semantics — no heap allocation is performed. If the pipe is full the function returns pdFAIL immediately.

Parameters

xFunctionToPend	Callback to invoke in the timer-task context.
pvParameter1	First argument forwarded to the callback.
ulParameter2	Second argument forwarded to the callback.
pxHigherPriorityTaskWoken	Always set to pdFALSE (STK wakes the timer task internally; no manual yield required).

Returns: pdPASS on success, pdFAIL if the static queue was full.

Definition at line 2846 of file freertos_stk.cpp.

{
    // STK wakes the tick task internally; no manual context switch needed.
    if (pxHigherPriorityTaskWoken != nullptr)
        *pxHigherPriorityTaskWoken = pdFALSE;
 
    if (xFunctionToPend == nullptr)
        return pdFAIL;
 
    // From ISR the TimerHost must already be running (a timer was created
    // before the ISR fired — the only realistic usage pattern).
    if (g_TimerHost == nullptr)
        return pdFAIL;
 
    // Non-blocking enqueue: TryWrite() holds a ScopedCriticalSection internally
    // — unconditionally ISR-safe, no allocator call, no blocking.
    const PendCall call = { xFunctionToPend, pvParameter1, ulParameter2 };
    if (!g_PendCallPipe.TryWrite(call))
        return pdFAIL;
 
    // Kick the drainer via ISR-safe TimerHost::Restart().
    KickPendDrainerFromISR();
 
    return pdPASS;
}

References g_PendCallPipe, g_TimerHost, KickPendDrainerFromISR(), pdFAIL, pdFALSE, and pdPASS.

Here is the call graph for this function:

◆ xTimerReset()

BaseType_t xTimerReset	(	TimerHandle_t	xTimer,
		TickType_t	xTicksToWait )

Reset a timer (restart its period from the current tick).

Returns: pdPASS on success.

Definition at line 2682 of file freertos_stk.cpp.

{
    return xTimerStart(xTimer, xTicksToWait); // Restart restarts from now
}

References xTimerStart().

Here is the call graph for this function:

◆ xTimerResetFromISR()

BaseType_t xTimerResetFromISR	(	TimerHandle_t	xTimer,
		BaseType_t *	pxHigherPriorityTaskWoken )

Reset (restart the period of) a timer from ISR context.

Parameters

pxHigherPriorityTaskWoken Always set to pdFALSE.

Returns: pdPASS on success, pdFAIL if the command queue is full or handle is invalid.

Definition at line 2754 of file freertos_stk.cpp.

{
    // Reset = Restart from now, same as xTimerStart.
    return xTimerStartFromISR(xTimer, pxHigherPriorityTaskWoken);
}

References xTimerStartFromISR().

Here is the call graph for this function:

◆ xTimerStart()

BaseType_t xTimerStart	(	TimerHandle_t	xTimer,
		TickType_t	xTicksToWait )

Start (or restart) a timer from the current tick.

Returns: pdPASS on success, pdFAIL on error.

Definition at line 2654 of file freertos_stk.cpp.

{
    if (IsIrqContext() || (xTimer == nullptr) || (g_TimerHost == nullptr))
        return pdFAIL;
 
    FrtosTimer *t = static_cast<FrtosTimer *>(xTimer);
 
    uint32_t period = t->m_auto_reload
                      ? static_cast<uint32_t>(t->m_period)
                      : 0U; // 0 = one-shot (no reload period)
 
    return g_TimerHost->Restart(*t, static_cast<uint32_t>(t->m_period), period)
           ? pdPASS : pdFAIL;
}

References g_TimerHost, IsIrqContext(), FrtosTimer::m_auto_reload, FrtosTimer::m_period, pdFAIL, and pdPASS.

Referenced by xTimerChangePeriod(), and xTimerReset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ xTimerStartFromISR()

BaseType_t xTimerStartFromISR	(	TimerHandle_t	xTimer,
		BaseType_t *	pxHigherPriorityTaskWoken )

Start (or restart) a timer from ISR context.

Parameters

pxHigherPriorityTaskWoken Always set to pdFALSE.

Returns: pdPASS on success, pdFAIL if the command queue is full or handle is invalid.

Definition at line 2721 of file freertos_stk.cpp.

{
    if (pxHigherPriorityTaskWoken != nullptr)
        *pxHigherPriorityTaskWoken = pdFALSE;
 
    if ((xTimer == nullptr) || (g_TimerHost == nullptr))
        return pdFAIL;
 
    FrtosTimer *t  = static_cast<FrtosTimer *>(xTimer);
    uint32_t period = t->m_auto_reload ? static_cast<uint32_t>(t->m_period) : 0U;
 
    return g_TimerHost->Restart(*t, static_cast<uint32_t>(t->m_period), period)
           ? pdPASS : pdFAIL;
}

References g_TimerHost, FrtosTimer::m_auto_reload, FrtosTimer::m_period, pdFAIL, pdFALSE, and pdPASS.

Referenced by xTimerResetFromISR().

Here is the caller graph for this function:

◆ xTimerStop()

BaseType_t xTimerStop	(	TimerHandle_t	xTimer,
		TickType_t	xTicksToWait )

Stop a running timer.

Returns: pdPASS on success, pdFAIL if the timer was not running.

Definition at line 2669 of file freertos_stk.cpp.

{
    if (IsIrqContext() || (xTimer == nullptr) || (g_TimerHost == nullptr))
        return pdFAIL;
 
    FrtosTimer *t = static_cast<FrtosTimer *>(xTimer);
 
    if (!t->IsActive())
        return pdFAIL;
 
    return g_TimerHost->Stop(*t) ? pdPASS : pdFAIL;
}

References g_TimerHost, stk::time::TimerHost::Timer::IsActive(), IsIrqContext(), pdFAIL, and pdPASS.

Here is the call graph for this function:

◆ xTimerStopFromISR()

BaseType_t xTimerStopFromISR	(	TimerHandle_t	xTimer,
		BaseType_t *	pxHigherPriorityTaskWoken )

Stop a running timer from ISR context.

Parameters

pxHigherPriorityTaskWoken Always set to pdFALSE.

Returns: pdPASS on success, pdFAIL if the timer is not running or handle is invalid.

Definition at line 2737 of file freertos_stk.cpp.

{
    if (pxHigherPriorityTaskWoken != nullptr)
        *pxHigherPriorityTaskWoken = pdFALSE;
 
    if ((xTimer == nullptr) || (g_TimerHost == nullptr))
        return pdFAIL;
 
    FrtosTimer *t = static_cast<FrtosTimer *>(xTimer);
 
    if (!t->IsActive())
        return pdFAIL;
 
    return g_TimerHost->Stop(*t) ? pdPASS : pdFAIL;
}

References g_TimerHost, stk::time::TimerHost::Timer::IsActive(), pdFAIL, pdFALSE, and pdPASS.

Here is the call graph for this function:

Classes

Macros

Typedefs

Enumerations

Functions

Detailed Description

Macro Definition Documentation

◆ configMAX_PRIORITIES

◆ configMINIMAL_STACK_SIZE

◆ configNUM_THREAD_LOCAL_STORAGE_POINTERS

◆ configSTACK_DEPTH_TYPE

◆ configTASK_NOTIFICATION_ARRAY_ENTRIES

◆ configTICK_RATE_HZ

◆ configTOTAL_HEAP_SIZE

◆ configUSE_COUNTING_SEMAPHORES

◆ configUSE_EVENT_GROUPS

◆ configUSE_MUTEXES

◆ configUSE_QUEUE_SETS

◆ configUSE_STREAM_BUFFERS

◆ configUSE_TASK_NOTIFICATIONS

◆ configUSE_TIMERS

◆ errQUEUE_EMPTY

◆ errQUEUE_FULL

◆ FREERTOS_STK_DEFAULT_STACK_WORDS

◆ FREERTOS_STK_MAX_TASKS

◆ FREERTOS_STK_PEND_CALL_QUEUE_SIZE

◆ pdFAIL

◆ pdFALSE

◆ pdMS_TO_TICKS

◆ pdPASS

◆ pdTRUE

◆ portMAX_DELAY

◆ portNUM_CONFIGURABLE_REGIONS

◆ portYIELD

◆ STATIC_EVENT_GROUP_TCB_SIZE_WORDS

◆ STATIC_MESSAGE_BUFFER_TCB_SIZE_WORDS

◆ STATIC_QUEUE_TCB_SIZE_WORDS

◆ STATIC_SEMAPHORE_TCB_SIZE_WORDS

◆ STATIC_STREAM_BUFFER_TCB_SIZE_WORDS

◆ STATIC_TASK_TCB_SIZE_WORDS

◆ STATIC_TIMER_TCB_SIZE_WORDS

◆ taskDISABLE_INTERRUPTS

◆ taskENABLE_INTERRUPTS

◆ taskENTER_CRITICAL

◆ taskEXIT_CRITICAL

◆ taskSCHEDULER_NOT_STARTED

◆ taskSCHEDULER_RUNNING

◆ taskSCHEDULER_SUSPENDED

◆ taskYIELD

◆ tskIDLE_PRIORITY

◆ xTaskHandle

Typedef Documentation

◆ BaseType_t

◆ EventBits_t

◆ EventGroupHandle_t

◆ MessageBufferHandle_t

◆ PendedFunction_t

◆ portBASE_TYPE

◆ QueueHandle_t

◆ QueueSetHandle_t

◆ QueueSetMemberHandle_t

◆ SemaphoreHandle_t

◆ StackType_t

◆ StreamBufferCallbackFunction_t

◆ StreamBufferHandle_t

◆ TaskFunction_t

◆ TaskHandle_t

◆ TickType_t

◆ TimerCallbackFunction_t

◆ TimerHandle_t

◆ UBaseType_t

Enumeration Type Documentation

◆ eNotifyAction

◆ eTaskState

Function Documentation

◆ eTaskGetState()

◆ pcTaskGetName()

◆ pcTimerGetName()

◆ pvPortMalloc()

◆ pvTaskGetThreadLocalStoragePointer()