update Demo-Build/RISC-V32/readme.txt.

Signed-off-by: 零中断延迟的RTOS <cosyos@139.com>

CosyOS-III 版本更新记录.md

@@ -225,3 +225,102 @@
 * DEBUG输出（包括任务管理器和命令行）扩展至 中英文双语。
 * 更新日期：2026.03.10
 
+### V2.3.3
+* CosyOS-III Cube 新版发布，完美支持中文路径，无论是 CosyOS路径 还是 工程路径，都可随意用中文，不会有问题。<br>
+  同时修复了路径识别上的bug，可应对各种复杂路径，确保成功安装。
+* 更新日期：2026.04.06
+
+### V2.3.4
+* 优化了协作式调度和时间片轮转调度相关算法和细节。
+* uYieldTasking()，调整为：当开启相同优先级任务的协作式调度或时间片轮转调度时，才支持此项服务。
+* 更新日期：2026.04.16
+
+### V2.3.5
+* 部分关键字重命名，包括数据类型、变量名称、宏定义等。
+* 调整了大部分 const、volatile 关键字的位置，由数据类型之前调整为之后。
+* syscfg.h 中增加了选项，可配置安全运行时计数器的位数。
+* 更新日期：2026.06.10
+
+### V2.3.6
+* 有关任务启动的三个全局变量封装在一个结构体中。
+* 启动任务增加了新的安全策略，避免重复启动同一个任务。
+* 修复了一处有关任务调度的隐形bug。
+* 更新日期：2026.06.11
+
+### V2.3.7
+* 修复了 port_cmx_s.c 中的一处遗漏重命名。
+* 进一步优化了启动任务，提高可靠性。
+* 增加了一项新的服务，重置任务。
+* 更新日期：2026.06.13
+
+### V2.3.8
+* 超时链表由单向链表调整为双向链表。
+* 安全运行时，彻底解决其在特定情况下的不可靠因素。
+* 更新日期：2026.06.15
+
+### V2.3.9
+* 增加了新的栈监控机制，使得对主栈和任务栈用量的检查更为准确，进一步提高了可靠性并降低了栈溢出的风险。
+* 更新日期：2026.06.20
+
+### V2.4.0
+* 进一步优化了主栈检查，提升可靠性和易用性。
+* 修复了GCC编译器会产生警告的问题。
+* 更新日期：2026.06.22
+
+### V2.4.1
+* 增加配置选项，是否需要在用户中断中接收消息？
+* 创建服务功能升级，互斥信号量、二值信号量、计数信号量、飞信、邮箱等，提供了创建不初始化服务，<br>
+  该功能可用来创建相应的数组，或把它们封装在结构体中。
+* 更新日期：2026.06.28
+
+### V2.4.2
+* 内核代码和移植文件中，部分关键路径添加屏障指令，以保安全。
+* 裁剪掉了 for Cortex-M0 的 互斥访问机制二。
+* 更新日期：2026.07.04
+
+### V3.0.0
+* 重构了移植架构，为使未来的移植工作可以更顺利的进行。
+* 新增了对 RISC-V32 指令集架构的支持，并针对 青稞V4系列微处理器 进行测试和调优。
+* 中断FIFO服务技术进一步升级，优化了包括 中断FIFO服务装载器、中断FIFO服务处理器。<br>
+  针对 80251 推出了新的 中断FIFO服务互斥访问方案，新增方案包括 [INC]指令、关闭总中断。
+* 其它调整及优化。
+* 更新日期：2026.07.21
+
+### V3.0.1
+* 针对 RISC-V32，推出了自研先进技术，可实现 CH32V 全程开启硬件压栈。<br>
+  该技术为纯软件实现，不依赖特定硬件（0x804->bit5），V103、203 等皆可完美支持。
+* 优化了中断FIFO服务装载器，性能进一步提升。同时增加了新的互斥访问方案：关闭总中断（嵌套方式）。
+* 更新日期：2026.07.30
+
+### V3.0.2
+* 解决了 V3.0.1 版本中，硬件压栈相关技术的不可靠因素，确保系统稳定可靠运行。
+* 更新日期：2026.08.03
+
+### V3.0.3
+* V3.0.2 版本的硬件压栈技术仍存在不可靠因素，现已彻底解决。
+* 同时推出了 硬件压栈技术可靠性验证方法，以方便测试和验证。
+* 更新日期：2026.08.05
+
+### V3.0.4
+* 解决了 Cortex-M33 任务不能正常启动并运行的问题，可靠性进一步提升。
+* 更新日期：2026.08.07
+
+### V3.0.5
+* Cortex-M33 任务不能正常启动的问题解决后，导致 RISC-V 任务不能正常启动。<br>
+  紧急推出新版本解决上述问题，并使 RISC-V 的任务切换更加可靠。
+* 更新日期：2026.08.07
+
+### V3.0.6
+* for RISC-V32，推出了终极先进技术，可实现硬件压栈无需可靠性验证，即可确保任务切换的安全、可靠。
+* 更新日期：2026.08.09
+
+### V3.0.7
+* 针对 RV32 硬件压栈，分为两个文件，port_rv32e_HWS.S、port_rv32i_HWS.S，分别针对 RV32E 和 RV32I。
+* 针对 RV32E，中断FIFO服务的装载，新增了互斥访问机制。
+* 优化了 arm 互斥访问机制，当中断FIFO服务并发装载时，效率会有显著提升。
+* 更新日期：2026.08.14
+
+### V3.0.8
+* RISC-V32，系统滴答自动配置做出调整，计数模式调整为向上计数，以尽可能兼容青稞系列更多的型号。
+* 更新日期：2026.08.15
+

Demo-Build/80251/demo_debug.c

@@ -3,11 +3,12 @@
  * @file     demo_debug.c
  * @brief    例程-DEBUG for STC32G
  * @author   迟凯峰
- * @version  V1.0.1
- * @date     2025.10.20
+ * @version  V1.0.3
+ * @date     2026.07.31
  ******************************************************************************/
 
-#if 0 /* 编译开关 */
+#if 1 /* 编译开关 */ \
+ && defined ( __C251__ )
 
 #include "CosyOS.H"
 #if (SYSCFG_DEBUGGING == __ENABLED__)

Demo-Build/80251/demo_main.c

@@ -3,8 +3,8 @@
  * @file     demo_main.c
  * @brief    例程-主函数 for STC32G
  * @author   迟凯峰
- * @version  V1.0.2
- * @date     2025.10.20
+ * @version  V1.0.3
+ * @date     2026.06.20
  ******************************************************************************/
 
 #if 0 /* 编译开关 */
@@ -14,6 +14,11 @@
 
 int main(void)
 {
+    /* 主栈检查初始化 */// 在main函数的入口处
+    #if (SYSCFG_DEBUGGING == 1) && (MCUCFG_TASKSTACK_MODE & __MSP__)
+    uMainStack_CheckInit(256); // 传参主栈大小，务必与启动文件中定义值相同。
+    #endif
+
     /* USER INIT CODE BEGIN */
     
     /* USER INIT CODE END */

Demo-Build/80251/readme.txt

@@ -4,16 +4,24 @@
    CosyOS-配置 / syscfg.h -> 系统配置>>标准头文件，应首先被正确定义。
    而后，在 C251、A251 标签页中，可能需要添加标准头文件的包含路径。
 
-2、main函数（参照例程 demo_main.c）
+2、MCU配置
+   CosyOS-配置 / mcucfg_80251.h -> 系统时钟频率，需要正确定义。
+   内存方案配置，需根据edata内存的大小选择合适的方案。
+   基本的原则是：
+   （1）如果edata内存很大，优先考虑方案一。
+   （2）如果ddata内存适中，考虑方案二三四。
+   （3）如果edata内存很小，优先考虑方案五。
+
+3、main函数（参照例程 demo_main.c）
    初始化 PendSV中断（必须）
    配置 DEBUG（可选）
    启动 CosyOS（必须）
 
-3、系统中断（参照例程 demo_int.c）
+4、系统中断（参照例程 demo_int.c）
    屏蔽 定时器0中断原函数（必须）
    屏蔽 PendSV中断原函数（必须）
 
-4、DEBUG（可选，参照例程 demo_debug.c）
+5、DEBUG（可选，参照例程 demo_debug.c）
 
 不出意外的话，您的项目现在已经可以正常编译了。
 
@@ -34,4 +42,15 @@
    其中的用户定义部分，与PendSV中断配置、用户自定义任务切换现场保护
    等功能息息相关，在未来可能需要适当调整。
 
+--------------------------------------------------------------------
+
+其它注意事项
+
+1、任务栈SIZE不允许大于65535。
+2、CosyOS for 80251，原生仅适配 Keil C251 编译器，如果您使用其它编译器，
+   应注意以下事项：
+   （1）CosyOS 内核中需要 __C251__ 关键字做条件编译，移植汇编文件中需要
+        __A251__ 关键字做条件编译，如果编译器不支持该关键字可自行添加。
+   （2）其它可能的、未知的兼容性问题。
+
 

Demo-Build/8051/demo_debug.c

@@ -3,11 +3,12 @@
  * @file     demo_debug.c
  * @brief    例程-DEBUG for STC8H
  * @author   迟凯峰
- * @version  V1.0.1
- * @date     2025.10.20
+ * @version  V1.0.3
+ * @date     2026.07.31
  ******************************************************************************/
 
-#if 0 /* 编译开关 */
+#if 1 /* 编译开关 */ \
+ && defined ( __C51__ )
 
 #include "CosyOS.H"
 #if (SYSCFG_DEBUGGING == __ENABLED__)

Demo-Build/8051/demo_main.c

@@ -3,8 +3,8 @@
  * @file     demo_main.c
  * @brief    例程-主函数 for STC8H
  * @author   迟凯峰
- * @version  V1.0.2
- * @date     2025.10.20
+ * @version  V1.0.3
+ * @date     2026.06.20
  ******************************************************************************/
 
 #if 0 /* 编译开关 */
@@ -14,6 +14,11 @@
 
 int main(void)
 {
+    /* 主栈检查初始化 */// 在main函数的入口处
+    #if (SYSCFG_DEBUGGING == 1)
+    uMainStack_CheckInit();
+    #endif
+
     /* USER INIT CODE BEGIN */
     
     /* USER INIT CODE END */

Demo-Build/8051/readme.txt

@@ -4,16 +4,19 @@
    CosyOS-配置 / syscfg.h -> 系统配置>>标准头文件，应首先被正确定义。
    而后，在 C51、A51 标签页中，可能需要添加标准头文件的包含路径。
 
-2、main函数（参照例程 demo_main.c）
+2、MCU配置
+   CosyOS-配置 / mcucfg_8051.h -> 系统时钟频率，需要正确定义。
+
+3、main函数（参照例程 demo_main.c）
    初始化 PendSV中断（必须）
    配置 DEBUG（可选）
    启动 CosyOS（必须）
 
-3、系统中断（参照例程 demo_int.c）
+4、系统中断（参照例程 demo_int.c）
    屏蔽 定时器0中断原函数（必须）
    屏蔽 PendSV中断原函数（必须）
 
-4、DEBUG（可选，参照例程 demo_debug.c）
+5、DEBUG（可选，参照例程 demo_debug.c）
 
 不出意外的话，您的项目现在已经可以正常编译了。
 
@@ -64,4 +67,20 @@
    覆盖地图中应逐一查看这些函数，对于使用了内存的应手动修正调用树或
    移除覆盖分析。
 
+-------------------------------------------------------------------
+
+其它注意事项
+
+1、默认情况下，任务栈SIZE不允许大于255。只有在启用了XBPSTACK的任务切换
+   现场保护时，任务栈SIZE才允许大于255，最大可为65535。
+2、CosyOS for 8051，原生仅适配 Keil C51 编译器，如果您使用其它编译器，
+   应注意以下事项：
+   （1）CosyOS 内核中需要 __C51__ 关键字做条件编译，移植汇编文件中需要
+        __A51__ 关键字做条件编译，如果编译器不支持该关键字可自行添加。
+   （2）CosyOS 内核中会用到 #pragma NOAREGS 来实现相对寄存器访问，如果
+        编译器不支持应设法等效替换。
+   （3）已知某些编译器不支持 .s 汇编文件，可将移植文件中的 .s 文件更名为
+        .A51，如 port_8051s.s 更名为 port_8051s.A51。
+   （4）其它可能的、未知的兼容性问题。
+
 

Demo-Build/Cortex-M/demo_debug_fwl.c

@@ -1,13 +1,13 @@
 /**************************************************************************//**
  * @item     CosyOS-III 例程（系统构建）
  * @file     demo_debug_fwl.c
- * @brief    例程-DEBUG for STM32F4 use Standard Peripheric Driver
+ * @brief    例程-DEBUG for STM32 use Standard Peripheric Driver
  * @author   迟凯峰
- * @version  V1.0.1
- * @date     2026.02.19
+ * @version  V1.0.2
+ * @date     2026.06.28
  ******************************************************************************/
 
-#if 0 /* 编译开关 */ \
+#if 1 /* 编译开关 */ \
  && defined (USE_STDPERIPH_DRIVER)
 
 #include "CosyOS.H"
@@ -37,7 +37,15 @@
 
 ////////////////////////////////////////////////////////////////////////////////
 
+#if   (__CORTEX_M == 0)
+#include "stm32f0xx_usart.h"
+#elif (__CORTEX_M == 3)
+#include "stm32f10x_usart.h"
+#elif (__CORTEX_M == 4)
 #include "stm32f4xx_usart.h"
+#elif (__CORTEX_M == 7)
+#include "stm32h7xx_usart.h"
+#endif
 static char  u_debug_recv_buff[DEBUG_RECV_BUFF];
 static char *u_debug_recv_p = u_debug_recv_buff;
 #if   (DEBUG_MODE == 0)

Demo-Build/Cortex-M/demo_debug_hal.c

@@ -1,13 +1,13 @@
 /**************************************************************************//**
  * @item     CosyOS-III 例程（系统构建）
  * @file     demo_debug_hal.c
- * @brief    例程-DEBUG for STM32F4 use HAL Driver
+ * @brief    例程-DEBUG for STM32 use HAL Driver
  * @author   迟凯峰
- * @version  V1.0.1
- * @date     2026.02.19
+ * @version  V1.0.2
+ * @date     2026.06.28
  ******************************************************************************/
 
-#if 0 /* 编译开关 */ \
+#if 1 /* 编译开关 */ \
  && defined (USE_HAL_DRIVER)
 
 #include "CosyOS.H"

Demo-Build/Cortex-M/demo_main.c

@@ -3,8 +3,8 @@
  * @file     demo_main.c
  * @brief    例程-主函数 for Cortex-M
  * @author   迟凯峰
- * @version  V1.0.2
- * @date     2026.02.19
+ * @version  V1.0.4
+ * @date     2026.06.22
  ******************************************************************************/
 
 #if 0 /* 编译开关 */
@@ -14,6 +14,15 @@
 
 int main(void)
 {
+    /* 主栈检查初始化 */// 在main函数的入口处
+    #if (SYSCFG_DEBUGGING == 1)
+    #if defined ( __ICCARM__ ) // IAR EWARM
+    uMainStack_CheckInit();
+    #else // AC5/AC6/GCC
+    uMainStack_CheckInit(0x1000); // 传参主栈大小，务必与定义值相同。
+    #endif
+    #endif
+    
     /* USER INIT CODE BEGIN */
     // firmware library standard peripheric Driver
     #if   defined (USE_STDPERIPH_DRIVER)

Demo-Build/Cortex-M/readme.txt

@@ -6,24 +6,24 @@
 1、系统配置
    CosyOS-配置 / syscfg.h -> 系统配置>>标准头文件，应首先被正确定义。
 
-2、main函数（参照例程 demo_main.c）
+2、MCU配置
+   CosyOS-配置 / mcucfg_cmx.h，配置 系统中断 和 互斥访问方案。
+   Cortex-M3/M4/M7等内核：根据系统中断配置，选择 mcucfg_cm0.h
+   或 mcucfg_cm3.h 进行再配置。
+   Cortex-M0/M0+等内核：在 mcucfg_cm0.h 中，继续配置 系统中断。
+
+3、main函数（参照例程 demo_main.c）
    初始化 SysTick替代定时器（可选）
    配置 DEBUG（可选）
    启动 CosyOS（必须）
 
-3、系统中断（参照例程 demo_int.c）
+4、系统中断（参照例程 demo_int.c）
    屏蔽 PendSV中断原函数（必须）
    调用 tCosyTick_Handler（必须）
 
-4、DEBUG（可选，参照例程 demo_debug_fwl.c 或 demo_debug_hal.c）
+5、DEBUG（可选，参照例程 demo_debug_fwl.c 或 demo_debug_hal.c）
 
-Cortex-M3/M4/M7等内核：
-   不出意外的话，您的项目现在已经可以正常编译了。
-
-Cortex-M0/M0+等内核：
-   CosyOS-配置 / mcucfg_cmx.h，配置 系统中断 和 互斥访问方案；
-   CosyOS-配置 / mcucfg_cm0.h，配置 系统中断；
-   至此，您的项目才能正常编译。
+不出意外的话，您的项目现在已经可以正常编译了。
 
 但在未来，仍需重点关注如下内容：
 
@@ -35,8 +35,8 @@ Cortex-M0/M0+等内核：
    CosyOS-配置 / mcucfg_cm0.h
    CosyOS-配置 / mcucfg_cm3.h
 
-3、启动文件配置
-   在启动文件中需要合理的配置堆栈，STACK固定给中断使用；
+3、堆栈配置
+   需要合理的配置堆栈，STACK固定给中断使用；
    动态分配的内存和动态创建的对象，都需要用到HEAP。
 
 

Demo-Build/RISC-V32/demo_debug.c

@@ -0,0 +1,106 @@
+/**************************************************************************//**
+ * @item     CosyOS-III 例程（系统构建）
+ * @file     demo_debug.c
+ * @brief    例程-DEBUG for CH32V30x use firmware library
+ * @author   迟凯峰
+ * @version  v1.0.1
+ * @date     2026.07.31
+ ******************************************************************************/
+
+#if 0 /* 编译开关 */
+
+#include "CosyOS.H"
+#if (SYSCFG_DEBUGGING == __ENABLED__)
+
+/*
+ * 用户定义
+ */
+
+/*-------------------------------------------------------------*
+ | DEBUG_MODE | 输出（UART SEND）| 输入（UART RECV）| 推荐等级 |
+ |------------+------------------+------------------+----------|
+ | 0          | printf（查询）   | 串口接收中断     | *        |
+ |------------+------------------+------------------+----------|
+ | 1          | 串口发送中断     | 串口接收中断     | ***      |
+ *-------------------------------------------------------------*/
+#define DEBUG_MODE          1 // 建议不要配置为0，否则极易导致 系统调试器（Debugger）的任务栈需求激增！
+
+/* DEBUG RECV 缓存SIZE */
+#define DEBUG_RECV_BUFF     32
+
+////////////////////////////////////////////////////////////////////////////////
+
+// 1、例程中使用了UART1做为DEBUG专用串口，用户如需更换其它串口请自行调整。
+// 2、下方的DEBUG配置函数 Debug_Config()，不能够取代基本的串口初始化工作，
+//    用户在main函数中，在调用该函数之前，需先行初始化串口。
+
+////////////////////////////////////////////////////////////////////////////////
+
+#include "ch32v30x_usart.h"
+static char  u_debug_recv_buff[DEBUG_RECV_BUFF];
+static char *u_debug_recv_p = u_debug_recv_buff;
+#if   (DEBUG_MODE == 0)
+#include <stdio.h>
+#elif (DEBUG_MODE == 1)
+static char *u_debug_send_p;
+#endif
+
+void Debug_Config(void)
+{
+    #if   (DEBUG_MODE == 0)
+    USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
+    
+    #elif (DEBUG_MODE == 1)
+    USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
+    #endif
+}
+
+#if (SYSCFG_DEBUG_SENDLEN == __DISABLED__)
+void debug_hook(char _XDATA_MEM_ *p)
+#else
+void debug_hook(char _XDATA_MEM_ *p, s_u16_t len)
+#endif
+{
+    #if   (DEBUG_MODE == 0)
+    printf("%s", p);
+    xDebugSend_Complete();
+    
+    #elif (DEBUG_MODE == 1)
+    u_debug_send_p = p;
+    USART_ITConfig(USART1, USART_IT_TXE, ENABLE);
+    #endif
+}
+
+// 根据是否启用硬件压栈及串口中断优先级，选择相匹配的声明方式：
+void USART1_IRQHandler(void) __attribute__((interrupt)); // 声明为软件压栈
+//void USART1_IRQHandler(void) __attribute__((interrupt("WCH-Interrupt-fast"))); // 声明为硬件压栈
+void USART1_IRQHandler(void)
+{
+    #if   (DEBUG_MODE == 1)
+    if(USART_GetITStatus(USART1, USART_IT_TXE) != RESET){
+        if(*u_debug_send_p){
+            USART_SendData(USART1, *u_debug_send_p++);
+        }
+        else{
+            USART_ITConfig(USART1, USART_IT_TXE, DISABLE);
+            xDebugSend_Complete();
+        }
+    }
+    #endif
+    if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET){
+        if(u_debug_recv_p - u_debug_recv_buff < DEBUG_RECV_BUFF - 1){
+            *u_debug_recv_p = USART_ReceiveData(USART1);
+            if(*u_debug_recv_p++ == '\n'){
+                xDebugRecv_Handler(u_debug_recv_buff, u_debug_recv_p - u_debug_recv_buff);
+                u_debug_recv_p = u_debug_recv_buff;
+            }
+        }
+        else{
+            u_debug_recv_p = u_debug_recv_buff;
+        }
+    }
+}
+
+#endif
+
+#endif

Demo-Build/RISC-V32/readme.txt

@@ -0,0 +1,184 @@
+RISC-V32 之系统构建
+
+
+概述
+
+1、rv32 目前暂不支持 cube 安装，用户需手动移植。移植过程中遇到问题
+   可加入社区获取技术支持。
+
+2、目前仅支持 PSP栈模式，即不存在全局唯一主栈或中断专用栈，而是当前
+   任务栈即为当前主栈。这导致所有中断都是入任务栈，所以中断嵌套深度
+   应尽量配置少一些，同时任务栈SIZE应尽量大一些，以防溢出。
+
+3、CosyOS 采用了自研先进技术，可实现 CH32V 全程开启硬件压栈。
+   该技术为纯软件实现，不依赖特定硬件（0x804->bit5），V103、203 等
+   皆可完美支持。所以，如果您的处理器支持硬件压栈，建议开启。
+
+   如果开启硬件压栈，中断函数的声明原则等同裸机。
+   即如果最大硬件压栈深度为3级，需要将低优先级的三级中断声明为硬件压栈，
+   高优先级的中断声明为软件压栈。
+
+   RV32I 开启硬件压栈，注意事项：
+   （1）处理器需要仅工作在机器模式
+        可在启动文件中，通过配置 mstatus 的 MPP 为 3 来实现。
+   （2）x4(tp)、mscratch、0xE000E040（中断优先级阈值）等寄存器，专用
+        于任务切换，不允许用户使用。
+
+
+移植流程（以 MRS2 为例）
+
+1、裸机工程
+   准备项目的裸机工程，一个最基础的工程即可。
+
+2、删除文件
+   删除 CosyOS-源代码 中无关的文件，使其不被编译。
+
+   建议必须删除的文件：
+   （1）Port 中，仅保留 port_x32、syscfg.h
+   （2）Port / port_x32 中，仅保留 RISC-V32、port_x32.c、port_x32.h
+
+   建议可选删除的文件：
+   （1）Demo-Service
+   （2）Demo-Build 中，仅保留 RISC-V32、demo_task.c
+   注：如果不删除不会影响正常编译
+
+3、拷贝文件
+   拷贝 CosyOS-源代码 至工程中。
+
+4、包含路径
+   打开工程，添加下方的包含路径。
+   C包含路径：
+      cosyos-v3.0.1/System
+      cosyos-v3.0.1/Port
+      cosyos-v3.0.1/Port/port_x32
+      cosyos-v3.0.1/Port/port_x32/RISC-V32
+   汇编包含路径：
+      cosyos-v3.0.1/Port
+      cosyos-v3.0.1/Port/port_x32/RISC-V32
+
+
+构建流程
+
+0、Include/Exclude
+   Port / port_x32 / RISC-V32 / port_rv32_SWS.S， 为软件压栈专用，兼容 RV32E、RV32I 指令集；
+   Port / port_x32 / RISC-V32 / port_rv32e_HWS.S，为硬件压栈专用，针对 RV32E 指令集（青稞 V2 系列）；
+   Port / port_x32 / RISC-V32 / port_rv32i_HWS.S，为硬件压栈专用，针对 RV32I 指令集（青稞 V3/V4 系列）；
+   根据是否启用硬件压栈，Include 相匹配的文件，Exclude 不匹配的文件。
+   如果启用硬件压栈，port_rv32e_HWS.S、port_rv32i_HWS.S 可同时包含。
+
+1、系统配置
+   Port / syscfg.h -> 系统配置>>处理器架构，应定义为 4。
+   Port / syscfg.h -> 系统配置>>标准头文件，需要正确定义，如定义为
+   "ch32v30x.h"。
+
+2、MCU配置
+   Port / port_x32 / RISC-V32 / mcucfg_rv32.h 中，配置系统滴答和
+   系统时钟。
+
+3、main函数
+   在main函数的末尾处，先配置 DEBUG（如果使用 CosyOS-任务管理器），
+   最后再启动 CosyOS（必须）。
+
+4、系统中断
+   CosyOS 固定采用 SysTick_Handler 和 SW_Handler 做为系统中断。
+   用户需要自行在 SysTick_Handler 中调用 tCosyTick_Handler。
+   用户不要自行创建 SW_Handler。
+
+5、DEBUG（可选，参照例程 demo_debug.c）
+
+在未来，用户仍需重点关注如下内容：
+
+1、系统配置
+   Port / syscfg.h
+
+2、MCU配置
+   Port / port_x32 / RISC-V32 / mcucfg_rv32.h
+
+3、启动文件配置
+   在 handle_reset 中，配置特权级（mstatus）；
+   配置硬件压栈使能、中断嵌套使能、中断嵌套深度、硬件压栈溢出后中断使能（0x804）。
+
+4、ld文件配置
+   配置硬件栈size。
+   通常配置一个极小的数值即可，据不完全测试，该值配置为0即可正常运行：
+   __stack_size = 0;
+
+
+例程
+
+/* 例程-main */
+int main(void)
+{
+    /* USER INIT CODE BEGIN */
+    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
+    SystemCoreClockUpdate();
+    Delay_Init();
+////USART_Printf_Init(115200);
+    USART1_UART_Init (115200);
+    printf("SystemClk:%d\r\n",SystemCoreClock);
+    printf( "ChipID:%08x\r\n", DBGMCU_GetCHIPID() );
+    printf("This is printf example\r\n");
+    /* USER INIT CODE END */
+
+    /* USER DEBUG CONFIG */// for CosyOS-Taskmgr
+    #if (SYSCFG_DEBUGGING == 1)
+    if(1){
+        void Debug_Config(void);
+        Debug_Config();
+    }// defined in demo_debug.c
+    #endif
+
+    /* USER 启动 CosyOS */// 在main函数的末尾处
+    if(1){
+        #if 1 // 建议前期调试时开启，如果CosyOS启动失败会返回错误码提示用户！
+        unsigned char _ecode = uStartCosyOS();
+        printf("CosyOS startup failed, error code: %d.\r\n", (int)_ecode);
+        #else
+        uStartCosyOS();
+        #endif
+    }
+
+    while(1);
+}
+
+/* 例程-SysTick_Handler */// 根据是否启用硬件压栈，选择相匹配的声明方式：
+//void SysTick_Handler(void) __attribute__((interrupt)); // 声明为软件压栈
+void SysTick_Handler(void) __attribute__((interrupt("WCH-Interrupt-fast"))); // 声明为硬件压栈
+void SysTick_Handler(void)
+{
+    SysTick->SR = 0;
+    tCosyTick_Handler();
+}
+
+/* 例程-启动文件 */// 使能硬件压栈并仅为机器模式
+handle_reset:
+/* Enable interrupt nesting and hardware stack */
+    //      HWSTKOVEN, PMTCFG,    INESTEN,  HWSTKEN
+    li t0, (1 << 4) | (3 << 2) | (1 << 1) | 1
+    csrw 0x804, t0
+/* Enable floating point and global interrupt, configure privileged mode */
+    //      FS,         MPP,        MPIE,      MIE
+    li t0, (3 << 13) | (3 << 11) | (1 << 7) | (1 << 3)
+    csrw mstatus, t0
+
+/*
+0x804
+HWSTKOVEN：硬件压栈溢出后中断使能
+PMTCFG：   中断嵌套深度
+INESTEN：  中断嵌套使能
+HWSTKEN：  硬件压栈使能
+
+mstatus
+FS：  浮点单元状态
+MPP： 进中断前特权模式
+MPIE：进中断前中断使能状态
+MIE： 机器模式中断使能
+*/
+
+/* 例程-断点测试钩子 */// for RV32I 硬件压栈
+void test_breakpoint_hook(void)
+{
+    printf("break point test failed\r\n");
+    while(1);
+}
+

Demo-Build/demo_task.c

@@ -3,8 +3,8 @@
  * @file     demo_task.c
  * @brief    例程-任务
  * @author   迟凯峰
- * @version  V1.0.4
- * @date     2025.12.24
+ * @version  V1.1.0
+ * @date     2026.07.22
  ******************************************************************************/
 
 #if 0 /* 编译开关 */
@@ -17,19 +17,13 @@
  |-----------------------+-----------------------------------------------------------*
  | 任务名称 | 任务优先级 | 任务栈大小 | 安全运行时 | 任务名称文本（兼容模式）        |
  |----------+------------+------------+------------+---------------------------------|
- | task_1   | 1级        | 384字节    | 0为无限长  | 0为自动引用任务名称，即"task_1" |
+ | task_1   | 1级        | 512字节    | 0为无限长  | 0为自动引用任务名称，即"task_1" |
  |----------+------------+------------+------------+---------------------------------|
- | task_2   | 2级        | 384字节    | 9滴答周期  | "task_led"为任务名称文本        |
+ | task_2   | 2级        | 512字节    | 9滴答周期  | "task_led"为任务名称文本        |
  *-----------------------------------------------------------------------------------*/
 
-/*
-   注意事项 for 8051：
-        1、在默认情况下，任务栈SIZE不允许大于255。
-        2、只有在启用了XBPSTACK的任务切换现场保护时，任务栈SIZE才允许大于255，最大可为65535。
- */
-
 /* 静态创建 task_1 */
-uCreateTask(task_1, 1, 384, 0, 0)
+uCreateTask(task_1, 1, 512, 0, 0)
 {
     while(1){
         printf("task_1\r\n");
@@ -38,7 +32,7 @@ uCreateTask(task_1, 1, 384, 0, 0)
 }
 
 /* 动态创建 task_2 */
-dCreateTask(task_2, 2, 384, 9, "task_led")
+dCreateTask(task_2, 2, 512, 9, "task_led")
 {
     while(1){
         printf("task_2\r\n");

Demo-Service/1、事件同步/event_binary.c

@@ -6,7 +6,7 @@
  * @note     事件处理线程（task_1）中，可以实现超时处理机制。
  * @author   迟凯峰
  * @version  V1.0.0
- * @date     2025.10.21
+ * @date     2026.07.31
  ******************************************************************************/
 
 /*-------------------------------------------------------*
@@ -19,7 +19,7 @@
  | pGiveBin(bin)       | 中断中给予二值信号量 - FLAG服务 |
  *-------------------------------------------------------*/
 
-#if 1 /* 编译开关 */
+#if 0 /* 编译开关 */
 
 #include "CosyOS.H"
 

Demo-Service/1、事件同步/event_clrblk.c

@@ -6,7 +6,7 @@
  * @note     事件处理线程（task_1）中，无法实现超时处理机制。
  * @author   迟凯峰
  * @version  V1.0.0
- * @date     2025.10.21
+ * @date     2026.07.31
  ******************************************************************************/
 
 /*-------------------------------------------------*
@@ -19,7 +19,7 @@
  | pClearBlock(task) | 中断中清除阻塞 - FLAG服务   |
  *-------------------------------------------------*/
 
-#if 1 /* 编译开关 */
+#if 0 /* 编译开关 */
 
 #include "CosyOS.H"
 

Demo-Service/1、事件同步/event_group.c

@@ -7,10 +7,10 @@
              统一处理该类事件。
  * @author   迟凯峰
  * @version  V1.0.0
- * @date     2025.10.22
+ * @date     2026.07.31
  ******************************************************************************/
 
-#if 1 /* 编译开关 */
+#if 0 /* 编译开关 */
 
 #include "CosyOS.H"
 

Demo-Service/1、事件同步/event_ressus.c

@@ -6,7 +6,7 @@
  * @note     事件处理线程（task_1）中，无法实现超时处理机制。
  * @author   迟凯峰
  * @version  V1.0.0
- * @date     2025.10.21
+ * @date     2026.07.31
  ******************************************************************************/
 
 /*-----------------------------------------------*
@@ -19,7 +19,7 @@
  | pResumeTask(task) | 中断中恢复任务 - FLAG服务 |
  *-----------------------------------------------*/
 
-#if 1 /* 编译开关 */
+#if 0 /* 编译开关 */
 
 #include "CosyOS.H"
 

Demo-Service/1、事件同步/event_semaph.c

@@ -7,7 +7,7 @@
  * @note     计数信号量，是唯一能够实现并发事件同步的手段。
  * @author   迟凯峰
  * @version  V1.0.0
- * @date     2025.10.21
+ * @date     2026.07.31
  ******************************************************************************/
 
 /*-------------------------------------------------------*
@@ -18,7 +18,7 @@
  | iGiveSem(sem)       | 中断中给予计数信号量 - FIFO服务 |
  *-------------------------------------------------------*/
 
-#if 1 /* 编译开关 */
+#if 0 /* 编译开关 */
 
 #include "CosyOS.H"
 

Demo-Service/2、消息同步/msg_taskmsg.c

@@ -5,10 +5,10 @@
  * @details  通过私信的应用实现任务间通信。
  * @author   迟凯峰
  * @version  V1.0.1
- * @date     2026.02.04
+ * @date     2026.07.31
  ******************************************************************************/
 
-#if 1 /* 编译开关 */
+#if 0 /* 编译开关 */
 
 #include "CosyOS.H" // 用户的各个c文件中应包含此文件
 #include <stdio.h> // for printf
@@ -22,7 +22,7 @@
 
 dExternTaskmsg(task_2)(unsigned int, void *, float); // 声明动态创建的私信任务 task_2
 
-/* 静态创建私信任务 task_1 */              // 1个私信参数
+/* 静态创建私信任务 task_1 */// 1个私信参数
 uCreateTaskmsg(task_1, 1, 512, 0, "task_key", 1)(unsigned int tm1)
 {
     while(1){ // 已内置循环，此循环可省略
@@ -35,7 +35,7 @@ uCreateTaskmsg(task_1, 1, 512, 0, "task_key", 1)(unsigned int tm1)
     uEndTaskmsg(); // 结束私信任务
 }
 
-/* 动态创建私信任务 task_2 */              // 3个私信参数
+/* 动态创建私信任务 task_2 */// 3个私信参数
 dCreateTaskmsg(task_2, 2, 768, 0, "task_led", 3)(unsigned int tm1, void *tm2, float tm3)
 {
 //  while(1){ // 已内置循环，此循环可省略

Demo-Service/3、互斥访问/mutexc_mutex.c

@@ -6,10 +6,10 @@
  * @note     可实现超时处理机制。
  * @author   迟凯峰
  * @version  V1.0.0
- * @date     2025.10.25
+ * @date     2026.07.31
  ******************************************************************************/
 
-#if 1 /* 编译开关 */
+#if 0 /* 编译开关 */
 
 #include "CosyOS.H"
 

Demo-Service/4、重入访问/reent_semaph.c

@@ -6,10 +6,10 @@
  * @note     可实现超时处理机制。
  * @author   迟凯峰
  * @version  V1.0.0
- * @date     2025.10.25
+ * @date     2026.07.31
  ******************************************************************************/
 
-#if 1 /* 编译开关 */
+#if 0 /* 编译开关 */
 
 #include "CosyOS.H"
 

Demo-Service/5、协作式任务/coop_binary.c

@@ -6,7 +6,7 @@
  * @note     适用于多个任意优先级任务的循环协作。
  * @author   迟凯峰
  * @version  V1.0.0
- * @date     2025.10.21
+ * @date     2026.07.31
  ******************************************************************************/
 
 /*-------------------------------------------*
@@ -17,7 +17,7 @@
  | uGiveBin(bin)     | 任务中 给予二值信号量 |
  *-------------------------------------------*/
 
-#if 1 /* 编译开关 */
+#if 0 /* 编译开关 */
 
 #include "CosyOS.H"
 

Demo-Service/5、协作式任务/coop_delay.c

@@ -1,76 +0,0 @@
-/**************************************************************************//**
- * @item     CosyOS-III 例程（服务应用）
- * @file     coop_delay.c
- * @brief    协作_阻塞延时
- * @details  通过阻塞延时，实现任务的循环协作。
- * @note     适用于多个相同优先级任务的循环协作，依赖协作式调度算法。
- * @author   迟凯峰
- * @version  V1.0.0
- * @date     2025.10.21
- ******************************************************************************/
-
-/*-----------------------------------*
- | 服务            | 描述            |
- |-----------------+-----------------|
- | uDelay_xx(time) | 任务中 阻塞延时 |
- *-----------------------------------*/
-
-/*
-    注意事项：
-    1、需开启相同优先级任务的协作式调度。
-    2、延时时间最短为两个tick，不可更短。
-    3、任务的启动顺序，决定了任务的协作运行顺序。
- */
-
-#if 1 /* 编译开关 */
-
-#include "CosyOS.H"
-
-/* task_1 */
-uCreateTask(task_1, 1, 384, 0, 0)
-{
-    while(1){
-        /* 协作处理事务 开始 */
-        
-        /* 协作处理事务 结束 */
-        /* 同步至task_2 开始 */
-        uDelay_tc(2);
-        /* 同步至task_2 结束 */
-    }
-}
-
-/* task_2 */
-uCreateTask(task_2, 1, 384, 0, 0)
-{
-    while(1){
-        /* 协作处理事务 开始 */
-        
-        /* 协作处理事务 结束 */
-        /* 同步至task_3 开始 */
-        uDelay_tc(2);
-        /* 同步至task_3 结束 */
-    }
-}
-
-/* task_3 */
-uCreateTask(task_3, 1, 384, 0, 0)
-{
-    while(1){
-        /* 协作处理事务 开始 */
-        
-        /* 协作处理事务 结束 */
-        /* 同步至task_1 开始 */
-        uDelay_tc(2);
-        /* 同步至task_1 结束 */
-    }
-}
-
-/* 启动钩子 */
-void start_hook(void)
-{
-    uStartTask_Ready(task_1); // 启动task_1，初始状态为就绪状态
-    uStartTask_Ready(task_2); // 启动task_2，初始状态为就绪状态
-    uStartTask_Ready(task_3); // 启动task_3，初始状态为就绪状态
-}
-
-#endif

Demo-Service/5、协作式任务/coop_ressus_1.c

@@ -6,7 +6,7 @@
  * @note     适用于两个不同优先级任务的循环协作。
  * @author   迟凯峰
  * @version  V1.0.0
- * @date     2025.10.21
+ * @date     2026.07.31
  ******************************************************************************/
 
 /*-------------------------------------*
@@ -17,7 +17,7 @@
  | uResumeTask(task) | 任务中 恢复任务 |
  *-------------------------------------*/
 
-#if 1 /* 编译开关 */
+#if 0 /* 编译开关 */
 
 #include "CosyOS.H"
 

Demo-Service/5、协作式任务/coop_ressus_2.c

@@ -6,7 +6,7 @@
  * @note     适用于多个不同优先级任务的循环协作。
  * @author   迟凯峰
  * @version  V1.0.0
- * @date     2025.10.21
+ * @date     2026.07.31
  ******************************************************************************/
 
 /*----------------------------------------------------------*
@@ -15,7 +15,7 @@
  | uResumeSuspend(task) | 任务中 恢复指定任务并挂起自身任务 |
  *----------------------------------------------------------*/
 
-#if 1 /* 编译开关 */
+#if 0 /* 编译开关 */
 
 #include "CosyOS.H"
 

Demo-Service/5、协作式任务/coop_ressus_3.c

@@ -6,7 +6,7 @@
  * @note     适用于多个相同优先级任务的循环协作。
  * @author   迟凯峰
  * @version  V1.0.0
- * @date     2025.10.21
+ * @date     2026.07.31
  ******************************************************************************/
 
 /*----------------------------------------------------------*
@@ -15,7 +15,7 @@
  | uResumeSuspend(task) | 任务中 恢复指定任务并挂起自身任务 |
  *----------------------------------------------------------*/
 
-#if 1 /* 编译开关 */
+#if 0 /* 编译开关 */
 
 #include "CosyOS.H"
 

Demo-Service/5、协作式任务/coop_yield.c

@@ -3,10 +3,10 @@
  * @file     coop_yield.c
  * @brief    协作_禅让任务
  * @details  通过禅让任务，实现任务的循环协作。
- * @note     适用于多个相同优先级任务的循环协作，依赖时间片轮转调度算法。
+ * @note     适用于多个相同优先级任务的循环协作。
  * @author   迟凯峰
- * @version  V1.0.0
- * @date     2025.10.21
+ * @version  V1.0.1
+ * @date     2026.07.31
  ******************************************************************************/
 
 /*--------------------------------*
@@ -17,12 +17,12 @@
 
 /*
     注意事项：
-    1、需开启相同优先级任务的时间片轮转调度。
-    2、每个任务的运行时间，都必须小于时间片时间。
+    1、需开启相同优先级任务的协作式调度或时间片轮转调度。
+    2、如果是时间片轮转调度，每个任务的运行时间，都必须小于时间片时间。
     3、任务的启动顺序，决定了任务的协作运行顺序。
  */
 
-#if 1 /* 编译开关 */
+#if 0 /* 编译开关 */
 
 #include "CosyOS.H"
 

Demo-Service/6、综合应用/comp_usart.c

@@ -12,10 +12,10 @@
  * @note     本例程仅以 STM32-HAL库 的应用为例，其它情形请用户自行做出调整。
  * @author   迟凯峰
  * @version  V1.0.1
- * @date     2026.02.19
+ * @date     2026.07.31
  ******************************************************************************/
 
-#if 1 /* 编译开关 */
+#if 0 /* 编译开关 */
 
 
 #define PENDSV_FIFO_FLAG  2 // 定时服务为中断挂起服务，选择 FIFO服务 或 FLAG服务（1：FIFO服务，2：FLAG服务）

Port/Cortex-M/port_cmx.c

@@ -1,125 +0,0 @@
-/**************************************************************************//**
- * @item     CosyOS-III Port
- * @file     port_cmx.c
- * @brief    CMSIS Cortex-M Core Port File
- * @author   迟凯峰
- * @version  V2.3.1
- * @date     2026.03.01
- ******************************************************************************/
-
-#include "os_var.h"
-#ifdef __PORT_CMX_H
-
-
-/*
- * 中断FIFO服务
- */
-
-#if (MCUCFG_PENDSVFIFO_DEPTH > 0)
-
-#if (SYSCFG_PENDSVFIFO_MONITOR == __ENABLED__)
-s_u32_t mPendSV_FIFO_DepthMAX = 0;
-s_u16_t mPendSV_FIFO_CountMAX = 0;
-#endif
-void *mPendSV_FIFO_0[MCUCFG_PENDSVFIFO_DEPTH + 1]; /*!< FIFO0 */
-void *mPendSV_FIFO_1[MCUCFG_PENDSVFIFO_DEPTH + 1]; /*!< FIFO1 */
-volatile bool m_sign_fifo = true;    /*!< FIFO互斥访问锁：入FIFO与出FIFO的互斥
-if(m_sign_fifo == true) {中断FIFO服务装载器入FIFO0，中断FIFO服务处理器出FIFO1}
-if(m_sign_fifo == false){中断FIFO服务装载器入FIFO1，中断FIFO服务处理器出FIFO0} */
-  #if (MCUCFG_PENDSVFIFO_MUTEX == 2) /*!< 互斥访问机制一 */
-void *mPendSV_FIFO_X;                /*!< FIFO替身计数器 */
-#elif (MCUCFG_PENDSVFIFO_MUTEX == 3) /*!< 互斥访问机制二 */
-volatile bool m0_sign_mutex = false; /*!< FIFO计数器访问 */
-s_u8_t M0_IRQn_Pri[48];              /*!< 中断优先级表   */
-#endif
-
-/* 中断FIFO服务处理器 */
-void mPendSV_FIFOHandler(void)
-{
-	register void **p;
-	register void *sv;
-	register s_u32_t i;
-	register s_u16_t j = 0;
-	
-	__FIFO_0:
-	p = mPendSV_FIFO_0;
-	/* 独占访问FIFO0 */
-	m_sign_fifo = false;
-	if(true){
-		i = (s_u32_t)mPendSV_FIFO_0[0];
-		#if (MCUCFG_PENDSVFIFO_MUTEX == 3)
-		i >>= 24;
-		#endif
-		mPendSV_FIFO_0[0] = OS_NULL;
-		#if (SYSCFG_PENDSVFIFO_MONITOR == __ENABLED__)
-		if(i > mPendSV_FIFO_DepthMAX){
-			mPendSV_FIFO_DepthMAX = i;
-		}
-		#endif
-		if(i > MCUCFG_PENDSVFIFO_DEPTH){
-			i = MCUCFG_PENDSVFIFO_DEPTH;
-			#if (SYSCFG_PENDSVFIFO_MONITOR == __ENABLED__)
-			s_fault.overflow_pendsvfifo = true;
-			#endif
-		}
-		j += i;
-		do{
-			sv = *++p;
-			#if (MCUCFG_PENDSVFIFO_MUTEX <= 1)
-			(*sPendSV_FIFOHandler[*(const s_u8_t *)sv])(sv);
-			#else
-			if(sv != OS_NULL){
-				*p = OS_NULL;
-				(*sPendSV_FIFOHandler[*(const s_u8_t *)sv])(sv);
-			}
-			#endif
-		}while(--i);
-	}
-	
-	OS_NOP(1);
-	
-	p = mPendSV_FIFO_1;
-	/* 独占访问FIFO1 */
-	m_sign_fifo = true;
-	if(mPendSV_FIFO_1[0]){
-		i = (s_u32_t)mPendSV_FIFO_1[0];
-		#if (MCUCFG_PENDSVFIFO_MUTEX == 3)
-		i >>= 24;
-		#endif
-		mPendSV_FIFO_1[0] = OS_NULL;
-		#if (SYSCFG_PENDSVFIFO_MONITOR == __ENABLED__)
-		if(i > mPendSV_FIFO_DepthMAX){
-			mPendSV_FIFO_DepthMAX = i;
-		}
-		#endif
-		if(i > MCUCFG_PENDSVFIFO_DEPTH){
-			i = MCUCFG_PENDSVFIFO_DEPTH;
-			#if (SYSCFG_PENDSVFIFO_MONITOR == __ENABLED__)
-			s_fault.overflow_pendsvfifo = true;
-			#endif
-		}
-		j += i;
-		do{
-			sv = *++p;
-			#if (MCUCFG_PENDSVFIFO_MUTEX <= 1)
-			(*sPendSV_FIFOHandler[*(const s_u8_t *)sv])(sv);
-			#else
-			if(sv != OS_NULL){
-				*p = OS_NULL;
-				(*sPendSV_FIFOHandler[*(const s_u8_t *)sv])(sv);
-			}
-			#endif
-		}while(--i);
-	}
-	
-	if(mPendSV_FIFO_0[0] && j < MCUCFG_PENDSVFIFO_COUNT) goto __FIFO_0;
-	#if (SYSCFG_PENDSVFIFO_MONITOR == __ENABLED__)
-	if(mPendSV_FIFO_CountMAX < j) mPendSV_FIFO_CountMAX = j;
-	#endif
-}
-
-#endif
-
-
-
-#endif

Port/port_x32/Cortex-M/EWARM/port_cmx_iar.s

@@ -3,8 +3,8 @@
  * @file     port_cmx_iar.s
  * @brief    CMSIS Cortex-M Core Port File for IAR Compiler
  * @author   迟凯峰
- * @version  V2.3.1
- * @date     2026.03.01
+ * @version  v3.0.0
+ * @date     2026.07.21
  ******************************************************************************/
 
                                     用户须知
@@ -41,7 +41,6 @@ OS_PendSV_Handler:
                 bl      sPendSV_Handler
 ; 直接返回吗？
                 cbz     r0, __RETURN
-                isb
 ; 保护现场吗？
                 ldr     r1, =s_task_current
                 IF (SYSCFG_DEBUGGING == 1)
@@ -49,24 +48,22 @@ OS_PendSV_Handler:
                 cbz     r0, __RESTORE
                 ENDIF
                 mrs     r0, psp
+                isb
 ; 任务PC监控
                 IF (SYSCFG_TASKPC_MONITOR == 1)
-                EXTERN  s_taskmgr_sign
                 EXTERN  s_pc
-                ldr     r2, =s_taskmgr_sign
-                ldrb    r2, [r2]
-                cbz     r2, __PROTECTING
                 ldr     r2, [r0,#24]
                 ldr     r3, =s_pc
                 str     r2, [r3]
                 ENDIF
 ; 保护现场
-__PROTECTING    IF (MCUCFG_ASPEN_LSPEN == 1)
+                IF (MCUCFG_ASPEN_LSPEN == 1)
                 vstmdb  r0!, {s16-s31}
                 ENDIF
                 stmdb   r0!, {r4-r11}
                 ldr     r2, [r1]
                 str     r0, [r2]
+                dsb
 ; 恢复现场
 __RESTORE       ldr     r3, =s_task_news
                 ldr     r3, [r3]
@@ -84,22 +81,29 @@ __RETURN        pop     {pc}
 
 ; 中断FIFO服务装载器
 
-                IF (MCUCFG_PENDSVFIFO_DEPTH > 0)
+                IF (SYSCFG_PENDSVFIFO_DEPTH > 0)
 
                 PUBLIC  mPendSV_FIFOLoader
 mPendSV_FIFOLoader:
                 EXTERN  mPendSV_FIFO_0
                 EXTERN  mPendSV_FIFO_1
-                EXTERN  m_sign_fifo
+                EXTERN  m_fifo_lock
 ; FIFO选择
-                ldr     r2, =m_sign_fifo
+                ldr     r2, =m_fifo_lock
                 ldrb    r3, [r2]
                 cbz     r3, __FIFO1
 __FIFO0         ldr     r1, =mPendSV_FIFO_0
-                b       __COUNT
+                b       __OVERFLOW1
 __FIFO1         ldr     r1, =mPendSV_FIFO_1
+; 计数溢出
+__OVERFLOW1     IF (0) ; 正常情况下计数器难以溢出，默认关闭防护以提高装载效率。
+                ldr     r2, [r1]
+                ldr     r3, =0x80000000
+                cmp     r2, r3
+                bhi     __OVER
+                ENDIF
 ; FIFO计数
-__COUNT         /* 1、互斥访问指令 */
+                /* 互斥访问指令 */
                 #if (MCUCFG_PENDSVFIFO_MUTEX == 1)
 __LOOP          ldrex   r2, [r1]
                 adds    r2, #1
@@ -110,7 +114,7 @@ __LOOP          ldrex   r2, [r1]
                 #error 互斥访问方案 未选择 互斥访问指令！
                 #endif
 ; FIFO溢出
-                cmp     r2, #MCUCFG_PENDSVFIFO_DEPTH
+                cmp     r2, #SYSCFG_PENDSVFIFO_DEPTH
                 bhi     __OVER
 ; FIFO装载
                 lsls    r2, r2, #2

Port/port_x32/Cortex-M/mcucfg_cm0.h

@@ -3,8 +3,8 @@
  * @file     mcucfg_cm0.h
  * @brief    CMSIS Cortex-M Core Config File
  * @author   迟凯峰
- * @version  V2.0.0
- * @date     2025.08.04
+ * @version  v3.0.0
+ * @date     2026.08.15
  ******************************************************************************/
 
 #ifndef __MCUCFG_CM0_H
@@ -62,11 +62,11 @@
 
 // 替代定时器-重装载值
 // 如果该值为常量可配置为常量，否则应配置为可读的重装载值寄存器。
-#define MCUCFG_SYSTICK_LOADVALUE        (SYSCFG_SYSTICK_CYCLE - 1) //=(TIM14->ARR)
+#define MCUCFG_SYSTICK_LOADVALUE        (SYSCFG_SYSTICK_CYCLE - 1) // = (TIM14->ARR)
 
 // 替代定时器-时钟
 // 告知CosyOS您所配置的定时器时钟，单位为兆赫（MHZ）。
-#define MCUCFG_SYSTICK_CLK              1 //=(系统时钟 / (TIM14->PSC + 1))
+#define MCUCFG_SYSTICK_CLK              1 // = (系统时钟 / (TIM14->PSC + 1))
 
 //////////////////////////////////* 系统定义 *//////////////////////////////////
 

Port/port_x32/Cortex-M/mcucfg_cm3.h

@@ -3,8 +3,8 @@
  * @file     mcucfg_cm3.h
  * @brief    CMSIS Cortex-M Core Config File
  * @author   迟凯峰
- * @version  V2.0.0
- * @date     2025.08.04
+ * @version  v3.0.0
+ * @date     2026.08.15
  ******************************************************************************/
 
 #ifndef __MCUCFG_CM3_H
@@ -69,7 +69,7 @@
 
 // 系统滴答-时钟
 // 告知CosyOS您所配置的系统滴答时钟，单位为兆赫（MHZ）。
-#define MCUCFG_SYSTICK_CLK              (系统时钟 / ((SysTick->CTRL & 4) ? 1 : 8))
+#define MCUCFG_SYSTICK_CLK              168 // = (系统时钟 / ((SysTick->CTRL & 4) ? 1 : 8))
 
 #endif
 

Port/port_x32/Cortex-M/mcucfg_cmx.h

@@ -3,8 +3,8 @@
  * @file     mcucfg_cmx.h
  * @brief    CMSIS Cortex-M Core Config File
  * @author   迟凯峰
- * @version  V2.3.1
- * @date     2026.03.01
+ * @version  v3.0.0
+ * @date     2026.07.21
  ******************************************************************************/
 
 #ifndef __MCUCFG_CMX_H
@@ -33,12 +33,12 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 // <o> 中断FIFO服务装载器-互斥访问方案
-// <1=> 互斥访问指令 <2=> 互斥访问机制一 <3=> 互斥访问机制二 <0=> 关闭总中断
+// <1=> 互斥访问指令 <255=> 互斥访问机制 <0=> 关闭总中断
 // <i> ------------------------------------------------------------------------
-// <i> 一、互斥访问指令
+// <i> 互斥访问指令
 // <i> 仅适用于Cortex-M3/M4/M7等支持互斥访问指令[LDREX/STREX]的内核，可实现全局不关总中断、零中断延迟。
 // <i> ------------------------------------------------------------------------
-// <i> 二、互斥访问机制一
+// <i> 互斥访问机制
 // <i> 仅推荐于Cortex-M0/M0+等不支持互斥访问指令[LDREX/STREX]的内核，可实现全局不关总中断、零中断延迟。
 // <i> 全局寄存器变量
 // <i> 首先需要定义一个全局寄存器变量（系统默认定义为r6），专用于互斥访问：
@@ -55,46 +55,20 @@
 // <i> 注：中断优先级号为负值的中断通常仅包括 Reset_Handler、NMI_Handler、HardFault_Handler。
 // <i> 用户需严格遵守上述的服务调用规约，否则可能会对系统可靠性造成不利影响。
 // <i> ------------------------------------------------------------------------
-// <i> 三、互斥访问机制二
-// <i> 仅推荐于Cortex-M0/M0+等不支持互斥访问指令[LDREX/STREX]的内核，可实现全局不关总中断、零中断延迟。
-// <i> 服务调用规约
-// <i> 仅允许用户在中断优先级号：0、1、2、3 的用户中断中调用【中断FIFO服务】。
-// <i> 中断优先级号：负值的用户中断中不允许调用【中断FIFO服务】。
-// <i> 注：中断优先级号为负值的中断通常仅包括 Reset_Handler、NMI_Handler、HardFault_Handler。
-// <i> 这基本上已经相当于没有服务调用规约的限制。
-// <i> ------------------------------------------------------------------------
-// <i> 零、关闭总中断
+// <i> 关闭总中断
 // <i> 适用于所有ARM内核，并具有极短的、确定的关闭总中断时间，包括关闭总中断、再次开启总中断在内，
 // <i> 共10个指令周期（嵌套方式）；如果是非嵌套方式，仅为7个指令周期。
-// <i> 内核关闭总中断仅发生在 port_cmx_s.c 中，“中断FIFO服务装载器” 中的 “__COUNT” 段。
+// <i> 内核关闭总中断仅发生在 port_cmx_s.c 中，“中断FIFO服务装载器” 中的 “FIFO计数” 段。
 // <i> ------------------------------------------------------------------------
 // <i> 配置技巧：
 // <i> 用户可优先选择 “互斥访问指令” 编译尝试，如果内核不支持该指令，编译器会给出明确提示，此时再更换其它方案。
-// <i> 在中断FIFO服务的装载效率上，“互斥访问机制一” 要比 “互斥访问机制二” 高效许多，但缺点是服务调用规约的限制较大。
 #define MCUCFG_PENDSVFIFO_MUTEX         1
 
 // <q> 关闭总中断-嵌套方式
 // <i> 当“中断FIFO服务装载器-互斥访问方案”选择关闭总中断时，是否采用嵌套方式？
 // <i> 如果用户在中断中使用了中断锁（xDisableIRQ/xResumeIRQ）或自行关闭总中断（操作PRIMASK），推荐采用嵌套方式。
 // <i> 否则可关闭嵌套方式，缩短内核关闭总中断时间（将缩短至7个指令周期）。
-#define MCUCFG_PENDSVFIFO_MUTEX0        1
-
-///////////////////////////////////////////////////////////////////////////////
-// <o> PendSV_FIFO深度
-// <i> 此项参数取决于您在中断中调用的FIFO服务的总数及中断的频率。
-// <i> 对于Cortex-M来说，PendSV_FIFO的最大深度可为255。
-// <i> 可开启PendSV_FIFO监控功能，监控历史上的最大值，再适当增大，以确保其不会溢出。
-#define MCUCFG_PENDSVFIFO_DEPTH         32
-
-// <o> 中断FIFO服务处理器-最大并发执行数
-// <i> 中断FIFO服务处理器在一次运行中，允许执行服务的最大数量。
-// <i> 如果超出这个数值，中断FIFO服务处理器将主动退出运行，而后继续执行任务调度/切换。
-// <i> 该功能可防止因中断FIFO服务的多阶段持续并发而导致的中断FIFO服务处理器死锁（永远有执行不完的服务），
-// <i> 并最终导致任务不能调度运行。
-// <i> 该值通常建议在“PendSV_FIFO深度值的2~10倍之间”选取，不建议过大或过小。
-// <i> 可开启PendSV_FIFO监控功能，监控“实际并发执行数”在历史上的最大值，如果过大说明设计存在不合理因素，
-// <i> 应设法予以解决。
-#define MCUCFG_PENDSVFIFO_COUNT         256
+#define MCUCFG_PENDSVFIFO_XXXXX         1
 
 ///////////////////////////////////////////////////////////////////////////////
 // <q> 浮点寄存器上下文自动保存
@@ -108,15 +82,4 @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
-#if (MCUCFG_PENDSVFIFO_DEPTH > 255)
-#error PendSV_FIFO深度溢出！
-#endif
-
-#define MCUCFG_OSZEROINSTALL  0
-#define mSysTick_Clear()
-#define mUserReg_SAVEc()
-#define mUserReg_RESc()
-
-
-
 #endif

Port/port_x32/Cortex-M/port_cmx.c

@@ -0,0 +1,32 @@
+/**************************************************************************//**
+ * @item     CosyOS-III Port
+ * @file     port_cmx.c
+ * @brief    CMSIS Cortex-M Core Port File
+ * @author   迟凯峰
+ * @version  v3.0.0
+ * @date     2026.07.21
+ ******************************************************************************/
+
+#include "os_var.h"
+#ifdef __PORT_CMX_H
+
+
+/*
+ * 栈监控（主栈）
+ */
+#if (SYSCFG_DEBUGGING == __ENABLED__)
+s_u32_t m_msp; // main stack initial pointer
+s_u32_t m_stacksize; // main stack size
+s_u32_t m_stacklen_max = 0; // main stack used length of maximum
+#endif
+
+
+/*
+ * 中断FIFO服务
+ */
+#if (SYSCFG_PENDSVFIFO_DEPTH > 0) && (MCUCFG_PENDSVFIFO_MUTEX == 0xFF)
+void *mPendSV_FIFO_X; // 互斥访问机制.FIFO替身计数器
+#endif
+
+
+#endif

Port/port_x32/RISC-V32/mcucfg_rv32.h

@@ -0,0 +1,107 @@
+/**************************************************************************//**
+ * @item     CosyOS-III Config
+ * @file     mcucfg_rv32.h
+ * @brief    RISC-V32 Core Config File
+ * @author   迟凯峰
+ * @version  v3.0.7
+ * @date     2026.08.15
+ ******************************************************************************/
+
+#ifndef __MCUCFG_RV32_H
+#define __MCUCFG_RV32_H
+
+///////////////////////////////////////////////////////////////////////////////
+// 中断FIFO服务装载器-互斥访问方案
+// <1=> [lr][sc]指令 <2=> [amoadd]指令 <255=> 互斥访问机制 <0=> 关闭总中断（嵌套方式）
+// <i> ------------------------------------------------------------------------
+// [lr][sc]指令
+// 可实现全局不关总中断、零中断延迟。
+// 值得留意的是，青稞 V3A/V4 系列微处理器，对该指令进行了弱化处理，仅作为 lw，sw
+// 执行，不再具有独占访问能力，所以不要使用。
+// <i> ------------------------------------------------------------------------
+// [amoadd]指令
+// 可实现全局不关总中断、零中断延迟。
+// 该指令执行周期可能会稍长且不确定。
+// <i> ------------------------------------------------------------------------
+// 互斥访问机制
+// 可实现全局不关总中断、零中断延迟。
+// 适用于不支持上述原子访问指令的情况，如青稞 V2 系列。
+// x4(tp)、mscratch 专用于该机制下中断FIFO服务的互斥装载，用户不要使用。
+// 青稞 V3/V4 系列，如果启用硬件压栈（port_rv32i_HWS.S），也会用到这两个寄存器，
+// 会与互斥访问机制相冲突。
+// <i> ------------------------------------------------------------------------
+// 关闭总中断（嵌套方式）
+// 适用于不支持上述原子访问指令的情况，如青稞 V2 系列。
+// 由于在关闭总中断之后必须使用 fence.i 指令同步隔离，所以关闭总中断时间暂不确定。
+#define MCUCFG_PENDSVFIFO_MUTEX         2
+
+///////////////////////////////////////////////////////////////////////////////
+// 浮点寄存器上下文自动保存
+// <0=> 不保存 <1=> 保存
+// 是否启用浮点寄存器的上下文自动保存功能？
+// 如果存在并且启用了硬件浮点单元，同时在多个任务中都要进行浮点运算，可考虑开启该选项。
+#define MCUCFG_FPU_AUTOSTORE            0
+
+///////////////////////////////////////////////////////////////////////////////
+
+/* 系统滴答-配置方式 */
+// <0=> 手动配置 <1=> 自动配置
+// 手动配置：您需自行手动配置和系统滴答有关的一切事宜；
+// 例外的是，滴答中断优先级将由CosyOS自动配置为最低级。
+// 自动配置：CosyOS会自动为您处理好一切事宜，开箱即用。
+#define MCUCFG_SYSTICK_AUTOCONFIG       1
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+#if (MCUCFG_SYSTICK_AUTOCONFIG == 1)
+/* 自动配置-额外配置 */
+// 如果系统滴答配置方式为自动配置，需额外配置下方定义项。
+
+// 系统时钟频率
+// 告知CosyOS您所配置的系统时钟，单位为兆赫（MHZ）。
+#define MCUCFG_SYSCLK                   96
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+#else
+/* 手动配置-额外配置 */
+// 如果系统滴答配置方式为手动配置，用户仍需额外配置下方定义项，
+// 用于 CosyOS-任务管理器 的CPU使用率统计、滴答时间统计等功能。
+// 当然，如果您不打算使用 CosyOS-任务管理器，可不用配置。
+// 默认配置仅为示例，给用户以参考和提示。
+
+// 系统滴答-计数方式
+// <1=> 从零向上计数至重装载值溢出 <2=> 从重装载值向下计数至零溢出
+// <3=> 从重装载值向上计数至零溢出 <4=> 从零向下计数至重装载值溢出
+// 告知CosyOS您所配置的定时器计数方式。
+#define MCUCFG_SYSTICK_COUNTMODE        2
+
+// 系统滴答-位数
+// 如果定时器计数方式配置为3或4，应正确配置该定义。
+#define MCUCFG_SYSTICK_BITS             32
+
+// 系统滴答-当前值
+// 应配置为可读的当前值寄存器。
+#define MCUCFG_SYSTICK_CURRVALUE        (*(volatile uint32_t *)0xE000F008)
+
+// 系统滴答-重装载值
+// 如果该值为常量可配置为常量，否则应配置为可读的重装载值寄存器。
+#define MCUCFG_SYSTICK_LOADVALUE        (*(volatile uint32_t *)0xE000F010)
+
+// 系统滴答-时钟
+// 告知CosyOS您所配置的系统滴答时钟，单位为兆赫（MHZ）。
+#define MCUCFG_SYSTICK_CLK              96 // = (系统时钟 / (((*(volatile uint32_t *)0xE000F000) & 4) ? 1 : 8))
+
+#endif
+
+//////////////////////////////////* 系统定义 *//////////////////////////////////
+
+// 以下为系统定义，用户不可随意修改。
+
+#define MCUCFG_REGBYTES     4
+#define MCUCFG_FPUBYTES     4
+#define MCUCFG_TIMn_IRQn   12
+#define MCUCFG_XXXx_IRQn   14
+#define OS_PendSV_Handler  SW_Handler
+
+////////////////////////////////////////////////////////////////////////////////
+
+#endif

Port/port_x32/RISC-V32/port_rv32.h

@@ -0,0 +1,174 @@
+/**************************************************************************//**
+ * @item     CosyOS-III Port
+ * @file     port_rv32.h
+ * @brief    RISC-V32 Core Port File
+ * @author   迟凯峰
+ * @version  v3.0.8
+ * @date     2026.08.15
+ ******************************************************************************/
+
+#ifndef __PORT_RV32_H
+#define __PORT_RV32_H
+
+/* INCLUDE */
+#include "port_x32.h"
+#include "mcucfg_rv32.h"
+#include SYSCFG_STANDARDHEAD
+#include "os_cmsis.h"
+#include "os_stack.h"
+
+
+/* CONST & ATTRIBUTE */
+#define MCUCFG_STACK_ALIGN        __ALIGNED(16)
+#define MCUCFG_TASKSTACK_REALLOC  __DISABLED__
+#if (MCUCFG_FPU_AUTOSTORE == __ENABLED__)
+#define MCUCFG_PUSH_FPU          (32 * MCUCFG_FPUBYTES)
+#else
+#define MCUCFG_PUSH_FPU           0
+#endif
+#if !defined ( __riscv_32e )
+#define MCUCFG_PUSH_REG          (32 * MCUCFG_REGBYTES)
+#else
+#define MCUCFG_PUSH_REG          (16 * MCUCFG_REGBYTES)
+#endif
+#define MCUCFG_BASICSTACKSIZE    (MCUCFG_PUSH_FPU + MCUCFG_PUSH_REG)
+
+
+/* TaskCtrl */
+#define mTaskCtrl_Head_           m_sp_t psp;
+#define mTaskCtrl_Tail_           m_sp_t psp_top;
+
+
+/*
+ * SysTick
+ */
+#if (MCUCFG_SYSTICK_AUTOCONFIG == __ENABLED__)
+/* 自动配置 */
+#define MCUCFG_SYSTICK_COUNTMODE   1             /*!< 计数方式，1：从零向上计数至重装载值溢出 */
+#define MCUCFG_SYSTICK_LIMITVALUE (1UL << 32)    /*!< 极限值 */
+#define MCUCFG_SYSTICK_CURRVALUE  *(volatile s_u32_t *)(0xE000F008) /*!< 当前值寄存器 */
+#define MCUCFG_SYSTICK_CLK         MCUCFG_SYSCLK
+#define MCUCFG_SYSTICK_COUNT1CYC  (SYSCFG_SYSTICK_CYCLE * MCUCFG_SYSTICK_CLK * 1UL)
+#define MCUCFG_SYSTICK_LOADVALUE  (MCUCFG_SYSTICK_COUNT1CYC - 1)
+#define MCUCFG_SYSTICK_MAXVALUE    MCUCFG_SYSTICK_LOADVALUE
+#define MCUCFG_SYSTICK_MINVALUE    0
+#if (MCUCFG_SYSTICK_COUNT1CYC > MCUCFG_SYSTICK_LIMITVALUE)
+#error 系统滴答定时器溢出。
+#endif
+#define mSysTick_SetLOAD()        *(volatile s_u32_t *)(0xE000F010) = MCUCFG_SYSTICK_LOADVALUE
+#define mSysTick_SetCTRL()        *(volatile s_u32_t *)(0xE000F000) = 0x2F
+#define mSysTick_INIT() \
+do{ \
+	mSysTick_SetPRI(); \
+	mSysTick_SetLOAD(); \
+	mSysTick_SetCTRL(); \
+}while(false)
+
+#else
+/* 手动配置 */
+  #if (MCUCFG_SYSTICK_COUNTMODE == 1 || MCUCFG_SYSTICK_COUNTMODE == 2)
+#define MCUCFG_SYSTICK_MAXVALUE   (MCUCFG_SYSTICK_LOADVALUE)
+#define MCUCFG_SYSTICK_MINVALUE    0
+#define MCUCFG_SYSTICK_COUNT1CYC  (MCUCFG_SYSTICK_LOADVALUE + 1UL)
+
+#elif (MCUCFG_SYSTICK_COUNTMODE == 3 || MCUCFG_SYSTICK_COUNTMODE == 4)
+#define MCUCFG_SYSTICK_LIMITVALUE (1UL << MCUCFG_SYSTICK_BITS)
+#define MCUCFG_SYSTICK_MAXVALUE   (MCUCFG_SYSTICK_LIMITVALUE)
+#define MCUCFG_SYSTICK_MINVALUE   (MCUCFG_SYSTICK_LOADVALUE)
+#define MCUCFG_SYSTICK_COUNT1CYC  (MCUCFG_SYSTICK_MAXVALUE - MCUCFG_SYSTICK_MINVALUE)
+#endif
+
+#define mSysTick_INIT()  mSysTick_SetPRI()
+#endif
+
+
+/*
+ * SysTick_Handler + PendSV_Handler
+ */
+
+/* SysTick */
+#define mSysTick_SetPRI() \
+	*(volatile s_u8_t *)(0xE000E400 + MCUCFG_TIMn_IRQn) = 0xFF
+
+/* PendSV */
+#define mPendSV_SetPRI() \
+	*(volatile s_u8_t *)(0xE000E400 + MCUCFG_XXXx_IRQn) = 0xFF
+
+#define mPendSV_Set() \
+	*(volatile s_u32_t *)(0xE000E200 + MCUCFG_XXXx_IRQn / 32 * 4) = 0x01UL << (MCUCFG_XXXx_IRQn % 32)
+
+#define mPendSV_Clear() \
+	*(volatile s_u32_t *)(0xE000E280 + MCUCFG_XXXx_IRQn / 32 * 4) = 0x01UL << (MCUCFG_XXXx_IRQn % 32)
+
+#define mPendSV_INIT()   mPendSV_SetPRI()
+
+/* 内核锁 */
+#define mSysINT_Disable() \
+	*(volatile s_u32_t *)(0xE000E180 + MCUCFG_XXXx_IRQn / 32 * 4) = (0x01UL << (MCUCFG_XXXx_IRQn % 32)) \
+                                                                  | (0x01UL << (MCUCFG_TIMn_IRQn % 32))
+#define mSysINT_Enable() \
+	*(volatile s_u32_t *)(0xE000E100 + MCUCFG_XXXx_IRQn / 32 * 4) = (0x01UL << (MCUCFG_XXXx_IRQn % 32)) \
+                                                                  | (0x01UL << (MCUCFG_TIMn_IRQn % 32))
+__STATIC_FORCEINLINE void __mu_disable_sysirq(void)
+{
+	mSysINT_Disable();
+	__ASM("fence.i");
+}
+
+__STATIC_FORCEINLINE void __mu_enable_sysirq(void)
+{
+	__ASM("fence rw, rw");
+	mSysINT_Enable();
+}
+
+
+/* CosyOS初始化 */
+#define mCosyOS_INIT() \
+do{ \
+	mPendSV_INIT(); \
+	mSysTick_INIT(); \
+}while(false)
+
+
+/* CosyOS低功耗 */
+#define mCosyOS_IDLE()  __WFI()
+
+
+/* 任务栈 */
+#define MCUCFG_TASKSTACK_MODE __PSP__
+
+#define mTaskStack_Init() \
+do{ \
+	node_news->psp_top = (m_sp_t)node_news->bsp + node_news->stacksize; \
+	if(node_news->psp_top % 16){ \
+		node_news->psp_top /= 16; \
+		node_news->psp_top *= 16; \
+		node_news->stacksize = node_news->psp_top - (m_sp_t)node_news->bsp; \
+	} \
+	mTaskStack_CheckInit(); \
+	mTaskStack_Reset(); \
+}while(false)
+
+#define mTaskStack_Reset() \
+do{ \
+	node_news->psp = node_news->psp_top; \
+	node_news->psp -= MCUCFG_BASICSTACKSIZE; \
+	*(volatile s_u32_t *)(node_news->psp + MCUCFG_PUSH_FPU) = (s_u32_t)node_news->entry; /* x0(mepc) */ \
+}while(false)
+
+/* 栈监控 */
+#if (SYSCFG_DEBUGGING == __ENABLED__)
+#define mTaskStack_Check0()    s_task_current->psp_top - __get_SP() + MCUCFG_PUSH_FPU
+#define mTaskStack_Check()     s_stack_check((s_u8_t *)(s_task_current->psp_top), s_task_current->stacksize)
+#define mTaskStack_CheckInit() s_stack_check_init((s_u8_t *)(node_news->psp_top), node_news->stacksize)
+
+#else
+#define mTaskStack_CheckInit()
+#endif
+
+
+/* 内存访问屏障 */
+#define __mx_MMB()  __ASM("fence rw, rw")
+
+
+#endif

Port/port_x32/RISC-V32/port_rv32_FSL.S

@@ -0,0 +1,85 @@
+/**************************************************************************//**
+ * @item     CosyOS-III Port
+ * @file     port_rv32_FSL.S
+ * @brief    RISC-V32 Core Port File for Interrupt FIFO Service Loading
+ * @author   迟凯峰
+ * @version  v3.0.7
+ * @date     2026.08.14
+ ******************************************************************************/
+
+#include "syscfg.h"
+#include "mcucfg_rv32.h"
+
+////////////////////////////////////////////////////////////////////////////////
+
+#if (SYSCFG_PENDSVFIFO_DEPTH > 0)
+
+/* 互斥访问机制 */
+#if (MCUCFG_PENDSVFIFO_MUTEX == 0xFF)
+.data
+mPendSV_FIFO_X: .word 0
+#endif
+
+/* 中断FIFO服务装载器 */
+.global mPendSV_FIFOLoader
+.align  2
+mPendSV_FIFOLoader:
+
+/* FIFO选择 */
+	la       a2,  m_fifo_lock
+	lb       a3, (a2)
+	beqz     a3,  1f
+	la       a1,  mPendSV_FIFO_0
+	j        2f
+1:	la       a1,  mPendSV_FIFO_1
+/* 计数溢出 */
+2:
+	#if (0) // 正常情况下计数器难以溢出，默认关闭防护以提高装载效率。
+	lw       a2, (a1)
+	li       a3,  0x80000000
+	bltu     a3,  a2,  5f
+	#endif
+/* FIFO计数 */
+	/* 关闭总中断（嵌套方式）*/
+	#if   (MCUCFG_PENDSVFIFO_MUTEX == 0)
+	csrr     a3,  mstatus
+	csrc     mstatus, 0x8
+	fence.i
+	lw       a2, (a1)
+	addi     a2,  a2,  1
+	sw       a2, (a1)
+	csrw     mstatus, a3
+	/* [lr][sc]指令 */
+	#elif (MCUCFG_PENDSVFIFO_MUTEX == 1)
+3:	lr.w     a2, (a1)
+	addi     a2,  a2,  1
+	sc.w     a3,  a2, (a1)
+	bnez     a3,  3b
+	/* [amoadd]指令 */
+	#elif (MCUCFG_PENDSVFIFO_MUTEX == 2)
+	li       a3,  1
+	amoadd.w a2,  a3, (a1)
+	addi     a2,  a2,  1
+	/* 互斥访问机制 */
+	#elif (MCUCFG_PENDSVFIFO_MUTEX == 0xFF)
+	csrrwi   a3,  mscratch, 1
+3:	add      tp,  a1,  zero
+	lw       a2, (tp)
+	addi     a2,  a2,  1
+	sw       a2, (tp)
+	bne      tp,  a1,  3b
+	csrw     mscratch, a3
+	beqz     a3,  4f
+	la       tp,  mPendSV_FIFO_X
+	#endif
+/* FIFO溢出 */
+4:	li       a3,  SYSCFG_PENDSVFIFO_DEPTH
+	bltu     a3,  a2,  5f
+/* FIFO装载 */
+	slli     a2,  a2,  2
+	add      a1,  a1,  a2
+	sw       a0, (a1)
+
+5:	ret
+
+#endif

Port/port_x32/RISC-V32/port_rv32e_HWS.S

@@ -0,0 +1,73 @@
+/**************************************************************************//**
+ * @item     CosyOS-III Port
+ * @file     port_rv32e_HWS.S
+ * @brief    RV32E Core Port File for Hardware Stack
+ * @note     对处理器特权模式无要求。
+ * @note     x4(tp)寄存器默认未保护，如需保护可自行开启。
+ * @author   迟凯峰
+ * @version  v3.0.7
+ * @date     2026.08.14
+ ******************************************************************************/
+
+#if defined ( __riscv_32e )
+
+#include "syscfg.h"
+#include "mcucfg_rv32.h"
+#define   store    sw
+#define   load     lw
+
+////////////////////////////////////////////////////////////////////////////////
+
+/* PendSV 软中断 */
+
+.global OS_PendSV_Handler
+.align  2
+OS_PendSV_Handler: // hardware push Caller
+
+/* push Callee */
+	addi sp, sp, -4 * MCUCFG_REGBYTES
+	store    x8,  1 * MCUCFG_REGBYTES(sp)
+	store    x9,  2 * MCUCFG_REGBYTES(sp)
+////store    x4,  3 * MCUCFG_REGBYTES(sp) // default not store/load x4
+
+	call    sPendSV_Handler
+	beqz    a0,  2f // 直接返回
+	la      s1,  s_task_current
+	addi    s0,  a0, -1
+	beqz    s0,  1f // 恢复现场
+
+/* push mepc */
+	csrr    a0,  mepc
+	store   a0,   0 * MCUCFG_REGBYTES(sp)
+
+/* 任务-PC 监控 */
+#if (SYSCFG_TASKPC_MONITOR == 1)
+	la      a1,  s_pc
+	sw      a0, (a1)
+#endif
+
+	lw      t0, (s1)
+	sw      sp, (t0)
+	fence   rw,  rw
+
+/* 恢复现场 */
+1:	la      t1,  s_task_news
+	lw      t0, (t1)
+	lw      sp, (t0)
+	sw      t0, (s1)
+
+/* pop mepc */
+	load    a0,   0 * MCUCFG_REGBYTES(sp)
+	csrw    mepc, a0
+
+/* pop Callee */
+2:	load    x8,   1 * MCUCFG_REGBYTES(sp)
+	load    x9,   2 * MCUCFG_REGBYTES(sp)
+////load    x4,   3 * MCUCFG_REGBYTES(sp) // default not store/load x4
+	addi sp, sp,  4 * MCUCFG_REGBYTES
+
+	mret // hardware pop Caller
+
+////////////////////////////////////////////////////////////////////////////////
+
+#endif

Port/port_x32/port_x32.c

@@ -0,0 +1,90 @@
+/**************************************************************************//**
+ * @item     CosyOS-III Port
+ * @file     port_x32.c
+ * @brief    32 bits Micro-Controller Public Port File
+ * @author   迟凯峰
+ * @version  v3.0.0
+ * @date     2026.07.21
+ ******************************************************************************/
+
+#include "os_var.h"
+#ifdef __PORT_X32_H
+
+
+/*
+ * 中断FIFO服务
+ */
+#if (SYSCFG_PENDSVFIFO_DEPTH > 0)
+
+/**
+ \brief    FIFO互斥访问锁
+ \details  入FIFO与出FIFO之间的互斥
+ \note     if(锁) { 中断FIFO服务装载器入FIFO0，中断FIFO服务处理器出FIFO1 } <br>
+           else   { 中断FIFO服务装载器入FIFO1，中断FIFO服务处理器出FIFO0 }
+ */
+bool volatile m_fifo_lock = true;
+
+void *mPendSV_FIFO_0[SYSCFG_PENDSVFIFO_DEPTH + 1]; // FIFO0
+void *mPendSV_FIFO_1[SYSCFG_PENDSVFIFO_DEPTH + 1]; // FIFO1
+
+#if (SYSCFG_PENDSVFIFO_MONITOR == __ENABLED__)
+s_u32_t mPendSV_FIFO_DepthMAX/**/sZeroInstall;
+s_u16_t mPendSV_FIFO_CountMAX/**/sZeroInstall;
+#endif
+
+/* 中断FIFO服务处理器 */
+void mPendSV_FIFOHandler(void)
+{
+	register s_u32_t i;
+	register s_u16_t j = 0;
+	register bool lock = 1;
+	register void ** p;
+	         void ** const fifo[2] = {mPendSV_FIFO_0, mPendSV_FIFO_1};
+	
+	while(true){
+		lock = !lock;
+		p = fifo[lock];
+		m_fifo_lock = lock;
+		__mx_MMB();
+		
+		if(p[0]){
+			i = (s_u32_t)p[0];
+			p[0] = 0;
+			#if (SYSCFG_PENDSVFIFO_MONITOR == __ENABLED__)
+			if(i > mPendSV_FIFO_DepthMAX){
+				mPendSV_FIFO_DepthMAX = i;
+			}
+			#endif
+			if(i > SYSCFG_PENDSVFIFO_DEPTH){
+				i = SYSCFG_PENDSVFIFO_DEPTH;
+				#if (SYSCFG_PENDSVFIFO_MONITOR == __ENABLED__)
+				s_fault.overflow_pendsvfifo = true;
+				#endif
+			}
+			j += i;
+			do{
+				register void *sv = *++p;
+				#if (MCUCFG_PENDSVFIFO_MUTEX < 0x80)
+				(*sPendSV_FIFOHandler[*(s_u8_t const *)sv])(sv);
+				#else
+				if(sv != OS_NULL){
+					*p = OS_NULL;
+					(*sPendSV_FIFOHandler[*(s_u8_t const *)sv])(sv);
+				}
+				#endif
+			}while(--i);
+		}
+		
+		if(lock){
+			if(0 == mPendSV_FIFO_0[0]) break;
+			if(j >= SYSCFG_PENDSVFIFO_COUNT) break;
+		}
+	}
+	
+	#if (SYSCFG_PENDSVFIFO_MONITOR == __ENABLED__)
+	if(mPendSV_FIFO_CountMAX < j) mPendSV_FIFO_CountMAX = j;
+	#endif
+}
+
+#endif
+#endif

Port/port_x32/port_x32.h

@@ -0,0 +1,96 @@
+/**************************************************************************//**
+ * @item     CosyOS-III Port
+ * @file     port_x32.h
+ * @brief    32 bits Micro-Controller Public Port File
+ * @author   迟凯峰
+ * @version  v3.0.0
+ * @date     2026.07.21
+ ******************************************************************************/
+
+#ifndef __PORT_X32_H
+#define __PORT_X32_H
+
+/* INCLUDE */
+#include "syscfg.h"
+#include "os_def.h"
+#include <stdbool.h>
+
+
+/* LAJI */
+#define _SYS_REG_
+#define _SYS_MEM_
+#define _OBJ_MEM_
+#define _RTC_MEM_
+#define _QUE_MEM_
+#define _CODE_MEM_
+#define _CONST_MEM_
+#define _STACK_MEM_
+#define _XDATA_MEM_
+#define _DEBUG_MEM_
+#define _STATIC_MEM_
+#define _MALLOC_MEM_
+
+
+/* Typedef */
+#define m_boolvoid_tf
+typedef char  s_s8_t;
+typedef short s_s16_t;
+typedef int   s_s32_t;
+typedef unsigned char  s_u8_t;
+typedef unsigned short s_u16_t;
+typedef unsigned int   s_u32_t;
+typedef bool     m_bit_t;
+typedef s_u32_t  m_sp_t;
+typedef s_u32_t  m_pc_t;
+typedef s_u32_t  m_tick_t;
+typedef s_u32_t  m_group_t;
+typedef s_u32_t  m_fetion_t;
+typedef s_u32_t  m_tqcount_t;
+typedef s_u32_t  m_rtccount_t;
+typedef s_u32_t  m_stacklen_t;
+typedef s_u32_t  m_stacksize_t;
+
+
+/* CONST & ATTRIBUTE */
+#define MCUCFG_PCLEN        4
+#define MCUCFG_TASK_ATTRIBUTE
+#define MCUCFG_OSIT_ATTRIBUTE
+#define MCUCFG_SYSTICK_ATTRIBUTE
+#define MCUCFG_TERNARY_MASK
+
+
+/* 中断FIFO服务-声明 */
+#if (SYSCFG_PENDSVFIFO_DEPTH > 0)
+extern  bool     volatile  m_fifo_lock;
+extern  s_u32_t  mPendSV_FIFO_DepthMAX;
+extern  s_u16_t  mPendSV_FIFO_CountMAX;
+extern  void    *mPendSV_FIFO_0[SYSCFG_PENDSVFIFO_DEPTH + 1];
+extern  void    *mPendSV_FIFO_1[SYSCFG_PENDSVFIFO_DEPTH + 1];
+extern  void     mPendSV_FIFOLoader (void *sv);
+extern  void     mPendSV_FIFOHandler(void);
+#endif
+
+/* 中断FIFO服务-装载 */
+#define mPendSV_FIFOLoad() \
+do{ \
+	mPendSV_FIFOLoader(&u_psv); \
+	mPendSV_Set(); \
+}while(false)
+
+/* 中断FIFO服务-处理 */
+#define mPendSV_FIFOHandle() \
+	if(mPendSV_FIFO_0[0]) mPendSV_FIFOHandler()
+
+
+/* 事件标志组-中断中写多标志位 */
+#define miWriteFlagBits() \
+	if(!u_psv.value){ \
+		do{}while(false)
+
+
+/* 内核锁 */
+#define mSysIRQ_Disable() __mu_disable_sysirq()
+#define mSysIRQ_Enable()  __mu_enable_sysirq()
+
+
+#endif

Port/port_x51/80251/mcucfg_80251.h

@@ -3,8 +3,8 @@
  * @file     mcucfg_80251.h
  * @brief    80251 Core Config File
  * @author   迟凯峰
- * @version  V2.3.1
- * @date     2026.03.01
+ * @version  v3.0.0
+ * @date     2026.07.21
  ******************************************************************************/
 
 #ifndef __MCUCFG_80251_H
@@ -72,22 +72,26 @@
 
 // </h>
 ///////////////////////////////////////////////////////////////////////////////
-// <o> PendSV_FIFO深度
-// <0=> 0级（不启用PendSV_FIFO）<8=> 8级 <16=> 16级 <24=> 24级 <32=> 32级 <40=> 40级
-// <i> 此项参数取决于您在中断中调用挂起服务的总数及中断的频率。
-// <i> 对于80251来说，PendSV_FIFO的最大深度为40，您应妥善处理中断中调用的挂起服务，避免不必要的调用。
-// <i> 可开启PendSV_FIFO监控功能，监控历史上的最大值，再适当增大，以确保其不会溢出。
-#define MCUCFG_PENDSVFIFO_DEPTH         32
-
-// <o> 中断FIFO服务处理器-最大并发执行数
-// <i> 中断FIFO服务处理器在一次运行中，允许执行服务的最大数量。
-// <i> 如果超出这个数值，中断FIFO服务处理器将主动退出运行，而后继续执行任务调度/切换。
-// <i> 该功能可防止因中断FIFO服务的多阶段持续并发而导致的中断FIFO服务处理器死锁（永远有执行不完的服务），
-// <i> 并最终导致任务不能调度运行。
-// <i> 该值通常建议在“PendSV_FIFO深度值的2~10倍之间”选取，不建议过大或过小。
-// <i> 可开启PendSV_FIFO监控功能，监控“实际并发执行数”在历史上的最大值，如果过大说明设计存在不合理因素，
-// <i> 应设法予以解决。
-#define MCUCFG_PENDSVFIFO_COUNT         256
+// <o> 中断FIFO服务装载器-互斥访问方案
+// <256=> [JBC]指令 <255=> [INC]指令 <0=> 关闭总中断
+// <i> ------------------------------------------------------------------------
+// <i> [JBC]指令
+// <i> 适用于所有80251内核，可实现全局不关总中断、零中断延迟。
+// <i> 适用于FIFO服务持续并发量较小的情况。
+// <i> PendSV_FIFO深度最大值：40
+// <i> ------------------------------------------------------------------------
+// <i> [INC]指令
+// <i> 适用于所有80251内核，可实现全局不关总中断、零中断延迟。
+// <i> 适用于FIFO服务持续并发量较大的情况。
+// <i> PendSV_FIFO深度最大值：127
+// <i> ------------------------------------------------------------------------
+// <i> 关闭总中断
+// <i> 适用于所有80251内核，并具有极短的、确定的关闭总中断时间，
+// <i> 包括关闭总中断、再次开启总中断在内，共8个机器周期。
+// <i> 内核关闭总中断仅发生在 port_80251s.s > mPendSV_FIFOPreempt 中。
+// <i> 适用于FIFO服务持续并发量较大的情况。
+// <i> PendSV_FIFO深度最大值：127
+#define MCUCFG_PENDSVFIFO_MUTEX         256
 
 ///////////////////////////////////////////////////////////////////////////////
 // <h> 动态内存设置
@@ -191,8 +195,12 @@ do{ \
 
 ///////////////////////////////////////////////////////////////////////////////
 
-#define __MSP__   0 // MSP模式
-#define __PSP__   1 // PSP模式
+#ifndef __MSP__
+#define __MSP__   1 // MSP模式
+#endif
+#ifndef __PSP__
+#define __PSP__   2 // PSP模式
+#endif
 
 #if   (__MCUCFG_SYSCLK && __MCUCFG_SYSCLK <= 255)
 #define MCUCFG_SYSCLK   (__MCUCFG_SYSCLK / 1UL)
@@ -232,10 +240,5 @@ do{ \
 #define mUserReg_Addr (node_news->bsp + 42)
 #endif
 
-#if ((MCUCFG_PENDSVFIFO_DEPTH % 8) || (MCUCFG_PENDSVFIFO_DEPTH > 40))
-#error 参数非法 of 中断挂起服务FIFO队列深度！
-#endif
-
-
 
 #endif

Port/port_x51/80251/mcucfg_80251.inc

@@ -4,8 +4,8 @@
 ;* @brief    80251 Core Config File
 ;* @details  自定义任务切换现场保护，汇编语言保护方案。
 ;* @author   迟凯峰
-;* @version  V2.0.0
-;* @date     2025.08.04
+;* @version  v3.0.0
+;* @date     2026.07.21
 ;*******************************************************************************
 
 ; 下方各定义项已经直接给出示例（保护/恢复：DPH1、DPL1、DPS），直接修改即可。

Port/port_x51/80251/port_80251.c

@@ -0,0 +1,114 @@
+/**************************************************************************//**
+ * @item     CosyOS-III Port
+ * @file     port_80251.c
+ * @brief    80251 Core Port File
+ * @author   迟凯峰
+ * @version  v3.0.0
+ * @date     2026.07.21
+ ******************************************************************************/
+
+#include "os_var.h"
+#ifdef __PORT_80251_H
+
+s_u16_t _SYS_MEM_ m_bsp_add = sizeof(s_taskload_ts);
+static s_u8_t xdata mVOID _at_ 0;
+
+
+/*
+ * 栈监控（涵盖主栈和任务栈）
+ */
+#if (SYSCFG_DEBUGGING == __ENABLED__)
+s_u16_t data m_taskstacklen;
+#if (MCUCFG_TASKSTACK_MODE == __MSP__)
+s_u16_t m_msp;
+s_u16_t m_stacksize;
+s_u16_t m_stacklen_max/**/sZeroInstall;
+#endif
+#endif
+
+
+/*
+ * 中断FIFO服务
+ */
+#if (SYSCFG_PENDSVFIFO_DEPTH > 0)
+
+#if (MCUCFG_PENDSVFIFO_MUTEX < 0x80) \
+ || (MCUCFG_PENDSVFIFO_MUTEX > 0xFF)
+void _STATIC_MEM_ *mPendSV_FIFO_0[SYSCFG_PENDSVFIFO_DEPTH] _at_ 0x0100; // FIFO0
+void _STATIC_MEM_ *mPendSV_FIFO_1[SYSCFG_PENDSVFIFO_DEPTH] _at_ 0x0200; // FIFO1
+#else
+void _STATIC_MEM_ *mPendSV_FIFO_0[SYSCFG_PENDSVFIFO_DEPTH] _at_ 0x0100/**/sZeroInstall_Group;
+void _STATIC_MEM_ *mPendSV_FIFO_1[SYSCFG_PENDSVFIFO_DEPTH] _at_ 0x0200/**/sZeroInstall_Group;
+#endif
+
+
+/*
+ * [INC]指令 和 关闭总中断
+ */
+#if (MCUCFG_PENDSVFIFO_MUTEX < 0x100)
+
+/* FIFO计数器 */
+s_u8_t data m_fifo_count[2]/**/sZeroInstall_Group;
+
+/* 中断FIFO服务处理器 */
+void mPendSV_FIFOHandler(void)
+{
+	register s_u8_t i;
+	register s_u16_t j = 0;
+	register bool lock = 1;
+	register void _STATIC_MEM_ * _STATIC_MEM_ * p;
+	         void _STATIC_MEM_ * _STATIC_MEM_ * const fifo[2] = {
+	              mPendSV_FIFO_0 - 1,
+	              mPendSV_FIFO_1 - 1
+	         };
+	
+	while(true){
+		lock = !lock;
+		p = fifo[lock];
+		m_fifo_lock = lock;
+		__mx_MMB();
+		
+		if(m_fifo_count[lock]){
+			i = m_fifo_count[lock];
+			m_fifo_count[lock] = 0;
+			#if (SYSCFG_PENDSVFIFO_MONITOR == __ENABLED__)
+			if(i > mPendSV_FIFO_DepthMAX){
+				mPendSV_FIFO_DepthMAX = i;
+			}
+			#endif
+			if(i > SYSCFG_PENDSVFIFO_DEPTH){
+				i = SYSCFG_PENDSVFIFO_DEPTH;
+				#if (SYSCFG_PENDSVFIFO_MONITOR == __ENABLED__)
+				s_fault.overflow_pendsvfifo = true;
+				#endif
+			}
+			j += i;
+			do{
+				register void _STATIC_MEM_ *sv = *++p;
+				#if (MCUCFG_PENDSVFIFO_MUTEX < 0x80)
+				(*sPendSV_FIFOHandler[*(s_u8_t const *)sv])(sv);
+				#else
+				if(sv != OS_NULL){
+					*p = OS_NULL;
+					(*sPendSV_FIFOHandler[*(s_u8_t const *)sv])(sv);
+				}
+				#endif
+			}while(--i);
+		}
+		
+		if(lock){
+			if(0 == m_fifo_count[0]) break;
+			if(j >= SYSCFG_PENDSVFIFO_COUNT) break;
+		}
+	}
+	
+	#if (SYSCFG_PENDSVFIFO_MONITOR == __ENABLED__)
+	if(mPendSV_FIFO_CountMAX < j) mPendSV_FIFO_CountMAX = j;
+	#endif
+}
+
+#endif
+#endif
+
+
+#endif

Port/port_x51/80251/startup_80251.s

@@ -3,12 +3,11 @@
 ;* @file     startup_80251.s
 ;* @brief    80251 Core Startup File
 ;* @author   迟凯峰
-;* @version  V2.0.0
-;* @date     2025.08.04
+;* @version  v3.0.0
+;* @date     2026.07.21
 ;*******************************************************************************
 ;
-$INCLUDE (syscfg.h)
-IF SYSCFG_MCUCORE == 80251
+IF __A251__
 $INCLUDE (mcucfg_80251.h)
 ;
 ;///////////////////////////////////////////////////////////////////////////////

Port/port_x51/8051/mcucfg_8051.h

@@ -3,8 +3,8 @@
  * @file     mcucfg_8051.h
  * @brief    8051 Core Config File
  * @author   迟凯峰
- * @version  V2.3.1
- * @date     2026.03.01
+ * @version  v3.0.0
+ * @date     2026.07.21
  ******************************************************************************/
 
 #ifndef __MCUCFG_8051_H
@@ -75,24 +75,6 @@
 #define mPendSV_Clear                   CLR IE0
 
 // </h>
-///////////////////////////////////////////////////////////////////////////////
-// <o> PendSV_FIFO深度
-// <0=> 0级（不启用PendSV_FIFO）<8=> 8级 <16=> 16级 <24=> 24级 <32=> 32级 <40=> 40级
-// <i> 此项参数取决于您在中断中调用挂起服务的总数及中断的频率。
-// <i> 对于8051来说，PendSV_FIFO的最大深度为40，您应妥善处理中断中调用的挂起服务，避免不必要的调用。
-// <i> 可开启PendSV_FIFO监控功能，监控历史上的最大值，再适当增大，以确保其不会溢出。
-#define MCUCFG_PENDSVFIFO_DEPTH         16
-
-// <o> 中断FIFO服务处理器-最大并发执行数
-// <i> 中断FIFO服务处理器在一次运行中，允许执行服务的最大数量。
-// <i> 如果超出这个数值，中断FIFO服务处理器将主动退出运行，而后继续执行任务调度/切换。
-// <i> 该功能可防止因中断FIFO服务的多阶段持续并发而导致的中断FIFO服务处理器死锁（永远有执行不完的服务），
-// <i> 并最终导致任务不能调度运行。
-// <i> 该值通常建议在“PendSV_FIFO深度值的2~10倍之间”选取，不建议过大或过小。
-// <i> 可开启PendSV_FIFO监控功能，监控“实际并发执行数”在历史上的最大值，如果过大说明设计存在不合理因素，
-// <i> 应设法予以解决。
-#define MCUCFG_PENDSVFIFO_COUNT         128
-
 ///////////////////////////////////////////////////////////////////////////////
 // <h> 动态内存设置
 // <i> CosyOS会使用下列参数自动初始化内存池。
@@ -234,6 +216,8 @@ do{ \
 #define _QUE_MEM_ xdata
 #endif
 
+#define MCUCFG_PENDSVFIFO_MUTEX  0x100
+
 #if (!__MCUCFG_USERREGSAVE_C)
 #define mUserReg_DEFc_
 #define mUserReg_SAVEc()
@@ -253,10 +237,5 @@ do{ \
 #endif
 #endif
 
-#if ((MCUCFG_PENDSVFIFO_DEPTH % 8) || (MCUCFG_PENDSVFIFO_DEPTH > 40))
-#error 参数非法 of 中断挂起服务FIFO队列深度！
-#endif
-
-
 
 #endif

Port/port_x51/8051/mcucfg_8051.inc

@@ -4,8 +4,8 @@
 ;* @brief    8051 Core Config File
 ;* @details  自定义任务切换现场保护，汇编语言保护方案。
 ;* @author   迟凯峰
-;* @version  V2.0.0
-;* @date     2025.08.04
+;* @version  v3.0.0
+;* @date     2026.07.21
 ;*******************************************************************************
 ;
 ; 请在 mcucfg_8051.h 文件中，选择您中意的保护方案，而后在下面重新调整代码。

Port/port_x51/8051/port_8051.c

@@ -0,0 +1,38 @@
+/**************************************************************************//**
+ * @item     CosyOS-III Port
+ * @file     port_8051.c
+ * @brief    8051 Core Port File
+ * @author   迟凯峰
+ * @version  v3.0.0
+ * @date     2026.07.21
+ ******************************************************************************/
+
+#include "os_var.h"
+#ifdef __PORT_8051_H
+
+s_u8_t _SYS_MEM_ m_bsp_add = sizeof(s_taskload_ts);
+
+
+/*
+ * 栈监控（涵盖主栈和任务栈）
+ */
+#if (SYSCFG_DEBUGGING == __ENABLED__)
+s_u8_t data m_taskstacklen;
+s_u8_t m_msp;
+s_u8_t m_stacksize;
+s_u8_t m_stacklen_max/**/sZeroInstall;
+#endif
+
+
+/*
+ * 中断FIFO服务
+ */
+#if (SYSCFG_PENDSVFIFO_DEPTH > 0)
+s_u16_t mPendSV_FIFO_0[SYSCFG_PENDSVFIFO_DEPTH] _at_ 0x0000;
+s_u16_t mPendSV_FIFO_1[SYSCFG_PENDSVFIFO_DEPTH] _at_ 0x0100;
+#else
+static s_u8_t xdata mVOID _at_ 0;
+#endif
+
+
+#endif

Port/port_x51/8051/startup_8051.s

@@ -3,13 +3,12 @@
 ;* @file     startup_8051.s
 ;* @brief    8051 Core Startup File
 ;* @author   迟凯峰
-;* @version  V2.0.0
-;* @date     2025.08.04
+;* @version  v3.0.0
+;* @date     2026.07.21
 ;*******************************************************************************
 ;
+IF __A51__
 $NOMOD51
-$INCLUDE (syscfg.h)
-IF SYSCFG_MCUCORE == 8051
 ;
 ;-------------------------------------------------------------------------------
 ;  基于 STARTUP.A51 修改，摒弃了一些不常用的或用不到的功能，并添加中文注释。

Port/port_x51/port_x51.h

@@ -0,0 +1,104 @@
+/**************************************************************************//**
+ * @item     CosyOS-III Port
+ * @file     port_x51.h
+ * @brief    80x51 Core Port File
+ * @author   迟凯峰
+ * @version  v3.0.0
+ * @date     2026.07.21
+ ******************************************************************************/
+
+#ifndef __PORT_X51_H
+#define __PORT_X51_H
+
+/* INCLUDE */
+#include "syscfg.h"
+#include "os_def.h"
+#include <intrins.h>
+
+
+/* Typedef */
+typedef char  s_s8_t;
+typedef short s_s16_t;
+typedef long  s_s32_t;
+typedef unsigned char  s_u8_t;
+typedef unsigned short s_u16_t;
+typedef unsigned long  s_u32_t;
+typedef s_u8_t   bool;
+typedef bit      m_bit_t;
+typedef s_u32_t  m_group_t;
+#if (SYSCFG_SYSTICK_CYCLE > 1000000UL / 65536)
+typedef s_u16_t  m_rtccount_t;
+#else
+typedef s_u32_t  m_rtccount_t;
+#endif
+
+
+/* Extern */
+extern  void     mx_disable_irq(void);
+extern  void     mx_resume_irq (void);
+#if (SYSCFG_PENDSVFIFO_DEPTH > 0)
+extern  bit      m_sign_fifo_0_0;
+extern  bit           m_fifo_lock;
+extern  s_u8_t   data m_fifo_count[2];
+extern  s_u8_t   mPendSV_FIFO_DepthMAX;
+extern  s_u16_t  mPendSV_FIFO_CountMAX;
+extern  void     mPendSV_FIFOHandler(void);
+#endif
+
+
+/* CONST & ATTRIBUTE */
+#define MCUCFG_STACK_ALIGN
+
+
+/* SysTick */
+#define MCUCFG_SYSTICK_COUNTMODE    3                /*!< 计数方式，3：从重装载值向上计数至零溢出 */
+#define MCUCFG_SYSTICK_LIMITVALUE  (1UL << 16)       /*!< 极限值 */
+#define MCUCFG_SYSTICK_CLKDIV     ((MCUCFG_SYSCLKHZ / 1000UL * SYSCFG_SYSTICK_CYCLE <= MCUCFG_SYSTICK_MAXVALUE * 1000UL) ? 1 : 12)
+#define MCUCFG_SYSTICK_COUNT1CYC  ((MCUCFG_SYSCLKHZ / 1000UL * SYSCFG_SYSTICK_CYCLE) / MCUCFG_SYSTICK_CLKDIV   / 1000UL)
+#define MCUCFG_SYSTICK_LOADVALUE   (MCUCFG_SYSTICK_LIMITVALUE - MCUCFG_SYSTICK_COUNT1CYC)
+#define MCUCFG_SYSTICK_MAXVALUE     MCUCFG_SYSTICK_LIMITVALUE
+#define MCUCFG_SYSTICK_MINVALUE     MCUCFG_SYSTICK_LOADVALUE
+
+
+/* 内核锁 */
+#define mSysIRQ_Disable() \
+do{ \
+	mPendSV_Disable(); \
+	mSysTick_Disable(); \
+}while(false)
+
+#define mSysIRQ_Enable() \
+do{ \
+	mSysTick_Enable(); \
+	mPendSV_Enable(); \
+}while(false)
+
+
+/* CosyOS初始化 */
+#define mCosyOS_INIT() \
+do{ \
+	s_init_mempool((void _MALLOC_MEM_ *)MCUCFG_MALLOCMEMBPTR, MCUCFG_MALLOCMEMSIZE); \
+	OS_NOP(1); \
+	mSysTick_INIT(); \
+	EA = 1; \
+}while(false)
+
+
+/* CosyOS低功耗 */
+#define mCosyOS_IDLE() \
+do{ \
+	PCON |= 0x01; \
+	OS_NOP(4); \
+}while(false)
+
+
+/* 全局临界区 */
+#define mxDisableIRQ()  mx_disable_irq()
+#define mxResumeIRQ()   mx_resume_irq()
+
+
+/* 内存访问屏障 */
+#define __mx_MMB()
+
+
+#endif

Port/syscfg.h

@@ -3,8 +3,8 @@
  * @file     syscfg.h
  * @brief    OS Config File
  * @author   迟凯峰
- * @version  V2.3.2
- * @date     2026.03.14
+ * @version  v3.0.0
+ * @date     2026.07.21
  ******************************************************************************/
 
 #ifndef __SYSCFG_H
@@ -18,9 +18,9 @@
 // <h> 系统配置
 // <i> 系统配置
 
-// <o> MCU内核
-// <1=> 8051 <2=> 80251 <3=> Cortex-M
-// <i> 告知CosyOS您的MCU内核，CosyOS将自动包含相匹配的MCU配置文件和PORT文件。
+// <o> 处理器架构
+// <1=> 8051 <2=> 80251 <3=> Cortex-M <4=> RISC-V32
+// <i> 告知CosyOS您的处理器架构，CosyOS将自动包含相匹配的MCU配置文件和PORT文件。
 #define __SYSCFG_MCUCORE                3
 
 // <s> 标准头文件
@@ -40,11 +40,17 @@
 // <i> 通常您可能不会用到内核锁，即使偶尔使用也应是极简的代码、一般不会嵌套调用。
 #define SYSCFG_KERNELLOCKNESTING        0
 
-// <q> 安全运行时
+// <e> 安全运行时
 // <i> 是否启用安全运行时？
 // <i> 安全运行时是CosyOS的安全关键技术之一，可防止某任务长期独占或超时使用处理器。
 #define SYSCFG_SAFERUNTIME              0
 
+// <o> 安全运行时计数器位数
+// <8=> 8位 <16=> 16位 <32=> 32位
+// <i> 如果MCU内核为8051，此项建议尽量配置为低位，以提高性能。
+#define SYSCFG_SRTIME_BITS              32
+// </e>
+
 // <q> 低功耗模式
 // <i> 是否启用低功耗模式？
 // <i> 如果开启该选项，CosyOS会在系统空闲任务中进入低功耗模式。
@@ -52,11 +58,36 @@
 // <i> 您也可不启用该功能，并自行配置自己的低功耗，在 idle_hook 中。
 #define SYSCFG_LOWPOWERMODE             0
 
+// <h> 中断FIFO服务
+// <i> 中断FIFO服务
+
+// <o> PendSV_FIFO深度
+// <i> 1、此项参数取决于您在中断中调用的FIFO服务总数及中断的频率。
+// <i> 2、对于8051来说，该值只能在 0/8/16/24/32/40 之中选取，其中0为不使用中断FIFO服务。
+// <i> 3、对于80251来说，如果中断FIFO服务装载器-互斥访问方案选择为[JBC]指令，
+// <i>    该值只能在 0/8/16/24/32/40 之中选取，其中0为不使用中断FIFO服务。
+// <i> 4、对于80251来说，如果中断FIFO服务装载器-互斥访问方案选择为[INC]指令或关闭总中断，
+// <i>    该值可在 0~127 之间选取，其中0为不使用中断FIFO服务。
+// <i> 5、对于 ARM、RISC-V 等新型架构来说，该值可在 0~255 之间选取，其中0为不使用中断FIFO服务。
+// <i> 6、可开启PendSV_FIFO监控功能，监控历史上的最大值，再适当增大，以确保其不会溢出。
+#define SYSCFG_PENDSVFIFO_DEPTH         32
+
+// <o> 中断FIFO服务处理器-最大并发执行数
+// <i> 中断FIFO服务处理器在一次运行中，允许执行服务的最大数量。
+// <i> 如果超出这个数值，中断FIFO服务处理器将主动退出运行，而后继续执行任务调度/切换。
+// <i> 该功能可防止因中断FIFO服务的多阶段持续并发而导致的中断FIFO服务处理器死锁（永远有执行不完的服务），
+// <i> 并最终导致任务不能调度运行。
+// <i> 该值通常建议在PendSV_FIFO深度值的2~10倍之间选取，不建议过大或过小。
+// <i> 可开启PendSV_FIFO监控功能，监控实际并发执行数在历史上的最大值，如果过大说明设计存在不合理因素，
+// <i> 应设法予以解决。
+#define SYSCFG_PENDSVFIFO_COUNT         256
+
 // <q> 中断FIFO服务-错误调用返回
 // <i> 是否启用中断FIFO服务-错误调用返回？
 // <i> 启用该功能后，当中断FIFO服务执行失败时，可在相应的回调函数中处理善后。
 #define SYSCFG_PENDSVFIFO_ERRORCALLBACK 0
 
+// </h>
 // </h>
 ///////////////////////////////////////////////////////////////////////////////
 // <e> DEBUG配置
@@ -75,7 +106,7 @@
 // <i> 标准模式：创建任务-尾参数，为任务名称文本。
 // <i> 兼容模式：创建任务-尾参数，如果输入字符串，则为任务名称文本；如果输入0，任务名称文本自动引用任务名称。
 // <i> 兼容模式，某些编译器（Keil C51、C251），不能正常支持。
-#define __SYSCFG_CREATETASKCUSTOM       0
+#define __SYSCFG_CREATETASKCUSTOM       2
 
 // <o> 任务名称最大长度
 // <i> 取值范围：<8-255>
@@ -158,11 +189,11 @@
 
 // <o> Starter-StackSize
 // <i> 任务启动器的任务栈大小，单位为字节数（Bytes）。
-#define SYSCFG_STACKSIZE_STARTER        384
+#define SYSCFG_STACKSIZE_STARTER        512
 
 // <o> Sysidle-StackSize
 // <i> 系统空闲任务的任务栈大小，单位为字节数（Bytes）。
-#define SYSCFG_STACKSIZE_SYSIDLE        256
+#define SYSCFG_STACKSIZE_SYSIDLE        384
 
 // <o> 任务栈重分配增量
 // <i> 当任务栈模式为MSP模式、任务为动态创建时，CosyOS将自动启用任务栈重分配机制，以抵御任务栈溢出的风险。
@@ -205,10 +236,9 @@
 // <i> 对于 CosyOS 来说，不同优先级的任务，永远都实行抢占式调度；
 // <i> 而相同优先级的任务，则分为无调度、协作式调度、时间片轮转调度。
 // <i> 无调度，是指不支持相同优先级的任务调度，每个任务的优先级都必须不同。
-// <i> 协作式调度，要求任务必须主动放弃处理器使用权（阻塞或挂起等方式），才能切换至下一个相同优先级的任务运行。
-// <i> 协作式调度，在性能上会高于时间片轮转调度，而且更节约内存。
-// <i> 协作式调度，用户不能创建自己的空闲任务。
-// <i> 在未经深思熟虑时，可优先选择时间片轮转调度，以保证相同优先级任务的平等运行机会。
+// <i> 时间片轮转调度，是指相同优先级的各个任务，享有相同的运行时间（时间片），轮流运行。
+// <i> 协作式调度，要求任务必须主动禅让处理器使用权，才能切换至下一个相同优先级的任务运行。
+// <i> 在未经深思熟虑时，应优先选择时间片轮转调度，以保证相同优先级任务的平等运行机会。
 #define SYSCFG_SAMEPRISCHEDULE          2
 
 // <h> 时间片模式
@@ -265,7 +295,7 @@
 // <o> 任务定时器位数
 // <8=> 8位 <16=> 16位 <32=> 32位
 // <i> 如果MCU内核为8051，此项建议尽量配置为低位（8位/16位），这将使大部分任务服务的执行效率提升约10%。
-#define SYSCFG_DELAYBITS                32
+#define SYSCFG_DELAY_BITS               32
 
 // </h>
 ///////////////////////////////////////////////////////////////////////////////
@@ -295,12 +325,12 @@
 // <o> 定时中断定时器位数
 // <8=> 8位 <16=> 16位 <32=> 32位
 // <i> 如果MCU内核为8051，此项建议尽量配置为低位，以提高性能。
-#define SYSCFG_TIMINTBITS               32
+#define SYSCFG_TIMINT_BITS              32
 
 // <o> 定时查询定时器位数
 // <8=> 8位 <16=> 16位 <32=> 32位
 // <i> 如果MCU内核为8051，此项建议尽量配置为低位，以提高性能。
-#define SYSCFG_TIMQRYBITS               32
+#define SYSCFG_TIMQRY_BITS              32
 
 // </h>
 ///////////////////////////////////////////////////////////////////////////////
@@ -354,7 +384,7 @@
 // <o> 计数信号量位数
 // <8=> 8位 <16=> 16位 <32=> 32位
 // <i> 如果MCU内核为8051，此项建议尽量配置为低位，以提高性能。
-#define SYSCFG_SEMAPHOREBITS            32
+#define SYSCFG_SEMAPH_BITS              32
 // </e>
 
 // <q> 事件标志组
@@ -373,10 +403,16 @@
 // <i> 是否启用消息邮箱？
 #define SYSCFG_MAILBOX                  1
 
-// <q> 消息队列
+// <e> 消息队列
 // <i> 是否启用消息队列？
 #define SYSCFG_MSGQUEUE                 1
 
+// <q> 中断中接收
+// <i> 是否需要在用户中断中接收消息？
+// <i> 如果不会在用户中断中接收消息，建议关闭该选项。
+// <i> 关闭该选项可使队列为无锁队列，性能进一步提升。
+#define SYSCFG_MSGQUEUE_INTRECV         1
+// </e>
 // </h>
 ///////////////////////////////////////////////////////////////////////////////
 // <h> 杂项设置
@@ -434,6 +470,8 @@
 #define SYSCFG_MCUCORE                  80251
 #elif (__SYSCFG_MCUCORE == 3)
 #define SYSCFG_MCUCORE                  cmx   // Cortex-M
+#elif (__SYSCFG_MCUCORE == 4)
+#define SYSCFG_MCUCORE                  rv32  // RISC-V32
 #endif
 
 #if (SYSCFG_DEBUGGING == 0)
@@ -459,6 +497,16 @@
 #define SYSCFG_STARTERCREATE d
 #endif
 
+#if defined ( __C51__ )
+#if ((SYSCFG_PENDSVFIFO_DEPTH % 8) || (SYSCFG_PENDSVFIFO_DEPTH > 40))
+#error 参数非法 of 中断挂起服务FIFO队列深度！
+#endif
+#elif !defined ( __C251__ )
+#if (SYSCFG_PENDSVFIFO_DEPTH > 255)
+#error 参数非法 of 中断挂起服务FIFO队列深度！
+#endif
+#endif
+
 #ifdef SYSCFG_TASKNAMELEN_MAX
 #if (SYSCFG_TASKNAMELEN_MAX < 8 || SYSCFG_TASKNAMELEN_MAX > 255)
 #error 参数非法 of 任务名称最大长度！
@@ -486,5 +534,4 @@
 #endif
 
 
-
 #endif

README.md

@@ -2,24 +2,23 @@
 ![Author](https://img.shields.io/badge/Author-迟凯峰-red?style=flat-square)
 ![languge](https://img.shields.io/badge/languge-C、Asm-blue)
 ![license](https://img.shields.io/badge/license-Apache2.0-brightgreen.svg)
-![version](https://img.shields.io/badge/version-2.3.2-green)
+![version](https://img.shields.io/badge/version-3.0.8-green)
 [![star](https://gitee.com/cosyos/cosyos/badge/star.svg?theme=dark)](https://gitee.com/cosyos/cosyos/stargazers)
 [![fork](https://gitee.com/cosyos/cosyos/badge/fork.svg?theme=dark)](https://gitee.com/cosyos/cosyos/members)
 
 * CosyOS-QQ交流群：303421780.
 
 ### 最新消息
-* CosyOS-III V2.3.0 发布，私信回归了，与之前版本相比，更为易用和高效、也更加可靠，欢迎大家踊跃试用！<br>
-  Demo-Service > 2、消息同步，有例程可做为参考。
-* CosyOS官网 [https://www.cosyos.com](https://www.cosyos.com)，现已正式上线，诚邀您莅临访问！<br>
-  当前正处于建站初期，各方面内容都还不够丰富，正在持续优化并完善中。。。
-* 近日，新增 例程-服务应用，为用户示范各项常用服务的典型应用，并在未来会陆续优化完善。
-* CosyOS-III V2.0.0 发布，推出了中断挂起服务_FIFO-错误调用返回，这标志着CosyOS进一步走向成熟和完善。
-* CosyOS-III V1.4.0 发布，推出了升级安装程序 CosyOS-III Cube.exe，可轻松将裸机工程升级为CosyOS工程。
-* CosyOS-III V1.3.8 发布，完善了对 Arm Compiler 5/6、GNU Compiler、IAR Compiler 等主流编译器的支持。
-* CosyOS-III V1.3.0 发布，解决了当嵌套获取多个互斥信号量时，可能会发生的优先级反转问题（该bug普遍存在于常见主流RTOS中）。
-* CosyOS 又取得新突破，现已升级至 **CosyOS-III**，说明文档持续更新中。。。<br>
-  原有 CosyOS-I、CosyOS-II 停止更新维护，但仍提供技术支持。
+CosyOS-III V3.0.1 版本发布，针对 RISC-V32，推出了自研先进技术，可实现 **CH32V 全程开启硬件压栈** 。该技术为纯软件实现，不依赖特定硬件（0x804->bit5），V103、203 等皆可完美支持。
+
+### 移植流程
+**Cube安装方式：** <br>
+**1、裸机工程** 先准备好项目的裸机工程。<br>
+**2、升级安装** 运行 CosyOS-III Cube.exe，把 裸机工程 升级为 CosyOS工程。<br>
+**3、系统构建** 打开工程，参照 CosyOS-例程（系统构建）> readme.txt 中的说明，完成系统构建。<br>
+
+**手动移植方式：** <br>
+RISC-V32 暂不支持 Cube安装，只能自行手动移植，移植可参考 Demo-Build/RISC-V32/readme.txt 中的说明，如移植过程中遇到问题可加入社区获取工程模板和技术支持。
 
 ### 序言
 * 近年来，随着RTOS的普及及在嵌入式设备中的广泛应用，以关闭总中断等方式来保护临界段所带来的危害性（丢失响应、处理延误）正日益凸显出来，其中以高速通讯接收丢帧、高速捕获丢失脉冲等中断丢失响应现象最为紧要和普遍。有些RTOS关闭总中断可能过于频繁，且未能提供“系统最大关闭总中断时间”等核心关键参数，实时性有待商榷。<br>
@@ -100,17 +99,19 @@ dCreateTask(task_3, 3, 384, 9, "task_key")
 # 启动钩子
 void start_hook(void)
 {
+//  uScheduleLock();            // 如果不想在启动任务过程中进行任务调度，可开启调度锁。
     uStartTask_Ready  (task_1); // 启动 task_1，初始状态为就绪状态
     uStartTask_Block  (task_2); // 启动 task_2，初始状态为阻塞状态（阻塞类型为延时阻塞，延时时间为无限长）
     uStartTask_Suspend(task_3); // 启动 task_3，初始状态为挂起状态
+//  uScheduleUnlock();
 }
 ```
 
 您有没有眼前一亮呢？CosyOS创建任务竟如此简单，通过调用API并输入各项参数，而后直接写任务代码即可。下一步就是在启动钩子中启动任务，任务便可参与调度并运行了。 _**任务静态创建与动态创建的相互转换也极为便利，API名称中，仅需 “u”改“d” 或 “d”改“u” 即可。**_ 
 
 ### 突破创新
-* 所有支持内核均可实现全局不关总中断、**零中断延迟**，从系统层面保证了用户中断的实时响应
-* 领先的零中断延迟技术，率先应用于8051、Cortex-M0等处理器，在世界上可能尚属首例
+* 所有支持内核均可实现 **全局不关总中断、零中断延迟**，从系统层面保证了用户中断的实时响应
+* 领先的零中断延迟技术，率先应用于 8051、Cortex-M0 等处理器，在世界上可能尚属首例
 * **任务就绪表**，采用 零/一/二级位图，保证了抢占式任务调度的硬实时性
 * **三维链表**技术，可显著的减少操作链表，服务的执行速度更快
 * 创新的**协作式调度**，协作仅作用于相同优先级的任务，具有高度的实用价值
@@ -130,8 +131,8 @@ void start_hook(void)
 ![任务管理器](images/taskmgr.png "任务管理器")<br>
 -—————— CosyOS-III 任务管理器 ——————-
 
-### 支持内核
-CosyOS 现支持 8051、80251、Cortex-M 等内核，未来会陆续添加对其它内核的支持。<br>
+### 支持架构
+CosyOS 现支持 8051、80251、Cortex-M、RISC-V32 等架构，未来会陆续添加对其它架构的支持。<br>
 
 ### 编译环境
 CosyOS 现支持 keil C51、C251、MDK-Arm（AC5、AC6），GCC-Arm，IAR-EWARM 等主流编译器，<br>
@@ -148,7 +149,9 @@ CosyOS 现支持 keil C51、C251、MDK-Arm（AC5、AC6），GCC-Arm，IAR-EWARM
 |  **Demo-Service**  |  **例程文件** <br>例程文件 for 服务应用 <br> _不会通过安装程序添加到工程中，用户需自行查阅。_ |
 
 ### 文档中心
-#### [API用户参考手册](https://gitee.com/cosyos/cosyos/blob/master/%E8%AF%B4%E6%98%8E%E6%96%87%E6%A1%A3/CosyOS-III%20API%E7%94%A8%E6%88%B7%E5%8F%82%E8%80%83%E6%89%8B%E5%86%8C%20V2.0.0.chm)
+#### [API用户参考手册](https://gitee.com/cosyos/cosyos/blob/master/CosyOS-III%20API%E7%94%A8%E6%88%B7%E5%8F%82%E8%80%83%E6%89%8B%E5%86%8C%20v3.0.0.chm)
+
+ **[CosyOS官网](https://www.cosyos.com/)** 为大家提供了丰富的说明文档，包括 内核原理、开发指南、注意事项、疑难解答 等，可前往查阅。
 
 ### 参与贡献
 

System/CosyOS.H

@@ -4,13 +4,15 @@
  * @brief    系统链接头文件
  * @details  用户的各个c文件中应包含此文件。
  * @author   迟凯峰
- * @version  V2.3.1
- * @date     2026.03.01
+ * @version  v3.0.8
+ * @date     2026.08.15
  ******************************************************************************/
 
 #ifndef __COSYOS_H
 #define __COSYOS_H
 
+#define COSYOS3_VERSION "v3.0.8"
+
 #include "os_var.h"
 #include "os_api.h"
 #include "sv_com.h"
@@ -20,9 +22,8 @@
 #include "sv_pend.h"
 #include "sv_task.h"
 #include "sv_tick.h"
-#include "ur_api.h"
 #include "ur_eapi.h"
-
+#include "ur_api.h"
 
 
 #endif

System/os_api.h

@@ -3,8 +3,8 @@
  * @file     os_api.h
  * @brief    系统内核专用API
  * @author   迟凯峰
- * @version  V2.3.1
- * @date     2026.03.01
+ * @version  v3.0.0
+ * @date     2026.07.21
  ******************************************************************************/
 
 #ifndef __OS_API_H
@@ -33,27 +33,27 @@
 
 /** 启动定时中断任务 */
 #define sStartTask_TimInt(tmid) \
-	sUSV_StartTask_0(s_timint_handle[tmid]->hookorhand.hand, OS_STATUS_SUSPENDED)
+	sUSV_StartTask_0(s_timint_handle[tmid]->hookorload.load, OS_STATUS_SUSPENDED)
 
 /** 启动定时查询任务 */
 #define sStartTask_TimQry(tmid) \
-	sUSV_StartTask_0(s_timqry_handle[tmid]->hookorhand.hand, OS_STATUS_SUSPENDED)
+	sUSV_StartTask_0(s_timqry_handle[tmid]->hookorload.load, OS_STATUS_SUSPENDED)
 
 /** 恢复定时中断任务 */
 #define sResumeTask_TimInt(tmid) \
-	sTSV_ResumeTask(*(s_timint_handle[tmid]->hookorhand.hand)->dualhandle)
+	sTSV_ResumeTask(*(s_timint_handle[tmid]->hookorload.load)->h2task)
 
 /** 恢复定时查询任务 */
 #define sResumeTask_TimQry(tmid) \
-	sTSV_ResumeTask(*(s_timqry_handle[tmid]->hookorhand.hand)->dualhandle)
+	sTSV_ResumeTask(*(s_timqry_handle[tmid]->hookorload.load)->h2task)
 
 /** 调用定时中断钩子 */
 #define sCallHook_TimInt(tmid) \
-	(*s_timint_handle[tmid]->hookorhand.hook)()
+	(*s_timint_handle[tmid]->hookorload.hook)()
 
 /** 调用定时查询钩子 */
 #define sCallHook_TimQry(tmid) \
-	(*s_timqry_handle[tmid]->hookorhand.hook)()
+	(*s_timqry_handle[tmid]->hookorload.hook)()
 
 
 /*
@@ -220,7 +220,7 @@ sTaskMsg_Init_7(g); \
 tm8##g = tm8_##g
 
 #define sTaskMsg_Init(n) \
-static volatile s_u8_t u_tmrf = 0; \
+static s_u8_t volatile u_tmrf = 0; \
 if(s_taskmsg_sign){ \
 	u_tmrf = 1; \
 	sTaskMsg_Init_##n(_); \

System/os_base.h

@@ -1,22 +0,0 @@
-/**************************************************************************//**
- * @item     CosyOS-III Kernel
- * @file     os_base.h
- * @brief    基本数据类型定义
- * @author   迟凯峰
- * @version  V2.3.0
- * @date     2026.02.01
- ******************************************************************************/
-
-#ifndef __OS_BASE_H
-#define __OS_BASE_H
-
-typedef char  s_s8_t;
-typedef short s_s16_t;
-typedef long  s_s32_t;
-typedef unsigned char  s_u8_t;
-typedef unsigned short s_u16_t;
-typedef unsigned long  s_u32_t;
-typedef s_u8_t s_ecode_t; /*!< 错误码类型 */
-
-
-#endif

System/os_cmsis.h

@@ -1,19 +1,63 @@
 /**************************************************************************//**
- * @item     CosyOS-III Port
- * @file     cmsis_specific.h
+ * @item     CosyOS-III Kernel
+ * @file     os_cmsis.h
  * @brief    CMSIS compiler specific defines
  * @author   迟凯峰
- * @version  V2.0.0
- * @date     2025.08.04
+ * @version  v3.0.0
+ * @date     2026.07.21
  ******************************************************************************/
 
-#ifndef __CMSIS_SPECIFIC_H
-#define __CMSIS_SPECIFIC_H
+#ifndef __OS_CMSIS_H
+#define __OS_CMSIS_H
+
+/*
+ * Keil C51
+ */
+#if   defined ( __C51__ )
+
+  #ifndef   __WEAK
+    #define __WEAK
+  #endif
+  #ifndef   __NOP
+    #define __NOP _nop_
+  #endif
+  #ifndef   __STATIC_FORCEINLINE
+    #define __STATIC_FORCEINLINE static
+  #endif
+  #ifndef   __NOINLINE
+    #define __NOINLINE
+  #endif
+  #ifndef   __UNUSED
+    #define __UNUSED(X) X = X
+  #endif
+
+
+/*
+ * Keil C251
+ */
+#elif defined ( __C251__ )
+
+  #ifndef   __WEAK
+    #define __WEAK
+  #endif
+  #ifndef   __NOP
+    #define __NOP _nop_
+  #endif
+  #ifndef   __STATIC_FORCEINLINE
+    #define __STATIC_FORCEINLINE static
+  #endif
+  #ifndef   __NOINLINE
+    #define __NOINLINE
+  #endif
+  #ifndef   __UNUSED
+    #define __UNUSED(X) void *p_##X = (void *)X
+  #endif
+
 
 /*
  * Arm Compiler 4/5
  */
-#if   defined ( __CC_ARM )
+#elif defined ( __CC_ARM )
 
   #ifndef   __ASM
     #define __ASM                                  __asm
@@ -36,7 +80,9 @@
   #ifndef   __NOINLINE
     #define __NOINLINE                             __attribute__((noinline))
   #endif
+  #ifndef   __UNUSED
     #define __UNUSED(X)                            (void)X
+  #endif
 
 
 /*
@@ -65,7 +111,9 @@
   #ifndef   __NOINLINE
     #define __NOINLINE                             __attribute__((noinline))
   #endif
+  #ifndef   __UNUSED
     #define __UNUSED(X)                            (void)X
+  #endif
 
 
 /*
@@ -94,7 +142,9 @@
   #ifndef   __NOINLINE
     #define __NOINLINE                             __attribute__((noinline))
   #endif
+  #ifndef   __UNUSED
     #define __UNUSED(X)                            (void)X
+  #endif
 
 
 /*
@@ -135,7 +185,9 @@
   #ifndef   __NOINLINE
     #define __NOINLINE                             //_Pragma("optimize = no_inline")
   #endif
+  #ifndef   __UNUSED
     #define __UNUSED(X)                            (void)X
+  #endif
 
 
 /*

System/os_debug.c

@@ -4,8 +4,8 @@
  * @brief    DEBUG接口
  * @details  DEBUG接口，串口发送和接收解析。
  * @author   迟凯峰
- * @version  V2.3.2
- * @date     2026.03.08
+ * @version  v3.0.0
+ * @date     2026.07.21
  ******************************************************************************/
 
 #include "os_var.h"
@@ -24,7 +24,7 @@
  \note       Keil C51/C251 标准库中的 atoi() 是非线程安全的，故额外定义此函数，
              专用于DEBUG接口的串口接收解析。
  */
-static int _atoi_(const char* str)
+static int _atoi_(char const *str)
 {
 	if(str == OS_NULL || !*str){
 		return 0;

System/os_def.h

@@ -3,8 +3,8 @@
  * @file     os_def.h
  * @brief    初始宏定义
  * @author   迟凯峰
- * @version  V2.3.0
- * @date     2026.02.18
+ * @version  v3.0.0
+ * @date     2026.07.21
  ******************************************************************************/
 
 #ifndef __OS_DEF_H
@@ -33,8 +33,7 @@
 
 #define true     1
 #define false    0
-#define OS_NULL  0 /*!< 通用的空指针 */
-#define OS_VOID  ((s_tasknode_tsp)~0) /*!< 专用的空指针，超时链表专用。*/
+#define OS_NULL  0
 
 
 /*
@@ -52,6 +51,9 @@
 #define __ARM__            2 /*!< 指令集架构：ARM ...... */
 #define __COOPERATIVE__    1 /*!< 协作式调度............ */
 #define __TIMESHARING__    2 /*!< 时间片轮转调度........ */
+#define __MSP__            0x01
+#define __PSP__            0x02
+#define __MSP_PSP__        (__MSP__ | __PSP__)
 
 
 /*
@@ -100,45 +102,51 @@
  * SVID（服务ID，中断FIFO服务-系统专用ID）
  */
 
-#define OS_SVID_CLEARDELAY   0x00
-#define OS_SVID_RESUMETASK   0x01
-#define OS_SVID_SUSPENDTASK  0x02
-#define OS_SVID_DELETETASK   0x03
-#define OS_SVID_CLEARBLOCK   0x04
-#define OS_SVID_SETBLOCK     0x05
-#define OS_SVID_SETTASKPRI   0x06
-#define OS_SVID_WRITEBINARY  0x07
-#define OS_SVID_GIVESEMAPH   0x08
-#define OS_SVID_SENDFETION   0x09
-#define OS_SVID_SENDMAIL     0x0A
-#define OS_SVID_SENDMSG      0x0B
-#define OS_SVID_TIMINT       0x0C
-#define OS_SVID_TIMQRY       0x0D
-#define OS_SVID_WRITEGROUP   0x0E
-#define OS_SVID_WRITEGVAR    0x0F
-#define OS_SVID_PENDSVC      0x10
-#define OS_SVID_END          0x11
+#define OS_SVID_CLEARDELAY   0x00 /*!< 清除就绪延时 ....... */
+#define OS_SVID_RESUMETASK   0x01 /*!< 恢复任务 ........... */
+#define OS_SVID_SUSPENDTASK  0x02 /*!< 挂起任务 ........... */
+#define OS_SVID_DELETETASK   0x03 /*!< 删除任务 ........... */
+#define OS_SVID_RESETTASK    0x04 /*!< 重置任务 ........... */
+#define OS_SVID_CLEARBLOCK   0x05 /*!< 清除阻塞 ........... */
+#define OS_SVID_SETBLOCK     0x06 /*!< 设置阻塞 ........... */
+#define OS_SVID_SETTASKPRI   0x07 /*!< 设置任务优先级 ..... */
+#define OS_SVID_WRITEBINARY  0x08 /*!< 写二值信号量 ....... */
+#define OS_SVID_GIVESEMAPH   0x09 /*!< 给予计数信号量 ..... */
+#define OS_SVID_SENDFETION   0x0A /*!< 发送飞信 ........... */
+#define OS_SVID_SENDMAIL     0x0B /*!< 发送邮件 ........... */
+#define OS_SVID_SENDMSG      0x0C /*!< 发送消息 ........... */
+#define OS_SVID_TIMINT       0x0D /*!< 定时中断 ........... */
+#define OS_SVID_TIMQRY       0x0E /*!< 定时查询 ........... */
+#define OS_SVID_WRITEGROUP   0x0F /*!< 写标志组 ........... */
+#define OS_SVID_WRITEGVAR    0x10 /*!< 写全局变量 ......... */
+#define OS_SVID_PENDSVC      0x11 /*!< 挂起服务调用 ....... */
+#define OS_SVID_END          0x12
 
 
 /*
  * ECODE（错误码）
  */
 
-#define OS_ECODE_NOERROR               0 /*!< 无错误 ............. */
-#define OS_ECODE_OVERFLOW_MSGQUEUE     1 /*!< 消息队列溢出 ....... */
-#define OS_ECODE_OVERFLOW_TASKQUEUE    2 /*!< 任务队列溢出 ....... */
-#define OS_ECODE_OVERFLOW_TASKSTACK    3 /*!< 任务栈溢出 ......... */
-#define OS_ECODE_MALLOCFAIL_MSGNODE    4 /*!< 消息节点内存分配失败 */
-#define OS_ECODE_MALLOCFAIL_TASKNODE   5 /*!< 任务节点内存分配失败 */
-#define OS_ECODE_MALLOCFAIL_TASKSTACK  6 /*!< 任务栈内存分配失败 . */
-#define OS_ECODE_TASKSUSPENDED         7 /*!< 任务已挂起 ......... */
-#define OS_ECODE_TASKSTOPPED           8 /*!< 任务已停止 ......... */
-#define OS_ECODE_TASKNOTSTARTED        9 /*!< 任务未启动/已删除 .. */
-#define OS_ECODE_TASKNOTREADY         10 /*!< 任务未就绪 ......... */
-#define OS_ECODE_TASKNOTBLOCKED       11 /*!< 任务未阻塞 ......... */
-#define OS_ECODE_TASKNOTSUSPENDED     12 /*!< 任务未挂起 ......... */
-#define OS_ECODE_TASKPRIUNCHANGED     13 /*!< 任务优先级未改变 ... */
-#define OS_ECODE_DONOTKNOW           255 /*!< 未知错误 ........... */
+#define OS_ECODE_NOERROR               0x00 /*!< 无错误 ............. */
+
+#define OS_ECODE_TASKSTARTED           0x0D /*!< 任务已启动 ......... */
+#define OS_ECODE_TASKSUSPENDED         0x0E /*!< 任务已挂起 ......... */
+#define OS_ECODE_TASKSTOPPED           0x0F /*!< 任务已停止 ......... */
+#define OS_ECODE_TASKDELETED           0x10 /*!< 任务已删除 ......... */
+#define OS_ECODE_TASKNOTSTARTED        0x10 /*!< 任务未启动 ......... */
+#define OS_ECODE_TASKNOTBLOCKED        0x11 /*!< 任务未阻塞 ......... */
+#define OS_ECODE_TASKNOTSUSPENDED      0x12 /*!< 任务未挂起 ......... */
+#define OS_ECODE_TASKPRIUNCHANGED      0x13 /*!< 任务优先级未改变 ... */
+
+#define OS_ECODE_OVERFLOW_MSGQUEUE     0x21 /*!< 消息队列溢出 ....... */
+#define OS_ECODE_OVERFLOW_TASKQUEUE    0x22 /*!< 任务队列溢出 ....... */
+#define OS_ECODE_OVERFLOW_TASKSTACK    0x23 /*!< 任务栈溢出 ......... */
+
+#define OS_ECODE_MALLOCFAIL_MSGNODE    0x31 /*!< 消息节点内存分配失败 */
+#define OS_ECODE_MALLOCFAIL_TASKNODE   0x32 /*!< 任务节点内存分配失败 */
+#define OS_ECODE_MALLOCFAIL_TASKSTACK  0x33 /*!< 任务栈内存分配失败 . */
+
+#define OS_ECODE_DONOTKNOW             0xFF /*!< 未知错误 ........... */
 
 
 

System/os_main.c

@@ -3,8 +3,8 @@
  * @file     os_main.c
  * @brief    启动-CosyOS
  * @author   迟凯峰
- * @version  V2.3.0
- * @date     2026.02.01
+ * @version  v3.0.0
+ * @date     2026.07.21
  ******************************************************************************/
 
 #include "os_var.h"

System/os_stack.c

@@ -0,0 +1,99 @@
+/**************************************************************************//**
+ * @item     CosyOS-III Kernel
+ * @file     os_stack.c
+ * @brief    main stack and task stack check
+ * @author   迟凯峰
+ * @version  v3.0.0
+ * @date     2026.07.21
+ ******************************************************************************/
+
+#include "os_stack.h"
+
+#if (SYSCFG_DEBUGGING == __ENABLED__)
+
+#include <string.h>
+
+#if   defined ( __C51__ )
+#define STACK_TYPE  1 // 满增栈
+static s_u8_t const stack_data[ 8] = {"CosyOS51"};
+
+#elif defined ( __C251__ )
+#define STACK_TYPE  1 // 满增栈
+static s_u8_t const stack_data[16] = {"CosyOS for 80251"};
+
+#else
+#define STACK_TYPE  2 // 满减栈
+static s_u8_t const stack_data[32] = {"CosyOS is an RTOS come on China."};
+#endif
+
+/**
+ \brief      栈检查初始化
+ \param[in]  addr      栈的初始安装指针
+ \param[in]  size      栈的大小
+ \return     无
+ */
+void s_stack_check_init(STACK_ADDR_T addr, STACK_SIZE_T size)
+{
+	STACK_SIZE_T i;
+	STACK_SIZE_T c = size / sizeof(stack_data);
+	
+	#if   ( STACK_TYPE == 1 )
+	STACK_ADDR_T p = addr + size - sizeof(stack_data);
+	
+	#elif ( STACK_TYPE == 2 )
+	STACK_ADDR_T p = addr - size;
+	#endif
+	
+	for(i = 0; i < c; i++){
+		memcpy(p, stack_data, sizeof(stack_data));
+		
+		#if   ( STACK_TYPE == 1 )
+		p -= sizeof(stack_data);
+		
+		#elif ( STACK_TYPE == 2 )
+		p += sizeof(stack_data);
+		#endif
+	}
+}
+
+/**
+ \brief      栈检查
+ \param[in]  addr      栈的初始安装指针
+ \param[in]  size      栈的大小
+ \return     栈用量
+ */
+STACK_SIZE_T s_stack_check(STACK_ADDR_T addr, STACK_SIZE_T size)
+{
+	STACK_SIZE_T i;
+	STACK_SIZE_T c = size / sizeof(stack_data);
+	
+	#if   ( STACK_TYPE == 1 )
+	STACK_ADDR_T p = addr + size - sizeof(stack_data);
+	
+	#elif ( STACK_TYPE == 2 )
+	STACK_ADDR_T p = addr - size;
+	#endif
+	
+	for(i = 0; i < c; i++){
+		if(!memcmp(p, stack_data, sizeof(stack_data))){
+			
+			#if   ( STACK_TYPE == 1 )
+			p -= sizeof(stack_data);
+			
+			#elif ( STACK_TYPE == 2 )
+			p += sizeof(stack_data);
+			#endif
+		}
+		else{
+			break;
+		}
+	}
+	#if   ( STACK_TYPE == 1 )
+	return (STACK_SIZE_T)(p - addr) + sizeof(stack_data);
+	
+	#elif ( STACK_TYPE == 2 )
+	return (STACK_SIZE_T)(addr - p);
+	#endif
+}
+
+#endif

System/os_stack.h

@@ -0,0 +1,33 @@
+/**************************************************************************//**
+ * @item     CosyOS-III Kernel
+ * @file     os_stack.h
+ * @brief    main stack and task stack check
+ * @author   迟凯峰
+ * @version  v3.0.0
+ * @date     2026.07.21
+ ******************************************************************************/
+
+#ifndef __OS_STACK_H
+#define __OS_STACK_H
+
+#include "os_redef.h"
+
+#if   defined ( __C51__ )
+typedef s_u8_t  idata *STACK_ADDR_T;
+typedef s_u8_t  STACK_SIZE_T;
+
+#elif defined ( __C251__ )
+typedef s_u8_t  edata *STACK_ADDR_T;
+typedef s_u16_t STACK_SIZE_T;
+
+#else
+typedef s_u8_t *STACK_ADDR_T;
+typedef s_u32_t STACK_SIZE_T;
+#endif
+
+
+        void s_stack_check_init(STACK_ADDR_T addr, STACK_SIZE_T size);
+STACK_SIZE_T s_stack_check     (STACK_ADDR_T addr, STACK_SIZE_T size);
+
+
+#endif

System/os_starter.c

@@ -3,8 +3,8 @@
  * @file     os_starter.c
  * @brief    任务启动器（Starter）
  * @author   迟凯峰
- * @version  V2.3.2
- * @date     2026.03.08
+ * @version  v3.0.0
+ * @date     2026.07.21
  ******************************************************************************/
 
 #include "os_var.h"

System/os_sysidle.c

@@ -3,8 +3,8 @@
  * @file     os_sysidle.c
  * @brief    系统空闲任务（Sysidle）
  * @author   迟凯峰
- * @version  V2.3.2
- * @date     2026.03.08
+ * @version  v3.0.0
+ * @date     2026.07.21
  ******************************************************************************/
 
 #include "os_var.h"
@@ -46,6 +46,14 @@ uCreateTask(Sysidle, 0, SYSCFG_STACKSIZE_SYSIDLE, 0, _taskname)
 		#if (SYSCFG_IDLEHOOK == __ENABLED__)
 		idle_hook();
 		#endif
+		#if (SYSCFG_DEBUGGING == __ENABLED__) && (MCUCFG_TASKSTACK_MODE & __MSP__)
+		if(true){
+			m_stacklen_t len = mMainStack_Check();
+			if(m_stacklen_max < len){
+				m_stacklen_max = len;
+			}
+		}
+		#endif
 		#if (SYSCFG_LOWPOWERMODE == __ENABLED__)
 		mCosyOS_IDLE();
 		#endif

System/os_timing.c

@@ -3,8 +3,8 @@
  * @file     os_timing.c
  * @brief    初始化定时中断、定时查询
  * @author   迟凯峰
- * @version  V2.3.0
- * @date     2026.02.01
+ * @version  v3.0.0
+ * @date     2026.07.21
  ******************************************************************************/
 
 #include "os_var.h"

System/os_var.c

@@ -3,85 +3,83 @@
  * @file     os_var.c
  * @brief    系统全局变量定义
  * @author   迟凯峰
- * @version  V2.3.0
- * @date     2026.02.01
+ * @version  v3.0.0
+ * @date     2026.07.21
  ******************************************************************************/
 
 #include "os_redef.h"
 
 /* The Soft-RTC */
 #if (SYSCFG_SOFTRTC == __ENABLED__)
-const     s_u8_t             _CONST_MEM_   s_month0day[13] = {31, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; /*!< 每月各有几天？*/
-          s_u8_t               _RTC_MEM_   s_month2day = 28;                      /*!< 二月有几天？*/
-          s_every_ts           _SYS_MEM_   s_sign_every/**/sZeroInstall_Group;    /*!< 每信号 */
-          m_rtccount_t         _SYS_MEM_   s_rtc_counter/**/sZeroInstall;         /*!< RTC计数器 */
-          s_rtc_ts             _RTC_MEM_   s_rtc = {SYSCFG_MANUFACTUREDATE};      /*!< RTC */
+s_u8_t          const _CONST_MEM_   s_month0day[13] = {31, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; /*!< 每月各有几天？*/
+s_u8_t                  _RTC_MEM_   s_month2day = 28;                      /*!< 二月有几天？*/
+s_every_ts              _SYS_MEM_   s_sign_every/**/sZeroInstall_Group;    /*!< 每信号 */
+m_rtccount_t            _SYS_MEM_   s_rtc_counter/**/sZeroInstall;         /*!< RTC计数器 */
+s_rtc_ts                _RTC_MEM_   s_rtc = {SYSCFG_MANUFACTUREDATE};      /*!< RTC */
 #endif
 /* The Task */
-volatile  m_bit_t            /*_SYS_MEM_*/ s_sign_startup = true;
-volatile  s_schesign_tu        _SYS_MEM_   s_sign_schedule = {{0, 1}};            /*!< 调度信号 */
-volatile  m_bit_t            /*_SYS_MEM_*/ s_sign_delay/**/sZeroInstall;          /*!< 就绪延时信号 */
-          s_u8_t               _SYS_MEM_   s_schedulelock_counter/**/sZeroInstall;/*!< 调度锁嵌套计数器 */
-          s_ecode_t            _SYS_MEM_   s_startup_ecode = OS_ECODE_NOERROR;    /*!< 启动任务时，用来异地缓存错误码 */
-          s_u8_t               _SYS_MEM_   s_task_status0 = OS_STATUS_DELETED;    /*!< 被启动任务 -> 初始状态 */
-          s_taskhand_tsp       _SYS_MEM_   s_task_starter/**/sZeroInstall;        /*!< 被启动任务 -> 装载块句柄 */
-          s_tasknode_tsp       _SYS_MEM_   s_task_current/**/sZeroInstall;        /*!< 当前任务句柄 */
-          s_tasknode_tsp                   s_timer_list[OS_TIMESLOTNUM]/**/sZeroInstall_Group; /*!< 定时器链表 */
-          s_u8_t               _SYS_MEM_   s_timer_pointer = OS_TIMESLOTNUM - 1UL;
+m_bit_t       volatile/*_SYS_MEM_*/ s_sign_startup = true;
+s_schesign_tu volatile  _SYS_MEM_   s_sign_schedule = {{0, 1}};            /*!< 调度信号 */
+m_bit_t       volatile/*_SYS_MEM_*/ s_sign_delay/**/sZeroInstall;          /*!< 就绪延时信号 */
+s_u8_t                  _SYS_MEM_   s_schedulelock_counter/**/sZeroInstall;/*!< 调度锁嵌套计数器 */
+s_taskstart_ts			_SYS_MEM_   s_task_starter/**/sZeroInstall_Group;  /*!< 任务启动器 */
+s_taskctrl_tsp          _SYS_MEM_   s_task_current/**/sZeroInstall;        /*!< 当前任务句柄 */
+s_taskctrl_tsp                      s_timer_list[OS_TIMESLOTNUM]/**/sZeroInstall_Group; /*!< 定时器链表 */
+s_u8_t                  _SYS_MEM_   s_timer_pointer = OS_TIMESLOTNUM - 1UL;
 #if (SYSCFG_SAMEPRISCHEDULE == __TIMESHARING__ && SYSCFG_TIMESHARINGMODE == 2)
-const     s_sharing_t        _CONST_MEM_   s_time_sharing[SYSCFG_TASKPRIORITY] = {SYSCFG_CUSTOMTIMESHARING}; /*!< 自定义时间片 -> 时间片数组 */
+s_sharing_t     const _CONST_MEM_   s_time_sharing[SYSCFG_TASKPRIORITY] = {SYSCFG_CUSTOMTIMESHARING}; /*!< 自定义时间片 -> 时间片数组 */
 #endif
 #if (SYSCFG_KERNELLOCKNESTING == __ENABLED__)
-          s_u8_t               _SYS_MEM_   s_kernellock_counter/**/sZeroInstall;  /*!< 内核锁嵌套计数器 */
+s_u8_t                  _SYS_MEM_   s_kernellock_counter/**/sZeroInstall;  /*!< 内核锁嵌套计数器 */
 #endif
 /* The Safe runtime */
 #if (SYSCFG_SAFERUNTIME == __ENABLED__)
-          m_bit_t            /*_SYS_MEM_*/ s_timeout_sign/**/sZeroInstall;        /*!< 超时信号 */
-          s_tasknode_tsp       _SYS_MEM_   s_timeout_list = OS_VOID;              /*!< 超时链表 */
+m_bit_t               /*_SYS_MEM_*/ s_timeout_sign/**/sZeroInstall;        /*!< 超时信号 */
+s_taskctrl_tsp       _STATIC_MEM_   s_timeout_list/**/sZeroInstall;        /*!< 超时链表 */
 #endif
 /* The Timing Interrupt */
 #if (OS_TIMINTTOTAL > 0)
-          s_timinthand_tsp                 s_timint_handle[OS_TIMINTTOTAL];       /*!< 定时中断句柄 */
+s_timinthand_tsp                    s_timint_handle[OS_TIMINTTOTAL];       /*!< 定时中断句柄 */
 #endif
 /* The Timing Query */
 #if (OS_TIMQRYTOTAL > 0)
-          s_timqryhand_tsp                 s_timqry_handle[OS_TIMQRYTOTAL];       /*!< 定时查询句柄 */
+s_timqryhand_tsp                    s_timqry_handle[OS_TIMQRYTOTAL];       /*!< 定时查询句柄 */
 #endif
 /* The Task Message */
 #if (SYSCFG_TASKMSG == __ENABLED__)
-volatile  s_u8_t             /*_SYS_MEM_*/ s_taskmsg_sign/**/sZeroInstall;        /*!< 发送私信信号 */
+s_u8_t        volatile  _SYS_MEM_   s_taskmsg_sign/**/sZeroInstall;        /*!< 发送私信信号 */
 #endif
 /* The Debug Interface */
 #if (SYSCFG_DEBUGGING == __ENABLED__)
-          m_bit_t            /*_SYS_MEM_*/ s_debug_sendsign/**/sZeroInstall;
-          s_u8_t               _SYS_MEM_   s_debug_sendtype/**/sZeroInstall;
-          s_u8_t               _SYS_MEM_   s_debug_recvlen/**/sZeroInstall;
-          char *             _XDATA_MEM_   s_debug_recvptr;/*
-          char               _XDATA_MEM_   s_cmdline_sendbuff[OS_CMDLINESENDBUFFSIZE];
+m_bit_t               /*_SYS_MEM_*/ s_debug_sendsign/**/sZeroInstall;
+s_u8_t                  _SYS_MEM_   s_debug_sendtype/**/sZeroInstall;
+s_u8_t                  _SYS_MEM_   s_debug_recvlen/**/sZeroInstall;
+char *                _XDATA_MEM_   s_debug_recvptr;/*
+char                  _XDATA_MEM_   s_cmdline_sendbuff[OS_CMDLINESENDBUFFSIZE];
 #if (SYSCFG_DEBUG_SENDLEN == __ENABLED__)
-          s_u16_t            _XDATA_MEM_   s_cmdline_sendlen;
+s_u16_t               _XDATA_MEM_   s_cmdline_sendlen;
 #endif*/
-          m_bit_t            /*_SYS_MEM_*/ s_taskmgr_sign = SYSCFG_TASKMGR_AUTOSTART;
-          char               _XDATA_MEM_   s_taskmgr_sendbuff[OS_TASKMGRSENDBUFFSIZE];
+m_bit_t               /*_SYS_MEM_*/ s_taskmgr_sign = SYSCFG_TASKMGR_AUTOSTART;
+char                  _XDATA_MEM_   s_taskmgr_sendbuff[OS_TASKMGRSENDBUFFSIZE];
 #if (SYSCFG_DEBUG_SENDLEN == __ENABLED__)
-          s_u16_t            _XDATA_MEM_   s_taskmgr_sendlen;
+s_u16_t               _XDATA_MEM_   s_taskmgr_sendlen;
 #endif
-          s_u32_t            _DEBUG_MEM_   s_taskmgr_upspeed/**/sZeroInstall;
-          s_alarm_ts         _DEBUG_MEM_   s_alarm/**/sZeroInstall_Group;
-          s_fault_ts         _DEBUG_MEM_   s_fault/**/sZeroInstall_Group;
+s_u32_t               _DEBUG_MEM_   s_taskmgr_upspeed/**/sZeroInstall;
+s_alarm_ts            _DEBUG_MEM_   s_alarm/**/sZeroInstall_Group;
+s_fault_ts            _DEBUG_MEM_   s_fault/**/sZeroInstall_Group;
 #if (SYSCFG_SYSTICKTIME_COUNT == __ENABLED__)
-          s_u32_t            _DEBUG_MEM_   s_tick_count1/**/sZeroInstall;
-          s_u32_t            _DEBUG_MEM_   s_tick_count2/**/sZeroInstall;
+s_u32_t               _DEBUG_MEM_   s_tick_count1/**/sZeroInstall;
+s_u32_t               _DEBUG_MEM_   s_tick_count2/**/sZeroInstall;
 #endif
 #if (SYSCFG_TASKPC_MONITOR == __ENABLED__)
-          m_pc_t               _SYS_MEM_   s_pc/**/sZeroInstall;
+m_pc_t                  _SYS_MEM_   s_pc/**/sZeroInstall;
 #endif
 #if (SYSCFG_RUNTIME_COUNT == __ENABLED__)
-          s_runtime_ts       _DEBUG_MEM_   s_runtime/**/sZeroInstall_Group;
+s_runtime_ts          _DEBUG_MEM_   s_runtime/**/sZeroInstall_Group;
 #endif
 #endif
 /* The Task */
-const s_u8_t _CONST_MEM_ s_task_pickmap[SYSCFG_TASKPICKBITMAP * 128] =
+s_u8_t const _CONST_MEM_ s_task_pickmap[SYSCFG_TASKPICKBITMAP * 128] =
 {
 	#if   (SYSCFG_TASKPICKBITMAP == 1)
      /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F */
@@ -113,7 +111,7 @@ const s_u8_t _CONST_MEM_ s_task_pickmap[SYSCFG_TASKPICKBITMAP * 128] =
 /* F */ 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7
 	#endif
 }; /*!< Task pick bitmap */
-s_tasknode_tsp _QUE_MEM_ s_task_queue[SYSCFG_TASKPRIORITY]/**/sZeroInstall_Group; /*!< 任务队列 */
+s_taskctrl_tsp _QUE_MEM_ s_task_queue[SYSCFG_TASKPRIORITY]/**/sZeroInstall_Group; /*!< 任务队列 */
 m_tqcount_t    _QUE_MEM_ s_task_queue_count/**/sZeroInstall;
 #if   (SYSCFG_TASKPRIORITY > 64)
 s_u8_t _QUE_MEM_ s_task_table_index/**/sZeroInstall; /*!< 任务表索引 */
@@ -130,6 +128,6 @@ s_u8_t _QUE_MEM_ s_task_ready_count[SYSCFG_TASKPRIORITY]/**/sZeroInstall_Group;
 #elif (SYSCFG_MUTEX == __ENABLED__)
 s_u8_t _SYS_MEM_ s_taskpri_ceiling = SYSCFG_BASEPRI_CEILING; /*!< 天花板优先级 */
 #endif
-#if (MCUCFG_PENDSVFIFO_DEPTH > 0 && SYSCFG_PENDSVFIFO_ERRORCALLBACK == __ENABLED__)
+#if (SYSCFG_PENDSVFIFO_DEPTH > 0 && SYSCFG_PENDSVFIFO_ERRORCALLBACK == __ENABLED__)
 s_ecode_t _SYS_MEM_ s_psvfifo_ecode; /*!< 中断挂起服务_FIFO-错误调用返回.错误码 */
 #endif

System/os_var.h

@@ -3,8 +3,8 @@
  * @file     os_var.h
  * @brief    系统全局变量声明
  * @author   迟凯峰
- * @version  V2.3.0
- * @date     2026.02.01
+ * @version  v3.0.0
+ * @date     2026.07.21
  ******************************************************************************/
 
 #ifndef __OS_VAR_H
@@ -13,78 +13,76 @@
 
 /* The Soft-RTC */
 #if (SYSCFG_SOFTRTC == __ENABLED__)
-extern  const     s_u8_t             _CONST_MEM_   s_month0day[13];
-extern            s_u8_t               _RTC_MEM_   s_month2day;
-extern            s_every_ts           _SYS_MEM_   s_sign_every;
-extern            m_rtccount_t         _SYS_MEM_   s_rtc_counter;
-extern            s_rtc_ts             _RTC_MEM_   s_rtc;
+extern  s_u8_t          const _CONST_MEM_   s_month0day[13];
+extern  s_u8_t                  _RTC_MEM_   s_month2day;
+extern  s_every_ts              _SYS_MEM_   s_sign_every;
+extern  m_rtccount_t            _SYS_MEM_   s_rtc_counter;
+extern  s_rtc_ts                _RTC_MEM_   s_rtc;
 #endif
 /* The Task */
-extern  volatile  m_bit_t            /*_SYS_MEM_*/ s_sign_startup;
-extern  volatile  s_schesign_tu        _SYS_MEM_   s_sign_schedule;
-extern  volatile  m_bit_t            /*_SYS_MEM_*/ s_sign_delay;
-extern            s_u8_t               _SYS_MEM_   s_schedulelock_counter;
-extern            s_ecode_t            _SYS_MEM_   s_startup_ecode;
-extern            s_u8_t               _SYS_MEM_   s_task_status0;
-extern            s_taskhand_tsp       _SYS_MEM_   s_task_starter;
-extern            s_tasknode_tsp       _SYS_MEM_   s_task_current;
-extern            s_tasknode_tsp                   s_timer_list[OS_TIMESLOTNUM];
-extern            s_u8_t               _SYS_MEM_   s_timer_pointer;
+extern  m_bit_t       volatile/*_SYS_MEM_*/ s_sign_startup;
+extern  s_schesign_tu volatile  _SYS_MEM_   s_sign_schedule;
+extern  m_bit_t       volatile/*_SYS_MEM_*/ s_sign_delay;
+extern  s_u8_t                  _SYS_MEM_   s_schedulelock_counter;
+extern  s_taskstart_ts			_SYS_MEM_   s_task_starter;
+extern  s_taskctrl_tsp          _SYS_MEM_   s_task_current;
+extern  s_taskctrl_tsp                      s_timer_list[OS_TIMESLOTNUM];
+extern  s_u8_t                  _SYS_MEM_   s_timer_pointer;
 #if (SYSCFG_SAMEPRISCHEDULE == __TIMESHARING__ && SYSCFG_TIMESHARINGMODE == 2)
-extern  const     s_sharing_t        _CONST_MEM_   s_time_sharing[SYSCFG_TASKPRIORITY];
+extern  s_sharing_t     const _CONST_MEM_   s_time_sharing[SYSCFG_TASKPRIORITY];
 #endif
 #if (SYSCFG_KERNELLOCKNESTING == __ENABLED__)
-extern            s_u8_t               _SYS_MEM_   s_kernellock_counter;
+extern  s_u8_t                  _SYS_MEM_   s_kernellock_counter;
 #endif
 /* The Safe runtime */
 #if (SYSCFG_SAFERUNTIME == __ENABLED__)
-extern            m_bit_t            /*_SYS_MEM_*/ s_timeout_sign;
-extern            s_tasknode_tsp       _SYS_MEM_   s_timeout_list;
+extern  m_bit_t               /*_SYS_MEM_*/ s_timeout_sign;
+extern  s_taskctrl_tsp       _STATIC_MEM_   s_timeout_list;
 #endif
 /* The Timing Interrupt */
 #if (OS_TIMINTTOTAL > 0)
-extern            s_timinthand_tsp                 s_timint_handle[OS_TIMINTTOTAL];
+extern  s_timinthand_tsp                    s_timint_handle[OS_TIMINTTOTAL];
 #endif
 /* The Timing Query */
 #if (OS_TIMQRYTOTAL > 0)
-extern            s_timqryhand_tsp                 s_timqry_handle[OS_TIMQRYTOTAL];
+extern  s_timqryhand_tsp                    s_timqry_handle[OS_TIMQRYTOTAL];
 #endif
 /* The Task Message */
 #if (SYSCFG_TASKMSG == __ENABLED__)
-extern  volatile  s_u8_t             /*_SYS_MEM_*/ s_taskmsg_sign;
+extern  s_u8_t        volatile  _SYS_MEM_   s_taskmsg_sign;
 #endif
 /* The Debug Interface */
 #if (SYSCFG_DEBUGGING == __ENABLED__)
-extern            m_bit_t            /*_SYS_MEM_*/ s_debug_sendsign;
-extern            s_u8_t               _SYS_MEM_   s_debug_sendtype;
-extern            s_u8_t               _SYS_MEM_   s_debug_recvlen;
-extern            char *             _XDATA_MEM_   s_debug_recvptr;/*
-extern            char               _XDATA_MEM_   s_cmdline_sendbuff[OS_CMDLINESENDBUFFSIZE];
+extern  m_bit_t               /*_SYS_MEM_*/ s_debug_sendsign;
+extern  s_u8_t                  _SYS_MEM_   s_debug_sendtype;
+extern  s_u8_t                  _SYS_MEM_   s_debug_recvlen;
+extern  char *                _XDATA_MEM_   s_debug_recvptr;/*
+extern  char                  _XDATA_MEM_   s_cmdline_sendbuff[OS_CMDLINESENDBUFFSIZE];
 #if (SYSCFG_DEBUG_SENDLEN == __ENABLED__)
-extern            s_u16_t            _XDATA_MEM_   s_cmdline_sendlen;
+extern  s_u16_t               _XDATA_MEM_   s_cmdline_sendlen;
 #endif*/
-extern            m_bit_t            /*_SYS_MEM_*/ s_taskmgr_sign;
-extern            char               _XDATA_MEM_   s_taskmgr_sendbuff[OS_TASKMGRSENDBUFFSIZE];
+extern  m_bit_t               /*_SYS_MEM_*/ s_taskmgr_sign;
+extern  char                  _XDATA_MEM_   s_taskmgr_sendbuff[OS_TASKMGRSENDBUFFSIZE];
 #if (SYSCFG_DEBUG_SENDLEN == __ENABLED__)
-extern            s_u16_t            _XDATA_MEM_   s_taskmgr_sendlen;
+extern  s_u16_t               _XDATA_MEM_   s_taskmgr_sendlen;
 #endif
-extern            s_u32_t            _DEBUG_MEM_   s_taskmgr_upspeed;
-extern            s_alarm_ts         _DEBUG_MEM_   s_alarm;
-extern            s_fault_ts         _DEBUG_MEM_   s_fault;
+extern  s_u32_t               _DEBUG_MEM_   s_taskmgr_upspeed;
+extern  s_alarm_ts            _DEBUG_MEM_   s_alarm;
+extern  s_fault_ts            _DEBUG_MEM_   s_fault;
 #if (SYSCFG_SYSTICKTIME_COUNT == __ENABLED__)
-extern            s_u32_t            _DEBUG_MEM_   s_tick_count1;
-extern            s_u32_t            _DEBUG_MEM_   s_tick_count2;
+extern  s_u32_t               _DEBUG_MEM_   s_tick_count1;
+extern  s_u32_t               _DEBUG_MEM_   s_tick_count2;
 #endif
 #if (SYSCFG_TASKPC_MONITOR == __ENABLED__)
-extern            m_pc_t               _SYS_MEM_   s_pc;
+extern  m_pc_t                  _SYS_MEM_   s_pc;
 #endif
 #if (SYSCFG_RUNTIME_COUNT == __ENABLED__)
-extern            s_runtime_ts       _DEBUG_MEM_   s_runtime;
+extern  s_runtime_ts          _DEBUG_MEM_   s_runtime;
 #endif
 #endif
 /* The Task */
-extern  const s_u8_t _CONST_MEM_ s_task_pickmap[SYSCFG_TASKPICKBITMAP * 128];
-extern  s_tasknode_tsp _QUE_MEM_ s_task_queue[SYSCFG_TASKPRIORITY];
+extern  s_u8_t const _CONST_MEM_ s_task_pickmap[SYSCFG_TASKPICKBITMAP * 128];
+extern  s_taskctrl_tsp _QUE_MEM_ s_task_queue[SYSCFG_TASKPRIORITY];
 extern  m_tqcount_t    _QUE_MEM_ s_task_queue_count;
 #if   (SYSCFG_TASKPRIORITY > 64)
 extern  s_u8_t _QUE_MEM_ s_task_table_index;
@@ -101,7 +99,7 @@ extern  s_u8_t _QUE_MEM_ s_task_ready_count[SYSCFG_TASKPRIORITY];
 #elif (SYSCFG_MUTEX == __ENABLED__)
 extern  s_u8_t _SYS_MEM_ s_taskpri_ceiling;
 #endif
-#if (MCUCFG_PENDSVFIFO_DEPTH > 0 && SYSCFG_PENDSVFIFO_ERRORCALLBACK == __ENABLED__)
+#if (SYSCFG_PENDSVFIFO_DEPTH > 0 && SYSCFG_PENDSVFIFO_ERRORCALLBACK == __ENABLED__)
 extern  s_ecode_t _SYS_MEM_ s_psvfifo_ecode;
 #endif
 extern  void (_CODE_MEM_ * const _CONST_MEM_ sPendSV_FIFOHandler[OS_SVID_END])(void _STATIC_MEM_ *sv);

System/sv_com.h

@@ -4,41 +4,43 @@
  * @brief    内核公共服务
  * @details  在服务层临界区中调用并执行。
  * @author   迟凯峰
- * @version  V2.3.0
- * @date     2026.02.01
+ * @version  v3.0.0
+ * @date     2026.07.21
  ******************************************************************************/
 
 #ifndef __SV_COM_H
 #define __SV_COM_H
 
 #include "os_redef.h"
-void      sa_add_ready        (s_tasknode_tsp htask);
-void      sa_remove_ready     (s_tasknode_tsp htask);
-void      sa_insert_taskque   (s_tasknode_tsp htask);
-void      sa_remove_taskque   (s_tasknode_tsp htask);
-void      sa_insert_blocklist (s_tasknode_tsp *h2task);
-void      sa_remove_blocklist (s_tasknode_tsp htask);
-void      sa_insert_timerlist (s_tasknode_tsp htask, s_delay_t tick);
-void      sa_remove_timerlist (s_tasknode_tsp htask);
-void      sa_block_to_float   (s_tasknode_tsp htask);
-void      sa_float_to_block   (s_tasknode_tsp htask);
-void      sa_block_to_ready   (s_tasknode_tsp htask);
-void      sa_resume_task      (s_tasknode_tsp htask);
-void      sa_suspend_task     (s_tasknode_tsp htask);
-void      sa_stop_task        (s_tasknode_tsp htask);
-void      sa_free_task        (s_tasknode_tsp htask);
-void      sa_delete_task      (s_tasknode_tsp htask);
-void      sa_clear_block      (s_tasknode_tsp htask);
-void      sa_set_block        (s_tasknode_tsp htask, s_delay_t tick);
-void      sa_set_taskpri      (s_tasknode_tsp htask, s_u8_t npri);
+void      sa_add_ready        (s_taskctrl_tsp htask);
+void      sa_remove_ready     (s_taskctrl_tsp htask);
+void      sa_insert_taskque   (s_taskctrl_tsp htask);
+void      sa_remove_taskque   (s_taskctrl_tsp htask);
+void      sa_insert_blocklist (s_taskctrl_tsp *h2task);
+void      sa_remove_blocklist (s_taskctrl_tsp htask);
+void      sa_insert_timerlist (s_taskctrl_tsp htask, s_delay_t tick);
+void      sa_remove_timerlist (s_taskctrl_tsp htask);
+void      sa_block_to_float   (s_taskctrl_tsp htask);
+void      sa_float_to_block   (s_taskctrl_tsp htask);
+void      sa_block_to_ready   (s_taskctrl_tsp htask);
+void      sa_resume_task      (s_taskctrl_tsp htask);
+void      sa_suspend_task     (s_taskctrl_tsp htask);
+void      sa_stop_task        (s_taskctrl_tsp htask);
+void      sa_free_task        (s_taskctrl_tsp htask);
+void      sa_delete_task      (s_taskctrl_tsp htask);
+void      sa_reset_task       (s_taskctrl_tsp htask, s_u8_t status);
+void      sa_clear_block      (s_taskctrl_tsp htask);
+void      sa_set_block        (s_taskctrl_tsp htask, s_delay_t tick);
+void      sa_set_taskpri      (s_taskctrl_tsp htask, s_u8_t npri);
 
 void      sc_clear_delay      (void);
-s_ecode_t sc_resume_task      (s_tasknode_tsp htask);
-s_ecode_t sc_suspend_task     (s_tasknode_tsp htask);
-s_ecode_t sc_delete_task      (s_tasknode_tsp htask);
-s_ecode_t sc_clear_block      (s_tasknode_tsp htask);
-s_ecode_t sc_set_block        (s_tasknode_tsp htask, s_delay_t tick);
-s_ecode_t sc_set_taskpri      (s_tasknode_tsp htask, s_u8_t npri);
+s_ecode_t sc_resume_task      (s_taskctrl_tsp htask);
+s_ecode_t sc_suspend_task     (s_taskctrl_tsp htask);
+s_ecode_t sc_delete_task      (s_taskctrl_tsp htask);
+s_ecode_t sc_reset_task       (s_taskctrl_tsp htask, s_u8_t status);
+s_ecode_t sc_clear_block      (s_taskctrl_tsp htask);
+s_ecode_t sc_set_block        (s_taskctrl_tsp htask, s_delay_t tick);
+s_ecode_t sc_set_taskpri      (s_taskctrl_tsp htask, s_u8_t npri);
 void      sc_write_binary     (s_binary_tsp hbin, bool value);
 void      sc_give_semaph      (s_semaph_tsp hsem);
 void      sc_send_fetion      (s_tionbox_tsp htbox, m_fetion_t tion);

System/sv_int_fifo.c

@@ -4,12 +4,12 @@
  * @brief    中断FIFO服务-执行函数
  * @details  仅在 PendSV中断 中由系统调用并执行。
  * @author   迟凯峰
- * @version  V2.3.1
- * @date     2026.03.01
+ * @version  v3.0.0
+ * @date     2026.07.21
  ******************************************************************************/
 
 #include "os_var.h"
-#if (MCUCFG_PENDSVFIFO_DEPTH > 0)
+#if (SYSCFG_PENDSVFIFO_DEPTH > 0)
 #include "os_api.h"
 #include "sv_com.h"
 #include "ur_api.h"
@@ -57,7 +57,7 @@ static void _clear_delay_(void _STATIC_MEM_ *sv) MCUCFG_OSIT_ATTRIBUTE
 #if 1 /* 编译开关 *//* 如果用户不会调用关联服务，可手动移除该函数（1 改为 0）*/
 static void _resume_task_(void _STATIC_MEM_ *sv) MCUCFG_OSIT_ATTRIBUTE
 {
-	s_tasknode_tsp htask = ((sp_task_tsp)sv)->htask;
+	s_taskctrl_tsp htask = ((sp_task_tsp)sv)->htask;
 	#if (SYSCFG_PENDSVFIFO_ERRORCALLBACK == __ENABLED__)
 	s_ecode_t _ecode = sc_resume_task(htask);
 	if(_ecode){
@@ -84,7 +84,7 @@ static void _resume_task_(void _STATIC_MEM_ *sv) MCUCFG_OSIT_ATTRIBUTE
 #if 1 /* 编译开关 *//* 如果用户不会调用关联服务，可手动移除该函数（1 改为 0）*/
 static void _suspend_task_(void _STATIC_MEM_ *sv) MCUCFG_OSIT_ATTRIBUTE
 {
-	s_tasknode_tsp htask = ((sp_task_tsp)sv)->htask;
+	s_taskctrl_tsp htask = ((sp_task_tsp)sv)->htask;
 	#if (SYSCFG_PENDSVFIFO_ERRORCALLBACK == __ENABLED__)
 	s_ecode_t _ecode = sc_suspend_task(htask);
 	if(_ecode){
@@ -111,7 +111,7 @@ static void _suspend_task_(void _STATIC_MEM_ *sv) MCUCFG_OSIT_ATTRIBUTE
 #if 1 /* 编译开关 *//* 如果用户不会调用关联服务，可手动移除该函数（1 改为 0）*/
 static void _delete_task_(void _STATIC_MEM_ *sv) MCUCFG_OSIT_ATTRIBUTE
 {
-	s_tasknode_tsp htask = ((sp_task_tsp)sv)->htask;
+	s_taskctrl_tsp htask = ((sp_task_tsp)sv)->htask;
 	#if (SYSCFG_PENDSVFIFO_ERRORCALLBACK == __ENABLED__)
 	s_ecode_t _ecode = sc_delete_task(htask);
 	if(_ecode){
@@ -129,6 +129,34 @@ static void _delete_task_(void _STATIC_MEM_ *sv) MCUCFG_OSIT_ATTRIBUTE
 #define _delete_task_ OS_NULL
 #endif
 
+/**
+ \brief      重置任务
+ \param[in]  sv        服务的结构体指针
+ \return     无
+ \note       关联服务：iResetTask(task, status)。
+ */
+#if 1 /* 编译开关 *//* 如果用户不会调用关联服务，可手动移除该函数（1 改为 0）*/
+static void _reset_task_(void _STATIC_MEM_ *sv) MCUCFG_OSIT_ATTRIBUTE
+{
+	s_taskctrl_tsp htask = ((sp_taskrst_tsp)sv)->htask;
+	s_u8_t status = ((sp_taskrst_tsp)sv)->status;
+	#if (SYSCFG_PENDSVFIFO_ERRORCALLBACK == __ENABLED__)
+	s_ecode_t _ecode = sc_reset_task(htask, status);
+	if(_ecode){
+		s_psvfifo_ecode = _ecode;
+		pResetTask_ErrorCallback(htask, status);
+	}
+	#else
+	if(htask == OS_NULL) return;
+	if(htask->status < OS_STATUS_DELETED){
+		sa_reset_task(htask, status);
+	}
+	#endif
+}
+#else
+#define _reset_task_ OS_NULL
+#endif
+
 /**
  \brief      清除阻塞（状态）
  \param[in]  sv        服务的结构体指针
@@ -138,7 +166,7 @@ static void _delete_task_(void _STATIC_MEM_ *sv) MCUCFG_OSIT_ATTRIBUTE
 #if 1 /* 编译开关 *//* 如果用户不会调用关联服务，可手动移除该函数（1 改为 0）*/
 static void _clear_block_(void _STATIC_MEM_ *sv) MCUCFG_OSIT_ATTRIBUTE
 {
-	s_tasknode_tsp htask = ((sp_task_tsp)sv)->htask;
+	s_taskctrl_tsp htask = ((sp_task_tsp)sv)->htask;
 	#if (SYSCFG_PENDSVFIFO_ERRORCALLBACK == __ENABLED__)
 	s_ecode_t _ecode = sc_clear_block(htask);
 	if(_ecode){
@@ -166,7 +194,7 @@ static void _clear_block_(void _STATIC_MEM_ *sv) MCUCFG_OSIT_ATTRIBUTE
 #if 1 /* 编译开关 *//* 如果用户不会调用关联服务，可手动移除该函数（1 改为 0）*/
 static void _set_block_(void _STATIC_MEM_ *sv) MCUCFG_OSIT_ATTRIBUTE
 {
-	s_tasknode_tsp htask = ((sp_blocktime_tsp)sv)->htask;
+	s_taskctrl_tsp htask = ((sp_blocktime_tsp)sv)->htask;
 	s_delay_t tick = ((sp_blocktime_tsp)sv)->tick;
 	#if (SYSCFG_PENDSVFIFO_ERRORCALLBACK == __ENABLED__)
 	s_ecode_t _ecode = sc_set_block(htask, tick);
@@ -194,7 +222,7 @@ static void _set_block_(void _STATIC_MEM_ *sv) MCUCFG_OSIT_ATTRIBUTE
 #if 1 /* 编译开关 *//* 如果用户不会调用关联服务，可手动移除该函数（1 改为 0）*/
 static void _set_taskpri_(void _STATIC_MEM_ *sv) MCUCFG_OSIT_ATTRIBUTE
 {
-	s_tasknode_tsp htask = ((sp_taskpri_tsp)sv)->htask;
+	s_taskctrl_tsp htask = ((sp_taskpri_tsp)sv)->htask;
 	s_u8_t npri = ((sp_taskpri_tsp)sv)->npri;
 	#if (SYSCFG_PENDSVFIFO_ERRORCALLBACK == __ENABLED__)
 	s_ecode_t _ecode = sc_set_taskpri(htask, npri);
@@ -421,6 +449,7 @@ void (_CODE_MEM_ * const _CONST_MEM_ sPendSV_FIFOHandler[OS_SVID_END])(void _STA
 	_resume_task_,
 	_suspend_task_,
 	_delete_task_,
+	_reset_task_,
 	_clear_block_,
 	_set_block_,
 	_set_taskpri_,
@@ -451,7 +480,7 @@ void (_CODE_MEM_ * const _CONST_MEM_ sPendSV_FIFOHandler[OS_SVID_END])(void _STA
  */
 #if 1 /* 编译开关 *//* 如果该函数在用户文件中实现且此处的弱定义无效，可手动移除该函数（1 改为 0）*/ \
  && !defined (_resume_task_)
-__WEAK void pResumeTask_ErrorCallback(s_tasknode_tsp htask) MCUCFG_OSIT_ATTRIBUTE
+__WEAK void pResumeTask_ErrorCallback(s_taskctrl_tsp htask) MCUCFG_OSIT_ATTRIBUTE
 {
   /* Prevent unused argument(s) compilation warning */
   __UNUSED(htask);
@@ -468,7 +497,7 @@ __WEAK void pResumeTask_ErrorCallback(s_tasknode_tsp htask) MCUCFG_OSIT_ATTRIBUT
  */
 #if 1 /* 编译开关 *//* 如果该函数在用户文件中实现且此处的弱定义无效，可手动移除该函数（1 改为 0）*/ \
  && !defined (_suspend_task_)
-__WEAK void pSuspendTask_ErrorCallback(s_tasknode_tsp htask) MCUCFG_OSIT_ATTRIBUTE
+__WEAK void pSuspendTask_ErrorCallback(s_taskctrl_tsp htask) MCUCFG_OSIT_ATTRIBUTE
 {
   /* Prevent unused argument(s) compilation warning */
   __UNUSED(htask);
@@ -485,7 +514,7 @@ __WEAK void pSuspendTask_ErrorCallback(s_tasknode_tsp htask) MCUCFG_OSIT_ATTRIBU
  */
 #if 1 /* 编译开关 *//* 如果该函数在用户文件中实现且此处的弱定义无效，可手动移除该函数（1 改为 0）*/ \
  && !defined (_delete_task_)
-__WEAK void pDeleteTask_ErrorCallback(s_tasknode_tsp htask) MCUCFG_OSIT_ATTRIBUTE
+__WEAK void pDeleteTask_ErrorCallback(s_taskctrl_tsp htask) MCUCFG_OSIT_ATTRIBUTE
 {
   /* Prevent unused argument(s) compilation warning */
   __UNUSED(htask);
@@ -495,6 +524,25 @@ __WEAK void pDeleteTask_ErrorCallback(s_tasknode_tsp htask) MCUCFG_OSIT_ATTRIBUT
 }
 #endif
 
+/**
+ \brief      iResetTask(task, status) error callback
+ \param[in]  htask     任务句柄
+ \param[in]  status    任务初始状态
+ \return     无
+ */
+#if 1 /* 编译开关 *//* 如果该函数在用户文件中实现且此处的弱定义无效，可手动移除该函数（1 改为 0）*/ \
+ && !defined (_reset_task_)
+__WEAK void pResetTask_ErrorCallback(s_taskctrl_tsp htask, s_u8_t status) MCUCFG_OSIT_ATTRIBUTE
+{
+  /* Prevent unused argument(s) compilation warning */
+  __UNUSED(htask);
+  __UNUSED(status);
+  /* NOTE: This function should not be modified, when the callback is needed,
+           the pDeleteTask_ErrorCallback could be implemented in the user file
+   */
+}
+#endif
+
 /**
  \brief      iClearBlock(task) error callback
  \param[in]  htask     任务句柄
@@ -502,7 +550,7 @@ __WEAK void pDeleteTask_ErrorCallback(s_tasknode_tsp htask) MCUCFG_OSIT_ATTRIBUT
  */
 #if 1 /* 编译开关 *//* 如果该函数在用户文件中实现且此处的弱定义无效，可手动移除该函数（1 改为 0）*/ \
  && !defined (_clear_block_)
-__WEAK void pClearBlock_ErrorCallback(s_tasknode_tsp htask) MCUCFG_OSIT_ATTRIBUTE
+__WEAK void pClearBlock_ErrorCallback(s_taskctrl_tsp htask) MCUCFG_OSIT_ATTRIBUTE
 {
   /* Prevent unused argument(s) compilation warning */
   __UNUSED(htask);
@@ -522,7 +570,7 @@ __WEAK void pClearBlock_ErrorCallback(s_tasknode_tsp htask) MCUCFG_OSIT_ATTRIBUT
  */
 #if 1 /* 编译开关 *//* 如果该函数在用户文件中实现且此处的弱定义无效，可手动移除该函数（1 改为 0）*/ \
  && !defined (_set_block_)
-__WEAK void pSetBlock_ErrorCallback(s_tasknode_tsp htask, s_delay_t tick) MCUCFG_OSIT_ATTRIBUTE
+__WEAK void pSetBlock_ErrorCallback(s_taskctrl_tsp htask, s_delay_t tick) MCUCFG_OSIT_ATTRIBUTE
 {
   /* Prevent unused argument(s) compilation warning */
   __UNUSED(htask);
@@ -541,7 +589,7 @@ __WEAK void pSetBlock_ErrorCallback(s_tasknode_tsp htask, s_delay_t tick) MCUCFG
  */
 #if 1 /* 编译开关 *//* 如果该函数在用户文件中实现且此处的弱定义无效，可手动移除该函数（1 改为 0）*/ \
  && !defined (_set_taskpri_)
-__WEAK void pSetTaskPri_ErrorCallback(s_tasknode_tsp htask, s_u8_t npri) MCUCFG_OSIT_ATTRIBUTE
+__WEAK void pSetTaskPri_ErrorCallback(s_taskctrl_tsp htask, s_u8_t npri) MCUCFG_OSIT_ATTRIBUTE
 {
   /* Prevent unused argument(s) compilation warning */
   __UNUSED(htask);

System/sv_int_fifo.h

@@ -4,8 +4,8 @@
  * @brief    中断FIFO服务-调用宏
  * @details  仅在用户中断中调用，而后挂起到 PendSV中断 中执行。
  * @author   迟凯峰
- * @version  V2.3.1
- * @date     2026.03.01
+ * @version  v3.0.0
+ * @date     2026.07.21
  ******************************************************************************/
 
 #ifndef __SV_INT_FIFO_H
@@ -56,6 +56,14 @@ do{ \
 	mPendSV_FIFOLoad(); \
 }while(false)
 
+/** 重置任务 */
+#define sIPS_ResetTask(_htask, _status) \
+do{ \
+	static sp_taskrst_ts u_psv = {OS_SVID_RESETTASK, OS_NULL, _status}; \
+	u_psv.htask = _htask; \
+	mPendSV_FIFOLoad(); \
+}while(false)
+
 /** 清除阻塞（状态）*/
 #define sIPS_ClearBlock(_htask) \
 do{ \
@@ -147,8 +155,8 @@ do{ \
 	static sp_group_ts u_psv = {OS_SVID_WRITEGROUP, (void *)&_group, _sign##sizeof(_group), 0}; \
 	u_##_group##_ts u_grp; \
 	miWriteFlagBits(); \
-	sizeof(u_grp) == 1 ? *(s_u8_t  *)&u_grp = false : MCUCFG_TERNARYMASK \
-	sizeof(u_grp) == 2 ? *(s_u16_t *)&u_grp = false : MCUCFG_TERNARYMASK \
+	sizeof(u_grp) == 1 ? *(s_u8_t  *)&u_grp = false : MCUCFG_TERNARY_MASK \
+	sizeof(u_grp) == 2 ? *(s_u16_t *)&u_grp = false : MCUCFG_TERNARY_MASK \
 	sizeof(u_grp) == 4 ? *(s_u32_t *)&u_grp = false : false; \
 	siWriteFlagBits_##_nbit(
 
@@ -169,7 +177,7 @@ do{ \
 /** 设置时间 */
 #define sIPS_SetTime(_t) \
 do{ \
-	static const m_rtccount_t _c = 1000000UL / SYSCFG_SYSTICK_CYCLE / 2 + 1; \
+	static m_rtccount_t const _c = 1000000UL / SYSCFG_SYSTICK_CYCLE / 2 + 1; \
 	iWriteGAry(&s_rtc, _t, sizeof(s_rtc)); \
 	iWriteGVar(s_rtc_counter, _c); \
 }while(false)

System/sv_int_loc.c

@@ -4,15 +4,16 @@
  * @brief    中断本地服务
  * @details  在用户中断中调用并直接在本地执行。
  * @author   迟凯峰
- * @version  V2.3.0
- * @date     2026.02.19
+ * @version  v3.0.0
+ * @date     2026.07.21
  ******************************************************************************/
 
 #include "os_var.h"
 #include "sv_com.h"
 
-#if (SYSCFG_MCUCORE == 8051)
-#pragma NOAREGS /* 相对寄存器访问 for C51 */
+/* 相对寄存器访问 for C51 */
+#if defined ( __C51__ )
+#pragma NOAREGS
 #endif
 
 /**
@@ -66,8 +67,8 @@ void *si_recv_mail(s_mailbox_tsp hmbox)
 }
 #endif
 
-#if (SYSCFG_MSGQUEUE == __ENABLED__)
-#if (SYSCFG_MCUCORE == 8051)
+#if (SYSCFG_MSGQUEUE == __ENABLED__) && (SYSCFG_MSGQUEUE_INTRECV == __ENABLED__)
+#if defined ( __C51__ )
 /**
  \brief      获取队列互斥量
  \details    获取队列访问权限 for C51接收消息。
@@ -76,8 +77,9 @@ void *si_recv_mail(s_mailbox_tsp hmbox)
  */
 bool si_take_quemut(s_msgque_tsp hque)
 {
-	if(!hque->mutex) return false;
-	hque->mutex = false;
+	if(!hque->lock) return false;
+	hque->lock = false;
+	__mx_MMB();
 	
 	if(hque->type == __DYNAMIC__){
 		#if (SYSCFG_DEBUGGING == __ENABLED__)
@@ -87,7 +89,8 @@ bool si_take_quemut(s_msgque_tsp hque)
 	else if(!hque->counter);
 	else return true;
 	
-	hque->mutex = true;
+	__mx_MMB();
+	hque->lock = true;
 	return false;
 }
 
@@ -112,7 +115,7 @@ static void *_back_ret_(bool _STATIC_MEM_ *mut, void *msg)
 void *si_recv_msg_c51(s_msgque_tsp hque)
 {
 	void *msg = sc_recv_msg_staque((s_staque_tsp)hque);
-	return _back_ret_((bool *)&hque->mutex, msg);
+	return _back_ret_((bool *)&hque->lock, msg);
 }
 #else
 /**
@@ -123,8 +126,9 @@ void *si_recv_msg_c51(s_msgque_tsp hque)
 void *si_recv_msg_n51(s_msgque_tsp hque)
 {
 	void *msg = OS_NULL;
-	if(!hque->mutex) return OS_NULL;
-	hque->mutex = false;
+	if(!hque->lock) return OS_NULL;
+	hque->lock = false;
+	__mx_MMB();
 	
 	if(hque->type == __DYNAMIC__){
 		#if (SYSCFG_DEBUGGING == __ENABLED__)
@@ -135,7 +139,8 @@ void *si_recv_msg_n51(s_msgque_tsp hque)
 		msg = sc_recv_msg_staque((s_staque_tsp)hque);
 	}
 	
-	hque->mutex = true;
+	__mx_MMB();
+	hque->lock = true;
 	return msg;
 }
 #endif

System/sv_int_loc.h

@@ -4,8 +4,8 @@
  * @brief    中断本地服务
  * @details  在用户中断中调用并直接在本地执行。
  * @author   迟凯峰
- * @version  V2.3.0
- * @date     2026.02.19
+ * @version  v3.0.0
+ * @date     2026.07.21
  ******************************************************************************/
 
 #ifndef __SV_INT_LOC_H
@@ -32,12 +32,19 @@ m_fetion_t si_recv_fetion (s_tionbox_tsp htbox);
 #define sISV_RecvFetion(tbox) si_recv_fetion(&tbox) /*!< 接收飞信 */
 #define sISV_RecvMail(mbox)   si_recv_mail(&mbox)   /*!< 接收邮件 */
 
-#if (SYSCFG_MCUCORE == 8051)
+#if defined ( __C51__ )
 #define sISV_RecvMsg(que) (si_take_quemut((s_msgque_tsp)&que) ? si_recv_msg_c51((s_msgque_tsp)&que) : OS_NULL) /*!< C51接收消息 */
 #else
 #define sISV_RecvMsg(que)  si_recv_msg_n51((s_msgque_tsp)&que) /*!< 非51接收消息 */
 #endif
 
+/** 归还二值信号量 */
+#define sISV_BackBin(bin) \
+do{ \
+	__mx_MMB(); \
+	bin.binary = true; \
+}while(false)
+
 /** 查询标志组 */
 #define sISV_QueryFlagGroup(group) \
 ( \

System/sv_pend.h

@@ -4,8 +4,8 @@
  * @brief    PSV服务
  * @details  仅在 PendSV中断 中调用并执行。
  * @author   迟凯峰
- * @version  V2.3.1
- * @date     2026.03.01
+ * @version  v3.0.0
+ * @date     2026.07.21
  ******************************************************************************/
 
 #ifndef __SV_PEND_H
@@ -23,14 +23,15 @@
  @{
  */
 
-#define sPSV_ClearDelay()            sc_clear_delay()            /*!< 清除就绪延时 */
-#define sPSV_ResumeTask(htask)       sc_resume_task(htask)       /*!< 恢复任务 */
-#define sPSV_SuspendTask(htask)      sc_suspend_task(htask)      /*!< 挂起任务 */
-#define sPSV_DeleteTask(htask)       sc_delete_task(htask)       /*!< 删除任务 */
-#define sPSV_ClearBlock(htask)       sc_clear_block(htask)       /*!< 清除阻塞（状态）*/
-#define sPSV_SetBlock(htask, tick)   sc_set_block(htask, tick)   /*!< 设置阻塞（时间）*/
-#define sPSV_SetTaskPri(htask, npri) sc_set_taskpri(htask, npri) /*!< 设置任务优先级 */
-#define sPSV_GiveBin(bin)            sc_write_binary(&bin, true) /*!< 给予二值信号量 */
+#define sPSV_ClearDelay()             sc_clear_delay()            /*!< 清除就绪延时 */
+#define sPSV_ResumeTask(htask)        sc_resume_task(htask)       /*!< 恢复任务 */
+#define sPSV_SuspendTask(htask)       sc_suspend_task(htask)      /*!< 挂起任务 */
+#define sPSV_DeleteTask(htask)        sc_delete_task(htask)       /*!< 删除任务 */
+#define sPSV_ResetTask(htask, status) sc_reset_task(htask, status)/*!< 重置任务 */
+#define sPSV_ClearBlock(htask)        sc_clear_block(htask)       /*!< 清除阻塞（状态）*/
+#define sPSV_SetBlock(htask, tick)    sc_set_block(htask, tick)   /*!< 设置阻塞（时间）*/
+#define sPSV_SetTaskPri(htask, npri)  sc_set_taskpri(htask, npri) /*!< 设置任务优先级 */
+#define sPSV_GiveBin(bin)             sc_write_binary(&bin, true) /*!< 给予二值信号量 */
 
 /** @} */
 /** @} */

System/sv_task.h

@@ -4,8 +4,8 @@
  * @brief    任务服务
  * @details  仅在任务中调用并执行。
  * @author   迟凯峰
- * @version  V2.3.0
- * @date     2026.02.19
+ * @version  v3.0.0
+ * @date     2026.07.21
  ******************************************************************************/
 
 #ifndef __SV_TASK_H
@@ -13,7 +13,7 @@
 
 #include "os_var.h"
 
-#if (MCUCFG_ISA != __ARM__)
+#if defined ( __C51__ ) || defined ( __C251__ )
 void       su_schedule_locks    (void);
 void       su_kernel_lock0      (void);
 void       su_kernel_unlock0    (void);
@@ -23,7 +23,7 @@ void      *su_kernel_unlocks_rvp(void *p);
 
 #if (SYSCFG_KERNELLOCKNESTING == __DISABLED__)
 #define    su_kernel_locks      su_kernel_lock0
-#elif (MCUCFG_ISA != __ARM__)
+#elif defined ( __C51__ ) || defined ( __C251__ )
 void       su_kernel_locks      (void);
 #endif
 
@@ -31,9 +31,9 @@ void       su_schedule_unlocks  (void);
 void       su_kernel_unlocks    (void);
 void       su_kernel_unlock0_psv(void);
 
-s_ecode_t  su_startup_task_0    (s_taskhand_tsp hhand, s_u8_t status);
-s_ecode_t  su_startup_task_1    (s_taskhand_tsp hhand, s_u8_t status, s_voidvoid_tfp entry);
-s_ecode_t  su_resume_suspend    (s_tasknode_tsp htask);
+s_ecode_t  su_startup_task_0    (s_taskload_tsp hload, s_u8_t status);
+s_ecode_t  su_startup_task_1    (s_taskload_tsp hload, s_u8_t status, s_voidvoid_tfp entry);
+s_ecode_t  su_resume_suspend    (s_taskctrl_tsp htask);
 void       su_yield_tasking     (void);
 void       su_delay             (s_delay_t tick);
 bool       su_take_mutex        (s_mutex_tsp hmut, s_delay_t tick);
@@ -44,11 +44,11 @@ bool       su_take_semaph       (s_semaph_tsp hsem, s_delay_t tick);
 m_fetion_t su_recv_fetion       (s_tionbox_tsp htbox, s_delay_t tick);
 void      *su_recv_mail         (s_mailbox_tsp hmbox, s_delay_t tick);
 void      *su_recv_msg          (s_msgque_tsp hque, s_delay_t tick);
-bool       su_recv_taskmsg      (volatile s_u8_t  _STATIC_MEM_ *tmrf, s_delay_t tick);
-bool       su_wait_group_1      (volatile s_u8_t  _STATIC_MEM_ *hgrp, s_delay_t tick);
-bool       su_wait_group_2      (volatile s_u16_t _STATIC_MEM_ *hgrp, s_delay_t tick);
-bool       su_wait_group_4      (volatile s_u32_t _STATIC_MEM_ *hgrp, s_delay_t tick);
-bool       su_query_group       (volatile void    _STATIC_MEM_ *hgrp, s_u8_t size);
+bool       su_recv_taskmsg      (s_u8_t  volatile _STATIC_MEM_ *tmrf, s_delay_t tick);
+bool       su_wait_group_1      (s_u8_t  volatile _STATIC_MEM_ *hgrp, s_delay_t tick);
+bool       su_wait_group_2      (s_u16_t volatile _STATIC_MEM_ *hgrp, s_delay_t tick);
+bool       su_wait_group_4      (s_u32_t volatile _STATIC_MEM_ *hgrp, s_delay_t tick);
+bool       su_query_group       (void    volatile _STATIC_MEM_ *hgrp, s_u8_t size);
 bool       su_init_mempool      (s_thrmem_tsp hmem, size_t size);
 void _MALLOC_MEM_ *su_talloc    (s_thrmem_tsp hmem, size_t size);
 void _MALLOC_MEM_ *su_xalloc    (void _MALLOC_MEM_ *p);
@@ -63,11 +63,12 @@ void _MALLOC_MEM_ *su_xalloc    (void _MALLOC_MEM_ *p);
  @{
  */
 
-#if (MCUCFG_ISA == __ARM__)
+#if !defined ( __C51__ ) && !defined ( __C251__ )
 /** 调度上锁（进入嵌套任务临界区）*/
 __STATIC_FORCEINLINE void su_schedule_locks(void)
 {
 	s_sign_schedule.every[0] = true;
+	__mx_MMB();
 	s_schedulelock_counter++;
 }
 
@@ -116,15 +117,15 @@ __STATIC_FORCEINLINE void *su_kernel_unlocks_rvp(void *p)
  */
 
 /** 启动任务 */
-#define sUSV_StartTask_0(hhand, status) \
+#define sUSV_StartTask_0(hload, status) \
 ( \
-	(m_boolvoid_tf(su_kernel_lock0))() || true ? su_startup_task_0((s_taskhand_tsp)hhand, status) : OS_ECODE_NOERROR \
+	(m_boolvoid_tf(su_kernel_lock0))() || true ? su_startup_task_0((s_taskload_tsp)hload, status) : OS_ECODE_NOERROR \
 )
 
 /** 启动任务 */
-#define sUSV_StartTask_1(hhand, status, entry) \
+#define sUSV_StartTask_1(hload, status, entry) \
 ( \
-	(m_boolvoid_tf(su_kernel_lock0))() || true ? su_startup_task_1((s_taskhand_tsp)hhand, status, (s_voidvoid_tfp)entry) : OS_ECODE_NOERROR \
+	(m_boolvoid_tf(su_kernel_lock0))() || true ? su_startup_task_1((s_taskload_tsp)hload, status, (s_voidvoid_tfp)entry) : OS_ECODE_NOERROR \
 )
 
 /** 恢复指定任务并挂起自身任务 */
@@ -151,6 +152,12 @@ __STATIC_FORCEINLINE void *su_kernel_unlocks_rvp(void *p)
 	(m_boolvoid_tf(su_kernel_locks))() || true ? su_kernel_unlocks_rec(sc_delete_task(htask)) : OS_ECODE_NOERROR \
 )
 
+/** 重置任务 */
+#define sUSV_ResetTask(htask, status) \
+( \
+	(m_boolvoid_tf(su_kernel_locks))() || true ? su_kernel_unlocks_rec(sc_reset_task(htask, status)) : OS_ECODE_NOERROR \
+)
+
 /** 清除阻塞（状态）*/
 #define sUSV_ClearBlock(htask) \
 ( \
@@ -337,8 +344,8 @@ do{ \
 #define sUSV_ClearFlagGroup(group) \
 do{ \
 	su_kernel_locks(); \
-	sizeof(group) == 1 ? *(s_u8_t  *)&group = false : MCUCFG_TERNARYMASK \
-	sizeof(group) == 2 ? *(s_u16_t *)&group = false : MCUCFG_TERNARYMASK \
+	sizeof(group) == 1 ? *(s_u8_t  *)&group = false : MCUCFG_TERNARY_MASK \
+	sizeof(group) == 2 ? *(s_u16_t *)&group = false : MCUCFG_TERNARY_MASK \
 	sizeof(group) == 4 ? *(s_u32_t *)&group = false : false; \
 	su_kernel_unlocks(); \
 }while(false)

System/sv_tick.c

@@ -4,8 +4,8 @@
  * @brief    滴答服务
  * @details  仅在 SysTick中断 中调用并执行。
  * @author   迟凯峰
- * @version  V2.3.0
- * @date     2026.02.19
+ * @version  v3.0.0
+ * @date     2026.07.21
  ******************************************************************************/
 
 #include "os_var.h"
@@ -26,7 +26,7 @@
  */
 bool st_take_semaph(s_semaph_tsp hsem) MCUCFG_OSIT_ATTRIBUTE
 {
-	s_semsize_t counter = hsem->counter;
+	s_semaph_t counter = hsem->counter;
 	if(counter){
 		hsem->counter = counter - 1;
 		return true;
@@ -45,7 +45,10 @@ bool st_take_semaph(s_semaph_tsp hsem) MCUCFG_OSIT_ATTRIBUTE
 void *st_recv_msg(s_msgque_tsp hque) MCUCFG_OSIT_ATTRIBUTE
 {
 	void *msg = OS_NULL;
-	hque->mutex = false;
+	#if (SYSCFG_MSGQUEUE_INTRECV == __ENABLED__)
+	hque->lock = false;
+	__mx_MMB();
+	#endif
 	
 	if(hque->counter){
 		if(hque->type == __DYNAMIC__){
@@ -56,7 +59,10 @@ void *st_recv_msg(s_msgque_tsp hque) MCUCFG_OSIT_ATTRIBUTE
 		}
 	}
 	
-	hque->mutex = true;
+	#if (SYSCFG_MSGQUEUE_INTRECV == __ENABLED__)
+	__mx_MMB();
+	hque->lock = true;
+	#endif
 	return msg;
 }
 #endif

System/sv_tick.h

@@ -4,8 +4,8 @@
  * @brief    滴答服务
  * @details  仅在 SysTick中断 中调用并执行。
  * @author   迟凯峰
- * @version  V2.3.0
- * @date     2026.02.19
+ * @version  v3.0.0
+ * @date     2026.07.21
  ******************************************************************************/
 
 #ifndef __SV_TICK_H
@@ -26,29 +26,37 @@ void      *st_recv_msg     (s_msgque_tsp hque);
  @{
  */
 
-#define sTSV_ClearDelay()            sc_clear_delay()                    /*!< 清除就绪延时 */
-#define sTSV_ResumeTask(htask)       sc_resume_task(htask)               /*!< 恢复任务 */
-#define sTSV_SuspendTask(htask)      sc_suspend_task(htask)              /*!< 挂起任务 */
-#define sTSV_DeleteTask(htask)       sc_delete_task(htask)               /*!< 删除任务 */
-#define sTSV_ClearBlock(htask)       sc_clear_block(htask)               /*!< 清除阻塞 */
-#define sTSV_SetBlock(htask, tick)   sc_set_block(htask, tick)           /*!< 设置阻塞 */
-#define sTSV_SetTaskPri(htask, npri) sc_set_taskpri(htask, npri)         /*!< 设置任务优先级 */
-#define sTSV_GiveBin(bin)            sc_write_binary(&bin, true)         /*!< 给予二值信号量 */
-#define sTSV_GiveSem(sem)            sc_give_semaph(&sem)                /*!< 给予计数信号量 */
-#define sTSV_SendFetion(tbox, tion)  sc_send_fetion(&tbox, tion)         /*!< 发送飞信 */
-#define sTSV_SendMail(mbox, mail)    sc_send_mail(&mbox, mail)           /*!< 发送邮件 */
-#define sTSV_SendMsg(que, msg)       sc_send_msg((s_msgque_tsp)&que, msg)/*!< 发送消息 */
-#define sTSV_TimInt(tmid, tick)      sc_timint(tmid, tick)               /*!< 定时中断 */
-#define sTSV_TimQry(tmid, tick)      sc_timqry(tmid, tick)               /*!< 定时查询 */
+#define sTSV_ClearDelay()             sc_clear_delay()                    /*!< 清除就绪延时 */
+#define sTSV_ResumeTask(htask)        sc_resume_task(htask)               /*!< 恢复任务 */
+#define sTSV_SuspendTask(htask)       sc_suspend_task(htask)              /*!< 挂起任务 */
+#define sTSV_DeleteTask(htask)        sc_delete_task(htask)               /*!< 删除任务 */
+#define sTSV_ResetTask(htask, status) sc_reset_task(htask, status)        /*!< 重置任务 */
+#define sTSV_ClearBlock(htask)        sc_clear_block(htask)               /*!< 清除阻塞 */
+#define sTSV_SetBlock(htask, tick)    sc_set_block(htask, tick)           /*!< 设置阻塞 */
+#define sTSV_SetTaskPri(htask, npri)  sc_set_taskpri(htask, npri)         /*!< 设置任务优先级 */
+#define sTSV_GiveBin(bin)             sc_write_binary(&bin, true)         /*!< 给予二值信号量 */
+#define sTSV_GiveSem(sem)             sc_give_semaph(&sem)                /*!< 给予计数信号量 */
+#define sTSV_SendFetion(tbox, tion)   sc_send_fetion(&tbox, tion)         /*!< 发送飞信 */
+#define sTSV_SendMail(mbox, mail)     sc_send_mail(&mbox, mail)           /*!< 发送邮件 */
+#define sTSV_SendMsg(que, msg)        sc_send_msg((s_msgque_tsp)&que, msg)/*!< 发送消息 */
+#define sTSV_TimInt(tmid, tick)       sc_timint(tmid, tick)               /*!< 定时中断 */
+#define sTSV_TimQry(tmid, tick)       sc_timqry(tmid, tick)               /*!< 定时查询 */
 
-#define sTSV_TakeSem(sem)            st_take_semaph(&sem)                /*!< 获取计数信号量 */
-#define sTSV_RecvMsg(que)            st_recv_msg((s_msgque_tsp)&que)     /*!< 接收消息 */
+#define sTSV_TakeSem(sem)             st_take_semaph(&sem)                /*!< 获取计数信号量 */
+#define sTSV_RecvMsg(que)             st_recv_msg((s_msgque_tsp)&que)     /*!< 接收消息 */
 
-#define sTSV_TakeBin(bin)            si_take_binary(&bin)                /*!< 获取二值信号量 */
-#define sTSV_RecvFetion(tbox)        si_recv_fetion(&tbox)               /*!< 接收飞信 */
-#define sTSV_RecvMail(mbox)          si_recv_mail(&mbox)                 /*!< 接收邮件 */
+#define sTSV_TakeBin(bin)             si_take_binary(&bin)                /*!< 获取二值信号量 */
+#define sTSV_RecvFetion(tbox)         si_recv_fetion(&tbox)               /*!< 接收飞信 */
+#define sTSV_RecvMail(mbox)           si_recv_mail(&mbox)                 /*!< 接收邮件 */
 
-#define sTSV_GetTime(t)              s_memcpy(t, &s_rtc, sizeof(s_rtc))  /*!< 获取时间 */
+#define sTSV_GetTime(t)               s_memcpy(t, &s_rtc, sizeof(s_rtc))  /*!< 获取时间 */
+
+/** 归还二值信号量 */
+#define sTSV_BackBin(bin) \
+do{ \
+	__mx_MMB(); \
+	bin.binary = true; \
+}while(false)
 
 /** 发送私信 */
 #define sTSV_SendTaskmsg(task) \
@@ -75,8 +83,8 @@ do{ \
 /** 清除标志组 */
 #define sTSV_ClearFlagGroup(group) \
 do{ \
-	sizeof(group) == 1 ? *(s_u8_t  *)&group = false : MCUCFG_TERNARYMASK \
-	sizeof(group) == 2 ? *(s_u16_t *)&group = false : MCUCFG_TERNARYMASK \
+	sizeof(group) == 1 ? *(s_u8_t  *)&group = false : MCUCFG_TERNARY_MASK \
+	sizeof(group) == 2 ? *(s_u16_t *)&group = false : MCUCFG_TERNARY_MASK \
 	sizeof(group) == 4 ? *(s_u32_t *)&group = false : false; \
 }while(false)
 

System/ur_eapi.h

@@ -5,8 +5,8 @@
  * @details  用户API的补充扩展定义，仅是定义无注释说明，所有内核服务的API说明
              均在 ur_api.h 中，并支持 doxygen。
  * @author   迟凯峰
- * @version  V2.3.0
- * @date     2026.02.01
+ * @version  v3.0.0
+ * @date     2026.07.21
  ******************************************************************************/
 
 #ifndef __UR_EAPI_H
@@ -45,6 +45,12 @@
   #define pDeleteTask(task)             sPSV_DeleteTask(task)
   #define iDeleteTask(task)             sIPS_DeleteTask(task)
 
+/* 重置任务 */
+//#define uResetTask(task, status)      sUSV_ResetTask(task, status)
+  #define tResetTask(task, status)      sTSV_ResetTask(task, status)
+  #define pResetTask(task, status)      sPSV_ResetTask(task, status)
+  #define iResetTask(task, status)      sIPS_ResetTask(task, status)
+
 /* 设置任务优先级 */
 //#define uSetTaskPri(task, npri)       sUSV_SetTaskPri(task, npri)
   #define tSetTaskPri(task, npri)       sTSV_SetTaskPri(task, npri)
@@ -221,8 +227,8 @@
 
 /* 归还二值信号量 */
 //#define uBackBin(bin)                 uGiveBin(bin)
-  #define tBackBin(bin)                 bin.binary = true
-  #define iBackBin(bin)                 bin.binary = true
+  #define tBackBin(bin)                 sTSV_BackBin(bin)
+  #define iBackBin(bin)                 sISV_BackBin(bin)
 
 /* 获取二值信号量 */
 //#define uTakeBin(bin, tc)             sUSV_TakeBin(bin, tc)