ggw/chest_strap
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

BLE streaming of sensor data working

Browse Source
This commit is contained in:
ggw
2026-04-30 18:14:35 -05:00
parent b6e40323e3
commit 42f91eb075
107 changed files with 39837 additions and 35 deletions
Download Patch File Download Diff File Expand all files Collapse all files
code/wb1mmc_code/Utilities/sequencer/stm32_seq.c
+686
View File
@@ -0,0 +1,686 @@
/**
******************************************************************************
* @file stm32_seq.c
* @author MCD Application Team
* @brief Simple sequencer implementation
******************************************************************************
* @attention
*
* <h2><center>&copy; Copyright (c) 2019 STMicroelectronics.
* All rights reserved.</center></h2>
*
* This software is licensed under terms that can be found in the LICENSE file
* in the root directory of this software component.
* If no LICENSE file comes with this software, it is provided AS-IS.
*
******************************************************************************
*/
/* Includes ------------------------------------------------------------------*/
#include "stm32_seq.h"
#include "utilities_conf.h"
/** @addtogroup SEQUENCER
* @{
*/
/* Private typedef -----------------------------------------------------------*/
/** @defgroup SEQUENCER_Private_type SEQUENCER private type
* @{
*/
/**
* @brief structure used to manage task scheduling
*/
typedef struct
{
uint32_t priority; /*!<bit field of the enabled task. */
uint32_t round_robin; /*!<mask on the allowed task to be running. */
} UTIL_SEQ_Priority_t;
/**
* @}
*/
/* Private defines -----------------------------------------------------------*/
/** @defgroup SEQUENCER_Private_define SEQUENCER private defines
* @{
*/
/**
* @brief macro used to enter the critical section before calling the IDLE function
* @note in a basic configuration shall be identical to the macro
* UTIL_SEQ_ENTER_CRITICAL_SECTION. The redefinition of this macro will allow
* to perform specific operation
*/
#ifndef UTIL_SEQ_ENTER_CRITICAL_SECTION_IDLE
#define UTIL_SEQ_ENTER_CRITICAL_SECTION_IDLE( ) UTIL_SEQ_ENTER_CRITICAL_SECTION( )
#endif /* UTIL_SEQ_ENTER_CRITICAL_SECTION_IDLE */
/**
* @brief macro used to exit the critical section when exiting the IDLE function
* @note the behavior of the macro shall be symmetrical with the macro
* UTIL_SEQ_ENTER_CRITICAL_SECTION_IDLE
*/
#ifndef UTIL_SEQ_EXIT_CRITICAL_SECTION_IDLE
#define UTIL_SEQ_EXIT_CRITICAL_SECTION_IDLE( ) UTIL_SEQ_EXIT_CRITICAL_SECTION( )
#endif /* UTIL_SEQ_EXIT_CRITICAL_SECTION_IDLE */
/**
* @brief define to represent no task running
*/
#define UTIL_SEQ_NOTASKRUNNING (0xFFFFFFFFU)
/**
* @brief define to represent no bit set inside uint32_t mapping
*/
#define UTIL_SEQ_NO_BIT_SET (0U)
/**
* @brief define to represent all bits set inside uint32_t mapping
*/
#define UTIL_SEQ_ALL_BIT_SET (~0U)
/**
* @brief default number of task is default 32 (maximum), can be reduced by redefining in utilities_conf.h
*/
#ifndef UTIL_SEQ_CONF_TASK_NBR
#define UTIL_SEQ_CONF_TASK_NBR (32)
#endif /* UTIL_SEQ_CONF_TASK_NBR */
#if UTIL_SEQ_CONF_TASK_NBR > 32
#error "UTIL_SEQ_CONF_TASK_NBR must be less than or equal to 32"
#endif /* UTIL_SEQ_CONF_TASK_NBR */
/**
* @brief default value of priority number.
*/
#ifndef UTIL_SEQ_CONF_PRIO_NBR
#define UTIL_SEQ_CONF_PRIO_NBR (2)
#endif /* UTIL_SEQ_CONF_PRIO_NBR */
/**
* @brief default memset function.
*/
#ifndef UTIL_SEQ_MEMSET8
#define UTIL_SEQ_MEMSET8( dest, value, size ) UTILS_MEMSET8( dest, value, size )
#endif /* UTIL_SEQ_MEMSET8 */
/**
* @}
*/
/* Private variables ---------------------------------------------------------*/
/** @defgroup SEQUENCER_Private_varaible SEQUENCER private variables
* @{
*/
/**
* @brief task set.
*/
static volatile UTIL_SEQ_bm_t TaskSet;
/**
* @brief task mask.
*/
static volatile UTIL_SEQ_bm_t TaskMask = UTIL_SEQ_ALL_BIT_SET;
/**
* @brief super mask.
*/
static UTIL_SEQ_bm_t SuperMask = UTIL_SEQ_ALL_BIT_SET;
/**
* @brief evt set mask.
*/
static volatile UTIL_SEQ_bm_t EvtSet = UTIL_SEQ_NO_BIT_SET;
/**
* @brief evt expected mask.
*/
static volatile UTIL_SEQ_bm_t EvtWaited = UTIL_SEQ_NO_BIT_SET;
/**
* @brief current task id.
*/
static uint32_t CurrentTaskIdx = 0U;
/**
* @brief task function registered.
*/
static void (*TaskCb[UTIL_SEQ_CONF_TASK_NBR])( void );
/**
* @brief task prio management.
*/
static volatile UTIL_SEQ_Priority_t TaskPrio[UTIL_SEQ_CONF_PRIO_NBR];
/**
* @brief List of the cleared task
*/
static UTIL_SEQ_bm_t TaskClearList = 0;
/**
* @}
*/
/* Private function prototypes -----------------------------------------------*/
/** @defgroup SEQUENCER_Private_function SEQUENCER private functions
* @{
*/
uint8_t SEQ_BitPosition(uint32_t Value);
/**
* @}
*/
/* Functions Definition ------------------------------------------------------*/
/** @addtogroup SEQUENCER_Exported_function SEQUENCER exported functions
* @{
*/
void UTIL_SEQ_Init( void )
{
TaskSet = UTIL_SEQ_NO_BIT_SET;
TaskMask = UTIL_SEQ_ALL_BIT_SET;
SuperMask = UTIL_SEQ_ALL_BIT_SET;
EvtSet = UTIL_SEQ_NO_BIT_SET;
EvtWaited = UTIL_SEQ_NO_BIT_SET;
CurrentTaskIdx = 0U;
(void)UTIL_SEQ_MEMSET8((uint8_t *)TaskCb, 0, sizeof(TaskCb));
for(uint32_t index = 0; index < UTIL_SEQ_CONF_PRIO_NBR; index++)
{
TaskPrio[index].priority = 0;
TaskPrio[index].round_robin = 0;
}
UTIL_SEQ_INIT_CRITICAL_SECTION( );
TaskClearList = 0;
}
void UTIL_SEQ_DeInit( void )
{
}
/**
* This function can be nested.
* That is the reason why many variables that are used only in that function are declared static.
* Note: These variables could have been declared static in the function.
*
*/
void UTIL_SEQ_Run( UTIL_SEQ_bm_t Mask_bm )
{
uint32_t counter;
UTIL_SEQ_bm_t current_task_set;
UTIL_SEQ_bm_t super_mask_backup;
UTIL_SEQ_bm_t local_taskset;
UTIL_SEQ_bm_t local_evtset;
UTIL_SEQ_bm_t local_taskmask;
UTIL_SEQ_bm_t local_evtwaited;
uint32_t round_robin[UTIL_SEQ_CONF_PRIO_NBR];
UTIL_SEQ_bm_t task_starving_list;
/*
* When this function is nested, the mask to be applied cannot be larger than the first call
* The mask is always getting smaller and smaller
* A copy is made of the mask set by UTIL_SEQ_Run() in case it is called again in the task
*/
super_mask_backup = SuperMask;
SuperMask &= Mask_bm;
/*
* There are two independent mask to check:
* TaskMask that comes from UTIL_SEQ_PauseTask() / UTIL_SEQ_ResumeTask
* SuperMask that comes from UTIL_SEQ_Run
* If the waited event is there, exit from UTIL_SEQ_Run() to return to the
* waiting task
*/
local_taskset = TaskSet;
local_evtset = EvtSet;
local_taskmask = TaskMask;
local_evtwaited = EvtWaited;
while(((local_taskset & local_taskmask & SuperMask) != 0U) && ((local_evtset & local_evtwaited)==0U))
{
counter = 0U;
/*
* When a flag is set, the associated bit is set in TaskPrio[counter].priority mask depending
* on the priority parameter given from UTIL_SEQ_SetTask()
* The while loop is looking for a flag set from the highest priority maskr to the lower
*/
while((TaskPrio[counter].priority & local_taskmask & SuperMask)== 0U)
{
counter++;
}
current_task_set = TaskPrio[counter].priority & local_taskmask & SuperMask;
/*
* The round_robin register is a mask of allowed flags to be evaluated.
* The concept is to make sure that on each round on UTIL_SEQ_Run(), if two same flags are always set,
* the sequencer does not run always only the first one.
* When a task has been executed, The flag is removed from the round_robin mask.
* If on the next UTIL_SEQ_RUN(), the two same flags are set again, the round_robin mask will
* mask out the first flag so that the second one can be executed.
* Note that the first flag is not removed from the list of pending task but just masked by
* the round_robin mask
*
* In the check below, the round_robin mask is reinitialize in case all pending
* tasks haven been executed at least once
*/
if ((TaskPrio[counter].round_robin & current_task_set) == 0U)
{
TaskPrio[counter].round_robin = UTIL_SEQ_ALL_BIT_SET;
}
/*
* Compute the Stack Startving List
* This is the list of the task that have been set at least once minus the one that have been cleared ar least once
*/
task_starving_list = TaskSet;
/*
* Due to the concept of TaskPrio[counter].round_robin and TaskClearList, it could be that at some points in time,
* (when using UTIL_SEQ_WaitEvt()), that there is a situation where at the same time, a bit is set in TaskPrio[counter].round_robin
* and reset in TaskClearList and another bit is set in TaskClearList and reset in TaskPrio[counter].round_robin.
* Such situation shall not happen when evaluating task_starving_list
* At any time, there should not be any bit reset in TaskPrio[counter].round_robin and reset in TaskClearList
* It is correct with regard to the Sequencer Architecture to set in TaskClearList all tasks that are said to be executed from TaskPrio[counter].round_robin
* This synchronizes both information before calculating the CurrentTaskIdx
*/
TaskClearList |= (~TaskPrio[counter].round_robin);
task_starving_list &= (~TaskClearList);
/*
* Consider first the starving list and update current_task_set accordingly
*/
if ((task_starving_list & current_task_set) != 0U)
{
current_task_set = (task_starving_list & current_task_set);
}
else
{
/* nothing to do */
}
/*
* Reinitialize the Starving List if required
*/
if(task_starving_list == 0)
{
TaskClearList = 0;
}
/*
* Read the flag index of the task to be executed
* Once the index is read, the associated task will be executed even though a higher priority stack is requested
* before task execution.
*/
CurrentTaskIdx = (SEQ_BitPosition(current_task_set & TaskPrio[counter].round_robin));
UTIL_SEQ_ENTER_CRITICAL_SECTION( );
/* remove from the list or pending task the one that has been selected to be executed */
TaskSet &= ~(1U << CurrentTaskIdx);
/*
* remove from all priority mask the task that has been selected to be executed
*/
for (counter = UTIL_SEQ_CONF_PRIO_NBR; counter != 0U; counter--)
{
TaskPrio[counter - 1u].priority &= ~(1U << CurrentTaskIdx);
}
UTIL_SEQ_EXIT_CRITICAL_SECTION( );
UTIL_SEQ_PreTask(CurrentTaskIdx);
/*
* Check that function exists before calling it
*/
if ((CurrentTaskIdx < UTIL_SEQ_CONF_TASK_NBR) && (TaskCb[CurrentTaskIdx] != NULL))
{
/*
* save the round-robin value to take into account the operation done in UTIL_SEQ_WaitEvt
*/
for (uint32_t index = 0; index < UTIL_SEQ_CONF_PRIO_NBR; index++)
{
TaskPrio[index].round_robin &= ~(1U << CurrentTaskIdx);
round_robin[index] = TaskPrio[index].round_robin;
}
/* Execute the task */
TaskCb[CurrentTaskIdx]( );
/*
* restore the round-robin context
*/
for (uint32_t index = 0; index < UTIL_SEQ_CONF_PRIO_NBR; index++)
{
TaskPrio[index].round_robin &= round_robin[index];
}
UTIL_SEQ_PostTask(CurrentTaskIdx);
local_taskset = TaskSet;
local_evtset = EvtSet;
local_taskmask = TaskMask;
local_evtwaited = EvtWaited;
/*
* Update the two list for next round
*/
TaskClearList |= (1U << CurrentTaskIdx);
}
else
{
/*
* must never occurs, it means there is a warning in the system
*/
UTIL_SEQ_CatchWarning(UTIL_SEQ_WARNING_INVALIDTASKID);
}
}
/* the set of CurrentTaskIdx to no task running allows to call WaitEvt in the Pre/Post ilde context */
CurrentTaskIdx = UTIL_SEQ_NOTASKRUNNING;
/* if a waited event is present, ignore the IDLE sequence */
if ((local_evtset & EvtWaited)== 0U)
{
UTIL_SEQ_PreIdle( );
UTIL_SEQ_ENTER_CRITICAL_SECTION_IDLE( );
local_taskset = TaskSet;
local_evtset = EvtSet;
local_taskmask = TaskMask;
if ((local_taskset & local_taskmask & SuperMask) == 0U)
{
if ((local_evtset & EvtWaited)== 0U)
{
UTIL_SEQ_Idle( );
}
}
UTIL_SEQ_EXIT_CRITICAL_SECTION_IDLE( );
UTIL_SEQ_PostIdle( );
}
/* restore the mask from UTIL_SEQ_Run() */
SuperMask = super_mask_backup;
return;
}
void UTIL_SEQ_RegTask(UTIL_SEQ_bm_t TaskId_bm, uint32_t Flags, void (*Task)( void ))
{
(void)Flags;
UTIL_SEQ_ENTER_CRITICAL_SECTION();
TaskCb[SEQ_BitPosition(TaskId_bm)] = Task;
UTIL_SEQ_EXIT_CRITICAL_SECTION();
return;
}
uint32_t UTIL_SEQ_IsRegisteredTask(UTIL_SEQ_bm_t TaskId_bm )
{
uint32_t _status = 0;
UTIL_SEQ_ENTER_CRITICAL_SECTION();
if ( TaskCb[SEQ_BitPosition(TaskId_bm)] != NULL )
{
_status = 1;
}
UTIL_SEQ_EXIT_CRITICAL_SECTION();
return _status;
}
void UTIL_SEQ_SetTask( UTIL_SEQ_bm_t TaskId_bm, uint32_t Task_Prio )
{
UTIL_SEQ_ENTER_CRITICAL_SECTION( );
TaskSet |= TaskId_bm;
TaskPrio[Task_Prio].priority |= TaskId_bm;
UTIL_SEQ_EXIT_CRITICAL_SECTION( );
return;
}
uint32_t UTIL_SEQ_IsSchedulableTask( UTIL_SEQ_bm_t TaskId_bm)
{
uint32_t _status;
UTIL_SEQ_bm_t local_taskset;
UTIL_SEQ_ENTER_CRITICAL_SECTION();
local_taskset = TaskSet;
_status = ((local_taskset & TaskMask & SuperMask & TaskId_bm) == TaskId_bm)? 1U: 0U;
UTIL_SEQ_EXIT_CRITICAL_SECTION();
return _status;
}
void UTIL_SEQ_PauseTask( UTIL_SEQ_bm_t TaskId_bm )
{
UTIL_SEQ_ENTER_CRITICAL_SECTION( );
TaskMask &= (~TaskId_bm);
UTIL_SEQ_EXIT_CRITICAL_SECTION( );
return;
}
uint32_t UTIL_SEQ_IsPauseTask( UTIL_SEQ_bm_t TaskId_bm )
{
uint32_t _status;
UTIL_SEQ_ENTER_CRITICAL_SECTION( );
_status = ((TaskMask & TaskId_bm) == TaskId_bm) ? 0u:1u;
UTIL_SEQ_EXIT_CRITICAL_SECTION( );
return _status;
}
void UTIL_SEQ_ResumeTask( UTIL_SEQ_bm_t TaskId_bm )
{
UTIL_SEQ_ENTER_CRITICAL_SECTION( );
TaskMask |= TaskId_bm;
UTIL_SEQ_EXIT_CRITICAL_SECTION( );
return;
}
void UTIL_SEQ_SetEvt( UTIL_SEQ_bm_t EvtId_bm )
{
UTIL_SEQ_ENTER_CRITICAL_SECTION( );
EvtSet |= EvtId_bm;
UTIL_SEQ_EXIT_CRITICAL_SECTION( );
return;
}
void UTIL_SEQ_ClrEvt( UTIL_SEQ_bm_t EvtId_bm )
{
UTIL_SEQ_ENTER_CRITICAL_SECTION( );
EvtSet &= (~EvtId_bm);
UTIL_SEQ_EXIT_CRITICAL_SECTION( );
return;
}
void UTIL_SEQ_WaitEvt(UTIL_SEQ_bm_t EvtId_bm)
{
UTIL_SEQ_bm_t event_waited_id_backup;
UTIL_SEQ_bm_t current_task_idx;
UTIL_SEQ_bm_t wait_task_idx;
/*
* store in local the current_task_id_bm as the global variable CurrentTaskIdx
* may be overwritten in case there are nested call of UTIL_SEQ_Run()
*/
current_task_idx = CurrentTaskIdx;
if(UTIL_SEQ_NOTASKRUNNING == CurrentTaskIdx)
{
wait_task_idx = 0u;
}
else
{
wait_task_idx = (uint32_t)1u << CurrentTaskIdx;
}
/* backup the event id that was currently waited */
event_waited_id_backup = EvtWaited;
EvtWaited = EvtId_bm;
/*
* wait for the new event
* note: that means that if the previous waited event occurs, it will not exit
* the while loop below.
* The system is waiting only for the last waited event.
* When it will go out, it will wait again from the previous one.
* It case it occurs while waiting for the second one, the while loop will exit immediately
*/
while ((EvtSet & EvtId_bm) == 0U)
{
UTIL_SEQ_EvtIdle(wait_task_idx, EvtId_bm);
}
/*
* Restore the CurrentTaskIdx that may have been modified by call of UTIL_SEQ_Run()
* from UTIL_SEQ_EvtIdle(). This is required so that a second call of UTIL_SEQ_WaitEvt()
* in the same process pass the correct current_task_id_bm in the call of UTIL_SEQ_EvtIdle()
*/
CurrentTaskIdx = current_task_idx;
UTIL_SEQ_ENTER_CRITICAL_SECTION( );
EvtSet &= (~EvtId_bm);
UTIL_SEQ_EXIT_CRITICAL_SECTION( );
EvtWaited = event_waited_id_backup;
return;
}
UTIL_SEQ_bm_t UTIL_SEQ_IsEvtPend( void )
{
UTIL_SEQ_bm_t local_evtwaited = EvtWaited;
return (EvtSet & local_evtwaited);
}
__WEAK void UTIL_SEQ_EvtIdle( UTIL_SEQ_bm_t TaskId_bm, UTIL_SEQ_bm_t EvtWaited_bm )
{
(void)EvtWaited_bm;
UTIL_SEQ_Run(~TaskId_bm);
return;
}
__WEAK void UTIL_SEQ_Idle( void )
{
return;
}
__WEAK void UTIL_SEQ_PreIdle( void )
{
/*
* Unless specified by the application, there is nothing to be done
*/
return;
}
__WEAK void UTIL_SEQ_PostIdle( void )
{
/*
* Unless specified by the application, there is nothing to be done
*/
return;
}
__WEAK void UTIL_SEQ_PreTask( uint32_t TaskId )
{
(void)TaskId;
return;
}
__WEAK void UTIL_SEQ_PostTask( uint32_t TaskId )
{
(void)TaskId;
return;
}
__WEAK void UTIL_SEQ_CatchWarning(UTIL_SEQ_WARNING WarningId)
{
(void)WarningId;
return;
}
/**
* @}
*/
/** @addtogroup SEQUENCER_Private_function
* @{
*/
#if( __CORTEX_M == 0)
const uint8_t SEQ_clz_table_4bit[16U] = { 4U, 3U, 2U, 2U, 1U, 1U, 1U, 1U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U };
/**
* @brief return the position of the first bit set to 1
* @param Value 32 bit value
* @retval bit position
*/
uint8_t SEQ_BitPosition(uint32_t Value)
{
uint8_t position = 0U;
uint32_t lvalue = Value;
if ((lvalue & 0xFFFF0000U) == 0U)
{
position = 16U;
lvalue <<= 16U;
}
if ((lvalue & 0xFF000000U) == 0U)
{
position += 8U;
lvalue <<= 8U;
}
if ((lvalue & 0xF0000000U) == 0U)
{
position += 4U;
lvalue <<= 4U;
}
position += SEQ_clz_table_4bit[lvalue >> (32-4)];
return (uint8_t)(31U-position);
}
#else
/**
* @brief return the position of the first bit set to 1
* @param Value 32 bit value
* @retval bit position
*/
uint8_t SEQ_BitPosition(uint32_t Value)
{
return (uint8_t)(31 -__CLZ( Value ));
}
#endif /* __CORTEX_M == 0 */
/**
* @}
*/
/**
* @}
*/
code/wb1mmc_code/Utilities/sequencer/stm32_seq.h
+405
View File
@@ -0,0 +1,405 @@
/**
******************************************************************************
* @file stm32_seq.h
* @author MCD Application Team
* @brief sequencer interface
******************************************************************************
* @attention
*
* <h2><center>&copy; Copyright (c) 2019 STMicroelectronics.
* All rights reserved.</center></h2>
*
* This software is licensed under terms that can be found in the LICENSE file
* in the root directory of this software component.
* If no LICENSE file comes with this software, it is provided AS-IS.
*
******************************************************************************
*/
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef STM32_SEQ_H
#define STM32_SEQ_H
#ifdef __cplusplus
extern "C" {
#endif
/* Includes ------------------------------------------------------------------*/
#include "stdint.h"
/** @defgroup SEQUENCER sequencer utilities
* @{
*/
/* Exported types ------------------------------------------------------------*/
/** @defgroup SEQUENCER_Exported_type SEQUENCER exported types
* @{
*/
/**
* @brief bit mapping of the task.
* this value is used to represent a list of task (each corresponds to a task).
*/
typedef uint32_t UTIL_SEQ_bm_t;
/**
* @brief lits of the warning of the sequencer.
* this value is used to indicate warning detected during the sequencer execution.
*/
typedef enum {
UTIL_SEQ_WARNING_INVALIDTASKID,
}UTIL_SEQ_WARNING;
/**
* @}
*/
/* Exported constants --------------------------------------------------------*/
/** @defgroup SEQUENCER_Exported_const SEQUENCER exported constants
* @{
*/
/**
* @brief This provides a default value for unused parameter
*
*/
#define UTIL_SEQ_RFU 0
/**
* @brief Default value used to start the scheduling.
*
* This informs the sequencer that all tasks registered shall be considered
*
* @note
* This should be used in the application\n
* while(1)\n
* {\n
* UTIL_SEQ_Run( UTIL_SEQ_DEFAULT );\n
* }\n
*
*/
#define UTIL_SEQ_DEFAULT (~0U)
/**
* @}
*/
/* External variables --------------------------------------------------------*/
/* Exported macros -----------------------------------------------------------*/
/** @defgroup SEQUENCER_Exported_macro SEQUENCER exported macros
* @{
*/
/**
* @brief This macro can be used to define a task with one parameter
*
* @note this is an example of using this macro
*
* task prototype definition
* void FUNCTION_NAME(void *Instance)
* {
* uint8_t _instance = *(uint8_t*) Instance;
* }
*
* task declaration in the application for two instances
* const uint8_t instance1 = 1;
* const uint8_t instance2 = 2;
* UTIL_SEQ_TaskParamDef(FUNCTION_NAME, instance1)
* UTIL_SEQ_TaskParamDef(FUNCTION_NAME, instance2)
*
* task initialization
* UTIL_SEQ_RegTask(1 << 1, 0, UTIL_SEQ_TaskFunction(FUNCTION_NAME,instance2));
* UTIL_SEQ_RegTask(1 << 10, 0, UTIL_SEQ_TaskFunction(FUNCTION_NAME,instance3));
*
* Then no change on the management of the task within the application, the instance being managed within the overloaded function
*
*/
#define UTIL_SEQ_TaskParamDef(_FUNC_,_PARAM_VAL_) \
static void SEQ_FUNC_##_FUNC_##_PARAM_VAL_(void); \
static void SEQ_FUNC_##_FUNC_##_PARAM_VAL_(void) \
{ \
static void *SEQ_PARAM_##_FUNC_ = (void*)&_PARAM_VAL_;\
_FUNC_(SEQ_PARAM_##_FUNC_); \
}
/**
* @brief This macro is used to retrieve the function name of the task
*/
#define UTIL_SEQ_TaskFunction(_FUNC_,_PARAM_VAL_) SEQ_FUNC_##_FUNC_##_PARAM_VAL_
/**
* @}
*/
/* Exported functions ------------------------------------------------------- */
/** @defgroup SEQUENCER_Exported_function SEQUENCER exported functions
* @{
*/
/**
* @brief This function initializes the sequencer resources.
*
* @note It shall not be called from an ISR.
*
*/
void UTIL_SEQ_Init( void );
/**
* @brief This function un-initializes the sequencer resources.
*
* @note It shall not be called from an ISR
*
*/
void UTIL_SEQ_DeInit( void );
/**
* @brief This function is called by the sequencer in critical section (PRIMASK bit) when
* - there are no more tasks to be executed
* AND
* - there are no pending event or the pending event is still not set
* @note The application should enter low power mode in this function
* When this function is not implemented by the application, the sequencer keeps running a while loop (RUN MODE).
* It shall be called only by the sequencer.
*
*/
void UTIL_SEQ_Idle( void );
/**
* @brief This function is called by the sequencer outside critical section just before calling UTIL_SEQ_Idle( )
* UTIL_SEQ_PreIdle() is considered as the last task executed before calling UTIL_SEQ_Idle( )
* In case a task or an event is set from an interrupt handler just after UTIL_SEQ_PreIdle() is called,
* UTIL_SEQ_Idle() will not be called.
*
* @note It shall be called only by the sequencer.
*
*/
void UTIL_SEQ_PreIdle( void );
/**
* @brief This function is called by the sequencer outside critical section either
* - after calling UTIL_SEQ_Idle( )
* OR
* - after calling UTIL_SEQ_PreIdle( ) without call to UTIL_SEQ_Idle() due to an incoming task set or event
* requested after UTIL_SEQ_PreIdle() has been called.
*
* @note UTIL_SEQ_PostIdle() is always called if UTIL_SEQ_PreIdle() has been called and never called otherwise.
* It shall be called only by the sequencer.
*
*/
void UTIL_SEQ_PostIdle( void );
/**
* @brief This function requests the sequencer to execute all pending tasks using round robin mechanism.
* When no task are pending, it calls UTIL_SEQ_Idle();
* This function should be called in a while loop in the application
*
* @param Mask_bm list of task (bit mapping) that is be kept in the sequencer list.
*
* @note It shall not be called from an ISR.
* @note The construction of the task must take into account the fact that there is no counting / protection
* on the activation of the task. Thus, when the task is running, it must perform all the operations
* in progress programmed before its call or manage a reprogramming of the task.
*
*/
void UTIL_SEQ_Run( UTIL_SEQ_bm_t Mask_bm );
/**
* @brief This function registers a task in the sequencer.
*
* @param TaskId_bm The Id of the task
* @param Flags Flags are reserved param for future use
* @param Task Reference of the function to be executed
*
* @note It may be called from an ISR.
*
*/
void UTIL_SEQ_RegTask( UTIL_SEQ_bm_t TaskId_bm, uint32_t Flags, void (*Task)( void ) );
/**
* @brief This function checks if a task is registered
*
* @param TaskId_bm The Id of the task
* It shall be (1<<task_id) where task_id is the number assigned when the task has been registered
* @retval 0 if not 1 if true
*/
uint32_t UTIL_SEQ_IsRegisteredTask( UTIL_SEQ_bm_t TaskId_bm );
/**
* @brief This function requests a task to be executed
*
* @param TaskId_bm The Id of the task
* It shall be (1<<task_id) where task_id is the number assigned when the task has been registered
* @param Task_Prio The priority of the task
* It shall a number from 0 (high priority) to 31 (low priority)
* The priority is checked each time the sequencer needs to select a new task to execute
* It does not permit to preempt a running task with lower priority
*
* @note It may be called from an ISR
*
*/
void UTIL_SEQ_SetTask( UTIL_SEQ_bm_t TaskId_bm, uint32_t Task_Prio );
/**
* @brief This function checks if a task could be scheduled.
*
* @param TaskId_bm The Id of the task
* It shall be (1<<task_id) where task_id is the number assigned when the task has been registered
* @retval 0 if not 1 if true
*
* @note It may be called from an ISR.
*
*/
uint32_t UTIL_SEQ_IsSchedulableTask( UTIL_SEQ_bm_t TaskId_bm);
/**
* @brief This function prevents a task to be called by the sequencer even when set with UTIL_SEQ_SetTask()
* By default, all tasks are executed by the sequencer when set with UTIL_SEQ_SetTask()
* When a task is paused, it is moved out from the sequencer list
*
* @param TaskId_bm The Id of the task
* It shall be (1<<task_id) where task_id is the number assigned when the task has been registered
*
* @note It may be called from an ISR.
*
*/
void UTIL_SEQ_PauseTask( UTIL_SEQ_bm_t TaskId_bm );
/**
* @brief This function allows to know if the task has been put in pause.
* By default, all tasks are executed by the sequencer when set with UTIL_SEQ_SetTask()
* The exit of the pause shall be done by the function UTIL_SEQ_ResumeTask.
*
* @param TaskId_bm The Id of the task
* It shall be (1<<task_id) where task_id is the number assigned when the task has been registered
*
* @note It may be called from an ISR.
*
*/
uint32_t UTIL_SEQ_IsPauseTask( UTIL_SEQ_bm_t TaskId_bm );
/**
* @brief This function allows again a task to be called by the sequencer if set with UTIL_SEQ_SetTask()
* This is used in relation with UTIL_SEQ_PauseTask()
*
* @param TaskId_bm The Id of the task
* It shall be (1<<task_id) where task_id is the number assigned when the task has been registered
*
* @note It may be called from an ISR.
*
*/
void UTIL_SEQ_ResumeTask( UTIL_SEQ_bm_t TaskId_bm );
/**
* @brief This function sets an event that is waited with UTIL_SEQ_WaitEvt()
*
* @param EvtId_bm event id bit mask
*
* @note An event shall be a 32 bit mapping where only 1 bit is set
* It may be called from an ISR.
*
*/
void UTIL_SEQ_SetEvt( UTIL_SEQ_bm_t EvtId_bm );
/**
* @brief This function may be used to clear the event before calling UTIL_SEQ_WaitEvt()
* This API may be useful when the UTIL_SEQ_SetEvt() is called several time to notify the same event.
* Due to Software Architecture where the timings are hard to control, this may be an unwanted case.
*
* @param EvtId_bm event id bm
* It shall be a bit mapping where only 1 bit is set
*
* @note It may be called from an ISR.
*
*/
void UTIL_SEQ_ClrEvt( UTIL_SEQ_bm_t EvtId_bm );
/**
* @brief This function waits for a specific event to be set. The sequencer loops UTIL_SEQ_EvtIdle() until the event is set
* When called recursively, it acts as a First in / Last out mechanism. The sequencer waits for the
* last event requested to be set even though one of the already requested event has been set.
*
* @param EvtId_bm event id bit mask
* It shall be a bit mapping where only 1 bit is set
*
* @note It shall not be called from an ISR.
* @note The construction of the task must take into account the fact that there is no counting / protection on the
* event. Thus, when the task is running, it must perform all the operations in progress programmed before its call
* or manage a reprogramming of the task.
*/
void UTIL_SEQ_WaitEvt( UTIL_SEQ_bm_t EvtId_bm );
/**
* @brief This function returns whether the waited event is pending or not
* It is useful only when the UTIL_SEQ_EvtIdle() is overloaded by the application. In that case, when the low
* power mode needs to be executed, the application shall first check whether the waited event is pending
* or not. Both the event checking and the low power mode processing should be done in critical section
*
* @retval 0 when the waited event is not there or the evt_id when the waited event is pending
*
* @note It may be called from an ISR.
*
*/
UTIL_SEQ_bm_t UTIL_SEQ_IsEvtPend( void );
/**
* @brief This function loops until the waited event is set
* @param TaskId_bm The task id that is currently running. When task_id_bm = 0, it means UTIL_SEQ_WaitEvt( )
* has been called outside a registered task (ie at startup before UTIL_SEQ_Run( ) has been called
* @param EvtWaited_bm The event id that is waited.
*
* @note When not implemented by the application, it calls UTIL_SEQ_Run(~TaskId_bm) which means the waited
* task is suspended until the waited event and the other tasks are running or the application enter
* low power mode.
* Else the user can redefine his own function for example call sequencer UTIL_SEQ_Run(0) to suspend all
* the task and let the sequencer enter the low power mode.
* It shall be called only by the sequencer.
*
*/
void UTIL_SEQ_EvtIdle( UTIL_SEQ_bm_t TaskId_bm, UTIL_SEQ_bm_t EvtWaited_bm );
/**
* @brief This function is call before a task execution
* @param TaskId The task id.
*
* @note the function is provided to help the debug and
* the default implementation does nothing
*
*/
void UTIL_SEQ_PreTask( uint32_t TaskId );
/**
* @brief This function is called after a task execution
* @param TaskId The task id.
*
* @note the function is provided to help the debug and
* the default implementation does nothing
*
*/
void UTIL_SEQ_PostTask( uint32_t TaskId );
/**
* @brief This function is called when a warning is detected
* @param WarningId The warning id.
*
* @note the function is provided to help the debug and
* the default implementation does nothing
*/
void UTIL_SEQ_CatchWarning(UTIL_SEQ_WARNING WarningId);
/**
* @}
*/
/**
* @}
*/
#ifdef __cplusplus
}
#endif
#endif /*__STM32_SEQ_H */