lih/TSCP
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: lih/TSCP:debug/9.4.2应用跟随调试
Branches Tags
lih/TSCP:master lih/TSCP:stable/新加坡分支 lih/TSCP:dev/9.11 lih/TSCP:test/四乘压力测试 lih/TSCP:dev/9.3.101.3 lih/TSCP:stable/9.4.1分支 lih/TSCP:test/轨旁IP化测试 lih/TSCP:debug/9.4.2应用跟随调试 lih/TSCP:stable/迪士尼分支
lih/TSCP:分支9.3.1 lih/TSCP:9.10 lih/TSCP:9.9 lih/TSCP:9.8 lih/TSCP:分支9.4.2 lih/TSCP:9.7 lih/TSCP:9.6 lih/TSCP:9.5 lih/TSCP:9.3 lih/TSCP:9.2 lih/TSCP:9.1
..
compare: lih/TSCP:9.7
Branches Tags
lih/TSCP:stable/新加坡分支 lih/TSCP:dev/9.11 lih/TSCP:test/四乘压力测试 lih/TSCP:master lih/TSCP:dev/9.3.101.3 lih/TSCP:stable/9.4.1分支 lih/TSCP:test/轨旁IP化测试 lih/TSCP:debug/9.4.2应用跟随调试 lih/TSCP:stable/迪士尼分支
lih/TSCP:分支9.3.1 lih/TSCP:9.10 lih/TSCP:9.9 lih/TSCP:9.8 lih/TSCP:分支9.4.2 lih/TSCP:9.7 lih/TSCP:9.6 lih/TSCP:9.5 lih/TSCP:9.3 lih/TSCP:9.2 lih/TSCP:9.1

3 Commits
debug/9.4.2应用跟随调试 .. 9.7

Author SHA1 Message Date
lh 6d6ddaec6b [9.7] 9.7首版一回代码，基线版本 2026-05-22 15:40:28 +08:00
lh 4ffa99ff65 [9.6] 9.6首版一回代码，基线版本 2026-05-22 15:25:38 +08:00
lh 1765e65e49 [9.5] 9.5首版首轮代码，基线版本 2026-05-22 15:18:05 +08:00
295 changed files with 64315 additions and 29043 deletions
Expand all files Collapse all files
TSCP/src/APP/APP_API.c
+267 -40
View File
@@ -16,6 +16,10 @@
static CM_UINT32 gFollowDataLen = 0u; /*应用跟随数据长度*/
static CM_UINT8 gFollowData[MSCP_FOLLOW_BUFF_SIZE] = { 0 }; /*应用跟随数据*/
static CM_UINT32 gCiRcFollowDataLen = 0u; /*CI-RC同步数据长度*/
static CM_UINT8 gCiRcFollowData[MSCP_FOLLOW_BUFF_SIZE] = { 0 }; /*CI-RC同步数据*/
extern UINT8 LocalCiId; /*系统配置文件中定义的联锁ID*/
/* 内网安全通信配置参数，示例： */
/* 内网安全通信配置参数，示例： */
/*ATP、ATO、MMI间通信时,SFP协议使用的数据库数组:
@@ -25,14 +29,15 @@ static CM_UINT8 gFollowData[MSCP_FOLLOW_BUFF_SIZE] = { 0 }; /*应用跟随数据
const CM_UINT8 g_SfpInnetParam[] =
{
0,4,/*不同设备通信关系表记录个数*/
0,5,/*不同设备通信关系表记录个数*/
/*记录的格式如下:*/
/* 发起方 发起方发送数据 发起方报文 发起方报文 发起方接收Ack 跟随方 跟随方发送数据 跟随方运行 跟随方报文 此通信关系中成功发送 */
/* 设备类型 通信类型 发送周期长度 最大延时 报文最大延时差 设备类型 通信类型 周期长度 最大延时 一包数据所需最小周期数 */
/*ZC->CI*/ 0x22, 0x55, 0x01,0x1D, 0x01,0x1D, 0x01,0x1D, 0xff, 0x55, 0x00,0xC8, 0x00,0xC8, 0x02,
/*AOM->TIAS*/ 0x15, 0x55, 0x00,0xC8, 0x00,0xC8, 0x00,0xC8, 0x03, 0x55, 0x00,0xC8, 0x00,0xC8, 0x02,
/*AOM->ATP*/ 0x14, 0x55, 0x00,0xC8, 0x00,0xC8, 0x00,0xC8, 0x15, 0x55, 0x00,0xC8, 0x00,0xC8, 0x02,
/*主机->维护机*/ 0xD9, 0x55, 0x01,0x2c, 0x01,0x2C, 0x01,0x2C, 0xf8, 0x55, 0x00,0xc8, 0x00,0xc8, 0x02,
/*RC主机->维护机*/ 0xD9, 0x55, 0x01,0x2c, 0x01,0x2C, 0x01,0x2C, 0xf8, 0x55, 0x00,0xc8, 0x00,0xc8, 0x02,
/*CI主机->维护机*/ 0xDE, 0x55, 0x01,0x2c, 0x01,0x2C, 0x01,0x2C, 0xf8, 0x55, 0x00,0xc8, 0x00,0xc8, 0x02,
0,2,/*相同设备通信关系表记录个数*/
/*记录的格式如下:*/
/* 发起方 发起方 发起方发送数据 发起方报文 发起方报文 发起方接收Ack 跟随方 跟随方 跟随方发送数据 跟随方运行 跟随方报文 此通信关系中成功发送 */
@@ -185,6 +190,7 @@ ENUM_CM_RETURN APP_API_Init(OUT CM_UINT8 VitalBuf[200], OUT CM_UINT16* pVitalLen
MSCP_SetOutAtsVobcFunc(pReserveOutVobc);
pReserveInAts = SerialInVobcAtsFunc;
MSCP_SetInVobcAtsFunc(pReserveInAts);
MSCP_SetRCFollowUpFunc(SetCiGeneralData);
#if 1
cSwtichFalg = GetCiFunctionSwitchConfig(FUNC_OC_200_INOUTNET);
@@ -224,9 +230,63 @@ void APP_API_Data_Init()
UINT16 ii = 0U;
UINT8 szFSFILEVersionFS[DFS_VERSION_LENGTH] = { 0 };
UINT8 funcRetVal = 0U;
UINT8 cBoardInfo = 0U;
UINT8 cPluginId = 0U;
UINT8 cBoardId = 0U;
UINT8 cRetVal = CI_ERROR;
UINT16 locTypeId = 0U;
UINT8 cDevType = 0U;
UINT8 cSystemWorkType = SYSTEM_WORK_MODE_ONLY;
funcRetVal = dquGetFSVersion(DataPath, szFSFILEVersionFS);
locTypeId = MSCP_GetOutnetID();
LocalCiId = (UINT8)(locTypeId & 0x00FFU); /*联锁设备ID*/
cDevType = (UINT8)((locTypeId >> 8U) & 0x00FFU); /*RC/CI类型*/
cRetVal = CiPatternInit((const)DataPath); /*初始化当前联锁类型配置数据*/
if ((CI_SUCCESS == cRetVal) && (CI_SUCCESS == funcRetVal)) /*初始化当前联锁类型配置数据*/
{
cSystemWorkType = GetSystemWorkType();
#if (kPLATFORM==kVXWORKS)
/*若为真机，则通过平台获取设备类型*/
cBoardInfo = MSCP_GetDrvBoardID();
PlatSheBeiType = &gSheBeiType; /*联锁设备类型*/
cPluginId = ((cBoardInfo >> 4U) & 0x0FU);
cBoardId = (cBoardInfo & 0x0FU);
if (((0x03U == cPluginId) && ((0x03U == cBoardId) || (0x05U == cBoardId)))
|| ((0x0CU == cPluginId) && ((0x06U == cBoardId) || (0x0AU == cBoardId))))
{
(void)SetLocalRcWorkMode(RC_WORK_MODE_TIOC);
gSheBeiType = RC_WORK_MODE_TIOC;
}
else if (((0x04U == cPluginId) && ((0x03U == cBoardId) || (0x05U == cBoardId)))
|| ((0x0BU == cPluginId) && ((0x06U == cBoardId) || (0x0AU == cBoardId))))
{
(void)SetLocalRcWorkMode(RC_WORK_MODE_CI);
gSheBeiType = RC_WORK_MODE_CI;
}
else
{
debug_infor_printf((const)"APP_API_Data_Init Error: CI_SYSTEM_TYPE Error.\n");
printf((const)"APP_API_Data_Init Error: CI_SYSTEM_TYPE Error.\n");
}
/*真机需校验设备类型是否一致*/
locTypeId = MSCP_GetOutnetID();
cDevType = (UINT8)((locTypeId >> 8U) & 0x00FFU); /*RC/CI类型*/
if (gSheBeiType == cDevType)
{
/*继续处理*/
}
else
{
debug_infor_printf((const)"APP_API_Data_Init Error: DevType[0x%x] And [0x%x] Is Not Equal \n", gSheBeiType, cDevType);
cRetVal = CI_ERROR;
}
}
if(CI_SUCCESS == cRetVal)
{
/*文件配置*/
STRU_APP_CFG_T AppCfgInterface = {
.FS_NAME = "RCI.FS", /**< FS文件名称 */
@@ -246,43 +306,21 @@ void APP_API_Data_Init()
.reboot_replycount = 10, /**< 重启确认报文回复次数 */
.M_AutoReboot_Count = 3, /**< 自动重启次数 */
.M_AutoClear_Days = 1, /**< 连续运行多久清空宕机次数的天数 */
.CPU[0].IP_2oo2 = "192.168.0.11", /**< 2oo2通信IP */
.CPU[0].IP_2x2 = "192.168.1.62", /**< 2x2通信IP */
.CPU[0].IP_Out = "192.168.1.62", /**< 外网通信IP */
.CPU[0].IP_Maintain = "192.168.146.101", /**< 维护通信IP */
/*适用透传通道-选配*/
.CPU[0].IP_Com = "192.168.1.62", /**< 通用通信IP */
.CPU[0].IP_Com_Extend = "192.168.1.62",/**< 通用通信扩展IP */
.M_Area_Enable = 0, /**< 区域状态开关配置 */
.M_AREA_SEB_Enable = 0xAA, /**< RC与CI扩展板卡通信功能开关配置 */
.CPU[0].Logger_PortBase = 55011, /**< 明文日志记录发送端口 */
.CPU[0].Logger_PortCiphertext = 55002, /**< 暗文日志记录发送端口 */
.CPU[1].IP_2oo2 = "192.168.0.12", /**< 2oo2通信IP */
.CPU[1].IP_2x2 = "192.168.2.62", /**< 2x2通信IP */
.CPU[1].IP_Out = "192.168.2.62", /**< 外网通信IP */
.CPU[1].IP_Maintain = "192.168.18.102", /**< 维护通信IP */
/*适用透传通道-选配*/
.CPU[1].IP_Com = "192.168.2.62", /**< 通用通信IP */
.CPU[1].IP_Com_Extend = "192.168.2.62",/**< 通用通信扩展IP */
.CPU[1].Logger_PortBase = 55012, /**< 明文日志记录发送端口 */
.CPU[1].Logger_PortCiphertext = 55002, /**< 暗文日志记录发送端口 */
.CPU[2].IP_2oo2 = "192.168.0.21", /**< 2oo2通信IP */
.CPU[2].IP_2x2 = "192.168.1.64", /**< 2x2通信IP */
.CPU[2].IP_Out = "192.168.1.64", /**< 外网通信IP */
.CPU[2].IP_Maintain = "192.168.146.103", /**< 维护通信IP */
/*适用透传通道-选配*/
.CPU[2].IP_Com = "192.168.1.64", /**< 通用通信IP */
.CPU[2].IP_Com_Extend = "192.168.1.64",/**< 通用通信扩展IP */
.CPU[2].Logger_PortBase = 55021, /**< 明文日志记录发送端口 */
.CPU[2].Logger_PortCiphertext = 55002, /**< 暗文日志记录发送端口 */
.CPU[3].IP_2oo2 = "192.168.0.22", /**< 2oo2通信IP */
.CPU[3].IP_2x2 = "192.168.2.64", /**< 2x2通信IP */
.CPU[3].IP_Out = "192.168.2.64", /**< 外网通信IP */
.CPU[3].IP_Maintain = "192.168.18.104", /**< 维护通信IP */
/*适用透传通道-选配*/
.CPU[3].IP_Com = "192.168.2.64", /**< 通用通信IP */
.CPU[3].IP_Com_Extend = "192.168.2.64",/**< 通用通信扩展IP */
.CPU[3].Logger_PortBase = 55022, /**< 明文日志记录发送端口 */
.CPU[3].Logger_PortCiphertext = 55002, /**< 暗文日志记录发送端口 */
/*通用端口配置*/
@@ -313,6 +351,9 @@ void APP_API_Data_Init()
.OutNetRed.CC_P_IP = "192.168.2.60", /**< 通控的内网IP */
.OutNetRed.EXTEND_G_IP = "192.168.1.70", /**< 扩展板卡的内网IP */
.OutNetRed.EXTEND_P_IP = "192.168.2.70", /**< 扩展板卡的内网IP */
.Another_SEB.EXTEND_R_G_IP = "192.168.1.90", /**< CI扩展板卡的内网IP */
.Another_SEB.EXTEND_R_P_IP = "192.168.2.90", /**< CI扩展板卡的内网IP */
.Another_SEB.OutnetSafe_R_Port = 54001, /**< 外网安全通信端口 */
.OutNetRed.OutnetSafe_Port = 54001, /**< 外网安全通信端口 */
.OutNetRed.OutnetRaw_Port = 54002, /**< 外网透传通信端口 */
.OutNetRed.InnetRaw_Port = 53003, /**< 内网透传通信端口 */
@@ -321,23 +362,177 @@ void APP_API_Data_Init()
.OutNetBlue.CC_P_IP = "192.168.2.61", /**< 通控的内网IP */
.OutNetBlue.EXTEND_G_IP = "192.168.1.71", /**< 扩展板卡的内网IP */
.OutNetBlue.EXTEND_P_IP = "192.168.2.71", /**< 扩展板卡的内网IP */
.Another_SEB.EXTEND_B_G_IP = "192.168.1.91", /**< CI扩展板卡的内网IP */
.Another_SEB.EXTEND_B_P_IP = "192.168.2.91", /**< CI扩展板卡的内网IP */
.Another_SEB.OutnetSafe_B_Port = 54001, /**< 外网安全通信端口 */
.OutNetBlue.OutnetSafe_Port = 54001, /**< 外网安全通信端口 */
.OutNetBlue.OutnetRaw_Port = 54002, /**< 外网透传通信端口 */
.OutNetBlue.InnetRaw_Port = 53003, /**< 内网透传通信端口 */
/*日志记录目标设备IP配置*/
.Logger_G_IP = "192.168.146.100", /**< 绿网日志记录IP */
.Logger_P_IP = "192.168.18.100", /**< 紫网日志记录IP */
/*内网通信设备注册最大支持0-255*/
.INNET_COM_NUM = 1, /**< 内网通信设备数量 */
.INNET_COM_CFG[0].InnetID = DEVICE_TYPE_AIM, /**< 内网通信ID */
.INNET_COM_CFG[0].IP_G = (CM_UINT32)inet_addr("192.168.146.100"),/**< 绿网IP */
.INNET_COM_CFG[0].Port_Raw_G = 55004, /**< 绿网透传端口 */
.INNET_COM_CFG[0].Port_Safe_G = 55003, /**< 绿网安全端口 */
.INNET_COM_CFG[0].IP_P = (CM_UINT32)inet_addr("192.168.18.100"),/**< 紫网IP */
.INNET_COM_CFG[0].Port_Raw_P = 55004, /**< 紫网透传端口 */
.INNET_COM_CFG[0].Port_Safe_P = 55003, /**< 紫网安全端口 */
};
if (RC_WORK_MODE_TIOC == CI_SYSTEM_TYPE_RCI)
{
/*设置IP 与CIIP一致*/
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[0].IP_2oo2), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.0.11"), (UINT32)sizeof("192.168.0.11"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[0].IP_2x2), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.62"), (UINT32)sizeof("192.168.1.62"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[0].IP_Out), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.62"), (UINT32)sizeof("192.168.1.62"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[0].IP_Com), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.62"), (UINT32)sizeof("192.168.1.62"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[0].IP_Com_Extend), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.62"), (UINT32)sizeof("192.168.1.62"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[1].IP_2oo2), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.0.12"), (UINT32)sizeof("192.168.0.12"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[1].IP_2x2), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.62"), (UINT32)sizeof("192.168.2.62"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[1].IP_Out), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.62"), (UINT32)sizeof("192.168.2.62"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[1].IP_Com), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.62"), (UINT32)sizeof("192.168.2.62"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[1].IP_Com_Extend), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.62"), (UINT32)sizeof("192.168.2.62"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[2].IP_2oo2), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.0.21"), (UINT32)sizeof("192.168.0.21"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[2].IP_2x2), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.64"), (UINT32)sizeof("192.168.1.64"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[2].IP_Out), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.64"), (UINT32)sizeof("192.168.1.64"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[2].IP_Com), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.64"), (UINT32)sizeof("192.168.1.64"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[2].IP_Com_Extend), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.64"), (UINT32)sizeof("192.168.1.64"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[3].IP_2oo2), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.0.22"), (UINT32)sizeof("192.168.0.22"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[3].IP_2x2), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.64"), (UINT32)sizeof("192.168.2.64"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[3].IP_Out), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.64"), (UINT32)sizeof("192.168.2.64"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[3].IP_Com), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.64"), (UINT32)sizeof("192.168.2.64"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[3].IP_Com_Extend), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.64"), (UINT32)sizeof("192.168.2.64"));
/*CPU1*/
(void)CommonMemCpy((void*)(AppCfgInterface.AREA_CPU[0].IP_Area_A), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.66"), (UINT32)sizeof("192.168.1.66"));
(void)CommonMemCpy((void*)(AppCfgInterface.AREA_CPU[0].IP_Area_B), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.68"), (UINT32)sizeof("192.168.1.68"));
(void)CommonMemCpy((void*)(AppCfgInterface.AREA_CPU[0].IP_Multicast_Mine), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("239.0.0.21"), (UINT32)sizeof("239.0.0.21"));
(void)CommonMemCpy((void*)(AppCfgInterface.AREA_CPU[0].IP_Multicast_Dest), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("239.0.0.11"), (UINT32)sizeof("239.0.0.11"));
/*CPU2*/
(void)CommonMemCpy((void*)(AppCfgInterface.AREA_CPU[1].IP_Area_A), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.66"), (UINT32)sizeof("192.168.2.66"));
(void)CommonMemCpy((void*)(AppCfgInterface.AREA_CPU[1].IP_Area_B), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.68"), (UINT32)sizeof("192.168.2.68"));
(void)CommonMemCpy((void*)(AppCfgInterface.AREA_CPU[1].IP_Multicast_Mine), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("239.0.0.22"), (UINT32)sizeof("239.0.0.22"));
(void)CommonMemCpy((void*)(AppCfgInterface.AREA_CPU[1].IP_Multicast_Dest), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("239.0.0.12"), (UINT32)sizeof("239.0.0.12"));
/*内网 通控与扩展板卡*/
(void)CommonMemCpy((void*)(AppCfgInterface.OutNetRed.CC_G_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.60"), (UINT32)sizeof("192.168.1.60"));
(void)CommonMemCpy((void*)(AppCfgInterface.OutNetRed.CC_P_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.60"), (UINT32)sizeof("192.168.2.60"));
(void)CommonMemCpy((void*)(AppCfgInterface.OutNetRed.EXTEND_G_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.70"), (UINT32)sizeof("192.168.1.70"));
(void)CommonMemCpy((void*)(AppCfgInterface.OutNetRed.EXTEND_P_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.70"), (UINT32)sizeof("192.168.2.70"));
(void)CommonMemCpy((void*)(AppCfgInterface.Another_SEB.EXTEND_R_G_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.90"), (UINT32)sizeof("192.168.1.90"));
(void)CommonMemCpy((void*)(AppCfgInterface.Another_SEB.EXTEND_R_P_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.90"), (UINT32)sizeof("192.168.2.90"));
(void)CommonMemCpy((void*)(AppCfgInterface.OutNetBlue.CC_G_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.61"), (UINT32)sizeof("192.168.1.61"));
(void)CommonMemCpy((void*)(AppCfgInterface.OutNetBlue.CC_P_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.61"), (UINT32)sizeof("192.168.2.61"));
(void)CommonMemCpy((void*)(AppCfgInterface.OutNetBlue.EXTEND_G_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.71"), (UINT32)sizeof("192.168.1.71"));
(void)CommonMemCpy((void*)(AppCfgInterface.OutNetBlue.EXTEND_P_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.71"), (UINT32)sizeof("192.168.2.71"));
(void)CommonMemCpy((void*)(AppCfgInterface.Another_SEB.EXTEND_B_G_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.91"), (UINT32)sizeof("192.168.1.91"));
(void)CommonMemCpy((void*)(AppCfgInterface.Another_SEB.EXTEND_B_P_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.91"), (UINT32)sizeof("192.168.2.91"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[0].IP_Maintain), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.146.101"), (UINT32)sizeof("192.168.146.101"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[1].IP_Maintain), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.18.102"), (UINT32)sizeof("192.168.18.102"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[2].IP_Maintain), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.146.103"), (UINT32)sizeof("192.168.146.103"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[3].IP_Maintain), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.18.104"), (UINT32)sizeof("192.168.18.104"));
(void)CommonMemCpy((void*)(AppCfgInterface.Logger_G_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.146.100"), (UINT32)sizeof("192.168.146.100"));
(void)CommonMemCpy((void*)(AppCfgInterface.Logger_P_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.18.100"), (UINT32)sizeof("192.168.18.100"));
AppCfgInterface.INNET_COM_CFG[0].IP_G = (CM_UINT32)inet_addr("192.168.146.100");
AppCfgInterface.INNET_COM_CFG[0].IP_P = (CM_UINT32)inet_addr("192.168.18.100");
}
else
{/*设置IP 与CIIP一致*/
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[0].IP_2oo2), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.0.11"), (UINT32)sizeof("192.168.0.11"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[0].IP_2x2), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.66"), (UINT32)sizeof("192.168.1.66"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[0].IP_Out), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.66"), (UINT32)sizeof("192.168.1.66"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[0].IP_Com), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.66"), (UINT32)sizeof("192.168.1.66"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[0].IP_Com_Extend), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.66"), (UINT32)sizeof("192.168.1.66"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[1].IP_2oo2), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.0.12"), (UINT32)sizeof("192.168.0.12"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[1].IP_2x2), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.66"), (UINT32)sizeof("192.168.2.66"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[1].IP_Out), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.66"), (UINT32)sizeof("192.168.2.66"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[1].IP_Com), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.66"), (UINT32)sizeof("192.168.2.66"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[1].IP_Com_Extend), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.66"), (UINT32)sizeof("192.168.2.66"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[2].IP_2oo2), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.0.21"), (UINT32)sizeof("192.168.0.21"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[2].IP_2x2), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.68"), (UINT32)sizeof("192.168.1.68"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[2].IP_Out), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.68"), (UINT32)sizeof("192.168.1.68"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[2].IP_Com), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.68"), (UINT32)sizeof("192.168.1.68"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[2].IP_Com_Extend), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.68"), (UINT32)sizeof("192.168.1.68"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[3].IP_2oo2), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.0.22"), (UINT32)sizeof("192.168.0.22"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[3].IP_2x2), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.68"), (UINT32)sizeof("192.168.2.68"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[3].IP_Out), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.68"), (UINT32)sizeof("192.168.2.68"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[3].IP_Com), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.68"), (UINT32)sizeof("192.168.2.68"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[3].IP_Com_Extend), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.68"), (UINT32)sizeof("192.168.2.68"));
/*CPU1*/
(void)CommonMemCpy((void*)(AppCfgInterface.AREA_CPU[0].IP_Area_A), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.62"), (UINT32)sizeof("192.168.1.62"));
(void)CommonMemCpy((void*)(AppCfgInterface.AREA_CPU[0].IP_Area_B), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.64"), (UINT32)sizeof("192.168.1.64"));
(void)CommonMemCpy((void*)(AppCfgInterface.AREA_CPU[0].IP_Multicast_Mine), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("239.0.0.11"), (UINT32)sizeof("239.0.0.11"));
(void)CommonMemCpy((void*)(AppCfgInterface.AREA_CPU[0].IP_Multicast_Dest), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("239.0.0.21"), (UINT32)sizeof("239.0.0.21"));
/*CPU2*/
(void)CommonMemCpy((void*)(AppCfgInterface.AREA_CPU[1].IP_Area_A), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.62"), (UINT32)sizeof("192.168.2.62"));
(void)CommonMemCpy((void*)(AppCfgInterface.AREA_CPU[1].IP_Area_B), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.64"), (UINT32)sizeof("192.168.2.64"));
(void)CommonMemCpy((void*)(AppCfgInterface.AREA_CPU[1].IP_Multicast_Mine), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("239.0.0.12"), (UINT32)sizeof("239.0.0.12"));
(void)CommonMemCpy((void*)(AppCfgInterface.AREA_CPU[1].IP_Multicast_Dest), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("239.0.0.22"), (UINT32)sizeof("239.0.0.22"));
/*内网 通控与扩展板卡*/
(void)CommonMemCpy((void*)(AppCfgInterface.OutNetRed.CC_G_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.80"), (UINT32)sizeof("192.168.1.80"));
(void)CommonMemCpy((void*)(AppCfgInterface.OutNetRed.CC_P_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.80"), (UINT32)sizeof("192.168.2.80"));
(void)CommonMemCpy((void*)(AppCfgInterface.OutNetRed.EXTEND_G_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.90"), (UINT32)sizeof("192.168.1.90"));
(void)CommonMemCpy((void*)(AppCfgInterface.OutNetRed.EXTEND_P_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.90"), (UINT32)sizeof("192.168.2.90"));
(void)CommonMemCpy((void*)(AppCfgInterface.Another_SEB.EXTEND_R_G_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.90"), (UINT32)sizeof("192.168.1.90"));
(void)CommonMemCpy((void*)(AppCfgInterface.Another_SEB.EXTEND_R_P_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.90"), (UINT32)sizeof("192.168.2.90"));
(void)CommonMemCpy((void*)(AppCfgInterface.OutNetBlue.CC_G_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.81"), (UINT32)sizeof("192.168.1.81"));
(void)CommonMemCpy((void*)(AppCfgInterface.OutNetBlue.CC_P_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.81"), (UINT32)sizeof("192.168.2.81"));
(void)CommonMemCpy((void*)(AppCfgInterface.OutNetBlue.EXTEND_G_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.91"), (UINT32)sizeof("192.168.1.91"));
(void)CommonMemCpy((void*)(AppCfgInterface.OutNetBlue.EXTEND_P_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.91"), (UINT32)sizeof("192.168.2.91"));
(void)CommonMemCpy((void*)(AppCfgInterface.Another_SEB.EXTEND_B_G_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.1.91"), (UINT32)sizeof("192.168.1.91"));
(void)CommonMemCpy((void*)(AppCfgInterface.Another_SEB.EXTEND_B_P_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.2.91"), (UINT32)sizeof("192.168.2.91"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[0].IP_Maintain), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.148.101"), (UINT32)sizeof("192.168.148.101"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[1].IP_Maintain), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.20.102"), (UINT32)sizeof("192.168.20.102"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[2].IP_Maintain), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.148.103"), (UINT32)sizeof("192.168.148.103"));
(void)CommonMemCpy((void*)(AppCfgInterface.CPU[3].IP_Maintain), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.20.104"), (UINT32)sizeof("192.168.20.104"));
(void)CommonMemCpy((void*)(AppCfgInterface.Logger_G_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.148.100"), (UINT32)sizeof("192.168.148.100"));
(void)CommonMemCpy((void*)(AppCfgInterface.Logger_P_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.20.100"), (UINT32)sizeof("192.168.20.100"));
AppCfgInterface.INNET_COM_CFG[0].IP_G = (CM_UINT32)inet_addr("192.168.148.100");
AppCfgInterface.INNET_COM_CFG[0].IP_P = (CM_UINT32)inet_addr("192.168.20.100");
}
if(SYSTEM_WORK_MODE_ONLY == cSystemWorkType)
{
/*单系统运行：区域开关设置为0*/
AppCfgInterface.M_Area_Enable = 0u;
}
else
{
/*双系统运行*/
if (RC_WORK_MODE_TIOC == CI_SYSTEM_TYPE_RCI)
{
/*RC区域开关设置为0xAA*/
AppCfgInterface.M_Area_Enable = 0xAAu;
/**< RC与CI扩展板卡通信功能开关配置 */
AppCfgInterface.M_AREA_SEB_Enable = 0x55u;
}
else
{
/*设置CI IP+区域IP*/
AppCfgInterface.M_Area_Enable = 0x55u;
}
}
MSCP_Set_APP_ConfigData(&AppCfgInterface);
#endif
/*组FS版本号*/
@@ -360,6 +555,7 @@ void APP_API_Data_Init()
MSCP_SetAppVersion(appVersBuffer);
MSCP_SetFsVersion(fsVersBuffer);
}
}
/**
* @brief 应用周期主逻辑
* @return ENUM_CM_RETURN 函数执行结果
@@ -396,6 +592,9 @@ ENUM_CM_RETURN APP_API_MainFunc(void)
gFollowDataLen = GetCiAppData(gFollowData);
MSCP_SetFollowData(gFollowData, gFollowDataLen);
gCiRcFollowDataLen = GetCiGeneralData(gCiRcFollowData);
MSCP_CISendAppData(gCiRcFollowData, gCiRcFollowDataLen);
return retVal;
}
@@ -523,6 +722,9 @@ ENUM_CM_RECCUSEB Is_Send_ExtendBoard(IN const CM_UINT16 dstDevTypeId)
UINT8 chLocalCiType = 0U; /*本联锁属性*/
UINT8 chDstCiType = 0U; /*本联锁属性*/
UINT8 chCldScxCommMode = 0U;
UINT8 chWorkType = 0U; /*双系工作模式*/
UINT8 cControlState = 0U;/*主备用模式*/
UINT8 cRcWorkMode = 0u;/*RC工作模式*/
UINT8 chResult = CI_ERROR; /*联锁属性检查结果*/
wAtsGtWayDevTypeId = GetTiocTrnsmtGtwyDevTypeId();
@@ -535,8 +737,11 @@ ENUM_CM_RECCUSEB Is_Send_ExtendBoard(IN const CM_UINT16 dstDevTypeId)
chLocalCiType = GetLocalCiType();
chDstCiType = GetCiType(devId);
chCldScxCommMode = GetCiFunctionSwitchConfig(SCX_CLD_INTERFACE_TYPE);
chWorkType = GetSystemWorkType();
cControlState = GetLocalCiBackUpPattern();
cRcWorkMode = GetLocalRcWorkMode();
if ((SCX_CLD_SERIAL_PORT_COMM == chCldScxCommMode) && (CI_SYSTEM_TYPE_CI == devType))
if ((SCX_CLD_SERIAL_PORT_COMM == chCldScxCommMode) && (CI_SYSTEM_TYPE_RCI == devType))
{
if (((CI_TYPE_CLD == chLocalCiType) && (CI_TYPE_SCX == chDstCiType)) || ((CI_TYPE_SCX == chLocalCiType) && (CI_TYPE_CLD == chDstCiType)))
{
@@ -553,9 +758,9 @@ ENUM_CM_RECCUSEB Is_Send_ExtendBoard(IN const CM_UINT16 dstDevTypeId)
; /*不为串口通信，此时不对本地CI类型及对方CI类型进行判断*/
}
if ((CI_SYSTEM_TYPE_XIANDI == devType) || (CI_SYSTEM_TYPE_ATS == devType) || (CI_SYSTEM_TYPE_LEU == devType)
if ((CI_SYSTEM_TYPE_XIANDI == devType) || (CI_SYSTEM_TYPE_ATS == devType)
|| (CI_SUCCESS == chResult)
|| (CI_SYSTEM_TYPE_VOBC_BACKUP == devType)) /*现地,ATS,LEU,使用串口的相邻CI*/
|| (CI_SYSTEM_TYPE_VOBC_BACKUP == devType)) /*现地,ATS,使用串口的相邻CI*/
{
retVal = ENUM_CM_SEB;
}
@@ -563,6 +768,28 @@ ENUM_CM_RECCUSEB Is_Send_ExtendBoard(IN const CM_UINT16 dstDevTypeId)
{
retVal = ENUM_CM_CCSEB;
}
else if (CI_SYSTEM_TYPE_LEU == devType)
{
if ((SYSTEM_WORK_MODE_ALL == chWorkType) && (RC_WORK_MODE_TIOC == cRcWorkMode))
{
/*双系统,并且当前是RC*/
if (SYSTEM_WORK_MODE_MAIN == cControlState)
{
/*是RC主用时，需要用CI的串口板进行LEU通信*/
retVal = ENUM_CM_SEB_ANOTHER;
}
else
{
/*RC备用，禁止发送*/
retVal = ENUM_CM_FORBIDDEN;
}
}
else
{
/*单系统，或当前是CI*/
retVal = ENUM_CM_SEB;
}
}
else
{
retVal = ENUM_CM_CC;
@@ -761,7 +988,7 @@ ENUM_CM_RETURN SerialOutAtsVobcFunc(UINT16 inDstId IN, UINT16* outSrcId OUT, UIN
inDstType = (UINT8)((inDstId & 0xff00U) >> 8);
if ((CI_SYSTEM_TYPE_VOBC_BACKUP == inDstType) || (CI_SYSTEM_TYPE_ITE == inDstType))
{
*outSrcId = (CI_SYSTEM_TYPE_CI << 8) + GetSystemParaLocalCiId();
*outSrcId = (CI_SYSTEM_TYPE_RCI << 8) + GetSystemParaLocalCiId();
*outDstId = GetATSInterfaceTypeId();
retVal = ENUM_CM_TRUE;
TSCP/src/APP/PU13_integration_config/ci_integrate_config.h
+1 -1
View File
@@ -30,6 +30,6 @@
#define VER_INTE_PROJECT 220 /*项目编号*/
#define VER_INTE_PRODUCT 40 /*产品编号*/
#define VER_INTE_EXE 1 /*可执行编号*/
#define VER_INTE_TIME 126 /*集成次数编号*/
#define VER_INTE_TIME 112 /*集成次数编号*/
#endif/*endif of #define _CI_INTEGRATE_CONFIG_H*/
TSCP/src/APP/ciapp/2oo2/2oo2DataTransferManage.c
+3429 -502
View File
File diff suppressed because it is too large Load Diff
TSCP/src/APP/ciapp/2oo2/2oo2DataTransferManage.h
+288 -1
View File
@@ -56,7 +56,6 @@
#include "../Route/LogicalRouteDataManage.h"
#include "../Route/LongRouteDataManage.h"
#include "../ReverseCut/ReverseCutDataManage.h"
#include "../AxisSort/AxisSort.h"
#ifdef __cplusplus
extern "C" {
@@ -154,6 +153,20 @@ UINT32 CopyValidSetVobcBackHlht(const UINT8 *pCurCiAppDataPointer, UINT16 struNu
*/
UINT32 CopyValidSetVobcDataStru(const UINT8* pCurCiAppDataPointer, VobcToCiDataStruct* pDataStru, UINT16 struNum);
/*
* 功能描述： 拷贝RC通信的VOBC有效数据到对应的全局数组
* 参数说明：
输入参数
const UINT8 *pCurCiAppDataPointer:当前数据指针
UINT16 struNum:数组长度,
UINT16 struLength:结构体长度
输出参数
void *pDataStru:结构体指针,
* 返回值 ： 拷贝数据的长度
*/
UINT32 CopyValidSetRcVobcDataStru(const UINT8* pCurCiAppDataPointer, void* pDataStru, UINT16 struNum, UINT16 struLength);
/*
* 功能描述：拷贝ITE有效数据到对应的全局数组
* 参数说明：const UINT8 *pCurCiAppDataPointer:当前数据指针
@@ -189,6 +202,280 @@ UINT32 GetCiAppData(UINT8 *pCiAppDataPointer);
*/
UINT8 SetCiAppData(const UINT8 *pCiAppDataPointer,const UINT32 len);
/**
* @brief 拷贝获取现地有效互联互通头
* @param[in] UINT8 *pCurCiAppDataPointer:当前数据指针
* @param[in] UINT16 struNum:数组长度
* @param[in] struLength:结构体长度
* @return 无
* @note by cgh 20251103
*/
UINT32 CopyValidGetXiandiHlht(UINT8* pCurCiAppDataPointer, UINT16 struNum, UINT16 struLength);
/**
* @brief 拷贝设置现地有效互联互通头
* @param[in] UINT8 *pCurCiAppDataPointer:当前数据指针
* @param[in] UINT16 struNum:数组长度
* @param[in] struLength:结构体长度
* @return 无
* @note by cgh 20251103
*/
UINT32 CopyValidSetXiandiHlht(const UINT8* pCurCiAppDataPointer, UINT16 struNum, UINT16 struLength);
/**
* @brief 拷贝获取ATS有效互联互通头
* @param[in] UINT8 *pCurCiAppDataPointer:当前数据指针
* @param[in] UINT16 struNum:数组长度
* @param[in] struLength:结构体长度
* @return 无
* @note by cgh 20251103
*/
UINT32 CopyValidGetAtsHlht(UINT8* pCurCiAppDataPointer, UINT16 struNum, UINT16 struLength);
/**
* @brief 拷贝设置ATS有效互联互通头
* @param[in] UINT8 *pCurCiAppDataPointer:当前数据指针
* @param[in] UINT16 struNum:数组长度
* @param[in] struLength:结构体长度
* @return 无
* @note by cgh 20251103
*/
UINT32 CopyValidSetAtsiHlht(const UINT8* pCurCiAppDataPointer, UINT16 struNum, UINT16 struLength);
/*
* 功能描述： CI待发送RC应用数据
* 参数说明： UINT8 *pCiAppDataPointer, CI应用数据指针
* 返回值 ： void
*/
UINT32 GetCiGeneralData(UINT8* pCiAppDataPointer);
/*
* 功能描述： RC设置CI的应用数据
* 参数说明： UINT8 *pCiAppDataPointer, CI应用数据指针
* const UINT32 len，数据长度
* 返回值 ： UINT8，
*/
UINT8 SetCiGeneralData(const UINT8* pCiAppDataPointer, const UINT32 len);
/*
* 功能描述：二乘拷贝互联互通报文头
* 参数说明：UINT8 *pCurCiAppDataPointer 当前数据指针
* UINT16 struNum 数组长度
* struLength 结构体长度
* HLHTHeadContextStru pstrHLHTHeadCtxs[] 待拷贝的互联互通报文头
* 返 回 值：拷贝的数据长度
* Created By LQ 2025.11.04
*/
UINT32 CopyValidGetHlhtHeadCtxs(UINT8* pCurCiAppDataPointer, UINT16 struNum, UINT16 struLength, HLHTHeadContextStru pstrHLHTHeadCtxs[]);
/*
* 功能描述：二乘设置互联互通报文头
* 参数说明：UINT8 *pCurCiAppDataPointer 当前数据指针
* UINT16 struNum 数组长度
* struLength 结构体长度
* HLHTHeadContextStru pstrHLHTHeadCtxs[] 待设置的互联互通报文头
* 返 回 值：拷贝的数据长度
* Created By LQ 2025.11.04
*/
UINT32 CopyValidSetHlhtHeadCtxs(const UINT8* pCurCiAppDataPointer, UINT16 struNum, UINT16 struLength, HLHTHeadContextStru pstrHLHTHeadCtxs[]);
/*
* 功能描述：二乘拷贝信号机结构体-车车
* 参数说明：UINT8 *pCurCiAppDataPointer 当前数据指针
* UINT16 struNum 数组长度
* SignalDataStructCC pstSignalDataStruCC[] 待拷贝的结构体
* 返 回 值：拷贝的数据长度
* Created By LYJ 2025.11.07
*/
UINT32 CopyValidGetSigDataCC(UINT8* pCurCiAppDataPointer, UINT16 struNum, SignalDataStructCC pstSignalDataStruCC[]);
/*
* 功能描述：二乘设置信号机结构体-车车
* 参数说明：UINT8 *pCurCiAppDataPointer 当前数据指针
* UINT16 struNum 数组长度
* SignalDataStructCC pstSignalDataStruCC[] 待设置的结构体
* 返 回 值：拷贝的数据长度
* Created By LYJ 2025.11.07
*/
UINT32 CopyValidSetSigDataCC(UINT8* pCurCiAppDataPointer, UINT16 struNum, SignalDataStructCC pstSignalDataStruCC[]);
/*
* 功能描述：二乘拷贝防淹门结构体-车车
* 参数说明：UINT8 *pCurCiAppDataPointer 当前数据指针
* UINT16 struNum 数组长度
* FloodGateDataStructCC pstFloodGateDataStruCC[] 待拷贝的结构体
* 返 回 值：拷贝的数据长度
* Created By LYJ 2025.11.07
*/
UINT32 CopyValidGetFloodGateDataCC(UINT8* pCurCiAppDataPointer, UINT16 struNum, FloodGateDataStructCC pstFloodGateDataStruCC[]);
/*
* 功能描述：二乘设置防淹门结构体-车车
* 参数说明：UINT8 *pCurCiAppDataPointer 当前数据指针
* UINT16 struNum 数组长度
* FloodGateDataStructCC pstFloodGateDataStruCC[] 待拷贝的结构体
* 返 回 值：拷贝的数据长度
* Created By LYJ 2025.11.07
*/
UINT32 CopyValidSetFloodGateDataCC(UINT8* pCurCiAppDataPointer, UINT16 struNum, FloodGateDataStructCC pstFloodGateDataStruCC[]);
/*
* 功能描述：二乘拷贝逻辑区段结构体-车车
* 参数说明：UINT8 *pCurCiAppDataPointer 当前数据指针
* UINT16 struNum 数组长度
* LogicSectionDataStructCC pstLogSecDataStruCC[] 待拷贝的结构体
* 返 回 值：拷贝的数据长度
* Created By LYJ 2025.11.07
*/
UINT32 CopyValidGetLogicSecDataCC(UINT8* pCurCiAppDataPointer, UINT16 struNum, LogicSectionDataStructCC pstLogSecDataStruCC[]);
/*
* 功能描述：二乘设置逻辑区段结构体-车车
* 参数说明：UINT8 *pCurCiAppDataPointer 当前数据指针
* UINT16 struNum 数组长度
* LogicSectionDataStructCC pstLogSecDataStruCC[] 待拷贝的结构体
* 返 回 值：拷贝的数据长度
* Created By LYJ 2025.11.07
*/
UINT32 CopyValidSetLogicSecDataCC(UINT8* pCurCiAppDataPointer, UINT16 struNum, LogicSectionDataStructCC pstLogSecDataStruCC[]);
/*
* 功能描述：二乘拷贝进路结构体-车车
* 参数说明：UINT8 *pCurCiAppDataPointer 当前数据指针
* UINT16 struNum 数组长度
* RouteDataStructCC pstRouteDataStruCC[] 待拷贝的结构体
* 返 回 值：拷贝的数据长度
* Created By LYJ 2025.11.10
*/
UINT32 CopyValidGetRouteDataCC(UINT8* pCurCiAppDataPointer, UINT16 struNum, RouteDataStructCC pstRouteDataStruCC[]);
/*
* 功能描述：二乘拷贝进路结构体-车车
* 参数说明：UINT8 *pCurCiAppDataPointer 当前数据指针
* UINT16 struNum 数组长度
* RouteDataStructCC pstRouteDataStruCC[] 待拷贝的结构体
* 返 回 值：拷贝的数据长度
* Created By LYJ 2025.11.10
*/
UINT32 CopyValidSetRouteDataCC(UINT8* pCurCiAppDataPointer, UINT16 struNum, RouteDataStructCC pstRouteDataStruCC[]);
/*
* 功能描述：拷贝ZC发送的信号机数据
* 参数说明：UINT8* pCurCiAppDataPointer 当前数据指针
* 返 回 值：拷贝数据的长度
* Created By LQ 2025.11.10
*/
UINT32 CopyGetZcSignalDymDataStru(UINT8* pCurCiAppDataPointer);
/*
* 功能描述：同步ZC发送的信号机数据
* 参数说明：UINT8* pCurCiAppDataPointer 当前数据指针
* 返 回 值：拷贝数据的长度
* Created By LQ 2025.11.10
*/
UINT32 CopySetZcSignalDymDataStru(const UINT8* pCurCiAppDataPointer);
/*
* 功能描述：拷贝ZC发送的逻辑区段数据
* 参数说明：UINT8* pCurCiAppDataPointer 当前数据指针
* 返 回 值：拷贝数据的长度
* Created By LQ 2025.11.10
*/
UINT32 CopyGetZcLogSecDymDataStru(UINT8* pCurCiAppDataPointer);
/*
* 功能描述：同步ZC发送的逻辑区段数据
* 参数说明：UINT8* pCurCiAppDataPointer 当前数据指针
* 返 回 值：拷贝数据的长度
* Created By LQ 2025.11.10
*/
UINT32 CopySetZcLogSecDymDataStru(const UINT8* pCurCiAppDataPointer);
/*
* 功能描述：拷贝ZC发送的计轴区段数据
* 参数说明：UINT8* pCurCiAppDataPointer 当前数据指针
* 返 回 值：拷贝数据的长度
* Created By LQ 2025.11.10
*/
UINT32 CopyGetZcAxisSecDymDataStru(UINT8* pCurCiAppDataPointer);
/*
* 功能描述：同步ZC发送的计轴区段数据
* 参数说明：UINT8* pCurCiAppDataPointer 当前数据指针
* 返 回 值：拷贝数据的长度
* Created By LQ 2025.11.10
*/
UINT32 CopySetZcAxisSecDymDataStru(const UINT8* pCurCiAppDataPointer);
/*
* 功能描述：拷贝ZC发送的物理区段数据
* 参数说明：UINT8* pCurCiAppDataPointer 当前数据指针
* 返 回 值：拷贝数据的长度
* Created By LQ 2025.11.10
*/
UINT32 CopyGetZcPhySecDymDataStru(UINT8* pCurCiAppDataPointer);
/*
* 功能描述：同步ZC发送的物理区段数据
* 参数说明：UINT8* pCurCiAppDataPointer 当前数据指针
* 返 回 值：拷贝数据的长度
* Created By LQ 2025.11.10
*/
UINT32 CopySetZcPhySecDymDataStru(const UINT8* pCurCiAppDataPointer);
/*
* 功能描述：拷贝ZC发送的进路数据
* 参数说明：UINT8* pCurCiAppDataPointer 当前数据指针
* 返 回 值：拷贝数据的长度
* Created By LQ 2025.11.10
*/
UINT32 CopyGetZcRouteDymDataStru(UINT8* pCurCiAppDataPointer);
/*
* 功能描述：同步ZC发送的进路数据
* 参数说明：UINT8* pCurCiAppDataPointer 当前数据指针
* 返 回 值：拷贝数据的长度
* Created By LQ 2025.11.10
*/
UINT32 CopySetZcRouteDymDataStru(const UINT8* pCurCiAppDataPointer);
/*
* 功能描述：二乘设置OC有效数据
* 参数说明：UINT8 *pCurCiAppDataPointer 当前数据指针
* UINT16 struNum 数组长度
* 返 回 值：拷贝的数据长度
* Created By fan 2025.11.12
*/
UINT32 CopyValidSetOcOrginData(UINT8* pCurCiAppDataPointer, UINT16 struNum, OcToCiOriginDataStruct OcRecvData[]);
/*
* 功能描述：二乘拷贝OC原始数据有效值
* 参数说明：UINT8 *pCurCiAppDataPointer 当前数据指针
* UINT16 struNum 数组长度
* OcToCiOriginDataStruct OcRecvData[] 待拷贝的结构体
* 返 回 值：拷贝的数据长度
* Created By fan 2025.11.12
*/
UINT32 CopyValidGetOcOrginData(UINT8* pCurCiAppDataPointer, UINT16 struNum, OcToCiOriginDataStruct OcRecvData[]);
/*
* 功能描述： 设置报文上下文数据
* 参数说明：
输入参数
const UINT8 *pCurCiAppDataPointer:当前数据指针
UINT16 struNum:数组长度,
输出参数
HLHTHeadContextStru *pDataStru:结构体指针,
* 返回值 ： 拷贝数据的长度
* 注 意 ； 只适用于报文上下文
*/
UINT32 CopyValidSetHlhtHeadDataStru(const UINT8 *pCurCiAppDataPointer, UINT16 struNum, HLHTHeadContextStru *pDataStru);
/*
* 功能描述： 拷贝报文上下文数据数据
输入参数
const HLHTHeadContextStru *pDataStru 结构体指针
UINT16 struNum:数组长度,
输出参数
UINT8 *pCurCiAppDataPointer:当前数据指针,
* 返回值 ： 拷贝数据的长度
* 注 意 ； 只适用于报文上下文
*/
UINT32 CopyValidGetHlhtHeadDataStru(UINT8 *pCurCiAppDataPointer, UINT16 struNum, const HLHTHeadContextStru *pDataStru);
#ifdef __cplusplus
}
#endif
TSCP/src/APP/ciapp/2oo2/2oo2InterfaceDataManage.c
+25 -17
View File
@@ -10,7 +10,6 @@
********************************************************/
#include "../2oo2/2oo2InterfaceDataManage.h"
#include "MSCP_APP_API.h"
#include "stdarg.h"
#include "protclStruct.h"
#include "ParsePackCommon.h"
@@ -29,9 +28,7 @@ extern UINT8 processor_mode; /*ƽ̨
extern UINT8 FSIOLinkStatusInfo; /*联锁机与FSIO之间连接状态*/
extern UINT8 LEULinkStatusInfo; /*联锁与LEU通信状态*/
extern UINT8 ZCLinkStatusInfo; /*联锁与ZC通信状态*/
extern UINT8 gSheBeiType; /*对外的设备类型*/
extern UINT8 gSheBeiID; /*对外的设备ID*/
extern UINT8 LocalCiId; /*系统配置文件中定义的联锁ID*/
extern QueueStruct logPrintfQue; /*日志存储数据队列*/
UINT8 gSheBeiType;
#endif
@@ -97,20 +94,20 @@ QueueStruct logPrintfQue; /*
/*
* 功能描述： 平台初始化
* 参数说明： void
* 返回值 ： NULL: 获取数据失败
* !NULL: 平台ATS到CI接口队列
* 返回值 ： 0: 失败
* 1: 成功
* Modified By LQ 2025.08.27
*/
UINT8 Initial2oo2Interface(void)
{
UINT8 rtn = 0u;
UINT16 locTypeId = 0;
UINT8 result = 0u;
UINT8 rtn = CI_ERROR;
UINT8 result = 0U;
/*定义平台数据队列指针*/
#ifdef PLATFORM_2OO2
rtn = CI_SUCCESS;
ProtocolToCiDataQueue = &gCbtcData.DataToApp; /*初始化协议到CI数据队列*/
CiToProtocolDataQueue = &gCbtcData.OutputDataQueue; /*初始化CI到协议数据队列*/
@@ -155,19 +152,20 @@ UINT8 Initial2oo2Interface(void)
CiToLEUDataQueue = CiToFsfbDataQueue; /*初始化CI到Leu数据队列*/
CiAndIoComState = &FSIOLinkStatusInfo; /*联锁与IO通信状态*/
locTypeId = MSCP_GetOutnetID();
/*LocalCiId = gSheBeiID;*/ /*联锁设备ID*/
PlatSheBeiType = &gSheBeiType; /*联锁设备类型*/
LocalCiId = (UINT8)(locTypeId & 0xFFu); /*联锁设备ID*/
gSheBeiType = (UINT8)((locTypeId >> 8u) & 0xFFu);
OcToCiDataQueue = NULL; /*初始化Oc到Ci的数据队列*/
CiToOcDataQueue = CiToProtocolDataQueue; /*初始化Ci到Oc的数据队列*/
if (CI_SUCCESS == rtn)
{
if (1U != QueueInitial(&logPrintfQue, 500000U)) /*初始化日志缓存队列*/
{
debug_infor_printf((const)"canQueueRecv init error \n");
rtn = CI_ERROR;
}
else
{
#if 0
/*联锁与LEU、ZC、CI等的通信状态描述*/
@@ -195,11 +193,21 @@ UINT8 Initial2oo2Interface(void)
result = HLHTCiIdMapInitial();
if (CI_SUCCESS == result)
{
rtn = 1;
rtn = CI_SUCCESS;
}
else
{
debug_infor_printf((const)"Initial2oo2Interface init error: HLHTCiIdMapInitial Error\n");
rtn = CI_ERROR; /*返回失败*/
}
}
}
else
{
rtn = CI_ERROR; /*返回失败*/
}
return rtn;
}
/*
@@ -504,7 +512,7 @@ QueueStruct* Get2oo2CiToPscDataQueue(void)
UINT32 Get2oo2CurCycleNum(void)
{
#if (kPLATFORM==kVXWORKS)
return MSCP_GetSysCount();
return MSCP_GetAreaSysCount();
#else
return *CurCycleNum;
#endif
TSCP/src/APP/ciapp/2oo2/2oo2InterfaceDataManage.h
+5 -2
View File
@@ -21,6 +21,7 @@
#include "CommonQueue.h"
#include "../Transmit/TransmitStateDataManage.h"
#include "MSCP_APP_API.h"
#ifdef PLATFORM_2OO2
#include "sfpplatform.h"
#include "RsspWl.h"
@@ -89,12 +90,14 @@ extern UINT8* CiAndCiComDeviceNum; /*
extern UINT8* CiAndCiComIdBuf; /*联锁与联锁通信设备ID*/
extern UINT8* CiAndCiComState; /*联锁与联锁通信状态*/
extern UINT8* PlatSheBeiType; /*平台对外设备类型*/
extern UINT8 gSheBeiType; /*对外的设备类型*/
/*
* 功能描述： 平台初始化
* 参数说明： void
* 返回值 ： NULL: 获取数据失败
* !NULL: 平台ATS到CI接口队列
* 返回值 ： 0: 失败
* 1: 成功
* Modified By LQ 2025.08.27
*/
UINT8 Initial2oo2Interface(void);
TSCP/src/APP/ciapp/AllAutoReturn/AllAutoReturnConfigDataManage.c
+21
View File
@@ -125,6 +125,27 @@ UINT8 GetAllAutoReturnRouteBelongCiId(const UINT16 allAutoReturnId)
return belongCiId;
}
/*
* 功能描述： 获取指定ID全自动折返所属虚拟联锁ID
* 参数说明： const UINT16 allAutoReturnId, 全自动折返ID
* 返回值 ： 0: 获取数据失败
* >0: 所属虚拟联锁ID
* add by mpt 20260107
*/
UINT8 GetAllAutoRetRoutBelongVirCiId(const UINT16 allAutoReturnId)
{
UINT16 bufIndex = 0u; /*数组下标*/
UINT8 belongVirCiId = CI_ERROR;
bufIndex = GetAllAutoReturnBufIndex(allAutoReturnId); /*获取全自动折返数组下标*/
if (bufIndex < ALL_AUTO_RETURN_SUM_MAX)
{
belongVirCiId = AllAutoReturnConfigDataStru[bufIndex].BelongVirCiId;
}
return belongVirCiId;
}
/*
* 功能描述： 获取指定ID全自动折返包含进路ID数组
TSCP/src/APP/ciapp/AllAutoReturn/AllAutoReturnConfigDataManage.h
+9
View File
@@ -34,6 +34,7 @@ typedef struct S_AllAutoReturnConfigDataStruct
{
UINT16 AllAutoReturnId; /*全自动折返ID (配置字段)*/
UINT8 BelongCiId; /*所属联锁ID*/
UINT8 BelongVirCiId; /*虚拟联锁ID*/
UINT8 RouteSum; /*全自动折返包含进路数目 (配置字段)*/
UINT16 RouteIdBuf[ALL_AUTO_RETURN_INCLROUTE_SUM_MAX]; /*全自动折返进路ID数组 (配置字段)*/
UINT16 RebackRouteIdBuf[ALL_AUTO_RETURN_REBACKROUTE_SUM_MAX]; /*全自动折返包含折出进路数组(配置字段)*/
@@ -92,6 +93,14 @@ UINT8 GetAllAutoReturnIncludeRouteSum(const UINT16 allAutoReturnId);
* >0: 所属联锁ID
*/
UINT8 GetAllAutoReturnRouteBelongCiId(const UINT16 allAutoReturnId);
/*
* 功能描述： 获取指定ID全自动折返所属虚拟联锁ID
* 参数说明： const UINT16 allAutoReturnId, 全自动折返ID
* 返回值 ： 0: 获取数据失败
* >0: 所属虚拟联锁ID
* add by mpt 20260107
*/
UINT8 GetAllAutoRetRoutBelongVirCiId(const UINT16 allAutoReturnId);
/*
* 功能描述： 获取指定ID全自动折返包含进路ID数组
TSCP/src/APP/ciapp/AllAutoReturn/AllAutoReturnDefine.h
+1 -1
View File
@@ -41,5 +41,5 @@
#define ALL_AUTO_RETURN_DICHU_COMMR ((UINT8)0x06) /*抵触的普通进路已办理*/
#define ALL_AUTO_RETURN_HAVE_BLOCK ((UINT8)0x02) /*全自动折返进路存在封锁*/
#define ALL_AUTO_RETURN_FLOOD_STATE_ERR ((UINT8)0x03) /*全自动折返进路存在防淹门不满足*/
#define ALL_AUTO_RETURN_COUPROUTE_SET ((UINT8)0x07) /*联挂进路已办理*/
#endif
TSCP/src/APP/ciapp/AutoReturn/AutoReturnConfigDataManage.c
+21
View File
@@ -119,6 +119,27 @@ UINT8 GetAutoReturnRouteBelongCiId(const UINT16 autoReturnId)
return returnValue;
}
/*
* 功能描述： 获取指定ID自动折返所属虚拟联锁ID
* 参数说明： const UINT16 autoReturnId, 自动折返ID
* 返回值 ： 0: 获取数据失败
* >0: 所属联锁ID
* add by mpt 20260107
*/
UINT8 GetAutoReturnRouteBelongVirCiId(const UINT16 autoReturnId)
{
UINT16 bufIndex = 0u; /*数组下标*/
UINT8 returnValue = CI_ERROR;
bufIndex = GetAutoReturnBufIndex(autoReturnId); /*获取自动折返数组下标*/
if (bufIndex < AUTO_RETURN_SUM_MAX)
{
returnValue = AutoReturnConfigDataStru[bufIndex].BelongVirCiId;
}
return returnValue;
}
/*
* 功能描述： 获取指定ID自动折返包含进路ID数组
TSCP/src/APP/ciapp/AutoReturn/AutoReturnConfigDataManage.h
+9
View File
@@ -34,6 +34,7 @@ typedef struct S_AutoReturnConfigDataStruct
{
UINT16 AutoReturnId; /*自动折返ID (配置字段)*/
UINT8 BelongCiId; /*所属联锁ID*/
UINT8 BelongVirCiId; /*所属虚拟联锁ID*/
UINT8 RouteSum; /*自动折返包含进路数目 (配置字段)*/
UINT16 RouteIdBuf[AUTO_RETURN_INCLROUTE_SUM_MAX]; /*自动折返进路包含进路ID数组 (配置字段)*/
UINT8 AutoReturnOpposedReturnIdSum; /*自动折返抵触自动折返进路数目 (配置字段)*/
@@ -88,6 +89,14 @@ UINT8 GetAutoReturnIncludeRouteSum(const UINT16 autoReturnId);
* >0: 所属联锁ID
*/
UINT8 GetAutoReturnRouteBelongCiId(const UINT16 autoReturnId);
/*
* 功能描述： 获取指定ID自动折返所属虚拟联锁ID
* 参数说明： const UINT16 autoReturnId, 自动折返ID
* 返回值 ： 0: 获取数据失败
* >0: 所属联锁ID
* add by mpt 20260107
*/
UINT8 GetAutoReturnRouteBelongVirCiId(const UINT16 autoReturnId);
/*
* 功能描述： 获取指定ID自动折返包含进路ID数组
TSCP/src/APP/ciapp/AutoReturn/AutoReturnDefine.h
+1 -1
View File
@@ -41,5 +41,5 @@
#define AUTO_RETURN_DICHU_COMMROUTE ((UINT8)0x06) /*抵触的普通进路已办理*/
#define AUTO_RETURN_HAVE_BLOCK ((UINT8)0x02) /*自动折返进路存在封锁*/
#define AUTO_RETURN_FLOOD_STATE_ERR ((UINT8)0x03) /*自动折返进路存在防淹门不满足*/
#define AUTO_RETURN_COUPROUTE_SET ((UINT8)0x07) /*联挂进路已办理*/
#endif
TSCP/src/APP/ciapp/AutoRoute/AutoRouteConfigDataManage.c
+20
View File
@@ -97,6 +97,26 @@ UINT8 GetAutoRouteBelongCiId(const UINT16 autoRouteId)
}
return belongCiId;
}
/*
* 功能描述： 获取指定ID自动进路所属虚拟联锁ID
* 参数说明： const UINT16 autoRouteId, 自动进路ID
* 返回值 ： 0: 获取数据失败
* >0: 所属联锁ID
* add by mpt 20260107
*/
UINT8 GetAutoRouteBelongVirCiId(const UINT16 autoRouteId)
{
UINT16 bufIndex = 0u; /*数组下标*/
UINT8 belongVirCiId = CI_ERROR;
bufIndex = GetAutoRouteBufIndex(autoRouteId); /*获取自动进路数组下标*/
if (bufIndex < AUTO_ROUTE_SUM_MAX)
{
belongVirCiId = AutoRouteConfigDataStru[bufIndex].BelongVirCiId;
}
return belongVirCiId;
}
/*
TSCP/src/APP/ciapp/AutoRoute/AutoRouteConfigDataManage.h
+8
View File
@@ -32,6 +32,7 @@ typedef struct S_AutoRouteConfigDataStruct
{
UINT16 AutoRouteId; /*自动进路ID (配置字段)*/
UINT8 BelongCiId; /*所属联锁ID*/
UINT8 BelongVirCiId; /*所属虚拟联锁ID*/
UINT8 RouteSum; /*自动进路包含进路数目 (配置字段)*/
UINT16 RouteIdBuf[AUTO_ROUTE_INCLROUTE_SUM_MAX]; /*自动进路进路ID数组 (配置字段)*/
UINT8 AutoRouteOpposedRouteIdSum; /*自动通过进路抵触自动通过进路数目 (配置字段)*/
@@ -89,6 +90,13 @@ UINT16 GetAutoRouteBufIndex(const UINT16 AutoRouteId);
* >0: 所属联锁ID
*/
UINT8 GetAutoRouteBelongCiId(const UINT16 autoRouteId);
/*
* 功能描述： 获取指定ID自动进路所属虚拟联锁ID
* 参数说明： const UINT16 autoRouteId, 自动进路ID
* 返回值 ： 0: 获取数据失败
* >0: 所属联锁ID
*/
UINT8 GetAutoRouteBelongVirCiId(const UINT16 autoRouteId);
/*
* 功能描述： 获取指定ID自动进路包含进路数目
TSCP/src/APP/ciapp/AutoRoute/AutoRouteDefine.h
+1 -1
View File
@@ -36,7 +36,7 @@
#define AUTO_ROUTE_DICHU_COMMROUTE ((UINT8)0x06) /*抵触普通进路已办理*/
#define AUTO_ROUTE_HAVE_BLOCK ((UINT8)0x02) /*自动进路存在封锁*/
#define AUTO_ROUTE_FLOOD_STATE_ERR ((UINT8)0x03) /*自动进路存在防淹门不满足*/
#define AUTO_ROUTE_COUPROUTE_SET ((UINT8)0x07) /*联挂进路已办理*/
#endif
TSCP/src/APP/ciapp/AxisAssert/AxisAssertDataPrepare.c
+4 -3
View File
@@ -87,14 +87,15 @@ UINT8 aam_PrepareACStatus(UINT16 ACID)
* @param[in] UINT16 ACID 基准计轴ID
* @param[in] UINT8 dir 查询方向
* @param[out] UINT16 arACID[AC_MAXCNT_IN_SWITCH] 相邻计轴ID
* @param[out] UINT8* DirectionPointFlag 是否有方向变化点 DIRECTIONPOINT_FLAG_VALID
* @return UINT8_MAX 查询失败
0~AC_MAXCNT_IN_SWITCH 查询成功
* @note 无
*/
UINT8 aam_PrepareAdjacentAC(UINT16 ACID, UINT8 dir, INOUT UINT16 arACID[AC_MAXCNT_IN_SWITCH], UINT8* DirectionPointFlag)
UINT8 aam_PrepareAdjacentAC(UINT16 ACID, UINT8 dir, INOUT UINT16 arACID[AC_MAXCNT_IN_SWITCH])
{
return elm_PrepareAdjacentAC(ACID, dir, arACID, DirectionPointFlag);
UINT8 cDirectionPointFlag = 0U; /*是否具有方向变化点标志*/
return elm_PrepareAdjacentAC(ACID, dir, arACID, &cDirectionPointFlag);
}
/**
TSCP/src/APP/ciapp/AxisAssert/AxisAssertDataPrepare.h
+1 -2
View File
@@ -89,12 +89,11 @@ UINT8 aam_PrepareACStatus(UINT16 ACID);
* @param[in] UINT16 ACID 基准计轴ID
* @param[in] UINT8 dir 查询方向
* @param[out] UINT16 arACID[AC_MAXCNT_IN_SWITCH] 相邻计轴ID
* @param[out] UINT8* DirectionPointFlag 是否有方向变化点 DIRECTIONPOINT_FLAG_VALID
* @return UINT8_MAX 查询失败
0~AC_MAXCNT_IN_SWITCH 查询成功
* @note 无
*/
UINT8 aam_PrepareAdjacentAC(UINT16 ACID, UINT8 dir, INOUT UINT16 arACID[AC_MAXCNT_IN_SWITCH], UINT8* DirectionPointFlag);
UINT8 aam_PrepareAdjacentAC(UINT16 ACID, UINT8 dir, INOUT UINT16 arACID[AC_MAXCNT_IN_SWITCH]);
/**
* @brief 通过计轴区段ID查找计轴区段位置
TSCP/src/APP/ciapp/AxisAssert/AxisAssertManage.c
-3
View File
@@ -182,12 +182,9 @@ UINT8 aam_SetAxisAssert(UINT16 acIndex,const AxisAsserStruct* pBuff)
*/
void aam_ResetAxisAssertByACIndex(UINT16 acIndex)
{
UINT8 chCanArbTag = 0U;/*保留Arb判断*/
if ((0U != acIndex) && (acIndex < AXIS_SECTION_SUM_MAX))
{
chCanArbTag = gs_AxisAssert[acIndex].redunOverCanArb;
(void)CommonMemSet(&gs_AxisAssert[acIndex], (UINT32)sizeof(AxisAsserStruct),0, (UINT32)sizeof(AxisAsserStruct));
gs_AxisAssert[acIndex].redunOverCanArb = chCanArbTag;
}
}
TSCP/src/APP/ciapp/AxisAssert/AxisAssertManageAPI.c
+38 -298
View File
@@ -319,15 +319,8 @@ static UINT8 aam_AxisErrorJudge(UINT16 acID,UINT16 acIndex)
UINT8 cAxisCommBadArbFlag = AAM_COMM_BAD_ARB_NO;
UINT8 chPhyTrainCheck = CI_SUCCESS;
UINT8 cAcCbtcAttr = 0U; /*计轴区段CBTC区域属性*/
UINT8 cAcRelEnvelopeCnt = 0U; /*计轴区段包络数量*/
UINT32 dwOccupyStartCyc = 0U;/*计轴占用起始周期号*/
UINT32 dwCurCyc = 0U;/*当前周期号*/
UINT8 DirectionPointSameSide = DIRECTIONPOINT_FLAG_INVALID;
UINT8 DirectionPointConvertSide = DIRECTIONPOINT_FLAG_INVALID;
EnvelopeStruct strEnvelopeInfo[SECTION_REL_ENVELOPE_SUM_MAX] = { 0U };
chSwitch = aam_PrepareArbSwitch();
dwCurCyc = Get2oo2CurCycleNum();
if (CI_SUCCESS == chSwitch)
{
;
@@ -344,10 +337,10 @@ static UINT8 aam_AxisErrorJudge(UINT16 acID,UINT16 acIndex)
else
{
/** 查询前方计轴*/
acSameCnt = aam_PrepareAdjacentAC(acID, EMAP_SAME_DIR, acSameID, &DirectionPointSameSide);
acSameCnt = aam_PrepareAdjacentAC(acID, EMAP_SAME_DIR, acSameID);
/** 查询后方计轴 */
acConvertCnt = aam_PrepareAdjacentAC(acID, EMAP_CONVER_DIR, acConvertID,&DirectionPointConvertSide);
acConvertCnt = aam_PrepareAdjacentAC(acID, EMAP_CONVER_DIR, acConvertID);
/** 获取区段由占用变空闲持续时间 */
maxRedunTimes = aam_PrepareRedunTimes();
@@ -364,24 +357,15 @@ static UINT8 aam_AxisErrorJudge(UINT16 acID,UINT16 acIndex)
ASSER_DEBUG(0u != errorCode, AAM_LOG(AAM_LOG_FATAL, "info:Clear AC%d RedunTime becasue pre/back error.\n", acID));
}
else
{
/*仅在待判断计轴当周期由空闲变占用时检查*/
dwOccupyStartCyc = GetAxisSecOccCyc(acID);
if (dwCurCyc == dwOccupyStartCyc)
{
/** 检查附近区段状态*/
chNearbyCheck = aam_CheckNearbyTrainType(acID);
}
else
{
chNearbyCheck = CI_SUCCESS;
}
/** 处理前方计轴车辆接近*/
sameTrainType = aam_CheckNearbyTrainEnvelopeType(acID, EMAP_SAME_DIR, acSameCnt, acSameID, DirectionPointSameSide);
sameTrainType = aam_SearchNearbyTrainType(acID, EMAP_SAME_DIR, acSameCnt, acSameID);
/** 处理后方计轴车辆接近 */
convertTrainType = aam_CheckNearbyTrainEnvelopeType(acID, EMAP_CONVER_DIR, acConvertCnt, acConvertID, DirectionPointConvertSide);
convertTrainType = aam_SearchNearbyTrainType(acID, EMAP_CONVER_DIR, acConvertCnt, acConvertID);
/*检查所属物理区段有无故障车*/
chPhyTrainCheck = aam_CheckPhyTrain(acID);
@@ -409,7 +393,9 @@ static UINT8 aam_AxisErrorJudge(UINT16 acID,UINT16 acIndex)
{
; /*继续处理*/
}
/** 判断相邻范围内计轴坏车最近占用时间检查通过 */
if ((CI_ERROR == chNearbyCheck))
{
/*有 坏车接近 或左右相邻计轴均无车接近 立即清除冗余计时*/
if ((AAM_BAD_NEAR == sameTrainType) || (AAM_BAD_NEAR == convertTrainType))
{
@@ -423,14 +409,15 @@ static UINT8 aam_AxisErrorJudge(UINT16 acID,UINT16 acIndex)
aam_SetAxisStatus(acIndex, AAM_STATUS_OCC);
AAM_LOG(AAM_LOG_FATAL, "info:AC%d not match ARB condition, NearByTrainCheck:%d.\n", acID, chNearbyCheck);
}
else if (CI_ERROR == chNearbyCheck)
else
{
/** 范围内坏车失败 UT冗余*/
/** 冗余计时位加1*/
aam_AddRedunTime(acIndex, maxRedunTimes);
/*置标志位*/
aam_SetAxisRedunCanArbFlag(acIndex, REDUN_OVER_ARB_NO);
}
}
else
{
/** 冗余计时位加1*/
@@ -448,11 +435,18 @@ static UINT8 aam_AxisErrorJudge(UINT16 acID,UINT16 acIndex)
{
if (AAM_STATUS_ARB == tmpACStatus)
{
/** 计轴已经ARB 不检查防护范围*/
cAcRelEnvelopeCnt = elm_GetEnvelopeInAC(acID, strEnvelopeInfo);
if ((0U < cAcRelEnvelopeCnt) && (SECTION_REL_ENVELOPE_SUM_MAX > cAcRelEnvelopeCnt))
/** 计轴已经ARB 检查防护范围 防护失败不应维持ARB*/
if (CI_ERROR == chNearbyCheck)
{
/*ARB区段存在包络，不进行ARB连续占用判断*/
/** 清除之前的冗余计时位 */
funRtn = aam_ClearPassTrainFlag(acIndex);
ASSER_ERROR(CI_ERROR == funRtn, errorCode, 0x20000000u);
funRtn = aam_ClearRedunTime(acIndex);
ASSER_ERROR(CI_ERROR == funRtn, errorCode, 0x10000000u);
aam_SetAxisStatus(acIndex, AAM_STATUS_OCC);
AAM_LOG(AAM_LOG_FATAL, "info:AC%d keep ARB Fail, NearByTrainCheck:%d.\n", acID, chNearbyCheck);
}
else
{
@@ -1565,7 +1559,7 @@ UINT8 aam_CheckNearbyTrainType(UINT16 ACID)
UINT8 retVal = CI_ERROR;
UINT8 phyAcNum = 0u;
UINT16* pACBuff = NULL;
UINT16 wBasePhyid = 0U;/*基准物理区段*/
UINT16 wBasePhyid = 0U;
UINT8 jj = 0U;
UINT8 ii = 0U;
UINT8 chKeepcheck = CI_SUCCESS; /*继续检查标志*/
@@ -1573,13 +1567,11 @@ UINT8 aam_CheckNearbyTrainType(UINT16 ACID)
UINT32 cyCheckUtCyc = 0U; /*检查周期数*/
UINT32 dwRecentUtCyc = 0U; /*最近坏车占用周期号*/
UINT16 wCheckPhySec = 0U; /*待检查区段*/
UINT16* pAdjacentPhyBuf = NULL; /*直接相连区段数组*/
UINT16* wAdjacentPhyBuf = NULL; /*直接相连区段数组*/
UINT8 chAdjacentPhyNum = 0U; /*直接相连区段数量*/
UINT8 chNearSecNum = 0U; /*间接相邻数量*/
UINT16* pNearSecBuf = NULL; /*间接相连区段数组*/
UINT8 chSwitchPosCheck = CI_ERROR;/*当前道岔检查结果*/
UINT8 chTransitAcNum = 0U; /*跳转计轴数量*/
UINT16* pTransitAcBuf = NULL; /*跳转计轴数组*/
UINT16* dwNearSecBuf = NULL; /*间接相连区段数组*/
cyCheckUtCyc = GetArbProtectCheckTime();
wBasePhyid = aam_PrepareACBelongPhyid(ACID);
@@ -1616,16 +1608,12 @@ UINT8 aam_CheckNearbyTrainType(UINT16 ACID)
{
/*Step2 :当前物理区段直接相邻物理区段所有计轴无坏车*/
chAdjacentPhyNum = GetAdjacentPhySecNum(wBasePhyid);
pAdjacentPhyBuf = GetAdjacentPhySecBuf(wBasePhyid);
if ((0U != chAdjacentPhyNum) && (NULL != pAdjacentPhyBuf))
wAdjacentPhyBuf = GetAdjacentPhySecBuf(wBasePhyid);
if ((0U != chAdjacentPhyNum) && (NULL != wAdjacentPhyBuf))
{
for (ii = 0; ii < chAdjacentPhyNum; ii++)
{
wCheckPhySec = pAdjacentPhyBuf[ii];
chSwitchPosCheck = GetAdjacentPhySecAcCheck(wBasePhyid, wCheckPhySec);
if (CI_SUCCESS == chSwitchPosCheck)
{
/* 邻近区段有坏车曾占用再取消，认为坏车接近*/
wCheckPhySec = wAdjacentPhyBuf[ii];
phyAcNum = GetPAxisSectionSum(wCheckPhySec);
pACBuff = GetPAxisSectionIdBuf(wCheckPhySec);
/*遍历计轴上最近坏车占用周期*/
@@ -1637,7 +1625,7 @@ UINT8 aam_CheckNearbyTrainType(UINT16 ACID)
chTimeFlag = SystemOverTimeCheck(dwRecentUtCyc, cyCheckUtCyc);
if (CI_TIME_IN == chTimeFlag)
{
/*还在时间范围内*/
/*还在时间范围内 认为坏车接近*/
chKeepcheck = CI_ERROR;
retVal = CI_ERROR;
debug_infor_printf((const)"ACid: %d , ArbNearSecCheck fail step2, PhySec = %d\n", ACID, wCheckPhySec);
@@ -1650,12 +1638,6 @@ UINT8 aam_CheckNearbyTrainType(UINT16 ACID)
chKeepcheck = CI_ERROR;
}
}
else
{
;/*不处理*/
debug_infor_printf((const)"ACid: %d ,AdjacentSec Skip PhySec = %d\n", ACID, wCheckPhySec);
}
}
}
else
{
@@ -1667,28 +1649,10 @@ UINT8 aam_CheckNearbyTrainType(UINT16 ACID)
{
/*Step3 :当前物理区段间接相邻物理区段所有计轴无坏车*/
chNearSecNum = GetNearPhySecNum(wBasePhyid);
pNearSecBuf = GetIndirectNearPhySecBuf(wBasePhyid);
dwNearSecBuf = GetIndirectNearPhySecBuf(wBasePhyid);
for (ii = 0; ii < chNearSecNum; ii++)
{
wCheckPhySec = pNearSecBuf[ii];
chTransitAcNum = GetPhySecNearSecTransitAcNum(wBasePhyid, wCheckPhySec);
pTransitAcBuf = GetPhySecNearSecTransitAcBuf(wBasePhyid, wCheckPhySec);
chSwitchPosCheck = CI_ERROR;
if (NULL != pTransitAcBuf)
{
for (jj = 0; jj < chTransitAcNum; jj++)
{
chSwitchPosCheck = GetTransitPhySecAcCheck(wBasePhyid, pTransitAcBuf[jj]);
if (CI_SUCCESS == chSwitchPosCheck)
{
break;
}
}
}
if (CI_SUCCESS == chSwitchPosCheck)
{
/* 邻近可达区段有坏车曾占用再取消，认为坏车接近*/
wCheckPhySec = dwNearSecBuf[ii];
phyAcNum = GetPAxisSectionSum(wCheckPhySec);
pACBuff = GetPAxisSectionIdBuf(wCheckPhySec);
/*遍历计轴上最近坏车占用周期*/
@@ -1713,16 +1677,6 @@ UINT8 aam_CheckNearbyTrainType(UINT16 ACID)
chKeepcheck = CI_ERROR;
}
}
else
{
;/*不可达状态 坏车占用不影响*/
debug_infor_printf((const)"ACid: %d ,NearSec Skip PhySec = %d\n", ACID, wCheckPhySec);
}
if (CI_SUCCESS != chKeepcheck)
{
break;
}
}
}
if (CI_SUCCESS == chKeepcheck)
{
@@ -2157,18 +2111,16 @@ UINT8 aam_ArbContinuousOccCheck(UINT16 wAcId, UINT8 cNearAcNum, UINT16 pNearAcId
UINT8 cRetVal = CI_ERROR;
UINT16 wBufIndex = 0U;
UINT16 wCurRelPhySecId = 0U; /*本计轴区段所属物理区段ID*/
UINT32 dwCiAndAxleTransBadEnsureCnt = 0U; /*判断与计轴通信中断周期数*/
UINT8 dwCiAndAxleTransBadEnsureCnt = 0U; /*判断与计轴通信中断周期数*/
UINT32 dwCurAxleOccStartCycNum = 0U; /*本计轴区段占用起始周期*/
UINT8 ii = 0U;
UINT16 wNearRelPhySecId = 0U; /*相邻计轴区段所属物理区段ID*/
UINT8 cAcRelEnvelopeCnt = 0U; /*计轴区段包络数量*/
UINT8 cAcRelEnvelopeCnt = 0U;
EnvelopeStruct strEnvelopeInfo[SECTION_REL_ENVELOPE_SUM_MAX] = { 0U };
UINT32 dwNearAxleOccStartCycNum = 0U; /*相邻计轴区段占用起始周期*/
UINT8 cRcId = 0U;
UINT8 cFunRtn = 0U;
UINT16 wNearAcIndex = 0U;
UINT8 cPhySecPreOccState = 0U; /*区段上周期占用状态*/
UINT8 cAxisSecTXSafeLocFlag = 0U; /*计轴区段列车安全位置覆盖标志*/
wBufIndex = GetAxisSecConfigBufIndex(wAcId); /*获取区段数组下标*/
@@ -2185,18 +2137,12 @@ UINT8 aam_ArbContinuousOccCheck(UINT16 wAcId, UINT8 cNearAcNum, UINT16 pNearAcId
wNearRelPhySecId = GetAxisSecRelativePhySecId(pNearAcId[ii]);
if (0U != wNearRelPhySecId)
{
cAcRelEnvelopeCnt = elm_GetEnvelopeInAC(pNearAcId[ii], strEnvelopeInfo); /*获取相邻计轴区段的包络信息*/
dwNearAxleOccStartCycNum = GetSecColOccupyStartCycNum(wNearRelPhySecId); /*获取相邻计轴区段采集占用起始周期*/
cPhySecPreOccState = GetPhySecPreOccupyState(wNearRelPhySecId); /*获取相邻计轴区段上周期采集占用状态*/
cAxisSecTXSafeLocFlag =GetAxisTXSafeLocFlag(pNearAcId[ii]); /*获取相邻计轴区段列车安全位置覆盖标志*/
cAcRelEnvelopeCnt = elm_GetEnvelopeInAC(pNearAcId[ii], strEnvelopeInfo);
dwNearAxleOccStartCycNum = GetSecColOccupyStartCycNum(wNearRelPhySecId);
if (((0U == cAcRelEnvelopeCnt) || (SECTION_REL_ENVELOPE_SUM_MAX == cAcRelEnvelopeCnt))
&& ((dwCurAxleOccStartCycNum + dwCiAndAxleTransBadEnsureCnt) < dwNearAxleOccStartCycNum)
&& (SECTION_OCCUPY_NO == cPhySecPreOccState)
&& (AXIS_SECTION_SAFELOC_YES != cAxisSecTXSafeLocFlag))
&& ((dwCurAxleOccStartCycNum + dwCiAndAxleTransBadEnsureCnt) < dwNearAxleOccStartCycNum))
{
/*相邻计轴区段无包络&&占用起始时间超过了“与计轴通信中断超时判断时间”&&相邻计轴区段上周期采集为空闲&&相邻计轴区段无列车安全位置覆盖*/
cRetVal = CI_ERROR;
cRetVal = CI_ERROR; /*相邻计轴区段无包络且占用起始时间超过了“与计轴通信中断超时判断时间”*/
cFunRtn = aam_PrepareACIsSelf(pNearAcId[ii], &cRcId); /*判断相邻区段是否为本控区区段*/
@@ -2216,7 +2162,7 @@ UINT8 aam_ArbContinuousOccCheck(UINT16 wAcId, UINT8 cNearAcNum, UINT16 pNearAcId
}
else
{
/*继续检查*/
/*相邻计轴区段占用起始周期未超过“与计轴通信中断超时判断时间”，继续检查*/
}
}
else
@@ -2237,209 +2183,3 @@ UINT8 aam_ArbContinuousOccCheck(UINT16 wAcId, UINT8 cNearAcNum, UINT16 pNearAcId
return cRetVal;
}
/**
* 功能：查询计轴区段邻近范围内包络类型
* @param[in] UINT16 ACID 基准计轴ID
* @param[in] UINT8 dir 查询方向
* @param[in] UINT16 arACID[AC_MAXCNT_IN_SWITCH] 相邻计轴ID
* @param[in] UINT8 DirectionPointFlag 是否有方向变化点 DIRECTIONPOINT_FLAG_VALID
* 返回值：
AAM_NO_TRAIN_NEAR 无车接近
AAM_BAD_NEAR 坏车
AAM_GOOD_OCC 好车占用
AAM_SLEEP_OCC 休眠车
AAM_GOOD_FAR_AWAY 好车远离
AAM_GOOD_NEAR 好车接近
* Create: fan 2026/04/11
*/
UINT8 aam_CheckNearbyTrainEnvelopeType(UINT16 baseACID, UINT8 Dir, UINT8 acCnt, UINT16 acID[AC_MAXCNT_IN_SWITCH], UINT8 DirectionPointFlag)
{
UINT8 chAdjacentTrainType = AAM_BAD_NEAR;
UINT8 chFirstStepTrainType = AAM_BAD_NEAR;
UINT8 chSndStepTrainType = AAM_BAD_NEAR;
UINT8 ii = 0U;
UINT8 jj = 0U;
UINT8 kk = 0U;
UINT8 chRetTrainType = AAM_BAD_NEAR;
UINT16 wTempAcList[AC_MAXCNT_IN_SWITCH] = { 0U };
UINT8 chFirstStepAcCnt = 0U;
UINT16 wFirstStepID[AC_MAXCNT_IN_SWITCH] = { 0U };
UINT8 chSndStepAcCnt = 0U;
UINT16 wSndStepID[AC_MAXCNT_IN_SWITCH] = { 0U };
UINT32 dwArbProtectLen = 0U;/*ARB防护距离*/
UINT16 wArbProtectDis = GetSystemParaValue(ARB_CHECK_ALXE_SEC_LEN);
UINT32 dwCheckAcLen = 0U; /*找到计轴长度*/
UINT32 dwTempAcLen = 0U; /*计轴长度*/
UINT8 chChangePoitFlag = DIRECTIONPOINT_FLAG_INVALID;
UINT8 chTemp = 0U;
UINT8 chChangePoitCnt = 0U;
UINT8 chFirstDir = Dir;
UINT8 chSndDir = Dir;
UINT8 chLocalId = 0U;/*本联锁ID*/
UINT8 chAcBelongCi = 0U;
UINT8 chRelEnvelopeCnt = 0u;
UINT16 envelopeIds[SECTION_REL_ENVELOPE_SUM_MAX] = { 0u };
EnvelopeStruct* pTempEnvelope = NULL;/*包络信息*/
UINT8 chUseNvram = 0U;
dwArbProtectLen = (UINT32)(wArbProtectDis * 100U);
chLocalId = GetSystemParaLocalCiId();
if (0U == acCnt)
{
/*失败返回MAX 尽头线为0*/
chRetTrainType = AAM_NO_TRAIN_NEAR;
}
else if(AC_MAXCNT_IN_SWITCH >= acCnt)
{
for (ii = 0U; ii < acCnt; ii++)
{
wTempAcList[0] = acID[ii];
dwCheckAcLen = GetAxisSecTotalLen(acID[ii]);
chAdjacentTrainType = aam_SearchNearbyTrainType(baseACID, Dir, 1U, wTempAcList);
chAcBelongCi = GetAxisSectionBelongCiId(acID[ii]);
if (chAcBelongCi == chLocalId)
{
/*额外检查属于本联锁的直接相邻区段 无NVRAM车 */
chRelEnvelopeCnt = elm_GetEnvelopeIDsInAC(acID[ii], envelopeIds);
if (0u != chRelEnvelopeCnt)
{
for (jj = 0u; jj < chRelEnvelopeCnt; jj++)
{
pTempEnvelope = elm_GetEnvelopeInfoByID(envelopeIds[jj]);
for (kk = 0u; kk < pTempEnvelope->trianCnt; kk++)
{
chUseNvram = GetTrainNvramPosFlag(pTempEnvelope->trainID[kk]);
if (TRAIN_NVRAM_POS_FLAG_NO != chUseNvram)
{
chAdjacentTrainType = AAM_BAD_NEAR;
break;
}
}
}
}
}
/** 根据列车包络数量进行处理 */
if ((0U == ii) || (AAM_BAD_NEAR == chAdjacentTrainType))
{
chRetTrainType = chAdjacentTrainType;/*记录第一个结果 或更新为最坏结果*/
}
if ((AAM_NO_TRAIN_NEAR == chAdjacentTrainType) && (dwArbProtectLen > dwCheckAcLen))
{
/*路径无车 继续查找*/
chFirstDir = TransDirectionPointDir(DirectionPointFlag, Dir, &chChangePoitCnt);
chFirstStepAcCnt = aam_PrepareAdjacentAC(acID[ii], chFirstDir, wFirstStepID, &chChangePoitFlag);
if (UINT8_MAX != chFirstStepAcCnt)
{
for (jj = 0U; jj < chFirstStepAcCnt; jj++)
{
wTempAcList[0] = wFirstStepID[jj];
chFirstStepTrainType = aam_SearchNearbyTrainType(acID[ii], chFirstDir, 1U, wTempAcList);
dwTempAcLen = GetAxisSecTotalLen(wFirstStepID[jj]);
if ((AAM_NO_TRAIN_NEAR == chFirstStepTrainType) && (dwArbProtectLen >(dwCheckAcLen + dwTempAcLen)))
{
/*路径无车 继续查找*/
chSndDir = TransDirectionPointDir(chChangePoitFlag, chFirstDir, &chChangePoitCnt);
chSndStepAcCnt = aam_PrepareAdjacentAC(wFirstStepID[jj], chSndDir, wSndStepID, &chTemp);
if (UINT8_MAX != chSndStepAcCnt)
{
for (kk = 0U; kk < chSndStepAcCnt; kk++)
{
wTempAcList[0] = wSndStepID[kk];
chSndStepTrainType = aam_SearchNearbyTrainType(wFirstStepID[jj], chSndDir, 1U, wTempAcList);
/*更新最坏结果*/
chFirstStepTrainType = GetWorseNearbyTrainType(chFirstStepTrainType, chSndStepTrainType);
if (AAM_BAD_NEAR == chFirstStepTrainType)
{
/*可以停止遍历其他计轴*/
break;
}
}
}
else
{
/*异常防护*/
chFirstStepTrainType = AAM_BAD_NEAR;
break;
}
}
else
{
;/*停止当前路线*/
}
/*更新最坏结果*/
chAdjacentTrainType = GetWorseNearbyTrainType(chAdjacentTrainType, chFirstStepTrainType);
if (AAM_BAD_NEAR == chAdjacentTrainType)
{
/*可以停止遍历其他计轴*/
break;
}
}
}
else
{
/*异常防护*/
chAdjacentTrainType = AAM_BAD_NEAR;
break;
}
}
else
{
;/*停止当前路线*/
}
/*更新最坏结果*/
chRetTrainType = GetWorseNearbyTrainType(chRetTrainType, chAdjacentTrainType);
if (AAM_BAD_NEAR == chRetTrainType)
{
/*可以停止遍历其他计轴*/
break;
}
}
}
else
{
;/*返回坏车*/
}
return chRetTrainType;
}
/**
* 功能：更新路线上更有风险的结果
* 输入参数：UINT8 chPreType当前记录类型 UINT8 chAfterType比较的更新列车类型
* 返回值：
AAM_NO_TRAIN_NEAR 无车接近
AAM_BAD_NEAR 坏车
AAM_GOOD_OCC 好车占用
AAM_SLEEP_OCC 休眠车
AAM_GOOD_FAR_AWAY 好车远离
AAM_GOOD_NEAR 好车接近
* Create: fan 2026/04/11
*/
UINT8 GetWorseNearbyTrainType(UINT8 chPreType, UINT8 chAfterType)
{
/*定义结果严重程度： 坏车接近>休眠车>好车占用>其他>无车*/
UINT8 chRetval = AAM_BAD_NEAR;
if ((AAM_BAD_NEAR == chPreType)||(AAM_BAD_NEAR == chAfterType))
{
chRetval = AAM_BAD_NEAR;
}
else if ((AAM_SLEEP_OCC == chPreType) || (AAM_SLEEP_OCC == chAfterType))
{
chRetval = AAM_SLEEP_OCC;
}
else if ((AAM_GOOD_OCC == chPreType) || (AAM_GOOD_OCC == chAfterType))
{
chRetval = AAM_GOOD_OCC;
}
else if(AAM_NO_TRAIN_NEAR == chPreType)
{
chRetval = chAfterType;
}
else
{
chRetval = chPreType;
}
return chRetval;
}
TSCP/src/APP/ciapp/AxisAssert/AxisAssertManageAPI.h
-32
View File
@@ -233,36 +233,4 @@ UINT8 aam_CheckPhyTrain(UINT16 ACID);
*/
UINT8 aam_ArbContinuousOccCheck(UINT16 wAcId, UINT8 cNearAcNum, UINT16 pNearAcId[AC_MAXCNT_IN_SWITCH]);
/**
* 功能：查询计轴区段邻近范围内包络类型
* 输入参数：UINT16 ACID 计轴区段
* @param[in] UINT16 ACID 基准计轴ID
* @param[in] UINT8 dir 查询方向
* @param[in] UINT16 arACID[AC_MAXCNT_IN_SWITCH] 相邻计轴ID
* @param[in] UINT8 DirectionPointFlag 是否有方向变化点 DIRECTIONPOINT_FLAG_VALID
AAM_NO_TRAIN_NEAR 无车接近
AAM_BAD_NEAR 坏车
AAM_GOOD_OCC 好车占用
AAM_SLEEP_OCC 休眠车
AAM_GOOD_FAR_AWAY 好车远离
AAM_GOOD_NEAR 好车接近
* Create: fan 2026/04/11
*/
UINT8 aam_CheckNearbyTrainEnvelopeType(UINT16 baseACID, UINT8 Dir, UINT8 acCnt, UINT16 acID[AC_MAXCNT_IN_SWITCH], UINT8 DirectionPointFlag);
/**
* 功能：更新路线上更有风险的列车类型结果
* 输入参数：UINT8 chPreType当前记录类型 UINT8 chAfterType比较的更新列车类型
* 返回值：
AAM_NO_TRAIN_NEAR 无车接近
AAM_BAD_NEAR 坏车
AAM_GOOD_OCC 好车占用
AAM_SLEEP_OCC 休眠车
AAM_GOOD_FAR_AWAY 好车远离
AAM_GOOD_NEAR 好车接近
* Create: fan 2026/04/11
*/
UINT8 GetWorseNearbyTrainType(UINT8 chPreType, UINT8 chAfterType);
#endif /*AXIS_ASSERT_MANAGE_API_H_*/
TSCP/src/APP/ciapp/AxisSort/AxisSort.c
+5 -44
View File
@@ -16,7 +16,7 @@
static UINT16 g_pSortLinkNum; /* 本控区的Link数量 */
static UINT16 g_pSortLinkIndex[AS_LINK_MAX + 1U]; /* 本控区的Link索引 */
AS_SORT_INFO_s g_pSortLinkInfo[AS_LINK_MAX + 1U]; /*link排序*/
static AS_SORT_INFO_s g_pSortLinkInfo[AS_LINK_MAX + 1U]; /*link排序*/
/* 通信车序列，在SortCT阶段完成CT车排序 */
static UINT16 s_pCTSortIndex[SIZE_MAX_LINE_TRAIN_NUM]; /*本信息不周期清空*/
@@ -2188,34 +2188,12 @@ UINT32 as_GetTransferData(OUT UINT8 * pDataBuff, IN UINT32 curIndex)
{
UINT32 ret = curIndex;
UINT32 copyIndex = curIndex;
UINT16 wLinkNum = 0U;
UINT16 u16Index = 0U;
UINT16 wTmpLinkId = 0U;
UINT8 chLocalId = GetSystemParaLocalCiId();
UINT8 chLinkCIId = 0U;/*link所属联锁*/
UINT32 dwLinkNumIndex =0U;/*数量位置 */
if (NULL != pDataBuff)
{
(void)CommonMemCpy(&pDataBuff[copyIndex], (UINT32)(sizeof(UINT16) * SIZE_MAX_LINE_TRAIN_NUM), s_pCTSortIndex, (UINT32)(sizeof(UINT16) * SIZE_MAX_LINE_TRAIN_NUM));
copyIndex += (UINT32)(sizeof(UINT16) * SIZE_MAX_LINE_TRAIN_NUM);
(void)CommonMemCpy(&pDataBuff[copyIndex], (UINT32)(sizeof(CT_SORT_INFO_s) * (SIZE_MAX_COM_VOBC_NUM + 1U)), s_pCTSortInfo, (UINT32)(sizeof(CT_SORT_INFO_s) * (SIZE_MAX_COM_VOBC_NUM + 1U)));
copyIndex += (UINT32)(sizeof(CT_SORT_INFO_s) * (SIZE_MAX_COM_VOBC_NUM + 1U));
/*拷贝link列车排序*/
dwLinkNumIndex = copyIndex;
copyIndex += 2U;
for (u16Index = 1U; u16Index <= g_pSortLinkNum; u16Index++)
{
wTmpLinkId = g_pSortLinkInfo[u16Index].u16ID;
chLinkCIId = (UINT8)GetLinkManageTiocById(wTmpLinkId);
if ((0U != chLocalId) && (chLinkCIId == chLocalId))
{
/*仅拷贝本联锁*/
(void)CommonMemCpy(&pDataBuff[copyIndex],(UINT32)(sizeof(AS_SORT_INFO_s)), &g_pSortLinkInfo[u16Index], (UINT32)(sizeof(AS_SORT_INFO_s)));
copyIndex += (UINT32)(sizeof(AS_SORT_INFO_s));
wLinkNum++;
}
}
ShortToChar(wLinkNum, &pDataBuff[dwLinkNumIndex]); /* 写入有车占用的计轴区段数量 */
(void)CommonMemCpy(&pDataBuff[copyIndex], (UINT32)(sizeof(CT_SORT_INFO_s) * SIZE_MAX_COM_VOBC_NUM + 1u), s_pCTSortInfo, (UINT32)(sizeof(CT_SORT_INFO_s) * SIZE_MAX_COM_VOBC_NUM + 1u));
copyIndex += (UINT32)(sizeof(CT_SORT_INFO_s) * SIZE_MAX_COM_VOBC_NUM + 1u);
ret = copyIndex;
}
else
@@ -2237,29 +2215,12 @@ UINT32 as_SetTransferData(IN UINT8 * pDataBuff, IN UINT32 curIndex)
{
UINT32 ret = curIndex;
UINT32 copyIndex = curIndex;
UINT16 wLinkNum = 0U;
UINT16 jj = 0U;
UINT16 wTmpLinkId =0U;
UINT16 wLinkIndex = 0U;
if (NULL != pDataBuff)
{
(void)CommonMemCpy(s_pCTSortIndex, (UINT32)(sizeof(UINT16) * SIZE_MAX_LINE_TRAIN_NUM), &pDataBuff[copyIndex], (UINT32)(sizeof(UINT16) * SIZE_MAX_LINE_TRAIN_NUM));
copyIndex += (UINT32)(sizeof(UINT16) * SIZE_MAX_LINE_TRAIN_NUM);
(void)CommonMemCpy(s_pCTSortInfo, (UINT32)(sizeof(CT_SORT_INFO_s) * (SIZE_MAX_COM_VOBC_NUM + 1U)), &pDataBuff[copyIndex], (UINT32)(sizeof(CT_SORT_INFO_s) * (SIZE_MAX_COM_VOBC_NUM + 1U)));
copyIndex += (UINT32)(sizeof(CT_SORT_INFO_s) * (SIZE_MAX_COM_VOBC_NUM + 1U));
/*拷贝列车排序*/
wLinkNum = ShortFromChar(&pDataBuff[copyIndex]);
copyIndex += 2u;
for (jj = 0U; jj < wLinkNum; jj++)
{
wTmpLinkId = ShortFromCharLE(&pDataBuff[copyIndex]);
wLinkIndex = g_pSortLinkIndex[wTmpLinkId];
if ((DEFAULT_ZERO < wLinkIndex) && (wLinkIndex < AS_LINK_MAX+1U))
{
(void)CommonMemCpy(&g_pSortLinkInfo[wLinkIndex], (UINT32)(sizeof(AS_SORT_INFO_s)), &pDataBuff[copyIndex], (UINT32)(sizeof(AS_SORT_INFO_s)));
copyIndex += (UINT32)(sizeof(AS_SORT_INFO_s));
}
}
(void)CommonMemCpy(s_pCTSortInfo, (UINT32)(sizeof(CT_SORT_INFO_s) * SIZE_MAX_COM_VOBC_NUM + 1u), &pDataBuff[copyIndex], (UINT32)(sizeof(CT_SORT_INFO_s) * SIZE_MAX_COM_VOBC_NUM + 1u));
copyIndex += (UINT32)(sizeof(CT_SORT_INFO_s) * SIZE_MAX_COM_VOBC_NUM + 1u);
ret = copyIndex;
}
else
TSCP/src/APP/ciapp/AxisSort/AxisSort.h
+1 -1
View File
@@ -48,5 +48,5 @@ typedef struct
UINT16 TrainEnveLopeID[ENVELOPE_SUM_MAX]; /*所有包络ID信息*/
}s_TRAIN_ENVELOPE_ID;
extern AS_SORT_INFO_s g_pSortLinkInfo[AS_LINK_MAX + 1U]; /*link排序*/
#endif /* INC_AXIS_SORT_INC */
TSCP/src/APP/ciapp/CutoffPoint/CutoffPointDataManage.c
+55 -242
View File
@@ -667,74 +667,35 @@ void SetCfpOtherOcEData(const UINT16 wCfpId, const UINT8 chEnvelopeIndex, const
* @param wCfpId 分界点ID
* @return 无
* @note 内部优化 20220419 wqm 编码规范：函数dsuCheckSameLoc返回值需要变量承接
* @note 内部优化 20260413 相邻联锁发送按照分界点计轴向内方计算一个ARB防护距离
*/
void SetCfpLocalOcEData(const UINT16 wCfpId)
{
UINT16 wIndex = 0u;
UINT8 chEnvelopeNum = 0u;
UINT16 wLinkId = 0u;
UINT16 tmpACCnt = 0U;
UINT16 tmpAcIdBuf[AC_MAXCNT_IN_SWITCH] = { 0U };
UINT16 wAcId = 0u;
UINT8 chEnvelopeIndex = 0u;
EnvelopeStruct szTmpEnvelope[SECTION_REL_ENVELOPE_SUM_MAX] = { 0u };
UINT8 chLocalId = 0u;
UINT16 wLinkTioc = 0u;
UINT16 wArbProtectDis = GetSystemParaValue(ARB_CHECK_ALXE_SEC_LEN);
UINT32 dwCheckAcLen = 0U; /*找到计轴长度*/
UINT32 dwFirstStepAcLen = 0U; /*找到计轴长度*/
UINT32 dwArbProtectLen = 0U;/*ARB防护距离*/
UINT8 chLocalCiType = 0U;
UINT8 chDir = 0U; /*分界点计轴方向*/
UINT8 chFirstStepAcCnt = 0U;
UINT16 wFirstStepID[AC_MAXCNT_IN_SWITCH] = { 0U };
UINT8 chSndStepAcCnt = 0U;
UINT16 wSndStepID[AC_MAXCNT_IN_SWITCH] = { 0U };
UINT8 chChangePoint = 0U;
UINT8 ii = 0U;
UINT8 jj = 0U;
UINT8 chCfpAcIndex = 0U;
UINT8 chStepCheck = CI_ERROR;
UINT8 chNextDir = 0U;
UINT8 chPointNum = 0u;
UINT8 chAcBelongTioc = 0U;
UINT8 chFail = CI_SUCCESS;
wIndex = GetCfpBufIndex(wCfpId);
chLocalId = GetSystemParaLocalCiId();
dwArbProtectLen = (UINT32)(wArbProtectDis * 100U);
chLocalCiType = GetLocalCiType();
/* 输入合法 */
if (CUTOFF_POINT_SUM_MAX > wIndex)
{
wLinkId = GetCfpInFirstLink(wCfpId);
/*清除脏数据*/
g_CutoffPointDataBuf[wIndex].chLocalTiocEnvelopeNum = 0U;
(void)CommonMemSet(&g_CutoffPointDataBuf[wIndex].szLocalEnvelope, (UINT32)((OTHER_RC_SEND_ENVELOPE_SUM_MAX)*sizeof(CfpEnvelopeStruct)), 0U, (UINT32)((OTHER_RC_SEND_ENVELOPE_SUM_MAX)*sizeof(CfpEnvelopeStruct)));
chStepCheck = GetAxisSeqFromLinkSeq(&wLinkId, 1u, tmpAcIdBuf, &tmpACCnt, AC_MAXCNT_IN_SWITCH);
chDir = GetCfpLocDir(wCfpId);
if ((CI_SUCCESS == chStepCheck) && (0u != tmpACCnt))
{
for (chCfpAcIndex = 0U; chCfpAcIndex < tmpACCnt; chCfpAcIndex++)
{
chEnvelopeNum = elm_GetEnvelopeInAC(tmpAcIdBuf[chCfpAcIndex], szTmpEnvelope);
chFail = CI_SUCCESS;
wAcId = GetLinkBelongAcId(wLinkId);
chEnvelopeNum = elm_GetEnvelopeInAC(wAcId, szTmpEnvelope);
if (SECTION_REL_ENVELOPE_SUM_MAX == chEnvelopeNum)
{
/*查找失败 添加坏车包络*/
chEnvelopeNum = 1U;
(void)elm_CreatTempUKTEnvelope(tmpAcIdBuf[chCfpAcIndex], chDir, &szTmpEnvelope[0]);
;
}
/*将包络信息添加到分界点动态数据 */
g_CutoffPointDataBuf[wIndex].chLocalTiocEnvelopeNum += chEnvelopeNum;
for (chEnvelopeIndex = 0U; chEnvelopeIndex < chEnvelopeNum; chEnvelopeIndex++)
else
{/* 将包络信息添加到分界点动态数据 */
g_CutoffPointDataBuf[wIndex].chLocalTiocEnvelopeNum = chEnvelopeNum;
for (chEnvelopeIndex = 0u; chEnvelopeIndex < chEnvelopeNum; chEnvelopeIndex++)
{
chStepCheck = CutCfpOtherOcEData(tmpAcIdBuf[chCfpAcIndex], &szTmpEnvelope[chEnvelopeIndex], chDir);
if (CI_ERROR == chStepCheck)
{
/*截取失败设置坏车*/
(void)elm_CreatTempUKTEnvelope(tmpAcIdBuf[chCfpAcIndex], chDir, &szTmpEnvelope[chEnvelopeIndex]);
}
g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].envelopeType = szTmpEnvelope[chEnvelopeIndex].envelopeType;
g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].headTrainID = szTmpEnvelope[chEnvelopeIndex].headTrainID;
g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].tailTrainID = szTmpEnvelope[chEnvelopeIndex].tailTrainID;
@@ -764,108 +725,7 @@ void SetCfpLocalOcEData(const UINT16 wCfpId)
(void)CommonMemCpy(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].ACTPort, (UINT32)sizeof(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].ACTPort), \
szTmpEnvelope[chEnvelopeIndex].ACTPort, (UINT32)sizeof(szTmpEnvelope[chEnvelopeIndex].ACTPort));
}
if (0U == chEnvelopeNum)
{
/*分界点无包络计轴 向本联锁内方继续查找*/
chStepCheck = GetAcSwitchPosCheck(tmpAcIdBuf[chCfpAcIndex]);/*本计轴道岔位置不满足时停止检查*/
dwCheckAcLen = GetAxisSecTotalLen(tmpAcIdBuf[chCfpAcIndex]);
if ((dwArbProtectLen > dwCheckAcLen) && (CI_TYPE_CLD != chLocalCiType)&&(CI_SUCCESS == chStepCheck))
{
chFirstStepAcCnt = elm_PrepareAdjacentAC(tmpAcIdBuf[chCfpAcIndex], chDir, wFirstStepID, &chChangePoint);
if (AC_MAXCNT_IN_SWITCH < chFirstStepAcCnt)
{
chFail = CI_ERROR;
(void)elm_CreatTempUKTEnvelope(tmpAcIdBuf[chCfpAcIndex], chDir, &szTmpEnvelope[0]);
(void)CutCfpOtherOcEData(tmpAcIdBuf[chCfpAcIndex], &szTmpEnvelope[0], chDir);
}
else
{
for (ii = 0U; ii < chFirstStepAcCnt; ii++)
{
chAcBelongTioc = GetAxisSectionBelongCiId(tmpAcIdBuf[chCfpAcIndex]);
if (chAcBelongTioc == chLocalId)
{
chStepCheck = SetCfpLocalArbDistanceData(wFirstStepID[ii], wCfpId, chDir);
dwFirstStepAcLen = GetAxisSecTotalLen(wFirstStepID[ii]);
if ((dwArbProtectLen > (dwCheckAcLen + dwFirstStepAcLen)) && (CI_SUCCESS == chStepCheck))
{
chNextDir = TransDirectionPointDir(chChangePoint, chDir, &chPointNum);
chSndStepAcCnt = elm_PrepareAdjacentAC(wFirstStepID[ii], chNextDir, wSndStepID, &chChangePoint);
if (AC_MAXCNT_IN_SWITCH < chFirstStepAcCnt)
{
chFail = CI_ERROR;
(void)elm_CreatTempUKTEnvelope(wFirstStepID[ii], chNextDir, &szTmpEnvelope[0]);
(void)CutCfpOtherOcEData(wFirstStepID[ii], &szTmpEnvelope[0], chNextDir);
}
else
{
for (jj = 0U; jj < chSndStepAcCnt; jj++)
{
chAcBelongTioc = GetAxisSectionBelongCiId(tmpAcIdBuf[chCfpAcIndex]);
if (chAcBelongTioc == chLocalId)
{
(void)SetCfpLocalArbDistanceData(wSndStepID[jj], wCfpId, chNextDir);
}
/*不继续添加*/
}
}
}
else
{
;/*不查找下一计轴*/
}
}
}
}
if (CI_ERROR == chFail)
{
/* 异常防护 生成UKT*/
chEnvelopeIndex = g_CutoffPointDataBuf[wIndex].chLocalTiocEnvelopeNum;
g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].envelopeType = szTmpEnvelope[0].envelopeType;
g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].headTrainID = szTmpEnvelope[0].headTrainID;
g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].tailTrainID = szTmpEnvelope[0].tailTrainID;
g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].startPos = szTmpEnvelope[0].startPos;
wLinkTioc = GetLinkManageTiocById(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].startPos.Lnk);
/* 内部优化 20220419 wqm 编码规范：函数dsuCheckSameLoc返回值需要变量承接*/
if (wLinkTioc != chLocalId)
{
(void)dsuCheckSameLoc(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].startPos.Lnk, \
g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].startPos.Off, \
&g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].startPos.Lnk, \
&g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].startPos.Off);
}
g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].endPos = szTmpEnvelope[0].endPos;
wLinkTioc = GetLinkManageTiocById(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].endPos.Lnk);
if (wLinkTioc != chLocalId)
{
(void)dsuCheckSameLoc(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].endPos.Lnk, \
g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].endPos.Off, \
&g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].endPos.Lnk, \
&g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].endPos.Off);
}
g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].trianCnt = szTmpEnvelope[0].trianCnt;
(void)CommonMemCpy(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].trainID, (UINT32)sizeof(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].trainID), \
szTmpEnvelope[0].trainID, (UINT32)sizeof(szTmpEnvelope[0].trainID));
(void)CommonMemCpy(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].ACTPort, (UINT32)sizeof(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[chEnvelopeIndex].ACTPort), \
szTmpEnvelope[0].ACTPort, (UINT32)sizeof(szTmpEnvelope[0].ACTPort));
g_CutoffPointDataBuf[wIndex].chLocalTiocEnvelopeNum++;
}
}
}
else
{
;/*找到列车包络 不再查找该计轴后续方向*/
}
}
}
else
{
}
}
else
{
@@ -879,7 +739,7 @@ void SetCfpLocalOcEData(const UINT16 wCfpId)
* @param CfpEnvelopeStruct szEnvelope 包络数据
* @return 包络数量
*/
UINT8 GetOtherOcEnvelope(const UINT16 wOtherOc, CfpEnvelopeStruct szEnvelope[OTHER_RC_SEND_ENVELOPE_SUM_MAX * ONE_OTHER_CFP_SUM_MAX])
UINT8 GetOtherOcEnvelope(const UINT16 wOtherOc, CfpEnvelopeStruct szEnvelope[SECTION_REL_ENVELOPE_SUM_MAX * ONE_OTHER_CFP_SUM_MAX])
{
UINT16 wCfpIndex = 0u;
UINT16 wCfpId = 0u;
@@ -932,6 +792,7 @@ void SetCfpLocalOcCtData(const UINT16 wCfpId)
UINT8 chSendNum = 0u;
UINT8 chFunRtn = CI_ERROR;
struct_PathPoint strPoint = { 0u };
UINT8 dir = 0u;
wIndex = GetCfpBufIndex(wCfpId);
/* 输入合法 */
@@ -952,7 +813,9 @@ void SetCfpLocalOcCtData(const UINT16 wCfpId)
g_CutoffPointDataBuf[wIndex].szLocalCtTrain[chSendNum].dwDelay = GetTrainMsgDelayTime(szCtTrainId[chCtIndex]);
g_CutoffPointDataBuf[wIndex].szLocalCtTrain[chSendNum].wSpeed = GetTrainSpeed(szCtTrainId[chCtIndex]);
g_CutoffPointDataBuf[wIndex].szLocalCtTrain[chSendNum].chSpeedDir = GetTrainSpeedDir(szCtTrainId[chCtIndex]);
g_CutoffPointDataBuf[wIndex].szLocalCtTrain[chSendNum].chTrainDir = GetTrainDir(szCtTrainId[chCtIndex]);
dir = GetTrainDir(szCtTrainId[chCtIndex]); /*获取列车的逻辑方向*/
g_CutoffPointDataBuf[wIndex].szLocalCtTrain[chSendNum].chTrainDir = ConvertDirectionToLogic(dir); /*将逻辑方向转换为运营方向*/
g_CutoffPointDataBuf[wIndex].szLocalCtTrain[chSendNum].wMaxHeadLink = GetTrainMaxHeadLink(szCtTrainId[chCtIndex]);
g_CutoffPointDataBuf[wIndex].szLocalCtTrain[chSendNum].dwMaxHeadOff = GetTrainMaxHeadOffset(szCtTrainId[chCtIndex]);
g_CutoffPointDataBuf[wIndex].szLocalCtTrain[chSendNum].wMinHeadLink = GetTrainMinHeadLink(szCtTrainId[chCtIndex]);
@@ -1020,16 +883,22 @@ UINT8 GetCfpLocalOcCtNum(const UINT16 wCfpId)
/**
* @brief 截取分界点相邻OC发来的包络数据
* @param wAcId 截取计轴ID UINT8 chDir 方向
* @param EnvelopeStruct* strEnvelope 包络数据
* @param wCfpId 分界点ID
* @param CfpEnvelopeStruct* strEnvelope 包络数据
* @return CI_ ERROR 截取失败
* CI_ SUCCESS 截取成功
* by cgh 20240111
* modify fan20260413：按照计轴进行包络截取
*/
UINT8 CutCfpOtherOcEData(const UINT16 wAcId, EnvelopeStruct* strEnvelope, UINT8 chDir)
UINT8 CutCfpOtherOcEData(const UINT16 wCfpId, CfpEnvelopeStruct* strEnvelope)
{
UINT8 chReval = CI_ERROR;
UINT8 chLocalCiId = 0U;/*本地联锁ID*/
UINT16 wLinkTioc = 0U;/*LINK所属联锁ID*/
UINT16 wCfpLinkId = 0U;/*分界点LINK ID*/
UINT32 dwCfpLinkOffset = 0U;/*分界点LINK偏移量*/
UINT16 wCfpSameLocLinkId = 0U;/*分界点同位点LINK ID*/
UINT32 dwCfpSameLocLinkOffset = 0U;/*分界点同位点LINK偏移量*/
UINT16 wLinkBelongAxieId = 0U;/*LINK所属计轴区段ID*/
UINT8 chAxieIncLinkSum = 0U;/*计轴区段包含LINK数目*/
UINT16* szAxieIncLink = NULL;/*计轴区段包含LINK*/
UINT8 ii = 0U;
@@ -1038,14 +907,35 @@ UINT8 CutCfpOtherOcEData(const UINT16 wAcId, EnvelopeStruct* strEnvelope, UINT8
UINT8 chEnvelopeEndFlag = 0U;/*包络终端是否在计轴区段标志*/
ELM_AxisLocStruct tmpAxieSecLoc = { 0U };/*计轴区段位置*/
if (AXIS_SECTION_SUM_MAX > wAcId)
if (CUTOFF_POINT_SUM_MAX > wCfpId)
{
/*只截取UCT包络*/
if ((TYPE_UCT_ENVELOPE == strEnvelope->envelopeType) || (TYPE_CT_ENVELOPE == strEnvelope->envelopeType))
{
chAxieIncLinkSum = GetAxisLinkSum(wAcId);
szAxieIncLink = GetAxisLinkIdBuf(wAcId);
chKeepFlag = elm_PrepareACLoc(wAcId, chDir, &tmpAxieSecLoc);
chLocalCiId = GetSystemParaLocalCiId();
wCfpLinkId = GetCfpLink(wCfpId);
dwCfpLinkOffset = GetCfpOffset(wCfpId);
wLinkTioc = GetLinkManageTiocById(wCfpLinkId);
if (chLocalCiId == wLinkTioc)
{
/*分界点数据配置的位置为本联锁，需要转换为相邻联锁的同位点*/
chKeepFlag = dsuCheckSameLoc(wCfpLinkId, dwCfpLinkOffset, &wCfpSameLocLinkId, &dwCfpSameLocLinkOffset);
}
else
{
/*分界点LINK属于相邻联锁，此时使用分界点对应的LINK数据*/
chKeepFlag = CI_SUCCESS;
wCfpSameLocLinkId = wCfpLinkId;
dwCfpSameLocLinkOffset = dwCfpLinkOffset;
}
if (CI_SUCCESS == chKeepFlag)
{
wLinkBelongAxieId = GetLinkBelongAcId(wCfpSameLocLinkId);
chAxieIncLinkSum = GetAxisLinkSum(wLinkBelongAxieId);
szAxieIncLink = GetAxisLinkIdBuf(wLinkBelongAxieId);
chKeepFlag = elm_PrepareACLoc(wLinkBelongAxieId, ELM_DIR_SAME, &tmpAxieSecLoc);
if (CI_SUCCESS == chKeepFlag)
{
@@ -1125,6 +1015,11 @@ UINT8 CutCfpOtherOcEData(const UINT16 wAcId, EnvelopeStruct* strEnvelope, UINT8
}
}
else
{
; /*返回失败*/
}
}
else
{
/*其他包络类型不截取，保留原数据*/
chReval = CI_SUCCESS;
@@ -1737,7 +1632,7 @@ void OtherCfpTrainInfoCal(UINT16 wLinkId,UINT32 dwOffSet,UINT32 dwLocalOffSet, C
{
chLinkTiocId = (UINT8)GetLinkManageTiocById(wLinkId);
strCfpInfo = GetCfpOtherOcTrainInfo(wCfpId);
chTransmitStat = GetCiTransmitState(CI_SYSTEM_TYPE_CI, chLinkTiocId);
chTransmitStat = GetRcPbTacsTransmitState(chLinkTiocId);
if ((TRANSMIT_STATE_GOOD != chTransmitStat) || (UINT16_MAX == strCfpInfo.wTrainId))
{
;/*通信不良好，或者分界点列车信息获取失败*/
@@ -1837,85 +1732,3 @@ void CfpTrainInfoCal(UINT16 wLinkId, UINT32 dwOffSet, UINT32 dwLocalOffSet, CfpT
}
}
}
/**
* @brief 根据分界点内方计轴向内查找ARB防护距离内可达计轴上包络
* 输入参数： wAcId 本联锁分界点计轴 wCfpId分界点 UINT8 chDir 方向
* 返回值： CI_SUCCESS(计轴无包络 需继续查找) CI_ERROR（计轴存在包络）
* Create fanwen 2026.4.13
**/
UINT8 SetCfpLocalArbDistanceData(const UINT16 wAcId, const UINT16 wCfpId,UINT8 chDir)
{
UINT8 retVal = CI_ERROR;
UINT8 chEnvelopeNum = 0U;
EnvelopeStruct szTmpEnvelope[SECTION_REL_ENVELOPE_SUM_MAX] = { 0u };
UINT16 wIndex = GetCfpBufIndex(wCfpId);
UINT8 ii = 0u;/*索引*/
UINT8 chLocalId = 0u;
UINT16 wLinkTioc = 0u;
UINT8 chCurNum = 0U;
UINT8 chStepCheck = CI_ERROR;
chLocalId = GetSystemParaLocalCiId();
chEnvelopeNum = elm_GetEnvelopeInAC(wAcId, szTmpEnvelope);
chCurNum = g_CutoffPointDataBuf[wIndex].chLocalTiocEnvelopeNum;
if (SECTION_REL_ENVELOPE_SUM_MAX == chEnvelopeNum)
{
/*查找失败 添加坏车包络*/
chEnvelopeNum = 1U;
(void)elm_CreatTempUKTEnvelope(wAcId, chDir, &szTmpEnvelope[0]);
}
if (0U != chEnvelopeNum)
{
if (OTHER_RC_SEND_ENVELOPE_SUM_MAX > chCurNum + chEnvelopeNum)
{
/* 将包络信息添加到分界点动态数据 */
g_CutoffPointDataBuf[wIndex].chLocalTiocEnvelopeNum = chCurNum + chEnvelopeNum;
for (ii = 0U; ii < chEnvelopeNum; ii ++)
{
/*仅截取本计轴*/
chStepCheck = CutCfpOtherOcEData(wAcId, &szTmpEnvelope[ii], chDir);
if (CI_ERROR == chStepCheck)
{
/*截取失败设置坏车*/
(void)elm_CreatTempUKTEnvelope(wAcId, chDir, &szTmpEnvelope[ii]);
}
g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].envelopeType = szTmpEnvelope[ii].envelopeType;
g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].headTrainID = szTmpEnvelope[ii].headTrainID;
g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].tailTrainID = szTmpEnvelope[ii].tailTrainID;
g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].startPos = szTmpEnvelope[ii].startPos;
wLinkTioc = GetLinkManageTiocById(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].startPos.Lnk);
/* 内部优化 20220419 wqm 编码规范：函数dsuCheckSameLoc返回值需要变量承接*/
if (wLinkTioc != (UINT16)chLocalId)
{
(void)dsuCheckSameLoc(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].startPos.Lnk, \
g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].startPos.Off, \
&g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].startPos.Lnk, \
&g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].startPos.Off);
}
g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].endPos = szTmpEnvelope[ii].endPos;
wLinkTioc = GetLinkManageTiocById(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].endPos.Lnk);
if (wLinkTioc != (UINT16)chLocalId)
{
(void)dsuCheckSameLoc(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].endPos.Lnk, \
g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].endPos.Off, \
&g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].endPos.Lnk, \
&g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].endPos.Off);
}
g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].trianCnt = szTmpEnvelope[ii].trianCnt;
(void)CommonMemCpy(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].trainID, (UINT32)sizeof(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].trainID), \
szTmpEnvelope[ii].trainID, (UINT32)sizeof(szTmpEnvelope[ii].trainID));
(void)CommonMemCpy(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].ACTPort, (UINT32)sizeof(g_CutoffPointDataBuf[wIndex].szLocalEnvelope[ii + chCurNum].ACTPort), \
szTmpEnvelope[ii].ACTPort, (UINT32)sizeof(szTmpEnvelope[ii].ACTPort));
}
}
else
{
;
}
}
else
{
retVal = CI_SUCCESS;/*对应计轴无包络*/
}
return retVal;
}
TSCP/src/APP/ciapp/CutoffPoint/CutoffPointDataManage.h
+6 -14
View File
@@ -65,9 +65,9 @@ typedef struct
CfpTrainInfoStru otherTiocTrainInfo; /* 接收到的其他联锁的列车信息 */
CfpTrainInfoStru localTiocTrainInfo; /* 待发送到其他联锁的列车信息 */
UINT8 chLocalTiocEnvelopeNum; /* 待发送到其他联锁的包络数量 */
CfpEnvelopeStruct szLocalEnvelope[OTHER_RC_SEND_ENVELOPE_SUM_MAX]; /* 待发送到其他联锁的包络数量 */
CfpEnvelopeStruct szLocalEnvelope[SECTION_REL_ENVELOPE_SUM_MAX]; /* 待发送到其他联锁的包络数量 */
UINT8 chOtherTiocEnvelopeNum; /* 接收到的其他联锁的包络数量 */
CfpEnvelopeStruct szOtherEnvelope[OTHER_RC_SEND_ENVELOPE_SUM_MAX]; /* 接收到的其他联锁的包络信息 */
CfpEnvelopeStruct szOtherEnvelope[SECTION_REL_ENVELOPE_SUM_MAX]; /* 接收到的其他联锁的包络信息 */
UINT8 chCtNum; /* 分界点通信车数量 */
CfpCtTrainStruct szLocalCtTrain[TRAIN_SUM_MAX]; /* 分界点通信车信息 */
CfpRRMDataStruct szCfpRRMData; /* 分界点远程RM数据*/
@@ -179,7 +179,7 @@ void SetCfpLocalOcEData(const UINT16 wCfpId);
* @param CfpEnvelopeStruct szEnvelope 包络数据
* @return 包络数量
*/
UINT8 GetOtherOcEnvelope(const UINT16 wOtherOc, CfpEnvelopeStruct szEnvelope[OTHER_RC_SEND_ENVELOPE_SUM_MAX * ONE_OTHER_CFP_SUM_MAX]);
UINT8 GetOtherOcEnvelope(const UINT16 wOtherOc, CfpEnvelopeStruct szEnvelope[SECTION_REL_ENVELOPE_SUM_MAX * ONE_OTHER_CFP_SUM_MAX]);
/*
* 功能描述： 获取边界点数据存储地址
@@ -212,13 +212,13 @@ UINT8 GetCfpLocalOcCtNum(const UINT16 wCfpId);
/**
* @brief 截取分界点相邻OC发来的包络数据
* @param wAcId 截取计轴ID
* @param EnvelopeStruct* strEnvelope 包络数据 chDir方向
* @param wCfpId 分界点ID
* @param CfpEnvelopeStruct* strEnvelope 包络数据
* @return CI_ ERROR 截取失败
* CI_ SUCCESS 截取成功
* by cgh 20240111
*/
UINT8 CutCfpOtherOcEData(const UINT16 wAcId, EnvelopeStruct* strEnvelope, UINT8 chDir);
UINT8 CutCfpOtherOcEData(const UINT16 wCfpId,CfpEnvelopeStruct* strEnvelope);
/**
* @brief 获取分界点跨控区RRM源RC ID
@@ -367,14 +367,6 @@ void OtherCfpTrainInfoCal(UINT16 wLinkId, UINT32 dwOffSet, UINT32 dwLocalOffSet,
*/
void CfpTrainInfoCal(UINT16 wLinkId, UINT32 dwOffSet, UINT32 dwLocalOffSet, CfpTrainInfoStru* trainInfo, UINT8 cDir);
/**
* @brief 根据分界点内方计轴向内查找ARB防护距离内可达计轴上包络
* 输入参数： wAcId 本联锁分界点计轴 wCfpId分界点 UINT8 chDir 方向
* 返回值： CI_SUCCESS(计轴无包络 需继续查找) CI_ERROR（计轴存在包络）
* Create fanwen 2026.4.13
**/
UINT8 SetCfpLocalArbDistanceData(const UINT16 wAcId, const UINT16 wCfpId, UINT8 chDir);
#ifdef __cplusplus
}
#endif
TSCP/src/APP/ciapp/DataManage/DeviceConfigDataManage.c
+33 -5
View File
@@ -43,6 +43,7 @@ UINT8 GetCiEmapCheckVer(const UINT8 ciId, UINT32 *emapVer,const UINT8 commDevTyp
switch (commDevType)
{/*根据通信设备类型获取CI与该通信设备的共用数据校验信息*/
case CI_SYSTEM_TYPE_VOBC:
case CI_SYSTEM_TYPE_IVOC:
case CI_SYSTEM_TYPE_ITE:
*emapVer = gEmapCiConfigStrus[ciId].dataVerCheckCIAndVOBC; /*ITE使用与VOBC相同的校验信息*/
break;
@@ -57,7 +58,7 @@ UINT8 GetCiEmapCheckVer(const UINT8 ciId, UINT32 *emapVer,const UINT8 commDevTyp
*emapVer = gEmapCiConfigStrus[ciId].dataVerCheckCIAndTMC;
break;
default:
/*CI_SYSTEM_TYPE_CI等情况*/
/*CI_SYSTEM_TYPE_RCI等情况*/
break;
}
@@ -111,8 +112,8 @@ UINT8 IsSameLineCI(const UINT8 ciA, const UINT8 ciB)
UINT8 dquDevNameA = CI_ERROR;
UINT8 dquDevNameB = CI_ERROR;
u16CiA = (UINT16)((CI_SYSTEM_TYPE_CI * 256u) + ciA);
u16CiB = (UINT16)((CI_SYSTEM_TYPE_CI * 256u) + ciB);
u16CiA = (UINT16)((CI_SYSTEM_TYPE_RCI * 256u) + ciA);
u16CiB = (UINT16)((CI_SYSTEM_TYPE_RCI * 256u) + ciB);
cbtcSysType = GetCbtcSysType();
@@ -202,10 +203,14 @@ UINT32 GetCiTranCiDataCheckVer(const UINT8 ciId, const UINT16 deviceName)
UINT32 retDataVer = CI_ERROR;
UINT8 ii = 0U;
UINT8 chBreakFlag = 0U;
if ((ciId > 0U) && (ciId < CI_SUM_MAX) && (deviceName > 0U))
UINT8 chDevType = 0U;
chDevType = (UINT8)((deviceName & 0xFF00) >> 8U);
if ((ciId > 0U) && (ciId < CI_SUM_MAX) &&
((RC_WORK_MODE_CI == chDevType)||(RC_WORK_MODE_TIOC == chDevType)))
{
if (gEmapCiConfigStrus[ciId].devId == ciId)
{
if (RC_WORK_MODE_CI == chDevType)
{
for (ii = 0U; ii < gEmapCiConfigStrus[ciId].chAdjoinCICount; ii++)
{
@@ -227,6 +232,29 @@ UINT32 GetCiTranCiDataCheckVer(const UINT8 ciId, const UINT16 deviceName)
}
}
}
else
{
for (ii = 0U; ii < gEmapCiConfigStrus[ciId].chAdjoinRCCount; ii++)
{
if (ii < CI_TRAINSMIT_CI_MAX_NUM)
{
if ((deviceName == gEmapCiConfigStrus[ciId].wAdjoinRCId[ii]) && (gEmapCiConfigStrus[ciId].wAdjoinRCId[ii] > 0U) && (gEmapCiConfigStrus[ciId].wAdjoinRCId[ii] < 0xFFFFU))
{
retDataVer = gEmapCiConfigStrus[ciId].dwAdjoinRCShareCheckData[ii];
chBreakFlag = 1U;
}
}
else
{
chBreakFlag = 1U;
}
if (1U == chBreakFlag)
{
break;
}
}
}
}
}
return retDataVer;
}
TSCP/src/APP/ciapp/DataManage/DeviceConfigDataManage.h
+4
View File
@@ -36,11 +36,15 @@ typedef struct S_EmapCheckVerConfigStruct
UINT8 chAdjoinCICount; /*相邻CI数量*/
UINT16 wAdjoinCIId[CI_TRAINSMIT_CI_MAX_NUM]; /*相邻CI[1-6]的ID*/
UINT32 dwAdjoinCIShareCheckData[CI_TRAINSMIT_CI_MAX_NUM]; /*与相邻CI[1-6]的共用数据校验信息*/
UINT8 chAdjoinRCCount; /*相邻RC数量*/
UINT16 wAdjoinRCId[CI_TRAINSMIT_CI_MAX_NUM]; /*相邻RC[1-6]的ID*/
UINT32 dwAdjoinRCShareCheckData[CI_TRAINSMIT_CI_MAX_NUM]; /*与相邻RC[1-6]的共用数据校验信息*/
UINT16 ciTransmitAxisId[CI_TRAINSMIT_AXIS_MAX_NUM];/*与联锁通信的计轴系统ID*/
UINT32 ciTransmitAxisCheckData[CI_TRAINSMIT_AXIS_MAX_NUM];/*与联锁通信的计轴系统校验信息*/
UINT8 chAdjoinOcCount; /*与CI通信的oc数量*/
UINT16 wAdjoinOcId[CI_TRAINSMIT_OC_MAX_NUM]; /*Oc[1-10]的ID*/
UINT32 dwAdjoinOcShareCheckData[CI_TRAINSMIT_OC_MAX_NUM]; /*与OC[1-10]的共用数据校验信息*/
UINT32 dwLocalShareCheckData; /*与本控区RC/CI校验信息*/
} EmapCiConfigStru;
extern EmapCiConfigStru gEmapCiConfigStrus[CI_SUM_MAX];/*存储各CI使用的电子地图版本*/
TSCP/src/APP/ciapp/DataManage/DeviceDataManage.c
+284 -251
View File
@@ -21,7 +21,6 @@
#include "dquCIInterFace.h"
#include "LogicalRouteDataManage.h"
#include "../LogicProcess/LogicalRouteLogicCheck.h"
#include "InterlockLogicCheck.h"
UINT8 AllSignalBrightFlag = CI_ALL_SIGNAL_BRIGHT_NO; /*全站亮灯标志*/
@@ -47,6 +46,8 @@ UINT8 g_AllTsrFlag = CI_ALL_TSR_UNVALID; /*
UINT8 g_AllSnowModel = CI_ALL_SNOW_UNVALID; /*全线雨雪模式命令：0x55-有效；0xAA-无效*/
UINT8 g_AllSnowModelCC = CI_ALL_SNOW_UNVALID; /*全线雨雪模式命令CC：0x55-有效；0xAA-无效*/
UINT8 g_AllSnowLevel = CI_SNOW_LEVEL_DEFAULT; /*全线湿轨级别：0-默认值；1-一级；2-二级*/
UINT8 g_IteLineCutState = CI_ITE_LINE_CUT_DEFAULT; /*ITE全线切除状态：0x55：切除ITE；0xAA：使用ITE；0xFF：默认值*/
@@ -87,11 +88,15 @@ CtrlPowerStruct ctrlpowerFlag[VIRTUAL_CI_MAX] = { 0u };
UINT8 LocalAreaSnowNum = 0U; /*本地区间雨雪站台数量*/
AreaSnowInfoStruct szLocalAreaSnow[LOCAL_AREA_SNOW_SUM_MAX] = { 0U }; /*本地区间雨雪数组*/
UINT8 gLocalAreaSnowNumCC = 0U; /*本地区间雨雪站台数量CC*/
AreaSnowInfoStruct gszLocalAreaSnowCC[LOCAL_AREA_SNOW_SUM_MAX] = { 0U }; /*本地区间雨雪数组CC*/
LineCommTrainStruct gStrLineCommTrain = { 0U }; /*全线通信车结构体*/
UINT32 gFlyProtectOverCyc = 0U; /*飞车宕机报警起始周期*/
UINT8 g_LocalSnowModel = CI_LOCAL_SNOW_UNVALID; /*本地雨雪模式命令*/
UINT8 g_LocalSnowModelCC = CI_LOCAL_SNOW_UNVALID; /*本地雨雪模式命令CC*/
UINT8 gLocalAreaIteCutNum = 0U; /*本地区间ITE切除数量*/
UINT16 gSzLocalAreaIteCutId[ALL_AREA_SNOW_SUM_MAX] = { 0U }; /*本地区间ITE切除ID数组——需要存储ZC发送的所有区间ID*/
@@ -211,46 +216,6 @@ UINT8 GetLabourCancelLinShiXianState(void)
return LabourCancelLinShiXianState;
}
/*
功能描述：人工取消临时限速状态迁移处理
参数说明：setFlag 状态
返回值：无
*/
void LabourCancelLSXianStaMoveProc(UINT8 setFlag)
{
UINT8 linShiXianState = 0u;
UINT8 wholelinShiXianState = 0u;
linShiXianState = GetLabourCancelLinShiXianState();
wholelinShiXianState = GetWholeLineLinShiXianSuFlag();
switch(setFlag)
{
case LINSHIXIANSU_COMM_GOOD_STATE:/*与ZC通信正常状态*/
if((LINSHIXIANSU_COMM_BAD_STATE == linShiXianState) ||
(LINSHIXIANSU_LABOURCANCLE_YES_STATE == linShiXianState))
{/*前一状态为： 通信故障且未进行人工取消 || 通信故障且进行了人工取消 则进行状态迁移*/
LabourCancelLinShiXianState = setFlag;
}
break;
case LINSHIXIANSU_COMM_BAD_STATE:/*与ZC通信故障状态*/
if((LINSHIXIANSU_COMM_GOOD_STATE == linShiXianState) && (WHOLE_LINE_LINSHIXIANSUSET_YES == wholelinShiXianState))
{/*前一状态为：通信正常状态且临时限速标志为设置 则进行状态迁移*/
LabourCancelLinShiXianState = setFlag;
}
break;
case LINSHIXIANSU_LABOURCANCLE_YES_STATE:/*已经进行了人工取消临时限速*/
if(LINSHIXIANSU_COMM_BAD_STATE == linShiXianState)
{/*前一状态为：通信故障状态 则进行状态迁移*/
LabourCancelLinShiXianState = setFlag;
}
break;
default:
/*不可达分支*/
break;
}
}
/*
功能描述：人工取消临时限速状态迁移处理
参数说明：setFlag 状态,UINT8 virCIid 虚拟联锁ID
@@ -1263,10 +1228,18 @@ void RouteDrvInnerSwitch(const UINT16 routeId, const UINT8 DrivFlag)
switchId = pRouteProtectSwitchStru[ii].ProtectSwitchId;
chSwitchBelCiId = GetSwitchBelongCiId(switchId);
if ((chLocalCiId == chSwitchBelCiId) && (0U != chLocalCiId))
{
funRtn = CheckSwitchPosAndMoveValid(pRouteProtectSwitchStru[ii].ProtectSwitchId, pRouteProtectSwitchStru[ii].ProtectPosition, ESEND_LEVEL_ZERO);
if (CI_ERROR == funRtn)
{
/*不可动防护道岔不进行驱动，已在锁闭条件中通过二级侧防进行防护*/
}
else
{
switchExpPos = pRouteProtectSwitchStru[ii].ProtectPosition;
(void)SwitchDriveProcess(switchId, switchExpPos); /*设置进路关联防护道岔的驱动状态为驱动中*/
}
}
else
{
;
@@ -1697,10 +1670,10 @@ void DriveSignalOpen(const UINT16 signalId, const UINT16 routeId)
UINT8 bCiSwitchShowGreenYellow = FUNC_SWITCH_OFF;/*ci显示绿黄开关,默认是关闭的*/
UINT8 belongVirCI= 0u;
UINT8 includeVirFlag= GetCiFunctionSwitchConfig(FUNC_INCLUDEVIRCI_FLAG);
UINT8 sigalMaintainState = 0u;
UINT8 signalIsfushiFlag = 0u;
UINT8 signalCurDriveColor = 0u;
UINT8 chRoutelightFlag = 0U;
routeLevel = GetRouteLevel(routeId); /*获取进路级别*/
if(ROUTE_LEVEL_BLOC == routeLevel)
@@ -1790,19 +1763,24 @@ void DriveSignalOpen(const UINT16 signalId, const UINT16 routeId)
}
/*虚拟联锁兼容*/
if(FUNC_SWITCH_ON == includeVirFlag)
{
belongVirCI = GetSignalBelongVirCiId(signalId);
allSignalBrightFlag = GetVirCIAllSignalBrightState(belongVirCI);/*本虚拟联锁全站亮灯标志*/
}
else
{
allSignalBrightFlag = GetAllSignalBrightFlag(); /*全站亮灯标志*/
}
lightExtinctState = GetSignalLightExtinctState(signalId);/*信号机亮灭状态*/
sigalMaintainState = GetSignalMaintainState(signalId);/*信号机维修点灯状态*/
chRoutelightFlag = GetSignalShineBit2(signalId);
if (SIGNAL_LIGHT_CONFIG_CBTC_LIGHT_BIT2 == chRoutelightFlag)
{
lightExtinctState = SIGNAL_LIGHT_EXTICT_STATE_YES;
}
else
{
/*数据配置常亮，CBTC接近时灭灯，驱动亮灯；配置其他依据亮灭灯状态*/
}
signalIsfushiFlag = GetSignalIsfushiFlag(signalId);
signalCurDriveColor = GetSignalCurDriveColor(signalId);
if ((SIGNAL_DRIVECOLOUR_NULL == signalCurDriveColor)&&(SIGNALTYPE_FUSHI_YES != signalIsfushiFlag))/*驱开放增加是否复示防护逻辑，避免数据配错导致的异常情况*/
@@ -2062,7 +2040,6 @@ UINT8 DriveSignalClose(const UINT16 signalId)
UINT8 belongVirCIid = 0u;
UINT8 detainOpenRedBright = 0u;
UINT8 signalDetainFlag = 0u;
UINT8 includeVirFlag= GetCiFunctionSwitchConfig(FUNC_INCLUDEVIRCI_FLAG);
UINT8 sigalMaintainState = 0u;
UINT8 signalIsfushiFlag = 0u;
UINT16 wSigInFirstPhyId = 0U;
@@ -2070,22 +2047,18 @@ UINT8 DriveSignalClose(const UINT16 signalId)
UINT8 routeLeadProperty = 0U;
UINT8 routeState = 0U;
UINT16 wStartSignalId = 0u;
UINT8 chRoutelightFlag = 0U;
if ((0u == signalId) || (signalId >= SIGNAL_SUM_MAX))
{
reVal = CI_ERROR;
}
else
{
/*虚拟联锁兼容*/
if(FUNC_SWITCH_ON == includeVirFlag)
{
belongVirCIid = GetSignalBelongVirCiId(signalId);
allSignalBrightFlag = GetVirCIAllSignalBrightState(belongVirCIid); /*全站亮灯标志*/
}
else
{
allSignalBrightFlag = GetAllSignalBrightFlag(); /*全站亮灯标志*/
}
/*无论什么时候，复示信号机关闭都驱动红灭*/
signalIsfushiFlag = GetSignalIsfushiFlag(signalId);
if (SIGNALTYPE_FUSHI_YES == signalIsfushiFlag)
@@ -2104,6 +2077,15 @@ UINT8 DriveSignalClose(const UINT16 signalId)
routeState = GetRouteState(routeId);/*获取进路状态*/
wStartSignalId = GetRouteStartSignalId(routeId);
chRoutelightFlag = GetSignalShineBit2(signalId);
if (SIGNAL_LIGHT_CONFIG_CBTC_LIGHT_BIT2 == chRoutelightFlag)
{
lightExtinctState = SIGNAL_LIGHT_EXTICT_STATE_YES;
}
else
{
/*数据配置常亮，CBTC接近时灭灯，驱动亮灯；配置其他依据亮灭灯状态*/
}
if (((ROUTE_LEAD_PROPERTY_YES == routeLeadProperty) || (ROUTE_LEAD_PROPERTY_CBTC_YES == routeLeadProperty))
&& ((ROUTE_STATE_LEAD_LOCK == routeState)
|| (ROUTE_STATE_LEAD_LOCKERR == routeState)
@@ -4345,7 +4327,6 @@ void YLockSignalOpenManage(void)
UINT8 belongVirCI = 0u;
UINT8 flag = 0u;
UINT8 yLockState = 0u;
UINT8 includeVirFlag = GetCiFunctionSwitchConfig(FUNC_INCLUDEVIRCI_FLAG);
/*处理信号机*/
@@ -4357,15 +4338,12 @@ void YLockSignalOpenManage(void)
signalId = GetSignalId(ii); /*获取信号机ID*/
belongCiId = GetSignalBelongCiId(signalId); /*获取进路所属联锁ID*/
if(FUNC_SWITCH_ON == includeVirFlag)
{
belongVirCI = GetSignalBelongVirCiId(signalId); /*获取信号机所属虚拟联锁ID*/
yLockState = GetVirCIAllSwitchYLockState(belongVirCI);
}
else
{
yLockState = GetAllSwitchYLockFlag();
}
if ((0u == signalId) || (signalId >= SIGNAL_SUM_MAX))
{
@@ -5950,8 +5928,6 @@ UINT8 CheckJumpLockApply(UINT16 axisSectionId)
UINT8 routeTrainNear = 0u;
UINT8 physicalCheck = 0u;
UINT8 phyPLockRouteState = 0u;
UINT16 devId = 0u; /*设备ID*/
UINT8 devState = 0u; /*设备状态*/
physicalSecId = GetAxisSecRelativePhySecId(axisSectionId);
routeRlockId = GetPhySecRLockBelongRouteId(physicalSecId);/*物理区段进路锁闭所属进路ID*/
@@ -6096,41 +6072,9 @@ UINT8 CheckJumpLockApply(UINT16 axisSectionId)
}
}
}
/*计轴区段内所有道岔未引导总锁*/
if (CI_SUCCESS == reVal)
{
devId = 0u;
devState = 0u;
reVal = AxisSecSwitchYZLockCheck(axisSectionId, &devId, &devState);
}
/*计轴区段的防护道岔未引导总锁*/
if (CI_SUCCESS == reVal)
{
devId = 0u;
devState = 0u;
reVal = AxisSecProtSwtYLockCheck(axisSectionId, &devId, &devState);
}
if (CI_SUCCESS == reVal)
{/*检查防护道岔位置*/
devId = 0u;
devState = 0u;
reVal = AxisSecAllProtSwitchPosCheck(axisSectionId, &devId, &devState);
}
if (CI_SUCCESS == reVal)
{/*检查防护道岔封锁状态*/
devId = 0u;
devState = 0u;
reVal = AxisSecProtSwitchFLockCheck(axisSectionId, &devId, &devState);
}
return reVal;
}
/*
* 功能描述： 检查指定进路内的指定逻辑区段ID前（包含指定逻辑区段ID）的区段无UT占用
* 参数说明： UINT16 routeId, 进路ID
@@ -6257,8 +6201,6 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
UINT8 logSecLockState = 0U;
UINT8 logSecLockRouteNum = 0U;
UINT8 chFailStep = 0U;
UINT8 cYLockAlarmFlag = FLAG_UNSET; /*引导总锁报警标志*/
UINT8 cYLockState = 0U; /*引导总锁状态*/
bufIndex = GetlogSectionBufIndex(logSectionId); /*获取区段数组下标*/
/**区段下标合法*/
@@ -6417,11 +6359,8 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
switchCurPosition = GetSwitchCurPosition(curSwitchId); /*获取道岔当前位置*/
retFlag = checkSwtLastValDrvPosStayorNot(curSwitchId, switchCurPosition); /*检查道岔上一次驱动是否还在有效期*/
switchFLockState = GetSwitchFLockState(curSwitchId); /*获取道岔封锁状态*/
cYLockState = GetSwitchYLockState(curSwitchId);
if ((pLgcSecSwitchStru[ii].SwitchPosition != switchCurPosition) || (CI_ERROR == retFlag) || (SWITCH_LOCK_FENGSUO_YES == switchFLockState)
|| (SWITCH_LOCK_YINZONG_NO != cYLockState))
{/*（判断当前计轴包含的道岔位置与道岔当前的位置有一个不同）或（某个道岔上一次驱动仍然有效）或（道岔封锁）或（道岔引导总锁）*/
if ((pLgcSecSwitchStru[ii].SwitchPosition != switchCurPosition) || (CI_ERROR == retFlag) || (SWITCH_LOCK_FENGSUO_YES == switchFLockState))
{/*（判断当前计轴包含的道岔位置与道岔当前的位置有一个不同）或（某个道岔上一次驱动仍然有效）或（道岔封锁）*/
reVal = CI_ERROR;
chFailStep = 8U;
break;
@@ -6527,29 +6466,6 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
reVal = CI_SUCCESS;
}
}
if (CI_SUCCESS == reVal)
{/*防护道岔封锁状态检查*/
devId = 0u; /*设备ID*/
devState = 0u; /*设备状态*/
reVal = LogicSecRltvPrtctSwFLockCheck(logSectionId, &devId, &devState, &cYLockAlarmFlag);/*封锁检查*/
if (CI_SUCCESS != reVal)
{
chFailStep = 13U;
}
}
if (CI_SUCCESS == reVal)
{/*防护道岔位置检查*/
devId = 0u; /*设备ID*/
devState = 0u; /*设备状态*/
reVal = LogicSecRltvPrtctSwPosCheck(logSectionId, &devId, &devState);/*位置检查*/
if (CI_SUCCESS != reVal)
{
chFailStep = 14U;
}
}
}
else
{
@@ -6851,17 +6767,10 @@ UINT8 JumpLockDriveSwitch(const UINT16 axisSecId)
AxisSwitchStruct* pRouteSwitchStru = NULL; /*道岔数据结构指针*/
UINT8 innerSwitchRetVal = CI_ERROR; /*检查计轴区段内道岔是否可被驱动的结果*/
AxisSwitchStruct* pProtectSwitchStru = NULL; /*防护道岔数据结构指针*/
UINT8 protectSwitchSum = 0u;
switchSum = GetAxisSwitchSum(axisSecId);
pRouteSwitchStru = GetAxisSwitchIdStru(axisSecId);
protectSwitchSum = GetAxisSecRelateProSwSum(axisSecId);
pProtectSwitchStru = GetAxisSecRelateProSwStru(axisSecId);
if ((0u == axisSecId) || (axisSecId >= AXIS_SECTION_SUM_MAX) || (NULL == pRouteSwitchStru) || (NULL == pProtectSwitchStru))
if((0u == axisSecId) || (axisSecId >= AXIS_SECTION_SUM_MAX))
{
innerSwitchRetVal = CI_ERROR;
}
@@ -6890,32 +6799,6 @@ UINT8 JumpLockDriveSwitch(const UINT16 axisSecId)
}
}
if (innerSwitchRetVal == CI_SUCCESS)
{
/* 单操相反位置取消驱动检查 */
for (ii = 0u; ii < protectSwitchSum; ii++)
{
switchId = pProtectSwitchStru[ii].SwitchId;
switchExpPosition = pProtectSwitchStru[ii].SwitchPosition;
switchDancaoPosition = GetSwitchDanCaoPostition(switchId);
if ((SWITCH_POSITION_INVALID == switchDancaoPosition)
||
(switchDancaoPosition == switchExpPosition))
{/*单操无效 或者 单操位置与动作位置一样*/
innerSwitchRetVal = CI_SUCCESS;
}
else
{
/*单操到相反位置取消道岔的驱动*/
innerSwitchRetVal = CI_ERROR;
break;
}
}
}
if(innerSwitchRetVal == CI_SUCCESS)
{
/*驱动计轴区段道岔*/
@@ -6934,7 +6817,7 @@ UINT8 JumpLockDriveSwitch(const UINT16 axisSecId)
/*
功能描述: 驱动计轴区段内道岔，计轴区段关联防护道岔处理
功能描述: 驱动计轴区段内道岔处理
输入参数: const UINT16 axisSecId 计轴区段ID
输出参数: const UINT8 DrivFlag 道岔驱动标志
返回值: 无
@@ -6946,18 +6829,12 @@ void AxisSecDrvInnerSwitch(const UINT16 axisSecId, const UINT8 DrivFlag)
UINT8 switchExpPos = 0u; /*道岔期望位置*/
AxisSwitchStruct* pAxisSecSwitchStru = NULL; /*道岔数据*/
UINT8 ii = 0u; /*循环变量*/
AxisSwitchStruct* pProtectSwitchStru = NULL; /*防护道岔数据结构指针*/
UINT8 protectSwitchSum = 0u;
UINT8 funRtn = CI_ERROR;
switchSum = GetAxisSwitchSum(axisSecId); /*获取计轴区段道岔数目*/
pAxisSecSwitchStru = GetAxisSwitchIdStru(axisSecId); /*获取计轴区段内道岔数据*/
protectSwitchSum = GetAxisSecRelateProSwSum(axisSecId);
pProtectSwitchStru = GetAxisSecRelateProSwStru(axisSecId);
if ((NULL != pAxisSecSwitchStru) && (NULL != pProtectSwitchStru))
{
if(SWITCH_NEED_DRIV_TRUE == DrivFlag)
{/*需要驱动计轴区段内道岔*/
@@ -6965,17 +6842,9 @@ void AxisSecDrvInnerSwitch(const UINT16 axisSecId, const UINT8 DrivFlag)
{
switchId = pAxisSecSwitchStru[ii].SwitchId;
switchExpPos = pAxisSecSwitchStru[ii].SwitchPosition;
(void)SwitchDriveProcess(switchId, switchExpPos); /*设置计轴区段内道岔的驱动状态为驱动中*/
funRtn = SwitchDriveProcess(switchId, switchExpPos); /*设置计轴区段内道岔的驱动状态为驱动中*/
}
for (ii = 0u; ii < protectSwitchSum; ii++)
{
switchId = pProtectSwitchStru[ii].SwitchId;
switchExpPos = pProtectSwitchStru[ii].SwitchPosition;
(void)SwitchDriveProcess(switchId, switchExpPos); /*设置计轴区段防护道岔的驱动状态为驱动中*/
}
}
}
}
@@ -7429,7 +7298,7 @@ UINT8 GetSwitchLogSecLockState(UINT16 switchId, UINT16* logOccOrLockId, UINT8* p
UINT8 retValue = CI_ERROR;
UINT8 chLogSecLogLockState = 0U; /*逻辑区段逻辑锁闭状态*/
UINT8 cLockBelongLogicRouteNum = 0U; /*逻辑区段逻辑锁闭所属逻辑进路数量*/
UINT8 chLogSecJumpLockState = 0U;
/*获取道岔关联逻辑区段信息*/
logSecSum = GetSwitchLogSecSum(switchId);
logSecBuf = GetSwitchLogSecBuf(switchId);
@@ -7453,9 +7322,8 @@ UINT8 GetSwitchLogSecLockState(UINT16 switchId, UINT16* logOccOrLockId, UINT8* p
/*检查逻辑区段逻辑锁闭状态*/
chLogSecLogLockState = GetLogSecLogLockState(logSecBuf[i]);
cLockBelongLogicRouteNum = GetLogSecLockBelLogRouteSum(logSecBuf[i]);
chLogSecJumpLockState = GetLogSecJumpLockState(logSecBuf[i]);
if ((LOG_SECTION_LOGLOCK_NO == chLogSecLogLockState) && (0U == cLockBelongLogicRouteNum) && (LOGIC_SECTION_JUMP_LOCK_NO == chLogSecJumpLockState))
if ((LOG_SECTION_LOGLOCK_NO == chLogSecLogLockState) && (0U == cLockBelongLogicRouteNum))
{
retValue = CI_SUCCESS;
}
@@ -9075,7 +8943,7 @@ void SetCtrlPower(const UINT8 virtualCiId, const UINT8 ctrlPowerFlag, const UINT
UINT8 i = 0u;
UINT8 cimode = 0u;
UINT8 virtualCiNum = 0u;
cimode = GetCiModeFlag();
cimode = GetVirCImode(virtualCiId);
virtualCiNum = GetVirtualCINum();
if (CI_MODE_ATS != cimode)
{
@@ -9182,26 +9050,30 @@ void SetSigleRouteAutoTriggerManage(UINT8 virCIid, UINT16 routeId, UINT8 setFlag
{
UINT8 chkFState = CI_ERROR;
UINT8 chkFloodState = CI_ERROR;
UINT8 includeVirFlag = GetCiFunctionSwitchConfig(FUNC_INCLUDEVIRCI_FLAG);
UINT8 belongCiId = 0u; /*进路所属联锁ID*/
UINT8 localCiId = 0u; /*本地联锁ID*/
UINT8 belongVirCI = 0u;
UINT8 flag = 0u;
UINT8 autoTriggerType = 0u; /*自动触发进路属性*/
UINT8 chRoutCouplinkFlag = 0U;
UINT16 wLastPhyId = 0U;
UINT16 wLockRouteId = 0U;
UINT16 wSigId = 0U;
UINT16 wSameStartSigRouteNum = 0U;
UINT16* pSameStartSigRouteBuf = NULL;
UINT16 jj = 0U;
autoTriggerType = GetAutoTriggerType(routeId); /*获取进路自动触发进路属性*/
localCiId = GetSystemParaLocalCiId(); /*获取本机联锁ID*/
belongCiId = GetRouteBelongCiId(routeId); /*获取进路所属联锁ID*/
if (ROUTE_TYPE_AUTO_TRIGGER == autoTriggerType)
{
if (FUNC_SWITCH_ON == includeVirFlag)
{
belongVirCI = GetRouteBelongVirCiId(routeId);
if (belongVirCI != virCIid)
{
flag = 1u;
}
}
if ((0u == routeId) || (routeId >= ROUTE_SUM_MAX) || (belongCiId != localCiId) || (1u == flag))
{
@@ -9211,7 +9083,71 @@ void SetSigleRouteAutoTriggerManage(UINT8 virCIid, UINT16 routeId, UINT8 setFlag
{
/*检查自动触发进路封锁状态*/
chkFState = ChekAutoTriggerRouteFlockState(routeId);
if (CI_SUCCESS == chkFState)
{
/*检查进路无联挂标志*/
chRoutCouplinkFlag = GetRouteCouplinkFlag(routeId);
if (ROUTE_COUPLINK_FLAG_NO == chRoutCouplinkFlag)
{
/*继续检查*/
}
else
{
chkFState = CI_ERROR;
}
/*进路最后区段锁闭所属进路不存在联挂标志*/
if (CI_SUCCESS == chkFState)
{
wLastPhyId = GetRouteLastPhySectionId(routeId); /*获取进路最后物理区段*/
wLockRouteId = GetPhySecRLockBelongRouteId(wLastPhyId); /*获取物理区段锁闭所属进路*/
chRoutCouplinkFlag = GetRouteCouplinkFlag(wLockRouteId);/*获取联挂标志*/
if (ROUTE_COUPLINK_FLAG_NO == chRoutCouplinkFlag)
{
/*不存在联挂标志*/
}
else
{
chkFState = CI_ERROR;
}
}
else
{
/*不处理*/
}
if (CI_SUCCESS == chkFState)
{
/*进路始端信号机为始端的其他进路也不存在联挂标志*/
wSigId = GetRouteStartSignalId(routeId);
wSameStartSigRouteNum = GetStartSignalRouteSum(wSigId); /*获取始端信号机进路数量和数组*/
pSameStartSigRouteBuf = GetStartSignalRouteBuf(wSigId);
if ((NULL != pSameStartSigRouteBuf) && (0U < wSameStartSigRouteNum))
{
for (jj = 0U; jj < wSameStartSigRouteNum; jj++)
{
chRoutCouplinkFlag = GetRouteCouplinkFlag(pSameStartSigRouteBuf[jj]);
if (ROUTE_COUPLINK_FLAG_NO == chRoutCouplinkFlag)
{
/*不存在联挂标志*/
}
else
{
chkFState = CI_ERROR;
break;
}
}
}
else
{
chkFState = CI_ERROR;
}
}
else
{
/*不处理*/
}
}
if (CI_SUCCESS == chkFState)
{
/*检查自动触发进路防淹门状态*/
@@ -9249,7 +9185,6 @@ void SetSigleRouteAutoTriggerManage(UINT8 virCIid, UINT16 routeId, UINT8 setFlag
*/
void CancelSigleRouteAutoTrigger(UINT8 virCIid, UINT16 routeId, UINT8 setFlag)
{
UINT8 includeVirFlag = GetCiFunctionSwitchConfig(FUNC_INCLUDEVIRCI_FLAG);
UINT8 belongCiId = 0u; /*进路所属联锁ID*/
UINT8 localCiId = 0u; /*本地联锁ID*/
UINT8 belongVirCI = 0u;
@@ -9259,14 +9194,13 @@ void CancelSigleRouteAutoTrigger(UINT8 virCIid, UINT16 routeId, UINT8 setFlag)
localCiId = GetSystemParaLocalCiId(); /*获取本机联锁ID*/
belongCiId = GetRouteBelongCiId(routeId); /*获取进路所属联锁ID*/
flag = 0u;
if (FUNC_SWITCH_ON == includeVirFlag)
{
belongVirCI = GetRouteBelongVirCiId(routeId);
if (belongVirCI != virCIid)
{
flag = 1u;
}
}
if ((0u == routeId) || (routeId >= ROUTE_SUM_MAX) || (belongCiId != localCiId) || (1u == flag))
{
@@ -11480,82 +11414,181 @@ UINT16 GetRouteFirstLockedLogSecId(UINT16 wRouteId)
}
/*
功能描述:
清除逻辑区段关联道岔单操位置
输入参数:
const UINT16 逻辑区段ID
输出参数:
无.
返回值:
无
add by mpt 20260403
* 功能描述：紧急临时限速处理
* 参数说明：const UINT16 wLogSectionId 逻辑区段ID
* const UINT8 chExiansuState 限速状态
* 返 回 值：无
* by 20250916
*/
void ClearLogSeceSwitchDanCaoPos(const UINT16 logicSecId)
void EmergXianSuProcess(const UINT16 wLogSectionId, const UINT8 chExiansuState)
{
UINT8 switchSum = 0u; /*道岔数目*/
UINT16 switchId = 0u; /*道岔ID*/
UINT8 ii = 0u; /*循环变量*/
UINT8 checkSum = 0u;
LogsecSwitchStruct* dataIdBuf = NULL;
UINT8 chLogicSecSwitchSum = 0U;/*逻辑区段道岔数目*/
LogsecSwitchStruct* pLogicSecSwitchIdData = NULL;/*逻辑区段道岔ID数据*/
chLogicSecSwitchSum = GetLogicSecSwitchSum(logicSecId);/*逻辑区段道岔数目*/
pLogicSecSwitchIdData = GetLogicSecSwitchIdStru(logicSecId);/*逻辑区段道岔ID数据*/
checkSum = GetLgcRelateProSwSum(logicSecId);/*获取指定ID逻辑区段关联防护道岔数目*/
dataIdBuf = GetLgcRelateProSwStru(logicSecId);
if (NULL != pLogicSecSwitchIdData)
UINT8 chBelongCiId = 0U;
UINT8 chLocalCiId = 0U;
UINT8 chPerLogSecExiansuState = 0U;
if ((0U < wLogSectionId) && (LOGIC_SECTION_SUM_MAX > wLogSectionId))
{
for (ii = 0u; ii < chLogicSecSwitchSum; ii++)
chBelongCiId = GetLogSecBelongCiId(wLogSectionId);/*逻辑区段所属联锁*/
chLocalCiId = GetSystemParaLocalCiId();
if ((chLocalCiId == chBelongCiId) && (0U != chLocalCiId))
{
switchId = pLogicSecSwitchIdData[ii].SwitchId;
/*设置该道岔期望驱动位置为无效*/
(void)SetSwitchDanCaoPosition(switchId, SWITCH_POSITION_INVALID);
chPerLogSecExiansuState = GetLogSecEmergXianSu(wLogSectionId);
SetLogSecEmergXianSu(wLogSectionId, chExiansuState);/*设置逻辑区段紧急临时限速*/
if ((LOGSEC_EMERG_XS_SET_YES != chPerLogSecExiansuState) && (LOGSEC_EMERG_XS_SET_YES == chExiansuState))
{
/*由未设置到设置*/
ClearLgcSecBelongRtXsCfm(wLogSectionId); /*清除限速确认*/
}
else
{
/*不处理*/
}
}
if (NULL != dataIdBuf)
else
{
for (ii = 0u; ii < checkSum; ii++)
{
switchId = dataIdBuf[ii].SwitchId;
/*设置该道岔期望驱动位置为无效*/
(void)SetSwitchDanCaoPosition(switchId, SWITCH_POSITION_INVALID);
/*非本联锁逻辑区段，不处理*/
}
}
else
{
/*不处理*/
}
}
/*
功能描述:
清除计轴区段关联道岔单操位置
输入参数:
const UINT16 计轴区段ID
输出参数:
无.
返回值:
无
add by mpt 20260403
* 功能描述：获取全线雨雪模式命令CC
* 参数说明：void
* 返 回 值：0x55 有效
* 0xAA 无效
* Created By LQ 2025.11.07
*/
void ClearAxisSeceSwitchDanCaoPos(const UINT16 axisSecId)
UINT8 GetAllSnowModelCC(void)
{
return g_AllSnowModelCC;
}
/*
* 功能描述：设置全线雨雪模式命令CC
* 参数说明：UINT8 setmodle 全线雨雪模式
* 返 回 值：void
* Created By LQ 2025.11.07
*/
void SetAllSnowModelCC(UINT8 setmodle)
{
if ((CI_ALL_SNOW_VALID == setmodle) || (CI_ALL_SNOW_UNVALID == setmodle))
{
g_AllSnowModelCC = setmodle;
}
else
{
/*不处理*/
}
}
/*
* 功能描述：获取本地区间雨雪站台数量CC
* 参数说明：无
* 返 回 值：区间雨雪站台数量
* Created By LQ 2025.11.06
*/
UINT8 GetLocalAreaSnowNumCC(void)
{
return gLocalAreaSnowNumCC;
}
/*
* 功能描述：获取本地区间雨雪信息CC
* 参数说明：无
* 返 回 值：区间雨雪信息
* Created By LQ 2025.11.06
*/
AreaSnowInfoStruct* GetLocalAreaSnowCC(void)
{
return gszLocalAreaSnowCC;
}
/*
* 功能描述：设置本地区间雨雪站台信息CC
* 参数说明：const UINT8 cAreaSnowNum 区间雨雪数量
* const AreaSnowInfoStruct pAreaSnowBuf[LOCAL_AREA_SNOW_SUM_MAX] 区间雨雪数组
* 返 回 值：无
* Created By LQ 2025.11.06
*/
void SetLocalAreaSnowInfoCC(const UINT8 cAreaSnowNum, const AreaSnowInfoStruct pAreaSnowBuf[LOCAL_AREA_SNOW_SUM_MAX])
{
UINT16* pLogSectionIdBuf = NULL;
UINT8 chLogSectionSum = 0U;
UINT8 ii = 0U;
pLogSectionIdBuf = GetAxisSecLogSectionIdBuf(axisSecId);
chLogSectionSum = GetAxisSecLogSectionSum(axisSecId);
if ((LOCAL_AREA_SNOW_SUM_MAX >= cAreaSnowNum) && (NULL != pAreaSnowBuf))
{
/*清除本地区间雨雪站台信息CC*/
(void)CommonMemSet(gszLocalAreaSnowCC, (UINT32)(sizeof(AreaSnowInfoStruct) * LOCAL_AREA_SNOW_SUM_MAX), 0U, (UINT32)(sizeof(AreaSnowInfoStruct) * LOCAL_AREA_SNOW_SUM_MAX));
if (NULL != pLogSectionIdBuf)
gLocalAreaSnowNumCC = cAreaSnowNum;
for (ii = 0U; ii < cAreaSnowNum; ii++)
{
for (ii = 0U; ii < chLogSectionSum; ii++)
gszLocalAreaSnowCC[ii] = pAreaSnowBuf[ii]; /*存储本控区的区间雨雪状态信息*/
}
}
else
{
/*清除逻辑区段道岔道岔标志*/
ClearLogSeceSwitchDanCaoPos(pLogSectionIdBuf[ii]);
/*入参非法，不处理*/
}
}
/*
* 功能描述：获取本地雨雪模式命令CC
* 参数说明：无
* 返 回 值：0x55 无效
* 0xAA 有效
* Created By LQ 2025.11.06
*/
UINT8 GetLocalSnowModelCC(void)
{
return g_LocalSnowModelCC;
}
/*
* 功能描述：设置本地雨雪模式命令CC
* 参数说明：UINT8 setmodle 本地雨雪模式
* 返 回 值：无
* Created By LQ 2025.11.06
*/
void SetLocalSnowModelCC(UINT8 setmodle)
{
if ((CI_LOCAL_SNOW_UNVALID == setmodle) || (CI_LOCAL_SNOW_VALID == setmodle))
{
g_LocalSnowModelCC = setmodle;
}
else
{
; /*不处理*/
}
}
/*
* 功能描述： 获取虚拟联锁类型
* 参数说明： UINT8 chVirCiId 虚拟联锁ID
* 返回值 ：
CI_TYPE_ZX ((UINT8)0x01) 正线联锁
CI_TYPE_CLD ((UINT8)0x04) 车辆段联锁
CI_TYPE_SCX ((UINT8)0x02) 试车线
add by mpt 20260104
*/
UINT8 GetLocalVirCiType(UINT8 chVirCiId)
{
UINT8 cLocalCiId = 0U;
UINT8 ret = 0U;
cLocalCiId = GetSystemParaLocalCiId();
if (chVirCiId == 200U + cLocalCiId)
{
ret = CI_TYPE_SCX;
}
else
{
ret = GetLocalCiType();
}
return ret;
}
TSCP/src/APP/ciapp/DataManage/DeviceDataManage.h
+78 -27
View File
@@ -190,6 +190,8 @@ extern UINT8 g_AllTsrFlag; /*
extern UINT8 g_AllSnowModel; /*全线雨雪模式命令*/
extern UINT8 g_AllSnowModelCC; /*全线雨雪模式命令CC：0x55-有效；0xAA-无效*/
extern UINT8 g_AllSnowLevel; /*全线湿轨级别：0-默认值；1-一级；2-二级*/
extern UINT8 g_IteLineCutState; /*ITE全线切除状态：0x55：切除ITE；0xAA：使用ITE；0xFF：默认值*/
@@ -232,11 +234,16 @@ extern CtrlPowerStruct ctrlpowerFlag[VIRTUAL_CI_MAX];
extern UINT8 LocalAreaSnowNum; /*本地区间雨雪站台数量*/
extern AreaSnowInfoStruct szLocalAreaSnow[LOCAL_AREA_SNOW_SUM_MAX]; /*本地区间雨雪数组*/
extern UINT8 gLocalAreaSnowNumCC; /*本地区间雨雪站台数量CC*/
extern AreaSnowInfoStruct gszLocalAreaSnowCC[LOCAL_AREA_SNOW_SUM_MAX]; /*本地区间雨雪数组CC*/
extern LineCommTrainStruct gStrLineCommTrain; /*全线通信车结构体*/
extern UINT32 gFlyProtectOverCyc; /*飞车宕机报警起始周期*/
extern UINT8 g_LocalSnowModel; /*本地雨雪模式命令*/
extern UINT8 g_LocalSnowModelCC; /*本地雨雪模式命令CC*/
extern UINT8 gLocalAreaIteCutNum; /*本地区间ITE切除数量*/
extern UINT16 gSzLocalAreaIteCutId[ALL_AREA_SNOW_SUM_MAX]; /*本地区间ITE切除ID数组*/
@@ -288,13 +295,6 @@ void SetStartLockFlag(UINT8 setFlag);
LINSHIXIANSU_COMM_BAD_YES_LABOURCANCLE_STATE
*/
UINT8 GetLabourCancelLinShiXianState(void);
/*
功能描述：人工取消临时限速状态迁移处理
参数说明：setFlag 状态
返回值：无
*/
void LabourCancelLSXianStaMoveProc(UINT8 setFlag);
/*
功能描述：人工取消临时限速状态迁移处理
参数说明：setFlag 状态,UINT8 virCIid 虚拟联锁ID
@@ -1897,31 +1897,82 @@ void SetLocalAreaIteCutInfo(const UINT8 cAreaIteCutNum, const UINT16 pAreaIteCut
* Created By LQ 2025.05.08
*/
UINT16 GetRouteFirstLockedLogSecId(UINT16 wRouteId);
/*
* 功能描述：紧急临时限速处理
* 参数说明：const UINT16 wPhySectionId 逻辑区段ID
* const UINT8 chExiansuState 限速状态
* 返 回 值：无
* by 202500916
*/
void EmergXianSuProcess(const UINT16 wPhySectionId, const UINT8 chExiansuState);
/*
功能描述:
清除逻辑区段关联道岔单操位置
输入参数:
const UINT16 逻辑区段ID
输出参数:
无.
返回值:
无
add by mpt 20260403
* 功能描述：获取全线雨雪模式命令CC
* 参数说明：void
* 返 回 值：0x55 有效
* 0xAA 无效
* Created By LQ 2025.11.07
*/
void ClearLogSeceSwitchDanCaoPos(const UINT16 logicSecId);
UINT8 GetAllSnowModelCC(void);
/*
功能描述:
清除计轴区段关联道岔单操位置
输入参数:
const UINT16 计轴区段ID
输出参数:
无.
返回值:
无
add by mpt 20260403
* 功能描述：设置全线雨雪模式命令CC
* 参数说明：UINT8 setmodle 全线雨雪模式
* 返 回 值：void
* Created By LQ 2025.11.07
*/
void ClearAxisSeceSwitchDanCaoPos(const UINT16 axisSecId);
void SetAllSnowModelCC(UINT8 setmodle);
/*
* 功能描述：获取本地区间雨雪站台数量CC
* 参数说明：无
* 返 回 值：区间雨雪站台数量
* Created By LQ 2025.11.06
*/
UINT8 GetLocalAreaSnowNumCC(void);
/*
* 功能描述：获取本地区间雨雪信息CC
* 参数说明：无
* 返 回 值：区间雨雪信息
* Created By LQ 2025.11.06
*/
AreaSnowInfoStruct* GetLocalAreaSnowCC(void);
/*
* 功能描述：设置本地区间雨雪站台信息CC
* 参数说明：const UINT8 cAreaSnowNum 区间雨雪数量
* const AreaSnowInfoStruct pAreaSnowBuf[LOCAL_AREA_SNOW_SUM_MAX] 区间雨雪数组
* 返 回 值：无
* Created By LQ 2025.11.06
*/
void SetLocalAreaSnowInfoCC(const UINT8 cAreaSnowNum, const AreaSnowInfoStruct pAreaSnowBuf[LOCAL_AREA_SNOW_SUM_MAX]);
/*
* 功能描述：获取本地雨雪模式命令CC
* 参数说明：无
* 返 回 值：0x55 无效
* 0xAA 有效
* Created By LQ 2025.11.06
*/
UINT8 GetLocalSnowModelCC(void);
/*
* 功能描述：设置本地雨雪模式命令CC
* 参数说明：UINT8 setmodle 本地雨雪模式
* 返 回 值：无
* Created By LQ 2025.11.06
*/
void SetLocalSnowModelCC(UINT8 setmodle);
/*
* 功能描述： 获取虚拟联锁类型
* 参数说明： UINT8 chVirCiId 虚拟联锁ID
* 返回值 ：
CI_TYPE_ZX ((UINT8)0x01) 正线联锁
CI_TYPE_CLD ((UINT8)0x04) 车辆段联锁
CI_TYPE_SCX ((UINT8)0x02) 试车线
add by mpt 20260104
*/
UINT8 GetLocalVirCiType(UINT8 chVirCiId);
#endif
TSCP/src/APP/ciapp/DataManage/PlatDataManage.c
+4 -5
View File
@@ -450,7 +450,7 @@ UINT8 CheckRCIAPowerFaultState(void)
else
{
retVal = CI_ERROR;
debug_infor_printf((const)"PLATIO_A_Node_Power_FaultState StartTime%d\n", dwErrorStartCyc);
debug_infor_printf((const)"\nPLATIO_A_Node_Power_FaultState StartTime%d\n", dwErrorStartCyc);
}
}
else
@@ -494,7 +494,7 @@ UINT8 CheckRCIBPowerFaultState(void)
else
{
retVal = CI_ERROR;
debug_infor_printf((const)"PLATIO_B_Node_Power_FaultState StartTime%d\n", dwErrorStartCyc);
debug_infor_printf((const)"\nPLATIO_B_Node_Power_FaultState StartTime%d\n", dwErrorStartCyc);
}
}
else
@@ -515,7 +515,6 @@ UINT8 CheckRCIBPowerFaultState(void)
UINT8 CheckRCIAPowerModeFaultState(void)
{
UINT8 retVal = CI_ERROR;
UINT8 powerAPUBAState = 0U; /*PUB A采集的24VA电源状态 1*/
UINT8 powerBPUBAState = 0U; /*PUB A采集的24VB电源状态 3*/
UINT8 vol1Flag = 0U; /*CPI A采集24VA电源 1*/
@@ -551,7 +550,7 @@ UINT8 CheckRCIAPowerModeFaultState(void)
else
{
retVal = CI_ERROR;
debug_infor_printf((const)"PLATIO_A_Mode_Power_FaultState StartTime%d\n", dwErrorStartCyc);
debug_infor_printf((const)"\nPLATIO_A_Mode_Power_FaultState StartTime%d\n", dwErrorStartCyc);
}
}
else
@@ -607,7 +606,7 @@ UINT8 CheckRCIBPowerModeFaultState(void)
else
{
retVal = CI_ERROR;
debug_infor_printf((const)"PLATIO_B_Mode_Power_FaultState StartTime%d\n", dwErrorStartCyc);
debug_infor_printf((const)"\nPLATIO_B_Mode_Power_FaultState StartTime%d\n", dwErrorStartCyc);
}
}
else
TSCP/src/APP/ciapp/DataManage/PlatDataManage.h
+1 -2
View File
@@ -59,7 +59,6 @@
#define CCU_CommBadEnsureTime_CycleCount ((UINT16)5u) /*应用与通控通信中断判断周期数*/
#define VOLTAGE_MAX_TO_0 ((UINT16)500U) /*电压判断为0的阈值*/
#define IO_POWERSTATE_TOLERANCE ((UINT8)0x02) /*平台电源报警容忍周期数，容忍3周期，超过2周期报警*/
/*平台心跳帧信息结构*/
@@ -102,7 +101,6 @@ typedef struct S_PlatGPIODataStruct
UINT8 ModepowerBState_PUB; /*机柜B系电源插箱中为CPUB供电的24VDC电源模块状态*/
}PlatGPIODataStruct;
/*平台发送的电源采集状态容忍同步数据*/
typedef struct S_PlatGPIOToleranceData
{
@@ -114,6 +112,7 @@ typedef struct S_PlatGPIOToleranceData
/*
* 功能描述： 清空指定通控板卡发送的心跳数据
* 参数说明： 板卡ID
TSCP/src/APP/ciapp/ERROR/ErrorDefine.h
+20
View File
@@ -110,6 +110,7 @@
#define EFUNC_SWITCHTESTLOGIC ((UINT8)0x80U) /*函数：SetSwitchTestLogicManage道岔定反位测试*/
#define EFUNC_OVERLAP_VALIDMASK_CHECK ((UINT8)0x4A) /*函数：OverlapValidMaskCheck 计算保护区段有效码位检查*/
#define EFUNC_ROUTE_LOCK_DRIVE_SWITCH ((UINT8)0xD2) /*RouteLockDriveSwitch 锁闭道岔*/
#define EFUNC_ROUTE_COUPLINK_SET ((UINT8)0xD7) /*SetCouplinkRouteLogicManage 办理联挂进路逻辑管理*/
/*车辆段联锁逻辑检查*/
#define EFUNC_SET_LEAD_ROUTE_CHECK ((UINT8)0x4B) /*办理引导进路检查*/
@@ -214,6 +215,11 @@
#define EFUNC_OVERLAP_ZHAOCHA_CHECK ((UINT8)0xD3) /*保护区段照查条件检查*/
#define EFUNC_PARSE_LOCAL_CI2RC_DATA ((UINT8)0xD4U) /*函数：ParseCiToLocalRcDataFrame*/
#define EFUNC_PARSE_LOCAL_RC2CI_DATA ((UINT8)0xD5U) /*函数：ParseRcToLocalCiDataFrame*/
#define EFUNC_PARSE_LOCAL_CI2CI_DATA ((UINT8)0xD6U) /*函数：ParseCiToCiDataFrame*/
#define EFUNC_PARSE_LOCAL_OC2CI_DATA ((UINT8)0xD7U) /*函数：ParseOcToCiDataFrame*/
/*************************************************分界线******************************************************************************/
/*************************************************分界线******************************************************************************/
@@ -235,6 +241,7 @@
#define ETYPE_ROUTE_XUANPAI_OVERTIME ((UINT8)0x10) /*进路选排超时*/
#define ETYPE_GROUP_AUTO_ROUTE_STATE ((UINT8)0x16) /*组合自动进路*/
#define ETYPE_ROUTE_APPLY_SWITCH_MOVE ((UINT8)0xA4) /*进路道岔单操中*/
#define ETYPE_COUPLINK_ROUTE_IDLE ((UINT8)0xA5) /*联挂进路内无被联挂车*/
#define ETYPE_COMM_WITH_VOBC ((UINT8)0x11) /*与VOBC通信*/
@@ -245,6 +252,8 @@
#define ETYPE_COMM_WITH_PSC ((UINT8)0x15) /*CI与PSC通信*/
#define ETYPE_COMM_WITH_TMC ((UINT8)0x17) /*与TMC通信*/
#define ETYPE_COMM_WITH_RC ((UINT8)0x18U) /*与RC通信*/
#define ETYPE_COMM_WITH_OC ((UINT8)0x19U) /*与OC通信*/
/* 信号机故障类型编码 (UINT8)0x21-(UINT8)0x3f */
/* 设备类型 CI_DEVICE_TYPE_SIGNAL */
@@ -298,6 +307,7 @@
/*保护区段类型*/
#define ETYPE_OVERLAP_LABORUNLOCK_FAIL ((UINT8)0x51U) /*保护区段人工锁闭条件不满足*/
#define ETYPE_OVERLAP_RES_CHECK_FAIL ((UINT8)0x52U) /*保护区段资源检查条件不满足*/
#define ETYPE_OVERLAP_LABORUNLOCK_STATE ((UINT8)0x53U) /*保护区段人工解锁状态不满足*/
/* 道岔类型编码 (UINT8)0x61-(UINT8)0x7f */
/* 设备类型 CI_DEVICE_TYPE_SWITCH */
@@ -385,6 +395,16 @@
#define ETYPE_LOGSEC_XIANSU_STATE ((UINT8)0xC5) /*逻辑区段限速设置*/
#define ETYPE_LOGSEC_FIRSTLOCK_STATE ((UINT8)0xC6) /*逻辑区段为第一个锁闭区段检查*/
#define ETYPE_LOGSEC_CBTC_PROPERTY ((UINT8)0xC7) /*逻辑区段CBTC属性检查*/
#define ETYPE_LOGSEC_CONTINUOUS ((UINT8)0xC8) /*逻辑区段连续性检查*/
/*动态路径故障类型*/
#define ETYPE_PART_ROUTE_RES ((UINT8)0xD0) /*动态路径资源检查*/
#define ETYPE_PART_ROUTE_MATCH_ROUTE ((UINT8)0xD1) /*动态路径匹配进路检查*/
#define ETYPE_PART_ROUTE_SCREEN ((UINT8)0xD2) /*动态路径列车筛选检查*/
#define ETYPE_PART_ROUTE_REPEAT ((UINT8)0xD3) /*动态路径重复办理检查*/
#define ETYPE_PART_ROUTE_SEC_ATTR ((UINT8)0xD4) /*动态路径区段属性检查*/
#define ETYPE_PART_ROUTE_TRAIN_COMM ((UINT8)0xD5) /*动态路径列车通信状态检查*/
#define ETYPE_PART_ROUTE_TRAIN_POS ((UINT8)0xD6) /*动态路径列车位置检查*/
/* 系统故障 */
/* 设备类型 EFUNC_LOGIC_MANAGE_SYETEM */
TSCP/src/APP/ciapp/ESB/ESBConfigDataManage.c
+51
View File
@@ -663,3 +663,54 @@ UINT8 CheckEsbBelSendRange(const UINT16 wCheckEsbId)
return retVal;
}
/*
* 功能描述：获取指定ID紧急停车按钮关联的同站紧急按钮数量
* 参数说明：const UINT16 esbId 紧急停车按钮ID
* 返 回 值：同站紧急按钮数量
* Created By LQ 2025.12.30
*/
UINT8 GetEsbRelOnePlatEsbNum(const UINT16 esbId)
{
UINT16 bufIndex = 0U; /*数组下标*/
UINT8 reVal = 0U;
bufIndex = GetEsbConfigBufIndex(esbId); /*获取数组下标*/
if (ESB_SUM_MAX > bufIndex)
{
reVal = EsbConfigDataStru[bufIndex].RelOnePlatEsbNum;
}
else
{
/*返回0*/
}
return reVal;
}
/*
* 功能描述：获取指定ID紧急停车按钮关联的同站紧急按钮ID数组
* 参数说明：const UINT16 esbId 紧急停车按钮ID
* 返 回 值：NULL 获取数据失败
* 其它 同站紧急按钮ID数组
* Created By LQ 2025.12.30
*/
UINT16* GetEsbRelOnePlatEsbId(const UINT16 esbId)
{
UINT16 bufIndex = 0U; /*数组下标*/
UINT16* reVal = NULL;
bufIndex = GetEsbConfigBufIndex(esbId); /*获取数组下标*/
if (ESB_SUM_MAX > bufIndex)
{
reVal = EsbConfigDataStru[bufIndex].RelOnePlatEsbId;
}
else
{
/*返回NULL*/
}
return reVal;
}
TSCP/src/APP/ciapp/ESB/ESBConfigDataManage.h
+20
View File
@@ -19,6 +19,7 @@
#include "CommonTypes.h"
#include "../System/CiSystemDefine.h"
#include "../System/SystemParameterManage.h"
#include "dquStructInit.h"
#ifdef __cplusplus
@@ -50,6 +51,8 @@ typedef struct S_EsbConfigDataStruct
UINT16 EsbCutoffBuzzRelayId; /*切除蜂鸣器报警继电器ID*/
UINT8 ConfigAtsCiEssSteadyMask; /*是否配置了ATS-CI稳灯状态码位0x55 配置；0xaa未配置*/
UINT8 ConfigAtsCiEssFlashMask; /*是否配置了ATS-CI闪灯状态码位0x55 配置；0xaa未配置*/
UINT8 RelOnePlatEsbNum; /*关联同站ESB数量*/
UINT16 RelOnePlatEsbId[ESB_PROTECT_LINK_NUM]; /*关联同站ESB ID数组*/
} EsbConfigDataStruct;
/*******************************全局变量声明*******************************/
@@ -293,6 +296,23 @@ UINT16 GetEsbCutoffBuzzRelayId(const UINT16 esbId);
*/
UINT8 CheckEsbBelSendRange(const UINT16 wCheckEsbId);
/*
* 功能描述：获取指定ID紧急停车按钮关联的同站紧急按钮数量
* 参数说明：const UINT16 esbId 紧急停车按钮ID
* 返 回 值：同站紧急按钮数量
* Created By LQ 2025.12.30
*/
UINT8 GetEsbRelOnePlatEsbNum(const UINT16 esbId);
/*
* 功能描述：获取指定ID紧急停车按钮关联的同站紧急按钮ID数组
* 参数说明：const UINT16 esbId 紧急停车按钮ID
* 返 回 值：NULL 获取数据失败
* 其它 同站紧急按钮ID数组
* Created By LQ 2025.12.30
*/
UINT16* GetEsbRelOnePlatEsbId(const UINT16 esbId);
#ifdef __cplusplus
}
#endif
TSCP/src/APP/ciapp/ESB/ESBDataManage.c
+301
View File
@@ -171,6 +171,8 @@ UINT8 EsbDataManageInit(void)
EsbDataStru[esbId].EsbCutErrTriggerPressCycNum = 0U; /*紧急关闭旁路按钮误触发按下周期*/
EsbDataStru[esbId].EsbCutErrorFlag = ESB_ERROR_FLAG_NO; /*紧急关闭旁路按钮未故障*/
EsbDataStru[esbId].EsbCutRelayDownState = ESB_RELAY_ERROR_DOWN_YES; /*紧急关闭旁路按钮采集继电器落下状态初始化为通信异常落下*/
EsbDataStru[esbId].cOnePlatEsbState = ESB_STATE_VALID_NO; /*初始化同站紧急按钮未激活*/
EsbDataStru[esbId].cOnePlatEsbCutState = ESB_CUT_NO; /*初始化同站紧急旁路按钮未激活*/
}
rtn = CI_SUCCESS;
return rtn;
@@ -1073,3 +1075,302 @@ UINT8 GetEsbRelayDownState(const UINT16 esbId)
return reVal;
}
/*
* 功能描述： 获取指定ID紧急停车按钮状态(融合了旁路状态)
* 参数说明： const UINT16 esbId, 紧急停车按钮ID
* 返回值 ： 0: 获取数据失败
* >0: 紧急停车按钮状态
*/
UINT8 GetEsbMergeState(const UINT16 esbId)
{
UINT8 reVal = CI_ERROR;
UINT8 chEsbState = 0U;
UINT8 chEsbCutState = 0U;
chEsbState = GetEsbState(esbId);
chEsbCutState = GetEsbCutState(esbId);
if (ESB_CUT_YES == chEsbCutState)
{
reVal = ESB_STATE_VALID_NO;/*未按下*/
}
else
{
if (ESB_STATE_VALID_NO == chEsbState)
{
reVal = ESB_STATE_VALID_NO;/*未按下*/
}
else
{
reVal = ESB_STATE_VALID_YES;
}
}
return reVal;
}
/*
* 功能描述：获取指定ID紧急按钮同站紧急按钮激活状态
* 参数说明：const UINT16 esbId 紧急停车按钮ID
* 返 回 值：0 获取数据失败
* 0x55 紧急未激活
* 0xAA 紧急激活
* Created By LQ 2025.12.29
*/
UINT8 GetOnePlatEsbState(const UINT16 esbId)
{
UINT16 bufIndex = 0U; /*数组下标*/
UINT8 reVal = CI_ERROR;
bufIndex = GetEsbConfigBufIndex(esbId); /*获取数组下标*/
if (ESB_SUM_MAX > bufIndex)
{
reVal = EsbDataStru[bufIndex].cOnePlatEsbState;
}
else
{
/*返回失败*/
}
return reVal;
}
/*
* 功能描述：设置指定ID紧急按钮同站紧急按钮激活状态
* 参数说明：const UINT16 esbId 紧急按钮ID
* const UINT8 esbState 紧急按钮状态
* 返 回 值：无
* Created By LQ 2025.12.29
*/
void SetOnePlatEsbState(const UINT16 esbId, const UINT8 esbState)
{
UINT16 bufIndex = 0U; /*数组下标*/
bufIndex = GetEsbConfigBufIndex(esbId); /*获取数组下标*/
if (ESB_SUM_MAX > bufIndex)
{
if ((ESB_STATE_VALID_NO == esbState) || (ESB_STATE_VALID_YES == esbState))
{
EsbDataStru[bufIndex].cOnePlatEsbState = esbState; /*同站紧急按钮激活状态*/
}
else
{
/*不处理*/
}
}
else
{
/*不处理*/
}
}
/*
* 功能描述：获取指定ID紧急按钮同站紧急旁路按钮激活状态
* 参数说明：const UINT16 esbId 紧急停车按钮ID
* 返 回 值：0 获取数据失败
* 0x55 旁路未激活
* 0xAA 旁路激活
* Created By LQ 2025.12.29
*/
UINT8 GetOnePlatEsbCutState(const UINT16 esbId)
{
UINT16 bufIndex = 0U; /*数组下标*/
UINT8 reVal = CI_ERROR;
bufIndex = GetEsbConfigBufIndex(esbId); /*获取数组下标*/
if (ESB_SUM_MAX > bufIndex)
{
reVal = EsbDataStru[bufIndex].cOnePlatEsbCutState;
}
else
{
/*返回失败*/
}
return reVal;
}
/*
* 功能描述：设置指定ID紧急按钮同站紧急旁路按钮激活状态
* 参数说明：const UINT16 esbId 紧急按钮ID
* const UINT8 esbCutState 紧急旁路按钮状态
* 返 回 值：无
* Created By LQ 2025.12.29
*/
void SetOnePlatEsbCutState(const UINT16 esbId, const UINT8 esbCutState)
{
UINT16 bufIndex = 0U; /*数组下标*/
bufIndex = GetEsbConfigBufIndex(esbId); /*获取数组下标*/
if (ESB_SUM_MAX > bufIndex)
{
if ((ESB_CUT_NO == esbCutState) || (ESB_CUT_YES == esbCutState))
{
EsbDataStru[bufIndex].cOnePlatEsbCutState = esbCutState; /*同站紧急按钮激活状态*/
}
else
{
/*不处理*/
}
}
else
{
/*不处理*/
}
}
/*
* 功能描述：清除同站紧急按钮及旁路按钮激活状态
* 参数说明：无
* 返 回 值：无
* Created By LQ 2025.12.30
*/
void ClearOnePlatEsbAndCutState(void)
{
UINT16 wEsbTotalSum = 0U; /*ESB总数*/
UINT16 ii = 0U;
UINT16 wEsbId = 0U; /*ESB ID*/
wEsbTotalSum = GetTotalEsbCurNum();
/*重置所有紧急按钮的同站紧急按钮及旁路按钮为未激活状态*/
for (ii = 0U; ii < wEsbTotalSum; ii++)
{
wEsbId = GetEsbId(ii);
SetOnePlatEsbState(wEsbId, ESB_STATE_VALID_NO);
SetOnePlatEsbCutState(wEsbId, ESB_CUT_NO);
}
}
/*
* 功能描述：设置指定ID紧急按钮关联的其它同站紧急按钮激活状态
* 参数说明：const UINT16 esbId 紧急按钮ID
* const UINT8 esbState 紧急按钮状态
* 返 回 值：无
* Created By LQ 2025.12.29
*/
void SetRelOtherOnePlatEsbState(const UINT16 esbId, const UINT8 esbState)
{
UINT16 bufIndex = 0U; /*数组下标*/
UINT8 cRelOnePlatEsbNum = 0U; /*关联的其它同站紧急按钮数量*/
UINT16* pRelOnePlatEsbId = NULL; /*关联的其它同站紧急按钮ID*/
UINT8 ii = 0U;
bufIndex = GetEsbConfigBufIndex(esbId); /*获取数组下标*/
cRelOnePlatEsbNum = GetEsbRelOnePlatEsbNum(esbId);
pRelOnePlatEsbId = GetEsbRelOnePlatEsbId(esbId);
if ((ESB_SUM_MAX > bufIndex) && (0U < cRelOnePlatEsbNum) && (NULL != pRelOnePlatEsbId))
{
if ((ESB_STATE_VALID_NO == esbState) || (ESB_STATE_VALID_YES == esbState))
{
for (ii = 0U; ii < cRelOnePlatEsbNum; ii++)
{
SetOnePlatEsbState(pRelOnePlatEsbId[ii], esbState);
}
}
else
{
/*不处理*/
}
}
else
{
/*不处理*/
}
}
/*
* 功能描述：设置指定ID紧急按钮关联的其它同站紧急旁路按钮激活状态
* 参数说明：const UINT16 esbId 紧急按钮ID
* const UINT8 esbCutState 紧急旁路按钮状态
* 返 回 值：无
* Created By LQ 2025.12.29
*/
void SetRelOtherOnePlatEsbCutState(const UINT16 esbId, const UINT8 esbCutState)
{
UINT16 bufIndex = 0U; /*数组下标*/
UINT8 cRelOnePlatEsbNum = 0U; /*关联的其它同站紧急按钮数量*/
UINT16* pRelOnePlatEsbId = NULL; /*关联的其它同站紧急按钮ID*/
UINT8 ii = 0U;
bufIndex = GetEsbConfigBufIndex(esbId); /*获取数组下标*/
cRelOnePlatEsbNum = GetEsbRelOnePlatEsbNum(esbId);
pRelOnePlatEsbId = GetEsbRelOnePlatEsbId(esbId);
if ((ESB_SUM_MAX > bufIndex) && (0U < cRelOnePlatEsbNum) && (NULL != pRelOnePlatEsbId))
{
if ((ESB_CUT_NO == esbCutState) || (ESB_CUT_YES == esbCutState))
{
for (ii = 0U; ii < cRelOnePlatEsbNum; ii++)
{
SetOnePlatEsbCutState(pRelOnePlatEsbId[ii], esbCutState);
}
}
else
{
/*不处理*/
}
}
else
{
/*不处理*/
}
}
/*
* 功能描述：检查指定ID紧急按钮关联的其它同站紧急按钮状态
* 参数说明：const UINT16 esbId 紧急按钮ID
* 返 回 值：1 紧急无效或旁路有效
* 0 紧急有效
* Created By LQ 2025.12.29
*/
UINT8 CheckRelOtherOnePlatEsbState(const UINT16 esbId)
{
UINT8 cRetVal = CI_ERROR;
UINT16 bufIndex = 0U; /*数组下标*/
UINT8 cRelOnePlatEsbNum = 0U; /*关联的其它同站紧急按钮数量*/
UINT16* pRelOnePlatEsbId = NULL; /*关联的其它同站紧急按钮ID*/
UINT8 ii = 0U;
UINT8 cEsbState = 0U; /*紧急按钮状态*/
UINT8 cEsbCutState = 0U; /*紧急按钮旁路状态*/
bufIndex = GetEsbConfigBufIndex(esbId); /*获取数组下标*/
cRelOnePlatEsbNum = GetEsbRelOnePlatEsbNum(esbId);
pRelOnePlatEsbId = GetEsbRelOnePlatEsbId(esbId);
if ((ESB_SUM_MAX > bufIndex) && (NULL != pRelOnePlatEsbId))
{
cRetVal = CI_SUCCESS;
for (ii = 0U; ii < cRelOnePlatEsbNum; ii++)
{
cEsbState = GetEsbState(pRelOnePlatEsbId[ii]);
cEsbCutState = GetEsbCutState(pRelOnePlatEsbId[ii]);
if ((ESB_STATE_VALID_NO == cEsbState) || (ESB_CUT_YES == cEsbCutState))
{
/*继续检查*/
}
else
{
cRetVal = CI_ERROR; /*存在一个ESB紧急有效且旁路无效，返回0*/
break;
}
}
}
else
{
cRetVal = CI_ERROR; /*入参非法，返回0*/
}
return cRetVal;
}
TSCP/src/APP/ciapp/ESB/ESBDataManage.h
+82
View File
@@ -49,6 +49,8 @@ typedef struct S_EsbDataStruct
UINT32 EsbCutErrTriggerPressCycNum; /*紧急关闭旁路按钮误触发按下周期*/
UINT8 EsbCutErrorFlag; /*紧急关闭旁路按钮故障标志，0x55-未故障，0xaa-故障*/
UINT8 EsbCutRelayDownState; /*紧急关闭旁路按钮采集继电器落下状态，0x55-正常采集落下，0xaa-通信异常落下*/
UINT8 cOnePlatEsbState; /*同站紧急按钮激活状态：0x55-未激活，0xAA-激活*/
UINT8 cOnePlatEsbCutState; /*同站紧急旁路按钮激活状态：0x55-未激活，0xAA-激活*/
} EsbDataStruct;
/*******************************全局变量声明*******************************/
@@ -406,6 +408,86 @@ void SetEsbRelayDownState(const UINT16 esbId, const UINT8 cRelayDownState);
* Created By LQ 2025.04.01
*/
UINT8 GetEsbRelayDownState(const UINT16 esbId);
/*
* 功能描述： 获取指定ID紧急停车按钮状态(融合了旁路状态)
* 参数说明： const UINT16 esbId, 紧急停车按钮ID
* 返回值 ： 0: 获取数据失败
* >0: 紧急停车按钮状态
*/
UINT8 GetEsbMergeState(const UINT16 esbId);
/*
* 功能描述：获取指定ID紧急按钮同站紧急按钮激活状态
* 参数说明：const UINT16 esbId 紧急停车按钮ID
* 返 回 值：0 获取数据失败
* 0x55 紧急未激活
* 0xAA 紧急激活
* Created By LQ 2025.12.29
*/
UINT8 GetOnePlatEsbState(const UINT16 esbId);
/*
* 功能描述：设置指定ID紧急按钮同站紧急按钮激活状态
* 参数说明：const UINT16 esbId 紧急按钮ID
* const UINT8 esbState 紧急按钮状态
* 返 回 值：无
* Created By LQ 2025.12.29
*/
void SetOnePlatEsbState(const UINT16 esbId, const UINT8 esbState);
/*
* 功能描述：获取指定ID紧急按钮同站紧急旁路按钮激活状态
* 参数说明：const UINT16 esbId 紧急停车按钮ID
* 返 回 值：0 获取数据失败
* 0x55 旁路未激活
* 0xAA 旁路激活
* Created By LQ 2025.12.29
*/
UINT8 GetOnePlatEsbCutState(const UINT16 esbId);
/*
* 功能描述：设置指定ID紧急按钮同站紧急旁路按钮激活状态
* 参数说明：const UINT16 esbId 紧急按钮ID
* const UINT8 esbCutState 紧急旁路按钮状态
* 返 回 值：无
* Created By LQ 2025.12.29
*/
void SetOnePlatEsbCutState(const UINT16 esbId, const UINT8 esbCutState);
/*
* 功能描述：清除同站紧急按钮及旁路按钮激活状态
* 参数说明：无
* 返 回 值：无
* Created By LQ 2025.12.30
*/
void ClearOnePlatEsbAndCutState(void);
/*
* 功能描述：设置指定ID紧急按钮关联的其它同站紧急按钮激活状态
* 参数说明：const UINT16 esbId 紧急按钮ID
* const UINT8 esbState 紧急按钮状态
* 返 回 值：无
* Created By LQ 2025.12.29
*/
void SetRelOtherOnePlatEsbState(const UINT16 esbId, const UINT8 esbState);
/*
* 功能描述：设置指定ID紧急按钮关联的其它同站紧急旁路按钮激活状态
* 参数说明：const UINT16 esbId 紧急按钮ID
* const UINT8 esbCutState 紧急旁路按钮状态
* 返 回 值：无
* Created By LQ 2025.12.29
*/
void SetRelOtherOnePlatEsbCutState(const UINT16 esbId, const UINT8 esbCutState);
/*
* 功能描述：检查指定ID紧急按钮关联的其它同站紧急按钮状态
* 参数说明：const UINT16 esbId 紧急按钮ID
* 返 回 值：1 紧急无效或旁路有效
* 0 紧急有效
* Created By LQ 2025.12.29
*/
UINT8 CheckRelOtherOnePlatEsbState(const UINT16 esbId);
#ifdef __cplusplus
}
TSCP/src/APP/ciapp/EnvelopeManage/ELMDataPrepare.c
+17 -17
View File
@@ -176,7 +176,7 @@ else
UINT8 elm_PrepareTrainSafeLoc(UINT16 trainID,INOUT ELM_TrainSafeLocStruct* pTrainSafeLoc)
{
UINT8 chRtnVal = CI_ERROR;
UINT16 wTrainID = (UINT16)(0x1400u + (trainID & 0x00ffu));
UINT16 wTrainID = (UINT16)(TRAIN_ID_MIN_IVOC + (trainID & 0x00ffU));
if (NULL != pTrainSafeLoc)
{
@@ -1012,7 +1012,7 @@ UINT32 elm_PrepareTrainLength(UINT16 trainid)
UINT8 chTrainType = 0u;
UINT8 chFunRtn = CI_ERROR;
UINT32 dwRtnVal = 0u;
UINT16 wTrainID = (UINT16)(0x1400u + (trainid & 0x00ffu));
UINT16 wTrainID = (UINT16)(TRAIN_ID_MIN_IVOC + (trainid & 0x00ffU));
/*获取列车类型*/
chFunRtn = dquGetTrainType(wTrainID, &chTrainType);
@@ -1074,7 +1074,7 @@ UINT8 elm_PrepareNextAcMinSafeHeadLoc(UINT16 trainid, OUT UINT16 acID[AC_MAXCNT_
UINT8 chFunRtn = CI_ERROR;
LinkPointDataStru strPoint = { 0u };
UINT16 wSwitchId = 0u;
UINT16 wTrainID = (UINT16)(0x1400u + (trainid & 0x00ffu));
UINT16 wTrainID = (UINT16)(TRAIN_ID_MIN_IVOC + (trainid & 0x00ffU));
UINT8 cDirectionPointFlag = 0U; /*是否具有方向变化点标志*/
@@ -1135,7 +1135,7 @@ UINT8 elm_PrepareMaxSafeHeadLoc(UINT16 trainid, OUT LOD_STRU *pLoc)
UINT16 wLink = 0u;
UINT32 dwOff = UINT32_MAX;
UINT8 chDir = 0u;
UINT16 wTrainID = (UINT16)(0x1400u + (trainid & 0x00ffu));
UINT16 wTrainID = (UINT16)(TRAIN_ID_MIN_IVOC + (trainid & 0x00ffU));
wLink = GetTrainMaxHeadLink(wTrainID);
@@ -1169,7 +1169,7 @@ UINT8 elm_PrepareMinSafeHeadLoc(UINT16 trainid, OUT LOD_STRU *pLoc)
UINT16 wLink = 0u;
UINT32 dwOff = UINT32_MAX;
UINT8 chDir = 0u;
UINT16 wTrainID = (UINT16)(0x1400u + (trainid & 0x00ffu));
UINT16 wTrainID = (UINT16)(TRAIN_ID_MIN_IVOC + (trainid & 0x00ffU));
wLink = GetTrainMinHeadLink(wTrainID);
@@ -1200,7 +1200,7 @@ UINT16 elm_PrepareACOfMaxSafeHeadLoc(UINT16 trainid)
UINT16 wMinHeadLink = 0u;
UINT8 chFunRtn = CI_ERROR;
UINT16 wRtn = 0u;
UINT16 wTrainID = (UINT16)(0x1400u + (trainid & 0x00ffu));
UINT16 wTrainID = (UINT16)(TRAIN_ID_MIN_IVOC + (trainid & 0x00ffU));
wMinHeadLink = GetTrainMaxHeadLink(wTrainID);
chFunRtn = IsLinkIdValid(wMinHeadLink);
@@ -1227,7 +1227,7 @@ UINT16 elm_PrepareACOfMinSafeHeadLoc(UINT16 trainid)
UINT16 wMinHeadLink = 0u;
UINT8 chFunRtn = CI_ERROR;
UINT16 wRtn = 0u;
UINT16 wTrainID = (UINT16)(0x1400u + (trainid & 0x00ffu));
UINT16 wTrainID = (UINT16)(TRAIN_ID_MIN_IVOC + (trainid & 0x00ffU));
wMinHeadLink = GetTrainMinHeadLink(wTrainID);
chFunRtn = IsLinkIdValid(wMinHeadLink);
@@ -1261,7 +1261,7 @@ UINT8 elm_PrepareNextAcMaxSafeTailLoc(UINT16 trainid, OUT UINT16 acID[AC_MAXCNT_
UINT8 chFunRtn = CI_ERROR;
LinkPointDataStru strPoint = { 0u };
UINT16 wSwitchId = 0u;
UINT16 wTrainID = (UINT16)(0x1400u + (trainid & 0x00ffu));
UINT16 wTrainID = (UINT16)(TRAIN_ID_MIN_IVOC + (trainid & 0x00ffU));
UINT8 cDirectionPointFlag = 0U; /*是否具有方向变化点标志*/
@@ -1324,7 +1324,7 @@ UINT8 elm_PrepareMaxSafeTailLoc(UINT16 trainid, OUT LOD_STRU *pLoc)
UINT16 wLink = 0u;
UINT32 dwOff = UINT32_MAX;
UINT8 chDir = 0u;
UINT16 wTrainID = (UINT16)(0x1400u + (trainid & 0x00ffu));
UINT16 wTrainID = (UINT16)(TRAIN_ID_MIN_IVOC + (trainid & 0x00ffU));
wLink = GetTrainMaxTailLink(wTrainID);
dwOff = GetTrainMaxTailOffset(wTrainID);
@@ -1357,7 +1357,7 @@ UINT8 elm_PrepareMinSafeTailLoc(UINT16 trainid, OUT LOD_STRU *pLoc)
UINT16 wLink = 0u;
UINT32 dwOff = UINT32_MAX;
UINT8 chDir = 0u;
UINT16 wTrainID = (UINT16)(0x1400u + (trainid & 0x00ffu));
UINT16 wTrainID = (UINT16)(TRAIN_ID_MIN_IVOC + (trainid & 0x00ffU));
wLink = GetTrainMinTailLink(wTrainID);
dwOff = GetTrainMinTailOffset(wTrainID);
@@ -1387,7 +1387,7 @@ UINT16 elm_PrepareACOfMaxSafeTailLoc(UINT16 trainid)
UINT16 wMaxTailLink = 0u;
UINT8 chFunRtn = CI_ERROR;
UINT16 wRtn = 0u;
UINT16 wTrainID = (UINT16)(0x1400u + (trainid & 0x00ffu));
UINT16 wTrainID = (UINT16)(TRAIN_ID_MIN_IVOC + (trainid & 0x00ffU));
wMaxTailLink = GetTrainMaxTailLink(wTrainID);
chFunRtn = IsLinkIdValid(wMaxTailLink);
@@ -1414,7 +1414,7 @@ UINT16 elm_PrepareACOfMinSafeTailLoc(UINT16 trainid)
UINT16 wMaxTailLink = 0u;
UINT8 chFunRtn = CI_ERROR;
UINT16 wRtn = 0u;
UINT16 wTrainID = (UINT16)(0x1400u + (trainid & 0x00ffu));
UINT16 wTrainID = (UINT16)(TRAIN_ID_MIN_IVOC + (trainid & 0x00ffU));
wMaxTailLink = GetTrainMinTailLink(wTrainID);
chFunRtn = IsLinkIdValid(wMaxTailLink);
@@ -1652,7 +1652,7 @@ UINT8 elm_PrepareComOCID(IN const UINT8 **pOCIDbuff)
else
{
/** 获取本OC通信的OC数量 */
ret = GetCiTransmitSpecifySysDevSum(CI_SYSTEM_TYPE_CI);
ret = GetCiTransmitSpecifySysDevSum(CI_SYSTEM_TYPE_RCI);
/** 判断是否存在，不存在直接返回*/
if (0u == ret)
@@ -1662,7 +1662,7 @@ UINT8 elm_PrepareComOCID(IN const UINT8 **pOCIDbuff)
else
{
/** 获取相邻通信的TIOC ID */
(*pOCIDbuff) = GetCiTransmitSpecifySysDevBuf(CI_SYSTEM_TYPE_CI);
(*pOCIDbuff) = GetCiTransmitSpecifySysDevBuf(CI_SYSTEM_TYPE_RCI);
}
}
@@ -1683,8 +1683,8 @@ UINT8 elm_PrepareOCCommStatus(UINT8 OCID)
UINT8 ret = ELM_COM_STATUS_ERROR;
UINT8 funRtn = TRANSMIT_STATE_BAD;
/** 获取OC通信状态 */
funRtn = GetCiTransmitState(CI_SYSTEM_TYPE_CI,OCID);
/** 获取Rc通信状态 */
funRtn = GetRcPbTacsTransmitState(OCID);
/** 设置函数返回值 */
ASSERT_SETRET(TRANSMIT_STATE_GOOD == funRtn,ret,ELM_COM_STATUS_OK,ELM_COM_STATUS_ERROR)
@@ -1771,7 +1771,7 @@ UINT8 elm_PrepareTrainSafeHeadFlag(UINT16 trainId)
{
UINT8 ret = CI_ERROR;
UINT16 funRtn = TRAIN_HEAD_FLAG_YES;
UINT16 wTrainID = (UINT16)(0x1400u + (trainId & 0x00ffu));
UINT16 wTrainID = (UINT16)(TRAIN_ID_MIN_IVOC + (trainId & 0x00ffU));
funRtn = GetTrainSafeHeadFlag(wTrainID);
TSCP/src/APP/ciapp/EnvelopeManage/EnvelopeDefine.h
-1
View File
@@ -28,7 +28,6 @@
#define TRAIN_IN_ENVELOPE_SUM_MAX (15u) /*列车包络中包含的列车最大数量(开区间)*/
#define SECTION_IN_ENVELOPE_SUM_MAX (10u) /*列车包络中包含的区段最大个数(开区间)*/
#define SECTION_REL_ENVELOPE_SUM_MAX (15u) /*区段关联的包络最大个数(开区间)*/
#define OTHER_RC_SEND_ENVELOPE_SUM_MAX (50u) /*相邻联锁发送最大包络数量*/
#define TRAIN_REL_ENVELOPE_SUM_MAX (15u) /*列车关联的包络最大个数(开区间)*/
#define MAX_ENVELOPE_LOG_NUM (10000U) /*包络日志打印缓存大小*/
TSCP/src/APP/ciapp/EnvelopeManage/EnvelopeLogicProcess.c
+4 -34
View File
@@ -330,12 +330,6 @@ static void elm_FlyingProtect(void)
UINT16 wTrainId = 0U;
UINT8 chTimeCheck = 0u;
UINT32 dwFlyOverCyc = 0U;
UINT8 cNvramFlag = 0U; /*列车使用NVRAM标志*/
UINT8 cPosMonistorState = 0U; /*列车位置监督状态*/
UINT8 cFuncSwitch = 0U; /*使用NVRAM位置且位置监督无效的列车飞车不宕机开关：0xAA-飞车不宕机 0x55-飞车宕机*/
/*周期清除使用NVRAM位置且位置监督无效的飞车信息*/
ClearNvramFlyingTrain();
chCTCheck = elm_FlyingProtect_CT(); /*检查CT飞车*/
elm_FlyingProtect_UCT();/*UCT包络飞车删除为UKT*/
@@ -350,7 +344,7 @@ static void elm_FlyingProtect(void)
{
/** 获取数据配置的飞车宕机最大冗余时间 */
maxShutdownRedunTime = elm_PrepareCTFlyingRedunTime();
cFuncSwitch = GetCiFunctionSwitchConfig(FUNC_NVRAM_TRAIN_FlYING_OVER);
for (ii = 0U; ii < trainCnt; ii++)
{
wTrainId = GetTrainId(ii);
@@ -358,23 +352,13 @@ static void elm_FlyingProtect(void)
{
dwFlyStartCyc = GetTrainStartFlyProtectCycNum(wTrainId);
chTimeCheck = SystemOverTimeCheck(dwFlyStartCyc, (UINT32)maxShutdownRedunTime);
if (CI_TIME_OUT== chTimeCheck)
{
cNvramFlag = GetTrainNvramPosFlag(wTrainId);
cPosMonistorState = GetTrainPosMonitorState(wTrainId);
if ((TRAIN_NVRAM_POS_FLAG_YES == cNvramFlag) && (TRAIN_POS_MONITOR_VALID != cPosMonistorState) && (FUNC_SWITCH_ON == cFuncSwitch))
{
/*使用NVRAM位置且位置监督无效的列车飞车后，若NVRAM列车飞车不宕机开关打开，RC仅向列车发飞车特控报文，不宕机*/
}
else
{
SetFlyProtectOverCyc(dwCurCyc); /*飞车标志*/
}
}
else
{
; /*未超过冗余时间或列车通信中断*/
; /*未超过冗余时间*/
}
}
}
@@ -1199,7 +1183,7 @@ void elm_AddNextOCEnvelopetoBuff(UINT8 OCid)
UINT16 buffIndex = ENVELOPE_UNVAILD_INDEX;
UINT32 errorCode = 0u;
EnvelopeStruct tempEnvelope = {0u};
CfpEnvelopeStruct InfEnvelope[OTHER_RC_SEND_ENVELOPE_SUM_MAX * ONE_OTHER_CFP_SUM_MAX] = {0u};
CfpEnvelopeStruct InfEnvelope[SECTION_REL_ENVELOPE_SUM_MAX * ONE_OTHER_CFP_SUM_MAX] = {0u};
/** 获取OC发送的包络信息个数 */
envelopeCnt = elm_PrepareNextOcInfEnvelope(OCid,InfEnvelope);
@@ -3064,13 +3048,9 @@ UINT8 elm_UCTEnvelopeLeaveAC(UINT8 flag,IN const EnvelopeStruct* pEnvelope,UINT1
UINT32 dwFlyStartCyc = 0U;
UINT8 chTimeCheck = 0U;
UINT8 flyCheck = 0U;
UINT8 cNvramFlag = 0U; /*列车使用NVRAM标志*/
UINT8 cPosMonistorState = 0U; /*列车位置监督状态*/
UINT8 cFuncSwitch = 0U; /*使用NVRAM位置且位置监督无效的列车飞车不宕机开关：0xAA-飞车不宕机 0x55-飞车宕机*/
/** CT飞车防护*/
trainCnt = elm_PrepareCommTrainID(trainID);
cFuncSwitch = GetCiFunctionSwitchConfig(FUNC_NVRAM_TRAIN_FlYING_OVER);
/** 遍历所有的通信车 */
for (cycle = 0u; cycle < trainCnt; cycle++)
{
@@ -3116,19 +3096,9 @@ UINT8 elm_UCTEnvelopeLeaveAC(UINT8 flag,IN const EnvelopeStruct* pEnvelope,UINT1
dwFlyStartCyc = GetTrainStartFlyProtectCycNum(trainID[cycle]);
chTimeCheck = SystemOverTimeCheck(dwFlyStartCyc, (UINT32)maxShutdownRedunTime);
if (CI_TIME_OUT == chTimeCheck)
{
cNvramFlag = GetTrainNvramPosFlag(trainID[cycle]);
cPosMonistorState = GetTrainPosMonitorState(trainID[cycle]);
if ((TRAIN_NVRAM_POS_FLAG_YES == cNvramFlag) && (TRAIN_POS_MONITOR_VALID != cPosMonistorState) && (FUNC_SWITCH_ON == cFuncSwitch))
{
/*使用NVRAM位置且位置监督无效的列车飞车后，若NVRAM列车飞车不宕机开关打开，RC仅向列车发飞车特控报文，不宕机*/
AddNvramFlyingTrain(trainID[cycle]);
}
else
{
elm_AddFlyingTrain(trainID[cycle], pEnvelop->id);
}
}
flyCheck++;
}
else
TSCP/src/APP/ciapp/EnvelopeManage/UCTEnvelopeTrack.c
+4 -21
View File
@@ -2114,10 +2114,8 @@ static UINT8 elm_UCTEnvelopeHeadHandle(UINT8 endlineFlag, IN const EnvelopeStruc
wAgLink = GetBGLinkRelAGLinkId(wLinkId);
chBgUtSwitch = GetNoCGFollowUtSwitch();
wNextLinkId = FindAdjacentLinkIDSafe(wLinkId, ptemp->endPos.Dir, &wSwitchId, &cDirectionPointFlag);
if ((FUNC_SWITCH_ON == chBgUtSwitch) && (LINK_REL_PHYSEC_BG == chBgAtt) && (wNextLinkId == wAgLink)
&& ((pPretemp->startPos.Lnk == wAgLink) || (pPretemp->endPos.Lnk == wAgLink))
&& (1U == ptemp->ACCnt))
{/* B轨UT可追踪开关打开，UCT仅处于B轨，相邻区段是A轨，CT包络在A轨，此场景不延伸 */
if ((FUNC_SWITCH_ON == chBgUtSwitch) && (LINK_REL_PHYSEC_BG == chBgAtt) && (wNextLinkId == wAgLink) && ((pPretemp->startPos.Lnk == wAgLink) || (pPretemp->endPos.Lnk == wAgLink)))
{/* B轨UT可追踪开关打开，UCT处于B轨，相邻区段是A轨，CT包络在A轨，此场景不延伸 */
ret = 0x55u;
}
else
@@ -2786,10 +2784,8 @@ static UINT8 elm_UCTEnvelopeTailHandle(UINT8 endlineFlag, const EnvelopeStruct *
wAgLink = GetBGLinkRelAGLinkId(wLinkId);
chBgUtSwitch = GetNoCGFollowUtSwitch();
wNextLinkId = FindAdjacentLinkIDSafe(wLinkId, ~ptemp->startPos.Dir, &wSwitchId, &cDirectionPointFlag);
if ((FUNC_SWITCH_ON == chBgUtSwitch) && (LINK_REL_PHYSEC_BG == chBgAtt) && (wNextLinkId == wAgLink)
&& ((pBacktemp->startPos.Lnk == wAgLink) || (pBacktemp->endPos.Lnk == wAgLink))
&& (1U == ptemp->ACCnt))
{/* B轨UT可追踪开关打开，UCT仅处于B轨，相邻区段是A轨，CT包络在A轨，此场景不延伸 */
if ((FUNC_SWITCH_ON == chBgUtSwitch) && (LINK_REL_PHYSEC_BG == chBgAtt) && (wNextLinkId == wAgLink) && ((pBacktemp->startPos.Lnk == wAgLink) || (pBacktemp->endPos.Lnk == wAgLink)))
{/* B轨UT可追踪开关打开，UCT处于B轨，相邻区段是A轨，CT包络在A轨，此场景不延伸 */
ret = 0x55u;
}
else
@@ -3299,7 +3295,6 @@ static UINT8 elm_UCTEnvelopeMoving(const EnvelopeStruct* ptemp)
2、包络内包含的道岔无四开且占用，
3，不为休眠车,
4、列车车长不小于两倍线路最小车长
* by cgh 20250915
*/
static UINT8 elm_ConvertToUCTCheck(const EnvelopeStruct* ptemp)
{
@@ -3311,7 +3306,6 @@ static UINT8 elm_ConvertToUCTCheck(const EnvelopeStruct* ptemp)
UINT32 minTrainLength = 0U;
UINT32 dwTempLength = 0U;
UINT8 chTrainNvramPosFlag = 0U;
UINT8 chTrainIsIsFollowUtFlag = 0U;/*是否为列车可追踪UT*/
/** 入口参数校验 */
ASSERT_RET_VALUE(NULL == ptemp,ret,0x80000000U);
@@ -3364,17 +3358,6 @@ static UINT8 elm_ConvertToUCTCheck(const EnvelopeStruct* ptemp)
; /* 不满足转为UCT条件 */
}
if (0U == errorCode)
{
/** 获取列车是否处于可追踪UT场景 */
chTrainIsIsFollowUtFlag = CheckTrainIsFollowUt(ptemp->id);
ASSER_ERROR(CI_SUCCESS == chTrainIsIsFollowUtFlag, errorCode, 0x02000000U);
}
else
{
; /* 不满足转为UCT条件 */
}
/** 设置函数返回值 */
ASSERT_SETRET(0U == errorCode,ret,CI_SUCCESS,CI_ERROR);
ASSER_DEBUG(0U != errorCode,ELM_LOG_LOC(ELM_LOG_ERROR,"errorCode:0x%08x info:ELM%d can't convert to UCT!",errorCode,ptemp->id));
TSCP/src/APP/ciapp/FloodGate/FloodGateDataManage.c
+26 -16
View File
@@ -14,6 +14,7 @@
FloodGateDataStruct FloodGateDataStru[FLOOD_GATE_SUM_MAX]; /*定义防淹门动态数据*/
FloodGateDataStructCC FloodGateDataStruCC[FLOOD_GATE_SUM_MAX]; /*定义防淹门动态数据-车车*/
/*
@@ -26,7 +27,16 @@ FloodGateDataStruct *GetFloodGateData(void)
{
return FloodGateDataStru;
}
/*
* 功能描述： 获取防淹门数据结构体指针车车
* 参数说明：
* 返回值 ：
FloodGateDataStructCC *
*/
FloodGateDataStructCC* GetFloodGateDataCC(void)
{
return FloodGateDataStruCC;
}
/*
* 功能描述： 获取指定ID防淹门开门锁闭状态
@@ -482,7 +492,7 @@ UINT8 GetFloodGateCloseApplyIvocSum(const UINT16 floodGateId)
if (0u < bufIndex)
{
reVal = FloodGateDataStru[bufIndex].FloodGateCloseApplyIvocSum;
reVal = FloodGateDataStruCC[bufIndex].FloodGateCloseApplyIvocSum;
}
else
{
@@ -505,7 +515,7 @@ void SetFloodGateCloseApplyIvocSum(const UINT16 floodGateId, const UINT8 wTrainS
if (0u < bufIndex)
{
FloodGateDataStru[bufIndex].FloodGateCloseApplyIvocSum = wTrainSum;
FloodGateDataStruCC[bufIndex].FloodGateCloseApplyIvocSum = wTrainSum;
}
else
{
@@ -527,7 +537,7 @@ UINT16* GetFloodGateCloseApplyIvocId(const UINT16 floodGateId)
if (0u < bufIndex)
{
applyIvocBuf = FloodGateDataStru[bufIndex].FloodGateCloseApplyIvocId;
applyIvocBuf = FloodGateDataStruCC[bufIndex].FloodGateCloseApplyIvocId;
}
else
{
@@ -549,11 +559,11 @@ void SetFloodGateCloseApplyIvocId(const UINT16 floodGateId, const UINT16* applyI
if (0u < bufIndex)
{
(void)CommonMemSet(FloodGateDataStru[bufIndex].FloodGateCloseApplyIvocId,
(void)CommonMemSet(FloodGateDataStruCC[bufIndex].FloodGateCloseApplyIvocId,
(UINT32)(sizeof(UINT16)*FLOOD_GATE_APPLY_TRAIN_SUM_MAX),
0U, (UINT32)(sizeof(UINT16)*FLOOD_GATE_APPLY_TRAIN_SUM_MAX)); /*先出清，防止脏数据*/
(void)CommonMemCpy(FloodGateDataStru[bufIndex].FloodGateCloseApplyIvocId, /*赋值申请的列车ID*/
(void)CommonMemCpy(FloodGateDataStruCC[bufIndex].FloodGateCloseApplyIvocId, /*赋值申请的列车ID*/
(UINT32)(sizeof(UINT16)*FLOOD_GATE_APPLY_TRAIN_SUM_MAX),
applyIvocBuf, (UINT32)(sizeof(UINT16)*FLOOD_GATE_APPLY_TRAIN_SUM_MAX));
}
@@ -574,7 +584,7 @@ FloodGateTrainAnsStruct* GetFloodGateCloseFromIvocStru(const UINT16 floodGateId)
if (0u < bufIndex)
{
retVal = FloodGateDataStru[bufIndex].FloodGateCloseFromIvocStru;
retVal = FloodGateDataStruCC[bufIndex].FloodGateCloseFromIvocStru;
}
else
{
@@ -610,7 +620,7 @@ void SetFloodGateAllowCloseFlagIVOC(UINT16 floodGateId, UINT16 wTrainId, UINT8 a
trainSumIndex = chIvocSum;
for (ii = 0U; ii < chIvocSum; ii++)
{
if (FloodGateDataStru[bufIndex].FloodGateCloseFromIvocStru[ii].wTrainId == wTrainId)
if (FloodGateDataStruCC[bufIndex].FloodGateCloseFromIvocStru[ii].wTrainId == wTrainId)
{
retVal = CI_ERROR; /*已存入过的列车,且回复了，不再存入*/
break;
@@ -619,8 +629,8 @@ void SetFloodGateAllowCloseFlagIVOC(UINT16 floodGateId, UINT16 wTrainId, UINT8 a
if (CI_SUCCESS == retVal)
{
FloodGateDataStru[bufIndex].FloodGateCloseFromIvocStru[trainSumIndex].wTrainId = wTrainId;
FloodGateDataStru[bufIndex].FloodGateCloseFromIvocStru[trainSumIndex].wFloodGateCloseIvocFlag = agreeFlag; /*检查标志的时候，查所有起始周期询问的列车是否都回复了同意*/
FloodGateDataStruCC[bufIndex].FloodGateCloseFromIvocStru[trainSumIndex].wTrainId = wTrainId;
FloodGateDataStruCC[bufIndex].FloodGateCloseFromIvocStru[trainSumIndex].wFloodGateCloseIvocFlag = agreeFlag; /*检查标志的时候，查所有起始周期询问的列车是否都回复了同意*/
chIvocSum++;
SetFloodGateCloseAnsIvocSum(floodGateId, chIvocSum);
}
@@ -653,8 +663,8 @@ void ClearFloodGateAllowClosFlagIVOC(UINT16 floodGateId)
{
for (ii = 0U; ii < chIvocSum; ii++)
{
FloodGateDataStru[bufIndex].FloodGateCloseFromIvocStru[ii].wTrainId = 0U;
FloodGateDataStru[bufIndex].FloodGateCloseFromIvocStru[ii].wFloodGateCloseIvocFlag = FLOOD_GATE_NOT_ALLOWCLOSE_IVOC;
FloodGateDataStruCC[bufIndex].FloodGateCloseFromIvocStru[ii].wTrainId = 0U;
FloodGateDataStruCC[bufIndex].FloodGateCloseFromIvocStru[ii].wFloodGateCloseIvocFlag = FLOOD_GATE_NOT_ALLOWCLOSE_IVOC;
}
SetFloodGateCloseAnsIvocSum(floodGateId, 0U);
}
@@ -674,7 +684,7 @@ UINT8 GetFloodGateAccessUTFlag(const UINT16 floodGateId)
if (0u < bufIndex)
{
reVal = FloodGateDataStru[bufIndex].FloodGateAccessUTFlag;
reVal = FloodGateDataStruCC[bufIndex].FloodGateAccessUTFlag;
}
else
{
@@ -699,7 +709,7 @@ void SetFloodGateAccessUTFlag(const UINT16 floodGateId, const UINT8 accessUTFlag
{
if ((FLOOD_GATE_ACCESS_UT_YES == accessUTFlag) || (FLOOD_GATE_ACCESS_UT_NO == accessUTFlag))
{/*混跑或者纯CT跑*/
FloodGateDataStru[bufIndex].FloodGateAccessUTFlag = accessUTFlag;
FloodGateDataStruCC[bufIndex].FloodGateAccessUTFlag = accessUTFlag;
}
}
else
@@ -722,7 +732,7 @@ UINT8 GetFloodGateCloseAnsIvocSum(const UINT16 floodGateId)
if (0u < bufIndex)
{
reVal = FloodGateDataStru[bufIndex].FloodGateCloseAnsIvocSum;
reVal = FloodGateDataStruCC[bufIndex].FloodGateCloseAnsIvocSum;
}
else
{
@@ -745,7 +755,7 @@ void SetFloodGateCloseAnsIvocSum(const UINT16 floodGateId, const UINT8 wTrainSum
if (0u < bufIndex)
{
FloodGateDataStru[bufIndex].FloodGateCloseAnsIvocSum = wTrainSum;
FloodGateDataStruCC[bufIndex].FloodGateCloseAnsIvocSum = wTrainSum;
}
else
{
TSCP/src/APP/ciapp/FloodGate/FloodGateDataManage.h
+15 -6
View File
@@ -50,21 +50,23 @@ typedef struct S_FloodGateDataStruct
* 条件1为当前关门请求为是，且条件2满足，当前同意关门状态才为同意；
*/
UINT8 CurAgreeCloseStateOut; /*当前同意关门输出状态（动态字段）:FLOOD_GATE_AGREE_CLOSE、FLOOD_GATE_NOT_AGREE_CLOSE*/
UINT32 CurYGJCrossLineStartCount;/*当前YGJ混线开始时间*/
UINT32 CurFloodGateDelayCloseStartCyc; /*防淹门接近区段占压延时关门开始时间*/
} FloodGateDataStruct;
/*防淹门数据结构体*/
typedef struct S_FloodGateDataStructCC
{
UINT16 FloodGateId; /*防淹门ID (初始化字段)*/
UINT8 FloodGateCloseApplyIvocSum; /*防淹门关门申请列车数量*/
UINT16 FloodGateCloseApplyIvocId[FLOOD_GATE_APPLY_TRAIN_SUM_MAX]; /*防淹门关门申请列车ID*/
UINT8 FloodGateCloseAnsIvocSum; /*防淹门关门允许，列车回复数量*/
FloodGateTrainAnsStruct FloodGateCloseFromIvocStru[FLOOD_GATE_APPLY_TRAIN_SUM_MAX]; /*列车同意防淹门关门请求结构体*/
UINT8 FloodGateAccessUTFlag; /*防淹门接近区段是否有非通信车标志*/
} FloodGateDataStruct;
}FloodGateDataStructCC;
/*******************************全局变量声明*******************************/
extern FloodGateDataStruct FloodGateDataStru[FLOOD_GATE_SUM_MAX]; /*定义防淹门动态数据*/
extern FloodGateDataStructCC FloodGateDataStruCC[FLOOD_GATE_SUM_MAX]; /*定义防淹门动态数据-车车*/
/*
* 功能描述： 获取防淹门数据结构体指针
* 参数说明：
@@ -72,6 +74,13 @@ extern FloodGateDataStruct FloodGateDataStru[FLOOD_GATE_SUM_MAX]; /*
FloodGateDataStruct *
*/
FloodGateDataStruct *GetFloodGateData(void);
/*
* 功能描述： 获取防淹门数据结构体指针车车
* 参数说明：
* 返回值 ：
FloodGateDataStructCC *
*/
FloodGateDataStructCC* GetFloodGateDataCC(void);
/*
* 功能描述： 获取指定ID防淹门开门锁闭状态
TSCP/src/APP/ciapp/Garagedoor/GaragedoorDataManage.c
+17 -8
View File
@@ -14,7 +14,7 @@
#include "WLScreenDataPrepare.h"
GaragedoorDataStruct GaragedoorDataStru[GARAGE_DOOR_SUM_MAX]; /*定义车库门数据结构体*/
GaragedoorDataStructCC GaragedoorDataStruCC[GARAGE_DOOR_SUM_MAX]; /*定义车库门数据结构体-车车*/
/*
* 功能描述： 获取指定车库门数据
@@ -26,7 +26,16 @@ GaragedoorDataStruct *GetGaragedoorData(void)
{
return GaragedoorDataStru;
}
/*
* 功能描述： 获取指定车库门数据-车车
* 参数说明：
* 返回值 ：
GaragedoorDataStructCC *
*/
GaragedoorDataStructCC* GetGaragedoorDataCC(void)
{
return GaragedoorDataStruCC;
}
/*
* 功能描述： 获取指定ID车库门状态
* 参数说明： const UINT16 garagedoorId, 车库门ID
@@ -143,7 +152,7 @@ UINT8 GetGaragedoorAllowCloseFlagIVOC(const UINT16 garagedoorId)
if (bufIndex < GARAGE_DOOR_SUM_MAX)
{
reVal = GaragedoorDataStru[bufIndex].GDAllowCloseFlagIVOC;
reVal = GaragedoorDataStruCC[bufIndex].GDAllowCloseFlagIVOC;
}
return reVal;
@@ -167,7 +176,7 @@ void SetGaragedoorAllowCloseFlagIVOC(const UINT16 garagedoorId, const UINT8 allo
if ((GARAGE_DOOR_ALLOW_CLOSE_YES == allowCloseFlag) || (GARAGE_DOOR_ALLOW_CLOSE_NO == allowCloseFlag))
{
GaragedoorDataStru[bufIndex].GDAllowCloseFlagIVOC = allowCloseFlag; /*允许关门标志*/
GaragedoorDataStruCC[bufIndex].GDAllowCloseFlagIVOC = allowCloseFlag; /*允许关门标志*/
}
}
@@ -190,7 +199,7 @@ UINT16 GetGaragedoorNearestTrainId(const UINT16 garagedoorId)
if (bufIndex < GARAGE_DOOR_SUM_MAX)
{
reVal = GaragedoorDataStru[bufIndex].GDAkuNearestTrainId;
reVal = GaragedoorDataStruCC[bufIndex].GDAkuNearestTrainId;
}
return reVal;
@@ -215,7 +224,7 @@ void SetGaragedoorNearestTrainId(const UINT16 garagedoorId, const UINT16 trainId
if (UINT16_MAX!= trainId)
{
GaragedoorDataStru[bufIndex].GDAkuNearestTrainId = trainId; /*允许关门标志*/
GaragedoorDataStruCC[bufIndex].GDAkuNearestTrainId = trainId; /*允许关门标志*/
}
}
@@ -561,7 +570,7 @@ void SetWaiteIVOCResponseStartCycNum(const UINT16 garagedoorId, const UINT32 sta
if (bufIndex < GARAGE_DOOR_SUM_MAX)
{
GaragedoorDataStru[bufIndex].waiteIVOCResponseStartCycNum = startCycNum; /*起始周期号*/
GaragedoorDataStruCC[bufIndex].waiteIVOCResponseStartCycNum = startCycNum; /*起始周期号*/
}
}
@@ -581,7 +590,7 @@ UINT32 GetWaiteIVOCResponseStartCycNum(const UINT16 garagedoorId)
if (bufIndex < GARAGE_DOOR_SUM_MAX)
{
ret = GaragedoorDataStru[bufIndex].waiteIVOCResponseStartCycNum;
ret = GaragedoorDataStruCC[bufIndex].waiteIVOCResponseStartCycNum;
}
return ret;
TSCP/src/APP/ciapp/Garagedoor/GaragedoorDataManage.h
+18 -5
View File
@@ -32,8 +32,7 @@ typedef struct S_GaragedoorDataStruct
UINT16 GaragedoorId; /*车库门ID (初始化字段)*/
UINT8 GaragedoorState; /*车库门状态 (动态字段)*/
UINT8 GaragedoorAllowCloseFlag; /*车库门允许关门标志，ZC发送*/
UINT8 GDAllowCloseFlagIVOC; /*车库门允许关门标志，IVOC发送*/
UINT16 GDAkuNearestTrainId; /*A库物理区段上最接近的列车*/
UINT8 GaragedoorModeState; /*车库门模式状态*/
UINT8 GaragedoorFaultState; /*车库门故障状态*/
UINT8 GaragedoorPangLuState; /*车库门旁路状态*/
@@ -41,14 +40,21 @@ typedef struct S_GaragedoorDataStruct
UINT8 cmdProcessState; /* 命令处理状态 */
UINT32 drvDoorStartCycle; /* 驱动开始时间,预留 */
UINT32 waiteZCResponseStartCycNum; /*等待ZC反馈开始时间*/
UINT32 waiteIVOCResponseStartCycNum; /*等待IVOC反馈开始时间*/
UINT32 GaragedoorOpenStartCycNum; /*车库门打开开始周期 (动态字段)*/
UINT32 GaragedoorCloseStartCycNum; /*车库门关闭开始周期 (动态字段)*/
} GaragedoorDataStruct;
/*车库门数据结构体*/
typedef struct S_GaragedoorDataStructCC
{
UINT16 GaragedoorId; /*车库门ID (初始化字段)*/
UINT8 GDAllowCloseFlagIVOC; /*车库门允许关门标志，IVOC发送*/
UINT16 GDAkuNearestTrainId; /*A库物理区段上最接近的列车*/
UINT32 waiteIVOCResponseStartCycNum; /*等待IVOC反馈开始时间*/
}GaragedoorDataStructCC;
extern GaragedoorDataStruct GaragedoorDataStru[GARAGE_DOOR_SUM_MAX]; /*定义车库门数据结构体*/
extern GaragedoorDataStructCC GaragedoorDataStruCC[GARAGE_DOOR_SUM_MAX]; /*定义车库门数据结构体-车车*/
/*
* 功能描述： 获取指定车库门数据
* 参数说明：
@@ -56,6 +62,13 @@ extern GaragedoorDataStruct GaragedoorDataStru[GARAGE_DOOR_SUM_MAX]; /*
GaragedoorDataStruct *
*/
GaragedoorDataStruct *GetGaragedoorData(void);
/*
* 功能描述： 获取指定车库门数据-车车
* 参数说明：
* 返回值 ：
GaragedoorDataStructCC *
*/
GaragedoorDataStructCC* GetGaragedoorDataCC(void);
/*
* 功能描述： 获取指定ID车库门驱动状态
TSCP/src/APP/ciapp/HLHTMsgHead/HLHTCommonDataPacketHead.c
+39 -2
View File
@@ -93,7 +93,7 @@ UINT8 HLHTRecvCommonPacketHeadCheck(UINT16 LocalDevName, UINT16 RemoteDevName, U
UINT32 LocalEtcsId = 0u; /*发送方标识*/
UINT32 RemoteEtcsId = 0u; /*接收方标识*/
UINT32 emapVer = 0U;/*应该使用的电子地图版本*/
UINT8 emapCheckVer = 0U; /*电子地图版本校验结果*/
UINT8 emapCheckVer = CI_ERROR; /*电子地图版本获取结果*/
UINT8 chRet = 0U;
/*错误码每次都清零*/
@@ -109,6 +109,29 @@ UINT8 HLHTRecvCommonPacketHeadCheck(UINT16 LocalDevName, UINT16 RemoteDevName, U
;
}
if ((CI_SYSTEM_TYPE_OC == devType) || (CI_SYSTEM_TYPE_XIANDI == devType) || (CI_SYSTEM_TYPE_ATS == devType))
{
/*OC/现地/ATS无互联互通ID*/
if ((UINT16)(pMICommonPackage->sourceId & 0x0000FFFFU) != LocalDevName)
{
*pErrorCode |= GAL_COMPARE_SEND_FLAG_ERR;
}
else
{
;
}
if((UINT16)(pMICommonPackage->destId & 0x0000FFFFU) != RemoteDevName)
{
*pErrorCode |= GAL_COMPARE_RECV_FLAG_ERR;
}
else
{
;
}
}
else
{
/*发送方校验*/
chRet = dquDevName2HlhtId(LocalDevName, logId, &LocalEtcsId);
if ((CI_ERROR == chRet) || (pMICommonPackage->sourceId != LocalEtcsId))
@@ -119,7 +142,6 @@ UINT8 HLHTRecvCommonPacketHeadCheck(UINT16 LocalDevName, UINT16 RemoteDevName, U
{
;
}
/*接收方校验*/
chRet = dquDevName2HlhtId(RemoteDevName, logId, &RemoteEtcsId);
if ((CI_ERROR == chRet) || (pMICommonPackage->destId != RemoteEtcsId))
@@ -130,8 +152,23 @@ UINT8 HLHTRecvCommonPacketHeadCheck(UINT16 LocalDevName, UINT16 RemoteDevName, U
{
;
}
}
if ((CI_SYSTEM_TYPE_CI == devType) || (CI_SYSTEM_TYPE_RC == devType))
{
/*修改：根据发送方类型获取电子地图校验*/
emapVer = GetCiTranCiDataCheckVer((UINT8)(RemoteDevName & 0x00FFU), LocalDevName);
emapCheckVer = CI_SUCCESS;
}
else if (CI_SYSTEM_TYPE_OC == devType)
{
emapVer = GetCiTranOcDataCheckVer((UINT8)(RemoteDevName & 0x00FFU), LocalDevName);
emapCheckVer = CI_SUCCESS;
}
else
{
emapCheckVer = GetCiEmapCheckVer((UINT8)RemoteDevName, &emapVer, devType);
}
if (CI_SUCCESS == emapCheckVer)
{
/*电子地图版本校验信息(4字节CRC比较)*/
TSCP/src/APP/ciapp/HLHTMsgHead/HLHTHeadContexManage.c
+166 -22
View File
@@ -15,15 +15,22 @@
#include "../2oo2/2oo2InterfaceDataManage.h"
#include "CommonMemory.h"
HLHTHeadContextStru ciHLHTHeadCtxs[CI_SUM_MAX]={0};/*存放与本CI通信的相邻CI互联互通报文头上下文数据*/
HLHTHeadContextStru vobcHLHTHeadCtxs[VOBC_SUM_MAX]={0};/*存放与本CI通信的VOBC互联互通报文头上下文数据*/
HLHTHeadContextStru vobcBackupHLHTHeadCtxs[VOBC_BACKUP_SUM_MAX] = { 0 };/*存放与本CI通信的后备模式VOBC互联互通报文头上下文数据*/
HLHTHeadContextStru zcHLHTHeadCtxs[ZC_SUM_MAX]={0};/*存放与本CI通信的ZC互联互通报文头上下文数据*/
HLHTHeadContextStru ocHLHTHeadCtxs[OC_SUM_MAX]={0};/*存放与本CI通信的OC互联互通报文头上下文数据*/
HLHTHeadContextStru axleHLHTHeadCtxs[AXLE_SUM_MAX] = { 0 };/*存放与本CI通信的计轴系统互联互通报文头上下文数据*/
HLHTHeadContextStru tmcHLHTHeadCtxs[TMC_SUM_MAX] = { 0 };/*存放与本TIOC通信的TMC互联互通报文头上下文数据*/
HLHTHeadContextStru ciHLHTHeadCtxs[CI_SUM_MAX]={0U};/*存放与本控区通信的相邻CI互联互通报文头上下文数据*/
HLHTHeadContextStru gSzRcHLHTHeadCtxs[CI_SUM_MAX] = { 0U }; /*存放与本控区通信的相邻RC互联互通报文头上下文数据*/
HLHTHeadContextStru ciHLHTHeadCtxsCiToRc[CI_SUM_MAX] = { 0U };/*存放本控区CI同步的相邻CI互联互通报文头上下文数据*/
HLHTHeadContextStru gSzRcHLHTHeadCtxsCiToRc[CI_SUM_MAX] = { 0U }; /*存放本控区CI同步的相邻RC互联互通报文头上下文数据*/
HLHTHeadContextStru vobcHLHTHeadCtxs[VOBC_SUM_MAX]={0U};/*存放与本CI通信的VOBC互联互通报文头上下文数据*/
HLHTHeadContextStru vobcBackupHLHTHeadCtxs[VOBC_BACKUP_SUM_MAX] = { 0U };/*存放与本CI通信的后备模式VOBC互联互通报文头上下文数据*/
HLHTHeadContextStru zcHLHTHeadCtxs[ZC_SUM_MAX]={0U};/*存放与本CI通信的ZC互联互通报文头上下文数据*/
HLHTHeadContextStru ocHLHTHeadCtxs[OC_SUM_MAX]={0U};/*存放与本CI通信的OC互联互通报文头上下文数据*/
HLHTHeadContextStru ocHLHTHeadCtxsCiToRc[OC_SUM_MAX] = { 0U };/*存放同步的CI通-OC互联互通报文头上下文数据*/
HLHTHeadContextStru axleHLHTHeadCtxs[AXLE_SUM_MAX] = { 0U };/*存放与本CI通信的计轴系统互联互通报文头上下文数据*/
HLHTHeadContextStru gSzRcAxleHLHTHeadCtxs[AXLE_SUM_MAX] = { 0U };/*存放与RC通信的计轴系统互联互通报文头上下文数据*/
HLHTHeadContextStru tmcHLHTHeadCtxs[TMC_SUM_MAX] = { 0U };/*存放与本TIOC通信的TMC互联互通报文头上下文数据*/
HLHTHeadContextStru IteHLHTHeadCtxs[ITE_SUM_MAX][VOBC_INC_ITE_SUM_MAX] = { 0U };/*存放与本TIOC通信的ITE互联互通报文头上下文数据*/
HLHTHeadContextStru gSzXiandiHLHTHeadCtxs[ATS_SUM_MAX] = { 0U };/*存放与本CI通信的现地互联互通报文头上下文数据*/
HLHTHeadContextStru gSzAtsHLHTHeadCtxs[ATS_SUM_MAX] = { 0U };/*存放与本CI通信的ATS互联互通报文头上下文数据*/
HLHTHeadContextStru vobcToRcHLHTHeadCtxs[VOBC_SUM_MAX] = { 0 };/*RC模式下，存放与本RC通信的510 VOBC互联互通报文头上下文数据。CI模式下不使用*/
/*
* 功能描述:本地函数，获得某种设备类型的用于后续运算的互联互通头上下文数据
* 参数说明:
@@ -417,6 +424,7 @@ void ProcHlhtHeadCtxTimeOut(void)
{
UINT32 timeoutSnCount = 0U;
UINT32 timeoutSpan = 0U;
UINT8 chSystemWorkType = GetSystemWorkType();; /*系统工作类型*/
/*处理VOBC通用报文头的时效性*/
timeoutSnCount = GetCiAndVobcTransBadEnsureCnt();
@@ -436,6 +444,11 @@ void ProcHlhtHeadCtxTimeOut(void)
timeoutSpan = GetCiAndCiTransmitBadEnsureTime();
ProcHlhtHeadCtxTimeOutDiffSys(timeoutSnCount, timeoutSpan, ciHLHTHeadCtxs, CI_SUM_MAX);
/*处理RC通用报文头的时效性*/
timeoutSnCount = GetCiAndCiTransBadEnsureCnt();
timeoutSpan = GetCiAndCiTransmitBadEnsureTime();
ProcHlhtHeadCtxTimeOutDiffSys(timeoutSnCount, timeoutSpan, gSzRcHLHTHeadCtxs, CI_SUM_MAX);
/*处理与CI通信的ZC通用报文头的时效性*/
timeoutSnCount = GetCiAndZcTransBadEnsureCnt();
timeoutSpan = GetCiAndZcTransmitBadEnsureTime();
@@ -451,10 +464,38 @@ void ProcHlhtHeadCtxTimeOut(void)
timeoutSpan = GetCiAndOcTransmitBadEnsureTime();
ProcHlhtHeadCtxTimeOutDiffSys(timeoutSnCount, timeoutSpan, ocHLHTHeadCtxs, OC_SUM_MAX);
#if 0
/*不需要处理CI同步过来的数据 需要留着周期号用来做接收数据判断*/
ProcHlhtHeadCtxTimeOutDiffSys(timeoutSnCount, timeoutSpan, ocHLHTHeadCtxsCiToRc, OC_SUM_MAX);
#endif
/*处理与AXLE通信报文头的时效性*/
timeoutSnCount = GetCiAndAxleTransBadEnsureCnt();
timeoutSpan = GetCiAndAxleTransBadEnsureTime();
ProcHlhtHeadCtxTimeOutDiffSys(timeoutSnCount, timeoutSpan, axleHLHTHeadCtxs, AXLE_SUM_MAX);
if ((SYSTEM_WORK_MODE_ALL == chSystemWorkType) && (RC_WORK_MODE_TIOC == CI_SYSTEM_TYPE_RCI))
{
/*双系统RC还需要处理RC通用报文头*/
ProcHlhtHeadCtxTimeOutDiffSys(timeoutSnCount, timeoutSpan, gSzRcAxleHLHTHeadCtxs, AXLE_SUM_MAX);
}
else
{
;
}
/*处理与现地通信报文头的时效性*/
timeoutSnCount = GetCiAndAtsTransBadEnsureCnt();
timeoutSpan = GetCiAndAtsTransBadEnsureTime();
ProcHlhtHeadCtxTimeOutDiffSys(timeoutSnCount, timeoutSpan, gSzXiandiHLHTHeadCtxs, ATS_SUM_MAX);
/*处理与ATS通信报文头的时效性*/
timeoutSnCount = GetCiAndAtsTransBadEnsureCnt();
timeoutSpan = GetCiAndAtsTransBadEnsureTime();
ProcHlhtHeadCtxTimeOutDiffSys(timeoutSnCount, timeoutSpan, gSzAtsHLHTHeadCtxs, ATS_SUM_MAX);
/*处理VOBC通用报文头的时效性*/
timeoutSnCount = GetCiAndVobcTransBadEnsureCnt();
timeoutSpan = GetCiAndVobcTransBadEnsureTime();
ProcHlhtHeadCtxTimeOutDiffSys(timeoutSnCount, timeoutSpan, vobcToRcHLHTHeadCtxs, VOBC_SUM_MAX);
}
/*
* 功能描述： 根据设备类型，获得具备初始通信互联互通头的所有设备ID
@@ -537,15 +578,40 @@ static UINT8 GetHLHTHeadCtxTmepVars(const UINT8 devType, UINT16 *devMaxSum, HLHT
UINT8 retVal = CI_ERROR;
UINT16 maxDevSum = 0u;
HLHTHeadContextStru *tempHeadCtxPtr = NULL;
UINT8 chSystemWorkType = GetSystemWorkType();/*系统工作类型*/
UINT8 cRcWorkMode = 0U;/*本系统当前工作模式*/
if ((CI_SYSTEM_TYPE_CI == devType))
cRcWorkMode = GetLocalRcWorkMode();
if (CI_SYSTEM_TYPE_CI == devType)
{
maxDevSum = CI_SUM_MAX;
tempHeadCtxPtr = ciHLHTHeadCtxs;
retVal = CI_SUCCESS;
}
else if (CI_SYSTEM_TYPE_RC == devType)
{
maxDevSum = CI_SUM_MAX;
tempHeadCtxPtr = gSzRcHLHTHeadCtxs;
retVal = CI_SUCCESS;
}
else if (CI_SYSTEM_TYPE_VOBC == devType)
{
maxDevSum = VOBC_SUM_MAX;
if (RC_WORK_MODE_CI == cRcWorkMode)
{
tempHeadCtxPtr = vobcHLHTHeadCtxs;
}
else
{/*RC模式下*/
tempHeadCtxPtr = vobcToRcHLHTHeadCtxs;
}
retVal = CI_SUCCESS;
}
else if (CI_SYSTEM_TYPE_IVOC == devType)
{
maxDevSum = VOBC_SUM_MAX;
tempHeadCtxPtr = vobcHLHTHeadCtxs;
@@ -576,7 +642,14 @@ static UINT8 GetHLHTHeadCtxTmepVars(const UINT8 devType, UINT16 *devMaxSum, HLHT
else if (CI_SYSTEM_TYPE_AXIS == devType)
{
maxDevSum = AXLE_SUM_MAX;
if((SYSTEM_WORK_MODE_ALL == chSystemWorkType) && (RC_WORK_MODE_TIOC == CI_SYSTEM_TYPE_RCI))
{
tempHeadCtxPtr = gSzRcAxleHLHTHeadCtxs;
}
else
{
tempHeadCtxPtr = axleHLHTHeadCtxs;
}
retVal = CI_SUCCESS;
}
@@ -587,6 +660,20 @@ static UINT8 GetHLHTHeadCtxTmepVars(const UINT8 devType, UINT16 *devMaxSum, HLHT
retVal = CI_SUCCESS;
}
else if (CI_SYSTEM_TYPE_XIANDI == devType)
{
maxDevSum = ATS_SUM_MAX;
tempHeadCtxPtr = gSzXiandiHLHTHeadCtxs;
retVal = CI_SUCCESS;
}
else if (CI_SYSTEM_TYPE_ATS == devType)
{
maxDevSum = ATS_SUM_MAX;
tempHeadCtxPtr = gSzAtsHLHTHeadCtxs;
retVal = CI_SUCCESS;
}
else
{
retVal = CI_ERROR;
@@ -614,7 +701,7 @@ static void ProcHlhtHeadCtxTimeOutDiffSys(const UINT32 timeoutSnCount, const UIN
HLHTHeadContextStru tempHeadCtx = { 0u };
UINT8 headValid = 0u;
INT32 remainValidiy;/*剩余的时间*/
UINT8 chRcID = 0U;
if (NULL != headCtxs)
{
for (i = 0u;i < headCount;i++)
@@ -651,23 +738,11 @@ static void ProcHlhtHeadCtxTimeOutDiffSys(const UINT32 timeoutSnCount, const UIN
}
if (0u == headValid)
{
if (headCtxs == axleHLHTHeadCtxs) /*计轴系统中断时,GAL层对方序号,收到对方数据时本方序号,设置0xFFFFFFFF*/
{
headCtxs[i].logId = 0u;
headCtxs[i].sourceRecvOppMsgSN = 0u;
headCtxs[i].sourcePreOwnMsgSN = 0u;
headCtxs[i].sourceComPeriod = 0u;
headCtxs[i].sourceCrntOwnMsgSN = 0xFFFFFFFFu;
headCtxs[i].ciPreRecvOwnSn = 0xFFFFFFFFu;
}
else
{
(void)CommonMemSet(&(headCtxs[i]), (UINT32)sizeof(HLHTHeadContextStru), 0u, (UINT32)sizeof(HLHTHeadContextStru));
headCtxs[i].sourceCrntOwnMsgSN = 0xFFFFFFFFu;
headCtxs[i].ciPreRecvOwnSn = 0xFFFFFFFFu;
}
}
else
{
; /*不处理*/
@@ -1183,3 +1258,72 @@ void ProcIteHlhtHeadCtxTimeOut(const UINT32 dwTimeoutSnCount, const UINT32 dwTim
}
}
}
/*
* 功能描述：获取指定oc的CI-RC同步互联互通报文头上下文数据
* 参数说明：const UINT8 oc ID
* 返 回 值：NULL 获取数据失败
* 非NULL 获取数据成功
* Created By fan 2025.11.12
*/
HLHTHeadContextStru* GetCiToRcHLHTOcHeadCtx(const UINT8 ocId)
{
HLHTHeadContextStru* pstrRetVal = NULL;
if ((0U < ocId) && (OC_SUM_MAX > ocId))
{
pstrRetVal = &ocHLHTHeadCtxsCiToRc[ocId];
}
else
{
/*不处理*/
}
return pstrRetVal;
}
/*
* 功能描述：获取指定CI的CI-RC同步CI互联互通报文头上下文数据
* 参数说明：const UINT8 chDevId 设备ID
* 返 回 值：NULL 获取数据失败
* 非NULL 获取数据成功
* Created By fan 2025.12.31
*/
HLHTHeadContextStru* GetCiToRcWithCiHeadCtx(const UINT8 chDevId)
{
HLHTHeadContextStru* pstrRetVal = NULL;
if ((0U < chDevId) && (CI_SUM_MAX > chDevId))
{
pstrRetVal = &ciHLHTHeadCtxsCiToRc[chDevId];
}
else
{
/*不处理*/
}
return pstrRetVal;
}
/*
* 功能描述：获取指定CI的CI-RC同步RC互联互通报文头上下文数据
* 参数说明：const UINT8 chDevId 设备ID
* 返 回 值：NULL 获取数据失败
* 非NULL 获取数据成功
* Created By fan 2025.12.31
*/
HLHTHeadContextStru* GetCiToRcWithRcHeadCtx(const UINT8 chDevId)
{
HLHTHeadContextStru* pstrRetVal = NULL;
if ((0U < chDevId) && (CI_SUM_MAX > chDevId))
{
pstrRetVal = &gSzRcHLHTHeadCtxsCiToRc[chDevId];
}
else
{
/*不处理*/
}
return pstrRetVal;
}
TSCP/src/APP/ciapp/HLHTMsgHead/HLHTHeadContexManage.h
+34 -2
View File
@@ -38,15 +38,22 @@ extern "C" {
} HLHTHeadContextStru;
/*******************************全局变量声明*******************************/
extern HLHTHeadContextStru ciHLHTHeadCtxs[CI_SUM_MAX];/*存放与本CI通信的相邻CI互联互通报文头上下文数据*/
extern HLHTHeadContextStru ciHLHTHeadCtxs[CI_SUM_MAX];/*存放与本控区通信的相邻CI互联互通报文头上下文数据*/
extern HLHTHeadContextStru gSzRcHLHTHeadCtxs[CI_SUM_MAX]; /*存放与本控区通信的相邻RC互联互通报文头上下文数据*/
extern HLHTHeadContextStru ciHLHTHeadCtxsCiToRc[CI_SUM_MAX];/*存放与本控区通信的相邻CI互联互通报文头上下文数据*/
extern HLHTHeadContextStru gSzRcHLHTHeadCtxsCiToRc[CI_SUM_MAX]; /*存放与本控区通信的相邻RC互联互通报文头上下文数据*/
extern HLHTHeadContextStru vobcHLHTHeadCtxs[VOBC_SUM_MAX];/*存放与本CI通信的VOBC互联互通报文头上下文数据*/
extern HLHTHeadContextStru vobcBackupHLHTHeadCtxs[VOBC_BACKUP_SUM_MAX];/*存放与本CI通信的后备模式VOBC互联互通报文头上下文数据*/
extern HLHTHeadContextStru zcHLHTHeadCtxs[ZC_SUM_MAX];/*存放与本CI通信的ZC互联互通报文头上下文数据*/
extern HLHTHeadContextStru ocHLHTHeadCtxs[OC_SUM_MAX];/*存放与本CI通信的OC互联互通报文头上下文数据*/
extern HLHTHeadContextStru ocHLHTHeadCtxsCiToRc[OC_SUM_MAX];/*存放与本CI通信的OC互联互通报文头上下文数据*/
extern HLHTHeadContextStru axleHLHTHeadCtxs[AXLE_SUM_MAX];/*存放与本CI通信的计轴系统互联互通报文头上下文数据*/
extern HLHTHeadContextStru gSzRcAxleHLHTHeadCtxs[AXLE_SUM_MAX];/*存放与RC通信的计轴系统互联互通报文头上下文数据*/
extern HLHTHeadContextStru tmcHLHTHeadCtxs[TMC_SUM_MAX];/*存放与本TIOC通信的TMC互联互通报文头上下文数据*/
extern HLHTHeadContextStru IteHLHTHeadCtxs[ITE_SUM_MAX][VOBC_INC_ITE_SUM_MAX];/*存放与本TIOC通信的ITE互联互通报文头上下文数据*/
extern HLHTHeadContextStru gSzXiandiHLHTHeadCtxs[ATS_SUM_MAX]; /*存放与本CI通信的现地互联互通报文头上下文数据*/
extern HLHTHeadContextStru gSzAtsHLHTHeadCtxs[ATS_SUM_MAX]; /*存放与本CI通信的ATS互联互通报文头上下文数据*/
extern HLHTHeadContextStru vobcToRcHLHTHeadCtxs[VOBC_SUM_MAX];/*RC模式下，存放与本RC通信的510 VOBC互联互通报文头上下文数据。CI模式下不使用*/
/*
* 功能描述:获取某个设备最近一次给CI发送数据时其当前的序号
* 参数说明:
@@ -285,6 +292,31 @@ extern "C" {
* Created By LQ 2024.06.11
*/
void ProcIteHlhtHeadCtxTimeOut(const UINT32 dwTimeoutSnCount, const UINT32 dwTimeoutSpan);
/*
* 功能描述：获取指定oc的CI-RC同步互联互通报文头上下文数据
* 参数说明：const UINT8 oc ID
* 返 回 值：NULL 获取数据失败
* 非NULL 获取数据成功
* Created By fan 2025.11.12
*/
HLHTHeadContextStru* GetCiToRcHLHTOcHeadCtx(const UINT8 ocId);
/*
* 功能描述：获取指定CI的CI-RC同步CI互联互通报文头上下文数据
* 参数说明：const UINT8 chDevId 设备ID
* 返 回 值：NULL 获取数据失败
* 非NULL 获取数据成功
* Created By fan 2025.12.31
*/
HLHTHeadContextStru* GetCiToRcWithCiHeadCtx(const UINT8 chDevId);
/*
* 功能描述：获取指定CI的CI-RC同步RC互联互通报文头上下文数据
* 参数说明：const UINT8 chDevId 设备ID
* 返 回 值：NULL 获取数据失败
* 非NULL 获取数据成功
* Created By fan 2025.12.31
*/
HLHTHeadContextStru* GetCiToRcWithRcHeadCtx(const UINT8 chDevId);
#ifdef __cplusplus
}
TSCP/src/APP/ciapp/IO/DeviceRelayDataProcess.c
+1586 -335
View File
File diff suppressed because it is too large Load Diff
TSCP/src/APP/ciapp/IO/DeviceRelayDataProcess.h
+150 -7
View File
@@ -137,12 +137,14 @@ void SwitchDeviceToRelayStateProc(void);
*/
void PhySecRelayToDeviceStateProc(void);
#if 0
/*
* 功能描述： 更新区段计轴复位继电器状态
* 参数说明： void
* 返回值 ： void
*/
void PhySecResetToRelayStateProc(void);
#endif
/*
* 功能描述： 更新区段计轴复位继电器状态
* 参数说明： void
@@ -354,7 +356,7 @@ void ProcessJXTCPulseInterfStopDrv(UINT16 startJXTCRelayId, UINT16 stopJXTCRelay
/******************************OC spks指示灯输出处理****************************/
/*
* 功能描述： OC spks指示灯和spks旁路指示灯输出处理
* 功能描述： OC spks指示灯、spks旁路指示灯及蜂鸣继电器处理
* 参数说明： void
* 返回值 ： void
*/
@@ -803,7 +805,7 @@ UINT8 WashMachineWorkModeRelayProc(const UINT16 washMachineId);
* CI_SUCCESS: 更新成功
* by cgh 20231113
*/
UINT8 DownWashDevToRelayStaProc(const UINT16 washMachineId);
void DownWashDevToRelayStaProc(const UINT16 washMachineId);
/*
* 功能描述： 降级模式洗车线关联进路状态检查
@@ -985,13 +987,154 @@ UINT8 GetFstDetBtnCollTolerateRet(const UINT16 wSignalId);
UINT8 GetSndDetBtnCollTolerateRet(const UINT16 wSignalId);
/*
* 功能描述：清除物理区段复位起始周期
* 参数说明：无
* 功能描述： 设置所有道岔转辙机位置
* 参数说明： UINT16 switchCurSum 道岔总数
* 返回值 ： 无
* 注：解决复位指令执行期间，总复位未按下一直下发复位指令的问题
* Created By fan 2026.03.24
*/
void CleanPhySecResetStartCycNum(void);
void SetAllSingleSwitchZzjState(UINT16 switchCurSum);
/*
* 功能描述： 指定洗车机ID降级模式洗车按钮状态更新
* 参数说明： const UINT16 washMachineId 洗车机ID
* 返回值 ： void
*/
void WashMachineButtonStateProc(const UINT16 washMachineId);
/*
* 功能描述： 指定洗车机ID降级模式请求信息处理
* 参数说明： const UINT16 washMachineId 洗车机ID
* 返回值 ： void
*/
void WashMachineApplyStateProc(const UINT16 washMachineId);
/*
* 功能描述： 指定洗车机ID降级模式洗车请求信息处理
* 参数说明： const UINT16 washMachineId 洗车机ID
* 返回值 ： void
*/
void WashMachineApplyProc(const UINT16 washMachineId);
/*
* 功能描述： 指定洗车机ID降级模式反向通过请求信息处理
* 参数说明： const UINT16 washMachineId 洗车机ID
* 返回值 ： void
*/
void WashMachinePassApplyProc(const UINT16 washMachineId);
/*
* 功能描述： 洗车线控制室更新洗车同意按钮逻辑
* 参数说明： const UINT16 washMachineId 洗车机ID
* 返回值 ： void
*/
void WashMachineButtonUpdate(const UINT16 washMachineId);
/*
* 功能描述： DCC更新洗车同意按钮逻辑
* 参数说明： const UINT16 washMachineId 洗车机ID
* 返回值 ： void
*/
void WashMachineDCCButtonUpdate(const UINT16 washMachineId);
/*
* 功能描述： 融合洗车同意状态
* 参数说明： const UINT16 washMachineId 洗车机ID
* 返回值 ： void
*/
void FusionWashMachineAllowState(const UINT16 washMachineId);
/*
* 功能描述： 洗车线控制室更新反向洗车同意按钮逻辑
* 参数说明： const UINT16 washMachineId 洗车机ID
* 返回值 ： void
*/
void WashMachinePassButtonUpdate(const UINT16 washMachineId);
/*
* 功能描述： DCC更新反向洗车同意按钮逻辑
* 参数说明： const UINT16 washMachineId 洗车机ID
* 返回值 ： void
*/
void WashMachineDCCPassButtonUpdate(const UINT16 washMachineId);
/*
* 功能描述： 融合反向通过同意按钮状态
* 参数说明： const UINT16 washMachineId 洗车机ID
* 返回值 ： void
*/
void FusionWashMachinePassAllowState(const UINT16 washMachineId);
/*
* 功能描述： 降级模式洗车线洗车请求指示灯
* 参数说明： const UINT16 washMachineId 洗车机ID
* 返回值 ：void
*/
void WashMachineApplyLight(const UINT16 washMachineId);
/*
* 功能描述： 降级模式DCC洗车请求指示灯
* 参数说明： const UINT16 washMachineId 洗车机ID
* 返回值 ：void
*/
void WashMachineDccApplyLight(const UINT16 washMachineId);
/*
* 功能描述： 降级模式洗车线洗车反向通过请求指示灯
* 参数说明： const UINT16 washMachineId 洗车机ID
* 返回值 ：void
*/
void WashMachinePassApplyLight(const UINT16 washMachineId);
/*
* 功能描述： 降级模式DCC洗车反向通过请求指示灯
* 参数说明： const UINT16 washMachineId 洗车机ID
* 返回值 ：void
*/
void WashMachineDccPassApplyLight(const UINT16 washMachineId);
/*
* 功能描述： 降级模式洗车同意指示灯
* 参数说明： const UINT16 washMachineId 洗车机ID
* 返回值 ：void
*/
void WashMachineAllowLight(const UINT16 washMachineId);
/*
* 功能描述： 降级模式DCC洗车同意指示灯
* 参数说明： const UINT16 washMachineId 洗车机ID
* 返回值 ：void
*/
void WashMachineDccAllowLight(const UINT16 washMachineId);
/*
* 功能描述： 降级模式洗车同意反向通过指示灯
* 参数说明： const UINT16 washMachineId 洗车机ID
* 返回值 ：void
*/
void WashMachinePassAllowLight(const UINT16 washMachineId);
/*
* 功能描述： 降级模式DCC洗车同意反向通过指示灯
* 参数说明： const UINT16 washMachineId 洗车机ID
* 返回值 ：void
*/
void WashMachineDccPassAllowLight(const UINT16 washMachineId);
/*
* 功能描述： 更新屏蔽门对应IBP盘发车按钮继电器状态
* 参数说明： const UINT16 wPsdId 屏蔽门ID
* 返回值 ： CI_ERROR: 更新失败
* CI_SUCCESS: 更新成功
*/
UINT8 PsdIbpRelToDevStaProc(const UINT16 wPsdId);
/*
* 功能描述：同站紧急按钮及旁路按钮状态处理
* 参数说明：void
* 返 回 值：无
* Created By LQ 2025.12.30
*/
void OnePlatEsbAndCutBtnProc(void);
#ifdef __cplusplus
}
TSCP/src/APP/ciapp/IO/InputDataProcess.c
+2443 -2042
View File
File diff suppressed because it is too large Load Diff
TSCP/src/APP/ciapp/IO/InputDataProcess.h
+81 -9
View File
@@ -128,14 +128,6 @@ void ProcessPscToCiData(void);
*/
UINT8 ProcessAtsOrXianDiToCiData(void);
/*
* 功能描述： 处理车辆段的ATS或现地到CI数据
* 参数说明： void
* 返回值 ： 0:处理失败
* 1:处理成功
*/
UINT8 ProcessAtsOrXianDiToCiDataCld(void);
/*
* 功能描述： 处理设备逻辑状态
* 参数说明： void
@@ -304,7 +296,7 @@ UINT8 CheckOrderWhetherDoing(UINT8 virCIid,UINT8 belongVirCIid,UINT8 orderType,U
* UINT8 MaskType 码位类型
* 返回值 ： 无
*/
void DealAutoReturnMask_UseVirCI(UINT16 DeviceId,UINT16*maskBuf,UINT8 MaskType,UINT16 index);
void DealAutoReturnMask(UINT16 DeviceId,UINT8* pMaskBuf,UINT8 MaskType,UINT16 index);
/*
* 功能描述： 获取全站维修点灯状态
* 参数说明： UINT8 virCIid 虚拟联锁ID
@@ -466,6 +458,86 @@ void ProcessOCToCiPsdData(void);
*/
void ProcessOcToCiRelayDiffData(void);
/*
* 功能描述：处理CI与RC间通信状态和数据
* 参数说明：void
* 返 回 值：无
* Created By LQ 2025.11.04
*/
void ProcessCiAndRcInfo(void);
/**
* @brief 保护区段解锁申请
* @param[in] 无
* @return 无
* @note by cgh 20251107
*/
void OverlapUnlockApplyDeal(void);
/**
* @brief 进路停车保证处理
* @param[in] 无
* @return 无
* @note by cgh 20251107
*/
void RouteStopensureDeal(void);
/**
* @brief 更新双系统融合数据
* @param[in] void
* @return 无
* @note by cgh 20251106
*/
void UpdateDoubleSystemMergeInfo(void);
/*
* 功能描述：逻辑区段信息融合处理
* 参数说明：无
* 返 回 值：无
* Created By LQ 2025.11.07
*/
void LogSecInfoMergePro(void);
/*
* 功能描述：雨雪信息融合处理
* 参数说明：无
* 返 回 值：无
* Created By LQ 2025.11.10
*/
void SnowInfoMergePro(void);
/**
* @brief 进路停车保证信息融合
* @param[in] void
* @return 无
* @note by cgh 20251106
*/
void RouteStopensureFlagMergeDeal(void);
/**
* @brief 信号机信息融合处理
* @param[in] void
* @return 无
* @note by cgh 20251106
*/
void SignalInfoMergeDeal(void);
/*
* 功能描述：信号机列车跨压处理
* 参数说明：无
* 返 回 值：无
* Created By LQ 2025.11.11
*/
void SignalTrainCrossPro(void);
/*
* 功能描述： 处理VOBC到CI数据
* 参数说明： void
* 返回值 ： void
*/
void ProcessIvocToRCData(void);
#ifdef __cplusplus
}
#endif
TSCP/src/APP/ciapp/IO/OutputDataProcess.c
+1153 -1069
View File
File diff suppressed because it is too large Load Diff
TSCP/src/APP/ciapp/IO/OutputDataProcess.h
+75 -6
View File
@@ -92,6 +92,7 @@ UINT8 CiToAtsBackInfoFunctionJudge(const UINT8 functionId,const UINT8 deviceType
*/
void IndicatorStateProc(void);
#if 0
/*
* 功能描述： 指示器状态处理
* 参数说明： void
@@ -99,6 +100,7 @@ void IndicatorStateProc(void);
*/
void IndicatorStateProc_UseVirCI(UINT8 virCIid);
#endif
/*
* 功能描述： 非进路继电器状态处理
* 参数说明： void
@@ -147,12 +149,7 @@ void SignaDsBreakAlarmIndicator_Vir(UINT8 virCIid,UINT8 devId);
*/
void CiToCiOutputCmdProc(void);
/*
* 功能描述： 根据无人折返指示灯的闪灯和稳灯状态驱动继电器或设置状态
* 参数说明： 无
* 返回值 ： 无
*/
static void AutoRtnIndictStatusProc_VirCI(void);
/*
* 功能描述： 获取组合自动进路所属虚拟联锁ID
* 参数说明： groupAutoRouteId 组合自动进路的ID
@@ -456,6 +453,78 @@ UINT8 FindRouteLeaveAxis(const UINT16 routeId);
*/
void RtnRealyAdhesionStatePro(void);
/*
* 功能描述： 获取人工解锁保护区段剩余倒计时
* 参数说明： const UINT16 overlapId 保护区段id
* 返回值 ： 倒计时
* by cgh 20250928
*/
UINT16 GetOverlapLaborUnlockBackTime(const UINT16 overlapId);
/*
* 功能描述： 设置联锁I系II系工作状态指示灯
* 参数说明： const UINT16 wFIndicatorId I系指示灯id
* const UINT16 wSIndicatorId II系指示灯id
* 返回值 ： 无
* by lyj 20260105
*/
void SetWorkStatusIndicator(const UINT16 wFIndicatorId, const UINT16 wSIndicatorId);
/*
* 功能描述： 设置信号故障关闭指示灯
* 参数说明： const UINT16 wIndicatorId 指示灯id
* 返回值 ： 无
* by lyj 20260105
*/
void SetSigFaultCloseIndicator(const UINT16 wIndicatorId);
/*
* 功能描述： 设置道岔挤岔指示灯
* 参数说明： const UINT16 wIndicatorId 指示灯id
* 返回值 ： 无
* by lyj 20260105
*/
void SetSwitchJiChaIndicator(const UINT16 wIndicatorId);
/*
* 功能描述： 设置车库门故障指示灯
* 参数说明： const UINT16 wIndicatorId 指示灯id
* 返回值 ： 无
* by lyj 20260105
*/
void SetGDoorFaultIndicator(const UINT16 wIndicatorId);
/*
* 功能描述： 设置继电器混线指示灯
* 参数说明： const UINT16 wIndicatorId 指示灯id
* 返回值 ： 无
* by lyj 20260105
*/
void SetRealyHunXianIndicator(const UINT16 wIndicatorId);
/*
* 功能描述： 设置应急盘指示灯
* 参数说明： const UINT16 wIndicatorId 指示灯id
* 返回值 ： 无
* by lyj 20260106
*/
void SetYjpIndicator(const UINT16 wIndicatorId);
/*
* 功能描述： 设置试车请求指示灯
* 参数说明： const UINT16 wIndicatorId 指示灯id
* 返回值 ： 无
* by lyj 20260106
*/
void SetSCApplyIndicator(const UINT16 wIndicatorId);
/*
* 功能描述： 设置试车同意指示灯
* 参数说明： const UINT16 wIndicatorId 指示灯id
* 返回值 ： 无
* by lyj 20260106
*/
void SetSCAllowIndicator(const UINT16 wIndicatorId);
/*
* 功能描述： 设置试车结束指示灯
* 参数说明： const UINT16 wIndicatorId 指示灯id
* 返回值 ： 无
* by lyj 20260106
*/
void SetSCOverIndicator(const UINT16 wIndicatorId);
#ifdef __cplusplus
}
#endif
TSCP/src/APP/ciapp/Indicator/IndicatorConfigDataManage.c
+27 -1
View File
@@ -423,7 +423,7 @@ UINT8 GetIndicatorDevId(UINT16 indicatorId)
* >0u: 报警灯设备ID
* by cgh 20240910
*/
UINT8 GetIndicatorRelNonReturnId(UINT16 indicatorId)
UINT16 GetIndicatorRelNonReturnId(UINT16 indicatorId)
{
UINT16 wRetVal = CI_ERROR;
@@ -457,3 +457,29 @@ UINT8 GetIndicatorRelNonReturnId(UINT16 indicatorId)
return wRetVal;
}
/*
* 功能描述： 根据指示灯ID获取指示灯虚拟联锁ID
* 参数说明： UINT16 wIndicId 指示灯ID
* 返回值 ： 0u: 获取数据失败
* >0u: 虚拟联锁ID
* BY:lyj 20260105
*/
UINT8 GetIndicBelongRtuId(UINT16 wIndicId)
{
UINT16 bufIndex = 0U; /*数组下标*/
UINT8 reVal = CI_ERROR;
bufIndex = GetIndicatorConfigBufIndex(wIndicId); /*获取指示器相关继电器数组下标*/
if (INDICATOR_SUM_MAX > bufIndex)
{
reVal = IndicatorConfigDataStru[bufIndex].chBelongVirCIid;
}
else
{
/*不处理*/
}
return reVal;
}
TSCP/src/APP/ciapp/Indicator/IndicatorConfigDataManage.h
+10 -1
View File
@@ -30,6 +30,7 @@ typedef struct S_IndicatorConfigDataStruct
UINT8 IdSum; /*相关Id数量(配置字段)*/
UINT16 IdBuf[INDICATOR_RELAY_SUM_MAX]; /*相关ID (配置字段)*/
UINT8 BjdDeviceId; /*报警灯设备ID*/
UINT8 chBelongVirCIid; /*所属虚拟联锁ID*/
} IndicatorConfigDataStruct;
/*cgh-合并ECI11.0:OC站表示灯 OC站指一级集中站（CI+OC）的现地工作站、二级集中站（OC）的有岔非集现地工作站，中央联锁工作站*/
@@ -183,7 +184,15 @@ UINT8 GetIndicatorDevId(UINT16 indicatorId);
* >0u: 报警灯设备ID
* by cgh 20240910
*/
UINT8 GetIndicatorRelNonReturnId(UINT16 indicatorId);
UINT16 GetIndicatorRelNonReturnId(UINT16 indicatorId);
/*
* 功能描述： 根据指示灯ID获取指示灯虚拟联锁ID
* 参数说明： UINT16 wIndicId 指示灯ID
* 返回值 ： 0u: 获取数据失败
* >0u: 虚拟联锁ID
* BY:lyj 20260105
*/
UINT8 GetIndicBelongRtuId(UINT16 wIndicId);
#ifdef __cplusplus
}
TSCP/src/APP/ciapp/Indicator/IndicatorDefine.h
+3 -1
View File
@@ -64,7 +64,9 @@
#define INDICATOR_TYPE_SWITCH_JICHA ((UINT8)0x24) /* 道岔挤岔状态 */
#define INDICATOR_TYPE_GD_DAD ((UINT8)0x25) /* 车库门故障报警状态 */
#define INDICATOR_TYPE_XICHEJI_ALLOW_STATE ((UINT8)0x26) /* 非FAO线路同意洗车状态指示灯 */
#define INDICATOR_TYPE_DOWNWASH_ALLOW_PASS_STATE ((UINT8)0x29) /* 降级模式洗车同意通过指示灯 */
#define INDICATOR_TYPE_DOWNWASH_ALLOW_PASS ((UINT8)0x29) /* 降级模式洗车同意通过指示灯 */
#define INDICATOR_TYPE_DOWNWASH_APPLY ((UINT8)0x63) /* 降级模式洗车请求指示灯 */
#define INDICATOR_TYPE_DOWNWASH_PASS_APPLY ((UINT8)0x64) /* 降级模式反向通过请求指示灯 */
#define INDICATOR_TYPE_ATS_CONFIRM_RELAY_INTERFACE ((UINT8)0x27) /*相邻联锁继电接口确认状态指示灯*/
TSCP/src/APP/ciapp/Initial/ConfigDataReadManage.c
+63 -12
View File
@@ -129,6 +129,9 @@ UINT8 InitAllStaticDataStr(void)
/*声光报警器配置数据结构体*/
chRtn &= CommonMemSet(SGBJConfigDataStru, (UINT32)(SGBJ_SUM_MAX * sizeof(SGBJConfigDataStruct)), 0u, (UINT32)(SGBJ_SUM_MAX * sizeof(SGBJConfigDataStruct)));
/*试灯数据配置结构体*/
chRtn &= CommonMemSet(LightTestButtonConfigDataStru, (UINT32)(LIGHTTESTBUTTON_BUTTON_MAX_NUM * sizeof(LightTestButtonConfigDataStruct)), 0u, (UINT32)(LIGHTTESTBUTTON_BUTTON_MAX_NUM * sizeof(LightTestButtonConfigDataStruct)));
return chRtn;
}
@@ -246,6 +249,7 @@ UINT8 ReadConfigureData(void)
{
; /*不处理*/
}
if (0u == rtnVal)
{
PhysicalSectionCurSum = ReadPhySicalSectionConfigData(LocalCiId, PhysicalSectionConfigDataStru);/*读物理区段配置数据*/
@@ -446,6 +450,13 @@ UINT8 ReadConfigureData(void)
if (0u == rtnVal)
{
IndicatorCurSum = ReadIndicatorConfigData(LocalCiId, IndicatorConfigDataStru); /*读指示灯报警灯配置数据*/
if (-1 == IndicatorCurSum)
{
rtnVal = 20u;/*读取指示灯报警灯配置数据失败*/
debug_infor_printf((const)"ReadIndicatorConfigData fail.");
}
#if 0
includeVirFlag = GetCiFunctionSwitchConfig(FUNC_INCLUDEVIRCI_FLAG);
if (FUNC_SWITCH_ON == includeVirFlag)
{
@@ -468,15 +479,7 @@ UINT8 ReadConfigureData(void)
}
}
else
{
IndicatorCurSum = ReadIndicatorConfigData(LocalCiId, IndicatorConfigDataStru); /*读指示灯报警灯配置数据*/
if (-1 == IndicatorCurSum)
{
rtnVal = 20u;/*读取指示灯报警灯配置数据失败*/
debug_infor_printf((const)"ReadIndicatorConfigData fail.");
}
}
#endif
}
else
{
@@ -552,7 +555,23 @@ UINT8 ReadConfigureData(void)
{
; /*不处理*/
}
if (0u == rtnVal)
{
LightTestButtonCurSum = ReadLightTestConfigData(LocalCiId, LightTestButtonConfigDataStru); /*读OC试灯按钮配置数据*/
if (-1 == LightTestButtonCurSum)
{
rtnVal = 44u;/*读取OC试灯按钮数据失败*/
debug_infor_printf((const)"\nReadLightTestConfigData fail.\n");
}
else
{
; /*不处理*/
}
}
else
{
; /*不处理*/
}
if (0u == rtnVal)
{
CiToAtsMaskCurSum = ReadCiToAtsMaskConfigData(LocalCiId, CiToAtsMaskConfigDataStru); /*读CI-ATS配置数据*/
@@ -1083,6 +1102,31 @@ UINT8 ReadConfigureData(void)
rtnVal = 2u;
}
if (0u == rtnVal)
{
g_ret = QueryTrackBelongLink();
if (CI_ERROR == g_ret)
{
debug_infor_printf((const)"QueryTrackBelongLink Error\n");
rtnVal = 43u;
}
}
else
{
/*不处理*/
}
if (0u == rtnVal)
{
/*设置试车线与车辆段合设配置*/
g_ret = SetCldAndScxMergeConfig();
if (CI_ERROR == g_ret)
{
debug_infor_printf((const)"SetCldAndScxMergeConfig fail.\r\n");
}
}
}
@@ -1099,7 +1143,6 @@ UINT8 ReadConfigureData(void)
UINT8 DeviceDataManage(void)
{
UINT8 rtValue = 0u;
UINT8 includeVirFlag= GetCiFunctionSwitchConfig(FUNC_INCLUDEVIRCI_FLAG);
UINT8 reval = CI_ERROR;
/*整理继电器数据*/
if (CI_ERROR == RelayConfigDataManage())
@@ -1223,6 +1266,7 @@ UINT8 DeviceDataManage(void)
{
rtValue = 0u;
}
#if 0
if(FUNC_SWITCH_ON == includeVirFlag)
{
reval = InitVirCIlocalCiIndicatorIdBuf();
@@ -1231,7 +1275,8 @@ UINT8 DeviceDataManage(void)
rtValue = 1u;
}
}
else
#endif
if (0U == rtValue)
{
reval = IndicatorConfigDataManage();
if (CI_ERROR == reval)
@@ -1240,6 +1285,7 @@ UINT8 DeviceDataManage(void)
}
}
if (0U == rtValue)
{
reval = CutoffPointConfigDataManage();
@@ -2040,6 +2086,11 @@ INT8 OcConnectConfigDataToDevStruct(SignalConfigDataStruct* pSignalCfgData, Phys
{
pSwitchCfgData[j].ByPassRelayId = pConnectCfgData[i].OcConnetRelayDataBuf[k].RelayId;
}
/*IBP*/
else if(SWITCH_IBP_TYPE == pConnectCfgData[i].OcConnetRelayDataBuf[k].RelayType)
{
pSwitchCfgData[j].IbpDrvRelayId = pConnectCfgData[i].OcConnetRelayDataBuf[k].DrvRelayId;
}
else
{
/*不做处理*/
TSCP/src/APP/ciapp/Initial/ConfigDataReadManage.h
+1
View File
@@ -60,6 +60,7 @@
#include "../Route/LongRouteConfigDataManage.h"
#include "../SGBJ/SGBJConfigDataManage.h"
#include "../VirtualDevice/VirtualDevDataManage.h"
#include "LightTestButtonConfigDataManage.h"
extern INT16 trackCheckRes;
extern INT16 g_ret;
TSCP/src/APP/ciapp/Initial/InitialProcess.c
+564 -185
View File
File diff suppressed because it is too large Load Diff
TSCP/src/APP/ciapp/Initial/InitialProcess.h
+24 -1
View File
@@ -243,7 +243,12 @@ UINT8 InitialPhySecIdBufOfOtherCi(void);
* 返回值 ： void
*/
void ResetDynamicState(const UINT8 ciId);
/*
* 功能描述：重置相邻Rc通信中断动态数据
* 参数说明：const UINT8 ciId, 重置联锁ID
* 返回值 ： void
*/
void ResetDynamicRcState(const UINT8 ciId);
/*
* 功能描述： 初始化全自动折返进路数据
@@ -330,6 +335,24 @@ UINT8 InitLEUDataStru(void);
*/
UINT8 InitialRtnIndicStaData(void);
/*
* 功能描述：重置本控区RC的设备动态数据
* 参数说明：void
* 返 回 值：void
* Created By LQ 2025.11.07
*/
void ResetLocalRcDynamicState(void);
/*
* 功能描述：重置控区设备状态处理
* 参数说明：void
* 返 回 值：无
* Created By LQ 2025.11.19
*/
void ResetDevStateProcess(void);
#ifdef __cplusplus
}
#endif
TSCP/src/APP/ciapp/LightTestButtonManage/LightTestButtonConfigDataManage.c
+129
View File
@@ -0,0 +1,129 @@
/********************************************************
*
* 文 件 名： LightTestButtonConfigDataManage.c
* 版权说明： 北京交控科技有限公司
* 创建时间： 2025-12-09
* 作 者： 联锁组
* 功能描述： 试灯按钮配置数据管理
* 修改记录：
*
********************************************************/
#include "LightTestButtonConfigDataManage.h"
LightTestButtonConfigDataStruct LightTestButtonConfigDataStru[LIGHTTESTBUTTON_BUTTON_MAX_NUM] = {0}; /*定义试灯按钮数据配置结构体*/
INT16 LightTestButtonCurSum = 0; /*试灯按钮当前总数*/
/*
* 功能描述： 获取试灯按钮当前总数
* 参数说明： void
* 返回值 ： 0: 获取数据失败
* >0: 试灯按钮当前总数
*/
UINT16 GetLightTestButtonCurSum(void)
{
UINT16 retVal = 0u;
if (LIGHTTESTBUTTON_BUTTON_MAX_NUM <= ((UINT16)LightTestButtonCurSum))
{
retVal = LIGHTTESTBUTTON_BUTTON_MAX_NUM;
}
else
{
retVal = (UINT16)LightTestButtonCurSum;
}
return retVal;
}
/*
* 功能描述： 获取试灯按钮的ID
* 参数说明： UINT16 index 试灯按钮索引
* 返回值 UINT16 retVal 试灯按钮ID
*/
UINT16 GetLightTestButtonId(UINT16 index)
{
UINT16 retVal = 0u;
UINT16 lightTestButtonCurSum = GetLightTestButtonCurSum();
if (index < lightTestButtonCurSum)
{
retVal = LightTestButtonConfigDataStru[index].LightTestButtonId;
}
else
{
}
return retVal;
}
/*
* 功能描述： 获取试灯按钮ID对应的继电器数据
* 参数说明： UINT16 lightTestButtonId 试灯按钮ID
* 返回值 ：
LightTestButtonConfigDataStruct *
*/
LightTestButtonConfigDataStruct *GetLightTestButtonConfigData(UINT16 lightTestButtonId)
{
LightTestButtonConfigDataStruct *retVal = NULL;
UINT16 i = 0u;
UINT16 lightTestButtonCurSum = GetLightTestButtonCurSum();
for (i = 0u; i < lightTestButtonCurSum; i++)
{
if (lightTestButtonId == LightTestButtonConfigDataStru[i].LightTestButtonId)
{
retVal = &LightTestButtonConfigDataStru[i];
break;
}
else
{
}
}
return retVal;
}
/*
* 功能描述： 获取试灯按钮ID对应继电器的总数量
* 参数说明： UINT16 lightTestButtonId 试灯按钮ID
* 返回值 ： UINT16 lightTestButtonRelayNum 继电器数量
*/
UINT16 GetLightTestButtonRelayNum(UINT16 lightTestButtonId)
{
UINT16 lightTestButtonRelayNum = 0u;
LightTestButtonConfigDataStruct *lightTestButtonConfigData = GetLightTestButtonConfigData(lightTestButtonId);
if (NULL != lightTestButtonConfigData)
{
lightTestButtonRelayNum = lightTestButtonConfigData->LightTestButtonRelayNum;
}
else
{
; /* 不处理 */
}
return lightTestButtonRelayNum;
}
/*
* 功能描述： 获取试灯按钮ID对应继电器ID
* 参数说明： UINT16 lightTestButtonId 试灯按钮ID
* UINT16 index 继电器索引
* 返回值 ： UINT16 lightTestButtonRelayId 继电器ID
*/
UINT16 GetLightTestButtonRelayId(UINT16 lightTestButtonId, UINT16 index)
{
UINT16 lightTestButtonRelayId = 0u;
LightTestButtonConfigDataStruct *lightTestButtonConfigData = GetLightTestButtonConfigData(lightTestButtonId);
if (NULL != lightTestButtonConfigData)
{
if (index < lightTestButtonConfigData->LightTestButtonRelayNum)
{
lightTestButtonRelayId = lightTestButtonConfigData->LightRelayId[index];
}
else
{
; /* 不处理 */
}
}
else
{
; /* 不处理 */
}
return lightTestButtonRelayId;
}
TSCP/src/APP/ciapp/LightTestButtonManage/LightTestButtonConfigDataManage.h
+80
View File
@@ -0,0 +1,80 @@
/********************************************************
*
* 文 件 名： LightTestButtonConfigDataManage.h
* 版权说明： 北京交控科技有限公司
* 创建时间： 2025-12-09
* 作 者： 联锁组
* 功能描述： 试灯按钮配置数据管理头文件
* 函数包括：
* 使用注意：
* 修改记录：
*
********************************************************/
#ifndef _LIGHTTESTBUTTON_CONFIG_DATA_MANAGE_H_
#define _LIGHTTESTBUTTON_CONFIG_DATA_MANAGE_H_
#include "LightTestButtonDefine.h"
typedef struct S_LightTestButtonConfigDataStruct
{
UINT16 LightTestButtonId; /* 试灯按钮ID (配置字段) */
UINT16 BelongOcId; /* 所属OC ID (配置字段) */
UINT8 LightTestButtonType; /* 试灯按钮类型 (配置字段) */
UINT16 LightTestButtonRelayNum; /* 试灯表示灯继电器数量 */
UINT16 LightRelayId[LIGHTTESTBUTTON_LIGHT_SUPPORT_MAX_NUM]; /* 试灯表示灯继电器ID数组 */
}LightTestButtonConfigDataStruct;
extern LightTestButtonConfigDataStruct LightTestButtonConfigDataStru[LIGHTTESTBUTTON_BUTTON_MAX_NUM]; /*定义试灯按钮数据配置结构体*/
extern INT16 LightTestButtonCurSum; /*试灯按钮当前总数*/
#ifdef __cplusplus
extern "C" {
#endif
/*
* 功能描述： 获取试灯按钮当前总数
* 参数说明： void
* 返回值 ： 0: 获取数据失败
* >0: 信试灯按钮当前总数
*/
UINT16 GetLightTestButtonCurSum(void);
/*
* 功能描述： 获取试灯按钮的ID
* 参数说明： UINT16 index 试灯按钮索引
* 返回值 UINT16 retVal 试灯按钮ID
*/
UINT16 GetLightTestButtonId(UINT16 index);
/*
* 功能描述： 获取试灯按钮ID对应的继电器数据
* 参数说明： UINT16 lightTestButtonId 试灯按钮ID
* 返回值 ：
LightTestButtonConfigDataStruct *
*/
LightTestButtonConfigDataStruct *GetLightTestButtonConfigData(UINT16 lightTestButtonId);
/*
* 功能描述： 获取试灯按钮ID对应继电器的总数量
* 参数说明： UINT16 lightTestButtonId 试灯按钮ID
* 返回值 ： UINT16 lightTestButtonRelayNum 继电器数量
*/
UINT16 GetLightTestButtonRelayNum(UINT16 lightTestButtonId);
/*
* 功能描述： 获取试灯按钮ID对应继电器ID
* 参数说明： UINT16 lightTestButtonId 试灯按钮ID
* UINT16 index 继电器索引
* 返回值 ： UINT16 lightTestButtonRelayId 继电器ID
*/
UINT16 GetLightTestButtonRelayId(UINT16 lightTestButtonId, UINT16 index);
#ifdef __cplusplus
}
#endif
#endif
TSCP/src/APP/ciapp/LightTestButtonManage/LightTestButtonDataManage.c
+63
View File
@@ -0,0 +1,63 @@
/********************************************************
*
* 文 件 名： LightTestButtonDataManage.c
* 版权说明： 北京交控科技有限公司
* 创建时间： 2025-12-09
* 作 者： 联锁组
* 功能描述： 试灯按钮数据管理
* 修改记录：
*
********************************************************/
#include "LightTestButtonDataManage.h"
/*
* 功能描述： 试灯按钮处理函数
* 参数说明： void
* 返回值 ： void
*/
void LightTestButtonDataManageProc(void)
{
UINT16 i = 0u; /*循环变量*/
UINT16 j = 0u; /*循环变量*/
UINT16 lightTestButtonId = 0u; /* 试灯按钮ID */
UINT16 lightTestButtonRelayNum = 0u; /* 试灯按钮ID数量 */
UINT16 lightRelayId = 0u; /* 试灯表示灯继电器ID */
UINT16 ligthtRelatNum = 0u; /* 试灯表示灯继电器数量 */
UINT8 lightTestButtonState = RELAY_STATE_DOWN; /*试灯按钮状态*/
lightTestButtonRelayNum = GetLightTestButtonCurSum(); /*获取试灯按钮总数量*/
for(i = 0u; i < lightTestButtonRelayNum; i++)
{
/* 获取对应试灯按钮ID*/
lightTestButtonId = GetLightTestButtonId(i);
/*获取试灯按钮继电器采集状态*/
lightTestButtonState = GetRelayCollState(lightTestButtonId);
if(RELAY_STATE_UP == lightTestButtonState) /*试灯按钮按下*/
{
/* 试灯表示灯继电器数量*/
ligthtRelatNum = GetLightTestButtonRelayNum(lightTestButtonId);
for(j = 0u; j < ligthtRelatNum; j++)
{
/* 获取对应试灯表示灯继电器ID*/
lightRelayId = GetLightTestButtonRelayId(lightTestButtonId,j);
/*设置试灯表示灯继电器吸起*/
(void)SetRelayDriveState(lightRelayId, RELAY_DRIVE_STATE_UP);
}
}
else if(RELAY_STATE_DOWN == lightTestButtonState) /*试灯按钮未按下*/
{
/* 不处理即可 */
}
else
{
/* 不处理 */
}
}
}
TSCP/src/APP/ciapp/LightTestButtonManage/LightTestButtonDataManage.h
+42
View File
@@ -0,0 +1,42 @@
/********************************************************
* 文 件 名： LightTestButtonDataManage.h
* 版权说明： 北京交控科技有限公司
* 创建时间： 2025-12-09
* 作 者： 联锁组
* 功能描述： 试灯按钮数据管理头文件
* 函数包括：
* 使用注意：
* 修改记录：
*
********************************************************/
#ifndef _LIGHTTEST_BUTTON_DATA_MANAGE_H_
#define _LIGHTTEST_BUTTON_DATA_MANAGE_H_
#include "LightTestButtonDefine.h"
#include "LightTestButtonConfigDataManage.h"
#include "RelayDefine.h"
#include "RelayDataManage.h"
#ifdef __cplusplus
extern "C" {
#endif
/*
* 功能描述： 试灯按钮处理函数
* 参数说明： void
* 返回值 ： void
*/
void LightTestButtonDataManageProc(void);
#ifdef __cplusplus
}
#endif
#endif
TSCP/src/APP/ciapp/LightTestButtonManage/LightTestButtonDefine.h
+33
View File
@@ -0,0 +1,33 @@
/********************************************************
*
* 文 件 名： LightTestButtonDefine.h
* 版权说明： 北京交控科技有限公司
* 创建时间： 2025-12-09
* 作 者： 联锁组
* 功能描述： 试灯按钮配置数据头文件
* 函数包括：
* 使用注意：
* 修改记录：
*
********************************************************/
#ifndef _LIGHTTESTBUTTON_DEFINE_H_
#define _LIGHTTESTBUTTON_DEFINE_H_
#include "CommonTypes.h"
/* 试灯表示灯最大数量 */
#define LIGHTTESTBUTTON_LIGHT_MAX_NUM ((UINT8)13U)
/* 试灯表示灯支持最大数 */
#define LIGHTTESTBUTTON_LIGHT_SUPPORT_MAX_NUM ((UINT8)39U)
/* 试灯按钮可配置最大数量 */
#define LIGHTTESTBUTTON_BUTTON_MAX_NUM ((UINT16)70U)
/* 武汉新港OC采集试灯按钮类型 */
#define LIGHTTESTBUTTON_TYPE_XINGANG ((UINT8)0xaaU)
#endif
TSCP/src/APP/ciapp/LogRecord/LogRecord.c
+237 -117
View File
@@ -21,18 +21,27 @@ UINT16 colStringLength = 0u;
UINT8 drvString[RELAY_SUM_MAX] = {0u};/*驱动数据*/
UINT16 drvStringLength = 0u;
AxisSectionDataStruct Record_AxisSecDataStru[AXIS_SECTION_SUM_MAX];/*参考计轴区段数据*/
AxisSectionDataStructCC Record_AxisSecDataStruCC[AXIS_SECTION_SUM_MAX];/*参考计轴区段数据-车车*/
SignalDataStruct Record_SignalDataStru[SIGNAL_SUM_MAX];/*参考信号机动态数据*/
SignalDataStructCC Record_SignalDataStruCC[SIGNAL_SUM_MAX];/*参考信号机动态数据-车车*/
EsbDataStruct Record_EsbDataStru[ESB_SUM_MAX]; /*参考ESB动态数据*/
SwitchDataStruct Record_SwitchDataStru[SWITCH_SUM_MAX];/*参考道岔动态数据*/
PhysicalSectionDataStruct Record_PhysicalSectionDataStru[PHYSICAL_SECTION_SUM_MAX];/*参考物理区段动态数据*/
PhysicalSectionDataStructCC Record_PhySecDataStruCC[PHYSICAL_SECTION_SUM_MAX] = { 0U };/*参考物理区段动态数据CC*/
RouteDataStruct Record_RouteDataStru[ROUTE_SUM_MAX];/*参考进路动态数据*/
RouteDataStructCC Record_RouteDataStruCC[ROUTE_SUM_MAX];/*参考进路动态数据-车车*/
NonRouteDataStruct Record_NonRouteDataStru[NONROUTE_ID_NUM_MAX]; /*参考非进路调车动态数据*/
LogicSectionDataStruct Record_LogicSecDataStru[LOGIC_SECTION_SUM_MAX];/*参考逻辑区段动态数据*/
LogicSectionDataStructCC Record_LogicSecDataStruCC[LOGIC_SECTION_SUM_MAX];/*参考逻辑区段动态数据-车车*/
WashMachineDataStruct Record_WashMachineDataStru[WASHMACHINE_SUM_MAX]; /*参考洗车机动态数据*/
PsdDataStruct Record_PsdDataStru[PSD_SUM_MAX];/*参考屏蔽门动态数据*/
PsdDataStructCC Record_PsdDataStruCC[PSD_SUM_MAX] = { 0U };/*参考屏蔽门动态数据CC*/
GaragedoorDataStruct Record_GaragedoorDataStru[GARAGE_DOOR_SUM_MAX]; /*参考车库门数据结构体*/
FloodGateDataStruct Record_FloodGateDataStru[FLOOD_GATE_SUM_MAX]; /**/
GaragedoorDataStructCC Record_GaragedoorDataStruCC[GARAGE_DOOR_SUM_MAX]; /*参考车库门数据结构体-车车*/
FloodGateDataStruct Record_FloodGateDataStru[FLOOD_GATE_SUM_MAX]; /*参考防烟门数据结构体*/
FloodGateDataStructCC Record_FloodGateDataStruCC[FLOOD_GATE_SUM_MAX]; /*参考防烟门数据结构体-车车*/
OverlapDataStruct Record_OverlapDataStru[OVERLAP_SUM_MAX];/*参考保护区段动态数据*/
OverlapDataStructCC Record_OverlapDataStruCC[OVERLAP_SUM_MAX];/*参考保护区段动态数据-车车*/
VirCIKeyDataStru Record_VirCIKeyDataStru[VIRTUAL_CI_MAX]= {0u};/*记录虚拟联锁关键数据*/
VirCIKeyDataStru newVirCIKeyDataStru[VIRTUAL_CI_MAX]= {0u};
SpksDataStruct Record_spksDataBuff[SPKS_SUM_MAX] = { 0u };
@@ -42,7 +51,7 @@ TsrDataStruct Record_TsrInfo[TSR_MAX_SUM] = { 0u }; /*
OCStationIndicDataStru Record_OCStationIndicBuff[INDICATOR_SUM_MAX] = { 0u };
LogicalRouteDataStruct Record_LogicalRouteDataStru[ROUTE_LOGICAL_SUM_MAX] = { 0U };
NonAutoReturnDataStruct Record_NonReturnDataStru[NON_AUTO_RETURN_SUM_MAX] = { 0U };
NonAutoReturnDataStructCC Record_NonReturnDataStruCC[NON_AUTO_RETURN_SUM_MAX] = { 0U };
UINT8 outString[1024*1024] = {0u};/*比较后的设备打印数据缓冲*/
extern QueueStruct logPrintfQue; /*日志打印缓存队列*/
UINT16 logIndex = 0u; /*日志缓存索引*/
@@ -458,19 +467,29 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
UINT16 wTrainId = 0u;
UINT8 returnValue = CI_SUCCESS;/*返回值*/
UINT8 comparaResult = 0u;/*比较结果*/
UINT8 comparaResultCC = 0u;/*比较结果*/
UINT16 floodGateTotalSum = 0u;/*防淹门总数量*/
AxisSectionDataStruct* newAxisSecData = GetAxisSecData();
AxisSectionDataStructCC* pAxisSecDataCC = GetAxisSecDataCC();
SignalDataStruct* newSignalData = GetSignalData();
SignalDataStructCC* pSignalDataCC = GetSignalDataCC();
SwitchDataStruct* newSwitchData = GetSwitchData();
PhysicalSectionDataStruct* newPhysicalSectionData = GetPhySecData();
PhysicalSectionDataStructCC* pPhysicalSectionDataCC = GetPhySecDataCC();
RouteDataStruct* newRouteData = GetRouteData();
RouteDataStructCC* pRouteDataCC = GetRouteDataCC();
NonRouteDataStruct* newNonRouteDataStru = GetNonRouteDataPtr();
LogicSectionDataStruct* newLogicSecData = GetLogicSecData();
LogicSectionDataStructCC* pLogicSecDataCC = GetLogicSecDataCC();
WashMachineDataStruct* newWashMachineData = GetWashMachineData();
PsdDataStruct * newPsdData = GetPsdData();
PsdDataStructCC* pPsdDataCC = GetPsdDataCC();
GaragedoorDataStruct* newGaragedoorData = GetGaragedoorData(); /*获取车库门数据结构体*/
GaragedoorDataStructCC* pGaragedoorDataCC = GetGaragedoorDataCC(); /*获取车库门数据结构体*/
FloodGateDataStruct *pNewFloodGateData = GetFloodGateData(); /*获取防淹门数据结构体*/
FloodGateDataStructCC* pNewFloodGateDataCC = GetFloodGateDataCC(); /*获取防淹门数据结构体*/
OverlapDataStruct* newOverlapData = GetOverlapData();
OverlapDataStructCC* pOverlapDataCC = GetOverlapDataCC();
TrainInfoStru* pNewTrainInfoData = GetTrainInfoData();
TsrDataStruct* pNewTsrInfo = GetTsrData(); /* 临时限速信息 */
CfpDataStru * pNewCfpData = GetCfpData();
@@ -485,7 +504,7 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
UINT8 localCiType = 0u;
UINT16 wNonAutoReturnCurSum = 0U;/*无人折返按钮当前总数*/
NonAutoReturnDataStruct* pNonAutoReturnData = NULL; /*无人折返数据结构体指针*/
NonAutoReturnDataStructCC* pNonReturnDataStruCC = NULL; /*无人折返数据结构体指针-CC*/
/*************************************打印物理区段数据********************************************/
/*打印区段数据*/
@@ -497,9 +516,10 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
deviceId = GetPhySecId(ii);
comparaResult = DeviceCompara((UINT8*)(&Record_PhysicalSectionDataStru[deviceId]), (UINT16)sizeof(PhysicalSectionDataStruct),
(UINT8*)(&newPhysicalSectionData[deviceId]), (UINT16)sizeof(PhysicalSectionDataStruct));
comparaResultCC = DeviceCompara((UINT8*)(&Record_PhySecDataStruCC[deviceId]), (UINT16)sizeof(PhysicalSectionDataStructCC),
(UINT8*)(&pPhysicalSectionDataCC[deviceId]), (UINT16)sizeof(PhysicalSectionDataStructCC));
if(0u != comparaResult)
if ((1U == comparaResult) || (1U == comparaResultCC))
{/*比较数据不一致*/
if (CI_ERROR != Flag)
@@ -529,11 +549,15 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
outString[outStringLength++] = newPhysicalSectionData[deviceId].SectionResetType;/*区段计轴复位类型*/
LongToChar(newPhysicalSectionData[deviceId].SectionResetStartCycNum, &outString[outStringLength]);/*区段计轴复位开始周期*/
outStringLength += 4u;
outString[outStringLength++] = newPhysicalSectionData[deviceId].chResetCmdTag;/*复位命令标签*/
outString[outStringLength++] = newPhysicalSectionData[deviceId].chResetCmdTagBack;/*复位命令标签反馈*/
outString[outStringLength++] = newPhysicalSectionData[deviceId].PhySecPreResetState;/*计轴预复位状态*/
outString[outStringLength++] = newPhysicalSectionData[deviceId].chPreResetBack;/*预复位命令反馈*/
outString[outStringLength++] = newPhysicalSectionData[deviceId].chDirectResetRst;/*直接复位结果*/
outString[outStringLength++] = newPhysicalSectionData[deviceId].chDirectResetBack;/*直接复位命令反馈*/
outString[outStringLength++] = newPhysicalSectionData[deviceId].StopSteadyFlag;/*停稳状态信息*/
outString[outStringLength] = pPhysicalSectionDataCC[deviceId].StopSteadyFlag;/*停稳状态信息CC(0x55-未停稳，0xAA-停稳)*/
outStringLength++;
outString[outStringLength++] = newPhysicalSectionData[deviceId].ArbState;/*ARB状态*/
outString[outStringLength++] = newPhysicalSectionData[deviceId].ProtectSecLockDelayTimeFlag;/*保护区段锁闭延时标志(动态字段)*/
outString[outStringLength++] = newPhysicalSectionData[deviceId].StopCheckFlag; /*物理区段停止检查标志(未设置/设置) (动态字段)*/
@@ -567,6 +591,10 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
outStringLength += 4u;
}
}
else
{
/*数据一致，不处理*/
}
}
if (0u == outStringLength)
@@ -613,11 +641,14 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
comparaResult = DeviceCompara((UINT8*)(&Record_SignalDataStru[deviceId]), (UINT16)sizeof(SignalDataStruct),
(UINT8*)(&newSignalData[deviceId]), (UINT16)sizeof(SignalDataStruct));
if (0u==comparaResult)
comparaResultCC = DeviceCompara((UINT8*)(&Record_SignalDataStruCC[deviceId]), (UINT16)sizeof(SignalDataStructCC),
(UINT8*)(&pSignalDataCC[deviceId]), (UINT16)sizeof(SignalDataStructCC));
if ((0U==comparaResult) && (0U == comparaResultCC))
{/*比较数据一致*/
}
else if (1u==comparaResult )
else if ((1U==comparaResult ) || (1U == comparaResultCC))
{/*比较数据不一致*/
if (CI_ERROR != Flag)
@@ -628,6 +659,8 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
outStringLength += 2u;
outString[outStringLength++] = newSignalData[deviceId].FLockState;/*封锁状态*/
outString[outStringLength++] = newSignalData[deviceId].LightExtinctState;/*亮灭灯状态*/
outString[outStringLength] = pSignalDataCC[deviceId].LightExtinctState;/*亮灭灯状态CC(0x55：灭灯，0xaa：亮灯)*/
outStringLength++;
outString[outStringLength++] = newSignalData[deviceId].PreColor;/*之前显示颜色*/
outString[outStringLength++] = newSignalData[deviceId].CurColor;/*当前显示颜色*/
outString[outStringLength++] = newSignalData[deviceId].PreDriveColor;/*之前驱动颜色*/
@@ -640,6 +673,8 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
LongToChar(newSignalData[deviceId].CollSigOpenStartCycNum,&outString[outStringLength]); /*采集信号机开放起始周期*/
outStringLength += 4u;
outString[outStringLength++] = newSignalData[deviceId].SignalCrossState;/*信号机跨压状态*/
outString[outStringLength] = pSignalDataCC[deviceId].SignalCrossState;/*信号机跨压状态CC(0x55：未跨压，0xaa：跨压)*/
outStringLength++;
outString[outStringLength++] = newSignalData[deviceId].SignalYLockOpenState;/*引导总锁信号开放状态*/
outString[outStringLength++] = newSignalData[deviceId].AtsDetainFlag;/*Ats人工扣车标志*/
outString[outStringLength++] = newSignalData[deviceId].AtsDetainFlagAuto;/*Ats自动扣车标志*/
@@ -667,7 +702,7 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
outString[outStringLength++] = newSignalData[deviceId].DoubleYellowDsBreakFlag;/*双黄灯丝断丝标志状态*/
outString[outStringLength++] = newSignalData[deviceId].MaintainLightState;/*信号机维修点灯状态*/
if (MAX_SIGNAL_LIGHTUPLINK_NUM < newSignalData[deviceId].wSignalLightUpLinkIdSum)
if (MAX_SIGNAL_LIGHTUPLINK_NUM < pSignalDataCC[deviceId].wSignalLightUpLinkIdSum)
{
/* 数量合法 */
ShortToChar(0u, &outString[outStringLength]);/*信号机点灯link数量*/
@@ -676,12 +711,12 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
else
{
/* 数量合法 */
ShortToChar(newSignalData[deviceId].wSignalLightUpLinkIdSum, &outString[outStringLength]);/*信号机点灯link数量*/
ShortToChar(pSignalDataCC[deviceId].wSignalLightUpLinkIdSum, &outString[outStringLength]);/*信号机点灯link数量*/
outStringLength += 2u;
for (jj = 0u; jj < newSignalData[deviceId].wSignalLightUpLinkIdSum; jj++)
for (jj = 0u; jj < pSignalDataCC[deviceId].wSignalLightUpLinkIdSum; jj++)
{
ShortToChar(newSignalData[deviceId].szSignalLightUpLinkIdBuf[jj], &outString[outStringLength]);/*信号机点灯link数量*/
ShortToChar(pSignalDataCC[deviceId].szSignalLightUpLinkIdBuf[jj], &outString[outStringLength]);/*信号机点灯link数量*/
outStringLength += 2u;
}
}
@@ -699,9 +734,9 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
outStringLength += 4u;
LongToChar(newSignalData[deviceId].CancelDetainErrTrigPressCycNum, &outString[outStringLength]); /*取消扣车按钮误触发按下周期*/
outStringLength += 4u;
ShortToChar(newSignalData[deviceId].wSignalLightUpTrainId, &outString[outStringLength]);/*信号机点灯区段接近列车ID*/
ShortToChar(pSignalDataCC[deviceId].wSignalLightUpTrainId, &outString[outStringLength]);/*信号机点灯区段接近列车ID*/
outStringLength += 2u;
outString[outStringLength++] = newSignalData[deviceId].cSleepTrainLightUpFlag; /*休眠车点亮信号机标志：0x55 无效，0xAA 有效*/
outString[outStringLength++] = pSignalDataCC[deviceId].cSleepTrainLightUpFlag; /*休眠车点亮信号机标志：0x55 无效，0xAA 有效*/
outString[outStringLength++] = newSignalData[deviceId].cInHumidRailFlag; /*信号机湿轨标志：0x55 无效，0xAA 有效*/
outString[outStringLength] = newSignalData[deviceId].cDetCutBtnState; /*扣车旁路按钮状态：0x55-无效，0xAA-有效*/
outStringLength++;
@@ -798,6 +833,11 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
outStringLength += 4u;
LongToChar(pNewEsbData[deviceId].EsbCutErrTriggerPressCycNum, &outString[outStringLength]); /*紧急关闭旁路按钮误触发按下周期*/
outStringLength += 4U;
outString[outStringLength] = pNewEsbData[deviceId].cOnePlatEsbState;/*同站紧急按钮激活状态：0x55-未激活，0xAA-激活*/
outStringLength++;
outString[outStringLength] = pNewEsbData[deviceId].cOnePlatEsbCutState;/*同站紧急旁路按钮激活状态：0x55-未激活，0xAA-激活*/
outStringLength++;
}
}
else
@@ -963,11 +1003,14 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
comparaResult = DeviceCompara((UINT8*)(&Record_RouteDataStru[deviceId]), (UINT16)sizeof(RouteDataStruct),
(UINT8*)(&newRouteData[deviceId]), (UINT16)sizeof(RouteDataStruct));
if (0u==comparaResult)
comparaResultCC = DeviceCompara((UINT8*)(&Record_RouteDataStruCC[deviceId]), (UINT16)sizeof(RouteDataStructCC),
(UINT8*)(&pRouteDataCC[deviceId]), (UINT16)sizeof(RouteDataStructCC));
if ((0U == comparaResult) && (0U == comparaResultCC))
{/*比较数据一致*/
}
else if (1u==comparaResult )
else if ((1U==comparaResult) || (1U == comparaResultCC))
{/*比较数据不一致*/
if (CI_ERROR != Flag)
@@ -1003,6 +1046,8 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
ShortToChar(newRouteData[deviceId].AllAutoReturnId,&outString[outStringLength]);/*全自动折返进路ID*/
outStringLength += 2u;
outString[outStringLength++] = newRouteData[deviceId].StopensureFlag;/*停车保证标志*/
outString[outStringLength] = pRouteDataCC[deviceId].StopensureFlag;/*停车保证标志CC(0x55：已设置，0xAA：未设置)*/
outStringLength++;
outString[outStringLength++] = newRouteData[deviceId].StopKeepCheckFlag; /* 保持时候用的停车保证标志 */
outString[outStringLength++] = newRouteData[deviceId].RouteStateFlag; /*进路状态标志（1：表示有效；0：表示无效）*/
outString[outStringLength++] = newRouteData[deviceId].TrainEnterFlag;/*列车驶入标志*/
@@ -1035,19 +1080,19 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
outString[outStringLength++] = newRouteData[deviceId].AutoSigPropertyLoseEfficacyFlag; /*自动信号属性失效标志（未设置/设置）*/
outString[outStringLength++] = newRouteData[deviceId].OverlapNeedCIlockFlag; /*保护区段需要CI锁闭标志*/
outString[outStringLength++] = newRouteData[deviceId].OverlapLockProcFlag; /*保护区段在锁闭过程中标志*/
ShortToChar(newRouteData[deviceId].wStopEnsureTrainId, &outString[outStringLength]);/*进路停车保证列车ID*/
ShortToChar(pRouteDataCC[deviceId].wStopEnsureTrainId, &outString[outStringLength]);/*进路停车保证列车ID*/
outStringLength += 2u;
LongToChar(newRouteData[deviceId].dwStopEnsureCyc, &outString[outStringLength]);/*停车保证询问周期号*/
LongToChar(pRouteDataCC[deviceId].dwStopEnsureCyc, &outString[outStringLength]);/*停车保证询问周期号*/
outStringLength += 4u;
outString[outStringLength++] = newRouteData[deviceId].cResReqOtherCIId; /*发送资源申请的联锁ID*/
outString[outStringLength++] = pRouteDataCC[deviceId].cResReqOtherCIId; /*发送资源申请的联锁ID*/
if (ROUTE_APPLY_RECD_TRAIN_SUM_MAX >= newRouteData[deviceId].chResReqTrainSum)
if (ROUTE_APPLY_RECD_TRAIN_SUM_MAX >= pRouteDataCC[deviceId].chResReqTrainSum)
{
outString[outStringLength++] = newRouteData[deviceId].chResReqTrainSum; /*发送资源申请的联锁ID*/
for (jj = 0u; jj < newRouteData[deviceId].chResReqTrainSum; jj++)
outString[outStringLength++] = pRouteDataCC[deviceId].chResReqTrainSum; /*发送资源申请的联锁ID*/
for (jj = 0u; jj < pRouteDataCC[deviceId].chResReqTrainSum; jj++)
{
ShortToChar(newRouteData[deviceId].wszResReqTrainId[jj], &outString[outStringLength]);/*发送资源申请的列车ID*/
ShortToChar(pRouteDataCC[deviceId].wszResReqTrainId[jj], &outString[outStringLength]);/*发送资源申请的列车ID*/
outStringLength += 2u;
}
}
@@ -1056,13 +1101,13 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
outString[outStringLength++] = 0u; /*发送资源申请的联锁ID*/
}
if (ROUTE_APPLY_RECD_TRAIN_SUM_MAX >= newRouteData[deviceId].ITSRouteApplyTrainIdSum)
if (ROUTE_APPLY_RECD_TRAIN_SUM_MAX >= pRouteDataCC[deviceId].ITSRouteApplyTrainIdSum)
{
outString[outStringLength++] = newRouteData[deviceId].ITSRouteApplyTrainIdSum; /*ITS申请路径命令的列车ID记录总数*/
outString[outStringLength++] = pRouteDataCC[deviceId].ITSRouteApplyTrainIdSum; /*ITS申请路径命令的列车ID记录总数*/
for (jj = 0u; jj < newRouteData[deviceId].ITSRouteApplyTrainIdSum; jj++)
for (jj = 0u; jj < pRouteDataCC[deviceId].ITSRouteApplyTrainIdSum; jj++)
{
ShortToChar(newRouteData[deviceId].ITSRouteApplyTrainIdBuf[jj], &outString[outStringLength]);/*通过ITS申请路径命令记录的列车ID数组*/
ShortToChar(pRouteDataCC[deviceId].ITSRouteApplyTrainIdBuf[jj], &outString[outStringLength]);/*通过ITS申请路径命令记录的列车ID数组*/
outStringLength += 2u;
}
@@ -1073,16 +1118,16 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
}
/*可动道岔标志*/
outString[outStringLength++] = newRouteData[deviceId].HalfRouteDataSt.HalfRouteSwitchMoveValid;
outString[outStringLength++] = pRouteDataCC[deviceId].HalfRouteDataSt.HalfRouteSwitchMoveValid;
if (MAX_ROUTE_IN_LT_NUM > newRouteData[deviceId].HalfRouteDataSt.RouteLockLgcSecNum)
if (MAX_ROUTE_IN_LT_NUM > pRouteDataCC[deviceId].HalfRouteDataSt.RouteLockLgcSecNum)
{
/*部分锁闭逻辑区段数量*/
outString[outStringLength++] = newRouteData[deviceId].HalfRouteDataSt.RouteLockLgcSecNum;
outString[outStringLength++] = pRouteDataCC[deviceId].HalfRouteDataSt.RouteLockLgcSecNum;
/*部分锁闭逻辑区段ID*/
for (jj = 0u; jj < newRouteData[deviceId].HalfRouteDataSt.RouteLockLgcSecNum; jj++)
for (jj = 0u; jj < pRouteDataCC[deviceId].HalfRouteDataSt.RouteLockLgcSecNum; jj++)
{
ShortToChar(newRouteData[deviceId].HalfRouteDataSt.RouteLockLgcSecIdBuf[jj], &outString[outStringLength]);/*通过ITS申请路径命令记录的列车ID数组*/
ShortToChar(pRouteDataCC[deviceId].HalfRouteDataSt.RouteLockLgcSecIdBuf[jj], &outString[outStringLength]);/*通过ITS申请路径命令记录的列车ID数组*/
outStringLength += 2u;
}
@@ -1092,18 +1137,18 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
outString[outStringLength++] = 0u;
}
/*部分锁闭列车ID*/
ShortToChar(newRouteData[deviceId].HalfRouteDataSt.HalfResReqTrainId, &outString[outStringLength]);/*通过ITS申请路径命令记录的列车ID数组*/
ShortToChar(pRouteDataCC[deviceId].HalfRouteDataSt.HalfResReqTrainId, &outString[outStringLength]);/*通过ITS申请路径命令记录的列车ID数组*/
outStringLength += 2u;
if (ROUTE_TRAIN_LOC_MAX_LGC_SUM >= newRouteData[deviceId].HalfRouteDataSt.TrainLocLgcSecNum)
if (ROUTE_TRAIN_LOC_MAX_LGC_SUM >= pRouteDataCC[deviceId].HalfRouteDataSt.TrainLocLgcSecNum)
{
/*部分锁闭列车身下资源数量*/
outString[outStringLength++] = newRouteData[deviceId].HalfRouteDataSt.TrainLocLgcSecNum;
outString[outStringLength++] = pRouteDataCC[deviceId].HalfRouteDataSt.TrainLocLgcSecNum;
for (jj = 0u; jj < newRouteData[deviceId].HalfRouteDataSt.TrainLocLgcSecNum; jj++)
for (jj = 0u; jj < pRouteDataCC[deviceId].HalfRouteDataSt.TrainLocLgcSecNum; jj++)
{
/*部分锁闭列车身下资源逻辑区段ID*/
ShortToChar(newRouteData[deviceId].HalfRouteDataSt.TrainLocLgcSecIdBuf[jj], &outString[outStringLength]);/*通过ITS申请路径命令记录的列车ID数组*/
ShortToChar(pRouteDataCC[deviceId].HalfRouteDataSt.TrainLocLgcSecIdBuf[jj], &outString[outStringLength]);/*通过ITS申请路径命令记录的列车ID数组*/
outStringLength += 2u;
}
@@ -1112,7 +1157,7 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
{
outString[outStringLength++] = 0u;
}
LongToChar(newRouteData[deviceId].dwFirstElockStartCycNum, &outString[outStringLength]); /*进路第一个锁闭的逻辑区段延时设置区段故障起始周期号*/
LongToChar(pRouteDataCC[deviceId].dwFirstElockStartCycNum, &outString[outStringLength]); /*进路第一个锁闭的逻辑区段延时设置区段故障起始周期号*/
outStringLength += 4u;
outString[outStringLength++] = newRouteData[deviceId].cRelZuHeRouteSGBJDelayFlag; /*关联组合进路声光报警是否延时标志*/
@@ -1123,8 +1168,11 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
outString[outStringLength++] = newRouteData[deviceId].cRouteNeedDriveSGBJFlag; /*进路驱动声光报警标志*/
outString[outStringLength++] = newRouteData[deviceId].cRouteDrivedSGBJFlag; /*进路驱动声光报警标志：0x55 未驱动过；0xAA 已驱动过*/
outString[outStringLength++] = newRouteData[deviceId].chRouteNearSecSearchState; /*进路接近区段查询状态是否有故障车*/
outString[outStringLength++] = pRouteDataCC[deviceId].chRouteNearSecSearchState; /*进路接近区段查询状态是否有故障车*/
outString[outStringLength++] = newRouteData[deviceId].chRouteApplySwitchCheckFlag; /*进路办理相邻控区道岔检查标志*/
outString[outStringLength++] = newRouteData[deviceId].chRoutCouplinkFlag; /*进路联挂标志*/
outString[outStringLength++] = newRouteData[deviceId].chCouplinkSuccessFlag; /*进路联挂成功*/
outString[outStringLength++] = newRouteData[deviceId].chCouplinkErrorFlag; /*进路联挂失败*/
}
}
else
@@ -1265,12 +1313,13 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
deviceId = GetLogicSecId(ii);
comparaResult = DeviceCompara((UINT8*)(&Record_LogicSecDataStru[deviceId]), (UINT16)sizeof(LogicSectionDataStruct),
(UINT8*)(&newLogicSecData[deviceId]), (UINT16)sizeof(LogicSectionDataStruct));
if (0u==comparaResult)
comparaResultCC = DeviceCompara((UINT8*)(&Record_LogicSecDataStruCC[deviceId]), (UINT16)sizeof(LogicSectionDataStructCC),
(UINT8*)(&pLogicSecDataCC[deviceId]), (UINT16)sizeof(LogicSectionDataStructCC));
if ((0U==comparaResult) && (0U == comparaResultCC))
{/*比较数据一致*/
}
else if (1u==comparaResult )
else if ((1U==comparaResult) || (1U == comparaResultCC))
{/*比较数据不一致*/
if (CI_ERROR==Flag)
@@ -1286,10 +1335,18 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
outString[outStringLength++] = newLogicSecData[deviceId].PreOccupyState;/*逻辑区段之前占用状态*/
outString[outStringLength++] = newLogicSecData[deviceId].CurOccupyState;/*逻辑区段当前占用状态*/
outString[outStringLength++] = newLogicSecData[deviceId].LinShiXianSuSetFlag;/*逻辑区段临时限速*/
outString[outStringLength++] = newLogicSecData[deviceId].OccupyState;/*逻辑区段占用状态*/
outString[outStringLength] = pLogicSecDataCC[deviceId].LinShiXianSuSetFlag;/*逻辑区段临时限速CC(0x55-已未设置临时限速，0xAA-已设置临时限速，0xFF-临时限速无效)*/
outStringLength++;
outString[outStringLength++] = newLogicSecData[deviceId].OccupyState;/*逻辑区段初始占用状态*/
outString[outStringLength] = pLogicSecDataCC[deviceId].OccupyState;/*逻辑区段初始占用状态CC(0x55-未占用，0xAA-非通信车占用，0xBB-通信车占用)*/
outStringLength++;
outString[outStringLength] = newLogicSecData[deviceId].TXOccupyState;/*逻辑区段通信车占用状态(0x55-无车或非通信车占用，0xAA-通信车占用)*/
outStringLength++;
outString[outStringLength] = pLogicSecDataCC[deviceId].TXOccupyState;/*逻辑区段通信车占用状态CC(0x55-无车或非通信车占用，0xAA-通信车占用)*/
outStringLength++;
outString[outStringLength++] = newLogicSecData[deviceId].LogLockState;/*逻辑区段锁闭状态*/
outString[outStringLength++] = newLogicSecData[deviceId].LogLockDir;/*逻辑区段锁闭方向*/
outString[outStringLength++] = newLogicSecData[deviceId].chResShareFlag;/*逻辑区段共享标志 0x55共享 0xAA非共享*/
outString[outStringLength++] = pLogicSecDataCC[deviceId].chResShareFlag;/*逻辑区段共享标志 0x55共享 0xAA非共享*/
ShortToChar(newLogicSecData[deviceId].LogLockBelongRoute,&outString[outStringLength]);/*逻辑锁闭所属进路*/
outStringLength += 2u;
LongToChar(newLogicSecData[deviceId].LogUnlockStartCycNum,&outString[outStringLength]);/*逻辑延时解锁周期号*/
@@ -1297,53 +1354,53 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
ShortToChar(newLogicSecData[deviceId].wPLockBelongRouteId, &outString[outStringLength]);/*防护锁闭的进路编号*/
outStringLength += 2u;
outString[outStringLength++] = newLogicSecData[deviceId].cResReqOtherCIId;/*发送资源请求的其他联锁ID*/
ShortToChar(newLogicSecData[deviceId].wResReqTrainId, &outString[outStringLength]);/*发送资源请求的列车ID*/
outString[outStringLength++] = pLogicSecDataCC[deviceId].cResReqOtherCIId;/*发送资源请求的其他联锁ID*/
ShortToChar(pLogicSecDataCC[deviceId].wResReqTrainId, &outString[outStringLength]);/*发送资源请求的列车ID*/
outStringLength += 2u;
ShortToChar(newLogicSecData[deviceId].JumpLockTrainId, &outString[outStringLength]);/*申请或释放跳跃锁闭命令的列车ID*/
ShortToChar(pLogicSecDataCC[deviceId].JumpLockTrainId, &outString[outStringLength]);/*申请或释放跳跃锁闭命令的列车ID*/
outStringLength += 2u;
outString[outStringLength++] = newLogicSecData[deviceId].LogJumpLockState;/*逻辑区段跳跃锁闭状态 0x55 未锁闭，0xAA 锁闭*/
outString[outStringLength++] = newLogicSecData[deviceId].LogJumpLockDelayUnlockFlag;/*逻辑区段跳跃锁闭延时解锁设置标志 0x55 未设置，0xaa 设置*/
LongToChar(newLogicSecData[deviceId].LogSecJumpDelayUnlockStartCyc, &outString[outStringLength]);/*逻辑区段跳跃锁闭延时解锁起始周期号*/
outString[outStringLength++] = pLogicSecDataCC[deviceId].LogJumpLockState;/*逻辑区段跳跃锁闭状态 0x55 未锁闭，0xAA 锁闭*/
outString[outStringLength++] = pLogicSecDataCC[deviceId].LogJumpLockDelayUnlockFlag;/*逻辑区段跳跃锁闭延时解锁设置标志 0x55 未设置，0xaa 设置*/
LongToChar(pLogicSecDataCC[deviceId].LogSecJumpDelayUnlockStartCyc, &outString[outStringLength]);/*逻辑区段跳跃锁闭延时解锁起始周期号*/
outStringLength += 4u;
outString[outStringLength++] = newLogicSecData[deviceId].LogSecJumpLockPermFlag;/*逻辑区段跳跃锁闭允许标志 0x55 允许，0xaa 禁止*/
outString[outStringLength++] = pLogicSecDataCC[deviceId].LogSecJumpLockPermFlag;/*逻辑区段跳跃锁闭允许标志 0x55 允许，0xaa 禁止*/
if (LOGIC_SECTION_RES_SUM_MAX < newLogicSecData[deviceId].chTrainInfoSum)
if (LOGIC_SECTION_RES_SUM_MAX < pLogicSecDataCC[deviceId].chTrainInfoSum)
{
/* 数量不合法 */
outString[outStringLength++] = 0u;/*逻辑区段资源数量*/
}
else
{
outString[outStringLength++] = newLogicSecData[deviceId].chTrainInfoSum;/*逻辑区段资源数量*/
for (jj = 0u; jj < newLogicSecData[deviceId].chTrainInfoSum; jj++)
outString[outStringLength++] = pLogicSecDataCC[deviceId].chTrainInfoSum;/*逻辑区段资源数量*/
for (jj = 0u; jj < pLogicSecDataCC[deviceId].chTrainInfoSum; jj++)
{
ShortToChar(newLogicSecData[deviceId].szTrainResData[jj].wTrainId, &outString[outStringLength]);/*列车ID*/
ShortToChar(pLogicSecDataCC[deviceId].szTrainResData[jj].wTrainId, &outString[outStringLength]);/*列车ID*/
outStringLength += 2u;
outString[outStringLength++] = newLogicSecData[deviceId].szTrainResData[jj].chTrainApplyState;/*列车申请状态*/
outString[outStringLength++] = newLogicSecData[deviceId].szTrainResData[jj].chLogicResUsable;/*列车资源状态*/
outString[outStringLength++] = newLogicSecData[deviceId].szTrainResData[jj].chLogicReturnState;/*折返逻辑区段标志*/
outString[outStringLength++] = newLogicSecData[deviceId].szTrainResData[jj].chLogicUnlockState;/*列车申请状态*/
LongToChar(newLogicSecData[deviceId].szTrainResData[jj].dwRcvUnlockCmdCyc, &outString[outStringLength]);/*逻辑延时解锁周期号*/
outString[outStringLength++] = pLogicSecDataCC[deviceId].szTrainResData[jj].chTrainApplyState;/*列车申请状态*/
outString[outStringLength++] = pLogicSecDataCC[deviceId].szTrainResData[jj].chLogicResUsable;/*列车资源状态*/
outString[outStringLength++] = pLogicSecDataCC[deviceId].szTrainResData[jj].chLogicReturnState;/*折返逻辑区段标志*/
outString[outStringLength++] = pLogicSecDataCC[deviceId].szTrainResData[jj].chLogicUnlockState;/*列车申请状态*/
LongToChar(pLogicSecDataCC[deviceId].szTrainResData[jj].dwRcvUnlockCmdCyc, &outString[outStringLength]);/*逻辑延时解锁周期号*/
outStringLength += 4u;
}
}
LongToChar(newLogicSecData[deviceId].LogErrlockStartCycNum, &outString[outStringLength]);/*逻辑区段延时设置故障锁闭起始周期号*/
LongToChar(pLogicSecDataCC[deviceId].LogErrlockStartCycNum, &outString[outStringLength]);/*逻辑区段延时设置故障锁闭起始周期号*/
outStringLength += 4U;
outString[outStringLength++] = newLogicSecData[deviceId].chLogicProResUsable;/*逻辑区段防护锁闭资源可用状态*/
outString[outStringLength++] = newLogicSecData[deviceId].chLogicSpksFLockState;/*逻辑区段被SPKS封锁状态*/
if (LOGSEC_RELATE_ROUTE_SUM_MAX >= newLogicSecData[deviceId].chLogSecLockBelLogRouteSum)
if (LOGSEC_RELATE_ROUTE_SUM_MAX >= pLogicSecDataCC[deviceId].chLogSecLockBelLogRouteSum)
{
outString[outStringLength++] = newLogicSecData[deviceId].chLogSecLockBelLogRouteSum; /*逻辑区段锁闭所属逻辑进路数量*/
for (kk = 0U; kk < newLogicSecData[deviceId].chLogSecLockBelLogRouteSum; kk++)
outString[outStringLength++] = pLogicSecDataCC[deviceId].chLogSecLockBelLogRouteSum; /*逻辑区段锁闭所属逻辑进路数量*/
for (kk = 0U; kk < pLogicSecDataCC[deviceId].chLogSecLockBelLogRouteSum; kk++)
{
ShortToChar(newLogicSecData[deviceId].szLogSecLockBelLogRouteData[kk].wLogSecLockBelLogRouteId, &outString[outStringLength]); /*逻辑区段锁闭所属逻辑进路ID*/
ShortToChar(pLogicSecDataCC[deviceId].szLogSecLockBelLogRouteData[kk].wLogSecLockBelLogRouteId, &outString[outStringLength]); /*逻辑区段锁闭所属逻辑进路ID*/
outStringLength += 2u;
outString[outStringLength++] = newLogicSecData[deviceId].szLogSecLockBelLogRouteData[kk].chLogSecLockBelLogRouteState; /*逻辑区段锁闭所属逻辑进路状态*/
outString[outStringLength++] = newLogicSecData[deviceId].szLogSecLockBelLogRouteData[kk].wLogSecLockBelLogRouteDir; /*逻辑区段被逻辑进路锁闭的方向ID*/
outString[outStringLength++] = pLogicSecDataCC[deviceId].szLogSecLockBelLogRouteData[kk].chLogSecLockBelLogRouteState; /*逻辑区段锁闭所属逻辑进路状态*/
outString[outStringLength++] = pLogicSecDataCC[deviceId].szLogSecLockBelLogRouteData[kk].wLogSecLockBelLogRouteDir; /*逻辑区段被逻辑进路锁闭的方向ID*/
}
}
else
@@ -1351,11 +1408,12 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
outString[outStringLength++] = 0U; /*逻辑区段锁闭所属逻辑进路数量超限，不解析*/
}
outString[outStringLength++] = newLogicSecData[deviceId].LogSecLogLockState; /*逻辑区段逻辑锁闭状态*/
outString[outStringLength++] = newLogicSecData[deviceId].LogSecLogLockDir; /*逻辑区段逻辑锁闭方向*/
outString[outStringLength++] = pLogicSecDataCC[deviceId].LogSecLogLockState; /*逻辑区段逻辑锁闭状态*/
outString[outStringLength++] = pLogicSecDataCC[deviceId].LogSecLogLockDir; /*逻辑区段逻辑锁闭方向*/
outString[outStringLength++] = newLogicSecData[deviceId].chLinShiXianSuSetSpeed; /*逻辑区段临时限速值*/
outString[outStringLength++] = newLogicSecData[deviceId].chAblRelLogSecUsableFlag; /*ABL列车关联逻辑区段允许使用标志*/
outString[outStringLength++] = newLogicSecData[deviceId].cRouteLeaveLogFlag; /*离去区段ABL列车检查标志*/
outString[outStringLength++] = pLogicSecDataCC[deviceId].chAblRelLogSecUsableFlag; /*ABL列车关联逻辑区段允许使用标志*/
outString[outStringLength++] = pLogicSecDataCC[deviceId].cRouteLeaveLogFlag; /*离去区段ABL列车检查标志*/
outString[outStringLength++] = newLogicSecData[deviceId].chLogSecEmergXianSu;/*逻辑区段紧急临时限速*/
}
}
else
@@ -1437,18 +1495,46 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
outString[outStringLength++] = newWashMachineData[deviceId].PauseTrainWashRequestDrvState;/*暂停洗车请求驱动状态(动态字段:驱动)*/
outString[outStringLength++] = newWashMachineData[deviceId].PaseWashMachineRequesDrvtState;/*通过洗车机请求驱动状态(动态字段:驱动)*/
outString[outStringLength++] = newWashMachineData[deviceId].WashmachineXTACurState;/*洗车同意按钮当前状态*/
outString[outStringLength++] = newWashMachineData[deviceId].WashmachineXTAPreState;/*洗车同意按钮上周期状态*/
outString[outStringLength++] = newWashMachineData[deviceId].WashmachineXTALogicState;/*洗车机按钮逻辑状态*/
LongToChar(newWashMachineData[deviceId].WashmachineXTAPressDownCycle,&outString[outStringLength]);/*洗车机洗车同意按钮按下起始周期*/
outStringLength += 4u;
outString[outStringLength++] = newWashMachineData[deviceId].WashMachineWorkModeDrvtState;/*洗车机洗车模式驱动状态(动态字段:驱动)*/
outString[outStringLength++] = newWashMachineData[deviceId].WashModeState;/*洗车机洗车模式采集状态*/
outString[outStringLength++] = newWashMachineData[deviceId].chSetWashWorkModeBack;/*设置洗车机工作模式反馈*/
outString[outStringLength++] = newWashMachineData[deviceId].chDownWashAllowState;/*降级模式洗车同意状态*/
outString[outStringLength++] = newWashMachineData[deviceId].chDownWashAllowPassState;/*降级模式洗车同意通过状态*/
LongToChar(newWashMachineData[deviceId].WashWorkModeRelayDrvCycle, &outString[outStringLength]);/*洗车模式继电器驱动起始周期号*/
outStringLength += 4u;
outString[outStringLength++] = newWashMachineData[deviceId].chDownWashAllowState;/**降级模式洗车同意状态(动态字段:融合)*/
outString[outStringLength++] = newWashMachineData[deviceId].chDownWashAllowPassState;/*降级模式洗车同意通过状态(动态字段:融合)*/
outString[outStringLength++] = newWashMachineData[deviceId].chDownWashReqState;/*降级模式洗车请求状态*/
LongToChar(newWashMachineData[deviceId].dwDownWashReqCycle, &outString[outStringLength]);/*降级模式洗车请求周期*/
outStringLength += 4u;
outString[outStringLength++] = newWashMachineData[deviceId].chDownWashPassReqState;/*降级模式反向洗车请求状态*/
LongToChar(newWashMachineData[deviceId].dwDownWashPassReqCycle, &outString[outStringLength]);/*降级模式反向洗车请求周期*/
outStringLength += 4u;
outString[outStringLength++] = newWashMachineData[deviceId].chDownWashAllowColState;/*降级模式洗车线洗车同意状态*/
LongToChar(newWashMachineData[deviceId].dwDownWashAllowCycle, &outString[outStringLength]);/*降级模式洗车线洗车同意按钮按下起始周期*/
outStringLength += 4u;
LongToChar(newWashMachineData[deviceId].dwDownWashBtVadCycle, &outString[outStringLength]);/*降级模式洗车线洗车同意按钮有效周期*/
outStringLength += 4u;
outString[outStringLength++] = newWashMachineData[deviceId].chDownDccWashAllowColState;/*降级模式DCC洗车同意状态*/
LongToChar(newWashMachineData[deviceId].dwDownWashDccAllowCycle, &outString[outStringLength]);/*降级模式DCC洗车同意按钮按下起始周期*/
outStringLength += 4u;
LongToChar(newWashMachineData[deviceId].dwDownWashDccBtVadCycle, &outString[outStringLength]);/*降级模式DCC洗车同意按钮有效周期*/
outStringLength += 4u;
outString[outStringLength++] = newWashMachineData[deviceId].chDownWashAllowErrState;/*降级模式洗车线洗车同意粘连状态*/
outString[outStringLength++] = newWashMachineData[deviceId].chDownDccWashAllowErrState;/*降级模式DCC洗车同意粘连状态*/
outString[outStringLength++] = newWashMachineData[deviceId].chDownWashAllowPassColState;/*降级模式洗车线洗车同意反向通过状态*/
LongToChar(newWashMachineData[deviceId].dwDownWashAllowPassCycle, &outString[outStringLength]);/*降级模式洗车线反向通过洗车同意按钮按下起始周期*/
outStringLength += 4u;
LongToChar(newWashMachineData[deviceId].dwDownWashBtVadPassCycle, &outString[outStringLength]);/*降级模式洗车线反向通过洗车同意按钮有效周期*/
outStringLength += 4u;
outString[outStringLength++] = newWashMachineData[deviceId].chDownDccWashAllowPassColState;/*降级模式DCC洗车同意反向通过状态*/
LongToChar(newWashMachineData[deviceId].dwDownWashDccAllowPassCycle, &outString[outStringLength]);/*降级模式DCC反向通过洗车同意按钮按下起始周期*/
outStringLength += 4u;
LongToChar(newWashMachineData[deviceId].dwDownWashDccBtVadPassCycle, &outString[outStringLength]);/*降级模式DCC反向通过洗车同意按钮有效周期*/
outStringLength += 4u;
outString[outStringLength++] = newWashMachineData[deviceId].chDownWashAllowPassErrState;/*降级模式洗车线洗车同意反向通过粘连状态*/
outString[outStringLength++] = newWashMachineData[deviceId].chDownDccWashAllowPassErrState;/*降级模式DCC洗车同意反向通过粘连状态*/
}
}
@@ -1492,12 +1578,14 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
deviceId = GetPsdId(ii);
comparaResult = DeviceCompara((UINT8*)(&Record_PsdDataStru[deviceId]), (UINT16)sizeof(PsdDataStruct),
(UINT8*)(&newPsdData[deviceId]), (UINT16)sizeof(PsdDataStruct));
comparaResultCC = DeviceCompara((UINT8*)(&Record_PsdDataStruCC[deviceId]), (UINT16)sizeof(PsdDataStructCC),
(UINT8*)(&pPsdDataCC[deviceId]), (UINT16)sizeof(PsdDataStructCC));
if (0u==comparaResult)
if ((0U == comparaResult) && (0U == comparaResultCC))
{/*比较数据一致*/
}
else if (1u==comparaResult )
else if ((1U == comparaResult)|| (1U == comparaResultCC))
{/*比较数据不一致*/
if (CI_ERROR==Flag)
@@ -1512,6 +1600,8 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
outStringLength += 2u;
ShortToChar(newPsdData[deviceId].psdEditGroupInfo,&outString[outStringLength]);/*PSD 编组信息*/
outStringLength += 2u;
ShortToChar(pPsdDataCC[deviceId].psdEditGroupInfo, &outString[outStringLength]);/*PSD 编组信息CC(0-默认值，3-三编组，4-四编组，6-六编组，8-八编组)*/
outStringLength += 2U;
outString[outStringLength++] = newPsdData[deviceId].DoorButtonState;/*屏蔽门按钮状态*/
outString[outStringLength++] = newPsdData[deviceId].MutualLockRemoveState;/*屏蔽门互锁解除状态*/
outString[outStringLength++] = newPsdData[deviceId].PsdDriveState;/*屏蔽门驱动状态*/
@@ -1521,6 +1611,12 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
outString[outStringLength++] = newPsdData[deviceId].PsdCmd;/*操作屏蔽门的命令*/
LongToChar(newPsdData[deviceId].CmdSetCycle,&outString[outStringLength]);/*命令设置周期*/
outStringLength += 4u;
ShortToChar(pPsdDataCC[deviceId].SrcVobcId, &outString[outStringLength]);/*操作该屏蔽门的当前VOBC编号CC*/
outStringLength += 2U;
outString[outStringLength] = pPsdDataCC[deviceId].PsdCmd;/*操作屏蔽门的命令CC(0x00-默认值，0x55-打开PSD命令，0xAA-关闭PSD命令，0xFF-查询PSD命令)*/
outStringLength++;
LongToChar(pPsdDataCC[deviceId].CmdSetCycle, &outString[outStringLength]);/*命令设置周期CC*/
outStringLength += 4U;
LongToChar(newPsdData[deviceId].CmdSetCyclePsc,&outString[outStringLength]);/*psc状态设置周期*/
outStringLength += 4u;
outString[outStringLength++] = newPsdData[deviceId].doorOpenButtonState;/*站台开门按钮状态*/
@@ -1532,6 +1628,8 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
outStringLength += 4u;
outString[outStringLength++] = newPsdData[deviceId].StartDetectionState;/*启动探测状态*/
outString[outStringLength++] = newPsdData[deviceId].StopDetectionState; /*停止探测状态*/
LongToChar(newPsdData[deviceId].StopDetectionCycNum,&outString[outStringLength]);/*停止探测周期*/
outStringLength += 4u;
outString[outStringLength++] = newPsdData[deviceId].VOBCDoorState; /*VOBC车门状态*/
LongToChar(newPsdData[deviceId].PCBPressCycNum,&outString[outStringLength]);/*PCB按下起始周期*/
outStringLength += 4u;
@@ -1561,6 +1659,14 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
outStringLength++;
LongToChar(newPsdData[deviceId].dwPsdRelayDownCycNum, &outString[outStringLength]); /*PSD门关继电器落下起始周期*/
outStringLength += 4U;
outString[outStringLength] = newPsdData[deviceId].JXTCMutualLockFaultState; /*间隙探测旁路按钮故障状态*/
outStringLength++;
LongToChar(newPsdData[deviceId].JXTCMutualLockStartCycNum, &outString[outStringLength]); /*间隙探测旁路按钮按压起始周期*/
outStringLength += 4U;
outString[outStringLength++] = newPsdData[deviceId].ibpButtonState;/*IBP盘发车按钮状态*/
LongToChar(newPsdData[deviceId].IBPPressCycNum, &outString[outStringLength]); /*IBP盘发车按钮按下周期*/
outStringLength += 4U;
}
}
else
@@ -1604,12 +1710,14 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
deviceId = GetGaragedoorId(ii);
comparaResult = DeviceCompara((UINT8*)(&Record_GaragedoorDataStru[deviceId]), (UINT16)sizeof(GaragedoorDataStruct),
(UINT8*)(&newGaragedoorData[deviceId]), (UINT16)sizeof(GaragedoorDataStruct));
comparaResultCC = DeviceCompara((UINT8*)(&Record_GaragedoorDataStruCC[deviceId]), (UINT16)sizeof(GaragedoorDataStructCC),
(UINT8*)(&pGaragedoorDataCC[deviceId]), (UINT16)sizeof(GaragedoorDataStructCC));
if (0u==comparaResult)
if ((0U == comparaResult) && (0U == comparaResultCC))
{/*比较数据一致*/
}
else if (1u==comparaResult )
else if ((1U == comparaResult) || (1U == comparaResultCC))
{/*比较数据不一致*/
if (CI_ERROR==Flag)
@@ -1624,7 +1732,7 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
outStringLength += 2u;
outString[outStringLength++] = newGaragedoorData[deviceId].GaragedoorState; /*车库门状态 (动态字段)*/
outString[outStringLength++] = newGaragedoorData[deviceId].GaragedoorAllowCloseFlag; /*车库门允许关门标志ZC*/
outString[outStringLength++] = newGaragedoorData[deviceId].GDAllowCloseFlagIVOC; /*车库门允许关门标志IVOC*/
outString[outStringLength++] = pGaragedoorDataCC[deviceId].GDAllowCloseFlagIVOC; /*车库门允许关门标志IVOC*/
outString[outStringLength++] = newGaragedoorData[deviceId].GaragedoorModeState; /*车库门模式状态*/
outString[outStringLength++] = newGaragedoorData[deviceId].GaragedoorFaultState; /*车库门故障状态*/
outString[outStringLength++] = newGaragedoorData[deviceId].GaragedoorPangLuState; /*车库门旁路状态*/;
@@ -1632,7 +1740,7 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
outString[outStringLength++] = newGaragedoorData[deviceId].cmdProcessState; /* 命令处理状态 */
LongToChar(newGaragedoorData[deviceId].waiteZCResponseStartCycNum,&outString[outStringLength]);/* 等待ZC反馈开始时间 */
outStringLength += 4u;
LongToChar(newGaragedoorData[deviceId].waiteIVOCResponseStartCycNum, &outString[outStringLength]);/* 等待IVOC反馈开始时间 */
LongToChar(pGaragedoorDataCC[deviceId].waiteIVOCResponseStartCycNum, &outString[outStringLength]);/* 等待IVOC反馈开始时间 */
outStringLength += 4u;
LongToChar(newGaragedoorData[deviceId].GaragedoorOpenStartCycNum,&outString[outStringLength]);/* 车库门打开开始周期 */
outStringLength += 4u;
@@ -1681,12 +1789,14 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
deviceId = GetFloodGateId(ii);
comparaResult = DeviceCompara((UINT8*)(&Record_FloodGateDataStru[deviceId]), (UINT16)sizeof(FloodGateDataStruct),
(UINT8*)(&pNewFloodGateData[deviceId]), (UINT16)sizeof(FloodGateDataStruct));
comparaResultCC = DeviceCompara((UINT8*)(&Record_FloodGateDataStruCC[deviceId]), (UINT16)sizeof(FloodGateDataStructCC),
(UINT8*)(&pNewFloodGateDataCC[deviceId]), (UINT16)sizeof(FloodGateDataStructCC));
if (0u==comparaResult )
if ((0U == comparaResult) && (0U == comparaResultCC))
{/*比较数据一致*/
}
else if (1u==comparaResult )
else if ((1U == comparaResult) || (1U == comparaResultCC))
{/*比较数据不一致*/
if (CI_ERROR==Flag )
@@ -1706,19 +1816,19 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
outString[outStringLength++] = pNewFloodGateData[deviceId].CurAgreeCloseStateIn; /*当前同意关门采集状态*/;
outString[outStringLength++] = pNewFloodGateData[deviceId].CurAgreeCloseStateOut; /* 当前同意关门输出状态（动态字段）*/
outString[outStringLength++] = pNewFloodGateData[deviceId].FloodGateCloseApplyIvocSum; /*防淹门关门申请列车数量*/
for (jj = 0u; jj < pNewFloodGateData[deviceId].FloodGateCloseApplyIvocSum; jj++)
outString[outStringLength++] = pNewFloodGateDataCC[deviceId].FloodGateCloseApplyIvocSum; /*防淹门关门申请列车数量*/
for (jj = 0u; jj < pNewFloodGateDataCC[deviceId].FloodGateCloseApplyIvocSum; jj++)
{
ShortToChar(pNewFloodGateData[deviceId].FloodGateCloseApplyIvocId[jj], &outString[outStringLength]);/*防淹门关门申请列车ID*/
ShortToChar(pNewFloodGateDataCC[deviceId].FloodGateCloseApplyIvocId[jj], &outString[outStringLength]);/*防淹门关门申请列车ID*/
outStringLength += 2u;
}
outString[outStringLength++] = pNewFloodGateData[deviceId].FloodGateCloseAnsIvocSum; /*防淹门关门列车回复列车数量*/
for (jj = 0u; jj < pNewFloodGateData[deviceId].FloodGateCloseAnsIvocSum; jj++)
outString[outStringLength++] = pNewFloodGateDataCC[deviceId].FloodGateCloseAnsIvocSum; /*防淹门关门列车回复列车数量*/
for (jj = 0u; jj < pNewFloodGateDataCC[deviceId].FloodGateCloseAnsIvocSum; jj++)
{
ShortToChar(pNewFloodGateData[deviceId].FloodGateCloseFromIvocStru[jj].wTrainId, &outString[outStringLength]);/*列车同意防淹门关门请求列车ID*/
ShortToChar(pNewFloodGateDataCC[deviceId].FloodGateCloseFromIvocStru[jj].wTrainId, &outString[outStringLength]);/*列车同意防淹门关门请求列车ID*/
outStringLength += 2u;
outString[outStringLength++] = pNewFloodGateData[deviceId].FloodGateCloseFromIvocStru[jj].wFloodGateCloseIvocFlag; /*列车同意防淹门关门请求状态*/
outString[outStringLength++] = pNewFloodGateDataCC[deviceId].FloodGateCloseFromIvocStru[jj].wFloodGateCloseIvocFlag; /*列车同意防淹门关门请求状态*/
}
}
@@ -1762,12 +1872,14 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
deviceId = GetOverlapId(ii);
comparaResult = DeviceCompara((UINT8*)(&Record_OverlapDataStru[deviceId]), (UINT16)sizeof(OverlapDataStruct),
(UINT8*)(&newOverlapData[deviceId]), (UINT16)sizeof(OverlapDataStruct));
comparaResultCC = DeviceCompara((UINT8*)(&Record_OverlapDataStruCC[deviceId]), (UINT16)sizeof(OverlapDataStructCC),
(UINT8*)(&pOverlapDataCC[deviceId]), (UINT16)sizeof(OverlapDataStructCC));
if (0u==comparaResult)
if ((0U == comparaResult) && (0U == comparaResultCC))
{/*比较数据一致*/
}
else if (1u==comparaResult )
else if ((1U == comparaResult) || (1U == comparaResultCC))
{/*比较数据不一致*/
if (CI_ERROR != Flag)
@@ -1782,6 +1894,10 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
outStringLength += 4u;
LongToChar(newOverlapData[deviceId].XuanPaiStartCycNum,&outString[outStringLength]);/*保护区段选排开始周期号*/
outStringLength += 4u;
LongToChar(newOverlapData[deviceId].dwAtsLastTimeLockCyc, &outString[outStringLength]);/*最近一次ATS锁闭保护区段周期号*/
outStringLength += 4u;
outString[outStringLength++] = newOverlapData[deviceId].OverlapFromSetRouteCmdFlag; /*保护区段由进路办理时连带的标志*/
outString[outStringLength++] = newOverlapData[deviceId].chPreLaborUnlockState; /*之前人工解锁状态*/
outString[outStringLength++] = newOverlapData[deviceId].OverlapUnlockApplyFlag;/*向ZC申请解锁保护区段解锁标志*/
outString[outStringLength++] = newOverlapData[deviceId].OverlapCanLaborUnlockFlag;/*保护区段可以人工解锁标志*/
outString[outStringLength++] = newOverlapData[deviceId].OverlapLaborUnlockSetState;/*保护区段人工解锁设置状态*/
@@ -1798,10 +1914,10 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
outStringLength += 2U;
outString[outStringLength++] = newOverlapData[deviceId].laborLockOverlapCmd;/*人工锁闭保护区段命令标志*/
ShortToChar(newOverlapData[deviceId].wOverlapUnlockApplyTrainId, &outString[outStringLength]);/*申请解锁保护区段的列车ID*/
ShortToChar(pOverlapDataCC[deviceId].wOverlapUnlockApplyTrainId, &outString[outStringLength]);/*申请解锁保护区段的列车ID*/
outStringLength += 2U;
LongToChar(newOverlapData[deviceId].dwReqIvocUnLockStartCycNum, &outString[outStringLength]);/*向车申请解锁保护区段起始周期号*/
LongToChar(pOverlapDataCC[deviceId].dwReqIvocUnLockStartCycNum, &outString[outStringLength]);/*向车申请解锁保护区段起始周期号*/
outStringLength += 4U;
outString[outStringLength++] = newOverlapData[deviceId].cProSwitchCheckResultFlag;/*跨控区防护道岔检查结果标志（0xFF：默认值，0x55：失败，0xAA：成功）*/
@@ -1876,11 +1992,14 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
comparaResult = DeviceCompara((UINT8*)(&Record_AxisSecDataStru[deviceId]), (UINT16)sizeof(AxisSectionDataStruct),
(UINT8*)(&newAxisSecData[deviceId]), (UINT16)sizeof(AxisSectionDataStruct));
if (0u==comparaResult)
comparaResultCC = DeviceCompara((UINT8*)(&Record_AxisSecDataStruCC[deviceId]), (UINT16)sizeof(AxisSectionDataStructCC),
(UINT8*)(&pAxisSecDataCC[deviceId]), (UINT16)sizeof(AxisSectionDataStructCC));
if ((0u==comparaResult) && (0U == comparaResultCC))
{/*比较数据一致*/
}
else if (1u==comparaResult )
else if ((1U==comparaResult ) || (1U == comparaResultCC))
{/*比较数据不一致*/
if (CI_ERROR != Flag)
@@ -1890,20 +2009,20 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
ShortToChar(newAxisSecData[deviceId].AxisSectionId,&outString[outStringLength]);/*计轴区段ID*/
outStringLength += 2u;
outString[outStringLength++] = newAxisSecData[deviceId].AxisArbState;/*计轴ARB状态 (动态字段)*/
outString[outStringLength] = pAxisSecDataCC[deviceId].AxisArbState;/*计轴ARB状态CC(0x55-未ARB，0xaa-ARB)*/
outStringLength++;
outString[outStringLength++] = newAxisSecData[deviceId].AxisJumpLockApplyFlag;/*跳跃锁闭申请标志*/
outString[outStringLength++] = newAxisSecData[deviceId].AxisJumpLockCancelApplyFlag;/*跳跃锁闭取消申请标志*/
LongToChar(newAxisSecData[deviceId].AxisJumpLockApplyCylce,&outString[outStringLength]);/*跳跃锁闭申请周期号*/
outStringLength += 4u;
outString[outStringLength++] = newAxisSecData[deviceId].AxisJumpLockState;/*跳跃锁闭状态*/
outString[outStringLength++] = newAxisSecData[deviceId].AxisOccStatus;/*计轴占用状态*/
LongToChar(newAxisSecData[deviceId].dwAxisOccCycNum, &outString[outStringLength]);/*计轴占用起始周期*/
outString[outStringLength++] = pAxisSecDataCC[deviceId].AxisOccStatus;/*计轴占用状态*/
LongToChar(pAxisSecDataCC[deviceId].dwAxisOccCycNum, &outString[outStringLength]);/*计轴占用起始周期*/
outStringLength += 4u;
LongToChar(newAxisSecData[deviceId].dwUtOccupyCycNum, &outString[outStringLength]);/*计轴最近坏车占用周期*/
LongToChar(pAxisSecDataCC[deviceId].dwUtOccupyCycNum, &outString[outStringLength]);/*计轴最近坏车占用周期*/
outStringLength += 4u;
ShortToChar(newAxisSecData[deviceId].wPosMonitorTrainId, &outString[outStringLength]); /*监督有效的列车ID*/
ShortToChar(pAxisSecDataCC[deviceId].wPosMonitorTrainId, &outString[outStringLength]); /*监督有效的列车ID*/
outStringLength += 2u;
outString[outStringLength] = newAxisSecData[deviceId].cAxisTXSafeLocFlag; /*计轴区段列车安全位置覆盖标志：0x55-无效；0xAA-有效*/
outStringLength++;
}
}
else
@@ -2289,6 +2408,9 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
outString[outStringLength] = pNewTrainInfoData[deviceId].chTrainReportState; /*列车汇报状态*/
outStringLength++;
outString[outStringLength++] = pNewTrainInfoData[deviceId].chEaCmdState; /*区间疏散命令状态：0x55 有效；0xAA 无效*/
outString[outStringLength++] = pNewTrainInfoData[deviceId].chtrainControlMode;/*当前控车模式*/
outString[outStringLength++] = pNewTrainInfoData[deviceId].chTrainPostionMode; /*列车位置模式，0无位置，1使用IVOC位置，2使用VOBC位置*/
}
@@ -2707,17 +2829,19 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
break;
}
pNonAutoReturnData = GetNonReturnData();
pNonReturnDataStruCC = GetNonReturnDataCC();
/*比较数据*/
deviceId = GetNonReturnId(ii);
comparaResult = DeviceCompara((UINT8*)(&Record_NonReturnDataStru[deviceId]), (UINT16)sizeof(NonAutoReturnDataStruct),
(UINT8*)(&pNonAutoReturnData[deviceId]), (UINT16)sizeof(NonAutoReturnDataStruct));
if (0u == comparaResult)
comparaResultCC = DeviceCompara((UINT8*)(&Record_NonReturnDataStruCC[deviceId]), (UINT16)sizeof(NonAutoReturnDataStructCC),
(UINT8*)(&pNonReturnDataStruCC[deviceId]), (UINT16)sizeof(NonAutoReturnDataStructCC));
if ((0U == comparaResult) && (0U == comparaResultCC))
{/*比较数据一致*/
}
else if (1u == comparaResult)
else if ((1U == comparaResult) || (1U == comparaResultCC))
{/*比较数据不一致*/
if (CI_ERROR == Flag)
@@ -2728,10 +2852,12 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
{
/**************打印数据信息****************/
outString[outStringLength++] = pNonAutoReturnData[deviceId].IndicatorDevID; /*指示灯设备ID*/
ShortToChar(pNonAutoReturnData[deviceId].cmdSetTrainId, &outString[outStringLength]);/*命令列车ID*/
ShortToChar(pNonReturnDataStruCC[deviceId].cmdSetTrainId, &outString[outStringLength]);/*命令列车ID*/
outStringLength += 2u;
outString[outStringLength++] = pNonAutoReturnData[deviceId].VobcToCIAutoRtnIndicFlashState; /*车载给联锁的无人折返指示灯闪灯状态*/
outString[outStringLength++] = pNonAutoReturnData[deviceId].VobcToCIAutoRtnIndicSteadyState; /*车载给联锁的无人折返指示灯稳灯状态*/
outString[outStringLength] = pNonAutoReturnData[deviceId].VobcToCIAutoRtnIndicFlashState; /*车载给联锁的无人折返指示灯闪灯状态*/
outStringLength++;
outString[outStringLength] = pNonAutoReturnData[deviceId].VobcToCIAutoRtnIndicSteadyState; /*车载给联锁的无人折返指示灯稳灯状态*/
outStringLength++;
ShortToChar(pNonAutoReturnData[deviceId].RtnRelayAdhesionState.AdhesionRealyId, &outString[outStringLength]);/*粘连继电器ID*/
outStringLength += 2u;
outString[outStringLength++] = pNonAutoReturnData[deviceId].RtnRelayAdhesionState.AdhesionState; /*继电器粘连状态*/
@@ -2923,7 +3049,7 @@ UINT8 DeviceCompara(UINT8* deviceStruAddr1, const UINT16 deviceStruLen1,
void GetVirCIKeyDataStru(void)
{
UINT8 ii = 0u;
UINT8 jj = 0U;
for(ii=0u;ii<g_VirtualCIStructData.virtualCiNum;ii++)
{
@@ -2942,12 +3068,6 @@ void GetVirCIKeyDataStru(void)
newVirCIKeyDataStru[ii].ZfwValidCycNum = g_VirtualCIStructData.virtualCi[ii].ZfwValidCycNum;
for (jj = 0U; jj < RTNINDICATOR_SUM_MAX; jj++)
{
newVirCIKeyDataStru[ii].RtnIndicatorKeyData[jj].PrintVirCiIndicatorDevId = g_VirtualCIStructData.virtualCi[ii].VirCIRtnIndicatorStaData[jj].VirCiIndicatorDevId;
newVirCIKeyDataStru[ii].RtnIndicatorKeyData[jj].PrintVirCiFlashState = g_VirtualCIStructData.virtualCi[ii].VirCIRtnIndicatorStaData[jj].VirCiFlashState;
newVirCIKeyDataStru[ii].RtnIndicatorKeyData[jj].PrintVirCiSteadyState = g_VirtualCIStructData.virtualCi[ii].VirCIRtnIndicatorStaData[jj].VirCiSteadyState;
}
newVirCIKeyDataStru[ii].ZfwjHunXianFLag = g_VirtualCIStructData.virtualCi[ii].ZfwjHunXianFLag;
}
}
TSCP/src/APP/ciapp/LogicManage/InterlockCommonManage.c
+49 -82
View File
@@ -16,6 +16,7 @@
#include "../Section/LogicSectionDataManage.h"
#include "LogicalRouteDataManage.h"
#include "../LogicProcess/LogicalRouteLogicCheck.h"
#include "../Overlap/OverlapDataManage.h"
/* C01_进路监督级别确认 */
/*
@@ -564,6 +565,8 @@ void SetRouteRelProSwitchLockSta(const UINT16 routeId, const UINT8 lockCommand)
UINT16 protectSwitchId = 0u; /*防护道岔ID*/
UINT8 routeProtectSwitchSum = 0u; /*防护道岔数目*/
RouteProtectSwitchStruct* routeProtectSwitchStru = NULL; /*防护道岔数据*/
UINT8 cSwitchCurPos = 0U; /*道岔当前位置*/
UINT8 cFuncRet = CI_ERROR;
routeProtectSwitchSum = GetRouteRelatedProtectSwitchSum(routeId); /*获取防护道岔数目*/
routeProtectSwitchStru = GetRouteRelatedProtSwitchData(routeId); /*获取防护道岔数据*/
@@ -589,6 +592,11 @@ void SetRouteRelProSwitchLockSta(const UINT16 routeId, const UINT8 lockCommand)
for (ii = 0u; ii < routeProtectSwitchSum; ii++)
{
protectSwitchId = routeProtectSwitchStru[ii].ProtectSwitchId;
cSwitchCurPos = GetSwitchCurPosition(protectSwitchId);
cFuncRet = checkSwtLastValDrvPosStayorNot(protectSwitchId, routeProtectSwitchStru[ii].ProtectPosition);
if ((SWITCH_LOCK_PROTECT_CANCEL == lockCommand)
|| ((SWITCH_LOCK_PROTECT_SET == lockCommand) && (cSwitchCurPos == routeProtectSwitchStru[ii].ProtectPosition) && (CI_SUCCESS == cFuncRet)))
{
SetSwitchLockStatus(SWITCH_PLOCKTYPE_ROUTE, routeId, protectSwitchId, lockCommand); /*设置道岔防护锁闭状态*/
/*RC 13.0.0 修：不检查防护道岔中双动道岔另一端*/
#if 0
@@ -601,6 +609,11 @@ void SetRouteRelProSwitchLockSta(const UINT16 routeId, const UINT8 lockCommand)
}
#endif
}
else
{
/*防护道岔不在防护位置或防护道岔存在反向驱动，不设置防护锁闭*/
}
}
}
else
{
@@ -789,7 +802,6 @@ void PhySecFaultUnlockLogicManage(const UINT16 phySectionId,const UINT8 virCIid)
UINT8 goExec = CI_ERROR;
UINT8 autoTriggerType = 0U;
UINT8 belongvirCIid = 0U;
UINT8 includeVirFlag = GetCiFunctionSwitchConfig(FUNC_INCLUDEVIRCI_FLAG);
UINT8 chPhyIncLogSum = 0U; /*包含逻辑区段数目*/
UINT16* pPhyIncLogId = NULL; /*物理区段包含逻辑区段ID数组*/
UINT16 wLogLockBelongRouteId = 0U; /*逻辑区段锁闭所属进路ID*/
@@ -1026,8 +1038,6 @@ void PhySecFaultUnlockLogicManage(const UINT16 phySectionId,const UINT8 virCIid)
}
}
else if((phyBelongCi == localCiId)&&(TRANSMIT_STATE_GOOD == commState))
{
if(FUNC_SWITCH_ON == includeVirFlag)
{
belongvirCIid = GetPhySecBelongVirCiId(phySectionId);
if((belongvirCIid == virCIid)&&(0u != virCIid))/*区故解可以由相邻虚拟联锁现地操作，不相邻不能操作*/
@@ -1037,12 +1047,6 @@ void PhySecFaultUnlockLogicManage(const UINT16 phySectionId,const UINT8 virCIid)
}
}
else
{
/*进路属于相邻联锁，且区段属于本联锁时，传递区段故障解锁命令 */
AddCiSendToCiCmdInfo(CI_CMD_SECTION_FAULT_UNLOCK,phySectionId,0u,routeBelongCi);
}
}
else
{
/*异常情况，不处理区故解命令*/
}
@@ -1380,6 +1384,12 @@ void RouteRecoverOpenProc(const UINT16 routeId)
UINT8 errType = CI_ERROR;
UINT8 localCiType = GetLocalCiType();/*获得联锁类型*/
UINT16 wStartSignalId = 0U; /*进路始端信号机ID*/
UINT8 chVirCiId = 0U;/*虚拟联锁*/
UINT8 chLocalVirCiType = 0U;
chVirCiId = GetRouteBelongVirCiId(routeId);
chLocalVirCiType = GetLocalVirCiType(chVirCiId);
routeState = GetRouteState(routeId);
recoverState = GetRouteRecoverOpenFlag(routeId);
@@ -1388,7 +1398,7 @@ void RouteRecoverOpenProc(const UINT16 routeId)
{
if (ROUTE_RECOVER_STA_WAIT == recoverState)
{
if ((CI_TYPE_ZX == localCiType) || (CI_TYPE_SCX == localCiType))
if ((CI_TYPE_ZX == chLocalVirCiType) || (CI_TYPE_SCX == chLocalVirCiType))
{
errType = RecoverOpenRouteCheck(routeId);
}
@@ -1433,7 +1443,6 @@ void SetAtsExpectLockOverlapIdProc(const UINT16 expLkOverlapId,const UINT8 lockT
UINT16 ii = 0u;
UINT16 routeOverlapSum = 0u; /*进路保护区段数目*/
UINT16 routeId = 0u; /*进路ID*/
UINT16 routedLockOverlapId = 0u; /*进路锁闭过OverlapId*/
UINT8 retVal = CI_SUCCESS; /*执行检查*/
UINT8 routeState = 0u; /*进路状态*/
UINT16 preOverlepId = 0u;
@@ -1443,9 +1452,9 @@ void SetAtsExpectLockOverlapIdProc(const UINT16 expLkOverlapId,const UINT8 lockT
UINT8 flag = 0u;
UINT8 belongCiId = 0u;
UINT8 localCiId = GetSystemParaLocalCiId(); /*获取本机联锁ID*/
UINT8 includeVirFlag = GetCiFunctionSwitchConfig(FUNC_INCLUDEVIRCI_FLAG);
UINT8 virCIid = 0u;
UINT8 ciCtrModeFlag = 0u;
UINT32 dwCurCycNum = Get2oo2CurCycleNum();
if ((0u == expLkOverlapId) || (UINT16_MAX == expLkOverlapId))
{/*判断输入参数有效性*/
@@ -1514,29 +1523,15 @@ void SetAtsExpectLockOverlapIdProc(const UINT16 expLkOverlapId,const UINT8 lockT
if (CI_SUCCESS == retVal)
{
virCIid = GetOverlapBelongVirCiId(expLkOverlapId);
if(FUNC_SWITCH_ON == includeVirFlag)
{
ciCtrModeFlag = GetVirCImode(virCIid);/*获取联锁控制模式*/
}
else
{
ciCtrModeFlag = GetCiModeFlag(); /*获取联锁控制模式*/
}
ciCtrModeFlag = GetVirCImode(virCIid);/*获取联锁控制模式*/
if ((CI_MODE_CI_LOCAL == ciCtrModeFlag) || (0u == ciCtrModeFlag))/*处于联锁控或者获取错误，发送现地不能响应人工锁闭命令*/
{
retVal = CI_ERROR;
}
}
/*add by shl*/
if (CI_SUCCESS == retVal)
{
routedLockOverlapId = GetRouteOverlapLockedId(routeId); /*获取进路锁闭过保护区段ID*/
if (0u == routedLockOverlapId)
{
/*判断进路状态，是否满足锁闭保护区段条件，若满足则设置期望锁闭保护区段*/
routeState = GetRouteState(routeId);
@@ -1558,6 +1553,7 @@ void SetAtsExpectLockOverlapIdProc(const UINT16 expLkOverlapId,const UINT8 lockT
{
SetOverlapAtsOrlaborLockCmdFlag(expLkOverlapId, LOCK_OVERLAP_CMD_YES);/*设置保护区段锁闭命令标志，用于保护区段解锁倒计时计算*/
SetOverlaplaborLockCmdFlag(expLkOverlapId, LOCK_OVERLAP_CMD_YES);/*设置人工锁闭标志，用于人工命令一次有效处理*/
ClearPreLoaborUnlockState(expLkOverlapId);
}
else if (ATS_LOCK_OVERLAP == lockType)/*ATS锁闭*/
{
@@ -1574,18 +1570,14 @@ void SetAtsExpectLockOverlapIdProc(const UINT16 expLkOverlapId,const UINT8 lockT
}
SetRouteAtsExpLkOverlapId(routeId, expLkOverlapId);
SetOverlapFromSetRouteCmdFlag(expLkOverlapId, OVERLAP_ROUTE_FLAG_NO);/*清除标志*/
SetOverlapAtsLastTimeLockCyc(expLkOverlapId, dwCurCycNum);
retVal = CI_SUCCESS;
}
else
{
retVal = CI_ERROR;
}
}
}
}
}
}
@@ -1609,7 +1601,6 @@ UINT8 CheckPhySecFaultUnlockCanDo(const UINT16 phySectionId,const UINT8 virCIid)
UINT16 lockBelongRouteId = 0u; /*区段锁闭所属进路ID*/
UINT8 reVal = CI_ERROR;
UINT8 belongvirCIid = 0u;
UINT8 includeVirFlag = GetCiFunctionSwitchConfig(FUNC_INCLUDEVIRCI_FLAG);
UINT8 isErrLock = CI_ERROR;
UINT8 phyLockState = 0U;
@@ -1635,8 +1626,7 @@ UINT8 CheckPhySecFaultUnlockCanDo(const UINT16 phySectionId,const UINT8 virCIid)
}
if(CI_SUCCESS == reVal)
{
if(FUNC_SWITCH_ON == includeVirFlag)
{
belongvirCIid = GetRouteBelongVirCiId(lockBelongRouteId);
if(0u < virCIid)
{
@@ -1662,11 +1652,7 @@ UINT8 CheckPhySecFaultUnlockCanDo(const UINT16 phySectionId,const UINT8 virCIid)
reVal = CI_ERROR;
}
}
else
{
reVal = CI_SUCCESS;
}
}
/*按顺序解锁进路异常锁闭*/
@@ -1927,6 +1913,18 @@ void ClearSomeFlagDependRouteState(const UINT16 routeId)
{
SetRouteGroupRouteCmdFlag(routeId, ROUTE_GROUPROUTE_CMD_NO); /*清除进路的组合进路命令标志*/
}
/*若进路处于以下状态，清除联挂进路标志*/
if ((ROUTE_STATE_IDLE == routeState) || (ROUTE_STATE_DELAY_UNLOCK == routeState)
|| (ROUTE_STATE_LEAD_XUANPAI == routeState) || (ROUTE_STATE_LEAD_LOCK == routeState)
|| (ROUTE_STATE_LEAD_LOCKERR == routeState) || (ROUTE_STATE_LEAD_OPEN == routeState))
{
SetRouteCouplinkFlag(routeId, ROUTE_COUPLINK_FLAG_NO);
}
else
{
/*不处理*/
}
}
/*
@@ -3400,14 +3398,12 @@ void OtherCiLogSecFaultUnlockProcess(const UINT16 wLogSectionId, const UINT8 chV
UINT8 chLogFaultUnLockRes = 0U;/*逻辑区段故障解锁条件检查结果*/
UINT8 chLogSecBelongRouteDir = 0U;/*逻辑区段锁闭所属进路方向*/
UINT8 chRouteLogSecHaveUnLock = 0u;/*进路逻辑区段是否已解锁*/
UINT8 chIncludeVirFlag = 0U;/*是否支持虚拟联锁*/
UINT8 chBelongVirCiId = 0U;/*逻辑区段所属虚拟联锁ID*/
UINT16 wLogSecBelongPhySecId = 0U;/*逻辑区段所属物理区段ID*/
chLocalCiId = GetSystemParaLocalCiId(); /*获取本机联锁ID*/
wLogLockBelongRouteId = GetLogSecLockBelongRoute(wLogSectionId);
chFuncSwitch = GetCiFunctionSwitchConfig(FUNC_SWITCH_USE_RELAY_INTERFACE_BETWEEN_NEIGHBOURCI);
chIncludeVirFlag = GetCiFunctionSwitchConfig(FUNC_INCLUDEVIRCI_FLAG);
chConfirmRelayInterfaceFlag = GetCiCiRelayInterfConfirmFlag();/*继电接口确认状态*/
if ((0U < wLogLockBelongRouteId) && (ROUTE_SUM_MAX > wLogLockBelongRouteId))
@@ -3441,21 +3437,15 @@ void OtherCiLogSecFaultUnlockProcess(const UINT16 wLogSectionId, const UINT8 chV
else if ((chLocalCiId == chLogSecBelongCiId) && (TRANSMIT_STATE_GOOD == chCommState))
{
wLogSecBelongPhySecId = GetLgcSecRelativePhySecId(wLogSectionId);
if (FUNC_SWITCH_ON == chIncludeVirFlag)
{
chBelongVirCiId = GetLogSecBelongVirCiId(wLogSectionId);
if ((chVirCIid == chBelongVirCiId) && (0U != chVirCIid))
{
/*进路属于相邻联锁，且区段属于本联锁时，传递区段故障解锁命令 */
AddCiSendToCiCmdInfo(CI_CMD_SECTION_FAULT_UNLOCK, wLogSecBelongPhySecId, 0U, chRouteBelongCiId);
}
}
else
{
/*进路属于相邻联锁，且区段属于本联锁时，传递区段故障解锁命令 */
AddCiSendToCiCmdInfo(CI_CMD_SECTION_FAULT_UNLOCK, wLogSecBelongPhySecId, 0U, chRouteBelongCiId);
}
}
else
{
@@ -3476,7 +3466,6 @@ UINT8 CheckLogSecFaultUnlockCanDo(const UINT16 wLogSectionId, const UINT8 chVirC
UINT16 wLockBelongRouteId = 0U; /*区段锁闭所属进路ID*/
UINT8 reVal = CI_ERROR;
UINT8 chBelongvirCIid = 0U;
UINT8 chIncludeVirFlag = GetCiFunctionSwitchConfig(FUNC_INCLUDEVIRCI_FLAG);
if ((0u == wLogSectionId) || (LOGIC_SECTION_SUM_MAX <= wLogSectionId))
{
@@ -3499,8 +3488,7 @@ UINT8 CheckLogSecFaultUnlockCanDo(const UINT16 wLogSectionId, const UINT8 chVirC
}
if (CI_SUCCESS == reVal)
{
if (FUNC_SWITCH_ON == chIncludeVirFlag)
{
chBelongvirCIid = GetRouteBelongVirCiId(wLockBelongRouteId);
if (0U < chVirCIid)
{
@@ -3527,11 +3515,6 @@ UINT8 CheckLogSecFaultUnlockCanDo(const UINT16 wLogSectionId, const UINT8 chVirC
}
}
else
{
reVal = CI_SUCCESS;
}
}
return reVal;
}
@@ -4488,7 +4471,6 @@ void DriveLogRouteSignalClose(const UINT16 wLogSignalId)
UINT8 sigalMaintainState = 0u;
UINT8 detainOpenRedBright = 0u;
UINT8 signalDetainFlag = 0u;
UINT8 includeVirFlag = GetCiFunctionSwitchConfig(FUNC_INCLUDEVIRCI_FLAG);
if ((0u == wLogSignalId) || (SIGNAL_SUM_MAX <= wLogSignalId))
{
/*不做处理*/
@@ -4496,15 +4478,11 @@ void DriveLogRouteSignalClose(const UINT16 wLogSignalId)
else
{
/*虚拟联锁兼容*/
if (FUNC_SWITCH_ON == includeVirFlag)
{
belongVirCIid = GetSignalBelongVirCiId(wLogSignalId);
allSignalBrightFlag = GetVirCIAllSignalBrightState(belongVirCIid); /*全站亮灯标志*/
}
else
{
allSignalBrightFlag = GetAllSignalBrightFlag(); /*全站亮灯标志*/
}
/*无论什么时候，复示信号机关闭都驱动红灭*/
signalIsfushiFlag = GetSignalIsfushiFlag(wLogSignalId);
@@ -5103,7 +5081,6 @@ void LogRouteErrLockFaultManage(const UINT16 wPhySectionId)
void SetAtsLockOverlapHaveRouteId(const UINT16 expLkOverlapId, const UINT16 routeId)
{
UINT16 routeOverlapSum = 0U; /*进路保护区段数目*/
UINT16 routedLockOverlapId = 0U; /*进路锁闭过OverlapId*/
UINT8 retVal = CI_SUCCESS; /*返回值*/
UINT8 routeState = 0U; /*进路状态*/
UINT16 preOverlepId = 0U;
@@ -5112,11 +5089,11 @@ void SetAtsLockOverlapHaveRouteId(const UINT16 expLkOverlapId, const UINT16 rout
UINT8 phySectionSta = 0U;
UINT8 belongCiId = 0U;
UINT8 localCiId = GetSystemParaLocalCiId(); /*获取本机联锁ID*/
UINT8 includeVirFlag = GetCiFunctionSwitchConfig(FUNC_INCLUDEVIRCI_FLAG);
UINT8 virCIid = 0U;
UINT8 ciCtrModeFlag = 0U;
UINT8 routeStateFlag = 0U;
UINT8 flag = 0U;
UINT32 dwCurCycNum = Get2oo2CurCycleNum();
routeStateFlag = GetRouteStateFlag(routeId);
@@ -5179,14 +5156,8 @@ void SetAtsLockOverlapHaveRouteId(const UINT16 expLkOverlapId, const UINT16 rout
if (CI_SUCCESS == retVal)
{
virCIid = GetOverlapBelongVirCiId(expLkOverlapId);
if (FUNC_SWITCH_ON == includeVirFlag)
{
ciCtrModeFlag = GetVirCImode(virCIid);/*获取联锁控制模式*/
}
else
{
ciCtrModeFlag = GetCiModeFlag(); /*获取联锁控制模式*/
}
if ((CI_MODE_CI_LOCAL == ciCtrModeFlag) || (0U == ciCtrModeFlag))/*处于联锁控或者获取错误，发送现地不能响应人工锁闭命令*/
{
@@ -5195,10 +5166,6 @@ void SetAtsLockOverlapHaveRouteId(const UINT16 expLkOverlapId, const UINT16 rout
}
if (CI_SUCCESS == retVal)
{
routedLockOverlapId = GetRouteOverlapLockedId(routeId); /*获取进路锁闭过保护区段ID*/
if (0U == routedLockOverlapId)
{
/*判断进路状态，是否满足锁闭保护区段条件，若满足则设置期望锁闭保护区段*/
routeState = GetRouteState(routeId);
@@ -5214,7 +5181,8 @@ void SetAtsLockOverlapHaveRouteId(const UINT16 expLkOverlapId, const UINT16 rout
|| (ROUTE_STATE_NEAR_LOCKERR == routeState)
|| ((ROUTE_STATE_AUTO_UNLOCK == routeState) && (ROUTE_STATE_FLAG_YES == routeStateFlag))
)
{/*设置指定ID进路的期望锁闭保护区段ID*/
{
/*设置指定ID进路的期望锁闭保护区段ID*/
/*仅处理ATS办理保护区段，不处理人工办理保护区段*/
phySectionId = GetRouteLastPhySectionId(routeId);
phySectionSta = GetPhySecCurMergeState(phySectionId);
@@ -5231,6 +5199,7 @@ void SetAtsLockOverlapHaveRouteId(const UINT16 expLkOverlapId, const UINT16 rout
SetOverlapFromSetRouteCmdFlag(expLkOverlapId, OVERLAP_ROUTE_FLAG_YES);/*设置保护区段由进路连带标识*/
SetOverlapAtsLastTimeLockCyc(expLkOverlapId, dwCurCycNum);
retVal = CI_SUCCESS;
}
else
@@ -5244,8 +5213,6 @@ void SetAtsLockOverlapHaveRouteId(const UINT16 expLkOverlapId, const UINT16 rout
}
}
}
if (0U == flag)
{/*发送的这个区段不属于任何进路的保护区段*/
TSCP/src/APP/ciapp/LogicManage/InterlockLogicManage.c
+534 -610
View File
File diff suppressed because it is too large Load Diff
TSCP/src/APP/ciapp/LogicManage/InterlockLogicManage.h
+12 -29
View File
@@ -628,14 +628,6 @@ void StartTrianTestManage(void);
*/
void StopTrianTestManage(void);
/*
* 功能描述： 取消临时限速设置
* 参数说明： 无
* 返回值 ：
CI_ERROR 失败
CI_SUCCESS 成功
*/
UINT8 CancleLinShiXianSuManage(void);
/*
* 功能描述： 取消临时限速设置
* 参数说明： 无
@@ -1142,12 +1134,12 @@ void LeadRouteFirstXuanPaiManage(const UINT16 routeId);
void SetOcPscPlConfirmFlag(UINT8 setFlag, const UINT16 ocPId);
/*
* 功能描述： 保护区段照查条件更新
* 功能描述： 保护区段状态更新
* 参数说明： const UINT16 wRouteId 进路ID
* 返回值 ：无
* by cgh 20250617
* by cgh 20250928
*/
void OverlapZhaoChaRelayUpDateManage(void);
void OverlapStateUpdateManage(void);
/*
* 功能描述： 更新列车向后跳跃允许状态处理
* 参数说明： 无
@@ -1156,28 +1148,19 @@ void OverlapZhaoChaRelayUpDateManage(void);
*/
void TrainJumpBackApplyProc(void);
/*
* 功能描述： 批量计轴复位命令逻辑管理
* 参数说明： const UINT8 cPhySecSum 物理区段数量
* const UINT16 pPhySecIdBuff[] 物理区段ID数组
* 返回值 ： void
* 功能描述： 办理联挂进路逻辑管理
* 参数说明： const UINT16 wRouteId
* 返回值 ： 无
* Create: 20250917
*/
void BatchAixsResetLogicManage(const UINT8 cPhySecSum, const UINT16 pPhySecIdBuff[], const UINT8 resetType);
void SetCouplinkRouteLogicManage(const UINT16 wRouteId);
/*
* 功能描述：牵出线区段外方进路检查
* 参数说明： const UINT16 wPhySecId 牵出线区段
* 返回值 ：CI_SUCCESS列车进路已办理 CI_ERROR未办理列车进路
* by fan 20260415
* 功能描述： 锁闭道岔逻辑管理
* 参数说明： void
* 返回值 ：
*/
UINT8 CheckQcxLiecheRoute(UINT16 wPhySecId);
/*
* 功能描述： 计轴区段跳跃锁闭状态机管理
* 参数说明： const UINT16 axisSecId, 计轴区段ID
* 返回值 ： void
* add by mpt 20260407
*/
void AxisJumpLockStateManage(const UINT16 axisSectionId);
void lockSwitchLogicManage(void);
#ifdef __cplusplus
}
TSCP/src/APP/ciapp/LogicManage/RouteRecoverManage.c
+87 -34
View File
@@ -189,7 +189,7 @@ UINT8 OpenCbtcLTrainRouteErrProcess(const UINT16 routeId, const UINT8 checkStep)
UINT8 sendLevel = ESEND_LEVEL_ZERO;
UINT8 routeReverseProperty = 0u;
UINT8 airShaftRouteType = 0u;
UINT8 chRouteCouplinkFlag = 0U;
/* 联锁逻辑检查 */
/* 进路监督模式为【CBTC】*/
@@ -325,8 +325,18 @@ UINT8 OpenCbtcLTrainRouteErrProcess(const UINT16 routeId, const UINT8 checkStep)
{
routeReverseProperty = GetRouteReverseProperty(routeId);
airShaftRouteType = GetAirShaftRouteType(routeId);
chRouteCouplinkFlag = GetRouteCouplinkFlag(routeId); /*获取进路联挂标志*/
if ((ROUTE_REVERSE_PROPERTY_YES == routeReverseProperty)|| (ROUTE_TYPE_AIRSHAFT == airShaftRouteType))
{ /*反向进路需检查所有区段的占用状态，之前由于不检查占用状态导致信号出清进路内方第一区段，信号机重开的问题*/
{
if (ROUTE_COUPLINK_FLAG_YES == chRouteCouplinkFlag)
{
/* 反向联挂进路允许追踪，区段条件在OpenCbtcRouteSectionErrCheck */
/*存在联挂标志，不在查反向进路全部空闲，其他条件检查;风井进路设置不上联挂标志所以需要检查全部区段空闲*/
}
else
{
/*反向进路需检查所有区段的占用状态，之前由于不检查占用状态导致信号出清进路内方第一区段，信号机重开的问题*/
/*风井进路不允许追踪办理，故开放条件需增加对进路内方所有区段的占用状态检查*/
devId = 0u;
devState = 0u;
@@ -343,6 +353,8 @@ UINT8 OpenCbtcLTrainRouteErrProcess(const UINT16 routeId, const UINT8 checkStep)
/* 失败返回 */
reResult = CI_ERROR;
}
}
/* 防护进路联锁条件检查 */
if (CI_SUCCESS == reResult)
{
@@ -427,26 +439,6 @@ UINT8 OpenCbtcLTrainRouteErrProcess(const UINT16 routeId, const UINT8 checkStep)
{
;
}
/*风井占用检查*/
if ((CI_SUCCESS == reResult) || (CI_ROUTE_RECOVER_ERR == reResult))
{
devId = 0u;
devState = 0u;
checkResult = RouteAirShaftSecOccuCheck(routeId, &devId, &devState);
if (CI_SUCCESS == checkResult)
{
/* 通过检查 */
}
else
{
/* 失败返回 */
reResult = CI_ERROR;
}
}
else
{
/*不处理*/
}
/* 侵限区段SPKS联锁条件检查 */
if ((CI_SUCCESS == reResult) || (CI_ROUTE_RECOVER_ERR == reResult))
@@ -783,7 +775,7 @@ UINT8 OpenCbtcReturnRouteErrProcess(const UINT16 routeId, const UINT8 checkStep)
/* 取消标志 */
UINT8 const zxqFlag = GetRouteZongQuXiaoFlag(routeId);
UINT8 const zrjFlag = GetRouteZongRenJieFlag(routeId);
UINT8 chRouteCouplinkFlag = 0U;
/*故障发送级别*/
UINT8 sendLevel = ESEND_LEVEL_ZERO;
@@ -920,8 +912,16 @@ UINT8 OpenCbtcReturnRouteErrProcess(const UINT16 routeId, const UINT8 checkStep)
{
devId = 0u;
devState = 0u;
chRouteCouplinkFlag = GetRouteCouplinkFlag(routeId); /*获取进路联挂标志*/
if (ROUTE_COUPLINK_FLAG_YES == chRouteCouplinkFlag)
{
checkResult = SetCouplinkRouteSecOccCheck(routeId, &devId, &devState);
}
else
{
checkResult = RouteAllSecOccuClearCheck(routeId, &devId, &devState);
if (checkResult == CI_SUCCESS)
}
if (CI_SUCCESS == checkResult)
{
/* 通过检查 */
reResult = CI_SUCCESS;
@@ -1366,6 +1366,7 @@ UINT8 KeepCbtcLTrainRouteErrProcess(const UINT16 routeId)
UINT16 trainEnteringRouteState = 0u;
UINT8 signalCrossState = 0u;
UINT8 rcWorkMode = 0U; /*rc工作模式*/
UINT8 chRouteCouplinkFlag = 0U;
rcWorkMode = GetLocalRcWorkMode();
/* 联锁逻辑检查 */
@@ -1491,7 +1492,16 @@ UINT8 KeepCbtcLTrainRouteErrProcess(const UINT16 routeId)
{ /*反向进路或风井进路需对进路内方所有区段的占压状态进行检查*/
devId = 0u;
devState = 0u;
chRouteCouplinkFlag = GetRouteCouplinkFlag(routeId); /*获取进路联挂标志*/
if (ROUTE_COUPLINK_FLAG_YES == chRouteCouplinkFlag)
{
checkResult = KeepCouplinkRouteSecOccCheck(routeId, &devId, &devState);;
}
else
{
checkResult = RouteAllSecOccuClearCheck(routeId, &devId, &devState);
}
if (checkResult == CI_SUCCESS)
{
/* 通过检查 */
@@ -1876,6 +1886,7 @@ UINT8 KeepCbtcReturnRouteErrProcess(const UINT16 routeId)
UINT8 trainEnteringRouteState =0u;
UINT8 signalCrossState = 0u;
UINT8 rcWorkMode = 0U; /*rc工作模式*/
UINT8 chRouteCouplinkFlag = 0U;
rcWorkMode = GetLocalRcWorkMode();
devState = GetRouteLevel(routeId);
if (ROUTE_LEVEL_CBTC == devState)
@@ -2010,8 +2021,17 @@ UINT8 KeepCbtcReturnRouteErrProcess(const UINT16 routeId)
}
}
else if(RC_WORK_MODE_CI == rcWorkMode)
{
chRouteCouplinkFlag = GetRouteCouplinkFlag(routeId); /*获取进路联挂标志*/
if (ROUTE_COUPLINK_FLAG_YES == chRouteCouplinkFlag)
{
checkResult = KeepCouplinkRouteSecOccCheck(routeId, &devId, &devState);
}
else
{
checkResult = RouteAllSecOccuClearCheck(routeId, &devId, &devState);
}
if (CI_SUCCESS == checkResult)
{
/* 通过检查 */
@@ -3087,6 +3107,7 @@ static UINT8 OtherCiValidErrCheck(UINT16 const routeId)
UINT8 toOpenCheckFlag = 0u;/*恢复可重开信号的条件标志*/
UINT8 otherResult = 0u;/*其他联锁检查条件返回值*/
UINT8 cFuncSwitchSpks = 0U; /*SPKS信号重开检查进路级别开关*/
UINT8 cPsdExceptOpenState = 0U; /*PSD异常打开状态*/
if (routeLevel == ROUTE_LEVEL_BLOC)
{
@@ -3140,12 +3161,20 @@ static UINT8 OtherCiValidErrCheck(UINT16 const routeId)
{
if (psdIdBuf[j] == tmpOtherCiDevInfo->DevId)
{
toOpenCheckFlag = 1u;
cPsdExceptOpenState = GePsdExceptOpenState(tmpOtherCiDevInfo->DevId);
if (PSD_EXCEPT_OPEN_NO == cPsdExceptOpenState)
{
toOpenCheckFlag = 1U; /*PSD未异常打开，设置可自动重开*/
}
else
{
toOpenCheckFlag = 0U; /*存在PSD异常打开，停止遍历，设置不可自动重开*/
break;
}
}
}
}
}
else
{
toOpenCheckFlag = 0u;
@@ -3604,6 +3633,9 @@ static UINT8 OpenBlocRouteOverlapErrCheck(const UINT16 routeId)
/*防护进路*/
UINT8 const overlapSum = GetRouteOverlapSum(routeId);
UINT16 const overlapId = GetRouteOverlapLockedId(routeId);
UINT8 cSndSideProFuncSwitch = 0U;
cSndSideProFuncSwitch = GetSndSideProtectFuncSwitch(); /*二级侧防功能开关*/
UINT8 lineIdentity = CI_TRADITION_RAILWAY;
@@ -3666,8 +3698,6 @@ static UINT8 OpenBlocRouteOverlapErrCheck(const UINT16 routeId)
reResult = CI_ERROR;
}
}
}
else
{
@@ -3746,7 +3776,6 @@ static UINT8 OpenBlocRouteOverlapErrCheck(const UINT16 routeId)
}
}
if (CI_SUCCESS == reResult)
{
/*检查进路侵限条件状态*/
@@ -3762,15 +3791,23 @@ static UINT8 OpenBlocRouteOverlapErrCheck(const UINT16 routeId)
/*保护区段侧防条件检查*/
if ((CI_SUCCESS == reResult) || (CI_ROUTE_RECOVER_ERR == reResult))
{
if (FUNC_SWITCH_ON == cSndSideProFuncSwitch)
{
/*仅在二级侧防开关配置为支持二级侧防时才进行侧防条件检查*/
/*检查保护区段侧防道岔区段状态*/
devId = 0u;
devState = 0u;
checkResult = OverlapLateralDfnCheck(overlapId, &devId, &devState);
checkResult = OlapSideProtectConditionCheck(overlapId, 0U, 0U);
if (CI_ERROR == checkResult)
{
reResult = checkResult;
}
}
else
{
/*不处理*/
}
}
/*检查保护区段有效性*/
if ((CI_SUCCESS == reResult) || (CI_ROUTE_RECOVER_ERR == reResult))
@@ -4285,7 +4322,8 @@ static UINT8 OpenCbtcRouteSectionErrCheck(const UINT16 routeId)
UINT8 functionId = EFUNC_OPENROUTESECTIONERRCHECK;
UINT8 rcWorkMode = 0U;
UINT8 cLocalCiType = 0U; /*本控区类型*/
UINT8 chRouteCouplinkFlag = 0U;
UINT8 chSigCrossState = 0U;
rcWorkMode = GetLocalRcWorkMode();
/* 联锁逻辑检查 */
@@ -4312,18 +4350,32 @@ static UINT8 OpenCbtcRouteSectionErrCheck(const UINT16 routeId)
}
else if (RC_WORK_MODE_CI == rcWorkMode)
{/*CI*/
/* 进路始端信号机【未跨压】且内方第一逻辑区段【空闲】*/
startSignalId = GetRouteStartSignalId(routeId);
chSigCrossState = GetSignalCrossState(startSignalId);
if (SIGNAL_CROSS_STATE_NO == chSigCrossState)
{
chRouteCouplinkFlag = GetRouteCouplinkFlag(routeId); /*获取进路联挂标志*/
if (ROUTE_COUPLINK_FLAG_YES == chRouteCouplinkFlag)
{
/*联挂进路区段占用检查*/
reResult = SetCouplinkRouteSecOccCheck(routeId, &devId, &devState);
}
else
{
devId = GetRouteInFirstLogSecId(routeId);
devState = GetLogSecCurOccupyState(devId);
if ((GetSignalCrossState(startSignalId) == SIGNAL_CROSS_STATE_NO) &&
(devState == SECTION_OCCUPY_NO))
if (SECTION_OCCUPY_NO == devState)
{
/* 通过检查 */
reResult = CI_SUCCESS;
}
else
{
reResult = CI_ERROR;
}
}
}
else
{
reResult = CheckEngineerVehicleNear(routeId);/*检查是否是工程车接近的跨压*/
}
@@ -4361,6 +4413,7 @@ static UINT8 OpenCbtcRouteSectionErrCheck(const UINT16 routeId)
{
;
}
/*使用新增的函数RouteIntruSecVainSPKSErrCheck*/
#if 0
/*侵限区段侵限条件不满足检查*/
TSCP/src/APP/ciapp/LogicManage/TradInterlockLogicManage.c
+178 -14
View File
@@ -6120,11 +6120,11 @@ UINT16 GetReturnId(const UINT16 routeId)
for (ii = 0u; ii < starSigRouteSum; ii++)
{
/*B库改为两条进路，当8编组车占压两条进路时，此时BG2进路解锁需要检查以差值信号机为始端的进路的状态*/
if ((ROUTE_STATE_IDLE == GetRouteState(starSigRouteBuf[ii])) &&(CI_SUCCESS == CheckRoutePhysicalType(starSigRouteBuf[ii])) &&
(SIGNAL_VIRTUAL_YES == GetSignalVirtualAttr(returnSigId)))
if ((ROUTE_STATE_IDLE == GetRouteState(starSigRouteBuf[ii])) &&(CI_SUCCESS == CheckRoutePhysicalType(starSigRouteBuf[ii])))
{
/*以并置信号机为始端的进路均为空闲且进路包含的区段均为列检库区段，且并置信号机为虚拟信号机,
该种算法目前只限制在库线中中途折返场景*/
该种算法目前只限制在库线中中途折返场景(SIGNAL_VIRTUAL_YES == GetSignalVirtualAttr(returnSigId))*/
/*联挂功能去掉虚拟信号机检查条件*/
}
else
{
@@ -7100,22 +7100,186 @@ UINT8 CLDPhySectionFaultUnlockDeal(const UINT16 phySectionId,const UINT16 lockBe
}
/*
* 功能描述： 取消洗车逻辑管理
* 参数说明： void
* 功能描述： 取消洗车命令处理
* 参数说明： 无
* 返回值 ： void
by hh 20251208
*/
void CancelWashWorkLogicM(void)
{/*取消洗车命令*/
UINT16 washMachineId = 0u;
washMachineId = GetWashMachineId(0u);
#if 0
SetCancelWashMachineFlag(washMachineId,CANCEL_WASH_FLAG_SET_YES);
#endif
if (washMachineId >0u)
{/*收到现地取消洗车命令，直接把洗车同意按钮状逻辑态置为抬起*/
(void)SetWashmachineXTALogicState(washMachineId,XTA_STATE_RAISE_UP);
{
UINT16 washMachineId = 0U; /*洗车机ID*/
UINT16 wDownWashRelateRouteFirstId = 0U; /*降级模式洗车线控制台表示灯1关联进路ID*/
UINT8 chRouteState = 0U;/*进路状态*/
UINT8 downWashAllowState = 0U;/*降级模式洗车同意状态(融合)*/
UINT8 washMachineButtonType = GetCiFunctionSwitchConfig(FUNC_WDOWNWASH_ZIFUSHI_BUTTON); /*降级模式洗车同意按钮自复式类型*/
washMachineId = GetWashMachineId(0U);
if ((FUNC_SWITCH_ON == washMachineButtonType) && (washMachineId > 0u) && (washMachineId < WASHMACHINE_SUM_MAX))
{
downWashAllowState = GetDownWashAllowState(washMachineId);
if (WASH_COL_STATE_ALLOW_YES == downWashAllowState)
{
wDownWashRelateRouteFirstId = GetDownWashRelateRoute1Id(washMachineId);
chRouteState = GetRouteState(wDownWashRelateRouteFirstId);
if (ROUTE_STATE_IDLE == chRouteState)
{
/*设置降级模式洗车线和DCC的洗车同意按钮状态无效*/
SetDownWashAllowColState(washMachineId, WASH_COL_STATE_ALLOW_NO);
/*清除洗车线洗车同意按钮有效周期*/
SetDownWashBtVadCycle(washMachineId, 0U);
SetDownDccWashAllowColState(washMachineId, WASH_COL_STATE_ALLOW_NO);
/*清除DCC洗车同意按钮有效周期*/
SetDownWashDccBtVadCycle(washMachineId, 0U);
SetDownWashReqState(washMachineId, WASH_REQ_STATE_ALLOW_NO);
SetDownWashReqCycle(washMachineId, 0U);
}
else
{
/*向ATS报警进路未取消，请先取消进路 0XB5*/
SetCiSendCmdBackInfoData(CI_BACK_ROUTE_IDLE_NOT, CI_DEVICE_TYPE_ROUTE, wDownWashRelateRouteFirstId, 0U, 0U);
}
}
else
{
/*向ATS报警"当前洗车机洗车同意按钮未按下，不需要取消 0XB6"*/
SetCiSendCmdBackInfoData(CI_BACK_WASH_BUTTON_PRESS_NOT, CI_DEVICE_TYPE_WASHMACHINE, washMachineId, 0U, 0U);
}
}
else
{
/*其他情况不处理*/
}
}
/*
* 功能描述： 请求洗车命令处理
* 参数说明： 无
* 返回值 ： void
*by hh 20251208
*/
void ReqWashWorkLogicM(void)
{
UINT32 curCycle = Get2oo2CurCycleNum(); /*当前周期号*/
UINT8 downWashReqState = WASH_REQ_STATE_ALLOW_NO; /*洗车机洗车请求状态*/
UINT16 wMachineId = 0U; /*洗车机ID*/
UINT8 washMachineButtonType = GetCiFunctionSwitchConfig(FUNC_WDOWNWASH_ZIFUSHI_BUTTON); /*降级模式洗车同意按钮自复式类型*/
wMachineId = GetWashMachineId(0U);
if((FUNC_SWITCH_ON == washMachineButtonType) && (wMachineId >0u) && (wMachineId < WASHMACHINE_SUM_MAX))
{
downWashReqState = GetDownWashReqState(wMachineId);
if (WASH_REQ_STATE_ALLOW_NO == downWashReqState)
{
/*设置降级模式洗车请求有效*/
SetDownWashReqState(wMachineId, WASH_REQ_STATE_ALLOW_YES);
/*设置降级模式洗车请求周期号有效*/
SetDownWashReqCycle(wMachineId, curCycle);
}
else
{
/*向ATS报警当前洗车机洗车请求有效，请勿重复操作 0xB3*/
SetCiSendCmdBackInfoData(CI_BACK_WASH_APPLY_NOT, CI_DEVICE_TYPE_WASHMACHINE, wMachineId, 0U, 0U);
}
}
else
{
/*不处理*/
}
}
/*
* 功能描述： 反向通过请求命令处理
* 参数说明：无
* 返回值 ： void
*by hh 20251208
*/
void ReqPassWashWorkLogicM(void)
{
UINT32 curCycle = Get2oo2CurCycleNum(); /*当前周期号*/
UINT8 downWashPassReqState = WASH_REQ_STATE_ALLOW_NO; /*反向洗车请求状态*/
UINT16 wMachineId = 0U; /*洗车机ID*/
UINT8 washMachineButtonType = GetCiFunctionSwitchConfig(FUNC_WDOWNWASH_ZIFUSHI_BUTTON); /*降级模式洗车同意按钮自复式类型*/
wMachineId = GetWashMachineId(0U);
if ((FUNC_SWITCH_ON == washMachineButtonType) && (wMachineId > 0u) && (wMachineId < WASHMACHINE_SUM_MAX))
{
downWashPassReqState = GetDownWashPassReqState(wMachineId);
if (WASH_REQ_STATE_ALLOW_NO == downWashPassReqState)
{
/*设置降级模式反向洗车请求有效*/
SetDownWashPassReqState(wMachineId, WASH_REQ_STATE_ALLOW_YES);
/*设置降级模式反向洗车请求周期号有效*/
SetDownWashPassReqCycle(wMachineId, curCycle);
}
else
{
SetCiSendCmdBackInfoData(CI_BACK_WASH_PASSAPPLY_NOT, CI_DEVICE_TYPE_WASHMACHINE, wMachineId, 0U, 0U);
}
}
else
{
/*不处理*/
}
}
/*
* 功能描述： 取消反向通过请求命令处理
* 参数说明： 无
* 返回值 ： void
*by hh 20251208
*/
void CancelPassWashWorkLogicM(void)
{
UINT16 wDownWashRelateRouteSecId = 0U; /*降级模式洗车线控制台表示灯2关联进路ID*/
UINT8 chRouteState = 0U;/*进路状态*/
UINT8 downWashAllowPassState = 0U;/*降级模式反向通过洗车同意状态(融合)*/
UINT16 wMachineId = 0U; /*洗车机ID*/
UINT8 washMachineButtonType = GetCiFunctionSwitchConfig(FUNC_WDOWNWASH_ZIFUSHI_BUTTON); /*降级模式洗车同意按钮自复式类型*/
wMachineId = GetWashMachineId(0U);
if ((FUNC_SWITCH_ON == washMachineButtonType) && (wMachineId > 0u && wMachineId < WASHMACHINE_SUM_MAX))
{
downWashAllowPassState = GetDownWashAllowPassState(wMachineId);
if (WASH_COL_STATE_ALLOW_YES == downWashAllowPassState)
{
wDownWashRelateRouteSecId = GetDownWashRelateRoute2Id(wMachineId);
chRouteState = GetRouteState(wDownWashRelateRouteSecId);
if (ROUTE_STATE_IDLE == chRouteState)
{
/*设置降级模式洗车线和DCC的反向洗车同意按钮状态无效*/
SetDownWashAllowPassColState(wMachineId, WASH_COL_STATE_ALLOW_NO);
/*清除洗车线反向通过同意按钮有效周期*/
SetDownWashBtVadPassCycle(wMachineId, 0U);
SetDownDccWashAllowPassColState(wMachineId, WASH_COL_STATE_ALLOW_NO);
/*清除DCC反向通过同意按钮有效周期*/
SetDownWashDccBtVadPassCycle(wMachineId, 0U);
SetDownWashPassReqState(wMachineId, WASH_REQ_STATE_ALLOW_NO);
SetDownWashPassReqCycle(wMachineId, 0U);
}
else
{
/*向ATS报警进路未取消，请先取消进路 0XB5*/
SetCiSendCmdBackInfoData(CI_BACK_ROUTE_IDLE_NOT, CI_DEVICE_TYPE_ROUTE, wDownWashRelateRouteSecId, 0U, 0U);
}
}
else
{
/*向ATS报警"洗车机XXX反向通过同意按钮未按下，不需要取消 0XB7"*/
SetCiSendCmdBackInfoData(CI_BACK_WASH_PASSBUTTON_PRESS_NOT, CI_DEVICE_TYPE_WASHMACHINE, wMachineId, 0U, 0U);
}
}
else
{
/*其他情况不处理*/
}
}
/*
* 功能描述： 进路调车同意逻辑管理
TSCP/src/APP/ciapp/LogicManage/TradInterlockLogicManage.h
+27 -2
View File
@@ -766,12 +766,37 @@ UINT16 GetReturnId(const UINT16 routeId);
void DTrainRtnUnlockRemoteRAllLockP(const UINT16 routeId);
/*
* 功能描述： 取消洗车逻辑管理
* 参数说明： void
* 功能描述： 取消洗车命令处理
* 参数说明： 无
* 返回值 ： void
by hh 20251208
*/
void CancelWashWorkLogicM(void);
/*
* 功能描述： 请求洗车命令处理
* 参数说明： 无
* 返回值 ： void
*by hh 20251208
*/
void ReqWashWorkLogicM(void);
/*
* 功能描述： 反向通过请求命令处理
* 参数说明：无
* 返回值 ： void
*by hh 20251208
*/
void ReqPassWashWorkLogicM(void);
/*
* 功能描述： 取消反向通过请求洗车逻辑管理
* 参数说明： const UINT16 wMachineId 洗车机ID
* 返回值 ： void
*by hh 20251208
*/
void CancelPassWashWorkLogicM(void);
/*
* 功能描述： 进路调车同意逻辑管理
* 参数说明： void
TSCP/src/APP/ciapp/LogicProcess/InterlockLogicCheck.c
+2280 -1603
View File
File diff suppressed because it is too large Load Diff
TSCP/src/APP/ciapp/LogicProcess/InterlockLogicCheck.h
+201 -235
View File
@@ -946,6 +946,18 @@ UINT8 RouteAllSecJumpLockStateCheck(UINT16 const routeId,UINT16 *pDevId,UINT8 *p
* CI_SUCCESS
*/
UINT8 KeepRouteSwitchCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel);
/*
* 功能描述：引导进路信号保持道岔联锁条件检查
* 参数说明：UINT16 RouteId, 进路号
* UINT8 functionId, 调用函数编号
* UINT8 sendLevel, 故障码发送级别
* 返 回 值：CI_ERROR 0 失败
* CI_SUCCESS 1 成功
* Created By LQ 2025.09.29
*/
UINT8 KeepLeadRouteSwitchCheck(UINT16 routeId, UINT8 functionId, UINT8 sendLevel);
/*
* 功能描述： 保持列车进路信号机联锁条件检查
* 参数说明：
@@ -970,6 +982,18 @@ UINT8 KeepLTrainRouteSignalCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel
*/
UINT8 LockBlocRouteSwitchCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel);
/*
* 功能描述：引导进路锁闭道岔联锁条件检查
* 参数说明：UINT16 RouteId, 进路号
* UINT8 functionId, 调用函数编号
* UINT8 sendLevel, 故障码发送级别
* 返 回 值：CI_ERROR
* CI_SUCCESS
* RETURN_LOCK_ERR_SWITPOS 道岔位置不正确
* Created By LQ 2025.09.29
*/
UINT8 LockLeadRouteSwitchCheck(UINT16 routeId, UINT8 functionId, UINT8 sendLevel);
/*
* 功能描述： 锁闭点式进路区段联锁条件检查
* 参数说明：
@@ -1165,6 +1189,17 @@ UINT8 OpenLTrainRouteSignalCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel
*/
UINT8 OpenBlocRouteSwitchCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel);
/*
* 功能描述：引导进路开放信号道岔联锁条件检查
* 参数说明：UINT16 RouteId, 进路号
* UINT8 functionId, 调用函数编号
* UINT8 sendLevel, 故障码发送级别
* 返 回 值：CI_ERROR 0 失败
* CI_SUCCESS 1 成功
* Created By LQ 2025.09.29
*/
UINT8 OpenLeadRouteSwitchCheck(UINT16 routeId, UINT8 functionId, UINT8 sendLevel);
/* L10_点式进路开放信号保护区段联锁条件检查 */
/*
* 功能描述： 点式进路开放信号保护区段联锁条件检查
@@ -1676,18 +1711,6 @@ UINT8 LogRouteNextLogSecLockCheck(UINT16 const wLogicSecId, UINT16 const wLogRou
*/
UINT8 LogicSecRltvPrtctSwLockCheck(UINT16 const wLgcId, UINT16 *pDevId, UINT8 *pDevState);
/*
* 功能描述： 逻辑区段所处道岔防护道岔未封锁检查
* 参数说明： UINT16 const routeId, 进路ID
* UINT16 *pDevId, 设备Id（返回）
* UINT8 *pDevState, 设备状态（返回）
* UINT8* pYLockAlarmFlag 引导总锁报警标志（返回）
* 返回值 ： CI_ERROR
* CI_SUCCESS
* 创建 ： qw.liu 2022-03-01
*/
UINT8 LogicSecRltvPrtctSwFLockCheck(UINT16 const wLgcId, UINT16* pDevId, UINT8* pDevState, UINT8* pYLockAlarmFlag);
/*
* 功能描述： 逻辑区段所处道岔防护道岔位置检查
* 参数说明： UINT16 const routeId, 进路ID
@@ -1699,6 +1722,17 @@ UINT8 LogicSecRltvPrtctSwFLockCheck(UINT16 const wLgcId, UINT16* pDevId, UINT8*
*/
UINT8 LogicSecRltvPrtctSwPosCheck(UINT16 const wLgcId, UINT16 *pDevId, UINT8 *pDevState);
/*
* 功能描述： 逻辑区段所处道岔防护道岔未封锁检查
* 参数说明： UINT16 const routeId, 进路ID
* UINT16 *pDevId, 设备Id（返回）
* UINT8 *pDevState, 设备状态（返回）
* UINT8* pYLockAlarmFlag 引导总锁报警标志（返回）
* 返回值 ： CI_ERROR
* CI_SUCCESS
* 创建 ： qw.liu 2022-03-01
*/
UINT8 LogicSecRltvPrtctSwFLockCheck(UINT16 const wLgcId, UINT16* pDevId, UINT8* pDevState, UINT8* pYLockAlarmFlag);
/*
* 功能描述： 逻辑区段所处道岔未封锁检查
@@ -1863,15 +1897,7 @@ UINT8 LockLeadRouteSectionCheck(UINT16 routeId, UINT8 functionId, UINT8 sendLeve
*/
UINT8 LogicSecSwitchLtrlDfncCheck(UINT16 const wLgcId, UINT16 *pDevId, UINT8 *pDevState);
/*
* 功能描述： 进路区段全部侧防条件满足检查
* 参数说明： UINT16 routeId, 进路号
* UINT16 *pDevId, 设备Id（返回）
* UINT8 *pDevState, 设备状态（返回）
* 返回值 ： CI_ERROR
* CI_SUCCESS
*/
UINT8 RouteAllLtrlDfncSwitchCheck(UINT16 const routeId, UINT16 *pDevId, UINT8 *pDevState);
/*
* 功能描述： 进路区段全部联络线设备条件满足检查
@@ -2205,15 +2231,7 @@ UINT8 LogSecSeqIncUTCheck(const UINT16 wTrainId, const UINT8 cLogSecSum, const U
*/
UINT8 RouteHalfProSwitchFLockCheck(UINT16 const routeId, UINT16* pDevId, UINT8* pDevState, UINT8* pYLockAlarmFlag);
/*
* 功能描述： 进路区段全部侧防条件满足检查
* 参数说明： UINT16 routeId, 进路号
* UINT16 *pDevId, 设备Id（返回）
* UINT8 *pDevState, 设备状态（返回）
* 返回值 ： CI_ERROR
* CI_SUCCESS
*/
UINT8 RouteHalfLtrlDfncSwitchCheck(UINT16 const routeId, UINT16 *pDevId, UINT8 *pDevState);
/*
* 功能描述： 部分进路区段全部联络线设备条件满足检查
@@ -2500,16 +2518,7 @@ UINT8 CheckRouteZhefanJiesuo(UINT16 const routeId);
*/
UINT8 CheckOverlapPhysecOtherLock(UINT16 const overlapId, UINT16* pDevId, UINT8* pDevState);
/*
* 功能描述：保护区段侧防条件检查
* 参数说明：UINT16 const overlapId, OverlapID
* UINT16* pDevId 设备Id（返回）
* UINT8* pDevState 设备状态（返回）
* 返回值 ：0 检查失败
* 1 检查成功
* Created By LQ 2024.01.05
*/
UINT8 OverlapLateralDfnCheck(UINT16 const overlapId, UINT16* pDevId, UINT8* pDevState);
/*
* 功能描述： 检查保护区段的CBTC区域属性
@@ -2614,7 +2623,7 @@ UINT8 CtTrainHeadSuspCheck(const UINT16 wTrainId, const UINT8 cLogSecSeqDir, con
* 输出参数：无
* 返回值 ：CI_ERROR 0 失败
* CI_SUCCESS 1 成功
* Edit By cgh 2025.10.17
* Created By LQ 2024.09.05
*/
UINT8 LogSecSeqAndTrainPosCheckCLD(const UINT8 cLogSecSum, const UINT16* pLogSecIdBuff, const UINT16 wTrainId, const UINT8 cFunctionId, const UINT8 cSendLevel);
@@ -2707,13 +2716,13 @@ UINT8 OtherCiOvlpRelProSwMovValCheck(const UINT16 wOverlapId);
UINT8 OverlapProSwUsingCheck(const UINT16 wOverlapId, UINT16* pDevId, UINT8* pDevState, UINT8* pAlarmType);
/*
* 功能描述： 获取指定进路办理相邻控区道岔检查标志
* 参数说明： const UINT16 routeId 进路ID
* 返 回 值： 进路办理相邻控区道岔检查标志
* 输出参数：UINT16* switchID道岔ID、UINT8* chSwitchState道岔状态
* by cgh 20241202
* 功能描述： 进路关联所有道岔位置正确检查
* 参数说明： UINT16 const routeId, 进路号）
* 返回值 ： CI_ERROR
* CI_SUCCESS
* BY CGH 20250224
*/
UINT8 RouteRelAllSwitchPosCheck(UINT16 const routeId, UINT16* switchID, UINT8* chSwitchState);
UINT8 RouteRelAllSwitchPosCheck(UINT16 const routeId);
/*
*函数功能：保护区段照查继电器检查
@@ -2762,198 +2771,155 @@ UINT8 RouteCldAttrCheck(UINT16 wRouteId);
* Created By LQ 2025.08.18
*/
UINT8 OverlapOccuUnlockCheck(UINT16 overlapId, UINT8 functionId);
/*
* 功能描述：列车占用完全在指定区段检查
* 输入参数：const UINT16 wPhySecId 物理区段ID
* const UINT16 wTrainId 列车ID
* 输出参数：无
* 返回值 ：CI_ERROR 0 不完全在
* CI_SUCCESS 1 完全在
* by cgh 20251017
*/
UINT8 TrainOccSameSecCheck(const UINT16 wPhySecId, const UINT16 wTrainId);
/*
* 功能描述：占用是否属于同一区段检查
* 输入参数：const UINT16 wBasePhySecId 基准物理区段ID
* const UINT16 wCheckPhySecId 待检查物理区段ID
* 输出参数：无
* 返回值 ：CI_ERROR 0 不属于
* CI_SUCCESS 1 属于
* by cgh 20251017
*/
UINT8 OccBelSameSecCheck(const UINT16 wBasePhySecId, const UINT16 wCheckPhySecId);
/*
* 功能描述： 进路风井区段占用检查
* 参数说明： UINT16 routeId, 进路号
* UINT16 *pDevId, 设备Id（返回）
* UINT8 *pDevState, 设备状态（返回）（占用/空闲）
* 返回值 ： CI_ERROR
* CI_SUCCESS
* by yx 2026.03.04
*/
UINT8 RouteAirShaftSecOccuCheck(UINT16 const routeId, UINT16* pDevId, UINT8* pDevState);
/*
* 功能描述： 进路风井区段锁闭检查
* 参数说明： UINT16 routeId, 进路号
* UINT16 *pDevId, 设备Id（返回）
* UINT8 *pDevState, 设备状态（返回）
* 返回值 ： CI_ERROR
* CI_SUCCESS
* by yx 2026.03.04
*/
UINT8 RouteAirShaftSecLockCheck(UINT16 const routeId, UINT16* pDevId, UINT8* pDevState);
/*
* 功能描述： 计轴区段所有防护道岔位置正确检查
* 参数说明： UINT16 const axisSecId, 计轴区段编号
* UINT16 *pDevId, 设备Id（返回）
* UINT8 *pDevState, 设备状态（返回）
* 返回值 ： CI_ERROR
* CI_SUCCESS
* add mpt 20260331
*/
UINT8 AxisSecAllProtSwitchPosCheck(UINT16 const axisSecId, UINT16* pDevId, UINT8* pDevState);
/*
* 功能描述： 计轴区段道岔封锁状态检查
* 参数说明： UINT16 const axisSecId, 计轴区段编号
* UINT16 *pDevId, 设备Id（返回）
* UINT8 *pDevState, 设备状态（返回）
* 返回值 ： CI_ERROR
* CI_SUCCESS
* Add by mpt 20260331
*/
UINT8 AxisSecProtSwitchFLockCheck(UINT16 const axisSecId, UINT16* pDevId, UINT8* pDevState);
/*
* 功能描述： 检查计轴区段跳跃锁闭是否有防护道岔驱动超时
* 参数说明： const UINT16 routeId, 进路ID
* 返回值 ： UINT8
CI_SUCCESS:计轴区段防护道岔无道岔驱动超时
CI_ERROR:计轴区段防护道岔驱动超时
add by mpt 20260331
*/
UINT8 ChekJumpLockProtectSwitDrivOvtmStat(const UINT16 axisSecId);
/*
* 功能描述： 计轴区段的防护道岔位置和动作有效性检查
* 参数说明： UINT16 const axisSecId, 计轴区段编号
* UINT16 *pDevId, 设备Id（返回）
* UINT8 *pDevState, 设备状态（返回）
* 返回值 ： CI_ERROR
* CI_SUCCESS
* add by mpt 20260331
*/
UINT8 AxisSecPorteSwitchPosMoveCheck(UINT16 const axisSecId, UINT16* pDevId, UINT8* pDevState, UINT8 funcId, UINT8 sendLevel);
/*
* 功能描述： 区段征用、区段防护道岔区段征用、区段内道岔道岔征用检查、区段内防护道岔道岔征用
* 参数说明：const UINT16 axisSecId 计轴区段ID
* 返回值 ： CI_ERROR
* CI_SUCCESS
* add by mpt 20260331
*/
UINT8 JumpPhySectionUseCheck(const UINT16 axisSecId);
/*
* 功能描述：区段防护道岔区段、防护道岔征用检查
* 参数说明：const UINT16 axisSecId 计轴区段ID
* 返回值 ： CI_ERROR
* CI_SUCCESS
* add by mpt 20260331
*/
UINT8 JumpPhySectionPortectUseCheck(const UINT16 axisSecId);
/*
* 功能描述：逻辑区段防护道岔区段征用、道岔征用检查
* 参数说明：const UINT16 axisSecId 计轴区段ID
* 返回值 ： CI_ERROR
* CI_SUCCESS
* add by mpt 20260331
*/
UINT8 JumpLogicSecPortectUseCheck(const UINT16 wLgcId);
/*
* 功能描述：计轴区段所在道岔道岔征用检查
* 参数说明：const UINT16 axisSecId 计轴区段ID
* 返回值 ： CI_ERROR
* CI_SUCCESS
* add by mpt 20260331
*/
UINT8 JumpPhySectionSwitchUseCheck(const UINT16 axisSecId);
/*
* 功能描述：设置跳跃锁闭防护道岔区段征用状态
* 参数说明：const UINT16 axisSecId 计轴区段ID
* const UINT8 state 状态
* 返回值 ： void
* add by mpt 20260331
*/
void SetJumpPhySectionPortectSecUse(const UINT16 axisSecId, const UINT8 state);
/*
* 功能描述：设置逻辑区段的防护道岔区段征用
* 参数说明：const UINT16 axisSecId 计轴区段ID
* const UINT8 state 状态
* 返回值 ： void
* add by mpt 20260331
*/
void SetJumpLogicSecPortectUse(const UINT16 wLgcId, const UINT8 state);
/*
* 功能描述： 设置计轴区段关联防护道岔防护锁闭状态
* 参数说明： const UINT16 axisSecId, 计轴区段ID
* const UINT8 lockCommand, 锁闭状态
* 返回值 ： void
* add by mpt 20260331
*/
void SetAxisRelProSwitchLockSta(const UINT16 axisSecId, const UINT8 lockCommand);
/*
* 功能描述： 计轴区段关联防护道岔防护锁闭检查
* 参数说明： UINT16 const routeId, 计轴区段号
* UINT16 *pDevId, 设备Id（返回）
* UINT8 *pDevState, 设备状态（返回）
* 返回值 ： CI_ERROR
* CI_SUCCESS
* add mpt 20260331
*/
UINT8 AxisRelatedProSwitchLockCheck(UINT16 const axisSecId, UINT16* pDevId, UINT8* pDevState);
/*
* 功能描述： 设置逻辑区段关联防护道岔防护锁闭状态
* 参数说明： const UINT16 axisSecId, 计轴区段ID
* const UINT8 lockCommand, 锁闭状态
* 返回值 ： void
* add by mpt 20260331
*/
void SetLogSecRelProSwitchLockSta(const UINT16 wLgcId, const UINT8 lockCommand);
/*
* 功能描述：计轴区段所有道岔是否全部征用
* 参数说明：const UINT16 axisSecId 计轴区段ID
* 返回值 ： CI_ERROR 未全部征用
* CI_SUCCESS 全部征用
* add by mpt 20260403
*/
UINT8 JumpPhySecAllUseCheck(const UINT16 axisSecId);
/*
* 功能描述： 计轴区段防护道岔引导总锁状态检查
* 参数说明： UINT16 const axisSecId, 计轴区段编号
* UINT16 *pDevId, 设备Id（返回）
* UINT8 *pDevState, 设备状态（返回）
* 功能描述：办理联挂进路区段检查
* 参数说明：const UINT16 wRouteId 进路ID
* UINT16* pDevId 设备ID
* UINT8* pDevState 设备状态
* 返 回 值：CI_ERROR 0 失败
* CI_SUCCESS 1 成功
* Add by LQ 20260518
* Created By 2025.09.18
*/
UINT8 AxisSecProtSwtYLockCheck(UINT16 const axisSecId, UINT16* pDevId, UINT8* pDevState);
UINT8 SetCouplinkRouteSecOccCheck(const UINT16 wRouteId, UINT16* pDevId, UINT8* pDevState);
/*
* 功能描述：保持联挂进路区段占用检查
* 参数说明：const UINT16 wRouteId 进路ID
* UINT16* pDevId 设备ID
* UINT8* pDevState 设备状态
* 返 回 值：CI_ERROR 0 失败
* CI_SUCCESS 1 成功
* Created By 2025.09.18
*/
UINT8 KeepCouplinkRouteSecOccCheck(const UINT16 wRouteId, UINT16* pDevId, UINT8* pDevState);
/*
* 功能描述：单个侧防条件检查
* 参数说明：SideProtecStru SidePretectData 一项侧防条件
* UINT16 wDevId 设备ID
* UINT8 cDevType 设备类型
* UINT8 functionId 函数ID
* UINT8 sendLevel 发送等级
* 返 回 值：CI_ERROR 0 失败
* CI_SUCCESS 1 成功
*/
UINT8 SingleSideProtectCheck(SideProtecStru SidePretectData, UINT16 wDevId, UINT8 cDevType, UINT8 functionId, UINT8 sendLevel);
/*
* 功能描述：侧防道岔位置检查
* 参数说明：SideProtecSwitchData* pSideProtecSwitchBuf 道岔侧防条件
* UINT8 chSideProtecSwitchNum 侧防道岔数量
* 返 回 值：CI_ERROR 0 侧防道岔位置连通
* CI_SUCCESS 1 侧防道岔位置不连通
*/
UINT8 SideProtectSwitchPosCheck(SideProtecSwitchData* pSideProtecSwitchBuf, UINT8 chSideProtecSwitchNum);
/*
* 功能描述：侧防物理区段条件检查
* 参数说明：SideProtecStru SidePretectData 侧防条件
* UINT8 functionId 函数ID
* UINT8 sendLevel 发送等级
* 返 回 值： CI_ERROR 失败
* CI_SUCCESS 成功
*/
UINT8 SideProtectPhySecCheck(SideProtecStru SidePretectData, UINT8 functionId, UINT8 sendLevel);
/*
* 功能描述： 检查进路侧防条件
* 参数说明：UINT16 routeId 进路ID
UINT8 functionId 函数ID
UINT8 sendLevel 发送等级
* 返回值 ： CI_ERROR
* CI_SUCCESS
* 创建 ：
*/
UINT8 RouteSideProtectConditionCheck(UINT16 routeId, UINT8 functionId, UINT8 sendLevel);
/*
* 功能描述： 检查保护区段侧防条件
* 参数说明：UINT16 wOverlapId 保护区段ID
UINT8 functionId 函数ID
UINT8 sendLevel 发送等级
* 返回值 ： CI_ERROR
* CI_SUCCESS
* 创建 ：
*/
UINT8 OlapSideProtectConditionCheck(UINT16 wOverlapId, UINT8 functionId, UINT8 sendLevel);
/*
* 功能描述：侧防区段道岔位置检查
* 参数说明：UINT16 const physicalId, 物理区段ID
* SideProtecStru SidePretectData 侧防数据
* 返 回 值：CI_ERROR 0 失败
* CI_SUCCESS 1 成功
*/
UINT8 SideProtectPhySecSwtPosCheck(const UINT16 physicalId, SideProtecStru SidePretectData);
/*
* 功能描述：检查保护区段道岔及防护道岔位置是否正确
* 参数说明：const UINT16 overlapId overlap ID
* 返 回 值：CI_ERROR 0 道岔位置错误
* CI_SUCCESS 1 道岔位置正确
* Created By LQ 2025.09.28
*/
UINT8 CheckOverlapSwitchPosRight(const UINT16 overlapId);
/*
*函数功能：保护区段之前人工解锁状态检查
*参数说明：const UINT16 wRouteId 进路ID
* UINT16 *pDevId, 设备Id（返回）
* UINT8 *pDevState, 设备状态（返回）
* 返回值 ： CI_ERROR
* CI_SUCCESS
* by cgh 20250929
*/
UINT8 OverlapPreLaborUnLockStateCheck(UINT16 const wRouteId, UINT16* pDevId, UINT8* pDevState);
/*
* 功能描述：侧防关键道岔检查
* 参数说明：UINT16 wSwitchId 关键道岔ID
* UINT16 wDevId 设备ID
* UINT8 cDevType 设备类型
* 返 回 值：CI_ERROR 0 失败
* CI_SUCCESS 1 成功
* Created By LQ 2025.09.29
*/
UINT8 SingleSideKeySwitchCheck(UINT16 wSwitchId, UINT16 wDevId, UINT8 cDevType);
/*
* 功能描述：物理区段锁闭码位侧防条件检查
* 参数说明：UINT16 wPhySecId 物理区段ID
* 返 回 值：CI_ERROR 0 失败
* CI_SUCCESS 1 成功
* Created By LQ 2025.09.29
*/
UINT8 PhySecLockMaskSideProtectCheck(UINT16 wPhySecId);
/*
*函数功能：自动通过进路办理联挂属性检查
*参数说明： const UINT16 wAutoRouteId 进路ID
* const UINT8 chFunctionId 函数ID
* 返回值 ： CI_ERROR
* CI_SUCCESS
* by lyj 20250929
*/
UINT8 AutoRouteCouplinkStateCheck(const UINT16 wAutoRouteId, const UINT8 chFunctionId);
/*
*函数功能：自动折返进路办理联挂属性检查
*参数说明： const UINT16 wAutoRouteId 进路ID
* const UINT8 chFunctionId 函数ID
* 返回值 ： CI_ERROR
* CI_SUCCESS
* by lyj 20250929
*/
UINT8 AutoReturnRouteCouplinkCheck(const UINT16 wAutoRouteId, const UINT8 chFunctionId);
/*
*函数功能：全自动折返进路办理联挂属性检查
*参数说明： const UINT16 wAutoRouteId 进路ID
* const UINT8 chFunctionId 函数ID
* 返回值 ： CI_ERROR
* CI_SUCCESS
* by lyj 20250929
*/
UINT8 AllAutoReturnRCouplinkCheck(const UINT16 wAutoRouteId, const UINT8 chFunctionId);
#endif
TSCP/src/APP/ciapp/LogicProcess/InterlockLogicProcess.c
+688 -311
View File
File diff suppressed because it is too large Load Diff
TSCP/src/APP/ciapp/LogicProcess/InterlockLogicProcess.h
+21 -3
View File
@@ -688,15 +688,16 @@ void LgcSecUnlockProc(const UINT16 routeId, const UINT16 logSectionId);
* 返回值 ： void
*/
void RouteLgcSecResReleaseProcess(const UINT16 wRouteId);
/*
* 功能描述： 检查保护区段人工解锁是否可执行
* 参数说明： const UINT16 overlapId, 保护区段ID
* const UINT32 dwOverlapUnlockCount 保护区段自动解锁周期数
* const UINT32 dwOverlapUnlockStartCyc 保护区段自动解锁起始周期
* const UINT16 wRouteId 进路ID
* 返回值 ： CI_SUCCESS:成功
CI_ERROR:失败
* edit cgh 20250928
*/
UINT8 CheckOverlapLaborUnlock(const UINT16 overlapId, const UINT32 dwOverlapUnlockCount, const UINT32 dwOverlapUnlockStartCyc);
UINT8 CheckOverlapLaborUnlock(const UINT16 overlapId, const UINT16 wRouteId);
/*
* 功能描述： 计算保护区段解锁倒计时开始周期
* 参数说明： const UINT16 overlapId, 保护区段ID
@@ -824,6 +825,23 @@ UINT8 RouteLgcSecResReturnSecCheck(UINT16 wValidReturnSigId, const UINT16 wRoute
*/
UINT8 LgcOverlapUsableProcess(UINT16 const wLgcSecId);
#endif
/*
* 功能描述： 进路联挂标志处理
* 参数说明： const UINT16 wRouteId 进路ID
* const UINT8 functionId 函数ID
* const UINT8 sendLevel 报警级别
* 返回值 ： 联挂标志设置结果
* Create: 20250917
*/
UINT8 SetRouteCouplinkProcess(const UINT16 wRouteId, const UINT8 functionId, const UINT8 sendLevel);
/*
* 功能描述： 刷新联挂标志
* 参数说明： const UINT16 wRouteId 进路ID
* 返回值 ： 无
* Create: 20250919
*/
void UpdateRouteCouplinkFlag(const UINT16 wRouteId);
#ifdef __cplusplus
}
#endif
TSCP/src/APP/ciapp/LogicProcess/LogicalRouteLogicCheck.c
+25 -35
View File
@@ -823,7 +823,7 @@ UINT8 SetLogRouteSwitchCheck(UINT16 logRouteId, UINT8 functionId, UINT8 sendLeve
{
devId = 0u;
devState = 0u;
checkResult = LogRouteCeFangSwitchCheck(logRouteId, &devId, &devState);
checkResult = LogRouteCeFangSwitchCheck(logRouteId, functionId, sendLevel);
if (CI_SUCCESS == checkResult)
{
/* 通过检查 */
@@ -831,8 +831,7 @@ UINT8 SetLogRouteSwitchCheck(UINT16 logRouteId, UINT8 functionId, UINT8 sendLeve
}
else
{
/* 记录故障码 */
SetErrorData(functionId, CI_DEVICE_TYPE_PHYSEC, devId, ETYPE_PS_NO_UT_CT_OCU_STATE, devState, sendLevel);
/* 失败返回 */
reResult = CI_ERROR;
}
@@ -1034,7 +1033,7 @@ UINT8 LockLogRouteSwitchCheck(UINT16 logRouteId, UINT8 functionId, UINT8 sendLev
{
devId = 0u;
devState = 0u;
checkResult = LogRouteCeFangSwitchCheck(logRouteId, &devId, &devState);
checkResult = LogRouteCeFangSwitchCheck(logRouteId, functionId, sendLevel);
if (CI_SUCCESS == checkResult)
{
/* 通过检查 */
@@ -1042,8 +1041,7 @@ UINT8 LockLogRouteSwitchCheck(UINT16 logRouteId, UINT8 functionId, UINT8 sendLev
}
else
{
/* 记录故障码 */
SetErrorData(functionId, CI_DEVICE_TYPE_PHYSEC, devId, ETYPE_PS_NO_UT_CT_OCU_STATE, devState, sendLevel);
/* 失败返回 */
reResult = CI_ERROR;
}
@@ -1298,46 +1296,39 @@ UINT8 LogRouteProSwitchFLockCheck(UINT16 const routeId, UINT16* pDevId, UINT8* p
/*
* 功能描述： 逻辑进路侧防条件满足检查
* 参数说明： UINT16 routeId, 逻辑进路号
* UINT16 *pDevId, 设备Id（返回）
* UINT8 *pDevState, 设备状态（返回）
* UINT8 functionId, 函数ID
* UINT8 sendLevel 发送等级
* 返回值 ： CI_ERROR
* CI_SUCCESS
*/
UINT8 LogRouteCeFangSwitchCheck(UINT16 const routeId, UINT16* pDevId, UINT8* pDevState)
UINT8 LogRouteCeFangSwitchCheck(UINT16 const routeId,UINT8 functionId, UINT8 sendLevel)
{
/* 进路区段*/
UINT16 const checkSum = GetLogicalRouteInLogSecSum(routeId);
UINT16* const dataIdBuf = GetLogicalRouteInLogSecId(routeId);
/* 局部变量定义初始化 */
UINT16 i = 0u; /* 循环变量 */
UINT16 devId = 0u;
UINT8 i = 0u; /* 循环变量 */
UINT8 reVal = CI_ERROR;
SideProtecStru* pLogRoutSidePrtectData = NULL;
UINT8 chLogRoutSidePrtectDataNum = 0u;
if ((0u == checkSum) || (NULL == pDevId) || (NULL == pDevState))
UINT8 cDevType = 0u;
UINT8 cDevStateType = 0u;
UINT16 cDevId = 0u;
UINT8 cDevState = 0u;
pLogRoutSidePrtectData = GetLogRoutSidePrtectData(routeId);
chLogRoutSidePrtectDataNum = GetLogRoutSidePrtectDataNum(routeId);
if (NULL == pLogRoutSidePrtectData)
{
/*区段数据错误*/
reVal = CI_ERROR;
}
else
{
/*开始检查*/
for (i = 0u; i < checkSum; i++)
{
devId = dataIdBuf[i];
reVal = LogicSecSwitchLtrlDfncCheck(devId, pDevId, pDevState);
if (CI_SUCCESS == reVal)
{
/* 通过检查*/
}
else
{
/*状态不一致返回故障状态*/
reVal = CI_ERROR;
break;
}
}
reVal = CI_SUCCESS;
/*功能预留*/
}
/*全部通过检查*/
return reVal;
}
@@ -2800,7 +2791,7 @@ UINT8 KeepLogRouteSwitchCheck(UINT16 wLogRouteId, UINT8 functionId, UINT8 sendLe
{
devId = 0u;
devState = 0u;
checkResult = LogRouteCeFangSwitchCheck(wLogRouteId, &devId, &devState);
checkResult = LogRouteCeFangSwitchCheck(wLogRouteId, functionId, sendLevel);
if (CI_SUCCESS == checkResult)
{
/* 通过检查 */
@@ -2808,8 +2799,7 @@ UINT8 KeepLogRouteSwitchCheck(UINT16 wLogRouteId, UINT8 functionId, UINT8 sendLe
}
else
{
/* 记录故障码 */
SetErrorData(functionId, CI_DEVICE_TYPE_PHYSEC, devId, ETYPE_PS_NO_UT_CT_OCU_STATE, devState, sendLevel);
/* 失败返回 */
reResult = CI_ERROR;
}
TSCP/src/APP/ciapp/LogicProcess/LogicalRouteLogicCheck.h
+3 -3
View File
@@ -138,12 +138,12 @@ UINT8 LogRouteProSwitchFLockCheck(UINT16 const routeId, UINT16* pDevId, UINT8* p
/*
* 功能描述： 逻辑进路侧防条件满足检查
* 参数说明： UINT16 routeId, 逻辑进路号
* UINT16 *pDevId, 设备Id（返回）
* UINT8 *pDevState, 设备状态（返回）
* UINT8 functionId, 函数ID
* UINT8 sendLevel 发送等级
* 返回值 ： CI_ERROR
* CI_SUCCESS
*/
UINT8 LogRouteCeFangSwitchCheck(UINT16 const routeId, UINT16* pDevId, UINT8* pDevState);
UINT8 LogRouteCeFangSwitchCheck(UINT16 const routeId, UINT8 functionId, UINT8 sendLevel);
/*
* 功能描述： 逻辑进路区段全部联络线设备条件满足检查
TSCP/src/APP/ciapp/LogicProcess/TradInterlockLogicProcess.c
+355 -11
View File
@@ -28,10 +28,32 @@ UINT8 SetLTrainRouteP(const UINT16 routeId)
/* 局部变量定义初始化 */
UINT8 devState = 0U; /*设备状态*/
UINT8 reResult = CI_ERROR; /*返回值*/
UINT8 chRouteCouplinkFlag = 0U;
UINT8 chRouteLevel = 0U;
/* 联锁条件检查 */
chRouteCouplinkFlag = GetRouteCouplinkFlag(routeId); /*获取进路联挂标志*/
chRouteLevel = GetRouteLevel(routeId); /*获取进路监督级别*/
devState = GetRouteState(routeId);
if ((ROUTE_COUPLINK_FLAG_YES == chRouteCouplinkFlag) && (ROUTE_LEVEL_CBTC == chRouteLevel))
{
/* 进路状态条件：进路状态空闲、进路初选、自动解锁正常、自动解锁异常（ARB）、初锁异常、预先锁闭、接近锁闭正常、接近锁闭异常都可以办理联挂进路 */
if ((ROUTE_STATE_IDLE == devState) || (ROUTE_STATE_FIRST_XUANPAI == devState) || (ROUTE_STATE_FIRST_LOCKERR == devState)
|| (ROUTE_STATE_YUXIAN_LOCK == devState) || (ROUTE_STATE_NEAR_LOCK == devState) || (ROUTE_STATE_NEAR_LOCKERR == devState)
|| (ROUTE_STATE_AUTO_UNLOCK == devState) || (ROUTE_STATE_AUTO_UNLOCKERR == devState))
{
/* 返回成功 */
reResult = CI_SUCCESS;
}
else
{
/* 记录故障码 */
SetErrorData(functionId, CI_DEVICE_TYPE_ROUTE, routeId, ETYPE_ROUTE_STATE, devState, sendLevel);
/* 失败返回 */
reResult = CI_ERROR;
}
}
else
{
/*进路状态空闲或初选或自动解锁异常（ARB且故障锁闭）*/
if ((ROUTE_STATE_IDLE == devState) || (ROUTE_STATE_FIRST_XUANPAI == devState) || (ROUTE_STATE_AUTO_UNLOCKERR == devState))
{
@@ -45,6 +67,8 @@ UINT8 SetLTrainRouteP(const UINT16 routeId)
/* 失败返回 */
reResult = CI_ERROR;
}
}
/*信号联锁条件检查*/
/*if ((CI_SUCCESS == reResult) && (CI_ERROR == SetLTrainRouteSignalCheck(routeId,functionId,sendLevel)))*/
@@ -218,7 +242,7 @@ UINT8 SetLeadRouteP(const UINT16 routeId)
}
/*道岔联锁条件检查*/
if ((CI_SUCCESS == reResult) && (CI_ERROR == SetLTrainRouteSwitchCheck(routeId,functionId,sendLevel)))
if ((CI_SUCCESS == reResult) && (CI_ERROR == SetLeadRouteSwitchCheck(routeId,functionId,sendLevel)))
{
/* 失败返回 */
reResult = CI_ERROR;
@@ -670,7 +694,7 @@ UINT8 LockLeadTrainRouteP(const UINT16 routeId)
if (CI_SUCCESS == reResult)
{
chCheckResult = SetLTrainRouteSwitchCheck(routeId, functionId, sendLevel);
chCheckResult = SetLeadRouteSwitchCheck(routeId, functionId, sendLevel);
if (CI_ERROR == chCheckResult)
{
/* 失败返回 */
@@ -2183,7 +2207,8 @@ UINT8 SetLTrainRouteSectionCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel
UINT16 devId = 0u; /*设备ID*/
UINT8 devState = 0u; /*设备状态*/
UINT8 chRouteCouplinkFlag = 0U;
UINT8 chRouteLevel = 0U;
/* 联锁逻辑检查 */
/* 进路内所有区段未被封锁 */
@@ -2208,16 +2233,35 @@ UINT8 SetLTrainRouteSectionCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel
{
devId = 0u;
devState = 0u;
chRouteCouplinkFlag = GetRouteCouplinkFlag(routeId); /*获取进路联挂标志*/
chRouteLevel = GetRouteLevel(routeId); /*获取进路监督级别*/
if ((ROUTE_COUPLINK_FLAG_YES == chRouteCouplinkFlag) && (ROUTE_LEVEL_CBTC == chRouteLevel))
{
checkResult = SetCouplinkRouteSecOccCheck(routeId, &devId, &devState);
}
else
{
checkResult = RouteAllSecOccuClearCheck(routeId, &devId, &devState);
}
if (checkResult == CI_SUCCESS)
{
/* 通过检查 */
reResult = CI_SUCCESS;
}
else
{
if (0U == devId)
{
/* 记录故障码 */
SetErrorData(functionId, CI_DEVICE_TYPE_ROUTE, routeId, ETYPE_COUPLINK_ROUTE_IDLE, 0U, sendLevel);
}
else
{
/* 记录故障码 */
SetErrorData(functionId, CI_DEVICE_TYPE_PHYSEC, devId, ETYPE_PS_MERGY_OCU_STATE, devState, sendLevel);
}
/* 失败返回 */
reResult = CI_ERROR;
}
@@ -2370,11 +2414,12 @@ UINT8 SetLTrainRouteSwitchCheck(UINT16 routeId, UINT8 functionId, UINT8 sendLeve
}
}
/*场段进路不查侧防条件*/
#if 0
/*进路侧防道岔条件检查*/
if (CI_SUCCESS == reResult)
{
checkResult = RouteAllLtrlDfncSwitchCheck(routeId, &devId, &devState);
checkResult = RouteSideProtectConditionCheck(routeId, functionId, sendLevel);
if (CI_SUCCESS == checkResult)
{
/* 通过检查 */
@@ -2382,8 +2427,7 @@ UINT8 SetLTrainRouteSwitchCheck(UINT16 routeId, UINT8 functionId, UINT8 sendLeve
}
else
{
/* ¼Ç¼¹ÊÕÏÂë */
SetErrorData(functionId, CI_DEVICE_TYPE_PHYSEC, devId, ETYPE_PS_NO_UT_CT_OCU_STATE, devState, sendLevel);
/* 失败返回 */
reResult = CI_ERROR;
}
@@ -2393,6 +2437,7 @@ UINT8 SetLTrainRouteSwitchCheck(UINT16 routeId, UINT8 functionId, UINT8 sendLeve
/* 失败返回 */
reResult = CI_ERROR;
}
#endif
if (CI_SUCCESS == reResult)
{
@@ -2564,6 +2609,285 @@ UINT8 SetLTrainRouteSwitchCheck(UINT16 routeId, UINT8 functionId, UINT8 sendLeve
return reResult;
}
/*
* 功能描述：办理引导进路道岔联锁条件检查
* 参数说明：UINT16 RouteId, 进路号
* UINT8 functionId, 调用函数编号
* UINT8 sendLevel, 故障码发送级别
* 返 回 值：CI_ERROR 0 失败
* CI_SUCCESS 1 成功
* Created By LQ 2025.09.29
*/
UINT8 SetLeadRouteSwitchCheck(UINT16 routeId, UINT8 functionId, UINT8 sendLevel)
{
/* 局部变量定义初始化 */
UINT8 reResult = CI_ERROR; /*返回值*/
UINT8 checkResult = CI_ERROR; /*检查结果*/
UINT16 devId = 0U; /*设备ID*/
UINT8 devState = 0U; /*设备状态*/
UINT8 reResultP = CI_ERROR; /*道岔位置局部检查返回值*/
UINT8 chConnetCheckFunc = 0U;
chConnetCheckFunc = GetCiFunctionSwitchConfig(FUNC_SETROUTE_CONNECT_CHECK); /*获取是否要检查联络线条件的开关*/
/*进路内所有道岔【未引导总锁】*/
devId = 0U;
devState = 0U;
checkResult = RouteSwitchYLockCheck(routeId, &devId, &devState);
if (CI_SUCCESS == checkResult)
{
/* 通过检查 */
reResult = CI_SUCCESS;
}
else
{
/* 记录故障码 */
SetErrorData(functionId, CI_DEVICE_TYPE_SWITCH, devId, ETYPE_SWT_YLOCK_STATE, devState, sendLevel);
/* 失败返回 */
reResult = CI_ERROR;
}
if (CI_SUCCESS == reResult)
{
/*进路内所有道岔【未封锁】*/
devId = 0U;
devState = 0U;
checkResult = RouteSwitchFLockCheck(routeId, &devId, &devState);
if (CI_SUCCESS == checkResult)
{
/* 通过检查 */
reResult = CI_SUCCESS;
}
else
{
/* 记录故障码 */
SetErrorData(functionId, CI_DEVICE_TYPE_SWITCH, devId, ETYPE_SWT_FLOCK_STATE, devState, sendLevel);
/* 失败返回 */
reResult = CI_ERROR;
}
}
else
{
; /*继续执行*/
}
if (CI_SUCCESS == reResult)
{
/*进路防护道岔【未封锁】*/
devId = 0U;
devState = 0U;
checkResult = RouteReltProtSwitchFLockCheck(routeId, &devId, &devState);
if (CI_SUCCESS == checkResult)
{
/* 通过检查 */
reResult = CI_SUCCESS;
}
else
{
/* 记录故障码 */
SetErrorData(functionId, CI_DEVICE_TYPE_SWITCH, devId, ETYPE_SWT_FLOCK_STATE, devState, sendLevel);
/* 失败返回 */
reResult = CI_ERROR;
}
}
#if 0
/*进路侧防道岔条件检查*/
if (CI_SUCCESS == reResult)
{
checkResult = RouteSideProtectConditionCheck(routeId, functionId, sendLevel);
if (CI_SUCCESS == checkResult)
{
/* 通过检查 */
reResult = CI_SUCCESS;
}
else
{
/* 失败返回 */
reResult = CI_ERROR;
}
}
else
{
/* 失败返回 */
reResult = CI_ERROR;
}
#endif
if (CI_SUCCESS == reResult)
{
if (FUNC_SWITCH_ON == chConnetCheckFunc)
{
; /*开关打开，不检查联络线条件*/
}
else
{
/*进路联络线设备条件检查*/
checkResult = RouteContactLineDevSwitchCheck(routeId, functionId, sendLevel);
if (CI_SUCCESS == checkResult)
{
/* 通过检查 */
reResult = CI_SUCCESS;
}
else
{
/* 失败返回 */
reResult = CI_ERROR;
}
}
}
if (CI_SUCCESS == reResult)
{
/*进路内所有道岔位置正确或位置不正确但可动作*/
devId = 0U;
devState = 0U;
checkResult = RouteSwitchPosAndMoveValidCheck(routeId, sendLevel);
if (CI_SUCCESS == checkResult)
{
/* 通过检查 */
reResult = CI_SUCCESS;
}
else
{
/* 失败返回 */
reResult = checkResult;
}
}
else
{
; /*继续执行*/
}
if (CI_SUCCESS == reResult)
{
/*进路内所有道岔位置正确
不正确：RETURN_LOCK_ERR_SWITPOS
正确：CI_SUCCESS */
devId = 0U;
devState = 0U;
checkResult = RouteAllSwitchPosCheck(routeId, &devId, &devState);
if (checkResult == CI_SUCCESS)
{
/* 通过检查 */
reResult = CI_SUCCESS;
}
else
{
/* 失败返回 */
reResult = RETURN_LOCK_ERR_SWITPOS;
}
}
else
{
/*如果是进路内道岔等待相邻联锁反馈道岔检查状态,先不检查道岔是否全在位置，继续等待*/
}
if ((CI_SUCCESS == reResult) || (RETURN_LOCK_ERR_SWITPOS == reResult))
{
/*进路关联防护道岔【未引导总锁】*/
devId = 0U;
devState = 0U;
checkResult = RouteRelatedProSwitchYLockCheck(routeId, &devId, &devState);
if (CI_SUCCESS == checkResult)
{
/* 通过检查 */
reResultP = CI_SUCCESS;
}
else
{
/* 记录故障码 */
SetErrorData(functionId, CI_DEVICE_TYPE_SWITCH, devId, ETYPE_SWT_YLOCK_STATE, devState, sendLevel);
/* 失败返回 */
reResultP = CI_ERROR;
}
if (CI_SUCCESS == reResultP)
{
/*进路关联防护道岔位置正确或位置不正确但可动作*/
devId = 0U;
devState = 0U;
checkResult = RouteRelProSwiPosAndMovValCheck(routeId, sendLevel);
if (CI_SUCCESS == checkResult)
{
/* 能检查到防护道岔是否可动作，说明道岔全在本控区或相邻控区已反馈道岔检查状态 */
/* 通过检查 */
reResultP = CI_SUCCESS;
}
else
{
/* 失败返回 */
reResultP = checkResult;
}
}
else
{
reResultP = CI_ERROR;
}
if (CI_SUCCESS == reResultP)
{
/*进路关联防护道岔位置正确*/
devId = 0U;
devState = 0U;
checkResult = RouteRelatedProSwitchPosCheck(routeId, &devId, &devState);
if (checkResult == CI_SUCCESS)
{
/* 通过检查 */
reResultP = CI_SUCCESS;
}
else
{
/* 失败返回 */
reResultP = RETURN_LOCK_ERR_SWITPOS;
}
}
else
{
/*如果是进路防护道岔等待相邻联锁反馈道岔检查状态,先不检查防护道岔是否全在位置，继续等待*/
}
if (CI_ERROR == reResultP)
{/*如果防护道岔的检查结果为错误，则总的检查结果为错误*/
reResult = CI_ERROR;
}
else if (CI_SUCCESS == reResultP)
{
/*如果防护道岔的检查结果为成功，则总的检查结果保持不变*/
}
else if (RETURN_LOCK_ERR_WAIT_SWCHECK == reResultP)
{
/*如果防护道岔的检查结果等待检查，则总的检查结果等待检查*/
reResult = RETURN_LOCK_ERR_WAIT_SWCHECK;
}
else if (RETURN_LOCK_ERR_SWITPOS == reResultP)
{/*如果防护道岔的检查结果为锁闭位置错误，则总的检查结果为锁闭位置错误*/
reResult = RETURN_LOCK_ERR_SWITPOS;
}
else
{/*其它不存在的情况，置总的结果为错误*/
reResult = CI_ERROR;
}
}
else if (RETURN_LOCK_ERR_WAIT_SWCHECK == reResult)
{
/*进路内道岔等待相邻联锁反馈道岔检查状态,先不检查防护道岔状态，继续等待*/
;
}
else
{
/* 失败返回 */
reResult = CI_ERROR;
}
/* 返回结果 */
return reResult;
}
/*
* 功能描述： 办理调车进路区段联锁条件检查
* 参数说明：
@@ -2892,7 +3216,8 @@ UINT8 LockLTrainRouteSectionCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLeve
UINT16 devId = 0u; /*设备ID*/
UINT8 devState = 0u; /*设备状态*/
UINT8 chRouteCouplinkFlag = 0U;
UINT8 chRouteLevel = 0U;
/* 联锁逻辑检查 */
/* 进路内所有区段未被封锁 */
@@ -2917,16 +3242,35 @@ UINT8 LockLTrainRouteSectionCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLeve
{
devId = 0u;
devState = 0u;
chRouteCouplinkFlag = GetRouteCouplinkFlag(routeId); /*获取进路联挂标志*/
chRouteLevel = GetRouteLevel(routeId); /*获取进路监督级别*/
if ((ROUTE_COUPLINK_FLAG_YES == chRouteCouplinkFlag) && (ROUTE_LEVEL_CBTC == chRouteLevel))
{
checkResult = SetCouplinkRouteSecOccCheck(routeId, &devId, &devState);
}
else
{
checkResult = RouteAllSecOccuClearCheck(routeId, &devId, &devState);
}
if (checkResult == CI_SUCCESS)
{
/* 通过检查 */
reResult = CI_SUCCESS;
}
else
{
if (0U == devId)
{
/* 记录故障码 */
SetErrorData(functionId, CI_DEVICE_TYPE_ROUTE, routeId, ETYPE_COUPLINK_ROUTE_IDLE, 0U, sendLevel);
}
else
{
/* 记录故障码 */
SetErrorData(functionId, CI_DEVICE_TYPE_PHYSEC, devId, ETYPE_PS_MERGY_OCU_STATE, devState, sendLevel);
}
/* 失败返回 */
reResult = CI_ERROR;
}
@@ -4193,7 +4537,7 @@ UINT8 SetLeadRouteCheck(const UINT16 routeId)
/*道岔联锁条件检查*/
if (CI_SUCCESS == reResult)
{
reResult = SetLTrainRouteSwitchCheck(routeId, functionId, sendLevel);
reResult = SetLeadRouteSwitchCheck(routeId, functionId, sendLevel);
if (CI_ERROR == reResult)
{
/* 失败返回 */
TSCP/src/APP/ciapp/LogicProcess/TradInterlockLogicProcess.h
+11
View File
@@ -266,6 +266,17 @@ UINT8 SetLTrainRouteSectionCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel
*/
UINT8 SetLTrainRouteSwitchCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel);
/*
* 功能描述：办理引导进路道岔联锁条件检查
* 参数说明：UINT16 RouteId, 进路号
* UINT8 functionId, 调用函数编号
* UINT8 sendLevel, 故障码发送级别
* 返 回 值：CI_ERROR 0 失败
* CI_SUCCESS 1 成功
* Created By LQ 2025.09.29
*/
UINT8 SetLeadRouteSwitchCheck(UINT16 routeId, UINT8 functionId, UINT8 sendLevel);
/*
* 功能描述： 办理调车进路区段联锁条件检查
* 参数说明：
TSCP/src/APP/ciapp/Main/MainApp.c
+20
View File
@@ -46,6 +46,7 @@ UINT8 MainProcess(void)
UINT8 retVal = CI_SUCCESS;
UINT8 localCiType = GetLocalCiType();
UINT16* pTiocFsVersion = NULL;
UINT8 cControlState = 0U; /*主备用状态*/
unsigned long long cost[20] = {0U};
#ifdef LOGPRINT
@@ -102,6 +103,10 @@ UINT8 MainProcess(void)
#endif/*2OO2平台标志结束*/
}
/*更新当前系统升主起始周期号*/
UpdateSystemMainUseCyc();
debug_infor_printf((const)"\n\nSystemMainUseCyc: %d\n", gSystemUpdateMainUseCycNum);/*系统切换主用起始周期号*/
#endif/*打印标志结束*/
cost[0] = MSCP_GetTick();
@@ -144,6 +149,21 @@ UINT8 MainProcess(void)
/*清除上周期故障码*/
ClearErrorData();
cControlState = GetLocalCiBackUpPattern();
if (SYSTEM_WORK_MODE_UNAVAILABLE == cControlState)
{
#if 0
/*系统不可用时，周期重置设备状态*/
ResetDevStateProcess();
debug_infor_printf((const)"\nMainProcess: ControlState[%d], ResetDevStateProcess\n", cControlState);
#endif
}
else
{
/*不处理*/
}
cost[6] = MSCP_GetTick();
debug_infor_printf((const)"\n Parse :%dms InputData:%dms MainProcess:%dms Output:%dms PackOut:%dms SendLog:%dms \n", (cost[1] - cost[0]) / 1000, (cost[2] - cost[1]) / 1000, (cost[3] - cost[2]) / 1000, (cost[4] - cost[3]) / 1000, (cost[5] - cost[4]) / 1000, (cost[6] - cost[5]) / 1000);
TSCP/src/APP/ciapp/Mask/MaskConfigDataManage.c
+4 -4
View File
@@ -50,7 +50,7 @@ UINT16 GetMaskId(const UINT8 SendsystemType, const UINT8 RecvsystemType, const U
{
UINT16 returnValue = 0u;/*·µ»ØÖµ*/
if (SendsystemType == CI_SYSTEM_TYPE_CI)
if (SendsystemType == CI_SYSTEM_TYPE_RCI)
{
switch (RecvsystemType)
{
@@ -74,7 +74,7 @@ UINT16 GetMaskId(const UINT8 SendsystemType, const UINT8 RecvsystemType, const U
}
else if (SendsystemType == CI_SYSTEM_TYPE_ZC)
{
if (CI_SYSTEM_TYPE_CI == RecvsystemType)
if (CI_SYSTEM_TYPE_RCI == RecvsystemType)
{
returnValue = ZcToCiMaskConfigDataStru[Index].MaskId;
}
@@ -345,7 +345,7 @@ UINT16 GetMaskIndex(const UINT8 SendsystemType, const UINT8 RecvsystemType, cons
if (SendsystemType == CI_SYSTEM_TYPE_CI)
if (SendsystemType == CI_SYSTEM_TYPE_RCI)
{
switch (RecvsystemType)
{
@@ -390,7 +390,7 @@ UINT16 GetMaskIndex(const UINT8 SendsystemType, const UINT8 RecvsystemType, cons
}
else if (SendsystemType == CI_SYSTEM_TYPE_ZC)
{
if (CI_SYSTEM_TYPE_CI == RecvsystemType)
if (CI_SYSTEM_TYPE_RCI == RecvsystemType)
{
for (ii = 1u; ii <= ZcToCiMaskCurSum; ii++)
{
TSCP/src/APP/ciapp/Mask/MaskDefine.h
+15 -3
View File
@@ -50,6 +50,7 @@
#define MASK_TYPE_SWITCH_OPEN_CAP ((UINT8)0x0E) /*定义道岔所在板卡开盖状态*/
#define MASK_TYPE_SWITCH_SUDDEN_JICHA ((UINT8)0x0F) /*定义道岔静态红闪码位*/
#define MASK_TYPE_SWITCH_JICHA ((UINT8)0x10) /*定义道岔挤岔码位：28.0.0.14数据结构使用*/
#define MASK_TYPE_SWITCH_QINGXIAN ((UINT8)0x11) /*定义道岔侵限状态码位*/
/*单轨_道岔码位*/
/* zt 删除单轨相关代码 2022-02-15 */
@@ -140,7 +141,7 @@
#define MASK_TYPE_LOGICSECTION_JUMPLOCK ((UINT8)0x9A) /*定义逻辑区段跳跃锁闭码位*/
#define MASK_TYPE_LOGICSECTION_ARB ((UINT8)0x9B) /*定义逻辑区段ARB状态码位*/
#define MASK_TYPE_LOGICSECTION_SPKS_FLOCK ((UINT8)0x9C) /*定义逻辑区段SPKS封锁状态码位*/
#define MASK_TYPE_LOGICSECTION_EMERG_XIANSU ((UINT8)0x9D) /*定义逻辑区段紧急临时限速码位*/
/*保护区段相关码位*/
@@ -167,6 +168,8 @@
#define MASK_TYPE_ROUTE_DC_AGREE ((UINT8)0x52) /*定义进路调车同意状态码位(CI-ATS)*/
#define MASK_TYPE_ROUTE_AUTO_TRIGGER ((UINT8)0x53) /*定义进路自动触发标码位(CI-ATS)*/
#define MASK_TYPE_ROUTE_DC_AGREE_ERR ((UINT8)0x54) /*定义进路调车同意按钮故障状态码位(CI-ATS)*/
#define MASK_TYPE_ROUTE_COUPLIN_SUCCESS ((UINT8)0xA8) /*定义进路联挂成功码位(ZC-CI)*/
#define MASK_TYPE_ROUTE_COUPLIN_ERROR ((UINT8)0xA9) /*定义进路联挂失败码位(ZC-CI)*/
/*站台相关码位*/
@@ -181,7 +184,9 @@
#define MASK_TYPE_CANCEL_ESP_FAULT ((UINT8)0x9c) /*定义取消紧急关闭按钮故障码位*/
#define MASK_TYPE_ESP_FAULT ((UINT8)0x9d) /*定义紧急关闭按钮故障码位*/
#define MASK_TYPE_CUT_ESP_FAULT ((UINT8)0xA3) /*定义紧急关闭旁路按钮故障码位*/
#define MASK_TYPE_ESP_PRESS_STATE ((UINT8)0xA4) /*定义紧急关闭按钮按下状态码位*/
#define MASK_TYPE_CUT_ESP_STATE ((UINT8)0xA4) /*定义紧急关闭旁路按钮激活状态码位*/
#define MASK_TYPE_ONEPLAT_ESP_STATE ((UINT8)0xAB) /*定义紧急关闭按钮同站紧急按钮激活状态码位*/
#define MASK_TYPE_ONEPLAT_CUT_ESP_STATE ((UINT8)0xAC) /*定义紧急关闭按钮同站旁路按钮激活状态码位*/
/*站台安全门相关码位*/
#define MASK_TYPE_PSD_STATE ((UINT8)0x60) /*定义站台安全门状态码位-ZC,LEU用*/
@@ -200,7 +205,10 @@
#define MASK_TYPE_PSD_VIDEO_QK_LU ((UINT8)0xA1) /*定义清客按钮箱视频清客表示灯（绿)状态码位*/
#define MASK_TYPE_PSD_VIDEO_QK_HONG ((UINT8)0xA2) /*定义清客按钮箱视频清客表示灯（红)状态码位*/
#define MASK_TYPE_PSD_EXCEPT_OPEN ((UINT8)0xA5) /*定义站台安全门异常打开码位*/
#define MASK_TYPE_PSD_JXTCPANGLU_FAULT ((UINT8)0xAA) /*定义间隙探测旁路按钮故障码位*/
#define MASK_TYPE_PSD_IBP_STATE ((UINT8)0xAD) /*定义IBP盘按钮状态码位*/
#define MASK_TYPE_PSD_IBP_FAULT ((UINT8)0xAE) /*定义IBP盘按钮故障码位*/
#define MASK_TYPE_PSD_JXTC_STATE ((UINT8)0xAF) /*定义间隙探测状态码位*/
/*车库门相关码位*/
#define MASK_TYPE_GARAGEDOOR_OPEN_STATE ((UINT8)0x62) /*定义车库门开门状态码位（CI->ATS）*/
#define MASK_TYPE_GARAGEDOOR_CLOSE_STATE ((UINT8)0x63) /*定义车库门关门状态码位（CI->ATS）*/
@@ -232,6 +240,10 @@
/*洗车机相关码位*/
#define MASK_TYPE_WASHMACHINE_READYSTATE ((UINT8)0x74) /*定义洗车机就绪状态码位*/
#define MASK_TYPE_WASHMACHINE_WORKMODE ((UINT8)0x9E) /*定义洗车机工作模式码位*/
#define MASK_TYPE_WASHMACHINE_ZNTBUTTN ((UINT8)0x9F) /*定义CI-ATS洗车机降级模式洗车线洗车同意按钮粘连码位,0有粘连，1为无粘连*/
#define MASK_TYPE_DCCWASHACHINE_ZNTBUTTN ((UINT8)0xb0) /*定义CI-ATS洗车机降级模式DCC洗车同意按钮粘连码位,0有粘连，1为无粘连*/
#define MASK_TYPE_PASSWASHMACHINE_ZNTBUTTN ((UINT8)0xb1) /*定义CI-ATS洗车机降级模式洗车线洗车反向通过同意按钮粘连码位,0有粘连，1为无粘连*/
#define MASK_TYPE_DCCPASSWASHMACHINE_ZNTBUTTN ((UINT8)0xb2) /*定义CI-ATS洗车机降级模式DCC洗车反向通过同意按钮粘连码位,0有粘连，1为无粘连*/
/*防淹门相关码位*/
TSCP/src/APP/ciapp/NonAutoReturn/NonAutoReturnDataManage.c
+13 -2
View File
@@ -16,6 +16,7 @@
NonAutoReturnDataStruct NonReturnDataStru[NON_AUTO_RETURN_SUM_MAX]; /*无人自动折返动态结构体*/
NonAutoReturnDataStructCC NonReturnDataStruCC[NON_AUTO_RETURN_SUM_MAX]; /*无人自动折返动态结构体-车车*/
/*
* 功能描述： 获取无人折返数据结构体指针
@@ -28,6 +29,16 @@ NonAutoReturnDataStruct* GetNonReturnData(void)
return NonReturnDataStru;
}
/*
* 功能描述： 获取无人折返数据结构体指针-车车
* 参数说明：
* 返回值 ：
NonAutoReturnDataStruct *
*/
NonAutoReturnDataStruct* GetNonReturnDataCC(void)
{
return NonReturnDataStruCC;
}
/*
* 功能描述： 获取指定ID无人自动折返按钮命令列车ID
* 参数说明： const UINT16 autoReturnId, 自动折返ID
@@ -41,7 +52,7 @@ UINT16 GetNonRtnCmdSetTrainId(const UINT16 nonReturnId)
bufIndex = GetNonReturnBufIndex(nonReturnId);
if (bufIndex < NON_AUTO_RETURN_SUM_MAX)
{
trainId = NonReturnDataStru[bufIndex].cmdSetTrainId;
trainId = NonReturnDataStruCC[bufIndex].cmdSetTrainId;
}
else
{
@@ -64,7 +75,7 @@ void SetNonRtnCmdSetTrainId(const UINT16 nonReturnId,const UINT16 trainId)
if (bufIndex < NON_AUTO_RETURN_SUM_MAX)
{
NonReturnDataStru[bufIndex].cmdSetTrainId = trainId;
NonReturnDataStruCC[bufIndex].cmdSetTrainId = trainId;
}
else
{
TSCP/src/APP/ciapp/NonAutoReturn/NonAutoReturnDataManage.h
+15 -2
View File
@@ -35,15 +35,21 @@ typedef struct S_RtnRelayAdhesionStruct
/*无人自动自动折返数据结构体*/
typedef struct S_NonAutoReturnDataStruct
{
UINT16 cmdSetTrainId; /*命令列车ID (动态字段)*/
UINT8 IndicatorDevID; /*指示灯设备ID*/
UINT8 VobcToCIAutoRtnIndicFlashState; /*车载给联锁的无人折返指示灯闪灯状态*/
UINT8 VobcToCIAutoRtnIndicSteadyState; /*车载给联锁的无人折返指示灯稳灯状态*/
RtnRelayAdhesionStruct RtnRelayAdhesionState; /*无人折返继电器粘连状态*/
} NonAutoReturnDataStruct;
extern NonAutoReturnDataStruct NonReturnDataStru[NON_AUTO_RETURN_SUM_MAX]; /*无人自动折返动态结构体*/
/*无人自动自动折返数据结构体-车车*/
typedef struct S_NonAutoReturnDataStructCC
{
UINT8 IndicatorDevID; /*指示灯设备ID*/
UINT16 cmdSetTrainId; /*命令列车ID (动态字段)*/
} NonAutoReturnDataStructCC;
extern NonAutoReturnDataStruct NonReturnDataStru[NON_AUTO_RETURN_SUM_MAX]; /*无人自动折返动态结构体*/
extern NonAutoReturnDataStructCC NonReturnDataStruCC[NON_AUTO_RETURN_SUM_MAX]; /*无人自动折返动态结构体-车车*/
/*
* 功能描述： 获取指定ID无人自动折返按钮命令列车ID
* 参数说明： const UINT16 autoReturnId, 自动折返ID
@@ -51,6 +57,13 @@ extern NonAutoReturnDataStruct NonReturnDataStru[NON_AUTO_RETURN_SUM_MAX]; /*
* >0: 无人自动折返按钮指示灯继电器ID
*/
UINT16 GetNonRtnCmdSetTrainId(const UINT16 nonReturnId);
/*
* 功能描述： 获取无人折返数据结构体指针-车车
* 参数说明：
* 返回值 ：
NonAutoReturnDataStruct *
*/
NonAutoReturnDataStruct* GetNonReturnDataCC(void);
/*
* 功能描述： 获取无人折返数据结构体指针
TSCP/src/APP/ciapp/Overlap/OverlapConfigDataManage.c
+69
View File
@@ -923,3 +923,72 @@ UINT16 GetOverlapThatZhaoChaRelayId(const UINT16 overlapId)
return reVal;
}
/*
* 功能描述： 获取指定保护区段侧防条件
* 参数说明： const UINT16 wRouteId, 进路ID
* 返回值 ： 返回侧防条件数据
*/
SideProtecGroupStru GetOverlapSideProtecGroupData(const UINT16 wOverlapId)
{
SideProtecGroupStru cRetVal = { 0u };
UINT16 bufIndex = 0U; /*数组下标*/
bufIndex = GetOverlapConfigBufIndex(wOverlapId); /*获取数组下标*/
if (OVERLAP_SUM_MAX > bufIndex)
{
cRetVal = OverlapConfigDataStru[bufIndex].SideProtecGroupData;
}
else
{
/*无处理*/
}
return cRetVal;
}
/*
* 功能描述： 获取保护区段指定道岔的防护锁闭位置
* 参数说明： const UINT16 wOverlapId, 保护区段ID
* const UINT16 wSwitchId 道岔ID
*
* 返回值 ：1，2为道岔位置,0u 非法值
*
*/
UINT8 GetOverlapThisPortecSwitchPos(const UINT16 wOverlapId, const UINT16 wSwitchId)
{
UINT8 chRetVal = 0U;
UINT16 bufIndex = 0U;
UINT8 i = 0u;
bufIndex = GetOverlapConfigBufIndex(wOverlapId); /*获取保护区段数组下标*/
if (OVERLAP_SUM_MAX > bufIndex)
{
for (i = 0u; i < OverlapConfigDataStru[bufIndex].ProtectSwitchSum; i++)
{
if (OverlapConfigDataStru[bufIndex].ProtectSwitchStru[i].ProtectSwitchId == wSwitchId)
{
chRetVal = OverlapConfigDataStru[bufIndex].ProtectSwitchStru[i].ProtectPosition;
break;
}
}
}
else
{
/*不处理*/
}
if ((SWITCH_POSITION_DINGWEI == chRetVal) || (SWITCH_POSITION_FANWEI == chRetVal))
{
/*校验通过*/
}
else
{
chRetVal = 0u;
}
return chRetVal;
}
TSCP/src/APP/ciapp/Overlap/OverlapConfigDataManage.h
+17 -2
View File
@@ -19,7 +19,7 @@
#include "CommonTypes.h"
#include "../System/CiSystemDefine.h"
#include "../System/SystemParameterManage.h"
#include "RouteConfigDataManage.h"
#ifdef __cplusplus
@@ -74,6 +74,7 @@ typedef struct S_OverlapConfigDataStruct
UINT16 AxisSecFarId; /*保护区段最远端计轴区段ID*/
UINT16 wOverlapThisZhaoChaRelayId; /*保护区段本端照查继电器ID*/
UINT16 wOverlapThatZhaoChaRelayId; /*保护区段对端照查继电器ID*/
SideProtecGroupStru SideProtecGroupData; /*保护区段侧防条件*/
} OverlapConfigDataStruct;
extern OverlapConfigDataStruct OverlapConfigDataStru[OVERLAP_SUM_MAX]; /*定义OVERLAP数据配置结构体,cgh-合并CID-2539-1：此处声明不进行初始化，统一放到InitAllStaticDataStr函数中进行初始化，为解决生成内核过大得问题*/
@@ -389,7 +390,21 @@ UINT16 GetOverlapThisZhaoChaRelayId(const UINT16 overlapId);
* by cgh 20250617
*/
UINT16 GetOverlapThatZhaoChaRelayId(const UINT16 overlapId);
/*
* 功能描述： 获取指定保护区段侧防条件
* 参数说明： const UINT16 wRouteId, 进路ID
* 返回值 ： 返回侧防条件数据
*/
SideProtecGroupStru GetOverlapSideProtecGroupData(const UINT16 wOverlapId);
/*
* 功能描述： 获取保护区段指定道岔的防护锁闭位置
* 参数说明： const UINT16 wOverlapId, 保护区段ID
* const UINT16 wSwitchId 道岔ID
*
* 返回值 ：1，2为道岔位置,0u 非法值
*
*/
UINT8 GetOverlapThisPortecSwitchPos(const UINT16 wOverlapId, const UINT16 wSwitchId);
#ifdef __cplusplus
}
#endif
TSCP/src/APP/ciapp/Overlap/OverlapDataManage.c
+318 -13
View File
@@ -15,7 +15,7 @@
OverlapDataStruct OverlapDataStru[OVERLAP_SUM_MAX]; /*定义OVERLAP数据结构体*/
OverlapDataStructCC OverlapDataStruCC[OVERLAP_SUM_MAX]; /*定义OVERLAP数据结构体-车车*/
/*
@@ -28,7 +28,16 @@ OverlapDataStruct *GetOverlapData(void)
{
return OverlapDataStru;
}
/*
* 功能描述： 获取指定ID保护区段数据-车车
* 参数说明：
* 返回值 ：
OverlapDataStructCC *
*/
OverlapDataStructCC* GetOverlapDataCC(void)
{
return OverlapDataStruCC;
}
/*
* 功能描述： 获取指定ID保护区段所属进路ID
* 参数说明： const UINT16 overlapId, 保护区段ID
@@ -82,6 +91,8 @@ void SetOverlapRelateProtSwLockSta(const UINT16 overlapId, const UINT8 lockComma
UINT16 protectSwitchId = 0u; /*防护道岔ID*/
UINT8 overlapProtectSwitchSum = 0u; /*防护道岔数目*/
OverlapProtectSwitchStruct* overlapProtectSwitchStru = NULL; /*防护道岔数据*/
UINT8 cSwitchCurPos = 0U;
UINT8 cFuncRet = CI_ERROR;
overlapProtectSwitchSum = GetOverlapRelatedProtSwitSum(overlapId); /*获取防护道岔数目*/
overlapProtectSwitchStru = GetOverlapRelatedProtSwitStru(overlapId); /*获取防护道岔数据*/
@@ -107,6 +118,11 @@ void SetOverlapRelateProtSwLockSta(const UINT16 overlapId, const UINT8 lockComma
for (ii= 0u; ii < overlapProtectSwitchSum; ii++)
{
protectSwitchId = overlapProtectSwitchStru[ii].ProtectSwitchId;
cSwitchCurPos = GetSwitchCurPosition(protectSwitchId);
cFuncRet = checkSwtLastValDrvPosStayorNot(protectSwitchId, overlapProtectSwitchStru[ii].ProtectPosition);
if ((SWITCH_LOCK_PROTECT_CANCEL == lockCommand)
|| ((SWITCH_LOCK_PROTECT_SET == lockCommand) && (cSwitchCurPos == overlapProtectSwitchStru[ii].ProtectPosition) && (CI_SUCCESS == cFuncRet)))
{
SetSwitchLockStatus(SWITCH_PLOCKTYPE_OVERLAP, overlapId, protectSwitchId, lockCommand); /*设置道岔防护锁闭状态*/
/*RC 13.0.0 修：不检查防护道岔中双动道岔另一端*/
#if 0
@@ -119,6 +135,11 @@ void SetOverlapRelateProtSwLockSta(const UINT16 overlapId, const UINT8 lockComma
}
#endif
}
else
{
/*防护道岔不在防护位置或防护道岔存在反向驱动时，不设置防护锁闭*/
}
}
}
else
{
@@ -265,7 +286,7 @@ void SetOverlapUnlockApplyFlag(const UINT16 overlapId, const UINT8 overlapUnlock
* 功能描述：获取指定ID保护区段申请解锁的列车ID
* 参数说明：const UINT16 overlapId, 保护区段ID
* 返回值 ：0 获取失败
* 其它 列车ID（不带0x14）
* 其它 列车ID（不带0x10）
*/
UINT16 GetOverlapUnlockApplyTrainId(const UINT16 overlapId)
{
@@ -276,7 +297,7 @@ UINT16 GetOverlapUnlockApplyTrainId(const UINT16 overlapId)
if (bufIndex < OVERLAP_SUM_MAX)
{
reVal = OverlapDataStru[bufIndex].wOverlapUnlockApplyTrainId;
reVal = OverlapDataStruCC[bufIndex].wOverlapUnlockApplyTrainId;
}
return reVal;
}
@@ -285,7 +306,7 @@ UINT16 GetOverlapUnlockApplyTrainId(const UINT16 overlapId)
/*
* 功能描述： 设置指定ID保护区段申请解锁的列车ID
* 参数说明： const UINT16 overlapId, 保护区段ID
* const UINT16 wTrainId，列车ID（不带0x14）
* const UINT16 wTrainId，列车ID（不带0x10）
* 返回值 ： 无
*
*/
@@ -297,7 +318,7 @@ void SetOverlapUnlockApplyTrainId(const UINT16 overlapId, const UINT16 wTrainId)
if (bufIndex < OVERLAP_SUM_MAX)
{
OverlapDataStru[bufIndex].wOverlapUnlockApplyTrainId = wTrainId;
OverlapDataStruCC[bufIndex].wOverlapUnlockApplyTrainId = wTrainId;
}
}
@@ -622,7 +643,7 @@ void SetReqIvocUnlockStartCycNum(const UINT16 overlapId, const UINT32 reqIvocUnl
if (bufIndex < OVERLAP_SUM_MAX)
{
OverlapDataStru[bufIndex].dwReqIvocUnLockStartCycNum = reqIvocUnlockStartCycNum; /*人工解锁起始周期号*/
OverlapDataStruCC[bufIndex].dwReqIvocUnLockStartCycNum = reqIvocUnlockStartCycNum; /*人工解锁起始周期号*/
}
}
@@ -641,7 +662,7 @@ UINT32 GetReqIvocUnlockStartCycNum(const UINT16 overlapId)
if (bufIndex < OVERLAP_SUM_MAX)
{
reVal = OverlapDataStru[bufIndex].dwReqIvocUnLockStartCycNum; /*人工解锁起始周期号*/
reVal = OverlapDataStruCC[bufIndex].dwReqIvocUnLockStartCycNum; /*人工解锁起始周期号*/
}
return reVal;
}
@@ -661,7 +682,7 @@ void SetOverlapIvocAllowUnlockFlag(const UINT16 overlapId, const UINT8 overlapIv
if ((bufIndex < OVERLAP_SUM_MAX) && ((IVOC_ALLOW_UNLOCK_OVERLAP_YES == overlapIvocUnlockFlag) || (IVOC_ALLOW_UNLOCK_OVERLAP_NO == overlapIvocUnlockFlag)))
{
OverlapDataStru[bufIndex].cIvocAllowUnlockFlag = overlapIvocUnlockFlag;
OverlapDataStruCC[bufIndex].cIvocAllowUnlockFlag = overlapIvocUnlockFlag;
}
else
{
@@ -685,7 +706,7 @@ UINT8 GetOverlapIvocAllowUnlockFlag(const UINT16 overlapId)
if (bufIndex < OVERLAP_SUM_MAX)
{
reVal = OverlapDataStru[bufIndex].cIvocAllowUnlockFlag;
reVal = OverlapDataStruCC[bufIndex].cIvocAllowUnlockFlag;
}
else
{
@@ -821,13 +842,13 @@ UINT8 GetOverlapFromSetRouteCmdFlag(const UINT16 overlapId)
}
/*
* 功能描述： 清保护区段人工或ATS锁闭命令标志
* 功能描述： 清除保护区段个别标志
* 参数说明： const UINT16 routeId, 进路ID
* const UINT16 overlapId, 保护区段ID
* 返回值:无
* by cgh 20240920
* by cgh 20260106
*/
void CleanOverlapAtsOrlaborLockFlag(const UINT16 routeId, const UINT16 overlapId)
void CleanOverlapSpecificFlag(const UINT16 routeId, const UINT16 overlapId)
{
UINT16 overlapRouteSum = 0U; /*保护区段进路数量*/
UINT16* pOverlapRouteBuf = NULL; /*保护区段进路数据*/
@@ -835,6 +856,8 @@ void CleanOverlapAtsOrlaborLockFlag(const UINT16 routeId, const UINT16 overlapId
UINT16 routeLastPhyId = 0U; /*进路最后一个物理区段ID*/
UINT8 routeLastPhyState = 0U; /*进路最后一个物理区段融合占用状态*/
UINT16 ii = 0U; /*游标*/
UINT32 dwUnlockStartCycNum = 0U; /*保护区段解锁起始周期号*/
UINT32 dwAtsLastTimeLockCyc = 0U; /*最近一次ATS锁闭保护区段周期号*/
overlapRouteSum = GetOverlapRouteIdSum(overlapId); /*获取保护区段进路数量*/
pOverlapRouteBuf = GetOverlapRouteIdBuf(overlapId); /*获取保护区段进路数据*/
@@ -855,6 +878,29 @@ void CleanOverlapAtsOrlaborLockFlag(const UINT16 routeId, const UINT16 overlapId
{
SetOverlapAtsOrlaborLockCmdFlag(overlapId, LOCK_OVERLAP_CMD_NO);
}
dwUnlockStartCycNum = GetOverlapUnlockStartCycNum(overlapId);
dwAtsLastTimeLockCyc = GetOverlapAtsLastTimeLockCyc(overlapId);
if (0U == dwUnlockStartCycNum)
{
/*说明是人工解锁，人工解锁就不保留之前的命令了*/
SetRouteAtsExpLkOverlapId(routeId, 0U);
SetOverlapFromSetRouteCmdFlag(overlapId, OVERLAP_ROUTE_FLAG_NO);/*清除保护区段建立命令由进路命令连带下发标志*/
}
else
{
if ((dwAtsLastTimeLockCyc < dwUnlockStartCycNum) && (0U < dwAtsLastTimeLockCyc))
{
/*ATS最后一次下发锁闭保护区段命令时保护区段未自动解锁*/
SetRouteAtsExpLkOverlapId(routeId, 0U);
SetOverlapFromSetRouteCmdFlag(overlapId, OVERLAP_ROUTE_FLAG_NO);/*清除保护区段建立命令由进路命令连带下发标志*/
}
else
{
;
}
}
}
/*
@@ -976,3 +1022,262 @@ UINT8 GetOverlapProSwtCheckStartFlag(const UINT16 wOverlapId)
return cRetVal;
}
/*
* 功能描述： 获取指定ID保护区段之前人工解锁状态
* 参数说明： const UINT16 overlapId, 保护区段ID
* 返回值 ： 0: 获取数据失败
* >0:之前人工解锁状态
* BY CGH 20250928
*/
UINT8 GetOverlapPreLoaborUnlockState(const UINT16 overlapId)
{
UINT16 bufIndex = 0U; /*数组下标*/
UINT8 reVal = CI_ERROR;
bufIndex = GetOverlapConfigBufIndex(overlapId); /*获取数组下标*/
if (bufIndex < OVERLAP_SUM_MAX)
{
reVal = OverlapDataStru[bufIndex].chPreLaborUnlockState;
}
else
{
;
}
return reVal;
}
/*
* 功能描述： 设置指定ID保护区段之前人工解锁状态
* 参数说明： const UINT16 overlapId, 保护区段ID
* const UINT8 chPreLaborUnlockState, 之前人工解锁状态
* 返回值 void
* by cgh 20250928
*/
void SetOverlapPreLoaborUnlockState(const UINT16 overlapId, const UINT8 chPreLaborUnlockState)
{
UINT16 bufIndex = 0U; /*数组下标*/
bufIndex = GetOverlapConfigBufIndex(overlapId); /*获取数组下标*/
if ((bufIndex < OVERLAP_SUM_MAX)
&& ((PRO_PRE_LABOR_UNLOCK_STATE_YES == chPreLaborUnlockState)
|| (PRO_PRE_LABOR_UNLOCK_STATE_NO == chPreLaborUnlockState)))
{
OverlapDataStru[bufIndex].chPreLaborUnlockState = chPreLaborUnlockState; /*设置解锁起始周期号*/
}
else
{
;
}
}
/*
* 功能描述：保护区段锁闭所属进路检查
* 参数说明： const UINT16 wOverlapId 进路ID
* 返回值 ：CI_SUCCESS 所有进路均空闲
* CI_ERROR 存在进路不是空闲
* by cgh 20250928
*/
UINT8 OverlapLockRouteCheck(const UINT16 wOverlapId)
{
UINT8 chReval = CI_ERROR;
UINT16 dwOverlapRouteSum = 0U; /*保护区段进路数目*/
UINT16* pOverlapRouteBuf = NULL; /*保护区段进路数组*/
UINT16 jj = 0U;
UINT8 chRouteState = 0U; /*进路状态*/
UINT8 chFlag = 0U; /*检查标志*/
if ((0U < wOverlapId) && (OVERLAP_SUM_MAX > wOverlapId))
{
dwOverlapRouteSum = GetOverlapRouteIdSum(wOverlapId);
pOverlapRouteBuf = GetOverlapRouteIdBuf(wOverlapId);
if ((NULL != pOverlapRouteBuf))
{
for (jj = 0U; jj < dwOverlapRouteSum; jj++)
{
chRouteState = GetRouteState(pOverlapRouteBuf[jj]);
if ((ROUTE_STATE_IDLE != chRouteState))
{
chFlag = 1U;
break;
}
else
{
;
}
}
if (0U == chFlag)
{
chReval = CI_SUCCESS;
}
else
{
; /*存在不空闲的进路*/
}
}
else
{
;
}
}
else
{
;
}
return chReval;
}
/*
* 功能描述：设置指定ID保护区段关联物理区段停准停稳状态
* 参数说明：const UINT16 overlapId 保护区段ID
* const UINT8 chSetFlag 设置标志
* 返回值 ：无
*/
void SetOverlapBelPhyStopSteadyFlag(const UINT16 wOverlapId, const UINT8 chSetFlag)
{
UINT16 wOverlopBelRouteId = 0U; /*保护区段锁闭所属进路ID*/
UINT8 chRoutePhySecSum = 0U; /*进路包含的物理区段数目*/
RoutePhysicalSectionStruct* szRoutePhySecData = NULL; /*进路包含物理区段结构数组*/
if ((0U < wOverlapId) && (wOverlapId < OVERLAP_SUM_MAX)
&& ((PHYSICAL_SECTION_STOPSTEADY_NO == chSetFlag) || (PHYSICAL_SECTION_STOPSTEADY_YES == chSetFlag)))
{
wOverlopBelRouteId = GetOverlapBelongRouteId(wOverlapId);
if (0U != wOverlopBelRouteId)
{
chRoutePhySecSum = GetRoutePhysicalSectionSum(wOverlopBelRouteId);
szRoutePhySecData = GetRouteSectionData(wOverlopBelRouteId);
if (NULL != szRoutePhySecData)
{
/*设置车车的物理区段停稳状态*/
SetPhySecStopSteadyFlagCC(szRoutePhySecData[chRoutePhySecSum - 1U].PhysicalSectionId, chSetFlag);
}
else
{
;
}
}
else
{
/*无锁闭所属进路不处理*/
}
}
else
{
/*不处理*/
}
}
/* 功能描述：清除期望保护区段关联所有进路的所有保护区段人工锁闭过标志
* 参数说明： const UINT16 expLkOverlapId, ATS或现地发送的期望锁闭区段ID
* 返回值 ： 无
* by cgh 20260106
*/
void ClearPreLoaborUnlockState(const UINT16 expLkOverlapId)
{
UINT8 overlapSum = 0U;
UINT16* overlapIdBuf = NULL;
UINT16 ii = 0U;
UINT8 jj = 0U;
UINT8 localCiId = 0U; /*本联锁集中区ID*/
UINT8 OverlapBelongCiId = 0U;
UINT16 overlapRouteSum = 0U;/*保护区段关联进路数量*/
UINT16* overlapRouteBuf = NULL;/*保护区段关联进路数据*/
overlapRouteSum = GetOverlapRouteIdSum(expLkOverlapId);/*获取保护区段关联进路总数*/
overlapRouteBuf = GetOverlapRouteIdBuf(expLkOverlapId);/*获取进路数据*/
localCiId = GetSystemParaLocalCiId(); /*获取本机联锁ID*/
if ((0U != overlapRouteSum) && (NULL != overlapRouteBuf))
{
for (ii = 0U; ii < overlapRouteSum; ii++)
{
overlapSum = GetRouteOverlapSum(overlapRouteBuf[ii]); /*获取Overlap总数*/
overlapIdBuf = GetRouteOverlapIdBuf(overlapRouteBuf[ii]); /*获取Overlap ID BUF*/
if ((0U == overlapSum) || (NULL == overlapIdBuf))
{
;/*数据异常*/
}
else
{
for (jj = 0U; jj < overlapSum; jj++)
{
OverlapBelongCiId = GetOverlapBelongCiId(overlapIdBuf[jj]);
if (OverlapBelongCiId == localCiId)
{
SetOverlapPreLoaborUnlockState(overlapIdBuf[jj], PRO_PRE_LABOR_UNLOCK_STATE_NO);
}
else
{
; /*相邻联锁的不处理*/
}
}
}
}
}
else
{
; /*不处理*/
}
}
/*
* 功能描述： 获取指定ID保护区段最近一次ATS锁闭保护区段周期号
* 参数说明： const UINT16 overlapId, 保护区段ID
* 返回值 ： 最近一次ATS锁闭保护区段周期号
* BY CGH 20260106
*/
UINT32 GetOverlapAtsLastTimeLockCyc(const UINT16 overlapId)
{
UINT16 bufIndex = 0U; /*数组下标*/
UINT32 reVal = CI_ERROR;
bufIndex = GetOverlapConfigBufIndex(overlapId); /*获取数组下标*/
if (bufIndex < OVERLAP_SUM_MAX)
{
reVal = OverlapDataStru[bufIndex].dwAtsLastTimeLockCyc;
}
else
{
;
}
return reVal;
}
/*
* 功能描述： 设置指定ID保护区段最近一次ATS锁闭保护区段周期号
* 参数说明： const UINT16 overlapId, 保护区段ID
* const UINT32 dwAtsLastTimeLockCyc, 最近一次ATS锁闭保护区段周期号
* 返回值 void
* by cgh 20250928
*/
void SetOverlapAtsLastTimeLockCyc(const UINT16 overlapId, const UINT32 dwAtsLastTimeLockCyc)
{
UINT16 bufIndex = 0U; /*数组下标*/
bufIndex = GetOverlapConfigBufIndex(overlapId); /*获取数组下标*/
if (bufIndex < OVERLAP_SUM_MAX)
{
OverlapDataStru[bufIndex].dwAtsLastTimeLockCyc = dwAtsLastTimeLockCyc; /*设置解锁起始周期号*/
}
else
{
;
}
}
TSCP/src/APP/ciapp/Overlap/OverlapDataManage.h
+89 -9
View File
@@ -35,9 +35,6 @@ typedef struct S_OverlapDataStruct
UINT32 UnlockStartCycNum; /*保护区段解锁起始周期号 (动态字段)*/
UINT32 XuanPaiStartCycNum; /*保护区段选排开始周期号(动态字段)*/
UINT8 OverlapUnlockApplyFlag; /*向ZC申请解锁保护区段解锁标志，20181105*/
UINT16 wOverlapUnlockApplyTrainId;/* 申请保护区段解锁的列车ID（不带0x14）*/
UINT32 dwReqIvocUnLockStartCycNum; /*向车申请解锁保护区段起始周期号*/
UINT8 cIvocAllowUnlockFlag; /*列车允许解锁保护区段标志，0xAA同意解锁，0x55不同意解锁*/
UINT8 OverlapCanLaborUnlockFlag;/*保护区段可以人工解锁标志*/
UINT8 OverlapLaborUnlockSetState;/*保护区段人工解锁设置状态*/
UINT32 laborUnlockStartCycNum;/*人工解锁起始周期号*/
@@ -48,10 +45,21 @@ typedef struct S_OverlapDataStruct
UINT8 OverlapFromSetRouteCmdFlag;/*保护区段由进路办理时连带的标志*/
UINT8 cProSwitchCheckResultFlag; /*跨控区防护道岔检查结果标志（0xFF：默认值，0x55：失败，0xAA：成功）*/
UINT8 cProSwitchCheckStartFlag; /*跨控区防护道岔检查开始标志（0x55：检查开始，0xAA：检查停止）*/
UINT8 chPreLaborUnlockState; /*之前人工解锁状态*/
UINT32 dwAtsLastTimeLockCyc; /*最近一次ATS锁闭保护区段周期号*/
} OverlapDataStruct;
/*保护区段数据结构体*/
typedef struct S_OverlapDataStructCC
{
UINT16 OverlapId; /*保护区段组ID (初始化字段)*/
UINT16 wOverlapUnlockApplyTrainId; /*申请保护区段解锁的列车ID（不带0x10）*/
UINT32 dwReqIvocUnLockStartCycNum; /*向车申请解锁保护区段起始周期号*/
UINT8 cIvocAllowUnlockFlag; /*列车允许解锁保护区段标志，0xAA同意解锁，0x55不同意解锁*/
}OverlapDataStructCC;
/*******************************全局变量声明*******************************/
extern OverlapDataStruct OverlapDataStru[OVERLAP_SUM_MAX]; /*定义OVERLAP数据结构体*/
extern OverlapDataStructCC OverlapDataStruCC[OVERLAP_SUM_MAX]; /*定义OVERLAP数据结构体-车车*/
/*
* 功能描述： 获取指定ID保护区段数据
* 参数说明：
@@ -59,6 +67,19 @@ extern OverlapDataStruct OverlapDataStru[OVERLAP_SUM_MAX]; /*
OverlapDataStruct *
*/
OverlapDataStruct *GetOverlapData(void);
/*
* 功能描述： 获取指定ID保护区段数据-车车
* 参数说明：
* 返回值 ：
OverlapDataStructCC *
*/
/*
* 功能描述： 获取指定ID保护区段数据-车车
* 参数说明：
* 返回值 ：
OverlapDataStructCC *
*/
OverlapDataStructCC* GetOverlapDataCC(void);
/*
* 功能描述： 获取指定ID保护区段所属进路ID
@@ -69,7 +90,7 @@ OverlapDataStruct *GetOverlapData(void);
UINT16 GetOverlapBelongRouteId(const UINT16 overlapId);
/*
* 功能描述： 设置指定ID保护区段组解锁起始周期号
* 功能描述： 设置指定ID保护区段所属进路
* 参数说明： const UINT16 overlapId, 保护区段ID
* const UINT16 belongRouteId, 所属进路号
* 返回值 ： 无
@@ -138,7 +159,7 @@ void SetOverlapUnlockApplyFlag(const UINT16 overlapId, const UINT8 overlapUnlock
* 功能描述：获取指定ID保护区段申请解锁的列车ID
* 参数说明：const UINT16 overlapId, 保护区段ID
* 返回值 ：0 获取失败
* 其它 列车ID（不带0x14）
* 其它 列车ID（不带0x10）
*/
UINT16 GetOverlapUnlockApplyTrainId(const UINT16 overlapId);
@@ -146,7 +167,7 @@ UINT16 GetOverlapUnlockApplyTrainId(const UINT16 overlapId);
/*
* 功能描述： 设置指定ID保护区段申请解锁的列车ID
* 参数说明： const UINT16 overlapId, 保护区段ID
* const UINT16 wTrainId，列车ID（不带0x14）
* const UINT16 wTrainId，列车ID（不带0x10）
* 返回值 ： 无
*
*/
@@ -315,13 +336,13 @@ void SetOverlapFromSetRouteCmdFlag(const UINT16 overlapId, const UINT8 setFlag);
UINT8 GetOverlapFromSetRouteCmdFlag(const UINT16 overlapId);
/*
* 功能描述： 清保护区段人工或ATS锁闭命令标志
* 功能描述： 清除保护区段个别标志
* 参数说明： const UINT16 routeId, 进路ID
* const UINT16 overlapId, 保护区段ID
* 返回值:无
* by cgh 20240920
* by cgh 20260106
*/
void CleanOverlapAtsOrlaborLockFlag(const UINT16 routeId, const UINT16 overlapId);
void CleanOverlapSpecificFlag(const UINT16 routeId, const UINT16 overlapId);
/*
* 功能描述：设置保护区段防护道岔检查结果标志
@@ -360,6 +381,65 @@ void SetOverlapProSwtCheckStartFlag(const UINT16 wOverlapId, const UINT8 cCheckS
*/
UINT8 GetOverlapProSwtCheckStartFlag(const UINT16 wOverlapId);
/*
* 功能描述： 获取指定ID保护区段之前人工解锁状态
* 参数说明： const UINT16 overlapId, 保护区段ID
* 返回值 ： 0: 获取数据失败
* >0:之前人工解锁状态
* BY CGH 20250928
*/
UINT8 GetOverlapPreLoaborUnlockState(const UINT16 overlapId);
/*
* 功能描述： 设置指定ID保护区段之前人工解锁状态
* 参数说明： const UINT16 overlapId, 保护区段ID
* const UINT8 chPreLaborUnlockState, 之前人工解锁状态
* 返回值 void
* by cgh 20250928
*/
void SetOverlapPreLoaborUnlockState(const UINT16 overlapId, const UINT8 chPreLaborUnlockState);
/*
* 功能描述：保护区段锁闭所属进路检查
* 参数说明： const UINT16 wOverlapId 进路ID
* 返回值 ：CI_SUCCESS 所有进路均空闲
* CI_ERROR 存在进路不是空闲
* by cgh 20250928
*/
UINT8 OverlapLockRouteCheck(const UINT16 wOverlapId);
/*
* 功能描述：设置指定ID保护区段关联物理区段停准停稳状态
* 参数说明：const UINT16 overlapId 保护区段ID
* const UINT8 chSetFlag 设置标志
* 返回值 ：无
*/
void SetOverlapBelPhyStopSteadyFlag(const UINT16 wOverlapId, const UINT8 chSetFlag);
/* 功能描述：清除期望保护区段关联所有进路的所有保护区段人工锁闭过标志
* 参数说明： const UINT16 expLkOverlapId, ATS或现地发送的期望锁闭区段ID
* 返回值 ： 无
* by cgh 20260106
*/
void ClearPreLoaborUnlockState(const UINT16 expLkOverlapId);
/*
* 功能描述： 获取指定ID保护区段最近一次ATS锁闭保护区段周期号
* 参数说明： const UINT16 overlapId, 保护区段ID
* 返回值 ： 最近一次ATS锁闭保护区段周期号
* BY CGH 20260106
*/
UINT32 GetOverlapAtsLastTimeLockCyc(const UINT16 overlapId);
/*
* 功能描述： 设置指定ID保护区段最近一次ATS锁闭保护区段周期号
* 参数说明： const UINT16 overlapId, 保护区段ID
* const UINT32 dwAtsLastTimeLockCyc, 最近一次ATS锁闭保护区段周期号
* 返回值 void
* by cgh 20250928
*/
void SetOverlapAtsLastTimeLockCyc(const UINT16 overlapId, const UINT32 dwAtsLastTimeLockCyc);
#ifdef __cplusplus
}
#endif
TSCP/src/APP/ciapp/Overlap/OverlapDefine.h
+4
View File
@@ -72,6 +72,10 @@
#define PROSWITCH_CHECK_START_VALID ((UINT8)0x55) /*开始检查*/
#define PROSWITCH_CHECK_START_INVALID ((UINT8)0xAA) /*停止检查*/
/*保护区段之前人工解锁标志*/
#define PRO_PRE_LABOR_UNLOCK_STATE_YES ((UINT8)0x55) /*之前成功人工解锁过*/
#define PRO_PRE_LABOR_UNLOCK_STATE_NO ((UINT8)0xAA) /*之前未人工解锁过*/
#define OVERLAP_USING_OVERTIME_CYC_NUM 10U /*保护区段征用超时周期数*/
#endif
TSCP/src/APP/ciapp/PSD/PSDConfigDataManage.c
+117
View File
@@ -1066,3 +1066,120 @@ UINT8 GetPsdControlType(const UINT16 doorId)
return retVal;
}
/*
* 功能描述： 获取指定ID屏蔽门三编组驱动开门继电器ID
* 参数说明： const UINT16 doorId, 屏蔽门ID
* 返回值 ： 0: 获取数据失败
* >0: 驱动开门继电器ID
*/
UINT16 GetThreeGroupPsdOpenDrvRelayId(const UINT16 doorId)
{
UINT16 bufIndex = 0u; /*数组下标*/
UINT16 retVal = 0u;
bufIndex = GetPsdConfigBufIndex(doorId); /*获取屏蔽门数组下标*/
if (PSD_SUM_MAX > bufIndex)
{
retVal = PsdConfigDataStru[bufIndex].OpenThreeEditGroupDriveRelayId;
}
else
{
retVal = CI_ERROR;
}
return retVal;
}
/*
* 功能描述： 获取指定ID屏蔽门再次开门继电器ID2
* 参数说明： const UINT16 doorId, 屏蔽门ID
* 返回值 ： 0: 获取数据失败
* >0: 再次开门继电器ID
*/
UINT16 GetPsdReOpenRelayId2(const UINT16 doorId)
{
UINT16 bufIndex = 0u; /*数组下标*/
UINT16 retVal = CI_ERROR;
bufIndex = GetPsdConfigBufIndex(doorId); /*获取屏蔽门数组下标*/
if (PSD_SUM_MAX > bufIndex)
{
retVal = PsdConfigDataStru[bufIndex].doorReopenRelayId2;
}
else
{
retVal = CI_ERROR;
}
return retVal;
}
/*
* 功能描述： 获取指定ID屏蔽门包含ESB
* 参数说明： const UINT16 doorId, 屏蔽门ID
* 返回值 ：ESB ID数组
*/
UINT16* GetPsdIncloudeEsbIdBuf(const UINT16 psdId)
{
UINT16 bufIndex = 0u; /*数组下标*/
UINT16* retVal = NULL;
bufIndex = GetPsdConfigBufIndex(psdId); /*获取屏蔽门数组下标*/
if (PSD_SUM_MAX > bufIndex)
{
retVal = PsdConfigDataStru[bufIndex].IncloudeEsbIdBuf;
}
else
{
retVal = NULL;
}
return retVal;
}
/*
* 功能描述： 获取指定ID屏蔽门包含ESB数量
* 参数说明： const UINT16 doorId, 屏蔽门ID
* 返回值 ：ESB ID数组
*/
UINT8 GetPsdIncloudeEsbNum(const UINT16 psdId)
{
UINT16 bufIndex = 0u; /*数组下标*/
UINT8 retVal = NULL;
bufIndex = GetPsdConfigBufIndex(psdId); /*获取屏蔽门数组下标*/
if (PSD_SUM_MAX > bufIndex)
{
retVal = PsdConfigDataStru[bufIndex].IncloudeEsbNum;
}
else
{
retVal = NULL;
}
return retVal;
}
/*
* 功能描述： 获取指定ID屏蔽门IBP盘发车按钮继电器ID
* 参数说明： const UINT16 doorId, 屏蔽门ID
* 返回值 ： 0: 获取数据失败
* >0: IBP盘发车按钮继电器ID
*/
UINT16 GetIbpConfmRelayId(const UINT16 doorId)
{
UINT16 bufIndex = 0u; /*数组下标*/
UINT16 retVal = CI_ERROR;
bufIndex = GetPsdConfigBufIndex(doorId); /*获取屏蔽门数组下标*/
if (bufIndex < PSD_SUM_MAX)
{
retVal = PsdConfigDataStru[bufIndex].wIbpRelayId;
}
else
{
retVal = CI_ERROR;
}
return retVal;
}
TSCP/src/APP/ciapp/PSD/PSDConfigDataManage.h
+39
View File
@@ -39,6 +39,7 @@ typedef struct S_PsdConfigDataStruct
UINT16 MutualLockRelayId; /*互锁解除继电器ID (配置字段)*/
UINT16 wMutualLockRelayId2; /*互锁解除继电器ID2(配置字段) 迪斯尼*/
UINT16 CloseDriveRelayId; /*关门继电器ID (配置字段)*/
UINT16 OpenThreeEditGroupDriveRelayId; /*打开三编组屏蔽门的驱动继电器(配置字段)*/
UINT16 OpenFourEditGroupDriveRelayId; /*打开四编组屏蔽门的驱动继电器(配置字段)*/
UINT16 OpenSixEditGroupDriveRelayId; /*打开六编组屏蔽门的驱动继电器(配置字段)*/
UINT16 OpenEightEditGroupDriveRelayId; /*打开八编组屏蔽门的驱动继电器(配置字段)*/
@@ -46,6 +47,7 @@ typedef struct S_PsdConfigDataStruct
UINT16 wDoorStateRelayId2; /*门开采集继电器ID2(配置字段) 迪斯尼*/
UINT16 wRelayDoorButtonId; /*屏蔽门再关门按钮继电器*/
UINT16 doorReopenRelayId; /*站台门再次开门继电器*/
UINT16 doorReopenRelayId2; /*站台门再次开门继电器2*/
UINT16 departureConfirmRelayId; /*发车确认继电器*/
UINT16 detectStartRelayId; /*启动探测继电器*/
UINT16 detectStopRelayId; /*停止探测继电器*/
@@ -68,6 +70,9 @@ typedef struct S_PsdConfigDataStruct
UINT16 wPsdSndProLinkId; /*屏蔽门防护link2ID*/
UINT16 wPsdTrdProLinkId; /*屏蔽门防护link3ID*/
UINT8 chPsdControlType; /*屏蔽门控制类型*/
UINT16 IncloudeEsbIdBuf[PSD_INCLUDE_ESB_NUM]; /*屏蔽门包含ESB ID*/
UINT8 IncloudeEsbNum; /*包含ESB数量*/
UINT16 wIbpRelayId; /*IBP盘发车按钮继电器ID*/
} PsdConfigDataStruct;
@@ -421,6 +426,40 @@ UINT8 CheckPsdBelSendRange(const UINT16 wCheckPsdId);
* 返回值 ： UINT8 控制类型（0x55 OC-P控制 0xAA RCI控制）
*/
UINT8 GetPsdControlType(const UINT16 doorId);
/*
* 功能描述： 获取指定ID屏蔽门三编组驱动开门继电器ID
* 参数说明： const UINT16 doorId, 屏蔽门ID
* 返回值 ： 0: 获取数据失败
* >0: 驱动开门继电器ID
*/
UINT16 GetThreeGroupPsdOpenDrvRelayId(const UINT16 doorId);
/*
* 功能描述： 获取指定ID屏蔽门再次开门继电器ID2
* 参数说明： const UINT16 doorId, 屏蔽门ID
* 返回值 ： 0: 获取数据失败
* >0: 再次开门继电器ID
*/
UINT16 GetPsdReOpenRelayId2(const UINT16 doorId);
/*
* 功能描述： 获取指定ID屏蔽门包含ESB数量
* 参数说明： const UINT16 doorId, 屏蔽门ID
* 返回值 ：ESB ID数组
*/
UINT8 GetPsdIncloudeEsbNum(const UINT16 psdId);
/*
* 功能描述： 获取指定ID屏蔽门包含ESB
* 参数说明： const UINT16 doorId, 屏蔽门ID
* 返回值 ：ESB ID数组
*/
UINT16* GetPsdIncloudeEsbIdBuf(const UINT16 psdId);
/*
* 功能描述： 获取指定ID屏蔽门IBP盘发车按钮继电器ID
* 参数说明： const UINT16 doorId, 屏蔽门ID
* 返回值 ： 0: 获取数据失败
* >0: IBP盘发车按钮继电器ID
*/
UINT16 GetIbpConfmRelayId(const UINT16 doorId);
#ifdef __cplusplus
}
TSCP/src/APP/ciapp/PSD/PSDDataManage.c
+521 -1
View File
@@ -11,8 +11,10 @@
#include "PSDDataManage.h"
#include "../ParsePack/ParsePackDefine.h"
#include "ESBDataManage.h"
PsdDataStruct PsdDataStru[PSD_SUM_MAX]; /*定义屏蔽门数据结构体*/
PsdDataStruct PsdDataStru[PSD_SUM_MAX] = { 0U }; /*定义屏蔽门数据结构体*/
PsdDataStructCC PsdDataStruCC[PSD_SUM_MAX] = { 0U }; /*定义车车屏蔽门数据结构体*/
/*
* 功能描述： 获取指定ID屏蔽门数据
@@ -24,6 +26,16 @@ PsdDataStruct *GetPsdData(void)
return PsdDataStru;
}
/*
* 功能描述：获取指定ID屏蔽门数据CC
* 参数说明：无
* 返 回 值：车车屏蔽门动态数据
*/
PsdDataStructCC* GetPsdDataCC(void)
{
return PsdDataStruCC;
}
/*
* 功能描述： 获取指定ID屏蔽门互锁解除状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
@@ -519,6 +531,9 @@ void ResetPsdData(const UINT16 psdId)
PsdDataStru[bufIndex].PsdDriveState=PSD_DRIVE_STATE_INVALID;
PsdDataStru[bufIndex].PsdPreDriveState=PSD_DRIVE_STATE_INVALID;
SetPsdVobcCmdCC(psdId,0u, PSD_DEFAULT_CONTROL_CMD,0u);
SetPsdEditGroupInfoDataCC(psdId, PSD_EDIT_GROUP_DEFAULT); /*设置RC的PSD编组信息为默认值*/
}
else
{
@@ -937,6 +952,54 @@ UINT8 GetStopDetectionState(const UINT16 doorId)
}
return retVal;
}
/*
* 功能描述：设置指定PSD停止探测周期号
* 参数说明： const UINT16 doorId, 屏蔽门ID
* const UINT32 startCycNum, 起始周期号
* 返回值 ： 无
*
*/
void SetStopDetectionCycNum(const UINT16 doorId, const UINT32 startCycNum)
{
UINT16 bufIndex = 0u; /*数组下标*/
bufIndex = GetPsdConfigBufIndex(doorId); /*获取屏蔽门数组下标*/
if (bufIndex < PSD_SUM_MAX)
{
PsdDataStru[bufIndex].StopDetectionCycNum = startCycNum;
}
else
{
/*不做处理*/
}
}
/*
* 功能描述： 获取停止探测起始周期号
* 参数说明： const UINT16 doorId, 进路ID
* 返回值 ： 0: 获取数据失败
* >0: 起始周期号
*/
UINT32 GetStopDetectionCycNum(const UINT16 doorId)
{
UINT16 bufIndex = 0u; /*数组下标*/
UINT32 retVal = CI_ERROR;
bufIndex = GetPsdConfigBufIndex(doorId); /*获取屏蔽门数组下标*/
if (bufIndex < PSD_SUM_MAX)
{
retVal = PsdDataStru[bufIndex].StopDetectionCycNum;
}
else
{
retVal = CI_ERROR;
}
return retVal;
}
#if 0
/*
* 功能描述： 设置因VOBC关PSD而需要被重开的进路
@@ -2856,3 +2919,460 @@ void SetPsdRelayDownCycNum(const UINT16 doorId, const UINT32 startCycNum)
/*不处理*/
}
}
/*
* 功能描述：获取指定ID屏蔽门编组信息CC
* 参数说明：const UINT16 doorId, 屏蔽门ID
* 返 回 值：0 无编组信息
* 3 三编组
* 4 四编组
* 6 六编组
* 8 八编组
* Created By LQ 2025.11.05
*/
UINT16 GetPsdEditGroupInfoDataCC(const UINT16 doorId)
{
UINT16 bufIndex = 0U; /*数组下标*/
UINT16 retVal = CI_ERROR;
bufIndex = GetPsdConfigBufIndex(doorId); /*获取屏蔽门数组下标*/
if (bufIndex < PSD_SUM_MAX)
{
retVal = PsdDataStruCC[bufIndex].psdEditGroupInfo;
}
else
{
retVal = CI_ERROR;
}
return retVal;
}
/*
* 功能描述：设置指定ID屏蔽门编组信息CC
* 参数说明：const UINT16 doorId, 屏蔽门ID
* const UINT16 wPsdEditGroupInfo 屏蔽门编组信息
* 返 回 值：无
* Created By LQ 2025.11.05
*/
void SetPsdEditGroupInfoDataCC(const UINT16 doorId, const UINT16 wPsdEditGroupInfo)
{
UINT16 bufIndex = 0U; /*数组下标*/
bufIndex = GetPsdConfigBufIndex(doorId); /*获取屏蔽门数组下标*/
if (bufIndex < PSD_SUM_MAX)
{
if ((PSD_THREE_EDIT_GROUP == wPsdEditGroupInfo)
|| (PSD_FOUR_EDIT_GROUP == wPsdEditGroupInfo)
|| (PSD_SIX_EDIT_GROUP == wPsdEditGroupInfo)
|| (PSD_EIGHT_EDIT_GROUP == wPsdEditGroupInfo)
|| (PSD_EDIT_GROUP_DEFAULT == wPsdEditGroupInfo))
{
PsdDataStruCC[bufIndex].psdEditGroupInfo = wPsdEditGroupInfo; /*不考虑FAO的特殊接口*/
}
else
{
/*不处理*/
}
}
else
{
/*不处理*/
}
}
/*
* 功能描述：获取PSD的VOBC控制命令CC
* 参数说明：const UINT16 doorId,屏蔽门ID
* 返 回 值：0x00-默认值
* 0x55-打开PSD命令
* 0xAA-关闭PSD命令
* 0xFF-查询PSD命令
* Created By LQ 2025.11.05
*/
UINT8 GetPsdVobcCmdCC(const UINT16 doorId)
{
UINT16 bufIndex = 0U; /*数组下标*/
UINT8 ctrlCmd = PSD_DEFAULT_CONTROL_CMD;
bufIndex = GetPsdConfigBufIndex(doorId); /*获取屏蔽门数组下标*/
if (bufIndex < PSD_SUM_MAX)
{
ctrlCmd = PsdDataStruCC[bufIndex].PsdCmd;
}
else
{
ctrlCmd = PSD_DEFAULT_CONTROL_CMD;
}
return ctrlCmd;
}
/*
* 功能描述： 获取当前控制该PSD的VOBC的编号CC
* 参数说明： const UINT16 doorId,屏蔽门ID
* 返 回 值： VOBC ID
* Created By LQ 2025.11.05
*/
UINT16 GetPsdVobcIdCC(const UINT16 doorId)
{
UINT16 bufIndex = 0U; /*数组下标*/
UINT16 vobcId = 0U;
bufIndex = GetPsdConfigBufIndex(doorId); /*获取屏蔽门数组下标*/
if (bufIndex < PSD_SUM_MAX)
{
vobcId = PsdDataStruCC[bufIndex].SrcVobcId;
}
else
{
vobcId = 0U;
}
return vobcId;
}
/*
* 功能描述：获得该PSD的控制命令的设置周期CC
* 参数说明：const UINT16 doorId,屏蔽门ID
* 返 回 值：该PSD的控制命令的设置周期
* Created By LQ 2025.11.05
*/
UINT32 GetPsdCmdSetCycleCC(const UINT16 doorId)
{
UINT16 bufIndex = 0U; /*数组下标*/
UINT32 setCycle = 0U;
bufIndex = GetPsdConfigBufIndex(doorId); /*获取屏蔽门数组下标*/
if (bufIndex < PSD_SUM_MAX)
{
setCycle = PsdDataStruCC[bufIndex].CmdSetCycle;
}
else
{
setCycle = 0U;
}
return setCycle;
}
/*
* 功能描述：设置PSD的VOBC操作命令CC
* 参数说明：const UINT16 doorId 屏蔽门ID
* const UINT16 vobcId 操作屏蔽门的VOBC ID
* const UINT8 operCmd 来自VOBC的开关门命令
* const UINT32 dwCycNum 周期号
* 返 回 值：无
* Created By LQ 2025.11.05
*/
void SetPsdVobcCmdCC(const UINT16 doorId, const UINT16 vobcId, const UINT8 operCmd, const UINT32 dwCycNum)
{
UINT16 bufIndex = 0U; /*数组下标*/
bufIndex = GetPsdConfigBufIndex(doorId); /*获取屏蔽门数组下标*/
if (bufIndex < PSD_SUM_MAX)
{
if ((PSD_DEFAULT_CONTROL_CMD == operCmd)
|| (VOBCTOCI_COMMAND_TYPE_PSDOPEN == operCmd)
|| (VOBCTOCI_COMMAND_TYPE_PSDCLOSE == operCmd)
|| (VOBCTOCI_COMMAND_TYPE_PSDCHECK_FAOHLHT == operCmd))
{
if (PsdDataStruCC[bufIndex].SrcVobcId == vobcId)
{
PsdDataStruCC[bufIndex].PsdCmd = operCmd;
}
else
{
/*另一个VOBC开始操作该屏蔽门，对之前VOBC操作该屏蔽门产生的上下文进行复位*/
PsdDataStruCC[bufIndex].SrcVobcId = vobcId;
PsdDataStruCC[bufIndex].PsdCmd = operCmd;
}
PsdDataStruCC[bufIndex].CmdSetCycle = dwCycNum;
}
else
{
/*命令非法，不处理*/
}
}
else
{
/*不做处理*/
}
}
/*
* 功能描述：获取指定ID屏蔽门编组信息CC
* 参数说明：const UINT16 doorId, 屏蔽门ID
* 返 回 值：0 无编组信息
* 3 三编组
* 4 四编组
* 6 六编组
* 8 八编组
*/
UINT16 GetPsdEditGroupInfoData(const UINT16 doorId)
{
UINT16 bufIndex = 0U; /*数组下标*/
UINT16 retVal = CI_ERROR;
bufIndex = GetPsdConfigBufIndex(doorId); /*获取屏蔽门数组下标*/
if (bufIndex < PSD_SUM_MAX)
{
retVal = PsdDataStru[bufIndex].psdEditGroupInfo;
}
else
{
retVal = CI_ERROR;
}
return retVal;
}
/*
* 功能描述：设置指定ID屏蔽门编组信息
* 参数说明：const UINT16 doorId, 屏蔽门ID
* const UINT16 wPsdEditGroupInfo 屏蔽门编组信息
* 返 回 值：无
*/
void SetPsdEditGroupInfoData(const UINT16 doorId, const UINT16 wPsdEditGroupInfo)
{
UINT16 bufIndex = 0U; /*数组下标*/
bufIndex = GetPsdConfigBufIndex(doorId); /*获取屏蔽门数组下标*/
if (bufIndex < PSD_SUM_MAX)
{
if ((PSD_THREE_EDIT_GROUP == wPsdEditGroupInfo)
|| (PSD_FOUR_EDIT_GROUP == wPsdEditGroupInfo)
|| (PSD_SIX_EDIT_GROUP == wPsdEditGroupInfo)
|| (PSD_EIGHT_EDIT_GROUP == wPsdEditGroupInfo)
|| (PSD_EDIT_GROUP_DEFAULT == wPsdEditGroupInfo))
{
PsdDataStru[bufIndex].psdEditGroupInfo = wPsdEditGroupInfo; /*不考虑FAO的特殊接口*/
}
else
{
/*不处理*/
}
}
else
{
/*不处理*/
}
}
/*
* 功能描述：获取指定ID屏蔽门间隙探测互锁解除故障状态
* 参数说明：const UINT16 doorId, 屏蔽门ID
* 返 回 值： 0 返回失败
* 0< 间隙探测互锁解除故障状态
*/
UINT8 GetPsdJXTCMutualLockFaultState(const UINT16 doorId)
{
UINT16 bufIndex = 0U; /*数组下标*/
UINT8 retVal = CI_ERROR;
bufIndex = GetPsdConfigBufIndex(doorId); /*获取屏蔽门数组下标*/
if (PSD_SUM_MAX > bufIndex)
{
retVal = PsdDataStru[bufIndex].JXTCMutualLockFaultState;
}
else
{
retVal = CI_ERROR;
}
return retVal;
}
/*
* 功能描述：设置指定ID屏蔽门间隙探测互锁解除故障状态
* 参数说明：const UINT16 doorId, 屏蔽门ID
* const UINT8 wJXTCMutualLockFaultState 间隙探测互锁解除故障状态
* 返 回 值：无
*/
void SetPsdJXTCMutualLockFaultState(const UINT16 doorId, const UINT8 wJXTCMutualLockFaultState)
{
UINT16 bufIndex = 0U; /*数组下标*/
bufIndex = GetPsdConfigBufIndex(doorId); /*获取屏蔽门数组下标*/
if (PSD_SUM_MAX > bufIndex)
{
if ((JXTC_MUTUALLOCKFAULT_YES == wJXTCMutualLockFaultState)
|| (JXTC_MUTUALLOCKFAULT_NO == wJXTCMutualLockFaultState))
{
PsdDataStru[bufIndex].JXTCMutualLockFaultState = wJXTCMutualLockFaultState; /*间隙探测互锁解除故障状态*/
}
else
{
/*不处理*/
}
}
else
{
/*不处理*/
}
}
/*
* 功能描述：获取指定ID屏蔽门间隙探测互锁解除时间
* 参数说明：const UINT16 doorId, 屏蔽门ID
* 返 回 值： 0 返回失败
* 0< 屏蔽门间隙探测互锁解除时间
*/
UINT32 GetPsdJXTCMutualLockStartCycNum(const UINT16 doorId)
{
UINT16 bufIndex = 0U; /*数组下标*/
UINT32 retVal = CI_ERROR;
bufIndex = GetPsdConfigBufIndex(doorId); /*获取屏蔽门数组下标*/
if (PSD_SUM_MAX > bufIndex)
{
retVal = PsdDataStru[bufIndex].JXTCMutualLockStartCycNum;
}
else
{
retVal = CI_ERROR;
}
return retVal;
}
/*
* 功能描述：设置指定ID屏蔽门间隙探测互锁解除起始时间
* 参数说明：const UINT16 doorId, 屏蔽门ID
* const UINT32 cycnum 互锁解除起始时间
* 返 回 值：无
*/
void SetPsdJXTCMutualLockStartCycNum(const UINT16 doorId, const UINT32 cycnum)
{
UINT16 bufIndex = 0U; /*数组下标*/
bufIndex = GetPsdConfigBufIndex(doorId); /*获取屏蔽门数组下标*/
if (PSD_SUM_MAX > bufIndex)
{
PsdDataStru[bufIndex].JXTCMutualLockStartCycNum = cycnum;
}
else
{
/*不处理*/
}
}
/*
* 功能描述： 设置指定ID屏蔽门IBP盘发车按钮状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
* UINT8 setFlag 需设置的按钮状态
* 返回值 ： CI_ERROR 失败
* CI_SUCCESS 成功
*/
UINT8 SetPsdButtonIbpState(const UINT16 doorId, const UINT8 setFlag)
{
UINT16 bufIndex = 0u; /*数组下标*/
UINT8 retVal = 0u;
bufIndex = GetPsdConfigBufIndex(doorId); /*获取屏蔽门数组下标*/
if (bufIndex < PSD_SUM_MAX)
{
if ((PLATFORM_DEPAR_BUTTON_STATE_VALID == setFlag) || (PLATFORM_DEPAR_BUTTON_STATE_INVALID == setFlag)
||(PLATFORM_DEPAR_BUTTON_STATE_FAULT == setFlag))
{
PsdDataStru[bufIndex].ibpButtonState = setFlag; /*设置按钮状态*/
retVal = CI_SUCCESS;
}
else
{
retVal = CI_ERROR;
}
}
else
{
retVal = CI_ERROR;
}
return retVal;
}
/*
* 功能描述： 获取指定ID屏蔽门IBP盘发车按钮状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
* 返回值 ：0: 获取数据失败
* >0: IBP盘发车按钮状态
*/
UINT8 GetPsdButtonIbpState(const UINT16 doorId)
{
UINT16 bufIndex = 0u; /*数组下标*/
UINT8 retVal = 0u;
bufIndex = GetPsdConfigBufIndex(doorId); /*获取屏蔽门数组下标*/
if (bufIndex < PSD_SUM_MAX)
{
retVal = PsdDataStru[bufIndex].ibpButtonState;
}
else
{
retVal = CI_ERROR;
}
return retVal;
}
/*
* 功能描述：设置指定ID屏蔽门IBP按下起始周期号
* 参数说明： const UINT16 doorId, 屏蔽门ID
* const UINT32 startCycNum, 起始周期号
* 返回值 ： 0: 设置数据失败
* >0: 设置数据成功
*/
UINT8 SetIBPPressCycNum(const UINT16 doorId, const UINT32 startCycNum)
{
UINT16 bufIndex = 0u; /*数组下标*/
UINT8 retVal = CI_ERROR;
bufIndex = GetPsdConfigBufIndex(doorId); /*获取屏蔽门数组下标*/
if (bufIndex < PSD_SUM_MAX)
{
PsdDataStru[bufIndex].IBPPressCycNum = startCycNum;
retVal = CI_SUCCESS;
}
else
{
retVal = CI_ERROR;
}
return retVal;
}
/*
* 功能描述： 获取指定ID屏蔽门IBP按下起始周期号
* 参数说明： const UINT16 doorId，屏蔽门ID
* 返回值 ： 0: 获取数据失败
* >0: 起始周期号
*/
UINT32 GetIBPPressCycNum(const UINT16 doorId)
{
UINT16 bufIndex = 0u; /*数组下标*/
UINT32 retVal = CI_ERROR;
bufIndex = GetPsdConfigBufIndex(doorId); /*获取屏蔽门数组下标*/
if (bufIndex < PSD_SUM_MAX)
{
retVal = PsdDataStru[bufIndex].IBPPressCycNum;
}
else
{
retVal = CI_ERROR;
}
return retVal;
}
TSCP/src/APP/ciapp/PSD/PSDDataManage.h
+177
View File
@@ -22,6 +22,7 @@
#include "CommonTypes.h"
#include "../System/CiSystemDefine.h"
#include "../Relay/RelayConfigDataManage.h"
#include "CiInterfaceDefine.h"
#ifdef __cplusplus
extern "C" {
@@ -58,6 +59,7 @@ typedef struct S_PsdDataStruct
UINT32 StartDetectionCycNum; /*开启探测周期*/
UINT8 StartDetectionState; /*启动探测状态*/
UINT8 StopDetectionState; /*停止探测状态*/
UINT32 StopDetectionCycNum; /*停止探测周期*/
UINT8 VOBCDoorState; /*VOBC车门状态*/
UINT32 PCBPressCycNum; /*PCB按下起始周期*/
UINT32 POBPressCycNum; /*POB按下起始周期*/
@@ -91,9 +93,25 @@ typedef struct S_PsdDataStruct
UINT8 psdCloseErrState; /*关门故障状态*/
UINT8 cPsdExceptOpenState; /*屏蔽门异常打开状态：0x55-异常打开，0xAA-未异常打开*/
UINT32 dwPsdRelayDownCycNum; /*PSD门关继电器落下起始周期*/
UINT8 JXTCMutualLockFaultState; /*间隙探测互锁解除按钮故障状态 (动态字段)*/
UINT32 JXTCMutualLockStartCycNum; /*间隙探测互锁解除起始时间*/
UINT8 ibpButtonState; /*IBP盘发车按钮状态(动态字段)*/
UINT32 IBPPressCycNum; /*IBP按下起始周期*/
} PsdDataStruct;
/*屏蔽门数据结构体*/
typedef struct S_PsdDataStructCC
{
UINT16 PsdId; /*屏蔽门ID (初始化字段)*/
UINT16 psdEditGroupInfo; /*屏蔽门编组信息CC(0-默认值，3-三编组，4-四编组，6-六编组，8-八编组)*/
UINT16 SrcVobcId; /*操作该屏蔽门的当前VOBC编号CC*/
UINT8 PsdCmd; /*操作屏蔽门的命令CC(0x00-默认值，0x55-打开PSD命令，0xAA-关闭PSD命令，0xFF-查询PSD命令)*/
UINT32 CmdSetCycle;/*命令设置周期CC*/
} PsdDataStructCC;
extern PsdDataStruct PsdDataStru[PSD_SUM_MAX]; /*定义屏蔽门数据结构体*/
extern PsdDataStructCC PsdDataStruCC[PSD_SUM_MAX]; /*定义车车屏蔽门数据结构体*/
/*
* 功能描述： 设置PSD的VOBC操作命令
@@ -169,6 +187,13 @@ void ResetPsdData(const UINT16 psdId);
*/
PsdDataStruct *GetPsdData(void);
/*
* 功能描述：获取指定ID屏蔽门数据CC
* 参数说明：无
* 返 回 值：车车屏蔽门动态数据
*/
PsdDataStructCC* GetPsdDataCC(void);
/*
* 功能描述： 获取指定ID屏蔽门互锁解除状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
@@ -387,6 +412,23 @@ void SetStopDetectionState(const UINT16 doorId, const UINT32 detectionState);
*/
UINT8 GetStopDetectionState(const UINT16 doorId);
/*
* 功能描述：设置指定PSD停止探测周期号
* 参数说明： const UINT16 doorId, 屏蔽门ID
* const UINT32 startCycNum, 起始周期号
* 返回值 ： 无
*
*/
void SetStopDetectionCycNum(const UINT16 doorId, const UINT32 startCycNum);
/*
* 功能描述： 获取停止探测起始周期号
* 参数说明： const UINT16 doorId, 进路ID
* 返回值 ： 0: 获取数据失败
* >0: 起始周期号
*/
UINT32 GetStopDetectionCycNum(const UINT16 doorId);
/*
* 功能描述： 获取指定ID屏蔽门开门按钮状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
@@ -1002,6 +1044,141 @@ UINT32 GetPsdRelayDownCycNum(const UINT16 doorId);
*/
void SetPsdRelayDownCycNum(const UINT16 doorId, const UINT32 startCycNum);
/*
* 功能描述：获取指定ID屏蔽门编组信息CC
* 参数说明：const UINT16 doorId, 屏蔽门ID
* 返 回 值：0 无编组信息
* 3 三编组
* 4 四编组
* 6 六编组
* 8 八编组
* Created By LQ 2025.11.05
*/
UINT16 GetPsdEditGroupInfoDataCC(const UINT16 doorId);
/*
* 功能描述：设置指定ID屏蔽门编组信息CC
* 参数说明：const UINT16 doorId, 屏蔽门ID
* const UINT16 wPsdEditGroupInfo 屏蔽门编组信息
* 返 回 值：无
* Created By LQ 2025.11.05
*/
void SetPsdEditGroupInfoDataCC(const UINT16 doorId, const UINT16 wPsdEditGroupInfo);
/*
* 功能描述：获取PSD的VOBC控制命令CC
* 参数说明：const UINT16 doorId,屏蔽门ID
* 返 回 值：0x00-默认值
* 0x55-打开PSD命令
* 0xAA-关闭PSD命令
* 0xFF-查询PSD命令
* Created By LQ 2025.11.05
*/
UINT8 GetPsdVobcCmdCC(const UINT16 doorId);
/*
* 功能描述： 获取当前控制该PSD的VOBC的编号CC
* 参数说明： const UINT16 doorId,屏蔽门ID
* 返 回 值： VOBC ID
* Created By LQ 2025.11.05
*/
UINT16 GetPsdVobcIdCC(const UINT16 doorId);
/*
* 功能描述：获得该PSD的控制命令的设置周期CC
* 参数说明：const UINT16 doorId,屏蔽门ID
* 返 回 值：该PSD的控制命令的设置周期
* Created By LQ 2025.11.05
*/
UINT32 GetPsdCmdSetCycleCC(const UINT16 doorId);
/*
* 功能描述：设置PSD的VOBC操作命令CC
* 参数说明：const UINT16 doorId 屏蔽门ID
* const UINT16 vobcId 操作屏蔽门的VOBC ID
* const UINT8 operCmd 来自VOBC的开关门命令
* const UINT32 dwCycNum 周期号
* 返 回 值：无
* Created By LQ 2025.11.05
*/
void SetPsdVobcCmdCC(const UINT16 doorId, const UINT16 vobcId, const UINT8 operCmd, const UINT32 dwCycNum);
/*
* 功能描述：获取指定ID屏蔽门编组信息CC
* 参数说明：const UINT16 doorId, 屏蔽门ID
* 返 回 值：0 无编组信息
* 3 三编组
* 4 四编组
* 6 六编组
* 8 八编组
*/
UINT16 GetPsdEditGroupInfoData(const UINT16 doorId);
/*
* 功能描述：设置指定ID屏蔽门编组信息
* 参数说明：const UINT16 doorId, 屏蔽门ID
* const UINT16 wPsdEditGroupInfo 屏蔽门编组信息
* 返 回 值：无
*/
void SetPsdEditGroupInfoData(const UINT16 doorId, const UINT16 wPsdEditGroupInfo);
/*
* 功能描述：获取指定ID屏蔽门间隙探测互锁解除故障状态
* 参数说明：const UINT16 doorId, 屏蔽门ID
* 返 回 值： 0 返回失败
* 0< 间隙探测互锁解除故障状态
*/
UINT8 GetPsdJXTCMutualLockFaultState(const UINT16 doorId);
/*
* 功能描述：设置指定ID屏蔽门间隙探测互锁解除故障状态
* 参数说明：const UINT16 doorId, 屏蔽门ID
* const UINT8 wJXTCMutualLockFaultState 间隙探测互锁解除故障状态
* 返 回 值：无
*/
void SetPsdJXTCMutualLockFaultState(const UINT16 doorId, const UINT8 wJXTCMutualLockFaultState);
/*
* 功能描述：获取指定ID屏蔽门间隙探测互锁解除时间
* 参数说明：const UINT16 doorId, 屏蔽门ID
* 返 回 值： 0 返回失败
* 0< 屏蔽门间隙探测互锁解除时间
*/
UINT32 GetPsdJXTCMutualLockStartCycNum(const UINT16 doorId);
/*
* 功能描述：设置指定ID屏蔽门间隙探测互锁解除起始时间
* 参数说明：const UINT16 doorId, 屏蔽门ID
* const UINT32 cycnum 互锁解除起始时间
* 返 回 值：无
*/
void SetPsdJXTCMutualLockStartCycNum(const UINT16 doorId, const UINT32 cycnum);
/*
* 功能描述： 设置指定ID屏蔽门IBP盘发车按钮状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
* UINT8 setFlag 需设置的按钮状态
* 返回值 ： PSD_BUTTON_PANGLU_STATE_VALID 0x55 有效
* PSD_BUTTON_PANGLU_STATE_INVALID 0xaa 无效
*/
UINT8 SetPsdButtonIbpState(const UINT16 doorId, const UINT8 setFlag);
/*
* 功能描述： 获取指定ID屏蔽门IBP按下起始周期号
* 参数说明： const UINT16 doorId，屏蔽门ID
* 返回值 ： 0: 获取数据失败
* >0: 起始周期号
*/
UINT32 GetIBPPressCycNum(const UINT16 doorId);
/*
* 功能描述： 获取指定ID屏蔽门IBP盘发车按钮状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
* 返回值 ：0: 获取数据失败
* >0: IBP盘发车按钮状态
*/
UINT8 GetPsdButtonIbpState(const UINT16 doorId);
/*
* 功能描述：设置指定ID屏蔽门IBP按下起始周期号
* 参数说明： const UINT16 doorId, 屏蔽门ID
* const UINT32 startCycNum, 起始周期号
* 返回值 ： 0: 设置数据失败
* >0: 设置数据成功
*/
UINT8 SetIBPPressCycNum(const UINT16 doorId, const UINT32 startCycNum);
#ifdef __cplusplus
}
#endif
TSCP/src/APP/ciapp/PSD/PSDDefine.h
+14 -3
View File
@@ -92,9 +92,11 @@
#define PSD_SIX_EDIT_GROUP_FAO_YF ((UINT8)0x02U) /*六编组*/
/*屏蔽门编组信息定义*/
#define PSD_FOUR_EDIT_GROUP ((UINT8)0x04U) /*Ëıà×é*/
#define PSD_SIX_EDIT_GROUP ((UINT8)0x06U) /*Áù±à×é*/
#define PSD_EIGHT_EDIT_GROUP ((UINT8)0x08U) /*°Ë±à×é*/
#define PSD_EDIT_GROUP_DEFAULT ((UINT16)0x00U) /*默认值*/
#define PSD_THREE_EDIT_GROUP ((UINT16)0x03U) /*三编组*/
#define PSD_FOUR_EDIT_GROUP ((UINT16)0x04U) /*四编组*/
#define PSD_SIX_EDIT_GROUP ((UINT16)0x06U) /*六编组*/
#define PSD_EIGHT_EDIT_GROUP ((UINT16)0x08U) /*八编组*/
/*办理出来的出站进路信号关闭是否在屏蔽门打开之前的标志*/
#define PSD_OPEN_BEFORE_SIG_CLOSE_YES ((UINT8)0xaaU) /*屏蔽门打开之前信号关闭*/
@@ -133,6 +135,7 @@
#define PLATFORM_DEPAR_BUTTON_STATE_VALID ((UINT8)0x55U) /*有效*/
#define PLATFORM_DEPAR_BUTTON_STATE_INVALID ((UINT8)0xaaU) /*无效*/
#define PLATFORM_DEPAR_BUTTON_NO ((UINT8)0xccU) /*无站台发车按钮*/
#define PLATFORM_DEPAR_BUTTON_STATE_FAULT ((UINT8)0xffU) /*站台发车按钮故障（IBP）*/
/*站台按钮旁路状态*/
#define PSD_BUTTON_PANGLU_STATE_VALID ((UINT8)0x55U) /*有效*/
@@ -207,4 +210,12 @@
#define HIGH_FOUR_CHAR ((UINT8)0U) /*高四字节*/
#define LOW_FOUR_CHAR ((UINT8)1U) /*低四字节*/
/*间隙探测互锁解除故障状态*/
#define JXTC_MUTUALLOCKFAULT_YES ((UINT8)0x55U) /*间隙探测互锁解除按钮故障*/
#define JXTC_MUTUALLOCKFAULT_NO ((UINT8)0xaaU) /*间隙探测互锁解除按钮未故障*/
#define JXTC_MUTUALLOCKFAULT_NOCHECK ((UINT8)0xFFU) /*间隙探测互锁解除按钮未检测*/
#define PSD_INCLUDE_ESB_NUM ((UINT8)10U) /*ESB个数*/
#endif
TSCP/src/APP/ciapp/ParsePack/CiInterfaceDefine.h
+24 -14
View File
@@ -107,7 +107,7 @@
#define ATS_CMD_SECTION_FENGSUO_CANCEL ((UINT8)0x61) /*区段解封*/
#define ATS_CMD_PHYSEC_PRE_RESET_ONE ((UINT8)0x62) /*计轴预复位一次*/
#define ATS_CMD_PHYSEC_PRE_RESET_TWO ((UINT8)0x63) /*计轴预复位二次*/
#define ATS_CMD_CANCEL_XICHE ((UINT8)0x64) /*现地取消洗车命令*/
#define ATS_CMD_CANCEL_XICHE ((UINT8)0x64) /*取消降级模式洗车命令*/
#define ATS_CMD_PHYSEC_GENERAL_RESET_SET ((UINT8)0x65) /*计轴总复位命令*/
#define ATS_CMD_PHYSEC_GENERAL_RESET_CANCEL ((UINT8)0x66) /*取消计轴总复位命令*/
#define ATS_CMD_CICI_NET_TO_RELAY_ONE ((UINT8)0x68) /*联锁与联锁网络接口转继电接口一次命令*/
@@ -118,7 +118,6 @@
#define ATS_CMD_QUXIAO_PSC_PL_TWO ((UINT8)0x73) /*取消PSC旁路二次命令*/
#define ATS_CMD_ROUTE_GROUP_AUTO_SET ((UINT8)0x74) /*办理组合自动进路命令*/
#define ATS_CMD_ROUTE_GROUP_AUTO_CANCLE ((UINT8)0x75) /*取消组合自动进路命令*/
#define ATS_CMD_SIGNALMAINTAINSTATE_ONE ((UINT8)0x76) /*信号机维修点灯一次*/
#define ATS_CMD_SIGNALMAINTAINSTATE_TWO ((UINT8)0x77) /*信号机维修点灯二次*/
#define ATS_CMD_CANCEL_SIG_MAINTAIN_ONE ((UINT8)0x78) /*取消信号机维修点灯一次*/
@@ -127,17 +126,12 @@
#define ATS_CMD_CANCEL_SW_ALARM_TWO ((UINT8)0x7b) /*取消转辙机封连报警二次命令*/
#define ATS_CMD_RECOVER_SW_ALARM_ONE ((UINT8)0x7c) /*恢复转辙机封连报警一次命令*/
#define ATS_CMD_RECOVER_SW_ALARM_TWO ((UINT8)0x7d) /*恢复转辙机封连报警二次命令*/
#define LABOR_CMD_CANCEL_OVERLAP_ONE ((UINT8)0x7e) /* 人工取消保护区段一次命令 */
#define LABOR_CMD_CANCEL_OVERLAP_TWO ((UINT8)0x7f) /* 人工取消保护区段二次命令 */
#define LABOR_CMD_SET_UP_OVERLAP ((UINT8)0x80) /* 人工建立保护区段命令,合代码暂时改成80 */
#define ATS_CMD_ROUTE_APPLY ((UINT8)0x92) /*申请路径*/
#define ATS_CMD_ROUTE_APPLY_CANCLE ((UINT8)0x93) /*取消申请路径*/
#define ATS_CMD_ROUTE_PART_APPLY ((UINT8)0x94) /*申请部分路径*/
#define ATS_CMD_ROUTE_PART_APPLY_CANCEL ((UINT8)0x95) /*取消申请部分路径*/
#define ATS_CMD_AUTO_RETURN_SET_ONE ((UINT8)0x96) /*自动折返一次有效命令*/
#define ATS_CMD_AUTO_RETURN_CMD_CANCEL ((UINT8)0x97) /*取消自动折返命令*/
#define ATS_CMD_SET_PHYSEC_ERR ((UINT8)0x98) /*物理区段故障占用设置命令*/
#define ATS_CMD_CANCEL_PHYSEC_FIRST ((UINT8)0x99) /*物理区段故障占用取消一次命令*/
#define ATS_CMD_CANCEL_PHYSEC_SECOND ((UINT8)0x9a) /*物理区段故障占用取消二次命令*/
@@ -146,25 +140,29 @@
#define ATS_CMD_OPEN_XIANSU_SIGNAL_FIRST ((UINT8)0x9d) /*开放限速信号一次*/
#define ATS_CMD_OPEN_XIANSU_SIGNAL_SECOND ((UINT8)0x9e) /*开放限速信号二次*/
#define ATS_CMD_OPEN_XIANSU_SIGNAL_SPECIAL ((UINT8)0xa6) /*限速信号特殊开放*/
#define ATS_CMD_OC_P_PL_ONE ((UINT8)0xa8) /*设置OC-P旁路一次命令*/
#define ATS_CMD_OC_P_PL_TWO ((UINT8)0xa9) /*设置OC-P旁路二次命令*/
#define ATS_CMD_QUXIAO_OC_P_PL_ONE ((UINT8)0xaa) /*取消OC-P旁路一次命令*/
#define ATS_CMD_QUXIAO_OC_P_PL_TWO ((UINT8)0xab) /*取消OC-P旁路二次命令*/
#define ATS_CMD_GET_CTRL_POWER ((UINT8)0x81) /* 获取联锁控制权*/
#define ATS_CMD_RELEASE_CTRL_POWER ((UINT8)0x82) /* 释放联锁控制权*/
#define ATS_CMD_ROUTE_AUTO_TRIGGER_SET (UINT8)0x83 /*单个进路自动触发进路办理 */
#define ATS_CMD_ROUTE_CANCLE_AUTO_TRIGGER (UINT8)0x84 /*单个进路取消自动触发进路 */
#define ATS_CMD_SWITCH_DINGWEI_TEST_ONE ((UINT8)0x85) /* 道岔定位测试一次命令*/
#define ATS_CMD_SWITCH_DINGWEI_TEST_TWO ((UINT8)0x86) /* 道岔定位测试二次命令*/
#define ATS_CMD_SWITCH_FANWEI_TEST_ONE ((UINT8)0x87) /* 道岔反位测试一次命令*/
#define ATS_CMD_SWITCH_FANWEI_TEST_TWO ((UINT8)0x88) /*道岔反位测试二次命令*/
#define SCX_ATS_CMD_ESS_GO_POSITION (UINT8)0x89 /*ESS去位命令*/
#define SCX_ATS_CMD_ESS_STOP_POSITION (UINT8)0x90 /*ESS停位命令*/
#define ATS_CMD_STATION_QK_SET (UINT8)0x91 /*站台清客标志设置 */
#define ATS_CMD_EMERG_XS_SET_ONE (UINT8)0xAC /*设置紧急临时限速一次命令 */
#define ATS_CMD_EMERG_XS_SET_TWO (UINT8)0xAD /*设置紧急临时限速二次命令 */
#define ATS_CMD_EMERG_XS_CANCEL_ONE (UINT8)0xAE /*取消紧急临时限速一次命令 */
#define ATS_CMD_EMERG_XS_CANCEL_TWO (UINT8)0xAF /*取消紧急临时限速二次命令 */
#define ATS_CMD_COUPLING_ROUTE_SET (UINT8)0xB0 /*联挂进路办理 */
#define ATS_CMD_APPLY_XICHE ((UINT8)0xB1) /*降级模式洗车请求*/
#define ATS_CMD_APPLY_PASSXICHE ((UINT8)0xB2) /*现地请求反向洗车命令-降级模式*/
#define ATS_CMD_CANCEL_PASSXICHE ((UINT8)0xB3) /*现地取消反向洗车命令-降级模式*/
/****联锁到其他联锁的命令宏定义****/
#define CI_CMD_PHYSEC_USING_APPLY ((UINT16)0x0001) /*物理区段征用申请*/
@@ -237,7 +235,7 @@
#define CI_BACK_ROUTE_LOCK_NOTALL ((UINT8)0x06) /*进路不完整锁闭?新增?*/
#define CI_BACK_ROUTE_LEVEL_CBTC ((UINT8)0x08) /*进路监督级别不为点式?未使用?*/
#define CI_BACK_ROUTE_LEVEL_BLOC ((UINT8)0x00) /*进路监督级别不为CBTC?未使用?*/
#define CI_BACK_ROUTE_LEVEL_BLOC ((UINT8)0xBA) /*进路监督级别不为CBTC*/
#define CI_BACK_ROUTE_TYPE_ERROR ((UINT8)0x00) /*进路类型异常?未使用?*/
#define CI_BACK_ROUTE_STATE_ERROR ((UINT8)0x59) /*进路建立条件不满足*/
#define CI_BACK_RETURN_ROUTE_STATE_ERROR ((UINT8)0x5A) /*折返进路不允许追踪办理*/
@@ -249,6 +247,7 @@
#define CI_BACK_AUTO_TRIGGER_SET_ERR (UINT8)0x85 /*进路的自动触发标志设置失败*/
#define CI_BACK_LEAD_ROUTE_CANCEL ((UINT8)0xA4) /*引导进路无法使用总取消解锁反馈*/
#define CI_BACK_COUPLINK_ROUTE_IDLE ((UINT8)0xAF) /*联挂进路内无被联挂车*/
/*信号机故障反馈*/
#define CI_BACK_SIG_START_OPEN ((UINT8)0x11) /*进路始端信号机开放*/
@@ -289,6 +288,7 @@
#define CI_BACK_PSEC_RESET_IN_CT ((UINT8)0x58) /*计轴复位中CT占用*/
#define UNLOCK_OVELAP_CANNOT (UINT8)0x80 /*解锁保护区段条件不满足*/
#define LOCK_OVELAP_OUT_CANNOT (UINT8)0x81 /*保护区段锁闭条件不满足*/
#define CI_BACK_PSEC_RESET_ING ((UINT8)0xAE) /*物理区段正在计轴复位*/
/*道岔故障反馈*/
#define CI_BACK_SWT_YLOCK_YES ((UINT8)0x31) /*道岔引导总锁*/
@@ -337,6 +337,14 @@
#define CI_BACK_OTHER_ROUTE_NOT_OPEN ((UINT8)0x9D) /*进路其他联锁条件需开放进路未开放*/
#define CI_BACK_WASH_PASS_ALLOW_NOT ((UINT8)0x9E) /*洗车库/线未同意通过*/
#define CI_BACK_WASH_APPLY_NOT ((UINT8)0xB3) /*洗车机洗车请求有效，请勿重复操作*/
#define CI_BACK_WASH_PASSAPPLY_NOT ((UINT8)0xB4) /*洗车机反向通过请求有效，请勿重复操作*/
#define CI_BACK_ROUTE_IDLE_NOT ((UINT8)0xB5) /*进路未空闲，请先取消进路*/
#define CI_BACK_WASH_BUTTON_PRESS_NOT ((UINT8)0xB6) /*洗车同意按钮未按下，不需要取消*/
#define CI_BACK_WASH_PASSBUTTON_PRESS_NOT ((UINT8)0xB7) /*洗车反向通过同意按钮未按下，不需要取消*/
#define CI_BACK_WASH_APPLY_BUTTON_NOT ((UINT8)0xB8) /*洗车机XXX洗车同意按钮在规定时间内未按下，洗车请求失效*/
#define CI_BACK_WASH_PASS_BUTTON_NOT ((UINT8)0xB9) /*洗车机XXX反向同意按钮在规定时间内未按下，反向通过请求失效*/
/* 设置与取消物理区段故障列车占用反馈 */
#define CI_BACK_SPE_TRAIN_DIR_ERR ((UINT8)0x86) /*设置物理区段故障车占用：与已存在的故障车方向不一致*/
#define CI_BACK_SPE_LOOK_DIR_ERR ((UINT8)0x87) /*设置物理区段故障车占用：与物理区段锁闭方向不一致*/
@@ -448,15 +456,17 @@
#define CI_BACK_AUTO_ROUTE_HAVE_BLOCK ((UINT8)0x95) /*自动通过进路自动进路存在封锁*/
#define CI_BACK_AUTO_ROUTE_FLOOD_STATE_ERR ((UINT8)0x96) /*自动通过进路存在防淹门不满足*/
#define CI_BACK_AUTO_ROUTE_COUPROUTE_SET ((UINT8)0xB0) /*自动通过联挂进路已办理*/
#define CI_BACK_AUTO_RETURN_HAVE_BLOCK ((UINT8)0x98) /*自动折返进路存在封锁*/
#define CI_BACK_AUTO_RETURN_FLOOD_STATE_ERR ((UINT8)0x99) /*自动折返进路存在防淹门不满足*/
#define CI_BACK_AUTO_RETURN_COUPROUTE_SET ((UINT8)0xB1) /*自动折返联挂进路已办理*/
#define CI_BACK_ALLAUTO_RETURN_HAVE_BLOCK ((UINT8)0x9B) /*全自动折返进路存在封锁*/
#define CI_BACK_ALLAUTO_RETURN_FLOOD_STATE_ERR ((UINT8)0x9C) /*全自动折返进路存在防淹门不满足*/
#define CI_BACK_ALLAUTO_RETURN_COUPROUTE_SET ((UINT8)0xB2) /*全自动折返联挂进路已办理*/
#endif
TSCP/src/APP/ciapp/ParsePack/ParsePackAtsData.c
+1750 -1124
View File
File diff suppressed because it is too large Load Diff
TSCP/src/APP/ciapp/ParsePack/ParsePackAtsData.h
+116 -38
View File
@@ -69,6 +69,17 @@
#define OC_TO_ATS_SWITCH_ZZJ_NORMAL ((UINT8)0x55) /*OC给ATS的多机牵引对应道岔状态-正常*/
#define OC_TO_ATS_SWITCH_ZZJ_ALARM ((UINT8)0xAA) /*OC给ATS的多机牵引对应道岔状态-故障*/
#define ATS_CI_INTERFACE_INFOTYPE ((UINT16)0x0407U) /*ATS-联锁接口类型*/
#define RCI_ATS_INFO_TYPE_COMMON_STATE ((UINT16)0x0201U) /*RCI->ATS通用状态信息，周期发送*/
#define RCI_ATS_INFO_TYPE_STATION_STATE ((UINT16)0x0202U) /*RCI->ATS站场状态信息，间隔1周期发送*/
#define RCI_ATS_INFO_TYPE_DEVICE_STATE ((UINT16)0x0203U) /*RCI->ATS设备状态信息，间隔1周期发送*/
#define ATS_CI_INFO_TYPE_HEART_STATE ((UINT16)0x0204U) /*ATS->CI心跳状态信息，周期发送*/
#define ATS_CI_INFO_TYPE_CMD_CONTROL ((UINT16)0x0205U) /*ATS->CI命令控制信息，ATS触发发送*/
#define SHOW_2OO2_STATE_MAIN ((UINT8)0x55U) /*显示主备系状态-主系*/
#define SHOW_2OO2_STATE_BACKUP ((UINT8)0xaaU) /*显示主备系状态-备系*/
#define SHOW_2OO2_STATE_UNKNOW ((UINT8)0xFFU) /*显示主备系状态-未知*/
/*执行电插箱相关信息*/
typedef struct s_PlusBoxDataSendATS
{
@@ -91,8 +102,8 @@ typedef struct S_CommandDataStruct
UINT8 VirCIid;/*虚拟联锁ID*/
/*车车新加*/
UINT16 wTrainIdParam; /*列车ID 20220301车车新增*/
UINT8 chSectionSum; /*区段数量,命令类型为0x93,0x94代表逻辑区段数量，0x0b,0x0c代表物理区段数量*/
UINT16 wSectionData[MAX_ROUTE_IN_LT_NUM];/*区段序列，命令类型为0x93,0x94代表逻辑区段序列，0x0b,0x0c代表物理区段序列*/
UINT8 chLogicSecSum; /*逻辑区段数量 20220301车车新增*/
UINT16 wLogicSecData[MAX_ROUTE_IN_LT_NUM];/*逻辑区段序列 20220301车车新增*/
UINT8 OCid;/*OC ID*/
UINT16 OverLapRouteID; /*保护区段关联进路ID 20240319车车新增*/
@@ -106,6 +117,14 @@ typedef struct s_SwitchZzjDataSendATS
UINT8 szSwitchIncldeZzjState[MAX_OC_SWITCH_INCLUDE_ZZJ_NUM]; /*给ATS组包的道岔对应转辙机状态*/
}OcToATSSwitchZzjData;
/*最近一次收到ATS命令数据的周期号信息*/
typedef struct s_ReciveAtsCmdDataCycInfo
{
UINT8 chDeviceType; /*设备类型*/
UINT8 chDeviceId; /*设备ID*/
UINT32 dwReciveCmdDataAtsCycNum; /*收到ATS命令数据时ATS周期号*/
}ReciveAtsCmdDataCycInfo;
#ifdef __cplusplus
extern "C" {
#endif
@@ -121,26 +140,32 @@ extern CommandDataStruct CiSendBackDataTempStru[CI_TO_ATSORXIANDI_CMD_DATA_STRU_
extern UINT16 CiSendBackDataTempStruSum;
extern UINT8 LastCmdSourceSysType;
extern UINT32 FirstCmdId; /*首次操作确认的命令ID号*/
extern ReciveAtsCmdDataCycInfo szReciveAtsCmdDataCycInfo[ATS_SUM_MAX * 2U]; /*收到ATS命令数据周期号信息数组*/
extern UINT16 gReciveAtsCmdDataDeviceSum; /*收到ATS命令数据设备数目*/
/*
* 功能描述： 解析操作命令数据帧
* 参数说明： const UINT8* dataBuf, 数据缓冲区
* const UINT16 dataLength, 数据长度
* const UINT8 chDevType 设备类型
* const UINT8 chDeciveId 设备ID
* 返回值 ： 0: 数据解析失败
* 1: 数据解析成功
* edit by cgh 20251104
*/
UINT8 ParseAtsOrXianDiToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength);
UINT8 ParseAtsOrXianDiToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength, const UINT8 chDevType, const UINT8 chDeciveId);
/*
* 功能描述： 组ATS或现地数据
* 参数说明：
* 参数说明： QueueStruct* ciToAtsDataQueue, 组包发送队列地址
* const UINT8 deviceId, 目标系统ID
* const UINT8 targetDevType, 目标系统类型
* const UINT8 frame,帧类型
* UINT8* chSendXiandiorAtsBuf 码位数据数组首地址
* 返回值 ： 0: 组包失败
* 1: 组包成功
*/
UINT8 PackCiToAtsOrXianDiData( const UINT8 deviceId, const UINT8 targetDevType,const UINT8 frame);
UINT8 PackCiToAtsOrXianDiData(const UINT8 deviceId, const UINT8 targetDevType, const UINT8 frame, UINT8* chSendXiandiorAtsBuf);
/*
* 功能描述： 获取CI接收的操作命令结构体数组长度
@@ -409,48 +434,101 @@ UINT8 GetOcPscConfirmFlag(UINT8 index);
void PackCiDataToAts(UINT8* ciToXianDiDataBuffer, UINT16* ii);
/*
* 功能描述：检查批量计轴复位命令
* 参数说明：UINT8 virCIid 输入虚拟联锁ID
* UINT8 orderType 命令类型
* const UINT8 cPhySecSum 物理区段数量
* const UINT16 pPhySecIdBuff[] 物理区段ID数组
* 功能描述：向ATS组相邻RC/CI的通信状态（双系统使用）
* 参数说明：UINT8* ciToXianDiDataBuffer 存放信息的buffer（出参）
* UINT16* ii 偏移量（出参）
* 返 回 值：无
* Created By yx 2026.04.14
* Created By LQ 2026.01.05
*/
UINT8 CheckAxisResetCmd(UINT8 virCIid, UINT8 cmdType, const UINT8 cPhySecSum, const UINT16 pPhySecIdBuff[]);
void PackNearRciCommStateToAts(UINT8* ciToXianDiDataBuffer, UINT16* ii);
/*
* 功能描述： 针对批量计轴复位一次二次命令的反馈
* 参数说明： const UINT32 commandId, 命令ID
* const UINT16 deviceId, 设备ID
* const UINT8 deviceType, 设备类型
* const UINT16 termial_id,终端ID
* const UINT8 order_type，命令类型
* const UINT8 response_type, 回复类型
* const UINT8 affirm_result, 确认结果
* const UINT8 virCIid, 虚拟联锁ID
* const UINT8 cPhySecSum 物理区段数量
* const UINT16 pPhySecIdBuff[] 物理区段ID数组
* 功能描述：向ATS组通信表示灯（双系统使用）
* 参数说明：UINT8* ciToXianDiDataBuffer 存放信息的buffer（出参）
* UINT16* ii 偏移量（出参）
* 返 回 值：无
* Created By yx 2026.04.14
* Created By LQ 2026.01.05
*/
void SetAixsResetCiSendCmdBackData(const UINT32 commandId, const UINT16 deviceId, const UINT8 deviceType, const UINT16 termial_id, const UINT8 order_type, const UINT8 response_type, const UINT8 affirm_result, const UINT8 virCIid, const UINT8 cPhySecSum, const UINT16 pPhySecIdBuff[]);
void PackCommIndicatorToAts(UINT8* ciToXianDiDataBuffer, UINT16* ii);
/*
* 功能描述： 批量计轴复位二次命令有效性检查
* 参数说明： const UINT32 commandId, 命令ID
* const UINT16 deviceId, 设备ID
* const UINT8 deviceType, 设备类型
* const UINT16 termial_id,终端ID
* const UINT8 order_type，命令类型
* const UINT8 virCIid, 虚拟联锁ID
* const UINT8 cPhySecSum 物理区段数量
* const UINT16 pPhySecIdBuff[] 物理区段ID数组
* 返回值 ：CI_ERROR : 失败
* CI_SUCCESS: 成功
* Created By yx 2026.04.14
* 功能描述：检查指定类型表示灯是否需要向ATS组包（双系统使用）
* 参数说明：UINT8 cIndicatorType 表示灯类型
* 返 回 值：0 不需要组包
* 1 需要组包
* Created By LQ 2026.01.05
*/
UINT8 CheckAxisResetSndOrderValid(const UINT32 commandId, const UINT16 deviceId, const UINT8 deviceType, const UINT16 termial_id, const UINT8 order_type, const UINT8 virCiID, const UINT8 cPhySecSum, const UINT16 pPhySecIdBuff[]);
UINT8 AtsIndicatorPackCheck(UINT8 cIndicatorType);
/**
* @brief RC/CI设备通用状态处理
* @param[in] UINT8* ciToXianDiDataBuffer CI组包给ATS或现地的数据数组
* @param[in] UINT16* ii CI组包给ATS或现地的数据索引
* @return 无
* @note by cgh 20251103
*/
void RcOrCiDeciveCommonStateDeal(UINT8* ciToXianDiDataBuffer, UINT16* ii);
/**
* @brief 发送ATS通用设备状态处理
* @param[in] UINT8* ciToXianDiDataBuffer CI组包给ATS或现地的数据数组
* @param[in] UINT16* wDataIndex CI组包给ATS或现地的数据索引
* @param[in] const UINT8 chDeviceId, 目标系统ID
* @param[in] const UINT8 chTargetDevType, 目标系统类型
* @return 无
* @note by cgh 20251103
*/
void SendAtsCommonDeviceStateDeal(UINT8* ciToXianDiDataBuffer, UINT16* wDataIndex, const UINT8 chDeviceId, const UINT8 chTargetDevType);
/**
* @brief 发送ATS通用站场状态处理
* @param[in] UINT8* ciToXianDiDataBuffer CI组包给ATS或现地的数据数组
* @param[in] UINT16* wDataIndex CI组包给ATS或现地的数据索引
* @param[in] const UINT8 chDeviceId, 目标系统ID
* @param[in] const UINT8 chTargetDevType, 目标系统类型
* @param[in] UINT8* chSendXiandiorAtsBuf 码位数据数组首地址
* @return 无
* @note by cgh 20251103
*/
void SendAtsCommonStationStateDeal(UINT8* ciToXianDiDataBuffer, UINT16* wDataIndex, const UINT8 chDeviceId, const UINT8 chTargetDevType, UINT8* chSendXiandiorAtsBuf);
/**
* @brief 收到ATS命令处理
* @param[in] const UINT8* dataBuf, 数据缓冲区
* @param[in] UINT16* dataIndex, 数据索引
* @param[in] const UINT16 dataLength, 数据长度
* @return CI_ERROR 失败 CI_SUCCESS 成功
* @note by cgh 20251104
*/
UINT8 ReciveAtsCmdDeal(const UINT8* dataBuf, UINT16* dataIndex, const UINT16 wDataLength);
/**
* @brief 更新ATS命令数据周期号信息
* @param[in] UINT8 chDeviceType 设备类型
* @param[in] UINT8 chDeviceId 设备ID
* @return 无
* @note by cgh 20251105
*/
void UpdateAtsCmdDataCycInfo(UINT8 chDeviceType, UINT8 chDeviceId);
/**
* @brief 获取收到ATS命令数据时ATS周期号
* @param[in] UINT8 chDeviceType 设备类型
* @param[in] UINT8 chDeviceId 设备ID
* @return UINT32 收到ATS命令数据时ATS周期号
* @note by cgh 20251105
*/
UINT32 GetReciveCmdDataAtsCycNum(UINT8 chDeviceType, UINT8 chDeviceId);
/**
* @brief 组包RC/CI设备通用状态信息
* @param[in] UINT8* ciToXianDiDataBuffer CI组包给ATS或现地的数据数组
* @param[in] UINT16* ii CI组包给ATS或现地的数据索引
* @return 无
* @note by cgh 20251111
*/
void PackRcOrCiDeciveCommonState(UINT8* ciToXianDiDataBuffer, UINT16* ii);
#ifdef __cplusplus
}
#endif
TSCP/src/APP/ciapp/ParsePack/ParsePackAxleData.c
+252 -23
View File
@@ -124,7 +124,7 @@ UINT8 InitAxleToCiDataStru(void)
UINT8 deviceSum = 0u; /*设备总数*/
UINT8* deviceIdBuf = NULL; /*设备ID数组*/
UINT8 i = 0u; /*用于循环*/
UINT8 j = 0u; /*用于循环*/
UINT16 j = 0u; /*用于循环*/
UINT8 ciId = 0u; /*本CI ID*/
UINT8 axleId = 0u; /*计轴ID*/
UINT16 axleName = 0u; /*计轴设备名称：类型+ID*/
@@ -137,14 +137,18 @@ UINT8 InitAxleToCiDataStru(void)
UINT8 belongAxleSysId = 0u; /*物理区段所属计轴ID*/
UINT16 axlePhySecSum = 0u; /*计轴系统包含物理区段数目*/
UINT8 pyhIsThisLine = 0u;
UINT8 chAxisLogId = 0U;
ciId = GetSystemParaLocalCiId();
ciName = (CI_SYSTEM_TYPE_CI) * 256U + ciId;
ciName = (CI_SYSTEM_TYPE_RCI) * 256U + ciId;
rtn = DsuRsspInitWl((const)DataPath, 0, NULL, ciName, 0, &dsuRsspInfo);
if (CI_SUCCESS == rtn)
{
deviceSum = GetCiTransmitSpecifySysDevSum(CI_SYSTEM_TYPE_AXIS); /*获取通信Axis设备总数*/
deviceIdBuf = GetCiTransmitSpecifySysDevBuf(CI_SYSTEM_TYPE_AXIS); /*获取通信Axis设备ID数组*/
chAxisLogId = GetAxisLogId();
if ((deviceSum > 0u) && (deviceIdBuf != NULL))
{
phySecCurSum = GetPhySecCurSum();
@@ -153,21 +157,26 @@ UINT8 InitAxleToCiDataStru(void)
axleId = deviceIdBuf[i];
axleName = (CI_SYSTEM_TYPE_AXIS) * 256u + axleId;
rtn = dquDevName2HlhtId(axleName, 0U, &axieEtcsId); /*获取计轴互联互通ID*/
rtn &= dquDevName2HlhtId(ciName, 0U, &ciEtcsId); /*获取CI互联互通ID*/
rtn = dquDevName2HlhtId(axleName, chAxisLogId, &axieEtcsId); /*获取计轴互联互通ID*/
rtn &= dquDevName2HlhtId(ciName, 0U, &ciEtcsId); /*获取联锁互联互通ID*/
if (CI_SUCCESS == rtn) /*GAL层互联互通ID获取成功*/
{
if (axleId >= AXIS_TO_CI_SUM_MAX)
if ((UINT16)axleId >= AXIS_TO_CI_SUM_MAX)
{
rtn = CI_ERROR;
break;/*防护代码，防止越界*/
}
else
{
axisToCiDataStru[axleId].deviceType = CI_SYSTEM_TYPE_AXIS;
axisToCiDataStru[axleId].axisSystemId = deviceIdBuf[i];
axisToCiDataStru[axleId].axisEtcsId = axieEtcsId;
axisToCiDataStru[axleId].ciEtcsId = ciEtcsId;
(void)memset(axisToCiDataStru[axleId].PhySecIdx, (INT)AXISDATASTR_IDX, PHYSICAL_SECTION_SUM_MAX); /*默认设置下标为无效位置*/
(void)CommonMemSet((void*)&axisToCiDataStru[axleId].PhySecIdx, (UINT32)sizeof(UINT8) * PHYSICAL_SECTION_SUM_MAX, AXISDATASTR_IDX, (UINT32)sizeof(UINT8) * PHYSICAL_SECTION_SUM_MAX);
for (j = 0u; j < phySecCurSum; j++) /*遍历物理区段*/
{
phySecId = GetPhySecId(j);
@@ -190,8 +199,10 @@ UINT8 InitAxleToCiDataStru(void)
axisToCiDataStru[axleId].axisDataStr[axlePhySecSum].chDirectResetRst = RELAY_STATE_DOWN;
axisToCiDataStru[axleId].axisDataStr[axlePhySecSum].chDirectResetBack = RELAY_STATE_UP;
axisToCiDataStru[axleId].axisDataStr[axlePhySecSum].State = RELAY_STATE_DOWN;
axisToCiDataStru[axleId].axisDataStr[axlePhySecSum].chResetCmdTagBack = 0U;
axisToCiDataStru[axleId].PhySecIdx[phySecId] = (UINT8)(axlePhySecSum);
axisToCiDataStru[axleId].dwLastRecvDataCycNum = 0U;
axisToCiDataStru[axleId].SectionSum++;
}
@@ -201,18 +212,37 @@ UINT8 InitAxleToCiDataStru(void)
break;
}
}
else
{
; /*不处理*/
}
}
}
}
else
{
rtn = CI_SUCCESS;
}
;
}
if (CI_ERROR == rtn)
{
debug_infor_printf((const)"InitAxleToCiDataStru fail.\r\n");
debug_infor_printf((const)"InitAxleToCiDataStru fail,dquDevName2HlhtId error\r\n");
break;
}
else
{
; /*继续初始化*/
}
}
}
else
{
;
}
}
else
{
debug_infor_printf((const)"InitAxleToCiDataStru fail,DsuRsspInitWl error\r\n");
}
return rtn;
@@ -251,6 +281,9 @@ UINT8 ParseAxisToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength, cons
UINT16 axisDevName = 0U; /*计轴名称：类型+ID*/
UINT16 wPhySecCurSum = 0U; /*本控区物理区段数目*/
UINT16 wIndexInAxle = 0U; /*物理区段的索引号*/
UINT8 chResetCmdTag = 0U; /*复位命令标签反馈*/
UINT8 chCurSystemAreaState = 0U; /*当前系统区域状态*/
UINT32 dwSystemUpdateMainUseCycNum = 0U; /*系统主用起始周期号*/
deviceSum = GetCiTransmitSpecifySysDevSum(CI_SYSTEM_TYPE_AXIS); /*获取通信Axis设备总数*/
deviceIdBuf = GetCiTransmitSpecifySysDevBuf(CI_SYSTEM_TYPE_AXIS); /*获取通信Axis设备ID数组*/
@@ -309,7 +342,7 @@ UINT8 ParseAxisToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength, cons
galPrtclVer = GetCiAndAxisPrtclCheckVer(); /*获取联锁与计轴系统协议版本号*/
galAxisDataVer = GetCiTranAxisDataCheckVer(localCiId, axisDevName); /*获取计轴系统数据版本号*/
headRet = GalHeadCheck(axisToCiDataStru[systemId].axisEtcsId, axisToCiDataStru[systemId].ciEtcsId, GAL_INTERFACE, galPrtclVer, galAxisDataVer, &hlhtGalHead, &errCode);
debug_infor_printf((const)"\nAXLE %d GAL Check Result:%d errCode:%d", systemId, headRet, errCode); /*0x55正确，0xaa错误，0x33初始通信帧*/
debug_infor_printf((const)"\nAXLE %d GAL Check Result:%d errCode:%d\n", systemId, headRet, errCode); /*0x55正确，0xaa错误，0x33初始通信帧*/
if (HLHT_HEAD_SUCCESS == headRet)
{
@@ -605,6 +638,101 @@ UINT8 ParseAxisToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength, cons
debug_infor_printf((const)"\nAxis phySecNum:%d ERROR,RC wPhySecCurSum::%d\n", phySecNum, wPhySecCurSum);
}
}
else if (AXIS_TYPE_STANDARD_INTERFACE == acFty)
{
if (0XAAU == dataBuf[ii])
{
ii++; /*包类型*/
phySecNum = ShortFromChar(&dataBuf[ii]); /*获取计轴区段数量*/
ii += 2U;;
wPhySecCurSum = axisToCiDataStru[systemId].SectionSum;
if ((AXIS_TO_CI_SECTION_SUM_MAX > phySecNum) && (wPhySecCurSum == phySecNum))
{
for (jj = 0u; jj < phySecNum; jj++)
{
wIndexInAxle += 1U;
retVal = GetInAxlePhySecIdx(systemId, wIndexInAxle, &axisDataStrIdx);
if (CI_SUCCESS == retVal)
{
if (0x02U == (dataBuf[ii] & 0x03U))
{
/*10B:区段空闲*/
axisToCiDataStru[systemId].axisDataStr[axisDataStrIdx].gdRelayState = RELAY_STATE_UP;
}
else
{ /*01B:区段占用 11B:异常占用 00B:未知*/
axisToCiDataStru[systemId].axisDataStr[axisDataStrIdx].gdRelayState = RELAY_STATE_DOWN;
}
}
else
{
;
}
if (CI_SUCCESS == retVal)
{
if (0x01U == ((dataBuf[ii] >> 2U) & 0x03U))
{
/*计轴预复位成功*/
axisToCiDataStru[systemId].axisDataStr[axisDataStrIdx].PreResetRst = RELAY_STATE_UP;
}
else
{
/*计轴预复位未执行或者执行未成功*/
axisToCiDataStru[systemId].axisDataStr[axisDataStrIdx].PreResetRst = RELAY_STATE_DOWN;
}
}
else
{
;
}
if (CI_SUCCESS == retVal)
{
chResetCmdTag = (dataBuf[ii] >> 4U);
if (PHY_SEC_RESET_CMD_FLAG_SUM_MAX >= chResetCmdTag)
{
/*计轴预复位成功*/
axisToCiDataStru[systemId].axisDataStr[axisDataStrIdx].chResetCmdTagBack = chResetCmdTag;
}
else
{
retVal = CI_ERROR;
debug_infor_printf((const)"\nAxis chResetCmdTag:%d ERROR\n", chResetCmdTag);
}
ii++;
}
else
{
;
}
if (CI_SUCCESS != retVal)
{
retVal = CI_ERROR;
break; /*解析失败，停止解析，返回失败*/
}
else
{
/*继续解析*/
}
}
}
else
{
retVal = CI_ERROR;
debug_infor_printf((const)"\nAxis phySecNum:%d ERROR,RC wPhySecCurSum::%d\n", phySecNum, wPhySecCurSum);
}
}
else
{
retVal = CI_ERROR;
debug_infor_printf((const)"\nAxis PackageType:%d ERROR\n", dataBuf[ii]);
}
}
else
{
retVal = CI_ERROR;
@@ -613,7 +741,7 @@ UINT8 ParseAxisToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength, cons
else /*无效*/
{
retVal = CI_ERROR;
debug_infor_printf((const)"\naxleSys gal check err.axleSysId=%d,remainValidiy=%d,curCycle=%d,RSN=%d,TSN=%d,LTSN=%d", systemId, remainValidiy, curCycleNo, hlhtGalHead.recvOppMsgSN, hlhtGalHead.crntOwnMsgSN, hlhtGalHead.preOwnMsgSN);
debug_infor_printf((const)"\naxleSys gal check err.axleSysId=%d,remainValidiy=%d,curCycle=%d,RSN=%d,TSN=%d,LTSN=%d\n", systemId, remainValidiy, curCycleNo, hlhtGalHead.recvOppMsgSN, hlhtGalHead.crntOwnMsgSN, hlhtGalHead.preOwnMsgSN);
}
if (CI_SUCCESS == retVal)
@@ -624,6 +752,21 @@ UINT8 ParseAxisToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength, cons
SetHLHTHeadCtxSrcOppSN(CI_SYSTEM_TYPE_AXIS, systemId, hlhtGalHead.recvOppMsgSN);
SetHLHTHeadCtxSrcOwnSN(CI_SYSTEM_TYPE_AXIS, systemId, hlhtGalHead.preOwnMsgSN);
SetHLHTHeadCtxCiRcvSN(CI_SYSTEM_TYPE_AXIS, systemId, curCycleNo);
chCurSystemAreaState = GetLocalCiBackUpPattern();
dwSystemUpdateMainUseCycNum = GetSystemUpdateMainUseCycNum();
/*通用报文头校验合法*/
if ((SYSTEM_WORK_MODE_MAIN != chCurSystemAreaState)
|| ((SYSTEM_WORK_MODE_MAIN == chCurSystemAreaState) && (hlhtGalHead.recvOppMsgSN < dwSystemUpdateMainUseCycNum)))
{
/*当前备用或主用但还未回复主用时发给计轴的数据，只存储通用报文头，不更新收到*/
debug_infor_printf((const)"\nnot deal axleSysId=%d data,because chCurSystemAreaState %d or hlhtGalHead.recvOppMsgSN %d < dwSystemUpdateMainUseCycNum,\n", systemId, chCurSystemAreaState, hlhtGalHead.recvOppMsgSN);
}
else
{
axisToCiDataStru[systemId].dwLastRecvDataCycNum = curCycleNo;
}
}
}
else if (HLHT_HEAD_INIT == headRet)
@@ -686,17 +829,6 @@ UINT8 ParseAxisToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength, cons
return retVal;
}
/*
* 功能描述： 获取计轴采集数据结构体数组
* 参数说明： void
* 返回值 ： NULL: 获取失败
* !NULL: 采集板结构体数组指针
*/
AxisToCiDataStruct* GetCollAxisDataStruct(void)
{
return axisToCiDataStru;
}
/*
* 功能描述： 清除Axis数据
* 参数说明： void
@@ -755,6 +887,9 @@ UINT8 PackCiToAxisData(UINT8 axisSysId)
UINT8 chOffset = 0U;/*偏移量*/
UINT8 chSecResetBackState = 0U;/*区段复位状态*/
UINT16 wIndexInAxle = 0U; /*物理区段的索引号*/
UINT8 chResetCmdTagBack = 0U; /*命令标签反馈*/
UINT8 chResetCmdTag = 0U; /*命令标签*/
UINT8 chAxisLogId = 0U; /*逻辑ID*/
axisDevName = (CI_SYSTEM_TYPE_AXIS) * 256U + axisSysId;
if (AXIS_TO_CI_SUM_MAX > axisSysId)
@@ -1054,6 +1189,65 @@ UINT8 PackCiToAxisData(UINT8 axisSysId)
; /*不继续组包*/
}
}
else if (AXIS_TYPE_STANDARD_INTERFACE == acFty)
{
CiToAxisDataBuffer[ii] = 0X55U;
ii++;
phyCount = axisToCiDataStru[axisSysId].SectionSum;
ShortToChar(phyCount, &CiToAxisDataBuffer[ii]);
ii += 2U;
for (jj = 0U; jj < phyCount; jj++)
{
wIndexInAxle += 1U;
phySecId = GetPhyIdByIndexInAxle(axisSysId, wIndexInAxle); /*区段ID*/
fwCycle = GetPhySecResetStartCycNum(phySecId);
chResetCmdTagBack = GetPhySecResetCmdTagBack(phySecId);
chResetCmdTag = GetPhySecResetCmdTag(phySecId);
if (0U < fwCycle)
{
if (chResetCmdTagBack == chResetCmdTag)
{
CiToAxisDataBuffer[ii] = CiToAxisDataBuffer[ii] | (0X00U);
}
else
{
resetType = GetPhySecSectionResetType(phySecId);
if (PHYSICAL_SECTION_PRE_RESET_NO == resetType)
{
CiToAxisDataBuffer[ii] = CiToAxisDataBuffer[ii] | (0X0AU);
}
else if (PHYSICAL_SECTION_PRE_RESET_YES == resetType)
{
CiToAxisDataBuffer[ii] = CiToAxisDataBuffer[ii] | (0X05U);
}
else
{
retVal = CI_ERROR;
}
}
}
else
{
/*不发送*/
CiToAxisDataBuffer[ii] = CiToAxisDataBuffer[ii] | (0X00U);
}
CiToAxisDataBuffer[ii] = CiToAxisDataBuffer[ii] | ((UINT8)(chResetCmdTag << 4U));
ii++;
if (CI_ERROR == retVal)
{
break;
}
else
{
; /*继续*/
}
}
}
else
{
retVal = CI_ERROR;
@@ -1081,7 +1275,8 @@ UINT8 PackCiToAxisData(UINT8 axisSysId)
if (CI_SUCCESS == retVal)/*如果之前的操作是成功的*/
{
dstDevId = (((UINT16)(CI_SYSTEM_TYPE_AXIS << 8u)) | ((UINT16)axisSysId));
outnetSafeSendRtn = OutnetSafeSend(dstDevId, 1U, &CiToAxisDataBuffer[0], ii);
chAxisLogId = GetAxisLogId();
outnetSafeSendRtn = OutnetSafeSend(dstDevId, chAxisLogId, &CiToAxisDataBuffer[0], ii);
if (1u == outnetSafeSendRtn)
{ /*写队列成功*/
#ifdef LOGPRINT/*日志打印宏*/
@@ -1305,3 +1500,37 @@ UINT8 GetInAxlePhySecIdx(const UINT8 chAxleId, const UINT16 wIndexInAxle, UINT8*
return ret;
}
/*
* 功能描述： 获取计轴系统逻辑ID
* 参数说明：
* 返回值 ：计轴系统逻辑ID
* by cgh 20250903
*/
UINT8 GetAxisLogId(void)
{
UINT8 rtn = CI_ERROR; /*返回值*/
UINT8 chSystemWorkMode = 0U; /*系统工作模式*/
UINT8 chSystemWorkType = 0U; /*系统工作类型*/
chSystemWorkMode = GetLocalRcWorkMode();
chSystemWorkType = GetSystemWorkType();
if (SYSTEM_WORK_MODE_ALL == chSystemWorkType)
{
if (RC_WORK_MODE_CI == chSystemWorkMode)
{
rtn = 1U;
}
else
{
rtn = 2U;
}
}
else
{
rtn = 1U;
}
return rtn;
}
TSCP/src/APP/ciapp/ParsePack/ParsePackAxleData.h
+10 -9
View File
@@ -56,7 +56,7 @@ typedef struct S_AxisDataStruct
UINT8 chDirectResetRst; /*直接复位结果*/
UINT8 chDirectResetBack; /*直接复位命令反馈*/
UINT8 State; /*状态*/
UINT8 chResetCmdTagBack; /*复位命令标签反馈*/
} AxisCollDataStruct;
typedef struct S_AxisToCiDataStruct
@@ -68,6 +68,7 @@ typedef struct S_AxisToCiDataStruct
UINT8 SectionSum; /*区段数量: 动态字段*/
UINT8 PhySecIdx[PHYSICAL_SECTION_SUM_MAX]; /*物理区段在计轴区段信息结构体数组中位置数组*/
AxisCollDataStruct axisDataStr[CI_INCLUDE_AXIS_MAX_SUM]; /*计轴区段信息结构体数组*/
UINT32 dwLastRecvDataCycNum; /*最后收到数据周期号*/
}AxisToCiDataStruct;
@@ -88,14 +89,6 @@ extern "C" {
*/
UINT8 ParseAxisToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength, const UINT8 systemId);
/*
* 功能描述： 获取计轴采集数据结构体数组
* 参数说明： void
* 返回值 ： NULL: 获取失败
* !NULL: 采集板结构体数组指针
*/
AxisToCiDataStruct* GetCollAxisDataStruct(void);
#if 0
/*
* 功能描述： 解析处理计轴通信采集数据
@@ -140,6 +133,14 @@ UINT8 InitAxleToCiDataStru(void);
*/
UINT8 GetInAxlePhySecIdx(const UINT8 chAxleId, const UINT16 wIndexInAxle, UINT8* pAxleDataStrIdx);
/*
* 功能描述： 获取计轴系统逻辑ID
* 参数说明：
* 返回值 ：计轴系统逻辑ID
* by cgh 20250903
*/
UINT8 GetAxisLogId(void);
#ifdef __cplusplus
}
TSCP/src/APP/ciapp/ParsePack/ParsePackCiData.c
+7873 -2439
View File
File diff suppressed because it is too large Load Diff

Some files were not shown because too many files have changed in this diff Show More