begriffs open source - cmsis-freertos/blob - CMSIS/RTOS2/FreeRTOS/Source/freertos

1 /* --------------------------------------------------------------------------

3 *

4 * SPDX-License-Identifier: Apache-2.0

5 *

6 * Licensed under the Apache License, Version 2.0 (the License); you may

7 * not use this file except in compliance with the License.

8 * You may obtain a copy of the License at

9 *

10 * www.apache.org/licenses/LICENSE-2.0

11 *

12 * Unless required by applicable law or agreed to in writing, software

13 * distributed under the License is distributed on an AS IS BASIS, WITHOUT

14 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

15 * See the License for the specific language governing permissions and

16 * limitations under the License.

17 *

18 * Name: freertos_evr.c

19 * Purpose: FreeRTOS Event Recorder implementation

20 *

21 *---------------------------------------------------------------------------*/

23 #include "freertos_evr.h"

24 #include "cmsis_compiler.h"

26 #include "FreeRTOS.h" // ARM.FreeRTOS::RTOS:Core

27 #include "task.h" // ARM.FreeRTOS::RTOS:Core

28 #include "semphr.h" // ARM.FreeRTOS::RTOS:Core

29 #include "event_groups.h" // ARM.FreeRTOS::RTOS:Event Groups

31 #ifdef RTE_Compiler_EventRecorder

33 #include "EventRecorder.h"

35 /* FreeRTOS component number */

36 #define EvtFreeRTOSTasksNo (0xF0U)

37 #define EvtFreeRTOSQueueNo (0xF1U)

38 #define EvtFreeRTOSTimersNo (0xF2U)

39 #define EvtFreeRTOSEventGroupsNo (0xF3U)

40 #define EvtFreeRTOSHeapNo (0xF4U)

42 /* Event IDs for "FreeRTOS Tasks" */

43 #define EvtFreeRTOSTasks_TaskCreate EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x00U)

44 #define EvtFreeRTOSTasks_TaskCreateFailed EventID(EventLevelError, EvtFreeRTOSTasksNo, 0x01U)

45 #define EvtFreeRTOSTasks_TaskDelete EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x02U)

46 #define EvtFreeRTOSTasks_TaskDelayUntil EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x03U)

47 #define EvtFreeRTOSTasks_TaskDelay EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x04U)

48 #define EvtFreeRTOSTasks_TaskPrioritySet EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x05U)

49 #define EvtFreeRTOSTasks_TaskSuspend EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x06U)

50 #define EvtFreeRTOSTasks_TaskResume EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x07U)

51 #define EvtFreeRTOSTasks_TaskResumeFromIsr EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x08U)

52 #define EvtFreeRTOSTasks_TaskIncrementTick EventID(EventLevelDetail, EvtFreeRTOSTasksNo, 0x09U)

53 #define EvtFreeRTOSTasks_IncreaseTickCount EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x0AU)

54 #define EvtFreeRTOSTasks_TaskSwitchedOut EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x0BU)

55 #define EvtFreeRTOSTasks_TaskSwitchedIn EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x0CU)

56 #define EvtFreeRTOSTasks_TaskPriorityInherit EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x0DU)

57 #define EvtFreeRTOSTasks_TaskPriorityDisinherit EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x0EU)

58 #define EvtFreeRTOSTasks_MovedTaskToReadyState EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x0FU)

59 #define EvtFreeRTOSTasks_PostMovedTaskToReadyState EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x10U)

60 #define EvtFreeRTOSTasks_LowPowerIdleBegin EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x11U)

61 #define EvtFreeRTOSTasks_LowPowerIdleEnd EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x12U)

62 #define EvtFreeRTOSTasks_TaskNotifyTakeBlock EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x13U)

63 #define EvtFreeRTOSTasks_TaskNotifyTake EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x14U)

64 #define EvtFreeRTOSTasks_TaskNotifyWaitBlock EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x15U)

65 #define EvtFreeRTOSTasks_TaskNotifyWait EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x16U)

66 #define EvtFreeRTOSTasks_TaskNotify EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x17U)

67 #define EvtFreeRTOSTasks_TaskNotifyFromIsr EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x18U)

68 #define EvtFreeRTOSTasks_TaskNotifyGiveFromIsr EventID(EventLevelOp, EvtFreeRTOSTasksNo, 0x19U)

70 /* Event IDs for "FreeRTOS Queue" */

71 #define EvtFreeRTOSQueue_QueueCreate EventID(EventLevelOp, EvtFreeRTOSQueueNo, 0x00U)

72 #define EvtFreeRTOSQueue_QueueCreateFailed EventID(EventLevelError, EvtFreeRTOSQueueNo, 0x01U)

73 #define EvtFreeRTOSQueue_CreateMutex EventID(EventLevelOp, EvtFreeRTOSQueueNo, 0x02U)

74 #define EvtFreeRTOSQueue_CreateMutexFailed EventID(EventLevelError, EvtFreeRTOSQueueNo, 0x03U)

75 #define EvtFreeRTOSQueue_GiveMutexRecursive EventID(EventLevelOp, EvtFreeRTOSQueueNo, 0x04U)

76 #define EvtFreeRTOSQueue_GiveMutexRecursiveFailed EventID(EventLevelError, EvtFreeRTOSQueueNo, 0x05U)

77 #define EvtFreeRTOSQueue_TakeMutexRecursive EventID(EventLevelOp, EvtFreeRTOSQueueNo, 0x06U)

78 #define EvtFreeRTOSQueue_TakeMutexRecursiveFailed EventID(EventLevelError, EvtFreeRTOSQueueNo, 0x07U)

79 #define EvtFreeRTOSQueue_CreateCountingSemaphore EventID(EventLevelOp, EvtFreeRTOSQueueNo, 0x08U)

80 #define EvtFreeRTOSQueue_CreateCountingSemaphoreFailed EventID(EventLevelError, EvtFreeRTOSQueueNo, 0x09U)

81 #define EvtFreeRTOSQueue_QueueSend EventID(EventLevelOp, EvtFreeRTOSQueueNo, 0x0AU)

82 #define EvtFreeRTOSQueue_QueueSendFailed EventID(EventLevelError, EvtFreeRTOSQueueNo, 0x0BU)

83 #define EvtFreeRTOSQueue_QueueReceive EventID(EventLevelOp, EvtFreeRTOSQueueNo, 0x0CU)

84 #define EvtFreeRTOSQueue_QueuePeek EventID(EventLevelOp, EvtFreeRTOSQueueNo, 0x0DU)

85 #define EvtFreeRTOSQueue_QueuePeekFromIsr EventID(EventLevelOp, EvtFreeRTOSQueueNo, 0x0EU)

86 #define EvtFreeRTOSQueue_QueueReceiveFailed EventID(EventLevelError, EvtFreeRTOSQueueNo, 0x0FU)

87 #define EvtFreeRTOSQueue_QueueSendFromIsr EventID(EventLevelOp, EvtFreeRTOSQueueNo, 0x10U)

88 #define EvtFreeRTOSQueue_QueueSendFromIsrFailed EventID(EventLevelError, EvtFreeRTOSQueueNo, 0x11U)

89 #define EvtFreeRTOSQueue_QueueReceiveFromIsr EventID(EventLevelOp, EvtFreeRTOSQueueNo, 0x12U)

90 #define EvtFreeRTOSQueue_QueueReceiveFromIsrFailed EventID(EventLevelError, EvtFreeRTOSQueueNo, 0x13U)

91 #define EvtFreeRTOSQueue_QueuePeekFromIsrFailed EventID(EventLevelError, EvtFreeRTOSQueueNo, 0x14U)

92 #define EvtFreeRTOSQueue_QueueDelete EventID(EventLevelOp, EvtFreeRTOSQueueNo, 0x15U)

93 #define EvtFreeRTOSQueue_QueueRegistryAdd EventID(EventLevelOp, EvtFreeRTOSQueueNo, 0x16U)

94 #define EvtFreeRTOSQueue_BlockingOnQueueReceive EventID(EventLevelOp, EvtFreeRTOSQueueNo, 0x17U)

95 #define EvtFreeRTOSQueue_BlockingOnQueueSend EventID(EventLevelOp, EvtFreeRTOSQueueNo, 0x18U)

97 /* Event IDs for "FreeRTOS Timers" */

98 #define EvtFreeRTOSTimers_TimerCreate EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x00U)

99 #define EvtFreeRTOSTimers_TimerCreateFailed EventID(EventLevelError, EvtFreeRTOSTimersNo, 0x01U)

100 #define EvtFreeRTOSTimers_TimerCommandSend EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x02U)

101 #define EvtFreeRTOSTimers_TimerCommandReceived EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x03U)

102 #define EvtFreeRTOSTimers_TimerExpired EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x04U)

103 #define EvtFreeRTOSTimers_PendFuncCall EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x05U)

104 #define EvtFreeRTOSTimers_PendFuncCallFromIsr EventID(EventLevelOp, EvtFreeRTOSTimersNo, 0x06U)

105

106 /* Event IDs for "FreeRTOS EventGroups" */

107 #define EvtFreeRTOSEventGroups_EventGroupCreate EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x00U)

108 #define EvtFreeRTOSEventGroups_EventGroupCreateFailed EventID(EventLevelError, EvtFreeRTOSEventGroupsNo, 0x01U)

109 #define EvtFreeRTOSEventGroups_EventGroupSyncBlock EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x02U)

110 #define EvtFreeRTOSEventGroups_EventGroupSyncEnd EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x03U)

111 #define EvtFreeRTOSEventGroups_EventGroupWaitBitsBlock EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x04U)

112 #define EvtFreeRTOSEventGroups_EventGroupWaitBitsEnd EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x05U)

113 #define EvtFreeRTOSEventGroups_EventGroupClearBits EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x06U)

114 #define EvtFreeRTOSEventGroups_EventGroupClearBitsFromIsr EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x07U)

115 #define EvtFreeRTOSEventGroups_EventGroupSetBits EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x08U)

116 #define EvtFreeRTOSEventGroups_EventGroupSetBitsFromIsr EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x09U)

117 #define EvtFreeRTOSEventGroups_EventGroupDelete EventID(EventLevelOp, EvtFreeRTOSEventGroupsNo, 0x0AU)

118

119 /* Event IDs for "FreeRTOS Heap" */

120 #define EvtFreeRTOSHeap_Malloc EventID(EventLevelOp, EvtFreeRTOSHeapNo, 0x00U)

121 #define EvtFreeRTOSHeap_Free EventID(EventLevelOp, EvtFreeRTOSHeapNo, 0x01U)

122

123 #endif /* RTE_Compiler_EventRecorder */

124

125

126 /* Tasks */

127

128 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_CREATE_DISABLE))

129 void EvrFreeRTOSTasks_TaskCreate (/*TCB_t*/void *pxNewTCB) {

130 #if defined(RTE_Compiler_EventRecorder)

131 EventRecord2(EvtFreeRTOSTasks_TaskCreate, (uint32_t)pxNewTCB, 0U);

132 #else

133 (void)pxNewTCB;

134 #endif

135 }

136 #endif

137

138 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_CREATE_FAILED_DISABLE))

139 void EvrFreeRTOSTasks_TaskCreateFailed (void) {

140 #if defined(RTE_Compiler_EventRecorder)

141 EventRecord2(EvtFreeRTOSTasks_TaskCreateFailed, 0U, 0U);

142 #endif

143 }

144 #endif

145

146 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_DELETE_DISABLE))

147 void EvrFreeRTOSTasks_TaskDelete (/*TCB_t*/void *pxTCB) {

148 #if defined(RTE_Compiler_EventRecorder)

149 EventRecord2(EvtFreeRTOSTasks_TaskDelete, (uint32_t)pxTCB, 0U);

150 #else

151 (void)pxTCB;

152 #endif

153 }

154 #endif

155

156 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_DELAY_UNTIL_DISABLE))

157 void EvrFreeRTOSTasks_TaskDelayUntil (uint32_t xTimeToWake) {

158 #if defined(RTE_Compiler_EventRecorder)

159 EventRecord2(EvtFreeRTOSTasks_TaskDelayUntil, xTimeToWake, 0U);

160 #else

161 (void)xTimeToWake;

162 #endif

163 }

164 #endif

165

166 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_DELAY_DISABLE))

167 void EvrFreeRTOSTasks_TaskDelay (uint32_t xTicksToDelay) {

168 #if defined(RTE_Compiler_EventRecorder)

169 EventRecord2(EvtFreeRTOSTasks_TaskDelay, xTicksToDelay, 0U);

170 #else

171 (void)xTicksToDelay;

172 #endif

173 }

174 #endif

175

176 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_PRIORITY_SET_DISABLE))

177 void EvrFreeRTOSTasks_TaskPrioritySet (/*TCB_t*/void *pxTCB, uint32_t uxNewPriority) {

178 #if defined(RTE_Compiler_EventRecorder)

179 EventRecord2(EvtFreeRTOSTasks_TaskPrioritySet, (uint32_t)pxTCB, uxNewPriority);

180 #else

181 (void)pxTCB;

182 (void)uxNewPriority;

183 #endif

184 }

185 #endif

186

187 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_SUSPEND_DISABLE))

188 void EvrFreeRTOSTasks_TaskSuspend (/*TCB_t*/void *pxTCB) {

189 #if defined(RTE_Compiler_EventRecorder)

190 EventRecord2(EvtFreeRTOSTasks_TaskSuspend, (uint32_t)pxTCB, 0U);

191 #else

192 (void)pxTCB;

193 #endif

194 }

195 #endif

196

197 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_RESUME_DISABLE))

198 void EvrFreeRTOSTasks_TaskResume (/*TCB_t*/void *pxTCB) {

199 #if defined(RTE_Compiler_EventRecorder)

200 EventRecord2(EvtFreeRTOSTasks_TaskResume, (uint32_t)pxTCB, 0U);

201 #else

202 (void)pxTCB;

203 #endif

204 }

205 #endif

206

207 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_RESUME_FROM_ISR_DISABLE))

208 void EvrFreeRTOSTasks_TaskResumeFromIsr (/*TCB_t*/void *pxTCB) {

209 #if defined(RTE_Compiler_EventRecorder)

210 EventRecord2(EvtFreeRTOSTasks_TaskResumeFromIsr, (uint32_t)pxTCB, 0U);

211 #else

212 (void)pxTCB;

213 #endif

214 }

215 #endif

216

217 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_INCREMENT_TICK_DISABLE))

218 void EvrFreeRTOSTasks_TaskIncrementTick (uint32_t xTickCount) {

219 #if defined(RTE_Compiler_EventRecorder)

220 EventRecord2(EvtFreeRTOSTasks_TaskIncrementTick, xTickCount, 0U);

221 #else

222 (void)xTickCount;

223 #endif

224 }

225 #endif

226

227 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceINCREASE_TICK_COUNT_DISABLE))

228 void EvrFreeRTOSTasks_IncreaseTickCount (uint32_t xTicksToJump) {

229 #if defined(RTE_Compiler_EventRecorder)

230 EventRecord2(EvtFreeRTOSTasks_IncreaseTickCount, xTicksToJump, 0U);

231 #else

232 (void)xTicksToJump;

233 #endif

234 }

235 #endif

236

237 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_SWITCHED_OUT_DISABLE))

238 void EvrFreeRTOSTasks_TaskSwitchedOut (/*TCB_t*/void *pxCurrentTCB) {

239 #if defined(RTE_Compiler_EventRecorder)

240 EventRecord2(EvtFreeRTOSTasks_TaskSwitchedOut, (uint32_t)pxCurrentTCB, 0U);

241 #else

242 (void)pxCurrentTCB;

243 #endif

244 }

245 #endif

246

247 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_SWITCHED_IN_DISABLE))

248 void EvrFreeRTOSTasks_TaskSwitchedIn (/*TCB_t*/void *pxCurrentTCB, uint32_t uxTopPriority) {

249 #if defined(RTE_Compiler_EventRecorder)

250 EventRecord2(EvtFreeRTOSTasks_TaskSwitchedIn, (uint32_t)pxCurrentTCB, uxTopPriority);

251 #else

252 (void)pxCurrentTCB;

253 (void)uxTopPriority;

254 #endif

255 }

256 #endif

257

258 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_PRIORITY_INHERIT_DISABLE))

259 void EvrFreeRTOSTasks_TaskPriorityInherit (/*TCB_t*/void *pxTCBOfMutexHolder, uint32_t uxInheritedPriority) {

260 #if defined(RTE_Compiler_EventRecorder)

261 EventRecord2(EvtFreeRTOSTasks_TaskPriorityInherit, (uint32_t)pxTCBOfMutexHolder, (uint32_t)uxInheritedPriority);

262 #else

263 (void)pxTCBOfMutexHolder;

264 (void)uxInheritedPriority;

265 #endif

266 }

267 #endif

268

269 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_PRIORITY_DISINHERIT_DISABLE))

270 void EvrFreeRTOSTasks_TaskPriorityDisinherit (/*TCB_t*/void *pxTCBOfMutexHolder, uint32_t uxOriginalPriority) {

271 #if defined(RTE_Compiler_EventRecorder)

272 EventRecord2(EvtFreeRTOSTasks_TaskPriorityDisinherit, (uint32_t)pxTCBOfMutexHolder, (uint32_t)uxOriginalPriority);

273 #else

274 (void)pxTCBOfMutexHolder;

275 (void)uxOriginalPriority;

276 #endif

277 }

278 #endif

279

280 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceMOVED_TASK_TO_READY_STATE_DISABLE))

281 void EvrFreeRTOSTasks_MovedTaskToReadyState (/*TCB_t*/void *pxTCB) {

282 #if defined(RTE_Compiler_EventRecorder)

283 EventRecord2(EvtFreeRTOSTasks_MovedTaskToReadyState, (uint32_t)pxTCB, 0U);

284 #else

285 (void)pxTCB;

286 #endif

287 }

288 #endif

289

290 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(tracePOST_MOVED_TASK_TO_READY_STATE_DISABLE))

291 void EvrFreeRTOSTasks_PostMovedTaskToReadyState (/*TCB_t*/void *pxTCB) {

292 #if defined(RTE_Compiler_EventRecorder)

293 EventRecord2(EvtFreeRTOSTasks_PostMovedTaskToReadyState, (uint32_t)pxTCB, 0U);

294 #else

295 (void)pxTCB;

296 #endif

297 }

298 #endif

299

300 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceLOW_POWER_IDLE_BEGIN_DISABLE))

301 void EvrFreeRTOSTasks_LowPowerIdleBegin (uint32_t xExpectedIdleTime) {

302 #if defined(RTE_Compiler_EventRecorder)

303 EventRecord2(EvtFreeRTOSTasks_LowPowerIdleBegin, xExpectedIdleTime, 0U);

304 #else

305 (void)xExpectedIdleTime;

306 #endif

307 }

308 #endif

309

310 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceLOW_POWER_IDLE_END_DISABLE))

311 void EvrFreeRTOSTasks_LowPowerIdleEnd (void) {

312 #if defined(RTE_Compiler_EventRecorder)

313 EventRecord2(EvtFreeRTOSTasks_LowPowerIdleEnd, 0U, 0U);

314 #endif

315 }

316 #endif

317

318 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_NOTIFY_TAKE_BLOCK_DISABLE))

319 void EvrFreeRTOSTasks_TaskNotifyTakeBlock (uint32_t xTicksToWait) {

320 #if defined(RTE_Compiler_EventRecorder)

321 EventRecord2(EvtFreeRTOSTasks_TaskNotifyTakeBlock, xTicksToWait, 0U);

322 #else

323 (void)xTicksToWait;

324 #endif

325 }

326 #endif

327

328 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_NOTIFY_TAKE_DISABLE))

329 void EvrFreeRTOSTasks_TaskNotifyTake (uint32_t ulNotifiedValue) {

330 #if defined(RTE_Compiler_EventRecorder)

331 EventRecord2(EvtFreeRTOSTasks_TaskNotifyTake, ulNotifiedValue, 0U);

332 #else

333 (void)ulNotifiedValue;

334 #endif

335 }

336 #endif

337

338 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_NOTIFY_WAIT_BLOCK_DISABLE))

339 void EvrFreeRTOSTasks_TaskNotifyWaitBlock (uint32_t xTicksToWait) {

340 #if defined(RTE_Compiler_EventRecorder)

341 EventRecord2(EvtFreeRTOSTasks_TaskNotifyWaitBlock, xTicksToWait, 0U);

342 #else

343 (void)xTicksToWait;

344 #endif

345 }

346 #endif

347

348 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_NOTIFY_WAIT_DISABLE))

349 void EvrFreeRTOSTasks_TaskNotifyWait (uint32_t ulNotifiedValue) {

350 #if defined(RTE_Compiler_EventRecorder)

351 EventRecord2(EvtFreeRTOSTasks_TaskNotifyWait, ulNotifiedValue, 0U);

352 #else

353 (void)ulNotifiedValue;

354 #endif

355 }

356 #endif

357

358 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_NOTIFY_DISABLE))

359 void EvrFreeRTOSTasks_TaskNotify (/*TCB_t*/void *xTaskToNotify, uint32_t ulValue, /*eNotifyAction*/uint32_t eAction, uint32_t ulNotifiedValue) {

360 #if defined(RTE_Compiler_EventRecorder)

361 EventRecord4(EvtFreeRTOSTasks_TaskNotify, (uint32_t)xTaskToNotify, ulValue, eAction, ulNotifiedValue);

362 #else

363 (void)xTaskToNotify;

364 (void)ulValue;

365 (void)eAction;

366 (void)ulNotifiedValue;

367 #endif

368 }

369 #endif

370

371 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_NOTIFY_FROM_ISR_DISABLE))

372 void EvrFreeRTOSTasks_TaskNotifyFromIsr (/*TCB_t*/void *xTaskToNotify, uint32_t ulValue, /*eNotifyAction*/uint32_t eAction, uint32_t ulNotifiedValue) {

373 #if defined(RTE_Compiler_EventRecorder)

374 EventRecord4(EvtFreeRTOSTasks_TaskNotifyFromIsr, (uint32_t)xTaskToNotify, ulValue, eAction, ulNotifiedValue);

375 #else

376 (void)xTaskToNotify;

377 (void)ulValue;

378 (void)eAction;

379 (void)ulNotifiedValue;

380 #endif

381 }

382 #endif

383

384 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTASK_NOTIFY_GIVE_FROM_ISR_DISABLE))

385 void EvrFreeRTOSTasks_TaskNotifyGiveFromIsr (/*TCB_t*/void *xTaskToNotify, uint32_t ulNotifiedValue) {

386 #if defined(RTE_Compiler_EventRecorder)

387 EventRecord2(EvtFreeRTOSTasks_TaskNotifyGiveFromIsr, (uint32_t)xTaskToNotify, ulNotifiedValue);

388 #else

389 (void)xTaskToNotify;

390 (void)ulNotifiedValue;

391 #endif

392 }

393 #endif

394

395

396 /* Queue */

397

398 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_CREATE_DISABLE))

399 void EvrFreeRTOSQueue_QueueCreate (/*Queue_t*/void *pxQueue) {

400 #if defined(RTE_Compiler_EventRecorder)

401 EventRecord2(EvtFreeRTOSQueue_QueueCreate, (uint32_t)pxQueue, 0U);

402 #else

403 (void)pxQueue;

404 #endif

405 }

406 #endif

407

408 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_CREATE_FAILED_DISABLE))

409 void EvrFreeRTOSQueue_QueueCreateFailed (uint32_t ucQueueType) {

410 #if defined(RTE_Compiler_EventRecorder)

411 EventRecord2(EvtFreeRTOSQueue_QueueCreateFailed, ucQueueType, 0U);

412 #else

413 (void)ucQueueType;

414 #endif

415 }

416 #endif

417

418 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceCREATE_MUTEX_DISABLE))

419 void EvrFreeRTOSQueue_CreateMutex (/*Queue_t*/void *pxNewQueue) {

420 #if defined(RTE_Compiler_EventRecorder)

421 EventRecord2(EvtFreeRTOSQueue_CreateMutex, (uint32_t)pxNewQueue, 0U);

422 #else

423 (void)pxNewQueue;

424 #endif

425 }

426 #endif

427

428 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceCREATE_MUTEX_FAILED_DISABLE))

429 void EvrFreeRTOSQueue_CreateMutexFailed (void) {

430 #if defined(RTE_Compiler_EventRecorder)

431 EventRecord2(EvtFreeRTOSQueue_CreateMutexFailed, 0U, 0U);

432 #endif

433 }

434 #endif

435

436 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceGIVE_MUTEX_RECURSIVE_DISABLE))

437 void EvrFreeRTOSQueue_GiveMutexRecursive (/*Queue_t*/void *pxMutex) {

438 #if defined(RTE_Compiler_EventRecorder)

439 EventRecord2(EvtFreeRTOSQueue_GiveMutexRecursive, (uint32_t)pxMutex, 0U);

440 #else

441 (void)pxMutex;

442 #endif

443 }

444 #endif

445

446 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceGIVE_MUTEX_RECURSIVE_FAILED_DISABLE))

447 void EvrFreeRTOSQueue_GiveMutexRecursiveFailed (/*Queue_t*/void *pxMutex) {

448 #if defined(RTE_Compiler_EventRecorder)

449 EventRecord2(EvtFreeRTOSQueue_GiveMutexRecursiveFailed, (uint32_t)pxMutex, 0U);

450 #else

451 (void)pxMutex;

452 #endif

453 }

454 #endif

455

456 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTAKE_MUTEX_RECURSIVE_DISABLE))

457 void EvrFreeRTOSQueue_TakeMutexRecursive (/*Queue_t*/void *pxMutex) {

458 #if defined(RTE_Compiler_EventRecorder)

459 EventRecord2(EvtFreeRTOSQueue_TakeMutexRecursive, (uint32_t)pxMutex, 0U);

460 #else

461 (void)pxMutex;

462 #endif

463 }

464 #endif

465

466 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTAKE_MUTEX_RECURSIVE_FAILED_DISABLE))

467 void EvrFreeRTOSQueue_TakeMutexRecursiveFailed (/*Queue_t*/void *pxMutex) {

468 #if defined(RTE_Compiler_EventRecorder)

469 EventRecord2(EvtFreeRTOSQueue_TakeMutexRecursiveFailed, (uint32_t)pxMutex, 0U);

470 #else

471 (void)pxMutex;

472 #endif

473 }

474 #endif

475

476 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceCREATE_COUNTING_SEMAPHORE_DISABLE))

477 void EvrFreeRTOSQueue_CreateCountingSemaphore (/*Queue_t*/void *xHandle) {

478 #if defined(RTE_Compiler_EventRecorder)

479 EventRecord2(EvtFreeRTOSQueue_CreateCountingSemaphore, (uint32_t)xHandle, 0U);

480 #else

481 (void)xHandle;

482 #endif

483 }

484 #endif

485

486 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceCREATE_COUNTING_SEMAPHORE_FAILED_DISABLE))

487 void EvrFreeRTOSQueue_CreateCountingSemaphoreFailed (void) {

488 #if defined(RTE_Compiler_EventRecorder)

489 EventRecord2(EvtFreeRTOSQueue_CreateCountingSemaphoreFailed, 0U, 0U);

490 #endif

491 }

492 #endif

493

494 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_SEND_DISABLE))

495 void EvrFreeRTOSQueue_QueueSend (/*Queue_t*/void *pxQueue) {

496 #if defined(RTE_Compiler_EventRecorder)

497 EventRecord2(EvtFreeRTOSQueue_QueueSend, (uint32_t)pxQueue, 0U);

498 #else

499 (void)pxQueue;

500 #endif

501 }

502 #endif

503

504 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_SEND_FAILED_DISABLE))

505 void EvrFreeRTOSQueue_QueueSendFailed (/*Queue_t*/void *pxQueue) {

506 #if defined(RTE_Compiler_EventRecorder)

507 EventRecord2(EvtFreeRTOSQueue_QueueSendFailed, (uint32_t)pxQueue, 0U);

508 #else

509 (void)pxQueue;

510 #endif

511 }

512 #endif

513

514 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_RECEIVE_DISABLE))

515 void EvrFreeRTOSQueue_QueueReceive (/*Queue_t*/void *pxQueue) {

516 #if defined(RTE_Compiler_EventRecorder)

517 EventRecord2(EvtFreeRTOSQueue_QueueReceive, (uint32_t)pxQueue, 0U);

518 #else

519 (void)pxQueue;

520 #endif

521 }

522 #endif

523

524 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_PEEK_DISABLE))

525 void EvrFreeRTOSQueue_QueuePeek (/*Queue_t*/void *pxQueue) {

526 #if defined(RTE_Compiler_EventRecorder)

527 EventRecord2(EvtFreeRTOSQueue_QueuePeek, (uint32_t)pxQueue, 0U);

528 #else

529 (void)pxQueue;

530 #endif

531 }

532 #endif

533

534 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_PEEK_FROM_ISR_DISABLE))

535 void EvrFreeRTOSQueue_QueuePeekFromIsr (/*Queue_t*/void *pxQueue) {

536 #if defined(RTE_Compiler_EventRecorder)

537 EventRecord2(EvtFreeRTOSQueue_QueuePeekFromIsr, (uint32_t)pxQueue, 0U);

538 #else

539 (void)pxQueue;

540 #endif

541 }

542 #endif

543

544 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_RECEIVE_FAILED_DISABLE))

545 void EvrFreeRTOSQueue_QueueReceiveFailed (/*Queue_t*/void *pxQueue) {

546 #if defined(RTE_Compiler_EventRecorder)

547 EventRecord2(EvtFreeRTOSQueue_QueueReceiveFailed, (uint32_t)pxQueue, 0U);

548 #else

549 (void)pxQueue;

550 #endif

551 }

552 #endif

553

554 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_SEND_FROM_ISR_DISABLE))

555 void EvrFreeRTOSQueue_QueueSendFromIsr (/*Queue_t*/void *pxQueue) {

556 #if defined(RTE_Compiler_EventRecorder)

557 EventRecord2(EvtFreeRTOSQueue_QueueSendFromIsr, (uint32_t)pxQueue, 0U);

558 #else

559 (void)pxQueue;

560 #endif

561 }

562 #endif

563

564 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_SEND_FROM_ISR_FAILED_DISABLE))

565 void EvrFreeRTOSQueue_QueueSendFromIsrFailed (/*Queue_t*/void *pxQueue) {

566 #if defined(RTE_Compiler_EventRecorder)

567 EventRecord2(EvtFreeRTOSQueue_QueueSendFromIsrFailed, (uint32_t)pxQueue, 0U);

568 #else

569 (void)pxQueue;

570 #endif

571 }

572 #endif

573

574 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_RECEIVE_FROM_ISR_DISABLE))

575 void EvrFreeRTOSQueue_QueueReceiveFromIsr (/*Queue_t*/void *pxQueue) {

576 #if defined(RTE_Compiler_EventRecorder)

577 EventRecord2(EvtFreeRTOSQueue_QueueReceiveFromIsr, (uint32_t)pxQueue, 0U);

578 #else

579 (void)pxQueue;

580 #endif

581 }

582 #endif

583

584 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_RECEIVE_FROM_ISR_FAILED_DISABLE))

585 void EvrFreeRTOSQueue_QueueReceiveFromIsrFailed (/*Queue_t*/void *pxQueue) {

586 #if defined(RTE_Compiler_EventRecorder)

587 EventRecord2(EvtFreeRTOSQueue_QueueReceiveFromIsrFailed, (uint32_t)pxQueue, 0U);

588 #else

589 (void)pxQueue;

590 #endif

591 }

592 #endif

593

594 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_PEEK_FROM_ISR_FAILED_DISABLE))

595 void EvrFreeRTOSQueue_QueuePeekFromIsrFailed (/*Queue_t*/void *pxQueue) {

596 #if defined(RTE_Compiler_EventRecorder)

597 EventRecord2(EvtFreeRTOSQueue_QueuePeekFromIsrFailed, (uint32_t)pxQueue, 0U);

598 #else

599 (void)pxQueue;

600 #endif

601 }

602 #endif

603

604 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_DELETE_DISABLE))

605 void EvrFreeRTOSQueue_QueueDelete (/*Queue_t*/void *pxQueue) {

606 #if defined(RTE_Compiler_EventRecorder)

607 EventRecord2(EvtFreeRTOSQueue_QueueDelete, (uint32_t)pxQueue, 0U);

608 #else

609 (void)pxQueue;

610 #endif

611 }

612 #endif

613

614 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceQUEUE_REGISTRY_ADD_DISABLE))

615 void EvrFreeRTOSQueue_QueueRegistryAdd (/*Queue_t*/void *pxQueue, const char *pcQueueName) {

616 #if defined(RTE_Compiler_EventRecorder)

617 EventRecord2(EvtFreeRTOSQueue_QueueRegistryAdd, (uint32_t)pxQueue, (uint32_t)pcQueueName);

618 #else

619 (void)pxQueue;

620 (void)pcQueueName;

621 #endif

622 }

623 #endif

624

625 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceBLOCKING_ON_QUEUE_RECEIVE_DISABLE))

626 void EvrFreeRTOSQueue_BlockingOnQueueReceive (/*Queue_t*/void *pxQueue) {

627 #if defined(RTE_Compiler_EventRecorder)

628 EventRecord2(EvtFreeRTOSQueue_BlockingOnQueueReceive, (uint32_t)pxQueue, 0U);

629 #else

630 (void)pxQueue;

631 #endif

632 }

633 #endif

634

635 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceBLOCKING_ON_QUEUE_SEND_DISABLE))

636 void EvrFreeRTOSQueue_BlockingOnQueueSend (/*Queue_t*/void *pxQueue) {

637 #if defined(RTE_Compiler_EventRecorder)

638 EventRecord2(EvtFreeRTOSQueue_BlockingOnQueueSend, (uint32_t)pxQueue, 0U);

639 #else

640 (void)pxQueue;

641 #endif

642 }

643 #endif

644

645

646 /* Timers */

647

648 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTIMER_CREATE_DISABLE))

649 void EvrFreeRTOSTimers_TimerCreate (/*Timer_t*/void *pxNewTimer) {

650 #if defined(RTE_Compiler_EventRecorder)

651 EventRecord2(EvtFreeRTOSTimers_TimerCreate, (uint32_t)pxNewTimer, 0U);

652 #else

653 (void)pxNewTimer;

654 #endif

655 }

656 #endif

657

658 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTIMER_CREATE_FAILED_DISABLE))

659 void EvrFreeRTOSTimers_TimerCreateFailed (void) {

660 #if defined(RTE_Compiler_EventRecorder)

661 EventRecord2(EvtFreeRTOSTimers_TimerCreateFailed, 0U, 0U);

662 #endif

663 }

664 #endif

665

666 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTIMER_COMMAND_SEND_DISABLE))

667 void EvrFreeRTOSTimers_TimerCommandSend (/*Timer_t*/void *pxTimer, uint32_t xCommandID, uint32_t xOptionalValue, uint32_t xReturn) {

668 #if defined(RTE_Compiler_EventRecorder)

669 EventRecord4(EvtFreeRTOSTimers_TimerCommandSend, (uint32_t)pxTimer, xCommandID, xOptionalValue, xReturn);

670 #else

671 (void)pxTimer;

672 (void)xCommandID;

673 (void)xOptionalValue;

674 (void)xReturn;

675 #endif

676 }

677 #endif

678

679 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTIMER_COMMAND_RECEIVED_DISABLE))

680 void EvrFreeRTOSTimers_TimerCommandReceived (/*Timer_t*/void *pxTimer, uint32_t xCommandID, uint32_t xOptionalValue) {

681 #if defined(RTE_Compiler_EventRecorder)

682 EventRecord4(EvtFreeRTOSTimers_TimerCommandReceived, (uint32_t)pxTimer, xCommandID, xOptionalValue, 0U);

683 #else

684 (void)pxTimer;

685 (void)xCommandID;

686 (void)xOptionalValue;

687 #endif

688 }

689 #endif

690

691 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceTIMER_EXPIRED_DISABLE))

692 void EvrFreeRTOSTimers_TimerExpired (/*Timer_t*/void *pxTimer) {

693 #if defined(RTE_Compiler_EventRecorder)

694 EventRecord2(EvtFreeRTOSTimers_TimerExpired, (uint32_t)pxTimer, 0U);

695 #else

696 (void)pxTimer;

697 #endif

698 }

699 #endif

700

701 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(tracePEND_FUNC_CALL_DISABLE))

702 void EvrFreeRTOSTimers_PendFuncCall (/*PendedFunction_t*/void *pxFunctionToPend, void *pvParameter1, uint32_t ulParameter2, uint32_t xReturn) {

703 #if defined(RTE_Compiler_EventRecorder)

704 EventRecord4(EvtFreeRTOSTimers_PendFuncCall, (uint32_t)pxFunctionToPend, (uint32_t)pvParameter1, ulParameter2, xReturn);

705 #else

706 (void)pxFunctionToPend;

707 (void)pvParameter1;

708 (void)ulParameter2;

709 (void)xReturn;

710 #endif

711 }

712 #endif

713

714 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(tracePEND_FUNC_CALL_FROM_ISR_DISABLE))

715 void EvrFreeRTOSTimers_PendFuncCallFromIsr (/*PendedFunction_t*/void *pxFunctionToPend, void *pvParameter1, uint32_t ulParameter2, uint32_t xReturn) {

716 #if defined(RTE_Compiler_EventRecorder)

717 EventRecord4(EvtFreeRTOSTimers_PendFuncCallFromIsr, (uint32_t)pxFunctionToPend, (uint32_t)pvParameter1, ulParameter2, xReturn);

718 #else

719 (void)pxFunctionToPend;

720 (void)pvParameter1;

721 (void)ulParameter2;

722 (void)xReturn;

723 #endif

724 }

725 #endif

726

727

728 /* Event Groups */

729

730 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceEVENT_GROUP_CREATE_DISABLE))

731 void EvrFreeRTOSEventGroups_EventGroupCreate (/*EventGroup_t*/void *pxEventGroup) {

732 #if defined(RTE_Compiler_EventRecorder)

733 EventRecord2(EvtFreeRTOSEventGroups_EventGroupCreate, (uint32_t)pxEventGroup, 0U);

734 #else

735 (void)pxEventGroup;

736 #endif

737 }

738 #endif

739

740 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceEVENT_GROUP_CREATE_FAILED_DISABLE))

741 void EvrFreeRTOSEventGroups_EventGroupCreateFailed (void) {

742 #if defined(RTE_Compiler_EventRecorder)

743 EventRecord2(EvtFreeRTOSEventGroups_EventGroupCreateFailed, 0U, 0U);

744 #endif

745 }

746 #endif

747

748 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceEVENT_GROUP_SYNC_BLOCK_DISABLE))

749 void EvrFreeRTOSEventGroups_EventGroupSyncBlock (/*EventGroup_t*/void *pxEventGroup, uint32_t uxBitsToSet, uint32_t uxBitsToWaitFor) {

750 #if defined(RTE_Compiler_EventRecorder)

751 EventRecord4(EvtFreeRTOSEventGroups_EventGroupSyncBlock, (uint32_t)pxEventGroup, uxBitsToSet, uxBitsToWaitFor, 0U);

752 #else

753 (void)pxEventGroup;

754 (void)uxBitsToSet;

755 (void)uxBitsToWaitFor;

756 #endif

757 }

758 #endif

759

760 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceEVENT_GROUP_SYNC_END_DISABLE))

761 void EvrFreeRTOSEventGroups_EventGroupSyncEnd (/*EventGroup_t*/void *pxEventGroup, uint32_t uxBitsToSet, uint32_t uxBitsToWaitFor, uint32_t xTimeoutOccurred) {

762 #if defined(RTE_Compiler_EventRecorder)

763 EventRecord4(EvtFreeRTOSEventGroups_EventGroupSyncEnd, (uint32_t)pxEventGroup, uxBitsToSet, uxBitsToWaitFor, xTimeoutOccurred);

764 #else

765 (void)pxEventGroup;

766 (void)uxBitsToSet;

767 (void)uxBitsToWaitFor;

768 (void)xTimeoutOccurred;

769 #endif

770 }

771 #endif

772

773 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceEVENT_GROUP_WAIT_BITS_BLOCK_DISABLE))

774 void EvrFreeRTOSEventGroups_EventGroupWaitBitsBlock (/*EventGroup_t*/void *pxEventGroup, uint32_t uxBitsToWaitFor) {

775 #if defined(RTE_Compiler_EventRecorder)

776 EventRecord2(EvtFreeRTOSEventGroups_EventGroupWaitBitsBlock, (uint32_t)pxEventGroup, uxBitsToWaitFor);

777 #else

778 (void)pxEventGroup;

779 (void)uxBitsToWaitFor;

780 #endif

781 }

782 #endif

783

784 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceEVENT_GROUP_WAIT_BITS_END_DISABLE))

785 void EvrFreeRTOSEventGroups_EventGroupWaitBitsEnd (/*EventGroup_t*/void *pxEventGroup, uint32_t uxBitsToWaitFor, uint32_t xTimeoutOccurred) {

786 #if defined(RTE_Compiler_EventRecorder)

787 EventRecord4(EvtFreeRTOSEventGroups_EventGroupWaitBitsEnd, (uint32_t)pxEventGroup, uxBitsToWaitFor, xTimeoutOccurred, 0U);

788 #else

789 (void)pxEventGroup;

790 (void)uxBitsToWaitFor;

791 (void)xTimeoutOccurred;

792 #endif

793 }

794 #endif

795

796 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceEVENT_GROUP_CLEAR_BITS_DISABLE))

797 void EvrFreeRTOSEventGroups_EventGroupClearBits (/*EventGroup_t*/void *pxEventGroup, uint32_t uxBitsToClear) {

798 #if defined(RTE_Compiler_EventRecorder)

799 EventRecord2(EvtFreeRTOSEventGroups_EventGroupClearBits, (uint32_t)pxEventGroup, uxBitsToClear);

800 #else

801 (void)pxEventGroup;

802 (void)uxBitsToClear;

803 #endif

804 }

805 #endif

806

807 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceEVENT_GROUP_CLEAR_BITS_FROM_ISR_DISABLE))

808 void EvrFreeRTOSEventGroups_EventGroupClearBitsFromIsr (/*EventGroup_t*/void *pxEventGroup, uint32_t uxBitsToClear) {

809 #if defined(RTE_Compiler_EventRecorder)

810 EventRecord2(EvtFreeRTOSEventGroups_EventGroupClearBitsFromIsr, (uint32_t)pxEventGroup, uxBitsToClear);

811 #else

812 (void)pxEventGroup;

813 (void)uxBitsToClear;

814 #endif

815 }

816 #endif

817

818 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceEVENT_GROUP_SET_BITS_DISABLE))

819 void EvrFreeRTOSEventGroups_EventGroupSetBits (/*EventGroup_t*/void *pxEventGroup, uint32_t uxBitsToSet) {

820 #if defined(RTE_Compiler_EventRecorder)

821 EventRecord2(EvtFreeRTOSEventGroups_EventGroupSetBits, (uint32_t)pxEventGroup, uxBitsToSet);

822 #else

823 (void)pxEventGroup;

824 (void)uxBitsToSet;

825 #endif

826 }

827 #endif

828

829 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceEVENT_GROUP_SET_BITS_FROM_ISR_DISABLE))

830 void EvrFreeRTOSEventGroups_EventGroupSetBitsFromIsr (/*EventGroup_t*/void *pxEventGroup, uint32_t uxBitsToSet) {

831 #if defined(RTE_Compiler_EventRecorder)

832 EventRecord2(EvtFreeRTOSEventGroups_EventGroupSetBitsFromIsr, (uint32_t)pxEventGroup, uxBitsToSet);

833 #else

834 (void)pxEventGroup;

835 (void)uxBitsToSet;

836 #endif

837 }

838 #endif

839

840 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceEVENT_GROUP_DELETE_DISABLE))

841 void EvrFreeRTOSEventGroups_EventGroupDelete (/*EventGroup_t*/void *pxEventGroup) {

842 #if defined(RTE_Compiler_EventRecorder)

843 EventRecord2(EvtFreeRTOSEventGroups_EventGroupDelete, (uint32_t)pxEventGroup, 0U);

844 #else

845 (void)pxEventGroup;

846 #endif

847 }

848 #endif

849

850

851 /* Heap */

852

853 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceMALLOC_DISABLE))

854 void EvrFreeRTOSHeap_Malloc (void *pvAddress, uint32_t uiSize) {

855 #if defined(RTE_Compiler_EventRecorder)

856 EventRecord2(EvtFreeRTOSHeap_Malloc, (uint32_t)pvAddress, uiSize);

857 #else

858 (void)pvAddress;

859 (void)uiSize;

860 #endif

861 }

862 #endif

863

864 #if (!defined(EVR_FREERTOS_DISABLE) && !defined(traceFREE_DISABLE))

865 void EvrFreeRTOSHeap_Free (void *pvAddress, uint32_t uiSize) {

866 #if defined(RTE_Compiler_EventRecorder)

867 EventRecord2(EvtFreeRTOSHeap_Free, (uint32_t)pvAddress, uiSize);

868 #else

869 (void)pvAddress;

870 (void)uiSize;

871 #endif

872 }

873 #endif