/**************************************************************************//**
 * @item     CosyOS-III Kernel
 * @file     os_redef.h
 * @brief    系统重定义
 * @details  基于 os_def.h、syscfg.h、mcucfg_x.h、port_x.h 等文件中的定义
             而再次定义，包括宏定义和类型定义。
 * @author   迟凯峰
 * @version  v3.0.0
 * @date     2026.07.21
 ******************************************************************************/

#ifndef __OS_REDEF_H
#define __OS_REDEF_H

/*------------------------------------------------------------------------------
 * INCLUDE */

#include <stdlib.h>
#include "os_def.h"
#include "syscfg.h"
#include sDefStr(sCat2Str(port_, SYSCFG_MCUCORE.h))

/*------------------------------------------------------------------------------
 * ZERO-INSTALL */

#if defined ( MCUCFG_OSZEROINSTALL ) && (MCUCFG_OSZEROINSTALL == __ENABLED__)
#define sZeroInstall = 0
#define sZeroInstall_Group = {0}
#else
#define sZeroInstall
#define sZeroInstall_Group
#endif

/*------------------------------------------------------------------------------
 * OS-NOP */

#define OS_NOPx1  __NOP()
#define OS_NOPx2  OS_NOPx1; OS_NOPx1
#define OS_NOPx3  OS_NOPx2; OS_NOPx1
#define OS_NOPx4  OS_NOPx3; OS_NOPx1
#define OS_NOPx5  OS_NOPx4; OS_NOPx1
#define OS_NOPx6  OS_NOPx5; OS_NOPx1
#define OS_NOPx7  OS_NOPx6; OS_NOPx1
#define OS_NOPx8  OS_NOPx7; OS_NOPx1
#define OS_NOP(n)  sCat2Str(OS_NOPx, n)

/*------------------------------------------------------------------------------
 * TOTAL */

#if (SYSCFG_TIMESLOTBITS >= 1 && SYSCFG_TIMESLOTBITS <= 8)
#define OS_TIMESLOTBITS    SYSCFG_TIMESLOTBITS
#elif (SYSCFG_TIMESLOTBITS == 251 || SYSCFG_TIMESLOTBITS == 253 || SYSCFG_TIMESLOTBITS == 256)
#define __OS_TIMESLOTNUM   (SYSCFG_TASKPRIORITY * (SYSCFG_SAMEPRISCHEDULE ? 3 : 1)) / (SYSCFG_TIMESLOTBITS - 250)
  #if (__OS_TIMESLOTNUM >= (128 + 64))
#define OS_TIMESLOTBITS    8
#elif (__OS_TIMESLOTNUM >= (64 + 32))
#define OS_TIMESLOTBITS    7
#elif (__OS_TIMESLOTNUM >= (32 + 16))
#define OS_TIMESLOTBITS    6
#elif (__OS_TIMESLOTNUM >= (16 + 8))
#define OS_TIMESLOTBITS    5
#elif (__OS_TIMESLOTNUM >= (8 + 4))
#define OS_TIMESLOTBITS    4
#elif (__OS_TIMESLOTNUM >= (4 + 2))
#define OS_TIMESLOTBITS    3
#elif (__OS_TIMESLOTNUM >= (2 + 1))
#define OS_TIMESLOTBITS    2
#else
#define OS_TIMESLOTBITS    1
#endif
#else
#error 参数非法 of 延时定时器时间轮槽数！
#endif
#define OS_TIMESLOTNUM     (1UL << OS_TIMESLOTBITS)

#define OS_TIMINTTOTAL     SYSCFG_USERTIMINTTOTAL   /*!< 定时中断总数 */
#if (SYSCFG_DEBUGGING == __DISABLED__)
#define OS_TIMQRYTOTAL     SYSCFG_USERTIMQRYTOTAL   /*!< 定时查询总数 */
#else
#define OS_TIMQRYTOTAL    (SYSCFG_USERTIMQRYTOTAL + 2)

/*------------------------------------------------------------------------------
 * TMID（定时器ID）*/

#define OS_TMID_DEBUGGER   SYSCFG_USERTIMQRYTOTAL   /*!< TMID of Debugger */
/** TMID of Taskmgr */
  #if (OS_TIMQRYTOTAL ==  2)
#define OS_TMID_TASKMGR     1
#elif (OS_TIMQRYTOTAL ==  3)
#define OS_TMID_TASKMGR     2
#elif (OS_TIMQRYTOTAL ==  4)
#define OS_TMID_TASKMGR     3
#elif (OS_TIMQRYTOTAL ==  5)
#define OS_TMID_TASKMGR     4
#elif (OS_TIMQRYTOTAL ==  6)
#define OS_TMID_TASKMGR     5
#elif (OS_TIMQRYTOTAL ==  7)
#define OS_TMID_TASKMGR     6
#elif (OS_TIMQRYTOTAL ==  8)
#define OS_TMID_TASKMGR     7
#elif (OS_TIMQRYTOTAL ==  9)
#define OS_TMID_TASKMGR     8
#elif (OS_TIMQRYTOTAL == 10)
#define OS_TMID_TASKMGR     9
#elif (OS_TIMQRYTOTAL == 11)
#define OS_TMID_TASKMGR    10
#elif (OS_TIMQRYTOTAL == 12)
#define OS_TMID_TASKMGR    11
#elif (OS_TIMQRYTOTAL == 13)
#define OS_TMID_TASKMGR    12
#elif (OS_TIMQRYTOTAL == 14)
#define OS_TMID_TASKMGR    13
#elif (OS_TIMQRYTOTAL == 15)
#define OS_TMID_TASKMGR    14
#elif (OS_TIMQRYTOTAL == 16)
#define OS_TMID_TASKMGR    15
#elif (OS_TIMQRYTOTAL == 17)
#define OS_TMID_TASKMGR    16
#elif (OS_TIMQRYTOTAL == 18)
#define OS_TMID_TASKMGR    17
#elif (OS_TIMQRYTOTAL == 19)
#define OS_TMID_TASKMGR    18
#elif (OS_TIMQRYTOTAL == 20)
#define OS_TMID_TASKMGR    19
#elif (OS_TIMQRYTOTAL == 21)
#define OS_TMID_TASKMGR    20
#elif (OS_TIMQRYTOTAL == 22)
#define OS_TMID_TASKMGR    21
#elif (OS_TIMQRYTOTAL == 23)
#define OS_TMID_TASKMGR    22
#elif (OS_TIMQRYTOTAL == 24)
#define OS_TMID_TASKMGR    23
#elif (OS_TIMQRYTOTAL == 25)
#define OS_TMID_TASKMGR    24
#elif (OS_TIMQRYTOTAL == 26)
#define OS_TMID_TASKMGR    25
#elif (OS_TIMQRYTOTAL == 27)
#define OS_TMID_TASKMGR    26
#elif (OS_TIMQRYTOTAL == 28)
#define OS_TMID_TASKMGR    27
#elif (OS_TIMQRYTOTAL == 29)
#define OS_TMID_TASKMGR    28
#elif (OS_TIMQRYTOTAL == 30)
#define OS_TMID_TASKMGR    29
#elif (OS_TIMQRYTOTAL == 31)
#define OS_TMID_TASKMGR    30
#elif (OS_TIMQRYTOTAL == 32)
#define OS_TMID_TASKMGR    31
#elif (OS_TIMQRYTOTAL == 33)
#define OS_TMID_TASKMGR    32
#elif (OS_TIMQRYTOTAL == 34)
#define OS_TMID_TASKMGR    33
#endif
#endif

/*------------------------------------------------------------------------------
 * Time Sharing（时间片）*/

#if (SYSCFG_SAMEPRISCHEDULE == __TIMESHARING__)
  #if (SYSCFG_TIMESHARINGMODE == 0)
#define OS_TIMESHARING(htask) SYSCFG_GLOBALTIMESHARING
#define OS_TIMESHARING_MAX    SYSCFG_GLOBALTIMESHARING
#define OS_TIMESHARING_MIN    SYSCFG_GLOBALTIMESHARING
#elif (SYSCFG_TIMESHARINGMODE == 1)
#define OS_TIMESHARING(htask) SYSCFG_FORMULATIMESHARING(htask->pri)
#define OS_TIMESHARING_MAX    SYSCFG_FORMULATIMESHARING(0)
#define OS_TIMESHARING_MIN    SYSCFG_FORMULATIMESHARING(SYSCFG_TASKPRIORITY - 1)
#elif (SYSCFG_TIMESHARINGMODE == 2)
#define OS_TIMESHARING(htask) s_time_sharing[htask->pri]
#define OS_TIMESHARING_MAX    SYSCFG_TIMESHARING_MAX
#define OS_TIMESHARING_MIN    1
#endif
#if (OS_TIMESHARING_MIN == 0 || OS_TIMESHARING_MAX > 65535)
#error 参数非法 of 时间片！
#endif
#endif

/*------------------------------------------------------------------------------
 * DEBUG */

#if (SYSCFG_DEBUGGING == __ENABLED__)

#define OS_TASKMGR_LEN_RAM  (11 + sizeof(int))

#define OS_TASKMGR_LEN_LINE \
( \
	  SYSCFG_TASKNAMELEN_MAX \
	+ OS_TASKMGR_LEN_PRI + OS_TASKMGR_LEN_STA \
	+ OS_TASKMGR_LEN_CPU + OS_TASKMGR_LEN_RAM \
)

#define OS_CMDLINESENDBUFFSIZE  (SYSCFG_TASKNAMELEN_MAX + 64) /*!< size of 命令行发送缓存 */

#if (SYSCFG_SAMEPRISCHEDULE == 0)
#define OS_TASKTOTAL       SYSCFG_TASKPRIORITY /*!< 在线任务总数 */
#else
#define OS_TASKTOTAL      (SYSCFG_USERTASKTOTAL + 4)
#endif

#define OS_TASKMGRSENDBUFFSIZE \
( \
	(OS_TASKMGR_LEN_LINE + 2) * (OS_TASKTOTAL + 7 + SYSCFG_RTC_SHOW) + 2 * 2 + 1 \
) /*!< size of Taskmgr发送缓存 */

#endif

/*------------------------------------------------------------------------------
 * typedef base */

#if (SYSCFG_SAMEPRISCHEDULE == __TIMESHARING__)
  #if (OS_TIMESHARING_MAX < 256)
typedef s_u8_t  s_sharing_t; /*!< 时间片类型 */
#elif (OS_TIMESHARING_MAX < 65536)
typedef s_u16_t s_sharing_t;
#else
#error 参数非法 of 时间片！
#endif
#endif

typedef s_u8_t  s_ecode_t;   /*!< 错误码类型 */
typedef sCat3Str(s_u, SYSCFG_DELAY_BITS, _t)  s_delay_t;  /*!< 延时定时器类型 */
typedef sCat3Str(s_u, SYSCFG_TIMINT_BITS, _t) s_timint_t; /*!< 定时中断定时器类型 */
typedef sCat3Str(s_u, SYSCFG_TIMQRY_BITS, _t) s_timqry_t; /*!< 定时查询定时器类型 */
typedef sCat3Str(s_u, SYSCFG_SEMAPH_BITS, _t) s_semaph_t; /*!< 计数信号量类型 */
typedef sCat3Str(s_u, SYSCFG_SRTIME_BITS, _t) s_srtime_t; /*!< 安全运行时类型 */

/*------------------------------------------------------------------------------
 * typedef function and function pointer */

typedef bool s_boolvoid_tf(void); /*!< Keil C51 专用 */
typedef bool (_CODE_MEM_ *s_boolvoid_tfp)(void);
typedef void (_CODE_MEM_ *s_voidvoid_tfp)(void);

/*------------------------------------------------------------------------------
 * typedef union */

/**
 \brief      调度信号
 */
typedef union
{
	 s_u8_t volatile every[2];
	s_u16_t volatile total;
}s_schesign_tu;

/*------------------------------------------------------------------------------
 * typedef struct */

/**
 \brief      运行时间
 */
typedef struct
{
	s_u16_t day;   /*!< 天 */
	s_u8_t hour;   /*!< 时 */
	s_u8_t minute; /*!< 分 */
	s_u8_t second; /*!< 秒 */
}s_runtime_ts;

/**
 \brief      软件RTC
 */
typedef struct
{
	s_u8_t yeah;   /*!< 年高八位 */
	s_u8_t year;   /*!< 年低八位 */
	s_u8_t month;  /*!< 月 */
	s_u8_t date;   /*!< 日 */
	s_u8_t hour;   /*!< 时 [24时制] */
	s_u8_t minute; /*!< 分 */
	s_u8_t second; /*!< 秒 */
	s_u8_t day;    /*!< 周 [1：周一，7：周日] */
}s_rtc_ts;

/**
 \brief      软件RTC-每信号
 \details    典型的应用示例参见 tick_hook。
 */
typedef struct
{
	sDefBitField(year);    /*!< 每年 */
	sDefBitField(month);   /*!< 每月 */
	sDefBitField(day);     /*!< 每日 */
	sDefBitField(hour);    /*!< 每时 */
	sDefBitField(minute);  /*!< 每分 */
	sDefBitField(second);  /*!< 每秒 */
	sDefBitField(halfsec); /*!< 每半秒 */
	sDefVoidBits(1);
}s_every_ts;

/**
 \brief      系统警告
 */
typedef struct
{
	sDefBitField(overflow_msgqueue);         /*!<【omq】：消息队列溢出 ....... */
	sDefBitField(timeout_saferuntime);       /*!<【srt】：安全运行时超时 ..... */
	sDefBitField(outrange_taskpriority);     /*!<【otp】：任务优先级超出范围 . */
	sDefBitField(realloc_taskstack);         /*!<【rts】：任务栈重分配发生 ... */
	sDefBitField(overflow_taskstack);        /*!<【ots】：未来的任务栈溢出 ... */
	sDefBitField(task_repeated_startup);     /*!<【trs】：任务重复启动........ */
	sDefVoidBits(2);
}s_alarm_ts;

/**
 \brief      系统异常
 */
typedef struct
{
	sDefBitField(mallocfailed_msgnode);      /*!<【mmn】：消息节点内存分配失败 */
	sDefBitField(mallocfailed_tasknode);     /*!<【mtn】：任务节点内存分配失败 */
	sDefBitField(mallocfailed_taskstack);    /*!<【mts】：任务栈内存分配失败 . */
	sDefBitField(reallocfailed_taskstack);   /*!<【rts】：任务栈内存重分配失败 */
	sDefBitField(overflow_taskstack);        /*!<【ots】：任务栈溢出 ......... */
	sDefBitField(failed_startuptask);        /*!<【fst】：启动任务失败 ....... */
	sDefBitField(error_recvmsg_int);         /*!<【erm】：中断中接收消息错误 . */
	sDefBitField(overflow_pendsvfifo);       /*!<【opd】：PendSV_FIFO溢出 .... */
}s_fault_ts;

/**
 \brief      时间轮
 */
typedef struct
{
	   s_u8_t slots;
	s_delay_t cycle;
}s_timewheel_ts;

/**
 \brief      任务控制块
 \details    包含了任务所需的全部关键信息。
             任务静态创建时，任务控制块为静态；
             任务动态创建时，任务控制块为动态。
 */
typedef struct s_taskctrl_ts
{
	mTaskCtrl_Head_ /*!< MSP：stacklen，PSP：psp，MSP+PSP：psp */
	                                        s_u8_t opri;         /*!< 任务创建时的优先级 */
	                                 m_stacksize_t stacksize;    /*!< 任务栈size */
	struct s_taskctrl_ts _OBJ_MEM_ * _STATIC_MEM_ *h2task;       /*!< 任务二重句柄：指向任务句柄的指针 */
	                                s_voidvoid_tfp entry;        /*!< 任务函数入口指针 */
	#if (SYSCFG_DEBUGGING == __ENABLED__)
	                       char const _CONST_MEM_ *name;         /*!< 任务名称（字符串）*/
	#endif
	#if (SYSCFG_SAFERUNTIME == __ENABLED__)
	                                    s_srtime_t srt_maximum;  /*!< 安全运行时设定值 */
	#endif
	                             s_u8_t _OBJ_MEM_ *bsp;          /*!< base stack pointer，任务栈的起始地址 */
	                                        s_u8_t create;       /*!< 任务创建 [0：静态创建，1：动态创建未重分配，2：动态创建已重分配] */
	                                        s_u8_t status;       /*!< 任务状态 */
	                                        s_u8_t blocktype;    /*!< 阻塞类型 */
	                            void _STATIC_MEM_ *handle;       /*!< 内核对象句柄，仅指向静态对象 */
	                                s_timewheel_ts timer;        /*!< 任务定时器 */
	                                        s_u8_t pri;          /*!< 任务当前优先级 */
	#if   (SYSCFG_SAMEPRISCHEDULE == __COOPERATIVE__)
	                                          bool yield;        /*!< 禅让 */
	#elif (SYSCFG_SAMEPRISCHEDULE == __TIMESHARING__)
	                                   s_sharing_t tc_counter;   /*!< 滴答周期计数器 */
	#endif
	#if (SYSCFG_DEBUGGING == __ENABLED__)
	                                       s_u32_t usedtime[2];  /*!< CPU 使用时间计数 */
	                                  m_stacklen_t stacklen_max; /*!< 任务栈的实际占用在历史上的最大值 */
	#endif
	#if (SYSCFG_SAFERUNTIME == __ENABLED__)
	                                    s_srtime_t srt_counter;  /*!< 安全运行时计数器 */
	#endif
	               struct s_taskctrl_ts _OBJ_MEM_ *last_b;       /*!< 上一节点 of 阻塞/超时链表 */
	               struct s_taskctrl_ts _OBJ_MEM_ *next_b;       /*!< 下一节点 of 阻塞/超时链表 */
	               struct s_taskctrl_ts _OBJ_MEM_ *last_t;       /*!< 上一节点 of 定时器链表 */
	               struct s_taskctrl_ts _OBJ_MEM_ *next_t;       /*!< 下一节点 of 定时器链表 */
	#if (SYSCFG_SAMEPRISCHEDULE)
	               struct s_taskctrl_ts _OBJ_MEM_ *last;         /*!< 上一节点 of 任务链表 */
	               struct s_taskctrl_ts _OBJ_MEM_ *next;         /*!< 下一节点 of 任务链表 */
 	    #if (SYSCFG_MUTEX == __ENABLED__)
	               struct s_taskctrl_ts _OBJ_MEM_ *link;         /*!< 互斥信号量获取阻塞-任务链接 */
	    #endif
	#endif
	mTaskCtrl_Tail_ /*!< MCS51/251：mUserReg_DEFc_，减栈：psp_top */
}s_taskctrl_ts;
typedef s_taskctrl_ts _OBJ_MEM_ *s_taskctrl_tsp; /*!< 任务句柄 */

/**
 \brief      任务装载块
 \details    创建任务时，用来装载任务的关键参数。
          1、当任务为动态创建时，会定义此结构体；在启动任务时，会动态的分配任务控制块，
             再把任务装载块中的参数传入任务控制块。
          2、当任务为静态创建时，任务控制块就是任务装载块，不会再额外定义此结构体。
             注：有关结构体成员的相关说明参见任务控制块。
 */
typedef struct
{
	                                         const mTaskCtrl_Head_
	                                  s_u8_t const opri;
	                           m_stacksize_t const stacksize;
	s_taskctrl_ts _OBJ_MEM_ * _STATIC_MEM_ * const h2task;
	                                s_voidvoid_tfp entry;
	#if (SYSCFG_DEBUGGING == __ENABLED__)
	                char const _CONST_MEM_ * const name;
	#endif
	#if (SYSCFG_SAFERUNTIME == __ENABLED__)
	                              s_srtime_t const srt_maximum;
	#endif
}s_taskload_ts;
typedef s_taskload_ts _STATIC_MEM_ *s_taskload_tsp; /*!< 任务装载块句柄 */

/**
 \brief      任务启动器
 */
typedef struct
{
	s_taskload_tsp hload;  /*!< 任务装载块句柄 */
	        s_u8_t status; /*!< 任务初始状态 */
	     s_ecode_t _ecode; /*!< 返回错误码 */
}s_taskstart_ts;

/**
 \brief      钩子函数指针 or 任务装载块句柄
 */
typedef union
{
	s_voidvoid_tfp hook; /*!< 钩子函数指针 */
	s_taskload_tsp load; /*!< 任务装载块句柄 */
}s_hookorload_tu;

/**
 \brief      定时中断HAND（控制块）
 \details    创建定时中断任务或钩子时，会定义此结构体。
 */
typedef struct
{
	             s_timint_t timer;      /*!< 定时器 */
	             s_timint_t reload;     /*!< 重装载值 */
	                   bool autoreload; /*!< 是否自动重装载定时器？*/
	             bool const hookortask; /*!< 该定时中断是钩子还是任务？[0：hook，1：task] */
	  s_hookorload_tu const hookorload; /*!< 钩子函数指针 or 任务装载块句柄 */
}s_timinthand_ts;
typedef s_timinthand_ts _STATIC_MEM_ *s_timinthand_tsp; /*!< 定时中断句柄 */

/**
 \brief      定时查询HAND（控制块）
 \details    创建定时查询任务或钩子时，会定义此结构体。
 */
typedef struct
{
	             s_timqry_t timer;      /*!< 定时器 */
	             s_timqry_t reload;     /*!< 重装载值 */
	                   bool autoreload; /*!< 是否自动重装载定时器？*/
	             bool const hookortask; /*!< 该定时查询是钩子还是任务？[0：hook，1：task] */
	  s_hookorload_tu const hookorload; /*!< 钩子函数指针 or 任务装载块句柄 */
	   s_boolvoid_tfp const event;      /*!< 定时查询事件函数指针 */
}s_timqryhand_ts;
typedef s_timqryhand_ts _STATIC_MEM_ *s_timqryhand_tsp; /*!< 定时查询句柄 */

/**
 \brief      互斥信号量控制块
 \details    创建互斥信号量时，会定义此结构体。
 */
typedef struct
{
	s_taskctrl_tsp htask;
	s_taskctrl_tsp otask;
	s_u8_t opri;
	s_u8_t volatile mutex;
}s_mutex_ts;
typedef s_mutex_ts _STATIC_MEM_ *s_mutex_tsp; /*!< 互斥信号量句柄 */

/**
 \brief      二值信号量控制块
 \details    创建二值信号量时，会定义此结构体。
 */
typedef struct
{
	s_taskctrl_tsp htask;
	bool volatile binary;
}s_binary_ts;
typedef s_binary_ts _STATIC_MEM_ *s_binary_tsp; /*!< 二值信号量句柄 */

/**
 \brief      计数信号量控制块
 \details    创建计数信号量时，会定义此结构体。
 */
typedef struct
{
	s_taskctrl_tsp htask;
	s_semaph_t volatile counter;
	s_semaph_t const    maximum;
}s_semaph_ts;
typedef s_semaph_ts _STATIC_MEM_ *s_semaph_tsp; /*!< 计数信号量句柄 */

/**
 \brief      信箱控制块
 \details    创建信箱时，会定义此结构体。
 */
typedef struct
{
	s_taskctrl_tsp htask;
	m_fetion_t volatile tion;
}s_tionbox_ts;
typedef s_tionbox_ts _STATIC_MEM_ *s_tionbox_tsp; /*!< 信箱句柄 */

/**
 \brief      邮箱控制块
 \details    创建邮箱时，会定义此结构体。
 */
typedef struct
{
	s_taskctrl_tsp htask;
	bool volatile flag;
	void *mail;
}s_mailbox_ts;
typedef s_mailbox_ts _STATIC_MEM_ *s_mailbox_tsp; /*!< 邮箱句柄 */

/**
 \brief      消息节点
 \details    动态队列之消息节点。
 */
typedef struct s_msgnode_ts
{
	void *msg;
	struct s_msgnode_ts _MALLOC_MEM_ *last;
	struct s_msgnode_ts _MALLOC_MEM_ *next;
}s_msgnode_ts;
typedef s_msgnode_ts _MALLOC_MEM_ *s_msgnode_tsp; /*!< 消息句柄 */

/**
 \brief      动态队列控制块
 \details    创建动态队列时，会定义此结构体。
 */
typedef struct
{
	   s_taskctrl_tsp htask;
	#if (SYSCFG_MSGQUEUE_INTRECV == __ENABLED__)
	    bool volatile lock;
	#endif
	  size_t volatile counter;
	     s_u8_t const type;
	     s_u8_t const mode;
	     size_t const len;
	    s_msgnode_tsp head;
	    s_msgnode_tsp tail;
}s_dynque_ts;
typedef s_dynque_ts _STATIC_MEM_ *s_dynque_tsp; /*!< 动态队列句柄 */

/**
 \brief      静态队列控制块
 \details    创建静态队列时，会定义此结构体。
 */
typedef struct
{
	       s_taskctrl_tsp htask;
	#if (SYSCFG_MSGQUEUE_INTRECV == __ENABLED__)
	        bool volatile lock;
	#endif
	      size_t volatile counter;
	         s_u8_t const type;
	         s_u8_t const mode;
	         size_t const len;
	void * _STATIC_MEM_ * head;
	void * _STATIC_MEM_ * tail;
	void * _STATIC_MEM_ * const base;
}s_staque_ts;
typedef s_staque_ts _STATIC_MEM_ *s_staque_tsp; /*!< 静态队列句柄 */

/**
 \brief      队列控制块
 \details    创建队列时，并不会定义此结构体；访问队列时，通过其队列句柄，
             即可访问动态队列控制块，也可访问静态队列控制块。
 */
typedef struct
{
	   s_taskctrl_tsp htask;   /*!< 任务句柄 */
	#if (SYSCFG_MSGQUEUE_INTRECV == __ENABLED__)
	    bool volatile lock;    /*!< 队列互斥锁 */
	#endif
	  size_t volatile counter; /*!< 队列计数器：记录队列中消息的数量 */
	     s_u8_t const type;    /*!< 队列类型 [0：静态队列，1：动态队列] */
	     s_u8_t const mode;    /*!< 传输模式 [0：FIFO，1：LIFO] */
	     size_t const len;     /*!< 队列长度 */
}s_msgque_ts;
typedef s_msgque_ts _STATIC_MEM_ *s_msgque_tsp; /*!< 队列句柄 */

/**
 \brief      线程内存控制块
 \details    创建线程内存池时，会定义此结构体。
 */
typedef struct
{
	void _MALLOC_MEM_ *head;
	void _MALLOC_MEM_ *move;
	size_t size;
}s_thrmem_ts;
typedef s_thrmem_ts _STATIC_MEM_ *s_thrmem_tsp; /*!< 线程内存句柄 */

/*------------------------------------------------------------------------------
 * 中断FIFO服务-结构体类型定义 */

typedef struct
{
	s_u8_t const svid;
}sp_svid_ts;
typedef sp_svid_ts _STATIC_MEM_ *sp_svid_tsp;

typedef struct
{
	  s_u8_t const svid;
	s_taskctrl_tsp htask;
}sp_task_ts;
typedef sp_task_ts _STATIC_MEM_ *sp_task_tsp;

typedef struct
{
	  s_u8_t const svid;
	s_taskctrl_tsp htask;
	  s_u8_t const status;
}sp_taskrst_ts;
typedef sp_taskrst_ts _STATIC_MEM_ *sp_taskrst_tsp;

typedef struct
{
	  s_u8_t const svid;
	s_taskctrl_tsp htask;
	  s_u8_t const npri;
}sp_taskpri_ts;
typedef sp_taskpri_ts _STATIC_MEM_ *sp_taskpri_tsp;

typedef struct
{
	   s_u8_t const svid;
	 s_taskctrl_tsp htask;
	s_delay_t const tick;
}sp_blocktime_ts;
typedef sp_blocktime_ts _STATIC_MEM_ *sp_blocktime_tsp;

typedef struct
{
	s_u8_t const svid;
	s_u8_t const tmid;
	  s_timint_t tick;
}sp_timint_ts;
typedef sp_timint_ts _STATIC_MEM_ *sp_timint_tsp;

typedef struct
{
	s_u8_t const svid;
	s_u8_t const tmid;
	  s_timqry_t tick;
}sp_timqry_ts;
typedef sp_timqry_ts _STATIC_MEM_ *sp_timqry_tsp;

typedef struct
{
	      s_u8_t const svid;
	s_binary_tsp const hbin;
	        bool const value;
}sp_binary_ts;
typedef sp_binary_ts _STATIC_MEM_ *sp_binary_tsp;

typedef struct
{
	      s_u8_t const svid;
	s_semaph_tsp const hsem;
}sp_semaph_ts;
typedef sp_semaph_ts _STATIC_MEM_ *sp_semaph_tsp;

typedef struct
{
	       s_u8_t const svid;
	s_tionbox_tsp const htbox;
	         m_fetion_t tion;
}sp_tionbox_ts;
typedef sp_tionbox_ts _STATIC_MEM_ *sp_tionbox_tsp;

typedef struct
{
	       s_u8_t const svid;
	s_mailbox_tsp const hmbox;
	              void *mail;
}sp_mailbox_ts;
typedef sp_mailbox_ts _STATIC_MEM_ *sp_mailbox_tsp;

typedef struct
{
	      s_u8_t const svid;
	s_msgque_tsp const hque;
	             void *msg;
}sp_msgque_ts;
typedef sp_msgque_ts _STATIC_MEM_ *sp_msgque_tsp;

typedef struct
{
	             s_u8_t const svid;
	void _STATIC_MEM_ * const hgrp;
	               char const size;
	                m_group_t value;
}sp_group_ts;
typedef sp_group_ts _STATIC_MEM_ *sp_group_tsp;

typedef struct
{
	s_u8_t const svid;
	void * const gp;
	void * const lp;
	size_t const size;
}sp_gvar_ts;
typedef sp_gvar_ts _STATIC_MEM_ *sp_gvar_tsp;

typedef struct
{
	        s_u8_t const svid;
	s_voidvoid_tfp const fp;
}sp_pendsvc_ts;
typedef sp_pendsvc_ts _STATIC_MEM_ *sp_pendsvc_tsp;



#endif
