Esp32 C3 UART driver (#6214)

* Use FreeRTOS wrapper

* Add console driver

* Add patch, .config. Update readme.

* Change date

12 files changed, 15625 insertions, 419 deletions

diff --git a/bsp/ESP32_C3/.config b/bsp/ESP32_C3/.config
index 1c191aced3..6ad0fb6b9f 100644
--- a/bsp/ESP32_C3/.config
+++ b/bsp/ESP32_C3/.config
@@ -62,7 +62,9 @@ CONFIG_RT_USING_HEAP=y
 CONFIG_RT_USING_DEVICE=y
 # CONFIG_RT_USING_DEVICE_OPS is not set
 # CONFIG_RT_USING_INTERRUPT_INFO is not set
-# CONFIG_RT_USING_CONSOLE is not set
+CONFIG_RT_USING_CONSOLE=y
+CONFIG_RT_CONSOLEBUF_SIZE=256
+CONFIG_RT_CONSOLE_DEVICE_NAME="uart"
 CONFIG_RT_VER_NUM=0x40101
 # CONFIG_RT_USING_CPU_FFS is not set
 # CONFIG_ARCH_CPU_STACK_GROWS_UPWARD is not set
@@ -73,7 +75,21 @@ CONFIG_RT_VER_NUM=0x40101
 CONFIG_RT_USING_COMPONENTS_INIT=y
 # CONFIG_RT_USING_USER_MAIN is not set
 # CONFIG_RT_USING_LEGACY is not set
-# CONFIG_RT_USING_MSH is not set
+CONFIG_RT_USING_MSH=y
+CONFIG_RT_USING_FINSH=y
+CONFIG_FINSH_USING_MSH=y
+CONFIG_FINSH_THREAD_NAME="tshell"
+CONFIG_FINSH_THREAD_PRIORITY=20
+CONFIG_FINSH_THREAD_STACK_SIZE=4096
+CONFIG_FINSH_USING_HISTORY=y
+CONFIG_FINSH_HISTORY_LINES=5
+CONFIG_FINSH_USING_SYMTAB=y
+CONFIG_FINSH_CMD_SIZE=80
+CONFIG_MSH_USING_BUILT_IN_COMMANDS=y
+CONFIG_FINSH_USING_DESCRIPTION=y
+# CONFIG_FINSH_ECHO_DISABLE_DEFAULT is not set
+# CONFIG_FINSH_USING_AUTH is not set
+CONFIG_FINSH_ARG_MAX=10
 # CONFIG_RT_USING_DFS is not set
 # CONFIG_RT_USING_FAL is not set
 
@@ -82,7 +98,11 @@ CONFIG_RT_USING_COMPONENTS_INIT=y
 #
 CONFIG_RT_USING_DEVICE_IPC=y
 # CONFIG_RT_USING_SYSTEM_WORKQUEUE is not set
-# CONFIG_RT_USING_SERIAL is not set
+CONFIG_RT_USING_SERIAL=y
+CONFIG_RT_USING_SERIAL_V1=y
+# CONFIG_RT_USING_SERIAL_V2 is not set
+# CONFIG_RT_SERIAL_USING_DMA is not set
+CONFIG_RT_SERIAL_RB_BUFSZ=64
 # CONFIG_RT_USING_CAN is not set
 # CONFIG_RT_USING_HWTIMER is not set
 # CONFIG_RT_USING_CPUTIME is not set
@@ -620,9 +640,12 @@ CONFIG_BSP_BOARD_LUATOS_ESP32C3=y
 # Onboard Peripheral Drivers
 #
 CONFIG_RT_BSP_LED_PIN=12
+CONFIG_RT_BSP_UART_PORT=0
+CONFIG_RT_BSP_UART_TX_PIN=21
+CONFIG_RT_BSP_UART_RX_PIN=20
 
 #
 # On-chip Peripheral Drivers
 #
 CONFIG_BSP_USING_GPIO=y
-# CONFIG_BSP_USING_UART is not set
+CONFIG_BSP_USING_UART=y
diff --git a/bsp/ESP32_C3/0001-add-the-config-of-RTTHREAD.patch b/bsp/ESP32_C3/0001-add-the-config-of-RTTHREAD.patch
deleted file mode 100644
index d1f2d6ae5a..0000000000
--- a/bsp/ESP32_C3/0001-add-the-config-of-RTTHREAD.patch
+++ /dev/null
@@ -1,393 +0,0 @@
-From 317ee995e9d530587bfb14439b3b1ee38d1afe77 Mon Sep 17 00:00:00 2001
-From: supperthomas <[email protected]>
-Date: Fri, 6 May 2022 23:06:28 +0800
-Subject: [PATCH] add the config of RTTHREAD
-
-add the init link file
----
- Kconfig                                       |   4 +
- .../esp_system/ld/esp32c3/sections.ld.in      |  26 +++
- components/freertos/port/port_common.c        |   5 +
- components/freertos/port/port_systick.c       |   3 +
- components/riscv/vectors.S                    | 220 ++++++++++++++++--
- 5 files changed, 239 insertions(+), 19 deletions(-)
-
-diff --git a/Kconfig b/Kconfig
-index 928d274106..d368adaa37 100644
---- a/Kconfig
-+++ b/Kconfig
-@@ -61,6 +61,10 @@ mainmenu "Espressif IoT Development Framework Configuration"
-         bool
-         default "y" if IDF_TARGET="linux"
- 
-+    config IDF_RTOS_RTTHREAD
-+        bool "RT-THREAD SELECT"
-+        default "n" 
-+
-     config IDF_FIRMWARE_CHIP_ID
-         hex
-         default 0x0000 if IDF_TARGET_ESP32
-diff --git a/components/esp_system/ld/esp32c3/sections.ld.in b/components/esp_system/ld/esp32c3/sections.ld.in
-index 0ebeda06c1..8215237fff 100644
---- a/components/esp_system/ld/esp32c3/sections.ld.in
-+++ b/components/esp_system/ld/esp32c3/sections.ld.in
-@@ -183,6 +183,32 @@ SECTIONS
-     _noinit_end = ABSOLUTE(.);
-   } > dram0_0_seg
- 
-+  .stack_dummy (COPY):
-+  {
-+      . = ALIGN(8);
-+       __STACKSIZE__ = 40960; 
-+      __stack_start__ = .;
-+      *(.stack*)
-+      . += __STACKSIZE__;
-+      __stack_cpu0 = .;
-+      __stack_end__ = .;
-+  } > dram0_0_seg
-+
-+  .stack_dummy (COPY):
-+  {
-+      . = ALIGN(8);
-+       __HEAPSIZE__ = 40960; 
-+      __heap_start__ = .;
-+      . += __STACKSIZE__;
-+      __heap_end__ = .;
-+        /* section information for initial. */
-+        . = ALIGN(4);
-+        __rt_init_start = .;
-+        KEEP(*(SORT(.rti_fn*)))
-+        __rt_init_end = .;
-+
-+        . = ALIGN(4);
-+  } > dram0_0_seg
-   /* Shared RAM */
-   .dram0.bss (NOLOAD) :
-   {
-diff --git a/components/freertos/port/port_common.c b/components/freertos/port/port_common.c
-index ffca3d5429..9d8159f588 100644
---- a/components/freertos/port/port_common.c
-+++ b/components/freertos/port/port_common.c
-@@ -74,11 +74,16 @@ void esp_startup_start_app_common(void)
-     esp_gdbstub_init();
- #endif // CONFIG_ESP_SYSTEM_GDBSTUB_RUNTIME
- 
-+#ifdef CONFIG_IDF_RTOS_RTTHREAD
-+    app_main();
-+#else
-     portBASE_TYPE res = xTaskCreatePinnedToCore(&main_task, "main",
-                                                 ESP_TASK_MAIN_STACK, NULL,
-                                                 ESP_TASK_MAIN_PRIO, NULL, ESP_TASK_MAIN_CORE);
-     assert(res == pdTRUE);
-     (void)res;
-+#endif
-+
- }
- 
- static void main_task(void* args)
-diff --git a/components/freertos/port/port_systick.c b/components/freertos/port/port_systick.c
-index 0c14a155a1..0fa203574b 100644
---- a/components/freertos/port/port_systick.c
-+++ b/components/freertos/port/port_systick.c
-@@ -116,6 +116,8 @@ void vPortSetupTimer(void)
-  */
- IRAM_ATTR void SysTickIsrHandler(void *arg)
- {
-+#ifdef CONFIG_IDF_RTOS_RTTHREAD
-+#else
-     uint32_t cpuid = xPortGetCoreID();
-     systimer_hal_context_t *systimer_hal = (systimer_hal_context_t *)arg;
- #ifdef CONFIG_PM_TRACE
-@@ -144,6 +146,7 @@ IRAM_ATTR void SysTickIsrHandler(void *arg)
- #ifdef CONFIG_PM_TRACE
-     ESP_PM_TRACE_EXIT(TICK, cpuid);
- #endif
-+#endif
- }
- 
- #endif // CONFIG_FREERTOS_SYSTICK_USES_CCOUNT
-diff --git a/components/riscv/vectors.S b/components/riscv/vectors.S
-index 1006d5bea5..963494fcb3 100644
---- a/components/riscv/vectors.S
-+++ b/components/riscv/vectors.S
-@@ -17,6 +17,9 @@
- #include "soc/soc_caps.h"
- #include "sdkconfig.h"
- 
-+#define STORE                   sw
-+#define LOAD                    lw
-+#define REGBYTES                4
- 
- 	.equ SAVE_REGS, 32
- 	.equ CONTEXT_SIZE, (SAVE_REGS * 4)
-@@ -218,25 +221,27 @@ _call_panic_handler:
- 	 */
- 	.global _interrupt_handler
- 	.type _interrupt_handler, @function
-+#ifndef CONFIG_IDF_RTOS_RTTHREAD
-+
- _interrupt_handler:
- 	/* entry */
--	save_regs
--	save_mepc
-+	save_regs   /* 保存寄存器 */
-+	save_mepc   /* 保存MEPC */
- 
- 	/* Before doing anythig preserve the stack pointer */
- 	/* It will be saved in current TCB, if needed */
--	mv a0, sp
-+	mv a0, sp            /* 保存SP  a0 = sp */
- 	call rtos_int_enter
- 
- 	/* Before dispatch c handler, restore interrupt to enable nested intr */
--	csrr s1, mcause
--	csrr s2, mstatus
-+	csrr s1, mcause    /* 保存mcause s1 = mcause */
-+	csrr s2, mstatus  /* 保存mstatus  s2 = mstatus */
- 
--	/* Save the interrupt threshold level */
--	la t0, INTERRUPT_CORE0_CPU_INT_THRESH_REG
--	lw s3, 0(t0)
-+	/* Save the interrupt threshold level 保存中断嵌套层数? */
-+	la t0, INTERRUPT_CORE0_CPU_INT_THRESH_REG  /* 保存mstatus  t0 = &INTERRUPT_CORE0_CPU_INT_THRESH_REG */
-+	lw s3, 0(t0)    /*   s3 = mstatus */
- 
--	/* Increase interrupt threshold level */
-+	/* Increase interrupt threshold level 增加中断嵌套层数*/
- 	li t2, 0x7fffffff
- 	and t1, s1, t2		/* t1 = mcause & mask */
- 	slli t1, t1, 2 		/* t1 = mcause * 4 */
-@@ -247,8 +252,8 @@ _interrupt_handler:
- 	sw t2, 0(t0)		/* INTERRUPT_CORE0_CPU_INT_THRESH_REG = t2 */
- 	fence
- 
--	li t0, 0x8
--	csrrs t0, mstatus, t0
-+	li t0, 0x8   /* t0 = 8 */
-+	csrrs t0, mstatus, t0    /*设置状态MIE寄存器，开总中断*/
- 
- 	#ifdef CONFIG_PM_TRACE
- 	li      a0, 0       /* = ESP_PM_TRACE_IDLE */
-@@ -269,34 +274,211 @@ _interrupt_handler:
- 	/* call the C dispatcher */
- 	mv      a0, sp      /* argument 1, stack pointer */
- 	mv      a1, s1      /* argument 2, interrupt number (mcause) */
--	/* mask off the interrupt flag of mcause */
-+	/* mask off the interrupt flag of mcause   屏幕异常中断*/
- 	li	    t0, 0x7fffffff
- 	and     a1, a1, t0
- 	jal     _global_interrupt_handler
- 
--	/* After dispatch c handler, disable interrupt to make freertos make context switch */
-+	/* After dispatch c handler, disable interrupt to make freertos make context switch 
-+	在调用c函数之后，disable 中断让freertos能够做内容切换
-+	*/
- 
- 	li t0, 0x8
--	csrrc t0, mstatus, t0
-+	csrrc t0, mstatus, t0  /*清状态MIE寄存器 关总中断*/
- 
--	/* restore the interrupt threshold level */
-+
-+	/* restore the interrupt threshold level  中断嵌套 */
- 	la t0, INTERRUPT_CORE0_CPU_INT_THRESH_REG
- 	sw s3, 0(t0)
- 	fence
- 
- 	/* Yield to the next task is needed: */
--	mv a0, sp
-+	mv a0, sp     /* a0 = sp*/
- 	call rtos_int_exit
- 
- 	/* The next (or current) stack pointer is returned in a0 */
--	mv sp, a0
-+	mv sp, a0    /* sp = a0*/
- 
- 	/* restore the rest of the registers */
--	csrw mcause, s1
--	csrw mstatus, s2
-+	csrw mcause, s1  /* mcause = s1 */
-+	csrw mstatus, s2   /* mstatus = s2 */
- 	restore_mepc
- 	restore_regs
- 
- 	/* exit, this will also re-enable the interrupts */
- 	mret
- 	.size  _interrupt_handler, .-_interrupt_handler
-+#else
-+_interrupt_handler:
-+    /* 此时CPU的sp = from_thread->sp */
-+    /* 注意： 在这里，并没有将mepc的值赋值为from_thread栈中的epc，但后面会赋值 */
-+    addi sp, sp, -32 * REGBYTES             /* sp = sp - 32 * 4 栈指针向下偏移32个寄存器长度，用来将CPU的寄存器保存到from_thread的栈中*/
-+    STORE x1,   1 * REGBYTES(sp)            /* 将CPU的x1寄存器，即ra寄存器，保存到from_thread->栈中 */
-+
-+    li    t0,   0x80                        /* t0 = 0x80 */
-+    STORE t0,   2 * REGBYTES(sp)            /* mstatus = t0, 即关闭全局中断 */
-+
-+    /* 将 CPU 的其他寄存器的值，保存到from_thread的任务栈中 */
-+    STORE x4,   4 * REGBYTES(sp)
-+    STORE x5,   5 * REGBYTES(sp)
-+    STORE x6,   6 * REGBYTES(sp)
-+    STORE x7,   7 * REGBYTES(sp)
-+    STORE x8,   8 * REGBYTES(sp)
-+    STORE x9,   9 * REGBYTES(sp)
-+    STORE x10, 10 * REGBYTES(sp)
-+    STORE x11, 11 * REGBYTES(sp)
-+    STORE x12, 12 * REGBYTES(sp)
-+    STORE x13, 13 * REGBYTES(sp)
-+    STORE x14, 14 * REGBYTES(sp)
-+    STORE x15, 15 * REGBYTES(sp)
-+    STORE x16, 16 * REGBYTES(sp)
-+    STORE x17, 17 * REGBYTES(sp)
-+    STORE x18, 18 * REGBYTES(sp)
-+    STORE x19, 19 * REGBYTES(sp)
-+    STORE x20, 20 * REGBYTES(sp)
-+    STORE x21, 21 * REGBYTES(sp)
-+    STORE x22, 22 * REGBYTES(sp)
-+    STORE x23, 23 * REGBYTES(sp)
-+    STORE x24, 24 * REGBYTES(sp)
-+    STORE x25, 25 * REGBYTES(sp)
-+    STORE x26, 26 * REGBYTES(sp)
-+    STORE x27, 27 * REGBYTES(sp)
-+    STORE x28, 28 * REGBYTES(sp)
-+    STORE x29, 29 * REGBYTES(sp)
-+    STORE x30, 30 * REGBYTES(sp)
-+    STORE x31, 31 * REGBYTES(sp)
-+
-+    /* 备份 CPU 的 sp (这时，CPU的sp其实就是from thread的sp指针) 寄存器的值到 s0 寄存器中，下面会使用s0，恢复 CPU 的寄存器 */
-+    move  s0, sp    /* s0 = sp */
-+
-+    /* 在中断函数中，中断函数中调用的C函数，需要使用 sp， 这里，在中断函数中，使用的 sp 为，系统的栈资源 */
-+    /* switch to interrupt stack */
-+    la    sp, __stack_end__   /* sp = _sp */
-+
-+    /* interrupt handle */
-+    /* 注意： 在调用C函数之前,比如sp的值为0x30001000, 在执行完C函数后，sp的值还是会变成 0x30001000 */
-+    call  rt_interrupt_enter    /* 执行所有的中断函数前，调用该函数 */
-+
-+    csrr s1, mcause
-+	csrr s2, mstatus
-+
-+    /* Save the interrupt threshold level */
-+	la t0, INTERRUPT_CORE0_CPU_INT_THRESH_REG
-+	lw s3, 0(t0)
-+
-+    li t2, 0x7fffffff
-+	and t1, s1, t2		/* t1 = mcause & mask */
-+	slli t1, t1, 2 		/* t1 = mcause * 4 */
-+	la t2, INTC_INT_PRIO_REG(0)
-+	add t1, t2, t1		/* t1 = INTC_INT_PRIO_REG + 4 * mcause */
-+	lw t2, 0(t1)		/* t2 = INTC_INT_PRIO_REG[mcause] */
-+	addi t2, t2, 1		/* t2 = t2 +1 */
-+	sw t2, 0(t0)		/* INTERRUPT_CORE0_CPU_INT_THRESH_REG = t2 */
-+	fence
-+
-+    li t0, 0x8
-+	csrrs t0, mstatus, t0
-+
-+    /* call the C dispatcher */
-+	mv      a0, sp      /* argument 1, stack pointer */
-+	mv      a1, s1      /* argument 2, interrupt number (mcause) */
-+	/* mask off the interrupt flag of mcause */
-+	li	    t0, 0x7fffffff
-+	and     a1, a1, t0
-+	jal     _global_interrupt_handler
-+
-+    li t0, 0x8
-+	csrrc t0, mstatus, t0
-+
-+	/* restore the interrupt threshold level */
-+	la t0, INTERRUPT_CORE0_CPU_INT_THRESH_REG
-+	sw s3, 0(t0)
-+	fence
-+
-+    call  rt_interrupt_leave    /* 执行所有的中断函数后，调用该函数 */
-+
-+    /* 上面，将保存执行中断服务函数之前的CPU的sp寄存器到了s0所指向的位置处，当执行完中断服务函数，需要将之前的CPU寄存器，恢复一下,此时sp又变成了from thread的sp了 */
-+    move  sp, s0    /* sp = s0 */
-+
-+    /* 下面两句话，相当于将 rt_thread_switch_interrupt_flag 值，赋值给了s2  */
-+    /* 将 rt_thread_switch_interrupt_flag 的地址值，赋值给 s0 寄存器*/
-+    la    s0, rt_thread_switch_interrupt_flag       /* s0 = &rt_thread_switch_interrupt_flag */
-+    /* 将 s0 所指向的地址处的内容，取出来，赋值给 s2 寄存器，其实就是将  rt_thread_switch_interrupt_flag 的值，赋值给了 s2 寄存器*/
-+    lw    s2, 0(s0)                 /* s2 = *s0 = rt_thread_switch_interrupt_flag */
-+
-+    /* 如果 s2的值，即 rt_thread_switch_interrupt_flag 值，如果不为0，则需要继续执行下一条指令，如果为0，则需要跳转到 spurious_interrupt 标号处 执行 */
-+    /* 如果 s2的值等于0，rt_thread_switch_interrupt_flag等于0， 则不需要在中断处理函数中，进行上下文切换，反之则需要 */
-+    /* 如果不需要上下文切换， */
-+
-+    /* 在这里，跳转到 spurious_interrupt的话，是不会进行上下文切换的，因为，此时CPU的sp指针还是from线程的*/
-+    beqz  s2, spurious_interrupt    /* if (s2 == 0) goto spurious_interrupt; else 执行下一条语句*/
-+
-+    /* 需要上下文切换： 主要目的是将CPU的sp指针，赋值为to_thread的sp */
-+    
-+    /* 将 s0 所执向的地址的内容设置为0， 也就是，将变量 rt_thread_switch_interrupt_flag 赋值为了 0 */
-+    /* s0存放的值是 rt_thread_switch_interrupt_flag 变量的地址*/
-+    sw    zero, 0(s0)       /* *s0 = 0; 也就是 rt_thread_switch_interrupt_flag = 0 */
-+    /* 将 mepc 的值，赋值给 a0 寄存器，mepc 的值是，跳转到中断函数执行之前的 PC 指针 */
-+    /* 这时的mpec其实，还是from线程，在跳转到中断执行前的一个PC地址 */
-+    csrr  a0, mepc  /* a0 = mepc */
-+
-+    /* 将 mpec 的值写回到freom thread任务栈中的 epc 中,待后续，恢复from线程时，使用 */
-+    STORE a0, 0 * REGBYTES(sp)  /* from_thread->sp->epc = a0 ，中断入口处*/
-+
-+    /* 将from_thread的sp指针，赋值为CPU的sp指针 */
-+    la    s0, rt_interrupt_from_thread  /* s0 = &rt_interrupt_from_thread 注意： rt_interrupt_from_thread = &(from_thread->sp) */
-+    LOAD  s1, 0(s0)                     /* s1 = rt_interrupt_from_thread，也就是s1 = &(from_thread->sp) */
-+    STORE sp, 0(s1)                     /* from_thread->sp = sp*/
-+   
-+    /* 接下来，需要开始恢复CPU的sp为to_thread的sp了 */
-+    la    s0, rt_interrupt_to_thread    /* s0 = &rt_interrupt_to_thread 注意： rt_interrupt_to_thread = &(to_thred->sp)*/
-+    LOAD  s1, 0(s0)                     /* s1 = rt_interrupt_to_thread, 也就是s1 = &(to_thred->sp) */
-+    LOAD  sp, 0(s1)                     /* sp = (to_thred->sp)*/
-+
-+    /* 将CPU的 mepc设置为to_thred的mepc，待中断退出，执行mret指令后，将从该地址开始执行 */
-+    LOAD  a0,  0 * REGBYTES(sp)         /* a0 = to_thread的mepc的值*/
-+    csrw  mepc, a0                      /* mepc = a0 */
-+
-+
-+spurious_interrupt:
-+    LOAD  x1,   1 * REGBYTES(sp)
-+
-+    /* Remain in M-mode after mret */
-+    li    t0, 0x00001800
-+    csrs  mstatus, t0
-+    LOAD  t0,   2 * REGBYTES(sp)
-+    csrs  mstatus, t0
-+
-+    LOAD  x4,   4 * REGBYTES(sp)
-+    LOAD  x5,   5 * REGBYTES(sp)
-+    LOAD  x6,   6 * REGBYTES(sp)
-+    LOAD  x7,   7 * REGBYTES(sp)
-+    LOAD  x8,   8 * REGBYTES(sp)
-+    LOAD  x9,   9 * REGBYTES(sp)
-+    LOAD  x10, 10 * REGBYTES(sp)
-+    LOAD  x11, 11 * REGBYTES(sp)
-+    LOAD  x12, 12 * REGBYTES(sp)
-+    LOAD  x13, 13 * REGBYTES(sp)
-+    LOAD  x14, 14 * REGBYTES(sp)
-+    LOAD  x15, 15 * REGBYTES(sp)
-+    LOAD  x16, 16 * REGBYTES(sp)
-+    LOAD  x17, 17 * REGBYTES(sp)
-+    LOAD  x18, 18 * REGBYTES(sp)
-+    LOAD  x19, 19 * REGBYTES(sp)
-+    LOAD  x20, 20 * REGBYTES(sp)
-+    LOAD  x21, 21 * REGBYTES(sp)
-+    LOAD  x22, 22 * REGBYTES(sp)
-+    LOAD  x23, 23 * REGBYTES(sp)
-+    LOAD  x24, 24 * REGBYTES(sp)
-+    LOAD  x25, 25 * REGBYTES(sp)
-+    LOAD  x26, 26 * REGBYTES(sp)
-+    LOAD  x27, 27 * REGBYTES(sp)
-+    LOAD  x28, 28 * REGBYTES(sp)
-+    LOAD  x29, 29 * REGBYTES(sp)
-+    LOAD  x30, 30 * REGBYTES(sp)
-+    LOAD  x31, 31 * REGBYTES(sp)
-+
-+    addi  sp, sp, 32 * REGBYTES
-+    mret
-+	.size  _interrupt_handler, .-_interrupt_handler
-+#endif
--- 
-2.35.1.windows.2
-
diff --git a/bsp/ESP32_C3/README.md b/bsp/ESP32_C3/README.md
index 41b15b0dd0..491f0befe4 100644
--- a/bsp/ESP32_C3/README.md
+++ b/bsp/ESP32_C3/README.md
@@ -45,7 +45,7 @@
 | **片上外设**      | **支持情况** | **备注**                              |
 | :----------------- | :----------: | :------------------------------------- |
 | GPIO              |     支持     |  |
-| UART              |     支持中     |                                 |
+| UART              |     支持     | 使用LUATOS_ESP32C3开发板需要在UART0_TX和UART0_RX连接串口转USB芯片（如CP2102）|
 | JTAG调试          |     支持     | ESP32C3采用USB方式和PC链接的开发板可以调试                                |
 
 ## 使用说明
@@ -58,15 +58,15 @@ IDF的搭建方法有很多种，尝试了很多种方法之后，总结了一�
 
 ### ESP-IDF 添加RT-THREAD patch 
 
-由于IDF使用的是FREERTOS，如果需要使用rt-thread就需要修改一些文件。将`0001-add-the-config-of-RTTHREAD.patch` 这个文件拷贝到IDF的代码目录下面，然后在`git bash`命令行内执行命令下面几条命令就可以打上patch
+由于IDF使用的是FREERTOS，如果需要使用rt-thread就需要修改一些文件。将`rtt.patch` 这个文件拷贝到IDF的代码目录下面，然后在`git bash`命令行内执行命令下面几条命令就可以打上patch
 
 ```
 cd esp/esp-idf
 git checkout v4.4
-git am 0001-add-the-config-of-RTTHREAD.patch
+git am rtt.patch
 ```
 
-如果不想用patch文件，已经将代码上传到github上面，可以进入[supperthomas/esp-idf](https://github.com/supperthomas/esp-idf) 下载最新的master分支代码即可。修改之后的IDF，原来的IDF的example还是正常使用，互不干扰，可以放心使用。
+如果不想用patch文件，已经将代码上传到github上面，可以进入[tangzz98/esp-idf](https://github.com/tangzz98/esp-idf/tree/freertos_wrapper) 下载最新的freertos_wrapper分支代码即可。修改之后的IDF，原来的IDF的example还是正常使用，互不干扰，可以放心使用。
 
 #### 编译下载
 
diff --git a/bsp/ESP32_C3/board/Kconfig b/bsp/ESP32_C3/board/Kconfig
index c9cd6bc4f8..84b5b742e4 100644
--- a/bsp/ESP32_C3/board/Kconfig
+++ b/bsp/ESP32_C3/board/Kconfig
@@ -27,6 +27,21 @@ menu "Onboard Peripheral Drivers"
         default 8 if BSP_BOARD_HX_EXP32C3
         depends on BSP_USING_GPIO
 
+    config RT_BSP_UART_PORT
+        int "UART PORT SET"
+        default 0
+        depends on BSP_USING_UART
+
+    config RT_BSP_UART_TX_PIN
+        int "UART TX PIN SET"
+        default 21 if BSP_BOARD_LUATOS_ESP32C3
+        depends on BSP_USING_UART
+
+    config RT_BSP_UART_RX_PIN
+        int "UART RX PIN SET"
+        default 20 if BSP_BOARD_LUATOS_ESP32C3
+        depends on BSP_USING_UART
+
 endmenu
 
 
@@ -38,7 +53,9 @@ menu "On-chip Peripheral Drivers"
     
     config BSP_USING_UART
 		bool "Enable UART"
-        default n
+        select RT_USING_SERIAL
+        select RT_USING_SERIAL_V1
+        default y
 endmenu
 
 endmenu
diff --git a/bsp/ESP32_C3/main/CMakeLists.txt b/bsp/ESP32_C3/main/CMakeLists.txt
index fa49b82278..55b74d2117 100644
--- a/bsp/ESP32_C3/main/CMakeLists.txt
+++ b/bsp/ESP32_C3/main/CMakeLists.txt
@@ -1,5 +1,6 @@
 idf_component_register(SRCS "board.c" "main.c"
                     "drv_gpio.c"
+                    "drv_uart.c"
                     "../../../libcpu/risc-v/common/cpuport.c"
                     "../../../libcpu/risc-v/common/context_gcc.S"
                     "../../../src/components.c"
@@ -24,11 +25,18 @@ idf_component_register(SRCS "board.c" "main.c"
                     "../../../components/drivers/ipc/dataqueue.c"
                     "../../../components/drivers/ipc/ringbuffer.c"
                     "../../../components/drivers/ipc/workqueue.c"
+                    "../../../components/drivers/serial/serial.c"
+                    "../../../components/finsh/cmd.c"
+                    "../../../components/finsh/msh_file.c"
+                    "../../../components/finsh/msh_parse.c"
+                    "../../../components/finsh/msh.c"
+                    "../../../components/finsh/shell.c"
 
                     INCLUDE_DIRS 
                     "../../../components/drivers/include/drivers"
 
                     "../../../components/drivers/include"
+                    "../../../components/finsh"
                     "."
                     "../../../include" 
                     "../../../libcpu/risc-v/common" 
diff --git a/bsp/ESP32_C3/main/board.c b/bsp/ESP32_C3/main/board.c
index 994cdfe36d..9dd7c7725c 100644
--- a/bsp/ESP32_C3/main/board.c
+++ b/bsp/ESP32_C3/main/board.c
@@ -21,8 +21,8 @@
 #include "rtthread.h"
 #include "rthw.h"
 #include "drv_gpio.h"
-
-#define rt_kprintf printf
+#include "drv_uart.h"
+#include "shell.h"
 
 #ifdef RT_USING_COMPONENTS_INIT
 /*
@@ -190,16 +190,13 @@ void rt_hw_systick_init(void)
 void rt_hw_board_init(void)
 {
     rt_hw_systick_init();
-#if defined(RT_USING_HEAP)
-    extern int __heap_start__;
-    extern int __heap_end__;
-    printf("%s:%d__heap_start__:%p,__heap_end__:%p\n",__func__,__LINE__,&__heap_start__,&__heap_end__);
-    rt_system_heap_init((void *)&__heap_start__, (void *)&__heap_end__);
-#endif
     /* Board underlying hardware initialization */
 #ifdef RT_USING_COMPONENTS_INIT
     rt_components_board_init();
 #endif
+#if defined(RT_USING_CONSOLE) && defined(RT_USING_DEVICE)
+    rt_console_set_device(RT_CONSOLE_DEVICE_NAME);
+#endif
 }
 
 static void rtthread_startup(void)
@@ -207,15 +204,10 @@ static void rtthread_startup(void)
     rt_hw_interrupt_disable();
     /* init board */
     rt_hw_board_init();
-    /* show RT-Thread version */
-    rt_show_version();
 
     /* timer system initialization */
     rt_system_timer_init();
 
-    /* scheduler system initialization */
-    rt_system_scheduler_init();
-
     /* create init_thread */
     rt_application_init();
 
@@ -229,6 +221,8 @@ static void rtthread_startup(void)
     rt_system_scheduler_start();
     /* init scheduler system */
     rt_hw_pin_init();
+    rt_hw_uart_init();
+    finsh_system_init();
     /* never reach here */
     return ;
 }
diff --git a/bsp/ESP32_C3/main/drv_uart.c b/bsp/ESP32_C3/main/drv_uart.c
new file mode 100644
index 0000000000..f2bc7c486e
--- /dev/null
+++ b/bsp/ESP32_C3/main/drv_uart.c
@@ -0,0 +1,133 @@
+/*
+ * Copyright (c) 2006-2022, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2022-08-04     tangzz98     first version
+ *
+ */
+
+#include "drv_uart.h"
+
+#ifdef RT_USING_SERIAL_V1
+
+#ifdef CONFIG_UART_ISR_IN_IRAM
+#define UART_ISR_ATTR     IRAM_ATTR
+#else
+#define UART_ISR_ATTR
+#endif
+
+uart_hal_context_t hal[] = {
+    {
+        .dev = &UART0,
+    },
+    {
+        .dev = &UART1,
+    },
+};
+
+static struct rt_serial_device _serial;
+
+static void mcu_uart_rx_intr_handler(void *param)
+{
+    uint32_t uart_intr_status;
+    struct rt_serial_device *serial;
+    uart_port_t port;
+    rt_interrupt_enter();
+    serial = (struct rt_serial_device *)param;
+    port = (uart_port_t)serial->parent.user_data;
+    uart_intr_status = uart_hal_get_intsts_mask(&hal[port]);
+    if (uart_intr_status != 0)
+    {
+        if (uart_intr_status & UART_INTR_RXFIFO_FULL)
+        {
+            rt_hw_serial_isr(serial, RT_SERIAL_EVENT_RX_IND);
+        }
+        uart_hal_clr_intsts_mask(&hal[port], uart_intr_status);
+    }
+    rt_interrupt_leave();
+}
+
+static rt_err_t mcu_uart_configure(struct rt_serial_device *serial, struct serial_configure *cfg)
+{
+    return RT_EOK;
+}
+
+static rt_err_t mcu_uart_control(struct rt_serial_device *serial, int cmd, void *arg)
+{
+    return RT_EOK;
+}
+
+static int mcu_uart_putc(struct rt_serial_device *serial, char c)
+{
+    uart_port_t port = (uart_port_t)serial->parent.user_data;
+    uint32_t write_size = 0;
+    do
+    {
+        uart_hal_write_txfifo(&hal[port], (const uint8_t *)&c, 1, &write_size);
+    } while (write_size == 0);
+
+    return 1;
+}
+
+static int mcu_uart_getc(struct rt_serial_device *serial)
+{
+    uart_port_t port = (uart_port_t)serial->parent.user_data;
+    uint8_t c;
+    int len = uart_hal_get_rxfifo_len(&hal[port]);
+    if (len == 0)
+    {
+        return -1;
+    }
+    else
+    {
+        len = 1;
+        uart_hal_read_rxfifo(&hal[port], &c, &len);
+        return (int)c;
+    }
+}
+
+static const struct rt_uart_ops _uart_ops =
+{
+    mcu_uart_configure,
+    mcu_uart_control,
+    mcu_uart_putc,
+    mcu_uart_getc,
+    RT_NULL,
+};
+
+int rt_hw_uart_init(void)
+{
+    uart_intr_config_t uart_intr = {
+        .intr_enable_mask = UART_INTR_RXFIFO_FULL,
+        .rxfifo_full_thresh = 1,
+    };
+    struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;
+    uart_config_t uart_config = {
+        .baud_rate = BAUD_RATE_115200,
+        .data_bits = UART_DATA_8_BITS,
+        .parity    = UART_PARITY_DISABLE,
+        .stop_bits = UART_STOP_BITS_1,
+        .flow_ctrl = UART_HW_FLOWCTRL_DISABLE,
+        .source_clk = UART_SCLK_APB,
+    };
+    int intr_alloc_flags = 0;
+
+#if CONFIG_UART_ISR_IN_IRAM
+    intr_alloc_flags = ESP_INTR_FLAG_IRAM;
+#endif
+
+    ESP_ERROR_CHECK(uart_param_config(RT_BSP_UART_PORT, &uart_config));
+    ESP_ERROR_CHECK(uart_set_pin(RT_BSP_UART_PORT, RT_BSP_UART_TX_PIN, RT_BSP_UART_RX_PIN, UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE));
+    ESP_ERROR_CHECK(esp_intr_alloc(uart_periph_signal[RT_BSP_UART_PORT].irq, intr_alloc_flags, mcu_uart_rx_intr_handler, (void *)&_serial, NULL));
+    ESP_ERROR_CHECK(uart_intr_config(RT_BSP_UART_PORT, &uart_intr));
+    _serial.ops = &_uart_ops;
+    _serial.config = config;
+
+    return rt_hw_serial_register(&_serial, "uart", RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX, (void *)RT_BSP_UART_PORT);
+}
+INIT_BOARD_EXPORT(rt_hw_uart_init);
+
+#endif /* RT_USING_SERIAL_V1 */
diff --git a/bsp/ESP32_C3/main/drv_uart.h b/bsp/ESP32_C3/main/drv_uart.h
new file mode 100644
index 0000000000..26ee4ef30a
--- /dev/null
+++ b/bsp/ESP32_C3/main/drv_uart.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2006-2022, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2022-08-04     tangzz98     first version
+ *
+ */
+
+#ifndef __DRV_UART_H__
+#define __DRV_UART_H__
+
+#include <rtthread.h>
+#include <rthw.h>
+
+#ifdef RT_USING_DEVICE
+#include <rtdevice.h>
+#endif
+
+#include "driver/uart.h"
+#include "hal/uart_hal.h"
+#include "sdkconfig.h"
+
+int rt_hw_uart_init(void);
+
+#endif /* __DRV_UART_H__ */
diff --git a/bsp/ESP32_C3/main/main.c b/bsp/ESP32_C3/main/main.c
index 7b38605297..22d8c8d513 100644
--- a/bsp/ESP32_C3/main/main.c
+++ b/bsp/ESP32_C3/main/main.c
@@ -15,10 +15,12 @@
 
 int rtt_main(void)
 {
+    /* show RT-Thread version */
+    rt_show_version();
+    rt_kprintf("Hello!RT-THREAD!\r\n");
     rt_pin_mode(RT_BSP_LED_PIN, PIN_MODE_OUTPUT);
     while (1)
     {
-        printf("Hello!RT-THREAD!\r\n");
         rt_pin_write(RT_BSP_LED_PIN, PIN_HIGH);
         rt_thread_mdelay(1000);
         rt_pin_write(RT_BSP_LED_PIN, PIN_LOW);
diff --git a/bsp/ESP32_C3/rtconfig.h b/bsp/ESP32_C3/rtconfig.h
index 071fbc3b10..dfad290077 100644
--- a/bsp/ESP32_C3/rtconfig.h
+++ b/bsp/ESP32_C3/rtconfig.h
@@ -34,16 +34,34 @@
 /* Kernel Device Object */
 
 #define RT_USING_DEVICE
+#define RT_USING_CONSOLE
+#define RT_CONSOLEBUF_SIZE 256
+#define RT_CONSOLE_DEVICE_NAME "uart"
 #define RT_VER_NUM 0x40101
 
 /* RT-Thread Components */
 
 #define RT_USING_COMPONENTS_INIT
+#define RT_USING_MSH
+#define RT_USING_FINSH
+#define FINSH_USING_MSH
+#define FINSH_THREAD_NAME "tshell"
+#define FINSH_THREAD_PRIORITY 20
+#define FINSH_THREAD_STACK_SIZE 4096
+#define FINSH_USING_HISTORY
+#define FINSH_HISTORY_LINES 5
+#define FINSH_USING_SYMTAB
+#define FINSH_CMD_SIZE 80
+#define MSH_USING_BUILT_IN_COMMANDS
+#define FINSH_USING_DESCRIPTION
+#define FINSH_ARG_MAX 10
 
 /* Device Drivers */
 
 #define RT_USING_DEVICE_IPC
 #define RT_USING_PIN
+#define RT_USING_SERIAL
+#define RT_USING_SERIAL_V1
 
 /* Using USB */
 
@@ -150,9 +168,13 @@
 /* Onboard Peripheral Drivers */
 
 #define RT_BSP_LED_PIN 12
+#define RT_BSP_UART_PORT 0
+#define RT_BSP_UART_TX_PIN 21
+#define RT_BSP_UART_RX_PIN 20
 
 /* On-chip Peripheral Drivers */
 
 #define BSP_USING_GPIO
+#define BSP_USING_UART
 
 #endif
diff --git a/bsp/ESP32_C3/rtt.patch b/bsp/ESP32_C3/rtt.patch
new file mode 100644
index 0000000000..e4f3d431f9
--- /dev/null
+++ b/bsp/ESP32_C3/rtt.patch
@@ -0,0 +1,15373 @@
+From 3d7fabf23eeae26b7d739fbb649090aa590dcf3b Mon Sep 17 00:00:00 2001
+From: supperthomas <[email protected]>
+Date: Fri, 6 May 2022 23:06:28 +0800
+Subject: [PATCH 1/4] add the config of RTTHREAD
+
+add the init link file
+---
+ Kconfig                                       |   4 +
+ .../esp_system/ld/esp32c3/sections.ld.in      |  26 +++
+ components/freertos/port/port_common.c        |   5 +
+ components/freertos/port/port_systick.c       |   3 +
+ components/riscv/vectors.S                    | 220 ++++++++++++++++--
+ 5 files changed, 239 insertions(+), 19 deletions(-)
+
+diff --git a/Kconfig b/Kconfig
+index 928d274106..d368adaa37 100644
+--- a/Kconfig
++++ b/Kconfig
+@@ -61,6 +61,10 @@ mainmenu "Espressif IoT Development Framework Configuration"
+         bool
+         default "y" if IDF_TARGET="linux"
+ 
++    config IDF_RTOS_RTTHREAD
++        bool "RT-THREAD SELECT"
++        default "n" 
++
+     config IDF_FIRMWARE_CHIP_ID
+         hex
+         default 0x0000 if IDF_TARGET_ESP32
+diff --git a/components/esp_system/ld/esp32c3/sections.ld.in b/components/esp_system/ld/esp32c3/sections.ld.in
+index 0ebeda06c1..8215237fff 100644
+--- a/components/esp_system/ld/esp32c3/sections.ld.in
++++ b/components/esp_system/ld/esp32c3/sections.ld.in
+@@ -183,6 +183,32 @@ SECTIONS
+     _noinit_end = ABSOLUTE(.);
+   } > dram0_0_seg
+ 
++  .stack_dummy (COPY):
++  {
++      . = ALIGN(8);
++       __STACKSIZE__ = 40960; 
++      __stack_start__ = .;
++      *(.stack*)
++      . += __STACKSIZE__;
++      __stack_cpu0 = .;
++      __stack_end__ = .;
++  } > dram0_0_seg
++
++  .stack_dummy (COPY):
++  {
++      . = ALIGN(8);
++       __HEAPSIZE__ = 40960; 
++      __heap_start__ = .;
++      . += __STACKSIZE__;
++      __heap_end__ = .;
++        /* section information for initial. */
++        . = ALIGN(4);
++        __rt_init_start = .;
++        KEEP(*(SORT(.rti_fn*)))
++        __rt_init_end = .;
++
++        . = ALIGN(4);
++  } > dram0_0_seg
+   /* Shared RAM */
+   .dram0.bss (NOLOAD) :
+   {
+diff --git a/components/freertos/port/port_common.c b/components/freertos/port/port_common.c
+index ffca3d5429..9d8159f588 100644
+--- a/components/freertos/port/port_common.c
++++ b/components/freertos/port/port_common.c
+@@ -74,11 +74,16 @@ void esp_startup_start_app_common(void)
+     esp_gdbstub_init();
+ #endif // CONFIG_ESP_SYSTEM_GDBSTUB_RUNTIME
+ 
++#ifdef CONFIG_IDF_RTOS_RTTHREAD
++    app_main();
++#else
+     portBASE_TYPE res = xTaskCreatePinnedToCore(&main_task, "main",
+                                                 ESP_TASK_MAIN_STACK, NULL,
+                                                 ESP_TASK_MAIN_PRIO, NULL, ESP_TASK_MAIN_CORE);
+     assert(res == pdTRUE);
+     (void)res;
++#endif
++
+ }
+ 
+ static void main_task(void* args)
+diff --git a/components/freertos/port/port_systick.c b/components/freertos/port/port_systick.c
+index 0c14a155a1..0fa203574b 100644
+--- a/components/freertos/port/port_systick.c
++++ b/components/freertos/port/port_systick.c
+@@ -116,6 +116,8 @@ void vPortSetupTimer(void)
+  */
+ IRAM_ATTR void SysTickIsrHandler(void *arg)
+ {
++#ifdef CONFIG_IDF_RTOS_RTTHREAD
++#else
+     uint32_t cpuid = xPortGetCoreID();
+     systimer_hal_context_t *systimer_hal = (systimer_hal_context_t *)arg;
+ #ifdef CONFIG_PM_TRACE
+@@ -144,6 +146,7 @@ IRAM_ATTR void SysTickIsrHandler(void *arg)
+ #ifdef CONFIG_PM_TRACE
+     ESP_PM_TRACE_EXIT(TICK, cpuid);
+ #endif
++#endif
+ }
+ 
+ #endif // CONFIG_FREERTOS_SYSTICK_USES_CCOUNT
+diff --git a/components/riscv/vectors.S b/components/riscv/vectors.S
+index 1006d5bea5..963494fcb3 100644
+--- a/components/riscv/vectors.S
++++ b/components/riscv/vectors.S
+@@ -17,6 +17,9 @@
+ #include "soc/soc_caps.h"
+ #include "sdkconfig.h"
+ 
++#define STORE                   sw
++#define LOAD                    lw
++#define REGBYTES                4
+ 
+ 	.equ SAVE_REGS, 32
+ 	.equ CONTEXT_SIZE, (SAVE_REGS * 4)
+@@ -218,25 +221,27 @@ _call_panic_handler:
+ 	 */
+ 	.global _interrupt_handler
+ 	.type _interrupt_handler, @function
++#ifndef CONFIG_IDF_RTOS_RTTHREAD
++
+ _interrupt_handler:
+ 	/* entry */
+-	save_regs
+-	save_mepc
++	save_regs   /* 保存寄存器 */
++	save_mepc   /* 保存MEPC */
+ 
+ 	/* Before doing anythig preserve the stack pointer */
+ 	/* It will be saved in current TCB, if needed */
+-	mv a0, sp
++	mv a0, sp            /* 保存SP  a0 = sp */
+ 	call rtos_int_enter
+ 
+ 	/* Before dispatch c handler, restore interrupt to enable nested intr */
+-	csrr s1, mcause
+-	csrr s2, mstatus
++	csrr s1, mcause    /* 保存mcause s1 = mcause */
++	csrr s2, mstatus  /* 保存mstatus  s2 = mstatus */
+ 
+-	/* Save the interrupt threshold level */
+-	la t0, INTERRUPT_CORE0_CPU_INT_THRESH_REG
+-	lw s3, 0(t0)
++	/* Save the interrupt threshold level 保存中断嵌套层数? */
++	la t0, INTERRUPT_CORE0_CPU_INT_THRESH_REG  /* 保存mstatus  t0 = &INTERRUPT_CORE0_CPU_INT_THRESH_REG */
++	lw s3, 0(t0)    /*   s3 = mstatus */
+ 
+-	/* Increase interrupt threshold level */
++	/* Increase interrupt threshold level 增加中断嵌套层数*/
+ 	li t2, 0x7fffffff
+ 	and t1, s1, t2		/* t1 = mcause & mask */
+ 	slli t1, t1, 2 		/* t1 = mcause * 4 */
+@@ -247,8 +252,8 @@ _interrupt_handler:
+ 	sw t2, 0(t0)		/* INTERRUPT_CORE0_CPU_INT_THRESH_REG = t2 */
+ 	fence
+ 
+-	li t0, 0x8
+-	csrrs t0, mstatus, t0
++	li t0, 0x8   /* t0 = 8 */
++	csrrs t0, mstatus, t0    /*设置状态MIE寄存器，开总中断*/
+ 
+ 	#ifdef CONFIG_PM_TRACE
+ 	li      a0, 0       /* = ESP_PM_TRACE_IDLE */
+@@ -269,34 +274,211 @@ _interrupt_handler:
+ 	/* call the C dispatcher */
+ 	mv      a0, sp      /* argument 1, stack pointer */
+ 	mv      a1, s1      /* argument 2, interrupt number (mcause) */
+-	/* mask off the interrupt flag of mcause */
++	/* mask off the interrupt flag of mcause   屏幕异常中断*/
+ 	li	    t0, 0x7fffffff
+ 	and     a1, a1, t0
+ 	jal     _global_interrupt_handler
+ 
+-	/* After dispatch c handler, disable interrupt to make freertos make context switch */
++	/* After dispatch c handler, disable interrupt to make freertos make context switch 
++	在调用c函数之后，disable 中断让freertos能够做内容切换
++	*/
+ 
+ 	li t0, 0x8
+-	csrrc t0, mstatus, t0
++	csrrc t0, mstatus, t0  /*清状态MIE寄存器 关总中断*/
+ 
+-	/* restore the interrupt threshold level */
++
++	/* restore the interrupt threshold level  中断嵌套 */
+ 	la t0, INTERRUPT_CORE0_CPU_INT_THRESH_REG
+ 	sw s3, 0(t0)
+ 	fence
+ 
+ 	/* Yield to the next task is needed: */
+-	mv a0, sp
++	mv a0, sp     /* a0 = sp*/
+ 	call rtos_int_exit
+ 
+ 	/* The next (or current) stack pointer is returned in a0 */
+-	mv sp, a0
++	mv sp, a0    /* sp = a0*/
+ 
+ 	/* restore the rest of the registers */
+-	csrw mcause, s1
+-	csrw mstatus, s2
++	csrw mcause, s1  /* mcause = s1 */
++	csrw mstatus, s2   /* mstatus = s2 */
+ 	restore_mepc
+ 	restore_regs
+ 
+ 	/* exit, this will also re-enable the interrupts */
+ 	mret
+ 	.size  _interrupt_handler, .-_interrupt_handler
++#else
++_interrupt_handler:
++    /* 此时CPU的sp = from_thread->sp */
++    /* 注意： 在这里，并没有将mepc的值赋值为from_thread栈中的epc，但后面会赋值 */
++    addi sp, sp, -32 * REGBYTES             /* sp = sp - 32 * 4 栈指针向下偏移32个寄存器长度，用来将CPU的寄存器保存到from_thread的栈中*/
++    STORE x1,   1 * REGBYTES(sp)            /* 将CPU的x1寄存器，即ra寄存器，保存到from_thread->栈中 */
++
++    li    t0,   0x80                        /* t0 = 0x80 */
++    STORE t0,   2 * REGBYTES(sp)            /* mstatus = t0, 即关闭全局中断 */
++
++    /* 将 CPU 的其他寄存器的值，保存到from_thread的任务栈中 */
++    STORE x4,   4 * REGBYTES(sp)
++    STORE x5,   5 * REGBYTES(sp)
++    STORE x6,   6 * REGBYTES(sp)
++    STORE x7,   7 * REGBYTES(sp)
++    STORE x8,   8 * REGBYTES(sp)
++    STORE x9,   9 * REGBYTES(sp)
++    STORE x10, 10 * REGBYTES(sp)
++    STORE x11, 11 * REGBYTES(sp)
++    STORE x12, 12 * REGBYTES(sp)
++    STORE x13, 13 * REGBYTES(sp)
++    STORE x14, 14 * REGBYTES(sp)
++    STORE x15, 15 * REGBYTES(sp)
++    STORE x16, 16 * REGBYTES(sp)
++    STORE x17, 17 * REGBYTES(sp)
++    STORE x18, 18 * REGBYTES(sp)
++    STORE x19, 19 * REGBYTES(sp)
++    STORE x20, 20 * REGBYTES(sp)
++    STORE x21, 21 * REGBYTES(sp)
++    STORE x22, 22 * REGBYTES(sp)
++    STORE x23, 23 * REGBYTES(sp)
++    STORE x24, 24 * REGBYTES(sp)
++    STORE x25, 25 * REGBYTES(sp)
++    STORE x26, 26 * REGBYTES(sp)
++    STORE x27, 27 * REGBYTES(sp)
++    STORE x28, 28 * REGBYTES(sp)
++    STORE x29, 29 * REGBYTES(sp)
++    STORE x30, 30 * REGBYTES(sp)
++    STORE x31, 31 * REGBYTES(sp)
++
++    /* 备份 CPU 的 sp (这时，CPU的sp其实就是from thread的sp指针) 寄存器的值到 s0 寄存器中，下面会使用s0，恢复 CPU 的寄存器 */
++    move  s0, sp    /* s0 = sp */
++
++    /* 在中断函数中，中断函数中调用的C函数，需要使用 sp， 这里，在中断函数中，使用的 sp 为，系统的栈资源 */
++    /* switch to interrupt stack */
++    la    sp, __stack_end__   /* sp = _sp */
++
++    /* interrupt handle */
++    /* 注意： 在调用C函数之前,比如sp的值为0x30001000, 在执行完C函数后，sp的值还是会变成 0x30001000 */
++    call  rt_interrupt_enter    /* 执行所有的中断函数前，调用该函数 */
++
++    csrr s1, mcause
++	csrr s2, mstatus
++
++    /* Save the interrupt threshold level */
++	la t0, INTERRUPT_CORE0_CPU_INT_THRESH_REG
++	lw s3, 0(t0)
++
++    li t2, 0x7fffffff
++	and t1, s1, t2		/* t1 = mcause & mask */
++	slli t1, t1, 2 		/* t1 = mcause * 4 */
++	la t2, INTC_INT_PRIO_REG(0)
++	add t1, t2, t1		/* t1 = INTC_INT_PRIO_REG + 4 * mcause */
++	lw t2, 0(t1)		/* t2 = INTC_INT_PRIO_REG[mcause] */
++	addi t2, t2, 1		/* t2 = t2 +1 */
++	sw t2, 0(t0)		/* INTERRUPT_CORE0_CPU_INT_THRESH_REG = t2 */
++	fence
++
++    li t0, 0x8
++	csrrs t0, mstatus, t0
++
++    /* call the C dispatcher */
++	mv      a0, sp      /* argument 1, stack pointer */
++	mv      a1, s1      /* argument 2, interrupt number (mcause) */
++	/* mask off the interrupt flag of mcause */
++	li	    t0, 0x7fffffff
++	and     a1, a1, t0
++	jal     _global_interrupt_handler
++
++    li t0, 0x8
++	csrrc t0, mstatus, t0
++
++	/* restore the interrupt threshold level */
++	la t0, INTERRUPT_CORE0_CPU_INT_THRESH_REG
++	sw s3, 0(t0)
++	fence
++
++    call  rt_interrupt_leave    /* 执行所有的中断函数后，调用该函数 */
++
++    /* 上面，将保存执行中断服务函数之前的CPU的sp寄存器到了s0所指向的位置处，当执行完中断服务函数，需要将之前的CPU寄存器，恢复一下,此时sp又变成了from thread的sp了 */
++    move  sp, s0    /* sp = s0 */
++
++    /* 下面两句话，相当于将 rt_thread_switch_interrupt_flag 值，赋值给了s2  */
++    /* 将 rt_thread_switch_interrupt_flag 的地址值，赋值给 s0 寄存器*/
++    la    s0, rt_thread_switch_interrupt_flag       /* s0 = &rt_thread_switch_interrupt_flag */
++    /* 将 s0 所指向的地址处的内容，取出来，赋值给 s2 寄存器，其实就是将  rt_thread_switch_interrupt_flag 的值，赋值给了 s2 寄存器*/
++    lw    s2, 0(s0)                 /* s2 = *s0 = rt_thread_switch_interrupt_flag */
++
++    /* 如果 s2的值，即 rt_thread_switch_interrupt_flag 值，如果不为0，则需要继续执行下一条指令，如果为0，则需要跳转到 spurious_interrupt 标号处 执行 */
++    /* 如果 s2的值等于0，rt_thread_switch_interrupt_flag等于0， 则不需要在中断处理函数中，进行上下文切换，反之则需要 */
++    /* 如果不需要上下文切换， */
++
++    /* 在这里，跳转到 spurious_interrupt的话，是不会进行上下文切换的，因为，此时CPU的sp指针还是from线程的*/
++    beqz  s2, spurious_interrupt    /* if (s2 == 0) goto spurious_interrupt; else 执行下一条语句*/
++
++    /* 需要上下文切换： 主要目的是将CPU的sp指针，赋值为to_thread的sp */
++    
++    /* 将 s0 所执向的地址的内容设置为0， 也就是，将变量 rt_thread_switch_interrupt_flag 赋值为了 0 */
++    /* s0存放的值是 rt_thread_switch_interrupt_flag 变量的地址*/
++    sw    zero, 0(s0)       /* *s0 = 0; 也就是 rt_thread_switch_interrupt_flag = 0 */
++    /* 将 mepc 的值，赋值给 a0 寄存器，mepc 的值是，跳转到中断函数执行之前的 PC 指针 */
++    /* 这时的mpec其实，还是from线程，在跳转到中断执行前的一个PC地址 */
++    csrr  a0, mepc  /* a0 = mepc */
++
++    /* 将 mpec 的值写回到freom thread任务栈中的 epc 中,待后续，恢复from线程时，使用 */
++    STORE a0, 0 * REGBYTES(sp)  /* from_thread->sp->epc = a0 ，中断入口处*/
++
++    /* 将from_thread的sp指针，赋值为CPU的sp指针 */
++    la    s0, rt_interrupt_from_thread  /* s0 = &rt_interrupt_from_thread 注意： rt_interrupt_from_thread = &(from_thread->sp) */
++    LOAD  s1, 0(s0)                     /* s1 = rt_interrupt_from_thread，也就是s1 = &(from_thread->sp) */
++    STORE sp, 0(s1)                     /* from_thread->sp = sp*/
++   
++    /* 接下来，需要开始恢复CPU的sp为to_thread的sp了 */
++    la    s0, rt_interrupt_to_thread    /* s0 = &rt_interrupt_to_thread 注意： rt_interrupt_to_thread = &(to_thred->sp)*/
++    LOAD  s1, 0(s0)                     /* s1 = rt_interrupt_to_thread, 也就是s1 = &(to_thred->sp) */
++    LOAD  sp, 0(s1)                     /* sp = (to_thred->sp)*/
++
++    /* 将CPU的 mepc设置为to_thred的mepc，待中断退出，执行mret指令后，将从该地址开始执行 */
++    LOAD  a0,  0 * REGBYTES(sp)         /* a0 = to_thread的mepc的值*/
++    csrw  mepc, a0                      /* mepc = a0 */
++
++
++spurious_interrupt:
++    LOAD  x1,   1 * REGBYTES(sp)
++
++    /* Remain in M-mode after mret */
++    li    t0, 0x00001800
++    csrs  mstatus, t0
++    LOAD  t0,   2 * REGBYTES(sp)
++    csrs  mstatus, t0
++
++    LOAD  x4,   4 * REGBYTES(sp)
++    LOAD  x5,   5 * REGBYTES(sp)
++    LOAD  x6,   6 * REGBYTES(sp)
++    LOAD  x7,   7 * REGBYTES(sp)
++    LOAD  x8,   8 * REGBYTES(sp)
++    LOAD  x9,   9 * REGBYTES(sp)
++    LOAD  x10, 10 * REGBYTES(sp)
++    LOAD  x11, 11 * REGBYTES(sp)
++    LOAD  x12, 12 * REGBYTES(sp)
++    LOAD  x13, 13 * REGBYTES(sp)
++    LOAD  x14, 14 * REGBYTES(sp)
++    LOAD  x15, 15 * REGBYTES(sp)
++    LOAD  x16, 16 * REGBYTES(sp)
++    LOAD  x17, 17 * REGBYTES(sp)
++    LOAD  x18, 18 * REGBYTES(sp)
++    LOAD  x19, 19 * REGBYTES(sp)
++    LOAD  x20, 20 * REGBYTES(sp)
++    LOAD  x21, 21 * REGBYTES(sp)
++    LOAD  x22, 22 * REGBYTES(sp)
++    LOAD  x23, 23 * REGBYTES(sp)
++    LOAD  x24, 24 * REGBYTES(sp)
++    LOAD  x25, 25 * REGBYTES(sp)
++    LOAD  x26, 26 * REGBYTES(sp)
++    LOAD  x27, 27 * REGBYTES(sp)
++    LOAD  x28, 28 * REGBYTES(sp)
++    LOAD  x29, 29 * REGBYTES(sp)
++    LOAD  x30, 30 * REGBYTES(sp)
++    LOAD  x31, 31 * REGBYTES(sp)
++
++    addi  sp, sp, 32 * REGBYTES
++    mret
++	.size  _interrupt_handler, .-_interrupt_handler
++#endif
+-- 
+2.32.0 (Apple Git-132)
+
+
+From d0d1f625543282df462af56cc18abaa5a47d4f40 Mon Sep 17 00:00:00 2001
+From: supperthomas <[email protected]>
+Date: Sat, 9 Jul 2022 21:37:53 +0800
+Subject: [PATCH 2/4] remove submodule
+
+remove submodule
+---
+ .gitmodules | 111 ----------------------------------------------------
+ 1 file changed, 111 deletions(-)
+
+diff --git a/.gitmodules b/.gitmodules
+index 49edc68e10..8b13789179 100644
+--- a/.gitmodules
++++ b/.gitmodules
+@@ -1,112 +1 @@
+-#
+-# All the relative URL paths are intended to be GitHub ones
+-# For Espressif's public projects please use '../../espressif/proj', not a '../proj'
+-#
+ 
+-[submodule "components/esptool_py/esptool"]
+-	path = components/esptool_py/esptool
+-	url = ../../espressif/esptool.git
+-
+-[submodule "components/bt/controller/lib_esp32"]
+-	path = components/bt/controller/lib_esp32
+-        url = ../../espressif/esp32-bt-lib.git
+-
+-[submodule "components/bootloader/subproject/components/micro-ecc/micro-ecc"]
+-	path = components/bootloader/subproject/components/micro-ecc/micro-ecc
+-	url = ../../kmackay/micro-ecc.git
+-
+-[submodule "components/coap/libcoap"]
+-	path = components/coap/libcoap
+-	url = ../../obgm/libcoap.git
+-
+-[submodule "components/nghttp/nghttp2"]
+-	path = components/nghttp/nghttp2
+-	url = ../../nghttp2/nghttp2.git
+-
+-[submodule "components/libsodium/libsodium"]
+-	path = components/libsodium/libsodium
+-	url = ../../jedisct1/libsodium.git
+-
+-[submodule "components/spiffs/spiffs"]
+-	path = components/spiffs/spiffs
+-	url = ../../pellepl/spiffs.git
+-
+-[submodule "components/json/cJSON"]
+-	path = components/json/cJSON
+-	url = ../../DaveGamble/cJSON.git
+-
+-[submodule "components/mbedtls/mbedtls"]
+-	path = components/mbedtls/mbedtls
+-	url = ../../espressif/mbedtls.git
+-
+-[submodule "components/asio/asio"]
+-	path = components/asio/asio
+-	url = ../../espressif/asio.git
+-
+-[submodule "components/expat/expat"]
+-	path = components/expat/expat
+-	url = ../../libexpat/libexpat.git
+-
+-[submodule "components/lwip/lwip"]
+-	path = components/lwip/lwip
+-	url = ../../espressif/esp-lwip.git
+-
+-[submodule "components/mqtt/esp-mqtt"]
+-	path = components/mqtt/esp-mqtt
+-	url = ../../espressif/esp-mqtt.git
+-
+-[submodule "components/protobuf-c/protobuf-c"]
+-	path = components/protobuf-c/protobuf-c
+-	url = ../../protobuf-c/protobuf-c.git
+-
+-[submodule "components/unity/unity"]
+-	path = components/unity/unity
+-	url = ../../ThrowTheSwitch/Unity.git
+-
+-[submodule "examples/build_system/cmake/import_lib/main/lib/tinyxml2"]
+-	path = examples/build_system/cmake/import_lib/main/lib/tinyxml2
+-	url = ../../leethomason/tinyxml2.git
+-
+-[submodule "components/bt/host/nimble/nimble"]
+-	path = components/bt/host/nimble/nimble
+-	url = ../../espressif/esp-nimble.git
+-
+-[submodule "components/cbor/tinycbor"]
+-	path = components/cbor/tinycbor
+-	url = ../../intel/tinycbor.git
+-
+-[submodule "components/esp_wifi/lib"]
+-	path = components/esp_wifi/lib
+-	url = ../../espressif/esp32-wifi-lib.git
+-
+-[submodule "components/tinyusb/tinyusb"]
+-	path = components/tinyusb/tinyusb
+-	url = ../../espressif/tinyusb.git
+-
+-[submodule "examples/peripherals/secure_element/atecc608_ecdsa/components/esp-cryptoauthlib"]
+-	path = examples/peripherals/secure_element/atecc608_ecdsa/components/esp-cryptoauthlib
+-	url = ../../espressif/esp-cryptoauthlib.git
+-
+-[submodule "components/cmock/CMock"]
+-	path = components/cmock/CMock
+-	url = ../../ThrowTheSwitch/CMock.git
+-
+-[submodule "components/openthread/openthread"]
+-	path = components/openthread/openthread
+-	url = ../../espressif/openthread.git
+-
+-[submodule "components/bt/controller/lib_esp32c3_family"]
+-	path = components/bt/controller/lib_esp32c3_family
+-	url = ../../espressif/esp32c3-bt-lib.git
+-
+-[submodule "components/esp_phy/lib"]
+-	path = components/esp_phy/lib
+-	url = ../../espressif/esp-phy-lib.git
+-
+-[submodule "components/openthread/lib"]
+-	path = components/openthread/lib
+-	url = ../../espressif/esp-thread-lib.git
+-
+-[submodule "components/ieee802154/lib"]
+-	path = components/ieee802154/lib
+-	url = ../../espressif/esp-ieee802154-lib.git
+-- 
+2.32.0 (Apple Git-132)
+
+
+From 29b9d1ebe7fe1c817428b856e208561ae0dc574b Mon Sep 17 00:00:00 2001
+From: tangzz98 <[email protected]>
+Date: Sat, 30 Jul 2022 15:08:12 +0800
+Subject: [PATCH 3/4] Add FreeRTOS wrapper
+
+---
+ .../include/esp_serial_slave_link/essl.h      |    2 +-
+ .../port/arch/riscv/expression_with_stack.c   |    6 +
+ components/esp_system/startup.c               |   12 +
+ components/freertos/CMakeLists.txt            |   73 +-
+ .../FreeRTOS/esp_additions/task_snapshot.c    |  212 ++
+ .../FreeRTOS/event_groups.c                   |  225 ++
+ .../FreeRTOS/freertos_v8_compat.c             |   33 +
+ .../esp_additions/freertos/FreeRTOSConfig.h   |  326 +++
+ .../esp_additions/freertos/task_snapshot.h    |   90 +
+ .../FreeRTOS/include/freertos/FreeRTOS.h      | 1198 +++++++++
+ .../FreeRTOS/include/freertos/event_groups.h  |  621 +++++
+ .../FreeRTOS/include/freertos/list.h          |  416 +++
+ .../FreeRTOS/include/freertos/portable.h      |  141 +
+ .../FreeRTOS/include/freertos/projdefs.h      |   64 +
+ .../FreeRTOS/include/freertos/queue.h         | 1188 +++++++++
+ .../FreeRTOS/include/freertos/semphr.h        | 1188 +++++++++
+ .../FreeRTOS/include/freertos/task.h          | 2265 +++++++++++++++++
+ .../FreeRTOS/include/freertos/timers.h        | 1185 +++++++++
+ .../FreeRTOS/list.c                           |  213 ++
+ .../FreeRTOS/port/MemMang/heap_1.c            |  145 ++
+ .../FreeRTOS/port/MemMang/heap_2.c            |  277 ++
+ .../FreeRTOS/port/MemMang/heap_3.c            |   78 +
+ .../FreeRTOS/port/MemMang/heap_4.c            |  447 ++++
+ .../FreeRTOS/port/MemMang/heap_5.c            |  506 ++++
+ .../FreeRTOS/port/port_common.c               |  203 ++
+ .../include/freertos/FreeRTOSConfig_arch.h    |  105 +
+ .../rt-thread/include/freertos/portmacro.h    |  107 +
+ .../include/freertos/portmacro_deprecated.h   |   94 +
+ .../include/freertos/portmacro_esp32c3.h      |  424 +++
+ .../FreeRTOS/port/rt-thread/port.c            |   44 +
+ .../FreeRTOS/port/rt-thread/port_esp32c3.c    |  197 ++
+ .../FreeRTOS/queue.c                          |  787 ++++++
+ .../FreeRTOS/tasks.c                          | 1254 +++++++++
+ .../FreeRTOS/timers.c                         |  328 +++
+ .../RT-Thread-wrapper-of-FreeRTOS/readme.md   |    3 +
+ 35 files changed, 14436 insertions(+), 21 deletions(-)
+ create mode 100644 components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/esp_additions/task_snapshot.c
+ create mode 100644 components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/event_groups.c
+ create mode 100644 components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/freertos_v8_compat.c
+ create mode 100644 components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/esp_additions/freertos/FreeRTOSConfig.h
+ create mode 100644 components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/esp_additions/freertos/task_snapshot.h
+ create mode 100644 components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/freertos/FreeRTOS.h
+ create mode 100644 components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/freertos/event_groups.h
+ create mode 100644 components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/freertos/list.h
+ create mode 100644 components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/freertos/portable.h
+ create mode 100644 components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/freertos/projdefs.h
+ create mode 100644 components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/freertos/queue.h
+ create mode 100644 components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/freertos/semphr.h
+ create mode 100644 components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/freertos/task.h
+ create mode 100644 components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/freertos/timers.h
+ create mode 100644 components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/list.c
+ create mode 100644 components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/MemMang/heap_1.c
+ create mode 100644 components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/MemMang/heap_2.c
+ create mode 100644 components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/MemMang/heap_3.c
+ create mode 100644 components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/MemMang/heap_4.c
+ create mode 100644 components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/MemMang/heap_5.c
+ create mode 100644 components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/port_common.c
+ create mode 100644 components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/rt-thread/include/freertos/FreeRTOSConfig_arch.h
+ create mode 100644 components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/rt-thread/include/freertos/portmacro.h
+ create mode 100644 components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/rt-thread/include/freertos/portmacro_deprecated.h
+ create mode 100644 components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/rt-thread/include/freertos/portmacro_esp32c3.h
+ create mode 100644 components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/rt-thread/port.c
+ create mode 100644 components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/rt-thread/port_esp32c3.c
+ create mode 100644 components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/queue.c
+ create mode 100644 components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/tasks.c
+ create mode 100644 components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/timers.c
+ create mode 100644 components/freertos/RT-Thread-wrapper-of-FreeRTOS/readme.md
+
+diff --git a/components/esp_serial_slave_link/include/esp_serial_slave_link/essl.h b/components/esp_serial_slave_link/include/esp_serial_slave_link/essl.h
+index f03274a401..e9bc4939c0 100644
+--- a/components/esp_serial_slave_link/include/esp_serial_slave_link/essl.h
++++ b/components/esp_serial_slave_link/include/esp_serial_slave_link/essl.h
+@@ -160,7 +160,7 @@ esp_err_t essl_read_reg(essl_handle_t handle, uint8_t add, uint8_t *value_o, uin
+  *        - ESP_ERR_NOT_SUPPORTED: Current device does not support this function.
+  *        - ESP_ERR_TIMEOUT:       No interrupts before timeout.
+  */
+-esp_err_t essl_wait_int(essl_handle_t handle, uint32_t wait_ms);
++esp_err_t essl_wait_int(essl_handle_t handle, TickType_t wait_ms);
+ 
+ /** Clear interrupt bits of ESSL slave. All the bits set in the mask will be cleared, while other bits will stay the same.
+  *
+diff --git a/components/esp_system/port/arch/riscv/expression_with_stack.c b/components/esp_system/port/arch/riscv/expression_with_stack.c
+index 07d22bf3aa..64c1e0689d 100644
+--- a/components/esp_system/port/arch/riscv/expression_with_stack.c
++++ b/components/esp_system/port/arch/riscv/expression_with_stack.c
+@@ -18,6 +18,7 @@
+ #include "freertos/FreeRTOS.h"
+ #include "freertos/portmacro.h"
+ 
++#if !defined CONFIG_IDF_RTOS_RTTHREAD
+ static portMUX_TYPE shared_stack_spinlock = portMUX_INITIALIZER_UNLOCKED;
+ static void *current_task_stack = NULL;
+ 
+@@ -45,10 +46,12 @@ static StackType_t *esp_switch_stack_setup(StackType_t *stack, size_t stack_size
+ #endif
+     return ((StackType_t *)adjusted_top_of_stack);
+ }
++#endif
+ 
+ 
+ void esp_execute_shared_stack_function(SemaphoreHandle_t lock, void *stack, size_t stack_size, shared_stack_function function)
+ {
++#if !defined CONFIG_IDF_RTOS_RTTHREAD
+     assert(lock);
+     assert(stack);
+     assert(stack_size > 0 && stack_size >= CONFIG_ESP_MINIMAL_SHARED_STACK_SIZE);
+@@ -70,4 +73,7 @@ void esp_execute_shared_stack_function(SemaphoreHandle_t lock, void *stack, size
+     portEXIT_CRITICAL(&shared_stack_spinlock);
+ 
+     xSemaphoreGive(lock);
++#else
++    function();
++#endif
+ }
+diff --git a/components/esp_system/startup.c b/components/esp_system/startup.c
+index 139ae8b6a2..6c6acdf575 100644
+--- a/components/esp_system/startup.c
++++ b/components/esp_system/startup.c
+@@ -56,6 +56,10 @@
+ 
+ #include "esp_rom_sys.h"
+ 
++#if CONFIG_IDF_RTOS_RTTHREAD
++#include "rtthread.h"
++#endif
++
+ // [refactor-todo] make this file completely target-independent
+ #if CONFIG_IDF_TARGET_ESP32
+ #include "esp32/clk.h"
+@@ -235,6 +239,14 @@ static void do_core_init(void)
+        app CPU, and when that is not up yet, the memory will be inaccessible and heap_caps_init may
+        fail initializing it properly. */
+     heap_caps_init();
++#if CONFIG_IDF_RTOS_RTTHREAD
++#if defined RT_USING_HEAP
++    extern int __heap_start__;
++    extern int __heap_end__;
++    rt_system_heap_init((void *)&__heap_start__, (void *)&__heap_end__);
++#endif
++    rt_system_scheduler_init();
++#endif
+ 
+     // When apptrace module is enabled, there will be SEGGER_SYSVIEW calls in the newlib init.
+     // SEGGER_SYSVIEW relies on apptrace module
+diff --git a/components/freertos/CMakeLists.txt b/components/freertos/CMakeLists.txt
+index bd5acf5a2f..8db7883df6 100644
+--- a/components/freertos/CMakeLists.txt
++++ b/components/freertos/CMakeLists.txt
+@@ -6,7 +6,29 @@ endif()
+ 
+ idf_build_get_property(target IDF_TARGET)
+ 
+-if(CONFIG_IDF_TARGET_ARCH_XTENSA)
++if(CONFIG_IDF_RTOS_RTTHREAD)
++    set(freertos_root "RT-Thread-wrapper-of-FreeRTOS/FreeRTOS")
++else()
++    set(freertos_root ".")
++endif()
++
++if(CONFIG_IDF_RTOS_RTTHREAD)
++    set(srcs
++        "${freertos_root}/port/rt-thread/port.c"
++        "${freertos_root}/port/rt-thread/port_esp32c3.c")
++
++    set(include_dirs
++        "${freertos_root}/include"
++        "${freertos_root}/include/esp_additions/freertos"  # For files with #include "FreeRTOSConfig.h"
++        "${freertos_root}/port/rt-thread/include"            # For including arch-specific FreeRTOSConfig_arch.h in port/<arch>/include
++        "${freertos_root}/include/esp_additions")          # For files with #include "freertos/FreeRTOSConfig.h"
++
++    set(private_include_dirs
++        "${freertos_root}/port/rt-thread/include/freertos"
++        "${freertos_root}/port/rt-thread"
++        "${freertos_root}")
++
++elseif(CONFIG_IDF_TARGET_ARCH_XTENSA)
+     set(srcs
+         "port/xtensa/port.c"
+         "port/xtensa/portasm.S"
+@@ -48,21 +70,25 @@ elseif(CONFIG_IDF_TARGET_ARCH_RISCV)
+ endif()
+ 
+ list(APPEND srcs
+-    "esp_additions/task_snapshot.c"
+-    "port/port_common.c"
+-    "port/port_systick.c"
+-    "croutine.c"
+-    "event_groups.c"
+-    "list.c"
+-    "queue.c"
+-    "tasks.c"
+-    "timers.c"
+-    "stream_buffer.c"
+-    "FreeRTOS-openocd.c"
+-    "freertos_v8_compat.c")
++    "${freertos_root}/port/port_common.c"
++    "${freertos_root}/event_groups.c"
++    "${freertos_root}/queue.c"
++    "${freertos_root}/tasks.c"
++    "${freertos_root}/timers.c"
++    "${freertos_root}/list.c"
++    "${freertos_root}/freertos_v8_compat.c"
++    "${freertos_root}/esp_additions/task_snapshot.c")
++
++if(NOT CONFIG_IDF_RTOS_RTTHREAD)
++    list(APPEND srcs
++        "port/port_systick.c"
++        "croutine.c"
++        "stream_buffer.c"
++        "freertos_v8_compat.c")
++endif()
+ 
+ list(APPEND private_include_dirs
+-    "include/freertos")
++    "${freertos_root}/include/freertos")
+ 
+ if(CONFIG_ESP32_IRAM_AS_8BIT_ACCESSIBLE_MEMORY)
+     list(APPEND srcs "port/xtensa/xtensa_loadstore_handler.S")
+@@ -71,7 +97,7 @@ endif()
+ # esp_timer is required by FreeRTOS because we use esp_tiemr_get_time() to do profiling
+ # app_trace is required by FreeRTOS headers only when CONFIG_APPTRACE_SV_ENABLE=y,
+ # REQUIRES can't depend on config options, so always require it.
+-set(required_components app_trace esp_timer)
++set(required_components app_trace esp_timer main)
+ 
+ idf_component_register(SRCS "${srcs}"
+                     INCLUDE_DIRS ${include_dirs}
+@@ -88,15 +114,22 @@ if(CONFIG_FREERTOS_DEBUG_OCDAWARE)
+ endif()
+ 
+ set_source_files_properties(
+-    tasks.c
+-    event_groups.c
+-    timers.c
+-    queue.c
+-    stream_buffer.c
++    "${freertos_root}/tasks.c"
++    "${freertos_root}/event_groups.c"
++    "${freertos_root}/timers.c"
++    "${freertos_root}/queue.c"
+     PROPERTIES COMPILE_DEFINITIONS
+     _ESP_FREERTOS_INTERNAL
+     )
+ 
++if(NOT CONFIG_IDF_RTOS_RTTHREAD)
++    set_source_files_properties(
++        stream_buffer.c
++        PROPERTIES COMPILE_DEFINITIONS
++        _ESP_FREERTOS_INTERNAL
++    )
++endif()
++
+ # The freertos component provides the `start_app` and `start_app_other_cores`
+ # if it is included in the build. It then calls `app_main`
+ # from the main task created, which must be provided by the user.
+diff --git a/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/esp_additions/task_snapshot.c b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/esp_additions/task_snapshot.c
+new file mode 100644
+index 0000000000..1244118b60
+--- /dev/null
++++ b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/esp_additions/task_snapshot.c
+@@ -0,0 +1,212 @@
++/*
++ * SPDX-FileCopyrightText: 2017-2021 Espressif Systems (Shanghai) CO LTD
++ *
++ * SPDX-License-Identifier: Apache-2.0
++ */
++
++#include "freertos/FreeRTOS.h"
++#include "freertos/task_snapshot.h"
++
++#ifndef DIM
++#define DIM(t) (sizeof(t)/ sizeof(*(t)))
++#endif
++
++#if ( configENABLE_TASK_SNAPSHOT == 1 )
++
++	static void prvTaskGetSnapshot( TaskSnapshot_t *pxTaskSnapshotArray, UBaseType_t *uxTask, void *pxTCB )
++	{
++		if (pxTCB == NULL) {
++			return;
++		}
++		pxTaskSnapshotArray[ *uxTask ].pxTCB = pxTCB;
++		pxTaskSnapshotArray[ *uxTask ].pxTopOfStack = (StackType_t *) pxTCBGetTopOfStack(pxTCB);
++		#if( portSTACK_GROWTH < 0 )
++		{
++			pxTaskSnapshotArray[ *uxTask ].pxEndOfStack = pxTCBGetEndOfStack(pxTCB);
++		}
++		#else
++		{
++			pxTaskSnapshotArray[ *uxTask ].pxEndOfStack = pxTCBGetStartOfStack(pxTCB);
++		}
++		#endif
++		(*uxTask)++;
++	}
++
++	static void prvTaskGetSnapshotsFromList( TaskSnapshot_t *pxTaskSnapshotArray, UBaseType_t *uxTask, const UBaseType_t uxArraySize, List_t *pxList )
++	{
++		void *pxNextTCB = NULL;
++		void *pxFirstTCB = NULL;
++
++		if( listCURRENT_LIST_LENGTH( pxList ) > ( UBaseType_t ) 0 )
++		{
++			listGET_OWNER_OF_NEXT_ENTRY( pxFirstTCB, pxList );
++			do
++			{
++				if( *uxTask >= uxArraySize ) {
++					break;
++				}
++
++				listGET_OWNER_OF_NEXT_ENTRY( pxNextTCB, pxList );
++				prvTaskGetSnapshot( pxTaskSnapshotArray, uxTask, pxNextTCB );
++			} while( pxNextTCB != pxFirstTCB );
++		}
++		else
++		{
++			mtCOVERAGE_TEST_MARKER();
++		}
++	}
++
++	UBaseType_t uxTaskGetSnapshotAll( TaskSnapshot_t * const pxTaskSnapshotArray, const UBaseType_t uxArraySize, UBaseType_t * const pxTcbSz )
++	{
++		UBaseType_t uxTask = 0;
++		UBaseType_t i = 0;
++
++
++		*pxTcbSz = pxTCBGetSize();
++		/* Fill in an TaskStatus_t structure with information on each
++		task in the Ready state. */
++		i = configMAX_PRIORITIES;
++		do
++		{
++			i--;
++			prvTaskGetSnapshotsFromList( pxTaskSnapshotArray, &uxTask, uxArraySize, pxListGetReadyTask(i) );
++		} while( i > ( UBaseType_t ) tskIDLE_PRIORITY ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */
++
++		/* Fill in an TaskStatus_t structure with information on each
++		task in the Blocked state. */
++		prvTaskGetSnapshotsFromList( pxTaskSnapshotArray, &uxTask, uxArraySize, pxGetDelayedTaskList() );
++		prvTaskGetSnapshotsFromList( pxTaskSnapshotArray, &uxTask, uxArraySize, pxGetOverflowDelayedTaskList() );
++		for (i = 0; i < configNUM_CORES; i++) {
++			if( uxTask >= uxArraySize ) {
++				break;
++			}
++			prvTaskGetSnapshotsFromList( pxTaskSnapshotArray, &uxTask, uxArraySize, pxListGetReadyPendingTask(i) );
++		}
++
++		#if( INCLUDE_vTaskDelete == 1 )
++		{
++			prvTaskGetSnapshotsFromList( pxTaskSnapshotArray, &uxTask, uxArraySize, pxGetTasksWaitingTermination() );
++		}
++		#endif
++
++		#if ( INCLUDE_vTaskSuspend == 1 )
++		{
++			prvTaskGetSnapshotsFromList( pxTaskSnapshotArray, &uxTask, uxArraySize, pxGetSuspendedTaskList() );
++		}
++		#endif
++		return uxTask;
++	}
++
++	static void *prvFirstTaskGet( List_t *pxList )
++	{
++		ListItem_t *pxListItem = listGET_HEAD_ENTRY( pxList );
++		if( pxListItem != listGET_END_MARKER( pxList ) ) {
++			return listGET_LIST_ITEM_OWNER( pxListItem );
++		}
++		return NULL;
++	}
++
++	static void *prvNextTaskGet( void *pxTCB )
++	{
++		List_t *pxList = listLIST_ITEM_CONTAINER( pxTCBGetStateListItem(pxTCB) );
++		ListItem_t *pxListItem = listGET_NEXT( pxTCBGetStateListItem(pxTCB) );
++		if( pxListItem != listGET_END_MARKER( pxList ) ) {
++			return listGET_LIST_ITEM_OWNER( pxListItem );
++		}
++		return NULL;
++	}
++
++	void vTaskGetSnapshot( TaskHandle_t pxTask, TaskSnapshot_t *pxTaskSnapshot )
++	{
++		configASSERT( portVALID_TCB_MEM(pxTask) );
++		configASSERT( pxTaskSnapshot != NULL );
++		pxTaskSnapshot->pxTCB = (void*) pxTask;
++		pxTaskSnapshot->pxTopOfStack = pxTCBGetTopOfStack((void*) pxTask);
++		pxTaskSnapshot->pxEndOfStack = pxTCBGetEndOfStack((void*) pxTask);
++	}
++
++	TaskHandle_t pxTaskGetNext( TaskHandle_t pxTask )
++	{
++		void *pxTCB = pxTask;
++		List_t *pxTaskList = NULL;
++		UBaseType_t i = configMAX_PRIORITIES;
++		UBaseType_t bCurTaskListFound = pdFALSE;
++		List_t *task_lists[] = {
++			pxGetDelayedTaskList(),
++			pxGetOverflowDelayedTaskList(),
++		#if( INCLUDE_vTaskDelete == 1 )
++			pxGetTasksWaitingTermination(),
++		#endif
++		#if( INCLUDE_vTaskSuspend == 1 )
++			pxGetSuspendedTaskList()
++		#endif
++		};
++
++		if( pxTask != NULL && !portVALID_TCB_MEM(pxTask) ) {
++			return NULL;
++		}
++
++		if( pxTCB != NULL ) {
++			pxTCB = prvNextTaskGet( pxTCB );
++			if( pxTCB != NULL ) {
++				// take care not to return garbage
++				return portVALID_TCB_MEM(pxTCB) ? pxTCB : NULL;
++			}
++			pxTaskList = listLIST_ITEM_CONTAINER( pxTCBGetStateListItem(pxTask) );
++		}
++		/* ready tasks lists */
++		do
++		{
++			i--;
++			List_t *pxList = pxListGetReadyTask(i);
++			if( bCurTaskListFound == pdFALSE && pxTaskList != NULL ) {
++				/* need to find list the current task item from */
++				if( pxTaskList == pxList ) {
++					bCurTaskListFound = pdTRUE;
++				}
++				continue; /* go to the next 'ready list' */
++			}
++			pxTCB = prvFirstTaskGet( pxList );
++			if( pxTCB != NULL ) {
++				// take care not to return garbage
++				return portVALID_TCB_MEM(pxTCB) ? pxTCB : NULL;
++		}
++		}
++		while( i > tskIDLE_PRIORITY );
++		/* pending ready tasks lists */
++		for (i = 0; i < configNUM_CORES; i++) {
++			List_t *pxList = pxListGetReadyPendingTask(i);
++			if( bCurTaskListFound == pdFALSE && pxTaskList != NULL ) {
++				/* need to find list the current task item from */
++				if( pxTaskList == pxList ) {
++					bCurTaskListFound = pdTRUE;
++				}
++				continue; /* go to the next 'ready list' */
++			}
++			pxTCB = prvFirstTaskGet( pxList );
++			if( pxTCB != NULL ) {
++				// take care not to return garbage
++				return portVALID_TCB_MEM(pxTCB) ? pxTCB : NULL;
++			}
++		}
++		/* other tasks lists */
++		for (i = 0; i < DIM(task_lists); i++) {
++			List_t *pxList = task_lists[ i ];
++			if( bCurTaskListFound == pdFALSE && pxTaskList != NULL ) {
++				/* need to find list the current task item from */
++				if( pxTaskList == pxList ) {
++					bCurTaskListFound = pdTRUE;
++				}
++				continue; /* go to the next 'ready list' */
++			}
++			pxTCB = prvFirstTaskGet( pxList );
++			if( pxTCB != NULL ) {
++				// take care not to return garbage
++				return portVALID_TCB_MEM(pxTCB) ? pxTCB : NULL;
++			}
++		}
++
++		return NULL;
++	}
++
++#endif
+diff --git a/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/event_groups.c b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/event_groups.c
+new file mode 100644
+index 0000000000..1b708564ed
+--- /dev/null
++++ b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/event_groups.c
+@@ -0,0 +1,225 @@
++/*
++ * FreeRTOS Kernel V10.4.6
++ * 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
++ *
++ */
++
++/* Standard includes. */
++#include <stdlib.h>
++
++/* FreeRTOS includes. */
++#include "FreeRTOS.h"
++#include "task.h"
++#include "event_groups.h"
++
++typedef struct EventGroupDef_t
++{
++    struct rt_event event;
++} EventGroup_t;
++
++static volatile rt_uint8_t event_index = 0;
++
++/*-----------------------------------------------------------*/
++
++#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
++
++    EventGroupHandle_t xEventGroupCreateStatic( StaticEventGroup_t * pxEventGroupBuffer )
++    {
++        char name[RT_NAME_MAX] = {0};
++
++        /* A StaticEventGroup_t object must be provided. */
++        configASSERT( pxEventGroupBuffer );
++
++        rt_snprintf( name, RT_NAME_MAX, "event%02d", event_index++ );
++        rt_event_init( ( rt_event_t ) pxEventGroupBuffer, name, RT_IPC_FLAG_PRIO );
++
++        return ( EventGroupHandle_t ) pxEventGroupBuffer;
++    }
++
++#endif /* configSUPPORT_STATIC_ALLOCATION */
++/*-----------------------------------------------------------*/
++
++#if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
++
++    EventGroupHandle_t xEventGroupCreate( void )
++    {
++        EventGroup_t * pxEventBits;
++        char name[RT_NAME_MAX] = {0};
++
++        rt_snprintf( name, RT_NAME_MAX, "event%02d", event_index++ );
++        pxEventBits = ( EventGroup_t * ) rt_event_create( name, RT_IPC_FLAG_PRIO );
++
++        return pxEventBits;
++    }
++
++#endif /* configSUPPORT_DYNAMIC_ALLOCATION */
++/*-----------------------------------------------------------*/
++
++EventBits_t xEventGroupWaitBits( EventGroupHandle_t xEventGroup,
++                                 const EventBits_t uxBitsToWaitFor,
++                                 const BaseType_t xClearOnExit,
++                                 const BaseType_t xWaitForAllBits,
++                                 TickType_t xTicksToWait )
++{
++    rt_event_t event = ( rt_event_t ) xEventGroup;
++    rt_uint8_t option = 0;
++    rt_uint32_t recved;
++    rt_base_t level;
++    rt_err_t err;
++
++    /* 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 != 0 );
++    #if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
++        {
++            configASSERT( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) );
++        }
++    #endif
++
++    if ( xWaitForAllBits != pdFALSE )
++    {
++        option |= RT_EVENT_FLAG_AND;
++    }
++    else
++    {
++        option |= RT_EVENT_FLAG_OR;
++    }
++    if ( xClearOnExit != pdFALSE )
++    {
++        option |= RT_EVENT_FLAG_CLEAR;
++    }
++    err = rt_event_recv( event, ( rt_uint32_t ) uxBitsToWaitFor, option, ( rt_int32_t ) xTicksToWait, &recved );
++
++    if ( err != RT_EOK )
++    {
++        level = rt_hw_interrupt_disable();
++        recved = event->set;
++        rt_hw_interrupt_enable(level);
++    }
++
++    return ( EventBits_t ) recved;
++}
++/*-----------------------------------------------------------*/
++
++EventBits_t xEventGroupClearBits( EventGroupHandle_t xEventGroup,
++                                  const EventBits_t uxBitsToClear )
++{
++    rt_event_t event = ( rt_event_t ) xEventGroup;
++    EventBits_t uxReturn;
++    rt_base_t level;
++
++    configASSERT( xEventGroup );
++
++    level = rt_hw_interrupt_disable();
++    uxReturn = ( EventBits_t ) event->set;
++    event->set &= ~( ( rt_uint32_t ) uxBitsToClear );
++    rt_hw_interrupt_enable( level );
++
++    return uxReturn;
++}
++/*-----------------------------------------------------------*/
++
++BaseType_t xEventGroupClearBitsFromISR( EventGroupHandle_t xEventGroup,
++                                        const EventBits_t uxBitsToClear )
++{
++    return xEventGroupClearBits( xEventGroup, uxBitsToClear );
++}
++
++EventBits_t xEventGroupGetBitsFromISR( EventGroupHandle_t xEventGroup )
++{
++    rt_event_t event = ( rt_event_t ) xEventGroup;
++    EventBits_t uxReturn;
++    rt_base_t level;
++
++    level = rt_hw_interrupt_disable();
++    uxReturn = ( EventBits_t ) event->set;
++    rt_hw_interrupt_enable( level );
++
++    return uxReturn;
++}
++/*-----------------------------------------------------------*/
++
++EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup,
++                                const EventBits_t uxBitsToSet )
++{
++    rt_event_t event = ( rt_event_t ) xEventGroup;
++    rt_base_t level;
++    EventBits_t uxReturn;
++
++    configASSERT( xEventGroup );
++
++    rt_event_send( event, ( rt_uint32_t ) uxBitsToSet);
++
++    level = rt_hw_interrupt_disable();
++    uxReturn = ( EventBits_t ) event->set;
++    rt_hw_interrupt_enable(level);
++
++    return uxReturn;
++}
++/*-----------------------------------------------------------*/
++
++void vEventGroupDelete( EventGroupHandle_t xEventGroup )
++{
++    rt_event_t event = ( rt_event_t ) xEventGroup;
++
++    configASSERT( xEventGroup );
++
++#if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
++    if ( rt_object_is_systemobject( ( rt_object_t ) event ) )
++#endif
++    {
++    #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
++        rt_event_detach( event );
++    #endif
++#if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
++    }
++    else
++    {
++#endif
++    #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
++        rt_event_delete( event );
++    #endif
++    }
++}
++/*-----------------------------------------------------------*/
++
++#if ( ( configUSE_TRACE_FACILITY == 1 ) && ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) )
++
++    BaseType_t xEventGroupSetBitsFromISR( EventGroupHandle_t xEventGroup,
++                                          const EventBits_t uxBitsToSet,
++                                          BaseType_t * pxHigherPriorityTaskWoken )
++    {
++        xEventGroupSetBits( xEventGroup, uxBitsToSet );
++        if ( pxHigherPriorityTaskWoken != NULL)
++        {
++            pxHigherPriorityTaskWoken = pdFALSE;
++        }
++
++        return pdPASS;
++    }
++
++#endif /* if ( ( configUSE_TRACE_FACILITY == 1 ) && ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) ) */
++/*-----------------------------------------------------------*/
+diff --git a/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/freertos_v8_compat.c b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/freertos_v8_compat.c
+new file mode 100644
+index 0000000000..fe8d689125
+--- /dev/null
++++ b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/freertos_v8_compat.c
+@@ -0,0 +1,33 @@
++// Copyright 2020 Espressif Systems (Shanghai) Co., Ltd.
++//
++// Licensed under the Apache License, Version 2.0 (the "License");
++// you may not use this file except in compliance with the License.
++// You may obtain a copy of the License at
++//
++//     http://www.apache.org/licenses/LICENSE-2.0
++//
++// Unless required by applicable law or agreed to in writing, software
++// distributed under the License is distributed on an "AS IS" BASIS,
++// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++// See the License for the specific language governing permissions and
++// limitations under the License.
++
++#include "FreeRTOS.h"
++#include "queue.h"
++#include "semphr.h"
++
++/* This API is kept for backward ABI compatibility with prebuilt libraries against FreeRTOS v8/v9 in ESP-IDF */
++BaseType_t xQueueGenericReceive( QueueHandle_t xQueue, void * const pvBuffer, TickType_t xTicksToWait, const BaseType_t xPeek )
++{
++	if ( xPeek == pdTRUE )
++	{
++		return xQueuePeek( xQueue, pvBuffer, xTicksToWait );
++	}
++
++	if ( pvBuffer == NULL )
++	{
++		return xQueueSemaphoreTake( xQueue, xTicksToWait );
++	}
++
++	return xQueueReceive( xQueue, pvBuffer, xTicksToWait );
++}
+diff --git a/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/esp_additions/freertos/FreeRTOSConfig.h b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/esp_additions/freertos/FreeRTOSConfig.h
+new file mode 100644
+index 0000000000..8a4739a3a5
+--- /dev/null
++++ b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/esp_additions/freertos/FreeRTOSConfig.h
+@@ -0,0 +1,326 @@
++/*
++    FreeRTOS V10 - Copyright (C) 2021 Real Time Engineers Ltd.
++    All rights reserved
++
++    VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
++
++    This file is part of the FreeRTOS distribution.
++
++    FreeRTOS is free software; you can redistribute it and/or modify it under
++    the terms of the GNU General Public License (version 2) as published by the
++    Free Software Foundation >>!AND MODIFIED BY!<< the FreeRTOS exception.
++
++	***************************************************************************
++    >>!   NOTE: The modification to the GPL is included to allow you to     !<<
++    >>!   distribute a combined work that includes FreeRTOS without being   !<<
++    >>!   obliged to provide the source code for proprietary components     !<<
++    >>!   outside of the FreeRTOS kernel.                                   !<<
++	***************************************************************************
++
++    FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY
++    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
++    FOR A PARTICULAR PURPOSE.  Full license text is available on the following
++    link: http://www.freertos.org/a00114.html
++
++    ***************************************************************************
++     *                                                                       *
++     *    FreeRTOS provides completely free yet professionally developed,    *
++     *    robust, strictly quality controlled, supported, and cross          *
++     *    platform software that is more than just the market leader, it     *
++     *    is the industry's de facto standard.                               *
++     *                                                                       *
++     *    Help yourself get started quickly while simultaneously helping     *
++     *    to support the FreeRTOS project by purchasing a FreeRTOS           *
++     *    tutorial book, reference manual, or both:                          *
++     *    http://www.FreeRTOS.org/Documentation                              *
++     *                                                                       *
++    ***************************************************************************
++
++    http://www.FreeRTOS.org/FAQHelp.html - Having a problem?  Start by reading
++	the FAQ page "My application does not run, what could be wrong?".  Have you
++	defined configASSERT()?
++
++	http://www.FreeRTOS.org/support - In return for receiving this top quality
++	embedded software for free we request you assist our global community by
++	participating in the support forum.
++
++	http://www.FreeRTOS.org/training - Investing in training allows your team to
++	be as productive as possible as early as possible.  Now you can receive
++	FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers
++	Ltd, and the world's leading authority on the world's leading RTOS.
++
++    http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,
++    including FreeRTOS+Trace - an indispensable productivity tool, a DOS
++    compatible FAT file system, and our tiny thread aware UDP/IP stack.
++
++    http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.
++    Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.
++
++    http://www.OpenRTOS.com - Real Time Engineers ltd. license FreeRTOS to High
++    Integrity Systems ltd. to sell under the OpenRTOS brand.  Low cost OpenRTOS
++    licenses offer ticketed support, indemnification and commercial middleware.
++
++    http://www.SafeRTOS.com - High Integrity Systems also provide a safety
++    engineered and independently SIL3 certified version for use in safety and
++    mission critical applications that require provable dependability.
++
++    1 tab == 4 spaces!
++*/
++
++#ifndef FREERTOS_CONFIG_H
++#define FREERTOS_CONFIG_H
++
++#include "sdkconfig.h"
++
++/* for likely and unlikely */
++#include "esp_compiler.h"
++
++// The arch-specific FreeRTOSConfig_arch.h in port/<arch>/include.
++#include "freertos/FreeRTOSConfig_arch.h"
++
++#if !(defined(FREERTOS_CONFIG_XTENSA_H) \
++        || defined(FREERTOS_CONFIG_RISCV_H) \
++        || defined(FREERTOS_CONFIG_LINUX_H))
++#error "Needs architecture-speific FreeRTOSConfig.h!"
++#endif
++
++#ifndef CONFIG_FREERTOS_UNICORE
++#define portNUM_PROCESSORS                              2
++#else
++#define portNUM_PROCESSORS                              1
++#endif
++
++#define portUSING_MPU_WRAPPERS                          0
++#define configUSE_MUTEX                                 1
++
++#define configNUM_THREAD_LOCAL_STORAGE_POINTERS CONFIG_FREERTOS_THREAD_LOCAL_STORAGE_POINTERS
++#define configTHREAD_LOCAL_STORAGE_DELETE_CALLBACKS     1
++
++/* configASSERT behaviour */
++#ifndef __ASSEMBLER__
++#include <assert.h>
++
++// If CONFIG_FREERTOS_ASSERT_DISABLE is set then configASSERT is defined empty later in FreeRTOS.h and the macro
++// configASSERT_DEFINED remains unset (meaning some warnings are avoided)
++
++#if defined(CONFIG_FREERTOS_ASSERT_FAIL_PRINT_CONTINUE)
++#define configASSERT(a) if (unlikely(!(a))) {                               \
++        esp_rom_printf("%s:%d (%s)- assert failed!\n", __FILE__, __LINE__,  \
++                   __FUNCTION__);                                           \
++    }
++#elif defined(CONFIG_FREERTOS_ASSERT_FAIL_ABORT)
++#define configASSERT(a) assert(a)
++#endif
++
++#if CONFIG_FREERTOS_ASSERT_ON_UNTESTED_FUNCTION
++#define UNTESTED_FUNCTION() { esp_rom_printf("Untested FreeRTOS function %s\r\n", __FUNCTION__); configASSERT(false); } while(0)
++#else
++#define UNTESTED_FUNCTION()
++#endif
++
++#endif /* def __ASSEMBLER__ */
++
++/*-----------------------------------------------------------
++ * Application specific definitions.
++ *
++ * These definitions should be adjusted for your particular hardware and
++ * application requirements.
++ *
++ * Note that the default heap size is deliberately kept small so that
++ * the build is more likely to succeed for configurations with limited
++ * memory.
++ *
++ * THESE PARAMETERS ARE DESCRIBED WITHIN THE 'CONFIGURATION' SECTION OF THE
++ * FreeRTOS API DOCUMENTATION AVAILABLE ON THE FreeRTOS.org WEB SITE.
++ *----------------------------------------------------------*/
++
++#define configUSE_PREEMPTION                            1
++#define configUSE_IDLE_HOOK                             1
++#define configUSE_TICK_HOOK                             1
++#define configRECORD_STACK_HIGH_ADDRESS                 1
++#define configTICK_RATE_HZ                              ( CONFIG_FREERTOS_HZ )
++
++/* This has impact on speed of search for highest priority */
++#define configMAX_PRIORITIES                            ( 32 )
++
++/* Various things that impact minimum stack sizes */
++
++/* Higher stack checker modes cause overhead on each function call */
++#if CONFIG_STACK_CHECK_ALL || CONFIG_STACK_CHECK_STRONG
++#define configSTACK_OVERHEAD_CHECKER                    256
++#else
++#define configSTACK_OVERHEAD_CHECKER                    0
++#endif
++
++/* with optimizations disabled, scheduler uses additional stack */
++#if CONFIG_COMPILER_OPTIMIZATION_NONE
++#define configSTACK_OVERHEAD_OPTIMIZATION               320
++#else
++#define configSTACK_OVERHEAD_OPTIMIZATION               0
++#endif
++
++/* apptrace mdule increases minimum stack usage */
++#if CONFIG_APPTRACE_ENABLE
++#define configSTACK_OVERHEAD_APPTRACE                   1280
++#else
++#define configSTACK_OVERHEAD_APPTRACE                   0
++#endif
++
++/* Stack watchpoint decreases minimum usable stack size by up to 60 bytes.
++   See FreeRTOS FREERTOS_WATCHPOINT_END_OF_STACK option in Kconfig. */
++#if CONFIG_FREERTOS_WATCHPOINT_END_OF_STACK
++#define configSTACK_OVERHEAD_WATCHPOINT                   60
++#else
++#define configSTACK_OVERHEAD_WATCHPOINT                   0
++#endif
++
++#define configSTACK_OVERHEAD_TOTAL (                                    \
++                                    configSTACK_OVERHEAD_CHECKER +      \
++                                    configSTACK_OVERHEAD_OPTIMIZATION + \
++                                    configSTACK_OVERHEAD_APPTRACE +     \
++                                    configSTACK_OVERHEAD_WATCHPOINT     \
++                                                                        )
++
++#define configMINIMAL_STACK_SIZE                        (768 + configSTACK_OVERHEAD_TOTAL)
++
++#ifndef configIDLE_TASK_STACK_SIZE
++#define configIDLE_TASK_STACK_SIZE CONFIG_FREERTOS_IDLE_TASK_STACKSIZE
++#endif
++
++/* Minimal heap size to make sure examples can run on memory limited
++   configs. Adjust this to suit your system. */
++
++
++//We define the heap to span all of the non-statically-allocated shared RAM. ToDo: Make sure there
++//is some space left for the app and main cpu when running outside of a thread.
++#define configAPPLICATION_ALLOCATED_HEAP                1
++#define configTOTAL_HEAP_SIZE                           (&_heap_end - &_heap_start)//( ( size_t ) (64 * 1024) )
++
++#define configMAX_TASK_NAME_LEN                         ( CONFIG_FREERTOS_MAX_TASK_NAME_LEN )
++
++#ifdef CONFIG_FREERTOS_USE_TRACE_FACILITY
++#define configUSE_TRACE_FACILITY                        1       /* Used by uxTaskGetSystemState(), and other trace facility functions */
++#endif
++
++#ifdef CONFIG_FREERTOS_USE_STATS_FORMATTING_FUNCTIONS
++#define configUSE_STATS_FORMATTING_FUNCTIONS            1   /* Used by vTaskList() */
++#endif
++
++#ifdef CONFIG_FREERTOS_VTASKLIST_INCLUDE_COREID
++#define configTASKLIST_INCLUDE_COREID                   1
++#endif
++
++#ifdef CONFIG_FREERTOS_GENERATE_RUN_TIME_STATS
++#define configGENERATE_RUN_TIME_STATS                   1       /* Used by vTaskGetRunTimeStats() */
++#endif
++
++#define configBENCHMARK                                 0
++#define configUSE_16_BIT_TICKS                          0
++#define configIDLE_SHOULD_YIELD                         0
++#define configQUEUE_REGISTRY_SIZE                       CONFIG_FREERTOS_QUEUE_REGISTRY_SIZE
++
++#define configUSE_MUTEXES                               1
++#define configUSE_RECURSIVE_MUTEXES                     1
++#define configUSE_COUNTING_SEMAPHORES                   1
++
++#if CONFIG_FREERTOS_CHECK_STACKOVERFLOW_NONE
++#define configCHECK_FOR_STACK_OVERFLOW                  0
++#elif CONFIG_FREERTOS_CHECK_STACKOVERFLOW_PTRVAL
++#define configCHECK_FOR_STACK_OVERFLOW                  1
++#elif CONFIG_FREERTOS_CHECK_STACKOVERFLOW_CANARY
++#define configCHECK_FOR_STACK_OVERFLOW                  2
++#endif
++
++
++/* Co-routine definitions. */
++#define configUSE_CO_ROUTINES                           0
++#define configMAX_CO_ROUTINE_PRIORITIES                 ( 2 )
++
++/* Set the following definitions to 1 to include the API function, or zero
++   to exclude the API function. */
++
++#define INCLUDE_vTaskPrioritySet                        1
++#define INCLUDE_uxTaskPriorityGet                       1
++#define INCLUDE_vTaskDelete                             1
++#define INCLUDE_vTaskCleanUpResources                   0
++#define INCLUDE_vTaskSuspend                            1
++#define INCLUDE_vTaskDelayUntil                         1
++#define INCLUDE_vTaskDelay                              1
++#define INCLUDE_uxTaskGetStackHighWaterMark             1
++#define INCLUDE_pcTaskGetTaskName                       1
++#define INCLUDE_xTaskGetIdleTaskHandle                  1
++#define INCLUDE_pxTaskGetStackStart                     1
++#define INCLUDE_eTaskGetState                           1
++#define INCLUDE_xTaskAbortDelay                         1
++#define INCLUDE_xTaskGetHandle                          1
++#define INCLUDE_xSemaphoreGetMutexHolder                1
++#define INCLUDE_xTimerPendFunctionCall                  1
++#define INCLUDE_xTimerGetTimerDaemonTaskHandle          0   //Currently there is no need for this API
++
++/* The priority at which the tick interrupt runs.  This should probably be
++   kept at 1. */
++#define configKERNEL_INTERRUPT_PRIORITY                 1
++
++#if !CONFIG_IDF_TARGET_LINUX
++#define configUSE_NEWLIB_REENTRANT                      1
++#endif
++
++#define configSUPPORT_DYNAMIC_ALLOCATION                1
++#define configSUPPORT_STATIC_ALLOCATION                 1
++
++#ifndef __ASSEMBLER__
++#if CONFIG_FREERTOS_ENABLE_STATIC_TASK_CLEAN_UP
++extern void vPortCleanUpTCB ( void *pxTCB );
++#define portCLEAN_UP_TCB( pxTCB )           vPortCleanUpTCB( pxTCB )
++#endif
++#endif
++
++/* Test FreeRTOS timers (with timer task) and more. */
++/* Some files don't compile if this flag is disabled */
++#define configUSE_TIMERS                                1
++#define configTIMER_TASK_PRIORITY                       CONFIG_FREERTOS_TIMER_TASK_PRIORITY
++#define configTIMER_QUEUE_LENGTH                        CONFIG_FREERTOS_TIMER_QUEUE_LENGTH
++#define configTIMER_TASK_STACK_DEPTH                    CONFIG_FREERTOS_TIMER_TASK_STACK_DEPTH
++
++#define configUSE_QUEUE_SETS                            1
++
++#define configUSE_TICKLESS_IDLE                         CONFIG_FREERTOS_USE_TICKLESS_IDLE
++#if configUSE_TICKLESS_IDLE
++#define configEXPECTED_IDLE_TIME_BEFORE_SLEEP           CONFIG_FREERTOS_IDLE_TIME_BEFORE_SLEEP
++#endif //configUSE_TICKLESS_IDLE
++
++
++#if CONFIG_FREERTOS_ENABLE_TASK_SNAPSHOT
++#define configENABLE_TASK_SNAPSHOT                      1
++#endif
++#ifndef configENABLE_TASK_SNAPSHOT
++#define configENABLE_TASK_SNAPSHOT                      0
++#endif
++
++#if CONFIG_SYSVIEW_ENABLE
++#ifndef __ASSEMBLER__
++#include "SEGGER_SYSVIEW_FreeRTOS.h"
++#undef INLINE // to avoid redefinition
++#endif /* def __ASSEMBLER__ */
++#endif
++
++#if CONFIG_FREERTOS_CHECK_MUTEX_GIVEN_BY_OWNER
++#define configCHECK_MUTEX_GIVEN_BY_OWNER                1
++#else
++#define configCHECK_MUTEX_GIVEN_BY_OWNER                0
++#endif
++
++
++#define configINCLUDE_FREERTOS_TASK_C_ADDITIONS_H       1
++
++#define configTASK_NOTIFICATION_ARRAY_ENTRIES           1
++
++// backward compatibility for 4.4
++#define xTaskRemoveFromUnorderedEventList vTaskRemoveFromUnorderedEventList
++
++#define configNUM_CORES                                 portNUM_PROCESSORS
++
++/* RT-Thread wrapper */
++#define INCLUDE_xTaskGetCurrentTaskHandle   1
++
++#endif /* FREERTOS_CONFIG_H */
+diff --git a/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/esp_additions/freertos/task_snapshot.h b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/esp_additions/freertos/task_snapshot.h
+new file mode 100644
+index 0000000000..1ad04cce69
+--- /dev/null
++++ b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/esp_additions/freertos/task_snapshot.h
+@@ -0,0 +1,90 @@
++// Copyright 2015-2021 Espressif Systems (Shanghai) PTE LTD
++//
++// Licensed under the Apache License, Version 2.0 (the "License");
++// you may not use this file except in compliance with the License.
++// You may obtain a copy of the License at
++//
++//     http://www.apache.org/licenses/LICENSE-2.0
++//
++// Unless required by applicable law or agreed to in writing, software
++// distributed under the License is distributed on an "AS IS" BASIS,
++// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++// See the License for the specific language governing permissions and
++// limitations under the License.
++
++#pragma once
++
++#include "freertos/FreeRTOS.h"
++#include "freertos/task.h"
++
++#if ( configENABLE_TASK_SNAPSHOT == 1 )
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++/**
++ * Check `freertos_tasks_c_additions.h` file for more info
++ * about these functions declaration.
++ */
++UBaseType_t pxTCBGetSize ( void );
++ListItem_t*	pxTCBGetStateListItem ( void *pxTCB );
++StackType_t* pxTCBGetStartOfStack ( void *pxTCB );
++StackType_t* pxTCBGetTopOfStack ( void *pxTCB );
++StackType_t* pxTCBGetEndOfStack ( void *pxTCB );
++List_t* pxListGetReadyTask ( UBaseType_t idx );
++List_t* pxListGetReadyPendingTask ( UBaseType_t idx );
++List_t* pxGetDelayedTaskList ( void );
++List_t* pxGetOverflowDelayedTaskList ( void );
++List_t* pxGetTasksWaitingTermination ( void );
++List_t* pxGetSuspendedTaskList ( void );
++
++/**
++ * Used with the uxTaskGetSnapshotAll() function to save memory snapshot of each task in the system.
++ * We need this struct because TCB_t is defined (hidden) in tasks.c.
++ */
++typedef struct xTASK_SNAPSHOT
++{
++	void        *pxTCB;         /*!< Address of task control block. */
++	StackType_t *pxTopOfStack;  /*!< Points to the location of the last item placed on the tasks stack. */
++	StackType_t *pxEndOfStack;  /*!< Points to the end of the stack. pxTopOfStack < pxEndOfStack, stack grows hi2lo
++									pxTopOfStack > pxEndOfStack, stack grows lo2hi*/
++} TaskSnapshot_t;
++
++
++/*
++ * This function fills array with TaskSnapshot_t structures for every task in the system.
++ * Used by panic handling code to get snapshots of all tasks in the system.
++ * Only available when configENABLE_TASK_SNAPSHOT is set to 1.
++ * @param pxTaskSnapshotArray Pointer to array of TaskSnapshot_t structures to store tasks snapshot data.
++ * @param uxArraySize Size of tasks snapshots array.
++ * @param pxTcbSz Pointer to store size of TCB.
++ * @return Number of elements stored in array.
++ */
++UBaseType_t uxTaskGetSnapshotAll( TaskSnapshot_t * const pxTaskSnapshotArray, const UBaseType_t uxArraySize, UBaseType_t * const pxTcbSz );
++
++/*
++ * This function iterates over all tasks in the system.
++ * Used by panic handling code to iterate over tasks in the system.
++ * Only available when configENABLE_TASK_SNAPSHOT is set to 1.
++ * @note This function should not be used while FreeRTOS is running (as it doesn't acquire any locks).
++ * @param pxTask task handle.
++ * @return Handle for the next task. If pxTask is NULL, returns hadnle for the first task.
++ */
++TaskHandle_t pxTaskGetNext( TaskHandle_t pxTask );
++
++/*
++ * This function fills TaskSnapshot_t structure for specified task.
++ * Used by panic handling code to get snapshot of a task.
++ * Only available when configENABLE_TASK_SNAPSHOT is set to 1.
++ * @note This function should not be used while FreeRTOS is running (as it doesn't acquire any locks).
++ * @param pxTask task handle.
++ * @param pxTaskSnapshot address of TaskSnapshot_t structure to fill.
++ */
++void vTaskGetSnapshot( TaskHandle_t pxTask, TaskSnapshot_t *pxTaskSnapshot );
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif
+diff --git a/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/freertos/FreeRTOS.h b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/freertos/FreeRTOS.h
+new file mode 100644
+index 0000000000..b3efa13f20
+--- /dev/null
++++ b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/freertos/FreeRTOS.h
+@@ -0,0 +1,1198 @@
++/*
++ * FreeRTOS Kernel V10.4.6
++ * 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_FREERTOS_H
++#define INC_FREERTOS_H
++
++/*
++ * Include the generic headers required for the FreeRTOS port being used.
++ */
++#include <stddef.h>
++
++/*
++ * If stdint.h cannot be located then:
++ *   + If using GCC ensure the -nostdint options is *not* being used.
++ *   + Ensure the project's include path includes the directory in which your
++ *     compiler stores stdint.h.
++ *   + Set any compiler options necessary for it to support C99, as technically
++ *     stdint.h is only mandatory with C99 (FreeRTOS does not require C99 in any
++ *     other way).
++ *   + The FreeRTOS download includes a simple stdint.h definition that can be
++ *     used in cases where none is provided by the compiler.  The files only
++ *     contains the typedefs required to build FreeRTOS.  Read the instructions
++ *     in FreeRTOS/source/stdint.readme for more information.
++ */
++#include <stdint.h> /* READ COMMENT ABOVE. */
++
++/* *INDENT-OFF* */
++#ifdef __cplusplus
++    extern "C" {
++#endif
++/* *INDENT-ON* */
++
++#include <rtthread.h>
++#include <rthw.h>
++
++/* Application specific configuration options. */
++#include "FreeRTOSConfig.h"
++
++/* Basic FreeRTOS definitions. */
++#include "projdefs.h"
++
++/* Definitions specific to the port being used. */
++#include "portable.h"
++
++/* Must be defaulted before configUSE_NEWLIB_REENTRANT is used below. */
++#ifndef configUSE_NEWLIB_REENTRANT
++    #define configUSE_NEWLIB_REENTRANT    0
++#endif
++
++/* Required if struct _reent is used. */
++#if ( configUSE_NEWLIB_REENTRANT == 1 )
++    #include <reent.h>
++#endif
++
++/*
++ * Check all the required application specific macros have been defined.
++ * These macros are application specific and (as downloaded) are defined
++ * within FreeRTOSConfig.h.
++ */
++
++#ifndef configMINIMAL_STACK_SIZE
++    #error Missing definition:  configMINIMAL_STACK_SIZE must be defined in FreeRTOSConfig.h.  configMINIMAL_STACK_SIZE defines the size (in words) of the stack allocated to the idle task.  Refer to the demo project provided for your port for a suitable value.
++#endif
++
++#ifndef configMAX_PRIORITIES
++    #error Missing definition:  configMAX_PRIORITIES must be defined in FreeRTOSConfig.h.  See the Configuration section of the FreeRTOS API documentation for details.
++#endif
++
++#if configMAX_PRIORITIES < 1
++    #error configMAX_PRIORITIES must be defined to be greater than or equal to 1.
++#endif
++
++#ifndef configUSE_PREEMPTION
++    #error Missing definition:  configUSE_PREEMPTION must be defined in FreeRTOSConfig.h as either 1 or 0.  See the Configuration section of the FreeRTOS API documentation for details.
++#endif
++
++#ifndef configUSE_IDLE_HOOK
++    #error Missing definition:  configUSE_IDLE_HOOK must be defined in FreeRTOSConfig.h as either 1 or 0.  See the Configuration section of the FreeRTOS API documentation for details.
++#endif
++
++#ifndef configUSE_TICK_HOOK
++    #error Missing definition:  configUSE_TICK_HOOK must be defined in FreeRTOSConfig.h as either 1 or 0.  See the Configuration section of the FreeRTOS API documentation for details.
++#endif
++
++#ifndef configUSE_16_BIT_TICKS
++    #error Missing definition:  configUSE_16_BIT_TICKS must be defined in FreeRTOSConfig.h as either 1 or 0.  See the Configuration section of the FreeRTOS API documentation for details.
++#endif
++
++#ifndef configUSE_CO_ROUTINES
++    #define configUSE_CO_ROUTINES    0
++#endif
++
++#ifndef INCLUDE_vTaskPrioritySet
++    #define INCLUDE_vTaskPrioritySet    0
++#endif
++
++#ifndef INCLUDE_uxTaskPriorityGet
++    #define INCLUDE_uxTaskPriorityGet    0
++#endif
++
++#ifndef INCLUDE_vTaskDelete
++    #define INCLUDE_vTaskDelete    0
++#endif
++
++#ifndef INCLUDE_vTaskSuspend
++    #define INCLUDE_vTaskSuspend    0
++#endif
++
++#ifdef INCLUDE_xTaskDelayUntil
++    #ifdef INCLUDE_vTaskDelayUntil
++
++/* INCLUDE_vTaskDelayUntil was replaced by INCLUDE_xTaskDelayUntil.  Backward
++ * compatibility is maintained if only one or the other is defined, but
++ * there is a conflict if both are defined. */
++        #error INCLUDE_vTaskDelayUntil and INCLUDE_xTaskDelayUntil are both defined.  INCLUDE_vTaskDelayUntil is no longer required and should be removed
++    #endif
++#endif
++
++#ifndef INCLUDE_xTaskDelayUntil
++    #ifdef INCLUDE_vTaskDelayUntil
++
++/* If INCLUDE_vTaskDelayUntil is set but INCLUDE_xTaskDelayUntil is not then
++ * the project's FreeRTOSConfig.h probably pre-dates the introduction of
++ * xTaskDelayUntil and setting INCLUDE_xTaskDelayUntil to whatever
++ * INCLUDE_vTaskDelayUntil is set to will ensure backward compatibility.
++ */
++        #define INCLUDE_xTaskDelayUntil    INCLUDE_vTaskDelayUntil
++    #endif
++#endif
++
++#ifndef INCLUDE_xTaskDelayUntil
++    #define INCLUDE_xTaskDelayUntil    0
++#endif
++
++#ifndef INCLUDE_vTaskDelay
++    #define INCLUDE_vTaskDelay    0
++#endif
++
++#ifndef INCLUDE_xTaskGetIdleTaskHandle
++    #define INCLUDE_xTaskGetIdleTaskHandle    0
++#endif
++
++#ifndef INCLUDE_xTaskAbortDelay
++    #define INCLUDE_xTaskAbortDelay    0
++#endif
++
++#ifndef INCLUDE_xQueueGetMutexHolder
++    #define INCLUDE_xQueueGetMutexHolder    0
++#endif
++
++#ifndef INCLUDE_xSemaphoreGetMutexHolder
++    #define INCLUDE_xSemaphoreGetMutexHolder    INCLUDE_xQueueGetMutexHolder
++#endif
++
++#ifndef INCLUDE_xTaskGetHandle
++    #define INCLUDE_xTaskGetHandle    0
++#endif
++
++#ifndef INCLUDE_uxTaskGetStackHighWaterMark
++    #define INCLUDE_uxTaskGetStackHighWaterMark    0
++#endif
++
++#ifndef INCLUDE_uxTaskGetStackHighWaterMark2
++    #define INCLUDE_uxTaskGetStackHighWaterMark2    0
++#endif
++
++#ifndef INCLUDE_eTaskGetState
++    #define INCLUDE_eTaskGetState    0
++#endif
++
++#ifndef INCLUDE_xTaskResumeFromISR
++    #define INCLUDE_xTaskResumeFromISR    1
++#endif
++
++#ifndef INCLUDE_xTimerPendFunctionCall
++    #define INCLUDE_xTimerPendFunctionCall    0
++#endif
++
++#ifndef INCLUDE_xTaskGetSchedulerState
++    #define INCLUDE_xTaskGetSchedulerState    0
++#endif
++
++#ifndef INCLUDE_xTaskGetCurrentTaskHandle
++    #define INCLUDE_xTaskGetCurrentTaskHandle    0
++#endif
++
++#if configUSE_CO_ROUTINES != 0
++    #ifndef configMAX_CO_ROUTINE_PRIORITIES
++        #error configMAX_CO_ROUTINE_PRIORITIES must be greater than or equal to 1.
++    #endif
++#endif
++
++#ifndef configUSE_DAEMON_TASK_STARTUP_HOOK
++    #define configUSE_DAEMON_TASK_STARTUP_HOOK    0
++#endif
++
++#ifndef configUSE_APPLICATION_TASK_TAG
++    #define configUSE_APPLICATION_TASK_TAG    0
++#endif
++
++#ifndef configNUM_THREAD_LOCAL_STORAGE_POINTERS
++    #define configNUM_THREAD_LOCAL_STORAGE_POINTERS    0
++#endif
++
++#ifndef configUSE_RECURSIVE_MUTEXES
++    #define configUSE_RECURSIVE_MUTEXES    0
++#endif
++
++#ifndef configUSE_MUTEXES
++    #define configUSE_MUTEXES    0
++#endif
++
++#ifndef configUSE_TIMERS
++    #define configUSE_TIMERS    0
++#endif
++
++#ifndef configUSE_COUNTING_SEMAPHORES
++    #define configUSE_COUNTING_SEMAPHORES    0
++#endif
++
++#ifndef configUSE_ALTERNATIVE_API
++    #define configUSE_ALTERNATIVE_API    0
++#endif
++
++#ifndef portCRITICAL_NESTING_IN_TCB
++    #define portCRITICAL_NESTING_IN_TCB    0
++#endif
++
++#ifndef configMAX_TASK_NAME_LEN
++    #define configMAX_TASK_NAME_LEN    16
++#endif
++
++#ifndef configIDLE_SHOULD_YIELD
++    #define configIDLE_SHOULD_YIELD    1
++#endif
++
++#if configMAX_TASK_NAME_LEN < 1
++    #error configMAX_TASK_NAME_LEN must be set to a minimum of 1 in FreeRTOSConfig.h
++#endif
++
++#ifndef configASSERT
++    #define configASSERT( x )
++    #define configASSERT_DEFINED    0
++#else
++    #define configASSERT_DEFINED    1
++#endif
++
++/* configPRECONDITION should be defined as configASSERT.
++ * The CBMC proofs need a way to track assumptions and assertions.
++ * A configPRECONDITION statement should express an implicit invariant or
++ * assumption made.  A configASSERT statement should express an invariant that must
++ * hold explicit before calling the code. */
++#ifndef configPRECONDITION
++    #define configPRECONDITION( X )    configASSERT( X )
++    #define configPRECONDITION_DEFINED    0
++#else
++    #define configPRECONDITION_DEFINED    1
++#endif
++
++#ifndef portMEMORY_BARRIER
++    #define portMEMORY_BARRIER()
++#endif
++
++#ifndef portSOFTWARE_BARRIER
++    #define portSOFTWARE_BARRIER()
++#endif
++
++/* The timers module relies on xTaskGetSchedulerState(). */
++#if configUSE_TIMERS == 1
++
++    #ifndef configTIMER_TASK_PRIORITY
++        #error If configUSE_TIMERS is set to 1 then configTIMER_TASK_PRIORITY must also be defined.
++    #endif /* configTIMER_TASK_PRIORITY */
++
++    #ifndef configTIMER_QUEUE_LENGTH
++        #error If configUSE_TIMERS is set to 1 then configTIMER_QUEUE_LENGTH must also be defined.
++    #endif /* configTIMER_QUEUE_LENGTH */
++
++    #ifndef configTIMER_TASK_STACK_DEPTH
++        #error If configUSE_TIMERS is set to 1 then configTIMER_TASK_STACK_DEPTH must also be defined.
++    #endif /* configTIMER_TASK_STACK_DEPTH */
++
++#endif /* configUSE_TIMERS */
++
++#ifndef portSET_INTERRUPT_MASK_FROM_ISR
++    #define portSET_INTERRUPT_MASK_FROM_ISR()    0
++#endif
++
++#ifndef portCLEAR_INTERRUPT_MASK_FROM_ISR
++    #define portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedStatusValue )    ( void ) uxSavedStatusValue
++#endif
++
++#ifndef portCLEAN_UP_TCB
++    #define portCLEAN_UP_TCB( pxTCB )    ( void ) pxTCB
++#endif
++
++#ifndef portPRE_TASK_DELETE_HOOK
++    #define portPRE_TASK_DELETE_HOOK( pvTaskToDelete, pxYieldPending )
++#endif
++
++#ifndef portSETUP_TCB
++    #define portSETUP_TCB( pxTCB )    ( void ) pxTCB
++#endif
++
++#ifndef configQUEUE_REGISTRY_SIZE
++    #define configQUEUE_REGISTRY_SIZE    0U
++#endif
++
++#if ( configQUEUE_REGISTRY_SIZE < 1 )
++    #define vQueueAddToRegistry( xQueue, pcName )
++    #define vQueueUnregisterQueue( xQueue )
++    #define pcQueueGetName( xQueue )
++#endif
++
++#ifndef portPOINTER_SIZE_TYPE
++    #define portPOINTER_SIZE_TYPE    uint32_t
++#endif
++
++/* Remove any unused trace macros. */
++#ifndef traceSTART
++
++/* Used to perform any necessary initialisation - for example, open a file
++ * into which trace is to be written. */
++    #define traceSTART()
++#endif
++
++#ifndef traceEND
++
++/* Use to close a trace, for example close a file into which trace has been
++ * written. */
++    #define traceEND()
++#endif
++
++#ifndef traceTASK_SWITCHED_IN
++
++/* Called after a task has been selected to run.  pxCurrentTCB holds a pointer
++ * to the task control block of the selected task. */
++    #define traceTASK_SWITCHED_IN()
++#endif
++
++#ifndef traceINCREASE_TICK_COUNT
++
++/* Called before stepping the tick count after waking from tickless idle
++ * sleep. */
++    #define traceINCREASE_TICK_COUNT( x )
++#endif
++
++#ifndef traceLOW_POWER_IDLE_BEGIN
++    /* Called immediately before entering tickless idle. */
++    #define traceLOW_POWER_IDLE_BEGIN()
++#endif
++
++#ifndef traceLOW_POWER_IDLE_END
++    /* Called when returning to the Idle task after a tickless idle. */
++    #define traceLOW_POWER_IDLE_END()
++#endif
++
++#ifndef traceTASK_SWITCHED_OUT
++
++/* Called before a task has been selected to run.  pxCurrentTCB holds a pointer
++ * to the task control block of the task being switched out. */
++    #define traceTASK_SWITCHED_OUT()
++#endif
++
++#ifndef traceTASK_PRIORITY_INHERIT
++
++/* Called when a task attempts to take a mutex that is already held by a
++ * lower priority task.  pxTCBOfMutexHolder is a pointer to the TCB of the task
++ * that holds the mutex.  uxInheritedPriority is the priority the mutex holder
++ * will inherit (the priority of the task that is attempting to obtain the
++ * muted. */
++    #define traceTASK_PRIORITY_INHERIT( pxTCBOfMutexHolder, uxInheritedPriority )
++#endif
++
++#ifndef traceTASK_PRIORITY_DISINHERIT
++
++/* Called when a task releases a mutex, the holding of which had resulted in
++ * the task inheriting the priority of a higher priority task.
++ * pxTCBOfMutexHolder is a pointer to the TCB of the task that is releasing the
++ * mutex.  uxOriginalPriority is the task's configured (base) priority. */
++    #define traceTASK_PRIORITY_DISINHERIT( pxTCBOfMutexHolder, uxOriginalPriority )
++#endif
++
++#ifndef traceBLOCKING_ON_QUEUE_RECEIVE
++
++/* Task is about to block because it cannot read from a
++ * queue/mutex/semaphore.  pxQueue is a pointer to the queue/mutex/semaphore
++ * upon which the read was attempted.  pxCurrentTCB points to the TCB of the
++ * task that attempted the read. */
++    #define traceBLOCKING_ON_QUEUE_RECEIVE( pxQueue )
++#endif
++
++#ifndef traceBLOCKING_ON_QUEUE_PEEK
++
++/* Task is about to block because it cannot read from a
++ * queue/mutex/semaphore.  pxQueue is a pointer to the queue/mutex/semaphore
++ * upon which the read was attempted.  pxCurrentTCB points to the TCB of the
++ * task that attempted the read. */
++    #define traceBLOCKING_ON_QUEUE_PEEK( pxQueue )
++#endif
++
++#ifndef traceBLOCKING_ON_QUEUE_SEND
++
++/* Task is about to block because it cannot write to a
++ * queue/mutex/semaphore.  pxQueue is a pointer to the queue/mutex/semaphore
++ * upon which the write was attempted.  pxCurrentTCB points to the TCB of the
++ * task that attempted the write. */
++    #define traceBLOCKING_ON_QUEUE_SEND( pxQueue )
++#endif
++
++#ifndef configCHECK_FOR_STACK_OVERFLOW
++    #define configCHECK_FOR_STACK_OVERFLOW    0
++#endif
++
++#ifndef configRECORD_STACK_HIGH_ADDRESS
++    #define configRECORD_STACK_HIGH_ADDRESS    0
++#endif
++
++#ifndef configINCLUDE_FREERTOS_TASK_C_ADDITIONS_H
++    #define configINCLUDE_FREERTOS_TASK_C_ADDITIONS_H    0
++#endif
++
++/* The following event macros are embedded in the kernel API calls. */
++
++#ifndef traceMOVED_TASK_TO_READY_STATE
++    #define traceMOVED_TASK_TO_READY_STATE( pxTCB )
++#endif
++
++#ifndef tracePOST_MOVED_TASK_TO_READY_STATE
++    #define tracePOST_MOVED_TASK_TO_READY_STATE( pxTCB )
++#endif
++
++#ifndef traceQUEUE_CREATE
++    #define traceQUEUE_CREATE( pxNewQueue )
++#endif
++
++#ifndef traceQUEUE_CREATE_FAILED
++    #define traceQUEUE_CREATE_FAILED( ucQueueType )
++#endif
++
++#ifndef traceCREATE_MUTEX
++    #define traceCREATE_MUTEX( pxNewQueue )
++#endif
++
++#ifndef traceCREATE_MUTEX_FAILED
++    #define traceCREATE_MUTEX_FAILED()
++#endif
++
++#ifndef traceGIVE_MUTEX_RECURSIVE
++    #define traceGIVE_MUTEX_RECURSIVE( pxMutex )
++#endif
++
++#ifndef traceGIVE_MUTEX_RECURSIVE_FAILED
++    #define traceGIVE_MUTEX_RECURSIVE_FAILED( pxMutex )
++#endif
++
++#ifndef traceTAKE_MUTEX_RECURSIVE
++    #define traceTAKE_MUTEX_RECURSIVE( pxMutex )
++#endif
++
++#ifndef traceTAKE_MUTEX_RECURSIVE_FAILED
++    #define traceTAKE_MUTEX_RECURSIVE_FAILED( pxMutex )
++#endif
++
++#ifndef traceCREATE_COUNTING_SEMAPHORE
++    #define traceCREATE_COUNTING_SEMAPHORE()
++#endif
++
++#ifndef traceCREATE_COUNTING_SEMAPHORE_FAILED
++    #define traceCREATE_COUNTING_SEMAPHORE_FAILED()
++#endif
++
++#ifndef traceQUEUE_SET_SEND
++    #define traceQUEUE_SET_SEND    traceQUEUE_SEND
++#endif
++
++#ifndef traceQUEUE_SEND
++    #define traceQUEUE_SEND( pxQueue )
++#endif
++
++#ifndef traceQUEUE_SEND_FAILED
++    #define traceQUEUE_SEND_FAILED( pxQueue )
++#endif
++
++#ifndef traceQUEUE_RECEIVE
++    #define traceQUEUE_RECEIVE( pxQueue )
++#endif
++
++#ifndef traceQUEUE_PEEK
++    #define traceQUEUE_PEEK( pxQueue )
++#endif
++
++#ifndef traceQUEUE_PEEK_FAILED
++    #define traceQUEUE_PEEK_FAILED( pxQueue )
++#endif
++
++#ifndef traceQUEUE_PEEK_FROM_ISR
++    #define traceQUEUE_PEEK_FROM_ISR( pxQueue )
++#endif
++
++#ifndef traceQUEUE_RECEIVE_FAILED
++    #define traceQUEUE_RECEIVE_FAILED( pxQueue )
++#endif
++
++#ifndef traceQUEUE_SEND_FROM_ISR
++    #define traceQUEUE_SEND_FROM_ISR( pxQueue )
++#endif
++
++#ifndef traceQUEUE_SEND_FROM_ISR_FAILED
++    #define traceQUEUE_SEND_FROM_ISR_FAILED( pxQueue )
++#endif
++
++#ifndef traceQUEUE_RECEIVE_FROM_ISR
++    #define traceQUEUE_RECEIVE_FROM_ISR( pxQueue )
++#endif
++
++#ifndef traceQUEUE_RECEIVE_FROM_ISR_FAILED
++    #define traceQUEUE_RECEIVE_FROM_ISR_FAILED( pxQueue )
++#endif
++
++#ifndef traceQUEUE_PEEK_FROM_ISR_FAILED
++    #define traceQUEUE_PEEK_FROM_ISR_FAILED( pxQueue )
++#endif
++
++#ifndef traceQUEUE_DELETE
++    #define traceQUEUE_DELETE( pxQueue )
++#endif
++
++#ifndef traceTASK_CREATE
++    #define traceTASK_CREATE( pxNewTCB )
++#endif
++
++#ifndef traceTASK_CREATE_FAILED
++    #define traceTASK_CREATE_FAILED()
++#endif
++
++#ifndef traceTASK_DELETE
++    #define traceTASK_DELETE( pxTaskToDelete )
++#endif
++
++#ifndef traceTASK_DELAY_UNTIL
++    #define traceTASK_DELAY_UNTIL( x )
++#endif
++
++#ifndef traceTASK_DELAY
++    #define traceTASK_DELAY()
++#endif
++
++#ifndef traceTASK_PRIORITY_SET
++    #define traceTASK_PRIORITY_SET( pxTask, uxNewPriority )
++#endif
++
++#ifndef traceTASK_SUSPEND
++    #define traceTASK_SUSPEND( pxTaskToSuspend )
++#endif
++
++#ifndef traceTASK_RESUME
++    #define traceTASK_RESUME( pxTaskToResume )
++#endif
++
++#ifndef traceTASK_RESUME_FROM_ISR
++    #define traceTASK_RESUME_FROM_ISR( pxTaskToResume )
++#endif
++
++#ifndef traceTASK_INCREMENT_TICK
++    #define traceTASK_INCREMENT_TICK( xTickCount )
++#endif
++
++#ifndef traceTIMER_CREATE
++    #define traceTIMER_CREATE( pxNewTimer )
++#endif
++
++#ifndef traceTIMER_CREATE_FAILED
++    #define traceTIMER_CREATE_FAILED()
++#endif
++
++#ifndef traceTIMER_COMMAND_SEND
++    #define traceTIMER_COMMAND_SEND( xTimer, xMessageID, xMessageValueValue, xReturn )
++#endif
++
++#ifndef traceTIMER_EXPIRED
++    #define traceTIMER_EXPIRED( pxTimer )
++#endif
++
++#ifndef traceTIMER_COMMAND_RECEIVED
++    #define traceTIMER_COMMAND_RECEIVED( pxTimer, xMessageID, xMessageValue )
++#endif
++
++#ifndef traceMALLOC
++    #define traceMALLOC( pvAddress, uiSize )
++#endif
++
++#ifndef traceFREE
++    #define traceFREE( pvAddress, uiSize )
++#endif
++
++#ifndef traceEVENT_GROUP_CREATE
++    #define traceEVENT_GROUP_CREATE( xEventGroup )
++#endif
++
++#ifndef traceEVENT_GROUP_CREATE_FAILED
++    #define traceEVENT_GROUP_CREATE_FAILED()
++#endif
++
++#ifndef traceEVENT_GROUP_SYNC_BLOCK
++    #define traceEVENT_GROUP_SYNC_BLOCK( xEventGroup, uxBitsToSet, uxBitsToWaitFor )
++#endif
++
++#ifndef traceEVENT_GROUP_SYNC_END
++    #define traceEVENT_GROUP_SYNC_END( xEventGroup, uxBitsToSet, uxBitsToWaitFor, xTimeoutOccurred )    ( void ) xTimeoutOccurred
++#endif
++
++#ifndef traceEVENT_GROUP_WAIT_BITS_BLOCK
++    #define traceEVENT_GROUP_WAIT_BITS_BLOCK( xEventGroup, uxBitsToWaitFor )
++#endif
++
++#ifndef traceEVENT_GROUP_WAIT_BITS_END
++    #define traceEVENT_GROUP_WAIT_BITS_END( xEventGroup, uxBitsToWaitFor, xTimeoutOccurred )    ( void ) xTimeoutOccurred
++#endif
++
++#ifndef traceEVENT_GROUP_CLEAR_BITS
++    #define traceEVENT_GROUP_CLEAR_BITS( xEventGroup, uxBitsToClear )
++#endif
++
++#ifndef traceEVENT_GROUP_CLEAR_BITS_FROM_ISR
++    #define traceEVENT_GROUP_CLEAR_BITS_FROM_ISR( xEventGroup, uxBitsToClear )
++#endif
++
++#ifndef traceEVENT_GROUP_SET_BITS
++    #define traceEVENT_GROUP_SET_BITS( xEventGroup, uxBitsToSet )
++#endif
++
++#ifndef traceEVENT_GROUP_SET_BITS_FROM_ISR
++    #define traceEVENT_GROUP_SET_BITS_FROM_ISR( xEventGroup, uxBitsToSet )
++#endif
++
++#ifndef traceEVENT_GROUP_DELETE
++    #define traceEVENT_GROUP_DELETE( xEventGroup )
++#endif
++
++#ifndef tracePEND_FUNC_CALL
++    #define tracePEND_FUNC_CALL( xFunctionToPend, pvParameter1, ulParameter2, ret )
++#endif
++
++#ifndef tracePEND_FUNC_CALL_FROM_ISR
++    #define tracePEND_FUNC_CALL_FROM_ISR( xFunctionToPend, pvParameter1, ulParameter2, ret )
++#endif
++
++#ifndef traceQUEUE_REGISTRY_ADD
++    #define traceQUEUE_REGISTRY_ADD( xQueue, pcQueueName )
++#endif
++
++#ifndef traceTASK_NOTIFY_TAKE_BLOCK
++    #define traceTASK_NOTIFY_TAKE_BLOCK( uxIndexToWait )
++#endif
++
++#ifndef traceTASK_NOTIFY_TAKE
++    #define traceTASK_NOTIFY_TAKE( uxIndexToWait )
++#endif
++
++#ifndef traceTASK_NOTIFY_WAIT_BLOCK
++    #define traceTASK_NOTIFY_WAIT_BLOCK( uxIndexToWait )
++#endif
++
++#ifndef traceTASK_NOTIFY_WAIT
++    #define traceTASK_NOTIFY_WAIT( uxIndexToWait )
++#endif
++
++#ifndef traceTASK_NOTIFY
++    #define traceTASK_NOTIFY( uxIndexToNotify )
++#endif
++
++#ifndef traceTASK_NOTIFY_FROM_ISR
++    #define traceTASK_NOTIFY_FROM_ISR( uxIndexToNotify )
++#endif
++
++#ifndef traceTASK_NOTIFY_GIVE_FROM_ISR
++    #define traceTASK_NOTIFY_GIVE_FROM_ISR( uxIndexToNotify )
++#endif
++
++#ifndef traceSTREAM_BUFFER_CREATE_FAILED
++    #define traceSTREAM_BUFFER_CREATE_FAILED( xIsMessageBuffer )
++#endif
++
++#ifndef traceSTREAM_BUFFER_CREATE_STATIC_FAILED
++    #define traceSTREAM_BUFFER_CREATE_STATIC_FAILED( xReturn, xIsMessageBuffer )
++#endif
++
++#ifndef traceSTREAM_BUFFER_CREATE
++    #define traceSTREAM_BUFFER_CREATE( pxStreamBuffer, xIsMessageBuffer )
++#endif
++
++#ifndef traceSTREAM_BUFFER_DELETE
++    #define traceSTREAM_BUFFER_DELETE( xStreamBuffer )
++#endif
++
++#ifndef traceSTREAM_BUFFER_RESET
++    #define traceSTREAM_BUFFER_RESET( xStreamBuffer )
++#endif
++
++#ifndef traceBLOCKING_ON_STREAM_BUFFER_SEND
++    #define traceBLOCKING_ON_STREAM_BUFFER_SEND( xStreamBuffer )
++#endif
++
++#ifndef traceSTREAM_BUFFER_SEND
++    #define traceSTREAM_BUFFER_SEND( xStreamBuffer, xBytesSent )
++#endif
++
++#ifndef traceSTREAM_BUFFER_SEND_FAILED
++    #define traceSTREAM_BUFFER_SEND_FAILED( xStreamBuffer )
++#endif
++
++#ifndef traceSTREAM_BUFFER_SEND_FROM_ISR
++    #define traceSTREAM_BUFFER_SEND_FROM_ISR( xStreamBuffer, xBytesSent )
++#endif
++
++#ifndef traceBLOCKING_ON_STREAM_BUFFER_RECEIVE
++    #define traceBLOCKING_ON_STREAM_BUFFER_RECEIVE( xStreamBuffer )
++#endif
++
++#ifndef traceSTREAM_BUFFER_RECEIVE
++    #define traceSTREAM_BUFFER_RECEIVE( xStreamBuffer, xReceivedLength )
++#endif
++
++#ifndef traceSTREAM_BUFFER_RECEIVE_FAILED
++    #define traceSTREAM_BUFFER_RECEIVE_FAILED( xStreamBuffer )
++#endif
++
++#ifndef traceSTREAM_BUFFER_RECEIVE_FROM_ISR
++    #define traceSTREAM_BUFFER_RECEIVE_FROM_ISR( xStreamBuffer, xReceivedLength )
++#endif
++
++#ifdef ESP_PLATFORM
++#ifndef traceISR_EXIT_TO_SCHEDULER
++    #define traceISR_EXIT_TO_SCHEDULER()
++#endif
++
++#ifndef traceISR_EXIT
++    #define traceISR_EXIT()
++#endif
++
++#ifndef traceISR_ENTER
++    #define traceISR_ENTER(_n_)
++#endif
++#endif // ESP_PLATFORM
++
++#ifndef configGENERATE_RUN_TIME_STATS
++    #define configGENERATE_RUN_TIME_STATS    0
++#endif
++
++#if ( configGENERATE_RUN_TIME_STATS == 1 )
++
++    #ifndef portCONFIGURE_TIMER_FOR_RUN_TIME_STATS
++        #error If configGENERATE_RUN_TIME_STATS is defined then portCONFIGURE_TIMER_FOR_RUN_TIME_STATS must also be defined.  portCONFIGURE_TIMER_FOR_RUN_TIME_STATS should call a port layer function to setup a peripheral timer/counter that can then be used as the run time counter time base.
++    #endif /* portCONFIGURE_TIMER_FOR_RUN_TIME_STATS */
++
++    #ifndef portGET_RUN_TIME_COUNTER_VALUE
++        #ifndef portALT_GET_RUN_TIME_COUNTER_VALUE
++            #error If configGENERATE_RUN_TIME_STATS is defined then either portGET_RUN_TIME_COUNTER_VALUE or portALT_GET_RUN_TIME_COUNTER_VALUE must also be defined.  See the examples provided and the FreeRTOS web site for more information.
++        #endif /* portALT_GET_RUN_TIME_COUNTER_VALUE */
++    #endif /* portGET_RUN_TIME_COUNTER_VALUE */
++
++#endif /* configGENERATE_RUN_TIME_STATS */
++
++#ifndef portCONFIGURE_TIMER_FOR_RUN_TIME_STATS
++    #define portCONFIGURE_TIMER_FOR_RUN_TIME_STATS()
++#endif
++
++#ifndef configUSE_MALLOC_FAILED_HOOK
++    #define configUSE_MALLOC_FAILED_HOOK    0
++#endif
++
++#ifndef portPRIVILEGE_BIT
++    #define portPRIVILEGE_BIT    ( ( UBaseType_t ) 0x00 )
++#endif
++
++#ifndef portYIELD_WITHIN_API
++    #define portYIELD_WITHIN_API    portYIELD
++#endif
++
++#ifndef portSUPPRESS_TICKS_AND_SLEEP
++    #define portSUPPRESS_TICKS_AND_SLEEP( xExpectedIdleTime )
++#endif
++
++#ifndef configEXPECTED_IDLE_TIME_BEFORE_SLEEP
++    #define configEXPECTED_IDLE_TIME_BEFORE_SLEEP    2
++#endif
++
++#if configEXPECTED_IDLE_TIME_BEFORE_SLEEP < 2
++    #error configEXPECTED_IDLE_TIME_BEFORE_SLEEP must not be less than 2
++#endif
++
++#ifndef configUSE_TICKLESS_IDLE
++    #define configUSE_TICKLESS_IDLE    0
++#endif
++
++#ifndef configPRE_SUPPRESS_TICKS_AND_SLEEP_PROCESSING
++    #define configPRE_SUPPRESS_TICKS_AND_SLEEP_PROCESSING( x )
++#endif
++
++#ifndef configPRE_SLEEP_PROCESSING
++    #define configPRE_SLEEP_PROCESSING( x )
++#endif
++
++#ifndef configPOST_SLEEP_PROCESSING
++    #define configPOST_SLEEP_PROCESSING( x )
++#endif
++
++#ifndef configUSE_QUEUE_SETS
++    #define configUSE_QUEUE_SETS    0
++#endif
++
++#ifndef portTASK_USES_FLOATING_POINT
++    #define portTASK_USES_FLOATING_POINT()
++#endif
++
++#ifndef portALLOCATE_SECURE_CONTEXT
++    #define portALLOCATE_SECURE_CONTEXT( ulSecureStackSize )
++#endif
++
++#ifndef portDONT_DISCARD
++    #define portDONT_DISCARD
++#endif
++
++#ifndef configUSE_TIME_SLICING
++    #define configUSE_TIME_SLICING    1
++#endif
++
++#ifndef configINCLUDE_APPLICATION_DEFINED_PRIVILEGED_FUNCTIONS
++    #define configINCLUDE_APPLICATION_DEFINED_PRIVILEGED_FUNCTIONS    0
++#endif
++
++#ifndef configUSE_STATS_FORMATTING_FUNCTIONS
++    #define configUSE_STATS_FORMATTING_FUNCTIONS    0
++#endif
++
++#ifndef portASSERT_IF_INTERRUPT_PRIORITY_INVALID
++    #define portASSERT_IF_INTERRUPT_PRIORITY_INVALID()
++#endif
++
++#ifndef configUSE_TRACE_FACILITY
++    #define configUSE_TRACE_FACILITY    0
++#endif
++
++#ifndef mtCOVERAGE_TEST_MARKER
++    #define mtCOVERAGE_TEST_MARKER()
++#endif
++
++#ifndef mtCOVERAGE_TEST_DELAY
++    #define mtCOVERAGE_TEST_DELAY()
++#endif
++
++#ifndef portASSERT_IF_IN_ISR
++    #define portASSERT_IF_IN_ISR()
++#endif
++
++#ifndef configUSE_PORT_OPTIMISED_TASK_SELECTION
++    #define configUSE_PORT_OPTIMISED_TASK_SELECTION    0
++#endif
++
++#ifndef configAPPLICATION_ALLOCATED_HEAP
++    #define configAPPLICATION_ALLOCATED_HEAP    0
++#endif
++
++#ifndef configUSE_TASK_NOTIFICATIONS
++    #define configUSE_TASK_NOTIFICATIONS    1
++#endif
++
++#ifndef configTASK_NOTIFICATION_ARRAY_ENTRIES
++    #define configTASK_NOTIFICATION_ARRAY_ENTRIES    1
++#endif
++
++#if configTASK_NOTIFICATION_ARRAY_ENTRIES < 1
++    #error configTASK_NOTIFICATION_ARRAY_ENTRIES must be at least 1
++#endif
++
++#ifndef configUSE_POSIX_ERRNO
++    #define configUSE_POSIX_ERRNO    0
++#endif
++
++#ifndef portTICK_TYPE_IS_ATOMIC
++    #define portTICK_TYPE_IS_ATOMIC    0
++#endif
++
++#ifndef configSUPPORT_STATIC_ALLOCATION
++    /* Defaults to 0 for backward compatibility. */
++    #define configSUPPORT_STATIC_ALLOCATION    0
++#endif
++
++#ifndef configSUPPORT_DYNAMIC_ALLOCATION
++    /* Defaults to 1 for backward compatibility. */
++    #define configSUPPORT_DYNAMIC_ALLOCATION    1
++#endif
++
++#ifndef configSTACK_DEPTH_TYPE
++
++/* Defaults to uint16_t for backward compatibility, but can be overridden
++ * in FreeRTOSConfig.h if uint16_t is too restrictive. */
++    #define configSTACK_DEPTH_TYPE    uint16_t
++#endif
++
++#ifndef configRUN_TIME_COUNTER_TYPE
++
++/* Defaults to uint32_t for backward compatibility, but can be overridden in
++ * FreeRTOSConfig.h if uint32_t is too restrictive. */
++
++    #define configRUN_TIME_COUNTER_TYPE    uint32_t
++#endif
++
++#ifndef configMESSAGE_BUFFER_LENGTH_TYPE
++
++/* Defaults to size_t for backward compatibility, but can be overridden
++ * in FreeRTOSConfig.h if lengths will always be less than the number of bytes
++ * in a size_t. */
++    #define configMESSAGE_BUFFER_LENGTH_TYPE    size_t
++#endif
++
++/* Sanity check the configuration. */
++#if ( configUSE_TICKLESS_IDLE != 0 )
++    #if ( INCLUDE_vTaskSuspend != 1 )
++        #error INCLUDE_vTaskSuspend must be set to 1 if configUSE_TICKLESS_IDLE is not set to 0
++    #endif /* INCLUDE_vTaskSuspend */
++#endif /* configUSE_TICKLESS_IDLE */
++
++#if ( ( configSUPPORT_STATIC_ALLOCATION == 0 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 0 ) )
++    #error configSUPPORT_STATIC_ALLOCATION and configSUPPORT_DYNAMIC_ALLOCATION cannot both be 0, but can both be 1.
++#endif
++
++#if ( ( configUSE_RECURSIVE_MUTEXES == 1 ) && ( configUSE_MUTEXES != 1 ) )
++    #error configUSE_MUTEXES must be set to 1 to use recursive mutexes
++#endif
++
++#ifndef configINITIAL_TICK_COUNT
++    #define configINITIAL_TICK_COUNT    0
++#endif
++
++#if ( portTICK_TYPE_IS_ATOMIC == 0 )
++
++/* Either variables of tick type cannot be read atomically, or
++ * portTICK_TYPE_IS_ATOMIC was not set - map the critical sections used when
++ * the tick count is returned to the standard critical section macros. */
++    #define portTICK_TYPE_ENTER_CRITICAL()                      portENTER_CRITICAL()
++    #define portTICK_TYPE_EXIT_CRITICAL()                       portEXIT_CRITICAL()
++    #define portTICK_TYPE_SET_INTERRUPT_MASK_FROM_ISR()         portSET_INTERRUPT_MASK_FROM_ISR()
++    #define portTICK_TYPE_CLEAR_INTERRUPT_MASK_FROM_ISR( x )    portCLEAR_INTERRUPT_MASK_FROM_ISR( ( x ) )
++#else
++
++/* The tick type can be read atomically, so critical sections used when the
++ * tick count is returned can be defined away. */
++    #define portTICK_TYPE_ENTER_CRITICAL()
++    #define portTICK_TYPE_EXIT_CRITICAL()
++    #define portTICK_TYPE_SET_INTERRUPT_MASK_FROM_ISR()         0
++    #define portTICK_TYPE_CLEAR_INTERRUPT_MASK_FROM_ISR( x )    ( void ) x
++#endif /* if ( portTICK_TYPE_IS_ATOMIC == 0 ) */
++
++/* Definitions to allow backward compatibility with FreeRTOS versions prior to
++ * V8 if desired. */
++#ifndef configENABLE_BACKWARD_COMPATIBILITY
++    #define configENABLE_BACKWARD_COMPATIBILITY    1
++#endif
++
++#ifndef configPRINTF
++
++/* configPRINTF() was not defined, so define it away to nothing.  To use
++ * configPRINTF() then define it as follows (where MyPrintFunction() is
++ * provided by the application writer):
++ *
++ * void MyPrintFunction(const char *pcFormat, ... );
++ #define configPRINTF( X )   MyPrintFunction X
++ *
++ * Then call like a standard printf() function, but placing brackets around
++ * all parameters so they are passed as a single parameter.  For example:
++ * configPRINTF( ("Value = %d", MyVariable) ); */
++    #define configPRINTF( X )
++#endif
++
++#ifndef configMAX
++
++/* The application writer has not provided their own MAX macro, so define
++ * the following generic implementation. */
++    #define configMAX( a, b )    ( ( ( a ) > ( b ) ) ? ( a ) : ( b ) )
++#endif
++
++#ifndef configMIN
++
++/* The application writer has not provided their own MIN macro, so define
++ * the following generic implementation. */
++    #define configMIN( a, b )    ( ( ( a ) < ( b ) ) ? ( a ) : ( b ) )
++#endif
++
++#if configENABLE_BACKWARD_COMPATIBILITY == 1
++    #define eTaskStateGet                 eTaskGetState
++    #define portTickType                  TickType_t
++    #define xTaskHandle                   TaskHandle_t
++    #define xQueueHandle                  QueueHandle_t
++    #define xSemaphoreHandle              SemaphoreHandle_t
++    #define xQueueSetHandle               QueueSetHandle_t
++    #define xQueueSetMemberHandle         QueueSetMemberHandle_t
++    #define xTimeOutType                  TimeOut_t
++    #define xMemoryRegion                 MemoryRegion_t
++    #define xTaskParameters               TaskParameters_t
++    #define xTaskStatusType               TaskStatus_t
++    #define xTimerHandle                  TimerHandle_t
++    #define xCoRoutineHandle              CoRoutineHandle_t
++    #define pdTASK_HOOK_CODE              TaskHookFunction_t
++    #define portTICK_RATE_MS              portTICK_PERIOD_MS
++    #define pcTaskGetTaskName             pcTaskGetName
++    #define pcTimerGetTimerName           pcTimerGetName
++    #define pcQueueGetQueueName           pcQueueGetName
++    #define vTaskGetTaskInfo              vTaskGetInfo
++    #define xTaskGetIdleRunTimeCounter    ulTaskGetIdleRunTimeCounter
++
++/* Backward compatibility within the scheduler code only - these definitions
++ * are not really required but are included for completeness. */
++    #define tmrTIMER_CALLBACK             TimerCallbackFunction_t
++    #define pdTASK_CODE                   TaskFunction_t
++    #define xListItem                     ListItem_t
++    #define xList                         List_t
++
++/* For libraries that break the list data hiding, and access list structure
++ * members directly (which is not supposed to be done). */
++    #define pxContainer                   pvContainer
++#endif /* configENABLE_BACKWARD_COMPATIBILITY */
++
++#if ( configUSE_ALTERNATIVE_API != 0 )
++    #error The alternative API was deprecated some time ago, and was removed in FreeRTOS V9.0 0
++#endif
++
++/* Set configUSE_TASK_FPU_SUPPORT to 0 to omit floating point support even
++ * if floating point hardware is otherwise supported by the FreeRTOS port in use.
++ * This constant is not supported by all FreeRTOS ports that include floating
++ * point support. */
++#ifndef configUSE_TASK_FPU_SUPPORT
++    #define configUSE_TASK_FPU_SUPPORT    1
++#endif
++
++/* Set configENABLE_MPU to 1 to enable MPU support and 0 to disable it. This is
++ * currently used in ARMv8M ports. */
++#ifndef configENABLE_MPU
++    #define configENABLE_MPU    0
++#endif
++
++/* Set configENABLE_FPU to 1 to enable FPU support and 0 to disable it. This is
++ * currently used in ARMv8M ports. */
++#ifndef configENABLE_FPU
++    #define configENABLE_FPU    1
++#endif
++
++/* Set configENABLE_TRUSTZONE to 1 enable TrustZone support and 0 to disable it.
++ * This is currently used in ARMv8M ports. */
++#ifndef configENABLE_TRUSTZONE
++    #define configENABLE_TRUSTZONE    1
++#endif
++
++/* Set configRUN_FREERTOS_SECURE_ONLY to 1 to run the FreeRTOS ARMv8M port on
++ * the Secure Side only. */
++#ifndef configRUN_FREERTOS_SECURE_ONLY
++    #define configRUN_FREERTOS_SECURE_ONLY    0
++#endif
++
++#ifndef configRUN_ADDITIONAL_TESTS
++    #define configRUN_ADDITIONAL_TESTS    0
++#endif
++
++
++/* Sometimes the FreeRTOSConfig.h settings only allow a task to be created using
++ * dynamically allocated RAM, in which case when any task is deleted it is known
++ * that both the task's stack and TCB need to be freed.  Sometimes the
++ * FreeRTOSConfig.h settings only allow a task to be created using statically
++ * allocated RAM, in which case when any task is deleted it is known that neither
++ * the task's stack or TCB should be freed.  Sometimes the FreeRTOSConfig.h
++ * settings allow a task to be created using either statically or dynamically
++ * allocated RAM, in which case a member of the TCB is used to record whether the
++ * stack and/or TCB were allocated statically or dynamically, so when a task is
++ * deleted the RAM that was allocated dynamically is freed again and no attempt is
++ * made to free the RAM that was allocated statically.
++ * tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE is only true if it is possible for a
++ * task to be created using either statically or dynamically allocated RAM.  Note
++ * that if portUSING_MPU_WRAPPERS is 1 then a protected task can be created with
++ * a statically allocated stack and a dynamically allocated TCB.
++ *
++ * The following table lists various combinations of portUSING_MPU_WRAPPERS,
++ * configSUPPORT_DYNAMIC_ALLOCATION and configSUPPORT_STATIC_ALLOCATION and
++ * when it is possible to have both static and dynamic allocation:
++ *  +-----+---------+--------+-----------------------------+-----------------------------------+------------------+-----------+
++ * | MPU | Dynamic | Static |     Available Functions     |       Possible Allocations        | Both Dynamic and | Need Free |
++ * |     |         |        |                             |                                   | Static Possible  |           |
++ * +-----+---------+--------+-----------------------------+-----------------------------------+------------------+-----------+
++ * | 0   | 0       | 1      | xTaskCreateStatic           | TCB - Static, Stack - Static      | No               | No        |
++ * +-----|---------|--------|-----------------------------|-----------------------------------|------------------|-----------|
++ * | 0   | 1       | 0      | xTaskCreate                 | TCB - Dynamic, Stack - Dynamic    | No               | Yes       |
++ * +-----|---------|--------|-----------------------------|-----------------------------------|------------------|-----------|
++ * | 0   | 1       | 1      | xTaskCreate,                | 1. TCB - Dynamic, Stack - Dynamic | Yes              | Yes       |
++ * |     |         |        | xTaskCreateStatic           | 2. TCB - Static, Stack - Static   |                  |           |
++ * +-----|---------|--------|-----------------------------|-----------------------------------|------------------|-----------|
++ * | 1   | 0       | 1      | xTaskCreateStatic,          | TCB - Static, Stack - Static      | No               | No        |
++ * |     |         |        | xTaskCreateRestrictedStatic |                                   |                  |           |
++ * +-----|---------|--------|-----------------------------|-----------------------------------|------------------|-----------|
++ * | 1   | 1       | 0      | xTaskCreate,                | 1. TCB - Dynamic, Stack - Dynamic | Yes              | Yes       |
++ * |     |         |        | xTaskCreateRestricted       | 2. TCB - Dynamic, Stack - Static  |                  |           |
++ * +-----|---------|--------|-----------------------------|-----------------------------------|------------------|-----------|
++ * | 1   | 1       | 1      | xTaskCreate,                | 1. TCB - Dynamic, Stack - Dynamic | Yes              | Yes       |
++ * |     |         |        | xTaskCreateStatic,          | 2. TCB - Dynamic, Stack - Static  |                  |           |
++ * |     |         |        | xTaskCreateRestricted,      | 3. TCB - Static, Stack - Static   |                  |           |
++ * |     |         |        | xTaskCreateRestrictedStatic |                                   |                  |           |
++ * +-----+---------+--------+-----------------------------+-----------------------------------+------------------+-----------+
++ */
++#define tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE                                                                                     \
++    ( ( ( portUSING_MPU_WRAPPERS == 0 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) ) || \
++      ( ( portUSING_MPU_WRAPPERS == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) )
++
++/*
++ * In line with software engineering best practice, especially when supplying a
++ * library that is likely to change in future versions, FreeRTOS implements a
++ * strict data hiding policy.  This means the Task structure used internally by
++ * FreeRTOS is not accessible to application code.  However, if the application
++ * writer wants to statically allocate the memory required to create a task then
++ * the size of the task object needs to be known.  The StaticTask_t structure
++ * below is provided for this purpose.  Its sizes and alignment requirements are
++ * guaranteed to match those of the genuine structure, no matter which
++ * architecture is being used, and no matter how the values in FreeRTOSConfig.h
++ * are set.  Its contents are somewhat obfuscated in the hope users will
++ * recognise that it would be unwise to make direct use of the structure members.
++ */
++typedef struct xSTATIC_TCB
++{
++    struct rt_thread thread;
++    #if ( configUSE_APPLICATION_TASK_TAG == 1 )
++        void * pxTaskTag;
++    #endif
++    #if ( configUSE_TASK_NOTIFICATIONS == 1 )
++        uint32_t ulNotifiedValue[ configTASK_NOTIFICATION_ARRAY_ENTRIES ];
++        uint8_t ucNotifyState[ configTASK_NOTIFICATION_ARRAY_ENTRIES ];
++    #endif
++    #if ( INCLUDE_xTaskAbortDelay == 1 )
++        uint8_t ucDelayAborted;
++    #endif
++} StaticTask_t;
++
++typedef struct
++{
++    struct rt_ipc_object *rt_ipc;
++    struct rt_messagequeue ipc_obj;
++} StaticQueue_t;
++
++typedef struct
++{
++    struct rt_ipc_object *rt_ipc;
++    union
++    {
++        struct rt_semaphore_wrapper semaphore;
++        struct rt_mutex mutex;
++    } ipc_obj;
++} StaticSemaphore_t;
++
++typedef struct xSTATIC_EVENT_GROUP
++{
++    struct rt_event event;
++} StaticEventGroup_t;
++
++typedef struct xSTATIC_TIMER
++{
++    struct rt_timer timer;
++    void * pvTimerID;
++} StaticTimer_t;
++
++/* *INDENT-OFF* */
++#ifdef __cplusplus
++    }
++#endif
++/* *INDENT-ON* */
++
++#endif /* INC_FREERTOS_H */
+diff --git a/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/freertos/event_groups.h b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/freertos/event_groups.h
+new file mode 100644
+index 0000000000..591814d37f
+--- /dev/null
++++ b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/freertos/event_groups.h
+@@ -0,0 +1,621 @@
++/*
++ * FreeRTOS Kernel V10.4.6
++ * 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 EVENT_GROUPS_H
++#define EVENT_GROUPS_H
++
++#ifndef INC_FREERTOS_H
++    #error "include FreeRTOS.h" must appear in source files before "include event_groups.h"
++#endif
++
++/* *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
++ */
++
++
++
++/**
++ * 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;
++
++/**
++ * 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
++ */
++#if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
++    EventGroupHandle_t xEventGroupCreate( void );
++#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
++ */
++#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
++    EventGroupHandle_t xEventGroupCreateStatic( StaticEventGroup_t * pxEventGroupBuffer );
++#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 );
++
++/**
++ * 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 );
++
++/**
++ * 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
++ */
++BaseType_t xEventGroupClearBitsFromISR( EventGroupHandle_t xEventGroup,
++                                        const EventBits_t uxBitsToClear );
++
++/**
++ * 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 );
++
++/**
++ * 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
++ */
++BaseType_t xEventGroupSetBitsFromISR( EventGroupHandle_t xEventGroup,
++                                      const EventBits_t uxBitsToSet,
++                                      BaseType_t * pxHigherPriorityTaskWoken );
++
++/**
++ * 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.
++ *
++ * @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 );
++
++/**
++ * 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 );
++
++/* *INDENT-OFF* */
++#ifdef __cplusplus
++    }
++#endif
++/* *INDENT-ON* */
++
++#endif /* EVENT_GROUPS_H */
+diff --git a/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/freertos/list.h b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/freertos/list.h
+new file mode 100644
+index 0000000000..dde1f3572e
+--- /dev/null
++++ b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/freertos/list.h
+@@ -0,0 +1,416 @@
++/*
++ * FreeRTOS Kernel V10.4.3
++ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
++ *
++ * 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
++ *
++ */
++
++/*
++ * This is the list implementation used by the scheduler.  While it is tailored
++ * heavily for the schedulers needs, it is also available for use by
++ * application code.
++ *
++ * list_ts can only store pointers to list_item_ts.  Each ListItem_t contains a
++ * numeric value (xItemValue).  Most of the time the lists are sorted in
++ * descending item value order.
++ *
++ * Lists are created already containing one list item.  The value of this
++ * item is the maximum possible that can be stored, it is therefore always at
++ * the end of the list and acts as a marker.  The list member pxHead always
++ * points to this marker - even though it is at the tail of the list.  This
++ * is because the tail contains a wrap back pointer to the true head of
++ * the list.
++ *
++ * 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
++ * 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.
++ *
++ *
++ * \page ListIntroduction List Implementation
++ * \ingroup FreeRTOSIntro
++ */
++
++#ifndef INC_FREERTOS_H
++    #error "FreeRTOS.h must be included before list.h"
++#endif
++
++#ifndef LIST_H
++#define LIST_H
++
++/*
++ * The list structure members are modified from within interrupts, and therefore
++ * by rights should be declared volatile.  However, they are only modified in a
++ * functionally atomic way (within critical sections of with the scheduler
++ * suspended) and are either passed by reference into a function or indexed via
++ * a volatile variable.  Therefore, in all use cases tested so far, the volatile
++ * qualifier can be omitted in order to provide a moderate performance
++ * improvement without adversely affecting functional behaviour.  The assembly
++ * instructions generated by the IAR, ARM and GCC compilers when the respective
++ * compiler's options were set for maximum optimisation has been inspected and
++ * deemed to be as intended.  That said, as compiler technology advances, and
++ * especially if aggressive cross module optimisation is used (a use case that
++ * has not been exercised to any great extend) then it is feasible that the
++ * volatile qualifier will be needed for correct optimisation.  It is expected
++ * that a compiler removing essential code because, without the volatile
++ * qualifier on the list structure members and with aggressive cross module
++ * optimisation, the compiler deemed the code unnecessary will result in
++ * complete and obvious failure of the scheduler.  If this is ever experienced
++ * then the volatile qualifier can be inserted in the relevant places within the
++ * list structures by simply defining configLIST_VOLATILE to volatile in
++ * FreeRTOSConfig.h (as per the example at the bottom of this comment block).
++ * If configLIST_VOLATILE is not defined then the preprocessor directives below
++ * will simply #define configLIST_VOLATILE away completely.
++ *
++ * To use volatile list structure members then add the following line to
++ * FreeRTOSConfig.h (without the quotes):
++ * "#define configLIST_VOLATILE volatile"
++ */
++#ifndef configLIST_VOLATILE
++    #define configLIST_VOLATILE
++#endif /* configSUPPORT_CROSS_MODULE_OPTIMISATION */
++
++/* *INDENT-OFF* */
++#ifdef __cplusplus
++    extern "C" {
++#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.*/
++#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 )
++#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 ) )
++#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 descending 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. */
++    configLIST_VOLATILE TickType_t xItemValue;
++    struct xLIST_ITEM * configLIST_VOLATILE pxNext;
++    struct xLIST_ITEM * configLIST_VOLATILE pxPrevious;
++};
++typedef struct xMINI_LIST_ITEM MiniListItem_t;
++
++/*
++ * 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
++ */
++#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
++ */
++#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 descending 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
++ */
++#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
++ */
++#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
++ */
++#define listGET_HEAD_ENTRY( pxList )                      ( ( ( pxList )->xListEnd ).pxNext )
++
++/*
++ * 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
++ */
++#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
++ */
++#define listLIST_IS_EMPTY( pxList )                       ( ( ( pxList )->uxNumberOfItems == ( UBaseType_t ) 0 ) ? pdTRUE : pdFALSE )
++
++/*
++ * 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 )                                           \
++    {                                                                                          \
++        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;                       \
++        }                                                                                      \
++        ( pxTCB ) = ( pxConstList )->pxIndex->pvOwner;                                         \
++    }
++
++
++/*
++ * 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.
++ */
++#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
++ */
++#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.
++ */
++#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 );
++
++/*
++ * 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 );
++
++/*
++ * Insert a list item into a list.  The item will be inserted into the list in
++ * a position determined by its item value (descending 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 );
++
++/*
++ * 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 );
++
++/*
++ * 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 );
++
++/* *INDENT-OFF* */
++#ifdef __cplusplus
++    }
++#endif
++/* *INDENT-ON* */
++
++#endif /* ifndef LIST_H */
+diff --git a/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/freertos/portable.h b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/freertos/portable.h
+new file mode 100644
+index 0000000000..f0b56ae166
+--- /dev/null
++++ b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/freertos/portable.h
+@@ -0,0 +1,141 @@
++/*
++ * FreeRTOS Kernel V10.4.6
++ * 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
++ *
++ */
++
++/*-----------------------------------------------------------
++* Portable layer API.  Each function must be defined for each port.
++*----------------------------------------------------------*/
++
++#ifndef PORTABLE_H
++#define PORTABLE_H
++
++#include "freertos/portmacro.h"
++
++#if portBYTE_ALIGNMENT == 32
++    #define portBYTE_ALIGNMENT_MASK    ( 0x001f )
++#elif portBYTE_ALIGNMENT == 16
++    #define portBYTE_ALIGNMENT_MASK    ( 0x000f )
++#elif portBYTE_ALIGNMENT == 8
++    #define portBYTE_ALIGNMENT_MASK    ( 0x0007 )
++#elif portBYTE_ALIGNMENT == 4
++    #define portBYTE_ALIGNMENT_MASK    ( 0x0003 )
++#elif portBYTE_ALIGNMENT == 2
++    #define portBYTE_ALIGNMENT_MASK    ( 0x0001 )
++#elif portBYTE_ALIGNMENT == 1
++    #define portBYTE_ALIGNMENT_MASK    ( 0x0000 )
++#else /* if portBYTE_ALIGNMENT == 32 */
++    #error "Invalid portBYTE_ALIGNMENT definition"
++#endif /* if portBYTE_ALIGNMENT == 32 */
++
++/* *INDENT-OFF* */
++#ifdef __cplusplus
++    extern "C" {
++#endif
++/* *INDENT-ON* */
++
++#ifdef configUSE_FREERTOS_PROVIDED_HEAP
++
++/* 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;
++
++#if( configSTACK_ALLOCATION_FROM_SEPARATE_HEAP == 1 )
++    void *pvPortMallocStack( size_t xSize ) PRIVILEGED_FUNCTION;
++    void vPortFreeStack( void *pv ) PRIVILEGED_FUNCTION;
++#else
++    #define pvPortMallocStack pvPortMalloc
++    #define vPortFreeStack vPortFree
++#endif
++#else  // configUSE_FREERTOS_PROVIDED_HEAP
++
++/*
++ * Map to the memory management routines required for the port.
++ *
++ * Note that libc standard malloc/free are also available for
++ * non-FreeRTOS-specific code, and behave the same as
++ * pvPortMalloc()/vPortFree().
++ */
++#define pvPortMalloc malloc
++#define vPortFree free
++#define xPortGetFreeHeapSize esp_get_free_heap_size
++#define xPortGetMinimumEverFreeHeapSize esp_get_minimum_free_heap_size
++
++#endif
++
++void vPortEndScheduler( void );
++
++/* *INDENT-OFF* */
++#ifdef __cplusplus
++    }
++#endif
++/* *INDENT-ON* */
++
++#endif /* PORTABLE_H */
+diff --git a/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/freertos/projdefs.h b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/freertos/projdefs.h
+new file mode 100644
+index 0000000000..8b7c01bee7
+--- /dev/null
++++ b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/freertos/projdefs.h
+@@ -0,0 +1,64 @@
++/*
++ * FreeRTOS Kernel V10.4.6
++ * 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 PROJDEFS_H
++#define PROJDEFS_H
++
++/*
++ * 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 * );
++
++/* 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 ) rt_tick_from_millisecond( (rt_int32_t) xTimeInMs ) )
++#endif
++
++#ifdef ESP_PLATFORM
++#ifndef pdTICKS_TO_MS
++    #define pdTICKS_TO_MS( xTicks )   ( ( uint32_t ) ( xTicks ) * 1000 / configTICK_RATE_HZ )
++#endif
++#endif // ESP_PLATFORM
++
++#define pdFALSE                                  ( ( BaseType_t ) 0 )
++#define pdTRUE                                   ( ( BaseType_t ) 1 )
++
++#define pdPASS                                   ( pdTRUE )
++#define pdFAIL                                   ( pdFALSE )
++#define errQUEUE_EMPTY                           ( ( BaseType_t ) 0 )
++#define errQUEUE_FULL                            ( ( BaseType_t ) 0 )
++
++/* FreeRTOS error definitions. */
++#define errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY    ( -1 )
++#define errQUEUE_BLOCKED                         ( -4 )
++#define errQUEUE_YIELD                           ( -5 )
++
++#endif /* PROJDEFS_H */
+diff --git a/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/freertos/queue.h b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/freertos/queue.h
+new file mode 100644
+index 0000000000..57fe10ee8d
+--- /dev/null
++++ b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/freertos/queue.h
+@@ -0,0 +1,1188 @@
++/*
++ * FreeRTOS Kernel V10.4.6
++ * 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 QUEUE_H
++#define QUEUE_H
++
++/* *INDENT-OFF* */
++#ifdef __cplusplus
++    extern "C" {
++#endif
++/* *INDENT-ON* */
++
++#include "task.h"
++
++/**
++ * Type by which queues are referenced.  For example, a call to xQueueCreate()
++ * returns an QueueHandle_t variable that can then be used as a parameter to
++ * xQueueSend(), xQueueReceive(), etc.
++ */
++struct QueueDefinition; /* Using old naming convention so as not to break kernel aware debuggers. */
++typedef struct QueueDefinition   * QueueHandle_t;
++
++/* For internal use only. */
++#define queueSEND_TO_BACK                     ( ( BaseType_t ) 0 )
++#define queueSEND_TO_FRONT                    ( ( BaseType_t ) 1 )
++#define queueOVERWRITE                        ( ( BaseType_t ) 2 )
++
++/* For internal use only.  These definitions *must* match those in queue.c. */
++#define queueQUEUE_TYPE_BASE                  ( ( uint8_t ) 0U )
++#define queueQUEUE_TYPE_SET                   ( ( uint8_t ) 0U )
++#define queueQUEUE_TYPE_MUTEX                 ( ( uint8_t ) 1U )
++#define queueQUEUE_TYPE_COUNTING_SEMAPHORE    ( ( uint8_t ) 2U )
++#define queueQUEUE_TYPE_BINARY_SEMAPHORE      ( ( uint8_t ) 3U )
++#define queueQUEUE_TYPE_RECURSIVE_MUTEX       ( ( uint8_t ) 4U )
++
++/**
++ * queue. h
++ * @code{c}
++ * QueueHandle_t xQueueCreate(
++ *                            UBaseType_t uxQueueLength,
++ *                            UBaseType_t uxItemSize
++ *                        );
++ * @endcode
++ *
++ * Creates a new queue instance, and returns a handle by which the new queue
++ * can be referenced.
++ *
++ * Internally, within the FreeRTOS implementation, queues use two blocks of
++ * memory.  The first block is used to hold the queue's data structures.  The
++ * second block is used to hold items placed into the queue.  If a queue is
++ * created using xQueueCreate() then both blocks of memory are automatically
++ * dynamically allocated inside the xQueueCreate() function.  (see
++ * https://www.FreeRTOS.org/a00111.html).  If a queue is created using
++ * xQueueCreateStatic() then the application writer must provide the memory that
++ * will get used by the queue.  xQueueCreateStatic() therefore allows a queue to
++ * be created without using any dynamic memory allocation.
++ *
++ * https://www.FreeRTOS.org/Embedded-RTOS-Queues.html
++ *
++ * @param uxQueueLength The maximum number of items that the queue can contain.
++ *
++ * @param uxItemSize The number of bytes each item in the queue will require.
++ * Items are queued by copy, not by reference, so this is the number of bytes
++ * that will be copied for each posted item.  Each item on the queue must be
++ * the same size.
++ *
++ * @return If the queue is successfully create then a handle to the newly
++ * created queue is returned.  If the queue cannot be created then 0 is
++ * returned.
++ *
++ * Example usage:
++ * @code{c}
++ * struct AMessage
++ * {
++ *  char ucMessageID;
++ *  char ucData[ 20 ];
++ * };
++ *
++ * void vATask( void *pvParameters )
++ * {
++ * QueueHandle_t xQueue1, xQueue2;
++ *
++ *  // Create a queue capable of containing 10 uint32_t values.
++ *  xQueue1 = xQueueCreate( 10, sizeof( uint32_t ) );
++ *  if( xQueue1 == 0 )
++ *  {
++ *      // Queue was not created and must not be used.
++ *  }
++ *
++ *  // Create a queue capable of containing 10 pointers to AMessage structures.
++ *  // These should be passed by pointer as they contain a lot of data.
++ *  xQueue2 = xQueueCreate( 10, sizeof( struct AMessage * ) );
++ *  if( xQueue2 == 0 )
++ *  {
++ *      // Queue was not created and must not be used.
++ *  }
++ *
++ *  // ... Rest of task code.
++ * }
++ * @endcode
++ * \defgroup xQueueCreate xQueueCreate
++ * \ingroup QueueManagement
++ */
++#if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
++    #define xQueueCreate( uxQueueLength, uxItemSize )    xQueueGenericCreate( ( uxQueueLength ), ( uxItemSize ), ( queueQUEUE_TYPE_BASE ) )
++#endif
++
++/**
++ * queue. h
++ * @code{c}
++ * QueueHandle_t xQueueCreateStatic(
++ *                            UBaseType_t uxQueueLength,
++ *                            UBaseType_t uxItemSize,
++ *                            uint8_t *pucQueueStorage,
++ *                            StaticQueue_t *pxQueueBuffer
++ *                        );
++ * @endcode
++ *
++ * Creates a new queue instance, and returns a handle by which the new queue
++ * can be referenced.
++ *
++ * Internally, within the FreeRTOS implementation, queues use two blocks of
++ * memory.  The first block is used to hold the queue's data structures.  The
++ * second block is used to hold items placed into the queue.  If a queue is
++ * created using xQueueCreate() then both blocks of memory are automatically
++ * dynamically allocated inside the xQueueCreate() function.  (see
++ * https://www.FreeRTOS.org/a00111.html).  If a queue is created using
++ * xQueueCreateStatic() then the application writer must provide the memory that
++ * will get used by the queue.  xQueueCreateStatic() therefore allows a queue to
++ * be created without using any dynamic memory allocation.
++ *
++ * https://www.FreeRTOS.org/Embedded-RTOS-Queues.html
++ *
++ * @param uxQueueLength The maximum number of items that the queue can contain.
++ *
++ * @param uxItemSize The number of bytes each item in the queue will require.
++ * Items are queued by copy, not by reference, so this is the number of bytes
++ * that will be copied for each posted item.  Each item on the queue must be
++ * the same size.
++ *
++ * @param pucQueueStorage If uxItemSize is not zero then
++ * pucQueueStorage must point to a uint8_t array that is at least large
++ * enough to hold the maximum number of items that can be in the queue at any
++ * one time - which is ( uxQueueLength * uxItemsSize ) bytes.  If uxItemSize is
++ * zero then pucQueueStorage can be NULL.
++ *
++ * @param pxQueueBuffer Must point to a variable of type StaticQueue_t, which
++ * will be used to hold the queue's data structure.
++ *
++ * @return If the queue is created then a handle to the created queue is
++ * returned.  If pxQueueBuffer is NULL then NULL is returned.
++ *
++ * Example usage:
++ * @code{c}
++ * struct AMessage
++ * {
++ *  char ucMessageID;
++ *  char ucData[ 20 ];
++ * };
++ *
++ #define QUEUE_LENGTH 10
++ #define ITEM_SIZE sizeof( uint32_t )
++ *
++ * // xQueueBuffer will hold the queue structure.
++ * StaticQueue_t xQueueBuffer;
++ *
++ * // ucQueueStorage will hold the items posted to the queue.  Must be at least
++ * // [(queue length) * ( queue item size)] bytes long.
++ * uint8_t ucQueueStorage[ QUEUE_LENGTH * ITEM_SIZE ];
++ *
++ * void vATask( void *pvParameters )
++ * {
++ *  QueueHandle_t xQueue1;
++ *
++ *  // Create a queue capable of containing 10 uint32_t values.
++ *  xQueue1 = xQueueCreate( QUEUE_LENGTH, // The number of items the queue can hold.
++ *                          ITEM_SIZE     // The size of each item in the queue
++ *                          &( ucQueueStorage[ 0 ] ), // The buffer that will hold the items in the queue.
++ *                          &xQueueBuffer ); // The buffer that will hold the queue structure.
++ *
++ *  // The queue is guaranteed to be created successfully as no dynamic memory
++ *  // allocation is used.  Therefore xQueue1 is now a handle to a valid queue.
++ *
++ *  // ... Rest of task code.
++ * }
++ * @endcode
++ * \defgroup xQueueCreateStatic xQueueCreateStatic
++ * \ingroup QueueManagement
++ */
++#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
++    #define xQueueCreateStatic( uxQueueLength, uxItemSize, pucQueueStorage, pxQueueBuffer )    xQueueGenericCreateStatic( ( uxQueueLength ), ( uxItemSize ), ( pucQueueStorage ), ( pxQueueBuffer ), ( queueQUEUE_TYPE_BASE ) )
++#endif /* configSUPPORT_STATIC_ALLOCATION */
++
++/**
++ * queue. h
++ * @code{c}
++ * BaseType_t xQueueSendToToFront(
++ *                                 QueueHandle_t    xQueue,
++ *                                 const void       *pvItemToQueue,
++ *                                 TickType_t       xTicksToWait
++ *                             );
++ * @endcode
++ *
++ * Post an item to the front of a queue.  The item is queued by copy, not by
++ * reference.  This function must not be called from an interrupt service
++ * routine.  See xQueueSendFromISR () for an alternative which may be used
++ * in an ISR.
++ *
++ * @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 xTicksToWait The maximum amount of time the task should block
++ * waiting for space to become available on the queue, should it already
++ * be full.  The call will return immediately if this is set to 0 and the
++ * queue is full.  The time is defined in tick periods so the constant
++ * portTICK_PERIOD_MS should be used to convert to real time if this is required.
++ *
++ * @return pdTRUE if the item was successfully posted, otherwise errQUEUE_FULL.
++ *
++ * Example usage:
++ * @code{c}
++ * struct AMessage
++ * {
++ *  char ucMessageID;
++ *  char ucData[ 20 ];
++ * } xMessage;
++ *
++ * uint32_t ulVar = 10UL;
++ *
++ * void vATask( void *pvParameters )
++ * {
++ * QueueHandle_t xQueue1, xQueue2;
++ * struct AMessage *pxMessage;
++ *
++ *  // Create a queue capable of containing 10 uint32_t values.
++ *  xQueue1 = xQueueCreate( 10, sizeof( uint32_t ) );
++ *
++ *  // Create a queue capable of containing 10 pointers to AMessage structures.
++ *  // These should be passed by pointer as they contain a lot of data.
++ *  xQueue2 = xQueueCreate( 10, sizeof( struct AMessage * ) );
++ *
++ *  // ...
++ *
++ *  if( xQueue1 != 0 )
++ *  {
++ *      // Send an uint32_t.  Wait for 10 ticks for space to become
++ *      // available if necessary.
++ *      if( xQueueSendToFront( xQueue1, ( void * ) &ulVar, ( TickType_t ) 10 ) != pdPASS )
++ *      {
++ *          // Failed to post the message, even after 10 ticks.
++ *      }
++ *  }
++ *
++ *  if( xQueue2 != 0 )
++ *  {
++ *      // Send a pointer to a struct AMessage object.  Don't block if the
++ *      // queue is already full.
++ *      pxMessage = & xMessage;
++ *      xQueueSendToFront( xQueue2, ( void * ) &pxMessage, ( TickType_t ) 0 );
++ *  }
++ *
++ *  // ... Rest of task code.
++ * }
++ * @endcode
++ * \defgroup xQueueSend xQueueSend
++ * \ingroup QueueManagement
++ */
++#define xQueueSendToFront( xQueue, pvItemToQueue, xTicksToWait ) \
++    xQueueGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_FRONT )
++
++/**
++ * queue. h
++ * @code{c}
++ * BaseType_t xQueueSendToBack(
++ *                                 QueueHandle_t    xQueue,
++ *                                 const void       *pvItemToQueue,
++ *                                 TickType_t       xTicksToWait
++ *                             );
++ * @endcode
++ *
++ * This is a macro that calls xQueueGenericSend().
++ *
++ * Post an item to the back of a queue.  The item is queued by copy, not by
++ * reference.  This function must not be called from an interrupt service
++ * routine.  See xQueueSendFromISR () for an alternative which may be used
++ * in an ISR.
++ *
++ * @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 xTicksToWait The maximum amount of time the task should block
++ * waiting for space to become available on the queue, should it already
++ * be full.  The call will return immediately if this is set to 0 and the queue
++ * is full.  The  time is defined in tick periods so the constant
++ * portTICK_PERIOD_MS should be used to convert to real time if this is required.
++ *
++ * @return pdTRUE if the item was successfully posted, otherwise errQUEUE_FULL.
++ *
++ * Example usage:
++ * @code{c}
++ * struct AMessage
++ * {
++ *  char ucMessageID;
++ *  char ucData[ 20 ];
++ * } xMessage;
++ *
++ * uint32_t ulVar = 10UL;
++ *
++ * void vATask( void *pvParameters )
++ * {
++ * QueueHandle_t xQueue1, xQueue2;
++ * struct AMessage *pxMessage;
++ *
++ *  // Create a queue capable of containing 10 uint32_t values.
++ *  xQueue1 = xQueueCreate( 10, sizeof( uint32_t ) );
++ *
++ *  // Create a queue capable of containing 10 pointers to AMessage structures.
++ *  // These should be passed by pointer as they contain a lot of data.
++ *  xQueue2 = xQueueCreate( 10, sizeof( struct AMessage * ) );
++ *
++ *  // ...
++ *
++ *  if( xQueue1 != 0 )
++ *  {
++ *      // Send an uint32_t.  Wait for 10 ticks for space to become
++ *      // available if necessary.
++ *      if( xQueueSendToBack( xQueue1, ( void * ) &ulVar, ( TickType_t ) 10 ) != pdPASS )
++ *      {
++ *          // Failed to post the message, even after 10 ticks.
++ *      }
++ *  }
++ *
++ *  if( xQueue2 != 0 )
++ *  {
++ *      // Send a pointer to a struct AMessage object.  Don't block if the
++ *      // queue is already full.
++ *      pxMessage = & xMessage;
++ *      xQueueSendToBack( xQueue2, ( void * ) &pxMessage, ( TickType_t ) 0 );
++ *  }
++ *
++ *  // ... Rest of task code.
++ * }
++ * @endcode
++ * \defgroup xQueueSend xQueueSend
++ * \ingroup QueueManagement
++ */
++#define xQueueSendToBack( xQueue, pvItemToQueue, xTicksToWait ) \
++    xQueueGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_BACK )
++
++/**
++ * queue. h
++ * @code{c}
++ * BaseType_t xQueueSend(
++ *                            QueueHandle_t xQueue,
++ *                            const void * pvItemToQueue,
++ *                            TickType_t xTicksToWait
++ *                       );
++ * @endcode
++ *
++ * This is a macro that calls xQueueGenericSend().  It is included for
++ * backward compatibility with versions of FreeRTOS.org that did not
++ * include the xQueueSendToFront() and xQueueSendToBack() macros.  It is
++ * equivalent to xQueueSendToBack().
++ *
++ * Post an item on a queue.  The item is queued by copy, not by reference.
++ * This function must not be called from an interrupt service routine.
++ * See xQueueSendFromISR () for an alternative which may be used in an ISR.
++ *
++ * @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 xTicksToWait The maximum amount of time the task should block
++ * waiting for space to become available on the queue, should it already
++ * be full.  The call will return immediately if this is set to 0 and the
++ * queue is full.  The time is defined in tick periods so the constant
++ * portTICK_PERIOD_MS should be used to convert to real time if this is required.
++ *
++ * @return pdTRUE if the item was successfully posted, otherwise errQUEUE_FULL.
++ *
++ * Example usage:
++ * @code{c}
++ * struct AMessage
++ * {
++ *  char ucMessageID;
++ *  char ucData[ 20 ];
++ * } xMessage;
++ *
++ * uint32_t ulVar = 10UL;
++ *
++ * void vATask( void *pvParameters )
++ * {
++ * QueueHandle_t xQueue1, xQueue2;
++ * struct AMessage *pxMessage;
++ *
++ *  // Create a queue capable of containing 10 uint32_t values.
++ *  xQueue1 = xQueueCreate( 10, sizeof( uint32_t ) );
++ *
++ *  // Create a queue capable of containing 10 pointers to AMessage structures.
++ *  // These should be passed by pointer as they contain a lot of data.
++ *  xQueue2 = xQueueCreate( 10, sizeof( struct AMessage * ) );
++ *
++ *  // ...
++ *
++ *  if( xQueue1 != 0 )
++ *  {
++ *      // Send an uint32_t.  Wait for 10 ticks for space to become
++ *      // available if necessary.
++ *      if( xQueueSend( xQueue1, ( void * ) &ulVar, ( TickType_t ) 10 ) != pdPASS )
++ *      {
++ *          // Failed to post the message, even after 10 ticks.
++ *      }
++ *  }
++ *
++ *  if( xQueue2 != 0 )
++ *  {
++ *      // Send a pointer to a struct AMessage object.  Don't block if the
++ *      // queue is already full.
++ *      pxMessage = & xMessage;
++ *      xQueueSend( xQueue2, ( void * ) &pxMessage, ( TickType_t ) 0 );
++ *  }
++ *
++ *  // ... Rest of task code.
++ * }
++ * @endcode
++ * \defgroup xQueueSend xQueueSend
++ * \ingroup QueueManagement
++ */
++#define xQueueSend( xQueue, pvItemToQueue, xTicksToWait ) \
++    xQueueGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_BACK )
++
++/**
++ * queue. h
++ * @code{c}
++ * BaseType_t xQueueGenericSend(
++ *                                  QueueHandle_t xQueue,
++ *                                  const void * pvItemToQueue,
++ *                                  TickType_t xTicksToWait
++ *                                  BaseType_t xCopyPosition
++ *                              );
++ * @endcode
++ *
++ * It is preferred that the macros xQueueSend(), xQueueSendToFront() and
++ * xQueueSendToBack() are used in place of calling this function directly.
++ *
++ * Post an item on a queue.  The item is queued by copy, not by reference.
++ * This function must not be called from an interrupt service routine.
++ * See xQueueSendFromISR () for an alternative which may be used in an ISR.
++ *
++ * @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 xTicksToWait The maximum amount of time the task should block
++ * waiting for space to become available on the queue, should it already
++ * be full.  The call will return immediately if this is set to 0 and the
++ * queue is full.  The time is defined in tick periods so the constant
++ * portTICK_PERIOD_MS should be used to convert to real time if this is required.
++ *
++ * @param xCopyPosition Can take the value queueSEND_TO_BACK to place the
++ * item at the back of the queue, or queueSEND_TO_FRONT to place the item
++ * at the front of the queue (for high priority messages).
++ *
++ * @return pdTRUE if the item was successfully posted, otherwise errQUEUE_FULL.
++ *
++ * Example usage:
++ * @code{c}
++ * struct AMessage
++ * {
++ *  char ucMessageID;
++ *  char ucData[ 20 ];
++ * } xMessage;
++ *
++ * uint32_t ulVar = 10UL;
++ *
++ * void vATask( void *pvParameters )
++ * {
++ * QueueHandle_t xQueue1, xQueue2;
++ * struct AMessage *pxMessage;
++ *
++ *  // Create a queue capable of containing 10 uint32_t values.
++ *  xQueue1 = xQueueCreate( 10, sizeof( uint32_t ) );
++ *
++ *  // Create a queue capable of containing 10 pointers to AMessage structures.
++ *  // These should be passed by pointer as they contain a lot of data.
++ *  xQueue2 = xQueueCreate( 10, sizeof( struct AMessage * ) );
++ *
++ *  // ...
++ *
++ *  if( xQueue1 != 0 )
++ *  {
++ *      // Send an uint32_t.  Wait for 10 ticks for space to become
++ *      // available if necessary.
++ *      if( xQueueGenericSend( xQueue1, ( void * ) &ulVar, ( TickType_t ) 10, queueSEND_TO_BACK ) != pdPASS )
++ *      {
++ *          // Failed to post the message, even after 10 ticks.
++ *      }
++ *  }
++ *
++ *  if( xQueue2 != 0 )
++ *  {
++ *      // Send a pointer to a struct AMessage object.  Don't block if the
++ *      // queue is already full.
++ *      pxMessage = & xMessage;
++ *      xQueueGenericSend( xQueue2, ( void * ) &pxMessage, ( TickType_t ) 0, queueSEND_TO_BACK );
++ *  }
++ *
++ *  // ... Rest of task code.
++ * }
++ * @endcode
++ * \defgroup xQueueSend xQueueSend
++ * \ingroup QueueManagement
++ */
++BaseType_t xQueueGenericSend( QueueHandle_t xQueue,
++                              const void * const pvItemToQueue,
++                              TickType_t xTicksToWait,
++                              const BaseType_t xCopyPosition );
++
++/**
++ * queue. h
++ * @code{c}
++ * BaseType_t xQueueReceive(
++ *                               QueueHandle_t xQueue,
++ *                               void *pvBuffer,
++ *                               TickType_t xTicksToWait
++ *                          );
++ * @endcode
++ *
++ * Receive an item from a queue.  The item is received by copy so a buffer of
++ * adequate size must be provided.  The number of bytes copied into the buffer
++ * was defined when the queue was created.
++ *
++ * Successfully received items are removed from the queue.
++ *
++ * This function must not be used in an interrupt service routine.  See
++ * xQueueReceiveFromISR for an alternative that can.
++ *
++ * @param xQueue The handle to the queue from which the item is to be
++ * received.
++ *
++ * @param pvBuffer Pointer to the buffer into which the received item will
++ * be copied.
++ *
++ * @param xTicksToWait The maximum amount of time the task should block
++ * waiting for an item to receive should the queue be empty at the time
++ * of the call. xQueueReceive() will return immediately if xTicksToWait
++ * is zero and the queue is empty.  The time is defined in tick periods so the
++ * constant portTICK_PERIOD_MS should be used to convert to real time if this is
++ * required.
++ *
++ * @return pdTRUE if an item was successfully received from the queue,
++ * otherwise pdFALSE.
++ *
++ * Example usage:
++ * @code{c}
++ * struct AMessage
++ * {
++ *  char ucMessageID;
++ *  char ucData[ 20 ];
++ * } xMessage;
++ *
++ * QueueHandle_t xQueue;
++ *
++ * // Task to create a queue and post a value.
++ * void vATask( void *pvParameters )
++ * {
++ * struct AMessage *pxMessage;
++ *
++ *  // Create a queue capable of containing 10 pointers to AMessage structures.
++ *  // These should be passed by pointer as they contain a lot of data.
++ *  xQueue = xQueueCreate( 10, sizeof( struct AMessage * ) );
++ *  if( xQueue == 0 )
++ *  {
++ *      // Failed to create the queue.
++ *  }
++ *
++ *  // ...
++ *
++ *  // Send a pointer to a struct AMessage object.  Don't block if the
++ *  // queue is already full.
++ *  pxMessage = & xMessage;
++ *  xQueueSend( xQueue, ( void * ) &pxMessage, ( TickType_t ) 0 );
++ *
++ *  // ... Rest of task code.
++ * }
++ *
++ * // Task to receive from the queue.
++ * void vADifferentTask( void *pvParameters )
++ * {
++ * struct AMessage *pxRxedMessage;
++ *
++ *  if( xQueue != 0 )
++ *  {
++ *      // Receive a message on the created queue.  Block for 10 ticks if a
++ *      // message is not immediately available.
++ *      if( xQueueReceive( xQueue, &( pxRxedMessage ), ( TickType_t ) 10 ) )
++ *      {
++ *          // pcRxedMessage now points to the struct AMessage variable posted
++ *          // by vATask.
++ *      }
++ *  }
++ *
++ *  // ... Rest of task code.
++ * }
++ * @endcode
++ * \defgroup xQueueReceive xQueueReceive
++ * \ingroup QueueManagement
++ */
++BaseType_t xQueueReceive( QueueHandle_t xQueue,
++                          void * const pvBuffer,
++                          TickType_t xTicksToWait );
++
++/**
++ * queue. h
++ * @code{c}
++ * UBaseType_t uxQueueMessagesWaiting( const QueueHandle_t xQueue );
++ * @endcode
++ *
++ * Return the number of messages stored in a queue.
++ *
++ * @param xQueue A handle to the queue being queried.
++ *
++ * @return The number of messages available in the queue.
++ *
++ * \defgroup uxQueueMessagesWaiting uxQueueMessagesWaiting
++ * \ingroup QueueManagement
++ */
++UBaseType_t uxQueueMessagesWaiting( const QueueHandle_t xQueue );
++
++/**
++ * queue. h
++ * @code{c}
++ * UBaseType_t uxQueueSpacesAvailable( const QueueHandle_t xQueue );
++ * @endcode
++ *
++ * Return the number of free spaces available in a queue.  This is equal to the
++ * number of items that can be sent to the queue before the queue becomes full
++ * if no items are removed.
++ *
++ * @param xQueue A handle to the queue being queried.
++ *
++ * @return The number of spaces available in the queue.
++ *
++ * \defgroup uxQueueMessagesWaiting uxQueueMessagesWaiting
++ * \ingroup QueueManagement
++ */
++UBaseType_t uxQueueSpacesAvailable( const QueueHandle_t xQueue );
++
++/**
++ * queue. h
++ * @code{c}
++ * void vQueueDelete( QueueHandle_t xQueue );
++ * @endcode
++ *
++ * Delete a queue - freeing all the memory allocated for storing of items
++ * placed on the queue.
++ *
++ * @param xQueue A handle to the queue to be deleted.
++ *
++ * \defgroup vQueueDelete vQueueDelete
++ * \ingroup QueueManagement
++ */
++void vQueueDelete( QueueHandle_t xQueue );
++
++/**
++ * queue. h
++ * @code{c}
++ * BaseType_t xQueueSendToFrontFromISR(
++ *                                       QueueHandle_t xQueue,
++ *                                       const void *pvItemToQueue,
++ *                                       BaseType_t *pxHigherPriorityTaskWoken
++ *                                    );
++ * @endcode
++ *
++ * This is a macro that calls xQueueGenericSendFromISR().
++ *
++ * Post an item to the front of a queue.  It is safe to use this macro from
++ * within an interrupt service routine.
++ *
++ * Items are queued by copy not reference so it is preferable to only
++ * queue small items, especially when called from an ISR.  In most cases
++ * it would be preferable to store a pointer to the item being queued.
++ *
++ * @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 pxHigherPriorityTaskWoken xQueueSendToFrontFromISR() will set
++ * *pxHigherPriorityTaskWoken to pdTRUE if sending to the queue caused a task
++ * to unblock, and the unblocked task has a priority higher than the currently
++ * running task.  If xQueueSendToFromFromISR() sets this value to pdTRUE then
++ * a context switch should be requested before the interrupt is exited.
++ *
++ * @return pdTRUE if the data was successfully sent to the queue, otherwise
++ * errQUEUE_FULL.
++ *
++ * Example usage for buffered IO (where the ISR can obtain more than one value
++ * per call):
++ * @code{c}
++ * void vBufferISR( void )
++ * {
++ * char cIn;
++ * BaseType_t xHigherPrioritTaskWoken;
++ *
++ *  // We have not woken a task at the start of the ISR.
++ *  xHigherPriorityTaskWoken = pdFALSE;
++ *
++ *  // Loop until the buffer is empty.
++ *  do
++ *  {
++ *      // Obtain a byte from the buffer.
++ *      cIn = portINPUT_BYTE( RX_REGISTER_ADDRESS );
++ *
++ *      // Post the byte.
++ *      xQueueSendToFrontFromISR( xRxQueue, &cIn, &xHigherPriorityTaskWoken );
++ *
++ *  } while( portINPUT_BYTE( BUFFER_COUNT ) );
++ *
++ *  // Now the buffer is empty we can switch context if necessary.
++ *  if( xHigherPriorityTaskWoken )
++ *  {
++ *      taskYIELD ();
++ *  }
++ * }
++ * @endcode
++ *
++ * \defgroup xQueueSendFromISR xQueueSendFromISR
++ * \ingroup QueueManagement
++ */
++#define xQueueSendToFrontFromISR( xQueue, pvItemToQueue, pxHigherPriorityTaskWoken ) \
++    xQueueGenericSendFromISR( ( xQueue ), ( pvItemToQueue ), ( pxHigherPriorityTaskWoken ), queueSEND_TO_FRONT )
++
++
++/**
++ * queue. h
++ * @code{c}
++ * BaseType_t xQueueSendToBackFromISR(
++ *                                       QueueHandle_t xQueue,
++ *                                       const void *pvItemToQueue,
++ *                                       BaseType_t *pxHigherPriorityTaskWoken
++ *                                    );
++ * @endcode
++ *
++ * This is a macro that calls xQueueGenericSendFromISR().
++ *
++ * Post an item to the back of a queue.  It is safe to use this macro from
++ * within an interrupt service routine.
++ *
++ * Items are queued by copy not reference so it is preferable to only
++ * queue small items, especially when called from an ISR.  In most cases
++ * it would be preferable to store a pointer to the item being queued.
++ *
++ * @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 pxHigherPriorityTaskWoken xQueueSendToBackFromISR() will set
++ * *pxHigherPriorityTaskWoken to pdTRUE if sending to the queue caused a task
++ * to unblock, and the unblocked task has a priority higher than the currently
++ * running task.  If xQueueSendToBackFromISR() sets this value to pdTRUE then
++ * a context switch should be requested before the interrupt is exited.
++ *
++ * @return pdTRUE if the data was successfully sent to the queue, otherwise
++ * errQUEUE_FULL.
++ *
++ * Example usage for buffered IO (where the ISR can obtain more than one value
++ * per call):
++ * @code{c}
++ * void vBufferISR( void )
++ * {
++ * char cIn;
++ * BaseType_t xHigherPriorityTaskWoken;
++ *
++ *  // We have not woken a task at the start of the ISR.
++ *  xHigherPriorityTaskWoken = pdFALSE;
++ *
++ *  // Loop until the buffer is empty.
++ *  do
++ *  {
++ *      // Obtain a byte from the buffer.
++ *      cIn = portINPUT_BYTE( RX_REGISTER_ADDRESS );
++ *
++ *      // Post the byte.
++ *      xQueueSendToBackFromISR( xRxQueue, &cIn, &xHigherPriorityTaskWoken );
++ *
++ *  } while( portINPUT_BYTE( BUFFER_COUNT ) );
++ *
++ *  // Now the buffer is empty we can switch context if necessary.
++ *  if( xHigherPriorityTaskWoken )
++ *  {
++ *      taskYIELD ();
++ *  }
++ * }
++ * @endcode
++ *
++ * \defgroup xQueueSendFromISR xQueueSendFromISR
++ * \ingroup QueueManagement
++ */
++#define xQueueSendToBackFromISR( xQueue, pvItemToQueue, pxHigherPriorityTaskWoken ) \
++    xQueueGenericSendFromISR( ( xQueue ), ( pvItemToQueue ), ( pxHigherPriorityTaskWoken ), queueSEND_TO_BACK )
++
++/**
++ * queue. h
++ * @code{c}
++ * BaseType_t xQueueSendFromISR(
++ *                                   QueueHandle_t xQueue,
++ *                                   const void *pvItemToQueue,
++ *                                   BaseType_t *pxHigherPriorityTaskWoken
++ *                              );
++ * @endcode
++ *
++ * This is a macro that calls xQueueGenericSendFromISR().  It is included
++ * for backward compatibility with versions of FreeRTOS.org that did not
++ * include the xQueueSendToBackFromISR() and xQueueSendToFrontFromISR()
++ * macros.
++ *
++ * Post an item to the back of a queue.  It is safe to use this function from
++ * within an interrupt service routine.
++ *
++ * Items are queued by copy not reference so it is preferable to only
++ * queue small items, especially when called from an ISR.  In most cases
++ * it would be preferable to store a pointer to the item being queued.
++ *
++ * @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 pxHigherPriorityTaskWoken xQueueSendFromISR() will set
++ * *pxHigherPriorityTaskWoken to pdTRUE if sending to the queue caused a task
++ * to unblock, and the unblocked task has a priority higher than the currently
++ * running task.  If xQueueSendFromISR() sets this value to pdTRUE then
++ * a context switch should be requested before the interrupt is exited.
++ *
++ * @return pdTRUE if the data was successfully sent to the queue, otherwise
++ * errQUEUE_FULL.
++ *
++ * Example usage for buffered IO (where the ISR can obtain more than one value
++ * per call):
++ * @code{c}
++ * void vBufferISR( void )
++ * {
++ * char cIn;
++ * BaseType_t xHigherPriorityTaskWoken;
++ *
++ *  // We have not woken a task at the start of the ISR.
++ *  xHigherPriorityTaskWoken = pdFALSE;
++ *
++ *  // Loop until the buffer is empty.
++ *  do
++ *  {
++ *      // Obtain a byte from the buffer.
++ *      cIn = portINPUT_BYTE( RX_REGISTER_ADDRESS );
++ *
++ *      // Post the byte.
++ *      xQueueSendFromISR( xRxQueue, &cIn, &xHigherPriorityTaskWoken );
++ *
++ *  } while( portINPUT_BYTE( BUFFER_COUNT ) );
++ *
++ *  // Now the buffer is empty we can switch context if necessary.
++ *  if( xHigherPriorityTaskWoken )
++ *  {
++ *      // Actual macro used here is port specific.
++ *      portYIELD_FROM_ISR ();
++ *  }
++ * }
++ * @endcode
++ *
++ * \defgroup xQueueSendFromISR xQueueSendFromISR
++ * \ingroup QueueManagement
++ */
++#define xQueueSendFromISR( xQueue, pvItemToQueue, pxHigherPriorityTaskWoken ) \
++    xQueueGenericSendFromISR( ( xQueue ), ( pvItemToQueue ), ( pxHigherPriorityTaskWoken ), queueSEND_TO_BACK )
++
++/**
++ * queue. h
++ * @code{c}
++ * BaseType_t xQueueGenericSendFromISR(
++ *                                         QueueHandle_t    xQueue,
++ *                                         const    void    *pvItemToQueue,
++ *                                         BaseType_t  *pxHigherPriorityTaskWoken,
++ *                                         BaseType_t  xCopyPosition
++ *                                     );
++ * @endcode
++ *
++ * It is preferred that the macros xQueueSendFromISR(),
++ * xQueueSendToFrontFromISR() and xQueueSendToBackFromISR() be used in place
++ * of calling this function directly.  xQueueGiveFromISR() is an
++ * equivalent for use by semaphores that don't actually copy any data.
++ *
++ * Post an item on a queue.  It is safe to use this function from within an
++ * interrupt service routine.
++ *
++ * Items are queued by copy not reference so it is preferable to only
++ * queue small items, especially when called from an ISR.  In most cases
++ * it would be preferable to store a pointer to the item being queued.
++ *
++ * @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 pxHigherPriorityTaskWoken xQueueGenericSendFromISR() will set
++ * *pxHigherPriorityTaskWoken to pdTRUE if sending to the queue caused a task
++ * to unblock, and the unblocked task has a priority higher than the currently
++ * running task.  If xQueueGenericSendFromISR() sets this value to pdTRUE then
++ * a context switch should be requested before the interrupt is exited.
++ *
++ * @param xCopyPosition Can take the value queueSEND_TO_BACK to place the
++ * item at the back of the queue, or queueSEND_TO_FRONT to place the item
++ * at the front of the queue (for high priority messages).
++ *
++ * @return pdTRUE if the data was successfully sent to the queue, otherwise
++ * errQUEUE_FULL.
++ *
++ * Example usage for buffered IO (where the ISR can obtain more than one value
++ * per call):
++ * @code{c}
++ * void vBufferISR( void )
++ * {
++ * char cIn;
++ * BaseType_t xHigherPriorityTaskWokenByPost;
++ *
++ *  // We have not woken a task at the start of the ISR.
++ *  xHigherPriorityTaskWokenByPost = pdFALSE;
++ *
++ *  // Loop until the buffer is empty.
++ *  do
++ *  {
++ *      // Obtain a byte from the buffer.
++ *      cIn = portINPUT_BYTE( RX_REGISTER_ADDRESS );
++ *
++ *      // Post each byte.
++ *      xQueueGenericSendFromISR( xRxQueue, &cIn, &xHigherPriorityTaskWokenByPost, queueSEND_TO_BACK );
++ *
++ *  } while( portINPUT_BYTE( BUFFER_COUNT ) );
++ *
++ *  // Now the buffer is empty we can switch context if necessary.  Note that the
++ *  // name of the yield function required is port specific.
++ *  if( xHigherPriorityTaskWokenByPost )
++ *  {
++ *      portYIELD_FROM_ISR();
++ *  }
++ * }
++ * @endcode
++ *
++ * \defgroup xQueueSendFromISR xQueueSendFromISR
++ * \ingroup QueueManagement
++ */
++BaseType_t xQueueGenericSendFromISR( QueueHandle_t xQueue,
++                                     const void * const pvItemToQueue,
++                                     BaseType_t * const pxHigherPriorityTaskWoken,
++                                     const BaseType_t xCopyPosition );
++BaseType_t xQueueGiveFromISR( QueueHandle_t xQueue,
++                              BaseType_t * const pxHigherPriorityTaskWoken );
++
++/**
++ * queue. h
++ * @code{c}
++ * BaseType_t xQueueReceiveFromISR(
++ *                                     QueueHandle_t    xQueue,
++ *                                     void             *pvBuffer,
++ *                                     BaseType_t       *pxTaskWoken
++ *                                 );
++ * @endcode
++ *
++ * Receive an item from a queue.  It is safe to use this function from within an
++ * interrupt service routine.
++ *
++ * @param xQueue The handle to the queue from which the item is to be
++ * received.
++ *
++ * @param pvBuffer Pointer to the buffer into which the received item will
++ * be copied.
++ *
++ * @param pxTaskWoken A task may be blocked waiting for space to become
++ * available on the queue.  If xQueueReceiveFromISR causes such a task to
++ * unblock *pxTaskWoken will get set to pdTRUE, otherwise *pxTaskWoken will
++ * remain unchanged.
++ *
++ * @return pdTRUE if an item was successfully received from the queue,
++ * otherwise pdFALSE.
++ *
++ * Example usage:
++ * @code{c}
++ *
++ * QueueHandle_t xQueue;
++ *
++ * // Function to create a queue and post some values.
++ * void vAFunction( void *pvParameters )
++ * {
++ * char cValueToPost;
++ * const TickType_t xTicksToWait = ( TickType_t )0xff;
++ *
++ *  // Create a queue capable of containing 10 characters.
++ *  xQueue = xQueueCreate( 10, sizeof( char ) );
++ *  if( xQueue == 0 )
++ *  {
++ *      // Failed to create the queue.
++ *  }
++ *
++ *  // ...
++ *
++ *  // Post some characters that will be used within an ISR.  If the queue
++ *  // is full then this task will block for xTicksToWait ticks.
++ *  cValueToPost = 'a';
++ *  xQueueSend( xQueue, ( void * ) &cValueToPost, xTicksToWait );
++ *  cValueToPost = 'b';
++ *  xQueueSend( xQueue, ( void * ) &cValueToPost, xTicksToWait );
++ *
++ *  // ... keep posting characters ... this task may block when the queue
++ *  // becomes full.
++ *
++ *  cValueToPost = 'c';
++ *  xQueueSend( xQueue, ( void * ) &cValueToPost, xTicksToWait );
++ * }
++ *
++ * // ISR that outputs all the characters received on the queue.
++ * void vISR_Routine( void )
++ * {
++ * BaseType_t xTaskWokenByReceive = pdFALSE;
++ * char cRxedChar;
++ *
++ *  while( xQueueReceiveFromISR( xQueue, ( void * ) &cRxedChar, &xTaskWokenByReceive) )
++ *  {
++ *      // A character was received.  Output the character now.
++ *      vOutputCharacter( cRxedChar );
++ *
++ *      // If removing the character from the queue woke the task that was
++ *      // posting onto the queue cTaskWokenByReceive will have been set to
++ *      // pdTRUE.  No matter how many times this loop iterates only one
++ *      // task will be woken.
++ *  }
++ *
++ *  if( cTaskWokenByPost != ( char ) pdFALSE;
++ *  {
++ *      taskYIELD ();
++ *  }
++ * }
++ * @endcode
++ * \defgroup xQueueReceiveFromISR xQueueReceiveFromISR
++ * \ingroup QueueManagement
++ */
++BaseType_t xQueueReceiveFromISR( QueueHandle_t xQueue,
++                                 void * const pvBuffer,
++                                 BaseType_t * const pxHigherPriorityTaskWoken );
++
++/*
++ * Utilities to query queues that are safe to use from an ISR.  These utilities
++ * should be used only from witin an ISR, or within a critical section.
++ */
++BaseType_t xQueueIsQueueEmptyFromISR( const QueueHandle_t xQueue );
++BaseType_t xQueueIsQueueFullFromISR( const QueueHandle_t xQueue );
++UBaseType_t uxQueueMessagesWaitingFromISR( const QueueHandle_t xQueue );
++
++/*
++ * For internal use only.  Use xSemaphoreCreateMutex(),
++ * xSemaphoreCreateCounting() or xSemaphoreGetMutexHolder() instead of calling
++ * these functions directly.
++ */
++QueueHandle_t xQueueCreateMutex( const uint8_t ucQueueType );
++QueueHandle_t xQueueCreateMutexStatic( const uint8_t ucQueueType,
++                                       StaticQueue_t * pxStaticQueue );
++QueueHandle_t xQueueCreateCountingSemaphore( const UBaseType_t uxMaxCount,
++                                             const UBaseType_t uxInitialCount );
++QueueHandle_t xQueueCreateCountingSemaphoreStatic( const UBaseType_t uxMaxCount,
++                                                   const UBaseType_t uxInitialCount,
++                                                   StaticQueue_t * pxStaticQueue );
++BaseType_t xQueueSemaphoreTake( QueueHandle_t xQueue,
++                                TickType_t xTicksToWait );
++TaskHandle_t xQueueGetMutexHolder( QueueHandle_t xSemaphore );
++TaskHandle_t xQueueGetMutexHolderFromISR( QueueHandle_t xSemaphore );
++
++/*
++ * For internal use only.  Use xSemaphoreTakeMutexRecursive() or
++ * xSemaphoreGiveMutexRecursive() instead of calling these functions directly.
++ */
++BaseType_t xQueueTakeMutexRecursive( QueueHandle_t xMutex,
++                                     TickType_t xTicksToWait );
++BaseType_t xQueueGiveMutexRecursive( QueueHandle_t xMutex );
++
++/*
++ * Reset a queue back to its original empty state.  The return value is now
++ * obsolete and is always set to pdPASS.
++ */
++#define xQueueReset( xQueue )    xQueueGenericReset( xQueue, pdFALSE )
++
++/*
++ * Generic version of the function used to create a queue using dynamic memory
++ * allocation.  This is called by other functions and macros that create other
++ * RTOS objects that use the queue structure as their base.
++ */
++#if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
++    QueueHandle_t xQueueGenericCreate( const UBaseType_t uxQueueLength,
++                                       const UBaseType_t uxItemSize,
++                                       const uint8_t ucQueueType );
++#endif
++
++/*
++ * Generic version of the function used to create a queue using dynamic memory
++ * allocation.  This is called by other functions and macros that create other
++ * RTOS objects that use the queue structure as their base.
++ */
++#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
++    QueueHandle_t xQueueGenericCreateStatic( const UBaseType_t uxQueueLength,
++                                             const UBaseType_t uxItemSize,
++                                             uint8_t * pucQueueStorage,
++                                             StaticQueue_t * pxStaticQueue,
++                                             const uint8_t ucQueueType );
++#endif
++
++/* Not public API functions. */
++BaseType_t xQueueGenericReset( QueueHandle_t xQueue,
++                               BaseType_t xNewQueue );
++
++/* Unimplemented */
++typedef struct QueueDefinition   * QueueSetHandle_t;
++typedef struct QueueDefinition   * QueueSetMemberHandle_t;
++QueueSetHandle_t xQueueCreateSet( const UBaseType_t uxEventQueueLength );
++BaseType_t xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore,
++                           QueueSetHandle_t xQueueSet );
++BaseType_t xQueueRemoveFromSet( QueueSetMemberHandle_t xQueueOrSemaphore,
++                                QueueSetHandle_t xQueueSet );
++QueueSetMemberHandle_t xQueueSelectFromSet( QueueSetHandle_t xQueueSet,
++                                            const TickType_t xTicksToWait );
++QueueSetMemberHandle_t xQueueSelectFromSetFromISR( QueueSetHandle_t xQueueSet );
++BaseType_t xQueuePeek( QueueHandle_t xQueue,
++                       void * const pvBuffer,
++                       TickType_t xTicksToWait );
++BaseType_t xQueueOverwrite(QueueHandle_t xQueue, const void * pvItemToQueue);
++BaseType_t xQueueOverwriteFromISR(QueueHandle_t xQueue, const void * pvItemToQueue, BaseType_t *pxHigherPriorityTaskWoken);
++/* *INDENT-OFF* */
++#ifdef __cplusplus
++    }
++#endif
++/* *INDENT-ON* */
++
++#endif /* QUEUE_H */
+diff --git a/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/freertos/semphr.h b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/freertos/semphr.h
+new file mode 100644
+index 0000000000..053dd177cf
+--- /dev/null
++++ b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/freertos/semphr.h
+@@ -0,0 +1,1188 @@
++/*
++ * FreeRTOS Kernel V10.4.6
++ * 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 SEMAPHORE_H
++#define SEMAPHORE_H
++
++#ifndef INC_FREERTOS_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 semGIVE_BLOCK_TIME                  ( ( TickType_t ) 0U )
++
++
++/**
++ * semphr. h
++ * @code{c}
++ * vSemaphoreCreateBinary( SemaphoreHandle_t xSemaphore );
++ * @endcode
++ *
++ * In many usage scenarios it is faster and more memory efficient to use a
++ * direct to task notification in place of a binary semaphore!
++ * https://www.FreeRTOS.org/RTOS-task-notifications.html
++ *
++ * This old vSemaphoreCreateBinary() macro is now deprecated in favour of the
++ * xSemaphoreCreateBinary() function.  Note that binary semaphores created using
++ * the vSemaphoreCreateBinary() macro are created in a state such that the
++ * first call to 'take' the semaphore would pass, whereas binary semaphores
++ * created using xSemaphoreCreateBinary() are created in a state such that the
++ * the semaphore must first be 'given' before it can be 'taken'.
++ *
++ * <i>Macro</i> that implements a semaphore by using the existing queue mechanism.
++ * The queue length is 1 as this is a binary semaphore.  The data size is 0
++ * as we don't want to actually store any data - we just want to know if the
++ * queue is empty or full.
++ *
++ * This type of semaphore can be used for pure synchronisation between tasks or
++ * between an interrupt and a task.  The semaphore need not be given back once
++ * obtained, so one task/interrupt can continuously 'give' the semaphore while
++ * another continuously 'takes' the semaphore.  For this reason this type of
++ * semaphore does not use a priority inheritance mechanism.  For an alternative
++ * that does use priority inheritance see xSemaphoreCreateMutex().
++ *
++ * @param xSemaphore Handle to the created semaphore.  Should be of type SemaphoreHandle_t.
++ *
++ * Example usage:
++ * @code{c}
++ * SemaphoreHandle_t xSemaphore = NULL;
++ *
++ * void vATask( void * pvParameters )
++ * {
++ *  // Semaphore cannot be used before a call to vSemaphoreCreateBinary ().
++ *  // This is a macro so pass the variable in directly.
++ *  vSemaphoreCreateBinary( xSemaphore );
++ *
++ *  if( xSemaphore != NULL )
++ *  {
++ *      // The semaphore was created successfully.
++ *      // The semaphore can now be used.
++ *  }
++ * }
++ * @endcode
++ * \defgroup vSemaphoreCreateBinary vSemaphoreCreateBinary
++ * \ingroup Semaphores
++ */
++#if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
++    #define vSemaphoreCreateBinary( xSemaphore )                                                                                     \
++    {                                                                                                                                \
++        ( xSemaphore ) = xQueueGenericCreate( ( UBaseType_t ) 1, semSEMAPHORE_QUEUE_ITEM_LENGTH, queueQUEUE_TYPE_BINARY_SEMAPHORE ); \
++        if( ( xSemaphore ) != NULL )                                                                                                 \
++        {                                                                                                                            \
++            ( void ) xSemaphoreGive( ( xSemaphore ) );                                                                               \
++        }                                                                                                                            \
++    }
++#endif
++
++/**
++ * semphr. h
++ * @code{c}
++ * SemaphoreHandle_t xSemaphoreCreateBinary( void );
++ * @endcode
++ *
++ * Creates a new binary semaphore instance, and returns a handle by which the
++ * new semaphore can be referenced.
++ *
++ * In many usage scenarios it is faster and more memory efficient to use a
++ * direct to task notification in place of a binary semaphore!
++ * https://www.FreeRTOS.org/RTOS-task-notifications.html
++ *
++ * Internally, within the FreeRTOS implementation, binary semaphores use a block
++ * of memory, in which the semaphore structure is stored.  If a binary semaphore
++ * is created using xSemaphoreCreateBinary() then the required memory is
++ * automatically dynamically allocated inside the xSemaphoreCreateBinary()
++ * function.  (see https://www.FreeRTOS.org/a00111.html).  If a binary semaphore
++ * is created using xSemaphoreCreateBinaryStatic() then the application writer
++ * must provide the memory.  xSemaphoreCreateBinaryStatic() therefore allows a
++ * binary semaphore to be created without using any dynamic memory allocation.
++ *
++ * The old vSemaphoreCreateBinary() macro is now deprecated in favour of this
++ * xSemaphoreCreateBinary() function.  Note that binary semaphores created using
++ * the vSemaphoreCreateBinary() macro are created in a state such that the
++ * first call to 'take' the semaphore would pass, whereas binary semaphores
++ * created using xSemaphoreCreateBinary() are created in a state such that the
++ * the semaphore must first be 'given' before it can be 'taken'.
++ *
++ * This type of semaphore can be used for pure synchronisation between tasks or
++ * between an interrupt and a task.  The semaphore need not be given back once
++ * obtained, so one task/interrupt can continuously 'give' the semaphore while
++ * another continuously 'takes' the semaphore.  For this reason this type of
++ * semaphore does not use a priority inheritance mechanism.  For an alternative
++ * that does use priority inheritance see xSemaphoreCreateMutex().
++ *
++ * @return Handle to the created semaphore, or NULL if the memory required to
++ * hold the semaphore's data structures could not be allocated.
++ *
++ * Example usage:
++ * @code{c}
++ * SemaphoreHandle_t xSemaphore = NULL;
++ *
++ * void vATask( void * pvParameters )
++ * {
++ *  // Semaphore cannot be used before a call to xSemaphoreCreateBinary().
++ *  // This is a macro so pass the variable in directly.
++ *  xSemaphore = xSemaphoreCreateBinary();
++ *
++ *  if( xSemaphore != NULL )
++ *  {
++ *      // The semaphore was created successfully.
++ *      // The semaphore can now be used.
++ *  }
++ * }
++ * @endcode
++ * \defgroup xSemaphoreCreateBinary xSemaphoreCreateBinary
++ * \ingroup Semaphores
++ */
++#if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
++    #define xSemaphoreCreateBinary()    xQueueGenericCreate( ( UBaseType_t ) 1, semSEMAPHORE_QUEUE_ITEM_LENGTH, queueQUEUE_TYPE_BINARY_SEMAPHORE )
++#endif
++
++/**
++ * semphr. h
++ * @code{c}
++ * SemaphoreHandle_t xSemaphoreCreateBinaryStatic( StaticSemaphore_t *pxSemaphoreBuffer );
++ * @endcode
++ *
++ * Creates a new binary semaphore instance, and returns a handle by which the
++ * new semaphore can be referenced.
++ *
++ * NOTE: In many usage scenarios it is faster and more memory efficient to use a
++ * direct to task notification in place of a binary semaphore!
++ * https://www.FreeRTOS.org/RTOS-task-notifications.html
++ *
++ * Internally, within the FreeRTOS implementation, binary semaphores use a block
++ * of memory, in which the semaphore structure is stored.  If a binary semaphore
++ * is created using xSemaphoreCreateBinary() then the required memory is
++ * automatically dynamically allocated inside the xSemaphoreCreateBinary()
++ * function.  (see https://www.FreeRTOS.org/a00111.html).  If a binary semaphore
++ * is created using xSemaphoreCreateBinaryStatic() then the application writer
++ * must provide the memory.  xSemaphoreCreateBinaryStatic() therefore allows a
++ * binary semaphore to be created without using any dynamic memory allocation.
++ *
++ * This type of semaphore can be used for pure synchronisation between tasks or
++ * between an interrupt and a task.  The semaphore need not be given back once
++ * obtained, so one task/interrupt can continuously 'give' the semaphore while
++ * another continuously 'takes' the semaphore.  For this reason this type of
++ * semaphore does not use a priority inheritance mechanism.  For an alternative
++ * that does use priority inheritance see xSemaphoreCreateMutex().
++ *
++ * @param pxSemaphoreBuffer Must point to a variable of type StaticSemaphore_t,
++ * which will then be used to hold the semaphore's data structure, removing the
++ * need for the memory to be allocated dynamically.
++ *
++ * @return If the semaphore is created then a handle to the created semaphore is
++ * returned.  If pxSemaphoreBuffer is NULL then NULL is returned.
++ *
++ * Example usage:
++ * @code{c}
++ * SemaphoreHandle_t xSemaphore = NULL;
++ * StaticSemaphore_t xSemaphoreBuffer;
++ *
++ * void vATask( void * pvParameters )
++ * {
++ *  // Semaphore cannot be used before a call to xSemaphoreCreateBinary().
++ *  // The semaphore's data structures will be placed in the xSemaphoreBuffer
++ *  // variable, the address of which is passed into the function.  The
++ *  // function's parameter is not NULL, so the function will not attempt any
++ *  // dynamic memory allocation, and therefore the function will not return
++ *  // return NULL.
++ *  xSemaphore = xSemaphoreCreateBinary( &xSemaphoreBuffer );
++ *
++ *  // Rest of task code goes here.
++ * }
++ * @endcode
++ * \defgroup xSemaphoreCreateBinaryStatic xSemaphoreCreateBinaryStatic
++ * \ingroup Semaphores
++ */
++#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
++    #define xSemaphoreCreateBinaryStatic( pxStaticSemaphore )    xQueueGenericCreateStatic( ( UBaseType_t ) 1, semSEMAPHORE_QUEUE_ITEM_LENGTH, NULL, ( StaticQueue_t * ) pxStaticSemaphore, queueQUEUE_TYPE_BINARY_SEMAPHORE )
++#endif /* configSUPPORT_STATIC_ALLOCATION */
++
++/**
++ * semphr. h
++ * @code{c}
++ * xSemaphoreTake(
++ *                   SemaphoreHandle_t xSemaphore,
++ *                   TickType_t xBlockTime
++ *               );
++ * @endcode
++ *
++ * <i>Macro</i> to obtain a semaphore.  The semaphore must have previously been
++ * created with a call to xSemaphoreCreateBinary(), xSemaphoreCreateMutex() or
++ * xSemaphoreCreateCounting().
++ *
++ * @param xSemaphore A handle to the semaphore being taken - obtained when
++ * the semaphore was created.
++ *
++ * @param xBlockTime The time in ticks to wait for the semaphore to become
++ * available.  The macro portTICK_PERIOD_MS can be used to convert this to a
++ * real time.  A block time of zero can be used to poll the semaphore.  A block
++ * time of portMAX_DELAY can be used to block indefinitely (provided
++ * INCLUDE_vTaskSuspend is set to 1 in FreeRTOSConfig.h).
++ *
++ * @return pdTRUE if the semaphore was obtained.  pdFALSE
++ * if xBlockTime expired without the semaphore becoming available.
++ *
++ * Example usage:
++ * @code{c}
++ * SemaphoreHandle_t xSemaphore = NULL;
++ *
++ * // A task that creates a semaphore.
++ * void vATask( void * pvParameters )
++ * {
++ *  // Create the semaphore to guard a shared resource.
++ *  xSemaphore = xSemaphoreCreateBinary();
++ * }
++ *
++ * // A task that uses the semaphore.
++ * void vAnotherTask( void * pvParameters )
++ * {
++ *  // ... Do other things.
++ *
++ *  if( xSemaphore != NULL )
++ *  {
++ *      // See if we can obtain the semaphore.  If the semaphore is not available
++ *      // wait 10 ticks to see if it becomes free.
++ *      if( xSemaphoreTake( xSemaphore, ( TickType_t ) 10 ) == pdTRUE )
++ *      {
++ *          // We were able to obtain the semaphore and can now access the
++ *          // shared resource.
++ *
++ *          // ...
++ *
++ *          // We have finished accessing the shared resource.  Release the
++ *          // semaphore.
++ *          xSemaphoreGive( xSemaphore );
++ *      }
++ *      else
++ *      {
++ *          // We could not obtain the semaphore and can therefore not access
++ *          // the shared resource safely.
++ *      }
++ *  }
++ * }
++ * @endcode
++ * \defgroup xSemaphoreTake xSemaphoreTake
++ * \ingroup Semaphores
++ */
++#define xSemaphoreTake( xSemaphore, xBlockTime )    xQueueSemaphoreTake( ( xSemaphore ), ( xBlockTime ) )
++
++/**
++ * semphr. h
++ * @code{c}
++ * xSemaphoreTakeRecursive(
++ *                          SemaphoreHandle_t xMutex,
++ *                          TickType_t xBlockTime
++ *                        );
++ * @endcode
++ *
++ * <i>Macro</i> to recursively obtain, or 'take', a mutex type semaphore.
++ * The mutex must have previously been created using a call to
++ * xSemaphoreCreateRecursiveMutex();
++ *
++ * configUSE_RECURSIVE_MUTEXES must be set to 1 in FreeRTOSConfig.h for this
++ * macro to be available.
++ *
++ * This macro must not be used on mutexes created using xSemaphoreCreateMutex().
++ *
++ * A mutex used recursively can be 'taken' repeatedly by the owner. The mutex
++ * doesn't become available again until the owner has called
++ * xSemaphoreGiveRecursive() for each successful 'take' request.  For example,
++ * if a task successfully 'takes' the same mutex 5 times then the mutex will
++ * not be available to any other task until it has also  'given' the mutex back
++ * exactly five times.
++ *
++ * @param xMutex A handle to the mutex being obtained.  This is the
++ * handle returned by xSemaphoreCreateRecursiveMutex();
++ *
++ * @param xBlockTime The time in ticks to wait for the semaphore to become
++ * available.  The macro portTICK_PERIOD_MS can be used to convert this to a
++ * real time.  A block time of zero can be used to poll the semaphore.  If
++ * the task already owns the semaphore then xSemaphoreTakeRecursive() will
++ * return immediately no matter what the value of xBlockTime.
++ *
++ * @return pdTRUE if the semaphore was obtained.  pdFALSE if xBlockTime
++ * expired without the semaphore becoming available.
++ *
++ * Example usage:
++ * @code{c}
++ * SemaphoreHandle_t xMutex = NULL;
++ *
++ * // A task that creates a mutex.
++ * void vATask( void * pvParameters )
++ * {
++ *  // Create the mutex to guard a shared resource.
++ *  xMutex = xSemaphoreCreateRecursiveMutex();
++ * }
++ *
++ * // A task that uses the mutex.
++ * void vAnotherTask( void * pvParameters )
++ * {
++ *  // ... Do other things.
++ *
++ *  if( xMutex != NULL )
++ *  {
++ *      // See if we can obtain the mutex.  If the mutex is not available
++ *      // wait 10 ticks to see if it becomes free.
++ *      if( xSemaphoreTakeRecursive( xSemaphore, ( TickType_t ) 10 ) == pdTRUE )
++ *      {
++ *          // We were able to obtain the mutex and can now access the
++ *          // shared resource.
++ *
++ *          // ...
++ *          // For some reason due to the nature of the code further calls to
++ *          // xSemaphoreTakeRecursive() are made on the same mutex.  In real
++ *          // code these would not be just sequential calls as this would make
++ *          // no sense.  Instead the calls are likely to be buried inside
++ *          // a more complex call structure.
++ *          xSemaphoreTakeRecursive( xMutex, ( TickType_t ) 10 );
++ *          xSemaphoreTakeRecursive( xMutex, ( TickType_t ) 10 );
++ *
++ *          // The mutex has now been 'taken' three times, so will not be
++ *          // available to another task until it has also been given back
++ *          // three times.  Again it is unlikely that real code would have
++ *          // these calls sequentially, but instead buried in a more complex
++ *          // call structure.  This is just for illustrative purposes.
++ *          xSemaphoreGiveRecursive( xMutex );
++ *          xSemaphoreGiveRecursive( xMutex );
++ *          xSemaphoreGiveRecursive( xMutex );
++ *
++ *          // Now the mutex can be taken by other tasks.
++ *      }
++ *      else
++ *      {
++ *          // We could not obtain the mutex and can therefore not access
++ *          // the shared resource safely.
++ *      }
++ *  }
++ * }
++ * @endcode
++ * \defgroup xSemaphoreTakeRecursive xSemaphoreTakeRecursive
++ * \ingroup Semaphores
++ */
++#if ( configUSE_RECURSIVE_MUTEXES == 1 )
++    #define xSemaphoreTakeRecursive( xMutex, xBlockTime )    xQueueTakeMutexRecursive( ( xMutex ), ( xBlockTime ) )
++#endif
++
++/**
++ * semphr. h
++ * @code{c}
++ * xSemaphoreGive( SemaphoreHandle_t xSemaphore );
++ * @endcode
++ *
++ * <i>Macro</i> to release a semaphore.  The semaphore must have previously been
++ * created with a call to xSemaphoreCreateBinary(), xSemaphoreCreateMutex() or
++ * xSemaphoreCreateCounting(). and obtained using sSemaphoreTake().
++ *
++ * This macro must not be used from an ISR.  See xSemaphoreGiveFromISR () for
++ * an alternative which can be used from an ISR.
++ *
++ * This macro must also not be used on semaphores created using
++ * xSemaphoreCreateRecursiveMutex().
++ *
++ * @param xSemaphore A handle to the semaphore being released.  This is the
++ * handle returned when the semaphore was created.
++ *
++ * @return pdTRUE if the semaphore was released.  pdFALSE if an error occurred.
++ * Semaphores are implemented using queues.  An error can occur if there is
++ * no space on the queue to post a message - indicating that the
++ * semaphore was not first obtained correctly.
++ *
++ * Example usage:
++ * @code{c}
++ * SemaphoreHandle_t xSemaphore = NULL;
++ *
++ * void vATask( void * pvParameters )
++ * {
++ *  // Create the semaphore to guard a shared resource.
++ *  xSemaphore = vSemaphoreCreateBinary();
++ *
++ *  if( xSemaphore != NULL )
++ *  {
++ *      if( xSemaphoreGive( xSemaphore ) != pdTRUE )
++ *      {
++ *          // We would expect this call to fail because we cannot give
++ *          // a semaphore without first "taking" it!
++ *      }
++ *
++ *      // Obtain the semaphore - don't block if the semaphore is not
++ *      // immediately available.
++ *      if( xSemaphoreTake( xSemaphore, ( TickType_t ) 0 ) )
++ *      {
++ *          // We now have the semaphore and can access the shared resource.
++ *
++ *          // ...
++ *
++ *          // We have finished accessing the shared resource so can free the
++ *          // semaphore.
++ *          if( xSemaphoreGive( xSemaphore ) != pdTRUE )
++ *          {
++ *              // We would not expect this call to fail because we must have
++ *              // obtained the semaphore to get here.
++ *          }
++ *      }
++ *  }
++ * }
++ * @endcode
++ * \defgroup xSemaphoreGive xSemaphoreGive
++ * \ingroup Semaphores
++ */
++#define xSemaphoreGive( xSemaphore )    xQueueGenericSend( ( QueueHandle_t ) ( xSemaphore ), NULL, semGIVE_BLOCK_TIME, queueSEND_TO_BACK )
++
++/**
++ * semphr. h
++ * @code{c}
++ * xSemaphoreGiveRecursive( SemaphoreHandle_t xMutex );
++ * @endcode
++ *
++ * <i>Macro</i> to recursively release, or 'give', a mutex type semaphore.
++ * The mutex must have previously been created using a call to
++ * xSemaphoreCreateRecursiveMutex();
++ *
++ * configUSE_RECURSIVE_MUTEXES must be set to 1 in FreeRTOSConfig.h for this
++ * macro to be available.
++ *
++ * This macro must not be used on mutexes created using xSemaphoreCreateMutex().
++ *
++ * A mutex used recursively can be 'taken' repeatedly by the owner. The mutex
++ * doesn't become available again until the owner has called
++ * xSemaphoreGiveRecursive() for each successful 'take' request.  For example,
++ * if a task successfully 'takes' the same mutex 5 times then the mutex will
++ * not be available to any other task until it has also  'given' the mutex back
++ * exactly five times.
++ *
++ * @param xMutex A handle to the mutex being released, or 'given'.  This is the
++ * handle returned by xSemaphoreCreateMutex();
++ *
++ * @return pdTRUE if the semaphore was given.
++ *
++ * Example usage:
++ * @code{c}
++ * SemaphoreHandle_t xMutex = NULL;
++ *
++ * // A task that creates a mutex.
++ * void vATask( void * pvParameters )
++ * {
++ *  // Create the mutex to guard a shared resource.
++ *  xMutex = xSemaphoreCreateRecursiveMutex();
++ * }
++ *
++ * // A task that uses the mutex.
++ * void vAnotherTask( void * pvParameters )
++ * {
++ *  // ... Do other things.
++ *
++ *  if( xMutex != NULL )
++ *  {
++ *      // See if we can obtain the mutex.  If the mutex is not available
++ *      // wait 10 ticks to see if it becomes free.
++ *      if( xSemaphoreTakeRecursive( xMutex, ( TickType_t ) 10 ) == pdTRUE )
++ *      {
++ *          // We were able to obtain the mutex and can now access the
++ *          // shared resource.
++ *
++ *          // ...
++ *          // For some reason due to the nature of the code further calls to
++ *          // xSemaphoreTakeRecursive() are made on the same mutex.  In real
++ *          // code these would not be just sequential calls as this would make
++ *          // no sense.  Instead the calls are likely to be buried inside
++ *          // a more complex call structure.
++ *          xSemaphoreTakeRecursive( xMutex, ( TickType_t ) 10 );
++ *          xSemaphoreTakeRecursive( xMutex, ( TickType_t ) 10 );
++ *
++ *          // The mutex has now been 'taken' three times, so will not be
++ *          // available to another task until it has also been given back
++ *          // three times.  Again it is unlikely that real code would have
++ *          // these calls sequentially, it would be more likely that the calls
++ *          // to xSemaphoreGiveRecursive() would be called as a call stack
++ *          // unwound.  This is just for demonstrative purposes.
++ *          xSemaphoreGiveRecursive( xMutex );
++ *          xSemaphoreGiveRecursive( xMutex );
++ *          xSemaphoreGiveRecursive( xMutex );
++ *
++ *          // Now the mutex can be taken by other tasks.
++ *      }
++ *      else
++ *      {
++ *          // We could not obtain the mutex and can therefore not access
++ *          // the shared resource safely.
++ *      }
++ *  }
++ * }
++ * @endcode
++ * \defgroup xSemaphoreGiveRecursive xSemaphoreGiveRecursive
++ * \ingroup Semaphores
++ */
++#if ( configUSE_RECURSIVE_MUTEXES == 1 )
++    #define xSemaphoreGiveRecursive( xMutex )    xQueueGiveMutexRecursive( ( xMutex ) )
++#endif
++
++/**
++ * semphr. h
++ * @code{c}
++ * xSemaphoreGiveFromISR(
++ *                        SemaphoreHandle_t xSemaphore,
++ *                        BaseType_t *pxHigherPriorityTaskWoken
++ *                    );
++ * @endcode
++ *
++ * <i>Macro</i> to  release a semaphore.  The semaphore must have previously been
++ * created with a call to xSemaphoreCreateBinary() or xSemaphoreCreateCounting().
++ *
++ * Mutex type semaphores (those created using a call to xSemaphoreCreateMutex())
++ * must not be used with this macro.
++ *
++ * This macro can be used from an ISR.
++ *
++ * @param xSemaphore A handle to the semaphore being released.  This is the
++ * handle returned when the semaphore was created.
++ *
++ * @param pxHigherPriorityTaskWoken xSemaphoreGiveFromISR() will set
++ * *pxHigherPriorityTaskWoken to pdTRUE if giving the semaphore caused a task
++ * to unblock, and the unblocked task has a priority higher than the currently
++ * running task.  If xSemaphoreGiveFromISR() sets this value to pdTRUE then
++ * a context switch should be requested before the interrupt is exited.
++ *
++ * @return pdTRUE if the semaphore was successfully given, otherwise errQUEUE_FULL.
++ *
++ * Example usage:
++ * @code{c}
++ \#define LONG_TIME 0xffff
++ \#define TICKS_TO_WAIT 10
++ * SemaphoreHandle_t xSemaphore = NULL;
++ *
++ * // Repetitive task.
++ * void vATask( void * pvParameters )
++ * {
++ *  for( ;; )
++ *  {
++ *      // We want this task to run every 10 ticks of a timer.  The semaphore
++ *      // was created before this task was started.
++ *
++ *      // Block waiting for the semaphore to become available.
++ *      if( xSemaphoreTake( xSemaphore, LONG_TIME ) == pdTRUE )
++ *      {
++ *          // It is time to execute.
++ *
++ *          // ...
++ *
++ *          // We have finished our task.  Return to the top of the loop where
++ *          // we will block on the semaphore until it is time to execute
++ *          // again.  Note when using the semaphore for synchronisation with an
++ *          // ISR in this manner there is no need to 'give' the semaphore back.
++ *      }
++ *  }
++ * }
++ *
++ * // Timer ISR
++ * void vTimerISR( void * pvParameters )
++ * {
++ * static uint8_t ucLocalTickCount = 0;
++ * static BaseType_t xHigherPriorityTaskWoken;
++ *
++ *  // A timer tick has occurred.
++ *
++ *  // ... Do other time functions.
++ *
++ *  // Is it time for vATask () to run?
++ *  xHigherPriorityTaskWoken = pdFALSE;
++ *  ucLocalTickCount++;
++ *  if( ucLocalTickCount >= TICKS_TO_WAIT )
++ *  {
++ *      // Unblock the task by releasing the semaphore.
++ *      xSemaphoreGiveFromISR( xSemaphore, &xHigherPriorityTaskWoken );
++ *
++ *      // Reset the count so we release the semaphore again in 10 ticks time.
++ *      ucLocalTickCount = 0;
++ *  }
++ *
++ *  if( xHigherPriorityTaskWoken != pdFALSE )
++ *  {
++ *      // We can force a context switch here.  Context switching from an
++ *      // ISR uses port specific syntax.  Check the demo task for your port
++ *      // to find the syntax required.
++ *  }
++ * }
++ * @endcode
++ * \defgroup xSemaphoreGiveFromISR xSemaphoreGiveFromISR
++ * \ingroup Semaphores
++ */
++#define xSemaphoreGiveFromISR( xSemaphore, pxHigherPriorityTaskWoken )    xQueueGiveFromISR( ( QueueHandle_t ) ( xSemaphore ), ( pxHigherPriorityTaskWoken ) )
++
++/**
++ * semphr. h
++ * @code{c}
++ * xSemaphoreTakeFromISR(
++ *                        SemaphoreHandle_t xSemaphore,
++ *                        BaseType_t *pxHigherPriorityTaskWoken
++ *                    );
++ * @endcode
++ *
++ * <i>Macro</i> to  take a semaphore from an ISR.  The semaphore must have
++ * previously been created with a call to xSemaphoreCreateBinary() or
++ * xSemaphoreCreateCounting().
++ *
++ * Mutex type semaphores (those created using a call to xSemaphoreCreateMutex())
++ * must not be used with this macro.
++ *
++ * This macro can be used from an ISR, however taking a semaphore from an ISR
++ * is not a common operation.  It is likely to only be useful when taking a
++ * counting semaphore when an interrupt is obtaining an object from a resource
++ * pool (when the semaphore count indicates the number of resources available).
++ *
++ * @param xSemaphore A handle to the semaphore being taken.  This is the
++ * handle returned when the semaphore was created.
++ *
++ * @param pxHigherPriorityTaskWoken xSemaphoreTakeFromISR() will set
++ * *pxHigherPriorityTaskWoken to pdTRUE if taking the semaphore caused a task
++ * to unblock, and the unblocked task has a priority higher than the currently
++ * running task.  If xSemaphoreTakeFromISR() sets this value to pdTRUE then
++ * a context switch should be requested before the interrupt is exited.
++ *
++ * @return pdTRUE if the semaphore was successfully taken, otherwise
++ * pdFALSE
++ */
++#define xSemaphoreTakeFromISR( xSemaphore, pxHigherPriorityTaskWoken )    xQueueReceiveFromISR( ( QueueHandle_t ) ( xSemaphore ), NULL, ( pxHigherPriorityTaskWoken ) )
++
++/**
++ * semphr. h
++ * @code{c}
++ * SemaphoreHandle_t xSemaphoreCreateMutex( void );
++ * @endcode
++ *
++ * Creates a new mutex type semaphore instance, and returns a handle by which
++ * the new mutex can be referenced.
++ *
++ * Internally, within the FreeRTOS implementation, mutex semaphores use a block
++ * of memory, in which the mutex structure is stored.  If a mutex is created
++ * using xSemaphoreCreateMutex() then the required memory is automatically
++ * dynamically allocated inside the xSemaphoreCreateMutex() function.  (see
++ * https://www.FreeRTOS.org/a00111.html).  If a mutex is created using
++ * xSemaphoreCreateMutexStatic() then the application writer must provided the
++ * memory.  xSemaphoreCreateMutexStatic() therefore allows a mutex to be created
++ * without using any dynamic memory allocation.
++ *
++ * Mutexes created using this function can be accessed using the xSemaphoreTake()
++ * and xSemaphoreGive() macros.  The xSemaphoreTakeRecursive() and
++ * xSemaphoreGiveRecursive() macros must not be used.
++ *
++ * This type of semaphore uses a priority inheritance mechanism so a task
++ * 'taking' a semaphore MUST ALWAYS 'give' the semaphore back once the
++ * semaphore it is no longer required.
++ *
++ * Mutex type semaphores cannot be used from within interrupt service routines.
++ *
++ * See xSemaphoreCreateBinary() for an alternative implementation that can be
++ * used for pure synchronisation (where one task or interrupt always 'gives' the
++ * semaphore and another always 'takes' the semaphore) and from within interrupt
++ * service routines.
++ *
++ * @return If the mutex was successfully created then a handle to the created
++ * semaphore is returned.  If there was not enough heap to allocate the mutex
++ * data structures then NULL is returned.
++ *
++ * Example usage:
++ * @code{c}
++ * SemaphoreHandle_t xSemaphore;
++ *
++ * void vATask( void * pvParameters )
++ * {
++ *  // Semaphore cannot be used before a call to xSemaphoreCreateMutex().
++ *  // This is a macro so pass the variable in directly.
++ *  xSemaphore = xSemaphoreCreateMutex();
++ *
++ *  if( xSemaphore != NULL )
++ *  {
++ *      // The semaphore was created successfully.
++ *      // The semaphore can now be used.
++ *  }
++ * }
++ * @endcode
++ * \defgroup xSemaphoreCreateMutex xSemaphoreCreateMutex
++ * \ingroup Semaphores
++ */
++#if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
++    #define xSemaphoreCreateMutex()    xQueueCreateMutex( queueQUEUE_TYPE_MUTEX )
++#endif
++
++/**
++ * semphr. h
++ * @code{c}
++ * SemaphoreHandle_t xSemaphoreCreateMutexStatic( StaticSemaphore_t *pxMutexBuffer );
++ * @endcode
++ *
++ * Creates a new mutex type semaphore instance, and returns a handle by which
++ * the new mutex can be referenced.
++ *
++ * Internally, within the FreeRTOS implementation, mutex semaphores use a block
++ * of memory, in which the mutex structure is stored.  If a mutex is created
++ * using xSemaphoreCreateMutex() then the required memory is automatically
++ * dynamically allocated inside the xSemaphoreCreateMutex() function.  (see
++ * https://www.FreeRTOS.org/a00111.html).  If a mutex is created using
++ * xSemaphoreCreateMutexStatic() then the application writer must provided the
++ * memory.  xSemaphoreCreateMutexStatic() therefore allows a mutex to be created
++ * without using any dynamic memory allocation.
++ *
++ * Mutexes created using this function can be accessed using the xSemaphoreTake()
++ * and xSemaphoreGive() macros.  The xSemaphoreTakeRecursive() and
++ * xSemaphoreGiveRecursive() macros must not be used.
++ *
++ * This type of semaphore uses a priority inheritance mechanism so a task
++ * 'taking' a semaphore MUST ALWAYS 'give' the semaphore back once the
++ * semaphore it is no longer required.
++ *
++ * Mutex type semaphores cannot be used from within interrupt service routines.
++ *
++ * See xSemaphoreCreateBinary() for an alternative implementation that can be
++ * used for pure synchronisation (where one task or interrupt always 'gives' the
++ * semaphore and another always 'takes' the semaphore) and from within interrupt
++ * service routines.
++ *
++ * @param pxMutexBuffer Must point to a variable of type StaticSemaphore_t,
++ * which will be used to hold the mutex's data structure, removing the need for
++ * the memory to be allocated dynamically.
++ *
++ * @return If the mutex was successfully created then a handle to the created
++ * mutex is returned.  If pxMutexBuffer was NULL then NULL is returned.
++ *
++ * Example usage:
++ * @code{c}
++ * SemaphoreHandle_t xSemaphore;
++ * StaticSemaphore_t xMutexBuffer;
++ *
++ * void vATask( void * pvParameters )
++ * {
++ *  // A mutex cannot be used before it has been created.  xMutexBuffer is
++ *  // into xSemaphoreCreateMutexStatic() so no dynamic memory allocation is
++ *  // attempted.
++ *  xSemaphore = xSemaphoreCreateMutexStatic( &xMutexBuffer );
++ *
++ *  // As no dynamic memory allocation was performed, xSemaphore cannot be NULL,
++ *  // so there is no need to check it.
++ * }
++ * @endcode
++ * \defgroup xSemaphoreCreateMutexStatic xSemaphoreCreateMutexStatic
++ * \ingroup Semaphores
++ */
++#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
++    #define xSemaphoreCreateMutexStatic( pxMutexBuffer )    xQueueCreateMutexStatic( queueQUEUE_TYPE_MUTEX, ( StaticQueue_t * ) ( pxMutexBuffer ) )
++#endif /* configSUPPORT_STATIC_ALLOCATION */
++
++/**
++ * semphr. h
++ * @code{c}
++ * SemaphoreHandle_t xSemaphoreCreateRecursiveMutex( void );
++ * @endcode
++ *
++ * 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
++ * 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
++ * xSemaphoreCreateRecursiveMutex() function.  (see
++ * https://www.FreeRTOS.org/a00111.html).  If a recursive mutex is created using
++ * xSemaphoreCreateRecursiveMutexStatic() then the application writer must
++ * provide the memory that will get used by the mutex.
++ * xSemaphoreCreateRecursiveMutexStatic() therefore allows a recursive mutex to
++ * be created without using any dynamic memory allocation.
++ *
++ * Mutexes created using this macro can be accessed using the
++ * xSemaphoreTakeRecursive() and xSemaphoreGiveRecursive() macros.  The
++ * xSemaphoreTake() and xSemaphoreGive() macros must not be used.
++ *
++ * A mutex used recursively can be 'taken' repeatedly by the owner. The mutex
++ * doesn't become available again until the owner has called
++ * xSemaphoreGiveRecursive() for each successful 'take' request.  For example,
++ * if a task successfully 'takes' the same mutex 5 times then the mutex will
++ * not be available to any other task until it has also  'given' the mutex back
++ * exactly five times.
++ *
++ * This type of semaphore uses a priority inheritance mechanism so a task
++ * 'taking' a semaphore MUST ALWAYS 'give' the semaphore back once the
++ * semaphore it is no longer required.
++ *
++ * Mutex type semaphores cannot be used from within interrupt service routines.
++ *
++ * See xSemaphoreCreateBinary() for an alternative implementation that can be
++ * used for pure synchronisation (where one task or interrupt always 'gives' the
++ * semaphore and another always 'takes' the semaphore) and from within interrupt
++ * service routines.
++ *
++ * @return xSemaphore Handle to the created mutex semaphore.  Should be of type
++ * SemaphoreHandle_t.
++ *
++ * Example usage:
++ * @code{c}
++ * SemaphoreHandle_t xSemaphore;
++ *
++ * void vATask( void * pvParameters )
++ * {
++ *  // Semaphore cannot be used before a call to xSemaphoreCreateMutex().
++ *  // This is a macro so pass the variable in directly.
++ *  xSemaphore = xSemaphoreCreateRecursiveMutex();
++ *
++ *  if( xSemaphore != NULL )
++ *  {
++ *      // The semaphore was created successfully.
++ *      // The semaphore can now be used.
++ *  }
++ * }
++ * @endcode
++ * \defgroup xSemaphoreCreateRecursiveMutex xSemaphoreCreateRecursiveMutex
++ * \ingroup Semaphores
++ */
++#if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configUSE_RECURSIVE_MUTEXES == 1 ) )
++    #define xSemaphoreCreateRecursiveMutex()    xQueueCreateMutex( queueQUEUE_TYPE_RECURSIVE_MUTEX )
++#endif
++
++/**
++ * semphr. h
++ * @code{c}
++ * SemaphoreHandle_t xSemaphoreCreateRecursiveMutexStatic( StaticSemaphore_t *pxMutexBuffer );
++ * @endcode
++ *
++ * 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
++ * 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
++ * xSemaphoreCreateRecursiveMutex() function.  (see
++ * https://www.FreeRTOS.org/a00111.html).  If a recursive mutex is created using
++ * xSemaphoreCreateRecursiveMutexStatic() then the application writer must
++ * provide the memory that will get used by the mutex.
++ * xSemaphoreCreateRecursiveMutexStatic() therefore allows a recursive mutex to
++ * be created without using any dynamic memory allocation.
++ *
++ * Mutexes created using this macro can be accessed using the
++ * xSemaphoreTakeRecursive() and xSemaphoreGiveRecursive() macros.  The
++ * xSemaphoreTake() and xSemaphoreGive() macros must not be used.
++ *
++ * A mutex used recursively can be 'taken' repeatedly by the owner. The mutex
++ * doesn't become available again until the owner has called
++ * xSemaphoreGiveRecursive() for each successful 'take' request.  For example,
++ * if a task successfully 'takes' the same mutex 5 times then the mutex will
++ * not be available to any other task until it has also  'given' the mutex back
++ * exactly five times.
++ *
++ * This type of semaphore uses a priority inheritance mechanism so a task
++ * 'taking' a semaphore MUST ALWAYS 'give' the semaphore back once the
++ * semaphore it is no longer required.
++ *
++ * Mutex type semaphores cannot be used from within interrupt service routines.
++ *
++ * See xSemaphoreCreateBinary() for an alternative implementation that can be
++ * used for pure synchronisation (where one task or interrupt always 'gives' the
++ * semaphore and another always 'takes' the semaphore) and from within interrupt
++ * service routines.
++ *
++ * @param pxMutexBuffer Must point to a variable of type StaticSemaphore_t,
++ * which will then be used to hold the recursive mutex's data structure,
++ * removing the need for the memory to be allocated dynamically.
++ *
++ * @return If the recursive mutex was successfully created then a handle to the
++ * created recursive mutex is returned.  If pxMutexBuffer was NULL then NULL is
++ * returned.
++ *
++ * Example usage:
++ * @code{c}
++ * SemaphoreHandle_t xSemaphore;
++ * StaticSemaphore_t xMutexBuffer;
++ *
++ * void vATask( void * pvParameters )
++ * {
++ *  // A recursive semaphore cannot be used before it is created.  Here a
++ *  // recursive mutex is created using xSemaphoreCreateRecursiveMutexStatic().
++ *  // The address of xMutexBuffer is passed into the function, and will hold
++ *  // the mutexes data structures - so no dynamic memory allocation will be
++ *  // attempted.
++ *  xSemaphore = xSemaphoreCreateRecursiveMutexStatic( &xMutexBuffer );
++ *
++ *  // As no dynamic memory allocation was performed, xSemaphore cannot be NULL,
++ *  // so there is no need to check it.
++ * }
++ * @endcode
++ * \defgroup xSemaphoreCreateRecursiveMutexStatic xSemaphoreCreateRecursiveMutexStatic
++ * \ingroup Semaphores
++ */
++#if ( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_RECURSIVE_MUTEXES == 1 ) )
++    #define xSemaphoreCreateRecursiveMutexStatic( pxStaticSemaphore )    xQueueCreateMutexStatic( queueQUEUE_TYPE_RECURSIVE_MUTEX, ( StaticQueue_t * ) pxStaticSemaphore )
++#endif /* configSUPPORT_STATIC_ALLOCATION */
++
++/**
++ * semphr. h
++ * @code{c}
++ * SemaphoreHandle_t xSemaphoreCreateCounting( UBaseType_t uxMaxCount, UBaseType_t uxInitialCount );
++ * @endcode
++ *
++ * Creates a new counting semaphore instance, and returns a handle by which the
++ * new counting semaphore can be referenced.
++ *
++ * In many usage scenarios it is faster and more memory efficient to use a
++ * direct to task notification in place of a counting semaphore!
++ * https://www.FreeRTOS.org/RTOS-task-notifications.html
++ *
++ * Internally, within the FreeRTOS implementation, counting semaphores use a
++ * block of memory, in which the counting semaphore structure is stored.  If a
++ * counting semaphore is created using xSemaphoreCreateCounting() then the
++ * required memory is automatically dynamically allocated inside the
++ * xSemaphoreCreateCounting() function.  (see
++ * https://www.FreeRTOS.org/a00111.html).  If a counting semaphore is created
++ * using xSemaphoreCreateCountingStatic() then the application writer can
++ * instead optionally provide the memory that will get used by the counting
++ * semaphore.  xSemaphoreCreateCountingStatic() therefore allows a counting
++ * semaphore to be created without using any dynamic memory allocation.
++ *
++ * Counting semaphores are typically used for two things:
++ *
++ * 1) Counting events.
++ *
++ *    In this usage scenario an event handler will 'give' a semaphore each time
++ *    an event occurs (incrementing the semaphore count value), and a handler
++ *    task will 'take' a semaphore each time it processes an event
++ *    (decrementing the semaphore count value).  The count value is therefore
++ *    the difference between the number of events that have occurred and the
++ *    number that have been processed.  In this case it is desirable for the
++ *    initial count value to be zero.
++ *
++ * 2) Resource management.
++ *
++ *    In this usage scenario the count value indicates the number of resources
++ *    available.  To obtain control of a resource a task must first obtain a
++ *    semaphore - decrementing the semaphore count value.  When the count value
++ *    reaches zero there are no free resources.  When a task finishes with the
++ *    resource it 'gives' the semaphore back - incrementing the semaphore count
++ *    value.  In this case it is desirable for the initial count value to be
++ *    equal to the maximum count value, indicating that all resources are free.
++ *
++ * @param uxMaxCount The maximum count value that can be reached.  When the
++ *        semaphore reaches this value it can no longer be 'given'.
++ *
++ * @param uxInitialCount The count value assigned to the semaphore when it is
++ *        created.
++ *
++ * @return Handle to the created semaphore.  Null if the semaphore could not be
++ *         created.
++ *
++ * Example usage:
++ * @code{c}
++ * SemaphoreHandle_t xSemaphore;
++ *
++ * void vATask( void * pvParameters )
++ * {
++ * SemaphoreHandle_t xSemaphore = NULL;
++ *
++ *  // Semaphore cannot be used before a call to xSemaphoreCreateCounting().
++ *  // The max value to which the semaphore can count should be 10, and the
++ *  // initial value assigned to the count should be 0.
++ *  xSemaphore = xSemaphoreCreateCounting( 10, 0 );
++ *
++ *  if( xSemaphore != NULL )
++ *  {
++ *      // The semaphore was created successfully.
++ *      // The semaphore can now be used.
++ *  }
++ * }
++ * @endcode
++ * \defgroup xSemaphoreCreateCounting xSemaphoreCreateCounting
++ * \ingroup Semaphores
++ */
++#if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
++    #define xSemaphoreCreateCounting( uxMaxCount, uxInitialCount )    xQueueCreateCountingSemaphore( ( uxMaxCount ), ( uxInitialCount ) )
++#endif
++
++/**
++ * semphr. h
++ * @code{c}
++ * SemaphoreHandle_t xSemaphoreCreateCountingStatic( UBaseType_t uxMaxCount, UBaseType_t uxInitialCount, StaticSemaphore_t *pxSemaphoreBuffer );
++ * @endcode
++ *
++ * Creates a new counting semaphore instance, and returns a handle by which the
++ * new counting semaphore can be referenced.
++ *
++ * In many usage scenarios it is faster and more memory efficient to use a
++ * direct to task notification in place of a counting semaphore!
++ * https://www.FreeRTOS.org/RTOS-task-notifications.html
++ *
++ * Internally, within the FreeRTOS implementation, counting semaphores use a
++ * block of memory, in which the counting semaphore structure is stored.  If a
++ * counting semaphore is created using xSemaphoreCreateCounting() then the
++ * required memory is automatically dynamically allocated inside the
++ * xSemaphoreCreateCounting() function.  (see
++ * https://www.FreeRTOS.org/a00111.html).  If a counting semaphore is created
++ * using xSemaphoreCreateCountingStatic() then the application writer must
++ * provide the memory.  xSemaphoreCreateCountingStatic() therefore allows a
++ * counting semaphore to be created without using any dynamic memory allocation.
++ *
++ * Counting semaphores are typically used for two things:
++ *
++ * 1) Counting events.
++ *
++ *    In this usage scenario an event handler will 'give' a semaphore each time
++ *    an event occurs (incrementing the semaphore count value), and a handler
++ *    task will 'take' a semaphore each time it processes an event
++ *    (decrementing the semaphore count value).  The count value is therefore
++ *    the difference between the number of events that have occurred and the
++ *    number that have been processed.  In this case it is desirable for the
++ *    initial count value to be zero.
++ *
++ * 2) Resource management.
++ *
++ *    In this usage scenario the count value indicates the number of resources
++ *    available.  To obtain control of a resource a task must first obtain a
++ *    semaphore - decrementing the semaphore count value.  When the count value
++ *    reaches zero there are no free resources.  When a task finishes with the
++ *    resource it 'gives' the semaphore back - incrementing the semaphore count
++ *    value.  In this case it is desirable for the initial count value to be
++ *    equal to the maximum count value, indicating that all resources are free.
++ *
++ * @param uxMaxCount The maximum count value that can be reached.  When the
++ *        semaphore reaches this value it can no longer be 'given'.
++ *
++ * @param uxInitialCount The count value assigned to the semaphore when it is
++ *        created.
++ *
++ * @param pxSemaphoreBuffer Must point to a variable of type StaticSemaphore_t,
++ * which will then be used to hold the semaphore's data structure, removing the
++ * need for the memory to be allocated dynamically.
++ *
++ * @return If the counting semaphore was successfully created then a handle to
++ * the created counting semaphore is returned.  If pxSemaphoreBuffer was NULL
++ * then NULL is returned.
++ *
++ * Example usage:
++ * @code{c}
++ * SemaphoreHandle_t xSemaphore;
++ * StaticSemaphore_t xSemaphoreBuffer;
++ *
++ * void vATask( void * pvParameters )
++ * {
++ * SemaphoreHandle_t xSemaphore = NULL;
++ *
++ *  // Counting semaphore cannot be used before they have been created.  Create
++ *  // a counting semaphore using xSemaphoreCreateCountingStatic().  The max
++ *  // value to which the semaphore can count is 10, and the initial value
++ *  // assigned to the count will be 0.  The address of xSemaphoreBuffer is
++ *  // passed in and will be used to hold the semaphore structure, so no dynamic
++ *  // memory allocation will be used.
++ *  xSemaphore = xSemaphoreCreateCounting( 10, 0, &xSemaphoreBuffer );
++ *
++ *  // No memory allocation was attempted so xSemaphore cannot be NULL, so there
++ *  // is no need to check its value.
++ * }
++ * @endcode
++ * \defgroup xSemaphoreCreateCountingStatic xSemaphoreCreateCountingStatic
++ * \ingroup Semaphores
++ */
++#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
++    #define xSemaphoreCreateCountingStatic( uxMaxCount, uxInitialCount, pxSemaphoreBuffer )    xQueueCreateCountingSemaphoreStatic( ( uxMaxCount ), ( uxInitialCount ), ( StaticQueue_t * ) ( pxSemaphoreBuffer ) )
++#endif /* configSUPPORT_STATIC_ALLOCATION */
++
++/**
++ * semphr. h
++ * @code{c}
++ * void vSemaphoreDelete( SemaphoreHandle_t xSemaphore );
++ * @endcode
++ *
++ * Delete a semaphore.  This function must be used with care.  For example,
++ * do not delete a mutex type semaphore if the mutex is held by a task.
++ *
++ * @param xSemaphore A handle to the semaphore to be deleted.
++ *
++ * \defgroup vSemaphoreDelete vSemaphoreDelete
++ * \ingroup Semaphores
++ */
++#define vSemaphoreDelete( xSemaphore )                   vQueueDelete( ( QueueHandle_t ) ( xSemaphore ) )
++
++/**
++ * semphr.h
++ * @code{c}
++ * TaskHandle_t xSemaphoreGetMutexHolder( SemaphoreHandle_t xMutex );
++ * @endcode
++ *
++ * If xMutex is indeed a mutex type semaphore, return the current mutex holder.
++ * If xMutex is not a mutex type semaphore, or the mutex is available (not held
++ * by a task), return NULL.
++ *
++ * Note: This is a good way of determining if the calling task is the mutex
++ * holder, but not a good way of determining the identity of the mutex holder as
++ * the holder may change between the function exiting and the returned value
++ * being tested.
++ */
++#define xSemaphoreGetMutexHolder( xSemaphore )           xQueueGetMutexHolder( ( xSemaphore ) )
++
++/**
++ * semphr.h
++ * @code{c}
++ * TaskHandle_t xSemaphoreGetMutexHolderFromISR( SemaphoreHandle_t xMutex );
++ * @endcode
++ *
++ * If xMutex is indeed a mutex type semaphore, return the current mutex holder.
++ * If xMutex is not a mutex type semaphore, or the mutex is available (not held
++ * by a task), return NULL.
++ *
++ */
++#define xSemaphoreGetMutexHolderFromISR( xSemaphore )    xQueueGetMutexHolderFromISR( ( xSemaphore ) )
++
++/**
++ * semphr.h
++ * @code{c}
++ * UBaseType_t uxSemaphoreGetCount( SemaphoreHandle_t xSemaphore );
++ * @endcode
++ *
++ * If the semaphore is a counting semaphore then uxSemaphoreGetCount() returns
++ * its current count value.  If the semaphore is a binary semaphore then
++ * uxSemaphoreGetCount() returns 1 if the semaphore is available, and 0 if the
++ * semaphore is not available.
++ *
++ */
++#define uxSemaphoreGetCount( xSemaphore )                uxQueueMessagesWaiting( ( QueueHandle_t ) ( xSemaphore ) )
++
++/**
++ * semphr.h
++ * @code{c}
++ * UBaseType_t uxSemaphoreGetCountFromISR( SemaphoreHandle_t xSemaphore );
++ * @endcode
++ *
++ * If the semaphore is a counting semaphore then uxSemaphoreGetCountFromISR() returns
++ * its current count value.  If the semaphore is a binary semaphore then
++ * uxSemaphoreGetCountFromISR() returns 1 if the semaphore is available, and 0 if the
++ * semaphore is not available.
++ *
++ */
++#define uxSemaphoreGetCountFromISR( xSemaphore )         uxQueueMessagesWaitingFromISR( ( QueueHandle_t ) ( xSemaphore ) )
++
++#endif /* SEMAPHORE_H */
+diff --git a/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/freertos/task.h b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/freertos/task.h
+new file mode 100644
+index 0000000000..20f6a52104
+--- /dev/null
++++ b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/freertos/task.h
+@@ -0,0 +1,2265 @@
++/*
++ * FreeRTOS Kernel V10.4.6
++ * 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_TASK_H
++#define INC_TASK_H
++
++#ifndef INC_FREERTOS_H
++    #error "include FreeRTOS.h must appear in source files before include task.h"
++#endif
++
++/* *INDENT-OFF* */
++#ifdef __cplusplus
++    extern "C" {
++#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
++
++/* 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 )
++
++/* ESP32 */
++#define tskNO_AFFINITY  ( 0x7FFFFFFF )
++
++/**
++ * 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
++{
++    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. */
++    eSuspended,   /* The task being queried is in the Suspended state, or is in the Blocked state with an infinite time out. */
++    eDeleted,     /* The task being queried has been deleted, but its TCB has not yet been freed. */
++    eInvalid      /* Used as an 'invalid state' value. */
++} eTaskState;
++
++/* Actions that can be performed when vTaskNotify() is called. */
++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. */
++    eSetValueWithOverwrite,   /* Set the task's notification value to a specific value even if the previous value has not yet been read by the task. */
++    eSetValueWithoutOverwrite /* Set the task's notification value if the previous value has been read by the task. */
++} eNotifyAction;
++
++/*
++ * Used internally only.
++ */
++typedef struct xTIME_OUT
++{
++    BaseType_t xOverflowCount;
++    TickType_t xTimeOnEntering;
++} TimeOut_t;
++
++/**
++ * Defines the priority used by the idle task.  This must not be modified.
++ *
++ * \ingroup TaskUtils
++ */
++#define tskIDLE_PRIORITY    ( ( UBaseType_t ) 0U )
++
++/**
++ * task. h
++ *
++ * Macro for forcing a context switch.
++ *
++ * \defgroup taskYIELD taskYIELD
++ * \ingroup SchedulerControl
++ */
++#define taskYIELD()                        portYIELD()
++
++/**
++ * task. h
++ *
++ * Macro to mark the start of a critical code region.  Preemptive context
++ * switches cannot occur when in a critical region.
++ *
++ * NOTE: This may alter the stack (depending on the portable implementation)
++ * so must be used with care!
++ *
++ * \defgroup taskENTER_CRITICAL taskENTER_CRITICAL
++ * \ingroup SchedulerControl
++ */
++#define taskENTER_CRITICAL()               portENTER_CRITICAL()
++#define taskENTER_CRITICAL_FROM_ISR()      portSET_INTERRUPT_MASK_FROM_ISR()
++
++/**
++ * task. h
++ *
++ * Macro to mark the end of a critical code region.  Preemptive context
++ * switches cannot occur when in a critical region.
++ *
++ * NOTE: This may alter the stack (depending on the portable implementation)
++ * so must be used with care!
++ *
++ * \defgroup taskEXIT_CRITICAL taskEXIT_CRITICAL
++ * \ingroup SchedulerControl
++ */
++#define taskEXIT_CRITICAL()                portEXIT_CRITICAL()
++#define taskEXIT_CRITICAL_FROM_ISR( x )    portCLEAR_INTERRUPT_MASK_FROM_ISR( x )
++
++/**
++ * task. h
++ *
++ * Macro to disable all maskable interrupts.
++ *
++ * \defgroup taskDISABLE_INTERRUPTS taskDISABLE_INTERRUPTS
++ * \ingroup SchedulerControl
++ */
++#define taskDISABLE_INTERRUPTS()           portDISABLE_INTERRUPTS()
++
++/**
++ * task. h
++ *
++ * Macro to enable microcontroller interrupts.
++ *
++ * \defgroup taskENABLE_INTERRUPTS taskENABLE_INTERRUPTS
++ * \ingroup SchedulerControl
++ */
++#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
++ * is used in assert() statements. */
++#define taskSCHEDULER_SUSPENDED      ( ( BaseType_t ) 0 )
++#define taskSCHEDULER_NOT_STARTED    ( ( BaseType_t ) 1 )
++#define taskSCHEDULER_RUNNING        ( ( BaseType_t ) 2 )
++
++/*-----------------------------------------------------------
++* TASK CREATION API
++*----------------------------------------------------------*/
++
++/**
++ * task. h
++ * @code{c}
++ * BaseType_t xTaskCreate(
++ *                            TaskFunction_t pxTaskCode,
++ *                            const char *pcName,
++ *                            configSTACK_DEPTH_TYPE usStackDepth,
++ *                            void *pvParameters,
++ *                            UBaseType_t uxPriority,
++ *                            TaskHandle_t *pxCreatedTask
++ *                        );
++ * @endcode
++ *
++ * Create a new task and add it to the list of tasks that are ready to run.
++ *
++ * Internally, within the FreeRTOS implementation, tasks use two blocks of
++ * memory.  The first block is used to hold the task's data structures.  The
++ * second block is used by the task as its stack.  If a task is created using
++ * xTaskCreate() then both blocks of memory are automatically dynamically
++ * allocated inside the xTaskCreate() function.  (see
++ * https://www.FreeRTOS.org/a00111.html).  If a task is created using
++ * xTaskCreateStatic() then the application writer must provide the required
++ * memory.  xTaskCreateStatic() therefore allows a task to be created without
++ * using any dynamic memory allocation.
++ *
++ * See xTaskCreateStatic() for a version that does not use any dynamic memory
++ * allocation.
++ *
++ * xTaskCreate() can only be used to create a task that has unrestricted
++ * access to the entire microcontroller memory map.  Systems that include MPU
++ * support can alternatively create an MPU constrained task using
++ * xTaskCreateRestricted().
++ *
++ * @param pxTaskCode Pointer to the task entry function.  Tasks
++ * must be implemented to never return (i.e. continuous loop).
++ *
++ * @param pcName A descriptive name for the task.  This is mainly used to
++ * 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
++ * 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
++ * will be allocated for stack storage.
++ *
++ * @param pvParameters Pointer that will be used as the parameter for the task
++ * being created.
++ *
++ * @param uxPriority The priority at which the task should run.  Systems that
++ * include MPU support can optionally create tasks in a privileged (system)
++ * mode by setting bit portPRIVILEGE_BIT of the priority parameter.  For
++ * example, to create a privileged task at priority 2 the uxPriority parameter
++ * should be set to ( 2 | portPRIVILEGE_BIT ).
++ *
++ * @param pxCreatedTask Used to pass back a handle by which the created task
++ * can be referenced.
++ *
++ * @return pdPASS if the task was successfully created and added to a ready
++ * list, otherwise an error code defined in the file projdefs.h
++ *
++ * Example usage:
++ * @code{c}
++ * // Task to be created.
++ * void vTaskCode( void * pvParameters )
++ * {
++ *   for( ;; )
++ *   {
++ *       // Task code goes here.
++ *   }
++ * }
++ *
++ * // Function that creates a task.
++ * void vOtherFunction( void )
++ * {
++ * static uint8_t ucParameterToPass;
++ * TaskHandle_t xHandle = NULL;
++ *
++ *   // Create the task, storing the handle.  Note that the passed parameter ucParameterToPass
++ *   // must exist for the lifetime of the task, so in this case is declared static.  If it was just an
++ *   // an automatic stack variable it might no longer exist, or at least have been corrupted, by the time
++ *   // the new task attempts to access it.
++ *   xTaskCreate( vTaskCode, "NAME", STACK_SIZE, &ucParameterToPass, tskIDLE_PRIORITY, &xHandle );
++ *   configASSERT( xHandle );
++ *
++ *   // Use the handle to delete the task.
++ *   if( xHandle != NULL )
++ *   {
++ *      vTaskDelete( xHandle );
++ *   }
++ * }
++ * @endcode
++ * \defgroup xTaskCreate xTaskCreate
++ * \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 );
++#endif
++/* ESP32 */
++#if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
++    BaseType_t xTaskCreatePinnedToCore( TaskFunction_t pvTaskCode,
++                                        const char * const pcName,
++                                        const uint32_t usStackDepth,
++                                        void * const pvParameters,
++                                        UBaseType_t uxPriority,
++                                        TaskHandle_t * const pvCreatedTask,
++                                        const BaseType_t xCoreID);
++
++#endif
++
++/**
++ * task. h
++ * @code{c}
++ * TaskHandle_t xTaskCreateStatic( TaskFunction_t pxTaskCode,
++ *                               const char *pcName,
++ *                               uint32_t ulStackDepth,
++ *                               void *pvParameters,
++ *                               UBaseType_t uxPriority,
++ *                               StackType_t *puxStackBuffer,
++ *                               StaticTask_t *pxTaskBuffer );
++ * @endcode
++ *
++ * Create a new task and add it to the list of tasks that are ready to run.
++ *
++ * Internally, within the FreeRTOS implementation, tasks use two blocks of
++ * memory.  The first block is used to hold the task's data structures.  The
++ * second block is used by the task as its stack.  If a task is created using
++ * xTaskCreate() then both blocks of memory are automatically dynamically
++ * allocated inside the xTaskCreate() function.  (see
++ * https://www.FreeRTOS.org/a00111.html).  If a task is created using
++ * xTaskCreateStatic() then the application writer must provide the required
++ * memory.  xTaskCreateStatic() therefore allows a task to be created without
++ * using any dynamic memory allocation.
++ *
++ * @param pxTaskCode Pointer to the task entry function.  Tasks
++ * must be implemented to never return (i.e. continuous loop).
++ *
++ * @param pcName A descriptive name for the task.  This is mainly used to
++ * 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
++ * 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
++ * will be allocated for stack storage.
++ *
++ * @param pvParameters Pointer that will be used as the parameter for the task
++ * being created.
++ *
++ * @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,
++ * removing the need for the stack to be allocated dynamically.
++ *
++ * @param pxTaskBuffer Must point to a variable of type StaticTask_t, which will
++ * then be used to hold the task's data structures, removing the need for the
++ * memory to be allocated dynamically.
++ *
++ * @return If neither puxStackBuffer nor pxTaskBuffer are NULL, then the task
++ * will be created and a handle to the created task is returned.  If either
++ * puxStackBuffer or pxTaskBuffer are NULL then the task will not be created and
++ * NULL is returned.
++ *
++ * Example usage:
++ * @code{c}
++ *
++ *  // Dimensions of the buffer that the task being created will use as its stack.
++ *  // NOTE:  This is the number of words the stack will hold, not the number of
++ *  // bytes.  For example, if each stack item is 32-bits, and this is set to 100,
++ *  // then 400 bytes (100 * 32-bits) will be allocated.
++ #define STACK_SIZE 200
++ *
++ *  // Structure that will hold the TCB of the task being created.
++ *  StaticTask_t xTaskBuffer;
++ *
++ *  // Buffer that the task being created will use as its stack.  Note this is
++ *  // an array of StackType_t variables.  The size of StackType_t is dependent on
++ *  // the RTOS port.
++ *  StackType_t xStack[ STACK_SIZE ];
++ *
++ *  // Function that implements the task being created.
++ *  void vTaskCode( void * pvParameters )
++ *  {
++ *      // 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 );
++ *
++ *      for( ;; )
++ *      {
++ *          // Task code goes here.
++ *      }
++ *  }
++ *
++ *  // Function that creates a task.
++ *  void vOtherFunction( void )
++ *  {
++ *      TaskHandle_t xHandle = NULL;
++ *
++ *      // Create the task without using any dynamic memory allocation.
++ *      xHandle = xTaskCreateStatic(
++ *                    vTaskCode,       // Function that implements the task.
++ *                    "NAME",          // Text name for the task.
++ *                    STACK_SIZE,      // Stack size in words, not bytes.
++ *                    ( void * ) 1,    // Parameter passed into the task.
++ *                    tskIDLE_PRIORITY,// Priority at which the task is created.
++ *                    xStack,          // Array to use as the task's stack.
++ *                    &xTaskBuffer );  // Variable to hold the task's data structure.
++ *
++ *      // puxStackBuffer and pxTaskBuffer were not NULL, so the task will have
++ *      // been created, and xHandle will be the task's handle.  Use the handle
++ *      // to suspend the task.
++ *      vTaskSuspend( xHandle );
++ *  }
++ * @endcode
++ * \defgroup xTaskCreateStatic xTaskCreateStatic
++ * \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 );
++#endif /* configSUPPORT_STATIC_ALLOCATION */
++
++/**
++ * task. h
++ * @code{c}
++ * void vTaskDelete( TaskHandle_t xTaskToDelete );
++ * @endcode
++ *
++ * INCLUDE_vTaskDelete must be defined as 1 for this function to be available.
++ * See the configuration section for more information.
++ *
++ * Remove a task from the RTOS real time kernel's management.  The task being
++ * deleted will be removed from all ready, blocked, suspended and event lists.
++ *
++ * NOTE:  The idle task is responsible for freeing the kernel allocated
++ * memory from tasks that have been deleted.  It is therefore important that
++ * the idle task is not starved of microcontroller processing time if your
++ * application makes any calls to vTaskDelete ().  Memory allocated by the
++ * task code is not automatically freed, and should be freed before the task
++ * is deleted.
++ *
++ * See the demo application file death.c for sample code that utilises
++ * vTaskDelete ().
++ *
++ * @param xTaskToDelete The handle of the task to be deleted.  Passing NULL will
++ * cause the calling task to be deleted.
++ *
++ * Example usage:
++ * @code{c}
++ * void vOtherFunction( void )
++ * {
++ * TaskHandle_t xHandle;
++ *
++ *   // Create the task, storing the handle.
++ *   xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
++ *
++ *   // Use the handle to delete the task.
++ *   vTaskDelete( xHandle );
++ * }
++ * @endcode
++ * \defgroup vTaskDelete vTaskDelete
++ * \ingroup Tasks
++ */
++void vTaskDelete( TaskHandle_t xTaskToDelete );
++
++/*-----------------------------------------------------------
++* TASK CONTROL API
++*----------------------------------------------------------*/
++
++/**
++ * task. h
++ * @code{c}
++ * void vTaskDelay( const TickType_t xTicksToDelay );
++ * @endcode
++ *
++ * Delay a task for a given number of ticks.  The actual time that the
++ * task remains blocked depends on the tick rate.  The constant
++ * portTICK_PERIOD_MS can be used to calculate real time from the tick
++ * rate - with the resolution of one tick period.
++ *
++ * INCLUDE_vTaskDelay must be defined as 1 for this function to be available.
++ * See the configuration section for more information.
++ *
++ *
++ * vTaskDelay() specifies a time at which the task wishes to unblock relative to
++ * the time at which vTaskDelay() is called.  For example, specifying a block
++ * period of 100 ticks will cause the task to unblock 100 ticks after
++ * vTaskDelay() is called.  vTaskDelay() does not therefore provide a good method
++ * of controlling the frequency of a periodic task as the path taken through the
++ * code, as well as other task and interrupt activity, will affect the frequency
++ * at which vTaskDelay() gets called and therefore the time at which the task
++ * next executes.  See xTaskDelayUntil() for an alternative API function designed
++ * to facilitate fixed frequency execution.  It does this by specifying an
++ * absolute time (rather than a relative time) at which the calling task should
++ * unblock.
++ *
++ * @param xTicksToDelay The amount of time, in tick periods, that
++ * the calling task should block.
++ *
++ * Example usage:
++ *
++ * void vTaskFunction( void * pvParameters )
++ * {
++ * // Block for 500ms.
++ * const TickType_t xDelay = 500 / portTICK_PERIOD_MS;
++ *
++ *   for( ;; )
++ *   {
++ *       // Simply toggle the LED every 500ms, blocking between each toggle.
++ *       vToggleLED();
++ *       vTaskDelay( xDelay );
++ *   }
++ * }
++ *
++ * \defgroup vTaskDelay vTaskDelay
++ * \ingroup TaskCtrl
++ */
++void vTaskDelay( const TickType_t xTicksToDelay );
++
++/**
++ * task. h
++ * @code{c}
++ * BaseType_t xTaskDelayUntil( TickType_t *pxPreviousWakeTime, const TickType_t xTimeIncrement );
++ * @endcode
++ *
++ * INCLUDE_xTaskDelayUntil must be defined as 1 for this function to be available.
++ * See the configuration section for more information.
++ *
++ * Delay a task until a specified time.  This function can be used by periodic
++ * tasks to ensure a constant execution frequency.
++ *
++ * This function differs from vTaskDelay () in one important aspect:  vTaskDelay () will
++ * cause a task to block for the specified number of ticks from the time vTaskDelay () is
++ * called.  It is therefore difficult to use vTaskDelay () by itself to generate a fixed
++ * execution frequency as the time between a task starting to execute and that task
++ * calling vTaskDelay () may not be fixed [the task may take a different path though the
++ * code between calls, or may get interrupted or preempted a different number of times
++ * each time it executes].
++ *
++ * Whereas vTaskDelay () specifies a wake time relative to the time at which the function
++ * is called, xTaskDelayUntil () specifies the absolute (exact) time at which it wishes to
++ * unblock.
++ *
++ * The macro pdMS_TO_TICKS() can be used to calculate the number of ticks from a
++ * time specified in milliseconds with a resolution of one tick period.
++ *
++ * @param pxPreviousWakeTime Pointer to a variable that holds the time at which the
++ * task was last unblocked.  The variable must be initialised with the current time
++ * prior to its first use (see the example below).  Following this the variable is
++ * automatically updated within xTaskDelayUntil ().
++ *
++ * @param xTimeIncrement The cycle time period.  The task will be unblocked at
++ * time *pxPreviousWakeTime + xTimeIncrement.  Calling xTaskDelayUntil with the
++ * same xTimeIncrement parameter value will cause the task to execute with
++ * a fixed interface period.
++ *
++ * @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.
++ *
++ * Example usage:
++ * @code{c}
++ * // Perform an action every 10 ticks.
++ * void vTaskFunction( void * pvParameters )
++ * {
++ * TickType_t xLastWakeTime;
++ * const TickType_t xFrequency = 10;
++ * BaseType_t xWasDelayed;
++ *
++ *     // Initialise the xLastWakeTime variable with the current time.
++ *     xLastWakeTime = xTaskGetTickCount ();
++ *     for( ;; )
++ *     {
++ *         // Wait for the next cycle.
++ *         xWasDelayed = xTaskDelayUntil( &xLastWakeTime, xFrequency );
++ *
++ *         // Perform action here. xWasDelayed value can be used to determine
++ *         // whether a deadline was missed if the code here took too long.
++ *     }
++ * }
++ * @endcode
++ * \defgroup xTaskDelayUntil xTaskDelayUntil
++ * \ingroup TaskCtrl
++ */
++BaseType_t xTaskDelayUntil( TickType_t * const pxPreviousWakeTime,
++                            const TickType_t xTimeIncrement );
++
++/*
++ * vTaskDelayUntil() is the older version of xTaskDelayUntil() and does not
++ * return a value.
++ */
++#define vTaskDelayUntil( pxPreviousWakeTime, xTimeIncrement )           \
++    {                                                                   \
++        ( void ) xTaskDelayUntil( pxPreviousWakeTime, xTimeIncrement ); \
++    }
++
++/**
++ * task. h
++ * @code{c}
++ * BaseType_t xTaskAbortDelay( TaskHandle_t xTask );
++ * @endcode
++ *
++ * INCLUDE_xTaskAbortDelay must be defined as 1 in FreeRTOSConfig.h for this
++ * function to be available.
++ *
++ * A task will enter the Blocked state when it is waiting for an event.  The
++ * event it is waiting for can be a temporal event (waiting for a time), such
++ * as when vTaskDelay() is called, or an event on an object, such as when
++ * xQueueReceive() or ulTaskNotifyTake() is called.  If the handle of a task
++ * that is in the Blocked state is used in a call to xTaskAbortDelay() then the
++ * task will leave the Blocked state, and return from whichever function call
++ * placed the task into the Blocked state.
++ *
++ * There is no 'FromISR' version of this function as an interrupt would need to
++ * know which object a task was blocked on in order to know which actions to
++ * take.  For example, if the task was blocked on a queue the interrupt handler
++ * would then need to know if the queue was locked.
++ *
++ * @param xTask The handle of the task to remove from the Blocked state.
++ *
++ * @return If the task referenced by xTask was not in the Blocked state then
++ * pdFAIL is returned.  Otherwise pdPASS is returned.
++ *
++ * \defgroup xTaskAbortDelay xTaskAbortDelay
++ * \ingroup TaskCtrl
++ */
++BaseType_t xTaskAbortDelay( TaskHandle_t xTask );
++
++/**
++ * task. h
++ * @code{c}
++ * UBaseType_t uxTaskPriorityGet( const TaskHandle_t xTask );
++ * @endcode
++ *
++ * INCLUDE_uxTaskPriorityGet must be defined as 1 for this function to be available.
++ * See the configuration section for more information.
++ *
++ * Obtain the priority of any task.
++ *
++ * @param xTask Handle of the task to be queried.  Passing a NULL
++ * handle results in the priority of the calling task being returned.
++ *
++ * @return The priority of xTask.
++ *
++ * Example usage:
++ * @code{c}
++ * void vAFunction( void )
++ * {
++ * TaskHandle_t xHandle;
++ *
++ *   // Create a task, storing the handle.
++ *   xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
++ *
++ *   // ...
++ *
++ *   // Use the handle to obtain the priority of the created task.
++ *   // It was created with tskIDLE_PRIORITY, but may have changed
++ *   // it itself.
++ *   if( uxTaskPriorityGet( xHandle ) != tskIDLE_PRIORITY )
++ *   {
++ *       // The task has changed it's priority.
++ *   }
++ *
++ *   // ...
++ *
++ *   // Is our priority higher than the created task?
++ *   if( uxTaskPriorityGet( xHandle ) < uxTaskPriorityGet( NULL ) )
++ *   {
++ *       // Our priority (obtained using NULL handle) is higher.
++ *   }
++ * }
++ * @endcode
++ * \defgroup uxTaskPriorityGet uxTaskPriorityGet
++ * \ingroup TaskCtrl
++ */
++UBaseType_t uxTaskPriorityGet( const TaskHandle_t xTask );
++
++/**
++ * task. h
++ * @code{c}
++ * UBaseType_t uxTaskPriorityGetFromISR( const TaskHandle_t xTask );
++ * @endcode
++ *
++ * A version of uxTaskPriorityGet() that can be used from an ISR.
++ */
++UBaseType_t uxTaskPriorityGetFromISR( const TaskHandle_t xTask );
++
++/**
++ * task. h
++ * @code{c}
++ * eTaskState eTaskGetState( TaskHandle_t xTask );
++ * @endcode
++ *
++ * INCLUDE_eTaskGetState must be defined as 1 for this function to be available.
++ * See the configuration section for more information.
++ *
++ * Obtain the state of any task.  States are encoded by the eTaskState
++ * enumerated type.
++ *
++ * @param xTask Handle of the task to be queried.
++ *
++ * @return The state of xTask at the time the function was called.  Note the
++ * 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 );
++
++/**
++ * task. h
++ * @code{c}
++ * void vTaskPrioritySet( TaskHandle_t xTask, UBaseType_t uxNewPriority );
++ * @endcode
++ *
++ * INCLUDE_vTaskPrioritySet must be defined as 1 for this function to be available.
++ * See the configuration section for more information.
++ *
++ * Set the priority of any task.
++ *
++ * A context switch will occur before the function returns if the priority
++ * being set is higher than the currently executing task.
++ *
++ * @param xTask Handle to the task for which the priority is being set.
++ * Passing a NULL handle results in the priority of the calling task being set.
++ *
++ * @param uxNewPriority The priority to which the task will be set.
++ *
++ * Example usage:
++ * @code{c}
++ * void vAFunction( void )
++ * {
++ * TaskHandle_t xHandle;
++ *
++ *   // Create a task, storing the handle.
++ *   xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
++ *
++ *   // ...
++ *
++ *   // Use the handle to raise the priority of the created task.
++ *   vTaskPrioritySet( xHandle, tskIDLE_PRIORITY + 1 );
++ *
++ *   // ...
++ *
++ *   // Use a NULL handle to raise our priority to the same value.
++ *   vTaskPrioritySet( NULL, tskIDLE_PRIORITY + 1 );
++ * }
++ * @endcode
++ * \defgroup vTaskPrioritySet vTaskPrioritySet
++ * \ingroup TaskCtrl
++ */
++void vTaskPrioritySet( TaskHandle_t xTask,
++                       UBaseType_t uxNewPriority );
++
++/**
++ * task. h
++ * @code{c}
++ * void vTaskSuspend( TaskHandle_t xTaskToSuspend );
++ * @endcode
++ *
++ * INCLUDE_vTaskSuspend must be defined as 1 for this function to be available.
++ * See the configuration section for more information.
++ *
++ * Suspend any task.  When suspended a task will never get any microcontroller
++ * processing time, no matter what its priority.
++ *
++ * Calls to vTaskSuspend are not accumulative -
++ * i.e. calling vTaskSuspend () twice on the same task still only requires one
++ * call to vTaskResume () to ready the suspended task.
++ *
++ * RT-Thread only supports suspending the current running thread.
++ * This function must be called with NULL as the parameter.
++ *
++ * @param xTaskToSuspend Handle to the task being suspended.  Passing a NULL
++ * handle will cause the calling task to be suspended.
++ *
++ * Example usage:
++ * @code{c}
++ * void vAFunction( void )
++ * {
++ * TaskHandle_t xHandle;
++ *
++ *   // Create a task, storing the handle.
++ *   xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
++ *
++ *   // ...
++ *
++ *   // Use the handle to suspend the created task.
++ *   vTaskSuspend( xHandle );
++ *
++ *   // ...
++ *
++ *   // The created task will not run during this period, unless
++ *   // another task calls vTaskResume( xHandle ).
++ *
++ *   //...
++ *
++ *
++ *   // Suspend ourselves.
++ *   vTaskSuspend( NULL );
++ *
++ *   // We cannot get here unless another task calls vTaskResume
++ *   // with our handle as the parameter.
++ * }
++ * @endcode
++ * \defgroup vTaskSuspend vTaskSuspend
++ * \ingroup TaskCtrl
++ */
++void vTaskSuspend( TaskHandle_t xTaskToSuspend );
++
++/**
++ * task. h
++ * @code{c}
++ * void vTaskResume( TaskHandle_t xTaskToResume );
++ * @endcode
++ *
++ * INCLUDE_vTaskSuspend must be defined as 1 for this function to be available.
++ * See the configuration section for more information.
++ *
++ * Resumes a suspended task.
++ *
++ * A task that has been suspended by one or more calls to vTaskSuspend ()
++ * will be made available for running again by a single call to
++ * vTaskResume ().
++ *
++ * @param xTaskToResume Handle to the task being readied.
++ *
++ * Example usage:
++ * @code{c}
++ * void vAFunction( void )
++ * {
++ * TaskHandle_t xHandle;
++ *
++ *   // Create a task, storing the handle.
++ *   xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
++ *
++ *   // ...
++ *
++ *   // Use the handle to suspend the created task.
++ *   vTaskSuspend( xHandle );
++ *
++ *   // ...
++ *
++ *   // The created task will not run during this period, unless
++ *   // another task calls vTaskResume( xHandle ).
++ *
++ *   //...
++ *
++ *
++ *   // Resume the suspended task ourselves.
++ *   vTaskResume( xHandle );
++ *
++ *   // The created task will once again get microcontroller processing
++ *   // time in accordance with its priority within the system.
++ * }
++ * @endcode
++ * \defgroup vTaskResume vTaskResume
++ * \ingroup TaskCtrl
++ */
++void vTaskResume( TaskHandle_t xTaskToResume );
++
++/**
++ * task. h
++ * @code{c}
++ * void xTaskResumeFromISR( TaskHandle_t xTaskToResume );
++ * @endcode
++ *
++ * INCLUDE_xTaskResumeFromISR must be defined as 1 for this function to be
++ * available.  See the configuration section for more information.
++ *
++ * An implementation of vTaskResume() that can be called from within an ISR.
++ *
++ * A task that has been suspended by one or more calls to vTaskSuspend ()
++ * will be made available for running again by a single call to
++ * xTaskResumeFromISR ().
++ *
++ * xTaskResumeFromISR() should not be used to synchronise a task with an
++ * interrupt if there is a chance that the interrupt could arrive prior to the
++ * task being suspended - as this can lead to interrupts being missed. Use of a
++ * semaphore as a synchronisation mechanism would avoid this eventuality.
++ *
++ * @param xTaskToResume Handle to the task being readied.
++ *
++ * @return pdTRUE if resuming the task should result in a context switch,
++ * otherwise pdFALSE. This is used by the ISR to determine if a context switch
++ * may be required following the ISR.
++ *
++ * \defgroup vTaskResumeFromISR vTaskResumeFromISR
++ * \ingroup TaskCtrl
++ */
++BaseType_t xTaskResumeFromISR( TaskHandle_t xTaskToResume );
++
++/*-----------------------------------------------------------
++* SCHEDULER CONTROL
++*----------------------------------------------------------*/
++
++/**
++ * task. h
++ * @code{c}
++ * void vTaskStartScheduler( void );
++ * @endcode
++ *
++ * Starts the real time kernel tick processing.  After calling the kernel
++ * has control over which tasks are executed and when.
++ *
++ * See the demo application file main.c for an example of creating
++ * tasks and starting the kernel.
++ *
++ * Example usage:
++ * @code{c}
++ * void vAFunction( void )
++ * {
++ *   // Create at least one task before starting the kernel.
++ *   xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );
++ *
++ *   // Start the real time kernel with preemption.
++ *   vTaskStartScheduler ();
++ *
++ *   // Will not get here unless a task calls vTaskEndScheduler ()
++ * }
++ * @endcode
++ *
++ * \defgroup vTaskStartScheduler vTaskStartScheduler
++ * \ingroup SchedulerControl
++ */
++void vTaskStartScheduler( void );
++
++/**
++ * task. h
++ * @code{c}
++ * void vTaskEndScheduler( void );
++ * @endcode
++ *
++ * NOTE:  At the time of writing only the x86 real mode port, which runs on a PC
++ * in place of DOS, implements this function.
++ *
++ * Stops the real time kernel tick.  All created tasks will be automatically
++ * deleted and multitasking (either preemptive or cooperative) will
++ * stop.  Execution then resumes from the point where vTaskStartScheduler ()
++ * was called, as if vTaskStartScheduler () had just returned.
++ *
++ * See the demo application file main. c in the demo/PC directory for an
++ * example that uses vTaskEndScheduler ().
++ *
++ * vTaskEndScheduler () requires an exit function to be defined within the
++ * portable layer (see vPortEndScheduler () in port. c for the PC port).  This
++ * performs hardware specific operations such as stopping the kernel tick.
++ *
++ * vTaskEndScheduler () will cause all of the resources allocated by the
++ * kernel to be freed - but will not free resources allocated by application
++ * tasks.
++ *
++ * Example usage:
++ * @code{c}
++ * void vTaskCode( void * pvParameters )
++ * {
++ *   for( ;; )
++ *   {
++ *       // Task code goes here.
++ *
++ *       // At some point we want to end the real time kernel processing
++ *       // so call ...
++ *       vTaskEndScheduler ();
++ *   }
++ * }
++ *
++ * void vAFunction( void )
++ * {
++ *   // Create at least one task before starting the kernel.
++ *   xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );
++ *
++ *   // Start the real time kernel with preemption.
++ *   vTaskStartScheduler ();
++ *
++ *   // Will only get here when the vTaskCode () task has called
++ *   // vTaskEndScheduler ().  When we get here we are back to single task
++ *   // execution.
++ * }
++ * @endcode
++ *
++ * \defgroup vTaskEndScheduler vTaskEndScheduler
++ * \ingroup SchedulerControl
++ */
++void vTaskEndScheduler( void );
++
++/**
++ * task. h
++ * @code{c}
++ * void vTaskSuspendAll( void );
++ * @endcode
++ *
++ * Suspends the scheduler without disabling interrupts.  Context switches will
++ * not occur while the scheduler is suspended.
++ *
++ * After calling vTaskSuspendAll () the calling task will continue to execute
++ * without risk of being swapped out until a call to xTaskResumeAll () has been
++ * made.
++ *
++ * API functions that have the potential to cause a context switch (for example,
++ * xTaskDelayUntil(), xQueueSend(), etc.) must not be called while the scheduler
++ * is suspended.
++ *
++ * Example usage:
++ * @code{c}
++ * void vTask1( void * pvParameters )
++ * {
++ *   for( ;; )
++ *   {
++ *       // Task code goes here.
++ *
++ *       // ...
++ *
++ *       // At some point the task wants to perform a long operation during
++ *       // which it does not want to get swapped out.  It cannot use
++ *       // taskENTER_CRITICAL ()/taskEXIT_CRITICAL () as the length of the
++ *       // operation may cause interrupts to be missed - including the
++ *       // ticks.
++ *
++ *       // Prevent the real time kernel swapping out the task.
++ *       vTaskSuspendAll ();
++ *
++ *       // Perform the operation here.  There is no need to use critical
++ *       // sections as we have all the microcontroller processing time.
++ *       // During this time interrupts will still operate and the kernel
++ *       // tick count will be maintained.
++ *
++ *       // ...
++ *
++ *       // The operation is complete.  Restart the kernel.
++ *       xTaskResumeAll ();
++ *   }
++ * }
++ * @endcode
++ * \defgroup vTaskSuspendAll vTaskSuspendAll
++ * \ingroup SchedulerControl
++ */
++void vTaskSuspendAll( void );
++
++/**
++ * task. h
++ * @code{c}
++ * BaseType_t xTaskResumeAll( void );
++ * @endcode
++ *
++ * Resumes scheduler activity after it was suspended by a call to
++ * vTaskSuspendAll().
++ *
++ * xTaskResumeAll() only resumes the scheduler.  It does not unsuspend tasks
++ * that were previously suspended by a call to vTaskSuspend().
++ *
++ * @return If resuming the scheduler caused a context switch then pdTRUE is
++ *         returned, otherwise pdFALSE is returned.
++ *
++ * Example usage:
++ * @code{c}
++ * void vTask1( void * pvParameters )
++ * {
++ *   for( ;; )
++ *   {
++ *       // Task code goes here.
++ *
++ *       // ...
++ *
++ *       // At some point the task wants to perform a long operation during
++ *       // which it does not want to get swapped out.  It cannot use
++ *       // taskENTER_CRITICAL ()/taskEXIT_CRITICAL () as the length of the
++ *       // operation may cause interrupts to be missed - including the
++ *       // ticks.
++ *
++ *       // Prevent the real time kernel swapping out the task.
++ *       vTaskSuspendAll ();
++ *
++ *       // Perform the operation here.  There is no need to use critical
++ *       // sections as we have all the microcontroller processing time.
++ *       // During this time interrupts will still operate and the real
++ *       // time kernel tick count will be maintained.
++ *
++ *       // ...
++ *
++ *       // The operation is complete.  Restart the kernel.  We want to force
++ *       // a context switch - but there is no point if resuming the scheduler
++ *       // caused a context switch already.
++ *       if( !xTaskResumeAll () )
++ *       {
++ *            taskYIELD ();
++ *       }
++ *   }
++ * }
++ * @endcode
++ * \defgroup xTaskResumeAll xTaskResumeAll
++ * \ingroup SchedulerControl
++ */
++BaseType_t xTaskResumeAll( void );
++
++/*-----------------------------------------------------------
++* TASK UTILITIES
++*----------------------------------------------------------*/
++
++/**
++ * task. h
++ * @code{c}
++ * TickType_t xTaskGetTickCount( void );
++ * @endcode
++ *
++ * @return The count of ticks since vTaskStartScheduler was called.
++ *
++ * \defgroup xTaskGetTickCount xTaskGetTickCount
++ * \ingroup TaskUtils
++ */
++TickType_t xTaskGetTickCount( void );
++
++/**
++ * task. h
++ * @code{c}
++ * TickType_t xTaskGetTickCountFromISR( void );
++ * @endcode
++ *
++ * @return The count of ticks since vTaskStartScheduler was called.
++ *
++ * This is a version of xTaskGetTickCount() that is safe to be called from an
++ * ISR - provided that TickType_t is the natural word size of the
++ * microcontroller being used or interrupt nesting is either not supported or
++ * not being used.
++ *
++ * \defgroup xTaskGetTickCountFromISR xTaskGetTickCountFromISR
++ * \ingroup TaskUtils
++ */
++TickType_t xTaskGetTickCountFromISR( void );
++
++/**
++ * task. h
++ * @code{c}
++ * uint16_t uxTaskGetNumberOfTasks( void );
++ * @endcode
++ *
++ * @return The number of tasks that the real time kernel is currently managing.
++ * This includes all ready, blocked and suspended tasks.  A task that
++ * has been deleted but not yet freed by the idle task will also be
++ * included in the count.
++ *
++ * \defgroup uxTaskGetNumberOfTasks uxTaskGetNumberOfTasks
++ * \ingroup TaskUtils
++ */
++UBaseType_t uxTaskGetNumberOfTasks( void );
++
++/**
++ * task. h
++ * @code{c}
++ * char *pcTaskGetName( TaskHandle_t xTaskToQuery );
++ * @endcode
++ *
++ * @return The text (human readable) name of the task referenced by the handle
++ * xTaskToQuery.  A task can query its own name by either passing in its own
++ * handle, or by setting xTaskToQuery to NULL.
++ *
++ * \defgroup pcTaskGetName pcTaskGetName
++ * \ingroup TaskUtils
++ */
++char * pcTaskGetName( TaskHandle_t xTaskToQuery ); /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
++
++/**
++ * task. h
++ * @code{c}
++ * TaskHandle_t xTaskGetHandle( const char *pcNameToQuery );
++ * @endcode
++ *
++ * NOTE:  This function takes a relatively long time to complete and should be
++ * used sparingly.
++ *
++ * @return The handle of the task that has the human readable name pcNameToQuery.
++ * NULL is returned if no matching name is found.  INCLUDE_xTaskGetHandle
++ * must be set to 1 in FreeRTOSConfig.h for pcTaskGetHandle() to be available.
++ *
++ * \defgroup pcTaskGetHandle pcTaskGetHandle
++ * \ingroup TaskUtils
++ */
++TaskHandle_t xTaskGetHandle( const char * pcNameToQuery ); /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
++
++/**
++ * task.h
++ * @code{c}
++ * UBaseType_t uxTaskGetStackHighWaterMark( TaskHandle_t xTask );
++ * @endcode
++ *
++ * INCLUDE_uxTaskGetStackHighWaterMark must be set to 1 in FreeRTOSConfig.h for
++ * this function to be available.
++ *
++ * Returns the high water mark of the stack associated with xTask.  That is,
++ * the minimum free stack space there has been (in words, so on a 32 bit machine
++ * a value of 1 means 4 bytes) since the task started.  The smaller the returned
++ * number the closer the task has come to overflowing its stack.
++ *
++ * uxTaskGetStackHighWaterMark() and uxTaskGetStackHighWaterMark2() are the
++ * same except for their return type.  Using configSTACK_DEPTH_TYPE allows the
++ * user to determine the return type.  It gets around the problem of the value
++ * overflowing on 8-bit types without breaking backward compatibility for
++ * applications that expect an 8-bit return type.
++ *
++ * @param xTask Handle of the task associated with the stack to be checked.
++ * Set xTask to NULL to check the stack of the calling task.
++ *
++ * @return The smallest amount of free stack space there has been (in words, so
++ * actual spaces on the stack rather than bytes) since the task referenced by
++ * xTask was created.
++ */
++UBaseType_t uxTaskGetStackHighWaterMark( TaskHandle_t xTask );
++
++/**
++ * task.h
++ * @code{c}
++ * configSTACK_DEPTH_TYPE uxTaskGetStackHighWaterMark2( TaskHandle_t xTask );
++ * @endcode
++ *
++ * INCLUDE_uxTaskGetStackHighWaterMark2 must be set to 1 in FreeRTOSConfig.h for
++ * this function to be available.
++ *
++ * Returns the high water mark of the stack associated with xTask.  That is,
++ * the minimum free stack space there has been (in words, so on a 32 bit machine
++ * a value of 1 means 4 bytes) since the task started.  The smaller the returned
++ * number the closer the task has come to overflowing its stack.
++ *
++ * uxTaskGetStackHighWaterMark() and uxTaskGetStackHighWaterMark2() are the
++ * same except for their return type.  Using configSTACK_DEPTH_TYPE allows the
++ * user to determine the return type.  It gets around the problem of the value
++ * overflowing on 8-bit types without breaking backward compatibility for
++ * applications that expect an 8-bit return type.
++ *
++ * @param xTask Handle of the task associated with the stack to be checked.
++ * Set xTask to NULL to check the stack of the calling task.
++ *
++ * @return The smallest amount of free stack space there has been (in words, so
++ * actual spaces on the stack rather than bytes) since the task referenced by
++ * xTask was created.
++ */
++configSTACK_DEPTH_TYPE uxTaskGetStackHighWaterMark2( TaskHandle_t xTask );
++
++/* 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,
++ * so the following two prototypes will cause a compilation error.  This can be
++ * fixed by simply guarding against the inclusion of these two prototypes unless
++ * they are explicitly required by the configUSE_APPLICATION_TASK_TAG configuration
++ * constant. */
++#ifdef configUSE_APPLICATION_TASK_TAG
++    #if configUSE_APPLICATION_TASK_TAG == 1
++
++/**
++ * task.h
++ * @code{c}
++ * void vTaskSetApplicationTaskTag( TaskHandle_t xTask, TaskHookFunction_t pxHookFunction );
++ * @endcode
++ *
++ * Sets pxHookFunction to be the task hook function used by the task xTask.
++ * Passing xTask as NULL has the effect of setting the calling tasks hook
++ * function.
++ */
++        void vTaskSetApplicationTaskTag( TaskHandle_t xTask,
++                                         TaskHookFunction_t pxHookFunction );
++
++/**
++ * task.h
++ * @code{c}
++ * void xTaskGetApplicationTaskTag( TaskHandle_t xTask );
++ * @endcode
++ *
++ * Returns the pxHookFunction value assigned to the task xTask.  Do not
++ * call from an interrupt service routine - call
++ * xTaskGetApplicationTaskTagFromISR() instead.
++ */
++        TaskHookFunction_t xTaskGetApplicationTaskTag( TaskHandle_t xTask );
++
++/**
++ * task.h
++ * @code{c}
++ * void xTaskGetApplicationTaskTagFromISR( TaskHandle_t xTask );
++ * @endcode
++ *
++ * Returns the pxHookFunction value assigned to the task xTask.  Can
++ * be called from an interrupt service routine.
++ */
++        TaskHookFunction_t xTaskGetApplicationTaskTagFromISR( TaskHandle_t xTask );
++    #endif /* configUSE_APPLICATION_TASK_TAG ==1 */
++#endif /* ifdef configUSE_APPLICATION_TASK_TAG */
++
++/**
++ * task.h
++ * @code{c}
++ * BaseType_t xTaskCallApplicationTaskHook( TaskHandle_t xTask, void *pvParameter );
++ * @endcode
++ *
++ * Calls the hook function associated with xTask.  Passing xTask as NULL has
++ * the effect of calling the Running tasks (the calling task) hook function.
++ *
++ * pvParameter is passed to the hook function for the task to interpret as it
++ * 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 );
++
++/**
++ * 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.
++ */
++TaskHandle_t xTaskGetIdleTaskHandle( void );
++
++/**
++ * task. h
++ * @code{c}
++ * BaseType_t xTaskNotifyIndexed( TaskHandle_t xTaskToNotify, UBaseType_t uxIndexToNotify, uint32_t ulValue, eNotifyAction eAction );
++ * BaseType_t xTaskNotify( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction );
++ * @endcode
++ *
++ * See https://www.FreeRTOS.org/RTOS-task-notifications.html for details.
++ *
++ * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for these
++ * functions to be available.
++ *
++ * Sends a direct to task notification to a task, with an optional value and
++ * action.
++ *
++ * Each task has a private array of "notification values" (or 'notifications'),
++ * each of which is a 32-bit unsigned integer (uint32_t).  The constant
++ * configTASK_NOTIFICATION_ARRAY_ENTRIES sets the number of indexes in the
++ * array, and (for backward compatibility) defaults to 1 if left undefined.
++ * Prior to FreeRTOS V10.4.0 there was only one notification value per task.
++ *
++ * Events can be sent to a task using an intermediary object.  Examples of such
++ * objects are queues, semaphores, mutexes and event groups.  Task notifications
++ * are a method of sending an event directly to a task without the need for such
++ * an intermediary object.
++ *
++ * A notification sent to a task can optionally perform an action, such as
++ * update, overwrite or increment one of the task's notification values.  In
++ * that way task notifications can be used to send data to a task, or be used as
++ * light weight and fast binary or counting semaphores.
++ *
++ * A task can use xTaskNotifyWaitIndexed() or ulTaskNotifyTakeIndexed() to
++ * [optionally] block to wait for a notification to be pending.  The task does
++ * not consume any CPU time while it is in the Blocked state.
++ *
++ * A notification sent to a task will remain pending until it is cleared by the
++ * task calling xTaskNotifyWaitIndexed() or ulTaskNotifyTakeIndexed() (or their
++ * un-indexed equivalents).  If the task was already in the Blocked state to
++ * wait for a notification when the notification arrives then the task will
++ * automatically be removed from the Blocked state (unblocked) and the
++ * notification cleared.
++ *
++ * **NOTE** Each notification within the array operates independently - a task
++ * can only block on one notification within the array at a time and will not be
++ * unblocked by a notification sent to any other array index.
++ *
++ * Backward compatibility information:
++ * Prior to FreeRTOS V10.4.0 each task had a single "notification value", and
++ * all task notification API functions operated on that value. Replacing the
++ * single notification value with an array of notification values necessitated a
++ * new set of API functions that could address specific notifications within the
++ * array.  xTaskNotify() is the original API function, and remains backward
++ * compatible by always operating on the notification value at index 0 in the
++ * array. Calling xTaskNotify() is equivalent to calling xTaskNotifyIndexed()
++ * with the uxIndexToNotify parameter set to 0.
++ *
++ * @param xTaskToNotify The handle of the task being notified.  The handle to a
++ * task can be returned from the xTaskCreate() API function used to create the
++ * task, and the handle of the currently running task can be obtained by calling
++ * xTaskGetCurrentTaskHandle().
++ *
++ * @param uxIndexToNotify The index within the target task's array of
++ * notification values to which the notification is to be sent.  uxIndexToNotify
++ * must be less than configTASK_NOTIFICATION_ARRAY_ENTRIES.  xTaskNotify() does
++ * not have this parameter and always sends notifications to index 0.
++ *
++ * @param ulValue Data that can be sent with the notification.  How the data is
++ * used depends on the value of the eAction parameter.
++ *
++ * @param eAction Specifies how the notification updates the task's notification
++ * value, if at all.  Valid values for eAction are as follows:
++ *
++ * eSetBits -
++ * The target notification value is bitwise ORed with ulValue.
++ * xTaskNotifyIndexed() always returns pdPASS in this case.
++ *
++ * eIncrement -
++ * The target notification value is incremented.  ulValue is not used and
++ * xTaskNotifyIndexed() always returns pdPASS in this case.
++ *
++ * eSetValueWithOverwrite -
++ * The target notification value is set to the value of ulValue, even if the
++ * task being notified had not yet processed the previous notification at the
++ * same array index (the task already had a notification pending at that index).
++ * xTaskNotifyIndexed() always returns pdPASS in this case.
++ *
++ * eSetValueWithoutOverwrite -
++ * If the task being notified did not already have a notification pending at the
++ * same array index then the target notification value is set to ulValue and
++ * xTaskNotifyIndexed() will return pdPASS.  If the task being notified already
++ * had a notification pending at the same array index then no action is
++ * performed and pdFAIL is returned.
++ *
++ * eNoAction -
++ * The task receives a notification at the specified array index without the
++ * 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.
++ *
++ * @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 );
++#define xTaskNotify( xTaskToNotify, ulValue, eAction ) \
++    xTaskGenericNotify( ( xTaskToNotify ), ( tskDEFAULT_INDEX_TO_NOTIFY ), ( ulValue ), ( eAction ), NULL )
++#define xTaskNotifyIndexed( xTaskToNotify, uxIndexToNotify, ulValue, eAction ) \
++    xTaskGenericNotify( ( xTaskToNotify ), ( uxIndexToNotify ), ( ulValue ), ( eAction ), NULL )
++
++/**
++ * task. h
++ * @code{c}
++ * BaseType_t xTaskNotifyAndQueryIndexed( TaskHandle_t xTaskToNotify, UBaseType_t uxIndexToNotify, uint32_t ulValue, eNotifyAction eAction, uint32_t *pulPreviousNotifyValue );
++ * BaseType_t xTaskNotifyAndQuery( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, uint32_t *pulPreviousNotifyValue );
++ * @endcode
++ *
++ * See https://www.FreeRTOS.org/RTOS-task-notifications.html for details.
++ *
++ * xTaskNotifyAndQueryIndexed() performs the same operation as
++ * xTaskNotifyIndexed() with the addition that it also returns the subject
++ * task's prior notification value (the notification value at the time the
++ * function is called rather than when the function returns) in the additional
++ * pulPreviousNotifyValue parameter.
++ *
++ * xTaskNotifyAndQuery() performs the same operation as xTaskNotify() with the
++ * addition that it also returns the subject task's prior notification value
++ * (the notification value as it was at the time the function is called, rather
++ * than when the function returns) in the additional pulPreviousNotifyValue
++ * parameter.
++ *
++ * \defgroup xTaskNotifyAndQueryIndexed xTaskNotifyAndQueryIndexed
++ * \ingroup TaskNotifications
++ */
++#define xTaskNotifyAndQuery( xTaskToNotify, ulValue, eAction, pulPreviousNotifyValue ) \
++    xTaskGenericNotify( ( xTaskToNotify ), ( tskDEFAULT_INDEX_TO_NOTIFY ), ( ulValue ), ( eAction ), ( pulPreviousNotifyValue ) )
++#define xTaskNotifyAndQueryIndexed( xTaskToNotify, uxIndexToNotify, ulValue, eAction, pulPreviousNotifyValue ) \
++    xTaskGenericNotify( ( xTaskToNotify ), ( uxIndexToNotify ), ( ulValue ), ( eAction ), ( pulPreviousNotifyValue ) )
++
++/**
++ * task. h
++ * @code{c}
++ * BaseType_t xTaskNotifyIndexedFromISR( TaskHandle_t xTaskToNotify, UBaseType_t uxIndexToNotify, uint32_t ulValue, eNotifyAction eAction, BaseType_t *pxHigherPriorityTaskWoken );
++ * BaseType_t xTaskNotifyFromISR( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, BaseType_t *pxHigherPriorityTaskWoken );
++ * @endcode
++ *
++ * See https://www.FreeRTOS.org/RTOS-task-notifications.html for details.
++ *
++ * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for these
++ * functions to be available.
++ *
++ * A version of xTaskNotifyIndexed() that can be used from an interrupt service
++ * routine (ISR).
++ *
++ * Each task has a private array of "notification values" (or 'notifications'),
++ * each of which is a 32-bit unsigned integer (uint32_t).  The constant
++ * configTASK_NOTIFICATION_ARRAY_ENTRIES sets the number of indexes in the
++ * array, and (for backward compatibility) defaults to 1 if left undefined.
++ * Prior to FreeRTOS V10.4.0 there was only one notification value per task.
++ *
++ * Events can be sent to a task using an intermediary object.  Examples of such
++ * objects are queues, semaphores, mutexes and event groups.  Task notifications
++ * are a method of sending an event directly to a task without the need for such
++ * an intermediary object.
++ *
++ * A notification sent to a task can optionally perform an action, such as
++ * update, overwrite or increment one of the task's notification values.  In
++ * that way task notifications can be used to send data to a task, or be used as
++ * light weight and fast binary or counting semaphores.
++ *
++ * A task can use xTaskNotifyWaitIndexed() to [optionally] block to wait for a
++ * notification to be pending, or ulTaskNotifyTakeIndexed() to [optionally] block
++ * to wait for a notification value to have a non-zero value.  The task does
++ * not consume any CPU time while it is in the Blocked state.
++ *
++ * A notification sent to a task will remain pending until it is cleared by the
++ * task calling xTaskNotifyWaitIndexed() or ulTaskNotifyTakeIndexed() (or their
++ * un-indexed equivalents).  If the task was already in the Blocked state to
++ * wait for a notification when the notification arrives then the task will
++ * automatically be removed from the Blocked state (unblocked) and the
++ * notification cleared.
++ *
++ * **NOTE** Each notification within the array operates independently - a task
++ * can only block on one notification within the array at a time and will not be
++ * unblocked by a notification sent to any other array index.
++ *
++ * Backward compatibility information:
++ * Prior to FreeRTOS V10.4.0 each task had a single "notification value", and
++ * all task notification API functions operated on that value. Replacing the
++ * single notification value with an array of notification values necessitated a
++ * new set of API functions that could address specific notifications within the
++ * array.  xTaskNotifyFromISR() is the original API function, and remains
++ * backward compatible by always operating on the notification value at index 0
++ * within the array. Calling xTaskNotifyFromISR() is equivalent to calling
++ * xTaskNotifyIndexedFromISR() with the uxIndexToNotify parameter set to 0.
++ *
++ * @param uxIndexToNotify The index within the target task's array of
++ * notification values to which the notification is to be sent.  uxIndexToNotify
++ * must be less than configTASK_NOTIFICATION_ARRAY_ENTRIES.  xTaskNotifyFromISR()
++ * does not have this parameter and always sends notifications to index 0.
++ *
++ * @param xTaskToNotify The handle of the task being notified.  The handle to a
++ * task can be returned from the xTaskCreate() API function used to create the
++ * task, and the handle of the currently running task can be obtained by calling
++ * xTaskGetCurrentTaskHandle().
++ *
++ * @param ulValue Data that can be sent with the notification.  How the data is
++ * used depends on the value of the eAction parameter.
++ *
++ * @param eAction Specifies how the notification updates the task's notification
++ * value, if at all.  Valid values for eAction are as follows:
++ *
++ * eSetBits -
++ * The task's notification value is bitwise ORed with ulValue.  xTaskNotify()
++ * always returns pdPASS in this case.
++ *
++ * eIncrement -
++ * The task's notification value is incremented.  ulValue is not used and
++ * xTaskNotify() always returns pdPASS in this case.
++ *
++ * eSetValueWithOverwrite -
++ * The task's notification value is set to the value of ulValue, even if the
++ * task being notified had not yet processed the previous notification (the
++ * task already had a notification pending).  xTaskNotify() always returns
++ * pdPASS in this case.
++ *
++ * eSetValueWithoutOverwrite -
++ * If the task being notified did not already have a notification pending then
++ * the task's notification value is set to ulValue and xTaskNotify() will
++ * return pdPASS.  If the task being notified already had a notification
++ * pending then no action is performed and pdFAIL is returned.
++ *
++ * eNoAction -
++ * The task receives a notification without its notification value being
++ * updated.  ulValue is not used and xTaskNotify() always returns pdPASS in
++ * this case.
++ *
++ * @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
++ * unblocked task has a priority higher than the currently running task.  If
++ * xTaskNotifyFromISR() sets this value to pdTRUE then a context switch should
++ * be requested before the interrupt is exited.  How a context switch is
++ * requested from an ISR is dependent on the port - see the documentation page
++ * for the port in use.
++ *
++ * @return Dependent on the value of eAction.  See the description of the
++ * eAction parameter.
++ *
++ * \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 );
++#define xTaskNotifyFromISR( xTaskToNotify, ulValue, eAction, pxHigherPriorityTaskWoken ) \
++    xTaskGenericNotifyFromISR( ( xTaskToNotify ), ( tskDEFAULT_INDEX_TO_NOTIFY ), ( ulValue ), ( eAction ), NULL, ( pxHigherPriorityTaskWoken ) )
++#define xTaskNotifyIndexedFromISR( xTaskToNotify, uxIndexToNotify, ulValue, eAction, pxHigherPriorityTaskWoken ) \
++    xTaskGenericNotifyFromISR( ( xTaskToNotify ), ( uxIndexToNotify ), ( ulValue ), ( eAction ), NULL, ( pxHigherPriorityTaskWoken ) )
++
++/**
++ * task. h
++ * @code{c}
++ * BaseType_t xTaskNotifyAndQueryIndexedFromISR( TaskHandle_t xTaskToNotify, UBaseType_t uxIndexToNotify, uint32_t ulValue, eNotifyAction eAction, uint32_t *pulPreviousNotificationValue, BaseType_t *pxHigherPriorityTaskWoken );
++ * BaseType_t xTaskNotifyAndQueryFromISR( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, uint32_t *pulPreviousNotificationValue, BaseType_t *pxHigherPriorityTaskWoken );
++ * @endcode
++ *
++ * See https://www.FreeRTOS.org/RTOS-task-notifications.html for details.
++ *
++ * xTaskNotifyAndQueryIndexedFromISR() performs the same operation as
++ * xTaskNotifyIndexedFromISR() with the addition that it also returns the
++ * subject task's prior notification value (the notification value at the time
++ * the function is called rather than at the time the function returns) in the
++ * additional pulPreviousNotifyValue parameter.
++ *
++ * xTaskNotifyAndQueryFromISR() performs the same operation as
++ * xTaskNotifyFromISR() with the addition that it also returns the subject
++ * task's prior notification value (the notification value at the time the
++ * function is called rather than at the time the function returns) in the
++ * additional pulPreviousNotifyValue parameter.
++ *
++ * \defgroup xTaskNotifyAndQueryIndexedFromISR xTaskNotifyAndQueryIndexedFromISR
++ * \ingroup TaskNotifications
++ */
++#define xTaskNotifyAndQueryIndexedFromISR( xTaskToNotify, uxIndexToNotify, ulValue, eAction, pulPreviousNotificationValue, pxHigherPriorityTaskWoken ) \
++    xTaskGenericNotifyFromISR( ( xTaskToNotify ), ( uxIndexToNotify ), ( ulValue ), ( eAction ), ( pulPreviousNotificationValue ), ( pxHigherPriorityTaskWoken ) )
++#define xTaskNotifyAndQueryFromISR( xTaskToNotify, ulValue, eAction, pulPreviousNotificationValue, pxHigherPriorityTaskWoken ) \
++    xTaskGenericNotifyFromISR( ( xTaskToNotify ), ( tskDEFAULT_INDEX_TO_NOTIFY ), ( ulValue ), ( eAction ), ( pulPreviousNotificationValue ), ( pxHigherPriorityTaskWoken ) )
++
++/**
++ * task. h
++ * @code{c}
++ * BaseType_t xTaskNotifyWaitIndexed( UBaseType_t uxIndexToWaitOn, uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait );
++ *
++ * BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait );
++ * @endcode
++ *
++ * Waits for a direct to task notification to be pending at a given index within
++ * an array of direct to task notifications.
++ *
++ * See https://www.FreeRTOS.org/RTOS-task-notifications.html for details.
++ *
++ * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for this
++ * function to be available.
++ *
++ * Each task has a private array of "notification values" (or 'notifications'),
++ * each of which is a 32-bit unsigned integer (uint32_t).  The constant
++ * configTASK_NOTIFICATION_ARRAY_ENTRIES sets the number of indexes in the
++ * array, and (for backward compatibility) defaults to 1 if left undefined.
++ * Prior to FreeRTOS V10.4.0 there was only one notification value per task.
++ *
++ * Events can be sent to a task using an intermediary object.  Examples of such
++ * objects are queues, semaphores, mutexes and event groups.  Task notifications
++ * are a method of sending an event directly to a task without the need for such
++ * an intermediary object.
++ *
++ * A notification sent to a task can optionally perform an action, such as
++ * update, overwrite or increment one of the task's notification values.  In
++ * that way task notifications can be used to send data to a task, or be used as
++ * light weight and fast binary or counting semaphores.
++ *
++ * A notification sent to a task will remain pending until it is cleared by the
++ * task calling xTaskNotifyWaitIndexed() or ulTaskNotifyTakeIndexed() (or their
++ * un-indexed equivalents).  If the task was already in the Blocked state to
++ * wait for a notification when the notification arrives then the task will
++ * automatically be removed from the Blocked state (unblocked) and the
++ * notification cleared.
++ *
++ * A task can use xTaskNotifyWaitIndexed() to [optionally] block to wait for a
++ * notification to be pending, or ulTaskNotifyTakeIndexed() to [optionally] block
++ * to wait for a notification value to have a non-zero value.  The task does
++ * not consume any CPU time while it is in the Blocked state.
++ *
++ * **NOTE** Each notification within the array operates independently - a task
++ * can only block on one notification within the array at a time and will not be
++ * unblocked by a notification sent to any other array index.
++ *
++ * Backward compatibility information:
++ * Prior to FreeRTOS V10.4.0 each task had a single "notification value", and
++ * all task notification API functions operated on that value. Replacing the
++ * single notification value with an array of notification values necessitated a
++ * new set of API functions that could address specific notifications within the
++ * array.  xTaskNotifyWait() is the original API function, and remains backward
++ * compatible by always operating on the notification value at index 0 in the
++ * array. Calling xTaskNotifyWait() is equivalent to calling
++ * xTaskNotifyWaitIndexed() with the uxIndexToWaitOn parameter set to 0.
++ *
++ * @param uxIndexToWaitOn The index within the calling task's array of
++ * notification values on which the calling task will wait for a notification to
++ * be received.  uxIndexToWaitOn must be less than
++ * configTASK_NOTIFICATION_ARRAY_ENTRIES.  xTaskNotifyWait() does
++ * not have this parameter and always waits for notifications on index 0.
++ *
++ * @param ulBitsToClearOnEntry Bits that are set in ulBitsToClearOnEntry value
++ * 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
++ * the effect of resetting the task's notification value to 0.  Setting
++ * ulBitsToClearOnEntry to 0 will leave the task's notification value unchanged.
++ *
++ * @param ulBitsToClearOnExit If a notification is pending or received before
++ * the calling task exits the xTaskNotifyWait() function then the task's
++ * notification value (see the xTaskNotify() API function) is passed out using
++ * the pulNotificationValue parameter.  Then any bits that are set in
++ * ulBitsToClearOnExit will be cleared in the task's notification value (note
++ * *pulNotificationValue is set before any bits are cleared).  Setting
++ * ulBitsToClearOnExit to ULONG_MAX (if limits.h is included) or 0xffffffffUL
++ * (if limits.h is not included) will have the effect of resetting the task's
++ * notification value to 0 before the function exits.  Setting
++ * ulBitsToClearOnExit to 0 will leave the task's notification value unchanged
++ * when the function exits (in which case the value passed out in
++ * pulNotificationValue will match the task's notification value).
++ *
++ * @param pulNotificationValue Used to pass the task's notification value out
++ * of the function.  Note the value passed out will not be effected by the
++ * clearing of any bits caused by ulBitsToClearOnExit being non-zero.
++ *
++ * @param xTicksToWait The maximum amount of time that the task should wait in
++ * the Blocked state for a notification to be received, should a notification
++ * not already be pending when xTaskNotifyWait() was called.  The task
++ * will not consume any processing time while it is in the Blocked state.  This
++ * is specified in kernel ticks, the macro pdMS_TO_TICKS( value_in_ms ) can be
++ * used to convert a time specified in milliseconds to a time specified in
++ * ticks.
++ *
++ * @return If a notification was received (including notifications that were
++ * already pending when xTaskNotifyWait was called) then pdPASS is
++ * returned.  Otherwise pdFAIL is returned.
++ *
++ * \defgroup xTaskNotifyWaitIndexed xTaskNotifyWaitIndexed
++ * \ingroup TaskNotifications
++ */
++BaseType_t xTaskGenericNotifyWait( UBaseType_t uxIndexToWaitOn,
++                                   uint32_t ulBitsToClearOnEntry,
++                                   uint32_t ulBitsToClearOnExit,
++                                   uint32_t * pulNotificationValue,
++                                   TickType_t xTicksToWait );
++#define xTaskNotifyWait( ulBitsToClearOnEntry, ulBitsToClearOnExit, pulNotificationValue, xTicksToWait ) \
++    xTaskGenericNotifyWait( tskDEFAULT_INDEX_TO_NOTIFY, ( ulBitsToClearOnEntry ), ( ulBitsToClearOnExit ), ( pulNotificationValue ), ( xTicksToWait ) )
++#define xTaskNotifyWaitIndexed( uxIndexToWaitOn, ulBitsToClearOnEntry, ulBitsToClearOnExit, pulNotificationValue, xTicksToWait ) \
++    xTaskGenericNotifyWait( ( uxIndexToWaitOn ), ( ulBitsToClearOnEntry ), ( ulBitsToClearOnExit ), ( pulNotificationValue ), ( xTicksToWait ) )
++
++/**
++ * task. h
++ * @code{c}
++ * BaseType_t xTaskNotifyGiveIndexed( TaskHandle_t xTaskToNotify, UBaseType_t uxIndexToNotify );
++ * BaseType_t xTaskNotifyGive( TaskHandle_t xTaskToNotify );
++ * @endcode
++ *
++ * Sends a direct to task notification to a particular index in the target
++ * task's notification array in a manner similar to giving a counting semaphore.
++ *
++ * See https://www.FreeRTOS.org/RTOS-task-notifications.html for more details.
++ *
++ * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for these
++ * macros to be available.
++ *
++ * Each task has a private array of "notification values" (or 'notifications'),
++ * each of which is a 32-bit unsigned integer (uint32_t).  The constant
++ * configTASK_NOTIFICATION_ARRAY_ENTRIES sets the number of indexes in the
++ * array, and (for backward compatibility) defaults to 1 if left undefined.
++ * Prior to FreeRTOS V10.4.0 there was only one notification value per task.
++ *
++ * Events can be sent to a task using an intermediary object.  Examples of such
++ * objects are queues, semaphores, mutexes and event groups.  Task notifications
++ * are a method of sending an event directly to a task without the need for such
++ * an intermediary object.
++ *
++ * A notification sent to a task can optionally perform an action, such as
++ * update, overwrite or increment one of the task's notification values.  In
++ * that way task notifications can be used to send data to a task, or be used as
++ * light weight and fast binary or counting semaphores.
++ *
++ * xTaskNotifyGiveIndexed() is a helper macro intended for use when task
++ * notifications are used as light weight and faster binary or counting
++ * semaphore equivalents.  Actual FreeRTOS semaphores are given using the
++ * xSemaphoreGive() API function, the equivalent action that instead uses a task
++ * notification is xTaskNotifyGiveIndexed().
++ *
++ * 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
++ * xTaskNotifyWaitIndexed() API function.
++ *
++ * **NOTE** Each notification within the array operates independently - a task
++ * can only block on one notification within the array at a time and will not be
++ * unblocked by a notification sent to any other array index.
++ *
++ * Backward compatibility information:
++ * Prior to FreeRTOS V10.4.0 each task had a single "notification value", and
++ * all task notification API functions operated on that value. Replacing the
++ * single notification value with an array of notification values necessitated a
++ * new set of API functions that could address specific notifications within the
++ * array.  xTaskNotifyGive() is the original API function, and remains backward
++ * compatible by always operating on the notification value at index 0 in the
++ * array. Calling xTaskNotifyGive() is equivalent to calling
++ * xTaskNotifyGiveIndexed() with the uxIndexToNotify parameter set to 0.
++ *
++ * @param xTaskToNotify The handle of the task being notified.  The handle to a
++ * task can be returned from the xTaskCreate() API function used to create the
++ * task, and the handle of the currently running task can be obtained by calling
++ * xTaskGetCurrentTaskHandle().
++ *
++ * @param uxIndexToNotify The index within the target task's array of
++ * notification values to which the notification is to be sent.  uxIndexToNotify
++ * must be less than configTASK_NOTIFICATION_ARRAY_ENTRIES.  xTaskNotifyGive()
++ * does not have this parameter and always sends notifications to index 0.
++ *
++ * @return xTaskNotifyGive() is a macro that calls xTaskNotify() with the
++ * eAction parameter set to eIncrement - so pdPASS is always returned.
++ *
++ * \defgroup xTaskNotifyGiveIndexed xTaskNotifyGiveIndexed
++ * \ingroup TaskNotifications
++ */
++#define xTaskNotifyGive( xTaskToNotify ) \
++    xTaskGenericNotify( ( xTaskToNotify ), ( tskDEFAULT_INDEX_TO_NOTIFY ), ( 0 ), eIncrement, NULL )
++#define xTaskNotifyGiveIndexed( xTaskToNotify, uxIndexToNotify ) \
++    xTaskGenericNotify( ( xTaskToNotify ), ( uxIndexToNotify ), ( 0 ), eIncrement, NULL )
++
++/**
++ * task. h
++ * @code{c}
++ * void vTaskNotifyGiveIndexedFromISR( TaskHandle_t xTaskHandle, UBaseType_t uxIndexToNotify, BaseType_t *pxHigherPriorityTaskWoken );
++ * void vTaskNotifyGiveFromISR( TaskHandle_t xTaskHandle, BaseType_t *pxHigherPriorityTaskWoken );
++ * @endcode
++ *
++ * A version of xTaskNotifyGiveIndexed() that can be called from an interrupt
++ * service routine (ISR).
++ *
++ * See https://www.FreeRTOS.org/RTOS-task-notifications.html for more details.
++ *
++ * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for this macro
++ * to be available.
++ *
++ * Each task has a private array of "notification values" (or 'notifications'),
++ * each of which is a 32-bit unsigned integer (uint32_t).  The constant
++ * configTASK_NOTIFICATION_ARRAY_ENTRIES sets the number of indexes in the
++ * array, and (for backward compatibility) defaults to 1 if left undefined.
++ * Prior to FreeRTOS V10.4.0 there was only one notification value per task.
++ *
++ * Events can be sent to a task using an intermediary object.  Examples of such
++ * objects are queues, semaphores, mutexes and event groups.  Task notifications
++ * are a method of sending an event directly to a task without the need for such
++ * an intermediary object.
++ *
++ * A notification sent to a task can optionally perform an action, such as
++ * update, overwrite or increment one of the task's notification values.  In
++ * that way task notifications can be used to send data to a task, or be used as
++ * light weight and fast binary or counting semaphores.
++ *
++ * vTaskNotifyGiveIndexedFromISR() is intended for use when task notifications
++ * are used as light weight and faster binary or counting semaphore equivalents.
++ * Actual FreeRTOS semaphores are given from an ISR using the
++ * xSemaphoreGiveFromISR() API function, the equivalent action that instead uses
++ * a task notification is vTaskNotifyGiveIndexedFromISR().
++ *
++ * 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
++ * xTaskNotifyWaitIndexed() API function.
++ *
++ * **NOTE** Each notification within the array operates independently - a task
++ * can only block on one notification within the array at a time and will not be
++ * unblocked by a notification sent to any other array index.
++ *
++ * Backward compatibility information:
++ * Prior to FreeRTOS V10.4.0 each task had a single "notification value", and
++ * all task notification API functions operated on that value. Replacing the
++ * single notification value with an array of notification values necessitated a
++ * new set of API functions that could address specific notifications within the
++ * array.  xTaskNotifyFromISR() is the original API function, and remains
++ * backward compatible by always operating on the notification value at index 0
++ * within the array. Calling xTaskNotifyGiveFromISR() is equivalent to calling
++ * xTaskNotifyGiveIndexedFromISR() with the uxIndexToNotify parameter set to 0.
++ *
++ * @param xTaskToNotify The handle of the task being notified.  The handle to a
++ * task can be returned from the xTaskCreate() API function used to create the
++ * task, and the handle of the currently running task can be obtained by calling
++ * xTaskGetCurrentTaskHandle().
++ *
++ * @param uxIndexToNotify The index within the target task's array of
++ * notification values to which the notification is to be sent.  uxIndexToNotify
++ * must be less than configTASK_NOTIFICATION_ARRAY_ENTRIES.
++ * xTaskNotifyGiveFromISR() does not have this parameter and always sends
++ * notifications to index 0.
++ *
++ * @param pxHigherPriorityTaskWoken  vTaskNotifyGiveFromISR() 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
++ * unblocked task has a priority higher than the currently running task.  If
++ * vTaskNotifyGiveFromISR() sets this value to pdTRUE then a context switch
++ * should be requested before the interrupt is exited.  How a context switch is
++ * requested from an ISR is dependent on the port - see the documentation page
++ * for the port in use.
++ *
++ * \defgroup vTaskNotifyGiveIndexedFromISR vTaskNotifyGiveIndexedFromISR
++ * \ingroup TaskNotifications
++ */
++void vTaskGenericNotifyGiveFromISR( TaskHandle_t xTaskToNotify,
++                                    UBaseType_t uxIndexToNotify,
++                                    BaseType_t * pxHigherPriorityTaskWoken );
++#define vTaskNotifyGiveFromISR( xTaskToNotify, pxHigherPriorityTaskWoken ) \
++    vTaskGenericNotifyGiveFromISR( ( xTaskToNotify ), ( tskDEFAULT_INDEX_TO_NOTIFY ), ( pxHigherPriorityTaskWoken ) );
++#define vTaskNotifyGiveIndexedFromISR( xTaskToNotify, uxIndexToNotify, pxHigherPriorityTaskWoken ) \
++    vTaskGenericNotifyGiveFromISR( ( xTaskToNotify ), ( uxIndexToNotify ), ( pxHigherPriorityTaskWoken ) );
++
++/**
++ * task. h
++ * @code{c}
++ * uint32_t ulTaskNotifyTakeIndexed( UBaseType_t uxIndexToWaitOn, BaseType_t xClearCountOnExit, TickType_t xTicksToWait );
++ *
++ * uint32_t ulTaskNotifyTake( BaseType_t xClearCountOnExit, TickType_t xTicksToWait );
++ * @endcode
++ *
++ * Waits for a direct to task notification on a particular index in the calling
++ * task's notification array in a manner similar to taking a counting semaphore.
++ *
++ * See https://www.FreeRTOS.org/RTOS-task-notifications.html for details.
++ *
++ * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for this
++ * function to be available.
++ *
++ * Each task has a private array of "notification values" (or 'notifications'),
++ * each of which is a 32-bit unsigned integer (uint32_t).  The constant
++ * configTASK_NOTIFICATION_ARRAY_ENTRIES sets the number of indexes in the
++ * array, and (for backward compatibility) defaults to 1 if left undefined.
++ * Prior to FreeRTOS V10.4.0 there was only one notification value per task.
++ *
++ * Events can be sent to a task using an intermediary object.  Examples of such
++ * objects are queues, semaphores, mutexes and event groups.  Task notifications
++ * are a method of sending an event directly to a task without the need for such
++ * an intermediary object.
++ *
++ * A notification sent to a task can optionally perform an action, such as
++ * update, overwrite or increment one of the task's notification values.  In
++ * that way task notifications can be used to send data to a task, or be used as
++ * light weight and fast binary or counting semaphores.
++ *
++ * ulTaskNotifyTakeIndexed() is intended for use when a task notification is
++ * used as a faster and lighter weight binary or counting semaphore alternative.
++ * Actual FreeRTOS semaphores are taken using the xSemaphoreTake() API function,
++ * the equivalent action that instead uses a task notification is
++ * ulTaskNotifyTakeIndexed().
++ *
++ * When a task is using its notification value as a binary or counting semaphore
++ * other tasks should send notifications to it using the xTaskNotifyGiveIndexed()
++ * macro, or xTaskNotifyIndex() function with the eAction parameter set to
++ * eIncrement.
++ *
++ * ulTaskNotifyTakeIndexed() can either clear the task's notification value at
++ * the array index specified by the uxIndexToWaitOn parameter to zero on exit,
++ * in which case the notification value acts like a binary semaphore, or
++ * decrement the notification value on exit, in which case the notification
++ * value acts like a counting semaphore.
++ *
++ * A task can use ulTaskNotifyTakeIndexed() to [optionally] block to wait for
++ * a notification.  The task does not consume any CPU time while it is in the
++ * Blocked state.
++ *
++ * Where as xTaskNotifyWaitIndexed() will return when a notification is pending,
++ * ulTaskNotifyTakeIndexed() will return when the task's notification value is
++ * not zero.
++ *
++ * **NOTE** Each notification within the array operates independently - a task
++ * can only block on one notification within the array at a time and will not be
++ * unblocked by a notification sent to any other array index.
++ *
++ * Backward compatibility information:
++ * Prior to FreeRTOS V10.4.0 each task had a single "notification value", and
++ * all task notification API functions operated on that value. Replacing the
++ * single notification value with an array of notification values necessitated a
++ * new set of API functions that could address specific notifications within the
++ * array.  ulTaskNotifyTake() is the original API function, and remains backward
++ * compatible by always operating on the notification value at index 0 in the
++ * array. Calling ulTaskNotifyTake() is equivalent to calling
++ * ulTaskNotifyTakeIndexed() with the uxIndexToWaitOn parameter set to 0.
++ *
++ * @param uxIndexToWaitOn The index within the calling task's array of
++ * notification values on which the calling task will wait for a notification to
++ * be non-zero.  uxIndexToWaitOn must be less than
++ * configTASK_NOTIFICATION_ARRAY_ENTRIES.  xTaskNotifyTake() does
++ * not have this parameter and always waits for notifications on index 0.
++ *
++ * @param xClearCountOnExit if xClearCountOnExit is pdFALSE then the task's
++ * notification value is decremented when the function exits.  In this way the
++ * notification value acts like a counting semaphore.  If xClearCountOnExit is
++ * not pdFALSE then the task's notification value is cleared to zero when the
++ * function exits.  In this way the notification value acts like a binary
++ * semaphore.
++ *
++ * @param xTicksToWait The maximum amount of time that the task should wait in
++ * the Blocked state for the task's notification value to be greater than zero,
++ * should the count not already be greater than zero when
++ * ulTaskNotifyTake() was called.  The task will not consume any processing
++ * time while it is in the Blocked state.  This is specified in kernel ticks,
++ * the macro pdMS_TO_TICKS( value_in_ms ) can be used to convert a time
++ * specified in milliseconds to a time specified in ticks.
++ *
++ * @return The task's notification count before it is either cleared to zero or
++ * decremented (see the xClearCountOnExit parameter).
++ *
++ * \defgroup ulTaskNotifyTakeIndexed ulTaskNotifyTakeIndexed
++ * \ingroup TaskNotifications
++ */
++uint32_t ulTaskGenericNotifyTake( UBaseType_t uxIndexToWaitOn,
++                                  BaseType_t xClearCountOnExit,
++                                  TickType_t xTicksToWait );
++#define ulTaskNotifyTake( xClearCountOnExit, xTicksToWait ) \
++    ulTaskGenericNotifyTake( ( tskDEFAULT_INDEX_TO_NOTIFY ), ( xClearCountOnExit ), ( xTicksToWait ) )
++#define ulTaskNotifyTakeIndexed( uxIndexToWaitOn, xClearCountOnExit, xTicksToWait ) \
++    ulTaskGenericNotifyTake( ( uxIndexToWaitOn ), ( xClearCountOnExit ), ( xTicksToWait ) )
++
++/**
++ * task. h
++ * @code{c}
++ * BaseType_t xTaskNotifyStateClearIndexed( TaskHandle_t xTask, UBaseType_t uxIndexToCLear );
++ *
++ * BaseType_t xTaskNotifyStateClear( TaskHandle_t xTask );
++ * @endcode
++ *
++ * See https://www.FreeRTOS.org/RTOS-task-notifications.html for details.
++ *
++ * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for these
++ * functions to be available.
++ *
++ * Each task has a private array of "notification values" (or 'notifications'),
++ * each of which is a 32-bit unsigned integer (uint32_t).  The constant
++ * configTASK_NOTIFICATION_ARRAY_ENTRIES sets the number of indexes in the
++ * array, and (for backward compatibility) defaults to 1 if left undefined.
++ * Prior to FreeRTOS V10.4.0 there was only one notification value per task.
++ *
++ * If a notification is sent to an index within the array of notifications then
++ * the notification at that index is said to be 'pending' until it is read or
++ * explicitly cleared by the receiving task.  xTaskNotifyStateClearIndexed()
++ * is the function that clears a pending notification without reading the
++ * notification value.  The notification value at the same array index is not
++ * altered.  Set xTask to NULL to clear the notification state of the calling
++ * task.
++ *
++ * Backward compatibility information:
++ * Prior to FreeRTOS V10.4.0 each task had a single "notification value", and
++ * all task notification API functions operated on that value. Replacing the
++ * single notification value with an array of notification values necessitated a
++ * new set of API functions that could address specific notifications within the
++ * array.  xTaskNotifyStateClear() is the original API function, and remains
++ * backward compatible by always operating on the notification value at index 0
++ * within the array. Calling xTaskNotifyStateClear() is equivalent to calling
++ * xTaskNotifyStateClearIndexed() with the uxIndexToNotify parameter set to 0.
++ *
++ * @param xTask The handle of the RTOS task that will have a notification state
++ * cleared.  Set xTask to NULL to clear a notification state in the calling
++ * task.  To obtain a task's handle create the task using xTaskCreate() and
++ * make use of the pxCreatedTask parameter, or create the task using
++ * xTaskCreateStatic() and store the returned value, or use the task's name in
++ * a call to xTaskGetHandle().
++ *
++ * @param uxIndexToClear The index within the target task's array of
++ * notification values to act upon.  For example, setting uxIndexToClear to 1
++ * will clear the state of the notification at index 1 within the array.
++ * uxIndexToClear must be less than configTASK_NOTIFICATION_ARRAY_ENTRIES.
++ * ulTaskNotifyStateClear() does not have this parameter and always acts on the
++ * notification at index 0.
++ *
++ * @return pdTRUE if the task's notification state was set to
++ * eNotWaitingNotification, otherwise pdFALSE.
++ *
++ * \defgroup xTaskNotifyStateClearIndexed xTaskNotifyStateClearIndexed
++ * \ingroup TaskNotifications
++ */
++BaseType_t xTaskGenericNotifyStateClear( TaskHandle_t xTask,
++                                         UBaseType_t uxIndexToClear );
++#define xTaskNotifyStateClear( xTask ) \
++    xTaskGenericNotifyStateClear( ( xTask ), ( tskDEFAULT_INDEX_TO_NOTIFY ) )
++#define xTaskNotifyStateClearIndexed( xTask, uxIndexToClear ) \
++    xTaskGenericNotifyStateClear( ( xTask ), ( uxIndexToClear ) )
++
++/**
++ * task. h
++ * @code{c}
++ * uint32_t ulTaskNotifyValueClearIndexed( TaskHandle_t xTask, UBaseType_t uxIndexToClear, uint32_t ulBitsToClear );
++ *
++ * uint32_t ulTaskNotifyValueClear( TaskHandle_t xTask, uint32_t ulBitsToClear );
++ * @endcode
++ *
++ * See https://www.FreeRTOS.org/RTOS-task-notifications.html for details.
++ *
++ * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for these
++ * functions to be available.
++ *
++ * Each task has a private array of "notification values" (or 'notifications'),
++ * each of which is a 32-bit unsigned integer (uint32_t).  The constant
++ * configTASK_NOTIFICATION_ARRAY_ENTRIES sets the number of indexes in the
++ * array, and (for backward compatibility) defaults to 1 if left undefined.
++ * Prior to FreeRTOS V10.4.0 there was only one notification value per task.
++ *
++ * ulTaskNotifyValueClearIndexed() clears the bits specified by the
++ * ulBitsToClear bit mask in the notification value at array index uxIndexToClear
++ * of the task referenced by xTask.
++ *
++ * Backward compatibility information:
++ * Prior to FreeRTOS V10.4.0 each task had a single "notification value", and
++ * all task notification API functions operated on that value. Replacing the
++ * single notification value with an array of notification values necessitated a
++ * new set of API functions that could address specific notifications within the
++ * array.  ulTaskNotifyValueClear() is the original API function, and remains
++ * backward compatible by always operating on the notification value at index 0
++ * within the array. Calling ulTaskNotifyValueClear() is equivalent to calling
++ * ulTaskNotifyValueClearIndexed() with the uxIndexToClear parameter set to 0.
++ *
++ * @param xTask The handle of the RTOS task that will have bits in one of its
++ * notification values cleared. Set xTask to NULL to clear bits in a
++ * notification value of the calling task.  To obtain a task's handle create the
++ * task using xTaskCreate() and make use of the pxCreatedTask parameter, or
++ * create the task using xTaskCreateStatic() and store the returned value, or
++ * use the task's name in a call to xTaskGetHandle().
++ *
++ * @param uxIndexToClear The index within the target task's array of
++ * notification values in which to clear the bits.  uxIndexToClear
++ * must be less than configTASK_NOTIFICATION_ARRAY_ENTRIES.
++ * ulTaskNotifyValueClear() does not have this parameter and always clears bits
++ * in the notification value at index 0.
++ *
++ * @param ulBitsToClear Bit mask of the bits to clear in the notification value of
++ * xTask. Set a bit to 1 to clear the corresponding bits in the task's notification
++ * value. Set ulBitsToClear to 0xffffffff (UINT_MAX on 32-bit architectures) to clear
++ * the notification value to 0.  Set ulBitsToClear to 0 to query the task's
++ * notification value without clearing any bits.
++ *
++ *
++ * @return The value of the target task's notification value before the bits
++ * specified by ulBitsToClear were cleared.
++ * \defgroup ulTaskNotifyValueClear ulTaskNotifyValueClear
++ * \ingroup TaskNotifications
++ */
++uint32_t ulTaskGenericNotifyValueClear( TaskHandle_t xTask,
++                                        UBaseType_t uxIndexToClear,
++                                        uint32_t ulBitsToClear );
++#define ulTaskNotifyValueClear( xTask, ulBitsToClear ) \
++    ulTaskGenericNotifyValueClear( ( xTask ), ( tskDEFAULT_INDEX_TO_NOTIFY ), ( ulBitsToClear ) )
++#define ulTaskNotifyValueClearIndexed( xTask, uxIndexToClear, ulBitsToClear ) \
++    ulTaskGenericNotifyValueClear( ( xTask ), ( uxIndexToClear ), ( ulBitsToClear ) )
++
++/**
++ * task.h
++ * @code{c}
++ * void vTaskSetTimeOutState( TimeOut_t * const pxTimeOut );
++ * @endcode
++ *
++ * Capture the current time for future use with xTaskCheckForTimeOut().
++ *
++ * @param pxTimeOut Pointer to a timeout object into which the current time
++ * is to be captured.  The captured time includes the tick count and the number
++ * of times the tick count has overflowed since the system first booted.
++ * \defgroup vTaskSetTimeOutState vTaskSetTimeOutState
++ * \ingroup TaskCtrl
++ */
++void vTaskSetTimeOutState( TimeOut_t * const pxTimeOut );
++
++/**
++ * task.h
++ * @code{c}
++ * BaseType_t xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut, TickType_t * const pxTicksToWait );
++ * @endcode
++ *
++ * Determines if pxTicksToWait ticks has passed since a time was captured
++ * using a call to vTaskSetTimeOutState().  The captured time includes the tick
++ * count and the number of times the tick count has overflowed.
++ *
++ * @param pxTimeOut The time status as captured previously using
++ * vTaskSetTimeOutState. If the timeout has not yet occurred, it is updated
++ * to reflect the current time status.
++ * @param pxTicksToWait The number of ticks to check for timeout i.e. if
++ * pxTicksToWait ticks have passed since pxTimeOut was last updated (either by
++ * vTaskSetTimeOutState() or xTaskCheckForTimeOut()), the timeout has occurred.
++ * If the timeout has not occurred, pxTicksToWait is updated to reflect the
++ * number of remaining ticks.
++ *
++ * @return If timeout has occurred, pdTRUE is returned. Otherwise pdFALSE is
++ * returned and pxTicksToWait is updated to reflect the number of remaining
++ * ticks.
++ *
++ * @see https://www.FreeRTOS.org/xTaskCheckForTimeOut.html
++ *
++ * Example Usage:
++ * @code{c}
++ *  // Driver library function used to receive uxWantedBytes from an Rx buffer
++ *  // that is filled by a UART interrupt. If there are not enough bytes in the
++ *  // Rx buffer then the task enters the Blocked state until it is notified that
++ *  // more data has been placed into the buffer. If there is still not enough
++ *  // data then the task re-enters the Blocked state, and xTaskCheckForTimeOut()
++ *  // is used to re-calculate the Block time to ensure the total amount of time
++ *  // spent in the Blocked state does not exceed MAX_TIME_TO_WAIT. This
++ *  // continues until either the buffer contains at least uxWantedBytes bytes,
++ *  // or the total amount of time spent in the Blocked state reaches
++ *  // MAX_TIME_TO_WAIT - at which point the task reads however many bytes are
++ *  // available up to a maximum of uxWantedBytes.
++ *
++ *  size_t xUART_Receive( uint8_t *pucBuffer, size_t uxWantedBytes )
++ *  {
++ *  size_t uxReceived = 0;
++ *  TickType_t xTicksToWait = MAX_TIME_TO_WAIT;
++ *  TimeOut_t xTimeOut;
++ *
++ *      // Initialize xTimeOut.  This records the time at which this function
++ *      // was entered.
++ *      vTaskSetTimeOutState( &xTimeOut );
++ *
++ *      // Loop until the buffer contains the wanted number of bytes, or a
++ *      // timeout occurs.
++ *      while( UART_bytes_in_rx_buffer( pxUARTInstance ) < uxWantedBytes )
++ *      {
++ *          // The buffer didn't contain enough data so this task is going to
++ *          // enter the Blocked state. Adjusting xTicksToWait to account for
++ *          // any time that has been spent in the Blocked state within this
++ *          // function so far to ensure the total amount of time spent in the
++ *          // Blocked state does not exceed MAX_TIME_TO_WAIT.
++ *          if( xTaskCheckForTimeOut( &xTimeOut, &xTicksToWait ) != pdFALSE )
++ *          {
++ *              //Timed out before the wanted number of bytes were available,
++ *              // exit the loop.
++ *              break;
++ *          }
++ *
++ *          // Wait for a maximum of xTicksToWait ticks to be notified that the
++ *          // receive interrupt has placed more data into the buffer.
++ *          ulTaskNotifyTake( pdTRUE, xTicksToWait );
++ *      }
++ *
++ *      // Attempt to read uxWantedBytes from the receive buffer into pucBuffer.
++ *      // The actual number of bytes read (which might be less than
++ *      // uxWantedBytes) is returned.
++ *      uxReceived = UART_read_from_receive_buffer( pxUARTInstance,
++ *                                                  pucBuffer,
++ *                                                  uxWantedBytes );
++ *
++ *      return uxReceived;
++ *  }
++ * @endcode
++ * \defgroup xTaskCheckForTimeOut xTaskCheckForTimeOut
++ * \ingroup TaskCtrl
++ */
++BaseType_t xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut,
++                                 TickType_t * const pxTicksToWait );
++
++/*-----------------------------------------------------------
++* SCHEDULER INTERNALS AVAILABLE FOR PORTING PURPOSES
++*----------------------------------------------------------*/
++
++/*
++ * Return the handle of the calling task.
++ */
++TaskHandle_t xTaskGetCurrentTaskHandle( void );
++
++/*
++ * Returns the scheduler state as taskSCHEDULER_RUNNING,
++ * taskSCHEDULER_NOT_STARTED or taskSCHEDULER_SUSPENDED.
++ */
++BaseType_t xTaskGetSchedulerState( void );
++
++/* ESP32 */
++BaseType_t xTaskGetAffinity( TaskHandle_t xTask );
++TaskHandle_t xTaskGetCurrentTaskHandleForCPU( BaseType_t cpuid );
++TaskHandle_t xTaskGetIdleTaskHandleForCPU( UBaseType_t cpuid );
++/* Unimplemented */
++#if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS > 0 )
++void vTaskSetThreadLocalStoragePointer( TaskHandle_t xTaskToSet,
++                                            BaseType_t xIndex,
++                                            void * pvValue );
++void * pvTaskGetThreadLocalStoragePointer( TaskHandle_t xTaskToQuery,
++                                               BaseType_t xIndex );
++#if ( configTHREAD_LOCAL_STORAGE_DELETE_CALLBACKS )
++typedef void (*TlsDeleteCallbackFunction_t)( int, void * );
++void vTaskSetThreadLocalStoragePointerAndDelCallback( TaskHandle_t xTaskToSet, BaseType_t xIndex, void *pvValue, TlsDeleteCallbackFunction_t pvDelCallback);
++#endif
++#endif
++
++/* *INDENT-OFF* */
++#ifdef __cplusplus
++    }
++#endif
++/* *INDENT-ON* */
++#endif /* INC_TASK_H */
+diff --git a/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/freertos/timers.h b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/freertos/timers.h
+new file mode 100644
+index 0000000000..c5d1acf4d4
+--- /dev/null
++++ b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/include/freertos/timers.h
+@@ -0,0 +1,1185 @@
++/*
++ * FreeRTOS Kernel V10.4.6
++ * 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 TIMERS_H
++#define TIMERS_H
++
++#ifndef INC_FREERTOS_H
++    #error "include FreeRTOS.h must appear in source files before include timers.h"
++#endif
++
++#include "task.h"
++
++/* *INDENT-OFF* */
++#ifdef __cplusplus
++    extern "C" {
++#endif
++/* *INDENT-ON* */
++
++/*-----------------------------------------------------------
++* MACROS AND DEFINITIONS
++*----------------------------------------------------------*/
++
++/* IDs for commands that can be sent/received on the timer queue.  These are to
++ * be used solely through the macros that make up the public software timer API,
++ * as defined below.  The commands that are sent from interrupts must use the
++ * highest numbers as tmrFIRST_FROM_ISR_COMMAND is used to determine if the task
++ * or interrupt version of the queue send function should be used. */
++#define tmrCOMMAND_EXECUTE_CALLBACK_FROM_ISR    ( ( BaseType_t ) -2 )
++#define tmrCOMMAND_EXECUTE_CALLBACK             ( ( BaseType_t ) -1 )
++#define tmrCOMMAND_START_DONT_TRACE             ( ( BaseType_t ) 0 )
++#define tmrCOMMAND_START                        ( ( BaseType_t ) 1 )
++#define tmrCOMMAND_RESET                        ( ( BaseType_t ) 2 )
++#define tmrCOMMAND_STOP                         ( ( BaseType_t ) 3 )
++#define tmrCOMMAND_CHANGE_PERIOD                ( ( BaseType_t ) 4 )
++#define tmrCOMMAND_DELETE                       ( ( BaseType_t ) 5 )
++
++#define tmrFIRST_FROM_ISR_COMMAND               ( ( BaseType_t ) 6 )
++#define tmrCOMMAND_START_FROM_ISR               ( ( BaseType_t ) 6 )
++#define tmrCOMMAND_RESET_FROM_ISR               ( ( BaseType_t ) 7 )
++#define tmrCOMMAND_STOP_FROM_ISR                ( ( BaseType_t ) 8 )
++#define tmrCOMMAND_CHANGE_PERIOD_FROM_ISR       ( ( BaseType_t ) 9 )
++
++/**
++ * Type by which software timers are referenced.  For example, a call to
++ * xTimerCreate() returns an TimerHandle_t variable that can then be used to
++ * reference the subject timer in calls to other software timer API functions
++ * (for example, xTimerStart(), xTimerReset(), etc.).
++ */
++struct tmrTimerControl; /* The old naming convention is used to prevent breaking kernel aware debuggers. */
++typedef struct tmrTimerControl * TimerHandle_t;
++
++/*
++ * Defines the prototype to which timer callback functions must conform.
++ */
++typedef void (* TimerCallbackFunction_t)( TimerHandle_t xTimer );
++
++/**
++ * TimerHandle_t xTimerCreate(  const char * const pcTimerName,
++ *                              TickType_t xTimerPeriodInTicks,
++ *                              UBaseType_t uxAutoReload,
++ *                              void * pvTimerID,
++ *                              TimerCallbackFunction_t pxCallbackFunction );
++ *
++ * Creates a new software timer instance, and returns a handle by which the
++ * created software timer can be referenced.
++ *
++ * Internally, within the FreeRTOS implementation, software timers use a block
++ * of memory, in which the timer data structure is stored.  If a software timer
++ * is created using xTimerCreate() then the required memory is automatically
++ * dynamically allocated inside the xTimerCreate() function.  (see
++ * https://www.FreeRTOS.org/a00111.html).  If a software timer is created using
++ * xTimerCreateStatic() then the application writer must provide the memory that
++ * will get used by the software timer.  xTimerCreateStatic() therefore allows a
++ * software timer to be created without using any dynamic memory allocation.
++ *
++ * Timers are created in the dormant state.  The xTimerStart(), xTimerReset(),
++ * xTimerStartFromISR(), xTimerResetFromISR(), xTimerChangePeriod() and
++ * xTimerChangePeriodFromISR() API functions can all be used to transition a
++ * timer into the active state.
++ *
++ * @param pcTimerName A text name that is assigned to the timer.  This is done
++ * purely to assist debugging.  The kernel itself only ever references a timer
++ * by its handle, and never by its name.
++ *
++ * @param xTimerPeriodInTicks The timer period.  The time is defined in tick
++ * periods so the constant portTICK_PERIOD_MS can be used to convert a time that
++ * has been specified in milliseconds.  For example, if the timer must expire
++ * after 100 ticks, then xTimerPeriodInTicks should be set to 100.
++ * Alternatively, if the timer must expire after 500ms, then xPeriod can be set
++ * to ( 500 / portTICK_PERIOD_MS ) provided configTICK_RATE_HZ is less than or
++ * equal to 1000.  Time timer period must be greater than 0.
++ *
++ * @param uxAutoReload If uxAutoReload is set to pdTRUE then the timer will
++ * expire repeatedly with a frequency set by the xTimerPeriodInTicks parameter.
++ * If uxAutoReload is set to pdFALSE then the timer will be a one-shot timer and
++ * enter the dormant state after it expires.
++ *
++ * @param pvTimerID An identifier that is assigned to the timer being created.
++ * Typically this would be used in the timer callback function to identify which
++ * timer expired when the same callback function is assigned to more than one
++ * timer.
++ *
++ * @param pxCallbackFunction The function to call when the timer expires.
++ * Callback functions must have the prototype defined by TimerCallbackFunction_t,
++ * which is "void vCallbackFunction( TimerHandle_t xTimer );".
++ *
++ * @return If the timer is successfully created then a handle to the newly
++ * created timer is returned.  If the timer cannot be created because there is
++ * insufficient FreeRTOS heap remaining to allocate the timer
++ * structures then NULL is returned.
++ *
++ * Example usage:
++ * @verbatim
++ * #define NUM_TIMERS 5
++ *
++ * // An array to hold handles to the created timers.
++ * TimerHandle_t xTimers[ NUM_TIMERS ];
++ *
++ * // An array to hold a count of the number of times each timer expires.
++ * int32_t lExpireCounters[ NUM_TIMERS ] = { 0 };
++ *
++ * // Define a callback function that will be used by multiple timer instances.
++ * // The callback function does nothing but count the number of times the
++ * // associated timer expires, and stop the timer once the timer has expired
++ * // 10 times.
++ * void vTimerCallback( TimerHandle_t pxTimer )
++ * {
++ * int32_t lArrayIndex;
++ * const int32_t xMaxExpiryCountBeforeStopping = 10;
++ *
++ *     // Optionally do something if the pxTimer parameter is NULL.
++ *     configASSERT( pxTimer );
++ *
++ *     // Which timer expired?
++ *     lArrayIndex = ( int32_t ) pvTimerGetTimerID( pxTimer );
++ *
++ *     // Increment the number of times that pxTimer has expired.
++ *     lExpireCounters[ lArrayIndex ] += 1;
++ *
++ *     // If the timer has expired 10 times then stop it from running.
++ *     if( lExpireCounters[ lArrayIndex ] == xMaxExpiryCountBeforeStopping )
++ *     {
++ *         // Do not use a block time if calling a timer API function from a
++ *         // timer callback function, as doing so could cause a deadlock!
++ *         xTimerStop( pxTimer, 0 );
++ *     }
++ * }
++ *
++ * void main( void )
++ * {
++ * int32_t x;
++ *
++ *     // Create then start some timers.  Starting the timers before the scheduler
++ *     // has been started means the timers will start running immediately that
++ *     // the scheduler starts.
++ *     for( x = 0; x < NUM_TIMERS; x++ )
++ *     {
++ *         xTimers[ x ] = xTimerCreate(    "Timer",       // Just a text name, not used by the kernel.
++ *                                         ( 100 * x ),   // The timer period in ticks.
++ *                                         pdTRUE,        // The timers will auto-reload themselves when they expire.
++ *                                         ( void * ) x,  // Assign each timer a unique id equal to its array index.
++ *                                         vTimerCallback // Each timer calls the same callback when it expires.
++ *                                     );
++ *
++ *         if( xTimers[ x ] == NULL )
++ *         {
++ *             // The timer was not created.
++ *         }
++ *         else
++ *         {
++ *             // Start the timer.  No block time is specified, and even if one was
++ *             // it would be ignored because the scheduler has not yet been
++ *             // started.
++ *             if( xTimerStart( xTimers[ x ], 0 ) != pdPASS )
++ *             {
++ *                 // The timer could not be set into the Active state.
++ *             }
++ *         }
++ *     }
++ *
++ *     // ...
++ *     // Create tasks here.
++ *     // ...
++ *
++ *     // Starting the scheduler will start the timers running as they have already
++ *     // been set into the active state.
++ *     vTaskStartScheduler();
++ *
++ *     // Should not reach here.
++ *     for( ;; );
++ * }
++ * @endverbatim
++ */
++#if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
++    TimerHandle_t xTimerCreate( const char * const pcTimerName, /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
++                                const TickType_t xTimerPeriodInTicks,
++                                const UBaseType_t uxAutoReload,
++                                void * const pvTimerID,
++                                TimerCallbackFunction_t pxCallbackFunction );
++#endif
++
++/**
++ * TimerHandle_t xTimerCreateStatic(const char * const pcTimerName,
++ *                                  TickType_t xTimerPeriodInTicks,
++ *                                  UBaseType_t uxAutoReload,
++ *                                  void * pvTimerID,
++ *                                  TimerCallbackFunction_t pxCallbackFunction,
++ *                                  StaticTimer_t *pxTimerBuffer );
++ *
++ * Creates a new software timer instance, and returns a handle by which the
++ * created software timer can be referenced.
++ *
++ * Internally, within the FreeRTOS implementation, software timers use a block
++ * of memory, in which the timer data structure is stored.  If a software timer
++ * is created using xTimerCreate() then the required memory is automatically
++ * dynamically allocated inside the xTimerCreate() function.  (see
++ * https://www.FreeRTOS.org/a00111.html).  If a software timer is created using
++ * xTimerCreateStatic() then the application writer must provide the memory that
++ * will get used by the software timer.  xTimerCreateStatic() therefore allows a
++ * software timer to be created without using any dynamic memory allocation.
++ *
++ * Timers are created in the dormant state.  The xTimerStart(), xTimerReset(),
++ * xTimerStartFromISR(), xTimerResetFromISR(), xTimerChangePeriod() and
++ * xTimerChangePeriodFromISR() API functions can all be used to transition a
++ * timer into the active state.
++ *
++ * @param pcTimerName A text name that is assigned to the timer.  This is done
++ * purely to assist debugging.  The kernel itself only ever references a timer
++ * by its handle, and never by its name.
++ *
++ * @param xTimerPeriodInTicks The timer period.  The time is defined in tick
++ * periods so the constant portTICK_PERIOD_MS can be used to convert a time that
++ * has been specified in milliseconds.  For example, if the timer must expire
++ * after 100 ticks, then xTimerPeriodInTicks should be set to 100.
++ * Alternatively, if the timer must expire after 500ms, then xPeriod can be set
++ * to ( 500 / portTICK_PERIOD_MS ) provided configTICK_RATE_HZ is less than or
++ * equal to 1000.  The timer period must be greater than 0.
++ *
++ * @param uxAutoReload If uxAutoReload is set to pdTRUE then the timer will
++ * expire repeatedly with a frequency set by the xTimerPeriodInTicks parameter.
++ * If uxAutoReload is set to pdFALSE then the timer will be a one-shot timer and
++ * enter the dormant state after it expires.
++ *
++ * @param pvTimerID An identifier that is assigned to the timer being created.
++ * Typically this would be used in the timer callback function to identify which
++ * timer expired when the same callback function is assigned to more than one
++ * timer.
++ *
++ * @param pxCallbackFunction The function to call when the timer expires.
++ * Callback functions must have the prototype defined by TimerCallbackFunction_t,
++ * which is "void vCallbackFunction( TimerHandle_t xTimer );".
++ *
++ * @param pxTimerBuffer Must point to a variable of type StaticTimer_t, which
++ * will be then be used to hold the software timer's data structures, removing
++ * the need for the memory to be allocated dynamically.
++ *
++ * @return If the timer is created then a handle to the created timer is
++ * returned.  If pxTimerBuffer was NULL then NULL is returned.
++ *
++ * Example usage:
++ * @verbatim
++ *
++ * // The buffer used to hold the software timer's data structure.
++ * static StaticTimer_t xTimerBuffer;
++ *
++ * // A variable that will be incremented by the software timer's callback
++ * // function.
++ * UBaseType_t uxVariableToIncrement = 0;
++ *
++ * // A software timer callback function that increments a variable passed to
++ * // it when the software timer was created.  After the 5th increment the
++ * // callback function stops the software timer.
++ * static void prvTimerCallback( TimerHandle_t xExpiredTimer )
++ * {
++ * UBaseType_t *puxVariableToIncrement;
++ * BaseType_t xReturned;
++ *
++ *     // Obtain the address of the variable to increment from the timer ID.
++ *     puxVariableToIncrement = ( UBaseType_t * ) pvTimerGetTimerID( xExpiredTimer );
++ *
++ *     // Increment the variable to show the timer callback has executed.
++ *     ( *puxVariableToIncrement )++;
++ *
++ *     // If this callback has executed the required number of times, stop the
++ *     // timer.
++ *     if( *puxVariableToIncrement == 5 )
++ *     {
++ *         // This is called from a timer callback so must not block.
++ *         xTimerStop( xExpiredTimer, staticDONT_BLOCK );
++ *     }
++ * }
++ *
++ *
++ * void main( void )
++ * {
++ *     // Create the software time.  xTimerCreateStatic() has an extra parameter
++ *     // than the normal xTimerCreate() API function.  The parameter is a pointer
++ *     // to the StaticTimer_t structure that will hold the software timer
++ *     // structure.  If the parameter is passed as NULL then the structure will be
++ *     // allocated dynamically, just as if xTimerCreate() had been called.
++ *     xTimer = xTimerCreateStatic( "T1",             // Text name for the task.  Helps debugging only.  Not used by FreeRTOS.
++ *                                  xTimerPeriod,     // The period of the timer in ticks.
++ *                                  pdTRUE,           // This is an auto-reload timer.
++ *                                  ( void * ) &uxVariableToIncrement,    // A variable incremented by the software timer's callback function
++ *                                  prvTimerCallback, // The function to execute when the timer expires.
++ *                                  &xTimerBuffer );  // The buffer that will hold the software timer structure.
++ *
++ *     // The scheduler has not started yet so a block time is not used.
++ *     xReturned = xTimerStart( xTimer, 0 );
++ *
++ *     // ...
++ *     // Create tasks here.
++ *     // ...
++ *
++ *     // Starting the scheduler will start the timers running as they have already
++ *     // been set into the active state.
++ *     vTaskStartScheduler();
++ *
++ *     // Should not reach here.
++ *     for( ;; );
++ * }
++ * @endverbatim
++ */
++#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
++    TimerHandle_t xTimerCreateStatic( const char * const pcTimerName, /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
++                                      const TickType_t xTimerPeriodInTicks,
++                                      const UBaseType_t uxAutoReload,
++                                      void * const pvTimerID,
++                                      TimerCallbackFunction_t pxCallbackFunction,
++                                      StaticTimer_t * pxTimerBuffer );
++#endif /* configSUPPORT_STATIC_ALLOCATION */
++
++/**
++ * void *pvTimerGetTimerID( TimerHandle_t xTimer );
++ *
++ * Returns the ID assigned to the timer.
++ *
++ * IDs are assigned to timers using the pvTimerID parameter of the call to
++ * xTimerCreated() that was used to create the timer, and by calling the
++ * vTimerSetTimerID() API function.
++ *
++ * If the same callback function is assigned to multiple timers then the timer
++ * ID can be used as time specific (timer local) storage.
++ *
++ * @param xTimer The timer being queried.
++ *
++ * @return The ID assigned to the timer being queried.
++ *
++ * Example usage:
++ *
++ * See the xTimerCreate() API function example usage scenario.
++ */
++void * pvTimerGetTimerID( const TimerHandle_t xTimer );
++
++/**
++ * void vTimerSetTimerID( TimerHandle_t xTimer, void *pvNewID );
++ *
++ * Sets the ID assigned to the timer.
++ *
++ * IDs are assigned to timers using the pvTimerID parameter of the call to
++ * xTimerCreated() that was used to create the timer.
++ *
++ * If the same callback function is assigned to multiple timers then the timer
++ * ID can be used as time specific (timer local) storage.
++ *
++ * @param xTimer The timer being updated.
++ *
++ * @param pvNewID The ID to assign to the timer.
++ *
++ * Example usage:
++ *
++ * See the xTimerCreate() API function example usage scenario.
++ */
++void vTimerSetTimerID( TimerHandle_t xTimer,
++                       void * pvNewID );
++
++/**
++ * BaseType_t xTimerIsTimerActive( TimerHandle_t xTimer );
++ *
++ * Queries a timer to see if it is active or dormant.
++ *
++ * A timer will be dormant if:
++ *     1) It has been created but not started, or
++ *     2) It is an expired one-shot timer that has not been restarted.
++ *
++ * Timers are created in the dormant state.  The xTimerStart(), xTimerReset(),
++ * xTimerStartFromISR(), xTimerResetFromISR(), xTimerChangePeriod() and
++ * xTimerChangePeriodFromISR() API functions can all be used to transition a timer into the
++ * active state.
++ *
++ * @param xTimer The timer being queried.
++ *
++ * @return pdFALSE will be returned if the timer is dormant.  A value other than
++ * pdFALSE will be returned if the timer is active.
++ *
++ * Example usage:
++ * @verbatim
++ * // This function assumes xTimer has already been created.
++ * void vAFunction( TimerHandle_t xTimer )
++ * {
++ *     if( xTimerIsTimerActive( xTimer ) != pdFALSE ) // or more simply and equivalently "if( xTimerIsTimerActive( xTimer ) )"
++ *     {
++ *         // xTimer is active, do something.
++ *     }
++ *     else
++ *     {
++ *         // xTimer is not active, do something else.
++ *     }
++ * }
++ * @endverbatim
++ */
++BaseType_t xTimerIsTimerActive( TimerHandle_t xTimer );
++
++/**
++ * TaskHandle_t xTimerGetTimerDaemonTaskHandle( void );
++ *
++ * Simply returns the handle of the timer service/daemon task.  It it not valid
++ * to call xTimerGetTimerDaemonTaskHandle() before the scheduler has been started.
++ */
++TaskHandle_t xTimerGetTimerDaemonTaskHandle( void );
++
++/**
++ * BaseType_t xTimerStart( TimerHandle_t xTimer, TickType_t xTicksToWait );
++ *
++ * Timer functionality is provided by a timer service/daemon task.  Many of the
++ * public FreeRTOS timer API functions send commands to the timer service task
++ * through a queue called the timer command queue.  The timer command queue is
++ * private to the kernel itself and is not directly accessible to application
++ * code.  The length of the timer command queue is set by the
++ * configTIMER_QUEUE_LENGTH configuration constant.
++ *
++ * xTimerStart() starts a timer that was previously created using the
++ * xTimerCreate() API function.  If the timer had already been started and was
++ * already in the active state, then xTimerStart() has equivalent functionality
++ * to the xTimerReset() API function.
++ *
++ * Starting a timer ensures the timer is in the active state.  If the timer
++ * is not stopped, deleted, or reset in the mean time, the callback function
++ * associated with the timer will get called 'n' ticks after xTimerStart() was
++ * called, where 'n' is the timers defined period.
++ *
++ * It is valid to call xTimerStart() before the scheduler has been started, but
++ * when this is done the timer will not actually start until the scheduler is
++ * started, and the timers expiry time will be relative to when the scheduler is
++ * started, not relative to when xTimerStart() was called.
++ *
++ * The configUSE_TIMERS configuration constant must be set to 1 for xTimerStart()
++ * to be available.
++ *
++ * @param xTimer The handle of the timer being started/restarted.
++ *
++ * @param xTicksToWait Specifies the time, in ticks, that the calling task should
++ * be held in the Blocked state to wait for the start command to be successfully
++ * sent to the timer command queue, should the queue already be full when
++ * xTimerStart() was called.  xTicksToWait is ignored if xTimerStart() is called
++ * before the scheduler is started.
++ *
++ * @return pdFAIL will be returned if the start command could not be sent to
++ * the timer command queue even after xTicksToWait ticks had passed.  pdPASS will
++ * be returned if the command was successfully sent to the timer command queue.
++ * When the command is actually processed will depend on the priority of the
++ * timer service/daemon task relative to other tasks in the system, although the
++ * timers expiry time is relative to when xTimerStart() is actually called.  The
++ * timer service/daemon task priority is set by the configTIMER_TASK_PRIORITY
++ * configuration constant.
++ *
++ * Example usage:
++ *
++ * See the xTimerCreate() API function example usage scenario.
++ *
++ */
++#define xTimerStart( xTimer, xTicksToWait ) \
++    xTimerGenericCommand( ( xTimer ), tmrCOMMAND_START, ( xTaskGetTickCount() ), NULL, ( xTicksToWait ) )
++
++/**
++ * BaseType_t xTimerStop( TimerHandle_t xTimer, TickType_t xTicksToWait );
++ *
++ * Timer functionality is provided by a timer service/daemon task.  Many of the
++ * public FreeRTOS timer API functions send commands to the timer service task
++ * through a queue called the timer command queue.  The timer command queue is
++ * private to the kernel itself and is not directly accessible to application
++ * code.  The length of the timer command queue is set by the
++ * configTIMER_QUEUE_LENGTH configuration constant.
++ *
++ * xTimerStop() stops a timer that was previously started using either of the
++ * The xTimerStart(), xTimerReset(), xTimerStartFromISR(), xTimerResetFromISR(),
++ * xTimerChangePeriod() or xTimerChangePeriodFromISR() API functions.
++ *
++ * Stopping a timer ensures the timer is not in the active state.
++ *
++ * The configUSE_TIMERS configuration constant must be set to 1 for xTimerStop()
++ * to be available.
++ *
++ * @param xTimer The handle of the timer being stopped.
++ *
++ * @param xTicksToWait Specifies the time, in ticks, that the calling task should
++ * be held in the Blocked state to wait for the stop command to be successfully
++ * sent to the timer command queue, should the queue already be full when
++ * xTimerStop() was called.  xTicksToWait is ignored if xTimerStop() is called
++ * before the scheduler is started.
++ *
++ * @return pdFAIL will be returned if the stop command could not be sent to
++ * the timer command queue even after xTicksToWait ticks had passed.  pdPASS will
++ * be returned if the command was successfully sent to the timer command queue.
++ * When the command is actually processed will depend on the priority of the
++ * timer service/daemon task relative to other tasks in the system.  The timer
++ * service/daemon task priority is set by the configTIMER_TASK_PRIORITY
++ * configuration constant.
++ *
++ * Example usage:
++ *
++ * See the xTimerCreate() API function example usage scenario.
++ *
++ */
++#define xTimerStop( xTimer, xTicksToWait ) \
++    xTimerGenericCommand( ( xTimer ), tmrCOMMAND_STOP, 0U, NULL, ( xTicksToWait ) )
++
++/**
++ * BaseType_t xTimerChangePeriod(   TimerHandle_t xTimer,
++ *                                  TickType_t xNewPeriod,
++ *                                  TickType_t xTicksToWait );
++ *
++ * Timer functionality is provided by a timer service/daemon task.  Many of the
++ * public FreeRTOS timer API functions send commands to the timer service task
++ * through a queue called the timer command queue.  The timer command queue is
++ * private to the kernel itself and is not directly accessible to application
++ * code.  The length of the timer command queue is set by the
++ * configTIMER_QUEUE_LENGTH configuration constant.
++ *
++ * xTimerChangePeriod() changes the period of a timer that was previously
++ * created using the xTimerCreate() API function.
++ *
++ * xTimerChangePeriod() can be called to change the period of an active or
++ * dormant state timer.
++ *
++ * The configUSE_TIMERS configuration constant must be set to 1 for
++ * xTimerChangePeriod() to be available.
++ *
++ * @param xTimer The handle of the timer that is having its period changed.
++ *
++ * @param xNewPeriod The new period for xTimer. Timer periods are specified in
++ * tick periods, so the constant portTICK_PERIOD_MS can be used to convert a time
++ * that has been specified in milliseconds.  For example, if the timer must
++ * expire after 100 ticks, then xNewPeriod should be set to 100.  Alternatively,
++ * if the timer must expire after 500ms, then xNewPeriod can be set to
++ * ( 500 / portTICK_PERIOD_MS ) provided configTICK_RATE_HZ is less than
++ * or equal to 1000.
++ *
++ * @param xTicksToWait Specifies the time, in ticks, that the calling task should
++ * be held in the Blocked state to wait for the change period command to be
++ * successfully sent to the timer command queue, should the queue already be
++ * full when xTimerChangePeriod() was called.  xTicksToWait is ignored if
++ * xTimerChangePeriod() is called before the scheduler is started.
++ *
++ * @return pdFAIL will be returned if the change period command could not be
++ * sent to the timer command queue even after xTicksToWait ticks had passed.
++ * pdPASS will be returned if the command was successfully sent to the timer
++ * command queue.  When the command is actually processed will depend on the
++ * priority of the timer service/daemon task relative to other tasks in the
++ * system.  The timer service/daemon task priority is set by the
++ * configTIMER_TASK_PRIORITY configuration constant.
++ *
++ * Example usage:
++ * @verbatim
++ * // This function assumes xTimer has already been created.  If the timer
++ * // referenced by xTimer is already active when it is called, then the timer
++ * // is deleted.  If the timer referenced by xTimer is not active when it is
++ * // called, then the period of the timer is set to 500ms and the timer is
++ * // started.
++ * void vAFunction( TimerHandle_t xTimer )
++ * {
++ *     if( xTimerIsTimerActive( xTimer ) != pdFALSE ) // or more simply and equivalently "if( xTimerIsTimerActive( xTimer ) )"
++ *     {
++ *         // xTimer is already active - delete it.
++ *         xTimerDelete( xTimer );
++ *     }
++ *     else
++ *     {
++ *         // xTimer is not active, change its period to 500ms.  This will also
++ *         // cause the timer to start.  Block for a maximum of 100 ticks if the
++ *         // change period command cannot immediately be sent to the timer
++ *         // command queue.
++ *         if( xTimerChangePeriod( xTimer, 500 / portTICK_PERIOD_MS, 100 ) == pdPASS )
++ *         {
++ *             // The command was successfully sent.
++ *         }
++ *         else
++ *         {
++ *             // The command could not be sent, even after waiting for 100 ticks
++ *             // to pass.  Take appropriate action here.
++ *         }
++ *     }
++ * }
++ * @endverbatim
++ */
++#define xTimerChangePeriod( xTimer, xNewPeriod, xTicksToWait ) \
++    xTimerGenericCommand( ( xTimer ), tmrCOMMAND_CHANGE_PERIOD, ( xNewPeriod ), NULL, ( xTicksToWait ) )
++
++/**
++ * BaseType_t xTimerDelete( TimerHandle_t xTimer, TickType_t xTicksToWait );
++ *
++ * Timer functionality is provided by a timer service/daemon task.  Many of the
++ * public FreeRTOS timer API functions send commands to the timer service task
++ * through a queue called the timer command queue.  The timer command queue is
++ * private to the kernel itself and is not directly accessible to application
++ * code.  The length of the timer command queue is set by the
++ * configTIMER_QUEUE_LENGTH configuration constant.
++ *
++ * xTimerDelete() deletes a timer that was previously created using the
++ * xTimerCreate() API function.
++ *
++ * The configUSE_TIMERS configuration constant must be set to 1 for
++ * xTimerDelete() to be available.
++ *
++ * @param xTimer The handle of the timer being deleted.
++ *
++ * @param xTicksToWait Specifies the time, in ticks, that the calling task should
++ * be held in the Blocked state to wait for the delete command to be
++ * successfully sent to the timer command queue, should the queue already be
++ * full when xTimerDelete() was called.  xTicksToWait is ignored if xTimerDelete()
++ * is called before the scheduler is started.
++ *
++ * @return pdFAIL will be returned if the delete command could not be sent to
++ * the timer command queue even after xTicksToWait ticks had passed.  pdPASS will
++ * be returned if the command was successfully sent to the timer command queue.
++ * When the command is actually processed will depend on the priority of the
++ * timer service/daemon task relative to other tasks in the system.  The timer
++ * service/daemon task priority is set by the configTIMER_TASK_PRIORITY
++ * configuration constant.
++ *
++ * Example usage:
++ *
++ * See the xTimerChangePeriod() API function example usage scenario.
++ */
++#define xTimerDelete( xTimer, xTicksToWait ) \
++    xTimerGenericCommand( ( xTimer ), tmrCOMMAND_DELETE, 0U, NULL, ( xTicksToWait ) )
++
++/**
++ * BaseType_t xTimerReset( TimerHandle_t xTimer, TickType_t xTicksToWait );
++ *
++ * Timer functionality is provided by a timer service/daemon task.  Many of the
++ * public FreeRTOS timer API functions send commands to the timer service task
++ * through a queue called the timer command queue.  The timer command queue is
++ * private to the kernel itself and is not directly accessible to application
++ * code.  The length of the timer command queue is set by the
++ * configTIMER_QUEUE_LENGTH configuration constant.
++ *
++ * xTimerReset() re-starts a timer that was previously created using the
++ * xTimerCreate() API function.  If the timer had already been started and was
++ * already in the active state, then xTimerReset() will cause the timer to
++ * re-evaluate its expiry time so that it is relative to when xTimerReset() was
++ * called.  If the timer was in the dormant state then xTimerReset() has
++ * equivalent functionality to the xTimerStart() API function.
++ *
++ * Resetting a timer ensures the timer is in the active state.  If the timer
++ * is not stopped, deleted, or reset in the mean time, the callback function
++ * associated with the timer will get called 'n' ticks after xTimerReset() was
++ * called, where 'n' is the timers defined period.
++ *
++ * It is valid to call xTimerReset() before the scheduler has been started, but
++ * when this is done the timer will not actually start until the scheduler is
++ * started, and the timers expiry time will be relative to when the scheduler is
++ * started, not relative to when xTimerReset() was called.
++ *
++ * The configUSE_TIMERS configuration constant must be set to 1 for xTimerReset()
++ * to be available.
++ *
++ * @param xTimer The handle of the timer being reset/started/restarted.
++ *
++ * @param xTicksToWait Specifies the time, in ticks, that the calling task should
++ * be held in the Blocked state to wait for the reset command to be successfully
++ * sent to the timer command queue, should the queue already be full when
++ * xTimerReset() was called.  xTicksToWait is ignored if xTimerReset() is called
++ * before the scheduler is started.
++ *
++ * @return pdFAIL will be returned if the reset command could not be sent to
++ * the timer command queue even after xTicksToWait ticks had passed.  pdPASS will
++ * be returned if the command was successfully sent to the timer command queue.
++ * When the command is actually processed will depend on the priority of the
++ * timer service/daemon task relative to other tasks in the system, although the
++ * timers expiry time is relative to when xTimerStart() is actually called.  The
++ * timer service/daemon task priority is set by the configTIMER_TASK_PRIORITY
++ * configuration constant.
++ *
++ * Example usage:
++ * @verbatim
++ * // When a key is pressed, an LCD back-light is switched on.  If 5 seconds pass
++ * // without a key being pressed, then the LCD back-light is switched off.  In
++ * // this case, the timer is a one-shot timer.
++ *
++ * TimerHandle_t xBacklightTimer = NULL;
++ *
++ * // The callback function assigned to the one-shot timer.  In this case the
++ * // parameter is not used.
++ * void vBacklightTimerCallback( TimerHandle_t pxTimer )
++ * {
++ *     // The timer expired, therefore 5 seconds must have passed since a key
++ *     // was pressed.  Switch off the LCD back-light.
++ *     vSetBacklightState( BACKLIGHT_OFF );
++ * }
++ *
++ * // The key press event handler.
++ * void vKeyPressEventHandler( char cKey )
++ * {
++ *     // Ensure the LCD back-light is on, then reset the timer that is
++ *     // responsible for turning the back-light off after 5 seconds of
++ *     // key inactivity.  Wait 10 ticks for the command to be successfully sent
++ *     // if it cannot be sent immediately.
++ *     vSetBacklightState( BACKLIGHT_ON );
++ *     if( xTimerReset( xBacklightTimer, 100 ) != pdPASS )
++ *     {
++ *         // The reset command was not executed successfully.  Take appropriate
++ *         // action here.
++ *     }
++ *
++ *     // Perform the rest of the key processing here.
++ * }
++ *
++ * void main( void )
++ * {
++ * int32_t x;
++ *
++ *     // Create then start the one-shot timer that is responsible for turning
++ *     // the back-light off if no keys are pressed within a 5 second period.
++ *     xBacklightTimer = xTimerCreate( "BacklightTimer",           // Just a text name, not used by the kernel.
++ *                                     ( 5000 / portTICK_PERIOD_MS), // The timer period in ticks.
++ *                                     pdFALSE,                    // The timer is a one-shot timer.
++ *                                     0,                          // The id is not used by the callback so can take any value.
++ *                                     vBacklightTimerCallback     // The callback function that switches the LCD back-light off.
++ *                                   );
++ *
++ *     if( xBacklightTimer == NULL )
++ *     {
++ *         // The timer was not created.
++ *     }
++ *     else
++ *     {
++ *         // Start the timer.  No block time is specified, and even if one was
++ *         // it would be ignored because the scheduler has not yet been
++ *         // started.
++ *         if( xTimerStart( xBacklightTimer, 0 ) != pdPASS )
++ *         {
++ *             // The timer could not be set into the Active state.
++ *         }
++ *     }
++ *
++ *     // ...
++ *     // Create tasks here.
++ *     // ...
++ *
++ *     // Starting the scheduler will start the timer running as it has already
++ *     // been set into the active state.
++ *     vTaskStartScheduler();
++ *
++ *     // Should not reach here.
++ *     for( ;; );
++ * }
++ * @endverbatim
++ */
++#define xTimerReset( xTimer, xTicksToWait ) \
++    xTimerGenericCommand( ( xTimer ), tmrCOMMAND_RESET, ( xTaskGetTickCount() ), NULL, ( xTicksToWait ) )
++
++/**
++ * BaseType_t xTimerStartFromISR(   TimerHandle_t xTimer,
++ *                                  BaseType_t *pxHigherPriorityTaskWoken );
++ *
++ * A version of xTimerStart() that can be called from an interrupt service
++ * routine.
++ *
++ * @param xTimer The handle of the timer being started/restarted.
++ *
++ * @param pxHigherPriorityTaskWoken The timer service/daemon task spends most
++ * of its time in the Blocked state, waiting for messages to arrive on the timer
++ * command queue.  Calling xTimerStartFromISR() writes a message to the timer
++ * command queue, so has the potential to transition the timer service/daemon
++ * task out of the Blocked state.  If calling xTimerStartFromISR() causes the
++ * timer service/daemon task to leave the Blocked state, and the timer service/
++ * daemon task has a priority equal to or greater than the currently executing
++ * task (the task that was interrupted), then *pxHigherPriorityTaskWoken will
++ * get set to pdTRUE internally within the xTimerStartFromISR() function.  If
++ * xTimerStartFromISR() sets this value to pdTRUE then a context switch should
++ * be performed before the interrupt exits.
++ *
++ * @return pdFAIL will be returned if the start command could not be sent to
++ * the timer command queue.  pdPASS will be returned if the command was
++ * successfully sent to the timer command queue.  When the command is actually
++ * processed will depend on the priority of the timer service/daemon task
++ * relative to other tasks in the system, although the timers expiry time is
++ * relative to when xTimerStartFromISR() is actually called.  The timer
++ * service/daemon task priority is set by the configTIMER_TASK_PRIORITY
++ * configuration constant.
++ *
++ * Example usage:
++ * @verbatim
++ * // This scenario assumes xBacklightTimer has already been created.  When a
++ * // key is pressed, an LCD back-light is switched on.  If 5 seconds pass
++ * // without a key being pressed, then the LCD back-light is switched off.  In
++ * // this case, the timer is a one-shot timer, and unlike the example given for
++ * // the xTimerReset() function, the key press event handler is an interrupt
++ * // service routine.
++ *
++ * // The callback function assigned to the one-shot timer.  In this case the
++ * // parameter is not used.
++ * void vBacklightTimerCallback( TimerHandle_t pxTimer )
++ * {
++ *     // The timer expired, therefore 5 seconds must have passed since a key
++ *     // was pressed.  Switch off the LCD back-light.
++ *     vSetBacklightState( BACKLIGHT_OFF );
++ * }
++ *
++ * // The key press interrupt service routine.
++ * void vKeyPressEventInterruptHandler( void )
++ * {
++ * BaseType_t xHigherPriorityTaskWoken = pdFALSE;
++ *
++ *     // Ensure the LCD back-light is on, then restart the timer that is
++ *     // responsible for turning the back-light off after 5 seconds of
++ *     // key inactivity.  This is an interrupt service routine so can only
++ *     // call FreeRTOS API functions that end in "FromISR".
++ *     vSetBacklightState( BACKLIGHT_ON );
++ *
++ *     // xTimerStartFromISR() or xTimerResetFromISR() could be called here
++ *     // as both cause the timer to re-calculate its expiry time.
++ *     // xHigherPriorityTaskWoken was initialised to pdFALSE when it was
++ *     // declared (in this function).
++ *     if( xTimerStartFromISR( xBacklightTimer, &xHigherPriorityTaskWoken ) != pdPASS )
++ *     {
++ *         // The start command was not executed successfully.  Take appropriate
++ *         // action here.
++ *     }
++ *
++ *     // Perform the rest of the key processing here.
++ *
++ *     // If xHigherPriorityTaskWoken equals pdTRUE, then a context switch
++ *     // should be performed.  The syntax required to perform a context switch
++ *     // from inside an ISR varies from port to port, and from compiler to
++ *     // compiler.  Inspect the demos for the port you are using to find the
++ *     // actual syntax required.
++ *     if( xHigherPriorityTaskWoken != pdFALSE )
++ *     {
++ *         // Call the interrupt safe yield function here (actual function
++ *         // depends on the FreeRTOS port being used).
++ *     }
++ * }
++ * @endverbatim
++ */
++#define xTimerStartFromISR( xTimer, pxHigherPriorityTaskWoken ) \
++    xTimerGenericCommand( ( xTimer ), tmrCOMMAND_START_FROM_ISR, ( xTaskGetTickCountFromISR() ), ( pxHigherPriorityTaskWoken ), 0U )
++
++/**
++ * BaseType_t xTimerStopFromISR(    TimerHandle_t xTimer,
++ *                                  BaseType_t *pxHigherPriorityTaskWoken );
++ *
++ * A version of xTimerStop() that can be called from an interrupt service
++ * routine.
++ *
++ * @param xTimer The handle of the timer being stopped.
++ *
++ * @param pxHigherPriorityTaskWoken The timer service/daemon task spends most
++ * of its time in the Blocked state, waiting for messages to arrive on the timer
++ * command queue.  Calling xTimerStopFromISR() writes a message to the timer
++ * command queue, so has the potential to transition the timer service/daemon
++ * task out of the Blocked state.  If calling xTimerStopFromISR() causes the
++ * timer service/daemon task to leave the Blocked state, and the timer service/
++ * daemon task has a priority equal to or greater than the currently executing
++ * task (the task that was interrupted), then *pxHigherPriorityTaskWoken will
++ * get set to pdTRUE internally within the xTimerStopFromISR() function.  If
++ * xTimerStopFromISR() sets this value to pdTRUE then a context switch should
++ * be performed before the interrupt exits.
++ *
++ * @return pdFAIL will be returned if the stop command could not be sent to
++ * the timer command queue.  pdPASS will be returned if the command was
++ * successfully sent to the timer command queue.  When the command is actually
++ * processed will depend on the priority of the timer service/daemon task
++ * relative to other tasks in the system.  The timer service/daemon task
++ * priority is set by the configTIMER_TASK_PRIORITY configuration constant.
++ *
++ * Example usage:
++ * @verbatim
++ * // This scenario assumes xTimer has already been created and started.  When
++ * // an interrupt occurs, the timer should be simply stopped.
++ *
++ * // The interrupt service routine that stops the timer.
++ * void vAnExampleInterruptServiceRoutine( void )
++ * {
++ * BaseType_t xHigherPriorityTaskWoken = pdFALSE;
++ *
++ *     // The interrupt has occurred - simply stop the timer.
++ *     // xHigherPriorityTaskWoken was set to pdFALSE where it was defined
++ *     // (within this function).  As this is an interrupt service routine, only
++ *     // FreeRTOS API functions that end in "FromISR" can be used.
++ *     if( xTimerStopFromISR( xTimer, &xHigherPriorityTaskWoken ) != pdPASS )
++ *     {
++ *         // The stop command was not executed successfully.  Take appropriate
++ *         // action here.
++ *     }
++ *
++ *     // If xHigherPriorityTaskWoken equals pdTRUE, then a context switch
++ *     // should be performed.  The syntax required to perform a context switch
++ *     // from inside an ISR varies from port to port, and from compiler to
++ *     // compiler.  Inspect the demos for the port you are using to find the
++ *     // actual syntax required.
++ *     if( xHigherPriorityTaskWoken != pdFALSE )
++ *     {
++ *         // Call the interrupt safe yield function here (actual function
++ *         // depends on the FreeRTOS port being used).
++ *     }
++ * }
++ * @endverbatim
++ */
++#define xTimerStopFromISR( xTimer, pxHigherPriorityTaskWoken ) \
++    xTimerGenericCommand( ( xTimer ), tmrCOMMAND_STOP_FROM_ISR, 0, ( pxHigherPriorityTaskWoken ), 0U )
++
++/**
++ * BaseType_t xTimerChangePeriodFromISR( TimerHandle_t xTimer,
++ *                                       TickType_t xNewPeriod,
++ *                                       BaseType_t *pxHigherPriorityTaskWoken );
++ *
++ * A version of xTimerChangePeriod() that can be called from an interrupt
++ * service routine.
++ *
++ * @param xTimer The handle of the timer that is having its period changed.
++ *
++ * @param xNewPeriod The new period for xTimer. Timer periods are specified in
++ * tick periods, so the constant portTICK_PERIOD_MS can be used to convert a time
++ * that has been specified in milliseconds.  For example, if the timer must
++ * expire after 100 ticks, then xNewPeriod should be set to 100.  Alternatively,
++ * if the timer must expire after 500ms, then xNewPeriod can be set to
++ * ( 500 / portTICK_PERIOD_MS ) provided configTICK_RATE_HZ is less than
++ * or equal to 1000.
++ *
++ * @param pxHigherPriorityTaskWoken The timer service/daemon task spends most
++ * of its time in the Blocked state, waiting for messages to arrive on the timer
++ * command queue.  Calling xTimerChangePeriodFromISR() writes a message to the
++ * timer command queue, so has the potential to transition the timer service/
++ * daemon task out of the Blocked state.  If calling xTimerChangePeriodFromISR()
++ * causes the timer service/daemon task to leave the Blocked state, and the
++ * timer service/daemon task has a priority equal to or greater than the
++ * currently executing task (the task that was interrupted), then
++ * *pxHigherPriorityTaskWoken will get set to pdTRUE internally within the
++ * xTimerChangePeriodFromISR() function.  If xTimerChangePeriodFromISR() sets
++ * this value to pdTRUE then a context switch should be performed before the
++ * interrupt exits.
++ *
++ * @return pdFAIL will be returned if the command to change the timers period
++ * could not be sent to the timer command queue.  pdPASS will be returned if the
++ * command was successfully sent to the timer command queue.  When the command
++ * is actually processed will depend on the priority of the timer service/daemon
++ * task relative to other tasks in the system.  The timer service/daemon task
++ * priority is set by the configTIMER_TASK_PRIORITY configuration constant.
++ *
++ * Example usage:
++ * @verbatim
++ * // This scenario assumes xTimer has already been created and started.  When
++ * // an interrupt occurs, the period of xTimer should be changed to 500ms.
++ *
++ * // The interrupt service routine that changes the period of xTimer.
++ * void vAnExampleInterruptServiceRoutine( void )
++ * {
++ * BaseType_t xHigherPriorityTaskWoken = pdFALSE;
++ *
++ *     // The interrupt has occurred - change the period of xTimer to 500ms.
++ *     // xHigherPriorityTaskWoken was set to pdFALSE where it was defined
++ *     // (within this function).  As this is an interrupt service routine, only
++ *     // FreeRTOS API functions that end in "FromISR" can be used.
++ *     if( xTimerChangePeriodFromISR( xTimer, &xHigherPriorityTaskWoken ) != pdPASS )
++ *     {
++ *         // The command to change the timers period was not executed
++ *         // successfully.  Take appropriate action here.
++ *     }
++ *
++ *     // If xHigherPriorityTaskWoken equals pdTRUE, then a context switch
++ *     // should be performed.  The syntax required to perform a context switch
++ *     // from inside an ISR varies from port to port, and from compiler to
++ *     // compiler.  Inspect the demos for the port you are using to find the
++ *     // actual syntax required.
++ *     if( xHigherPriorityTaskWoken != pdFALSE )
++ *     {
++ *         // Call the interrupt safe yield function here (actual function
++ *         // depends on the FreeRTOS port being used).
++ *     }
++ * }
++ * @endverbatim
++ */
++#define xTimerChangePeriodFromISR( xTimer, xNewPeriod, pxHigherPriorityTaskWoken ) \
++    xTimerGenericCommand( ( xTimer ), tmrCOMMAND_CHANGE_PERIOD_FROM_ISR, ( xNewPeriod ), ( pxHigherPriorityTaskWoken ), 0U )
++
++/**
++ * BaseType_t xTimerResetFromISR(   TimerHandle_t xTimer,
++ *                                  BaseType_t *pxHigherPriorityTaskWoken );
++ *
++ * A version of xTimerReset() that can be called from an interrupt service
++ * routine.
++ *
++ * @param xTimer The handle of the timer that is to be started, reset, or
++ * restarted.
++ *
++ * @param pxHigherPriorityTaskWoken The timer service/daemon task spends most
++ * of its time in the Blocked state, waiting for messages to arrive on the timer
++ * command queue.  Calling xTimerResetFromISR() writes a message to the timer
++ * command queue, so has the potential to transition the timer service/daemon
++ * task out of the Blocked state.  If calling xTimerResetFromISR() causes the
++ * timer service/daemon task to leave the Blocked state, and the timer service/
++ * daemon task has a priority equal to or greater than the currently executing
++ * task (the task that was interrupted), then *pxHigherPriorityTaskWoken will
++ * get set to pdTRUE internally within the xTimerResetFromISR() function.  If
++ * xTimerResetFromISR() sets this value to pdTRUE then a context switch should
++ * be performed before the interrupt exits.
++ *
++ * @return pdFAIL will be returned if the reset command could not be sent to
++ * the timer command queue.  pdPASS will be returned if the command was
++ * successfully sent to the timer command queue.  When the command is actually
++ * processed will depend on the priority of the timer service/daemon task
++ * relative to other tasks in the system, although the timers expiry time is
++ * relative to when xTimerResetFromISR() is actually called.  The timer service/daemon
++ * task priority is set by the configTIMER_TASK_PRIORITY configuration constant.
++ *
++ * Example usage:
++ * @verbatim
++ * // This scenario assumes xBacklightTimer has already been created.  When a
++ * // key is pressed, an LCD back-light is switched on.  If 5 seconds pass
++ * // without a key being pressed, then the LCD back-light is switched off.  In
++ * // this case, the timer is a one-shot timer, and unlike the example given for
++ * // the xTimerReset() function, the key press event handler is an interrupt
++ * // service routine.
++ *
++ * // The callback function assigned to the one-shot timer.  In this case the
++ * // parameter is not used.
++ * void vBacklightTimerCallback( TimerHandle_t pxTimer )
++ * {
++ *     // The timer expired, therefore 5 seconds must have passed since a key
++ *     // was pressed.  Switch off the LCD back-light.
++ *     vSetBacklightState( BACKLIGHT_OFF );
++ * }
++ *
++ * // The key press interrupt service routine.
++ * void vKeyPressEventInterruptHandler( void )
++ * {
++ * BaseType_t xHigherPriorityTaskWoken = pdFALSE;
++ *
++ *     // Ensure the LCD back-light is on, then reset the timer that is
++ *     // responsible for turning the back-light off after 5 seconds of
++ *     // key inactivity.  This is an interrupt service routine so can only
++ *     // call FreeRTOS API functions that end in "FromISR".
++ *     vSetBacklightState( BACKLIGHT_ON );
++ *
++ *     // xTimerStartFromISR() or xTimerResetFromISR() could be called here
++ *     // as both cause the timer to re-calculate its expiry time.
++ *     // xHigherPriorityTaskWoken was initialised to pdFALSE when it was
++ *     // declared (in this function).
++ *     if( xTimerResetFromISR( xBacklightTimer, &xHigherPriorityTaskWoken ) != pdPASS )
++ *     {
++ *         // The reset command was not executed successfully.  Take appropriate
++ *         // action here.
++ *     }
++ *
++ *     // Perform the rest of the key processing here.
++ *
++ *     // If xHigherPriorityTaskWoken equals pdTRUE, then a context switch
++ *     // should be performed.  The syntax required to perform a context switch
++ *     // from inside an ISR varies from port to port, and from compiler to
++ *     // compiler.  Inspect the demos for the port you are using to find the
++ *     // actual syntax required.
++ *     if( xHigherPriorityTaskWoken != pdFALSE )
++ *     {
++ *         // Call the interrupt safe yield function here (actual function
++ *         // depends on the FreeRTOS port being used).
++ *     }
++ * }
++ * @endverbatim
++ */
++#define xTimerResetFromISR( xTimer, pxHigherPriorityTaskWoken ) \
++    xTimerGenericCommand( ( xTimer ), tmrCOMMAND_RESET_FROM_ISR, ( xTaskGetTickCountFromISR() ), ( pxHigherPriorityTaskWoken ), 0U )
++
++/**
++ * const char * const pcTimerGetName( TimerHandle_t xTimer );
++ *
++ * Returns the name that was assigned to a timer when the timer was created.
++ *
++ * @param xTimer The handle of the timer being queried.
++ *
++ * @return The name assigned to the timer specified by the xTimer parameter.
++ */
++const char * pcTimerGetName( TimerHandle_t xTimer );
++
++/**
++ * void vTimerSetReloadMode( TimerHandle_t xTimer, const UBaseType_t uxAutoReload );
++ *
++ * Updates a timer to be either an auto-reload timer, in which case the timer
++ * automatically resets itself each time it expires, or a one-shot timer, in
++ * which case the timer will only expire once unless it is manually restarted.
++ *
++ * @param xTimer The handle of the timer being updated.
++ *
++ * @param uxAutoReload If uxAutoReload is set to pdTRUE then the timer will
++ * expire repeatedly with a frequency set by the timer's period (see the
++ * xTimerPeriodInTicks parameter of the xTimerCreate() API function).  If
++ * uxAutoReload is set to pdFALSE then the timer will be a one-shot timer and
++ * enter the dormant state after it expires.
++ */
++void vTimerSetReloadMode( TimerHandle_t xTimer,
++                          const UBaseType_t uxAutoReload );
++
++/**
++ * UBaseType_t uxTimerGetReloadMode( TimerHandle_t xTimer );
++ *
++ * Queries a timer to determine if it is an auto-reload timer, in which case the timer
++ * automatically resets itself each time it expires, or a one-shot timer, in
++ * which case the timer will only expire once unless it is manually restarted.
++ *
++ * @param xTimer The handle of the timer being queried.
++ *
++ * @return If the timer is an auto-reload timer then pdTRUE is returned, otherwise
++ * pdFALSE is returned.
++ */
++UBaseType_t uxTimerGetReloadMode( TimerHandle_t xTimer );
++
++/**
++ * TickType_t xTimerGetPeriod( TimerHandle_t xTimer );
++ *
++ * Returns the period of a timer.
++ *
++ * @param xTimer The handle of the timer being queried.
++ *
++ * @return The period of the timer in ticks.
++ */
++TickType_t xTimerGetPeriod( TimerHandle_t xTimer );
++
++/**
++ * TickType_t xTimerGetExpiryTime( TimerHandle_t xTimer );
++ *
++ * Returns the time in ticks at which the timer will expire.  If this is less
++ * than the current tick count then the expiry time has overflowed from the
++ * current time.
++ *
++ * @param xTimer The handle of the timer being queried.
++ *
++ * @return If the timer is running then the time in ticks at which the timer
++ * will next expire is returned.  If the timer is not running then the return
++ * value is undefined.
++ */
++TickType_t xTimerGetExpiryTime( TimerHandle_t xTimer );
++
++/*
++ * Functions beyond this part are not part of the public API and are intended
++ * for use by the kernel only.
++ */
++BaseType_t xTimerGenericCommand( TimerHandle_t xTimer,
++                                 const BaseType_t xCommandID,
++                                 const TickType_t xOptionalValue,
++                                 BaseType_t * const pxHigherPriorityTaskWoken,
++                                 const TickType_t xTicksToWait );
++
++/* *INDENT-OFF* */
++#ifdef __cplusplus
++    }
++#endif
++/* *INDENT-ON* */
++#endif /* TIMERS_H */
+diff --git a/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/list.c b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/list.c
+new file mode 100644
+index 0000000000..5eec523162
+--- /dev/null
++++ b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/list.c
+@@ -0,0 +1,213 @@
++/*
++ * FreeRTOS Kernel V10.4.3
++ * Copyright (C) 2020 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
++ *
++ * 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
++ *
++ */
++
++
++#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
++ * task.h is included from an application file. */
++#define MPU_WRAPPERS_INCLUDED_FROM_API_FILE
++
++#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
++ * 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. */
++
++/*-----------------------------------------------------------
++* PUBLIC LIST API documented in list.h
++*----------------------------------------------------------*/
++
++void vListInitialise( List_t * const 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. */
++
++    /* 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->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 );
++}
++/*-----------------------------------------------------------*/
++
++void vListInitialiseItem( ListItem_t * const 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 );
++}
++/*-----------------------------------------------------------*/
++
++void vListInsertEnd( List_t * const pxList,
++                     ListItem_t * const pxNewListItem )
++{
++    ListItem_t * const pxIndex = pxList->pxIndex;
++
++    /* 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 );
++
++    /* 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;
++
++    /* Only used during decision coverage testing. */
++    mtCOVERAGE_TEST_DELAY();
++
++    pxIndex->pxPrevious->pxNext = pxNewListItem;
++    pxIndex->pxPrevious = pxNewListItem;
++
++    /* Remember which list the item is in. */
++    pxNewListItem->pxContainer = pxList;
++
++    ( pxList->uxNumberOfItems )++;
++}
++/*-----------------------------------------------------------*/
++
++void vListInsert( List_t * const pxList,
++                  ListItem_t * const pxNewListItem )
++{
++    ListItem_t * pxIterator;
++    const TickType_t xValueOfInsertion = pxNewListItem->xItemValue;
++
++    /* 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 );
++
++    /* Insert the new list item into the list, sorted in xItemValue order.
++     *
++     * If the list already contains a list item with the same item value then the
++     * new list item should be placed after it.  This ensures that TCBs which are
++     * stored in ready lists (all of which have the same xItemValue value) get a
++     * 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 )
++    {
++        pxIterator = pxList->xListEnd.pxPrevious;
++    }
++    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
++        *  more tips, and ensure configASSERT() is defined!
++        *  https://www.FreeRTOS.org/a00110.html#configASSERT
++        *
++        *   1) Stack overflow -
++        *      see https://www.FreeRTOS.org/Stacks-and-stack-overflow-checking.html
++        *   2) Incorrect interrupt priority assignment, especially on Cortex-M
++        *      parts where numerically high priority values denote low actual
++        *      interrupt priorities, which can seem counter intuitive.  See
++        *      https://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html and the definition
++        *      of configMAX_SYSCALL_INTERRUPT_PRIORITY on
++        *      https://www.FreeRTOS.org/a00110.html
++        *   3) Calling an API function from within a critical section or when
++        *      the scheduler is suspended, or calling an API function that does
++        *      not end in "FromISR" from an interrupt.
++        *   4) Using a queue or semaphore before it has been initialised or
++        *      before the scheduler has been started (are interrupts firing
++        *      before vTaskStartScheduler() has been called?).
++        *   5) If the FreeRTOS port supports interrupt nesting then ensure that
++        *      the priority of the tick interrupt is at or below
++        *      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. */
++        {
++            /* There is nothing to do here, just iterating to the wanted
++             * insertion position. */
++        }
++    }
++
++    pxNewListItem->pxNext = pxIterator->pxNext;
++    pxNewListItem->pxNext->pxPrevious = pxNewListItem;
++    pxNewListItem->pxPrevious = pxIterator;
++    pxIterator->pxNext = pxNewListItem;
++
++    /* Remember which list the item is in.  This allows fast removal of the
++     * item later. */
++    pxNewListItem->pxContainer = pxList;
++
++    ( pxList->uxNumberOfItems )++;
++}
++/*-----------------------------------------------------------*/
++
++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;
++
++    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 )
++    {
++        pxList->pxIndex = pxItemToRemove->pxPrevious;
++    }
++    else
++    {
++        mtCOVERAGE_TEST_MARKER();
++    }
++
++    pxItemToRemove->pxContainer = NULL;
++    ( pxList->uxNumberOfItems )--;
++
++    return pxList->uxNumberOfItems;
++}
++/*-----------------------------------------------------------*/
+diff --git a/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/MemMang/heap_1.c b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/MemMang/heap_1.c
+new file mode 100644
+index 0000000000..cebc240892
+--- /dev/null
++++ b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/MemMang/heap_1.c
+@@ -0,0 +1,145 @@
++/*
++ * FreeRTOS Kernel V10.4.6
++ * 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
++ *
++ */
++
++
++/*
++ * The simplest possible implementation of pvPortMalloc().  Note that this
++ * implementation does NOT allow allocated memory to be freed again.
++ *
++ * See heap_2.c, heap_3.c and heap_4.c for alternative implementations, and the
++ * memory management pages of https://www.FreeRTOS.org for more information.
++ */
++#include <stdlib.h>
++
++#include "FreeRTOS.h"
++#include "task.h"
++
++#if ( configSUPPORT_DYNAMIC_ALLOCATION == 0 )
++    #error This file must not be used if configSUPPORT_DYNAMIC_ALLOCATION is 0
++#endif
++
++/* A few bytes might be lost to byte aligning the heap start address. */
++#define configADJUSTED_HEAP_SIZE    ( configTOTAL_HEAP_SIZE - portBYTE_ALIGNMENT )
++
++/* Allocate the memory for the heap. */
++#if ( configAPPLICATION_ALLOCATED_HEAP == 1 )
++
++/* The application writer has already defined the array used for the RTOS
++* heap - probably so it can be placed in a special segment or address. */
++    extern uint8_t ucHeap[ configTOTAL_HEAP_SIZE ];
++#else
++    static uint8_t ucHeap[ configTOTAL_HEAP_SIZE ];
++#endif /* configAPPLICATION_ALLOCATED_HEAP */
++
++/* Index into the ucHeap array. */
++static size_t xNextFreeByte = ( size_t ) 0;
++
++/*-----------------------------------------------------------*/
++
++void * pvPortMalloc( size_t xWantedSize )
++{
++    void * pvReturn = NULL;
++    static uint8_t * pucAlignedHeap = NULL;
++
++    /* Ensure that blocks are always aligned. */
++    #if ( portBYTE_ALIGNMENT != 1 )
++        {
++            if( xWantedSize & portBYTE_ALIGNMENT_MASK )
++            {
++                /* Byte alignment required. Check for overflow. */
++                if ( (xWantedSize + ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) )) > xWantedSize )
++                {
++                    xWantedSize += ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) );
++                }
++                else
++                {
++                    xWantedSize = 0;
++                }
++            }
++        }
++    #endif
++
++    vTaskSuspendAll();
++    {
++        if( pucAlignedHeap == NULL )
++        {
++            /* Ensure the heap starts on a correctly aligned boundary. */
++            pucAlignedHeap = ( uint8_t * ) ( ( ( portPOINTER_SIZE_TYPE ) & ucHeap[ portBYTE_ALIGNMENT - 1 ] ) & ( ~( ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) ) );
++        }
++
++        /* Check there is enough room left for the allocation and. */
++        if( ( xWantedSize > 0 ) && /* valid size */
++            ( ( xNextFreeByte + xWantedSize ) < configADJUSTED_HEAP_SIZE ) &&
++            ( ( xNextFreeByte + xWantedSize ) > xNextFreeByte ) ) /* Check for overflow. */
++        {
++            /* Return the next free byte then increment the index past this
++             * block. */
++            pvReturn = pucAlignedHeap + xNextFreeByte;
++            xNextFreeByte += xWantedSize;
++        }
++
++    }
++    ( void ) xTaskResumeAll();
++
++    #if ( configUSE_MALLOC_FAILED_HOOK == 1 )
++        {
++            if( pvReturn == NULL )
++            {
++                extern void vApplicationMallocFailedHook( void );
++                vApplicationMallocFailedHook();
++            }
++        }
++    #endif
++
++    return pvReturn;
++}
++/*-----------------------------------------------------------*/
++
++void vPortFree( void * pv )
++{
++    /* Memory cannot be freed using this scheme.  See heap_2.c, heap_3.c and
++     * heap_4.c for alternative implementations, and the memory management pages of
++     * https://www.FreeRTOS.org for more information. */
++    ( void ) pv;
++
++    /* Force an assert as it is invalid to call this function. */
++    configASSERT( pv == NULL );
++}
++/*-----------------------------------------------------------*/
++
++void vPortInitialiseBlocks( void )
++{
++    /* Only required when static memory is not cleared. */
++    xNextFreeByte = ( size_t ) 0;
++}
++/*-----------------------------------------------------------*/
++
++size_t xPortGetFreeHeapSize( void )
++{
++    return( configADJUSTED_HEAP_SIZE - xNextFreeByte );
++}
+diff --git a/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/MemMang/heap_2.c b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/MemMang/heap_2.c
+new file mode 100644
+index 0000000000..00a68b26b4
+--- /dev/null
++++ b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/MemMang/heap_2.c
+@@ -0,0 +1,277 @@
++/*
++ * FreeRTOS Kernel V10.4.6
++ * 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
++ *
++ */
++
++/*
++ * A sample implementation of pvPortMalloc() and vPortFree() that permits
++ * allocated blocks to be freed, but does not combine adjacent free blocks
++ * into a single larger block (and so will fragment memory).  See heap_4.c for
++ * an equivalent that does combine adjacent blocks into single larger blocks.
++ *
++ * See heap_1.c, heap_3.c and heap_4.c for alternative implementations, and the
++ * memory management pages of https://www.FreeRTOS.org for more information.
++ */
++#include <stdlib.h>
++
++#include "FreeRTOS.h"
++#include "task.h"
++
++#if ( configSUPPORT_DYNAMIC_ALLOCATION == 0 )
++    #error This file must not be used if configSUPPORT_DYNAMIC_ALLOCATION is 0
++#endif
++
++/* A few bytes might be lost to byte aligning the heap start address. */
++#define configADJUSTED_HEAP_SIZE    ( configTOTAL_HEAP_SIZE - portBYTE_ALIGNMENT )
++
++/*
++ * Initialises the heap structures before their first use.
++ */
++static void prvHeapInit( void );
++
++/* Allocate the memory for the heap. */
++#if ( configAPPLICATION_ALLOCATED_HEAP == 1 )
++
++/* The application writer has already defined the array used for the RTOS
++* heap - probably so it can be placed in a special segment or address. */
++    extern uint8_t ucHeap[ configTOTAL_HEAP_SIZE ];
++#else
++    static uint8_t ucHeap[ configTOTAL_HEAP_SIZE ];
++#endif /* configAPPLICATION_ALLOCATED_HEAP */
++
++
++/* Define the linked list structure.  This is used to link free blocks in order
++ * of their size. */
++typedef struct A_BLOCK_LINK
++{
++    struct A_BLOCK_LINK * pxNextFreeBlock; /*<< The next free block in the list. */
++    size_t xBlockSize;                     /*<< The size of the free block. */
++} BlockLink_t;
++
++
++static const uint16_t heapSTRUCT_SIZE = ( ( sizeof( BlockLink_t ) + ( portBYTE_ALIGNMENT - 1 ) ) & ~portBYTE_ALIGNMENT_MASK );
++#define heapMINIMUM_BLOCK_SIZE    ( ( size_t ) ( heapSTRUCT_SIZE * 2 ) )
++
++/* Create a couple of list links to mark the start and end of the list. */
++static BlockLink_t xStart, xEnd;
++
++/* Keeps track of the number of free bytes remaining, but says nothing about
++ * fragmentation. */
++static size_t xFreeBytesRemaining = configADJUSTED_HEAP_SIZE;
++
++/* STATIC FUNCTIONS ARE DEFINED AS MACROS TO MINIMIZE THE FUNCTION CALL DEPTH. */
++
++/*
++ * Insert a block into the list of free blocks - which is ordered by size of
++ * the block.  Small blocks at the start of the list and large blocks at the end
++ * of the list.
++ */
++#define prvInsertBlockIntoFreeList( pxBlockToInsert )                                                                               \
++    {                                                                                                                               \
++        BlockLink_t * pxIterator;                                                                                                   \
++        size_t xBlockSize;                                                                                                          \
++                                                                                                                                    \
++        xBlockSize = pxBlockToInsert->xBlockSize;                                                                                   \
++                                                                                                                                    \
++        /* Iterate through the list until a block is found that has a larger size */                                                \
++        /* than the block we are inserting. */                                                                                      \
++        for( pxIterator = &xStart; pxIterator->pxNextFreeBlock->xBlockSize < xBlockSize; pxIterator = pxIterator->pxNextFreeBlock ) \
++        {                                                                                                                           \
++            /* There is nothing to do here - just iterate to the correct position. */                                               \
++        }                                                                                                                           \
++                                                                                                                                    \
++        /* Update the list to include the block being inserted in the correct */                                                    \
++        /* position. */                                                                                                             \
++        pxBlockToInsert->pxNextFreeBlock = pxIterator->pxNextFreeBlock;                                                             \
++        pxIterator->pxNextFreeBlock = pxBlockToInsert;                                                                              \
++    }
++/*-----------------------------------------------------------*/
++
++void * pvPortMalloc( size_t xWantedSize )
++{
++    BlockLink_t * pxBlock, * pxPreviousBlock, * pxNewBlockLink;
++    static BaseType_t xHeapHasBeenInitialised = pdFALSE;
++    void * pvReturn = NULL;
++
++    vTaskSuspendAll();
++    {
++        /* If this is the first call to malloc then the heap will require
++         * initialisation to setup the list of free blocks. */
++        if( xHeapHasBeenInitialised == pdFALSE )
++        {
++            prvHeapInit();
++            xHeapHasBeenInitialised = pdTRUE;
++        }
++
++        /* The wanted size must be increased so it can contain a BlockLink_t
++         * structure in addition to the requested amount of bytes. */
++        if( ( xWantedSize > 0 ) &&
++            ( ( xWantedSize + heapSTRUCT_SIZE ) >  xWantedSize ) ) /* Overflow check */
++        {
++            xWantedSize += heapSTRUCT_SIZE;
++
++            /* Byte alignment required. Check for overflow. */
++            if( ( xWantedSize + ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) ) )
++                    > xWantedSize )
++            {
++                xWantedSize += ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) );
++                configASSERT( ( xWantedSize & portBYTE_ALIGNMENT_MASK ) == 0 );
++            }
++            else
++            {
++                xWantedSize = 0;
++            }
++        }
++        else
++        {
++            xWantedSize = 0;
++        }
++
++
++        if( ( xWantedSize > 0 ) && ( xWantedSize <= xFreeBytesRemaining ) )
++        {
++            /* Blocks are stored in byte order - traverse the list from the start
++             * (smallest) block until one of adequate size is found. */
++            pxPreviousBlock = &xStart;
++            pxBlock = xStart.pxNextFreeBlock;
++
++            while( ( pxBlock->xBlockSize < xWantedSize ) && ( pxBlock->pxNextFreeBlock != NULL ) )
++            {
++                pxPreviousBlock = pxBlock;
++                pxBlock = pxBlock->pxNextFreeBlock;
++            }
++
++            /* If we found the end marker then a block of adequate size was not found. */
++            if( pxBlock != &xEnd )
++            {
++                /* Return the memory space - jumping over the BlockLink_t structure
++                 * at its start. */
++                pvReturn = ( void * ) ( ( ( uint8_t * ) pxPreviousBlock->pxNextFreeBlock ) + heapSTRUCT_SIZE );
++
++                /* This block is being returned for use so must be taken out of the
++                 * list of free blocks. */
++                pxPreviousBlock->pxNextFreeBlock = pxBlock->pxNextFreeBlock;
++
++                /* If the block is larger than required it can be split into two. */
++                if( ( pxBlock->xBlockSize - xWantedSize ) > heapMINIMUM_BLOCK_SIZE )
++                {
++                    /* This block is to be split into two.  Create a new block
++                     * following the number of bytes requested. The void cast is
++                     * used to prevent byte alignment warnings from the compiler. */
++                    pxNewBlockLink = ( void * ) ( ( ( uint8_t * ) pxBlock ) + xWantedSize );
++
++                    /* Calculate the sizes of two blocks split from the single
++                     * block. */
++                    pxNewBlockLink->xBlockSize = pxBlock->xBlockSize - xWantedSize;
++                    pxBlock->xBlockSize = xWantedSize;
++
++                    /* Insert the new block into the list of free blocks. */
++                    prvInsertBlockIntoFreeList( ( pxNewBlockLink ) );
++                }
++
++                xFreeBytesRemaining -= pxBlock->xBlockSize;
++            }
++        }
++
++    }
++    ( void ) xTaskResumeAll();
++
++    #if ( configUSE_MALLOC_FAILED_HOOK == 1 )
++        {
++            if( pvReturn == NULL )
++            {
++                extern void vApplicationMallocFailedHook( void );
++                vApplicationMallocFailedHook();
++            }
++        }
++    #endif
++
++    return pvReturn;
++}
++/*-----------------------------------------------------------*/
++
++void vPortFree( void * pv )
++{
++    uint8_t * puc = ( uint8_t * ) pv;
++    BlockLink_t * pxLink;
++
++    if( pv != NULL )
++    {
++        /* The memory being freed will have an BlockLink_t structure immediately
++         * before it. */
++        puc -= heapSTRUCT_SIZE;
++
++        /* This unexpected casting is to keep some compilers from issuing
++         * byte alignment warnings. */
++        pxLink = ( void * ) puc;
++
++        vTaskSuspendAll();
++        {
++            /* Add this block to the list of free blocks. */
++            prvInsertBlockIntoFreeList( ( ( BlockLink_t * ) pxLink ) );
++            xFreeBytesRemaining += pxLink->xBlockSize;
++        }
++        ( void ) xTaskResumeAll();
++    }
++}
++/*-----------------------------------------------------------*/
++
++size_t xPortGetFreeHeapSize( void )
++{
++    return xFreeBytesRemaining;
++}
++/*-----------------------------------------------------------*/
++
++void vPortInitialiseBlocks( void )
++{
++    /* This just exists to keep the linker quiet. */
++}
++/*-----------------------------------------------------------*/
++
++static void prvHeapInit( void )
++{
++    BlockLink_t * pxFirstFreeBlock;
++    uint8_t * pucAlignedHeap;
++
++    /* Ensure the heap starts on a correctly aligned boundary. */
++    pucAlignedHeap = ( uint8_t * ) ( ( ( portPOINTER_SIZE_TYPE ) & ucHeap[ portBYTE_ALIGNMENT - 1 ] ) & ( ~( ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) ) );
++
++    /* xStart is used to hold a pointer to the first item in the list of free
++     * blocks.  The void cast is used to prevent compiler warnings. */
++    xStart.pxNextFreeBlock = ( void * ) pucAlignedHeap;
++    xStart.xBlockSize = ( size_t ) 0;
++
++    /* xEnd is used to mark the end of the list of free blocks. */
++    xEnd.xBlockSize = configADJUSTED_HEAP_SIZE;
++    xEnd.pxNextFreeBlock = NULL;
++
++    /* To start with there is a single free block that is sized to take up the
++     * entire heap space. */
++    pxFirstFreeBlock = ( void * ) pucAlignedHeap;
++    pxFirstFreeBlock->xBlockSize = configADJUSTED_HEAP_SIZE;
++    pxFirstFreeBlock->pxNextFreeBlock = &xEnd;
++}
++/*-----------------------------------------------------------*/
+diff --git a/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/MemMang/heap_3.c b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/MemMang/heap_3.c
+new file mode 100644
+index 0000000000..7cdd9bb18a
+--- /dev/null
++++ b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/MemMang/heap_3.c
+@@ -0,0 +1,78 @@
++/*
++ * FreeRTOS Kernel V10.4.6
++ * 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 pvPortMalloc() and vPortFree() that relies on the
++ * compilers own malloc() and free() implementations.
++ *
++ * This file can only be used if the linker is configured to to generate
++ * a heap memory area.
++ *
++ * See heap_1.c, heap_2.c and heap_4.c for alternative implementations, and the
++ * memory management pages of https://www.FreeRTOS.org for more information.
++ */
++
++#include <stdlib.h>
++
++#include "FreeRTOS.h"
++#include "task.h"
++
++#if ( configSUPPORT_DYNAMIC_ALLOCATION == 0 )
++    #error This file must not be used if configSUPPORT_DYNAMIC_ALLOCATION is 0
++#endif
++
++/*-----------------------------------------------------------*/
++
++void * pvPortMalloc( size_t xWantedSize )
++{
++    void * pvReturn;
++
++    pvReturn = RT_KERNEL_MALLOC( xWantedSize );
++
++    #if ( configUSE_MALLOC_FAILED_HOOK == 1 )
++        {
++            if( pvReturn == NULL )
++            {
++                extern void vApplicationMallocFailedHook( void );
++                vApplicationMallocFailedHook();
++            }
++        }
++    #endif
++
++    return pvReturn;
++}
++/*-----------------------------------------------------------*/
++
++void vPortFree( void * pv )
++{
++    if( pv )
++    {
++        RT_KERNEL_FREE( pv );
++    }
++}
+diff --git a/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/MemMang/heap_4.c b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/MemMang/heap_4.c
+new file mode 100644
+index 0000000000..53536b7025
+--- /dev/null
++++ b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/MemMang/heap_4.c
+@@ -0,0 +1,447 @@
++/*
++ * FreeRTOS Kernel V10.4.6
++ * 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
++ *
++ */
++
++/*
++ * A sample implementation of pvPortMalloc() and vPortFree() that combines
++ * (coalescences) adjacent memory blocks as they are freed, and in so doing
++ * limits memory fragmentation.
++ *
++ * See heap_1.c, heap_2.c and heap_3.c for alternative implementations, and the
++ * memory management pages of https://www.FreeRTOS.org for more information.
++ */
++#include <stdlib.h>
++
++#include "FreeRTOS.h"
++#include "task.h"
++
++#if ( configSUPPORT_DYNAMIC_ALLOCATION == 0 )
++    #error This file must not be used if configSUPPORT_DYNAMIC_ALLOCATION is 0
++#endif
++
++/* Block sizes must not get too small. */
++#define heapMINIMUM_BLOCK_SIZE    ( ( size_t ) ( xHeapStructSize << 1 ) )
++
++/* Assumes 8bit bytes! */
++#define heapBITS_PER_BYTE         ( ( size_t ) 8 )
++
++/* Allocate the memory for the heap. */
++#if ( configAPPLICATION_ALLOCATED_HEAP == 1 )
++
++/* The application writer has already defined the array used for the RTOS
++* heap - probably so it can be placed in a special segment or address. */
++    extern uint8_t ucHeap[ configTOTAL_HEAP_SIZE ];
++#else
++    static uint8_t ucHeap[ configTOTAL_HEAP_SIZE ];
++#endif /* configAPPLICATION_ALLOCATED_HEAP */
++
++/* Define the linked list structure.  This is used to link free blocks in order
++ * of their memory address. */
++typedef struct A_BLOCK_LINK
++{
++    struct A_BLOCK_LINK * pxNextFreeBlock; /*<< The next free block in the list. */
++    size_t xBlockSize;                     /*<< The size of the free block. */
++} BlockLink_t;
++
++/*-----------------------------------------------------------*/
++
++/*
++ * Inserts a block of memory that is being freed into the correct position in
++ * the list of free memory blocks.  The block being freed will be merged with
++ * the block in front it and/or the block behind it if the memory blocks are
++ * adjacent to each other.
++ */
++static void prvInsertBlockIntoFreeList( BlockLink_t * pxBlockToInsert );
++
++/*
++ * Called automatically to setup the required heap structures the first time
++ * pvPortMalloc() is called.
++ */
++static void prvHeapInit( void );
++
++/*-----------------------------------------------------------*/
++
++/* The size of the structure placed at the beginning of each allocated memory
++ * block must by correctly byte aligned. */
++static const size_t xHeapStructSize = ( sizeof( BlockLink_t ) + ( ( size_t ) ( portBYTE_ALIGNMENT - 1 ) ) ) & ~( ( size_t ) portBYTE_ALIGNMENT_MASK );
++
++/* Create a couple of list links to mark the start and end of the list. */
++static BlockLink_t xStart, * pxEnd = NULL;
++
++/* Keeps track of the number of calls to allocate and free memory as well as the
++ * number of free bytes remaining, but says nothing about fragmentation. */
++static size_t xFreeBytesRemaining = 0U;
++static size_t xMinimumEverFreeBytesRemaining = 0U;
++static size_t xNumberOfSuccessfulAllocations = 0;
++static size_t xNumberOfSuccessfulFrees = 0;
++
++/* Gets set to the top bit of an size_t type.  When this bit in the xBlockSize
++ * member of an BlockLink_t structure is set then the block belongs to the
++ * application.  When the bit is free the block is still part of the free heap
++ * space. */
++static size_t xBlockAllocatedBit = 0;
++
++/*-----------------------------------------------------------*/
++
++void * pvPortMalloc( size_t xWantedSize )
++{
++    BlockLink_t * pxBlock, * pxPreviousBlock, * pxNewBlockLink;
++    void * pvReturn = NULL;
++
++    vTaskSuspendAll();
++    {
++        /* If this is the first call to malloc then the heap will require
++         * initialisation to setup the list of free blocks. */
++        if( pxEnd == NULL )
++        {
++            prvHeapInit();
++        }
++
++        /* Check the requested block size is not so large that the top bit is
++         * set.  The top bit of the block size member of the BlockLink_t structure
++         * is used to determine who owns the block - the application or the
++         * kernel, so it must be free. */
++        if( ( xWantedSize & xBlockAllocatedBit ) == 0 )
++        {
++            /* The wanted size must be increased so it can contain a BlockLink_t
++             * structure in addition to the requested amount of bytes. */
++            if( ( xWantedSize > 0 ) &&
++                ( ( xWantedSize + xHeapStructSize ) >  xWantedSize ) ) /* Overflow check */
++            {
++                xWantedSize += xHeapStructSize;
++
++                /* Ensure that blocks are always aligned. */
++                if( ( xWantedSize & portBYTE_ALIGNMENT_MASK ) != 0x00 )
++                {
++                    /* Byte alignment required. Check for overflow. */
++                    if( ( xWantedSize + ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) ) )
++                            > xWantedSize )
++                    {
++                        xWantedSize += ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) );
++                        configASSERT( ( xWantedSize & portBYTE_ALIGNMENT_MASK ) == 0 );
++                    }
++                    else
++                    {
++                        xWantedSize = 0;
++                    }
++                }
++            }
++            else
++            {
++                xWantedSize = 0;
++            }
++
++            if( ( xWantedSize > 0 ) && ( xWantedSize <= xFreeBytesRemaining ) )
++            {
++                /* Traverse the list from the start (lowest address) block until
++                 * one of adequate size is found. */
++                pxPreviousBlock = &xStart;
++                pxBlock = xStart.pxNextFreeBlock;
++
++                while( ( pxBlock->xBlockSize < xWantedSize ) && ( pxBlock->pxNextFreeBlock != NULL ) )
++                {
++                    pxPreviousBlock = pxBlock;
++                    pxBlock = pxBlock->pxNextFreeBlock;
++                }
++
++                /* If the end marker was reached then a block of adequate size
++                 * was not found. */
++                if( pxBlock != pxEnd )
++                {
++                    /* Return the memory space pointed to - jumping over the
++                     * BlockLink_t structure at its start. */
++                    pvReturn = ( void * ) ( ( ( uint8_t * ) pxPreviousBlock->pxNextFreeBlock ) + xHeapStructSize );
++
++                    /* This block is being returned for use so must be taken out
++                     * of the list of free blocks. */
++                    pxPreviousBlock->pxNextFreeBlock = pxBlock->pxNextFreeBlock;
++
++                    /* If the block is larger than required it can be split into
++                     * two. */
++                    if( ( pxBlock->xBlockSize - xWantedSize ) > heapMINIMUM_BLOCK_SIZE )
++                    {
++                        /* This block is to be split into two.  Create a new
++                         * block following the number of bytes requested. The void
++                         * cast is used to prevent byte alignment warnings from the
++                         * compiler. */
++                        pxNewBlockLink = ( void * ) ( ( ( uint8_t * ) pxBlock ) + xWantedSize );
++                        configASSERT( ( ( ( size_t ) pxNewBlockLink ) & portBYTE_ALIGNMENT_MASK ) == 0 );
++
++                        /* Calculate the sizes of two blocks split from the
++                         * single block. */
++                        pxNewBlockLink->xBlockSize = pxBlock->xBlockSize - xWantedSize;
++                        pxBlock->xBlockSize = xWantedSize;
++
++                        /* Insert the new block into the list of free blocks. */
++                        prvInsertBlockIntoFreeList( pxNewBlockLink );
++                    }
++
++                    xFreeBytesRemaining -= pxBlock->xBlockSize;
++
++                    if( xFreeBytesRemaining < xMinimumEverFreeBytesRemaining )
++                    {
++                        xMinimumEverFreeBytesRemaining = xFreeBytesRemaining;
++                    }
++
++                    /* The block is being returned - it is allocated and owned
++                     * by the application and has no "next" block. */
++                    pxBlock->xBlockSize |= xBlockAllocatedBit;
++                    pxBlock->pxNextFreeBlock = NULL;
++                    xNumberOfSuccessfulAllocations++;
++                }
++            }
++        }
++
++    }
++    ( void ) xTaskResumeAll();
++
++    #if ( configUSE_MALLOC_FAILED_HOOK == 1 )
++        {
++            if( pvReturn == NULL )
++            {
++                extern void vApplicationMallocFailedHook( void );
++                vApplicationMallocFailedHook();
++            }
++        }
++    #endif /* if ( configUSE_MALLOC_FAILED_HOOK == 1 ) */
++
++    configASSERT( ( ( ( size_t ) pvReturn ) & ( size_t ) portBYTE_ALIGNMENT_MASK ) == 0 );
++    return pvReturn;
++}
++/*-----------------------------------------------------------*/
++
++void vPortFree( void * pv )
++{
++    uint8_t * puc = ( uint8_t * ) pv;
++    BlockLink_t * pxLink;
++
++    if( pv != NULL )
++    {
++        /* The memory being freed will have an BlockLink_t structure immediately
++         * before it. */
++        puc -= xHeapStructSize;
++
++        /* This casting is to keep the compiler from issuing warnings. */
++        pxLink = ( void * ) puc;
++
++        /* Check the block is actually allocated. */
++        configASSERT( ( pxLink->xBlockSize & xBlockAllocatedBit ) != 0 );
++        configASSERT( pxLink->pxNextFreeBlock == NULL );
++
++        if( ( pxLink->xBlockSize & xBlockAllocatedBit ) != 0 )
++        {
++            if( pxLink->pxNextFreeBlock == NULL )
++            {
++                /* The block is being returned to the heap - it is no longer
++                 * allocated. */
++                pxLink->xBlockSize &= ~xBlockAllocatedBit;
++
++                vTaskSuspendAll();
++                {
++                    /* Add this block to the list of free blocks. */
++                    xFreeBytesRemaining += pxLink->xBlockSize;
++                    prvInsertBlockIntoFreeList( ( ( BlockLink_t * ) pxLink ) );
++                    xNumberOfSuccessfulFrees++;
++                }
++                ( void ) xTaskResumeAll();
++            }
++        }
++    }
++}
++/*-----------------------------------------------------------*/
++
++size_t xPortGetFreeHeapSize( void )
++{
++    return xFreeBytesRemaining;
++}
++/*-----------------------------------------------------------*/
++
++size_t xPortGetMinimumEverFreeHeapSize( void )
++{
++    return xMinimumEverFreeBytesRemaining;
++}
++/*-----------------------------------------------------------*/
++
++void vPortInitialiseBlocks( void )
++{
++    /* This just exists to keep the linker quiet. */
++}
++/*-----------------------------------------------------------*/
++
++static void prvHeapInit( void ) /* PRIVILEGED_FUNCTION */
++{
++    BlockLink_t * pxFirstFreeBlock;
++    uint8_t * pucAlignedHeap;
++    size_t uxAddress;
++    size_t xTotalHeapSize = configTOTAL_HEAP_SIZE;
++
++    /* Ensure the heap starts on a correctly aligned boundary. */
++    uxAddress = ( size_t ) ucHeap;
++
++    if( ( uxAddress & portBYTE_ALIGNMENT_MASK ) != 0 )
++    {
++        uxAddress += ( portBYTE_ALIGNMENT - 1 );
++        uxAddress &= ~( ( size_t ) portBYTE_ALIGNMENT_MASK );
++        xTotalHeapSize -= uxAddress - ( size_t ) ucHeap;
++    }
++
++    pucAlignedHeap = ( uint8_t * ) uxAddress;
++
++    /* xStart is used to hold a pointer to the first item in the list of free
++     * blocks.  The void cast is used to prevent compiler warnings. */
++    xStart.pxNextFreeBlock = ( void * ) pucAlignedHeap;
++    xStart.xBlockSize = ( size_t ) 0;
++
++    /* pxEnd is used to mark the end of the list of free blocks and is inserted
++     * at the end of the heap space. */
++    uxAddress = ( ( size_t ) pucAlignedHeap ) + xTotalHeapSize;
++    uxAddress -= xHeapStructSize;
++    uxAddress &= ~( ( size_t ) portBYTE_ALIGNMENT_MASK );
++    pxEnd = ( void * ) uxAddress;
++    pxEnd->xBlockSize = 0;
++    pxEnd->pxNextFreeBlock = NULL;
++
++    /* To start with there is a single free block that is sized to take up the
++     * entire heap space, minus the space taken by pxEnd. */
++    pxFirstFreeBlock = ( void * ) pucAlignedHeap;
++    pxFirstFreeBlock->xBlockSize = uxAddress - ( size_t ) pxFirstFreeBlock;
++    pxFirstFreeBlock->pxNextFreeBlock = pxEnd;
++
++    /* Only one block exists - and it covers the entire usable heap space. */
++    xMinimumEverFreeBytesRemaining = pxFirstFreeBlock->xBlockSize;
++    xFreeBytesRemaining = pxFirstFreeBlock->xBlockSize;
++
++    /* Work out the position of the top bit in a size_t variable. */
++    xBlockAllocatedBit = ( ( size_t ) 1 ) << ( ( sizeof( size_t ) * heapBITS_PER_BYTE ) - 1 );
++}
++/*-----------------------------------------------------------*/
++
++static void prvInsertBlockIntoFreeList( BlockLink_t * pxBlockToInsert ) /* PRIVILEGED_FUNCTION */
++{
++    BlockLink_t * pxIterator;
++    uint8_t * puc;
++
++    /* Iterate through the list until a block is found that has a higher address
++     * than the block being inserted. */
++    for( pxIterator = &xStart; pxIterator->pxNextFreeBlock < pxBlockToInsert; pxIterator = pxIterator->pxNextFreeBlock )
++    {
++        /* Nothing to do here, just iterate to the right position. */
++    }
++
++    /* Do the block being inserted, and the block it is being inserted after
++     * make a contiguous block of memory? */
++    puc = ( uint8_t * ) pxIterator;
++
++    if( ( puc + pxIterator->xBlockSize ) == ( uint8_t * ) pxBlockToInsert )
++    {
++        pxIterator->xBlockSize += pxBlockToInsert->xBlockSize;
++        pxBlockToInsert = pxIterator;
++    }
++
++    /* Do the block being inserted, and the block it is being inserted before
++     * make a contiguous block of memory? */
++    puc = ( uint8_t * ) pxBlockToInsert;
++
++    if( ( puc + pxBlockToInsert->xBlockSize ) == ( uint8_t * ) pxIterator->pxNextFreeBlock )
++    {
++        if( pxIterator->pxNextFreeBlock != pxEnd )
++        {
++            /* Form one big block from the two blocks. */
++            pxBlockToInsert->xBlockSize += pxIterator->pxNextFreeBlock->xBlockSize;
++            pxBlockToInsert->pxNextFreeBlock = pxIterator->pxNextFreeBlock->pxNextFreeBlock;
++        }
++        else
++        {
++            pxBlockToInsert->pxNextFreeBlock = pxEnd;
++        }
++    }
++    else
++    {
++        pxBlockToInsert->pxNextFreeBlock = pxIterator->pxNextFreeBlock;
++    }
++
++    /* If the block being inserted plugged a gab, so was merged with the block
++     * before and the block after, then it's pxNextFreeBlock pointer will have
++     * already been set, and should not be set here as that would make it point
++     * to itself. */
++    if( pxIterator != pxBlockToInsert )
++    {
++        pxIterator->pxNextFreeBlock = pxBlockToInsert;
++    }
++}
++/*-----------------------------------------------------------*/
++
++void vPortGetHeapStats( HeapStats_t * pxHeapStats )
++{
++    BlockLink_t * pxBlock;
++    size_t xBlocks = 0, xMaxSize = 0, xMinSize = portMAX_DELAY; /* portMAX_DELAY used as a portable way of getting the maximum value. */
++
++    vTaskSuspendAll();
++    {
++        pxBlock = xStart.pxNextFreeBlock;
++
++        /* pxBlock will be NULL if the heap has not been initialised.  The heap
++         * is initialised automatically when the first allocation is made. */
++        if( pxBlock != NULL )
++        {
++            do
++            {
++                /* Increment the number of blocks and record the largest block seen
++                 * so far. */
++                xBlocks++;
++
++                if( pxBlock->xBlockSize > xMaxSize )
++                {
++                    xMaxSize = pxBlock->xBlockSize;
++                }
++
++                if( pxBlock->xBlockSize < xMinSize )
++                {
++                    xMinSize = pxBlock->xBlockSize;
++                }
++
++                /* Move to the next block in the chain until the last block is
++                 * reached. */
++                pxBlock = pxBlock->pxNextFreeBlock;
++            } while( pxBlock != pxEnd );
++        }
++    }
++    ( void ) xTaskResumeAll();
++
++    pxHeapStats->xSizeOfLargestFreeBlockInBytes = xMaxSize;
++    pxHeapStats->xSizeOfSmallestFreeBlockInBytes = xMinSize;
++    pxHeapStats->xNumberOfFreeBlocks = xBlocks;
++
++    taskENTER_CRITICAL();
++    {
++        pxHeapStats->xAvailableHeapSpaceInBytes = xFreeBytesRemaining;
++        pxHeapStats->xNumberOfSuccessfulAllocations = xNumberOfSuccessfulAllocations;
++        pxHeapStats->xNumberOfSuccessfulFrees = xNumberOfSuccessfulFrees;
++        pxHeapStats->xMinimumEverFreeBytesRemaining = xMinimumEverFreeBytesRemaining;
++    }
++    taskEXIT_CRITICAL();
++}
+diff --git a/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/MemMang/heap_5.c b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/MemMang/heap_5.c
+new file mode 100644
+index 0000000000..7fadbd4b0f
+--- /dev/null
++++ b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/MemMang/heap_5.c
+@@ -0,0 +1,506 @@
++/*
++ * FreeRTOS Kernel V10.4.6
++ * 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
++ *
++ */
++
++/*
++ * A sample implementation of pvPortMalloc() that allows the heap to be defined
++ * across multiple non-contigous blocks and combines (coalescences) adjacent
++ * memory blocks as they are freed.
++ *
++ * See heap_1.c, heap_2.c, heap_3.c and heap_4.c for alternative
++ * implementations, and the memory management pages of https://www.FreeRTOS.org
++ * for more information.
++ *
++ * Usage notes:
++ *
++ * vPortDefineHeapRegions() ***must*** be called before pvPortMalloc().
++ * pvPortMalloc() will be called if any task objects (tasks, queues, event
++ * groups, etc.) are created, therefore vPortDefineHeapRegions() ***must*** be
++ * called before any other objects are defined.
++ *
++ * vPortDefineHeapRegions() takes a single parameter.  The parameter is an array
++ * of HeapRegion_t structures.  HeapRegion_t is defined in portable.h as
++ *
++ * typedef struct HeapRegion
++ * {
++ *  uint8_t *pucStartAddress; << Start address of a block of memory that will be part of the heap.
++ *  size_t xSizeInBytes;      << Size of the block of memory.
++ * } HeapRegion_t;
++ *
++ * The array is terminated using a NULL zero sized region definition, and the
++ * memory regions defined in the array ***must*** appear in address order from
++ * low address to high address.  So the following is a valid example of how
++ * to use the function.
++ *
++ * HeapRegion_t xHeapRegions[] =
++ * {
++ *  { ( uint8_t * ) 0x80000000UL, 0x10000 }, << Defines a block of 0x10000 bytes starting at address 0x80000000
++ *  { ( uint8_t * ) 0x90000000UL, 0xa0000 }, << Defines a block of 0xa0000 bytes starting at address of 0x90000000
++ *  { NULL, 0 }                << Terminates the array.
++ * };
++ *
++ * vPortDefineHeapRegions( xHeapRegions ); << Pass the array into vPortDefineHeapRegions().
++ *
++ * Note 0x80000000 is the lower address so appears in the array first.
++ *
++ */
++#include <stdlib.h>
++
++#include "FreeRTOS.h"
++#include "task.h"
++
++#if ( configSUPPORT_DYNAMIC_ALLOCATION == 0 )
++    #error This file must not be used if configSUPPORT_DYNAMIC_ALLOCATION is 0
++#endif
++
++/* Block sizes must not get too small. */
++#define heapMINIMUM_BLOCK_SIZE    ( ( size_t ) ( xHeapStructSize << 1 ) )
++
++/* Assumes 8bit bytes! */
++#define heapBITS_PER_BYTE         ( ( size_t ) 8 )
++
++/* Define the linked list structure.  This is used to link free blocks in order
++ * of their memory address. */
++typedef struct A_BLOCK_LINK
++{
++    struct A_BLOCK_LINK * pxNextFreeBlock; /*<< The next free block in the list. */
++    size_t xBlockSize;                     /*<< The size of the free block. */
++} BlockLink_t;
++
++/*-----------------------------------------------------------*/
++
++/*
++ * Inserts a block of memory that is being freed into the correct position in
++ * the list of free memory blocks.  The block being freed will be merged with
++ * the block in front it and/or the block behind it if the memory blocks are
++ * adjacent to each other.
++ */
++static void prvInsertBlockIntoFreeList( BlockLink_t * pxBlockToInsert );
++
++/*-----------------------------------------------------------*/
++
++/* The size of the structure placed at the beginning of each allocated memory
++ * block must by correctly byte aligned. */
++static const size_t xHeapStructSize = ( sizeof( BlockLink_t ) + ( ( size_t ) ( portBYTE_ALIGNMENT - 1 ) ) ) & ~( ( size_t ) portBYTE_ALIGNMENT_MASK );
++
++/* Create a couple of list links to mark the start and end of the list. */
++static BlockLink_t xStart, * pxEnd = NULL;
++
++/* Keeps track of the number of calls to allocate and free memory as well as the
++ * number of free bytes remaining, but says nothing about fragmentation. */
++static size_t xFreeBytesRemaining = 0U;
++static size_t xMinimumEverFreeBytesRemaining = 0U;
++static size_t xNumberOfSuccessfulAllocations = 0;
++static size_t xNumberOfSuccessfulFrees = 0;
++
++/* Gets set to the top bit of an size_t type.  When this bit in the xBlockSize
++ * member of an BlockLink_t structure is set then the block belongs to the
++ * application.  When the bit is free the block is still part of the free heap
++ * space. */
++static size_t xBlockAllocatedBit = 0;
++
++/*-----------------------------------------------------------*/
++
++void * pvPortMalloc( size_t xWantedSize )
++{
++    BlockLink_t * pxBlock, * pxPreviousBlock, * pxNewBlockLink;
++    void * pvReturn = NULL;
++
++    /* The heap must be initialised before the first call to
++     * prvPortMalloc(). */
++    configASSERT( pxEnd );
++
++    vTaskSuspendAll();
++    {
++        /* Check the requested block size is not so large that the top bit is
++         * set.  The top bit of the block size member of the BlockLink_t structure
++         * is used to determine who owns the block - the application or the
++         * kernel, so it must be free. */
++        if( ( xWantedSize & xBlockAllocatedBit ) == 0 )
++        {
++            /* The wanted size is increased so it can contain a BlockLink_t
++             * structure in addition to the requested amount of bytes. */
++            if( ( xWantedSize > 0 ) &&
++                ( ( xWantedSize + xHeapStructSize ) >  xWantedSize ) ) /* Overflow check */
++            {
++                xWantedSize += xHeapStructSize;
++
++                /* Ensure that blocks are always aligned */
++                if( ( xWantedSize & portBYTE_ALIGNMENT_MASK ) != 0x00 )
++                {
++                    /* Byte alignment required. Check for overflow */
++                    if( ( xWantedSize + ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) ) ) >
++                         xWantedSize )
++                    {
++                        xWantedSize += ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) );
++                    }
++                    else
++                    {
++                        xWantedSize = 0;
++                    }
++                }
++            }
++            else
++            {
++                xWantedSize = 0;
++            }
++
++            if( ( xWantedSize > 0 ) && ( xWantedSize <= xFreeBytesRemaining ) )
++            {
++                /* Traverse the list from the start (lowest address) block until
++                 * one of adequate size is found. */
++                pxPreviousBlock = &xStart;
++                pxBlock = xStart.pxNextFreeBlock;
++
++                while( ( pxBlock->xBlockSize < xWantedSize ) && ( pxBlock->pxNextFreeBlock != NULL ) )
++                {
++                    pxPreviousBlock = pxBlock;
++                    pxBlock = pxBlock->pxNextFreeBlock;
++                }
++
++                /* If the end marker was reached then a block of adequate size
++                 * was not found. */
++                if( pxBlock != pxEnd )
++                {
++                    /* Return the memory space pointed to - jumping over the
++                     * BlockLink_t structure at its start. */
++                    pvReturn = ( void * ) ( ( ( uint8_t * ) pxPreviousBlock->pxNextFreeBlock ) + xHeapStructSize );
++
++                    /* This block is being returned for use so must be taken out
++                     * of the list of free blocks. */
++                    pxPreviousBlock->pxNextFreeBlock = pxBlock->pxNextFreeBlock;
++
++                    /* If the block is larger than required it can be split into
++                     * two. */
++                    if( ( pxBlock->xBlockSize - xWantedSize ) > heapMINIMUM_BLOCK_SIZE )
++                    {
++                        /* This block is to be split into two.  Create a new
++                         * block following the number of bytes requested. The void
++                         * cast is used to prevent byte alignment warnings from the
++                         * compiler. */
++                        pxNewBlockLink = ( void * ) ( ( ( uint8_t * ) pxBlock ) + xWantedSize );
++
++                        /* Calculate the sizes of two blocks split from the
++                         * single block. */
++                        pxNewBlockLink->xBlockSize = pxBlock->xBlockSize - xWantedSize;
++                        pxBlock->xBlockSize = xWantedSize;
++
++                        /* Insert the new block into the list of free blocks. */
++                        prvInsertBlockIntoFreeList( ( pxNewBlockLink ) );
++                    }
++
++                    xFreeBytesRemaining -= pxBlock->xBlockSize;
++
++                    if( xFreeBytesRemaining < xMinimumEverFreeBytesRemaining )
++                    {
++                        xMinimumEverFreeBytesRemaining = xFreeBytesRemaining;
++                    }
++
++                    /* The block is being returned - it is allocated and owned
++                     * by the application and has no "next" block. */
++                    pxBlock->xBlockSize |= xBlockAllocatedBit;
++                    pxBlock->pxNextFreeBlock = NULL;
++                    xNumberOfSuccessfulAllocations++;
++                }
++            }
++        }
++
++    }
++    ( void ) xTaskResumeAll();
++
++    #if ( configUSE_MALLOC_FAILED_HOOK == 1 )
++        {
++            if( pvReturn == NULL )
++            {
++                extern void vApplicationMallocFailedHook( void );
++                vApplicationMallocFailedHook();
++            }
++        }
++    #endif /* if ( configUSE_MALLOC_FAILED_HOOK == 1 ) */
++
++    return pvReturn;
++}
++/*-----------------------------------------------------------*/
++
++void vPortFree( void * pv )
++{
++    uint8_t * puc = ( uint8_t * ) pv;
++    BlockLink_t * pxLink;
++
++    if( pv != NULL )
++    {
++        /* The memory being freed will have an BlockLink_t structure immediately
++         * before it. */
++        puc -= xHeapStructSize;
++
++        /* This casting is to keep the compiler from issuing warnings. */
++        pxLink = ( void * ) puc;
++
++        /* Check the block is actually allocated. */
++        configASSERT( ( pxLink->xBlockSize & xBlockAllocatedBit ) != 0 );
++        configASSERT( pxLink->pxNextFreeBlock == NULL );
++
++        if( ( pxLink->xBlockSize & xBlockAllocatedBit ) != 0 )
++        {
++            if( pxLink->pxNextFreeBlock == NULL )
++            {
++                /* The block is being returned to the heap - it is no longer
++                 * allocated. */
++                pxLink->xBlockSize &= ~xBlockAllocatedBit;
++
++                vTaskSuspendAll();
++                {
++                    /* Add this block to the list of free blocks. */
++                    xFreeBytesRemaining += pxLink->xBlockSize;
++                    prvInsertBlockIntoFreeList( ( ( BlockLink_t * ) pxLink ) );
++                    xNumberOfSuccessfulFrees++;
++                }
++                ( void ) xTaskResumeAll();
++            }
++        }
++    }
++}
++/*-----------------------------------------------------------*/
++
++size_t xPortGetFreeHeapSize( void )
++{
++    return xFreeBytesRemaining;
++}
++/*-----------------------------------------------------------*/
++
++size_t xPortGetMinimumEverFreeHeapSize( void )
++{
++    return xMinimumEverFreeBytesRemaining;
++}
++/*-----------------------------------------------------------*/
++
++static void prvInsertBlockIntoFreeList( BlockLink_t * pxBlockToInsert )
++{
++    BlockLink_t * pxIterator;
++    uint8_t * puc;
++
++    /* Iterate through the list until a block is found that has a higher address
++     * than the block being inserted. */
++    for( pxIterator = &xStart; pxIterator->pxNextFreeBlock < pxBlockToInsert; pxIterator = pxIterator->pxNextFreeBlock )
++    {
++        /* Nothing to do here, just iterate to the right position. */
++    }
++
++    /* Do the block being inserted, and the block it is being inserted after
++     * make a contiguous block of memory? */
++    puc = ( uint8_t * ) pxIterator;
++
++    if( ( puc + pxIterator->xBlockSize ) == ( uint8_t * ) pxBlockToInsert )
++    {
++        pxIterator->xBlockSize += pxBlockToInsert->xBlockSize;
++        pxBlockToInsert = pxIterator;
++    }
++
++    /* Do the block being inserted, and the block it is being inserted before
++     * make a contiguous block of memory? */
++    puc = ( uint8_t * ) pxBlockToInsert;
++
++    if( ( puc + pxBlockToInsert->xBlockSize ) == ( uint8_t * ) pxIterator->pxNextFreeBlock )
++    {
++        if( pxIterator->pxNextFreeBlock != pxEnd )
++        {
++            /* Form one big block from the two blocks. */
++            pxBlockToInsert->xBlockSize += pxIterator->pxNextFreeBlock->xBlockSize;
++            pxBlockToInsert->pxNextFreeBlock = pxIterator->pxNextFreeBlock->pxNextFreeBlock;
++        }
++        else
++        {
++            pxBlockToInsert->pxNextFreeBlock = pxEnd;
++        }
++    }
++    else
++    {
++        pxBlockToInsert->pxNextFreeBlock = pxIterator->pxNextFreeBlock;
++    }
++
++    /* If the block being inserted plugged a gab, so was merged with the block
++     * before and the block after, then it's pxNextFreeBlock pointer will have
++     * already been set, and should not be set here as that would make it point
++     * to itself. */
++    if( pxIterator != pxBlockToInsert )
++    {
++        pxIterator->pxNextFreeBlock = pxBlockToInsert;
++    }
++}
++/*-----------------------------------------------------------*/
++
++void vPortDefineHeapRegions( const HeapRegion_t * const pxHeapRegions )
++{
++    BlockLink_t * pxFirstFreeBlockInRegion = NULL, * pxPreviousFreeBlock;
++    size_t xAlignedHeap;
++    size_t xTotalRegionSize, xTotalHeapSize = 0;
++    BaseType_t xDefinedRegions = 0;
++    size_t xAddress;
++    const HeapRegion_t * pxHeapRegion;
++
++    /* Can only call once! */
++    configASSERT( pxEnd == NULL );
++
++    pxHeapRegion = &( pxHeapRegions[ xDefinedRegions ] );
++
++    while( pxHeapRegion->xSizeInBytes > 0 )
++    {
++        xTotalRegionSize = pxHeapRegion->xSizeInBytes;
++
++        /* Ensure the heap region starts on a correctly aligned boundary. */
++        xAddress = ( size_t ) pxHeapRegion->pucStartAddress;
++
++        if( ( xAddress & portBYTE_ALIGNMENT_MASK ) != 0 )
++        {
++            xAddress += ( portBYTE_ALIGNMENT - 1 );
++            xAddress &= ~portBYTE_ALIGNMENT_MASK;
++
++            /* Adjust the size for the bytes lost to alignment. */
++            xTotalRegionSize -= xAddress - ( size_t ) pxHeapRegion->pucStartAddress;
++        }
++
++        xAlignedHeap = xAddress;
++
++        /* Set xStart if it has not already been set. */
++        if( xDefinedRegions == 0 )
++        {
++            /* xStart is used to hold a pointer to the first item in the list of
++             *  free blocks.  The void cast is used to prevent compiler warnings. */
++            xStart.pxNextFreeBlock = ( BlockLink_t * ) xAlignedHeap;
++            xStart.xBlockSize = ( size_t ) 0;
++        }
++        else
++        {
++            /* Should only get here if one region has already been added to the
++             * heap. */
++            configASSERT( pxEnd != NULL );
++
++            /* Check blocks are passed in with increasing start addresses. */
++            configASSERT( xAddress > ( size_t ) pxEnd );
++        }
++
++        /* Remember the location of the end marker in the previous region, if
++         * any. */
++        pxPreviousFreeBlock = pxEnd;
++
++        /* pxEnd is used to mark the end of the list of free blocks and is
++         * inserted at the end of the region space. */
++        xAddress = xAlignedHeap + xTotalRegionSize;
++        xAddress -= xHeapStructSize;
++        xAddress &= ~portBYTE_ALIGNMENT_MASK;
++        pxEnd = ( BlockLink_t * ) xAddress;
++        pxEnd->xBlockSize = 0;
++        pxEnd->pxNextFreeBlock = NULL;
++
++        /* To start with there is a single free block in this region that is
++         * sized to take up the entire heap region minus the space taken by the
++         * free block structure. */
++        pxFirstFreeBlockInRegion = ( BlockLink_t * ) xAlignedHeap;
++        pxFirstFreeBlockInRegion->xBlockSize = xAddress - ( size_t ) pxFirstFreeBlockInRegion;
++        pxFirstFreeBlockInRegion->pxNextFreeBlock = pxEnd;
++
++        /* If this is not the first region that makes up the entire heap space
++         * then link the previous region to this region. */
++        if( pxPreviousFreeBlock != NULL )
++        {
++            pxPreviousFreeBlock->pxNextFreeBlock = pxFirstFreeBlockInRegion;
++        }
++
++        xTotalHeapSize += pxFirstFreeBlockInRegion->xBlockSize;
++
++        /* Move onto the next HeapRegion_t structure. */
++        xDefinedRegions++;
++        pxHeapRegion = &( pxHeapRegions[ xDefinedRegions ] );
++    }
++
++    xMinimumEverFreeBytesRemaining = xTotalHeapSize;
++    xFreeBytesRemaining = xTotalHeapSize;
++
++    /* Check something was actually defined before it is accessed. */
++    configASSERT( xTotalHeapSize );
++
++    /* Work out the position of the top bit in a size_t variable. */
++    xBlockAllocatedBit = ( ( size_t ) 1 ) << ( ( sizeof( size_t ) * heapBITS_PER_BYTE ) - 1 );
++}
++/*-----------------------------------------------------------*/
++
++void vPortGetHeapStats( HeapStats_t * pxHeapStats )
++{
++    BlockLink_t * pxBlock;
++    size_t xBlocks = 0, xMaxSize = 0, xMinSize = portMAX_DELAY; /* portMAX_DELAY used as a portable way of getting the maximum value. */
++
++    vTaskSuspendAll();
++    {
++        pxBlock = xStart.pxNextFreeBlock;
++
++        /* pxBlock will be NULL if the heap has not been initialised.  The heap
++         * is initialised automatically when the first allocation is made. */
++        if( pxBlock != NULL )
++        {
++            do
++            {
++                /* Increment the number of blocks and record the largest block seen
++                 * so far. */
++                xBlocks++;
++
++                if( pxBlock->xBlockSize > xMaxSize )
++                {
++                    xMaxSize = pxBlock->xBlockSize;
++                }
++
++                /* Heap five will have a zero sized block at the end of each
++                 * each region - the block is only used to link to the next
++                 * heap region so it not a real block. */
++                if( pxBlock->xBlockSize != 0 )
++                {
++                    if( pxBlock->xBlockSize < xMinSize )
++                    {
++                        xMinSize = pxBlock->xBlockSize;
++                    }
++                }
++
++                /* Move to the next block in the chain until the last block is
++                 * reached. */
++                pxBlock = pxBlock->pxNextFreeBlock;
++            } while( pxBlock != pxEnd );
++        }
++    }
++    ( void ) xTaskResumeAll();
++
++    pxHeapStats->xSizeOfLargestFreeBlockInBytes = xMaxSize;
++    pxHeapStats->xSizeOfSmallestFreeBlockInBytes = xMinSize;
++    pxHeapStats->xNumberOfFreeBlocks = xBlocks;
++
++    taskENTER_CRITICAL();
++    {
++        pxHeapStats->xAvailableHeapSpaceInBytes = xFreeBytesRemaining;
++        pxHeapStats->xNumberOfSuccessfulAllocations = xNumberOfSuccessfulAllocations;
++        pxHeapStats->xNumberOfSuccessfulFrees = xNumberOfSuccessfulFrees;
++        pxHeapStats->xMinimumEverFreeBytesRemaining = xMinimumEverFreeBytesRemaining;
++    }
++    taskEXIT_CRITICAL();
++}
+diff --git a/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/port_common.c b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/port_common.c
+new file mode 100644
+index 0000000000..9d8159f588
+--- /dev/null
++++ b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/port_common.c
+@@ -0,0 +1,203 @@
++/*
++ * SPDX-FileCopyrightText: 2021 Espressif Systems (Shanghai) CO LTD
++ *
++ * SPDX-License-Identifier: Apache-2.0
++ */
++
++#include <string.h>
++#include "FreeRTOS.h"
++#include "task.h"
++#include "portmacro.h"
++#include "esp_system.h"
++#include "esp_heap_caps_init.h"
++#include "esp_int_wdt.h"
++#include "esp_task_wdt.h"
++#include "esp_task.h"
++#include "esp_private/crosscore_int.h"
++#include "esp_private/startup_internal.h"    /* Required by g_spiram_ok. [refactor-todo] for g_spiram_ok */
++#include "esp_log.h"
++#include "soc/soc_memory_types.h"
++#include "soc/dport_access.h"
++#include "sdkconfig.h"
++
++#if CONFIG_IDF_TARGET_ESP32
++#include "esp32/spiram.h"
++#elif CONFIG_IDF_TARGET_ESP32S2
++#include "esp32s2/spiram.h"
++#elif CONFIG_IDF_TARGET_ESP32S3
++#include "esp32s3/spiram.h"
++#elif CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32H2
++// SPIRAM is not supported on ESP32-C3
++#endif
++
++#if CONFIG_SPIRAM_MALLOC_RESERVE_INTERNAL
++static const char* TAG = "cpu_start";
++#endif
++
++/* Architecture-agnostic parts of the FreeRTOS ESP-IDF port layer can go here.
++ *
++ * The actual call flow will be to call esp_startup_start_app() in <ARCH>/port.c,
++ * which will then call esp_startup_start_app_common()
++ */
++
++// Duplicate of inaccessible xSchedulerRunning; needed at startup to avoid counting nesting
++volatile unsigned port_xSchedulerRunning[portNUM_PROCESSORS] = {0};
++
++// For now, running FreeRTOS on one core and a bare metal on the other (or other OSes)
++// is not supported. For now CONFIG_FREERTOS_UNICORE and CONFIG_ESP_SYSTEM_SINGLE_CORE_MODE
++// should mirror each other's values.
++//
++// And since this should be true, we can just check for CONFIG_FREERTOS_UNICORE.
++#if CONFIG_FREERTOS_UNICORE != CONFIG_ESP_SYSTEM_SINGLE_CORE_MODE
++    #error "FreeRTOS and system configuration mismatch regarding the use of multiple cores."
++#endif
++
++static void main_task(void* args);
++
++#ifdef CONFIG_ESP_SYSTEM_GDBSTUB_RUNTIME
++void esp_gdbstub_init(void);
++#endif // CONFIG_ESP_SYSTEM_GDBSTUB_RUNTIME
++
++extern void app_main(void);
++
++void esp_startup_start_app_common(void)
++{
++#if CONFIG_ESP_INT_WDT
++    esp_int_wdt_init();
++    //Initialize the interrupt watch dog for CPU0.
++    esp_int_wdt_cpu_init();
++#endif
++
++    esp_crosscore_int_init();
++
++#ifdef CONFIG_ESP_SYSTEM_GDBSTUB_RUNTIME
++    esp_gdbstub_init();
++#endif // CONFIG_ESP_SYSTEM_GDBSTUB_RUNTIME
++
++#ifdef CONFIG_IDF_RTOS_RTTHREAD
++    app_main();
++#else
++    portBASE_TYPE res = xTaskCreatePinnedToCore(&main_task, "main",
++                                                ESP_TASK_MAIN_STACK, NULL,
++                                                ESP_TASK_MAIN_PRIO, NULL, ESP_TASK_MAIN_CORE);
++    assert(res == pdTRUE);
++    (void)res;
++#endif
++
++}
++
++static void main_task(void* args)
++{
++#if !CONFIG_FREERTOS_UNICORE
++    // Wait for FreeRTOS initialization to finish on APP CPU, before replacing its startup stack
++    while (port_xSchedulerRunning[1] == 0) {
++        ;
++    }
++#endif
++
++    // [refactor-todo] check if there is a way to move the following block to esp_system startup
++    heap_caps_enable_nonos_stack_heaps();
++
++    // Now we have startup stack RAM available for heap, enable any DMA pool memory
++#if CONFIG_SPIRAM_MALLOC_RESERVE_INTERNAL
++    if (g_spiram_ok) {
++        esp_err_t r = esp_spiram_reserve_dma_pool(CONFIG_SPIRAM_MALLOC_RESERVE_INTERNAL);
++        if (r != ESP_OK) {
++            ESP_EARLY_LOGE(TAG, "Could not reserve internal/DMA pool (error 0x%x)", r);
++            abort();
++        }
++    }
++#endif
++
++    //Initialize task wdt if configured to do so
++#ifdef CONFIG_ESP_TASK_WDT_PANIC
++    ESP_ERROR_CHECK(esp_task_wdt_init(CONFIG_ESP_TASK_WDT_TIMEOUT_S, true));
++#elif CONFIG_ESP_TASK_WDT
++    ESP_ERROR_CHECK(esp_task_wdt_init(CONFIG_ESP_TASK_WDT_TIMEOUT_S, false));
++#endif
++
++    //Add IDLE 0 to task wdt
++#ifdef CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU0
++    TaskHandle_t idle_0 = xTaskGetIdleTaskHandleForCPU(0);
++    if(idle_0 != NULL){
++        ESP_ERROR_CHECK(esp_task_wdt_add(idle_0));
++    }
++#endif
++    //Add IDLE 1 to task wdt
++#ifdef CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU1
++    TaskHandle_t idle_1 = xTaskGetIdleTaskHandleForCPU(1);
++    if(idle_1 != NULL){
++        ESP_ERROR_CHECK(esp_task_wdt_add(idle_1));
++    }
++#endif
++
++    app_main();
++    vTaskDelete(NULL);
++}
++
++// -------------------- Heap Related -----------------------
++
++bool xPortCheckValidTCBMem(const void *ptr)
++{
++    return esp_ptr_internal(ptr) && esp_ptr_byte_accessible(ptr);
++}
++
++bool xPortcheckValidStackMem(const void *ptr)
++{
++#ifdef CONFIG_SPIRAM_ALLOW_STACK_EXTERNAL_MEMORY
++    return esp_ptr_byte_accessible(ptr);
++#else
++    return esp_ptr_internal(ptr) && esp_ptr_byte_accessible(ptr);
++#endif
++}
++
++// ------------- FreeRTOS Static Allocation ----------------
++
++/*
++This function is required by FreeRTOS when configSUPPORT_STATIC_ALLOCATION is
++enabled and is used by FreeRTOS to obtain memory for its IDLE tasks.
++
++Like the pvPortMallocTcbMem() and pvPortMallocStackMem() macros, TCB and stack
++memory MUST be placed in internal RAM.
++*/
++void vApplicationGetIdleTaskMemory(StaticTask_t **ppxIdleTaskTCBBuffer,
++                                   StackType_t **ppxIdleTaskStackBuffer,
++                                   uint32_t *pulIdleTaskStackSize )
++{
++    StaticTask_t *pxTCBBufferTemp;
++    StackType_t *pxStackBufferTemp;
++    //Allocate TCB and stack buffer in internal memory
++    pxTCBBufferTemp = pvPortMallocTcbMem(sizeof(StaticTask_t));
++    pxStackBufferTemp = pvPortMallocStackMem(configIDLE_TASK_STACK_SIZE);
++    assert(pxTCBBufferTemp != NULL);
++    assert(pxStackBufferTemp != NULL);
++    //Write back pointers
++    *ppxIdleTaskTCBBuffer = pxTCBBufferTemp;
++    *ppxIdleTaskStackBuffer = pxStackBufferTemp;
++    *pulIdleTaskStackSize = configIDLE_TASK_STACK_SIZE;
++}
++
++/*
++This function is required by FreeRTOS when configSUPPORT_STATIC_ALLOCATION is
++enabled and is used by the FreeRTOS Timer to obtain memory for its daemone task.
++
++
++Like the pvPortMallocTcbMem() and pvPortMallocStackMem() macros, TCB and stack
++memory MUST be placed in internal RAM.
++*/
++void vApplicationGetTimerTaskMemory(StaticTask_t **ppxTimerTaskTCBBuffer,
++                                    StackType_t **ppxTimerTaskStackBuffer,
++                                    uint32_t *pulTimerTaskStackSize )
++{
++    StaticTask_t *pxTCBBufferTemp;
++    StackType_t *pxStackBufferTemp;
++    //Allocate TCB and stack buffer in internal memory
++    pxTCBBufferTemp = pvPortMallocTcbMem(sizeof(StaticTask_t));
++    pxStackBufferTemp = pvPortMallocStackMem(configTIMER_TASK_STACK_DEPTH);
++    assert(pxTCBBufferTemp != NULL);
++    assert(pxStackBufferTemp != NULL);
++    //Write back pointers
++    *ppxTimerTaskTCBBuffer = pxTCBBufferTemp;
++    *ppxTimerTaskStackBuffer = pxStackBufferTemp;
++    *pulTimerTaskStackSize = configTIMER_TASK_STACK_DEPTH;
++}
+diff --git a/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/rt-thread/include/freertos/FreeRTOSConfig_arch.h b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/rt-thread/include/freertos/FreeRTOSConfig_arch.h
+new file mode 100644
+index 0000000000..a7d534343f
+--- /dev/null
++++ b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/rt-thread/include/freertos/FreeRTOSConfig_arch.h
+@@ -0,0 +1,105 @@
++/*
++    FreeRTOS V10 - Copyright (C) 2021 Real Time Engineers Ltd.
++    All rights reserved
++
++    VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
++
++    This file is part of the FreeRTOS distribution.
++
++    FreeRTOS is free software; you can redistribute it and/or modify it under
++    the terms of the GNU General Public License (version 2) as published by the
++    Free Software Foundation >>!AND MODIFIED BY!<< the FreeRTOS exception.
++
++	***************************************************************************
++    >>!   NOTE: The modification to the GPL is included to allow you to     !<<
++    >>!   distribute a combined work that includes FreeRTOS without being   !<<
++    >>!   obliged to provide the source code for proprietary components     !<<
++    >>!   outside of the FreeRTOS kernel.                                   !<<
++	***************************************************************************
++
++    FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY
++    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
++    FOR A PARTICULAR PURPOSE.  Full license text is available on the following
++    link: http://www.freertos.org/a00114.html
++
++    ***************************************************************************
++     *                                                                       *
++     *    FreeRTOS provides completely free yet professionally developed,    *
++     *    robust, strictly quality controlled, supported, and cross          *
++     *    platform software that is more than just the market leader, it     *
++     *    is the industry's de facto standard.                               *
++     *                                                                       *
++     *    Help yourself get started quickly while simultaneously helping     *
++     *    to support the FreeRTOS project by purchasing a FreeRTOS           *
++     *    tutorial book, reference manual, or both:                          *
++     *    http://www.FreeRTOS.org/Documentation                              *
++     *                                                                       *
++    ***************************************************************************
++
++    http://www.FreeRTOS.org/FAQHelp.html - Having a problem?  Start by reading
++	the FAQ page "My application does not run, what could be wrong?".  Have you
++	defined configASSERT()?
++
++	http://www.FreeRTOS.org/support - In return for receiving this top quality
++	embedded software for free we request you assist our global community by
++	participating in the support forum.
++
++	http://www.FreeRTOS.org/training - Investing in training allows your team to
++	be as productive as possible as early as possible.  Now you can receive
++	FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers
++	Ltd, and the world's leading authority on the world's leading RTOS.
++
++    http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,
++    including FreeRTOS+Trace - an indispensable productivity tool, a DOS
++    compatible FAT file system, and our tiny thread aware UDP/IP stack.
++
++    http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.
++    Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.
++
++    http://www.OpenRTOS.com - Real Time Engineers ltd. license FreeRTOS to High
++    Integrity Systems ltd. to sell under the OpenRTOS brand.  Low cost OpenRTOS
++    licenses offer ticketed support, indemnification and commercial middleware.
++
++    http://www.SafeRTOS.com - High Integrity Systems also provide a safety
++    engineered and independently SIL3 certified version for use in safety and
++    mission critical applications that require provable dependability.
++
++    1 tab == 4 spaces!
++*/
++
++#ifndef FREERTOS_CONFIG_RISCV_H
++#define FREERTOS_CONFIG_RISCV_H
++
++// This file is included in the common FreeRTOSConfig.h.
++
++#include "sdkconfig.h"
++
++#define configUSE_PORT_OPTIMISED_TASK_SELECTION         0
++
++#ifndef __ASSEMBLER__
++#if CONFIG_IDF_TARGET_ESP32C3
++#include "esp32c3/rom/ets_sys.h"
++#elif CONFIG_IDF_TARGET_ESP32H2
++#include "esp32h2/rom/ets_sys.h"
++#endif
++#endif // __ASSEMBLER__
++
++/* The maximum interrupt priority from which FreeRTOS.org API functions can
++   be called.  Only API functions that end in ...FromISR() can be used within
++   interrupts. */
++#define configMAX_SYSCALL_INTERRUPT_PRIORITY            0
++
++#ifndef configISR_STACK_SIZE
++#define configISR_STACK_SIZE                            (CONFIG_FREERTOS_ISR_STACKSIZE)
++#endif
++
++#ifndef __ASSEMBLER__
++#if CONFIG_APPTRACE_SV_ENABLE
++extern int xPortSwitchFlag;
++#define os_task_switch_is_pended(_cpu_) (xPortSwitchFlag)
++#else
++#define os_task_switch_is_pended(_cpu_) (false)
++#endif
++#endif
++
++#endif // FREERTOS_CONFIG_RISCV_H
+diff --git a/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/rt-thread/include/freertos/portmacro.h b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/rt-thread/include/freertos/portmacro.h
+new file mode 100644
+index 0000000000..ce683ac301
+--- /dev/null
++++ b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/rt-thread/include/freertos/portmacro.h
+@@ -0,0 +1,107 @@
++/*
++ * FreeRTOS Kernel V10.4.6
++ * 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 PORTMACRO_H
++    #define PORTMACRO_H
++
++    #ifdef __cplusplus
++        extern "C" {
++    #endif
++
++/*-----------------------------------------------------------
++ * Port specific definitions.
++ *
++ * The settings in this file configure FreeRTOS correctly for the
++ * given hardware and compiler.
++ *
++ * These settings should not be altered.
++ *-----------------------------------------------------------
++ */
++
++/* Type definitions. */
++    #define portCHAR          char
++    #define portFLOAT         float
++    #define portDOUBLE        double
++    #define portLONG          long
++    #define portSHORT         short
++    #define portSTACK_TYPE    rt_ubase_t
++    #define portBASE_TYPE     rt_base_t
++
++    typedef portSTACK_TYPE   StackType_t;
++    typedef rt_base_t        BaseType_t;
++    typedef rt_ubase_t       UBaseType_t;
++    typedef rt_tick_t        TickType_t;
++    #define portMAX_DELAY    ( TickType_t ) RT_TICK_MAX
++
++    struct rt_semaphore_wrapper
++    {
++        struct rt_semaphore sem;
++        rt_uint16_t max_value;
++    };
++
++/*-----------------------------------------------------------*/
++
++/* Architecture specifics. */
++    #define portBYTE_ALIGNMENT      RT_ALIGN_SIZE
++    #define portPOINTER_SIZE_TYPE   rt_size_t
++/*-----------------------------------------------------------*/
++
++/* Scheduler utilities. */
++    #define portYIELD()                 rt_thread_yield()
++    #define portYIELD_FROM_ISR( x )     rt_thread_yield()
++
++/*-----------------------------------------------------------*/
++
++/* Critical section management. */
++    extern void vPortEnterCritical( void );
++    extern void vPortExitCritical( void );
++    #define portSET_INTERRUPT_MASK_FROM_ISR()         rt_hw_interrupt_disable()
++    #define portCLEAR_INTERRUPT_MASK_FROM_ISR( x )    rt_hw_interrupt_enable( x )
++    #define portDISABLE_INTERRUPTS()                  vPortEnterCritical()
++    #define portENABLE_INTERRUPTS()                   vPortExitCritical()
++    //#define portENTER_CRITICAL()                      vPortEnterCritical()
++    //#define portEXIT_CRITICAL()                       vPortExitCritical()
++
++/*-----------------------------------------------------------*/
++
++/* Use this macro to calculate the buffer size when allocating a queue statically
++ * To ensure the buffer can fit the desired number of messages
++ */
++    #define QUEUE_BUFFER_SIZE( uxQueueLength, uxItemSize )  ( ( RT_ALIGN( uxItemSize, RT_ALIGN_SIZE ) + sizeof( void * ) ) * uxQueueLength )
++
++    BaseType_t rt_err_to_freertos(rt_err_t rt_err);
++
++/* For ESP32 */
++    #include "portmacro_esp32c3.h"
++
++    #ifdef __cplusplus
++        }
++    #endif
++
++#endif /* PORTMACRO_H */
+diff --git a/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/rt-thread/include/freertos/portmacro_deprecated.h b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/rt-thread/include/freertos/portmacro_deprecated.h
+new file mode 100644
+index 0000000000..597d99c333
+--- /dev/null
++++ b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/rt-thread/include/freertos/portmacro_deprecated.h
+@@ -0,0 +1,94 @@
++/*
++ * SPDX-FileCopyrightText: 2017-2021 Espressif Systems (Shanghai) CO LTD
++ *
++ * SPDX-License-Identifier: Apache-2.0
++ */
++
++/* ---------------------------------------------------- Deprecate ------------------------------------------------------
++ * - Macros or functions that should be deprecated in v5.0, then removed in the next major release
++ * - Kept as not to cause a breaking change
++ * - Include this header at the end of portmacro.h
++ * ------------------------------------------------------------------------------------------------------------------ */
++
++/**
++ * @brief Disable interrupts in a nested manner
++ *
++ * Does the exact same thing as portSET_INTERRUPT_MASK_FROM_ISR()
++ *
++ * @deprecated This function is deprecated. Call portSET_INTERRUPT_MASK_FROM_ISR() instead
++ */
++static inline __attribute__((deprecated)) UBaseType_t portENTER_CRITICAL_NESTED(void) {
++    return portSET_INTERRUPT_MASK_FROM_ISR();
++}
++
++/**
++ * @brief Reenables interrupts in a nested manner
++ *
++ * Does the exact same thing as portCLEAR_INTERRUPT_MASK_FROM_ISR()
++ *
++ * @deprecated This function is deprecated. Call portCLEAR_INTERRUPT_MASK_FROM_ISR() instead
++ */
++static inline void __attribute__((deprecated)) portEXIT_CRITICAL_NESTED(UBaseType_t prev_level)
++{
++    portCLEAR_INTERRUPT_MASK_FROM_ISR(prev_level);
++}
++
++/* ---------------------- Spinlocks --------------------- */
++
++/**
++ * @brief Deprecated placed holder function to initialize a spinlock
++ *
++ * Currently does nothing.
++ *
++ * @deprecated This function is deprecated. If on multi-core, use spinlock_initialize() instead
++ * @param[in] mux Spinlock
++ */
++static inline void __attribute__((deprecated)) __attribute__((always_inline)) vPortCPUInitializeMutex(portMUX_TYPE *mux)
++{
++    (void)mux;
++}
++
++/**
++ * @brief Deprecated placed holder function to acquire a spinlock
++ *
++ * Currently does nothing.
++ *
++ * @deprecated This function is deprecated. If on multi-core, use spinlock_acquire() instead
++ * @param[in] mux Spinlock
++ */
++static inline void __attribute__((deprecated)) __attribute__((always_inline)) vPortCPUAcquireMutex(portMUX_TYPE *mux)
++{
++    (void)mux;
++}
++
++/**
++ * @brief Deprecated placed holder function to acquire a spinlock but with a specified timeout
++ *
++ * Currently just returns true
++ *
++ * @deprecated This function is deprecated. If on multi-core, use spinlock_acquire() instead
++ * @note Does not have deprecated attribute due to usage in app_trace_util.c
++ * @param[in] mux Spinlock
++ * @param[in] timeout Timeout in number of CPU cycles
++ * @return true Always returns true
++ */
++static inline bool __attribute__((always_inline))  vPortCPUAcquireMutexTimeout(portMUX_TYPE *mux, int timeout_cycles)
++{
++    (void)mux;
++    (void)timeout_cycles;
++    return true;
++}
++
++/**
++ * @brief Deprecated placed holder function to release a spinlock
++ *
++ * Currently does nothing.
++ *
++ * @deprecated This function is deprecated. If on multi-core, use spinlock_release() instead
++ * @note Does not have deprecated attribute due to usage in app_trace_util.c
++ * @param[in] mux Spinlock
++ */
++static inline void __attribute__((always_inline)) vPortCPUReleaseMutex(portMUX_TYPE *mux)
++{
++    (void)mux;
++}
+diff --git a/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/rt-thread/include/freertos/portmacro_esp32c3.h b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/rt-thread/include/freertos/portmacro_esp32c3.h
+new file mode 100644
+index 0000000000..88459bb6a2
+--- /dev/null
++++ b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/rt-thread/include/freertos/portmacro_esp32c3.h
+@@ -0,0 +1,424 @@
++/*
++ * FreeRTOS Kernel V10.4.3
++ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
++ *
++ * 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.
++ *
++ * http://www.FreeRTOS.org
++ * http://aws.amazon.com/freertos
++ *
++ * 1 tab == 4 spaces!
++ */
++
++#ifndef PORTMACRO_ESP32C3_H
++#define PORTMACRO_ESP32C3_H
++
++#ifndef __ASSEMBLER__
++
++#include "sdkconfig.h"
++#include <stdint.h>
++#include <stdlib.h>
++#include <stdbool.h>
++#include <stdio.h>
++#include "soc/spinlock.h"
++#include "soc/interrupt_core0_reg.h"
++#include "soc/cpu.h"
++#include "esp_attr.h"
++#include "esp_rom_sys.h"
++#include "esp_timer.h"              /* required for FreeRTOS run time stats */
++#include "esp_heap_caps.h"
++#include "esp_system.h"             /* required by esp_get_...() functions in portable.h. [refactor-todo] Update portable.h */
++#include "esp_newlib.h"
++//#include "portbenchmark.h"
++
++/* [refactor-todo] These includes are not directly used in this file. They are kept into to prevent a breaking change. Remove these. */
++#include <limits.h>
++#ifdef CONFIG_LEGACY_INCLUDE_COMMON_HEADERS
++#include "soc/soc_memory_layout.h"
++#endif
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++
++
++/* --------------------------------------------------- Port Types ------------------------------------------------------
++ * - Port specific types.
++ * - The settings in this file configure FreeRTOS correctly for the given hardware and compiler.
++ * - These settings should not be altered.
++ * - The port types must come first as they are used further down in this file
++ * ------------------------------------------------------------------------------------------------------------------ */
++
++/* Task function macros as described on the FreeRTOS.org WEB site. */
++#define portTASK_FUNCTION_PROTO(vFunction, pvParameters) void vFunction(void *pvParameters)
++#define portTASK_FUNCTION(vFunction, pvParameters) void vFunction(void *pvParameters)
++
++// interrupt module will mask interrupt with priority less than threshold
++#define RVHAL_EXCM_LEVEL            4
++
++
++/* ----------------------------------------------- Port Configurations -------------------------------------------------
++ * - Configurations values supplied by each port
++ * - Required by FreeRTOS
++ * ------------------------------------------------------------------------------------------------------------------ */
++
++#define portCRITICAL_NESTING_IN_TCB     0
++#define portSTACK_GROWTH                (-1)
++#define portTICK_PERIOD_MS              ((TickType_t) (1000 / configTICK_RATE_HZ))
++#define portNOP() __asm volatile        (" nop ")
++
++
++
++/* ---------------------------------------------- Forward Declarations -------------------------------------------------
++ * - Forward declarations of all the port functions and macros need to implement the FreeRTOS porting interface
++ * - These must come before definition/declaration of the FreeRTOS porting interface
++ * ------------------------------------------------------------------------------------------------------------------ */
++
++// --------------------- Interrupts ------------------------
++
++/**
++ * @brief Checks if the current core is in an ISR context
++ *
++ * - ISR context consist of Low/Mid priority ISR, or time tick ISR
++ * - High priority ISRs aren't detected here, but they normally cannot call C code, so that should not be an issue anyway.
++ *
++ * @note [refactor-todo] Check if this should be inlined
++ * @return
++ *  - pdTRUE if in ISR
++ *  - pdFALSE otherwise
++ */
++BaseType_t xPortInIsrContext(void);
++
++/**
++ * @brief Check if in ISR context from High priority ISRs
++ *
++ * - Called from High priority ISR
++ * - Checks if the previous context (before high priority interrupt) was in ISR context (meaning low/med priority)
++ *
++ * @note [refactor-todo] Check if this should be inlined
++ * @return
++ *  - pdTRUE if in previous in ISR context
++ *  - pdFALSE otherwise
++ */
++BaseType_t xPortInterruptedFromISRContext(void);
++
++/* ---------------------- Spinlocks ------------------------
++ - Spinlocks added to match API with SMP FreeRTOS. Single core RISC-V does not need spin locks
++ - Because single core does not have a primitive spinlock data type, we have to implement one here
++ * @note [refactor-todo] Refactor critical section API so that this is no longer required
++ * ------------------------------------------------------ */
++
++/**
++ * @brief Spinlock object
++ * Owner:
++ *  - Set to 0 if uninitialized
++ *  - Set to portMUX_FREE_VAL when free
++ *  - Set to CORE_ID_REGVAL_PRO or CORE_ID_REGVAL_AP when locked
++ *  - Any other value indicates corruption
++ * Count:
++ *  - 0 if unlocked
++ *  - Recursive count if locked
++ *
++ * @note Not a true spinlock as single core RISC-V does not have atomic compare and set instruction
++ * @note Keep portMUX_INITIALIZER_UNLOCKED in sync with this struct
++ */
++typedef struct {
++    uint32_t owner;
++    uint32_t count;
++} portMUX_TYPE;
++/**< Spinlock initializer */
++#define portMUX_INITIALIZER_UNLOCKED {                      \
++            .owner = portMUX_FREE_VAL,                      \
++            .count = 0,                                     \
++        }
++#define portMUX_FREE_VAL                    SPINLOCK_FREE           /**< Spinlock is free. [refactor-todo] check if this is still required */
++#define portMUX_NO_TIMEOUT                  SPINLOCK_WAIT_FOREVER   /**< When passed for 'timeout_cycles', spin forever if necessary. [refactor-todo] check if this is still required */
++#define portMUX_TRY_LOCK                    SPINLOCK_NO_WAIT        /**< Try to acquire the spinlock a single time only. [refactor-todo] check if this is still required */
++#define portMUX_INITIALIZE(mux)    ({ \
++    (mux)->owner = portMUX_FREE_VAL; \
++    (mux)->count = 0; \
++})
++
++/**
++ * @brief Wrapper for atomic compare-and-set instruction
++ *
++ * @note Isn't a real atomic CAS.
++ * @note [refactor-todo] check if we still need this
++ * @note [refactor-todo] Check if this function should be renamed (due to void return type)
++ *
++ * @param[inout] addr Pointer to target address
++ * @param[in] compare Compare value
++ * @param[inout] set Pointer to set value
++ */
++static inline void __attribute__((always_inline)) uxPortCompareSet(volatile uint32_t *addr, uint32_t compare, uint32_t *set);
++
++/**
++ * @brief Wrapper for atomic compare-and-set instruction in external RAM
++ *
++ * @note Isn't a real atomic CAS.
++ * @note [refactor-todo] check if we still need this
++ * @note [refactor-todo] Check if this function should be renamed (due to void return type)
++ *
++ * @param[inout] addr Pointer to target address
++ * @param[in] compare Compare value
++ * @param[inout] set Pointer to set value
++ */
++static inline void uxPortCompareSetExtram(volatile uint32_t *addr, uint32_t compare, uint32_t *set);
++
++// ---------------------- Yielding -------------------------
++
++/**
++ * @brief Perform a context switch from a task
++ *
++ * @note [refactor-todo] The rest of ESP-IDF should call taskYield() instead
++ */
++#define vPortYield()    portYIELD()
++
++/**
++ * @brief Perform a context switch from an ISR
++ */
++#define vPortYieldFromISR() portYIELD_FROM_ISR(0)
++
++/**
++ * @brief Checks if the current core can yield
++ *
++ * - A core cannot yield if its in an ISR or in a critical section
++ *
++ * @note [refactor-todo] See if this can be separated from port macro
++ * @note [refactor-todo] Check if this function should be renamed (due to bool return type)
++ * @return true Core can yield
++ * @return false Core cannot yield
++ */
++static inline bool IRAM_ATTR xPortCanYield(void);
++
++// ------------------- Hook Functions ----------------------
++
++extern void esp_vApplicationIdleHook(void);
++extern void esp_vApplicationTickHook(void);
++
++/**
++ * @brief Hook function called on entry to tickless idle
++ *
++ * - Implemented in pm_impl.c
++ *
++ * @param xExpectedIdleTime Expected idle time
++ */
++void vApplicationSleep(TickType_t xExpectedIdleTime);
++
++// ----------------------- System --------------------------
++
++/**
++ * @brief Get the tick rate per second
++ *
++ * @note [refactor-todo] make this inline
++ * @note [refactor-todo] Check if this function should be renamed (due to uint return type)
++ * @return uint32_t Tick rate in Hz
++ */
++uint32_t xPortGetTickRateHz(void);
++
++/**
++ * @brief Set a watchpoint to watch the last 32 bytes of the stack
++ *
++ * Callback to set a watchpoint on the end of the stack. Called every context switch to change the stack watchpoint
++ * around.
++ *
++ * @param pxStackStart Pointer to the start of the stack
++ */
++void vPortSetStackWatchpoint(void *pxStackStart);
++
++/**
++ * @brief Get the current core's ID
++ *
++ * @note Added to be compatible with SMP API
++ * @note [refactor-todo] IDF should call a FreeRTOS like macro instead of port function directly
++ * @return BaseType_t Core ID
++ */
++static inline BaseType_t IRAM_ATTR xPortGetCoreID(void)
++{
++    return (uint32_t) cpu_hal_get_core_id();
++}
++
++
++
++/* ------------------------------------------- FreeRTOS Porting Interface ----------------------------------------------
++ * - Contains all the mappings of the macros required by FreeRTOS
++ * - Most come after forward declare as porting macros map to declared functions
++ * - Maps to forward declared functions
++ * ------------------------------------------------------------------------------------------------------------------ */
++
++// ----------------------- Memory --------------------------
++
++/**
++ * @brief Task memory allocation macros
++ *
++ * @note Because the ROM routines don't necessarily handle a stack in external RAM correctly, we force the stack
++ * memory to always be internal.
++ * @note [refactor-todo] Update portable.h to match v10.4.3 to use new malloc prototypes
++ */
++#define portTcbMemoryCaps               (MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT)
++#define portStackMemoryCaps             (MALLOC_CAP_INTERNAL|MALLOC_CAP_8BIT)
++#define pvPortMallocTcbMem(size)        pvPortMalloc(size)
++#define pvPortMallocStackMem(size)      pvPortMalloc(size)
++
++// ------------------ Critical Sections --------------------
++#define portENTER_CRITICAL(mux)                 {(void)mux;  vPortEnterCritical();}
++#define portEXIT_CRITICAL(mux)                  {(void)mux;  vPortExitCritical();}
++#define portTRY_ENTER_CRITICAL(mux, timeout)    ({  \
++    (void)mux; (void)timeout;                       \
++    vPortEnterCritical();                           \
++    BaseType_t ret = pdPASS;                        \
++    ret;                                            \
++})
++//In single-core RISC-V, we can use the same critical section API
++#define portENTER_CRITICAL_ISR(mux)                 portENTER_CRITICAL(mux)
++#define portEXIT_CRITICAL_ISR(mux)                  portEXIT_CRITICAL(mux)
++#define portTRY_ENTER_CRITICAL_ISR(mux, timeout)    portTRY_ENTER_CRITICAL(mux, timeout)
++
++/* [refactor-todo] on RISC-V, both ISR and non-ISR cases result in the same call. We can redefine this macro */
++#define portENTER_CRITICAL_SAFE(mux)    ({  \
++    if (xPortInIsrContext()) {              \
++        portENTER_CRITICAL_ISR(mux);        \
++    } else {                                \
++        portENTER_CRITICAL(mux);            \
++    }                                       \
++})
++#define portEXIT_CRITICAL_SAFE(mux)     ({  \
++    if (xPortInIsrContext()) {              \
++        portEXIT_CRITICAL_ISR(mux);         \
++    } else {                                \
++        portEXIT_CRITICAL(mux);             \
++    }                                       \
++})
++#define portTRY_ENTER_CRITICAL_SAFE(mux, timeout)   portENTER_CRITICAL_SAFE(mux, timeout)
++
++// ---------------------- Yielding -------------------------
++
++#define portEND_SWITCHING_ISR(xSwitchRequired) if(xSwitchRequired) vPortYield()
++/* Yielding within an API call (when interrupts are off), means the yield should be delayed
++   until interrupts are re-enabled.
++   To do this, we use the "cross-core" interrupt as a trigger to yield on this core when interrupts are re-enabled.This
++   is the same interrupt & code path which is used to trigger a yield between CPUs, although in this case the yield is
++   happening on the same CPU.
++*/
++#define portYIELD_WITHIN_API() portYIELD()
++
++// ------------------- Hook Functions ----------------------
++
++#ifndef CONFIG_FREERTOS_LEGACY_HOOKS
++#define vApplicationIdleHook    esp_vApplicationIdleHook
++#define vApplicationTickHook    esp_vApplicationTickHook
++#endif /* !CONFIG_FREERTOS_LEGACY_HOOKS */
++#define portSUPPRESS_TICKS_AND_SLEEP(idleTime) vApplicationSleep(idleTime)
++
++// ------------------- Run Time Stats ----------------------
++
++#define portCONFIGURE_TIMER_FOR_RUN_TIME_STATS()
++#define portGET_RUN_TIME_COUNTER_VALUE() 0
++#ifdef CONFIG_FREERTOS_RUN_TIME_STATS_USING_ESP_TIMER
++/* Coarse resolution time (us) */
++#define portALT_GET_RUN_TIME_COUNTER_VALUE(x)    do {x = (uint32_t)esp_timer_get_time();} while(0)
++#endif
++
++
++
++/* --------------------------------------------- Inline Implementations ------------------------------------------------
++ * - Implementation of inline functions of the forward declares
++ * - Should come after forward declare and FreeRTOS Porting interface, as implementation may use both.
++ * - For implementation of non-inlined functions, see port.c, port_common.c, or other assembly files
++ * ------------------------------------------------------------------------------------------------------------------ */
++
++// --------------------- Interrupts ------------------------
++
++
++
++// ---------------------- Spinlocks ------------------------
++
++static inline void __attribute__((always_inline)) uxPortCompareSet(volatile uint32_t *addr, uint32_t compare, uint32_t *set)
++{
++    compare_and_set_native(addr, compare, set);
++}
++
++static inline void uxPortCompareSetExtram(volatile uint32_t *addr, uint32_t compare, uint32_t *set)
++{
++#if defined(CONFIG_SPIRAM)
++    compare_and_set_extram(addr, compare, set);
++#endif
++}
++
++// ---------------------- Yielding -------------------------
++
++static inline bool IRAM_ATTR xPortCanYield(void)
++{
++    uint32_t threshold = REG_READ(INTERRUPT_CORE0_CPU_INT_THRESH_REG);
++    /* when enter critical code, FreeRTOS will mask threshold to RVHAL_EXCM_LEVEL
++     * and exit critical code, will recover threshold value (1). so threshold <= 1
++     * means not in critical code
++     */
++    return (threshold <= 1);
++}
++
++
++
++/* ------------------------------------------------------ Misc ---------------------------------------------------------
++ * - Miscellaneous porting macros
++ * - These are not port of the FreeRTOS porting interface, but are used by other FreeRTOS dependent components
++ * ------------------------------------------------------------------------------------------------------------------ */
++
++// -------------------- Heap Related -----------------------
++
++/**
++ * @brief Checks if a given piece of memory can be used to store a task's TCB
++ *
++ * - Defined in port_common.c
++ *
++ * @param ptr Pointer to memory
++ * @return true Memory can be used to store a TCB
++ * @return false Otherwise
++ */
++bool xPortCheckValidTCBMem(const void *ptr);
++
++/**
++ * @brief Checks if a given piece of memory can be used to store a task's stack
++ *
++ * - Defined in port_common.c
++ *
++ * @param ptr Pointer to memory
++ * @return true Memory can be used to store a task stack
++ * @return false Otherwise
++ */
++bool xPortcheckValidStackMem(const void *ptr);
++
++#define portVALID_TCB_MEM(ptr) xPortCheckValidTCBMem(ptr)
++#define portVALID_STACK_MEM(ptr) xPortcheckValidStackMem(ptr)
++
++
++
++/* ---------------------------------------------------- Deprecate ------------------------------------------------------
++ * - Pull in header containing deprecated macros here
++ * ------------------------------------------------------------------------------------------------------------------ */
++
++#include "portmacro_deprecated.h"
++
++#ifdef __cplusplus
++}
++#endif
++
++#endif //__ASSEMBLER__
++
++#endif /* PORTMACRO_H */
+diff --git a/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/rt-thread/port.c b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/rt-thread/port.c
+new file mode 100644
+index 0000000000..9d8195f832
+--- /dev/null
++++ b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/rt-thread/port.c
+@@ -0,0 +1,44 @@
++#include <FreeRTOS.h>
++
++static rt_base_t level = 0;
++static rt_base_t critical_nesting = 0;
++
++void vPortEnterCritical( void )
++{
++    if ( critical_nesting == 0 )
++    {
++        level = rt_hw_interrupt_disable();
++    }
++    critical_nesting += 1;
++}
++
++void vPortExitCritical( void )
++{
++    critical_nesting -= 1;
++    if ( critical_nesting == 0 )
++    {
++        rt_hw_interrupt_enable( level );
++    }
++}
++
++void vPortEndScheduler( void )
++{
++    /* Not implemented in ports where there is nothing to return to. */
++}
++
++BaseType_t rt_err_to_freertos(rt_err_t rt_err)
++{
++    switch(-rt_err)
++    {
++        case RT_EOK:
++            return pdPASS;
++        case RT_ENOMEM:
++            return errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY;
++        case RT_EFULL:
++            return errQUEUE_FULL;
++        case RT_EEMPTY:
++            return errQUEUE_EMPTY;
++        default:
++            return pdFAIL;
++    }
++}
+diff --git a/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/rt-thread/port_esp32c3.c b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/rt-thread/port_esp32c3.c
+new file mode 100644
+index 0000000000..64fbe9b15b
+--- /dev/null
++++ b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/port/rt-thread/port_esp32c3.c
+@@ -0,0 +1,197 @@
++/*
++    FreeRTOS V8.2.3 - Copyright (C) 2015 Real Time Engineers Ltd.
++    All rights reserved
++
++    VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
++
++    This file is part of the FreeRTOS distribution and was contributed
++    to the project by Technolution B.V. (www.technolution.nl,
++    [email protected]) under the terms of the FreeRTOS
++    contributors license.
++
++    FreeRTOS is free software; you can redistribute it and/or modify it under
++    the terms of the GNU General Public License (version 2) as published by the
++    Free Software Foundation >>>> AND MODIFIED BY <<<< the FreeRTOS exception.
++
++    ***************************************************************************
++    >>!   NOTE: The modification to the GPL is included to allow you to     !<<
++    >>!   distribute a combined work that includes FreeRTOS without being   !<<
++    >>!   obliged to provide the source code for proprietary components     !<<
++    >>!   outside of the FreeRTOS kernel.                                   !<<
++    ***************************************************************************
++
++    FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY
++    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
++    FOR A PARTICULAR PURPOSE.  Full license text is available on the following
++    link: http://www.freertos.org/a00114.html
++
++    ***************************************************************************
++     *                                                                       *
++     *    FreeRTOS provides completely free yet professionally developed,    *
++     *    robust, strictly quality controlled, supported, and cross          *
++     *    platform software that is more than just the market leader, it     *
++     *    is the industry's de facto standard.                               *
++     *                                                                       *
++     *    Help yourself get started quickly while simultaneously helping     *
++     *    to support the FreeRTOS project by purchasing a FreeRTOS           *
++     *    tutorial book, reference manual, or both:                          *
++     *    http://www.FreeRTOS.org/Documentation                              *
++     *                                                                       *
++    ***************************************************************************
++
++    http://www.FreeRTOS.org/FAQHelp.html - Having a problem?  Start by reading
++    the FAQ page "My application does not run, what could be wrong?".  Have you
++    defined configASSERT()?
++
++    http://www.FreeRTOS.org/support - In return for receiving this top quality
++    embedded software for free we request you assist our global community by
++    participating in the support forum.
++
++    http://www.FreeRTOS.org/training - Investing in training allows your team to
++    be as productive as possible as early as possible.  Now you can receive
++    FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers
++    Ltd, and the world's leading authority on the world's leading RTOS.
++
++    http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,
++    including FreeRTOS+Trace - an indispensable productivity tool, a DOS
++    compatible FAT file system, and our tiny thread aware UDP/IP stack.
++
++    http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.
++    Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.
++
++    http://www.OpenRTOS.com - Real Time Engineers ltd. license FreeRTOS to High
++    Integrity Systems ltd. to sell under the OpenRTOS brand.  Low cost OpenRTOS
++    licenses offer ticketed support, indemnification and commercial middleware.
++
++    http://www.SafeRTOS.com - High Integrity Systems also provide a safety
++    engineered and independently SIL3 certified version for use in safety and
++    mission critical applications that require provable dependability.
++
++    1 tab == 4 spaces!
++*/
++
++/*-----------------------------------------------------------------------
++ * Implementation of functions defined in portable.h for the RISC-V port.
++ *----------------------------------------------------------------------*/
++
++#include "sdkconfig.h"
++#include <string.h>
++#include "soc/soc_caps.h"
++#include "soc/periph_defs.h"
++#include "soc/system_reg.h"
++#include "hal/systimer_hal.h"
++#include "hal/systimer_ll.h"
++#include "riscv/rvruntime-frames.h"
++#include "riscv/riscv_interrupts.h"
++#include "riscv/interrupt.h"
++#include "esp_private/crosscore_int.h"
++#include "esp_private/pm_trace.h"
++#include "esp_attr.h"
++#include "esp_system.h"
++#include "esp_intr_alloc.h"
++#include "esp_debug_helpers.h"
++#include "esp_log.h"
++#include "FreeRTOS.h"       /* This pulls in portmacro.h */
++#include "task.h"
++#include "portmacro.h"
++//#include "port_systick.h"
++
++
++
++/* ---------------------------------------------------- Variables ------------------------------------------------------
++ *
++ * ------------------------------------------------------------------------------------------------------------------ */
++
++static const char *TAG = "cpu_start"; // [refactor-todo]: might be appropriate to change in the future, but
++
++/**
++ * @brief A variable is used to keep track of the critical section nesting.
++ * @note This variable has to be stored as part of the task context and must be initialized to a non zero value
++ *       to ensure interrupts don't inadvertently become unmasked before the scheduler starts.
++ *       As it is stored as part of the task context it will automatically be set to 0 when the first task is started.
++ */
++static UBaseType_t uxCriticalNesting = 0;
++static UBaseType_t uxSavedInterruptState = 0;
++BaseType_t uxSchedulerRunning = 0;
++UBaseType_t uxInterruptNesting = 0;
++BaseType_t xPortSwitchFlag = 0;
++__attribute__((aligned(16))) static StackType_t xIsrStack[configISR_STACK_SIZE];
++StackType_t *xIsrStackTop = &xIsrStack[0] + (configISR_STACK_SIZE & (~((portPOINTER_SIZE_TYPE)portBYTE_ALIGNMENT_MASK)));
++
++
++
++/* ---------------------------------------------- Port Implementations -------------------------------------------------
++ *
++ * ------------------------------------------------------------------------------------------------------------------ */
++
++// --------------------- Interrupts ------------------------
++
++BaseType_t xPortInIsrContext(void)
++{
++    return (BaseType_t)rt_interrupt_get_nest();
++}
++
++BaseType_t IRAM_ATTR xPortInterruptedFromISRContext(void)
++{
++    /* For single core, this can be the same as xPortInIsrContext() because reading it is atomic */
++    return (BaseType_t)rt_interrupt_get_nest();
++}
++
++// ---------------------- Spinlocks ------------------------
++
++
++// ---------------------- Yielding -------------------------
++
++
++// ------------------- Hook Functions ----------------------
++
++void __attribute__((weak)) vApplicationStackOverflowHook(TaskHandle_t xTask, char *pcTaskName)
++{
++#define ERR_STR1 "***ERROR*** A stack overflow in task "
++#define ERR_STR2 " has been detected."
++    const char *str[] = {ERR_STR1, pcTaskName, ERR_STR2};
++
++    char buf[sizeof(ERR_STR1) + CONFIG_FREERTOS_MAX_TASK_NAME_LEN + sizeof(ERR_STR2) + 1 /* null char */] = {0};
++
++    char *dest = buf;
++    for (int i = 0; i < sizeof(str) / sizeof(str[0]); i++) {
++        dest = strcat(dest, str[i]);
++    }
++    esp_system_abort(buf);
++}
++
++// ----------------------- System --------------------------
++
++uint32_t xPortGetTickRateHz(void)
++{
++    return (uint32_t)configTICK_RATE_HZ;
++}
++
++#define STACK_WATCH_AREA_SIZE 32
++#define STACK_WATCH_POINT_NUMBER (SOC_CPU_WATCHPOINTS_NUM - 1)
++
++void vPortSetStackWatchpoint(void *pxStackStart)
++{
++    uint32_t addr = (uint32_t)pxStackStart;
++    addr = (addr + (STACK_WATCH_AREA_SIZE - 1)) & (~(STACK_WATCH_AREA_SIZE - 1));
++    esp_cpu_set_watchpoint(STACK_WATCH_POINT_NUMBER, (char *)addr, STACK_WATCH_AREA_SIZE, ESP_WATCHPOINT_STORE);
++}
++
++
++
++/* ---------------------------------------------- Misc Implementations -------------------------------------------------
++ *
++ * ------------------------------------------------------------------------------------------------------------------ */
++
++// --------------------- App Start-up ----------------------
++
++/* [refactor-todo]: See if we can include this through a header */
++extern void esp_startup_start_app_common(void);
++
++void esp_startup_start_app(void)
++{
++    esp_startup_start_app_common();
++
++    ESP_LOGI(TAG, "Starting scheduler.");
++    vTaskStartScheduler();
++}
+diff --git a/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/queue.c b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/queue.c
+new file mode 100644
+index 0000000000..8965e193d0
+--- /dev/null
++++ b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/queue.c
+@@ -0,0 +1,787 @@
++/*
++ * FreeRTOS Kernel V10.4.6
++ * 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
++ *
++ */
++
++#include <stdlib.h>
++#include <string.h>
++
++#include "FreeRTOS.h"
++#include "queue.h"
++
++/* Semaphores do not actually store or copy data, so have an item size of
++ * zero. */
++#define queueSEMAPHORE_QUEUE_ITEM_LENGTH    ( ( UBaseType_t ) 0 )
++#define queueMUTEX_GIVE_BLOCK_TIME          ( ( TickType_t ) 0U )
++
++typedef struct QueueDefinition
++{
++    struct rt_ipc_object *rt_ipc;
++} xQUEUE;
++typedef xQUEUE Queue_t;
++
++static volatile rt_uint8_t mutex_index = 0;
++static volatile rt_uint8_t sem_index = 0;
++static volatile rt_uint8_t queue_index = 0;
++
++/*-----------------------------------------------------------*/
++
++BaseType_t xQueueGenericReset( QueueHandle_t xQueue,
++                               BaseType_t xNewQueue )
++{
++    Queue_t * const pxQueue = xQueue;
++    struct rt_ipc_object *pipc;
++    rt_uint8_t type;
++
++    configASSERT( pxQueue );
++
++    pipc = pxQueue->rt_ipc;
++    RT_ASSERT( pipc != RT_NULL );
++    type = rt_object_get_type( &pipc->parent );
++
++    if ( type == RT_Object_Class_Semaphore )
++    {
++        rt_sem_control( ( rt_sem_t ) pipc, RT_IPC_CMD_RESET, ( void * ) 0);
++    }
++    else if ( type == RT_Object_Class_MessageQueue )
++    {
++        rt_mq_control( ( rt_mq_t ) pipc, RT_IPC_CMD_RESET, RT_NULL );
++    }
++
++    return pdPASS;
++}
++/*-----------------------------------------------------------*/
++
++#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
++
++    QueueHandle_t xQueueGenericCreateStatic( const UBaseType_t uxQueueLength,
++                                             const UBaseType_t uxItemSize,
++                                             uint8_t * pucQueueStorage,
++                                             StaticQueue_t * pxStaticQueue,
++                                             const uint8_t ucQueueType )
++    {
++        Queue_t * pxNewQueue = NULL;
++        char name[RT_NAME_MAX] = {0};
++
++        /* The StaticQueue_t structure and the queue storage area must be
++         * supplied. */
++        configASSERT( pxStaticQueue );
++
++        if( ( uxQueueLength > ( UBaseType_t ) 0 ) &&
++            ( pxStaticQueue != NULL ) &&
++
++            /* A queue storage area should be provided if the item size is not 0, and
++             * should not be provided if the item size is 0. */
++            ( !( ( pucQueueStorage != NULL ) && ( uxItemSize == 0 ) ) ) &&
++            ( !( ( pucQueueStorage == NULL ) && ( uxItemSize != 0 ) ) ) )
++        {
++            if ( ucQueueType == queueQUEUE_TYPE_RECURSIVE_MUTEX || ucQueueType == queueQUEUE_TYPE_MUTEX )
++            {
++                rt_snprintf( name, RT_NAME_MAX, "mutex%02d", mutex_index++ );
++                rt_mutex_init( ( rt_mutex_t ) &( ( StaticSemaphore_t * ) pxStaticQueue )->ipc_obj.mutex, name, RT_IPC_FLAG_PRIO );
++            }
++            else if ( ucQueueType == queueQUEUE_TYPE_BINARY_SEMAPHORE || ucQueueType == queueQUEUE_TYPE_COUNTING_SEMAPHORE )
++            {
++                rt_snprintf( name, RT_NAME_MAX, "sem%02d", sem_index++ );
++                rt_sem_init( ( rt_sem_t ) &( ( StaticSemaphore_t * ) pxStaticQueue )->ipc_obj.semaphore, name, 0, RT_IPC_FLAG_PRIO );
++                ( ( StaticSemaphore_t * ) pxStaticQueue )->ipc_obj.semaphore.max_value = uxQueueLength;
++            }
++            else if ( ucQueueType == queueQUEUE_TYPE_BASE )
++            {
++                rt_snprintf( name, RT_NAME_MAX, "queue%02d", queue_index++ );
++                rt_mq_init( &( pxStaticQueue->ipc_obj ), name, pucQueueStorage, uxItemSize, QUEUE_BUFFER_SIZE( uxQueueLength, uxItemSize ), RT_IPC_FLAG_PRIO );
++            }
++            else
++            {
++                return pxNewQueue;
++            }
++            pxStaticQueue->rt_ipc = ( struct rt_ipc_object * ) &pxStaticQueue->ipc_obj;
++            pxNewQueue = ( QueueHandle_t ) pxStaticQueue;
++        }
++
++        return pxNewQueue;
++    }
++
++#endif /* configSUPPORT_STATIC_ALLOCATION */
++/*-----------------------------------------------------------*/
++
++#if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
++
++    QueueHandle_t xQueueGenericCreate( const UBaseType_t uxQueueLength,
++                                       const UBaseType_t uxItemSize,
++                                       const uint8_t ucQueueType )
++    {
++        Queue_t * pxNewQueue = NULL;
++        char name[RT_NAME_MAX] = {0};
++        struct rt_ipc_object * pipc = RT_NULL;
++
++        if( ( uxQueueLength > ( UBaseType_t ) 0 ) &&
++            /* Check for multiplication overflow. */
++            ( ( SIZE_MAX / uxQueueLength ) >= uxItemSize ) &&
++            /* Check for addition overflow. */
++            ( ( SIZE_MAX - sizeof( Queue_t ) ) >= ( uxQueueLength * uxItemSize ) ) )
++        {
++            pxNewQueue = ( Queue_t * ) RT_KERNEL_MALLOC( sizeof( Queue_t ) );
++            if ( pxNewQueue == NULL )
++            {
++                return ( QueueHandle_t ) pxNewQueue;
++            }
++            if ( ucQueueType == queueQUEUE_TYPE_RECURSIVE_MUTEX || ucQueueType == queueQUEUE_TYPE_MUTEX )
++            {
++                rt_snprintf( name, RT_NAME_MAX, "mutex%02d", mutex_index++ );
++                pipc = ( struct rt_ipc_object * ) rt_mutex_create( name, RT_IPC_FLAG_PRIO );
++            }
++            else if ( ucQueueType == queueQUEUE_TYPE_BINARY_SEMAPHORE || ucQueueType == queueQUEUE_TYPE_COUNTING_SEMAPHORE )
++            {
++                rt_snprintf( name, RT_NAME_MAX, "sem%02d", sem_index++ );
++                pipc = ( struct rt_ipc_object * ) RT_KERNEL_MALLOC( sizeof( struct rt_semaphore_wrapper ) );
++                if ( pipc != RT_NULL )
++                {
++                    rt_sem_init( ( rt_sem_t ) pipc, name, 0, RT_IPC_FLAG_PRIO );
++                    ( ( struct rt_semaphore_wrapper * ) pipc )->max_value = uxQueueLength;
++                    /* Mark as dynamic so we can distinguish in vQueueDelete */
++                    pipc->parent.type &= ~RT_Object_Class_Static;
++                }
++            }
++            else if ( ucQueueType == queueQUEUE_TYPE_BASE )
++            {
++                rt_snprintf( name, RT_NAME_MAX, "queue%02d", queue_index++ );
++                pipc = ( struct rt_ipc_object * ) rt_mq_create( name, uxItemSize, uxQueueLength, RT_IPC_FLAG_PRIO);
++            }
++
++            if ( pipc == RT_NULL )
++            {
++                RT_KERNEL_FREE( pxNewQueue );
++                return NULL;
++            }
++            pxNewQueue->rt_ipc = pipc;
++        }
++
++        return ( QueueHandle_t ) pxNewQueue;
++    }
++
++#endif /* configSUPPORT_STATIC_ALLOCATION */
++/*-----------------------------------------------------------*/
++
++#if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
++
++    QueueHandle_t xQueueCreateMutex( const uint8_t ucQueueType )
++    {
++        QueueHandle_t xNewQueue;
++        const UBaseType_t uxMutexLength = ( UBaseType_t ) 1, uxMutexSize = ( UBaseType_t ) 0;
++
++        xNewQueue = xQueueGenericCreate( uxMutexLength, uxMutexSize, ucQueueType );
++        return xNewQueue;
++    }
++
++#endif /* configUSE_MUTEXES */
++/*-----------------------------------------------------------*/
++
++#if ( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
++
++    QueueHandle_t xQueueCreateMutexStatic( const uint8_t ucQueueType,
++                                           StaticQueue_t * pxStaticQueue )
++    {
++        QueueHandle_t xNewQueue;
++        const UBaseType_t uxMutexLength = ( UBaseType_t ) 1, uxMutexSize = ( UBaseType_t ) 0;
++
++        xNewQueue = xQueueGenericCreateStatic( uxMutexLength, uxMutexSize, NULL, pxStaticQueue, ucQueueType );
++
++        return xNewQueue;
++    }
++
++#endif /* configUSE_MUTEXES */
++/*-----------------------------------------------------------*/
++
++#if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) )
++
++    TaskHandle_t xQueueGetMutexHolder( QueueHandle_t xSemaphore )
++    {
++        TaskHandle_t pxReturn;
++        struct rt_ipc_object *pipc;
++        rt_uint8_t type;
++        rt_base_t level;
++
++        configASSERT( xSemaphore );
++
++        pipc = xSemaphore->rt_ipc;
++        RT_ASSERT( pipc != RT_NULL );
++        type = rt_object_get_type( &pipc->parent );
++
++        if ( type == RT_Object_Class_Mutex )
++        {
++            level = rt_hw_interrupt_disable();
++            pxReturn = ( TaskHandle_t ) ( ( rt_mutex_t ) pipc )->owner;
++            rt_hw_interrupt_enable( level );
++        }
++        else
++        {
++            pxReturn = NULL;
++        }
++
++        return pxReturn;
++    }
++
++#endif /* if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) ) */
++/*-----------------------------------------------------------*/
++
++#if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) )
++
++    TaskHandle_t xQueueGetMutexHolderFromISR( QueueHandle_t xSemaphore )
++    {
++        return xQueueGetMutexHolder( xSemaphore );
++    }
++
++#endif /* if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) ) */
++/*-----------------------------------------------------------*/
++
++#if ( configUSE_RECURSIVE_MUTEXES == 1 )
++
++    BaseType_t xQueueGiveMutexRecursive( QueueHandle_t xMutex )
++    {
++        Queue_t * const pxMutex = ( Queue_t * ) xMutex;
++        configASSERT( pxMutex );
++        return xQueueGenericSend( pxMutex, NULL, queueMUTEX_GIVE_BLOCK_TIME, queueSEND_TO_BACK );
++    }
++
++#endif /* configUSE_RECURSIVE_MUTEXES */
++/*-----------------------------------------------------------*/
++
++#if ( configUSE_RECURSIVE_MUTEXES == 1 )
++
++    BaseType_t xQueueTakeMutexRecursive( QueueHandle_t xMutex,
++                                         TickType_t xTicksToWait )
++    {
++        Queue_t * const pxMutex = ( Queue_t * ) xMutex;
++        configASSERT( pxMutex );
++        return xQueueSemaphoreTake( pxMutex, xTicksToWait );
++    }
++
++#endif /* configUSE_RECURSIVE_MUTEXES */
++/*-----------------------------------------------------------*/
++
++#if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
++
++    QueueHandle_t xQueueCreateCountingSemaphoreStatic( const UBaseType_t uxMaxCount,
++                                                       const UBaseType_t uxInitialCount,
++                                                       StaticQueue_t * pxStaticQueue )
++    {
++        QueueHandle_t xHandle = NULL;
++
++        if( ( uxMaxCount != 0 ) &&
++            ( uxInitialCount <= uxMaxCount ) )
++        {
++            xHandle = xQueueGenericCreateStatic( uxMaxCount, queueSEMAPHORE_QUEUE_ITEM_LENGTH, NULL, pxStaticQueue, queueQUEUE_TYPE_COUNTING_SEMAPHORE );
++
++            if( xHandle != NULL )
++            {
++                ( ( rt_sem_t ) ( ( Queue_t * ) xHandle )->rt_ipc )->value = uxInitialCount;
++            }
++        }
++        else
++        {
++            configASSERT( xHandle );
++        }
++
++        return xHandle;
++    }
++
++#endif /* ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */
++/*-----------------------------------------------------------*/
++
++#if ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
++
++    QueueHandle_t xQueueCreateCountingSemaphore( const UBaseType_t uxMaxCount,
++                                                 const UBaseType_t uxInitialCount )
++    {
++        QueueHandle_t xHandle = NULL;
++
++        if( ( uxMaxCount != 0 ) &&
++            ( uxInitialCount <= uxMaxCount ) )
++        {
++            xHandle = xQueueGenericCreate( uxMaxCount, queueSEMAPHORE_QUEUE_ITEM_LENGTH, queueQUEUE_TYPE_COUNTING_SEMAPHORE );
++
++            if( xHandle != NULL )
++            {
++                ( ( rt_sem_t ) ( ( Queue_t * ) xHandle )->rt_ipc )->value = uxInitialCount;
++            }
++        }
++        else
++        {
++            configASSERT( xHandle );
++        }
++
++        return xHandle;
++    }
++
++#endif /* ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */
++/*-----------------------------------------------------------*/
++
++BaseType_t xQueueGenericSend( QueueHandle_t xQueue,
++                              const void * const pvItemToQueue,
++                              TickType_t xTicksToWait,
++                              const BaseType_t xCopyPosition )
++{
++    Queue_t * const pxQueue = xQueue;
++    struct rt_ipc_object *pipc;
++    rt_uint8_t type;
++    rt_base_t level;
++    rt_err_t err = -RT_ERROR;
++
++    configASSERT( pxQueue );
++    #if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
++        {
++            configASSERT( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) );
++        }
++    #endif
++
++    pipc = pxQueue->rt_ipc;
++    RT_ASSERT( pipc != RT_NULL );
++    type = rt_object_get_type( &pipc->parent );
++    if ( type == RT_Object_Class_Mutex )
++    {
++        err = rt_mutex_release( ( rt_mutex_t ) pipc );
++    }
++    else if ( type == RT_Object_Class_Semaphore )
++    {
++        level = rt_hw_interrupt_disable();
++        if ( ( ( rt_sem_t ) pipc )->value < ( ( struct rt_semaphore_wrapper * ) pipc )->max_value )
++        {
++            err = rt_sem_release( ( rt_sem_t ) pipc );
++        }
++        rt_hw_interrupt_enable( level );
++    }
++    else if ( type == RT_Object_Class_MessageQueue )
++    {
++        if ( xCopyPosition == queueSEND_TO_BACK )
++        {
++            err = rt_mq_send_wait( ( rt_mq_t ) pipc, pvItemToQueue, ( ( rt_mq_t ) pipc )->msg_size, ( rt_int32_t ) xTicksToWait );
++        }
++        else if ( xCopyPosition == queueSEND_TO_FRONT )
++        {
++            // TODO: need to implement the timeout for LIFO
++            err = rt_mq_urgent( ( rt_mq_t ) pipc, pvItemToQueue, ( ( rt_mq_t ) pipc )->msg_size );
++        }
++    }
++
++    return rt_err_to_freertos( err );
++}
++/*-----------------------------------------------------------*/
++
++BaseType_t xQueueGenericSendFromISR( QueueHandle_t xQueue,
++                                     const void * const pvItemToQueue,
++                                     BaseType_t * const pxHigherPriorityTaskWoken,
++                                     const BaseType_t xCopyPosition )
++{
++    Queue_t * const pxQueue = xQueue;
++    struct rt_ipc_object *pipc;
++    rt_uint8_t type;
++    rt_err_t err = -RT_ERROR;
++
++    configASSERT( pxQueue );
++
++    pipc = pxQueue->rt_ipc;
++    RT_ASSERT( pipc != RT_NULL );
++    type = rt_object_get_type( &pipc->parent );
++    if ( type == RT_Object_Class_MessageQueue )
++    {
++        if ( xCopyPosition == queueSEND_TO_BACK )
++        {
++            err = rt_mq_send( ( rt_mq_t ) pipc, pvItemToQueue, ( ( rt_mq_t ) pipc )->msg_size);
++        }
++        else if ( xCopyPosition == queueSEND_TO_FRONT )
++        {
++            err = rt_mq_urgent( ( rt_mq_t ) pipc, pvItemToQueue, ( ( rt_mq_t ) pipc )->msg_size );
++        }
++    }
++
++    return rt_err_to_freertos( err );
++}
++/*-----------------------------------------------------------*/
++
++BaseType_t xQueueGiveFromISR( QueueHandle_t xQueue,
++                              BaseType_t * const pxHigherPriorityTaskWoken )
++{
++    Queue_t * const pxQueue = xQueue;
++    struct rt_ipc_object *pipc;
++    rt_uint8_t type;
++    rt_base_t level;
++    rt_err_t err = -RT_ERROR;
++
++    configASSERT( pxQueue );
++
++    pipc = pxQueue->rt_ipc;
++    RT_ASSERT( pipc != RT_NULL );
++    type = rt_object_get_type( &pipc->parent );
++    RT_ASSERT( type != RT_Object_Class_Mutex );
++    if ( type == RT_Object_Class_Semaphore )
++    {
++        level = rt_hw_interrupt_disable();
++        if ( ( ( rt_sem_t ) pipc )->value < ( ( struct rt_semaphore_wrapper * ) pipc )->max_value )
++        {
++            err = rt_sem_release( ( rt_sem_t ) pipc );
++        }
++        rt_hw_interrupt_enable( level );
++    }
++    if ( pxHigherPriorityTaskWoken != NULL )
++    {
++        *pxHigherPriorityTaskWoken = pdFALSE;
++    }
++
++    return rt_err_to_freertos( err );
++}
++/*-----------------------------------------------------------*/
++
++BaseType_t xQueueReceive( QueueHandle_t xQueue,
++                          void * const pvBuffer,
++                          TickType_t xTicksToWait )
++{
++    Queue_t * const pxQueue = xQueue;
++    struct rt_ipc_object *pipc;
++    rt_uint8_t type;
++    rt_err_t err = -RT_ERROR;
++
++    /* Check the queue pointer is not NULL. */
++    configASSERT( ( pxQueue ) );
++
++    /* Cannot block if the scheduler is suspended. */
++    #if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
++        {
++            configASSERT( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) );
++        }
++    #endif
++
++    pipc = pxQueue->rt_ipc;
++    RT_ASSERT( pipc != RT_NULL );
++    type = rt_object_get_type( &pipc->parent );
++    if ( type == RT_Object_Class_MessageQueue )
++    {
++        err = rt_mq_recv( ( rt_mq_t ) pipc, pvBuffer, ( ( rt_mq_t ) pipc )->msg_size, ( rt_int32_t ) xTicksToWait );
++    }
++
++    return rt_err_to_freertos( err );
++}
++/*-----------------------------------------------------------*/
++
++BaseType_t xQueueSemaphoreTake( QueueHandle_t xQueue,
++                                TickType_t xTicksToWait )
++{
++    Queue_t * const pxQueue = xQueue;
++    struct rt_ipc_object *pipc;
++    rt_uint8_t type;
++    rt_err_t err = -RT_ERROR;
++
++    /* Check the queue pointer is not NULL. */
++    configASSERT( ( pxQueue ) );
++
++    /* Cannot block if the scheduler is suspended. */
++    #if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
++        {
++            configASSERT( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) );
++        }
++    #endif
++
++    pipc = pxQueue->rt_ipc;
++    RT_ASSERT( pipc != RT_NULL );
++    type = rt_object_get_type( &pipc->parent );
++    if ( type == RT_Object_Class_Mutex )
++    {
++        err = rt_mutex_take( ( rt_mutex_t ) pipc, ( rt_int32_t ) xTicksToWait );
++    }
++    else if ( type == RT_Object_Class_Semaphore )
++    {
++        err = rt_sem_take( ( rt_sem_t ) pipc, ( rt_int32_t ) xTicksToWait );
++    }
++
++    return rt_err_to_freertos( err );
++}
++/*-----------------------------------------------------------*/
++
++BaseType_t xQueueReceiveFromISR( QueueHandle_t xQueue,
++                                 void * const pvBuffer,
++                                 BaseType_t * const pxHigherPriorityTaskWoken )
++{
++    Queue_t * const pxQueue = xQueue;
++    struct rt_ipc_object *pipc;
++    rt_uint8_t type;
++    rt_err_t err = -RT_ERROR;
++
++    configASSERT( pxQueue );
++
++    pipc = pxQueue->rt_ipc;
++    RT_ASSERT( pipc != RT_NULL );
++    type = rt_object_get_type( &pipc->parent );
++    RT_ASSERT( type != RT_Object_Class_Mutex );
++    if ( type == RT_Object_Class_Semaphore )
++    {
++        err = rt_sem_take( ( rt_sem_t ) pipc, RT_WAITING_NO );
++    }
++    else if ( type == RT_Object_Class_MessageQueue )
++    {
++        err = rt_mq_recv( ( rt_mq_t ) pipc, pvBuffer, ( ( rt_mq_t ) pipc )->msg_size, RT_WAITING_NO );
++    }
++    if ( pxHigherPriorityTaskWoken != NULL )
++    {
++        *pxHigherPriorityTaskWoken = pdFALSE;
++    }
++
++    return rt_err_to_freertos( err );
++}
++/*-----------------------------------------------------------*/
++
++UBaseType_t uxQueueMessagesWaiting( const QueueHandle_t xQueue )
++{
++    UBaseType_t uxReturn = 0;
++    struct rt_ipc_object *pipc;
++    rt_uint8_t type;
++    rt_base_t level;
++
++    configASSERT( xQueue );
++
++    pipc = xQueue->rt_ipc;
++    RT_ASSERT( pipc != RT_NULL );
++    type = rt_object_get_type( &pipc->parent );
++
++    level = rt_hw_interrupt_disable();
++
++    if ( type == RT_Object_Class_Mutex )
++    {
++        uxReturn = ( ( rt_mutex_t ) pipc )->value;
++    }
++    else if ( type == RT_Object_Class_Semaphore )
++    {
++        uxReturn = ( ( rt_sem_t ) pipc )->value;
++    }
++    else if ( type == RT_Object_Class_MessageQueue )
++    {
++        uxReturn = ( ( rt_mq_t ) pipc )->entry;
++    }
++
++    rt_hw_interrupt_enable( level );
++
++    return uxReturn;
++}
++/*-----------------------------------------------------------*/
++
++UBaseType_t uxQueueSpacesAvailable( const QueueHandle_t xQueue )
++{
++    UBaseType_t uxReturn = 0;
++    struct rt_ipc_object *pipc;
++    rt_uint8_t type;
++    rt_base_t level;
++
++    configASSERT( xQueue );
++
++    pipc = xQueue->rt_ipc;
++    RT_ASSERT( pipc != RT_NULL );
++    type = rt_object_get_type( &pipc->parent );
++
++    level = rt_hw_interrupt_disable();
++
++    if ( type == RT_Object_Class_Mutex )
++    {
++        uxReturn = 1 - ( ( rt_mutex_t ) pipc )->value;
++    }
++    else if ( type == RT_Object_Class_Semaphore )
++    {
++        uxReturn = ( ( struct rt_semaphore_wrapper * ) pipc )->max_value - ( ( rt_sem_t ) pipc )->value;
++    }
++    else if ( type == RT_Object_Class_MessageQueue )
++    {
++        uxReturn = ( ( rt_mq_t ) pipc )->max_msgs - ( ( rt_mq_t ) pipc )->entry;
++    }
++
++    rt_hw_interrupt_enable( level );
++
++    return uxReturn;
++}
++/*-----------------------------------------------------------*/
++
++UBaseType_t uxQueueMessagesWaitingFromISR( const QueueHandle_t xQueue )
++{
++    return uxQueueMessagesWaiting( xQueue );
++}
++/*-----------------------------------------------------------*/
++
++void vQueueDelete( QueueHandle_t xQueue )
++{
++    Queue_t * const pxQueue = xQueue;
++    struct rt_ipc_object *pipc;
++    rt_uint8_t type;
++
++    configASSERT( pxQueue );
++
++    pipc = pxQueue->rt_ipc;
++    RT_ASSERT( pipc != RT_NULL );
++    type = rt_object_get_type( &pipc->parent );
++#if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
++    if ( rt_object_is_systemobject( ( rt_object_t ) pipc ) )
++#endif
++    {
++    #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
++        if ( type == RT_Object_Class_Mutex )
++        {
++            rt_mutex_detach( ( rt_mutex_t ) pipc );
++        }
++        else if ( type == RT_Object_Class_Semaphore )
++        {
++            rt_sem_detach( ( rt_sem_t ) pipc );
++        }
++        else if ( type == RT_Object_Class_MessageQueue )
++        {
++            rt_mq_detach( ( rt_mq_t ) pipc );
++        }
++    #endif
++#if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
++    }
++    else
++    {
++#endif
++    #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
++        if ( type == RT_Object_Class_Mutex )
++        {
++            rt_mutex_delete( ( rt_mutex_t ) pipc );
++        }
++        else if ( type == RT_Object_Class_Semaphore )
++        {
++            /* Allocated with rt_sem_init in xQueueGenericCreate */
++            pipc->parent.type |= RT_Object_Class_Static;
++            rt_sem_detach( ( rt_sem_t ) pipc );
++            RT_KERNEL_FREE( pipc );
++        }
++        else if ( type == RT_Object_Class_MessageQueue )
++        {
++            rt_mq_delete( ( rt_mq_t ) pipc );
++        }
++        else
++        {
++            return;
++        }
++        RT_KERNEL_FREE( pxQueue );
++    #endif
++    }
++}
++/*-----------------------------------------------------------*/
++
++BaseType_t xQueueIsQueueEmptyFromISR( const QueueHandle_t xQueue )
++{
++    BaseType_t xReturn;
++
++    configASSERT( xQueue );
++
++    if( uxQueueMessagesWaiting( xQueue ) == ( UBaseType_t ) 0 )
++    {
++        xReturn = pdTRUE;
++    }
++    else
++    {
++        xReturn = pdFALSE;
++    }
++
++    return xReturn;
++}
++/*-----------------------------------------------------------*/
++
++BaseType_t xQueueIsQueueFullFromISR( const QueueHandle_t xQueue )
++{
++    BaseType_t xReturn;
++
++    configASSERT( xQueue );
++
++    if ( uxQueueSpacesAvailable( xQueue ) == ( UBaseType_t ) 0 )
++    {
++        xReturn = pdTRUE;
++    }
++    else
++    {
++        xReturn = pdFALSE;
++    }
++
++    return xReturn;
++}
++/*-----------------------------------------------------------*/
++
++/* Unimplemented */
++#include "esp_log.h"
++QueueSetHandle_t xQueueCreateSet( const UBaseType_t uxEventQueueLength )
++{
++    ESP_LOGE("freertos", "xQueueCreateSet unimplemented");
++    RT_ASSERT(0);
++    return NULL;
++}
++BaseType_t xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore,
++                           QueueSetHandle_t xQueueSet )
++{
++    ESP_LOGE("freertos", "xQueueAddToSet unimplemented");
++    RT_ASSERT(0);
++    return pdFAIL;
++}
++
++BaseType_t xQueueRemoveFromSet( QueueSetMemberHandle_t xQueueOrSemaphore,
++                                QueueSetHandle_t xQueueSet )
++{
++    ESP_LOGE("freertos", "xQueueRemoveFromSet unimplemented");
++    RT_ASSERT(0);
++    return pdFAIL;
++}
++
++QueueSetMemberHandle_t xQueueSelectFromSet( QueueSetHandle_t xQueueSet,
++                                            const TickType_t xTicksToWait )
++{
++    ESP_LOGE("freertos", "xQueueSelectFromSet unimplemented");
++    RT_ASSERT(0);
++    return NULL;
++}
++
++QueueSetMemberHandle_t xQueueSelectFromSetFromISR( QueueSetHandle_t xQueueSet )
++{
++    ESP_LOGE("freertos", "xQueueSelectFromSetFromISR unimplemented");
++    RT_ASSERT(0);
++    return NULL;
++}
++
++BaseType_t xQueuePeek( QueueHandle_t xQueue,
++                       void * const pvBuffer,
++                       TickType_t xTicksToWait )
++{
++    ESP_LOGE("freertos", "xQueuePeek unimplemented");
++    RT_ASSERT(0);
++    return pdFAIL;
++}
++
++BaseType_t xQueueOverwrite(QueueHandle_t xQueue, const void * pvItemToQueue)
++{
++    ESP_LOGE("freertos", "xQueueOverwrite unimplemented");
++    RT_ASSERT(0);
++    return pdFAIL;
++}
++
++BaseType_t xQueueOverwriteFromISR(QueueHandle_t xQueue, const void * pvItemToQueue, BaseType_t *pxHigherPriorityTaskWoken)
++{
++    ESP_LOGE("freertos", "xQueueOverwriteFromISR unimplemented");
++    RT_ASSERT(0);
++    return pdFAIL;  
++}
+diff --git a/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/tasks.c b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/tasks.c
+new file mode 100644
+index 0000000000..d3e8c27a09
+--- /dev/null
++++ b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/tasks.c
+@@ -0,0 +1,1254 @@
++/*
++ * FreeRTOS Kernel V10.4.6
++ * 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
++ *
++ */
++
++/* Standard includes. */
++#include <stdlib.h>
++#include <string.h>
++
++/* FreeRTOS includes. */
++#include "FreeRTOS.h"
++#include "task.h"
++
++//TODO: check configMAX_PRIORITIES == RT_THREAD_PRIORITY_MAX
++#define FREERTOS_PRIORITY_TO_RTTHREAD(priority)    ( configMAX_PRIORITIES - 1 - ( priority ) )
++#define RTTHREAD_PRIORITY_TO_FREERTOS(priority)    ( RT_THREAD_PRIORITY_MAX - 1 - ( priority ) )
++
++/* Values that can be assigned to the ucNotifyState member of the TCB. */
++#define taskNOT_WAITING_NOTIFICATION              ( ( uint8_t ) 0 ) /* Must be zero as it is the initialised value. */
++#define taskWAITING_NOTIFICATION                  ( ( uint8_t ) 1 )
++#define taskNOTIFICATION_RECEIVED                 ( ( uint8_t ) 2 )
++
++/*
++ * Several functions take a TaskHandle_t parameter that can optionally be NULL,
++ * where NULL is used to indicate that the handle of the currently executing
++ * task should be used in place of the parameter.  This macro simply checks to
++ * see if the parameter is NULL and returns a pointer to the appropriate TCB.
++ */
++#define prvGetTCBFromHandle( pxHandle )    ( ( ( pxHandle ) == NULL ) ? ( xTaskGetCurrentTaskHandle() ) : ( pxHandle ) )
++
++/*
++ * Task control block.  A task control block (TCB) is allocated for each task,
++ * and stores task state information, including a pointer to the task's context
++ * (the task's run time environment, including register values)
++ */
++typedef struct tskTaskControlBlock
++{
++    struct rt_thread thread;
++    #if ( configUSE_APPLICATION_TASK_TAG == 1 )
++        TaskHookFunction_t pxTaskTag;
++    #endif
++    #if ( configUSE_TASK_NOTIFICATIONS == 1 )
++        volatile uint32_t ulNotifiedValue[ configTASK_NOTIFICATION_ARRAY_ENTRIES ];
++        volatile uint8_t ucNotifyState[ configTASK_NOTIFICATION_ARRAY_ENTRIES ];
++    #endif
++    #if ( INCLUDE_xTaskAbortDelay == 1 )
++        uint8_t ucDelayAborted;
++    #endif
++} tskTCB;
++typedef tskTCB TCB_t;
++
++/* Other file private variables. --------------------------------*/
++static volatile BaseType_t xSchedulerRunning = pdFALSE;
++
++/*-----------------------------------------------------------*/
++
++/*
++ * Called after a Task_t structure has been allocated either statically or
++ * dynamically to fill in the structure's members.
++ */
++static void prvInitialiseNewTask( TaskFunction_t pxTaskCode,
++                                  const char * const pcName,
++                                  const uint32_t ulStackDepth,
++                                  void * const pvParameters,
++                                  UBaseType_t uxPriority,
++                                  TaskHandle_t * const pxCreatedTask,
++                                  TCB_t * pxNewTCB,
++                                  StackType_t * const puxStackBuffer );
++
++#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
++
++    TaskHandle_t 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 )
++    {
++        TCB_t * pxNewTCB;
++        TaskHandle_t xReturn = NULL;
++
++        configASSERT( puxStackBuffer != NULL );
++        configASSERT( pxTaskBuffer != NULL );
++
++        #if ( configASSERT_DEFINED == 1 )
++            {
++                /* Sanity check that the size of the structure used to declare a
++                 * variable of type StaticTask_t equals the size of the real task
++                 * structure. */
++                volatile size_t xSize = sizeof( StaticTask_t );
++                configASSERT( xSize == sizeof( TCB_t ) );
++                ( void ) xSize; /* Prevent lint warning when configASSERT() is not used. */
++            }
++        #endif /* configASSERT_DEFINED */
++
++        if( ( pxTaskBuffer != NULL ) && ( puxStackBuffer != NULL ) )
++        {
++            pxNewTCB = ( TCB_t * ) pxTaskBuffer;
++            prvInitialiseNewTask( pxTaskCode, pcName, ulStackDepth, pvParameters, uxPriority, &xReturn, pxNewTCB, puxStackBuffer );
++            rt_thread_startup( ( rt_thread_t ) pxNewTCB );
++        }
++
++        return xReturn;
++    }
++
++#endif /* SUPPORT_STATIC_ALLOCATION */
++
++#if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
++
++    BaseType_t xTaskCreate( TaskFunction_t pxTaskCode,
++                            const char * const pcName,
++                            const configSTACK_DEPTH_TYPE usStackDepth,
++                            void * const pvParameters,
++                            UBaseType_t uxPriority,
++                            TaskHandle_t * const pxCreatedTask )
++    {
++        TCB_t * pxNewTCB;
++        BaseType_t xReturn = errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY;
++        void * stack_start = RT_NULL;
++
++        pxNewTCB = ( TCB_t * ) RT_KERNEL_MALLOC( sizeof( TCB_t ) );
++        if ( pxNewTCB != NULL )
++        {
++            stack_start = RT_KERNEL_MALLOC( usStackDepth * sizeof( StackType_t ) );
++            if ( stack_start != RT_NULL )
++            {
++                prvInitialiseNewTask( pxTaskCode, pcName, ( uint32_t ) usStackDepth, pvParameters, uxPriority, pxCreatedTask, pxNewTCB, ( StackType_t * ) stack_start );
++                xReturn = pdPASS;
++                /* Mark as dynamic */
++                ( ( struct rt_thread * ) pxNewTCB )->type &= ~RT_Object_Class_Static;
++                rt_thread_startup( ( rt_thread_t ) pxNewTCB );
++            }
++            else
++            {
++                RT_KERNEL_FREE( pxNewTCB );
++            }
++        }
++
++        return xReturn;
++    }
++
++#endif /* configSUPPORT_DYNAMIC_ALLOCATION */
++/*-----------------------------------------------------------*/
++
++/* ESP32 */
++#if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
++
++    BaseType_t xTaskCreatePinnedToCore( TaskFunction_t pvTaskCode,
++                            const char * const pcName, /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
++                            const uint32_t usStackDepth,
++                            void * const pvParameters,
++                            UBaseType_t uxPriority,
++                            TaskHandle_t * const pvCreatedTask,
++                            const BaseType_t xCoreID)
++    {
++        ( void ) xCoreID;
++        return xTaskCreate( pvTaskCode, pcName, usStackDepth, pvParameters, uxPriority, pvCreatedTask );
++    }
++
++#endif /* configSUPPORT_DYNAMIC_ALLOCATION */
++/*-----------------------------------------------------------*/
++
++static void prvInitialiseNewTask( TaskFunction_t pxTaskCode,
++                                  const char * const pcName,
++                                  const uint32_t ulStackDepth,
++                                  void * const pvParameters,
++                                  UBaseType_t uxPriority,
++                                  TaskHandle_t * const pxCreatedTask,
++                                  TCB_t * pxNewTCB,
++                                  StackType_t * const puxStackBuffer )
++{
++    /* This is used as an array index so must ensure it's not too large. */
++    configASSERT( uxPriority < configMAX_PRIORITIES );
++
++    if( uxPriority >= ( UBaseType_t ) configMAX_PRIORITIES )
++    {
++        uxPriority = ( UBaseType_t ) configMAX_PRIORITIES - ( UBaseType_t ) 1U;
++    }
++
++    rt_thread_init( ( struct rt_thread * ) pxNewTCB, pcName, pxTaskCode, pvParameters,
++                    puxStackBuffer, ulStackDepth * sizeof( StackType_t ), FREERTOS_PRIORITY_TO_RTTHREAD( uxPriority ), 1 );
++
++#if ( configUSE_APPLICATION_TASK_TAG == 1 )
++    pxNewTCB->pxTaskTag = NULL;
++#endif
++
++#if ( configUSE_TASK_NOTIFICATIONS == 1 )
++    rt_memset( ( void * ) &( pxNewTCB->ulNotifiedValue[ 0 ] ), 0x00, sizeof( pxNewTCB->ulNotifiedValue ) );
++    rt_memset( ( void * ) &( pxNewTCB->ucNotifyState[ 0 ] ), 0x00, sizeof( pxNewTCB->ucNotifyState ) );
++#endif
++
++#if ( INCLUDE_xTaskAbortDelay == 1 )
++    pxNewTCB->ucDelayAborted = pdFALSE;
++#endif
++
++    if ( pxCreatedTask != NULL )
++    {
++        *pxCreatedTask = ( TaskHandle_t ) pxNewTCB;
++    }
++}
++/*-----------------------------------------------------------*/
++
++#if ( INCLUDE_vTaskDelete == 1 )
++
++    void vTaskDelete( TaskHandle_t xTaskToDelete )
++    {
++        rt_thread_t thread = ( rt_thread_t ) prvGetTCBFromHandle( xTaskToDelete );
++        if ( thread == RT_NULL )
++        {
++            thread = rt_thread_self();
++        }
++    #if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
++        if ( rt_object_is_systemobject( ( rt_object_t ) thread ) )
++    #endif
++        {
++        #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
++            rt_thread_detach( thread );
++        #endif
++    #if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
++        }
++        else
++        {
++    #endif
++        #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
++            rt_thread_delete( thread );
++        #endif
++        }
++
++        if ( thread == rt_thread_self() )
++        {
++            rt_schedule();
++        }
++    }
++
++#endif /* INCLUDE_vTaskDelete */
++/*-----------------------------------------------------------*/
++
++#if ( INCLUDE_xTaskDelayUntil == 1 )
++
++    BaseType_t xTaskDelayUntil( TickType_t * const pxPreviousWakeTime,
++                                const TickType_t xTimeIncrement )
++    {
++        BaseType_t xShouldDelay = pdFALSE;
++        rt_base_t level;
++        rt_tick_t cur_tick;
++
++        RT_ASSERT( pxPreviousWakeTime != RT_NULL );
++        RT_ASSERT( xTimeIncrement > 0U );
++
++        level = rt_hw_interrupt_disable();
++        cur_tick = rt_tick_get();
++        if (cur_tick - *pxPreviousWakeTime < xTimeIncrement)
++        {
++            rt_thread_delay_until( pxPreviousWakeTime, xTimeIncrement );
++            xShouldDelay = pdTRUE;
++        }
++        rt_hw_interrupt_enable( level );
++
++        return xShouldDelay;
++    }
++
++#endif /* INCLUDE_xTaskDelayUntil */
++/*-----------------------------------------------------------*/
++
++#if ( INCLUDE_vTaskDelay == 1 )
++
++    void vTaskDelay( const TickType_t xTicksToDelay )
++    {
++        rt_thread_delay( xTicksToDelay );
++    }
++
++#endif /* INCLUDE_vTaskDelay */
++/*-----------------------------------------------------------*/
++
++#if ( ( INCLUDE_eTaskGetState == 1 ) || ( configUSE_TRACE_FACILITY == 1 ) || ( INCLUDE_xTaskAbortDelay == 1 ) )
++
++    eTaskState eTaskGetState( TaskHandle_t xTask )
++    {
++        eTaskState eReturn;
++        rt_thread_t thread = ( rt_thread_t ) xTask;
++        rt_base_t level;
++
++        configASSERT( xTask );
++
++        level = rt_hw_interrupt_disable();
++
++        switch ( thread->stat & RT_THREAD_STAT_MASK )
++        {
++            case RT_THREAD_READY:
++            {
++                eReturn = eReady;
++                break;
++            }
++            case RT_THREAD_SUSPEND:
++            {
++                /* If thread timer is activated it is blocked with a timeout */
++                if ( thread->thread_timer.parent.flag & RT_TIMER_FLAG_ACTIVATED )
++                {
++                    eReturn = eBlocked;
++                }
++                /* Otherwise it is suspended or blocked with an infinite timeout */
++                else
++                {
++                    eReturn = eSuspended;
++                }
++                break;
++            }
++            case RT_THREAD_RUNNING:
++            {
++                eReturn = eRunning;
++                break;
++            }
++            case RT_THREAD_CLOSE:
++            {
++                eReturn = eDeleted;
++                break;
++            }
++            default:
++                eReturn = eInvalid;
++        }
++
++        rt_hw_interrupt_enable( level );
++
++        return eReturn;
++    }
++
++#endif /* INCLUDE_eTaskGetState */
++/*-----------------------------------------------------------*/
++
++#if ( INCLUDE_uxTaskPriorityGet == 1 )
++
++    UBaseType_t uxTaskPriorityGet( const TaskHandle_t xTask )
++    {
++        UBaseType_t uxReturn;
++        rt_thread_t thread = ( rt_thread_t ) prvGetTCBFromHandle( xTask );
++        rt_base_t level;
++
++        level = rt_hw_interrupt_disable();
++        uxReturn = thread->current_priority;
++        rt_hw_interrupt_enable( level );
++
++        return RTTHREAD_PRIORITY_TO_FREERTOS( uxReturn );
++    }
++
++#endif /* INCLUDE_uxTaskPriorityGet */
++/*-----------------------------------------------------------*/
++
++#if ( INCLUDE_uxTaskPriorityGet == 1 )
++
++    UBaseType_t uxTaskPriorityGetFromISR( const TaskHandle_t xTask )
++    {
++        return uxTaskPriorityGet( xTask );
++    }
++
++#endif /* INCLUDE_uxTaskPriorityGet */
++/*-----------------------------------------------------------*/
++
++#if ( INCLUDE_vTaskPrioritySet == 1 )
++
++    void vTaskPrioritySet( TaskHandle_t xTask,
++                           UBaseType_t uxNewPriority )
++    {
++        extern rt_thread_t rt_current_thread;
++        rt_thread_t thread;
++        rt_uint8_t current_priority;
++        rt_bool_t need_schedule = RT_FALSE;
++        rt_base_t level;
++
++        configASSERT( uxNewPriority < configMAX_PRIORITIES );
++
++        /* Ensure the new priority is valid. */
++        if( uxNewPriority >= ( UBaseType_t ) configMAX_PRIORITIES )
++        {
++            uxNewPriority = ( UBaseType_t ) configMAX_PRIORITIES - ( UBaseType_t ) 1U;
++        }
++        uxNewPriority = FREERTOS_PRIORITY_TO_RTTHREAD( uxNewPriority );
++
++        level = rt_hw_interrupt_disable();
++
++        thread = ( rt_thread_t ) prvGetTCBFromHandle( xTask );
++        current_priority = thread->current_priority;
++        if ( current_priority != uxNewPriority )
++        {
++            rt_thread_control( thread, RT_THREAD_CTRL_CHANGE_PRIORITY, &uxNewPriority);
++            if ( uxNewPriority < current_priority )
++            {
++                /* The priority of a task other than the currently running task is being raised.
++                 * Need to schedule if the priority is raised above that of the running task */
++                if ( thread != rt_current_thread && uxNewPriority <= rt_current_thread->current_priority )
++                {
++                    need_schedule = RT_TRUE;
++                }
++            }
++            /* Setting the priority of the running task down means
++             * there may now be another task of higher priority that
++             * is ready to execute. */
++            else if ( thread == rt_current_thread )
++            {
++                need_schedule = RT_TRUE;
++            }
++        }
++
++        rt_hw_interrupt_enable( level );
++
++        if ( need_schedule == RT_TRUE )
++        {
++            rt_schedule();
++        }
++    }
++
++#endif /* INCLUDE_vTaskPrioritySet */
++/*-----------------------------------------------------------*/
++
++#if ( INCLUDE_vTaskSuspend == 1 )
++
++    void vTaskSuspend( TaskHandle_t xTaskToSuspend )
++    {
++        rt_thread_t thread = ( rt_thread_t ) prvGetTCBFromHandle( xTaskToSuspend );
++        if ( rt_thread_suspend( thread ) == RT_EOK )
++        {
++            rt_schedule();
++        }
++    }
++
++#endif /* INCLUDE_vTaskSuspend */
++/*-----------------------------------------------------------*/
++
++#if ( INCLUDE_vTaskSuspend == 1 )
++
++    void vTaskResume( TaskHandle_t xTaskToResume )
++    {
++        rt_thread_t thread = ( rt_thread_t ) xTaskToResume;
++        rt_bool_t need_schedule = RT_FALSE;
++        rt_base_t level;
++
++        /* It does not make sense to resume the calling task. */
++        configASSERT( xTaskToResume );
++
++        if ( thread != NULL && thread != rt_thread_self() )
++        {
++            level = rt_hw_interrupt_disable();
++            /* A task with higher priority than the current running task is ready */
++            if ( rt_thread_resume( thread ) == RT_EOK && thread->current_priority <= rt_thread_self()->current_priority )
++            {
++                need_schedule = RT_TRUE;
++            }
++            rt_hw_interrupt_enable( level );
++        }
++        if (need_schedule == RT_TRUE)
++        {
++            rt_schedule();
++        }
++    }
++
++#endif /* INCLUDE_vTaskSuspend */
++
++/*-----------------------------------------------------------*/
++
++#if ( ( INCLUDE_xTaskResumeFromISR == 1 ) && ( INCLUDE_vTaskSuspend == 1 ) )
++
++    BaseType_t xTaskResumeFromISR( TaskHandle_t xTaskToResume )
++    {
++        vTaskResume( xTaskToResume );
++        return pdFALSE;
++    }
++
++#endif /* ( ( INCLUDE_xTaskResumeFromISR == 1 ) && ( INCLUDE_vTaskSuspend == 1 ) ) */
++/*-----------------------------------------------------------*/
++
++void vTaskStartScheduler( void )
++{
++    xSchedulerRunning = pdTRUE;
++}
++/*-----------------------------------------------------------*/
++
++void vTaskEndScheduler( void )
++{
++    xSchedulerRunning = pdFALSE;
++    vPortEndScheduler();
++}
++/*----------------------------------------------------------*/
++
++#if ( configUSE_NEWLIB_REENTRANT == 1 )
++struct _reent* __getreent(void) {
++    return _GLOBAL_REENT;
++}
++#endif
++
++void vTaskSuspendAll( void )
++{
++    rt_enter_critical();
++}
++/*----------------------------------------------------------*/
++
++BaseType_t xTaskResumeAll( void )
++{
++    rt_exit_critical();
++    return pdFALSE;
++}
++/*-----------------------------------------------------------*/
++
++TickType_t xTaskGetTickCount( void )
++{
++    return rt_tick_get();
++}
++/*-----------------------------------------------------------*/
++
++TickType_t xTaskGetTickCountFromISR( void )
++{
++    return rt_tick_get();
++}
++/*-----------------------------------------------------------*/
++
++UBaseType_t uxTaskGetNumberOfTasks( void )
++{
++    UBaseType_t uxReturn = 0;
++    rt_base_t level;
++    struct rt_object_information *information;
++    struct rt_list_node *node = RT_NULL;
++
++    information = rt_object_get_information( RT_Object_Class_Thread );
++    RT_ASSERT( information != RT_NULL );
++
++    level = rt_hw_interrupt_disable();
++
++    rt_list_for_each( node, &( information->object_list ) )
++    {
++        uxReturn += 1;
++    }
++
++    rt_hw_interrupt_enable( level );
++
++    return uxReturn;
++}
++/*-----------------------------------------------------------*/
++
++char * pcTaskGetName( TaskHandle_t xTaskToQuery )
++{
++    rt_thread_t thread = ( rt_thread_t ) prvGetTCBFromHandle( xTaskToQuery );
++    return &( thread->name[ 0 ] );
++}
++/*-----------------------------------------------------------*/
++
++#if ( INCLUDE_xTaskGetHandle == 1 )
++
++    TaskHandle_t xTaskGetHandle( const char * pcNameToQuery )
++    {
++        return ( TaskHandle_t ) rt_thread_find( ( char * ) pcNameToQuery );
++    }
++
++#endif /* INCLUDE_xTaskGetHandle */
++/*-----------------------------------------------------------*/
++
++#if ( INCLUDE_xTaskGetIdleTaskHandle == 1 )
++
++    TaskHandle_t xTaskGetIdleTaskHandle( void )
++    {
++        return ( TaskHandle_t ) rt_thread_find( "tidle0" );
++    }
++
++#endif /* INCLUDE_xTaskGetIdleTaskHandle */
++/*----------------------------------------------------------*/
++
++#if ( INCLUDE_xTaskAbortDelay == 1 )
++
++    BaseType_t xTaskAbortDelay( TaskHandle_t xTask )
++    {
++        TCB_t * pxTCB = xTask;
++        BaseType_t xReturn;
++        rt_thread_t thread = ( rt_thread_t ) xTask;
++        rt_bool_t need_schedule = RT_FALSE;
++        rt_base_t level;
++
++        configASSERT( pxTCB );
++
++        level = rt_hw_interrupt_disable();
++
++        if ( eTaskGetState( xTask ) == eBlocked )
++        {
++            rt_thread_resume( thread );
++            thread->error = -RT_ETIMEOUT;
++            pxTCB->ucDelayAborted = pdTRUE;
++            if ( thread->current_priority < rt_thread_self()->current_priority ){
++                need_schedule = RT_TRUE;
++            }
++            xReturn = pdPASS;
++        }
++        else
++        {
++            xReturn = pdFAIL;
++        }
++
++        rt_hw_interrupt_enable( level );
++
++        if ( need_schedule == RT_TRUE )
++        {
++            rt_schedule();
++        }
++
++        return xReturn;
++    }
++
++#endif /* INCLUDE_xTaskAbortDelay */
++/*----------------------------------------------------------*/
++
++#if ( configUSE_APPLICATION_TASK_TAG == 1 )
++
++    void vTaskSetApplicationTaskTag( TaskHandle_t xTask,
++                                     TaskHookFunction_t pxHookFunction )
++    {
++        TCB_t * xTCB = prvGetTCBFromHandle( xTask );
++        rt_base_t level;
++
++        level = rt_hw_interrupt_disable();
++        xTCB->pxTaskTag = pxHookFunction;
++        rt_hw_interrupt_enable( level );
++    }
++
++#endif /* configUSE_APPLICATION_TASK_TAG */
++/*-----------------------------------------------------------*/
++
++#if ( configUSE_APPLICATION_TASK_TAG == 1 )
++
++    TaskHookFunction_t xTaskGetApplicationTaskTag( TaskHandle_t xTask )
++    {
++        TaskHookFunction_t xReturn;
++        TCB_t * xTCB = prvGetTCBFromHandle( xTask );
++        rt_base_t level;
++
++        level = rt_hw_interrupt_disable();
++        xReturn = xTCB->pxTaskTag;
++        rt_hw_interrupt_enable( level );
++
++        return xReturn;
++    }
++
++#endif /* configUSE_APPLICATION_TASK_TAG */
++/*-----------------------------------------------------------*/
++
++#if ( configUSE_APPLICATION_TASK_TAG == 1 )
++
++    TaskHookFunction_t xTaskGetApplicationTaskTagFromISR( TaskHandle_t xTask )
++    {
++        return xTaskGetApplicationTaskTag( xTask );
++    }
++
++#endif /* configUSE_APPLICATION_TASK_TAG */
++/*-----------------------------------------------------------*/
++
++#if ( configUSE_APPLICATION_TASK_TAG == 1 )
++
++    BaseType_t xTaskCallApplicationTaskHook( TaskHandle_t xTask,
++                                             void * pvParameter )
++    {
++        BaseType_t xReturn;
++        TCB_t * xTCB = prvGetTCBFromHandle( xTask );
++
++        if( xTCB->pxTaskTag != NULL )
++        {
++            xReturn = xTCB->pxTaskTag( pvParameter );
++        }
++        else
++        {
++            xReturn = pdFAIL;
++        }
++
++        return xReturn;
++    }
++
++#endif /* configUSE_APPLICATION_TASK_TAG */
++/*-----------------------------------------------------------*/
++
++void vTaskSetTimeOutState( TimeOut_t * const pxTimeOut )
++{
++    rt_base_t level;
++
++    configASSERT( pxTimeOut );
++    level = rt_hw_interrupt_disable();
++    pxTimeOut->xOverflowCount = 0;
++    pxTimeOut->xTimeOnEntering = ( TickType_t ) rt_tick_get();
++    rt_hw_interrupt_enable( level );
++}
++/*-----------------------------------------------------------*/
++
++void vTaskInternalSetTimeOutState( TimeOut_t * const pxTimeOut )
++{
++    /* For internal use only as it does not use a critical section. */
++    pxTimeOut->xOverflowCount = 0;
++    pxTimeOut->xTimeOnEntering = ( TickType_t ) rt_tick_get();;
++}
++/*-----------------------------------------------------------*/
++
++BaseType_t xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut,
++                                 TickType_t * const pxTicksToWait )
++{
++    TCB_t * pxCurrentTCB = ( TCB_t * ) rt_thread_self();
++    BaseType_t xReturn;
++    rt_base_t level;
++
++    configASSERT( pxTimeOut );
++    configASSERT( pxTicksToWait );
++
++    level = rt_hw_interrupt_disable();
++    /* Minor optimisation.  The tick count cannot change in this block. */
++    const TickType_t xConstTickCount = ( TickType_t ) rt_tick_get();
++    const TickType_t xElapsedTime = xConstTickCount - pxTimeOut->xTimeOnEntering;
++
++#if ( INCLUDE_xTaskAbortDelay == 1 )
++    if( pxCurrentTCB->ucDelayAborted != ( uint8_t ) pdFALSE )
++    {
++        /* The delay was aborted, which is not the same as a time out,
++         * but has the same result. */
++        pxCurrentTCB->ucDelayAborted = pdFALSE;
++        xReturn = pdTRUE;
++    }
++    else
++#endif
++
++#if ( INCLUDE_vTaskSuspend == 1 )
++    if( *pxTicksToWait == portMAX_DELAY )
++    {
++        /* If INCLUDE_vTaskSuspend is set to 1 and the block time
++         * specified is the maximum block time then the task should block
++         * indefinitely, and therefore never time out. */
++        xReturn = pdFALSE;
++    }
++    else
++#endif
++
++    if( xElapsedTime < *pxTicksToWait )
++    {
++        /* Not a genuine timeout. Adjust parameters for time remaining. */
++        *pxTicksToWait -= xElapsedTime;
++        vTaskInternalSetTimeOutState( pxTimeOut );
++        xReturn = pdFALSE;
++    }
++    else
++    {
++        *pxTicksToWait = ( TickType_t ) 0;
++        xReturn = pdTRUE;
++    }
++    rt_hw_interrupt_enable( level );
++
++    return xReturn;
++}
++/*-----------------------------------------------------------*/
++
++#if ( ( INCLUDE_xTaskGetCurrentTaskHandle == 1 ) )
++
++    TaskHandle_t xTaskGetCurrentTaskHandle( void )
++    {
++        TaskHandle_t xReturn;
++
++        /* A critical section is not required as this is not called from
++         * an interrupt and the current TCB will always be the same for any
++         * individual execution thread. */
++        xReturn = ( TaskHandle_t ) rt_thread_self();
++
++        return xReturn;
++    }
++
++#endif /* ( ( INCLUDE_xTaskGetCurrentTaskHandle == 1 ) || ( configUSE_MUTEXES == 1 ) ) */
++/*-----------------------------------------------------------*/
++
++#if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
++
++    BaseType_t xTaskGetSchedulerState( void )
++    {
++        BaseType_t xReturn;
++
++        if( xSchedulerRunning == pdFALSE )
++        {
++            xReturn = taskSCHEDULER_NOT_STARTED;
++        }
++        else
++        {
++            if( rt_critical_level() == 0 )
++            {
++                xReturn = taskSCHEDULER_RUNNING;
++            }
++            else
++            {
++                xReturn = taskSCHEDULER_SUSPENDED;
++            }
++        }
++
++        return xReturn;
++    }
++
++#endif /* ( ( INCLUDE_xTaskGetSchedulerState == 1 ) ) */
++/*-----------------------------------------------------------*/
++
++#if ( configUSE_TASK_NOTIFICATIONS == 1 )
++
++    uint32_t ulTaskGenericNotifyTake( UBaseType_t uxIndexToWait,
++                                      BaseType_t xClearCountOnExit,
++                                      TickType_t xTicksToWait )
++    {
++        uint32_t ulReturn;
++        TCB_t * pxCurrentTCB = ( TCB_t * ) rt_thread_self();
++        rt_thread_t thread = ( rt_thread_t ) pxCurrentTCB;
++        rt_base_t level;
++
++        configASSERT( uxIndexToWait < configTASK_NOTIFICATION_ARRAY_ENTRIES );
++
++        level = rt_hw_interrupt_disable();
++        /* Only block if the notification count is not already non-zero. */
++        if( pxCurrentTCB->ulNotifiedValue[ uxIndexToWait ] == 0UL )
++        {
++            /* Mark this task as waiting for a notification. */
++            pxCurrentTCB->ucNotifyState[ uxIndexToWait ] = taskWAITING_NOTIFICATION;
++
++            if( xTicksToWait > ( TickType_t ) 0 )
++            {
++                rt_thread_suspend( thread );
++                if ( ( rt_int32_t ) xTicksToWait > 0 )
++                {
++                    rt_timer_control(&(thread->thread_timer),
++                                     RT_TIMER_CTRL_SET_TIME,
++                                     &xTicksToWait);
++                    rt_timer_start(&(thread->thread_timer));
++                }
++                rt_hw_interrupt_enable(level);
++                rt_schedule();
++                /* Clear thread error. */
++                thread->error = RT_EOK;
++            }
++        }
++        rt_hw_interrupt_enable( level );
++
++        level = rt_hw_interrupt_disable();
++        ulReturn = pxCurrentTCB->ulNotifiedValue[ uxIndexToWait ];
++
++        if( ulReturn != 0UL )
++        {
++            if( xClearCountOnExit != pdFALSE )
++            {
++                pxCurrentTCB->ulNotifiedValue[ uxIndexToWait ] = 0UL;
++            }
++            else
++            {
++                pxCurrentTCB->ulNotifiedValue[ uxIndexToWait ] = ulReturn - ( uint32_t ) 1;
++            }
++        }
++
++        pxCurrentTCB->ucNotifyState[ uxIndexToWait ] = taskNOT_WAITING_NOTIFICATION;
++        rt_hw_interrupt_enable( level );
++
++        return ulReturn;
++    }
++
++#endif /* configUSE_TASK_NOTIFICATIONS */
++/*-----------------------------------------------------------*/
++
++#if ( configUSE_TASK_NOTIFICATIONS == 1 )
++
++    BaseType_t xTaskGenericNotifyWait( UBaseType_t uxIndexToWait,
++                                       uint32_t ulBitsToClearOnEntry,
++                                       uint32_t ulBitsToClearOnExit,
++                                       uint32_t * pulNotificationValue,
++                                       TickType_t xTicksToWait )
++    {
++        BaseType_t xReturn;
++        TCB_t * pxCurrentTCB = ( TCB_t * ) rt_thread_self();
++        rt_thread_t thread = ( rt_thread_t ) pxCurrentTCB;
++        rt_base_t level;
++
++        configASSERT( uxIndexToWait < configTASK_NOTIFICATION_ARRAY_ENTRIES );
++
++        level = rt_hw_interrupt_disable();
++        /* Only block if a notification is not already pending. */
++        if( pxCurrentTCB->ucNotifyState[ uxIndexToWait ] != taskNOTIFICATION_RECEIVED )
++        {
++            /* Clear bits in the task's notification value as bits may get
++             * set  by the notifying task or interrupt.  This can be used to
++             * clear the value to zero. */
++            pxCurrentTCB->ulNotifiedValue[ uxIndexToWait ] &= ~ulBitsToClearOnEntry;
++
++            /* Mark this task as waiting for a notification. */
++            pxCurrentTCB->ucNotifyState[ uxIndexToWait ] = taskWAITING_NOTIFICATION;
++
++            if( xTicksToWait > ( TickType_t ) 0 )
++            {
++                rt_thread_suspend( thread );
++                if ( ( rt_int32_t ) xTicksToWait > 0 )
++                {
++                    rt_timer_control(&(thread->thread_timer),
++                                     RT_TIMER_CTRL_SET_TIME,
++                                     &xTicksToWait);
++                    rt_timer_start(&(thread->thread_timer));
++                }
++                rt_hw_interrupt_enable(level);
++                rt_schedule();
++                /* Clear thread error. It is not used to determine the function return value. */
++                thread->error = RT_EOK;
++            }
++            else
++            {
++                rt_hw_interrupt_enable( level );
++            }
++        }
++        else
++        {
++            rt_hw_interrupt_enable( level );
++        }
++
++        level = rt_hw_interrupt_disable();
++
++        if( pulNotificationValue != NULL )
++        {
++            /* Output the current notification value, which may or may not
++             * have changed. */
++            *pulNotificationValue = pxCurrentTCB->ulNotifiedValue[ uxIndexToWait ];
++        }
++
++        /* If ucNotifyValue is set then either the task never entered the
++         * blocked state (because a notification was already pending) or the
++         * task unblocked because of a notification.  Otherwise the task
++         * unblocked because of a timeout. */
++        if( pxCurrentTCB->ucNotifyState[ uxIndexToWait ] != taskNOTIFICATION_RECEIVED )
++        {
++            /* A notification was not received. */
++            xReturn = pdFALSE;
++        }
++        else
++        {
++            /* A notification was already pending or a notification was
++             * received while the task was waiting. */
++            pxCurrentTCB->ulNotifiedValue[ uxIndexToWait ] &= ~ulBitsToClearOnExit;
++            xReturn = pdTRUE;
++        }
++
++        pxCurrentTCB->ucNotifyState[ uxIndexToWait ] = taskNOT_WAITING_NOTIFICATION;
++        rt_hw_interrupt_enable( level );
++
++        return xReturn;
++    }
++
++#endif /* configUSE_TASK_NOTIFICATIONS */
++/*-----------------------------------------------------------*/
++
++#if ( configUSE_TASK_NOTIFICATIONS == 1 )
++
++    BaseType_t xTaskGenericNotify( TaskHandle_t xTaskToNotify,
++                                   UBaseType_t uxIndexToNotify,
++                                   uint32_t ulValue,
++                                   eNotifyAction eAction,
++                                   uint32_t * pulPreviousNotificationValue )
++    {
++        TCB_t * pxTCB;
++        BaseType_t xReturn = pdPASS;
++        uint8_t ucOriginalNotifyState;
++        rt_base_t level;
++
++        configASSERT( uxIndexToNotify < configTASK_NOTIFICATION_ARRAY_ENTRIES );
++        configASSERT( xTaskToNotify );
++        pxTCB = xTaskToNotify;
++
++        level = rt_hw_interrupt_disable();
++
++        if( pulPreviousNotificationValue != NULL )
++        {
++            *pulPreviousNotificationValue = pxTCB->ulNotifiedValue[ uxIndexToNotify ];
++        }
++
++        ucOriginalNotifyState = pxTCB->ucNotifyState[ uxIndexToNotify ];
++
++        pxTCB->ucNotifyState[ uxIndexToNotify ] = taskNOTIFICATION_RECEIVED;
++
++        switch( eAction )
++        {
++            case eSetBits:
++                pxTCB->ulNotifiedValue[ uxIndexToNotify ] |= ulValue;
++                break;
++
++            case eIncrement:
++                ( pxTCB->ulNotifiedValue[ uxIndexToNotify ] )++;
++                break;
++
++            case eSetValueWithOverwrite:
++                pxTCB->ulNotifiedValue[ uxIndexToNotify ] = ulValue;
++                break;
++
++            case eSetValueWithoutOverwrite:
++
++                if( ucOriginalNotifyState != taskNOTIFICATION_RECEIVED )
++                {
++                    pxTCB->ulNotifiedValue[ uxIndexToNotify ] = ulValue;
++                }
++                else
++                {
++                    /* The value could not be written to the task. */
++                    xReturn = pdFAIL;
++                }
++
++                break;
++
++            case eNoAction:
++
++                /* The task is being notified without its notify value being
++                 * updated. */
++                break;
++
++            default:
++
++                /* Should not get here if all enums are handled.
++                 * Artificially force an assert by testing a value the
++                 * compiler can't assume is const. */
++                configASSERT( xTaskToNotify == NULL );
++
++                break;
++        }
++
++
++        /* If the task is in the blocked state specifically to wait for a
++         * notification then unblock it now. */
++        if( ucOriginalNotifyState == taskWAITING_NOTIFICATION )
++        {
++            rt_thread_resume( ( rt_thread_t ) pxTCB );
++
++            if( ( ( rt_thread_t ) pxTCB )->current_priority < rt_thread_self()->current_priority )
++            {
++                /* The notified task has a priority above the currently
++                 * executing task so a schedule is required. */
++                rt_schedule();
++            }
++        }
++        rt_hw_interrupt_enable( level );
++
++        return xReturn;
++    }
++
++#endif /* configUSE_TASK_NOTIFICATIONS */
++/*-----------------------------------------------------------*/
++
++#if ( configUSE_TASK_NOTIFICATIONS == 1 )
++
++    BaseType_t xTaskGenericNotifyFromISR( TaskHandle_t xTaskToNotify,
++                                          UBaseType_t uxIndexToNotify,
++                                          uint32_t ulValue,
++                                          eNotifyAction eAction,
++                                          uint32_t * pulPreviousNotificationValue,
++                                          BaseType_t * pxHigherPriorityTaskWoken )
++    {
++        BaseType_t xReturn;
++
++        xReturn = xTaskGenericNotify( xTaskToNotify, uxIndexToNotify, ulValue, eAction, pulPreviousNotificationValue );
++        if ( pxHigherPriorityTaskWoken != NULL )
++        {
++            *pxHigherPriorityTaskWoken = pdFALSE;
++        }
++
++        return xReturn;
++    }
++
++#endif /* configUSE_TASK_NOTIFICATIONS */
++/*-----------------------------------------------------------*/
++
++#if ( configUSE_TASK_NOTIFICATIONS == 1 )
++
++    void vTaskGenericNotifyGiveFromISR( TaskHandle_t xTaskToNotify,
++                                        UBaseType_t uxIndexToNotify,
++                                        BaseType_t * pxHigherPriorityTaskWoken )
++    {
++        xTaskNotifyGiveIndexed( xTaskToNotify, uxIndexToNotify );
++        if ( pxHigherPriorityTaskWoken != NULL )
++        {
++            *pxHigherPriorityTaskWoken = pdFALSE;
++        }
++    }
++
++#endif /* configUSE_TASK_NOTIFICATIONS */
++/*-----------------------------------------------------------*/
++
++#if ( configUSE_TASK_NOTIFICATIONS == 1 )
++
++    BaseType_t xTaskGenericNotifyStateClear( TaskHandle_t xTask,
++                                             UBaseType_t uxIndexToClear )
++    {
++        TCB_t * pxTCB;
++        BaseType_t xReturn;
++        rt_base_t level;
++
++        configASSERT( uxIndexToClear < configTASK_NOTIFICATION_ARRAY_ENTRIES );
++
++        /* If null is passed in here then it is the calling task that is having
++         * its notification state cleared. */
++        pxTCB = prvGetTCBFromHandle( xTask );
++
++        level = rt_hw_interrupt_disable();
++
++        if( pxTCB->ucNotifyState[ uxIndexToClear ] == taskNOTIFICATION_RECEIVED )
++        {
++            pxTCB->ucNotifyState[ uxIndexToClear ] = taskNOT_WAITING_NOTIFICATION;
++            xReturn = pdPASS;
++        }
++        else
++        {
++            xReturn = pdFAIL;
++        }
++
++        rt_hw_interrupt_enable( level );
++
++        return xReturn;
++    }
++
++#endif /* configUSE_TASK_NOTIFICATIONS */
++/*-----------------------------------------------------------*/
++
++#if ( configUSE_TASK_NOTIFICATIONS == 1 )
++
++    uint32_t ulTaskGenericNotifyValueClear( TaskHandle_t xTask,
++                                            UBaseType_t uxIndexToClear,
++                                            uint32_t ulBitsToClear )
++    {
++        TCB_t * pxTCB;
++        uint32_t ulReturn;
++        rt_base_t level;
++
++        /* If null is passed in here then it is the calling task that is having
++         * its notification state cleared. */
++        pxTCB = prvGetTCBFromHandle( xTask );
++
++        level = rt_hw_interrupt_disable();
++
++        /* Return the notification as it was before the bits were cleared,
++         * then clear the bit mask. */
++        ulReturn = pxTCB->ulNotifiedValue[ uxIndexToClear ];
++        pxTCB->ulNotifiedValue[ uxIndexToClear ] &= ~ulBitsToClear;
++
++        rt_hw_interrupt_enable( level );
++
++        return ulReturn;
++    }
++
++#endif /* configUSE_TASK_NOTIFICATIONS */
++/*-----------------------------------------------------------*/
++
++#if ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 )
++
++/* uxTaskGetStackHighWaterMark() and uxTaskGetStackHighWaterMark2() are the
++ * same except for their return type.  Using configSTACK_DEPTH_TYPE allows the
++ * user to determine the return type.  It gets around the problem of the value
++ * overflowing on 8-bit types without breaking backward compatibility for
++ * applications that expect an 8-bit return type. */
++    configSTACK_DEPTH_TYPE uxTaskGetStackHighWaterMark2( TaskHandle_t xTask )
++    {
++        uint32_t ulCount = 0U;
++        rt_thread_t thread = ( rt_thread_t ) prvGetTCBFromHandle( xTask );
++        rt_uint8_t * stack_addr = thread->stack_addr;
++
++    #ifdef ARCH_CPU_STACK_GROWS_UPWARD
++        stack_addr = stack_addr + thread->stack_size - 1;
++        while ( *stack_addr == '#' )
++        {
++            ulCount += 1;
++            stack_addr -= 1;
++        }
++    #else
++        while ( *stack_addr == '#' )
++        {
++            ulCount += 1;
++            stack_addr += 1;
++        }
++    #endif
++
++        ulCount /= ( uint32_t ) sizeof( StackType_t );
++
++        return ( configSTACK_DEPTH_TYPE ) ulCount;
++    }
++
++#endif /* INCLUDE_uxTaskGetStackHighWaterMark2 */
++/*-----------------------------------------------------------*/
++
++#if ( INCLUDE_uxTaskGetStackHighWaterMark == 1 )
++
++    UBaseType_t uxTaskGetStackHighWaterMark( TaskHandle_t xTask )
++    {
++        return ( UBaseType_t ) uxTaskGetStackHighWaterMark2( xTask );
++    }
++
++#endif /* INCLUDE_uxTaskGetStackHighWaterMark */
++/*-----------------------------------------------------------*/
++
++
++/* ESP32 */
++BaseType_t xTaskGetAffinity( TaskHandle_t xTask )
++{
++    ( void ) xTask;
++    return 0;
++}
++
++TaskHandle_t xTaskGetCurrentTaskHandleForCPU( BaseType_t cpuid )
++{
++    ( void ) cpuid;
++    return xTaskGetCurrentTaskHandle();
++}
++
++TaskHandle_t xTaskGetIdleTaskHandleForCPU( UBaseType_t cpuid )
++{
++    ( void ) cpuid;
++    return xTaskGetIdleTaskHandle();
++}
++
++/* Unimplemented */
++#include "esp_log.h"
++#if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS > 0 )
++void vTaskSetThreadLocalStoragePointer( TaskHandle_t xTaskToSet,
++                                            BaseType_t xIndex,
++                                            void * pvValue )
++{
++    ESP_LOGE("freertos", "vTaskSetThreadLocalStoragePointer unimplemented");
++    RT_ASSERT(0);
++}
++void * pvTaskGetThreadLocalStoragePointer( TaskHandle_t xTaskToQuery,
++                                               BaseType_t xIndex )
++{
++    ESP_LOGE("freertos", "pvTaskGetThreadLocalStoragePointer unimplemented");
++    RT_ASSERT(0);
++    return NULL;
++}
++#if ( configTHREAD_LOCAL_STORAGE_DELETE_CALLBACKS )
++typedef void (*TlsDeleteCallbackFunction_t)( int, void * );
++void vTaskSetThreadLocalStoragePointerAndDelCallback( TaskHandle_t xTaskToSet, BaseType_t xIndex, void *pvValue, TlsDeleteCallbackFunction_t pvDelCallback)
++{
++    ESP_LOGE("freertos", "vTaskSetThreadLocalStoragePointerAndDelCallback unimplemented");
++    RT_ASSERT(0);
++}
++#endif
++#endif
+diff --git a/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/timers.c b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/timers.c
+new file mode 100644
+index 0000000000..b5b5693d53
+--- /dev/null
++++ b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/FreeRTOS/timers.c
+@@ -0,0 +1,328 @@
++/*
++ * FreeRTOS Kernel V10.4.6
++ * 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
++ *
++ */
++
++/* Standard includes. */
++#include <stdlib.h>
++
++#include "FreeRTOS.h"
++#include "task.h"
++#include "queue.h"
++#include "timers.h"
++
++/* This entire source file will be skipped if the application is not configured
++ * to include software timer functionality.  This #if is closed at the very bottom
++ * of this file.  If you want to include software timer functionality then ensure
++ * configUSE_TIMERS is set to 1 in FreeRTOSConfig.h. */
++#if ( configUSE_TIMERS == 1 )
++
++    typedef void (* rt_timer_callback_t)(void *);
++
++/* The definition of the timers themselves. */
++    typedef struct tmrTimerControl
++    {
++        struct rt_timer timer;
++        void * pvTimerID;                           /*<< An ID to identify the timer.  This allows the timer to be identified when the same callback is used for multiple timers. */
++    } xTIMER;
++
++    typedef xTIMER Timer_t;
++
++/*-----------------------------------------------------------*/
++
++    #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
++
++        TimerHandle_t xTimerCreate( const char * const pcTimerName,
++                                    const TickType_t xTimerPeriodInTicks,
++                                    const UBaseType_t uxAutoReload,
++                                    void * const pvTimerID,
++                                    TimerCallbackFunction_t pxCallbackFunction )
++        {
++            Timer_t * pxNewTimer;
++            rt_uint8_t flag = RT_TIMER_FLAG_SOFT_TIMER;
++
++            pxNewTimer = ( Timer_t * ) RT_KERNEL_MALLOC( sizeof( Timer_t ) );
++
++            if( pxNewTimer != RT_NULL )
++            {
++                if ( uxAutoReload != pdFALSE )
++                {
++                    flag |= RT_TIMER_FLAG_PERIODIC;
++                }
++                else
++                {
++                    flag |= RT_TIMER_FLAG_ONE_SHOT;
++                }
++                rt_timer_init( ( rt_timer_t ) pxNewTimer, pcTimerName, ( rt_timer_callback_t ) pxCallbackFunction, pxNewTimer, xTimerPeriodInTicks, flag );
++                pxNewTimer->pvTimerID = pvTimerID;
++                /* Mark as dynamic so we can distinguish when deleting */
++                ( ( rt_timer_t ) pxNewTimer )->parent.type &= ~RT_Object_Class_Static;
++            }
++
++            return pxNewTimer;
++        }
++
++    #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
++/*-----------------------------------------------------------*/
++
++    #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
++
++        TimerHandle_t xTimerCreateStatic( const char * const pcTimerName,
++                                          const TickType_t xTimerPeriodInTicks,
++                                          const UBaseType_t uxAutoReload,
++                                          void * const pvTimerID,
++                                          TimerCallbackFunction_t pxCallbackFunction,
++                                          StaticTimer_t * pxTimerBuffer )
++        {
++            Timer_t * pxNewTimer;
++            rt_uint8_t flag = RT_TIMER_FLAG_SOFT_TIMER;
++
++            #if ( configASSERT_DEFINED == 1 )
++                {
++                    /* Sanity check that the size of the structure used to declare a
++                     * variable of type StaticTimer_t equals the size of the real timer
++                     * structure. */
++                    volatile size_t xSize = sizeof( StaticTimer_t );
++                    configASSERT( xSize == sizeof( Timer_t ) );
++                    ( void ) xSize; /* Keeps lint quiet when configASSERT() is not defined. */
++                }
++            #endif /* configASSERT_DEFINED */
++
++            /* A pointer to a StaticTimer_t structure MUST be provided, use it. */
++            configASSERT( pxTimerBuffer );
++            pxNewTimer = ( Timer_t * ) pxTimerBuffer;
++
++            if( pxNewTimer != NULL )
++            {
++                if ( uxAutoReload != pdFALSE )
++                {
++                    flag |= RT_TIMER_FLAG_PERIODIC;
++                }
++                else
++                {
++                    flag |= RT_TIMER_FLAG_ONE_SHOT;
++                }
++                rt_timer_init( ( rt_timer_t ) pxNewTimer, pcTimerName, ( rt_timer_callback_t ) pxCallbackFunction, pxNewTimer, xTimerPeriodInTicks, flag );
++                pxNewTimer->pvTimerID = pvTimerID;
++            }
++
++            return pxNewTimer;
++        }
++
++    #endif /* configSUPPORT_STATIC_ALLOCATION */
++/*-----------------------------------------------------------*/
++
++    BaseType_t xTimerGenericCommand( TimerHandle_t xTimer,
++                                     const BaseType_t xCommandID,
++                                     const TickType_t xOptionalValue,
++                                     BaseType_t * const pxHigherPriorityTaskWoken,
++                                     const TickType_t xTicksToWait )
++    {
++        rt_err_t err = -RT_ERROR;
++
++        configASSERT( xTimer );
++
++        if ( ( xCommandID == tmrCOMMAND_START ) || ( xCommandID == tmrCOMMAND_START_FROM_ISR )
++             || ( xCommandID == tmrCOMMAND_RESET ) || ( xCommandID == tmrCOMMAND_RESET_FROM_ISR ) )
++        {
++            err = rt_timer_start( ( rt_timer_t ) xTimer );
++        }
++        else if ( ( xCommandID == tmrCOMMAND_STOP ) || ( xCommandID == tmrCOMMAND_STOP_FROM_ISR ) )
++        {
++            err = rt_timer_stop( ( rt_timer_t ) xTimer );
++        }
++        else if ( ( xCommandID == tmrCOMMAND_CHANGE_PERIOD ) || ( xCommandID == tmrCOMMAND_CHANGE_PERIOD_FROM_ISR ) )
++        {
++            if ( rt_timer_stop( ( rt_timer_t ) xTimer ) == RT_EOK )
++            {
++                if ( rt_timer_control( ( rt_timer_t ) xTimer, RT_TIMER_CTRL_SET_TIME, ( void * ) &xOptionalValue ) == RT_EOK )
++                {
++                    err = rt_timer_start( ( rt_timer_t ) xTimer );
++                }
++            }
++        }
++        else if ( xCommandID == tmrCOMMAND_DELETE )
++        {
++        #if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
++            if ( rt_object_is_systemobject( ( rt_object_t ) xTimer ) )
++        #endif
++            {
++            #if ( configSUPPORT_STATIC_ALLOCATION == 1 )
++                err = rt_timer_detach( ( rt_timer_t ) xTimer );
++            #endif
++        #if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
++            }
++            else
++            {
++        #endif
++            #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
++                ( ( rt_timer_t ) xTimer )->parent.type |= RT_Object_Class_Static;
++                err = rt_timer_detach( ( rt_timer_t ) xTimer );
++                RT_KERNEL_FREE( xTimer );
++            #endif
++            }
++        }
++
++        if ( ( xCommandID >= tmrFIRST_FROM_ISR_COMMAND ) && ( xCommandID <= tmrCOMMAND_CHANGE_PERIOD_FROM_ISR ) && ( pxHigherPriorityTaskWoken != NULL ) )
++        {
++            *pxHigherPriorityTaskWoken = pdFALSE;
++        }
++
++        return rt_err_to_freertos( err );
++    }
++/*-----------------------------------------------------------*/
++
++    TaskHandle_t xTimerGetTimerDaemonTaskHandle( void )
++    {
++        return ( TaskHandle_t ) rt_thread_find( "timer" );
++    }
++/*-----------------------------------------------------------*/
++
++    TickType_t xTimerGetPeriod( TimerHandle_t xTimer )
++    {
++        Timer_t * pxTimer = xTimer;
++        rt_tick_t arg;
++
++        configASSERT( xTimer );
++        rt_timer_control( ( rt_timer_t ) pxTimer, RT_TIMER_CTRL_GET_TIME, &arg );
++
++        return ( TickType_t ) arg;
++    }
++/*-----------------------------------------------------------*/
++
++    void vTimerSetReloadMode( TimerHandle_t xTimer,
++                              const UBaseType_t uxAutoReload )
++    {
++        Timer_t * pxTimer = xTimer;
++
++        configASSERT( xTimer );
++        if ( uxAutoReload != pdFALSE )
++        {
++            rt_timer_control( ( rt_timer_t ) pxTimer, RT_TIMER_CTRL_SET_PERIODIC, RT_NULL );
++        }
++        else
++        {
++            rt_timer_control( ( rt_timer_t ) pxTimer, RT_TIMER_CTRL_SET_ONESHOT, RT_NULL );
++        }
++    }
++/*-----------------------------------------------------------*/
++
++    UBaseType_t uxTimerGetReloadMode( TimerHandle_t xTimer )
++    {
++        Timer_t * pxTimer = xTimer;
++        UBaseType_t uxReturn;
++        rt_base_t level;
++
++        configASSERT( xTimer );
++        level = rt_hw_interrupt_disable();
++        if ( ( ( rt_timer_t ) pxTimer )->parent.flag & RT_TIMER_FLAG_PERIODIC )
++        {
++            uxReturn = ( UBaseType_t ) pdTRUE;
++        }
++        else
++        {
++            uxReturn = ( UBaseType_t ) pdFALSE;
++        }
++        rt_hw_interrupt_enable( level );
++
++        return uxReturn;
++    }
++/*-----------------------------------------------------------*/
++
++    TickType_t xTimerGetExpiryTime( TimerHandle_t xTimer )
++    {
++        Timer_t * pxTimer = xTimer;
++        TickType_t xReturn;
++
++        configASSERT( xTimer );
++        rt_timer_control( ( rt_timer_t ) pxTimer, RT_TIMER_CTRL_GET_REMAIN_TIME, &xReturn );
++
++        return xReturn;
++    }
++/*-----------------------------------------------------------*/
++
++    const char * pcTimerGetName( TimerHandle_t xTimer )
++    {
++        Timer_t * pxTimer = xTimer;
++
++        configASSERT( xTimer );
++        return ( ( rt_timer_t ) pxTimer )->parent.name;
++    }
++/*-----------------------------------------------------------*/
++
++    BaseType_t xTimerIsTimerActive( TimerHandle_t xTimer )
++    {
++        BaseType_t xReturn;
++        Timer_t * pxTimer = xTimer;
++        rt_uint32_t arg;
++
++        configASSERT( xTimer );
++
++        rt_timer_control( ( rt_timer_t ) pxTimer, RT_TIMER_CTRL_GET_STATE, &arg );
++        if ( arg == RT_TIMER_FLAG_ACTIVATED )
++        {
++            xReturn = pdTRUE;
++        }
++        else
++        {
++            xReturn = pdFALSE;
++        }
++
++        return xReturn;
++    }
++/*-----------------------------------------------------------*/
++
++    void * pvTimerGetTimerID( const TimerHandle_t xTimer )
++    {
++        Timer_t * const pxTimer = xTimer;
++        void * pvReturn;
++        rt_base_t level;
++
++        configASSERT( xTimer );
++
++        level = rt_hw_interrupt_disable();
++        pvReturn = pxTimer->pvTimerID;
++        rt_hw_interrupt_enable( level );
++
++        return pvReturn;
++    }
++/*-----------------------------------------------------------*/
++
++    void vTimerSetTimerID( TimerHandle_t xTimer,
++                           void * pvNewID )
++    {
++        Timer_t * const pxTimer = xTimer;
++        rt_base_t level;
++
++        configASSERT( xTimer );
++
++        level = rt_hw_interrupt_disable();
++        pxTimer->pvTimerID = pvNewID;
++        rt_hw_interrupt_enable( level );
++    }
++/*-----------------------------------------------------------*/
++
++#endif /* configUSE_TIMERS == 1 */
+diff --git a/components/freertos/RT-Thread-wrapper-of-FreeRTOS/readme.md b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/readme.md
+new file mode 100644
+index 0000000000..6a0fafb4c7
+--- /dev/null
++++ b/components/freertos/RT-Thread-wrapper-of-FreeRTOS/readme.md
+@@ -0,0 +1,3 @@
++# RT-Thread操作系统的FreeRTOS兼容层
++## FreeRTOS Application Compatibility Layer (ACL) for RT-Thread
++## 让基于FreeRTOS开发的应用层无感地迁移到RT-Thread操作系统
+-- 
+2.32.0 (Apple Git-132)
+
+
+From 9981521890074b517074bf85a4e0a1f71cef851e Mon Sep 17 00:00:00 2001
+From: tangzz98 <[email protected]>
+Date: Wed, 3 Aug 2022 16:17:06 +0800
+Subject: [PATCH 4/4] Update linker script for finsh
+
+---
+ components/esp_system/ld/esp32c3/sections.ld.in | 10 ++++++++++
+ 1 file changed, 10 insertions(+)
+
+diff --git a/components/esp_system/ld/esp32c3/sections.ld.in b/components/esp_system/ld/esp32c3/sections.ld.in
+index 8215237fff..561ae92318 100644
+--- a/components/esp_system/ld/esp32c3/sections.ld.in
++++ b/components/esp_system/ld/esp32c3/sections.ld.in
+@@ -248,6 +248,16 @@ SECTIONS
+     *(.fini.literal)
+     *(.fini)
+     *(.gnu.version)
++        
++    /* section information for finsh shell */
++    . = ALIGN(4);
++    __fsymtab_start = .;
++    KEEP(*(FSymTab))
++    __fsymtab_end = .;
++    . = ALIGN(4);
++    __vsymtab_start = .;
++    KEEP(*(VSymTab))
++    __vsymtab_end = .;
+ 
+     /** CPU will try to prefetch up to 16 bytes of
+       * of instructions. This means that any configuration (e.g. MMU, PMS) must allow
+-- 
+2.32.0 (Apple Git-132)
+
diff --git a/bsp/ESP32_C3/sdkconfig b/bsp/ESP32_C3/sdkconfig
index 5cff687a40..bb0a7931a6 100644
--- a/bsp/ESP32_C3/sdkconfig
+++ b/bsp/ESP32_C3/sdkconfig
@@ -600,7 +600,7 @@ CONFIG_FREERTOS_CORETIMER_SYSTIMER_LVL1=y
 # CONFIG_FREERTOS_CORETIMER_SYSTIMER_LVL3 is not set
 CONFIG_FREERTOS_SYSTICK_USES_SYSTIMER=y
 CONFIG_FREERTOS_OPTIMIZED_SCHEDULER=y
-CONFIG_FREERTOS_HZ=100
+CONFIG_FREERTOS_HZ=1000
 CONFIG_FREERTOS_ASSERT_ON_UNTESTED_FUNCTION=y
 # CONFIG_FREERTOS_CHECK_STACKOVERFLOW_NONE is not set
 # CONFIG_FREERTOS_CHECK_STACKOVERFLOW_PTRVAL is not set
@@ -628,8 +628,7 @@ CONFIG_FREERTOS_CHECK_MUTEX_GIVEN_BY_OWNER=y
 # CONFIG_FREERTOS_CHECK_PORT_CRITICAL_COMPLIANCE is not set
 # CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH is not set
 CONFIG_FREERTOS_DEBUG_OCDAWARE=y
-CONFIG_FREERTOS_ENABLE_TASK_SNAPSHOT=y
-# CONFIG_FREERTOS_PLACE_SNAPSHOT_FUNS_INTO_FLASH is not set
+# CONFIG_FREERTOS_ENABLE_TASK_SNAPSHOT is not set
 # end of FreeRTOS
 
 #