foxBMS  1.2.0
The foxBMS Battery Management System API Documentation
ftask.c
Go to the documentation of this file.
1 /**
2  *
3  * @copyright © 2010 - 2021, Fraunhofer-Gesellschaft zur Foerderung der angewandten Forschung e.V.
4  * All rights reserved.
5  *
6  * SPDX-License-Identifier: BSD-3-Clause
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions are met:
10  *
11  * 1. Redistributions of source code must retain the above copyright notice, this
12  * list of conditions and the following disclaimer.
13  *
14  * 2. Redistributions in binary form must reproduce the above copyright notice,
15  * this list of conditions and the following disclaimer in the documentation
16  * and/or other materials provided with the distribution.
17  *
18  * 3. Neither the name of the copyright holder nor the names of its
19  * contributors may be used to endorse or promote products derived from
20  * this software without specific prior written permission.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
23  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
25  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
28  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
29  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32  *
33  * We kindly request you to use one or more of the following phrases to refer to
34  * foxBMS in your hardware, software, documentation or advertising materials:
35  *
36  * - ″This product uses parts of foxBMS®″
37  * - ″This product includes parts of foxBMS®″
38  * - ″This product is derived from foxBMS®″
39  *
40  */
41 
42 /**
43  * @file ftask.c
44  * @author foxBMS Team
45  * @date 2019-08-27 (date of creation)
46  * @updated 2021-07-23 (date of last update)
47  * @ingroup TASK
48  * @prefix FTSK
49  *
50  * @brief Implementation of engine task driver
51  * @details TODO
52  */
53 
54 /*========== Includes =======================================================*/
55 #include "ftask.h"
56 
57 #include "can_cfg.h"
58 
59 #include "FreeRTOS.h"
60 #include "stream_buffer.h"
61 
62 #include "database.h"
63 #include "sys_mon.h"
64 
65 /*========== Macros and Definitions =========================================*/
66 /** Length of queue that is used in the database */
67 #define FTSK_DATABASE_QUEUE_LENGTH (1u)
68 
69 /** Size of queue item that is used in the database */
70 #define FTSK_DATABASE_QUEUE_ITEM_SIZE (sizeof(DATA_QUEUE_MESSAGE_s))
71 
72 /** Length of queue that is used in the insulation measurement device (IMD) */
73 #define FTSK_IMD_QUEUE_LENGTH (5u)
74 /** Size of queue item that is used in the IMD driver */
75 #define FTSK_IMD_QUEUE_ITEM_SIZE (sizeof(CAN_BUFFERELEMENT_s))
76 
77 /** Length of queue that is used in the can module for receiving messages */
78 #define FTSK_CAN_RX_QUEUE_LENGTH (50u)
79 /** Size of queue item that is used in the can driver */
80 #define FTSK_CAN_RX_QUEUE_ITEM_SIZE (sizeof(CAN_BUFFERELEMENT_s))
81 
82 /*========== Static Constant and Variable Definitions =======================*/
83 /**
84  * @brief size of storage area for the database queue
85  * @details The array that is used for the queue's storage area.
86  * This must be at least
87  * #FTSK_DATABASE_QUEUE_LENGTH * #FTSK_DATABASE_QUEUE_ITEM_SIZE
88  */
90 /** structure for static database queue */
91 static StaticQueue_t ftsk_databaseQueueStructure;
92 
93 /**
94  * @brief size of storage area for the IMD queue
95  * @details The array that is used for the queue's storage area.
96  * This must be at least
97  * #FTSK_IMD_QUEUE_LENGTH * #FTSK_IMD_QUEUE_ITEM_SIZE
98  */
100 /** structure for static data queue */
101 static StaticQueue_t ftsk_imdQueueStructure;
102 
103 /* INCLUDE MARKER FOR THE DOCUMENTATION; DO NOT MOVE can-documentation-rx-queue-vars-start-include */
104 /** structure for static data queue */
105 static StaticQueue_t ftsk_canRxQueueStructure = {0};
106 /**
107  * @brief size of storage area for the CAN Rx queue
108  * @details The array that is used for the queue's storage area.
109  * This must be at least
110  * #FTSK_CAN_RX_QUEUE_LENGTH * #FTSK_CAN_RX_QUEUE_ITEM_SIZE
111  */
113 /* INCLUDE MARKER FOR THE DOCUMENTATION; DO NOT MOVE can-documentation-rx-queue-vars-stop-include */
114 
115 /********* Engine Task *****************************************************/
116 /** Definition of task handle of the engine task */
117 static TaskHandle_t ftsk_taskHandleEngine;
118 
119 /** Task Struct for #ftsk_taskHandleEngine */
120 static StaticTask_t ftsk_taskEngine;
121 
122 /** Stack of #ftsk_taskHandleEngine */
124 
125 /********* Cyclic 1 ms Task *************************************************/
126 /** Definition of task handle for the cyclic 1 ms task */
127 static TaskHandle_t ftsk_taskHandleCyclic1ms;
128 
129 /** Task Struct for #ftsk_taskHandleCyclic1ms */
130 static StaticTask_t ftsk_taskCyclic1ms;
131 
132 /** Stack of #ftsk_taskHandleCyclic1ms */
134 
135 /********* Cyclic 10 ms Task ************************************************/
136 /** Definition of task handle for the cyclic 10 ms task */
137 static TaskHandle_t ftsk_taskHandleCyclic10ms;
138 
139 /** Task Struct for #ftsk_taskHandleCyclic10ms */
140 static StaticTask_t ftsk_taskCyclic10ms;
141 
142 /** Stack of #ftsk_taskHandleCyclic10ms */
144 
145 /********* Cyclic 100 ms Task ***********************************************/
146 /** Definition of task handle for the cyclic 100 ms task */
147 static TaskHandle_t ftsk_taskHandleCyclic100ms;
148 
149 /** Task Struct for #ftsk_taskHandleCyclic100ms */
150 static StaticTask_t ftsk_taskCyclic100ms;
151 
152 /** Stack of #ftsk_taskHandleCyclic100ms */
154 
155 /********* Cyclic 100 ms Task for Algorithms ********************************/
156 /** Definition of task handle for the cyclic 100 ms task for algorithms */
158 
159 /** Task Struct for #ftsk_taskHandleCyclicAlgorithm100ms */
160 static StaticTask_t ftsk_taskCyclicAlgorithm100ms;
161 
162 /** Stack of #ftsk_taskHandleCyclicAlgorithm100ms */
164 
165 /*========== Extern Constant and Variable Definitions =======================*/
166 volatile bool ftsk_allQueuesCreated = false;
167 
168 QueueHandle_t ftsk_databaseQueue = NULL_PTR;
169 
171 
172 /* INCLUDE MARKER FOR THE DOCUMENTATION; DO NOT MOVE can-documentation-rx-queue-handle-start-include */
173 QueueHandle_t ftsk_canRxQueue = NULL_PTR;
174 /* INCLUDE MARKER FOR THE DOCUMENTATION; DO NOT MOVE can-documentation-rx-queue-handle-stop-include */
175 
176 /*========== Static Function Prototypes =====================================*/
177 /**
178  * @brief Database-Task
179  * @details The task manages the data exchange with the database and must have a
180  * higher task priority than any task using the database.
181  * @ingroup API_OS
182  */
183 static void FTSK_CreateTaskEngine(void);
184 
185 /**
186  * @brief Creation of cyclic 1 ms task
187  * @details The Task calls OsStartUp() in the very beginning, this is the first
188  * active Task. Then the Task is delayed by a phase as defined in
189  * ftsk_tskdef_cyclic_1ms.phase (in milliseconds). After the phase
190  * delay, the cyclic execution starts, the entry time is saved in
191  * current_time. After one cycle, the Task is set to sleep until entry
192  * time + ftsk_tskdef_cyclic_1ms.cycleTime (in milliseconds).
193  */
194 static void FTSK_CreateTaskCyclic1ms(void);
195 
196 /**
197  * @brief Creation of cyclic 10 ms task
198  * @details Task is delayed by a phase as defined in
199  * ftsk_tskdef_cyclic_10ms.phase (in milliseconds). After the phase
200  * delay, the cyclic execution starts, the entry time is saved in
201  * current_time. After one cycle, the Task is set to sleep until entry
202  * time + ftsk_tskdef_cyclic_10ms.cycleTime (in milliseconds).
203  */
204 static void FTSK_CreateTaskCyclic10ms(void);
205 
206 /**
207  * @brief Creation of cyclic 100 ms task
208  * @details Task is delayed by a phase as defined in
209  * ftsk_tskdef_cyclic_100ms.phase (in milliseconds). After the phase
210  * delay, the cyclic execution starts, the entry time is saved in
211  * current_time. After one cycle, the Task is set to sleep until entry
212  * time + ftsk_tskdef_cyclic_100ms.cycleTime (in milliseconds).
213  */
214 static void FTSK_CreateTaskCyclic100ms(void);
215 
216 /**
217  * @brief Creation of cyclic 100 ms algorithm task
218  * @details Task is delayed by a phase as defined in
219  * ftsk_taskDefinitionCyclicAlgorithm100ms.Phase (in milliseconds).
220  * After the phase delay, the cyclic execution starts, the entry time
221  * is saved in current_time. After one cycle, the Task is set to sleep
222  * until
223  * entry time + ftsk_taskDefinitionCyclicAlgorithm100ms.CycleTime
224  * (in milliseconds).
225  */
226 static void FTSK_CreateTaskCyclicAlgorithm100ms(void);
227 
228 /*========== Static Function Implementations ================================*/
229 /* tell compiler this function is a task, context save not necessary */
230 #pragma TASK(FTSK_CreateTaskEngine)
231 static void FTSK_CreateTaskEngine(void) {
235 
237  while (1) {
238  /* notify system monitoring that task will be called */
240  /* user code implemention */
242  /* notify system monitoring that task has been called */
244  }
245 }
246 
247 /* tell compiler this function is a task, context save not necessary */
248 #pragma TASK(FTSK_CreateTaskCyclic1ms)
249 static void FTSK_CreateTaskCyclic1ms(void) {
250  uint32_t current_time = 0;
251 
252  while (os_boot != OS_ENGINE_RUNNING) {
253  }
254 
257 
259  current_time = OS_GetTickCount();
260  while (1) {
261  /* notify system monitoring that task will be called */
263  /* user code implementation */
265  /* notify system monitoring that task has been called */
267  /* let task sleep until it is due again */
269  }
270 }
271 
272 /* tell compiler this function is a task, context save not necessary */
273 #pragma TASK(FTSK_CreateTaskCyclic10ms)
274 static void FTSK_CreateTaskCyclic10ms(void) {
275  uint32_t current_time = 0;
276 
278  }
279 
281  current_time = OS_GetTickCount();
282  while (1) {
283  /* notify system monitoring that task will be called */
285  /* user code implementation */
287  /* notify system monitoring that task has been called */
289  /* let task sleep until it is due again */
291  }
292 }
293 
294 /* tell compiler this function is a task, context save not necessary */
295 #pragma TASK(FTSK_CreateTaskCyclic100ms)
296 static void FTSK_CreateTaskCyclic100ms(void) {
297  uint32_t current_time = 0;
298 
300  }
301 
303  current_time = OS_GetTickCount();
304  while (1) {
305  /* notify system monitoring that task will be called */
307  /* user code implementation */
309  /* notify system monitoring that task has been called */
311  /* let task sleep until it is due again */
313  }
314 }
315 
316 /* tell compiler this function is a task, context save not necessary */
317 #pragma TASK(FTSK_CreateTaskCyclicAlgorithm100ms)
319  uint32_t current_time = 0;
320 
322  }
323 
326  current_time = OS_GetTickCount();
327  while (1) {
328  /* notify system monitoring that task will be called */
330  /* user code implementation */
332  /* notify system monitoring that task has been called */
334  /* let task sleep until it is due again */
336  }
337 }
338 
339 /*========== Extern Function Implementations ================================*/
340 extern void FTSK_CreateQueues(void) {
341  /* Create a queue capable of containing a pointer of type DATA_QUEUE_MESSAGE_s
342  Data of Messages are passed by pointer as they contain a lot of data. */
343  ftsk_databaseQueue = xQueueCreateStatic(
349  vQueueAddToRegistry(ftsk_databaseQueue, "Database Queue");
350  ftsk_imdCanDataQueue = xQueueCreateStatic(
352  vQueueAddToRegistry(ftsk_imdCanDataQueue, "IMD CAN Data Queue");
354  ftsk_canRxQueue = xQueueCreateStatic(
356  vQueueAddToRegistry(ftsk_canRxQueue, "CAN Receive Queue");
359  ftsk_allQueuesCreated = true;
361 }
362 
363 extern void FTSK_CreateTasks(void) {
364  ftsk_taskHandleEngine = xTaskCreateStatic(
365  (TaskFunction_t)FTSK_CreateTaskEngine,
366  (const portCHAR *)"FTSK_CreateTaskEngine",
368  NULL,
371  &ftsk_taskEngine);
372  /* Trap if initialization failed */
374 
375  /* Cyclic Task 1ms */
376  ftsk_taskHandleCyclic1ms = xTaskCreateStatic(
377  (TaskFunction_t)FTSK_CreateTaskCyclic1ms,
378  (const portCHAR *)"FTSK_CreateTaskCyclic1ms",
380  NULL,
384  /* Trap if initialization failed */
386 
387  /* Cyclic Task 10ms */
388  ftsk_taskHandleCyclic10ms = xTaskCreateStatic(
389  (TaskFunction_t)FTSK_CreateTaskCyclic10ms,
390  (const portCHAR *)"FTSK_CreateTaskCyclic10ms",
392  NULL,
396  /* Trap if initialization failed */
398 
399  /* Cyclic Task 100ms */
400  ftsk_taskHandleCyclic100ms = xTaskCreateStatic(
401  (TaskFunction_t)FTSK_CreateTaskCyclic100ms,
402  (const portCHAR *)"FTSK_CreateTaskCyclic100ms",
404  NULL,
408  /* Trap if initialization failed */
410 
411  /* Cyclic Task 100ms for algorithms */
412  ftsk_taskHandleCyclicAlgorithm100ms = xTaskCreateStatic(
413  (TaskFunction_t)FTSK_CreateTaskCyclicAlgorithm100ms,
414  (const portCHAR *)"FTSK_CreateTaskCyclicAlgorithm100ms",
416  NULL,
420  /* Trap if initialization failed */
422 }
423 
424 /*========== Externalized Static Function Implementations (Unit Test) =======*/
Headers for the configuration for the CAN module.
Database module header.
#define FAS_ASSERT(x)
Assertion macro that asserts that x is true.
Definition: fassert.h:237
#define NULL_PTR
Null pointer.
Definition: fstd_types.h:66
static StaticTask_t ftsk_taskEngine
Definition: ftask.c:120
static void FTSK_CreateTaskEngine(void)
Database-Task.
Definition: ftask.c:231
#define FTSK_DATABASE_QUEUE_LENGTH
Definition: ftask.c:67
static uint8_t ftsk_imdQueueStorageArea[FTSK_IMD_QUEUE_LENGTH *FTSK_IMD_QUEUE_ITEM_SIZE]
size of storage area for the IMD queue
Definition: ftask.c:99
static StaticQueue_t ftsk_databaseQueueStructure
Definition: ftask.c:91
static void FTSK_CreateTaskCyclicAlgorithm100ms(void)
Creation of cyclic 100 ms algorithm task.
Definition: ftask.c:318
static StackType_t ftsk_stackSizeCyclicAlgorithm100ms[FTSK_TASK_CYCLIC_ALGORITHM_100MS_STACKSIZE]
Definition: ftask.c:163
static TaskHandle_t ftsk_taskHandleEngine
Definition: ftask.c:117
static TaskHandle_t ftsk_taskHandleCyclicAlgorithm100ms
Definition: ftask.c:157
volatile bool ftsk_allQueuesCreated
Definition: ftask.c:166
static StackType_t ftsk_stackSizeEngine[FTSK_TASK_ENGINE_STACK_SIZE]
Definition: ftask.c:123
static StaticTask_t ftsk_taskCyclic100ms
Definition: ftask.c:150
QueueHandle_t ftsk_databaseQueue
Definition: ftask.c:168
#define FTSK_CAN_RX_QUEUE_LENGTH
Definition: ftask.c:78
static uint8_t ftsk_databaseQueueStorageArea[FTSK_DATABASE_QUEUE_LENGTH *FTSK_DATABASE_QUEUE_ITEM_SIZE]
size of storage area for the database queue
Definition: ftask.c:89
static StaticQueue_t ftsk_canRxQueueStructure
Definition: ftask.c:105
static StaticQueue_t ftsk_imdQueueStructure
Definition: ftask.c:101
#define FTSK_IMD_QUEUE_ITEM_SIZE
Definition: ftask.c:75
static void FTSK_CreateTaskCyclic10ms(void)
Creation of cyclic 10 ms task.
Definition: ftask.c:274
static StackType_t ftsk_stackSizeCyclic10ms[FTSK_TASK_CYCLIC_10MS_STACK_SIZE]
Definition: ftask.c:143
static StackType_t ftsk_stackSizeCyclic100ms[FTSK_TASK_CYCLIC_100MS_STACK_SIZE]
Definition: ftask.c:153
void FTSK_CreateTasks(void)
Creates all tasks of the group.
Definition: ftask.c:363
static StaticTask_t ftsk_taskCyclicAlgorithm100ms
Definition: ftask.c:160
static uint8_t ftsk_canRxQueueStorageArea[FTSK_CAN_RX_QUEUE_LENGTH *FTSK_CAN_RX_QUEUE_ITEM_SIZE]
size of storage area for the CAN Rx queue
Definition: ftask.c:112
static void FTSK_CreateTaskCyclic100ms(void)
Creation of cyclic 100 ms task.
Definition: ftask.c:296
#define FTSK_CAN_RX_QUEUE_ITEM_SIZE
Definition: ftask.c:80
static TaskHandle_t ftsk_taskHandleCyclic100ms
Definition: ftask.c:147
static StackType_t ftsk_stackSizeCyclic1ms[FTSK_TASK_CYCLIC_1MS_STACK_SIZE]
Definition: ftask.c:133
QueueHandle_t ftsk_canRxQueue
Definition: ftask.c:173
static StaticTask_t ftsk_taskCyclic1ms
Definition: ftask.c:130
void FTSK_CreateQueues(void)
Creates all queues.
Definition: ftask.c:340
static StaticTask_t ftsk_taskCyclic10ms
Definition: ftask.c:140
#define FTSK_DATABASE_QUEUE_ITEM_SIZE
Definition: ftask.c:70
QueueHandle_t ftsk_imdCanDataQueue
Definition: ftask.c:170
static void FTSK_CreateTaskCyclic1ms(void)
Creation of cyclic 1 ms task.
Definition: ftask.c:249
static TaskHandle_t ftsk_taskHandleCyclic1ms
Definition: ftask.c:127
static TaskHandle_t ftsk_taskHandleCyclic10ms
Definition: ftask.c:137
#define FTSK_IMD_QUEUE_LENGTH
Definition: ftask.c:73
Header of task driver implementation.
OS_TASK_DEFINITION_s ftsk_taskDefinitionCyclic100ms
Task configuration of the cyclic 100 ms task.
Definition: ftask_cfg.c:114
void FTSK_InitializeUserCodeEngine(void)
Initializes the database.
Definition: ftask_cfg.c:130
void FTSK_RunUserCodeEngine(void)
Engine task for the database and the system monitoring module.
Definition: ftask_cfg.c:151
OS_TASK_DEFINITION_s ftsk_taskDefinitionEngine
Definition of the engine task.
Definition: ftask_cfg.c:105
OS_TASK_DEFINITION_s ftsk_taskDefinitionCyclic1ms
Task configuration of the cyclic 1 ms task.
Definition: ftask_cfg.c:107
OS_TASK_DEFINITION_s ftsk_taskDefinitionCyclicAlgorithm100ms
Task configuration of the cyclic 100 ms task for algorithms.
Definition: ftask_cfg.c:119
void FTSK_RunUserCodeCyclic100ms(void)
Cyclic 100 ms task.
Definition: ftask_cfg.c:227
void FTSK_InitializeUserCodePreCyclicTasks(void)
Initialization function before all tasks started.
Definition: ftask_cfg.c:160
void FTSK_RunUserCodeCyclic10ms(void)
Cyclic 10 ms task.
Definition: ftask_cfg.c:205
void FTSK_RunUserCodeCyclic1ms(void)
Cyclic 1 ms task.
Definition: ftask_cfg.c:195
OS_TASK_DEFINITION_s ftsk_taskDefinitionCyclic10ms
Task configuration of the cyclic 10 ms task.
Definition: ftask_cfg.c:112
void FTSK_RunUserCodeCyclicAlgorithm100ms(void)
Cyclic 100 ms task for algorithms.
Definition: ftask_cfg.c:247
#define FTSK_TASK_ENGINE_STACK_SIZE
Stack size of engine task.
Definition: ftask_cfg.h:64
#define FTSK_TASK_CYCLIC_100MS_STACK_SIZE
Stack size of cyclic 100 ms task.
Definition: ftask_cfg.h:100
#define FTSK_TASK_CYCLIC_1MS_STACK_SIZE
Stack size of cyclic 1 ms task.
Definition: ftask_cfg.h:76
#define FTSK_TASK_CYCLIC_ALGORITHM_100MS_STACKSIZE
Stack size of cyclic 100 ms task for algorithms.
Definition: ftask_cfg.h:112
#define FTSK_TASK_CYCLIC_10MS_STACK_SIZE
Stack size of cyclic 10 ms task.
Definition: ftask_cfg.h:88
void OS_DelayTaskUntil(uint32_t *pPreviousWakeTime, uint32_t milliseconds)
Delay a task until a specified time.
Definition: os.c:196
uint32_t os_schedulerStartTime
Scheduler "zero" time for task phase control.
Definition: os.c:76
void OS_ExitTaskCritical(void)
Exit Critical interface function for use in FreeRTOS-Tasks and FreeRTOS-ISR.
Definition: os.c:178
void OS_EnterTaskCritical(void)
Enter Critical interface function for use in FreeRTOS-Tasks and FreeRTOS-ISR.
Definition: os.c:174
uint32_t OS_GetTickCount(void)
Returns OS based system tick value.
Definition: os.c:182
volatile OS_BOOT_STATE_e os_boot
Definition: os.c:72
@ OS_PRECYCLIC_INIT_HAS_FINISHED
Definition: os.h:97
@ OS_SCHEDULER_RUNNING
Definition: os.h:95
@ OS_ENGINE_RUNNING
Definition: os.h:96
@ OS_SYSTEM_RUNNING
Definition: os.h:98
UBaseType_t priority
Definition: os.h:119
uint32_t cycleTime
Definition: os.h:118
uint16_t stackSize
Definition: os.h:120
uint32_t phase
Definition: os.h:117
void SYSM_Notify(SYSM_TASK_ID_e tsk_id, SYSM_NOTIFY_TYPE_e state, uint32_t time)
Sets needed bits to indicate that a task is running.
Definition: sys_mon.c:104
@ SYSM_NOTIFY_ENTER
Definition: sys_mon.h:62
@ SYSM_NOTIFY_EXIT
Definition: sys_mon.h:63
@ SYSM_TASK_ID_CYCLIC_10ms
Definition: sys_mon_cfg.h:75
@ SYSM_TASK_ID_CYCLIC_ALGORITHM_100ms
Definition: sys_mon_cfg.h:77
@ SYSM_TASK_ID_CYCLIC_100ms
Definition: sys_mon_cfg.h:76
@ SYSM_TASK_ID_CYCLIC_1ms
Definition: sys_mon_cfg.h:74
@ SYSM_TASK_ID_ENGINE
Definition: sys_mon_cfg.h:73