Merge pull request #2293 from KeystoneHQ/merge/v3.1.0

### .gitattributes
@@ -0,0 +1 @@
+* text=auto eol=lf

### .github/workflows/rust-cardano-checks.yml
@@ -27,4 +27,4 @@ jobs:
         uses: taiki-e/install-action@cargo-llvm-cov
 
       - name: Run rust/apps/cardano
-        run: cd rust/apps/cardano && cargo +$RUST_TOOLCHAIN llvm-cov --fail-under-regions 53 --fail-under-functions 63 --fail-under-lines 66 --ignore-filename-regex 'keystore/*|utils/*'
+        run: cd rust/apps/cardano && cargo +$RUST_TOOLCHAIN llvm-cov --fail-under-regions 76 --fail-under-functions 65 --fail-under-lines 72 --ignore-filename-regex 'keystore/*|utils/*'

### CHANGELOG-ZH.md
@@ -1,3 +1,42 @@
+## 3.1.0 (2026-09-10)
+
+**Web3:**
+
+### 新增
+
+1. 优化初始化设置流程，新增固件升级及安全备份提示
+
+### 优化
+
+1. IOTA 交易解析优化
+2. ADA 交易解析优化
+3. SOL 默认展示 Sub-Account Path
+4. 移除 Core Wallet 连接入口
+5. USB 功能优化
+6. 安全策略优化
+
+
+**CYPHERPUNK:**
+
+### 新增
+
+1. 优化初始化设置流程，新增固件升级及安全备份提示
+
+### 优化
+
+1. 安全策略优化
+
+**BTC-ONLY:**
+
+### 新增
+
+1. 优化初始化设置流程，新增固件升级及安全备份提示
+
+
+### 优化
+
+1. 安全策略优化
+
 ## 3.0.8 (2026-09-15)
 
 **Web3:**
@@ -13,7 +52,6 @@
 ### 新增
 1. 支持 Solana V1 交易格式
 
-
 ## 3.0.4 (2026-8-10)
 
 **Web3:**

### CHANGELOG.md
@@ -1,3 +1,46 @@
+## 3.1.0 (2026-09-10)
+
+**Web3:**
+
+
+### What’s New
+
+1. Improved the initial setup process with new firmware update and secure backup reminders
+
+### Improvements
+
+1. Optimized IOTA transaction parsing
+2. Optimized ADA transaction parsing
+3. Displayed the Sub-Account Path by default for SOL
+4. Removed the Core Wallet connection entry
+5. Optimized USB functionality
+6. Enhanced security policies
+
+
+**CYPHERPUNK:**
+
+### What’s New
+
+1. Improved the initial setup process with new firmware update and secure backup reminders
+
+### Improvements
+
+1. Enhanced security policies
+
+
+
+
+**BTC-ONLY:**
+
+
+### What’s New
+
+1. Improved the initial setup process with new firmware update and secure backup reminders
+
+### Improvements
+
+1. Enhanced security policies
+
 ## 3.0.8 (2026-09-15)
 
 **Web3:**
@@ -13,7 +56,6 @@
 ### What's new
 1. Added support for Solana v1 transactions
 
-
 ## 3.0.4 (2026-08-10)
 
 **Web3:**

### CMakeLists.txt
@@ -1,6 +1,7 @@
-set(CMAKE_SYSTEM_NAME Generic)
 cmake_minimum_required(VERSION 3.10)
 
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
 option(COMPILE_KEYSTONE "compile on MAIN target" ON)
 
 set(BUILD_ENVIRONMENT "DEBUG")
@@ -123,7 +124,7 @@ set(EXTERNAL_INCLUDE_PATH
     external/cryptoauthlib/lib
     external/FreeRTOS
     external/FreeRTOS/Source/include
-    external/FreeRTOS/Source/portable/GCC/ARM_CM4F
+    external/FreeRTOS/Source/portable/GCC/ARM_CM4_MPU
     external/FreeRTOS/CMSIS_RTOS_V2
     external/lvgl
     external/lvgl/src
@@ -171,7 +172,7 @@ set(SRC_INCLUDE_PATH
 )
 
 set(INCLUDE_DIR
-    build/rust-builds
+    ${CMAKE_BINARY_DIR}/rust-builds
     ${SRC_INCLUDE_PATH}
     ${CRYPTO_INCLUDE_PATH}
     ${GUI_INCLUDE_PATH}
@@ -239,7 +240,16 @@ file(GLOB_RECURSE CRYPTO_SLIP39
 )
 
 if(COMPILE_KEYSTONE)
+    set(CMAKE_SYSTEM_NAME Generic)
     message(STATUS "Compiling for MAIN target")
+    set(CROSS_COMPILE_PREFIX arm-none-eabi)
+    set(CMAKE_C_COMPILER ${CROSS_COMPILE_PREFIX}-gcc)
+    set(CMAKE_CXX_COMPILER ${CROSS_COMPILE_PREFIX}-g++)
+    set(CMAKE_ASM_COMPILER ${CROSS_COMPILE_PREFIX}-gcc)
+    set(CMAKE_OBJCOPY ${CROSS_COMPILE_PREFIX}-objcopy)
+    set(CMAKE_OBJDUMP ${CROSS_COMPILE_PREFIX}-objdump)
+    set(CMAKE_SIZE ${CROSS_COMPILE_PREFIX}-size)
+    set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
     project(mh1903)
     include(firmware.cmake)
 
@@ -314,6 +324,33 @@ if(COMPILE_KEYSTONE)
         list(REMOVE_ITEM objsrc ${excluded_files})
     endforeach()
 
+    set_property(SOURCE
+        ${MH1903_DRIVER}
+        ${FREERTOS}
+        ${EXTERNAL}
+        ${USB_DRIVER}
+        ${LVGL}
+        ${SAFE_C}
+        ${CM_BACKTRACE}
+        APPEND PROPERTY COMPILE_OPTIONS
+        -Wno-format
+        -Wno-format-security
+    )
+
+    if(NOT BUILD_PRODUCTION)
+        set_property(SOURCE test/test_cmd.c APPEND PROPERTY COMPILE_OPTIONS
+            -Wno-error=format
+        )
+    endif()
+
+    set_property(SOURCE
+        src/tasks/mpu_sandbox_runtime.c
+        src/webusb_protocol/general/eapdu_framing.c
+        APPEND PROPERTY COMPILE_OPTIONS
+        -fno-builtin
+        -fno-tree-loop-distribute-patterns
+    )
+
     add_executable(${PROJECT_NAME}.elf ${objsrc})
     target_compile_definitions(${PROJECT_NAME}.elf PRIVATE ${COMMON_DEFINITIONS})
     target_include_directories(${PROJECT_NAME}.elf PRIVATE ${INCLUDE_DIR})
@@ -328,17 +365,19 @@ if(COMPILE_KEYSTONE)
     set(ELF_FILE ${PROJECT_BINARY_DIR}/${PROJECT_NAME}.elf)
     set(HEX_FILE ${PROJECT_BINARY_DIR}/${PROJECT_NAME}.hex)
     set(BIN_FILE ${PROJECT_BINARY_DIR}/${PROJECT_NAME}.bin)
-
+    file(RELATIVE_PATH ELF_FILE_FROM_SOURCE ${CMAKE_CURRENT_SOURCE_DIR} ${ELF_FILE})
     add_custom_command(TARGET "${PROJECT_NAME}.elf" POST_BUILD
+        COMMAND ${CMAKE_COMMAND} -E chdir ${CMAKE_CURRENT_SOURCE_DIR}
+                python tools/check_mpu_sandbox_elf.py
+                ${ELF_FILE_FROM_SOURCE} --objdump ${CMAKE_OBJDUMP}
         COMMAND ${CMAKE_OBJCOPY} -Obinary ${ELF_FILE} ${BIN_FILE}
         COMMAND ${CMAKE_OBJCOPY} -Oihex ${ELF_FILE} ${HEX_FILE}
-        COMMENT "Building ${PROJECT_NAME}.bin and ${PROJECT_NAME}.hex"
 
         COMMAND ${CMAKE_COMMAND} -E copy ${HEX_FILE} "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.hex"
         COMMAND ${CMAKE_COMMAND} -E copy ${BIN_FILE} "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.bin"
 
         COMMAND ${CMAKE_SIZE} --format=berkeley ${PROJECT_NAME}.elf ${PROJECT_NAME}.hex
-        COMMENT "Invoking: Cross ARM GNU Print Size"
+        COMMENT "Building firmware images and printing their sizes"
     )
 else()
     project(simulator)
@@ -397,4 +436,4 @@ else()
             COMMENT "Signing the executable"
         )
     endif()
-endif()
\ No newline at end of file
+endif()

### Dockerfile
@@ -1,4 +1,4 @@
-FROM ubuntu:20.04 as base
+FROM ubuntu:22.04 AS base
 ARG DEBIAN_FRONTEND=noninteractive
 RUN apt-get update -y
 RUN apt-get install -y \
@@ -24,7 +24,7 @@ RUN cargo install cbindgen bindgen-cli
 RUN pip3 install PyYaml
 RUN pip3 install pillow
 
-FROM base as pillar
+FROM base AS pillar
 RUN wget -q https://developer.arm.com/-/media/Files/downloads/gnu-rm/9-2019q4/gcc-arm-none-eabi-9-2019-q4-major-x86_64-linux.tar.bz2 -O  gcc-arm-none-eabi.tar.bz2
 RUN mkdir gcc-arm-none-eabi && tar xjf gcc-arm-none-eabi.tar.bz2 -C gcc-arm-none-eabi --strip-components 1
 RUN rm gcc-arm-none-eabi.tar.bz2

### build.bat
@@ -1,5 +1,6 @@
 @echo off
 SETLOCAL ENABLEEXTENSIONS
+SET "CARGO_TERM_COLOR=always"
 
 SET BUILD_FOLDER=%CD%\build
 SET BUILD_SIMULATOR_FOLDER=%CD%\build_simulator
@@ -9,7 +10,7 @@ SET MAKE_PADDING_FILE_PATH=%TOOLS_FOLDER%\padding_bin_file
 SET ASTYLE_PATH=%TOOLS_FOLDER%\AStyle.bat
 SET PACK_PATH=%CD%\pack.bat
 SET LANGUAGE_PATH=%CD%\src\ui\lv_i18n
-SET LANGUAGE_SCRIPT=py data_loader.py
+SET LANGUAGE_SCRIPT=python data_loader.py
 SET RUST_C_PATH=%CD%\rust\rust_c
 
 SET "build_options=log copy production screen debug format release rebuild btc_only cypherpunk simulator language clean"
@@ -40,18 +41,22 @@ IF NOT EXIST %BUILD_FOLDER%\padding_bin_file.py (
 )
 
 CALL :EXECUTE_BUILD
+SET "BUILD_EXIT_CODE=%ERRORLEVEL%"
 
-ENDLOCAL
-GOTO :EOF
+ENDLOCAL & EXIT /B %BUILD_EXIT_CODE%
 
 :EXECUTE_BUILD
 IF "%build_language%"=="true" (
     pushd %LANGUAGE_PATH%
     %LANGUAGE_SCRIPT%
-    popd  
+    IF ERRORLEVEL 1 (
+        popd
+        EXIT /B 1
+    )
+    popd
 )
 
-SET "cmake_parm=-DBUILD_PRODUCTION=false -DBTC_ONLY=false -DCYPHERPUNK=false -DENABLE_SCREEN_SHOT=false -DDEBUG_MEMORY=false"
+SET "cmake_parm=-DCMAKE_COLOR_DIAGNOSTICS=ON -DBUILD_PRODUCTION=false -DBTC_ONLY=false -DCYPHERPUNK=false -DENABLE_SCREEN_SHOT=false -DDEBUG_MEMORY=false"
 IF "%build_production%"=="true" SET "cmake_parm=%cmake_parm% -DBUILD_PRODUCTION=true"
 IF "%build_btc_only%"=="true" SET "cmake_parm=%cmake_parm% -DBTC_ONLY=true"
 IF "%build_cypherpunk%"=="true" SET "cmake_parm=%cmake_parm% -DCYPHERPUNK=true"
@@ -61,18 +66,23 @@ IF "%build_debug%"=="true" SET "cmake_parm=%cmake_parm% -DDEBUG_MEMORY=true"
 IF "%build_simulator%"=="true" (
     IF NOT EXIST %BUILD_SIMULATOR_FOLDER% mkdir %BUILD_SIMULATOR_FOLDER%
     pushd %BUILD_SIMULATOR_FOLDER%
-    cmake -G "Unix Makefiles" -DBUILD_TYPE=Simulator %cmake_parm% .. 
-    make -j16
+    cmake -G Ninja -DBUILD_TYPE=Simulator %cmake_parm% ..
+    IF ERRORLEVEL 1 EXIT /B 1
+    cmake --build .
+    IF ERRORLEVEL 1 EXIT /B 1
     popd
 ) ELSE (
     pushd %BUILD_FOLDER%
-    cmake -G "Unix Makefiles" %cmake_parm% ..
+    cmake -G Ninja -DCMAKE_TRY_COMPILE_TARGET_TYPE=STATIC_LIBRARY %cmake_parm% ..
+    IF ERRORLEVEL 1 EXIT /B 1
     IF "%build_log%"=="true" (
-        make -j16 > makefile.log 2>&1
+        cmake --build . > build.log 2>&1
     ) ELSE (
-        make -j16
+        cmake --build .
     )
+    IF ERRORLEVEL 1 EXIT /B 1
     python padding_bin_file.py mh1903.bin
+    IF ERRORLEVEL 1 EXIT /B 1
     popd
 )
 

### build.py
@@ -146,6 +146,5 @@ def build_images(images_directory):
     if platform.system() == 'Darwin':
         ota_maker()
     purpose = args.purpose
-    if purpose and purpose == "debug":
+    if purpose == "debug" and platform.system() == 'Darwin':
         ota_maker()
-

### external/FreeRTOS/CMSIS_RTOS_V2/cmsis_os2.c
@@ -31,6 +31,7 @@
 #include "task.h"                       // ARM.FreeRTOS::RTOS:Core
 #include "event_groups.h"               // ARM.FreeRTOS::RTOS:Event Groups
 #include "semphr.h"                     // ARM.FreeRTOS::RTOS:Core
+#include "user_memory.h"
 
 /*---------------------------------------------------------------------------*/
 #ifndef __ARM_ARCH_6M__
@@ -176,6 +177,11 @@ osKernelState_t osKernelGetState(void)
 {
     osKernelState_t state;
 
+    /* The MPU wrapper must not issue an SVC from Handler mode. */
+    if (IS_IRQ()) {
+        return KernelState;
+    }
+
     switch (xTaskGetSchedulerState()) {
     case taskSCHEDULER_RUNNING:
         state = osKernelRunning;
@@ -399,6 +405,9 @@ osThreadId_t osThreadNew(osThreadFunc_t func, void *argument, const osThreadAttr
             mem = 0;
         }
 
+        /* Existing firmware tasks remain privileged during the MPU baseline phase. */
+        prio |= portPRIVILEGE_BIT;
+
         if (mem == 1) {
             hTask = xTaskCreateStatic((TaskFunction_t) func, name, stack, argument, prio, (StackType_t  *) attr->stack_mem,
                                       (StaticTask_t *) attr->cb_mem);
@@ -643,7 +652,7 @@ uint32_t osThreadEnumerate(osThreadId_t *thread_array, uint32_t array_items)
             count = uxTaskGetSystemState(task, count, NULL);
 
             for (i = 0U; (i < count) && (i < array_items); i++) {
-                thread_array[i] = (osThreadId_t) task[i].xHandle;
+                thread_array[i] = (osThreadId_t) xTaskGetHandle(task[i].pcTaskName);
             }
             count = i;
         }
@@ -1717,21 +1726,16 @@ uint32_t osMessageQueueGetCount(osMessageQueueId_t mq_id)
 
 uint32_t osMessageQueueGetSpace(osMessageQueueId_t mq_id)
 {
-    StaticQueue_t *mq = (StaticQueue_t *) mq_id;
+    QueueHandle_t hQueue = (QueueHandle_t) mq_id;
     uint32_t space;
-    uint32_t isrm;
 
-    if (mq == NULL) {
+    if (hQueue == NULL) {
         space = 0U;
     } else if (IS_IRQ()) {
-        isrm = taskENTER_CRITICAL_FROM_ISR();
-
-        /* space = pxQueue->uxLength - pxQueue->uxMessagesWaiting; */
-        space = mq->uxDummy4[1] - mq->uxDummy4[0];
-
-        taskEXIT_CRITICAL_FROM_ISR(isrm);
+        /* This project only calls this query from task context. */
+        space = 0U;
     } else {
-        space = (uint32_t) uxQueueSpacesAvailable((QueueHandle_t) mq);
+        space = (uint32_t) uxQueueSpacesAvailable(hQueue);
     }
 
     return (space);
@@ -1786,7 +1790,7 @@ extern void vApplicationIdleHook(void);
 extern void vApplicationTickHook(void);
 extern void vApplicationMallocFailedHook(void);
 extern void vApplicationDaemonTaskStartupHook(void);
-extern void vApplicationStackOverflowHook(TaskHandle_t xTask, signed char *pcTaskName);
+extern void vApplicationStackOverflowHook(TaskHandle_t xTask, char *pcTaskName);
 
 /**
   Dummy implementation of the callback function vApplicationIdleHook().
@@ -1820,7 +1824,7 @@ __WEAK void vApplicationDaemonTaskStartupHook(void) {}
   Dummy implementation of the callback function vApplicationStackOverflowHook().
 */
 #if (configCHECK_FOR_STACK_OVERFLOW > 0)
-__WEAK void vApplicationStackOverflowHook(TaskHandle_t xTask, signed char *pcTaskName)
+__WEAK void vApplicationStackOverflowHook(TaskHandle_t xTask, char *pcTaskName)
 {
     (void) xTask;
     (void) pcTaskName;

### external/FreeRTOS/FreeRTOSConfig.h
@@ -1,6 +1,6 @@
 /* USER CODE BEGIN Header */
 /*
- * FreeRTOS Kernel V10.0.1
+ * FreeRTOS Kernel V11.3.0
  * Copyright (C) 2017 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
@@ -42,9 +42,9 @@
  * See http://www.freertos.org/a00110.html
  *----------------------------------------------------------*/
 
-/* USER CODE BEGIN Includes */
-/* Section where include file can be added */
-/* USER CODE END Includes */
+/* USER CODE BEGIN Includes */
+#include "rtos_expand.h"
+/* USER CODE END Includes */
 
 /* Ensure definitions are only used by the compiler, and not by the assembler. */
 #if defined(__ICCARM__) || defined(__CC_ARM) || defined(__GNUC__)
@@ -62,11 +62,23 @@ extern uint32_t SystemCoreClock;
 #define configTICK_RATE_HZ                          ((TickType_t)1000)
 #define configMAX_PRIORITIES                        ( 56 )
 #define configMINIMAL_STACK_SIZE                    ((uint16_t)128)
-#define configTOTAL_HEAP_SIZE                       ((size_t)1024 * 440)
+#define configCHECK_FOR_STACK_OVERFLOW              2
+#define configTOTAL_HEAP_SIZE                       ((size_t)1024 * 424)
 #define configMAX_TASK_NAME_LEN                     ( 16 )
-#define configUSE_TRACE_FACILITY                    1
-#define configUSE_16_BIT_TICKS                      0
-#define configUSE_MUTEXES                           1
+#define configUSE_TRACE_FACILITY                    1
+#define configUSE_16_BIT_TICKS                      0
+#define configRECORD_STACK_HIGH_ADDRESS             1
+#define configTOTAL_MPU_REGIONS                     8
+#define configUSE_MPU_WRAPPERS_V1                   0
+#define configSYSTEM_CALL_STACK_SIZE                128
+#define configPROTECTED_KERNEL_OBJECT_POOL_SIZE     128
+#define configENABLE_ACCESS_CONTROL_LIST            1
+#define configUSE_APPLICATION_DEFINED_SYSTEM_CALL_FILTER 1
+#define configENFORCE_SYSTEM_CALLS_FROM_KERNEL_ONLY 1
+#define configALLOW_UNPRIVILEGED_CRITICAL_SECTIONS  0
+#define configAPPLICATION_ALLOCATED_HEAP            1
+#define configALLOW_UNPRIVILEGED_PERIPHERAL_ACCESS  0
+#define configUSE_MUTEXES                           1
 #define configQUEUE_REGISTRY_SIZE                   8
 #define configUSE_RECURSIVE_MUTEXES                 1
 #define configUSE_COUNTING_SEMAPHORES               1
@@ -135,7 +147,27 @@ See http://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html. */
 /* Normal assert() semantics without relying on the provision of an assert.h
 header file. */
 /* USER CODE BEGIN 1 */
-#define configASSERT( x ) if ((x) == 0) {printf("assert file=%s, line=%d\r\n", __FILE__, __LINE__); taskDISABLE_INTERRUPTS(); for( ;; );}
+#define configASSERT( x )                                                        \
+    do {                                                                         \
+        if( ( x ) == 0 ) {                                                       \
+            uint32_t ulAssertIpsr;                                               \
+            int32_t lAssertIrq;                                                  \
+            uint32_t ulAssertPriority = 0xFFFFFFFFUL;                            \
+            __asm volatile ( "mrs %0, ipsr" : "=r" ( ulAssertIpsr )::"memory" ); \
+            lAssertIrq = ( int32_t ) ulAssertIpsr - 16;                          \
+            if( lAssertIrq >= 0 ) {                                              \
+                ulAssertPriority = ( ( volatile uint8_t * ) 0xE000E400UL )[ lAssertIrq ]; \
+            }                                                                    \
+            printf( "assert file=%s, line=%d, ipsr=%lu, irq=%ld, "              \
+                    "prio=0x%02lX, max_syscall=0x%02X, aircr=0x%08lX\r\n",      \
+                    __FILE__, __LINE__, ( unsigned long ) ulAssertIpsr,           \
+                    ( long ) lAssertIrq, ( unsigned long ) ulAssertPriority,      \
+                    ( unsigned int ) configMAX_SYSCALL_INTERRUPT_PRIORITY,       \
+                    ( unsigned long ) ( *( ( volatile uint32_t * ) 0xE000ED0CUL ) ) ); \
+            taskDISABLE_INTERRUPTS();                                            \
+            for( ;; );                                                           \
+        }                                                                        \
+    } while( 0 )
 /* USER CODE END 1 */
 
 /* Definitions that map the FreeRTOS port interrupt handlers to their CMSIS

### external/FreeRTOS/LICENSE.md
@@ -0,0 +1,19 @@
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

### external/FreeRTOS/Source/croutine.c
@@ -1,6 +1,6 @@
 /*
- * FreeRTOS Kernel V10.4.6
- * Copyright (C) 2021 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ * FreeRTOS Kernel V11.3.0
+ * Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -30,33 +30,35 @@
 #include "task.h"
 #include "croutine.h"
 
-/* Remove the whole file is co-routines are not being used. */
+/* Remove the whole file if co-routines are not being used. */
 #if ( configUSE_CO_ROUTINES != 0 )
 
 /*
  * Some kernel aware debuggers require data to be viewed to be global, rather
  * than file scope.
  */
-#ifdef portREMOVE_STATIC_QUALIFIER
-#define static
-#endif
+    #ifdef portREMOVE_STATIC_QUALIFIER
+        #define static
+    #endif
 
 
 /* Lists for ready and blocked co-routines. --------------------*/
-static List_t pxReadyCoRoutineLists[ configMAX_CO_ROUTINE_PRIORITIES ]; /*< Prioritised ready co-routines. */
-static List_t xDelayedCoRoutineList1;                                   /*< Delayed co-routines. */
-static List_t xDelayedCoRoutineList2;                                   /*< Delayed co-routines (two lists are used - one for delays that have overflowed the current tick count. */
-static List_t * pxDelayedCoRoutineList = NULL;                          /*< Points to the delayed co-routine list currently being used. */
-static List_t * pxOverflowDelayedCoRoutineList = NULL;                  /*< Points to the delayed co-routine list currently being used to hold co-routines that have overflowed the current tick count. */
-static List_t xPendingReadyCoRoutineList;                               /*< Holds co-routines that have been readied by an external event.  They cannot be added directly to the ready lists as the ready lists cannot be accessed by interrupts. */
+    static List_t pxReadyCoRoutineLists[ configMAX_CO_ROUTINE_PRIORITIES ]; /**< Prioritised ready co-routines. */
+    static List_t xDelayedCoRoutineList1;                                   /**< Delayed co-routines. */
+    static List_t xDelayedCoRoutineList2;                                   /**< Delayed co-routines (two lists are used - one for delays that have overflowed the current tick count. */
+    static List_t * pxDelayedCoRoutineList = NULL;                          /**< Points to the delayed co-routine list currently being used. */
+    static List_t * pxOverflowDelayedCoRoutineList = NULL;                  /**< Points to the delayed co-routine list currently being used to hold co-routines that have overflowed the current tick count. */
+    static List_t xPendingReadyCoRoutineList;                               /**< Holds co-routines that have been readied by an external event.  They cannot be added directly to the ready lists as the ready lists cannot be accessed by interrupts. */
 
 /* Other file private variables. --------------------------------*/
-CRCB_t * pxCurrentCoRoutine = NULL;
-static UBaseType_t uxTopCoRoutineReadyPriority = 0;
-static TickType_t xCoRoutineTickCount = 0, xLastTickCount = 0, xPassedTicks = 0;
+    CRCB_t * pxCurrentCoRoutine = NULL;
+    static UBaseType_t uxTopCoRoutineReadyPriority = ( UBaseType_t ) 0U;
+    static TickType_t xCoRoutineTickCount = ( TickType_t ) 0U;
+    static TickType_t xLastTickCount = ( TickType_t ) 0U;
+    static TickType_t xPassedTicks = ( TickType_t ) 0U;
 
 /* The initial state of the co-routine when it is created. */
-#define corINITIAL_STATE    ( 0 )
+    #define corINITIAL_STATE    ( 0 )
 
 /*
  * Place the co-routine represented by pxCRCB into the appropriate ready queue
@@ -65,28 +67,28 @@ static TickType_t xCoRoutineTickCount = 0, xLastTickCount = 0, xPassedTicks = 0;
  * This macro accesses the co-routine ready lists and therefore must not be
  * used from within an ISR.
  */
-#define prvAddCoRoutineToReadyQueue( pxCRCB )                                                                       \
-    {                                                                                                                   \
-        if( pxCRCB->uxPriority > uxTopCoRoutineReadyPriority )                                                          \
-        {                                                                                                               \
-            uxTopCoRoutineReadyPriority = pxCRCB->uxPriority;                                                           \
-        }                                                                                                               \
-        vListInsertEnd( ( List_t * ) &( pxReadyCoRoutineLists[ pxCRCB->uxPriority ] ), &( pxCRCB->xGenericListItem ) ); \
-    }
+    #define prvAddCoRoutineToReadyQueue( pxCRCB )                                                                               \
+    do {                                                                                                                        \
+        if( ( pxCRCB )->uxPriority > uxTopCoRoutineReadyPriority )                                                              \
+        {                                                                                                                       \
+            uxTopCoRoutineReadyPriority = ( pxCRCB )->uxPriority;                                                               \
+        }                                                                                                                       \
+        vListInsertEnd( ( List_t * ) &( pxReadyCoRoutineLists[ ( pxCRCB )->uxPriority ] ), &( ( pxCRCB )->xGenericListItem ) ); \
+    } while( 0 )
 
 /*
  * Utility to ready all the lists used by the scheduler.  This is called
  * automatically upon the creation of the first co-routine.
  */
-static void prvInitialiseCoRoutineLists(void);
+    static void prvInitialiseCoRoutineLists( void );
 
 /*
  * Co-routines that are readied by an interrupt cannot be placed directly into
  * the ready lists (there is no mutual exclusion).  Instead they are placed in
  * in the pending ready list in order that they can later be moved to the ready
  * list by the co-routine scheduler.
  */
-static void prvCheckPendingReadyList(void);
+    static void prvCheckPendingReadyList( void );
 
 /*
  * Macro that looks at the list of co-routines that are currently delayed to
@@ -96,246 +98,308 @@ static void prvCheckPendingReadyList(void);
  * meaning once one co-routine has been found whose timer has not expired
  * we need not look any further down the list.
  */
-static void prvCheckDelayedList(void);
+    static void prvCheckDelayedList( void );
 
 /*-----------------------------------------------------------*/
 
-BaseType_t xCoRoutineCreate(crCOROUTINE_CODE pxCoRoutineCode,
-                            UBaseType_t uxPriority,
-                            UBaseType_t uxIndex)
-{
-    BaseType_t xReturn;
-    CRCB_t * pxCoRoutine;
-
-    /* Allocate the memory that will store the co-routine control block. */
-    pxCoRoutine = (CRCB_t *) SramMalloc(sizeof(CRCB_t));
-
-    if (pxCoRoutine) {
-        /* If pxCurrentCoRoutine is NULL then this is the first co-routine to
-        * be created and the co-routine data structures need initialising. */
-        if (pxCurrentCoRoutine == NULL) {
-            pxCurrentCoRoutine = pxCoRoutine;
-            prvInitialiseCoRoutineLists();
-        }
+    BaseType_t xCoRoutineCreate( crCOROUTINE_CODE pxCoRoutineCode,
+                                 UBaseType_t uxPriority,
+                                 UBaseType_t uxIndex )
+    {
+        BaseType_t xReturn;
+        CRCB_t * pxCoRoutine;
 
-        /* Check the priority is within limits. */
-        if (uxPriority >= configMAX_CO_ROUTINE_PRIORITIES) {
-            uxPriority = configMAX_CO_ROUTINE_PRIORITIES - 1;
-        }
+        traceENTER_xCoRoutineCreate( pxCoRoutineCode, uxPriority, uxIndex );
 
-        /* Fill out the co-routine control block from the function parameters. */
-        pxCoRoutine->uxState = corINITIAL_STATE;
-        pxCoRoutine->uxPriority = uxPriority;
-        pxCoRoutine->uxIndex = uxIndex;
-        pxCoRoutine->pxCoRoutineFunction = pxCoRoutineCode;
+        /* Allocate the memory that will store the co-routine control block. */
+        /* MISRA Ref 11.5.1 [Malloc memory assignment] */
+        /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-115 */
+        /* coverity[misra_c_2012_rule_11_5_violation] */
+        pxCoRoutine = ( CRCB_t * ) pvPortMalloc( sizeof( CRCB_t ) );
 
-        /* Initialise all the other co-routine control block parameters. */
-        vListInitialiseItem(&(pxCoRoutine->xGenericListItem));
-        vListInitialiseItem(&(pxCoRoutine->xEventListItem));
+        if( pxCoRoutine )
+        {
+            /* If pxCurrentCoRoutine is NULL then this is the first co-routine to
+            * be created and the co-routine data structures need initialising. */
+            if( pxCurrentCoRoutine == NULL )
+            {
+                pxCurrentCoRoutine = pxCoRoutine;
+                prvInitialiseCoRoutineLists();
+            }
 
-        /* Set the co-routine control block as a link back from the ListItem_t.
-         * This is so we can get back to the containing CRCB from a generic item
-         * in a list. */
-        listSET_LIST_ITEM_OWNER(&(pxCoRoutine->xGenericListItem), pxCoRoutine);
-        listSET_LIST_ITEM_OWNER(&(pxCoRoutine->xEventListItem), pxCoRoutine);
+            /* Check the priority is within limits. */
+            if( uxPriority >= configMAX_CO_ROUTINE_PRIORITIES )
+            {
+                uxPriority = configMAX_CO_ROUTINE_PRIORITIES - 1;
+            }
 
-        /* Event lists are always in priority order. */
-        listSET_LIST_ITEM_VALUE(&(pxCoRoutine->xEventListItem), ((TickType_t) configMAX_CO_ROUTINE_PRIORITIES - (TickType_t) uxPriority));
+            /* Fill out the co-routine control block from the function parameters. */
+            pxCoRoutine->uxState = corINITIAL_STATE;
+            pxCoRoutine->uxPriority = uxPriority;
+            pxCoRoutine->uxIndex = uxIndex;
+            pxCoRoutine->pxCoRoutineFunction = pxCoRoutineCode;
 
-        /* Now the co-routine has been initialised it can be added to the ready
-         * list at the correct priority. */
-        prvAddCoRoutineToReadyQueue(pxCoRoutine);
+            /* Initialise all the other co-routine control block parameters. */
+            vListInitialiseItem( &( pxCoRoutine->xGenericListItem ) );
+            vListInitialiseItem( &( pxCoRoutine->xEventListItem ) );
 
-        xReturn = pdPASS;
-    } else {
-        xReturn = errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY;
-    }
+            /* Set the co-routine control block as a link back from the ListItem_t.
+             * This is so we can get back to the containing CRCB from a generic item
+             * in a list. */
+            listSET_LIST_ITEM_OWNER( &( pxCoRoutine->xGenericListItem ), pxCoRoutine );
+            listSET_LIST_ITEM_OWNER( &( pxCoRoutine->xEventListItem ), pxCoRoutine );
 
-    return xReturn;
-}
-/*-----------------------------------------------------------*/
+            /* Event lists are always in priority order. */
+            listSET_LIST_ITEM_VALUE( &( pxCoRoutine->xEventListItem ), ( ( TickType_t ) configMAX_CO_ROUTINE_PRIORITIES - ( TickType_t ) uxPriority ) );
 
-void vCoRoutineAddToDelayedList(TickType_t xTicksToDelay,
-                                List_t * pxEventList)
-{
-    TickType_t xTimeToWake;
-
-    /* Calculate the time to wake - this may overflow but this is
-     * not a problem. */
-    xTimeToWake = xCoRoutineTickCount + xTicksToDelay;
-
-    /* We must remove ourselves from the ready list before adding
-     * ourselves to the blocked list as the same list item is used for
-     * both lists. */
-    (void) uxListRemove((ListItem_t *) & (pxCurrentCoRoutine->xGenericListItem));
-
-    /* The list item will be inserted in wake time order. */
-    listSET_LIST_ITEM_VALUE(&(pxCurrentCoRoutine->xGenericListItem), xTimeToWake);
-
-    if (xTimeToWake < xCoRoutineTickCount) {
-        /* Wake time has overflowed.  Place this item in the
-         * overflow list. */
-        vListInsert((List_t *) pxOverflowDelayedCoRoutineList, (ListItem_t *) & (pxCurrentCoRoutine->xGenericListItem));
-    } else {
-        /* The wake time has not overflowed, so we can use the
-         * current block list. */
-        vListInsert((List_t *) pxDelayedCoRoutineList, (ListItem_t *) & (pxCurrentCoRoutine->xGenericListItem));
-    }
+            /* Now the co-routine has been initialised it can be added to the ready
+             * list at the correct priority. */
+            prvAddCoRoutineToReadyQueue( pxCoRoutine );
+
+            xReturn = pdPASS;
+        }
+        else
+        {
+            xReturn = errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY;
+        }
 
-    if (pxEventList) {
-        /* Also add the co-routine to an event list.  If this is done then the
-         * function must be called with interrupts disabled. */
-        vListInsert(pxEventList, &(pxCurrentCoRoutine->xEventListItem));
+        traceRETURN_xCoRoutineCreate( xReturn );
+
+        return xReturn;
     }
-}
 /*-----------------------------------------------------------*/
 
-static void prvCheckPendingReadyList(void)
-{
-    /* Are there any co-routines waiting to get moved to the ready list?  These
-     * are co-routines that have been readied by an ISR.  The ISR cannot access
-     * the ready lists itself. */
-    while (listLIST_IS_EMPTY(&xPendingReadyCoRoutineList) == pdFALSE) {
-        CRCB_t * pxUnblockedCRCB;
+    void vCoRoutineAddToDelayedList( TickType_t xTicksToDelay,
+                                     List_t * pxEventList )
+    {
+        TickType_t xTimeToWake;
+
+        traceENTER_vCoRoutineAddToDelayedList( xTicksToDelay, pxEventList );
+
+        /* Calculate the time to wake - this may overflow but this is
+         * not a problem. */
+        xTimeToWake = xCoRoutineTickCount + xTicksToDelay;
 
-        /* The pending ready list can be accessed by an ISR. */
-        portDISABLE_INTERRUPTS();
+        /* We must remove ourselves from the ready list before adding
+         * ourselves to the blocked list as the same list item is used for
+         * both lists. */
+        ( void ) uxListRemove( ( ListItem_t * ) &( pxCurrentCoRoutine->xGenericListItem ) );
+
+        /* The list item will be inserted in wake time order. */
+        listSET_LIST_ITEM_VALUE( &( pxCurrentCoRoutine->xGenericListItem ), xTimeToWake );
+
+        if( xTimeToWake < xCoRoutineTickCount )
+        {
+            /* Wake time has overflowed.  Place this item in the
+             * overflow list. */
+            vListInsert( ( List_t * ) pxOverflowDelayedCoRoutineList, ( ListItem_t * ) &( pxCurrentCoRoutine->xGenericListItem ) );
+        }
+        else
+        {
+            /* The wake time has not overflowed, so we can use the
+             * current block list. */
+            vListInsert( ( List_t * ) pxDelayedCoRoutineList, ( ListItem_t * ) &( pxCurrentCoRoutine->xGenericListItem ) );
+        }
+
+        if( pxEventList )
         {
-            pxUnblockedCRCB = (CRCB_t *) listGET_OWNER_OF_HEAD_ENTRY((&xPendingReadyCoRoutineList));
-            (void) uxListRemove(&(pxUnblockedCRCB->xEventListItem));
+            /* Also add the co-routine to an event list.  If this is done then the
+             * function must be called with interrupts disabled. */
+            vListInsert( pxEventList, &( pxCurrentCoRoutine->xEventListItem ) );
         }
-        portENABLE_INTERRUPTS();
 
-        (void) uxListRemove(&(pxUnblockedCRCB->xGenericListItem));
-        prvAddCoRoutineToReadyQueue(pxUnblockedCRCB);
+        traceRETURN_vCoRoutineAddToDelayedList();
     }
-}
 /*-----------------------------------------------------------*/
 
-static void prvCheckDelayedList(void)
-{
-    CRCB_t * pxCRCB;
+    static void prvCheckPendingReadyList( void )
+    {
+        /* Are there any co-routines waiting to get moved to the ready list?  These
+         * are co-routines that have been readied by an ISR.  The ISR cannot access
+         * the ready lists itself. */
+        while( listLIST_IS_EMPTY( &xPendingReadyCoRoutineList ) == pdFALSE )
+        {
+            CRCB_t * pxUnblockedCRCB;
 
-    xPassedTicks = xTaskGetTickCount() - xLastTickCount;
+            /* The pending ready list can be accessed by an ISR. */
+            portDISABLE_INTERRUPTS();
+            {
+                pxUnblockedCRCB = ( CRCB_t * ) listGET_OWNER_OF_HEAD_ENTRY( ( &xPendingReadyCoRoutineList ) );
+                ( void ) uxListRemove( &( pxUnblockedCRCB->xEventListItem ) );
+            }
+            portENABLE_INTERRUPTS();
 
-    while (xPassedTicks) {
-        xCoRoutineTickCount++;
-        xPassedTicks--;
+            ( void ) uxListRemove( &( pxUnblockedCRCB->xGenericListItem ) );
+            prvAddCoRoutineToReadyQueue( pxUnblockedCRCB );
+        }
+    }
+/*-----------------------------------------------------------*/
 
-        /* If the tick count has overflowed we need to swap the ready lists. */
-        if (xCoRoutineTickCount == 0) {
-            List_t * pxTemp;
+    static void prvCheckDelayedList( void )
+    {
+        CRCB_t * pxCRCB;
 
-            /* Tick count has overflowed so we need to swap the delay lists.  If there are
-             * any items in pxDelayedCoRoutineList here then there is an error! */
-            pxTemp = pxDelayedCoRoutineList;
-            pxDelayedCoRoutineList = pxOverflowDelayedCoRoutineList;
-            pxOverflowDelayedCoRoutineList = pxTemp;
-        }
+        xPassedTicks = xTaskGetTickCount() - xLastTickCount;
+
+        while( xPassedTicks )
+        {
+            xCoRoutineTickCount++;
+            xPassedTicks--;
 
-        /* See if this tick has made a timeout expire. */
-        while (listLIST_IS_EMPTY(pxDelayedCoRoutineList) == pdFALSE) {
-            pxCRCB = (CRCB_t *) listGET_OWNER_OF_HEAD_ENTRY(pxDelayedCoRoutineList);
+            /* If the tick count has overflowed we need to swap the ready lists. */
+            if( xCoRoutineTickCount == 0 )
+            {
+                List_t * pxTemp;
 
-            if (xCoRoutineTickCount < listGET_LIST_ITEM_VALUE(&(pxCRCB->xGenericListItem))) {
-                /* Timeout not yet expired. */
-                break;
+                /* Tick count has overflowed so we need to swap the delay lists.  If there are
+                 * any items in pxDelayedCoRoutineList here then there is an error! */
+                pxTemp = pxDelayedCoRoutineList;
+                pxDelayedCoRoutineList = pxOverflowDelayedCoRoutineList;
+                pxOverflowDelayedCoRoutineList = pxTemp;
             }
 
-            portDISABLE_INTERRUPTS();
+            /* See if this tick has made a timeout expire. */
+            while( listLIST_IS_EMPTY( pxDelayedCoRoutineList ) == pdFALSE )
             {
-                /* The event could have occurred just before this critical
-                 *  section.  If this is the case then the generic list item will
-                 *  have been moved to the pending ready list and the following
-                 *  line is still valid.  Also the pvContainer parameter will have
-                 *  been set to NULL so the following lines are also valid. */
-                (void) uxListRemove(&(pxCRCB->xGenericListItem));
-
-                /* Is the co-routine waiting on an event also? */
-                if (pxCRCB->xEventListItem.pxContainer) {
-                    (void) uxListRemove(&(pxCRCB->xEventListItem));
+                pxCRCB = ( CRCB_t * ) listGET_OWNER_OF_HEAD_ENTRY( pxDelayedCoRoutineList );
+
+                if( xCoRoutineTickCount < listGET_LIST_ITEM_VALUE( &( pxCRCB->xGenericListItem ) ) )
+                {
+                    /* Timeout not yet expired. */
+                    break;
                 }
-            }
-            portENABLE_INTERRUPTS();
 
-            prvAddCoRoutineToReadyQueue(pxCRCB);
+                portDISABLE_INTERRUPTS();
+                {
+                    /* The event could have occurred just before this critical
+                     *  section.  If this is the case then the generic list item will
+                     *  have been moved to the pending ready list and the following
+                     *  line is still valid.  Also the pvContainer parameter will have
+                     *  been set to NULL so the following lines are also valid. */
+                    ( void ) uxListRemove( &( pxCRCB->xGenericListItem ) );
+
+                    /* Is the co-routine waiting on an event also? */
+                    if( pxCRCB->xEventListItem.pxContainer )
+                    {
+                        ( void ) uxListRemove( &( pxCRCB->xEventListItem ) );
+                    }
+                }
+                portENABLE_INTERRUPTS();
+
+                prvAddCoRoutineToReadyQueue( pxCRCB );
+            }
         }
-    }
 
-    xLastTickCount = xCoRoutineTickCount;
-}
+        xLastTickCount = xCoRoutineTickCount;
+    }
 /*-----------------------------------------------------------*/
 
-void vCoRoutineSchedule(void)
-{
-    /* Only run a co-routine after prvInitialiseCoRoutineLists() has been
-     * called.  prvInitialiseCoRoutineLists() is called automatically when a
-     * co-routine is created. */
-    if (pxDelayedCoRoutineList != NULL) {
-        /* See if any co-routines readied by events need moving to the ready lists. */
-        prvCheckPendingReadyList();
-
-        /* See if any delayed co-routines have timed out. */
-        prvCheckDelayedList();
-
-        /* Find the highest priority queue that contains ready co-routines. */
-        while (listLIST_IS_EMPTY(&(pxReadyCoRoutineLists[ uxTopCoRoutineReadyPriority ]))) {
-            if (uxTopCoRoutineReadyPriority == 0) {
-                /* No more co-routines to check. */
-                return;
+    void vCoRoutineSchedule( void )
+    {
+        traceENTER_vCoRoutineSchedule();
+
+        /* Only run a co-routine after prvInitialiseCoRoutineLists() has been
+         * called.  prvInitialiseCoRoutineLists() is called automatically when a
+         * co-routine is created. */
+        if( pxDelayedCoRoutineList != NULL )
+        {
+            /* See if any co-routines readied by events need moving to the ready lists. */
+            prvCheckPendingReadyList();
+
+            /* See if any delayed co-routines have timed out. */
+            prvCheckDelayedList();
+
+            /* Find the highest priority queue that contains ready co-routines. */
+            while( listLIST_IS_EMPTY( &( pxReadyCoRoutineLists[ uxTopCoRoutineReadyPriority ] ) ) )
+            {
+                if( uxTopCoRoutineReadyPriority == 0 )
+                {
+                    /* No more co-routines to check. */
+                    return;
+                }
+
+                --uxTopCoRoutineReadyPriority;
             }
 
-            --uxTopCoRoutineReadyPriority;
-        }
+            /* listGET_OWNER_OF_NEXT_ENTRY walks through the list, so the co-routines
+             * of the same priority get an equal share of the processor time. */
+            listGET_OWNER_OF_NEXT_ENTRY( pxCurrentCoRoutine, &( pxReadyCoRoutineLists[ uxTopCoRoutineReadyPriority ] ) );
 
-        /* listGET_OWNER_OF_NEXT_ENTRY walks through the list, so the co-routines
-         * of the same priority get an equal share of the processor time. */
-        listGET_OWNER_OF_NEXT_ENTRY(pxCurrentCoRoutine, &(pxReadyCoRoutineLists[ uxTopCoRoutineReadyPriority ]));
+            /* Call the co-routine. */
+            ( pxCurrentCoRoutine->pxCoRoutineFunction )( pxCurrentCoRoutine, pxCurrentCoRoutine->uxIndex );
+        }
 
-        /* Call the co-routine. */
-        (pxCurrentCoRoutine->pxCoRoutineFunction)(pxCurrentCoRoutine, pxCurrentCoRoutine->uxIndex);
+        traceRETURN_vCoRoutineSchedule();
     }
-}
 /*-----------------------------------------------------------*/
 
-static void prvInitialiseCoRoutineLists(void)
-{
-    UBaseType_t uxPriority;
+    static void prvInitialiseCoRoutineLists( void )
+    {
+        UBaseType_t uxPriority;
 
-    for (uxPriority = 0; uxPriority < configMAX_CO_ROUTINE_PRIORITIES; uxPriority++) {
-        vListInitialise((List_t *) & (pxReadyCoRoutineLists[ uxPriority ]));
-    }
+        for( uxPriority = 0; uxPriority < configMAX_CO_ROUTINE_PRIORITIES; uxPriority++ )
+        {
+            vListInitialise( ( List_t * ) &( pxReadyCoRoutineLists[ uxPriority ] ) );
+        }
 
-    vListInitialise((List_t *) &xDelayedCoRoutineList1);
-    vListInitialise((List_t *) &xDelayedCoRoutineList2);
-    vListInitialise((List_t *) &xPendingReadyCoRoutineList);
+        vListInitialise( ( List_t * ) &xDelayedCoRoutineList1 );
+        vListInitialise( ( List_t * ) &xDelayedCoRoutineList2 );
+        vListInitialise( ( List_t * ) &xPendingReadyCoRoutineList );
 
-    /* Start with pxDelayedCoRoutineList using list1 and the
-     * pxOverflowDelayedCoRoutineList using list2. */
-    pxDelayedCoRoutineList = &xDelayedCoRoutineList1;
-    pxOverflowDelayedCoRoutineList = &xDelayedCoRoutineList2;
-}
+        /* Start with pxDelayedCoRoutineList using list1 and the
+         * pxOverflowDelayedCoRoutineList using list2. */
+        pxDelayedCoRoutineList = &xDelayedCoRoutineList1;
+        pxOverflowDelayedCoRoutineList = &xDelayedCoRoutineList2;
+    }
 /*-----------------------------------------------------------*/
 
-BaseType_t xCoRoutineRemoveFromEventList(const List_t * pxEventList)
-{
-    CRCB_t * pxUnblockedCRCB;
-    BaseType_t xReturn;
-
-    /* This function is called from within an interrupt.  It can only access
-     * event lists and the pending ready list.  This function assumes that a
-     * check has already been made to ensure pxEventList is not empty. */
-    pxUnblockedCRCB = (CRCB_t *) listGET_OWNER_OF_HEAD_ENTRY(pxEventList);
-    (void) uxListRemove(&(pxUnblockedCRCB->xEventListItem));
-    vListInsertEnd((List_t *) & (xPendingReadyCoRoutineList), &(pxUnblockedCRCB->xEventListItem));
-
-    if (pxUnblockedCRCB->uxPriority >= pxCurrentCoRoutine->uxPriority) {
-        xReturn = pdTRUE;
-    } else {
-        xReturn = pdFALSE;
+    BaseType_t xCoRoutineRemoveFromEventList( const List_t * pxEventList )
+    {
+        CRCB_t * pxUnblockedCRCB;
+        BaseType_t xReturn;
+
+        traceENTER_xCoRoutineRemoveFromEventList( pxEventList );
+
+        /* This function is called from within an interrupt.  It can only access
+         * event lists and the pending ready list.  This function assumes that a
+         * check has already been made to ensure pxEventList is not empty. */
+        pxUnblockedCRCB = ( CRCB_t * ) listGET_OWNER_OF_HEAD_ENTRY( pxEventList );
+        ( void ) uxListRemove( &( pxUnblockedCRCB->xEventListItem ) );
+        vListInsertEnd( ( List_t * ) &( xPendingReadyCoRoutineList ), &( pxUnblockedCRCB->xEventListItem ) );
+
+        if( pxUnblockedCRCB->uxPriority >= pxCurrentCoRoutine->uxPriority )
+        {
+            xReturn = pdTRUE;
+        }
+        else
+        {
+            xReturn = pdFALSE;
+        }
+
+        traceRETURN_xCoRoutineRemoveFromEventList( xReturn );
+
+        return xReturn;
     }
+/*-----------------------------------------------------------*/
 
-    return xReturn;
-}
+/*
+ * Reset state in this file. This state is normally initialized at start up.
+ * This function must be called by the application before restarting the
+ * scheduler.
+ */
+    void vCoRoutineResetState( void )
+    {
+        /* Lists for ready and blocked co-routines. */
+        pxDelayedCoRoutineList = NULL;
+        pxOverflowDelayedCoRoutineList = NULL;
+
+        /* Other file private variables. */
+        pxCurrentCoRoutine = NULL;
+        uxTopCoRoutineReadyPriority = ( UBaseType_t ) 0U;
+        xCoRoutineTickCount = ( TickType_t ) 0U;
+        xLastTickCount = ( TickType_t ) 0U;
+        xPassedTicks = ( TickType_t ) 0U;
+    }
+/*-----------------------------------------------------------*/
 
 #endif /* configUSE_CO_ROUTINES == 0 */

### external/FreeRTOS/Source/event_groups.c
@@ -1,6 +1,6 @@
 /*
- * FreeRTOS Kernel V10.4.6
- * Copyright (C) 2021 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ * FreeRTOS Kernel V11.3.0
+ * Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -30,7 +30,7 @@
 #include <stdlib.h>
 
 /* Defining MPU_WRAPPERS_INCLUDED_FROM_API_FILE prevents task.h from redefining
- * all the API functions to use the MPU wrappers.  That should only be done when
+ * all the API functions to use the MPU wrappers. That should only be done when
  * task.h is included from an application file. */
 #define MPU_WRAPPERS_INCLUDED_FROM_API_FILE
 
@@ -40,39 +40,30 @@
 #include "timers.h"
 #include "event_groups.h"
 
-/* Lint e961, e750 and e9021 are suppressed as a MISRA exception justified
- * because the MPU ports require MPU_WRAPPERS_INCLUDED_FROM_API_FILE to be defined
+/* The MPU ports require MPU_WRAPPERS_INCLUDED_FROM_API_FILE to be defined
  * for the header files above, but not in this file, in order to generate the
  * correct privileged Vs unprivileged linkage and placement. */
-#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE /*lint !e961 !e750 !e9021 See comment above. */
-
-/* The following bit fields convey control information in a task's event list
- * item value.  It is important they don't clash with the
- * taskEVENT_LIST_ITEM_VALUE_IN_USE definition. */
-#if configUSE_16_BIT_TICKS == 1
-#define eventCLEAR_EVENTS_ON_EXIT_BIT    0x0100U
-#define eventUNBLOCKED_DUE_TO_BIT_SET    0x0200U
-#define eventWAIT_FOR_ALL_BITS           0x0400U
-#define eventEVENT_BITS_CONTROL_BYTES    0xff00U
-#else
-#define eventCLEAR_EVENTS_ON_EXIT_BIT    0x01000000UL
-#define eventUNBLOCKED_DUE_TO_BIT_SET    0x02000000UL
-#define eventWAIT_FOR_ALL_BITS           0x04000000UL
-#define eventEVENT_BITS_CONTROL_BYTES    0xff000000UL
-#endif
-
-typedef struct EventGroupDef_t {
-    EventBits_t uxEventBits;
-    List_t xTasksWaitingForBits; /*< List of tasks waiting for a bit to be set. */
-
-#if ( configUSE_TRACE_FACILITY == 1 )
-    UBaseType_t uxEventGroupNumber;
-#endif
-
-#if ( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
-    uint8_t ucStaticallyAllocated; /*< Set to pdTRUE if the event group is statically allocated to ensure no attempt is made to free the memory. */
-#endif
-} EventGroup_t;
+#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE
+
+/* This entire source file will be skipped if the application is not configured
+ * to include event groups functionality. This #if is closed at the very bottom
+ * of this file. If you want to include event groups then ensure
+ * configUSE_EVENT_GROUPS is set to 1 in FreeRTOSConfig.h. */
+#if ( configUSE_EVENT_GROUPS == 1 )
+
+    typedef struct EventGroupDef_t
+    {
+        EventBits_t uxEventBits;
+        List_t xTasksWaitingForBits; /**< List of tasks waiting for a bit to be set. */
+
+        #if ( configUSE_TRACE_FACILITY == 1 )
+            UBaseType_t uxEventGroupNumber;
+        #endif
+
+        #if ( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
+            uint8_t ucStaticallyAllocated; /**< Set to pdTRUE if the event group is statically allocated to ensure no attempt is made to free the memory. */
+        #endif
+    } EventGroup_t;
 
 /*-----------------------------------------------------------*/
 
@@ -81,618 +72,816 @@ typedef struct EventGroupDef_t {
  * The wait condition is defined by xWaitForAllBits.  If xWaitForAllBits is
  * pdTRUE then the wait condition is met if all the bits set in uxBitsToWaitFor
  * are also set in uxCurrentEventBits.  If xWaitForAllBits is pdFALSE then the
- * wait condition is met if any of the bits set in uxBitsToWait for are also set
+ * wait condition is met if any of the bits set in uxBitsToWaitFor are also set
  * in uxCurrentEventBits.
  */
-static BaseType_t prvTestWaitCondition(const EventBits_t uxCurrentEventBits,
-                                       const EventBits_t uxBitsToWaitFor,
-                                       const BaseType_t xWaitForAllBits) PRIVILEGED_FUNCTION;
+    static BaseType_t prvTestWaitCondition( const EventBits_t uxCurrentEventBits,
+                                            const EventBits_t uxBitsToWaitFor,
+                                            const BaseType_t xWaitForAllBits ) PRIVILEGED_FUNCTION;
 
 /*-----------------------------------------------------------*/
 
-#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
+    #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
 
-EventGroupHandle_t xEventGroupCreateStatic(StaticEventGroup_t * pxEventGroupBuffer)
-{
-    EventGroup_t * pxEventBits;
+        EventGroupHandle_t xEventGroupCreateStatic( StaticEventGroup_t * pxEventGroupBuffer )
+        {
+            EventGroup_t * pxEventBits;
 
-    /* A StaticEventGroup_t object must be provided. */
-    configASSERT(pxEventGroupBuffer);
+            traceENTER_xEventGroupCreateStatic( pxEventGroupBuffer );
 
-#if ( configASSERT_DEFINED == 1 )
-    {
-        /* Sanity check that the size of the structure used to declare a
-         * variable of type StaticEventGroup_t equals the size of the real
-         * event group structure. */
-        volatile size_t xSize = sizeof(StaticEventGroup_t);
-        configASSERT(xSize == sizeof(EventGroup_t));
-    } /*lint !e529 xSize is referenced if configASSERT() is defined. */
-#endif /* configASSERT_DEFINED */
-
-    /* The user has provided a statically allocated event group - use it. */
-    pxEventBits = (EventGroup_t *) pxEventGroupBuffer;   /*lint !e740 !e9087 EventGroup_t and StaticEventGroup_t are deliberately aliased for data hiding purposes and guaranteed to have the same size and alignment requirement - checked by configASSERT(). */
-
-    if (pxEventBits != NULL) {
-        pxEventBits->uxEventBits = 0;
-        vListInitialise(&(pxEventBits->xTasksWaitingForBits));
-
-#if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
-        {
-            /* Both static and dynamic allocation can be used, so note that
-             * this event group was created statically in case the event group
-             * is later deleted. */
-            pxEventBits->ucStaticallyAllocated = pdTRUE;
-        }
-#endif /* configSUPPORT_DYNAMIC_ALLOCATION */
-
-        traceEVENT_GROUP_CREATE(pxEventBits);
-    } else {
-        /* xEventGroupCreateStatic should only ever be called with
-         * pxEventGroupBuffer pointing to a pre-allocated (compile time
-         * allocated) StaticEventGroup_t variable. */
-        traceEVENT_GROUP_CREATE_FAILED();
-    }
+            /* A StaticEventGroup_t object must be provided. */
+            configASSERT( pxEventGroupBuffer );
 
-    return pxEventBits;
-}
+            #if ( configASSERT_DEFINED == 1 )
+            {
+                /* Sanity check that the size of the structure used to declare a
+                 * variable of type StaticEventGroup_t equals the size of the real
+                 * event group structure. */
+                volatile size_t xSize = sizeof( StaticEventGroup_t );
+                configASSERT( xSize == sizeof( EventGroup_t ) );
+            }
+            #endif /* configASSERT_DEFINED */
 
-#endif /* configSUPPORT_STATIC_ALLOCATION */
+            /* The user has provided a statically allocated event group - use it. */
+            /* MISRA Ref 11.3.1 [Misaligned access] */
+            /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-113 */
+            /* coverity[misra_c_2012_rule_11_3_violation] */
+            pxEventBits = ( EventGroup_t * ) pxEventGroupBuffer;
+
+            if( pxEventBits != NULL )
+            {
+                pxEventBits->uxEventBits = 0;
+                vListInitialise( &( pxEventBits->xTasksWaitingForBits ) );
+
+                #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
+                {
+                    /* Both static and dynamic allocation can be used, so note that
+                     * this event group was created statically in case the event group
+                     * is later deleted. */
+                    pxEventBits->ucStaticallyAllocated = pdTRUE;
+                }
+                #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
+
+                traceEVENT_GROUP_CREATE( pxEventBits );
+            }
+            else
+            {
+                /* xEventGroupCreateStatic should only ever be called with
+                 * pxEventGroupBuffer pointing to a pre-allocated (compile time
+                 * allocated) StaticEventGroup_t variable. */
+                traceEVENT_GROUP_CREATE_FAILED();
+            }
+
+            traceRETURN_xEventGroupCreateStatic( pxEventBits );
+
+            return pxEventBits;
+        }
+
+    #endif /* configSUPPORT_STATIC_ALLOCATION */
 /*-----------------------------------------------------------*/
 
-#if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
-
-EventGroupHandle_t xEventGroupCreate(void)
-{
-    EventGroup_t * pxEventBits;
-
-    /* Allocate the event group.  Justification for MISRA deviation as
-     * follows:  SramMalloc() always ensures returned memory blocks are
-     * aligned per the requirements of the MCU stack.  In this case
-     * SramMalloc() must return a pointer that is guaranteed to meet the
-     * alignment requirements of the EventGroup_t structure - which (if you
-     * follow it through) is the alignment requirements of the TickType_t type
-     * (EventBits_t being of TickType_t itself).  Therefore, whenever the
-     * stack alignment requirements are greater than or equal to the
-     * TickType_t alignment requirements the cast is safe.  In other cases,
-     * where the natural word size of the architecture is less than
-     * sizeof( TickType_t ), the TickType_t variables will be accessed in two
-     * or more reads operations, and the alignment requirements is only that
-     * of each individual read. */
-    pxEventBits = (EventGroup_t *) SramMalloc(sizeof(EventGroup_t));       /*lint !e9087 !e9079 see comment above. */
-
-    if (pxEventBits != NULL) {
-        pxEventBits->uxEventBits = 0;
-        vListInitialise(&(pxEventBits->xTasksWaitingForBits));
-
-#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
+    #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
+
+        EventGroupHandle_t xEventGroupCreate( void )
         {
-            /* Both static and dynamic allocation can be used, so note this
-             * event group was allocated statically in case the event group is
-             * later deleted. */
-            pxEventBits->ucStaticallyAllocated = pdFALSE;
-        }
-#endif /* configSUPPORT_STATIC_ALLOCATION */
+            EventGroup_t * pxEventBits;
 
-        traceEVENT_GROUP_CREATE(pxEventBits);
-    } else {
-        traceEVENT_GROUP_CREATE_FAILED(); /*lint !e9063 Else branch only exists to allow tracing and does not generate code if trace macros are not defined. */
-    }
+            traceENTER_xEventGroupCreate();
+
+            /* MISRA Ref 11.5.1 [Malloc memory assignment] */
+            /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-115 */
+            /* coverity[misra_c_2012_rule_11_5_violation] */
+            pxEventBits = ( EventGroup_t * ) pvPortMalloc( sizeof( EventGroup_t ) );
+
+            if( pxEventBits != NULL )
+            {
+                pxEventBits->uxEventBits = 0;
+                vListInitialise( &( pxEventBits->xTasksWaitingForBits ) );
+
+                #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
+                {
+                    /* Both static and dynamic allocation can be used, so note this
+                     * event group was allocated statically in case the event group is
+                     * later deleted. */
+                    pxEventBits->ucStaticallyAllocated = pdFALSE;
+                }
+                #endif /* configSUPPORT_STATIC_ALLOCATION */
+
+                traceEVENT_GROUP_CREATE( pxEventBits );
+            }
+            else
+            {
+                traceEVENT_GROUP_CREATE_FAILED();
+            }
+
+            traceRETURN_xEventGroupCreate( pxEventBits );
 
-    return pxEventBits;
-}
+            return pxEventBits;
+        }
 
-#endif /* configSUPPORT_DYNAMIC_ALLOCATION */
+    #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
 /*-----------------------------------------------------------*/
 
-EventBits_t xEventGroupSync(EventGroupHandle_t xEventGroup,
-                            const EventBits_t uxBitsToSet,
-                            const EventBits_t uxBitsToWaitFor,
-                            TickType_t xTicksToWait)
-{
-    EventBits_t uxOriginalBitValue, uxReturn;
-    EventGroup_t * pxEventBits = xEventGroup;
-    BaseType_t xAlreadyYielded;
-    BaseType_t xTimeoutOccurred = pdFALSE;
-
-    configASSERT((uxBitsToWaitFor & eventEVENT_BITS_CONTROL_BYTES) == 0);
-    configASSERT(uxBitsToWaitFor != 0);
-#if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
+    EventBits_t xEventGroupSync( EventGroupHandle_t xEventGroup,
+                                 const EventBits_t uxBitsToSet,
+                                 const EventBits_t uxBitsToWaitFor,
+                                 TickType_t xTicksToWait )
     {
-        configASSERT(!((xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED) && (xTicksToWait != 0)));
-    }
-#endif
+        EventBits_t uxOriginalBitValue, uxReturn;
+        EventGroup_t * pxEventBits = xEventGroup;
+        BaseType_t xAlreadyYielded;
+        BaseType_t xTimeoutOccurred = pdFALSE;
 
-    vTaskSuspendAll();
-    {
-        uxOriginalBitValue = pxEventBits->uxEventBits;
+        traceENTER_xEventGroupSync( xEventGroup, uxBitsToSet, uxBitsToWaitFor, xTicksToWait );
 
-        (void) xEventGroupSetBits(xEventGroup, uxBitsToSet);
+        configASSERT( ( uxBitsToWaitFor & eventEVENT_BITS_CONTROL_BYTES ) == 0 );
+        configASSERT( uxBitsToWaitFor != 0 );
+        #if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
+        {
+            configASSERT( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) );
+        }
+        #endif
 
-        if (((uxOriginalBitValue | uxBitsToSet) & uxBitsToWaitFor) == uxBitsToWaitFor) {
-            /* All the rendezvous bits are now set - no need to block. */
-            uxReturn = (uxOriginalBitValue | uxBitsToSet);
+        vTaskSuspendAll();
+        {
+            uxOriginalBitValue = pxEventBits->uxEventBits;
 
-            /* Rendezvous always clear the bits.  They will have been cleared
-             * already unless this is the only task in the rendezvous. */
-            pxEventBits->uxEventBits &= ~uxBitsToWaitFor;
+            ( void ) xEventGroupSetBits( xEventGroup, uxBitsToSet );
 
-            xTicksToWait = 0;
-        } else {
-            if (xTicksToWait != (TickType_t) 0) {
-                traceEVENT_GROUP_SYNC_BLOCK(xEventGroup, uxBitsToSet, uxBitsToWaitFor);
+            if( ( ( uxOriginalBitValue | uxBitsToSet ) & uxBitsToWaitFor ) == uxBitsToWaitFor )
+            {
+                /* All the rendezvous bits are now set - no need to block. */
+                uxReturn = ( uxOriginalBitValue | uxBitsToSet );
 
-                /* Store the bits that the calling task is waiting for in the
-                 * task's event list item so the kernel knows when a match is
-                 * found.  Then enter the blocked state. */
-                vTaskPlaceOnUnorderedEventList(&(pxEventBits->xTasksWaitingForBits), (uxBitsToWaitFor | eventCLEAR_EVENTS_ON_EXIT_BIT | eventWAIT_FOR_ALL_BITS), xTicksToWait);
+                /* Rendezvous always clear the bits.  They will have been cleared
+                 * already unless this is the only task in the rendezvous. */
+                pxEventBits->uxEventBits &= ~uxBitsToWaitFor;
 
-                /* This assignment is obsolete as uxReturn will get set after
-                 * the task unblocks, but some compilers mistakenly generate a
-                 * warning about uxReturn being returned without being set if the
-                 * assignment is omitted. */
-                uxReturn = 0;
-            } else {
-                /* The rendezvous bits were not set, but no block time was
-                 * specified - just return the current event bit value. */
-                uxReturn = pxEventBits->uxEventBits;
-                xTimeoutOccurred = pdTRUE;
+                xTicksToWait = 0;
+            }
+            else
+            {
+                if( xTicksToWait != ( TickType_t ) 0 )
+                {
+                    traceEVENT_GROUP_SYNC_BLOCK( xEventGroup, uxBitsToSet, uxBitsToWaitFor );
+
+                    /* Store the bits that the calling task is waiting for in the
+                     * task's event list item so the kernel knows when a match is
+                     * found.  Then enter the blocked state. */
+                    vTaskPlaceOnUnorderedEventList( &( pxEventBits->xTasksWaitingForBits ), ( uxBitsToWaitFor | eventCLEAR_EVENTS_ON_EXIT_BIT | eventWAIT_FOR_ALL_BITS ), xTicksToWait );
+
+                    /* This assignment is obsolete as uxReturn will get set after
+                     * the task unblocks, but some compilers mistakenly generate a
+                     * warning about uxReturn being returned without being set if the
+                     * assignment is omitted. */
+                    uxReturn = 0;
+                }
+                else
+                {
+                    /* The rendezvous bits were not set, but no block time was
+                     * specified - just return the current event bit value. */
+                    uxReturn = pxEventBits->uxEventBits;
+                    xTimeoutOccurred = pdTRUE;
+                }
             }
         }
-    }
-    xAlreadyYielded = xTaskResumeAll();
+        xAlreadyYielded = xTaskResumeAll();
 
-    if (xTicksToWait != (TickType_t) 0) {
-        if (xAlreadyYielded == pdFALSE) {
-            portYIELD_WITHIN_API();
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
+        if( xTicksToWait != ( TickType_t ) 0 )
+        {
+            if( xAlreadyYielded == pdFALSE )
+            {
+                taskYIELD_WITHIN_API();
+            }
+            else
+            {
+                mtCOVERAGE_TEST_MARKER();
+            }
 
-        /* The task blocked to wait for its required bits to be set - at this
-         * point either the required bits were set or the block time expired.  If
-         * the required bits were set they will have been stored in the task's
-         * event list item, and they should now be retrieved then cleared. */
-        uxReturn = uxTaskResetEventItemValue();
+            /* The task blocked to wait for its required bits to be set - at this
+             * point either the required bits were set or the block time expired.  If
+             * the required bits were set they will have been stored in the task's
+             * event list item, and they should now be retrieved then cleared. */
+            uxReturn = uxTaskResetEventItemValue();
 
-        if ((uxReturn & eventUNBLOCKED_DUE_TO_BIT_SET) == (EventBits_t) 0) {
-            /* The task timed out, just return the current event bit value. */
-            taskENTER_CRITICAL();
+            if( ( uxReturn & eventUNBLOCKED_DUE_TO_BIT_SET ) == ( EventBits_t ) 0 )
             {
-                uxReturn = pxEventBits->uxEventBits;
-
-                /* Although the task got here because it timed out before the
-                 * bits it was waiting for were set, it is possible that since it
-                 * unblocked another task has set the bits.  If this is the case
-                 * then it needs to clear the bits before exiting. */
-                if ((uxReturn & uxBitsToWaitFor) == uxBitsToWaitFor) {
-                    pxEventBits->uxEventBits &= ~uxBitsToWaitFor;
-                } else {
-                    mtCOVERAGE_TEST_MARKER();
+                /* The task timed out, just return the current event bit value. */
+                taskENTER_CRITICAL();
+                {
+                    uxReturn = pxEventBits->uxEventBits;
+
+                    /* Although the task got here because it timed out before the
+                     * bits it was waiting for were set, it is possible that since it
+                     * unblocked another task has set the bits.  If this is the case
+                     * then it needs to clear the bits before exiting. */
+                    if( ( uxReturn & uxBitsToWaitFor ) == uxBitsToWaitFor )
+                    {
+                        pxEventBits->uxEventBits &= ~uxBitsToWaitFor;
+                    }
+                    else
+                    {
+                        mtCOVERAGE_TEST_MARKER();
+                    }
                 }
+                taskEXIT_CRITICAL();
+
+                xTimeoutOccurred = pdTRUE;
+            }
+            else
+            {
+                /* The task unblocked because the bits were set. */
             }
-            taskEXIT_CRITICAL();
 
-            xTimeoutOccurred = pdTRUE;
-        } else {
-            /* The task unblocked because the bits were set. */
+            /* Control bits might be set as the task had blocked should not be
+             * returned. */
+            uxReturn &= ~eventEVENT_BITS_CONTROL_BYTES;
         }
 
-        /* Control bits might be set as the task had blocked should not be
-         * returned. */
-        uxReturn &= ~eventEVENT_BITS_CONTROL_BYTES;
-    }
+        traceEVENT_GROUP_SYNC_END( xEventGroup, uxBitsToSet, uxBitsToWaitFor, xTimeoutOccurred );
 
-    traceEVENT_GROUP_SYNC_END(xEventGroup, uxBitsToSet, uxBitsToWaitFor, xTimeoutOccurred);
+        /* Prevent compiler warnings when trace macros are not used. */
+        ( void ) xTimeoutOccurred;
 
-    /* Prevent compiler warnings when trace macros are not used. */
-    (void) xTimeoutOccurred;
+        traceRETURN_xEventGroupSync( uxReturn );
 
-    return uxReturn;
-}
-/*-----------------------------------------------------------*/
-
-EventBits_t xEventGroupWaitBits(EventGroupHandle_t xEventGroup,
-                                const EventBits_t uxBitsToWaitFor,
-                                const BaseType_t xClearOnExit,
-                                const BaseType_t xWaitForAllBits,
-                                TickType_t xTicksToWait)
-{
-    EventGroup_t * pxEventBits = xEventGroup;
-    EventBits_t uxReturn, uxControlBits = 0;
-    BaseType_t xWaitConditionMet, xAlreadyYielded;
-    BaseType_t xTimeoutOccurred = pdFALSE;
-
-    /* Check the user is not attempting to wait on the bits used by the kernel
-     * itself, and that at least one bit is being requested. */
-    configASSERT(xEventGroup);
-    configASSERT((uxBitsToWaitFor & eventEVENT_BITS_CONTROL_BYTES) == 0);
-    configASSERT(uxBitsToWaitFor != 0);
-#if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
-    {
-        configASSERT(!((xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED) && (xTicksToWait != 0)));
+        return uxReturn;
     }
-#endif
+/*-----------------------------------------------------------*/
 
-    vTaskSuspendAll();
+    EventBits_t xEventGroupWaitBits( EventGroupHandle_t xEventGroup,
+                                     const EventBits_t uxBitsToWaitFor,
+                                     const BaseType_t xClearOnExit,
+                                     const BaseType_t xWaitForAllBits,
+                                     TickType_t xTicksToWait )
     {
-        const EventBits_t uxCurrentEventBits = pxEventBits->uxEventBits;
+        EventGroup_t * pxEventBits = xEventGroup;
+        EventBits_t uxReturn, uxControlBits = 0;
+        BaseType_t xWaitConditionMet, xAlreadyYielded;
+        BaseType_t xTimeoutOccurred = pdFALSE;
+
+        traceENTER_xEventGroupWaitBits( xEventGroup, uxBitsToWaitFor, xClearOnExit, xWaitForAllBits, xTicksToWait );
+
+        /* Check the user is not attempting to wait on the bits used by the kernel
+         * itself, and that at least one bit is being requested. */
+        configASSERT( xEventGroup );
+        configASSERT( ( uxBitsToWaitFor & eventEVENT_BITS_CONTROL_BYTES ) == 0 );
+        configASSERT( uxBitsToWaitFor != 0 );
+        #if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
+        {
+            configASSERT( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) );
+        }
+        #endif
 
-        /* Check to see if the wait condition is already met or not. */
-        xWaitConditionMet = prvTestWaitCondition(uxCurrentEventBits, uxBitsToWaitFor, xWaitForAllBits);
+        vTaskSuspendAll();
+        {
+            const EventBits_t uxCurrentEventBits = pxEventBits->uxEventBits;
 
-        if (xWaitConditionMet != pdFALSE) {
-            /* The wait condition has already been met so there is no need to
-             * block. */
-            uxReturn = uxCurrentEventBits;
-            xTicksToWait = (TickType_t) 0;
+            /* Check to see if the wait condition is already met or not. */
+            xWaitConditionMet = prvTestWaitCondition( uxCurrentEventBits, uxBitsToWaitFor, xWaitForAllBits );
 
-            /* Clear the wait bits if requested to do so. */
-            if (xClearOnExit != pdFALSE) {
-                pxEventBits->uxEventBits &= ~uxBitsToWaitFor;
-            } else {
-                mtCOVERAGE_TEST_MARKER();
+            if( xWaitConditionMet != pdFALSE )
+            {
+                /* The wait condition has already been met so there is no need to
+                 * block. */
+                uxReturn = uxCurrentEventBits;
+                xTicksToWait = ( TickType_t ) 0;
+
+                /* Clear the wait bits if requested to do so. */
+                if( xClearOnExit != pdFALSE )
+                {
+                    pxEventBits->uxEventBits &= ~uxBitsToWaitFor;
+                }
+                else
+                {
+                    mtCOVERAGE_TEST_MARKER();
+                }
             }
-        } else if (xTicksToWait == (TickType_t) 0) {
-            /* The wait condition has not been met, but no block time was
-             * specified, so just return the current value. */
-            uxReturn = uxCurrentEventBits;
-            xTimeoutOccurred = pdTRUE;
-        } else {
-            /* The task is going to block to wait for its required bits to be
-             * set.  uxControlBits are used to remember the specified behaviour of
-             * this call to xEventGroupWaitBits() - for use when the event bits
-             * unblock the task. */
-            if (xClearOnExit != pdFALSE) {
-                uxControlBits |= eventCLEAR_EVENTS_ON_EXIT_BIT;
-            } else {
-                mtCOVERAGE_TEST_MARKER();
+            else if( xTicksToWait == ( TickType_t ) 0 )
+            {
+                /* The wait condition has not been met, but no block time was
+                 * specified, so just return the current value. */
+                uxReturn = uxCurrentEventBits;
+                xTimeoutOccurred = pdTRUE;
             }
+            else
+            {
+                /* The task is going to block to wait for its required bits to be
+                 * set.  uxControlBits are used to remember the specified behaviour of
+                 * this call to xEventGroupWaitBits() - for use when the event bits
+                 * unblock the task. */
+                if( xClearOnExit != pdFALSE )
+                {
+                    uxControlBits |= eventCLEAR_EVENTS_ON_EXIT_BIT;
+                }
+                else
+                {
+                    mtCOVERAGE_TEST_MARKER();
+                }
 
-            if (xWaitForAllBits != pdFALSE) {
-                uxControlBits |= eventWAIT_FOR_ALL_BITS;
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
+                if( xWaitForAllBits != pdFALSE )
+                {
+                    uxControlBits |= eventWAIT_FOR_ALL_BITS;
+                }
+                else
+                {
+                    mtCOVERAGE_TEST_MARKER();
+                }
 
-            /* Store the bits that the calling task is waiting for in the
-             * task's event list item so the kernel knows when a match is
-             * found.  Then enter the blocked state. */
-            vTaskPlaceOnUnorderedEventList(&(pxEventBits->xTasksWaitingForBits), (uxBitsToWaitFor | uxControlBits), xTicksToWait);
+                /* Store the bits that the calling task is waiting for in the
+                 * task's event list item so the kernel knows when a match is
+                 * found.  Then enter the blocked state. */
+                vTaskPlaceOnUnorderedEventList( &( pxEventBits->xTasksWaitingForBits ), ( uxBitsToWaitFor | uxControlBits ), xTicksToWait );
 
-            /* This is obsolete as it will get set after the task unblocks, but
-             * some compilers mistakenly generate a warning about the variable
-             * being returned without being set if it is not done. */
-            uxReturn = 0;
+                /* This is obsolete as it will get set after the task unblocks, but
+                 * some compilers mistakenly generate a warning about the variable
+                 * being returned without being set if it is not done. */
+                uxReturn = 0;
 
-            traceEVENT_GROUP_WAIT_BITS_BLOCK(xEventGroup, uxBitsToWaitFor);
+                traceEVENT_GROUP_WAIT_BITS_BLOCK( xEventGroup, uxBitsToWaitFor );
+            }
         }
-    }
-    xAlreadyYielded = xTaskResumeAll();
+        xAlreadyYielded = xTaskResumeAll();
 
-    if (xTicksToWait != (TickType_t) 0) {
-        if (xAlreadyYielded == pdFALSE) {
-            portYIELD_WITHIN_API();
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
+        if( xTicksToWait != ( TickType_t ) 0 )
+        {
+            if( xAlreadyYielded == pdFALSE )
+            {
+                taskYIELD_WITHIN_API();
+            }
+            else
+            {
+                mtCOVERAGE_TEST_MARKER();
+            }
 
-        /* The task blocked to wait for its required bits to be set - at this
-         * point either the required bits were set or the block time expired.  If
-         * the required bits were set they will have been stored in the task's
-         * event list item, and they should now be retrieved then cleared. */
-        uxReturn = uxTaskResetEventItemValue();
+            /* The task blocked to wait for its required bits to be set - at this
+             * point either the required bits were set or the block time expired.  If
+             * the required bits were set they will have been stored in the task's
+             * event list item, and they should now be retrieved then cleared. */
+            uxReturn = uxTaskResetEventItemValue();
 
-        if ((uxReturn & eventUNBLOCKED_DUE_TO_BIT_SET) == (EventBits_t) 0) {
-            taskENTER_CRITICAL();
+            if( ( uxReturn & eventUNBLOCKED_DUE_TO_BIT_SET ) == ( EventBits_t ) 0 )
             {
-                /* The task timed out, just return the current event bit value. */
-                uxReturn = pxEventBits->uxEventBits;
-
-                /* It is possible that the event bits were updated between this
-                 * task leaving the Blocked state and running again. */
-                if (prvTestWaitCondition(uxReturn, uxBitsToWaitFor, xWaitForAllBits) != pdFALSE) {
-                    if (xClearOnExit != pdFALSE) {
-                        pxEventBits->uxEventBits &= ~uxBitsToWaitFor;
-                    } else {
+                taskENTER_CRITICAL();
+                {
+                    /* The task timed out, just return the current event bit value. */
+                    uxReturn = pxEventBits->uxEventBits;
+
+                    /* It is possible that the event bits were updated between this
+                     * task leaving the Blocked state and running again. */
+                    if( prvTestWaitCondition( uxReturn, uxBitsToWaitFor, xWaitForAllBits ) != pdFALSE )
+                    {
+                        if( xClearOnExit != pdFALSE )
+                        {
+                            pxEventBits->uxEventBits &= ~uxBitsToWaitFor;
+                        }
+                        else
+                        {
+                            mtCOVERAGE_TEST_MARKER();
+                        }
+                    }
+                    else
+                    {
                         mtCOVERAGE_TEST_MARKER();
                     }
-                } else {
-                    mtCOVERAGE_TEST_MARKER();
-                }
 
-                xTimeoutOccurred = pdTRUE;
+                    xTimeoutOccurred = pdTRUE;
+                }
+                taskEXIT_CRITICAL();
             }
-            taskEXIT_CRITICAL();
-        } else {
-            /* The task unblocked because the bits were set. */
+            else
+            {
+                /* The task unblocked because the bits were set. */
+            }
+
+            /* The task blocked so control bits may have been set. */
+            uxReturn &= ~eventEVENT_BITS_CONTROL_BYTES;
         }
 
-        /* The task blocked so control bits may have been set. */
-        uxReturn &= ~eventEVENT_BITS_CONTROL_BYTES;
-    }
+        traceEVENT_GROUP_WAIT_BITS_END( xEventGroup, uxBitsToWaitFor, xTimeoutOccurred );
 
-    traceEVENT_GROUP_WAIT_BITS_END(xEventGroup, uxBitsToWaitFor, xTimeoutOccurred);
+        /* Prevent compiler warnings when trace macros are not used. */
+        ( void ) xTimeoutOccurred;
 
-    /* Prevent compiler warnings when trace macros are not used. */
-    (void) xTimeoutOccurred;
+        traceRETURN_xEventGroupWaitBits( uxReturn );
 
-    return uxReturn;
-}
+        return uxReturn;
+    }
 /*-----------------------------------------------------------*/
 
-EventBits_t xEventGroupClearBits(EventGroupHandle_t xEventGroup,
-                                 const EventBits_t uxBitsToClear)
-{
-    EventGroup_t * pxEventBits = xEventGroup;
-    EventBits_t uxReturn;
+    EventBits_t xEventGroupClearBits( EventGroupHandle_t xEventGroup,
+                                      const EventBits_t uxBitsToClear )
+    {
+        EventGroup_t * pxEventBits = xEventGroup;
+        EventBits_t uxReturn;
 
-    /* Check the user is not attempting to clear the bits used by the kernel
-     * itself. */
-    configASSERT(xEventGroup);
-    configASSERT((uxBitsToClear & eventEVENT_BITS_CONTROL_BYTES) == 0);
+        traceENTER_xEventGroupClearBits( xEventGroup, uxBitsToClear );
 
-    taskENTER_CRITICAL();
-    {
-        traceEVENT_GROUP_CLEAR_BITS(xEventGroup, uxBitsToClear);
+        /* Check the user is not attempting to clear the bits used by the kernel
+         * itself. */
+        configASSERT( xEventGroup );
+        configASSERT( ( uxBitsToClear & eventEVENT_BITS_CONTROL_BYTES ) == 0 );
 
-        /* The value returned is the event group value prior to the bits being
-         * cleared. */
-        uxReturn = pxEventBits->uxEventBits;
+        taskENTER_CRITICAL();
+        {
+            traceEVENT_GROUP_CLEAR_BITS( xEventGroup, uxBitsToClear );
 
-        /* Clear the bits. */
-        pxEventBits->uxEventBits &= ~uxBitsToClear;
-    }
-    taskEXIT_CRITICAL();
+            /* The value returned is the event group value prior to the bits being
+             * cleared. */
+            uxReturn = pxEventBits->uxEventBits;
 
-    return uxReturn;
-}
-/*-----------------------------------------------------------*/
+            /* Clear the bits. */
+            pxEventBits->uxEventBits &= ~uxBitsToClear;
+        }
+        taskEXIT_CRITICAL();
 
-#if ( ( configUSE_TRACE_FACILITY == 1 ) && ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) )
+        traceRETURN_xEventGroupClearBits( uxReturn );
 
-BaseType_t xEventGroupClearBitsFromISR(EventGroupHandle_t xEventGroup,
-                                       const EventBits_t uxBitsToClear)
-{
-    BaseType_t xReturn;
+        return uxReturn;
+    }
+/*-----------------------------------------------------------*/
 
-    traceEVENT_GROUP_CLEAR_BITS_FROM_ISR(xEventGroup, uxBitsToClear);
-    xReturn = xTimerPendFunctionCallFromISR(vEventGroupClearBitsCallback, (void *) xEventGroup, (uint32_t) uxBitsToClear, NULL);       /*lint !e9087 Can't avoid cast to void* as a generic callback function not specific to this use case. Callback casts back to original type so safe. */
+    #if ( ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) )
 
-    return xReturn;
-}
+        BaseType_t xEventGroupClearBitsFromISR( EventGroupHandle_t xEventGroup,
+                                                const EventBits_t uxBitsToClear )
+        {
+            BaseType_t xReturn;
 
-#endif /* if ( ( configUSE_TRACE_FACILITY == 1 ) && ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) ) */
-/*-----------------------------------------------------------*/
+            traceENTER_xEventGroupClearBitsFromISR( xEventGroup, uxBitsToClear );
 
-EventBits_t xEventGroupGetBitsFromISR(EventGroupHandle_t xEventGroup)
-{
-    UBaseType_t uxSavedInterruptStatus;
-    EventGroup_t const * const pxEventBits = xEventGroup;
-    EventBits_t uxReturn;
+            traceEVENT_GROUP_CLEAR_BITS_FROM_ISR( xEventGroup, uxBitsToClear );
+            xReturn = xTimerPendFunctionCallFromISR( &vEventGroupClearBitsCallback, ( void * ) xEventGroup, ( uint32_t ) uxBitsToClear, NULL );
 
-    uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
-    {
-        uxReturn = pxEventBits->uxEventBits;
-    }
-    portCLEAR_INTERRUPT_MASK_FROM_ISR(uxSavedInterruptStatus);
+            traceRETURN_xEventGroupClearBitsFromISR( xReturn );
+
+            return xReturn;
+        }
 
-    return uxReturn;
-} /*lint !e818 EventGroupHandle_t is a typedef used in other functions to so can't be pointer to const. */
+    #endif /* if ( ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) ) */
 /*-----------------------------------------------------------*/
 
-EventBits_t xEventGroupSetBits(EventGroupHandle_t xEventGroup,
-                               const EventBits_t uxBitsToSet)
-{
-    ListItem_t * pxListItem, * pxNext;
-    ListItem_t const * pxListEnd;
-    List_t const * pxList;
-    EventBits_t uxBitsToClear = 0, uxBitsWaitedFor, uxControlBits;
-    EventGroup_t * pxEventBits = xEventGroup;
-    BaseType_t xMatchFound = pdFALSE;
-
-    /* Check the user is not attempting to set the bits used by the kernel
-     * itself. */
-    configASSERT(xEventGroup);
-    configASSERT((uxBitsToSet & eventEVENT_BITS_CONTROL_BYTES) == 0);
-
-    pxList = &(pxEventBits->xTasksWaitingForBits);
-    pxListEnd = listGET_END_MARKER(pxList);   /*lint !e826 !e740 !e9087 The mini list structure is used as the list end to save RAM.  This is checked and valid. */
-    vTaskSuspendAll();
+    EventBits_t xEventGroupGetBitsFromISR( EventGroupHandle_t xEventGroup )
     {
-        traceEVENT_GROUP_SET_BITS(xEventGroup, uxBitsToSet);
+        UBaseType_t uxSavedInterruptStatus;
+        EventGroup_t const * const pxEventBits = xEventGroup;
+        EventBits_t uxReturn;
+
+        traceENTER_xEventGroupGetBitsFromISR( xEventGroup );
 
-        pxListItem = listGET_HEAD_ENTRY(pxList);
+        /* MISRA Ref 4.7.1 [Return value shall be checked] */
+        /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#dir-47 */
+        /* coverity[misra_c_2012_directive_4_7_violation] */
+        uxSavedInterruptStatus = taskENTER_CRITICAL_FROM_ISR();
+        {
+            uxReturn = pxEventBits->uxEventBits;
+        }
+        taskEXIT_CRITICAL_FROM_ISR( uxSavedInterruptStatus );
+
+        traceRETURN_xEventGroupGetBitsFromISR( uxReturn );
+
+        return uxReturn;
+    }
+/*-----------------------------------------------------------*/
 
-        /* Set the bits. */
-        pxEventBits->uxEventBits |= uxBitsToSet;
+    EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup,
+                                    const EventBits_t uxBitsToSet )
+    {
+        ListItem_t * pxListItem;
+        ListItem_t * pxNext;
+        ListItem_t const * pxListEnd;
+        List_t const * pxList;
+        EventBits_t uxBitsToClear = 0, uxBitsWaitedFor, uxControlBits, uxReturnBits;
+        EventGroup_t * pxEventBits = xEventGroup;
+        BaseType_t xMatchFound = pdFALSE;
+
+        traceENTER_xEventGroupSetBits( xEventGroup, uxBitsToSet );
+
+        /* Check the user is not attempting to set the bits used by the kernel
+         * itself. */
+        configASSERT( xEventGroup );
+        configASSERT( ( uxBitsToSet & eventEVENT_BITS_CONTROL_BYTES ) == 0 );
+
+        pxList = &( pxEventBits->xTasksWaitingForBits );
+        pxListEnd = listGET_END_MARKER( pxList );
+        vTaskSuspendAll();
+        {
+            traceEVENT_GROUP_SET_BITS( xEventGroup, uxBitsToSet );
 
-        /* See if the new bit value should unblock any tasks. */
-        while (pxListItem != pxListEnd) {
-            pxNext = listGET_NEXT(pxListItem);
-            uxBitsWaitedFor = listGET_LIST_ITEM_VALUE(pxListItem);
-            xMatchFound = pdFALSE;
+            pxListItem = listGET_HEAD_ENTRY( pxList );
 
-            /* Split the bits waited for from the control bits. */
-            uxControlBits = uxBitsWaitedFor & eventEVENT_BITS_CONTROL_BYTES;
-            uxBitsWaitedFor &= ~eventEVENT_BITS_CONTROL_BYTES;
+            /* Set the bits. */
+            pxEventBits->uxEventBits |= uxBitsToSet;
 
-            if ((uxControlBits & eventWAIT_FOR_ALL_BITS) == (EventBits_t) 0) {
-                /* Just looking for single bit being set. */
-                if ((uxBitsWaitedFor & pxEventBits->uxEventBits) != (EventBits_t) 0) {
+            /* See if the new bit value should unblock any tasks. */
+            while( pxListItem != pxListEnd )
+            {
+                pxNext = listGET_NEXT( pxListItem );
+                uxBitsWaitedFor = listGET_LIST_ITEM_VALUE( pxListItem );
+                xMatchFound = pdFALSE;
+
+                /* Split the bits waited for from the control bits. */
+                uxControlBits = uxBitsWaitedFor & eventEVENT_BITS_CONTROL_BYTES;
+                uxBitsWaitedFor &= ~eventEVENT_BITS_CONTROL_BYTES;
+
+                if( ( uxControlBits & eventWAIT_FOR_ALL_BITS ) == ( EventBits_t ) 0 )
+                {
+                    /* Just looking for single bit being set. */
+                    if( ( uxBitsWaitedFor & pxEventBits->uxEventBits ) != ( EventBits_t ) 0 )
+                    {
+                        xMatchFound = pdTRUE;
+                    }
+                    else
+                    {
+                        mtCOVERAGE_TEST_MARKER();
+                    }
+                }
+                else if( ( uxBitsWaitedFor & pxEventBits->uxEventBits ) == uxBitsWaitedFor )
+                {
+                    /* All bits are set. */
                     xMatchFound = pdTRUE;
-                } else {
-                    mtCOVERAGE_TEST_MARKER();
                 }
-            } else if ((uxBitsWaitedFor & pxEventBits->uxEventBits) == uxBitsWaitedFor) {
-                /* All bits are set. */
-                xMatchFound = pdTRUE;
-            } else {
-                /* Need all bits to be set, but not all the bits were set. */
-            }
+                else
+                {
+                    /* Need all bits to be set, but not all the bits were set. */
+                }
 
-            if (xMatchFound != pdFALSE) {
-                /* The bits match.  Should the bits be cleared on exit? */
-                if ((uxControlBits & eventCLEAR_EVENTS_ON_EXIT_BIT) != (EventBits_t) 0) {
-                    uxBitsToClear |= uxBitsWaitedFor;
-                } else {
-                    mtCOVERAGE_TEST_MARKER();
+                if( xMatchFound != pdFALSE )
+                {
+                    /* The bits match.  Should the bits be cleared on exit? */
+                    if( ( uxControlBits & eventCLEAR_EVENTS_ON_EXIT_BIT ) != ( EventBits_t ) 0 )
+                    {
+                        uxBitsToClear |= uxBitsWaitedFor;
+                    }
+                    else
+                    {
+                        mtCOVERAGE_TEST_MARKER();
+                    }
+
+                    /* Store the actual event flag value in the task's event list
+                     * item before removing the task from the event list.  The
+                     * eventUNBLOCKED_DUE_TO_BIT_SET bit is set so the task knows
+                     * that is was unblocked due to its required bits matching, rather
+                     * than because it timed out. */
+                    vTaskRemoveFromUnorderedEventList( pxListItem, pxEventBits->uxEventBits | eventUNBLOCKED_DUE_TO_BIT_SET );
                 }
 
-                /* Store the actual event flag value in the task's event list
-                 * item before removing the task from the event list.  The
-                 * eventUNBLOCKED_DUE_TO_BIT_SET bit is set so the task knows
-                 * that is was unblocked due to its required bits matching, rather
-                 * than because it timed out. */
-                vTaskRemoveFromUnorderedEventList(pxListItem, pxEventBits->uxEventBits | eventUNBLOCKED_DUE_TO_BIT_SET);
+                /* Move onto the next list item.  Note pxListItem->pxNext is not
+                 * used here as the list item may have been removed from the event list
+                 * and inserted into the ready/pending reading list. */
+                pxListItem = pxNext;
             }
 
-            /* Move onto the next list item.  Note pxListItem->pxNext is not
-             * used here as the list item may have been removed from the event list
-             * and inserted into the ready/pending reading list. */
-            pxListItem = pxNext;
+            /* Clear any bits that matched when the eventCLEAR_EVENTS_ON_EXIT_BIT
+             * bit was set in the control word. */
+            pxEventBits->uxEventBits &= ~uxBitsToClear;
+
+            /* Snapshot resulting bits. */
+            uxReturnBits = pxEventBits->uxEventBits;
         }
+        ( void ) xTaskResumeAll();
 
-        /* Clear any bits that matched when the eventCLEAR_EVENTS_ON_EXIT_BIT
-         * bit was set in the control word. */
-        pxEventBits->uxEventBits &= ~uxBitsToClear;
-    }
-    (void) xTaskResumeAll();
+        traceRETURN_xEventGroupSetBits( uxReturnBits );
 
-    return pxEventBits->uxEventBits;
-}
+        return uxReturnBits;
+    }
 /*-----------------------------------------------------------*/
 
-void vEventGroupDelete(EventGroupHandle_t xEventGroup)
-{
-    EventGroup_t * pxEventBits = xEventGroup;
-    const List_t * pxTasksWaitingForBits;
+    void vEventGroupDelete( EventGroupHandle_t xEventGroup )
+    {
+        EventGroup_t * pxEventBits = xEventGroup;
+        const List_t * pxTasksWaitingForBits;
 
-    configASSERT(pxEventBits);
+        traceENTER_vEventGroupDelete( xEventGroup );
 
-    pxTasksWaitingForBits = &(pxEventBits->xTasksWaitingForBits);
+        configASSERT( pxEventBits );
 
-    vTaskSuspendAll();
-    {
-        traceEVENT_GROUP_DELETE(xEventGroup);
+        pxTasksWaitingForBits = &( pxEventBits->xTasksWaitingForBits );
+
+        vTaskSuspendAll();
+        {
+            traceEVENT_GROUP_DELETE( xEventGroup );
 
-        while (listCURRENT_LIST_LENGTH(pxTasksWaitingForBits) > (UBaseType_t) 0) {
-            /* Unblock the task, returning 0 as the event list is being deleted
-             * and cannot therefore have any bits set. */
-            configASSERT(pxTasksWaitingForBits->xListEnd.pxNext != (const ListItem_t *) & (pxTasksWaitingForBits->xListEnd));
-            vTaskRemoveFromUnorderedEventList(pxTasksWaitingForBits->xListEnd.pxNext, eventUNBLOCKED_DUE_TO_BIT_SET);
+            while( listCURRENT_LIST_LENGTH( pxTasksWaitingForBits ) > ( UBaseType_t ) 0 )
+            {
+                /* Unblock the task, returning 0 as the event list is being deleted
+                 * and cannot therefore have any bits set. */
+                configASSERT( pxTasksWaitingForBits->xListEnd.pxNext != ( const ListItem_t * ) &( pxTasksWaitingForBits->xListEnd ) );
+                vTaskRemoveFromUnorderedEventList( pxTasksWaitingForBits->xListEnd.pxNext, eventUNBLOCKED_DUE_TO_BIT_SET );
+            }
         }
+        ( void ) xTaskResumeAll();
 
-#if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 0 ) )
+        #if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 0 ) )
         {
             /* The event group can only have been allocated dynamically - free
              * it again. */
-            SramFree(pxEventBits);
+            vPortFree( pxEventBits );
         }
-#elif ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
+        #elif ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
         {
             /* The event group could have been allocated statically or
              * dynamically, so check before attempting to free the memory. */
-            if (pxEventBits->ucStaticallyAllocated == (uint8_t) pdFALSE) {
-                SramFree(pxEventBits);
-            } else {
+            if( pxEventBits->ucStaticallyAllocated == ( uint8_t ) pdFALSE )
+            {
+                vPortFree( pxEventBits );
+            }
+            else
+            {
                 mtCOVERAGE_TEST_MARKER();
             }
         }
-#endif /* configSUPPORT_DYNAMIC_ALLOCATION */
+        #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
+
+        traceRETURN_vEventGroupDelete();
     }
-    (void) xTaskResumeAll();
-}
+/*-----------------------------------------------------------*/
+
+    #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
+        BaseType_t xEventGroupGetStaticBuffer( EventGroupHandle_t xEventGroup,
+                                               StaticEventGroup_t ** ppxEventGroupBuffer )
+        {
+            BaseType_t xReturn;
+            EventGroup_t * pxEventBits = xEventGroup;
+
+            traceENTER_xEventGroupGetStaticBuffer( xEventGroup, ppxEventGroupBuffer );
+
+            configASSERT( pxEventBits );
+            configASSERT( ppxEventGroupBuffer );
+
+            #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
+            {
+                /* Check if the event group was statically allocated. */
+                if( pxEventBits->ucStaticallyAllocated == ( uint8_t ) pdTRUE )
+                {
+                    /* MISRA Ref 11.3.1 [Misaligned access] */
+                    /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-113 */
+                    /* coverity[misra_c_2012_rule_11_3_violation] */
+                    *ppxEventGroupBuffer = ( StaticEventGroup_t * ) pxEventBits;
+                    xReturn = pdTRUE;
+                }
+                else
+                {
+                    xReturn = pdFALSE;
+                }
+            }
+            #else /* configSUPPORT_DYNAMIC_ALLOCATION */
+            {
+                /* Event group must have been statically allocated. */
+                /* MISRA Ref 11.3.1 [Misaligned access] */
+                /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-113 */
+                /* coverity[misra_c_2012_rule_11_3_violation] */
+                *ppxEventGroupBuffer = ( StaticEventGroup_t * ) pxEventBits;
+                xReturn = pdTRUE;
+            }
+            #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
+
+            traceRETURN_xEventGroupGetStaticBuffer( xReturn );
+
+            return xReturn;
+        }
+    #endif /* configSUPPORT_STATIC_ALLOCATION */
 /*-----------------------------------------------------------*/
 
 /* For internal use only - execute a 'set bits' command that was pended from
  * an interrupt. */
-void vEventGroupSetBitsCallback(void * pvEventGroup,
-                                const uint32_t ulBitsToSet)
-{
-    (void) xEventGroupSetBits(pvEventGroup, (EventBits_t) ulBitsToSet);       /*lint !e9079 Can't avoid cast to void* as a generic timer callback prototype. Callback casts back to original type so safe. */
-}
+    void vEventGroupSetBitsCallback( void * pvEventGroup,
+                                     uint32_t ulBitsToSet )
+    {
+        traceENTER_vEventGroupSetBitsCallback( pvEventGroup, ulBitsToSet );
+
+        /* MISRA Ref 11.5.4 [Callback function parameter] */
+        /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-115 */
+        /* coverity[misra_c_2012_rule_11_5_violation] */
+        ( void ) xEventGroupSetBits( pvEventGroup, ( EventBits_t ) ulBitsToSet );
+
+        traceRETURN_vEventGroupSetBitsCallback();
+    }
 /*-----------------------------------------------------------*/
 
 /* For internal use only - execute a 'clear bits' command that was pended from
  * an interrupt. */
-void vEventGroupClearBitsCallback(void * pvEventGroup,
-                                  const uint32_t ulBitsToClear)
-{
-    (void) xEventGroupClearBits(pvEventGroup, (EventBits_t) ulBitsToClear);       /*lint !e9079 Can't avoid cast to void* as a generic timer callback prototype. Callback casts back to original type so safe. */
-}
+    void vEventGroupClearBitsCallback( void * pvEventGroup,
+                                       uint32_t ulBitsToClear )
+    {
+        traceENTER_vEventGroupClearBitsCallback( pvEventGroup, ulBitsToClear );
+
+        /* MISRA Ref 11.5.4 [Callback function parameter] */
+        /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-115 */
+        /* coverity[misra_c_2012_rule_11_5_violation] */
+        ( void ) xEventGroupClearBits( pvEventGroup, ( EventBits_t ) ulBitsToClear );
+
+        traceRETURN_vEventGroupClearBitsCallback();
+    }
 /*-----------------------------------------------------------*/
 
-static BaseType_t prvTestWaitCondition(const EventBits_t uxCurrentEventBits,
-                                       const EventBits_t uxBitsToWaitFor,
-                                       const BaseType_t xWaitForAllBits)
-{
-    BaseType_t xWaitConditionMet = pdFALSE;
-
-    if (xWaitForAllBits == pdFALSE) {
-        /* Task only has to wait for one bit within uxBitsToWaitFor to be
-         * set.  Is one already set? */
-        if ((uxCurrentEventBits & uxBitsToWaitFor) != (EventBits_t) 0) {
-            xWaitConditionMet = pdTRUE;
-        } else {
-            mtCOVERAGE_TEST_MARKER();
+    static BaseType_t prvTestWaitCondition( const EventBits_t uxCurrentEventBits,
+                                            const EventBits_t uxBitsToWaitFor,
+                                            const BaseType_t xWaitForAllBits )
+    {
+        BaseType_t xWaitConditionMet = pdFALSE;
+
+        if( xWaitForAllBits == pdFALSE )
+        {
+            /* Task only has to wait for one bit within uxBitsToWaitFor to be
+             * set.  Is one already set? */
+            if( ( uxCurrentEventBits & uxBitsToWaitFor ) != ( EventBits_t ) 0 )
+            {
+                xWaitConditionMet = pdTRUE;
+            }
+            else
+            {
+                mtCOVERAGE_TEST_MARKER();
+            }
         }
-    } else {
-        /* Task has to wait for all the bits in uxBitsToWaitFor to be set.
-         * Are they set already? */
-        if ((uxCurrentEventBits & uxBitsToWaitFor) == uxBitsToWaitFor) {
-            xWaitConditionMet = pdTRUE;
-        } else {
-            mtCOVERAGE_TEST_MARKER();
+        else
+        {
+            /* Task has to wait for all the bits in uxBitsToWaitFor to be set.
+             * Are they set already? */
+            if( ( uxCurrentEventBits & uxBitsToWaitFor ) == uxBitsToWaitFor )
+            {
+                xWaitConditionMet = pdTRUE;
+            }
+            else
+            {
+                mtCOVERAGE_TEST_MARKER();
+            }
         }
-    }
 
-    return xWaitConditionMet;
-}
+        return xWaitConditionMet;
+    }
 /*-----------------------------------------------------------*/
 
-#if ( ( configUSE_TRACE_FACILITY == 1 ) && ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) )
+    #if ( ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) )
+
+        BaseType_t xEventGroupSetBitsFromISR( EventGroupHandle_t xEventGroup,
+                                              const EventBits_t uxBitsToSet,
+                                              BaseType_t * pxHigherPriorityTaskWoken )
+        {
+            BaseType_t xReturn;
 
-BaseType_t xEventGroupSetBitsFromISR(EventGroupHandle_t xEventGroup,
-                                     const EventBits_t uxBitsToSet,
-                                     BaseType_t * pxHigherPriorityTaskWoken)
-{
-    BaseType_t xReturn;
+            traceENTER_xEventGroupSetBitsFromISR( xEventGroup, uxBitsToSet, pxHigherPriorityTaskWoken );
 
-    traceEVENT_GROUP_SET_BITS_FROM_ISR(xEventGroup, uxBitsToSet);
-    xReturn = xTimerPendFunctionCallFromISR(vEventGroupSetBitsCallback, (void *) xEventGroup, (uint32_t) uxBitsToSet, pxHigherPriorityTaskWoken);       /*lint !e9087 Can't avoid cast to void* as a generic callback function not specific to this use case. Callback casts back to original type so safe. */
+            traceEVENT_GROUP_SET_BITS_FROM_ISR( xEventGroup, uxBitsToSet );
+            xReturn = xTimerPendFunctionCallFromISR( &vEventGroupSetBitsCallback, ( void * ) xEventGroup, ( uint32_t ) uxBitsToSet, pxHigherPriorityTaskWoken );
 
-    return xReturn;
-}
+            traceRETURN_xEventGroupSetBitsFromISR( xReturn );
 
-#endif /* if ( ( configUSE_TRACE_FACILITY == 1 ) && ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) ) */
+            return xReturn;
+        }
+
+    #endif /* if ( ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) ) */
 /*-----------------------------------------------------------*/
 
-#if ( configUSE_TRACE_FACILITY == 1 )
+    #if ( configUSE_TRACE_FACILITY == 1 )
 
-UBaseType_t uxEventGroupGetNumber(void * xEventGroup)
-{
-    UBaseType_t xReturn;
-    EventGroup_t const * pxEventBits = (EventGroup_t *) xEventGroup;   /*lint !e9087 !e9079 EventGroupHandle_t is a pointer to an EventGroup_t, but EventGroupHandle_t is kept opaque outside of this file for data hiding purposes. */
+        UBaseType_t uxEventGroupGetNumber( void * xEventGroup )
+        {
+            UBaseType_t xReturn;
 
-    if (xEventGroup == NULL) {
-        xReturn = 0;
-    } else {
-        xReturn = pxEventBits->uxEventGroupNumber;
-    }
+            /* MISRA Ref 11.5.2 [Opaque pointer] */
+            /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-115 */
+            /* coverity[misra_c_2012_rule_11_5_violation] */
+            EventGroup_t const * pxEventBits = ( EventGroup_t * ) xEventGroup;
+
+            traceENTER_uxEventGroupGetNumber( xEventGroup );
+
+            if( xEventGroup == NULL )
+            {
+                xReturn = 0;
+            }
+            else
+            {
+                xReturn = pxEventBits->uxEventGroupNumber;
+            }
 
-    return xReturn;
-}
+            traceRETURN_uxEventGroupGetNumber( xReturn );
 
-#endif /* configUSE_TRACE_FACILITY */
+            return xReturn;
+        }
+
+    #endif /* configUSE_TRACE_FACILITY */
 /*-----------------------------------------------------------*/
 
-#if ( configUSE_TRACE_FACILITY == 1 )
+    #if ( configUSE_TRACE_FACILITY == 1 )
+
+        void vEventGroupSetNumber( void * xEventGroup,
+                                   UBaseType_t uxEventGroupNumber )
+        {
+            traceENTER_vEventGroupSetNumber( xEventGroup, uxEventGroupNumber );
 
-void vEventGroupSetNumber(void * xEventGroup,
-                          UBaseType_t uxEventGroupNumber)
-{
-    ((EventGroup_t *) xEventGroup)->uxEventGroupNumber = uxEventGroupNumber;     /*lint !e9087 !e9079 EventGroupHandle_t is a pointer to an EventGroup_t, but EventGroupHandle_t is kept opaque outside of this file for data hiding purposes. */
-}
+            /* MISRA Ref 11.5.2 [Opaque pointer] */
+            /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-115 */
+            /* coverity[misra_c_2012_rule_11_5_violation] */
+            ( ( EventGroup_t * ) xEventGroup )->uxEventGroupNumber = uxEventGroupNumber;
 
-#endif /* configUSE_TRACE_FACILITY */
+            traceRETURN_vEventGroupSetNumber();
+        }
+
+    #endif /* configUSE_TRACE_FACILITY */
 /*-----------------------------------------------------------*/
+
+/* This entire source file will be skipped if the application is not configured
+ * to include event groups functionality. If you want to include event groups
+ * then ensure configUSE_EVENT_GROUPS is set to 1 in FreeRTOSConfig.h. */
+#endif /* configUSE_EVENT_GROUPS == 1 */

### external/FreeRTOS/Source/include/CMakeLists.txt
@@ -0,0 +1,15 @@
+# FreeRTOS internal cmake file. Do not use it in user top-level project
+
+add_library(freertos_kernel_include INTERFACE)
+
+target_include_directories(freertos_kernel_include
+    INTERFACE
+        .
+        # Note: DEPRECATED but still supported, may be removed in a future release.
+        $<$<NOT:$<TARGET_EXISTS:freertos_config>>:${FREERTOS_CONFIG_FILE_DIRECTORY}>
+)
+
+target_link_libraries(freertos_kernel_include
+    INTERFACE
+        $<$<TARGET_EXISTS:freertos_config>:freertos_config>
+)

### external/FreeRTOS/Source/include/FreeRTOS.h
[binary or diff unavailable]

### external/FreeRTOS/Source/include/StackMacros.h
@@ -1,6 +1,6 @@
 /*
- * FreeRTOS Kernel V10.4.6
- * Copyright (C) 2021 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ * FreeRTOS Kernel V11.3.0
+ * Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -28,7 +28,7 @@
 
 
 #ifndef _MSC_VER /* Visual Studio doesn't support #warning. */
-#warning The name of this file has changed to stack_macros.h.  Please update your code accordingly.  This source file (which has the original name) will be removed in future released.
+    #warning The name of this file has changed to stack_macros.h.  Please update your code accordingly.  This source file (which has the original name) will be removed in a future release.
 #endif
 
 #include "stack_macros.h"

### external/FreeRTOS/Source/include/atomic.h
@@ -1,6 +1,6 @@
 /*
- * FreeRTOS Kernel V10.4.6
- * Copyright (C) 2021 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ * FreeRTOS Kernel V11.3.0
+ * Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -33,13 +33,21 @@
  * This file implements atomic functions by disabling interrupts globally.
  * Implementations with architecture specific atomic instructions can be
  * provided under each compiler directory.
+ *
+ * The atomic interface can be used in FreeRTOS tasks on all FreeRTOS ports. It
+ * can also be used in Interrupt Service Routines (ISRs) on FreeRTOS ports that
+ * support nested interrupts (i.e. portHAS_NESTED_INTERRUPTS is set to 1). The
+ * atomic interface must not be used in ISRs on FreeRTOS ports that do not
+ * support nested interrupts (i.e. portHAS_NESTED_INTERRUPTS is set to 0)
+ * because ISRs on these ports cannot be interrupted and therefore, do not need
+ * atomics in ISRs.
  */
 
 #ifndef ATOMIC_H
 #define ATOMIC_H
 
 #ifndef INC_FREERTOS_H
-#error "include FreeRTOS.h must appear in source files before include atomic.h"
+    #error "include FreeRTOS.h must appear in source files before include atomic.h"
 #endif
 
 /* Standard includes. */
@@ -51,74 +59,77 @@
 #endif
 /* *INDENT-ON* */
 
-    /*
-     * Port specific definitions -- entering/exiting critical section.
-     * Refer template -- ./lib/FreeRTOS/portable/Compiler/Arch/portmacro.h
-     *
-     * Every call to ATOMIC_EXIT_CRITICAL() must be closely paired with
-     * ATOMIC_ENTER_CRITICAL().
-     *
-     */
-#if defined( portSET_INTERRUPT_MASK_FROM_ISR )
-
-    /* Nested interrupt scheme is supported in this port. */
-#define ATOMIC_ENTER_CRITICAL() \
+/*
+ * Port specific definitions -- entering/exiting critical section.
+ * Refer template -- ./lib/FreeRTOS/portable/Compiler/Arch/portmacro.h
+ *
+ * Every call to ATOMIC_EXIT_CRITICAL() must be closely paired with
+ * ATOMIC_ENTER_CRITICAL().
+ *
+ */
+#if ( portHAS_NESTED_INTERRUPTS == 1 )
+
+/* Nested interrupt scheme is supported in this port. */
+    #define ATOMIC_ENTER_CRITICAL() \
     UBaseType_t uxCriticalSectionType = portSET_INTERRUPT_MASK_FROM_ISR()
 
-#define ATOMIC_EXIT_CRITICAL() \
+    #define ATOMIC_EXIT_CRITICAL() \
     portCLEAR_INTERRUPT_MASK_FROM_ISR( uxCriticalSectionType )
 
 #else
 
-    /* Nested interrupt scheme is NOT supported in this port. */
-#define ATOMIC_ENTER_CRITICAL()    portENTER_CRITICAL()
-#define ATOMIC_EXIT_CRITICAL()     portEXIT_CRITICAL()
+/* Nested interrupt scheme is NOT supported in this port. */
+    #define ATOMIC_ENTER_CRITICAL()    portENTER_CRITICAL()
+    #define ATOMIC_EXIT_CRITICAL()     portEXIT_CRITICAL()
 
 #endif /* portSET_INTERRUPT_MASK_FROM_ISR() */
 
-    /*
-     * Port specific definition -- "always inline".
-     * Inline is compiler specific, and may not always get inlined depending on your
-     * optimization level.  Also, inline is considered as performance optimization
-     * for atomic.  Thus, if portFORCE_INLINE is not provided by portmacro.h,
-     * instead of resulting error, simply define it away.
-     */
+/*
+ * Port specific definition -- "always inline".
+ * Inline is compiler specific, and may not always get inlined depending on your
+ * optimization level.  Also, inline is considered as performance optimization
+ * for atomic.  Thus, if portFORCE_INLINE is not provided by portmacro.h,
+ * instead of resulting error, simply define it away.
+ */
 #ifndef portFORCE_INLINE
-#define portFORCE_INLINE
+    #define portFORCE_INLINE
 #endif
 
 #define ATOMIC_COMPARE_AND_SWAP_SUCCESS    0x1U     /**< Compare and swap succeeded, swapped. */
 #define ATOMIC_COMPARE_AND_SWAP_FAILURE    0x0U     /**< Compare and swap failed, did not swap. */
 
-    /*----------------------------- Swap && CAS ------------------------------*/
-
-    /**
-     * Atomic compare-and-swap
-     *
-     * @brief Performs an atomic compare-and-swap operation on the specified values.
-     *
-     * @param[in, out] pulDestination  Pointer to memory location from where value is
-     *                               to be loaded and checked.
-     * @param[in] ulExchange         If condition meets, write this value to memory.
-     * @param[in] ulComparand        Swap condition.
-     *
-     * @return Unsigned integer of value 1 or 0. 1 for swapped, 0 for not swapped.
-     *
-     * @note This function only swaps *pulDestination with ulExchange, if previous
-     *       *pulDestination value equals ulComparand.
-     */
-    static portFORCE_INLINE uint32_t Atomic_CompareAndSwap_u32(uint32_t volatile * pulDestination,
-            uint32_t ulExchange,
-            uint32_t ulComparand)
+/*----------------------------- Swap && CAS ------------------------------*/
+
+/**
+ * Atomic compare-and-swap
+ *
+ * @brief Performs an atomic compare-and-swap operation on the specified values.
+ *
+ * @param[in, out] pulDestination  Pointer to memory location from where value is
+ *                               to be loaded and checked.
+ * @param[in] ulExchange         If condition meets, write this value to memory.
+ * @param[in] ulComparand        Swap condition.
+ *
+ * @return Unsigned integer of value 1 or 0. 1 for swapped, 0 for not swapped.
+ *
+ * @note This function only swaps *pulDestination with ulExchange, if previous
+ *       *pulDestination value equals ulComparand.
+ */
+static portFORCE_INLINE uint32_t Atomic_CompareAndSwap_u32( uint32_t volatile * pulDestination,
+                                                            uint32_t ulExchange,
+                                                            uint32_t ulComparand )
 {
     uint32_t ulReturnValue;
 
     ATOMIC_ENTER_CRITICAL();
     {
-        if (*pulDestination == ulComparand) {
+        if( *pulDestination == ulComparand )
+        {
             *pulDestination = ulExchange;
             ulReturnValue = ATOMIC_COMPARE_AND_SWAP_SUCCESS;
-        } else {
+        }
+        else
+        {
             ulReturnValue = ATOMIC_COMPARE_AND_SWAP_FAILURE;
         }
     }
@@ -140,8 +151,8 @@
  *
  * @return The initial value of *ppvDestination.
  */
-static portFORCE_INLINE void * Atomic_SwapPointers_p32(void * volatile * ppvDestination,
-        void * pvExchange)
+static portFORCE_INLINE void * Atomic_SwapPointers_p32( void * volatile * ppvDestination,
+                                                        void * pvExchange )
 {
     void * pReturnValue;
 
@@ -172,15 +183,16 @@ static portFORCE_INLINE void * Atomic_SwapPointers_p32(void * volatile * ppvDest
  * @note This function only swaps *ppvDestination with pvExchange, if previous
  *       *ppvDestination value equals pvComparand.
  */
-static portFORCE_INLINE uint32_t Atomic_CompareAndSwapPointers_p32(void * volatile * ppvDestination,
-        void * pvExchange,
-        void * pvComparand)
+static portFORCE_INLINE uint32_t Atomic_CompareAndSwapPointers_p32( void * volatile * ppvDestination,
+                                                                    void * pvExchange,
+                                                                    void * pvComparand )
 {
     uint32_t ulReturnValue = ATOMIC_COMPARE_AND_SWAP_FAILURE;
 
     ATOMIC_ENTER_CRITICAL();
     {
-        if (*ppvDestination == pvComparand) {
+        if( *ppvDestination == pvComparand )
+        {
             *ppvDestination = pvExchange;
             ulReturnValue = ATOMIC_COMPARE_AND_SWAP_SUCCESS;
         }
@@ -204,8 +216,8 @@ static portFORCE_INLINE uint32_t Atomic_CompareAndSwapPointers_p32(void * volati
  *
  * @return previous *pulAddend value.
  */
-static portFORCE_INLINE uint32_t Atomic_Add_u32(uint32_t volatile * pulAddend,
-        uint32_t ulCount)
+static portFORCE_INLINE uint32_t Atomic_Add_u32( uint32_t volatile * pulAddend,
+                                                 uint32_t ulCount )
 {
     uint32_t ulCurrent;
 
@@ -232,8 +244,8 @@ static portFORCE_INLINE uint32_t Atomic_Add_u32(uint32_t volatile * pulAddend,
  *
  * @return previous *pulAddend value.
  */
-static portFORCE_INLINE uint32_t Atomic_Subtract_u32(uint32_t volatile * pulAddend,
-        uint32_t ulCount)
+static portFORCE_INLINE uint32_t Atomic_Subtract_u32( uint32_t volatile * pulAddend,
+                                                      uint32_t ulCount )
 {
     uint32_t ulCurrent;
 
@@ -258,7 +270,7 @@ static portFORCE_INLINE uint32_t Atomic_Subtract_u32(uint32_t volatile * pulAdde
  *
  * @return *pulAddend value before increment.
  */
-static portFORCE_INLINE uint32_t Atomic_Increment_u32(uint32_t volatile * pulAddend)
+static portFORCE_INLINE uint32_t Atomic_Increment_u32( uint32_t volatile * pulAddend )
 {
     uint32_t ulCurrent;
 
@@ -283,7 +295,7 @@ static portFORCE_INLINE uint32_t Atomic_Increment_u32(uint32_t volatile * pulAdd
  *
  * @return *pulAddend value before decrement.
  */
-static portFORCE_INLINE uint32_t Atomic_Decrement_u32(uint32_t volatile * pulAddend)
+static portFORCE_INLINE uint32_t Atomic_Decrement_u32( uint32_t volatile * pulAddend )
 {
     uint32_t ulCurrent;
 
@@ -310,8 +322,8 @@ static portFORCE_INLINE uint32_t Atomic_Decrement_u32(uint32_t volatile * pulAdd
  *
  * @return The original value of *pulDestination.
  */
-static portFORCE_INLINE uint32_t Atomic_OR_u32(uint32_t volatile * pulDestination,
-        uint32_t ulValue)
+static portFORCE_INLINE uint32_t Atomic_OR_u32( uint32_t volatile * pulDestination,
+                                                uint32_t ulValue )
 {
     uint32_t ulCurrent;
 
@@ -337,8 +349,8 @@ static portFORCE_INLINE uint32_t Atomic_OR_u32(uint32_t volatile * pulDestinatio
  *
  * @return The original value of *pulDestination.
  */
-static portFORCE_INLINE uint32_t Atomic_AND_u32(uint32_t volatile * pulDestination,
-        uint32_t ulValue)
+static portFORCE_INLINE uint32_t Atomic_AND_u32( uint32_t volatile * pulDestination,
+                                                 uint32_t ulValue )
 {
     uint32_t ulCurrent;
 
@@ -364,15 +376,15 @@ static portFORCE_INLINE uint32_t Atomic_AND_u32(uint32_t volatile * pulDestinati
  *
  * @return The original value of *pulDestination.
  */
-static portFORCE_INLINE uint32_t Atomic_NAND_u32(uint32_t volatile * pulDestination,
-        uint32_t ulValue)
+static portFORCE_INLINE uint32_t Atomic_NAND_u32( uint32_t volatile * pulDestination,
+                                                  uint32_t ulValue )
 {
     uint32_t ulCurrent;
 
     ATOMIC_ENTER_CRITICAL();
     {
         ulCurrent = *pulDestination;
-        *pulDestination = ~(ulCurrent & ulValue);
+        *pulDestination = ~( ulCurrent & ulValue );
     }
     ATOMIC_EXIT_CRITICAL();
 
@@ -391,8 +403,8 @@ static portFORCE_INLINE uint32_t Atomic_NAND_u32(uint32_t volatile * pulDestinat
  *
  * @return The original value of *pulDestination.
  */
-static portFORCE_INLINE uint32_t Atomic_XOR_u32(uint32_t volatile * pulDestination,
-        uint32_t ulValue)
+static portFORCE_INLINE uint32_t Atomic_XOR_u32( uint32_t volatile * pulDestination,
+                                                 uint32_t ulValue )
 {
     uint32_t ulCurrent;
 

### external/FreeRTOS/Source/include/croutine.h
@@ -1,6 +1,6 @@
 /*
- * FreeRTOS Kernel V10.4.6
- * Copyright (C) 2021 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ * FreeRTOS Kernel V11.3.0
+ * Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -30,7 +30,7 @@
 #define CO_ROUTINE_H
 
 #ifndef INC_FREERTOS_H
-#error "include FreeRTOS.h must appear in source files before include croutine.h"
+    #error "include FreeRTOS.h must appear in source files before include croutine.h"
 #endif
 
 #include "list.h"
@@ -41,365 +41,371 @@
 #endif
 /* *INDENT-ON* */
 
-    /* Used to hide the implementation of the co-routine control block.  The
-     * control block structure however has to be included in the header due to
-     * the macro implementation of the co-routine functionality. */
-    typedef void * CoRoutineHandle_t;
+/* Used to hide the implementation of the co-routine control block.  The
+ * control block structure however has to be included in the header due to
+ * the macro implementation of the co-routine functionality. */
+typedef void * CoRoutineHandle_t;
 
-    /* Defines the prototype to which co-routine functions must conform. */
-    typedef void (* crCOROUTINE_CODE)(CoRoutineHandle_t,
-                                      UBaseType_t);
+/* Defines the prototype to which co-routine functions must conform. */
+typedef void (* crCOROUTINE_CODE)( CoRoutineHandle_t xHandle,
+                                   UBaseType_t uxIndex );
 
-    typedef struct corCoRoutineControlBlock {
-        crCOROUTINE_CODE pxCoRoutineFunction;
-        ListItem_t xGenericListItem; /*< List item used to place the CRCB in ready and blocked queues. */
-        ListItem_t xEventListItem;   /*< List item used to place the CRCB in event lists. */
-        UBaseType_t uxPriority;      /*< The priority of the co-routine in relation to other co-routines. */
-        UBaseType_t uxIndex;         /*< Used to distinguish between co-routines when multiple co-routines use the same co-routine function. */
-        uint16_t uxState;            /*< Used internally by the co-routine implementation. */
-    } CRCB_t;                        /* Co-routine control block.  Note must be identical in size down to uxPriority with TCB_t. */
+typedef struct corCoRoutineControlBlock
+{
+    crCOROUTINE_CODE pxCoRoutineFunction;
+    ListItem_t xGenericListItem; /**< List item used to place the CRCB in ready and blocked queues. */
+    ListItem_t xEventListItem;   /**< List item used to place the CRCB in event lists. */
+    UBaseType_t uxPriority;      /**< The priority of the co-routine in relation to other co-routines. */
+    UBaseType_t uxIndex;         /**< Used to distinguish between co-routines when multiple co-routines use the same co-routine function. */
+    uint16_t uxState;            /**< Used internally by the co-routine implementation. */
+} CRCB_t;                        /* Co-routine control block.  Note must be identical in size down to uxPriority with TCB_t. */
 
-    /**
-     * croutine. h
-     * @code{c}
-     * BaseType_t xCoRoutineCreate(
-     *                               crCOROUTINE_CODE pxCoRoutineCode,
-     *                               UBaseType_t uxPriority,
-     *                               UBaseType_t uxIndex
-     *                             );
-     * @endcode
-     *
-     * Create a new co-routine and add it to the list of co-routines that are
-     * ready to run.
-     *
-     * @param pxCoRoutineCode Pointer to the co-routine function.  Co-routine
-     * functions require special syntax - see the co-routine section of the WEB
-     * documentation for more information.
-     *
-     * @param uxPriority The priority with respect to other co-routines at which
-     *  the co-routine will run.
-     *
-     * @param uxIndex Used to distinguish between different co-routines that
-     * execute the same function.  See the example below and the co-routine section
-     * of the WEB documentation for further information.
-     *
-     * @return pdPASS if the co-routine was successfully created and added to a ready
-     * list, otherwise an error code defined with ProjDefs.h.
-     *
-     * Example usage:
-     * @code{c}
-     * // Co-routine to be created.
-     * void vFlashCoRoutine( CoRoutineHandle_t xHandle, UBaseType_t uxIndex )
-     * {
-     * // Variables in co-routines must be declared static if they must maintain value across a blocking call.
-     * // This may not be necessary for const variables.
-     * static const char cLedToFlash[ 2 ] = { 5, 6 };
-     * static const TickType_t uxFlashRates[ 2 ] = { 200, 400 };
-     *
-     *   // Must start every co-routine with a call to crSTART();
-     *   crSTART( xHandle );
-     *
-     *   for( ;; )
-     *   {
-     *       // This co-routine just delays for a fixed period, then toggles
-     *       // an LED.  Two co-routines are created using this function, so
-     *       // the uxIndex parameter is used to tell the co-routine which
-     *       // LED to flash and how int32_t to delay.  This assumes xQueue has
-     *       // already been created.
-     *       vParTestToggleLED( cLedToFlash[ uxIndex ] );
-     *       crDELAY( xHandle, uxFlashRates[ uxIndex ] );
-     *   }
-     *
-     *   // Must end every co-routine with a call to crEND();
-     *   crEND();
-     * }
-     *
-     * // Function that creates two co-routines.
-     * void vOtherFunction( void )
-     * {
-     * uint8_t ucParameterToPass;
-     * TaskHandle_t xHandle;
-     *
-     *   // Create two co-routines at priority 0.  The first is given index 0
-     *   // so (from the code above) toggles LED 5 every 200 ticks.  The second
-     *   // is given index 1 so toggles LED 6 every 400 ticks.
-     *   for( uxIndex = 0; uxIndex < 2; uxIndex++ )
-     *   {
-     *       xCoRoutineCreate( vFlashCoRoutine, 0, uxIndex );
-     *   }
-     * }
-     * @endcode
-     * \defgroup xCoRoutineCreate xCoRoutineCreate
-     * \ingroup Tasks
-     */
-    BaseType_t xCoRoutineCreate(crCOROUTINE_CODE pxCoRoutineCode,
-                                UBaseType_t uxPriority,
-                                UBaseType_t uxIndex);
+/**
+ * croutine. h
+ * @code{c}
+ * BaseType_t xCoRoutineCreate(
+ *                               crCOROUTINE_CODE pxCoRoutineCode,
+ *                               UBaseType_t uxPriority,
+ *                               UBaseType_t uxIndex
+ *                             );
+ * @endcode
+ *
+ * Create a new co-routine and add it to the list of co-routines that are
+ * ready to run.
+ *
+ * @param pxCoRoutineCode Pointer to the co-routine function.  Co-routine
+ * functions require special syntax - see the co-routine section of the WEB
+ * documentation for more information.
+ *
+ * @param uxPriority The priority with respect to other co-routines at which
+ *  the co-routine will run.
+ *
+ * @param uxIndex Used to distinguish between different co-routines that
+ * execute the same function.  See the example below and the co-routine section
+ * of the WEB documentation for further information.
+ *
+ * @return pdPASS if the co-routine was successfully created and added to a ready
+ * list, otherwise an error code defined with ProjDefs.h.
+ *
+ * Example usage:
+ * @code{c}
+ * // Co-routine to be created.
+ * void vFlashCoRoutine( CoRoutineHandle_t xHandle, UBaseType_t uxIndex )
+ * {
+ * // Variables in co-routines must be declared static if they must maintain value across a blocking call.
+ * // This may not be necessary for const variables.
+ * static const char cLedToFlash[ 2 ] = { 5, 6 };
+ * static const TickType_t uxFlashRates[ 2 ] = { 200, 400 };
+ *
+ *   // Must start every co-routine with a call to crSTART();
+ *   crSTART( xHandle );
+ *
+ *   for( ;; )
+ *   {
+ *       // This co-routine just delays for a fixed period, then toggles
+ *       // an LED.  Two co-routines are created using this function, so
+ *       // the uxIndex parameter is used to tell the co-routine which
+ *       // LED to flash and how int32_t to delay.  This assumes xQueue has
+ *       // already been created.
+ *       vParTestToggleLED( cLedToFlash[ uxIndex ] );
+ *       crDELAY( xHandle, uxFlashRates[ uxIndex ] );
+ *   }
+ *
+ *   // Must end every co-routine with a call to crEND();
+ *   crEND();
+ * }
+ *
+ * // Function that creates two co-routines.
+ * void vOtherFunction( void )
+ * {
+ * uint8_t ucParameterToPass;
+ * TaskHandle_t xHandle;
+ *
+ *   // Create two co-routines at priority 0.  The first is given index 0
+ *   // so (from the code above) toggles LED 5 every 200 ticks.  The second
+ *   // is given index 1 so toggles LED 6 every 400 ticks.
+ *   for( uxIndex = 0; uxIndex < 2; uxIndex++ )
+ *   {
+ *       xCoRoutineCreate( vFlashCoRoutine, 0, uxIndex );
+ *   }
+ * }
+ * @endcode
+ * \defgroup xCoRoutineCreate xCoRoutineCreate
+ * \ingroup Tasks
+ */
+BaseType_t xCoRoutineCreate( crCOROUTINE_CODE pxCoRoutineCode,
+                             UBaseType_t uxPriority,
+                             UBaseType_t uxIndex );
 
 
-    /**
-     * croutine. h
-     * @code{c}
-     * void vCoRoutineSchedule( void );
-     * @endcode
-     *
-     * Run a co-routine.
-     *
-     * vCoRoutineSchedule() executes the highest priority co-routine that is able
-     * to run.  The co-routine will execute until it either blocks, yields or is
-     * preempted by a task.  Co-routines execute cooperatively so one
-     * co-routine cannot be preempted by another, but can be preempted by a task.
-     *
-     * If an application comprises of both tasks and co-routines then
-     * vCoRoutineSchedule should be called from the idle task (in an idle task
-     * hook).
-     *
-     * Example usage:
-     * @code{c}
-     * // This idle task hook will schedule a co-routine each time it is called.
-     * // The rest of the idle task will execute between co-routine calls.
-     * void vApplicationIdleHook( void )
-     * {
-     *  vCoRoutineSchedule();
-     * }
-     *
-     * // Alternatively, if you do not require any other part of the idle task to
-     * // execute, the idle task hook can call vCoRoutineSchedule() within an
-     * // infinite loop.
-     * void vApplicationIdleHook( void )
-     * {
-     *  for( ;; )
-     *  {
-     *      vCoRoutineSchedule();
-     *  }
-     * }
-     * @endcode
-     * \defgroup vCoRoutineSchedule vCoRoutineSchedule
-     * \ingroup Tasks
-     */
-    void vCoRoutineSchedule(void);
+/**
+ * croutine. h
+ * @code{c}
+ * void vCoRoutineSchedule( void );
+ * @endcode
+ *
+ * Run a co-routine.
+ *
+ * vCoRoutineSchedule() executes the highest priority co-routine that is able
+ * to run.  The co-routine will execute until it either blocks, yields or is
+ * preempted by a task.  Co-routines execute cooperatively so one
+ * co-routine cannot be preempted by another, but can be preempted by a task.
+ *
+ * If an application comprises of both tasks and co-routines then
+ * vCoRoutineSchedule should be called from the idle task (in an idle task
+ * hook).
+ *
+ * Example usage:
+ * @code{c}
+ * // This idle task hook will schedule a co-routine each time it is called.
+ * // The rest of the idle task will execute between co-routine calls.
+ * void vApplicationIdleHook( void )
+ * {
+ *  vCoRoutineSchedule();
+ * }
+ *
+ * // Alternatively, if you do not require any other part of the idle task to
+ * // execute, the idle task hook can call vCoRoutineSchedule() within an
+ * // infinite loop.
+ * void vApplicationIdleHook( void )
+ * {
+ *  for( ;; )
+ *  {
+ *      vCoRoutineSchedule();
+ *  }
+ * }
+ * @endcode
+ * \defgroup vCoRoutineSchedule vCoRoutineSchedule
+ * \ingroup Tasks
+ */
+void vCoRoutineSchedule( void );
 
-    /**
-     * croutine. h
-     * @code{c}
-     * crSTART( CoRoutineHandle_t xHandle );
-     * @endcode
-     *
-     * This macro MUST always be called at the start of a co-routine function.
-     *
-     * Example usage:
-     * @code{c}
-     * // Co-routine to be created.
-     * void vACoRoutine( CoRoutineHandle_t xHandle, UBaseType_t uxIndex )
-     * {
-     * // Variables in co-routines must be declared static if they must maintain value across a blocking call.
-     * static int32_t ulAVariable;
-     *
-     *   // Must start every co-routine with a call to crSTART();
-     *   crSTART( xHandle );
-     *
-     *   for( ;; )
-     *   {
-     *        // Co-routine functionality goes here.
-     *   }
-     *
-     *   // Must end every co-routine with a call to crEND();
-     *   crEND();
-     * }
-     * @endcode
-     * \defgroup crSTART crSTART
-     * \ingroup Tasks
-     */
+/**
+ * croutine. h
+ * @code{c}
+ * crSTART( CoRoutineHandle_t xHandle );
+ * @endcode
+ *
+ * This macro MUST always be called at the start of a co-routine function.
+ *
+ * Example usage:
+ * @code{c}
+ * // Co-routine to be created.
+ * void vACoRoutine( CoRoutineHandle_t xHandle, UBaseType_t uxIndex )
+ * {
+ * // Variables in co-routines must be declared static if they must maintain value across a blocking call.
+ * static int32_t ulAVariable;
+ *
+ *   // Must start every co-routine with a call to crSTART();
+ *   crSTART( xHandle );
+ *
+ *   for( ;; )
+ *   {
+ *        // Co-routine functionality goes here.
+ *   }
+ *
+ *   // Must end every co-routine with a call to crEND();
+ *   crEND();
+ * }
+ * @endcode
+ * \defgroup crSTART crSTART
+ * \ingroup Tasks
+ */
 #define crSTART( pxCRCB )                            \
     switch( ( ( CRCB_t * ) ( pxCRCB ) )->uxState ) { \
         case 0:
 
-    /**
-     * croutine. h
-     * @code{c}
-     * crEND();
-     * @endcode
-     *
-     * This macro MUST always be called at the end of a co-routine function.
-     *
-     * Example usage:
-     * @code{c}
-     * // Co-routine to be created.
-     * void vACoRoutine( CoRoutineHandle_t xHandle, UBaseType_t uxIndex )
-     * {
-     * // Variables in co-routines must be declared static if they must maintain value across a blocking call.
-     * static int32_t ulAVariable;
-     *
-     *   // Must start every co-routine with a call to crSTART();
-     *   crSTART( xHandle );
-     *
-     *   for( ;; )
-     *   {
-     *        // Co-routine functionality goes here.
-     *   }
-     *
-     *   // Must end every co-routine with a call to crEND();
-     *   crEND();
-     * }
-     * @endcode
-     * \defgroup crSTART crSTART
-     * \ingroup Tasks
-     */
+/**
+ * croutine. h
+ * @code{c}
+ * crEND();
+ * @endcode
+ *
+ * This macro MUST always be called at the end of a co-routine function.
+ *
+ * Example usage:
+ * @code{c}
+ * // Co-routine to be created.
+ * void vACoRoutine( CoRoutineHandle_t xHandle, UBaseType_t uxIndex )
+ * {
+ * // Variables in co-routines must be declared static if they must maintain value across a blocking call.
+ * static int32_t ulAVariable;
+ *
+ *   // Must start every co-routine with a call to crSTART();
+ *   crSTART( xHandle );
+ *
+ *   for( ;; )
+ *   {
+ *        // Co-routine functionality goes here.
+ *   }
+ *
+ *   // Must end every co-routine with a call to crEND();
+ *   crEND();
+ * }
+ * @endcode
+ * \defgroup crSTART crSTART
+ * \ingroup Tasks
+ */
+
+/* *INDENT-OFF* */
 #define crEND()    }
+/* *INDENT-ON* */
 
-    /*
-     * These macros are intended for internal use by the co-routine implementation
-     * only.  The macros should not be used directly by application writers.
-     */
+/*
+ * These macros are intended for internal use by the co-routine implementation
+ * only.  The macros should not be used directly by application writers.
+ */
 #define crSET_STATE0( xHandle )                                       \
     ( ( CRCB_t * ) ( xHandle ) )->uxState = ( __LINE__ * 2 ); return; \
     case ( __LINE__ * 2 ):
 #define crSET_STATE1( xHandle )                                               \
     ( ( CRCB_t * ) ( xHandle ) )->uxState = ( ( __LINE__ * 2 ) + 1 ); return; \
     case ( ( __LINE__ * 2 ) + 1 ):
 
-    /**
-     * croutine. h
-     * @code{c}
-     * crDELAY( CoRoutineHandle_t xHandle, TickType_t xTicksToDelay );
-     * @endcode
-     *
-     * Delay a co-routine for a fixed period of time.
-     *
-     * crDELAY can only be called from the co-routine function itself - not
-     * from within a function called by the co-routine function.  This is because
-     * co-routines do not maintain their own stack.
-     *
-     * @param xHandle The handle of the co-routine to delay.  This is the xHandle
-     * parameter of the co-routine function.
-     *
-     * @param xTickToDelay The number of ticks that the co-routine should delay
-     * for.  The actual amount of time this equates to is defined by
-     * configTICK_RATE_HZ (set in FreeRTOSConfig.h).  The constant portTICK_PERIOD_MS
-     * can be used to convert ticks to milliseconds.
-     *
-     * Example usage:
-     * @code{c}
-     * // Co-routine to be created.
-     * void vACoRoutine( CoRoutineHandle_t xHandle, UBaseType_t uxIndex )
-     * {
-     * // Variables in co-routines must be declared static if they must maintain value across a blocking call.
-     * // This may not be necessary for const variables.
-     * // We are to delay for 200ms.
-     * static const xTickType xDelayTime = 200 / portTICK_PERIOD_MS;
-     *
-     *   // Must start every co-routine with a call to crSTART();
-     *   crSTART( xHandle );
-     *
-     *   for( ;; )
-     *   {
-     *      // Delay for 200ms.
-     *      crDELAY( xHandle, xDelayTime );
-     *
-     *      // Do something here.
-     *   }
-     *
-     *   // Must end every co-routine with a call to crEND();
-     *   crEND();
-     * }
-     * @endcode
-     * \defgroup crDELAY crDELAY
-     * \ingroup Tasks
-     */
-#define crDELAY( xHandle, xTicksToDelay )                      \
-    if( ( xTicksToDelay ) > 0 )                                \
-    {                                                          \
-        vCoRoutineAddToDelayedList( ( xTicksToDelay ), NULL ); \
-    }                                                          \
-    crSET_STATE0( ( xHandle ) );
+/**
+ * croutine. h
+ * @code{c}
+ * crDELAY( CoRoutineHandle_t xHandle, TickType_t xTicksToDelay );
+ * @endcode
+ *
+ * Delay a co-routine for a fixed period of time.
+ *
+ * crDELAY can only be called from the co-routine function itself - not
+ * from within a function called by the co-routine function.  This is because
+ * co-routines do not maintain their own stack.
+ *
+ * @param xHandle The handle of the co-routine to delay.  This is the xHandle
+ * parameter of the co-routine function.
+ *
+ * @param xTickToDelay The number of ticks that the co-routine should delay
+ * for.  The actual amount of time this equates to is defined by
+ * configTICK_RATE_HZ (set in FreeRTOSConfig.h).  The constant portTICK_PERIOD_MS
+ * can be used to convert ticks to milliseconds.
+ *
+ * Example usage:
+ * @code{c}
+ * // Co-routine to be created.
+ * void vACoRoutine( CoRoutineHandle_t xHandle, UBaseType_t uxIndex )
+ * {
+ * // Variables in co-routines must be declared static if they must maintain value across a blocking call.
+ * // This may not be necessary for const variables.
+ * // We are to delay for 200ms.
+ * static const xTickType xDelayTime = 200 / portTICK_PERIOD_MS;
+ *
+ *   // Must start every co-routine with a call to crSTART();
+ *   crSTART( xHandle );
+ *
+ *   for( ;; )
+ *   {
+ *      // Delay for 200ms.
+ *      crDELAY( xHandle, xDelayTime );
+ *
+ *      // Do something here.
+ *   }
+ *
+ *   // Must end every co-routine with a call to crEND();
+ *   crEND();
+ * }
+ * @endcode
+ * \defgroup crDELAY crDELAY
+ * \ingroup Tasks
+ */
+#define crDELAY( xHandle, xTicksToDelay )                          \
+    do {                                                           \
+        if( ( xTicksToDelay ) > 0 )                                \
+        {                                                          \
+            vCoRoutineAddToDelayedList( ( xTicksToDelay ), NULL ); \
+        }                                                          \
+        crSET_STATE0( ( xHandle ) );                               \
+    } while( 0 )
 
-    /**
-     * @code{c}
-     * crQUEUE_SEND(
-     *                CoRoutineHandle_t xHandle,
-     *                QueueHandle_t pxQueue,
-     *                void *pvItemToQueue,
-     *                TickType_t xTicksToWait,
-     *                BaseType_t *pxResult
-     *           )
-     * @endcode
-     *
-     * The macro's crQUEUE_SEND() and crQUEUE_RECEIVE() are the co-routine
-     * equivalent to the xQueueSend() and xQueueReceive() functions used by tasks.
-     *
-     * crQUEUE_SEND and crQUEUE_RECEIVE can only be used from a co-routine whereas
-     * xQueueSend() and xQueueReceive() can only be used from tasks.
-     *
-     * crQUEUE_SEND can only be called from the co-routine function itself - not
-     * from within a function called by the co-routine function.  This is because
-     * co-routines do not maintain their own stack.
-     *
-     * See the co-routine section of the WEB documentation for information on
-     * passing data between tasks and co-routines and between ISR's and
-     * co-routines.
-     *
-     * @param xHandle The handle of the calling co-routine.  This is the xHandle
-     * parameter of the co-routine function.
-     *
-     * @param pxQueue The handle of the queue on which the data will be posted.
-     * The handle is obtained as the return value when the queue is created using
-     * the xQueueCreate() API function.
-     *
-     * @param pvItemToQueue A pointer to the data being posted onto the queue.
-     * The number of bytes of each queued item is specified when the queue is
-     * created.  This number of bytes is copied from pvItemToQueue into the queue
-     * itself.
-     *
-     * @param xTickToDelay The number of ticks that the co-routine should block
-     * to wait for space to become available on the queue, should space not be
-     * available immediately. The actual amount of time this equates to is defined
-     * by configTICK_RATE_HZ (set in FreeRTOSConfig.h).  The constant
-     * portTICK_PERIOD_MS can be used to convert ticks to milliseconds (see example
-     * below).
-     *
-     * @param pxResult The variable pointed to by pxResult will be set to pdPASS if
-     * data was successfully posted onto the queue, otherwise it will be set to an
-     * error defined within ProjDefs.h.
-     *
-     * Example usage:
-     * @code{c}
-     * // Co-routine function that blocks for a fixed period then posts a number onto
-     * // a queue.
-     * static void prvCoRoutineFlashTask( CoRoutineHandle_t xHandle, UBaseType_t uxIndex )
-     * {
-     * // Variables in co-routines must be declared static if they must maintain value across a blocking call.
-     * static BaseType_t xNumberToPost = 0;
-     * static BaseType_t xResult;
-     *
-     *  // Co-routines must begin with a call to crSTART().
-     *  crSTART( xHandle );
-     *
-     *  for( ;; )
-     *  {
-     *      // This assumes the queue has already been created.
-     *      crQUEUE_SEND( xHandle, xCoRoutineQueue, &xNumberToPost, NO_DELAY, &xResult );
-     *
-     *      if( xResult != pdPASS )
-     *      {
-     *          // The message was not posted!
-     *      }
-     *
-     *      // Increment the number to be posted onto the queue.
-     *      xNumberToPost++;
-     *
-     *      // Delay for 100 ticks.
-     *      crDELAY( xHandle, 100 );
-     *  }
-     *
-     *  // Co-routines must end with a call to crEND().
-     *  crEND();
-     * }
-     * @endcode
-     * \defgroup crQUEUE_SEND crQUEUE_SEND
-     * \ingroup Tasks
-     */
+/**
+ * @code{c}
+ * crQUEUE_SEND(
+ *                CoRoutineHandle_t xHandle,
+ *                QueueHandle_t pxQueue,
+ *                void *pvItemToQueue,
+ *                TickType_t xTicksToWait,
+ *                BaseType_t *pxResult
+ *           )
+ * @endcode
+ *
+ * The macro's crQUEUE_SEND() and crQUEUE_RECEIVE() are the co-routine
+ * equivalent to the xQueueSend() and xQueueReceive() functions used by tasks.
+ *
+ * crQUEUE_SEND and crQUEUE_RECEIVE can only be used from a co-routine whereas
+ * xQueueSend() and xQueueReceive() can only be used from tasks.
+ *
+ * crQUEUE_SEND can only be called from the co-routine function itself - not
+ * from within a function called by the co-routine function.  This is because
+ * co-routines do not maintain their own stack.
+ *
+ * See the co-routine section of the WEB documentation for information on
+ * passing data between tasks and co-routines and between ISR's and
+ * co-routines.
+ *
+ * @param xHandle The handle of the calling co-routine.  This is the xHandle
+ * parameter of the co-routine function.
+ *
+ * @param pxQueue The handle of the queue on which the data will be posted.
+ * The handle is obtained as the return value when the queue is created using
+ * the xQueueCreate() API function.
+ *
+ * @param pvItemToQueue A pointer to the data being posted onto the queue.
+ * The number of bytes of each queued item is specified when the queue is
+ * created.  This number of bytes is copied from pvItemToQueue into the queue
+ * itself.
+ *
+ * @param xTickToDelay The number of ticks that the co-routine should block
+ * to wait for space to become available on the queue, should space not be
+ * available immediately. The actual amount of time this equates to is defined
+ * by configTICK_RATE_HZ (set in FreeRTOSConfig.h).  The constant
+ * portTICK_PERIOD_MS can be used to convert ticks to milliseconds (see example
+ * below).
+ *
+ * @param pxResult The variable pointed to by pxResult will be set to pdPASS if
+ * data was successfully posted onto the queue, otherwise it will be set to an
+ * error defined within ProjDefs.h.
+ *
+ * Example usage:
+ * @code{c}
+ * // Co-routine function that blocks for a fixed period then posts a number onto
+ * // a queue.
+ * static void prvCoRoutineFlashTask( CoRoutineHandle_t xHandle, UBaseType_t uxIndex )
+ * {
+ * // Variables in co-routines must be declared static if they must maintain value across a blocking call.
+ * static BaseType_t xNumberToPost = 0;
+ * static BaseType_t xResult;
+ *
+ *  // Co-routines must begin with a call to crSTART().
+ *  crSTART( xHandle );
+ *
+ *  for( ;; )
+ *  {
+ *      // This assumes the queue has already been created.
+ *      crQUEUE_SEND( xHandle, xCoRoutineQueue, &xNumberToPost, NO_DELAY, &xResult );
+ *
+ *      if( xResult != pdPASS )
+ *      {
+ *          // The message was not posted!
+ *      }
+ *
+ *      // Increment the number to be posted onto the queue.
+ *      xNumberToPost++;
+ *
+ *      // Delay for 100 ticks.
+ *      crDELAY( xHandle, 100 );
+ *  }
+ *
+ *  // Co-routines must end with a call to crEND().
+ *  crEND();
+ * }
+ * @endcode
+ * \defgroup crQUEUE_SEND crQUEUE_SEND
+ * \ingroup Tasks
+ */
 #define crQUEUE_SEND( xHandle, pxQueue, pvItemToQueue, xTicksToWait, pxResult )           \
-    {                                                                                     \
+    do {                                                                                  \
         *( pxResult ) = xQueueCRSend( ( pxQueue ), ( pvItemToQueue ), ( xTicksToWait ) ); \
         if( *( pxResult ) == errQUEUE_BLOCKED )                                           \
         {                                                                                 \
@@ -411,89 +417,89 @@
             crSET_STATE1( ( xHandle ) );                                                  \
             *pxResult = pdPASS;                                                           \
         }                                                                                 \
-    }
+    } while( 0 )
 
-    /**
-     * croutine. h
-     * @code{c}
-     * crQUEUE_RECEIVE(
-     *                   CoRoutineHandle_t xHandle,
-     *                   QueueHandle_t pxQueue,
-     *                   void *pvBuffer,
-     *                   TickType_t xTicksToWait,
-     *                   BaseType_t *pxResult
-     *               )
-     * @endcode
-     *
-     * The macro's crQUEUE_SEND() and crQUEUE_RECEIVE() are the co-routine
-     * equivalent to the xQueueSend() and xQueueReceive() functions used by tasks.
-     *
-     * crQUEUE_SEND and crQUEUE_RECEIVE can only be used from a co-routine whereas
-     * xQueueSend() and xQueueReceive() can only be used from tasks.
-     *
-     * crQUEUE_RECEIVE can only be called from the co-routine function itself - not
-     * from within a function called by the co-routine function.  This is because
-     * co-routines do not maintain their own stack.
-     *
-     * See the co-routine section of the WEB documentation for information on
-     * passing data between tasks and co-routines and between ISR's and
-     * co-routines.
-     *
-     * @param xHandle The handle of the calling co-routine.  This is the xHandle
-     * parameter of the co-routine function.
-     *
-     * @param pxQueue The handle of the queue from which the data will be received.
-     * The handle is obtained as the return value when the queue is created using
-     * the xQueueCreate() API function.
-     *
-     * @param pvBuffer The buffer into which the received item is to be copied.
-     * The number of bytes of each queued item is specified when the queue is
-     * created.  This number of bytes is copied into pvBuffer.
-     *
-     * @param xTickToDelay The number of ticks that the co-routine should block
-     * to wait for data to become available from the queue, should data not be
-     * available immediately. The actual amount of time this equates to is defined
-     * by configTICK_RATE_HZ (set in FreeRTOSConfig.h).  The constant
-     * portTICK_PERIOD_MS can be used to convert ticks to milliseconds (see the
-     * crQUEUE_SEND example).
-     *
-     * @param pxResult The variable pointed to by pxResult will be set to pdPASS if
-     * data was successfully retrieved from the queue, otherwise it will be set to
-     * an error code as defined within ProjDefs.h.
-     *
-     * Example usage:
-     * @code{c}
-     * // A co-routine receives the number of an LED to flash from a queue.  It
-     * // blocks on the queue until the number is received.
-     * static void prvCoRoutineFlashWorkTask( CoRoutineHandle_t xHandle, UBaseType_t uxIndex )
-     * {
-     * // Variables in co-routines must be declared static if they must maintain value across a blocking call.
-     * static BaseType_t xResult;
-     * static UBaseType_t uxLEDToFlash;
-     *
-     *  // All co-routines must start with a call to crSTART().
-     *  crSTART( xHandle );
-     *
-     *  for( ;; )
-     *  {
-     *      // Wait for data to become available on the queue.
-     *      crQUEUE_RECEIVE( xHandle, xCoRoutineQueue, &uxLEDToFlash, portMAX_DELAY, &xResult );
-     *
-     *      if( xResult == pdPASS )
-     *      {
-     *          // We received the LED to flash - flash it!
-     *          vParTestToggleLED( uxLEDToFlash );
-     *      }
-     *  }
-     *
-     *  crEND();
-     * }
-     * @endcode
-     * \defgroup crQUEUE_RECEIVE crQUEUE_RECEIVE
-     * \ingroup Tasks
-     */
+/**
+ * croutine. h
+ * @code{c}
+ * crQUEUE_RECEIVE(
+ *                   CoRoutineHandle_t xHandle,
+ *                   QueueHandle_t pxQueue,
+ *                   void *pvBuffer,
+ *                   TickType_t xTicksToWait,
+ *                   BaseType_t *pxResult
+ *               )
+ * @endcode
+ *
+ * The macro's crQUEUE_SEND() and crQUEUE_RECEIVE() are the co-routine
+ * equivalent to the xQueueSend() and xQueueReceive() functions used by tasks.
+ *
+ * crQUEUE_SEND and crQUEUE_RECEIVE can only be used from a co-routine whereas
+ * xQueueSend() and xQueueReceive() can only be used from tasks.
+ *
+ * crQUEUE_RECEIVE can only be called from the co-routine function itself - not
+ * from within a function called by the co-routine function.  This is because
+ * co-routines do not maintain their own stack.
+ *
+ * See the co-routine section of the WEB documentation for information on
+ * passing data between tasks and co-routines and between ISR's and
+ * co-routines.
+ *
+ * @param xHandle The handle of the calling co-routine.  This is the xHandle
+ * parameter of the co-routine function.
+ *
+ * @param pxQueue The handle of the queue from which the data will be received.
+ * The handle is obtained as the return value when the queue is created using
+ * the xQueueCreate() API function.
+ *
+ * @param pvBuffer The buffer into which the received item is to be copied.
+ * The number of bytes of each queued item is specified when the queue is
+ * created.  This number of bytes is copied into pvBuffer.
+ *
+ * @param xTickToDelay The number of ticks that the co-routine should block
+ * to wait for data to become available from the queue, should data not be
+ * available immediately. The actual amount of time this equates to is defined
+ * by configTICK_RATE_HZ (set in FreeRTOSConfig.h).  The constant
+ * portTICK_PERIOD_MS can be used to convert ticks to milliseconds (see the
+ * crQUEUE_SEND example).
+ *
+ * @param pxResult The variable pointed to by pxResult will be set to pdPASS if
+ * data was successfully retrieved from the queue, otherwise it will be set to
+ * an error code as defined within ProjDefs.h.
+ *
+ * Example usage:
+ * @code{c}
+ * // A co-routine receives the number of an LED to flash from a queue.  It
+ * // blocks on the queue until the number is received.
+ * static void prvCoRoutineFlashWorkTask( CoRoutineHandle_t xHandle, UBaseType_t uxIndex )
+ * {
+ * // Variables in co-routines must be declared static if they must maintain value across a blocking call.
+ * static BaseType_t xResult;
+ * static UBaseType_t uxLEDToFlash;
+ *
+ *  // All co-routines must start with a call to crSTART().
+ *  crSTART( xHandle );
+ *
+ *  for( ;; )
+ *  {
+ *      // Wait for data to become available on the queue.
+ *      crQUEUE_RECEIVE( xHandle, xCoRoutineQueue, &uxLEDToFlash, portMAX_DELAY, &xResult );
+ *
+ *      if( xResult == pdPASS )
+ *      {
+ *          // We received the LED to flash - flash it!
+ *          vParTestToggleLED( uxLEDToFlash );
+ *      }
+ *  }
+ *
+ *  crEND();
+ * }
+ * @endcode
+ * \defgroup crQUEUE_RECEIVE crQUEUE_RECEIVE
+ * \ingroup Tasks
+ */
 #define crQUEUE_RECEIVE( xHandle, pxQueue, pvBuffer, xTicksToWait, pxResult )           \
-    {                                                                                   \
+    do {                                                                                \
         *( pxResult ) = xQueueCRReceive( ( pxQueue ), ( pvBuffer ), ( xTicksToWait ) ); \
         if( *( pxResult ) == errQUEUE_BLOCKED )                                         \
         {                                                                               \
@@ -505,243 +511,250 @@
             crSET_STATE1( ( xHandle ) );                                                \
             *( pxResult ) = pdPASS;                                                     \
         }                                                                               \
-    }
+    } while( 0 )
 
-    /**
-     * croutine. h
-     * @code{c}
-     * crQUEUE_SEND_FROM_ISR(
-     *                          QueueHandle_t pxQueue,
-     *                          void *pvItemToQueue,
-     *                          BaseType_t xCoRoutinePreviouslyWoken
-     *                     )
-     * @endcode
-     *
-     * The macro's crQUEUE_SEND_FROM_ISR() and crQUEUE_RECEIVE_FROM_ISR() are the
-     * co-routine equivalent to the xQueueSendFromISR() and xQueueReceiveFromISR()
-     * functions used by tasks.
-     *
-     * crQUEUE_SEND_FROM_ISR() and crQUEUE_RECEIVE_FROM_ISR() can only be used to
-     * pass data between a co-routine and and ISR, whereas xQueueSendFromISR() and
-     * xQueueReceiveFromISR() can only be used to pass data between a task and and
-     * ISR.
-     *
-     * crQUEUE_SEND_FROM_ISR can only be called from an ISR to send data to a queue
-     * that is being used from within a co-routine.
-     *
-     * See the co-routine section of the WEB documentation for information on
-     * passing data between tasks and co-routines and between ISR's and
-     * co-routines.
-     *
-     * @param xQueue The handle to the queue on which the item is to be posted.
-     *
-     * @param pvItemToQueue A pointer to the item that is to be placed on the
-     * queue.  The size of the items the queue will hold was defined when the
-     * queue was created, so this many bytes will be copied from pvItemToQueue
-     * into the queue storage area.
-     *
-     * @param xCoRoutinePreviouslyWoken This is included so an ISR can post onto
-     * the same queue multiple times from a single interrupt.  The first call
-     * should always pass in pdFALSE.  Subsequent calls should pass in
-     * the value returned from the previous call.
-     *
-     * @return pdTRUE if a co-routine was woken by posting onto the queue.  This is
-     * used by the ISR to determine if a context switch may be required following
-     * the ISR.
-     *
-     * Example usage:
-     * @code{c}
-     * // A co-routine that blocks on a queue waiting for characters to be received.
-     * static void vReceivingCoRoutine( CoRoutineHandle_t xHandle, UBaseType_t uxIndex )
-     * {
-     * char cRxedChar;
-     * BaseType_t xResult;
-     *
-     *   // All co-routines must start with a call to crSTART().
-     *   crSTART( xHandle );
-     *
-     *   for( ;; )
-     *   {
-     *       // Wait for data to become available on the queue.  This assumes the
-     *       // queue xCommsRxQueue has already been created!
-     *       crQUEUE_RECEIVE( xHandle, xCommsRxQueue, &uxLEDToFlash, portMAX_DELAY, &xResult );
-     *
-     *       // Was a character received?
-     *       if( xResult == pdPASS )
-     *       {
-     *           // Process the character here.
-     *       }
-     *   }
-     *
-     *   // All co-routines must end with a call to crEND().
-     *   crEND();
-     * }
-     *
-     * // An ISR that uses a queue to send characters received on a serial port to
-     * // a co-routine.
-     * void vUART_ISR( void )
-     * {
-     * char cRxedChar;
-     * BaseType_t xCRWokenByPost = pdFALSE;
-     *
-     *   // We loop around reading characters until there are none left in the UART.
-     *   while( UART_RX_REG_NOT_EMPTY() )
-     *   {
-     *       // Obtain the character from the UART.
-     *       cRxedChar = UART_RX_REG;
-     *
-     *       // Post the character onto a queue.  xCRWokenByPost will be pdFALSE
-     *       // the first time around the loop.  If the post causes a co-routine
-     *       // to be woken (unblocked) then xCRWokenByPost will be set to pdTRUE.
-     *       // In this manner we can ensure that if more than one co-routine is
-     *       // blocked on the queue only one is woken by this ISR no matter how
-     *       // many characters are posted to the queue.
-     *       xCRWokenByPost = crQUEUE_SEND_FROM_ISR( xCommsRxQueue, &cRxedChar, xCRWokenByPost );
-     *   }
-     * }
-     * @endcode
-     * \defgroup crQUEUE_SEND_FROM_ISR crQUEUE_SEND_FROM_ISR
-     * \ingroup Tasks
-     */
+/**
+ * croutine. h
+ * @code{c}
+ * crQUEUE_SEND_FROM_ISR(
+ *                          QueueHandle_t pxQueue,
+ *                          void *pvItemToQueue,
+ *                          BaseType_t xCoRoutinePreviouslyWoken
+ *                     )
+ * @endcode
+ *
+ * The macro's crQUEUE_SEND_FROM_ISR() and crQUEUE_RECEIVE_FROM_ISR() are the
+ * co-routine equivalent to the xQueueSendFromISR() and xQueueReceiveFromISR()
+ * functions used by tasks.
+ *
+ * crQUEUE_SEND_FROM_ISR() and crQUEUE_RECEIVE_FROM_ISR() can only be used to
+ * pass data between a co-routine and and ISR, whereas xQueueSendFromISR() and
+ * xQueueReceiveFromISR() can only be used to pass data between a task and and
+ * ISR.
+ *
+ * crQUEUE_SEND_FROM_ISR can only be called from an ISR to send data to a queue
+ * that is being used from within a co-routine.
+ *
+ * See the co-routine section of the WEB documentation for information on
+ * passing data between tasks and co-routines and between ISR's and
+ * co-routines.
+ *
+ * @param xQueue The handle to the queue on which the item is to be posted.
+ *
+ * @param pvItemToQueue A pointer to the item that is to be placed on the
+ * queue.  The size of the items the queue will hold was defined when the
+ * queue was created, so this many bytes will be copied from pvItemToQueue
+ * into the queue storage area.
+ *
+ * @param xCoRoutinePreviouslyWoken This is included so an ISR can post onto
+ * the same queue multiple times from a single interrupt.  The first call
+ * should always pass in pdFALSE.  Subsequent calls should pass in
+ * the value returned from the previous call.
+ *
+ * @return pdTRUE if a co-routine was woken by posting onto the queue.  This is
+ * used by the ISR to determine if a context switch may be required following
+ * the ISR.
+ *
+ * Example usage:
+ * @code{c}
+ * // A co-routine that blocks on a queue waiting for characters to be received.
+ * static void vReceivingCoRoutine( CoRoutineHandle_t xHandle, UBaseType_t uxIndex )
+ * {
+ * char cRxedChar;
+ * BaseType_t xResult;
+ *
+ *   // All co-routines must start with a call to crSTART().
+ *   crSTART( xHandle );
+ *
+ *   for( ;; )
+ *   {
+ *       // Wait for data to become available on the queue.  This assumes the
+ *       // queue xCommsRxQueue has already been created!
+ *       crQUEUE_RECEIVE( xHandle, xCommsRxQueue, &uxLEDToFlash, portMAX_DELAY, &xResult );
+ *
+ *       // Was a character received?
+ *       if( xResult == pdPASS )
+ *       {
+ *           // Process the character here.
+ *       }
+ *   }
+ *
+ *   // All co-routines must end with a call to crEND().
+ *   crEND();
+ * }
+ *
+ * // An ISR that uses a queue to send characters received on a serial port to
+ * // a co-routine.
+ * void vUART_ISR( void )
+ * {
+ * char cRxedChar;
+ * BaseType_t xCRWokenByPost = pdFALSE;
+ *
+ *   // We loop around reading characters until there are none left in the UART.
+ *   while( UART_RX_REG_NOT_EMPTY() )
+ *   {
+ *       // Obtain the character from the UART.
+ *       cRxedChar = UART_RX_REG;
+ *
+ *       // Post the character onto a queue.  xCRWokenByPost will be pdFALSE
+ *       // the first time around the loop.  If the post causes a co-routine
+ *       // to be woken (unblocked) then xCRWokenByPost will be set to pdTRUE.
+ *       // In this manner we can ensure that if more than one co-routine is
+ *       // blocked on the queue only one is woken by this ISR no matter how
+ *       // many characters are posted to the queue.
+ *       xCRWokenByPost = crQUEUE_SEND_FROM_ISR( xCommsRxQueue, &cRxedChar, xCRWokenByPost );
+ *   }
+ * }
+ * @endcode
+ * \defgroup crQUEUE_SEND_FROM_ISR crQUEUE_SEND_FROM_ISR
+ * \ingroup Tasks
+ */
 #define crQUEUE_SEND_FROM_ISR( pxQueue, pvItemToQueue, xCoRoutinePreviouslyWoken ) \
     xQueueCRSendFromISR( ( pxQueue ), ( pvItemToQueue ), ( xCoRoutinePreviouslyWoken ) )
 
 
-    /**
-     * croutine. h
-     * @code{c}
-     * crQUEUE_SEND_FROM_ISR(
-     *                          QueueHandle_t pxQueue,
-     *                          void *pvBuffer,
-     *                          BaseType_t * pxCoRoutineWoken
-     *                     )
-     * @endcode
-     *
-     * The macro's crQUEUE_SEND_FROM_ISR() and crQUEUE_RECEIVE_FROM_ISR() are the
-     * co-routine equivalent to the xQueueSendFromISR() and xQueueReceiveFromISR()
-     * functions used by tasks.
-     *
-     * crQUEUE_SEND_FROM_ISR() and crQUEUE_RECEIVE_FROM_ISR() can only be used to
-     * pass data between a co-routine and and ISR, whereas xQueueSendFromISR() and
-     * xQueueReceiveFromISR() can only be used to pass data between a task and and
-     * ISR.
-     *
-     * crQUEUE_RECEIVE_FROM_ISR can only be called from an ISR to receive data
-     * from a queue that is being used from within a co-routine (a co-routine
-     * posted to the queue).
-     *
-     * See the co-routine section of the WEB documentation for information on
-     * passing data between tasks and co-routines and between ISR's and
-     * co-routines.
-     *
-     * @param xQueue The handle to the queue on which the item is to be posted.
-     *
-     * @param pvBuffer A pointer to a buffer into which the received item will be
-     * placed.  The size of the items the queue will hold was defined when the
-     * queue was created, so this many bytes will be copied from the queue into
-     * pvBuffer.
-     *
-     * @param pxCoRoutineWoken A co-routine may be blocked waiting for space to become
-     * available on the queue.  If crQUEUE_RECEIVE_FROM_ISR causes such a
-     * co-routine to unblock *pxCoRoutineWoken will get set to pdTRUE, otherwise
-     * *pxCoRoutineWoken will remain unchanged.
-     *
-     * @return pdTRUE an item was successfully received from the queue, otherwise
-     * pdFALSE.
-     *
-     * Example usage:
-     * @code{c}
-     * // A co-routine that posts a character to a queue then blocks for a fixed
-     * // period.  The character is incremented each time.
-     * static void vSendingCoRoutine( CoRoutineHandle_t xHandle, UBaseType_t uxIndex )
-     * {
-     * // cChar holds its value while this co-routine is blocked and must therefore
-     * // be declared static.
-     * static char cCharToTx = 'a';
-     * BaseType_t xResult;
-     *
-     *   // All co-routines must start with a call to crSTART().
-     *   crSTART( xHandle );
-     *
-     *   for( ;; )
-     *   {
-     *       // Send the next character to the queue.
-     *       crQUEUE_SEND( xHandle, xCoRoutineQueue, &cCharToTx, NO_DELAY, &xResult );
-     *
-     *       if( xResult == pdPASS )
-     *       {
-     *           // The character was successfully posted to the queue.
-     *       }
-     *       else
-     *       {
-     *          // Could not post the character to the queue.
-     *       }
-     *
-     *       // Enable the UART Tx interrupt to cause an interrupt in this
-     *       // hypothetical UART.  The interrupt will obtain the character
-     *       // from the queue and send it.
-     *       ENABLE_RX_INTERRUPT();
-     *
-     *       // Increment to the next character then block for a fixed period.
-     *       // cCharToTx will maintain its value across the delay as it is
-     *       // declared static.
-     *       cCharToTx++;
-     *       if( cCharToTx > 'x' )
-     *       {
-     *          cCharToTx = 'a';
-     *       }
-     *       crDELAY( 100 );
-     *   }
-     *
-     *   // All co-routines must end with a call to crEND().
-     *   crEND();
-     * }
-     *
-     * // An ISR that uses a queue to receive characters to send on a UART.
-     * void vUART_ISR( void )
-     * {
-     * char cCharToTx;
-     * BaseType_t xCRWokenByPost = pdFALSE;
-     *
-     *   while( UART_TX_REG_EMPTY() )
-     *   {
-     *       // Are there any characters in the queue waiting to be sent?
-     *       // xCRWokenByPost will automatically be set to pdTRUE if a co-routine
-     *       // is woken by the post - ensuring that only a single co-routine is
-     *       // woken no matter how many times we go around this loop.
-     *       if( crQUEUE_RECEIVE_FROM_ISR( pxQueue, &cCharToTx, &xCRWokenByPost ) )
-     *       {
-     *           SEND_CHARACTER( cCharToTx );
-     *       }
-     *   }
-     * }
-     * @endcode
-     * \defgroup crQUEUE_RECEIVE_FROM_ISR crQUEUE_RECEIVE_FROM_ISR
-     * \ingroup Tasks
-     */
+/**
+ * croutine. h
+ * @code{c}
+ * crQUEUE_SEND_FROM_ISR(
+ *                          QueueHandle_t pxQueue,
+ *                          void *pvBuffer,
+ *                          BaseType_t * pxCoRoutineWoken
+ *                     )
+ * @endcode
+ *
+ * The macro's crQUEUE_SEND_FROM_ISR() and crQUEUE_RECEIVE_FROM_ISR() are the
+ * co-routine equivalent to the xQueueSendFromISR() and xQueueReceiveFromISR()
+ * functions used by tasks.
+ *
+ * crQUEUE_SEND_FROM_ISR() and crQUEUE_RECEIVE_FROM_ISR() can only be used to
+ * pass data between a co-routine and and ISR, whereas xQueueSendFromISR() and
+ * xQueueReceiveFromISR() can only be used to pass data between a task and and
+ * ISR.
+ *
+ * crQUEUE_RECEIVE_FROM_ISR can only be called from an ISR to receive data
+ * from a queue that is being used from within a co-routine (a co-routine
+ * posted to the queue).
+ *
+ * See the co-routine section of the WEB documentation for information on
+ * passing data between tasks and co-routines and between ISR's and
+ * co-routines.
+ *
+ * @param xQueue The handle to the queue on which the item is to be posted.
+ *
+ * @param pvBuffer A pointer to a buffer into which the received item will be
+ * placed.  The size of the items the queue will hold was defined when the
+ * queue was created, so this many bytes will be copied from the queue into
+ * pvBuffer.
+ *
+ * @param pxCoRoutineWoken A co-routine may be blocked waiting for space to become
+ * available on the queue.  If crQUEUE_RECEIVE_FROM_ISR causes such a
+ * co-routine to unblock *pxCoRoutineWoken will get set to pdTRUE, otherwise
+ * *pxCoRoutineWoken will remain unchanged.
+ *
+ * @return pdTRUE an item was successfully received from the queue, otherwise
+ * pdFALSE.
+ *
+ * Example usage:
+ * @code{c}
+ * // A co-routine that posts a character to a queue then blocks for a fixed
+ * // period.  The character is incremented each time.
+ * static void vSendingCoRoutine( CoRoutineHandle_t xHandle, UBaseType_t uxIndex )
+ * {
+ * // cChar holds its value while this co-routine is blocked and must therefore
+ * // be declared static.
+ * static char cCharToTx = 'a';
+ * BaseType_t xResult;
+ *
+ *   // All co-routines must start with a call to crSTART().
+ *   crSTART( xHandle );
+ *
+ *   for( ;; )
+ *   {
+ *       // Send the next character to the queue.
+ *       crQUEUE_SEND( xHandle, xCoRoutineQueue, &cCharToTx, NO_DELAY, &xResult );
+ *
+ *       if( xResult == pdPASS )
+ *       {
+ *           // The character was successfully posted to the queue.
+ *       }
+ *       else
+ *       {
+ *          // Could not post the character to the queue.
+ *       }
+ *
+ *       // Enable the UART Tx interrupt to cause an interrupt in this
+ *       // hypothetical UART.  The interrupt will obtain the character
+ *       // from the queue and send it.
+ *       ENABLE_RX_INTERRUPT();
+ *
+ *       // Increment to the next character then block for a fixed period.
+ *       // cCharToTx will maintain its value across the delay as it is
+ *       // declared static.
+ *       cCharToTx++;
+ *       if( cCharToTx > 'x' )
+ *       {
+ *          cCharToTx = 'a';
+ *       }
+ *       crDELAY( 100 );
+ *   }
+ *
+ *   // All co-routines must end with a call to crEND().
+ *   crEND();
+ * }
+ *
+ * // An ISR that uses a queue to receive characters to send on a UART.
+ * void vUART_ISR( void )
+ * {
+ * char cCharToTx;
+ * BaseType_t xCRWokenByPost = pdFALSE;
+ *
+ *   while( UART_TX_REG_EMPTY() )
+ *   {
+ *       // Are there any characters in the queue waiting to be sent?
+ *       // xCRWokenByPost will automatically be set to pdTRUE if a co-routine
+ *       // is woken by the post - ensuring that only a single co-routine is
+ *       // woken no matter how many times we go around this loop.
+ *       if( crQUEUE_RECEIVE_FROM_ISR( pxQueue, &cCharToTx, &xCRWokenByPost ) )
+ *       {
+ *           SEND_CHARACTER( cCharToTx );
+ *       }
+ *   }
+ * }
+ * @endcode
+ * \defgroup crQUEUE_RECEIVE_FROM_ISR crQUEUE_RECEIVE_FROM_ISR
+ * \ingroup Tasks
+ */
 #define crQUEUE_RECEIVE_FROM_ISR( pxQueue, pvBuffer, pxCoRoutineWoken ) \
     xQueueCRReceiveFromISR( ( pxQueue ), ( pvBuffer ), ( pxCoRoutineWoken ) )
 
-    /*
-     * This function is intended for internal use by the co-routine macros only.
-     * The macro nature of the co-routine implementation requires that the
-     * prototype appears here.  The function should not be used by application
-     * writers.
-     *
-     * Removes the current co-routine from its ready list and places it in the
-     * appropriate delayed list.
-     */
-    void vCoRoutineAddToDelayedList(TickType_t xTicksToDelay,
-                                    List_t * pxEventList);
+/*
+ * This function is intended for internal use by the co-routine macros only.
+ * The macro nature of the co-routine implementation requires that the
+ * prototype appears here.  The function should not be used by application
+ * writers.
+ *
+ * Removes the current co-routine from its ready list and places it in the
+ * appropriate delayed list.
+ */
+void vCoRoutineAddToDelayedList( TickType_t xTicksToDelay,
+                                 List_t * pxEventList );
 
-    /*
-     * This function is intended for internal use by the queue implementation only.
-     * The function should not be used by application writers.
-     *
-     * Removes the highest priority co-routine from the event list and places it in
-     * the pending ready list.
-     */
-    BaseType_t xCoRoutineRemoveFromEventList(const List_t * pxEventList);
+/*
+ * This function is intended for internal use by the queue implementation only.
+ * The function should not be used by application writers.
+ *
+ * Removes the highest priority co-routine from the event list and places it in
+ * the pending ready list.
+ */
+BaseType_t xCoRoutineRemoveFromEventList( const List_t * pxEventList );
+
+
+/*
+ * This function resets the internal state of the coroutine module. It must be
+ * called by the application before restarting the scheduler.
+ */
+void vCoRoutineResetState( void ) PRIVILEGED_FUNCTION;
 
 /* *INDENT-OFF* */
 #ifdef __cplusplus

### external/FreeRTOS/Source/include/deprecated_definitions.h
@@ -1,6 +1,6 @@
 /*
- * FreeRTOS Kernel V10.4.6
- * Copyright (C) 2021 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ * FreeRTOS Kernel V11.3.0
+ * Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -40,242 +40,242 @@
  * projects should not use them. */
 
 #ifdef OPEN_WATCOM_INDUSTRIAL_PC_PORT
-#include "..\..\Source\portable\owatcom\16bitdos\pc\portmacro.h"
-typedef void (__interrupt __far * pxISR)();
+    #include "..\..\Source\portable\owatcom\16bitdos\pc\portmacro.h"
+    typedef void ( __interrupt __far * pxISR )();
 #endif
 
 #ifdef OPEN_WATCOM_FLASH_LITE_186_PORT
-#include "..\..\Source\portable\owatcom\16bitdos\flsh186\portmacro.h"
-typedef void (__interrupt __far * pxISR)();
+    #include "..\..\Source\portable\owatcom\16bitdos\flsh186\portmacro.h"
+    typedef void ( __interrupt __far * pxISR )();
 #endif
 
 #ifdef GCC_MEGA_AVR
-#include "../portable/GCC/ATMega323/portmacro.h"
+    #include "../portable/GCC/ATMega323/portmacro.h"
 #endif
 
 #ifdef IAR_MEGA_AVR
-#include "../portable/IAR/ATMega323/portmacro.h"
+    #include "../portable/IAR/ATMega323/portmacro.h"
 #endif
 
 #ifdef MPLAB_PIC24_PORT
-#include "../../Source/portable/MPLAB/PIC24_dsPIC/portmacro.h"
+    #include "../../Source/portable/MPLAB/PIC24_dsPIC/portmacro.h"
 #endif
 
 #ifdef MPLAB_DSPIC_PORT
-#include "../../Source/portable/MPLAB/PIC24_dsPIC/portmacro.h"
+    #include "../../Source/portable/MPLAB/PIC24_dsPIC/portmacro.h"
 #endif
 
 #ifdef MPLAB_PIC18F_PORT
-#include "../../Source/portable/MPLAB/PIC18F/portmacro.h"
+    #include "../../Source/portable/MPLAB/PIC18F/portmacro.h"
 #endif
 
 #ifdef MPLAB_PIC32MX_PORT
-#include "../../Source/portable/MPLAB/PIC32MX/portmacro.h"
+    #include "../../Source/portable/MPLAB/PIC32MX/portmacro.h"
 #endif
 
 #ifdef _FEDPICC
-#include "libFreeRTOS/Include/portmacro.h"
+    #include "libFreeRTOS/Include/portmacro.h"
 #endif
 
 #ifdef SDCC_CYGNAL
-#include "../../Source/portable/SDCC/Cygnal/portmacro.h"
+    #include "../../Source/portable/SDCC/Cygnal/portmacro.h"
 #endif
 
 #ifdef GCC_ARM7
-#include "../../Source/portable/GCC/ARM7_LPC2000/portmacro.h"
+    #include "../../Source/portable/GCC/ARM7_LPC2000/portmacro.h"
 #endif
 
 #ifdef GCC_ARM7_ECLIPSE
-#include "portmacro.h"
+    #include "portmacro.h"
 #endif
 
 #ifdef ROWLEY_LPC23xx
-#include "../../Source/portable/GCC/ARM7_LPC23xx/portmacro.h"
+    #include "../../Source/portable/GCC/ARM7_LPC23xx/portmacro.h"
 #endif
 
 #ifdef IAR_MSP430
-#include "..\..\Source\portable\IAR\MSP430\portmacro.h"
+    #include "..\..\Source\portable\IAR\MSP430\portmacro.h"
 #endif
 
 #ifdef GCC_MSP430
-#include "../../Source/portable/GCC/MSP430F449/portmacro.h"
+    #include "../../Source/portable/GCC/MSP430F449/portmacro.h"
 #endif
 
 #ifdef ROWLEY_MSP430
-#include "../../Source/portable/Rowley/MSP430F449/portmacro.h"
+    #include "../../Source/portable/Rowley/MSP430F449/portmacro.h"
 #endif
 
 #ifdef ARM7_LPC21xx_KEIL_RVDS
-#include "..\..\Source\portable\RVDS\ARM7_LPC21xx\portmacro.h"
+    #include "..\..\Source\portable\RVDS\ARM7_LPC21xx\portmacro.h"
 #endif
 
 #ifdef SAM7_GCC
-#include "../../Source/portable/GCC/ARM7_AT91SAM7S/portmacro.h"
+    #include "../../Source/portable/GCC/ARM7_AT91SAM7S/portmacro.h"
 #endif
 
 #ifdef SAM7_IAR
-#include "..\..\Source\portable\IAR\AtmelSAM7S64\portmacro.h"
+    #include "..\..\Source\portable\IAR\AtmelSAM7S64\portmacro.h"
 #endif
 
 #ifdef SAM9XE_IAR
-#include "..\..\Source\portable\IAR\AtmelSAM9XE\portmacro.h"
+    #include "..\..\Source\portable\IAR\AtmelSAM9XE\portmacro.h"
 #endif
 
 #ifdef LPC2000_IAR
-#include "..\..\Source\portable\IAR\LPC2000\portmacro.h"
+    #include "..\..\Source\portable\IAR\LPC2000\portmacro.h"
 #endif
 
 #ifdef STR71X_IAR
-#include "..\..\Source\portable\IAR\STR71x\portmacro.h"
+    #include "..\..\Source\portable\IAR\STR71x\portmacro.h"
 #endif
 
 #ifdef STR75X_IAR
-#include "..\..\Source\portable\IAR\STR75x\portmacro.h"
+    #include "..\..\Source\portable\IAR\STR75x\portmacro.h"
 #endif
 
 #ifdef STR75X_GCC
-#include "..\..\Source\portable\GCC\STR75x\portmacro.h"
+    #include "..\..\Source\portable\GCC\STR75x\portmacro.h"
 #endif
 
 #ifdef STR91X_IAR
-#include "..\..\Source\portable\IAR\STR91x\portmacro.h"
+    #include "..\..\Source\portable\IAR\STR91x\portmacro.h"
 #endif
 
 #ifdef GCC_H8S
-#include "../../Source/portable/GCC/H8S2329/portmacro.h"
+    #include "../../Source/portable/GCC/H8S2329/portmacro.h"
 #endif
 
 #ifdef GCC_AT91FR40008
-#include "../../Source/portable/GCC/ARM7_AT91FR40008/portmacro.h"
+    #include "../../Source/portable/GCC/ARM7_AT91FR40008/portmacro.h"
 #endif
 
 #ifdef RVDS_ARMCM3_LM3S102
-#include "../../Source/portable/RVDS/ARM_CM3/portmacro.h"
+    #include "../../Source/portable/RVDS/ARM_CM3/portmacro.h"
 #endif
 
 #ifdef GCC_ARMCM3_LM3S102
-#include "../../Source/portable/GCC/ARM_CM3/portmacro.h"
+    #include "../../Source/portable/GCC/ARM_CM3/portmacro.h"
 #endif
 
 #ifdef GCC_ARMCM3
-#include "../../Source/portable/GCC/ARM_CM3/portmacro.h"
+    #include "../../Source/portable/GCC/ARM_CM3/portmacro.h"
 #endif
 
 #ifdef IAR_ARM_CM3
-#include "../../Source/portable/IAR/ARM_CM3/portmacro.h"
+    #include "../../Source/portable/IAR/ARM_CM3/portmacro.h"
 #endif
 
 #ifdef IAR_ARMCM3_LM
-#include "../../Source/portable/IAR/ARM_CM3/portmacro.h"
+    #include "../../Source/portable/IAR/ARM_CM3/portmacro.h"
 #endif
 
 #ifdef HCS12_CODE_WARRIOR
-#include "../../Source/portable/CodeWarrior/HCS12/portmacro.h"
+    #include "../../Source/portable/CodeWarrior/HCS12/portmacro.h"
 #endif
 
 #ifdef MICROBLAZE_GCC
-#include "../../Source/portable/GCC/MicroBlaze/portmacro.h"
+    #include "../../Source/portable/GCC/MicroBlaze/portmacro.h"
 #endif
 
 #ifdef TERN_EE
-#include "..\..\Source\portable\Paradigm\Tern_EE\small\portmacro.h"
+    #include "..\..\Source\portable\Paradigm\Tern_EE\small\portmacro.h"
 #endif
 
 #ifdef GCC_HCS12
-#include "../../Source/portable/GCC/HCS12/portmacro.h"
+    #include "../../Source/portable/GCC/HCS12/portmacro.h"
 #endif
 
 #ifdef GCC_MCF5235
-#include "../../Source/portable/GCC/MCF5235/portmacro.h"
+    #include "../../Source/portable/GCC/MCF5235/portmacro.h"
 #endif
 
 #ifdef COLDFIRE_V2_GCC
-#include "../../../Source/portable/GCC/ColdFire_V2/portmacro.h"
+    #include "../../../Source/portable/GCC/ColdFire_V2/portmacro.h"
 #endif
 
 #ifdef COLDFIRE_V2_CODEWARRIOR
-#include "../../Source/portable/CodeWarrior/ColdFire_V2/portmacro.h"
+    #include "../../Source/portable/CodeWarrior/ColdFire_V2/portmacro.h"
 #endif
 
 #ifdef GCC_PPC405
-#include "../../Source/portable/GCC/PPC405_Xilinx/portmacro.h"
+    #include "../../Source/portable/GCC/PPC405_Xilinx/portmacro.h"
 #endif
 
 #ifdef GCC_PPC440
-#include "../../Source/portable/GCC/PPC440_Xilinx/portmacro.h"
+    #include "../../Source/portable/GCC/PPC440_Xilinx/portmacro.h"
 #endif
 
 #ifdef _16FX_SOFTUNE
-#include "..\..\Source\portable\Softune\MB96340\portmacro.h"
+    #include "..\..\Source\portable\Softune\MB96340\portmacro.h"
 #endif
 
 #ifdef BCC_INDUSTRIAL_PC_PORT
 
 /* A short file name has to be used in place of the normal
  * FreeRTOSConfig.h when using the Borland compiler. */
-#include "frconfig.h"
-#include "..\portable\BCC\16BitDOS\PC\prtmacro.h"
-typedef void (__interrupt __far * pxISR)();
+    #include "frconfig.h"
+    #include "..\portable\BCC\16BitDOS\PC\prtmacro.h"
+    typedef void ( __interrupt __far * pxISR )();
 #endif
 
 #ifdef BCC_FLASH_LITE_186_PORT
 
 /* A short file name has to be used in place of the normal
  * FreeRTOSConfig.h when using the Borland compiler. */
-#include "frconfig.h"
-#include "..\portable\BCC\16BitDOS\flsh186\prtmacro.h"
-typedef void (__interrupt __far * pxISR)();
+    #include "frconfig.h"
+    #include "..\portable\BCC\16BitDOS\flsh186\prtmacro.h"
+    typedef void ( __interrupt __far * pxISR )();
 #endif
 
 #ifdef __GNUC__
-#ifdef __AVR32_AVR32A__
-#include "portmacro.h"
-#endif
+    #ifdef __AVR32_AVR32A__
+        #include "portmacro.h"
+    #endif
 #endif
 
 #ifdef __ICCAVR32__
-#ifdef __CORE__
-#if __CORE__ == __AVR32A__
-#include "portmacro.h"
-#endif
-#endif
+    #ifdef __CORE__
+        #if __CORE__ == __AVR32A__
+            #include "portmacro.h"
+        #endif
+    #endif
 #endif
 
 #ifdef __91467D
-#include "portmacro.h"
+    #include "portmacro.h"
 #endif
 
 #ifdef __96340
-#include "portmacro.h"
+    #include "portmacro.h"
 #endif
 
 
 #ifdef __IAR_V850ES_Fx3__
-#include "../../Source/portable/IAR/V850ES/portmacro.h"
+    #include "../../Source/portable/IAR/V850ES/portmacro.h"
 #endif
 
 #ifdef __IAR_V850ES_Jx3__
-#include "../../Source/portable/IAR/V850ES/portmacro.h"
+    #include "../../Source/portable/IAR/V850ES/portmacro.h"
 #endif
 
 #ifdef __IAR_V850ES_Jx3_L__
-#include "../../Source/portable/IAR/V850ES/portmacro.h"
+    #include "../../Source/portable/IAR/V850ES/portmacro.h"
 #endif
 
 #ifdef __IAR_V850ES_Jx2__
-#include "../../Source/portable/IAR/V850ES/portmacro.h"
+    #include "../../Source/portable/IAR/V850ES/portmacro.h"
 #endif
 
 #ifdef __IAR_V850ES_Hx2__
-#include "../../Source/portable/IAR/V850ES/portmacro.h"
+    #include "../../Source/portable/IAR/V850ES/portmacro.h"
 #endif
 
 #ifdef __IAR_78K0R_Kx3__
-#include "../../Source/portable/IAR/78K0R/portmacro.h"
+    #include "../../Source/portable/IAR/78K0R/portmacro.h"
 #endif
 
 #ifdef __IAR_78K0R_Kx3L__
-#include "../../Source/portable/IAR/78K0R/portmacro.h"
+    #include "../../Source/portable/IAR/78K0R/portmacro.h"
 #endif
 
 #endif /* DEPRECATED_DEFINITIONS_H */

### external/FreeRTOS/Source/include/event_groups.h
@@ -1,6 +1,6 @@
 /*
- * FreeRTOS Kernel V10.4.6
- * Copyright (C) 2021 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ * FreeRTOS Kernel V11.3.0
+ * Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -30,742 +30,813 @@
 #define EVENT_GROUPS_H
 
 #ifndef INC_FREERTOS_H
-#error "include FreeRTOS.h" must appear in source files before "include event_groups.h"
+    #error "include FreeRTOS.h" must appear in source files before "include event_groups.h"
 #endif
 
 /* FreeRTOS includes. */
 #include "timers.h"
 
+/* The following bit fields convey control information in a task's event list
+ * item value.  It is important they don't clash with the
+ * taskEVENT_LIST_ITEM_VALUE_IN_USE definition. */
+#if ( configTICK_TYPE_WIDTH_IN_BITS == TICK_TYPE_WIDTH_16_BITS )
+    #define eventCLEAR_EVENTS_ON_EXIT_BIT    ( ( uint16_t ) 0x0100U )
+    #define eventUNBLOCKED_DUE_TO_BIT_SET    ( ( uint16_t ) 0x0200U )
+    #define eventWAIT_FOR_ALL_BITS           ( ( uint16_t ) 0x0400U )
+    #define eventEVENT_BITS_CONTROL_BYTES    ( ( uint16_t ) 0xff00U )
+#elif ( configTICK_TYPE_WIDTH_IN_BITS == TICK_TYPE_WIDTH_32_BITS )
+    #define eventCLEAR_EVENTS_ON_EXIT_BIT    ( ( uint32_t ) 0x01000000U )
+    #define eventUNBLOCKED_DUE_TO_BIT_SET    ( ( uint32_t ) 0x02000000U )
+    #define eventWAIT_FOR_ALL_BITS           ( ( uint32_t ) 0x04000000U )
+    #define eventEVENT_BITS_CONTROL_BYTES    ( ( uint32_t ) 0xff000000U )
+#elif ( configTICK_TYPE_WIDTH_IN_BITS == TICK_TYPE_WIDTH_64_BITS )
+    #define eventCLEAR_EVENTS_ON_EXIT_BIT    ( ( uint64_t ) 0x0100000000000000U )
+    #define eventUNBLOCKED_DUE_TO_BIT_SET    ( ( uint64_t ) 0x0200000000000000U )
+    #define eventWAIT_FOR_ALL_BITS           ( ( uint64_t ) 0x0400000000000000U )
+    #define eventEVENT_BITS_CONTROL_BYTES    ( ( uint64_t ) 0xff00000000000000U )
+#endif /* if ( configTICK_TYPE_WIDTH_IN_BITS == TICK_TYPE_WIDTH_16_BITS ) */
+
 /* *INDENT-OFF* */
 #ifdef __cplusplus
     extern "C" {
 #endif
 /* *INDENT-ON* */
 
-    /**
-     * An event group is a collection of bits to which an application can assign a
-     * meaning.  For example, an application may create an event group to convey
-     * the status of various CAN bus related events in which bit 0 might mean "A CAN
-     * message has been received and is ready for processing", bit 1 might mean "The
-     * application has queued a message that is ready for sending onto the CAN
-     * network", and bit 2 might mean "It is time to send a SYNC message onto the
-     * CAN network" etc.  A task can then test the bit values to see which events
-     * are active, and optionally enter the Blocked state to wait for a specified
-     * bit or a group of specified bits to be active.  To continue the CAN bus
-     * example, a CAN controlling task can enter the Blocked state (and therefore
-     * not consume any processing time) until either bit 0, bit 1 or bit 2 are
-     * active, at which time the bit that was actually active would inform the task
-     * which action it had to take (process a received message, send a message, or
-     * send a SYNC).
-     *
-     * The event groups implementation contains intelligence to avoid race
-     * conditions that would otherwise occur were an application to use a simple
-     * variable for the same purpose.  This is particularly important with respect
-     * to when a bit within an event group is to be cleared, and when bits have to
-     * be set and then tested atomically - as is the case where event groups are
-     * used to create a synchronisation point between multiple tasks (a
-     * 'rendezvous').
-     *
-     * \defgroup EventGroup
-     */
+/**
+ * An event group is a collection of bits to which an application can assign a
+ * meaning.  For example, an application may create an event group to convey
+ * the status of various CAN bus related events in which bit 0 might mean "A CAN
+ * message has been received and is ready for processing", bit 1 might mean "The
+ * application has queued a message that is ready for sending onto the CAN
+ * network", and bit 2 might mean "It is time to send a SYNC message onto the
+ * CAN network" etc.  A task can then test the bit values to see which events
+ * are active, and optionally enter the Blocked state to wait for a specified
+ * bit or a group of specified bits to be active.  To continue the CAN bus
+ * example, a CAN controlling task can enter the Blocked state (and therefore
+ * not consume any processing time) until either bit 0, bit 1 or bit 2 are
+ * active, at which time the bit that was actually active would inform the task
+ * which action it had to take (process a received message, send a message, or
+ * send a SYNC).
+ *
+ * The event groups implementation contains intelligence to avoid race
+ * conditions that would otherwise occur were an application to use a simple
+ * variable for the same purpose.  This is particularly important with respect
+ * to when a bit within an event group is to be cleared, and when bits have to
+ * be set and then tested atomically - as is the case where event groups are
+ * used to create a synchronisation point between multiple tasks (a
+ * 'rendezvous').
+ */
 
 
 
-    /**
-     * event_groups.h
-     *
-     * Type by which event groups are referenced.  For example, a call to
-     * xEventGroupCreate() returns an EventGroupHandle_t variable that can then
-     * be used as a parameter to other event group functions.
-     *
-     * \defgroup EventGroupHandle_t EventGroupHandle_t
-     * \ingroup EventGroup
-     */
-    struct EventGroupDef_t;
-    typedef struct EventGroupDef_t   * EventGroupHandle_t;
+/**
+ * event_groups.h
+ *
+ * Type by which event groups are referenced.  For example, a call to
+ * xEventGroupCreate() returns an EventGroupHandle_t variable that can then
+ * be used as a parameter to other event group functions.
+ *
+ * \defgroup EventGroupHandle_t EventGroupHandle_t
+ * \ingroup EventGroup
+ */
+struct EventGroupDef_t;
+typedef struct EventGroupDef_t   * EventGroupHandle_t;
 
-    /*
-     * The type that holds event bits always matches TickType_t - therefore the
-     * number of bits it holds is set by configUSE_16_BIT_TICKS (16 bits if set to 1,
-     * 32 bits if set to 0.
-     *
-     * \defgroup EventBits_t EventBits_t
-     * \ingroup EventGroup
-     */
-    typedef TickType_t               EventBits_t;
+/*
+ * The type that holds event bits always matches TickType_t - therefore the
+ * number of bits it holds is set by configTICK_TYPE_WIDTH_IN_BITS (16 bits if set to 0,
+ * 32 bits if set to 1, 64 bits if set to 2.
+ *
+ * \defgroup EventBits_t EventBits_t
+ * \ingroup EventGroup
+ */
+typedef TickType_t               EventBits_t;
 
-    /**
-     * event_groups.h
-     * @code{c}
-     * EventGroupHandle_t xEventGroupCreate( void );
-     * @endcode
-     *
-     * Create a new event group.
-     *
-     * Internally, within the FreeRTOS implementation, event groups use a [small]
-     * block of memory, in which the event group's structure is stored.  If an event
-     * groups is created using xEventGroupCreate() then the required memory is
-     * automatically dynamically allocated inside the xEventGroupCreate() function.
-     * (see https://www.FreeRTOS.org/a00111.html).  If an event group is created
-     * using xEventGroupCreateStatic() then the application writer must instead
-     * provide the memory that will get used by the event group.
-     * xEventGroupCreateStatic() therefore allows an event group to be created
-     * without using any dynamic memory allocation.
-     *
-     * Although event groups are not related to ticks, for internal implementation
-     * reasons the number of bits available for use in an event group is dependent
-     * on the configUSE_16_BIT_TICKS setting in FreeRTOSConfig.h.  If
-     * configUSE_16_BIT_TICKS is 1 then each event group contains 8 usable bits (bit
-     * 0 to bit 7).  If configUSE_16_BIT_TICKS is set to 0 then each event group has
-     * 24 usable bits (bit 0 to bit 23).  The EventBits_t type is used to store
-     * event bits within an event group.
-     *
-     * @return If the event group was created then a handle to the event group is
-     * returned.  If there was insufficient FreeRTOS heap available to create the
-     * event group then NULL is returned.  See https://www.FreeRTOS.org/a00111.html
-     *
-     * Example usage:
-     * @code{c}
-     *  // Declare a variable to hold the created event group.
-     *  EventGroupHandle_t xCreatedEventGroup;
-     *
-     *  // Attempt to create the event group.
-     *  xCreatedEventGroup = xEventGroupCreate();
-     *
-     *  // Was the event group created successfully?
-     *  if( xCreatedEventGroup == NULL )
-     *  {
-     *      // The event group was not created because there was insufficient
-     *      // FreeRTOS heap available.
-     *  }
-     *  else
-     *  {
-     *      // The event group was created.
-     *  }
-     * @endcode
-     * \defgroup xEventGroupCreate xEventGroupCreate
-     * \ingroup EventGroup
-     */
+/**
+ * event_groups.h
+ * @code{c}
+ * EventGroupHandle_t xEventGroupCreate( void );
+ * @endcode
+ *
+ * Create a new event group.
+ *
+ * Internally, within the FreeRTOS implementation, event groups use a [small]
+ * block of memory, in which the event group's structure is stored.  If an event
+ * groups is created using xEventGroupCreate() then the required memory is
+ * automatically dynamically allocated inside the xEventGroupCreate() function.
+ * (see https://www.FreeRTOS.org/a00111.html).  If an event group is created
+ * using xEventGroupCreateStatic() then the application writer must instead
+ * provide the memory that will get used by the event group.
+ * xEventGroupCreateStatic() therefore allows an event group to be created
+ * without using any dynamic memory allocation.
+ *
+ * Although event groups are not related to ticks, for internal implementation
+ * reasons the number of bits available for use in an event group is dependent
+ * on the configTICK_TYPE_WIDTH_IN_BITS setting in FreeRTOSConfig.h.  If
+ * configTICK_TYPE_WIDTH_IN_BITS is 0 then each event group contains 8 usable bits (bit
+ * 0 to bit 7).  If configTICK_TYPE_WIDTH_IN_BITS is set to 1 then each event group has
+ * 24 usable bits (bit 0 to bit 23).  If configTICK_TYPE_WIDTH_IN_BITS is set to 2 then
+ * each event group has 56 usable bits (bit 0 to bit 53). The EventBits_t type
+ * is used to store event bits within an event group.
+ *
+ * The configUSE_EVENT_GROUPS configuration constant must be set to 1 for xEventGroupCreate()
+ * to be available.
+ *
+ * @return If the event group was created then a handle to the event group is
+ * returned.  If there was insufficient FreeRTOS heap available to create the
+ * event group then NULL is returned.  See https://www.FreeRTOS.org/a00111.html
+ *
+ * Example usage:
+ * @code{c}
+ *  // Declare a variable to hold the created event group.
+ *  EventGroupHandle_t xCreatedEventGroup;
+ *
+ *  // Attempt to create the event group.
+ *  xCreatedEventGroup = xEventGroupCreate();
+ *
+ *  // Was the event group created successfully?
+ *  if( xCreatedEventGroup == NULL )
+ *  {
+ *      // The event group was not created because there was insufficient
+ *      // FreeRTOS heap available.
+ *  }
+ *  else
+ *  {
+ *      // The event group was created.
+ *  }
+ * @endcode
+ * \defgroup xEventGroupCreate xEventGroupCreate
+ * \ingroup EventGroup
+ */
 #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
-    EventGroupHandle_t xEventGroupCreate(void) PRIVILEGED_FUNCTION;
+    EventGroupHandle_t xEventGroupCreate( void ) PRIVILEGED_FUNCTION;
 #endif
 
-    /**
-     * event_groups.h
-     * @code{c}
-     * EventGroupHandle_t xEventGroupCreateStatic( EventGroupHandle_t * pxEventGroupBuffer );
-     * @endcode
-     *
-     * Create a new event group.
-     *
-     * Internally, within the FreeRTOS implementation, event groups use a [small]
-     * block of memory, in which the event group's structure is stored.  If an event
-     * groups is created using xEventGroupCreate() then the required memory is
-     * automatically dynamically allocated inside the xEventGroupCreate() function.
-     * (see https://www.FreeRTOS.org/a00111.html).  If an event group is created
-     * using xEventGroupCreateStatic() then the application writer must instead
-     * provide the memory that will get used by the event group.
-     * xEventGroupCreateStatic() therefore allows an event group to be created
-     * without using any dynamic memory allocation.
-     *
-     * Although event groups are not related to ticks, for internal implementation
-     * reasons the number of bits available for use in an event group is dependent
-     * on the configUSE_16_BIT_TICKS setting in FreeRTOSConfig.h.  If
-     * configUSE_16_BIT_TICKS is 1 then each event group contains 8 usable bits (bit
-     * 0 to bit 7).  If configUSE_16_BIT_TICKS is set to 0 then each event group has
-     * 24 usable bits (bit 0 to bit 23).  The EventBits_t type is used to store
-     * event bits within an event group.
-     *
-     * @param pxEventGroupBuffer pxEventGroupBuffer must point to a variable of type
-     * StaticEventGroup_t, which will be then be used to hold the event group's data
-     * structures, removing the need for the memory to be allocated dynamically.
-     *
-     * @return If the event group was created then a handle to the event group is
-     * returned.  If pxEventGroupBuffer was NULL then NULL is returned.
-     *
-     * Example usage:
-     * @code{c}
-     *  // StaticEventGroup_t is a publicly accessible structure that has the same
-     *  // size and alignment requirements as the real event group structure.  It is
-     *  // provided as a mechanism for applications to know the size of the event
-     *  // group (which is dependent on the architecture and configuration file
-     *  // settings) without breaking the strict data hiding policy by exposing the
-     *  // real event group internals.  This StaticEventGroup_t variable is passed
-     *  // into the xSemaphoreCreateEventGroupStatic() function and is used to store
-     *  // the event group's data structures
-     *  StaticEventGroup_t xEventGroupBuffer;
-     *
-     *  // Create the event group without dynamically allocating any memory.
-     *  xEventGroup = xEventGroupCreateStatic( &xEventGroupBuffer );
-     * @endcode
-     */
+/**
+ * event_groups.h
+ * @code{c}
+ * EventGroupHandle_t xEventGroupCreateStatic( EventGroupHandle_t * pxEventGroupBuffer );
+ * @endcode
+ *
+ * Create a new event group.
+ *
+ * Internally, within the FreeRTOS implementation, event groups use a [small]
+ * block of memory, in which the event group's structure is stored.  If an event
+ * groups is created using xEventGroupCreate() then the required memory is
+ * automatically dynamically allocated inside the xEventGroupCreate() function.
+ * (see https://www.FreeRTOS.org/a00111.html).  If an event group is created
+ * using xEventGroupCreateStatic() then the application writer must instead
+ * provide the memory that will get used by the event group.
+ * xEventGroupCreateStatic() therefore allows an event group to be created
+ * without using any dynamic memory allocation.
+ *
+ * Although event groups are not related to ticks, for internal implementation
+ * reasons the number of bits available for use in an event group is dependent
+ * on the configTICK_TYPE_WIDTH_IN_BITS setting in FreeRTOSConfig.h.  If
+ * configTICK_TYPE_WIDTH_IN_BITS is 0 then each event group contains 8 usable bits (bit
+ * 0 to bit 7).  If configTICK_TYPE_WIDTH_IN_BITS is set to 1 then each event group has
+ * 24 usable bits (bit 0 to bit 23).  If configTICK_TYPE_WIDTH_IN_BITS is set to 2 then
+ * each event group has 56 usable bits (bit 0 to bit 53).  The EventBits_t type
+ * is used to store event bits within an event group.
+ *
+ * The configUSE_EVENT_GROUPS configuration constant must be set to 1 for xEventGroupCreateStatic()
+ * to be available.
+ *
+ * @param pxEventGroupBuffer pxEventGroupBuffer must point to a variable of type
+ * StaticEventGroup_t, which will be then be used to hold the event group's data
+ * structures, removing the need for the memory to be allocated dynamically.
+ *
+ * @return If the event group was created then a handle to the event group is
+ * returned.  If pxEventGroupBuffer was NULL then NULL is returned.
+ *
+ * Example usage:
+ * @code{c}
+ *  // StaticEventGroup_t is a publicly accessible structure that has the same
+ *  // size and alignment requirements as the real event group structure.  It is
+ *  // provided as a mechanism for applications to know the size of the event
+ *  // group (which is dependent on the architecture and configuration file
+ *  // settings) without breaking the strict data hiding policy by exposing the
+ *  // real event group internals.  This StaticEventGroup_t variable is passed
+ *  // into the xSemaphoreCreateEventGroupStatic() function and is used to store
+ *  // the event group's data structures
+ *  StaticEventGroup_t xEventGroupBuffer;
+ *
+ *  // Create the event group without dynamically allocating any memory.
+ *  xEventGroup = xEventGroupCreateStatic( &xEventGroupBuffer );
+ * @endcode
+ */
 #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
-    EventGroupHandle_t xEventGroupCreateStatic(StaticEventGroup_t * pxEventGroupBuffer) PRIVILEGED_FUNCTION;
+    EventGroupHandle_t xEventGroupCreateStatic( StaticEventGroup_t * pxEventGroupBuffer ) PRIVILEGED_FUNCTION;
 #endif
 
-    /**
-     * event_groups.h
-     * @code{c}
-     *  EventBits_t xEventGroupWaitBits(    EventGroupHandle_t xEventGroup,
-     *                                      const EventBits_t uxBitsToWaitFor,
-     *                                      const BaseType_t xClearOnExit,
-     *                                      const BaseType_t xWaitForAllBits,
-     *                                      const TickType_t xTicksToWait );
-     * @endcode
-     *
-     * [Potentially] block to wait for one or more bits to be set within a
-     * previously created event group.
-     *
-     * This function cannot be called from an interrupt.
-     *
-     * @param xEventGroup The event group in which the bits are being tested.  The
-     * event group must have previously been created using a call to
-     * xEventGroupCreate().
-     *
-     * @param uxBitsToWaitFor A bitwise value that indicates the bit or bits to test
-     * inside the event group.  For example, to wait for bit 0 and/or bit 2 set
-     * uxBitsToWaitFor to 0x05.  To wait for bits 0 and/or bit 1 and/or bit 2 set
-     * uxBitsToWaitFor to 0x07.  Etc.
-     *
-     * @param xClearOnExit If xClearOnExit is set to pdTRUE then any bits within
-     * uxBitsToWaitFor that are set within the event group will be cleared before
-     * xEventGroupWaitBits() returns if the wait condition was met (if the function
-     * returns for a reason other than a timeout).  If xClearOnExit is set to
-     * pdFALSE then the bits set in the event group are not altered when the call to
-     * xEventGroupWaitBits() returns.
-     *
-     * @param xWaitForAllBits If xWaitForAllBits is set to pdTRUE then
-     * xEventGroupWaitBits() will return when either all the bits in uxBitsToWaitFor
-     * are set or the specified block time expires.  If xWaitForAllBits is set to
-     * pdFALSE then xEventGroupWaitBits() will return when any one of the bits set
-     * in uxBitsToWaitFor is set or the specified block time expires.  The block
-     * time is specified by the xTicksToWait parameter.
-     *
-     * @param xTicksToWait The maximum amount of time (specified in 'ticks') to wait
-     * for one/all (depending on the xWaitForAllBits value) of the bits specified by
-     * uxBitsToWaitFor to become set.
-     *
-     * @return The value of the event group at the time either the bits being waited
-     * for became set, or the block time expired.  Test the return value to know
-     * which bits were set.  If xEventGroupWaitBits() returned because its timeout
-     * expired then not all the bits being waited for will be set.  If
-     * xEventGroupWaitBits() returned because the bits it was waiting for were set
-     * then the returned value is the event group value before any bits were
-     * automatically cleared in the case that xClearOnExit parameter was set to
-     * pdTRUE.
-     *
-     * Example usage:
-     * @code{c}
-     * #define BIT_0 ( 1 << 0 )
-     * #define BIT_4 ( 1 << 4 )
-     *
-     * void aFunction( EventGroupHandle_t xEventGroup )
-     * {
-     * EventBits_t uxBits;
-     * const TickType_t xTicksToWait = 100 / portTICK_PERIOD_MS;
-     *
-     *      // Wait a maximum of 100ms for either bit 0 or bit 4 to be set within
-     *      // the event group.  Clear the bits before exiting.
-     *      uxBits = xEventGroupWaitBits(
-     *                  xEventGroup,    // The event group being tested.
-     *                  BIT_0 | BIT_4,  // The bits within the event group to wait for.
-     *                  pdTRUE,         // BIT_0 and BIT_4 should be cleared before returning.
-     *                  pdFALSE,        // Don't wait for both bits, either bit will do.
-     *                  xTicksToWait ); // Wait a maximum of 100ms for either bit to be set.
-     *
-     *      if( ( uxBits & ( BIT_0 | BIT_4 ) ) == ( BIT_0 | BIT_4 ) )
-     *      {
-     *          // xEventGroupWaitBits() returned because both bits were set.
-     *      }
-     *      else if( ( uxBits & BIT_0 ) != 0 )
-     *      {
-     *          // xEventGroupWaitBits() returned because just BIT_0 was set.
-     *      }
-     *      else if( ( uxBits & BIT_4 ) != 0 )
-     *      {
-     *          // xEventGroupWaitBits() returned because just BIT_4 was set.
-     *      }
-     *      else
-     *      {
-     *          // xEventGroupWaitBits() returned because xTicksToWait ticks passed
-     *          // without either BIT_0 or BIT_4 becoming set.
-     *      }
-     * }
-     * @endcode
-     * \defgroup xEventGroupWaitBits xEventGroupWaitBits
-     * \ingroup EventGroup
-     */
-    EventBits_t xEventGroupWaitBits(EventGroupHandle_t xEventGroup,
-                                    const EventBits_t uxBitsToWaitFor,
-                                    const BaseType_t xClearOnExit,
-                                    const BaseType_t xWaitForAllBits,
-                                    TickType_t xTicksToWait) PRIVILEGED_FUNCTION;
+/**
+ * event_groups.h
+ * @code{c}
+ *  EventBits_t xEventGroupWaitBits(    EventGroupHandle_t xEventGroup,
+ *                                      const EventBits_t uxBitsToWaitFor,
+ *                                      const BaseType_t xClearOnExit,
+ *                                      const BaseType_t xWaitForAllBits,
+ *                                      const TickType_t xTicksToWait );
+ * @endcode
+ *
+ * [Potentially] block to wait for one or more bits to be set within a
+ * previously created event group.
+ *
+ * This function cannot be called from an interrupt.
+ *
+ * The configUSE_EVENT_GROUPS configuration constant must be set to 1 for xEventGroupWaitBits()
+ * to be available.
+ *
+ * @param xEventGroup The event group in which the bits are being tested.  The
+ * event group must have previously been created using a call to
+ * xEventGroupCreate().
+ *
+ * @param uxBitsToWaitFor A bitwise value that indicates the bit or bits to test
+ * inside the event group.  For example, to wait for bit 0 and/or bit 2 set
+ * uxBitsToWaitFor to 0x05.  To wait for bits 0 and/or bit 1 and/or bit 2 set
+ * uxBitsToWaitFor to 0x07.  Etc.
+ *
+ * @param xClearOnExit If xClearOnExit is set to pdTRUE then any bits within
+ * uxBitsToWaitFor that are set within the event group will be cleared before
+ * xEventGroupWaitBits() returns if the wait condition was met (if the function
+ * returns for a reason other than a timeout).  If xClearOnExit is set to
+ * pdFALSE then the bits set in the event group are not altered when the call to
+ * xEventGroupWaitBits() returns.
+ *
+ * @param xWaitForAllBits If xWaitForAllBits is set to pdTRUE then
+ * xEventGroupWaitBits() will return when either all the bits in uxBitsToWaitFor
+ * are set or the specified block time expires.  If xWaitForAllBits is set to
+ * pdFALSE then xEventGroupWaitBits() will return when any one of the bits set
+ * in uxBitsToWaitFor is set or the specified block time expires.  The block
+ * time is specified by the xTicksToWait parameter.
+ *
+ * @param xTicksToWait The maximum amount of time (specified in 'ticks') to wait
+ * for one/all (depending on the xWaitForAllBits value) of the bits specified by
+ * uxBitsToWaitFor to become set. A value of portMAX_DELAY can be used to block
+ * indefinitely (provided INCLUDE_vTaskSuspend is set to 1 in FreeRTOSConfig.h).
+ *
+ * @return The value of the event group at the time either the bits being waited
+ * for became set, or the block time expired.  Test the return value to know
+ * which bits were set.  If xEventGroupWaitBits() returned because its timeout
+ * expired then not all the bits being waited for will be set.  If
+ * xEventGroupWaitBits() returned because the bits it was waiting for were set
+ * then the returned value is the event group value before any bits were
+ * automatically cleared in the case that xClearOnExit parameter was set to
+ * pdTRUE.
+ *
+ * Example usage:
+ * @code{c}
+ * #define BIT_0 ( 1 << 0 )
+ * #define BIT_4 ( 1 << 4 )
+ *
+ * void aFunction( EventGroupHandle_t xEventGroup )
+ * {
+ * EventBits_t uxBits;
+ * const TickType_t xTicksToWait = 100 / portTICK_PERIOD_MS;
+ *
+ *      // Wait a maximum of 100ms for either bit 0 or bit 4 to be set within
+ *      // the event group.  Clear the bits before exiting.
+ *      uxBits = xEventGroupWaitBits(
+ *                  xEventGroup,    // The event group being tested.
+ *                  BIT_0 | BIT_4,  // The bits within the event group to wait for.
+ *                  pdTRUE,         // BIT_0 and BIT_4 should be cleared before returning.
+ *                  pdFALSE,        // Don't wait for both bits, either bit will do.
+ *                  xTicksToWait ); // Wait a maximum of 100ms for either bit to be set.
+ *
+ *      if( ( uxBits & ( BIT_0 | BIT_4 ) ) == ( BIT_0 | BIT_4 ) )
+ *      {
+ *          // xEventGroupWaitBits() returned because both bits were set.
+ *      }
+ *      else if( ( uxBits & BIT_0 ) != 0 )
+ *      {
+ *          // xEventGroupWaitBits() returned because just BIT_0 was set.
+ *      }
+ *      else if( ( uxBits & BIT_4 ) != 0 )
+ *      {
+ *          // xEventGroupWaitBits() returned because just BIT_4 was set.
+ *      }
+ *      else
+ *      {
+ *          // xEventGroupWaitBits() returned because xTicksToWait ticks passed
+ *          // without either BIT_0 or BIT_4 becoming set.
+ *      }
+ * }
+ * @endcode
+ * \defgroup xEventGroupWaitBits xEventGroupWaitBits
+ * \ingroup EventGroup
+ */
+EventBits_t xEventGroupWaitBits( EventGroupHandle_t xEventGroup,
+                                 const EventBits_t uxBitsToWaitFor,
+                                 const BaseType_t xClearOnExit,
+                                 const BaseType_t xWaitForAllBits,
+                                 TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
 
-    /**
-     * event_groups.h
-     * @code{c}
-     *  EventBits_t xEventGroupClearBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear );
-     * @endcode
-     *
-     * Clear bits within an event group.  This function cannot be called from an
-     * interrupt.
-     *
-     * @param xEventGroup The event group in which the bits are to be cleared.
-     *
-     * @param uxBitsToClear A bitwise value that indicates the bit or bits to clear
-     * in the event group.  For example, to clear bit 3 only, set uxBitsToClear to
-     * 0x08.  To clear bit 3 and bit 0 set uxBitsToClear to 0x09.
-     *
-     * @return The value of the event group before the specified bits were cleared.
-     *
-     * Example usage:
-     * @code{c}
-     * #define BIT_0 ( 1 << 0 )
-     * #define BIT_4 ( 1 << 4 )
-     *
-     * void aFunction( EventGroupHandle_t xEventGroup )
-     * {
-     * EventBits_t uxBits;
-     *
-     *      // Clear bit 0 and bit 4 in xEventGroup.
-     *      uxBits = xEventGroupClearBits(
-     *                              xEventGroup,    // The event group being updated.
-     *                              BIT_0 | BIT_4 );// The bits being cleared.
-     *
-     *      if( ( uxBits & ( BIT_0 | BIT_4 ) ) == ( BIT_0 | BIT_4 ) )
-     *      {
-     *          // Both bit 0 and bit 4 were set before xEventGroupClearBits() was
-     *          // called.  Both will now be clear (not set).
-     *      }
-     *      else if( ( uxBits & BIT_0 ) != 0 )
-     *      {
-     *          // Bit 0 was set before xEventGroupClearBits() was called.  It will
-     *          // now be clear.
-     *      }
-     *      else if( ( uxBits & BIT_4 ) != 0 )
-     *      {
-     *          // Bit 4 was set before xEventGroupClearBits() was called.  It will
-     *          // now be clear.
-     *      }
-     *      else
-     *      {
-     *          // Neither bit 0 nor bit 4 were set in the first place.
-     *      }
-     * }
-     * @endcode
-     * \defgroup xEventGroupClearBits xEventGroupClearBits
-     * \ingroup EventGroup
-     */
-    EventBits_t xEventGroupClearBits(EventGroupHandle_t xEventGroup,
-                                     const EventBits_t uxBitsToClear) PRIVILEGED_FUNCTION;
+/**
+ * event_groups.h
+ * @code{c}
+ *  EventBits_t xEventGroupClearBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear );
+ * @endcode
+ *
+ * Clear bits within an event group.  This function cannot be called from an
+ * interrupt.
+ *
+ * The configUSE_EVENT_GROUPS configuration constant must be set to 1 for xEventGroupClearBits()
+ * to be available.
+ *
+ * @param xEventGroup The event group in which the bits are to be cleared.
+ *
+ * @param uxBitsToClear A bitwise value that indicates the bit or bits to clear
+ * in the event group.  For example, to clear bit 3 only, set uxBitsToClear to
+ * 0x08.  To clear bit 3 and bit 0 set uxBitsToClear to 0x09.
+ *
+ * @return The value of the event group before the specified bits were cleared.
+ *
+ * Example usage:
+ * @code{c}
+ * #define BIT_0 ( 1 << 0 )
+ * #define BIT_4 ( 1 << 4 )
+ *
+ * void aFunction( EventGroupHandle_t xEventGroup )
+ * {
+ * EventBits_t uxBits;
+ *
+ *      // Clear bit 0 and bit 4 in xEventGroup.
+ *      uxBits = xEventGroupClearBits(
+ *                              xEventGroup,    // The event group being updated.
+ *                              BIT_0 | BIT_4 );// The bits being cleared.
+ *
+ *      if( ( uxBits & ( BIT_0 | BIT_4 ) ) == ( BIT_0 | BIT_4 ) )
+ *      {
+ *          // Both bit 0 and bit 4 were set before xEventGroupClearBits() was
+ *          // called.  Both will now be clear (not set).
+ *      }
+ *      else if( ( uxBits & BIT_0 ) != 0 )
+ *      {
+ *          // Bit 0 was set before xEventGroupClearBits() was called.  It will
+ *          // now be clear.
+ *      }
+ *      else if( ( uxBits & BIT_4 ) != 0 )
+ *      {
+ *          // Bit 4 was set before xEventGroupClearBits() was called.  It will
+ *          // now be clear.
+ *      }
+ *      else
+ *      {
+ *          // Neither bit 0 nor bit 4 were set in the first place.
+ *      }
+ * }
+ * @endcode
+ * \defgroup xEventGroupClearBits xEventGroupClearBits
+ * \ingroup EventGroup
+ */
+EventBits_t xEventGroupClearBits( EventGroupHandle_t xEventGroup,
+                                  const EventBits_t uxBitsToClear ) PRIVILEGED_FUNCTION;
 
-    /**
-     * event_groups.h
-     * @code{c}
-     *  BaseType_t xEventGroupClearBitsFromISR( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet );
-     * @endcode
-     *
-     * A version of xEventGroupClearBits() that can be called from an interrupt.
-     *
-     * Setting bits in an event group is not a deterministic operation because there
-     * are an unknown number of tasks that may be waiting for the bit or bits being
-     * set.  FreeRTOS does not allow nondeterministic operations to be performed
-     * while interrupts are disabled, so protects event groups that are accessed
-     * from tasks by suspending the scheduler rather than disabling interrupts.  As
-     * a result event groups cannot be accessed directly from an interrupt service
-     * routine.  Therefore xEventGroupClearBitsFromISR() sends a message to the
-     * timer task to have the clear operation performed in the context of the timer
-     * task.
-     *
-     * @param xEventGroup The event group in which the bits are to be cleared.
-     *
-     * @param uxBitsToClear A bitwise value that indicates the bit or bits to clear.
-     * For example, to clear bit 3 only, set uxBitsToClear to 0x08.  To clear bit 3
-     * and bit 0 set uxBitsToClear to 0x09.
-     *
-     * @return If the request to execute the function was posted successfully then
-     * pdPASS is returned, otherwise pdFALSE is returned.  pdFALSE will be returned
-     * if the timer service queue was full.
-     *
-     * Example usage:
-     * @code{c}
-     * #define BIT_0 ( 1 << 0 )
-     * #define BIT_4 ( 1 << 4 )
-     *
-     * // An event group which it is assumed has already been created by a call to
-     * // xEventGroupCreate().
-     * EventGroupHandle_t xEventGroup;
-     *
-     * void anInterruptHandler( void )
-     * {
-     *      // Clear bit 0 and bit 4 in xEventGroup.
-     *      xResult = xEventGroupClearBitsFromISR(
-     *                          xEventGroup,     // The event group being updated.
-     *                          BIT_0 | BIT_4 ); // The bits being set.
-     *
-     *      if( xResult == pdPASS )
-     *      {
-     *          // The message was posted successfully.
-     *      }
-     * }
-     * @endcode
-     * \defgroup xEventGroupClearBitsFromISR xEventGroupClearBitsFromISR
-     * \ingroup EventGroup
-     */
-#if ( configUSE_TRACE_FACILITY == 1 )
-    BaseType_t xEventGroupClearBitsFromISR(EventGroupHandle_t xEventGroup,
-            const EventBits_t uxBitsToClear) PRIVILEGED_FUNCTION;
-#else
-#define xEventGroupClearBitsFromISR( xEventGroup, uxBitsToClear ) \
-    xTimerPendFunctionCallFromISR( vEventGroupClearBitsCallback, ( void * ) xEventGroup, ( uint32_t ) uxBitsToClear, NULL )
-#endif
+/**
+ * event_groups.h
+ * @code{c}
+ *  BaseType_t xEventGroupClearBitsFromISR( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet );
+ * @endcode
+ *
+ * A version of xEventGroupClearBits() that can be called from an interrupt.
+ *
+ * Setting bits in an event group is not a deterministic operation because there
+ * are an unknown number of tasks that may be waiting for the bit or bits being
+ * set.  FreeRTOS does not allow nondeterministic operations to be performed
+ * while interrupts are disabled, so protects event groups that are accessed
+ * from tasks by suspending the scheduler rather than disabling interrupts.  As
+ * a result event groups cannot be accessed directly from an interrupt service
+ * routine.  Therefore xEventGroupClearBitsFromISR() sends a message to the
+ * timer task to have the clear operation performed in the context of the timer
+ * task.
+ *
+ * @note If this function returns pdPASS then the timer task is ready to run
+ * and a portYIELD_FROM_ISR(pdTRUE) should be executed to perform the needed
+ * clear on the event group.  This behavior is different from
+ * xEventGroupSetBitsFromISR because the parameter xHigherPriorityTaskWoken is
+ * not present.
+ *
+ * @param xEventGroup The event group in which the bits are to be cleared.
+ *
+ * @param uxBitsToClear A bitwise value that indicates the bit or bits to clear.
+ * For example, to clear bit 3 only, set uxBitsToClear to 0x08.  To clear bit 3
+ * and bit 0 set uxBitsToClear to 0x09.
+ *
+ * @return If the request to execute the function was posted successfully then
+ * pdPASS is returned, otherwise pdFALSE is returned.  pdFALSE will be returned
+ * if the timer service queue was full.
+ *
+ * Example usage:
+ * @code{c}
+ * #define BIT_0 ( 1 << 0 )
+ * #define BIT_4 ( 1 << 4 )
+ *
+ * // An event group which it is assumed has already been created by a call to
+ * // xEventGroupCreate().
+ * EventGroupHandle_t xEventGroup;
+ *
+ * void anInterruptHandler( void )
+ * {
+ *      // Clear bit 0 and bit 4 in xEventGroup.
+ *      xResult = xEventGroupClearBitsFromISR(
+ *                          xEventGroup,     // The event group being updated.
+ *                          BIT_0 | BIT_4 ); // The bits being set.
+ *
+ *      if( xResult == pdPASS )
+ *      {
+ *          // The message was posted successfully.
+ *          portYIELD_FROM_ISR(pdTRUE);
+ *      }
+ * }
+ * @endcode
+ * \defgroup xEventGroupClearBitsFromISR xEventGroupClearBitsFromISR
+ * \ingroup EventGroup
+ */
+#if ( ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) )
+    BaseType_t xEventGroupClearBitsFromISR( EventGroupHandle_t xEventGroup,
+                                            const EventBits_t uxBitsToClear ) PRIVILEGED_FUNCTION;
+#endif /* if ( ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) ) */
+
+/**
+ * event_groups.h
+ * @code{c}
+ *  EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet );
+ * @endcode
+ *
+ * Set bits within an event group.
+ * This function cannot be called from an interrupt.  xEventGroupSetBitsFromISR()
+ * is a version that can be called from an interrupt.
+ *
+ * Setting bits in an event group will automatically unblock tasks that are
+ * blocked waiting for the bits.
+ *
+ * The configUSE_EVENT_GROUPS configuration constant must be set to 1 for xEventGroupSetBits()
+ * to be available.
+ *
+ * @param xEventGroup The event group in which the bits are to be set.
+ *
+ * @param uxBitsToSet A bitwise value that indicates the bit or bits to set.
+ * For example, to set bit 3 only, set uxBitsToSet to 0x08.  To set bit 3
+ * and bit 0 set uxBitsToSet to 0x09.
+ *
+ * @return The value of the event group at the time the call to
+ * xEventGroupSetBits() returns.  Returned value might have the bits specified
+ * by the uxBitsToSet parameter cleared if setting a bit results in a task
+ * that was waiting for the bit leaving the blocked state then it is possible
+ * the bit will be cleared automatically (see the xClearBitOnExit parameter
+ * of xEventGroupWaitBits()).
+ *
+ * Example usage:
+ * @code{c}
+ * #define BIT_0 ( 1 << 0 )
+ * #define BIT_4 ( 1 << 4 )
+ *
+ * void aFunction( EventGroupHandle_t xEventGroup )
+ * {
+ * EventBits_t uxBits;
+ *
+ *      // Set bit 0 and bit 4 in xEventGroup.
+ *      uxBits = xEventGroupSetBits(
+ *                          xEventGroup,    // The event group being updated.
+ *                          BIT_0 | BIT_4 );// The bits being set.
+ *
+ *      if( ( uxBits & ( BIT_0 | BIT_4 ) ) == ( BIT_0 | BIT_4 ) )
+ *      {
+ *          // Both bit 0 and bit 4 remained set when the function returned.
+ *      }
+ *      else if( ( uxBits & BIT_0 ) != 0 )
+ *      {
+ *          // Bit 0 remained set when the function returned, but bit 4 was
+ *          // cleared.  It might be that bit 4 was cleared automatically as a
+ *          // task that was waiting for bit 4 was removed from the Blocked
+ *          // state.
+ *      }
+ *      else if( ( uxBits & BIT_4 ) != 0 )
+ *      {
+ *          // Bit 4 remained set when the function returned, but bit 0 was
+ *          // cleared.  It might be that bit 0 was cleared automatically as a
+ *          // task that was waiting for bit 0 was removed from the Blocked
+ *          // state.
+ *      }
+ *      else
+ *      {
+ *          // Neither bit 0 nor bit 4 remained set.  It might be that a task
+ *          // was waiting for both of the bits to be set, and the bits were
+ *          // cleared as the task left the Blocked state.
+ *      }
+ * }
+ * @endcode
+ * \defgroup xEventGroupSetBits xEventGroupSetBits
+ * \ingroup EventGroup
+ */
+EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup,
+                                const EventBits_t uxBitsToSet ) PRIVILEGED_FUNCTION;
 
-    /**
-     * event_groups.h
-     * @code{c}
-     *  EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet );
-     * @endcode
-     *
-     * Set bits within an event group.
-     * This function cannot be called from an interrupt.  xEventGroupSetBitsFromISR()
-     * is a version that can be called from an interrupt.
-     *
-     * Setting bits in an event group will automatically unblock tasks that are
-     * blocked waiting for the bits.
-     *
-     * @param xEventGroup The event group in which the bits are to be set.
-     *
-     * @param uxBitsToSet A bitwise value that indicates the bit or bits to set.
-     * For example, to set bit 3 only, set uxBitsToSet to 0x08.  To set bit 3
-     * and bit 0 set uxBitsToSet to 0x09.
-     *
-     * @return The value of the event group at the time the call to
-     * xEventGroupSetBits() returns.  There are two reasons why the returned value
-     * might have the bits specified by the uxBitsToSet parameter cleared.  First,
-     * if setting a bit results in a task that was waiting for the bit leaving the
-     * blocked state then it is possible the bit will be cleared automatically
-     * (see the xClearBitOnExit parameter of xEventGroupWaitBits()).  Second, any
-     * unblocked (or otherwise Ready state) task that has a priority above that of
-     * the task that called xEventGroupSetBits() will execute and may change the
-     * event group value before the call to xEventGroupSetBits() returns.
-     *
-     * Example usage:
-     * @code{c}
-     * #define BIT_0 ( 1 << 0 )
-     * #define BIT_4 ( 1 << 4 )
-     *
-     * void aFunction( EventGroupHandle_t xEventGroup )
-     * {
-     * EventBits_t uxBits;
-     *
-     *      // Set bit 0 and bit 4 in xEventGroup.
-     *      uxBits = xEventGroupSetBits(
-     *                          xEventGroup,    // The event group being updated.
-     *                          BIT_0 | BIT_4 );// The bits being set.
-     *
-     *      if( ( uxBits & ( BIT_0 | BIT_4 ) ) == ( BIT_0 | BIT_4 ) )
-     *      {
-     *          // Both bit 0 and bit 4 remained set when the function returned.
-     *      }
-     *      else if( ( uxBits & BIT_0 ) != 0 )
-     *      {
-     *          // Bit 0 remained set when the function returned, but bit 4 was
-     *          // cleared.  It might be that bit 4 was cleared automatically as a
-     *          // task that was waiting for bit 4 was removed from the Blocked
-     *          // state.
-     *      }
-     *      else if( ( uxBits & BIT_4 ) != 0 )
-     *      {
-     *          // Bit 4 remained set when the function returned, but bit 0 was
-     *          // cleared.  It might be that bit 0 was cleared automatically as a
-     *          // task that was waiting for bit 0 was removed from the Blocked
-     *          // state.
-     *      }
-     *      else
-     *      {
-     *          // Neither bit 0 nor bit 4 remained set.  It might be that a task
-     *          // was waiting for both of the bits to be set, and the bits were
-     *          // cleared as the task left the Blocked state.
-     *      }
-     * }
-     * @endcode
-     * \defgroup xEventGroupSetBits xEventGroupSetBits
-     * \ingroup EventGroup
-     */
-    EventBits_t xEventGroupSetBits(EventGroupHandle_t xEventGroup,
-                                   const EventBits_t uxBitsToSet) PRIVILEGED_FUNCTION;
+/**
+ * event_groups.h
+ * @code{c}
+ *  BaseType_t xEventGroupSetBitsFromISR( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet, BaseType_t *pxHigherPriorityTaskWoken );
+ * @endcode
+ *
+ * A version of xEventGroupSetBits() that can be called from an interrupt.
+ *
+ * Setting bits in an event group is not a deterministic operation because there
+ * are an unknown number of tasks that may be waiting for the bit or bits being
+ * set.  FreeRTOS does not allow nondeterministic operations to be performed in
+ * interrupts or from critical sections.  Therefore xEventGroupSetBitsFromISR()
+ * sends a message to the timer task to have the set operation performed in the
+ * context of the timer task - where a scheduler lock is used in place of a
+ * critical section.
+ *
+ * @param xEventGroup The event group in which the bits are to be set.
+ *
+ * @param uxBitsToSet A bitwise value that indicates the bit or bits to set.
+ * For example, to set bit 3 only, set uxBitsToSet to 0x08.  To set bit 3
+ * and bit 0 set uxBitsToSet to 0x09.
+ *
+ * @param pxHigherPriorityTaskWoken As mentioned above, calling this function
+ * will result in a message being sent to the timer daemon task.  If the
+ * priority of the timer daemon task is higher than the priority of the
+ * currently running task (the task the interrupt interrupted) then
+ * *pxHigherPriorityTaskWoken will be set to pdTRUE by
+ * xEventGroupSetBitsFromISR(), indicating that a context switch should be
+ * requested before the interrupt exits.  For that reason
+ * *pxHigherPriorityTaskWoken must be initialised to pdFALSE.  See the
+ * example code below.
+ *
+ * @return If the request to execute the function was posted successfully then
+ * pdPASS is returned, otherwise pdFALSE is returned.  pdFALSE will be returned
+ * if the timer service queue was full.
+ *
+ * Example usage:
+ * @code{c}
+ * #define BIT_0 ( 1 << 0 )
+ * #define BIT_4 ( 1 << 4 )
+ *
+ * // An event group which it is assumed has already been created by a call to
+ * // xEventGroupCreate().
+ * EventGroupHandle_t xEventGroup;
+ *
+ * void anInterruptHandler( void )
+ * {
+ * BaseType_t xHigherPriorityTaskWoken, xResult;
+ *
+ *      // xHigherPriorityTaskWoken must be initialised to pdFALSE.
+ *      xHigherPriorityTaskWoken = pdFALSE;
+ *
+ *      // Set bit 0 and bit 4 in xEventGroup.
+ *      xResult = xEventGroupSetBitsFromISR(
+ *                          xEventGroup,    // The event group being updated.
+ *                          BIT_0 | BIT_4   // The bits being set.
+ *                          &xHigherPriorityTaskWoken );
+ *
+ *      // Was the message posted successfully?
+ *      if( xResult == pdPASS )
+ *      {
+ *          // If xHigherPriorityTaskWoken is now set to pdTRUE then a context
+ *          // switch should be requested.  The macro used is port specific and
+ *          // will be either portYIELD_FROM_ISR() or portEND_SWITCHING_ISR() -
+ *          // refer to the documentation page for the port being used.
+ *          portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
+ *      }
+ * }
+ * @endcode
+ * \defgroup xEventGroupSetBitsFromISR xEventGroupSetBitsFromISR
+ * \ingroup EventGroup
+ */
+#if ( ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) )
+    BaseType_t xEventGroupSetBitsFromISR( EventGroupHandle_t xEventGroup,
+                                          const EventBits_t uxBitsToSet,
+                                          BaseType_t * pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;
+#endif /* if ( ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) ) */
 
-    /**
-     * event_groups.h
-     * @code{c}
-     *  BaseType_t xEventGroupSetBitsFromISR( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet, BaseType_t *pxHigherPriorityTaskWoken );
-     * @endcode
-     *
-     * A version of xEventGroupSetBits() that can be called from an interrupt.
-     *
-     * Setting bits in an event group is not a deterministic operation because there
-     * are an unknown number of tasks that may be waiting for the bit or bits being
-     * set.  FreeRTOS does not allow nondeterministic operations to be performed in
-     * interrupts or from critical sections.  Therefore xEventGroupSetBitsFromISR()
-     * sends a message to the timer task to have the set operation performed in the
-     * context of the timer task - where a scheduler lock is used in place of a
-     * critical section.
-     *
-     * @param xEventGroup The event group in which the bits are to be set.
-     *
-     * @param uxBitsToSet A bitwise value that indicates the bit or bits to set.
-     * For example, to set bit 3 only, set uxBitsToSet to 0x08.  To set bit 3
-     * and bit 0 set uxBitsToSet to 0x09.
-     *
-     * @param pxHigherPriorityTaskWoken As mentioned above, calling this function
-     * will result in a message being sent to the timer daemon task.  If the
-     * priority of the timer daemon task is higher than the priority of the
-     * currently running task (the task the interrupt interrupted) then
-     * *pxHigherPriorityTaskWoken will be set to pdTRUE by
-     * xEventGroupSetBitsFromISR(), indicating that a context switch should be
-     * requested before the interrupt exits.  For that reason
-     * *pxHigherPriorityTaskWoken must be initialised to pdFALSE.  See the
-     * example code below.
-     *
-     * @return If the request to execute the function was posted successfully then
-     * pdPASS is returned, otherwise pdFALSE is returned.  pdFALSE will be returned
-     * if the timer service queue was full.
-     *
-     * Example usage:
-     * @code{c}
-     * #define BIT_0 ( 1 << 0 )
-     * #define BIT_4 ( 1 << 4 )
-     *
-     * // An event group which it is assumed has already been created by a call to
-     * // xEventGroupCreate().
-     * EventGroupHandle_t xEventGroup;
-     *
-     * void anInterruptHandler( void )
-     * {
-     * BaseType_t xHigherPriorityTaskWoken, xResult;
-     *
-     *      // xHigherPriorityTaskWoken must be initialised to pdFALSE.
-     *      xHigherPriorityTaskWoken = pdFALSE;
-     *
-     *      // Set bit 0 and bit 4 in xEventGroup.
-     *      xResult = xEventGroupSetBitsFromISR(
-     *                          xEventGroup,    // The event group being updated.
-     *                          BIT_0 | BIT_4   // The bits being set.
-     *                          &xHigherPriorityTaskWoken );
-     *
-     *      // Was the message posted successfully?
-     *      if( xResult == pdPASS )
-     *      {
-     *          // If xHigherPriorityTaskWoken is now set to pdTRUE then a context
-     *          // switch should be requested.  The macro used is port specific and
-     *          // will be either portYIELD_FROM_ISR() or portEND_SWITCHING_ISR() -
-     *          // refer to the documentation page for the port being used.
-     *          portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
-     *      }
-     * }
-     * @endcode
-     * \defgroup xEventGroupSetBitsFromISR xEventGroupSetBitsFromISR
-     * \ingroup EventGroup
-     */
-#if ( configUSE_TRACE_FACILITY == 1 )
-    BaseType_t xEventGroupSetBitsFromISR(EventGroupHandle_t xEventGroup,
-            const EventBits_t uxBitsToSet,
-            BaseType_t * pxHigherPriorityTaskWoken) PRIVILEGED_FUNCTION;
-#else
-#define xEventGroupSetBitsFromISR( xEventGroup, uxBitsToSet, pxHigherPriorityTaskWoken ) \
-    xTimerPendFunctionCallFromISR( vEventGroupSetBitsCallback, ( void * ) xEventGroup, ( uint32_t ) uxBitsToSet, pxHigherPriorityTaskWoken )
-#endif
+/**
+ * event_groups.h
+ * @code{c}
+ *  EventBits_t xEventGroupSync(    EventGroupHandle_t xEventGroup,
+ *                                  const EventBits_t uxBitsToSet,
+ *                                  const EventBits_t uxBitsToWaitFor,
+ *                                  TickType_t xTicksToWait );
+ * @endcode
+ *
+ * Atomically set bits within an event group, then wait for a combination of
+ * bits to be set within the same event group.  This functionality is typically
+ * used to synchronise multiple tasks, where each task has to wait for the other
+ * tasks to reach a synchronisation point before proceeding.
+ *
+ * This function cannot be used from an interrupt.
+ *
+ * The function will return before its block time expires if the bits specified
+ * by the uxBitsToWait parameter are set, or become set within that time.  In
+ * this case all the bits specified by uxBitsToWait will be automatically
+ * cleared before the function returns.
+ *
+ * The configUSE_EVENT_GROUPS configuration constant must be set to 1 for xEventGroupSync()
+ * to be available.
+ *
+ * @param xEventGroup The event group in which the bits are being tested.  The
+ * event group must have previously been created using a call to
+ * xEventGroupCreate().
+ *
+ * @param uxBitsToSet The bits to set in the event group before determining
+ * if, and possibly waiting for, all the bits specified by the uxBitsToWait
+ * parameter are set.
+ *
+ * @param uxBitsToWaitFor A bitwise value that indicates the bit or bits to test
+ * inside the event group.  For example, to wait for bit 0 and bit 2 set
+ * uxBitsToWaitFor to 0x05.  To wait for bits 0 and bit 1 and bit 2 set
+ * uxBitsToWaitFor to 0x07.  Etc.
+ *
+ * @param xTicksToWait The maximum amount of time (specified in 'ticks') to wait
+ * for all of the bits specified by uxBitsToWaitFor to become set.
+ *
+ * @return The value of the event group at the time either the bits being waited
+ * for became set, or the block time expired.  Test the return value to know
+ * which bits were set.  If xEventGroupSync() returned because its timeout
+ * expired then not all the bits being waited for will be set.  If
+ * xEventGroupSync() returned because all the bits it was waiting for were
+ * set then the returned value is the event group value before any bits were
+ * automatically cleared.
+ *
+ * Example usage:
+ * @code{c}
+ * // Bits used by the three tasks.
+ * #define TASK_0_BIT     ( 1 << 0 )
+ * #define TASK_1_BIT     ( 1 << 1 )
+ * #define TASK_2_BIT     ( 1 << 2 )
+ *
+ * #define ALL_SYNC_BITS ( TASK_0_BIT | TASK_1_BIT | TASK_2_BIT )
+ *
+ * // Use an event group to synchronise three tasks.  It is assumed this event
+ * // group has already been created elsewhere.
+ * EventGroupHandle_t xEventBits;
+ *
+ * void vTask0( void *pvParameters )
+ * {
+ * EventBits_t uxReturn;
+ * TickType_t xTicksToWait = 100 / portTICK_PERIOD_MS;
+ *
+ *   for( ;; )
+ *   {
+ *      // Perform task functionality here.
+ *
+ *      // Set bit 0 in the event flag to note this task has reached the
+ *      // sync point.  The other two tasks will set the other two bits defined
+ *      // by ALL_SYNC_BITS.  All three tasks have reached the synchronisation
+ *      // point when all the ALL_SYNC_BITS are set.  Wait a maximum of 100ms
+ *      // for this to happen.
+ *      uxReturn = xEventGroupSync( xEventBits, TASK_0_BIT, ALL_SYNC_BITS, xTicksToWait );
+ *
+ *      if( ( uxReturn & ALL_SYNC_BITS ) == ALL_SYNC_BITS )
+ *      {
+ *          // All three tasks reached the synchronisation point before the call
+ *          // to xEventGroupSync() timed out.
+ *      }
+ *  }
+ * }
+ *
+ * void vTask1( void *pvParameters )
+ * {
+ *   for( ;; )
+ *   {
+ *      // Perform task functionality here.
+ *
+ *      // Set bit 1 in the event flag to note this task has reached the
+ *      // synchronisation point.  The other two tasks will set the other two
+ *      // bits defined by ALL_SYNC_BITS.  All three tasks have reached the
+ *      // synchronisation point when all the ALL_SYNC_BITS are set.  Wait
+ *      // indefinitely for this to happen.
+ *      xEventGroupSync( xEventBits, TASK_1_BIT, ALL_SYNC_BITS, portMAX_DELAY );
+ *
+ *      // xEventGroupSync() was called with an indefinite block time, so
+ *      // this task will only reach here if the synchronisation was made by all
+ *      // three tasks, so there is no need to test the return value.
+ *   }
+ * }
+ *
+ * void vTask2( void *pvParameters )
+ * {
+ *   for( ;; )
+ *   {
+ *      // Perform task functionality here.
+ *
+ *      // Set bit 2 in the event flag to note this task has reached the
+ *      // synchronisation point.  The other two tasks will set the other two
+ *      // bits defined by ALL_SYNC_BITS.  All three tasks have reached the
+ *      // synchronisation point when all the ALL_SYNC_BITS are set.  Wait
+ *      // indefinitely for this to happen.
+ *      xEventGroupSync( xEventBits, TASK_2_BIT, ALL_SYNC_BITS, portMAX_DELAY );
+ *
+ *      // xEventGroupSync() was called with an indefinite block time, so
+ *      // this task will only reach here if the synchronisation was made by all
+ *      // three tasks, so there is no need to test the return value.
+ *  }
+ * }
+ *
+ * @endcode
+ * \defgroup xEventGroupSync xEventGroupSync
+ * \ingroup EventGroup
+ */
+EventBits_t xEventGroupSync( EventGroupHandle_t xEventGroup,
+                             const EventBits_t uxBitsToSet,
+                             const EventBits_t uxBitsToWaitFor,
+                             TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
 
-    /**
-     * event_groups.h
-     * @code{c}
-     *  EventBits_t xEventGroupSync(    EventGroupHandle_t xEventGroup,
-     *                                  const EventBits_t uxBitsToSet,
-     *                                  const EventBits_t uxBitsToWaitFor,
-     *                                  TickType_t xTicksToWait );
-     * @endcode
-     *
-     * Atomically set bits within an event group, then wait for a combination of
-     * bits to be set within the same event group.  This functionality is typically
-     * used to synchronise multiple tasks, where each task has to wait for the other
-     * tasks to reach a synchronisation point before proceeding.
-     *
-     * This function cannot be used from an interrupt.
-     *
-     * The function will return before its block time expires if the bits specified
-     * by the uxBitsToWait parameter are set, or become set within that time.  In
-     * this case all the bits specified by uxBitsToWait will be automatically
-     * cleared before the function returns.
-     *
-     * @param xEventGroup The event group in which the bits are being tested.  The
-     * event group must have previously been created using a call to
-     * xEventGroupCreate().
-     *
-     * @param uxBitsToSet The bits to set in the event group before determining
-     * if, and possibly waiting for, all the bits specified by the uxBitsToWait
-     * parameter are set.
-     *
-     * @param uxBitsToWaitFor A bitwise value that indicates the bit or bits to test
-     * inside the event group.  For example, to wait for bit 0 and bit 2 set
-     * uxBitsToWaitFor to 0x05.  To wait for bits 0 and bit 1 and bit 2 set
-     * uxBitsToWaitFor to 0x07.  Etc.
-     *
-     * @param xTicksToWait The maximum amount of time (specified in 'ticks') to wait
-     * for all of the bits specified by uxBitsToWaitFor to become set.
-     *
-     * @return The value of the event group at the time either the bits being waited
-     * for became set, or the block time expired.  Test the return value to know
-     * which bits were set.  If xEventGroupSync() returned because its timeout
-     * expired then not all the bits being waited for will be set.  If
-     * xEventGroupSync() returned because all the bits it was waiting for were
-     * set then the returned value is the event group value before any bits were
-     * automatically cleared.
-     *
-     * Example usage:
-     * @code{c}
-     * // Bits used by the three tasks.
-     * #define TASK_0_BIT     ( 1 << 0 )
-     * #define TASK_1_BIT     ( 1 << 1 )
-     * #define TASK_2_BIT     ( 1 << 2 )
-     *
-     * #define ALL_SYNC_BITS ( TASK_0_BIT | TASK_1_BIT | TASK_2_BIT )
-     *
-     * // Use an event group to synchronise three tasks.  It is assumed this event
-     * // group has already been created elsewhere.
-     * EventGroupHandle_t xEventBits;
-     *
-     * void vTask0( void *pvParameters )
-     * {
-     * EventBits_t uxReturn;
-     * TickType_t xTicksToWait = 100 / portTICK_PERIOD_MS;
-     *
-     *   for( ;; )
-     *   {
-     *      // Perform task functionality here.
-     *
-     *      // Set bit 0 in the event flag to note this task has reached the
-     *      // sync point.  The other two tasks will set the other two bits defined
-     *      // by ALL_SYNC_BITS.  All three tasks have reached the synchronisation
-     *      // point when all the ALL_SYNC_BITS are set.  Wait a maximum of 100ms
-     *      // for this to happen.
-     *      uxReturn = xEventGroupSync( xEventBits, TASK_0_BIT, ALL_SYNC_BITS, xTicksToWait );
-     *
-     *      if( ( uxReturn & ALL_SYNC_BITS ) == ALL_SYNC_BITS )
-     *      {
-     *          // All three tasks reached the synchronisation point before the call
-     *          // to xEventGroupSync() timed out.
-     *      }
-     *  }
-     * }
-     *
-     * void vTask1( void *pvParameters )
-     * {
-     *   for( ;; )
-     *   {
-     *      // Perform task functionality here.
-     *
-     *      // Set bit 1 in the event flag to note this task has reached the
-     *      // synchronisation point.  The other two tasks will set the other two
-     *      // bits defined by ALL_SYNC_BITS.  All three tasks have reached the
-     *      // synchronisation point when all the ALL_SYNC_BITS are set.  Wait
-     *      // indefinitely for this to happen.
-     *      xEventGroupSync( xEventBits, TASK_1_BIT, ALL_SYNC_BITS, portMAX_DELAY );
-     *
-     *      // xEventGroupSync() was called with an indefinite block time, so
-     *      // this task will only reach here if the synchronisation was made by all
-     *      // three tasks, so there is no need to test the return value.
-     *   }
-     * }
-     *
-     * void vTask2( void *pvParameters )
-     * {
-     *   for( ;; )
-     *   {
-     *      // Perform task functionality here.
-     *
-     *      // Set bit 2 in the event flag to note this task has reached the
-     *      // synchronisation point.  The other two tasks will set the other two
-     *      // bits defined by ALL_SYNC_BITS.  All three tasks have reached the
-     *      // synchronisation point when all the ALL_SYNC_BITS are set.  Wait
-     *      // indefinitely for this to happen.
-     *      xEventGroupSync( xEventBits, TASK_2_BIT, ALL_SYNC_BITS, portMAX_DELAY );
-     *
-     *      // xEventGroupSync() was called with an indefinite block time, so
-     *      // this task will only reach here if the synchronisation was made by all
-     *      // three tasks, so there is no need to test the return value.
-     *  }
-     * }
-     *
-     * @endcode
-     * \defgroup xEventGroupSync xEventGroupSync
-     * \ingroup EventGroup
-     */
-    EventBits_t xEventGroupSync(EventGroupHandle_t xEventGroup,
-                                const EventBits_t uxBitsToSet,
-                                const EventBits_t uxBitsToWaitFor,
-                                TickType_t xTicksToWait) PRIVILEGED_FUNCTION;
 
+/**
+ * event_groups.h
+ * @code{c}
+ *  EventBits_t xEventGroupGetBits( EventGroupHandle_t xEventGroup );
+ * @endcode
+ *
+ * Returns the current value of the bits in an event group.  This function
+ * cannot be used from an interrupt.
+ *
+ * The configUSE_EVENT_GROUPS configuration constant must be set to 1 for xEventGroupGetBits()
+ * to be available.
+ *
+ * @param xEventGroup The event group being queried.
+ *
+ * @return The event group bits at the time xEventGroupGetBits() was called.
+ *
+ * \defgroup xEventGroupGetBits xEventGroupGetBits
+ * \ingroup EventGroup
+ */
+#define xEventGroupGetBits( xEventGroup )    xEventGroupClearBits( ( xEventGroup ), 0 )
 
-    /**
-     * event_groups.h
-     * @code{c}
-     *  EventBits_t xEventGroupGetBits( EventGroupHandle_t xEventGroup );
-     * @endcode
-     *
-     * Returns the current value of the bits in an event group.  This function
-     * cannot be used from an interrupt.
-     *
-     * @param xEventGroup The event group being queried.
-     *
-     * @return The event group bits at the time xEventGroupGetBits() was called.
-     *
-     * \defgroup xEventGroupGetBits xEventGroupGetBits
-     * \ingroup EventGroup
-     */
-#define xEventGroupGetBits( xEventGroup )    xEventGroupClearBits( xEventGroup, 0 )
+/**
+ * event_groups.h
+ * @code{c}
+ *  EventBits_t xEventGroupGetBitsFromISR( EventGroupHandle_t xEventGroup );
+ * @endcode
+ *
+ * A version of xEventGroupGetBits() that can be called from an ISR.
+ *
+ * The configUSE_EVENT_GROUPS configuration constant must be set to 1 for xEventGroupGetBitsFromISR()
+ * to be available.
+ *
+ * @param xEventGroup The event group being queried.
+ *
+ * @return The event group bits at the time xEventGroupGetBitsFromISR() was called.
+ *
+ * \defgroup xEventGroupGetBitsFromISR xEventGroupGetBitsFromISR
+ * \ingroup EventGroup
+ */
+EventBits_t xEventGroupGetBitsFromISR( EventGroupHandle_t xEventGroup ) PRIVILEGED_FUNCTION;
 
-    /**
-     * event_groups.h
-     * @code{c}
-     *  EventBits_t xEventGroupGetBitsFromISR( EventGroupHandle_t xEventGroup );
-     * @endcode
-     *
-     * A version of xEventGroupGetBits() that can be called from an ISR.
-     *
-     * @param xEventGroup The event group being queried.
-     *
-     * @return The event group bits at the time xEventGroupGetBitsFromISR() was called.
-     *
-     * \defgroup xEventGroupGetBitsFromISR xEventGroupGetBitsFromISR
-     * \ingroup EventGroup
-     */
-    EventBits_t xEventGroupGetBitsFromISR(EventGroupHandle_t xEventGroup) PRIVILEGED_FUNCTION;
+/**
+ * event_groups.h
+ * @code{c}
+ *  void xEventGroupDelete( EventGroupHandle_t xEventGroup );
+ * @endcode
+ *
+ * Delete an event group that was previously created by a call to
+ * xEventGroupCreate().  Tasks that are blocked on the event group will be
+ * unblocked and obtain 0 as the event group's value.
+ *
+ * The configUSE_EVENT_GROUPS configuration constant must be set to 1 for vEventGroupDelete()
+ * to be available.
+ *
+ * @param xEventGroup The event group being deleted.
+ */
+void vEventGroupDelete( EventGroupHandle_t xEventGroup ) PRIVILEGED_FUNCTION;
 
-    /**
-     * event_groups.h
-     * @code{c}
-     *  void xEventGroupDelete( EventGroupHandle_t xEventGroup );
-     * @endcode
-     *
-     * Delete an event group that was previously created by a call to
-     * xEventGroupCreate().  Tasks that are blocked on the event group will be
-     * unblocked and obtain 0 as the event group's value.
-     *
-     * @param xEventGroup The event group being deleted.
-     */
-    void vEventGroupDelete(EventGroupHandle_t xEventGroup) PRIVILEGED_FUNCTION;
+/**
+ * event_groups.h
+ * @code{c}
+ *  BaseType_t xEventGroupGetStaticBuffer( EventGroupHandle_t xEventGroup,
+ *                                         StaticEventGroup_t ** ppxEventGroupBuffer );
+ * @endcode
+ *
+ * Retrieve a pointer to a statically created event groups's data structure
+ * buffer. It is the same buffer that is supplied at the time of creation.
+ *
+ * The configUSE_EVENT_GROUPS configuration constant must be set to 1 for xEventGroupGetStaticBuffer()
+ * to be available.
+ *
+ * @param xEventGroup The event group for which to retrieve the buffer.
+ *
+ * @param ppxEventGroupBuffer Used to return a pointer to the event groups's
+ * data structure buffer.
+ *
+ * @return pdTRUE if the buffer was retrieved, pdFALSE otherwise.
+ */
+#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
+    BaseType_t xEventGroupGetStaticBuffer( EventGroupHandle_t xEventGroup,
+                                           StaticEventGroup_t ** ppxEventGroupBuffer ) PRIVILEGED_FUNCTION;
+#endif /* configSUPPORT_STATIC_ALLOCATION */
 
-    /* For internal use only. */
-    void vEventGroupSetBitsCallback(void * pvEventGroup,
-                                    const uint32_t ulBitsToSet) PRIVILEGED_FUNCTION;
-    void vEventGroupClearBitsCallback(void * pvEventGroup,
-                                      const uint32_t ulBitsToClear) PRIVILEGED_FUNCTION;
+/* For internal use only. */
+void vEventGroupSetBitsCallback( void * pvEventGroup,
+                                 uint32_t ulBitsToSet ) PRIVILEGED_FUNCTION;
+void vEventGroupClearBitsCallback( void * pvEventGroup,
+                                   uint32_t ulBitsToClear ) PRIVILEGED_FUNCTION;
 
 
 #if ( configUSE_TRACE_FACILITY == 1 )
-    UBaseType_t uxEventGroupGetNumber(void * xEventGroup) PRIVILEGED_FUNCTION;
-    void vEventGroupSetNumber(void * xEventGroup,
-                              UBaseType_t uxEventGroupNumber) PRIVILEGED_FUNCTION;
+    UBaseType_t uxEventGroupGetNumber( void * xEventGroup ) PRIVILEGED_FUNCTION;
+    void vEventGroupSetNumber( void * xEventGroup,
+                               UBaseType_t uxEventGroupNumber ) PRIVILEGED_FUNCTION;
 #endif
 
 /* *INDENT-OFF* */

### external/FreeRTOS/Source/include/list.h
@@ -1,6 +1,6 @@
 /*
- * FreeRTOS Kernel V10.4.6
- * Copyright (C) 2021 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ * FreeRTOS Kernel V11.3.0
+ * Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -44,7 +44,7 @@
  *
  * In addition to it's value, each list item contains a pointer to the next
  * item in the list (pxNext), a pointer to the list it is in (pxContainer)
- * and a pointer to back to the object that contains it.  These later two
+ * and a pointer back to the object that contains it.  These later two
  * pointers are included for efficiency of list manipulation.  There is
  * effectively a two way link between the object containing the list item and
  * the list item itself.
@@ -59,7 +59,7 @@
 #define LIST_H
 
 #ifndef INC_FREERTOS_H
-#error "FreeRTOS.h must be included before list.h"
+    #error "FreeRTOS.h must be included before list.h"
 #endif
 
 /*
@@ -91,7 +91,7 @@
  * "#define configLIST_VOLATILE volatile"
  */
 #ifndef configLIST_VOLATILE
-#define configLIST_VOLATILE
+    #define configLIST_VOLATILE
 #endif /* configSUPPORT_CROSS_MODULE_OPTIMISATION */
 
 /* *INDENT-OFF* */
@@ -100,252 +100,267 @@
 #endif
 /* *INDENT-ON* */
 
-    /* Macros that can be used to place known values within the list structures,
-     * then check that the known values do not get corrupted during the execution of
-     * the application.   These may catch the list data structures being overwritten in
-     * memory.  They will not catch data errors caused by incorrect configuration or
-     * use of FreeRTOS.*/
+/* Macros that can be used to place known values within the list structures,
+ * then check that the known values do not get corrupted during the execution of
+ * the application.   These may catch the list data structures being overwritten in
+ * memory.  They will not catch data errors caused by incorrect configuration or
+ * use of FreeRTOS.*/
 #if ( configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES == 0 )
     /* Define the macros to do nothing. */
-#define listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE
-#define listSECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE
-#define listFIRST_LIST_INTEGRITY_CHECK_VALUE
-#define listSECOND_LIST_INTEGRITY_CHECK_VALUE
-#define listSET_FIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem )
-#define listSET_SECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem )
-#define listSET_LIST_INTEGRITY_CHECK_1_VALUE( pxList )
-#define listSET_LIST_INTEGRITY_CHECK_2_VALUE( pxList )
-#define listTEST_LIST_ITEM_INTEGRITY( pxItem )
-#define listTEST_LIST_INTEGRITY( pxList )
+    #define listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE
+    #define listSECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE
+    #define listFIRST_LIST_INTEGRITY_CHECK_VALUE
+    #define listSECOND_LIST_INTEGRITY_CHECK_VALUE
+    #define listSET_FIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem )
+    #define listSET_SECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem )
+    #define listSET_LIST_INTEGRITY_CHECK_1_VALUE( pxList )
+    #define listSET_LIST_INTEGRITY_CHECK_2_VALUE( pxList )
+    #define listTEST_LIST_ITEM_INTEGRITY( pxItem )
+    #define listTEST_LIST_INTEGRITY( pxList )
 #else /* if ( configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES == 0 ) */
     /* Define macros that add new members into the list structures. */
-#define listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE     TickType_t xListItemIntegrityValue1;
-#define listSECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE    TickType_t xListItemIntegrityValue2;
-#define listFIRST_LIST_INTEGRITY_CHECK_VALUE          TickType_t xListIntegrityValue1;
-#define listSECOND_LIST_INTEGRITY_CHECK_VALUE         TickType_t xListIntegrityValue2;
-
-    /* Define macros that set the new structure members to known values. */
-#define listSET_FIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem )     ( pxItem )->xListItemIntegrityValue1 = pdINTEGRITY_CHECK_VALUE
-#define listSET_SECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem )    ( pxItem )->xListItemIntegrityValue2 = pdINTEGRITY_CHECK_VALUE
-#define listSET_LIST_INTEGRITY_CHECK_1_VALUE( pxList )              ( pxList )->xListIntegrityValue1 = pdINTEGRITY_CHECK_VALUE
-#define listSET_LIST_INTEGRITY_CHECK_2_VALUE( pxList )              ( pxList )->xListIntegrityValue2 = pdINTEGRITY_CHECK_VALUE
-
-    /* Define macros that will assert if one of the structure members does not
-     * contain its expected value. */
-#define listTEST_LIST_ITEM_INTEGRITY( pxItem )                      configASSERT( ( ( pxItem )->xListItemIntegrityValue1 == pdINTEGRITY_CHECK_VALUE ) && ( ( pxItem )->xListItemIntegrityValue2 == pdINTEGRITY_CHECK_VALUE ) )
-#define listTEST_LIST_INTEGRITY( pxList )                           configASSERT( ( ( pxList )->xListIntegrityValue1 == pdINTEGRITY_CHECK_VALUE ) && ( ( pxList )->xListIntegrityValue2 == pdINTEGRITY_CHECK_VALUE ) )
+    #define listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE     TickType_t xListItemIntegrityValue1;
+    #define listSECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE    TickType_t xListItemIntegrityValue2;
+    #define listFIRST_LIST_INTEGRITY_CHECK_VALUE          TickType_t xListIntegrityValue1;
+    #define listSECOND_LIST_INTEGRITY_CHECK_VALUE         TickType_t xListIntegrityValue2;
+
+/* Define macros that set the new structure members to known values. */
+    #define listSET_FIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem )     ( pxItem )->xListItemIntegrityValue1 = pdINTEGRITY_CHECK_VALUE
+    #define listSET_SECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem )    ( pxItem )->xListItemIntegrityValue2 = pdINTEGRITY_CHECK_VALUE
+    #define listSET_LIST_INTEGRITY_CHECK_1_VALUE( pxList )              ( pxList )->xListIntegrityValue1 = pdINTEGRITY_CHECK_VALUE
+    #define listSET_LIST_INTEGRITY_CHECK_2_VALUE( pxList )              ( pxList )->xListIntegrityValue2 = pdINTEGRITY_CHECK_VALUE
+
+/* Define macros that will assert if one of the structure members does not
+ * contain its expected value. */
+    #define listTEST_LIST_ITEM_INTEGRITY( pxItem )                      configASSERT( ( ( pxItem )->xListItemIntegrityValue1 == pdINTEGRITY_CHECK_VALUE ) && ( ( pxItem )->xListItemIntegrityValue2 == pdINTEGRITY_CHECK_VALUE ) )
+    #define listTEST_LIST_INTEGRITY( pxList )                           configASSERT( ( ( pxList )->xListIntegrityValue1 == pdINTEGRITY_CHECK_VALUE ) && ( ( pxList )->xListIntegrityValue2 == pdINTEGRITY_CHECK_VALUE ) )
 #endif /* configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES */
 
 
-    /*
-     * Definition of the only type of object that a list can contain.
-     */
-    struct xLIST;
-    struct xLIST_ITEM {
-        listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE           /*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
-        configLIST_VOLATILE TickType_t xItemValue;          /*< The value being listed.  In most cases this is used to sort the list in ascending order. */
-        struct xLIST_ITEM * configLIST_VOLATILE pxNext;     /*< Pointer to the next ListItem_t in the list. */
-        struct xLIST_ITEM * configLIST_VOLATILE pxPrevious; /*< Pointer to the previous ListItem_t in the list. */
-        void * pvOwner;                                     /*< Pointer to the object (normally a TCB) that contains the list item.  There is therefore a two way link between the object containing the list item and the list item itself. */
-        struct xLIST * configLIST_VOLATILE pxContainer;     /*< Pointer to the list in which this list item is placed (if any). */
-        listSECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE          /*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
-    };
-    typedef struct xLIST_ITEM ListItem_t;                   /* For some reason lint wants this as two separate definitions. */
-
-    struct xMINI_LIST_ITEM {
-        listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE /*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
+/*
+ * Definition of the only type of object that a list can contain.
+ */
+struct xLIST;
+struct xLIST_ITEM
+{
+    listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE           /**< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
+    configLIST_VOLATILE TickType_t xItemValue;          /**< The value being listed.  In most cases this is used to sort the list in ascending order. */
+    struct xLIST_ITEM * configLIST_VOLATILE pxNext;     /**< Pointer to the next ListItem_t in the list. */
+    struct xLIST_ITEM * configLIST_VOLATILE pxPrevious; /**< Pointer to the previous ListItem_t in the list. */
+    void * pvOwner;                                     /**< Pointer to the object (normally a TCB) that contains the list item.  There is therefore a two way link between the object containing the list item and the list item itself. */
+    struct xLIST * configLIST_VOLATILE pxContainer;     /**< Pointer to the list in which this list item is placed (if any). */
+    listSECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE          /**< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
+};
+typedef struct xLIST_ITEM ListItem_t;
+
+#if ( configUSE_MINI_LIST_ITEM == 1 )
+    struct xMINI_LIST_ITEM
+    {
+        listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE /**< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
         configLIST_VOLATILE TickType_t xItemValue;
         struct xLIST_ITEM * configLIST_VOLATILE pxNext;
         struct xLIST_ITEM * configLIST_VOLATILE pxPrevious;
     };
     typedef struct xMINI_LIST_ITEM MiniListItem_t;
+#else
+    typedef struct xLIST_ITEM      MiniListItem_t;
+#endif
 
-    /*
-     * Definition of the type of queue used by the scheduler.
-     */
-    typedef struct xLIST {
-        listFIRST_LIST_INTEGRITY_CHECK_VALUE      /*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
-        volatile UBaseType_t uxNumberOfItems;
-        ListItem_t * configLIST_VOLATILE pxIndex; /*< Used to walk through the list.  Points to the last item returned by a call to listGET_OWNER_OF_NEXT_ENTRY (). */
-        MiniListItem_t xListEnd;                  /*< List item that contains the maximum possible item value meaning it is always at the end of the list and is therefore used as a marker. */
-        listSECOND_LIST_INTEGRITY_CHECK_VALUE     /*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
-    } List_t;
-
-    /*
-     * Access macro to set the owner of a list item.  The owner of a list item
-     * is the object (usually a TCB) that contains the list item.
-     *
-     * \page listSET_LIST_ITEM_OWNER listSET_LIST_ITEM_OWNER
-     * \ingroup LinkedList
-     */
+/*
+ * Definition of the type of queue used by the scheduler.
+ */
+typedef struct xLIST
+{
+    listFIRST_LIST_INTEGRITY_CHECK_VALUE      /**< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
+    configLIST_VOLATILE UBaseType_t uxNumberOfItems;
+    ListItem_t * configLIST_VOLATILE pxIndex; /**< Used to walk through the list.  Points to the last item returned by a call to listGET_OWNER_OF_NEXT_ENTRY (). */
+    MiniListItem_t xListEnd;                  /**< List item that contains the maximum possible item value meaning it is always at the end of the list and is therefore used as a marker. */
+    listSECOND_LIST_INTEGRITY_CHECK_VALUE     /**< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
+} List_t;
+
+/*
+ * Access macro to set the owner of a list item.  The owner of a list item
+ * is the object (usually a TCB) that contains the list item.
+ *
+ * \page listSET_LIST_ITEM_OWNER listSET_LIST_ITEM_OWNER
+ * \ingroup LinkedList
+ */
 #define listSET_LIST_ITEM_OWNER( pxListItem, pxOwner )    ( ( pxListItem )->pvOwner = ( void * ) ( pxOwner ) )
 
-    /*
-     * Access macro to get the owner of a list item.  The owner of a list item
-     * is the object (usually a TCB) that contains the list item.
-     *
-     * \page listGET_LIST_ITEM_OWNER listSET_LIST_ITEM_OWNER
-     * \ingroup LinkedList
-     */
+/*
+ * Access macro to get the owner of a list item.  The owner of a list item
+ * is the object (usually a TCB) that contains the list item.
+ *
+ * \page listGET_LIST_ITEM_OWNER listSET_LIST_ITEM_OWNER
+ * \ingroup LinkedList
+ */
 #define listGET_LIST_ITEM_OWNER( pxListItem )             ( ( pxListItem )->pvOwner )
 
-    /*
-     * Access macro to set the value of the list item.  In most cases the value is
-     * used to sort the list in ascending order.
-     *
-     * \page listSET_LIST_ITEM_VALUE listSET_LIST_ITEM_VALUE
-     * \ingroup LinkedList
-     */
+/*
+ * Access macro to set the value of the list item.  In most cases the value is
+ * used to sort the list in ascending order.
+ *
+ * \page listSET_LIST_ITEM_VALUE listSET_LIST_ITEM_VALUE
+ * \ingroup LinkedList
+ */
 #define listSET_LIST_ITEM_VALUE( pxListItem, xValue )     ( ( pxListItem )->xItemValue = ( xValue ) )
 
-    /*
-     * Access macro to retrieve the value of the list item.  The value can
-     * represent anything - for example the priority of a task, or the time at
-     * which a task should be unblocked.
-     *
-     * \page listGET_LIST_ITEM_VALUE listGET_LIST_ITEM_VALUE
-     * \ingroup LinkedList
-     */
+/*
+ * Access macro to retrieve the value of the list item.  The value can
+ * represent anything - for example the priority of a task, or the time at
+ * which a task should be unblocked.
+ *
+ * \page listGET_LIST_ITEM_VALUE listGET_LIST_ITEM_VALUE
+ * \ingroup LinkedList
+ */
 #define listGET_LIST_ITEM_VALUE( pxListItem )             ( ( pxListItem )->xItemValue )
 
-    /*
-     * Access macro to retrieve the value of the list item at the head of a given
-     * list.
-     *
-     * \page listGET_LIST_ITEM_VALUE listGET_LIST_ITEM_VALUE
-     * \ingroup LinkedList
-     */
+/*
+ * Access macro to retrieve the value of the list item at the head of a given
+ * list.
+ *
+ * \page listGET_LIST_ITEM_VALUE listGET_LIST_ITEM_VALUE
+ * \ingroup LinkedList
+ */
 #define listGET_ITEM_VALUE_OF_HEAD_ENTRY( pxList )        ( ( ( pxList )->xListEnd ).pxNext->xItemValue )
 
-    /*
-     * Return the list item at the head of the list.
-     *
-     * \page listGET_HEAD_ENTRY listGET_HEAD_ENTRY
-     * \ingroup LinkedList
-     */
+/*
+ * Return the list item at the head of the list.
+ *
+ * \page listGET_HEAD_ENTRY listGET_HEAD_ENTRY
+ * \ingroup LinkedList
+ */
 #define listGET_HEAD_ENTRY( pxList )                      ( ( ( pxList )->xListEnd ).pxNext )
 
-    /*
-     * Return the next list item.
-     *
-     * \page listGET_NEXT listGET_NEXT
-     * \ingroup LinkedList
-     */
+/*
+ * Return the next list item.
+ *
+ * \page listGET_NEXT listGET_NEXT
+ * \ingroup LinkedList
+ */
 #define listGET_NEXT( pxListItem )                        ( ( pxListItem )->pxNext )
 
-    /*
-     * Return the list item that marks the end of the list
-     *
-     * \page listGET_END_MARKER listGET_END_MARKER
-     * \ingroup LinkedList
-     */
+/*
+ * Return the list item that marks the end of the list
+ *
+ * \page listGET_END_MARKER listGET_END_MARKER
+ * \ingroup LinkedList
+ */
 #define listGET_END_MARKER( pxList )                      ( ( ListItem_t const * ) ( &( ( pxList )->xListEnd ) ) )
 
-    /*
-     * Access macro to determine if a list contains any items.  The macro will
-     * only have the value true if the list is empty.
-     *
-     * \page listLIST_IS_EMPTY listLIST_IS_EMPTY
-     * \ingroup LinkedList
-     */
+/*
+ * Access macro to determine if a list contains any items.  The macro will
+ * only have the value true if the list is empty.
+ *
+ * \page listLIST_IS_EMPTY listLIST_IS_EMPTY
+ * \ingroup LinkedList
+ */
 #define listLIST_IS_EMPTY( pxList )                       ( ( ( pxList )->uxNumberOfItems == ( UBaseType_t ) 0 ) ? pdTRUE : pdFALSE )
 
-    /*
-     * Access macro to return the number of items in the list.
-     */
+/*
+ * Access macro to return the number of items in the list.
+ */
 #define listCURRENT_LIST_LENGTH( pxList )                 ( ( pxList )->uxNumberOfItems )
 
-    /*
-     * Access function to obtain the owner of the next entry in a list.
-     *
-     * The list member pxIndex is used to walk through a list.  Calling
-     * listGET_OWNER_OF_NEXT_ENTRY increments pxIndex to the next item in the list
-     * and returns that entry's pxOwner parameter.  Using multiple calls to this
-     * function it is therefore possible to move through every item contained in
-     * a list.
-     *
-     * The pxOwner parameter of a list item is a pointer to the object that owns
-     * the list item.  In the scheduler this is normally a task control block.
-     * The pxOwner parameter effectively creates a two way link between the list
-     * item and its owner.
-     *
-     * @param pxTCB pxTCB is set to the address of the owner of the next list item.
-     * @param pxList The list from which the next item owner is to be returned.
-     *
-     * \page listGET_OWNER_OF_NEXT_ENTRY listGET_OWNER_OF_NEXT_ENTRY
-     * \ingroup LinkedList
-     */
-#define listGET_OWNER_OF_NEXT_ENTRY( pxTCB, pxList )                                           \
-    {                                                                                          \
+/*
+ * Access function to obtain the owner of the next entry in a list.
+ *
+ * The list member pxIndex is used to walk through a list.  Calling
+ * listGET_OWNER_OF_NEXT_ENTRY increments pxIndex to the next item in the list
+ * and returns that entry's pxOwner parameter.  Using multiple calls to this
+ * function it is therefore possible to move through every item contained in
+ * a list.
+ *
+ * The pxOwner parameter of a list item is a pointer to the object that owns
+ * the list item.  In the scheduler this is normally a task control block.
+ * The pxOwner parameter effectively creates a two way link between the list
+ * item and its owner.
+ *
+ * @param pxTCB pxTCB is set to the address of the owner of the next list item.
+ * @param pxList The list from which the next item owner is to be returned.
+ *
+ * \page listGET_OWNER_OF_NEXT_ENTRY listGET_OWNER_OF_NEXT_ENTRY
+ * \ingroup LinkedList
+ */
+#if ( configNUMBER_OF_CORES == 1 )
+    #define listGET_OWNER_OF_NEXT_ENTRY( pxTCB, pxList )                                       \
+    do {                                                                                       \
         List_t * const pxConstList = ( pxList );                                               \
         /* Increment the index to the next item and return the item, ensuring */               \
         /* we don't return the marker used at the end of the list.  */                         \
         ( pxConstList )->pxIndex = ( pxConstList )->pxIndex->pxNext;                           \
         if( ( void * ) ( pxConstList )->pxIndex == ( void * ) &( ( pxConstList )->xListEnd ) ) \
         {                                                                                      \
-            ( pxConstList )->pxIndex = ( pxConstList )->pxIndex->pxNext;                       \
+            ( pxConstList )->pxIndex = ( pxConstList )->xListEnd.pxNext;                       \
         }                                                                                      \
         ( pxTCB ) = ( pxConstList )->pxIndex->pvOwner;                                         \
-    }
+    } while( 0 )
+#else /* #if ( configNUMBER_OF_CORES == 1 ) */
+
+/* This function is not required in SMP. FreeRTOS SMP scheduler doesn't use
+ * pxIndex and it should always point to the xListEnd. Not defining this macro
+ * here to prevent updating pxIndex.
+ */
+#endif /* #if ( configNUMBER_OF_CORES == 1 ) */
 
-    /*
-     * Version of uxListRemove() that does not return a value.  Provided as a slight
-     * optimisation for xTaskIncrementTick() by being inline.
-     *
-     * Remove an item from a list.  The list item has a pointer to the list that
-     * it is in, so only the list item need be passed into the function.
-     *
-     * @param uxListRemove The item to be removed.  The item will remove itself from
-     * the list pointed to by it's pxContainer parameter.
-     *
-     * @return The number of items that remain in the list after the list item has
-     * been removed.
-     *
-     * \page listREMOVE_ITEM listREMOVE_ITEM
-     * \ingroup LinkedList
-     */
+/*
+ * Version of uxListRemove() that does not return a value.  Provided as a slight
+ * optimisation for xTaskIncrementTick() by being inline.
+ *
+ * Remove an item from a list.  The list item has a pointer to the list that
+ * it is in, so only the list item need be passed into the function.
+ *
+ * @param uxListRemove The item to be removed.  The item will remove itself from
+ * the list pointed to by it's pxContainer parameter.
+ *
+ * @return The number of items that remain in the list after the list item has
+ * been removed.
+ *
+ * \page listREMOVE_ITEM listREMOVE_ITEM
+ * \ingroup LinkedList
+ */
 #define listREMOVE_ITEM( pxItemToRemove ) \
-    {                                     \
+    do {                                  \
         /* The list item knows which list it is in.  Obtain the list from the list \
-         * item. */                                                              \
-        List_t * const pxList = ( pxItemToRemove )->pxContainer;                 \
-                                                                                 \
-        ( pxItemToRemove )->pxNext->pxPrevious = ( pxItemToRemove )->pxPrevious; \
-        ( pxItemToRemove )->pxPrevious->pxNext = ( pxItemToRemove )->pxNext;     \
-        /* Make sure the index is left pointing to a valid item. */              \
-        if( pxList->pxIndex == ( pxItemToRemove ) )                              \
-        {                                                                        \
-            pxList->pxIndex = ( pxItemToRemove )->pxPrevious;                    \
-        }                                                                        \
-                                                                                 \
-        ( pxItemToRemove )->pxContainer = NULL;                                  \
-        ( pxList->uxNumberOfItems )--;                                           \
-    }
+         * item. */                                                                                 \
+        List_t * const pxList = ( pxItemToRemove )->pxContainer;                                    \
+                                                                                                    \
+        ( pxItemToRemove )->pxNext->pxPrevious = ( pxItemToRemove )->pxPrevious;                    \
+        ( pxItemToRemove )->pxPrevious->pxNext = ( pxItemToRemove )->pxNext;                        \
+        /* Make sure the index is left pointing to a valid item. */                                 \
+        if( pxList->pxIndex == ( pxItemToRemove ) )                                                 \
+        {                                                                                           \
+            pxList->pxIndex = ( pxItemToRemove )->pxPrevious;                                       \
+        }                                                                                           \
+                                                                                                    \
+        ( pxItemToRemove )->pxContainer = NULL;                                                     \
+        ( ( pxList )->uxNumberOfItems ) = ( UBaseType_t ) ( ( ( pxList )->uxNumberOfItems ) - 1U ); \
+    } while( 0 )
 
-    /*
-     * Inline version of vListInsertEnd() to provide slight optimisation for
-     * xTaskIncrementTick().
-     *
-     * Insert a list item into a list.  The item will be inserted in a position
-     * such that it will be the last item within the list returned by multiple
-     * calls to listGET_OWNER_OF_NEXT_ENTRY.
-     *
-     * The list member pxIndex is used to walk through a list.  Calling
-     * listGET_OWNER_OF_NEXT_ENTRY increments pxIndex to the next item in the list.
-     * Placing an item in a list using vListInsertEnd effectively places the item
-     * in the list position pointed to by pxIndex.  This means that every other
-     * item within the list will be returned by listGET_OWNER_OF_NEXT_ENTRY before
-     * the pxIndex parameter again points to the item being inserted.
-     *
-     * @param pxList The list into which the item is to be inserted.
-     *
-     * @param pxNewListItem The list item to be inserted into the list.
-     *
-     * \page listINSERT_END listINSERT_END
-     * \ingroup LinkedList
-     */
+/*
+ * Inline version of vListInsertEnd() to provide slight optimisation for
+ * xTaskIncrementTick().
+ *
+ * Insert a list item into a list.  The item will be inserted in a position
+ * such that it will be the last item within the list returned by multiple
+ * calls to listGET_OWNER_OF_NEXT_ENTRY.
+ *
+ * The list member pxIndex is used to walk through a list.  Calling
+ * listGET_OWNER_OF_NEXT_ENTRY increments pxIndex to the next item in the list.
+ * Placing an item in a list using vListInsertEnd effectively places the item
+ * in the list position pointed to by pxIndex.  This means that every other
+ * item within the list will be returned by listGET_OWNER_OF_NEXT_ENTRY before
+ * the pxIndex parameter again points to the item being inserted.
+ *
+ * @param pxList The list into which the item is to be inserted.
+ *
+ * @param pxNewListItem The list item to be inserted into the list.
+ *
+ * \page listINSERT_END listINSERT_END
+ * \ingroup LinkedList
+ */
 #define listINSERT_END( pxList, pxNewListItem )           \
-    {                                                     \
+    do {                                                  \
         ListItem_t * const pxIndex = ( pxList )->pxIndex; \
                                                           \
         /* Only effective when configASSERT() is also defined, these tests may catch \
@@ -356,136 +371,136 @@
                                                                                 \
         /* Insert a new list item into ( pxList ), but rather than sort the list, \
          * makes the new list item the last item to be removed by a call to \
-         * listGET_OWNER_OF_NEXT_ENTRY(). */                 \
-        ( pxNewListItem )->pxNext = pxIndex;                 \
-        ( pxNewListItem )->pxPrevious = pxIndex->pxPrevious; \
-                                                             \
-        pxIndex->pxPrevious->pxNext = ( pxNewListItem );     \
-        pxIndex->pxPrevious = ( pxNewListItem );             \
-                                                             \
-        /* Remember which list the item is in. */            \
-        ( pxNewListItem )->pxContainer = ( pxList );         \
-                                                             \
-        ( ( pxList )->uxNumberOfItems )++;                   \
-    }
+         * listGET_OWNER_OF_NEXT_ENTRY(). */                                                        \
+        ( pxNewListItem )->pxNext = pxIndex;                                                        \
+        ( pxNewListItem )->pxPrevious = pxIndex->pxPrevious;                                        \
+                                                                                                    \
+        pxIndex->pxPrevious->pxNext = ( pxNewListItem );                                            \
+        pxIndex->pxPrevious = ( pxNewListItem );                                                    \
+                                                                                                    \
+        /* Remember which list the item is in. */                                                   \
+        ( pxNewListItem )->pxContainer = ( pxList );                                                \
+                                                                                                    \
+        ( ( pxList )->uxNumberOfItems ) = ( UBaseType_t ) ( ( ( pxList )->uxNumberOfItems ) + 1U ); \
+    } while( 0 )
 
-    /*
-     * Access function to obtain the owner of the first entry in a list.  Lists
-     * are normally sorted in ascending item value order.
-     *
-     * This function returns the pxOwner member of the first item in the list.
-     * The pxOwner parameter of a list item is a pointer to the object that owns
-     * the list item.  In the scheduler this is normally a task control block.
-     * The pxOwner parameter effectively creates a two way link between the list
-     * item and its owner.
-     *
-     * @param pxList The list from which the owner of the head item is to be
-     * returned.
-     *
-     * \page listGET_OWNER_OF_HEAD_ENTRY listGET_OWNER_OF_HEAD_ENTRY
-     * \ingroup LinkedList
-     */
+/*
+ * Access function to obtain the owner of the first entry in a list.  Lists
+ * are normally sorted in ascending item value order.
+ *
+ * This function returns the pxOwner member of the first item in the list.
+ * The pxOwner parameter of a list item is a pointer to the object that owns
+ * the list item.  In the scheduler this is normally a task control block.
+ * The pxOwner parameter effectively creates a two way link between the list
+ * item and its owner.
+ *
+ * @param pxList The list from which the owner of the head item is to be
+ * returned.
+ *
+ * \page listGET_OWNER_OF_HEAD_ENTRY listGET_OWNER_OF_HEAD_ENTRY
+ * \ingroup LinkedList
+ */
 #define listGET_OWNER_OF_HEAD_ENTRY( pxList )            ( ( &( ( pxList )->xListEnd ) )->pxNext->pvOwner )
 
-    /*
-     * Check to see if a list item is within a list.  The list item maintains a
-     * "container" pointer that points to the list it is in.  All this macro does
-     * is check to see if the container and the list match.
-     *
-     * @param pxList The list we want to know if the list item is within.
-     * @param pxListItem The list item we want to know if is in the list.
-     * @return pdTRUE if the list item is in the list, otherwise pdFALSE.
-     */
+/*
+ * Check to see if a list item is within a list.  The list item maintains a
+ * "container" pointer that points to the list it is in.  All this macro does
+ * is check to see if the container and the list match.
+ *
+ * @param pxList The list we want to know if the list item is within.
+ * @param pxListItem The list item we want to know if is in the list.
+ * @return pdTRUE if the list item is in the list, otherwise pdFALSE.
+ */
 #define listIS_CONTAINED_WITHIN( pxList, pxListItem )    ( ( ( pxListItem )->pxContainer == ( pxList ) ) ? ( pdTRUE ) : ( pdFALSE ) )
 
-    /*
-     * Return the list a list item is contained within (referenced from).
-     *
-     * @param pxListItem The list item being queried.
-     * @return A pointer to the List_t object that references the pxListItem
-     */
+/*
+ * Return the list a list item is contained within (referenced from).
+ *
+ * @param pxListItem The list item being queried.
+ * @return A pointer to the List_t object that references the pxListItem
+ */
 #define listLIST_ITEM_CONTAINER( pxListItem )            ( ( pxListItem )->pxContainer )
 
-    /*
-     * This provides a crude means of knowing if a list has been initialised, as
-     * pxList->xListEnd.xItemValue is set to portMAX_DELAY by the vListInitialise()
-     * function.
-     */
+/*
+ * This provides a crude means of knowing if a list has been initialised, as
+ * pxList->xListEnd.xItemValue is set to portMAX_DELAY by the vListInitialise()
+ * function.
+ */
 #define listLIST_IS_INITIALISED( pxList )                ( ( pxList )->xListEnd.xItemValue == portMAX_DELAY )
 
-    /*
-     * Must be called before a list is used!  This initialises all the members
-     * of the list structure and inserts the xListEnd item into the list as a
-     * marker to the back of the list.
-     *
-     * @param pxList Pointer to the list being initialised.
-     *
-     * \page vListInitialise vListInitialise
-     * \ingroup LinkedList
-     */
-    void vListInitialise(List_t * const pxList) PRIVILEGED_FUNCTION;
-
-    /*
-     * Must be called before a list item is used.  This sets the list container to
-     * null so the item does not think that it is already contained in a list.
-     *
-     * @param pxItem Pointer to the list item being initialised.
-     *
-     * \page vListInitialiseItem vListInitialiseItem
-     * \ingroup LinkedList
-     */
-    void vListInitialiseItem(ListItem_t * const pxItem) PRIVILEGED_FUNCTION;
-
-    /*
-     * Insert a list item into a list.  The item will be inserted into the list in
-     * a position determined by its item value (ascending item value order).
-     *
-     * @param pxList The list into which the item is to be inserted.
-     *
-     * @param pxNewListItem The item that is to be placed in the list.
-     *
-     * \page vListInsert vListInsert
-     * \ingroup LinkedList
-     */
-    void vListInsert(List_t * const pxList,
-                     ListItem_t * const pxNewListItem) PRIVILEGED_FUNCTION;
-
-    /*
-     * Insert a list item into a list.  The item will be inserted in a position
-     * such that it will be the last item within the list returned by multiple
-     * calls to listGET_OWNER_OF_NEXT_ENTRY.
-     *
-     * The list member pxIndex is used to walk through a list.  Calling
-     * listGET_OWNER_OF_NEXT_ENTRY increments pxIndex to the next item in the list.
-     * Placing an item in a list using vListInsertEnd effectively places the item
-     * in the list position pointed to by pxIndex.  This means that every other
-     * item within the list will be returned by listGET_OWNER_OF_NEXT_ENTRY before
-     * the pxIndex parameter again points to the item being inserted.
-     *
-     * @param pxList The list into which the item is to be inserted.
-     *
-     * @param pxNewListItem The list item to be inserted into the list.
-     *
-     * \page vListInsertEnd vListInsertEnd
-     * \ingroup LinkedList
-     */
-    void vListInsertEnd(List_t * const pxList,
-                        ListItem_t * const pxNewListItem) PRIVILEGED_FUNCTION;
-
-    /*
-     * Remove an item from a list.  The list item has a pointer to the list that
-     * it is in, so only the list item need be passed into the function.
-     *
-     * @param uxListRemove The item to be removed.  The item will remove itself from
-     * the list pointed to by it's pxContainer parameter.
-     *
-     * @return The number of items that remain in the list after the list item has
-     * been removed.
-     *
-     * \page uxListRemove uxListRemove
-     * \ingroup LinkedList
-     */
-    UBaseType_t uxListRemove(ListItem_t * const pxItemToRemove) PRIVILEGED_FUNCTION;
+/*
+ * Must be called before a list is used!  This initialises all the members
+ * of the list structure and inserts the xListEnd item into the list as a
+ * marker to the back of the list.
+ *
+ * @param pxList Pointer to the list being initialised.
+ *
+ * \page vListInitialise vListInitialise
+ * \ingroup LinkedList
+ */
+void vListInitialise( List_t * const pxList ) PRIVILEGED_FUNCTION;
+
+/*
+ * Must be called before a list item is used.  This sets the list container to
+ * null so the item does not think that it is already contained in a list.
+ *
+ * @param pxItem Pointer to the list item being initialised.
+ *
+ * \page vListInitialiseItem vListInitialiseItem
+ * \ingroup LinkedList
+ */
+void vListInitialiseItem( ListItem_t * const pxItem ) PRIVILEGED_FUNCTION;
+
+/*
+ * Insert a list item into a list.  The item will be inserted into the list in
+ * a position determined by its item value (ascending item value order).
+ *
+ * @param pxList The list into which the item is to be inserted.
+ *
+ * @param pxNewListItem The item that is to be placed in the list.
+ *
+ * \page vListInsert vListInsert
+ * \ingroup LinkedList
+ */
+void vListInsert( List_t * const pxList,
+                  ListItem_t * const pxNewListItem ) PRIVILEGED_FUNCTION;
+
+/*
+ * Insert a list item into a list.  The item will be inserted in a position
+ * such that it will be the last item within the list returned by multiple
+ * calls to listGET_OWNER_OF_NEXT_ENTRY.
+ *
+ * The list member pxIndex is used to walk through a list.  Calling
+ * listGET_OWNER_OF_NEXT_ENTRY increments pxIndex to the next item in the list.
+ * Placing an item in a list using vListInsertEnd effectively places the item
+ * in the list position pointed to by pxIndex.  This means that every other
+ * item within the list will be returned by listGET_OWNER_OF_NEXT_ENTRY before
+ * the pxIndex parameter again points to the item being inserted.
+ *
+ * @param pxList The list into which the item is to be inserted.
+ *
+ * @param pxNewListItem The list item to be inserted into the list.
+ *
+ * \page vListInsertEnd vListInsertEnd
+ * \ingroup LinkedList
+ */
+void vListInsertEnd( List_t * const pxList,
+                     ListItem_t * const pxNewListItem ) PRIVILEGED_FUNCTION;
+
+/*
+ * Remove an item from a list.  The list item has a pointer to the list that
+ * it is in, so only the list item need be passed into the function.
+ *
+ * @param uxListRemove The item to be removed.  The item will remove itself from
+ * the list pointed to by it's pxContainer parameter.
+ *
+ * @return The number of items that remain in the list after the list item has
+ * been removed.
+ *
+ * \page uxListRemove uxListRemove
+ * \ingroup LinkedList
+ */
+UBaseType_t uxListRemove( ListItem_t * const pxItemToRemove ) PRIVILEGED_FUNCTION;
 
 /* *INDENT-OFF* */
 #ifdef __cplusplus

### external/FreeRTOS/Source/include/message_buffer.h
@@ -1,6 +1,6 @@
 /*
- * FreeRTOS Kernel V10.4.6
- * Copyright (C) 2021 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ * FreeRTOS Kernel V11.3.0
+ * Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -43,12 +43,12 @@
  * writer and reader to be different tasks or interrupts, but, unlike other
  * FreeRTOS objects, it is not safe to have multiple different writers or
  * multiple different readers.  If there are to be multiple different writers
- * then the application writer must place each call to a writing API function
- * (such as xMessageBufferSend()) inside a critical section and set the send
- * block time to 0.  Likewise, if there are to be multiple different readers
- * then the application writer must place each call to a reading API function
- * (such as xMessageBufferRead()) inside a critical section and set the receive
- * timeout to 0.
+ * then the application writer must serialize calls to writing API functions
+ * (such as xStreamBufferSend()).  Likewise, if there are to be multiple
+ * different readers then the application writer must serialize calls to reading
+ * API functions (such as xStreamBufferReceive()).  One way to achieve such
+ * serialization in single core or SMP kernel is to place each API call inside a
+ * critical section and use a block time of 0.
  *
  * Message buffers hold variable length messages.  To enable that, when a
  * message is written to the message buffer an additional sizeof( size_t ) bytes
@@ -64,7 +64,7 @@
 #define FREERTOS_MESSAGE_BUFFER_H
 
 #ifndef INC_FREERTOS_H
-#error "include FreeRTOS.h must appear in source files before include message_buffer.h"
+    #error "include FreeRTOS.h must appear in source files before include message_buffer.h"
 #endif
 
 /* Message buffers are built onto of stream buffers. */
@@ -76,743 +76,887 @@
 #endif
 /* *INDENT-ON* */
 
-    /**
-     * Type by which message buffers are referenced.  For example, a call to
-     * xMessageBufferCreate() returns an MessageBufferHandle_t variable that can
-     * then be used as a parameter to xMessageBufferSend(), xMessageBufferReceive(),
-     * etc.
-     */
-    typedef void * MessageBufferHandle_t;
+/**
+ * Type by which message buffers are referenced.  For example, a call to
+ * xMessageBufferCreate() returns an MessageBufferHandle_t variable that can
+ * then be used as a parameter to xMessageBufferSend(), xMessageBufferReceive(),
+ * etc. Message buffer is essentially built as a stream buffer hence its handle
+ * is also set to same type as a stream buffer handle.
+ */
+typedef StreamBufferHandle_t MessageBufferHandle_t;
 
-    /*-----------------------------------------------------------*/
+/*-----------------------------------------------------------*/
 
-    /**
-     * message_buffer.h
-     *
-     * @code{c}
-     * MessageBufferHandle_t xMessageBufferCreate( size_t xBufferSizeBytes );
-     * @endcode
-     *
-     * Creates a new message buffer using dynamically allocated memory.  See
-     * xMessageBufferCreateStatic() for a version that uses statically allocated
-     * memory (memory that is allocated at compile time).
-     *
-     * configSUPPORT_DYNAMIC_ALLOCATION must be set to 1 or left undefined in
-     * FreeRTOSConfig.h for xMessageBufferCreate() to be available.
-     *
-     * @param xBufferSizeBytes The total number of bytes (not messages) the message
-     * buffer will be able to hold at any one time.  When a message is written to
-     * the message buffer an additional sizeof( size_t ) bytes are also written to
-     * store the message's length.  sizeof( size_t ) is typically 4 bytes on a
-     * 32-bit architecture, so on most 32-bit architectures a 10 byte message will
-     * take up 14 bytes of message buffer space.
-     *
-     * @return If NULL is returned, then the message buffer cannot be created
-     * because there is insufficient heap memory available for FreeRTOS to allocate
-     * the message buffer data structures and storage area.  A non-NULL value being
-     * returned indicates that the message buffer has been created successfully -
-     * the returned value should be stored as the handle to the created message
-     * buffer.
-     *
-     * Example use:
-     * @code{c}
-     *
-     * void vAFunction( void )
-     * {
-     * MessageBufferHandle_t xMessageBuffer;
-     * const size_t xMessageBufferSizeBytes = 100;
-     *
-     *  // Create a message buffer that can hold 100 bytes.  The memory used to hold
-     *  // both the message buffer structure and the messages themselves is allocated
-     *  // dynamically.  Each message added to the buffer consumes an additional 4
-     *  // bytes which are used to hold the lengh of the message.
-     *  xMessageBuffer = xMessageBufferCreate( xMessageBufferSizeBytes );
-     *
-     *  if( xMessageBuffer == NULL )
-     *  {
-     *      // There was not enough heap memory space available to create the
-     *      // message buffer.
-     *  }
-     *  else
-     *  {
-     *      // The message buffer was created successfully and can now be used.
-     *  }
-     *
-     * @endcode
-     * \defgroup xMessageBufferCreate xMessageBufferCreate
-     * \ingroup MessageBufferManagement
-     */
+/**
+ * message_buffer.h
+ *
+ * @code{c}
+ * MessageBufferHandle_t xMessageBufferCreate( size_t xBufferSizeBytes );
+ * @endcode
+ *
+ * Creates a new message buffer using dynamically allocated memory.  See
+ * xMessageBufferCreateStatic() for a version that uses statically allocated
+ * memory (memory that is allocated at compile time).
+ *
+ * configSUPPORT_DYNAMIC_ALLOCATION must be set to 1 or left undefined in
+ * FreeRTOSConfig.h for xMessageBufferCreate() to be available.
+ * configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
+ * xMessageBufferCreate() to be available.
+ *
+ * @param xBufferSizeBytes The total number of bytes (not messages) the message
+ * buffer will be able to hold at any one time.  When a message is written to
+ * the message buffer an additional sizeof( size_t ) bytes are also written to
+ * store the message's length.  sizeof( size_t ) is typically 4 bytes on a
+ * 32-bit architecture, so on most 32-bit architectures a 10 byte message will
+ * take up 14 bytes of message buffer space.
+ *
+ * @param pxSendCompletedCallback Callback invoked when a send operation to the
+ * message buffer is complete. If the parameter is NULL or xMessageBufferCreate()
+ * is called without the parameter, then it will use the default implementation
+ * provided by sbSEND_COMPLETED macro. To enable the callback,
+ * configUSE_SB_COMPLETED_CALLBACK must be set to 1 in FreeRTOSConfig.h.
+ *
+ * @param pxReceiveCompletedCallback Callback invoked when a receive operation from
+ * the message buffer is complete. If the parameter is NULL or xMessageBufferCreate()
+ * is called without the parameter, it will use the default implementation provided
+ * by sbRECEIVE_COMPLETED macro. To enable the callback,
+ * configUSE_SB_COMPLETED_CALLBACK must be set to 1 in FreeRTOSConfig.h.
+ *
+ * @return If NULL is returned, then the message buffer cannot be created
+ * because there is insufficient heap memory available for FreeRTOS to allocate
+ * the message buffer data structures and storage area.  A non-NULL value being
+ * returned indicates that the message buffer has been created successfully -
+ * the returned value should be stored as the handle to the created message
+ * buffer.
+ *
+ * Example use:
+ * @code{c}
+ *
+ * void vAFunction( void )
+ * {
+ * MessageBufferHandle_t xMessageBuffer;
+ * const size_t xMessageBufferSizeBytes = 100;
+ *
+ *  // Create a message buffer that can hold 100 bytes.  The memory used to hold
+ *  // both the message buffer structure and the messages themselves is allocated
+ *  // dynamically.  Each message added to the buffer consumes an additional 4
+ *  // bytes which are used to hold the length of the message.
+ *  xMessageBuffer = xMessageBufferCreate( xMessageBufferSizeBytes );
+ *
+ *  if( xMessageBuffer == NULL )
+ *  {
+ *      // There was not enough heap memory space available to create the
+ *      // message buffer.
+ *  }
+ *  else
+ *  {
+ *      // The message buffer was created successfully and can now be used.
+ *  }
+ *
+ * @endcode
+ * \defgroup xMessageBufferCreate xMessageBufferCreate
+ * \ingroup MessageBufferManagement
+ */
 #define xMessageBufferCreate( xBufferSizeBytes ) \
-    ( MessageBufferHandle_t ) xStreamBufferGenericCreate( xBufferSizeBytes, ( size_t ) 0, pdTRUE )
+    xStreamBufferGenericCreate( ( xBufferSizeBytes ), ( size_t ) 0, sbTYPE_MESSAGE_BUFFER, NULL, NULL )
+
+#if ( configUSE_SB_COMPLETED_CALLBACK == 1 )
+    #define xMessageBufferCreateWithCallback( xBufferSizeBytes, pxSendCompletedCallback, pxReceiveCompletedCallback ) \
+    xStreamBufferGenericCreate( ( xBufferSizeBytes ), ( size_t ) 0, sbTYPE_MESSAGE_BUFFER, ( pxSendCompletedCallback ), ( pxReceiveCompletedCallback ) )
+#endif
 
-    /**
-     * message_buffer.h
-     *
-     * @code{c}
-     * MessageBufferHandle_t xMessageBufferCreateStatic( size_t xBufferSizeBytes,
-     *                                                uint8_t *pucMessageBufferStorageArea,
-     *                                                StaticMessageBuffer_t *pxStaticMessageBuffer );
-     * @endcode
-     * Creates a new message buffer using statically allocated memory.  See
-     * xMessageBufferCreate() for a version that uses dynamically allocated memory.
-     *
-     * @param xBufferSizeBytes The size, in bytes, of the buffer pointed to by the
-     * pucMessageBufferStorageArea parameter.  When a message is written to the
-     * message buffer an additional sizeof( size_t ) bytes are also written to store
-     * the message's length.  sizeof( size_t ) is typically 4 bytes on a 32-bit
-     * architecture, so on most 32-bit architecture a 10 byte message will take up
-     * 14 bytes of message buffer space.  The maximum number of bytes that can be
-     * stored in the message buffer is actually (xBufferSizeBytes - 1).
-     *
-     * @param pucMessageBufferStorageArea Must point to a uint8_t array that is at
-     * least xBufferSizeBytes big.  This is the array to which messages are
-     * copied when they are written to the message buffer.
-     *
-     * @param pxStaticMessageBuffer Must point to a variable of type
-     * StaticMessageBuffer_t, which will be used to hold the message buffer's data
-     * structure.
-     *
-     * @return If the message buffer is created successfully then a handle to the
-     * created message buffer is returned. If either pucMessageBufferStorageArea or
-     * pxStaticmessageBuffer are NULL then NULL is returned.
-     *
-     * Example use:
-     * @code{c}
-     *
-     * // Used to dimension the array used to hold the messages.  The available space
-     * // will actually be one less than this, so 999.
-     #define STORAGE_SIZE_BYTES 1000
-     *
-     * // Defines the memory that will actually hold the messages within the message
-     * // buffer.
-     * static uint8_t ucStorageBuffer[ STORAGE_SIZE_BYTES ];
-     *
-     * // The variable used to hold the message buffer structure.
-     * StaticMessageBuffer_t xMessageBufferStruct;
-     *
-     * void MyFunction( void )
-     * {
-     * MessageBufferHandle_t xMessageBuffer;
-     *
-     *  xMessageBuffer = xMessageBufferCreateStatic( sizeof( ucStorageBuffer ),
-     *                                               ucStorageBuffer,
-     *                                               &xMessageBufferStruct );
-     *
-     *  // As neither the pucMessageBufferStorageArea or pxStaticMessageBuffer
-     *  // parameters were NULL, xMessageBuffer will not be NULL, and can be used to
-     *  // reference the created message buffer in other message buffer API calls.
-     *
-     *  // Other code that uses the message buffer can go here.
-     * }
-     *
-     * @endcode
-     * \defgroup xMessageBufferCreateStatic xMessageBufferCreateStatic
-     * \ingroup MessageBufferManagement
-     */
+/**
+ * message_buffer.h
+ *
+ * @code{c}
+ * MessageBufferHandle_t xMessageBufferCreateStatic( size_t xBufferSizeBytes,
+ *                                                   uint8_t *pucMessageBufferStorageArea,
+ *                                                   StaticMessageBuffer_t *pxStaticMessageBuffer );
+ * @endcode
+ * Creates a new message buffer using statically allocated memory.  See
+ * xMessageBufferCreate() for a version that uses dynamically allocated memory.
+ *
+ * configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
+ * xMessageBufferCreateStatic() to be available.
+ *
+ * @param xBufferSizeBytes The size, in bytes, of the buffer pointed to by the
+ * pucMessageBufferStorageArea parameter.  When a message is written to the
+ * message buffer an additional sizeof( size_t ) bytes are also written to store
+ * the message's length.  sizeof( size_t ) is typically 4 bytes on a 32-bit
+ * architecture, so on most 32-bit architecture a 10 byte message will take up
+ * 14 bytes of message buffer space.  The maximum number of bytes that can be
+ * stored in the message buffer is actually (xBufferSizeBytes - 1).
+ *
+ * @param pucMessageBufferStorageArea Must point to a uint8_t array that is at
+ * least xBufferSizeBytes big.  This is the array to which messages are
+ * copied when they are written to the message buffer.
+ *
+ * @param pxStaticMessageBuffer Must point to a variable of type
+ * StaticMessageBuffer_t, which will be used to hold the message buffer's data
+ * structure.
+ *
+ * @param pxSendCompletedCallback Callback invoked when a new message is sent to the message buffer.
+ * If the parameter is NULL or xMessageBufferCreate() is called without the parameter, then it will use the default
+ * implementation provided by sbSEND_COMPLETED macro. To enable the callback,
+ * configUSE_SB_COMPLETED_CALLBACK must be set to 1 in FreeRTOSConfig.h.
+ *
+ * @param pxReceiveCompletedCallback Callback invoked when a message is read from a
+ * message buffer. If the parameter is NULL or xMessageBufferCreate() is called without the parameter, it will
+ * use the default implementation provided by sbRECEIVE_COMPLETED macro. To enable the callback,
+ * configUSE_SB_COMPLETED_CALLBACK must be set to 1 in FreeRTOSConfig.h.
+ *
+ * @return If the message buffer is created successfully then a handle to the
+ * created message buffer is returned. If either pucMessageBufferStorageArea or
+ * pxStaticmessageBuffer are NULL then NULL is returned.
+ *
+ * Example use:
+ * @code{c}
+ *
+ * // Used to dimension the array used to hold the messages.  The available space
+ * // will actually be one less than this, so 999.
+ #define STORAGE_SIZE_BYTES 1000
+ *
+ * // Defines the memory that will actually hold the messages within the message
+ * // buffer.
+ * static uint8_t ucStorageBuffer[ STORAGE_SIZE_BYTES ];
+ *
+ * // The variable used to hold the message buffer structure.
+ * StaticMessageBuffer_t xMessageBufferStruct;
+ *
+ * void MyFunction( void )
+ * {
+ * MessageBufferHandle_t xMessageBuffer;
+ *
+ *  xMessageBuffer = xMessageBufferCreateStatic( sizeof( ucStorageBuffer ),
+ *                                               ucStorageBuffer,
+ *                                               &xMessageBufferStruct );
+ *
+ *  // As neither the pucMessageBufferStorageArea or pxStaticMessageBuffer
+ *  // parameters were NULL, xMessageBuffer will not be NULL, and can be used to
+ *  // reference the created message buffer in other message buffer API calls.
+ *
+ *  // Other code that uses the message buffer can go here.
+ * }
+ *
+ * @endcode
+ * \defgroup xMessageBufferCreateStatic xMessageBufferCreateStatic
+ * \ingroup MessageBufferManagement
+ */
 #define xMessageBufferCreateStatic( xBufferSizeBytes, pucMessageBufferStorageArea, pxStaticMessageBuffer ) \
-    ( MessageBufferHandle_t ) xStreamBufferGenericCreateStatic( xBufferSizeBytes, 0, pdTRUE, pucMessageBufferStorageArea, pxStaticMessageBuffer )
+    xStreamBufferGenericCreateStatic( ( xBufferSizeBytes ), 0, sbTYPE_MESSAGE_BUFFER, ( pucMessageBufferStorageArea ), ( pxStaticMessageBuffer ), NULL, NULL )
+
+#if ( configUSE_SB_COMPLETED_CALLBACK == 1 )
+    #define xMessageBufferCreateStaticWithCallback( xBufferSizeBytes, pucMessageBufferStorageArea, pxStaticMessageBuffer, pxSendCompletedCallback, pxReceiveCompletedCallback ) \
+    xStreamBufferGenericCreateStatic( ( xBufferSizeBytes ), 0, sbTYPE_MESSAGE_BUFFER, ( pucMessageBufferStorageArea ), ( pxStaticMessageBuffer ), ( pxSendCompletedCallback ), ( pxReceiveCompletedCallback ) )
+#endif
+
+/**
+ * message_buffer.h
+ *
+ * @code{c}
+ * BaseType_t xMessageBufferGetStaticBuffers( MessageBufferHandle_t xMessageBuffer,
+ *                                            uint8_t ** ppucMessageBufferStorageArea,
+ *                                            StaticMessageBuffer_t ** ppxStaticMessageBuffer );
+ * @endcode
+ *
+ * Retrieve pointers to a statically created message buffer's data structure
+ * buffer and storage area buffer. These are the same buffers that are supplied
+ * at the time of creation.
+ *
+ * configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
+ * xMessageBufferGetStaticBuffers() to be available.
+ *
+ * @param xMessageBuffer The message buffer for which to retrieve the buffers.
+ *
+ * @param ppucMessageBufferStorageArea Used to return a pointer to the
+ * message buffer's storage area buffer.
+ *
+ * @param ppxStaticMessageBuffer Used to return a pointer to the message
+ * buffer's data structure buffer.
+ *
+ * @return pdTRUE if buffers were retrieved, pdFALSE otherwise..
+ *
+ * \defgroup xMessageBufferGetStaticBuffers xMessageBufferGetStaticBuffers
+ * \ingroup MessageBufferManagement
+ */
+#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
+    #define xMessageBufferGetStaticBuffers( xMessageBuffer, ppucMessageBufferStorageArea, ppxStaticMessageBuffer ) \
+    xStreamBufferGetStaticBuffers( ( xMessageBuffer ), ( ppucMessageBufferStorageArea ), ( ppxStaticMessageBuffer ) )
+#endif /* configSUPPORT_STATIC_ALLOCATION */
 
-    /**
-     * message_buffer.h
-     *
-     * @code{c}
-     * size_t xMessageBufferSend( MessageBufferHandle_t xMessageBuffer,
-     *                         const void *pvTxData,
-     *                         size_t xDataLengthBytes,
-     *                         TickType_t xTicksToWait );
-     * @endcode
-     *
-     * Sends a discrete message to the message buffer.  The message can be any
-     * length that fits within the buffer's free space, and is copied into the
-     * buffer.
-     *
-     * ***NOTE***:  Uniquely among FreeRTOS objects, the stream buffer
-     * implementation (so also the message buffer implementation, as message buffers
-     * are built on top of stream buffers) assumes there is only one task or
-     * interrupt that will write to the buffer (the writer), and only one task or
-     * interrupt that will read from the buffer (the reader).  It is safe for the
-     * writer and reader to be different tasks or interrupts, but, unlike other
-     * FreeRTOS objects, it is not safe to have multiple different writers or
-     * multiple different readers.  If there are to be multiple different writers
-     * then the application writer must place each call to a writing API function
-     * (such as xMessageBufferSend()) inside a critical section and set the send
-     * block time to 0.  Likewise, if there are to be multiple different readers
-     * then the application writer must place each call to a reading API function
-     * (such as xMessageBufferRead()) inside a critical section and set the receive
-     * block time to 0.
-     *
-     * Use xMessageBufferSend() to write to a message buffer from a task.  Use
-     * xMessageBufferSendFromISR() to write to a message buffer from an interrupt
-     * service routine (ISR).
-     *
-     * @param xMessageBuffer The handle of the message buffer to which a message is
-     * being sent.
-     *
-     * @param pvTxData A pointer to the message that is to be copied into the
-     * message buffer.
-     *
-     * @param xDataLengthBytes The length of the message.  That is, the number of
-     * bytes to copy from pvTxData into the message buffer.  When a message is
-     * written to the message buffer an additional sizeof( size_t ) bytes are also
-     * written to store the message's length.  sizeof( size_t ) is typically 4 bytes
-     * on a 32-bit architecture, so on most 32-bit architecture setting
-     * xDataLengthBytes to 20 will reduce the free space in the message buffer by 24
-     * bytes (20 bytes of message data and 4 bytes to hold the message length).
-     *
-     * @param xTicksToWait The maximum amount of time the calling task should remain
-     * in the Blocked state to wait for enough space to become available in the
-     * message buffer, should the message buffer have insufficient space when
-     * xMessageBufferSend() is called.  The calling task will never block if
-     * xTicksToWait is zero.  The block time is specified in tick periods, so the
-     * absolute time it represents is dependent on the tick frequency.  The macro
-     * pdMS_TO_TICKS() can be used to convert a time specified in milliseconds into
-     * a time specified in ticks.  Setting xTicksToWait to portMAX_DELAY will cause
-     * the task to wait indefinitely (without timing out), provided
-     * INCLUDE_vTaskSuspend is set to 1 in FreeRTOSConfig.h.  Tasks do not use any
-     * CPU time when they are in the Blocked state.
-     *
-     * @return The number of bytes written to the message buffer.  If the call to
-     * xMessageBufferSend() times out before there was enough space to write the
-     * message into the message buffer then zero is returned.  If the call did not
-     * time out then xDataLengthBytes is returned.
-     *
-     * Example use:
-     * @code{c}
-     * void vAFunction( MessageBufferHandle_t xMessageBuffer )
-     * {
-     * size_t xBytesSent;
-     * uint8_t ucArrayToSend[] = { 0, 1, 2, 3 };
-     * char *pcStringToSend = "String to send";
-     * const TickType_t x100ms = pdMS_TO_TICKS( 100 );
-     *
-     *  // Send an array to the message buffer, blocking for a maximum of 100ms to
-     *  // wait for enough space to be available in the message buffer.
-     *  xBytesSent = xMessageBufferSend( xMessageBuffer, ( void * ) ucArrayToSend, sizeof( ucArrayToSend ), x100ms );
-     *
-     *  if( xBytesSent != sizeof( ucArrayToSend ) )
-     *  {
-     *      // The call to xMessageBufferSend() times out before there was enough
-     *      // space in the buffer for the data to be written.
-     *  }
-     *
-     *  // Send the string to the message buffer.  Return immediately if there is
-     *  // not enough space in the buffer.
-     *  xBytesSent = xMessageBufferSend( xMessageBuffer, ( void * ) pcStringToSend, strlen( pcStringToSend ), 0 );
-     *
-     *  if( xBytesSent != strlen( pcStringToSend ) )
-     *  {
-     *      // The string could not be added to the message buffer because there was
-     *      // not enough free space in the buffer.
-     *  }
-     * }
-     * @endcode
-     * \defgroup xMessageBufferSend xMessageBufferSend
-     * \ingroup MessageBufferManagement
-     */
+/**
+ * message_buffer.h
+ *
+ * @code{c}
+ * size_t xMessageBufferSend( MessageBufferHandle_t xMessageBuffer,
+ *                            const void *pvTxData,
+ *                            size_t xDataLengthBytes,
+ *                            TickType_t xTicksToWait );
+ * @endcode
+ *
+ * Sends a discrete message to the message buffer.  The message can be any
+ * length that fits within the buffer's free space, and is copied into the
+ * buffer.
+ *
+ * ***NOTE***:  Uniquely among FreeRTOS objects, the stream buffer
+ * implementation (so also the message buffer implementation, as message buffers
+ * are built on top of stream buffers) assumes there is only one task or
+ * interrupt that will write to the buffer (the writer), and only one task or
+ * interrupt that will read from the buffer (the reader).  It is safe for the
+ * writer and reader to be different tasks or interrupts, but, unlike other
+ * FreeRTOS objects, it is not safe to have multiple different writers or
+ * multiple different readers.  If there are to be multiple different writers
+ * then the application writer must serialize calls to writing API functions
+ * (such as xStreamBufferSend()).  Likewise, if there are to be multiple
+ * different readers then the application writer must serialize calls to reading
+ * API functions (such as xStreamBufferReceive()).  One way to achieve such
+ * serialization in single core or SMP kernel is to place each API call inside a
+ * critical section and use a block time of 0.
+ *
+ * Use xMessageBufferSend() to write to a message buffer from a task.  Use
+ * xMessageBufferSendFromISR() to write to a message buffer from an interrupt
+ * service routine (ISR).
+ *
+ * configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
+ * xMessageBufferSend() to be available.
+ *
+ * @param xMessageBuffer The handle of the message buffer to which a message is
+ * being sent.
+ *
+ * @param pvTxData A pointer to the message that is to be copied into the
+ * message buffer.
+ *
+ * @param xDataLengthBytes The length of the message.  That is, the number of
+ * bytes to copy from pvTxData into the message buffer.  When a message is
+ * written to the message buffer an additional sizeof( size_t ) bytes are also
+ * written to store the message's length.  sizeof( size_t ) is typically 4 bytes
+ * on a 32-bit architecture, so on most 32-bit architecture setting
+ * xDataLengthBytes to 20 will reduce the free space in the message buffer by 24
+ * bytes (20 bytes of message data and 4 bytes to hold the message length).
+ *
+ * @param xTicksToWait The maximum amount of time the calling task should remain
+ * in the Blocked state to wait for enough space to become available in the
+ * message buffer, should the message buffer have insufficient space when
+ * xMessageBufferSend() is called.  The calling task will never block if
+ * xTicksToWait is zero.  The block time is specified in tick periods, so the
+ * absolute time it represents is dependent on the tick frequency.  The macro
+ * pdMS_TO_TICKS() can be used to convert a time specified in milliseconds into
+ * a time specified in ticks.  Setting xTicksToWait to portMAX_DELAY will cause
+ * the task to wait indefinitely (without timing out), provided
+ * INCLUDE_vTaskSuspend is set to 1 in FreeRTOSConfig.h.  Tasks do not use any
+ * CPU time when they are in the Blocked state.
+ *
+ * @return The number of bytes written to the message buffer.  If the call to
+ * xMessageBufferSend() times out before there was enough space to write the
+ * message into the message buffer then zero is returned.  If the call did not
+ * time out then xDataLengthBytes is returned.
+ *
+ * Example use:
+ * @code{c}
+ * void vAFunction( MessageBufferHandle_t xMessageBuffer )
+ * {
+ * size_t xBytesSent;
+ * uint8_t ucArrayToSend[] = { 0, 1, 2, 3 };
+ * char *pcStringToSend = "String to send";
+ * const TickType_t x100ms = pdMS_TO_TICKS( 100 );
+ *
+ *  // Send an array to the message buffer, blocking for a maximum of 100ms to
+ *  // wait for enough space to be available in the message buffer.
+ *  xBytesSent = xMessageBufferSend( xMessageBuffer, ( void * ) ucArrayToSend, sizeof( ucArrayToSend ), x100ms );
+ *
+ *  if( xBytesSent != sizeof( ucArrayToSend ) )
+ *  {
+ *      // The call to xMessageBufferSend() times out before there was enough
+ *      // space in the buffer for the data to be written.
+ *  }
+ *
+ *  // Send the string to the message buffer.  Return immediately if there is
+ *  // not enough space in the buffer.
+ *  xBytesSent = xMessageBufferSend( xMessageBuffer, ( void * ) pcStringToSend, strlen( pcStringToSend ), 0 );
+ *
+ *  if( xBytesSent != strlen( pcStringToSend ) )
+ *  {
+ *      // The string could not be added to the message buffer because there was
+ *      // not enough free space in the buffer.
+ *  }
+ * }
+ * @endcode
+ * \defgroup xMessageBufferSend xMessageBufferSend
+ * \ingroup MessageBufferManagement
+ */
 #define xMessageBufferSend( xMessageBuffer, pvTxData, xDataLengthBytes, xTicksToWait ) \
-    xStreamBufferSend( ( StreamBufferHandle_t ) xMessageBuffer, pvTxData, xDataLengthBytes, xTicksToWait )
+    xStreamBufferSend( ( xMessageBuffer ), ( pvTxData ), ( xDataLengthBytes ), ( xTicksToWait ) )
 
-    /**
-     * message_buffer.h
-     *
-     * @code{c}
-     * size_t xMessageBufferSendFromISR( MessageBufferHandle_t xMessageBuffer,
-     *                                const void *pvTxData,
-     *                                size_t xDataLengthBytes,
-     *                                BaseType_t *pxHigherPriorityTaskWoken );
-     * @endcode
-     *
-     * Interrupt safe version of the API function that sends a discrete message to
-     * the message buffer.  The message can be any length that fits within the
-     * buffer's free space, and is copied into the buffer.
-     *
-     * ***NOTE***:  Uniquely among FreeRTOS objects, the stream buffer
-     * implementation (so also the message buffer implementation, as message buffers
-     * are built on top of stream buffers) assumes there is only one task or
-     * interrupt that will write to the buffer (the writer), and only one task or
-     * interrupt that will read from the buffer (the reader).  It is safe for the
-     * writer and reader to be different tasks or interrupts, but, unlike other
-     * FreeRTOS objects, it is not safe to have multiple different writers or
-     * multiple different readers.  If there are to be multiple different writers
-     * then the application writer must place each call to a writing API function
-     * (such as xMessageBufferSend()) inside a critical section and set the send
-     * block time to 0.  Likewise, if there are to be multiple different readers
-     * then the application writer must place each call to a reading API function
-     * (such as xMessageBufferRead()) inside a critical section and set the receive
-     * block time to 0.
-     *
-     * Use xMessageBufferSend() to write to a message buffer from a task.  Use
-     * xMessageBufferSendFromISR() to write to a message buffer from an interrupt
-     * service routine (ISR).
-     *
-     * @param xMessageBuffer The handle of the message buffer to which a message is
-     * being sent.
-     *
-     * @param pvTxData A pointer to the message that is to be copied into the
-     * message buffer.
-     *
-     * @param xDataLengthBytes The length of the message.  That is, the number of
-     * bytes to copy from pvTxData into the message buffer.  When a message is
-     * written to the message buffer an additional sizeof( size_t ) bytes are also
-     * written to store the message's length.  sizeof( size_t ) is typically 4 bytes
-     * on a 32-bit architecture, so on most 32-bit architecture setting
-     * xDataLengthBytes to 20 will reduce the free space in the message buffer by 24
-     * bytes (20 bytes of message data and 4 bytes to hold the message length).
-     *
-     * @param pxHigherPriorityTaskWoken  It is possible that a message buffer will
-     * have a task blocked on it waiting for data.  Calling
-     * xMessageBufferSendFromISR() can make data available, and so cause a task that
-     * was waiting for data to leave the Blocked state.  If calling
-     * xMessageBufferSendFromISR() causes a task to leave the Blocked state, and the
-     * unblocked task has a priority higher than the currently executing task (the
-     * task that was interrupted), then, internally, xMessageBufferSendFromISR()
-     * will set *pxHigherPriorityTaskWoken to pdTRUE.  If
-     * xMessageBufferSendFromISR() sets this value to pdTRUE, then normally a
-     * context switch should be performed before the interrupt is exited.  This will
-     * ensure that the interrupt returns directly to the highest priority Ready
-     * state task.  *pxHigherPriorityTaskWoken should be set to pdFALSE before it
-     * is passed into the function.  See the code example below for an example.
-     *
-     * @return The number of bytes actually written to the message buffer.  If the
-     * message buffer didn't have enough free space for the message to be stored
-     * then 0 is returned, otherwise xDataLengthBytes is returned.
-     *
-     * Example use:
-     * @code{c}
-     * // A message buffer that has already been created.
-     * MessageBufferHandle_t xMessageBuffer;
-     *
-     * void vAnInterruptServiceRoutine( void )
-     * {
-     * size_t xBytesSent;
-     * char *pcStringToSend = "String to send";
-     * BaseType_t xHigherPriorityTaskWoken = pdFALSE; // Initialised to pdFALSE.
-     *
-     *  // Attempt to send the string to the message buffer.
-     *  xBytesSent = xMessageBufferSendFromISR( xMessageBuffer,
-     *                                          ( void * ) pcStringToSend,
-     *                                          strlen( pcStringToSend ),
-     *                                          &xHigherPriorityTaskWoken );
-     *
-     *  if( xBytesSent != strlen( pcStringToSend ) )
-     *  {
-     *      // The string could not be added to the message buffer because there was
-     *      // not enough free space in the buffer.
-     *  }
-     *
-     *  // If xHigherPriorityTaskWoken was set to pdTRUE inside
-     *  // xMessageBufferSendFromISR() then a task that has a priority above the
-     *  // priority of the currently executing task was unblocked and a context
-     *  // switch should be performed to ensure the ISR returns to the unblocked
-     *  // task.  In most FreeRTOS ports this is done by simply passing
-     *  // xHigherPriorityTaskWoken into portYIELD_FROM_ISR(), which will test the
-     *  // variables value, and perform the context switch if necessary.  Check the
-     *  // documentation for the port in use for port specific instructions.
-     *  portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
-     * }
-     * @endcode
-     * \defgroup xMessageBufferSendFromISR xMessageBufferSendFromISR
-     * \ingroup MessageBufferManagement
-     */
+/**
+ * message_buffer.h
+ *
+ * @code{c}
+ * size_t xMessageBufferSendFromISR( MessageBufferHandle_t xMessageBuffer,
+ *                                   const void *pvTxData,
+ *                                   size_t xDataLengthBytes,
+ *                                   BaseType_t *pxHigherPriorityTaskWoken );
+ * @endcode
+ *
+ * Interrupt safe version of the API function that sends a discrete message to
+ * the message buffer.  The message can be any length that fits within the
+ * buffer's free space, and is copied into the buffer.
+ *
+ * ***NOTE***:  Uniquely among FreeRTOS objects, the stream buffer
+ * implementation (so also the message buffer implementation, as message buffers
+ * are built on top of stream buffers) assumes there is only one task or
+ * interrupt that will write to the buffer (the writer), and only one task or
+ * interrupt that will read from the buffer (the reader).  It is safe for the
+ * writer and reader to be different tasks or interrupts, but, unlike other
+ * FreeRTOS objects, it is not safe to have multiple different writers or
+ * multiple different readers.  If there are to be multiple different writers
+ * then the application writer must serialize calls to writing API functions
+ * (such as xStreamBufferSend()).  Likewise, if there are to be multiple
+ * different readers then the application writer must serialize calls to reading
+ * API functions (such as xStreamBufferReceive()).  One way to achieve such
+ * serialization in single core or SMP kernel is to place each API call inside a
+ * critical section and use a block time of 0.
+ *
+ * Use xMessageBufferSend() to write to a message buffer from a task.  Use
+ * xMessageBufferSendFromISR() to write to a message buffer from an interrupt
+ * service routine (ISR).
+ *
+ * configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
+ * xMessageBufferSendFromISR() to be available.
+ *
+ * @param xMessageBuffer The handle of the message buffer to which a message is
+ * being sent.
+ *
+ * @param pvTxData A pointer to the message that is to be copied into the
+ * message buffer.
+ *
+ * @param xDataLengthBytes The length of the message.  That is, the number of
+ * bytes to copy from pvTxData into the message buffer.  When a message is
+ * written to the message buffer an additional sizeof( size_t ) bytes are also
+ * written to store the message's length.  sizeof( size_t ) is typically 4 bytes
+ * on a 32-bit architecture, so on most 32-bit architecture setting
+ * xDataLengthBytes to 20 will reduce the free space in the message buffer by 24
+ * bytes (20 bytes of message data and 4 bytes to hold the message length).
+ *
+ * @param pxHigherPriorityTaskWoken  It is possible that a message buffer will
+ * have a task blocked on it waiting for data.  Calling
+ * xMessageBufferSendFromISR() can make data available, and so cause a task that
+ * was waiting for data to leave the Blocked state.  If calling
+ * xMessageBufferSendFromISR() causes a task to leave the Blocked state, and the
+ * unblocked task has a priority higher than the currently executing task (the
+ * task that was interrupted), then, internally, xMessageBufferSendFromISR()
+ * will set *pxHigherPriorityTaskWoken to pdTRUE.  If
+ * xMessageBufferSendFromISR() sets this value to pdTRUE, then normally a
+ * context switch should be performed before the interrupt is exited.  This will
+ * ensure that the interrupt returns directly to the highest priority Ready
+ * state task.  *pxHigherPriorityTaskWoken should be set to pdFALSE before it
+ * is passed into the function.  See the code example below for an example.
+ *
+ * @return The number of bytes actually written to the message buffer.  If the
+ * message buffer didn't have enough free space for the message to be stored
+ * then 0 is returned, otherwise xDataLengthBytes is returned.
+ *
+ * Example use:
+ * @code{c}
+ * // A message buffer that has already been created.
+ * MessageBufferHandle_t xMessageBuffer;
+ *
+ * void vAnInterruptServiceRoutine( void )
+ * {
+ * size_t xBytesSent;
+ * char *pcStringToSend = "String to send";
+ * BaseType_t xHigherPriorityTaskWoken = pdFALSE; // Initialised to pdFALSE.
+ *
+ *  // Attempt to send the string to the message buffer.
+ *  xBytesSent = xMessageBufferSendFromISR( xMessageBuffer,
+ *                                          ( void * ) pcStringToSend,
+ *                                          strlen( pcStringToSend ),
+ *                                          &xHigherPriorityTaskWoken );
+ *
+ *  if( xBytesSent != strlen( pcStringToSend ) )
+ *  {
+ *      // The string could not be added to the message buffer because there was
+ *      // not enough free space in the buffer.
+ *  }
+ *
+ *  // If xHigherPriorityTaskWoken was set to pdTRUE inside
+ *  // xMessageBufferSendFromISR() then a task that has a priority above the
+ *  // priority of the currently executing task was unblocked and a context
+ *  // switch should be performed to ensure the ISR returns to the unblocked
+ *  // task.  In most FreeRTOS ports this is done by simply passing
+ *  // xHigherPriorityTaskWoken into portYIELD_FROM_ISR(), which will test the
+ *  // variables value, and perform the context switch if necessary.  Check the
+ *  // documentation for the port in use for port specific instructions.
+ *  portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
+ * }
+ * @endcode
+ * \defgroup xMessageBufferSendFromISR xMessageBufferSendFromISR
+ * \ingroup MessageBufferManagement
+ */
 #define xMessageBufferSendFromISR( xMessageBuffer, pvTxData, xDataLengthBytes, pxHigherPriorityTaskWoken ) \
-    xStreamBufferSendFromISR( ( StreamBufferHandle_t ) xMessageBuffer, pvTxData, xDataLengthBytes, pxHigherPriorityTaskWoken )
+    xStreamBufferSendFromISR( ( xMessageBuffer ), ( pvTxData ), ( xDataLengthBytes ), ( pxHigherPriorityTaskWoken ) )
 
-    /**
-     * message_buffer.h
-     *
-     * @code{c}
-     * size_t xMessageBufferReceive( MessageBufferHandle_t xMessageBuffer,
-     *                            void *pvRxData,
-     *                            size_t xBufferLengthBytes,
-     *                            TickType_t xTicksToWait );
-     * @endcode
-     *
-     * Receives a discrete message from a message buffer.  Messages can be of
-     * variable length and are copied out of the buffer.
-     *
-     * ***NOTE***:  Uniquely among FreeRTOS objects, the stream buffer
-     * implementation (so also the message buffer implementation, as message buffers
-     * are built on top of stream buffers) assumes there is only one task or
-     * interrupt that will write to the buffer (the writer), and only one task or
-     * interrupt that will read from the buffer (the reader).  It is safe for the
-     * writer and reader to be different tasks or interrupts, but, unlike other
-     * FreeRTOS objects, it is not safe to have multiple different writers or
-     * multiple different readers.  If there are to be multiple different writers
-     * then the application writer must place each call to a writing API function
-     * (such as xMessageBufferSend()) inside a critical section and set the send
-     * block time to 0.  Likewise, if there are to be multiple different readers
-     * then the application writer must place each call to a reading API function
-     * (such as xMessageBufferRead()) inside a critical section and set the receive
-     * block time to 0.
-     *
-     * Use xMessageBufferReceive() to read from a message buffer from a task.  Use
-     * xMessageBufferReceiveFromISR() to read from a message buffer from an
-     * interrupt service routine (ISR).
-     *
-     * @param xMessageBuffer The handle of the message buffer from which a message
-     * is being received.
-     *
-     * @param pvRxData A pointer to the buffer into which the received message is
-     * to be copied.
-     *
-     * @param xBufferLengthBytes The length of the buffer pointed to by the pvRxData
-     * parameter.  This sets the maximum length of the message that can be received.
-     * If xBufferLengthBytes is too small to hold the next message then the message
-     * will be left in the message buffer and 0 will be returned.
-     *
-     * @param xTicksToWait The maximum amount of time the task should remain in the
-     * Blocked state to wait for a message, should the message buffer be empty.
-     * xMessageBufferReceive() will return immediately if xTicksToWait is zero and
-     * the message buffer is empty.  The block time is specified in tick periods, so
-     * the absolute time it represents is dependent on the tick frequency.  The
-     * macro pdMS_TO_TICKS() can be used to convert a time specified in milliseconds
-     * into a time specified in ticks.  Setting xTicksToWait to portMAX_DELAY will
-     * cause the task to wait indefinitely (without timing out), provided
-     * INCLUDE_vTaskSuspend is set to 1 in FreeRTOSConfig.h.  Tasks do not use any
-     * CPU time when they are in the Blocked state.
-     *
-     * @return The length, in bytes, of the message read from the message buffer, if
-     * any.  If xMessageBufferReceive() times out before a message became available
-     * then zero is returned.  If the length of the message is greater than
-     * xBufferLengthBytes then the message will be left in the message buffer and
-     * zero is returned.
-     *
-     * Example use:
-     * @code{c}
-     * void vAFunction( MessageBuffer_t xMessageBuffer )
-     * {
-     * uint8_t ucRxData[ 20 ];
-     * size_t xReceivedBytes;
-     * const TickType_t xBlockTime = pdMS_TO_TICKS( 20 );
-     *
-     *  // Receive the next message from the message buffer.  Wait in the Blocked
-     *  // state (so not using any CPU processing time) for a maximum of 100ms for
-     *  // a message to become available.
-     *  xReceivedBytes = xMessageBufferReceive( xMessageBuffer,
-     *                                          ( void * ) ucRxData,
-     *                                          sizeof( ucRxData ),
-     *                                          xBlockTime );
-     *
-     *  if( xReceivedBytes > 0 )
-     *  {
-     *      // A ucRxData contains a message that is xReceivedBytes long.  Process
-     *      // the message here....
-     *  }
-     * }
-     * @endcode
-     * \defgroup xMessageBufferReceive xMessageBufferReceive
-     * \ingroup MessageBufferManagement
-     */
+/**
+ * message_buffer.h
+ *
+ * @code{c}
+ * size_t xMessageBufferReceive( MessageBufferHandle_t xMessageBuffer,
+ *                               void *pvRxData,
+ *                               size_t xBufferLengthBytes,
+ *                               TickType_t xTicksToWait );
+ * @endcode
+ *
+ * Receives a discrete message from a message buffer.  Messages can be of
+ * variable length and are copied out of the buffer.
+ *
+ * ***NOTE***:  Uniquely among FreeRTOS objects, the stream buffer
+ * implementation (so also the message buffer implementation, as message buffers
+ * are built on top of stream buffers) assumes there is only one task or
+ * interrupt that will write to the buffer (the writer), and only one task or
+ * interrupt that will read from the buffer (the reader).  It is safe for the
+ * writer and reader to be different tasks or interrupts, but, unlike other
+ * FreeRTOS objects, it is not safe to have multiple different writers or
+ * multiple different readers.  If there are to be multiple different writers
+ * then the application writer must serialize calls to writing API functions
+ * (such as xStreamBufferSend()).  Likewise, if there are to be multiple
+ * different readers then the application writer must serialize calls to reading
+ * API functions (such as xStreamBufferReceive()).  One way to achieve such
+ * serialization in single core or SMP kernel is to place each API call inside a
+ * critical section and use a block time of 0.
+ *
+ * Use xMessageBufferReceive() to read from a message buffer from a task.  Use
+ * xMessageBufferReceiveFromISR() to read from a message buffer from an
+ * interrupt service routine (ISR).
+ *
+ * configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
+ * xMessageBufferReceive() to be available.
+ *
+ * @param xMessageBuffer The handle of the message buffer from which a message
+ * is being received.
+ *
+ * @param pvRxData A pointer to the buffer into which the received message is
+ * to be copied.
+ *
+ * @param xBufferLengthBytes The length of the buffer pointed to by the pvRxData
+ * parameter.  This sets the maximum length of the message that can be received.
+ * If xBufferLengthBytes is too small to hold the next message then the message
+ * will be left in the message buffer and 0 will be returned.
+ *
+ * @param xTicksToWait The maximum amount of time the task should remain in the
+ * Blocked state to wait for a message, should the message buffer be empty.
+ * xMessageBufferReceive() will return immediately if xTicksToWait is zero and
+ * the message buffer is empty.  The block time is specified in tick periods, so
+ * the absolute time it represents is dependent on the tick frequency.  The
+ * macro pdMS_TO_TICKS() can be used to convert a time specified in milliseconds
+ * into a time specified in ticks.  Setting xTicksToWait to portMAX_DELAY will
+ * cause the task to wait indefinitely (without timing out), provided
+ * INCLUDE_vTaskSuspend is set to 1 in FreeRTOSConfig.h.  Tasks do not use any
+ * CPU time when they are in the Blocked state.
+ *
+ * @return The length, in bytes, of the message read from the message buffer, if
+ * any.  If xMessageBufferReceive() times out before a message became available
+ * then zero is returned.  If the length of the message is greater than
+ * xBufferLengthBytes then the message will be left in the message buffer and
+ * zero is returned.
+ *
+ * Example use:
+ * @code{c}
+ * void vAFunction( MessageBuffer_t xMessageBuffer )
+ * {
+ * uint8_t ucRxData[ 20 ];
+ * size_t xReceivedBytes;
+ * const TickType_t xBlockTime = pdMS_TO_TICKS( 20 );
+ *
+ *  // Receive the next message from the message buffer.  Wait in the Blocked
+ *  // state (so not using any CPU processing time) for a maximum of 100ms for
+ *  // a message to become available.
+ *  xReceivedBytes = xMessageBufferReceive( xMessageBuffer,
+ *                                          ( void * ) ucRxData,
+ *                                          sizeof( ucRxData ),
+ *                                          xBlockTime );
+ *
+ *  if( xReceivedBytes > 0 )
+ *  {
+ *      // A ucRxData contains a message that is xReceivedBytes long.  Process
+ *      // the message here....
+ *  }
+ * }
+ * @endcode
+ * \defgroup xMessageBufferReceive xMessageBufferReceive
+ * \ingroup MessageBufferManagement
+ */
 #define xMessageBufferReceive( xMessageBuffer, pvRxData, xBufferLengthBytes, xTicksToWait ) \
-    xStreamBufferReceive( ( StreamBufferHandle_t ) xMessageBuffer, pvRxData, xBufferLengthBytes, xTicksToWait )
+    xStreamBufferReceive( ( xMessageBuffer ), ( pvRxData ), ( xBufferLengthBytes ), ( xTicksToWait ) )
 
 
-    /**
-     * message_buffer.h
-     *
-     * @code{c}
-     * size_t xMessageBufferReceiveFromISR( MessageBufferHandle_t xMessageBuffer,
-     *                                   void *pvRxData,
-     *                                   size_t xBufferLengthBytes,
-     *                                   BaseType_t *pxHigherPriorityTaskWoken );
-     * @endcode
-     *
-     * An interrupt safe version of the API function that receives a discrete
-     * message from a message buffer.  Messages can be of variable length and are
-     * copied out of the buffer.
-     *
-     * ***NOTE***:  Uniquely among FreeRTOS objects, the stream buffer
-     * implementation (so also the message buffer implementation, as message buffers
-     * are built on top of stream buffers) assumes there is only one task or
-     * interrupt that will write to the buffer (the writer), and only one task or
-     * interrupt that will read from the buffer (the reader).  It is safe for the
-     * writer and reader to be different tasks or interrupts, but, unlike other
-     * FreeRTOS objects, it is not safe to have multiple different writers or
-     * multiple different readers.  If there are to be multiple different writers
-     * then the application writer must place each call to a writing API function
-     * (such as xMessageBufferSend()) inside a critical section and set the send
-     * block time to 0.  Likewise, if there are to be multiple different readers
-     * then the application writer must place each call to a reading API function
-     * (such as xMessageBufferRead()) inside a critical section and set the receive
-     * block time to 0.
-     *
-     * Use xMessageBufferReceive() to read from a message buffer from a task.  Use
-     * xMessageBufferReceiveFromISR() to read from a message buffer from an
-     * interrupt service routine (ISR).
-     *
-     * @param xMessageBuffer The handle of the message buffer from which a message
-     * is being received.
-     *
-     * @param pvRxData A pointer to the buffer into which the received message is
-     * to be copied.
-     *
-     * @param xBufferLengthBytes The length of the buffer pointed to by the pvRxData
-     * parameter.  This sets the maximum length of the message that can be received.
-     * If xBufferLengthBytes is too small to hold the next message then the message
-     * will be left in the message buffer and 0 will be returned.
-     *
-     * @param pxHigherPriorityTaskWoken  It is possible that a message buffer will
-     * have a task blocked on it waiting for space to become available.  Calling
-     * xMessageBufferReceiveFromISR() can make space available, and so cause a task
-     * that is waiting for space to leave the Blocked state.  If calling
-     * xMessageBufferReceiveFromISR() causes a task to leave the Blocked state, and
-     * the unblocked task has a priority higher than the currently executing task
-     * (the task that was interrupted), then, internally,
-     * xMessageBufferReceiveFromISR() will set *pxHigherPriorityTaskWoken to pdTRUE.
-     * If xMessageBufferReceiveFromISR() sets this value to pdTRUE, then normally a
-     * context switch should be performed before the interrupt is exited.  That will
-     * ensure the interrupt returns directly to the highest priority Ready state
-     * task.  *pxHigherPriorityTaskWoken should be set to pdFALSE before it is
-     * passed into the function.  See the code example below for an example.
-     *
-     * @return The length, in bytes, of the message read from the message buffer, if
-     * any.
-     *
-     * Example use:
-     * @code{c}
-     * // A message buffer that has already been created.
-     * MessageBuffer_t xMessageBuffer;
-     *
-     * void vAnInterruptServiceRoutine( void )
-     * {
-     * uint8_t ucRxData[ 20 ];
-     * size_t xReceivedBytes;
-     * BaseType_t xHigherPriorityTaskWoken = pdFALSE;  // Initialised to pdFALSE.
-     *
-     *  // Receive the next message from the message buffer.
-     *  xReceivedBytes = xMessageBufferReceiveFromISR( xMessageBuffer,
-     *                                                ( void * ) ucRxData,
-     *                                                sizeof( ucRxData ),
-     *                                                &xHigherPriorityTaskWoken );
-     *
-     *  if( xReceivedBytes > 0 )
-     *  {
-     *      // A ucRxData contains a message that is xReceivedBytes long.  Process
-     *      // the message here....
-     *  }
-     *
-     *  // If xHigherPriorityTaskWoken was set to pdTRUE inside
-     *  // xMessageBufferReceiveFromISR() then a task that has a priority above the
-     *  // priority of the currently executing task was unblocked and a context
-     *  // switch should be performed to ensure the ISR returns to the unblocked
-     *  // task.  In most FreeRTOS ports this is done by simply passing
-     *  // xHigherPriorityTaskWoken into portYIELD_FROM_ISR(), which will test the
-     *  // variables value, and perform the context switch if necessary.  Check the
-     *  // documentation for the port in use for port specific instructions.
-     *  portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
-     * }
-     * @endcode
-     * \defgroup xMessageBufferReceiveFromISR xMessageBufferReceiveFromISR
-     * \ingroup MessageBufferManagement
-     */
+/**
+ * message_buffer.h
+ *
+ * @code{c}
+ * size_t xMessageBufferReceiveFromISR( MessageBufferHandle_t xMessageBuffer,
+ *                                      void *pvRxData,
+ *                                      size_t xBufferLengthBytes,
+ *                                      BaseType_t *pxHigherPriorityTaskWoken );
+ * @endcode
+ *
+ * An interrupt safe version of the API function that receives a discrete
+ * message from a message buffer.  Messages can be of variable length and are
+ * copied out of the buffer.
+ *
+ * ***NOTE***:  Uniquely among FreeRTOS objects, the stream buffer
+ * implementation (so also the message buffer implementation, as message buffers
+ * are built on top of stream buffers) assumes there is only one task or
+ * interrupt that will write to the buffer (the writer), and only one task or
+ * interrupt that will read from the buffer (the reader).  It is safe for the
+ * writer and reader to be different tasks or interrupts, but, unlike other
+ * FreeRTOS objects, it is not safe to have multiple different writers or
+ * multiple different readers.  If there are to be multiple different writers
+ * then the application writer must serialize calls to writing API functions
+ * (such as xStreamBufferSend()).  Likewise, if there are to be multiple
+ * different readers then the application writer must serialize calls to reading
+ * API functions (such as xStreamBufferReceive()).  One way to achieve such
+ * serialization in single core or SMP kernel is to place each API call inside a
+ * critical section and use a block time of 0.
+ *
+ * Use xMessageBufferReceive() to read from a message buffer from a task.  Use
+ * xMessageBufferReceiveFromISR() to read from a message buffer from an
+ * interrupt service routine (ISR).
+ *
+ * configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
+ * xMessageBufferReceiveFromISR() to be available.
+ *
+ * @param xMessageBuffer The handle of the message buffer from which a message
+ * is being received.
+ *
+ * @param pvRxData A pointer to the buffer into which the received message is
+ * to be copied.
+ *
+ * @param xBufferLengthBytes The length of the buffer pointed to by the pvRxData
+ * parameter.  This sets the maximum length of the message that can be received.
+ * If xBufferLengthBytes is too small to hold the next message then the message
+ * will be left in the message buffer and 0 will be returned.
+ *
+ * @param pxHigherPriorityTaskWoken  It is possible that a message buffer will
+ * have a task blocked on it waiting for space to become available.  Calling
+ * xMessageBufferReceiveFromISR() can make space available, and so cause a task
+ * that is waiting for space to leave the Blocked state.  If calling
+ * xMessageBufferReceiveFromISR() causes a task to leave the Blocked state, and
+ * the unblocked task has a priority higher than the currently executing task
+ * (the task that was interrupted), then, internally,
+ * xMessageBufferReceiveFromISR() will set *pxHigherPriorityTaskWoken to pdTRUE.
+ * If xMessageBufferReceiveFromISR() sets this value to pdTRUE, then normally a
+ * context switch should be performed before the interrupt is exited.  That will
+ * ensure the interrupt returns directly to the highest priority Ready state
+ * task.  *pxHigherPriorityTaskWoken should be set to pdFALSE before it is
+ * passed into the function.  See the code example below for an example.
+ *
+ * @return The length, in bytes, of the message read from the message buffer, if
+ * any.
+ *
+ * Example use:
+ * @code{c}
+ * // A message buffer that has already been created.
+ * MessageBuffer_t xMessageBuffer;
+ *
+ * void vAnInterruptServiceRoutine( void )
+ * {
+ * uint8_t ucRxData[ 20 ];
+ * size_t xReceivedBytes;
+ * BaseType_t xHigherPriorityTaskWoken = pdFALSE;  // Initialised to pdFALSE.
+ *
+ *  // Receive the next message from the message buffer.
+ *  xReceivedBytes = xMessageBufferReceiveFromISR( xMessageBuffer,
+ *                                                ( void * ) ucRxData,
+ *                                                sizeof( ucRxData ),
+ *                                                &xHigherPriorityTaskWoken );
+ *
+ *  if( xReceivedBytes > 0 )
+ *  {
+ *      // A ucRxData contains a message that is xReceivedBytes long.  Process
+ *      // the message here....
+ *  }
+ *
+ *  // If xHigherPriorityTaskWoken was set to pdTRUE inside
+ *  // xMessageBufferReceiveFromISR() then a task that has a priority above the
+ *  // priority of the currently executing task was unblocked and a context
+ *  // switch should be performed to ensure the ISR returns to the unblocked
+ *  // task.  In most FreeRTOS ports this is done by simply passing
+ *  // xHigherPriorityTaskWoken into portYIELD_FROM_ISR(), which will test the
+ *  // variables value, and perform the context switch if necessary.  Check the
+ *  // documentation for the port in use for port specific instructions.
+ *  portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
+ * }
+ * @endcode
+ * \defgroup xMessageBufferReceiveFromISR xMessageBufferReceiveFromISR
+ * \ingroup MessageBufferManagement
+ */
 #define xMessageBufferReceiveFromISR( xMessageBuffer, pvRxData, xBufferLengthBytes, pxHigherPriorityTaskWoken ) \
-    xStreamBufferReceiveFromISR( ( StreamBufferHandle_t ) xMessageBuffer, pvRxData, xBufferLengthBytes, pxHigherPriorityTaskWoken )
+    xStreamBufferReceiveFromISR( ( xMessageBuffer ), ( pvRxData ), ( xBufferLengthBytes ), ( pxHigherPriorityTaskWoken ) )
 
-    /**
-     * message_buffer.h
-     *
-     * @code{c}
-     * void vMessageBufferDelete( MessageBufferHandle_t xMessageBuffer );
-     * @endcode
-     *
-     * Deletes a message buffer that was previously created using a call to
-     * xMessageBufferCreate() or xMessageBufferCreateStatic().  If the message
-     * buffer was created using dynamic memory (that is, by xMessageBufferCreate()),
-     * then the allocated memory is freed.
-     *
-     * A message buffer handle must not be used after the message buffer has been
-     * deleted.
-     *
-     * @param xMessageBuffer The handle of the message buffer to be deleted.
-     *
-     */
+/**
+ * message_buffer.h
+ *
+ * @code{c}
+ * void vMessageBufferDelete( MessageBufferHandle_t xMessageBuffer );
+ * @endcode
+ *
+ * Deletes a message buffer that was previously created using a call to
+ * xMessageBufferCreate() or xMessageBufferCreateStatic().  If the message
+ * buffer was created using dynamic memory (that is, by xMessageBufferCreate()),
+ * then the allocated memory is freed.
+ *
+ * A message buffer handle must not be used after the message buffer has been
+ * deleted.
+ *
+ * configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
+ * vMessageBufferDelete() to be available.
+ *
+ * @param xMessageBuffer The handle of the message buffer to be deleted.
+ *
+ */
 #define vMessageBufferDelete( xMessageBuffer ) \
-    vStreamBufferDelete( ( StreamBufferHandle_t ) xMessageBuffer )
+    vStreamBufferDelete( xMessageBuffer )
 
-    /**
-     * message_buffer.h
-     * @code{c}
-     * BaseType_t xMessageBufferIsFull( MessageBufferHandle_t xMessageBuffer );
-     * @endcode
-     *
-     * Tests to see if a message buffer is full.  A message buffer is full if it
-     * cannot accept any more messages, of any size, until space is made available
-     * by a message being removed from the message buffer.
-     *
-     * @param xMessageBuffer The handle of the message buffer being queried.
-     *
-     * @return If the message buffer referenced by xMessageBuffer is full then
-     * pdTRUE is returned.  Otherwise pdFALSE is returned.
-     */
+/**
+ * message_buffer.h
+ * @code{c}
+ * BaseType_t xMessageBufferIsFull( MessageBufferHandle_t xMessageBuffer );
+ * @endcode
+ *
+ * Tests to see if a message buffer is full.  A message buffer is full if it
+ * cannot accept any more messages, of any size, until space is made available
+ * by a message being removed from the message buffer.
+ *
+ * configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
+ * xMessageBufferIsFull() to be available.
+ *
+ * @param xMessageBuffer The handle of the message buffer being queried.
+ *
+ * @return If the message buffer referenced by xMessageBuffer is full then
+ * pdTRUE is returned.  Otherwise pdFALSE is returned.
+ */
 #define xMessageBufferIsFull( xMessageBuffer ) \
-    xStreamBufferIsFull( ( StreamBufferHandle_t ) xMessageBuffer )
+    xStreamBufferIsFull( xMessageBuffer )
 
-    /**
-     * message_buffer.h
-     * @code{c}
-     * BaseType_t xMessageBufferIsEmpty( MessageBufferHandle_t xMessageBuffer );
-     * @endcode
-     *
-     * Tests to see if a message buffer is empty (does not contain any messages).
-     *
-     * @param xMessageBuffer The handle of the message buffer being queried.
-     *
-     * @return If the message buffer referenced by xMessageBuffer is empty then
-     * pdTRUE is returned.  Otherwise pdFALSE is returned.
-     *
-     */
+/**
+ * message_buffer.h
+ * @code{c}
+ * BaseType_t xMessageBufferIsEmpty( MessageBufferHandle_t xMessageBuffer );
+ * @endcode
+ *
+ * Tests to see if a message buffer is empty (does not contain any messages).
+ *
+ * configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
+ * xMessageBufferIsEmpty() to be available.
+ *
+ * @param xMessageBuffer The handle of the message buffer being queried.
+ *
+ * @return If the message buffer referenced by xMessageBuffer is empty then
+ * pdTRUE is returned.  Otherwise pdFALSE is returned.
+ *
+ */
 #define xMessageBufferIsEmpty( xMessageBuffer ) \
-    xStreamBufferIsEmpty( ( StreamBufferHandle_t ) xMessageBuffer )
+    xStreamBufferIsEmpty( xMessageBuffer )
 
-    /**
-     * message_buffer.h
-     * @code{c}
-     * BaseType_t xMessageBufferReset( MessageBufferHandle_t xMessageBuffer );
-     * @endcode
-     *
-     * Resets a message buffer to its initial empty state, discarding any message it
-     * contained.
-     *
-     * A message buffer can only be reset if there are no tasks blocked on it.
-     *
-     * @param xMessageBuffer The handle of the message buffer being reset.
-     *
-     * @return If the message buffer was reset then pdPASS is returned.  If the
-     * message buffer could not be reset because either there was a task blocked on
-     * the message queue to wait for space to become available, or to wait for a
-     * a message to be available, then pdFAIL is returned.
-     *
-     * \defgroup xMessageBufferReset xMessageBufferReset
-     * \ingroup MessageBufferManagement
-     */
+/**
+ * message_buffer.h
+ * @code{c}
+ * BaseType_t xMessageBufferReset( MessageBufferHandle_t xMessageBuffer );
+ * @endcode
+ *
+ * Resets a message buffer to its initial empty state, discarding any message it
+ * contained.
+ *
+ * A message buffer can only be reset if there are no tasks blocked on it.
+ *
+ * Use xMessageBufferReset() to reset a message buffer from a task.
+ * Use xMessageBufferResetFromISR() to reset a message buffer from an
+ * interrupt service routine (ISR).
+ *
+ * configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
+ * xMessageBufferReset() to be available.
+ *
+ * @param xMessageBuffer The handle of the message buffer being reset.
+ *
+ * @return If the message buffer was reset then pdPASS is returned.  If the
+ * message buffer could not be reset because either there was a task blocked on
+ * the message queue to wait for space to become available, or to wait for a
+ * a message to be available, then pdFAIL is returned.
+ *
+ * \defgroup xMessageBufferReset xMessageBufferReset
+ * \ingroup MessageBufferManagement
+ */
 #define xMessageBufferReset( xMessageBuffer ) \
-    xStreamBufferReset( ( StreamBufferHandle_t ) xMessageBuffer )
+    xStreamBufferReset( xMessageBuffer )
+
 
+/**
+ * message_buffer.h
+ * @code{c}
+ * BaseType_t xMessageBufferResetFromISR( MessageBufferHandle_t xMessageBuffer );
+ * @endcode
+ *
+ * An interrupt safe version of the API function that resets the message buffer.
+ * Resets a message buffer to its initial empty state, discarding any message it
+ * contained.
+ *
+ * A message buffer can only be reset if there are no tasks blocked on it.
+ *
+ * Use xMessageBufferReset() to reset a message buffer from a task.
+ * Use xMessageBufferResetFromISR() to reset a message buffer from an
+ * interrupt service routine (ISR).
+ *
+ * configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
+ * xMessageBufferResetFromISR() to be available.
+ *
+ * @param xMessageBuffer The handle of the message buffer being reset.
+ *
+ * @return If the message buffer was reset then pdPASS is returned.  If the
+ * message buffer could not be reset because either there was a task blocked on
+ * the message queue to wait for space to become available, or to wait for a
+ * a message to be available, then pdFAIL is returned.
+ *
+ * \defgroup xMessageBufferResetFromISR xMessageBufferResetFromISR
+ * \ingroup MessageBufferManagement
+ */
+#define xMessageBufferResetFromISR( xMessageBuffer ) \
+    xStreamBufferResetFromISR( xMessageBuffer )
 
-    /**
-     * message_buffer.h
-     * @code{c}
-     * size_t xMessageBufferSpaceAvailable( MessageBufferHandle_t xMessageBuffer );
-     * @endcode
-     * Returns the number of bytes of free space in the message buffer.
-     *
-     * @param xMessageBuffer The handle of the message buffer being queried.
-     *
-     * @return The number of bytes that can be written to the message buffer before
-     * the message buffer would be full.  When a message is written to the message
-     * buffer an additional sizeof( size_t ) bytes are also written to store the
-     * message's length.  sizeof( size_t ) is typically 4 bytes on a 32-bit
-     * architecture, so if xMessageBufferSpacesAvailable() returns 10, then the size
-     * of the largest message that can be written to the message buffer is 6 bytes.
-     *
-     * \defgroup xMessageBufferSpaceAvailable xMessageBufferSpaceAvailable
-     * \ingroup MessageBufferManagement
-     */
+/**
+ * message_buffer.h
+ * @code{c}
+ * size_t xMessageBufferSpaceAvailable( MessageBufferHandle_t xMessageBuffer );
+ * @endcode
+ * Returns the number of bytes of free space in the message buffer.
+ *
+ * configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
+ * xMessageBufferSpaceAvailable() to be available.
+ *
+ * @param xMessageBuffer The handle of the message buffer being queried.
+ *
+ * @return The number of bytes that can be written to the message buffer before
+ * the message buffer would be full.  When a message is written to the message
+ * buffer an additional sizeof( size_t ) bytes are also written to store the
+ * message's length.  sizeof( size_t ) is typically 4 bytes on a 32-bit
+ * architecture, so if xMessageBufferSpacesAvailable() returns 10, then the size
+ * of the largest message that can be written to the message buffer is 6 bytes.
+ *
+ * \defgroup xMessageBufferSpaceAvailable xMessageBufferSpaceAvailable
+ * \ingroup MessageBufferManagement
+ */
 #define xMessageBufferSpaceAvailable( xMessageBuffer ) \
-    xStreamBufferSpacesAvailable( ( StreamBufferHandle_t ) xMessageBuffer )
+    xStreamBufferSpacesAvailable( xMessageBuffer )
 #define xMessageBufferSpacesAvailable( xMessageBuffer ) \
-    xStreamBufferSpacesAvailable( ( StreamBufferHandle_t ) xMessageBuffer ) /* Corrects typo in original macro name. */
+    xStreamBufferSpacesAvailable( xMessageBuffer ) /* Corrects typo in original macro name. */
 
-    /**
-     * message_buffer.h
-     * @code{c}
-     * size_t xMessageBufferNextLengthBytes( MessageBufferHandle_t xMessageBuffer );
-     * @endcode
-     * Returns the length (in bytes) of the next message in a message buffer.
-     * Useful if xMessageBufferReceive() returned 0 because the size of the buffer
-     * passed into xMessageBufferReceive() was too small to hold the next message.
-     *
-     * @param xMessageBuffer The handle of the message buffer being queried.
-     *
-     * @return The length (in bytes) of the next message in the message buffer, or 0
-     * if the message buffer is empty.
-     *
-     * \defgroup xMessageBufferNextLengthBytes xMessageBufferNextLengthBytes
-     * \ingroup MessageBufferManagement
-     */
+/**
+ * message_buffer.h
+ * @code{c}
+ * size_t xMessageBufferNextLengthBytes( MessageBufferHandle_t xMessageBuffer );
+ * @endcode
+ * Returns the length (in bytes) of the next message in a message buffer.
+ * Useful if xMessageBufferReceive() returned 0 because the size of the buffer
+ * passed into xMessageBufferReceive() was too small to hold the next message.
+ *
+ * configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
+ * xMessageBufferNextLengthBytes() to be available.
+ *
+ * @param xMessageBuffer The handle of the message buffer being queried.
+ *
+ * @return The length (in bytes) of the next message in the message buffer, or 0
+ * if the message buffer is empty.
+ *
+ * \defgroup xMessageBufferNextLengthBytes xMessageBufferNextLengthBytes
+ * \ingroup MessageBufferManagement
+ */
 #define xMessageBufferNextLengthBytes( xMessageBuffer ) \
-    xStreamBufferNextMessageLengthBytes( ( StreamBufferHandle_t ) xMessageBuffer ) PRIVILEGED_FUNCTION;
+    xStreamBufferNextMessageLengthBytes( xMessageBuffer )
 
-    /**
-     * message_buffer.h
-     *
-     * @code{c}
-     * BaseType_t xMessageBufferSendCompletedFromISR( MessageBufferHandle_t xMessageBuffer, BaseType_t *pxHigherPriorityTaskWoken );
-     * @endcode
-     *
-     * For advanced users only.
-     *
-     * The sbSEND_COMPLETED() macro is called from within the FreeRTOS APIs when
-     * data is sent to a message buffer or stream buffer.  If there was a task that
-     * was blocked on the message or stream buffer waiting for data to arrive then
-     * the sbSEND_COMPLETED() macro sends a notification to the task to remove it
-     * from the Blocked state.  xMessageBufferSendCompletedFromISR() does the same
-     * thing.  It is provided to enable application writers to implement their own
-     * version of sbSEND_COMPLETED(), and MUST NOT BE USED AT ANY OTHER TIME.
-     *
-     * See the example implemented in FreeRTOS/Demo/Minimal/MessageBufferAMP.c for
-     * additional information.
-     *
-     * @param xMessageBuffer The handle of the stream buffer to which data was
-     * written.
-     *
-     * @param pxHigherPriorityTaskWoken *pxHigherPriorityTaskWoken should be
-     * initialised to pdFALSE before it is passed into
-     * xMessageBufferSendCompletedFromISR().  If calling
-     * xMessageBufferSendCompletedFromISR() removes a task from the Blocked state,
-     * and the task has a priority above the priority of the currently running task,
-     * then *pxHigherPriorityTaskWoken will get set to pdTRUE indicating that a
-     * context switch should be performed before exiting the ISR.
-     *
-     * @return If a task was removed from the Blocked state then pdTRUE is returned.
-     * Otherwise pdFALSE is returned.
-     *
-     * \defgroup xMessageBufferSendCompletedFromISR xMessageBufferSendCompletedFromISR
-     * \ingroup StreamBufferManagement
-     */
+/**
+ * message_buffer.h
+ *
+ * @code{c}
+ * BaseType_t xMessageBufferSendCompletedFromISR( MessageBufferHandle_t xMessageBuffer, BaseType_t *pxHigherPriorityTaskWoken );
+ * @endcode
+ *
+ * For advanced users only.
+ *
+ * The sbSEND_COMPLETED() macro is called from within the FreeRTOS APIs when
+ * data is sent to a message buffer or stream buffer.  If there was a task that
+ * was blocked on the message or stream buffer waiting for data to arrive then
+ * the sbSEND_COMPLETED() macro sends a notification to the task to remove it
+ * from the Blocked state.  xMessageBufferSendCompletedFromISR() does the same
+ * thing.  It is provided to enable application writers to implement their own
+ * version of sbSEND_COMPLETED(), and MUST NOT BE USED AT ANY OTHER TIME.
+ *
+ * See the example implemented in FreeRTOS/Demo/Minimal/MessageBufferAMP.c for
+ * additional information.
+ *
+ * configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
+ * xMessageBufferSendCompletedFromISR() to be available.
+ *
+ * @param xMessageBuffer The handle of the stream buffer to which data was
+ * written.
+ *
+ * @param pxHigherPriorityTaskWoken *pxHigherPriorityTaskWoken should be
+ * initialised to pdFALSE before it is passed into
+ * xMessageBufferSendCompletedFromISR().  If calling
+ * xMessageBufferSendCompletedFromISR() removes a task from the Blocked state,
+ * and the task has a priority above the priority of the currently running task,
+ * then *pxHigherPriorityTaskWoken will get set to pdTRUE indicating that a
+ * context switch should be performed before exiting the ISR.
+ *
+ * @return If a task was removed from the Blocked state then pdTRUE is returned.
+ * Otherwise pdFALSE is returned.
+ *
+ * \defgroup xMessageBufferSendCompletedFromISR xMessageBufferSendCompletedFromISR
+ * \ingroup StreamBufferManagement
+ */
 #define xMessageBufferSendCompletedFromISR( xMessageBuffer, pxHigherPriorityTaskWoken ) \
-    xStreamBufferSendCompletedFromISR( ( StreamBufferHandle_t ) xMessageBuffer, pxHigherPriorityTaskWoken )
+    xStreamBufferSendCompletedFromISR( ( xMessageBuffer ), ( pxHigherPriorityTaskWoken ) )
 
-    /**
-     * message_buffer.h
-     *
-     * @code{c}
-     * BaseType_t xMessageBufferReceiveCompletedFromISR( MessageBufferHandle_t xMessageBuffer, BaseType_t *pxHigherPriorityTaskWoken );
-     * @endcode
-     *
-     * For advanced users only.
-     *
-     * The sbRECEIVE_COMPLETED() macro is called from within the FreeRTOS APIs when
-     * data is read out of a message buffer or stream buffer.  If there was a task
-     * that was blocked on the message or stream buffer waiting for data to arrive
-     * then the sbRECEIVE_COMPLETED() macro sends a notification to the task to
-     * remove it from the Blocked state.  xMessageBufferReceiveCompletedFromISR()
-     * does the same thing.  It is provided to enable application writers to
-     * implement their own version of sbRECEIVE_COMPLETED(), and MUST NOT BE USED AT
-     * ANY OTHER TIME.
-     *
-     * See the example implemented in FreeRTOS/Demo/Minimal/MessageBufferAMP.c for
-     * additional information.
-     *
-     * @param xMessageBuffer The handle of the stream buffer from which data was
-     * read.
-     *
-     * @param pxHigherPriorityTaskWoken *pxHigherPriorityTaskWoken should be
-     * initialised to pdFALSE before it is passed into
-     * xMessageBufferReceiveCompletedFromISR().  If calling
-     * xMessageBufferReceiveCompletedFromISR() removes a task from the Blocked state,
-     * and the task has a priority above the priority of the currently running task,
-     * then *pxHigherPriorityTaskWoken will get set to pdTRUE indicating that a
-     * context switch should be performed before exiting the ISR.
-     *
-     * @return If a task was removed from the Blocked state then pdTRUE is returned.
-     * Otherwise pdFALSE is returned.
-     *
-     * \defgroup xMessageBufferReceiveCompletedFromISR xMessageBufferReceiveCompletedFromISR
-     * \ingroup StreamBufferManagement
-     */
+/**
+ * message_buffer.h
+ *
+ * @code{c}
+ * BaseType_t xMessageBufferReceiveCompletedFromISR( MessageBufferHandle_t xMessageBuffer, BaseType_t *pxHigherPriorityTaskWoken );
+ * @endcode
+ *
+ * For advanced users only.
+ *
+ * The sbRECEIVE_COMPLETED() macro is called from within the FreeRTOS APIs when
+ * data is read out of a message buffer or stream buffer.  If there was a task
+ * that was blocked on the message or stream buffer waiting for data to arrive
+ * then the sbRECEIVE_COMPLETED() macro sends a notification to the task to
+ * remove it from the Blocked state.  xMessageBufferReceiveCompletedFromISR()
+ * does the same thing.  It is provided to enable application writers to
+ * implement their own version of sbRECEIVE_COMPLETED(), and MUST NOT BE USED AT
+ * ANY OTHER TIME.
+ *
+ * See the example implemented in FreeRTOS/Demo/Minimal/MessageBufferAMP.c for
+ * additional information.
+ *
+ * configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
+ * xMessageBufferReceiveCompletedFromISR() to be available.
+ *
+ * @param xMessageBuffer The handle of the stream buffer from which data was
+ * read.
+ *
+ * @param pxHigherPriorityTaskWoken *pxHigherPriorityTaskWoken should be
+ * initialised to pdFALSE before it is passed into
+ * xMessageBufferReceiveCompletedFromISR().  If calling
+ * xMessageBufferReceiveCompletedFromISR() removes a task from the Blocked state,
+ * and the task has a priority above the priority of the currently running task,
+ * then *pxHigherPriorityTaskWoken will get set to pdTRUE indicating that a
+ * context switch should be performed before exiting the ISR.
+ *
+ * @return If a task was removed from the Blocked state then pdTRUE is returned.
+ * Otherwise pdFALSE is returned.
+ *
+ * \defgroup xMessageBufferReceiveCompletedFromISR xMessageBufferReceiveCompletedFromISR
+ * \ingroup StreamBufferManagement
+ */
 #define xMessageBufferReceiveCompletedFromISR( xMessageBuffer, pxHigherPriorityTaskWoken ) \
-    xStreamBufferReceiveCompletedFromISR( ( StreamBufferHandle_t ) xMessageBuffer, pxHigherPriorityTaskWoken )
+    xStreamBufferReceiveCompletedFromISR( ( xMessageBuffer ), ( pxHigherPriorityTaskWoken ) )
 
 /* *INDENT-OFF* */
 #if defined( __cplusplus )

### external/FreeRTOS/Source/include/mpu_prototypes.h
@@ -1,6 +1,6 @@
 /*
- * FreeRTOS Kernel V10.4.6
- * Copyright (C) 2021 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ * FreeRTOS Kernel V11.3.0
+ * Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -38,223 +38,458 @@
 #ifndef MPU_PROTOTYPES_H
 #define MPU_PROTOTYPES_H
 
-/* MPU versions of tasks.h API functions. */
-BaseType_t MPU_xTaskCreate(TaskFunction_t pxTaskCode,
-                           const char * const pcName,
-                           const uint16_t usStackDepth,
-                           void * const pvParameters,
-                           UBaseType_t uxPriority,
-                           TaskHandle_t * const pxCreatedTask) FREERTOS_SYSTEM_CALL;
-TaskHandle_t MPU_xTaskCreateStatic(TaskFunction_t pxTaskCode,
-                                   const char * const pcName,
-                                   const uint32_t ulStackDepth,
-                                   void * const pvParameters,
-                                   UBaseType_t uxPriority,
-                                   StackType_t * const puxStackBuffer,
-                                   StaticTask_t * const pxTaskBuffer) FREERTOS_SYSTEM_CALL;
-void MPU_vTaskDelete(TaskHandle_t xTaskToDelete) FREERTOS_SYSTEM_CALL;
-void MPU_vTaskDelay(const TickType_t xTicksToDelay) FREERTOS_SYSTEM_CALL;
-BaseType_t MPU_xTaskDelayUntil(TickType_t * const pxPreviousWakeTime,
-                               const TickType_t xTimeIncrement) FREERTOS_SYSTEM_CALL;
-BaseType_t MPU_xTaskAbortDelay(TaskHandle_t xTask) FREERTOS_SYSTEM_CALL;
-UBaseType_t MPU_uxTaskPriorityGet(const TaskHandle_t xTask) FREERTOS_SYSTEM_CALL;
-eTaskState MPU_eTaskGetState(TaskHandle_t xTask) FREERTOS_SYSTEM_CALL;
-void MPU_vTaskGetInfo(TaskHandle_t xTask,
-                      TaskStatus_t * pxTaskStatus,
-                      BaseType_t xGetFreeStackSpace,
-                      eTaskState eState) FREERTOS_SYSTEM_CALL;
-void MPU_vTaskPrioritySet(TaskHandle_t xTask,
-                          UBaseType_t uxNewPriority) FREERTOS_SYSTEM_CALL;
-void MPU_vTaskSuspend(TaskHandle_t xTaskToSuspend) FREERTOS_SYSTEM_CALL;
-void MPU_vTaskResume(TaskHandle_t xTaskToResume) FREERTOS_SYSTEM_CALL;
-void MPU_vTaskStartScheduler(void) FREERTOS_SYSTEM_CALL;
-void MPU_vTaskSuspendAll(void) FREERTOS_SYSTEM_CALL;
-BaseType_t MPU_xTaskResumeAll(void) FREERTOS_SYSTEM_CALL;
-TickType_t MPU_xTaskGetTickCount(void) FREERTOS_SYSTEM_CALL;
-UBaseType_t MPU_uxTaskGetNumberOfTasks(void) FREERTOS_SYSTEM_CALL;
-char * MPU_pcTaskGetName(TaskHandle_t xTaskToQuery) FREERTOS_SYSTEM_CALL;
-TaskHandle_t MPU_xTaskGetHandle(const char * pcNameToQuery) FREERTOS_SYSTEM_CALL;
-UBaseType_t MPU_uxTaskGetStackHighWaterMark(TaskHandle_t xTask) FREERTOS_SYSTEM_CALL;
-configSTACK_DEPTH_TYPE MPU_uxTaskGetStackHighWaterMark2(TaskHandle_t xTask) FREERTOS_SYSTEM_CALL;
-void MPU_vTaskSetApplicationTaskTag(TaskHandle_t xTask,
-                                    TaskHookFunction_t pxHookFunction) FREERTOS_SYSTEM_CALL;
-TaskHookFunction_t MPU_xTaskGetApplicationTaskTag(TaskHandle_t xTask) FREERTOS_SYSTEM_CALL;
-void MPU_vTaskSetThreadLocalStoragePointer(TaskHandle_t xTaskToSet,
-        BaseType_t xIndex,
-        void * pvValue) FREERTOS_SYSTEM_CALL;
-void * MPU_pvTaskGetThreadLocalStoragePointer(TaskHandle_t xTaskToQuery,
-        BaseType_t xIndex) FREERTOS_SYSTEM_CALL;
-BaseType_t MPU_xTaskCallApplicationTaskHook(TaskHandle_t xTask,
-        void * pvParameter) FREERTOS_SYSTEM_CALL;
-TaskHandle_t MPU_xTaskGetIdleTaskHandle(void) FREERTOS_SYSTEM_CALL;
-UBaseType_t MPU_uxTaskGetSystemState(TaskStatus_t * const pxTaskStatusArray,
-                                     const UBaseType_t uxArraySize,
-                                     configRUN_TIME_COUNTER_TYPE * const pulTotalRunTime) FREERTOS_SYSTEM_CALL;
-configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetIdleRunTimeCounter(void) FREERTOS_SYSTEM_CALL;
-configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetIdleRunTimePercent(void) FREERTOS_SYSTEM_CALL;
-void MPU_vTaskList(char * pcWriteBuffer) FREERTOS_SYSTEM_CALL;
-void MPU_vTaskGetRunTimeStats(char * pcWriteBuffer) FREERTOS_SYSTEM_CALL;
-BaseType_t MPU_xTaskGenericNotify(TaskHandle_t xTaskToNotify,
-                                  UBaseType_t uxIndexToNotify,
-                                  uint32_t ulValue,
-                                  eNotifyAction eAction,
-                                  uint32_t * pulPreviousNotificationValue) FREERTOS_SYSTEM_CALL;
-BaseType_t MPU_xTaskGenericNotifyWait(UBaseType_t uxIndexToWaitOn,
-                                      uint32_t ulBitsToClearOnEntry,
-                                      uint32_t ulBitsToClearOnExit,
-                                      uint32_t * pulNotificationValue,
-                                      TickType_t xTicksToWait) FREERTOS_SYSTEM_CALL;
-uint32_t MPU_ulTaskGenericNotifyTake(UBaseType_t uxIndexToWaitOn,
-                                     BaseType_t xClearCountOnExit,
-                                     TickType_t xTicksToWait) FREERTOS_SYSTEM_CALL;
-BaseType_t MPU_xTaskGenericNotifyStateClear(TaskHandle_t xTask,
-        UBaseType_t uxIndexToClear) FREERTOS_SYSTEM_CALL;
-uint32_t MPU_ulTaskGenericNotifyValueClear(TaskHandle_t xTask,
-        UBaseType_t uxIndexToClear,
-        uint32_t ulBitsToClear) FREERTOS_SYSTEM_CALL;
-BaseType_t MPU_xTaskIncrementTick(void) FREERTOS_SYSTEM_CALL;
-TaskHandle_t MPU_xTaskGetCurrentTaskHandle(void) FREERTOS_SYSTEM_CALL;
-void MPU_vTaskSetTimeOutState(TimeOut_t * const pxTimeOut) FREERTOS_SYSTEM_CALL;
-BaseType_t MPU_xTaskCheckForTimeOut(TimeOut_t * const pxTimeOut,
-                                    TickType_t * const pxTicksToWait) FREERTOS_SYSTEM_CALL;
-void MPU_vTaskMissedYield(void) FREERTOS_SYSTEM_CALL;
-BaseType_t MPU_xTaskGetSchedulerState(void) FREERTOS_SYSTEM_CALL;
-BaseType_t MPU_xTaskCatchUpTicks(TickType_t xTicksToCatchUp) FREERTOS_SYSTEM_CALL;
+typedef struct xTaskGenericNotifyParams
+{
+    TaskHandle_t xTaskToNotify;
+    UBaseType_t uxIndexToNotify;
+    uint32_t ulValue;
+    eNotifyAction eAction;
+    uint32_t * pulPreviousNotificationValue;
+} xTaskGenericNotifyParams_t;
+
+typedef struct xTaskGenericNotifyWaitParams
+{
+    UBaseType_t uxIndexToWaitOn;
+    uint32_t ulBitsToClearOnEntry;
+    uint32_t ulBitsToClearOnExit;
+    uint32_t * pulNotificationValue;
+    TickType_t xTicksToWait;
+} xTaskGenericNotifyWaitParams_t;
+
+typedef struct xTimerGenericCommandFromTaskParams
+{
+    TimerHandle_t xTimer;
+    BaseType_t xCommandID;
+    TickType_t xOptionalValue;
+    BaseType_t * pxHigherPriorityTaskWoken;
+    TickType_t xTicksToWait;
+} xTimerGenericCommandFromTaskParams_t;
+
+typedef struct xEventGroupWaitBitsParams
+{
+    EventGroupHandle_t xEventGroup;
+    EventBits_t uxBitsToWaitFor;
+    BaseType_t xClearOnExit;
+    BaseType_t xWaitForAllBits;
+    TickType_t xTicksToWait;
+} xEventGroupWaitBitsParams_t;
+
+/* MPU versions of task.h API functions. */
+void MPU_vTaskDelay( const TickType_t xTicksToDelay ) FREERTOS_SYSTEM_CALL;
+BaseType_t MPU_xTaskDelayUntil( TickType_t * const pxPreviousWakeTime,
+                                const TickType_t xTimeIncrement ) FREERTOS_SYSTEM_CALL;
+BaseType_t MPU_xTaskAbortDelay( TaskHandle_t xTask ) FREERTOS_SYSTEM_CALL;
+UBaseType_t MPU_uxTaskPriorityGet( const TaskHandle_t xTask ) FREERTOS_SYSTEM_CALL;
+eTaskState MPU_eTaskGetState( TaskHandle_t xTask ) FREERTOS_SYSTEM_CALL;
+void MPU_vTaskGetInfo( TaskHandle_t xTask,
+                       TaskStatus_t * pxTaskStatus,
+                       BaseType_t xGetFreeStackSpace,
+                       eTaskState eState ) FREERTOS_SYSTEM_CALL;
+void MPU_vTaskSuspend( TaskHandle_t xTaskToSuspend ) FREERTOS_SYSTEM_CALL;
+void MPU_vTaskResume( TaskHandle_t xTaskToResume ) FREERTOS_SYSTEM_CALL;
+TickType_t MPU_xTaskGetTickCount( void ) FREERTOS_SYSTEM_CALL;
+UBaseType_t MPU_uxTaskGetNumberOfTasks( void ) FREERTOS_SYSTEM_CALL;
+UBaseType_t MPU_uxTaskGetStackHighWaterMark( TaskHandle_t xTask ) FREERTOS_SYSTEM_CALL;
+configSTACK_DEPTH_TYPE MPU_uxTaskGetStackHighWaterMark2( TaskHandle_t xTask ) FREERTOS_SYSTEM_CALL;
+void MPU_vTaskSetApplicationTaskTag( TaskHandle_t xTask,
+                                     TaskHookFunction_t pxHookFunction ) FREERTOS_SYSTEM_CALL;
+TaskHookFunction_t MPU_xTaskGetApplicationTaskTag( TaskHandle_t xTask ) FREERTOS_SYSTEM_CALL;
+void MPU_vTaskSetThreadLocalStoragePointer( TaskHandle_t xTaskToSet,
+                                            BaseType_t xIndex,
+                                            void * pvValue ) FREERTOS_SYSTEM_CALL;
+void * MPU_pvTaskGetThreadLocalStoragePointer( TaskHandle_t xTaskToQuery,
+                                               BaseType_t xIndex ) FREERTOS_SYSTEM_CALL;
+TaskHandle_t MPU_xTaskGetIdleTaskHandle( void ) FREERTOS_SYSTEM_CALL;
+UBaseType_t MPU_uxTaskGetSystemState( TaskStatus_t * const pxTaskStatusArray,
+                                      const UBaseType_t uxArraySize,
+                                      configRUN_TIME_COUNTER_TYPE * const pulTotalRunTime ) FREERTOS_SYSTEM_CALL;
+configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetRunTimeCounter( const TaskHandle_t xTask ) FREERTOS_SYSTEM_CALL;
+configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetRunTimePercent( const TaskHandle_t xTask ) FREERTOS_SYSTEM_CALL;
+configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetIdleRunTimeCounter( void ) FREERTOS_SYSTEM_CALL;
+configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetIdleRunTimePercent( void ) FREERTOS_SYSTEM_CALL;
+BaseType_t MPU_xTaskGenericNotify( TaskHandle_t xTaskToNotify,
+                                   UBaseType_t uxIndexToNotify,
+                                   uint32_t ulValue,
+                                   eNotifyAction eAction,
+                                   uint32_t * pulPreviousNotificationValue ) FREERTOS_SYSTEM_CALL;
+BaseType_t MPU_xTaskGenericNotifyEntry( const xTaskGenericNotifyParams_t * pxParams ) FREERTOS_SYSTEM_CALL;
+BaseType_t MPU_xTaskGenericNotifyWait( UBaseType_t uxIndexToWaitOn,
+                                       uint32_t ulBitsToClearOnEntry,
+                                       uint32_t ulBitsToClearOnExit,
+                                       uint32_t * pulNotificationValue,
+                                       TickType_t xTicksToWait ) FREERTOS_SYSTEM_CALL;
+BaseType_t MPU_xTaskGenericNotifyWaitEntry( const xTaskGenericNotifyWaitParams_t * pxParams ) FREERTOS_SYSTEM_CALL;
+uint32_t MPU_ulTaskGenericNotifyTake( UBaseType_t uxIndexToWaitOn,
+                                      BaseType_t xClearCountOnExit,
+                                      TickType_t xTicksToWait ) FREERTOS_SYSTEM_CALL;
+BaseType_t MPU_xTaskGenericNotifyStateClear( TaskHandle_t xTask,
+                                             UBaseType_t uxIndexToClear ) FREERTOS_SYSTEM_CALL;
+uint32_t MPU_ulTaskGenericNotifyValueClear( TaskHandle_t xTask,
+                                            UBaseType_t uxIndexToClear,
+                                            uint32_t ulBitsToClear ) FREERTOS_SYSTEM_CALL;
+void MPU_vTaskSetTimeOutState( TimeOut_t * const pxTimeOut ) FREERTOS_SYSTEM_CALL;
+BaseType_t MPU_xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut,
+                                     TickType_t * const pxTicksToWait ) FREERTOS_SYSTEM_CALL;
+TaskHandle_t MPU_xTaskGetCurrentTaskHandle( void ) FREERTOS_SYSTEM_CALL;
+BaseType_t MPU_xTaskGetSchedulerState( void ) FREERTOS_SYSTEM_CALL;
+
+/* Privileged only wrappers for Task APIs. These are needed so that
+ * the application can use opaque handles maintained in mpu_wrappers.c
+ * with all the APIs. */
+#if ( configUSE_MPU_WRAPPERS_V1 == 1 )
+
+    BaseType_t MPU_xTaskCreate( TaskFunction_t pxTaskCode,
+                                const char * const pcName,
+                                const configSTACK_DEPTH_TYPE uxStackDepth,
+                                void * const pvParameters,
+                                UBaseType_t uxPriority,
+                                TaskHandle_t * const pxCreatedTask ) FREERTOS_SYSTEM_CALL;
+    TaskHandle_t MPU_xTaskCreateStatic( TaskFunction_t pxTaskCode,
+                                        const char * const pcName,
+                                        const configSTACK_DEPTH_TYPE uxStackDepth,
+                                        void * const pvParameters,
+                                        UBaseType_t uxPriority,
+                                        StackType_t * const puxStackBuffer,
+                                        StaticTask_t * const pxTaskBuffer ) FREERTOS_SYSTEM_CALL;
+    void MPU_vTaskDelete( TaskHandle_t xTaskToDelete ) FREERTOS_SYSTEM_CALL;
+    void MPU_vTaskPrioritySet( TaskHandle_t xTask,
+                               UBaseType_t uxNewPriority ) FREERTOS_SYSTEM_CALL;
+    TaskHandle_t MPU_xTaskGetHandle( const char * pcNameToQuery ) FREERTOS_SYSTEM_CALL;
+    BaseType_t MPU_xTaskCallApplicationTaskHook( TaskHandle_t xTask,
+                                                 void * pvParameter ) FREERTOS_SYSTEM_CALL;
+    void MPU_vTaskGetRunTimeStatistics( char * pcWriteBuffer,
+                                        size_t uxBufferLength ) FREERTOS_SYSTEM_CALL;
+    void MPU_vTaskListTasks( char * pcWriteBuffer,
+                             size_t uxBufferLength ) FREERTOS_SYSTEM_CALL;
+    void MPU_vTaskSuspendAll( void ) FREERTOS_SYSTEM_CALL;
+    BaseType_t MPU_xTaskCatchUpTicks( TickType_t xTicksToCatchUp ) FREERTOS_SYSTEM_CALL;
+    BaseType_t MPU_xTaskResumeAll( void ) FREERTOS_SYSTEM_CALL;
+
+#else /* #if ( configUSE_MPU_WRAPPERS_V1 == 1 ) */
+
+    BaseType_t MPU_xTaskCreate( TaskFunction_t pxTaskCode,
+                                const char * const pcName,
+                                const configSTACK_DEPTH_TYPE uxStackDepth,
+                                void * const pvParameters,
+                                UBaseType_t uxPriority,
+                                TaskHandle_t * const pxCreatedTask ) PRIVILEGED_FUNCTION;
+    TaskHandle_t MPU_xTaskCreateStatic( TaskFunction_t pxTaskCode,
+                                        const char * const pcName,
+                                        const configSTACK_DEPTH_TYPE uxStackDepth,
+                                        void * const pvParameters,
+                                        UBaseType_t uxPriority,
+                                        StackType_t * const puxStackBuffer,
+                                        StaticTask_t * const pxTaskBuffer ) PRIVILEGED_FUNCTION;
+    void MPU_vTaskDelete( TaskHandle_t xTaskToDelete ) PRIVILEGED_FUNCTION;
+    void MPU_vTaskPrioritySet( TaskHandle_t xTask,
+                               UBaseType_t uxNewPriority ) PRIVILEGED_FUNCTION;
+    TaskHandle_t MPU_xTaskGetHandle( const char * pcNameToQuery ) PRIVILEGED_FUNCTION;
+    BaseType_t MPU_xTaskCallApplicationTaskHook( TaskHandle_t xTask,
+                                                 void * pvParameter ) PRIVILEGED_FUNCTION;
+
+#endif /* #if ( configUSE_MPU_WRAPPERS_V1 == 1 ) */
+
+char * MPU_pcTaskGetName( TaskHandle_t xTaskToQuery ) PRIVILEGED_FUNCTION;
+BaseType_t MPU_xTaskCreateRestricted( const TaskParameters_t * const pxTaskDefinition,
+                                      TaskHandle_t * pxCreatedTask ) PRIVILEGED_FUNCTION;
+BaseType_t MPU_xTaskCreateRestrictedStatic( const TaskParameters_t * const pxTaskDefinition,
+                                            TaskHandle_t * pxCreatedTask ) PRIVILEGED_FUNCTION;
+void MPU_vTaskAllocateMPURegions( TaskHandle_t xTaskToModify,
+                                  const MemoryRegion_t * const xRegions ) PRIVILEGED_FUNCTION;
+BaseType_t MPU_xTaskGetStaticBuffers( TaskHandle_t xTask,
+                                      StackType_t ** ppuxStackBuffer,
+                                      StaticTask_t ** ppxTaskBuffer ) PRIVILEGED_FUNCTION;
+UBaseType_t MPU_uxTaskPriorityGetFromISR( const TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
+UBaseType_t MPU_uxTaskBasePriorityGet( const TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
+UBaseType_t MPU_uxTaskBasePriorityGetFromISR( const TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
+BaseType_t MPU_xTaskResumeFromISR( TaskHandle_t xTaskToResume ) PRIVILEGED_FUNCTION;
+TaskHookFunction_t MPU_xTaskGetApplicationTaskTagFromISR( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
+BaseType_t MPU_xTaskGenericNotifyFromISR( TaskHandle_t xTaskToNotify,
+                                          UBaseType_t uxIndexToNotify,
+                                          uint32_t ulValue,
+                                          eNotifyAction eAction,
+                                          uint32_t * pulPreviousNotificationValue,
+                                          BaseType_t * pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;
+void MPU_vTaskGenericNotifyGiveFromISR( TaskHandle_t xTaskToNotify,
+                                        UBaseType_t uxIndexToNotify,
+                                        BaseType_t * pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;
 
 /* MPU versions of queue.h API functions. */
-BaseType_t MPU_xQueueGenericSend(QueueHandle_t xQueue,
-                                 const void * const pvItemToQueue,
-                                 TickType_t xTicksToWait,
-                                 const BaseType_t xCopyPosition) FREERTOS_SYSTEM_CALL;
-BaseType_t MPU_xQueueReceive(QueueHandle_t xQueue,
-                             void * const pvBuffer,
-                             TickType_t xTicksToWait) FREERTOS_SYSTEM_CALL;
-BaseType_t MPU_xQueuePeek(QueueHandle_t xQueue,
-                          void * const pvBuffer,
-                          TickType_t xTicksToWait) FREERTOS_SYSTEM_CALL;
-BaseType_t MPU_xQueueSemaphoreTake(QueueHandle_t xQueue,
-                                   TickType_t xTicksToWait) FREERTOS_SYSTEM_CALL;
-UBaseType_t MPU_uxQueueMessagesWaiting(const QueueHandle_t xQueue) FREERTOS_SYSTEM_CALL;
-UBaseType_t MPU_uxQueueSpacesAvailable(const QueueHandle_t xQueue) FREERTOS_SYSTEM_CALL;
-void MPU_vQueueDelete(QueueHandle_t xQueue) FREERTOS_SYSTEM_CALL;
-QueueHandle_t MPU_xQueueCreateMutex(const uint8_t ucQueueType) FREERTOS_SYSTEM_CALL;
-QueueHandle_t MPU_xQueueCreateMutexStatic(const uint8_t ucQueueType,
-        StaticQueue_t * pxStaticQueue) FREERTOS_SYSTEM_CALL;
-QueueHandle_t MPU_xQueueCreateCountingSemaphore(const UBaseType_t uxMaxCount,
-        const UBaseType_t uxInitialCount) FREERTOS_SYSTEM_CALL;
-QueueHandle_t MPU_xQueueCreateCountingSemaphoreStatic(const UBaseType_t uxMaxCount,
-        const UBaseType_t uxInitialCount,
-        StaticQueue_t * pxStaticQueue) FREERTOS_SYSTEM_CALL;
-TaskHandle_t MPU_xQueueGetMutexHolder(QueueHandle_t xSemaphore) FREERTOS_SYSTEM_CALL;
-BaseType_t MPU_xQueueTakeMutexRecursive(QueueHandle_t xMutex,
-                                        TickType_t xTicksToWait) FREERTOS_SYSTEM_CALL;
-BaseType_t MPU_xQueueGiveMutexRecursive(QueueHandle_t pxMutex) FREERTOS_SYSTEM_CALL;
-void MPU_vQueueAddToRegistry(QueueHandle_t xQueue,
-                             const char * pcName) FREERTOS_SYSTEM_CALL;
-void MPU_vQueueUnregisterQueue(QueueHandle_t xQueue) FREERTOS_SYSTEM_CALL;
-const char * MPU_pcQueueGetName(QueueHandle_t xQueue) FREERTOS_SYSTEM_CALL;
-QueueHandle_t MPU_xQueueGenericCreate(const UBaseType_t uxQueueLength,
-                                      const UBaseType_t uxItemSize,
-                                      const uint8_t ucQueueType) FREERTOS_SYSTEM_CALL;
-QueueHandle_t MPU_xQueueGenericCreateStatic(const UBaseType_t uxQueueLength,
-        const UBaseType_t uxItemSize,
-        uint8_t * pucQueueStorage,
-        StaticQueue_t * pxStaticQueue,
-        const uint8_t ucQueueType) FREERTOS_SYSTEM_CALL;
-QueueSetHandle_t MPU_xQueueCreateSet(const UBaseType_t uxEventQueueLength) FREERTOS_SYSTEM_CALL;
-BaseType_t MPU_xQueueAddToSet(QueueSetMemberHandle_t xQueueOrSemaphore,
-                              QueueSetHandle_t xQueueSet) FREERTOS_SYSTEM_CALL;
-BaseType_t MPU_xQueueRemoveFromSet(QueueSetMemberHandle_t xQueueOrSemaphore,
-                                   QueueSetHandle_t xQueueSet) FREERTOS_SYSTEM_CALL;
-QueueSetMemberHandle_t MPU_xQueueSelectFromSet(QueueSetHandle_t xQueueSet,
-        const TickType_t xTicksToWait) FREERTOS_SYSTEM_CALL;
-BaseType_t MPU_xQueueGenericReset(QueueHandle_t xQueue,
-                                  BaseType_t xNewQueue) FREERTOS_SYSTEM_CALL;
-void MPU_vQueueSetQueueNumber(QueueHandle_t xQueue,
-                              UBaseType_t uxQueueNumber) FREERTOS_SYSTEM_CALL;
-UBaseType_t MPU_uxQueueGetQueueNumber(QueueHandle_t xQueue) FREERTOS_SYSTEM_CALL;
-uint8_t MPU_ucQueueGetQueueType(QueueHandle_t xQueue) FREERTOS_SYSTEM_CALL;
+BaseType_t MPU_xQueueGenericSend( QueueHandle_t xQueue,
+                                  const void * const pvItemToQueue,
+                                  TickType_t xTicksToWait,
+                                  const BaseType_t xCopyPosition ) FREERTOS_SYSTEM_CALL;
+BaseType_t MPU_xQueueReceive( QueueHandle_t xQueue,
+                              void * const pvBuffer,
+                              TickType_t xTicksToWait ) FREERTOS_SYSTEM_CALL;
+BaseType_t MPU_xQueuePeek( QueueHandle_t xQueue,
+                           void * const pvBuffer,
+                           TickType_t xTicksToWait ) FREERTOS_SYSTEM_CALL;
+BaseType_t MPU_xQueueSemaphoreTake( QueueHandle_t xQueue,
+                                    TickType_t xTicksToWait ) FREERTOS_SYSTEM_CALL;
+UBaseType_t MPU_uxQueueMessagesWaiting( const QueueHandle_t xQueue ) FREERTOS_SYSTEM_CALL;
+UBaseType_t MPU_uxQueueSpacesAvailable( const QueueHandle_t xQueue ) FREERTOS_SYSTEM_CALL;
+TaskHandle_t MPU_xQueueGetMutexHolder( QueueHandle_t xSemaphore ) FREERTOS_SYSTEM_CALL;
+BaseType_t MPU_xQueueTakeMutexRecursive( QueueHandle_t xMutex,
+                                         TickType_t xTicksToWait ) FREERTOS_SYSTEM_CALL;
+BaseType_t MPU_xQueueGiveMutexRecursive( QueueHandle_t pxMutex ) FREERTOS_SYSTEM_CALL;
+void MPU_vQueueAddToRegistry( QueueHandle_t xQueue,
+                              const char * pcName ) FREERTOS_SYSTEM_CALL;
+void MPU_vQueueUnregisterQueue( QueueHandle_t xQueue ) FREERTOS_SYSTEM_CALL;
+const char * MPU_pcQueueGetName( QueueHandle_t xQueue ) FREERTOS_SYSTEM_CALL;
+BaseType_t MPU_xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore,
+                               QueueSetHandle_t xQueueSet ) FREERTOS_SYSTEM_CALL;
+QueueSetMemberHandle_t MPU_xQueueSelectFromSet( QueueSetHandle_t xQueueSet,
+                                                const TickType_t xTicksToWait ) FREERTOS_SYSTEM_CALL;
+void MPU_vQueueSetQueueNumber( QueueHandle_t xQueue,
+                               UBaseType_t uxQueueNumber ) FREERTOS_SYSTEM_CALL;
+UBaseType_t MPU_uxQueueGetQueueNumber( QueueHandle_t xQueue ) FREERTOS_SYSTEM_CALL;
+uint8_t MPU_ucQueueGetQueueType( QueueHandle_t xQueue ) FREERTOS_SYSTEM_CALL;
+
+/* Privileged only wrappers for Queue APIs. These are needed so that
+ * the application can use opaque handles maintained in mpu_wrappers.c
+ * with all the APIs. */
+#if ( configUSE_MPU_WRAPPERS_V1 == 1 )
+
+    void MPU_vQueueDelete( QueueHandle_t xQueue ) FREERTOS_SYSTEM_CALL;
+    QueueHandle_t MPU_xQueueCreateMutex( const uint8_t ucQueueType ) FREERTOS_SYSTEM_CALL;
+    QueueHandle_t MPU_xQueueCreateMutexStatic( const uint8_t ucQueueType,
+                                               StaticQueue_t * pxStaticQueue ) FREERTOS_SYSTEM_CALL;
+    QueueHandle_t MPU_xQueueCreateCountingSemaphore( const UBaseType_t uxMaxCount,
+                                                     const UBaseType_t uxInitialCount ) FREERTOS_SYSTEM_CALL;
+    QueueHandle_t MPU_xQueueCreateCountingSemaphoreStatic( const UBaseType_t uxMaxCount,
+                                                           const UBaseType_t uxInitialCount,
+                                                           StaticQueue_t * pxStaticQueue ) FREERTOS_SYSTEM_CALL;
+    QueueHandle_t MPU_xQueueGenericCreate( const UBaseType_t uxQueueLength,
+                                           const UBaseType_t uxItemSize,
+                                           const uint8_t ucQueueType ) FREERTOS_SYSTEM_CALL;
+    QueueHandle_t MPU_xQueueGenericCreateStatic( const UBaseType_t uxQueueLength,
+                                                 const UBaseType_t uxItemSize,
+                                                 uint8_t * pucQueueStorage,
+                                                 StaticQueue_t * pxStaticQueue,
+                                                 const uint8_t ucQueueType ) FREERTOS_SYSTEM_CALL;
+    QueueSetHandle_t MPU_xQueueCreateSet( const UBaseType_t uxEventQueueLength ) FREERTOS_SYSTEM_CALL;
+    QueueSetHandle_t MPU_xQueueCreateSetStatic( const UBaseType_t uxEventQueueLength,
+                                                uint8_t * pucQueueStorage,
+                                                StaticQueue_t * pxStaticQueue ) FREERTOS_SYSTEM_CALL;
+    BaseType_t MPU_xQueueRemoveFromSet( QueueSetMemberHandle_t xQueueOrSemaphore,
+                                        QueueSetHandle_t xQueueSet ) FREERTOS_SYSTEM_CALL;
+    BaseType_t MPU_xQueueGenericReset( QueueHandle_t xQueue,
+                                       BaseType_t xNewQueue ) FREERTOS_SYSTEM_CALL;
+
+#else /* #if ( configUSE_MPU_WRAPPERS_V1 == 1 ) */
+
+    void MPU_vQueueDelete( QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
+    QueueHandle_t MPU_xQueueCreateMutex( const uint8_t ucQueueType ) PRIVILEGED_FUNCTION;
+    QueueHandle_t MPU_xQueueCreateMutexStatic( const uint8_t ucQueueType,
+                                               StaticQueue_t * pxStaticQueue ) PRIVILEGED_FUNCTION;
+    QueueHandle_t MPU_xQueueCreateCountingSemaphore( const UBaseType_t uxMaxCount,
+                                                     const UBaseType_t uxInitialCount ) PRIVILEGED_FUNCTION;
+    QueueHandle_t MPU_xQueueCreateCountingSemaphoreStatic( const UBaseType_t uxMaxCount,
+                                                           const UBaseType_t uxInitialCount,
+                                                           StaticQueue_t * pxStaticQueue ) PRIVILEGED_FUNCTION;
+    QueueHandle_t MPU_xQueueGenericCreate( const UBaseType_t uxQueueLength,
+                                           const UBaseType_t uxItemSize,
+                                           const uint8_t ucQueueType ) PRIVILEGED_FUNCTION;
+    QueueHandle_t MPU_xQueueGenericCreateStatic( const UBaseType_t uxQueueLength,
+                                                 const UBaseType_t uxItemSize,
+                                                 uint8_t * pucQueueStorage,
+                                                 StaticQueue_t * pxStaticQueue,
+                                                 const uint8_t ucQueueType ) PRIVILEGED_FUNCTION;
+    QueueSetHandle_t MPU_xQueueCreateSet( const UBaseType_t uxEventQueueLength ) PRIVILEGED_FUNCTION;
+    QueueSetHandle_t MPU_xQueueCreateSetStatic( const UBaseType_t uxEventQueueLength,
+                                                uint8_t * pucQueueStorage,
+                                                StaticQueue_t * pxStaticQueue ) PRIVILEGED_FUNCTION;
+    BaseType_t MPU_xQueueRemoveFromSet( QueueSetMemberHandle_t xQueueOrSemaphore,
+                                        QueueSetHandle_t xQueueSet ) PRIVILEGED_FUNCTION;
+    BaseType_t MPU_xQueueGenericReset( QueueHandle_t xQueue,
+                                       BaseType_t xNewQueue ) PRIVILEGED_FUNCTION;
+
+#endif /* #if ( configUSE_MPU_WRAPPERS_V1 == 1 ) */
+
+BaseType_t MPU_xQueueGenericGetStaticBuffers( QueueHandle_t xQueue,
+                                              uint8_t ** ppucQueueStorage,
+                                              StaticQueue_t ** ppxStaticQueue ) PRIVILEGED_FUNCTION;
+BaseType_t MPU_xQueueGenericSendFromISR( QueueHandle_t xQueue,
+                                         const void * const pvItemToQueue,
+                                         BaseType_t * const pxHigherPriorityTaskWoken,
+                                         const BaseType_t xCopyPosition ) PRIVILEGED_FUNCTION;
+BaseType_t MPU_xQueueGiveFromISR( QueueHandle_t xQueue,
+                                  BaseType_t * const pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;
+BaseType_t MPU_xQueuePeekFromISR( QueueHandle_t xQueue,
+                                  void * const pvBuffer ) PRIVILEGED_FUNCTION;
+BaseType_t MPU_xQueueReceiveFromISR( QueueHandle_t xQueue,
+                                     void * const pvBuffer,
+                                     BaseType_t * const pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;
+BaseType_t MPU_xQueueIsQueueEmptyFromISR( const QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
+BaseType_t MPU_xQueueIsQueueFullFromISR( const QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
+UBaseType_t MPU_uxQueueMessagesWaitingFromISR( const QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
+TaskHandle_t MPU_xQueueGetMutexHolderFromISR( QueueHandle_t xSemaphore ) PRIVILEGED_FUNCTION;
+QueueSetMemberHandle_t MPU_xQueueSelectFromSetFromISR( QueueSetHandle_t xQueueSet ) PRIVILEGED_FUNCTION;
 
 /* MPU versions of timers.h API functions. */
-TimerHandle_t MPU_xTimerCreate(const char * const pcTimerName,
-                               const TickType_t xTimerPeriodInTicks,
-                               const UBaseType_t uxAutoReload,
-                               void * const pvTimerID,
-                               TimerCallbackFunction_t pxCallbackFunction) FREERTOS_SYSTEM_CALL;
-TimerHandle_t MPU_xTimerCreateStatic(const char * const pcTimerName,
-                                     const TickType_t xTimerPeriodInTicks,
-                                     const UBaseType_t uxAutoReload,
-                                     void * const pvTimerID,
-                                     TimerCallbackFunction_t pxCallbackFunction,
-                                     StaticTimer_t * pxTimerBuffer) FREERTOS_SYSTEM_CALL;
-void * MPU_pvTimerGetTimerID(const TimerHandle_t xTimer) FREERTOS_SYSTEM_CALL;
-void MPU_vTimerSetTimerID(TimerHandle_t xTimer,
-                          void * pvNewID) FREERTOS_SYSTEM_CALL;
-BaseType_t MPU_xTimerIsTimerActive(TimerHandle_t xTimer) FREERTOS_SYSTEM_CALL;
-TaskHandle_t MPU_xTimerGetTimerDaemonTaskHandle(void) FREERTOS_SYSTEM_CALL;
-BaseType_t MPU_xTimerPendFunctionCall(PendedFunction_t xFunctionToPend,
-                                      void * pvParameter1,
-                                      uint32_t ulParameter2,
-                                      TickType_t xTicksToWait) FREERTOS_SYSTEM_CALL;
-const char * MPU_pcTimerGetName(TimerHandle_t xTimer) FREERTOS_SYSTEM_CALL;
-void MPU_vTimerSetReloadMode(TimerHandle_t xTimer,
-                             const UBaseType_t uxAutoReload) FREERTOS_SYSTEM_CALL;
-UBaseType_t MPU_uxTimerGetReloadMode(TimerHandle_t xTimer) FREERTOS_SYSTEM_CALL;
-TickType_t MPU_xTimerGetPeriod(TimerHandle_t xTimer) FREERTOS_SYSTEM_CALL;
-TickType_t MPU_xTimerGetExpiryTime(TimerHandle_t xTimer) FREERTOS_SYSTEM_CALL;
-BaseType_t MPU_xTimerCreateTimerTask(void) FREERTOS_SYSTEM_CALL;
-BaseType_t MPU_xTimerGenericCommand(TimerHandle_t xTimer,
-                                    const BaseType_t xCommandID,
-                                    const TickType_t xOptionalValue,
-                                    BaseType_t * const pxHigherPriorityTaskWoken,
-                                    const TickType_t xTicksToWait) FREERTOS_SYSTEM_CALL;
+void * MPU_pvTimerGetTimerID( const TimerHandle_t xTimer ) FREERTOS_SYSTEM_CALL;
+void MPU_vTimerSetTimerID( TimerHandle_t xTimer,
+                           void * pvNewID ) FREERTOS_SYSTEM_CALL;
+BaseType_t MPU_xTimerIsTimerActive( TimerHandle_t xTimer ) FREERTOS_SYSTEM_CALL;
+TaskHandle_t MPU_xTimerGetTimerDaemonTaskHandle( void ) FREERTOS_SYSTEM_CALL;
+BaseType_t MPU_xTimerGenericCommandFromTask( TimerHandle_t xTimer,
+                                             const BaseType_t xCommandID,
+                                             const TickType_t xOptionalValue,
+                                             BaseType_t * const pxHigherPriorityTaskWoken,
+                                             const TickType_t xTicksToWait ) FREERTOS_SYSTEM_CALL;
+BaseType_t MPU_xTimerGenericCommandFromTaskEntry( const xTimerGenericCommandFromTaskParams_t * pxParams ) FREERTOS_SYSTEM_CALL;
+const char * MPU_pcTimerGetName( TimerHandle_t xTimer ) FREERTOS_SYSTEM_CALL;
+void MPU_vTimerSetReloadMode( TimerHandle_t xTimer,
+                              const BaseType_t xAutoReload ) FREERTOS_SYSTEM_CALL;
+BaseType_t MPU_xTimerGetReloadMode( TimerHandle_t xTimer ) FREERTOS_SYSTEM_CALL;
+UBaseType_t MPU_uxTimerGetReloadMode( TimerHandle_t xTimer ) FREERTOS_SYSTEM_CALL;
+TickType_t MPU_xTimerGetPeriod( TimerHandle_t xTimer ) FREERTOS_SYSTEM_CALL;
+TickType_t MPU_xTimerGetExpiryTime( TimerHandle_t xTimer ) FREERTOS_SYSTEM_CALL;
+
+/* Privileged only wrappers for Timer APIs. These are needed so that
+ * the application can use opaque handles maintained in mpu_wrappers.c
+ * with all the APIs. */
+TimerHandle_t MPU_xTimerCreate( const char * const pcTimerName,
+                                const TickType_t xTimerPeriodInTicks,
+                                const BaseType_t xAutoReload,
+                                void * const pvTimerID,
+                                TimerCallbackFunction_t pxCallbackFunction ) PRIVILEGED_FUNCTION;
+TimerHandle_t MPU_xTimerCreateStatic( const char * const pcTimerName,
+                                      const TickType_t xTimerPeriodInTicks,
+                                      const BaseType_t xAutoReload,
+                                      void * const pvTimerID,
+                                      TimerCallbackFunction_t pxCallbackFunction,
+                                      StaticTimer_t * pxTimerBuffer ) PRIVILEGED_FUNCTION;
+BaseType_t MPU_xTimerGetStaticBuffer( TimerHandle_t xTimer,
+                                      StaticTimer_t ** ppxTimerBuffer ) PRIVILEGED_FUNCTION;
+BaseType_t MPU_xTimerGenericCommandFromISR( TimerHandle_t xTimer,
+                                            const BaseType_t xCommandID,
+                                            const TickType_t xOptionalValue,
+                                            BaseType_t * const pxHigherPriorityTaskWoken,
+                                            const TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
 
 /* MPU versions of event_group.h API functions. */
-EventGroupHandle_t MPU_xEventGroupCreate(void) FREERTOS_SYSTEM_CALL;
-EventGroupHandle_t MPU_xEventGroupCreateStatic(StaticEventGroup_t * pxEventGroupBuffer) FREERTOS_SYSTEM_CALL;
-EventBits_t MPU_xEventGroupWaitBits(EventGroupHandle_t xEventGroup,
-                                    const EventBits_t uxBitsToWaitFor,
-                                    const BaseType_t xClearOnExit,
-                                    const BaseType_t xWaitForAllBits,
-                                    TickType_t xTicksToWait) FREERTOS_SYSTEM_CALL;
-EventBits_t MPU_xEventGroupClearBits(EventGroupHandle_t xEventGroup,
-                                     const EventBits_t uxBitsToClear) FREERTOS_SYSTEM_CALL;
-EventBits_t MPU_xEventGroupSetBits(EventGroupHandle_t xEventGroup,
-                                   const EventBits_t uxBitsToSet) FREERTOS_SYSTEM_CALL;
-EventBits_t MPU_xEventGroupSync(EventGroupHandle_t xEventGroup,
-                                const EventBits_t uxBitsToSet,
-                                const EventBits_t uxBitsToWaitFor,
-                                TickType_t xTicksToWait) FREERTOS_SYSTEM_CALL;
-void MPU_vEventGroupDelete(EventGroupHandle_t xEventGroup) FREERTOS_SYSTEM_CALL;
-UBaseType_t MPU_uxEventGroupGetNumber(void * xEventGroup) FREERTOS_SYSTEM_CALL;
+EventBits_t MPU_xEventGroupWaitBits( EventGroupHandle_t xEventGroup,
+                                     const EventBits_t uxBitsToWaitFor,
+                                     const BaseType_t xClearOnExit,
+                                     const BaseType_t xWaitForAllBits,
+                                     TickType_t xTicksToWait ) FREERTOS_SYSTEM_CALL;
+EventBits_t MPU_xEventGroupWaitBitsEntry( const xEventGroupWaitBitsParams_t * pxParams ) FREERTOS_SYSTEM_CALL;
+EventBits_t MPU_xEventGroupClearBits( EventGroupHandle_t xEventGroup,
+                                      const EventBits_t uxBitsToClear ) FREERTOS_SYSTEM_CALL;
+EventBits_t MPU_xEventGroupSetBits( EventGroupHandle_t xEventGroup,
+                                    const EventBits_t uxBitsToSet ) FREERTOS_SYSTEM_CALL;
+EventBits_t MPU_xEventGroupSync( EventGroupHandle_t xEventGroup,
+                                 const EventBits_t uxBitsToSet,
+                                 const EventBits_t uxBitsToWaitFor,
+                                 TickType_t xTicksToWait ) FREERTOS_SYSTEM_CALL;
+#if ( configUSE_TRACE_FACILITY == 1 )
+    UBaseType_t MPU_uxEventGroupGetNumber( void * xEventGroup ) FREERTOS_SYSTEM_CALL;
+    void MPU_vEventGroupSetNumber( void * xEventGroup,
+                                   UBaseType_t uxEventGroupNumber ) FREERTOS_SYSTEM_CALL;
+#endif /* #if ( configUSE_TRACE_FACILITY == 1 ) */
+
+/* Privileged only wrappers for Event Group APIs. These are needed so that
+ * the application can use opaque handles maintained in mpu_wrappers.c
+ * with all the APIs. */
+#if ( configUSE_MPU_WRAPPERS_V1 == 1 )
+
+    EventGroupHandle_t MPU_xEventGroupCreate( void ) FREERTOS_SYSTEM_CALL;
+    EventGroupHandle_t MPU_xEventGroupCreateStatic( StaticEventGroup_t * pxEventGroupBuffer ) FREERTOS_SYSTEM_CALL;
+    void MPU_vEventGroupDelete( EventGroupHandle_t xEventGroup ) FREERTOS_SYSTEM_CALL;
+
+#else /* #if ( configUSE_MPU_WRAPPERS_V1 == 1 ) */
+
+    EventGroupHandle_t MPU_xEventGroupCreate( void ) PRIVILEGED_FUNCTION;
+    EventGroupHandle_t MPU_xEventGroupCreateStatic( StaticEventGroup_t * pxEventGroupBuffer ) PRIVILEGED_FUNCTION;
+    void MPU_vEventGroupDelete( EventGroupHandle_t xEventGroup ) PRIVILEGED_FUNCTION;
+
+#endif /* #if ( configUSE_MPU_WRAPPERS_V1 == 1 ) */
+
+BaseType_t MPU_xEventGroupGetStaticBuffer( EventGroupHandle_t xEventGroup,
+                                           StaticEventGroup_t ** ppxEventGroupBuffer ) PRIVILEGED_FUNCTION;
+EventBits_t MPU_xEventGroupGetBitsFromISR( EventGroupHandle_t xEventGroup ) PRIVILEGED_FUNCTION;
+
+#if ( configUSE_MPU_WRAPPERS_V1 == 0 )
+    BaseType_t MPU_xEventGroupClearBitsFromISR( EventGroupHandle_t xEventGroup,
+                                                const EventBits_t uxBitsToClear ) FREERTOS_SYSTEM_CALL;
+    BaseType_t MPU_xEventGroupSetBitsFromISR( EventGroupHandle_t xEventGroup,
+                                              const EventBits_t uxBitsToSet,
+                                              BaseType_t * pxHigherPriorityTaskWoken ) FREERTOS_SYSTEM_CALL;
+#endif /* #if ( configUSE_MPU_WRAPPERS_V1 == 0 ) */
 
 /* MPU versions of message/stream_buffer.h API functions. */
-size_t MPU_xStreamBufferSend(StreamBufferHandle_t xStreamBuffer,
-                             const void * pvTxData,
-                             size_t xDataLengthBytes,
-                             TickType_t xTicksToWait) FREERTOS_SYSTEM_CALL;
-size_t MPU_xStreamBufferReceive(StreamBufferHandle_t xStreamBuffer,
-                                void * pvRxData,
-                                size_t xBufferLengthBytes,
-                                TickType_t xTicksToWait) FREERTOS_SYSTEM_CALL;
-size_t MPU_xStreamBufferNextMessageLengthBytes(StreamBufferHandle_t xStreamBuffer) FREERTOS_SYSTEM_CALL;
-void MPU_vStreamBufferDelete(StreamBufferHandle_t xStreamBuffer) FREERTOS_SYSTEM_CALL;
-BaseType_t MPU_xStreamBufferIsFull(StreamBufferHandle_t xStreamBuffer) FREERTOS_SYSTEM_CALL;
-BaseType_t MPU_xStreamBufferIsEmpty(StreamBufferHandle_t xStreamBuffer) FREERTOS_SYSTEM_CALL;
-BaseType_t MPU_xStreamBufferReset(StreamBufferHandle_t xStreamBuffer) FREERTOS_SYSTEM_CALL;
-size_t MPU_xStreamBufferSpacesAvailable(StreamBufferHandle_t xStreamBuffer) FREERTOS_SYSTEM_CALL;
-size_t MPU_xStreamBufferBytesAvailable(StreamBufferHandle_t xStreamBuffer) FREERTOS_SYSTEM_CALL;
-BaseType_t MPU_xStreamBufferSetTriggerLevel(StreamBufferHandle_t xStreamBuffer,
-        size_t xTriggerLevel) FREERTOS_SYSTEM_CALL;
-StreamBufferHandle_t MPU_xStreamBufferGenericCreate(size_t xBufferSizeBytes,
-        size_t xTriggerLevelBytes,
-        BaseType_t xIsMessageBuffer) FREERTOS_SYSTEM_CALL;
-StreamBufferHandle_t MPU_xStreamBufferGenericCreateStatic(size_t xBufferSizeBytes,
-        size_t xTriggerLevelBytes,
-        BaseType_t xIsMessageBuffer,
-        uint8_t * const pucStreamBufferStorageArea,
-        StaticStreamBuffer_t * const pxStaticStreamBuffer) FREERTOS_SYSTEM_CALL;
+size_t MPU_xStreamBufferSend( StreamBufferHandle_t xStreamBuffer,
+                              const void * pvTxData,
+                              size_t xDataLengthBytes,
+                              TickType_t xTicksToWait ) FREERTOS_SYSTEM_CALL;
+size_t MPU_xStreamBufferReceive( StreamBufferHandle_t xStreamBuffer,
+                                 void * pvRxData,
+                                 size_t xBufferLengthBytes,
+                                 TickType_t xTicksToWait ) FREERTOS_SYSTEM_CALL;
+BaseType_t MPU_xStreamBufferIsFull( StreamBufferHandle_t xStreamBuffer ) FREERTOS_SYSTEM_CALL;
+BaseType_t MPU_xStreamBufferIsEmpty( StreamBufferHandle_t xStreamBuffer ) FREERTOS_SYSTEM_CALL;
+size_t MPU_xStreamBufferSpacesAvailable( StreamBufferHandle_t xStreamBuffer ) FREERTOS_SYSTEM_CALL;
+size_t MPU_xStreamBufferBytesAvailable( StreamBufferHandle_t xStreamBuffer ) FREERTOS_SYSTEM_CALL;
+BaseType_t MPU_xStreamBufferSetTriggerLevel( StreamBufferHandle_t xStreamBuffer,
+                                             size_t xTriggerLevel ) FREERTOS_SYSTEM_CALL;
+size_t MPU_xStreamBufferNextMessageLengthBytes( StreamBufferHandle_t xStreamBuffer ) FREERTOS_SYSTEM_CALL;
+
+/* Privileged only wrappers for Stream Buffer APIs. These are needed so that
+ * the application can use opaque handles maintained in mpu_wrappers.c
+ * with all the APIs. */
+#if ( configUSE_MPU_WRAPPERS_V1 == 1 )
+
+    StreamBufferHandle_t MPU_xStreamBufferGenericCreate( size_t xBufferSizeBytes,
+                                                         size_t xTriggerLevelBytes,
+                                                         BaseType_t xStreamBufferType,
+                                                         StreamBufferCallbackFunction_t pxSendCompletedCallback,
+                                                         StreamBufferCallbackFunction_t pxReceiveCompletedCallback ) FREERTOS_SYSTEM_CALL;
+    StreamBufferHandle_t MPU_xStreamBufferGenericCreateStatic( size_t xBufferSizeBytes,
+                                                               size_t xTriggerLevelBytes,
+                                                               BaseType_t xStreamBufferType,
+                                                               uint8_t * const pucStreamBufferStorageArea,
+                                                               StaticStreamBuffer_t * const pxStaticStreamBuffer,
+                                                               StreamBufferCallbackFunction_t pxSendCompletedCallback,
+                                                               StreamBufferCallbackFunction_t pxReceiveCompletedCallback ) FREERTOS_SYSTEM_CALL;
+    void MPU_vStreamBufferDelete( StreamBufferHandle_t xStreamBuffer ) FREERTOS_SYSTEM_CALL;
+    BaseType_t MPU_xStreamBufferReset( StreamBufferHandle_t xStreamBuffer ) FREERTOS_SYSTEM_CALL;
+
+#else /* #if ( configUSE_MPU_WRAPPERS_V1 == 1 ) */
+
+    StreamBufferHandle_t MPU_xStreamBufferGenericCreate( size_t xBufferSizeBytes,
+                                                         size_t xTriggerLevelBytes,
+                                                         BaseType_t xStreamBufferType,
+                                                         StreamBufferCallbackFunction_t pxSendCompletedCallback,
+                                                         StreamBufferCallbackFunction_t pxReceiveCompletedCallback ) PRIVILEGED_FUNCTION;
+    StreamBufferHandle_t MPU_xStreamBufferGenericCreateStatic( size_t xBufferSizeBytes,
+                                                               size_t xTriggerLevelBytes,
+                                                               BaseType_t xStreamBufferType,
+                                                               uint8_t * const pucStreamBufferStorageArea,
+                                                               StaticStreamBuffer_t * const pxStaticStreamBuffer,
+                                                               StreamBufferCallbackFunction_t pxSendCompletedCallback,
+                                                               StreamBufferCallbackFunction_t pxReceiveCompletedCallback ) PRIVILEGED_FUNCTION;
+    void MPU_vStreamBufferDelete( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;
+    BaseType_t MPU_xStreamBufferReset( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;
 
+#endif /* #if ( configUSE_MPU_WRAPPERS_V1 == 1 ) */
 
+BaseType_t MPU_xStreamBufferGetStaticBuffers( StreamBufferHandle_t xStreamBuffers,
+                                              uint8_t * ppucStreamBufferStorageArea,
+                                              StaticStreamBuffer_t * ppxStaticStreamBuffer ) PRIVILEGED_FUNCTION;
+size_t MPU_xStreamBufferSendFromISR( StreamBufferHandle_t xStreamBuffer,
+                                     const void * pvTxData,
+                                     size_t xDataLengthBytes,
+                                     BaseType_t * const pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;
+size_t MPU_xStreamBufferReceiveFromISR( StreamBufferHandle_t xStreamBuffer,
+                                        void * pvRxData,
+                                        size_t xBufferLengthBytes,
+                                        BaseType_t * const pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;
+BaseType_t MPU_xStreamBufferSendCompletedFromISR( StreamBufferHandle_t xStreamBuffer,
+                                                  BaseType_t * pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;
+BaseType_t MPU_xStreamBufferReceiveCompletedFromISR( StreamBufferHandle_t xStreamBuffer,
+                                                     BaseType_t * pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;
+BaseType_t MPU_xStreamBufferResetFromISR( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;
 
 #endif /* MPU_PROTOTYPES_H */

### external/FreeRTOS/Source/include/mpu_syscall_numbers.h
@@ -0,0 +1,105 @@
+/*
+ * FreeRTOS Kernel V11.3.0
+ * Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ *
+ */
+
+#ifndef MPU_SYSCALL_NUMBERS_H
+#define MPU_SYSCALL_NUMBERS_H
+
+/* Numbers assigned to various system calls. */
+#define SYSTEM_CALL_xTaskGenericNotify                     0
+#define SYSTEM_CALL_xTaskGenericNotifyWait                 1
+#define SYSTEM_CALL_xTimerGenericCommandFromTask           2
+#define SYSTEM_CALL_xEventGroupWaitBits                    3
+#define SYSTEM_CALL_xTaskDelayUntil                        4
+#define SYSTEM_CALL_xTaskAbortDelay                        5
+#define SYSTEM_CALL_vTaskDelay                             6
+#define SYSTEM_CALL_uxTaskPriorityGet                      7
+#define SYSTEM_CALL_eTaskGetState                          8
+#define SYSTEM_CALL_vTaskGetInfo                           9
+#define SYSTEM_CALL_xTaskGetIdleTaskHandle                 10
+#define SYSTEM_CALL_vTaskSuspend                           11
+#define SYSTEM_CALL_vTaskResume                            12
+#define SYSTEM_CALL_xTaskGetTickCount                      13
+#define SYSTEM_CALL_uxTaskGetNumberOfTasks                 14
+#define SYSTEM_CALL_ulTaskGetRunTimeCounter                15
+#define SYSTEM_CALL_ulTaskGetRunTimePercent                16
+#define SYSTEM_CALL_ulTaskGetIdleRunTimePercent            17
+#define SYSTEM_CALL_ulTaskGetIdleRunTimeCounter            18
+#define SYSTEM_CALL_vTaskSetApplicationTaskTag             19
+#define SYSTEM_CALL_xTaskGetApplicationTaskTag             20
+#define SYSTEM_CALL_vTaskSetThreadLocalStoragePointer      21
+#define SYSTEM_CALL_pvTaskGetThreadLocalStoragePointer     22
+#define SYSTEM_CALL_uxTaskGetSystemState                   23
+#define SYSTEM_CALL_uxTaskGetStackHighWaterMark            24
+#define SYSTEM_CALL_uxTaskGetStackHighWaterMark2           25
+#define SYSTEM_CALL_xTaskGetCurrentTaskHandle              26
+#define SYSTEM_CALL_xTaskGetSchedulerState                 27
+#define SYSTEM_CALL_vTaskSetTimeOutState                   28
+#define SYSTEM_CALL_xTaskCheckForTimeOut                   29
+#define SYSTEM_CALL_ulTaskGenericNotifyTake                30
+#define SYSTEM_CALL_xTaskGenericNotifyStateClear           31
+#define SYSTEM_CALL_ulTaskGenericNotifyValueClear          32
+#define SYSTEM_CALL_xQueueGenericSend                      33
+#define SYSTEM_CALL_uxQueueMessagesWaiting                 34
+#define SYSTEM_CALL_uxQueueSpacesAvailable                 35
+#define SYSTEM_CALL_xQueueReceive                          36
+#define SYSTEM_CALL_xQueuePeek                             37
+#define SYSTEM_CALL_xQueueSemaphoreTake                    38
+#define SYSTEM_CALL_xQueueGetMutexHolder                   39
+#define SYSTEM_CALL_xQueueTakeMutexRecursive               40
+#define SYSTEM_CALL_xQueueGiveMutexRecursive               41
+#define SYSTEM_CALL_xQueueSelectFromSet                    42
+#define SYSTEM_CALL_xQueueAddToSet                         43
+#define SYSTEM_CALL_vQueueAddToRegistry                    44
+#define SYSTEM_CALL_vQueueUnregisterQueue                  45
+#define SYSTEM_CALL_pcQueueGetName                         46
+#define SYSTEM_CALL_pvTimerGetTimerID                      47
+#define SYSTEM_CALL_vTimerSetTimerID                       48
+#define SYSTEM_CALL_xTimerIsTimerActive                    49
+#define SYSTEM_CALL_xTimerGetTimerDaemonTaskHandle         50
+#define SYSTEM_CALL_pcTimerGetName                         51
+#define SYSTEM_CALL_vTimerSetReloadMode                    52
+#define SYSTEM_CALL_xTimerGetReloadMode                    53
+#define SYSTEM_CALL_uxTimerGetReloadMode                   54
+#define SYSTEM_CALL_xTimerGetPeriod                        55
+#define SYSTEM_CALL_xTimerGetExpiryTime                    56
+#define SYSTEM_CALL_xEventGroupClearBits                   57
+#define SYSTEM_CALL_xEventGroupSetBits                     58
+#define SYSTEM_CALL_xEventGroupSync                        59
+#define SYSTEM_CALL_uxEventGroupGetNumber                  60
+#define SYSTEM_CALL_vEventGroupSetNumber                   61
+#define SYSTEM_CALL_xStreamBufferSend                      62
+#define SYSTEM_CALL_xStreamBufferReceive                   63
+#define SYSTEM_CALL_xStreamBufferIsFull                    64
+#define SYSTEM_CALL_xStreamBufferIsEmpty                   65
+#define SYSTEM_CALL_xStreamBufferSpacesAvailable           66
+#define SYSTEM_CALL_xStreamBufferBytesAvailable            67
+#define SYSTEM_CALL_xStreamBufferSetTriggerLevel           68
+#define SYSTEM_CALL_xStreamBufferNextMessageLengthBytes    69
+#define NUM_SYSTEM_CALLS                                   70  /* Total number of system calls. */
+
+#endif /* MPU_SYSCALL_NUMBERS_H */

### external/FreeRTOS/Source/include/mpu_wrappers.h
@@ -1,6 +1,6 @@
 /*
- * FreeRTOS Kernel V10.4.6
- * Copyright (C) 2021 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ * FreeRTOS Kernel V11.3.0
+ * Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -36,7 +36,7 @@
 /* MPU_WRAPPERS_INCLUDED_FROM_API_FILE will be defined when this file is
  * included from queue.c or task.c to prevent it from having an effect within
  * those files. */
-#ifndef MPU_WRAPPERS_INCLUDED_FROM_API_FILE
+    #ifndef MPU_WRAPPERS_INCLUDED_FROM_API_FILE
 
 /*
  * Map standard (non MPU) API functions to equivalents that start
@@ -46,170 +46,245 @@
  * privileges.
  */
 
-/* Map standard tasks.h API functions to the MPU equivalents. */
-#define xTaskCreate                            MPU_xTaskCreate
-#define xTaskCreateStatic                      MPU_xTaskCreateStatic
-#define vTaskDelete                            MPU_vTaskDelete
-#define vTaskDelay                             MPU_vTaskDelay
-#define xTaskDelayUntil                        MPU_xTaskDelayUntil
-#define xTaskAbortDelay                        MPU_xTaskAbortDelay
-#define uxTaskPriorityGet                      MPU_uxTaskPriorityGet
-#define eTaskGetState                          MPU_eTaskGetState
-#define vTaskGetInfo                           MPU_vTaskGetInfo
-#define vTaskPrioritySet                       MPU_vTaskPrioritySet
-#define vTaskSuspend                           MPU_vTaskSuspend
-#define vTaskResume                            MPU_vTaskResume
-#define vTaskSuspendAll                        MPU_vTaskSuspendAll
-#define xTaskResumeAll                         MPU_xTaskResumeAll
-#define xTaskGetTickCount                      MPU_xTaskGetTickCount
-#define uxTaskGetNumberOfTasks                 MPU_uxTaskGetNumberOfTasks
-#define pcTaskGetName                          MPU_pcTaskGetName
-#define xTaskGetHandle                         MPU_xTaskGetHandle
-#define uxTaskGetStackHighWaterMark            MPU_uxTaskGetStackHighWaterMark
-#define uxTaskGetStackHighWaterMark2           MPU_uxTaskGetStackHighWaterMark2
-#define vTaskSetApplicationTaskTag             MPU_vTaskSetApplicationTaskTag
-#define xTaskGetApplicationTaskTag             MPU_xTaskGetApplicationTaskTag
-#define vTaskSetThreadLocalStoragePointer      MPU_vTaskSetThreadLocalStoragePointer
-#define pvTaskGetThreadLocalStoragePointer     MPU_pvTaskGetThreadLocalStoragePointer
-#define xTaskCallApplicationTaskHook           MPU_xTaskCallApplicationTaskHook
-#define xTaskGetIdleTaskHandle                 MPU_xTaskGetIdleTaskHandle
-#define uxTaskGetSystemState                   MPU_uxTaskGetSystemState
-#define vTaskList                              MPU_vTaskList
-#define vTaskGetRunTimeStats                   MPU_vTaskGetRunTimeStats
-#define ulTaskGetIdleRunTimeCounter            MPU_ulTaskGetIdleRunTimeCounter
-#define ulTaskGetIdleRunTimePercent            MPU_ulTaskGetIdleRunTimePercent
-#define xTaskGenericNotify                     MPU_xTaskGenericNotify
-#define xTaskGenericNotifyWait                 MPU_xTaskGenericNotifyWait
-#define ulTaskGenericNotifyTake                MPU_ulTaskGenericNotifyTake
-#define xTaskGenericNotifyStateClear           MPU_xTaskGenericNotifyStateClear
-#define ulTaskGenericNotifyValueClear          MPU_ulTaskGenericNotifyValueClear
-#define xTaskCatchUpTicks                      MPU_xTaskCatchUpTicks
-
-#define xTaskGetCurrentTaskHandle              MPU_xTaskGetCurrentTaskHandle
-#define vTaskSetTimeOutState                   MPU_vTaskSetTimeOutState
-#define xTaskCheckForTimeOut                   MPU_xTaskCheckForTimeOut
-#define xTaskGetSchedulerState                 MPU_xTaskGetSchedulerState
+/* Map standard task.h API functions to the MPU equivalents. */
+        #define vTaskDelay                            MPU_vTaskDelay
+        #define xTaskDelayUntil                       MPU_xTaskDelayUntil
+        #define xTaskAbortDelay                       MPU_xTaskAbortDelay
+        #define uxTaskPriorityGet                     MPU_uxTaskPriorityGet
+        #define eTaskGetState                         MPU_eTaskGetState
+        #define vTaskGetInfo                          MPU_vTaskGetInfo
+        #define vTaskSuspend                          MPU_vTaskSuspend
+        #define vTaskResume                           MPU_vTaskResume
+        #define xTaskGetTickCount                     MPU_xTaskGetTickCount
+        #define uxTaskGetNumberOfTasks                MPU_uxTaskGetNumberOfTasks
+        #define uxTaskGetStackHighWaterMark           MPU_uxTaskGetStackHighWaterMark
+        #define uxTaskGetStackHighWaterMark2          MPU_uxTaskGetStackHighWaterMark2
+        #define vTaskSetApplicationTaskTag            MPU_vTaskSetApplicationTaskTag
+        #define xTaskGetApplicationTaskTag            MPU_xTaskGetApplicationTaskTag
+        #define vTaskSetThreadLocalStoragePointer     MPU_vTaskSetThreadLocalStoragePointer
+        #define pvTaskGetThreadLocalStoragePointer    MPU_pvTaskGetThreadLocalStoragePointer
+        #define xTaskGetIdleTaskHandle                MPU_xTaskGetIdleTaskHandle
+        #define uxTaskGetSystemState                  MPU_uxTaskGetSystemState
+        #define ulTaskGetIdleRunTimeCounter           MPU_ulTaskGetIdleRunTimeCounter
+        #define ulTaskGetIdleRunTimePercent           MPU_ulTaskGetIdleRunTimePercent
+        #define xTaskGenericNotify                    MPU_xTaskGenericNotify
+        #define xTaskGenericNotifyWait                MPU_xTaskGenericNotifyWait
+        #define ulTaskGenericNotifyTake               MPU_ulTaskGenericNotifyTake
+        #define xTaskGenericNotifyStateClear          MPU_xTaskGenericNotifyStateClear
+        #define ulTaskGenericNotifyValueClear         MPU_ulTaskGenericNotifyValueClear
+        #define vTaskSetTimeOutState                  MPU_vTaskSetTimeOutState
+        #define xTaskCheckForTimeOut                  MPU_xTaskCheckForTimeOut
+        #define xTaskGetCurrentTaskHandle             MPU_xTaskGetCurrentTaskHandle
+        #define xTaskGetSchedulerState                MPU_xTaskGetSchedulerState
+
+        #if ( configUSE_MPU_WRAPPERS_V1 == 0 )
+            #define ulTaskGetRunTimeCounter           MPU_ulTaskGetRunTimeCounter
+            #define ulTaskGetRunTimePercent           MPU_ulTaskGetRunTimePercent
+        #endif /* #if ( configUSE_MPU_WRAPPERS_V1 == 0 ) */
+
+/* Privileged only wrappers for Task APIs. These are needed so that
+ * the application can use opaque handles maintained in mpu_wrappers.c
+ * with all the APIs. */
+        #if ( configUSE_MPU_WRAPPERS_V1 == 1 )
+
+/* These are not needed in v2 because they do not take a task
+ * handle and therefore, no lookup is needed. Needed in v1 because
+ * these are available as system calls in v1. */
+            #define vTaskGetRunTimeStatistics            MPU_vTaskGetRunTimeStatistics
+            #define vTaskListTasks                       MPU_vTaskListTasks
+            #define vTaskSuspendAll                      MPU_vTaskSuspendAll
+            #define xTaskCatchUpTicks                    MPU_xTaskCatchUpTicks
+            #define xTaskResumeAll                       MPU_xTaskResumeAll
+        #endif /* #if ( configUSE_MPU_WRAPPERS_V1 == 1 ) */
+
+        #define xTaskCreate                              MPU_xTaskCreate
+        #define xTaskCreateStatic                        MPU_xTaskCreateStatic
+        #define vTaskDelete                              MPU_vTaskDelete
+        #define vTaskPrioritySet                         MPU_vTaskPrioritySet
+        #define xTaskGetHandle                           MPU_xTaskGetHandle
+        #define xTaskCallApplicationTaskHook             MPU_xTaskCallApplicationTaskHook
+
+        #if ( configUSE_MPU_WRAPPERS_V1 == 0 )
+            #define pcTaskGetName                        MPU_pcTaskGetName
+            #define xTaskCreateRestricted                MPU_xTaskCreateRestricted
+            #define xTaskCreateRestrictedStatic          MPU_xTaskCreateRestrictedStatic
+            #define vTaskAllocateMPURegions              MPU_vTaskAllocateMPURegions
+            #define xTaskGetStaticBuffers                MPU_xTaskGetStaticBuffers
+            #define uxTaskPriorityGetFromISR             MPU_uxTaskPriorityGetFromISR
+            #define uxTaskBasePriorityGet                MPU_uxTaskBasePriorityGet
+            #define uxTaskBasePriorityGetFromISR         MPU_uxTaskBasePriorityGetFromISR
+            #define xTaskResumeFromISR                   MPU_xTaskResumeFromISR
+            #define xTaskGetApplicationTaskTagFromISR    MPU_xTaskGetApplicationTaskTagFromISR
+            #define xTaskGenericNotifyFromISR            MPU_xTaskGenericNotifyFromISR
+            #define vTaskGenericNotifyGiveFromISR        MPU_vTaskGenericNotifyGiveFromISR
+        #endif /* #if ( configUSE_MPU_WRAPPERS_V1 == 0 ) */
 
 /* Map standard queue.h API functions to the MPU equivalents. */
-#define xQueueGenericSend                      MPU_xQueueGenericSend
-#define xQueueReceive                          MPU_xQueueReceive
-#define xQueuePeek                             MPU_xQueuePeek
-#define xQueueSemaphoreTake                    MPU_xQueueSemaphoreTake
-#define uxQueueMessagesWaiting                 MPU_uxQueueMessagesWaiting
-#define uxQueueSpacesAvailable                 MPU_uxQueueSpacesAvailable
-#define vQueueDelete                           MPU_vQueueDelete
-#define xQueueCreateMutex                      MPU_xQueueCreateMutex
-#define xQueueCreateMutexStatic                MPU_xQueueCreateMutexStatic
-#define xQueueCreateCountingSemaphore          MPU_xQueueCreateCountingSemaphore
-#define xQueueCreateCountingSemaphoreStatic    MPU_xQueueCreateCountingSemaphoreStatic
-#define xQueueGetMutexHolder                   MPU_xQueueGetMutexHolder
-#define xQueueTakeMutexRecursive               MPU_xQueueTakeMutexRecursive
-#define xQueueGiveMutexRecursive               MPU_xQueueGiveMutexRecursive
-#define xQueueGenericCreate                    MPU_xQueueGenericCreate
-#define xQueueGenericCreateStatic              MPU_xQueueGenericCreateStatic
-#define xQueueCreateSet                        MPU_xQueueCreateSet
-#define xQueueAddToSet                         MPU_xQueueAddToSet
-#define xQueueRemoveFromSet                    MPU_xQueueRemoveFromSet
-#define xQueueSelectFromSet                    MPU_xQueueSelectFromSet
-#define xQueueGenericReset                     MPU_xQueueGenericReset
-
-#if ( configQUEUE_REGISTRY_SIZE > 0 )
-#define vQueueAddToRegistry                MPU_vQueueAddToRegistry
-#define vQueueUnregisterQueue              MPU_vQueueUnregisterQueue
-#define pcQueueGetName                     MPU_pcQueueGetName
-#endif
+        #define xQueueGenericSend            MPU_xQueueGenericSend
+        #define xQueueReceive                MPU_xQueueReceive
+        #define xQueuePeek                   MPU_xQueuePeek
+        #define xQueueSemaphoreTake          MPU_xQueueSemaphoreTake
+        #define uxQueueMessagesWaiting       MPU_uxQueueMessagesWaiting
+        #define uxQueueSpacesAvailable       MPU_uxQueueSpacesAvailable
+        #define xQueueGetMutexHolder         MPU_xQueueGetMutexHolder
+        #define xQueueTakeMutexRecursive     MPU_xQueueTakeMutexRecursive
+        #define xQueueGiveMutexRecursive     MPU_xQueueGiveMutexRecursive
+        #define xQueueAddToSet               MPU_xQueueAddToSet
+        #define xQueueSelectFromSet          MPU_xQueueSelectFromSet
+
+        #if ( configQUEUE_REGISTRY_SIZE > 0 )
+            #define vQueueAddToRegistry      MPU_vQueueAddToRegistry
+            #define vQueueUnregisterQueue    MPU_vQueueUnregisterQueue
+            #define pcQueueGetName           MPU_pcQueueGetName
+        #endif /* #if ( configQUEUE_REGISTRY_SIZE > 0 ) */
+
+/* Privileged only wrappers for Queue APIs. These are needed so that
+ * the application can use opaque handles maintained in mpu_wrappers.c
+ * with all the APIs. */
+        #define vQueueDelete                           MPU_vQueueDelete
+        #define xQueueCreateMutex                      MPU_xQueueCreateMutex
+        #define xQueueCreateMutexStatic                MPU_xQueueCreateMutexStatic
+        #define xQueueCreateCountingSemaphore          MPU_xQueueCreateCountingSemaphore
+        #define xQueueCreateCountingSemaphoreStatic    MPU_xQueueCreateCountingSemaphoreStatic
+        #define xQueueGenericCreate                    MPU_xQueueGenericCreate
+        #define xQueueGenericCreateStatic              MPU_xQueueGenericCreateStatic
+        #define xQueueGenericReset                     MPU_xQueueGenericReset
+        #define xQueueCreateSet                        MPU_xQueueCreateSet
+        #define xQueueCreateSetStatic                  MPU_xQueueCreateSetStatic
+        #define xQueueRemoveFromSet                    MPU_xQueueRemoveFromSet
+
+        #if ( configUSE_MPU_WRAPPERS_V1 == 0 )
+            #define xQueueGenericGetStaticBuffers      MPU_xQueueGenericGetStaticBuffers
+            #define xQueueGenericSendFromISR           MPU_xQueueGenericSendFromISR
+            #define xQueueGiveFromISR                  MPU_xQueueGiveFromISR
+            #define xQueuePeekFromISR                  MPU_xQueuePeekFromISR
+            #define xQueueReceiveFromISR               MPU_xQueueReceiveFromISR
+            #define xQueueIsQueueEmptyFromISR          MPU_xQueueIsQueueEmptyFromISR
+            #define xQueueIsQueueFullFromISR           MPU_xQueueIsQueueFullFromISR
+            #define uxQueueMessagesWaitingFromISR      MPU_uxQueueMessagesWaitingFromISR
+            #define xQueueGetMutexHolderFromISR        MPU_xQueueGetMutexHolderFromISR
+            #define xQueueSelectFromSetFromISR         MPU_xQueueSelectFromSetFromISR
+        #endif /* if ( configUSE_MPU_WRAPPERS_V1 == 0 ) */
 
 /* Map standard timer.h API functions to the MPU equivalents. */
-#define xTimerCreate                           MPU_xTimerCreate
-#define xTimerCreateStatic                     MPU_xTimerCreateStatic
-#define pvTimerGetTimerID                      MPU_pvTimerGetTimerID
-#define vTimerSetTimerID                       MPU_vTimerSetTimerID
-#define xTimerIsTimerActive                    MPU_xTimerIsTimerActive
-#define xTimerGetTimerDaemonTaskHandle         MPU_xTimerGetTimerDaemonTaskHandle
-#define xTimerPendFunctionCall                 MPU_xTimerPendFunctionCall
-#define pcTimerGetName                         MPU_pcTimerGetName
-#define vTimerSetReloadMode                    MPU_vTimerSetReloadMode
-#define uxTimerGetReloadMode                   MPU_uxTimerGetReloadMode
-#define xTimerGetPeriod                        MPU_xTimerGetPeriod
-#define xTimerGetExpiryTime                    MPU_xTimerGetExpiryTime
-#define xTimerGenericCommand                   MPU_xTimerGenericCommand
+        #define pvTimerGetTimerID                 MPU_pvTimerGetTimerID
+        #define vTimerSetTimerID                  MPU_vTimerSetTimerID
+        #define xTimerIsTimerActive               MPU_xTimerIsTimerActive
+        #define xTimerGetTimerDaemonTaskHandle    MPU_xTimerGetTimerDaemonTaskHandle
+        #define xTimerGenericCommandFromTask      MPU_xTimerGenericCommandFromTask
+        #define pcTimerGetName                    MPU_pcTimerGetName
+        #define vTimerSetReloadMode               MPU_vTimerSetReloadMode
+        #define uxTimerGetReloadMode              MPU_uxTimerGetReloadMode
+        #define xTimerGetPeriod                   MPU_xTimerGetPeriod
+        #define xTimerGetExpiryTime               MPU_xTimerGetExpiryTime
+
+        #if ( configUSE_MPU_WRAPPERS_V1 == 0 )
+            #define xTimerGetReloadMode           MPU_xTimerGetReloadMode
+        #endif /* #if ( configUSE_MPU_WRAPPERS_V1 == 0 ) */
+
+/* Privileged only wrappers for Timer APIs. These are needed so that
+ * the application can use opaque handles maintained in mpu_wrappers.c
+ * with all the APIs. */
+        #if ( configUSE_MPU_WRAPPERS_V1 == 0 )
+            #define xTimerCreate                   MPU_xTimerCreate
+            #define xTimerCreateStatic             MPU_xTimerCreateStatic
+            #define xTimerGetStaticBuffer          MPU_xTimerGetStaticBuffer
+            #define xTimerGenericCommandFromISR    MPU_xTimerGenericCommandFromISR
+        #endif /* #if ( configUSE_MPU_WRAPPERS_V1 == 0 ) */
 
 /* Map standard event_group.h API functions to the MPU equivalents. */
-#define xEventGroupCreate                      MPU_xEventGroupCreate
-#define xEventGroupCreateStatic                MPU_xEventGroupCreateStatic
-#define xEventGroupWaitBits                    MPU_xEventGroupWaitBits
-#define xEventGroupClearBits                   MPU_xEventGroupClearBits
-#define xEventGroupSetBits                     MPU_xEventGroupSetBits
-#define xEventGroupSync                        MPU_xEventGroupSync
-#define vEventGroupDelete                      MPU_vEventGroupDelete
+        #define xEventGroupWaitBits          MPU_xEventGroupWaitBits
+        #define xEventGroupClearBits         MPU_xEventGroupClearBits
+        #define xEventGroupSetBits           MPU_xEventGroupSetBits
+        #define xEventGroupSync              MPU_xEventGroupSync
+
+        #if ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_MPU_WRAPPERS_V1 == 0 ) )
+            #define uxEventGroupGetNumber    MPU_uxEventGroupGetNumber
+            #define vEventGroupSetNumber     MPU_vEventGroupSetNumber
+        #endif /* #if ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_MPU_WRAPPERS_V1 == 0 ) ) */
+
+/* Privileged only wrappers for Event Group APIs. These are needed so that
+ * the application can use opaque handles maintained in mpu_wrappers.c
+ * with all the APIs. */
+        #define xEventGroupCreate                  MPU_xEventGroupCreate
+        #define xEventGroupCreateStatic            MPU_xEventGroupCreateStatic
+        #define vEventGroupDelete                  MPU_vEventGroupDelete
+
+        #if ( configUSE_MPU_WRAPPERS_V1 == 0 )
+            #define xEventGroupGetStaticBuffer     MPU_xEventGroupGetStaticBuffer
+            #define xEventGroupClearBitsFromISR    MPU_xEventGroupClearBitsFromISR
+            #define xEventGroupSetBitsFromISR      MPU_xEventGroupSetBitsFromISR
+            #define xEventGroupGetBitsFromISR      MPU_xEventGroupGetBitsFromISR
+        #endif /* #if ( configUSE_MPU_WRAPPERS_V1 == 0 ) */
 
 /* Map standard message/stream_buffer.h API functions to the MPU
  * equivalents. */
-#define xStreamBufferSend                      MPU_xStreamBufferSend
-#define xStreamBufferReceive                   MPU_xStreamBufferReceive
-#define xStreamBufferNextMessageLengthBytes    MPU_xStreamBufferNextMessageLengthBytes
-#define vStreamBufferDelete                    MPU_vStreamBufferDelete
-#define xStreamBufferIsFull                    MPU_xStreamBufferIsFull
-#define xStreamBufferIsEmpty                   MPU_xStreamBufferIsEmpty
-#define xStreamBufferReset                     MPU_xStreamBufferReset
-#define xStreamBufferSpacesAvailable           MPU_xStreamBufferSpacesAvailable
-#define xStreamBufferBytesAvailable            MPU_xStreamBufferBytesAvailable
-#define xStreamBufferSetTriggerLevel           MPU_xStreamBufferSetTriggerLevel
-#define xStreamBufferGenericCreate             MPU_xStreamBufferGenericCreate
-#define xStreamBufferGenericCreateStatic       MPU_xStreamBufferGenericCreateStatic
-
-
-/* Remove the privileged function macro, but keep the PRIVILEGED_DATA
- * macro so applications can place data in privileged access sections
- * (useful when using statically allocated objects). */
-#define PRIVILEGED_FUNCTION
-#define PRIVILEGED_DATA    __attribute__( ( section( "privileged_data" ) ) )
-#define FREERTOS_SYSTEM_CALL
-
-#else /* MPU_WRAPPERS_INCLUDED_FROM_API_FILE */
-
-/* Ensure API functions go in the privileged execution section. */
-#define PRIVILEGED_FUNCTION     __attribute__( ( section( "privileged_functions" ) ) )
-#define PRIVILEGED_DATA         __attribute__( ( section( "privileged_data" ) ) )
-#define FREERTOS_SYSTEM_CALL    __attribute__( ( section( "freertos_system_calls" ) ) )
-
-/**
- * @brief Calls the port specific code to raise the privilege.
- *
- * Sets xRunningPrivileged to pdFALSE if privilege was raised, else sets
- * it to pdTRUE.
- */
-#define xPortRaisePrivilege( xRunningPrivileged )                      \
-        {                                                                      \
-            /* Check whether the processor is already privileged. */           \
-            xRunningPrivileged = portIS_PRIVILEGED();                          \
-                                                                               \
-            /* If the processor is not already privileged, raise privilege. */ \
-            if( xRunningPrivileged == pdFALSE )                                \
-            {                                                                  \
-                portRAISE_PRIVILEGE();                                         \
-            }                                                                  \
-        }
-
-/**
- * @brief If xRunningPrivileged is not pdTRUE, calls the port specific
- * code to reset the privilege, otherwise does nothing.
- */
-#define vPortResetPrivilege( xRunningPrivileged )   \
-        {                                                   \
-            if( xRunningPrivileged == pdFALSE )             \
-            {                                               \
-                portRESET_PRIVILEGE();                      \
-            }                                               \
-        }
+        #define xStreamBufferSend                      MPU_xStreamBufferSend
+        #define xStreamBufferReceive                   MPU_xStreamBufferReceive
+        #define xStreamBufferIsFull                    MPU_xStreamBufferIsFull
+        #define xStreamBufferIsEmpty                   MPU_xStreamBufferIsEmpty
+        #define xStreamBufferSpacesAvailable           MPU_xStreamBufferSpacesAvailable
+        #define xStreamBufferBytesAvailable            MPU_xStreamBufferBytesAvailable
+        #define xStreamBufferSetTriggerLevel           MPU_xStreamBufferSetTriggerLevel
+        #define xStreamBufferNextMessageLengthBytes    MPU_xStreamBufferNextMessageLengthBytes
+
+/* Privileged only wrappers for Stream Buffer APIs. These are needed so that
+ * the application can use opaque handles maintained in mpu_wrappers.c
+ * with all the APIs. */
+
+        #define xStreamBufferGenericCreate                  MPU_xStreamBufferGenericCreate
+        #define xStreamBufferGenericCreateStatic            MPU_xStreamBufferGenericCreateStatic
+        #define vStreamBufferDelete                         MPU_vStreamBufferDelete
+        #define xStreamBufferReset                          MPU_xStreamBufferReset
+
+        #if ( configUSE_MPU_WRAPPERS_V1 == 0 )
+            #define xStreamBufferGetStaticBuffers           MPU_xStreamBufferGetStaticBuffers
+            #define xStreamBufferSendFromISR                MPU_xStreamBufferSendFromISR
+            #define xStreamBufferReceiveFromISR             MPU_xStreamBufferReceiveFromISR
+            #define xStreamBufferSendCompletedFromISR       MPU_xStreamBufferSendCompletedFromISR
+            #define xStreamBufferReceiveCompletedFromISR    MPU_xStreamBufferReceiveCompletedFromISR
+            #define xStreamBufferResetFromISR               MPU_xStreamBufferResetFromISR
+        #endif /* #if ( configUSE_MPU_WRAPPERS_V1 == 0 ) */
+
+        #if ( ( configUSE_MPU_WRAPPERS_V1 == 0 ) && ( configENABLE_ACCESS_CONTROL_LIST == 1 ) )
+
+            #define vGrantAccessToTask( xTask, xTaskToGrantAccess )                        vGrantAccessToKernelObject( ( xTask ), ( int32_t ) ( xTaskToGrantAccess ) )
+            #define vRevokeAccessToTask( xTask, xTaskToRevokeAccess )                      vRevokeAccessToKernelObject( ( xTask ), ( int32_t ) ( xTaskToRevokeAccess ) )
+
+            #define vGrantAccessToSemaphore( xTask, xSemaphoreToGrantAccess )              vGrantAccessToKernelObject( ( xTask ), ( int32_t ) ( xSemaphoreToGrantAccess ) )
+            #define vRevokeAccessToSemaphore( xTask, xSemaphoreToRevokeAccess )            vRevokeAccessToKernelObject( ( xTask ), ( int32_t ) ( xSemaphoreToRevokeAccess ) )
+
+            #define vGrantAccessToQueue( xTask, xQueueToGrantAccess )                      vGrantAccessToKernelObject( ( xTask ), ( int32_t ) ( xQueueToGrantAccess ) )
+            #define vRevokeAccessToQueue( xTask, xQueueToRevokeAccess )                    vRevokeAccessToKernelObject( ( xTask ), ( int32_t ) ( xQueueToRevokeAccess ) )
+
+            #define vGrantAccessToQueueSet( xTask, xQueueSetToGrantAccess )                vGrantAccessToKernelObject( ( xTask ), ( int32_t ) ( xQueueSetToGrantAccess ) )
+            #define vRevokeAccessToQueueSet( xTask, xQueueSetToRevokeAccess )              vRevokeAccessToKernelObject( ( xTask ), ( int32_t ) ( xQueueSetToRevokeAccess ) )
+
+            #define vGrantAccessToEventGroup( xTask, xEventGroupToGrantAccess )            vGrantAccessToKernelObject( ( xTask ), ( int32_t ) ( xEventGroupToGrantAccess ) )
+            #define vRevokeAccessToEventGroup( xTask, xEventGroupToRevokeAccess )          vRevokeAccessToKernelObject( ( xTask ), ( int32_t ) ( xEventGroupToRevokeAccess ) )
+
+            #define vGrantAccessToStreamBuffer( xTask, xStreamBufferToGrantAccess )        vGrantAccessToKernelObject( ( xTask ), ( int32_t ) ( xStreamBufferToGrantAccess ) )
+            #define vRevokeAccessToStreamBuffer( xTask, xStreamBufferToRevokeAccess )      vRevokeAccessToKernelObject( ( xTask ), ( int32_t ) ( xStreamBufferToRevokeAccess ) )
+
+            #define vGrantAccessToMessageBuffer( xTask, xMessageBufferToGrantAccess )      vGrantAccessToKernelObject( ( xTask ), ( int32_t ) ( xMessageBufferToGrantAccess ) )
+            #define vRevokeAccessToMessageBuffer( xTask, xMessageBufferToRevokeAccess )    vRevokeAccessToKernelObject( ( xTask ), ( int32_t ) ( xMessageBufferToRevokeAccess ) )
+
+            #define vGrantAccessToTimer( xTask, xTimerToGrantAccess )                      vGrantAccessToKernelObject( ( xTask ), ( int32_t ) ( xTimerToGrantAccess ) )
+            #define vRevokeAccessToTimer( xTask, xTimerToRevokeAccess )                    vRevokeAccessToKernelObject( ( xTask ), ( int32_t ) ( xTimerToRevokeAccess ) )
+
+        #endif /* #if ( ( configUSE_MPU_WRAPPERS_V1 == 0 ) && ( configENABLE_ACCESS_CONTROL_LIST == 1 ) ) */
+
+    #endif /* MPU_WRAPPERS_INCLUDED_FROM_API_FILE */
 
-#endif /* MPU_WRAPPERS_INCLUDED_FROM_API_FILE */
+    #define PRIVILEGED_FUNCTION     __attribute__( ( section( "privileged_functions" ) ) )
+    #define PRIVILEGED_DATA         __attribute__( ( section( "privileged_data" ) ) )
+    #define FREERTOS_SYSTEM_CALL    __attribute__( ( section( "freertos_system_calls" ) ) )
 
 #else /* portUSING_MPU_WRAPPERS */
 
-#define PRIVILEGED_FUNCTION
-#define PRIVILEGED_DATA
-#define FREERTOS_SYSTEM_CALL
+    #define PRIVILEGED_FUNCTION
+    #define PRIVILEGED_DATA
+    #define FREERTOS_SYSTEM_CALL
 
 #endif /* portUSING_MPU_WRAPPERS */
 

### external/FreeRTOS/Source/include/newlib-freertos.h
@@ -0,0 +1,62 @@
+/*
+ * FreeRTOS Kernel V11.3.0
+ * Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ *
+ */
+
+#ifndef INC_NEWLIB_FREERTOS_H
+#define INC_NEWLIB_FREERTOS_H
+
+/* Note Newlib support has been included by popular demand, but is not
+ * used by the FreeRTOS maintainers themselves.  FreeRTOS is not
+ * responsible for resulting newlib operation.  User must be familiar with
+ * newlib and must provide system-wide implementations of the necessary
+ * stubs. Be warned that (at the time of writing) the current newlib design
+ * implements a system-wide malloc() that must be provided with locks.
+ *
+ * See the third party link http://www.nadler.com/embedded/newlibAndFreeRTOS.html
+ * for additional information. */
+
+#include <reent.h>
+
+#define configUSE_C_RUNTIME_TLS_SUPPORT    1
+
+#ifndef configTLS_BLOCK_TYPE
+    #define configTLS_BLOCK_TYPE           struct _reent
+#endif
+
+#ifndef configINIT_TLS_BLOCK
+    #define configINIT_TLS_BLOCK( xTLSBlock, pxTopOfStack )    _REENT_INIT_PTR( &( xTLSBlock ) )
+#endif
+
+#ifndef configSET_TLS_BLOCK
+    #define configSET_TLS_BLOCK( xTLSBlock )    ( _impure_ptr = &( xTLSBlock ) )
+#endif
+
+#ifndef configDEINIT_TLS_BLOCK
+    #define configDEINIT_TLS_BLOCK( xTLSBlock )    _reclaim_reent( &( xTLSBlock ) )
+#endif
+
+#endif /* INC_NEWLIB_FREERTOS_H */

### external/FreeRTOS/Source/include/picolibc-freertos.h
@@ -0,0 +1,91 @@
+/*
+ * FreeRTOS Kernel V11.3.0
+ * Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ *
+ */
+
+#ifndef INC_PICOLIBC_FREERTOS_H
+#define INC_PICOLIBC_FREERTOS_H
+
+/* Use picolibc TLS support to allocate space for __thread variables,
+ * initialize them at thread creation and set the TLS context at
+ * thread switch time.
+ *
+ * See the picolibc TLS docs:
+ * https://github.com/picolibc/picolibc/blob/main/doc/tls.md
+ * for additional information. */
+
+#include <picotls.h>
+
+#define configUSE_C_RUNTIME_TLS_SUPPORT    1
+
+#define configTLS_BLOCK_TYPE               void *
+
+#define picolibcTLS_SIZE                   ( ( portPOINTER_SIZE_TYPE ) _tls_size() )
+#define picolibcSTACK_ALIGNMENT_MASK       ( ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK )
+
+#if __PICOLIBC_MAJOR__ > 1 || __PICOLIBC_MINOR__ >= 8
+
+/* Picolibc 1.8 and newer have explicit alignment values provided
+ * by the _tls_align() inline */
+    #define picolibcTLS_ALIGNMENT_MASK    ( ( portPOINTER_SIZE_TYPE ) ( _tls_align() - 1 ) )
+#else
+
+/* For older Picolibc versions, use the general port alignment value */
+    #define picolibcTLS_ALIGNMENT_MASK    ( ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK )
+#endif
+
+/* Allocate thread local storage block off the end of the
+ * stack. The picolibcTLS_SIZE macro returns the size (in
+ * bytes) of the total TLS area used by the application.
+ * Calculate the top of stack address. */
+#if ( portSTACK_GROWTH < 0 )
+
+    #define configINIT_TLS_BLOCK( xTLSBlock, pxTopOfStack )                                  \
+    do {                                                                                     \
+        xTLSBlock = ( void * ) ( ( ( ( portPOINTER_SIZE_TYPE ) pxTopOfStack ) -              \
+                                   picolibcTLS_SIZE ) &                                      \
+                                 ~picolibcTLS_ALIGNMENT_MASK );                              \
+        pxTopOfStack = ( StackType_t * ) ( ( ( ( portPOINTER_SIZE_TYPE ) xTLSBlock ) - 1 ) & \
+                                           ~picolibcSTACK_ALIGNMENT_MASK );                  \
+        _init_tls( xTLSBlock );                                                              \
+    } while( 0 )
+#else /* portSTACK_GROWTH */
+    #define configINIT_TLS_BLOCK( xTLSBlock, pxTopOfStack )                                          \
+    do {                                                                                             \
+        xTLSBlock = ( void * ) ( ( ( portPOINTER_SIZE_TYPE ) pxTopOfStack +                          \
+                                   picolibcTLS_ALIGNMENT_MASK ) & ~picolibcTLS_ALIGNMENT_MASK );     \
+        pxTopOfStack = ( StackType_t * ) ( ( ( ( ( portPOINTER_SIZE_TYPE ) xTLSBlock ) +             \
+                                               picolibcTLS_SIZE ) + picolibcSTACK_ALIGNMENT_MASK ) & \
+                                           ~picolibcSTACK_ALIGNMENT_MASK );                          \
+        _init_tls( xTLSBlock );                                                                      \
+    } while( 0 )
+#endif /* portSTACK_GROWTH */
+
+#define configSET_TLS_BLOCK( xTLSBlock )    _set_tls( xTLSBlock )
+
+#define configDEINIT_TLS_BLOCK( xTLSBlock )
+
+#endif /* INC_PICOLIBC_FREERTOS_H */

### external/FreeRTOS/Source/include/portable.h
@@ -1,6 +1,6 @@
 /*
- * FreeRTOS Kernel V10.4.6
- * Copyright (C) 2021 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ * FreeRTOS Kernel V11.3.0
+ * Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -50,166 +50,235 @@
  * included here.  In this case the path to the correct portmacro.h header file
  * must be set in the compiler's include path. */
 #ifndef portENTER_CRITICAL
-#include "portmacro.h"
+    #include "portmacro.h"
 #endif
 
 #if portBYTE_ALIGNMENT == 32
-#define portBYTE_ALIGNMENT_MASK    ( 0x001f )
+    #define portBYTE_ALIGNMENT_MASK    ( 0x001f )
 #elif portBYTE_ALIGNMENT == 16
-#define portBYTE_ALIGNMENT_MASK    ( 0x000f )
+    #define portBYTE_ALIGNMENT_MASK    ( 0x000f )
 #elif portBYTE_ALIGNMENT == 8
-#define portBYTE_ALIGNMENT_MASK    ( 0x0007 )
+    #define portBYTE_ALIGNMENT_MASK    ( 0x0007 )
 #elif portBYTE_ALIGNMENT == 4
-#define portBYTE_ALIGNMENT_MASK    ( 0x0003 )
+    #define portBYTE_ALIGNMENT_MASK    ( 0x0003 )
 #elif portBYTE_ALIGNMENT == 2
-#define portBYTE_ALIGNMENT_MASK    ( 0x0001 )
+    #define portBYTE_ALIGNMENT_MASK    ( 0x0001 )
 #elif portBYTE_ALIGNMENT == 1
-#define portBYTE_ALIGNMENT_MASK    ( 0x0000 )
+    #define portBYTE_ALIGNMENT_MASK    ( 0x0000 )
 #else /* if portBYTE_ALIGNMENT == 32 */
-#error "Invalid portBYTE_ALIGNMENT definition"
+    #error "Invalid portBYTE_ALIGNMENT definition"
 #endif /* if portBYTE_ALIGNMENT == 32 */
 
 #ifndef portUSING_MPU_WRAPPERS
-#define portUSING_MPU_WRAPPERS    0
+    #define portUSING_MPU_WRAPPERS    0
 #endif
 
 #ifndef portNUM_CONFIGURABLE_REGIONS
-#define portNUM_CONFIGURABLE_REGIONS    1
+    #define portNUM_CONFIGURABLE_REGIONS    1
 #endif
 
 #ifndef portHAS_STACK_OVERFLOW_CHECKING
-#define portHAS_STACK_OVERFLOW_CHECKING    0
+    #define portHAS_STACK_OVERFLOW_CHECKING    0
 #endif
 
 #ifndef portARCH_NAME
-#define portARCH_NAME    NULL
+    #define portARCH_NAME    NULL
+#endif
+
+#ifndef portBASE_TYPE_ENTER_CRITICAL
+    #define portBASE_TYPE_ENTER_CRITICAL()    taskENTER_CRITICAL()
+#endif
+
+#ifndef portBASE_TYPE_EXIT_CRITICAL
+    #define portBASE_TYPE_EXIT_CRITICAL()    taskEXIT_CRITICAL()
+#endif
+
+#ifndef configSTACK_DEPTH_TYPE
+    #define configSTACK_DEPTH_TYPE    StackType_t
 #endif
 
 #ifndef configSTACK_ALLOCATION_FROM_SEPARATE_HEAP
-/* Defaults to 0 for backward compatibility. */
-#define configSTACK_ALLOCATION_FROM_SEPARATE_HEAP    0
+    /* Defaults to 0 for backward compatibility. */
+    #define configSTACK_ALLOCATION_FROM_SEPARATE_HEAP    0
 #endif
 
+#include "mpu_wrappers.h"
+
 /* *INDENT-OFF* */
 #ifdef __cplusplus
     extern "C" {
 #endif
 /* *INDENT-ON* */
 
-#include "mpu_wrappers.h"
-
-    /*
-     * Setup the stack of a new task so it is ready to be placed under the
-     * scheduler control.  The registers have to be placed on the stack in
-     * the order that the port expects to find them.
-     *
-     */
+/*
+ * Setup the stack of a new task so it is ready to be placed under the
+ * scheduler control.  The registers have to be placed on the stack in
+ * the order that the port expects to find them.
+ *
+ */
 #if ( portUSING_MPU_WRAPPERS == 1 )
-#if ( portHAS_STACK_OVERFLOW_CHECKING == 1 )
-    StackType_t * pxPortInitialiseStack(StackType_t * pxTopOfStack,
-                                        StackType_t * pxEndOfStack,
-                                        TaskFunction_t pxCode,
-                                        void * pvParameters,
-                                        BaseType_t xRunPrivileged) PRIVILEGED_FUNCTION;
-#else
-    StackType_t * pxPortInitialiseStack(StackType_t * pxTopOfStack,
-                                        TaskFunction_t pxCode,
-                                        void * pvParameters,
-                                        BaseType_t xRunPrivileged) PRIVILEGED_FUNCTION;
-#endif
+    #if ( portHAS_STACK_OVERFLOW_CHECKING == 1 )
+        StackType_t * pxPortInitialiseStack( StackType_t * pxTopOfStack,
+                                             StackType_t * pxEndOfStack,
+                                             TaskFunction_t pxCode,
+                                             void * pvParameters,
+                                             BaseType_t xRunPrivileged,
+                                             xMPU_SETTINGS * xMPUSettings ) PRIVILEGED_FUNCTION;
+    #else
+        StackType_t * pxPortInitialiseStack( StackType_t * pxTopOfStack,
+                                             TaskFunction_t pxCode,
+                                             void * pvParameters,
+                                             BaseType_t xRunPrivileged,
+                                             xMPU_SETTINGS * xMPUSettings ) PRIVILEGED_FUNCTION;
+    #endif /* if ( portHAS_STACK_OVERFLOW_CHECKING == 1 ) */
 #else /* if ( portUSING_MPU_WRAPPERS == 1 ) */
-#if ( portHAS_STACK_OVERFLOW_CHECKING == 1 )
-    StackType_t * pxPortInitialiseStack(StackType_t * pxTopOfStack,
-                                        StackType_t * pxEndOfStack,
-                                        TaskFunction_t pxCode,
-                                        void * pvParameters) PRIVILEGED_FUNCTION;
-#else
-    StackType_t * pxPortInitialiseStack(StackType_t * pxTopOfStack,
-                                        TaskFunction_t pxCode,
-                                        void * pvParameters) PRIVILEGED_FUNCTION;
-#endif
+    #if ( portHAS_STACK_OVERFLOW_CHECKING == 1 )
+        StackType_t * pxPortInitialiseStack( StackType_t * pxTopOfStack,
+                                             StackType_t * pxEndOfStack,
+                                             TaskFunction_t pxCode,
+                                             void * pvParameters ) PRIVILEGED_FUNCTION;
+    #else
+        StackType_t * pxPortInitialiseStack( StackType_t * pxTopOfStack,
+                                             TaskFunction_t pxCode,
+                                             void * pvParameters ) PRIVILEGED_FUNCTION;
+    #endif
 #endif /* if ( portUSING_MPU_WRAPPERS == 1 ) */
 
-    /* Used by heap_5.c to define the start address and size of each memory region
-     * that together comprise the total FreeRTOS heap space. */
-    typedef struct HeapRegion {
-        uint8_t * pucStartAddress;
-        size_t xSizeInBytes;
-    } HeapRegion_t;
-
-    /* Used to pass information about the heap out of vPortGetHeapStats(). */
-    typedef struct xHeapStats {
-        size_t xAvailableHeapSpaceInBytes;      /* The total heap size currently available - this is the sum of all the free blocks, not the largest block that can be allocated. */
-        size_t xSizeOfLargestFreeBlockInBytes;  /* The maximum size, in bytes, of all the free blocks within the heap at the time vPortGetHeapStats() is called. */
-        size_t xSizeOfSmallestFreeBlockInBytes; /* The minimum size, in bytes, of all the free blocks within the heap at the time vPortGetHeapStats() is called. */
-        size_t xNumberOfFreeBlocks;             /* The number of free memory blocks within the heap at the time vPortGetHeapStats() is called. */
-        size_t xMinimumEverFreeBytesRemaining;  /* The minimum amount of total free memory (sum of all free blocks) there has been in the heap since the system booted. */
-        size_t xNumberOfSuccessfulAllocations;  /* The number of calls to pvPortMalloc() that have returned a valid memory block. */
-        size_t xNumberOfSuccessfulFrees;        /* The number of calls to vPortFree() that has successfully freed a block of memory. */
-    } HeapStats_t;
-
-    /*
-     * Used to define multiple heap regions for use by heap_5.c.  This function
-     * must be called before any calls to pvPortMalloc() - not creating a task,
-     * queue, semaphore, mutex, software timer, event group, etc. will result in
-     * pvPortMalloc being called.
-     *
-     * pxHeapRegions passes in an array of HeapRegion_t structures - each of which
-     * defines a region of memory that can be used as the heap.  The array is
-     * terminated by a HeapRegions_t structure that has a size of 0.  The region
-     * with the lowest start address must appear first in the array.
-     */
-    void vPortDefineHeapRegions(const HeapRegion_t * const pxHeapRegions) PRIVILEGED_FUNCTION;
-
-    /*
-     * Returns a HeapStats_t structure filled with information about the current
-     * heap state.
-     */
-    void vPortGetHeapStats(HeapStats_t * pxHeapStats);
-
-    /*
-     * Map to the memory management routines required for the port.
-     */
-    void * pvPortMalloc(size_t xSize) PRIVILEGED_FUNCTION;
-    void vPortFree(void * pv) PRIVILEGED_FUNCTION;
-    void vPortInitialiseBlocks(void) PRIVILEGED_FUNCTION;
-    size_t xPortGetFreeHeapSize(void) PRIVILEGED_FUNCTION;
-    size_t xPortGetMinimumEverFreeHeapSize(void) PRIVILEGED_FUNCTION;
+/* Used by heap_5.c to define the start address and size of each memory region
+ * that together comprise the total FreeRTOS heap space. */
+typedef struct HeapRegion
+{
+    uint8_t * pucStartAddress;
+    size_t xSizeInBytes;
+} HeapRegion_t;
+
+/* Used to pass information about the heap out of vPortGetHeapStats(). */
+typedef struct xHeapStats
+{
+    size_t xAvailableHeapSpaceInBytes;      /* The total heap size currently available - this is the sum of all the free blocks, not the largest block that can be allocated. */
+    size_t xSizeOfLargestFreeBlockInBytes;  /* The maximum size, in bytes, of all the free blocks within the heap at the time vPortGetHeapStats() is called. */
+    size_t xSizeOfSmallestFreeBlockInBytes; /* The minimum size, in bytes, of all the free blocks within the heap at the time vPortGetHeapStats() is called. */
+    size_t xNumberOfFreeBlocks;             /* The number of free memory blocks within the heap at the time vPortGetHeapStats() is called. */
+    size_t xMinimumEverFreeBytesRemaining;  /* The minimum amount of total free memory (sum of all free blocks) there has been in the heap since the system booted. */
+    size_t xNumberOfSuccessfulAllocations;  /* The number of calls to pvPortMalloc() that have returned a valid memory block. */
+    size_t xNumberOfSuccessfulFrees;        /* The number of calls to vPortFree() that has successfully freed a block of memory. */
+} HeapStats_t;
+
+/*
+ * Used to define multiple heap regions for use by heap_5.c.  This function
+ * must be called before any calls to pvPortMalloc() - not creating a task,
+ * queue, semaphore, mutex, software timer, event group, etc. will result in
+ * pvPortMalloc being called.
+ *
+ * pxHeapRegions passes in an array of HeapRegion_t structures - each of which
+ * defines a region of memory that can be used as the heap.  The array is
+ * terminated by a HeapRegions_t structure that has a size of 0.  The region
+ * with the lowest start address must appear first in the array.
+ */
+void vPortDefineHeapRegions( const HeapRegion_t * const pxHeapRegions ) PRIVILEGED_FUNCTION;
+
+/*
+ * Returns a HeapStats_t structure filled with information about the current
+ * heap state.
+ */
+void vPortGetHeapStats( HeapStats_t * pxHeapStats );
+
+/*
+ * Map to the memory management routines required for the port.
+ */
+void * pvPortMalloc( size_t xWantedSize ) PRIVILEGED_FUNCTION;
+void * pvPortCalloc( size_t xNum,
+                     size_t xSize ) PRIVILEGED_FUNCTION;
+void vPortFree( void * pv ) PRIVILEGED_FUNCTION;
+void vPortInitialiseBlocks( void ) PRIVILEGED_FUNCTION;
+size_t xPortGetFreeHeapSize( void ) PRIVILEGED_FUNCTION;
+size_t xPortGetMinimumEverFreeHeapSize( void ) PRIVILEGED_FUNCTION;
+void xPortResetHeapMinimumEverFreeHeapSize( void ) PRIVILEGED_FUNCTION;
 
 #if ( configSTACK_ALLOCATION_FROM_SEPARATE_HEAP == 1 )
-    void * pvPortMallocStack(size_t xSize) PRIVILEGED_FUNCTION;
-    void vPortFreeStack(void * pv) PRIVILEGED_FUNCTION;
+    void * pvPortMallocStack( size_t xSize ) PRIVILEGED_FUNCTION;
+    void vPortFreeStack( void * pv ) PRIVILEGED_FUNCTION;
 #else
-#define pvPortMallocStack    SramMalloc
-#define vPortFreeStack       SramFree
-#endif
-
-    /*
-     * Setup the hardware ready for the scheduler to take control.  This generally
-     * sets up a tick interrupt and sets timers for the correct tick frequency.
-     */
-    BaseType_t xPortStartScheduler(void) PRIVILEGED_FUNCTION;
-
-    /*
-     * Undo any hardware/ISR setup that was performed by xPortStartScheduler() so
-     * the hardware is left in its original condition after the scheduler stops
-     * executing.
-     */
-    void vPortEndScheduler(void) PRIVILEGED_FUNCTION;
-
-    /*
-     * The structures and methods of manipulating the MPU are contained within the
-     * port layer.
-     *
-     * Fills the xMPUSettings structure with the memory region information
-     * contained in xRegions.
-     */
+    #define pvPortMallocStack    pvPortMalloc
+    #define vPortFreeStack       vPortFree
+#endif
+
+/*
+ * This function resets the internal state of the heap module. It must be called
+ * by the application before restarting the scheduler.
+ */
+void vPortHeapResetState( void ) PRIVILEGED_FUNCTION;
+
+#if ( configUSE_MALLOC_FAILED_HOOK == 1 )
+
+/**
+ * task.h
+ * @code{c}
+ * void vApplicationMallocFailedHook( void )
+ * @endcode
+ *
+ * This hook function is called when allocation failed.
+ */
+    void vApplicationMallocFailedHook( void );
+#endif
+
+/*
+ * Setup the hardware ready for the scheduler to take control.  This generally
+ * sets up a tick interrupt and sets timers for the correct tick frequency.
+ */
+BaseType_t xPortStartScheduler( void ) PRIVILEGED_FUNCTION;
+
+/*
+ * Undo any hardware/ISR setup that was performed by xPortStartScheduler() so
+ * the hardware is left in its original condition after the scheduler stops
+ * executing.
+ */
+void vPortEndScheduler( void ) PRIVILEGED_FUNCTION;
+
+/*
+ * The structures and methods of manipulating the MPU are contained within the
+ * port layer.
+ *
+ * Fills the xMPUSettings structure with the memory region information
+ * contained in xRegions.
+ */
 #if ( portUSING_MPU_WRAPPERS == 1 )
     struct xMEMORY_REGION;
-    void vPortStoreTaskMPUSettings(xMPU_SETTINGS * xMPUSettings,
-                                   const struct xMEMORY_REGION * const xRegions,
-                                   StackType_t * pxBottomOfStack,
-                                   uint32_t ulStackDepth) PRIVILEGED_FUNCTION;
+    void vPortStoreTaskMPUSettings( xMPU_SETTINGS * xMPUSettings,
+                                    const struct xMEMORY_REGION * const xRegions,
+                                    StackType_t * pxBottomOfStack,
+                                    configSTACK_DEPTH_TYPE uxStackDepth ) PRIVILEGED_FUNCTION;
+#endif
+
+/**
+ * @brief Checks if the calling task is authorized to access the given buffer.
+ *
+ * @param pvBuffer The buffer which the calling task wants to access.
+ * @param ulBufferLength The length of the pvBuffer.
+ * @param ulAccessRequested The permissions that the calling task wants.
+ *
+ * @return pdTRUE if the calling task is authorized to access the buffer,
+ *         pdFALSE otherwise.
+ */
+#if ( portUSING_MPU_WRAPPERS == 1 )
+    BaseType_t xPortIsAuthorizedToAccessBuffer( const void * pvBuffer,
+                                                uint32_t ulBufferLength,
+                                                uint32_t ulAccessRequested ) PRIVILEGED_FUNCTION;
+#endif
+
+/**
+ * @brief Checks if the calling task is authorized to access the given kernel object.
+ *
+ * @param lInternalIndexOfKernelObject The index of the kernel object in the kernel
+ *                                     object handle pool.
+ *
+ * @return pdTRUE if the calling task is authorized to access the kernel object,
+ *         pdFALSE otherwise.
+ */
+#if ( ( portUSING_MPU_WRAPPERS == 1 ) && ( configUSE_MPU_WRAPPERS_V1 == 0 ) )
+
+    BaseType_t xPortIsAuthorizedToAccessKernelObject( int32_t lInternalIndexOfKernelObject ) PRIVILEGED_FUNCTION;
+
 #endif
 
 /* *INDENT-OFF* */

### external/FreeRTOS/Source/include/projdefs.h
@@ -1,6 +1,6 @@
 /*
- * FreeRTOS Kernel V10.4.6
- * Copyright (C) 2021 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ * FreeRTOS Kernel V11.3.0
+ * Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -33,17 +33,28 @@
  * Defines the prototype to which task functions must conform.  Defined in this
  * file to ensure the type is known before portable.h is included.
  */
-typedef void (* TaskFunction_t)(void *);
+typedef void (* TaskFunction_t)( void * arg );
 
 /* Converts a time in milliseconds to a time in ticks.  This macro can be
  * overridden by a macro of the same name defined in FreeRTOSConfig.h in case the
  * definition here is not suitable for your application. */
 #ifndef pdMS_TO_TICKS
-#define pdMS_TO_TICKS( xTimeInMs )    ( ( TickType_t ) ( ( ( TickType_t ) ( xTimeInMs ) * ( TickType_t ) configTICK_RATE_HZ ) / ( TickType_t ) 1000U ) )
+    #define pdMS_TO_TICKS( xTimeInMs )    ( ( TickType_t ) ( ( ( uint64_t ) ( xTimeInMs ) * ( uint64_t ) configTICK_RATE_HZ ) / ( uint64_t ) 1000U ) )
+#endif
+
+/* Converts a time in ticks to a time in milliseconds.  This macro can be
+ * overridden by a macro of the same name defined in FreeRTOSConfig.h in case the
+ * definition here is not suitable for your application. */
+#ifndef pdTICKS_TO_MS
+    #define pdTICKS_TO_MS( xTimeInTicks )    ( ( TickType_t ) ( ( ( uint64_t ) ( xTimeInTicks ) * ( uint64_t ) 1000U ) / ( uint64_t ) configTICK_RATE_HZ ) )
 #endif
 
 #define pdFALSE                                  ( ( BaseType_t ) 0 )
 #define pdTRUE                                   ( ( BaseType_t ) 1 )
+#define pdFALSE_SIGNED                           ( ( BaseType_t ) 0 )
+#define pdTRUE_SIGNED                            ( ( BaseType_t ) 1 )
+#define pdFALSE_UNSIGNED                         ( ( UBaseType_t ) 0 )
+#define pdTRUE_UNSIGNED                          ( ( UBaseType_t ) 1 )
 
 #define pdPASS                                   ( pdTRUE )
 #define pdFAIL                                   ( pdFALSE )
@@ -57,13 +68,17 @@ typedef void (* TaskFunction_t)(void *);
 
 /* Macros used for basic data corruption checks. */
 #ifndef configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES
-#define configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES    0
+    #define configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES    0
 #endif
 
-#if ( configUSE_16_BIT_TICKS == 1 )
-#define pdINTEGRITY_CHECK_VALUE    0x5a5a
+#if ( configTICK_TYPE_WIDTH_IN_BITS == TICK_TYPE_WIDTH_16_BITS )
+    #define pdINTEGRITY_CHECK_VALUE    0x5a5a
+#elif ( configTICK_TYPE_WIDTH_IN_BITS == TICK_TYPE_WIDTH_32_BITS )
+    #define pdINTEGRITY_CHECK_VALUE    0x5a5a5a5aUL
+#elif ( configTICK_TYPE_WIDTH_IN_BITS == TICK_TYPE_WIDTH_64_BITS )
+    #define pdINTEGRITY_CHECK_VALUE    0x5a5a5a5a5a5a5a5aULL
 #else
-#define pdINTEGRITY_CHECK_VALUE    0x5a5a5a5aUL
+    #error configTICK_TYPE_WIDTH_IN_BITS set to unsupported tick type width.
 #endif
 
 /* The following errno values are used by FreeRTOS+ components, not FreeRTOS
@@ -96,6 +111,7 @@ typedef void (* TaskFunction_t)(void *);
 #define pdFREERTOS_ERRNO_ENOTEMPTY        90  /* Directory not empty */
 #define pdFREERTOS_ERRNO_ENAMETOOLONG     91  /* File or path name too long */
 #define pdFREERTOS_ERRNO_EOPNOTSUPP       95  /* Operation not supported on transport endpoint */
+#define pdFREERTOS_ERRNO_EAFNOSUPPORT     97  /* Address family not supported by protocol */
 #define pdFREERTOS_ERRNO_ENOBUFS          105 /* No buffer space available */
 #define pdFREERTOS_ERRNO_ENOPROTOOPT      109 /* Protocol not available */
 #define pdFREERTOS_ERRNO_EADDRINUSE       112 /* Address already in use */

### external/FreeRTOS/Source/include/queue.h
[binary or diff unavailable]

### external/FreeRTOS/Source/include/semphr.h
@@ -1,6 +1,6 @@
 /*
- * FreeRTOS Kernel V10.4.6
- * Copyright (C) 2021 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ * FreeRTOS Kernel V11.3.0
+ * Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -30,15 +30,15 @@
 #define SEMAPHORE_H
 
 #ifndef INC_FREERTOS_H
-#error "include FreeRTOS.h" must appear in source files before "include semphr.h"
+    #error "include FreeRTOS.h" must appear in source files before "include semphr.h"
 #endif
 
 #include "queue.h"
 
 typedef QueueHandle_t SemaphoreHandle_t;
 
-#define semBINARY_SEMAPHORE_QUEUE_LENGTH    ( ( uint8_t ) 1U )
-#define semSEMAPHORE_QUEUE_ITEM_LENGTH      ( ( uint8_t ) 0U )
+#define semBINARY_SEMAPHORE_QUEUE_LENGTH    ( ( UBaseType_t ) 1U )
+#define semSEMAPHORE_QUEUE_ITEM_LENGTH      ( ( UBaseType_t ) 0U )
 #define semGIVE_BLOCK_TIME                  ( ( TickType_t ) 0U )
 
 
@@ -94,14 +94,14 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * \ingroup Semaphores
  */
 #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
-#define vSemaphoreCreateBinary( xSemaphore )                                                                                     \
-    {                                                                                                                                \
+    #define vSemaphoreCreateBinary( xSemaphore )                                                                                     \
+    do {                                                                                                                             \
         ( xSemaphore ) = xQueueGenericCreate( ( UBaseType_t ) 1, semSEMAPHORE_QUEUE_ITEM_LENGTH, queueQUEUE_TYPE_BINARY_SEMAPHORE ); \
         if( ( xSemaphore ) != NULL )                                                                                                 \
         {                                                                                                                            \
             ( void ) xSemaphoreGive( ( xSemaphore ) );                                                                               \
         }                                                                                                                            \
-    }
+    } while( 0 )
 #endif
 
 /**
@@ -164,7 +164,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * \ingroup Semaphores
  */
 #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
-#define xSemaphoreCreateBinary()    xQueueGenericCreate( ( UBaseType_t ) 1, semSEMAPHORE_QUEUE_ITEM_LENGTH, queueQUEUE_TYPE_BINARY_SEMAPHORE )
+    #define xSemaphoreCreateBinary()    xQueueGenericCreate( ( UBaseType_t ) 1, semSEMAPHORE_QUEUE_ITEM_LENGTH, queueQUEUE_TYPE_BINARY_SEMAPHORE )
 #endif
 
 /**
@@ -225,7 +225,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * \ingroup Semaphores
  */
 #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
-#define xSemaphoreCreateBinaryStatic( pxStaticSemaphore )    xQueueGenericCreateStatic( ( UBaseType_t ) 1, semSEMAPHORE_QUEUE_ITEM_LENGTH, NULL, pxStaticSemaphore, queueQUEUE_TYPE_BINARY_SEMAPHORE )
+    #define xSemaphoreCreateBinaryStatic( pxStaticSemaphore )    xQueueGenericCreateStatic( ( UBaseType_t ) 1, semSEMAPHORE_QUEUE_ITEM_LENGTH, NULL, ( pxStaticSemaphore ), queueQUEUE_TYPE_BINARY_SEMAPHORE )
 #endif /* configSUPPORT_STATIC_ALLOCATION */
 
 /**
@@ -391,7 +391,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * \ingroup Semaphores
  */
 #if ( configUSE_RECURSIVE_MUTEXES == 1 )
-#define xSemaphoreTakeRecursive( xMutex, xBlockTime )    xQueueTakeMutexRecursive( ( xMutex ), ( xBlockTime ) )
+    #define xSemaphoreTakeRecursive( xMutex, xBlockTime )    xQueueTakeMutexRecursive( ( xMutex ), ( xBlockTime ) )
 #endif
 
 /**
@@ -544,7 +544,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * \ingroup Semaphores
  */
 #if ( configUSE_RECURSIVE_MUTEXES == 1 )
-#define xSemaphoreGiveRecursive( xMutex )    xQueueGiveMutexRecursive( ( xMutex ) )
+    #define xSemaphoreGiveRecursive( xMutex )    xQueueGiveMutexRecursive( ( xMutex ) )
 #endif
 
 /**
@@ -731,8 +731,8 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * \defgroup xSemaphoreCreateMutex xSemaphoreCreateMutex
  * \ingroup Semaphores
  */
-#if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
-#define xSemaphoreCreateMutex()    xQueueCreateMutex( queueQUEUE_TYPE_MUTEX )
+#if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configUSE_MUTEXES == 1 ) )
+    #define xSemaphoreCreateMutex()    xQueueCreateMutex( queueQUEUE_TYPE_MUTEX )
 #endif
 
 /**
@@ -794,9 +794,9 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * \defgroup xSemaphoreCreateMutexStatic xSemaphoreCreateMutexStatic
  * \ingroup Semaphores
  */
-#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
-#define xSemaphoreCreateMutexStatic( pxMutexBuffer )    xQueueCreateMutexStatic( queueQUEUE_TYPE_MUTEX, ( pxMutexBuffer ) )
-#endif /* configSUPPORT_STATIC_ALLOCATION */
+#if ( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_MUTEXES == 1 ) )
+    #define xSemaphoreCreateMutexStatic( pxMutexBuffer )    xQueueCreateMutexStatic( queueQUEUE_TYPE_MUTEX, ( pxMutexBuffer ) )
+#endif
 
 
 /**
@@ -808,7 +808,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * Creates a new recursive mutex type semaphore instance, and returns a handle
  * by which the new recursive mutex can be referenced.
  *
- * Internally, within the FreeRTOS implementation, recursive mutexs use a block
+ * Internally, within the FreeRTOS implementation, recursive mutexes use a block
  * of memory, in which the mutex structure is stored.  If a recursive mutex is
  * created using xSemaphoreCreateRecursiveMutex() then the required memory is
  * automatically dynamically allocated inside the
@@ -865,7 +865,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * \ingroup Semaphores
  */
 #if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configUSE_RECURSIVE_MUTEXES == 1 ) )
-#define xSemaphoreCreateRecursiveMutex()    xQueueCreateMutex( queueQUEUE_TYPE_RECURSIVE_MUTEX )
+    #define xSemaphoreCreateRecursiveMutex()    xQueueCreateMutex( queueQUEUE_TYPE_RECURSIVE_MUTEX )
 #endif
 
 /**
@@ -877,7 +877,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * Creates a new recursive mutex type semaphore instance, and returns a handle
  * by which the new recursive mutex can be referenced.
  *
- * Internally, within the FreeRTOS implementation, recursive mutexs use a block
+ * Internally, within the FreeRTOS implementation, recursive mutexes use a block
  * of memory, in which the mutex structure is stored.  If a recursive mutex is
  * created using xSemaphoreCreateRecursiveMutex() then the required memory is
  * automatically dynamically allocated inside the
@@ -940,7 +940,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * \ingroup Semaphores
  */
 #if ( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_RECURSIVE_MUTEXES == 1 ) )
-#define xSemaphoreCreateRecursiveMutexStatic( pxStaticSemaphore )    xQueueCreateMutexStatic( queueQUEUE_TYPE_RECURSIVE_MUTEX, pxStaticSemaphore )
+    #define xSemaphoreCreateRecursiveMutexStatic( pxStaticSemaphore )    xQueueCreateMutexStatic( queueQUEUE_TYPE_RECURSIVE_MUTEX, ( pxStaticSemaphore ) )
 #endif /* configSUPPORT_STATIC_ALLOCATION */
 
 /**
@@ -1022,7 +1022,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * \ingroup Semaphores
  */
 #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
-#define xSemaphoreCreateCounting( uxMaxCount, uxInitialCount )    xQueueCreateCountingSemaphore( ( uxMaxCount ), ( uxInitialCount ) )
+    #define xSemaphoreCreateCounting( uxMaxCount, uxInitialCount )    xQueueCreateCountingSemaphore( ( uxMaxCount ), ( uxInitialCount ) )
 #endif
 
 /**
@@ -1109,7 +1109,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * \ingroup Semaphores
  */
 #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
-#define xSemaphoreCreateCountingStatic( uxMaxCount, uxInitialCount, pxSemaphoreBuffer )    xQueueCreateCountingSemaphoreStatic( ( uxMaxCount ), ( uxInitialCount ), ( pxSemaphoreBuffer ) )
+    #define xSemaphoreCreateCountingStatic( uxMaxCount, uxInitialCount, pxSemaphoreBuffer )    xQueueCreateCountingSemaphoreStatic( ( uxMaxCount ), ( uxInitialCount ), ( pxSemaphoreBuffer ) )
 #endif /* configSUPPORT_STATIC_ALLOCATION */
 
 /**
@@ -1126,7 +1126,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * \defgroup vSemaphoreDelete vSemaphoreDelete
  * \ingroup Semaphores
  */
-#define vSemaphoreDelete( xSemaphore )                   vQueueDelete( ( QueueHandle_t ) ( xSemaphore ) )
+#define vSemaphoreDelete( xSemaphore )    vQueueDelete( ( QueueHandle_t ) ( xSemaphore ) )
 
 /**
  * semphr.h
@@ -1143,7 +1143,9 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * the holder may change between the function exiting and the returned value
  * being tested.
  */
-#define xSemaphoreGetMutexHolder( xSemaphore )           xQueueGetMutexHolder( ( xSemaphore ) )
+#if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) )
+    #define xSemaphoreGetMutexHolder( xSemaphore )    xQueueGetMutexHolder( ( xSemaphore ) )
+#endif
 
 /**
  * semphr.h
@@ -1156,7 +1158,9 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * by a task), return NULL.
  *
  */
-#define xSemaphoreGetMutexHolderFromISR( xSemaphore )    xQueueGetMutexHolderFromISR( ( xSemaphore ) )
+#if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) )
+    #define xSemaphoreGetMutexHolderFromISR( xSemaphore )    xQueueGetMutexHolderFromISR( ( xSemaphore ) )
+#endif
 
 /**
  * semphr.h
@@ -1170,7 +1174,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * semaphore is not available.
  *
  */
-#define uxSemaphoreGetCount( xSemaphore )                uxQueueMessagesWaiting( ( QueueHandle_t ) ( xSemaphore ) )
+#define uxSemaphoreGetCount( xSemaphore )           uxQueueMessagesWaiting( ( QueueHandle_t ) ( xSemaphore ) )
 
 /**
  * semphr.h
@@ -1184,6 +1188,28 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * semaphore is not available.
  *
  */
-#define uxSemaphoreGetCountFromISR( xSemaphore )         uxQueueMessagesWaitingFromISR( ( QueueHandle_t ) ( xSemaphore ) )
+#define uxSemaphoreGetCountFromISR( xSemaphore )    uxQueueMessagesWaitingFromISR( ( QueueHandle_t ) ( xSemaphore ) )
+
+/**
+ * semphr.h
+ * @code{c}
+ * BaseType_t xSemaphoreGetStaticBuffer( SemaphoreHandle_t xSemaphore,
+ *                                       StaticSemaphore_t ** ppxSemaphoreBuffer );
+ * @endcode
+ *
+ * Retrieve pointer to a statically created binary semaphore, counting semaphore,
+ * or mutex semaphore's data structure buffer. This is the same buffer that is
+ * supplied at the time of creation.
+ *
+ * @param xSemaphore The semaphore for which to retrieve the buffer.
+ *
+ * @param ppxSemaphoreBuffer Used to return a pointer to the semaphore's
+ * data structure buffer.
+ *
+ * @return pdTRUE if buffer was retrieved, pdFALSE otherwise.
+ */
+#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
+    #define xSemaphoreGetStaticBuffer( xSemaphore, ppxSemaphoreBuffer )    xQueueGenericGetStaticBuffers( ( QueueHandle_t ) ( xSemaphore ), NULL, ( ppxSemaphoreBuffer ) )
+#endif /* configSUPPORT_STATIC_ALLOCATION */
 
 #endif /* SEMAPHORE_H */

### external/FreeRTOS/Source/include/stack_macros.h
@@ -1,6 +1,6 @@
 /*
- * FreeRTOS Kernel V10.4.6
- * Copyright (C) 2021 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ * FreeRTOS Kernel V11.3.0
+ * Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -50,62 +50,80 @@
  * use on the stack.
  */
 #ifndef portSTACK_LIMIT_PADDING
-#define portSTACK_LIMIT_PADDING    0
+    #define portSTACK_LIMIT_PADDING    0
 #endif
 
-#if ( ( configCHECK_FOR_STACK_OVERFLOW == 1 ) && ( portSTACK_GROWTH < 0 ) )
+/* Stack overflow check is not straight forward to implement for MPU ports
+ * because of the following reasons:
+ * 1. The context is stored in TCB and as a result, pxTopOfStack member points
+ *    to the context location in TCB.
+ * 2. System calls are executed on a separate privileged only stack.
+ *
+ * It is still okay because an MPU region is used to protect task stack which
+ * means task stack overflow will trigger an MPU fault for unprivileged tasks.
+ * Additionally, architectures with hardware stack overflow checking support
+ * (such as Armv8-M) will trigger a fault when a task's stack overflows.
+ */
+#if ( ( configCHECK_FOR_STACK_OVERFLOW == 1 ) && ( portSTACK_GROWTH < 0 ) && ( portUSING_MPU_WRAPPERS != 1 ) )
 
 /* Only the current stack state is to be checked. */
-#define taskCHECK_FOR_STACK_OVERFLOW()                                                            \
-    {                                                                                                 \
-        /* Is the currently saved stack pointer within the stack limit? */                            \
-        if( pxCurrentTCB->pxTopOfStack <= pxCurrentTCB->pxStack + portSTACK_LIMIT_PADDING )           \
-        {                                                                                             \
-            vApplicationStackOverflowHook( ( TaskHandle_t ) pxCurrentTCB, pxCurrentTCB->pcTaskName ); \
-        }                                                                                             \
-    }
+    #define taskCHECK_FOR_STACK_OVERFLOW()                                                      \
+    do                                                                                          \
+    {                                                                                           \
+        /* Is the currently saved stack pointer within the stack limit? */                      \
+        if( pxCurrentTCB->pxTopOfStack <= pxCurrentTCB->pxStack + portSTACK_LIMIT_PADDING )     \
+        {                                                                                       \
+            char * pcOverflowTaskName = pxCurrentTCB->pcTaskName;                               \
+            vApplicationStackOverflowHook( ( TaskHandle_t ) pxCurrentTCB, pcOverflowTaskName ); \
+        }                                                                                       \
+    } while( 0 )
 
 #endif /* configCHECK_FOR_STACK_OVERFLOW == 1 */
 /*-----------------------------------------------------------*/
 
-#if ( ( configCHECK_FOR_STACK_OVERFLOW == 1 ) && ( portSTACK_GROWTH > 0 ) )
+#if ( ( configCHECK_FOR_STACK_OVERFLOW == 1 ) && ( portSTACK_GROWTH > 0 ) && ( portUSING_MPU_WRAPPERS != 1 ) )
 
 /* Only the current stack state is to be checked. */
-#define taskCHECK_FOR_STACK_OVERFLOW()                                                            \
-    {                                                                                                 \
-                                                                                                      \
-        /* Is the currently saved stack pointer within the stack limit? */                            \
-        if( pxCurrentTCB->pxTopOfStack >= pxCurrentTCB->pxEndOfStack - portSTACK_LIMIT_PADDING )      \
-        {                                                                                             \
-            vApplicationStackOverflowHook( ( TaskHandle_t ) pxCurrentTCB, pxCurrentTCB->pcTaskName ); \
-        }                                                                                             \
-    }
+    #define taskCHECK_FOR_STACK_OVERFLOW()                                                       \
+    do                                                                                           \
+    {                                                                                            \
+        /* Is the currently saved stack pointer within the stack limit? */                       \
+        if( pxCurrentTCB->pxTopOfStack >= pxCurrentTCB->pxEndOfStack - portSTACK_LIMIT_PADDING ) \
+        {                                                                                        \
+            char * pcOverflowTaskName = pxCurrentTCB->pcTaskName;                                \
+            vApplicationStackOverflowHook( ( TaskHandle_t ) pxCurrentTCB, pcOverflowTaskName );  \
+        }                                                                                        \
+    } while( 0 )
 
 #endif /* configCHECK_FOR_STACK_OVERFLOW == 1 */
 /*-----------------------------------------------------------*/
 
-#if ( ( configCHECK_FOR_STACK_OVERFLOW > 1 ) && ( portSTACK_GROWTH < 0 ) )
-
-#define taskCHECK_FOR_STACK_OVERFLOW()                                                            \
-    {                                                                                                 \
-        const uint32_t * const pulStack = ( uint32_t * ) pxCurrentTCB->pxStack;                       \
-        const uint32_t ulCheckValue = ( uint32_t ) 0xa5a5a5a5;                                        \
-                                                                                                      \
-        if( ( pulStack[ 0 ] != ulCheckValue ) ||                                                      \
-            ( pulStack[ 1 ] != ulCheckValue ) ||                                                      \
-            ( pulStack[ 2 ] != ulCheckValue ) ||                                                      \
-            ( pulStack[ 3 ] != ulCheckValue ) )                                                       \
-        {                                                                                             \
-            vApplicationStackOverflowHook( ( TaskHandle_t ) pxCurrentTCB, pxCurrentTCB->pcTaskName ); \
-        }                                                                                             \
-    }
+#if ( ( configCHECK_FOR_STACK_OVERFLOW > 1 ) && ( portSTACK_GROWTH < 0 ) && ( portUSING_MPU_WRAPPERS != 1 ) )
+
+    #define taskCHECK_FOR_STACK_OVERFLOW()                                                       \
+    do                                                                                           \
+    {                                                                                            \
+        const uint32_t * const pulStack = ( uint32_t * ) pxCurrentTCB->pxStack;                  \
+        const uint32_t ulCheckValue = ( uint32_t ) 0xa5a5a5a5U;                                  \
+                                                                                                 \
+        if( ( pxCurrentTCB->pxTopOfStack <= pxCurrentTCB->pxStack + portSTACK_LIMIT_PADDING ) || \
+            ( pulStack[ 0 ] != ulCheckValue ) ||                                                 \
+            ( pulStack[ 1 ] != ulCheckValue ) ||                                                 \
+            ( pulStack[ 2 ] != ulCheckValue ) ||                                                 \
+            ( pulStack[ 3 ] != ulCheckValue ) )                                                  \
+        {                                                                                        \
+            char * pcOverflowTaskName = pxCurrentTCB->pcTaskName;                                \
+            vApplicationStackOverflowHook( ( TaskHandle_t ) pxCurrentTCB, pcOverflowTaskName );  \
+        }                                                                                        \
+    } while( 0 )
 
 #endif /* #if( configCHECK_FOR_STACK_OVERFLOW > 1 ) */
 /*-----------------------------------------------------------*/
 
-#if ( ( configCHECK_FOR_STACK_OVERFLOW > 1 ) && ( portSTACK_GROWTH > 0 ) )
+#if ( ( configCHECK_FOR_STACK_OVERFLOW > 1 ) && ( portSTACK_GROWTH > 0 ) && ( portUSING_MPU_WRAPPERS != 1 ) )
 
-#define taskCHECK_FOR_STACK_OVERFLOW()                                                                                                \
+    #define taskCHECK_FOR_STACK_OVERFLOW()                                                                                                \
+    do                                                                                                                                    \
     {                                                                                                                                     \
         int8_t * pcEndOfStack = ( int8_t * ) pxCurrentTCB->pxEndOfStack;                                                                  \
         static const uint8_t ucExpectedStackBytes[] = { tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE,   \
@@ -114,22 +132,22 @@
                                                         tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE,   \
                                                         tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE }; \
                                                                                                                                           \
-                                                                                                                                          \
         pcEndOfStack -= sizeof( ucExpectedStackBytes );                                                                                   \
                                                                                                                                           \
-        /* Has the extremity of the task stack ever been written over? */                                                                 \
-        if( memcmp( ( void * ) pcEndOfStack, ( void * ) ucExpectedStackBytes, sizeof( ucExpectedStackBytes ) ) != 0 )                     \
+        if( ( pxCurrentTCB->pxTopOfStack >= pxCurrentTCB->pxEndOfStack - portSTACK_LIMIT_PADDING ) ||                                     \
+            ( memcmp( ( void * ) pcEndOfStack, ( void * ) ucExpectedStackBytes, sizeof( ucExpectedStackBytes ) ) != 0 ) )                 \
         {                                                                                                                                 \
-            vApplicationStackOverflowHook( ( TaskHandle_t ) pxCurrentTCB, pxCurrentTCB->pcTaskName );                                     \
+            char * pcOverflowTaskName = pxCurrentTCB->pcTaskName;                                                                         \
+            vApplicationStackOverflowHook( ( TaskHandle_t ) pxCurrentTCB, pcOverflowTaskName );                                           \
         }                                                                                                                                 \
-    }
+    } while( 0 )
 
 #endif /* #if( configCHECK_FOR_STACK_OVERFLOW > 1 ) */
 /*-----------------------------------------------------------*/
 
 /* Remove stack overflow macro if not being used. */
 #ifndef taskCHECK_FOR_STACK_OVERFLOW
-#define taskCHECK_FOR_STACK_OVERFLOW()
+    #define taskCHECK_FOR_STACK_OVERFLOW()
 #endif
 
 

### external/FreeRTOS/Source/include/stdint.readme
@@ -1,6 +1,6 @@
 /*
- * FreeRTOS Kernel V10.4.6
- * Copyright (C) 2021 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ * FreeRTOS Kernel V11.3.0
+ * Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
  *
  * SPDX-License-Identifier: MIT
  *

### external/FreeRTOS/Source/include/stream_buffer.h
@@ -1,6 +1,6 @@
 /*
- * FreeRTOS Kernel V10.4.6
- * Copyright (C) 2021 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ * FreeRTOS Kernel V11.3.0
+ * Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -40,20 +40,20 @@
  * writer and reader to be different tasks or interrupts, but, unlike other
  * FreeRTOS objects, it is not safe to have multiple different writers or
  * multiple different readers.  If there are to be multiple different writers
- * then the application writer must place each call to a writing API function
- * (such as xStreamBufferSend()) inside a critical section and set the send
- * block time to 0.  Likewise, if there are to be multiple different readers
- * then the application writer must place each call to a reading API function
- * (such as xStreamBufferReceive()) inside a critical section section and set the
- * receive block time to 0.
+ * then the application writer must serialize calls to writing API functions
+ * (such as xStreamBufferSend()).  Likewise, if there are to be multiple
+ * different readers then the application writer must serialize calls to reading
+ * API functions (such as xStreamBufferReceive()).  One way to achieve such
+ * serialization in single core or SMP kernel is to place each API call inside a
+ * critical section and use a block time of 0.
  *
  */
 
 #ifndef STREAM_BUFFER_H
 #define STREAM_BUFFER_H
 
 #ifndef INC_FREERTOS_H
-#error "include FreeRTOS.h must appear in source files before include stream_buffer.h"
+    #error "include FreeRTOS.h must appear in source files before include stream_buffer.h"
 #endif
 
 /* *INDENT-OFF* */
@@ -62,802 +62,1213 @@
 #endif
 /* *INDENT-ON* */
 
-    /**
-     * Type by which stream buffers are referenced.  For example, a call to
-     * xStreamBufferCreate() returns an StreamBufferHandle_t variable that can
-     * then be used as a parameter to xStreamBufferSend(), xStreamBufferReceive(),
-     * etc.
-     */
-    struct StreamBufferDef_t;
-    typedef struct StreamBufferDef_t * StreamBufferHandle_t;
-
-
-    /**
-     * stream_buffer.h
-     *
-     * @code{c}
-     * StreamBufferHandle_t xStreamBufferCreate( size_t xBufferSizeBytes, size_t xTriggerLevelBytes );
-     * @endcode
-     *
-     * Creates a new stream buffer using dynamically allocated memory.  See
-     * xStreamBufferCreateStatic() for a version that uses statically allocated
-     * memory (memory that is allocated at compile time).
-     *
-     * configSUPPORT_DYNAMIC_ALLOCATION must be set to 1 or left undefined in
-     * FreeRTOSConfig.h for xStreamBufferCreate() to be available.
-     *
-     * @param xBufferSizeBytes The total number of bytes the stream buffer will be
-     * able to hold at any one time.
-     *
-     * @param xTriggerLevelBytes The number of bytes that must be in the stream
-     * buffer before a task that is blocked on the stream buffer to wait for data is
-     * moved out of the blocked state.  For example, if a task is blocked on a read
-     * of an empty stream buffer that has a trigger level of 1 then the task will be
-     * unblocked when a single byte is written to the buffer or the task's block
-     * time expires.  As another example, if a task is blocked on a read of an empty
-     * stream buffer that has a trigger level of 10 then the task will not be
-     * unblocked until the stream buffer contains at least 10 bytes or the task's
-     * block time expires.  If a reading task's block time expires before the
-     * trigger level is reached then the task will still receive however many bytes
-     * are actually available.  Setting a trigger level of 0 will result in a
-     * trigger level of 1 being used.  It is not valid to specify a trigger level
-     * that is greater than the buffer size.
-     *
-     * @return If NULL is returned, then the stream buffer cannot be created
-     * because there is insufficient heap memory available for FreeRTOS to allocate
-     * the stream buffer data structures and storage area.  A non-NULL value being
-     * returned indicates that the stream buffer has been created successfully -
-     * the returned value should be stored as the handle to the created stream
-     * buffer.
-     *
-     * Example use:
-     * @code{c}
-     *
-     * void vAFunction( void )
-     * {
-     * StreamBufferHandle_t xStreamBuffer;
-     * const size_t xStreamBufferSizeBytes = 100, xTriggerLevel = 10;
-     *
-     *  // Create a stream buffer that can hold 100 bytes.  The memory used to hold
-     *  // both the stream buffer structure and the data in the stream buffer is
-     *  // allocated dynamically.
-     *  xStreamBuffer = xStreamBufferCreate( xStreamBufferSizeBytes, xTriggerLevel );
-     *
-     *  if( xStreamBuffer == NULL )
-     *  {
-     *      // There was not enough heap memory space available to create the
-     *      // stream buffer.
-     *  }
-     *  else
-     *  {
-     *      // The stream buffer was created successfully and can now be used.
-     *  }
-     * }
-     * @endcode
-     * \defgroup xStreamBufferCreate xStreamBufferCreate
-     * \ingroup StreamBufferManagement
-     */
-#define xStreamBufferCreate( xBufferSizeBytes, xTriggerLevelBytes )    xStreamBufferGenericCreate( xBufferSizeBytes, xTriggerLevelBytes, pdFALSE )
-
-    /**
-     * stream_buffer.h
-     *
-     * @code{c}
-     * StreamBufferHandle_t xStreamBufferCreateStatic( size_t xBufferSizeBytes,
-     *                                              size_t xTriggerLevelBytes,
-     *                                              uint8_t *pucStreamBufferStorageArea,
-     *                                              StaticStreamBuffer_t *pxStaticStreamBuffer );
-     * @endcode
-     * Creates a new stream buffer using statically allocated memory.  See
-     * xStreamBufferCreate() for a version that uses dynamically allocated memory.
-     *
-     * configSUPPORT_STATIC_ALLOCATION must be set to 1 in FreeRTOSConfig.h for
-     * xStreamBufferCreateStatic() to be available.
-     *
-     * @param xBufferSizeBytes The size, in bytes, of the buffer pointed to by the
-     * pucStreamBufferStorageArea parameter.
-     *
-     * @param xTriggerLevelBytes The number of bytes that must be in the stream
-     * buffer before a task that is blocked on the stream buffer to wait for data is
-     * moved out of the blocked state.  For example, if a task is blocked on a read
-     * of an empty stream buffer that has a trigger level of 1 then the task will be
-     * unblocked when a single byte is written to the buffer or the task's block
-     * time expires.  As another example, if a task is blocked on a read of an empty
-     * stream buffer that has a trigger level of 10 then the task will not be
-     * unblocked until the stream buffer contains at least 10 bytes or the task's
-     * block time expires.  If a reading task's block time expires before the
-     * trigger level is reached then the task will still receive however many bytes
-     * are actually available.  Setting a trigger level of 0 will result in a
-     * trigger level of 1 being used.  It is not valid to specify a trigger level
-     * that is greater than the buffer size.
-     *
-     * @param pucStreamBufferStorageArea Must point to a uint8_t array that is at
-     * least xBufferSizeBytes big.  This is the array to which streams are
-     * copied when they are written to the stream buffer.
-     *
-     * @param pxStaticStreamBuffer Must point to a variable of type
-     * StaticStreamBuffer_t, which will be used to hold the stream buffer's data
-     * structure.
-     *
-     * @return If the stream buffer is created successfully then a handle to the
-     * created stream buffer is returned. If either pucStreamBufferStorageArea or
-     * pxStaticstreamBuffer are NULL then NULL is returned.
-     *
-     * Example use:
-     * @code{c}
-     *
-     * // Used to dimension the array used to hold the streams.  The available space
-     * // will actually be one less than this, so 999.
-     #define STORAGE_SIZE_BYTES 1000
-     *
-     * // Defines the memory that will actually hold the streams within the stream
-     * // buffer.
-     * static uint8_t ucStorageBuffer[ STORAGE_SIZE_BYTES ];
-     *
-     * // The variable used to hold the stream buffer structure.
-     * StaticStreamBuffer_t xStreamBufferStruct;
-     *
-     * void MyFunction( void )
-     * {
-     * StreamBufferHandle_t xStreamBuffer;
-     * const size_t xTriggerLevel = 1;
-     *
-     *  xStreamBuffer = xStreamBufferCreateStatic( sizeof( ucStorageBuffer ),
-     *                                             xTriggerLevel,
-     *                                             ucStorageBuffer,
-     *                                             &xStreamBufferStruct );
-     *
-     *  // As neither the pucStreamBufferStorageArea or pxStaticStreamBuffer
-     *  // parameters were NULL, xStreamBuffer will not be NULL, and can be used to
-     *  // reference the created stream buffer in other stream buffer API calls.
-     *
-     *  // Other code that uses the stream buffer can go here.
-     * }
-     *
-     * @endcode
-     * \defgroup xStreamBufferCreateStatic xStreamBufferCreateStatic
-     * \ingroup StreamBufferManagement
-     */
+/**
+ * Type of stream buffer. For internal use only.
+ */
+#define sbTYPE_STREAM_BUFFER             ( ( BaseType_t ) 0 )
+#define sbTYPE_MESSAGE_BUFFER            ( ( BaseType_t ) 1 )
+#define sbTYPE_STREAM_BATCHING_BUFFER    ( ( BaseType_t ) 2 )
+
+/**
+ * Type by which stream buffers are referenced.  For example, a call to
+ * xStreamBufferCreate() returns an StreamBufferHandle_t variable that can
+ * then be used as a parameter to xStreamBufferSend(), xStreamBufferReceive(),
+ * etc.
+ */
+struct StreamBufferDef_t;
+typedef struct StreamBufferDef_t * StreamBufferHandle_t;
+
+/**
+ *  Type used as a stream buffer's optional callback.
+ */
+typedef void (* StreamBufferCallbackFunction_t)( StreamBufferHandle_t xStreamBuffer,
+                                                 BaseType_t xIsInsideISR,
+                                                 BaseType_t * const pxHigherPriorityTaskWoken );
+
+/**
+ * stream_buffer.h
+ *
+ * @code{c}
+ * StreamBufferHandle_t xStreamBufferCreate( size_t xBufferSizeBytes, size_t xTriggerLevelBytes );
+ * @endcode
+ *
+ * Creates a new stream buffer using dynamically allocated memory.  See
+ * xStreamBufferCreateStatic() for a version that uses statically allocated
+ * memory (memory that is allocated at compile time).
+ *
+ * configSUPPORT_DYNAMIC_ALLOCATION must be set to 1 or left undefined in
+ * FreeRTOSConfig.h for xStreamBufferCreate() to be available.
+ * configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
+ * xStreamBufferCreate() to be available.
+ *
+ * @param xBufferSizeBytes The total number of bytes the stream buffer will be
+ * able to hold at any one time.
+ *
+ * @param xTriggerLevelBytes The number of bytes that must be in the stream
+ * buffer before a task that is blocked on the stream buffer to wait for data is
+ * moved out of the blocked state.  For example, if a task is blocked on a read
+ * of an empty stream buffer that has a trigger level of 1 then the task will be
+ * unblocked when a single byte is written to the buffer or the task's block
+ * time expires.  As another example, if a task is blocked on a read of an empty
+ * stream buffer that has a trigger level of 10 then the task will not be
+ * unblocked until the stream buffer contains at least 10 bytes or the task's
+ * block time expires.  If a reading task's block time expires before the
+ * trigger level is reached then the task will still receive however many bytes
+ * are actually available.  Setting a trigger level of 0 will result in a
+ * trigger level of 1 being used.  It is not valid to specify a trigger level
+ * that is greater than the buffer size.
+ *
+ * @param pxSendCompletedCallback Callback invoked when number of bytes at least equal to
+ * trigger level is sent to the stream buffer. If the parameter is NULL, it will use the default
+ * implementation provided by sbSEND_COMPLETED macro. To enable the callback,
+ * configUSE_SB_COMPLETED_CALLBACK must be set to 1 in FreeRTOSConfig.h.
+ *
+ * @param pxReceiveCompletedCallback Callback invoked when more than zero bytes are read from a
+ * stream buffer. If the parameter is NULL, it will use the default
+ * implementation provided by sbRECEIVE_COMPLETED macro. To enable the callback,
+ * configUSE_SB_COMPLETED_CALLBACK must be set to 1 in FreeRTOSConfig.h.
+ *
+ * @return If NULL is returned, then the stream buffer cannot be created
+ * because there is insufficient heap memory available for FreeRTOS to allocate
+ * the stream buffer data structures and storage area.  A non-NULL value being
+ * returned indicates that the stream buffer has been created successfully -
+ * the returned value should be stored as the handle to the created stream
+ * buffer.
+ *
+ * Example use:
+ * @code{c}
+ *
+ * void vAFunction( void )
+ * {
+ * StreamBufferHandle_t xStreamBuffer;
+ * const size_t xStreamBufferSizeBytes = 100, xTriggerLevel = 10;
+ *
+ *  // Create a stream buffer that can hold 100 bytes.  The memory used to hold
+ *  // both the stream buffer structure and the data in the stream buffer is
+ *  // allocated dynamically.
+ *  xStreamBuffer = xStreamBufferCreate( xStreamBufferSizeBytes, xTriggerLevel );
+ *
+ *  if( xStreamBuffer == NULL )
+ *  {
+ *      // There was not enough heap memory space available to create the
+ *      // stream buffer.
+ *  }
+ *  else
+ *  {
+ *      // The stream buffer was created successfully and can now be used.
+ *  }
+ * }
+ * @endcode
+ * \defgroup xStreamBufferCreate xStreamBufferCreate
+ * \ingroup StreamBufferManagement
+ */
+
+#define xStreamBufferCreate( xBufferSizeBytes, xTriggerLevelBytes ) \
+    xStreamBufferGenericCreate( ( xBufferSizeBytes ), ( xTriggerLevelBytes ), sbTYPE_STREAM_BUFFER, NULL, NULL )
+
+#if ( configUSE_SB_COMPLETED_CALLBACK == 1 )
+    #define xStreamBufferCreateWithCallback( xBufferSizeBytes, xTriggerLevelBytes, pxSendCompletedCallback, pxReceiveCompletedCallback ) \
+    xStreamBufferGenericCreate( ( xBufferSizeBytes ), ( xTriggerLevelBytes ), sbTYPE_STREAM_BUFFER, ( pxSendCompletedCallback ), ( pxReceiveCompletedCallback ) )
+#endif
+
+/**
+ * stream_buffer.h
+ *
+ * @code{c}
+ * StreamBufferHandle_t xStreamBufferCreateStatic( size_t xBufferSizeBytes,
+ *                                                 size_t xTriggerLevelBytes,
+ *                                                 uint8_t *pucStreamBufferStorageArea,
+ *                                                 StaticStreamBuffer_t *pxStaticStreamBuffer );
+ * @endcode
+ * Creates a new stream buffer using statically allocated memory.  See
+ * xStreamBufferCreate() for a version that uses dynamically allocated memory.
+ *
+ * configSUPPORT_STATIC_ALLOCATION must be set to 1 in FreeRTOSConfig.h for
+ * xStreamBufferCreateStatic() to be available. configUSE_STREAM_BUFFERS must be
+ * set to 1 in for FreeRTOSConfig.h for xStreamBufferCreateStatic() to be
+ * available.
+ *
+ * @param xBufferSizeBytes The size, in bytes, of the buffer pointed to by the
+ * pucStreamBufferStorageArea parameter.
+ *
+ * @param xTriggerLevelBytes The number of bytes that must be in the stream
+ * buffer before a task that is blocked on the stream buffer to wait for data is
+ * moved out of the blocked state.  For example, if a task is blocked on a read
+ * of an empty stream buffer that has a trigger level of 1 then the task will be
+ * unblocked when a single byte is written to the buffer or the task's block
+ * time expires.  As another example, if a task is blocked on a read of an empty
+ * stream buffer that has a trigger level of 10 then the task will not be
+ * unblocked until the stream buffer contains at least 10 bytes or the task's
+ * block time expires.  If a reading task's block time expires before the
+ * trigger level is reached then the task will still receive however many bytes
+ * are actually available.  Setting a trigger level of 0 will result in a
+ * trigger level of 1 being used.  It is not valid to specify a trigger level
+ * that is greater than the buffer size.
+ *
+ * @param pucStreamBufferStorageArea Must point to a uint8_t array that is at
+ * least xBufferSizeBytes big.  This is the array to which streams are
+ * copied when they are written to the stream buffer.
+ *
+ * @param pxStaticStreamBuffer Must point to a variable of type
+ * StaticStreamBuffer_t, which will be used to hold the stream buffer's data
+ * structure.
+ *
+ * @param pxSendCompletedCallback Callback invoked when number of bytes at least equal to
+ * trigger level is sent to the stream buffer. If the parameter is NULL, it will use the default
+ * implementation provided by sbSEND_COMPLETED macro. To enable the callback,
+ * configUSE_SB_COMPLETED_CALLBACK must be set to 1 in FreeRTOSConfig.h.
+ *
+ * @param pxReceiveCompletedCallback Callback invoked when more than zero bytes are read from a
+ * stream buffer. If the parameter is NULL, it will use the default
+ * implementation provided by sbRECEIVE_COMPLETED macro. To enable the callback,
+ * configUSE_SB_COMPLETED_CALLBACK must be set to 1 in FreeRTOSConfig.h.
+ *
+ * @return If the stream buffer is created successfully then a handle to the
+ * created stream buffer is returned. If either pucStreamBufferStorageArea or
+ * pxStaticstreamBuffer are NULL then NULL is returned.
+ *
+ * Example use:
+ * @code{c}
+ *
+ * // Used to dimension the array used to hold the streams.  The available space
+ * // will actually be one less than this, so 999.
+ #define STORAGE_SIZE_BYTES 1000
+ *
+ * // Defines the memory that will actually hold the streams within the stream
+ * // buffer.
+ * static uint8_t ucStorageBuffer[ STORAGE_SIZE_BYTES ];
+ *
+ * // The variable used to hold the stream buffer structure.
+ * StaticStreamBuffer_t xStreamBufferStruct;
+ *
+ * void MyFunction( void )
+ * {
+ * StreamBufferHandle_t xStreamBuffer;
+ * const size_t xTriggerLevel = 1;
+ *
+ *  xStreamBuffer = xStreamBufferCreateStatic( sizeof( ucStorageBuffer ),
+ *                                             xTriggerLevel,
+ *                                             ucStorageBuffer,
+ *                                             &xStreamBufferStruct );
+ *
+ *  // As neither the pucStreamBufferStorageArea or pxStaticStreamBuffer
+ *  // parameters were NULL, xStreamBuffer will not be NULL, and can be used to
+ *  // reference the created stream buffer in other stream buffer API calls.
+ *
+ *  // Other code that uses the stream buffer can go here.
+ * }
+ *
+ * @endcode
+ * \defgroup xStreamBufferCreateStatic xStreamBufferCreateStatic
+ * \ingroup StreamBufferManagement
+ */
+
 #define xStreamBufferCreateStatic( xBufferSizeBytes, xTriggerLevelBytes, pucStreamBufferStorageArea, pxStaticStreamBuffer ) \
-    xStreamBufferGenericCreateStatic( xBufferSizeBytes, xTriggerLevelBytes, pdFALSE, pucStreamBufferStorageArea, pxStaticStreamBuffer )
-
-    /**
-     * stream_buffer.h
-     *
-     * @code{c}
-     * size_t xStreamBufferSend( StreamBufferHandle_t xStreamBuffer,
-     *                        const void *pvTxData,
-     *                        size_t xDataLengthBytes,
-     *                        TickType_t xTicksToWait );
-     * @endcode
-     *
-     * Sends bytes to a stream buffer.  The bytes are copied into the stream buffer.
-     *
-     * ***NOTE***:  Uniquely among FreeRTOS objects, the stream buffer
-     * implementation (so also the message buffer implementation, as message buffers
-     * are built on top of stream buffers) assumes there is only one task or
-     * interrupt that will write to the buffer (the writer), and only one task or
-     * interrupt that will read from the buffer (the reader).  It is safe for the
-     * writer and reader to be different tasks or interrupts, but, unlike other
-     * FreeRTOS objects, it is not safe to have multiple different writers or
-     * multiple different readers.  If there are to be multiple different writers
-     * then the application writer must place each call to a writing API function
-     * (such as xStreamBufferSend()) inside a critical section and set the send
-     * block time to 0.  Likewise, if there are to be multiple different readers
-     * then the application writer must place each call to a reading API function
-     * (such as xStreamBufferReceive()) inside a critical section and set the receive
-     * block time to 0.
-     *
-     * Use xStreamBufferSend() to write to a stream buffer from a task.  Use
-     * xStreamBufferSendFromISR() to write to a stream buffer from an interrupt
-     * service routine (ISR).
-     *
-     * @param xStreamBuffer The handle of the stream buffer to which a stream is
-     * being sent.
-     *
-     * @param pvTxData A pointer to the buffer that holds the bytes to be copied
-     * into the stream buffer.
-     *
-     * @param xDataLengthBytes   The maximum number of bytes to copy from pvTxData
-     * into the stream buffer.
-     *
-     * @param xTicksToWait The maximum amount of time the task should remain in the
-     * Blocked state to wait for enough space to become available in the stream
-     * buffer, should the stream buffer contain too little space to hold the
-     * another xDataLengthBytes bytes.  The block time is specified in tick periods,
-     * so the absolute time it represents is dependent on the tick frequency.  The
-     * macro pdMS_TO_TICKS() can be used to convert a time specified in milliseconds
-     * into a time specified in ticks.  Setting xTicksToWait to portMAX_DELAY will
-     * cause the task to wait indefinitely (without timing out), provided
-     * INCLUDE_vTaskSuspend is set to 1 in FreeRTOSConfig.h.  If a task times out
-     * before it can write all xDataLengthBytes into the buffer it will still write
-     * as many bytes as possible.  A task does not use any CPU time when it is in
-     * the blocked state.
-     *
-     * @return The number of bytes written to the stream buffer.  If a task times
-     * out before it can write all xDataLengthBytes into the buffer it will still
-     * write as many bytes as possible.
-     *
-     * Example use:
-     * @code{c}
-     * void vAFunction( StreamBufferHandle_t xStreamBuffer )
-     * {
-     * size_t xBytesSent;
-     * uint8_t ucArrayToSend[] = { 0, 1, 2, 3 };
-     * char *pcStringToSend = "String to send";
-     * const TickType_t x100ms = pdMS_TO_TICKS( 100 );
-     *
-     *  // Send an array to the stream buffer, blocking for a maximum of 100ms to
-     *  // wait for enough space to be available in the stream buffer.
-     *  xBytesSent = xStreamBufferSend( xStreamBuffer, ( void * ) ucArrayToSend, sizeof( ucArrayToSend ), x100ms );
-     *
-     *  if( xBytesSent != sizeof( ucArrayToSend ) )
-     *  {
-     *      // The call to xStreamBufferSend() times out before there was enough
-     *      // space in the buffer for the data to be written, but it did
-     *      // successfully write xBytesSent bytes.
-     *  }
-     *
-     *  // Send the string to the stream buffer.  Return immediately if there is not
-     *  // enough space in the buffer.
-     *  xBytesSent = xStreamBufferSend( xStreamBuffer, ( void * ) pcStringToSend, strlen( pcStringToSend ), 0 );
-     *
-     *  if( xBytesSent != strlen( pcStringToSend ) )
-     *  {
-     *      // The entire string could not be added to the stream buffer because
-     *      // there was not enough free space in the buffer, but xBytesSent bytes
-     *      // were sent.  Could try again to send the remaining bytes.
-     *  }
-     * }
-     * @endcode
-     * \defgroup xStreamBufferSend xStreamBufferSend
-     * \ingroup StreamBufferManagement
-     */
-    size_t xStreamBufferSend(StreamBufferHandle_t xStreamBuffer,
-                             const void * pvTxData,
-                             size_t xDataLengthBytes,
-                             TickType_t xTicksToWait) PRIVILEGED_FUNCTION;
-
-    /**
-     * stream_buffer.h
-     *
-     * @code{c}
-     * size_t xStreamBufferSendFromISR( StreamBufferHandle_t xStreamBuffer,
-     *                               const void *pvTxData,
-     *                               size_t xDataLengthBytes,
-     *                               BaseType_t *pxHigherPriorityTaskWoken );
-     * @endcode
-     *
-     * Interrupt safe version of the API function that sends a stream of bytes to
-     * the stream buffer.
-     *
-     * ***NOTE***:  Uniquely among FreeRTOS objects, the stream buffer
-     * implementation (so also the message buffer implementation, as message buffers
-     * are built on top of stream buffers) assumes there is only one task or
-     * interrupt that will write to the buffer (the writer), and only one task or
-     * interrupt that will read from the buffer (the reader).  It is safe for the
-     * writer and reader to be different tasks or interrupts, but, unlike other
-     * FreeRTOS objects, it is not safe to have multiple different writers or
-     * multiple different readers.  If there are to be multiple different writers
-     * then the application writer must place each call to a writing API function
-     * (such as xStreamBufferSend()) inside a critical section and set the send
-     * block time to 0.  Likewise, if there are to be multiple different readers
-     * then the application writer must place each call to a reading API function
-     * (such as xStreamBufferReceive()) inside a critical section and set the receive
-     * block time to 0.
-     *
-     * Use xStreamBufferSend() to write to a stream buffer from a task.  Use
-     * xStreamBufferSendFromISR() to write to a stream buffer from an interrupt
-     * service routine (ISR).
-     *
-     * @param xStreamBuffer The handle of the stream buffer to which a stream is
-     * being sent.
-     *
-     * @param pvTxData A pointer to the data that is to be copied into the stream
-     * buffer.
-     *
-     * @param xDataLengthBytes The maximum number of bytes to copy from pvTxData
-     * into the stream buffer.
-     *
-     * @param pxHigherPriorityTaskWoken  It is possible that a stream buffer will
-     * have a task blocked on it waiting for data.  Calling
-     * xStreamBufferSendFromISR() can make data available, and so cause a task that
-     * was waiting for data to leave the Blocked state.  If calling
-     * xStreamBufferSendFromISR() causes a task to leave the Blocked state, and the
-     * unblocked task has a priority higher than the currently executing task (the
-     * task that was interrupted), then, internally, xStreamBufferSendFromISR()
-     * will set *pxHigherPriorityTaskWoken to pdTRUE.  If
-     * xStreamBufferSendFromISR() sets this value to pdTRUE, then normally a
-     * context switch should be performed before the interrupt is exited.  This will
-     * ensure that the interrupt returns directly to the highest priority Ready
-     * state task.  *pxHigherPriorityTaskWoken should be set to pdFALSE before it
-     * is passed into the function.  See the example code below for an example.
-     *
-     * @return The number of bytes actually written to the stream buffer, which will
-     * be less than xDataLengthBytes if the stream buffer didn't have enough free
-     * space for all the bytes to be written.
-     *
-     * Example use:
-     * @code{c}
-     * // A stream buffer that has already been created.
-     * StreamBufferHandle_t xStreamBuffer;
-     *
-     * void vAnInterruptServiceRoutine( void )
-     * {
-     * size_t xBytesSent;
-     * char *pcStringToSend = "String to send";
-     * BaseType_t xHigherPriorityTaskWoken = pdFALSE; // Initialised to pdFALSE.
-     *
-     *  // Attempt to send the string to the stream buffer.
-     *  xBytesSent = xStreamBufferSendFromISR( xStreamBuffer,
-     *                                         ( void * ) pcStringToSend,
-     *                                         strlen( pcStringToSend ),
-     *                                         &xHigherPriorityTaskWoken );
-     *
-     *  if( xBytesSent != strlen( pcStringToSend ) )
-     *  {
-     *      // There was not enough free space in the stream buffer for the entire
-     *      // string to be written, ut xBytesSent bytes were written.
-     *  }
-     *
-     *  // If xHigherPriorityTaskWoken was set to pdTRUE inside
-     *  // xStreamBufferSendFromISR() then a task that has a priority above the
-     *  // priority of the currently executing task was unblocked and a context
-     *  // switch should be performed to ensure the ISR returns to the unblocked
-     *  // task.  In most FreeRTOS ports this is done by simply passing
-     *  // xHigherPriorityTaskWoken into taskYIELD_FROM_ISR(), which will test the
-     *  // variables value, and perform the context switch if necessary.  Check the
-     *  // documentation for the port in use for port specific instructions.
-     *  taskYIELD_FROM_ISR( xHigherPriorityTaskWoken );
-     * }
-     * @endcode
-     * \defgroup xStreamBufferSendFromISR xStreamBufferSendFromISR
-     * \ingroup StreamBufferManagement
-     */
-    size_t xStreamBufferSendFromISR(StreamBufferHandle_t xStreamBuffer,
-                                    const void * pvTxData,
-                                    size_t xDataLengthBytes,
-                                    BaseType_t * const pxHigherPriorityTaskWoken) PRIVILEGED_FUNCTION;
-
-    /**
-     * stream_buffer.h
-     *
-     * @code{c}
-     * size_t xStreamBufferReceive( StreamBufferHandle_t xStreamBuffer,
-     *                           void *pvRxData,
-     *                           size_t xBufferLengthBytes,
-     *                           TickType_t xTicksToWait );
-     * @endcode
-     *
-     * Receives bytes from a stream buffer.
-     *
-     * ***NOTE***:  Uniquely among FreeRTOS objects, the stream buffer
-     * implementation (so also the message buffer implementation, as message buffers
-     * are built on top of stream buffers) assumes there is only one task or
-     * interrupt that will write to the buffer (the writer), and only one task or
-     * interrupt that will read from the buffer (the reader).  It is safe for the
-     * writer and reader to be different tasks or interrupts, but, unlike other
-     * FreeRTOS objects, it is not safe to have multiple different writers or
-     * multiple different readers.  If there are to be multiple different writers
-     * then the application writer must place each call to a writing API function
-     * (such as xStreamBufferSend()) inside a critical section and set the send
-     * block time to 0.  Likewise, if there are to be multiple different readers
-     * then the application writer must place each call to a reading API function
-     * (such as xStreamBufferReceive()) inside a critical section and set the receive
-     * block time to 0.
-     *
-     * Use xStreamBufferReceive() to read from a stream buffer from a task.  Use
-     * xStreamBufferReceiveFromISR() to read from a stream buffer from an
-     * interrupt service routine (ISR).
-     *
-     * @param xStreamBuffer The handle of the stream buffer from which bytes are to
-     * be received.
-     *
-     * @param pvRxData A pointer to the buffer into which the received bytes will be
-     * copied.
-     *
-     * @param xBufferLengthBytes The length of the buffer pointed to by the
-     * pvRxData parameter.  This sets the maximum number of bytes to receive in one
-     * call.  xStreamBufferReceive will return as many bytes as possible up to a
-     * maximum set by xBufferLengthBytes.
-     *
-     * @param xTicksToWait The maximum amount of time the task should remain in the
-     * Blocked state to wait for data to become available if the stream buffer is
-     * empty.  xStreamBufferReceive() will return immediately if xTicksToWait is
-     * zero.  The block time is specified in tick periods, so the absolute time it
-     * represents is dependent on the tick frequency.  The macro pdMS_TO_TICKS() can
-     * be used to convert a time specified in milliseconds into a time specified in
-     * ticks.  Setting xTicksToWait to portMAX_DELAY will cause the task to wait
-     * indefinitely (without timing out), provided INCLUDE_vTaskSuspend is set to 1
-     * in FreeRTOSConfig.h.  A task does not use any CPU time when it is in the
-     * Blocked state.
-     *
-     * @return The number of bytes actually read from the stream buffer, which will
-     * be less than xBufferLengthBytes if the call to xStreamBufferReceive() timed
-     * out before xBufferLengthBytes were available.
-     *
-     * Example use:
-     * @code{c}
-     * void vAFunction( StreamBuffer_t xStreamBuffer )
-     * {
-     * uint8_t ucRxData[ 20 ];
-     * size_t xReceivedBytes;
-     * const TickType_t xBlockTime = pdMS_TO_TICKS( 20 );
-     *
-     *  // Receive up to another sizeof( ucRxData ) bytes from the stream buffer.
-     *  // Wait in the Blocked state (so not using any CPU processing time) for a
-     *  // maximum of 100ms for the full sizeof( ucRxData ) number of bytes to be
-     *  // available.
-     *  xReceivedBytes = xStreamBufferReceive( xStreamBuffer,
-     *                                         ( void * ) ucRxData,
-     *                                         sizeof( ucRxData ),
-     *                                         xBlockTime );
-     *
-     *  if( xReceivedBytes > 0 )
-     *  {
-     *      // A ucRxData contains another xRecievedBytes bytes of data, which can
-     *      // be processed here....
-     *  }
-     * }
-     * @endcode
-     * \defgroup xStreamBufferReceive xStreamBufferReceive
-     * \ingroup StreamBufferManagement
-     */
-    size_t xStreamBufferReceive(StreamBufferHandle_t xStreamBuffer,
-                                void * pvRxData,
-                                size_t xBufferLengthBytes,
-                                TickType_t xTicksToWait) PRIVILEGED_FUNCTION;
-
-    /**
-     * stream_buffer.h
-     *
-     * @code{c}
-     * size_t xStreamBufferReceiveFromISR( StreamBufferHandle_t xStreamBuffer,
-     *                                  void *pvRxData,
-     *                                  size_t xBufferLengthBytes,
-     *                                  BaseType_t *pxHigherPriorityTaskWoken );
-     * @endcode
-     *
-     * An interrupt safe version of the API function that receives bytes from a
-     * stream buffer.
-     *
-     * Use xStreamBufferReceive() to read bytes from a stream buffer from a task.
-     * Use xStreamBufferReceiveFromISR() to read bytes from a stream buffer from an
-     * interrupt service routine (ISR).
-     *
-     * @param xStreamBuffer The handle of the stream buffer from which a stream
-     * is being received.
-     *
-     * @param pvRxData A pointer to the buffer into which the received bytes are
-     * copied.
-     *
-     * @param xBufferLengthBytes The length of the buffer pointed to by the
-     * pvRxData parameter.  This sets the maximum number of bytes to receive in one
-     * call.  xStreamBufferReceive will return as many bytes as possible up to a
-     * maximum set by xBufferLengthBytes.
-     *
-     * @param pxHigherPriorityTaskWoken  It is possible that a stream buffer will
-     * have a task blocked on it waiting for space to become available.  Calling
-     * xStreamBufferReceiveFromISR() can make space available, and so cause a task
-     * that is waiting for space to leave the Blocked state.  If calling
-     * xStreamBufferReceiveFromISR() causes a task to leave the Blocked state, and
-     * the unblocked task has a priority higher than the currently executing task
-     * (the task that was interrupted), then, internally,
-     * xStreamBufferReceiveFromISR() will set *pxHigherPriorityTaskWoken to pdTRUE.
-     * If xStreamBufferReceiveFromISR() sets this value to pdTRUE, then normally a
-     * context switch should be performed before the interrupt is exited.  That will
-     * ensure the interrupt returns directly to the highest priority Ready state
-     * task.  *pxHigherPriorityTaskWoken should be set to pdFALSE before it is
-     * passed into the function.  See the code example below for an example.
-     *
-     * @return The number of bytes read from the stream buffer, if any.
-     *
-     * Example use:
-     * @code{c}
-     * // A stream buffer that has already been created.
-     * StreamBuffer_t xStreamBuffer;
-     *
-     * void vAnInterruptServiceRoutine( void )
-     * {
-     * uint8_t ucRxData[ 20 ];
-     * size_t xReceivedBytes;
-     * BaseType_t xHigherPriorityTaskWoken = pdFALSE;  // Initialised to pdFALSE.
-     *
-     *  // Receive the next stream from the stream buffer.
-     *  xReceivedBytes = xStreamBufferReceiveFromISR( xStreamBuffer,
-     *                                                ( void * ) ucRxData,
-     *                                                sizeof( ucRxData ),
-     *                                                &xHigherPriorityTaskWoken );
-     *
-     *  if( xReceivedBytes > 0 )
-     *  {
-     *      // ucRxData contains xReceivedBytes read from the stream buffer.
-     *      // Process the stream here....
-     *  }
-     *
-     *  // If xHigherPriorityTaskWoken was set to pdTRUE inside
-     *  // xStreamBufferReceiveFromISR() then a task that has a priority above the
-     *  // priority of the currently executing task was unblocked and a context
-     *  // switch should be performed to ensure the ISR returns to the unblocked
-     *  // task.  In most FreeRTOS ports this is done by simply passing
-     *  // xHigherPriorityTaskWoken into taskYIELD_FROM_ISR(), which will test the
-     *  // variables value, and perform the context switch if necessary.  Check the
-     *  // documentation for the port in use for port specific instructions.
-     *  taskYIELD_FROM_ISR( xHigherPriorityTaskWoken );
-     * }
-     * @endcode
-     * \defgroup xStreamBufferReceiveFromISR xStreamBufferReceiveFromISR
-     * \ingroup StreamBufferManagement
-     */
-    size_t xStreamBufferReceiveFromISR(StreamBufferHandle_t xStreamBuffer,
-                                       void * pvRxData,
-                                       size_t xBufferLengthBytes,
-                                       BaseType_t * const pxHigherPriorityTaskWoken) PRIVILEGED_FUNCTION;
-
-    /**
-     * stream_buffer.h
-     *
-     * @code{c}
-     * void vStreamBufferDelete( StreamBufferHandle_t xStreamBuffer );
-     * @endcode
-     *
-     * Deletes a stream buffer that was previously created using a call to
-     * xStreamBufferCreate() or xStreamBufferCreateStatic().  If the stream
-     * buffer was created using dynamic memory (that is, by xStreamBufferCreate()),
-     * then the allocated memory is freed.
-     *
-     * A stream buffer handle must not be used after the stream buffer has been
-     * deleted.
-     *
-     * @param xStreamBuffer The handle of the stream buffer to be deleted.
-     *
-     * \defgroup vStreamBufferDelete vStreamBufferDelete
-     * \ingroup StreamBufferManagement
-     */
-    void vStreamBufferDelete(StreamBufferHandle_t xStreamBuffer) PRIVILEGED_FUNCTION;
-
-    /**
-     * stream_buffer.h
-     *
-     * @code{c}
-     * BaseType_t xStreamBufferIsFull( StreamBufferHandle_t xStreamBuffer );
-     * @endcode
-     *
-     * Queries a stream buffer to see if it is full.  A stream buffer is full if it
-     * does not have any free space, and therefore cannot accept any more data.
-     *
-     * @param xStreamBuffer The handle of the stream buffer being queried.
-     *
-     * @return If the stream buffer is full then pdTRUE is returned.  Otherwise
-     * pdFALSE is returned.
-     *
-     * \defgroup xStreamBufferIsFull xStreamBufferIsFull
-     * \ingroup StreamBufferManagement
-     */
-    BaseType_t xStreamBufferIsFull(StreamBufferHandle_t xStreamBuffer) PRIVILEGED_FUNCTION;
-
-    /**
-     * stream_buffer.h
-     *
-     * @code{c}
-     * BaseType_t xStreamBufferIsEmpty( StreamBufferHandle_t xStreamBuffer );
-     * @endcode
-     *
-     * Queries a stream buffer to see if it is empty.  A stream buffer is empty if
-     * it does not contain any data.
-     *
-     * @param xStreamBuffer The handle of the stream buffer being queried.
-     *
-     * @return If the stream buffer is empty then pdTRUE is returned.  Otherwise
-     * pdFALSE is returned.
-     *
-     * \defgroup xStreamBufferIsEmpty xStreamBufferIsEmpty
-     * \ingroup StreamBufferManagement
-     */
-    BaseType_t xStreamBufferIsEmpty(StreamBufferHandle_t xStreamBuffer) PRIVILEGED_FUNCTION;
-
-    /**
-     * stream_buffer.h
-     *
-     * @code{c}
-     * BaseType_t xStreamBufferReset( StreamBufferHandle_t xStreamBuffer );
-     * @endcode
-     *
-     * Resets a stream buffer to its initial, empty, state.  Any data that was in
-     * the stream buffer is discarded.  A stream buffer can only be reset if there
-     * are no tasks blocked waiting to either send to or receive from the stream
-     * buffer.
-     *
-     * @param xStreamBuffer The handle of the stream buffer being reset.
-     *
-     * @return If the stream buffer is reset then pdPASS is returned.  If there was
-     * a task blocked waiting to send to or read from the stream buffer then the
-     * stream buffer is not reset and pdFAIL is returned.
-     *
-     * \defgroup xStreamBufferReset xStreamBufferReset
-     * \ingroup StreamBufferManagement
-     */
-    BaseType_t xStreamBufferReset(StreamBufferHandle_t xStreamBuffer) PRIVILEGED_FUNCTION;
-
-    /**
-     * stream_buffer.h
-     *
-     * @code{c}
-     * size_t xStreamBufferSpacesAvailable( StreamBufferHandle_t xStreamBuffer );
-     * @endcode
-     *
-     * Queries a stream buffer to see how much free space it contains, which is
-     * equal to the amount of data that can be sent to the stream buffer before it
-     * is full.
-     *
-     * @param xStreamBuffer The handle of the stream buffer being queried.
-     *
-     * @return The number of bytes that can be written to the stream buffer before
-     * the stream buffer would be full.
-     *
-     * \defgroup xStreamBufferSpacesAvailable xStreamBufferSpacesAvailable
-     * \ingroup StreamBufferManagement
-     */
-    size_t xStreamBufferSpacesAvailable(StreamBufferHandle_t xStreamBuffer) PRIVILEGED_FUNCTION;
-
-    /**
-     * stream_buffer.h
-     *
-     * @code{c}
-     * size_t xStreamBufferBytesAvailable( StreamBufferHandle_t xStreamBuffer );
-     * @endcode
-     *
-     * Queries a stream buffer to see how much data it contains, which is equal to
-     * the number of bytes that can be read from the stream buffer before the stream
-     * buffer would be empty.
-     *
-     * @param xStreamBuffer The handle of the stream buffer being queried.
-     *
-     * @return The number of bytes that can be read from the stream buffer before
-     * the stream buffer would be empty.
-     *
-     * \defgroup xStreamBufferBytesAvailable xStreamBufferBytesAvailable
-     * \ingroup StreamBufferManagement
-     */
-    size_t xStreamBufferBytesAvailable(StreamBufferHandle_t xStreamBuffer) PRIVILEGED_FUNCTION;
-
-    /**
-     * stream_buffer.h
-     *
-     * @code{c}
-     * BaseType_t xStreamBufferSetTriggerLevel( StreamBufferHandle_t xStreamBuffer, size_t xTriggerLevel );
-     * @endcode
-     *
-     * A stream buffer's trigger level is the number of bytes that must be in the
-     * stream buffer before a task that is blocked on the stream buffer to
-     * wait for data is moved out of the blocked state.  For example, if a task is
-     * blocked on a read of an empty stream buffer that has a trigger level of 1
-     * then the task will be unblocked when a single byte is written to the buffer
-     * or the task's block time expires.  As another example, if a task is blocked
-     * on a read of an empty stream buffer that has a trigger level of 10 then the
-     * task will not be unblocked until the stream buffer contains at least 10 bytes
-     * or the task's block time expires.  If a reading task's block time expires
-     * before the trigger level is reached then the task will still receive however
-     * many bytes are actually available.  Setting a trigger level of 0 will result
-     * in a trigger level of 1 being used.  It is not valid to specify a trigger
-     * level that is greater than the buffer size.
-     *
-     * A trigger level is set when the stream buffer is created, and can be modified
-     * using xStreamBufferSetTriggerLevel().
-     *
-     * @param xStreamBuffer The handle of the stream buffer being updated.
-     *
-     * @param xTriggerLevel The new trigger level for the stream buffer.
-     *
-     * @return If xTriggerLevel was less than or equal to the stream buffer's length
-     * then the trigger level will be updated and pdTRUE is returned.  Otherwise
-     * pdFALSE is returned.
-     *
-     * \defgroup xStreamBufferSetTriggerLevel xStreamBufferSetTriggerLevel
-     * \ingroup StreamBufferManagement
-     */
-    BaseType_t xStreamBufferSetTriggerLevel(StreamBufferHandle_t xStreamBuffer,
-            size_t xTriggerLevel) PRIVILEGED_FUNCTION;
-
-    /**
-     * stream_buffer.h
-     *
-     * @code{c}
-     * BaseType_t xStreamBufferSendCompletedFromISR( StreamBufferHandle_t xStreamBuffer, BaseType_t *pxHigherPriorityTaskWoken );
-     * @endcode
-     *
-     * For advanced users only.
-     *
-     * The sbSEND_COMPLETED() macro is called from within the FreeRTOS APIs when
-     * data is sent to a message buffer or stream buffer.  If there was a task that
-     * was blocked on the message or stream buffer waiting for data to arrive then
-     * the sbSEND_COMPLETED() macro sends a notification to the task to remove it
-     * from the Blocked state.  xStreamBufferSendCompletedFromISR() does the same
-     * thing.  It is provided to enable application writers to implement their own
-     * version of sbSEND_COMPLETED(), and MUST NOT BE USED AT ANY OTHER TIME.
-     *
-     * See the example implemented in FreeRTOS/Demo/Minimal/MessageBufferAMP.c for
-     * additional information.
-     *
-     * @param xStreamBuffer The handle of the stream buffer to which data was
-     * written.
-     *
-     * @param pxHigherPriorityTaskWoken *pxHigherPriorityTaskWoken should be
-     * initialised to pdFALSE before it is passed into
-     * xStreamBufferSendCompletedFromISR().  If calling
-     * xStreamBufferSendCompletedFromISR() removes a task from the Blocked state,
-     * and the task has a priority above the priority of the currently running task,
-     * then *pxHigherPriorityTaskWoken will get set to pdTRUE indicating that a
-     * context switch should be performed before exiting the ISR.
-     *
-     * @return If a task was removed from the Blocked state then pdTRUE is returned.
-     * Otherwise pdFALSE is returned.
-     *
-     * \defgroup xStreamBufferSendCompletedFromISR xStreamBufferSendCompletedFromISR
-     * \ingroup StreamBufferManagement
-     */
-    BaseType_t xStreamBufferSendCompletedFromISR(StreamBufferHandle_t xStreamBuffer,
-            BaseType_t * pxHigherPriorityTaskWoken) PRIVILEGED_FUNCTION;
-
-    /**
-     * stream_buffer.h
-     *
-     * @code{c}
-     * BaseType_t xStreamBufferReceiveCompletedFromISR( StreamBufferHandle_t xStreamBuffer, BaseType_t *pxHigherPriorityTaskWoken );
-     * @endcode
-     *
-     * For advanced users only.
-     *
-     * The sbRECEIVE_COMPLETED() macro is called from within the FreeRTOS APIs when
-     * data is read out of a message buffer or stream buffer.  If there was a task
-     * that was blocked on the message or stream buffer waiting for data to arrive
-     * then the sbRECEIVE_COMPLETED() macro sends a notification to the task to
-     * remove it from the Blocked state.  xStreamBufferReceiveCompletedFromISR()
-     * does the same thing.  It is provided to enable application writers to
-     * implement their own version of sbRECEIVE_COMPLETED(), and MUST NOT BE USED AT
-     * ANY OTHER TIME.
-     *
-     * See the example implemented in FreeRTOS/Demo/Minimal/MessageBufferAMP.c for
-     * additional information.
-     *
-     * @param xStreamBuffer The handle of the stream buffer from which data was
-     * read.
-     *
-     * @param pxHigherPriorityTaskWoken *pxHigherPriorityTaskWoken should be
-     * initialised to pdFALSE before it is passed into
-     * xStreamBufferReceiveCompletedFromISR().  If calling
-     * xStreamBufferReceiveCompletedFromISR() removes a task from the Blocked state,
-     * and the task has a priority above the priority of the currently running task,
-     * then *pxHigherPriorityTaskWoken will get set to pdTRUE indicating that a
-     * context switch should be performed before exiting the ISR.
-     *
-     * @return If a task was removed from the Blocked state then pdTRUE is returned.
-     * Otherwise pdFALSE is returned.
-     *
-     * \defgroup xStreamBufferReceiveCompletedFromISR xStreamBufferReceiveCompletedFromISR
-     * \ingroup StreamBufferManagement
-     */
-    BaseType_t xStreamBufferReceiveCompletedFromISR(StreamBufferHandle_t xStreamBuffer,
-            BaseType_t * pxHigherPriorityTaskWoken) PRIVILEGED_FUNCTION;
-
-    /* Functions below here are not part of the public API. */
-    StreamBufferHandle_t xStreamBufferGenericCreate(size_t xBufferSizeBytes,
-            size_t xTriggerLevelBytes,
-            BaseType_t xIsMessageBuffer) PRIVILEGED_FUNCTION;
-
-    StreamBufferHandle_t xStreamBufferGenericCreateStatic(size_t xBufferSizeBytes,
-            size_t xTriggerLevelBytes,
-            BaseType_t xIsMessageBuffer,
-            uint8_t * const pucStreamBufferStorageArea,
-            StaticStreamBuffer_t * const pxStaticStreamBuffer) PRIVILEGED_FUNCTION;
-
-    size_t xStreamBufferNextMessageLengthBytes(StreamBufferHandle_t xStreamBuffer) PRIVILEGED_FUNCTION;
+    xStreamBufferGenericCreateStatic( ( xBufferSizeBytes ), ( xTriggerLevelBytes ), sbTYPE_STREAM_BUFFER, ( pucStreamBufferStorageArea ), ( pxStaticStreamBuffer ), NULL, NULL )
+
+#if ( configUSE_SB_COMPLETED_CALLBACK == 1 )
+    #define xStreamBufferCreateStaticWithCallback( xBufferSizeBytes, xTriggerLevelBytes, pucStreamBufferStorageArea, pxStaticStreamBuffer, pxSendCompletedCallback, pxReceiveCompletedCallback ) \
+    xStreamBufferGenericCreateStatic( ( xBufferSizeBytes ), ( xTriggerLevelBytes ), sbTYPE_STREAM_BUFFER, ( pucStreamBufferStorageArea ), ( pxStaticStreamBuffer ), ( pxSendCompletedCallback ), ( pxReceiveCompletedCallback ) )
+#endif
+
+/**
+ * stream_buffer.h
+ *
+ * @code{c}
+ * StreamBufferHandle_t xStreamBatchingBufferCreate( size_t xBufferSizeBytes, size_t xTriggerLevelBytes );
+ * @endcode
+ *
+ * Creates a new stream batching buffer using dynamically allocated memory.  See
+ * xStreamBatchingBufferCreateStatic() for a version that uses statically
+ * allocated memory (memory that is allocated at compile time).
+ *
+ * configSUPPORT_DYNAMIC_ALLOCATION must be set to 1 or left undefined in
+ * FreeRTOSConfig.h for xStreamBatchingBufferCreate() to be available.
+ * configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
+ * xStreamBatchingBufferCreate() to be available.
+ *
+ * The difference between a stream buffer and a stream batching buffer is when
+ * a task performs read on a non-empty buffer:
+ * - The task reading from a non-empty stream buffer returns immediately
+ *   regardless of the amount of data in the buffer.
+ * - The task reading from a non-empty steam batching buffer blocks until the
+ *   amount of data in the buffer exceeds the trigger level or the block time
+ *   expires.
+ *
+ * @param xBufferSizeBytes The total number of bytes the stream batching buffer
+ * will be able to hold at any one time.
+ *
+ * @param xTriggerLevelBytes The number of bytes that must be in the stream
+ * batching buffer to unblock a task calling xStreamBufferReceive before the
+ * block time expires.
+ *
+ * @param pxSendCompletedCallback Callback invoked when number of bytes at least
+ * equal to trigger level is sent to the stream batching buffer. If the
+ * parameter is NULL, it will use the default implementation provided by
+ * sbSEND_COMPLETED macro. To enable the callback, configUSE_SB_COMPLETED_CALLBACK
+ * must be set to 1 in FreeRTOSConfig.h.
+ *
+ * @param pxReceiveCompletedCallback Callback invoked when more than zero bytes
+ * are read from a stream batching buffer. If the parameter is NULL, it will use
+ * the default implementation provided by sbRECEIVE_COMPLETED macro. To enable
+ * the callback, configUSE_SB_COMPLETED_CALLBACK must be set to 1 in
+ * FreeRTOSConfig.h.
+ *
+ * @return If NULL is returned, then the stream batching buffer cannot be created
+ * because there is insufficient heap memory available for FreeRTOS to allocate
+ * the stream batching buffer data structures and storage area.  A non-NULL value
+ * being returned indicates that the stream batching buffer has been created
+ * successfully - the returned value should be stored as the handle to the
+ * created stream batching buffer.
+ *
+ * Example use:
+ * @code{c}
+ *
+ * void vAFunction( void )
+ * {
+ * StreamBufferHandle_t xStreamBatchingBuffer;
+ * const size_t xStreamBufferSizeBytes = 100, xTriggerLevel = 10;
+ *
+ *  // Create a stream batching buffer that can hold 100 bytes.  The memory used
+ *  // to hold both the stream batching buffer structure and the data in the stream
+ *  // batching buffer is allocated dynamically.
+ *  xStreamBatchingBuffer = xStreamBatchingBufferCreate( xStreamBufferSizeBytes, xTriggerLevel );
+ *
+ *  if( xStreamBatchingBuffer == NULL )
+ *  {
+ *      // There was not enough heap memory space available to create the
+ *      // stream batching buffer.
+ *  }
+ *  else
+ *  {
+ *      // The stream batching buffer was created successfully and can now be used.
+ *  }
+ * }
+ * @endcode
+ * \defgroup xStreamBatchingBufferCreate xStreamBatchingBufferCreate
+ * \ingroup StreamBatchingBufferManagement
+ */
+
+#define xStreamBatchingBufferCreate( xBufferSizeBytes, xTriggerLevelBytes ) \
+    xStreamBufferGenericCreate( ( xBufferSizeBytes ), ( xTriggerLevelBytes ), sbTYPE_STREAM_BATCHING_BUFFER, NULL, NULL )
+
+#if ( configUSE_SB_COMPLETED_CALLBACK == 1 )
+    #define xStreamBatchingBufferCreateWithCallback( xBufferSizeBytes, xTriggerLevelBytes, pxSendCompletedCallback, pxReceiveCompletedCallback ) \
+    xStreamBufferGenericCreate( ( xBufferSizeBytes ), ( xTriggerLevelBytes ), sbTYPE_STREAM_BATCHING_BUFFER, ( pxSendCompletedCallback ), ( pxReceiveCompletedCallback ) )
+#endif
+
+/**
+ * stream_buffer.h
+ *
+ * @code{c}
+ * StreamBufferHandle_t xStreamBatchingBufferCreateStatic( size_t xBufferSizeBytes,
+ *                                                         size_t xTriggerLevelBytes,
+ *                                                         uint8_t *pucStreamBufferStorageArea,
+ *                                                         StaticStreamBuffer_t *pxStaticStreamBuffer );
+ * @endcode
+ * Creates a new stream batching buffer using statically allocated memory.  See
+ * xStreamBatchingBufferCreate() for a version that uses dynamically allocated
+ * memory.
+ *
+ * configSUPPORT_STATIC_ALLOCATION must be set to 1 in FreeRTOSConfig.h for
+ * xStreamBatchingBufferCreateStatic() to be available. configUSE_STREAM_BUFFERS
+ * must be set to 1 in for FreeRTOSConfig.h for xStreamBatchingBufferCreateStatic()
+ * to be available.
+ *
+ * The difference between a stream buffer and a stream batching buffer is when
+ * a task performs read on a non-empty buffer:
+ * - The task reading from a non-empty stream buffer returns immediately
+ *   regardless of the amount of data in the buffer.
+ * - The task reading from a non-empty steam batching buffer blocks until the
+ *   amount of data in the buffer exceeds the trigger level or the block time
+ *   expires.
+ *
+ * @param xBufferSizeBytes The size, in bytes, of the buffer pointed to by the
+ * pucStreamBufferStorageArea parameter.
+ *
+ * @param xTriggerLevelBytes The number of bytes that must be in the stream
+ * batching buffer to unblock a task calling xStreamBufferReceive before the
+ * block time expires.
+ *
+ * @param pucStreamBufferStorageArea Must point to a uint8_t array that is at
+ * least xBufferSizeBytes big.  This is the array to which streams are
+ * copied when they are written to the stream batching buffer.
+ *
+ * @param pxStaticStreamBuffer Must point to a variable of type
+ * StaticStreamBuffer_t, which will be used to hold the stream batching buffer's
+ * data structure.
+ *
+ * @param pxSendCompletedCallback Callback invoked when number of bytes at least
+ * equal to trigger level is sent to the stream batching buffer. If the parameter
+ * is NULL, it will use the default implementation provided by sbSEND_COMPLETED
+ * macro. To enable the callback, configUSE_SB_COMPLETED_CALLBACK must be set to
+ * 1 in FreeRTOSConfig.h.
+ *
+ * @param pxReceiveCompletedCallback Callback invoked when more than zero bytes
+ * are read from a stream batching buffer. If the parameter is NULL, it will use
+ * the default implementation provided by sbRECEIVE_COMPLETED macro. To enable
+ * the callback, configUSE_SB_COMPLETED_CALLBACK must be set to 1 in
+ * FreeRTOSConfig.h.
+ *
+ * @return If the stream batching buffer is created successfully then a handle
+ * to the created stream batching buffer is returned. If either pucStreamBufferStorageArea
+ * or pxStaticstreamBuffer are NULL then NULL is returned.
+ *
+ * Example use:
+ * @code{c}
+ *
+ * // Used to dimension the array used to hold the streams.  The available space
+ * // will actually be one less than this, so 999.
+ * #define STORAGE_SIZE_BYTES 1000
+ *
+ * // Defines the memory that will actually hold the streams within the stream
+ * // batching buffer.
+ * static uint8_t ucStorageBuffer[ STORAGE_SIZE_BYTES ];
+ *
+ * // The variable used to hold the stream batching buffer structure.
+ * StaticStreamBuffer_t xStreamBufferStruct;
+ *
+ * void MyFunction( void )
+ * {
+ * StreamBufferHandle_t xStreamBatchingBuffer;
+ * const size_t xTriggerLevel = 1;
+ *
+ *  xStreamBatchingBuffer = xStreamBatchingBufferCreateStatic( sizeof( ucStorageBuffer ),
+ *                                                             xTriggerLevel,
+ *                                                             ucStorageBuffer,
+ *                                                             &xStreamBufferStruct );
+ *
+ *  // As neither the pucStreamBufferStorageArea or pxStaticStreamBuffer
+ *  // parameters were NULL, xStreamBatchingBuffer will not be NULL, and can be
+ *  // used to reference the created stream batching buffer in other stream
+ *  // buffer API calls.
+ *
+ *  // Other code that uses the stream batching buffer can go here.
+ * }
+ *
+ * @endcode
+ * \defgroup xStreamBatchingBufferCreateStatic xStreamBatchingBufferCreateStatic
+ * \ingroup StreamBatchingBufferManagement
+ */
+
+#define xStreamBatchingBufferCreateStatic( xBufferSizeBytes, xTriggerLevelBytes, pucStreamBufferStorageArea, pxStaticStreamBuffer ) \
+    xStreamBufferGenericCreateStatic( ( xBufferSizeBytes ), ( xTriggerLevelBytes ), sbTYPE_STREAM_BATCHING_BUFFER, ( pucStreamBufferStorageArea ), ( pxStaticStreamBuffer ), NULL, NULL )
+
+#if ( configUSE_SB_COMPLETED_CALLBACK == 1 )
+    #define xStreamBatchingBufferCreateStaticWithCallback( xBufferSizeBytes, xTriggerLevelBytes, pucStreamBufferStorageArea, pxStaticStreamBuffer, pxSendCompletedCallback, pxReceiveCompletedCallback ) \
+    xStreamBufferGenericCreateStatic( ( xBufferSizeBytes ), ( xTriggerLevelBytes ), sbTYPE_STREAM_BATCHING_BUFFER, ( pucStreamBufferStorageArea ), ( pxStaticStreamBuffer ), ( pxSendCompletedCallback ), ( pxReceiveCompletedCallback ) )
+#endif
+
+/**
+ * stream_buffer.h
+ *
+ * @code{c}
+ * BaseType_t xStreamBufferGetStaticBuffers( StreamBufferHandle_t xStreamBuffer,
+ *                                           uint8_t ** ppucStreamBufferStorageArea,
+ *                                           StaticStreamBuffer_t ** ppxStaticStreamBuffer );
+ * @endcode
+ *
+ * Retrieve pointers to a statically created stream buffer's data structure
+ * buffer and storage area buffer. These are the same buffers that are supplied
+ * at the time of creation.
+ *
+ * configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
+ * xStreamBufferGetStaticBuffers() to be available.
+ *
+ * @param xStreamBuffer The stream buffer for which to retrieve the buffers.
+ *
+ * @param ppucStreamBufferStorageArea Used to return a pointer to the stream
+ * buffer's storage area buffer.
+ *
+ * @param ppxStaticStreamBuffer Used to return a pointer to the stream
+ * buffer's data structure buffer.
+ *
+ * @return pdTRUE if buffers were retrieved, pdFALSE otherwise.
+ *
+ * \defgroup xStreamBufferGetStaticBuffers xStreamBufferGetStaticBuffers
+ * \ingroup StreamBufferManagement
+ */
+#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
+    BaseType_t xStreamBufferGetStaticBuffers( StreamBufferHandle_t xStreamBuffer,
+                                              uint8_t ** ppucStreamBufferStorageArea,
+                                              StaticStreamBuffer_t ** ppxStaticStreamBuffer ) PRIVILEGED_FUNCTION;
+#endif /* configSUPPORT_STATIC_ALLOCATION */
+
+/**
+ * stream_buffer.h
+ *
+ * @code{c}
+ * size_t xStreamBufferSend( StreamBufferHandle_t xStreamBuffer,
+ *                           const void *pvTxData,
+ *                           size_t xDataLengthBytes,
+ *                           TickType_t xTicksToWait );
+ * @endcode
+ *
+ * Sends bytes to a stream buffer.  The bytes are copied into the stream buffer.
+ *
+ * ***NOTE***:  Uniquely among FreeRTOS objects, the stream buffer
+ * implementation (so also the message buffer implementation, as message buffers
+ * are built on top of stream buffers) assumes there is only one task or
+ * interrupt that will write to the buffer (the writer), and only one task or
+ * interrupt that will read from the buffer (the reader).  It is safe for the
+ * writer and reader to be different tasks or interrupts, but, unlike other
+ * FreeRTOS objects, it is not safe to have multiple different writers or
+ * multiple different readers.  If there are to be multiple different writers
+ * then the application writer must serialize calls to writing API functions
+ * (such as xStreamBufferSend()).  Likewise, if there are to be multiple
+ * different readers then the application writer must serialize calls to reading
+ * API functions (such as xStreamBufferReceive()).  One way to achieve such
+ * serialization in single core or SMP kernel is to place each API call inside a
+ * critical section and use a block time of 0.
+ *
+ * Use xStreamBufferSend() to write to a stream buffer from a task.  Use
+ * xStreamBufferSendFromISR() to write to a stream buffer from an interrupt
+ * service routine (ISR).
+ *
+ * configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
+ * xStreamBufferSend() to be available.
+ *
+ * @param xStreamBuffer The handle of the stream buffer to which a stream is
+ * being sent.
+ *
+ * @param pvTxData A pointer to the buffer that holds the bytes to be copied
+ * into the stream buffer.
+ *
+ * @param xDataLengthBytes   The maximum number of bytes to copy from pvTxData
+ * into the stream buffer.
+ *
+ * @param xTicksToWait The maximum amount of time the task should remain in the
+ * Blocked state to wait for enough space to become available in the stream
+ * buffer, should the stream buffer contain too little space to hold the
+ * another xDataLengthBytes bytes.  The block time is specified in tick periods,
+ * so the absolute time it represents is dependent on the tick frequency.  The
+ * macro pdMS_TO_TICKS() can be used to convert a time specified in milliseconds
+ * into a time specified in ticks.  Setting xTicksToWait to portMAX_DELAY will
+ * cause the task to wait indefinitely (without timing out), provided
+ * INCLUDE_vTaskSuspend is set to 1 in FreeRTOSConfig.h.  If a task times out
+ * before it can write all xDataLengthBytes into the buffer it will still write
+ * as many bytes as possible.  A task does not use any CPU time when it is in
+ * the blocked state.
+ *
+ * @return The number of bytes written to the stream buffer.  If a task times
+ * out before it can write all xDataLengthBytes into the buffer it will still
+ * write as many bytes as possible.
+ *
+ * Example use:
+ * @code{c}
+ * void vAFunction( StreamBufferHandle_t xStreamBuffer )
+ * {
+ * size_t xBytesSent;
+ * uint8_t ucArrayToSend[] = { 0, 1, 2, 3 };
+ * char *pcStringToSend = "String to send";
+ * const TickType_t x100ms = pdMS_TO_TICKS( 100 );
+ *
+ *  // Send an array to the stream buffer, blocking for a maximum of 100ms to
+ *  // wait for enough space to be available in the stream buffer.
+ *  xBytesSent = xStreamBufferSend( xStreamBuffer, ( void * ) ucArrayToSend, sizeof( ucArrayToSend ), x100ms );
+ *
+ *  if( xBytesSent != sizeof( ucArrayToSend ) )
+ *  {
+ *      // The call to xStreamBufferSend() times out before there was enough
+ *      // space in the buffer for the data to be written, but it did
+ *      // successfully write xBytesSent bytes.
+ *  }
+ *
+ *  // Send the string to the stream buffer.  Return immediately if there is not
+ *  // enough space in the buffer.
+ *  xBytesSent = xStreamBufferSend( xStreamBuffer, ( void * ) pcStringToSend, strlen( pcStringToSend ), 0 );
+ *
+ *  if( xBytesSent != strlen( pcStringToSend ) )
+ *  {
+ *      // The entire string could not be added to the stream buffer because
+ *      // there was not enough free space in the buffer, but xBytesSent bytes
+ *      // were sent.  Could try again to send the remaining bytes.
+ *  }
+ * }
+ * @endcode
+ * \defgroup xStreamBufferSend xStreamBufferSend
+ * \ingroup StreamBufferManagement
+ */
+size_t xStreamBufferSend( StreamBufferHandle_t xStreamBuffer,
+                          const void * pvTxData,
+                          size_t xDataLengthBytes,
+                          TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
+
+/**
+ * stream_buffer.h
+ *
+ * @code{c}
+ * size_t xStreamBufferSendFromISR( StreamBufferHandle_t xStreamBuffer,
+ *                                  const void *pvTxData,
+ *                                  size_t xDataLengthBytes,
+ *                                  BaseType_t *pxHigherPriorityTaskWoken );
+ * @endcode
+ *
+ * Interrupt safe version of the API function that sends a stream of bytes to
+ * the stream buffer.
+ *
+ * ***NOTE***:  Uniquely among FreeRTOS objects, the stream buffer
+ * implementation (so also the message buffer implementation, as message buffers
+ * are built on top of stream buffers) assumes there is only one task or
+ * interrupt that will write to the buffer (the writer), and only one task or
+ * interrupt that will read from the buffer (the reader).  It is safe for the
+ * writer and reader to be different tasks or interrupts, but, unlike other
+ * FreeRTOS objects, it is not safe to have multiple different writers or
+ * multiple different readers.  If there are to be multiple different writers
+ * then the application writer must serialize calls to writing API functions
+ * (such as xStreamBufferSend()).  Likewise, if there are to be multiple
+ * different readers then the application writer must serialize calls to reading
+ * API functions (such as xStreamBufferReceive()).  One way to achieve such
+ * serialization in single core or SMP kernel is to place each API call inside a
+ * critical section and use a block time of 0.
+ *
+ * Use xStreamBufferSend() to write to a stream buffer from a task.  Use
+ * xStreamBufferSendFromISR() to write to a stream buffer from an interrupt
+ * service routine (ISR).
+ *
+ * configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
+ * xStreamBufferSendFromISR() to be available.
+ *
+ * @param xStreamBuffer The handle of the stream buffer to which a stream is
+ * being sent.
+ *
+ * @param pvTxData A pointer to the data that is to be copied into the stream
+ * buffer.
+ *
+ * @param xDataLengthBytes The maximum number of bytes to copy from pvTxData
+ * into the stream buffer.
+ *
+ * @param pxHigherPriorityTaskWoken  It is possible that a stream buffer will
+ * have a task blocked on it waiting for data.  Calling
+ * xStreamBufferSendFromISR() can make data available, and so cause a task that
+ * was waiting for data to leave the Blocked state.  If calling
+ * xStreamBufferSendFromISR() causes a task to leave the Blocked state, and the
+ * unblocked task has a priority higher than the currently executing task (the
+ * task that was interrupted), then, internally, xStreamBufferSendFromISR()
+ * will set *pxHigherPriorityTaskWoken to pdTRUE.  If
+ * xStreamBufferSendFromISR() sets this value to pdTRUE, then normally a
+ * context switch should be performed before the interrupt is exited.  This will
+ * ensure that the interrupt returns directly to the highest priority Ready
+ * state task.  *pxHigherPriorityTaskWoken should be set to pdFALSE before it
+ * is passed into the function.  See the example code below for an example.
+ *
+ * @return The number of bytes actually written to the stream buffer, which will
+ * be less than xDataLengthBytes if the stream buffer didn't have enough free
+ * space for all the bytes to be written.
+ *
+ * Example use:
+ * @code{c}
+ * // A stream buffer that has already been created.
+ * StreamBufferHandle_t xStreamBuffer;
+ *
+ * void vAnInterruptServiceRoutine( void )
+ * {
+ * size_t xBytesSent;
+ * char *pcStringToSend = "String to send";
+ * BaseType_t xHigherPriorityTaskWoken = pdFALSE; // Initialised to pdFALSE.
+ *
+ *  // Attempt to send the string to the stream buffer.
+ *  xBytesSent = xStreamBufferSendFromISR( xStreamBuffer,
+ *                                         ( void * ) pcStringToSend,
+ *                                         strlen( pcStringToSend ),
+ *                                         &xHigherPriorityTaskWoken );
+ *
+ *  if( xBytesSent != strlen( pcStringToSend ) )
+ *  {
+ *      // There was not enough free space in the stream buffer for the entire
+ *      // string to be written, ut xBytesSent bytes were written.
+ *  }
+ *
+ *  // If xHigherPriorityTaskWoken was set to pdTRUE inside
+ *  // xStreamBufferSendFromISR() then a task that has a priority above the
+ *  // priority of the currently executing task was unblocked and a context
+ *  // switch should be performed to ensure the ISR returns to the unblocked
+ *  // task.  In most FreeRTOS ports this is done by simply passing
+ *  // xHigherPriorityTaskWoken into portYIELD_FROM_ISR(), which will test the
+ *  // variables value, and perform the context switch if necessary.  Check the
+ *  // documentation for the port in use for port specific instructions.
+ *  portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
+ * }
+ * @endcode
+ * \defgroup xStreamBufferSendFromISR xStreamBufferSendFromISR
+ * \ingroup StreamBufferManagement
+ */
+size_t xStreamBufferSendFromISR( StreamBufferHandle_t xStreamBuffer,
+                                 const void * pvTxData,
+                                 size_t xDataLengthBytes,
+                                 BaseType_t * const pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;
+
+/**
+ * stream_buffer.h
+ *
+ * @code{c}
+ * size_t xStreamBufferReceive( StreamBufferHandle_t xStreamBuffer,
+ *                              void *pvRxData,
+ *                              size_t xBufferLengthBytes,
+ *                              TickType_t xTicksToWait );
+ * @endcode
+ *
+ * Receives bytes from a stream buffer.
+ *
+ * ***NOTE***:  Uniquely among FreeRTOS objects, the stream buffer
+ * implementation (so also the message buffer implementation, as message buffers
+ * are built on top of stream buffers) assumes there is only one task or
+ * interrupt that will write to the buffer (the writer), and only one task or
+ * interrupt that will read from the buffer (the reader).  It is safe for the
+ * writer and reader to be different tasks or interrupts, but, unlike other
+ * FreeRTOS objects, it is not safe to have multiple different writers or
+ * multiple different readers.  If there are to be multiple different writers
+ * then the application writer must serialize calls to writing API functions
+ * (such as xStreamBufferSend()).  Likewise, if there are to be multiple
+ * different readers then the application writer must serialize calls to reading
+ * API functions (such as xStreamBufferReceive()).  One way to achieve such
+ * serialization in single core or SMP kernel is to place each API call inside a
+ * critical section and use a block time of 0.
+ *
+ * Use xStreamBufferReceive() to read from a stream buffer from a task.  Use
+ * xStreamBufferReceiveFromISR() to read from a stream buffer from an
+ * interrupt service routine (ISR).
+ *
+ * configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
+ * xStreamBufferReceive() to be available.
+ *
+ * @param xStreamBuffer The handle of the stream buffer from which bytes are to
+ * be received.
+ *
+ * @param pvRxData A pointer to the buffer into which the received bytes will be
+ * copied.
+ *
+ * @param xBufferLengthBytes The length of the buffer pointed to by the
+ * pvRxData parameter.  This sets the maximum number of bytes to receive in one
+ * call.  xStreamBufferReceive will return as many bytes as possible up to a
+ * maximum set by xBufferLengthBytes.
+ *
+ * @param xTicksToWait The maximum amount of time the task should remain in the
+ * Blocked state to wait for data to become available if the stream buffer is
+ * empty.  xStreamBufferReceive() will return immediately if xTicksToWait is
+ * zero.  The block time is specified in tick periods, so the absolute time it
+ * represents is dependent on the tick frequency.  The macro pdMS_TO_TICKS() can
+ * be used to convert a time specified in milliseconds into a time specified in
+ * ticks.  Setting xTicksToWait to portMAX_DELAY will cause the task to wait
+ * indefinitely (without timing out), provided INCLUDE_vTaskSuspend is set to 1
+ * in FreeRTOSConfig.h.  A task does not use any CPU time when it is in the
+ * Blocked state.
+ *
+ * @return The number of bytes actually read from the stream buffer, which will
+ * be less than xBufferLengthBytes if the call to xStreamBufferReceive() timed
+ * out before xBufferLengthBytes were available.
+ *
+ * Example use:
+ * @code{c}
+ * void vAFunction( StreamBuffer_t xStreamBuffer )
+ * {
+ * uint8_t ucRxData[ 20 ];
+ * size_t xReceivedBytes;
+ * const TickType_t xBlockTime = pdMS_TO_TICKS( 20 );
+ *
+ *  // Receive up to another sizeof( ucRxData ) bytes from the stream buffer.
+ *  // Wait in the Blocked state (so not using any CPU processing time) for a
+ *  // maximum of 100ms for the full sizeof( ucRxData ) number of bytes to be
+ *  // available.
+ *  xReceivedBytes = xStreamBufferReceive( xStreamBuffer,
+ *                                         ( void * ) ucRxData,
+ *                                         sizeof( ucRxData ),
+ *                                         xBlockTime );
+ *
+ *  if( xReceivedBytes > 0 )
+ *  {
+ *      // A ucRxData contains another xReceivedBytes bytes of data, which can
+ *      // be processed here....
+ *  }
+ * }
+ * @endcode
+ * \defgroup xStreamBufferReceive xStreamBufferReceive
+ * \ingroup StreamBufferManagement
+ */
+size_t xStreamBufferReceive( StreamBufferHandle_t xStreamBuffer,
+                             void * pvRxData,
+                             size_t xBufferLengthBytes,
+                             TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
+
+/**
+ * stream_buffer.h
+ *
+ * @code{c}
+ * size_t xStreamBufferReceiveFromISR( StreamBufferHandle_t xStreamBuffer,
+ *                                     void *pvRxData,
+ *                                     size_t xBufferLengthBytes,
+ *                                     BaseType_t *pxHigherPriorityTaskWoken );
+ * @endcode
+ *
+ * An interrupt safe version of the API function that receives bytes from a
+ * stream buffer.
+ *
+ * Use xStreamBufferReceive() to read bytes from a stream buffer from a task.
+ * Use xStreamBufferReceiveFromISR() to read bytes from a stream buffer from an
+ * interrupt service routine (ISR).
+ *
+ * configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
+ * xStreamBufferReceiveFromISR() to be available.
+ *
+ * @param xStreamBuffer The handle of the stream buffer from which a stream
+ * is being received.
+ *
+ * @param pvRxData A pointer to the buffer into which the received bytes are
+ * copied.
+ *
+ * @param xBufferLengthBytes The length of the buffer pointed to by the
+ * pvRxData parameter.  This sets the maximum number of bytes to receive in one
+ * call.  xStreamBufferReceive will return as many bytes as possible up to a
+ * maximum set by xBufferLengthBytes.
+ *
+ * @param pxHigherPriorityTaskWoken  It is possible that a stream buffer will
+ * have a task blocked on it waiting for space to become available.  Calling
+ * xStreamBufferReceiveFromISR() can make space available, and so cause a task
+ * that is waiting for space to leave the Blocked state.  If calling
+ * xStreamBufferReceiveFromISR() causes a task to leave the Blocked state, and
+ * the unblocked task has a priority higher than the currently executing task
+ * (the task that was interrupted), then, internally,
+ * xStreamBufferReceiveFromISR() will set *pxHigherPriorityTaskWoken to pdTRUE.
+ * If xStreamBufferReceiveFromISR() sets this value to pdTRUE, then normally a
+ * context switch should be performed before the interrupt is exited.  That will
+ * ensure the interrupt returns directly to the highest priority Ready state
+ * task.  *pxHigherPriorityTaskWoken should be set to pdFALSE before it is
+ * passed into the function.  See the code example below for an example.
+ *
+ * @return The number of bytes read from the stream buffer, if any.
+ *
+ * Example use:
+ * @code{c}
+ * // A stream buffer that has already been created.
+ * StreamBuffer_t xStreamBuffer;
+ *
+ * void vAnInterruptServiceRoutine( void )
+ * {
+ * uint8_t ucRxData[ 20 ];
+ * size_t xReceivedBytes;
+ * BaseType_t xHigherPriorityTaskWoken = pdFALSE;  // Initialised to pdFALSE.
+ *
+ *  // Receive the next stream from the stream buffer.
+ *  xReceivedBytes = xStreamBufferReceiveFromISR( xStreamBuffer,
+ *                                                ( void * ) ucRxData,
+ *                                                sizeof( ucRxData ),
+ *                                                &xHigherPriorityTaskWoken );
+ *
+ *  if( xReceivedBytes > 0 )
+ *  {
+ *      // ucRxData contains xReceivedBytes read from the stream buffer.
+ *      // Process the stream here....
+ *  }
+ *
+ *  // If xHigherPriorityTaskWoken was set to pdTRUE inside
+ *  // xStreamBufferReceiveFromISR() then a task that has a priority above the
+ *  // priority of the currently executing task was unblocked and a context
+ *  // switch should be performed to ensure the ISR returns to the unblocked
+ *  // task.  In most FreeRTOS ports this is done by simply passing
+ *  // xHigherPriorityTaskWoken into portYIELD_FROM_ISR(), which will test the
+ *  // variables value, and perform the context switch if necessary.  Check the
+ *  // documentation for the port in use for port specific instructions.
+ *  portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
+ * }
+ * @endcode
+ * \defgroup xStreamBufferReceiveFromISR xStreamBufferReceiveFromISR
+ * \ingroup StreamBufferManagement
+ */
+size_t xStreamBufferReceiveFromISR( StreamBufferHandle_t xStreamBuffer,
+                                    void * pvRxData,
+                                    size_t xBufferLengthBytes,
+                                    BaseType_t * const pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;
+
+/**
+ * stream_buffer.h
+ *
+ * @code{c}
+ * void vStreamBufferDelete( StreamBufferHandle_t xStreamBuffer );
+ * @endcode
+ *
+ * Deletes a stream buffer that was previously created using a call to
+ * xStreamBufferCreate() or xStreamBufferCreateStatic().  If the stream
+ * buffer was created using dynamic memory (that is, by xStreamBufferCreate()),
+ * then the allocated memory is freed.
+ *
+ * A stream buffer handle must not be used after the stream buffer has been
+ * deleted.
+ *
+ * configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
+ * vStreamBufferDelete() to be available.
+ *
+ * @param xStreamBuffer The handle of the stream buffer to be deleted.
+ *
+ * \defgroup vStreamBufferDelete vStreamBufferDelete
+ * \ingroup StreamBufferManagement
+ */
+void vStreamBufferDelete( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;
+
+/**
+ * stream_buffer.h
+ *
+ * @code{c}
+ * BaseType_t xStreamBufferIsFull( StreamBufferHandle_t xStreamBuffer );
+ * @endcode
+ *
+ * Queries a stream buffer to see if it is full.  A stream buffer is full if it
+ * does not have any free space, and therefore cannot accept any more data.
+ *
+ * configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
+ * xStreamBufferIsFull() to be available.
+ *
+ * @param xStreamBuffer The handle of the stream buffer being queried.
+ *
+ * @return If the stream buffer is full then pdTRUE is returned.  Otherwise
+ * pdFALSE is returned.
+ *
+ * \defgroup xStreamBufferIsFull xStreamBufferIsFull
+ * \ingroup StreamBufferManagement
+ */
+BaseType_t xStreamBufferIsFull( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;
+
+/**
+ * stream_buffer.h
+ *
+ * @code{c}
+ * BaseType_t xStreamBufferIsEmpty( StreamBufferHandle_t xStreamBuffer );
+ * @endcode
+ *
+ * Queries a stream buffer to see if it is empty.  A stream buffer is empty if
+ * it does not contain any data.
+ *
+ * configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
+ * xStreamBufferIsEmpty() to be available.
+ *
+ * @param xStreamBuffer The handle of the stream buffer being queried.
+ *
+ * @return If the stream buffer is empty then pdTRUE is returned.  Otherwise
+ * pdFALSE is returned.
+ *
+ * \defgroup xStreamBufferIsEmpty xStreamBufferIsEmpty
+ * \ingroup StreamBufferManagement
+ */
+BaseType_t xStreamBufferIsEmpty( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;
+
+/**
+ * stream_buffer.h
+ *
+ * @code{c}
+ * BaseType_t xStreamBufferReset( StreamBufferHandle_t xStreamBuffer );
+ * @endcode
+ *
+ * Resets a stream buffer to its initial, empty, state.  Any data that was in
+ * the stream buffer is discarded.  A stream buffer can only be reset if there
+ * are no tasks blocked waiting to either send to or receive from the stream
+ * buffer.
+ *
+ * Use xStreamBufferReset() to reset a stream buffer from a task.
+ * Use xStreamBufferResetFromISR() to reset a stream buffer from an
+ * interrupt service routine (ISR).
+ *
+ * configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
+ * xStreamBufferReset() to be available.
+ *
+ * @param xStreamBuffer The handle of the stream buffer being reset.
+ *
+ * @return If the stream buffer is reset then pdPASS is returned.  If there was
+ * a task blocked waiting to send to or read from the stream buffer then the
+ * stream buffer is not reset and pdFAIL is returned.
+ *
+ * \defgroup xStreamBufferReset xStreamBufferReset
+ * \ingroup StreamBufferManagement
+ */
+BaseType_t xStreamBufferReset( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;
+
+/**
+ * stream_buffer.h
+ *
+ * @code{c}
+ * BaseType_t xStreamBufferResetFromISR( StreamBufferHandle_t xStreamBuffer );
+ * @endcode
+ *
+ * An interrupt safe version of the API function that resets the stream buffer.
+ *
+ * Resets a stream buffer to its initial, empty, state.  Any data that was in
+ * the stream buffer is discarded.  A stream buffer can only be reset if there
+ * are no tasks blocked waiting to either send to or receive from the stream
+ * buffer.
+ *
+ * Use xStreamBufferReset() to reset a stream buffer from a task.
+ * Use xStreamBufferResetFromISR() to reset a stream buffer from an
+ * interrupt service routine (ISR).
+ *
+ * configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
+ * xStreamBufferResetFromISR() to be available.
+ *
+ * @param xStreamBuffer The handle of the stream buffer being reset.
+ *
+ * @return If the stream buffer is reset then pdPASS is returned.  If there was
+ * a task blocked waiting to send to or read from the stream buffer then the
+ * stream buffer is not reset and pdFAIL is returned.
+ *
+ * \defgroup xStreamBufferResetFromISR xStreamBufferResetFromISR
+ * \ingroup StreamBufferManagement
+ */
+BaseType_t xStreamBufferResetFromISR( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;
+
+/**
+ * stream_buffer.h
+ *
+ * @code{c}
+ * size_t xStreamBufferSpacesAvailable( StreamBufferHandle_t xStreamBuffer );
+ * @endcode
+ *
+ * Queries a stream buffer to see how much free space it contains, which is
+ * equal to the amount of data that can be sent to the stream buffer before it
+ * is full.
+ *
+ * configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
+ * xStreamBufferSpacesAvailable() to be available.
+ *
+ * @param xStreamBuffer The handle of the stream buffer being queried.
+ *
+ * @return The number of bytes that can be written to the stream buffer before
+ * the stream buffer would be full.
+ *
+ * \defgroup xStreamBufferSpacesAvailable xStreamBufferSpacesAvailable
+ * \ingroup StreamBufferManagement
+ */
+size_t xStreamBufferSpacesAvailable( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;
+
+/**
+ * stream_buffer.h
+ *
+ * @code{c}
+ * size_t xStreamBufferBytesAvailable( StreamBufferHandle_t xStreamBuffer );
+ * @endcode
+ *
+ * Queries a stream buffer to see how much data it contains, which is equal to
+ * the number of bytes that can be read from the stream buffer before the stream
+ * buffer would be empty.
+ *
+ * configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
+ * xStreamBufferBytesAvailable() to be available.
+ *
+ * @param xStreamBuffer The handle of the stream buffer being queried.
+ *
+ * @return The number of bytes that can be read from the stream buffer before
+ * the stream buffer would be empty.
+ *
+ * \defgroup xStreamBufferBytesAvailable xStreamBufferBytesAvailable
+ * \ingroup StreamBufferManagement
+ */
+size_t xStreamBufferBytesAvailable( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;
+
+/**
+ * stream_buffer.h
+ *
+ * @code{c}
+ * BaseType_t xStreamBufferSetTriggerLevel( StreamBufferHandle_t xStreamBuffer, size_t xTriggerLevel );
+ * @endcode
+ *
+ * A stream buffer's trigger level is the number of bytes that must be in the
+ * stream buffer before a task that is blocked on the stream buffer to
+ * wait for data is moved out of the blocked state.  For example, if a task is
+ * blocked on a read of an empty stream buffer that has a trigger level of 1
+ * then the task will be unblocked when a single byte is written to the buffer
+ * or the task's block time expires.  As another example, if a task is blocked
+ * on a read of an empty stream buffer that has a trigger level of 10 then the
+ * task will not be unblocked until the stream buffer contains at least 10 bytes
+ * or the task's block time expires.  If a reading task's block time expires
+ * before the trigger level is reached then the task will still receive however
+ * many bytes are actually available.  Setting a trigger level of 0 will result
+ * in a trigger level of 1 being used.  It is not valid to specify a trigger
+ * level that is greater than the buffer size.
+ *
+ * A trigger level is set when the stream buffer is created, and can be modified
+ * using xStreamBufferSetTriggerLevel().
+ *
+ * configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
+ * xStreamBufferSetTriggerLevel() to be available.
+ *
+ * @param xStreamBuffer The handle of the stream buffer being updated.
+ *
+ * @param xTriggerLevel The new trigger level for the stream buffer.
+ *
+ * @return If xTriggerLevel was less than or equal to the stream buffer's length
+ * then the trigger level will be updated and pdTRUE is returned.  Otherwise
+ * pdFALSE is returned.
+ *
+ * \defgroup xStreamBufferSetTriggerLevel xStreamBufferSetTriggerLevel
+ * \ingroup StreamBufferManagement
+ */
+BaseType_t xStreamBufferSetTriggerLevel( StreamBufferHandle_t xStreamBuffer,
+                                         size_t xTriggerLevel ) PRIVILEGED_FUNCTION;
+
+/**
+ * stream_buffer.h
+ *
+ * @code{c}
+ * BaseType_t xStreamBufferSendCompletedFromISR( StreamBufferHandle_t xStreamBuffer, BaseType_t *pxHigherPriorityTaskWoken );
+ * @endcode
+ *
+ * For advanced users only.
+ *
+ * The sbSEND_COMPLETED() macro is called from within the FreeRTOS APIs when
+ * data is sent to a message buffer or stream buffer.  If there was a task that
+ * was blocked on the message or stream buffer waiting for data to arrive then
+ * the sbSEND_COMPLETED() macro sends a notification to the task to remove it
+ * from the Blocked state.  xStreamBufferSendCompletedFromISR() does the same
+ * thing.  It is provided to enable application writers to implement their own
+ * version of sbSEND_COMPLETED(), and MUST NOT BE USED AT ANY OTHER TIME.
+ *
+ * See the example implemented in FreeRTOS/Demo/Minimal/MessageBufferAMP.c for
+ * additional information.
+ *
+ * configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
+ * xStreamBufferSendCompletedFromISR() to be available.
+ *
+ * @param xStreamBuffer The handle of the stream buffer to which data was
+ * written.
+ *
+ * @param pxHigherPriorityTaskWoken *pxHigherPriorityTaskWoken should be
+ * initialised to pdFALSE before it is passed into
+ * xStreamBufferSendCompletedFromISR().  If calling
+ * xStreamBufferSendCompletedFromISR() removes a task from the Blocked state,
+ * and the task has a priority above the priority of the currently running task,
+ * then *pxHigherPriorityTaskWoken will get set to pdTRUE indicating that a
+ * context switch should be performed before exiting the ISR.
+ *
+ * @return If a task was removed from the Blocked state then pdTRUE is returned.
+ * Otherwise pdFALSE is returned.
+ *
+ * \defgroup xStreamBufferSendCompletedFromISR xStreamBufferSendCompletedFromISR
+ * \ingroup StreamBufferManagement
+ */
+BaseType_t xStreamBufferSendCompletedFromISR( StreamBufferHandle_t xStreamBuffer,
+                                              BaseType_t * pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;
+
+/**
+ * stream_buffer.h
+ *
+ * @code{c}
+ * BaseType_t xStreamBufferReceiveCompletedFromISR( StreamBufferHandle_t xStreamBuffer, BaseType_t *pxHigherPriorityTaskWoken );
+ * @endcode
+ *
+ * For advanced users only.
+ *
+ * The sbRECEIVE_COMPLETED() macro is called from within the FreeRTOS APIs when
+ * data is read out of a message buffer or stream buffer.  If there was a task
+ * that was blocked on the message or stream buffer waiting for data to arrive
+ * then the sbRECEIVE_COMPLETED() macro sends a notification to the task to
+ * remove it from the Blocked state.  xStreamBufferReceiveCompletedFromISR()
+ * does the same thing.  It is provided to enable application writers to
+ * implement their own version of sbRECEIVE_COMPLETED(), and MUST NOT BE USED AT
+ * ANY OTHER TIME.
+ *
+ * See the example implemented in FreeRTOS/Demo/Minimal/MessageBufferAMP.c for
+ * additional information.
+ *
+ * configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
+ * xStreamBufferReceiveCompletedFromISR() to be available.
+ *
+ * @param xStreamBuffer The handle of the stream buffer from which data was
+ * read.
+ *
+ * @param pxHigherPriorityTaskWoken *pxHigherPriorityTaskWoken should be
+ * initialised to pdFALSE before it is passed into
+ * xStreamBufferReceiveCompletedFromISR().  If calling
+ * xStreamBufferReceiveCompletedFromISR() removes a task from the Blocked state,
+ * and the task has a priority above the priority of the currently running task,
+ * then *pxHigherPriorityTaskWoken will get set to pdTRUE indicating that a
+ * context switch should be performed before exiting the ISR.
+ *
+ * @return If a task was removed from the Blocked state then pdTRUE is returned.
+ * Otherwise pdFALSE is returned.
+ *
+ * \defgroup xStreamBufferReceiveCompletedFromISR xStreamBufferReceiveCompletedFromISR
+ * \ingroup StreamBufferManagement
+ */
+BaseType_t xStreamBufferReceiveCompletedFromISR( StreamBufferHandle_t xStreamBuffer,
+                                                 BaseType_t * pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;
+
+/**
+ * stream_buffer.h
+ *
+ * @code{c}
+ * UBaseType_t uxStreamBufferGetStreamBufferNotificationIndex( StreamBufferHandle_t xStreamBuffer );
+ * @endcode
+ *
+ * Get the task notification index used for the supplied stream buffer which can
+ * be set using vStreamBufferSetStreamBufferNotificationIndex. If the task
+ * notification index for the stream buffer is not changed using
+ * vStreamBufferSetStreamBufferNotificationIndex, this function returns the
+ * default value (tskDEFAULT_INDEX_TO_NOTIFY).
+ *
+ * configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
+ * uxStreamBufferGetStreamBufferNotificationIndex() to be available.
+ *
+ * @param xStreamBuffer The handle of the stream buffer for which the task
+ * notification index is retrieved.
+ *
+ * @return The task notification index for the stream buffer.
+ *
+ * \defgroup uxStreamBufferGetStreamBufferNotificationIndex uxStreamBufferGetStreamBufferNotificationIndex
+ * \ingroup StreamBufferManagement
+ */
+UBaseType_t uxStreamBufferGetStreamBufferNotificationIndex( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;
+
+/**
+ * stream_buffer.h
+ *
+ * @code{c}
+ * void vStreamBufferSetStreamBufferNotificationIndex ( StreamBuffer_t xStreamBuffer, UBaseType_t uxNotificationIndex );
+ * @endcode
+ *
+ * Set the task notification index used for the supplied stream buffer.
+ * Successive calls to stream buffer APIs (like xStreamBufferSend or
+ * xStreamBufferReceive) for this stream buffer will use this new index for
+ * their task notifications.
+ *
+ * If this function is not called, the default index (tskDEFAULT_INDEX_TO_NOTIFY)
+ * is used for task notifications. It is recommended to call this function
+ * before attempting to send or receive data from the stream buffer to avoid
+ * inconsistencies.
+ *
+ * configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
+ * vStreamBufferSetStreamBufferNotificationIndex() to be available.
+ *
+ * @param xStreamBuffer The handle of the stream buffer for which the task
+ * notification index is set.
+ *
+ * @param uxNotificationIndex The task notification index to set.
+ *
+ * \defgroup vStreamBufferSetStreamBufferNotificationIndex vStreamBufferSetStreamBufferNotificationIndex
+ * \ingroup StreamBufferManagement
+ */
+void vStreamBufferSetStreamBufferNotificationIndex( StreamBufferHandle_t xStreamBuffer,
+                                                    UBaseType_t uxNotificationIndex ) PRIVILEGED_FUNCTION;
+
+/* Functions below here are not part of the public API. */
+StreamBufferHandle_t xStreamBufferGenericCreate( size_t xBufferSizeBytes,
+                                                 size_t xTriggerLevelBytes,
+                                                 BaseType_t xStreamBufferType,
+                                                 StreamBufferCallbackFunction_t pxSendCompletedCallback,
+                                                 StreamBufferCallbackFunction_t pxReceiveCompletedCallback ) PRIVILEGED_FUNCTION;
+
+#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
+    StreamBufferHandle_t xStreamBufferGenericCreateStatic( size_t xBufferSizeBytes,
+                                                           size_t xTriggerLevelBytes,
+                                                           BaseType_t xStreamBufferType,
+                                                           uint8_t * const pucStreamBufferStorageArea,
+                                                           StaticStreamBuffer_t * const pxStaticStreamBuffer,
+                                                           StreamBufferCallbackFunction_t pxSendCompletedCallback,
+                                                           StreamBufferCallbackFunction_t pxReceiveCompletedCallback ) PRIVILEGED_FUNCTION;
+#endif
+
+size_t xStreamBufferNextMessageLengthBytes( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;
 
 #if ( configUSE_TRACE_FACILITY == 1 )
-    void vStreamBufferSetStreamBufferNumber(StreamBufferHandle_t xStreamBuffer,
-            UBaseType_t uxStreamBufferNumber) PRIVILEGED_FUNCTION;
-    UBaseType_t uxStreamBufferGetStreamBufferNumber(StreamBufferHandle_t xStreamBuffer) PRIVILEGED_FUNCTION;
-    uint8_t ucStreamBufferGetStreamBufferType(StreamBufferHandle_t xStreamBuffer) PRIVILEGED_FUNCTION;
+    void vStreamBufferSetStreamBufferNumber( StreamBufferHandle_t xStreamBuffer,
+                                             UBaseType_t uxStreamBufferNumber ) PRIVILEGED_FUNCTION;
+    UBaseType_t uxStreamBufferGetStreamBufferNumber( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;
+    uint8_t ucStreamBufferGetStreamBufferType( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;
 #endif
 
 /* *INDENT-OFF* */

### external/FreeRTOS/Source/include/task.h
@@ -1,6 +1,7 @@
 /*
- * FreeRTOS Kernel V10.4.6
- * Copyright (C) 2021 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ * FreeRTOS Kernel V11.3.0
+ * Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Copyright 2025 Arm Limited and/or its affiliates <open-source-office@arm.com>
  *
  * SPDX-License-Identifier: MIT
  *
@@ -31,7 +32,7 @@
 #define INC_TASK_H
 
 #ifndef INC_FREERTOS_H
-#error "include FreeRTOS.h must appear in source files before include task.h"
+    #error "include FreeRTOS.h must appear in source files before include task.h"
 #endif
 
 #include "list.h"
@@ -42,58 +43,71 @@
 #endif
 /* *INDENT-ON* */
 
-    /*-----------------------------------------------------------
-    * MACROS AND DEFINITIONS
-    *----------------------------------------------------------*/
-
-    /*
-     * If tskKERNEL_VERSION_NUMBER ends with + it represents the version in development
-     * after the numbered release.
-     *
-     * The tskKERNEL_VERSION_MAJOR, tskKERNEL_VERSION_MINOR, tskKERNEL_VERSION_BUILD
-     * values will reflect the last released version number.
-     */
-#define tskKERNEL_VERSION_NUMBER       "V10.4.6"
-#define tskKERNEL_VERSION_MAJOR        10
-#define tskKERNEL_VERSION_MINOR        4
-#define tskKERNEL_VERSION_BUILD        6
-
-    /* MPU region parameters passed in ulParameters
-     * of MemoryRegion_t struct. */
-#define tskMPU_REGION_READ_ONLY        ( 1UL << 0UL )
-#define tskMPU_REGION_READ_WRITE       ( 1UL << 1UL )
-#define tskMPU_REGION_EXECUTE_NEVER    ( 1UL << 2UL )
-#define tskMPU_REGION_NORMAL_MEMORY    ( 1UL << 3UL )
-#define tskMPU_REGION_DEVICE_MEMORY    ( 1UL << 4UL )
-
-    /* The direct to task notification feature used to have only a single notification
-     * per task.  Now there is an array of notifications per task that is dimensioned by
-     * configTASK_NOTIFICATION_ARRAY_ENTRIES.  For backward compatibility, any use of the
-     * original direct to task notification defaults to using the first index in the
-     * array. */
-#define tskDEFAULT_INDEX_TO_NOTIFY     ( 0 )
-
-    /**
-     * task. h
-     *
-     * Type by which tasks are referenced.  For example, a call to xTaskCreate
-     * returns (via a pointer parameter) an TaskHandle_t variable that can then
-     * be used as a parameter to vTaskDelete to delete the task.
-     *
-     * \defgroup TaskHandle_t TaskHandle_t
-     * \ingroup Tasks
-     */
-    struct tskTaskControlBlock; /* The old naming convention is used to prevent breaking kernel aware debuggers. */
-    typedef struct tskTaskControlBlock * TaskHandle_t;
-
-    /*
-     * Defines the prototype to which the application task hook function must
-     * conform.
-     */
-    typedef BaseType_t (* TaskHookFunction_t)(void *);
-
-    /* Task states returned by eTaskGetState. */
-typedef enum {
+/*-----------------------------------------------------------
+* MACROS AND DEFINITIONS
+*----------------------------------------------------------*/
+
+/*
+ * If tskKERNEL_VERSION_NUMBER ends with + it represents the version in development
+ * after the numbered release.
+ *
+ * The tskKERNEL_VERSION_MAJOR, tskKERNEL_VERSION_MINOR, tskKERNEL_VERSION_BUILD
+ * values will reflect the last released version number.
+ */
+#define tskKERNEL_VERSION_NUMBER                      "V11.3.0"
+#define tskKERNEL_VERSION_MAJOR                       11
+#define tskKERNEL_VERSION_MINOR                       3
+#define tskKERNEL_VERSION_BUILD                       0
+
+/* MPU region parameters passed in ulParameters
+ * of MemoryRegion_t struct. */
+#define tskMPU_REGION_READ_ONLY                       ( 1U << 0U )
+#define tskMPU_REGION_READ_WRITE                      ( 1U << 1U )
+#define tskMPU_REGION_EXECUTE_NEVER                   ( 1U << 2U )
+#define tskMPU_REGION_NORMAL_MEMORY                   ( 1U << 3U )
+#define tskMPU_REGION_DEVICE_MEMORY                   ( 1U << 4U )
+#if defined( portARMV8M_MINOR_VERSION ) && ( portARMV8M_MINOR_VERSION >= 1 )
+    #define tskMPU_REGION_PRIVILEGED_EXECUTE_NEVER    ( 1U << 5U )
+#endif /* portARMV8M_MINOR_VERSION >= 1 */
+#define tskMPU_REGION_NON_SHAREABLE                   ( 1U << 6U )
+#define tskMPU_REGION_OUTER_SHAREABLE                 ( 1U << 7U )
+#define tskMPU_REGION_INNER_SHAREABLE                 ( 1U << 8U )
+
+/* MPU region permissions stored in MPU settings to
+ * authorize access requests. */
+#define tskMPU_READ_PERMISSION                        ( 1U << 0U )
+#define tskMPU_WRITE_PERMISSION                       ( 1U << 1U )
+
+/* The direct to task notification feature used to have only a single notification
+ * per task.  Now there is an array of notifications per task that is dimensioned by
+ * configTASK_NOTIFICATION_ARRAY_ENTRIES.  For backward compatibility, any use of the
+ * original direct to task notification defaults to using the first index in the
+ * array. */
+#define tskDEFAULT_INDEX_TO_NOTIFY                    ( 0 )
+
+/**
+ * task. h
+ *
+ * Type by which tasks are referenced.  For example, a call to xTaskCreate
+ * returns (via a pointer parameter) an TaskHandle_t variable that can then
+ * be used as a parameter to vTaskDelete to delete the task.
+ *
+ * \defgroup TaskHandle_t TaskHandle_t
+ * \ingroup Tasks
+ */
+struct tskTaskControlBlock; /* The old naming convention is used to prevent breaking kernel aware debuggers. */
+typedef struct tskTaskControlBlock         * TaskHandle_t;
+typedef const struct tskTaskControlBlock   * ConstTaskHandle_t;
+
+/*
+ * Defines the prototype to which the application task hook function must
+ * conform.
+ */
+typedef BaseType_t (* TaskHookFunction_t)( void * arg );
+
+/* Task states returned by eTaskGetState. */
+typedef enum
+{
     eRunning = 0, /* A task is querying the state of itself, so must be running. */
     eReady,       /* The task being queried is in a ready or pending ready list. */
     eBlocked,     /* The task being queried is in the Blocked state. */
@@ -103,7 +117,8 @@ typedef enum {
 } eTaskState;
 
 /* Actions that can be performed when vTaskNotify() is called. */
-typedef enum {
+typedef enum
+{
     eNoAction = 0,            /* Notify the task without updating its notify value. */
     eSetBits,                 /* Set bits in the task's notification value. */
     eIncrement,               /* Increment the task's notification value. */
@@ -114,15 +129,17 @@ typedef enum {
 /*
  * Used internally only.
  */
-typedef struct xTIME_OUT {
+typedef struct xTIME_OUT
+{
     BaseType_t xOverflowCount;
     TickType_t xTimeOnEntering;
 } TimeOut_t;
 
 /*
  * Defines the memory ranges allocated to the task when an MPU is used.
  */
-typedef struct xMEMORY_REGION {
+typedef struct xMEMORY_REGION
+{
     void * pvBaseAddress;
     uint32_t ulLengthInBytes;
     uint32_t ulParameters;
@@ -131,38 +148,51 @@ typedef struct xMEMORY_REGION {
 /*
  * Parameters required to create an MPU protected task.
  */
-typedef struct xTASK_PARAMETERS {
+typedef struct xTASK_PARAMETERS
+{
     TaskFunction_t pvTaskCode;
-    const char * pcName; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
+    const char * pcName;
     configSTACK_DEPTH_TYPE usStackDepth;
     void * pvParameters;
     UBaseType_t uxPriority;
     StackType_t * puxStackBuffer;
     MemoryRegion_t xRegions[ portNUM_CONFIGURABLE_REGIONS ];
-#if ( ( portUSING_MPU_WRAPPERS == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
-    StaticTask_t * const pxTaskBuffer;
-#endif
+    #if ( ( portUSING_MPU_WRAPPERS == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
+        StaticTask_t * const pxTaskBuffer;
+    #endif
 } TaskParameters_t;
 
 /* Used with the uxTaskGetSystemState() function to return the state of each task
  * in the system. */
-typedef struct xTASK_STATUS {
+typedef struct xTASK_STATUS
+{
     TaskHandle_t xHandle;                         /* The handle of the task to which the rest of the information in the structure relates. */
-    const char * pcTaskName;                      /* A pointer to the task's name.  This value will be invalid if the task was deleted since the structure was populated! */ /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
-    UBaseType_t xTaskNumber;                      /* A number unique to the task. */
+    const char * pcTaskName;                      /* A pointer to the task's name.  This value will be invalid if the task was deleted since the structure was populated! */
+    UBaseType_t xTaskNumber;                      /* A number unique to the task. Note that this is not the task number that may be modified using vTaskSetTaskNumber() and uxTaskGetTaskNumber(), but a separate TCB-specific and unique identifier automatically assigned on task generation. */
     eTaskState eCurrentState;                     /* The state in which the task existed when the structure was populated. */
     UBaseType_t uxCurrentPriority;                /* The priority at which the task was running (may be inherited) when the structure was populated. */
     UBaseType_t uxBasePriority;                   /* The priority to which the task will return if the task's current priority has been inherited to avoid unbounded priority inversion when obtaining a mutex.  Only valid if configUSE_MUTEXES is defined as 1 in FreeRTOSConfig.h. */
     configRUN_TIME_COUNTER_TYPE ulRunTimeCounter; /* The total run time allocated to the task so far, as defined by the run time stats clock.  See https://www.FreeRTOS.org/rtos-run-time-stats.html.  Only valid when configGENERATE_RUN_TIME_STATS is defined as 1 in FreeRTOSConfig.h. */
     StackType_t * pxStackBase;                    /* Points to the lowest address of the task's stack area. */
+    #if ( ( portSTACK_GROWTH > 0 ) || ( configRECORD_STACK_HIGH_ADDRESS == 1 ) )
+        StackType_t * pxTopOfStack;               /* Points to the top address of the task's stack area. */
+        StackType_t * pxEndOfStack;               /* Points to the end address of the task's stack area. */
+    #endif
     configSTACK_DEPTH_TYPE usStackHighWaterMark;  /* The minimum amount of stack space that has remained for the task since the task was created.  The closer this value is to zero the closer the task has come to overflowing its stack. */
+    #if ( ( configUSE_CORE_AFFINITY == 1 ) && ( configNUMBER_OF_CORES > 1 ) )
+        UBaseType_t uxCoreAffinityMask;           /* The core affinity mask for the task */
+    #endif
 } TaskStatus_t;
 
 /* Possible return values for eTaskConfirmSleepModeStatus(). */
-typedef enum {
-    eAbortSleep = 0,       /* A task has been made ready or a context switch pended since portSUPPRESS_TICKS_AND_SLEEP() was called - abort entering a sleep mode. */
-    eStandardSleep,        /* Enter a sleep mode that will not last any longer than the expected idle time. */
-    eNoTasksWaitingTimeout /* No tasks are waiting for a timeout so it is safe to enter a sleep mode that can only be exited by an external interrupt. */
+typedef enum
+{
+    eAbortSleep = 0, /* A task has been made ready or a context switch pended since portSUPPRESS_TICKS_AND_SLEEP() was called - abort entering a sleep mode. */
+    eStandardSleep   /* Enter a sleep mode that will not last any longer than the expected idle time. */
+    #if ( INCLUDE_vTaskSuspend == 1 )
+        ,
+        eNoTasksWaitingTimeout /* No tasks are waiting for a timeout so it is safe to enter a sleep mode that can only be exited by an external interrupt. */
+    #endif /* INCLUDE_vTaskSuspend */
 } eSleepModeStatus;
 
 /**
@@ -172,6 +202,13 @@ typedef enum {
  */
 #define tskIDLE_PRIORITY    ( ( UBaseType_t ) 0U )
 
+/**
+ * Defines affinity to all available cores.
+ *
+ * \ingroup TaskUtils
+ */
+#define tskNO_AFFINITY      ( ( UBaseType_t ) -1 )
+
 /**
  * task. h
  *
@@ -180,7 +217,7 @@ typedef enum {
  * \defgroup taskYIELD taskYIELD
  * \ingroup SchedulerControl
  */
-#define taskYIELD()                        portYIELD()
+#define taskYIELD()                          portYIELD()
 
 /**
  * task. h
@@ -194,8 +231,12 @@ typedef enum {
  * \defgroup taskENTER_CRITICAL taskENTER_CRITICAL
  * \ingroup SchedulerControl
  */
-#define taskENTER_CRITICAL()               portENTER_CRITICAL()
-#define taskENTER_CRITICAL_FROM_ISR()      portSET_INTERRUPT_MASK_FROM_ISR()
+#define taskENTER_CRITICAL()                 portENTER_CRITICAL()
+#if ( configNUMBER_OF_CORES == 1 )
+    #define taskENTER_CRITICAL_FROM_ISR()    portSET_INTERRUPT_MASK_FROM_ISR()
+#else
+    #define taskENTER_CRITICAL_FROM_ISR()    portENTER_CRITICAL_FROM_ISR()
+#endif
 
 /**
  * task. h
@@ -209,8 +250,12 @@ typedef enum {
  * \defgroup taskEXIT_CRITICAL taskEXIT_CRITICAL
  * \ingroup SchedulerControl
  */
-#define taskEXIT_CRITICAL()                portEXIT_CRITICAL()
-#define taskEXIT_CRITICAL_FROM_ISR( x )    portCLEAR_INTERRUPT_MASK_FROM_ISR( x )
+#define taskEXIT_CRITICAL()                    portEXIT_CRITICAL()
+#if ( configNUMBER_OF_CORES == 1 )
+    #define taskEXIT_CRITICAL_FROM_ISR( x )    portCLEAR_INTERRUPT_MASK_FROM_ISR( x )
+#else
+    #define taskEXIT_CRITICAL_FROM_ISR( x )    portEXIT_CRITICAL_FROM_ISR( x )
+#endif
 
 /**
  * task. h
@@ -220,7 +265,7 @@ typedef enum {
  * \defgroup taskDISABLE_INTERRUPTS taskDISABLE_INTERRUPTS
  * \ingroup SchedulerControl
  */
-#define taskDISABLE_INTERRUPTS()           portDISABLE_INTERRUPTS()
+#define taskDISABLE_INTERRUPTS()    portDISABLE_INTERRUPTS()
 
 /**
  * task. h
@@ -230,7 +275,7 @@ typedef enum {
  * \defgroup taskENABLE_INTERRUPTS taskENABLE_INTERRUPTS
  * \ingroup SchedulerControl
  */
-#define taskENABLE_INTERRUPTS()            portENABLE_INTERRUPTS()
+#define taskENABLE_INTERRUPTS()     portENABLE_INTERRUPTS()
 
 /* Definitions returned by xTaskGetSchedulerState().  taskSCHEDULER_SUSPENDED is
  * 0 to generate more optimal code when configASSERT() is defined as the constant
@@ -239,6 +284,8 @@ typedef enum {
 #define taskSCHEDULER_NOT_STARTED    ( ( BaseType_t ) 1 )
 #define taskSCHEDULER_RUNNING        ( ( BaseType_t ) 2 )
 
+/* Checks if core ID is valid. */
+#define taskVALID_CORE_ID( xCoreID )    ( ( ( ( ( BaseType_t ) 0 <= ( xCoreID ) ) && ( ( xCoreID ) < ( BaseType_t ) configNUMBER_OF_CORES ) ) ) ? ( pdTRUE ) : ( pdFALSE ) )
 
 /*-----------------------------------------------------------
 * TASK CREATION API
@@ -249,8 +296,8 @@ typedef enum {
  * @code{c}
  * BaseType_t xTaskCreate(
  *                            TaskFunction_t pxTaskCode,
- *                            const char *pcName,
- *                            configSTACK_DEPTH_TYPE usStackDepth,
+ *                            const char * const pcName,
+ *                            const configSTACK_DEPTH_TYPE uxStackDepth,
  *                            void *pvParameters,
  *                            UBaseType_t uxPriority,
  *                            TaskHandle_t *pxCreatedTask
@@ -284,9 +331,9 @@ typedef enum {
  * facilitate debugging.  Max length defined by configMAX_TASK_NAME_LEN - default
  * is 16.
  *
- * @param usStackDepth The size of the task stack specified as the number of
+ * @param uxStackDepth The size of the task stack specified as the number of
  * variables the stack can hold - not the number of bytes.  For example, if
- * the stack is 16 bits wide and usStackDepth is defined as 100, 200 bytes
+ * the stack is 16 bits wide and uxStackDepth is defined as 100, 200 bytes
  * will be allocated for stack storage.
  *
  * @param pvParameters Pointer that will be used as the parameter for the task
@@ -339,20 +386,30 @@ typedef enum {
  * \ingroup Tasks
  */
 #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
-BaseType_t xTaskCreate(TaskFunction_t pxTaskCode,
-                       const char * const pcName, /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
-                       const configSTACK_DEPTH_TYPE usStackDepth,
-                       void * const pvParameters,
-                       UBaseType_t uxPriority,
-                       TaskHandle_t * const pxCreatedTask) PRIVILEGED_FUNCTION;
+    BaseType_t xTaskCreate( TaskFunction_t pxTaskCode,
+                            const char * const pcName,
+                            const configSTACK_DEPTH_TYPE uxStackDepth,
+                            void * const pvParameters,
+                            UBaseType_t uxPriority,
+                            TaskHandle_t * const pxCreatedTask ) PRIVILEGED_FUNCTION;
+#endif
+
+#if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configNUMBER_OF_CORES > 1 ) && ( configUSE_CORE_AFFINITY == 1 ) )
+    BaseType_t xTaskCreateAffinitySet( TaskFunction_t pxTaskCode,
+                                       const char * const pcName,
+                                       const configSTACK_DEPTH_TYPE uxStackDepth,
+                                       void * const pvParameters,
+                                       UBaseType_t uxPriority,
+                                       UBaseType_t uxCoreAffinityMask,
+                                       TaskHandle_t * const pxCreatedTask ) PRIVILEGED_FUNCTION;
 #endif
 
 /**
  * task. h
  * @code{c}
  * TaskHandle_t xTaskCreateStatic( TaskFunction_t pxTaskCode,
- *                               const char *pcName,
- *                               uint32_t ulStackDepth,
+ *                               const char * const pcName,
+ *                               const configSTACK_DEPTH_TYPE uxStackDepth,
  *                               void *pvParameters,
  *                               UBaseType_t uxPriority,
  *                               StackType_t *puxStackBuffer,
@@ -378,9 +435,9 @@ BaseType_t xTaskCreate(TaskFunction_t pxTaskCode,
  * facilitate debugging.  The maximum length of the string is defined by
  * configMAX_TASK_NAME_LEN in FreeRTOSConfig.h.
  *
- * @param ulStackDepth The size of the task stack specified as the number of
+ * @param uxStackDepth The size of the task stack specified as the number of
  * variables the stack can hold - not the number of bytes.  For example, if
- * the stack is 32-bits wide and ulStackDepth is defined as 100 then 400 bytes
+ * the stack is 32-bits wide and uxStackDepth is defined as 100 then 400 bytes
  * will be allocated for stack storage.
  *
  * @param pvParameters Pointer that will be used as the parameter for the task
@@ -389,7 +446,7 @@ BaseType_t xTaskCreate(TaskFunction_t pxTaskCode,
  * @param uxPriority The priority at which the task will run.
  *
  * @param puxStackBuffer Must point to a StackType_t array that has at least
- * ulStackDepth indexes - the array will then be used as the task's stack,
+ * uxStackDepth indexes - the array will then be used as the task's stack,
  * removing the need for the stack to be allocated dynamically.
  *
  * @param pxTaskBuffer Must point to a variable of type StaticTask_t, which will
@@ -423,7 +480,7 @@ BaseType_t xTaskCreate(TaskFunction_t pxTaskCode,
  *  {
  *      // The parameter value is expected to be 1 as 1 is passed in the
  *      // pvParameters value in the call to xTaskCreateStatic().
- *      configASSERT( ( uint32_t ) pvParameters == 1UL );
+ *      configASSERT( ( uint32_t ) pvParameters == 1U );
  *
  *      for( ;; )
  *      {
@@ -456,15 +513,26 @@ BaseType_t xTaskCreate(TaskFunction_t pxTaskCode,
  * \ingroup Tasks
  */
 #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
-TaskHandle_t xTaskCreateStatic(TaskFunction_t pxTaskCode,
-                               const char * const pcName, /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
-                               const uint32_t ulStackDepth,
-                               void * const pvParameters,
-                               UBaseType_t uxPriority,
-                               StackType_t * const puxStackBuffer,
-                               StaticTask_t * const pxTaskBuffer) PRIVILEGED_FUNCTION;
+    TaskHandle_t xTaskCreateStatic( TaskFunction_t pxTaskCode,
+                                    const char * const pcName,
+                                    const configSTACK_DEPTH_TYPE uxStackDepth,
+                                    void * const pvParameters,
+                                    UBaseType_t uxPriority,
+                                    StackType_t * const puxStackBuffer,
+                                    StaticTask_t * const pxTaskBuffer ) PRIVILEGED_FUNCTION;
 #endif /* configSUPPORT_STATIC_ALLOCATION */
 
+#if ( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configNUMBER_OF_CORES > 1 ) && ( configUSE_CORE_AFFINITY == 1 ) )
+    TaskHandle_t xTaskCreateStaticAffinitySet( TaskFunction_t pxTaskCode,
+                                               const char * const pcName,
+                                               const configSTACK_DEPTH_TYPE uxStackDepth,
+                                               void * const pvParameters,
+                                               UBaseType_t uxPriority,
+                                               StackType_t * const puxStackBuffer,
+                                               StaticTask_t * const pxTaskBuffer,
+                                               UBaseType_t uxCoreAffinityMask ) PRIVILEGED_FUNCTION;
+#endif
+
 /**
  * task. h
  * @code{c}
@@ -501,9 +569,9 @@ TaskHandle_t xTaskCreateStatic(TaskFunction_t pxTaskCode,
  * {
  *  vATask,     // pvTaskCode - the function that implements the task.
  *  "ATask",    // pcName - just a text name for the task to assist debugging.
- *  100,        // usStackDepth - the stack size DEFINED IN WORDS.
+ *  100,        // uxStackDepth - the stack size DEFINED IN WORDS.
  *  NULL,       // pvParameters - passed into the task function as the function parameters.
- *  ( 1UL | portPRIVILEGE_BIT ),// uxPriority - task priority, set the portPRIVILEGE_BIT if the task should run in a privileged state.
+ *  ( 1U | portPRIVILEGE_BIT ),// uxPriority - task priority, set the portPRIVILEGE_BIT if the task should run in a privileged state.
  *  cStackBuffer,// puxStackBuffer - the buffer to be used as the task stack.
  *
  *  // xRegions - Allocate up to three separate memory regions for access by
@@ -538,9 +606,15 @@ TaskHandle_t xTaskCreateStatic(TaskFunction_t pxTaskCode,
  * \defgroup xTaskCreateRestricted xTaskCreateRestricted
  * \ingroup Tasks
  */
-#if ( portUSING_MPU_WRAPPERS == 1 )
-BaseType_t xTaskCreateRestricted(const TaskParameters_t * const pxTaskDefinition,
-                                 TaskHandle_t * pxCreatedTask) PRIVILEGED_FUNCTION;
+#if ( ( portUSING_MPU_WRAPPERS == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
+    BaseType_t xTaskCreateRestricted( const TaskParameters_t * const pxTaskDefinition,
+                                      TaskHandle_t * pxCreatedTask ) PRIVILEGED_FUNCTION;
+#endif
+
+#if ( ( portUSING_MPU_WRAPPERS == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configNUMBER_OF_CORES > 1 ) && ( configUSE_CORE_AFFINITY == 1 ) )
+    BaseType_t xTaskCreateRestrictedAffinitySet( const TaskParameters_t * const pxTaskDefinition,
+                                                 UBaseType_t uxCoreAffinityMask,
+                                                 TaskHandle_t * pxCreatedTask ) PRIVILEGED_FUNCTION;
 #endif
 
 /**
@@ -589,9 +663,9 @@ BaseType_t xTaskCreateRestricted(const TaskParameters_t * const pxTaskDefinition
  * {
  *  vATask,     // pvTaskCode - the function that implements the task.
  *  "ATask",    // pcName - just a text name for the task to assist debugging.
- *  100,        // usStackDepth - the stack size DEFINED IN WORDS.
+ *  100,        // uxStackDepth - the stack size DEFINED IN WORDS.
  *  NULL,       // pvParameters - passed into the task function as the function parameters.
- *  ( 1UL | portPRIVILEGE_BIT ),// uxPriority - task priority, set the portPRIVILEGE_BIT if the task should run in a privileged state.
+ *  ( 1U | portPRIVILEGE_BIT ),// uxPriority - task priority, set the portPRIVILEGE_BIT if the task should run in a privileged state.
  *  cStackBuffer,// puxStackBuffer - the buffer to be used as the task stack.
  *
  *  // xRegions - Allocate up to three separate memory regions for access by
@@ -615,7 +689,7 @@ BaseType_t xTaskCreateRestricted(const TaskParameters_t * const pxTaskDefinition
  *  // Create a task from the const structure defined above.  The task handle
  *  // is requested (the second parameter is not NULL) but in this case just for
  *  // demonstration purposes as its not actually used.
- *  xTaskCreateRestricted( &xRegTest1Parameters, &xHandle );
+ *  xTaskCreateRestrictedStatic( &xRegTest1Parameters, &xHandle );
  *
  *  // Start the scheduler.
  *  vTaskStartScheduler();
@@ -629,8 +703,14 @@ BaseType_t xTaskCreateRestricted(const TaskParameters_t * const pxTaskDefinition
  * \ingroup Tasks
  */
 #if ( ( portUSING_MPU_WRAPPERS == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
-BaseType_t xTaskCreateRestrictedStatic(const TaskParameters_t * const pxTaskDefinition,
-                                       TaskHandle_t * pxCreatedTask) PRIVILEGED_FUNCTION;
+    BaseType_t xTaskCreateRestrictedStatic( const TaskParameters_t * const pxTaskDefinition,
+                                            TaskHandle_t * pxCreatedTask ) PRIVILEGED_FUNCTION;
+#endif
+
+#if ( ( portUSING_MPU_WRAPPERS == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configNUMBER_OF_CORES > 1 ) && ( configUSE_CORE_AFFINITY == 1 ) )
+    BaseType_t xTaskCreateRestrictedStaticAffinitySet( const TaskParameters_t * const pxTaskDefinition,
+                                                       UBaseType_t uxCoreAffinityMask,
+                                                       TaskHandle_t * pxCreatedTask ) PRIVILEGED_FUNCTION;
 #endif
 
 /**
@@ -643,9 +723,9 @@ BaseType_t xTaskCreateRestrictedStatic(const TaskParameters_t * const pxTaskDefi
  * a call to xTaskCreateRestricted().  These regions can be redefined using
  * vTaskAllocateMPURegions().
  *
- * @param xTask The handle of the task being updated.
+ * @param xTaskToModify The handle of the task being updated.
  *
- * @param xRegions A pointer to a MemoryRegion_t structure that contains the
+ * @param[in] pxRegions A pointer to a MemoryRegion_t structure that contains the
  * new memory region definitions.
  *
  * Example usage:
@@ -677,11 +757,13 @@ BaseType_t xTaskCreateRestrictedStatic(const TaskParameters_t * const pxTaskDefi
  *  // defined or shared regions have been declared elsewhere).
  * }
  * @endcode
- * \defgroup xTaskCreateRestricted xTaskCreateRestricted
+ * \defgroup vTaskAllocateMPURegions vTaskAllocateMPURegions
  * \ingroup Tasks
  */
-void vTaskAllocateMPURegions(TaskHandle_t xTask,
-                             const MemoryRegion_t * const pxRegions) PRIVILEGED_FUNCTION;
+#if ( portUSING_MPU_WRAPPERS == 1 )
+    void vTaskAllocateMPURegions( TaskHandle_t xTaskToModify,
+                                  const MemoryRegion_t * const pxRegions ) PRIVILEGED_FUNCTION;
+#endif
 
 /**
  * task. h
@@ -724,7 +806,7 @@ void vTaskAllocateMPURegions(TaskHandle_t xTask,
  * \defgroup vTaskDelete vTaskDelete
  * \ingroup Tasks
  */
-void vTaskDelete(TaskHandle_t xTaskToDelete) PRIVILEGED_FUNCTION;
+void vTaskDelete( TaskHandle_t xTaskToDelete ) PRIVILEGED_FUNCTION;
 
 /*-----------------------------------------------------------
 * TASK CONTROL API
@@ -778,7 +860,7 @@ void vTaskDelete(TaskHandle_t xTaskToDelete) PRIVILEGED_FUNCTION;
  * \defgroup vTaskDelay vTaskDelay
  * \ingroup TaskCtrl
  */
-void vTaskDelay(const TickType_t xTicksToDelay) PRIVILEGED_FUNCTION;
+void vTaskDelay( const TickType_t xTicksToDelay ) PRIVILEGED_FUNCTION;
 
 /**
  * task. h
@@ -819,7 +901,8 @@ void vTaskDelay(const TickType_t xTicksToDelay) PRIVILEGED_FUNCTION;
  *
  * @return Value which can be used to check whether the task was actually delayed.
  * Will be pdTRUE if the task way delayed and pdFALSE otherwise.  A task will not
- * be delayed if the next expected wake time is in the past.
+ * be delayed if the next expected wake time is in the past. This prevents periodic
+ * tasks from accumulating delays and allows them to resume their regular timing pattern.
  *
  * Example usage:
  * @code{c}
@@ -845,17 +928,17 @@ void vTaskDelay(const TickType_t xTicksToDelay) PRIVILEGED_FUNCTION;
  * \defgroup xTaskDelayUntil xTaskDelayUntil
  * \ingroup TaskCtrl
  */
-BaseType_t xTaskDelayUntil(TickType_t * const pxPreviousWakeTime,
-                           const TickType_t xTimeIncrement) PRIVILEGED_FUNCTION;
+BaseType_t xTaskDelayUntil( TickType_t * const pxPreviousWakeTime,
+                            const TickType_t xTimeIncrement ) PRIVILEGED_FUNCTION;
 
 /*
  * vTaskDelayUntil() is the older version of xTaskDelayUntil() and does not
  * return a value.
  */
-#define vTaskDelayUntil( pxPreviousWakeTime, xTimeIncrement )           \
-    {                                                                   \
-        ( void ) xTaskDelayUntil( pxPreviousWakeTime, xTimeIncrement ); \
-    }
+#define vTaskDelayUntil( pxPreviousWakeTime, xTimeIncrement )                   \
+    do {                                                                        \
+        ( void ) xTaskDelayUntil( ( pxPreviousWakeTime ), ( xTimeIncrement ) ); \
+    } while( 0 )
 
 
 /**
@@ -888,7 +971,9 @@ BaseType_t xTaskDelayUntil(TickType_t * const pxPreviousWakeTime,
  * \defgroup xTaskAbortDelay xTaskAbortDelay
  * \ingroup TaskCtrl
  */
-BaseType_t xTaskAbortDelay(TaskHandle_t xTask) PRIVILEGED_FUNCTION;
+#if ( INCLUDE_xTaskAbortDelay == 1 )
+    BaseType_t xTaskAbortDelay( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
+#endif
 
 /**
  * task. h
@@ -937,7 +1022,7 @@ BaseType_t xTaskAbortDelay(TaskHandle_t xTask) PRIVILEGED_FUNCTION;
  * \defgroup uxTaskPriorityGet uxTaskPriorityGet
  * \ingroup TaskCtrl
  */
-UBaseType_t uxTaskPriorityGet(const TaskHandle_t xTask) PRIVILEGED_FUNCTION;
+UBaseType_t uxTaskPriorityGet( const TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
 
 /**
  * task. h
@@ -947,7 +1032,38 @@ UBaseType_t uxTaskPriorityGet(const TaskHandle_t xTask) PRIVILEGED_FUNCTION;
  *
  * A version of uxTaskPriorityGet() that can be used from an ISR.
  */
-UBaseType_t uxTaskPriorityGetFromISR(const TaskHandle_t xTask) PRIVILEGED_FUNCTION;
+UBaseType_t uxTaskPriorityGetFromISR( const TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
+
+/**
+ * task. h
+ * @code{c}
+ * UBaseType_t uxTaskBasePriorityGet( const TaskHandle_t xTask );
+ * @endcode
+ *
+ * INCLUDE_uxTaskPriorityGet and configUSE_MUTEXES must be defined as 1 for this
+ * function to be available. See the configuration section for more information.
+ *
+ * Obtain the base priority of any task.
+ *
+ * @param xTask Handle of the task to be queried.  Passing a NULL
+ * handle results in the base priority of the calling task being returned.
+ *
+ * @return The base priority of xTask.
+ *
+ * \defgroup uxTaskPriorityGet uxTaskBasePriorityGet
+ * \ingroup TaskCtrl
+ */
+UBaseType_t uxTaskBasePriorityGet( const TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
+
+/**
+ * task. h
+ * @code{c}
+ * UBaseType_t uxTaskBasePriorityGetFromISR( const TaskHandle_t xTask );
+ * @endcode
+ *
+ * A version of uxTaskBasePriorityGet() that can be used from an ISR.
+ */
+UBaseType_t uxTaskBasePriorityGetFromISR( const TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
 
 /**
  * task. h
@@ -967,7 +1083,9 @@ UBaseType_t uxTaskPriorityGetFromISR(const TaskHandle_t xTask) PRIVILEGED_FUNCTI
  * state of the task might change between the function being called, and the
  * functions return value being tested by the calling task.
  */
-eTaskState eTaskGetState(TaskHandle_t xTask) PRIVILEGED_FUNCTION;
+#if ( ( INCLUDE_eTaskGetState == 1 ) || ( configUSE_TRACE_FACILITY == 1 ) || ( INCLUDE_xTaskAbortDelay == 1 ) )
+    eTaskState eTaskGetState( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
+#endif
 
 /**
  * task. h
@@ -987,7 +1105,7 @@ eTaskState eTaskGetState(TaskHandle_t xTask) PRIVILEGED_FUNCTION;
  * filled with information about the task referenced by the handle passed using
  * the xTask parameter.
  *
- * @xGetFreeStackSpace The TaskStatus_t structure contains a member to report
+ * @param xGetFreeStackSpace The TaskStatus_t structure contains a member to report
  * the stack high water mark of the task being queried.  Calculating the stack
  * high water mark takes a relatively long time, and can make the system
  * temporarily unresponsive - so the xGetFreeStackSpace parameter is provided to
@@ -1025,10 +1143,12 @@ eTaskState eTaskGetState(TaskHandle_t xTask) PRIVILEGED_FUNCTION;
  * \defgroup vTaskGetInfo vTaskGetInfo
  * \ingroup TaskCtrl
  */
-void vTaskGetInfo(TaskHandle_t xTask,
-                  TaskStatus_t * pxTaskStatus,
-                  BaseType_t xGetFreeStackSpace,
-                  eTaskState eState) PRIVILEGED_FUNCTION;
+#if ( configUSE_TRACE_FACILITY == 1 )
+    void vTaskGetInfo( TaskHandle_t xTask,
+                       TaskStatus_t * pxTaskStatus,
+                       BaseType_t xGetFreeStackSpace,
+                       eTaskState eState ) PRIVILEGED_FUNCTION;
+#endif
 
 /**
  * task. h
@@ -1072,8 +1192,8 @@ void vTaskGetInfo(TaskHandle_t xTask,
  * \defgroup vTaskPrioritySet vTaskPrioritySet
  * \ingroup TaskCtrl
  */
-void vTaskPrioritySet(TaskHandle_t xTask,
-                      UBaseType_t uxNewPriority) PRIVILEGED_FUNCTION;
+void vTaskPrioritySet( TaskHandle_t xTask,
+                       UBaseType_t uxNewPriority ) PRIVILEGED_FUNCTION;
 
 /**
  * task. h
@@ -1126,7 +1246,7 @@ void vTaskPrioritySet(TaskHandle_t xTask,
  * \defgroup vTaskSuspend vTaskSuspend
  * \ingroup TaskCtrl
  */
-void vTaskSuspend(TaskHandle_t xTaskToSuspend) PRIVILEGED_FUNCTION;
+void vTaskSuspend( TaskHandle_t xTaskToSuspend ) PRIVILEGED_FUNCTION;
 
 /**
  * task. h
@@ -1177,7 +1297,7 @@ void vTaskSuspend(TaskHandle_t xTaskToSuspend) PRIVILEGED_FUNCTION;
  * \defgroup vTaskResume vTaskResume
  * \ingroup TaskCtrl
  */
-void vTaskResume(TaskHandle_t xTaskToResume) PRIVILEGED_FUNCTION;
+void vTaskResume( TaskHandle_t xTaskToResume ) PRIVILEGED_FUNCTION;
 
 /**
  * task. h
@@ -1208,7 +1328,165 @@ void vTaskResume(TaskHandle_t xTaskToResume) PRIVILEGED_FUNCTION;
  * \defgroup vTaskResumeFromISR vTaskResumeFromISR
  * \ingroup TaskCtrl
  */
-BaseType_t xTaskResumeFromISR(TaskHandle_t xTaskToResume) PRIVILEGED_FUNCTION;
+BaseType_t xTaskResumeFromISR( TaskHandle_t xTaskToResume ) PRIVILEGED_FUNCTION;
+
+#if ( configUSE_CORE_AFFINITY == 1 )
+
+/**
+ * @brief Sets the core affinity mask for a task.
+ *
+ * It sets the cores on which a task can run. configUSE_CORE_AFFINITY must
+ * be defined as 1 for this function to be available.
+ *
+ * @param xTask The handle of the task to set the core affinity mask for.
+ * Passing NULL will set the core affinity mask for the calling task.
+ *
+ * @param uxCoreAffinityMask A bitwise value that indicates the cores on
+ * which the task can run. Cores are numbered from 0 to configNUMBER_OF_CORES - 1.
+ * For example, to ensure that a task can run on core 0 and core 1, set
+ * uxCoreAffinityMask to 0x03.
+ *
+ * Example usage:
+ *
+ * // The function that creates task.
+ * void vAFunction( void )
+ * {
+ * TaskHandle_t xHandle;
+ * UBaseType_t uxCoreAffinityMask;
+ *
+ *      // Create a task, storing the handle.
+ *      xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &( xHandle ) );
+ *
+ *      // Define the core affinity mask such that this task can only run
+ *      // on core 0 and core 2.
+ *      uxCoreAffinityMask = ( ( 1 << 0 ) | ( 1 << 2 ) );
+ *
+ *      //Set the core affinity mask for the task.
+ *      vTaskCoreAffinitySet( xHandle, uxCoreAffinityMask );
+ * }
+ */
+    void vTaskCoreAffinitySet( const TaskHandle_t xTask,
+                               UBaseType_t uxCoreAffinityMask );
+#endif
+
+#if ( ( configNUMBER_OF_CORES > 1 ) && ( configUSE_CORE_AFFINITY == 1 ) )
+
+/**
+ * @brief Gets the core affinity mask for a task.
+ *
+ * configUSE_CORE_AFFINITY must be defined as 1 for this function to be
+ * available.
+ *
+ * @param xTask The handle of the task to get the core affinity mask for.
+ * Passing NULL will get the core affinity mask for the calling task.
+ *
+ * @return The core affinity mask which is a bitwise value that indicates
+ * the cores on which a task can run. Cores are numbered from 0 to
+ * configNUMBER_OF_CORES - 1. For example, if a task can run on core 0 and core 1,
+ * the core affinity mask is 0x03.
+ *
+ * Example usage:
+ *
+ * // Task handle of the networking task - it is populated elsewhere.
+ * TaskHandle_t xNetworkingTaskHandle;
+ *
+ * void vAFunction( void )
+ * {
+ * TaskHandle_t xHandle;
+ * UBaseType_t uxNetworkingCoreAffinityMask;
+ *
+ *     // Create a task, storing the handle.
+ *     xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &( xHandle ) );
+ *
+ *     //Get the core affinity mask for the networking task.
+ *     uxNetworkingCoreAffinityMask = vTaskCoreAffinityGet( xNetworkingTaskHandle );
+ *
+ *     // Here is a hypothetical scenario, just for the example. Assume that we
+ *     // have 2 cores - Core 0 and core 1. We want to pin the application task to
+ *     // the core different than the networking task to ensure that the
+ *     // application task does not interfere with networking.
+ *     if( ( uxNetworkingCoreAffinityMask & ( 1 << 0 ) ) != 0 )
+ *     {
+ *         // The networking task can run on core 0, pin our task to core 1.
+ *         vTaskCoreAffinitySet( xHandle, ( 1 << 1 ) );
+ *     }
+ *     else
+ *     {
+ *         // Otherwise, pin our task to core 0.
+ *         vTaskCoreAffinitySet( xHandle, ( 1 << 0 ) );
+ *     }
+ * }
+ */
+    UBaseType_t vTaskCoreAffinityGet( ConstTaskHandle_t xTask );
+#endif
+
+#if ( configUSE_TASK_PREEMPTION_DISABLE == 1 )
+
+/**
+ * @brief Disables preemption for a task.
+ *
+ * @param xTask The handle of the task to disable preemption. Passing NULL
+ * disables preemption for the calling task.
+ *
+ * Example usage:
+ *
+ * void vTaskCode( void *pvParameters )
+ * {
+ *     // Silence warnings about unused parameters.
+ *     ( void ) pvParameters;
+ *
+ *     for( ;; )
+ *     {
+ *         // ... Perform some function here.
+ *
+ *         // Disable preemption for this task.
+ *         vTaskPreemptionDisable( NULL );
+ *
+ *         // The task will not be preempted when it is executing in this portion ...
+ *
+ *         // ... until the preemption is enabled again.
+ *         vTaskPreemptionEnable( NULL );
+ *
+ *         // The task can be preempted when it is executing in this portion.
+ *     }
+ * }
+ */
+    void vTaskPreemptionDisable( const TaskHandle_t xTask );
+#endif
+
+#if ( configUSE_TASK_PREEMPTION_DISABLE == 1 )
+
+/**
+ * @brief Enables preemption for a task.
+ *
+ * @param xTask The handle of the task to enable preemption. Passing NULL
+ * enables preemption for the calling task.
+ *
+ * Example usage:
+ *
+ * void vTaskCode( void *pvParameters )
+ * {
+ *     // Silence warnings about unused parameters.
+ *     ( void ) pvParameters;
+ *
+ *     for( ;; )
+ *     {
+ *         // ... Perform some function here.
+ *
+ *         // Disable preemption for this task.
+ *         vTaskPreemptionDisable( NULL );
+ *
+ *         // The task will not be preempted when it is executing in this portion ...
+ *
+ *         // ... until the preemption is enabled again.
+ *         vTaskPreemptionEnable( NULL );
+ *
+ *         // The task can be preempted when it is executing in this portion.
+ *     }
+ * }
+ */
+    void vTaskPreemptionEnable( const TaskHandle_t xTask );
+#endif
 
 /*-----------------------------------------------------------
 * SCHEDULER CONTROL
@@ -1243,7 +1521,7 @@ BaseType_t xTaskResumeFromISR(TaskHandle_t xTaskToResume) PRIVILEGED_FUNCTION;
  * \defgroup vTaskStartScheduler vTaskStartScheduler
  * \ingroup SchedulerControl
  */
-void vTaskStartScheduler(void) PRIVILEGED_FUNCTION;
+void vTaskStartScheduler( void ) PRIVILEGED_FUNCTION;
 
 /**
  * task. h
@@ -1301,7 +1579,7 @@ void vTaskStartScheduler(void) PRIVILEGED_FUNCTION;
  * \defgroup vTaskEndScheduler vTaskEndScheduler
  * \ingroup SchedulerControl
  */
-void vTaskEndScheduler(void) PRIVILEGED_FUNCTION;
+void vTaskEndScheduler( void ) PRIVILEGED_FUNCTION;
 
 /**
  * task. h
@@ -1354,7 +1632,7 @@ void vTaskEndScheduler(void) PRIVILEGED_FUNCTION;
  * \defgroup vTaskSuspendAll vTaskSuspendAll
  * \ingroup SchedulerControl
  */
-void vTaskSuspendAll(void) PRIVILEGED_FUNCTION;
+void vTaskSuspendAll( void ) PRIVILEGED_FUNCTION;
 
 /**
  * task. h
@@ -1410,7 +1688,7 @@ void vTaskSuspendAll(void) PRIVILEGED_FUNCTION;
  * \defgroup xTaskResumeAll xTaskResumeAll
  * \ingroup SchedulerControl
  */
-BaseType_t xTaskResumeAll(void) PRIVILEGED_FUNCTION;
+BaseType_t xTaskResumeAll( void ) PRIVILEGED_FUNCTION;
 
 /*-----------------------------------------------------------
 * TASK UTILITIES
@@ -1427,7 +1705,7 @@ BaseType_t xTaskResumeAll(void) PRIVILEGED_FUNCTION;
  * \defgroup xTaskGetTickCount xTaskGetTickCount
  * \ingroup TaskUtils
  */
-TickType_t xTaskGetTickCount(void) PRIVILEGED_FUNCTION;
+TickType_t xTaskGetTickCount( void ) PRIVILEGED_FUNCTION;
 
 /**
  * task. h
@@ -1445,7 +1723,7 @@ TickType_t xTaskGetTickCount(void) PRIVILEGED_FUNCTION;
  * \defgroup xTaskGetTickCountFromISR xTaskGetTickCountFromISR
  * \ingroup TaskUtils
  */
-TickType_t xTaskGetTickCountFromISR(void) PRIVILEGED_FUNCTION;
+TickType_t xTaskGetTickCountFromISR( void ) PRIVILEGED_FUNCTION;
 
 /**
  * task. h
@@ -1461,7 +1739,7 @@ TickType_t xTaskGetTickCountFromISR(void) PRIVILEGED_FUNCTION;
  * \defgroup uxTaskGetNumberOfTasks uxTaskGetNumberOfTasks
  * \ingroup TaskUtils
  */
-UBaseType_t uxTaskGetNumberOfTasks(void) PRIVILEGED_FUNCTION;
+UBaseType_t uxTaskGetNumberOfTasks( void ) PRIVILEGED_FUNCTION;
 
 /**
  * task. h
@@ -1476,7 +1754,7 @@ UBaseType_t uxTaskGetNumberOfTasks(void) PRIVILEGED_FUNCTION;
  * \defgroup pcTaskGetName pcTaskGetName
  * \ingroup TaskUtils
  */
-char * pcTaskGetName(TaskHandle_t xTaskToQuery) PRIVILEGED_FUNCTION;   /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
+char * pcTaskGetName( TaskHandle_t xTaskToQuery ) PRIVILEGED_FUNCTION;
 
 /**
  * task. h
@@ -1494,7 +1772,39 @@ char * pcTaskGetName(TaskHandle_t xTaskToQuery) PRIVILEGED_FUNCTION;   /*lint !e
  * \defgroup pcTaskGetHandle pcTaskGetHandle
  * \ingroup TaskUtils
  */
-TaskHandle_t xTaskGetHandle(const char * pcNameToQuery) PRIVILEGED_FUNCTION;   /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
+#if ( INCLUDE_xTaskGetHandle == 1 )
+    TaskHandle_t xTaskGetHandle( const char * pcNameToQuery ) PRIVILEGED_FUNCTION;
+#endif
+
+/**
+ * task. h
+ * @code{c}
+ * BaseType_t xTaskGetStaticBuffers( TaskHandle_t xTask,
+ *                                   StackType_t ** ppuxStackBuffer,
+ *                                   StaticTask_t ** ppxTaskBuffer );
+ * @endcode
+ *
+ * Retrieve pointers to a statically created task's data structure
+ * buffer and stack buffer. These are the same buffers that are supplied
+ * at the time of creation.
+ *
+ * @param xTask The task for which to retrieve the buffers.
+ *
+ * @param ppuxStackBuffer Used to return a pointer to the task's stack buffer.
+ *
+ * @param ppxTaskBuffer Used to return a pointer to the task's data structure
+ * buffer.
+ *
+ * @return pdTRUE if buffers were retrieved, pdFALSE otherwise.
+ *
+ * \defgroup xTaskGetStaticBuffers xTaskGetStaticBuffers
+ * \ingroup TaskUtils
+ */
+#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
+    BaseType_t xTaskGetStaticBuffers( TaskHandle_t xTask,
+                                      StackType_t ** ppuxStackBuffer,
+                                      StaticTask_t ** ppxTaskBuffer ) PRIVILEGED_FUNCTION;
+#endif /* configSUPPORT_STATIC_ALLOCATION */
 
 /**
  * task.h
@@ -1523,7 +1833,9 @@ TaskHandle_t xTaskGetHandle(const char * pcNameToQuery) PRIVILEGED_FUNCTION;   /
  * actual spaces on the stack rather than bytes) since the task referenced by
  * xTask was created.
  */
-UBaseType_t uxTaskGetStackHighWaterMark(TaskHandle_t xTask) PRIVILEGED_FUNCTION;
+#if ( INCLUDE_uxTaskGetStackHighWaterMark == 1 )
+    UBaseType_t uxTaskGetStackHighWaterMark( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
+#endif
 
 /**
  * task.h
@@ -1552,7 +1864,9 @@ UBaseType_t uxTaskGetStackHighWaterMark(TaskHandle_t xTask) PRIVILEGED_FUNCTION;
  * actual spaces on the stack rather than bytes) since the task referenced by
  * xTask was created.
  */
-configSTACK_DEPTH_TYPE uxTaskGetStackHighWaterMark2(TaskHandle_t xTask) PRIVILEGED_FUNCTION;
+#if ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 )
+    configSTACK_DEPTH_TYPE uxTaskGetStackHighWaterMark2( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
+#endif
 
 /* When using trace macros it is sometimes necessary to include task.h before
  * FreeRTOS.h.  When this is done TaskHookFunction_t will not yet have been defined,
@@ -1561,7 +1875,7 @@ configSTACK_DEPTH_TYPE uxTaskGetStackHighWaterMark2(TaskHandle_t xTask) PRIVILEG
  * they are explicitly required by the configUSE_APPLICATION_TASK_TAG configuration
  * constant. */
 #ifdef configUSE_APPLICATION_TASK_TAG
-#if configUSE_APPLICATION_TASK_TAG == 1
+    #if configUSE_APPLICATION_TASK_TAG == 1
 
 /**
  * task.h
@@ -1573,8 +1887,8 @@ configSTACK_DEPTH_TYPE uxTaskGetStackHighWaterMark2(TaskHandle_t xTask) PRIVILEG
  * Passing xTask as NULL has the effect of setting the calling tasks hook
  * function.
  */
-void vTaskSetApplicationTaskTag(TaskHandle_t xTask,
-                                TaskHookFunction_t pxHookFunction) PRIVILEGED_FUNCTION;
+        void vTaskSetApplicationTaskTag( TaskHandle_t xTask,
+                                         TaskHookFunction_t pxHookFunction ) PRIVILEGED_FUNCTION;
 
 /**
  * task.h
@@ -1586,7 +1900,7 @@ void vTaskSetApplicationTaskTag(TaskHandle_t xTask,
  * call from an interrupt service routine - call
  * xTaskGetApplicationTaskTagFromISR() instead.
  */
-TaskHookFunction_t xTaskGetApplicationTaskTag(TaskHandle_t xTask) PRIVILEGED_FUNCTION;
+        TaskHookFunction_t xTaskGetApplicationTaskTag( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
 
 /**
  * task.h
@@ -1597,8 +1911,8 @@ TaskHookFunction_t xTaskGetApplicationTaskTag(TaskHandle_t xTask) PRIVILEGED_FUN
  * Returns the pxHookFunction value assigned to the task xTask.  Can
  * be called from an interrupt service routine.
  */
-TaskHookFunction_t xTaskGetApplicationTaskTagFromISR(TaskHandle_t xTask) PRIVILEGED_FUNCTION;
-#endif /* configUSE_APPLICATION_TASK_TAG ==1 */
+        TaskHookFunction_t xTaskGetApplicationTaskTagFromISR( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
+    #endif /* configUSE_APPLICATION_TASK_TAG ==1 */
 #endif /* ifdef configUSE_APPLICATION_TASK_TAG */
 
 #if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS > 0 )
@@ -1608,11 +1922,11 @@ TaskHookFunction_t xTaskGetApplicationTaskTagFromISR(TaskHandle_t xTask) PRIVILE
  * kernel does not use the pointers itself, so the application writer can use
  * the pointers for any purpose they wish.  The following two functions are
  * used to set and query a pointer respectively. */
-void vTaskSetThreadLocalStoragePointer(TaskHandle_t xTaskToSet,
-                                       BaseType_t xIndex,
-                                       void * pvValue) PRIVILEGED_FUNCTION;
-void * pvTaskGetThreadLocalStoragePointer(TaskHandle_t xTaskToQuery,
-        BaseType_t xIndex) PRIVILEGED_FUNCTION;
+    void vTaskSetThreadLocalStoragePointer( TaskHandle_t xTaskToSet,
+                                            BaseType_t xIndex,
+                                            void * pvValue ) PRIVILEGED_FUNCTION;
+    void * pvTaskGetThreadLocalStoragePointer( TaskHandle_t xTaskToQuery,
+                                               BaseType_t xIndex ) PRIVILEGED_FUNCTION;
 
 #endif
 
@@ -1621,7 +1935,7 @@ void * pvTaskGetThreadLocalStoragePointer(TaskHandle_t xTaskToQuery,
 /**
  * task.h
  * @code{c}
- * void vApplicationStackOverflowHook( TaskHandle_t xTask char *pcTaskName);
+ * void vApplicationStackOverflowHook( TaskHandle_t xTask, char *pcTaskName);
  * @endcode
  *
  * The application stack overflow hook is called when a stack overflow is detected for a task.
@@ -1631,12 +1945,36 @@ void * pvTaskGetThreadLocalStoragePointer(TaskHandle_t xTaskToQuery,
  * @param xTask the task that just exceeded its stack boundaries.
  * @param pcTaskName A character string containing the name of the offending task.
  */
-void vApplicationStackOverflowHook(TaskHandle_t xTask,
-                                   char * pcTaskName);
+    /* MISRA Ref 8.6.1 [External linkage] */
+    /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-86 */
+    /* coverity[misra_c_2012_rule_8_6_violation] */
+    void vApplicationStackOverflowHook( TaskHandle_t xTask,
+                                        char * pcTaskName );
+
+#endif
+
+#if ( configUSE_IDLE_HOOK == 1 )
+
+/**
+ * task.h
+ * @code{c}
+ * void vApplicationIdleHook( void );
+ * @endcode
+ *
+ * The application idle hook is called by the idle task.
+ * This allows the application designer to add background functionality without
+ * the overhead of a separate task.
+ * NOTE: vApplicationIdleHook() MUST NOT, UNDER ANY CIRCUMSTANCES, CALL A FUNCTION THAT MIGHT BLOCK.
+ */
+    /* MISRA Ref 8.6.1 [External linkage] */
+    /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-86 */
+    /* coverity[misra_c_2012_rule_8_6_violation] */
+    void vApplicationIdleHook( void );
 
 #endif
 
-#if  ( configUSE_TICK_HOOK > 0 )
+
+#if  ( configUSE_TICK_HOOK != 0 )
 
 /**
  *  task.h
@@ -1646,7 +1984,10 @@ void vApplicationStackOverflowHook(TaskHandle_t xTask,
  *
  * This hook function is called in the system tick handler after any OS work is completed.
  */
-void vApplicationTickHook(void);   /*lint !e526 Symbol not defined as it is an application callback. */
+    /* MISRA Ref 8.6.1 [External linkage] */
+    /* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-86 */
+    /* coverity[misra_c_2012_rule_8_6_violation] */
+    void vApplicationTickHook( void );
 
 #endif
 
@@ -1655,20 +1996,51 @@ void vApplicationTickHook(void);   /*lint !e526 Symbol not defined as it is an a
 /**
  * task.h
  * @code{c}
- * void vApplicationGetIdleTaskMemory( StaticTask_t ** ppxIdleTaskTCBBuffer, StackType_t ** ppxIdleTaskStackBuffer, uint32_t *pulIdleTaskStackSize )
+ * void vApplicationGetIdleTaskMemory( StaticTask_t ** ppxIdleTaskTCBBuffer, StackType_t ** ppxIdleTaskStackBuffer, configSTACK_DEPTH_TYPE * puxIdleTaskStackSize )
  * @endcode
  *
  * This function is used to provide a statically allocated block of memory to FreeRTOS to hold the Idle Task TCB.  This function is required when
  * configSUPPORT_STATIC_ALLOCATION is set.  For more information see this URI: https://www.FreeRTOS.org/a00110.html#configSUPPORT_STATIC_ALLOCATION
  *
  * @param ppxIdleTaskTCBBuffer A handle to a statically allocated TCB buffer
  * @param ppxIdleTaskStackBuffer A handle to a statically allocated Stack buffer for the idle task
- * @param pulIdleTaskStackSize A pointer to the number of elements that will fit in the allocated stack buffer
+ * @param puxIdleTaskStackSize A pointer to the number of elements that will fit in the allocated stack buffer
  */
-void vApplicationGetIdleTaskMemory(StaticTask_t ** ppxIdleTaskTCBBuffer,
-                                   StackType_t ** ppxIdleTaskStackBuffer,
-                                   uint32_t * pulIdleTaskStackSize);  /*lint !e526 Symbol not defined as it is an application callback. */
-#endif
+    void vApplicationGetIdleTaskMemory( StaticTask_t ** ppxIdleTaskTCBBuffer,
+                                        StackType_t ** ppxIdleTaskStackBuffer,
+                                        configSTACK_DEPTH_TYPE * puxIdleTaskStackSize );
+
+/**
+ * task.h
+ * @code{c}
+ * void vApplicationGetPassiveIdleTaskMemory( StaticTask_t ** ppxIdleTaskTCBBuffer, StackType_t ** ppxIdleTaskStackBuffer, configSTACK_DEPTH_TYPE * puxIdleTaskStackSize, BaseType_t xCoreID )
+ * @endcode
+ *
+ * This function is used to provide a statically allocated block of memory to FreeRTOS to hold the Idle Tasks TCB.  This function is required when
+ * configSUPPORT_STATIC_ALLOCATION is set.  For more information see this URI: https://www.FreeRTOS.org/a00110.html#configSUPPORT_STATIC_ALLOCATION
+ *
+ * In the FreeRTOS SMP, there are a total of configNUMBER_OF_CORES idle tasks:
+ *  1. 1 Active idle task which does all the housekeeping.
+ *  2. ( configNUMBER_OF_CORES - 1 ) Passive idle tasks which do nothing.
+ * These idle tasks are created to ensure that each core has an idle task to run when
+ * no other task is available to run.
+ *
+ * The function vApplicationGetPassiveIdleTaskMemory is called with passive idle
+ * task index 0, 1 ... ( configNUMBER_OF_CORES - 2 ) to get memory for passive idle
+ * tasks.
+ *
+ * @param ppxIdleTaskTCBBuffer A handle to a statically allocated TCB buffer
+ * @param ppxIdleTaskStackBuffer A handle to a statically allocated Stack buffer for the idle task
+ * @param puxIdleTaskStackSize A pointer to the number of elements that will fit in the allocated stack buffer
+ * @param xPassiveIdleTaskIndex The passive idle task index of the idle task buffer
+ */
+    #if ( configNUMBER_OF_CORES > 1 )
+        void vApplicationGetPassiveIdleTaskMemory( StaticTask_t ** ppxIdleTaskTCBBuffer,
+                                                   StackType_t ** ppxIdleTaskStackBuffer,
+                                                   configSTACK_DEPTH_TYPE * puxIdleTaskStackSize,
+                                                   BaseType_t xPassiveIdleTaskIndex );
+    #endif /* #if ( configNUMBER_OF_CORES > 1 ) */
+#endif /* if ( configSUPPORT_STATIC_ALLOCATION == 1 ) */
 
 /**
  * task.h
@@ -1683,17 +2055,35 @@ void vApplicationGetIdleTaskMemory(StaticTask_t ** ppxIdleTaskTCBBuffer,
  * wants.  The return value is the value returned by the task hook function
  * registered by the user.
  */
-BaseType_t xTaskCallApplicationTaskHook(TaskHandle_t xTask,
-                                        void * pvParameter) PRIVILEGED_FUNCTION;
+#if ( configUSE_APPLICATION_TASK_TAG == 1 )
+    BaseType_t xTaskCallApplicationTaskHook( TaskHandle_t xTask,
+                                             void * pvParameter ) PRIVILEGED_FUNCTION;
+#endif
 
 /**
  * xTaskGetIdleTaskHandle() is only available if
  * INCLUDE_xTaskGetIdleTaskHandle is set to 1 in FreeRTOSConfig.h.
  *
- * Simply returns the handle of the idle task.  It is not valid to call
- * xTaskGetIdleTaskHandle() before the scheduler has been started.
+ * In single-core FreeRTOS, this function simply returns the handle of the idle
+ * task. It is not valid to call xTaskGetIdleTaskHandle() before the scheduler
+ * has been started.
+ *
+ * In the FreeRTOS SMP, there are a total of configNUMBER_OF_CORES idle tasks:
+ *  1. 1 Active idle task which does all the housekeeping.
+ *  2. ( configNUMBER_OF_CORES - 1 ) Passive idle tasks which do nothing.
+ * These idle tasks are created to ensure that each core has an idle task to run when
+ * no other task is available to run. Call xTaskGetIdleTaskHandle() or
+ * xTaskGetIdleTaskHandleForCore() with xCoreID set to 0  to get the Active
+ * idle task handle. Call xTaskGetIdleTaskHandleForCore() with xCoreID set to
+ * 1,2 ... ( configNUMBER_OF_CORES - 1 ) to get the Passive idle task handles.
  */
-TaskHandle_t xTaskGetIdleTaskHandle(void) PRIVILEGED_FUNCTION;
+#if ( INCLUDE_xTaskGetIdleTaskHandle == 1 )
+    #if ( configNUMBER_OF_CORES == 1 )
+        TaskHandle_t xTaskGetIdleTaskHandle( void ) PRIVILEGED_FUNCTION;
+    #endif /* #if ( configNUMBER_OF_CORES == 1 ) */
+
+    TaskHandle_t xTaskGetIdleTaskHandleForCore( BaseType_t xCoreID ) PRIVILEGED_FUNCTION;
+#endif /* #if ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) */
 
 /**
  * configUSE_TRACE_FACILITY must be defined as 1 in FreeRTOSConfig.h for
@@ -1749,15 +2139,15 @@ TaskHandle_t xTaskGetIdleTaskHandle(void) PRIVILEGED_FUNCTION;
  *
  *      // Allocate a TaskStatus_t structure for each task.  An array could be
  *      // allocated statically at compile time.
- *      pxTaskStatusArray = SramMalloc( uxArraySize * sizeof( TaskStatus_t ) );
+ *      pxTaskStatusArray = pvPortMalloc( uxArraySize * sizeof( TaskStatus_t ) );
  *
  *      if( pxTaskStatusArray != NULL )
  *      {
  *          // Generate raw status information about each task.
  *          uxArraySize = uxTaskGetSystemState( pxTaskStatusArray, uxArraySize, &ulTotalRunTime );
  *
  *          // For percentage calculations.
- *          ulTotalRunTime /= 100UL;
+ *          ulTotalRunTime /= 100U;
  *
  *          // Avoid divide by zero errors.
  *          if( ulTotalRunTime > 0 )
@@ -1771,7 +2161,7 @@ TaskHandle_t xTaskGetIdleTaskHandle(void) PRIVILEGED_FUNCTION;
  *                  // ulTotalRunTimeDiv100 has already been divided by 100.
  *                  ulStatsAsPercentage = pxTaskStatusArray[ x ].ulRunTimeCounter / ulTotalRunTime;
  *
- *                  if( ulStatsAsPercentage > 0UL )
+ *                  if( ulStatsAsPercentage > 0U )
  *                  {
  *                      sprintf( pcWriteBuffer, "%s\t\t%lu\t\t%lu%%\r\n", pxTaskStatusArray[ x ].pcTaskName, pxTaskStatusArray[ x ].ulRunTimeCounter, ulStatsAsPercentage );
  *                  }
@@ -1787,14 +2177,80 @@ TaskHandle_t xTaskGetIdleTaskHandle(void) PRIVILEGED_FUNCTION;
  *          }
  *
  *          // The array is no longer needed, free the memory it consumes.
- *          SramFree( pxTaskStatusArray );
+ *          vPortFree( pxTaskStatusArray );
  *      }
  *  }
  *  @endcode
  */
-UBaseType_t uxTaskGetSystemState(TaskStatus_t * const pxTaskStatusArray,
-                                 const UBaseType_t uxArraySize,
-                                 configRUN_TIME_COUNTER_TYPE * const pulTotalRunTime) PRIVILEGED_FUNCTION;
+#if ( configUSE_TRACE_FACILITY == 1 )
+    UBaseType_t uxTaskGetSystemState( TaskStatus_t * const pxTaskStatusArray,
+                                      const UBaseType_t uxArraySize,
+                                      configRUN_TIME_COUNTER_TYPE * const pulTotalRunTime ) PRIVILEGED_FUNCTION;
+#endif
+
+/**
+ * task. h
+ * @code{c}
+ * void vTaskListTasks( char *pcWriteBuffer, size_t uxBufferLength );
+ * @endcode
+ *
+ * configUSE_TRACE_FACILITY and configUSE_STATS_FORMATTING_FUNCTIONS must
+ * both be defined as 1 for this function to be available.  See the
+ * configuration section of the FreeRTOS.org website for more information.
+ *
+ * NOTE 1: This function will disable interrupts for its duration.  It is
+ * not intended for normal application runtime use but as a debug aid.
+ *
+ * Lists all the current tasks, along with their current state and stack
+ * usage high water mark.
+ *
+ * Tasks are reported as running ('X'), blocked ('B'), ready ('R'), deleted ('D')
+ * or suspended ('S').
+ *
+ * PLEASE NOTE:
+ *
+ * This function is provided for convenience only, and is used by many of the
+ * demo applications.  Do not consider it to be part of the scheduler.
+ *
+ * vTaskListTasks() calls uxTaskGetSystemState(), then formats part of the
+ * uxTaskGetSystemState() output into a human readable table that displays task
+ * information in the following format:
+ * Task Name, Task State, Task Priority, Task Stack High Watermak, Task Number.
+ *
+ * The following is a sample output:
+ * Task A       X       2           67           2
+ * Task B       R       1           67           3
+ * IDLE         R       0           67           5
+ * Tmr Svc      B       6           137          6
+ *
+ * Stack usage specified as the number of unused StackType_t words stack can hold
+ * on top of stack - not the number of bytes.
+ *
+ * vTaskListTasks() has a dependency on the snprintf() C library function that might
+ * bloat the code size, use a lot of stack, and provide different results on
+ * different platforms.  An alternative, tiny, third party, and limited
+ * functionality implementation of snprintf() is provided in many of the
+ * FreeRTOS/Demo sub-directories in a file called printf-stdarg.c (note
+ * printf-stdarg.c does not provide a full snprintf() implementation!).
+ *
+ * It is recommended that production systems call uxTaskGetSystemState()
+ * directly to get access to raw stats data, rather than indirectly through a
+ * call to vTaskListTasks().
+ *
+ * @param pcWriteBuffer A buffer into which the above mentioned details
+ * will be written, in ASCII form.  This buffer is assumed to be large
+ * enough to contain the generated report.  Approximately 40 bytes per
+ * task should be sufficient.
+ *
+ * @param uxBufferLength Length of the pcWriteBuffer.
+ *
+ * \defgroup vTaskListTasks vTaskListTasks
+ * \ingroup TaskUtils
+ */
+#if ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) )
+    void vTaskListTasks( char * pcWriteBuffer,
+                         size_t uxBufferLength ) PRIVILEGED_FUNCTION;
+#endif
 
 /**
  * task. h
@@ -1806,30 +2262,43 @@ UBaseType_t uxTaskGetSystemState(TaskStatus_t * const pxTaskStatusArray,
  * both be defined as 1 for this function to be available.  See the
  * configuration section of the FreeRTOS.org website for more information.
  *
+ * WARN: This function assumes that the pcWriteBuffer is of length
+ * configSTATS_BUFFER_MAX_LENGTH. This function is there only for
+ * backward compatibility. New applications are recommended to
+ * use vTaskListTasks and supply the length of the pcWriteBuffer explicitly.
+ *
  * NOTE 1: This function will disable interrupts for its duration.  It is
  * not intended for normal application runtime use but as a debug aid.
  *
  * Lists all the current tasks, along with their current state and stack
  * usage high water mark.
  *
- * Tasks are reported as blocked ('B'), ready ('R'), deleted ('D') or
- * suspended ('S').
+ * Tasks are reported as running ('X'), blocked ('B'), ready ('R'), deleted ('D')
+ * or suspended ('S').
  *
  * PLEASE NOTE:
  *
  * This function is provided for convenience only, and is used by many of the
  * demo applications.  Do not consider it to be part of the scheduler.
  *
  * vTaskList() calls uxTaskGetSystemState(), then formats part of the
- * uxTaskGetSystemState() output into a human readable table that displays task:
- * names, states, priority, stack usage and task number.
+ * uxTaskGetSystemState() output into a human readable table that displays task
+ * information in the following format:
+ * Task Name, Task State, Task Priority, Task Stack High Watermak, Task Number.
+ *
+ * The following is a sample output:
+ * Task A       X       2           67           2
+ * Task B       R       1           67           3
+ * IDLE         R       0           67           5
+ * Tmr Svc      B       6           137          6
+ *
  * Stack usage specified as the number of unused StackType_t words stack can hold
  * on top of stack - not the number of bytes.
  *
- * vTaskList() has a dependency on the sprintf() C library function that might
+ * vTaskList() has a dependency on the snprintf() C library function that might
  * bloat the code size, use a lot of stack, and provide different results on
  * different platforms.  An alternative, tiny, third party, and limited
- * functionality implementation of sprintf() is provided in many of the
+ * functionality implementation of snprintf() is provided in many of the
  * FreeRTOS/Demo sub-directories in a file called printf-stdarg.c (note
  * printf-stdarg.c does not provide a full snprintf() implementation!).
  *
@@ -1845,7 +2314,68 @@ UBaseType_t uxTaskGetSystemState(TaskStatus_t * const pxTaskStatusArray,
  * \defgroup vTaskList vTaskList
  * \ingroup TaskUtils
  */
-void vTaskList(char * pcWriteBuffer) PRIVILEGED_FUNCTION;   /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
+#define vTaskList( pcWriteBuffer )    vTaskListTasks( ( pcWriteBuffer ), configSTATS_BUFFER_MAX_LENGTH )
+
+/**
+ * task. h
+ * @code{c}
+ * void vTaskGetRunTimeStatistics( char *pcWriteBuffer, size_t uxBufferLength );
+ * @endcode
+ *
+ * configGENERATE_RUN_TIME_STATS and configUSE_STATS_FORMATTING_FUNCTIONS
+ * must both be defined as 1 for this function to be available.  The application
+ * must also then provide definitions for
+ * portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() and portGET_RUN_TIME_COUNTER_VALUE()
+ * to configure a peripheral timer/counter and return the timers current count
+ * value respectively.  The counter should be at least 10 times the frequency of
+ * the tick count.
+ *
+ * NOTE 1: This function will disable interrupts for its duration.  It is
+ * not intended for normal application runtime use but as a debug aid.
+ *
+ * Setting configGENERATE_RUN_TIME_STATS to 1 will result in a total
+ * accumulated execution time being stored for each task.  The resolution
+ * of the accumulated time value depends on the frequency of the timer
+ * configured by the portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() macro.
+ * Calling vTaskGetRunTimeStatistics() writes the total execution time of each
+ * task into a buffer, both as an absolute count value and as a percentage
+ * of the total system execution time.
+ *
+ * NOTE 2:
+ *
+ * This function is provided for convenience only, and is used by many of the
+ * demo applications.  Do not consider it to be part of the scheduler.
+ *
+ * vTaskGetRunTimeStatistics() calls uxTaskGetSystemState(), then formats part of
+ * the uxTaskGetSystemState() output into a human readable table that displays the
+ * amount of time each task has spent in the Running state in both absolute and
+ * percentage terms.
+ *
+ * vTaskGetRunTimeStatistics() has a dependency on the snprintf() C library function
+ * that might bloat the code size, use a lot of stack, and provide different
+ * results on different platforms.  An alternative, tiny, third party, and
+ * limited functionality implementation of snprintf() is provided in many of the
+ * FreeRTOS/Demo sub-directories in a file called printf-stdarg.c (note
+ * printf-stdarg.c does not provide a full snprintf() implementation!).
+ *
+ * It is recommended that production systems call uxTaskGetSystemState() directly
+ * to get access to raw stats data, rather than indirectly through a call to
+ * vTaskGetRunTimeStatistics().
+ *
+ * @param pcWriteBuffer A buffer into which the execution times will be
+ * written, in ASCII form.  This buffer is assumed to be large enough to
+ * contain the generated report.  Approximately 40 bytes per task should
+ * be sufficient.
+ *
+ * @param uxBufferLength Length of the pcWriteBuffer.
+ *
+ * \defgroup vTaskGetRunTimeStatistics vTaskGetRunTimeStatistics
+ * \ingroup TaskUtils
+ */
+#if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) && ( configUSE_TRACE_FACILITY == 1 ) )
+    void vTaskGetRunTimeStatistics( char * pcWriteBuffer,
+                                    size_t uxBufferLength ) PRIVILEGED_FUNCTION;
+#endif
 
 /**
  * task. h
@@ -1861,6 +2391,12 @@ void vTaskList(char * pcWriteBuffer) PRIVILEGED_FUNCTION;   /*lint !e971 Unquali
  * value respectively.  The counter should be at least 10 times the frequency of
  * the tick count.
  *
+ * WARN: This function assumes that the pcWriteBuffer is of length
+ * configSTATS_BUFFER_MAX_LENGTH. This function is there only for
+ * backward compatibility. New applications are recommended to use
+ * vTaskGetRunTimeStatistics and supply the length of the pcWriteBuffer
+ * explicitly.
+ *
  * NOTE 1: This function will disable interrupts for its duration.  It is
  * not intended for normal application runtime use but as a debug aid.
  *
@@ -1882,10 +2418,10 @@ void vTaskList(char * pcWriteBuffer) PRIVILEGED_FUNCTION;   /*lint !e971 Unquali
  * amount of time each task has spent in the Running state in both absolute and
  * percentage terms.
  *
- * vTaskGetRunTimeStats() has a dependency on the sprintf() C library function
+ * vTaskGetRunTimeStats() has a dependency on the snprintf() C library function
  * that might bloat the code size, use a lot of stack, and provide different
  * results on different platforms.  An alternative, tiny, third party, and
- * limited functionality implementation of sprintf() is provided in many of the
+ * limited functionality implementation of snprintf() is provided in many of the
  * FreeRTOS/Demo sub-directories in a file called printf-stdarg.c (note
  * printf-stdarg.c does not provide a full snprintf() implementation!).
  *
@@ -1901,7 +2437,45 @@ void vTaskList(char * pcWriteBuffer) PRIVILEGED_FUNCTION;   /*lint !e971 Unquali
  * \defgroup vTaskGetRunTimeStats vTaskGetRunTimeStats
  * \ingroup TaskUtils
  */
-void vTaskGetRunTimeStats(char * pcWriteBuffer) PRIVILEGED_FUNCTION;   /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
+#define vTaskGetRunTimeStats( pcWriteBuffer )    vTaskGetRunTimeStatistics( ( pcWriteBuffer ), configSTATS_BUFFER_MAX_LENGTH )
+
+/**
+ * task. h
+ * @code{c}
+ * configRUN_TIME_COUNTER_TYPE ulTaskGetRunTimeCounter( const TaskHandle_t xTask );
+ * configRUN_TIME_COUNTER_TYPE ulTaskGetRunTimePercent( const TaskHandle_t xTask );
+ * @endcode
+ *
+ * configGENERATE_RUN_TIME_STATS must be defined as 1 for these functions to be
+ * available.  The application must also then provide definitions for
+ * portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() and
+ * portGET_RUN_TIME_COUNTER_VALUE() to configure a peripheral timer/counter and
+ * return the timers current count value respectively.  The counter should be
+ * at least 10 times the frequency of the tick count.
+ *
+ * Setting configGENERATE_RUN_TIME_STATS to 1 will result in a total
+ * accumulated execution time being stored for each task.  The resolution
+ * of the accumulated time value depends on the frequency of the timer
+ * configured by the portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() macro.
+ * While uxTaskGetSystemState() and vTaskGetRunTimeStats() writes the total
+ * execution time of each task into a buffer, ulTaskGetRunTimeCounter()
+ * returns the total execution time of just one task and
+ * ulTaskGetRunTimePercent() returns the percentage of the CPU time used by
+ * just one task.
+ *
+ * @return The total run time of the given task or the percentage of the total
+ * run time consumed by the given task.  This is the amount of time the task
+ * has actually been executing.  The unit of time is dependent on the frequency
+ * configured using the portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() and
+ * portGET_RUN_TIME_COUNTER_VALUE() macros.
+ *
+ * \defgroup ulTaskGetRunTimeCounter ulTaskGetRunTimeCounter
+ * \ingroup TaskUtils
+ */
+#if ( configGENERATE_RUN_TIME_STATS == 1 )
+    configRUN_TIME_COUNTER_TYPE ulTaskGetRunTimeCounter( const TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
+    configRUN_TIME_COUNTER_TYPE ulTaskGetRunTimePercent( const TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
+#endif
 
 /**
  * task. h
@@ -1910,13 +2484,12 @@ void vTaskGetRunTimeStats(char * pcWriteBuffer) PRIVILEGED_FUNCTION;   /*lint !e
  * configRUN_TIME_COUNTER_TYPE ulTaskGetIdleRunTimePercent( void );
  * @endcode
  *
- * configGENERATE_RUN_TIME_STATS, configUSE_STATS_FORMATTING_FUNCTIONS and
- * INCLUDE_xTaskGetIdleTaskHandle must all be defined as 1 for these functions
- * to be available.  The application must also then provide definitions for
- * portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() and portGET_RUN_TIME_COUNTER_VALUE()
- * to configure a peripheral timer/counter and return the timers current count
- * value respectively.  The counter should be at least 10 times the frequency of
- * the tick count.
+ * configGENERATE_RUN_TIME_STATS must be defined as 1 for these functions to be
+ * available.  The application must also then provide definitions for
+ * portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() and
+ * portGET_RUN_TIME_COUNTER_VALUE() to configure a peripheral timer/counter and
+ * return the timers current count value respectively.  The counter should be
+ * at least 10 times the frequency of the tick count.
  *
  * Setting configGENERATE_RUN_TIME_STATS to 1 will result in a total
  * accumulated execution time being stored for each task.  The resolution
@@ -1941,8 +2514,10 @@ void vTaskGetRunTimeStats(char * pcWriteBuffer) PRIVILEGED_FUNCTION;   /*lint !e
  * \defgroup ulTaskGetIdleRunTimeCounter ulTaskGetIdleRunTimeCounter
  * \ingroup TaskUtils
  */
-configRUN_TIME_COUNTER_TYPE ulTaskGetIdleRunTimeCounter(void) PRIVILEGED_FUNCTION;
-configRUN_TIME_COUNTER_TYPE ulTaskGetIdleRunTimePercent(void) PRIVILEGED_FUNCTION;
+#if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) )
+    configRUN_TIME_COUNTER_TYPE ulTaskGetIdleRunTimeCounter( void ) PRIVILEGED_FUNCTION;
+    configRUN_TIME_COUNTER_TYPE ulTaskGetIdleRunTimePercent( void ) PRIVILEGED_FUNCTION;
+#endif
 
 /**
  * task. h
@@ -2042,21 +2617,20 @@ configRUN_TIME_COUNTER_TYPE ulTaskGetIdleRunTimePercent(void) PRIVILEGED_FUNCTIO
  * notification value at that index being updated.  ulValue is not used and
  * xTaskNotifyIndexed() always returns pdPASS in this case.
  *
- * pulPreviousNotificationValue -
- * Can be used to pass out the subject task's notification value before any
- * bits are modified by the notify function.
+ * @param pulPreviousNotificationValue Can be used to pass out the subject
+ * task's notification value before any bits are modified by the notify function.
  *
  * @return Dependent on the value of eAction.  See the description of the
  * eAction parameter.
  *
  * \defgroup xTaskNotifyIndexed xTaskNotifyIndexed
  * \ingroup TaskNotifications
  */
-BaseType_t xTaskGenericNotify(TaskHandle_t xTaskToNotify,
-                              UBaseType_t uxIndexToNotify,
-                              uint32_t ulValue,
-                              eNotifyAction eAction,
-                              uint32_t * pulPreviousNotificationValue) PRIVILEGED_FUNCTION;
+BaseType_t xTaskGenericNotify( TaskHandle_t xTaskToNotify,
+                               UBaseType_t uxIndexToNotify,
+                               uint32_t ulValue,
+                               eNotifyAction eAction,
+                               uint32_t * pulPreviousNotificationValue ) PRIVILEGED_FUNCTION;
 #define xTaskNotify( xTaskToNotify, ulValue, eAction ) \
     xTaskGenericNotify( ( xTaskToNotify ), ( tskDEFAULT_INDEX_TO_NOTIFY ), ( ulValue ), ( eAction ), NULL )
 #define xTaskNotifyIndexed( xTaskToNotify, uxIndexToNotify, ulValue, eAction ) \
@@ -2189,6 +2763,9 @@ BaseType_t xTaskGenericNotify(TaskHandle_t xTaskToNotify,
  * updated.  ulValue is not used and xTaskNotify() always returns pdPASS in
  * this case.
  *
+ * @param pulPreviousNotificationValue Can be used to pass out the subject
+ * task's notification value before any bits are modified by the notify function.
+ *
  * @param pxHigherPriorityTaskWoken  xTaskNotifyFromISR() will set
  * *pxHigherPriorityTaskWoken to pdTRUE if sending the notification caused the
  * task to which the notification was sent to leave the Blocked state, and the
@@ -2204,12 +2781,12 @@ BaseType_t xTaskGenericNotify(TaskHandle_t xTaskToNotify,
  * \defgroup xTaskNotifyIndexedFromISR xTaskNotifyIndexedFromISR
  * \ingroup TaskNotifications
  */
-BaseType_t xTaskGenericNotifyFromISR(TaskHandle_t xTaskToNotify,
-                                     UBaseType_t uxIndexToNotify,
-                                     uint32_t ulValue,
-                                     eNotifyAction eAction,
-                                     uint32_t * pulPreviousNotificationValue,
-                                     BaseType_t * pxHigherPriorityTaskWoken) PRIVILEGED_FUNCTION;
+BaseType_t xTaskGenericNotifyFromISR( TaskHandle_t xTaskToNotify,
+                                      UBaseType_t uxIndexToNotify,
+                                      uint32_t ulValue,
+                                      eNotifyAction eAction,
+                                      uint32_t * pulPreviousNotificationValue,
+                                      BaseType_t * pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;
 #define xTaskNotifyFromISR( xTaskToNotify, ulValue, eAction, pxHigherPriorityTaskWoken ) \
     xTaskGenericNotifyFromISR( ( xTaskToNotify ), ( tskDEFAULT_INDEX_TO_NOTIFY ), ( ulValue ), ( eAction ), NULL, ( pxHigherPriorityTaskWoken ) )
 #define xTaskNotifyIndexedFromISR( xTaskToNotify, uxIndexToNotify, ulValue, eAction, pxHigherPriorityTaskWoken ) \
@@ -2312,7 +2889,7 @@ BaseType_t xTaskGenericNotifyFromISR(TaskHandle_t xTaskToNotify,
  * will be cleared in the calling task's notification value before the task
  * checks to see if any notifications are pending, and optionally blocks if no
  * notifications are pending.  Setting ulBitsToClearOnEntry to ULONG_MAX (if
- * limits.h is included) or 0xffffffffUL (if limits.h is not included) will have
+ * limits.h is included) or 0xffffffffU (if limits.h is not included) will have
  * the effect of resetting the task's notification value to 0.  Setting
  * ulBitsToClearOnEntry to 0 will leave the task's notification value unchanged.
  *
@@ -2348,11 +2925,11 @@ BaseType_t xTaskGenericNotifyFromISR(TaskHandle_t xTaskToNotify,
  * \defgroup xTaskNotifyWaitIndexed xTaskNotifyWaitIndexed
  * \ingroup TaskNotifications
  */
-BaseType_t xTaskGenericNotifyWait(UBaseType_t uxIndexToWaitOn,
-                                  uint32_t ulBitsToClearOnEntry,
-                                  uint32_t ulBitsToClearOnExit,
-                                  uint32_t * pulNotificationValue,
-                                  TickType_t xTicksToWait) PRIVILEGED_FUNCTION;
+BaseType_t xTaskGenericNotifyWait( UBaseType_t uxIndexToWaitOn,
+                                   uint32_t ulBitsToClearOnEntry,
+                                   uint32_t ulBitsToClearOnExit,
+                                   uint32_t * pulNotificationValue,
+                                   TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
 #define xTaskNotifyWait( ulBitsToClearOnEntry, ulBitsToClearOnExit, pulNotificationValue, xTicksToWait ) \
     xTaskGenericNotifyWait( tskDEFAULT_INDEX_TO_NOTIFY, ( ulBitsToClearOnEntry ), ( ulBitsToClearOnExit ), ( pulNotificationValue ), ( xTicksToWait ) )
 #define xTaskNotifyWaitIndexed( uxIndexToWaitOn, ulBitsToClearOnEntry, ulBitsToClearOnExit, pulNotificationValue, xTicksToWait ) \
@@ -2397,7 +2974,7 @@ BaseType_t xTaskGenericNotifyWait(UBaseType_t uxIndexToWaitOn,
  *
  * When task notifications are being used as a binary or counting semaphore
  * equivalent then the task being notified should wait for the notification
- * using the ulTaskNotificationTakeIndexed() API function rather than the
+ * using the ulTaskNotifyTakeIndexed() API function rather than the
  * xTaskNotifyWaitIndexed() API function.
  *
  * **NOTE** Each notification within the array operates independently - a task
@@ -2474,7 +3051,7 @@ BaseType_t xTaskGenericNotifyWait(UBaseType_t uxIndexToWaitOn,
  *
  * When task notifications are being used as a binary or counting semaphore
  * equivalent then the task being notified should wait for the notification
- * using the ulTaskNotificationTakeIndexed() API function rather than the
+ * using the ulTaskNotifyTakeIndexed() API function rather than the
  * xTaskNotifyWaitIndexed() API function.
  *
  * **NOTE** Each notification within the array operates independently - a task
@@ -2514,13 +3091,13 @@ BaseType_t xTaskGenericNotifyWait(UBaseType_t uxIndexToWaitOn,
  * \defgroup vTaskNotifyGiveIndexedFromISR vTaskNotifyGiveIndexedFromISR
  * \ingroup TaskNotifications
  */
-void vTaskGenericNotifyGiveFromISR(TaskHandle_t xTaskToNotify,
-                                   UBaseType_t uxIndexToNotify,
-                                   BaseType_t * pxHigherPriorityTaskWoken) PRIVILEGED_FUNCTION;
+void vTaskGenericNotifyGiveFromISR( TaskHandle_t xTaskToNotify,
+                                    UBaseType_t uxIndexToNotify,
+                                    BaseType_t * pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;
 #define vTaskNotifyGiveFromISR( xTaskToNotify, pxHigherPriorityTaskWoken ) \
-    vTaskGenericNotifyGiveFromISR( ( xTaskToNotify ), ( tskDEFAULT_INDEX_TO_NOTIFY ), ( pxHigherPriorityTaskWoken ) );
+    vTaskGenericNotifyGiveFromISR( ( xTaskToNotify ), ( tskDEFAULT_INDEX_TO_NOTIFY ), ( pxHigherPriorityTaskWoken ) )
 #define vTaskNotifyGiveIndexedFromISR( xTaskToNotify, uxIndexToNotify, pxHigherPriorityTaskWoken ) \
-    vTaskGenericNotifyGiveFromISR( ( xTaskToNotify ), ( uxIndexToNotify ), ( pxHigherPriorityTaskWoken ) );
+    vTaskGenericNotifyGiveFromISR( ( xTaskToNotify ), ( uxIndexToNotify ), ( pxHigherPriorityTaskWoken ) )
 
 /**
  * task. h
@@ -2620,9 +3197,9 @@ void vTaskGenericNotifyGiveFromISR(TaskHandle_t xTaskToNotify,
  * \defgroup ulTaskNotifyTakeIndexed ulTaskNotifyTakeIndexed
  * \ingroup TaskNotifications
  */
-uint32_t ulTaskGenericNotifyTake(UBaseType_t uxIndexToWaitOn,
-                                 BaseType_t xClearCountOnExit,
-                                 TickType_t xTicksToWait) PRIVILEGED_FUNCTION;
+uint32_t ulTaskGenericNotifyTake( UBaseType_t uxIndexToWaitOn,
+                                  BaseType_t xClearCountOnExit,
+                                  TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
 #define ulTaskNotifyTake( xClearCountOnExit, xTicksToWait ) \
     ulTaskGenericNotifyTake( ( tskDEFAULT_INDEX_TO_NOTIFY ), ( xClearCountOnExit ), ( xTicksToWait ) )
 #define ulTaskNotifyTakeIndexed( uxIndexToWaitOn, xClearCountOnExit, xTicksToWait ) \
@@ -2685,8 +3262,8 @@ uint32_t ulTaskGenericNotifyTake(UBaseType_t uxIndexToWaitOn,
  * \defgroup xTaskNotifyStateClearIndexed xTaskNotifyStateClearIndexed
  * \ingroup TaskNotifications
  */
-BaseType_t xTaskGenericNotifyStateClear(TaskHandle_t xTask,
-                                        UBaseType_t uxIndexToClear) PRIVILEGED_FUNCTION;
+BaseType_t xTaskGenericNotifyStateClear( TaskHandle_t xTask,
+                                         UBaseType_t uxIndexToClear ) PRIVILEGED_FUNCTION;
 #define xTaskNotifyStateClear( xTask ) \
     xTaskGenericNotifyStateClear( ( xTask ), ( tskDEFAULT_INDEX_TO_NOTIFY ) )
 #define xTaskNotifyStateClearIndexed( xTask, uxIndexToClear ) \
@@ -2750,9 +3327,9 @@ BaseType_t xTaskGenericNotifyStateClear(TaskHandle_t xTask,
  * \defgroup ulTaskNotifyValueClear ulTaskNotifyValueClear
  * \ingroup TaskNotifications
  */
-uint32_t ulTaskGenericNotifyValueClear(TaskHandle_t xTask,
-                                       UBaseType_t uxIndexToClear,
-                                       uint32_t ulBitsToClear) PRIVILEGED_FUNCTION;
+uint32_t ulTaskGenericNotifyValueClear( TaskHandle_t xTask,
+                                        UBaseType_t uxIndexToClear,
+                                        uint32_t ulBitsToClear ) PRIVILEGED_FUNCTION;
 #define ulTaskNotifyValueClear( xTask, ulBitsToClear ) \
     ulTaskGenericNotifyValueClear( ( xTask ), ( tskDEFAULT_INDEX_TO_NOTIFY ), ( ulBitsToClear ) )
 #define ulTaskNotifyValueClearIndexed( xTask, uxIndexToClear, ulBitsToClear ) \
@@ -2772,7 +3349,7 @@ uint32_t ulTaskGenericNotifyValueClear(TaskHandle_t xTask,
  * \defgroup vTaskSetTimeOutState vTaskSetTimeOutState
  * \ingroup TaskCtrl
  */
-void vTaskSetTimeOutState(TimeOut_t * const pxTimeOut) PRIVILEGED_FUNCTION;
+void vTaskSetTimeOutState( TimeOut_t * const pxTimeOut ) PRIVILEGED_FUNCTION;
 
 /**
  * task.h
@@ -2857,8 +3434,8 @@ void vTaskSetTimeOutState(TimeOut_t * const pxTimeOut) PRIVILEGED_FUNCTION;
  * \defgroup xTaskCheckForTimeOut xTaskCheckForTimeOut
  * \ingroup TaskCtrl
  */
-BaseType_t xTaskCheckForTimeOut(TimeOut_t * const pxTimeOut,
-                                TickType_t * const pxTicksToWait) PRIVILEGED_FUNCTION;
+BaseType_t xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut,
+                                 TickType_t * const pxTicksToWait ) PRIVILEGED_FUNCTION;
 
 /**
  * task.h
@@ -2886,13 +3463,33 @@ BaseType_t xTaskCheckForTimeOut(TimeOut_t * const pxTimeOut,
  * \defgroup xTaskCatchUpTicks xTaskCatchUpTicks
  * \ingroup TaskCtrl
  */
-BaseType_t xTaskCatchUpTicks(TickType_t xTicksToCatchUp) PRIVILEGED_FUNCTION;
+BaseType_t xTaskCatchUpTicks( TickType_t xTicksToCatchUp ) PRIVILEGED_FUNCTION;
+
+/**
+ * task.h
+ * @code{c}
+ * void vTaskResetState( void );
+ * @endcode
+ *
+ * This function resets the internal state of the task. It must be called by the
+ * application before restarting the scheduler.
+ *
+ * \defgroup vTaskResetState vTaskResetState
+ * \ingroup SchedulerControl
+ */
+void vTaskResetState( void ) PRIVILEGED_FUNCTION;
 
 
 /*-----------------------------------------------------------
 * SCHEDULER INTERNALS AVAILABLE FOR PORTING PURPOSES
 *----------------------------------------------------------*/
 
+#if ( configNUMBER_OF_CORES == 1 )
+    #define taskYIELD_WITHIN_API()    portYIELD_WITHIN_API()
+#else /* #if ( configNUMBER_OF_CORES == 1 ) */
+    #define taskYIELD_WITHIN_API()    vTaskYieldWithinAPI()
+#endif /* #if ( configNUMBER_OF_CORES == 1 ) */
+
 /*
  * THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE.  IT IS ONLY
  * INTENDED FOR USE WHEN IMPLEMENTING A PORT OF THE SCHEDULER AND IS
@@ -2908,7 +3505,7 @@ BaseType_t xTaskCatchUpTicks(TickType_t xTicksToCatchUp) PRIVILEGED_FUNCTION;
  *   + Time slicing is in use and there is a task of equal priority to the
  *     currently running task.
  */
-BaseType_t xTaskIncrementTick(void) PRIVILEGED_FUNCTION;
+BaseType_t xTaskIncrementTick( void ) PRIVILEGED_FUNCTION;
 
 /*
  * THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE.  IT IS AN
@@ -2941,11 +3538,11 @@ BaseType_t xTaskIncrementTick(void) PRIVILEGED_FUNCTION;
  * portTICK_PERIOD_MS can be used to convert kernel ticks into a real time
  * period.
  */
-void vTaskPlaceOnEventList(List_t * const pxEventList,
-                           const TickType_t xTicksToWait) PRIVILEGED_FUNCTION;
-void vTaskPlaceOnUnorderedEventList(List_t * pxEventList,
-                                    const TickType_t xItemValue,
-                                    const TickType_t xTicksToWait) PRIVILEGED_FUNCTION;
+void vTaskPlaceOnEventList( List_t * const pxEventList,
+                            const TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
+void vTaskPlaceOnUnorderedEventList( List_t * pxEventList,
+                                     const TickType_t xItemValue,
+                                     const TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
 
 /*
  * THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE.  IT IS AN
@@ -2958,9 +3555,9 @@ void vTaskPlaceOnUnorderedEventList(List_t * pxEventList,
  * indefinitely, whereas vTaskPlaceOnEventList() does.
  *
  */
-void vTaskPlaceOnEventListRestricted(List_t * const pxEventList,
-                                     TickType_t xTicksToWait,
-                                     const BaseType_t xWaitIndefinitely) PRIVILEGED_FUNCTION;
+void vTaskPlaceOnEventListRestricted( List_t * const pxEventList,
+                                      TickType_t xTicksToWait,
+                                      const BaseType_t xWaitIndefinitely ) PRIVILEGED_FUNCTION;
 
 /*
  * THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE.  IT IS AN
@@ -2986,9 +3583,9 @@ void vTaskPlaceOnEventListRestricted(List_t * const pxEventList,
  * @return pdTRUE if the task being removed has a higher priority than the task
  * making the call, otherwise pdFALSE.
  */
-BaseType_t xTaskRemoveFromEventList(const List_t * const pxEventList) PRIVILEGED_FUNCTION;
-void vTaskRemoveFromUnorderedEventList(ListItem_t * pxEventListItem,
-                                       const TickType_t xItemValue) PRIVILEGED_FUNCTION;
+BaseType_t xTaskRemoveFromEventList( const List_t * const pxEventList ) PRIVILEGED_FUNCTION;
+void vTaskRemoveFromUnorderedEventList( ListItem_t * pxEventListItem,
+                                        const TickType_t xItemValue ) PRIVILEGED_FUNCTION;
 
 /*
  * THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE.  IT IS ONLY
@@ -2998,42 +3595,51 @@ void vTaskRemoveFromUnorderedEventList(ListItem_t * pxEventListItem,
  * Sets the pointer to the current TCB to the TCB of the highest priority task
  * that is ready to run.
  */
-portDONT_DISCARD void vTaskSwitchContext(void) PRIVILEGED_FUNCTION;
+#if ( configNUMBER_OF_CORES == 1 )
+    portDONT_DISCARD void vTaskSwitchContext( void ) PRIVILEGED_FUNCTION;
+#else
+    portDONT_DISCARD void vTaskSwitchContext( BaseType_t xCoreID ) PRIVILEGED_FUNCTION;
+#endif
 
 /*
  * THESE FUNCTIONS MUST NOT BE USED FROM APPLICATION CODE.  THEY ARE USED BY
  * THE EVENT BITS MODULE.
  */
-TickType_t uxTaskResetEventItemValue(void) PRIVILEGED_FUNCTION;
+TickType_t uxTaskResetEventItemValue( void ) PRIVILEGED_FUNCTION;
 
 /*
  * Return the handle of the calling task.
  */
-TaskHandle_t xTaskGetCurrentTaskHandle(void) PRIVILEGED_FUNCTION;
+TaskHandle_t xTaskGetCurrentTaskHandle( void ) PRIVILEGED_FUNCTION;
+
+/*
+ * Return the handle of the task running on specified core.
+ */
+TaskHandle_t xTaskGetCurrentTaskHandleForCore( BaseType_t xCoreID ) PRIVILEGED_FUNCTION;
 
 /*
  * Shortcut used by the queue implementation to prevent unnecessary call to
  * taskYIELD();
  */
-void vTaskMissedYield(void) PRIVILEGED_FUNCTION;
+void vTaskMissedYield( void ) PRIVILEGED_FUNCTION;
 
 /*
  * Returns the scheduler state as taskSCHEDULER_RUNNING,
  * taskSCHEDULER_NOT_STARTED or taskSCHEDULER_SUSPENDED.
  */
-BaseType_t xTaskGetSchedulerState(void) PRIVILEGED_FUNCTION;
+BaseType_t xTaskGetSchedulerState( void ) PRIVILEGED_FUNCTION;
 
 /*
  * Raises the priority of the mutex holder to that of the calling task should
  * the mutex holder have a priority less than the calling task.
  */
-BaseType_t xTaskPriorityInherit(TaskHandle_t const pxMutexHolder) PRIVILEGED_FUNCTION;
+BaseType_t xTaskPriorityInherit( TaskHandle_t const pxMutexHolder ) PRIVILEGED_FUNCTION;
 
 /*
  * Set the priority of a task back to its proper priority in the case that it
  * inherited a higher priority while it was holding a semaphore.
  */
-BaseType_t xTaskPriorityDisinherit(TaskHandle_t const pxMutexHolder) PRIVILEGED_FUNCTION;
+BaseType_t xTaskPriorityDisinherit( TaskHandle_t const pxMutexHolder ) PRIVILEGED_FUNCTION;
 
 /*
  * If a higher priority task attempting to obtain a mutex caused a lower
@@ -3043,20 +3649,24 @@ BaseType_t xTaskPriorityDisinherit(TaskHandle_t const pxMutexHolder) PRIVILEGED_
  * the highest priority task that is still waiting for the mutex (if there were
  * more than one task waiting for the mutex).
  */
-void vTaskPriorityDisinheritAfterTimeout(TaskHandle_t const pxMutexHolder,
-        UBaseType_t uxHighestPriorityWaitingTask) PRIVILEGED_FUNCTION;
+void vTaskPriorityDisinheritAfterTimeout( TaskHandle_t const pxMutexHolder,
+                                          UBaseType_t uxHighestPriorityWaitingTask ) PRIVILEGED_FUNCTION;
 
 /*
- * Get the uxTCBNumber assigned to the task referenced by the xTask parameter.
+ * Get the uxTaskNumber assigned to the task referenced by the xTask parameter.
  */
-UBaseType_t uxTaskGetTaskNumber(TaskHandle_t xTask) PRIVILEGED_FUNCTION;
+#if ( configUSE_TRACE_FACILITY == 1 )
+    UBaseType_t uxTaskGetTaskNumber( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
+#endif
 
 /*
  * Set the uxTaskNumber of the task referenced by the xTask parameter to
  * uxHandle.
  */
-void vTaskSetTaskNumber(TaskHandle_t xTask,
-                        const UBaseType_t uxHandle) PRIVILEGED_FUNCTION;
+#if ( configUSE_TRACE_FACILITY == 1 )
+    void vTaskSetTaskNumber( TaskHandle_t xTask,
+                             const UBaseType_t uxHandle ) PRIVILEGED_FUNCTION;
+#endif
 
 /*
  * Only available when configUSE_TICKLESS_IDLE is set to 1.
@@ -3066,7 +3676,9 @@ void vTaskSetTaskNumber(TaskHandle_t xTask,
  * to date with the actual execution time by being skipped forward by a time
  * equal to the idle period.
  */
-void vTaskStepTick(const TickType_t xTicksToJump) PRIVILEGED_FUNCTION;
+#if ( configUSE_TICKLESS_IDLE != 0 )
+    void vTaskStepTick( TickType_t xTicksToJump ) PRIVILEGED_FUNCTION;
+#endif
 
 /*
  * Only available when configUSE_TICKLESS_IDLE is set to 1.
@@ -3082,22 +3694,109 @@ void vTaskStepTick(const TickType_t xTicksToJump) PRIVILEGED_FUNCTION;
  * critical section between the timer being stopped and the sleep mode being
  * entered to ensure it is ok to proceed into the sleep mode.
  */
-eSleepModeStatus eTaskConfirmSleepModeStatus(void) PRIVILEGED_FUNCTION;
+#if ( configUSE_TICKLESS_IDLE != 0 )
+    eSleepModeStatus eTaskConfirmSleepModeStatus( void ) PRIVILEGED_FUNCTION;
+#endif
 
 /*
  * For internal use only.  Increment the mutex held count when a mutex is
  * taken and return the handle of the task that has taken the mutex.
  */
-TaskHandle_t pvTaskIncrementMutexHeldCount(void) PRIVILEGED_FUNCTION;
+TaskHandle_t pvTaskIncrementMutexHeldCount( void ) PRIVILEGED_FUNCTION;
 
 /*
  * For internal use only.  Same as vTaskSetTimeOutState(), but without a critical
  * section.
  */
-void vTaskInternalSetTimeOutState(TimeOut_t * const pxTimeOut) PRIVILEGED_FUNCTION;
+void vTaskInternalSetTimeOutState( TimeOut_t * const pxTimeOut ) PRIVILEGED_FUNCTION;
+
+/*
+ * For internal use only. Same as portYIELD_WITHIN_API() in single core FreeRTOS.
+ * For SMP this is not defined by the port.
+ */
+#if ( configNUMBER_OF_CORES > 1 )
+    void vTaskYieldWithinAPI( void );
+#endif
+
+/*
+ * This function is only intended for use when implementing a port of the scheduler
+ * and is only available when portCRITICAL_NESTING_IN_TCB is set to 1 or configNUMBER_OF_CORES
+ * is greater than 1. This function can be used in the implementation of portENTER_CRITICAL
+ * if port wants to maintain critical nesting count in TCB in single core FreeRTOS.
+ * It should be used in the implementation of portENTER_CRITICAL if port is running a
+ * multiple core FreeRTOS.
+ */
+#if ( ( portCRITICAL_NESTING_IN_TCB == 1 ) || ( configNUMBER_OF_CORES > 1 ) )
+    void vTaskEnterCritical( void );
+#endif
+
+/*
+ * This function is only intended for use when implementing a port of the scheduler
+ * and is only available when portCRITICAL_NESTING_IN_TCB is set to 1 or configNUMBER_OF_CORES
+ * is greater than 1. This function can be used in the implementation of portEXIT_CRITICAL
+ * if port wants to maintain critical nesting count in TCB in single core FreeRTOS.
+ * It should be used in the implementation of portEXIT_CRITICAL if port is running a
+ * multiple core FreeRTOS.
+ */
+#if ( ( portCRITICAL_NESTING_IN_TCB == 1 ) || ( configNUMBER_OF_CORES > 1 ) )
+    void vTaskExitCritical( void );
+#endif
+
+/*
+ * This function is only intended for use when implementing a port of the scheduler
+ * and is only available when configNUMBER_OF_CORES is greater than 1. This function
+ * should be used in the implementation of portENTER_CRITICAL_FROM_ISR if port is
+ * running a multiple core FreeRTOS.
+ */
+#if ( configNUMBER_OF_CORES > 1 )
+    UBaseType_t vTaskEnterCriticalFromISR( void );
+#endif
+
+/*
+ * This function is only intended for use when implementing a port of the scheduler
+ * and is only available when configNUMBER_OF_CORES is greater than 1. This function
+ * should be used in the implementation of portEXIT_CRITICAL_FROM_ISR if port is
+ * running a multiple core FreeRTOS.
+ */
+#if ( configNUMBER_OF_CORES > 1 )
+    void vTaskExitCriticalFromISR( UBaseType_t uxSavedInterruptStatus );
+#endif
+
+#if ( portUSING_MPU_WRAPPERS == 1 )
+
+/*
+ * For internal use only.  Get MPU settings associated with a task.
+ */
+    xMPU_SETTINGS * xTaskGetMPUSettings( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
+
+#endif /* portUSING_MPU_WRAPPERS */
+
+
+#if ( ( portUSING_MPU_WRAPPERS == 1 ) && ( configUSE_MPU_WRAPPERS_V1 == 0 ) && ( configENABLE_ACCESS_CONTROL_LIST == 1 ) )
+
+/*
+ * For internal use only.  Grant/Revoke a task's access to a kernel object.
+ */
+    void vGrantAccessToKernelObject( TaskHandle_t xExternalTaskHandle,
+                                     int32_t lExternalKernelObjectHandle ) PRIVILEGED_FUNCTION;
+    void vRevokeAccessToKernelObject( TaskHandle_t xExternalTaskHandle,
+                                      int32_t lExternalKernelObjectHandle ) PRIVILEGED_FUNCTION;
+
+/*
+ * For internal use only.  Grant/Revoke a task's access to a kernel object.
+ */
+    void vPortGrantAccessToKernelObject( TaskHandle_t xInternalTaskHandle,
+                                         int32_t lInternalIndexOfKernelObject ) PRIVILEGED_FUNCTION;
+    void vPortRevokeAccessToKernelObject( TaskHandle_t xInternalTaskHandle,
+                                          int32_t lInternalIndexOfKernelObject ) PRIVILEGED_FUNCTION;
 
+#endif /* #if ( ( portUSING_MPU_WRAPPERS == 1 ) && ( configUSE_MPU_WRAPPERS_V1 == 0 ) && ( configENABLE_ACCESS_CONTROL_LIST == 1 ) ) */
 
-UBaseType_t vTaskGetStackSize(TaskHandle_t xTask);
+/* Project diagnostics used by CmBacktrace and the task status screen. */
+uint32_t * vTaskStackAddr( void );
+uint32_t vTaskStackSize( void );
+char * vTaskName( void );
+UBaseType_t vTaskGetStackSize( TaskHandle_t xTask );
 
 /* *INDENT-OFF* */
 #ifdef __cplusplus

### external/FreeRTOS/Source/include/timers.h
[binary or diff unavailable]

### external/FreeRTOS/Source/list.c
@@ -1,6 +1,6 @@
 /*
- * FreeRTOS Kernel V10.4.6
- * Copyright (C) 2021 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ * FreeRTOS Kernel V11.3.0
+ * Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -37,63 +37,83 @@
 #include "FreeRTOS.h"
 #include "list.h"
 
-/* Lint e9021, e961 and e750 are suppressed as a MISRA exception justified
- * because the MPU ports require MPU_WRAPPERS_INCLUDED_FROM_API_FILE to be
+/* The MPU ports require MPU_WRAPPERS_INCLUDED_FROM_API_FILE to be
  * defined for the header files above, but not in this file, in order to
  * generate the correct privileged Vs unprivileged linkage and placement. */
-#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE /*lint !e961 !e750 !e9021. */
+#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE
 
 /*-----------------------------------------------------------
 * PUBLIC LIST API documented in list.h
 *----------------------------------------------------------*/
 
-void vListInitialise(List_t * const pxList)
+void vListInitialise( List_t * const pxList )
 {
+    traceENTER_vListInitialise( pxList );
+
     /* The list structure contains a list item which is used to mark the
      * end of the list.  To initialise the list the list end is inserted
      * as the only list entry. */
-    pxList->pxIndex = (ListItem_t *) & (pxList->xListEnd);    /*lint !e826 !e740 !e9087 The mini list structure is used as the list end to save RAM.  This is checked and valid. */
+    pxList->pxIndex = ( ListItem_t * ) &( pxList->xListEnd );
+
+    listSET_FIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE( &( pxList->xListEnd ) );
 
     /* The list end value is the highest possible value in the list to
      * ensure it remains at the end of the list. */
     pxList->xListEnd.xItemValue = portMAX_DELAY;
 
     /* The list end next and previous pointers point to itself so we know
      * when the list is empty. */
-    pxList->xListEnd.pxNext = (ListItem_t *) & (pxList->xListEnd);        /*lint !e826 !e740 !e9087 The mini list structure is used as the list end to save RAM.  This is checked and valid. */
-    pxList->xListEnd.pxPrevious = (ListItem_t *) & (pxList->xListEnd);    /*lint !e826 !e740 !e9087 The mini list structure is used as the list end to save RAM.  This is checked and valid. */
+    pxList->xListEnd.pxNext = ( ListItem_t * ) &( pxList->xListEnd );
+    pxList->xListEnd.pxPrevious = ( ListItem_t * ) &( pxList->xListEnd );
+
+    /* Initialize the remaining fields of xListEnd when it is a proper ListItem_t */
+    #if ( configUSE_MINI_LIST_ITEM == 0 )
+    {
+        pxList->xListEnd.pvOwner = NULL;
+        pxList->xListEnd.pxContainer = NULL;
+        listSET_SECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE( &( pxList->xListEnd ) );
+    }
+    #endif
 
-    pxList->uxNumberOfItems = (UBaseType_t) 0U;
+    pxList->uxNumberOfItems = ( UBaseType_t ) 0U;
 
     /* Write known values into the list if
      * configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
-    listSET_LIST_INTEGRITY_CHECK_1_VALUE(pxList);
-    listSET_LIST_INTEGRITY_CHECK_2_VALUE(pxList);
+    listSET_LIST_INTEGRITY_CHECK_1_VALUE( pxList );
+    listSET_LIST_INTEGRITY_CHECK_2_VALUE( pxList );
+
+    traceRETURN_vListInitialise();
 }
 /*-----------------------------------------------------------*/
 
-void vListInitialiseItem(ListItem_t * const pxItem)
+void vListInitialiseItem( ListItem_t * const pxItem )
 {
+    traceENTER_vListInitialiseItem( pxItem );
+
     /* Make sure the list item is not recorded as being on a list. */
     pxItem->pxContainer = NULL;
 
     /* Write known values into the list item if
      * configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
-    listSET_FIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE(pxItem);
-    listSET_SECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE(pxItem);
+    listSET_FIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem );
+    listSET_SECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem );
+
+    traceRETURN_vListInitialiseItem();
 }
 /*-----------------------------------------------------------*/
 
-void vListInsertEnd(List_t * const pxList,
-                    ListItem_t * const pxNewListItem)
+void vListInsertEnd( List_t * const pxList,
+                     ListItem_t * const pxNewListItem )
 {
     ListItem_t * const pxIndex = pxList->pxIndex;
 
+    traceENTER_vListInsertEnd( pxList, pxNewListItem );
+
     /* Only effective when configASSERT() is also defined, these tests may catch
      * the list data structures being overwritten in memory.  They will not catch
      * data errors caused by incorrect configuration or use of FreeRTOS. */
-    listTEST_LIST_INTEGRITY(pxList);
-    listTEST_LIST_ITEM_INTEGRITY(pxNewListItem);
+    listTEST_LIST_INTEGRITY( pxList );
+    listTEST_LIST_ITEM_INTEGRITY( pxNewListItem );
 
     /* Insert a new list item into pxList, but rather than sort the list,
      * makes the new list item the last item to be removed by a call to
@@ -110,21 +130,25 @@ void vListInsertEnd(List_t * const pxList,
     /* Remember which list the item is in. */
     pxNewListItem->pxContainer = pxList;
 
-    (pxList->uxNumberOfItems)++;
+    ( pxList->uxNumberOfItems ) = ( UBaseType_t ) ( pxList->uxNumberOfItems + 1U );
+
+    traceRETURN_vListInsertEnd();
 }
 /*-----------------------------------------------------------*/
 
-void vListInsert(List_t * const pxList,
-                 ListItem_t * const pxNewListItem)
+void vListInsert( List_t * const pxList,
+                  ListItem_t * const pxNewListItem )
 {
     ListItem_t * pxIterator;
     const TickType_t xValueOfInsertion = pxNewListItem->xItemValue;
 
+    traceENTER_vListInsert( pxList, pxNewListItem );
+
     /* Only effective when configASSERT() is also defined, these tests may catch
      * the list data structures being overwritten in memory.  They will not catch
      * data errors caused by incorrect configuration or use of FreeRTOS. */
-    listTEST_LIST_INTEGRITY(pxList);
-    listTEST_LIST_ITEM_INTEGRITY(pxNewListItem);
+    listTEST_LIST_INTEGRITY( pxList );
+    listTEST_LIST_ITEM_INTEGRITY( pxNewListItem );
 
     /* Insert the new list item into the list, sorted in xItemValue order.
      *
@@ -134,12 +158,15 @@ void vListInsert(List_t * const pxList,
      * share of the CPU.  However, if the xItemValue is the same as the back marker
      * the iteration loop below will not end.  Therefore the value is checked
      * first, and the algorithm slightly modified if necessary. */
-    if (xValueOfInsertion == portMAX_DELAY) {
+    if( xValueOfInsertion == portMAX_DELAY )
+    {
         pxIterator = pxList->xListEnd.pxPrevious;
-    } else {
+    }
+    else
+    {
         /* *** NOTE ***********************************************************
         *  If you find your application is crashing here then likely causes are
-        *  listed below.  In addition see https://www.FreeRTOS.org/FAQHelp.html for
+        *  listed below.  In addition see https://www.freertos.org/Why-FreeRTOS/FAQs for
         *  more tips, and ensure configASSERT() is defined!
         *  https://www.FreeRTOS.org/a00110.html#configASSERT
         *
@@ -162,10 +189,12 @@ void vListInsert(List_t * const pxList,
         *      configMAX_SYSCALL_INTERRUPT_PRIORITY.
         **********************************************************************/
 
-        for (pxIterator = (ListItem_t *) & (pxList->xListEnd); pxIterator->pxNext->xItemValue <= xValueOfInsertion; pxIterator = pxIterator->pxNext) { /*lint !e826 !e740 !e9087 The mini list structure is used as the list end to save RAM.  This is checked and valid. */
-            /*lint !e440 The iterator moves to a different value, not xValueOfInsertion. */
+        for( pxIterator = ( ListItem_t * ) &( pxList->xListEnd ); pxIterator->pxNext->xItemValue <= xValueOfInsertion; pxIterator = pxIterator->pxNext )
+        {
             /* There is nothing to do here, just iterating to the wanted
-             * insertion position. */
+             * insertion position.
+             * IF YOU FIND YOUR CODE STUCK HERE, SEE THE NOTE JUST ABOVE.
+             */
         }
     }
 
@@ -178,31 +207,41 @@ void vListInsert(List_t * const pxList,
      * item later. */
     pxNewListItem->pxContainer = pxList;
 
-    (pxList->uxNumberOfItems)++;
+    ( pxList->uxNumberOfItems ) = ( UBaseType_t ) ( pxList->uxNumberOfItems + 1U );
+
+    traceRETURN_vListInsert();
 }
 /*-----------------------------------------------------------*/
 
-UBaseType_t uxListRemove(ListItem_t * const pxItemToRemove)
+
+UBaseType_t uxListRemove( ListItem_t * const pxItemToRemove )
 {
     /* The list item knows which list it is in.  Obtain the list from the list
      * item. */
     List_t * const pxList = pxItemToRemove->pxContainer;
 
+    traceENTER_uxListRemove( pxItemToRemove );
+
     pxItemToRemove->pxNext->pxPrevious = pxItemToRemove->pxPrevious;
     pxItemToRemove->pxPrevious->pxNext = pxItemToRemove->pxNext;
 
     /* Only used during decision coverage testing. */
     mtCOVERAGE_TEST_DELAY();
 
     /* Make sure the index is left pointing to a valid item. */
-    if (pxList->pxIndex == pxItemToRemove) {
+    if( pxList->pxIndex == pxItemToRemove )
+    {
         pxList->pxIndex = pxItemToRemove->pxPrevious;
-    } else {
+    }
+    else
+    {
         mtCOVERAGE_TEST_MARKER();
     }
 
     pxItemToRemove->pxContainer = NULL;
-    (pxList->uxNumberOfItems)--;
+    ( pxList->uxNumberOfItems ) = ( UBaseType_t ) ( pxList->uxNumberOfItems - 1U );
+
+    traceRETURN_uxListRemove( pxList->uxNumberOfItems );
 
     return pxList->uxNumberOfItems;
 }

### external/FreeRTOS/Source/portable/Common/mpu_wrappers.c
@@ -0,0 +1,2581 @@
+/*
+ * FreeRTOS Kernel V11.3.0
+ * Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ * https://github.com/FreeRTOS
+ *
+ */
+
+/*
+ * Implementation of the wrapper functions used to raise the processor privilege
+ * before calling a standard FreeRTOS API function.
+ */
+
+/* Defining MPU_WRAPPERS_INCLUDED_FROM_API_FILE prevents task.h from redefining
+ * all the API functions to use the MPU wrappers.  That should only be done when
+ * task.h is included from an application file. */
+#define MPU_WRAPPERS_INCLUDED_FROM_API_FILE
+
+/* Scheduler includes. */
+#include "FreeRTOS.h"
+#include "task.h"
+#include "queue.h"
+#include "timers.h"
+#include "event_groups.h"
+#include "stream_buffer.h"
+#include "mpu_prototypes.h"
+
+#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE
+/*-----------------------------------------------------------*/
+
+#if ( ( portUSING_MPU_WRAPPERS == 1 ) && ( configUSE_MPU_WRAPPERS_V1 == 1 ) )
+
+    #if ( configENABLE_ACCESS_CONTROL_LIST == 1 )
+        #error Access control list is not available with this MPU wrapper. Please set configENABLE_ACCESS_CONTROL_LIST to 0.
+    #endif
+
+    #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
+        BaseType_t MPU_xTaskCreate( TaskFunction_t pvTaskCode,
+                                    const char * const pcName,
+                                    const configSTACK_DEPTH_TYPE uxStackDepth,
+                                    void * pvParameters,
+                                    UBaseType_t uxPriority,
+                                    TaskHandle_t * pxCreatedTask ) /* FREERTOS_SYSTEM_CALL */
+        {
+            BaseType_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                uxPriority = uxPriority & ~( portPRIVILEGE_BIT );
+                portMEMORY_BARRIER();
+
+                xReturn = xTaskCreate( pvTaskCode, pcName, uxStackDepth, pvParameters, uxPriority, pxCreatedTask );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xTaskCreate( pvTaskCode, pcName, uxStackDepth, pvParameters, uxPriority, pxCreatedTask );
+            }
+
+            return xReturn;
+        }
+    #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
+/*-----------------------------------------------------------*/
+
+    #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
+        TaskHandle_t MPU_xTaskCreateStatic( TaskFunction_t pxTaskCode,
+                                            const char * const pcName,
+                                            const configSTACK_DEPTH_TYPE uxStackDepth,
+                                            void * const pvParameters,
+                                            UBaseType_t uxPriority,
+                                            StackType_t * const puxStackBuffer,
+                                            StaticTask_t * const pxTaskBuffer ) /* FREERTOS_SYSTEM_CALL */
+        {
+            TaskHandle_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                uxPriority = uxPriority & ~( portPRIVILEGE_BIT );
+                portMEMORY_BARRIER();
+
+                xReturn = xTaskCreateStatic( pxTaskCode, pcName, uxStackDepth, pvParameters, uxPriority, puxStackBuffer, pxTaskBuffer );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xTaskCreateStatic( pxTaskCode, pcName, uxStackDepth, pvParameters, uxPriority, puxStackBuffer, pxTaskBuffer );
+            }
+
+            return xReturn;
+        }
+    #endif /* configSUPPORT_STATIC_ALLOCATION */
+/*-----------------------------------------------------------*/
+
+    #if ( INCLUDE_vTaskDelete == 1 )
+        void MPU_vTaskDelete( TaskHandle_t pxTaskToDelete ) /* FREERTOS_SYSTEM_CALL */
+        {
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                vTaskDelete( pxTaskToDelete );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                vTaskDelete( pxTaskToDelete );
+            }
+        }
+    #endif /* if ( INCLUDE_vTaskDelete == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( INCLUDE_xTaskDelayUntil == 1 )
+        BaseType_t MPU_xTaskDelayUntil( TickType_t * const pxPreviousWakeTime,
+                                        TickType_t xTimeIncrement ) /* FREERTOS_SYSTEM_CALL */
+        {
+            BaseType_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xTaskDelayUntil( pxPreviousWakeTime, xTimeIncrement );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xTaskDelayUntil( pxPreviousWakeTime, xTimeIncrement );
+            }
+
+            return xReturn;
+        }
+    #endif /* if ( INCLUDE_xTaskDelayUntil == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( INCLUDE_xTaskAbortDelay == 1 )
+        BaseType_t MPU_xTaskAbortDelay( TaskHandle_t xTask ) /* FREERTOS_SYSTEM_CALL */
+        {
+            BaseType_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xTaskAbortDelay( xTask );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xTaskAbortDelay( xTask );
+            }
+
+            return xReturn;
+        }
+    #endif /* if ( INCLUDE_xTaskAbortDelay == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( INCLUDE_vTaskDelay == 1 )
+        void MPU_vTaskDelay( TickType_t xTicksToDelay ) /* FREERTOS_SYSTEM_CALL */
+        {
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                vTaskDelay( xTicksToDelay );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                vTaskDelay( xTicksToDelay );
+            }
+        }
+    #endif /* if ( INCLUDE_vTaskDelay == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( INCLUDE_uxTaskPriorityGet == 1 )
+        UBaseType_t MPU_uxTaskPriorityGet( const TaskHandle_t pxTask ) /* FREERTOS_SYSTEM_CALL */
+        {
+            UBaseType_t uxReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                uxReturn = uxTaskPriorityGet( pxTask );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                uxReturn = uxTaskPriorityGet( pxTask );
+            }
+
+            return uxReturn;
+        }
+    #endif /* if ( INCLUDE_uxTaskPriorityGet == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( INCLUDE_vTaskPrioritySet == 1 )
+        void MPU_vTaskPrioritySet( TaskHandle_t pxTask,
+                                   UBaseType_t uxNewPriority ) /* FREERTOS_SYSTEM_CALL */
+        {
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                vTaskPrioritySet( pxTask, uxNewPriority );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                vTaskPrioritySet( pxTask, uxNewPriority );
+            }
+        }
+    #endif /* if ( INCLUDE_vTaskPrioritySet == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( INCLUDE_eTaskGetState == 1 )
+        eTaskState MPU_eTaskGetState( TaskHandle_t pxTask ) /* FREERTOS_SYSTEM_CALL */
+        {
+            eTaskState eReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                eReturn = eTaskGetState( pxTask );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                eReturn = eTaskGetState( pxTask );
+            }
+
+            return eReturn;
+        }
+    #endif /* if ( INCLUDE_eTaskGetState == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_TRACE_FACILITY == 1 )
+        void MPU_vTaskGetInfo( TaskHandle_t xTask,
+                               TaskStatus_t * pxTaskStatus,
+                               BaseType_t xGetFreeStackSpace,
+                               eTaskState eState ) /* FREERTOS_SYSTEM_CALL */
+        {
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                vTaskGetInfo( xTask, pxTaskStatus, xGetFreeStackSpace, eState );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                vTaskGetInfo( xTask, pxTaskStatus, xGetFreeStackSpace, eState );
+            }
+        }
+    #endif /* if ( configUSE_TRACE_FACILITY == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( INCLUDE_xTaskGetIdleTaskHandle == 1 )
+        TaskHandle_t MPU_xTaskGetIdleTaskHandle( void ) /* FREERTOS_SYSTEM_CALL */
+        {
+            TaskHandle_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+                xReturn = xTaskGetIdleTaskHandle();
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xTaskGetIdleTaskHandle();
+            }
+
+            return xReturn;
+        }
+    #endif /* if ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( INCLUDE_vTaskSuspend == 1 )
+        void MPU_vTaskSuspend( TaskHandle_t pxTaskToSuspend ) /* FREERTOS_SYSTEM_CALL */
+        {
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                vTaskSuspend( pxTaskToSuspend );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                vTaskSuspend( pxTaskToSuspend );
+            }
+        }
+    #endif /* if ( INCLUDE_vTaskSuspend == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( INCLUDE_vTaskSuspend == 1 )
+        void MPU_vTaskResume( TaskHandle_t pxTaskToResume ) /* FREERTOS_SYSTEM_CALL */
+        {
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                vTaskResume( pxTaskToResume );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                vTaskResume( pxTaskToResume );
+            }
+        }
+    #endif /* if ( INCLUDE_vTaskSuspend == 1 ) */
+/*-----------------------------------------------------------*/
+
+    void MPU_vTaskSuspendAll( void ) /* FREERTOS_SYSTEM_CALL */
+    {
+        if( portIS_PRIVILEGED() == pdFALSE )
+        {
+            portRAISE_PRIVILEGE();
+            portMEMORY_BARRIER();
+
+            vTaskSuspendAll();
+            portMEMORY_BARRIER();
+
+            portRESET_PRIVILEGE();
+            portMEMORY_BARRIER();
+        }
+        else
+        {
+            vTaskSuspendAll();
+        }
+    }
+/*-----------------------------------------------------------*/
+
+    BaseType_t MPU_xTaskResumeAll( void ) /* FREERTOS_SYSTEM_CALL */
+    {
+        BaseType_t xReturn;
+
+        if( portIS_PRIVILEGED() == pdFALSE )
+        {
+            portRAISE_PRIVILEGE();
+            portMEMORY_BARRIER();
+
+            xReturn = xTaskResumeAll();
+            portMEMORY_BARRIER();
+
+            portRESET_PRIVILEGE();
+            portMEMORY_BARRIER();
+        }
+        else
+        {
+            xReturn = xTaskResumeAll();
+        }
+
+        return xReturn;
+    }
+/*-----------------------------------------------------------*/
+
+    TickType_t MPU_xTaskGetTickCount( void ) /* FREERTOS_SYSTEM_CALL */
+    {
+        TickType_t xReturn;
+
+        if( portIS_PRIVILEGED() == pdFALSE )
+        {
+            portRAISE_PRIVILEGE();
+            portMEMORY_BARRIER();
+
+            xReturn = xTaskGetTickCount();
+            portMEMORY_BARRIER();
+
+            portRESET_PRIVILEGE();
+            portMEMORY_BARRIER();
+        }
+        else
+        {
+            xReturn = xTaskGetTickCount();
+        }
+
+        return xReturn;
+    }
+/*-----------------------------------------------------------*/
+
+    UBaseType_t MPU_uxTaskGetNumberOfTasks( void ) /* FREERTOS_SYSTEM_CALL */
+    {
+        UBaseType_t uxReturn;
+
+        if( portIS_PRIVILEGED() == pdFALSE )
+        {
+            portRAISE_PRIVILEGE();
+            portMEMORY_BARRIER();
+
+            uxReturn = uxTaskGetNumberOfTasks();
+            portMEMORY_BARRIER();
+
+            portRESET_PRIVILEGE();
+            portMEMORY_BARRIER();
+        }
+        else
+        {
+            uxReturn = uxTaskGetNumberOfTasks();
+        }
+
+        return uxReturn;
+    }
+/*-----------------------------------------------------------*/
+
+    #if ( INCLUDE_xTaskGetHandle == 1 )
+        TaskHandle_t MPU_xTaskGetHandle( const char * pcNameToQuery ) /* FREERTOS_SYSTEM_CALL */
+        {
+            TaskHandle_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xTaskGetHandle( pcNameToQuery );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xTaskGetHandle( pcNameToQuery );
+            }
+
+            return xReturn;
+        }
+    #endif /* if ( INCLUDE_xTaskGetHandle == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
+        void MPU_vTaskListTasks( char * pcWriteBuffer,
+                                 size_t uxBufferLength ) /* FREERTOS_SYSTEM_CALL */
+        {
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                vTaskListTasks( pcWriteBuffer, uxBufferLength );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                vTaskListTasks( pcWriteBuffer, uxBufferLength );
+            }
+        }
+    #endif /* if ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */
+/*-----------------------------------------------------------*/
+
+    #if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
+        void MPU_vTaskGetRunTimeStatistics( char * pcWriteBuffer,
+                                            size_t uxBufferLength ) /* FREERTOS_SYSTEM_CALL */
+        {
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                vTaskGetRunTimeStatistics( pcWriteBuffer, uxBufferLength );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                vTaskGetRunTimeStatistics( pcWriteBuffer, uxBufferLength );
+            }
+        }
+    #endif /* if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */
+/*-----------------------------------------------------------*/
+
+    #if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) )
+        configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetIdleRunTimePercent( void ) /* FREERTOS_SYSTEM_CALL */
+        {
+            configRUN_TIME_COUNTER_TYPE xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = ulTaskGetIdleRunTimePercent();
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = ulTaskGetIdleRunTimePercent();
+            }
+
+            return xReturn;
+        }
+    #endif /* if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) ) */
+/*-----------------------------------------------------------*/
+
+    #if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) )
+        configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetIdleRunTimeCounter( void ) /* FREERTOS_SYSTEM_CALL */
+        {
+            configRUN_TIME_COUNTER_TYPE xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = ulTaskGetIdleRunTimeCounter();
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = ulTaskGetIdleRunTimeCounter();
+            }
+
+            return xReturn;
+        }
+    #endif /* if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_APPLICATION_TASK_TAG == 1 )
+        void MPU_vTaskSetApplicationTaskTag( TaskHandle_t xTask,
+                                             TaskHookFunction_t pxTagValue ) /* FREERTOS_SYSTEM_CALL */
+        {
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                vTaskSetApplicationTaskTag( xTask, pxTagValue );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                vTaskSetApplicationTaskTag( xTask, pxTagValue );
+            }
+        }
+    #endif /* if ( configUSE_APPLICATION_TASK_TAG == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_APPLICATION_TASK_TAG == 1 )
+        TaskHookFunction_t MPU_xTaskGetApplicationTaskTag( TaskHandle_t xTask ) /* FREERTOS_SYSTEM_CALL */
+        {
+            TaskHookFunction_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xTaskGetApplicationTaskTag( xTask );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xTaskGetApplicationTaskTag( xTask );
+            }
+
+            return xReturn;
+        }
+    #endif /* if ( configUSE_APPLICATION_TASK_TAG == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )
+        void MPU_vTaskSetThreadLocalStoragePointer( TaskHandle_t xTaskToSet,
+                                                    BaseType_t xIndex,
+                                                    void * pvValue ) /* FREERTOS_SYSTEM_CALL */
+        {
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                vTaskSetThreadLocalStoragePointer( xTaskToSet, xIndex, pvValue );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                vTaskSetThreadLocalStoragePointer( xTaskToSet, xIndex, pvValue );
+            }
+        }
+    #endif /* if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )
+        void * MPU_pvTaskGetThreadLocalStoragePointer( TaskHandle_t xTaskToQuery,
+                                                       BaseType_t xIndex ) /* FREERTOS_SYSTEM_CALL */
+        {
+            void * pvReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                pvReturn = pvTaskGetThreadLocalStoragePointer( xTaskToQuery, xIndex );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                pvReturn = pvTaskGetThreadLocalStoragePointer( xTaskToQuery, xIndex );
+            }
+
+            return pvReturn;
+        }
+    #endif /* if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_APPLICATION_TASK_TAG == 1 )
+        BaseType_t MPU_xTaskCallApplicationTaskHook( TaskHandle_t xTask,
+                                                     void * pvParameter ) /* FREERTOS_SYSTEM_CALL */
+        {
+            BaseType_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xTaskCallApplicationTaskHook( xTask, pvParameter );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xTaskCallApplicationTaskHook( xTask, pvParameter );
+            }
+
+            return xReturn;
+        }
+    #endif /* if ( configUSE_APPLICATION_TASK_TAG == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_TRACE_FACILITY == 1 )
+        UBaseType_t MPU_uxTaskGetSystemState( TaskStatus_t * pxTaskStatusArray,
+                                              UBaseType_t uxArraySize,
+                                              configRUN_TIME_COUNTER_TYPE * pulTotalRunTime ) /* FREERTOS_SYSTEM_CALL */
+        {
+            UBaseType_t uxReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                uxReturn = uxTaskGetSystemState( pxTaskStatusArray, uxArraySize, pulTotalRunTime );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                uxReturn = uxTaskGetSystemState( pxTaskStatusArray, uxArraySize, pulTotalRunTime );
+            }
+
+            return uxReturn;
+        }
+    #endif /* if ( configUSE_TRACE_FACILITY == 1 ) */
+/*-----------------------------------------------------------*/
+
+    BaseType_t MPU_xTaskCatchUpTicks( TickType_t xTicksToCatchUp ) /* FREERTOS_SYSTEM_CALL */
+    {
+        BaseType_t xReturn;
+
+        if( portIS_PRIVILEGED() == pdFALSE )
+        {
+            portRAISE_PRIVILEGE();
+            portMEMORY_BARRIER();
+
+            xReturn = xTaskCatchUpTicks( xTicksToCatchUp );
+            portMEMORY_BARRIER();
+
+            portRESET_PRIVILEGE();
+            portMEMORY_BARRIER();
+        }
+        else
+        {
+            xReturn = xTaskCatchUpTicks( xTicksToCatchUp );
+        }
+
+        return xReturn;
+    }
+/*-----------------------------------------------------------*/
+
+    #if ( INCLUDE_uxTaskGetStackHighWaterMark == 1 )
+        UBaseType_t MPU_uxTaskGetStackHighWaterMark( TaskHandle_t xTask ) /* FREERTOS_SYSTEM_CALL */
+        {
+            UBaseType_t uxReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                uxReturn = uxTaskGetStackHighWaterMark( xTask );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                uxReturn = uxTaskGetStackHighWaterMark( xTask );
+            }
+
+            return uxReturn;
+        }
+    #endif /* if ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 )
+        configSTACK_DEPTH_TYPE MPU_uxTaskGetStackHighWaterMark2( TaskHandle_t xTask ) /* FREERTOS_SYSTEM_CALL */
+        {
+            configSTACK_DEPTH_TYPE uxReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                uxReturn = uxTaskGetStackHighWaterMark2( xTask );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                uxReturn = uxTaskGetStackHighWaterMark2( xTask );
+            }
+
+            return uxReturn;
+        }
+    #endif /* if ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( ( INCLUDE_xTaskGetCurrentTaskHandle == 1 ) || ( configUSE_RECURSIVE_MUTEXES == 1 ) )
+        TaskHandle_t MPU_xTaskGetCurrentTaskHandle( void ) /* FREERTOS_SYSTEM_CALL */
+        {
+            TaskHandle_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+                xReturn = xTaskGetCurrentTaskHandle();
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xTaskGetCurrentTaskHandle();
+            }
+
+            return xReturn;
+        }
+    #endif /* if ( ( INCLUDE_xTaskGetCurrentTaskHandle == 1 ) || ( configUSE_RECURSIVE_MUTEXES == 1 ) ) */
+/*-----------------------------------------------------------*/
+
+    #if ( INCLUDE_xTaskGetSchedulerState == 1 )
+        BaseType_t MPU_xTaskGetSchedulerState( void ) /* FREERTOS_SYSTEM_CALL */
+        {
+            BaseType_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xTaskGetSchedulerState();
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xTaskGetSchedulerState();
+            }
+
+            return xReturn;
+        }
+    #endif /* if ( INCLUDE_xTaskGetSchedulerState == 1 ) */
+/*-----------------------------------------------------------*/
+
+    void MPU_vTaskSetTimeOutState( TimeOut_t * const pxTimeOut ) /* FREERTOS_SYSTEM_CALL */
+    {
+        if( portIS_PRIVILEGED() == pdFALSE )
+        {
+            portRAISE_PRIVILEGE();
+            portMEMORY_BARRIER();
+
+            vTaskSetTimeOutState( pxTimeOut );
+            portMEMORY_BARRIER();
+
+            portRESET_PRIVILEGE();
+            portMEMORY_BARRIER();
+        }
+        else
+        {
+            vTaskSetTimeOutState( pxTimeOut );
+        }
+    }
+/*-----------------------------------------------------------*/
+
+    BaseType_t MPU_xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut,
+                                         TickType_t * const pxTicksToWait ) /* FREERTOS_SYSTEM_CALL */
+    {
+        BaseType_t xReturn;
+
+        if( portIS_PRIVILEGED() == pdFALSE )
+        {
+            portRAISE_PRIVILEGE();
+            portMEMORY_BARRIER();
+
+            xReturn = xTaskCheckForTimeOut( pxTimeOut, pxTicksToWait );
+            portMEMORY_BARRIER();
+
+            portRESET_PRIVILEGE();
+            portMEMORY_BARRIER();
+        }
+        else
+        {
+            xReturn = xTaskCheckForTimeOut( pxTimeOut, pxTicksToWait );
+        }
+
+        return xReturn;
+    }
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_TASK_NOTIFICATIONS == 1 )
+        BaseType_t MPU_xTaskGenericNotify( TaskHandle_t xTaskToNotify,
+                                           UBaseType_t uxIndexToNotify,
+                                           uint32_t ulValue,
+                                           eNotifyAction eAction,
+                                           uint32_t * pulPreviousNotificationValue ) /* FREERTOS_SYSTEM_CALL */
+        {
+            BaseType_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xTaskGenericNotify( xTaskToNotify, uxIndexToNotify, ulValue, eAction, pulPreviousNotificationValue );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xTaskGenericNotify( xTaskToNotify, uxIndexToNotify, ulValue, eAction, pulPreviousNotificationValue );
+            }
+
+            return xReturn;
+        }
+    #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_TASK_NOTIFICATIONS == 1 )
+        BaseType_t MPU_xTaskGenericNotifyWait( UBaseType_t uxIndexToWaitOn,
+                                               uint32_t ulBitsToClearOnEntry,
+                                               uint32_t ulBitsToClearOnExit,
+                                               uint32_t * pulNotificationValue,
+                                               TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
+        {
+            BaseType_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xTaskGenericNotifyWait( uxIndexToWaitOn, ulBitsToClearOnEntry, ulBitsToClearOnExit, pulNotificationValue, xTicksToWait );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xTaskGenericNotifyWait( uxIndexToWaitOn, ulBitsToClearOnEntry, ulBitsToClearOnExit, pulNotificationValue, xTicksToWait );
+            }
+
+            return xReturn;
+        }
+    #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_TASK_NOTIFICATIONS == 1 )
+        uint32_t MPU_ulTaskGenericNotifyTake( UBaseType_t uxIndexToWaitOn,
+                                              BaseType_t xClearCountOnExit,
+                                              TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
+        {
+            uint32_t ulReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                ulReturn = ulTaskGenericNotifyTake( uxIndexToWaitOn, xClearCountOnExit, xTicksToWait );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                ulReturn = ulTaskGenericNotifyTake( uxIndexToWaitOn, xClearCountOnExit, xTicksToWait );
+            }
+
+            return ulReturn;
+        }
+    #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_TASK_NOTIFICATIONS == 1 )
+        BaseType_t MPU_xTaskGenericNotifyStateClear( TaskHandle_t xTask,
+                                                     UBaseType_t uxIndexToClear ) /* FREERTOS_SYSTEM_CALL */
+        {
+            BaseType_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xTaskGenericNotifyStateClear( xTask, uxIndexToClear );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xTaskGenericNotifyStateClear( xTask, uxIndexToClear );
+            }
+
+            return xReturn;
+        }
+    #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_TASK_NOTIFICATIONS == 1 )
+        uint32_t MPU_ulTaskGenericNotifyValueClear( TaskHandle_t xTask,
+                                                    UBaseType_t uxIndexToClear,
+                                                    uint32_t ulBitsToClear ) /* FREERTOS_SYSTEM_CALL */
+        {
+            uint32_t ulReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                ulReturn = ulTaskGenericNotifyValueClear( xTask, uxIndexToClear, ulBitsToClear );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                ulReturn = ulTaskGenericNotifyValueClear( xTask, uxIndexToClear, ulBitsToClear );
+            }
+
+            return ulReturn;
+        }
+    #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
+        QueueHandle_t MPU_xQueueGenericCreate( UBaseType_t uxQueueLength,
+                                               UBaseType_t uxItemSize,
+                                               uint8_t ucQueueType ) /* FREERTOS_SYSTEM_CALL */
+        {
+            QueueHandle_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xQueueGenericCreate( uxQueueLength, uxItemSize, ucQueueType );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xQueueGenericCreate( uxQueueLength, uxItemSize, ucQueueType );
+            }
+
+            return xReturn;
+        }
+    #endif /* if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
+        QueueHandle_t MPU_xQueueGenericCreateStatic( const UBaseType_t uxQueueLength,
+                                                     const UBaseType_t uxItemSize,
+                                                     uint8_t * pucQueueStorage,
+                                                     StaticQueue_t * pxStaticQueue,
+                                                     const uint8_t ucQueueType ) /* FREERTOS_SYSTEM_CALL */
+        {
+            QueueHandle_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xQueueGenericCreateStatic( uxQueueLength, uxItemSize, pucQueueStorage, pxStaticQueue, ucQueueType );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xQueueGenericCreateStatic( uxQueueLength, uxItemSize, pucQueueStorage, pxStaticQueue, ucQueueType );
+            }
+
+            return xReturn;
+        }
+    #endif /* if ( configSUPPORT_STATIC_ALLOCATION == 1 ) */
+/*-----------------------------------------------------------*/
+
+    BaseType_t MPU_xQueueGenericReset( QueueHandle_t pxQueue,
+                                       BaseType_t xNewQueue ) /* FREERTOS_SYSTEM_CALL */
+    {
+        BaseType_t xReturn;
+
+        if( portIS_PRIVILEGED() == pdFALSE )
+        {
+            portRAISE_PRIVILEGE();
+            portMEMORY_BARRIER();
+
+            xReturn = xQueueGenericReset( pxQueue, xNewQueue );
+            portMEMORY_BARRIER();
+
+            portRESET_PRIVILEGE();
+            portMEMORY_BARRIER();
+        }
+        else
+        {
+            xReturn = xQueueGenericReset( pxQueue, xNewQueue );
+        }
+
+        return xReturn;
+    }
+/*-----------------------------------------------------------*/
+
+    BaseType_t MPU_xQueueGenericSend( QueueHandle_t xQueue,
+                                      const void * const pvItemToQueue,
+                                      TickType_t xTicksToWait,
+                                      BaseType_t xCopyPosition ) /* FREERTOS_SYSTEM_CALL */
+    {
+        BaseType_t xReturn;
+
+        if( portIS_PRIVILEGED() == pdFALSE )
+        {
+            portRAISE_PRIVILEGE();
+            portMEMORY_BARRIER();
+
+            xReturn = xQueueGenericSend( xQueue, pvItemToQueue, xTicksToWait, xCopyPosition );
+            portMEMORY_BARRIER();
+
+            portRESET_PRIVILEGE();
+            portMEMORY_BARRIER();
+        }
+        else
+        {
+            xReturn = xQueueGenericSend( xQueue, pvItemToQueue, xTicksToWait, xCopyPosition );
+        }
+
+        return xReturn;
+    }
+/*-----------------------------------------------------------*/
+
+    UBaseType_t MPU_uxQueueMessagesWaiting( const QueueHandle_t pxQueue ) /* FREERTOS_SYSTEM_CALL */
+    {
+        UBaseType_t uxReturn;
+
+        if( portIS_PRIVILEGED() == pdFALSE )
+        {
+            portRAISE_PRIVILEGE();
+            portMEMORY_BARRIER();
+
+            uxReturn = uxQueueMessagesWaiting( pxQueue );
+            portMEMORY_BARRIER();
+
+            portRESET_PRIVILEGE();
+            portMEMORY_BARRIER();
+        }
+        else
+        {
+            uxReturn = uxQueueMessagesWaiting( pxQueue );
+        }
+
+        return uxReturn;
+    }
+/*-----------------------------------------------------------*/
+
+    UBaseType_t MPU_uxQueueSpacesAvailable( const QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
+    {
+        UBaseType_t uxReturn;
+
+        if( portIS_PRIVILEGED() == pdFALSE )
+        {
+            portRAISE_PRIVILEGE();
+            portMEMORY_BARRIER();
+
+            uxReturn = uxQueueSpacesAvailable( xQueue );
+            portMEMORY_BARRIER();
+
+            portRESET_PRIVILEGE();
+            portMEMORY_BARRIER();
+        }
+        else
+        {
+            uxReturn = uxQueueSpacesAvailable( xQueue );
+        }
+
+        return uxReturn;
+    }
+/*-----------------------------------------------------------*/
+
+    BaseType_t MPU_xQueueReceive( QueueHandle_t pxQueue,
+                                  void * const pvBuffer,
+                                  TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
+    {
+        BaseType_t xReturn;
+
+        if( portIS_PRIVILEGED() == pdFALSE )
+        {
+            portRAISE_PRIVILEGE();
+            portMEMORY_BARRIER();
+
+            xReturn = xQueueReceive( pxQueue, pvBuffer, xTicksToWait );
+            portMEMORY_BARRIER();
+
+            portRESET_PRIVILEGE();
+            portMEMORY_BARRIER();
+        }
+        else
+        {
+            xReturn = xQueueReceive( pxQueue, pvBuffer, xTicksToWait );
+        }
+
+        return xReturn;
+    }
+/*-----------------------------------------------------------*/
+
+    BaseType_t MPU_xQueuePeek( QueueHandle_t xQueue,
+                               void * const pvBuffer,
+                               TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
+    {
+        BaseType_t xReturn;
+
+        if( portIS_PRIVILEGED() == pdFALSE )
+        {
+            portRAISE_PRIVILEGE();
+            portMEMORY_BARRIER();
+
+            xReturn = xQueuePeek( xQueue, pvBuffer, xTicksToWait );
+            portMEMORY_BARRIER();
+
+            portRESET_PRIVILEGE();
+            portMEMORY_BARRIER();
+        }
+        else
+        {
+            xReturn = xQueuePeek( xQueue, pvBuffer, xTicksToWait );
+        }
+
+        return xReturn;
+    }
+/*-----------------------------------------------------------*/
+
+    BaseType_t MPU_xQueueSemaphoreTake( QueueHandle_t xQueue,
+                                        TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
+    {
+        BaseType_t xReturn;
+
+        if( portIS_PRIVILEGED() == pdFALSE )
+        {
+            portRAISE_PRIVILEGE();
+            portMEMORY_BARRIER();
+
+            xReturn = xQueueSemaphoreTake( xQueue, xTicksToWait );
+            portMEMORY_BARRIER();
+
+            portRESET_PRIVILEGE();
+            portMEMORY_BARRIER();
+        }
+        else
+        {
+            xReturn = xQueueSemaphoreTake( xQueue, xTicksToWait );
+        }
+
+        return xReturn;
+    }
+/*-----------------------------------------------------------*/
+
+    #if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) )
+        TaskHandle_t MPU_xQueueGetMutexHolder( QueueHandle_t xSemaphore ) /* FREERTOS_SYSTEM_CALL */
+        {
+            void * xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xQueueGetMutexHolder( xSemaphore );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xQueueGetMutexHolder( xSemaphore );
+            }
+
+            return xReturn;
+        }
+    #endif /* if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) ) */
+/*-----------------------------------------------------------*/
+
+    #if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
+        QueueHandle_t MPU_xQueueCreateMutex( const uint8_t ucQueueType ) /* FREERTOS_SYSTEM_CALL */
+        {
+            QueueHandle_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xQueueCreateMutex( ucQueueType );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xQueueCreateMutex( ucQueueType );
+            }
+
+            return xReturn;
+        }
+    #endif /* if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */
+/*-----------------------------------------------------------*/
+
+    #if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
+        QueueHandle_t MPU_xQueueCreateMutexStatic( const uint8_t ucQueueType,
+                                                   StaticQueue_t * pxStaticQueue ) /* FREERTOS_SYSTEM_CALL */
+        {
+            QueueHandle_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xQueueCreateMutexStatic( ucQueueType, pxStaticQueue );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xQueueCreateMutexStatic( ucQueueType, pxStaticQueue );
+            }
+
+            return xReturn;
+        }
+    #endif /* if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) ) */
+/*-----------------------------------------------------------*/
+
+    #if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
+        QueueHandle_t MPU_xQueueCreateCountingSemaphore( UBaseType_t uxCountValue,
+                                                         UBaseType_t uxInitialCount ) /* FREERTOS_SYSTEM_CALL */
+        {
+            QueueHandle_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xQueueCreateCountingSemaphore( uxCountValue, uxInitialCount );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xQueueCreateCountingSemaphore( uxCountValue, uxInitialCount );
+            }
+
+            return xReturn;
+        }
+    #endif /* if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */
+/*-----------------------------------------------------------*/
+
+    #if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
+
+        QueueHandle_t MPU_xQueueCreateCountingSemaphoreStatic( const UBaseType_t uxMaxCount,
+                                                               const UBaseType_t uxInitialCount,
+                                                               StaticQueue_t * pxStaticQueue ) /* FREERTOS_SYSTEM_CALL */
+        {
+            QueueHandle_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xQueueCreateCountingSemaphoreStatic( uxMaxCount, uxInitialCount, pxStaticQueue );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xQueueCreateCountingSemaphoreStatic( uxMaxCount, uxInitialCount, pxStaticQueue );
+            }
+
+            return xReturn;
+        }
+    #endif /* if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_RECURSIVE_MUTEXES == 1 )
+        BaseType_t MPU_xQueueTakeMutexRecursive( QueueHandle_t xMutex,
+                                                 TickType_t xBlockTime ) /* FREERTOS_SYSTEM_CALL */
+        {
+            BaseType_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xQueueTakeMutexRecursive( xMutex, xBlockTime );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xQueueTakeMutexRecursive( xMutex, xBlockTime );
+            }
+
+            return xReturn;
+        }
+    #endif /* if ( configUSE_RECURSIVE_MUTEXES == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_RECURSIVE_MUTEXES == 1 )
+        BaseType_t MPU_xQueueGiveMutexRecursive( QueueHandle_t xMutex ) /* FREERTOS_SYSTEM_CALL */
+        {
+            BaseType_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xQueueGiveMutexRecursive( xMutex );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xQueueGiveMutexRecursive( xMutex );
+            }
+
+            return xReturn;
+        }
+    #endif /* if ( configUSE_RECURSIVE_MUTEXES == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( ( configUSE_QUEUE_SETS == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
+        QueueSetHandle_t MPU_xQueueCreateSet( UBaseType_t uxEventQueueLength ) /* FREERTOS_SYSTEM_CALL */
+        {
+            QueueSetHandle_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xQueueCreateSet( uxEventQueueLength );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xQueueCreateSet( uxEventQueueLength );
+            }
+
+            return xReturn;
+        }
+    #endif /* if ( ( configUSE_QUEUE_SETS == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */
+/*-----------------------------------------------------------*/
+
+    #if ( ( configUSE_QUEUE_SETS == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
+        QueueSetHandle_t MPU_xQueueCreateSetStatic( const UBaseType_t uxEventQueueLength,
+                                                    uint8_t * pucQueueStorage,
+                                                    StaticQueue_t * pxStaticQueue ) /* FREERTOS_SYSTEM_CALL */
+        {
+            QueueSetHandle_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xQueueCreateSetStatic( uxEventQueueLength, pucQueueStorage, pxStaticQueue );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xQueueCreateSetStatic( uxEventQueueLength, pucQueueStorage, pxStaticQueue );
+            }
+
+            return xReturn;
+        }
+    #endif /* if ( ( configUSE_QUEUE_SETS == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_QUEUE_SETS == 1 )
+        QueueSetMemberHandle_t MPU_xQueueSelectFromSet( QueueSetHandle_t xQueueSet,
+                                                        TickType_t xBlockTimeTicks ) /* FREERTOS_SYSTEM_CALL */
+        {
+            QueueSetMemberHandle_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xQueueSelectFromSet( xQueueSet, xBlockTimeTicks );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xQueueSelectFromSet( xQueueSet, xBlockTimeTicks );
+            }
+
+            return xReturn;
+        }
+    #endif /* if ( configUSE_QUEUE_SETS == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_QUEUE_SETS == 1 )
+        BaseType_t MPU_xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore,
+                                       QueueSetHandle_t xQueueSet ) /* FREERTOS_SYSTEM_CALL */
+        {
+            BaseType_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xQueueAddToSet( xQueueOrSemaphore, xQueueSet );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xQueueAddToSet( xQueueOrSemaphore, xQueueSet );
+            }
+
+            return xReturn;
+        }
+    #endif /* if ( configUSE_QUEUE_SETS == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_QUEUE_SETS == 1 )
+        BaseType_t MPU_xQueueRemoveFromSet( QueueSetMemberHandle_t xQueueOrSemaphore,
+                                            QueueSetHandle_t xQueueSet ) /* FREERTOS_SYSTEM_CALL */
+        {
+            BaseType_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xQueueRemoveFromSet( xQueueOrSemaphore, xQueueSet );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xQueueRemoveFromSet( xQueueOrSemaphore, xQueueSet );
+            }
+
+            return xReturn;
+        }
+    #endif /* if ( configUSE_QUEUE_SETS == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if configQUEUE_REGISTRY_SIZE > 0
+        void MPU_vQueueAddToRegistry( QueueHandle_t xQueue,
+                                      const char * pcName ) /* FREERTOS_SYSTEM_CALL */
+        {
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                vQueueAddToRegistry( xQueue, pcName );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                vQueueAddToRegistry( xQueue, pcName );
+            }
+        }
+    #endif /* if configQUEUE_REGISTRY_SIZE > 0 */
+/*-----------------------------------------------------------*/
+
+    #if configQUEUE_REGISTRY_SIZE > 0
+        void MPU_vQueueUnregisterQueue( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
+        {
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                vQueueUnregisterQueue( xQueue );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                vQueueUnregisterQueue( xQueue );
+            }
+        }
+    #endif /* if configQUEUE_REGISTRY_SIZE > 0 */
+/*-----------------------------------------------------------*/
+
+    #if configQUEUE_REGISTRY_SIZE > 0
+        const char * MPU_pcQueueGetName( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
+        {
+            const char * pcReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                pcReturn = pcQueueGetName( xQueue );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                pcReturn = pcQueueGetName( xQueue );
+            }
+
+            return pcReturn;
+        }
+    #endif /* if configQUEUE_REGISTRY_SIZE > 0 */
+/*-----------------------------------------------------------*/
+
+    void MPU_vQueueDelete( QueueHandle_t xQueue ) /* FREERTOS_SYSTEM_CALL */
+    {
+        if( portIS_PRIVILEGED() == pdFALSE )
+        {
+            portRAISE_PRIVILEGE();
+            portMEMORY_BARRIER();
+
+            vQueueDelete( xQueue );
+            portMEMORY_BARRIER();
+
+            portRESET_PRIVILEGE();
+            portMEMORY_BARRIER();
+        }
+        else
+        {
+            vQueueDelete( xQueue );
+        }
+    }
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_TIMERS == 1 )
+        void * MPU_pvTimerGetTimerID( const TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */
+        {
+            void * pvReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                pvReturn = pvTimerGetTimerID( xTimer );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                pvReturn = pvTimerGetTimerID( xTimer );
+            }
+
+            return pvReturn;
+        }
+    #endif /* if ( configUSE_TIMERS == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_TIMERS == 1 )
+        void MPU_vTimerSetTimerID( TimerHandle_t xTimer,
+                                   void * pvNewID ) /* FREERTOS_SYSTEM_CALL */
+        {
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                vTimerSetTimerID( xTimer, pvNewID );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                vTimerSetTimerID( xTimer, pvNewID );
+            }
+        }
+    #endif /* if ( configUSE_TIMERS == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_TIMERS == 1 )
+        BaseType_t MPU_xTimerIsTimerActive( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */
+        {
+            BaseType_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xTimerIsTimerActive( xTimer );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xTimerIsTimerActive( xTimer );
+            }
+
+            return xReturn;
+        }
+    #endif /* if ( configUSE_TIMERS == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_TIMERS == 1 )
+        TaskHandle_t MPU_xTimerGetTimerDaemonTaskHandle( void ) /* FREERTOS_SYSTEM_CALL */
+        {
+            TaskHandle_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xTimerGetTimerDaemonTaskHandle();
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xTimerGetTimerDaemonTaskHandle();
+            }
+
+            return xReturn;
+        }
+    #endif /* if ( configUSE_TIMERS == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_TIMERS == 1 )
+        void MPU_vTimerSetReloadMode( TimerHandle_t xTimer,
+                                      const BaseType_t xAutoReload ) /* FREERTOS_SYSTEM_CALL */
+        {
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                vTimerSetReloadMode( xTimer, xAutoReload );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                vTimerSetReloadMode( xTimer, xAutoReload );
+            }
+        }
+    #endif /* if ( configUSE_TIMERS == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_TIMERS == 1 )
+        UBaseType_t MPU_uxTimerGetReloadMode( TimerHandle_t xTimer )
+        {
+            UBaseType_t uxReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                uxReturn = uxTimerGetReloadMode( xTimer );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                uxReturn = uxTimerGetReloadMode( xTimer );
+            }
+
+            return uxReturn;
+        }
+    #endif /* if ( configUSE_TIMERS == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_TIMERS == 1 )
+        const char * MPU_pcTimerGetName( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */
+        {
+            const char * pcReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                pcReturn = pcTimerGetName( xTimer );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                pcReturn = pcTimerGetName( xTimer );
+            }
+
+            return pcReturn;
+        }
+    #endif /* if ( configUSE_TIMERS == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_TIMERS == 1 )
+        TickType_t MPU_xTimerGetPeriod( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */
+        {
+            TickType_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xTimerGetPeriod( xTimer );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xTimerGetPeriod( xTimer );
+            }
+
+            return xReturn;
+        }
+    #endif /* if ( configUSE_TIMERS == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_TIMERS == 1 )
+        TickType_t MPU_xTimerGetExpiryTime( TimerHandle_t xTimer ) /* FREERTOS_SYSTEM_CALL */
+        {
+            TickType_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xTimerGetExpiryTime( xTimer );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xTimerGetExpiryTime( xTimer );
+            }
+
+            return xReturn;
+        }
+    #endif /* if ( configUSE_TIMERS == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_TIMERS == 1 )
+        BaseType_t MPU_xTimerGenericCommandFromTask( TimerHandle_t xTimer,
+                                                     const BaseType_t xCommandID,
+                                                     const TickType_t xOptionalValue,
+                                                     BaseType_t * const pxHigherPriorityTaskWoken,
+                                                     const TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
+        {
+            BaseType_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xTimerGenericCommandFromTask( xTimer, xCommandID, xOptionalValue, pxHigherPriorityTaskWoken, xTicksToWait );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xTimerGenericCommandFromTask( xTimer, xCommandID, xOptionalValue, pxHigherPriorityTaskWoken, xTicksToWait );
+            }
+
+            return xReturn;
+        }
+    #endif /* if ( configUSE_TIMERS == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configUSE_EVENT_GROUPS == 1 ) )
+        EventGroupHandle_t MPU_xEventGroupCreate( void ) /* FREERTOS_SYSTEM_CALL */
+        {
+            EventGroupHandle_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xEventGroupCreate();
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xEventGroupCreate();
+            }
+
+            return xReturn;
+        }
+    #endif /* #if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configUSE_EVENT_GROUPS == 1 ) ) */
+/*-----------------------------------------------------------*/
+
+    #if ( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_EVENT_GROUPS == 1 ) )
+        EventGroupHandle_t MPU_xEventGroupCreateStatic( StaticEventGroup_t * pxEventGroupBuffer ) /* FREERTOS_SYSTEM_CALL */
+        {
+            EventGroupHandle_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xEventGroupCreateStatic( pxEventGroupBuffer );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xEventGroupCreateStatic( pxEventGroupBuffer );
+            }
+
+            return xReturn;
+        }
+    #endif /* #if ( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_EVENT_GROUPS == 1 ) ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_EVENT_GROUPS == 1 )
+        EventBits_t MPU_xEventGroupWaitBits( EventGroupHandle_t xEventGroup,
+                                             const EventBits_t uxBitsToWaitFor,
+                                             const BaseType_t xClearOnExit,
+                                             const BaseType_t xWaitForAllBits,
+                                             TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
+        {
+            EventBits_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xEventGroupWaitBits( xEventGroup, uxBitsToWaitFor, xClearOnExit, xWaitForAllBits, xTicksToWait );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xEventGroupWaitBits( xEventGroup, uxBitsToWaitFor, xClearOnExit, xWaitForAllBits, xTicksToWait );
+            }
+
+            return xReturn;
+        }
+    #endif /* #if ( configUSE_EVENT_GROUPS == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_EVENT_GROUPS == 1 )
+        EventBits_t MPU_xEventGroupClearBits( EventGroupHandle_t xEventGroup,
+                                              const EventBits_t uxBitsToClear ) /* FREERTOS_SYSTEM_CALL */
+        {
+            EventBits_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xEventGroupClearBits( xEventGroup, uxBitsToClear );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xEventGroupClearBits( xEventGroup, uxBitsToClear );
+            }
+
+            return xReturn;
+        }
+    #endif /* #if ( configUSE_EVENT_GROUPS == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_EVENT_GROUPS == 1 )
+        EventBits_t MPU_xEventGroupSetBits( EventGroupHandle_t xEventGroup,
+                                            const EventBits_t uxBitsToSet ) /* FREERTOS_SYSTEM_CALL */
+        {
+            EventBits_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xEventGroupSetBits( xEventGroup, uxBitsToSet );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xEventGroupSetBits( xEventGroup, uxBitsToSet );
+            }
+
+            return xReturn;
+        }
+    #endif /* #if ( configUSE_EVENT_GROUPS == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_EVENT_GROUPS == 1 )
+        EventBits_t MPU_xEventGroupSync( EventGroupHandle_t xEventGroup,
+                                         const EventBits_t uxBitsToSet,
+                                         const EventBits_t uxBitsToWaitFor,
+                                         TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
+        {
+            EventBits_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xEventGroupSync( xEventGroup, uxBitsToSet, uxBitsToWaitFor, xTicksToWait );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xEventGroupSync( xEventGroup, uxBitsToSet, uxBitsToWaitFor, xTicksToWait );
+            }
+
+            return xReturn;
+        }
+    #endif /* #if ( configUSE_EVENT_GROUPS == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_EVENT_GROUPS == 1 )
+        void MPU_vEventGroupDelete( EventGroupHandle_t xEventGroup ) /* FREERTOS_SYSTEM_CALL */
+        {
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                vEventGroupDelete( xEventGroup );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                vEventGroupDelete( xEventGroup );
+            }
+        }
+    #endif /* #if ( configUSE_EVENT_GROUPS == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_STREAM_BUFFERS == 1 )
+        size_t MPU_xStreamBufferSend( StreamBufferHandle_t xStreamBuffer,
+                                      const void * pvTxData,
+                                      size_t xDataLengthBytes,
+                                      TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
+        {
+            size_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xStreamBufferSend( xStreamBuffer, pvTxData, xDataLengthBytes, xTicksToWait );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xStreamBufferSend( xStreamBuffer, pvTxData, xDataLengthBytes, xTicksToWait );
+            }
+
+            return xReturn;
+        }
+    #endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_STREAM_BUFFERS == 1 )
+        size_t MPU_xStreamBufferNextMessageLengthBytes( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
+        {
+            size_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xStreamBufferNextMessageLengthBytes( xStreamBuffer );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xStreamBufferNextMessageLengthBytes( xStreamBuffer );
+            }
+
+            return xReturn;
+        }
+    #endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_STREAM_BUFFERS == 1 )
+        size_t MPU_xStreamBufferReceive( StreamBufferHandle_t xStreamBuffer,
+                                         void * pvRxData,
+                                         size_t xBufferLengthBytes,
+                                         TickType_t xTicksToWait ) /* FREERTOS_SYSTEM_CALL */
+        {
+            size_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xStreamBufferReceive( xStreamBuffer, pvRxData, xBufferLengthBytes, xTicksToWait );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xStreamBufferReceive( xStreamBuffer, pvRxData, xBufferLengthBytes, xTicksToWait );
+            }
+
+            return xReturn;
+        }
+    #endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_STREAM_BUFFERS == 1 )
+        void MPU_vStreamBufferDelete( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
+        {
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                vStreamBufferDelete( xStreamBuffer );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                vStreamBufferDelete( xStreamBuffer );
+            }
+        }
+    #endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_STREAM_BUFFERS == 1 )
+        BaseType_t MPU_xStreamBufferIsFull( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
+        {
+            BaseType_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xStreamBufferIsFull( xStreamBuffer );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xStreamBufferIsFull( xStreamBuffer );
+            }
+
+            return xReturn;
+        }
+    #endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_STREAM_BUFFERS == 1 )
+        BaseType_t MPU_xStreamBufferIsEmpty( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
+        {
+            BaseType_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xStreamBufferIsEmpty( xStreamBuffer );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xStreamBufferIsEmpty( xStreamBuffer );
+            }
+
+            return xReturn;
+        }
+    #endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_STREAM_BUFFERS == 1 )
+        BaseType_t MPU_xStreamBufferReset( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
+        {
+            BaseType_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xStreamBufferReset( xStreamBuffer );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xStreamBufferReset( xStreamBuffer );
+            }
+
+            return xReturn;
+        }
+    #endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_STREAM_BUFFERS == 1 )
+        size_t MPU_xStreamBufferSpacesAvailable( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
+        {
+            size_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+                xReturn = xStreamBufferSpacesAvailable( xStreamBuffer );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xStreamBufferSpacesAvailable( xStreamBuffer );
+            }
+
+            return xReturn;
+        }
+    #endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_STREAM_BUFFERS == 1 )
+        size_t MPU_xStreamBufferBytesAvailable( StreamBufferHandle_t xStreamBuffer ) /* FREERTOS_SYSTEM_CALL */
+        {
+            size_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xStreamBufferBytesAvailable( xStreamBuffer );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xStreamBufferBytesAvailable( xStreamBuffer );
+            }
+
+            return xReturn;
+        }
+    #endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( configUSE_STREAM_BUFFERS == 1 )
+        BaseType_t MPU_xStreamBufferSetTriggerLevel( StreamBufferHandle_t xStreamBuffer,
+                                                     size_t xTriggerLevel ) /* FREERTOS_SYSTEM_CALL */
+        {
+            BaseType_t xReturn;
+
+            if( portIS_PRIVILEGED() == pdFALSE )
+            {
+                portRAISE_PRIVILEGE();
+                portMEMORY_BARRIER();
+
+                xReturn = xStreamBufferSetTriggerLevel( xStreamBuffer, xTriggerLevel );
+                portMEMORY_BARRIER();
+
+                portRESET_PRIVILEGE();
+                portMEMORY_BARRIER();
+            }
+            else
+            {
+                xReturn = xStreamBufferSetTriggerLevel( xStreamBuffer, xTriggerLevel );
+            }
+
+            return xReturn;
+        }
+    #endif /* #if ( configUSE_STREAM_BUFFERS == 1 ) */
+/*-----------------------------------------------------------*/
+
+    #if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configUSE_STREAM_BUFFERS == 1 ) )
+        StreamBufferHandle_t MPU_xStreamBufferGenericCreate( size_t xBufferSizeBytes,
+                                                             size_t xTriggerLevelBytes,
+                                                             BaseType_t xStreamBufferType,
+                                                             StreamBufferCallbackFunction_t pxSendCompletedCallback,
+                                                             StreamBufferCallbackFunction_t pxReceiveCompletedCallback ) /* FREERTOS_SYSTEM_CALL */
+        {
+            StreamBufferHandle_t xReturn;
+
+            /**
+             * Stream buffer application level callback functionality is disabled for MPU
+             * enabled ports.
+             */
+            configASSERT( ( pxSendCompletedCallback == NULL ) &&
+                          ( pxReceiveCompletedCallback == NULL ) );
+
+            if( ( pxSendCompletedCallback == NULL ) &&
+                ( pxReceiveCompletedCallback == NULL ) )
+            {
+                if( portIS_PRIVILEGED() == pdFALSE )
+                {
+                    portRAISE_PRIVILEGE();
+                    portMEMORY_BARRIER();
+
+                    xReturn = xStreamBufferGenericCreate( xBufferSizeBytes,
+                                                          xTriggerLevelBytes,
+                                                          xStreamBufferType,
+                                                          NULL,
+                                                          NULL );
+                    portMEMORY_BARRIER();
+
+                    portRESET_PRIVILEGE();
+                    portMEMORY_BARRIER();
+                }
+                else
+                {
+                    xReturn = xStreamBufferGenericCreate( xBufferSizeBytes,
+                                                          xTriggerLevelBytes,
+                                                          xStreamBufferType,
+                                                          NULL,
+                                                          NULL );
+                }
+            }
+            else
+            {
+                traceSTREAM_BUFFER_CREATE_FAILED( xStreamBufferType );
+                xReturn = NULL;
+            }
+
+            return xReturn;
+        }
+    #endif /* #if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configUSE_STREAM_BUFFERS == 1 ) ) */
+/*-----------------------------------------------------------*/
+
+    #if ( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_STREAM_BUFFERS == 1 ) )
+        StreamBufferHandle_t MPU_xStreamBufferGenericCreateStatic( size_t xBufferSizeBytes,
+                                                                   size_t xTriggerLevelBytes,
+                                                                   BaseType_t xStreamBufferType,
+                                                                   uint8_t * const pucStreamBufferStorageArea,
+                                                                   StaticStreamBuffer_t * const pxStaticStreamBuffer,
+                                                                   StreamBufferCallbackFunction_t pxSendCompletedCallback,
+                                                                   StreamBufferCallbackFunction_t pxReceiveCompletedCallback ) /* FREERTOS_SYSTEM_CALL */
+        {
+            StreamBufferHandle_t xReturn;
+
+            /**
+             * Stream buffer application level callback functionality is disabled for MPU
+             * enabled ports.
+             */
+            configASSERT( ( pxSendCompletedCallback == NULL ) &&
+                          ( pxReceiveCompletedCallback == NULL ) );
+
+            if( ( pxSendCompletedCallback == NULL ) &&
+                ( pxReceiveCompletedCallback == NULL ) )
+            {
+                if( portIS_PRIVILEGED() == pdFALSE )
+                {
+                    portRAISE_PRIVILEGE();
+                    portMEMORY_BARRIER();
+
+                    xReturn = xStreamBufferGenericCreateStatic( xBufferSizeBytes,
+                                                                xTriggerLevelBytes,
+                                                                xStreamBufferType,
+                                                                pucStreamBufferStorageArea,
+                                                                pxStaticStreamBuffer,
+                                                                NULL,
+                                                                NULL );
+                    portMEMORY_BARRIER();
+
+                    portRESET_PRIVILEGE();
+                    portMEMORY_BARRIER();
+                }
+                else
+                {
+                    xReturn = xStreamBufferGenericCreateStatic( xBufferSizeBytes,
+                                                                xTriggerLevelBytes,
+                                                                xStreamBufferType,
+                                                                pucStreamBufferStorageArea,
+                                                                pxStaticStreamBuffer,
+                                                                NULL,
+                                                                NULL );
+                }
+            }
+            else
+            {
+                traceSTREAM_BUFFER_CREATE_STATIC_FAILED( xReturn, xStreamBufferType );
+                xReturn = NULL;
+            }
+
+            return xReturn;
+        }
+    #endif /* #if ( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_STREAM_BUFFERS == 1 ) ) */
+/*-----------------------------------------------------------*/
+
+
+/* Functions that the application writer wants to execute in privileged mode
+ * can be defined in application_defined_privileged_functions.h.  The functions
+ * must take the same format as those above whereby the privilege state on exit
+ * equals the privilege state on entry.  For example:
+ *
+ * void MPU_FunctionName( [parameters ] ) FREERTOS_SYSTEM_CALL;
+ * void MPU_FunctionName( [parameters ] )
+ * {
+ *      if( portIS_PRIVILEGED() == pdFALSE )
+ *      {
+ *          portRAISE_PRIVILEGE();
+ *          portMEMORY_BARRIER();
+ *
+ *          FunctionName( [parameters ] );
+ *          portMEMORY_BARRIER();
+ *
+ *          portRESET_PRIVILEGE();
+ *          portMEMORY_BARRIER();
+ *      }
+ *      else
+ *      {
+ *          FunctionName( [parameters ] );
+ *      }
+ * }
+ */
+
+    #if configINCLUDE_APPLICATION_DEFINED_PRIVILEGED_FUNCTIONS == 1
+        #include "application_defined_privileged_functions.h"
+    #endif
+/*-----------------------------------------------------------*/
+
+#endif /* #if ( ( portUSING_MPU_WRAPPERS == 1 ) && ( configUSE_MPU_WRAPPERS_V1 == 1 ) ) */
+/*-----------------------------------------------------------*/

### external/FreeRTOS/Source/portable/Common/mpu_wrappers_v2.c
[binary or diff unavailable]

### external/FreeRTOS/Source/portable/GCC/ARM_CM4F/port.c
@@ -1,6 +1,6 @@
 /*
- * FreeRTOS Kernel V10.4.6
- * Copyright (C) 2021 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ * FreeRTOS Kernel V11.3.0
+ * Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -34,31 +34,26 @@
 #include "FreeRTOS.h"
 #include "task.h"
 
-#ifndef __VFP_FP__
-#error This port can only be used when the project options are configured to enable hardware floating point support.
+#ifndef __ARM_FP
+    #error This port can only be used when the project options are configured to enable hardware floating point support.
 #endif
 
-#ifndef configSYSTICK_CLOCK_HZ
-#define configSYSTICK_CLOCK_HZ      configCPU_CLOCK_HZ
-/* Ensure the SysTick is clocked at the same frequency as the core. */
-#define portNVIC_SYSTICK_CLK_BIT    ( 1UL << 2UL )
-#else
-
-/* The way the SysTick is clocked is not modified in case it is not the same
- * as the core. */
-#define portNVIC_SYSTICK_CLK_BIT    ( 0 )
-#endif
+/* Prototype of all Interrupt Service Routines (ISRs). */
+typedef void ( * portISR_t )( void );
 
 /* Constants required to manipulate the core.  Registers first... */
 #define portNVIC_SYSTICK_CTRL_REG             ( *( ( volatile uint32_t * ) 0xe000e010 ) )
 #define portNVIC_SYSTICK_LOAD_REG             ( *( ( volatile uint32_t * ) 0xe000e014 ) )
 #define portNVIC_SYSTICK_CURRENT_VALUE_REG    ( *( ( volatile uint32_t * ) 0xe000e018 ) )
+#define portNVIC_SHPR2_REG                    ( *( ( volatile uint32_t * ) 0xe000ed1c ) )
 #define portNVIC_SHPR3_REG                    ( *( ( volatile uint32_t * ) 0xe000ed20 ) )
 /* ...then bits in the registers. */
+#define portNVIC_SYSTICK_CLK_BIT              ( 1UL << 2UL )
 #define portNVIC_SYSTICK_INT_BIT              ( 1UL << 1UL )
 #define portNVIC_SYSTICK_ENABLE_BIT           ( 1UL << 0UL )
 #define portNVIC_SYSTICK_COUNT_FLAG_BIT       ( 1UL << 16UL )
 #define portNVIC_PENDSVCLEAR_BIT              ( 1UL << 27UL )
+#define portNVIC_PEND_SYSTICK_SET_BIT         ( 1UL << 26UL )
 #define portNVIC_PEND_SYSTICK_CLEAR_BIT       ( 1UL << 25UL )
 
 /* Constants used to detect a Cortex-M7 r0p1 core, which should use the ARM_CM7
@@ -67,8 +62,14 @@
 #define portCORTEX_M7_r0p1_ID                 ( 0x410FC271UL )
 #define portCORTEX_M7_r0p0_ID                 ( 0x410FC270UL )
 
-#define portNVIC_PENDSV_PRI                   ( ( ( uint32_t ) configKERNEL_INTERRUPT_PRIORITY ) << 16UL )
-#define portNVIC_SYSTICK_PRI                  ( ( ( uint32_t ) configKERNEL_INTERRUPT_PRIORITY ) << 24UL )
+#define portMIN_INTERRUPT_PRIORITY            ( 255UL )
+#define portNVIC_PENDSV_PRI                   ( ( ( uint32_t ) portMIN_INTERRUPT_PRIORITY ) << 16UL )
+#define portNVIC_SYSTICK_PRI                  ( ( ( uint32_t ) portMIN_INTERRUPT_PRIORITY ) << 24UL )
+
+/* Constants used to check the installation of the FreeRTOS interrupt handlers. */
+#define portSCB_VTOR_REG                      ( *( ( portISR_t ** ) 0xE000ED08 ) )
+#define portVECTOR_INDEX_SVC                  ( 11 )
+#define portVECTOR_INDEX_PENDSV               ( 14 )
 
 /* Constants required to check the validity of an interrupt priority. */
 #define portFIRST_USER_INTERRUPT_NUMBER       ( 16 )
@@ -101,45 +102,57 @@
 /* A fiddle factor to estimate the number of SysTick counts that would have
  * occurred while the SysTick counter is stopped during tickless idle
  * calculations. */
-#define portMISSED_COUNTS_FACTOR              ( 45UL )
+#define portMISSED_COUNTS_FACTOR              ( 94UL )
+
+/* Let the user override the default SysTick clock rate.  If defined by the
+ * user, this symbol must equal the SysTick clock rate when the CLK bit is 0 in the
+ * configuration register. */
+#ifndef configSYSTICK_CLOCK_HZ
+    #define configSYSTICK_CLOCK_HZ             ( configCPU_CLOCK_HZ )
+    /* Ensure the SysTick is clocked at the same frequency as the core. */
+    #define portNVIC_SYSTICK_CLK_BIT_CONFIG    ( portNVIC_SYSTICK_CLK_BIT )
+#else
+    /* Select the option to clock SysTick not at the same frequency as the core. */
+    #define portNVIC_SYSTICK_CLK_BIT_CONFIG    ( 0 )
+#endif
 
 /* Let the user override the pre-loading of the initial LR with the address of
  * prvTaskExitError() in case it messes up unwinding of the stack in the
  * debugger. */
 #ifdef configTASK_RETURN_ADDRESS
-#define portTASK_RETURN_ADDRESS    configTASK_RETURN_ADDRESS
+    #define portTASK_RETURN_ADDRESS    configTASK_RETURN_ADDRESS
 #else
-#define portTASK_RETURN_ADDRESS    prvTaskExitError
+    #define portTASK_RETURN_ADDRESS    prvTaskExitError
 #endif
 
 /*
  * Setup the timer to generate the tick interrupts.  The implementation in this
  * file is weak to allow application writers to change the timer used to
  * generate the tick interrupt.
  */
-void vPortSetupTimerInterrupt(void);
+void vPortSetupTimerInterrupt( void );
 
 /*
  * Exception handlers.
  */
-void xPortPendSVHandler(void) __attribute__((naked));
-void xPortSysTickHandler(void);
-void vPortSVCHandler(void) __attribute__((naked));
+void xPortPendSVHandler( void ) __attribute__( ( naked ) );
+void xPortSysTickHandler( void );
+void vPortSVCHandler( void ) __attribute__( ( naked ) );
 
 /*
  * Start first task is a separate function so it can be tested in isolation.
  */
-static void prvPortStartFirstTask(void) __attribute__((naked));
+static void prvPortStartFirstTask( void ) __attribute__( ( naked ) );
 
 /*
  * Function to enable the VFP.
  */
-static void vPortEnableVFP(void) __attribute__((naked));
+static void vPortEnableVFP( void ) __attribute__( ( naked ) );
 
 /*
  * Used to catch tasks that attempt to return from their implementing function.
  */
-static void prvTaskExitError(void);
+static void prvTaskExitError( void );
 
 /*-----------------------------------------------------------*/
 
@@ -151,23 +164,23 @@ static UBaseType_t uxCriticalNesting = 0xaaaaaaaa;
  * The number of SysTick increments that make up one tick period.
  */
 #if ( configUSE_TICKLESS_IDLE == 1 )
-static uint32_t ulTimerCountsForOneTick = 0;
+    static uint32_t ulTimerCountsForOneTick = 0;
 #endif /* configUSE_TICKLESS_IDLE */
 
 /*
  * The maximum number of tick periods that can be suppressed is limited by the
  * 24 bit resolution of the SysTick timer.
  */
 #if ( configUSE_TICKLESS_IDLE == 1 )
-static uint32_t xMaximumPossibleSuppressedTicks = 0;
+    static uint32_t xMaximumPossibleSuppressedTicks = 0;
 #endif /* configUSE_TICKLESS_IDLE */
 
 /*
  * Compensate for the CPU cycles that pass while the SysTick is stopped (low
  * power functionality only.
  */
 #if ( configUSE_TICKLESS_IDLE == 1 )
-static uint32_t ulStoppedTimerCompensation = 0;
+    static uint32_t ulStoppedTimerCompensation = 0;
 #endif /* configUSE_TICKLESS_IDLE */
 
 /*
@@ -176,19 +189,19 @@ static uint32_t ulStoppedTimerCompensation = 0;
  * a priority above configMAX_SYSCALL_INTERRUPT_PRIORITY.
  */
 #if ( configASSERT_DEFINED == 1 )
-static uint8_t ucMaxSysCallPriority = 0;
-static uint32_t ulMaxPRIGROUPValue = 0;
-static const volatile uint8_t * const pcInterruptPriorityRegisters = (const volatile uint8_t * const) portNVIC_IP_REGISTERS_OFFSET_16;
+    static uint8_t ucMaxSysCallPriority = 0;
+    static uint32_t ulMaxPRIGROUPValue = 0;
+    static const volatile uint8_t * const pcInterruptPriorityRegisters = ( const volatile uint8_t * const ) portNVIC_IP_REGISTERS_OFFSET_16;
 #endif /* configASSERT_DEFINED */
 
 /*-----------------------------------------------------------*/
 
 /*
  * See header file for description.
  */
-StackType_t * pxPortInitialiseStack(StackType_t * pxTopOfStack,
-                                    TaskFunction_t pxCode,
-                                    void * pvParameters)
+StackType_t * pxPortInitialiseStack( StackType_t * pxTopOfStack,
+                                     TaskFunction_t pxCode,
+                                     void * pvParameters )
 {
     /* Simulate the stack frame as it would be created by a context switch
      * interrupt. */
@@ -199,13 +212,13 @@ StackType_t * pxPortInitialiseStack(StackType_t * pxTopOfStack,
 
     *pxTopOfStack = portINITIAL_XPSR;                                    /* xPSR */
     pxTopOfStack--;
-    *pxTopOfStack = ((StackType_t) pxCode) & portSTART_ADDRESS_MASK;     /* PC */
+    *pxTopOfStack = ( ( StackType_t ) pxCode ) & portSTART_ADDRESS_MASK; /* PC */
     pxTopOfStack--;
-    *pxTopOfStack = (StackType_t) portTASK_RETURN_ADDRESS;               /* LR */
+    *pxTopOfStack = ( StackType_t ) portTASK_RETURN_ADDRESS;             /* LR */
 
     /* Save code space by skipping register initialisation. */
     pxTopOfStack -= 5;                            /* R12, R3, R2 and R1. */
-    *pxTopOfStack = (StackType_t) pvParameters;   /* R0 */
+    *pxTopOfStack = ( StackType_t ) pvParameters; /* R0 */
 
     /* A save method is being used that requires each task to maintain its
      * own exec return value. */
@@ -218,7 +231,7 @@ StackType_t * pxPortInitialiseStack(StackType_t * pxTopOfStack,
 }
 /*-----------------------------------------------------------*/
 
-static void prvTaskExitError(void)
+static void prvTaskExitError( void )
 {
     volatile uint32_t ulDummy = 0;
 
@@ -228,10 +241,11 @@ static void prvTaskExitError(void)
      *
      * Artificially force an assert() to be triggered if configASSERT() is
      * defined, then stop here so application writers can catch the error. */
-    configASSERT(uxCriticalNesting == ~0UL);
+    configASSERT( uxCriticalNesting == ~0UL );
     portDISABLE_INTERRUPTS();
 
-    while (ulDummy == 0) {
+    while( ulDummy == 0 )
+    {
         /* This file calls prvTaskExitError() after the scheduler has been
          * started to remove a compiler warning about the function being defined
          * but never called.  ulDummy is used purely to quieten other warnings
@@ -243,68 +257,98 @@ static void prvTaskExitError(void)
 }
 /*-----------------------------------------------------------*/
 
-void vPortSVCHandler(void)
+void vPortSVCHandler( void )
 {
-    __asm volatile(
-        "	ldr	r3, pxCurrentTCBConst2		\n"/* Restore the context. */
-        "	ldr r1, [r3]					\n"/* Use pxCurrentTCBConst to get the pxCurrentTCB address. */
-        "	ldr r0, [r1]					\n"/* The first item in pxCurrentTCB is the task top of stack. */
-        "	ldmia r0!, {r4-r11, r14}		\n"/* Pop the registers that are not automatically saved on exception entry and the critical nesting count. */
-        "	msr psp, r0						\n"/* Restore the task stack pointer. */
-        "	isb								\n"
-        "	mov r0, #0 						\n"
-        "	msr	basepri, r0					\n"
-        "	bx r14							\n"
-        "									\n"
-        "	.align 4						\n"
-        "pxCurrentTCBConst2: .word pxCurrentTCB				\n"
-    );
+    __asm volatile (
+        "   ldr r3, =pxCurrentTCB           \n" /* Restore the context. */
+        "   ldr r1, [r3]                    \n" /* Get the pxCurrentTCB address. */
+        "   ldr r0, [r1]                    \n" /* The first item in pxCurrentTCB is the task top of stack. */
+        "   ldmia r0!, {r4-r11, r14}        \n" /* Pop the registers that are not automatically saved on exception entry and the critical nesting count. */
+        "   msr psp, r0                     \n" /* Restore the task stack pointer. */
+        "   isb                             \n"
+        "   mov r0, #0                      \n"
+        "   msr basepri, r0                 \n"
+        "   bx r14                          \n"
+        "                                   \n"
+        "   .ltorg                          \n"
+        );
 }
 /*-----------------------------------------------------------*/
 
-static void prvPortStartFirstTask(void)
+static void prvPortStartFirstTask( void )
 {
     /* Start the first task.  This also clears the bit that indicates the FPU is
      * in use in case the FPU was used before the scheduler was started - which
      * would otherwise result in the unnecessary leaving of space in the SVC stack
      * for lazy saving of FPU registers. */
-    __asm volatile(
-        " ldr r0, =0xE000ED08 	\n"/* Use the NVIC offset register to locate the stack. */
-        " ldr r0, [r0] 			\n"
-        " ldr r0, [r0] 			\n"
-        " msr msp, r0			\n"/* Set the msp back to the start of the stack. */
-        " mov r0, #0			\n"/* Clear the bit that indicates the FPU is in use, see comment above. */
-        " msr control, r0		\n"
-        " cpsie i				\n"/* Globally enable interrupts. */
-        " cpsie f				\n"
-        " dsb					\n"
-        " isb					\n"
-        " svc 0					\n"/* System call to start first task. */
-        " nop					\n"
-        " .ltorg				\n"
-    );
+    __asm volatile (
+        " ldr r0, =0xE000ED08   \n" /* Use the NVIC offset register to locate the stack. */
+        " ldr r0, [r0]          \n"
+        " ldr r0, [r0]          \n"
+        " msr msp, r0           \n" /* Set the msp back to the start of the stack. */
+        " mov r0, #0            \n" /* Clear the bit that indicates the FPU is in use, see comment above. */
+        " msr control, r0       \n"
+        " cpsie i               \n" /* Globally enable interrupts. */
+        " cpsie f               \n"
+        " dsb                   \n"
+        " isb                   \n"
+        " svc 0                 \n" /* System call to start first task. */
+        " nop                   \n"
+        " .ltorg                \n"
+        );
 }
 /*-----------------------------------------------------------*/
 
 /*
  * See header file for description.
  */
-BaseType_t xPortStartScheduler(void)
+BaseType_t xPortStartScheduler( void )
 {
-    /* configMAX_SYSCALL_INTERRUPT_PRIORITY must not be set to 0.
-     * See https://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html */
-    configASSERT(configMAX_SYSCALL_INTERRUPT_PRIORITY);
-
     /* This port can be used on all revisions of the Cortex-M7 core other than
      * the r0p1 parts.  r0p1 parts should use the port from the
      * /source/portable/GCC/ARM_CM7/r0p1 directory. */
-    configASSERT(portCPUID != portCORTEX_M7_r0p1_ID);
-    configASSERT(portCPUID != portCORTEX_M7_r0p0_ID);
+    configASSERT( portCPUID != portCORTEX_M7_r0p1_ID );
+    configASSERT( portCPUID != portCORTEX_M7_r0p0_ID );
+
+    /* An application can install FreeRTOS interrupt handlers in one of the
+     * following ways:
+     * 1. Direct Routing - Install the functions vPortSVCHandler and
+     *    xPortPendSVHandler for SVCall and PendSV interrupts respectively.
+     * 2. Indirect Routing - Install separate handlers for SVCall and PendSV
+     *    interrupts and route program control from those handlers to
+     *    vPortSVCHandler and xPortPendSVHandler functions.
+     *
+     * Applications that use Indirect Routing must set
+     * configCHECK_HANDLER_INSTALLATION to 0 in their FreeRTOSConfig.h. Direct
+     * routing, which is validated here when configCHECK_HANDLER_INSTALLATION
+     * is 1, should be preferred when possible. */
+    #if ( configCHECK_HANDLER_INSTALLATION == 1 )
+    {
+        const portISR_t * const pxVectorTable = portSCB_VTOR_REG;
 
-#if ( configASSERT_DEFINED == 1 )
+        /* Validate that the application has correctly installed the FreeRTOS
+         * handlers for SVCall and PendSV interrupts. We do not check the
+         * installation of the SysTick handler because the application may
+         * choose to drive the RTOS tick using a timer other than the SysTick
+         * timer by overriding the weak function vPortSetupTimerInterrupt().
+         *
+         * Assertion failures here indicate incorrect installation of the
+         * FreeRTOS handlers. For help installing the FreeRTOS handlers, see
+         * https://www.freertos.org/Why-FreeRTOS/FAQs.
+         *
+         * Systems with a configurable address for the interrupt vector table
+         * can also encounter assertion failures or even system faults here if
+         * VTOR is not set correctly to point to the application's vector table. */
+        configASSERT( pxVectorTable[ portVECTOR_INDEX_SVC ] == vPortSVCHandler );
+        configASSERT( pxVectorTable[ portVECTOR_INDEX_PENDSV ] == xPortPendSVHandler );
+    }
+    #endif /* configCHECK_HANDLER_INSTALLATION */
+
+    #if ( configASSERT_DEFINED == 1 )
     {
-        volatile uint32_t ulOriginalPriority;
-        volatile uint8_t * const pucFirstUserPriorityRegister = (volatile uint8_t * const)(portNVIC_IP_REGISTERS_OFFSET_16 + portFIRST_USER_INTERRUPT_NUMBER);
+        volatile uint8_t ucOriginalPriority;
+        volatile uint32_t ulImplementedPrioBits = 0;
+        volatile uint8_t * const pucFirstUserPriorityRegister = ( volatile uint8_t * const ) ( portNVIC_IP_REGISTERS_OFFSET_16 + portFIRST_USER_INTERRUPT_NUMBER );
         volatile uint8_t ucMaxPriorityValue;
 
         /* Determine the maximum priority from which ISR safe FreeRTOS API
@@ -313,7 +357,7 @@ BaseType_t xPortStartScheduler(void)
          * ensure interrupt entry is as fast and simple as possible.
          *
          * Save the interrupt priority value that is about to be clobbered. */
-        ulOriginalPriority = *pucFirstUserPriorityRegister;
+        ucOriginalPriority = *pucFirstUserPriorityRegister;
 
         /* Determine the number of priority bits available.  First write to all
          * possible bits. */
@@ -325,32 +369,53 @@ BaseType_t xPortStartScheduler(void)
         /* Use the same mask on the maximum system call priority. */
         ucMaxSysCallPriority = configMAX_SYSCALL_INTERRUPT_PRIORITY & ucMaxPriorityValue;
 
+        /* Check that the maximum system call priority is nonzero after
+         * accounting for the number of priority bits supported by the
+         * hardware. A priority of 0 is invalid because setting the BASEPRI
+         * register to 0 unmasks all interrupts, and interrupts with priority 0
+         * cannot be masked using BASEPRI.
+         * See https://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html */
+        configASSERT( ucMaxSysCallPriority );
+
+        /* Check that the bits not implemented in hardware are zero in
+         * configMAX_SYSCALL_INTERRUPT_PRIORITY. */
+        configASSERT( ( configMAX_SYSCALL_INTERRUPT_PRIORITY & ( ~ucMaxPriorityValue ) ) == 0U );
+
         /* Calculate the maximum acceptable priority group value for the number
          * of bits read back. */
-        ulMaxPRIGROUPValue = portMAX_PRIGROUP_BITS;
 
-        while ((ucMaxPriorityValue & portTOP_BIT_OF_BYTE) == portTOP_BIT_OF_BYTE) {
-            ulMaxPRIGROUPValue--;
-            ucMaxPriorityValue <<= (uint8_t) 0x01;
+        while( ( ucMaxPriorityValue & portTOP_BIT_OF_BYTE ) == portTOP_BIT_OF_BYTE )
+        {
+            ulImplementedPrioBits++;
+            ucMaxPriorityValue <<= ( uint8_t ) 0x01;
         }
 
-#ifdef __NVIC_PRIO_BITS
+        if( ulImplementedPrioBits == 8 )
         {
-            /* Check the CMSIS configuration that defines the number of
-             * priority bits matches the number of priority bits actually queried
-             * from the hardware. */
-            configASSERT((portMAX_PRIGROUP_BITS - ulMaxPRIGROUPValue) == __NVIC_PRIO_BITS);
+            /* When the hardware implements 8 priority bits, there is no way for
+             * the software to configure PRIGROUP to not have sub-priorities. As
+             * a result, the least significant bit is always used for sub-priority
+             * and there are 128 preemption priorities and 2 sub-priorities.
+             *
+             * This may cause some confusion in some cases - for example, if
+             * configMAX_SYSCALL_INTERRUPT_PRIORITY is set to 5, both 5 and 4
+             * priority interrupts will be masked in Critical Sections as those
+             * are at the same preemption priority. This may appear confusing as
+             * 4 is higher (numerically lower) priority than
+             * configMAX_SYSCALL_INTERRUPT_PRIORITY and therefore, should not
+             * have been masked. Instead, if we set configMAX_SYSCALL_INTERRUPT_PRIORITY
+             * to 4, this confusion does not happen and the behaviour remains the same.
+             *
+             * The following assert ensures that the sub-priority bit in the
+             * configMAX_SYSCALL_INTERRUPT_PRIORITY is clear to avoid the above mentioned
+             * confusion. */
+            configASSERT( ( configMAX_SYSCALL_INTERRUPT_PRIORITY & 0x1U ) == 0U );
+            ulMaxPRIGROUPValue = 0;
         }
-#endif
-
-#ifdef configPRIO_BITS
+        else
         {
-            /* Check the FreeRTOS configuration that defines the number of
-             * priority bits matches the number of priority bits actually queried
-             * from the hardware. */
-            configASSERT((portMAX_PRIGROUP_BITS - ulMaxPRIGROUPValue) == configPRIO_BITS);
+            ulMaxPRIGROUPValue = portMAX_PRIGROUP_BITS - ulImplementedPrioBits;
         }
-#endif
 
         /* Shift the priority group value back to its position within the AIRCR
          * register. */
@@ -359,13 +424,15 @@ BaseType_t xPortStartScheduler(void)
 
         /* Restore the clobbered interrupt priority register to its original
          * value. */
-        *pucFirstUserPriorityRegister = ulOriginalPriority;
+        *pucFirstUserPriorityRegister = ucOriginalPriority;
     }
-#endif /* configASSERT_DEFINED */
+    #endif /* configASSERT_DEFINED */
 
-    /* Make PendSV and SysTick the lowest priority interrupts. */
+    /* Make PendSV and SysTick the lowest priority interrupts, and make SVCall
+     * the highest priority. */
     portNVIC_SHPR3_REG |= portNVIC_PENDSV_PRI;
     portNVIC_SHPR3_REG |= portNVIC_SYSTICK_PRI;
+    portNVIC_SHPR2_REG = 0;
 
     /* Start the timer that generates the tick ISR.  Interrupts are disabled
      * here already. */
@@ -378,7 +445,7 @@ BaseType_t xPortStartScheduler(void)
     vPortEnableVFP();
 
     /* Lazy save always. */
-    *(portFPCCR) |= portASPEN_AND_LSPEN_BITS;
+    *( portFPCCR ) |= portASPEN_AND_LSPEN_BITS;
 
     /* Start the first task. */
     prvPortStartFirstTask();
@@ -397,15 +464,15 @@ BaseType_t xPortStartScheduler(void)
 }
 /*-----------------------------------------------------------*/
 
-void vPortEndScheduler(void)
+void vPortEndScheduler( void )
 {
     /* Not implemented in ports where there is nothing to return to.
      * Artificially force an assert. */
-    configASSERT(uxCriticalNesting == 1000UL);
+    configASSERT( uxCriticalNesting == 1000UL );
 }
 /*-----------------------------------------------------------*/
 
-void vPortEnterCritical(void)
+void vPortEnterCritical( void )
 {
     portDISABLE_INTERRUPTS();
     uxCriticalNesting++;
@@ -415,255 +482,325 @@ void vPortEnterCritical(void)
      * functions that end in "FromISR" can be used in an interrupt.  Only assert if
      * the critical nesting count is 1 to protect against recursive calls if the
      * assert function also uses a critical section. */
-    if (uxCriticalNesting == 1) {
-        configASSERT((portNVIC_INT_CTRL_REG & portVECTACTIVE_MASK) == 0);
+    if( uxCriticalNesting == 1 )
+    {
+        configASSERT( ( portNVIC_INT_CTRL_REG & portVECTACTIVE_MASK ) == 0 );
     }
 }
 /*-----------------------------------------------------------*/
 
-void vPortExitCritical(void)
+void vPortExitCritical( void )
 {
-    configASSERT(uxCriticalNesting);
+    configASSERT( uxCriticalNesting );
     uxCriticalNesting--;
 
-    if (uxCriticalNesting == 0) {
+    if( uxCriticalNesting == 0 )
+    {
         portENABLE_INTERRUPTS();
     }
 }
 /*-----------------------------------------------------------*/
 
-void xPortPendSVHandler(void)
+void xPortPendSVHandler( void )
 {
     /* This is a naked function. */
 
     __asm volatile
     (
-        "	mrs r0, psp							\n"
-        "	isb									\n"
-        "										\n"
-        "	ldr	r3, pxCurrentTCBConst			\n"/* Get the location of the current TCB. */
-        "	ldr	r2, [r3]						\n"
-        "										\n"
-        "	tst r14, #0x10						\n"/* Is the task using the FPU context?  If so, push high vfp registers. */
-        "	it eq								\n"
-        "	vstmdbeq r0!, {s16-s31}				\n"
-        "										\n"
-        "	stmdb r0!, {r4-r11, r14}			\n"/* Save the core registers. */
-        "	str r0, [r2]						\n"/* Save the new top of stack into the first member of the TCB. */
-        "										\n"
-        "	stmdb sp!, {r0, r3}					\n"
-        "	mov r0, %0 							\n"
-        "	msr basepri, r0						\n"
-        "	dsb									\n"
-        "	isb									\n"
-        "	bl vTaskSwitchContext				\n"
-        "	mov r0, #0							\n"
-        "	msr basepri, r0						\n"
-        "	ldmia sp!, {r0, r3}					\n"
-        "										\n"
-        "	ldr r1, [r3]						\n"/* The first item in pxCurrentTCB is the task top of stack. */
-        "	ldr r0, [r1]						\n"
-        "										\n"
-        "	ldmia r0!, {r4-r11, r14}			\n"/* Pop the core registers. */
-        "										\n"
-        "	tst r14, #0x10						\n"/* Is the task using the FPU context?  If so, pop the high vfp registers too. */
-        "	it eq								\n"
-        "	vldmiaeq r0!, {s16-s31}				\n"
-        "										\n"
-        "	msr psp, r0							\n"
-        "	isb									\n"
-        "										\n"
-#ifdef WORKAROUND_PMU_CM001 /* XMC4000 specific errata workaround. */
-#if WORKAROUND_PMU_CM001 == 1
-        "			push { r14 }				\n"
-        "			pop { pc }					\n"
-#endif
-#endif
-        "										\n"
-        "	bx r14								\n"
-        "										\n"
-        "	.align 4							\n"
-        "pxCurrentTCBConst: .word pxCurrentTCB	\n"
-        ::"i"(configMAX_SYSCALL_INTERRUPT_PRIORITY)
+        "   mrs r0, psp                         \n"
+        "   isb                                 \n"
+        "                                       \n"
+        "   ldr r3, =pxCurrentTCB               \n" /* Get the location of the current TCB. */
+        "   ldr r2, [r3]                        \n"
+        "                                       \n"
+        "   tst r14, #0x10                      \n" /* Is the task using the FPU context?  If so, push high vfp registers. */
+        "   it eq                               \n"
+        "   vstmdbeq r0!, {s16-s31}             \n"
+        "                                       \n"
+        "   stmdb r0!, {r4-r11, r14}            \n" /* Save the core registers. */
+        "   str r0, [r2]                        \n" /* Save the new top of stack into the first member of the TCB. */
+        "                                       \n"
+        "   stmdb sp!, {r0, r3}                 \n"
+        "   mov r0, %0                          \n"
+        "   msr basepri, r0                     \n"
+        "   dsb                                 \n"
+        "   isb                                 \n"
+        "   bl vTaskSwitchContext               \n"
+        "   mov r0, #0                          \n"
+        "   msr basepri, r0                     \n"
+        "   ldmia sp!, {r0, r3}                 \n"
+        "                                       \n"
+        "   ldr r1, [r3]                        \n" /* The first item in pxCurrentTCB is the task top of stack. */
+        "   ldr r0, [r1]                        \n"
+        "                                       \n"
+        "   ldmia r0!, {r4-r11, r14}            \n" /* Pop the core registers. */
+        "                                       \n"
+        "   tst r14, #0x10                      \n" /* Is the task using the FPU context?  If so, pop the high vfp registers too. */
+        "   it eq                               \n"
+        "   vldmiaeq r0!, {s16-s31}             \n"
+        "                                       \n"
+        "   msr psp, r0                         \n"
+        "   isb                                 \n"
+        "                                       \n"
+        #ifdef WORKAROUND_PMU_CM001 /* XMC4000 specific errata workaround. */
+            #if WORKAROUND_PMU_CM001 == 1
+                "           push { r14 }                \n"
+                "           pop { pc }                  \n"
+            #endif
+        #endif
+        "                                       \n"
+        "   bx r14                              \n"
+        "                                       \n"
+        "   .ltorg                              \n"
+        ::"i" ( configMAX_SYSCALL_INTERRUPT_PRIORITY )
     );
 }
 /*-----------------------------------------------------------*/
 
-void xPortSysTickHandler(void)
+void xPortSysTickHandler( void )
 {
     /* The SysTick runs at the lowest interrupt priority, so when this interrupt
      * executes all interrupts must be unmasked.  There is therefore no need to
      * save and then restore the interrupt mask value as its value is already
      * known. */
     portDISABLE_INTERRUPTS();
+    traceISR_ENTER();
     {
         /* Increment the RTOS tick. */
-        if (xTaskIncrementTick() != pdFALSE) {
+        if( xTaskIncrementTick() != pdFALSE )
+        {
+            traceISR_EXIT_TO_SCHEDULER();
+
             /* A context switch is required.  Context switching is performed in
              * the PendSV interrupt.  Pend the PendSV interrupt. */
             portNVIC_INT_CTRL_REG = portNVIC_PENDSVSET_BIT;
         }
+        else
+        {
+            traceISR_EXIT();
+        }
     }
     portENABLE_INTERRUPTS();
 }
 /*-----------------------------------------------------------*/
 
 #if ( configUSE_TICKLESS_IDLE == 1 )
 
-__attribute__((weak)) void vPortSuppressTicksAndSleep(TickType_t xExpectedIdleTime)
-{
-    uint32_t ulReloadValue, ulCompleteTickPeriods, ulCompletedSysTickDecrements;
-    TickType_t xModifiableIdleTime;
+    __attribute__( ( weak ) ) void vPortSuppressTicksAndSleep( TickType_t xExpectedIdleTime )
+    {
+        uint32_t ulReloadValue, ulCompleteTickPeriods, ulCompletedSysTickDecrements, ulSysTickDecrementsLeft;
+        TickType_t xModifiableIdleTime;
 
-    /* Make sure the SysTick reload value does not overflow the counter. */
-    if (xExpectedIdleTime > xMaximumPossibleSuppressedTicks) {
-        xExpectedIdleTime = xMaximumPossibleSuppressedTicks;
-    }
+        /* Make sure the SysTick reload value does not overflow the counter. */
+        if( xExpectedIdleTime > xMaximumPossibleSuppressedTicks )
+        {
+            xExpectedIdleTime = xMaximumPossibleSuppressedTicks;
+        }
 
-    /* Stop the SysTick momentarily.  The time the SysTick is stopped for
-     * is accounted for as best it can be, but using the tickless mode will
-     * inevitably result in some tiny drift of the time maintained by the
-     * kernel with respect to calendar time. */
-    portNVIC_SYSTICK_CTRL_REG &= ~portNVIC_SYSTICK_ENABLE_BIT;
+        /* Enter a critical section but don't use the taskENTER_CRITICAL()
+         * method as that will mask interrupts that should exit sleep mode. */
+        __asm volatile ( "cpsid i" ::: "memory" );
+        __asm volatile ( "dsb" );
+        __asm volatile ( "isb" );
 
-    /* Calculate the reload value required to wait xExpectedIdleTime
-     * tick periods.  -1 is used because this code will execute part way
-     * through one of the tick periods. */
-    ulReloadValue = portNVIC_SYSTICK_CURRENT_VALUE_REG + (ulTimerCountsForOneTick * (xExpectedIdleTime - 1UL));
+        /* If a context switch is pending or a task is waiting for the scheduler
+         * to be unsuspended then abandon the low power entry. */
+        if( eTaskConfirmSleepModeStatus() == eAbortSleep )
+        {
+            /* Re-enable interrupts - see comments above the cpsid instruction
+             * above. */
+            __asm volatile ( "cpsie i" ::: "memory" );
+        }
+        else
+        {
+            /* Stop the SysTick momentarily.  The time the SysTick is stopped for
+             * is accounted for as best it can be, but using the tickless mode will
+             * inevitably result in some tiny drift of the time maintained by the
+             * kernel with respect to calendar time. */
+            portNVIC_SYSTICK_CTRL_REG = ( portNVIC_SYSTICK_CLK_BIT_CONFIG | portNVIC_SYSTICK_INT_BIT );
+
+            /* Use the SysTick current-value register to determine the number of
+             * SysTick decrements remaining until the next tick interrupt.  If the
+             * current-value register is zero, then there are actually
+             * ulTimerCountsForOneTick decrements remaining, not zero, because the
+             * SysTick requests the interrupt when decrementing from 1 to 0. */
+            ulSysTickDecrementsLeft = portNVIC_SYSTICK_CURRENT_VALUE_REG;
+
+            if( ulSysTickDecrementsLeft == 0 )
+            {
+                ulSysTickDecrementsLeft = ulTimerCountsForOneTick;
+            }
 
-    if (ulReloadValue > ulStoppedTimerCompensation) {
-        ulReloadValue -= ulStoppedTimerCompensation;
-    }
+            /* Calculate the reload value required to wait xExpectedIdleTime
+             * tick periods.  -1 is used because this code normally executes part
+             * way through the first tick period.  But if the SysTick IRQ is now
+             * pending, then clear the IRQ, suppressing the first tick, and correct
+             * the reload value to reflect that the second tick period is already
+             * underway.  The expected idle time is always at least two ticks. */
+            ulReloadValue = ulSysTickDecrementsLeft + ( ulTimerCountsForOneTick * ( xExpectedIdleTime - 1UL ) );
+
+            if( ( portNVIC_INT_CTRL_REG & portNVIC_PEND_SYSTICK_SET_BIT ) != 0 )
+            {
+                portNVIC_INT_CTRL_REG = portNVIC_PEND_SYSTICK_CLEAR_BIT;
+                ulReloadValue -= ulTimerCountsForOneTick;
+            }
 
-    /* Enter a critical section but don't use the taskENTER_CRITICAL()
-     * method as that will mask interrupts that should exit sleep mode. */
-    __asm volatile("cpsid i" ::: "memory");
-    __asm volatile("dsb");
-    __asm volatile("isb");
-
-    /* If a context switch is pending or a task is waiting for the scheduler
-     * to be unsuspended then abandon the low power entry. */
-    if (eTaskConfirmSleepModeStatus() == eAbortSleep) {
-        /* Restart from whatever is left in the count register to complete
-         * this tick period. */
-        portNVIC_SYSTICK_LOAD_REG = portNVIC_SYSTICK_CURRENT_VALUE_REG;
-
-        /* Restart SysTick. */
-        portNVIC_SYSTICK_CTRL_REG |= portNVIC_SYSTICK_ENABLE_BIT;
-
-        /* Reset the reload register to the value required for normal tick
-         * periods. */
-        portNVIC_SYSTICK_LOAD_REG = ulTimerCountsForOneTick - 1UL;
-
-        /* Re-enable interrupts - see comments above the cpsid instruction()
-         * above. */
-        __asm volatile("cpsie i" ::: "memory");
-    } else {
-        /* Set the new reload value. */
-        portNVIC_SYSTICK_LOAD_REG = ulReloadValue;
-
-        /* Clear the SysTick count flag and set the count value back to
-         * zero. */
-        portNVIC_SYSTICK_CURRENT_VALUE_REG = 0UL;
-
-        /* Restart SysTick. */
-        portNVIC_SYSTICK_CTRL_REG |= portNVIC_SYSTICK_ENABLE_BIT;
-
-        /* Sleep until something happens.  configPRE_SLEEP_PROCESSING() can
-         * set its parameter to 0 to indicate that its implementation contains
-         * its own wait for interrupt or wait for event instruction, and so wfi
-         * should not be executed again.  However, the original expected idle
-         * time variable must remain unmodified, so a copy is taken. */
-        xModifiableIdleTime = xExpectedIdleTime;
-        configPRE_SLEEP_PROCESSING(xModifiableIdleTime);
-
-        if (xModifiableIdleTime > 0) {
-            __asm volatile("dsb" ::: "memory");
-            __asm volatile("wfi");
-            __asm volatile("isb");
-        }
+            if( ulReloadValue > ulStoppedTimerCompensation )
+            {
+                ulReloadValue -= ulStoppedTimerCompensation;
+            }
 
-        configPOST_SLEEP_PROCESSING(xExpectedIdleTime);
-
-        /* Re-enable interrupts to allow the interrupt that brought the MCU
-         * out of sleep mode to execute immediately.  see comments above
-         * __disable_interrupt() call above. */
-        __asm volatile("cpsie i" ::: "memory");
-        __asm volatile("dsb");
-        __asm volatile("isb");
-
-        /* Disable interrupts again because the clock is about to be stopped
-         * and interrupts that execute while the clock is stopped will increase
-         * any slippage between the time maintained by the RTOS and calendar
-         * time. */
-        __asm volatile("cpsid i" ::: "memory");
-        __asm volatile("dsb");
-        __asm volatile("isb");
-
-        /* Disable the SysTick clock without reading the
-         * portNVIC_SYSTICK_CTRL_REG register to ensure the
-         * portNVIC_SYSTICK_COUNT_FLAG_BIT is not cleared if it is set.  Again,
-         * the time the SysTick is stopped for is accounted for as best it can
-         * be, but using the tickless mode will inevitably result in some tiny
-         * drift of the time maintained by the kernel with respect to calendar
-         * time*/
-        portNVIC_SYSTICK_CTRL_REG = (portNVIC_SYSTICK_CLK_BIT | portNVIC_SYSTICK_INT_BIT);
-
-        /* Determine if the SysTick clock has already counted to zero and
-         * been set back to the current reload value (the reload back being
-         * correct for the entire expected idle time) or if the SysTick is yet
-         * to count to zero (in which case an interrupt other than the SysTick
-         * must have brought the system out of sleep mode). */
-        if ((portNVIC_SYSTICK_CTRL_REG & portNVIC_SYSTICK_COUNT_FLAG_BIT) != 0) {
-            uint32_t ulCalculatedLoadValue;
-
-            /* The tick interrupt is already pending, and the SysTick count
-             * reloaded with ulReloadValue.  Reset the
-             * portNVIC_SYSTICK_LOAD_REG with whatever remains of this tick
-             * period. */
-            ulCalculatedLoadValue = (ulTimerCountsForOneTick - 1UL) - (ulReloadValue - portNVIC_SYSTICK_CURRENT_VALUE_REG);
-
-            /* Don't allow a tiny value, or values that have somehow
-             * underflowed because the post sleep hook did something
-             * that took too long. */
-            if ((ulCalculatedLoadValue < ulStoppedTimerCompensation) || (ulCalculatedLoadValue > ulTimerCountsForOneTick)) {
-                ulCalculatedLoadValue = (ulTimerCountsForOneTick - 1UL);
+            /* Set the new reload value. */
+            portNVIC_SYSTICK_LOAD_REG = ulReloadValue;
+
+            /* Clear the SysTick count flag and set the count value back to
+             * zero. */
+            portNVIC_SYSTICK_CURRENT_VALUE_REG = 0UL;
+
+            /* Restart SysTick. */
+            portNVIC_SYSTICK_CTRL_REG |= portNVIC_SYSTICK_ENABLE_BIT;
+
+            /* Sleep until something happens.  configPRE_SLEEP_PROCESSING() can
+             * set its parameter to 0 to indicate that its implementation contains
+             * its own wait for interrupt or wait for event instruction, and so wfi
+             * should not be executed again.  However, the original expected idle
+             * time variable must remain unmodified, so a copy is taken. */
+            xModifiableIdleTime = xExpectedIdleTime;
+            configPRE_SLEEP_PROCESSING( xModifiableIdleTime );
+
+            if( xModifiableIdleTime > 0 )
+            {
+                __asm volatile ( "dsb" ::: "memory" );
+                __asm volatile ( "wfi" );
+                __asm volatile ( "isb" );
             }
 
-            portNVIC_SYSTICK_LOAD_REG = ulCalculatedLoadValue;
-
-            /* As the pending tick will be processed as soon as this
-             * function exits, the tick value maintained by the tick is stepped
-             * forward by one less than the time spent waiting. */
-            ulCompleteTickPeriods = xExpectedIdleTime - 1UL;
-        } else {
-            /* Something other than the tick interrupt ended the sleep.
-             * Work out how long the sleep lasted rounded to complete tick
-             * periods (not the ulReload value which accounted for part
-             * ticks). */
-            ulCompletedSysTickDecrements = (xExpectedIdleTime * ulTimerCountsForOneTick) - portNVIC_SYSTICK_CURRENT_VALUE_REG;
-
-            /* How many complete tick periods passed while the processor
-             * was waiting? */
-            ulCompleteTickPeriods = ulCompletedSysTickDecrements / ulTimerCountsForOneTick;
-
-            /* The reload value is set to whatever fraction of a single tick
-             * period remains. */
-            portNVIC_SYSTICK_LOAD_REG = ((ulCompleteTickPeriods + 1UL) * ulTimerCountsForOneTick) - ulCompletedSysTickDecrements;
-        }
+            configPOST_SLEEP_PROCESSING( xExpectedIdleTime );
+
+            /* Re-enable interrupts to allow the interrupt that brought the MCU
+             * out of sleep mode to execute immediately.  See comments above
+             * the cpsid instruction above. */
+            __asm volatile ( "cpsie i" ::: "memory" );
+            __asm volatile ( "dsb" );
+            __asm volatile ( "isb" );
+
+            /* Disable interrupts again because the clock is about to be stopped
+             * and interrupts that execute while the clock is stopped will increase
+             * any slippage between the time maintained by the RTOS and calendar
+             * time. */
+            __asm volatile ( "cpsid i" ::: "memory" );
+            __asm volatile ( "dsb" );
+            __asm volatile ( "isb" );
+
+            /* Disable the SysTick clock without reading the
+             * portNVIC_SYSTICK_CTRL_REG register to ensure the
+             * portNVIC_SYSTICK_COUNT_FLAG_BIT is not cleared if it is set.  Again,
+             * the time the SysTick is stopped for is accounted for as best it can
+             * be, but using the tickless mode will inevitably result in some tiny
+             * drift of the time maintained by the kernel with respect to calendar
+             * time*/
+            portNVIC_SYSTICK_CTRL_REG = ( portNVIC_SYSTICK_CLK_BIT_CONFIG | portNVIC_SYSTICK_INT_BIT );
+
+            /* Determine whether the SysTick has already counted to zero. */
+            if( ( portNVIC_SYSTICK_CTRL_REG & portNVIC_SYSTICK_COUNT_FLAG_BIT ) != 0 )
+            {
+                uint32_t ulCalculatedLoadValue;
+
+                /* The tick interrupt ended the sleep (or is now pending), and
+                 * a new tick period has started.  Reset portNVIC_SYSTICK_LOAD_REG
+                 * with whatever remains of the new tick period. */
+                ulCalculatedLoadValue = ( ulTimerCountsForOneTick - 1UL ) - ( ulReloadValue - portNVIC_SYSTICK_CURRENT_VALUE_REG );
+
+                /* Don't allow a tiny value, or values that have somehow
+                 * underflowed because the post sleep hook did something
+                 * that took too long or because the SysTick current-value register
+                 * is zero. */
+                if( ( ulCalculatedLoadValue <= ulStoppedTimerCompensation ) || ( ulCalculatedLoadValue > ulTimerCountsForOneTick ) )
+                {
+                    ulCalculatedLoadValue = ( ulTimerCountsForOneTick - 1UL );
+                }
+
+                portNVIC_SYSTICK_LOAD_REG = ulCalculatedLoadValue;
+
+                /* As the pending tick will be processed as soon as this
+                 * function exits, the tick value maintained by the tick is stepped
+                 * forward by one less than the time spent waiting. */
+                ulCompleteTickPeriods = xExpectedIdleTime - 1UL;
+            }
+            else
+            {
+                /* Something other than the tick interrupt ended the sleep. */
+
+                /* Use the SysTick current-value register to determine the
+                 * number of SysTick decrements remaining until the expected idle
+                 * time would have ended. */
+                ulSysTickDecrementsLeft = portNVIC_SYSTICK_CURRENT_VALUE_REG;
+                #if ( portNVIC_SYSTICK_CLK_BIT_CONFIG != portNVIC_SYSTICK_CLK_BIT )
+                {
+                    /* If the SysTick is not using the core clock, the current-
+                     * value register might still be zero here.  In that case, the
+                     * SysTick didn't load from the reload register, and there are
+                     * ulReloadValue decrements remaining in the expected idle
+                     * time, not zero. */
+                    if( ulSysTickDecrementsLeft == 0 )
+                    {
+                        ulSysTickDecrementsLeft = ulReloadValue;
+                    }
+                }
+                #endif /* portNVIC_SYSTICK_CLK_BIT_CONFIG */
+
+                /* Work out how long the sleep lasted rounded to complete tick
+                 * periods (not the ulReload value which accounted for part
+                 * ticks). */
+                ulCompletedSysTickDecrements = ( xExpectedIdleTime * ulTimerCountsForOneTick ) - ulSysTickDecrementsLeft;
+
+                /* How many complete tick periods passed while the processor
+                 * was waiting? */
+                ulCompleteTickPeriods = ulCompletedSysTickDecrements / ulTimerCountsForOneTick;
+
+                /* The reload value is set to whatever fraction of a single tick
+                 * period remains. */
+                portNVIC_SYSTICK_LOAD_REG = ( ( ulCompleteTickPeriods + 1UL ) * ulTimerCountsForOneTick ) - ulCompletedSysTickDecrements;
+            }
 
-        /* Restart SysTick so it runs from portNVIC_SYSTICK_LOAD_REG
-         * again, then set portNVIC_SYSTICK_LOAD_REG back to its standard
-         * value. */
-        portNVIC_SYSTICK_CURRENT_VALUE_REG = 0UL;
-        portNVIC_SYSTICK_CTRL_REG |= portNVIC_SYSTICK_ENABLE_BIT;
-        vTaskStepTick(ulCompleteTickPeriods);
-        portNVIC_SYSTICK_LOAD_REG = ulTimerCountsForOneTick - 1UL;
+            /* Restart SysTick so it runs from portNVIC_SYSTICK_LOAD_REG again,
+             * then set portNVIC_SYSTICK_LOAD_REG back to its standard value.  If
+             * the SysTick is not using the core clock, temporarily configure it to
+             * use the core clock.  This configuration forces the SysTick to load
+             * from portNVIC_SYSTICK_LOAD_REG immediately instead of at the next
+             * cycle of the other clock.  Then portNVIC_SYSTICK_LOAD_REG is ready
+             * to receive the standard value immediately. */
+            portNVIC_SYSTICK_CURRENT_VALUE_REG = 0UL;
+            portNVIC_SYSTICK_CTRL_REG = portNVIC_SYSTICK_CLK_BIT | portNVIC_SYSTICK_INT_BIT | portNVIC_SYSTICK_ENABLE_BIT;
+            #if ( portNVIC_SYSTICK_CLK_BIT_CONFIG == portNVIC_SYSTICK_CLK_BIT )
+            {
+                portNVIC_SYSTICK_LOAD_REG = ulTimerCountsForOneTick - 1UL;
+            }
+            #else
+            {
+                /* The temporary usage of the core clock has served its purpose,
+                 * as described above.  Resume usage of the other clock. */
+                portNVIC_SYSTICK_CTRL_REG = portNVIC_SYSTICK_CLK_BIT | portNVIC_SYSTICK_INT_BIT;
+
+                if( ( portNVIC_SYSTICK_CTRL_REG & portNVIC_SYSTICK_COUNT_FLAG_BIT ) != 0 )
+                {
+                    /* The partial tick period already ended.  Be sure the SysTick
+                     * counts it only once. */
+                    portNVIC_SYSTICK_CURRENT_VALUE_REG = 0;
+                }
+
+                portNVIC_SYSTICK_LOAD_REG = ulTimerCountsForOneTick - 1UL;
+                portNVIC_SYSTICK_CTRL_REG = portNVIC_SYSTICK_CLK_BIT_CONFIG | portNVIC_SYSTICK_INT_BIT | portNVIC_SYSTICK_ENABLE_BIT;
+            }
+            #endif /* portNVIC_SYSTICK_CLK_BIT_CONFIG */
 
-        /* Exit with interrupts enabled. */
-        __asm volatile("cpsie i" ::: "memory");
+            /* Step the tick to account for any tick periods that elapsed. */
+            vTaskStepTick( ulCompleteTickPeriods );
+
+            /* Exit with interrupts enabled. */
+            __asm volatile ( "cpsie i" ::: "memory" );
+        }
     }
-}
 
 #endif /* #if configUSE_TICKLESS_IDLE */
 /*-----------------------------------------------------------*/
@@ -672,98 +809,99 @@ __attribute__((weak)) void vPortSuppressTicksAndSleep(TickType_t xExpectedIdleTi
  * Setup the systick timer to generate the tick interrupts at the required
  * frequency.
  */
-__attribute__((weak)) void vPortSetupTimerInterrupt(void)
+__attribute__( ( weak ) ) void vPortSetupTimerInterrupt( void )
 {
     /* Calculate the constants required to configure the tick interrupt. */
-#if ( configUSE_TICKLESS_IDLE == 1 )
+    #if ( configUSE_TICKLESS_IDLE == 1 )
     {
-        ulTimerCountsForOneTick = (configSYSTICK_CLOCK_HZ / configTICK_RATE_HZ);
+        ulTimerCountsForOneTick = ( configSYSTICK_CLOCK_HZ / configTICK_RATE_HZ );
         xMaximumPossibleSuppressedTicks = portMAX_24_BIT_NUMBER / ulTimerCountsForOneTick;
-        ulStoppedTimerCompensation = portMISSED_COUNTS_FACTOR / (configCPU_CLOCK_HZ / configSYSTICK_CLOCK_HZ);
+        ulStoppedTimerCompensation = portMISSED_COUNTS_FACTOR / ( configCPU_CLOCK_HZ / configSYSTICK_CLOCK_HZ );
     }
-#endif /* configUSE_TICKLESS_IDLE */
+    #endif /* configUSE_TICKLESS_IDLE */
 
     /* Stop and clear the SysTick. */
     portNVIC_SYSTICK_CTRL_REG = 0UL;
     portNVIC_SYSTICK_CURRENT_VALUE_REG = 0UL;
 
     /* Configure SysTick to interrupt at the requested rate. */
-    portNVIC_SYSTICK_LOAD_REG = (configSYSTICK_CLOCK_HZ / configTICK_RATE_HZ) - 1UL;
-    portNVIC_SYSTICK_CTRL_REG = (portNVIC_SYSTICK_CLK_BIT | portNVIC_SYSTICK_INT_BIT | portNVIC_SYSTICK_ENABLE_BIT);
+    portNVIC_SYSTICK_LOAD_REG = ( configSYSTICK_CLOCK_HZ / configTICK_RATE_HZ ) - 1UL;
+    portNVIC_SYSTICK_CTRL_REG = ( portNVIC_SYSTICK_CLK_BIT_CONFIG | portNVIC_SYSTICK_INT_BIT | portNVIC_SYSTICK_ENABLE_BIT );
 }
 /*-----------------------------------------------------------*/
 
 /* This is a naked function. */
-static void vPortEnableVFP(void)
+static void vPortEnableVFP( void )
 {
     __asm volatile
     (
-        "	ldr.w r0, =0xE000ED88		\n"/* The FPU enable bits are in the CPACR. */
-        "	ldr r1, [r0]				\n"
-        "								\n"
-        "	orr r1, r1, #( 0xf << 20 )	\n"/* Enable CP10 and CP11 coprocessors, then save back. */
-        "	str r1, [r0]				\n"
-        "	bx r14						\n"
-        "	.ltorg						\n"
+        "   ldr.w r0, =0xE000ED88       \n" /* The FPU enable bits are in the CPACR. */
+        "   ldr r1, [r0]                \n"
+        "                               \n"
+        "   orr r1, r1, #( 0xf << 20 )  \n" /* Enable CP10 and CP11 coprocessors, then save back. */
+        "   str r1, [r0]                \n"
+        "   bx r14                      \n"
+        "   .ltorg                      \n"
     );
 }
 /*-----------------------------------------------------------*/
 
 #if ( configASSERT_DEFINED == 1 )
 
-void vPortValidateInterruptPriority(void)
-{
-    uint32_t ulCurrentInterrupt;
-    uint8_t ucCurrentPriority;
-
-    /* Obtain the number of the currently executing interrupt. */
-    __asm volatile("mrs %0, ipsr" : "=r"(ulCurrentInterrupt)::"memory");
-
-    /* Is the interrupt number a user defined interrupt? */
-    if (ulCurrentInterrupt >= portFIRST_USER_INTERRUPT_NUMBER) {
-        /* Look up the interrupt's priority. */
-        ucCurrentPriority = pcInterruptPriorityRegisters[ ulCurrentInterrupt ];
-
-        /* The following assertion will fail if a service routine (ISR) for
-         * an interrupt that has been assigned a priority above
-         * configMAX_SYSCALL_INTERRUPT_PRIORITY calls an ISR safe FreeRTOS API
-         * function.  ISR safe FreeRTOS API functions must *only* be called
-         * from interrupts that have been assigned a priority at or below
-         * configMAX_SYSCALL_INTERRUPT_PRIORITY.
-         *
-         * Numerically low interrupt priority numbers represent logically high
-         * interrupt priorities, therefore the priority of the interrupt must
-         * be set to a value equal to or numerically *higher* than
-         * configMAX_SYSCALL_INTERRUPT_PRIORITY.
-         *
-         * Interrupts that  use the FreeRTOS API must not be left at their
-         * default priority of  zero as that is the highest possible priority,
-         * which is guaranteed to be above configMAX_SYSCALL_INTERRUPT_PRIORITY,
-         * and  therefore also guaranteed to be invalid.
-         *
-         * FreeRTOS maintains separate thread and ISR API functions to ensure
-         * interrupt entry is as fast and simple as possible.
+    void vPortValidateInterruptPriority( void )
+    {
+        uint32_t ulCurrentInterrupt;
+        uint8_t ucCurrentPriority;
+
+        /* Obtain the number of the currently executing interrupt. */
+        __asm volatile ( "mrs %0, ipsr" : "=r" ( ulCurrentInterrupt )::"memory" );
+
+        /* Is the interrupt number a user defined interrupt? */
+        if( ulCurrentInterrupt >= portFIRST_USER_INTERRUPT_NUMBER )
+        {
+            /* Look up the interrupt's priority. */
+            ucCurrentPriority = pcInterruptPriorityRegisters[ ulCurrentInterrupt ];
+
+            /* The following assertion will fail if a service routine (ISR) for
+             * an interrupt that has been assigned a priority above
+             * configMAX_SYSCALL_INTERRUPT_PRIORITY calls an ISR safe FreeRTOS API
+             * function.  ISR safe FreeRTOS API functions must *only* be called
+             * from interrupts that have been assigned a priority at or below
+             * configMAX_SYSCALL_INTERRUPT_PRIORITY.
+             *
+             * Numerically low interrupt priority numbers represent logically high
+             * interrupt priorities, therefore the priority of the interrupt must
+             * be set to a value equal to or numerically *higher* than
+             * configMAX_SYSCALL_INTERRUPT_PRIORITY.
+             *
+             * Interrupts that  use the FreeRTOS API must not be left at their
+             * default priority of  zero as that is the highest possible priority,
+             * which is guaranteed to be above configMAX_SYSCALL_INTERRUPT_PRIORITY,
+             * and  therefore also guaranteed to be invalid.
+             *
+             * FreeRTOS maintains separate thread and ISR API functions to ensure
+             * interrupt entry is as fast and simple as possible.
+             *
+             * The following links provide detailed information:
+             * https://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html
+             * https://www.freertos.org/Why-FreeRTOS/FAQs */
+            configASSERT( ucCurrentPriority >= ucMaxSysCallPriority );
+        }
+
+        /* Priority grouping:  The interrupt controller (NVIC) allows the bits
+         * that define each interrupt's priority to be split between bits that
+         * define the interrupt's pre-emption priority bits and bits that define
+         * the interrupt's sub-priority.  For simplicity all bits must be defined
+         * to be pre-emption priority bits.  The following assertion will fail if
+         * this is not the case (if some bits represent a sub-priority).
          *
-         * The following links provide detailed information:
-         * https://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html
-         * https://www.FreeRTOS.org/FAQHelp.html */
-        configASSERT(ucCurrentPriority >= ucMaxSysCallPriority);
+         * If the application only uses CMSIS libraries for interrupt
+         * configuration then the correct setting can be achieved on all Cortex-M
+         * devices by calling NVIC_SetPriorityGrouping( 0 ); before starting the
+         * scheduler.  Note however that some vendor specific peripheral libraries
+         * assume a non-zero priority group setting, in which cases using a value
+         * of zero will result in unpredictable behaviour. */
+        configASSERT( ( portAIRCR_REG & portPRIORITY_GROUP_MASK ) <= ulMaxPRIGROUPValue );
     }
 
-    /* Priority grouping:  The interrupt controller (NVIC) allows the bits
-     * that define each interrupt's priority to be split between bits that
-     * define the interrupt's pre-emption priority bits and bits that define
-     * the interrupt's sub-priority.  For simplicity all bits must be defined
-     * to be pre-emption priority bits.  The following assertion will fail if
-     * this is not the case (if some bits represent a sub-priority).
-     *
-     * If the application only uses CMSIS libraries for interrupt
-     * configuration then the correct setting can be achieved on all Cortex-M
-     * devices by calling NVIC_SetPriorityGrouping( 0 ); before starting the
-     * scheduler.  Note however that some vendor specific peripheral libraries
-     * assume a non-zero priority group setting, in which cases using a value
-     * of zero will result in unpredictable behaviour. */
-    configASSERT((portAIRCR_REG & portPRIORITY_GROUP_MASK) <= ulMaxPRIGROUPValue);
-}
-
 #endif /* configASSERT_DEFINED */

### external/FreeRTOS/Source/portable/GCC/ARM_CM4F/portmacro.h
@@ -1,6 +1,6 @@
 /*
- * FreeRTOS Kernel V10.4.6
- * Copyright (C) 2021 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
+ * FreeRTOS Kernel V11.3.0
+ * Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
  *
  * SPDX-License-Identifier: MIT
  *
@@ -30,9 +30,11 @@
 #ifndef PORTMACRO_H
 #define PORTMACRO_H
 
+/* *INDENT-OFF* */
 #ifdef __cplusplus
-extern "C" {
+    extern "C" {
 #endif
+/* *INDENT-ON* */
 
 /*-----------------------------------------------------------
  * Port specific definitions.
@@ -57,17 +59,22 @@ typedef portSTACK_TYPE   StackType_t;
 typedef long             BaseType_t;
 typedef unsigned long    UBaseType_t;
 
-#if ( configUSE_16_BIT_TICKS == 1 )
-typedef uint16_t     TickType_t;
-#define portMAX_DELAY              ( TickType_t ) 0xffff
-#else
-typedef uint32_t     TickType_t;
-#define portMAX_DELAY              ( TickType_t ) 0xffffffffUL
+#if ( configTICK_TYPE_WIDTH_IN_BITS == TICK_TYPE_WIDTH_16_BITS )
+    typedef uint16_t     TickType_t;
+    #define portMAX_DELAY              ( TickType_t ) 0xffff
+#elif ( configTICK_TYPE_WIDTH_IN_BITS == TICK_TYPE_WIDTH_32_BITS )
+    typedef uint32_t     TickType_t;
+    #define portMAX_DELAY              ( TickType_t ) 0xffffffffUL
 
 /* 32-bit tick type on a 32-bit architecture, so reads of the tick count do
  * not need to be guarded with a critical section. */
-#define portTICK_TYPE_IS_ATOMIC    1
-#endif
+    #define portTICK_TYPE_IS_ATOMIC    1
+#elif ( configTICK_TYPE_WIDTH_IN_BITS == TICK_TYPE_WIDTH_64_BITS )
+    typedef uint64_t TickType_t;
+    #define portMAX_DELAY              ( TickType_t ) 0xffffffffffffffffULL
+#else /* if ( configTICK_TYPE_WIDTH_IN_BITS == TICK_TYPE_WIDTH_16_BITS ) */
+    #error configTICK_TYPE_WIDTH_IN_BITS set to unsupported tick type width.
+#endif /* if ( configTICK_TYPE_WIDTH_IN_BITS == TICK_TYPE_WIDTH_16_BITS ) */
 /*-----------------------------------------------------------*/
 
 /* Architecture specifics. */
@@ -78,7 +85,7 @@ typedef uint32_t     TickType_t;
 /*-----------------------------------------------------------*/
 
 /* Scheduler utilities. */
-#define portYIELD()                                 \
+#define portYIELD()                                     \
     {                                                   \
         /* Set a PendSV to request a context switch. */ \
         portNVIC_INT_CTRL_REG = portNVIC_PENDSVSET_BIT; \
@@ -91,13 +98,25 @@ typedef uint32_t     TickType_t;
 
 #define portNVIC_INT_CTRL_REG     ( *( ( volatile uint32_t * ) 0xe000ed04 ) )
 #define portNVIC_PENDSVSET_BIT    ( 1UL << 28UL )
-#define portEND_SWITCHING_ISR( xSwitchRequired )    do { if( xSwitchRequired != pdFALSE ) portYIELD(); } while( 0 )
-#define portYIELD_FROM_ISR( x )                     portEND_SWITCHING_ISR( x )
+#define portEND_SWITCHING_ISR( xSwitchRequired ) \
+    do                                           \
+    {                                            \
+        if( xSwitchRequired != pdFALSE )         \
+        {                                        \
+            traceISR_EXIT_TO_SCHEDULER();        \
+            portYIELD();                         \
+        }                                        \
+        else                                     \
+        {                                        \
+            traceISR_EXIT();                     \
+        }                                        \
+    } while( 0 )
+#define portYIELD_FROM_ISR( x )    portEND_SWITCHING_ISR( x )
 /*-----------------------------------------------------------*/
 
 /* Critical section management. */
-extern void vPortEnterCritical(void);
-extern void vPortExitCritical(void);
+extern void vPortEnterCritical( void );
+extern void vPortExitCritical( void );
 #define portSET_INTERRUPT_MASK_FROM_ISR()         ulPortRaiseBASEPRI()
 #define portCLEAR_INTERRUPT_MASK_FROM_ISR( x )    vPortSetBASEPRI( x )
 #define portDISABLE_INTERRUPTS()                  vPortRaiseBASEPRI()
@@ -116,48 +135,48 @@ extern void vPortExitCritical(void);
 
 /* Tickless idle/low power functionality. */
 #ifndef portSUPPRESS_TICKS_AND_SLEEP
-extern void vPortSuppressTicksAndSleep(TickType_t xExpectedIdleTime);
-#define portSUPPRESS_TICKS_AND_SLEEP( xExpectedIdleTime )    vPortSuppressTicksAndSleep( xExpectedIdleTime )
+    extern void vPortSuppressTicksAndSleep( TickType_t xExpectedIdleTime );
+    #define portSUPPRESS_TICKS_AND_SLEEP( xExpectedIdleTime )    vPortSuppressTicksAndSleep( xExpectedIdleTime )
 #endif
 /*-----------------------------------------------------------*/
 
 /* Architecture specific optimisations. */
 #ifndef configUSE_PORT_OPTIMISED_TASK_SELECTION
-#define configUSE_PORT_OPTIMISED_TASK_SELECTION    1
+    #define configUSE_PORT_OPTIMISED_TASK_SELECTION    1
 #endif
 
 #if configUSE_PORT_OPTIMISED_TASK_SELECTION == 1
 
 /* Generic helper function. */
-__attribute__((always_inline)) static inline uint8_t ucPortCountLeadingZeros(uint32_t ulBitmap)
-{
-    uint8_t ucReturn;
+    __attribute__( ( always_inline ) ) static inline uint8_t ucPortCountLeadingZeros( uint32_t ulBitmap )
+    {
+        uint8_t ucReturn;
 
-    __asm volatile("clz %0, %1" : "=r"(ucReturn) : "r"(ulBitmap) : "memory");
+        __asm volatile ( "clz %0, %1" : "=r" ( ucReturn ) : "r" ( ulBitmap ) : "memory" );
 
-    return ucReturn;
-}
+        return ucReturn;
+    }
 
 /* Check the configuration. */
-#if ( configMAX_PRIORITIES > 32 )
-#error configUSE_PORT_OPTIMISED_TASK_SELECTION can only be set to 1 when configMAX_PRIORITIES is less than or equal to 32.  It is very rare that a system requires more than 10 to 15 difference priorities as tasks that share a priority will time slice.
-#endif
+    #if ( configMAX_PRIORITIES > 32 )
+        #error configUSE_PORT_OPTIMISED_TASK_SELECTION can only be set to 1 when configMAX_PRIORITIES is less than or equal to 32.  It is very rare that a system requires more than 10 to 15 difference priorities as tasks that share a priority will time slice.
+    #endif
 
 /* Store/clear the ready priorities in a bit map. */
-#define portRECORD_READY_PRIORITY( uxPriority, uxReadyPriorities )    ( uxReadyPriorities ) |= ( 1UL << ( uxPriority ) )
-#define portRESET_READY_PRIORITY( uxPriority, uxReadyPriorities )     ( uxReadyPriorities ) &= ~( 1UL << ( uxPriority ) )
+    #define portRECORD_READY_PRIORITY( uxPriority, uxReadyPriorities )    ( uxReadyPriorities ) |= ( 1UL << ( uxPriority ) )
+    #define portRESET_READY_PRIORITY( uxPriority, uxReadyPriorities )     ( uxReadyPriorities ) &= ~( 1UL << ( uxPriority ) )
 
 /*-----------------------------------------------------------*/
 
-#define portGET_HIGHEST_PRIORITY( uxTopPriority, uxReadyPriorities )    uxTopPriority = ( 31UL - ( uint32_t ) ucPortCountLeadingZeros( ( uxReadyPriorities ) ) )
+    #define portGET_HIGHEST_PRIORITY( uxTopPriority, uxReadyPriorities )    uxTopPriority = ( 31UL - ( uint32_t ) ucPortCountLeadingZeros( ( uxReadyPriorities ) ) )
 
 #endif /* configUSE_PORT_OPTIMISED_TASK_SELECTION */
 
 /*-----------------------------------------------------------*/
 
-#ifdef configASSERT
-void vPortValidateInterruptPriority(void);
-#define portASSERT_IF_INTERRUPT_PRIORITY_INVALID()    vPortValidateInterruptPriority()
+#if ( configASSERT_DEFINED == 1 )
+    void vPortValidateInterruptPriority( void );
+    #define portASSERT_IF_INTERRUPT_PRIORITY_INVALID()    vPortValidateInterruptPriority()
 #endif
 
 /* portNOP() is not required by this port. */
@@ -166,20 +185,23 @@ void vPortValidateInterruptPriority(void);
 #define portINLINE              __inline
 
 #ifndef portFORCE_INLINE
-#define portFORCE_INLINE    inline __attribute__( ( always_inline ) )
+    #define portFORCE_INLINE    inline __attribute__( ( always_inline ) )
 #endif
 
-portFORCE_INLINE static BaseType_t xPortIsInsideInterrupt(void)
+portFORCE_INLINE static BaseType_t xPortIsInsideInterrupt( void )
 {
     uint32_t ulCurrentInterrupt;
     BaseType_t xReturn;
 
     /* Obtain the number of the currently executing interrupt. */
-    __asm volatile("mrs %0, ipsr" : "=r"(ulCurrentInterrupt)::"memory");
+    __asm volatile ( "mrs %0, ipsr" : "=r" ( ulCurrentInterrupt )::"memory" );
 
-    if (ulCurrentInterrupt == 0) {
+    if( ulCurrentInterrupt == 0 )
+    {
         xReturn = pdFALSE;
-    } else {
+    }
+    else
+    {
         xReturn = pdTRUE;
     }
 
@@ -188,34 +210,34 @@ portFORCE_INLINE static BaseType_t xPortIsInsideInterrupt(void)
 
 /*-----------------------------------------------------------*/
 
-portFORCE_INLINE static void vPortRaiseBASEPRI(void)
+portFORCE_INLINE static void vPortRaiseBASEPRI( void )
 {
     uint32_t ulNewBASEPRI;
 
     __asm volatile
     (
-        "	mov %0, %1												\n"\
-        "	msr basepri, %0											\n"\
-        "	isb														\n"\
-        "	dsb														\n"\
-        : "=r"(ulNewBASEPRI) : "i"(configMAX_SYSCALL_INTERRUPT_PRIORITY) : "memory"
+        "   mov %0, %1                                              \n" \
+        "   msr basepri, %0                                         \n" \
+        "   isb                                                     \n" \
+        "   dsb                                                     \n" \
+        : "=r" ( ulNewBASEPRI ) : "i" ( configMAX_SYSCALL_INTERRUPT_PRIORITY ) : "memory"
     );
 }
 
 /*-----------------------------------------------------------*/
 
-portFORCE_INLINE static uint32_t ulPortRaiseBASEPRI(void)
+portFORCE_INLINE static uint32_t ulPortRaiseBASEPRI( void )
 {
     uint32_t ulOriginalBASEPRI, ulNewBASEPRI;
 
     __asm volatile
     (
-        "	mrs %0, basepri											\n"\
-        "	mov %1, %2												\n"\
-        "	msr basepri, %1											\n"\
-        "	isb														\n"\
-        "	dsb														\n"\
-        : "=r"(ulOriginalBASEPRI), "=r"(ulNewBASEPRI) : "i"(configMAX_SYSCALL_INTERRUPT_PRIORITY) : "memory"
+        "   mrs %0, basepri                                         \n" \
+        "   mov %1, %2                                              \n" \
+        "   msr basepri, %1                                         \n" \
+        "   isb                                                     \n" \
+        "   dsb                                                     \n" \
+        : "=r" ( ulOriginalBASEPRI ), "=r" ( ulNewBASEPRI ) : "i" ( configMAX_SYSCALL_INTERRUPT_PRIORITY ) : "memory"
     );
 
     /* This return will not be reached but is necessary to prevent compiler
@@ -224,19 +246,21 @@ portFORCE_INLINE static uint32_t ulPortRaiseBASEPRI(void)
 }
 /*-----------------------------------------------------------*/
 
-portFORCE_INLINE static void vPortSetBASEPRI(uint32_t ulNewMaskValue)
+portFORCE_INLINE static void vPortSetBASEPRI( uint32_t ulNewMaskValue )
 {
     __asm volatile
     (
-        "	msr basepri, %0	"::"r"(ulNewMaskValue) : "memory"
+        "   msr basepri, %0 " ::"r" ( ulNewMaskValue ) : "memory"
     );
 }
 /*-----------------------------------------------------------*/
 
 #define portMEMORY_BARRIER()    __asm volatile ( "" ::: "memory" )
 
+/* *INDENT-OFF* */
 #ifdef __cplusplus
-}
+    }
 #endif
+/* *INDENT-ON* */
 
 #endif /* PORTMACRO_H */

### external/FreeRTOS/Source/portable/GCC/ARM_CM4_MPU/mpu_wrappers_v2_asm.c
[binary or diff unavailable]

### external/FreeRTOS/Source/portable/GCC/ARM_CM4_MPU/port.c
[binary or diff unavailable]

### external/FreeRTOS/Source/portable/GCC/ARM_CM4_MPU/portmacro.h
[binary or diff unavailable]

### external/FreeRTOS/Source/portable/MemMang/heap_4.c
[binary or diff unavailable]

### external/FreeRTOS/Source/queue.c
[binary or diff unavailable]

### external/FreeRTOS/Source/stream_buffer.c
[binary or diff unavailable]

### external/FreeRTOS/Source/tasks.c
[binary or diff unavailable]

### external/FreeRTOS/Source/timers.c
[binary or diff unavailable]

### external/FreeRTOS/UPSTREAM.md
[binary or diff unavailable]

### external/FreeRTOS/freertos_heap.c
[binary or diff unavailable]

### external/FreeRTOS/rtos_expand.c
[binary or diff unavailable]

### external/mh1903_lib/MHSCPU_Driver/src/mhscpu_wdt.c
[binary or diff unavailable]

### external/mh1903_lib/SCPU_USB_Lib/SCPU_USB_Device_Library/Class/cdc/inc/usbd_cdc_core.h
[binary or diff unavailable]

### external/mh1903_lib/SCPU_USB_Lib/SCPU_USB_Device_Library/Class/cdc/src/usbd_cdc_core.c
[binary or diff unavailable]

### external/mh1903_lib/SCPU_USB_Lib/SCPU_USB_OTG_Driver/src/usb_core.c
[binary or diff unavailable]

### firmware.cmake
[binary or diff unavailable]

### keystone3-firmware-release
[binary or diff unavailable]

### mh1903b.ld
[binary or diff unavailable]

### rust/CMakeLists.txt
[binary or diff unavailable]

### rust/Cargo.lock
[binary or diff unavailable]

### rust/Cargo.toml
[binary or diff unavailable]

### rust/apps/arweave/src/data_item.rs
[binary or diff unavailable]

### rust/apps/arweave/src/lib.rs
[binary or diff unavailable]

### rust/apps/cardano/Cargo.toml
[binary or diff unavailable]

### rust/apps/cardano/src/address.rs
[binary or diff unavailable]

### rust/apps/cardano/src/governance.rs
[binary or diff unavailable]

### rust/apps/cardano/src/structs.rs
[binary or diff unavailable]

### rust/apps/cardano/src/transaction.rs
[binary or diff unavailable]

### rust/apps/ethereum/src/eip712/eip712.rs
[binary or diff unavailable]

### rust/apps/ethereum/src/lib.rs
[binary or diff unavailable]

### rust/apps/stellar/src/address.rs
[binary or diff unavailable]

### rust/keystore/src/algorithms/rsa/mod.rs
[binary or diff unavailable]

### rust/rust_c/Cargo.toml
[binary or diff unavailable]

### rust/rust_c/src/cardano/mod.rs
[binary or diff unavailable]

### rust/rust_c/src/cardano/structs.rs
[binary or diff unavailable]

### rust/rust_c/src/common/ur.rs
[binary or diff unavailable]

### rust/rust_c/src/ethereum/mod.rs
[binary or diff unavailable]

### rust/rust_c/src/iota/mod.rs
[binary or diff unavailable]

### rust/rust_c/src/iota/structs.rs
[binary or diff unavailable]

### rust/rust_c/src/lib.rs
[binary or diff unavailable]

### rust/rust_c/src/sandbox_parser.rs
[binary or diff unavailable]

### rust/rust_c/src/zcash/mod.rs
[binary or diff unavailable]

### rust/sandbox_parser/Cargo.toml
[binary or diff unavailable]

### rust/sandbox_parser/src/lib.rs
[binary or diff unavailable]

### src/boot_update.c
[binary or diff unavailable]

### src/config/legacy_web_update_pad.c
[binary or diff unavailable]

### src/config/version.c
[binary or diff unavailable]

### src/config/version.h
[binary or diff unavailable]

### src/crypto/account_public_info.c
[binary or diff unavailable]

### src/crypto/account_public_info.h
[binary or diff unavailable]

### src/crypto/bips/bip39.c
[binary or diff unavailable]

### src/crypto/bips/bip39_english.inc
[binary or diff unavailable]

### src/crypto/bips/wordlist.c
[binary or diff unavailable]

### src/crypto/rsa.c
[binary or diff unavailable]

### src/crypto/rsa.h
[binary or diff unavailable]

### src/crypto/utils/hash_and_salt.c
[binary or diff unavailable]

### src/device_setting.h
[binary or diff unavailable]

### src/device_settings.c
[binary or diff unavailable]

### src/driver/drv_atecc608b.c
[binary or diff unavailable]

### src/driver/drv_aw32001.c
[binary or diff unavailable]

### src/driver/drv_battery.c
[binary or diff unavailable]

### src/driver/drv_bpk.c
[binary or diff unavailable]

### src/driver/drv_ds28s60.c
[binary or diff unavailable]

### src/driver/drv_ds28s60.h
[binary or diff unavailable]

### src/driver/drv_gd25qxx.c
[binary or diff unavailable]

### src/driver/drv_gsl1691.c
[binary or diff unavailable]

### src/driver/drv_i2c.c
[binary or diff unavailable]

### src/driver/drv_ili9806.c
[binary or diff unavailable]

### src/driver/drv_mpu.c
[binary or diff unavailable]

### src/driver/drv_mpu.h
[binary or diff unavailable]

### src/driver/drv_nt35510.c
[binary or diff unavailable]

### src/driver/drv_otp.c
[binary or diff unavailable]

### src/driver/drv_otp.h
[binary or diff unavailable]

### src/driver/drv_power.c
[binary or diff unavailable]

### src/driver/drv_psram.c
[binary or diff unavailable]

### src/driver/drv_qspi_flash.c
[binary or diff unavailable]

### src/driver/drv_sdcard.c
[binary or diff unavailable]

### src/driver/drv_sensor.c
[binary or diff unavailable]

### src/driver/drv_sys.c
[binary or diff unavailable]

### src/driver/drv_uart.c
[binary or diff unavailable]

### src/driver/hal_lcd.c
[binary or diff unavailable]

### src/driver/hardware_version.c
[binary or diff unavailable]

### src/driver/low_power.c
[binary or diff unavailable]

### src/driver/power_on_self_check.c
[binary or diff unavailable]

### src/driver/usb/drv_usb.c
[binary or diff unavailable]

### src/error_codes/err_code.c
[binary or diff unavailable]

### src/error_codes/err_code.h
[binary or diff unavailable]

### src/hardware_interface/anti_tamper.c
[binary or diff unavailable]

### src/hardware_interface/draw_on_lcd.c
[binary or diff unavailable]

### src/hardware_interface/draw_on_lcd.h
[binary or diff unavailable]

### src/hardware_interface/screenshot.c
[binary or diff unavailable]

### src/hardware_interface/se_interface.c
[binary or diff unavailable]

### src/main.c
[binary or diff unavailable]

### src/managers/account_manager.c
[binary or diff unavailable]

### src/managers/account_manager.h
[binary or diff unavailable]

### src/managers/fingerprint_process.c
[binary or diff unavailable]

### src/managers/keystore.c
[binary or diff unavailable]

### src/managers/keystore.h
[binary or diff unavailable]

### src/managers/power_manager.c
[binary or diff unavailable]

### src/managers/screen_manager.c
[binary or diff unavailable]

### src/managers/se_backend_gen1.c
[binary or diff unavailable]

### src/managers/se_manager.c
[binary or diff unavailable]

### src/managers/se_manager.h
[binary or diff unavailable]

### src/msg/general_msg.c
[binary or diff unavailable]

### src/presetting.c
[binary or diff unavailable]

### src/ram/user_memory.c
[binary or diff unavailable]

### src/ram/user_memory.h
[binary or diff unavailable]

### src/tasks/background_task.c
[binary or diff unavailable]

### src/tasks/cmd_task.c
[binary or diff unavailable]

### src/tasks/data_parser_task.c
[binary or diff unavailable]

### src/tasks/fetch_sensitive_data_task.c
[binary or diff unavailable]

### src/tasks/mpu_sandbox_internal.h
[binary or diff unavailable]

### src/tasks/mpu_sandbox_runtime.c
[binary or diff unavailable]

### src/tasks/mpu_sandbox_task.c
[binary or diff unavailable]

### src/tasks/mpu_sandbox_task.h
[binary or diff unavailable]

### src/tasks/mpu_sandbox_ur_validator.h
[binary or diff unavailable]

### src/tasks/qrdecode_task.c
[binary or diff unavailable]

### src/tasks/ui_display_task.c
[binary or diff unavailable]

### src/tasks/usb_task.c
[binary or diff unavailable]

### src/tasks/watchdog_task.c
[binary or diff unavailable]

### src/tasks/watchdog_task.h
[binary or diff unavailable]

### src/ui/gui_analyze/gui_analyze.c
[binary or diff unavailable]

### src/ui/gui_analyze/multi/web3/gui_general_analyze.c
[binary or diff unavailable]

### src/ui/gui_analyze/multi/web3/gui_general_analyze.h
[binary or diff unavailable]

### src/ui/gui_assets/abi/abi_ethereum.c
[binary or diff unavailable]

### src/ui/gui_assets/font/cn/cnIllustrate.c
[binary or diff unavailable]

### src/ui/gui_assets/font/cn/cnLittleTitle.c
[binary or diff unavailable]

### src/ui/gui_assets/font/cn/cnText.c
[binary or diff unavailable]

### src/ui/gui_assets/font/cn/cnTitle.c
[binary or diff unavailable]

### src/ui/gui_assets/font/de/deIllustrate.c
[binary or diff unavailable]

### src/ui/gui_assets/font/es/esIllustrate.c
[binary or diff unavailable]

### src/ui/gui_assets/font/ja/jaIllustrate.c
[binary or diff unavailable]

### src/ui/gui_assets/font/ja/jaLittleTitle.c
[binary or diff unavailable]

### src/ui/gui_assets/font/ja/jaText.c
[binary or diff unavailable]

### src/ui/gui_assets/font/ja/jaTitle.c
[binary or diff unavailable]

### src/ui/gui_assets/font/ko/koIllustrate.c
[binary or diff unavailable]

### src/ui/gui_assets/font/ko/koLittleTitle.c
[binary or diff unavailable]

### src/ui/gui_assets/font/ko/koText.c
[binary or diff unavailable]

### src/ui/gui_assets/font/ko/koTitle.c
[binary or diff unavailable]

### src/ui/gui_assets/font/ru/ruIllustrate.c
[binary or diff unavailable]

### src/ui/gui_assets/wallet/walletBeacon.c
[binary or diff unavailable]

### src/ui/gui_chain/gui_btc.c
[binary or diff unavailable]

### src/ui/gui_chain/gui_chain.c
[binary or diff unavailable]

### src/ui/gui_chain/gui_chain.h
[binary or diff unavailable]

### src/ui/gui_chain/gui_chain_components.c
[binary or diff unavailable]

### src/ui/gui_chain/gui_chain_components.h
[binary or diff unavailable]

### src/ui/gui_chain/multi/cypherpunk/gui_monero.c
[binary or diff unavailable]

### src/ui/gui_chain/multi/web3/gui_ada.c
[binary or diff unavailable]

### src/ui/gui_chain/multi/web3/gui_ada.h
[binary or diff unavailable]

### src/ui/gui_chain/multi/web3/gui_ar.c
[binary or diff unavailable]

### src/ui/gui_chain/multi/web3/gui_ar.h
[binary or diff unavailable]

### src/ui/gui_chain/multi/web3/gui_cosmos.c
[binary or diff unavailable]

### src/ui/gui_chain/multi/web3/gui_eth.c
[binary or diff unavailable]

### src/ui/gui_chain/multi/web3/gui_iota.c
[binary or diff unavailable]

### src/ui/gui_chain/multi/web3/gui_iota.h
[binary or diff unavailable]

### src/ui/gui_chain/multi/web3/gui_sol.c
[binary or diff unavailable]

### src/ui/gui_chain/multi/web3/gui_stellar.c
[binary or diff unavailable]

### src/ui/gui_chain/multi/web3/gui_sui.c
[binary or diff unavailable]

### src/ui/gui_chain/multi/web3/gui_ton.c
[binary or diff unavailable]

### src/ui/gui_chain/multi/web3/gui_xrp.c
[binary or diff unavailable]

### src/ui/gui_components/gui_attention_hintbox.c
[binary or diff unavailable]

### src/ui/gui_components/gui_attention_hintbox.h
[binary or diff unavailable]

### src/ui/gui_components/gui_hintbox.c
[binary or diff unavailable]

### src/ui/gui_components/gui_hintbox.h
[binary or diff unavailable]

### src/ui/gui_components/gui_keyboard_hintbox.c
[binary or diff unavailable]

### src/ui/gui_components/gui_mnemonic_input.c
[binary or diff unavailable]

### src/ui/gui_components/gui_status_bar.c
[binary or diff unavailable]

### src/ui/gui_frame/gui_framework.c
[binary or diff unavailable]

### src/ui/gui_frame/gui_resource.h
[binary or diff unavailable]

### src/ui/gui_model/gui_model.c
[binary or diff unavailable]

### src/ui/gui_model/gui_model.h
[binary or diff unavailable]

### src/ui/gui_views/btc_only/multi_sig/gui_import_multisig_wallet_info_view.c
[binary or diff unavailable]

### src/ui/gui_views/btc_only/multi_sig/gui_manage_multisig_wallet_view.c
[binary or diff unavailable]

### src/ui/gui_views/gui_connect_wallet_view.c
[binary or diff unavailable]

### src/ui/gui_views/gui_firmware_update_view.c
[binary or diff unavailable]

### src/ui/gui_views/gui_forget_pass_view.c
[binary or diff unavailable]

### src/ui/gui_views/gui_home_view.c
[binary or diff unavailable]

### src/ui/gui_views/gui_init_view.c
[binary or diff unavailable]

### src/ui/gui_views/gui_setting_view.c
[binary or diff unavailable]

### src/ui/gui_views/gui_system_setting_view.c
[binary or diff unavailable]

### src/ui/gui_views/gui_transaction_detail_view.c
[binary or diff unavailable]

### src/ui/gui_views/gui_transaction_signature_view.c
[binary or diff unavailable]

### src/ui/gui_views/gui_views.c
[binary or diff unavailable]

### src/ui/gui_views/gui_views.h
[binary or diff unavailable]

### src/ui/gui_views/multi/cypherpunk/gui_zcash_batch_view.c
[binary or diff unavailable]

### src/ui/gui_views/multi/gui_key_derivation_request_view.c
[binary or diff unavailable]

### src/ui/gui_views/multi/gui_standard_receive_view.c
[binary or diff unavailable]

### src/ui/gui_views/multi/web3/gui_derive_context_hash_request_view.c
[binary or diff unavailable]

### src/ui/gui_views/multi/web3/gui_eth_batch_tx_view.c
[binary or diff unavailable]

### src/ui/gui_wallet/multi/web3/gui_wallet.c
[binary or diff unavailable]

### src/ui/gui_wallet/multi/web3/gui_wallet.h
[binary or diff unavailable]

### src/ui/gui_widgets/btc_only/multi_sig/gui_import_multisig_wallet_info_widgets.c
[binary or diff unavailable]

### src/ui/gui_widgets/btc_only/multi_sig/gui_manage_multisig_wallet_widgets.c
[binary or diff unavailable]

### src/ui/gui_widgets/btc_only/multi_sig/gui_multisig_wallet_export_widgets.c
[binary or diff unavailable]

### src/ui/gui_widgets/gui_about_info_widgets.c
[binary or diff unavailable]

### src/ui/gui_widgets/gui_connect_wallet_widgets.h
[binary or diff unavailable]

### src/ui/gui_widgets/gui_create_share_widgets.c
[binary or diff unavailable]

### src/ui/gui_widgets/gui_create_wallet_widgets.c
[binary or diff unavailable]

### src/ui/gui_widgets/gui_device_public_key_widgets.c
[binary or diff unavailable]

### src/ui/gui_widgets/gui_dice_rolls_widgets.c
[binary or diff unavailable]

### src/ui/gui_widgets/gui_export_pubkey_widgets.c
[binary or diff unavailable]

### src/ui/gui_widgets/gui_firmware_update_widgets.c
[binary or diff unavailable]

### src/ui/gui_widgets/gui_import_phrase_widgets.c
[binary or diff unavailable]

### src/ui/gui_widgets/gui_import_share_widgets.c
[binary or diff unavailable]

### src/ui/gui_widgets/gui_init_widgets.c
[binary or diff unavailable]

### src/ui/gui_widgets/gui_lock_device_widgets.c
[binary or diff unavailable]

### src/ui/gui_widgets/gui_lock_widgets.c
[binary or diff unavailable]

### src/ui/gui_widgets/gui_nft_screen_widgets.c
[binary or diff unavailable]

### src/ui/gui_widgets/gui_nft_screen_widgets.h
[binary or diff unavailable]

### src/ui/gui_widgets/gui_pop_message_box.h
[binary or diff unavailable]

### src/ui/gui_widgets/gui_scan_widgets.c
[binary or diff unavailable]

### src/ui/gui_widgets/gui_scan_widgets.h
[binary or diff unavailable]

### src/ui/gui_widgets/gui_select_address_widgets.c
[binary or diff unavailable]

### src/ui/gui_widgets/gui_single_phrase_widgets.c
[binary or diff unavailable]

### src/ui/gui_widgets/gui_system_setting_widgets.c
[binary or diff unavailable]

### src/ui/gui_widgets/gui_system_setting_widgets.h
[binary or diff unavailable]

### src/ui/gui_widgets/gui_trans_nft_process_widgets.c
[binary or diff unavailable]

### src/ui/gui_widgets/gui_trans_nft_process_widgets.h
[binary or diff unavailable]

### src/ui/gui_widgets/gui_transaction_detail_widgets.c
[binary or diff unavailable]

### src/ui/gui_widgets/gui_utxo_receive_widgets.c
[binary or diff unavailable]

### src/ui/gui_widgets/gui_wallet_tutorial_widgets.c
[binary or diff unavailable]

### src/ui/gui_widgets/gui_wallet_tutorial_widgets.h
[binary or diff unavailable]

### src/ui/gui_widgets/gui_web_auth_result_widgets.c
[binary or diff unavailable]

### src/ui/gui_widgets/gui_wipe_device_widgets.c
[binary or diff unavailable]

### src/ui/gui_widgets/multi/gui_change_path_type_widgets.c
[binary or diff unavailable]

### src/ui/gui_widgets/multi/gui_home_widgets.h
[binary or diff unavailable]

### src/ui/gui_widgets/multi/gui_key_derivation_request_widgets.c
[binary or diff unavailable]

### src/ui/gui_widgets/multi/gui_multi_accounts_receive_widgets.c
[binary or diff unavailable]

### src/ui/gui_widgets/multi/gui_standard_receive_widgets.c
[binary or diff unavailable]

### src/ui/gui_widgets/multi/gui_standard_receive_widgets.h
[binary or diff unavailable]

### src/ui/gui_widgets/multi/gui_usb_transport_widgets.c
[binary or diff unavailable]

### src/ui/gui_widgets/multi/web3/gui_connect_wallet_widgets.c
[binary or diff unavailable]

### src/ui/gui_widgets/multi/web3/gui_derive_context_hash_request_widgets.c
[binary or diff unavailable]

### src/ui/gui_widgets/multi/web3/gui_eth_batch_tx_widgets.c
[binary or diff unavailable]

### src/ui/gui_widgets/multi/web3/gui_general_home_widgets.c
[binary or diff unavailable]

### src/ui/gui_widgets/multi/web3/gui_multi_path_coin_receive_widgets.c
[binary or diff unavailable]

### src/ui/gui_widgets/setting/gui_fingerprint_widgets.c
[binary or diff unavailable]

### src/ui/lv_i18n/data.csv
[binary or diff unavailable]

### src/ui/lv_i18n/data_loader.py
[binary or diff unavailable]

### src/ui/lv_i18n/get_font_contain.py
[binary or diff unavailable]

### src/ui/lv_i18n/lv_i18n.c
[binary or diff unavailable]

### src/user_fatfs.c
[binary or diff unavailable]

### src/user_sqlite3.c
[binary or diff unavailable]

### src/utils/assert.c
[binary or diff unavailable]

### src/utils/log/log.c
[binary or diff unavailable]

### src/utils/log/log_print.c
[binary or diff unavailable]

### src/utils/log/log_print.h
[binary or diff unavailable]

### src/utils/user_utils.c
[binary or diff unavailable]

### src/utils/user_utils.h
[binary or diff unavailable]

### src/webusb_protocol/general/eapdu_framing.c
[binary or diff unavailable]

### src/webusb_protocol/general/eapdu_framing.h
[binary or diff unavailable]

### src/webusb_protocol/general/eapdu_protocol_parser.c
[binary or diff unavailable]

### src/webusb_protocol/general/eapdu_protocol_parser.h
[binary or diff unavailable]

### src/webusb_protocol/general/eapdu_services/service_export_address.c
[binary or diff unavailable]

### src/webusb_protocol/general/eapdu_services/service_resolve_ur.c
[binary or diff unavailable]

### src/webusb_protocol/general/eapdu_services/service_resolve_ur.h
[binary or diff unavailable]

### src/webusb_protocol/general/eapdu_services/service_trans_usb_pubkey.c
[binary or diff unavailable]

### src/webusb_protocol/internal_protocol_parser.c
[binary or diff unavailable]

### src/webusb_protocol/protocol_codec.c
[binary or diff unavailable]