diff --git a/System/os_var.h b/System/os_var.h
new file mode 100644
index 00000000..68acf8c8
--- /dev/null
+++ b/System/os_var.h
@@ -0,0 +1,107 @@
+/**************************************************************************//**
+ * @item CosyOS-III Kernel
+ * @file os_var.h
+ * @brief 系统全局变量声明
+ * @author 迟凯峰
+ * @version v3.0.0
+ * @date 2026.07.21
+ ******************************************************************************/
+
+#ifndef __OS_VAR_H
+#define __OS_VAR_H
+#include "os_redef.h"
+
+/* The Soft-RTC */
+#if (SYSCFG_SOFTRTC == __ENABLED__)
+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 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 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;
+#endif
+/* The Safe runtime */
+#if (SYSCFG_SAFERUNTIME == __ENABLED__)
+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];
+#endif
+/* The Timing Query */
+#if (OS_TIMQRYTOTAL > 0)
+extern s_timqryhand_tsp s_timqry_handle[OS_TIMQRYTOTAL];
+#endif
+/* The Task Message */
+#if (SYSCFG_TASKMSG == __ENABLED__)
+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];
+#if (SYSCFG_DEBUG_SENDLEN == __ENABLED__)
+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];
+#if (SYSCFG_DEBUG_SENDLEN == __ENABLED__)
+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;
+#if (SYSCFG_SYSTICKTIME_COUNT == __ENABLED__)
+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;
+#endif
+#if (SYSCFG_RUNTIME_COUNT == __ENABLED__)
+extern s_runtime_ts _DEBUG_MEM_ s_runtime;
+#endif
+#endif
+/* The Task */
+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;
+extern s_u8_t _QUE_MEM_ s_task_bytes_index[SYSCFG_TASKPRIORITY / 64 + !!(SYSCFG_TASKPRIORITY % 64)];
+extern s_u8_t _QUE_MEM_ s_task_ready_table[SYSCFG_TASKPRIORITY / 64 + !!(SYSCFG_TASKPRIORITY % 64)][8];
+#elif (SYSCFG_TASKPRIORITY > 8)
+extern s_u8_t _QUE_MEM_ s_task_bytes_index;
+extern s_u8_t _QUE_MEM_ s_task_ready_table[SYSCFG_TASKPRIORITY / 8 + !!(SYSCFG_TASKPRIORITY % 8)];
+#else
+extern s_u8_t _QUE_MEM_ s_task_ready_table;
+#endif
+#if (SYSCFG_SAMEPRISCHEDULE)
+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 (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);
+
+#endif
diff --git a/System/sv_com.c b/System/sv_com.c
new file mode 100644
index 00000000..bc028908
--- /dev/null
+++ b/System/sv_com.c
@@ -0,0 +1,952 @@
+/**************************************************************************//**
+ * @item CosyOS-III Kernel
+ * @file sv_com.c
+ * @brief 内核公共服务
+ * @details 在服务层临界区中调用并执行。
+ * @author 迟凯峰
+ * @version v3.0.0
+ * @date 2026.07.21
+ ******************************************************************************/
+
+#include "os_var.h"
+#include "os_api.h"
+#include "sv_com.h"
+
+/* 相对寄存器访问 for C51 */
+#if defined ( __C51__ )
+#pragma NOAREGS
+#endif
+
+/**
+ \brief 加入就绪
+ \details 任务由非就绪状态变为就绪状态的相关调整。
+ \param[in] htask 任务句柄
+ \return 无
+ */
+void sa_add_ready(s_taskctrl_tsp htask)
+{
+ s_u8_t pri = htask->pri;
+ if(pri > s_task_current->pri){
+ s_sign_schedule.every[1] = false;
+ }
+ #if (SYSCFG_SAMEPRISCHEDULE)
+ if(s_task_ready_count[pri]++) return;
+ #endif
+ if(true){
+ s_u8_t bit_index = (pri & 7);
+ #if (SYSCFG_TASKPRIORITY > 64)
+ s_u8_t table_index = (pri >> 6);
+ s_u8_t bytes_index = (pri & 63) >> 3;
+ s_task_table_index |= (1 << table_index);
+ s_task_bytes_index[table_index] |= (1 << bytes_index);
+ s_task_ready_table[table_index][bytes_index] |= (1 << bit_index);
+ #elif (SYSCFG_TASKPRIORITY > 8)
+ s_u8_t bytes_index = (pri >> 3);
+ s_task_bytes_index |= (1 << bytes_index);
+ s_task_ready_table[bytes_index] |= (1 << bit_index);
+ #else
+ s_task_ready_table |= (1 << bit_index);
+ #endif
+ }
+}
+
+/**
+ \brief 移除就绪
+ \details 任务由就绪状态变为非就绪状态的相关调整。
+ \param[in] htask 任务句柄
+ \return 无
+ */
+void sa_remove_ready(s_taskctrl_tsp htask)
+{
+ s_u8_t pri = htask->pri;
+ if(htask == s_task_current){
+ s_sign_schedule.every[1] = false;
+ }
+ #if (SYSCFG_SAMEPRISCHEDULE)
+ if(--s_task_ready_count[pri]) return;
+ #endif
+ if(true){
+ s_u8_t bit_index = (pri & 7);
+ #if (SYSCFG_TASKPRIORITY > 64)
+ s_u8_t table_index = (pri >> 6);
+ s_u8_t bytes_index = (pri & 63) >> 3;
+ s_task_ready_table[table_index][bytes_index] &= ~(1 << bit_index);
+ if(!s_task_ready_table[table_index][bytes_index]){
+ s_task_bytes_index[table_index] &= ~(1 << bytes_index);
+ if(!s_task_bytes_index[table_index]){
+ s_task_table_index &= ~(1 << table_index);
+ }
+ }
+ #elif (SYSCFG_TASKPRIORITY > 8)
+ s_u8_t bytes_index = (pri >> 3);
+ s_task_ready_table[bytes_index] &= ~(1 << bit_index);
+ if(!s_task_ready_table[bytes_index]){
+ s_task_bytes_index &= ~(1 << bytes_index);
+ }
+ #else
+ s_task_ready_table &= ~(1 << bit_index);
+ #endif
+ }
+}
+
+/**
+ \brief 插入至任务队列
+ \details 任务节点插入至任务队列尾。
+ \param[in] htask 任务句柄
+ \return 无
+ */
+void sa_insert_taskque(s_taskctrl_tsp htask)
+{
+ s_u8_t pri = htask->pri;
+ #if (SYSCFG_SAMEPRISCHEDULE)
+ if(s_task_queue[pri] == OS_NULL){
+ s_task_queue[pri] = htask->last = htask->next = htask;
+ }
+ else{
+ htask->last = s_task_queue[pri]->last;
+ htask->next = s_task_queue[pri];
+ s_task_queue[pri]->last->next = htask;
+ s_task_queue[pri]->last = htask;
+ }
+ #else
+ s_task_queue[pri] = htask;
+ #endif
+}
+
+/**
+ \brief 移除从任务队列
+ \details 从任务队列中移除任务节点。
+ \param[in] htask 任务句柄
+ \return 无
+ */
+void sa_remove_taskque(s_taskctrl_tsp htask)
+{
+ s_u8_t pri = htask->pri;
+ #if (SYSCFG_SAMEPRISCHEDULE)
+ if(s_task_queue[pri] == s_task_queue[pri]->last){
+ s_task_queue[pri] = OS_NULL;
+ }
+ else{
+ htask->last->next = htask->next;
+ htask->next->last = htask->last;
+ if(htask == s_task_queue[pri]){
+ s_task_queue[pri] = htask->next;
+ }
+ }
+ #else
+ s_task_queue[pri] = OS_NULL;
+ #endif
+}
+
+/**
+ \brief 插入至阻塞链表
+ \details 当前任务节点插入至阻塞链表尾。
+ \param[in] h2task 指向链表头的指针
+ \return 无
+ */
+void sa_insert_blocklist(s_taskctrl_tsp *h2task)
+{
+ s_taskctrl_tsp htask = *h2task;
+ if(htask == OS_NULL){
+ *h2task = s_task_current->last_b = s_task_current->next_b = s_task_current;
+ }
+ else{
+ s_task_current->last_b = htask->last_b;
+ s_task_current->next_b = htask;
+ htask->last_b->next_b = s_task_current;
+ htask->last_b = s_task_current;
+ }
+}
+
+/**
+ \brief 移除从阻塞链表
+ \details 从阻塞链表中移除任务节点。
+ \param[in] htask 任务句柄
+ \return 无
+ */
+void sa_remove_blocklist(s_taskctrl_tsp htask)
+{
+ s_taskctrl_tsp *h2task = (s_taskctrl_tsp *)htask->handle;
+ if(htask == htask->next_b){
+ *h2task = OS_NULL;
+ }
+ else{
+ htask->last_b->next_b = htask->next_b;
+ htask->next_b->last_b = htask->last_b;
+ if(htask == *h2task){
+ *h2task = htask->next_b;
+ }
+ }
+// htask->last_b =
+ htask->next_b = OS_NULL;
+}
+
+/**
+ \brief 插入至定时器链表
+ \details 任务节点插入至定时器链表尾。
+ \param[in] htask 任务句柄
+ \param[in] tick 滴答周期（阻塞时间）
+ \return 无
+ */
+void sa_insert_timerlist(s_taskctrl_tsp htask, s_delay_t tick)
+{
+ s_u8_t m = tick & (OS_TIMESLOTNUM - 1UL);
+ s_u8_t i =
+ htask->timer.slots = (s_timer_pointer + m) & (OS_TIMESLOTNUM - 1UL);
+ htask->timer.cycle = (tick >> OS_TIMESLOTBITS) - !m;
+ if(s_timer_list[i] == OS_NULL){
+ s_timer_list[i] = htask->last_t = htask->next_t = htask;
+ }
+ else{
+ htask->last_t = s_timer_list[i]->last_t;
+ htask->next_t = s_timer_list[i];
+ s_timer_list[i]->last_t->next_t = htask;
+ s_timer_list[i]->last_t = htask;
+ }
+}
+
+/**
+ \brief 移除从定时器链表
+ \details 从定时器链表中移除任务节点。
+ \param[in] htask 任务句柄
+ \return 无
+ */
+void sa_remove_timerlist(s_taskctrl_tsp htask)
+{
+ s_u8_t i = htask->timer.slots;
+ if(htask == htask->next_t){
+ s_timer_list[i] = OS_NULL;
+ }
+ else{
+ htask->last_t->next_t = htask->next_t;
+ htask->next_t->last_t = htask->last_t;
+ if(htask == s_timer_list[i]){
+ s_timer_list[i] = htask->next_t;
+ }
+ }
+// htask->last_t =
+ htask->next_t = OS_NULL;
+}
+
+/**
+ \brief 阻塞变浮动
+ \details 阻塞链表中的任务全部由阻塞状态变为浮动状态。
+ \param[in] htask 任务句柄
+ \return 无
+ */
+void sa_block_to_float(s_taskctrl_tsp htask)
+{
+ s_taskctrl_tsp htemp = htask;
+ while(true){
+ if(htemp->status == OS_STATUS_BLOCKED){
+ htemp->status = OS_STATUS_FLOATING;
+ sa_add_ready(htemp);
+ }
+ else if(htemp->status == (OS_STATUS_BLOCKED | OS_STATUS_SUSPENDED)){
+ htemp->status = OS_STATUS_FLOATING | OS_STATUS_SUSPENDED;
+ }
+ #if (SYSCFG_SAMEPRISCHEDULE && SYSCFG_MUTEX == __ENABLED__)
+// if(htemp->blocktype == OS_BLOCKED_MUTEX){
+ htemp->link = OS_NULL;
+// }
+ #endif
+ htemp = htemp->next_b;
+ if(htask == htemp){
+ break;
+ }
+ }
+}
+
+/**
+ \brief 浮动变阻塞
+ \details 阻塞链表中的任务全部由浮动状态变为阻塞状态。
+ \param[in] htask 任务句柄
+ \return 无
+ */
+void sa_float_to_block(s_taskctrl_tsp htask)
+{
+ s_taskctrl_tsp htemp = htask;
+ while(true){
+ if(htemp->status == OS_STATUS_FLOATING){
+ htemp->status = OS_STATUS_BLOCKED;
+ sa_remove_ready(htemp);
+ }
+ else if(htemp->status == (OS_STATUS_FLOATING | OS_STATUS_SUSPENDED)){
+ htemp->status = OS_STATUS_BLOCKED | OS_STATUS_SUSPENDED;
+ }
+ #if (SYSCFG_SAMEPRISCHEDULE && SYSCFG_MUTEX == __ENABLED__)
+// if(htemp->blocktype == OS_BLOCKED_MUTEX){
+ htemp->link = s_task_current;
+// }
+ #endif
+ htemp = htemp->next_b;
+ if(htask == htemp){
+ break;
+ }
+ }
+}
+
+/**
+ \brief 阻塞变就绪
+ \details 阻塞链表中的任务由阻塞状态变为就绪状态。
+ \param[in] htask 任务句柄
+ \return 无
+ */
+void sa_block_to_ready(s_taskctrl_tsp htask)
+{
+ if(htask->status == OS_STATUS_BLOCKED){
+ htask->status = OS_STATUS_READY;
+ sa_add_ready(htask);
+ }
+ else if(htask->status == (OS_STATUS_BLOCKED | OS_STATUS_SUSPENDED)){
+ htask->status = OS_STATUS_READY | OS_STATUS_SUSPENDED;
+ }
+ if(htask->next_t != OS_NULL){
+ sa_remove_timerlist(htask);
+ }
+}
+
+/**
+ \brief 恢复任务
+ \param[in] htask 任务句柄
+ \return 无
+ */
+void sa_resume_task(s_taskctrl_tsp htask)
+{
+ htask->status &= (~OS_STATUS_SUSPENDED & 0xFF);
+ if(htask->status <= OS_STATUS_FLOATING){
+ sa_add_ready(htask);
+ }
+}
+
+/**
+ \brief 挂起任务
+ \param[in] htask 任务句柄
+ \return 无
+ */
+void sa_suspend_task(s_taskctrl_tsp htask)
+{
+ if(htask->status <= OS_STATUS_FLOATING){
+ sa_remove_ready(htask);
+ }
+ htask->status |= OS_STATUS_SUSPENDED;
+}
+
+/**
+ \brief 停止任务
+ \param[in] htask 任务句柄
+ \return 无
+ */
+__NOINLINE void sa_stop_task(s_taskctrl_tsp htask)
+{
+ if(htask->status <= OS_STATUS_FLOATING){
+ sa_remove_ready(htask);
+ }
+ htask->status = OS_STATUS_STOPPED;
+ if(htask->next_b != OS_NULL){
+ sa_remove_blocklist(htask);
+ }
+ if(htask->next_t != OS_NULL){
+ sa_remove_timerlist(htask);
+ }
+}
+
+/**
+ \brief 释放任务内存
+ \details 动态创建的任务被删除，需释放相应的动态内存。
+ \param[in] htask 任务句柄
+ \return 无
+ */
+__NOINLINE void sa_free_task(s_taskctrl_tsp htask)
+{
+ s_free(htask->bsp);
+ *htask->h2task = OS_NULL;
+ s_free(htask);
+}
+
+/**
+ \brief 删除任务
+ \param[in] htask 任务句柄
+ \return 无
+ */
+__NOINLINE void sa_delete_task(s_taskctrl_tsp htask)
+{
+ if(htask->status <= OS_STATUS_FLOATING){
+ sa_remove_ready(htask);
+ }
+ htask->status = OS_STATUS_DELETED;
+ if(htask->next_b != OS_NULL){
+ sa_remove_blocklist(htask);
+ }
+ if(htask->next_t != OS_NULL){
+ sa_remove_timerlist(htask);
+ }
+ sa_remove_taskque(htask);
+ s_task_queue_count--;
+ if(htask->create){
+ sa_free_task(htask);
+ }
+}
+
+/**
+ \brief 重置任务
+ \param[in] htask 任务句柄
+ \param[in] status 任务初始状态
+ \return 无
+ */
+void sa_reset_task(s_taskctrl_tsp htask, s_u8_t status)
+{
+ if(htask->status <= OS_STATUS_FLOATING){
+ sa_remove_ready(htask);
+ }
+ if(htask->next_b != OS_NULL){
+ sa_remove_blocklist(htask);
+ }
+ if(htask->next_t != OS_NULL){
+ sa_remove_timerlist(htask);
+ }
+ if(htask->opri != htask->pri){
+ sa_remove_taskque(htask);
+ if(htask->opri <= (s_u8_t)(SYSCFG_TASKPRIORITY - 1)){
+ htask->pri = htask->opri;
+ }
+ else{
+ htask->pri = SYSCFG_TASKPRIORITY - 1;
+ }
+ sa_insert_taskque(htask);
+ }
+ #define node_news htask
+ mTaskStack_Reset();
+ #undef node_news
+ htask->status = status;
+ htask->blocktype = 0;
+ htask->handle = OS_NULL;
+ htask->timer.slots = 0;
+ htask->timer.cycle = 0;
+ #if (SYSCFG_SAMEPRISCHEDULE == __COOPERATIVE__)
+ htask->yield = false;
+ #elif (SYSCFG_SAMEPRISCHEDULE == __TIMESHARING__)
+ htask->tc_counter = 0;
+ #endif
+ #if (SYSCFG_DEBUGGING == __ENABLED__)
+ htask->usedtime[0] = 0;
+ htask->usedtime[1] = 0;
+ #endif
+ #if (SYSCFG_SAFERUNTIME == __ENABLED__)
+ htask->srt_counter = 0;
+ #endif
+// htask->last_b = OS_NULL;
+ htask->next_b = OS_NULL;
+// htask->last_t = OS_NULL;
+ htask->next_t = OS_NULL;
+ #if (SYSCFG_SAMEPRISCHEDULE && SYSCFG_MUTEX == __ENABLED__)
+ htask->link = OS_NULL;
+ #endif
+ if(status == OS_STATUS_READY){
+ sa_add_ready(htask);
+ }
+}
+
+/**
+ \brief 清除阻塞（状态）
+ \param[in] htask 任务句柄
+ \return 无
+ */
+void sa_clear_block(s_taskctrl_tsp htask)
+{
+ if(htask->status == OS_STATUS_BLOCKED){
+ sa_add_ready(htask);
+ }
+ htask->status = OS_STATUS_READY;
+ if(htask->next_b != OS_NULL){
+ sa_remove_blocklist(htask);
+ }
+ if(htask->next_t != OS_NULL){
+ sa_remove_timerlist(htask);
+ }
+}
+
+/**
+ \brief 设置阻塞（时间）
+ \param[in] htask 任务句柄
+ \param[in] tick 滴答周期（阻塞时间）
+ +0：清除阻塞
+ ~0：无限阻塞
+ \return 无
+ */
+void sa_set_block(s_taskctrl_tsp htask, s_delay_t tick)
+{
+ if(!tick){
+ sa_clear_block(htask);
+ }
+ else{
+ if(htask->next_t != OS_NULL){
+ sa_remove_timerlist(htask);
+ }
+ if(~tick){
+ sa_insert_timerlist(htask, tick);
+ }
+ }
+}
+
+/**
+ \brief 设置任务优先级
+ \param[in] htask 任务句柄
+ \param[in] npri 新优先级
+ \return 无
+ */
+void sa_set_taskpri(s_taskctrl_tsp htask, s_u8_t npri)
+{
+ sa_remove_taskque(htask);
+ if(htask->status <= OS_STATUS_FLOATING){
+ sa_remove_ready(htask);
+ htask->pri = npri;
+ sa_add_ready(htask);
+ }
+ else{
+ htask->pri = npri;
+ }
+ sa_insert_taskque(htask);
+}
+
+/**
+ \brief 清除就绪延时
+ \param 无
+ \return 无
+ */
+void sc_clear_delay(void)
+{
+ if(s_sign_delay){
+ s_sign_delay = false;
+ if(s_task_current->next_t != OS_NULL){
+ sa_remove_timerlist(s_task_current);
+ }
+ }
+}
+
+/**
+ \brief 恢复任务
+ \param[in] htask 任务句柄
+ \return 错误码
+ */
+s_ecode_t sc_resume_task(s_taskctrl_tsp htask)
+{
+ if(htask == OS_NULL){
+ return OS_ECODE_TASKNOTSTARTED;
+ }
+ if(htask->status & OS_STATUS_SUSPENDED){
+ sa_resume_task(htask);
+ return OS_ECODE_NOERROR;
+ }
+ if(htask->status < OS_STATUS_STOPPED){
+ return OS_ECODE_TASKNOTSUSPENDED;
+ }
+ if(htask->status == OS_STATUS_STOPPED){
+ return OS_ECODE_TASKSTOPPED;
+ }
+ if(htask->status == OS_STATUS_DELETED){
+ return OS_ECODE_TASKNOTSTARTED;
+ }
+ else{
+ return OS_ECODE_DONOTKNOW;
+ }
+}
+
+/**
+ \brief 挂起任务
+ \param[in] htask 任务句柄
+ \return 错误码
+ */
+s_ecode_t sc_suspend_task(s_taskctrl_tsp htask)
+{
+ if(htask == OS_NULL){
+ return OS_ECODE_TASKNOTSTARTED;
+ }
+ if(htask->status < OS_STATUS_SUSPENDED){
+ sa_suspend_task(htask);
+ return OS_ECODE_NOERROR;
+ }
+ if(htask->status & OS_STATUS_SUSPENDED){
+ return OS_ECODE_TASKSUSPENDED;
+ }
+ if(htask->status == OS_STATUS_STOPPED){
+ return OS_ECODE_TASKSTOPPED;
+ }
+ if(htask->status == OS_STATUS_DELETED){
+ return OS_ECODE_TASKNOTSTARTED;
+ }
+ else{
+ return OS_ECODE_DONOTKNOW;
+ }
+}
+
+/**
+ \brief 删除任务
+ \param[in] htask 任务句柄
+ \return 错误码
+ */
+s_ecode_t sc_delete_task(s_taskctrl_tsp htask)
+{
+ if(htask == OS_NULL){
+ return OS_ECODE_TASKNOTSTARTED;
+ }
+ if(htask->status < OS_STATUS_DELETED){
+ sa_delete_task(htask);
+ return OS_ECODE_NOERROR;
+ }
+ if(htask->status == OS_STATUS_DELETED){
+ return OS_ECODE_TASKNOTSTARTED;
+ }
+ else{
+ return OS_ECODE_DONOTKNOW;
+ }
+}
+
+/**
+ \brief 重置任务
+ \param[in] htask 任务句柄
+ \param[in] status 任务初始状态
+ \return 错误码
+ */
+s_ecode_t sc_reset_task(s_taskctrl_tsp htask, s_u8_t status)
+{
+ if(htask == OS_NULL){
+ return OS_ECODE_TASKNOTSTARTED;
+ }
+ if(htask->status < OS_STATUS_DELETED){
+ sa_reset_task(htask, status);
+ return OS_ECODE_NOERROR;
+ }
+ if(htask->status == OS_STATUS_DELETED){
+ return OS_ECODE_TASKNOTSTARTED;
+ }
+ else{
+ return OS_ECODE_DONOTKNOW;
+ }
+}
+
+/**
+ \brief 清除阻塞（状态）
+ \param[in] htask 任务句柄
+ \return 错误码
+ */
+s_ecode_t sc_clear_block(s_taskctrl_tsp htask)
+{
+ if(htask == OS_NULL){
+ return OS_ECODE_TASKNOTSTARTED;
+ }
+ if(htask->status == OS_STATUS_FLOATING || htask->status == OS_STATUS_BLOCKED){
+ sa_clear_block(htask);
+ return OS_ECODE_NOERROR;
+ }
+ else{
+ return OS_ECODE_TASKNOTBLOCKED;
+ }
+}
+
+/**
+ \brief 设置阻塞（时间）
+ \param[in] htask 任务句柄
+ \param[in] tick 滴答周期（阻塞时间）
+ +0：清除阻塞
+ ~0：无限阻塞
+ \return 错误码
+ */
+s_ecode_t sc_set_block(s_taskctrl_tsp htask, s_delay_t tick)
+{
+ if(htask == OS_NULL){
+ return OS_ECODE_TASKNOTSTARTED;
+ }
+ if(htask->status == OS_STATUS_FLOATING || htask->status == OS_STATUS_BLOCKED){
+ sa_set_block(htask, tick);
+ return OS_ECODE_NOERROR;
+ }
+ else{
+ return OS_ECODE_TASKNOTBLOCKED;
+ }
+}
+
+/**
+ \brief 设置任务优先级
+ \param[in] htask 任务句柄
+ \param[in] npri 新优先级
+ \return 错误码
+ */
+s_ecode_t sc_set_taskpri(s_taskctrl_tsp htask, s_u8_t npri)
+{
+ if(htask == OS_NULL){
+ return OS_ECODE_TASKNOTSTARTED;
+ }
+ if(htask->status < OS_STATUS_STOPPED){
+ if(htask->pri != npri){
+ sa_set_taskpri(htask, npri);
+ return OS_ECODE_NOERROR;
+ }
+ else{
+ return OS_ECODE_TASKPRIUNCHANGED;
+ }
+ }
+ if(htask->status == OS_STATUS_STOPPED){
+ return OS_ECODE_TASKSTOPPED;
+ }
+ if(htask->status == OS_STATUS_DELETED){
+ return OS_ECODE_TASKNOTSTARTED;
+ }
+ else{
+ return OS_ECODE_DONOTKNOW;
+ }
+}
+
+#if (SYSCFG_BINARY == __ENABLED__)
+/**
+ \brief 写二值信号量
+ \param[in] hbin 二值信号量句柄
+ \param[in] value
+ 0：上锁
+ 1：给予
+ \return 无
+ */
+void sc_write_binary(s_binary_tsp hbin, bool value)
+{
+ hbin->binary = value;
+ if(!value) return;
+ if(hbin->htask != OS_NULL){
+ sa_block_to_float(hbin->htask);
+ }
+}
+#endif
+
+#if (SYSCFG_SEMAPHORE == __ENABLED__)
+/**
+ \brief 给予计数信号量
+ \param[in] hsem 计数信号量句柄
+ \return 无
+ */
+void sc_give_semaph(s_semaph_tsp hsem)
+{
+ s_semaph_t counter = hsem->counter;
+ if(counter < hsem->maximum){
+ hsem->counter = counter + 1;
+ }
+ if(!counter && hsem->htask != OS_NULL){
+ sa_block_to_float(hsem->htask);
+ }
+}
+#endif
+
+#if (SYSCFG_FETION == __ENABLED__)
+/**
+ \brief 发送飞信
+ \param[in] htbox 信箱句柄
+ \param[in] tion 飞信
+ \return 无
+ */
+void sc_send_fetion(s_tionbox_tsp htbox, m_fetion_t tion)
+{
+ s_taskctrl_tsp htask = htbox->htask;
+ htbox->tion = tion;
+ if(htask != OS_NULL){
+ sa_block_to_ready(htask);
+ htbox->htask =
+// htask->last_b =
+ htask->next_b = OS_NULL;
+ }
+}
+#endif
+
+#if (SYSCFG_MAILBOX == __ENABLED__)
+/**
+ \brief 发送邮件
+ \param[in] hmbox 邮箱句柄
+ \param[in] mail 邮件指针
+ \return 无
+ */
+void sc_send_mail(s_mailbox_tsp hmbox, void *mail)
+{
+ s_taskctrl_tsp htask = hmbox->htask;
+ hmbox->flag = false;
+ __mx_MMB();
+ hmbox->mail = mail;
+ __mx_MMB();
+ hmbox->flag = true;
+ if(htask != OS_NULL){
+ sa_block_to_ready(htask);
+ hmbox->htask =
+// htask->last_b =
+ htask->next_b = OS_NULL;
+ }
+}
+#endif
+
+#if (SYSCFG_MSGQUEUE == __ENABLED__)
+/**
+ \brief 发送消息
+ \param[in] hque 队列句柄
+ \param[in] msg 消息指针
+ \return 错误码
+ */
+s_ecode_t sc_send_msg(s_msgque_tsp hque, void *msg)
+{
+ s_taskctrl_tsp htask;
+ #if (SYSCFG_MSGQUEUE_INTRECV == __ENABLED__)
+ hque->lock = false;
+ __mx_MMB();
+ #endif
+ if(hque->counter == hque->len){
+ #if (SYSCFG_DEBUGGING == __ENABLED__)
+ s_alarm.overflow_msgqueue = true;
+ #endif
+ #if (SYSCFG_MSGQUEUE_INTRECV == __ENABLED__)
+ __mx_MMB();
+ hque->lock = true;
+ #endif
+ return OS_ECODE_OVERFLOW_MSGQUEUE;
+ }
+ if(hque->type == __DYNAMIC__){
+ s_msgnode_tsp hmsg = OS_NULL;
+ hmsg = (s_msgnode_tsp)s_malloc(sizeof(s_msgnode_ts));
+ if(hmsg == OS_NULL){
+ #if (SYSCFG_DEBUGGING == __ENABLED__)
+ s_fault.mallocfailed_msgnode = true;
+ #endif
+ #if (SYSCFG_MSGQUEUE_INTRECV == __ENABLED__)
+ __mx_MMB();
+ hque->lock = true;
+ #endif
+ return OS_ECODE_MALLOCFAIL_MSGNODE;
+ }
+ hmsg->msg = msg;
+ hmsg->next = OS_NULL;
+ hmsg->last = ((s_dynque_tsp)hque)->tail;
+ if(((s_dynque_tsp)hque)->tail != OS_NULL){
+ ((s_dynque_tsp)hque)->tail->next = hmsg;
+ }
+ ((s_dynque_tsp)hque)->tail = hmsg;
+ if(((s_dynque_tsp)hque)->head == OS_NULL){
+ ((s_dynque_tsp)hque)->head = hmsg;
+ }
+ }
+ else{
+ if(((s_staque_tsp)hque)->tail < ((s_staque_tsp)hque)->base + hque->len - 1){
+ ((s_staque_tsp)hque)->tail++;
+ }
+ else{
+ ((s_staque_tsp)hque)->tail = ((s_staque_tsp)hque)->base;
+ }
+ *((s_staque_tsp)hque)->tail = msg;
+ }
+ hque->counter++;
+ htask = hque->htask;
+ if(htask != OS_NULL){
+ sa_block_to_ready(htask);
+ hque ->htask =
+// htask->last_b =
+ htask->next_b = OS_NULL;
+ }
+ #if (SYSCFG_MSGQUEUE_INTRECV == __ENABLED__)
+ __mx_MMB();
+ hque->lock = true;
+ #endif
+ return OS_ECODE_NOERROR;
+}
+
+/**
+ \brief 接收消息（静态队列）
+ \param[in] hque 队列句柄
+ \return 消息指针
+ \note 本页中唯一一个还有可能被中断本地服务调用的公共函数。
+ */
+void *sc_recv_msg_staque(s_staque_tsp hque)
+{
+ void *msg;
+ if(hque->mode == __QUE_LIFO__){
+ msg = *hque->tail;
+ if(hque->tail > hque->base){
+ hque->tail--;
+ }
+ else{
+ hque->tail = hque->base + hque->len - 1;
+ }
+ }
+ else{
+ msg = *hque->head;
+ if(hque->head < hque->base + hque->len - 1){
+ hque->head++;
+ }
+ else{
+ hque->head = hque->base;
+ }
+ }
+ hque->counter--;
+ return msg;
+}
+
+/**
+ \brief 接收消息（动态队列）
+ \param[in] hque 队列句柄
+ \return 消息指针
+ */
+void *sc_recv_msg_dynque(s_dynque_tsp hque)
+{
+ void *msg;
+ s_msgnode_tsp hmsg;
+ if(hque->mode == __QUE_LIFO__){
+ hmsg = hque->tail;
+ msg = hmsg->msg;
+ hmsg = hmsg->last;
+ s_free(hque->tail);
+ hque->tail = hmsg;
+ if(hmsg == OS_NULL){
+ hque->head = OS_NULL;
+ }
+ else{
+ hmsg->next = OS_NULL;
+ }
+ }
+ else{
+ hmsg = hque->head;
+ msg = hmsg->msg;
+ hmsg = hmsg->next;
+ s_free(hque->head);
+ hque->head = hmsg;
+ if(hmsg == OS_NULL){
+ hque->tail = OS_NULL;
+ }
+ else{
+ hmsg->last = OS_NULL;
+ }
+ }
+ hque->counter--;
+ return msg;
+}
+#endif
+
+#if (OS_TIMINTTOTAL > 0)
+/**
+ \brief 定时中断
+ \param[in] tmid 定时中断定时器ID
+ \param[in] tick 滴答周期（定时时间）
+ \return 无
+ */
+void sc_timint(s_u8_t tmid, s_timint_t tick)
+{
+ s_timint_handle[tmid]->timer
+ = s_timint_handle[tmid]->reload
+ = tick;
+}
+#endif
+
+#if (OS_TIMQRYTOTAL > 0)
+/**
+ \brief 定时查询
+ \param[in] tmid 定时查询定时器ID
+ \param[in] tick 滴答周期（定时时间）
+ \return 无
+ */
+void sc_timqry(s_u8_t tmid, s_timqry_t tick)
+{
+ s_timqry_handle[tmid]->timer
+ = s_timqry_handle[tmid]->reload
+ = tick;
+}
+#endif
diff --git a/System/sv_com.h b/System/sv_com.h
new file mode 100644
index 00000000..03479e15
--- /dev/null
+++ b/System/sv_com.h
@@ -0,0 +1,54 @@
+/**************************************************************************//**
+ * @item CosyOS-III Kernel
+ * @file sv_com.h
+ * @brief 内核公共服务
+ * @details 在服务层临界区中调用并执行。
+ * @author 迟凯峰
+ * @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_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_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);
+void sc_send_mail (s_mailbox_tsp hmbox, void *mail);
+s_ecode_t sc_send_msg (s_msgque_tsp hque, void *msg);
+void *sc_recv_msg_staque (s_staque_tsp hque);
+void *sc_recv_msg_dynque (s_dynque_tsp hque);
+void sc_timint (s_u8_t tmid, s_timint_t tick);
+void sc_timqry (s_u8_t tmid, s_timqry_t tick);
+
+#endif
diff --git a/System/sv_create.h b/System/sv_create.h
new file mode 100644
index 00000000..899f5a67
--- /dev/null
+++ b/System/sv_create.h
@@ -0,0 +1,308 @@
+/**************************************************************************//**
+ * @item CosyOS-III Kernel
+ * @file sv_create.h
+ * @brief 创建服务
+ * @details 用于创建 CosyOS 内核对象。
+ * @author 迟凯峰
+ * @version v3.0.0
+ * @date 2026.07.21
+ ******************************************************************************/
+
+#ifndef __SV_CREATE_H
+#define __SV_CREATE_H
+
+/**
+ @addtogroup CosyOS_内核服务
+ @{
+ *//**
+ \defgroup 创建服务
+ \brief 用于创建 CosyOS 内核对象。
+ @{
+ */
+
+/*
+ * 声明任务
+ */
+
+/** 简化声明静态任务 */
+#define sCSV_ExtTask(name) \
+ extern s_taskctrl_ts u_taskload_##name; \
+ void u_task_##name
+
+/** 简化声明动态任务 */
+#define dCSV_ExtTask(name) \
+ extern s_taskload_ts u_taskload_##name; \
+ void u_task_##name
+
+/** 完整声明静态任务 */
+#define sCSV_ExternTask(name) \
+ extern s_taskctrl_tsp name; \
+ sCSV_ExtTask(name)
+
+/** 完整声明动态任务 */
+#define dCSV_ExternTask(name) \
+ extern s_taskctrl_tsp name; \
+ dCSV_ExtTask(name)
+
+
+/*
+ * 创建任务
+ */
+
+#if (SYSCFG_DEBUGGING == __ENABLED__)
+ #if (SYSCFG_SAFERUNTIME == __ENABLED__)
+ /** 静态创建，启用 DEBUGGING，启用 安全运行时 */
+ #define sCSV_CreateTask_0(name, pri, tss, srt, res, ety) \
+ s_taskctrl_ts u_taskload_##name = {0, pri, tss, &name, ety, res, srt, u_taskstack_##name, 0, OS_STATUS_DELETED}
+ #else /** 静态创建，启用 DEBUGGING，禁用 安全运行时 */
+ #define sCSV_CreateTask_0(name, pri, tss, srt, res, ety) \
+ s_taskctrl_ts u_taskload_##name = {0, pri, tss, &name, ety, res, u_taskstack_##name, 0, OS_STATUS_DELETED}
+ #endif
+#else
+ #if (SYSCFG_SAFERUNTIME == __ENABLED__)
+ /** 静态创建，禁用 DEBUGGING，启用 安全运行时 */
+ #define sCSV_CreateTask_0(name, pri, tss, srt, res, ety) \
+ s_taskctrl_ts u_taskload_##name = {0, pri, tss, &name, ety, srt, u_taskstack_##name, 0, OS_STATUS_DELETED}
+ #else /** 静态创建，禁用 DEBUGGING，禁用 安全运行时 */
+ #define sCSV_CreateTask_0(name, pri, tss, srt, res, ety) \
+ s_taskctrl_ts u_taskload_##name = {0, pri, tss, &name, ety, u_taskstack_##name, 0, OS_STATUS_DELETED}
+ #endif
+#endif
+#if (SYSCFG_DEBUGGING == __ENABLED__)
+ #if (SYSCFG_SAFERUNTIME == __ENABLED__)
+ /** 动态创建，启用 DEBUGGING，启用 安全运行时 */
+ #define dCSV_CreateTask_0(name, pri, tss, srt, res, ety) \
+ s_taskload_ts u_taskload_##name = {0, pri, tss, &name, ety, res, srt}
+ #else /** 动态创建，启用 DEBUGGING，禁用 安全运行时 */
+ #define dCSV_CreateTask_0(name, pri, tss, srt, res, ety) \
+ s_taskload_ts u_taskload_##name = {0, pri, tss, &name, ety, res}
+ #endif
+#else
+ #if (SYSCFG_SAFERUNTIME == __ENABLED__)
+ /** 动态创建，禁用 DEBUGGING，启用 安全运行时 */
+ #define dCSV_CreateTask_0(name, pri, tss, srt, res, ety) \
+ s_taskload_ts u_taskload_##name = {0, pri, tss, &name, ety, srt}
+ #else /** 动态创建，禁用 DEBUGGING，禁用 安全运行时 */
+ #define dCSV_CreateTask_0(name, pri, tss, srt, res, ety) \
+ s_taskload_ts u_taskload_##name = {0, pri, tss, &name, ety}
+ #endif
+#endif
+
+/** 静态创建一般任务 */
+#define sCSV_CreateTask(name, pri, tss, srt, res) \
+ void u_task_##name(void); \
+ s_taskctrl_ts u_taskload_##name; \
+ s_taskctrl_tsp name = &u_taskload_##name; \
+ MCUCFG_STACK_ALIGN static s_u8_t u_taskstack_##name[tss]; \
+ sCSV_CreateTask_0(name, pri, tss, srt, res, u_task_##name); \
+ void u_task_##name(void) MCUCFG_TASK_ATTRIBUTE
+
+/** 动态创建一般任务 */
+#define dCSV_CreateTask(name, pri, tss, srt, res) \
+ void u_task_##name(void); \
+ s_taskctrl_tsp name = OS_NULL; \
+ dCSV_CreateTask_0(name, pri, tss, srt, res, u_task_##name); \
+ void u_task_##name(void) MCUCFG_TASK_ATTRIBUTE
+
+/** 静态创建私信任务 */
+#define sCSV_CreateTaskmsg(name, pri, tss, srt, res, ntm) \
+ s_taskctrl_ts u_taskload_##name; \
+ s_taskctrl_tsp name = &u_taskload_##name; \
+ MCUCFG_STACK_ALIGN static s_u8_t u_taskstack_##name[tss]; \
+ sCSV_CreateTask_0(name, pri, tss, srt, res, OS_NULL); \
+ void u_task_##name sCreateTaskMsg_##ntm
+
+/** 动态创建私信任务 */
+#define dCSV_CreateTaskmsg(name, pri, tss, srt, res, ntm) \
+ s_taskctrl_tsp name = OS_NULL; \
+ dCSV_CreateTask_0(name, pri, tss, srt, res, OS_NULL); \
+ void u_task_##name sCreateTaskMsg_##ntm
+
+/** for 定时任务 */
+#if defined ( __GNUC__ )
+#define s_hookorload_load(p) .load=(s_taskload_tsp)p
+#define s_hookorload_hook(p) .hook=p
+#else
+#define s_hookorload_load(p) (s_voidvoid_tfp)p
+#define s_hookorload_hook(p) p
+#endif
+#define OS_TIMQRYINIT (s_timqry_t)(SYSCFG_USERTIMQRYINIT - 1) /*!< 定时查询初始值 */
+
+/** 静态创建定时中断任务 */
+#define sCSV_CreateTask_TimInt(tmid, arl, name, pri, tss, srt, res) \
+ s_taskctrl_ts u_taskload_##name; \
+ s_timinthand_ts _STATIC_MEM_ u_timinthand_##tmid = {0, 0, arl, 1, {s_hookorload_load(&u_taskload_##name)}}; \
+ sCSV_CreateTask(name, pri, tss, srt, res)
+
+/** 动态创建定时中断任务 */
+#define dCSV_CreateTask_TimInt(tmid, arl, name, pri, tss, srt, res) \
+ s_taskload_ts u_taskload_##name; \
+ s_timinthand_ts _STATIC_MEM_ u_timinthand_##tmid = {0, 0, arl, 1, {s_hookorload_load(&u_taskload_##name)}}; \
+ dCSV_CreateTask(name, pri, tss, srt, res)
+
+/** 静态创建定时查询任务 */
+#define sCSV_CreateTask_TimQry(tmid, event, arl, name, pri, tss, srt, res) \
+ bool u_timqryevent_##tmid(void) MCUCFG_OSIT_ATTRIBUTE {return (event ? true : false);} \
+ s_taskctrl_ts u_taskload_##name; \
+ s_timqryhand_ts _STATIC_MEM_ u_timqryhand_##tmid = {OS_TIMQRYINIT, OS_TIMQRYINIT, arl, 1, {s_hookorload_load(&u_taskload_##name)}, u_timqryevent_##tmid}; \
+ sCSV_CreateTask(name, pri, tss, srt, res)
+
+/** 动态创建定时查询任务 */
+#define dCSV_CreateTask_TimQry(tmid, event, arl, name, pri, tss, srt, res) \
+ bool u_timqryevent_##tmid(void) MCUCFG_OSIT_ATTRIBUTE {return (event ? true : false);} \
+ s_taskload_ts u_taskload_##name; \
+ s_timqryhand_ts _STATIC_MEM_ u_timqryhand_##tmid = {OS_TIMQRYINIT, OS_TIMQRYINIT, arl, 1, {s_hookorload_load(&u_taskload_##name)}, u_timqryevent_##tmid}; \
+ dCSV_CreateTask(name, pri, tss, srt, res)
+
+
+/*
+ * 创建钩子
+ */
+
+/** 创建定时中断钩子 */
+#define sCSV_CreateHook_TimInt(tmid, arl) \
+ void u_timint_##tmid(void); \
+ s_timinthand_ts _STATIC_MEM_ u_timinthand_##tmid = {0, 0, arl, 0, {s_hookorload_hook(u_timint_##tmid)}}; \
+ void u_timint_##tmid(void) MCUCFG_OSIT_ATTRIBUTE
+
+/** 创建定时查询钩子 */
+#define sCSV_CreateHook_TimQry(tmid, event, arl) \
+ void u_timqry_##tmid(void); \
+ bool u_timqryevent_##tmid(void) MCUCFG_OSIT_ATTRIBUTE {return (event ? true : false);} \
+ s_timqryhand_ts _STATIC_MEM_ u_timqryhand_##tmid = {OS_TIMQRYINIT, OS_TIMQRYINIT, arl, 0, {s_hookorload_hook(u_timqry_##tmid)}, u_timqryevent_##tmid}; \
+ void u_timqry_##tmid(void) MCUCFG_OSIT_ATTRIBUTE
+
+
+/*
+ * 互斥信号量
+ */
+
+/** 声明互斥信号量 */
+#define sCSV_ExternMut(name) \
+ extern s_mutex_ts name
+
+/** 创建互斥信号量并初始化 */
+#define sCSV_CreateMut(name) \
+ s_mutex_ts name = {0}
+
+/** 创建互斥信号量不初始化 */
+#define sCSV_CreateMut_NotInit(name) \
+ s_mutex_ts name
+
+
+/*
+ * 二值信号量
+ */
+
+/** 声明二值信号量 */
+#define sCSV_ExternBin(name) \
+ extern s_binary_ts name
+
+/** 创建二值信号量并初始化 */
+#define sCSV_CreateBin(name, init) \
+ s_binary_ts name = {OS_NULL, init}
+
+/** 创建二值信号量不初始化 */
+#define sCSV_CreateBin_NotInit(name) \
+ s_binary_ts name
+
+
+/*
+ * 计数信号量
+ */
+
+/** 声明计数信号量 */
+#define sCSV_ExternSem(name) \
+ extern s_semaph_ts name
+
+/** 创建计数信号量并初始化 */
+#define sCSV_CreateSem(name, init, max) \
+ s_semaph_ts name = {OS_NULL, init, max}
+
+/** 创建计数信号量不初始化 */
+#define sCSV_CreateSem_NotInit(name) \
+ s_semaph_ts name
+
+
+/*
+ * 飞信
+ */
+
+/** 声明信箱 */
+#define sCSV_ExternTionbox(name) \
+ extern s_tionbox_ts name
+
+/** 创建信箱并初始化 */
+#define sCSV_CreateTionbox(name) \
+ s_tionbox_ts name = {0}
+
+/** 创建信箱不初始化 */
+#define sCSV_CreateTionbox_NotInit(name) \
+ s_tionbox_ts name
+
+
+/*
+ * 邮箱
+ */
+
+/** 声明邮箱 */
+#define sCSV_ExternMailbox(name) \
+ extern s_mailbox_ts name
+
+/** 创建邮箱并初始化 */
+#define sCSV_CreateMailbox(name) \
+ s_mailbox_ts name = {0}
+
+/** 创建邮箱不初始化 */
+#define sCSV_CreateMailbox_NotInit(name) \
+ s_mailbox_ts name
+
+
+/*
+ * 消息队列
+ */
+
+/** 声明静态队列 */
+#define sCSV_ExternQueue_Static(name) \
+ extern s_staque_ts name
+
+/** 声明动态队列 */
+#define sCSV_ExternQueue_Dynamic(name) \
+ extern s_dynque_ts name
+
+/** 创建静态队列 */
+#define sCSV_CreateQueue_Static(name, mode, len) \
+ void *u_queue_##name[len]; \
+ s_staque_ts name = {OS_NULL, true, 0, __STATIC__, mode, len, u_queue_##name, u_queue_##name + len - 1, u_queue_##name}
+
+/** 创建动态队列 */
+#define sCSV_CreateQueue_Dynamic(name, mode, len) \
+ s_dynque_ts name = {OS_NULL, true, 0, __DYNAMIC__, mode, len, OS_NULL, OS_NULL}
+
+
+/*
+ * 事件标志组（必须声明）
+ */
+
+/** 声明标志组 */
+#define sCSV_ExternFlagGroup(name, bits) \
+ typedef struct{bits}u_##name##_ts; \
+ extern u_##name##_ts volatile name
+
+/** 创建标志组 */
+#define sCSV_CreateFlagGroup(name) \
+ u_##name##_ts volatile name
+
+
+/*
+ * 线程内存
+ */
+
+/** 创建线程内存池 */
+#define sCSV_CreateMempool() \
+ static s_thrmem_ts u_thrmem = {0}
+
+/** @} */
+/** @} */
+
+#endif
diff --git a/System/sv_int_fifo.c b/System/sv_int_fifo.c
new file mode 100644
index 00000000..8ec8591b
--- /dev/null
+++ b/System/sv_int_fifo.c
@@ -0,0 +1,627 @@
+/**************************************************************************//**
+ * @item CosyOS-III Kernel
+ * @file sv_int_fifo.c
+ * @brief 中断FIFO服务-执行函数
+ * @details 仅在 PendSV中断 中由系统调用并执行。
+ * @author 迟凯峰
+ * @version v3.0.0
+ * @date 2026.07.21
+ ******************************************************************************/
+
+#include "os_var.h"
+#if (SYSCFG_PENDSVFIFO_DEPTH > 0)
+#include "os_api.h"
+#include "sv_com.h"
+#include "ur_api.h"
+
+/**
+ @addtogroup 中断FIFO服务
+ @{
+ *//**
+ \defgroup 中断FIFO服务-执行函数
+ @{
+ */
+
+/**
+ \page 手动裁剪说明：
+
+ \li 本页中的各个执行函数，任何编译器都无法自动移除未使用，原因是
+ 它们是通过函数指针间接调用的。
+
+ \li 如果您希望做到极致的裁剪，可逐一查看这些函数，确定不使用的，
+ 可通过 编译开关 进行手动移除。
+ */
+
+/**
+ \brief 清除就绪延时
+ \param[in] sv 服务的结构体指针
+ \return 无
+ \note 关联服务：iClearDelay()。
+ */
+#if 1 /* 编译开关 *//* 如果用户不会调用关联服务，可手动移除该函数（1 改为 0）*/
+static void _clear_delay_(void _STATIC_MEM_ *sv) MCUCFG_OSIT_ATTRIBUTE
+{
+ __UNUSED(sv);
+ sc_clear_delay();
+}
+#else
+#define _clear_delay_ OS_NULL
+#endif
+
+/**
+ \brief 恢复任务
+ \param[in] sv 服务的结构体指针
+ \return 无
+ \note 关联服务：iResumeTask(task)。
+ */
+#if 1 /* 编译开关 *//* 如果用户不会调用关联服务，可手动移除该函数（1 改为 0）*/
+static void _resume_task_(void _STATIC_MEM_ *sv) MCUCFG_OSIT_ATTRIBUTE
+{
+ s_taskctrl_tsp htask = ((sp_task_tsp)sv)->htask;
+ #if (SYSCFG_PENDSVFIFO_ERRORCALLBACK == __ENABLED__)
+ s_ecode_t _ecode = sc_resume_task(htask);
+ if(_ecode){
+ s_psvfifo_ecode = _ecode;
+ pResumeTask_ErrorCallback(htask);
+ }
+ #else
+ if(htask == OS_NULL) return;
+ if(htask->status & OS_STATUS_SUSPENDED){
+ sa_resume_task(htask);
+ }
+ #endif
+}
+#else
+#define _resume_task_ OS_NULL
+#endif
+
+/**
+ \brief 挂起任务
+ \param[in] sv 服务的结构体指针
+ \return 无
+ \note 关联服务：iSuspendTask(task)。
+ */
+#if 1 /* 编译开关 *//* 如果用户不会调用关联服务，可手动移除该函数（1 改为 0）*/
+static void _suspend_task_(void _STATIC_MEM_ *sv) MCUCFG_OSIT_ATTRIBUTE
+{
+ s_taskctrl_tsp htask = ((sp_task_tsp)sv)->htask;
+ #if (SYSCFG_PENDSVFIFO_ERRORCALLBACK == __ENABLED__)
+ s_ecode_t _ecode = sc_suspend_task(htask);
+ if(_ecode){
+ s_psvfifo_ecode = _ecode;
+ pSuspendTask_ErrorCallback(htask);
+ }
+ #else
+ if(htask == OS_NULL) return;
+ if(htask->status < OS_STATUS_SUSPENDED){
+ sa_suspend_task(htask);
+ }
+ #endif
+}
+#else
+#define _suspend_task_ OS_NULL
+#endif
+
+/**
+ \brief 删除任务
+ \param[in] sv 服务的结构体指针
+ \return 无
+ \note 关联服务：iDeleteTask(task)。
+ */
+#if 1 /* 编译开关 *//* 如果用户不会调用关联服务，可手动移除该函数（1 改为 0）*/
+static void _delete_task_(void _STATIC_MEM_ *sv) MCUCFG_OSIT_ATTRIBUTE
+{
+ s_taskctrl_tsp htask = ((sp_task_tsp)sv)->htask;
+ #if (SYSCFG_PENDSVFIFO_ERRORCALLBACK == __ENABLED__)
+ s_ecode_t _ecode = sc_delete_task(htask);
+ if(_ecode){
+ s_psvfifo_ecode = _ecode;
+ pDeleteTask_ErrorCallback(htask);
+ }
+ #else
+ if(htask == OS_NULL) return;
+ if(htask->status < OS_STATUS_DELETED){
+ sa_delete_task(htask);
+ }
+ #endif
+}
+#else
+#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 服务的结构体指针
+ \return 无
+ \note 关联服务：iClearBlock(task)。
+ */
+#if 1 /* 编译开关 *//* 如果用户不会调用关联服务，可手动移除该函数（1 改为 0）*/
+static void _clear_block_(void _STATIC_MEM_ *sv) MCUCFG_OSIT_ATTRIBUTE
+{
+ s_taskctrl_tsp htask = ((sp_task_tsp)sv)->htask;
+ #if (SYSCFG_PENDSVFIFO_ERRORCALLBACK == __ENABLED__)
+ s_ecode_t _ecode = sc_clear_block(htask);
+ if(_ecode){
+ s_psvfifo_ecode = _ecode;
+ pClearBlock_ErrorCallback(htask);
+ }
+ #else
+ if(htask == OS_NULL) return;
+ if(htask->status == OS_STATUS_FLOATING || htask->status == OS_STATUS_BLOCKED){
+ sa_clear_block(htask);
+ }
+ #endif
+}
+#else
+#define _clear_block_ OS_NULL
+#endif
+
+/**
+ \brief 设置阻塞（时间）
+ \param[in] sv 服务的结构体指针
+ \return 无
+ \note 关联服务：iSetBlock_tc(task, tc)、iSetBlock_ms(task, ms)、
+ iSetBlock_s(task, s)、iSetBlock_m(task, m)、iSetBlock_h(task, h)。
+ */
+#if 1 /* 编译开关 *//* 如果用户不会调用关联服务，可手动移除该函数（1 改为 0）*/
+static void _set_block_(void _STATIC_MEM_ *sv) MCUCFG_OSIT_ATTRIBUTE
+{
+ 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);
+ if(_ecode){
+ s_psvfifo_ecode = _ecode;
+ pSetBlock_ErrorCallback(htask, tick);
+ }
+ #else
+ if(htask == OS_NULL) return;
+ if(htask->status == OS_STATUS_FLOATING || htask->status == OS_STATUS_BLOCKED){
+ sa_set_block(htask, tick);
+ }
+ #endif
+}
+#else
+#define _set_block_ OS_NULL
+#endif
+
+/**
+ \brief 设置任务优先级
+ \param[in] sv 服务的结构体指针
+ \return 无
+ \note 关联服务：iSetTaskPri(task, npri)。
+ */
+#if 1 /* 编译开关 *//* 如果用户不会调用关联服务，可手动移除该函数（1 改为 0）*/
+static void _set_taskpri_(void _STATIC_MEM_ *sv) MCUCFG_OSIT_ATTRIBUTE
+{
+ 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);
+ if(_ecode){
+ s_psvfifo_ecode = _ecode;
+ pSetTaskPri_ErrorCallback(htask, npri);
+ }
+ #else
+ if(htask == OS_NULL) return;
+ if(htask->status < OS_STATUS_STOPPED){
+ if(htask->pri != npri){
+ sa_set_taskpri(htask, npri);
+ }
+ }
+ #endif
+}
+#else
+#define _set_taskpri_ OS_NULL
+#endif
+
+/**
+ \brief 写二值信号量
+ \param[in] sv 服务的结构体指针
+ \return 无
+ \note 关联服务：iLockBin(bin)、iGiveBin(bin)。
+ */
+#if 1 /* 编译开关 *//* 如果用户不会调用关联服务，可手动移除该函数（1 改为 0）*/ \
+ && (SYSCFG_BINARY == __ENABLED__)
+static void _write_binary_(void _STATIC_MEM_ *sv) MCUCFG_OSIT_ATTRIBUTE
+{
+ s_binary_tsp hbin = ((sp_binary_tsp)sv)->hbin;
+ bool value = ((sp_binary_tsp)sv)->value;
+ sc_write_binary(hbin, value);
+}
+#else
+#define _write_binary_ OS_NULL
+#endif
+
+/**
+ \brief 给予计数信号量
+ \param[in] sv 服务的结构体指针
+ \return 无
+ \note 关联服务：iGiveSem(sem)。
+ */
+#if 1 /* 编译开关 *//* 如果用户不会调用关联服务，可手动移除该函数（1 改为 0）*/ \
+ && (SYSCFG_SEMAPHORE == __ENABLED__)
+static void _give_semaph_(void _STATIC_MEM_ *sv) MCUCFG_OSIT_ATTRIBUTE
+{
+ s_semaph_tsp hsem = ((sp_semaph_tsp)sv)->hsem;
+ sc_give_semaph(hsem);
+}
+#else
+#define _give_semaph_ OS_NULL
+#endif
+
+/**
+ \brief 发送飞信
+ \param[in] sv 服务的结构体指针
+ \return 无
+ \note 关联服务：iSendFetion(tbox, tion)。
+ */
+#if 1 /* 编译开关 *//* 如果用户不会调用关联服务，可手动移除该函数（1 改为 0）*/ \
+ && (SYSCFG_FETION == __ENABLED__)
+static void _send_fetion_(void _STATIC_MEM_ *sv) MCUCFG_OSIT_ATTRIBUTE
+{
+ s_tionbox_tsp htbox = ((sp_tionbox_tsp)sv)->htbox;
+ m_fetion_t tion = ((sp_tionbox_tsp)sv)->tion;
+ sc_send_fetion(htbox, tion);
+}
+#else
+#define _send_fetion_ OS_NULL
+#endif
+
+/**
+ \brief 发送邮件
+ \param[in] sv 服务的结构体指针
+ \return 无
+ \note 关联服务：iSendMail(mbox, mail)。
+ */
+#if 1 /* 编译开关 *//* 如果用户不会调用关联服务，可手动移除该函数（1 改为 0）*/ \
+ && (SYSCFG_MAILBOX == __ENABLED__)
+static void _send_mail_(void _STATIC_MEM_ *sv) MCUCFG_OSIT_ATTRIBUTE
+{
+ s_mailbox_tsp hmbox = ((sp_mailbox_tsp)sv)->hmbox;
+ void *mail = ((sp_mailbox_tsp)sv)->mail;
+ sc_send_mail(hmbox, mail);
+}
+#else
+#define _send_mail_ OS_NULL
+#endif
+
+/**
+ \brief 发送消息
+ \param[in] sv 服务的结构体指针
+ \return 无
+ \note 关联服务：iSendMsg(que, msg)。
+ */
+#if 1 /* 编译开关 *//* 如果用户不会调用关联服务，可手动移除该函数（1 改为 0）*/ \
+ && (SYSCFG_MSGQUEUE == __ENABLED__)
+static void _send_msg_(void _STATIC_MEM_ *sv) MCUCFG_OSIT_ATTRIBUTE
+{
+ s_msgque_tsp hque = ((sp_msgque_tsp)sv)->hque;
+ void *msg = ((sp_msgque_tsp)sv)->msg;
+ #if (SYSCFG_PENDSVFIFO_ERRORCALLBACK == __ENABLED__)
+ s_ecode_t _ecode = sc_send_msg(hque, msg);
+ if(_ecode){
+ s_psvfifo_ecode = _ecode;
+ pSendMsg_ErrorCallback(hque, msg);
+ }
+ #else
+ sc_send_msg(hque, msg);
+ #endif
+}
+#else
+#define _send_msg_ OS_NULL
+#endif
+
+/**
+ \brief 定时中断
+ \param[in] sv 服务的结构体指针
+ \return 无
+ \note 关联服务：iTimInt_tc(tmid, tc)、iTimInt_ms(tmid, ms)、iTimInt_s(tmid, s)、
+ iTimInt_m(tmid, m)、iTimInt_h(tmid, h)、iTimInt_Cancel(tmid)。
+ */
+#if 1 /* 编译开关 *//* 如果用户不会调用关联服务，可手动移除该函数（1 改为 0）*/ \
+ && (OS_TIMINTTOTAL > 0)
+static void _timint_(void _STATIC_MEM_ *sv) MCUCFG_OSIT_ATTRIBUTE
+{
+ s_u8_t tmid = ((sp_timint_tsp)sv)->tmid;
+ s_timint_t tick = ((sp_timint_tsp)sv)->tick;
+ sc_timint(tmid, tick);
+}
+#else
+#define _timint_ OS_NULL
+#endif
+
+/**
+ \brief 定时查询
+ \param[in] sv 服务的结构体指针
+ \return 无
+ \note 关联服务：iTimQry_tc(tmid, tc)、iTimQry_ms(tmid, ms)、iTimQry_s(tmid, s)、
+ iTimQry_m(tmid, m)、iTimQry_h(tmid, h)、iTimQry_Cancel(tmid)。
+ */
+#if 1 /* 编译开关 *//* 如果用户不会调用关联服务，可手动移除该函数（1 改为 0）*/ \
+ && (OS_TIMQRYTOTAL > 0)
+static void _timqry_(void _STATIC_MEM_ *sv) MCUCFG_OSIT_ATTRIBUTE
+{
+ s_u8_t tmid = ((sp_timqry_tsp)sv)->tmid;
+ s_timqry_t tick = ((sp_timqry_tsp)sv)->tick;
+ sc_timqry(tmid, tick);
+}
+#else
+#define _timqry_ OS_NULL
+#endif
+
+/**
+ \brief 写标志组
+ \param[in] sv 服务的结构体指针
+ \return 无
+ \note 关联服务：iClearFlagGroup(group)、
+ iSetFlagBit(group, bit)、iSetFlagBits(group, nbit) ...)、
+ iClearFlagBit(group, bit)、iClearFlagBits(group, nbit) ...)。
+ */
+#if 1 /* 编译开关 *//* 如果用户不会调用关联服务，可手动移除该函数（1 改为 0）*/ \
+ && (SYSCFG_FLAGGROUP == __ENABLED__)
+static void _write_group_(void _STATIC_MEM_ *sv) MCUCFG_OSIT_ATTRIBUTE
+{
+ switch((s_u8_t)(((sp_group_tsp)sv)->size)){
+ case 0x01: *(s_u8_t *)((sp_group_tsp)sv)->hgrp |= ((sp_group_tsp)sv)->value; break;
+ case 0x02: *(s_u16_t *)((sp_group_tsp)sv)->hgrp |= ((sp_group_tsp)sv)->value; break;
+ case 0x04: *(s_u32_t *)((sp_group_tsp)sv)->hgrp |= ((sp_group_tsp)sv)->value; break;
+ case 0xFF: *(s_u8_t *)((sp_group_tsp)sv)->hgrp &=~((sp_group_tsp)sv)->value; break;
+ case 0xFE: *(s_u16_t *)((sp_group_tsp)sv)->hgrp &=~((sp_group_tsp)sv)->value; break;
+ case 0xFC: *(s_u32_t *)((sp_group_tsp)sv)->hgrp &=~((sp_group_tsp)sv)->value; break;
+ }
+}
+#else
+#define _write_group_ OS_NULL
+#endif
+
+/**
+ \brief 全局变量写访问
+ \param[in] sv 服务的结构体指针
+ \return 无
+ \note 关联服务：iWriteGVar(gv, lv)、iWriteGAry(gp, lp, size)、iWriteGStr(gs, ls)。
+ */
+#if 1 /* 编译开关 *//* 如果用户不会调用关联服务，可手动移除该函数（1 改为 0）*/
+#include
+static void _write_gvar_(void _STATIC_MEM_ *sv) MCUCFG_OSIT_ATTRIBUTE
+{
+ size_t size = ((sp_gvar_tsp)sv)->size;
+ void * gp = ((sp_gvar_tsp)sv)->gp;
+ void * lp = ((sp_gvar_tsp)sv)->lp;
+ size ? s_memcpy(gp, lp, size) : s_strcpy((char *)gp, (char *)lp);
+}
+#else
+#define _write_gvar_ OS_NULL
+#endif
+
+/**
+ \brief 挂起服务调用
+ \param[in] sv 服务的结构体指针
+ \return 无
+ \note 关联服务：iPendSVC(fp)。
+ */
+#if 1 /* 编译开关 *//* 如果用户不会调用关联服务，可手动移除该函数（1 改为 0）*/
+static void _pendsvc_(void _STATIC_MEM_ *sv) MCUCFG_OSIT_ATTRIBUTE
+{
+ (*((sp_pendsvc_tsp)sv)->fp)();
+}
+#else
+#define _pendsvc_ OS_NULL
+#endif
+
+/**
+ \brief 中断FIFO服务-执行总函数（函数指针数组）
+ \param[in] [SVID] 服务ID
+ \param[in] sv 服务的结构体指针
+ \return 无
+ */
+void (_CODE_MEM_ * const _CONST_MEM_ sPendSV_FIFOHandler[OS_SVID_END])(void _STATIC_MEM_ *sv) =
+{
+ _clear_delay_,
+ _resume_task_,
+ _suspend_task_,
+ _delete_task_,
+ _reset_task_,
+ _clear_block_,
+ _set_block_,
+ _set_taskpri_,
+ _write_binary_,
+ _give_semaph_,
+ _send_fetion_,
+ _send_mail_,
+ _send_msg_,
+ _timint_,
+ _timqry_,
+ _write_group_,
+ _write_gvar_,
+ _pendsvc_
+};
+
+/** @} *//**
+ \defgroup 中断FIFO服务-错误调用返回
+ \note 当需要回调时，下列的回调函数可以在用户文件中实现。
+ @{
+ */
+
+#if (SYSCFG_PENDSVFIFO_ERRORCALLBACK == __ENABLED__)
+
+/**
+ \brief iResumeTask(task) error callback
+ \param[in] htask 任务句柄
+ \return 无
+ */
+#if 1 /* 编译开关 *//* 如果该函数在用户文件中实现且此处的弱定义无效，可手动移除该函数（1 改为 0）*/ \
+ && !defined (_resume_task_)
+__WEAK void pResumeTask_ErrorCallback(s_taskctrl_tsp htask) MCUCFG_OSIT_ATTRIBUTE
+{
+ /* Prevent unused argument(s) compilation warning */
+ __UNUSED(htask);
+ /* NOTE: This function should not be modified, when the callback is needed,
+ the pResumeTask_ErrorCallback could be implemented in the user file
+ */
+}
+#endif
+
+/**
+ \brief iSuspendTask(task) error callback
+ \param[in] htask 任务句柄
+ \return 无
+ */
+#if 1 /* 编译开关 *//* 如果该函数在用户文件中实现且此处的弱定义无效，可手动移除该函数（1 改为 0）*/ \
+ && !defined (_suspend_task_)
+__WEAK void pSuspendTask_ErrorCallback(s_taskctrl_tsp htask) MCUCFG_OSIT_ATTRIBUTE
+{
+ /* Prevent unused argument(s) compilation warning */
+ __UNUSED(htask);
+ /* NOTE: This function should not be modified, when the callback is needed,
+ the pSuspendTask_ErrorCallback could be implemented in the user file
+ */
+}
+#endif
+
+/**
+ \brief iDeleteTask(task) error callback
+ \param[in] htask 任务句柄
+ \return 无
+ */
+#if 1 /* 编译开关 *//* 如果该函数在用户文件中实现且此处的弱定义无效，可手动移除该函数（1 改为 0）*/ \
+ && !defined (_delete_task_)
+__WEAK void pDeleteTask_ErrorCallback(s_taskctrl_tsp htask) MCUCFG_OSIT_ATTRIBUTE
+{
+ /* Prevent unused argument(s) compilation warning */
+ __UNUSED(htask);
+ /* NOTE: This function should not be modified, when the callback is needed,
+ the pDeleteTask_ErrorCallback could be implemented in the user file
+ */
+}
+#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 任务句柄
+ \return 无
+ */
+#if 1 /* 编译开关 *//* 如果该函数在用户文件中实现且此处的弱定义无效，可手动移除该函数（1 改为 0）*/ \
+ && !defined (_clear_block_)
+__WEAK void pClearBlock_ErrorCallback(s_taskctrl_tsp htask) MCUCFG_OSIT_ATTRIBUTE
+{
+ /* Prevent unused argument(s) compilation warning */
+ __UNUSED(htask);
+ /* NOTE: This function should not be modified, when the callback is needed,
+ the pClearBlock_ErrorCallback could be implemented in the user file
+ */
+}
+#endif
+
+/**
+ \brief iSetBlock_x(task, x) error callback
+ \details iSetBlock_tc(task, tc)、iSetBlock_ms(task, ms)、iSetBlock_s(task, s)、
+ iSetBlock_m(task, m)、iSetBlock_h(task, h)，都通过该函数实现错误调用返回。
+ \param[in] htask 任务句柄
+ \param[in] tick 滴答周期（阻塞时间）
+ \return 无
+ */
+#if 1 /* 编译开关 *//* 如果该函数在用户文件中实现且此处的弱定义无效，可手动移除该函数（1 改为 0）*/ \
+ && !defined (_set_block_)
+__WEAK void pSetBlock_ErrorCallback(s_taskctrl_tsp htask, s_delay_t tick) MCUCFG_OSIT_ATTRIBUTE
+{
+ /* Prevent unused argument(s) compilation warning */
+ __UNUSED(htask);
+ __UNUSED(tick);
+ /* NOTE: This function should not be modified, when the callback is needed,
+ the pSetBlock_ErrorCallback could be implemented in the user file
+ */
+}
+#endif
+
+/**
+ \brief iSetTaskPri(task, npri) error callback
+ \param[in] htask 任务句柄
+ \param[in] npri 新优先级
+ \return 无
+ */
+#if 1 /* 编译开关 *//* 如果该函数在用户文件中实现且此处的弱定义无效，可手动移除该函数（1 改为 0）*/ \
+ && !defined (_set_taskpri_)
+__WEAK void pSetTaskPri_ErrorCallback(s_taskctrl_tsp htask, s_u8_t npri) MCUCFG_OSIT_ATTRIBUTE
+{
+ /* Prevent unused argument(s) compilation warning */
+ __UNUSED(htask);
+ __UNUSED(npri);
+ /* NOTE: This function should not be modified, when the callback is needed,
+ the pSetTaskPri_ErrorCallback could be implemented in the user file
+ */
+}
+#endif
+
+/**
+ \brief iSendMsg(que, msg) error callback
+ \param[in] hque 队列句柄
+ \param[in] msg 消息指针
+ \return 无
+ */
+#if 1 /* 编译开关 *//* 如果该函数在用户文件中实现且此处的弱定义无效，可手动移除该函数（1 改为 0）*/ \
+ && !defined (_send_msg_)
+__WEAK void pSendMsg_ErrorCallback(s_msgque_tsp hque, void *msg) MCUCFG_OSIT_ATTRIBUTE
+{
+ /* Prevent unused argument(s) compilation warning */
+ __UNUSED(hque);
+ __UNUSED(msg);
+ /* NOTE: This function should not be modified, when the callback is needed,
+ the pSendMsg_ErrorCallback could be implemented in the user file
+ */
+}
+#endif
+
+#endif
+
+/** @} */
+/** @} */
+
+#endif
diff --git a/System/sv_int_fifo.h b/System/sv_int_fifo.h
new file mode 100644
index 00000000..0615ddb2
--- /dev/null
+++ b/System/sv_int_fifo.h
@@ -0,0 +1,189 @@
+/**************************************************************************//**
+ * @item CosyOS-III Kernel
+ * @file sv_int_fifo.h
+ * @brief 中断FIFO服务-调用宏
+ * @details 仅在用户中断中调用，而后挂起到 PendSV中断 中执行。
+ * @author 迟凯峰
+ * @version v3.0.0
+ * @date 2026.07.21
+ ******************************************************************************/
+
+#ifndef __SV_INT_FIFO_H
+#define __SV_INT_FIFO_H
+
+/**
+ @addtogroup CosyOS_内核服务
+ @{
+ *//**
+ \defgroup 中断FIFO服务
+ \brief 在用户中断中调用但不在本地执行，而是把服务的相关内容写入到局部的结构体中，
+ 再把结构体指针入 PendSV_FIFO，再触发 PendSV，而后在 PendSV中断 中执行服务。
+ @{
+ *//**
+ \ingroup 中断FIFO服务
+ \defgroup 中断FIFO服务-调用宏
+ @{
+ */
+
+/** 清除就绪延时 */
+#define sIPS_ClearDelay() \
+do{ \
+ static sp_svid_ts u_psv = {OS_SVID_CLEARDELAY}; \
+ mPendSV_FIFOLoad(); \
+}while(false)
+
+/** 恢复任务 */
+#define sIPS_ResumeTask(_htask) \
+do{ \
+ static sp_task_ts u_psv = {OS_SVID_RESUMETASK, OS_NULL}; \
+ u_psv.htask = _htask; \
+ mPendSV_FIFOLoad(); \
+}while(false)
+
+/** 挂起任务 */
+#define sIPS_SuspendTask(_htask) \
+do{ \
+ static sp_task_ts u_psv = {OS_SVID_SUSPENDTASK, OS_NULL}; \
+ u_psv.htask = _htask; \
+ mPendSV_FIFOLoad(); \
+}while(false)
+
+/** 删除任务 */
+#define sIPS_DeleteTask(_htask) \
+do{ \
+ static sp_task_ts u_psv = {OS_SVID_DELETETASK, OS_NULL}; \
+ u_psv.htask = _htask; \
+ 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{ \
+ static sp_task_ts u_psv = {OS_SVID_CLEARBLOCK, OS_NULL}; \
+ u_psv.htask = _htask; \
+ mPendSV_FIFOLoad(); \
+}while(false)
+
+/** 设置阻塞（时间）*/
+#define sIPS_SetBlock(_htask, _tick) \
+do{ \
+ static sp_blocktime_ts u_psv = {OS_SVID_SETBLOCK, OS_NULL, _tick}; \
+ u_psv.htask = _htask; \
+ mPendSV_FIFOLoad(); \
+}while(false)
+
+/** 设置任务优先级 */
+#define sIPS_SetTaskPri(_htask, _npri) \
+do{ \
+ static sp_taskpri_ts u_psv = {OS_SVID_SETTASKPRI, OS_NULL, _npri}; \
+ u_psv.htask = _htask; \
+ mPendSV_FIFOLoad(); \
+}while(false)
+
+/** 写二值信号量 */
+#define sIPS_WriteBin(_bin, _value) \
+do{ \
+ static sp_binary_ts u_psv = {OS_SVID_WRITEBINARY, &_bin, _value}; \
+ mPendSV_FIFOLoad(); \
+}while(false)
+
+/** 给予计数信号量 */
+#define sIPS_GiveSem(_sem) \
+do{ \
+ static sp_semaph_ts u_psv = {OS_SVID_GIVESEMAPH, &_sem}; \
+ mPendSV_FIFOLoad(); \
+}while(false)
+
+/** 发送飞信 */
+#define sIPS_SendFetion(_tbox, _tion) \
+do{ \
+ static sp_tionbox_ts u_psv = {OS_SVID_SENDFETION, &_tbox, 0}; \
+ u_psv.tion = _tion; \
+ mPendSV_FIFOLoad(); \
+}while(false)
+
+/** 发送邮件 */
+#define sIPS_SendMail(_mbox, _mail) \
+do{ \
+ static sp_mailbox_ts u_psv = {OS_SVID_SENDMAIL, &_mbox, OS_NULL}; \
+ u_psv.mail = _mail; \
+ mPendSV_FIFOLoad(); \
+}while(false)
+
+/** 发送消息 */
+#define sIPS_SendMsg(_que, _msg) \
+do{ \
+ static sp_msgque_ts u_psv = {OS_SVID_SENDMSG, (s_msgque_tsp)&_que, OS_NULL}; \
+ u_psv.msg = _msg; \
+ mPendSV_FIFOLoad(); \
+}while(false)
+
+/** 定时中断 */
+#define sIPS_TimInt(_tmid, _tick) \
+do{ \
+ static sp_timint_ts u_psv = {OS_SVID_TIMINT, _tmid, 0}; \
+ u_psv.tick = _tick; \
+ mPendSV_FIFOLoad(); \
+}while(false)
+
+/** 定时查询 */
+#define sIPS_TimQry(_tmid, _tick) \
+do{ \
+ static sp_timqry_ts u_psv = {OS_SVID_TIMQRY, _tmid, 0}; \
+ u_psv.tick = _tick; \
+ mPendSV_FIFOLoad(); \
+}while(false)
+
+/** 清除标志组 */
+#define sIPS_ClearFlagGroup(_group) \
+do{ \
+ static sp_group_ts u_psv = {OS_SVID_WRITEGROUP, (void *)&_group, -sizeof(_group), ~0}; \
+ mPendSV_FIFOLoad(); \
+}while(false)
+
+/** 写多标志位 */
+#define sIPS_WriteFlagBits(_group, _sign, _nbit) \
+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_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(
+
+/** 全局变量写访问 */
+#define sIPS_WriteGVar(_gp, _lp, _size) \
+do{ \
+ static sp_gvar_ts u_psv = {OS_SVID_WRITEGVAR, _gp, _lp, _size}; \
+ mPendSV_FIFOLoad(); \
+}while(false)
+
+/** 挂起服务调用 */
+#define sIPS_PendSVC(_fp) \
+do{ \
+ static sp_pendsvc_ts u_psv = {OS_SVID_PENDSVC, _fp}; \
+ mPendSV_FIFOLoad(); \
+}while(false)
+
+/** 设置时间 */
+#define sIPS_SetTime(_t) \
+do{ \
+ 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)
+
+/** @} */
+/** @} */
+/** @} */
+
+#endif
diff --git a/System/sv_int_loc.c b/System/sv_int_loc.c
new file mode 100644
index 00000000..7b89540f
--- /dev/null
+++ b/System/sv_int_loc.c
@@ -0,0 +1,149 @@
+/**************************************************************************//**
+ * @item CosyOS-III Kernel
+ * @file sv_int_loc.c
+ * @brief 中断本地服务
+ * @details 在用户中断中调用并直接在本地执行。
+ * @author 迟凯峰
+ * @version v3.0.0
+ * @date 2026.07.21
+ ******************************************************************************/
+
+#include "os_var.h"
+#include "sv_com.h"
+
+/* 相对寄存器访问 for C51 */
+#if defined ( __C51__ )
+#pragma NOAREGS
+#endif
+
+/**
+ @addtogroup 中断本地服务
+ @{
+ */
+
+#if (SYSCFG_BINARY == __ENABLED__)
+/**
+ \brief 获取二值信号量
+ \param[in] hbin 二值信号量句柄
+ \return 结果 [true：成功，false：失败]
+ */
+bool si_take_binary(s_binary_tsp hbin)
+{
+ if(hbin->binary){
+ hbin->binary = false;
+ return true;
+ }
+ return false;
+}
+#endif
+
+#if (SYSCFG_FETION == __ENABLED__)
+/**
+ \brief 接收飞信
+ \param[in] htbox 信箱句柄
+ \return 飞信数据 [false：失败]
+ */
+m_fetion_t si_recv_fetion(s_tionbox_tsp htbox)
+{
+ m_fetion_t tion = htbox->tion;
+ htbox->tion = false;
+ return tion;
+}
+#endif
+
+#if (SYSCFG_MAILBOX == __ENABLED__)
+/**
+ \brief 接收邮件
+ \param[in] hmbox 邮箱句柄
+ \return 邮件指针 [NULL：失败]
+ */
+void *si_recv_mail(s_mailbox_tsp hmbox)
+{
+ if(hmbox->flag){
+ hmbox->flag = false;
+ return hmbox->mail;
+ }
+ return OS_NULL;
+}
+#endif
+
+#if (SYSCFG_MSGQUEUE == __ENABLED__) && (SYSCFG_MSGQUEUE_INTRECV == __ENABLED__)
+#if defined ( __C51__ )
+/**
+ \brief 获取队列互斥量
+ \details 获取队列访问权限 for C51接收消息。
+ \param[in] hque 队列句柄
+ \return 结果 [true：成功，false：失败]
+ */
+bool si_take_quemut(s_msgque_tsp hque)
+{
+ if(!hque->lock) return false;
+ hque->lock = false;
+ __mx_MMB();
+
+ if(hque->type == __DYNAMIC__){
+ #if (SYSCFG_DEBUGGING == __ENABLED__)
+ s_fault.error_recvmsg_int = true;
+ #endif
+ }
+ else if(!hque->counter);
+ else return true;
+
+ __mx_MMB();
+ hque->lock = true;
+ return false;
+}
+
+/**
+ \brief 归还并返回
+ \details 归还队列互斥量并返回消息指针 for C51接收消息。
+ \param[out] mut 队列互斥量指针
+ \param[in] msg 消息指针
+ \return 消息指针 [NULL：失败]
+ */
+static void *_back_ret_(bool _STATIC_MEM_ *mut, void *msg)
+{
+ *mut = true;
+ return msg;
+}
+
+/**
+ \brief C51接收消息
+ \param[in] hque 队列句柄
+ \return 消息指针 [NULL：失败]
+ */
+void *si_recv_msg_c51(s_msgque_tsp hque)
+{
+ void *msg = sc_recv_msg_staque((s_staque_tsp)hque);
+ return _back_ret_((bool *)&hque->lock, msg);
+}
+#else
+/**
+ \brief 非51接收消息
+ \param[in] hque 队列句柄
+ \return 消息指针 [NULL：失败]
+ */
+void *si_recv_msg_n51(s_msgque_tsp hque)
+{
+ void *msg = OS_NULL;
+ if(!hque->lock) return OS_NULL;
+ hque->lock = false;
+ __mx_MMB();
+
+ if(hque->type == __DYNAMIC__){
+ #if (SYSCFG_DEBUGGING == __ENABLED__)
+ s_fault.error_recvmsg_int = true;
+ #endif
+ }
+ else if(hque->counter){
+ msg = sc_recv_msg_staque((s_staque_tsp)hque);
+ }
+
+ __mx_MMB();
+ hque->lock = true;
+ return msg;
+}
+#endif
+#endif
+
+/** @} */
diff --git a/System/sv_int_loc.h b/System/sv_int_loc.h
new file mode 100644
index 00000000..00e3572d
--- /dev/null
+++ b/System/sv_int_loc.h
@@ -0,0 +1,60 @@
+/**************************************************************************//**
+ * @item CosyOS-III Kernel
+ * @file sv_int_loc.h
+ * @brief 中断本地服务
+ * @details 在用户中断中调用并直接在本地执行。
+ * @author 迟凯峰
+ * @version v3.0.0
+ * @date 2026.07.21
+ ******************************************************************************/
+
+#ifndef __SV_INT_LOC_H
+#define __SV_INT_LOC_H
+
+#include "os_redef.h"
+bool si_take_binary (s_binary_tsp hbin);
+bool si_take_quemut (s_msgque_tsp hque);
+void *si_recv_msg_c51(s_msgque_tsp hque);
+void *si_recv_msg_n51(s_msgque_tsp hque);
+void *si_recv_mail (s_mailbox_tsp hmbox);
+m_fetion_t si_recv_fetion (s_tionbox_tsp htbox);
+
+/**
+ @addtogroup CosyOS_内核服务
+ @{
+ *//**
+ \defgroup 中断本地服务
+ \brief 在用户中断中调用并直接在本地执行的服务。
+ @{
+ */
+
+#define sISV_TakeBin(bin) si_take_binary(&bin) /*!< 获取二值信号量 */
+#define sISV_RecvFetion(tbox) si_recv_fetion(&tbox) /*!< 接收飞信 */
+#define sISV_RecvMail(mbox) si_recv_mail(&mbox) /*!< 接收邮件 */
+
+#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) \
+( \
+ sizeof(group) == 1 ? *(s_u8_t *)&group ? true : false \
+ : sizeof(group) == 2 ? *(s_u16_t *)&group ? true : false \
+ : sizeof(group) == 4 ? *(s_u32_t *)&group ? true : false \
+ : false \
+)
+
+/** @} */
+/** @} */
+
+#endif
diff --git a/System/sv_pend.h b/System/sv_pend.h
new file mode 100644
index 00000000..6283105f
--- /dev/null
+++ b/System/sv_pend.h
@@ -0,0 +1,39 @@
+/**************************************************************************//**
+ * @item CosyOS-III Kernel
+ * @file sv_pend.h
+ * @brief PSV服务
+ * @details 仅在 PendSV中断 中调用并执行。
+ * @author 迟凯峰
+ * @version v3.0.0
+ * @date 2026.07.21
+ ******************************************************************************/
+
+#ifndef __SV_PEND_H
+#define __SV_PEND_H
+
+/**
+ @addtogroup CosyOS_内核服务
+ @{
+ *//**
+ \defgroup PSV服务
+ \brief 仅在 PendSV中断 中调用并执行的服务。
+ 包括通过挂起服务调用（iPendSVC）间接调用，在挂起服务钩子（pendsv_hook）中调用。
+ 如果通过挂起服务调用（iPendSVC）间接调用，就是 FIFO服务；
+ 如果通过挂起服务钩子（pendsv_hook） 调用，就是 FIAG服务。
+ @{
+ */
+
+#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) /*!< 给予二值信号量 */
+
+/** @} */
+/** @} */
+
+#endif
diff --git a/System/sv_task.c b/System/sv_task.c
new file mode 100644
index 00000000..2a0a1095
--- /dev/null
+++ b/System/sv_task.c
@@ -0,0 +1,837 @@
+/**************************************************************************//**
+ * @item CosyOS-III Kernel
+ * @file sv_task.c
+ * @brief 任务服务
+ * @details 仅在任务中调用并执行。
+ * @author 迟凯峰
+ * @version v3.0.0
+ * @date 2026.07.21
+ ******************************************************************************/
+
+#include "os_var.h"
+#include "os_api.h"
+#include "sv_com.h"
+#include "sv_task.h"
+
+/**
+ @addtogroup 任务服务
+ @{
+ */
+
+/** 调度解锁（退出嵌套任务临界区）*/
+void su_schedule_unlocks(void)
+{
+ s_schedulelock_counter--;
+ if(!s_schedulelock_counter){
+ #if (SYSCFG_KERNELLOCKNESTING == __ENABLED__)
+ if(!s_sign_schedule.every[1] && !s_kernellock_counter){
+ #else
+ if(!s_sign_schedule.every[1]){
+ #endif
+ s_sign_schedule.every[0] = false;
+ __mx_MMB();
+ mPendSV_Set();
+ while(!s_sign_schedule.every[1]);
+ }
+ else{
+ s_sign_schedule.every[0] = false;
+ }
+ }
+}
+
+/** 内核解锁（退出嵌套服务层临界区）*/
+void su_kernel_unlocks(void)
+{
+ #if (SYSCFG_KERNELLOCKNESTING == __ENABLED__)
+ s_kernellock_counter--;
+ if(s_kernellock_counter) return;
+ #endif
+ if(!s_sign_schedule.total){
+ mPendSV_Set();
+ mSysIRQ_Enable();
+ OS_NOP(1);
+ while(!s_sign_schedule.every[1]);
+ }
+ else{
+ mSysIRQ_Enable();
+ }
+}
+
+/** 内核解锁（退出非嵌套服务层临界区）并触发任务调度 */
+void su_kernel_unlock0_psv(void)
+{
+ s_sign_schedule.every[1] = false;
+ mPendSV_Set();
+ mSysIRQ_Enable();
+ OS_NOP(1);
+ while(!s_sign_schedule.every[1]);
+}
+
+#if defined ( __C51__ ) || defined ( __C251__ )
+/** 调度上锁（进入嵌套任务临界区）*/
+void su_schedule_locks(void)
+{
+ s_sign_schedule.every[0] = true;
+ __mx_MMB();
+ s_schedulelock_counter++;
+}
+
+/** 内核上锁（进入非嵌套服务层临界区）*/
+void su_kernel_lock0(void)
+{
+ mSysIRQ_Disable();
+}
+
+/** 内核解锁（退出非嵌套服务层临界区）*//*
+void su_kernel_unlock0(void)
+{
+ mSysIRQ_Enable();
+}*/
+
+/** 内核上锁（进入嵌套服务层临界区）*/
+#if (SYSCFG_KERNELLOCKNESTING == __ENABLED__)
+void su_kernel_locks(void)
+{
+ mSysIRQ_Disable();
+ s_kernellock_counter++;
+}
+#endif
+
+/** 内核解锁（退出嵌套服务层临界区）并返回(s_ecode_t) */
+s_ecode_t su_kernel_unlocks_rec(s_ecode_t e)
+{
+ su_kernel_unlocks();
+ return e;
+}
+
+/** 内核解锁（退出嵌套服务层临界区）并返回(void *) */
+void *su_kernel_unlocks_rvp(void *p)
+{
+ su_kernel_unlocks();
+ return p;
+}
+#endif
+
+
+/*
+ * 操作任务
+ */
+
+/**
+ \brief 启动任务
+ \param[in] hload 任务装载块句柄
+ \param[in] status 任务初始状态
+ \return 错误码
+ */
+s_ecode_t su_startup_task_0(s_taskload_tsp hload, s_u8_t status)
+{
+ s_task_starter.hload = hload;
+ s_task_starter.status = status;
+ s_sign_startup = false;
+ mPendSV_Set();
+ mSysIRQ_Enable();
+ OS_NOP(1);
+ while(!s_sign_startup);
+ return s_task_starter._ecode;
+}
+
+/**
+ \brief 启动任务
+ \param[in] hload 任务装载块句柄
+ \param[in] status 任务初始状态
+ \param[in] entry 任务函数入口
+ \return 错误码
+ */
+s_ecode_t su_startup_task_1(s_taskload_tsp hload, s_u8_t status, s_voidvoid_tfp entry)
+{
+ hload->entry = entry;
+ return su_startup_task_0(hload, status);
+}
+
+/**
+ \brief 恢复指定任务并挂起自身任务
+ \param[in] htask 任务句柄
+ \return 错误码
+ */
+s_ecode_t su_resume_suspend(s_taskctrl_tsp htask)
+{
+ s_ecode_t _ecode = sc_resume_task(htask);
+ if(_ecode == OS_ECODE_NOERROR || htask->status == OS_STATUS_READY){
+ sa_suspend_task(s_task_current);
+ return OS_ECODE_NOERROR;
+ }
+ else{
+ return _ecode;
+ }
+}
+
+#if (SYSCFG_SAMEPRISCHEDULE)
+/**
+ \brief 禅让任务
+ \param 无
+ \return 无
+ */
+void su_yield_tasking(void)
+{
+ su_kernel_locks();
+ #if (SYSCFG_SAMEPRISCHEDULE == __COOPERATIVE__)
+ s_task_current->yield = true;
+ #elif (SYSCFG_SAMEPRISCHEDULE == __TIMESHARING__)
+ s_task_current->tc_counter = ~0;
+ #endif
+ s_sign_schedule.every[1] = false;
+ su_kernel_unlocks();
+}
+#endif
+
+/**
+ \brief 自身任务延时
+ \param[in] tick 滴答周期（延时时间）
+ +0：非法
+ ~0：无限延时
+ \return 无
+ */
+void su_delay(s_delay_t tick)
+{
+ if(~tick) sa_insert_timerlist(s_task_current, tick);
+ if(!s_sign_schedule.every[0]){ /* 阻塞延时 */
+ sa_remove_ready(s_task_current);
+ s_task_current->status = OS_STATUS_BLOCKED;
+ su_kernel_unlock0_psv();
+ }
+ else{ /* 就绪延时 */
+ s_sign_delay = true;
+ mSysIRQ_Enable();
+ while(s_sign_delay);
+ }
+}
+
+/*
+ * 互斥信号量
+ */
+#if (SYSCFG_MUTEX == __ENABLED__)
+/**
+ \brief 获取互斥信号量
+ \param[in] hmut 互斥信号量句柄
+ \param[in] tick 滴答周期（超时时间）
+ +0：立即返回
+ ~0：无限等待
+ \return 结果
+ \retval false 失败
+ \retval true 成功
+ */
+bool su_take_mutex(s_mutex_tsp hmut, s_delay_t tick)
+{
+ if(!hmut->mutex) goto __RET_TRUE1;
+ if(s_task_current == hmut->otask) goto __RET_TRUE2;
+ if(!tick) goto __RET_FALSE;
+
+ if(~tick) sa_insert_timerlist(s_task_current, tick);
+ sa_insert_blocklist(&hmut->htask);
+ sa_remove_ready(s_task_current);
+ s_task_current->status = OS_STATUS_BLOCKED;
+ s_task_current->blocktype = OS_BLOCKED_MUTEX;
+ if(s_task_current->pri > hmut->otask->pri){
+ #if (SYSCFG_SAMEPRISCHEDULE)
+ s_taskctrl_tsp link = hmut->otask;
+ s_task_current->link = link;
+ do{
+ sa_set_taskpri(link, s_task_current->pri);
+ link = link->link;
+ }while(link != OS_NULL);
+ #else
+ sa_set_taskpri(hmut->otask, s_taskpri_ceiling++);
+ #endif
+ }
+ s_task_current->handle = hmut;
+ su_kernel_unlock0_psv();
+ #if defined ( __C51__ )
+ hmut = (s_mutex_tsp)s_task_current->handle;
+ #endif
+ if(!hmut->mutex) goto __RET_TRUE1;
+
+__RET_FALSE:
+ mSysIRQ_Enable();
+ return false;
+
+__RET_TRUE1:
+ if(hmut->htask != OS_NULL){
+ sa_float_to_block(hmut->htask);
+ }
+ hmut->otask = s_task_current;
+ hmut->opri = s_task_current->pri;
+
+__RET_TRUE2:
+ hmut->mutex++;
+ mSysIRQ_Enable();
+ return true;
+}
+
+/**
+ \brief 归还互斥信号量
+ \param[in] hmut 互斥信号量句柄
+ \return 无
+ */
+void su_back_mutex(s_mutex_tsp hmut)
+{
+ if(!hmut->mutex);
+ else if(s_task_current == hmut->otask){
+ hmut->mutex--;
+ if(!hmut->mutex){
+ if(s_task_current->pri > hmut->opri){
+ sa_set_taskpri(s_task_current, hmut->opri);
+ #if (!SYSCFG_SAMEPRISCHEDULE)
+ s_taskpri_ceiling--;
+ #endif
+ }
+ if(hmut->htask != OS_NULL){
+ sa_block_to_float(hmut->htask);
+ }
+ }
+ }
+ su_kernel_unlocks();
+}
+#endif
+
+
+/*
+ * 二值信号量
+ */
+#if (SYSCFG_BINARY == __ENABLED__)
+/**
+ \brief 等待二值信号量
+ \param[in] hbin 二值信号量句柄
+ \param[in] tick 滴答周期（超时时间）
+ +0：立即返回
+ ~0：无限等待
+ \return 结果
+ \retval false 失败
+ \retval true 成功
+ */
+bool su_wait_binary(s_binary_tsp hbin, s_delay_t tick)
+{
+ if(hbin->binary) goto __RET_TRUE;
+ if(!tick) goto __RET_FALSE;
+
+ if(~tick) sa_insert_timerlist(s_task_current, tick);
+ sa_insert_blocklist(&hbin->htask);
+ sa_remove_ready(s_task_current);
+ s_task_current->status = OS_STATUS_BLOCKED;
+ s_task_current->blocktype = OS_BLOCKED_BINARY;
+ s_task_current->handle = hbin;
+ su_kernel_unlock0_psv();
+ #if defined ( __C51__ )
+ hbin = (s_binary_tsp)s_task_current->handle;
+ #endif
+ if(hbin->binary) goto __RET_TRUE;
+
+__RET_FALSE:
+ mSysIRQ_Enable();
+ return false;
+
+__RET_TRUE:
+ mSysIRQ_Enable();
+ return true;
+}
+
+/**
+ \brief 获取二值信号量
+ \param[in] hbin 二值信号量句柄
+ \param[in] tick 滴答周期（超时时间）
+ +0：立即返回
+ ~0：无限等待
+ \return 结果
+ \retval false 失败
+ \retval true 成功
+ */
+bool su_take_binary(s_binary_tsp hbin, s_delay_t tick)
+{
+ if(hbin->binary) goto __RET_TRUE;
+ if(!tick) goto __RET_FALSE;
+
+ if(~tick) sa_insert_timerlist(s_task_current, tick);
+ sa_insert_blocklist(&hbin->htask);
+ sa_remove_ready(s_task_current);
+ s_task_current->status = OS_STATUS_BLOCKED;
+ s_task_current->blocktype = OS_BLOCKED_BINARY;
+ s_task_current->handle = hbin;
+ su_kernel_unlock0_psv();
+ #if defined ( __C51__ )
+ hbin = (s_binary_tsp)s_task_current->handle;
+ #endif
+ if(hbin->binary) goto __RET_TRUE;
+
+__RET_FALSE:
+ mSysIRQ_Enable();
+ return false;
+
+__RET_TRUE:
+ if(hbin->htask != OS_NULL){
+ sa_float_to_block(hbin->htask);
+ }
+ hbin->binary = false;
+ mSysIRQ_Enable();
+ return true;
+}
+#endif
+
+
+/*
+ * 计数信号量
+ */
+#if (SYSCFG_SEMAPHORE == __ENABLED__)
+/**
+ \brief 获取计数信号量
+ \param[in] hsem 计数信号量句柄
+ \param[in] tick 滴答周期（超时时间）
+ +0：立即返回
+ ~0：无限等待
+ \return 结果
+ \retval false 失败
+ \retval true 成功
+ */
+bool su_take_semaph(s_semaph_tsp hsem, s_delay_t tick)
+{
+ s_semaph_t counter;
+ counter = hsem->counter;
+ if(counter) goto __RET_TRUE;
+ if(!tick) goto __RET_FALSE;
+
+ if(~tick) sa_insert_timerlist(s_task_current, tick);
+ sa_insert_blocklist(&hsem->htask);
+ sa_remove_ready(s_task_current);
+ s_task_current->status = OS_STATUS_BLOCKED;
+ s_task_current->blocktype = OS_BLOCKED_SEMAPHORE;
+ s_task_current->handle = hsem;
+ su_kernel_unlock0_psv();
+ #if defined ( __C51__ )
+ hsem = (s_semaph_tsp)s_task_current->handle;
+ #endif
+ counter = hsem->counter;
+ if(counter) goto __RET_TRUE;
+
+__RET_FALSE:
+ mSysIRQ_Enable();
+ return false;
+
+__RET_TRUE:
+ counter--;
+ if(!counter && hsem->htask != OS_NULL){
+ sa_float_to_block(hsem->htask);
+ }
+ hsem->counter = counter;
+ mSysIRQ_Enable();
+ return true;
+}
+#endif
+
+
+/*
+ * 私信
+ */
+#if (SYSCFG_TASKMSG == __ENABLED__)
+/**
+ \brief 接收私信
+ \param[in] tmrf 私信标志
+ \param[in] tick 滴答周期（超时时间）
+ +0：立即返回
+ ~0：无限等待
+ \return 结果
+ \retval false 失败
+ \retval true 成功
+ */
+bool su_recv_taskmsg(s_u8_t volatile _STATIC_MEM_ *tmrf, s_delay_t tick)
+{
+ if(*tmrf) goto __RET_TRUE;
+ if(!tick) goto __RET_FALSE;
+
+ if(~tick) sa_insert_timerlist(s_task_current, tick);
+ sa_remove_ready(s_task_current);
+ s_task_current->status = OS_STATUS_BLOCKED;
+ s_task_current->blocktype = OS_BLOCKED_TASKMSG;
+ #if defined ( __C51__ )
+ s_task_current->handle = (void *)tmrf;
+ #endif
+ su_kernel_unlock0_psv();
+ #if defined ( __C51__ )
+ tmrf = (s_u8_t volatile _STATIC_MEM_ *)s_task_current->handle;
+ #endif
+ if(*tmrf) goto __RET_TRUE;
+
+__RET_FALSE:
+ mSysIRQ_Enable();
+ return false;
+
+__RET_TRUE:
+ *tmrf = 2;
+ (*s_task_current->entry)();
+ mSysIRQ_Enable();
+ return true;
+}
+#endif
+
+
+/*
+ * 飞信
+ */
+#if (SYSCFG_FETION == __ENABLED__)
+/**
+ \brief 退出非嵌套服务层临界区并返回飞信
+ \param[in] htbox 信箱句柄
+ \return 飞信
+ */
+__STATIC_FORCEINLINE m_fetion_t _unlock0_rfet_(s_tionbox_tsp htbox)
+{
+ m_fetion_t tion = htbox->tion;
+ htbox->tion = false;
+ mSysIRQ_Enable();
+ return tion;
+}
+
+/**
+ \brief 接收飞信
+ \param[in] htbox 信箱句柄
+ \param[in] tick 滴答周期（超时时间）
+ +0：立即返回
+ ~0：无限等待
+ \return 飞信
+ \retval false 失败
+ */
+m_fetion_t su_recv_fetion(s_tionbox_tsp htbox, s_delay_t tick)
+{
+ if(htbox->tion) goto __RET_TION;
+ if(!tick) goto __RET_FALSE;
+
+ if(~tick) sa_insert_timerlist(s_task_current, tick);
+ sa_insert_blocklist(&htbox->htask);
+ sa_remove_ready(s_task_current);
+ s_task_current->status = OS_STATUS_BLOCKED;
+ s_task_current->blocktype = OS_BLOCKED_FETION;
+ s_task_current->handle = htbox;
+ su_kernel_unlock0_psv();
+ #if defined ( __C51__ )
+ htbox = (s_tionbox_tsp)s_task_current->handle;
+ #endif
+
+__RET_TION:
+ return _unlock0_rfet_(htbox);
+
+__RET_FALSE:
+ mSysIRQ_Enable();
+ return false;
+}
+#endif
+
+
+/** 退出非嵌套服务层临界区并返回(void *) */
+#if (SYSCFG_MAILBOX == __ENABLED__ || SYSCFG_MSGQUEUE == __ENABLED__)
+__STATIC_FORCEINLINE void *_unlock0_rvp_(void *p)
+{
+ mSysIRQ_Enable();
+ return p;
+}
+#endif
+
+
+/*
+ * 邮箱
+ */
+#if (SYSCFG_MAILBOX == __ENABLED__)
+/**
+ \brief 接收邮件
+ \param[in] hmbox 邮箱句柄
+ \param[in] tick 滴答周期（超时时间）
+ +0：立即返回
+ ~0：无限等待
+ \return 邮件指针
+ \retval NULL 失败
+ */
+void *su_recv_mail(s_mailbox_tsp hmbox, s_delay_t tick)
+{
+ if(hmbox->flag) goto __RET_MAIL;
+ if(!tick) goto __RET_NULL;
+
+ if(~tick) sa_insert_timerlist(s_task_current, tick);
+ sa_insert_blocklist(&hmbox->htask);
+ sa_remove_ready(s_task_current);
+ s_task_current->status = OS_STATUS_BLOCKED;
+ s_task_current->blocktype = OS_BLOCKED_MAIL;
+ s_task_current->handle = hmbox;
+ su_kernel_unlock0_psv();
+ #if defined ( __C51__ )
+ hmbox = (s_mailbox_tsp)s_task_current->handle;
+ #endif
+ if(hmbox->flag) goto __RET_MAIL;
+
+__RET_NULL:
+ mSysIRQ_Enable();
+ return OS_NULL;
+
+__RET_MAIL:
+ hmbox->flag = false;
+ return _unlock0_rvp_(hmbox->mail);
+}
+#endif
+
+
+/*
+ * 消息队列
+ */
+#if (SYSCFG_MSGQUEUE == __ENABLED__)
+/**
+ \brief 接收消息
+ \param[in] hque 队列句柄
+ \param[in] tick 滴答周期（超时时间）
+ +0：立即返回
+ ~0：无限等待
+ \return 消息指针
+ \retval NULL 失败
+ */
+void *su_recv_msg(s_msgque_tsp hque, s_delay_t tick)
+{
+ void *msg;
+ #if (SYSCFG_MSGQUEUE_INTRECV == __ENABLED__)
+ hque->lock = false;
+ __mx_MMB();
+ #endif
+
+ if(hque->counter) goto __RECV_MSG;
+ if(!tick) goto __RET_NULL;
+
+ #if (SYSCFG_MSGQUEUE_INTRECV == __ENABLED__)
+ __mx_MMB();
+ hque->lock = true;
+ #endif
+ if(~tick) sa_insert_timerlist(s_task_current, tick);
+ sa_insert_blocklist(&hque->htask);
+ sa_remove_ready(s_task_current);
+ s_task_current->status = OS_STATUS_BLOCKED;
+ s_task_current->blocktype = OS_BLOCKED_MSG;
+ s_task_current->handle = hque;
+ su_kernel_unlock0_psv();
+ #if defined ( __C51__ )
+ hque = (s_msgque_tsp)s_task_current->handle;
+ #endif
+ #if (SYSCFG_MSGQUEUE_INTRECV == __ENABLED__)
+ hque->lock = false;
+ __mx_MMB();
+ #endif
+ if(!hque->counter) goto __RET_NULL;
+
+__RECV_MSG:
+ if(hque->type == __DYNAMIC__){
+ msg = sc_recv_msg_dynque((s_dynque_tsp)hque);
+ }
+ else{
+ msg = sc_recv_msg_staque((s_staque_tsp)hque);
+ }
+ #if (SYSCFG_MSGQUEUE_INTRECV == __ENABLED__)
+ __mx_MMB();
+ hque->lock = true;
+ #endif
+ return _unlock0_rvp_(msg);
+
+__RET_NULL:
+ #if (SYSCFG_MSGQUEUE_INTRECV == __ENABLED__)
+ __mx_MMB();
+ hque->lock = true;
+ #endif
+ mSysIRQ_Enable();
+ return OS_NULL;
+}
+#endif
+
+
+/*
+ * 事件标志组
+ */
+#if (SYSCFG_FLAGGROUP == __ENABLED__)
+/**
+ \brief 查询标志组
+ \param[in] hgrp 标志组句柄
+ \param[in] size sizeof(group)
+ \return 结果
+ \retval false 失败
+ \retval true 成功
+ */
+bool su_query_group(void volatile _STATIC_MEM_ *hgrp, s_u8_t size)
+{
+ switch(size){
+ case 1: if(*(s_u8_t *)hgrp) goto __RET_TRUE; break;
+ case 2: if(*(s_u16_t *)hgrp) goto __RET_TRUE; break;
+ case 4: if(*(s_u32_t *)hgrp) goto __RET_TRUE; break;
+ }
+ su_kernel_unlocks();
+ return false;
+
+__RET_TRUE:
+ su_kernel_unlocks();
+ return true;
+}
+
+/**
+ \brief 等待标志组_1
+ \param[in] hgrp 标志组句柄
+ \param[in] tick 滴答周期（超时时间）
+ +0：立即返回
+ ~0：无限等待
+ \return 结果
+ \retval false 失败
+ \retval true 成功
+ */
+bool su_wait_group_1(s_u8_t volatile _STATIC_MEM_ *hgrp, s_delay_t tick)
+{
+ if(*hgrp) goto __RET_TRUE;
+ if(!tick) goto __RET_FALSE;
+
+ if(~tick) sa_insert_timerlist(s_task_current, tick);
+ sa_remove_ready(s_task_current);
+ s_task_current->status = OS_STATUS_BLOCKED;
+ s_task_current->blocktype = 1;
+ s_task_current->handle = (void *)hgrp;
+ su_kernel_unlock0_psv();
+ #if defined ( __C51__ )
+ hgrp = (s_u8_t volatile _STATIC_MEM_ *)s_task_current->handle;
+ #endif
+ if(*hgrp) goto __RET_TRUE;
+
+__RET_FALSE:
+ mSysIRQ_Enable();
+ return false;
+
+__RET_TRUE:
+ mSysIRQ_Enable();
+ return true;
+}
+
+/**
+ \brief 等待标志组_2
+ \param[in] hgrp 标志组句柄
+ \param[in] tick 滴答周期（超时时间）
+ +0：立即返回
+ ~0：无限等待
+ \return 结果
+ \retval false 失败
+ \retval true 成功
+ */
+bool su_wait_group_2(s_u16_t volatile _STATIC_MEM_ *hgrp, s_delay_t tick)
+{
+ if(*hgrp) goto __RET_TRUE;
+ if(!tick) goto __RET_FALSE;
+
+ if(~tick) sa_insert_timerlist(s_task_current, tick);
+ sa_remove_ready(s_task_current);
+ s_task_current->status = OS_STATUS_BLOCKED;
+ s_task_current->blocktype = 2;
+ s_task_current->handle = (void *)hgrp;
+ su_kernel_unlock0_psv();
+ #if defined ( __C51__ )
+ hgrp = (s_u16_t volatile _STATIC_MEM_ *)s_task_current->handle;
+ #endif
+ if(*hgrp) goto __RET_TRUE;
+
+__RET_FALSE:
+ mSysIRQ_Enable();
+ return false;
+
+__RET_TRUE:
+ mSysIRQ_Enable();
+ return true;
+}
+
+/**
+ \brief 等待标志组_4
+ \param[in] hgrp 标志组句柄
+ \param[in] tick 滴答周期（超时时间）
+ +0：立即返回
+ ~0：无限等待
+ \return 结果
+ \retval false 失败
+ \retval true 成功
+ */
+bool su_wait_group_4(s_u32_t volatile _STATIC_MEM_ *hgrp, s_delay_t tick)
+{
+ if(*hgrp) goto __RET_TRUE;
+ if(!tick) goto __RET_FALSE;
+
+ if(~tick) sa_insert_timerlist(s_task_current, tick);
+ sa_remove_ready(s_task_current);
+ s_task_current->status = OS_STATUS_BLOCKED;
+ s_task_current->blocktype = 4;
+ s_task_current->handle = (void *)hgrp;
+ su_kernel_unlock0_psv();
+ #if defined ( __C51__ )
+ hgrp = (s_u32_t volatile _STATIC_MEM_ *)s_task_current->handle;
+ #endif
+ if(*hgrp) goto __RET_TRUE;
+
+__RET_FALSE:
+ mSysIRQ_Enable();
+ return false;
+
+__RET_TRUE:
+ mSysIRQ_Enable();
+ return true;
+}
+#endif
+
+
+/*
+ * 动态内存
+ */
+#if (SYSCFG_DYNMEMMGE == __ENABLED__)
+/**
+ \brief uxalloc
+ \param[in] p
+ \return 指针
+ \retval NULL 失败
+ */
+void _MALLOC_MEM_ *su_xalloc(void _MALLOC_MEM_ *p)
+{
+ su_kernel_unlocks();
+ return p;
+}
+
+/**
+ \brief 初始化线程内存池
+ \param[in] hmem 线程内存句柄
+ \param[in] size 内存池大小
+ \return 结果
+ \retval false 失败
+ \retval true 成功
+ */
+bool su_init_mempool(s_thrmem_tsp hmem, size_t size)
+{
+ hmem->head = hmem->move = (void _MALLOC_MEM_ *)s_malloc(size);
+ if(hmem->head == OS_NULL){
+ su_kernel_unlocks();
+ return false;
+ }
+ else{
+ hmem->size = size;
+ su_kernel_unlocks();
+ return true;
+ }
+}
+
+/**
+ \brief 线程内存分配
+ \param[in] hmem 线程内存句柄
+ \param[in] size 内存块大小
+ \return 指针
+ \retval NULL 失败
+ */
+void _MALLOC_MEM_ *su_talloc(s_thrmem_tsp hmem, size_t size)
+{
+ if(hmem->head == OS_NULL || (size_t)hmem->move - (size_t)hmem->head + size > hmem->size){
+ return OS_NULL;
+ }
+ else{
+ void _MALLOC_MEM_ *r = hmem->move;
+ hmem->move = (s_u8_t _MALLOC_MEM_ *)hmem->move + size;
+ return r;
+ }
+}
+#endif
+
+/** @} */
diff --git a/System/sv_task.h b/System/sv_task.h
new file mode 100644
index 00000000..db337a11
--- /dev/null
+++ b/System/sv_task.h
@@ -0,0 +1,456 @@
+/**************************************************************************//**
+ * @item CosyOS-III Kernel
+ * @file sv_task.h
+ * @brief 任务服务
+ * @details 仅在任务中调用并执行。
+ * @author 迟凯峰
+ * @version v3.0.0
+ * @date 2026.07.21
+ ******************************************************************************/
+
+#ifndef __SV_TASK_H
+#define __SV_TASK_H
+
+#include "os_var.h"
+
+#if defined ( __C51__ ) || defined ( __C251__ )
+void su_schedule_locks (void);
+void su_kernel_lock0 (void);
+void su_kernel_unlock0 (void);
+s_ecode_t su_kernel_unlocks_rec(s_ecode_t e);
+void *su_kernel_unlocks_rvp(void *p);
+#endif
+
+#if (SYSCFG_KERNELLOCKNESTING == __DISABLED__)
+#define su_kernel_locks su_kernel_lock0
+#elif defined ( __C51__ ) || defined ( __C251__ )
+void su_kernel_locks (void);
+#endif
+
+void su_schedule_unlocks (void);
+void su_kernel_unlocks (void);
+void su_kernel_unlock0_psv(void);
+
+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);
+void su_back_mutex (s_mutex_tsp hmut);
+bool su_wait_binary (s_binary_tsp hbin, s_delay_t tick);
+bool su_take_binary (s_binary_tsp hbin, s_delay_t tick);
+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 (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);
+
+
+/**
+ @addtogroup CosyOS_内核服务
+ @{
+ *//**
+ \defgroup 任务服务
+ \brief 仅在任务中调用并执行的服务。
+ @{
+ */
+
+#if !defined ( __C51__ ) && !defined ( __C251__ )
+/** 调度上锁（进入嵌套任务临界区）*/
+__STATIC_FORCEINLINE void su_schedule_locks(void)
+{
+ s_sign_schedule.every[0] = true;
+ __mx_MMB();
+ s_schedulelock_counter++;
+}
+
+/** 内核上锁（进入非嵌套服务层临界区）*/
+__STATIC_FORCEINLINE bool su_kernel_lock0(void)
+{
+ mSysIRQ_Disable();
+ return true;
+}
+
+/** 内核解锁（退出非嵌套服务层临界区）*//*
+__STATIC_FORCEINLINE bool su_kernel_unlock0(void)
+{
+ mSysIRQ_Enable();
+ return true;
+}*/
+
+/** 内核上锁（进入嵌套服务层临界区）*/
+#if (SYSCFG_KERNELLOCKNESTING == __ENABLED__)
+__STATIC_FORCEINLINE bool su_kernel_locks(void)
+{
+ mSysIRQ_Disable();
+ s_kernellock_counter++;
+ return true;
+}
+#endif
+
+/** 内核解锁（退出嵌套服务层临界区）并返回(s_ecode_t) */
+__STATIC_FORCEINLINE s_ecode_t su_kernel_unlocks_rec(s_ecode_t e)
+{
+ su_kernel_unlocks();
+ return e;
+}
+
+/** 内核解锁（退出嵌套服务层临界区）并返回(void *) */
+__STATIC_FORCEINLINE void *su_kernel_unlocks_rvp(void *p)
+{
+ su_kernel_unlocks();
+ return p;
+}
+#endif
+
+
+/*
+ * 操作任务
+ */
+
+/** 启动任务 */
+#define sUSV_StartTask_0(hload, status) \
+( \
+ (m_boolvoid_tf(su_kernel_lock0))() || true ? su_startup_task_0((s_taskload_tsp)hload, status) : OS_ECODE_NOERROR \
+)
+
+/** 启动任务 */
+#define sUSV_StartTask_1(hload, status, entry) \
+( \
+ (m_boolvoid_tf(su_kernel_lock0))() || true ? su_startup_task_1((s_taskload_tsp)hload, status, (s_voidvoid_tfp)entry) : OS_ECODE_NOERROR \
+)
+
+/** 恢复指定任务并挂起自身任务 */
+#define sUSV_ResumeSuspend(htask) \
+( \
+ (m_boolvoid_tf(su_kernel_locks))() || true ? su_kernel_unlocks_rec(su_resume_suspend(htask)) : OS_ECODE_NOERROR \
+)
+
+/** 恢复任务 */
+#define sUSV_ResumeTask(htask) \
+( \
+ (m_boolvoid_tf(su_kernel_locks))() || true ? su_kernel_unlocks_rec(sc_resume_task(htask)) : OS_ECODE_NOERROR \
+)
+
+/** 挂起任务 */
+#define sUSV_SuspendTask(htask) \
+( \
+ (m_boolvoid_tf(su_kernel_locks))() || true ? su_kernel_unlocks_rec(sc_suspend_task(htask)) : OS_ECODE_NOERROR \
+)
+
+/** 删除任务 */
+#define sUSV_DeleteTask(htask) \
+( \
+ (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) \
+( \
+ (m_boolvoid_tf(su_kernel_locks))() || true ? su_kernel_unlocks_rec(sc_clear_block(htask)) : OS_ECODE_NOERROR \
+)
+
+/** 设置阻塞（时间）*/
+#define sUSV_SetBlock(htask, tick) \
+( \
+ (m_boolvoid_tf(su_kernel_locks))() || true ? su_kernel_unlocks_rec(sc_set_block(htask, tick)) : OS_ECODE_NOERROR \
+)
+
+/** 设置任务优先级 */
+#define sUSV_SetTaskPri(htask, npri) \
+( \
+ (m_boolvoid_tf(su_kernel_locks))() || true ? su_kernel_unlocks_rec(sc_set_taskpri(htask, npri)) : OS_ECODE_NOERROR \
+)
+
+/** 自身任务延时 */
+#define sUSV_Delay(tick) \
+do{ \
+ mSysIRQ_Disable(); \
+ su_delay(tick); \
+}while(false)
+
+
+/*
+ * 互斥信号量
+ */
+
+/** 获取互斥信号量 */
+#define sUSV_TakeMut(mut, tick) \
+( \
+ (m_boolvoid_tf(su_kernel_lock0))() || true ? su_take_mutex(&mut, tick) : false \
+)
+
+/** 归还互斥信号量 */
+#define sUSV_BackMut(mut) \
+do{ \
+ su_kernel_locks(); \
+ su_back_mutex(&mut); \
+}while(false)
+
+
+/*
+ * 二值信号量
+ */
+
+/** 等待二值信号量 */
+#define sUSV_WaitBin(bin, tick) \
+( \
+ (m_boolvoid_tf(su_kernel_lock0))() || true ? su_wait_binary(&bin, tick) : false \
+)
+
+/** 获取二值信号量 */
+#define sUSV_TakeBin(bin, tick) \
+( \
+ (m_boolvoid_tf(su_kernel_lock0))() || true ? su_take_binary(&bin, tick) : false \
+)
+
+/** 给予二值信号量 */
+#define sUSV_GiveBin(bin) \
+do{ \
+ su_kernel_locks(); \
+ sc_write_binary(&bin, true); \
+ su_kernel_unlocks(); \
+}while(false)
+
+
+/*
+ * 计数信号量
+ */
+
+/** 获取计数信号量 */
+#define sUSV_TakeSem(sem, tick) \
+( \
+ (m_boolvoid_tf(su_kernel_lock0))() || true ? su_take_semaph(&sem, tick) : false \
+)
+
+/** 给予计数信号量 */
+#define sUSV_GiveSem(sem) \
+do{ \
+ su_kernel_locks(); \
+ sc_give_semaph(&sem); \
+ su_kernel_unlocks(); \
+}while(false)
+
+
+/*
+ * 私信
+ */
+
+/** 接收私信 */
+#define sUSV_RecvTaskmsg(tick) \
+( \
+ (m_boolvoid_tf(su_kernel_lock0))() || true ? su_recv_taskmsg(&u_tmrf, tick) : false \
+)
+
+/** 发送私信 */
+#define sUSV_SendTaskmsg(task) \
+ su_kernel_locks(); \
+ s_taskmsg_sign = 2; \
+ sa_block_to_ready(task); \
+ u_task_##task
+
+
+/*
+ * 飞信
+ */
+
+/** 接收飞信 */
+#define sUSV_RecvFetion(tbox, tick) \
+( \
+ (m_boolvoid_tf(su_kernel_lock0))() || true ? su_recv_fetion(&tbox, tick) : false \
+)
+
+/** 发送飞信 */
+#define sUSV_SendFetion(tbox, tion) \
+do{ \
+ su_kernel_locks(); \
+ sc_send_fetion(&tbox, tion); \
+ su_kernel_unlocks(); \
+}while(false)
+
+
+/*
+ * 邮箱
+ */
+
+/** 接收邮件 */
+#define sUSV_RecvMail(mbox, tick) \
+( \
+ (m_boolvoid_tf(su_kernel_lock0))() || true ? su_recv_mail(&mbox, tick) : OS_NULL \
+)
+
+/** 发送邮件 */
+#define sUSV_SendMail(mbox, mail) \
+do{ \
+ su_kernel_locks(); \
+ sc_send_mail(&mbox, mail); \
+ su_kernel_unlocks(); \
+}while(false)
+
+
+/*
+ * 消息队列
+ */
+
+/** 接收消息 */
+#define sUSV_RecvMsg(que, tick) \
+( \
+ (m_boolvoid_tf(su_kernel_lock0))() || true ? su_recv_msg((s_msgque_tsp)&que, tick) : OS_NULL \
+)
+
+/** 发送消息 */
+#define sUSV_SendMsg(que, msg) \
+( \
+ (m_boolvoid_tf(su_kernel_locks))() || true ? su_kernel_unlocks_rec(sc_send_msg((s_msgque_tsp)&que, msg)) : OS_ECODE_NOERROR \
+)
+
+
+/*
+ * 事件标志组
+ */
+
+/** 查询标志组 */
+#define sUSV_QueryFlagGroup(group) \
+( \
+ (m_boolvoid_tf(su_kernel_locks))() || true ? su_query_group((void *)&group, sizeof(group)) : false \
+)
+
+/** 等待标志组 */
+#define sUSV_WaitFlagGroup(group, tick) \
+( \
+ (m_boolvoid_tf(su_kernel_lock0))() || true ? ( \
+ sizeof(group) == 1 ? su_wait_group_1((s_u8_t *)&group, tick) \
+ : sizeof(group) == 2 ? su_wait_group_2((s_u16_t *)&group, tick) \
+ : sizeof(group) == 4 ? su_wait_group_4((s_u32_t *)&group, tick) \
+ : false \
+ ) : false \
+)
+
+/** 清除标志组 */
+#define sUSV_ClearFlagGroup(group) \
+do{ \
+ su_kernel_locks(); \
+ 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)
+
+/** 写多标志位 */
+#define sUSV_WriteFlagBits(group, value, nbit) \
+ suWriteFlagBits_##nbit(group, value,
+
+
+/*
+ * 定时
+ */
+
+/** 定时中断 */
+#define sUSV_TimInt(tmid, tick) \
+do{ \
+ su_kernel_locks(); \
+ sc_timint(tmid, tick); \
+ su_kernel_unlocks(); \
+}while(false)
+
+/** 定时查询 */
+#define sUSV_TimQry(tmid, tick) \
+do{ \
+ su_kernel_locks(); \
+ sc_timqry(tmid, tick); \
+ su_kernel_unlocks(); \
+}while(false)
+
+
+/*
+ * 软件RTC
+ */
+
+/** 获取时间 */
+#define sUSV_GetTime(t) \
+( \
+ (m_boolvoid_tf(su_kernel_locks))() || true ? su_kernel_unlocks_rvp(s_memcpy(t, &s_rtc, sizeof(s_rtc))) : OS_NULL \
+)
+
+/** 设置时间 */
+#define sUSV_SetTime(t) \
+do{ \
+ su_kernel_locks(); \
+ s_memcpy(&s_rtc, t, sizeof(s_rtc)); \
+ s_rtc_counter = 1000000UL / SYSCFG_SYSTICK_CYCLE / 2 + 1; \
+ su_kernel_unlocks(); \
+}while(false)
+
+
+/*
+ * 进程内存
+ */
+
+/** malloc */
+#define sUSV_Malloc(size) \
+( \
+ (m_boolvoid_tf(su_kernel_locks))() || true ? su_xalloc((void _MALLOC_MEM_ *)s_malloc(size)) : OS_NULL \
+)
+
+/** calloc */
+#define sUSV_Calloc(nmemb, size) \
+( \
+ (m_boolvoid_tf(su_kernel_locks))() || true ? su_xalloc((void _MALLOC_MEM_ *)s_calloc(nmemb, size)) : OS_NULL \
+)
+
+/** realloc */
+#define sUSV_Realloc(p, size) \
+( \
+ (m_boolvoid_tf(su_kernel_locks))() || true ? su_xalloc((void _MALLOC_MEM_ *)s_realloc(p, size)) : OS_NULL \
+)
+
+/** free */
+#define sUSV_Free(p) \
+do{ \
+ su_kernel_locks(); \
+ s_free(p); \
+ su_kernel_unlocks(); \
+}while(false)
+
+
+/*
+ * 线程内存
+ */
+
+/** 初始化线程内存池 */
+#define sUSV_InitMempool(size) \
+( \
+ (m_boolvoid_tf(su_kernel_locks))() || true ? su_init_mempool(&u_thrmem, size) : false \
+)
+
+/** 线程内存分配 */
+#define sUSV_Talloc(size) \
+( \
+ (m_boolvoid_tf(su_kernel_locks))() || true ? su_xalloc(su_talloc(&u_thrmem, size)) : OS_NULL \
+)
+
+/** 释放线程内存池 */
+#define sUSV_FreeMempool() \
+do{ \
+ sUSV_Free(u_thrmem.head); \
+ u_thrmem.head = u_thrmem.move = OS_NULL; \
+}while(false)
+
+/** @} */
+/** @} */
+
+#endif
diff --git a/System/sv_tick.c b/System/sv_tick.c
new file mode 100644
index 00000000..136603a9
--- /dev/null
+++ b/System/sv_tick.c
@@ -0,0 +1,70 @@
+/**************************************************************************//**
+ * @item CosyOS-III Kernel
+ * @file sv_tick.c
+ * @brief 滴答服务
+ * @details 仅在 SysTick中断 中调用并执行。
+ * @author 迟凯峰
+ * @version v3.0.0
+ * @date 2026.07.21
+ ******************************************************************************/
+
+#include "os_var.h"
+#include "sv_com.h"
+
+/**
+ @addtogroup 滴答服务
+ @{
+ */
+
+#if (SYSCFG_SEMAPHORE == __ENABLED__)
+/**
+ \brief 获取计数信号量
+ \param[in] hsem 计数信号量句柄
+ \return 结果
+ \retval false 失败
+ \retval true 成功
+ */
+bool st_take_semaph(s_semaph_tsp hsem) MCUCFG_OSIT_ATTRIBUTE
+{
+ s_semaph_t counter = hsem->counter;
+ if(counter){
+ hsem->counter = counter - 1;
+ return true;
+ }
+ return false;
+}
+#endif
+
+#if (SYSCFG_MSGQUEUE == __ENABLED__)
+/**
+ \brief 接收消息
+ \param[in] hque 队列句柄
+ \return 消息指针
+ \retval NULL 无消息
+ */
+void *st_recv_msg(s_msgque_tsp hque) MCUCFG_OSIT_ATTRIBUTE
+{
+ void *msg = OS_NULL;
+ #if (SYSCFG_MSGQUEUE_INTRECV == __ENABLED__)
+ hque->lock = false;
+ __mx_MMB();
+ #endif
+
+ if(hque->counter){
+ if(hque->type == __DYNAMIC__){
+ msg = sc_recv_msg_dynque((s_dynque_tsp)hque);
+ }
+ else{
+ msg = sc_recv_msg_staque((s_staque_tsp)hque);
+ }
+ }
+
+ #if (SYSCFG_MSGQUEUE_INTRECV == __ENABLED__)
+ __mx_MMB();
+ hque->lock = true;
+ #endif
+ return msg;
+}
+#endif
+
+/** @} */
diff --git a/System/sv_tick.h b/System/sv_tick.h
new file mode 100644
index 00000000..6c9b38b0
--- /dev/null
+++ b/System/sv_tick.h
@@ -0,0 +1,98 @@
+/**************************************************************************//**
+ * @item CosyOS-III Kernel
+ * @file sv_tick.h
+ * @brief 滴答服务
+ * @details 仅在 SysTick中断 中调用并执行。
+ * @author 迟凯峰
+ * @version v3.0.0
+ * @date 2026.07.21
+ ******************************************************************************/
+
+#ifndef __SV_TICK_H
+#define __SV_TICK_H
+
+#include "os_redef.h"
+bool st_take_semaph (s_semaph_tsp hsem);
+void *st_recv_msg (s_msgque_tsp hque);
+
+/**
+ @addtogroup CosyOS_内核服务
+ @{
+ *//**
+ \defgroup 滴答服务
+ \brief 仅在 SysTick中断 中调用并执行的服务。
+ 包括直接在 SysTick中断 中调用，在滴答钩子（tick_hook）、定时中断钩子（u_timint_##tmid）、
+ 定时查询钩子（u_timqry_##tmid）、定时查询事件（u_timqryevent_##tmid）中调用。
+ @{
+ */
+
+#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_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_BackBin(bin) \
+do{ \
+ __mx_MMB(); \
+ bin.binary = true; \
+}while(false)
+
+/** 发送私信 */
+#define sTSV_SendTaskmsg(task) \
+ s_taskmsg_sign = 1; \
+ sa_block_to_ready(task); \
+ u_task_##task
+
+/** 设置时间 */
+#define sTSV_SetTime(t) \
+do{ \
+ s_memcpy(&s_rtc, t, sizeof(s_rtc)); \
+ s_rtc_counter = 1000000UL / SYSCFG_SYSTICK_CYCLE / 2 + 1; \
+}while(false)
+
+/** 查询标志组 */
+#define sTSV_QueryFlagGroup(group) \
+( \
+ sizeof(group) == 1 ? *(s_u8_t *)&group ? true : false \
+ : sizeof(group) == 2 ? *(s_u16_t *)&group ? true : false \
+ : sizeof(group) == 4 ? *(s_u32_t *)&group ? true : false \
+ : false \
+)
+
+/** 清除标志组 */
+#define sTSV_ClearFlagGroup(group) \
+do{ \
+ 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)
+
+/** 写多标志位 */
+#define sTSV_WriteFlagBits(group, value, nbit) \
+ stWriteFlagBits_##nbit(group, value,
+
+/** @} */
+/** @} */
+
+#endif
diff --git a/System/ur_api.h b/System/ur_api.h
new file mode 100644
index 00000000..fe7d8d23
--- /dev/null
+++ b/System/ur_api.h
@@ -0,0 +1,2103 @@
+/**************************************************************************//**
+ * @item CosyOS-III Kernel
+ * @file ur_api.h
+ * @brief 用户API
+ * @details 用户API定义，含注释说明，所有内核服务的API说明均在此文件中，并支持doxygen。
+ * @author 迟凯峰
+ * @version v3.0.0
+ * @date 2026.07.21
+ ******************************************************************************/
+
+#ifndef __UR_API_H
+#define __UR_API_H
+
+#include "os_redef.h"
+
+/**
+ \page CosyOS_API_DESCRIBE 概述：API说明
+ 用户通过调用API来实现对系统服务的调用，所有API均为宏定义，所有API参数均支持宏定义。
+
+
+
+ \li API分类
+
+ \li 创建API
+ 静态创建[前缀：u]：分为 声明对象（uExtern）、创建对象（uCreate）、定义对象（uDef）。
+ 动态创建[前缀：d]：分为 声明对象（dExtern）、创建对象（dCreate）。
+
+ \li 任务API[前缀：u]
+ 仅在 任务 中调用。
+
+ \li 滴答API[前缀：t]
+ 仅在 SysTick中断 中调用。
+ 包括直接在 SysTick中断 中调用，在滴答钩子（tick_hook）、定时中断钩子（u_timint_##tmid）、
+ 定时查询钩子（u_timqry_##tmid）、定时查询事件（u_timqryevent_##tmid）中调用。
+
+ \li PSVAPI[前缀：p]
+ 仅在 PendSV中断 中调用。
+ 包括通过挂起服务调用（iPendSVC）间接调用、在挂起服务钩子（pendsv_hook）中调用。
+
+ \li 中断API[前缀：i]
+ 仅在 用户中断 中调用。
+ 包括 中断本地服务、中断FIFO服务。
+
+ \li 公共API[前缀：x]
+ 可在 任意处 调用。
+
+
+
+ \li API返回
+
+ \li 无返回
+ （1）服务的执行结果一定是成功的，所以不需要返回。
+ （2）所有中断挂起服务_FIFO均无法直接返回，但其中的部分服务允许支持错误调用返回。
+
+ \li 返回错误码
+ 服务的执行结果可能会失败，导致失败的原因可能有多个。
+ （1）无错误。
+ （2）由于结果已经成功，导致本次并未执行。
+ （3）失败。
+
+ \li 返回结果
+ 服务的执行结果可能会失败，但导致失败的原因是唯一的。
+ 执行结果为 bool 类型，true 为成功，false 为失败。
+
+ \li 返回指针
+ 返回一个指针，(void *) 类型，NULL 为失败。
+
+ \li 返回值
+ 返回一个数值，特定的数据类型，0 为失败。
+
+
+
+ \li 名词解释
+
+ \li 无限阻塞
+ 阻塞时间为无限长。
+
+ \li 无限等待
+ 超时时间为无限长。
+
+ \li 无限延时
+ 延时时间为无限长。
+
+ \li 无限同步
+ 仅同步一次，事件处理线程便可不限次数的周期运行处理事件。
+ 仅二值信号量支持该功能，可通过上锁的方式来终止无限同步。
+
+
+ */
+
+/**
+ \defgroup CosyOS_用户API
+ @{
+ */
+
+/**************************************************************************//**
+ \ingroup CosyOS_用户API
+ \defgroup 构建系统
+ \brief 系统构建相关服务。
+ @{
+ */
+
+/**
+ \brief 启动-CosyOS
+ \param 无
+ \return 错误码
+ \note 用户应自主创建main函数，并在其末尾处调用该函数来启动-CosyOS；
+ 在正常情况下，该函数并不会返回，而是直接调度至 Starter 运行；
+ 只有在 Sysidle / Starter 启动失败时，才会返回错误码提示用户。
+ */
+s_ecode_t uStartCosyOS(void);
+
+/**
+ \brief CosyOS-滴答
+ \param 无
+ \return 无
+ \note 对于Arm用户来说，您应自主创建 SysTick_Handler()，并在其中调用该服务。
+ \warning 对于51/251用户来说，系统滴答中断固定采用定时器0中断，并由CosyOS托管，
+ 您应屏蔽掉工程中原有的定时器0中断函数以避免冲突。
+ */
+void tCosyTick_Handler(void);
+
+/** @} */
+
+/**************************************************************************//**
+ \ingroup CosyOS_用户API
+ \defgroup 任务
+ \brief 任务线程的声明、创建、启动，及操作。
+ @{
+ */
+
+/**
+ \ingroup 任务
+ \defgroup 声明任务
+ \brief 任务线程的声明
+ \note 首先，声明任务不一定是必须的，当仅在一个c文件中启动、操作任务时，时常并不需要声明。
+ \note 在声明任务时，通常无论是在h文件中声明还是在c文件中声明，都应采用完整声明方式，
+ 只有在编译器发出警告，与该任务相关的全局变量未引用时，再考虑简化声明方式。
+ 通常这种情况并不会发生，典型的是在使用GCC(GNU)编译器时，可能偶尔会出现这种警告。
+ @{
+ */
+
+/**
+ \brief 简化声明静态一般任务
+ \param[in] task 任务名称
+ \return 无
+ */
+#define uExtTask(task) sCSV_ExtTask(task)(void)
+
+/**
+ \brief 简化声明动态一般任务
+ \param[in] task 任务名称
+ \return 无
+ */
+#define dExtTask(task) dCSV_ExtTask(task)(void)
+
+/**
+ \brief 完整声明静态一般任务
+ \param[in] task 任务名称
+ \return 无
+ */
+#define uExternTask(task) sCSV_ExternTask(task)(void)
+
+/**
+ \brief 完整声明动态一般任务
+ \param[in] task 任务名称
+ \return 无
+ */
+#define dExternTask(task) dCSV_ExternTask(task)(void)
+
+/**
+ \brief 简化声明静态私信任务
+ \param[in] task 任务名称
+ \param[in] add(...) 附加私信形参
+ \return 无
+ */
+#define uExtTaskmsg(task) sCSV_ExtTask(task)
+
+/**
+ \brief 简化声明动态私信任务
+ \param[in] task 任务名称
+ \param[in] add(...) 附加私信形参
+ \return 无
+ */
+#define dExtTaskmsg(task) dCSV_ExtTask(task)
+
+/**
+ \brief 完整声明静态私信任务
+ \param[in] task 任务名称
+ \param[in] add(...) 附加私信形参
+ \return 无
+ */
+#define uExternTaskmsg(task) sCSV_ExternTask(task)
+
+/**
+ \brief 完整声明动态私信任务
+ \param[in] task 任务名称
+ \param[in] add(...) 附加私信形参
+ \return 无
+ */
+#define dExternTaskmsg(task) dCSV_ExternTask(task)
+
+/** @} */
+
+/**
+ \ingroup 任务
+ \defgroup 创建任务
+ \brief 任务线程的创建
+ @{
+ */
+
+/**
+ \brief 静态创建一般任务
+ \param[in] task 任务名称
+ \param[in] pri 任务优先级
+ \param[in] tss 任务栈大小（单位为字节）
+ \param[in] srt 安全运行时（单位为滴答周期，0为无限长）
+ \param[in] res 任务名称文本
+ \param[in] add{...} 附加任务代码
+ \return 无
+ */
+#define uCreateTask(task, pri, tss, srt, res) \
+ sCSV_CreateTask(task, pri, tss, srt, SYSCFG_CREATETASKCUSTOM(task, res))
+
+/**
+ \brief 动态创建一般任务
+ \param[in] task 任务名称
+ \param[in] pri 任务优先级
+ \param[in] tss 任务栈大小（单位为字节）
+ \param[in] srt 安全运行时（单位为滴答周期，0为无限长）
+ \param[in] res 任务名称文本
+ \param[in] add{...} 附加任务代码
+ \return 无
+ */
+#define dCreateTask(task, pri, tss, srt, res) \
+ dCSV_CreateTask(task, pri, tss, srt, SYSCFG_CREATETASKCUSTOM(task, res))
+
+/**
+ \brief 静态创建私信任务
+ \param[in] task 任务名称
+ \param[in] pri 任务优先级
+ \param[in] tss 任务栈大小（单位为字节）
+ \param[in] srt 安全运行时（单位为滴答周期，0为无限长）
+ \param[in] res 任务名称文本
+ \param[in] ntm 私信参数数量（1~8 个）
+ \param[in] add(...) 附加私信形参
+ 形参类型：任意数据类型
+ 形参名称：必须依次为 tm1、tm2...
+ 示 例：(int tm1, float tm2, char *tm3)
+ \param[in] add{...} 附加任务代码
+ \return 无
+ */
+#define uCreateTaskmsg(task, pri, tss, srt, res, ntm) \
+ sCSV_CreateTaskmsg(task, pri, tss, srt, SYSCFG_CREATETASKCUSTOM(task, res), ntm)
+
+/**
+ \brief 动态创建私信任务
+ \param[in] task 任务名称
+ \param[in] pri 任务优先级
+ \param[in] tss 任务栈大小（单位为字节）
+ \param[in] srt 安全运行时（单位为滴答周期，0为无限长）
+ \param[in] res 任务名称文本
+ \param[in] ntm 私信参数数量（1~8 个）
+ \param[in] add(...) 附加私信形参
+ 形参类型：任意数据类型
+ 形参名称：必须依次为 tm1、tm2...
+ 示 例：(int tm1, float tm2, char *tm3)
+ \param[in] add{...} 附加任务代码
+ \return 无
+ */
+#define dCreateTaskmsg(task, pri, tss, srt, res, ntm) \
+ dCSV_CreateTaskmsg(task, pri, tss, srt, SYSCFG_CREATETASKCUSTOM(task, res), ntm)
+
+/**
+ \brief 静态创建定时中断任务
+ \param[in] tmid 定时中断定时器ID
+ \param[in] arl 自动重装载
+ \param[in] task 任务名称
+ \param[in] pri 任务优先级
+ \param[in] tss 任务栈大小（单位为字节）
+ \param[in] srt 安全运行时（单位为滴答周期，0为无限长）
+ \param[in] res 任务名称文本
+ \param[in] add{...} 附加任务代码
+ \return 无
+ */
+#define uCreateTask_TimInt(tmid, arl, task, pri, tss, srt, res) \
+ sCSV_CreateTask_TimInt(tmid, arl, task, pri, tss, srt, SYSCFG_CREATETASKCUSTOM(task, res))
+
+/**
+ \brief 动态创建定时中断任务
+ \param[in] tmid 定时中断定时器ID
+ \param[in] arl 自动重装载
+ \param[in] task 任务名称
+ \param[in] pri 任务优先级
+ \param[in] tss 任务栈大小（单位为字节）
+ \param[in] srt 安全运行时（单位为滴答周期，0为无限长）
+ \param[in] res 任务名称文本
+ \param[in] add{...} 附加任务代码
+ \return 无
+ */
+#define dCreateTask_TimInt(tmid, arl, task, pri, tss, srt, res) \
+ dCSV_CreateTask_TimInt(tmid, arl, task, pri, tss, srt, SYSCFG_CREATETASKCUSTOM(task, res))
+
+/**
+ \brief 静态创建定时查询任务
+ \param[in] tmid 定时查询定时器ID
+ \param[in] event 定时查询事件
+ \param[in] arl 自动重装载
+ \param[in] task 任务名称
+ \param[in] pri 任务优先级
+ \param[in] tss 任务栈大小（单位为字节）
+ \param[in] srt 安全运行时（单位为滴答周期，0为无限长）
+ \param[in] res 任务名称文本
+ \param[in] add{...} 附加任务代码
+ \return 无
+ */
+#define uCreateTask_TimQry(tmid, event, arl, task, pri, tss, srt, res) \
+ sCSV_CreateTask_TimQry(tmid, event, arl, task, pri, tss, srt, SYSCFG_CREATETASKCUSTOM(task, res))
+
+/**
+ \brief 动态创建定时查询任务
+ \param[in] tmid 定时查询定时器ID
+ \param[in] event 定时查询事件
+ \param[in] arl 自动重装载
+ \param[in] task 任务名称
+ \param[in] pri 任务优先级
+ \param[in] tss 任务栈大小（单位为字节）
+ \param[in] srt 安全运行时（单位为滴答周期，0为无限长）
+ \param[in] res 任务名称文本
+ \param[in] add{...} 附加任务代码
+ \return 无
+ */
+#define dCreateTask_TimQry(tmid, event, arl, task, pri, tss, srt, res) \
+ dCSV_CreateTask_TimQry(tmid, event, arl, task, pri, tss, srt, SYSCFG_CREATETASKCUSTOM(task, res))
+
+/** @} */
+
+/**
+ \ingroup 任务
+ \defgroup 启动任务
+ \brief 任务线程的启动。任务只有在启动以后，才能加入到任务队列参与调度并运行。
+ \warning 所有定时中断任务和定时查询任务均由操作系统自动启动，用户不要启动。
+ \warning 不支持在临界区中，包括任务临界区、服务层临界区、全局临界区，或关闭总中断时调用。
+ @{
+ */
+
+/**
+ \brief 启动任务
+ \details 启动任务并置任务的初始状态为设定状态。
+ \param[in] task 任务名称
+ \param[in] status 任务初始状态
+ 就绪状态：OS_STATUS_READY
+ 阻塞状态：OS_STATUS_BLOCKED，阻塞类型为延时阻塞，延时时间为无限长。
+ 挂起状态：OS_STATUS_SUSPENDED，先前状态为就绪状态。
+ \return 错误码（s_ecode_t）
+ \retval OS_ECODE_NOERROR 无错误
+ \retval OS_ECODE_TASKSTARTED 任务已启动
+ \retval OS_ECODE_OVERFLOW_TASKSTACK 任务栈溢出
+ \retval OS_ECODE_MALLOCFAIL_TASKNODE 任务节点内存分配失败
+ \retval OS_ECODE_MALLOCFAIL_TASKSTACK 任务栈内存分配失败
+ */
+#if (SYSCFG_TASKMSG == __ENABLED__)
+#define uStartTask(task, status) \
+ sUSV_StartTask_1(&sCat2Str(u_taskload_, task), status, sCat2Str(u_task_, task))
+#else
+#define uStartTask(task, status) \
+ sUSV_StartTask_0(&sCat2Str(u_taskload_, task), status)
+#endif
+
+/**
+ \brief 启动任务并就绪
+ \details 启动任务并置任务的初始状态为就绪状态。
+ \param[in] task 任务名称
+ \return 错误码（s_ecode_t）
+ \retval OS_ECODE_NOERROR 无错误
+ \retval OS_ECODE_TASKSTARTED 任务已启动
+ \retval OS_ECODE_OVERFLOW_TASKSTACK 任务栈溢出
+ \retval OS_ECODE_MALLOCFAIL_TASKNODE 任务节点内存分配失败
+ \retval OS_ECODE_MALLOCFAIL_TASKSTACK 任务栈内存分配失败
+ */
+#define uStartTask_Ready(task) \
+ uStartTask(task, OS_STATUS_READY)
+
+/**
+ \brief 启动任务并阻塞
+ \details 启动任务并置任务的初始状态为阻塞状态（阻塞类型为延时阻塞，延时时间为无限长）。
+ \param[in] task 任务名称
+ \return 错误码（s_ecode_t）
+ \retval OS_ECODE_NOERROR 无错误
+ \retval OS_ECODE_TASKSTARTED 任务已启动
+ \retval OS_ECODE_OVERFLOW_TASKSTACK 任务栈溢出
+ \retval OS_ECODE_MALLOCFAIL_TASKNODE 任务节点内存分配失败
+ \retval OS_ECODE_MALLOCFAIL_TASKSTACK 任务栈内存分配失败
+ */
+#define uStartTask_Block(task) \
+ uStartTask(task, OS_STATUS_BLOCKED)
+
+/**
+ \brief 启动任务并挂起
+ \details 启动任务并置任务的初始状态为挂起状态（先前状态为就绪状态）。
+ \param[in] task 任务名称
+ \return 错误码（s_ecode_t）
+ \retval OS_ECODE_NOERROR 无错误
+ \retval OS_ECODE_TASKSTARTED 任务已启动
+ \retval OS_ECODE_OVERFLOW_TASKSTACK 任务栈溢出
+ \retval OS_ECODE_MALLOCFAIL_TASKNODE 任务节点内存分配失败
+ \retval OS_ECODE_MALLOCFAIL_TASKSTACK 任务栈内存分配失败
+ */
+#define uStartTask_Suspend(task) \
+ uStartTask(task, OS_STATUS_SUSPENDED)
+
+/** @} */
+
+/**
+ \ingroup 任务
+ \defgroup 操作任务
+ \brief 对任意任务的操作，如 恢复、挂起、删除、设置优先级 等。
+ @{
+ */
+
+/**
+ \brief 清除就绪延时
+ \details 清除当前任务的就绪延时，前提是当前任务已在就绪延时中。
+ \param 无
+ \return 无
+ \note 同型服务：
+ pClearDelay()。
+ iClearDelay()。
+ */
+#define tClearDelay() sTSV_ClearDelay()
+
+/**
+ \brief 恢复任务
+ \param[in] task 任务名称
+ \return 错误码（s_ecode_t）
+ \retval OS_ECODE_NOERROR 无错误
+ \retval OS_ECODE_TASKNOTSUSPENDED 任务未挂起
+ \retval OS_ECODE_TASKSTOPPED 任务已停止
+ \retval OS_ECODE_TASKNOTSTARTED 任务未启动/已删除
+ \note 同型服务：
+ tResumeTask(task)，同返回。
+ pResumeTask(task)，同返回。
+ iResumeTask(task)，无返回/错误调用返回。
+ */
+#define uResumeTask(task) sUSV_ResumeTask(task)
+
+/**
+ \brief 挂起任务
+ \param[in] task 任务名称
+ \return 错误码（s_ecode_t）
+ \retval OS_ECODE_NOERROR 无错误
+ \retval OS_ECODE_TASKSUSPENDED 任务已挂起
+ \retval OS_ECODE_TASKSTOPPED 任务已停止
+ \retval OS_ECODE_TASKNOTSTARTED 任务未启动/已删除
+ \note 同型服务：
+ tSuspendTask(task)，同返回。
+ pSuspendTask(task)，同返回。
+ iSuspendTask(task)，无返回/错误调用返回。
+ */
+#define uSuspendTask(task) sUSV_SuspendTask(task)
+
+/**
+ \brief 删除任务
+ \param[in] task 任务名称
+ \return 错误码（s_ecode_t）
+ \retval OS_ECODE_NOERROR 无错误
+ \retval OS_ECODE_TASKNOTSTARTED 任务未启动/已删除
+ \note 同型服务：
+ tDeleteTask(task)，同返回。
+ pDeleteTask(task)，同返回。
+ iDeleteTask(task)，无返回/错误调用返回。
+ */
+#define uDeleteTask(task) sUSV_DeleteTask(task)
+
+/**
+ \brief 重置任务
+ \details 任务立即结束，不保留任何状态信息及过程数据，再返回线程入口处重新开始。
+ \note 其作用效果相当于删除任务后再重新启动任务。
+ \param[in] task 任务名称
+ \param[in] status 任务初始状态
+ \return 错误码（s_ecode_t）
+ \retval OS_ECODE_NOERROR 无错误
+ \retval OS_ECODE_TASKNOTSTARTED 任务未启动/已删除
+ \note 同型服务：
+ tResetTask(task, status)，同返回。
+ pResetTask(task, status)，同返回。
+ iResetTask(task, status)，无返回/错误调用返回。
+ */
+#define uResetTask(task, status) sUSV_ResetTask(task, status)
+
+/**
+ \brief 设置任务优先级
+ \param[in] task 任务名称
+ \param[in] npri 新优先级
+ \return 错误码（s_ecode_t）
+ \retval OS_ECODE_NOERROR 无错误
+ \retval OS_ECODE_TASKPRIUNCHANGED 任务优先级未改变
+ \retval OS_ECODE_TASKSTOPPED 任务已停止
+ \retval OS_ECODE_TASKNOTSTARTED 任务未启动/已删除
+ \note 同型服务：
+ tSetTaskPri(task, npri)，同返回。
+ pSetTaskPri(task, npri)，同返回。
+ iSetTaskPri(task, npri)，无返回/错误调用返回。
+ */
+#define uSetTaskPri(task, npri) sUSV_SetTaskPri(task, npri)
+
+/**
+ \brief 清除阻塞（状态）
+ \details 清除指定任务的阻塞状态并使其就绪。
+ \param[in] task 任务名称
+ \return 错误码（s_ecode_t）
+ \retval OS_ECODE_NOERROR 无错误
+ \retval OS_ECODE_TASKNOTBLOCKED 任务未阻塞
+ \retval OS_ECODE_TASKNOTSTARTED 任务未启动/已删除
+ \note 同型服务：
+ tClearBlock(task)，同返回。
+ pClearBlock(task)，同返回。
+ iClearBlock(task)，无返回/错误调用返回。
+ */
+#define uClearBlock(task) sUSV_ClearBlock(task)
+
+/**
+ \ingroup 操作任务
+ \defgroup 设置阻塞（时间）
+ \brief 设置、修改指定任务的阻塞时间，前提是该任务当前已为阻塞状态。
+ \note 理想误差：-1tick。
+ \warning 按 毫秒、秒钟、分钟、小时 设置，用户需自己保证时间的有效性（可被系统滴答周期整除）。
+ \warning 无限阻塞，仅能通过调用 xSetBlock_tc(task, ~0) 来实现。
+ @{
+ */
+
+/**
+ \brief 设置阻塞-滴答周期
+ \param[in] task 任务名称
+ \param[in] tc 滴答周期（阻塞时间）
+ +0：清除阻塞
+ ~0：无限阻塞
+ \return 错误码（s_ecode_t）
+ \retval OS_ECODE_NOERROR 无错误
+ \retval OS_ECODE_TASKNOTBLOCKED 任务未阻塞
+ \retval OS_ECODE_TASKNOTSTARTED 任务未启动/已删除
+ \note 同型服务：
+ tSetBlock_tc(task, tc)，同返回。
+ pSetBlock_tc(task, tc)，同返回。
+ iSetBlock_tc(task, tc)，无返回/错误调用返回。
+ */
+#define uSetBlock_tc(task, tc) sUSV_SetBlock(task, tc)
+
+/**
+ \brief 设置阻塞-毫秒
+ \param[in] task 任务名称
+ \param[in] ms 毫秒（阻塞时间）
+ 0：清除阻塞
+ \return 错误码（s_ecode_t）
+ \retval OS_ECODE_NOERROR 无错误
+ \retval OS_ECODE_TASKNOTBLOCKED 任务未阻塞
+ \retval OS_ECODE_TASKNOTSTARTED 任务未启动/已删除
+ \note 同型服务：
+ tSetBlock_ms(task, ms)，同返回。
+ pSetBlock_ms(task, ms)，同返回。
+ iSetBlock_ms(task, ms)，无返回/错误调用返回。
+ */
+#define uSetBlock_ms(task, ms) uSetBlock_tc(task, (1000UL * (ms)) / SYSCFG_SYSTICK_CYCLE)
+
+/**
+ \brief 设置阻塞-秒钟
+ \param[in] task 任务名称
+ \param[in] s 秒钟（阻塞时间）
+ 0：清除阻塞
+ \return 错误码（s_ecode_t）
+ \retval OS_ECODE_NOERROR 无错误
+ \retval OS_ECODE_TASKNOTBLOCKED 任务未阻塞
+ \retval OS_ECODE_TASKNOTSTARTED 任务未启动/已删除
+ \note 同型服务：
+ tSetBlock_s(task, s)，同返回。
+ pSetBlock_s(task, s)，同返回。
+ iSetBlock_s(task, s)，无返回/错误调用返回。
+ */
+#define uSetBlock_s(task, s) uSetBlock_ms(task, 1000UL * (s))
+
+/**
+ \brief 设置阻塞-分钟
+ \param[in] task 任务名称
+ \param[in] m 分钟（阻塞时间）
+ 0：清除阻塞
+ \return 错误码（s_ecode_t）
+ \retval OS_ECODE_NOERROR 无错误
+ \retval OS_ECODE_TASKNOTBLOCKED 任务未阻塞
+ \retval OS_ECODE_TASKNOTSTARTED 任务未启动/已删除
+ \note 同型服务：
+ tSetBlock_m(task, m)，同返回。
+ pSetBlock_m(task, m)，同返回。
+ iSetBlock_m(task, m)，无返回/错误调用返回。
+ */
+#define uSetBlock_m(task, m) uSetBlock_s(task, 60UL * (m))
+
+/**
+ \brief 设置阻塞-小时
+ \param[in] task 任务名称
+ \param[in] h 小时（阻塞时间）
+ 0：清除阻塞
+ \return 错误码（s_ecode_t）
+ \retval OS_ECODE_NOERROR 无错误
+ \retval OS_ECODE_TASKNOTBLOCKED 任务未阻塞
+ \retval OS_ECODE_TASKNOTSTARTED 任务未启动/已删除
+ \note 同型服务：
+ tSetBlock_h(task, h)，同返回。
+ pSetBlock_h(task, h)，同返回。
+ iSetBlock_h(task, h)，无返回/错误调用返回。
+ */
+#define uSetBlock_h(task, h) uSetBlock_m(task, 60UL * (h))
+
+/** @} */
+/** @} */
+/**
+ \ingroup 任务
+ \defgroup 操作自身任务
+ \brief 仅适用于对自身任务的操作
+ @{
+ */
+
+/**
+ \brief 禅让任务
+ \details 自身任务主动禅让CPU使用权，轮转至下一个相同优先级的任务运行。
+ \param 无
+ \return 无
+ \note 禅让后，任务仍为就绪状态。
+ \note 多个相同优先级的任务，通过禅让的方式可实现协作式任务。
+ \warning 当开启相同优先级任务的协作式调度或时间片轮转调度时，才支持此项服务。
+ */
+#define uYieldTasking() su_yield_tasking()
+
+/**
+ \brief 设置自身任务优先级
+ \param[in] npri 新优先级
+ \return 错误码（s_ecode_t）
+ \retval OS_ECODE_NOERROR 无错误
+ \retval OS_ECODE_TPLUNCHANGED 优先级未改变
+ */
+#define uSetTaskingPri(npri) sUSV_SetTaskPri(s_task_current, npri)
+
+/**
+ \brief 挂起自身任务
+ \param 无
+ \return 错误码（s_ecode_t）
+ \note 虽然也返回错误码，但在正常情况下结果一定是成功的，不必查看错误码。
+ */
+#define uSuspendTasking() sUSV_SuspendTask(s_task_current)
+
+/**
+ \brief 删除自身任务
+ \param 无
+ \return 错误码（s_ecode_t）
+ \note 虽然也返回错误码，但在正常情况下结果一定是成功的，不必查看错误码。
+ */
+#define uDeleteTasking() sUSV_DeleteTask(s_task_current)
+
+/**
+ \brief 恢复指定任务并挂起自身任务
+ \param[in] task 指定任务名称
+ \return 错误码（s_ecode_t）
+ \retval OS_ECODE_NOERROR 无错误
+ \retval OS_ECODE_TASKNOTREADY 指定任务未就绪
+ \retval OS_ECODE_TASKSTOPPED 指定任务已停止
+ \retval OS_ECODE_TASKNOTSTARTED 指定任务未启动/已删除
+ \note 当返回错误时，指定任务未能恢复为就绪状态，自身任务不会挂起。
+ */
+#define uResumeSuspend(task) sUSV_ResumeSuspend(task)
+
+/**
+ \ingroup 操作自身任务
+ \defgroup 自身任务延时
+ \brief 自身任务延时分为阻塞延时和就绪延时。
+ \note 阻塞延时：在延时期间，任务会进入阻塞状态，把CPU使用权转让给其它任务。
+ \note 就绪延时：在延时期间，任务会维持就绪状态，原地等待延时时间到达，不转让CPU使用权。
+ \note 当在任务临界区中，自动选择为就绪延时，否则选择为阻塞延时。
+ \note 理想误差：-1tick。
+ \warning 按 毫秒、秒钟、分钟、小时 延时，用户需自己保证时间的有效性（可被系统滴答周期整除）。
+ \warning 无限延时，仅能通过调用 uDelay_tc(~0) 来实现。
+ \warning 不支持在服务层临界区、全局临界区，或关闭总中断时调用。
+ @{
+ */
+
+/**
+ \brief 延时-滴答周期
+ \param[in] tc 滴答周期（延时时间）
+ ~0：无限延时
+ \return 无
+ */
+#define uDelay_tc(tc) sUSV_Delay(tc)
+
+/**
+ \brief 延时-毫秒
+ \param[in] ms 毫秒（延时时间）
+ \return 无
+ */
+#define uDelay_ms(ms) uDelay_tc((1000UL * (ms)) / SYSCFG_SYSTICK_CYCLE)
+
+/**
+ \brief 延时-秒钟
+ \param[in] s 秒钟（延时时间）
+ \return 无
+ */
+#define uDelay_s(s) uDelay_ms(1000UL * (s))
+
+/**
+ \brief 延时-分钟
+ \param[in] m 分钟（延时时间）
+ \return 无
+ */
+#define uDelay_m(m) uDelay_s(60UL * (m))
+
+/**
+ \brief 延时-小时
+ \param[in] h 小时（延时时间）
+ \return 无
+ */
+#define uDelay_h(h) uDelay_m(60UL * (h))
+/** @} */
+/** @} */
+/** @} */
+/**************************************************************************//**
+ \ingroup CosyOS_用户API
+ \defgroup 定时中断
+ \brief 由用户定时操作，当定时器溢出时，系统将自动恢复/调用与其绑定的任务/钩子并可自动重复定时。
+ \note 理想误差：-1tick。
+ \warning 按 毫秒、秒钟、分钟、小时 定时，用户需自己保证时间的有效性（可被系统滴答周期整除）。
+ @{
+ */
+
+/**
+ \brief 创建定时中断钩子
+ \param[in] tmid 定时器ID
+ \param[in] arl 自动重装载设置
+ 0：关闭自动重装载
+ 1：开启自动重装载
+ \param[in] add{...} 附加钩子代码
+ \return 无
+ */
+#define uCreateHook_TimInt(tmid, arl) \
+ sCSV_CreateHook_TimInt(tmid, arl)
+
+/**
+ \brief 定时中断-滴答周期
+ \param[in] tmid 定时中断定时器ID
+ \param[in] tc 滴答周期（定时时间）
+ \return 无
+ \note 同型服务：
+ tTimInt_tc(tmid, tc)。
+ iTimInt_tc(tmid, tc)。
+ */
+#define uTimInt_tc(tmid, tc) sUSV_TimInt(tmid, tc)
+
+/**
+ \brief 定时中断-毫秒
+ \param[in] tmid 定时中断定时器ID
+ \param[in] ms 毫秒（定时时间）
+ \return 无
+ \note 同型服务：
+ tTimInt_ms(tmid, ms)。
+ iTimInt_ms(tmid, ms)。
+ */
+#define uTimInt_ms(tmid, ms) uTimInt_tc(tmid, (1000UL * (ms)) / SYSCFG_SYSTICK_CYCLE)
+
+/**
+ \brief 定时中断-秒钟
+ \param[in] tmid 定时中断定时器ID
+ \param[in] s 秒钟（定时时间）
+ \return 无
+ \note 同型服务：
+ tTimInt_s(tmid, s)。
+ iTimInt_s(tmid, s)。
+ */
+#define uTimInt_s(tmid, s) uTimInt_ms(tmid, 1000UL * (s))
+
+/**
+ \brief 定时中断-分钟
+ \param[in] tmid 定时中断定时器ID
+ \param[in] m 分钟（定时时间）
+ \return 无
+ \note 同型服务：
+ tTimInt_m(tmid, m)。
+ iTimInt_m(tmid, m)。
+ */
+#define uTimInt_m(tmid, m) uTimInt_s(tmid, 60UL * (m))
+
+/**
+ \brief 定时中断-小时
+ \param[in] tmid 定时中断定时器ID
+ \param[in] h 小时（定时时间）
+ \return 无
+ \note 同型服务：
+ tTimInt_h(tmid, h)。
+ iTimInt_h(tmid, h)。
+ */
+#define uTimInt_h(tmid, h) uTimInt_m(tmid, 60UL * (h))
+
+/**
+ \brief 终止定时中断
+ \param[in] tmid 定时中断定时器ID
+ \return 无
+ \note 同型服务：
+ tTimInt_Cancel(tmid)。
+ iTimInt_Cancel(tmid)。
+ */
+#define uTimInt_Cancel(tmid) uTimInt_tc(tmid, 0)
+
+/**
+ \brief 定时中断定时器自动重装载
+ \param[in] tmid 定时中断定时器ID
+ \param[in] arl 自动重装载设置
+ 0：关闭自动重装载
+ 1：开启自动重装载
+ \return 无
+ */
+#define xTimInt_AutoReload(tmid, arl) s_timint_autoreload[tmid] = arl
+
+/** @} */
+
+/**************************************************************************//**
+ \ingroup CosyOS_用户API
+ \defgroup 定时查询
+ \brief 由用户定时操作，当定时器溢出后，系统在每个滴答周期都会查询用户定义的事件，
+ 若事件为真，系统将自动恢复/调用与其绑定的任务/钩子并可自动重复定时。
+ \note 理想误差：-1tick。
+ \warning 按 毫秒、秒钟、分钟、小时 定时，用户需自己保证时间的有效性（可被系统滴答周期整除）。
+ @{
+ */
+
+/**
+ \brief 创建定时查询钩子
+ \param[in] tmid 定时器ID
+ \param[in] event 定时查询事件
+ \param[in] arl 自动重装载设置
+ 0：关闭自动重装载
+ 1：开启自动重装载
+ \param[in] add{...} 附加钩子代码
+ \return 无
+ */
+#define uCreateHook_TimQry(tmid, event, arl) \
+ sCSV_CreateHook_TimQry(tmid, event, arl)
+
+/**
+ \brief 定时查询-滴答周期
+ \param[in] tmid 定时查询定时器ID
+ \param[in] tc 滴答周期（定时时间）
+ \return 无
+ \note 同型服务：
+ tTimQry_tc(tmid, tc)。
+ iTimQry_tc(tmid, tc)。
+ */
+#define uTimQry_tc(tmid, tc) sUSV_TimQry(tmid, tc)
+
+/**
+ \brief 定时查询-毫秒
+ \param[in] tmid 定时查询定时器ID
+ \param[in] ms 毫秒（定时时间）
+ \return 无
+ \note 同型服务：
+ tTimQry_ms(tmid, ms)。
+ iTimQry_ms(tmid, ms)。
+ */
+#define uTimQry_ms(tmid, ms) uTimQry_tc(tmid, (1000UL * (ms)) / SYSCFG_SYSTICK_CYCLE)
+
+/**
+ \brief 定时查询-秒钟
+ \param[in] tmid 定时查询定时器ID
+ \param[in] s 秒钟（定时时间）
+ \return 无
+ \note 同型服务：
+ tTimQry_s(tmid, s)。
+ iTimQry_s(tmid, s)。
+ */
+#define uTimQry_s(tmid, s) uTimQry_ms(tmid, 1000UL * (s))
+
+/**
+ \brief 定时查询-分钟
+ \param[in] tmid 定时查询定时器ID
+ \param[in] m 分钟（定时时间）
+ \return 无
+ \note 同型服务：
+ tTimQry_m(tmid, m)。
+ iTimQry_m(tmid, m)。
+ */
+#define uTimQry_m(tmid, m) uTimQry_s(tmid, 60UL * (m))
+
+/**
+ \brief 定时查询-小时
+ \param[in] tmid 定时查询定时器ID
+ \param[in] h 小时（定时时间）
+ \return 无
+ \note 同型服务：
+ tTimQry_h(tmid, h)。
+ iTimQry_h(tmid, h)。
+ */
+#define uTimQry_h(tmid, h) uTimQry_m(tmid, 60UL * (h))
+
+/**
+ \brief 终止定时查询
+ \param[in] tmid 定时查询定时器ID
+ \return 无
+ \note 同型服务：
+ tTimQry_Cancel(tmid)。
+ iTimQry_Cancel(tmid)。
+ */
+#define uTimQry_Cancel(tmid) uTimQry_tc(tmid, ~0)
+
+/**
+ \brief 定时查询定时器自动重装载
+ \param[in] tmid 定时查询定时器ID
+ \param[in] arl 自动重装载设置
+ 0：关闭自动重装载
+ 1：开启自动重装载
+ \return 无
+ */
+#define xTimQry_AutoReload(tmid, arl) s_timqry_autoreload[tmid] = arl
+
+/** @} */
+
+/**************************************************************************//**
+ \ingroup CosyOS_用户API
+ \defgroup 互斥信号量
+ \brief 仅适用于在任务中对任务级公共资源的互斥访问。
+ \note 有优先级继承/天花板机制，以抑制优先级反转的发生。
+ \note 互斥信号量均支持嵌套使用，最大嵌套深度255，获取与归还必须配对使用。
+ \note 如果任务中调用了获取互斥量，应谨慎操作该任务，如操作不当可能会导致获取该互斥量的其它任务死锁。
+ @{
+ */
+
+/**
+ \brief 声明互斥信号量
+ \param[in] mut 互斥信号量名称
+ \return 无
+ */
+#define uExternMut(mut) sCSV_ExternMut(mut)
+
+/**
+ \brief 创建互斥信号量并初始化
+ \param[in] mut 互斥信号量名称
+ \return 无
+ \note 创建互斥信号量时，系统将自动赋初值。
+ */
+#define uCreateMut(mut) sCSV_CreateMut(mut)
+
+/**
+ \brief 创建互斥信号量不初始化
+ \param[in] mut 互斥信号量名称
+ \return 无
+ \note 创建互斥信号量时，系统并不会赋初值。
+ \note 该功能可用来创建互斥信号量数组，或把互斥信号量封装在结构体中，
+ 但用户务必要自行正确初始化互斥信号量（参见下方例程）。
+ \code
+
+// 例程一、互斥量数组
+
+uCreateMut_NotInit(MutArray[8]);
+
+void start_hook(void)
+{
+ uint8_t i;
+ uCreateMut(mut);
+ for(i = 0; i < 8; i++){
+ MutArray[i] = mut;
+ }
+}
+
+
+// 例程二、互斥量为结构体成员
+
+struct{
+ uCreateMut_NotInit(mut);
+ uint8_t array[8];
+}MutStruct;
+
+void start_hook(void)
+{
+ uCreateMut(mut);
+ MutStruct.mut = mut;
+}
+
+ \endcode
+ */
+#define uCreateMut_NotInit(mut) sCSV_CreateMut_NotInit(mut)
+
+/**
+ \brief 获取互斥信号量
+ \param[in] mut 互斥信号量名称
+ \param[in] tc 滴答周期（超时时间）
+ +0：立即返回
+ ~0：无限等待
+ \return 结果（bool）
+ \retval false 失败
+ \retval true 成功
+ \warning 不支持在临界区中，包括任务临界区、服务层临界区、全局临界区，或关闭总中断时调用。
+ */
+#define uTakeMut(mut, tc) sUSV_TakeMut(mut, tc)
+
+/**
+ \brief 归还互斥信号量
+ \param[in] mut 互斥信号量名称
+ \return 无
+ */
+#define uBackMut(mut) sUSV_BackMut(mut)
+
+/** @} */
+
+/**************************************************************************//**
+ \ingroup CosyOS_用户API
+ \defgroup 二值信号量
+ \brief 常用于事件同步、互斥访问（中断与任务之间的互斥）。
+ @{
+ */
+
+/**
+ \brief 声明二值信号量
+ \param[in] bin 二值信号量名称
+ \return 无
+ */
+#define uExternBin(bin) sCSV_ExternBin(bin)
+
+/**
+ \brief 创建二值信号量并初始化
+ \param[in] bin 二值信号量名称
+ \param[in] init 二值信号量初始值
+ false（0）：已上锁，无法立即成功获取
+ true（1） ：已解锁，可以立即成功获取
+ \return 无
+ \note 当用于互斥访问时，初始值应为 true。
+ */
+#define uCreateBin(bin, init) sCSV_CreateBin(bin, init)
+
+/**
+ \brief 创建二值信号量不初始化
+ \param[in] bin 二值信号量名称
+ \return 无
+ \note 创建二值信号量时，系统并不会赋初值。
+ \note 该功能可用来创建二值信号量数组，或把二值信号量封装在结构体中，
+ 但用户务必要自行正确初始化二值信号量（参见互斥信号量例程）。
+ */
+#define uCreateBin_NotInit(bin) sCSV_CreateBin_NotInit(bin)
+
+/**
+ \brief 上锁二值信号量
+ \details 用于终止线程的无限同步。
+ \param[in] bin 二值信号量名称
+ \return 无
+ \note 同型服务：
+ tLockBin(bin)。
+ pLockBin(bin)。
+ iLockBin(bin)。
+ */
+#define uLockBin(bin) bin.binary = false
+
+/**
+ \brief 等待二值信号量
+ \details 在指定的超时时间内等待二值信号量为真，适用于任务的无限同步，与获取的区别是不上锁。
+ \param[in] bin 二值信号量名称
+ \param[in] tc 滴答周期（超时时间）
+ +0：立即返回
+ ~0：无限等待
+ \return 结果（bool）
+ \retval false 失败
+ \retval true 成功
+ \warning 不支持在临界区中，包括任务临界区、服务层临界区、全局临界区，或关闭总中断时调用。
+ */
+#define uWaitBin(bin, tc) sUSV_WaitBin(bin, tc)
+
+/**
+ \brief 给予二值信号量
+ \details 专用于事件同步。
+ \param[in] bin 二值信号量名称
+ \return 无
+ \note 同型服务：
+ tGiveBin(bin)。
+ pGiveBin(bin)。
+ iGiveBin(bin)。
+ */
+#define uGiveBin(bin) sUSV_GiveBin(bin)
+
+/**
+ \brief 获取二值信号量
+ \details 用于事件同步或互斥访问。
+ \param[in] bin 二值信号量名称
+ \param[in] tc 滴答周期（超时时间）
+ +0：立即返回
+ ~0：无限等待
+ \return 结果（bool）
+ \retval false 失败
+ \retval true 成功
+ \note 同型服务：
+ tTakeBin(bin)。
+ iTakeBin(bin)。
+ \warning 任务中获取，不支持在临界区中，包括任务临界区、服务层临界区、全局临界区，或关闭总中断时调用。
+ */
+#define uTakeBin(bin, tc) sUSV_TakeBin(bin, tc)
+
+/**
+ \brief 归还二值信号量
+ \details 专用于互斥访问。
+ \param[in] bin 二值信号量名称
+ \return 无
+ \note 同型服务：
+ tBackBin(bin)。
+ iBackBin(bin)。
+ */
+#define uBackBin(bin) uGiveBin(bin)
+
+/** @} */
+
+/**************************************************************************//**
+ \ingroup CosyOS_用户API
+ \defgroup 计数信号量
+ \brief 常用于事件同步、重入访问（资源管理），是唯一能够实现并发事件同步的手段。
+ @{
+ */
+
+/**
+ \brief 声明计数信号量
+ \param[in] sem 计数信号量名称
+ \return 无
+ */
+#define uExternSem(sem) sCSV_ExternSem(sem)
+
+/**
+ \brief 创建计数信号量并初始化
+ \param[in] sem 计数信号量名称
+ \param[in] init 计数信号量初始值
+ \param[in] max 计数信号量最大值
+ \return 无
+ \note 当用于重入访问时，初始值应等于最大值。
+ */
+#define uCreateSem(sem, init, max) sCSV_CreateSem(sem, init, max)
+
+/**
+ \brief 创建计数信号量不初始化
+ \param[in] sem 计数信号量名称
+ \return 无
+ \note 创建计数信号量时，系统并不会赋初值。
+ \note 该功能可用来创建计数信号量数组，或把计数信号量封装在结构体中，
+ 但用户务必要自行正确初始化计数信号量（参见互斥信号量例程）。
+ */
+#define uCreateSem_NotInit(sem) sCSV_CreateSem_NotInit(sem)
+
+/**
+ \brief 给予计数信号量
+ \param[in] sem 计数信号量名称
+ \return 无
+ \note 同型服务：
+ tGiveSem(sem)。
+ iGiveSem(sem)。
+ */
+#define uGiveSem(sem) sUSV_GiveSem(sem)
+
+/**
+ \brief 获取计数信号量
+ \param[in] sem 计数信号量名称
+ \param[in] tc 滴答周期（超时时间）
+ +0：立即返回
+ ~0：无限等待
+ \return 结果（bool）
+ \retval false 失败
+ \retval true 成功
+ \note 同型服务：
+ tTakeSem(sem)。
+ \warning 任务中获取，不支持在临界区中，包括任务临界区、服务层临界区、全局临界区，或关闭总中断时调用。
+ */
+#define uTakeSem(sem, tc) sUSV_TakeSem(sem, tc)
+
+/**
+ \brief 归还计数信号量
+ \param[in] sem 计数信号量名称
+ \return 无
+ \note 同型服务：
+ tBackSem(sem)。
+ */
+#define uBackSem(sem) uGiveSem(sem)
+
+/** @} */
+
+/**************************************************************************//**
+ \ingroup CosyOS_用户API
+ \defgroup 事件标志组
+ \brief 适用于对一类事件的事件同步。
+ \details 某一类事件，它的发生线程可能会有多个，均同步至同一个事件处理线程中统一处理该类事件。
+ \note 名词解释
+ 组名：标志组的名称
+ 位名：标志位的名称
+ 空位：空标志位
+ \note 查询标志位：任务、滴答、中断中，均直接查询。
+ @{
+ */
+
+/**
+ \brief 声明标志组
+ \param[in] group 组名
+ \param[in] bits 定义各标志位，分号间隔
+ \return 无
+ */
+#define uExternFlagGroup(group, bits) sCSV_ExternFlagGroup(group, bits)
+
+/**
+ \brief 定义标志位
+ \param[in] bit 位名
+ \return 无
+ */
+#define uDefFlagBit(bit) sDefBitField(bit)
+
+/**
+ \brief 定义空位
+ \param[in] nvb 空位的数量
+ \return 无
+ */
+#define uDefVoidBits(nvb) sDefVoidBits(nvb)
+
+/**
+ \brief 创建标志组
+ \param[in] group 组名
+ \param[in] add={...} 附加代码（赋初值）
+ \return 无
+ \note 需用户自行赋初值。
+ */
+#define uCreateFlagGroup(group) sCSV_CreateFlagGroup(group)
+
+/**
+ \brief 等待标志组
+ \param[in] group 组名
+ \param[in] tc 滴答周期（超时时间）
+ +0：立即返回
+ ~0：无限等待
+ \return 结果（bool）
+ \retval false 失败
+ \retval true 成功
+ \warning 不支持在临界区中，包括任务临界区、服务层临界区、全局临界区，或关闭总中断时调用。
+ \warning 事件的各个发生线程中设置标志位后，应调用 uClearBlock(task) 来手动完成事件同步。
+ */
+#define uWaitFlagGroup(group, tc) sUSV_WaitFlagGroup(group, tc)
+
+/**
+ \brief 查询标志组
+ \param[in] group 组名
+ \return 结果（bool）
+ \retval false 失败
+ \retval true 成功
+ \note 同型服务：
+ tQueryFlagGroup(group)。
+ iQueryFlagGroup(group)。
+ */
+#define uQueryFlagGroup(group) sUSV_QueryFlagGroup(group)
+
+/**
+ \brief 清除标志组
+ \param[in] group 组名
+ \return 无
+ \note 同型服务：
+ tClearFlagGroup(group)。
+ iClearFlagGroup(group)。
+ */
+#define uClearFlagGroup(group) sUSV_ClearFlagGroup(group)
+
+/**
+ \brief 设置标志位
+ \param[in] group 组名
+ \param[in] bit 位名
+ \return 无
+ \note 同型服务：
+ tSetFlagBit(group, bit)。
+ iSetFlagBit(group, bit)。
+ */
+#define uSetFlagBit(group, bit) uSetFlagBits(group, 1) bit)
+
+/**
+ \brief 清除标志位
+ \param[in] group 组名
+ \param[in] bit 位名
+ \return 无
+ \note 同型服务：
+ tClearFlagBit(group, bit)。
+ iClearFlagBit(group, bit)。
+ */
+#define uClearFlagBit(group, bit) uClearFlagBits(group, 1) bit)
+
+/**
+ \brief 设置多标志位
+ \param[in] group 组名
+ \param[in] nbit 标志位的数量
+ \param[in] add...) 各位名，逗号间隔
+ \return 无
+ \note 同型服务：
+ tSetFlagBits(group, nbit)。
+ iSetFlagBits(group, nbit)。
+ */
+#define uSetFlagBits(group, nbit) sUSV_WriteFlagBits(group, true, nbit)
+
+/**
+ \brief 清除多标志位
+ \param[in] group 组名
+ \param[in] nbit 标志位的数量
+ \param[in] add...) 各位名，逗号间隔
+ \return 无
+ \note 同型服务：
+ tClearFlagBits(group, nbit)。
+ iClearFlagBits(group, nbit)。
+ */
+#define uClearFlagBits(group, nbit) sUSV_WriteFlagBits(group, false, nbit)
+
+/** @} */
+
+/**************************************************************************//**
+ \ingroup CosyOS_用户API
+ \defgroup 私信
+ \brief 随意定义、灵活多变。
+ \details 私信是CosyOS独创的一种任务间通信方式，其实质就是任务函数形参。
+ \note 私信参数说明：
+ 1、私信参数的数量支持：1~8 个；
+ 2、各个参数的数据类型可为任意类型，只要编译器支持即可；
+ 3、各个参数的名称必须依次为：tm1、tm2...，用户可自行宏定义别名提高易用性。
+ @{
+ */
+
+/**
+ \brief 接收私信
+
+ 别名
+
+ uRecvTM
+ \param[in] tc 滴答周期（超时时间）
+ +0：立即返回
+ ~0：无限等待
+ \return 结果（bool）
+ \retval false 失败
+ \retval true 成功
+ \warning 不支持在临界区中，包括任务临界区、服务层临界区、全局临界区，或关闭总中断时调用。
+ */
+#define uRecvTaskmsg(tc) sUSV_RecvTaskmsg(tc)
+
+/**
+ \brief 发送私信
+
+ 别名
+
+ uSendTM
+ \param[in] task 任务名称
+ \param[in] add(...) 附加私信实参
+ \return 无
+ \note 同型服务：
+ tSendTaskmsg(task) / tSendTM。
+ \warning 如果在条件分支内调用，分支语句的{}不可省略。
+ */
+#define uSendTaskmsg(task) sUSV_SendTaskmsg(task)
+
+/**
+ \brief 结束私信任务
+ \details 私信任务的最后一句代码。
+
+ 别名
+
+ uEndTM
+ \param 无
+ \return 无
+ */
+#define uEndTaskmsg() }while(true)
+
+/** @} */
+
+/**************************************************************************//**
+ \ingroup CosyOS_用户API
+ \defgroup 飞信
+ \brief 原子类型、传输数据。
+ \details 仅使用一个变量，同时即是消息，又是新消息标志。
+ 飞信为0时，表示无消息；飞信非0时，表示有消息；
+ 因此：
+ \warning 用户传输的有效消息必须为真值。
+ \note 架构 数据类型
+ 8051 uint8_t
+ 80251 uint16_t
+ Arm32 uint32_t
+ 通用别名 m_fetion_t
+ @{
+ */
+
+/**
+ \brief 声明信箱
+ \param[in] tbox 信箱名称
+ \return 无
+ */
+#define uExternTionbox(tbox) sCSV_ExternTionbox(tbox)
+
+/**
+ \brief 创建信箱并初始化
+ \param[in] tbox 信箱名称
+ \return 无
+ \note 创建信箱时，系统将自动赋初值。
+ */
+#define uCreateTionbox(tbox) sCSV_CreateTionbox(tbox)
+
+/**
+ \brief 创建信箱不初始化
+ \param[in] tbox 信箱名称
+ \return 无
+ \note 创建信箱时，系统并不会赋初值。
+ \note 该功能可用来创建信箱数组，或把信箱封装在结构体中，
+ 但用户务必要自行正确初始化信箱（参见互斥信号量例程）。
+ */
+#define uCreateTionbox_NotInit(tbox) sCSV_CreateTionbox_NotInit(tbox)
+
+/**
+ \brief 接收飞信
+
+ 别名
+
+ uRecvFet
+ \param[in] tbox 信箱名称
+ \param[in] tc 滴答周期（超时时间）
+ +0：立即返回
+ ~0：无限等待
+ \return 飞信（m_fetion_t）
+ \retval false 无飞信
+ \note 同型服务：
+ tRecvFetion(tbox) / tRecvFet。
+ iRecvFetion(tbox) / iRecvFet。
+ \warning 任务中接收，不支持在临界区中，包括任务临界区、服务层临界区、全局临界区，或关闭总中断时调用。
+ */
+#define uRecvFetion(tbox, tc) sUSV_RecvFetion(tbox, tc)
+
+/**
+ \brief 发送飞信
+
+ 别名
+
+ uSendFet
+ \param[in] tbox 信箱名称
+ \param[in] tion 飞信
+ \return 无
+ \note 同型服务：
+ tSendFetion(tbox, tion) / tSendFet。
+ iSendFetion(tbox, tion) / iSendFet。
+ */
+#define uSendFetion(tbox, tion) sUSV_SendFetion(tbox, tion)
+
+/** @} */
+
+/**************************************************************************//**
+ \ingroup CosyOS_用户API
+ \defgroup 消息邮箱
+ \brief 任意类型、传输指针。
+ @{
+ */
+
+/**
+ \brief 声明邮箱
+ \param[in] mbox 邮箱名称
+ \return 无
+ */
+#define uExternMailbox(mbox) sCSV_ExternMailbox(mbox)
+
+/**
+ \brief 创建邮箱并初始化
+ \param[in] mbox 邮箱名称
+ \return 无
+ \note 创建邮箱时，系统将自动赋初值。
+ */
+#define uCreateMailbox(mbox) sCSV_CreateMailbox(mbox)
+
+/**
+ \brief 创建邮箱不初始化
+ \param[in] mbox 邮箱名称
+ \return 无
+ \note 创建邮箱时，系统并不会赋初值。
+ \note 该功能可用来创建邮箱数组，或把邮箱封装在结构体中，
+ 但用户务必要自行正确初始化邮箱（参见互斥信号量例程）。
+ */
+#define uCreateMailbox_NotInit(mbox) sCSV_CreateMailbox_NotInit(mbox)
+
+/**
+ \brief 接收邮件
+ \param[in] mbox 邮箱名称
+ \param[in] tc 滴答周期（超时时间）
+ +0：立即返回
+ ~0：无限等待
+ \return 邮件指针（void *）
+ \retval NULL 无邮件
+ \note 同型服务：
+ tRecvMail(mbox)。
+ iRecvMail(mbox)。
+ \warning 任务中接收，不支持在临界区中，包括任务临界区、服务层临界区、全局临界区，或关闭总中断时调用。
+ */
+#define uRecvMail(mbox, tc) sUSV_RecvMail(mbox, tc)
+
+/**
+ \brief 发送邮件
+ \param[in] mbox 邮箱名称
+ \param[in] mail 邮件指针
+ \return 无
+ \note 同型服务：
+ tSendMail(mbox, mail)。
+ iSendMail(mbox, mail)。
+ */
+#define uSendMail(mbox, mail) sUSV_SendMail(mbox, mail)
+
+/** @} */
+
+/**************************************************************************//**
+ \ingroup CosyOS_用户API
+ \defgroup 消息队列
+ \brief 任意类型、传输指针，是唯一能够实现并发消息同步的手段。
+ \details 支持多生产者多消费者，多个任务和中断可同时访问同一队列。
+ 支持静态队列和动态队列，传输模式支持先入先出和后入先出。
+ 静态队列：收发消息的效率高，队列占用固定的内存；
+ 动态队列：收发消息的效率低，接收消息后，队列内存可被回收。
+ \note 每条消息，用户应当自己明确消息的类型和size，此事与OS无关。
+ \note 不建议在中断中接收消息，因为有获取不到锁而返回失败的可能。
+ @{
+ */
+
+/**
+ \brief 声明静态队列
+ \param[in] que 队列名称
+ \return 无
+ */
+#define uExternQueue_Static(que) sCSV_ExternQueue_Static(que)
+
+/**
+ \brief 声明动态队列
+ \param[in] que 队列名称
+ \return 无
+ */
+#define uExternQueue_Dynamic(que) sCSV_ExternQueue_Dynamic(que)
+
+/**
+ \brief 创建静态队列
+ \param[in] que 队列名称
+ \param[in] mode 传输模式
+ 0：FIFO（先入先出）
+ 1：LIFO（后入先出）
+ \param[in] len 队列长度
+ \return 无
+ */
+#define uCreateQueue_Static(que, mode, len) sCSV_CreateQueue_Static(que, mode, len)
+
+/**
+ \brief 创建动态队列
+ \param[in] que 队列名称
+ \param[in] mode 传输模式
+ 0：FIFO（先入先出）
+ 1：LIFO（后入先出）
+ \param[in] len 队列长度
+ \return 无
+ */
+#define uCreateQueue_Dynamic(que, mode, len) sCSV_CreateQueue_Dynamic(que, mode, len)
+
+/**
+ \brief 接收消息
+ \param[in] que 队列名称
+ \param[in] tc 滴答周期（超时时间）
+ +0：立即返回
+ ~0：无限等待
+ \return 消息指针（void *）
+ \retval NULL 无消息
+ \note 同型服务：
+ tRecvMsg(que)。
+ iRecvMsg(que)。
+ \warning 任务中接收，不支持在临界区中，包括任务临界区、服务层临界区、全局临界区，或关闭总中断时调用。
+ \warning 中断中只能接收静态队列中的消息。
+ */
+#define uRecvMsg(que, tc) sUSV_RecvMsg(que, tc)
+
+/**
+ \brief 发送消息
+ \param[in] que 队列名称
+ \param[in] msg 消息指针
+ \return 错误码（s_ecode_t）
+ \retval OS_ECODE_NOERROR 无错误
+ \retval ECODE_OVERFLOW_MSGQUEUE 消息队列溢出
+ \retval ECODE_MALLOCFAIL_MSGNODE 消息节点内存分配失败
+ \note 同型服务：
+ tSendMsg(que, msg)，同返回。
+ iSendMsg(que, msg)，无返回/错误调用返回。
+ */
+#define uSendMsg(que, msg) sUSV_SendMsg(que, msg)
+
+/** @} */
+
+/**************************************************************************//**
+ \ingroup CosyOS_用户API
+ \defgroup 全局变量访问
+ \brief 由CosyOS内核提供服务支持，可实现在任务、滴答、中断中，对非原子型
+ 全局变量的线程安全访问，同时不会破坏零中断延迟。
+ \note 全局的结构体、数组、字符串等，都可视为非原子型全局变量。
+ \note 原子型访问：
+ 滴答中：直接->读访问、写访问、自运算。
+ 任务中：直接->读访问、写访问，内核上锁后->自运算。
+ 中断中：直接->读访问，调用服务->写访问、自运算。
+ \note 非原子型访问：
+ 滴答中：直接->读访问、写访问、自运算。
+ 任务中：内核上锁后->读访问、写访问、自运算。
+ 中断中：不可以读访问，调用服务->写访问、自运算。
+ \note 不可以读访问：
+ 建议挂起到PendSV中，或同步至某任务中处理事件。
+ 挂起到PendSV中：iPendSVC(fp) 或 pendsv_hook()，均可直接->读访问；
+ 同步至某任务中：内核上锁后->读访问。
+ @{
+ */
+
+/**
+ \brief 写全局变量
+ \param[in] gv 全局变量名称
+ \param[in] lv 局部变量名称
+ \return 无
+ */
+#define iWriteGVar(gv, lv) sIPS_WriteGVar((void *)&gv, (void *)&lv, sizeof(gv))
+
+/**
+ \brief 写全局数组
+ \param[in] gp 全局数组指针
+ \param[in] lp 局部数组指针
+ \param[in] size 拷贝的大小（字节数）
+ \return 无
+ */
+#define iWriteGAry(gp, lp, size) sIPS_WriteGVar(gp, lp, size)
+
+/**
+ \brief 写全局字符串
+ \param[in] gs 全局字符串指针
+ \param[in] ls 局部字符串指针
+ \return 无
+ */
+#define iWriteGStr(gs, ls) sIPS_WriteGVar(gs, ls, 0)
+
+/**
+ \brief 挂起服务调用
+ \param[in] fp 函数指针
+ \return 无
+ \note 适用于全局变量自运算、事件处理等。
+ */
+#define iPendSVC(fp) sIPS_PendSVC(fp)
+
+/** @} */
+
+/**************************************************************************//**
+ \ingroup CosyOS_用户API
+ \defgroup 软件RTC
+ \brief 适用于没有硬件RTC的物联网终端设备。
+ \note 实际应用中，可每间隔一段时间（如一小时）同步一次网络时间，以校正误差。
+ @{
+ */
+
+/**
+ \brief 获取时间
+ \param[in] t 本地时间的指针（s_rtc_ts *）
+ \return t（void *）
+ \note 同型服务：
+ tGetTime(t)。
+ */
+#define uGetTime(t) sUSV_GetTime(t)
+
+/**
+ \brief 设置时间
+ \param[in] t 本地时间的指针（s_rtc_ts *）
+ \return 无
+ \note 同型服务：
+ tSetTime(t)。
+ iSetTime(t)。
+ */
+#define uSetTime(t) sUSV_SetTime(t)
+
+/** @} */
+
+/**************************************************************************//**
+ \ingroup CosyOS_用户API
+ \defgroup 动态内存
+ @{
+ */
+
+/**
+ \ingroup 动态内存
+ \defgroup 进程内存
+ \brief 以进程为单位初始化内存池，各进程独享自己的内存池。
+ @{
+ */
+
+/**
+ \brief malloc
+ \details 在进程内存池或堆中分配一块内存。
+ \param[in] size 内存块的大小（字节数）
+ \return 分配的指针（void _MALLOC_MEM_ *）
+ \retval NULL 内存分配失败
+ */
+#define uMalloc(size) sUSV_Malloc(size)
+
+/**
+ \brief calloc
+ \details 在进程内存池或堆中连续分配多块内存。
+ \param[in] nmemb 内存块的数量
+ \param[in] size 内存块的大小（字节数）
+ \return 分配的指针（void _MALLOC_MEM_ *）
+ \retval NULL 内存分配失败
+ */
+#define uCalloc(nmemb, size) sUSV_Calloc(nmemb, size)
+
+/**
+ \brief realloc
+ \details 重新分配内存。
+ \param[in] p 预重分配的指针
+ \param[in] size 预重分配的大小（字节数）
+ \return 分配的指针（void _MALLOC_MEM_ *）
+ \retval NULL 内存分配失败
+ */
+#define uRealloc(p, size) sUSV_Realloc(p, size)
+
+/**
+ \brief free
+ \param[in] p 释放的指针
+ \return 无
+ */
+#define uFree(p) sUSV_Free(p)
+
+/** @} */
+
+/**
+ \ingroup 动态内存
+ \defgroup 线程内存
+ \brief 以线程为单位初始化内存池，各线程独享自己的内存池。
+ \note 线程内存的分配效率远高于进程内存，因为每一次调用uTalloc都是在自己的线程内存池中直接按序分配内存。
+ \note 在某线程中，如果需要多次动态内存分配，可考虑采用线程内存以提高性能。
+ \note 线程内存的应用法则：当所有uTalloc的内存都可以释放时，再一次性释放所有内存（线程内存池）。
+ @{
+ */
+
+/**
+ \brief 创建线程内存池
+ \details 实为定义变量（线程内存控制块），C89模式时可考虑在线程的开始处创建。
+ \param 无
+ \return 无
+ */
+#define uCreateMempool() sCSV_CreateMempool()
+
+/**
+ \brief 初始化线程内存池
+ \details 实质上是通过调用malloc，从进程内存池或堆中分配一块内存来做为线程内存池。
+ \param[in] size 线程内存池的大小（字节数）
+ \return 结果（bool）
+ \retval false 失败
+ \retval true 成功
+ */
+#define uInitMempool(size) sUSV_InitMempool(size)
+
+/**
+ \brief 线程内存分配
+ \details 在线程内存池中分配一块内存。
+ \param[in] size 内存块的大小（字节数）
+ \return 分配的指针（void _MALLOC_MEM_ *）
+ \retval NULL 内存分配失败
+ */
+#define uTalloc(size) sUSV_Talloc(size)
+
+/**
+ \brief 释放线程内存池
+ \param 无
+ \return 无
+ */
+#define uFreeMempool() sUSV_FreeMempool()
+
+/** @} */
+/** @} */
+/**************************************************************************//**
+ \ingroup CosyOS_用户API
+ \defgroup 临界区
+ \note CosyOS的临界区包括任务临界区、服务层临界区、全局临界区，均支持嵌套使用。
+ 各临界区之间也可随意互相嵌套，但通常推荐在任务临界区中嵌套服务层临界区，
+ 在服务层临界区中嵌套全局临界区，以逐步扩大保护范围。
+ @{
+ */
+
+/**
+ \ingroup 临界区
+ \defgroup 调度锁（任务临界区）
+ \brief 通过上锁任务调度器的方式，来实现任务级的临界区保护，仅支持在任务中调用。
+ \note 仅是上锁任务调度器，不关闭系统中断（SysTick、PendSV），所以即使是长时间的、
+ 对大段的任务级公共资源的独占访问，也不会影响系统节拍和内核服务的执行。
+ \note 调度锁支持嵌套使用，最大嵌套深度255，调度上锁与调度解锁必须配对使用。
+ \note 调度锁不会破坏零中断延迟，当需要任务级的临界区保护时，可以考虑。
+ @{
+ */
+
+/**
+ \brief 调度上锁（进入任务临界区）
+ \param 无
+ \return 无
+ */
+#define uScheduleLock() su_schedule_locks()
+
+/**
+ \brief 调度解锁（退出任务临界区）
+ \param 无
+ \return 无
+ */
+#define uScheduleUnlock() su_schedule_unlocks()
+
+/** @} */
+
+/**
+ \ingroup 临界区
+ \defgroup 内核锁（服务层临界区）
+ \brief OS内核级的临界区保护，会关闭系统中断（SysTick、PendSV），仅支持在任务中调用。
+ \note 由SysTick、PendSV、内核锁，共同组成大的服务层临界区，当处理得当时，可实现全局的临界区保护。
+ 实现过程：
+ 滴答中：直接访问即可。
+ 任务中：内核上锁后访问。
+ 中断中：采用中断挂起服务。
+ \note 内核锁支持嵌套使用，最大嵌套深度255，内核上锁与内核解锁必须配对使用。
+ \note 内核锁不会破坏零中断延迟，当需要全局的临界区保护时，应首先予以考虑。
+ \note 内核锁应遵循快进快出的原则，临界段代码的执行时间应远小于系统滴答周期，
+ 否则可能会导致丢失系统节拍、延误其它内核服务的执行，对系统实时性造成不利影响。
+ \note 当在任务中访问非原子全局变量时，可采用内核锁实现全局的临界区保护。
+ @{
+ */
+
+/**
+ \brief 内核上锁（进入服务层临界区）
+ \param 无
+ \return 无
+ */
+#define uKernelLock() su_kernel_locks()
+
+/**
+ \brief 内核解锁（退出服务层临界区）
+ \param 无
+ \return 无
+ */
+#define uKernelUnlock() su_kernel_unlocks()
+
+/** @} */
+
+/**
+ \ingroup 临界区
+ \defgroup 中断锁（全局临界区）
+ \brief 全局的临界区保护，通常会关闭总中断，支持在任意处调用。
+ \note CosyOS内核中从来不会关闭总中断，提供此项服务只是为了便于用户
+ 对全局公共资源和程序过程的保护。
+ \note 全局临界区会破坏零中断延迟，应做为最后的选项，慎重使用。
+ @{
+ */
+#if defined ( __C51__ ) || defined ( __C251__ )
+/**
+ \ingroup 全局临界区
+ \defgroup 操作-EA
+ \note 支持嵌套使用，最大嵌套深度255，进入临界区与退出临界区必须配对使用。
+ @{
+ */
+
+/**
+ \brief 进入全局临界区
+ \param 无
+ \return 无
+ */
+#define xDisableIRQ() mxDisableIRQ()
+
+/**
+ \brief 退出全局临界区
+ \param 无
+ \return 无
+ */
+#define xResumeIRQ() mxResumeIRQ()
+
+/** @} */
+#else
+/**
+ \ingroup 全局临界区
+ \defgroup 操作-PRIMASK
+ \note 支持嵌套使用，进入临界区与退出临界区必须配对使用。
+ @{
+ */
+
+/**
+ \brief 进入全局临界区
+ \param 无
+ \return oirq PRIMASK上一次的值（uint32_t类型）
+ */
+#define xDisableIRQ() mxDisableIRQ()
+
+/**
+ \brief 退出全局临界区
+ \param[in] oirq PRIMASK上一次的值（uint32_t类型）
+ \return 无
+ */
+#define xResumeIRQ(oirq) mxResumeIRQ(oirq)
+
+/** @} */
+
+/**
+ \ingroup 全局临界区
+ \defgroup 操作-BASEPRI
+ \note 使用条件：
+ 1、MCU必须有 BASEPRI 寄存器；
+ 2、MCU配置中，系统中断配置必须选择 TIMn_IRQHandler + XXX_IRQHandler。
+ \note 使用说明：
+ 1、关于npri，例如中断优先级分组选择 NVIC_PriorityGoup_4，那么中断优先级从高到低为 0~15。
+ 如果需要掩蔽（3~15）的中断，npri应输入3。
+ 2、支持嵌套使用，进入临界区与退出临界区必须配对使用。
+ 3、嵌套使用时，仅能逐步扩大掩蔽范围（npri越来越小），否则新的掩蔽范围不会生效（将维持上一次的掩蔽范围）。
+ @{
+ */
+
+/**
+ \brief 进入全局临界区
+ \param[in] npri 掩蔽范围的最高优先级的优先级号（uint32_t类型）
+ \return opri BASEPRI的原值（uint32_t类型）
+ */
+#define xMaskingPRI(npri) mxMaskingPRI(npri)
+
+/**
+ \brief 退出全局临界区
+ \param[in] opri BASEPRI的原值（uint32_t类型）
+ \return 无
+ */
+#define xResumePRI(opri) mxResumePRI(opri)
+
+/** @} */
+#endif
+/** @} */
+/** @} */
+/**************************************************************************//**
+ \ingroup CosyOS_用户API
+ \defgroup 杂项
+ @{
+ */
+
+/**
+ \ingroup 杂项
+ \defgroup 中断FIFO服务-错误调用返回
+ \note 当需要回调时，下列的回调函数可以在用户文件中实现。
+ \note 对于8051来说，如果系统中断被配置为使用独立的REGBANK（与任务使用不同的REGBANK），
+ 下列的回调函数需要添加using属性、或声明为相对寄存器访问。参见 tick_hook.c 中示例。
+ @{
+ */
+
+/**
+ \brief iResumeTask(task) error callback
+ \param[in] htask 任务句柄
+ \return 无
+ */
+void pResumeTask_ErrorCallback(s_taskctrl_tsp htask);
+
+/**
+ \brief iSuspendTask(task) error callback
+ \param[in] htask 任务句柄
+ \return 无
+ */
+void pSuspendTask_ErrorCallback(s_taskctrl_tsp htask);
+
+/**
+ \brief iDeleteTask(task) error callback
+ \param[in] htask 任务句柄
+ \return 无
+ */
+void pDeleteTask_ErrorCallback(s_taskctrl_tsp htask);
+
+/**
+ \brief iResetTask(task, status) error callback
+ \param[in] htask 任务句柄
+ \param[in] status 任务初始状态
+ \return 无
+ */
+void pResetTask_ErrorCallback(s_taskctrl_tsp htask, s_u8_t status);
+
+/**
+ \brief iClearBlock(task) error callback
+ \param[in] htask 任务句柄
+ \return 无
+ */
+void pClearBlock_ErrorCallback(s_taskctrl_tsp htask);
+
+/**
+ \brief iSetBlock_x(task, x) error callback
+ \details iSetBlock_tc(task, tc)、iSetBlock_ms(task, ms)、iSetBlock_s(task, s)、
+ iSetBlock_m(task, m)、iSetBlock_h(task, h)，都通过该函数实现错误调用返回。
+ \param[in] htask 任务句柄
+ \param[in] tick 滴答周期（阻塞时间）
+ \return 无
+ */
+void pSetBlock_ErrorCallback(s_taskctrl_tsp htask, s_delay_t tick);
+
+/**
+ \brief iSetTaskPri(task, npri) error callback
+ \param[in] htask 任务句柄
+ \param[in] npri 新优先级
+ \return 无
+ */
+void pSetTaskPri_ErrorCallback(s_taskctrl_tsp htask, s_u8_t npri);
+
+/**
+ \brief iSendMsg(que, msg) error callback
+ \param[in] hque 队列句柄
+ \param[in] msg 消息指针
+ \return 无
+ */
+void pSendMsg_ErrorCallback(s_msgque_tsp hque, void *msg);
+
+/**
+ \brief error code of error callback
+ \param 无
+ \return 错误码（s_ecode_t）
+ */
+#define pECode_ErrorCallback() s_psvfifo_ecode
+
+/** @} */
+
+/**
+ \ingroup 杂项
+ \defgroup DEBUG
+ \brief DEBUG接口，串口发送与接收的实现。
+ @{
+ */
+
+/**
+ \brief DEBUG发送完成
+ \param 无
+ \return 无
+ */
+#define xDebugSend_Complete() s_debug_sendsign = true
+
+/**
+ \brief DEBUG接收解析
+ \param[in] p 接收缓存的开始指针
+ \param[in] len 接收数据包的长度
+ \return 无
+ */
+#define xDebugRecv_Handler(p, len) \
+do{ \
+ s_debug_recvptr = p; \
+ s_debug_recvlen = len; \
+}while(false)
+
+/** @} */
+
+/**
+ \ingroup 杂项
+ \defgroup 时间单位转换
+ \brief 把其它单位的时间转换为滴答周期。
+ @{
+ */
+
+/**
+ \brief 毫秒转换为滴答周期
+ \param[in] ms 毫秒
+ \return 滴答周期
+ */
+#define xTick_ms(ms) ((1000UL * (ms)) / SYSCFG_SYSTICK_CYCLE)
+
+/**
+ \brief 秒钟转换为滴答周期
+ \param[in] s 秒钟
+ \return 滴答周期
+ */
+#define xTick_s(s) xTick_ms(1000UL * (s))
+
+/**
+ \brief 分钟转换为滴答周期
+ \param[in] m 分钟
+ \return 滴答周期
+ */
+#define xTick_m(m) xTick_s(60UL * (m))
+
+/**
+ \brief 小时转换为滴答周期
+ \param[in] h 小时
+ \return 滴答周期
+ */
+#define xTick_h(h) xTick_m(60UL * (h))
+
+/** @} */
+
+/**
+ \brief 触发PendSV
+ \details 在用户中断中，当采用FLAG服务时（自行挂起到 PendSV中断 中执行服务），
+ 在设置标志位后需手动触发PendSV，而后在 pendsv_hook() 中执行服务。
+ \param 无
+ \return 无
+ */
+#define iPendSV_Set() mPendSV_Set()
+
+/**
+ \brief 主栈用量检查初始化
+ \details 主栈用量检查功能适用于 MSP、MSP+PSP 栈模式，而不适用于 PSP模式，
+ 原因是 PSP模式不存在全局唯一主栈，而是当前任务栈即为当前主栈，
+ 所以该功能将被任务栈检查功能所替代。
+ \param[in] size 主栈大小（Keil C51、IAR EWARM 无需传参）
+ \return 无
+ \note 需在 main函数 的入口处调用。
+ \warning 主栈大小的定义如有变动，此处参数应随之调整、切勿遗忘，否则易导致
+ 检查结果不准确或系统运行异常。
+ */
+#if defined ( __C51__ ) || defined ( __ICCARM__ )
+#define uMainStack_CheckInit() mMainStack_CheckInit()
+#else
+#define uMainStack_CheckInit(size) mMainStack_CheckInit(size)
+#endif
+
+/** @} */
+
+
+/** @} */
+#endif
diff --git a/System/ur_eapi.h b/System/ur_eapi.h
new file mode 100644
index 00000000..c3803458
--- /dev/null
+++ b/System/ur_eapi.h
@@ -0,0 +1,297 @@
+/**************************************************************************//**
+ * @item CosyOS-III Kernel
+ * @file ur_eapi.h
+ * @brief 用户API扩展
+ * @details 用户API的补充扩展定义，仅是定义无注释说明，所有内核服务的API说明
+ 均在 ur_api.h 中，并支持 doxygen。
+ * @author 迟凯峰
+ * @version v3.0.0
+ * @date 2026.07.21
+ ******************************************************************************/
+
+#ifndef __UR_EAPI_H
+#define __UR_EAPI_H
+
+
+/*
+ * tpi(s)
+ */
+
+/* 清除就绪延时 */
+//#define tClearDelay() sTSV_ClearDelay()
+ #define pClearDelay() sPSV_ClearDelay()
+ #define iClearDelay() sIPS_ClearDelay()
+
+
+/*
+ * utpi(s)
+ */
+
+/* 恢复任务 */
+//#define uResumeTask(task) sUSV_ResumeTask(task)
+ #define tResumeTask(task) sTSV_ResumeTask(task)
+ #define pResumeTask(task) sPSV_ResumeTask(task)
+ #define iResumeTask(task) sIPS_ResumeTask(task)
+
+/* 挂起任务 */
+//#define uSuspendTask(task) sUSV_SuspendTask(task)
+ #define tSuspendTask(task) sTSV_SuspendTask(task)
+ #define pSuspendTask(task) sPSV_SuspendTask(task)
+ #define iSuspendTask(task) sIPS_SuspendTask(task)
+
+/* 删除任务 */
+//#define uDeleteTask(task) sUSV_DeleteTask(task)
+ #define tDeleteTask(task) sTSV_DeleteTask(task)
+ #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)
+ #define pSetTaskPri(task, npri) sPSV_SetTaskPri(task, npri)
+ #define iSetTaskPri(task, npri) sIPS_SetTaskPri(task, npri)
+
+/* 清除阻塞（状态）*/
+//#define uClearBlock(task) sUSV_ClearBlock(task)
+ #define tClearBlock(task) sTSV_ClearBlock(task)
+ #define pClearBlock(task) sPSV_ClearBlock(task)
+ #define iClearBlock(task) sIPS_ClearBlock(task)
+
+/* 设置阻塞-滴答周期 */
+//#define uSetBlock_tc(task, tc) sUSV_SetBlock(task, tc)
+ #define tSetBlock_tc(task, tc) sTSV_SetBlock(task, tc)
+ #define pSetBlock_tc(task, tc) sPSV_SetBlock(task, tc)
+ #define iSetBlock_tc(task, tc) sIPS_SetBlock(task, tc)
+
+/* 设置阻塞-毫秒 */
+//#define uSetBlock_ms(task, ms) uSetBlock_tc(task, (1000UL * (ms)) / SYSCFG_SYSTICK_CYCLE)
+ #define tSetBlock_ms(task, ms) tSetBlock_tc(task, (1000UL * (ms)) / SYSCFG_SYSTICK_CYCLE)
+ #define pSetBlock_ms(task, ms) pSetBlock_tc(task, (1000UL * (ms)) / SYSCFG_SYSTICK_CYCLE)
+ #define iSetBlock_ms(task, ms) iSetBlock_tc(task, (1000UL * (ms)) / SYSCFG_SYSTICK_CYCLE)
+
+/* 设置阻塞-秒钟 */
+//#define uSetBlock_s(task, s) uSetBlock_ms(task, 1000UL * (s))
+ #define tSetBlock_s(task, s) tSetBlock_ms(task, 1000UL * (s))
+ #define pSetBlock_s(task, s) pSetBlock_ms(task, 1000UL * (s))
+ #define iSetBlock_s(task, s) iSetBlock_ms(task, 1000UL * (s))
+
+/* 设置阻塞-分钟 */
+//#define uSetBlock_m(task, m) uSetBlock_s(task, 60UL * (m))
+ #define tSetBlock_m(task, m) tSetBlock_s(task, 60UL * (m))
+ #define pSetBlock_m(task, m) pSetBlock_s(task, 60UL * (m))
+ #define iSetBlock_m(task, m) iSetBlock_s(task, 60UL * (m))
+
+/* 设置阻塞-小时 */
+//#define uSetBlock_h(task, h) uSetBlock_m(task, 60UL * (h))
+ #define tSetBlock_h(task, h) tSetBlock_m(task, 60UL * (h))
+ #define pSetBlock_h(task, h) pSetBlock_m(task, 60UL * (h))
+ #define iSetBlock_h(task, h) iSetBlock_m(task, 60UL * (h))
+
+/* 给予二值信号量 */
+//#define uGiveBin(bin) sUSV_GiveBin(bin)
+ #define tGiveBin(bin) sTSV_GiveBin(bin)
+ #define pGiveBin(bin) sPSV_GiveBin(bin)
+ #define iGiveBin(bin) sIPS_WriteBin(bin, true)
+
+/* 上锁二值信号量 */
+//#define uLockBin(bin) bin.binary = false
+ #define tLockBin(bin) bin.binary = false
+ #define pLockBin(bin) bin.binary = false
+ #define iLockBin(bin) sIPS_WriteBin(bin, false)
+
+
+/*
+ * uti(s)
+ */
+
+/* 给予计数信号量 */
+//#define uGiveSem(sem) sUSV_GiveSem(sem)
+ #define tGiveSem(sem) sTSV_GiveSem(sem)
+ #define iGiveSem(sem) sIPS_GiveSem(sem)
+
+/* 发送飞信 */
+//#define uSendFetion(tbox, tion) sUSV_SendFetion(tbox, tion)
+ #define tSendFetion(tbox, tion) sTSV_SendFetion(tbox, tion)
+ #define iSendFetion(tbox, tion) sIPS_SendFetion(tbox, tion)
+
+/* 发送邮件 */
+//#define uSendMail(mbox, mail) sUSV_SendMail(mbox, mail)
+ #define tSendMail(mbox, mail) sTSV_SendMail(mbox, mail)
+ #define iSendMail(mbox, mail) sIPS_SendMail(mbox, mail)
+
+/* 发送消息 */
+//#define uSendMsg(que, msg) sUSV_SendMsg(que, msg)
+ #define tSendMsg(que, msg) sTSV_SendMsg(que, msg)
+ #define iSendMsg(que, msg) sIPS_SendMsg(que, msg)
+
+/* 清除标志组 */
+//#define uClearFlagGroup(group) sUSV_ClearFlagGroup(group)
+ #define tClearFlagGroup(group) sTSV_ClearFlagGroup(group)
+ #define iClearFlagGroup(group) sIPS_ClearFlagGroup(group)
+
+/* 设置标志位 */
+//#define uSetFlagBit(group, bit) uSetFlagBits(group, 1) bit)
+ #define tSetFlagBit(group, bit) tSetFlagBits(group, 1) bit)
+ #define iSetFlagBit(group, bit) iSetFlagBits(group, 1) bit)
+
+/* 清除标志位 */
+//#define uClearFlagBit(group, bit) uClearFlagBits(group, 1) bit)
+ #define tClearFlagBit(group, bit) tClearFlagBits(group, 1) bit)
+ #define iClearFlagBit(group, bit) iClearFlagBits(group, 1) bit)
+
+/* 设置多标志位 */
+//#define uSetFlagBits(group, nbit) sUSV_WriteFlagBits(group, true, nbit)
+ #define tSetFlagBits(group, nbit) sTSV_WriteFlagBits(group, true, nbit)
+ #define iSetFlagBits(group, nbit) sIPS_WriteFlagBits(group, +, nbit)
+
+/* 清除多标志位 */
+//#define uClearFlagBits(group, nbit) sUSV_WriteFlagBits(group, false, nbit)
+ #define tClearFlagBits(group, nbit) sTSV_WriteFlagBits(group, false, nbit)
+ #define iClearFlagBits(group, nbit) sIPS_WriteFlagBits(group, -, nbit)
+
+/* 定时中断-滴答周期 */
+//#define uTimInt_tc(tmid, tc) sUSV_TimInt(tmid, tc)
+ #define tTimInt_tc(tmid, tc) sTSV_TimInt(tmid, tc)
+ #define iTimInt_tc(tmid, tc) sIPS_TimInt(tmid, tc)
+
+/* 定时中断-毫秒 */
+//#define uTimInt_ms(tmid, ms) uTimInt_tc(tmid, (1000UL * (ms)) / SYSCFG_SYSTICK_CYCLE)
+ #define tTimInt_ms(tmid, ms) tTimInt_tc(tmid, (1000UL * (ms)) / SYSCFG_SYSTICK_CYCLE)
+ #define iTimInt_ms(tmid, ms) iTimInt_tc(tmid, (1000UL * (ms)) / SYSCFG_SYSTICK_CYCLE)
+
+/* 定时中断-秒钟 */
+//#define uTimInt_s(tmid, s) uTimInt_ms(tmid, 1000UL * (s))
+ #define tTimInt_s(tmid, s) tTimInt_ms(tmid, 1000UL * (s))
+ #define iTimInt_s(tmid, s) iTimInt_ms(tmid, 1000UL * (s))
+
+/* 定时中断-分钟 */
+//#define uTimInt_m(tmid, m) uTimInt_s(tmid, 60UL * (m))
+ #define tTimInt_m(tmid, m) tTimInt_s(tmid, 60UL * (m))
+ #define iTimInt_m(tmid, m) iTimInt_s(tmid, 60UL * (m))
+
+/* 定时中断-小时 */
+//#define uTimInt_h(tmid, h) uTimInt_m(tmid, 60UL * (h))
+ #define tTimInt_h(tmid, h) tTimInt_m(tmid, 60UL * (h))
+ #define iTimInt_h(tmid, h) iTimInt_m(tmid, 60UL * (h))
+
+/* 终止定时中断 */
+//#define uTimInt_Cancel(tmid) uTimInt_tc(tmid, 0)
+ #define tTimInt_Cancel(tmid) tTimInt_tc(tmid, 0)
+ #define iTimInt_Cancel(tmid) iTimInt_tc(tmid, 0)
+
+/* 定时查询-滴答周期 */
+//#define uTimQry_tc(tmid, tc) sUSV_TimQry(tmid, tc)
+ #define tTimQry_tc(tmid, tc) sTSV_TimQry(tmid, tc)
+ #define iTimQry_tc(tmid, tc) sIPS_TimQry(tmid, tc)
+
+/* 定时查询-毫秒 */
+//#define uTimQry_ms(tmid, ms) uTimQry_tc(tmid, (1000UL * (ms)) / SYSCFG_SYSTICK_CYCLE)
+ #define tTimQry_ms(tmid, ms) tTimQry_tc(tmid, (1000UL * (ms)) / SYSCFG_SYSTICK_CYCLE)
+ #define iTimQry_ms(tmid, ms) iTimQry_tc(tmid, (1000UL * (ms)) / SYSCFG_SYSTICK_CYCLE)
+
+/* 定时查询-秒钟 */
+//#define uTimQry_s(tmid, s) uTimQry_ms(tmid, 1000UL * (s))
+ #define tTimQry_s(tmid, s) tTimQry_ms(tmid, 1000UL * (s))
+ #define iTimQry_s(tmid, s) iTimQry_ms(tmid, 1000UL * (s))
+
+/* 定时查询-分钟 */
+//#define uTimQry_m(tmid, m) uTimQry_s(tmid, 60UL * (m))
+ #define tTimQry_m(tmid, m) tTimQry_s(tmid, 60UL * (m))
+ #define iTimQry_m(tmid, m) iTimQry_s(tmid, 60UL * (m))
+
+/* 定时查询-小时 */
+//#define uTimQry_h(tmid, h) uTimQry_m(tmid, 60UL * (h))
+ #define tTimQry_h(tmid, h) tTimQry_m(tmid, 60UL * (h))
+ #define iTimQry_h(tmid, h) iTimQry_m(tmid, 60UL * (h))
+
+/* 终止定时查询 */
+//#define uTimQry_Cancel(tmid) uTimQry_tc(tmid, ~0)
+ #define tTimQry_Cancel(tmid) tTimQry_tc(tmid, ~0)
+ #define iTimQry_Cancel(tmid) iTimQry_tc(tmid, ~0)
+
+/* 设置时间 */
+//#define uSetTime(t) sUSV_SetTime(t)
+ #define tSetTime(t) sTSV_SetTime(t)
+ #define iSetTime(t) sIPS_SetTime(t)
+
+
+/*
+ * uti(l)
+ */
+
+/* 归还二值信号量 */
+//#define uBackBin(bin) uGiveBin(bin)
+ #define tBackBin(bin) sTSV_BackBin(bin)
+ #define iBackBin(bin) sISV_BackBin(bin)
+
+/* 获取二值信号量 */
+//#define uTakeBin(bin, tc) sUSV_TakeBin(bin, tc)
+ #define tTakeBin(bin) sTSV_TakeBin(bin)
+ #define iTakeBin(bin) sISV_TakeBin(bin)
+
+/* 接收飞信 */
+//#define uRecvFetion(tbox, tc) sUSV_RecvFetion(tbox, tc)
+ #define tRecvFetion(tbox) sTSV_RecvFetion(tbox)
+ #define iRecvFetion(tbox) sISV_RecvFetion(tbox)
+
+/* 接收邮件 */
+//#define uRecvMail(mbox, tc) sUSV_RecvMail(mbox, tc)
+ #define tRecvMail(mbox) sTSV_RecvMail(mbox)
+ #define iRecvMail(mbox) sISV_RecvMail(mbox)
+
+/* 接收消息 */
+//#define uRecvMsg(que, tc) sUSV_RecvMsg(que, tc)
+ #define tRecvMsg(que) sTSV_RecvMsg(que)
+ #define iRecvMsg(que) sISV_RecvMsg(que)
+
+/* 查询标志组 */
+//#define uQueryFlagGroup(group) sUSV_QueryFlagGroup(group)
+ #define tQueryFlagGroup(group) sTSV_QueryFlagGroup(group)
+ #define iQueryFlagGroup(group) sISV_QueryFlagGroup(group)
+
+
+/*
+ * ut
+ */
+
+/* 获取时间 */
+//#define uGetTime(t) sUSV_GetTime(t)
+ #define tGetTime(t) sTSV_GetTime(t)
+
+/* 获取计数信号量 */
+//#define uTakeSem(sem, tc) sUSV_TakeSem(sem, tc)
+ #define tTakeSem(sem) sTSV_TakeSem(sem)
+
+/* 归还计数信号量 */
+//#define uBackSem(sem) uGiveSem(sem)
+ #define tBackSem(sem) tGiveSem(sem)
+
+/* 发送私信 */
+//#define uSendTaskmsg(task) sUSV_SendTaskmsg(task)
+ #define tSendTaskmsg(task) sTSV_SendTaskmsg(task)
+
+
+/*
+ * 别名定义（API简化）
+ */
+
+#define uRecvTM uRecvTaskmsg
+#define uSendTM uSendTaskmsg
+#define tSendTM tSendTaskmsg
+#define uEndTM uEndTaskmsg
+
+#define uRecvFet uRecvFetion
+#define tRecvFet tRecvFetion
+#define iRecvFet iRecvFetion
+#define uSendFet uSendFetion
+#define tSendFet tSendFetion
+#define iSendFet iSendFetion
+
+
+#endif