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

Compare commits

base: lih/TSCP:bdc50a96a33921ca0e58992c6f3e8a6f68bba1bb
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.6
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

2 Commits
bdc50a96a3 .. 9.6

Author SHA1 Message Date
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
233 changed files with 45230 additions and 17157 deletions
Expand all files Collapse all files
TSCP/src/APP/APP_API.c
+220 -38
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,20 @@ 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, /**< 区域状态开关配置 */
.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, /**< 暗文日志记录发送端口 */
/*通用端口配置*/
@@ -324,20 +361,161 @@ void APP_API_Data_Init()
.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.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.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.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.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;
}
else
{
/*设置CI IP+区域IP*/
AppCfgInterface.M_Area_Enable = 0x55u;
}
}
MSCP_Set_APP_ConfigData(&AppCfgInterface);
#endif
/*组FS版本号*/
@@ -360,6 +538,7 @@ void APP_API_Data_Init()
MSCP_SetAppVersion(appVersBuffer);
MSCP_SetFsVersion(fsVersBuffer);
}
}
/**
* @brief 应用周期主逻辑
* @return ENUM_CM_RETURN 函数执行结果
@@ -396,6 +575,9 @@ ENUM_CM_RETURN APP_API_MainFunc(void)
gFollowDataLen = GetCiAppData(gFollowData);
MSCP_SetFollowData(gFollowData, gFollowDataLen);
gCiRcFollowDataLen = GetCiGeneralData(gCiRcFollowData);
MSCP_CISendAppData(gCiRcFollowData, gCiRcFollowDataLen);
return retVal;
}
@@ -536,7 +718,7 @@ ENUM_CM_RECCUSEB Is_Send_ExtendBoard(IN const CM_UINT16 dstDevTypeId)
chDstCiType = GetCiType(devId);
chCldScxCommMode = GetCiFunctionSwitchConfig(SCX_CLD_INTERFACE_TYPE);
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)))
{
@@ -761,7 +943,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 101 /*集成次数编号*/
#define VER_INTE_TIME 105 /*集成次数编号*/
#endif/*endif of #define _CI_INTEGRATE_CONFIG_H*/
TSCP/src/APP/ciapp/2oo2/2oo2DataTransferManage.c
+3235 -471
View File
File diff suppressed because it is too large Load Diff
TSCP/src/APP/ciapp/2oo2/2oo2DataTransferManage.h
+274
View File
@@ -188,6 +188,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/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/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/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/CutoffPoint/CutoffPointDataManage.c
+1 -1
View File
@@ -1629,7 +1629,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 = GetCiTransmitState(CI_SYSTEM_TYPE_RCI, chLinkTiocId);
if ((TRANSMIT_STATE_GOOD != chTransmitStat) || (UINT16_MAX == strCfpInfo.wTrainId))
{
;/*通信不良好，或者分界点列车信息获取失败*/
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
+258 -1
View File
@@ -46,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：默认值*/
@@ -86,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*/
@@ -1262,10 +1268,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
{
;
@@ -1700,6 +1714,7 @@ void DriveSignalOpen(const UINT16 signalId, const UINT16 routeId)
UINT8 sigalMaintainState = 0u;
UINT8 signalIsfushiFlag = 0u;
UINT8 signalCurDriveColor = 0u;
UINT8 chRoutelightFlag = 0U;
routeLevel = GetRouteLevel(routeId); /*获取进路级别*/
if(ROUTE_LEVEL_BLOC == routeLevel)
@@ -1802,6 +1817,15 @@ void DriveSignalOpen(const UINT16 signalId, const UINT16 routeId)
lightExtinctState = GetSignalLightExtinctState(signalId);/*信号机亮灭状态*/
sigalMaintainState = GetSignalMaintainState(signalId);/*信号机维修点灯状态*/
chRoutelightFlag = GetSignalShine(signalId);
if (SIGNAL_LIGHT_CONFIG_CBTC_CLOSE == chRoutelightFlag)
{
lightExtinctState = SIGNAL_LIGHT_EXTICT_STATE_YES;
}
else
{
/*数据配置常亮，CBTC接近时灭灯，驱动亮灯；配置其他依据亮灭灯状态*/
}
signalIsfushiFlag = GetSignalIsfushiFlag(signalId);
signalCurDriveColor = GetSignalCurDriveColor(signalId);
if ((SIGNAL_DRIVECOLOUR_NULL == signalCurDriveColor)&&(SIGNALTYPE_FUSHI_YES != signalIsfushiFlag))/*驱开放增加是否复示防护逻辑，避免数据配错导致的异常情况*/
@@ -2069,6 +2093,7 @@ 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;
@@ -2103,6 +2128,15 @@ UINT8 DriveSignalClose(const UINT16 signalId)
routeState = GetRouteState(routeId);/*获取进路状态*/
wStartSignalId = GetRouteStartSignalId(routeId);
chRoutelightFlag = GetSignalShine(signalId);
if (SIGNAL_LIGHT_CONFIG_CBTC_CLOSE == 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)
@@ -9077,7 +9111,13 @@ void SetSigleRouteAutoTriggerManage(UINT8 virCIid, UINT16 routeId, UINT8 setFlag
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*/
@@ -9100,7 +9140,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)
{
/*检查自动触发进路防淹门状态*/
@@ -11367,3 +11471,156 @@ UINT16 GetRouteFirstLockedLogSecId(UINT16 wRouteId)
return wRetVal;
}
/*
* 功能描述：紧急临时限速处理
* 参数说明：const UINT16 wLogSectionId 逻辑区段ID
* const UINT8 chExiansuState 限速状态
* 返 回 值：无
* by 20250916
*/
void EmergXianSuProcess(const UINT16 wLogSectionId, const UINT8 chExiansuState)
{
UINT8 chBelongCiId = 0U;
UINT8 chLocalCiId = 0U;
UINT8 chPerLogSecExiansuState = 0U;
if ((0U < wLogSectionId) && (LOGIC_SECTION_SUM_MAX > wLogSectionId))
{
chBelongCiId = GetLogSecBelongCiId(wLogSectionId);/*逻辑区段所属联锁*/
chLocalCiId = GetSystemParaLocalCiId();
if ((chLocalCiId == chBelongCiId) && (0U != chLocalCiId))
{
chPerLogSecExiansuState = GetLogSecEmergXianSu(wLogSectionId);
SetLogSecEmergXianSu(wLogSectionId, chExiansuState);/*设置逻辑区段紧急临时限速*/
if ((LOGSEC_EMERG_XS_SET_YES != chPerLogSecExiansuState) && (LOGSEC_EMERG_XS_SET_YES == chExiansuState))
{
/*由未设置到设置*/
ClearLgcSecBelongRtXsCfm(wLogSectionId); /*清除限速确认*/
}
else
{
/*不处理*/
}
}
else
{
/*非本联锁逻辑区段，不处理*/
}
}
else
{
/*不处理*/
}
}
/*
* 功能描述：获取全线雨雪模式命令CC
* 参数说明：void
* 返 回 值：0x55 有效
* 0xAA 无效
* Created By LQ 2025.11.07
*/
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])
{
UINT8 ii = 0U;
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));
gLocalAreaSnowNumCC = cAreaSnowNum;
for (ii = 0U; ii < cAreaSnowNum; ii++)
{
gszLocalAreaSnowCC[ii] = pAreaSnowBuf[ii]; /*存储本控区的区间雨雪状态信息*/
}
}
else
{
/*入参非法，不处理*/
}
}
/*
* 功能描述：获取本地雨雪模式命令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
{
; /*不处理*/
}
}
TSCP/src/APP/ciapp/DataManage/DeviceDataManage.h
+75
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数组*/
@@ -1897,5 +1904,73 @@ 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);
/*
* 功能描述：获取全线雨雪模式命令CC
* 参数说明：void
* 返 回 值：0x55 有效
* 0xAA 无效
* Created By LQ 2025.11.07
*/
UINT8 GetAllSnowModelCC(void);
/*
* 功能描述：设置全线雨雪模式命令CC
* 参数说明：UINT8 setmodle 全线雨雪模式
* 返 回 值：void
* Created By LQ 2025.11.07
*/
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);
#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
+7
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,9 @@
#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*/
/*************************************************分界线******************************************************************************/
/*************************************************分界线******************************************************************************/
@@ -235,6 +239,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 +250,7 @@
#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通信*/
/* 信号机故障类型编码 (UINT8)0x21-(UINT8)0x3f */
/* 设备类型 CI_DEVICE_TYPE_SIGNAL */
@@ -298,6 +304,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 */
TSCP/src/APP/ciapp/EnvelopeManage/ELMDataPrepare.c
+16 -16
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);
}
}
@@ -1684,7 +1684,7 @@ UINT8 elm_PrepareOCCommStatus(UINT8 OCID)
UINT8 funRtn = TRANSMIT_STATE_BAD;
/** 获取OC通信状态 */
funRtn = GetCiTransmitState(CI_SYSTEM_TYPE_CI,OCID);
funRtn = GetCiTransmitState(CI_SYSTEM_TYPE_RCI,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/EnvelopeLogicProcess.c
+3 -33
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
{
; /*未超过冗余时间或列车通信中断*/
; /*未超过冗余时间*/
}
}
}
@@ -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
+38 -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,22 @@ 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
+118 -10
View File
@@ -15,15 +15,20 @@
#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 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 +422,7 @@ void ProcHlhtHeadCtxTimeOut(void)
{
UINT32 timeoutSnCount = 0U;
UINT32 timeoutSpan = 0U;
UINT8 chSystemWorkType = GetSystemWorkType();; /*系统工作类型*/
/*处理VOBC通用报文头的时效性*/
timeoutSnCount = GetCiAndVobcTransBadEnsureCnt();
@@ -436,6 +442,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 +462,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 +576,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 +640,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 +658,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;
@@ -652,7 +737,7 @@ static void ProcHlhtHeadCtxTimeOutDiffSys(const UINT32 timeoutSnCount, const UIN
if (0u == headValid)
{
if (headCtxs == axleHLHTHeadCtxs) /*计轴系统中断时,GAL层对方序号,收到对方数据时本方序号,设置0xFFFFFFFF*/
if ((headCtxs == axleHLHTHeadCtxs) || (headCtxs == gSzRcAxleHLHTHeadCtxs)) /*计轴系统中断时,GAL层对方序号,收到对方数据时本方序号,设置0xFFFFFFFF*/
{
headCtxs[i].logId = 0u;
headCtxs[i].sourceRecvOppMsgSN = 0u;
@@ -1183,3 +1268,26 @@ 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;
}
TSCP/src/APP/ciapp/HLHTMsgHead/HLHTHeadContexManage.h
+15 -2
View File
@@ -38,15 +38,20 @@ 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 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 +290,14 @@ 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);
#ifdef __cplusplus
}
TSCP/src/APP/ciapp/IO/DeviceRelayDataProcess.c
+244 -23
View File
@@ -362,6 +362,10 @@ void OcSwitchDeviceOutput(void)
chSwitchJichaState = GetSwitchPrompylyAlarmInfo(switchId);
/*只有静态红闪和动态红闪可以设置，其他设置不了一直为0*/
SetSwitchJichaState(switchId, chSwitchJichaState);
/*OC道岔转辙机标识灯状态处理 */
SetOcSwitchIndicatorLightStatus(switchId);
}
}
}
@@ -518,6 +522,9 @@ void OcSwitchDeviceInput(void)
/*设置所有道岔单独位置*/
SetAllSingleSwitchCurPosition(switchCurSum);
/*设置所有道岔转辙机状态*/
SetAllSingleSwitchZzjState(switchCurSum);
/*设置道岔当前逻辑位置*/
UpdataSwitchCurPostion(switchCurSum);
@@ -1135,6 +1142,8 @@ void OcSignalDeviceInput(void)
UINT32 signalDiffCyc = 0U; /*信号开放颜色不一致周期*/
UINT8 cFuncRet = 0U;
UINT8 cControlState = GetLocalCiBackUpPattern();
curCycNum= Get2oo2CurCycleNum();
signalCurSum = GetTotalSignalCurNum(); /*获取信号机总数*/
localCiId = GetSystemParaLocalCiId(); /*获取本机联锁ID*/
@@ -1255,10 +1264,13 @@ void OcSignalDeviceInput(void)
/*当前周期有驱动信号机，此处不再设置驱动无效*/
}
else
{
if (SYSTEM_WORK_MODE_MAIN == cControlState)
{
/*设置信号机驱动无效*/
SetSignalCurDriveColor(signalId, SIGNAL_DRIVECOLOUR_NULL);
}
}
/*设置当前显示颜色*/
OcSetSignalCurColor(signalId, signalCurColor);
@@ -1681,7 +1693,7 @@ void DetZfsCancelBtnActFlagProc(const UINT16 wSignalId, const UINT16 wCancelDetB
/******************************OC spks指示灯输出处理****************************/
/*
* 功能描述： OC spks指示灯和spks旁路指示灯输出处理
* 功能描述： OC spks指示灯、spks旁路指示灯及蜂鸣继电器处理
* 参数说明： void
* 返回值 ： void
*/
@@ -1700,6 +1712,9 @@ void SpksDisplayDrivOutput(void)
UINT32 dwSpksIndicDelayCount = 0u;
UINT8 checkCycOut = 0u;
UINT8 cSpksState = 0U;
UINT16 wSpksBuzzRelayId = 0U;
UINT16 wSpksCutBuzzRelayId = 0U;
UINT8 chRelayDriveState = 0U;/*继电器当前驱动状态*/
spksCurSum = GetSpksSum(); /*获取spks数量，默认为每个spks都有对应的指示灯*/
chLocalCiId = GetSystemParaLocalCiId(); /*获取本地联锁ID*/
@@ -1722,7 +1737,8 @@ void SpksDisplayDrivOutput(void)
cutSpksId = GetSpksCutRelayId(spksId); /*获取spks旁路按钮继电器ID*/
cutSpksDisplayId = GetSpksCutDisRelayId(spksId); /*根据spks ID获取spks旁路指示灯ID*/
wSpksBuzzRelayId = GetSpksBuzzRelayId(spksId);/*获取蜂鸣继电器ID*/
wSpksCutBuzzRelayId = GetSpksCutBuzzRelayId(spksId);/*获取切除蜂鸣继电器ID*/
devBlongCiId = GetSpksBelongCiId(spksId); /*获取设备所属联锁ID*/
if ((0u != cutSpksId) && (UINT16_MAX != cutSpksId))
@@ -1788,6 +1804,64 @@ void SpksDisplayDrivOutput(void)
/*spks室外指示灯驱动*/
spksflockStartNum = GetSpksflockStartNum(spksId);
SpksOutsideDisPlayDriv(spksId,spksflockStartNum);
/*SPKS蜂鸣继电器处理*/
if ((0u != wSpksBuzzRelayId) && (UINT16_MAX != wSpksBuzzRelayId))
{
/*蜂鸣器驱动状态*/
chRelayDriveState = GetRelayDriveState(wSpksBuzzRelayId);
/*spks有效*/
if ((SPKS_STATUS_YES == cSpksState)&&(RELAY_STATE_UP != tmpCutRelayColState))/*未旁路*/
{
/*驱动蜂鸣器吸起*/
(void)SetRelayDriveState(wSpksBuzzRelayId, RELAY_DRIVE_STATE_UP);
}
else
{
/*没有驱动*/
if (RELAY_DRIVE_STATE_NULL == chRelayDriveState)
{
/*驱动蜂鸣器落下*/
(void)SetRelayDriveState(wSpksBuzzRelayId, RELAY_DRIVE_STATE_DOWN);
}
else
{
;/*已有驱动，不处理*/
}
}
}
else
{
;/*此spks无蜂鸣继电器，不处理*/
}
/*SPKS切除蜂鸣继电器处理*/
if ((0u != wSpksCutBuzzRelayId) && (UINT16_MAX != wSpksCutBuzzRelayId))
{
/*继电器驱动状态*/
chRelayDriveState = GetRelayDriveState(wSpksCutBuzzRelayId);
if ((SPKS_STATUS_YES == cSpksState) && (RELAY_STATE_UP != tmpCutRelayColState))/*未旁路*/
{
/*驱动复原蜂鸣器落下*/
(void)SetRelayDriveState(wSpksCutBuzzRelayId, RELAY_DRIVE_STATE_DOWN);
}
else
{
/*没有驱动*/
if (RELAY_DRIVE_STATE_NULL == chRelayDriveState)
{
/*驱动蜂鸣器吸起*/
(void)SetRelayDriveState(wSpksCutBuzzRelayId, RELAY_DRIVE_STATE_UP);
}
else
{
;/*已有驱动，不处理*/
}
}
}
else
{
;/*此spks无蜂鸣切除继电器，不处理*/
}
}
else
{
@@ -6073,10 +6147,13 @@ void PhySecResetToRelayStateProc(void)
UINT8 overTimeCheck = 0u;
UINT16 wPhySecFwRelayId = 0U;/*物理区段复位继电器ID*/
UINT32 dwPhyResetCount = 0U; /*计轴复位超时周期数*/
UINT8 chCurSystemAreaState = 0U; /*系统当前区域状态*/
localCi = GetSystemParaLocalCiId();
relayZFWId = GetZFWRelayId(localCi); /*总复位继电器ID*/
retGeneralResetFlag = GetPhySecGeneralResetFlag(); /*获取物理区段计轴总复位继电器状态有效性*/
chCurSystemAreaState = GetLocalCiBackUpPattern();
if (relayZFWId > 0u)
{
relayZFWState = GetRelayCollState(relayZFWId); /*ZFWJ继电器采集状态*/
@@ -6203,6 +6280,17 @@ void PhySecResetToRelayStateProc(void)
retValid = CI_ERROR; /*计轴总复位继电器状态有效性值置位为无效*/
phySecId = GetPhySecId(ii);/*获取物理区段ID*/
if (SYSTEM_WORK_MODE_MAIN != chCurSystemAreaState)
{
/*当前系统不为主系，设置计轴复位起始周期号为0，不处理及对外组包计轴复位命令*/
SetPhySecResetStartCycNum(phySecId, 0U);
}
else
{
;
}
startCycNum = GetPhySecResetStartCycNum(phySecId);
wPhySecFwRelayId = GetPhySecFWRelayId(phySecId);
@@ -6556,7 +6644,6 @@ void PsdRelayToDeviceStateProc(void)
UINT8 chPsdCloseState = 0U;
UINT8 chPsdClose2State = 0U;
UINT8 chPsdButtonState = 0U;
UINT8 chPsdReOpenRelayState = 0U;
UINT8 reVal = CI_SUCCESS;
UINT8 relayCollState = 0u;
UINT8 buttonState = 0u;
@@ -6566,7 +6653,8 @@ void PsdRelayToDeviceStateProc(void)
UINT32 dwCycNum = 0U;
UINT8 chDsnLinSwitch = 0U;
UINT8 cFuncRet = 0U;
UINT16 wpsdReopenButtonRelayId2 = 0U;
UINT8 relayCollState2 = 0U;
chDsnLinSwitch = GetCiFunctionSwitchConfig(FUNC_DSN_LINE_SWITCH);
psdSum = GetPsdSum();
@@ -6641,11 +6729,26 @@ void PsdRelayToDeviceStateProc(void)
if (CI_SUCCESS == reVal)
{
psdReopenButtonRelayId = GetPsdReOpenRelayId(psdId);
wpsdReopenButtonRelayId2 = GetPsdReOpenRelayId2(psdId);
/*屏蔽门开门按钮状态更新*/
if ((0u != psdReopenButtonRelayId) && (UINT16_MAX != psdReopenButtonRelayId))
{/*站台开门按钮继电器ID有效*/
relayCollState = GetRelayCollState(psdReopenButtonRelayId);
if (RELAY_STATE_UP == relayCollState)
}
else
{
relayCollState = RELAY_STATE_DOWN;
}
if ((0u != wpsdReopenButtonRelayId2) && (UINT16_MAX != wpsdReopenButtonRelayId2))
{
relayCollState2 = GetRelayCollState(wpsdReopenButtonRelayId2);
}
else
{
relayCollState2 = RELAY_STATE_DOWN;
}
if ((RELAY_STATE_UP == relayCollState) || (RELAY_STATE_UP == relayCollState2))
{
buttonPressCycNum = GetPOBPressCycNum(psdId);
curCycNum = Get2oo2CurCycleNum();
@@ -6659,7 +6762,7 @@ void PsdRelayToDeviceStateProc(void)
reVal = CI_ERROR;
}
}
else if (RELAY_STATE_DOWN == relayCollState)
else if ((RELAY_STATE_DOWN == relayCollState) && (RELAY_STATE_DOWN == relayCollState2))
{
(void)SetPOBPressCycNum(psdId, 0u); /*清除POB按下起始周期号*/
buttonState = SetPsdOpenButtonState(psdId, PSD_OPEN_BUTTON_STATE_INVALID);
@@ -6674,10 +6777,6 @@ void PsdRelayToDeviceStateProc(void)
reVal = CI_ERROR;
}
}
else
{/*有些线路PSD不配置开门按钮继电器，continue，继续执行*/
}
}
if (CI_SUCCESS == reVal)
{
@@ -6887,33 +6986,53 @@ void PsdRelayToDeviceStateProc(void)
if (reVal == CI_SUCCESS)
{
psdReopenButtonRelayId = GetPsdReOpenRelayId(psdId);
wpsdReopenButtonRelayId2 = GetPsdReOpenRelayId2(psdId);
/*屏蔽门开门按钮状态更新*/
if ((0u != psdReopenButtonRelayId) && (UINT16_MAX != psdReopenButtonRelayId))
{/*站台开门按钮继电器ID有效*/
chPsdReOpenRelayState = GetRelayCollState(psdReopenButtonRelayId);
if (RELAY_STATE_UP == chPsdReOpenRelayState)
relayCollState = GetRelayCollState(psdReopenButtonRelayId);
}
else
{
dwCycNum = GetPOBPressCycNum(psdId);
if (0u == dwCycNum)
relayCollState = RELAY_STATE_DOWN;
}
if ((0u != wpsdReopenButtonRelayId2) && (UINT16_MAX != wpsdReopenButtonRelayId2))
{
relayCollState2 = GetRelayCollState(wpsdReopenButtonRelayId2);
}
else
{
relayCollState2 = RELAY_STATE_DOWN;
}
if ((RELAY_STATE_UP == relayCollState) || (RELAY_STATE_UP == relayCollState2))
{
buttonPressCycNum = GetPOBPressCycNum(psdId);
curCycNum = Get2oo2CurCycleNum();
if (0U == buttonPressCycNum)
{/*若未计时，则设置起始周期*/
(void)SetPOBPressCycNum(psdId, Get2oo2CurCycleNum());
(void)SetPOBPressCycNum(psdId, curCycNum);
}
reVal = SetPsdOpenButtonState(psdId, PSD_OPEN_BUTTON_STATE_VALID);
buttonState = SetPsdOpenButtonState(psdId, PSD_OPEN_BUTTON_STATE_VALID);
if (CI_ERROR == buttonState)
{
reVal = CI_ERROR;
}
else if (RELAY_STATE_DOWN == chPsdReOpenRelayState)
}
else if ((RELAY_STATE_DOWN == relayCollState) && (RELAY_STATE_DOWN == relayCollState2))
{
(void)SetPOBPressCycNum(psdId, 0u); /*清除POB按下起始周期号*/
reVal = SetPsdOpenButtonState(psdId, PSD_OPEN_BUTTON_STATE_INVALID);
buttonState = SetPsdOpenButtonState(psdId, PSD_OPEN_BUTTON_STATE_INVALID);
if (CI_ERROR == buttonState)
{
reVal = CI_ERROR;
}
}
else
{
(void)SetPOBPressCycNum(psdId, 0u); /*清除POB按下起始周期号*/
reVal = CI_ERROR;
}
}
else
{/*有些线路PSD不配置开门按钮继电器，continue，继续执行*/
}
}
@@ -7158,6 +7277,11 @@ UINT8 PsdDeviceToRelayStateProc(void)
{/*八编组屏蔽门*/
psdKMRelayId = GetEightGroupPsdOpenDrvRelayId(psdId);
}
else if (PSD_THREE_EDIT_GROUP == psdEditGroupInfo)
{
/*三编组屏蔽门*/
psdKMRelayId = GetThreeGroupPsdOpenDrvRelayId(psdId);
}
else
{/*编组无效*/
psdKMRelayId = 0u;
@@ -7207,6 +7331,16 @@ UINT8 PsdDeviceToRelayStateProc(void)
reVal = CI_ERROR;
}
}
tmpPsdKMRelayId = GetThreeGroupPsdOpenDrvRelayId(psdId);
if (tmpPsdKMRelayId > 0u)
{
/*所有开门继电器驱落下*/
relayFlag = SetRelayDriveState(tmpPsdKMRelayId, RELAY_DRIVE_STATE_DOWN);
if (CI_ERROR == relayFlag)
{/*开门继电器*/
reVal = CI_ERROR;
}
}
}
}
@@ -7275,6 +7409,16 @@ UINT8 PsdDeviceToRelayStateProc(void)
reVal = CI_ERROR;
}
}
tmpPsdKMRelayId = GetThreeGroupPsdOpenDrvRelayId(psdId);
if (tmpPsdKMRelayId > 0u)
{
/*所有开门继电器驱落下*/
relayFlag = SetRelayDriveState(tmpPsdKMRelayId, RELAY_DRIVE_STATE_DOWN);
if (CI_ERROR == relayFlag)
{/*开门继电器*/
reVal = CI_ERROR;
}
}
}
}
else
@@ -8421,7 +8565,6 @@ UINT8 GaragedoorRelayToDevStaProc(void)
gdOpenRelayState = GetRelayCollState(garagedoorOpenRelayId);
gdCloseRelayState = GetRelayCollState(garagedoorCloseRelayId);
gdKGHRelayState = GetRelayCollState(garagedoorKGHRelayId);
gdPangLuRelayState = GetRelayCollState(garagedoorPangLuRelayId);
gdGuZhangRelayState = GetRelayCollState(garagedoorFaultRelayId);
gdModeRelayState = GetRelayCollState(garagedoorModeRelayId);
@@ -8440,6 +8583,15 @@ UINT8 GaragedoorRelayToDevStaProc(void)
* 门开: 门开继电器↑ 门关继电器↓ 门关: 门开继电器↓ 门关继电器↑
*/
if ((0U < garagedoorKGHRelayId) && (UINT16_MAX > garagedoorKGHRelayId))
{/*配置了开关后节点继电器*/
gdKGHRelayState = GetRelayCollState(garagedoorKGHRelayId);
}
else
{/*未配置开关后节点继电器*/
gdKGHRelayState = RELAY_STATE_DOWN;
}
/*车库门开关*/
if ((RELAY_STATE_DOWN == gdOpenRelayState) && (RELAY_STATE_UP == gdCloseRelayState)
&& (RELAY_STATE_DOWN == gdKGHRelayState) && (RELAY_STATE_DOWN == gdPangLuRelayState))
@@ -14408,6 +14560,75 @@ void SetAllSingleSwitchCurPosition(UINT16 switchCurSum)
}
}
/*
* 功能描述： 设置所有道岔转辙机位置
* 参数说明： UINT16 switchCurSum 道岔总数
* 返回值 ： 无
*/
void SetAllSingleSwitchZzjState(UINT16 switchCurSum)
{
UINT16 belongOcId = 0u; /*道岔所属oc ID*/
UINT16 switchId = 0U; /*道岔ID*/
UINT16 ii = 0U; /*循环索引*/
UINT16 jj = 0U; /*循环索引*/
UINT8 flagFind = 0u;
UINT16 indexFind = 0u;
UINT8 chSwitchIncldeZzjNum = 0u; /*道岔对应转辙机数目，设备类型为信号机时,此个数为0*/
UINT8 szSwitchIncldeZzjState[MAX_OC_SWITCH_INCLUDE_ZZJ_NUM] = { 0 };/*转辙机状态*/
for (ii = 0U; ii < switchCurSum; ii++)
{
switchId = GetSwitchId(ii); /*获取道岔ID*/
belongOcId = GetSwitchBelongOcId(switchId);/*获取道岔所属Oc id*/
if ((0u < belongOcId) && (OC_SUM_MAX > belongOcId))
{
for (jj = 0u; jj < m_SwitchNum; jj++)
{
if (m_Switches[jj].DeviceId == switchId)
{
flagFind = 1u;
indexFind = jj;
break;
}
}
}
else
{
;/*不处理*/
}
if (1u == flagFind) /*找到了*/
{
flagFind = 0u;
chSwitchIncldeZzjNum = m_Switches[indexFind].chSwitchIncldeZzjNum;
if (0u == chSwitchIncldeZzjNum)
{
/* 不处理 */
}
else
{
for (jj = 0U; jj < MAX_OC_SWITCH_INCLUDE_ZZJ_NUM; jj++)
{
szSwitchIncldeZzjState[jj] = 0u;
}
for (jj = 0U; jj < chSwitchIncldeZzjNum; jj++)
{
szSwitchIncldeZzjState[jj] = m_Switches[indexFind].szSwitchIncldeZzjState[jj];
}
/* 保存完毕，开始存入动态结构体里面*/
SetOcSwitchZzjState(switchId, chSwitchIncldeZzjNum, szSwitchIncldeZzjState);
}
}
else
{
/*未找到*/
}
}
}
/*
* 功能描述： 设置道岔当前逻辑位置
* 参数说明： UINT16 switchCurSum 道岔总数
TSCP/src/APP/ciapp/IO/DeviceRelayDataProcess.h
+8 -1
View File
@@ -354,7 +354,7 @@ void ProcessJXTCPulseInterfStopDrv(UINT16 startJXTCRelayId, UINT16 stopJXTCRelay
/******************************OC spks指示灯输出处理****************************/
/*
* 功能描述： OC spks指示灯和spks旁路指示灯输出处理
* 功能描述： OC spks指示灯、spks旁路指示灯及蜂鸣继电器处理
* 参数说明： void
* 返回值 ： void
*/
@@ -984,6 +984,13 @@ UINT8 GetFstDetBtnCollTolerateRet(const UINT16 wSignalId);
*/
UINT8 GetSndDetBtnCollTolerateRet(const UINT16 wSignalId);
/*
* 功能描述： 设置所有道岔转辙机位置
* 参数说明： UINT16 switchCurSum 道岔总数
* 返回值 ： 无
*/
void SetAllSingleSwitchZzjState(UINT16 switchCurSum);
#ifdef __cplusplus
}
#endif
TSCP/src/APP/ciapp/IO/InputDataProcess.c
+2023 -426
View File
File diff suppressed because it is too large Load Diff
TSCP/src/APP/ciapp/IO/InputDataProcess.h
+80
View File
@@ -466,6 +466,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
+101 -25
View File
@@ -390,6 +390,9 @@ UINT8 GetAtsBackInfoParam(const UINT8 functionId,const UINT8 deviceStateType, co
case ETYPE_ROUTE_APPLY_SWITCH_MOVE:
returnValue = CI_BACK_SWT_MOVE; /*道岔单操中办理进路*/
break;
case ETYPE_COUPLINK_ROUTE_IDLE:
returnValue = CI_BACK_COUPLINK_ROUTE_IDLE; /*联挂进路内无被联挂车*/
break;
/*信号机故障反馈*/
case ETYPE_SIG_START_OPEN_STATE:
@@ -689,6 +692,7 @@ UINT8 GetAtsBackInfoParam(const UINT8 functionId,const UINT8 deviceStateType, co
case ETYPE_COMM_WITH_VOBC:
case ETYPE_COMM_WITH_ZC:
case ETYPE_COMM_WITH_CI:
case ETYPE_COMM_WITH_RC:
case ETYPE_COMM_WITH_TMC:
returnValue = deviceState; /*VOBC、ZC、CI、TMC与CI通信失败报警*/
break;
@@ -838,6 +842,10 @@ UINT8 GetAtsBackInfoParam(const UINT8 functionId,const UINT8 deviceStateType, co
{
returnValue = CI_BACK_AUTO_ROUTE_HAVE_BLOCK;
}
else if (AUTO_ROUTE_COUPROUTE_SET == deviceState)
{
returnValue = CI_BACK_AUTO_ROUTE_COUPROUTE_SET;
}
else
{
returnValue = CI_BACK_AUTO_ROUTE_FLOOD_STATE_ERR;
@@ -864,6 +872,10 @@ UINT8 GetAtsBackInfoParam(const UINT8 functionId,const UINT8 deviceStateType, co
{
returnValue = CI_BACK_AUTO_RETURN_HAVE_BLOCK;
}
else if (AUTO_RETURN_COUPROUTE_SET == deviceState)
{
returnValue = CI_BACK_AUTO_RETURN_COUPROUTE_SET;
}
else
{
returnValue = CI_BACK_AUTO_RETURN_FLOOD_STATE_ERR;
@@ -890,6 +902,10 @@ UINT8 GetAtsBackInfoParam(const UINT8 functionId,const UINT8 deviceStateType, co
{
returnValue = CI_BACK_ALLAUTO_RETURN_HAVE_BLOCK;
}
else if (ALL_AUTO_RETURN_COUPROUTE_SET == deviceState)
{
returnValue = CI_BACK_ALLAUTO_RETURN_COUPROUTE_SET;
}
else
{
returnValue = CI_BACK_ALLAUTO_RETURN_FLOOD_STATE_ERR;
@@ -1758,16 +1774,16 @@ void IndicatorStateProc(void)
&& (INDICATOR_TYPE_COMM_CI_LAST >= devType))
{/*第devType-INDICATOR_TYPE_COMM_CI_FIRST+1个相邻联锁通信状态*/
devRelaySum = Get2oo2CiAndOtherSysCommNum(CI_SYSTEM_TYPE_CI);
devRelaySum = Get2oo2CiAndOtherSysCommNum(CI_SYSTEM_TYPE_RCI);
jj = devType - INDICATOR_TYPE_COMM_CI_FIRST;
if (devRelaySum > jj)
{
if (TRANSMIT_2OO2_STATE_GOOD == Get2oo2CiAndOtherSysCommState(CI_SYSTEM_TYPE_CI,(UINT8)jj))
if (TRANSMIT_2OO2_STATE_GOOD == Get2oo2CiAndOtherSysCommState(CI_SYSTEM_TYPE_RCI,(UINT8)jj))
{/*上第jj+1个相邻联锁 通信良好*/
SetIndicatorState(devId, INDICATOR_SHOW_COMM_GREEN);/*设置指示灯通信良好*/
}
else if (TRANSMIT_2OO2_STATE_LINK == Get2oo2CiAndOtherSysCommState(CI_SYSTEM_TYPE_CI,(UINT8)jj))
else if (TRANSMIT_2OO2_STATE_LINK == Get2oo2CiAndOtherSysCommState(CI_SYSTEM_TYPE_RCI,(UINT8)jj))
{/*第jj+1个相邻联锁 通信一般*/
SetIndicatorState(devId, INDICATOR_SHOW_COMM_YELLOW);/*设置指示灯通信一般*/
@@ -3375,11 +3391,11 @@ void IndicatorStateProc_UseVirCI(UINT8 virCIid)
&& (INDICATOR_TYPE_COMM_CI_LAST >= devType))
{/*第devType-INDICATOR_TYPE_COMM_CI_FIRST+1个相邻联锁通信状态*/
devRelaySum = Get2oo2CiAndOtherSysCommNum(CI_SYSTEM_TYPE_CI);
devRelaySum = Get2oo2CiAndOtherSysCommNum(CI_SYSTEM_TYPE_RCI);
jj = devType - INDICATOR_TYPE_COMM_CI_FIRST;
if (devRelaySum > jj)
{
commState = Get2oo2CiAndOtherSysCommState(CI_SYSTEM_TYPE_CI,(UINT8)jj);
commState = Get2oo2CiAndOtherSysCommState(CI_SYSTEM_TYPE_RCI,(UINT8)jj);
if (TRANSMIT_2OO2_STATE_GOOD == commState)
{/*上第jj+1个相邻联锁 通信良好*/
@@ -5754,7 +5770,6 @@ UINT16 GetOverlapUnlockBackTime(const UINT16 overlapId, UINT16 OverlapUnLockCoun
UINT32 laborUnlockOverlapTimeCount =0u;
UINT16 returnTime = 0u;
/*自动解锁倒计时*/
deltCount = (INT32)(curCycleNum - startCycNum);
if((deltCount >= 0) && (deltCount <= (INT32)OverlapUnLockCount))/*倒计时数值在合理范围内*/
@@ -5778,24 +5793,15 @@ UINT16 GetOverlapUnlockBackTime(const UINT16 overlapId, UINT16 OverlapUnLockCoun
}
}
if (0u < laborUnlockStartCycNum)/*已经设置人工解锁*/
{
/*比较两个时间，返回最小的。因为在解锁；逻辑是以最小倒计时解锁的*/
if(autotimeData > labortimeData)
{
/*有人工解锁，就用人工解锁时间*/
returnTime = labortimeData;
}
else
{
returnTime = autotimeData;
}
}
else
{
returnTime = autotimeData;
}
return returnTime;
}
@@ -6276,6 +6282,7 @@ void OverlapTimeDataBackProcess(const UINT16 wOverlapId)
UINT8 chTmpOvlpOccuSecSta = 0U;/*临时变量，用作调用函数的出口参数，本函数中不关心其值*/
UINT8 chFuncSwitchSendTime = 0u;/*CBTC是否发送保护区段解锁倒计时*/
UINT8 chABLFlag = 0U; /*进路最后物理区段ABL占用标志*/
UINT32 dwLaborUnlockStartCycNum = 0U; /*保护区段人工解锁起始周期号*/
chLocalCiId = GetSystemParaLocalCiId();
chFuncSwitchSendTime = GetCiFunctionSwitchConfig(FUNC_SWITCH_SEND_UNLOCK_OVERLEP_TIMER_COUNTDOWN);
@@ -6295,6 +6302,9 @@ void OverlapTimeDataBackProcess(const UINT16 wOverlapId)
{
wRouteLastPhySectionId = GetRouteLastPhySectionId(wOverlapBelongRouteId);
dwUtCtStartOccuCount = GetSecUtOrCtOccuStartCycNum(wRouteLastPhySectionId);
wOverlapAllClearRes = OverlapAllSecOccuClearCheck(wOverlapId, &wTmpOvlpOccuSecId, &chTmpOvlpOccuSecSta);
dwLaborUnlockStartCycNum = GetlaborUnlockStartCycNum(wOverlapId);
/*进路顺序占压到最后一个区段的起始周期*/
if (0U <dwUtCtStartOccuCount)
{
@@ -6330,7 +6340,6 @@ void OverlapTimeDataBackProcess(const UINT16 wOverlapId)
}
}
wRouteStopSteadyPhySecId = GetRouteStopSteadyPhySecId(wRLockBelongRouteId);/*获取进路停稳物理区段ID*/
wOverlapAllClearRes = OverlapAllSecOccuClearCheck(wOverlapId, &wTmpOvlpOccuSecId, &chTmpOvlpOccuSecSta);
if ((wRouteLastPhySectionId == wRouteStopSteadyPhySecId) && (CI_SUCCESS == wOverlapAllClearRes))
{/*倒计时未超时*/
@@ -6348,10 +6357,10 @@ void OverlapTimeDataBackProcess(const UINT16 wOverlapId)
{
dwCtOverlapUnLockCount = GetOtherCIRouteOverlapCTUnlockCount(wRLockBelongRouteId);
}
if (FUNC_SWITCH_ON == chFuncSwitchSendTime)
if ((FUNC_SWITCH_ON == chFuncSwitchSendTime) || (0U < dwLaborUnlockStartCycNum))
{/*功能打开*/
wRouteStopSteadyPhySecId = GetRouteStopSteadyPhySecId(wRLockBelongRouteId);/*获取进路停稳物理区段ID*/
wOverlapAllClearRes = OverlapAllSecOccuClearCheck(wOverlapId, &wTmpOvlpOccuSecId, &chTmpOvlpOccuSecSta);
if ((wRouteLastPhySectionId == wRouteStopSteadyPhySecId) && (CI_SUCCESS == wOverlapAllClearRes))
{
wTimeData = GetOverlapUnlockBackTime(wOverlapId, (UINT16)dwCtOverlapUnLockCount, dwRelyonStartCycNum);
@@ -6361,7 +6370,29 @@ void OverlapTimeDataBackProcess(const UINT16 wOverlapId)
}
else
{
/*占用类型故障*/
/*解决问题：
物理区段占用变空闲容忍时，CT/UT占用起始时间有效，但占用标志已经变成了未占用；此时要是有人工解锁，倒计时会消失占用变空闲时间*/
if ((0U < dwLaborUnlockStartCycNum) && (CI_SUCCESS == wOverlapAllClearRes))
{
wTimeData = GetOverlapLaborUnlockBackTime(wOverlapId);
}
else
{
SetOverlapUnlockTime(wOverlapId, 0U);
}
}
}
else
{
/*人工解锁倒计时*/
if ((0U < dwLaborUnlockStartCycNum) && (CI_SUCCESS == wOverlapAllClearRes))
{
wTimeData = GetOverlapLaborUnlockBackTime(wOverlapId);
}
else
{
SetOverlapUnlockTime(wOverlapId, 0U);/*清除倒计时，因为区段再次占用时，要重新以区段占用开始时间作为倒计时参考，重新记时*/
}
}
if (0u < wTimeData)/*存在倒计时*/
@@ -6376,11 +6407,6 @@ void OverlapTimeDataBackProcess(const UINT16 wOverlapId)
SetOverlapUnlockTime(wOverlapId, wTimeData);
}
else
{
SetOverlapUnlockTime(wOverlapId, 0U);/*清除倒计时，因为区段再次占用时，要重新以区段占用开始时间作为倒计时参考，重新记时*/
}
}
else
{
if (chLocalCiId == wOverlapBelongRouteCiId)/*保护区段锁闭所属进路属于本联锁*/
{
@@ -6559,13 +6585,22 @@ void VobcBackUpOutputProcess(void)
UINT8 chMainValid = 0U;/*主用列车通信状态*/
UINT16 wVobcId = 0U;/*VOBC ID*/
UINT8 chBackUpValid = 0U;/*备用通信有效标志*/
UINT8 cRcWorkMode = 0U;
for (ii = 0U; ii < TRAIN_SUM_MAX; ii++)
{
wTrainId = GetTrainId(ii);
chBackUpValid = GetHLHTHeadCtxValid(CI_SYSTEM_TYPE_VOBC_BACKUP, (UINT8)(wTrainId & 0x00ffU));
/*根据工作模式获取互联互通报文头*/
if (RC_WORK_MODE_CI == cRcWorkMode)
{
chMainValid = GetHLHTHeadCtxValid(CI_SYSTEM_TYPE_VOBC, (UINT8)(wTrainId & 0x00ffU));
}
else
{
chMainValid = GetHLHTHeadCtxValid(CI_SYSTEM_TYPE_IVOC, (UINT8)(wTrainId & 0x00ffU));
}
wVobcId = 0U;
@@ -8573,3 +8608,44 @@ void RtnRealyAdhesionStatePro(void)
}
}
/*
* 功能描述： 获取人工解锁保护区段剩余倒计时
* 参数说明： const UINT16 overlapId 保护区段id
* 返回值 ： 倒计时
* by cgh 20250928
*/
UINT16 GetOverlapLaborUnlockBackTime(const UINT16 overlapId)
{
UINT16 wLabortimeData = 0u;
INT32 deltCount = 0;
UINT32 curCycleNum = Get2oo2CurCycleNum();
UINT32 appCycTime = GetSystemParaAppCycleTime();/*获取联锁周期*/
UINT32 laborUnlockStartCycNum = 0u;
UINT32 laborUnlockOverlapTimeCount = 0u;
/*人工解锁倒计时*/
laborUnlockStartCycNum = GetlaborUnlockStartCycNum(overlapId);
if (0u < laborUnlockStartCycNum)/*已经设置人工解锁*/
{
deltCount = (INT32)(curCycleNum - laborUnlockStartCycNum);
laborUnlockOverlapTimeCount = GetlabarUnlockOverlapTimeCount();
if ((deltCount >= 0) && (deltCount <= (INT32)laborUnlockOverlapTimeCount))/*倒计时数值在合理范围内*/
{
wLabortimeData = (UINT16)(((laborUnlockOverlapTimeCount + laborUnlockStartCycNum - curCycleNum) * appCycTime) / 1000U);
}
else
{
;
}
}
else
{
}
return wLabortimeData;
}
TSCP/src/APP/ciapp/IO/OutputDataProcess.h
+8
View File
@@ -456,6 +456,14 @@ UINT8 FindRouteLeaveAxis(const UINT16 routeId);
*/
void RtnRealyAdhesionStatePro(void);
/*
* 功能描述： 获取人工解锁保护区段剩余倒计时
* 参数说明： const UINT16 overlapId 保护区段id
* 返回值 ： 倒计时
* by cgh 20250928
*/
UINT16 GetOverlapLaborUnlockBackTime(const UINT16 overlapId);
#ifdef __cplusplus
}
#endif
TSCP/src/APP/ciapp/Initial/ConfigDataReadManage.c
+15
View File
@@ -1083,6 +1083,21 @@ 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
{
/*不处理*/
}
}
TSCP/src/APP/ciapp/Initial/InitialProcess.c
+445 -80
View File
@@ -20,6 +20,7 @@
#include "NonAutoReturnConfigDataManage.h"
#include "../Deployment/DeploymentExtern.h"
#include "NonAutoReturnDataManage.h"
#include "ParsePackZcData.h"
/****************************初始化动态数据队列********************************************/
extern TransmitRelationDataStruct TransmitRelaDataStru[TRANSMIT_OBJECT_SUM_MAX]; /*引用已定义通信关系数据结构体*/
@@ -65,6 +66,8 @@ UINT8 InitialProcess(void)
}
/*读取联锁配置数据*/
if (CI_SUCCESS == ret)
{
if (0u != ReadConfigureData())
{
#ifdef PLATFORM_2OO2
@@ -77,6 +80,11 @@ UINT8 InitialProcess(void)
}
}
else
{
/*不处理*/
}
cRcWorkMode = GetLocalRcWorkMode();
@@ -572,9 +580,7 @@ UINT8 InitialSignalData(void)
SignalDataStru[signalId].RelayDetainCmd = SIGNAL_DETAIN_CI_RELAY_NO;/*初始设成不扣车*/
SignalDataStru[signalId].NeighbourSignalDetainDrive = NEIGHBOUR_SIGNAL_DETAIN_DRIVE_NO;/*邻站信号机扣车无驱动*/
SignalDataStru[signalId].MaintainLightState = MAINTAIN_STATE_NO;/*信号机不处于维修点灯状态*/
SignalDataStru[signalId].wSignalLightUpLinkIdSum = 0U;
(void)CommonMemSet(SignalDataStru[signalId].szSignalLightUpLinkIdBuf, (UINT32)sizeof(SignalDataStru[signalId].szSignalLightUpLinkIdBuf),0U, (UINT32)sizeof(SignalDataStru[signalId].szSignalLightUpLinkIdBuf));
SignalDataStru[signalId].wSignalLightUpTrainId = 0U;
if ((0U == detainBtnRelayId) || (UINT16_MAX == detainBtnRelayId))
{
SignalDataStru[signalId].DetainBtnActivateFlag = SIGNAL_ZFS_BTN_ACT_FLAG_NO; /*自复式未配置扣车按钮继电器，初始化扣车按钮未激活*/
@@ -591,9 +597,7 @@ UINT8 InitialSignalData(void)
SignalDataStru[signalId].CancelDetainErrTrigPressCycNum = 0U; /*取消扣车按钮误触发按下周期*/
SignalDataStru[signalId].CancelDetainBtnValidFlag = SIGNAL_CANCEL_DETAIN_VALID_NO; /*取消扣车按钮有效标志*/
SignalDataStru[signalId].CancelDetainRelayDownState = SIGNAL_RELAY_ERROR_DOWN_YES; /*取消扣车按钮采集继电器落下状态初始化为异常落下*/
SignalDataStru[signalId].LogRouteSignalErrCloseFlag = LOG_ROUTE_SIGNAL_CLOSE_NOERR; /*初始化为未异常关闭标志(逻辑进路异常关闭使用)*/
SignalDataStru[signalId].VobcCroSigInPhyOccSta = SECTION_OCCUPY_NO; /*初始化信号机内方第一区段为空闲，当占压后再给ZC组确认信息*/
SignalDataStru[signalId].cSleepTrainLightUpFlag = SIGNAL_SLEEP_TRAIN_LIGHTUP_NO; /*初始化休眠车点亮信号机标志无效*/
SignalDataStru[signalId].cInHumidRailFlag = SIGNAL_IN_HUMID_RAIL_NO;
SignalDataStru[signalId].cDetCutBtnState = SIGNAL_DETAIN_CUT_VALID_NO; /*扣车旁路按钮状态*/
SignalDataStru[signalId].DetCutBtnPressCycNum = 0U; /*扣车旁路按钮正常按下周期*/
@@ -603,7 +607,6 @@ UINT8 InitialSignalData(void)
/*初始化信号机临时限速状态有效*/
SignalDataStru[signalId].LinShiXianSuSetFlag = SIGNAL_LINSHIXIANSUSET_STATE_YES;/*临时限速有效*/
routeSum = GetRouteCurSum();
for (jj = 0u; jj < routeSum; jj++)
{
@@ -672,6 +675,21 @@ UINT8 InitialSignalData(void)
{
SignalDataStru[signalId].ProSecValid = SIGNAL_PRO_SEC_INVALID;/*设置成无效导向安全*/
}
/*初始化车车结构体成员*/
SignalDataStruCC[signalId].SignalId = signalId;
SignalDataStruCC[signalId].wSignalLightUpLinkIdSum = 0U;
(void)CommonMemSet(SignalDataStruCC[signalId].szSignalLightUpLinkIdBuf, (UINT32)sizeof(SignalDataStruCC[signalId].szSignalLightUpLinkIdBuf), 0U, (UINT32)sizeof(SignalDataStruCC[signalId].szSignalLightUpLinkIdBuf));
SignalDataStruCC[signalId].wSignalLightUpTrainId = 0U;
SignalDataStruCC[signalId].LogRouteSignalErrCloseFlag = LOG_ROUTE_SIGNAL_CLOSE_NOERR; /*初始化为未异常关闭标志(逻辑进路异常关闭使用)*/
SignalDataStruCC[signalId].cSleepTrainLightUpFlag = SIGNAL_SLEEP_TRAIN_LIGHTUP_NO; /*初始化休眠车点亮信号机标志无效*/
SignalDataStruCC[signalId].LightExtinctState = SIGNAL_LIGHT_EXTICT_STATE_YES; /*信号机亮灭状态CC(0x55：灭灯，0xaa：亮灯)*/
SignalDataStruCC[signalId].SignalCrossState = SIGNAL_CROSS_STATE_NO; /*通信车跨压通过信号机状态CC(0x55：未跨压，0xaa：跨压)*/
/*初始化ZC发送的信号机动态数据*/
gZcToCiDymDataStru.szSignalDataStruZc[signalId].SignalId = signalId;
gZcToCiDymDataStru.szSignalDataStruZc[signalId].LightExtinctState = SIGNAL_LIGHT_EXTICT_STATE_YES;
gZcToCiDymDataStru.szSignalDataStruZc[signalId].SignalCrossState = SIGNAL_CROSS_STATE_NO;
}
/* 设置自动信号属性 */
@@ -761,6 +779,7 @@ UINT8 InitialSwitchData(void)
switchId = GetSwitchId(ii);/*获取配置文件中该索引下的道岔ID*/
SwitchDataStru[switchId].SwitchId = switchId;
SwitchDataStruCC[switchId].SwitchId = switchId;
SwitchDataStru[switchId].YLockState = SWITCH_LOCK_YINZONG_NO;
SwitchDataStru[switchId].LockStatus = SWITCH_LOCK_STATUS_NO;
SwitchDataStru[switchId].FLockState = SWITCH_LOCK_FENGSUO_NO;
@@ -785,7 +804,7 @@ UINT8 InitialSwitchData(void)
SwitchDataStru[switchId].DFHRelayValidCycNum = 0u;
SwitchDataStru[switchId].SigleDFHRelayValidCycNum = 0u;
SwitchDataStru[switchId].PLockedRouteNum = 0u;
SwitchDataStru[switchId].PLockedLogRouteNum = 0u;
SwitchDataStruCC[switchId].PLockedLogRouteNum = 0u;
SwitchDataStru[switchId].PLockedOverlapNum = 0u;
SwitchDataStru[switchId].PLockedNonRouteNum = 0u;
SwitchDataStru[switchId].YCRelayValidCycNum = 0u;
@@ -802,10 +821,16 @@ UINT8 InitialSwitchData(void)
for (jj=0; jj<SWITCH_MAX_PROTECT_LOCKED_NUM;jj++)
{
SwitchDataStru[switchId].PLockedRouteIdArr[jj] = 0u;
SwitchDataStru[switchId].PLockedLogRouteIdArr[jj] = 0u;
SwitchDataStruCC[switchId].PLockedLogRouteIdArr[jj] = 0u;
SwitchDataStru[switchId].PLockedOverlapIdArr[jj] = 0u;
SwitchDataStru[switchId].PLockedNonRouteIdArr[jj] = 0u;
}
/*初始化道岔转辙机数量、状态*/
SwitchDataStru[switchId].chSwitchIncldeZzjNum = 0u;
for (jj = 0; jj < SWITCH_ZZJ_POWER_STATE_MAX_NUM; jj++)
{
SwitchDataStru[switchId].szSwitchIncldeZzjState[jj] = OC_SWITCH_POSITION_SIKAI;
}
}
reVal = CI_SUCCESS;
return reVal;
@@ -862,6 +887,8 @@ UINT8 InitialPhySectionData(void)
PhysicalSectionDataStru[ii].FLockType = PHY_SEC_FLOCK_TYPE_NONE;
PhysicalSectionDataStru[ii].UtOrCtOccFlag = SECTION_OCCUPY_YES;
PhysicalSectionDataStru[ii].UtOrCtOccuStartCycNum = 0u;
PhysicalSectionDataStru[ii].chResetCmdTag = 0U;
PhysicalSectionDataStru[ii].chResetCmdTagBack = 0U;
PhysicalSectionDataStru[ii].PhySecPreResetState = PHYSICAL_SECTION_PRE_RESET_NO;
PhysicalSectionDataStru[ii].chPreResetBack = PHY_RESET_BACK_RECIVE_YES;
PhysicalSectionDataStru[ii].chDirectResetRst = PHYSICAL_DIRECT_RESET_NO;
@@ -887,7 +914,19 @@ UINT8 InitialPhySectionData(void)
{
break;
}
else
{
/*不处理*/
}
/*初始化车车结构体成员*/
PhysicalSectionDataStruCC[phySectionId].PhysicalSectionId = phySectionId;
PhysicalSectionDataStruCC[phySectionId].SecUseBelongLogRouteId = 0U;
PhysicalSectionDataStruCC[phySectionId].StopSteadyFlag = PHYSICAL_SECTION_STOPSTEADY_NO;
/*初始化ZC发送的物理区段动态数据*/
gZcToCiDymDataStru.PhysicalSectionDataStruZc[phySectionId].PhysicalSectionId = phySectionId;
gZcToCiDymDataStru.PhysicalSectionDataStruZc[phySectionId].StopSteadyFlag = PHYSICAL_SECTION_STOPSTEADY_NO;
}
#if 0
@@ -950,15 +989,22 @@ UINT8 InitialAxisSectionData(void)
AxisSectionDataStru[axisSectionId].AxisArbState = AXIS_SECTION_ARB_NO;
AxisSectionDataStru[axisSectionId].BelongCiId = GetPhySecBelongCiId(belongPhySecId);
AxisSectionDataStru[axisSectionId].BelongVirCIid = GetPhySecBelongVirCiId(belongPhySecId);
AxisSectionDataStru[axisSectionId].AxisJumpLockApplyFlag = AXIS_SECTION_JUMPLOCK_APPLY_NO;
AxisSectionDataStru[axisSectionId].AxisJumpLockCancelApplyFlag = AXSEC_CANCEL_JUMPLOCK_APPLY_NO;
AxisSectionDataStru[axisSectionId].AxisJumpLockApplyCylce = 0u;
AxisSectionDataStru[axisSectionId].AxisJumpLockState = AXIS_SECTION_JUMPLOCK_STATE_IDLE;
AxisSectionDataStru[axisSectionId].AxisOccStatus = AXIS_SECTION_OCCUPY_YES;
AxisSectionDataStru[axisSectionId].dwAxisOccCycNum = 0U;
AxisSectionDataStru[axisSectionId].wPosMonitorTrainId = 0U;
AxisSectionDataStru[axisSectionId].dwUtOccupyCycNum = 0U;
/*初始化车车结构体成员*/
AxisSectionDataStruCC[axisSectionId].AxisSectionId = axisSectionId;
AxisSectionDataStruCC[axisSectionId].AxisOccStatus = AXIS_SECTION_OCCUPY_YES;
AxisSectionDataStruCC[axisSectionId].dwAxisOccCycNum = 0U;
AxisSectionDataStruCC[axisSectionId].wPosMonitorTrainId = 0U;
AxisSectionDataStruCC[axisSectionId].dwUtOccupyCycNum = 0U;
AxisSectionDataStruCC[axisSectionId].AxisArbState = AXIS_SECTION_ARB_NO;
/*初始化ZC发送的计轴区段动态数据*/
gZcToCiDymDataStru.AxisSectionDataStruZc[axisSectionId].AxisSectionId = axisSectionId;
gZcToCiDymDataStru.AxisSectionDataStruZc[axisSectionId].AxisArbState = AXIS_SECTION_ARB_NO;
}
reVal = CI_SUCCESS;
return reVal;
@@ -1020,39 +1066,51 @@ UINT8 InitialLogicSectionData(void)
LogicSectionDataStru[logicSectionId].LogUnlockStartCycNum = 0u;
LogicSectionDataStru[logicSectionId].wPLockBelongRouteId = 0u;
LogicSectionDataStru[logicSectionId].OtherCiPLockBelongRouteId = 0U;
LogicSectionDataStru[logicSectionId].chResShareFlag = LOGIC_SECTION_RES_SHARE_NO;
LogicSectionDataStru[logicSectionId].JumpLockTrainId = 0u;
LogicSectionDataStru[logicSectionId].LogJumpLockState = LOGIC_SECTION_JUMP_LOCK_NO;
LogicSectionDataStru[logicSectionId].LogJumpLockDelayUnlockFlag = LOGIC_JUMPUNLOCK_DELAY_SET_NO;
LogicSectionDataStru[logicSectionId].LogSecJumpDelayUnlockStartCyc = 0u;
LogicSectionDataStru[logicSectionId].LogSecJumpLockPermFlag = LOGIC_JUMPUNLOCK_PERMISSIVE_NO;
LogicSectionDataStru[logicSectionId].chXianSuRemoveState = LOGIC_XIANSU_REMOVE_NO;
LogicSectionDataStru[logicSectionId].chTrainInfoSum = 0u;
LogicSectionDataStru[logicSectionId].chArbState = LGC_SECTION_ARB_NO;
LogicSectionDataStru[logicSectionId].LogErrlockStartCycNum = 0U;
LogicSectionDataStru[logicSectionId].chLogicProResUsable = LOGIC_SECTION_PRO_RES_UNUSABLE;
LogicSectionDataStru[logicSectionId].chLogicSpksFLockState = LOGIC_SECTION_SPKS_FLOCK_NO;/*仅用于ATS显示；逻辑区段不一定关联SPKS，如果初始化成封锁，无法获取SPKS状态，此逻辑区段会一直为封锁状态*/
LogicSectionDataStru[logicSectionId].chAblRelLogSecUsableFlag = LOGIC_ABLNEAR_USE_FLAG_NO; /*初始化ABL接近逻辑区段可用标志*/
LogicSectionDataStru[logicSectionId].cRouteLeaveLogFlag = LOGSEC_LEAVE_LOGSEC_REPLY_NO; /*离去区段ABL列车检查不通过*/
LogicSectionDataStru[logicSectionId].chLinShiXianSuSetSpeed = 0U; /*逻辑区段临时限速设置速度值*/
LogicSectionDataStru[logicSectionId].chLogSecEmergXianSu = LOGSEC_EMERG_XS_SET_NO; /*逻辑区段紧急临时限速*/
/*初始化车车结构体成员*/
LogicSectionDataStruCC[logicSectionId].LogicSectionId = logicSectionId;
LogicSectionDataStruCC[logicSectionId].chResShareFlag = LOGIC_SECTION_RES_SHARE_NO;
LogicSectionDataStruCC[logicSectionId].JumpLockTrainId = 0u;
LogicSectionDataStruCC[logicSectionId].LogJumpLockState = LOGIC_SECTION_JUMP_LOCK_NO;
LogicSectionDataStruCC[logicSectionId].LogJumpLockDelayUnlockFlag = LOGIC_JUMPUNLOCK_DELAY_SET_NO;
LogicSectionDataStruCC[logicSectionId].LogSecJumpDelayUnlockStartCyc = 0u;
LogicSectionDataStruCC[logicSectionId].LogSecJumpLockPermFlag = LOGIC_JUMPUNLOCK_PERMISSIVE_NO;
LogicSectionDataStruCC[logicSectionId].chTrainInfoSum = 0u;
LogicSectionDataStruCC[logicSectionId].LogErrlockStartCycNum = 0U;
LogicSectionDataStruCC[logicSectionId].chAblRelLogSecUsableFlag = LOGIC_ABLNEAR_USE_FLAG_NO; /*初始化ABL接近逻辑区段可用标志*/
LogicSectionDataStruCC[logicSectionId].cRouteLeaveLogFlag = LOGSEC_LEAVE_LOGSEC_REPLY_NO; /*离去区段ABL列车检查不通过*/
for (jj = 0U; jj < LOGIC_SECTION_RES_SUM_MAX; jj++)
{
LogicSectionDataStru[logicSectionId].szTrainResData[jj].wTrainId = 0U;
LogicSectionDataStru[logicSectionId].szTrainResData[jj].chLogicResUsable = LOGIC_SECTION_RES_UNUSABLE;
LogicSectionDataStru[logicSectionId].szTrainResData[jj].chLogicReturnState = LOGIC_SECTION_TRAIN_RETURN_NO ;
LogicSectionDataStru[logicSectionId].szTrainResData[jj].chTrainApplyState = LOGIC_SECTION_TRAIN_APPLY_NO;
LogicSectionDataStru[logicSectionId].szTrainResData[jj].chLogicUnlockState = LOGIC_SECTION_TRAIN_UNLOCK_NO;
LogicSectionDataStru[logicSectionId].szTrainResData[jj].dwRcvUnlockCmdCyc = 0U;
LogicSectionDataStruCC[logicSectionId].szTrainResData[jj].wTrainId = 0U;
LogicSectionDataStruCC[logicSectionId].szTrainResData[jj].chLogicResUsable = LOGIC_SECTION_RES_UNUSABLE;
LogicSectionDataStruCC[logicSectionId].szTrainResData[jj].chLogicReturnState = LOGIC_SECTION_TRAIN_RETURN_NO;
LogicSectionDataStruCC[logicSectionId].szTrainResData[jj].chTrainApplyState = LOGIC_SECTION_TRAIN_APPLY_NO;
LogicSectionDataStruCC[logicSectionId].szTrainResData[jj].chLogicUnlockState = LOGIC_SECTION_TRAIN_UNLOCK_NO;
LogicSectionDataStruCC[logicSectionId].szTrainResData[jj].dwRcvUnlockCmdCyc = 0U;
}
LogicSectionDataStru[logicSectionId].chLogSecLockBelLogRouteSum = 0U;
LogicSectionDataStruCC[logicSectionId].chLogSecLockBelLogRouteSum = 0U;
for (jj = 0U; jj < LOGSEC_RELATE_ROUTE_SUM_MAX; jj++)
{
LogicSectionDataStru[logicSectionId].szLogSecLockBelLogRouteData[jj].wLogSecLockBelLogRouteId = 0U;
LogicSectionDataStru[logicSectionId].szLogSecLockBelLogRouteData[jj].chLogSecLockBelLogRouteState = ROUTE_LOGICAL_STATE_IDLE;
LogicSectionDataStru[logicSectionId].szLogSecLockBelLogRouteData[jj].wLogSecLockBelLogRouteDir = CI_SYSTEM_DIRECTION_NONE;
LogicSectionDataStruCC[logicSectionId].szLogSecLockBelLogRouteData[jj].wLogSecLockBelLogRouteId = 0U;
LogicSectionDataStruCC[logicSectionId].szLogSecLockBelLogRouteData[jj].chLogSecLockBelLogRouteState = ROUTE_LOGICAL_STATE_IDLE;
LogicSectionDataStruCC[logicSectionId].szLogSecLockBelLogRouteData[jj].wLogSecLockBelLogRouteDir = CI_SYSTEM_DIRECTION_NONE;
}
LogicSectionDataStruCC[logicSectionId].LogSecLogLockState = LOG_SECTION_LOGLOCK_NO;
LogicSectionDataStruCC[logicSectionId].LinShiXianSuSetFlag = LOGSEC_LSXS_SET_STATE_NO; /*CI初始化为未设置临时限速，RC在下边再根据TMC开关重新初始化*/
LogicSectionDataStruCC[logicSectionId].OccupyState = LOGICSECTION_OCCUPY_UT;
LogicSectionDataStruCC[logicSectionId].TXOccupyState = LOGICSECTION_OCCUPY_NO_TX; /*非通信车占用状态*/
LogicSectionDataStru[logicSectionId].LogSecLogLockState = LOG_SECTION_LOGLOCK_NO;
/*初始化ZC发送的逻辑区段动态数据*/
gZcToCiDymDataStru.LogicSectionDataStruZc[logicSectionId].LogicSectionId = logicSectionId;
gZcToCiDymDataStru.LogicSectionDataStruZc[logicSectionId].LinShiXianSuSetFlag = LOGSEC_LSXS_SET_STATE_NO; /*先初始化为未设置临时限速，CI在下边再根据开关重新初始化*/
gZcToCiDymDataStru.LogicSectionDataStruZc[logicSectionId].OccupyState = LOGICSECTION_OCCUPY_UT;
gZcToCiDymDataStru.LogicSectionDataStruZc[logicSectionId].TXOccupyState = LOGICSECTION_OCCUPY_NO_TX;
}
@@ -1065,10 +1123,14 @@ UINT8 InitialLogicSectionData(void)
if (FUNC_SWITCH_OFF == chTmcSwitch)
{
LogicSectionDataStru[logicSectionId].LinShiXianSuSetFlag = LOGSEC_LSXS_SET_STATE_NO;
LogicSectionDataStruCC[logicSectionId].LinShiXianSuSetFlag = LOGSEC_LSXS_SET_STATE_NO;
gZcToCiDymDataStru.LogicSectionDataStruZc[logicSectionId].LinShiXianSuSetFlag = LOGSEC_LSXS_SET_STATE_NO;
}
else
{
LogicSectionDataStru[logicSectionId].LinShiXianSuSetFlag = LOGSEC_LSXS_SET_STATE_YES;
LogicSectionDataStruCC[logicSectionId].LinShiXianSuSetFlag = LOGSEC_LSXS_SET_STATE_YES;
gZcToCiDymDataStru.LogicSectionDataStruZc[logicSectionId].LinShiXianSuSetFlag = LOGSEC_LSXS_SET_STATE_YES;
}
}
@@ -1131,10 +1193,14 @@ UINT8 InitialLogicSectionData(void)
{
LogicSectionDataStru[logicSectionId].LinShiXianSuSetFlag = LOGSEC_LSXS_SET_STATE_YES;
SetWholeLineLinShiXianSuFlag(WHOLE_LINE_LINSHIXIANSUSET_YES);/*本集中区有逻辑区段:有临时限速属性*/
LogicSectionDataStruCC[logicSectionId].LinShiXianSuSetFlag = LOGSEC_LSXS_SET_STATE_YES;
gZcToCiDymDataStru.LogicSectionDataStruZc[logicSectionId].LinShiXianSuSetFlag = LOGSEC_LSXS_SET_STATE_YES;
}
else
{
LogicSectionDataStru[logicSectionId].LinShiXianSuSetFlag = LOGSEC_LSXS_SET_STATE_NO;
LogicSectionDataStruCC[logicSectionId].LinShiXianSuSetFlag = LOGSEC_LSXS_SET_STATE_NO;
gZcToCiDymDataStru.LogicSectionDataStruZc[logicSectionId].LinShiXianSuSetFlag = LOGSEC_LSXS_SET_STATE_NO;
}
break;
}
@@ -1151,6 +1217,8 @@ UINT8 InitialLogicSectionData(void)
if (jj > zcToCiMaskSum)
{
LogicSectionDataStru[logicSectionId].LinShiXianSuSetFlag = LOGSEC_LSXS_SET_STATE_INVALID;
LogicSectionDataStruCC[logicSectionId].LinShiXianSuSetFlag = LOGSEC_LSXS_SET_STATE_INVALID;
gZcToCiDymDataStru.LogicSectionDataStruZc[logicSectionId].LinShiXianSuSetFlag = LOGSEC_LSXS_SET_STATE_INVALID;
}
else
{
@@ -1225,6 +1293,7 @@ UINT8 InitialFloodGateData(void)
if ((0u < floodGateId) && (FLOOD_GATE_SUM_MAX> floodGateId))
{
FloodGateDataStru[floodGateId].FloodGateId = floodGateId;
FloodGateDataStruCC[floodGateId].FloodGateId = floodGateId;
FloodGateDataStru[floodGateId].CurAgreeCloseAckFromZC = FLOOD_GATE_NOT_ALLOWCLOSE_ZC;
FloodGateDataStru[floodGateId].CurAgreeCloseStateIn = FLOOD_GATE_NOT_AGREE_CLOSE;
FloodGateDataStru[floodGateId].CurAgreeCloseStateOut = FLOOD_GATE_NOT_AGREE_CLOSE;
@@ -1232,15 +1301,15 @@ UINT8 InitialFloodGateData(void)
FloodGateDataStru[floodGateId].CurOpenLockStateFromFYM = FLOOD_GATE_NOT_OPENLOCK;
FloodGateDataStru[floodGateId].CurYGJCrossLineStartCount = 0u;/*混线开始时间置为0*/
FloodGateDataStru[floodGateId].CurFloodGateDelayCloseStartCyc = 0u;/*防淹门接近区段占压延时关门开始时间置为0*/
FloodGateDataStru[floodGateId].FloodGateCloseApplyIvocSum = 0u;/*防淹门关门申请列车数量置为0*/
FloodGateDataStruCC[floodGateId].FloodGateCloseApplyIvocSum = 0u;/*防淹门关门申请列车数量置为0*/
for (jj = 0U; jj < FLOOD_GATE_APPLY_TRAIN_SUM_MAX; jj++)
{
FloodGateDataStru[floodGateId].FloodGateCloseApplyIvocId[jj] = 0u;/*防淹门关门申请列车ID置为0*/
FloodGateDataStru[floodGateId].FloodGateCloseFromIvocStru[jj].wTrainId = 0u; /*防淹门关门回复列车ID置为0*/
FloodGateDataStru[floodGateId].FloodGateCloseFromIvocStru[jj].wFloodGateCloseIvocFlag = FLOOD_GATE_NOT_ALLOWCLOSE_IVOC; /*防淹门关门回复标志置为不允许*/
FloodGateDataStruCC[floodGateId].FloodGateCloseApplyIvocId[jj] = 0u;/*防淹门关门申请列车ID置为0*/
FloodGateDataStruCC[floodGateId].FloodGateCloseFromIvocStru[jj].wTrainId = 0u; /*防淹门关门回复列车ID置为0*/
FloodGateDataStruCC[floodGateId].FloodGateCloseFromIvocStru[jj].wFloodGateCloseIvocFlag = FLOOD_GATE_NOT_ALLOWCLOSE_IVOC; /*防淹门关门回复标志置为不允许*/
}
FloodGateDataStru[floodGateId].FloodGateAccessUTFlag = FLOOD_GATE_ACCESS_UT_YES;/*防淹门接近区段占压是否有UT占压标志*/
FloodGateDataStru[floodGateId].FloodGateCloseAnsIvocSum = 0u;/*防淹门关门回复列车数量置为0*/
FloodGateDataStruCC[floodGateId].FloodGateAccessUTFlag = FLOOD_GATE_ACCESS_UT_YES;/*防淹门接近区段占压是否有UT占压标志*/
FloodGateDataStruCC[floodGateId].FloodGateCloseAnsIvocSum = 0u;/*防淹门关门回复列车数量置为0*/
}
else
{
@@ -1266,7 +1335,7 @@ UINT8 InitialPsdData(void)
UINT8 psdVirtual = 0u;
UINT16 wPsdButtenRelayId = 0u;
UINT16 wCleFarePCBButRelayId = 0U;/*清客确认箱关门按钮继电器ID*/
UINT16 wPsdButtenRelayId2 = 0U;
psdDataSum = GetTotalPsdCurNum();/*本联锁和相邻联锁发送给本联锁的Psd总数目*/
/*数值大于等于PSD_SUM_MAX会返回0*/
@@ -1293,7 +1362,9 @@ UINT8 InitialPsdData(void)
}
wPsdButtenRelayId = GetPsdReOpenRelayId(psdId);
if ((0u == wPsdButtenRelayId) || (UINT16_MAX == wPsdButtenRelayId))
wPsdButtenRelayId2 = GetPsdReOpenRelayId2(psdId);
if (((0u == wPsdButtenRelayId) || (UINT16_MAX == wPsdButtenRelayId))
&& ((0u == wPsdButtenRelayId2) || (UINT16_MAX == wPsdButtenRelayId2)))
{
PsdDataStru[psdId].doorOpenButtonState = PSD_OPEN_BUTTON_STATE_INVALID;
}
@@ -1384,6 +1455,13 @@ UINT8 InitialPsdData(void)
PsdDataStru[psdId].cPsdExceptOpenState = PSD_EXCEPT_OPEN_YES; /*初始化为PSD异常打开*/
PsdDataStru[psdId].dwPsdRelayDownCycNum = 0U; /*PSD门关继电器落下起始周期*/
/*初始化车车结构体成员*/
PsdDataStruCC[psdId].PsdId = psdId;
PsdDataStruCC[psdId].psdEditGroupInfo = 0U; /*psd编组信息初始化为0*/
PsdDataStruCC[psdId].SrcVobcId = 0U;
PsdDataStruCC[psdId].PsdCmd = PSD_DEFAULT_CONTROL_CMD;
PsdDataStruCC[psdId].CmdSetCycle = 0U;
}
reVal = CI_SUCCESS;
return reVal;
@@ -1473,13 +1551,14 @@ UINT8 InitialOverlapData(void)
overlapId = GetOverlapId(ii);/*获取配置文件中该索引下的保护区段ID*/
OverlapDataStru[overlapId].OverlapId = overlapId;
OverlapDataStruCC[overlapId].OverlapId = overlapId;
OverlapDataStru[overlapId].BelongRouteId = 0u;
OverlapDataStru[overlapId].UnlockStartCycNum = 0u;
OverlapDataStru[overlapId].XuanPaiStartCycNum = 0u;
OverlapDataStru[overlapId].OverlapUnlockApplyFlag = UNLOCK_OVERLAP_APPLY_NO;
OverlapDataStru[overlapId].wOverlapUnlockApplyTrainId = 0U;
OverlapDataStru[overlapId].dwReqIvocUnLockStartCycNum = 0U;
OverlapDataStru[overlapId].cIvocAllowUnlockFlag = IVOC_ALLOW_UNLOCK_OVERLAP_NO;
OverlapDataStruCC[overlapId].wOverlapUnlockApplyTrainId = 0U;
OverlapDataStruCC[overlapId].dwReqIvocUnLockStartCycNum = 0U;
OverlapDataStruCC[overlapId].cIvocAllowUnlockFlag = IVOC_ALLOW_UNLOCK_OVERLAP_NO;
OverlapDataStru[overlapId].OverlapCanLaborUnlockFlag = CANNOT_LABOR_UNLOCK_OVERLAP;
OverlapDataStru[overlapId].OverlapLaborUnlockSetState = LABOR_UNLOCK_OVERLAP_NO;
OverlapDataStru[overlapId].laborUnlockStartCycNum = 0u;
@@ -1489,6 +1568,7 @@ UINT8 InitialOverlapData(void)
OverlapDataStru[overlapId].laborLockOverlapCmd = LOCK_OVERLAP_CMD_NO;
OverlapDataStru[overlapId].cProSwitchCheckResultFlag = PROSWITCH_CHECK_RESULT_DEFAULT;
OverlapDataStru[overlapId].cProSwitchCheckStartFlag = PROSWITCH_CHECK_START_INVALID;
OverlapDataStru[overlapId].chPreLaborUnlockState = PRO_PRE_LABOR_UNLOCK_STATE_NO;
}
}
@@ -1518,7 +1598,8 @@ UINT8 InitialRouteData(void)
}
else
{
(void)memset(RouteDataStru,0,sizeof(RouteDataStru));
(void)CommonMemSet(RouteDataStru, sizeof(RouteDataStru),0U,sizeof(RouteDataStru));
(void)CommonMemSet(RouteDataStruCC, sizeof(RouteDataStruCC),0U, sizeof(RouteDataStruCC));
for (ii = 0u; ii < routeSum; ii++)
{
routeId = GetRouteId(ii);/*获取索引下的进路ID*/
@@ -1532,7 +1613,6 @@ UINT8 InitialRouteData(void)
RouteDataStru[routeId].RouteLevelChangeCyc = 0U;
RouteDataStru[routeId].AutoRouteId = 0u;
RouteDataStru[routeId].AutoReturnId = 0u;
RouteDataStru[routeId].XuanPaiStartCycNum = 0u;
RouteDataStru[routeId].RouteLockStartCycNum = 0u;
RouteDataStru[routeId].OverlapLockStartCycNum = 0u;
@@ -1567,35 +1647,43 @@ UINT8 InitialRouteData(void)
RouteDataStru[routeId].CancleDelayflag = ROUTE_ZQX_DELAY_NO; /*取消进路无延时解锁*/
RouteDataStru[routeId].AutoSigCancleState = AUTO_ROUTE_CANCLE_NO; /*自动信号取消状态为无效*/
RouteDataStru[routeId].CancleAutoSigCmd = AUTO_ROUTE_CANCLE_CMD_NO; /*设置自动信号取消命令无效*/
RouteDataStru[routeId].wStopEnsureTrainId = 0u;
RouteDataStru[routeId].dwStopEnsureCyc = 0u;
RouteDataStru[routeId].cResReqOtherCIId = 0u;
for (k = 0u; k < ROUTE_APPLY_RECD_TRAIN_SUM_MAX; k++)
{
RouteDataStru[routeId].wszResReqTrainId[k] = 0u;
}
RouteDataStru[routeId].ITSRouteApplyTrainIdSum = 0u;
for (k = 0u; k < ROUTE_APPLY_RECD_TRAIN_SUM_MAX; k++)
{
RouteDataStru[routeId].ITSRouteApplyTrainIdBuf[k] = 0u;
}
/*cgh-合并CID-2539-10：*/
RouteDataStru[routeId].OverlapNeedCIlockFlag = OVERLAPCILOCK_NO; /*保护区段联锁锁闭标志无效*/
RouteDataStru[routeId].OverlapLockProcFlag = OVERLAP_LOCK_PROC_NO; /*保护区段不在锁闭过程中*/
RouteDataStru[routeId].GroupRouteCmdFlag = ROUTE_GROUPROUTE_CMD_NO; /*进路不存在组合进路命令标志*/
RouteDataStru[routeId].AutoTriggerFlag = AUTO_TRIGGER_SET_NO; /*进路没有设置自动触发标志*/
RouteDataStru[routeId].dwFirstElockStartCycNum = 0U; /*进路第一个锁闭的逻辑区段延时设置区段故障起始周期号*/
RouteDataStru[routeId].cRelZuHeRouteSGBJDelayFlag = ROUTE_SGBJ_DELAY_OPEN_VALID; /*关联组合进路声光报警延时标志有效*/
RouteDataStru[routeId].dwDelayOpenStartCycNum = 0U; /*声光报警进路延时开放延时起始周期*/
RouteDataStru[routeId].cRouteNeedDriveSGBJFlag = ROUTE_DRIVE_SGBJ_INVALID; /*进路驱动声光报警标志无效*/
RouteDataStru[routeId].cRouteDrivedSGBJFlag = ROUTE_HAS_DRIVED_SGBJ_INVALID; /*初始化进路未驱动过声光报警*/
RouteDataStru[routeId].chRouteNearSecSearchState = ROUTE_NEAR_SEC_HAVE_UT; /*初始化进路接近区段查询状态为有故障车*/
RouteDataStru[routeId].chRouteApplySwitchCheckFlag = ROUTE_APPLY_SWITCH_CHECK_DEF; /*初始化进路办理相邻控区道岔检查标志*/
RouteDataStru[routeId].OtherCiRecordDevID = 0U;
RouteDataStru[routeId].OtherCiRecordDevState = 0U;
RouteDataStru[routeId].OtherCiRecordDevType = 0U;
RouteDataStru[routeId].OtherCiRecordErrorType = 0U;
RouteDataStru[routeId].cRouteToLeadFlag = ROUTE_TO_LEAD_FLAG_NO; /*初始化普通进路转引导进路标志为无效*/
RouteDataStru[routeId].chRoutCouplinkFlag = ROUTE_COUPLINK_FLAG_NO; /*初始化联挂标志无效*/
RouteDataStru[routeId].chCouplinkSuccessFlag = ROUTE_COUPLINK_RESULT_NOT; /*初始化联挂成功标志为未收到*/
RouteDataStru[routeId].chCouplinkErrorFlag = ROUTE_COUPLINK_RESULT_NOT; /*初始化联挂失败标志为未收到*/
/*初始化车车结构体成员*/
RouteDataStruCC[routeId].RouteId = routeId;
RouteDataStruCC[routeId].wStopEnsureTrainId = 0u;
RouteDataStruCC[routeId].dwStopEnsureCyc = 0u;
RouteDataStruCC[routeId].cResReqOtherCIId = 0u;
for (k = 0u; k < ROUTE_APPLY_RECD_TRAIN_SUM_MAX; k++)
{
RouteDataStruCC[routeId].wszResReqTrainId[k] = 0u;
}
RouteDataStruCC[routeId].ITSRouteApplyTrainIdSum = 0u;
for (k = 0u; k < ROUTE_APPLY_RECD_TRAIN_SUM_MAX; k++)
{
RouteDataStruCC[routeId].ITSRouteApplyTrainIdBuf[k] = 0u;
}
RouteDataStruCC[routeId].dwFirstElockStartCycNum = 0U; /*进路第一个锁闭的逻辑区段延时设置区段故障起始周期号*/
RouteDataStruCC[routeId].chRouteNearSecSearchState = ROUTE_NEAR_SEC_HAVE_UT; /*初始化进路接近区段查询状态为有故障车*/
RouteDataStruCC[routeId].StopensureFlag = ROUTE_STOPENSURE_NO;
/*初始化ZC发送的进路动态数据*/
gZcToCiDymDataStru.szRouteDataStruZc[routeId].RouteId = routeId;
gZcToCiDymDataStru.szRouteDataStruZc[routeId].StopensureFlag = ROUTE_STOPENSURE_NO;
}
}
@@ -1881,6 +1969,12 @@ UINT8 InitialTransmitStateData(void)
InitHlhtHeadCtx(CI_SYSTEM_TYPE_TMC);
InitHlhtHeadCtx(CI_SYSTEM_TYPE_AXIS);
InitHlhtHeadCtx(CI_SYSTEM_TYPE_CI);
InitHlhtHeadCtx(CI_SYSTEM_TYPE_RC);
InitHlhtHeadCtx(CI_SYSTEM_TYPE_ZC);
InitHlhtHeadCtx(CI_SYSTEM_TYPE_OC);
InitHlhtHeadCtx(CI_SYSTEM_TYPE_ATS);
InitHlhtHeadCtx(CI_SYSTEM_TYPE_XIANDI);
}
return reVal;
@@ -2196,9 +2290,9 @@ void ResetDynamicState(const UINT8 ciId)
}
}
if (LOG_SECTION_LOGLOCK_NORMAL == LogicSectionDataStru[logicSectionId].LogSecLogLockState)
if (LOG_SECTION_LOGLOCK_NORMAL == LogicSectionDataStruCC[logicSectionId].LogSecLogLockState)
{
LogicSectionDataStru[logicSectionId].LogSecLogLockState = LOG_SECTION_LOGLOCK_EXCEPT; /*与相邻联锁断通信，将相邻联锁逻辑正常锁闭的逻辑区段置为逻辑异常锁闭*/
LogicSectionDataStruCC[logicSectionId].LogSecLogLockState = LOG_SECTION_LOGLOCK_EXCEPT; /*与相邻联锁断通信，将相邻联锁逻辑正常锁闭的逻辑区段置为逻辑异常锁闭*/
}
if ((localCi !=phyBelongCi) && (TRANSMIT_STATE_BAD == commState) &&
@@ -2219,14 +2313,15 @@ void ResetDynamicState(const UINT8 ciId)
LogicSectionDataStru[logicSectionId].OccupyState = LOGICSECTION_OCCUPY_UT; /*占用状态*/
LogicSectionDataStru[logicSectionId].TXOccupyState = LOGICSECTION_OCCUPY_NO_TX; /*TSCI合并添加 20221208-lc*/
}
/*逻辑区段：占用、设置临时限速、未ARB*/
/*逻辑区段：占用、设置临时限速、未ARB、紧急临时限速有效*/
LogicSectionDataStru[logicSectionId].LinShiXianSuSetFlag= LOGSEC_LSXS_SET_STATE_YES; /*逻辑区段临时限速设置状态*/
LogicSectionDataStru[logicSectionId].chLinShiXianSuSetSpeed = 0U; /*逻辑区段临时限速设置速度值*/
LogicSectionDataStru[logicSectionId].chXianSuRemoveState = LOGIC_XIANSU_REMOVE_NO;
LogicSectionDataStru[logicSectionId].chArbState = LGC_SECTION_ARB_NO; /* 设置未ARB */
LogicSectionDataStru[logicSectionId].chAblRelLogSecUsableFlag = LOGIC_ABLNEAR_USE_FLAG_NO;
LogicSectionDataStru[logicSectionId].cRouteLeaveLogFlag = LOGSEC_LEAVE_LOGSEC_REPLY_NO; /*离去区段ABL列车检查不通过*/
LogicSectionDataStruCC[logicSectionId].chAblRelLogSecUsableFlag = LOGIC_ABLNEAR_USE_FLAG_NO;
LogicSectionDataStruCC[logicSectionId].cRouteLeaveLogFlag = LOGSEC_LEAVE_LOGSEC_REPLY_NO; /*离去区段ABL列车检查不通过*/
LogicSectionDataStru[logicSectionId].chLogicProResUsable = LOGIC_SECTION_PRO_RES_UNUSABLE;
LogicSectionDataStru[logicSectionId].chLogSecEmergXianSu = LOGSEC_EMERG_XS_SET_YES; /*逻辑区段紧急临时限速设置状态*/
}
else
{
@@ -2475,9 +2570,9 @@ void ResetDynamicState(const UINT8 ciId)
OverlapDataStru[devId].UnlockStartCycNum = 0u;
OverlapDataStru[devId].XuanPaiStartCycNum = 0u;
OverlapDataStru[devId].OverlapUnlockApplyFlag = UNLOCK_OVERLAP_APPLY_NO;
OverlapDataStru[devId].wOverlapUnlockApplyTrainId = 0U;
OverlapDataStru[devId].dwReqIvocUnLockStartCycNum = 0U;
OverlapDataStru[devId].cIvocAllowUnlockFlag = IVOC_ALLOW_UNLOCK_OVERLAP_NO;
OverlapDataStruCC[devId].wOverlapUnlockApplyTrainId = 0U;
OverlapDataStruCC[devId].dwReqIvocUnLockStartCycNum = 0U;
OverlapDataStruCC[devId].cIvocAllowUnlockFlag = IVOC_ALLOW_UNLOCK_OVERLAP_NO;
OverlapDataStru[devId].OverlapCanLaborUnlockFlag = CANNOT_LABOR_UNLOCK_OVERLAP;
OverlapDataStru[devId].OverlapLaborUnlockSetState = LABOR_UNLOCK_OVERLAP_NO;
OverlapDataStru[devId].laborUnlockStartCycNum = 0u;
@@ -2487,6 +2582,7 @@ void ResetDynamicState(const UINT8 ciId)
OverlapDataStru[devId].laborLockOverlapCmd = LOCK_OVERLAP_CMD_NO;
OverlapDataStru[devId].cProSwitchCheckResultFlag = PROSWITCH_CHECK_RESULT_INVALID;
OverlapDataStru[devId].cProSwitchCheckStartFlag = PROSWITCH_CHECK_START_INVALID;
OverlapDataStru[devId].chPreLaborUnlockState = PRO_PRE_LABOR_UNLOCK_STATE_NO;
}
else if ((chOverlapCiId == localCi) && (devId > 0U) && (devId < OVERLAP_SUM_MAX))
{
@@ -2661,17 +2757,18 @@ UINT8 InitialGaragedoorData(void)
garagedoorId = GetGaragedoorId(ii);/*获取配置文件中该索引下的车库门ID*/
GaragedoorDataStru[garagedoorId].GaragedoorId = garagedoorId; /*车库门ID (初始化字段)*/
GaragedoorDataStruCC[garagedoorId].GaragedoorId = garagedoorId; /*车库门ID (初始化字段)*/
GaragedoorDataStru[garagedoorId].GaragedoorState = GARAGE_DOOR_STATE_CLOSE; /*车库门状态 (动态字段)*/
GaragedoorDataStru[garagedoorId].GaragedoorModeState = GARAGE_DOOR_STATE_MODE_LOCAL; /*车库门模式状态*/
GaragedoorDataStru[garagedoorId].GaragedoorFaultState = GARAGE_DOOR_FAULT_TRUE; /*车库门故障状态*/
GaragedoorDataStru[garagedoorId].GDAkuNearestTrainId = NAME_FAILUREAREA; /*A库轨最接近车库门的列车ID*/
GaragedoorDataStruCC[garagedoorId].GDAkuNearestTrainId = NAME_FAILUREAREA; /*A库轨最接近车库门的列车ID*/
GaragedoorDataStru[garagedoorId].GaragedoorAllowCloseFlag = GARAGE_DOOR_ALLOW_CLOSE_NO; /*车库门允许关门标志ZC*/
GaragedoorDataStru[garagedoorId].GDAllowCloseFlagIVOC = GARAGE_DOOR_ALLOW_CLOSE_NO; /*车库门允许关门标志IVOC*/
GaragedoorDataStruCC[garagedoorId].GDAllowCloseFlagIVOC = GARAGE_DOOR_ALLOW_CLOSE_NO; /*车库门允许关门标志IVOC*/
GaragedoorDataStru[garagedoorId].drvDoorState = GARAGE_DOOR_DRV_NULL; /* 驱动车库门状态*/
GaragedoorDataStru[garagedoorId].cmdProcessState = GARAGE_DOOR_CMD_NULL; /* 命令处理状态 */
GaragedoorDataStru[garagedoorId].drvDoorStartCycle = 0u; /* 驱动开始时间,预留 */
GaragedoorDataStru[garagedoorId].waiteZCResponseStartCycNum = 0u; /*等待ZC反馈开始时间*/
GaragedoorDataStru[garagedoorId].waiteIVOCResponseStartCycNum = 0u; /*等待IVOC反馈开始时间*/
GaragedoorDataStruCC[garagedoorId].waiteIVOCResponseStartCycNum = 0u; /*等待IVOC反馈开始时间*/
GaragedoorDataStru[garagedoorId].GaragedoorOpenStartCycNum = 0u; /*车库门打开开始周期*/
GaragedoorDataStru[garagedoorId].GaragedoorCloseStartCycNum = 0u; /*车库门关闭开始周期*/
GaragedoorDataStru[garagedoorId].GaragedoorPangLuState = GARAGE_DOOR_PANGLU_FALSE; /*车库门旁路状态*/
@@ -2863,17 +2960,17 @@ void InitOcData(void)
m_OcToCiOrginDataArr[i].OcId = 0u;
m_OcToCiOrginDataArr[i].OcDeviceNum = 0u;
m_OcToCiOrginDataArr[i].OcDIBoardDataNum = 0u;
m_OcToCiOrginDataArr[i].OcSIBoardDataNum = 0u;
m_OcToCiOrginDataArr[i].OcDOBoardNum = 0u;
m_OcToCiOrginDataArr[i].OcSOBoardNum = 0u;
m_OcToCiOrginDataArr[i].OcSORBoardNum = 0u;
m_OcToCiOrginDataArr[i].OcGdNum = 0u;
m_OcToCiOrginDataArr[i].RecvErrorDevTypeCycle = 0u;
m_OcToCiOrginDataArr[i].PowerAState = (UINT8)0xFF;
m_OcToCiOrginDataArr[i].PowerBState = (UINT8)0xFF;
m_OcToCiOrginDataArr[i].OCDevFaultState = (UINT8)0xFF;
m_OcToCiOrginDataArr[i].FanState = (UINT8)0xFF;/*风扇状态，初始化为正常*/
m_OcToCiOrginDataArr[i].OCBoardSwapSysNum = 0U; /*OC切系板卡数初始化为零*/
for (j = 0U; j < MAX_OC_DEVICE_NUM; j++)
for (j = 0U; j < MAX_OC_DEVICE_SWAP_MAX; j++)
{
m_OcToCiOrginDataArr[i].SwapSysBoardId[j] = 0U;
}
@@ -3165,7 +3262,6 @@ UINT8 InitialRtnIndicStaData(void)
{
wNonAutoReturnId = GetNonReturnId(ii);
NonReturnDataStru[wNonAutoReturnId].IndicatorDevID = wNonAutoReturnId;
NonReturnDataStru[wNonAutoReturnId].cmdSetTrainId = 0U;
NonReturnDataStru[wNonAutoReturnId].VobcToCIAutoRtnIndicFlashState = VOBCTOCIAUTORTN_INDICT_MASK_INVALID;
NonReturnDataStru[wNonAutoReturnId].VobcToCIAutoRtnIndicSteadyState = VOBCTOCIAUTORTN_INDICT_MASK_INVALID;
@@ -3185,6 +3281,10 @@ UINT8 InitialRtnIndicStaData(void)
NonReturnDataStru[wNonAutoReturnId].RtnRelayAdhesionState.RelayUpCycNum = 0U;
}
/*初始化车车结构体成员*/
NonReturnDataStruCC[wNonAutoReturnId].IndicatorDevID = wNonAutoReturnId;
NonReturnDataStruCC[wNonAutoReturnId].cmdSetTrainId = 0U;
}
}
else
@@ -3245,3 +3345,268 @@ UINT8 InitialRtnIndicStaData(void)
return chReval;
}
/*
* 功能描述：重置本控区RC的设备动态数据
* 参数说明：void
* 返 回 值：void
* Created By LQ 2025.11.07
*/
void ResetLocalRcDynamicState(void)
{
UINT16 jj = 0U;
UINT8 cLocalCiId = 0U;
UINT8 cBelongCiId = 0U; /*设备所属控区ID*/
UINT16 wRouteNum = 0U; /*进路数量*/
UINT16 wRouteId = 0U; /*进路ID*/
UINT16 wSignalNum = 0U; /*信号机数量*/
UINT16 wSignalId = 0U; /*信号机ID*/
UINT16 wAxisSecNum = 0U; /*计轴区段数量*/
UINT16 wAxisSecId = 0U; /*计轴区段ID*/
UINT16 wLogSecNum = 0U; /*逻辑区段数量*/
UINT16 wLogSecId = 0U; /*逻辑区段ID*/
UINT16 wPhySecNum = 0U; /*物理区段数量*/
UINT16 wPhySecId = 0U; /*物理区段ID*/
UINT16 wPsdNum = 0U; /*PSD数量*/
UINT16 wPsdSecId = 0U; /*PSD ID*/
cLocalCiId = GetSystemParaLocalCiId();
/****** 重置RC进路信息 ******/
wRouteNum = GetRouteCurSum(); /*获取进路数量*/
for (jj = 0U; jj < wRouteNum; jj++)
{
wRouteId = GetRouteId(jj);
cBelongCiId = GetRouteBelongCiId(wRouteId);
if (cBelongCiId == cLocalCiId)
{
SetRouteStopensureFlagCC(wRouteId, ROUTE_STOPENSURE_NO); /*设置RC进路停车保证为无停车保证*/
}
else
{
/*非本控区设备，不处理*/
}
}
/****** 重置RC信号机信息 ******/
wSignalNum = GetSignalCurSum(); /*获取信号机数量*/
for (jj = 0U; jj < wSignalNum; jj++)
{
wSignalId = GetSignalId(jj);
cBelongCiId = GetSignalBelongCiId(wSignalId);
if (cBelongCiId == cLocalCiId)
{
SetSignalLightExtinctStateCC(wSignalId, SIGNAL_LIGHT_EXTICT_STATE_YES); /*设置RC信号机亮灭状态为亮灯*/
SetSignalCrossStateCC(wSignalId, SIGNAL_CROSS_STATE_NO); /*设置RC信号机跨压状态为未跨压*/
}
else
{
/*非本控区设备，不处理*/
}
}
/****** 重置RC计轴区段信息 ******/
wAxisSecNum = GetAxisSecCurSum(); /*获取计轴区段数量*/
for (jj = 0U; jj < wAxisSecNum; jj++)
{
wAxisSecId = GetAxisSecId(jj);
cBelongCiId = GetAxisBelongTioc(wAxisSecId);
if (cBelongCiId == cLocalCiId)
{
SetAxisSecArbStateCC(wAxisSecId, AXIS_SECTION_ARB_NO); /*设置RC计轴区段ARB状态为未ARB*/
}
else
{
/*非本控区设备，不处理*/
}
}
/****** 重置RC逻辑区段信息 ******/
wLogSecNum = GetLogicSecCurSum(); /*获取逻辑区段数量*/
for (jj = 0U; jj < wLogSecNum; jj++)
{
wLogSecId = GetLogicSecId(jj);
cBelongCiId = GetLogSecBelongCiId(wLogSecId);
if (cBelongCiId == cLocalCiId)
{
SetLogSecLinShiXianSuStateCC(wLogSecId, LOGSEC_LSXS_SET_STATE_YES); /*设置RC逻辑区段临时限速设置状态为已设置临时限速*/
SetLogSecOccupyStateCC(wLogSecId, LOGICSECTION_OCCUPY_UT); /*设置RC逻辑区段初始占用状态为UT占用*/
SetLogSecTXOccupyStateCC(wLogSecId, LOGICSECTION_OCCUPY_NO_TX); /*设置RC逻辑区段通信车占用状态为非通信车占用*/
}
else
{
/*非本控区设备，不处理*/
}
}
/****** 重置RC物理区段信息 ******/
wPhySecNum = GetPhySecCurSum(); /*获取物理区段数量*/
for (jj = 0U; jj < wPhySecNum; jj++)
{
wPhySecId = GetPhySecId(jj);
cBelongCiId = GetPhySecBelongCiId(wPhySecId);
if (cBelongCiId == cLocalCiId)
{
SetPhySecStopSteadyFlagCC(wPhySecId, PHYSICAL_SECTION_STOPSTEADY_NO); /*设置RC物理区段停稳状态为未停稳*/
}
else
{
/*非本控区设备，不处理*/
}
}
/****** 重置RC PSD信息 ******/
wPsdNum = GetPsdSum(); /*获取PSD数量*/
for (jj = 0U; jj < wPsdNum; jj++)
{
wPsdSecId = GetPsdId(jj);
cBelongCiId = GetPsdBelongCiId(wPsdSecId);
if (cBelongCiId == cLocalCiId)
{
SetPsdEditGroupInfoDataCC(wPsdSecId, PSD_EDIT_GROUP_DEFAULT); /*设置RC的PSD编组信息为默认值*/
SetPsdVobcCmdCC(wPsdSecId, 0U, PSD_DEFAULT_CONTROL_CMD, 0U); /*设置RC的PSD命令操作信息无效*/
}
else
{
/*非本控区设备，不处理*/
}
}
}
/*
* 功能描述：重置控区设备状态处理
* 参数说明：void
* 返 回 值：无
* Created By LQ 2025.11.19
*/
void ResetDevStateProcess(void)
{
UINT8 cRcWorkMode = 0U;
cRcWorkMode = GetLocalRcWorkMode();
/*系统不可用期间，周期重置为未全站解封*/
SetStartFLockFlag(CI_START_FLOCK_YES);
/*系统不可用期间，周期重置为未上电解锁*/
SetStartLockFlag(CI_START_LOCK_YES);
/*初始化进路数据*/
(void)InitialRouteData();
/*初始化信号机数据*/
(void)InitialSignalData();
/*初始化道岔数据*/
(void)InitialSwitchData();
/*初始化物理区段数据*/
(void)InitialPhySectionData();
/*初始化计轴区段数据*/
(void)InitialAxisSectionData();
/*初始化逻辑区段数据*/
(void)InitialLogicSectionData();
/*初始化紧急停车按钮数据*/
(void)InitialEsbData();
/*初始化屏蔽门数据*/
(void)InitialPsdData();
/*初始化站台数据*/
(void)InitialPlatformData();
/*初始化站台门控制器数据*/
(void)InitialPscToCiData();
/*初始化继电器数据*/
(void)InitialRelayData();
/*初始化保护区段组数据*/
(void)InitialOverlapData();
/*初始化自动折返数据*/
(void)InitialAutoReturnRouteData();
/*初始化自动通过数据*/
(void)InitialAutoRouteRouteData();
/*初始化指示灯数据*/
(void)InitialIndicatorStateData();
/*初始化通信状态数据*/
(void)InitialTransmitStateData();
/*初始化全自动折返数据*/
(void)InitialAllAutoReturnRouteData();
/*初始化车库门数据*/
(void)InitialGaragedoorData();
/*初始化SPKS数据*/
(void)SpksDataManageInit();
/*初始化ESB数据*/
(void)EsbDataManageInit();
/*初始化防淹门数据*/
(void)InitialFloodGateData();
/*初始化列车管理模块*/
(void)TrainDataModuleInit();
/* 初始化倒切设备数据 */
(void)ReverseCutDataManageInit();
if (RC_WORK_MODE_TIOC == cRcWorkMode)
{
/*初始化分界点数据*/
(void)CutoffPointDataManageInit();
/*初始化动态进路数据*/
InitialDynamicRouteData();
/*初始化逻辑进路数据*/
InitialLogicalRouteData();
/*初始化包络数据*/
as_Init();
(void)elm_Init();
ssp_Init();
/*初始化全线免筛数据*/
(void)wls_Init();
/*初始化全线紧急制动*/
WlbInit();
}
else
{
; /* 无处理 */
}
/*初始化OC数据*/
InitOcData();
/*初始化oc设备*/
InitOcDevices();
/*初始化中央联锁结构体*/
InitCtrlPowerStru();
/*初始化OC站指示灯*/
(void)InitialOCStationIndicStaData();
/*初始化无人折返指示灯状态数据*/
(void)InitialRtnIndicStaData();
/*初始化平台发送的通控、扩展板数据*/
InitPlatDataStru();
/*初始化LEU数据*/
(void)InitLEUDataStru();
TiocTransCtInit();
}
TSCP/src/APP/ciapp/Initial/InitialProcess.h
+16
View File
@@ -330,6 +330,22 @@ 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/LogRecord/LogRecord.c
+177 -95
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++;
@@ -963,11 +998,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 +1041,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 +1075,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 +1096,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 +1113,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 +1132,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 +1152,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 +1163,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 +1308,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 +1330,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 +1349,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 +1403,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
@@ -1492,12 +1545,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 +1567,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 +1578,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;/*站台开门按钮状态*/
@@ -1604,6 +1667,8 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
deviceId = GetGaragedoorId(ii);
comparaResult = DeviceCompara((UINT8*)(&Record_GaragedoorDataStru[deviceId]), (UINT16)sizeof(GaragedoorDataStruct),
(UINT8*)(&newGaragedoorData[deviceId]), (UINT16)sizeof(GaragedoorDataStruct));
comparaResult += DeviceCompara((UINT8*)(&Record_GaragedoorDataStruCC[deviceId]), (UINT16)sizeof(GaragedoorDataStructCC),
(UINT8*)(&pGaragedoorDataCC[deviceId]), (UINT16)sizeof(GaragedoorDataStructCC));
if (0u==comparaResult)
{/*比较数据一致*/
@@ -1624,7 +1689,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 +1697,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,6 +1746,8 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
deviceId = GetFloodGateId(ii);
comparaResult = DeviceCompara((UINT8*)(&Record_FloodGateDataStru[deviceId]), (UINT16)sizeof(FloodGateDataStruct),
(UINT8*)(&pNewFloodGateData[deviceId]), (UINT16)sizeof(FloodGateDataStruct));
comparaResult += DeviceCompara((UINT8*)(&Record_FloodGateDataStruCC[deviceId]), (UINT16)sizeof(FloodGateDataStructCC),
(UINT8*)(&pNewFloodGateDataCC[deviceId]), (UINT16)sizeof(FloodGateDataStructCC));
if (0u==comparaResult )
{/*比较数据一致*/
@@ -1706,19 +1773,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,6 +1829,8 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
deviceId = GetOverlapId(ii);
comparaResult = DeviceCompara((UINT8*)(&Record_OverlapDataStru[deviceId]), (UINT16)sizeof(OverlapDataStruct),
(UINT8*)(&newOverlapData[deviceId]), (UINT16)sizeof(OverlapDataStruct));
comparaResult += DeviceCompara((UINT8*)(&Record_OverlapDataStruCC[deviceId]), (UINT16)sizeof(OverlapDataStructCC),
(UINT8*)(&pOverlapDataCC[deviceId]), (UINT16)sizeof(OverlapDataStructCC));
if (0u==comparaResult)
{/*比较数据一致*/
@@ -1782,6 +1851,7 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
outStringLength += 4u;
LongToChar(newOverlapData[deviceId].XuanPaiStartCycNum,&outString[outStringLength]);/*保护区段选排开始周期号*/
outStringLength += 4u;
outString[outStringLength++] = newOverlapData[deviceId].chPreLaborUnlockState; /*之前人工解锁状态*/
outString[outStringLength++] = newOverlapData[deviceId].OverlapUnlockApplyFlag;/*向ZC申请解锁保护区段解锁标志*/
outString[outStringLength++] = newOverlapData[deviceId].OverlapCanLaborUnlockFlag;/*保护区段可以人工解锁标志*/
outString[outStringLength++] = newOverlapData[deviceId].OverlapLaborUnlockSetState;/*保护区段人工解锁设置状态*/
@@ -1798,10 +1868,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 +1946,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,17 +1963,19 @@ 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;
}
}
@@ -2287,6 +2362,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位置*/
}
@@ -2705,17 +2783,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)
@@ -2726,10 +2806,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; /*继电器粘连状态*/
TSCP/src/APP/ciapp/LogicManage/InterlockCommonManage.c
+24
View File
@@ -564,6 +564,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 +591,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 +608,11 @@ void SetRouteRelProSwitchLockSta(const UINT16 routeId, const UINT8 lockCommand)
}
#endif
}
else
{
/*防护道岔不在防护位置或防护道岔存在反向驱动，不设置防护锁闭*/
}
}
}
else
{
@@ -1927,6 +1939,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
{
/*不处理*/
}
}
/*
TSCP/src/APP/ciapp/LogicManage/InterlockLogicManage.c
+432 -94
View File
@@ -22,6 +22,7 @@
#include "LogicalRouteDataManage.h"
#include "../LogicProcess/LogicalRouteLogicCheck.h"
#include "../LogicManage/TradInterlockLogicManage.h"
#include "ParsePackZcData.h"
@@ -144,9 +145,11 @@ void InterlockLogicMainProc(void)
{
UINT8 localCiType = GetLocalCiType();
UINT8 cRcWorkMode = GetLocalRcWorkMode();
UINT8 cControlState = GetLocalCiBackUpPattern();
signed long long cost[20] = {0U};
cost[0] = MSCP_GetTick();
if (SYSTEM_WORK_MODE_MAIN == cControlState)
{
if ((CI_TYPE_ZX == localCiType) || (CI_TYPE_SCX == localCiType))
{
/*全自动折返进路逻辑处理*/
@@ -199,11 +202,10 @@ void InterlockLogicMainProc(void)
/*进路逻辑处理*/
RouteLogicManage();
/*保护区段照查继电器更新管理*/
OverlapZhaoChaRelayUpDateManage();
/*保护区段状态更新管理*/
OverlapStateUpdateManage();
/*进路列车释放解锁逻辑管理*/
RouteTrainResUnlockManage();
cost[2] = MSCP_GetTick();
@@ -213,15 +215,22 @@ void InterlockLogicMainProc(void)
/*保护区段其它联锁防护道岔管理*/
OverlapOtherCiProSwitchManage();
/*锁闭防护道岔处理*/
lockSwitchLogicManage();
/*解锁道岔逻辑处理*/
UnlockSwitchLogicManage();
/*逻辑区段资源管理*/
LogicSecResManage();
cost[3] = MSCP_GetTick();
/*跳跃锁闭逻辑处理*/
JumpLockManage();
}
cost[3] = MSCP_GetTick();
/*进路列车释放解锁逻辑管理*/
RouteTrainResUnlockManage();
/*逻辑区段资源管理*/
LogicSecResManage();
cost[4] = MSCP_GetTick();
debug_infor_printf((const)"\n JKJRelayLogicProcess :%dms RouteLogicManage:%dms LogicSecResManage:%dms JumpLockManage:%dms \n",(cost[1]-cost[0])/1000,(cost[2]-cost[1])/1000,(cost[3]-cost[2])/1000,(cost[4]-cost[3])/1000);
@@ -403,6 +412,9 @@ void RouteLogicManage(void)
/*清理进路信号容忍开放开始周期*/
SetClearKeepSignalTolerateCyc(routeId);
/*刷新联挂标志*/
UpdateRouteCouplinkFlag(routeId);
routeState = GetRouteState(routeId);
/*#####进路状态处理#####*/
@@ -3185,6 +3197,7 @@ UINT8 LockRouteOverlapAccdToAtsCmd(const UINT16 routeId, const UINT16 expLkOverl
UINT16 wOverlapLockRouteId = 0U;/*保护区段锁闭所属进路*/
UINT32 dwXuanpaiStartCycNum = 0U; /*保护区段道岔选排起始周期*/
UINT8 cTimeCheckFlag = CI_TIME_OUT;
UINT8 cSwitchPosCheckRet = CI_ERROR;
localCiId = GetSystemParaLocalCiId(); /*获取本机联锁ID*/
@@ -3233,7 +3246,8 @@ UINT8 LockRouteOverlapAccdToAtsCmd(const UINT16 routeId, const UINT16 expLkOverl
retValue = CI_ERROR;
}
if (CI_SUCCESS == retValue)
cSwitchPosCheckRet = CheckOverlapSwitchPosRight(expLkOverlapId); /*检查保护区段道岔和防护道岔位置是否正确*/
if ((CI_SUCCESS == retValue) && (CI_SUCCESS == cSwitchPosCheckRet))
{ /*锁闭成功*/
/*为了解决保护区段不解锁，重复被两条进路锁闭时，第二条进路锁闭保护区段前，清除第一条进路锁闭过的保护区段ID；
@@ -3282,7 +3296,7 @@ UINT8 LockRouteOverlapAccdToAtsCmd(const UINT16 routeId, const UINT16 expLkOverl
SetOverlapProSwtCheckStartFlag(expLkOverlapId, PROSWITCH_CHECK_START_VALID);
retValue = RETURN_WAIT_SWITCH_CHECK;
}
else if (RETURN_LOCK_ERR_SWITPOS == retValue)
else if ((RETURN_LOCK_ERR_SWITPOS == retValue) || ((CI_SUCCESS == retValue) && (CI_ERROR == cSwitchPosCheckRet)))
{
SetOverlapRelSwitchUsing(expLkOverlapId, SWITCH_USING_YES);
SetOverlapXuanPaiStartCycNum(expLkOverlapId, cycNum);
@@ -3361,6 +3375,7 @@ UINT8 LockRouteOverlapProc(const UINT16 routeId)
UINT32 dwXuanPaiStartCycNum = 0U; /*保护区段道岔选排起始周期*/
UINT8 cTimeCheckFlag = CI_TIME_OUT;
UINT8 cKeepWorkFlag = CI_ERROR;
UINT8 cSwitchPosCheckRet = CI_ERROR;
overlapSum = GetRouteOverlapSum(routeId); /*获取Overlap总数*/
overlapIdBuf = GetRouteOverlapIdBuf(routeId); /*获取Overlap ID BUF*/
@@ -3440,7 +3455,8 @@ UINT8 LockRouteOverlapProc(const UINT16 routeId)
returnValue = CI_ERROR;
}
if (CI_SUCCESS == returnValue)
cSwitchPosCheckRet = CheckOverlapSwitchPosRight(overlapIdBuf[ii]); /*检查保护区段道岔和防护道岔位置是否正确*/
if ((CI_SUCCESS == returnValue) && (CI_SUCCESS == cSwitchPosCheckRet))
{ /*锁闭成功*/
/*为了解决保护区段不解锁，重复被两条进路锁闭时，第二条进路锁闭保护区段前，清除第一条进路锁闭过的保护区段ID；
@@ -3493,7 +3509,7 @@ UINT8 LockRouteOverlapProc(const UINT16 routeId)
cKeepWorkFlag = CI_ERROR; /*停止遍历*/
returnValue = RETURN_WAIT_SWITCH_CHECK;
}
else if (RETURN_LOCK_ERR_SWITPOS == returnValue)
else if ((RETURN_LOCK_ERR_SWITPOS == returnValue) || ((CI_SUCCESS == returnValue) && (CI_ERROR == cSwitchPosCheckRet)))
{
SetOverlapRelSwitchUsing(overlapIdBuf[ii], SWITCH_USING_YES);
SetOverlapXuanPaiStartCycNum(overlapIdBuf[ii], dwCurCycNum);
@@ -4425,22 +4441,9 @@ void RouteZongRenJieProc(const UINT16 routeId)
SetRouteZongRenJieDelayType(routeId, ROUTE_ZRJ_DELAY_TYPE_IDLE);
}
else
{
/* 进路内有车占用，判断内方第一逻辑区段是否占用 */
if (ROUTE_TRAIN_ENTER_FLAG_NO == trainEnterSta)
{/*无车驶入，全部变绿光带*/
/*将进路内所有物理区段变成绿光带*/
SetRoutePhySectionLockState(routeId, PHYSICAL_SECTION_LOCK_EXCEPT);
/*进路逻辑区段都故障锁闭*/
SetRouteLogSectionLockState(routeId, LOG_SECTION_LOCK_EXCEPT);
}
else
{
/*车身后变绿光带*/
SetRoutePhySecExpLockToOccupy(routeId);
}
SetRouteStateManage(routeId, ROUTE_STATE_AUTO_UNLOCKERR);
}
}
@@ -4452,20 +4455,9 @@ void RouteZongRenJieProc(const UINT16 routeId)
SetRouteStateManage(routeId, ROUTE_STATE_IDLE); /*-->设置进路空闲*/
}
else
{
if (ROUTE_TRAIN_ENTER_FLAG_NO == trainEnterSta)
{/*无车驶入，全部变绿光带*/
/*将进路内所有物理区段变成绿光带*/
SetRoutePhySectionLockState(routeId, PHYSICAL_SECTION_LOCK_EXCEPT);
/*进路逻辑区段都故障锁闭*/
SetRouteLogSectionLockState(routeId, LOG_SECTION_LOCK_EXCEPT);
}
else
{
/*车身后变绿光带*/
SetRoutePhySecExpLockToOccupy(routeId);
}
SetRouteStateManage(routeId, ROUTE_STATE_AUTO_UNLOCKERR);
}
@@ -4491,19 +4483,11 @@ void RouteZongRenJieProc(const UINT16 routeId)
}
else
{
/* 进路内有车占用 */
if (ROUTE_TRAIN_ENTER_FLAG_NO == trainEnterSta)
{
/*无列车驶入过，延时后全部边绿光带*/
SetRouteZongRenJieDelayType(routeId, ROUTE_ZRJ_DELAY_TYPE_ALL_EXP);
}
else
{
/*延时后部分绿光带，即一个占压的物理区段之前的物理区段变绿光带*/
SetRouteZongRenJieDelayType(routeId, ROUTE_ZRJ_DELAY_TYPE_EXP_TO_OCCUPY);
}
}
}
else
{
/*进路不能取消*/
@@ -5217,6 +5201,7 @@ UINT8 OverlapLockDriveSwitch(const UINT16 overlapId)/* liu 06-26*/
OverlapProtectSwitchStruct* overlapProtectSwitchStru = NULL; /*防护道岔数据*/
UINT8 cLocalCiId = 0U;
UINT8 cSwitchBelongCiId = 0U;
UINT8 cFuncRet = CI_ERROR;
cLocalCiId = GetSystemParaLocalCiId();
@@ -5267,7 +5252,8 @@ UINT8 OverlapLockDriveSwitch(const UINT16 overlapId)/* liu 06-26*/
}
else
{
if (CI_ERROR == SwitchDriveProcess(switchId, switchExpPosition))
cFuncRet = SwitchDriveProcess(switchId, switchExpPosition);
if (CI_ERROR == cFuncRet)
{
retVal = CI_ERROR;
break;
@@ -5309,13 +5295,22 @@ UINT8 OverlapLockDriveSwitch(const UINT16 overlapId)/* liu 06-26*/
}
else
{
if (CI_ERROR == SwitchDriveProcess(switchId, switchExpPosition))
cFuncRet = CheckSwitchPosAndMoveValid(overlapProtectSwitchStru[ii].ProtectSwitchId, overlapProtectSwitchStru[ii].ProtectPosition, ESEND_LEVEL_ZERO); /*防护道岔可动性检查*/
if (CI_ERROR == cFuncRet)
{
/*不可动防护道岔不检查位置，已在锁闭条件中通过二级侧防进行防护*/
}
else
{
cFuncRet = SwitchDriveProcess(switchId, switchExpPosition);
if (CI_ERROR == cFuncRet)
{
retVal = CI_ERROR;
break;
}
}
}
}
else
{
/*非本控区道岔，不处理*/
@@ -5572,7 +5567,10 @@ void SetCommonRouteLogicManage(const UINT16 routeId,const UINT8 chSendLevel)
UINT16 wszReadyEtRouteTrainId[LOGIC_SECTION_RES_SUM_MAX] = { 0U };
UINT8 chFunRet = CI_ERROR;
UINT8 chHitSoftWallSwitch = 0U;/*撞软墙开关*/
UINT8 chRouteCouplinkFlag = 0U;
UINT16 wRouteInLastLogSecId = 0U;
UINT16 wLogLockRouteId = 0U;
UINT8 chAutoFlagCheck = 0U;
chHitSoftWallSwitch = GetHitSoftWallSwitch();
/*进路信号异常关闭，收到进路办理命令后执行信号重开开关 0xaa执行 0x55不执行*/
chSignalReOpenFunc = GetCiFunctionSwitchConfig(FUNC_ROUTELOCK_OPEN_SIGNAL);
@@ -5609,7 +5607,35 @@ void SetCommonRouteLogicManage(const UINT16 routeId,const UINT8 chSendLevel)
routeLevel = GetRouteLevel(routeId);
routeState = GetRouteState(routeId);
triggerFlag = GetRouteAutoTriggerFlag(routeId); /*获取进路的自动触发标志*/
chAutoFlagCheck = AutoSignalOrRouteValid(routeId);
}
if (CI_SUCCESS == cKeepWorkFlag)
{
/*联挂进路不能被列车进路追排*/
wRouteInLastLogSecId = GetRouteInLastLogSecId(routeId);
wLogLockRouteId = GetLogSecLockBelongRoute(wRouteInLastLogSecId);
if (0U != wLogLockRouteId)
{ /*进路最后一个逻辑区段锁闭所属进路存在联挂标志；则不允许追排列车进路*/
chRouteCouplinkFlag = GetRouteCouplinkFlag(wLogLockRouteId);
if ((ROUTE_COUPLINK_FLAG_YES == chRouteCouplinkFlag) && (ROUTE_TYPE_DIAOCHE != routeType))
{
if ((CI_SUCCESS == chAutoFlagCheck) || (AUTO_TRIGGER_SET_YES == triggerFlag))
{
/*自动进路不报警 */
}
else
{
/*添加反馈 */
SetCiSendCmdBackInfoData(CI_BACK_ROUTE_STATE_ERROR, CI_DEVICE_TYPE_ROUTE, routeId, 0u, 0u);/*反馈进路建立条件不满足*/
}
cKeepWorkFlag = CI_ERROR;
}
else
{
/*继续执行*/
}
}
}
if (CI_SUCCESS == cKeepWorkFlag)
@@ -5708,7 +5734,7 @@ void SetCommonRouteLogicManage(const UINT16 routeId,const UINT8 chSendLevel)
}
else
{
if ((AutoSignalOrRouteValid(routeId) == CI_SUCCESS) ||
if ((CI_SUCCESS == chAutoFlagCheck) ||
(AUTO_TRIGGER_SET_YES == triggerFlag))
{
/*自动进路或自动触发进路不发送ATS*/
@@ -7884,6 +7910,11 @@ void SetAutoRouteLogicManage(const UINT16 autoRouteId, const UINT8 virCIid)
}
}
if (CI_SUCCESS == chkStatus)
{
/*检查包含子进路未办理联挂进路*/
chkStatus = AutoRouteCouplinkStateCheck(autoRouteId, chFunctionId);
}
if (CI_SUCCESS == chkStatus)
{
SetAutoRouteSetFlag(autoRouteId, AUTO_ROUTE_SET_YES);
@@ -7985,7 +8016,11 @@ void SetAutoReturnLogicManage(const UINT16 autoReturnId, const UINT8 virCIid)
SetErrorData(chFunctionId, CI_DEVICE_TYPE_AUTORETURN, autoReturnId, ETYPE_AUTO_RETURN_FLAG, AUTO_RETURN_FLOOD_STATE_ERR, chSendLevel);
}
}
if (CI_SUCCESS == chkStatus)
{
/*检查包含子进路未办理联挂进路*/
chkStatus = AutoReturnRouteCouplinkCheck(autoReturnId, chFunctionId);
}
if (CI_SUCCESS == chkStatus)
{/*所有检查项完毕，设置自动属性*/
SetAutoReturnSetFlag(autoReturnId, AUTO_RETURN_SET_YES);
@@ -8326,6 +8361,8 @@ void SetSectionResetLogicManage(const UINT16 phySecId, const UINT8 resetType)
UINT8 const functionId = EFUNC_SET_SEC_RESET_LOGIC_MANAGE; /*函数故障码*/
UINT16 retValid = CI_ERROR; /*计轴总复位继电器状态有效性值，默认为无效*/
UINT8 occupyState = 0u; /*占用状态*/
UINT32 dwCurCycleNum = 0U;/*当前周期号*/
UINT32 dwResetStartCycNum = 0U; /*复位起始周期号*/
if ((0u < phySecId) && (PHYSICAL_SECTION_SUM_MAX > phySecId))
{
@@ -8342,8 +8379,19 @@ void SetSectionResetLogicManage(const UINT16 phySecId, const UINT8 resetType)
retValid = GetZFWValidByPhySecId(phySecId); /*获取物理区段计轴总复位继电器状态有效性*/
if (CI_SUCCESS == retValid) /*有效，执行计轴复位功能*/
{
dwResetStartCycNum = GetPhySecResetStartCycNum(phySecId);
if (0U == dwResetStartCycNum)
{
dwCurCycleNum = Get2oo2CurCycleNum();
SetPhySecSectionResetType(phySecId, resetType);
SetPhySecResetStartCycNum(phySecId, Get2oo2CurCycleNum());/*设置当前周期号位计轴复位命令起始周期号*/
SetPhySecResetStartCycNum(phySecId, dwCurCycleNum);/*设置当前周期号位计轴复位命令起始周期号*/
SetPhySecResetCmdTag(phySecId);
}
else
{
/*物理区段正在复位中*/
SetCiSendCmdBackInfoData(CI_BACK_PSEC_RESET_ING, CI_DEVICE_TYPE_PHYSEC, phySecId, 0U, 0U);
}
}
else /*无效，反馈计轴复位失败：总复位继电器落下*/
{
@@ -8376,18 +8424,20 @@ void SetThroughRouteManage(const UINT16 signalId)
UINT8 returnRouteState = 0u; /*折返进路状态*/
UINT8 returnRouteIdBelongCiId = 0u;/*折返进路所属联锁ID*/
UINT8 throughRouteIdBelongCiId = 0u;/*通过进路所属联锁ID*/
UINT8 returnRouteDirection = 0u;
UINT16 reRouteNormalLockPhy = 0u;
UINT8 phyMergeState = 0u;
UINT16 nextRouteLockPhy = 0u;
UINT16 lockPhyBelongRoute = 0u;
UINT8 nextRouteDirection = 0u;
UINT8 haveDirChangeAfterRoute = 0u;
UINT8 haveDirChangeInRoute = 0u;
UINT8 saveReRouteDir = 0u;
UINT8 throughRouteDir = 0u;
UINT16 wLastLgcSecId = 0U;
UINT16 wTrainId = 0u;
UINT8 chTrainSum = 0u;
UINT16 wLogicSecId = 0u;
UINT16 wEndSignalId = 0U;/*折返进路的终端信号机*/
UINT16 wStartSignalId = 0U;/*待信号特开进路的始端信号机*/
LogicTrainResStruct* pstLgcResInfo = NULL;
LogicTrainResStruct stTmpResInfo[LOGIC_SECTION_RES_SUM_MAX] = { 0U };
@@ -8410,8 +8460,6 @@ void SetThroughRouteManage(const UINT16 signalId)
returnRouteId = GetPhySecRLockBelongRouteId(signalOutSecId);
nextRouteId = GetPhySecRLockBelongRouteId(signalInSecId);
throughRouteId = GetRouteThroughRouteId(returnRouteId);
wEndSignalId = GetRouteEndSignalId(returnRouteId);/*获取终端信号机*/
wStartSignalId = GetRouteStartSignalId(nextRouteId);/*待办理信号特开的进路始端信号机*/
returnRouteIdBelongCiId = GetRouteBelongCiId(returnRouteId);/*获取折返进路所属联锁ID*/
throughRouteIdBelongCiId = GetRouteBelongCiId(throughRouteId);/*获取通过进路所属联锁ID*/
@@ -8436,11 +8484,35 @@ void SetThroughRouteManage(const UINT16 signalId)
{
/*获取锁闭进路*/
lockPhyBelongRoute = GetPhySecRLockBelongRouteId(signalInSecId);
saveReRouteDir = GetRouteDirection(returnRouteId);/*保存进路实际方向*/
nextRouteDirection = GetRouteDirection(lockPhyBelongRoute);
returnRouteDirection = GetRouteDirection(returnRouteId);
throughRouteDir = GetRouteDirection(throughRouteId); /*折返进路对应的通过进路方向*/
haveDirChangeAfterRoute = GetRouteHaveDirChangePointAfter(returnRouteId);
haveDirChangeInRoute = GetRouteHaveDirChangePointIn(returnRouteId);
saveReRouteDir = returnRouteDirection; /*保存进路实际方向*/
/*进路后方或进路内存在方向变化点*/
if ((ROUTE_HAVE_DIR_CHANGE_POINT == haveDirChangeAfterRoute) ||
(ROUTE_HAVE_DIR_CHANGE_POINT == haveDirChangeInRoute))
{
if (CI_SYSTEM_DIRECTION_UP == returnRouteDirection)
{
returnRouteDirection = CI_SYSTEM_DIRECTION_DOWN;
}
else if (CI_SYSTEM_DIRECTION_DOWN == returnRouteDirection)
{
returnRouteDirection = CI_SYSTEM_DIRECTION_UP;
}
else
{
/*不做处理*/
}
}
/*方向相同*/
if (wEndSignalId == wStartSignalId)
if (nextRouteDirection == returnRouteDirection)
{
if ((localCiId == returnRouteIdBelongCiId) && (localCiId == throughRouteIdBelongCiId))
{/*折返进路和通过进路都属于本联锁才设置折返进路空闲和通过进路自动解锁正常*/
@@ -8459,12 +8531,16 @@ void SetThroughRouteManage(const UINT16 signalId)
SetLogSecLockState(wLastLgcSecId, LOG_SECTION_LOCK_NO, returnRouteId, saveReRouteDir);
SetPhySecLockState(signalOutSecId, PHYSICAL_SECTION_LOCK_NO, returnRouteId, saveReRouteDir);
SetRouteStateManage(returnRouteId, ROUTE_STATE_IDLE);
/*设置区段属于当前进路锁闭*/
SetLogSecLockState(wLastLgcSecId, LOG_SECTION_LOCK_NORMAL, throughRouteId, throughRouteDir);
if (NULL != pstLgcResInfo)
{
CpyLgcSecResTrain(wLastLgcSecId, chTrainSum, stTmpResInfo);
@@ -8887,6 +8963,11 @@ void SetAllAutoReturnLogicManage(const UINT16 allAutoReturnId, const UINT8 virCI
SetErrorData(chFunctionId, CI_DEVICE_TYPE_ALLAUTORETURN, allAutoReturnId, ETYPE_ALL_AUTO_RETURN_FLAG, ALL_AUTO_RETURN_FLOOD_STATE_ERR, chSendLevel);
}
}
if (CI_SUCCESS == chkStatus)
{
/*检查包含子进路未办理联挂进路*/
chkStatus = AllAutoReturnRCouplinkCheck(allAutoReturnId,chFunctionId);
}
if (CI_SUCCESS == chkStatus)
{
@@ -9374,6 +9455,8 @@ UINT8 CancleLinShiXianSuManage(void)
if (LOGSEC_LSXS_SET_STATE_INVALID != state)
{/*具有临时限速属性*/
SetLogSecLinShiXianSuState(logSecId, LOGSEC_LSXS_SET_STATE_NO); /*取消临时限速*/
SetLogSecLinShiXianSuStateZc(logSecId, LOGSEC_LSXS_SET_STATE_NO); /*同时取消ZC的临时限速*/
/*备注：TMC尚不具备，限速清除先仅考虑和ZC通信*/
}
}
retVal = CI_SUCCESS;
@@ -9722,6 +9805,7 @@ void RouteStateFlagManage(const UINT16 routeId)
SetRoutePhySectionOccupyState(routeId, PHYSICAL_SECTION_USING_NO);
SetRouteStateFlag(routeId, ROUTE_STATE_FLAG_NO); /*-->设置进路状态转移标志无效*/
SetRouteCouplinkFlag(routeId, ROUTE_COUPLINK_FLAG_NO); /*-->清联挂标志*/
}
else if (CI_SUCCESS == returnValueFunc1)
{
@@ -9752,6 +9836,7 @@ void RouteStateFlagManage(const UINT16 routeId)
SetRouteStateFlag(routeId, ROUTE_STATE_FLAG_NO); /*-->设置进路状态转移标志无效*/
SetRouteCouplinkFlag(routeId, ROUTE_COUPLINK_FLAG_NO); /*-->清联挂标志*/
}
routeStateFlag = GetRouteStateFlag(routeId);
@@ -9818,6 +9903,7 @@ void RouteXuanPaiStateManage(const UINT16 routeId)
/* 单操取消办理 */
SetRouteStateFlag(routeId, ROUTE_STATE_FLAG_NO); /*-->设置进路状态转移标志无效*/
SetRouteCouplinkFlag(routeId, ROUTE_COUPLINK_FLAG_NO); /*-->清联挂标志*/
}
}
else if (RETURN_LOCK_ERR_WAIT_SWCHECK == returnValue)
@@ -9834,6 +9920,7 @@ void RouteXuanPaiStateManage(const UINT16 routeId)
/* 进路锁闭失败 */
SetRouteStateFlag(routeId, ROUTE_STATE_FLAG_NO); /*-->设置进路状态转移标志无效*/
SetRouteCouplinkFlag(routeId, ROUTE_COUPLINK_FLAG_NO); /*-->清联挂标志*/
}
}
@@ -11887,8 +11974,8 @@ void SetCiCiRelayInterfConfirmFlag(UINT8 setFlag)
localCi = GetSystemParaLocalCiId();/*本联锁ID*/
/*如果与相邻联锁通信都正常，则确认失败*/
ciSum = GetCiTransmitSpecifySysDevSum(CI_SYSTEM_TYPE_CI); /*获取通信联锁设备总数*/
pCiIdBuf = GetCiTransmitSpecifySysDevBuf(CI_SYSTEM_TYPE_CI);/*获取和本联锁通信的联锁ID组*/
ciSum = GetCiTransmitSpecifySysDevSum(CI_SYSTEM_TYPE_RCI); /*获取通信联锁设备总数*/
pCiIdBuf = GetCiTransmitSpecifySysDevBuf(CI_SYSTEM_TYPE_RCI);/*获取和本联锁通信的联锁ID组*/
for (jj = 0u; jj < ciSum; jj++)
{
@@ -11899,7 +11986,7 @@ void SetCiCiRelayInterfConfirmFlag(UINT8 setFlag)
dstCIType = GetCiType(pCiIdBuf[jj]);
if (CI_TYPE_SCX != dstCIType)
{
tranCiState = GetCiTransmitState(CI_SYSTEM_TYPE_CI, pCiIdBuf[jj]);
tranCiState = GetCiTransmitState(CI_SYSTEM_TYPE_RCI, pCiIdBuf[jj]);
if (TRANSMIT_STATE_GOOD == tranCiState)
{
@@ -11921,7 +12008,7 @@ void SetCiCiRelayInterfConfirmFlag(UINT8 setFlag)
}
else
{/*报警，与相邻联锁通信都正常*/
SetErrorData(funcId, CI_SYSTEM_TYPE_CI, localCi, ETYPE_COMM_WITH_NEIGHBOUR_CI, allCommState, sendLevel);
SetErrorData(funcId, CI_SYSTEM_TYPE_RCI, localCi, ETYPE_COMM_WITH_NEIGHBOUR_CI, allCommState, sendLevel);
}
}
@@ -12829,6 +12916,7 @@ void RouteLgcSecResUnlockManage(const UINT16 wRouteId)
UINT8 chOpenCloseState = 0U;
UINT8 chRouteRepeatOpenFlag = 0U;
UINT16 wStartSignalId = 0U;
UINT8 cSysType = 0U;
/*获取进路信息*/
chRouteState = GetRouteState(wRouteId);
@@ -12849,9 +12937,17 @@ void RouteLgcSecResUnlockManage(const UINT16 wRouteId)
&& ((ROUTE_STATE_AUTO_UNLOCK == chRouteState)
|| (ROUTE_STATE_NEAR_LOCK == chRouteState)
|| (ROUTE_STATE_HALF_UNLOCK == chRouteState))) /*部分锁闭相应列车释放解锁*/
{
cSysType = GetSystemWorkType();
if (SYSTEM_WORK_MODE_ALL == cSysType)
{
/*双系统不支持资源释放解锁*/
}
else
{
RouteLgcSecResUnlockProcess(wRouteId);
}
}
else /*只处理释放资源*/
{
@@ -12877,7 +12973,7 @@ void RouteApplyLogicManage(const UINT16 routeId, const UINT16 trainId)
UINT8 chRouteType = 0U;
/** 入参检查*/
if ((0u == routeId) || (ROUTE_SUM_MAX <= routeId) || (TRAIN_ID_MIN >= trainId) || (TRAIN_ID_MAX <= trainId))
if ((0u == routeId) || (ROUTE_SUM_MAX <= routeId) || (TRAIN_ID_MIN_IVOC >= trainId) || (TRAIN_ID_MAX_IVOC <= trainId))
{
keepWork = CI_ERROR;
}
@@ -13033,7 +13129,7 @@ void RoutePartApplyLogicManage(const UINT8 cLogSecSeqDir, const UINT16 wTrainId,
cCheckStep++;
if (CI_ERROR == keepWork)
{
SetErrorData(cFunctionId, CI_SYSTEM_TYPE_VOBC, (wTrainId & 0x00FFU), ETYPE_LOGSEC_CONTINUOUS, 0U, cSendLevel);
SetErrorData(cFunctionId, CI_SYSTEM_TYPE_IVOC_TO_ATS, (wTrainId & 0x00FFU), ETYPE_LOGSEC_CONTINUOUS, 0U, cSendLevel);
}
else
{
@@ -13139,7 +13235,7 @@ void RoutePartApplyLogicManage(const UINT8 cLogSecSeqDir, const UINT16 wTrainId,
if (CI_ERROR == keepWork)
{
SetErrorData(cFunctionId, CI_SYSTEM_TYPE_VOBC, (wTrainId & 0x00FFU), ETYPE_PART_ROUTE_MATCH_ROUTE, 0U, cSendLevel);
SetErrorData(cFunctionId, CI_SYSTEM_TYPE_IVOC_TO_ATS, (wTrainId & 0x00FFU), ETYPE_PART_ROUTE_MATCH_ROUTE, 0U, cSendLevel);
break; /*拆分失败，停止遍历*/
}
else
@@ -13202,7 +13298,7 @@ void RoutePartApplyLogicManage(const UINT8 cLogSecSeqDir, const UINT16 wTrainId,
if (CI_ERROR == keepWork)
{
SetErrorData(cFunctionId, CI_SYSTEM_TYPE_VOBC, (wTrainId & 0x00FFU), ETYPE_PART_ROUTE_MATCH_ROUTE, 0U, cSendLevel);
SetErrorData(cFunctionId, CI_SYSTEM_TYPE_IVOC_TO_ATS, (wTrainId & 0x00FFU), ETYPE_PART_ROUTE_MATCH_ROUTE, 0U, cSendLevel);
}
else
{
@@ -13220,7 +13316,7 @@ void RoutePartApplyLogicManage(const UINT8 cLogSecSeqDir, const UINT16 wTrainId,
if (CI_ERROR == keepWork)
{
SetErrorData(cFunctionId, CI_SYSTEM_TYPE_VOBC, (wTrainId & 0x00FFU), ETYPE_PART_ROUTE_SCREEN, 0U, cSendLevel);
SetErrorData(cFunctionId, CI_SYSTEM_TYPE_IVOC_TO_ATS, (wTrainId & 0x00FFU), ETYPE_PART_ROUTE_SCREEN, 0U, cSendLevel);
}
else
{
@@ -13403,6 +13499,11 @@ void RoutePartApplyLogicManage(const UINT8 cLogSecSeqDir, const UINT16 wTrainId,
LogicRouteOpenColorProc(wUsableLogicRouteId); /*设置逻辑进路始端信号机开放颜色*/
LogRouteOutLgcSecConfigDataInit(wUsableLogicRouteId);
#if 0
/*设置逻辑进路侧防条件*/
retVal = SetLogRoutSidePrtectData(wUsableLogicRouteId);
#endif
/*区段征用通过，设置逻辑进路状态为初选，否则设置逻辑进路状态空闲*/
keepWork = LogRoutePhySecUseLogicProcess(wUsableLogicRouteId);
if (CI_SUCCESS == keepWork)
@@ -13418,7 +13519,7 @@ void RoutePartApplyLogicManage(const UINT8 cLogSecSeqDir, const UINT16 wTrainId,
}
else
{
SetErrorData(cFunctionId, CI_SYSTEM_TYPE_VOBC, (wTrainId & 0x00FFU), ETYPE_PART_ROUTE_REPEAT, 0U, cSendLevel);
SetErrorData(cFunctionId, CI_SYSTEM_TYPE_IVOC_TO_ATS, (wTrainId & 0x00FFU), ETYPE_PART_ROUTE_REPEAT, 0U, cSendLevel);
debug_infor_printf((const)"Dynamic Logic Route Set Is Error: LogicRoute Repeat Set!\n"); /*逻辑进路重复办理或非停车区域*/
}
}
@@ -13442,7 +13543,7 @@ void RoutePartApplyLogicManage(const UINT8 cLogSecSeqDir, const UINT16 wTrainId,
}
else
{
SetErrorData(cFunctionId, CI_SYSTEM_TYPE_VOBC, (wTrainId & 0x00FFU), ETYPE_LOGSEC_CBTC_PROPERTY, 0U, cSendLevel);
SetErrorData(cFunctionId, CI_SYSTEM_TYPE_IVOC_TO_ATS, (wTrainId & 0x00FFU), ETYPE_LOGSEC_CBTC_PROPERTY, 0U, cSendLevel);
debug_infor_printf((const)"Dynamic Logic Route Set Is Error: LogSec Is Not CBTC Property!\n"); /*逻辑进路办理办理失败，逻辑区段非CBTC属性*/
}
}
@@ -13647,7 +13748,7 @@ static void TrainTransitmitStatJumpLockProcess(const UINT16 logSectionId, const
/** 入参检查*/
if ((LOGIC_SECTION_SUM_MAX > bufIndex)
&& (TRAIN_ID_MIN < trainId) && (TRAIN_ID_MAX > trainId))
&& (TRAIN_ID_MIN_IVOC < trainId) && (TRAIN_ID_MAX_IVOC > trainId))
{
logSecBelongCiId = GetLogSecBelongCiId(logSectionId);
if (localCi == logSecBelongCiId)
@@ -13740,7 +13841,7 @@ UINT8 CheckRouteLgsLinShiXianSuExist(const UINT16 routeId)
UINT8 cCheckFlag = CI_SUCCESS;
UINT16 devId = 0U;
UINT8 devState = 0U;
UINT8 chLogSecEmergXianSu = 0U;
/** 获取进路内逻辑区段和进路保护区段包含的逻辑区段*/
routeSectionSum = GetRouteLogSectionSum(routeId);
pRouteSectionDataBuf = GetRouteLogSectionIdBuf(routeId);
@@ -13753,9 +13854,10 @@ UINT8 CheckRouteLgsLinShiXianSuExist(const UINT16 routeId)
{
logSecId = pRouteSectionDataBuf[i];
logSecState = GetLogSecLinShiXianSuSetState(logSecId);
if (logSecState == LOGSEC_LSXS_SET_STATE_YES)
chLogSecEmergXianSu = GetLogSecEmergXianSu(logSecId);
if ((LOGSEC_LSXS_SET_STATE_YES == logSecState) || (LOGSEC_EMERG_XS_SET_YES == chLogSecEmergXianSu))
{
/** 进路内至少有一个逻辑区段设置了临时限速*/
/** 进路内至少有一个逻辑区段设置了临时限速或紧急临时限速*/
break;
}
else
@@ -13772,9 +13874,10 @@ UINT8 CheckRouteLgsLinShiXianSuExist(const UINT16 routeId)
{
logSecId = pRouteOvlapSectionDataBuf[j];
logSecState = GetLogSecLinShiXianSuSetState(logSecId);
if (logSecState == LOGSEC_LSXS_SET_STATE_YES)
chLogSecEmergXianSu = GetLogSecEmergXianSu(logSecId);
if ((LOGSEC_LSXS_SET_STATE_YES == logSecState) || (LOGSEC_EMERG_XS_SET_YES == chLogSecEmergXianSu))
{
/** 进路保护区段内至少有一个逻辑区段设置了临时限速*/
/** 进路保护区段内至少有一个逻辑区段设置了临时限速或紧急临时限速*/
break;
}
else
@@ -14025,7 +14128,7 @@ void RouteCancelResLogicManage(const UINT16 wRouteId, const UINT16 wTrainId)
if (CI_SUCCESS == chKeepWork)
{
checkResult = RouteAllSecOccuClearCheck(wRouteId, &devId, &devState); /*进路空闲检查*/
wRouteNearestTrainId |= 0x1400U; /*加上车类型*/
wRouteNearestTrainId |= TRAIN_ID_MIN_IVOC; /*加上车类型*/
autoSigRouteState = GetRouteAutoSigSetState(wRouteId); /*获取进路自动信号状态*/
if (ROUTE_AUTOSIGROUTE_YES == autoSigRouteState) /*进路自动信号不处理*/
@@ -15166,7 +15269,9 @@ void RouteXuanPaiCommonProcess(const UINT16 wRouteId, const UINT8 chLockRoutePro
RouteFirstLockManage(wRouteId);
}
else if (((CI_SUCCESS == chLockRouteProcCheck) && (SWITCH_NEED_DRIV_TRUE == chNeedForDrvRoutAssoSwit)) || (RETURN_LOCK_ERR_SWITPOS == chLockRouteProcCheck))
else if (((CI_SUCCESS == chLockRouteProcCheck) && (SWITCH_NEED_DRIV_TRUE == chNeedForDrvRoutAssoSwit))
|| (RETURN_LOCK_ERR_SWITPOS == chLockRouteProcCheck)
|| ((CI_SUCCESS == chLockRouteProcCheck) && (CI_ERROR == chSwitchPos)))
{
if (CI_SUCCESS == chRoutSwitDrvOvtmFlag)
{
@@ -15242,7 +15347,7 @@ void RouteNearestTrainRenJieManage(const UINT16 routeId)
delayStartCycNum = GetRouteZhefanJiesuoCyc(routeId); /*获取需要折返解锁开始的时间*/
delayTotalCycSum = GetRouteTrainRanJieDelayCyc(); /*获取进路需要折返解锁的总周期数*/
zongRenJieFlag = GetRouteZongRenJieFlag(routeId); /*获取进路总人解标志*/
wRouteNearestTrainId |= 0x1400U; /*加上车类型*/
wRouteNearestTrainId |= TRAIN_ID_MIN_IVOC; /*加上车类型*/
startSignalId = GetRouteStartSignalId(routeId);
@@ -15751,7 +15856,7 @@ void RoutePartApplyLogicManageCLD(const UINT8 cLogSecSeqDir, const UINT16 wTrain
if (CI_SUCCESS != keepWork)
{
SetErrorData(cFunctionId, CI_SYSTEM_TYPE_VOBC, (wTrainId & 0x00FFU), ETYPE_PART_ROUTE_MATCH_ROUTE, 0U, cSendLevel);
SetErrorData(cFunctionId, CI_SYSTEM_TYPE_IVOC_TO_ATS, (wTrainId & 0x00FFU), ETYPE_PART_ROUTE_MATCH_ROUTE, 0U, cSendLevel);
}
else
{
@@ -15771,7 +15876,7 @@ void RoutePartApplyLogicManageCLD(const UINT8 cLogSecSeqDir, const UINT16 wTrain
if (CI_SUCCESS != keepWork)
{
SetErrorData(cFunctionId, CI_SYSTEM_TYPE_VOBC, (wTrainId & 0x00FFU), ETYPE_PART_ROUTE_SCREEN, 0U, cSendLevel);
SetErrorData(cFunctionId, CI_SYSTEM_TYPE_IVOC_TO_ATS, (wTrainId & 0x00FFU), ETYPE_PART_ROUTE_SCREEN, 0U, cSendLevel);
}
else
{
@@ -15874,10 +15979,6 @@ void RouteOtherCiSwitchManage(void)
UINT8 chTransmitStat = 0U;/*通信状态*/
UINT8 chRouteApplySwitchCheckFlag = 0U;/*进路办理道岔检查标志*/
UINT8 chOthCiRouteExistLocalCiSw = 0U;/*其他控区进路是否存在本控区道岔*/
UINT16 errorCodeCurSum = 0U;
ErrorDataStruct* errorCodeStu = NULL; /*错误码数据*/
UINT16 devId = 0U;
UINT8 devState = 0U;
wRouteCurSum = GetRouteCurSum(); /*获取进路总数*/
chLocalCiId = GetSystemParaLocalCiId(); /*获取本机联锁ID*/
@@ -15916,7 +16017,7 @@ void RouteOtherCiSwitchManage(void)
if (CI_SUCCESS == chResult)
{
SetRouteApplySwitchCheckFlag(wRouteId, ROUTE_APPLY_SWITCH_CHECK_YES);
chResult = RouteRelAllSwitchPosCheck(wRouteId, &devId, &devState);
chResult = RouteRelAllSwitchPosCheck(wRouteId);
if (CI_SUCCESS == chResult)
{
; /*道岔位置正确返回成功*/
@@ -15932,7 +16033,6 @@ void RouteOtherCiSwitchManage(void)
{
/*引导进路要求相邻联锁道岔在规定位置，不驱动道岔*/
SetRouteApplySwitchCheckFlag(wRouteId, ROUTE_APPLY_SWITCH_CHECK_NO);
SetRouteApplySwitchCheckErrorData(wRouteId, devId, CI_DEVICE_TYPE_SWITCH, devState, ETYPE_SWT_POSTION_STATE);
}
}
@@ -15940,7 +16040,6 @@ void RouteOtherCiSwitchManage(void)
else
{
SetRouteApplySwitchCheckFlag(wRouteId, ROUTE_APPLY_SWITCH_CHECK_NO);
SetRouteApplySwitchCheckErrorData(wRouteId, wRouteId, CI_DEVICE_TYPE_ROUTE, 0U, ETYPE_ROUTE_APPLY_SWITCH_MOVE);/*进路道岔单操方向不一致*/
}
}
else
@@ -15950,10 +16049,6 @@ void RouteOtherCiSwitchManage(void)
}
else
{
/*处理相邻联锁传递处理错误码*/
errorCodeCurSum = GetErrorDataCurSum(); /*获取错误码总数*/
errorCodeStu = GetErrorData(errorCodeCurSum - 1U); /*最新故障记录*/
SetRouteApplySwitchCheckErrorData(wRouteId, errorCodeStu->DeviceId, errorCodeStu->DeviceType, errorCodeStu->DeviceState, errorCodeStu->DeviceStateType);
SetRouteApplySwitchCheckFlag(wRouteId, ROUTE_APPLY_SWITCH_CHECK_NO);
}
}
@@ -16331,12 +16426,12 @@ void SetOcPscPlConfirmFlag(UINT8 setFlag, const UINT16 ocPId)
}
/*
* 功能描述： 保护区段照查条件更新
* 功能描述： 保护区段状态更新
* 参数说明： const UINT16 wRouteId 进路ID
* 返回值 ：无
* by cgh 20250617
* by cgh 20250928
*/
void OverlapZhaoChaRelayUpDateManage(void)
void OverlapStateUpdateManage(void)
{
UINT16 wOverlapCurSum = 0U;/*保护区段当前总数*/
UINT16 ii = 0U;
@@ -16349,6 +16444,7 @@ void OverlapZhaoChaRelayUpDateManage(void)
UINT8 chRelayCollState = 0U; /*继电器采集状态*/
UINT8 chTimeCheckFlag = 0U;/*时间检查结果*/
UINT32 dwSigalCloseCyc = 0U; /*信号机关闭超限周期数*/
UINT8 chTempCheckFlag = 0U; /*临时检查标志*/
wOverlapCurSum = GetOverlapCurSum();
chLocalCiId = GetSystemParaLocalCiId();
@@ -16397,6 +16493,17 @@ void OverlapZhaoChaRelayUpDateManage(void)
{
; /*无本端照查继电器不处理*/
}
chTempCheckFlag = OverlapLockRouteCheck(wOverlapId);
if (CI_SUCCESS == chTempCheckFlag)
{
SetOverlapPreLoaborUnlockState(wOverlapId, PRO_PRE_LABOR_UNLOCK_STATE_NO);
}
else
{
;
}
}
else
{
@@ -16534,3 +16641,234 @@ void TrainJumpBackApplyProc(void)
}
}
}
/*
* 功能描述： 办理联挂进路逻辑管理
* 参数说明： const UINT16 wRouteId 进路ID
* 返回值 ： 无
* Create: 20250917
*/
void SetCouplinkRouteLogicManage(const UINT16 wRouteId)
{
UINT8 chlocalCiId = 0U; /*本地联锁ID*/
UINT8 chbelongCiId = 0U; /*进路所属联锁ID*/
UINT8 chReval = CI_ERROR;
UINT8 functionId = EFUNC_ROUTE_COUPLINK_SET;
UINT8 sendLevel = ESEND_LEVEL_ATS;
UINT8 chRouteCouplinkFlag = 0U;
UINT8 chRouteState = 0U;
UINT8 chSwitchUseSta = 0U;
UINT8 chPhyUseSta = 0U;
UINT16 startSignalId = 0U;
UINT8 checkRetVal = 0U;
if ((0U < wRouteId) && (ROUTE_SUM_MAX > wRouteId))
{
chlocalCiId = GetSystemParaLocalCiId(); /*获取本机联锁ID*/
chbelongCiId = GetRouteBelongCiId(wRouteId); /*获取进路所属联锁ID*/
if ((chlocalCiId == chbelongCiId) && (0U != chlocalCiId))
{
chReval = SetRouteCouplinkProcess(wRouteId, functionId, sendLevel);
chRouteCouplinkFlag = GetRouteCouplinkFlag(wRouteId);
if ((CI_SUCCESS == chReval) && (ROUTE_COUPLINK_FLAG_YES == chRouteCouplinkFlag))
{
chReval = SetRouteProc(wRouteId);
if (CI_SUCCESS == chReval)
{
chRouteState = GetRouteState(wRouteId);
if ((ROUTE_STATE_IDLE == chRouteState))
{
chPhyUseSta = RoutePhySectionUseLogicProcess(wRouteId);
if (CI_SUCCESS == chPhyUseSta)
{
chSwitchUseSta = CheckRouteContainSwitchUseSta(wRouteId);
if (CI_SUCCESS == chSwitchUseSta)
{
SetRouteStateManage(wRouteId, ROUTE_STATE_FIRST_XUANPAI); /*-->设置进路初选*/
}
else
{
/*设置错误码：道岔已征用*/
SetErrorData(functionId, CI_DEVICE_TYPE_ROUTE, wRouteId, ETYPE_SWT_USE_STATE, SWITCH_USING_YES, sendLevel);
}
}
else
{
/*错误码检查函数中已经设置*/
}
}
else if ((ROUTE_STATE_AUTO_UNLOCK == chRouteState) || (ROUTE_STATE_AUTO_UNLOCKERR == chRouteState))
{
/*进路自动解锁正常、自动解锁异常*/
chPhyUseSta = RoutePhySectionUseLogicProcess(wRouteId);
if (CI_SUCCESS == chPhyUseSta)
{
/*全部区段未征用*/
/*设置进路物理区段征用*/
SetRoutePhySectionOccupyState(wRouteId, PHYSICAL_SECTION_USING_YES);
SetRouteStateFlag(wRouteId, ROUTE_STATE_FLAG_YES); /*-->设置进路状态转移标志有效*/
(void)SetRouteXuanPaiStartCycNum(wRouteId, 0U);/*每次新的有效办理，都需要重新计算选排时间*/
}
else
{
/*错误码检查函数中已经设置*/
}
}
else if ((ROUTE_STATE_NEAR_LOCKERR == chRouteState) || (ROUTE_STATE_YUXIAN_LOCK == chRouteState)
|| (ROUTE_STATE_FIRST_LOCKERR == chRouteState)||(ROUTE_STATE_NEAR_LOCK == chRouteState))
{
/*完整锁闭*/
startSignalId = GetRouteStartSignalId(wRouteId);
checkRetVal = CheckTheDevIsNotOfDiffLine(CI_DEVICE_TYPE_SIGNAL, startSignalId);
if (CI_TRUE == checkRetVal)
{
/*信号重开*/
RepeatOpenSignalLogicManage(startSignalId);
}
else
{
/* 不执行 */
}
}
else
{
/* 不执行 */
}
}
else
{
/* 不执行 */
}
}
else
{
/* 不执行 */
}
}
else
{
/* 不执行 */
}
}
else
{
/* 不执行 */
}
}
/*
* 功能描述： 锁闭道岔逻辑管理
* 参数说明： void
* 返回值 ：
*/
void lockSwitchLogicManage(void)
{
UINT16 j = 0U;
UINT16 ii = 0U;
UINT16 dwSwitchTotalSum = 0U;
UINT8 localCiId = 0U; /*本地联锁ID*/
UINT16 switchId = 0U;
UINT16 hostSwitchNum = 0U;/*主体道岔数量*/
UINT16* pHostSwitchBuf = NULL;/*主体道岔Id缓存指针*/
UINT16 hostSwitchId = 0U;/*主体道岔ID*/
UINT16 hostPhyId = 0U;/*主体道岔物理区段ID*/
UINT16 wRLockBelongRouteId = 0U;
UINT8 retVal = CI_ERROR;
UINT16 wPLockBelongRouteId = 0u;
UINT16 wOverlapId = 0U;
UINT8 chSwitchCurPosition = 0U;
UINT8 chPortecSwitchPos = 0U;
localCiId = GetSystemParaLocalCiId(); /*获取本机联锁ID*/
dwSwitchTotalSum = GetTotalSwitchCurNum(); /*本联锁+相邻联锁*/
for (ii = 0u; ii < dwSwitchTotalSum; ii++)
{
switchId = GetSwitchId(ii); /*获取道岔ID*/
if ((0u < switchId) && (SWITCH_SUM_MAX >switchId))
{
hostSwitchNum = GetSwitchHostSwitchNum(switchId);
pHostSwitchBuf = GetSwitchHostSwitchIdBuf(switchId);
if ((hostSwitchNum > 0u) && (NULL != pHostSwitchBuf))
{
for (j = 0u; j < hostSwitchNum; j++)
{
hostSwitchId = pHostSwitchBuf[j];
hostPhyId = GetSwitchPhySectionId(hostSwitchId);/*获取主体道岔的道岔区段ID*/
if (0u == hostPhyId)
{
debug_infor_printf((const)"Error:hostSwitchId %d phySec is 0.\r\n", hostSwitchId);
}
else
{
/*根据物理区段进路锁闭状态锁闭防护道岔*/
wRLockBelongRouteId = GetPhySecRLockBelongRouteId(hostPhyId);
if (0u < wRLockBelongRouteId)
{
/*获取道岔当前是否已经被该进路设置了防护锁闭*/
retVal = GetSwitchThisRoutePLocked(switchId, wRLockBelongRouteId);
if (CI_ERROR == retVal)
{
/*检查道岔当前位置是否在进路要求的位置*/
chPortecSwitchPos = GetRouteThisPortecSwitchPos(wRLockBelongRouteId, switchId);
chSwitchCurPosition = GetSwitchCurPosition(switchId);
retVal = checkSwtLastValDrvPosStayorNot(switchId, chPortecSwitchPos); /*检查防护道岔是否存在反向驱动*/
if ((chPortecSwitchPos == chSwitchCurPosition) && (CI_SUCCESS == retVal))
{
SetSwitchLockStatus(SWITCH_PLOCKTYPE_ROUTE, wRLockBelongRouteId, switchId, SWITCH_LOCK_PROTECT_SET); /*设置道岔防护锁闭状态*/
}
else
{
/*不满足，则继续*/
}
}
}
/*根据物理区段保护区段锁闭状态锁闭防护道岔*/
wPLockBelongRouteId = GetPhySecPLockBelongRouteId(hostPhyId);
if (0u < wPLockBelongRouteId)
{
wOverlapId = GetRouteOverlapLockedId(wPLockBelongRouteId);/*获取进路当前锁闭的保护区段ID*/
retVal = GetSwitchThisOverlapPLocked(switchId, wOverlapId);/*获取当前道岔是否已经被该保护区段防护锁闭*/
if (CI_ERROR == retVal)
{/*未锁闭，则设置*/
/*检查道岔当前位置是否在进路要求的位置*/
chPortecSwitchPos = GetOverlapThisPortecSwitchPos(wOverlapId, switchId);
chSwitchCurPosition = GetSwitchCurPosition(switchId);
retVal = checkSwtLastValDrvPosStayorNot(switchId, chPortecSwitchPos); /*检查防护道岔是否存在反向驱动*/
if ((chPortecSwitchPos == chSwitchCurPosition) && (CI_SUCCESS == retVal))
{
/*设置保护区段关联防护道岔为防护锁闭*/
SetSwitchLockStatus(SWITCH_PLOCKTYPE_OVERLAP, wOverlapId, switchId, SWITCH_LOCK_PROTECT_SET);/*设置道岔防护锁闭状态*/
}
else
{
/*不满足，则继续*/
}
}
}
/*根据逻辑区段逻辑进路锁闭状态锁闭防护道岔*/
/*获取指定道岔所属逻辑区段，通过逻辑区段找到逻辑区段所属进路*/
/*预留*/
}
}
}
}
}
}
TSCP/src/APP/ciapp/LogicManage/InterlockLogicManage.h
+17 -3
View File
@@ -1142,12 +1142,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);
/*
* 功能描述： 更新列车向后跳跃允许状态处理
* 参数说明： 无
@@ -1155,6 +1155,20 @@ void OverlapZhaoChaRelayUpDateManage(void);
* Create: fan 20250725
*/
void TrainJumpBackApplyProc(void);
/*
* 功能描述： 办理联挂进路逻辑管理
* 参数说明： const UINT16 wRouteId
* 返回值 ： 无
* Create: 20250917
*/
void SetCouplinkRouteLogicManage(const UINT16 wRouteId);
/*
* 功能描述： 锁闭道岔逻辑管理
* 参数说明： void
* 返回值 ：
*/
void lockSwitchLogicManage(void);
#ifdef __cplusplus
}
TSCP/src/APP/ciapp/LogicManage/RouteRecoverManage.c
+83 -13
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)
{
@@ -763,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;
@@ -900,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;
@@ -1346,6 +1366,7 @@ UINT8 KeepCbtcLTrainRouteErrProcess(const UINT16 routeId)
UINT16 trainEnteringRouteState = 0u;
UINT8 signalCrossState = 0u;
UINT8 rcWorkMode = 0U; /*rc工作模式*/
UINT8 chRouteCouplinkFlag = 0U;
rcWorkMode = GetLocalRcWorkMode();
/* 联锁逻辑检查 */
@@ -1471,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)
{
/* 通过检查 */
@@ -1856,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)
@@ -1990,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)
{
/* 通过检查 */
@@ -3584,6 +3624,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;
@@ -3646,8 +3689,6 @@ static UINT8 OpenBlocRouteOverlapErrCheck(const UINT16 routeId)
reResult = CI_ERROR;
}
}
}
else
{
@@ -3690,6 +3731,12 @@ static UINT8 OpenBlocRouteOverlapErrCheck(const UINT16 routeId)
}
}
if (FUNC_SWITCH_ON == cSndSideProFuncSwitch)
{
/*二级侧防开关配置为支持二级侧防时，可不检查保护区段防护道岔位置及可动性，通过检查侧防条件防护*/
}
else
{
/*保护区段关联防护道岔【位置正确】*/
if (CI_SUCCESS == reResult)
{
@@ -3725,7 +3772,7 @@ static UINT8 OpenBlocRouteOverlapErrCheck(const UINT16 routeId)
reResult = CI_ERROR;
}
}
}
if (CI_SUCCESS == reResult)
{
@@ -3742,15 +3789,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))
@@ -4265,7 +4320,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();
/* 联锁逻辑检查 */
@@ -4292,18 +4348,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);/*检查是否是工程车接近的跨压*/
}
TSCP/src/APP/ciapp/LogicManage/TradInterlockLogicManage.c
+3 -3
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
{
TSCP/src/APP/ciapp/LogicProcess/InterlockLogicCheck.c
+2202 -468
View File
File diff suppressed because it is too large Load Diff
TSCP/src/APP/ciapp/LogicProcess/InterlockLogicCheck.h
+188 -51
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_点式进路开放信号保护区段联锁条件检查 */
/*
* 功能描述： 点式进路开放信号保护区段联锁条件检查
@@ -1862,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);
/*
* 功能描述： 进路区段全部联络线设备条件满足检查
@@ -2204,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);
/*
* 功能描述： 部分进路区段全部联络线设备条件满足检查
@@ -2499,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区域属性
@@ -2613,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);
@@ -2706,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);
/*
*函数功能：保护区段照查继电器检查
@@ -2761,28 +2771,155 @@ UINT8 RouteCldAttrCheck(UINT16 wRouteId);
* Created By LQ 2025.08.18
*/
UINT8 OverlapOccuUnlockCheck(UINT16 overlapId, UINT8 functionId);
/*
* 功能描述：办理联挂进路区段检查
* 参数说明：const UINT16 wRouteId 进路ID
* UINT16* pDevId 设备ID
* UINT8* pDevState 设备状态
* 返 回 值：CI_ERROR 0 失败
* CI_SUCCESS 1 成功
* Created By 2025.09.18
*/
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);
/*
* 功能描述：列车占用完全在指定区段检查
* 输入参数：const UINT16 wPhySecId 物理区段ID
* const UINT16 wTrainId 列车ID
* 输出参数：无
* 返回值 ：CI_ERROR 0 不完全在
* CI_SUCCESS 1 完全在
* by cgh 20251017
* 功能描述：单个侧防条件检查
* 参数说明：SideProtecStru SidePretectData 一项侧防条件
* UINT16 wDevId 设备ID
* UINT8 cDevType 设备类型
* UINT8 functionId 函数ID
* UINT8 sendLevel 发送等级
* 返 回 值：CI_ERROR 0 失败
* CI_SUCCESS 1 成功
*/
UINT8 TrainOccSameSecCheck(const UINT16 wPhySecId, const UINT16 wTrainId);
UINT8 SingleSideProtectCheck(SideProtecStru SidePretectData, UINT16 wDevId, UINT8 cDevType, UINT8 functionId, UINT8 sendLevel);
/*
* 功能描述：占用是否属于同一区段检查
* 输入参数：const UINT16 wBasePhySecId 基准物理区段ID
* const UINT16 wCheckPhySecId 待检查物理区段ID
* 输出参数：无
* 返回值 ：CI_ERROR 0 不属于
* CI_SUCCESS 1 属于
* by cgh 20251017
* 功能描述：侧防道岔位置检查
* 参数说明：SideProtecSwitchData* pSideProtecSwitchBuf 道岔侧防条件
* UINT8 chSideProtecSwitchNum 侧防道岔数量
* 返 回 值：CI_ERROR 0 侧防道岔位置连通
* CI_SUCCESS 1 侧防道岔位置不连通
*/
UINT8 OccBelSameSecCheck(const UINT16 wBasePhySecId, const UINT16 wCheckPhySecId);
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
+658 -186
View File
File diff suppressed because it is too large Load Diff
TSCP/src/APP/ciapp/LogicProcess/InterlockLogicProcess.h
+20 -3
View File
@@ -688,15 +688,15 @@ void LgcSecUnlockProc(const UINT16 routeId, const UINT16 logSectionId);
* 返回值 ： void
*/
void RouteLgcSecResReleaseProcess(const UINT16 wRouteId);
/*
* 功能描述： 检查保护区段人工解锁是否可执行
* 参数说明： const UINT16 overlapId, 保护区段ID
* const UINT32 dwOverlapUnlockCount 保护区段自动解锁周期数
* const UINT32 dwOverlapUnlockStartCyc 保护区段自动解锁起始周期
* 返回值 ： 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 overlapId, 保护区段ID
@@ -824,6 +824,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
+4 -1
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)*/
/*站台相关码位*/
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
+186 -10
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
{
@@ -976,3 +997,158 @@ 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
{
/*不处理*/
}
}
TSCP/src/APP/ciapp/Overlap/OverlapDataManage.h
+60 -5
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,20 @@ typedef struct S_OverlapDataStruct
UINT8 OverlapFromSetRouteCmdFlag;/*保护区段由进路办理时连带的标志*/
UINT8 cProSwitchCheckResultFlag; /*跨控区防护道岔检查结果标志（0xFF：默认值，0x55：失败，0xAA：成功）*/
UINT8 cProSwitchCheckStartFlag; /*跨控区防护道岔检查开始标志（0x55：检查开始，0xAA：检查停止）*/
UINT8 chPreLaborUnlockState; /*之前人工解锁状态*/
} 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 +66,19 @@ extern OverlapDataStruct OverlapDataStru[OVERLAP_SUM_MAX]; /*
OverlapDataStruct *
*/
OverlapDataStruct *GetOverlapData(void);
/*
* 功能描述： 获取指定ID保护区段数据-车车
* 参数说明：
* 返回值 ：
OverlapDataStructCC *
*/
/*
* 功能描述： 获取指定ID保护区段数据-车车
* 参数说明：
* 返回值 ：
OverlapDataStructCC *
*/
OverlapDataStructCC* GetOverlapDataCC(void);
/*
* 功能描述： 获取指定ID保护区段所属进路ID
@@ -138,7 +158,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 +166,7 @@ UINT16 GetOverlapUnlockApplyTrainId(const UINT16 overlapId);
/*
* 功能描述： 设置指定ID保护区段申请解锁的列车ID
* 参数说明： const UINT16 overlapId, 保护区段ID
* const UINT16 wTrainId，列车ID（不带0x14）
* const UINT16 wTrainId，列车ID（不带0x10）
* 返回值 ： 无
*
*/
@@ -360,6 +380,41 @@ 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);
#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
+93
View File
@@ -1066,3 +1066,96 @@ 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;
}
TSCP/src/APP/ciapp/PSD/PSDConfigDataManage.h
+30 -1
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,8 @@ typedef struct S_PsdConfigDataStruct
UINT16 wPsdSndProLinkId; /*屏蔽门防护link2ID*/
UINT16 wPsdTrdProLinkId; /*屏蔽门防护link3ID*/
UINT8 chPsdControlType; /*屏蔽门控制类型*/
UINT16 IncloudeEsbIdBuf[PSD_INCLUDE_ESB_NUM]; /*屏蔽门包含ESB ID*/
UINT8 IncloudeEsbNum; /*包含ESB数量*/
} PsdConfigDataStruct;
@@ -421,7 +425,32 @@ 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);
#ifdef __cplusplus
}
#endif
TSCP/src/APP/ciapp/PSD/PSDDataManage.c
+262 -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
{
@@ -2856,3 +2871,249 @@ 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
{
/*不处理*/
}
}
TSCP/src/APP/ciapp/PSD/PSDDataManage.h
+95
View File
@@ -22,6 +22,7 @@
#include "CommonTypes.h"
#include "../System/CiSystemDefine.h"
#include "../Relay/RelayConfigDataManage.h"
#include "CiInterfaceDefine.h"
#ifdef __cplusplus
extern "C" {
@@ -93,7 +94,18 @@ typedef struct S_PsdDataStruct
UINT32 dwPsdRelayDownCycNum; /*PSD门关继电器落下起始周期*/
} 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 +181,13 @@ void ResetPsdData(const UINT16 psdId);
*/
PsdDataStruct *GetPsdData(void);
/*
* 功能描述：获取指定ID屏蔽门数据CC
* 参数说明：无
* 返 回 值：车车屏蔽门动态数据
*/
PsdDataStructCC* GetPsdDataCC(void);
/*
* 功能描述： 获取指定ID屏蔽门互锁解除状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
@@ -1002,6 +1021,82 @@ 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);
#ifdef __cplusplus
}
#endif
TSCP/src/APP/ciapp/PSD/PSDDefine.h
+7 -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) /*屏蔽门打开之前信号关闭*/
@@ -207,4 +209,6 @@
#define HIGH_FOUR_CHAR ((UINT8)0U) /*高四字节*/
#define LOW_FOUR_CHAR ((UINT8)1U) /*低四字节*/
#define PSD_INCLUDE_ESB_NUM ((UINT8)10U) /*ESB个数*/
#endif
TSCP/src/APP/ciapp/ParsePack/CiInterfaceDefine.h
+11 -5
View File
@@ -135,9 +135,6 @@
#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) /*物理区段故障占用取消二次命令*/
@@ -165,6 +162,11 @@
#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 CI_CMD_PHYSEC_USING_APPLY ((UINT16)0x0001) /*物理区段征用申请*/
@@ -249,6 +251,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 +292,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) /*道岔引导总锁*/
@@ -448,15 +452,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
+1577 -945
View File
File diff suppressed because it is too large Load Diff
TSCP/src/APP/ciapp/ParsePack/ParsePackAtsData.h
+97 -3
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
{
@@ -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接收的操作命令结构体数组长度
@@ -408,6 +433,75 @@ UINT8 GetOcPscConfirmFlag(UINT8 index);
*/
void PackCiDataToAts(UINT8* ciToXianDiDataBuffer, UINT16* ii);
/**
* @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
+2574 -452
View File
File diff suppressed because it is too large Load Diff
TSCP/src/APP/ciapp/ParsePack/ParsePackCiData.h
+139 -14
View File
@@ -100,15 +100,16 @@
#define PHYSEC_LOCKDIRECTION_OPPST_YES ((UINT8)0xAA) /*取反*/
#define PHYSEC_LOCKDIRECTION_OPPST_DEFAULT ((UINT8)0xFF) /*默认值*/
#define CICI_VERSION ((UINT16)29) /*cici接口版本号，每次修改接口需要升级版本号——Last Modified On 2025.09.22*/
#define CICI_BEGIN_TO_STATION_LEN ((UINT16)16) /*从开始到站场长度止 cgh增加4个字节CI-CI校验信息*/
#define CICI_VERSION ((UINT8)30) /*cici接口版本号，每次修改接口需要升级版本号——Last Modified On 2025.11.04*/
#define CICI_BEGIN_TO_STATION_LEN ((UINT16)37) /*20251104更新为HLHT头长度+应用层保温内容前6字节*/
#define CICI_CICIVERINDEX (CICI_BEGIN_TO_STATION_LEN-6U-3U) /*20251104更新后CI接口版本信息索引*/
#define CICI_ONE_SWITCH_LEN ((UINT16)13) /*一个道岔数据长度*/
#define CICI_ONE_PHYSEC_LEN ((UINT16)23U)/*一个物理区段数据长度*/
#define CICI_ONE_LOGSEC_LEN ((UINT16)10)/*一个逻辑区段数据长度*/
#define CICI_ONE_LOGSEC_LEN ((UINT16)11)/*一个逻辑区段数据长度*/
#define CICI_ONE_SIGNAL_LEN ((UINT16)11)/*一个信号机数据长度*/
#define CICI_ONE_PSD_LEN ((UINT16)5)/*一个屏蔽门数据长度*/
#define CICI_ONE_ESB_LEN ((UINT16)4)/*一个ESB数据长度*/
#define CICI_ONE_ROUTE_LEN ((UINT16)12)/*一个进路数据长度*/
#define CICI_ONE_ROUTE_LEN ((UINT16)13)/*一个进路数据长度*/
#define CICI_ONE_PHYSEC_LOCKSTATE_LEN ((UINT16)10)/*一个物理区段锁闭状态数据长度*/
#define CICI_ONE_SPKS_LEN ((UINT16)4) /*一个SPKS数据长度*/
#define CICI_ONE_VIRTUAL_RELAY_LEN ((UINT16)3) /*一个虚拟SPKS数据长度*/
@@ -125,6 +126,14 @@
#define CICI_DR_CMD_FULL ((UINT8)0xaa) /*完整子进路*/
#define CICI_DR_CMD_LOGIC ((UINT8)0xbb) /*逻辑子进路*/
#define LOCAL_CI_RC_INTER_TYPE ((UINT16)0x0306U) /*本控区CI-RC接口类型*/
#define LOCAL_RC_TO_CI_INFO_DEV_STATE ((UINT16)0x0301U) /*本控区RC发送本控区CI设备状态帧*/
#define LOCAL_CI_TO_RC_INFO_HEART ((UINT16)0x0302U) /*本控区CI发送本控区RC心跳帧*/
#define LOCAL_RCI_INFO_STATE ((UINT16)0x0303U) /*同模式联锁间接口类型*/
#define LOCAL_CI_RC_PRTCL_VER ((UINT8)0x01U) /*本控区CI-RC协议版本号*/
/*物理区段数据结构体*/
typedef struct S_IntconPhySecDataStruct
{
@@ -269,21 +278,16 @@ extern "C" {
extern ToCiAreaIteCutStruct szRecvCiAreaIteCut[CI_COM_CI_MAX_NUM];
extern ToCiAreaIteCutStruct szSendCiAreaIteCut[CI_COM_CI_MAX_NUM];
/*
* 功能描述： 解析CI数据
* 参数说明： void
* 返回值 ： 0: 解析失败
* 1: 解析成功
*/
UINT8 ParseCiToCiData(void);
/*
* 功能描述： 解析CI单帧数据
* 参数说明： void
* 参数说明： UINT8* dataBuf 解析数据, UINT16 dataLength 长度,UINT8 chSendCiId 发送方id
* 返回值 ： 0:解析失败
* 1:解析成功
* @note 内部优化 20220419 wqm
1、编码规范：函数dsuCheckSameLoc返回值需要变量承接
2、增加返回值判断
*/
UINT8 ParseCiToCiDataFrame(UINT8* dataBuf, UINT16 dataLength);
UINT8 ParseCiToCiDataFrame(UINT8* dataBuf, UINT16 dataLength, UINT8 sourceId);
/*
* 功能描述： 校验相邻CI间单帧数据
@@ -1011,6 +1015,127 @@ UINT8 PackManufacDefPacket(UINT8* pInputBuf, UINT16* pItemLen, const UINT8 dstCi
*/
UINT8 ParseManufacDefPacket(const UINT8* pInputData, UINT16* pItemLen, const UINT8 srcCiId);
/*
* 功能描述：组CI到本控区RC单帧数据
* 参数说明：const UINT8 cRcId 目标RC ID
* 返 回 值：CI_ERROR 0 组数据失败
* CI_SUCCESS 1:组数据成功
* Created By LQ 2025.11.04
*/
UINT8 PackCiToLocalRcDataFrame(const UINT8 cRcId);
/*
* 功能描述：解析CI到本控区RC单帧数据
* 参数说明：const UINT8* dataBuf 数据缓冲区
* const UINT16 dataLength 数据长度
* const UINT8 systemId 源设备ID
* 返 回 值：CI_ERROR 0 组数据失败
* CI_SUCCESS 1 组数据成功
* Created By LQ 2025.11.04
*/
UINT8 ParseCiToLocalRcDataFrame(const UINT8* pDataBuf, const UINT16 dataLength, const UINT8 systemId);
/*
* 功能描述：组RC到本控区CI单帧数据
* 参数说明：const UINT8 cCiId 目标CI ID
* 返 回 值：CI_ERROR 0 组数据失败
* CI_SUCCESS 1 组数据成功
* Created By LQ 2025.11.05
*/
UINT8 PackRcToLocalCiDataFrame(const UINT8 cCiId);
/*
* 功能描述：解析RC到本控区CI单帧数据
* 参数说明：const UINT8* dataBuf 数据缓冲区
* const UINT16 dataLength 数据长度
* const UINT8 systemId 源设备ID
* 返 回 值：CI_ERROR 0 组数据失败
* CI_SUCCESS 1 组数据成功
* Created By LQ 2025.11.05
*/
UINT8 ParseRcToLocalCiDataFrame(const UINT8* pDataBuf, const UINT16 dataLength, const UINT8 systemId);
/*
* 功能描述：校验本控区RC发给CI的单帧数据
* 参数说明：UINT8* pDataBuf 输入数据信息
* UINT16 dataLength 输入数据长度
* UINT8 *pErrNo 校验失败故障码
* 返 回 值：CI_ERROR 0 校验失败
* CI_SUCCESS 0 校验成功
* Created By LQ 2025.11.05
*/
UINT8 ParseRcToLocalCiDataCheck(UINT8* pDataBuf, UINT16 dataLength, UINT8* pErrNo);
/*
* 功能描述：校验本控区RC发给CI的进路数据
* 参数说明：const UINT8* dataBuf 待解析的数据
* UINT16* index 索引
* 返 回 值：0 校验失败
* 1 校验成功
* Created By LQ 2025.11.05
*/
UINT8 CheckLocalRcToCiRouteData(const UINT8* dataBuf, UINT16* index);
/*
* 功能描述：校验本控区RC发给CI的信号机数据
* 参数说明：const UINT8* dataBuf 待解析的数据
* UINT16* index 索引
* 返 回 值：0 校验失败
* 1 校验成功
* Created By LQ 2025.11.05
*/
UINT8 CheckLocalRcToCiSignalData(const UINT8* dataBuf, UINT16* index);
/*
* 功能描述：校验本控区RC发给CI的计轴区段数据
* 参数说明：const UINT8* dataBuf 待解析的数据
* UINT16* index 索引
* 返 回 值：0 校验失败
* 1 校验成功
* Created By LQ 2025.11.05
*/
UINT8 CheckLocalRcToCiAxisSecData(const UINT8* dataBuf, UINT16* index);
/*
* 功能描述：校验本控区RC发给CI的逻辑区段数据
* 参数说明：const UINT8* dataBuf 待解析的数据
* UINT16* index 索引
* 返 回 值：0 校验失败
* 1 校验成功
* Created By LQ 2025.11.05
*/
UINT8 CheckLocalRcToCiLogSecData(const UINT8* dataBuf, UINT16* index);
/*
* 功能描述：校验本控区RC发给CI的物理区段数据
* 参数说明：const UINT8* dataBuf 待解析的数据
* UINT16* index 索引
* 返 回 值：0 校验失败
* 1 校验成功
* Created By LQ 2025.11.05
*/
UINT8 CheckLocalRcToCiPhySecData(const UINT8* dataBuf, UINT16* index);
/*
* 功能描述：校验本控区RC发给CI的屏蔽门数据
* 参数说明：const UINT8* dataBuf 待解析的数据
* UINT16* index 索引
* 返 回 值：0 校验失败
* 1 校验成功
* Created By LQ 2025.11.05
*/
UINT8 CheckLocalRcToCiPsdData(const UINT8* dataBuf, UINT16* index);
/*
* 功能描述：校验本控区RC发给CI的雨雪数据
* 参数说明：const UINT8* dataBuf 待解析的数据
* UINT16* index 索引
* 返 回 值：0 校验失败
* 1 校验成功
* Created By LQ 2025.11.05
*/
UINT8 CheckLocalRcToCiSnowData(const UINT8* dataBuf, UINT16* index);
#ifdef __cplusplus
}
#endif
TSCP/src/APP/ciapp/ParsePack/ParsePackCommon.c
+111 -21
View File
@@ -31,7 +31,8 @@
PlatHeartDataStruct RecvHeartDataStru = { 0U }; /*平台心跳帧数据结构*/
PlatGPIODataStruct RecvPlatDataStruGPIO = { 0U };/*平台0x2D帧数据结构 GPIO采集状态*/
PlatGPIOToleranceDataStruct gPlatDataGPIOTolercance = { 0U };/*平台硬件采集故障容忍记录数据*/
PlatGPIOToleranceDataStruct gPlatDataGPIOTolercance = { 0U };/*平台硬件采集故障容忍*/
/*
* 功能描述： 信号机相关码位处理
@@ -797,6 +798,7 @@ UINT8 PhySectionMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8
UINT8 phySecStopSteadyFlag = 0u;
UINT8 chPhyFree = CI_ERROR;
UINT8 gdDLline = 0u; /*线路是否采用轨道电路*/
UINT8 cFuncRet = CI_ERROR;
funcSwitchJumpLockDriveSwitch = GetCiFunctionSwitchConfig(FUNC_SWITCH_JUMPLOCK_DRIVE_SWITCH);
/*判断是否采用轨道电路*/
gdDLline = GetCiFunctionSwitchConfig(FUNC_CLD_GD_DIANLU_LINE);
@@ -831,16 +833,24 @@ UINT8 PhySectionMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8
phySecLockState = GetPhySecLockState(DeviceId);
localCiType = GetLocalCiType();
phyIntruSecVainCheck = PhysicalIntruSecVainCheck(DeviceId);
if (((PHYSICAL_SECTION_LOCK_NORMAL == phySecLockState) ||
(PHYSICAL_SECTION_LOCK_DELAY == phySecLockState) ||
(PHYSICAL_SECTION_LOCK_FAULTDELAY == phySecLockState) ||
((PHYSICAL_SECTION_LOCK_EXCEPT == phySecLockState) && (CI_TYPE_CLD == localCiType)))
&& (CI_SUCCESS == phyIntruSecVainCheck))
{/*正常锁闭或延时解锁或区故解延时,车辆段且异常锁闭也发送锁闭状态,当该区段对应的侵限条件成立，则向ZC发送未锁闭，20190308*/
cFuncRet = PhySecLockMaskSideProtectCheck(DeviceId); /*侧防条件检查*/
if (CI_SUCCESS== cFuncRet)
{
SetMaskValue(MaskId, dataBuf);
}
else
{
/*侧防条件不满足，发0未锁闭*/
}
}
else
{
}
@@ -1200,7 +1210,7 @@ UINT8 LogicSectionMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UIN
UINT8 cLogSecLogicLockState = LOG_SECTION_LOCK_NO; /*逻辑区段逻辑锁闭状态*/
UINT8 cLogSecLockDir = CI_SYSTEM_DIRECTION_NONE; /*逻辑区段锁闭方向*/
UINT8 chLogSecBelLogRouteSum = 0U;/*逻辑区段所属逻辑进路数目*/
UINT8 chLogSecEmergXianSu = 0U;/*逻辑区段紧急临时限速状态*/
switch (MaskType)
{
case MASK_TYPE_LOGICSECTION_UTOCCUPY:
@@ -1378,6 +1388,19 @@ UINT8 LogicSectionMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UIN
SetMaskValue(MaskId, dataBuf);
}
break;
case MASK_TYPE_LOGICSECTION_EMERG_XIANSU:
/* 逻辑区段紧急临时限速状态 */
chLogSecEmergXianSu = GetLogSecEmergXianSu(DeviceId);
if (LOGSEC_EMERG_XS_SET_NO == chLogSecEmergXianSu)
{
/*未设置限速码位为0*/
}
else
{
/*设置码位为1*/
SetMaskValue(MaskId, dataBuf);
}
break;
default:
returnValue = CI_ERROR;
@@ -1493,6 +1516,8 @@ UINT8 OverlapMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* d
returnValue = CI_ERROR;
}
if (CI_SUCCESS == returnValue)
{
SetMaskValue(MaskId, dataBuf);
@@ -2777,6 +2802,9 @@ UINT8 OverlapValidMaskCheck(const UINT16 rtOverlapLockedId)
UINT8 devState = 0u;
UINT32 laborUnlockStartCycNum = 0u;
UINT8 functionId = EFUNC_OVERLAP_VALIDMASK_CHECK;
UINT8 cSndSideProFuncSwitch = 0U;
cSndSideProFuncSwitch = GetSndSideProtectFuncSwitch(); /*二级侧防功能开关*/
if (0u != rtOverlapLockedId)
{
@@ -2797,6 +2825,10 @@ UINT8 OverlapValidMaskCheck(const UINT16 rtOverlapLockedId)
returnValue = CI_ERROR;
break;
}
else
{
/*不处理*/
}
}
if (ii == overlapPhySecSum)
@@ -2818,7 +2850,7 @@ UINT8 OverlapValidMaskCheck(const UINT16 rtOverlapLockedId)
(SWITCH_LOCK_FENGSUO_NO == GetSwitchFLockState(condSwiDataIdBuf[ii].SwitchId)) &&
(condSwiDataIdBuf[ii].SwitchPosition == GetSwitchCurPosition(condSwiDataIdBuf[ii].SwitchId)))
{
/* 保护区段所包含的道岔为：非引导总锁且未封锁且道岔位置正确，才发送码位*/
/* 保护区段所包含的道岔为：非引导总锁且未封锁且道岔位置正确，非连通位置不存在侵入，才发送码位*/
}
else
@@ -2829,6 +2861,10 @@ UINT8 OverlapValidMaskCheck(const UINT16 rtOverlapLockedId)
}
}
}
else
{
/*不处理*/
}
if (CI_SUCCESS == returnValue)
{ /*保护区段关联防护道岔*/
@@ -2840,13 +2876,12 @@ UINT8 OverlapValidMaskCheck(const UINT16 rtOverlapLockedId)
ylockStatus = GetSwitchYLockState(protSwiDataIdBuf[ii].ProtectSwitchId);
switchPos = GetSwitchCurPosition(protSwiDataIdBuf[ii].ProtectSwitchId);
fengsuoStateus = GetSwitchFLockState(protSwiDataIdBuf[ii].ProtectSwitchId);
if ((SWITCH_LOCK_YINZONG_NO == ylockStatus)
&& ((SWITCH_LOCK_STATUS_PROTECT == lockStatus) || (SWITCH_LOCK_STATUS_DAP == lockStatus))
&& (protSwiDataIdBuf[ii].ProtectPosition == switchPos)
&& ((((SWITCH_LOCK_STATUS_PROTECT == lockStatus) || (SWITCH_LOCK_STATUS_DAP == lockStatus)) && (protSwiDataIdBuf[ii].ProtectPosition == switchPos))
|| (FUNC_SWITCH_ON == cSndSideProFuncSwitch))
&& (SWITCH_LOCK_FENGSUO_NO == fengsuoStateus))
{
/* 保护区段关联防护道岔：非引导总锁且防护锁闭且道岔位置正确且未封锁，才发送码位*/
/* 保护区段关联防护道岔：非引导总锁且防护锁闭且（防护道岔位置正确或支持二级侧防）且未封锁，才发送码位*/
}
else
{
@@ -2855,6 +2890,10 @@ UINT8 OverlapValidMaskCheck(const UINT16 rtOverlapLockedId)
}
}
}
else
{
/*不处理*/
}
if (CI_SUCCESS == returnValue)
{
@@ -2868,6 +2907,10 @@ UINT8 OverlapValidMaskCheck(const UINT16 rtOverlapLockedId)
returnValue = CI_ERROR;
}
}
else
{
/*不处理*/
}
if (CI_SUCCESS == returnValue)
{
@@ -2880,6 +2923,10 @@ UINT8 OverlapValidMaskCheck(const UINT16 rtOverlapLockedId)
returnValue = CI_ERROR;
}
}
else
{
/*不处理*/
}
/*检查保护区段关联防淹门状态*/
if (CI_SUCCESS == returnValue)
@@ -2889,7 +2936,16 @@ UINT8 OverlapValidMaskCheck(const UINT16 rtOverlapLockedId)
{
SetErrorData(functionId, CI_DEVICE_TYPE_FLOODGATE, devId, devStateType, devState, ESEND_LEVEL_ZERO);
}
else
{
/*不处理*/
}
}
else
{
/*不处理*/
}
/*检查人工解锁保护区段是否处于倒计时过程中，倒计时过程中发ZC,LEU未建立*/
if (CI_SUCCESS == returnValue)
{
@@ -2898,6 +2954,14 @@ UINT8 OverlapValidMaskCheck(const UINT16 rtOverlapLockedId)
{
returnValue = CI_ERROR;
}
else
{
/*不处理*/
}
}
else
{
/*不处理*/
}
/*检查照查继电器状态*/
@@ -2915,6 +2979,28 @@ UINT8 OverlapValidMaskCheck(const UINT16 rtOverlapLockedId)
returnValue = CI_ERROR;
}
}
else
{
/*不处理*/
}
if (CI_SUCCESS == returnValue)
{
if (FUNC_SWITCH_ON == cSndSideProFuncSwitch)
{
/*仅在二级侧防开关配置为支持二级侧防时才进行侧防条件检查*/
returnValue = OlapSideProtectConditionCheck(rtOverlapLockedId, 0U, 0U);/*检查保护区段侧防条件*/
}
else
{
/*不处理*/
}
}
else
{
/*不处理*/
}
}
else
{
@@ -3163,22 +3249,22 @@ void PackCiToCimCommData(void)
/*相邻CI系统通信状态*/
deviceSum = GetCiTransmitSpecifySysDevSum(CI_SYSTEM_TYPE_CI);
pDeviceIdBuf = GetCiTransmitSpecifySysDevBuf(CI_SYSTEM_TYPE_CI);
deviceSum = GetCiTransmitSpecifySysDevSum(CI_SYSTEM_TYPE_RCI);
pDeviceIdBuf = GetCiTransmitSpecifySysDevBuf(CI_SYSTEM_TYPE_RCI);
if ((NULL != pDeviceIdBuf) && (0u != deviceSum))
{
for (j = 0u; j < deviceSum; j++)
{
transmitState = Get2oo2CiAndOtherSysCommState(CI_SYSTEM_TYPE_CI, j);
transmitState = Get2oo2CiAndOtherSysCommState(CI_SYSTEM_TYPE_RCI, j);
/*填ID*/
transmitDevSum++;
ciToCimDataBuffer[i++] = CI_SYSTEM_TYPE_CI;
ciToCimDataBuffer[i++] = CI_SYSTEM_TYPE_RCI;
ciToCimDataBuffer[i++] = pDeviceIdBuf[j];
/*组相邻RC/CI通信冗余周期*/
dwRecvCycNum = GetCiTransmitRecvDataCycNum(cLocalCiId, CI_SYSTEM_TYPE_CI, pDeviceIdBuf[j]);
dwRecvCycNum = GetCiTransmitRecvDataCycNum(cLocalCiId, CI_SYSTEM_TYPE_RCI, pDeviceIdBuf[j]);
if ((0U != dwRecvCycNum) && (UINT8_MAX > (dwCurCycNum - dwRecvCycNum)))
{
ciToCimDataBuffer[i] = (UINT8)(dwCurCycNum - dwRecvCycNum); /*组通信设备冗余周期*/
@@ -3943,7 +4029,9 @@ void PackCiToCimDeviceData(void)
PhysicalSectionDataStruct* pPhysicalData = NULL;
WashMachineDataStruct* pWashMachineData = NULL;
GaragedoorDataStruct* pGrageDoorData = NULL;
GaragedoorDataStructCC* pGrageDoorDataCC = NULL;
FloodGateDataStruct* pFloodGateData = NULL;
FloodGateDataStructCC* pFloodGateDataCC = NULL;
UINT8 cRcWorkMode = GetLocalRcWorkMode();
UINT8 chSwitchJichaState = 0U;
UINT8 chSwitchCurPos = 0U;
@@ -4194,6 +4282,7 @@ void PackCiToCimDeviceData(void)
/*打印车库门数据*/
deviceNum = GetGaragedoorSum();
pGrageDoorData = GetGaragedoorData();
pGrageDoorDataCC = GetGaragedoorDataCC();
ShortToChar(deviceNum, &ciToCimDataBuffer[ii]);/*车库门数量*/
ii += 2u;
for (jj = 0u; jj < deviceNum; jj++)
@@ -4207,7 +4296,7 @@ void PackCiToCimDeviceData(void)
ii += 2u;
ciToCimDataBuffer[ii++] = pGrageDoorData[deviceId].GaragedoorState; /*车库门状态 (动态字段)*/
ciToCimDataBuffer[ii++] = pGrageDoorData[deviceId].GaragedoorAllowCloseFlag; /*车库门允许关门标志 ZC*/
ciToCimDataBuffer[ii++] = pGrageDoorData[deviceId].GDAllowCloseFlagIVOC; /*车库门允许关门标志 IVOC*/
ciToCimDataBuffer[ii++] = pGrageDoorDataCC[deviceId].GDAllowCloseFlagIVOC; /*车库门允许关门标志 IVOC*/
ciToCimDataBuffer[ii++] = pGrageDoorData[deviceId].GaragedoorModeState; /*车库门模式状态*/
ciToCimDataBuffer[ii++] = pGrageDoorData[deviceId].GaragedoorFaultState; /*车库门故障状态*/
ciToCimDataBuffer[ii++] = pGrageDoorData[deviceId].GaragedoorPangLuState; /*车库门旁路状态*/;
@@ -4215,7 +4304,7 @@ void PackCiToCimDeviceData(void)
ciToCimDataBuffer[ii++] = pGrageDoorData[deviceId].cmdProcessState; /* 命令处理状态 */
LongToChar(pGrageDoorData[deviceId].waiteZCResponseStartCycNum, &ciToCimDataBuffer[ii]);/* 等待ZC反馈开始时间 */
ii += 4u;
LongToChar(pGrageDoorData[deviceId].waiteIVOCResponseStartCycNum, &ciToCimDataBuffer[ii]);/* 等待IVOC反馈开始时间 */
LongToChar(pGrageDoorDataCC[deviceId].waiteIVOCResponseStartCycNum, &ciToCimDataBuffer[ii]);/* 等待IVOC反馈开始时间 */
ii += 4u;
LongToChar(pGrageDoorData[deviceId].GaragedoorOpenStartCycNum, &ciToCimDataBuffer[ii]);/* 车库门打开开始周期 */
ii += 4u;
@@ -4227,6 +4316,7 @@ void PackCiToCimDeviceData(void)
/*打印防淹门数据*/
deviceNum = GetFloodGateCurSum();
pFloodGateData = GetFloodGateData();
pFloodGateDataCC = GetFloodGateDataCC();
ShortToChar(deviceNum, &ciToCimDataBuffer[ii]);/*防淹门数量*/
ii += 2u;
for (jj = 0u; jj < deviceNum; jj++)
@@ -4254,9 +4344,9 @@ void PackCiToCimDeviceData(void)
ciToCimDataBuffer[ii++] = pFloodGateData[deviceId].CurAgreeCloseStateOut; /* 当前同意关门输出状态（动态字段）*/
LongToChar(pFloodGateData[deviceId].CurFloodGateDelayCloseStartCyc, &ciToCimDataBuffer[ii]);/* 防淹门接近区段占压延时关门开始时间 */
ii += 4u;
ciToCimDataBuffer[ii++] = pFloodGateData[deviceId].FloodGateCloseApplyIvocSum; /*防淹门关门申请列车数量*/
ciToCimDataBuffer[ii++] = pFloodGateData[deviceId].FloodGateCloseAnsIvocSum; /*防淹门关门允许，列车回复数量*/
ciToCimDataBuffer[ii++] = pFloodGateData[deviceId].FloodGateAccessUTFlag; /*防淹门接近区段是否有非通信车标志*/
ciToCimDataBuffer[ii++] = pFloodGateDataCC[deviceId].FloodGateCloseApplyIvocSum; /*防淹门关门申请列车数量*/
ciToCimDataBuffer[ii++] = pFloodGateDataCC[deviceId].FloodGateCloseAnsIvocSum; /*防淹门关门允许，列车回复数量*/
ciToCimDataBuffer[ii++] = pFloodGateDataCC[deviceId].FloodGateAccessUTFlag; /*防淹门接近区段是否有非通信车标志*/
}
@@ -5068,7 +5158,7 @@ void PackCiToCimFlyProtectData(void)
pFlyData = GetFlyProtectData(chIndex);
wTrainId = pFlyData->wTrainId;
TrainFlyAxis = pFlyData->flyProtectSecCnt;
(void)dquDevName2HlhtId((UINT16)(CI_SYSTEM_TYPE_VOBC * 256U) + wTrainId, 0U, &dwTrainId); /*两字节列车ID转换为4字节互联互通ID*/
(void)dquDevName2HlhtId((UINT16)(CI_SYSTEM_TYPE_IVOC * 256U) + wTrainId, 0U, &dwTrainId); /*两字节列车ID转换为4字节互联互通ID*/
LongToChar(dwTrainId, &ciToCimDataBuffer[ii]); /* 列车ID */
ii += 4u;
@@ -5136,8 +5226,8 @@ void PackCiToCimCollDiffData(void)
{/*不处理*/
}
debug_infor_printf((const)"IO Compare Diff OCnum = %d\n", gDiffDataOcNum);
debug_out_array(0xAA, ciToCimDataBuffer, ii);
(void)debug_infor_printf((const)"IO Compare Diff OCnum = %d\n", gDiffDataOcNum);
(void)debug_out_array(0xAA, ciToCimDataBuffer, ii);
/*发送维护机*/
(void)DarkInfoPack(CIM_INFO_IO_COLL_DIFF_ALARM, ciToCimDataBuffer, ii);
TSCP/src/APP/ciapp/ParsePack/ParsePackCommon.h
+2
View File
@@ -45,6 +45,7 @@
#include "../DataManage/PlatDataManage.h"
#include "../IO/DeviceRelayDataProcess.h"
#ifdef __cplusplus
extern "C" {
#endif
@@ -61,6 +62,7 @@ extern "C" {
extern PlatHeartDataStruct RecvHeartDataStru;
extern PlatGPIODataStruct RecvPlatDataStruGPIO;
extern PlatGPIOToleranceDataStruct gPlatDataGPIOTolercance;
/*
* 功能描述： 信号机相关码位处理
* 参数说明： UINT8 MaskType, 码位类型
TSCP/src/APP/ciapp/ParsePack/ParsePackGateWayData.c
+1 -1
View File
@@ -2618,7 +2618,7 @@ UINT8 PackTiocToGateWayData(const UINT8 deviceId, const UINT8 targetDevType)
pFlyData = GetFlyProtectData(chIndex);
wTrainId = pFlyData->wTrainId;
TrainFlyAxis = pFlyData->flyProtectSecCnt;
chRtn = dquDevName2HlhtId((UINT16)(CI_SYSTEM_TYPE_VOBC * 256U) + wTrainId, 0U, &dwTrainId); /*两字节列车ID转换为4字节互联互通ID*/
chRtn = dquDevName2HlhtId((UINT16)(CI_SYSTEM_TYPE_IVOC * 256U) + wTrainId, 0U, &dwTrainId); /*两字节列车ID转换为4字节互联互通ID*/
if (chRtn == CI_SUCCESS)
{/*互联互通ID查询成功*/
LongToChar(dwTrainId, &szToGateWayDataBuf[ii]); /* 列车ID */
TSCP/src/APP/ciapp/ParsePack/ParsePackITEData.c
+2 -2
View File
@@ -166,7 +166,7 @@ UINT8 ParseIteToCiDataFrame(const UINT8* pDataBuf, const UINT16 dataLength, cons
wIteName = (CI_SYSTEM_TYPE_ITE) * 256U + systemId;
cLocalCiId = GetSystemParaLocalCiId();
wCiName = (CI_SYSTEM_TYPE_CI) * 256U + cLocalCiId;
wCiName = (CI_SYSTEM_TYPE_RCI) * 256U + cLocalCiId;
/*解析通用消息包头*/
strHlhtGalHead.devInterInfoType = ShortFromChar(&pDataBuf[ii]);
@@ -383,7 +383,7 @@ UINT8 PackCiToIteDataFrame(const UINT8 iteId, const UINT16 iteLogId)
{
/*首先获取组包时所需的信息，获取成功才继续组包*/
cLocalCiId = GetSystemParaLocalCiId();
cFuncRet = dquDevName2HlhtId(((UINT16)CI_SYSTEM_TYPE_CI * 256U + cLocalCiId), 0U, &dwCiEtcsId);
cFuncRet = dquDevName2HlhtId(((UINT16)CI_SYSTEM_TYPE_RCI * 256U + cLocalCiId), 0U, &dwCiEtcsId);
cFuncRet &= dquDevName2HlhtId(((UINT16)CI_SYSTEM_TYPE_ITE * 256U) + iteId, iteLogId, &dwIteEtcsId);
cFuncRet &= GetCiEmapCheckVer(cLocalCiId, &dwEmapCheckVer, CI_SYSTEM_TYPE_ITE);
pstrHlhtHeadCtx = GetIteHLHTHeadCtx(iteId, iteLogId); /*获取指定ITE互联互通报文头上下文数据*/
TSCP/src/APP/ciapp/ParsePack/ParsePackManage.c
+200 -40
View File
@@ -206,6 +206,13 @@ UINT8 ParseOtherSysToCiData(void)
UINT8 isBreak = 0u; /*退出遍历*/
UINT16 wTiocRcvAtsGtwyDevTypeId = 0U;
UINT8 errorNO_Type = 0u; /*CI间接口校验数据故障码*/
UINT8 cLocalDevType = 0U; /*本地设备类型*/
UINT8 cLocalCiId = 0U; /*本地ID*/
UINT8 cWorkMode = 0U;/*当前工作模式*/
UINT8 chCurSystemAreaState = 0U; /*当前系统区域状态*/
cWorkMode = GetLocalRcWorkMode();
curSysCount = MSCP_GetSysCount();
wTiocRcvAtsGtwyDevTypeId = GetTiocTrnsmtGtwyDevTypeId();
@@ -232,36 +239,20 @@ UINT8 ParseOtherSysToCiData(void)
debug_out_array(0x11, data, (UINT16)dataLen);
#endif/*平台打印结束*/
#endif/*日志打印结束*/
ocId = (UINT8)GetCiIdByOcId(devId);
ocId = GetCiIdByOcId(devId);
chLocalCiId = GetSystemParaLocalCiId();
if (ocId == chLocalCiId)/*如果oc id所属的ci id为本机联锁id*/
{
oc2ciParseResult = ParseOcToCiDataFrame(data, (UINT16)dataLen, devId);
if (CI_CHECK_LEN_ERROR == oc2ciParseResult)
if (CI_SUCCESS == oc2ciParseResult)
{
/*长度校验错误处理，把此OC原始缓存所有设备状态导向安全*/
/* 长度校验失败处理：
* 1. 当周期，OC原始数据缓存设备状态、轨道板状态、DI板卡状态、DO板卡状态置安全态。
* 2. 因为CI与此OC通信周期不更新，超过CI OC通信中断最大容忍周期数，也会置通信中断，所有设备状态导向安全。
*/
ResetOcOriginalState(devId);
ConvertOcOriginDataToPtData();/*把解析的OC板卡数据转换为OC点位数据*/
ConvertOcOriginDataToOcSigSwDev();/*把解析的OC设备数据转换为OC 信号机和 OC 道岔设备数据和OC轨道区段数据*/
debug_infor_printf((const)"OC Id %d len check ERROR.", devId);
}
else if (CI_SUCCESS == oc2ciParseResult)
{/*解析成功，转换OC板卡数据*/
ConvertOcOriginDataToPtData();/*把解析的OC板卡数据转换为OC点位数据*/
ConvertOcOriginDataToOcSigSwDev();/*把解析的OC设备数据转换为OC 信号机和 OC 道岔设备数据和OC轨道区段数据*/
debug_infor_printf((const)"\nconvert succeed\n");
/*解析成功，在ProcessOcToCiDat中处理数据(因RC备用时依赖CI同步数据)*/
debug_infor_printf((const)"\nOC %d DataCheck succeed\n", devId);
}
else
{
/*其它值，清除缓存数据*/
ResetOcOriginalState(devId);
ConvertOcOriginDataToPtData();/*把解析的OC板卡数据转换为OC点位数据*/
ConvertOcOriginDataToOcSigSwDev();/*把解析的OC设备数据转换为OC 信号机和 OC 道岔设备数据和OC轨道区段数据*/
debug_infor_printf((const)"OC Id %d parse ERROR.", devId);
/*其它值，什么也不做*/
/*解析OC数据错误处理，未同步数据，在ProcessOcToCiDat中会通信中断*/
}
}
else
@@ -283,10 +274,19 @@ UINT8 ParseOtherSysToCiData(void)
{
debug_infor_printf((const)"\nATS_RECV:%d", dataLen);
checkResult = ParseAtsOrXianDiToCiDataFrame(data, (UINT16)dataLen);
checkResult = ParseAtsOrXianDiToCiDataFrame(data, (UINT16)dataLen, CI_SYSTEM_TYPE_ATS, devId);
chCurSystemAreaState = GetLocalCiBackUpPattern();
if (SYSTEM_WORK_MODE_MAIN == chCurSystemAreaState)
{
(void)DarkInfoPack(CIM_INFO_ATS_TO_RCI_DATA, data, (UINT16)dataLen);
}
else
{
; /*非主系不组包*/
}
}
else
{
debug_infor_printf((const)"\nGATEWAY_RECV:%d", dataLen);
@@ -312,9 +312,18 @@ UINT8 ParseOtherSysToCiData(void)
#endif/*平台打印结束*/
#endif
checkResult = ParseAtsOrXianDiToCiDataFrame(data, (UINT16)dataLen);
checkResult = ParseAtsOrXianDiToCiDataFrame(data, (UINT16)dataLen, CI_SYSTEM_TYPE_XIANDI, devId);
chCurSystemAreaState = GetLocalCiBackUpPattern();
if (SYSTEM_WORK_MODE_MAIN == chCurSystemAreaState)
{
(void)DarkInfoPack(CIM_INFO_ATS_TO_RCI_DATA, data, (UINT16)dataLen);
}
else
{
; /*非主系不组包*/
}
if (CI_ERROR == checkResult)
{
debug_infor_printf((const)"parse xiandi id %d error.", devId);
@@ -324,6 +333,7 @@ UINT8 ParseOtherSysToCiData(void)
}
break;
case CI_SYSTEM_TYPE_CI:
case CI_SYSTEM_TYPE_RC:
/*解析CI数据*/
#ifdef LOGPRINT/*日志打印宏*/
#ifdef PLATFORM_2OO2/*2oo2平台打印*/
@@ -332,11 +342,16 @@ UINT8 ParseOtherSysToCiData(void)
#endif/*平台打印结束*/
#endif
cLocalDevType = Get2oo2SheBeiType();
cLocalCiId = GetSystemParaLocalCiId();
startLockFlag = GetStartLockFlag();
if (devType == cLocalDevType)
{
/*解析RC间或CI间数据*/
/*判断是否是同一条线路的联锁，不同线路联锁使用互联互通联锁接口，同一条线路使用自家联锁接口*/
sameLineCi = IsSameLineCI(devId, GetSystemParaLocalCiId());
sameLineCi = IsSameLineCI(devId, cLocalCiId);
if (SAME_LINE_YES == sameLineCi) /*同线*/
{
startLockFlag = GetStartLockFlag();
if (CI_START_LOCK_NO == startLockFlag)
{
checkResult = ParseCiToCiDataCheck(data, (UINT16)dataLen, &errorNO_Type); /*相邻CI间数据传输的校验*/
@@ -346,7 +361,7 @@ UINT8 ParseOtherSysToCiData(void)
}
else
{
checkResult = ParseCiToCiDataFrame(data, (UINT16)dataLen);
checkResult = ParseCiToCiDataFrame(data, (UINT16)dataLen, devId);
if (CI_SUCCESS != checkResult) /*错误*/
{
debug_infor_printf((const)"parse ci id %d error", devId);
@@ -376,7 +391,59 @@ UINT8 ParseOtherSysToCiData(void)
{
debug_infor_printf((const)"ci id %d sameLineCi:%d error", devId, sameLineCi);
}
}
else
{
if (CI_START_LOCK_NO == startLockFlag)
{
/*解析CI-RC间数据*/
if ((CI_SYSTEM_TYPE_CI == cLocalDevType) && (CI_SYSTEM_TYPE_RC == devType))
{
/*相邻CI间数据传输的校验*/
checkResult = ParseRcToLocalCiDataCheck(data, (UINT16)dataLen, &errorNO_Type);
if (CI_SUCCESS != checkResult)
{
debug_infor_printf((const)"ParseRcToLocalCiDataCheck: Step %d Error", errorNO_Type);
}
else
{
/*当前为CI，解析本控区RC发送的数据*/
checkResult = ParseRcToLocalCiDataFrame(data, (UINT16)dataLen, cLocalCiId);
if (CI_SUCCESS == checkResult)
{
/*不处理*/
}
else
{
debug_infor_printf((const)"\nParseRcToLocalCiDataFrame Error");
}
}
}
else if ((CI_SYSTEM_TYPE_RC == cLocalDevType) && (CI_SYSTEM_TYPE_CI == devType))
{
/*当前为RC，解析本控区CI发送的数据*/
checkResult = ParseCiToLocalRcDataFrame(data, (UINT16)dataLen, cLocalCiId);
if (CI_SUCCESS == checkResult)
{
/*不处理*/
}
else
{
debug_infor_printf((const)"\nParseCiToLocalRcDataFrame Error");
}
}
else
{
/*异常分支，不处理*/
}
}
else
{
/*未上电，不处理*/
}
}
break;
case CI_SYSTEM_TYPE_ZC:
@@ -410,16 +477,47 @@ UINT8 ParseOtherSysToCiData(void)
break;
case CI_SYSTEM_TYPE_VOBC: /*解析VOBC数据*/
debug_infor_printf((const)"\nVOBC_RECV:%d", (UINT16)dataLen);
debug_out_array(0xAA, data, (UINT16)dataLen);
if (RC_WORK_MODE_TIOC == cWorkMode)
{
debug_infor_printf((const)"\nRC_VOBC_CBTC_RECV:%d", (UINT16)dataLen);
debug_out_array(0xAA, data, (UINT16)dataLen);
/*车车模式下的VOBC模式*/
checkResult = ParseVobcToRcDataCC(data, (UINT16)dataLen, devId, srcDevLogicId);
if (CI_ERROR == checkResult) /*错误*/
{
debug_infor_printf((const)"parse vobc id %d,logic id %d error", devId, srcDevLogicId);
}
else
{/*无处理*/
}
}
else
{
debug_infor_printf((const)"\nVOBC_CBTC_RECV:%d", (UINT16)dataLen);
debug_out_array(0xAA, data, (UINT16)dataLen);
/*CI模式下用既有函数*/
checkResult = ParseVobcToCiDataFrame(data, (UINT16)dataLen, devId, srcDevLogicId);
if (CI_ERROR == checkResult) /*错误*/
{
debug_infor_printf((const)"parse vobc id %d,logic id %d error", devId, srcDevLogicId);
}
else
{/*无处理*/
}
}
break;
case CI_SYSTEM_TYPE_IVOC: /*解析IVOC数据*/
debug_infor_printf((const)"\nVOBC_PBTACS_RECV:%d", (UINT16)dataLen);
debug_out_array(0xAA, data, (UINT16)dataLen);
checkResult = ParseIvocToRcDataFrame(data, (UINT16)dataLen, devId, srcDevLogicId);
if (CI_ERROR == checkResult) /*错误*/
{
debug_infor_printf((const)"parse ivoc id %d,logic id %d error", devId, srcDevLogicId);
}
else
{/*无处理*/
}
break;
@@ -622,10 +720,18 @@ UINT8 PackCiToOtherSysData(void)
UINT32 fsfbOutQueIdx = 0u; /*fsfb输出队列位置*/
UINT16 fsfbOutQueFramLen = 0u; /*fsfb输出队列帧长度*/
UINT8 fsfbBtmHead[5] = { 0 }; /*fsfb btm帧头*/
UINT8 chTiocRcvAtsGtwyDevTypeId = 0U;
unsigned long long cost[20] = { 0U };
UINT32 dwFlyProtectOverCyc = GetFlyProtectOverCyc();
UINT8 chSendXiandiorAtsMaskBuf[CI_TO_ATS_DATA_LEN_MAX] = { 0U }; /*发送给现地或ATS的码位数据*/
UINT8 cSysType = 0U; /*系统类型*/
UINT8 cLocalCiType = 0U;
UINT8 cLocalCiId = 0U; /*本地ID*/
UINT8 cLocalDevType = 0U; /*本地设备类型*/
UINT8 cStartLockFlag = 0U; /*上电解锁标志*/
UINT8 cRcWorkMode = 0U;
cRcWorkMode = GetLocalRcWorkMode();
chTiocRcvAtsGtwyDevTypeId = (UINT8)GetTiocTrnsmtGtwyDevTypeId();
curSysCount = MSCP_GetSysCount();
@@ -634,6 +740,8 @@ UINT8 PackCiToOtherSysData(void)
if(0U == dwFlyProtectOverCyc)
{
/*组码位信息*/
(void)MaskPack(CI_SYSTEM_TYPE_XIANDI, chSendXiandiorAtsMaskBuf);
/*****组现地数据*****/
deviceSum = GetCiTransmitSpecifySysDevSum(CI_SYSTEM_TYPE_XIANDI); /*获取通信现地设备总数*/
deviceIdBuf = GetCiTransmitSpecifySysDevBuf(CI_SYSTEM_TYPE_XIANDI); /*获取通信现地设备ID数组*/
@@ -648,7 +756,7 @@ UINT8 PackCiToOtherSysData(void)
for (ii = 0u; ii < deviceSum; ii++)
{
/*组现地站场帧数据*/
reVal = PackCiToAtsOrXianDiData(deviceIdBuf[ii], CI_SYSTEM_TYPE_XIANDI, CI_ATS_STATION_FRAME);
reVal = PackCiToAtsOrXianDiData(deviceIdBuf[ii], CI_SYSTEM_TYPE_XIANDI, CI_ATS_STATION_FRAME, chSendXiandiorAtsMaskBuf);
if (CI_ERROR == reVal)
{
/*组包错误*/
@@ -666,7 +774,7 @@ UINT8 PackCiToOtherSysData(void)
for (ii = 0u; ii < deviceSum; ii++)
{
/*组现地设备帧数据*/
reVal = PackCiToAtsOrXianDiData(deviceIdBuf[ii], CI_SYSTEM_TYPE_XIANDI, CI_ATS_DEVICE_STATE_FRAME);
reVal = PackCiToAtsOrXianDiData(deviceIdBuf[ii], CI_SYSTEM_TYPE_XIANDI, CI_ATS_DEVICE_STATE_FRAME, chSendXiandiorAtsMaskBuf);
if (CI_ERROR == reVal)
{
/*组包错误*/
@@ -698,7 +806,7 @@ UINT8 PackCiToOtherSysData(void)
{
/*组ATS站场帧数据*/
reVal = PackCiToAtsOrXianDiData(deviceIdBuf[ii], CI_SYSTEM_TYPE_ATS, CI_ATS_STATION_FRAME);
reVal = PackCiToAtsOrXianDiData(deviceIdBuf[ii], CI_SYSTEM_TYPE_ATS, CI_ATS_STATION_FRAME, chSendXiandiorAtsMaskBuf);
if (CI_ERROR == reVal)
{
@@ -713,7 +821,7 @@ UINT8 PackCiToOtherSysData(void)
else
{
/*组ATS设备帧数据*/
reVal = PackCiToAtsOrXianDiData(deviceIdBuf[ii], CI_SYSTEM_TYPE_ATS, CI_ATS_DEVICE_STATE_FRAME);
reVal = PackCiToAtsOrXianDiData(deviceIdBuf[ii], CI_SYSTEM_TYPE_ATS, CI_ATS_DEVICE_STATE_FRAME, chSendXiandiorAtsMaskBuf);
if (CI_ERROR == reVal)
{
/*组包错误*/
@@ -901,6 +1009,51 @@ UINT8 PackCiToOtherSysData(void)
}
}
/*组CI-RC数据*/
cStartLockFlag = GetStartLockFlag();
if (CI_START_LOCK_NO == cStartLockFlag)
{
cSysType = GetSystemWorkType();
cLocalCiType = GetLocalCiType();
if ((SYSTEM_WORK_MODE_ALL == cSysType) && ((CI_TYPE_ZX == cLocalCiType) || (CI_TYPE_SCX == cLocalCiType)))
{
/*双系统下的正线和试车线才进行本控区CI-RC的组包*/
cLocalCiId = GetSystemParaLocalCiId();
cLocalDevType = Get2oo2SheBeiType();
if (CI_SYSTEM_TYPE_CI == cLocalDevType)
{
reVal = PackCiToLocalRcDataFrame(cLocalCiId); /*CI给本控区RC组包*/
if (CI_SUCCESS == reVal)
{
/*不处理*/
}
else
{
debug_infor_printf((const)"\nPackCiToLocalRcDataFrame Error.");
}
}
else
{
reVal = PackRcToLocalCiDataFrame(cLocalCiId); /*RC给本控区CI组包*/
if (CI_SUCCESS == reVal)
{
/*不处理*/
}
else
{
debug_infor_printf((const)"\nPackRcToLocalCiDataFrame Error.");
}
}
}
else
{
/*单系统或场段不涉及，不处理*/
}
}
else
{
/*未上电，不组包*/
}
/*****组LEU数据*****/
deviceSum = 0u;
@@ -930,8 +1083,8 @@ UINT8 PackCiToOtherSysData(void)
cost[2] = MSCP_GetTick();
/*****组VOBC数据*****/
/*组VOBC数据*/
reVal = PackCiToVobcData();
/*CI模式组VOBC数据，RC模式组IVOC数据*/
reVal = PackVobcData();
if (CI_ERROR == reVal)
{
/*组包错误*/
@@ -954,6 +1107,16 @@ UINT8 PackCiToOtherSysData(void)
}
/*仅RC模式，执行给510车组包*/
if (RC_WORK_MODE_TIOC == cRcWorkMode)
{
/*组RC-VOBC数据*/
reVal = PackRcToVobcData();
if (CI_ERROR == reVal)
{
}
}
/*****组PSD数据******/
deviceSum = 0u;
deviceIdBuf = NULL;
@@ -1010,12 +1173,9 @@ UINT8 PackCiToOtherSysData(void)
}
else
{
/*不处理*/
PackCiToVobcFlyProtectData(); /*组飞车特控报文*/
}
/*组飞车特控报文*/
PackCiToVobcFlyProtectData();
#ifdef APPCI_MAINTAIN_DEBUG
#ifdef PLATFORM_2OO2
/*cgh-合并CID-2349-1：*/
TSCP/src/APP/ciapp/ParsePack/ParsePackOcData.c
+487 -447
View File
File diff suppressed because it is too large Load Diff
TSCP/src/APP/ciapp/ParsePack/ParsePackOcData.h
+59 -28
View File
@@ -48,16 +48,17 @@
#include "../LogRecord/LogRecord.h"
#endif
#define MAX_OC_DEVICE_NUM ((UINT16)150) /*一个OC最多支持多少个设备*/
#define MAX_OC_DI_BOARD_NUM ((UINT16)20) /*一个OC支持最大DI板卡数量*/
#define MAX_OC_DO_BOARD_NUM ((UINT16)20) /*一个OC支持最大DO板卡数量*/
#define MAX_OC_SOR_BOARD_NUM ((UINT16)20) /*一个OC支持最大SOR板卡数量*/
#define MAX_OC_PLUS_BOX_NUM ((UINT16)3) /*一个OC支持最大执行电插箱*/
#define MAX_OC_SWITCH_INCLUDE_ZZJ_NUM ((UINT16)4) /*一个道岔支持最大转辙机个数*/
#define MAX_OC_SWITCH_INCLUDE_BOARD_NUM ((UINT8)4) /*一个道岔支持最大板卡数量*/
#define Max_OC_GD_NUM ((UINT16)100) /*一个oc支持最大多少个轨道区段*/
#define MAX_OC_DEVICE_SWITCH_MAX ((UINT16)84) /*一个OC最多支持道岔设备（不可达最大值）*/
#define MAX_OC_DEVICE_SIGNAL_MAX ((UINT16)168) /*一个OC最多支持信号机设备（不可达最大值）*/
#define MAX_OC_DEVICE_NUM ((UINT16)MAX_OC_DEVICE_SWITCH_MAX+MAX_OC_DEVICE_SIGNAL_MAX) /*一个OC最多支持多少个设备（不可达最大值）*/
#define MAX_OC_BOARD_NUM ((UINT16)22) /*一个OC支持最大DI/SI/DO/SO/SOR板卡数量（不可达最大值）*/
#define MAX_OC_PLUS_BOX_NUM ((UINT16)3) /*一个OC支持最大执行电插箱（可达最大值）*/
#define MAX_OC_DEVICE_SWAP_MAX ((UINT16)83) /*一个OC最大切系板卡数量(MAX_OC_DEVICE_NUM/2)（不可达最大值） */
#define MAX_OC_SWITCH_INCLUDE_ZZJ_NUM ((UINT16)10) /*一个道岔支持最大转辙机个数（可达最大值）*/
#define MAX_OC_SWITCH_INCLUDE_BOARD_NUM ((UINT8)10) /*一个道岔支持最大板卡数量（不可达最大值）*/
#define Max_OC_GD_NUM ((UINT16)252) /*一个oc支持最大多少个轨道区段（不可达最大值）*/
#define MAX_OC_DEVICE_PSD_MAX ((UINT8)2) /*一个OC最大屏蔽门数量（可达最大值）*/
#define OC_CI_STATE_INFO ((UINT16)0x8802) /*OC给CI状态信息*/
#define CI_OC_CONTROL_INFO ((UINT16)0x8801) /*CI给OC控制命令*/
@@ -91,13 +92,27 @@ typedef struct s_OcDevState
UINT8 BoardState[MAX_OC_SWITCH_INCLUDE_BOARD_NUM]; /*板卡状态 正常0x0000 错误发错误码*/
}OcDeviceStruct;
typedef struct s_OcBoardData
typedef struct s_OcDoBoardData
{
UINT8 BoardAddr; /*板卡地址*/
UINT8 BoardState; /*板卡状态 正常0x00 错误发错误码*/
UINT8 BoardCollData[18]; /*采集数据*/
}OcDIBoard;
typedef struct s_OcSIBoardData
{
UINT8 BoardAddr; /*板卡地址*/
UINT8 BoardState; /*板卡状态 正常0x00 错误发错误码*/
UINT8 BoardCollData[12]; /*采集数据*/
}OcSIBoard;
typedef struct s_OcSorBoardData
{
UINT8 BoardAddr; /*板卡地址*/
UINT8 BoardState; /*板卡状态 正常0x00 错误发错误码*/
UINT8 BoardCollData[5]; /*采集数据*/
}OcSorBoard;
typedef struct s_OcGd
{
UINT16 OcId; /*OC编号*/
@@ -153,14 +168,20 @@ typedef struct S_OcToCiDataStruct
UINT16 OcGdNum;/*一个oc的所有轨道区段的数量*/
OcGdDevice OcGdDevices[Max_OC_GD_NUM];/*一个oc的所有轨道区段设备*/
UINT16 OcDIBoardDataNum; /*一个oc的所有采集输入板卡数据数量*/
OcDIBoard OcDIBoardDatas[MAX_OC_DI_BOARD_NUM]; /*一个oc的所有采集输入板卡数据*/
UINT16 OcDIBoardDataNum; /*一个oc的所有DI板卡数据数量*/
OcDIBoard OcDIBoardDatas[MAX_OC_BOARD_NUM]; /*一个oc的所有DI板卡数据*/
UINT16 OcDOBoardNum;/*一个OC的所有采集输出板卡数量*/
OcDoBoard OcDOBoardDatas[MAX_OC_DO_BOARD_NUM]; /*OC的所有数字输出板卡*/
UINT16 OcSIBoardDataNum; /*一个oc的所有SI板卡数据数量*/
OcSIBoard OcSIBoardDatas[MAX_OC_BOARD_NUM]; /*一个oc的所有SI板卡数据*/
UINT16 OcSORBoardNum;/*一个OC输出继电器板卡数量*/
OcDIBoard OcSORBoardDatas[MAX_OC_SOR_BOARD_NUM]; /*OC的安全输出板卡数据*/
UINT16 OcDOBoardNum;/*一个OC的DO板卡数量*/
OcDoBoard OcDOBoardDatas[MAX_OC_BOARD_NUM]; /*OC的DO输出板卡*/
UINT16 OcSOBoardNum;/*一个OC的所有SO板卡数量*/
OcDoBoard OcSOBoardDatas[MAX_OC_BOARD_NUM]; /*OC的SO板卡*/
UINT8 OcSORBoardNum;/*一个OC输出继电器板卡数量*/
OcSorBoard OcSORBoardDatas[MAX_OC_BOARD_NUM]; /*OC的安全输出板卡数据*/
UINT8 PowerAState;/*A系电源状态，新增。0x55-双路空开正常，0xaa-单路空开异常，0xFF-双路空开异常*/
UINT8 PowerBState;/*B系电源状态，新增。0x55-双路空开正常，0xaa-单路空开异常，0xFF-双路空开异常*/
@@ -171,22 +192,20 @@ typedef struct S_OcToCiDataStruct
OcPlusBox szPlusBox[MAX_OC_PLUS_BOX_NUM];/*执行电插箱信息*/
UINT16 OCBoardSwapSysNum;/*OC切系板卡数量*/
UINT8 SwapSysBoardId[MAX_OC_DEVICE_NUM];/*OC切系板卡ID*/
UINT8 SwapSysBoardId[MAX_OC_DEVICE_SWAP_MAX];/*OC切系板卡ID*/
UINT8 OCPsdNum;/*屏蔽门数量*/
UINT8 DrvPowerState;/*驱动电源状态*/
UINT8 CtlPowerState;/*控制电源状态*/
UINT8 EdgeCtllerState1;/*边缘控制器1状态*/
UINT8 EdgeCtllerState2;/*边缘控制器2状态*/
OcToCiPsdInfo PsdInfo[PSD_SUM_MAX];/*屏蔽门信息*/
OcToCiPsdInfo PsdInfo[MAX_OC_DEVICE_PSD_MAX];/*屏蔽门信息*/
UINT8 chHaveYjk; /*是否具备应急控*/
UINT8 chControlMode; /*主控状态*/
UINT8 chOcYjpComm; /*OC与YJP通信状态*/
UINT32 ComStartCycle; /*通信开始周期，使用该周期判断OC与CI中断*/
UINT16 RecvErrorDevTypeCycle; /*收到错误设备类型周期*/
}OcToCiOriginDataStruct;
@@ -360,18 +379,18 @@ UINT16 ConvertSigDrvColorToSigDrvCmd(const UINT16 signalId, const UINT8 drvColor
/*
* 功能描述： 把解析的OC设备数据转换为OC 信号机和 OC 道岔设备数据
* 参数说明： void
* 功能描述： 把解析的对应OC设备数据转换为OC 信号机和 OC 道岔设备数据
* 参数说明： uint8 devId OC编号
* 返回值 ： void
*/
void ConvertOcOriginDataToOcSigSwDev(void);
void ConvertOcOriginDataToOcSigSwDev(UINT8 devId);
/*
* 功能描述： 把解析的OC板卡数据转换为OC点位数据
* 参数说明： void
* 功能描述： 把解析的指定OC的板卡数据转换为OC点位数据
* 参数说明： uint8 devId OC编号
* 返回值 ： void
*/
void ConvertOcOriginDataToPtData(void);
void ConvertOcOriginDataToPtData(UINT8 devId);
/*
* 功能描述： 初始化OC设备
@@ -428,7 +447,7 @@ INT16 GetIndexBySwitchId(UINT16 swId);
*/
INT16 GetIndexByGdId(UINT16 gdId);
#if 0
/*
* 功能描述： 校验Oc到CI的单帧数据长度合法性
* 参数说明： const UINT8* dataBuf, 数据缓冲区
@@ -445,7 +464,7 @@ UINT8 CheckOc2CiDataLenValid(const UINT8* dataBuf, const UINT16 totalLength);
*
*/
void ResetOcOriginalState(const UINT8 ocId);
#endif
/*
* 功能描述：为指定OC->CI的结构设置缺省值(安全值)
* 参数说明： index:OC id对应的数组下标
@@ -477,6 +496,18 @@ UINT32 GetPointTolerateCycNum(const UINT16 ocId, const UINT8 boardNum, const UIN
* 返回值 ： 无
*/
void SetPointTolerateCycNum(const UINT16 ocId, const UINT8 boardNum, const UINT8 pointNum, const UINT32 cycNum);
/*
* 功能描述： 校验接口值为0x55或0XAA,或等于输入的有效数值
* 参数说明： const UINT8 chInput, 接口输入数值，UINT8 chOtherValid,其他非0有效值
* 返回值 ： CI_ERROR CI_SUCCESS
*/
UINT8 OcInputStateCheck(const UINT8 chInput, const UINT8 chOtherValid);
/*
* 功能描述： 校验OC接口信号机状态有效有效
* 参数说明： const UINT8 chInput, 接口输入数值
* 返回值 ： CI_ERROR CI_SUCCESS
*/
UINT8 OcInputSignalStateCheck(const UINT8 chInput);
#ifdef __cplusplus
}
TSCP/src/APP/ciapp/ParsePack/ParsePackTmcData.c
+2 -2
View File
@@ -147,7 +147,7 @@ UINT8 ParseTmcToTiocDataFrame(UINT8* dataBuf, UINT16 dataLength, UINT8 systemId)
localCiId = GetSystemParaLocalCiId(); /*获取联锁ID*/
wTmcName = (CI_SYSTEM_TYPE_TMC)*256U + systemId;
wTiocName = (CI_SYSTEM_TYPE_CI)*256U + localCiId;
wTiocName = (CI_SYSTEM_TYPE_RCI)*256U + localCiId;
curntCycleNo = Get2oo2CurCycleNum();
/* 清空接收数据 */
@@ -874,7 +874,7 @@ UINT8 PackTiocToTmcData( UINT8 deviceId)
localCi = GetSystemParaLocalCiId(); /*获取本地联锁ID*/
/* 获取GAL头信息 */
retVal = dquDevName2HlhtId((CI_SYSTEM_TYPE_CI * 256U) + localCi, 0U, &cTiocEtcsId);
retVal = dquDevName2HlhtId((CI_SYSTEM_TYPE_RCI * 256U) + localCi, 0U, &cTiocEtcsId);
retVal &= dquDevName2HlhtId((CI_SYSTEM_TYPE_TMC * 256U) + deviceId, 0U, &cTmcEtcsId);
retVal &= GetCiEmapCheckVer(localCi, &emapCheckVer, CI_SYSTEM_TYPE_TMC);
dwHlhtHSrcSN = GetHLHTHeadCtxSrcCrntSN(CI_SYSTEM_TYPE_TMC, deviceId);
TSCP/src/APP/ciapp/ParsePack/ParsePackVobcData.c
+1186 -217
View File
File diff suppressed because it is too large Load Diff
TSCP/src/APP/ciapp/ParsePack/ParsePackVobcData.h
+97 -18
View File
@@ -104,8 +104,14 @@
#define CI_IVOC_INFO_TYPE_HEART_FRAME ((UINT16)0x0206U) /*OC->IVOC心跳帧，非周期*/
#define CI_IVOC_INFO_TYPE_SPECIAL_CONTROL ((UINT16)0x0208U) /*rc->IVOC特控报文帧，非周期*/
#define VOBC_RC_INTERFACE_INFOTYPE ((UINT16)0x0217U) /*VOBC-RC接口，RC-VOBC接口*/
#define VOBC_RC_INFO_STATE ((UINT16)0x0201U) /*VOBC->RC控制信息，周期发送*/
#define RC_VOBC_HEART_FRAME ((UINT16)0x0201U) /*RC->VOBC心跳信息，周期发送*/
#define CI_IVOC_PRTCL_VER ((UINT8)0x01U) /*CI_VOBC协议版本号*/
#define CI_IVOC_BACKUP_PRTCL_VER ((UINT8)0x066) /*CI_VOBC后备通道协议版本号*/
#define RC_VOBC_PRTCL_VER ((UINT8)0x065) /*RC_VOBC协议版本号*/
#define IVOC_CI_CMD_MAX ((UINT16)100U) /*IVOC 到CI命令数量最大值*/
#define IVOC_CI_CMD_DEVICE_MAX ((UINT8)100U) /*IVOC 到CI命令设备数量最大值*/
@@ -167,8 +173,9 @@
#define CI_IVOC_GAP_DETECT_STATUS_UNCLEAR ((UINT8)0xAA) /*CI2VOBC间隙探测状态：已检测且有障碍物*/
#define CI_IVOC_GAP_DETECT_STATUS_DEFAULT ((UINT8)0xFF) /*CI2VOBC间隙探测状态：未检测/无此功能，Default Value*/
#define CI_IVOC_ESB_STATE_VALID ((UINT8)0x55U) /*CI到IVOC ESB按钮按下*/
#define CI_IVOC_ESB_STATE_INVALID ((UINT8)0xAAU) /*CI到IVOC ESB按钮未按下*/
#define CI_IVOC_ESB_STATE_VALID ((UINT8)0x55U) /*CI到IVOC(VOBC) ESB按钮按下*/
#define CI_IVOC_ESB_STATE_INVALID ((UINT8)0xAAU) /*CI到IVOC(VOBC) ESB按钮未按下*/
#define CI_IVOC_NO_HAVE_ESB ((UINT8)0xFFU) /*CI到IVOC(VOBC) ESB按钮未按下*/
#define CI_IVOC_NON_RETURN_STATE_VALID ((UINT8)0x55U) /*CI到IVOC 无人折返按钮按下*/
#define CI_IVOC_NON_RETURN_STATE_INVALID ((UINT8)0xAAU) /*CI到IVOC 无人折返按钮未按下*/
@@ -225,6 +232,11 @@
#define CI_IVOC_LOST_POSITION ((UINT8)0x55U) /*CI到车载特控报文 丢位置*/
#define CI_VOBC_JXTC_CUT_YES ((UINT8)0x55) /*间隙探测旁路故障*/
#define CI_VOBC_JXTC_CUT_NO ((UINT8)0xAA) /*间隙探测旁路未故障*/
#define CI_VOBC_JXTC_OFF ((UINT8)0xFF) /*未检测/无此功能*/
#ifdef __cplusplus
extern "C" {
#endif
@@ -358,8 +370,12 @@ typedef struct S_VobcToCiDataStruct
UINT16 wHeadVobcId; /*前车ID*/
UINT8 chJumpBackApply; /*向后跳跃申请*/
UINT32 dwJumpBackSn; /*向后跳跃申请序列号*/
UINT8 controlMode; /*控车模式*/
} VobcToCiDataStruct;
/*在RC模式下，统一使用IvocToRcDataStruct*/
typedef VobcToCiDataStruct IvocToRcDataStruct;
/*使用后备模式与联锁通信的Vobc信息*/
typedef struct S_VobcBackUpToCiDataStruct
{
@@ -387,6 +403,34 @@ typedef struct S_VobcBackUpToCiDataStruct
} VobcBackUpToCiDataStruct;
/*与RC通信的Vobc信息，车车模式下，与RC通信的VOBC*/
typedef struct S_IvocToRcDataStruct
{
UINT16 VobcId; /*Vobc ID*/
UINT16 VobcType; /*列车类型:0x14 510车，0x10 车车的车，本结构体仅在RC模式存510车*/
UINT8 controlMode; /*控车模式*/
UINT8 trainDirection; /*列车运行方向*/
UINT8 chTrainLevel; /*列车运行级别 0x01：连续式列车控制级别（CBTC级别）；0x02：点式列车控制级别（ITC级别）；0x03：联锁控制级别(IL级别)；0x04：自主感知后备控制级别(ABL级别)；其他：非法。*/
UINT8 chTrainMode; /*列车模式，0x01：AM；0x02：CM；0x03：RM；0x04：EUM（预留）；0x05：FAM(预留)；0x06：CAM（预留）；其他：非法。*/
UINT16 appInfoType; /*应用信息类型*/
UINT16 vobcLogId; /*互联互通4IP VOBC1端或2端标识*/
UINT32 ComStartCycle; /*与VOBC通信周期，使用该周期做VOBC通信中断判断*/
UINT16 wTrainMaxSafeHeadLink; /*列车最大安全前端所处Link*/
UINT32 dwTrainMaxSafeHeadOffset; /*列车最大安全前端偏移量*/
UINT16 wTrainMinSafeHeadLink; /*列车最小安全前端所处link*/
UINT32 dwTrainMinSafeHeadOffset; /*列车最小安全前端偏移量*/
UINT16 wTrainMaxSafeTailLink; /*列车最大安全后端所处Link*/
UINT32 dwTrainMaxSafeTailOffset; /*列车最大安全后端偏移量*/
UINT16 wTrainMinSafeTailLink; /*列车最小安全后端所处link*/
UINT32 dwTrainMinSafeTailOffset; /*列车最小安全后端偏移量*/
UINT16 wTrainLen; /*列车车长*/
UINT16 wTrainSpeed; /*列车速度*/
UINT8 chSpeedDir; /*列车速度方向*/
} VobcToRcDataStruct;
#endif
extern VobcToCiDataStruct VobcToCiDataStru[VOBC_TO_CI_SUM_MAX];
@@ -395,6 +439,8 @@ extern VobcBackUpToCiDataStruct VobcBackUpToCiDataStru[VOBC_BACKUP_TO_CI_SUM_MAX
extern UINT8 VobcToCiSum;
extern VobcToRcDataStruct VobcToRcDataStru[VOBC_TO_CI_SUM_MAX];/*与RC通信的VOBC信息。本变量在CI模式下不使用。在RC模式下，仅存储与RC通信的510车的信息,记得二乘同步！！！！！！！！！*/
extern UINT8 VobcToRcSum;/*与RC通信的Vobc数目，仅RC模式下使用，记录与RC通信的VOBC车数量,2乘记得同步*/
/*
* 功能描述： 解析处理VOBC单帧数据
@@ -424,7 +470,7 @@ UINT8 ParseVobcBackUpToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength
* 返回值 ： 0:组数据失败
* 1:组数据成功
*/
UINT8 PackCiToVobcData(void);
UINT8 PackVobcData(void);
/*
* 功能描述： 组VOBC后备通道数据
@@ -458,13 +504,6 @@ UINT8 GetVobcToCiSum(void);
* CI_ERROR: 不合法
*/
UINT8 GetPsdEditGroupInfo(const UINT16 psdId);
/*
* 功能描述： 从VOBC发送给CI的信息结构体数组中，删除指定位置的数据
* 参数说明： const UINT8 idx:VOBC发送给CI的信息结构体数组的位置索引
* 返回值 ： 0:失败
* 1:成功
*/
UINT8 RemoveVobcToCiMsgAt(UINT8 idx);
/*
@@ -696,14 +735,6 @@ UINT8 ParseFAOHLHTBackUpControlData(UINT8* dataBuf, UINT16 dataLen, VobcToCiData
*/
void PackCiToVobcFlyProtectData(void);
/*
* 功能描述：组RC到车载飞车宕机信息
* 参数说明：const UINT16 wTrainId 列车ID
* 返 回 值：无
* Created By LQ 2025.09.15
*/
void PackCiToVobcFlyProtectInfo(const UINT16 wTrainId);
/*
* 功能描述：组包Ci到Ivoc的向后跳跃申请回复
* 参数说明： UINT8* dataBuf, 数据缓冲区
@@ -714,6 +745,54 @@ void PackCiToVobcFlyProtectInfo(const UINT16 wTrainId);
* Create： fan 20250725
*/
UINT8 PackCiToIvocJumpBackReply(UINT8* pDataBuf, UINT16* wDataLength, UINT16 wTrainId);
/*
* 功能描述： 解析处理VOBC单帧数据
* 参数说明： const UINT8* dataBuf, 数据缓冲区
* const UINT16 dataLength, 数据长度
* const UINT8 systemId, 源设备ID
* const UINT16 logId，互联互通4IP VOBC的1端或2端标识
* 返回值 ： 0: 数据解析失败
* 1: 数据解析成功
*/
UINT8 ParseVobcToRcDataCC(const UINT8* dataBuf, const UINT16 dataLength, const UINT8 systemId, const UINT16 logId);
/*
* 功能描述： RC模式组VOBC数据
* 参数说明： void
* 返回值 ： 0:组数据失败
* 1:组数据成功
*/
UINT8 PackRcToVobcData(void);
/*
* 功能描述： 获取VOBC到Rc命令结构体数组总数
* 参数说明： void
* 返回值 ： 数组总数
*/
UINT8 GetVobcToRcSum(void);
/*
* 功能描述： 解析处理Ivoc单帧数据
* 参数说明： const UINT8* dataBuf, 数据缓冲区
* const UINT16 dataLength, 数据长度
* const UINT8 systemId, 源设备ID
* const UINT16 logId，互联互通4IP VOBC的1端或2端标识
* 返回值 ： 0: 数据解析失败
* 1: 数据解析成功
*/
UINT8 ParseIvocToRcDataFrame(const UINT8* dataBuf, const UINT16 dataLength, const UINT8 systemId, const UINT16 logId);
/*
* 功能描述： 获取Ivoc到RC命令结构体数组总数
* 参数说明： void
* 返回值 ： 数组总数
*/
UINT8 GetIvocToRcSum(void);
/*
* 功能描述： 获取收到的列车主控状态
* 参数说明：const UINT16 wVobcId 列车ID
*
* 返回值 ： 0:获取失败
* 0x55 主控
* 0xaa 非主控
*/
UINT8 GetRecvVobcControlMode(const UINT16 wVobcId);
#ifdef __cplusplus
}
#endif
TSCP/src/APP/ciapp/ParsePack/ParsePackZcData.c
+575 -2
View File
@@ -26,6 +26,8 @@ ComTrainPosDataStruct ComTrainPosDataStru[ZC_TO_CI_TRAIN_MAX];/*
UINT16 ComTrainSum = 0u;/*列车数量*/
UINT8 lineIdentity = 0u; /*线路标识*/
ZcToCiDynamicDataStruct gZcToCiDymDataStru = { 0U }; /*ZC动态数据结构体*/
/*
* 功能描述： 解析ZC单帧数据
@@ -67,7 +69,7 @@ UINT8 ParseZcToCiDataFrame(UINT8* dataBuf, UINT16 dataLength, UINT8 systemId)
ci_zcPrtclVersion = GetVersionOfZCToCI();
localCiId = GetSystemParaLocalCiId(); /*获取联锁ID*/
zcName = (CI_SYSTEM_TYPE_ZC)*256U + systemId;
ciName = (CI_SYSTEM_TYPE_CI)*256U + localCiId;
ciName = (CI_SYSTEM_TYPE_RCI)*256U + localCiId;
curntCycleNo = Get2oo2CurCycleNum();
chDataType = GetLocalPublicDataType(); /*区分28.0.0.14与其他线路zc接口*/
if ((NULL != dataBuf) && (dataLength > 0u))
@@ -1073,7 +1075,7 @@ UINT8 PackCiToZcData( UINT8 deviceId)
localCi = GetSystemParaLocalCiId(); /*获取本地联锁ID*/
ci_zcPrtclVersion = GetVersionOfZCToCI();
/*首先获取组包时所需的信息，获取成功才有必要继续组包*/
CIName2HlhtId = dquDevName2HlhtId((CI_SYSTEM_TYPE_CI * 256U) + localCi, 0U, &ciEtcsId);
CIName2HlhtId = dquDevName2HlhtId((CI_SYSTEM_TYPE_RCI * 256U) + localCi, 0U, &ciEtcsId);
ZCName2HlhtId = dquDevName2HlhtId((CI_SYSTEM_TYPE_ZC * 256U) + deviceId, 0U, &zcEtcsId);
dwHlhtHSrcSN = GetHLHTHeadCtxSrcCrntSN(CI_SYSTEM_TYPE_ZC, deviceId);
dwHlhtHRcvSN = GetHLHTHeadCtxCiRcvSN(CI_SYSTEM_TYPE_ZC, deviceId);
@@ -1443,3 +1445,574 @@ UINT8 ParseZcIteCutData(UINT8* dataBuf, UINT16 dataLen)
return cRetVal;
}
/**
* @brief 获取ZC发送的进路停车保证标志
* @param[in] UINT16 wDeviceId 设备ID
* @return 进路停车保证标志
* @note by cgh 20251106
*/
UINT8 GetRouteStopensureFlagZc(UINT16 wDeviceId)
{
UINT8 chReval = ROUTE_STOPENSURE_NO;
UINT16 bufIndex = 0U; /*数组下标*/
bufIndex = GetRouteConfigBufIndex(wDeviceId); /*获取进路数组下标*/
if (bufIndex < ROUTE_SUM_MAX)
{
chReval = gZcToCiDymDataStru.szRouteDataStruZc[bufIndex].StopensureFlag;
}
else
{
/*返回无停车保证*/
}
return chReval;
}
/*
* 功能描述：设置ZC发送的进路停车保证标志
* 参数说明：const UINT16 routeId, 进路ID
* const UINT8 stopensureFlag 停车保证标志
* 返 回 值：无
* Created By LQ 2025.11.07
*/
void SetRouteStopensureFlagZc(const UINT16 routeId, const UINT8 stopensureFlag)
{
UINT16 bufIndex = 0U; /*数组下标*/
bufIndex = GetRouteConfigBufIndex(routeId); /*获取进路数组下标*/
if (bufIndex < ROUTE_SUM_MAX)
{
if ((ROUTE_STOPENSURE_YES == stopensureFlag) || (ROUTE_STOPENSURE_NO == stopensureFlag))
{
gZcToCiDymDataStru.szRouteDataStruZc[bufIndex].StopensureFlag = stopensureFlag; /*停车保证标志*/
}
else
{
/*不处理*/
}
}
else
{
/*不处理*/
}
}
/**
* @brief 获取ZC发送的信号机亮灭状态
* @param[in] UINT16 wDeviceId 设备ID
* @return 信号机亮灭状态
* @note by cgh 20251106
*/
UINT8 GetSignalLightExtinctStateZc(UINT16 wDeviceId)
{
UINT8 chReval = SIGNAL_LIGHT_EXTICT_STATE_YES;
UINT16 bufIndex = 0U; /*数组下标*/
bufIndex = GetSignalConfigBufIndex(wDeviceId); /*获取区段数组下标*/
if (bufIndex < SIGNAL_SUM_MAX)
{
chReval = gZcToCiDymDataStru.szSignalDataStruZc[bufIndex].LightExtinctState;
}
else
{
/*返回亮灯*/
}
return chReval;
}
/*
* 功能描述：设置ZC发送的信号机亮灭状态
* 参数说明：const UINT16 signalId, 信号机ID
* const UINT8 ligheCloseState, 亮灭状态
* 返 回 值：无
* Created By LQ 2025.11.07
*/
void SetSignalLightExtinctStateZc(const UINT16 signalId, const UINT8 lightExtinctState)
{
UINT16 bufIndex = 0U; /*数组下标*/
bufIndex = GetSignalConfigBufIndex(signalId); /*获取道岔数组下标*/
if (bufIndex < SIGNAL_SUM_MAX)
{
if ((SIGNAL_LIGHT_EXTICT_STATE_ALL_YES == lightExtinctState) || (SIGNAL_LIGHT_EXTICT_STATE_YES == lightExtinctState))
{
gZcToCiDymDataStru.szSignalDataStruZc[bufIndex].LightExtinctState = SIGNAL_LIGHT_EXTICT_STATE_YES;
}
else if (SIGNAL_LIGHT_EXTICT_STATE_NO == lightExtinctState)
{
gZcToCiDymDataStru.szSignalDataStruZc[bufIndex].LightExtinctState = SIGNAL_LIGHT_EXTICT_STATE_NO;
}
else
{
/*不处理*/
}
}
else
{
/*不处理*/
}
}
/*
* 功能描述：获取ZC发送的通信车跨压通过信号机状态
* 参数说明：const UINT16 signalId, 信号机ID
* 返 回 值：0 获取失败
* 0x55 未跨压
* 0xaa 跨压
* Created By LQ 2025.11.07
*/
UINT8 GetSignalCrossStateZc(const UINT16 signalId)
{
UINT16 bufIndex = 0U; /*数组下标*/
UINT8 reVal = CI_ERROR;
bufIndex = GetSignalConfigBufIndex(signalId); /*获取区段数组下标*/
if (bufIndex < SIGNAL_SUM_MAX)
{
reVal = gZcToCiDymDataStru.szSignalDataStruZc[bufIndex].SignalCrossState;
}
else
{
/*不处理*/
}
return reVal;
}
/*
* 功能描述：设置ZC发送的通信车跨压通过信号机状态
* 参数说明：const UINT16 signalId, 信号机ID
* 返 回 值：无
* Created By LQ 2025.11.07
*/
void SetSignalCrossStateZc(const UINT16 signalId, const UINT8 signalCrossState)
{
UINT16 bufIndex = 0U; /*数组下标*/
bufIndex = GetSignalConfigBufIndex(signalId); /*获取道岔数组下标*/
if (bufIndex < SIGNAL_SUM_MAX)
{
if ((SIGNAL_CROSS_STATE_NO == signalCrossState) || (SIGNAL_CROSS_STATE_YES == signalCrossState))
{
gZcToCiDymDataStru.szSignalDataStruZc[bufIndex].SignalCrossState = signalCrossState; /*设置通信车跨压通过信号机状态*/
}
else
{
/*不处理*/
}
}
else
{
/*不处理*/
}
}
/*
* 功能描述：获取ZC发送的逻辑区段临时限速设置状态
* 参数说明：const UINT16 logSectionId, 逻辑区段ID
* 返 回 值：0 获取数据失败
* 0x55 已未设置临时限速
* 0xAA 已设置临时限速
* 0xFF 临时限速无效
* Created By LQ 2025.11.07
*/
UINT8 GetLogSecLinShiXianSuStateZc(const UINT16 logSectionId)
{
UINT16 bufIndex = 0U; /*数组下标*/
UINT8 cRetVal = CI_ERROR;
bufIndex = GetlogSectionBufIndex(logSectionId); /*获取区段数组下标*/
if (LOGIC_SECTION_SUM_MAX > bufIndex)
{
cRetVal = gZcToCiDymDataStru.LogicSectionDataStruZc[bufIndex].LinShiXianSuSetFlag;
}
else
{
cRetVal = CI_ERROR;
}
return cRetVal;
}
/*
* 功能描述：设置ZC发送的逻辑区段临时限速设置状态
* 参数说明：const UINT16 logSectionId, 逻辑区段ID
* const UINT8 linShiXianSuSetState, 临时限速设置状态
* 返 回 值：无
* Created By LQ 2025.11.07
*/
void SetLogSecLinShiXianSuStateZc(const UINT16 logSectionId, const UINT8 linShiXianSuSetState)
{
UINT16 bufIndex = 0U; /*数组下标*/
bufIndex = GetlogSectionBufIndex(logSectionId); /*获取逻辑区段数组下标*/
if (LOGIC_SECTION_SUM_MAX > bufIndex)
{
if ((LOGSEC_LSXS_SET_STATE_NO == linShiXianSuSetState) ||
(LOGSEC_LSXS_SET_STATE_YES == linShiXianSuSetState) ||
(LOGSEC_LSXS_SET_STATE_INVALID == linShiXianSuSetState))
{
gZcToCiDymDataStru.LogicSectionDataStruZc[bufIndex].LinShiXianSuSetFlag = linShiXianSuSetState; /*逻辑区段临时限速设置状态*/
}
else
{
/*不做处理*/
}
}
else
{
/*不做处理*/
}
}
/*
* 功能描述：获取ZC发送的逻辑区段初始占用状态
* 参数说明：const UINT16 logSectionId, 逻辑区段ID
* 返 回 值：0 获取失败
* 0x55 未占用
* 0xAA 非通信车占用
* 0xBB 通信车占用
* Created By LQ 2025.11.07
*/
UINT8 GetLogSecOccupyStateZc(const UINT16 logSectionId)
{
UINT16 bufIndex = 0U; /*数组下标*/
UINT8 retVal = CI_ERROR;
bufIndex = GetlogSectionBufIndex(logSectionId); /*获取区段数组下标*/
if (bufIndex < LOGIC_SECTION_SUM_MAX)
{
retVal = gZcToCiDymDataStru.LogicSectionDataStruZc[bufIndex].OccupyState;
}
else
{
retVal = CI_ERROR;
}
return retVal;
}
/*
* 功能描述：设置ZC发送的逻辑区段初始占用状态
* 参数说明：const UINT16 logSectionId, 逻辑区段ID
* const UINT8 curOccupyState, 当前占用状态
* 返 回 值：无
* Created By LQ 2025.11.07
*/
void SetLogSecOccupyStateZc(const UINT16 logSectionId, const UINT8 curOccupyState)
{
UINT16 bufIndex = 0U; /*数组下标*/
bufIndex = GetlogSectionBufIndex(logSectionId); /*获取道岔数组下标*/
if (LOGIC_SECTION_SUM_MAX > bufIndex)
{
if ((LOGICSECTION_OCCUPY_UT == curOccupyState) ||
(LOGICSECTION_OCCUPY_CT == curOccupyState) ||
(LOGICSECTION_OCCUPY_NO == curOccupyState))
{
gZcToCiDymDataStru.LogicSectionDataStruZc[bufIndex].OccupyState = curOccupyState; /*逻辑区段当前占用状态*/
}
else
{
/*不设置*/
}
}
else
{
/*不设置*/
}
}
/*
* 功能描述：获取ZC发送的逻辑区段通信车占用状态
* 参数说明：const UINT16 logSectionId, 逻辑区段ID
* 返 回 值：0 获取失败
* 0x55 无车或非通信车占用
* 0xAA 通信车占用
* Created By LQ 2025.11.07
*/
UINT8 GetLogSecTXOccupyStateZc(const UINT16 logSectionId)
{
UINT16 bufIndex = 0U; /*数组下标*/
UINT8 retVal = CI_ERROR;
bufIndex = GetlogSectionBufIndex(logSectionId); /*获取区段数组下标*/
if (LOGIC_SECTION_SUM_MAX > bufIndex)
{
retVal = gZcToCiDymDataStru.LogicSectionDataStruZc[bufIndex].TXOccupyState;
}
else
{
retVal = CI_ERROR;
}
return retVal;
}
/*
* 功能描述：设置ZC发送的逻辑区段通信车占用状态
* 参数说明：const UINT16 logSectionId, 逻辑区段ID
* const UINT8 curOccupyState, 当前占用状态
* 返 回 值：无
* Created By LQ 2025.11.07
*/
void SetLogSecTXOccupyStateZc(const UINT16 logSectionId, const UINT8 curOccupyState)
{
UINT16 bufIndex = 0U; /*数组下标*/
bufIndex = GetlogSectionBufIndex(logSectionId); /*获取道岔数组下标*/
if (LOGIC_SECTION_SUM_MAX > bufIndex)
{
if ((LOGICSECTION_OCCUPY_TX == curOccupyState) ||
(LOGICSECTION_OCCUPY_NO_TX == curOccupyState))
{
gZcToCiDymDataStru.LogicSectionDataStruZc[bufIndex].TXOccupyState = curOccupyState; /*逻辑区段当前占用状态*/
}
else
{
; /*不处理*/
}
}
else
{
; /*不处理*/
}
}
/*
* 功能描述：获取ZC发送的计轴区段ARB状态
* 参数说明：const UINT16 axisSectionId, 计轴区段ID
* 返 回 值：0 获取数据失败
* 0x55 未ARB状态
* 0xaa ARB
* Created By LQ 2025.11.07
*/
UINT8 GetAxisSecArbStateZc(const UINT16 axisSectionId)
{
UINT16 bufIndex = 0U; /*数组下标*/
UINT8 retVal = CI_ERROR;
bufIndex = GetAxisSecConfigBufIndex(axisSectionId); /*获取区段数组下标*/
if (bufIndex < AXIS_SECTION_SUM_MAX)
{
retVal = gZcToCiDymDataStru.AxisSectionDataStruZc[bufIndex].AxisArbState;
}
else
{
retVal = CI_ERROR;
}
return retVal;
}
/*
* 功能描述：设置ZC发送的计轴区段ARB状态
* 参数说明：const UINT16 axisSectionId, 计轴区段ID
* const UINT8 arbState, ARB状态
* 返 回 值：无
* Created By LQ 2025.11.07
*/
void SetAxisSecArbStateZc(const UINT16 axisSectionId, const UINT8 arbState)
{
UINT16 bufIndex = 0U; /*数组下标*/
bufIndex = GetAxisSecConfigBufIndex(axisSectionId); /*获取计轴区段数组下标*/
if (bufIndex < AXIS_SECTION_SUM_MAX)
{
if ((AXIS_SECTION_ARB_NO == arbState) || (AXIS_SECTION_ARB_YES == arbState))
{
gZcToCiDymDataStru.AxisSectionDataStruZc[bufIndex].AxisArbState = arbState; /*计轴区段ARB状态*/
}
else
{
; /*不设置*/
}
}
else
{
; /*不设置*/
}
}
/*
* 功能描述：获取ZC发送的物理区段停稳状态
* 参数说明：const UINT16 phySectionId, 区段ID
* 返 回 值：0 获取数据失败
* 0x55 未停稳
* 0xAA 停稳
* Created By LQ 2025.11.07
*/
UINT8 GetPhySecStopSteadyZcOrVobc(const UINT16 phySectionId)
{
UINT16 bufIndex = 0U; /*数组下标*/
UINT8 retVal = CI_ERROR;
bufIndex = GetPhySecConfigBufIndex(phySectionId); /*获取区段数组下标*/
if (bufIndex < PHYSICAL_SECTION_SUM_MAX)
{
retVal = gZcToCiDymDataStru.PhysicalSectionDataStruZc[bufIndex].StopSteadyFlag;
}
else
{
retVal = CI_ERROR;
}
return retVal;
}
/*
* 功能描述：设置ZC发送的物理区段停稳状态
* 参数说明：const UINT16 phySectionId, 物理区段ID
* const UINT8 stopSteadyState, 停稳状态
* 返 回 值：无
* Created By LQ 2025.11.07
*/
void SetPhySecStopSteadyZcOrVobc(const UINT16 phySectionId, const UINT8 stopSteadyState)
{
UINT16 bufIndex = 0U; /*数组下标*/
bufIndex = GetPhySecConfigBufIndex(phySectionId); /*获取区段数组下标*/
if (bufIndex < PHYSICAL_SECTION_SUM_MAX)
{
if ((PHYSICAL_SECTION_STOPSTEADY_NO == stopSteadyState) || (PHYSICAL_SECTION_STOPSTEADY_YES == stopSteadyState))
{
gZcToCiDymDataStru.PhysicalSectionDataStruZc[bufIndex].StopSteadyFlag = stopSteadyState; /*物理区段停稳状态*/
}
else
{
/*不做处理*/
}
}
else
{
/*不做处理*/
}
}
/*
* 功能描述：获取ZC发送的全线雨雪模式
* 参数说明：void
* 返 回 值：0x55 有效
* 0xAA 无效
* Created By LQ 2025.11.10
*/
UINT8 GetAllSnowModelZc(void)
{
return gZcToCiDymDataStru.cSnowValidFlagZc;
}
/*
* 功能描述：设置ZC发送的全线雨雪模式
* 参数说明：UINT8 setmodle 全线雨雪模式
* 返 回 值：void
* Created By LQ 2025.11.10
*/
void SetAllSnowModelZc(UINT8 setmodle)
{
if ((CI_ALL_SNOW_VALID == setmodle) || (CI_ALL_SNOW_UNVALID == setmodle))
{
gZcToCiDymDataStru.cSnowValidFlagZc = setmodle;
}
else
{
/*不处理*/
}
}
/*
* 功能描述：获取ZC发送的本地区间雨雪站台数量
* 参数说明：无
* 返 回 值：区间雨雪站台数量
* Created By LQ 2025.11.10
*/
UINT8 GetLocalAreaSnowNumZc(void)
{
return gZcToCiDymDataStru.cAreaSnowPlatFormNumZc;
}
/*
* 功能描述：获取ZC发送的本地区间雨雪信息
* 参数说明：无
* 返 回 值：区间雨雪信息
* Created By LQ 2025.11.10
*/
AreaSnowInfoStruct* GetLocalAreaSnowZc(void)
{
return gZcToCiDymDataStru.szAreaSnowInfoZc;
}
/*
* 功能描述：设置ZC发送的本地区间雨雪信息
* 参数说明：const UINT8 cAreaSnowNum 区间雨雪数量
* const AreaSnowInfoStruct pAreaSnowBuf[LOCAL_AREA_SNOW_SUM_MAX] 区间雨雪数组
* 返 回 值：无
* Created By LQ 2025.11.10
*/
void SetLocalAreaSnowInfoZc(const UINT8 cAreaSnowNum, const AreaSnowInfoStruct pAreaSnowBuf[LOCAL_AREA_SNOW_SUM_MAX])
{
UINT8 ii = 0U;
if ((LOCAL_AREA_SNOW_SUM_MAX >= cAreaSnowNum) && (NULL != pAreaSnowBuf))
{
/*清除ZC发送的本地区间雨雪信息*/
(void)CommonMemSet(gZcToCiDymDataStru.szAreaSnowInfoZc, (UINT32)(sizeof(AreaSnowInfoStruct) * LOCAL_AREA_SNOW_SUM_MAX), 0U, (UINT32)(sizeof(AreaSnowInfoStruct) * LOCAL_AREA_SNOW_SUM_MAX));
gZcToCiDymDataStru.cAreaSnowPlatFormNumZc = cAreaSnowNum;
for (ii = 0U; ii < cAreaSnowNum; ii++)
{
gZcToCiDymDataStru.szAreaSnowInfoZc[ii] = pAreaSnowBuf[ii]; /*存储ZC发送的本控区的区间雨雪状态信息*/
}
}
else
{
/*入参非法，不处理*/
}
}
/*
* 功能描述：获取ZC发送的本地雨雪模式命令
* 参数说明：无
* 返 回 值：0x55 无效
* 0xAA 有效
* Created By LQ 2025.11.10
*/
UINT8 GetLocalSnowModelZc(void)
{
return gZcToCiDymDataStru.chLocalSnowValidFlagZc;
}
/*
* 功能描述：设置ZC发送的本地雨雪模式命令
* 参数说明：UINT8 setmodle 本地雨雪模式
* 返 回 值：无
* Created By LQ 2025.11.10
*/
void SetLocalSnowModelZc(UINT8 setmodle)
{
if ((CI_LOCAL_SNOW_UNVALID == setmodle) || (CI_LOCAL_SNOW_VALID == setmodle))
{
gZcToCiDymDataStru.chLocalSnowValidFlagZc = setmodle;
}
else
{
; /*不处理*/
}
}
TSCP/src/APP/ciapp/ParsePack/ParsePackZcData.h
+261
View File
@@ -66,6 +66,58 @@ typedef struct S_ZcToCiDataStruct
UINT16 szAreaIteCutId[ALL_AREA_SNOW_SUM_MAX]; /*区间ITE切除ID数组*/
} ZcToCiDataStruct;
/*ZC发送的信号机动态数据结构体*/
typedef struct S_SignalDataStructZC
{
UINT16 SignalId; /*信号机ID (配置字段)*/
UINT8 LightExtinctState; /*信号机亮灭状态ZC(0x55：灭灯，0xaa：亮灯)*/
UINT8 SignalCrossState; /*通信车跨压通过信号机状态ZC(0x55：未跨压，0xaa：跨压)*/
}SignalDataStructZC;
/*ZC发送的逻辑区段动态数据结构体*/
typedef struct S_LogicSectionDataStructZC
{
UINT16 LogicSectionId; /*逻辑区段ID (初始化字段)*/
UINT8 LinShiXianSuSetFlag; /*逻辑区段临时限速设置状态ZC(0x55-已未设置临时限速，0xAA-已设置临时限速，0xFF-临时限速无效)*/
UINT8 OccupyState; /*逻辑区段初始占用状态ZC(0x55-未占用，0xAA-非通信车占用，0xBB-通信车占用)*/
UINT8 TXOccupyState; /*逻辑区段通信车占用状态ZC(0x55-无车或非通信车占用，0xAA-通信车占用)*/
}LogicSectionDataStructZC;
/*ZC发送的计轴区段动态数据结构体*/
typedef struct S_AxisSectionDataStructZC
{
UINT16 AxisSectionId; /*计轴区段ID (初始化字段)*/
UINT8 AxisArbState; /*计轴ARB状态CC(0x55-未ARB，0xaa-ARB)*/
}AxisSectionDataStructZC;
/*ZC发送的物理区段动态数据结构体*/
typedef struct S_PhysicalSectionDataStructZC
{
UINT16 PhysicalSectionId; /*物理区段ID (初始化字段)*/
UINT8 StopSteadyFlag; /*区段停稳信息ZC(0x55-未停稳，0xAA-停稳)*/
}PhysicalSectionDataStructZC;
/*ZC发送的进路动态数据结构体*/
typedef struct S_RouteDataStructZC
{
UINT16 RouteId; /*进路ID (初始化字段)*/
UINT8 StopensureFlag; /*停车保证标志ZC(0x55：已设置，0xAA：未设置) */
}RouteDataStructZC;
/*存储ZC发送的动态数据结构体*/
typedef struct S_ZcToCiDynamicDataStruct
{
UINT8 cSnowValidFlagZc; /* 全线雨雪模式命令有效标志ZC */
UINT8 cAreaSnowPlatFormNumZc; /*区间雨雪站台数量ZC*/
AreaSnowInfoStruct szAreaSnowInfoZc[LOCAL_AREA_SNOW_SUM_MAX]; /*区间雨雪数组ZC*/
UINT8 chLocalSnowValidFlagZc; /* 本地雨雪模式命令有效标志ZC */
SignalDataStructZC szSignalDataStruZc[SIGNAL_SUM_MAX]; /*信号机数据结构体ZC（按顺序存储数据）*/
LogicSectionDataStructZC LogicSectionDataStruZc[LOGIC_SECTION_SUM_MAX]; /*定义逻辑区段数据结构体ZC（按顺序存储数据）*/
AxisSectionDataStructZC AxisSectionDataStruZc[AXIS_SECTION_SUM_MAX]; /*定义计轴区段数据结构体ZC（按顺序存储数据）*/
PhysicalSectionDataStructZC PhysicalSectionDataStruZc[PHYSICAL_SECTION_SUM_MAX]; /*定义物理区段数据结构体ZC（按顺序存储数据）*/
RouteDataStructZC szRouteDataStruZc[ROUTE_SUM_MAX]; /*进路数据结构体ZC（按顺序存储数据）*/
} ZcToCiDynamicDataStruct;
/*通信车位置信息*/
typedef struct S_ComTrainPosDataStruct
{
@@ -80,6 +132,7 @@ typedef struct S_ComTrainPosDataStruct
extern ComTrainPosDataStruct ComTrainPosDataStru[ZC_TO_CI_TRAIN_MAX];
extern UINT16 ComTrainSum;
extern UINT8 lineIdentity;
extern ZcToCiDynamicDataStruct gZcToCiDymDataStru; /*ZC动态数据结构体*/
#endif
@@ -207,6 +260,214 @@ ZcToCiDataStruct* GetZcToCiDataStru(void);
*/
UINT8 ParseZcIteCutData(UINT8* dataBuf, UINT16 dataLen);
/**
* @brief 获取ZC发送的进路停车保证标志
* @param[in] UINT16 wDeviceId 设备ID
* @return 进路停车保证标志
* @note by cgh 20251106
*/
UINT8 GetRouteStopensureFlagZc(UINT16 wDeviceId);
/*
* 功能描述：设置ZC发送的进路停车保证标志
* 参数说明：const UINT16 routeId, 进路ID
* const UINT8 stopensureFlag 停车保证标志
* 返 回 值：无
* Created By LQ 2025.11.06
*/
void SetRouteStopensureFlagZc(const UINT16 routeId, const UINT8 stopensureFlag);
/**
* @brief 获取ZC发送的信号机亮灭状态
* @param[in] UINT16 wDeviceId 设备ID
* @return 信号机亮灭状态
* @note by cgh 20251106
*/
UINT8 GetSignalLightExtinctStateZc(UINT16 wDeviceId);
/*
* 功能描述：设置ZC发送的信号机亮灭状态
* 参数说明：const UINT16 signalId, 信号机ID
* const UINT8 ligheCloseState, 亮灭状态
* 返 回 值：无
* Created By LQ 2025.11.06
*/
void SetSignalLightExtinctStateZc(const UINT16 signalId, const UINT8 lightExtinctState);
/*
* 功能描述：获取ZC发送的通信车跨压通过信号机状态
* 参数说明：const UINT16 signalId, 信号机ID
* 返 回 值：0 获取失败
* 0x55 未跨压
* 0xaa 跨压
* Created By LQ 2025.11.06
*/
UINT8 GetSignalCrossStateZc(const UINT16 signalId);
/*
* 功能描述：设置ZC发送的通信车跨压通过信号机状态
* 参数说明：const UINT16 signalId, 信号机ID
* 返 回 值：无
* Created By LQ 2025.11.06
*/
void SetSignalCrossStateZc(const UINT16 signalId, const UINT8 signalCrossState);
/*
* 功能描述：获取ZC发送的逻辑区段临时限速设置状态
* 参数说明：const UINT16 logSectionId, 逻辑区段ID
* 返 回 值：0 获取数据失败
* 0x55 已未设置临时限速
* 0xAA 已设置临时限速
* 0xFF 临时限速无效
* Created By LQ 2025.11.06
*/
UINT8 GetLogSecLinShiXianSuStateZc(const UINT16 logSectionId);
/*
* 功能描述：设置ZC发送的逻辑区段临时限速设置状态
* 参数说明：const UINT16 logSectionId, 逻辑区段ID
* const UINT8 linShiXianSuSetState, 临时限速设置状态
* 返 回 值：无
* Created By LQ 2025.11.06
*/
void SetLogSecLinShiXianSuStateZc(const UINT16 logSectionId, const UINT8 linShiXianSuSetState);
/*
* 功能描述：获取ZC发送的逻辑区段初始占用状态
* 参数说明：const UINT16 logSectionId, 逻辑区段ID
* 返 回 值：0 获取失败
* 0x55 未占用
* 0xAA 非通信车占用
* 0xBB 通信车占用
* Created By LQ 2025.11.06
*/
UINT8 GetLogSecOccupyStateZc(const UINT16 logSectionId);
/*
* 功能描述：设置ZC发送的逻辑区段初始占用状态
* 参数说明：const UINT16 logSectionId, 逻辑区段ID
* const UINT8 curOccupyState, 当前占用状态
* 返 回 值：无
* Created By LQ 2025.11.06
*/
void SetLogSecOccupyStateZc(const UINT16 logSectionId, const UINT8 curOccupyState);
/*
* 功能描述：获取ZC发送的逻辑区段通信车占用状态
* 参数说明：const UINT16 logSectionId, 逻辑区段ID
* 返 回 值：0 获取失败
* 0x55 无车或非通信车占用
* 0xAA 通信车占用
* Created By LQ 2025.11.06
*/
UINT8 GetLogSecTXOccupyStateZc(const UINT16 logSectionId);
/*
* 功能描述：设置ZC发送的逻辑区段通信车占用状态
* 参数说明：const UINT16 logSectionId, 逻辑区段ID
* const UINT8 curOccupyState, 当前占用状态
* 返 回 值：无
* Created By LQ 2025.11.06
*/
void SetLogSecTXOccupyStateZc(const UINT16 logSectionId, const UINT8 curOccupyState);
/*
* 功能描述：获取ZC发送的计轴区段ARB状态
* 参数说明：const UINT16 axisSectionId, 计轴区段ID
* 返 回 值：0 获取数据失败
* 0x55 未ARB状态
* 0xaa ARB
* Created By LQ 2025.11.07
*/
UINT8 GetAxisSecArbStateZc(const UINT16 axisSectionId);
/*
* 功能描述：设置ZC发送的计轴区段ARB状态
* 参数说明：const UINT16 axisSectionId, 计轴区段ID
* const UINT8 arbState, ARB状态
* 返 回 值：无
* Created By LQ 2025.11.07
*/
void SetAxisSecArbStateZc(const UINT16 axisSectionId, const UINT8 arbState);
/*
* 功能描述：获取ZC发送的物理区段停稳状态
* 参数说明：const UINT16 phySectionId, 区段ID
* 返 回 值：0 获取数据失败
* 0x55 未停稳
* 0xAA 停稳
* Created By LQ 2025.11.07
*/
UINT8 GetPhySecStopSteadyZcOrVobc(const UINT16 phySectionId);
/*
* 功能描述：设置ZC发送的物理区段停稳状态
* 参数说明：const UINT16 phySectionId, 物理区段ID
* const UINT8 stopSteadyState, 停稳状态
* 返 回 值：无
* Created By LQ 2025.11.07
*/
void SetPhySecStopSteadyZcOrVobc(const UINT16 phySectionId, const UINT8 stopSteadyState);
/*
* 功能描述：获取ZC发送的全线雨雪模式
* 参数说明：void
* 返 回 值：0x55 有效
* 0xAA 无效
* Created By LQ 2025.11.10
*/
UINT8 GetAllSnowModelZc(void);
/*
* 功能描述：设置ZC发送的全线雨雪模式
* 参数说明：UINT8 setmodle 全线雨雪模式
* 返 回 值：void
* Created By LQ 2025.11.10
*/
void SetAllSnowModelZc(UINT8 setmodle);
/*
* 功能描述：获取ZC发送的本地区间雨雪站台数量
* 参数说明：无
* 返 回 值：区间雨雪站台数量
* Created By LQ 2025.11.10
*/
UINT8 GetLocalAreaSnowNumZc(void);
/*
* 功能描述：获取ZC发送的本地区间雨雪信息
* 参数说明：无
* 返 回 值：区间雨雪信息
* Created By LQ 2025.11.10
*/
AreaSnowInfoStruct* GetLocalAreaSnowZc(void);
/*
* 功能描述：设置ZC发送的本地区间雨雪信息
* 参数说明：const UINT8 cAreaSnowNum 区间雨雪数量
* const AreaSnowInfoStruct pAreaSnowBuf[LOCAL_AREA_SNOW_SUM_MAX] 区间雨雪数组
* 返 回 值：无
* Created By LQ 2025.11.10
*/
void SetLocalAreaSnowInfoZc(const UINT8 cAreaSnowNum, const AreaSnowInfoStruct pAreaSnowBuf[LOCAL_AREA_SNOW_SUM_MAX]);
/*
* 功能描述：获取ZC发送的本地雨雪模式命令
* 参数说明：无
* 返 回 值：0x55 无效
* 0xAA 有效
* Created By LQ 2025.11.10
*/
UINT8 GetLocalSnowModelZc(void);
/*
* 功能描述：设置ZC发送的本地雨雪模式命令
* 参数说明：UINT8 setmodle 本地雨雪模式
* 返 回 值：无
* Created By LQ 2025.11.10
*/
void SetLocalSnowModelZc(UINT8 setmodle);
#ifdef __cplusplus
}
#endif
TSCP/src/APP/ciapp/QueryFiles/commonQueryStruDef.c
+2
View File
@@ -70,6 +70,8 @@ UINT16* dsuATSIndex; /*ATS
UINT16* dsuCIIndex; /*CI信息索引数组*/
UINT16* dsuRCIndex; /*CI信息索引数组*/
UINT16* dsuARIndex; /*新增加的结构体自动折返表，对应索引数组*/
UINT16* dsuZCComZoneIndex; /*新增加的ZC共管区域，对应索引数组 2012.1.5*/
TSCP/src/APP/ciapp/QueryFiles/commonQueryStruDef.h
+2
View File
@@ -74,6 +74,8 @@ extern UINT16* dsuATSIndex; /*ATS
extern UINT16* dsuCIIndex; /*CI信息索引数组*/
extern UINT16* dsuRCIndex; /*CI信息索引数组*/
extern UINT16* dsuARIndex; /*新增加的结构体自动折返表，对应索引数组*/
extern UINT16* dsuZCComZoneIndex; /*新增加的ZC共管区域，对应索引数组 2012.1.5*/
TSCP/src/APP/ciapp/QueryFiles/dquCIInit.c
+380 -20
View File
@@ -168,10 +168,24 @@ UINT8 RelayInit(CHAR* FSName)
if (DATA_TYPE_OLD == chLocalOc)
{
funcRtn *= OCSwitchConfigDataStructInit_OLD(FSName);
if (0u == funcRtn)
{
debug_infor_printf((const)"OCSwitchConfigDataStructInit_OLD fail.\r\n");
}
}
else
{
funcRtn *= OCSwitchConfigDataStructInit(FSName);
if (0u == funcRtn)
{
debug_infor_printf((const)"OCSwitchConfigDataStructInit fail.\r\n");
}
/*初始化OC 道岔转辙机状态指示灯*/
funcRtn *= OCSwitchCfgZzjDataStuInit(FSName);
if (0u == funcRtn)
{
debug_infor_printf((const)"OCSwitchCfgZzjDataStuInit fail.\r\n");
}
}
/*初始化OC 信号机配置表数据*/
@@ -181,7 +195,6 @@ UINT8 RelayInit(CHAR* FSName)
funcRtn *= OCPhySecConfigDataStructInit(FSName);
if (0u == funcRtn)
{
debug_infor_printf((const)"OCPhySecConfigDataStructInit fail.\r\n");
@@ -2040,7 +2053,7 @@ UINT8 PhySgmtCfgDtStruFromDquSgmtStr(DSU_PHYSICAL_SGMT_STRU* pPhysicalSgmt, Phys
{
}
}
if ((0u < dquCICfgDtStr.OCPhySecCfgStrLen) || (AXIS_TYPE_YONGLIE == acFty) || (AXIS_TYPE_KEANDA == acFty) || (AXIS_TYPE_FUHAOSHENG == acFty))
if ((0u < dquCICfgDtStr.OCPhySecCfgStrLen) || (AXIS_TYPE_YONGLIE == acFty) || (AXIS_TYPE_KEANDA == acFty) || (AXIS_TYPE_FUHAOSHENG == acFty) || (AXIS_TYPE_STANDARD_INTERFACE == acFty))
{
rtnvalue = 1u;
/*全电子联锁增加计轴总复位*/
@@ -3407,6 +3420,46 @@ UINT8 OverlapCfgDtStruFromDquStr(DSU_PROTECT_LINK_STRU * pProtectLink, OverlapCo
{
;
}
if (1U == rtnvalue)
{
for (k = 0u; k < LSDataLen.LSOverlapLockCondStruLen; k++)/*遍历保护区段锁闭条件表*/
{
if (LSData.pLSOverlapLockCondStru[k].wOverlapId == pOvlpCfgDtStr->OverlapId)
{
pOvlpCfgDtStr->SideProtecGroupData.GroupID = LSData.pLSOverlapLockCondStru[k].wSidePretectGroupId;/*找到侧防条件组ID*/
break;
}
}
if ((0u < pOvlpCfgDtStr->SideProtecGroupData.GroupID) && (UINT16_MAX > pOvlpCfgDtStr->SideProtecGroupData.GroupID))
{/*配置了侧防条件组ID*/
for (k = 0u; k < LSDataLen.LSSideProtecGroupStruLen; k++)/*遍历侧防条件组表*/
{
if (pOvlpCfgDtStr->SideProtecGroupData.GroupID == LSData.pLSSideProtecGroupStru[k].GroupID)/*根据侧防组ID匹配侧防条件*/
{
CommonMemCpy(&pOvlpCfgDtStr->SideProtecGroupData, sizeof(SideProtecGroupStru), &LSData.pLSSideProtecGroupStru[k], sizeof(SideProtecGroupStru));
break;
}
}
if (0u < LSDataLen.LSSideProtecGroupStruLen)
{/*存在侧防条件组表配置*/
if (LSDataLen.LSSideProtecGroupStruLen == k)
{/*侧防组表不存在指定组ID*/
rtnvalue = 0u;
}
else
{
/*无处理*/
}
}
else
{
rtnvalue = 0u;
}
}
}
return rtnvalue;
}
@@ -3427,7 +3480,7 @@ UINT8 OverlapConfigDataStructInit(CHAR * FSName)
callFun *= InitLS_RouteStruct (FSName);
callFun *= InitLS_OverlapLockCondStru(FSName);
callFun *= InitLS_FHDaoChaStru(FSName);
callFun *= InitLSSideProtec(FSName);/*初始化侧防条件表*/
/*电子地图初始化失败，函数失败退出*/
if(0u == callFun)
{
@@ -3590,6 +3643,7 @@ UINT8 PsdCfgDtStruFromDquEmergStr(DSU_SCREEN_STRU * pScreen,PsdConfigDataStruct*
UINT8 rtnvalue = 0u;
UINT16 stationId = 0u;
UINT16 linkindex = 0u;
UINT8 esbnum = 0u;
/*入口参数防护*/
if((NULL == pScreen) || (NULL == pPsdCfgDtStr))
@@ -3613,11 +3667,13 @@ UINT8 PsdCfgDtStruFromDquEmergStr(DSU_SCREEN_STRU * pScreen,PsdConfigDataStruct*
pPsdCfgDtStr->CloseDriveRelayId = 0u;
pPsdCfgDtStr->DoorStateRelayId = 0u;
pPsdCfgDtStr->MutualLockRelayId = 0u;
pPsdCfgDtStr->OpenThreeEditGroupDriveRelayId = 0U;
pPsdCfgDtStr->OpenFourEditGroupDriveRelayId = 0u;
pPsdCfgDtStr->OpenSixEditGroupDriveRelayId = 0u;
pPsdCfgDtStr->OpenEightEditGroupDriveRelayId = 0u;
pPsdCfgDtStr->wRelayDoorButtonId = 0u;
pPsdCfgDtStr->doorReopenRelayId = 0u;
pPsdCfgDtStr->doorReopenRelayId2 = 0u;
pPsdCfgDtStr->departureConfirmRelayId = 0u;
pPsdCfgDtStr->detectStartRelayId = 0u;
pPsdCfgDtStr->detectStopRelayId = 0u;
@@ -3689,6 +3745,10 @@ UINT8 PsdCfgDtStruFromDquEmergStr(DSU_SCREEN_STRU * pScreen,PsdConfigDataStruct*
pPsdCfgDtStr->wVideoQkLight2RelayId = (RelayData.pRelayScreenStr + i)->wVideoQkLight2RelayId;
pPsdCfgDtStr->VirtualAttribute = PSD_VIRTUAL_ATTR_NO;/*初始化为非虚拟属性*/
pPsdCfgDtStr->chPsdControlType = (RelayData.pRelayScreenStr + i)->chControlType;
pPsdCfgDtStr->OpenThreeEditGroupDriveRelayId = (RelayData.pRelayScreenStr + i)->wRelayThreeEditGroupOpenDoorId;
pPsdCfgDtStr->doorReopenRelayId2 = (RelayData.pRelayScreenStr + i)->doorReopenRelayId2;
break; /*屏蔽门继电器表中找到此屏蔽门，停止遍历*/
}
else
@@ -3696,6 +3756,26 @@ UINT8 PsdCfgDtStruFromDquEmergStr(DSU_SCREEN_STRU * pScreen,PsdConfigDataStruct*
/*继续初始化*/
}
}
for (i = 0u; i < dquCICfgDtStr.EsbCfgDtStrLen; i++)
{
if (pPsdCfgDtStr->BelongPlatformId == dquCICfgDtStr.EsbCfgDtStr[i].BelongPlatFormId)
{/*psd逻辑站台等于ESB所属逻辑站台*/
if (PSD_INCLUDE_ESB_NUM > esbnum)
{
pPsdCfgDtStr->IncloudeEsbIdBuf[esbnum] = dquCICfgDtStr.EsbCfgDtStr[i].EsbId;
esbnum++;
}
else
{
rtnvalue = 0U;
break;
}
}
}
pPsdCfgDtStr->IncloudeEsbNum = esbnum;
}
else
{
@@ -4793,8 +4873,9 @@ UINT8 RouteCfgDtStruFrmLSRouteStr( LS_RouteStruct * pLSRouteStr,RouteConfigDataS
rtnvalue = CI_ERROR;
}
ciType = (UINT8)(dsuStaticHeadStru.pCIStruStru[dsuCIIndex[pRouteCfgDtStr->BelongCiId]].wType);/*进路所属联锁类型*/
ciType = GetdsuStaticDataCiType(pRouteCfgDtStr->BelongCiId);/*进路所属联锁类型*/
if ((CI_ERROR != ciType)&&(CI_ERROR!= rtnvalue))
{
/*进路属性*/
if (0x01u == (pDsuRouteStr->wRouteType & 0x01u))
{
@@ -4881,6 +4962,15 @@ UINT8 RouteCfgDtStruFrmLSRouteStr( LS_RouteStruct * pLSRouteStr,RouteConfigDataS
}
else
{
}
/*进路联挂属性*/
if (0x8000U == (pDsuRouteStr->wRouteType & 0x8000U))
{
pRouteCfgDtStr->chRouteCouplinkType = ROUTE_TYPE_COUPLINK;
}
else
{
}
/*自动进路属性*/
@@ -5269,7 +5359,8 @@ UINT8 RouteCfgDtStruFrmLSRouteStr( LS_RouteStruct * pLSRouteStr,RouteConfigDataS
}
}else
}
else
{
}
@@ -5306,8 +5397,11 @@ UINT8 RouteCfgDtStruFrmLSRouteStr( LS_RouteStruct * pLSRouteStr,RouteConfigDataS
}
}
}
}
else
{
rtnvalue = CI_ERROR;
}
if(CI_SUCCESS == rtnvalue)
{
@@ -6735,6 +6829,37 @@ UINT8 RouteCfgDtStruFrmLSRouteStr( LS_RouteStruct * pLSRouteStr,RouteConfigDataS
{
}
#endif
if (CI_SUCCESS == rtnvalue)
{
if ((0u < pLSRouteStr->wSidePretecGroupID)&&(UINT16_MAX > pLSRouteStr->wSidePretecGroupID))
{
pRouteCfgDtStr->RouteSideProtecData.GroupID = pLSRouteStr->wSidePretecGroupID;
for (i = 0u; i < LSDataLen.LSRouteSideProtecStruLen; i++) /*遍历侧防组表*/
{
if (LSData.pLSSideProtecGroupStru[i].GroupID == pRouteCfgDtStr->RouteSideProtecData.GroupID)
{
CommonMemCpy(&pRouteCfgDtStr->RouteSideProtecData, sizeof(SideProtecGroupStru), &LSData.pLSSideProtecGroupStru[i], sizeof(SideProtecGroupStru));
break;
}
}
if (0U < LSDataLen.LSRouteSideProtecStruLen)
{
if (LSDataLen.LSRouteSideProtecStruLen == i)
{/*未找到*/
rtnvalue = 0u;/*查询出错*/
}
else
{/*无处理*/
}
}
else
{
rtnvalue = 0u;/*查询出错*/
}
}
}
}
else
{
@@ -6965,7 +7090,6 @@ UINT8 RouteConfigDataStructInit(CHAR * FSName)
callFun *= InitRelay_DCAgreeStru(FSName);/*初始化调车同意继电器表*/
callFun *= InitLS_SGBJStru(FSName); /*初始化声光报警表*/
callFun *= InitLS_TransRouteRtnDataStruct(FSName); /*初始化转换轨折返信号机表*/
/*电子地图初始化失败，函数失败退出*/
if(0u == callFun)
{
@@ -7092,8 +7216,12 @@ UINT8 RouteConfigDataStructInit(CHAR * FSName)
{
rtnvalue = 0u;
}
if ((CI_TYPE_ZX == (UINT8)dsuStaticHeadStru.pCIStruStru[dsuCIIndex[dquCICfgDtStr.RouteCfgDtStr[i].BelongCiId]].wType)
|| (CI_TYPE_SCX == (UINT8)dsuStaticHeadStru.pCIStruStru[dsuCIIndex[dquCICfgDtStr.RouteCfgDtStr[i].BelongCiId]].wType))
else
{
callFun = GetdsuStaticDataCiType(dquCICfgDtStr.RouteCfgDtStr[i].BelongCiId);
if (CI_ERROR != callFun)
{
if ((CI_TYPE_ZX == callFun) || (CI_TYPE_SCX == callFun))
{
execRet = RouteMainProConfigDataInit(dquCICfgDtStr.RouteCfgDtStr, &(dquCICfgDtStr.RouteCfgDtStr[i]));
if (execRet > 0u)
@@ -7115,6 +7243,12 @@ UINT8 RouteConfigDataStructInit(CHAR * FSName)
dquCICfgDtStr.RouteCfgDtStr[i].MainOrSubData.MainRouteProperty = ROUTE_INIT_PROPERTY; /*车辆段默认为普通进路*/
}
}
else
{
rtnvalue = 0u; /*联锁类型获取失败*/
}
}
}
}
/*逻辑区段关联进路及防护道岔计算*/
@@ -7228,7 +7362,7 @@ UINT8 TransmitRelationDataStruFrmSZ(UINT16 Data[])
UINT8 tmpCiId=0u; /*临时变量：ci id*/
UINT8 tmpOtherSysType =0u;/*临时变量：其它系统类型*/
UINT8 findFlag = 0u; /*找到标志*/
UINT16 chRcType = 0U;
/*入口参数防护*/
if(NULL == Data)
{
@@ -7238,8 +7372,15 @@ UINT8 TransmitRelationDataStruFrmSZ(UINT16 Data[])
else
{
}
if((0x3c00u != (Data[0]&0xFF00u)))
if (RC_WORK_MODE_CI == CI_SYSTEM_TYPE_RCI)
{
chRcType = 0x3C00U;
}
else
{
chRcType = 0x3D00U;
}
if((chRcType != (Data[0]&0xFF00u)))
{
rtnvalue = 1u;
return rtnvalue;
@@ -7386,10 +7527,12 @@ UINT8 RouteOpposedConfigDataInite(RouteConfigDataStruct * RouteCfgDtStr,RouteCon
UINT8 rtnvalue = 1u;
UINT8 Flag = 0u;
UINT8 chRouteCitype = 0U;
chRouteCitype = (UINT8)(dsuStaticHeadStru.pCIStruStru[dsuCIIndex[pRouteCfgDtStr->BelongCiId]].wType); /*进路所属联锁类型*/
chRouteCitype = GetdsuStaticDataCiType(pRouteCfgDtStr->BelongCiId); /*进路所属联锁类型*/
/*抵触进路ID数组 (配置字段)*/
pRouteCfgDtStr->OpposedRouteSum = 0u;
if (CI_ERROR !=chRouteCitype)
{
if ((CI_TYPE_CLD != chRouteCitype) && (CI_TYPE_TCC != chRouteCitype))
{
for (i = 0u; i < pRouteCfgDtStr->RoutePhySecSum; i++)
@@ -7456,6 +7599,11 @@ UINT8 RouteOpposedConfigDataInite(RouteConfigDataStruct * RouteCfgDtStr,RouteCon
/*车辆段无自动属性进路*/
rtnvalue = 1u;
}
}
else
{
rtnvalue = 0U;
}
return rtnvalue;
}
@@ -8109,6 +8257,8 @@ UINT8 ReadSpksConfigDataFromDquData(SpksDataConfigStruct* pSpksDataConfig)
pSpksDataConfig->cutDisplayRelayId = 0u;
pSpksDataConfig->menjinJSRelayId = 0u; /*新增SPKS关联的门禁解锁继电器ID */
pSpksDataConfig->VirtualAttribute = SPKS_VIRTUAL_ATTR_NO;/*初始化为非虚拟的*/
pSpksDataConfig->buzzRelayId = 0u;
pSpksDataConfig->cutBuzzRelayId = 0u;
if (NULL != RelayData.pRelaySpksStr)
{
for (i=0u;i < RelayDataLen.RelaySpksStrLen; i++)
@@ -8167,6 +8317,24 @@ UINT8 ReadSpksConfigDataFromDquData(SpksDataConfigStruct* pSpksDataConfig)
/*无操作*/
}
if ((0x0U != RelayData.pRelaySpksStr[i].buzzRelayId) && (0xffffU != RelayData.pRelaySpksStr[i].buzzRelayId))
{
pSpksDataConfig->buzzRelayId = RelayData.pRelaySpksStr[i].buzzRelayId;/*spks蜂鸣继电器*/
}
else
{
/*无操作*/
}
if ((0x0U != RelayData.pRelaySpksStr[i].cutBuzzRelayId) && (0xffffU != RelayData.pRelaySpksStr[i].cutBuzzRelayId))
{
pSpksDataConfig->cutBuzzRelayId = RelayData.pRelaySpksStr[i].cutBuzzRelayId;/*spks切除蜂鸣继电器*/
}
else
{
/*无操作*/
}
pSpksDataConfig->VirtualAttribute = SPKS_VIRTUAL_ATTR_NO;/*继电器表中查找到，则认为SPKS为非虚拟的*/
if (0u == pSpksDataConfig->colRelayId)
{
@@ -8261,7 +8429,7 @@ UINT8 ReadMJConfigDataFromDquData( MJDataConfigStruct* pMJDataConfig)
if ((0x0u != RelayData.pMjStr[i].mjjsRelayId) && (0xffffu != RelayData.pMjStr[i].mjjsRelayId))
{
pMJDataConfig[i].mjjsRelayId = RelayData.pMjStr[i].mjjsRelayId;
pMJDataConfig[i].belongCiId = (UINT8)GetCiIdByOcId(RelayData.pMjStr[i].ocId);
pMJDataConfig[i].belongCiId = GetCiIdByOcId(RelayData.pMjStr[i].ocId);
}
else
{
@@ -8962,7 +9130,7 @@ UINT8 CiPatternInit(CHAR* FSName)
SetLocalCiCTNearUnLockTime(val);
SetLocalWaysidePattern(pDataAddr[11]);
rtnValue = SetLocalRcWorkMode(pDataAddr[12]);
rtnValue = SetSystemWorkType(pDataAddr[12]);
}
findFlag = 1u;
@@ -9694,6 +9862,77 @@ UINT8 OCSwitchConfigDataStructInit(CHAR *FSName)
return rtnValue;
}
/*********************************************
*函数功能：初始化OC 道岔转辙机状态指示灯表
*参数说明：FSName文件指针
*返回值：0，失败；1，成功
*********************************************/
UINT8 OCSwitchCfgZzjDataStuInit(CHAR* FSName)
{
UINT8 rtnValue = 0u;
UINT8* pDataAddr = NULL; /*数据地址*/
UINT32 DataSize = 0u; /*数据大小（字节数）*/
UINT8 funcRtn = 0u;
UINT16 realRowCount = 0u; /*实际表数据的行数*/
UINT16 i = 0u;
UINT16 wDataLen = 0u; /*数据宽度*/
/*入口参数检查*/
if (NULL == FSName)
{
; /*入口参数不合法*/
}
else
{
/*读取道岔转辙机状态指示灯表数据*/
funcRtn = dquGetConfigDataNew(FSName, OC_DATA_TYPE, OC_SWITCH_ZZJ_POWER_ID, &pDataAddr, &DataSize, &realRowCount);
if (0u == funcRtn)
{
rtnValue = 0u;
}
else
{
rtnValue = 1u;
for (i = 0u; i < SWITCH_SUM_MAX; i++)
{
funcRtn &= CommonMemSet(dquCICfgDtStr.SwchCfgDtStr[i].ZzjPowerData, (UINT32)(SWITCH_ZZJ_POWER_STATE_MAX_NUM * sizeof(ZzjPowerConfigDataStruct)), 0u, (UINT32)(SWITCH_ZZJ_POWER_STATE_MAX_NUM * sizeof(ZzjPowerConfigDataStruct)));
}
if (1u == funcRtn)
{
/*不做处理*/
}
if ((0u != DataSize) && (0u != realRowCount))
{
if (0u == (DataSize % realRowCount))
{
/*计算每行字节长度*/
wDataLen = (UINT16)(DataSize / realRowCount);
for (i = 0u; i < realRowCount; i++)
{
/*道岔转辙机状态指示灯表配置表*/
(void)R_OCSwitchZzjCfgDataFromChar(pDataAddr);
pDataAddr += wDataLen;
}
}
else
{
/*数据错误*/
rtnValue = 0u;
}
}
else
{
; /*不做处理*/
}
}
}
return rtnValue;
}
/*********************************************
*函数功能：初始化OC 道岔配置表数据——OC2.1.6
@@ -10067,13 +10306,13 @@ UINT8 OCPhySecConfigDataStructInit(CHAR *FSName)
* 参数说明：
* UINT16 ocId：oc编号
* 返回值：
* UINT16：联锁id
* UINT8：联锁id
*/
UINT16 GetCiIdByOcId(UINT16 ocId)
UINT8 GetCiIdByOcId(UINT16 ocId)
{
UINT16 i = 0u; /*用于循环*/
UINT16 j = 0u; /*用于循环*/
UINT16 ciId = 0u; /*CI ID*/
UINT8 ciId = 0u; /*CI ID*/
UINT8 isBreak = 0u; /*是否退出遍历*/
for (i = 0u; i < dquCICfgDtStr.TrsmtRlsDtStrLen; i++)
@@ -11356,6 +11595,55 @@ void R_OCSwitchConfigDataFromChar(UINT8* pDataAddr)
}
}
/*********************************************
*函数功能：解析OC 道岔转辙机状态指示灯表
*参数说明：pDataAddr 数据地址；
*返回值：0，失败；1，成功
*********************************************/
void R_OCSwitchZzjCfgDataFromChar(UINT8* pDataAddr)
{
UINT8* pData = NULL;
UINT16 SwitchIdTemp = 0u;
UINT8 i = 0U;
ZzjPowerConfigDataStruct* zzjPowerTempData = NULL; /*转辙机供电配置数据*/
if (NULL == pDataAddr)
{
; /*入口参数为空，不进行解析操作*/
}
else
{
pData = pDataAddr;
SwitchIdTemp = ShortFromChar(pData);
zzjPowerTempData = dquCICfgDtStr.SwchCfgDtStr[g_dsuEmapStru->dsuEmapIndexStru->dsuPointIndex[SwitchIdTemp]].ZzjPowerData;
if (SwitchIdTemp < SWITCH_SUM_MAX)
{
/*道岔ID--2字节*/
// pOCSwitchZzjPowerCfgDtStr->SwitchId = SwitchIdTemp;
pData += 2u;
for (i = 0u; i < SWITCH_ZZJ_POWER_STATE_MAX_NUM; i++)
{
/*转辙机J1定表灯_供电1--2字节*/
zzjPowerTempData[i].ZzjDingweiPower1 = ShortFromChar(pData);
pData += 2u;
/*转辙机J1定表灯_供电2--2字节*/
zzjPowerTempData[i].ZzjDingweiPower2 = ShortFromChar(pData);
pData += 2u;
/*转辙机J1反表灯_供电1--2字节*/
zzjPowerTempData[i].ZzjFanweiPower1 = ShortFromChar(pData);
pData += 2u;
/*转辙机J1反表灯_供电2--2字节*/
zzjPowerTempData[i].ZzjFanweiPower2 = ShortFromChar(pData);
pData += 2u;
}
}
}
}
/*********************************************
*函数功能：主进路及子进路相关数据初始化
*参数说明：pRouteCfgDtStr进路配置数据结构体指针
@@ -12752,4 +13040,76 @@ static UINT8 LinkSpecialEaDataInit(CHAR* FSName)
return retVal;
}
/*
*功能描述: 获取联锁属性：
*输入参数: CHAR * FSName 数据文件名指针
*输出参数: 无
*返回值: CI_TYPE_ZX 1 正线联锁
CI_TYPE_CLD 4 车辆段联锁
CI_TYPE_SCX 2 试车线
CI_TYPE_TCC 3 停车场
CI_ERROR 0 失败
* 适用于调用在gEmapCiConfigStrus初始化之前
* by fan 20250909
*/
UINT8 GetdsuStaticDataCiType(UINT8 chCiID)
{
UINT8 chType = 0U;
UINT8 chFindRc = CI_ERROR;
UINT8 i = 0U;
if (RC_WORK_MODE_TIOC == CI_SYSTEM_TYPE_RCI)
{
if ((NULL != g_dsuEmapStru->dsuDataLenStru)
&& (0U != g_dsuEmapStru->dsuDataLenStru->wRCLen))
{
for (i = 0U; i < g_dsuEmapStru->dsuDataLenStru->wRCLen; i++)
{
if (chCiID == (UINT8)dsuStaticHeadStru.pRCStruStru[i].wID)
{
chType = (UINT8)dsuStaticHeadStru.pRCStruStru[i].wType;
chFindRc = CI_SUCCESS;
break;
}
}
}
else
{
chType = CI_ERROR;/*RC模式未配置RC表，返回错误*/
}
}
if ((RC_WORK_MODE_CI == CI_SYSTEM_TYPE_RCI) ||
((RC_WORK_MODE_TIOC == CI_SYSTEM_TYPE_RCI)&&(CI_ERROR == chFindRc)))
{
/*联锁模式 或 RC表未配置该联锁*/
if ((NULL != g_dsuEmapStru->dsuDataLenStru)
&& (0U != g_dsuEmapStru->dsuDataLenStru->wCILen))
{
for (i = 0U; i < g_dsuEmapStru->dsuDataLenStru->wCILen; i++)
{
if (chCiID == (UINT8)dsuStaticHeadStru.pCIStruStru[i].wID)
{
chType = (UINT8)dsuStaticHeadStru.pCIStruStru[i].wType;
break;
}
}
}
else
{
chType = CI_ERROR;/*返回错误*/
}
}
if ((CI_TYPE_ZX == chType) || (CI_TYPE_CLD == chType)
|| (CI_TYPE_SCX == chType) || (CI_TYPE_TCC == chType))
{
; /*合法值*/
}
else
{
/*非法值*/
(void)debug_infor_printf((const)"GetdsuStaticDataCiType fail: CI ID :%d ; Type :%d\n", chCiID, chType);
chType = CI_ERROR;
}
return chType;
}
TSCP/src/APP/ciapp/QueryFiles/dquCIInit.h
+32 -3
View File
@@ -60,8 +60,9 @@
#define OC_PHYSEC_CFG_STR_MEMBER_NUM ((UINT8)6)
#define AXIS_TYPE_YONGLIE ((UINT8)(0x01)) /*永列*/
#define AXIS_TYPE_KEANDA ((UINT8)(0x02)) /*科安达*/
#define AXIS_TYPE_KEANDA ((UINT8)(0x02)) /*科安达既有线路接口*/
#define AXIS_TYPE_FUHAOSHENG ((UINT8)(0x03)) /*富豪盛*/
#define AXIS_TYPE_STANDARD_INTERFACE ((UINT8)(0x04)) /*科安达城轨标准接口*/
#define INDICATOR_MAX_SIZE ((UINT16)2000) /*报警灯最大数组大小*/
@@ -584,6 +585,13 @@ UINT8 OCConfigDataStructInit(UINT16* len, CHAR* FSName, UINT32 DataTypeID, UINT3
*********************************************/
UINT8 OCSwitchConfigDataStructInit(CHAR *FSName);
/*********************************************
*函数功能：初始化OC 道岔转辙机状态指示灯表
*参数说明：FSName文件指针
*返回值：0，失败；1，成功
*********************************************/
UINT8 OCSwitchCfgZzjDataStuInit(CHAR* FSName);
/*********************************************
*函数功能：初始化OC 道岔配置表数据——OC2.1.6
*参数说明：FSName文件指针
@@ -625,9 +633,9 @@ UINT8 OCPhySecConfigDataStructInit(CHAR *FSName);
* 参数说明：
* UINT16 ocId：oc编号
* 返回值：
* UINT16：联锁id
* UINT8：联锁id
*/
UINT16 GetCiIdByOcId(UINT16 ocId);
UINT8 GetCiIdByOcId(UINT16 ocId);
/*********************************************
*函数功能：初始化站台门控制器配置数据结构体----对外结构体
@@ -821,6 +829,12 @@ UINT8 EaConfigDataStructInit(CHAR * FSName);
*备注：cgh-合并CID-2539-5：：修改初始化《OC_配置数据表》中“物理区段模块配置表”、“信号机模块配置表”、“道岔模块配置表”的初始化方式，和其他表格的初始化方式一致
*********************************************/
void R_OCSwitchConfigDataFromChar(UINT8* pDataAddr);
/*********************************************
*函数功能：解析OC 道岔转辙机状态指示灯表
*参数说明：pDataAddr 数据地址；
*返回值：0，失败；1，成功
*********************************************/
void R_OCSwitchZzjCfgDataFromChar(UINT8* pDataAddr);
/*********************************************
*函数功能：主进路及子进路相关数据初始化
@@ -937,5 +951,20 @@ UINT8 AgLinkExistRelCGFlagCalc(LinkDataConfigStru* pLinkScCfgDtStr);
*********************************************/
UINT8 BGLinkRelAGLinkCal(LinkDataConfigStru* pLinkScCfgDtStr);
/*
*功能描述: 获取联锁属性：
*输入参数: CHAR * FSName 数据文件名指针
*输出参数: 无
*返回值:
CI_TYPE_ZX 1 正线联锁
CI_TYPE_CLD 4 车辆段联锁
CI_TYPE_SCX 2 试车线
CI_TYPE_TCC 3 停车场
CI_ERROR 0 失败
* 适用于调用在gEmapCiConfigStrus初始化之前
* by fan 20250909
*/
UINT8 GetdsuStaticDataCiType(UINT8 chCiID);
#endif
TSCP/src/APP/ciapp/QueryFiles/dquCIInterFace.c
+268 -43
View File
@@ -2432,14 +2432,9 @@ UINT8 ReadSystemParamConfDataNew(const UINT8 ciId,SystemParameterStructNew* Syst
/*OC-TMC通信故障判断时间（ms）*/
SystemParameterStru->TmcOcCommunicationErrorTime = dquCICfgDtStr.SystemParaStrNew.TmcOcCommunicationErrorTime;
if (CI_TYPE_TCC == dsuStaticHeadStru.pCIStruStru[dsuCIIndex[ciId]].wType)
{
SystemParameterStru->CiType = CI_TYPE_CLD;
}
else
{
SystemParameterStru->CiType = (UINT8)dsuStaticHeadStru.pCIStruStru[dsuCIIndex[ciId]].wType;
}
/*本联锁类型，TCC转CLD已经在ReadEmapCiConfig处理*/
SystemParameterStru->CiType = gEmapCiConfigStrus[ciId].ciType;
SystemParameterStru->dwLineMinTrainLength = dquCICfgDtStr.SystemParaStrNew.dwLineMinTrainLength;
@@ -3260,6 +3255,7 @@ static void CIInitEmap(DSU_EMAP_STRU dsuEmapStruPar)
dsuAROutIndex = dsuEmapStruPar.dsuEmapIndexStru->dsuAROutIndex; /*无人折返退出区域信息索引数组*/
dsuATSIndex = dsuEmapStruPar.dsuEmapIndexStru->dsuATSIndex; /*ATS信息索引数组*/
dsuCIIndex = dsuEmapStruPar.dsuEmapIndexStru->dsuCIIndex; /*CI信息索引数组*/
dsuRCIndex = dsuEmapStruPar.dsuEmapIndexStru->dsuRCIndex; /*CI信息索引数组*/
dsuARIndex = dsuEmapStruPar.dsuEmapIndexStru->dsuARIndex; /*新增加的结构体自动折返表，对应索引数组*/
dsuZCComZoneIndex = dsuEmapStruPar.dsuEmapIndexStru->dsuZCComZoneIndex; /*新增加的ZC共管区域，对应索引数组 2012.1.5*/
dsuConResSpeedIndex = dsuEmapStruPar.dsuEmapIndexStru->dsuConResSpeedIndex; /*统一限速索引数组*/
@@ -3458,30 +3454,33 @@ UINT8 ReadVirtualDevicesInit(PsdConfigDataStruct* psdCfgData, EsbConfigDataStruc
*/
void ReadEmapCiConfig(EmapCiConfigStru emapVerArr[])
{
UINT16 ciStruSum = 0u;
UINT16 wCIStruSum = 0u;
UINT16 wRCStruSum = 0u;
UINT16 i;
UINT8 ciId;
UINT8 jj = 0U;
if (NULL != emapVerArr)
{
ciStruSum = dsuDataLenStru.wCILen;
wCIStruSum = dsuDataLenStru.wCILen;
for (i = 0u;i < ciStruSum;i++)
for (i = 0u; i < wCIStruSum; i++)
{
ciId = (UINT8)(dsuStaticHeadStru.pCIStruStru[i].wID);
ciId = (UINT8)(dsuStaticHeadStru.pCIStruStru[i].wID & 0x00FF);
emapVerArr[ciId].devId = ciId;
emapVerArr[ciId].ciType = (UINT8)(dsuStaticHeadStru.pCIStruStru[i].wType);
if (CI_TYPE_TCC == dsuStaticHeadStru.pCIStruStru[i].wType)
{
emapVerArr[ciId].ciType = CI_TYPE_CLD;
}
if (RC_WORK_MODE_CI == CI_SYSTEM_TYPE_RCI)
{
emapVerArr[ciId].dataVerCheckCIAndVOBC = dsuStaticHeadStru.pCIStruStru[i].dwVersionOfCIToVOBC;
emapVerArr[ciId].dataVerCheckCIAndZC = dsuStaticHeadStru.pCIStruStru[i].dwVersionOfCIToZC;
emapVerArr[ciId].dataVerCheckCIAndATS = dsuStaticHeadStru.pCIStruStru[i].dwVersionOfCIToATS;
emapVerArr[ciId].dataVerCheckCIAndTMC = dsuStaticHeadStru.pCIStruStru[i].dwVersionOfCIToTMC;
/*与相邻联锁数据校验信息*/
/*与相邻CI联锁数据校验信息*/
emapVerArr[ciId].chAdjoinCICount = dsuStaticHeadStru.pCIStruStru[i].dwAdjoinCICount;
for (jj = 0U; jj < CI_TRAINSMIT_CI_MAX_NUM; jj++)
{
@@ -3489,6 +3488,17 @@ void ReadEmapCiConfig(EmapCiConfigStru emapVerArr[])
emapVerArr[ciId].dwAdjoinCIShareCheckData[jj] = dsuStaticHeadStru.pCIStruStru[i].dwAdjoinCIShareCheckData[jj];
}
/*与相邻RC联锁数据校验信息*/
emapVerArr[ciId].chAdjoinRCCount = dsuStaticHeadStru.pCIStruStru[i].dwAdjoinRCCount;
for (jj = 0U; jj < CI_TRAINSMIT_CI_MAX_NUM; jj++)
{
emapVerArr[ciId].wAdjoinRCId[jj] = dsuStaticHeadStru.pCIStruStru[i].dwAdjoinRCId[jj];
emapVerArr[ciId].dwAdjoinRCShareCheckData[jj] = dsuStaticHeadStru.pCIStruStru[i].dwAdjoinRCShareCheckData[jj];
}
/*与本控区RC/CI校验信息*/
emapVerArr[ciId].dwLocalShareCheckData = dsuStaticHeadStru.pCIStruStru[i].dwLocalShareCheckData;
for (jj = 0U; jj < CI_TRAINSMIT_AXIS_MAX_NUM; jj++)
{
emapVerArr[ciId].ciTransmitAxisId[jj] = dsuStaticHeadStru.pCIStruStru[i].dwCIToAxleID[jj];
@@ -3503,6 +3513,69 @@ void ReadEmapCiConfig(EmapCiConfigStru emapVerArr[])
emapVerArr[ciId].dwAdjoinOcShareCheckData[jj] = dsuStaticHeadStru.pCIStruStru[i].dwAdjoinOcShareCheckData[jj];
}
}
else
{
; /*RC模式校验数据信息根据RC表初始化*/
}
}
if (RC_WORK_MODE_TIOC == CI_SYSTEM_TYPE_RCI)
{
wRCStruSum = dsuDataLenStru.wRCLen;
for (i = 0u; i < wRCStruSum; i++)
{
/*并非所有联锁均包含在RC表，因此未配置在RC表中时根据CI表初始化*/
ciId = (UINT8)(dsuStaticHeadStru.pRCStruStru[i].wID & 0x00FF);
emapVerArr[ciId].devId = ciId;
emapVerArr[ciId].ciType = (UINT8)(dsuStaticHeadStru.pRCStruStru[i].wType);
if (CI_TYPE_TCC == dsuStaticHeadStru.pRCStruStru[i].wType)
{
emapVerArr[ciId].ciType = CI_TYPE_CLD;
}
emapVerArr[ciId].dataVerCheckCIAndVOBC = dsuStaticHeadStru.pRCStruStru[i].dwVersionOfCIToVOBC;
emapVerArr[ciId].dataVerCheckCIAndZC = dsuStaticHeadStru.pRCStruStru[i].dwVersionOfCIToZC;
emapVerArr[ciId].dataVerCheckCIAndATS = dsuStaticHeadStru.pRCStruStru[i].dwVersionOfCIToATS;
emapVerArr[ciId].dataVerCheckCIAndTMC = dsuStaticHeadStru.pRCStruStru[i].dwVersionOfCIToTMC;
/*与相邻CI联锁数据校验信息*/
emapVerArr[ciId].chAdjoinCICount = dsuStaticHeadStru.pRCStruStru[i].dwAdjoinCICount;
for (jj = 0U; jj < CI_TRAINSMIT_CI_MAX_NUM; jj++)
{
emapVerArr[ciId].wAdjoinCIId[jj] = dsuStaticHeadStru.pRCStruStru[i].dwAdjoinCIId[jj];
emapVerArr[ciId].dwAdjoinCIShareCheckData[jj] = dsuStaticHeadStru.pRCStruStru[i].dwAdjoinCIShareCheckData[jj];
}
/*与相邻RC联锁数据校验信息*/
emapVerArr[ciId].chAdjoinRCCount = dsuStaticHeadStru.pRCStruStru[i].dwAdjoinRCCount;
for (jj = 0U; jj < CI_TRAINSMIT_CI_MAX_NUM; jj++)
{
emapVerArr[ciId].wAdjoinRCId[jj] = dsuStaticHeadStru.pRCStruStru[i].dwAdjoinRCId[jj];
emapVerArr[ciId].dwAdjoinRCShareCheckData[jj] = dsuStaticHeadStru.pRCStruStru[i].dwAdjoinRCShareCheckData[jj];
}
/*与本控区RC/CI校验信息*/
emapVerArr[ciId].dwLocalShareCheckData = dsuStaticHeadStru.pRCStruStru[i].dwLocalShareCheckData;
/*与计轴系统校验信息*/
for (jj = 0U; jj < CI_TRAINSMIT_AXIS_MAX_NUM; jj++)
{
emapVerArr[ciId].ciTransmitAxisId[jj] = dsuStaticHeadStru.pRCStruStru[i].dwCIToAxleID[jj];
emapVerArr[ciId].ciTransmitAxisCheckData[jj] = dsuStaticHeadStru.pRCStruStru[i].dwCIToAxleShareCheckData[jj];
}
/*与OC系统数据校验信息*/
emapVerArr[ciId].chAdjoinOcCount = dsuStaticHeadStru.pRCStruStru[i].chAdjoinOcCount;
for (jj = 0U; jj < CI_TRAINSMIT_OC_MAX_NUM; jj++)
{
emapVerArr[ciId].wAdjoinOcId[jj] = dsuStaticHeadStru.pRCStruStru[i].wAdjoinOcId[jj];
emapVerArr[ciId].dwAdjoinOcShareCheckData[jj] = dsuStaticHeadStru.pRCStruStru[i].dwAdjoinOcShareCheckData[jj];
}
}
}
else
{
; /*已初始化*/
}
}
}
@@ -3569,7 +3642,7 @@ UINT8 dquDevName2HlhtId(const UINT16 LocalDevName, const UINT16 logId, UINT32 *p
UINT8 retVal = CI_ERROR; /*函数返回值*/
UINT8 retOfQueryDevId = 0u; /*查询函数返回值*/
UINT32 hlhtId = 0u; /*互联互通ID*/
UINT32 szHlhtIdBuf[2] = {0u, 0u}; /*VOBC或ITE的互联互通ID数组*/
UINT32 szHlhtIdBuf[2] = {0u, 0u};
UINT32 dwIdIndex = 0u; /*索引*/
UINT8 devType = 0u; /*设备类型*/
UINT8 devId = 0u; /*设备ID*/
@@ -3590,8 +3663,19 @@ UINT8 dquDevName2HlhtId(const UINT16 LocalDevName, const UINT16 logId, UINT32 *p
case DEVTYPE_CI:
retOfQueryDevId = dquQueryOutDevId(QFUN_IDMAP_CI_ID, devId, &hlhtId);
break;
case DEVTYPE_RC:
retOfQueryDevId = dquQueryOutDevId(QFUN_IDMAP_RC_ID, devId, &hlhtId);
break;
case DEVTYPE_VOBC:
case DEVTYPE_IVOC:
if (DEVTYPE_VOBC == devType)
{
retOfQueryDevId = dquQueryOutVobcDevId(devId, szHlhtIdBuf);
}
else
{
retOfQueryDevId = dquQueryOutIvocDevId(devId, szHlhtIdBuf);
}
switch(logId)
{
@@ -3612,7 +3696,21 @@ UINT8 dquDevName2HlhtId(const UINT16 LocalDevName, const UINT16 logId, UINT32 *p
retOfQueryDevId = dquQueryOutDevId(IDMAP_DSU_ID, devId, &hlhtId);
break;
case DEVTYPE_AXLE:
retOfQueryDevId = dquQueryOutDevId(IDMAP_AXLE_ID, devId, &hlhtId);
retOfQueryDevId = dquQueryOutAxleDevId(devId, szHlhtIdBuf);
switch (logId)
{
case 1U:
dwIdIndex = 0U;
break;
case 2U:
dwIdIndex = 1U;
break;
default:
dwIdIndex = 0U;
break;
}
hlhtId = szHlhtIdBuf[dwIdIndex];
break;
break;
case DEVTYPE_ITE:
retOfQueryDevId = dquQueryOutIteDevId((UINT16)devId, szHlhtIdBuf);
@@ -3671,21 +3769,14 @@ UINT8 dquHlhtId2VobcName(IN UINT32 EtcsId, OUT UINT16 *pDevName, OUT UINT16 *pEn
UINT8 ret = 0U;
UINT8 endId = 0U;
UINT16 index = 0U;
RSSP2_DEVICE_TYPE type = DEVICE_TYPE_UNKNOWN;
UINT8 type = 0U;
if ((NULL != pDevName) && (NULL != pEndId))
{
*pDevName = 0;
*pEndId = 0;
ret = 1;
}
else
{
ret = 0;
}
*pDevName = 0U;
*pEndId = 0U;
ret = 1U;
if (1U == ret)
{
endId = GET_VOBC_END_ID(EtcsId);
switch (endId)
{
@@ -3702,40 +3793,63 @@ UINT8 dquHlhtId2VobcName(IN UINT32 EtcsId, OUT UINT16 *pDevName, OUT UINT16 *pEn
*pEndId = VOBC_ENDID_REDUN;
break;
default:
ret = 0;
ret = 0U;
break;
}
}
(void)GetEtcsTypeFromEtcsId(EtcsId, &type);
if ((DEVICE_TYPE_ATP != type) && (DEVICE_TYPE_AOM != type))
{
ret = 0;
}
if (1U == ret)
{
if (DEVICE_TYPE_ATP == type)
type = (UINT8)((EtcsId / 256U / 256U / 256U) & 0x1FU); /*将互联互通ID转为设备类型*/
if ((HLHT_DEVTYPE_VOBC == type) || (HLHT_DEVTYPE_IVOC == type) || (HLHT_DEVTYPE_AOM == type))
{
if (HLHT_DEVTYPE_VOBC == type)
{
ret = dquQueryVobcDevLgId2Index(EtcsId, ETCSID_MASK, &index, pEndId);
}
else if (HLHT_DEVTYPE_IVOC == type)
{
ret = dquQueryIvocDevLgId2Index(EtcsId, ETCSID_MASK, &index, pEndId);
}
else
{
ret = dquQueryAOMDevBits2Index(EtcsId, ETCSID_MASK, &index);
}
}
if (1U == ret)
{
if (DEVICE_TYPE_ATP == type)
if (HLHT_DEVTYPE_VOBC == type)
{
*pDevName = DEVTYPE_VOBC * 256U + index;
}
else if (HLHT_DEVTYPE_IVOC == type)
{
*pDevName = DEVTYPE_IVOC * 256U + index;
}
else
{
*pDevName = DEVTYPE_AOM * 256U + index;
}
}
else
{
ret = 0U;
}
}
else
{
ret = 0U;
}
}
else
{
ret = 0U;
}
}
else
{
ret = 0U;
}
return ret;
}
@@ -4054,8 +4168,7 @@ UINT8 dquQueryVobcDevLgId2Index(UINT32 devId, UINT32 bitMask, UINT16 *pInDevInde
for (index = 0U; index < DataCount; index++)
{
pwVobcDevId = dquGetVobcDevIdArray(index);
if (((devId&bitMask) == (pwVobcDevId[0] & bitMask))
)
if ((devId & bitMask) == (pwVobcDevId[0] & bitMask))
{
*pInDevIndex = dquGetVobcIndex(index);
*wLogicId = 1U;
@@ -4089,6 +4202,64 @@ UINT8 dquQueryVobcDevLgId2Index(UINT32 devId, UINT32 bitMask, UINT16 *pInDevInde
return bRetVal;
}
/**************************************************
* 函数功能：取Ivoc设备编号相应位数，查询Ivoc索引
* 参数说明：UINT32 devId 互联互通编号
* UINT32 bitMask 位数
* UINT16* pInDevIndex 索引位置（出参）
* UINT16* wLogicId 逻辑ID（出参）
* 返 回 值：0-失败
* 1-成功
* Created By LQ 2025.08.28
***************************************************/
UINT8 dquQueryIvocDevLgId2Index(UINT32 devId, UINT32 bitMask, UINT16* pInDevIndex, UINT16* wLogicId)
{
UINT8 bRetVal = 0U;
UINT16 index = 0U;
UINT16 DataCount = 0U;
UINT32* pwVobcDevId = NULL;
UINT16 tempCount = 0U;/*查找到符合条件的设备索引值个数，找到的个数应为1，否则查找失败*/
if ((NULL != pInDevIndex) && (NULL != wLogicId))
{
DataCount = dquGetIvocNumLen();
for (index = 0U; index < DataCount; index++)
{
pwVobcDevId = dquGetIvocDevIdArray(index);
if ((devId & bitMask) == (pwVobcDevId[0] & bitMask))
{
*pInDevIndex = dquGetIvocIndex(index);
*wLogicId = 1U;
tempCount++;
}
else if ((devId & bitMask) == (pwVobcDevId[1] & bitMask))
{
*pInDevIndex = dquGetIvocIndex(index);
*wLogicId = 2U;
tempCount++;
}
else
{
/*无操作*/
}
}
if (1U == tempCount)
{
bRetVal = 1U;
}
else
{
;
}
}
else
{
;
}
return bRetVal;
}
/*
* 功能描述： CRC32函数，计算过程如下，注意：计算CRC是从输入数据第一个字节的最高BIT开始的
* 采用的多项式0x4c10db7L，初始值为0x00000000,未镜像，结果异或系数为0x00000000
@@ -4279,10 +4450,18 @@ INT16 ReadEaConfigData(EaConfigStru* pEaConfigAddr)
*********************************************/
UINT8 GetWLScreenTypeById(const UINT8 ciId)
{
UINT8 cRetVal = TIOC_WLSCTEEN_VALID;
cRetVal = dsuStaticHeadStru.pCIStruStru[dsuCIIndex[ciId]].cWLScreenType;
UINT8 cRetVal = TIOC_WLSCTEEN_UNVALID;
UINT16 wRCStruSum = 0U;
UINT16 i = 0U;
wRCStruSum = dsuDataLenStru.wRCLen;
for (i = 0u; i < wRCStruSum; i++)
{
if ((UINT16)ciId == (0x00FF &dsuStaticHeadStru.pRCStruStru[i].wID))
{
cRetVal = dsuStaticHeadStru.pRCStruStru[i].cWLScreenType;
break;
}
}
return cRetVal;
}
@@ -4632,3 +4811,49 @@ UINT8 ReadPhySecIndexInAxle(const UINT8 chLocalCiId, PhysicalSectionConfigDataSt
return chReval;
}
/*
* 功能描述：计算轨道区段所属LINK
* 参数说明：void
* 返回值 ：CI_SUCCESS,成功
* CI_ERROR,失败
*/
UINT16 QueryTrackBelongLink(void)
{
UINT16 i = 0u;
UINT16 j = 0u;
UINT16 wLinkId = 0u;
UINT16 phySec = 0u;
UINT8 chSysType = 0U;
UINT32 trackSecId = 0U;
UINT16 sum = 0u;
UINT8 retVal = CI_ERROR;
retVal = CI_SUCCESS;
for (i = 0u; i < dsuIdmapStru.dsuIdmapLenStru->wTrackSecNumLen; i++)
{
for (j = 0u; j < dsuIdmapStru.dsuStaticIdmapStru->pTrackSecNumStru[i].wTrackNum; j++)
{
trackSecId = dsuIdmapStru.dsuStaticIdmapStru->pTrackSecNumStru[i].dwTrackSecId[j];
if (0u!= trackSecId)
{
if (TRCAK_SECTION_SUM_MAX > sum)
{
gTrackSecConfigDataStru[sum].trackSecId = trackSecId;
gTrackSecConfigDataStru[sum].linkId = dsuIdmapStru.dsuStaticIdmapStru->pTrackSecNumStru[i].wLinkId;
sum++;
}
else
{
retVal = CI_ERROR;
break;
}
}
}
}
gTrackSectionCurSum = sum;
return retVal;
}
TSCP/src/APP/ciapp/QueryFiles/dquCIInterFace.h
+19 -1
View File
@@ -434,6 +434,18 @@ UINT8 dquHlhtId2VobcName(IN UINT32 EtcsId, OUT UINT16 *pDevName, OUT UINT16 *pEn
***************************************************/
UINT8 dquQueryVobcDevLgId2Index(UINT32 devId, UINT32 bitMask, UINT16 *pInDevIndex, UINT16 *wLogicId);
/**************************************************
* 函数功能：取Ivoc设备编号相应位数，查询Ivoc索引
* 参数说明：UINT32 devId 互联互通编号
* UINT32 bitMask 位数
* UINT16* pInDevIndex 索引位置（出参）
* UINT16* wLogicId 逻辑ID（出参）
* 返 回 值：0-失败
* 1-成功
* Created By LQ 2025.08.28
***************************************************/
UINT8 dquQueryIvocDevLgId2Index(UINT32 devId, UINT32 bitMask, UINT16* pInDevIndex, UINT16* wLogicId);
/*
* 功能描述： CRC32函数，计算过程如下，注意：计算CRC是从输入数据第一个字节的最高BIT开始的
* 采用的多项式0x4c10db7L，初始值为0x00000000,未镜像，结果异或系数为0x00000000
@@ -506,7 +518,13 @@ UINT8 EnsureNearAxleStorageLineAtrr(const UINT16 wAxleId);
* BY CGH 20250418
*/
UINT8 ReadPhySecIndexInAxle(const UINT8 chLocalCiId, PhysicalSectionConfigDataStruct* pPhysicalSectionConfigDataStru);
/*
* 功能描述：计算轨道区段所属LINK
* 参数说明：void
* 返回值 ：CI_SUCCESS,成功
* CI_ERROR,失败
*/
UINT16 QueryTrackBelongLink(void);
#ifdef __cplusplus
}
#endif
TSCP/src/APP/ciapp/QueryFiles/dquCIJDQStruFrmChar.c
+137 -3
View File
@@ -52,7 +52,7 @@ UINT8 RelayConfigDataStruFromChar(UINT8 * pDataAddr,RelayConfigDataStruct* pRela
{
/*所属OC ID (配置字段)*/
OcIdBuff = dquCiShortFromChar(pData);
pRelayCfgDtStr->BelongCiId = (UINT8)(GetCiIdByOcId(OcIdBuff));
pRelayCfgDtStr->BelongCiId = GetCiIdByOcId(OcIdBuff);
pRelayCfgDtStr->BelongOcId = OcIdBuff;
pRelayCfgDtStr->BelongDrvOcId = pRelayCfgDtStr->BelongOcId;
pRelayCfgDtStr->BelongVirCIid = GetOCBelongVirCIid((UINT8)OcIdBuff);
@@ -223,6 +223,8 @@ UINT8 R_ScreenStructFromChar(UINT8 * pDataAddr,Relay_ScreenStruct* pScrnStr, UIN
}
pScrnStr->wRelayCloseDoorId = dquCiShortFromChar(pData); /*关门继电器ID */
pData += 2u;
pScrnStr->wRelayThreeEditGroupOpenDoorId = dquCiShortFromChar(pData); /*3编组开门继电器ID */
pData += 2u;
pScrnStr->wRelayFourEditGroupOpenDoorId = dquCiShortFromChar(pData); /*4编组开门继电器ID */
pData += 2u;
pScrnStr->wRelaySixEditGroupOpenDoorId = dquCiShortFromChar(pData); /*6编组开门继电器ID */
@@ -233,6 +235,126 @@ UINT8 R_ScreenStructFromChar(UINT8 * pDataAddr,Relay_ScreenStruct* pScrnStr, UIN
pData += 2u;
pScrnStr->doorReopenRelayId = dquCiShortFromChar(pData); /*站台门再次开门继电器ID*/
pData += 2u;
pScrnStr->doorReopenRelayId2 = dquCiShortFromChar(pData); /*站台门再次开门继电器ID2*/
pData += 2u;
pScrnStr->departureConfirmRelayId = dquCiShortFromChar(pData); /*发车确认继电器ID*/
pData += 2u;
pScrnStr->detectStartRelayId = dquCiShortFromChar(pData); /*启动探测继电器ID*/
pData += 2u;
pScrnStr->detectStopRelayId = dquCiShortFromChar(pData); /*停止探测继电器ID*/
pData += 2u;
pScrnStr->obstacleRelayId = dquCiShortFromChar(pData); /*障碍物继电器ID*/
pData += 2u;
pScrnStr->gapDetMuLockRelayId = dquCiShortFromChar(pData); /*间隙探测互锁解除继电器ID*/
pData += 2u;
pScrnStr->closeStateRelayId = dquCiShortFromChar(pData); /*关门状态继电器ID*/
pData += 2u;
if (40U < rowLen)
{
pScrnStr->wClearPasseSteadyLightRelayId = dquCiShortFromChar(pData); /*清客确认按钮指示灯稳灯继电器ID*/
pData += 2u;
pScrnStr->wClearPasseFlashLightRelayId = dquCiShortFromChar(pData); /*清客确认按钮指示灯闪灯继电器ID*/
pData += 2u;
pScrnStr->wClearPassengerButtonRelayId = dquCiShortFromChar(pData); /*清客确认按钮继电器ID*/
pData += 2u;
}
if (46U < rowLen)
{
pScrnStr->wCleFarePCBButtonRelayId = dquCiShortFromChar(pData); /*清客确认箱PCB按钮继电器*/
pData += 2u;
pScrnStr->wCleFarePDBFlaLigRelayId = dquCiShortFromChar(pData); /*清客确认箱PDB按钮指示灯闪灯继电器*/
pData += 2u;
}
if (50U < rowLen)
{
pScrnStr->wPobBsdRelayId = dquCiShortFromChar(pData); /*站台再开门按钮指示灯继电器*/
pData += 2u;
pScrnStr->wPcbBsdRelayId = dquCiShortFromChar(pData); /*站台再关门按钮指示灯继电器*/
pData += 2u;
}
if (54U < rowLen)
{
pScrnStr->wVideoQkLight1RelayId = dquCiShortFromChar(pData); /*清客按钮箱视频清客指示灯1（绿）继电器*/
pData += 2U;
pScrnStr->wVideoQkLight2RelayId = dquCiShortFromChar(pData); /*清客按钮箱视频清客指示灯2（红）继电器*/
pData += 2U;
}
if (58U < rowLen)
{
pScrnStr->chControlType = *pData; /*屏蔽门控制类型*/
pData += 1U;
}
else
{/*若没有这一列配置*/
pScrnStr->chControlType = PSD_CONTROL_TYPE_RCI; /*由RCI控制*/
}
rtnvalue = 1u;
}
return rtnvalue;
}
/*********************************************
*函数功能：从数据到屏蔽门继电器结构体
*参数说明：pDataAddr数据地址， pScrnStr屏蔽门继电器配置数据结构体指针,UINT16 rowLen 一行数据的长度
*返回值：0，失败；1，成功
*********************************************/
UINT8 R_ScreenStructFromCharT(UINT8* pDataAddr, Relay_ScreenStruct* pScrnStr, UINT16 rowLen)
{
UINT8* pData = pDataAddr;
UINT8 rtnvalue = 0u;
UINT8 localCiPattern = 0u; /*本CI模式*/
if ((NULL == pDataAddr) || (NULL == pScrnStr))
{
rtnvalue = 0u;
}
else
{
localCiPattern = GetLocalCiPattern();
pScrnStr->wScreenId = dquCiShortFromChar(pData); /*屏蔽门ID (配置字段)*/
pData += 2u;
if (CI_PATTERN_FULL_ELECTRONIC == localCiPattern)
{
pScrnStr->wOcId = dquCiShortFromChar(pData); /*OC ID*/
pData += 2u;
}
pScrnStr->wRelayRelatedId = dquCiShortFromChar(pData); /*互锁解除继电器ID */
pData += 2u;
if (CI_PATTERN_FULL_ELECTRONIC == localCiPattern)
{
pScrnStr->wRelayRelatedId2 = dquCiShortFromChar(pData); /*互锁解除继电器ID2 */
pData += 2;
}
pScrnStr->wRelayDoorClosedId = dquCiShortFromChar(pData); /*门关继电器ID */
pData += 2u;
if (CI_PATTERN_FULL_ELECTRONIC == localCiPattern)
{
pScrnStr->wRelayDoorClosedId2 = dquCiShortFromChar(pData); /*门关继电器ID2 */
pData += 2;
}
pScrnStr->wRelayCloseDoorId = dquCiShortFromChar(pData); /*关门继电器ID */
pData += 2u;
pScrnStr->wRelayFourEditGroupOpenDoorId = dquCiShortFromChar(pData); /*4编组开门继电器ID */
pData += 2u;
pScrnStr->wRelaySixEditGroupOpenDoorId = dquCiShortFromChar(pData); /*6编组开门继电器ID */
pData += 2u;
pScrnStr->wRelayEightEditGroupOpenDoorId = dquCiShortFromChar(pData); /*8编组开门继电器ID */
pData += 2u;
pScrnStr->wRelayDoorButtonId = dquCiShortFromChar(pData); /*PSD按钮继电器*/
pData += 2u;
pScrnStr->doorReopenRelayId = dquCiShortFromChar(pData); /*站台门再次开门继电器ID*/
pData += 2u;
pScrnStr->departureConfirmRelayId = dquCiShortFromChar(pData); /*发车确认继电器ID*/
pData += 2u;
pScrnStr->detectStartRelayId = dquCiShortFromChar(pData); /*启动探测继电器ID*/
@@ -675,7 +797,7 @@ UINT8 R_BaoJingDengStruFromChar(UINT8 * pDataAddr,Relay_BaoJingDengStruct* pBjdS
if (CI_PATTERN_FULL_ELECTRONIC == localCiPattern)
{
OCid = pBjdStr->wBelongCiId;/*对应全电子联锁，读取到的是OCid*/
pBjdStr->wBelongCiId = GetCiIdByOcId(pBjdStr->wBelongCiId);/*找到0Cid对应联锁id*/
pBjdStr->wBelongCiId = (UINT16)GetCiIdByOcId(pBjdStr->wBelongCiId);/*找到0Cid对应联锁id*/
if(FUNC_SWITCH_ON == includeVirFlag)
{
pBjdStr->wBelongVirCIid = GetOCBelongVirCIid((UINT8)OCid);/*找到0Cid对应虚拟联锁id*/
@@ -828,6 +950,18 @@ UINT8 R_SpksDataFromChar(UINT8 * pDataAddr,RelaySpksStruct* pSpksStr, UINT16 rea
pSpksStr->outsideRelayId = dquCiShortFromChar(pData); /*室外SPKS指示灯继电器*/
pData += 2u;
if (14U < realRowLen)
{
pSpksStr->buzzRelayId = dquCiShortFromChar(pData); /*蜂鸣继电器*/
pData += 2u;
pSpksStr->cutBuzzRelayId = dquCiShortFromChar(pData); /*切除蜂鸣继电器*/
pData += 2u;
}
else
{
;/*对未配置的数据做兼容*/
}
}
else if (CI_PATTERN_TRADITIONAL == localCiPattern)
@@ -1102,7 +1236,7 @@ UINT8 R_OCIndicStruFromChar(UINT8* pDataAddr, OCStationIndicConfigDataStru* pInd
pData += 2; /*ID*/
ocid = dquCiShortFromChar(pData); /*所属ID*/
pData += 2;
belongCiId = (UINT8)GetCiIdByOcId(ocid);
belongCiId = GetCiIdByOcId(ocid);
if (localCiId == belongCiId)
{
TSCP/src/APP/ciapp/QueryFiles/dquCIJDQStruFrmChar.h
+6
View File
@@ -36,6 +36,12 @@ UINT8 R_EmegencyStopStructFromChar(UINT8 * pDataAddr,Relay_EmgcyStpStruct* pEmgc
*返回值：0，失败；1，成功
*********************************************/
UINT8 R_ScreenStructFromChar(UINT8* pDataAddr, Relay_ScreenStruct* pScrnStr, UINT16 rowLen);
/*********************************************
*函数功能：从数据到屏蔽门继电器结构体
*参数说明：pDataAddr数据地址， pScrnStr屏蔽门继电器配置数据结构体指针,UINT16 rowLen 一行数据的长度
*返回值：0，失败；1，成功
*********************************************/
UINT8 R_ScreenStructFromCharT(UINT8* pDataAddr, Relay_ScreenStruct* pScrnStr, UINT16 rowLen);
/*********************************************
*函数功能：从数据到物理区段继电器结构体
TSCP/src/APP/ciapp/QueryFiles/dquCIJDQStruInit.c
+33 -20
View File
@@ -348,18 +348,19 @@ UINT8 InitRelay_ScreenStru(CHAR* CIDataName)
UINT32 DataSize = 0U; /*数据大小（字节数）*/
UINT16 j = 0U;
UINT16 wRealRowCount = 0U;
UINT8 rtnValue = 0u;
UINT32 excelId = 0u; /*excel id*/
UINT32 sheetId = 0u; /*sheet id*/
UINT32 rowLen = 0u; /*行长度*/
UINT8 localCiPattern = 0u; /*本CI模式*/
UINT8 rtnValue = 0U;
UINT32 excelId = 0U; /*excel id*/
UINT32 sheetId = 0U; /*sheet id*/
UINT32 rowLen = 0U; /*行长度*/
UINT8 localCiPattern = 0U; /*本CI模式*/
UINT8 chOcPattern = 0U;
/*已经初始化了，不用老是调用执行过程*/
if (RelayData.pRelayScreenStr != NULL)
{
rtnValue = 1u;
return rtnValue;
rtnValue = 1U; /*已初始化，直接返回1*/
}
else
{
localCiPattern = GetLocalCiPattern();
if (CI_PATTERN_TRADITIONAL == localCiPattern)
{
@@ -373,19 +374,17 @@ UINT8 InitRelay_ScreenStru(CHAR* CIDataName)
}
/*读取 默认行车序列 数据*/
funcRtn = dquGetConfigDataNew(CIDataName, excelId, sheetId, &pDataAddr, &DataSize, &wRealRowCount);
if (funcRtn == 0u)
if (funcRtn == 0U)
{
/*函数调用失败*/
rtnValue = 0u;
rtnValue = 0U;
}
else
{
rtnValue = 1u;
}
if (1U == rtnValue)
{/*求得个数*/
if (DataSize%wRealRowCount != 0u)
rtnValue = 1U;
if ((0U != DataSize) && (0U != wRealRowCount))
{
if (DataSize % wRealRowCount != 0U)
{
debug_infor_printf((const)"\nCI_RELAY_DATA,SCREEN_RELAY len %d not equal to fs", rowLen);
DebugPrintAppError(ERROR_fs_columns_len_not_equal_to_ci_software, CI_DEVICE_TYPE_FS_TABLE, (excelId << 8) + sheetId, PRINT_ONCE);
@@ -395,8 +394,6 @@ UINT8 InitRelay_ScreenStru(CHAR* CIDataName)
{
; /*不处理*/
}
}
if (1U == rtnValue)
{
RelayDataLen.RelayScreenStrLen = wRealRowCount;
@@ -413,8 +410,8 @@ UINT8 InitRelay_ScreenStru(CHAR* CIDataName)
/*动态申请空间失败*/
if (NULL == RelayData.pRelayScreenStr)
{
RelayDataLen.RelayScreenStrLen = 0u;
rtnValue = 0u;
RelayDataLen.RelayScreenStrLen = 0U;
rtnValue = 0U;
}
else
{
@@ -426,7 +423,16 @@ UINT8 InitRelay_ScreenStru(CHAR* CIDataName)
pScreenStr = RelayData.pRelayScreenStr + j;
/*填充数据结构体*/
chOcPattern = GetLocalOcPattern();
if(DATA_TYPE_NEW == chOcPattern)
{
rtnValue &= R_ScreenStructFromChar(pDataAddr, pScreenStr, (UINT16)rowLen);
}
else
{
rtnValue &= R_ScreenStructFromCharT(pDataAddr, pScreenStr, (UINT16)rowLen);
}
pDataAddr += rowLen;
}
@@ -437,6 +443,13 @@ UINT8 InitRelay_ScreenStru(CHAR* CIDataName)
{
; /*不处理*/
}
}
else
{
rtnValue = 1U; /*无真实PSD，直接返回1*/
}
}
}
return rtnValue;
}
TSCP/src/APP/ciapp/QueryFiles/dquCILSStru.h
+8 -1
View File
@@ -67,7 +67,7 @@
#define OTHER_CI_DATA_LEN ((UINT8)42)
#define ROUTE_DATA_ID ((UINT32)1) /*CI联锁表 -- 进路表*/
#define ROUTE_DATA_LEN ((UINT32)53) /*51:增加不为接近时是否延时解锁 +2 CBTC开放需开放*/
#define ROUTE_DATA_LEN ((UINT32)55) /*51:增加不为接近时是否延时解锁 +2 CBTC开放需开放 +2*/
#define OVERLAP_LOCK_COND_DATA_ID ((UINT8)16) /*CI联锁表 -- 保护区段锁闭条件表*/
#define OVERLAP_LOCK_COND_DATA_LEN ((UINT8)44)/*保护区段锁闭条件表新增一列：防护道岔组IDUDE2*/
@@ -96,6 +96,10 @@
#define TRANSROUTE_ZHEFANSIG_ID ((UINT8)27) /*CI联锁表 -- 转换轨进路折返信号机id表*/
#define SideProtecGroup_ID ((UINT8)28) /*CI联锁表 -- 侧防条件组表ID*/
#define SideProtec_ID ((UINT8)29) /*CI联锁表 -- 侧防条件表ID*/
#define CONTACT_DATA_LEN ((UINT8)12U)
/*单轨使用*/
@@ -312,6 +316,8 @@ typedef struct S_RouteStruct
UINT16 wBLCKOtherCIID; /*点式级别其他联锁ID*/
UINT16 wFloodGateIdBuf[ROUTE_MAX_FLOOD_GATE_NUM]; /*防淹门*/
UINT8 wNeedDelayUnlock; /*进路人解、取消需要延时解锁*/
UINT16 wSidePretecGroupID; /*侧防条件组ID*/
} LS_RouteStruct;
/*全自动折返进路表数据结构体*/
typedef struct S_AllAutoRtnRouteStruct
@@ -333,6 +339,7 @@ typedef struct S_OverlapLockCondStruct
UINT16 szIncludeFloodGateId[ROUTE_MAX_FLOOD_GATE_NUM]; /*包含防淹门ID*/
UINT16 wOverlapThisZhaoChaRelayId; /*保护区段本端照查继电器ID*/
UINT16 wOverlapThatZhaoChaRelayId; /*保护区段对端照查继电器ID*/
UINT16 wSidePretectGroupId; /*保护区段侧防条件组ID*/
} LS_OveralpLockCondStru;
/*进路内多开道岔数据结构体*/
TSCP/src/APP/ciapp/QueryFiles/dquCILSStruFrmChar.c
+178
View File
@@ -12,6 +12,8 @@
************************************************************************/
#include "dquCILSStruFrmChar.h"
#include "dquCIReadCommonChar.h"
#include "dquCIInit.h"
/*********************************************
*函数功能：从数据到长进路表转换
*参数说明：pDataAddr数据地址， pLongRouteStr长进路数据结构体指针
@@ -637,6 +639,11 @@ UINT8 LS_RouteStruFromChar(UINT8 * pDataAddr,LS_RouteStruct* pRouteStr)
pRouteStr->wNeedDelayUnlock = *pData;
pData++;
pRouteStr->wSidePretecGroupID = dquCiShortFromChar(pData);
pData += 2u;
rtnvalue = 1u;
return rtnvalue;
}
@@ -741,6 +748,10 @@ UINT8 LS_OverlapLockCondStruFromChar(UINT8 * pDataAddr, LS_OveralpLockCondStru *
pOverlapLockCondStru->wOverlapThatZhaoChaRelayId = dquCiShortFromChar(pData);
pData += LS_DATA_DUAL_BYTE_ELEM_LEN;
/*保护区段侧防条件组ID*/
pOverlapLockCondStru->wSidePretectGroupId = dquCiShortFromChar(pData);
pData += LS_DATA_DUAL_BYTE_ELEM_LEN;
rtnvalue = 1u;
}
return rtnvalue;
@@ -1066,3 +1077,170 @@ UINT8 LS_TransZFSigFromChar(UINT8* pDataAddr, LS_TransRouteZFSigStruct* pTransRo
}
return rtnvalue;
}
/*********************************************
* 函数功能：侧防条件组表行读取
* 参数说明：pDataAddr数据地址，
* pSideProtecGroupStru 侧防条件组表
* 返回值：0，失败；1，成功
*创建 ：fan
*********************************************/
UINT8 LS_read_SideProtecGroupData(UINT8* pDataAddr, SideProtecGroupStru* pSideProtecGroupStru)
{
UINT8* pData = pDataAddr;
UINT16 i = 0u;
UINT8 rtnvalue = 0u;
UINT8 j = 0u;
UINT8 flag = 0u;
if ((NULL == pDataAddr) || (NULL == pSideProtecGroupStru))
{
rtnvalue = 0u;
}
else
{
rtnvalue = 1u;
pSideProtecGroupStru->GroupID = dquCiShortFromChar(pData);
pData += 2u;
for (j = 0u; j < SIDE_PROTECT_NUM_MAX; j++)
{
pSideProtecGroupStru->RouteSideProtecBuf[j].SideProtecID = dquCiShortFromChar(pData);
pData += 2u;
if ((0u < pSideProtecGroupStru->RouteSideProtecBuf[j].SideProtecID) && (UINT16_MAX > pSideProtecGroupStru->RouteSideProtecBuf[j].SideProtecID))
{
if (1u == flag)
{/*读到过无效值，再次出现有效值则失败*/
rtnvalue = 0u;
break;
}
else
{
pSideProtecGroupStru->RouteSideProtecNum++;
}
}
else
{
flag = 1u;
}
}
}
return rtnvalue;
}
/*********************************************
* 函数功能：侧防条件组表行读取
* 参数说明：pDataAddr数据地址，
* pSideProtecStru 侧防条件表
* 返回值：0，失败；1，成功
*创建 ：fan
*********************************************/
UINT8 LS_read_SideProtecData(UINT8* pDataAddr, SideProtecStru* pSideProtecStru)
{
UINT8* pData = pDataAddr;
UINT8 rtnvalue = 0u;
UINT8 j = 0u;
UINT8 flag = 0u;
if ((NULL == pDataAddr) || (NULL == pSideProtecStru))
{
rtnvalue = 0u;
}
else
{
rtnvalue = 1u;
pSideProtecStru->SideProtecID = dquCiShortFromChar(pData);
pData += 2u;
pSideProtecStru->KeysSwitchID = dquCiShortFromChar(pData);
pData += 2u;
pSideProtecStru->KeysSwicthPos =*pData;
pData ++;
pSideProtecStru->SideProtecSignalID = dquCiShortFromChar(pData);
pData += 2u;
for (j = 0u; j < SIDE_PROTECT_SWITCH_NUM_MAX; j++)
{
pSideProtecStru->SideProtecSwitchBuf[j].SideProtecSwitchID = dquCiShortFromChar(pData);
pData += 2u;
pSideProtecStru->SideProtecSwitchBuf[j].SideProtecSwitchPos = *pData;
pData++;
if ((0u < pSideProtecStru->SideProtecSwitchBuf[j].SideProtecSwitchID) && (UINT16_MAX > pSideProtecStru->SideProtecSwitchBuf[j].SideProtecSwitchID))
{
if (1u == flag)
{/*读到过无效值，再次出现有效值则失败*/
rtnvalue = 0u;
break;
}
else
{
pSideProtecStru->SideProtecSwitchNum++;
}
}
else
{
flag = 1u;
}
}
if (0u == rtnvalue)
{
;/*已经失败了，就不需要遍历后续的了*/
}
else
{
flag = 0u;
for (j = 0u; j < SIDE_PROTECT_PHYSEC_NUM_MAX; j++)
{
pSideProtecStru->SideProtecPhyBuf[j].SideProtecPhySecID = dquCiShortFromChar(pData);
pData += 2u;
pSideProtecStru->SideProtecPhyBuf[j].SideProtecDirect = *pData;
pData++;
if ((0u < pSideProtecStru->SideProtecPhyBuf[j].SideProtecPhySecID) && (UINT16_MAX > pSideProtecStru->SideProtecPhyBuf[j].SideProtecPhySecID))
{
if ((CI_SYSTEM_DIRECTION_DOWN == pSideProtecStru->SideProtecPhyBuf[j].SideProtecDirect)
|| (CI_SYSTEM_DIRECTION_UP == pSideProtecStru->SideProtecPhyBuf[j].SideProtecDirect))
{
if (pSideProtecStru->SideProtecPhyBuf[j].SideProtecDirect == dquCICfgDtStr.SystemParaStrNew.LinkLogicDirUpAndDown)
{
pSideProtecStru->SideProtecPhyBuf[j].SideProtecDirect = CI_SYSTEM_DIRECTION_DOWN;
}
else
{
pSideProtecStru->SideProtecPhyBuf[j].SideProtecDirect = CI_SYSTEM_DIRECTION_UP;
}
}
else
{
flag = 1u;
}
if (1u == flag)
{/*读到过无效值，再次出现有效值则失败*/
rtnvalue = 0u;
break;
}
else
{
pSideProtecStru->SideProtecPhyNum++;
}
}
else
{
flag = 1u;
}
}
}
}
return rtnvalue;
}
TSCP/src/APP/ciapp/QueryFiles/dquCILSStruFrmChar.h
+16
View File
@@ -201,5 +201,21 @@ UINT8 LS_LgcSecInvEachStruFromChar(UINT8* pDataAddr, LS_EachLgcIntrudeStruct* pL
*创建 ：fan
*********************************************/
UINT8 LS_TransZFSigFromChar(UINT8* pDataAddr, LS_TransRouteZFSigStruct* pTransRouteZFSigStru);
/*********************************************
* 函数功能：侧防条件组表行读取
* 参数说明：pDataAddr数据地址，
* pSideProtecGroupStru 侧防条件组表
* 返回值：0，失败；1，成功
*创建 ：fan
*********************************************/
UINT8 LS_read_SideProtecGroupData(UINT8* pDataAddr, SideProtecGroupStru* pSideProtecGroupStru);
/*********************************************
* 函数功能：侧防条件组表行读取
* 参数说明：pDataAddr数据地址，
* pSideProtecStru 侧防条件表
* 返回值：0，失败；1，成功
*创建 ：fan
*********************************************/
UINT8 LS_read_SideProtecData(UINT8* pDataAddr, SideProtecStru* pSideProtecStru);
#endif
TSCP/src/APP/ciapp/QueryFiles/dquCILSStruInit.c
+281 -1
View File
@@ -1574,7 +1574,7 @@ UINT8 InitLS_OverlapLockCondStru(CHAR *LSDataName)
{
if (0U != DataSize % rowLen)
{
debug_infor_printf((const)"\nCI_LS_DATA,OVERLAP_LOCK_COND len %d not equal to fs", PHYSICAL_INTRU_DATA_LEN);
debug_infor_printf((const)"\nCI_LS_DATA,OVERLAP_LOCK_COND len %d not equal to fs", OVERLAP_LOCK_COND_DATA_ID);
DebugPrintAppError(ERROR_fs_columns_len_not_equal_to_ci_software, CI_DEVICE_TYPE_FS_TABLE, (LS_DATA_TYPE << 8) + OVERLAP_LOCK_COND_DATA_ID, PRINT_ONCE);
rtnValue = 0u;
}
@@ -2360,3 +2360,283 @@ UINT8 InitLS_TransRouteRtnDataStruct(CHAR* LSDataName)
}
return rtnValue;
}
/*********************************************
* 函数功能：初始化侧防条件
* 参数说明：LSDataName指针
* 返回值：0，失败；1，成功
*********************************************/
UINT8 InitLSSideProtec(CHAR* LSDataName)
{
UINT8 rtnValue = 0U;
UINT16 i = 0U;
UINT8 j = 0U;
UINT16 k = 0U;
UINT16 wRouteSideProtecNum = 0U;
UINT16 wSideProtecID = 0U;
if (NULL != LSDataName)
{
/*首先初始化侧防条件组表*/
rtnValue = InitLS_SideProtecGroupStru(LSDataName);
}
else
{
/*返回失败*/
}
/*再初始化侧防条件表*/
if (1U == rtnValue)
{
rtnValue = InitLS_SideProtecStru(LSDataName);
}
else
{
/*返回失败*/
}
/*根据ID为侧防道岔组表匹配侧防条件*/
if (1U == rtnValue)
{
for (i = 0u; i < LSDataLen.LSSideProtecGroupStruLen; i++)/*遍历侧防条件组表*/
{
wRouteSideProtecNum = LSData.pLSSideProtecGroupStru[i].RouteSideProtecNum;
for (j = 0u; j < wRouteSideProtecNum; j++)/*遍历每个侧防条件*/
{
wSideProtecID = LSData.pLSSideProtecGroupStru[i].RouteSideProtecBuf[j].SideProtecID;
if (0u < wSideProtecID)/*侧防条件组表中的侧防条件ID大于0*/
{
for (k = 0u; k < LSDataLen.LSRouteSideProtecStruLen; k++)
{
if (wSideProtecID == LSData.pLSRouteSideProtecStru[k].SideProtecID)
{
CommonMemCpy(&LSData.pLSSideProtecGroupStru[i].RouteSideProtecBuf[j], sizeof(SideProtecStru), &LSData.pLSRouteSideProtecStru[k], sizeof(SideProtecStru));
break;/*找到则跳出*/
}
else
{
/*继续遍历*/
}
}
if (k == LSDataLen.LSRouteSideProtecStruLen)
{
rtnValue = 0u;
}
}
else
{
break;
}
}
}
}
else
{
/*返回失败*/
}
return rtnValue;
}
/*********************************************
* 函数功能：初始化侧防条件组表
* 参数说明：LSDataName指针
* 返回值：0，失败；1，成功
*********************************************/
UINT8 InitLS_SideProtecGroupStru(CHAR* LSDataName)
{
UINT8 funcRtn = 0U;
SideProtecGroupStru* pSideProtecGroupStru = NULL; /*侧防条件组表*/
UINT8* pDataAddr = NULL; /*数据地址*/
UINT32 DataSize = 0U; /*数据大小（字节数）*/
UINT16 i = 0U;
UINT16 realRowCount = 0U; /*实际表数据的行数*/
UINT16 realRowLen = 0U; /*实际表数据的一行的长度*/
UINT8 rtnValue = 0U;
/*已经初始化了，不用老是调用执行过程*/
if (NULL != LSData.pLSSideProtecGroupStru)
{
rtnValue = 1U;
}
else
{
rtnValue = 1U;
/*读取侧防条件组表数据*/
funcRtn = dquGetConfigDataNew(LSDataName, LS_DATA_TYPE, SideProtecGroup_ID, &pDataAddr, &DataSize, &realRowCount);
if (0U == funcRtn)
{
/*函数调用失败*/
rtnValue = 0U;
debug_infor_printf((const)"\n SideProtecGroup_ID_TABLE NO IN FS\n");
}
else
{
if ((0U != DataSize) && (0U != realRowCount))
{
if (0U != (DataSize % realRowCount))
{
debug_infor_printf((const)"\nTIOC_LS_DATA,SideProtecGroup_ID_TABLE len %d %d not equal to fs\n", DataSize, realRowCount);
DebugPrintAppError(ERROR_fs_columns_len_not_equal_to_ci_software, CI_DEVICE_TYPE_FS_TABLE, (LS_DATA_TYPE << 8U) + SideProtecGroup_ID, PRINT_ONCE);
rtnValue = 0U;
}
else
{
/*数据实际一行的数据字节长度*/
realRowLen = (UINT16)(DataSize / realRowCount);
LSDataLen.LSSideProtecGroupStruLen = realRowCount;
/*动态申请空间*/
LSData.pLSSideProtecGroupStru = (SideProtecGroupStru*)MyNew((UINT32)(sizeof(SideProtecGroupStru) * LSDataLen.LSSideProtecGroupStruLen));
if (NULL == LSData.pLSSideProtecGroupStru)
{
LSDataLen.LSSideProtecGroupStruLen = 0U; /*动态申请空间失败，返回0*/
rtnValue = 0U;
}
else
{
/*内存先设为无效*/
(void)CommonMemSet(LSData.pLSSideProtecGroupStru, sizeof(SideProtecGroupStru) * LSDataLen.LSSideProtecGroupStruLen, 0U, sizeof(SideProtecGroupStru) * LSDataLen.LSSideProtecGroupStruLen);
/*解析数据到进路侧防条件结构体数组 */
for (i = 0U; i < LSDataLen.LSSideProtecGroupStruLen; i++)
{
pSideProtecGroupStru = LSData.pLSSideProtecGroupStru + i;
/*填充数据结构体*/
rtnValue = LS_read_SideProtecGroupData(pDataAddr, pSideProtecGroupStru);
pDataAddr += realRowLen;
if (0U == rtnValue)
{
debug_infor_printf((const)"\nRead SideProtecGroup_ID_TABLE Error: Error RowCount %d\n ", (i + 1U));
break;
}
else
{
/*继续读取*/
}
}
}
}
}
else
{
debug_infor_printf((const)"\SideProtecGroup_ID_TABLE_ERR DataSize %d realRowCount %d\n ", DataSize, realRowCount);
}
}
}
return rtnValue;
}
/*********************************************
* 函数功能：初始化侧防条件表
* 参数说明：LSDataName指针
* 返回值：0，失败；1，成功
*********************************************/
UINT8 InitLS_SideProtecStru(CHAR* LSDataName)
{
UINT8 funcRtn = 0U;
SideProtecStru* pSideProtecStru = NULL; /*侧防条件表*/
UINT8* pDataAddr = NULL; /*数据地址*/
UINT32 DataSize = 0U; /*数据大小（字节数）*/
UINT16 i = 0U;
UINT16 realRowCount = 0U; /*实际表数据的行数*/
UINT16 realRowLen = 0U; /*实际表数据的一行的长度*/
UINT8 rtnValue = 0U;
/*已经初始化了，不用老是调用执行过程*/
if (NULL != LSData.pLSRouteSideProtecStru)
{
rtnValue = 1U;
}
else
{
rtnValue = 1U;
/*读取侧防条件组表数据*/
funcRtn = dquGetConfigDataNew(LSDataName, LS_DATA_TYPE, SideProtec_ID, &pDataAddr, &DataSize, &realRowCount);
if (0U == funcRtn)
{
/*函数调用失败*/
rtnValue = 0U;
debug_infor_printf((const)"\n SideProtec_ID_TABLE NO IN FS\n");
}
else
{
if ((0U != DataSize) && (0U != realRowCount))
{
if (0U != (DataSize % realRowCount))
{
debug_infor_printf((const)"\nTIOC_LS_DATA,SideProtec_ID_TABLE len %d %d not equal to fs\n", DataSize, realRowCount);
DebugPrintAppError(ERROR_fs_columns_len_not_equal_to_ci_software, CI_DEVICE_TYPE_FS_TABLE, (LS_DATA_TYPE << 8U) + SideProtec_ID, PRINT_ONCE);
rtnValue = 0U;
}
else
{
/*数据实际一行的数据字节长度*/
realRowLen = (UINT16)(DataSize / realRowCount);
LSDataLen.LSRouteSideProtecStruLen = realRowCount;
/*动态申请空间*/
LSData.pLSRouteSideProtecStru = (SideProtecStru*)MyNew((UINT32)(sizeof(SideProtecStru) * LSDataLen.LSRouteSideProtecStruLen));
if (NULL == LSData.pLSRouteSideProtecStru)
{
LSDataLen.LSRouteSideProtecStruLen = 0U; /*动态申请空间失败，返回0*/
rtnValue = 0U;
}
else
{
/*内存先设为无效*/
(void)CommonMemSet(LSData.pLSRouteSideProtecStru, sizeof(SideProtecStru) * LSDataLen.LSRouteSideProtecStruLen, 0U, sizeof(SideProtecStru) * LSDataLen.LSRouteSideProtecStruLen);
/*解析数据到转换轨进路折返信号机id结构体数组 */
for (i = 0U; i < LSDataLen.LSRouteSideProtecStruLen; i++)
{
pSideProtecStru = LSData.pLSRouteSideProtecStru + i;
/*填充数据结构体*/
rtnValue = LS_read_SideProtecData(pDataAddr, pSideProtecStru);
pDataAddr += realRowLen;
if (0U == rtnValue)
{
debug_infor_printf((const)"\nRead SideProtec_ID_TABLE Error: Error RowCount %d\n ", (i + 1U));
break;
}
else
{
/*继续读取*/
}
}
}
}
}
else
{
debug_infor_printf((const)"\SideProtec_ID_TABLE_ERR DataSize %d realRowCount %d\n ", DataSize, realRowCount);
}
}
}
return rtnValue;
}
/*********************************************
* 函数功能：获取侧防条件数
* 参数说明：void
* 返回值：侧防条件数
*********************************************/
UINT16 GetLSSideProtecStruLen(void)
{
return LSDataLen.LSRouteSideProtecStruLen;
}
/*********************************************
* 函数功能：获取侧防条件
* 参数说明：void
* 返回值：侧防条件
*********************************************/
const SideProtecStru* GetLSSideProtecData(void)
{
return LSData.pLSRouteSideProtecStru;
}
TSCP/src/APP/ciapp/QueryFiles/dquCILSStruInit.h
+35
View File
@@ -44,6 +44,8 @@ typedef struct S_LSDataStruct
LS_ContactLineStruct* pLSContactLineStr; /*逻辑区段关联联络线设备检查条件结构体*/
LS_EachLgcIntrudeStruct* pLSLgcInvEachStru;/*逻辑区段互相侵限表*/
LS_TransRouteZFSigStruct* pLSTransRouteZFSigStru; /*转换轨折返信号机结构体*/
SideProtecGroupStru* pLSSideProtecGroupStru; /*进路侧防条件组表结构体*/
SideProtecStru* pLSRouteSideProtecStru;/*进路侧防条件表初始化*/
}LSDataStruct;
/*联锁数据结构*/
typedef struct S_LSDataStructLen
@@ -75,6 +77,8 @@ typedef struct S_LSDataStructLen
UINT16 LSContactStruLen; /*逻辑区段关联联络线设备检查条件表长度*/
UINT16 LSLgcInvEachLen; /*逻辑区段互相侵限条件表长度*/
UINT16 LSTransRouteZFSigStruLen; /*转换轨折返信号机表长度*/
UINT16 LSSideProtecGroupStruLen;/*侧防条件组表长度*/
UINT16 LSRouteSideProtecStruLen;/*侧防条件表长度*/
}LSDataStructLen;
/*********定义全局的联锁信息数据变量*******/
@@ -262,5 +266,36 @@ UINT8 InitLS_ContactConfigDataStruct(CHAR* LSDataName);
*********************************************/
UINT8 InitLS_TransRouteRtnDataStruct(CHAR* LSDataName);
/*********************************************
* 函数功能：初始化侧防条件
* 参数说明：LSDataName指针
* 返回值：0，失败；1，成功
*********************************************/
UINT8 InitLSSideProtec(CHAR* LSDataName);
/*********************************************
* 函数功能：初始化侧防条件表
* 参数说明：LSDataName指针
* 返回值：0，失败；1，成功
*********************************************/
UINT8 InitLS_SideProtecStru(CHAR* LSDataName);
/*********************************************
* 函数功能：初始化侧防条件组表
* 参数说明：LSDataName指针
* 返回值：0，失败；1，成功
*********************************************/
UINT8 InitLS_SideProtecGroupStru(CHAR* LSDataName);
/*********************************************
* 函数功能：获取侧防条件数
* 参数说明：void
* 返回值：侧防条件数
*********************************************/
UINT16 GetLSSideProtecStruLen(void);
/*********************************************
* 函数功能：获取侧防条件
* 参数说明：void
* 返回值：侧防条件
*********************************************/
const SideProtecStru* GetLSSideProtecData(void);
#endif
TSCP/src/APP/ciapp/QueryFiles/dquMaskInit.c
+710 -138
View File
File diff suppressed because it is too large Load Diff
TSCP/src/APP/ciapp/QueryFiles/dquMaskInit.h
+18 -3
View File
@@ -35,7 +35,7 @@
/*定义CI-ZC码位表单ID*/
#define CI_ZC_MASK_TYPE ((UINT32)0xB3)
#define CI_ZC_SWITCH_MASK_ID ((UINT32)1) /*CI-ZC道岔码位*/
#define CI_ZC_SWITCH_MASK_LEN ((UINT32)10) /*CI-ZC道岔码位字节长度--1行长度*/
#define CI_ZC_SWITCH_MASK_LEN ((UINT32)12) /*CI-ZC道岔码位字节长度--1行长度*/
#define CI_ZC_SIGNAL_MASK_ID ((UINT32)2) /*CI-ZC信号机码位*/
#define CI_ZC_SIGNAL_MASK_LEN ((UINT32)16) /*CI-ZC信号机码位字节长度--1行长度*/
@@ -47,10 +47,10 @@
#define CI_ZC_ESB_MASK_LEN ((UINT32)6) /*CI-ZC屏紧急停车按钮码位字节长度--1行长度*/
#define CI_ZC_LOGIC_SGMT_MASK_ID ((UINT32)6) /*CI-ZC逻辑区段码位*/
#define CI_ZC_LOGIC_SGMT_MASK_LEN ((UINT32)18) /*CI-ZC逻辑区段码位字节长度--1行长度*/
#define CI_ZC_LOGIC_SGMT_MASK_LEN ((UINT32)20) /*CI-ZC逻辑区段码位字节长度--1行长度*/
#define CI_ZC_ROUTE_MASK_ID ((UINT32)7) /*CI-ZC进路码位*/
#define CI_ZC_ROUTE_MASK_LEN ((UINT32)10) /*CI-ZC进路码位字节长度--1行长度*/
#define CI_ZC_ROUTE_MASK_LEN ((UINT32)14) /*CI-ZC进路码位字节长度--1行长度*/
#define CI_ZC_AXLE_SGMT_MASK_ID ((UINT32)5) /*CI-ZC计轴区段码位*/
#define CI_ZC_AXLE_SGMT_MASK_LEN ((UINT32)26) /*CI-ZC计轴区段码位字节长度--1行长度，Modified 20151015*/
@@ -180,6 +180,12 @@ UINT8 MaskCfgDtStruFrmCIATSEsbMask(UINT8 * FSDataName);
*********************************************/
UINT8 MaskCfgDtStruFrmCIATSLogSgmt(UINT8 * FSDataName);
/*********************************************
*函数功能：CI-ATS逻辑区段码位-杭德
*参数说明：FSDataName件指针
*返回值：0，失败；1，成功
*********************************************/
UINT8 MaskCfgDtStruFrmCIATSLogSgmtT(UINT8* FSDataName);
/*********************************************
*函数功能：CI-ATS进路码位
*参数说明：FSDataName件指针
*返回值：0，失败；1，成功
@@ -448,5 +454,14 @@ UINT8 MaskCfgStruFrmZCCIAxleSgmtMask2(UINT8 * FSDataName);
*返回值：0，失败；1，成功
*********************************************/
UINT8 MaskCfgStruFrmCIZCAxleSgmtMask2(UINT8 * FSDataName);
/*****
******CI到ZC码位表解析
********/
/*********************************************
*函数功能：CI-ZC道岔码位
*参数说明：FSDataName件指针
*返回值：0，失败；1，成功
*********************************************/
UINT8 MaskCfgDtStruFrmCIZCSwitchMask2(UINT8* FSDataName);
#endif

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