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

[9.6] 9.6首版一回代码，基线版本

Browse Source
This commit is contained in:
lh
2026-05-22 15:25:38 +08:00
parent 1765e65e49
commit 147c6223fe
275 changed files with 63864 additions and 19340 deletions
Download Patch File Download Diff File Expand all files Collapse all files
TSCP/src/APP/APP_API.c
+252 -126
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,11 +230,65 @@ 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)
/*文件配置*/
STRU_APP_CFG_T AppCfgInterface = {
/*若为真机，则通过平台获取设备类型*/
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文件名称 */
.APP_NAME = "RCOCI", /**< 应用文件名称 */
.CYC_TIME = 300, /**< 系统周期 */
@@ -246,109 +306,28 @@ void APP_API_Data_Init()
.reboot_replycount = 10, /**< 重启确认报文回复次数 */
.M_AutoReboot_Count = 3, /**< 自动重启次数 */
.M_AutoClear_Days = 1, /**< 连续运行多久清空宕机次数的天数 */
.M_Area_Enable = 0, /**< 区域状态开关配置 */
#if 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 */
.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, /**< 暗文日志记录发送端口 */
#else
.M_Area_Enable = 0xAA, /**< CI/RC标识 0x55为CI 0xAA为RC */
.CPU[0].IP_2oo2 = "192.168.0.31", /**< 2oo2通信IP */
.CPU[0].IP_2x2 = "192.168.1.63", /**< 2x2通信IP */
.CPU[0].IP_Out = "192.168.1.63", /**< 外网通信IP */
.CPU[0].IP_Maintain = "192.168.146.105", /**< 维护通信IP */
/*适用透传通道-选配*/
.CPU[0].IP_Com = "192.168.1.63", /**< 通用通信IP */
.CPU[0].IP_Com_Extend = "192.168.1.63",/**< 通用通信扩展IP */
.CPU[0].Logger_PortBase = 55011, /**< 明文日志记录发送端口 */
.CPU[0].Logger_PortCiphertext = 55002, /**< 暗文日志记录发送端口 */
.CPU[1].IP_2oo2 = "192.168.0.32", /**< 2oo2通信IP */
.CPU[1].IP_2x2 = "192.168.2.63", /**< 2x2通信IP */
.CPU[1].IP_Out = "192.168.2.63", /**< 外网通信IP */
.CPU[1].IP_Maintain = "192.168.18.106", /**< 维护通信IP */
/*适用透传通道-选配*/
.CPU[1].IP_Com = "192.168.2.63", /**< 通用通信IP */
.CPU[1].IP_Com_Extend = "192.168.2.63",/**< 通用通信扩展IP */
.CPU[1].Logger_PortBase = 55012, /**< 明文日志记录发送端口 */
.CPU[1].Logger_PortCiphertext = 55002, /**< 暗文日志记录发送端口 */
.CPU[2].IP_2oo2 = "192.168.0.41", /**< 2oo2通信IP */
.CPU[2].IP_2x2 = "192.168.1.65", /**< 2x2通信IP */
.CPU[2].IP_Out = "192.168.1.65", /**< 外网通信IP */
.CPU[2].IP_Maintain = "192.168.146.107", /**< 维护通信IP */
/*适用透传通道-选配*/
.CPU[2].IP_Com = "192.168.1.65", /**< 通用通信IP */
.CPU[2].IP_Com_Extend = "192.168.1.65",/**< 通用通信扩展IP */
.CPU[2].Logger_PortBase = 55021, /**< 明文日志记录发送端口 */
.CPU[2].Logger_PortCiphertext = 55002, /**< 暗文日志记录发送端口 */
.CPU[3].IP_2oo2 = "192.168.0.42", /**< 2oo2通信IP */
.CPU[3].IP_2x2 = "192.168.2.65", /**< 2x2通信IP */
.CPU[3].IP_Out = "192.168.2.65", /**< 外网通信IP */
.CPU[3].IP_Maintain = "192.168.18.108", /**< 维护通信IP */
/*适用透传通道-选配*/
.CPU[3].IP_Com = "192.168.2.65", /**< 通用通信IP */
.CPU[3].IP_Com_Extend = "192.168.2.65",/**< 通用通信扩展IP */
.CPU[3].Logger_PortBase = 55022, /**< 明文日志记录发送端口 */
.CPU[3].Logger_PortCiphertext = 55002, /**< 暗文日志记录发送端口 */
/*CPU1*/
.AREA_CPU[0].IP_Area_A = "192.168.1.62", /**< 另一插箱A系CPU1的2x2IP */
.AREA_CPU[0].IP_Area_B = "192.168.1.64", /**< 另一插箱B系CPU1的2x2IP */
.AREA_CPU[0].IP_Multicast_Mine = "239.0.0.21", /**< 本插箱CPU1所在广播域 */
.AREA_CPU[0].IP_Multicast_Dest = "239.0.0.11", /**< 另一插箱CPU1所在广播域 */
/*CPU2*/
.AREA_CPU[1].IP_Area_A = "192.168.2.62", /**< 另一插箱A系CPU2的2x2IP */
.AREA_CPU[1].IP_Area_B = "192.168.2.64", /**< 另一插箱B系CPU2的2x2IP */
.AREA_CPU[1].IP_Multicast_Mine = "239.0.0.22", /**< 本插箱CPU2所在广播域 */
.AREA_CPU[1].IP_Multicast_Dest = "239.0.0.12", /**< 另一插箱CPU2所在广播域 */
#endif
/*通用端口配置*/
/*通用端口配置*/
.Port_Outnet_Safe = 54001, /**< 外网安全通信端口 */
.Port_Innet_Safe = 53001, /**< 内网安全通信端口 */
.Port_Outnet_Raw = 54002, /**< 外网透明传输端口 */
// .Port_Log_Base = 55001, /**< 明文日志记录发送端口 */
// .Port_Log_Ciphertext = 55002, /**< 暗文日志记录发送端口 */
.Port_Remote_Update = 50000, /**< 远程部署通信端口 */
/*透传配置-选配*/
/*透传配置-选配*/
.Port_Innet_Raw_Num = 0, /**< 内网透传端口数量 */
.Port_Innet_Raw_Extend_Num = 0, /**< 内网透传扩展端口数量 */
.Innet_Raw_Parameter[0].Port_Innet_Raw = 3956, /**< 内网透明传输端口 */
@@ -366,7 +345,7 @@ void APP_API_Data_Init()
.Innet_Raw_Parameter[1].INNET_2oo2_RAW = 0X55, /**< 透传通道2取开关 */
.Innet_Raw_Parameter[1].INNET_2x2_RAW = 0XAA, /**< 透传通道2乘开关 */
.Innet_Raw_Parameter[1].IP_InnetRaw_maddr = "224.0.0.32",/**< 内网透传的组播IP */
/*外网通信配置*/
/*外网通信配置*/
.OutNetRed.CC_G_IP = "192.168.1.60", /**< 通控的内网IP */
.OutNetRed.CC_P_IP = "192.168.2.60", /**< 通控的内网IP */
.OutNetRed.EXTEND_G_IP = "192.168.1.70", /**< 扩展板卡的内网IP */
@@ -382,43 +361,183 @@ 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 */
// .Logger_PortBase = 55001, /**< 明文日志记录端口 */
// .Logger_PortCiphertext = 55002,
/*内网通信设备注册最大支持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, /**< 紫网安全端口 */
};
MSCP_Set_APP_ConfigData(&AppCfgInterface);
};
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版本号*/
ii = 0U;
fsVersBuffer[ii++] = szFSFILEVersionFS[0];
fsVersBuffer[ii++] = szFSFILEVersionFS[1];
fsVersBuffer[ii++] = szFSFILEVersionFS[2];
fsVersBuffer[ii++] = szFSFILEVersionFS[3];
/*组FS版本号*/
ii = 0U;
fsVersBuffer[ii++] = szFSFILEVersionFS[0];
fsVersBuffer[ii++] = szFSFILEVersionFS[1];
fsVersBuffer[ii++] = szFSFILEVersionFS[2];
fsVersBuffer[ii++] = szFSFILEVersionFS[3];
/*组软件版本号*/
ii = 0U;
appVersBuffer[ii++] = VER_SOFT_PRODUCT;
appVersBuffer[ii++] = VER_SOFT_MODUAL_APP >> 2U;
appVersBuffer[ii++] = (VER_SOFT_MODUAL_APP << 6U) + (VER_SOFT_MIANVERSION & (UINT8)0x3F);
appVersBuffer[ii++] = VER_SOFT_SUBVERSION;
/*设置平台调用获取外网信息函数*/
MSCP_SetSrcId(SetOutNetPara);
/*设置内网参数*/
MSCP_SetSfpInnetPara(g_SfpInnetParam);
MSCP_SetAppVersion(appVersBuffer);
MSCP_SetFsVersion(fsVersBuffer);
/*组软件版本号*/
ii = 0U;
appVersBuffer[ii++] = VER_INTE_PROJECT;
appVersBuffer[ii++] = VER_INTE_PRODUCT >> 2U;
appVersBuffer[ii++] = (VER_INTE_PRODUCT << 6U) + (VER_INTE_EXE & (UINT8)0x3F);
appVersBuffer[ii++] = VER_INTE_TIME;
/*设置平台调用获取外网信息函数*/
MSCP_SetSrcId(SetOutNetPara);
/*设置内网参数*/
MSCP_SetSfpInnetPara(g_SfpInnetParam);
MSCP_SetAppVersion(appVersBuffer);
MSCP_SetFsVersion(fsVersBuffer);
}
}
/**
* @brief 应用周期主逻辑
@@ -435,7 +554,7 @@ void APP_API_Data_Init()
*/
ENUM_CM_RETURN APP_API_MainFunc(void)
{
ENUM_CM_RETURN retVal = ENUM_CM_FALSE;
ENUM_CM_RETURN retVal = ENUM_CM_NULL;
CM_UINT64 startCycTick = 0u;
CM_UINT64 endCycTick = 0u;
@@ -456,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;
}
@@ -596,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)))
{
@@ -619,6 +741,10 @@ ENUM_CM_RECCUSEB Is_Send_ExtendBoard(IN const CM_UINT16 dstDevTypeId)
{
retVal = ENUM_CM_SEB;
}
else if (CI_SYSTEM_TYPE_ITE == devType)
{
retVal = ENUM_CM_CCSEB;
}
else
{
retVal = ENUM_CM_CC;
@@ -680,8 +806,8 @@ void SetOutNetPara(UINT8* pRxBuf, UINT32 dwLen, ENUM_OUTNET_CHN_T chOutNetType,
tempLen = *pCurLen;
if ((TRANSMIT_OBJECT_SUM_MAX * TRANSMIT_OBJECT_DEVICE_SUM_MAX) > (tempLen + objLen))
{
CommonMemCpy(&pOutBuf[tempLen], objLen * sizeof(UINT16), \
gTransmitObjTypeId, objLen * sizeof(UINT16));
CommonMemCpy((void*)&pOutBuf[tempLen], objLen * sizeof(UINT16), \
(const void*)gTransmitObjTypeId, objLen * sizeof(UINT16));
*pCurLen = tempLen + objLen;
debug_infor_printf("outnet in type len :%d", chOutNetType, objLen);
debug_out_array(0xAA, gTransmitObjTypeId, objLen * sizeof(UINT16));
@@ -815,9 +941,9 @@ ENUM_CM_RETURN SerialOutAtsVobcFunc(UINT16 inDstId IN, UINT16* outSrcId OUT, UIN
UINT8 inDstType = 0U;
inDstType = (UINT8)((inDstId & 0xff00U) >> 8);
if (CI_SYSTEM_TYPE_VOBC_BACKUP == inDstType)
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 77 /*集成次数编号*/
#define VER_INTE_TIME 105 /*集成次数编号*/
#endif/*endif of #define _CI_INTEGRATE_CONFIG_H*/
TSCP/src/APP/ciapp/2oo2/2oo2DataTransferManage.c
+3764 -805
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
+58 -50
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,44 +94,44 @@ 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到协议数据队列*/
FsfbToCiDataQueue = &Fsfb_Info.DataToApp; /*初始化Fsfb到CI数据队列*/
CiToFsfbDataQueue = &Fsfb_Info.OutputDataQueue; /*初始化CI到Fsfb数据队列*/
FsfbToCiDataQueue = &Fsfb_Info.DataToApp; /*初始化Fsfb到CI数据队列*/
CiToFsfbDataQueue = &Fsfb_Info.OutputDataQueue; /*初始化CI到Fsfb数据队列*/
CurCycleNum = &CycleNum; /*初始化平台周期*/
StartCycleNum = MSCP_GetSysCount(); /*上电周期号*/
PlatComputerId = &Computer_Id_Local_File;
PlatRunMode = &processor_mode;
PlatComputerId = &Computer_Id_Local_File;
PlatRunMode = &processor_mode;
IoToCiDataQueue = &canQueueRecv; /*初始化IO到CI数据队列*/
CiToIoDataQueue = &canQueueSend; /*初始化CI到IO数据队列*/
AtsToCiDataQueue = NULL; /*初始化ATS到CI数据队列*/
CiToAtsDataQueue = CiToProtocolDataQueue; /*初始化CI到ATS数据队列*/
CiToAtsDataQueue = CiToProtocolDataQueue; /*初始化CI到ATS数据队列*/
XianDiToCiDataQueue = NULL; /*初始化ATS到CI数据队列*/
XianDiToCiDataQueue = NULL; /*初始化ATS到CI数据队列*/
CiToXianDiDataQueue = CiToProtocolDataQueue; /*初始化CI到ATS数据队列*/
ZcToCiDataQueue = NULL; /*初始化ZC到CI数据队列*/
CiToZcDataQueue = CiToProtocolDataQueue; /*初始化CI到ZC数据队列*/
CiToZcDataQueue = CiToProtocolDataQueue; /*初始化CI到ZC数据队列*/
AxisToCiDataQueue = NULL; /*初始化Axis到CI数据队列*/
CiToAxisDataQueue = CiToProtocolDataQueue; /*初始化CI到Axis数据队列*/
@@ -142,7 +139,7 @@ UINT8 Initial2oo2Interface(void)
CiRecvFromCiDataQueue = NULL; /*初始化CI接受其他CI数据队列*/
CiSendToCiDataQueue = CiToProtocolDataQueue; /*初始化CI发送到其他CI数据队列*/
VobcToCiDataQueue = NULL; /*初始化Vobc到CI数据队列*/
VobcToCiDataQueue = NULL; /*初始化Vobc到CI数据队列*/
CiToVobcDataQueue = CiToProtocolDataQueue; /*初始化CI到Vobc数据队列*/
PlatformToCiDataQueue = NULL; /*初始化Psd到CI数据队列*/
@@ -151,55 +148,66 @@ UINT8 Initial2oo2Interface(void)
PscToCiDataQueue = NULL; /*初始化PSC到CI数据队列*/
CiToPscDataQueue = CiToProtocolDataQueue; /*初始化CI到PSC数据队列*/
LEUToCiDataQueue = NULL; /*初始化Leu到CI数据队列*/
LEUToCiDataQueue = NULL; /*初始化Leu到CI数据队列*/
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);
CiAndIoComState = &FSIOLinkStatusInfo; /*联锁与IO通信状态*/
OcToCiDataQueue = NULL; /*初始化Oc到Ci的数据队列*/
CiToOcDataQueue = CiToProtocolDataQueue; /*初始化Ci到Oc的数据队列*/
if (1U != QueueInitial(&logPrintfQue, 500000U)) /*初始化日志缓存队列*/
if (CI_SUCCESS == rtn)
{
debug_infor_printf((const)"canQueueRecv init error \n");
}
if (1U != QueueInitial(&logPrintfQue, 500000U)) /*初始化日志缓存队列*/
{
debug_infor_printf((const)"canQueueRecv init error \n");
rtn = CI_ERROR;
}
else
{
#if 0
/*联锁与LEU、ZC、CI等的通信状态描述*/
if (TransmitRelaDataCurSum < TRANSMIT_OBJECT_SUM_MAX)
{
for (ii = 0u; ii < TRANSMIT_OBJECT_SUM_MAX; ii++)
{
PlatComStatusStru[ii].SystemType = &(ComDevStatusInfo[ii].DeviceTypeOther);
PlatComStatusStru[ii].SystemNum = &(ComDevStatusInfo[ii].ComDevSum);
for (jj = 0u; jj < TRANSMIT_OBJECT_DEVICE_SUM_MAX; jj++)
{
PlatComStatusStru[ii].SystemIdBuf[jj] = &(ComDevStatusInfo[ii].ComDevIdBuf[jj]);
PlatComStatusStru[ii].CommunicationStatusBuf[jj] = &(ComDevStatusInfo[ii].ComDevIdComStatusBuf[jj]);
}
}
/*联锁与LEU、ZC、CI等的通信状态描述*/
if (TransmitRelaDataCurSum < TRANSMIT_OBJECT_SUM_MAX)
{
for (ii = 0u; ii < TRANSMIT_OBJECT_SUM_MAX; ii++)
{
PlatComStatusStru[ii].SystemType = &(ComDevStatusInfo[ii].DeviceTypeOther);
PlatComStatusStru[ii].SystemNum = &(ComDevStatusInfo[ii].ComDevSum);
for (jj = 0u; jj < TRANSMIT_OBJECT_DEVICE_SUM_MAX; jj++)
{
PlatComStatusStru[ii].SystemIdBuf[jj] = &(ComDevStatusInfo[ii].ComDevIdBuf[jj]);
PlatComStatusStru[ii].CommunicationStatusBuf[jj] = &(ComDevStatusInfo[ii].ComDevIdComStatusBuf[jj]);
}
}
}
else
{
}
else
{
}
}
#endif
#endif
result = HLHTCiIdMapInitial();
if (CI_SUCCESS == result)
result = HLHTCiIdMapInitial();
if (CI_SUCCESS == result)
{
rtn = CI_SUCCESS;
}
else
{
debug_infor_printf((const)"Initial2oo2Interface init error: HLHTCiIdMapInitial Error\n");
rtn = CI_ERROR; /*返回失败*/
}
}
}
else
{
rtn = 1;
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
+6 -3
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);
@@ -386,7 +389,7 @@ void SendOut_LogBuff();
void debug_infor_printf(char* debug_string, ...);
void debug_out_array(UINT8 mode, UINT8* debug_array, UINT16 len);
void DarkInfoPack(UINT16 mode, UINT8* debug_array, UINT16 len);
UINT8 OutnetSafeRecv(UINT16* srcTypeId, UINT16* srcLogicId, UINT8* data, UINT32* dataLen, UINT32 dataMaxLen);
UINT8 InnetSafeRecv(UINT16* srcTypeId, UINT16* srcLogicId, UINT8* data, UINT32* dataLen, UINT32 dataMaxLen);
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/AutoRouteDataManage.c
+10 -4
View File
@@ -107,7 +107,13 @@ void SetAutoRouteSetFlag(const UINT16 autoRouteId, const UINT8 setState)
}
}
/*
* 功能描述：获取自动进路动态数据结构体
* 参数说明：无
* 返 回 值：自动进路动态数据结构体
* Created By LQ 2025.05.26
*/
AutoRouteDataStruct* GetAutoRouteDataStr(void)
{
return AutoRouteDataStru;
}
TSCP/src/APP/ciapp/AutoRoute/AutoRouteDataManage.h
+7 -1
View File
@@ -56,7 +56,13 @@ UINT8 GetAutoRouteSetFlag(const UINT16 autoRouteId);
*/
void SetAutoRouteSetFlag(const UINT16 autoRouteId, const UINT8 setState);
/*
* 功能描述：获取自动进路动态数据结构体
* 参数说明：无
* 返 回 值：自动进路动态数据结构体
* Created By LQ 2025.05.26
*/
AutoRouteDataStruct* GetAutoRouteDataStr(void);
#ifdef __cplusplus
}
TSCP/src/APP/ciapp/AutoRoute/AutoRouteDefine.h
+1 -1
View File
@@ -36,7 +36,7 @@
#define AUTO_ROUTE_DICHU_COMMROUTE ((UINT8)0x06) /*抵触普通进路已办理*/
#define AUTO_ROUTE_HAVE_BLOCK ((UINT8)0x02) /*自动进路存在封锁*/
#define AUTO_ROUTE_FLOOD_STATE_ERR ((UINT8)0x03) /*自动进路存在防淹门不满足*/
#define AUTO_ROUTE_COUPROUTE_SET ((UINT8)0x07) /*联挂进路已办理*/
#endif
TSCP/src/APP/ciapp/AxisAssert/AxisAssertDefine.h
+1
View File
@@ -25,6 +25,7 @@
#define AAM_BAD_NEAR 0x03u /* 坏车接近 */
#define AAM_NO_TRAIN_NEAR 0x04u /* 无车接近 */
#define AAM_GOOD_OCC 0x05u /* 好车占用 */
#define AAM_SLEEP_OCC 0x06u /* 休眠车占用 */
#define AAM_API_AC_ARB 0x01u /* 计轴ARB*/
TSCP/src/APP/ciapp/AxisAssert/AxisAssertManageAPI.c
+245 -117
View File
@@ -53,6 +53,9 @@ static UINT8 aam_SearchNearestTrainInNextAC(UINT16 baseACID, UINT8 Dir, UINT8 en
UINT32 errorCode = 0u;
const EnvelopeStruct* pTempEnvelope = NULL;
ELM_AxisLocStruct tmpAcLoc = { 0u };
UINT8 cSleepState = 0U; /*包络关联列车休眠状态*/
UINT8 ii = 0U;
UINT8 chNoSleepCheck = 0U;
/*- 入口参数校验 */
ASSERT_RET_VALUE(NULL == envelopeIds,ret,0x80000000u);
@@ -103,24 +106,44 @@ static UINT8 aam_SearchNearestTrainInNextAC(UINT16 baseACID, UINT8 Dir, UINT8 en
ASSER_ERROR(CI_ERROR == funRtn,errorCode,0x10000000u);
AAM_LOG_LOC(AAM_LOG_ERROR,"errno:0x%08x info:Search NearestTrain ELM%d,ELM info error.",errorCode,preEnvelope)
}
else if (((TYPE_CT_ENVELOPE == pTempEnvelope->envelopeType) || (TYPE_UCT_ENVELOPE == pTempEnvelope->envelopeType)) &&
(FLAG_SET == funRtn) && (0u == pTempEnvelope->tailTrainID))
{
/** 好车远离 */
ret = AAM_GOOD_FAR_AWAY;
}
else if (((TYPE_CT_ENVELOPE == pTempEnvelope->envelopeType) || (TYPE_UCT_ENVELOPE == pTempEnvelope->envelopeType)) &&
(FLAG_UNSET == funRtn) && (0u == pTempEnvelope->headTrainID))
{
/** 好车接近 */
ret = AAM_GOOD_NEAR;
}
else
{
/** 坏车接近 */
ret = AAM_BAD_NEAR;
chNoSleepCheck = CI_SUCCESS;
for (ii = 0U; ii < pTempEnvelope->trianCnt; ii++)
{
cSleepState = GetTrainSleepState(pTempEnvelope->trainID[ii]);
if (TRAIN_SLEEP_YES == cSleepState)
{
chNoSleepCheck = CI_ERROR;
break;
}
}
if (CI_ERROR == chNoSleepCheck)
{
/*相邻计轴存在休眠车*/
ret = AAM_SLEEP_OCC;
}
else if (((TYPE_CT_ENVELOPE == pTempEnvelope->envelopeType) || (TYPE_UCT_ENVELOPE == pTempEnvelope->envelopeType)) &&
(FLAG_SET == funRtn) && (0u == pTempEnvelope->tailTrainID))
{
/** 好车远离 */
ret = AAM_GOOD_FAR_AWAY;
}
else if (((TYPE_CT_ENVELOPE == pTempEnvelope->envelopeType) || (TYPE_UCT_ENVELOPE == pTempEnvelope->envelopeType)) &&
(FLAG_UNSET == funRtn) && (0u == pTempEnvelope->headTrainID))
{
/** 好车接近 */
ret = AAM_GOOD_NEAR;
}
else
{
/** 坏车接近 */
ret = AAM_BAD_NEAR;
}
}
}
}
}
@@ -156,8 +179,6 @@ UINT8 aam_SearchNearbyTrainType(UINT16 baseACID, UINT8 Dir, UINT8 acCnt, UINT16
UINT8 acStatus = ELM_AC_OCC;
UINT16 tmpPhyid = 0u;
UINT8 phyRelACCnt = 0u;
UINT8 i = 0U;
UINT16 wTrainId = 0U;
const UINT16* phyRelACIDs = NULL;
const EnvelopeStruct* pTempEnvelope = NULL;
UINT8 acRelEnvelopeCnt = 0u;
@@ -281,30 +302,23 @@ static UINT8 aam_AxisErrorJudge(UINT16 acID,UINT16 acIndex)
UINT8 ret = CI_ERROR;
UINT8 funRtn = CI_ERROR;
UINT8 chNearbyCheck = CI_ERROR;
UINT8 acSameCnt = 0u;
UINT16 acSameID[AC_MAXCNT_IN_SWITCH] = { 0u };
UINT8 acConvertCnt = 0u;
UINT16 acConvertID[AC_MAXCNT_IN_SWITCH] = { 0u };
UINT32 errorCode = 0u;
UINT8 acSameCnt = 0U;
UINT16 acSameID[AC_MAXCNT_IN_SWITCH] = { 0U };
UINT8 acConvertCnt = 0U;
UINT16 acConvertID[AC_MAXCNT_IN_SWITCH] = { 0U };
UINT32 errorCode = 0U;
UINT8 sameTrainType = AAM_BAD_NEAR;
UINT8 convertTrainType = AAM_BAD_NEAR;
UINT8 tmpRedunTime = 0u;
UINT8 tmppassTrainType = 0u;
UINT8 tmpRedunTime = 0U;
UINT8 tmppassTrainType = 0U;
UINT8 tmpACStatus = AAM_STATUS_OCC;
UINT8 maxRedunTimes = 0u;
UINT8 chSwitch = 0u;
UINT8 chSwitch = 0U;
UINT32 dwArbCheckDistance = 0U; /*RC16.0： 系统配置ARB区段向外检查距离*/
UINT8 chRedunArbFlag = REDUN_OVER_ARB_NO; /*判断冗余计时结束后可否ARB标志*/
UINT8 dwCiAndAxleTransBadEnsureCnt = 0U; /*判断与计轴通信中断周期数*/
UINT32 dwCurAxleOccStartCycNum = 0U; /*本计轴区段占用起始周期*/
UINT8 ii = 0U;
UINT32 dwNearAxleOccStartCycNum = 0U; /*相邻计轴区段占用起始周期*/
UINT8 cAcRelEnvelopeCnt = 0U;
EnvelopeStruct strEnvelopeInfo[SECTION_REL_ENVELOPE_SUM_MAX] = { 0U };
UINT8 cOccCheckFlag = CI_ERROR;
UINT16 wCurRelPhySecId = 0U;
UINT16 wNearRelPhySecId = 0U;
UINT8 cAxisCommBadArbFlag = AAM_COMM_BAD_ARB_NO;
UINT8 chPhyTrainCheck = CI_SUCCESS;
UINT8 cAcCbtcAttr = 0U; /*计轴区段CBTC区域属性*/
chSwitch = aam_PrepareArbSwitch();
if (CI_SUCCESS == chSwitch)
@@ -353,6 +367,32 @@ static UINT8 aam_AxisErrorJudge(UINT16 acID,UINT16 acIndex)
/** 处理后方计轴车辆接近 */
convertTrainType = aam_SearchNearbyTrainType(acID, EMAP_CONVER_DIR, acConvertCnt, acConvertID);
/*检查所属物理区段有无故障车*/
chPhyTrainCheck = aam_CheckPhyTrain(acID);
cAcCbtcAttr = GetAxisSecCbtcProperty(acID); /*获取计轴区段CBTC区域属性*/
if ((CI_ERROR == chPhyTrainCheck) || (AXIS_SEC_CBTC_PROPERTY_YES != cAcCbtcAttr))
{
/** 计轴区段有故障车或非CBTC区域，清除之前的冗余计时位，设置占用 */
funRtn = aam_ClearPassTrainFlag(acIndex);
ASSER_ERROR(CI_ERROR == funRtn, errorCode, 0x20000000u);
funRtn = aam_ClearRedunTime(acIndex);
ASSER_ERROR(CI_ERROR == funRtn, errorCode, 0x10000000u);
aam_SetAxisStatus(acIndex, AAM_STATUS_OCC);
AAM_LOG(AAM_LOG_FATAL, "info:AC%d set UT,Physec has UKT\n ", acID);
}
else if ((AAM_SLEEP_OCC == sameTrainType) || (AAM_SLEEP_OCC == convertTrainType))
{
/** 清除好车通过标志，UT冗余 */
funRtn = aam_ClearPassTrainFlag(acIndex);
ASSER_ERROR(CI_ERROR == funRtn, errorCode, 0x20000000u);
}
else
{
; /*继续处理*/
}
/** 判断相邻范围内计轴坏车最近占用时间检查通过 */
if ((CI_ERROR == chNearbyCheck))
{
@@ -410,89 +450,13 @@ static UINT8 aam_AxisErrorJudge(UINT16 acID,UINT16 acIndex)
}
else
{
cOccCheckFlag = CI_SUCCESS;
dwCiAndAxleTransBadEnsureCnt = GetCiAndAxleTransBadEnsureCnt(); /*获取判断与计轴通信中断超时周期数*/
wCurRelPhySecId = GetAxisSecRelativePhySecId(acID);
if (0U != wCurRelPhySecId)
{
dwCurAxleOccStartCycNum = GetSecColOccupyStartCycNum(wCurRelPhySecId);
for (ii = 0U; ii < acSameCnt; ii++)
{
wNearRelPhySecId = GetAxisSecRelativePhySecId(acSameID[ii]);
if (0U != wNearRelPhySecId)
{
cAcRelEnvelopeCnt = elm_GetEnvelopeInAC(acSameID[ii], strEnvelopeInfo);
dwNearAxleOccStartCycNum = GetSecColOccupyStartCycNum(wNearRelPhySecId);
if (((0U == cAcRelEnvelopeCnt) || (SECTION_REL_ENVELOPE_SUM_MAX == cAcRelEnvelopeCnt))
&& ((dwCurAxleOccStartCycNum + dwCiAndAxleTransBadEnsureCnt) < dwNearAxleOccStartCycNum))
{
cOccCheckFlag = CI_ERROR; /*相邻计轴区段无包络且占用起始时间超过了“与计轴通信中断超时判断时间”*/
}
else
{
/*相邻计轴区段占用起始周期未超过“与计轴通信中断超时判断时间”，继续检查*/
}
}
else
{
cOccCheckFlag = CI_ERROR;
}
/*ARB计轴区段同向相邻计轴区段连续占用*/
funRtn = aam_ArbContinuousOccCheck(acID, acSameCnt, acSameID);
if (CI_ERROR == cOccCheckFlag)
{
break;
}
else
{
;
}
}
/*ARB计轴区段反向相邻计轴区段连续占用*/
funRtn &= aam_ArbContinuousOccCheck(acID, acConvertCnt, acConvertID);
if (CI_SUCCESS == cOccCheckFlag)
{
for (ii = 0U; ii < acConvertCnt; ii++)
{
wNearRelPhySecId = GetAxisSecRelativePhySecId(acConvertID[ii]);
if (0U != wNearRelPhySecId)
{
cAcRelEnvelopeCnt = elm_GetEnvelopeInAC(acConvertID[ii], strEnvelopeInfo);
dwNearAxleOccStartCycNum = GetSecColOccupyStartCycNum(wNearRelPhySecId);
if (((0U == cAcRelEnvelopeCnt) || (SECTION_REL_ENVELOPE_SUM_MAX == cAcRelEnvelopeCnt))
&& ((dwCurAxleOccStartCycNum + dwCiAndAxleTransBadEnsureCnt) < dwNearAxleOccStartCycNum))
{
cOccCheckFlag = CI_ERROR; /*相邻计轴区段无包络且占用起始时间超过了“与计轴通信中断超时判断时间”*/
}
else
{
/*相邻计轴区段占用起始周期未超过“与计轴通信中断超时判断时间”，继续检查*/
}
}
else
{
cOccCheckFlag = CI_ERROR;
}
if (CI_ERROR == cOccCheckFlag)
{
break;
}
else
{
;
}
}
}
else
{
/*检查失败，不处理*/
}
}
else
{
cOccCheckFlag = CI_ERROR;
}
if (CI_SUCCESS != cOccCheckFlag)
if (CI_SUCCESS != funRtn)
{
/** 清除本计轴区段之前的冗余计时位 */
funRtn = aam_ClearPassTrainFlag(acIndex);
@@ -502,7 +466,7 @@ static UINT8 aam_AxisErrorJudge(UINT16 acID,UINT16 acIndex)
ASSER_ERROR(CI_ERROR == funRtn, errorCode, 0x00400000U);
aam_SetAxisStatus(acIndex, AAM_STATUS_OCC);
AAM_LOG(AAM_LOG_FATAL, "info:AC%d Keep ARB Fail Because Of Near Sec Occ\n", acID);
AAM_LOG(AAM_LOG_FATAL, "info:AC%d Keep ARB Fail Because Of Near Sec Continuous Occ\n", acID);
}
else
{
@@ -887,9 +851,11 @@ void aam_MainProcess(void)
/** 尽头线ARB特殊处理*/
aam_InitEndLinePassFlag();
/*计轴子系统通信中断ARB特殊处理功能在RC20.0首版二回先注释掉（恢复时间待定）——By LQ 2025.05.07*/
#if 0
/*计轴子系统通信中断ARB特殊处理*/
aam_AxisCommBadArbPro();
#endif
for (cycle = 0u; cycle < acCnt; cycle++)
{
/** 判断计轴区段是否属于本OC */
@@ -2055,3 +2021,165 @@ UINT8 aam_GetAxisStatusAPI(UINT16 ACID)
reVal = aam_GetAxisStatus(acIndex);
return reVal;
}
/**
* 函数功能：检查计轴所在物理区段均无故障车
* 输入参数：UINT16 ACID 计轴区段id
* 返回值：CI_SUCCESS 无故障车
* CI_ERROR 存在故障车
* Create By fan 2025.06 18
*/
UINT8 aam_CheckPhyTrain(UINT16 ACID)
{
UINT8 reVal = CI_ERROR;
UINT16 wPhySecId = 0U; /*计轴所属物理区段*/
UINT8 phyAcNum = 0u; /*物理区段关联计轴数*/
UINT16* pACBuff = NULL;
UINT16 wAxisSecId = 0U; /*计轴区段id*/
UINT8 linkNum = 0U; /*ilnk数量*/
UINT16* pLinkBuf = NULL; /*link数组*/
UINT8 jj = 0U;
UINT8 ii = 0U;
UINT8 k = 0U;
TRAIN_SEQUANCE_s linkInctrainList[SIZE_MAX_TRAINOFAC] = { 0u }; /*link上的列车序列*/
UINT8 cLinkIncTrainSum = 0u; /*link列车数量*/
wPhySecId = aam_PrepareACBelongPhyid(ACID);
phyAcNum = GetPAxisSectionSum(wPhySecId);
pACBuff = GetPAxisSectionIdBuf(wPhySecId);
if ((0U != phyAcNum) && (NULL != pACBuff))
{
reVal = CI_SUCCESS;
for (ii = 0; ii < phyAcNum; ii++)
{
/*检查计轴上link有隐藏车*/
wAxisSecId = pACBuff[ii];
linkNum = GetAxisLinkSum(wAxisSecId);
pLinkBuf = GetAxisLinkIdBuf(wAxisSecId);
if ((0U != linkNum) && (NULL != pLinkBuf))
{
for (jj = 0; jj < linkNum; jj++)
{
cLinkIncTrainSum = as_GetLinkTrainList(pLinkBuf[jj], linkInctrainList, SIZE_MAX_TRAINOFAC);
for (k = 0U; k < cLinkIncTrainSum; k++)
{
if (NAME_FAILUREAREA != linkInctrainList[k].u16TrainID)
{
; /*继续*/
}
else
{
reVal = CI_ERROR; /*存在故障车，停止检查。返回失败*/
break;
}
}
if (CI_ERROR == reVal)
{
break;
}
}
}
else
{
/*获取失败 */
reVal = CI_ERROR;
}
if (CI_ERROR == reVal)
{
break;
}
}
}
else
{
reVal = CI_ERROR;
}
return reVal;
}
/*
* 函数功能：ARB区段连续占用检查
* 输入参数：UINT16 wAcId 计轴区段ID
* UINT8 cNearAcNum 相邻计轴区段数量
* UINT16 pNearAcId[AC_MAXCNT_IN_SWITCH] 相邻计轴区段ID
* 返 回 值：CI_SUCCESS 1 成功
* CI_ERROR 0 失败
* Created By LQ 2025.08.07
*/
UINT8 aam_ArbContinuousOccCheck(UINT16 wAcId, UINT8 cNearAcNum, UINT16 pNearAcId[AC_MAXCNT_IN_SWITCH])
{
UINT8 cRetVal = CI_ERROR;
UINT16 wBufIndex = 0U;
UINT16 wCurRelPhySecId = 0U; /*本计轴区段所属物理区段ID*/
UINT8 dwCiAndAxleTransBadEnsureCnt = 0U; /*判断与计轴通信中断周期数*/
UINT32 dwCurAxleOccStartCycNum = 0U; /*本计轴区段占用起始周期*/
UINT8 ii = 0U;
UINT16 wNearRelPhySecId = 0U; /*相邻计轴区段所属物理区段ID*/
UINT8 cAcRelEnvelopeCnt = 0U;
EnvelopeStruct strEnvelopeInfo[SECTION_REL_ENVELOPE_SUM_MAX] = { 0U };
UINT32 dwNearAxleOccStartCycNum = 0U; /*相邻计轴区段占用起始周期*/
UINT8 cRcId = 0U;
UINT8 cFunRtn = 0U;
UINT16 wNearAcIndex = 0U;
wBufIndex = GetAxisSecConfigBufIndex(wAcId); /*获取区段数组下标*/
if ((AXIS_SECTION_SUM_MAX > wBufIndex) && (AC_MAXCNT_IN_SWITCH > cNearAcNum) && (NULL != pNearAcId))
{
wCurRelPhySecId = GetAxisSecRelativePhySecId(wAcId);
if (0U != wCurRelPhySecId)
{
cRetVal = CI_SUCCESS;
dwCiAndAxleTransBadEnsureCnt = GetCiAndAxleTransBadEnsureCnt(); /*获取判断与计轴通信中断超时周期数*/
dwCurAxleOccStartCycNum = GetSecColOccupyStartCycNum(wCurRelPhySecId);
for (ii = 0U; ii < cNearAcNum; ii++)
{
wNearRelPhySecId = GetAxisSecRelativePhySecId(pNearAcId[ii]);
if (0U != wNearRelPhySecId)
{
cAcRelEnvelopeCnt = elm_GetEnvelopeInAC(pNearAcId[ii], strEnvelopeInfo);
dwNearAxleOccStartCycNum = GetSecColOccupyStartCycNum(wNearRelPhySecId);
if (((0U == cAcRelEnvelopeCnt) || (SECTION_REL_ENVELOPE_SUM_MAX == cAcRelEnvelopeCnt))
&& ((dwCurAxleOccStartCycNum + dwCiAndAxleTransBadEnsureCnt) < dwNearAxleOccStartCycNum))
{
cRetVal = CI_ERROR; /*相邻计轴区段无包络且占用起始时间超过了“与计轴通信中断超时判断时间”*/
cFunRtn = aam_PrepareACIsSelf(pNearAcId[ii], &cRcId); /*判断相邻区段是否为本控区区段*/
if (ELM_BELONG_OWNER == cFunRtn)
{
wNearAcIndex = aam_PrepareACIndex(pNearAcId[ii]);
(void)aam_ClearPassTrainFlag(wNearAcIndex); /*清除好车通过标志*/
(void)aam_ClearRedunTime(wNearAcIndex); /*清除冗余计时*/
aam_SetAxisStatus(wNearAcIndex, AAM_STATUS_OCC); /*设置占用*/
AAM_LOG(AAM_LOG_FATAL, "info:AC%d Set Occ Because Of Near Sec%d Keep Arb Fail\n", pNearAcId[ii], wAcId);
}
else
{
/*非本控区区段，不处理*/
}
}
else
{
/*相邻计轴区段占用起始周期未超过“与计轴通信中断超时判断时间”，继续检查*/
}
}
else
{
cRetVal = CI_ERROR; /*异常场景，返回失败*/
}
}
}
else
{
cRetVal = CI_ERROR; /*异常场景，返回失败*/
}
}
else
{
cRetVal = CI_ERROR; /*入参非法，返回失败*/
}
return cRetVal;
}
TSCP/src/APP/ciapp/AxisAssert/AxisAssertManageAPI.h
+20
View File
@@ -213,4 +213,24 @@ void SetRcAxleArb(void);
*/
UINT8 aam_GetAxisStatusAPI(UINT16 ACID);
/**
* 函数功能：检查计轴所在物理区段均无故障车
* 输入参数：UINT16 ACID 计轴区段id
* 返回值：CI_SUCCESS 无故障车
* CI_ERROR 存在故障车
* Create By fan 2025.06 18
*/
UINT8 aam_CheckPhyTrain(UINT16 ACID);
/*
* 函数功能：ARB区段连续占用检查
* 输入参数：UINT16 wAcId 计轴区段ID
* UINT8 cNearAcNum 相邻计轴区段数量
* UINT16 pNearAcId[AC_MAXCNT_IN_SWITCH] 相邻计轴区段ID
* 返 回 值：CI_SUCCESS 1 成功
* CI_ERROR 0 失败
* Created By LQ 2025.08.07
*/
UINT8 aam_ArbContinuousOccCheck(UINT16 wAcId, UINT8 cNearAcNum, UINT16 pNearAcId[AC_MAXCNT_IN_SWITCH]);
#endif /*AXIS_ASSERT_MANAGE_API_H_*/
TSCP/src/APP/ciapp/CutoffPoint/CutoffPointDataManage.c
+233 -136
View File
@@ -370,27 +370,22 @@ void CutoffPointOutput(void)
UINT16 wPhySecId = 0u;
UINT8 chOccState = 0u;
UINT8 cDir = 0u;
UINT8 cTrainDir = 0u;
UINT8 cFunRetVal = CI_ERROR;
TRAIN_SEQUANCE_s strTmp = { 0u };
CfpTrainInfoStru tmpTrainInfo = { 0u };
UINT16 wTrainId = 0u;
UINT32 dwDis = UINT32_MAX;
UINT32 dwDisTail = UINT32_MAX;
UINT32 dwDisHead = UINT32_MAX;
struct_PathPoint TrainPoint = { 0u };
struct_PathPoint TrainHeadPoint = { 0u };
struct_PathPoint TrainTailPoint = { 0u };
struct_PathPoint CutoffPoint = { 0u };
UINT8 cTrainTailDir = 0U; /*列车安全车尾方向*/
UINT8 cTrainHeadDir = 0U; /*列车安全车头方向*/
UINT32 dwFindLen = 0u;
struct_PathPoint LinkPoint = { 0u };
UINT32 dwFindLen = 0u;/*信号机点灯防护距离*/
UINT8 chTrainNum = 0u;
UINT8 cDirectionPointfirst = 0U; /*方向变化点1*/
UINT8 cDirectionPointsecond = 0U; /*方向变化点2*/
UINT16 wOtherCfpId = 0u; /*其他分界点ID*/
UINT8 chLocalId = 0u; /*本联锁id*/
UINT8 chLinkCIId = 0u; /*link所属联锁id*/
UINT8 chOtherFlag = FLAG_UNSET;
UINT8 chBreakFlag = FLAG_UNSET;
UINT32 dwLinkLen = 0U;/*本联锁已计算分界点距离*/
dwFindLen = GetSystemParaValue(SIGNAL_LIGHTUP_SEC_LEN_ID);
dwFindLen *= 100u;
dwFindLen *= 100U;
chLocalId = GetSystemParaLocalCiId();
/* 获取本联锁边界点数量 */
wCutoffPointSum = GetCfpSum();
@@ -405,157 +400,122 @@ void CutoffPointOutput(void)
cDir = GetCfpLocDir(wCutoffPointId);
/* 计算边界点的点灯link */
(void)CommonMemSet(wszLinkIdBuf, (UINT32)(sizeof(UINT16)*MAX_CFG_LIGHTUPLINK_NUM), 0U, (UINT32)(sizeof(UINT16)*MAX_CFG_LIGHTUPLINK_NUM));
cFunRetVal = CalCutoffPointOccupyLinkSeq(wCutoffPointId, &wLinkSum, wszLinkIdBuf);
/* 获取边界点信息 */
CutoffPoint.wLinkId = GetCfpLink(wCutoffPointId);
CutoffPoint.dwOffset = GetCfpOffset(wCutoffPointId);
/*重置计算位置 */
LinkPoint.wLinkId =0U;
LinkPoint.dwOffset = 0U;
wTrainId = 0u;
TrainPoint.wLinkId = 0u;
TrainPoint.dwOffset = 0u;
TrainTailPoint.wLinkId = 0U;
TrainTailPoint.dwOffset = 0U;
TrainHeadPoint.wLinkId = 0U;
TrainHeadPoint.dwOffset = 0U;
if (CI_SUCCESS == cFunRetVal)
wOtherCfpId = 0U;
chOtherFlag = FLAG_UNSET;
chBreakFlag = FLAG_UNSET;
dwLinkLen = 0U;
if ((CI_SUCCESS == cFunRetVal)&&(MAX_CFG_LIGHTUPLINK_NUM>=wLinkSum))
{
/* 区段查找成功,查到区段上的列车 */
for (j = 0u;j < wLinkSum;j++)
{
wLinkId = wszLinkIdBuf[j];
wPhySecId = GetLinkRelatedPhySec(wLinkId);
chOccState = GetPhySecCurOccupyState(wPhySecId);
chTrainNum = as_GetLinkTrainNum(wLinkId);
if ((SECTION_OCCUPY_NO != chOccState) && (0u != chTrainNum))
chLinkCIId = (UINT8)GetLinkManageTiocById(wLinkId);
if (chLinkCIId == chLocalId)
{
/* 找到有车占用的区段 */
wPhySecId = GetLinkRelatedPhySec(wLinkId);
chOccState = GetPhySecCurOccupyState(wPhySecId);
chTrainNum = as_GetLinkTrainNum(wLinkId);
if ((SECTION_OCCUPY_NO != chOccState) && (0u != chTrainNum))
{
/* 找到有车占用的区段 */
chBreakFlag = FLAG_SET;
}
else
{
;
}
}
else
{
chOtherFlag = FLAG_SET;
}
if (j < wLinkSum)
{
/* 更新已经计算的最远无车位置*/
LinkPoint.wLinkId = wLinkId;
if ((FLAG_SET == chOtherFlag)||(FLAG_SET == chBreakFlag))
{
if (DIR_SAME == cDir)
{
LinkPoint.dwOffset = 0U;
}
else
{
LinkPoint.dwOffset = GetLinkLengthById(wLinkId);
}
}
else
{
if (DIR_SAME == cDir)
{
LinkPoint.dwOffset = GetLinkLengthById(wLinkId);
}
else
{
LinkPoint.dwOffset = 0U;
}
if (j < wLinkSum - 1U)
{ /*检查是否有方向变化点，此处检查，当前link已按既定方向查找完，查下一link，若此时中间有方向变化点，则跨过方向变化点，到下一link改变方向查*/
cDirectionPointfirst = GetLinkLogicDirChangedById(wszLinkIdBuf[j]);
cDirectionPointsecond = GetLinkLogicDirChangedById(wszLinkIdBuf[(j + 1U)]); /*wLinkSum已检查越界*/
if (((LINK_DIRCHANGE_BEGIN == cDirectionPointfirst) || (LINK_DIRCHANGE_END == cDirectionPointfirst))
&& (cDirectionPointsecond == cDirectionPointfirst))
{
cDir = ConvertTrainDir(cDir); /*有方向变化点，转换方向*/
}
else
{
; /*没有反向变换点，不考虑变方向*/
}
}
dwLinkLen += GetLinkLengthById(wLinkId); /*未中断遍历，无车且属于本联锁，更新已计算link总长*/
}
}
else
{
; /*最后一个link 无需更新*/
}
if ((dwFindLen <= dwLinkLen)|| (FLAG_SET == chOtherFlag) || (FLAG_SET == chBreakFlag))
{
/*距离足够 或查找到相邻RC，或查找到占用，停止计算*/
break;
}
else
{
;
}
/*检查是否有方向变化点，此处检查，当前link已按既定方向查找完，查下一link，若此时中间有方向变化点，则跨过方向变化点，到下一link改变方向查*/
if (j < (wLinkSum - 1U))
{
cDirectionPointfirst = GetLinkLogicDirChangedById(wszLinkIdBuf[j]);
cDirectionPointsecond = GetLinkLogicDirChangedById(wszLinkIdBuf[(j + 1U)]); /*todo越界*/
if (((LINK_DIRCHANGE_BEGIN == cDirectionPointfirst) || (LINK_DIRCHANGE_END == cDirectionPointfirst))
&& (cDirectionPointsecond == cDirectionPointfirst))
{
cDir = ConvertTrainDir(cDir); /*有方向变化点，转换方向*/
}
else
{
; /*没有反向变换点，不考虑变方向*/
}
}
else
{
; /*最后一个link不需要考虑方向变化点的问题，防止数组越界*/
; /*无处理*/
}
}
/* 获取列车ID 获取距离分界点最近的列车*/
if (j < wLinkSum)
if ((j < wLinkSum) && (dwFindLen > dwLinkLen))
{
if (DIR_SAME == cDir)
if (FLAG_UNSET == chOtherFlag)
{
strTmp = as_GetLinkFirstTrain(wLinkId);
CfpTrainInfoCal(LinkPoint.wLinkId, LinkPoint.dwOffset, dwLinkLen, &tmpTrainInfo, cDir);
}
else
{
strTmp = as_GetLinkLastTrain(wLinkId);
/*找到不属于本联锁link 寻找对应联锁及分界点列车信息*/
OtherCfpTrainInfoCal(LinkPoint.wLinkId, LinkPoint.dwOffset, dwLinkLen, &tmpTrainInfo);
}
wTrainId = strTmp.u16TrainID;
}
else
{
;
}
if (j == wLinkSum)
{
/* 未找到有车占用发送无车 */
/* 未找到有车占用 或空闲距离足够发送无车 */
tmpTrainInfo.wTrainId = 0u;
tmpTrainInfo.chTrainLevel = 0u;
tmpTrainInfo.dwDis = 0u;
}
else
{
/* 存在占用，判断列车类型 */
if (NAME_FAILUREAREA == strTmp.u16TrainID)
{
/* 故障区域 */
tmpTrainInfo.wTrainId = SIZE_MAX_LINETRAIN;
tmpTrainInfo.chTrainLevel = 0u;
/* 获取区域位置 */
TrainPoint.wLinkId = wLinkId;
/*选取link上距离分界点最近的点*/
if (DIR_SAME == cDir)
{
TrainPoint.dwOffset = 0u;
}
else
{
TrainPoint.dwOffset = GetLinkLengthById(wLinkId);
}
/* 查询距离 */
dwDis = DsuAPointToBPoint(&TrainPoint, &CutoffPoint, &cTrainDir);
}
else
{
/* 正常车 */
tmpTrainInfo.wTrainId = strTmp.u16TrainID;
tmpTrainInfo.chTrainLevel = GetTrainLevel(tmpTrainInfo.wTrainId);
/*获取安全车尾点*/
TrainTailPoint.wLinkId = GetTrainSafeTailLink(wTrainId);
TrainTailPoint.dwOffset = GetTrainSafeTailOffset(wTrainId);
/*获取安全车头点*/
TrainHeadPoint.wLinkId = GetTrainSafeHeadLink(wTrainId);
TrainHeadPoint.dwOffset = GetTrainSafeHeadOffset(wTrainId);
/*获取车尾到分界点距离*/
dwDisTail = DsuAPointToBPoint(&TrainTailPoint, &CutoffPoint, &cTrainTailDir);
/*获取车头到分界点距离*/
dwDisHead = DsuAPointToBPoint(&TrainHeadPoint, &CutoffPoint, &cTrainHeadDir);
if (dwDisTail < dwDisHead)
{
dwDis = dwDisTail;
}
else
{
dwDis = dwDisHead;
}
}
if (UINT32_MAX == dwDis)
{
tmpTrainInfo.dwDis = 0u;
}
else if(dwFindLen >= dwDis)
{
tmpTrainInfo.dwDis = dwDis;
}
else
{
/* 超出范围，无车 */
tmpTrainInfo.wTrainId = 0u;
tmpTrainInfo.chTrainLevel = 0u;
tmpTrainInfo.dwDis = 0u;
}
}
}
else
{
@@ -1632,3 +1592,140 @@ void SetCfpSignalLightUpFlag(const UINT16 wCfpId, const UINT8 cLightUpFlag)
;
}
}
/*
* 功能描述： 根据其他分界点信息更新本联锁发送分界点列车数据
* 参数说明：UINT16 wLinkId 分界点link ,UINT32 dwOffSet偏移量, UINT32 dwLocalOffSet 本联锁已经查找距离
* [输出参数]: CfpTrainInfoStru* trainInfo 列车数据
* 返回值 ：无
* Created By fan 2025.05.26
*/
void OtherCfpTrainInfoCal(UINT16 wLinkId,UINT32 dwOffSet,UINT32 dwLocalOffSet, CfpTrainInfoStru* trainInfo)
{
UINT16 wCfpId = 0U;/*分界点id*/
UINT8 chTransmitStat = TRANSMIT_STATE_BAD;
CfpTrainInfoStru strCfpInfo = { 0u };
UINT8 chLinkTiocId = 0U;
UINT32 dwDdLen = 0U;/*信号机点灯距离*/
UINT32 dwLeftOffset = 0U;/*剩余需计算距离*/
/*数据初始化*/
dwDdLen = GetSystemParaValue(SIGNAL_LIGHTUP_SEC_LEN_ID);
dwDdLen *= 100u;
wCfpId = GetCfpIdByPoint(wLinkId, dwOffSet);
if (NULL != trainInfo)
{
/*初始化为在该分界点存在故障车*/
trainInfo->wTrainId = SIZE_MAX_LINETRAIN;
trainInfo->dwDis = dwLocalOffSet;
trainInfo->chTrainLevel = 0U;
if (dwDdLen > dwLocalOffSet)
{
dwLeftOffset = dwDdLen - dwLocalOffSet;
}
else
{
;/*无处理*/
}
if (0U != wCfpId)
{
chLinkTiocId = (UINT8)GetLinkManageTiocById(wLinkId);
strCfpInfo = GetCfpOtherOcTrainInfo(wCfpId);
chTransmitStat = GetCiTransmitState(CI_SYSTEM_TYPE_RCI, chLinkTiocId);
if ((TRANSMIT_STATE_GOOD != chTransmitStat) || (UINT16_MAX == strCfpInfo.wTrainId))
{
;/*通信不良好，或者分界点列车信息获取失败*/
}
else if ((0u == strCfpInfo.wTrainId) ||
((UINT32_MAX != strCfpInfo.dwDis) && (dwLeftOffset < strCfpInfo.dwDis)))
{
/*相邻Tioc无车 或 距离分界点距离大于剩余查找距离*/
trainInfo->wTrainId = 0U;
trainInfo->dwDis = 0U;
trainInfo->chTrainLevel = 0U;
}
else
{
/*传递分界点信息*/
trainInfo->wTrainId = strCfpInfo.wTrainId;
trainInfo->dwDis = strCfpInfo.dwDis + dwLocalOffSet;
trainInfo->chTrainLevel = strCfpInfo.chTrainLevel;
}
}
else
{
;/*分界点获取失败*/
}
}
}
/*
* 功能描述： 本联锁列车数据更新本联锁发送分界点列车数据
* 参数说明：UINT16 wLinkId 分界点link ,UINT32 dwOffSet偏移量, UINT32 dwLocalOffSet 本联锁已经查找距离 UINT8 cDir 方向
* [输出参数]: CfpTrainInfoStru* trainInfo 列车数据
* 返回值 ：无
* Created By fan 2025.06.04
*/
void CfpTrainInfoCal(UINT16 wLinkId, UINT32 dwOffSet, UINT32 dwLocalOffSet, CfpTrainInfoStru* trainInfo,UINT8 cDir)
{
TRAIN_SEQUANCE_s strTmp = { 0u };
UINT16 wTrainId = 0u;
UINT32 dwDis = UINT32_MAX;
UINT32 dwDisTail = UINT32_MAX;
UINT32 dwDisHead = UINT32_MAX;
struct_PathPoint TrainHeadPoint = { 0u };
struct_PathPoint TrainTailPoint = { 0u };
struct_PathPoint LinkPoint = { 0u };
UINT8 cTrainTailDir = 0U; /*列车安全车尾方向*/
UINT8 cTrainHeadDir = 0U; /*列车安全车头方向*/
if ((NULL != trainInfo)&&(0U!= wLinkId))
{
LinkPoint.wLinkId = wLinkId;
LinkPoint.dwOffset = dwOffSet;
/*占用link属于本联锁*/
if (DIR_SAME == cDir)
{
strTmp = as_GetLinkFirstTrain(wLinkId);
}
else
{
strTmp = as_GetLinkLastTrain(wLinkId);
}
wTrainId = strTmp.u16TrainID;
/* 存在占用，判断列车类型 */
if (NAME_FAILUREAREA == strTmp.u16TrainID)
{
/* 故障区域 */
trainInfo->wTrainId = SIZE_MAX_LINETRAIN;
trainInfo->chTrainLevel = 0u;
trainInfo->dwDis = dwLocalOffSet;
}
else
{
/* 正常车 */
trainInfo->wTrainId = strTmp.u16TrainID;
trainInfo->chTrainLevel = GetTrainLevel(trainInfo->wTrainId);
/*获取安全车尾点*/
TrainTailPoint.wLinkId = GetTrainSafeTailLink(wTrainId);
TrainTailPoint.dwOffset = GetTrainSafeTailOffset(wTrainId);
/*获取安全车头点*/
TrainHeadPoint.wLinkId = GetTrainSafeHeadLink(wTrainId);
TrainHeadPoint.dwOffset = GetTrainSafeHeadOffset(wTrainId);
/*获取车尾到已计算link最远端距离*/
dwDisTail = DsuAPointToBPoint(&TrainTailPoint, &LinkPoint, &cTrainTailDir);
/*获取车头到已计算link最远端距离*/
dwDisHead = DsuAPointToBPoint(&TrainHeadPoint, &LinkPoint, &cTrainHeadDir);
if (dwDisTail < dwDisHead)
{
dwDis = dwDisTail;
}
else
{
dwDis = dwDisHead;
}
trainInfo->dwDis = dwLocalOffSet + dwDis;
}
}
}
TSCP/src/APP/ciapp/CutoffPoint/CutoffPointDataManage.h
+17
View File
@@ -350,6 +350,23 @@ UINT8 GetCfpSignalLightUpFlag(const UINT16 wCfpId);
*/
void SetCfpSignalLightUpFlag(const UINT16 wCfpId, const UINT8 cLightUpFlag);
/*
* 功能描述： 根据其他分界点信息更新本联锁发送分界点列车数据
* 参数说明：UINT16 wLinkId 分界点link ,UINT32 dwOffSet偏移量, UINT32 dwLocalOffSet 本联锁已经查找距离
* [输出参数]: CfpTrainInfoStru* trainInfo 列车数据
* 返回值 ：CI_ERROR有车 CI_SUCCESS无车
* Created By fan 2025.05.26
*/
void OtherCfpTrainInfoCal(UINT16 wLinkId, UINT32 dwOffSet, UINT32 dwLocalOffSet, CfpTrainInfoStru* trainInfo);
/*
* 功能描述： 本联锁列车数据更新本联锁发送分界点列车数据
* 参数说明：UINT16 wLinkId 分界点link ,UINT32 dwOffSet偏移量, UINT32 dwLocalOffSet 本联锁已经查找距离 UINT8 cDir 方向
* [输出参数]: CfpTrainInfoStru* trainInfo 列车数据
* 返回值 ：无
* Created By fan 2025.06.04
*/
void CfpTrainInfoCal(UINT16 wLinkId, UINT32 dwOffSet, UINT32 dwLocalOffSet, CfpTrainInfoStru* trainInfo, UINT8 cDir);
#ifdef __cplusplus
}
#endif
TSCP/src/APP/ciapp/DataManage/DeviceConfigDataManage.c
+43 -15
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,28 +203,55 @@ 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)
{
for (ii = 0U; ii < gEmapCiConfigStrus[ciId].chAdjoinCICount; ii++)
if (RC_WORK_MODE_CI == chDevType)
{
if (ii < CI_TRAINSMIT_CI_MAX_NUM)
for (ii = 0U; ii < gEmapCiConfigStrus[ciId].chAdjoinCICount; ii++)
{
if ((deviceName == gEmapCiConfigStrus[ciId].wAdjoinCIId[ii]) && (gEmapCiConfigStrus[ciId].wAdjoinCIId[ii] > 0U) && (gEmapCiConfigStrus[ciId].wAdjoinCIId[ii] < 0xFFFFU))
if (ii < CI_TRAINSMIT_CI_MAX_NUM)
{
if ((deviceName == gEmapCiConfigStrus[ciId].wAdjoinCIId[ii]) && (gEmapCiConfigStrus[ciId].wAdjoinCIId[ii] > 0U) && (gEmapCiConfigStrus[ciId].wAdjoinCIId[ii] < 0xFFFFU))
{
retDataVer = gEmapCiConfigStrus[ciId].dwAdjoinCIShareCheckData[ii];
chBreakFlag = 1U;
}
}
else
{
retDataVer = gEmapCiConfigStrus[ciId].dwAdjoinCIShareCheckData[ii];
chBreakFlag = 1U;
}
if (1U == chBreakFlag)
{
break;
}
}
else
}
else
{
for (ii = 0U; ii < gEmapCiConfigStrus[ciId].chAdjoinRCCount; ii++)
{
chBreakFlag = 1U;
}
if (1U == chBreakFlag)
{
break;
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;
}
}
}
}
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
+532 -23
View File
@@ -44,7 +44,11 @@ UINT8 ciMode = CI_MODE_CI_LOCAL; /*
UINT8 g_AllTsrFlag = CI_ALL_TSR_UNVALID; /* 临时限速标志 */
UINT8 g_AllSnowModel = CI_ALL_SNOW_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：默认值*/
@@ -82,13 +86,20 @@ UINT8 SwitchBlockLinkState = RECOVER_SWITCH_BLOCK_LINK; /*
CtrlPowerStruct ctrlpowerFlag[VIRTUAL_CI_MAX] = { 0u };
UINT8 LocalAreaSnowNum = 0U; /*本地区间雨雪站台数量*/
UINT32 szLocalAreaSnowId[LOCAL_AREA_SNOW_SUM_MAX] = { 0U }; /*本地区间雨雪站台ID数组*/
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*/
/******************************联锁标志数据管理****************************/
@@ -1258,8 +1269,16 @@ void RouteDrvInnerSwitch(const UINT16 routeId, const UINT8 DrivFlag)
chSwitchBelCiId = GetSwitchBelongCiId(switchId);
if ((chLocalCiId == chSwitchBelCiId) && (0U != chLocalCiId))
{
switchExpPos = pRouteProtectSwitchStru[ii].ProtectPosition;
(void)SwitchDriveProcess(switchId, switchExpPos); /*设置进路关联防护道岔的驱动状态为驱动中*/
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
{
@@ -1324,6 +1343,18 @@ UINT8 RouteLockDriveSwitch(const UINT16 routeId, const UINT8 NeedForDrvRoutAssoS
RouteAssocSwitchStruct routeAssocSwitchStru = {0,0}; /*道岔数据*/
UINT8 routeProtectSwitchSum = 0u; /*防护道岔数目*/
RouteProtectSwitchStruct* pRouteProtectSwitchStru = NULL; /*防护道岔数据*/
UINT8 chAutoCheck = 0U;
UINT8 chSendLevel = 0U;
chAutoCheck = AutoSignalOrRouteValid(routeId);
if (chAutoCheck == CI_SUCCESS)
{
/*自动进路或自动信号不发送ATS*/
chSendLevel = ESEND_LEVEL_ZERO;
}
else
{
chSendLevel = ESEND_LEVEL_ATS;
}
if((0u == routeId) || (routeId >= ROUTE_SUM_MAX))
{
@@ -1377,6 +1408,8 @@ UINT8 RouteLockDriveSwitch(const UINT16 routeId, const UINT8 NeedForDrvRoutAssoS
else
{
RouteDrvInnerSwitch(routeId, SWITCH_NEED_DRIV_FALSE);
/*增加道岔单操位置不同报警*/
SetErrorData(EFUNC_ROUTE_LOCK_DRIVE_SWITCH,CI_DEVICE_TYPE_ROUTE,routeId, ETYPE_ROUTE_APPLY_SWITCH_MOVE,0U, chSendLevel);
}
if((CI_SUCCESS == assocSwitchRetVal) && (CI_SUCCESS == innerSwitchRetVal))
@@ -1681,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)
@@ -1783,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))/*驱开放增加是否复示防护逻辑，避免数据配错导致的异常情况*/
@@ -2050,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;
@@ -2084,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)
@@ -2148,6 +2201,8 @@ UINT8 DriveSignalClose(const UINT16 signalId)
*/
UINT8 GetSwitchMoveEarlyValidState(UINT16 switchId, UINT8 oper_src, UINT8 sendLevel)
{
UINT8 reVal = CI_ERROR;
#if 0
/*函数故障码*/
UINT8 const functionId = EFUNC_CHECK_SWITCH_MOVE;
@@ -2174,7 +2229,6 @@ UINT8 GetSwitchMoveEarlyValidState(UINT16 switchId, UINT8 oper_src, UINT8 sendLe
UINT8 switch2ndSecOccuState = 0u;
UINT8 switch2ndSecLockState = 0u;
UINT8 switch2ndSecMerOccuState = 0u;
UINT8 reVal = CI_ERROR;
UINT8 ARBMoveSwitchFlag = 0u;
UINT8 switch2ndSecJumpLockState = 0u;
UINT8 switch2ndSecFLockState = 0u;/*道岔2道岔区段封锁状态*/
@@ -2513,8 +2567,9 @@ UINT8 GetSwitchMoveEarlyValidState(UINT16 switchId, UINT8 oper_src, UINT8 sendLe
}
}
}
/*道岔可动*/
#endif
return reVal;
}
@@ -2577,9 +2632,9 @@ UINT8 GetSwitchMoveValidState(UINT16 switchId,UINT8 oper_src,UINT8 sendLevel)
/*判断是否采用轨道电路*/
gdDLline = GetCiFunctionSwitchConfig(FUNC_CLD_GD_DIANLU_LINE);
if ((JkjRelayId > 0u) && (JKJ_REYLAY_VALID == JkjRelayValid) && (CI_TYPE_CLD == ciType))
if ((JKJ_REYLAY_VALID == JkjRelayValid) && (CI_TYPE_CLD == ciType))
{/*应急盘继电器有效状态*/
SetErrorData(functionId, CI_DEVICE_TYPE_RELAY, JkjRelayId, ETYPE_JKJ_WORK, RELAY_STATE_DOWN, ESEND_LEVEL_ATS);
SetErrorData(functionId, CI_DEVICE_TYPE_RELAY, 0u, ETYPE_JKJ_WORK, RELAY_STATE_DOWN, ESEND_LEVEL_ATS);/*增加OC应急控功能，继电器ID填0*/
reVal = CI_ERROR;
}
else
@@ -5128,6 +5183,9 @@ UINT8 GetOtherCiDevStatus(UINT16 const devType,UINT16 const devId,UINT16 const c
devState = 0u;
}
break;
case CI_DEVICE_TYPE_PSD_EXCEPT_OPEN: /*站台屏蔽门（异常打开）*/
devState = GePsdExceptOpenState(devId);
break;
case CI_DEVICE_TYPE_GARAGEDOOR: /*车库门*/
tmpDevState = GetGaragedoorState(devId);
if (GARAGE_DOOR_STATE_OPEN == tmpDevState)
@@ -5264,6 +5322,7 @@ UINT8 GetOtherCiCheckDevStateType(UINT16 const devType)
retType = ETYPE_ESB_VALID;
break;
case CI_DEVICE_TYPE_PSD: /*站台屏蔽门*/
case CI_DEVICE_TYPE_PSD_EXCEPT_OPEN: /*站台屏蔽门（异常打开）*/
retType = ETYPE_PSD_CLOSE_NO;
break;
case CI_DEVICE_TYPE_GARAGEDOOR: /*车库门*/
@@ -5381,7 +5440,6 @@ void SetAllTsrFlag(UINT8 setFlag)
* 参数说明： void
* 返回值 ：0x55: 有效 0xAA:无效
*/
UINT8 GetAllSnowModel(void)
{
return g_AllSnowModel;
@@ -5404,6 +5462,37 @@ void SetAllSnowModel(UINT8 setmodle)
}
}
/*
* 功能描述：获取全线湿轨等级
* 参数说明：无
* 返 回 值：0 默认值
* 1 湿轨一级
* 2 湿轨二级
* Created By LQ 2025.05.28
*/
UINT8 GetAllSnowLevel(void)
{
return g_AllSnowLevel;
}
/*
* 功能描述：设置全线湿轨等级
* 参数说明：UINT8 cLevel 湿轨级别
* 返 回 值：无
* Created By LQ 2025.05.28
*/
void SetAllSnowLevel(UINT8 cLevel)
{
if ((CI_SNOW_LEVEL_DEFAULT == cLevel) || (CI_SNOW_LEVEL_ONE == cLevel) || (CI_SNOW_LEVEL_TWO == cLevel))
{
g_AllSnowLevel = cLevel;
}
else
{
/*不处理*/
}
}
/*
* 功能描述：获取ITE全线切除状态
* 参数说明：void
@@ -6166,6 +6255,7 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
UINT16 bufIndex = 0u; /*数组下标*/
UINT8 logSecLockState = 0U;
UINT8 logSecLockRouteNum = 0U;
UINT8 chFailStep = 0U;
bufIndex = GetlogSectionBufIndex(logSectionId); /*获取区段数组下标*/
/**区段下标合法*/
@@ -6197,6 +6287,7 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
{
/*调车进路锁闭*/
reVal = CI_ERROR;
chFailStep = 1U;
}
}
if (CI_SUCCESS == reVal)
@@ -6205,6 +6296,7 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
{
/*逻辑区段存在逻辑进路锁闭锁闭*/
reVal = CI_ERROR;
chFailStep = 2U;
}
}
@@ -6224,6 +6316,7 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
|| ((LOGICSECTION_OCCUPY_CT == curLogSecOccState) && (CI_ERROR == checkSulicTrain)))
{
reVal = CI_ERROR;
chFailStep =3U;
break;
}
else
@@ -6257,6 +6350,7 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
{
/*返回失败*/
reVal = CI_ERROR;
chFailStep = 4U;
}
else
{
@@ -6275,12 +6369,14 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
/*物理区段处于封锁状态(SPKS实施)*/
reVal = CI_ERROR;
chFailStep = 5U;
}
if ((CI_SUCCESS == reVal) && (CI_ERROR == logicCheck))
{
/*逻辑区段侵限检查不通过*/
reVal = CI_ERROR;
chFailStep = 6U;
}
if ((CI_SUCCESS == reVal) && (0u < routeRlockId))
@@ -6294,8 +6390,8 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
if ((CI_SUCCESS == routeTrainNear) &&
((ROUTE_STATE_YUXIAN_OPEN == routeState) || (ROUTE_STATE_NEAR_OPEN == routeState)))
{
reVal = CI_ERROR;
chFailStep = 7U;
}
}
else
@@ -6321,6 +6417,7 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
if ((pLgcSecSwitchStru[ii].SwitchPosition != switchCurPosition) || (CI_ERROR == retFlag) || (SWITCH_LOCK_FENGSUO_YES == switchFLockState))
{/*（判断当前计轴包含的道岔位置与道岔当前的位置有一个不同）或（某个道岔上一次驱动仍然有效）或（道岔封锁）*/
reVal = CI_ERROR;
chFailStep = 8U;
break;
}
else
@@ -6351,6 +6448,7 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
if (FLOOD_GATE_OPEN != floodState)
{
reVal = CI_ERROR;
chFailStep = 9U;
break;
}
else
@@ -6376,6 +6474,7 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
|| ((LOGICSECTION_OCCUPY_CT == curLogSecOccState) && (CI_ERROR == checkSulicTrain)))
{
reVal = CI_ERROR;
chFailStep = 10U;
}
else
{
@@ -6395,6 +6494,7 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
if (CI_ERROR == checkResult)
{
reVal = CI_ERROR;
chFailStep = 11U;
}
else
{
@@ -6406,11 +6506,30 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
/** 不做处理*/
}
}
if (CI_SUCCESS == reVal)
{
/* 区段无休眠车检查*/
checkResult = LogSecRelateNoSleepTrainCheck(logSectionId);
if (CI_ERROR == checkResult)
{
reVal = CI_ERROR;
chFailStep = 12U;
}
else
{
reVal = CI_SUCCESS;
}
}
}
else
{
reVal = CI_ERROR;
}
if (CI_ERROR == reVal)
{
debug_infor_printf((const)"\nCheckLogJumpLockApply ! LogSecID: %d__Error Position Is [%d]\n", logSectionId, chFailStep);
}
return reVal;
}
@@ -8992,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*/
@@ -9015,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)
{
/*检查自动触发进路防淹门状态*/
@@ -10616,10 +10805,10 @@ UINT8 GetDiaoCheRouteOpenState(const UINT16 wRouteId)
/*
* 功能描述：设置本地区间雨雪站台信息
* 参数说明：const UINT8 cAreaSnowNum 区间雨雪数量
* const UINT32 pAreaSnowIdBuf[] 区间雨雪ID数组
* const AreaSnowInfoStruct pAreaSnowBuf[LOCAL_AREA_SNOW_SUM_MAX] 区间雨雪数组
* 返回值 ：无
*/
void SetLocalAreaSnowInfo(const UINT8 cAreaSnowNum, const UINT32 pAreaSnowIdBuf[])
void SetLocalAreaSnowInfo(const UINT8 cAreaSnowNum, const AreaSnowInfoStruct pAreaSnowBuf[LOCAL_AREA_SNOW_SUM_MAX])
{
UINT8 ii = 0U;
UINT8 jj = 0U;
@@ -10632,20 +10821,20 @@ void SetLocalAreaSnowInfo(const UINT8 cAreaSnowNum, const UINT32 pAreaSnowIdBuf[
UINT8 cPhySecBelongCiId = 0U; /*SPKS关联物理区段的所属控区*/
UINT8 cLocalCiId = 0U; /*本地CI ID*/
if ((LOCAL_AREA_SNOW_SUM_MAX >= cAreaSnowNum) && (NULL != pAreaSnowIdBuf))
if ((LOCAL_AREA_SNOW_SUM_MAX >= cAreaSnowNum) && (NULL != pAreaSnowBuf))
{
/*清除本地区间雨雪站台信息和发送给相邻联锁的区间雨雪信息*/
ClearCiSendAreaSnowInfo();
(void)CommonMemSet(szLocalAreaSnowId, (UINT32)(sizeof(UINT32) * LOCAL_AREA_SNOW_SUM_MAX), 0U, (UINT32)(sizeof(UINT32) * LOCAL_AREA_SNOW_SUM_MAX));
(void)CommonMemSet(szLocalAreaSnow, (UINT32)(sizeof(AreaSnowInfoStruct) * LOCAL_AREA_SNOW_SUM_MAX), 0U, (UINT32)(sizeof(AreaSnowInfoStruct) * LOCAL_AREA_SNOW_SUM_MAX));
LocalAreaSnowNum = cAreaSnowNum;
for (ii = 0U; ii < cAreaSnowNum; ii++)
{
szLocalAreaSnowId[ii] = pAreaSnowIdBuf[ii]; /*存储本控区的区间雨雪状态信息*/
szLocalAreaSnow[ii] = pAreaSnowBuf[ii]; /*存储本控区的区间雨雪状态信息*/
/*判断是否需要向相邻联锁发送本控区的区间雨雪站台*/
/*判断是否需要向相邻联锁发送本控区的区间雨雪信息*/
cLocalCiId = GetSystemParaLocalCiId();
cPlatFormRelSpksNum = GetPlatFormRelSpksNum((UINT16)pAreaSnowIdBuf[ii], szPlatFormRelSpksId); /*获取站台关联的SPKS*/
cPlatFormRelSpksNum = GetPlatFormRelSpksNum(pAreaSnowBuf[ii].wAreaId, szPlatFormRelSpksId); /*获取站台关联的SPKS*/
if (CI_ERROR != cPlatFormRelSpksNum)
{
@@ -10664,7 +10853,7 @@ void SetLocalAreaSnowInfo(const UINT8 cAreaSnowNum, const UINT32 pAreaSnowIdBuf[
if ((cLocalCiId != cPhySecBelongCiId) && (0U != cLocalCiId) && (0U != cPhySecBelongCiId))
{
AddCiSendAreaSnowInfo(cLocalCiId, cPhySecBelongCiId, pAreaSnowIdBuf[ii]); /*站台关联有非本控区的区段，向区段所属CI发送站台ID*/
AddCiSendAreaSnowInfo(cLocalCiId, cPhySecBelongCiId, pAreaSnowBuf[ii].wAreaId, pAreaSnowBuf[ii].cAreaSnowLevel); /*站台关联有非本控区的区段，向区段所属CI发送站台ID*/
}
else
{
@@ -10701,13 +10890,13 @@ UINT8 GetLocalAreaSnowNum(void)
}
/*
* 功能描述：获取本地区间雨雪站台ID
* 功能描述：获取本地区间雨雪信息
* 参数说明：无
* 返回值 ：区间雨雪站台ID
* 返回值 ：区间雨雪信息
*/
UINT32* GetLocalAreaSnowId(void)
AreaSnowInfoStruct* GetLocalAreaSnow(void)
{
return szLocalAreaSnowId;
return szLocalAreaSnow;
}
@@ -11115,3 +11304,323 @@ void DefaultCtrlPowerDeal(const UINT8 virtualCiId)
;
}
}
/*
* 功能描述：获取本地区间ITE切除数量
* 参数说明：无
* 返 回 值：本地区间ITE切除数量
* Created By LQ 2025.04.15
*/
UINT8 GetLocalAreaIteCutNum(void)
{
return gLocalAreaIteCutNum;
}
/*
* 功能描述：获取本地区间ITE切除ID数组
* 参数说明：无
* 返 回 值：本地区间ITE切除ID数组
* Created By LQ 2025.04.15
*/
UINT16* GetLocalAreaIteCutId(void)
{
return gSzLocalAreaIteCutId;
}
/*
* 功能描述：清除本地区间ITE切除信息
* 参数说明：无
* 返 回 值：无
* Created By LQ 2025.04.15
*/
void ClearLocalAreaIteCutInfo(void)
{
gLocalAreaIteCutNum = 0U;
(void)CommonMemSet(gSzLocalAreaIteCutId, (UINT32)(sizeof(UINT16) * ALL_AREA_SNOW_SUM_MAX), 0U, (UINT32)(sizeof(UINT16) * ALL_AREA_SNOW_SUM_MAX));
}
/*
* 功能描述：设置本地区间ITE切除信息
* 参数说明：const UINT8 cAreaIteCutNum 区间ITE切除数量
* const UINT16 pAreaIteCutIdBuf[ALL_AREA_SNOW_SUM_MAX] 区间ID数组
* 返 回 值：无
* Created By LQ 2025.04.15
*/
void SetLocalAreaIteCutInfo(const UINT8 cAreaIteCutNum, const UINT16 pAreaIteCutIdBuf[ALL_AREA_SNOW_SUM_MAX])
{
UINT8 ii = 0U;
UINT8 jj = 0U;
UINT16 kk = 0U;
UINT8 cPlatFormRelSpksNum = 0U; /*站台关联的SPKS数量*/
UINT16 szPlatFormRelSpksId[PLATFORM_REL_SPKS_NUM_MAX] = { 0U }; /*站台关联的SPKS ID数组*/
UINT16 wSpksIndex = 0U;
UINT16 wSpksRelPhySecNum = 0U; /*SPKS关联物理区段数量*/
UINT16 wSpksRelPhySecId = 0U; /*SPKS关联物理区段ID*/
UINT8 cPhySecBelongCiId = 0U; /*SPKS关联物理区段的所属控区*/
UINT8 cLocalCiId = 0U; /*本地CI ID*/
UINT8 cPlatFormBelongCiId = 0U; /*站台关联Link所属CI*/
if ((ALL_AREA_SNOW_SUM_MAX >= cAreaIteCutNum) && (NULL != pAreaIteCutIdBuf))
{
/*先清除本地区间ITE切除信息及发送给相邻联锁的区间ITE切除信息*/
ClearLocalAreaIteCutInfo();
ClearCiSendAreaIteCutInfo();
/*开始刷新本地区间ITE切除信息*/
gLocalAreaIteCutNum = cAreaIteCutNum;
for (ii = 0U; ii < cAreaIteCutNum; ii++)
{
gSzLocalAreaIteCutId[ii] = pAreaIteCutIdBuf[ii]; /*存储本控区区间ID*/
/*判断是否需要向相邻联锁发送本控区的区间ITE切除信息*/
cLocalCiId = GetSystemParaLocalCiId();
cPlatFormBelongCiId = GetAreaSnowPlatFormBelongCiId(pAreaIteCutIdBuf[ii]); /*获取区间所属控区*/
if ((cLocalCiId == cPlatFormBelongCiId) && (0U != cLocalCiId))
{
cPlatFormRelSpksNum = GetPlatFormRelSpksNum(pAreaIteCutIdBuf[ii], szPlatFormRelSpksId); /*获取站台关联的SPKS*/
if (CI_ERROR != cPlatFormRelSpksNum)
{
/*遍历所有站台关联的SPKS，判断SPKS是否关联有非本控区的物理区段*/
for (jj = 0U; jj < cPlatFormRelSpksNum; jj++)
{
wSpksIndex = GetSpksConfigBufIndex(szPlatFormRelSpksId[jj]);
if (SPKS_SUM_MAX > wSpksIndex)
{
wSpksRelPhySecNum = GetSpksPhySecSumByIndex(wSpksIndex);
for (kk = 0U; kk < wSpksRelPhySecNum; kk++)
{
wSpksRelPhySecId = GetSpksPhySecId(szPlatFormRelSpksId[jj], kk);
cPhySecBelongCiId = GetPhySecBelongCiId(wSpksRelPhySecId);
if ((cLocalCiId != cPhySecBelongCiId) && (0U != cLocalCiId) && (0U != cPhySecBelongCiId))
{
AddCiSendAreaIteCutInfo(cLocalCiId, cPhySecBelongCiId, pAreaIteCutIdBuf[ii]); /*站台关联有非本控区的区段，向区段所属CI发送区间站台ID*/
}
else
{
/*继续遍历*/
}
}
}
else
{
/*不更新该区间雨雪，继续遍历*/
}
}
}
else
{
/*获取站台关联SPKS失败，不处理*/
}
}
else
{
/*非本控区区间，不对相邻RC/CI组包*/
}
}
}
else
{
/*入参非法，不处理*/
}
}
/*
* 功能描述：获取进路内第一个锁闭的逻辑区段ID
* 参数说明：UINT16 wRouteId 进路ID
* 返 回 值：0 无锁闭的逻辑区段
* >0 第一个锁闭的逻辑区段ID
* Created By LQ 2025.05.08
*/
UINT16 GetRouteFirstLockedLogSecId(UINT16 wRouteId)
{
UINT16 wRetVal = 0U;
UINT16 wRouteLogSecNum = 0U; /*进路包含的逻辑区段数量*/
UINT16* pRouteLogSecIdBuf = NULL; /*进路包含的逻辑区段ID*/
UINT16 i = 0U;
UINT16 wLockBelongRouteId = 0U; /*锁闭所属进路ID*/
/*获取进路逻辑区段数据*/
wRouteLogSecNum = GetRouteLogSectionSum(wRouteId);
pRouteLogSecIdBuf = GetRouteLogSectionIdBuf(wRouteId);
if ((0U < wRouteLogSecNum) && (NULL != pRouteLogSecIdBuf))
{
for (i = 0U; i < wRouteLogSecNum; i++)
{
wLockBelongRouteId = GetLogSecLockBelongRoute(pRouteLogSecIdBuf[i]); /*获取逻辑区段锁闭所属进路*/
if (wLockBelongRouteId == wRouteId)
{
/*逻辑区段被本进路锁闭，传出此逻辑区段*/
wRetVal = pRouteLogSecIdBuf[i];
break;
}
else
{
/*继续遍历查找*/
}
}
}
else
{
/*返回0*/
}
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
+155 -6
View File
@@ -15,6 +15,14 @@
#define _DEVICE_DATA_MANAGE_H_
#include "CommonTypes.h"
/*区间雨雪信息结构体*/
typedef struct S_AreaSnowInfoStruct
{
UINT16 wAreaId; /*区间ID*/
UINT8 cAreaSnowLevel; /*区间湿轨级别*/
} AreaSnowInfoStruct;
#include "../System/CiSystemDefine.h"
#include "../error/ErrorDataManage.h"
#include "../Transmit/TransmitStateDataManage.h"
@@ -156,6 +164,7 @@ typedef struct S_LineCommTrainStruct
UINT16 szCommTrainNumID[TRAIN_SUM_MAX]; /*全线通信车ID数组*/
}LineCommTrainStruct;
/*******************************全局变量声明*******************************/
extern UINT8 AllSignalBrightFlag; /*全站亮灯标志*/
@@ -181,6 +190,10 @@ 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：默认值*/
extern UINT8 g_AllLineTsrState; /*全线临时限速状态*/
@@ -219,13 +232,21 @@ extern UINT8 SwitchBlockLinkState; /*
extern CtrlPowerStruct ctrlpowerFlag[VIRTUAL_CI_MAX];
extern UINT8 LocalAreaSnowNum; /*本地区间雨雪站台数量*/
extern UINT32 szLocalAreaSnowId[LOCAL_AREA_SNOW_SUM_MAX]; /*本地区间雨雪站台ID数组*/
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数组*/
/******************************联锁标志数据管理****************************/
/*
@@ -1367,6 +1388,24 @@ extern UINT8 GetAllSnowModel(void);
*/
extern void SetAllSnowModel(UINT8 setmodle);
/*
* 功能描述：获取全线湿轨等级
* 参数说明：无
* 返 回 值：0 默认值
* 1 湿轨一级
* 2 湿轨二级
* Created By LQ 2025.05.28
*/
UINT8 GetAllSnowLevel(void);
/*
* 功能描述：设置全线湿轨等级
* 参数说明：UINT8 cLevel 湿轨级别
* 返 回 值：无
* Created By LQ 2025.05.28
*/
void SetAllSnowLevel(UINT8 cLevel);
/*
* 功能描述：获取ITE全线切除状态
* 参数说明：void
@@ -1710,10 +1749,10 @@ UINT8 GetDiaoCheRouteOpenState(const UINT16 wRouteId);
/*
* 功能描述：设置本地区间雨雪站台信息
* 参数说明：const UINT8 cAreaSnowNum 区间雨雪数量
* const UINT32 pAreaSnowIdBuf[] 区间雨雪ID数组
* const AreaSnowInfoStruct pAreaSnowBuf[LOCAL_AREA_SNOW_SUM_MAX] 区间雨雪数组
* 返回值 ：无
*/
void SetLocalAreaSnowInfo(const UINT8 cAreaSnowNum, const UINT32 pAreaSnowIdBuf[]);
void SetLocalAreaSnowInfo(const UINT8 cAreaSnowNum, const AreaSnowInfoStruct pAreaSnowBuf[LOCAL_AREA_SNOW_SUM_MAX]);
/*
* 功能描述：获取本地区间雨雪站台数量
@@ -1723,11 +1762,11 @@ void SetLocalAreaSnowInfo(const UINT8 cAreaSnowNum, const UINT32 pAreaSnowIdBuf[
UINT8 GetLocalAreaSnowNum(void);
/*
* 功能描述：获取本地区间雨雪站台ID
* 功能描述：获取本地区间雨雪信息
* 参数说明：无
* 返回值 ：区间雨雪站台ID
* 返回值 ：区间雨雪信息
*/
UINT32* GetLocalAreaSnowId(void);
AreaSnowInfoStruct* GetLocalAreaSnow(void);
/*
@@ -1824,4 +1863,114 @@ UINT8 GetSwitchUsingValidState(const UINT16 wSwitchId, const UINT8 chFunctionId,
*/
void DefaultCtrlPowerDeal(const UINT8 virtualCiId);
/*
* 功能描述：获取本地区间ITE切除数量
* 参数说明：无
* 返 回 值：本地区间ITE切除数量
* Created By LQ 2025.04.15
*/
UINT8 GetLocalAreaIteCutNum(void);
/*
* 功能描述：获取本地区间ITE切除ID数组
* 参数说明：无
* 返 回 值：本地区间ITE切除ID数组
* Created By LQ 2025.04.15
*/
UINT16* GetLocalAreaIteCutId(void);
/*
* 功能描述：清除本地区间ITE切除信息
* 参数说明：无
* 返 回 值：无
* Created By LQ 2025.04.15
*/
void ClearLocalAreaIteCutInfo(void);
/*
* 功能描述：设置本地区间ITE切除信息
* 参数说明：const UINT8 cAreaIteCutNum 区间ITE切除数量
* const UINT16 pAreaIteCutIdBuf[ALL_AREA_SNOW_SUM_MAX] 区间ID数组
* 返 回 值：无
* Created By LQ 2025.04.15
*/
void SetLocalAreaIteCutInfo(const UINT8 cAreaIteCutNum, const UINT16 pAreaIteCutIdBuf[ALL_AREA_SNOW_SUM_MAX]);
/*
* 功能描述：获取进路内第一个锁闭的逻辑区段ID
* 参数说明：UINT16 wRouteId 进路ID
* 返 回 值：0 无锁闭的逻辑区段
* >0 第一个锁闭的逻辑区段ID
* 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
+89 -15
View File
@@ -17,7 +17,7 @@
extern PlatHeartDataStruct RecvHeartDataStru ; /*平台心跳帧数据结构*/
extern PlatGPIODataStruct RecvPlatDataStruGPIO;/*平台0x2D帧数据结构 GPIO采集状态*/
extern PlatGPIOToleranceDataStruct gPlatDataGPIOTolercance;/*平台硬件采集故障容忍记录数据*/
@@ -427,18 +427,36 @@ UINT8 CheckRCIAPowerFaultState(void)
{
UINT8 retVal = CI_ERROR;
UINT8 cxABreakFlag = 0U; /*A系电源插箱空开断开检查*/
UINT8 chCheckState = 0U;
UINT32 dwErrorStartCyc = 0U;
UINT32 dwCurCyc = 0U;
cxABreakFlag = GetPowerANodeStatue();
dwErrorStartCyc = gPlatDataGPIOTolercance.powerANode_TolCyc;
dwCurCyc = Get2oo2CurCycleNum();
/* 1、A系电源插箱空开断开 */
if (NODE_STATUS_BREAK == cxABreakFlag)
{
/*A系电源故障状态*/
retVal = CI_ERROR;
chCheckState = SystemOverTimeCheck(dwErrorStartCyc, IO_POWERSTATE_TOLERANCE);
if (CI_TIME_NO == chCheckState)
{
gPlatDataGPIOTolercance.powerANode_TolCyc = dwCurCyc;
retVal = CI_SUCCESS;
}
else if (CI_TIME_IN == chCheckState)
{
retVal = CI_SUCCESS;/*继续容忍*/
}
else
{
retVal = CI_ERROR;
debug_infor_printf((const)"\nPLATIO_A_Node_Power_FaultState StartTime%d\n", dwErrorStartCyc);
}
}
else
{
retVal = CI_SUCCESS;
gPlatDataGPIOTolercance.powerANode_TolCyc = 0U;
}
return retVal;
}
@@ -453,18 +471,36 @@ UINT8 CheckRCIBPowerFaultState(void)
{
UINT8 retVal = CI_ERROR;
UINT8 cxBBreakFlag = 0U; /*B系电源插箱空开断开检查*/
UINT8 chCheckState = 0U;
UINT32 dwErrorStartCyc = 0U;
UINT32 dwCurCyc = 0U;
cxBBreakFlag = GetPowerBNodeStatue();
/* 1、B系电源插箱空开断开 */
dwErrorStartCyc = gPlatDataGPIOTolercance.powerBNode_TolCyc;
dwCurCyc = Get2oo2CurCycleNum();
/* 1、B系电源插箱空开断开*/
if (NODE_STATUS_BREAK == cxBBreakFlag)
{
/*B系电源故障状态*/
retVal = CI_ERROR;
chCheckState = SystemOverTimeCheck(dwErrorStartCyc, IO_POWERSTATE_TOLERANCE);
if (CI_TIME_NO == chCheckState)
{
gPlatDataGPIOTolercance.powerBNode_TolCyc = dwCurCyc;
retVal = CI_SUCCESS;
}
else if (CI_TIME_IN == chCheckState)
{
retVal = CI_SUCCESS;/*继续容忍*/
}
else
{
retVal = CI_ERROR;
debug_infor_printf((const)"\nPLATIO_B_Node_Power_FaultState StartTime%d\n", dwErrorStartCyc);
}
}
else
{
retVal = CI_SUCCESS;
gPlatDataGPIOTolercance.powerBNode_TolCyc = 0U;
}
return retVal;
}
@@ -479,16 +515,20 @@ 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*/
UINT8 vol3Flag = 0U; /*CPI A采集24VB电源 3*/
UINT8 chCheckState = 0U;
UINT32 dwErrorStartCyc = 0U;
UINT32 dwCurCyc = 0U;
powerAPUBAState = GetGPIOCollectPointStatus(COLLECT_MODEA_CCUA);
powerBPUBAState = GetGPIOCollectPointStatus(COLLECT_MODEB_CCUA);
vol1Flag = CheckPointVoltageState(COLLECT_MODEA_CCUA);
vol3Flag = CheckPointVoltageState(COLLECT_MODEB_CCUA);
dwErrorStartCyc = gPlatDataGPIOTolercance.powerAMode_TolCyc;
dwCurCyc = Get2oo2CurCycleNum();
/* 1、PUB A采集的24VA电源异常、或24VB电源异常
2、CPI A采集24VA电源、或24VB电源电压为0V */
@@ -496,11 +536,27 @@ UINT8 CheckRCIAPowerModeFaultState(void)
if (((CHECK_VOLTAGE_ZERO == vol1Flag) || (CHECK_VOLTAGE_ZERO == vol3Flag))
&& ((POWER_STATUS_ABNORMAL == powerAPUBAState) || (POWER_STATUS_ABNORMAL == powerBPUBAState)))
{
retVal = CI_ERROR;
/*检查容忍*/
chCheckState = SystemOverTimeCheck(dwErrorStartCyc, IO_POWERSTATE_TOLERANCE);
if (CI_TIME_NO == chCheckState)
{
gPlatDataGPIOTolercance.powerAMode_TolCyc = dwCurCyc;
retVal = CI_SUCCESS;
}
else if (CI_TIME_IN == chCheckState)
{
retVal = CI_SUCCESS;/*继续容忍*/
}
else
{
retVal = CI_ERROR;
debug_infor_printf((const)"\nPLATIO_A_Mode_Power_FaultState StartTime%d\n", dwErrorStartCyc);
}
}
else
{
retVal = CI_SUCCESS;
gPlatDataGPIOTolercance.powerAMode_TolCyc = 0U;
}
return retVal;
@@ -520,25 +576,43 @@ UINT8 CheckRCIBPowerModeFaultState(void)
UINT8 powerBPUBBState = 0U; /*PUB A采集的24VB电源状态 4*/
UINT8 vol2Flag = 0U; /*CPI B采集24VA电源 2*/
UINT8 vol4Flag = 0U; /*CPI B采集24VB电源 4*/
UINT8 chCheckState = 0U;
UINT32 dwErrorStartCyc = 0U;
UINT32 dwCurCyc = 0U;
powerAPUBBState = GetGPIOCollectPointStatus(COLLECT_MODEA_CCUB);
powerBPUBBState = GetGPIOCollectPointStatus(COLLECT_MODEB_CCUB);
vol2Flag = CheckPointVoltageState(COLLECT_MODEA_CCUB);
vol4Flag = CheckPointVoltageState(COLLECT_MODEB_CCUB);
dwErrorStartCyc = gPlatDataGPIOTolercance.powerBMode_TolCyc;
dwCurCyc = Get2oo2CurCycleNum();
/* 1、PUB B采集的24VA电源异常、或24VB电源异常
2、CPI B采集24VA电源、或24VB电源电压为0V */
/*暂未实现PUB采集，只判断电源电压*/
2、CPI B采集24VA电源、或24VB电源电压为0V */
if (((CHECK_VOLTAGE_ZERO == vol2Flag) || (CHECK_VOLTAGE_ZERO == vol4Flag))
&& ((POWER_STATUS_ABNORMAL == powerAPUBBState) || (POWER_STATUS_ABNORMAL == powerBPUBBState)))
{
retVal = CI_ERROR;
/*检查容忍*/
chCheckState = SystemOverTimeCheck(dwErrorStartCyc, IO_POWERSTATE_TOLERANCE);
if (CI_TIME_NO == chCheckState)
{
gPlatDataGPIOTolercance.powerBMode_TolCyc = dwCurCyc;
retVal = CI_SUCCESS;
}
else if (CI_TIME_IN == chCheckState)
{
retVal = CI_SUCCESS;/*继续容忍*/
}
else
{
retVal = CI_ERROR;
debug_infor_printf((const)"\nPLATIO_B_Mode_Power_FaultState StartTime%d\n", dwErrorStartCyc);
}
}
else
{
retVal = CI_SUCCESS;
gPlatDataGPIOTolercance.powerBMode_TolCyc = 0U;
}
return retVal;
TSCP/src/APP/ciapp/DataManage/PlatDataManage.h
+10 -2
View File
@@ -16,7 +16,7 @@
#include "CommonTypes.h"
#include "../System/CiSystemDefine.h"
#include "../System/SystemParameterManage.h"
#define BOARD_TYPE_CCUA ((UINT8)0x09) /*通控板A*/
@@ -59,6 +59,7 @@
#define CCU_CommBadEnsureTime_CycleCount ((UINT16)5u) /*应用与通控通信中断判断周期数*/
#define VOLTAGE_MAX_TO_0 ((UINT16)500U) /*电压判断为0的阈值*/
#define IO_POWERSTATE_TOLERANCE ((UINT8)0x02) /*平台电源报警容忍周期数，容忍3周期，超过2周期报警*/
/*平台心跳帧信息结构*/
typedef struct S_PlatHeartDataStruct
@@ -100,7 +101,14 @@ typedef struct S_PlatGPIODataStruct
UINT8 ModepowerBState_PUB; /*机柜B系电源插箱中为CPUB供电的24VDC电源模块状态*/
}PlatGPIODataStruct;
/*平台发送的电源采集状态容忍同步数据*/
typedef struct S_PlatGPIOToleranceData
{
UINT32 powerANode_TolCyc; /*A系电源插箱的故障容忍起始周期*/
UINT32 powerBNode_TolCyc; /*B系电源插箱的故障容忍起始周期*/
UINT32 powerAMode_TolCyc; /*A系电源模块的故障容忍起始周期*/
UINT32 powerBMode_TolCyc; /*B系电源模块的故障容忍起始周期*/
}PlatGPIOToleranceDataStruct;
TSCP/src/APP/ciapp/ERROR/ErrorDefine.h
+24 -1
View File
@@ -109,6 +109,8 @@
#define EFUNC_ROUTE_FIRST_LOG_UNLOCK ((UINT8)0x50) /*函数：RouteFirstLogSecAutoUnlockProcess进路第一逻辑区段自动解锁检查*/
#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) /*办理引导进路检查*/
@@ -135,7 +137,6 @@
#define EFUNC_CLD_CANCEL_D_TRAIN_ROUTE ((UINT8)0x66) /*取消进路调车*/
#define EFUNC_CLD_CLOSE_GARAGEDOOR ((UINT8)0x67) /*关闭车库门*/
#define EFUNC_CLD_CHECK_GARAGEDOOR_CLOSE ((UINT8)0xc9) /*车库门关闭条件检查（RC模式下）*/
#define EFUNC_CHECK_DIAOCHE_ROUTE_ZRJ ((UINT8)0x68) /* CheckDiaoCheRouteZRJFeasibility 检查调车进路总人解的可行性*/
#define EFUNC_CHECK_OPEN_L_ERR_CLD ((UINT8)0x69) /*OpenLTrainRouteErrP*/
#define EFUNC_CHECK_OPEN_D_ERR_CLD ((UINT8)0x6a)
#define EFUNC_KEEP_L_ERR_CLD ((UINT8)0x6b)
@@ -178,6 +179,8 @@
#define EFUNC_LOGSEC_LAST_SECLOCK ((UINT8)0x92) /* CheckLogRouteLogSecLastSecLock */
#define EFUNC_ROUTE_ZHONGTUZHEFAN_UNLOCK ((UINT8)0x94) /* CheckRouteZhefanJiesuo */
#define EFUNC_PART_ROUTE_CMD_PROC ((UINT8)0x95) /*RoutePartApplyLogicManage(正线/试车线部分进路命令处理)*/
#define EFUNC_PART_ROUTE_CMD_PROC_CLD ((UINT8)0x96) /*RoutePartApplyLogicManageCLD（场段部分进路命令处理）*/
/*逻辑进路相关报警函数*/
#define EFUNC_LogRouteOpenManage ((UINT8)0xC1) /*EFUNC_LogRouteOpenManage逻辑进路信号开放处理*/
@@ -210,6 +213,11 @@
#define EFUNC_FIRSTLEAVE_LOGSEC_CHECK ((UINT8)0xD1) /*离去逻辑区段检查RouteLeaveLogSecCheck*/
#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*/
/*************************************************分界线******************************************************************************/
/*************************************************分界线******************************************************************************/
@@ -230,6 +238,8 @@
#define ETYPE_ROUTE_APPLY_SWITCH_CHECK ((UINT8)0x0b) /*进路办理道岔状态检查*/
#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通信*/
@@ -240,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 */
@@ -293,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 */
@@ -313,6 +325,7 @@
#define ETYPE_CANCLE_ZHAOCHA ((UINT8)0x82) /*取消照查继电器*/
#define ETYPE_ZHAOCHA_ROUTE_OVERTIME ((UINT8)0x83) /*进路照查超时*/
#define ETYPE_JKJ_WORK ((UINT8)0x84) /*应急盘有效*/
#define ETYPE_ZHAOCHA_OVERLAP_OVERTIME ((UINT8)0x86) /*保护区段照查超时*/
/* 其他联锁条件检查相关故障类型编码 (UINT8)0x91-(UINT8)0x9f */
/* 设备类型
@@ -379,6 +392,16 @@
#define ETYPE_LOGSEC_XIANSU_STATE ((UINT8)0xC5) /*逻辑区段限速设置*/
#define ETYPE_LOGSEC_FIRSTLOCK_STATE ((UINT8)0xC6) /*逻辑区段为第一个锁闭区段检查*/
#define ETYPE_LOGSEC_CBTC_PROPERTY ((UINT8)0xC7) /*逻辑区段CBTC属性检查*/
#define ETYPE_LOGSEC_CONTINUOUS ((UINT8)0xC8) /*逻辑区段连续性检查*/
/*动态路径故障类型*/
#define ETYPE_PART_ROUTE_RES ((UINT8)0xD0) /*动态路径资源检查*/
#define ETYPE_PART_ROUTE_MATCH_ROUTE ((UINT8)0xD1) /*动态路径匹配进路检查*/
#define ETYPE_PART_ROUTE_SCREEN ((UINT8)0xD2) /*动态路径列车筛选检查*/
#define ETYPE_PART_ROUTE_REPEAT ((UINT8)0xD3) /*动态路径重复办理检查*/
#define ETYPE_PART_ROUTE_SEC_ATTR ((UINT8)0xD4) /*动态路径区段属性检查*/
#define ETYPE_PART_ROUTE_TRAIN_COMM ((UINT8)0xD5) /*动态路径列车通信状态检查*/
#define ETYPE_PART_ROUTE_TRAIN_POS ((UINT8)0xD6) /*动态路径列车位置检查*/
/* 系统故障 */
/* 设备类型 EFUNC_LOGIC_MANAGE_SYETEM */
TSCP/src/APP/ciapp/ESB/ESBDataManage.c
+275
View File
@@ -160,12 +160,17 @@ UINT8 EsbDataManageInit(void)
EsbDataStru[esbId].CutStatus = ESB_CUT_NO; /*ESB旁路未按下*/
EsbDataStru[esbId].EsbRelateRelayDriveState = ESB_PEPUP_ESSUP_INITION_STA; /*PEP和ESS都无效*/
EsbDataStru[esbId].EsbErrorFlag = ESB_ERROR_FLAG_NO; /*自复式ESB未故障*/
EsbDataStru[esbId].EsbRelayDownState = ESB_RELAY_ERROR_DOWN_YES; /*紧急关闭按钮采集继电器落下状态初始化为通信异常落下*/
EsbDataStru[esbId].CancelEsbErrorFlag = ESB_ERROR_FLAG_NO; /*自复式取消ESB未故障*/
EsbDataStru[esbId].EsbPressCycNum = 0U; /*紧急关闭按钮按下周期*/
EsbDataStru[esbId].CancelEsbPressCycNum = 0U; /*取消紧急关闭按钮按下周期*/
EsbDataStru[esbId].CancelEsbErrTriggerPressCycNum = 0U; /*取消紧急关闭按钮误触发按下周期*/
EsbDataStru[esbId].CancelEsbValidFlag = ESB_CANCEL_VALID_NO; /*取消紧急关闭按钮有效标志*/
EsbDataStru[esbId].CancelEsbRelayDownState = ESB_RELAY_ERROR_DOWN_YES; /*取消紧急关闭按钮采集继电器落下状态初始化为通信异常落下*/
EsbDataStru[esbId].EsbCutPressCycNum = 0U; /*紧急关闭旁路按钮按下周期*/
EsbDataStru[esbId].EsbCutErrTriggerPressCycNum = 0U; /*紧急关闭旁路按钮误触发按下周期*/
EsbDataStru[esbId].EsbCutErrorFlag = ESB_ERROR_FLAG_NO; /*紧急关闭旁路按钮未故障*/
EsbDataStru[esbId].EsbCutRelayDownState = ESB_RELAY_ERROR_DOWN_YES; /*紧急关闭旁路按钮采集继电器落下状态初始化为通信异常落下*/
}
rtn = CI_SUCCESS;
return rtn;
@@ -798,3 +803,273 @@ UINT8 GetCancelEsbRelayDownState(const UINT16 esbId)
return reVal;
}
/*
* 功能描述：设置紧急关闭旁路按钮按下周期
* 输入参数：const UINT16 esbId Esb ID
* const UINT32 startCycNum 周期号
* 输出参数：无
* 返 回 值：无
* Cretaed By LQ 2025.03.28
*/
void SetEsbCutPressCycNum(const UINT16 esbId, const UINT32 startCycNum)
{
UINT16 bufIndex = 0U;
bufIndex = GetEsbConfigBufIndex(esbId); /*获取数组下标*/
if (ESB_SUM_MAX > bufIndex)
{
EsbDataStru[bufIndex].EsbCutPressCycNum = startCycNum; /*紧急旁路按钮正常按下起始周期*/
}
else
{
; /*不处理*/
}
}
/*
* 功能描述：获取紧急关闭旁路按钮按下周期
* 输入参数：const UINT16 esbId Esb ID
* 输出参数：无
* 返 回 值：紧急关闭旁路按钮按下周期
* Cretaed By LQ 2025.03.28
*/
UINT32 GetEsbCutPressCycNum(const UINT16 esbId)
{
UINT16 bufIndex = 0u; /*数组下标*/
UINT32 reVal = CI_ERROR;
bufIndex = GetEsbConfigBufIndex(esbId); /*获取数组下标*/
if (ESB_SUM_MAX > bufIndex)
{
reVal = EsbDataStru[bufIndex].EsbCutPressCycNum;
}
else
{
/*下标非法，返回0*/
}
return reVal;
}
/*
* 功能描述：设置紧急关闭旁路按钮误触发按下周期
* 输入参数：const UINT16 esbId Esb ID
* const UINT32 startCycNum 周期号
* 输出参数：无
* 返 回 值：无
* Cretaed By LQ 2025.03.28
*/
void SetEsbCutErrTrigPressCycNum(const UINT16 esbId, const UINT32 startCycNum)
{
UINT16 bufIndex = 0U;
bufIndex = GetEsbConfigBufIndex(esbId); /*获取数组下标*/
if (ESB_SUM_MAX > bufIndex)
{
EsbDataStru[bufIndex].EsbCutErrTriggerPressCycNum = startCycNum; /*紧急旁路按钮误触发按下周期*/
}
else
{
; /*不处理*/
}
}
/*
* 功能描述：获取紧急关闭旁路按钮误触发按下周期
* 输入参数：const UINT16 esbId Esb ID
* 输出参数：无
* 返 回 值：紧急关闭旁路按钮误触发按下周期
* Cretaed By LQ 2025.03.28
*/
UINT32 GetEsbCutErrTrigPressCycNum(const UINT16 esbId)
{
UINT16 bufIndex = 0u; /*数组下标*/
UINT32 reVal = CI_ERROR;
bufIndex = GetEsbConfigBufIndex(esbId); /*获取数组下标*/
if (ESB_SUM_MAX > bufIndex)
{
reVal = EsbDataStru[bufIndex].EsbCutErrTriggerPressCycNum;
}
else
{
/*下标非法，返回0*/
}
return reVal;
}
/*
* 功能描述：设置紧急关闭旁路按钮采集继电器落下状态
* 参数说明：const UINT16 esbId 紧急停车按钮ID
* const UINT8 cRelayDownState 继电器落下状态
* 返回值：无
* Created By LQ 2025.03.28
*/
void SetEsbCutRelayDownState(const UINT16 esbId, const UINT8 cRelayDownState)
{
UINT16 bufIndex = 0U;
bufIndex = GetEsbConfigBufIndex(esbId); /*获取数组下标*/
if (ESB_SUM_MAX > bufIndex)
{
if ((ESB_RELAY_ERROR_DOWN_NO == cRelayDownState) || (ESB_RELAY_ERROR_DOWN_YES == cRelayDownState))
{
EsbDataStru[bufIndex].EsbCutRelayDownState = cRelayDownState;
}
else
{
; /*设置状态不合法，不进项状态更新*/
}
}
else
{
; /*数组下标不合法，不执行状态更新*/
}
}
/*
* 功能描述： 获取紧急关闭旁路按钮采集继电器落下状态
* 参数说明： const UINT16 esbId 紧急停车按钮ID
* 返回值 ： 0: 获取数据失败
* 0x55: 正常落下
* 0xaa: 通信异常落下
* Created By LQ 2025.03.28
*/
UINT8 GetEsbCutRelayDownState(const UINT16 esbId)
{
UINT16 bufIndex = 0U;
UINT8 reVal = CI_ERROR;
bufIndex = GetEsbConfigBufIndex(esbId); /*获取数组下标*/
if (ESB_SUM_MAX > bufIndex)
{
reVal = EsbDataStru[bufIndex].EsbCutRelayDownState;
}
else
{
; /*数组下标不合法，不执行状态更新*/
}
return reVal;
}
/*
* 功能描述：设置指定ID紧急关闭旁路按钮故障标志
* 参数说明：const UINT16 esbId, 紧急关闭按钮ID
* const UINT8 cEsbCutErrFlag 紧急关闭旁路按钮故障标志
* 返回值：无
* Created By LQ 2025.03.28
*/
void SetEsbCutErrFlag(const UINT16 esbId, const UINT8 cEsbCutErrFlag)
{
UINT16 bufIndex = 0U;
bufIndex = GetEsbConfigBufIndex(esbId); /*获取数组下标*/
if (ESB_SUM_MAX > bufIndex)
{
if ((ESB_ERROR_FLAG_NO == cEsbCutErrFlag) || (ESB_ERROR_FLAG_YES == cEsbCutErrFlag))
{
EsbDataStru[bufIndex].EsbCutErrorFlag = cEsbCutErrFlag;
}
else
{
; /*设置状态不合法，不进项状态更新*/
}
}
else
{
; /*数组下标不合法，不执行状态更新*/
}
}
/*
* 功能描述： 获取指定ID紧急关闭旁路按钮故障标志
* 参数说明： const UINT16 esbId, 紧急关闭按钮ID
* 返回值 ： 0: 获取数据失败
* 0x55: 未故障
* 0xaa: 故障
* Created By LQ 2025.03.28
*/
UINT8 GetEsbCutErrFlag(const UINT16 esbId)
{
UINT16 bufIndex = 0U;
UINT8 reVal = CI_ERROR;
bufIndex = GetEsbConfigBufIndex(esbId); /*获取数组下标*/
if (bufIndex < ESB_SUM_MAX)
{
reVal = EsbDataStru[bufIndex].EsbCutErrorFlag;
}
else
{
; /*数组下标不合法，不执行状态更新*/
}
return reVal;
}
/*
* 功能描述：设置紧急停车按钮采集继电器落下状态
* 参数说明：const UINT16 esbId 紧急停车按钮ID
* const UINT8 cRelayDownState 继电器落下状态
* 返回值：无
* Created By LQ 2025.04.01
*/
void SetEsbRelayDownState(const UINT16 esbId, const UINT8 cRelayDownState)
{
UINT16 bufIndex = 0U;
bufIndex = GetEsbConfigBufIndex(esbId); /*获取数组下标*/
if (ESB_SUM_MAX > bufIndex)
{
if ((ESB_RELAY_ERROR_DOWN_NO == cRelayDownState) || (ESB_RELAY_ERROR_DOWN_YES == cRelayDownState))
{
EsbDataStru[bufIndex].EsbRelayDownState = cRelayDownState;
}
else
{
; /*设置状态不合法，不进项状态更新*/
}
}
else
{
; /*数组下标不合法，不执行状态更新*/
}
}
/*
* 功能描述： 获取紧急停车按钮采集继电器落下状态
* 参数说明： const UINT16 esbId, 紧急停车按钮ID
* 返回值 ： 0: 获取数据失败
* 0x55: 正常落下
* 0xaa: 通信异常落下
* Created By LQ 2025.04.01
*/
UINT8 GetEsbRelayDownState(const UINT16 esbId)
{
UINT16 bufIndex = 0U;
UINT8 reVal = CI_ERROR;
bufIndex = GetEsbConfigBufIndex(esbId); /*获取数组下标*/
if (ESB_SUM_MAX > bufIndex)
{
reVal = EsbDataStru[bufIndex].EsbRelayDownState;
}
else
{
; /*数组下标不合法，不执行状态更新*/
}
return reVal;
}
TSCP/src/APP/ciapp/ESB/ESBDataManage.h
+97
View File
@@ -38,12 +38,17 @@ typedef struct S_EsbDataStruct
UINT8 EssSteadyState; /*ESS稳灯状态（用于虚拟联锁向ATS反馈）--0x55 需要设置稳灯；0xaa不需要设置稳灯*/
UINT8 EssFlashState; /*ESS闪灯状态（用于虚拟联锁向ATS反馈）--0x55 需要设置闪灯；0xaa不需要设置闪灯*/
UINT8 EsbErrorFlag; /*自复式紧急停车按钮故障标志，0x55未故障，0xaa故障*/
UINT8 EsbRelayDownState; /*紧急关闭按钮采集继电器落下状态，0x55：正常采集落下，0xaa：通信异常落下*/
UINT8 CancelEsbErrorFlag; /*自复式取消紧急停车按钮故障标志，0x55未故障，0xaa故障*/
UINT32 EsbPressCycNum; /*紧急关闭按钮按下周期*/
UINT32 CancelEsbPressCycNum; /*取消紧急关闭按钮正常按下周期*/
UINT32 CancelEsbErrTriggerPressCycNum; /*取消紧急关闭按钮误触发按下周期*/
UINT8 CancelEsbValidFlag; /*取消紧急关闭按钮有效标志，0x55无效，0xaa有效*/
UINT8 CancelEsbRelayDownState; /*取消紧急关闭按钮采集继电器落下状态，0x55：正常采集落下，0xaa：通信异常落下*/
UINT32 EsbCutPressCycNum; /*紧急关闭旁路按钮正常按下周期*/
UINT32 EsbCutErrTriggerPressCycNum; /*紧急关闭旁路按钮误触发按下周期*/
UINT8 EsbCutErrorFlag; /*紧急关闭旁路按钮故障标志，0x55-未故障，0xaa-故障*/
UINT8 EsbCutRelayDownState; /*紧急关闭旁路按钮采集继电器落下状态，0x55-正常采集落下，0xaa-通信异常落下*/
} EsbDataStruct;
/*******************************全局变量声明*******************************/
@@ -310,6 +315,98 @@ void SetCancelEsbRelayDownState(const UINT16 esbId, const UINT8 cRelayDownState)
*/
UINT8 GetCancelEsbRelayDownState(const UINT16 esbId);
/*
* 功能描述：设置紧急关闭旁路按钮按下周期
* 输入参数：const UINT16 esbId Esb ID
* const UINT32 startCycNum 周期号
* 输出参数：无
* 返 回 值：无
* Cretaed By LQ 2025.03.28
*/
void SetEsbCutPressCycNum(const UINT16 esbId, const UINT32 startCycNum);
/*
* 功能描述：获取紧急关闭旁路按钮按下周期
* 输入参数：const UINT16 esbId Esb ID
* 输出参数：无
* 返 回 值：紧急关闭旁路按钮按下周期
* Cretaed By LQ 2025.03.28
*/
UINT32 GetEsbCutPressCycNum(const UINT16 esbId);
/*
* 功能描述：设置紧急关闭旁路按钮误触发按下周期
* 输入参数：const UINT16 esbId Esb ID
* const UINT32 startCycNum 周期号
* 输出参数：无
* 返 回 值：无
* Cretaed By LQ 2025.03.28
*/
void SetEsbCutErrTrigPressCycNum(const UINT16 esbId, const UINT32 startCycNum);
/*
* 功能描述：获取紧急关闭旁路按钮误触发按下周期
* 输入参数：const UINT16 esbId Esb ID
* 输出参数：无
* 返 回 值：紧急关闭旁路按钮误触发按下周期
* Cretaed By LQ 2025.03.28
*/
UINT32 GetEsbCutErrTrigPressCycNum(const UINT16 esbId);
/*
* 功能描述：设置紧急关闭旁路按钮采集继电器落下状态
* 参数说明：const UINT16 esbId 紧急停车按钮ID
* const UINT8 cRelayDownState 继电器落下状态
* 返回值：无
* Created By LQ 2025.03.28
*/
void SetEsbCutRelayDownState(const UINT16 esbId, const UINT8 cRelayDownState);
/*
* 功能描述： 获取紧急关闭旁路按钮采集继电器落下状态
* 参数说明： const UINT16 esbId 紧急停车按钮ID
* 返回值 ： 0: 获取数据失败
* 0x55: 正常落下
* 0xaa: 通信异常落下
* Created By LQ 2025.03.28
*/
UINT8 GetEsbCutRelayDownState(const UINT16 esbId);
/*
* 功能描述：设置指定ID紧急关闭旁路按钮故障标志
* 参数说明：const UINT16 esbId, 紧急关闭按钮ID
* const UINT8 cEsbCutErrFlag 紧急关闭旁路按钮故障标志
* 返回值：无
*/
void SetEsbCutErrFlag(const UINT16 esbId, const UINT8 cEsbCutErrFlag);
/*
* 功能描述： 获取指定ID紧急关闭旁路按钮故障标志
* 参数说明： const UINT16 esbId, 紧急关闭按钮ID
* 返回值 ： 0: 获取数据失败
* >0: 紧停旁路按钮故障标志
*/
UINT8 GetEsbCutErrFlag(const UINT16 esbId);
/*
* 功能描述：设置紧急停车按钮采集继电器落下状态
* 参数说明：const UINT16 esbId 紧急停车按钮ID
* const UINT8 cRelayDownState 继电器落下状态
* 返回值：无
* Created By LQ 2025.04.01
*/
void SetEsbRelayDownState(const UINT16 esbId, const UINT8 cRelayDownState);
/*
* 功能描述： 获取紧急停车按钮采集继电器落下状态
* 参数说明： const UINT16 esbId, 紧急停车按钮ID
* 返回值 ： 0: 获取数据失败
* 0x55: 正常落下
* 0xaa: 通信异常落下
* Created By LQ 2025.04.01
*/
UINT8 GetEsbRelayDownState(const UINT16 esbId);
#ifdef __cplusplus
}
#endif
TSCP/src/APP/ciapp/EnvelopeManage/CTEnvelopeTrack.c
+184 -60
View File
@@ -1161,7 +1161,7 @@ void elm_CTEnvelopeTrack(void)
}
else if ((CI_SUCCESS == funRet) && (1u == relEnvelopeCnt))
{
/* 只有CT包络才设计B轨UT可追踪功能*/
/* 只有CT包络才涉及B轨UT可追踪功能*/
elm_DealNoCGFollowUt(relEnvelopeID[0u], trainID[cycle]);
/** 维护日志--调试级别*/
@@ -1277,16 +1277,9 @@ void elm_DealNoCGFollowUt(UINT16 wEnvelopeID,UINT16 wTrainId)
const EnvelopeStruct* pEnvelop = NULL;
UINT8 chNoCGFollowUtSwitch = 0U;
ELM_TrainSafeLocStruct safeLoc = { 0U }; /*列车安全位置*/
UINT8 chLinkRelPhySecAGorBGAttr = 0U;/*LINK关联物理区段ABD属性*/
UINT8 chEnvelopLinkABGAttr = 0U;/*包络相关LINK关联物理区段ABG属性*/
UINT16 wLinkRelatedPhySec = 0U;/*LINK关联物理区段*/
UINT8 chPhyLjkFlag = 0U;/*列检库属性*/
UINT16 wTrainEnterLjkLinkId = 0U;/*列车进入列检库LINK ID*/
UINT32 dwCycNum = 0U;/*当前周期号*/
UINT16 wTempTrainID = 0U;/*临时记录列车ID*/
UINT8 chTempVirHeadScreenFlag = 0U;/*临时虚拟前筛标志*/
UINT8 chTempVirTailScreenFlag = 0U;/*临时虚拟后筛标志*/
UINT8 chAgLinkExistRelCgFlag = 0U;/*AG是否存在CG标志*/
/** 获取列车包络 */
pEnvelop = elm_GetEnvelopeInfoPtr(wEnvelopeID);
@@ -1323,58 +1316,10 @@ void elm_DealNoCGFollowUt(UINT16 wEnvelopeID,UINT16 wTrainId)
{
if (0U == errorCode)
{
chLinkRelPhySecAGorBGAttr = GetLinkRelPhySecAGorBGAttr(safeLoc.endPos.Lnk);
chEnvelopLinkABGAttr = GetLinkRelPhySecAGorBGAttr(pEnvelop->endPos.Lnk);
wLinkRelatedPhySec = GetLinkRelatedPhySec(pEnvelop->endPos.Lnk);
chPhyLjkFlag = GetPhySecLjkFlag(wLinkRelatedPhySec);
chAgLinkExistRelCgFlag = GetAgLinkExistRelCgFlag(safeLoc.endPos.Lnk);
/*包络刷新在后，所以此时虽然安全位置进入AG，但包络可能还没进入*/
if ((LINK_REL_PHYSEC_AG == chLinkRelPhySecAGorBGAttr) && (0U == pEnvelop->headTrainID)
&& (LINK_REL_PHYSEC_DEFAULT == chEnvelopLinkABGAttr) && (PHYSICAL_SECTION_LJK_NO == chPhyLjkFlag)
&& (AGLINK_EXIST_REL_CG_NO == chAgLinkExistRelCgFlag))
{
/*列车安全车头驶入AG且当前驶入前没有前端可疑且不是从BG过来的车且不存在CG便设置前筛通过标志有效*/
SetTrainVirHeadScreenPassFlag(wTrainId,TRAIN_VIR_SCREEN_PASS_FLAG_VALID);
SetTrainEnterLjkLinkId(wTrainId, safeLoc.endPos.Lnk);
}
else
{
; /*不设置对应标志，安全位置和包络均进入AG维持原来的标志*/
}
chLinkRelPhySecAGorBGAttr = GetLinkRelPhySecAGorBGAttr(safeLoc.startPos.Lnk);
chEnvelopLinkABGAttr = GetLinkRelPhySecAGorBGAttr(pEnvelop->startPos.Lnk);
wLinkRelatedPhySec = GetLinkRelatedPhySec(pEnvelop->startPos.Lnk);
chPhyLjkFlag = GetPhySecLjkFlag(wLinkRelatedPhySec);
chAgLinkExistRelCgFlag = GetAgLinkExistRelCgFlag(safeLoc.startPos.Lnk);
/*包络刷新在后，所以此时虽然安全位置进入AG，但包络可能还没进入*/
if ((LINK_REL_PHYSEC_AG == chLinkRelPhySecAGorBGAttr) && (0U == pEnvelop->tailTrainID)
&& (LINK_REL_PHYSEC_DEFAULT == chEnvelopLinkABGAttr) && (PHYSICAL_SECTION_LJK_NO == chPhyLjkFlag)
&& (AGLINK_EXIST_REL_CG_NO == chAgLinkExistRelCgFlag))
{
/*列车安全车尾驶入AG且当前驶入前没有后端可疑且不是从BG过来的车且不存在CG便设置后筛通过标志有效*/
SetTrainVirTailScreenPassFlag(wTrainId, TRAIN_VIR_SCREEN_PASS_FLAG_VALID);
SetTrainEnterLjkLinkId(wTrainId, safeLoc.startPos.Lnk);
}
else
{
; /*不设置对应标志，安全位置和包络均进入AG维持原来的标志*/
}
wTrainEnterLjkLinkId = GetTrainEnterLjkLinkId(wTrainId);
/*列车包络完全进入A轨后，容忍占用到空闲时间，D轨出现计轴区段（道岔位置连通在D轨）采集占用，设置前筛通过标识、后筛通过标识无效*/
if ((LINK_REL_PHYSEC_AG == chLinkRelPhySecAGorBGAttr) && (safeLoc.startPos.Lnk == safeLoc.endPos.Lnk)
&& (safeLoc.startPos.Lnk == wTrainEnterLjkLinkId) && (AGLINK_EXIST_REL_CG_NO == chAgLinkExistRelCgFlag))
{
dwCycNum = Get2oo2CurCycleNum();
SetTrainFullEnterLjkCycNum(wTrainId, dwCycNum);
}
else
{
;
}
/*处理AG虚拟筛选标志*/
elm_DealAgVirScreenFlag(wEnvelopeID, wTrainId);
/*处理BG虚拟筛选标志*/
elm_DealBgVirScreenFlag(wEnvelopeID, wTrainId);
}
else
{
@@ -1572,3 +1517,182 @@ void elm_VirScreenPassMonitor(void)
}
}
}
/**
* @brief 处理AG虚拟筛选标志
* @param[in] UINT16 envelopeID 列车包络
* @param[in] UINT16 wTrainId 列车ID
* @return 无
* @note by cgh 20250805
*/
void elm_DealAgVirScreenFlag(UINT16 wEnvelopeID, UINT16 wTrainId)
{
UINT8 funRet = CI_ERROR;
const EnvelopeStruct* pEnvelop = NULL;
ELM_TrainSafeLocStruct safeLoc = { 0U }; /*列车安全位置*/
UINT8 chLinkRelPhySecAGorBGAttr = 0U;/*LINK关联物理区段ABG属性*/
UINT8 chEnvelopLinkABGAttr = 0U;/*包络相关LINK关联物理区段ABG属性*/
UINT16 wLinkRelatedPhySec = 0U;/*LINK关联物理区段*/
UINT8 chPhyLjkFlag = 0U;/*列检库属性*/
UINT16 wTrainEnterLjkLinkId = 0U;/*列车进入列检库LINK ID*/
UINT32 dwCycNum = 0U;/*当前周期号*/
UINT8 chAgLinkExistRelCgFlag = 0U;/*AG是否存在CG标志*/
/** 获取列车包络 */
pEnvelop = elm_GetEnvelopeInfoPtr(wEnvelopeID);
/** 入口参数校验 */
if ((NULL != pEnvelop) && (0U < wTrainId) && (LINE_MAX_TRAIN > wTrainId))
{
funRet = elm_PrepareTrainSafeLoc(wTrainId, &safeLoc);
if (CI_SUCCESS == funRet)
{
chLinkRelPhySecAGorBGAttr = GetLinkRelPhySecAGorBGAttr(safeLoc.endPos.Lnk);
chEnvelopLinkABGAttr = GetLinkRelPhySecAGorBGAttr(pEnvelop->endPos.Lnk);
wLinkRelatedPhySec = GetLinkRelatedPhySec(pEnvelop->endPos.Lnk);
chPhyLjkFlag = GetPhySecLjkFlag(wLinkRelatedPhySec);
chAgLinkExistRelCgFlag = GetAgLinkExistRelCgFlag(safeLoc.endPos.Lnk);
/*包络刷新在后，所以此时虽然安全位置进入AG，但包络可能还没进入*/
if ((LINK_REL_PHYSEC_AG == chLinkRelPhySecAGorBGAttr) && (0U == pEnvelop->headTrainID)
&& (LINK_REL_PHYSEC_DEFAULT == chEnvelopLinkABGAttr) && (PHYSICAL_SECTION_LJK_NO == chPhyLjkFlag)
&& (AGLINK_EXIST_REL_CG_NO == chAgLinkExistRelCgFlag))
{
/*列车安全车头驶入AG且当前驶入前没有前端可疑且不是从BG过来的车且不存在CG便设置前筛通过标志有效*/
SetTrainVirHeadScreenPassFlag(wTrainId, TRAIN_VIR_SCREEN_PASS_FLAG_VALID);
SetTrainEnterLjkLinkId(wTrainId, safeLoc.endPos.Lnk);
}
else
{
; /*不设置对应标志，安全位置和包络均进入AG维持原来的标志*/
}
chLinkRelPhySecAGorBGAttr = GetLinkRelPhySecAGorBGAttr(safeLoc.startPos.Lnk);
chEnvelopLinkABGAttr = GetLinkRelPhySecAGorBGAttr(pEnvelop->startPos.Lnk);
wLinkRelatedPhySec = GetLinkRelatedPhySec(pEnvelop->startPos.Lnk);
chPhyLjkFlag = GetPhySecLjkFlag(wLinkRelatedPhySec);
chAgLinkExistRelCgFlag = GetAgLinkExistRelCgFlag(safeLoc.startPos.Lnk);
/*包络刷新在后，所以此时虽然安全位置进入AG，但包络可能还没进入*/
if ((LINK_REL_PHYSEC_AG == chLinkRelPhySecAGorBGAttr) && (0U == pEnvelop->tailTrainID)
&& (LINK_REL_PHYSEC_DEFAULT == chEnvelopLinkABGAttr) && (PHYSICAL_SECTION_LJK_NO == chPhyLjkFlag)
&& (AGLINK_EXIST_REL_CG_NO == chAgLinkExistRelCgFlag))
{
/*列车安全车尾驶入AG且当前驶入前没有后端可疑且不是从BG过来的车且不存在CG便设置后筛通过标志有效*/
SetTrainVirTailScreenPassFlag(wTrainId, TRAIN_VIR_SCREEN_PASS_FLAG_VALID);
SetTrainEnterLjkLinkId(wTrainId, safeLoc.startPos.Lnk);
}
else
{
; /*不设置对应标志，安全位置和包络均进入AG维持原来的标志*/
}
wTrainEnterLjkLinkId = GetTrainEnterLjkLinkId(wTrainId);
/*列车包络完全进入A轨后，容忍占用到空闲时间，D轨出现计轴区段（道岔位置连通在D轨）采集占用，设置前筛通过标识、后筛通过标识无效*/
if ((LINK_REL_PHYSEC_AG == chLinkRelPhySecAGorBGAttr) && (safeLoc.startPos.Lnk == safeLoc.endPos.Lnk)
&& (safeLoc.startPos.Lnk == wTrainEnterLjkLinkId) && (AGLINK_EXIST_REL_CG_NO == chAgLinkExistRelCgFlag))
{
dwCycNum = Get2oo2CurCycleNum();
SetTrainFullEnterLjkCycNum(wTrainId, dwCycNum);
}
else
{
;
}
}
else
{
SetTrainVirHeadScreenPassFlag(wTrainId, TRAIN_VIR_SCREEN_PASS_FLAG_INVALID);
SetTrainVirTailScreenPassFlag(wTrainId, TRAIN_VIR_SCREEN_PASS_FLAG_INVALID);
SetTrainFullEnterLjkCycNum(wTrainId, 0U);
SetTrainEnterLjkLinkId(wTrainId, 0U);
}
}
else
{
;
}
}
/**
* @brief 处理BG虚拟筛选标志
* @param[in] UINT16 envelopeID 列车包络
* @param[in] UINT16 wTrainId 列车ID
* @return 无
* @note by cgh 20250805
*/
void elm_DealBgVirScreenFlag(UINT16 wEnvelopeID, UINT16 wTrainId)
{
UINT8 funRet = CI_ERROR;
const EnvelopeStruct* pEnvelop = NULL;
ELM_TrainSafeLocStruct safeLoc = { 0U }; /*列车安全位置*/
UINT8 chLinkRelPhySecAGorBGAttr = 0U;/*LINK关联物理区段ABG属性*/
UINT8 chEnvelopLinkABGAttr = 0U;/*包络相关LINK关联物理区段ABG属性*/
UINT8 chAgLinkExistRelCgFlag = 0U;/*AG是否存在CG标志*/
/** 获取列车包络 */
pEnvelop = elm_GetEnvelopeInfoPtr(wEnvelopeID);
/** 入口参数校验 */
if ((NULL != pEnvelop) && (0U < wTrainId) && (LINE_MAX_TRAIN > wTrainId))
{
funRet = elm_PrepareTrainSafeLoc(wTrainId, &safeLoc);
if (CI_SUCCESS == funRet)
{
chLinkRelPhySecAGorBGAttr = GetLinkRelPhySecAGorBGAttr(safeLoc.endPos.Lnk);
chEnvelopLinkABGAttr = GetLinkRelPhySecAGorBGAttr(pEnvelop->endPos.Lnk);
chAgLinkExistRelCgFlag = GetAgLinkExistRelCgFlag(pEnvelop->endPos.Lnk);
/*包络刷新在后，所以此时虽然安全位置进入BG，但包络可能还没进入*/
if ((LINK_REL_PHYSEC_BG == chLinkRelPhySecAGorBGAttr) && (0U == pEnvelop->headTrainID)
&& (LINK_REL_PHYSEC_AG == chEnvelopLinkABGAttr) && (AGLINK_EXIST_REL_CG_NO == chAgLinkExistRelCgFlag))
{
/*列车安全车头驶入BG且当前驶入前没有前端可疑且是从AG过来的车且不存在CG便设置前筛通过标志有效*/
SetTrainVirHeadScreenPassFlag(wTrainId, TRAIN_VIR_SCREEN_PASS_FLAG_INVALID);
SetTrainVirTailScreenPassFlag(wTrainId, TRAIN_VIR_SCREEN_PASS_FLAG_INVALID);
SetTrainFullEnterLjkCycNum(wTrainId, 0U);
SetTrainEnterLjkLinkId(wTrainId, 0U);
/*先清除再设置，仅为了逻辑清晰一些*/
SetTrainVirHeadScreenPassFlag(wTrainId, TRAIN_VIR_SCREEN_PASS_FLAG_VALID);
SetTrainEnterLjkLinkId(wTrainId, safeLoc.endPos.Lnk);
}
else
{
; /*不设置对应标志，安全位置和包络均进入BG维持原来的标志*/
}
chLinkRelPhySecAGorBGAttr = GetLinkRelPhySecAGorBGAttr(safeLoc.startPos.Lnk);
chEnvelopLinkABGAttr = GetLinkRelPhySecAGorBGAttr(pEnvelop->startPos.Lnk);
chAgLinkExistRelCgFlag = GetAgLinkExistRelCgFlag(pEnvelop->startPos.Lnk);
/*包络刷新在后，所以此时虽然安全位置进入BG，但包络可能还没进入*/
if ((LINK_REL_PHYSEC_BG == chLinkRelPhySecAGorBGAttr) && (0U == pEnvelop->tailTrainID)
&& (LINK_REL_PHYSEC_AG == chEnvelopLinkABGAttr) && (AGLINK_EXIST_REL_CG_NO == chAgLinkExistRelCgFlag))
{
/*列车安全车尾驶入BG且当前驶入前没有后端可疑且是从AG过来的车且不存在CG便设置后筛通过标志有效*/
SetTrainFullEnterLjkCycNum(wTrainId, 0U);
SetTrainEnterLjkLinkId(wTrainId, 0U);
/*先清除再设置，仅为了逻辑清晰一些*/
SetTrainVirTailScreenPassFlag(wTrainId, TRAIN_VIR_SCREEN_PASS_FLAG_VALID);
SetTrainEnterLjkLinkId(wTrainId, safeLoc.startPos.Lnk);
}
else
{
; /*不设置对应标志，安全位置和包络均进入AG维持原来的标志*/
}
}
else
{
SetTrainVirHeadScreenPassFlag(wTrainId, TRAIN_VIR_SCREEN_PASS_FLAG_INVALID);
SetTrainVirTailScreenPassFlag(wTrainId, TRAIN_VIR_SCREEN_PASS_FLAG_INVALID);
SetTrainFullEnterLjkCycNum(wTrainId, 0U);
SetTrainEnterLjkLinkId(wTrainId, 0U);
}
}
else
{
;
}
}
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
+59 -66
View File
@@ -106,7 +106,7 @@ static UINT8 elm_UKTAdjacentSwProtect(void)
nearTrainType = aam_SearchNearbyTrainType(pACIdbuff[cycleAc], EMAP_SAME_DIR, acSameCnt, acSameID);
}
if (AAM_BAD_NEAR == nearTrainType)
if ((AAM_BAD_NEAR == nearTrainType)|| (AAM_SLEEP_OCC == nearTrainType))
{
elm_PrepareClearSwPassTrainFlag(pACIdbuff[cycleAc]);
ELM_LOG(ELM_LOG_FATAL,"info:Switch Zone AC%d Clear CT pass flag by PreAC UT.\n",pACIdbuff[cycleAc]);
@@ -116,7 +116,7 @@ static UINT8 elm_UKTAdjacentSwProtect(void)
/** 查询前方计轴接近车类型*/
nearTrainType = aam_SearchNearbyTrainType(pACIdbuff[cycleAc],EMAP_CONVER_DIR,acConvertCnt,acConvertID);
if (AAM_BAD_NEAR == nearTrainType)
if ((AAM_BAD_NEAR == nearTrainType) || (AAM_SLEEP_OCC == nearTrainType))
{
elm_PrepareClearSwPassTrainFlag(pACIdbuff[cycleAc]);
ELM_LOG(ELM_LOG_FATAL,"info:Switch Zone AC%d Clear CT pass flag by backAC UT.\n",pACIdbuff[cycleAc]);
@@ -2036,6 +2036,8 @@ void elm_SafeProtectProcess(void)
UINT8 workFlag = ELM_WORK_ERROR;
UINT8 funRet = CI_ERROR;
UINT32 errorCode = 0u;
UINT8 localCiType = 0U;
UINT8 ciTrainTestState = 0U;
/** 包络管理模块可正常处理标志位 */
workFlag = elm_GetELMWorkFlag();
@@ -2055,8 +2057,17 @@ void elm_SafeProtectProcess(void)
funRet = elm_UTLosingProtect();
ASSER_ERROR(CI_ERROR == funRet,errorCode,0x40000000u);
/** CT/UCT车飞车防护--宕机防护*/
elm_FlyingProtect();
localCiType = GetLocalCiType();
ciTrainTestState = GetCiTrainTestStatus();
if ((CI_TYPE_SCX == localCiType) && ((CI_TRAIN_TEST_OFF == ciTrainTestState) || (CI_TRAIN_TEST_STOP == ciTrainTestState)))
{
ScxClearFlyProtectInfo(); /*试车线在未试车期间，不进行飞车宕机防护处理，同时清除之前的飞车信息，修复CT驶出试车线导致飞车宕机问题*/
}
else
{
/** CT/UCT车飞车防护--宕机防护*/
elm_FlyingProtect();
}
/** 本OC范围内的计轴映射表合法性校验 */
funRet = elm_ACRelEnvelopeCheck();
@@ -2595,6 +2606,7 @@ UINT8 elm_UCTEnvelopeLeaveAC(UINT8 flag,IN const EnvelopeStruct* pEnvelope,UINT1
UINT16 relEnvelopeID[TRAIN_REL_ENVELOPE_SUM_MAX] = {0u}; /*列车关联的包络索引*/
const EnvelopeStruct *pEnvelopeInfo = NULL;
const WLTrainStatusInfoStruct* pTemp = NULL;
UINT8 chTrainNvramPosFlag = 0U; /*列车NVRAM位置标识*/
/* 将本周期的的状态设置成上周期的状态 */
for (cycle = 1u; cycle < LINE_MAX_TRAIN; cycle++)
@@ -2640,10 +2652,19 @@ UINT8 elm_UCTEnvelopeLeaveAC(UINT8 flag,IN const EnvelopeStruct* pEnvelope,UINT1
if ((NULL != pEnvelopeInfo) &&
((TYPE_CT_ENVELOPE == pEnvelopeInfo->envelopeType) || (TYPE_UCT_ENVELOPE == pEnvelopeInfo->envelopeType)))
{
headNeedScreen = LINE_MAX_TRAIN == pEnvelopeInfo->headTrainID ? NEED_SCREEN : UNNEED_SCREEN;
tailNeedScreen = LINE_MAX_TRAIN == pEnvelopeInfo->tailTrainID ? NEED_SCREEN : UNNEED_SCREEN;
chTrainNvramPosFlag = GetTrainNvramPosFlag(cycle);
wls_SetTrainControlStatus(cycle,IN_CONTROL_STATUS,headNeedScreen,tailNeedScreen);
if (TRAIN_NVRAM_POS_FLAG_NO == chTrainNvramPosFlag)
{
headNeedScreen = LINE_MAX_TRAIN == pEnvelopeInfo->headTrainID ? NEED_SCREEN : UNNEED_SCREEN;
tailNeedScreen = LINE_MAX_TRAIN == pEnvelopeInfo->tailTrainID ? NEED_SCREEN : UNNEED_SCREEN;
wls_SetTrainControlStatus(cycle, IN_CONTROL_STATUS, headNeedScreen, tailNeedScreen);
}
else
{
ELM_LOG(ELM_LOG_FATAL, " not Add In Control Train,Because UseNvram Pos\n");
}
}
else
{
@@ -2764,25 +2785,24 @@ UINT8 elm_UCTEnvelopeLeaveAC(UINT8 flag,IN const EnvelopeStruct* pEnvelope,UINT1
* @return CI_ERROR 查询失败
CI_SUCCESS 查询成功
* @note
* by cgh 20240514 目前只用于RRM
* edit cgh 20250724 目前只用于RRM
*/
UINT8 elm_GetNearEnvelopRelSameTra(UINT16 envelopeId, OUT UINT16* preEnvelope, OUT UINT16* backEnvelope)
{
/*- 局部变量定义 */
UINT8 ret = CI_ERROR;
UINT8 funRet = CI_ERROR;
UINT32 errorCode = 0u; /*错误码*/
UINT32 errorCode = 0U; /*错误码*/
const EnvelopeStruct* pEnvelop = NULL;
UINT8 envelopeCnt = 0u; /* 包络数量 */
UINT16 arEnvelopID[TRAIN_SUM_MAX_IN_OC] = { 0u }; /*包络ID数组*/
UINT16 acCnt = 0u; /** 前方计轴数量*/
UINT16 acID[AC_MAXCNT_IN_SWITCH * AC_MAXCNT_IN_SWITCH] = { 0u };
UINT8 acStatus = ELM_AC_OCC;
UINT16 mergeACIndex = 0u;
UINT8 envelopeCnt = 0U; /* 包络数量 */
UINT16 arEnvelopID[TRAIN_SUM_MAX_IN_OC] = { 0U }; /*包络ID数组*/
UINT16 acCnt = 0U; /** 前方计轴数量*/
UINT16 acID[AC_MAXCNT_IN_SWITCH * AC_MAXCNT_IN_SWITCH] = { 0U };
UINT16 mergeACIndex = 0U;
UINT16 mergeACCntMax = (SECTION_IN_ENVELOPE_SUM_MAX + 2U * AC_MAXCNT_IN_SWITCH * AC_MAXCNT_IN_SWITCH);
UINT16 mergeACID[SECTION_IN_ENVELOPE_SUM_MAX + 2U * AC_MAXCNT_IN_SWITCH * AC_MAXCNT_IN_SWITCH] = { 0u };
UINT8 includeCnt = 0u;
UINT16 includeELMid[TRAIN_SUM_MAX_IN_OC] = { 0u }; /** 重合的包络id */
UINT16 mergeACID[SECTION_IN_ENVELOPE_SUM_MAX + 2U * AC_MAXCNT_IN_SWITCH * AC_MAXCNT_IN_SWITCH] = { 0U };
UINT8 includeCnt = 0U;
UINT16 includeELMid[TRAIN_SUM_MAX_IN_OC] = { 0U }; /** 重合的包络id */
/** 获取列车包络 */
pEnvelop = elm_GetEnvelopeInfoPtr(envelopeId);
@@ -2791,63 +2811,36 @@ UINT8 elm_UCTEnvelopeLeaveAC(UINT8 flag,IN const EnvelopeStruct* pEnvelope,UINT1
if ((NULL == pEnvelop) || (NULL == preEnvelope) || (NULL == backEnvelope))
{
/** 设置错误码*/
ASSER_ERROR(CI_ERROR == funRet, errorCode, 0x08000000u);
ASSER_ERROR(CI_ERROR == funRet, errorCode, 0x80000000U);
}
else
{
/** 获取车尾包络计轴占用状态 */
acStatus = elm_PrepareACStatus(pEnvelop->ACID[0]);
/* 查询后方计轴区段*/
acCnt = elm_GetEnvelopTailACIDs(pEnvelop, acID);
/** 判断包络尾是否占用，如果占用，则需要查询下一个计轴*/
if (ELM_AC_OCC == acStatus)
/** 合并车尾后方的计轴 */
mergeACIndex = elm_PrepareMergeUINT16Array(mergeACID, mergeACCntMax, mergeACIndex, acID, (AC_MAXCNT_IN_SWITCH * AC_MAXCNT_IN_SWITCH), acCnt);
/** 合并包络包含的计轴区段 */
mergeACIndex = elm_PrepareMergeUINT16Array(mergeACID, mergeACCntMax, mergeACIndex, pEnvelop->ACID, SECTION_IN_ENVELOPE_SUM_MAX, pEnvelop->ACCnt);
/** 设置错误码*/
ASSER_ERROR(mergeACIndex > mergeACCntMax, errorCode, 0x40000000U);
if (0U == errorCode)
{
/* 查询后方计轴，车尾计轴占用，存在道岔四开，为了确保能然后后端，需要查询安全车尾所属计轴的相邻计轴区段*/
acCnt = elm_GetEnvelopTailACIDs(pEnvelop, acID);
(void)CommonMemSet(&acID, (UINT32)((AC_MAXCNT_IN_SWITCH*AC_MAXCNT_IN_SWITCH)*sizeof(UINT16)),0U, (UINT32)((AC_MAXCNT_IN_SWITCH*AC_MAXCNT_IN_SWITCH)*sizeof(UINT16)));/*先清空数组防止脏数据*/
/* 查询前方计轴*/
acCnt = elm_GetEnvelopHeadACIDs(pEnvelop, acID);
/** 合并车尾后方的计轴 */
/** 合并车头前方的计轴 */
mergeACIndex = elm_PrepareMergeUINT16Array(mergeACID, mergeACCntMax, mergeACIndex, acID, (AC_MAXCNT_IN_SWITCH * AC_MAXCNT_IN_SWITCH), acCnt);
/** 先合并包络包含的计轴区段 */
mergeACIndex = elm_PrepareMergeUINT16Array(mergeACID, mergeACCntMax, mergeACIndex, pEnvelop->ACID, SECTION_IN_ENVELOPE_SUM_MAX, pEnvelop->ACCnt);
/** 设置错误码*/
ASSER_ERROR(mergeACIndex > mergeACCntMax, errorCode, 0x04000000u);
}
else
{
/** 先合并包络包含的计轴区段 */
mergeACIndex = elm_PrepareMergeUINT16Array(mergeACID, mergeACCntMax, mergeACIndex, pEnvelop->ACID, SECTION_IN_ENVELOPE_SUM_MAX, pEnvelop->ACCnt);
/** 设置错误码*/
ASSER_ERROR(mergeACIndex > mergeACCntMax, errorCode, 0x02000000u);
}
if (0u == errorCode)
{
/** 获取车头包络计轴占用状态 */
acStatus = elm_PrepareACStatus(pEnvelop->ACID[pEnvelop->ACCnt - 1U]);
/** 判断包络头是否占用，如果占用，则需要查询下一个计轴 */
if (ELM_AC_OCC == acStatus)
{
/* 查询前方计轴,此处查询四开道岔的相邻计轴其实属于一个冗余的处理，因为如果车头压入了岔区且占用，直接进行了删车，但是此处再这样处理一个是为了统一设计，另外做一个冗余防护*/
acCnt = elm_GetEnvelopHeadACIDs(pEnvelop, acID);
/** 合并车头前方的计轴 */
mergeACIndex = elm_PrepareMergeUINT16Array(mergeACID, mergeACCntMax, mergeACIndex, acID, (AC_MAXCNT_IN_SWITCH * AC_MAXCNT_IN_SWITCH), acCnt);
/** 设置错误码*/
ASSER_ERROR(mergeACIndex > mergeACCntMax, errorCode, 0x04000000u);
}
else
{
/** 无需处理*/
}
ASSER_ERROR(mergeACIndex > mergeACCntMax, errorCode, 0x20000000U);
/** 判断是否处理成功 */
if (0u == errorCode)
if (0U == errorCode)
{
/** 获取前方计轴包含的包络 */
envelopeCnt = elm_MergeEnvelope(mergeACID, (UINT8)mergeACIndex, arEnvelopID);
@@ -2856,7 +2849,7 @@ UINT8 elm_UCTEnvelopeLeaveAC(UINT8 flag,IN const EnvelopeStruct* pEnvelope,UINT1
funRet = elm_FindNearSameTrainEnvelop(pEnvelop, arEnvelopID, envelopeCnt, preEnvelope, backEnvelope, &includeCnt, includeELMid);
/** 设置错误码*/
ASSER_ERROR(CI_SUCCESS != funRet, errorCode, 0x08000000u);
ASSER_ERROR(CI_SUCCESS != funRet, errorCode, 0x10000000U);
}
else
{
@@ -2870,7 +2863,7 @@ UINT8 elm_UCTEnvelopeLeaveAC(UINT8 flag,IN const EnvelopeStruct* pEnvelope,UINT1
}
/** 设置返回值*/
ASSERT_SETRET(0u == errorCode, ret, CI_SUCCESS, CI_ERROR);
ASSERT_SETRET(0U == errorCode, ret, CI_SUCCESS, CI_ERROR);
return ret;
}
TSCP/src/APP/ciapp/EnvelopeManage/EnvelopeLogicProcess.h
+18
View File
@@ -486,4 +486,22 @@ void elm_FlyingProtect_UCT(void);
*/
void elm_DeleteUctPassFlag(UINT16 envelopeId);
/**
* @brief 处理AG虚拟筛选标志
* @param[in] UINT16 envelopeID 列车包络
* @param[in] UINT16 wTrainId 列车ID
* @return 无
* @note by cgh 20250805
*/
void elm_DealAgVirScreenFlag(UINT16 wEnvelopeID, UINT16 wTrainId);
/**
* @brief 处理BG虚拟筛选标志
* @param[in] UINT16 envelopeID 列车包络
* @param[in] UINT16 wTrainId 列车ID
* @return 无
* @note by cgh 20250805
*/
void elm_DealBgVirScreenFlag(UINT16 wEnvelopeID, UINT16 wTrainId);
#endif
TSCP/src/APP/ciapp/EnvelopeManage/EnvelopeScreen.c
+26 -14
View File
@@ -634,6 +634,7 @@ void elm_WLScreenProcess(void)
UINT8 relEnvelopeCnt= TRAIN_REL_ENVELOPE_SUM_MAX; /*列车关联的包络数量*/
UINT16 relEnvelopeID[TRAIN_REL_ENVELOPE_SUM_MAX] = {0u}; /*列车关联的包络索引*/
const EnvelopeStruct *pEnvelopeInfo = NULL;
UINT8 chTrainNvramPosFlag = 0U; /*列车NVRAM位置标识*/
/** 获取全线免筛标志 */
wlsFlag = wls_GetWLScreenPermitFlag();
@@ -653,26 +654,37 @@ void elm_WLScreenProcess(void)
((TYPE_CT_ENVELOPE == pEnvelopeInfo->envelopeType) || (TYPE_UCT_ENVELOPE == pEnvelopeInfo->envelopeType)))
{
ELM_LOG(ELM_LOG_FATAL,"info:ELM%d WLS Process,",pEnvelopeInfo->id);
if (LINE_MAX_TRAIN == pEnvelopeInfo->headTrainID)
chTrainNvramPosFlag = GetTrainNvramPosFlag(cycle);
if (TRAIN_NVRAM_POS_FLAG_NO == chTrainNvramPosFlag)
{
ELM_LOG(ELM_LOG_FATAL," delete Head suspicious,");
(void)elm_SetEnvelopeHeadTrainID(pEnvelopeInfo->id,0u);
if (LINE_MAX_TRAIN == pEnvelopeInfo->headTrainID)
{
ELM_LOG(ELM_LOG_FATAL, " delete Head suspicious,");
(void)elm_SetEnvelopeHeadTrainID(pEnvelopeInfo->id, 0u);
}
else
{
/* 不处理 */
}
if (LINE_MAX_TRAIN == pEnvelopeInfo->tailTrainID)
{
ELM_LOG(ELM_LOG_FATAL, " delete Tail suspicious,");
(void)elm_SetEnvelopeTailTrainID(pEnvelopeInfo->id, 0u);
}
else
{
/* 不处理 */
}
}
else
{
/* 不处理 */
ELM_LOG(ELM_LOG_FATAL, " not finish suspicious,because use nvram pos");
}
if (LINE_MAX_TRAIN == pEnvelopeInfo->tailTrainID)
{
ELM_LOG(ELM_LOG_FATAL," delete Tail suspicious,");
(void)elm_SetEnvelopeTailTrainID(pEnvelopeInfo->id,0u);
}
else
{
/* 不处理 */
}
ELM_LOG(ELM_LOG_FATAL,"\n");
ELM_LOG(ELM_LOG_FATAL, "\n");
}
}
else
TSCP/src/APP/ciapp/EnvelopeManage/UCTEnvelopeTrack.c
+78 -17
View File
@@ -1990,16 +1990,15 @@ static UINT8 elm_UCTEnvelopeHeadHandle(UINT8 endlineFlag, IN const EnvelopeStruc
/** 不添加前端可疑 */
funRtn = elm_SetEnvelopeHeadTrainID(ptemp->id, pPretemp->headTrainID);
ASSER_ERROR(CI_ERROR == funRtn, errorCode, 0x00002000u);
/** 则更新车头位置 */
funRtn = elm_SetUCTEnvelopeDot(ELM_HEAD, ptemp->ACID[ptemp->ACCnt - 1u], ptemp);
ASSER_ERROR(CI_ERROR == funRtn, errorCode, 0x00000800u);
}
else
{
funRtn = elm_SetEnvelopeHeadTrainID(ptemp->id, LINE_MAX_TRAIN);
ASSER_ERROR(CI_ERROR == funRtn, errorCode, 0x00001000u);
funRtn = elm_DeleteCTOrUCTEnvelope(ptemp->id);
ASSER_ERROR(CI_ERROR == funRtn, errorCode, 0x00000400u);
}
/** 则更新车头位置 */
funRtn = elm_SetUCTEnvelopeDot(ELM_HEAD, ptemp->ACID[ptemp->ACCnt - 1u], ptemp);
ASSER_ERROR(CI_ERROR == funRtn, errorCode, 0x00000800u);
}
ret = 0x55u;
}
@@ -2271,7 +2270,8 @@ static UINT8 elm_UCTEnvelopeHeadMoving(const EnvelopeStruct *ptemp)
UINT8 includeCnt = 0u;
UINT16 includeELMid[TRAIN_SUM_MAX_IN_OC] = {0u}; /** 重合的包络id */
UINT8 cHeadDirChangeFlag = DIRECTIONPOINT_FLAG_INVALID; /*包络头方向变化点标志*/
const EnvelopeStruct* pPretemp = NULL;
UINT16 wInputAcId = 0U;
/** 入口参数校验 */
ASSERT_RET_VALUE(NULL == ptemp,ret,0x80000000u);
@@ -2383,7 +2383,30 @@ static UINT8 elm_UCTEnvelopeHeadMoving(const EnvelopeStruct *ptemp)
if (0u == errorCode)
{
endLineFlag = (0u == acSameCnt) ? CI_SUCCESS : CI_ERROR;
funRtn = elm_UCTEnvelopeHeadHandle(endLineFlag,ptemp,acSameID[0u],preEnvelope, cHeadDirChangeFlag);
wInputAcId = acSameID[0U];
pPretemp = elm_GetEnvelopeInfoPtr(preEnvelope);
if (NULL != pPretemp)
{
for (cycle = 0U; cycle < pPretemp->ACCnt; cycle++)
{
if (ptemp->ACID[ptemp->ACCnt - 1U] == pPretemp->ACID[cycle])
{
wInputAcId = ptemp->ACID[ptemp->ACCnt - 1U];
break; /*前方包络与本包络终点处于同一计轴区段，停止遍历*/
}
else
{
/*继续遍历查找*/
}
}
}
else
{
/*不处理*/
}
/*若前方包络位于本包络终点计轴区段，则使用本包络终点计轴区段作为入参，否则使用本包络终点前方计轴区段作为入参*/
funRtn = elm_UCTEnvelopeHeadHandle(endLineFlag,ptemp, wInputAcId,preEnvelope, cHeadDirChangeFlag);
ASSER_ERROR(CI_ERROR == funRtn,errorCode,0x00400000u);
if (CI_ERROR != funRtn)
@@ -2634,17 +2657,17 @@ static UINT8 elm_UCTEnvelopeTailHandle(UINT8 endlineFlag, const EnvelopeStruct *
if (0x55u == funRtn)
{
/** 不添加前端可疑 */
funRtn = elm_SetEnvelopeTailTrainID(ptemp->id, pBacktemp->tailTrainID);
ASSER_ERROR(CI_ERROR == funRtn, errorCode, 0x00002000u);
/** 则更新车尾位置 */
funRtn = elm_SetUCTEnvelopeDot(ELM_TAIL, ptemp->ACID[0u], ptemp);
ASSER_ERROR(CI_ERROR == funRtn, errorCode, 0x00001000u);
}
else
{
funRtn = elm_SetEnvelopeTailTrainID(ptemp->id, LINE_MAX_TRAIN);
ASSER_ERROR(CI_ERROR == funRtn, errorCode, 0x00002000u);
funRtn = elm_DeleteCTOrUCTEnvelope(ptemp->id);
ASSER_ERROR(CI_ERROR == funRtn, errorCode, 0x00000800u);
}
/** 则更新车尾位置 */
funRtn = elm_SetUCTEnvelopeDot(ELM_TAIL, ptemp->ACID[0u], ptemp);
ASSER_ERROR(CI_ERROR == funRtn, errorCode, 0x00001000u);
}
ret = 0x55u;
}
@@ -2916,6 +2939,8 @@ static UINT8 elm_UCTEnvelopeTailMoving(const EnvelopeStruct *ptemp)
UINT8 includeCnt = 0u;
UINT16 includeELMid[TRAIN_SUM_MAX_IN_OC] = {0u}; /** 重合的包络id */
UINT8 cTailDirChangeFlag = DIRECTIONPOINT_FLAG_INVALID; /*包络尾方向变化点标志*/
const EnvelopeStruct* pBacktemp = NULL;
UINT16 wInputAcId = 0U;
/** 入口参数校验 */
ASSERT_RET_VALUE(NULL == ptemp,ret,0x80000000u);
@@ -3028,8 +3053,32 @@ static UINT8 elm_UCTEnvelopeTailMoving(const EnvelopeStruct *ptemp)
if (0u == errorCode)
{
endLineFlag = (0u == acConvertCnt) ? CI_SUCCESS : CI_ERROR;
funRtn = elm_UCTEnvelopeTailHandle(endLineFlag,ptemp,acConvertID[0u],backEnvelope, cTailDirChangeFlag);
ASSER_ERROR(CI_ERROR == funRtn,errorCode,0x00400000u);
wInputAcId = acConvertID[0U];
pBacktemp = elm_GetEnvelopeInfoPtr(backEnvelope);
if (NULL != pBacktemp)
{
for (cycle = 0U; cycle < pBacktemp->ACCnt; cycle++)
{
if (ptemp->ACID[0U] == pBacktemp->ACID[cycle])
{
wInputAcId = ptemp->ACID[0U];
break; /*后方包络与本包络起点处于同一计轴区段，停止遍历*/
}
else
{
/*继续遍历查找*/
}
}
}
else
{
/*不处理*/
}
/*若后方包络位于本包络起点计轴区段，则使用本包络起点计轴区段作为入参，否则使用本包络起点后方计轴区段作为入参*/
funRtn = elm_UCTEnvelopeTailHandle(endLineFlag, ptemp, wInputAcId, backEnvelope, cTailDirChangeFlag);
ASSER_ERROR(CI_ERROR == funRtn, errorCode, 0x00400000u);
if (CI_ERROR != funRtn)
{
@@ -3256,6 +3305,7 @@ static UINT8 elm_ConvertToUCTCheck(const EnvelopeStruct* ptemp)
UINT8 chCanUct = FLAG_SET;
UINT32 minTrainLength = 0U;
UINT32 dwTempLength = 0U;
UINT8 chTrainNvramPosFlag = 0U;
/** 入口参数校验 */
ASSERT_RET_VALUE(NULL == ptemp,ret,0x80000000U);
@@ -3297,6 +3347,17 @@ static UINT8 elm_ConvertToUCTCheck(const EnvelopeStruct* ptemp)
; /* 不满足转为UCT条件 */
}
if (0U == errorCode)
{
/** 获取列车是否使用NVRAM位置 */
chTrainNvramPosFlag = GetTrainNvramPosFlag(ptemp->trainID[0U]);
ASSER_ERROR(TRAIN_NVRAM_POS_FLAG_NO != chTrainNvramPosFlag, errorCode, 0x04000000U);
}
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
+49 -13
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,29 +109,65 @@ UINT8 HLHTRecvCommonPacketHeadCheck(UINT16 LocalDevName, UINT16 RemoteDevName, U
;
}
/*发送方校验*/
chRet = dquDevName2HlhtId(LocalDevName, logId, &LocalEtcsId);
if ((CI_ERROR == chRet) || (pMICommonPackage->sourceId != LocalEtcsId))
if ((CI_SYSTEM_TYPE_OC == devType) || (CI_SYSTEM_TYPE_XIANDI == devType) || (CI_SYSTEM_TYPE_ATS == devType))
{
*pErrorCode |= GAL_COMPARE_SEND_FLAG_ERR;
/*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))
{
*pErrorCode |= GAL_COMPARE_SEND_FLAG_ERR;
}
else
{
;
}
/*接收方校验*/
chRet = dquDevName2HlhtId(RemoteDevName, logId, &RemoteEtcsId);
if ((CI_ERROR == chRet) || (pMICommonPackage->destId != RemoteEtcsId))
{
*pErrorCode |= GAL_COMPARE_RECV_FLAG_ERR;
}
else
{
;
}
}
/*接收方校验*/
chRet = dquDevName2HlhtId(RemoteDevName, logId, &RemoteEtcsId);
if ((CI_ERROR == chRet) || (pMICommonPackage->destId != RemoteEtcsId))
if ((CI_SYSTEM_TYPE_CI == devType) || (CI_SYSTEM_TYPE_RC == devType))
{
*pErrorCode |= GAL_COMPARE_RECV_FLAG_ERR;
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);
}
emapCheckVer = GetCiEmapCheckVer((UINT8)RemoteDevName, &emapVer, devType);
if (CI_SUCCESS == emapCheckVer)
{
/*电子地图版本校验信息(4字节CRC比较)*/
TSCP/src/APP/ciapp/HLHTMsgHead/HLHTHeadContexManage.c
+119 -11
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;
tempHeadCtxPtr = axleHLHTHeadCtxs;
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
+1982 -446
View File
File diff suppressed because it is too large Load Diff
TSCP/src/APP/ciapp/IO/DeviceRelayDataProcess.h
+147 -9
View File
@@ -95,8 +95,8 @@ UINT8 GetSignalShowColor(const UINT16 signalId);
/*
* 功能描述： 信号机双系板卡故障，信号机当前设置颜色
* 参数说明：
UINT16 signalId：信号机id
UINT8 ocId OC ID
UINT16 signalId：信号机id
UINT8 ocId OC ID
* 返回值 ： 信号机颜色
*/
UINT8 GetOcBoardFaultSignalColor(UINT16 signalId, UINT8 ocId);
@@ -269,6 +269,7 @@ void FloodGateDeviceToRelayStateProc(void);
* 功能描述： 更新进路的调车同意逻辑状态
* 参数说明： void
* 返回值 ： void
* BY CGH 20250523
*/
void RouteDCTYRelayToDeviceStateProc(void);
@@ -353,7 +354,7 @@ void ProcessJXTCPulseInterfStopDrv(UINT16 startJXTCRelayId, UINT16 stopJXTCRelay
/******************************OC spks指示灯输出处理****************************/
/*
* 功能描述： OC spks指示灯和spks旁路指示灯输出处理
* 功能描述： OC spks指示灯、spks旁路指示灯及蜂鸣继电器处理
* 参数说明： void
* 返回值 ： void
*/
@@ -682,13 +683,14 @@ void DetZfsCancelBtnPressStateProc(const UINT16 wSignalId, const UINT16 wCancelD
void DetZfsCancelBtnActFlagProc(const UINT16 wSignalId, const UINT16 wCancelDetBtnRelayId);
/*
* 功能描述：驱动自复式扣车指示灯
* 参数说明：const UINT16 signalId, 信号机ID
* const UINT16 signalDetainDisplayId, 扣车表示灯继电器1ID
* 返回值：无
*
* 功能描述：驱动自复式扣车相关指示灯
* 参数说明：const UINT16 signalId 信号机ID
* const UINT16 signalDetDisRelayId 扣车表示灯继电器ID
* const UINT16 signalDetCutDisRelayId 扣车旁路表示灯继电器
* 返 回 值：无
* Modified By LQ 2025.07.03
*/
void DriveZfsDetainBsRelay(const UINT16 signalId, const UINT16 signalDetainDisplayId);
void DriveZfsDetainBsRelay(const UINT16 signalId, const UINT16 signalDetDisRelayId, const UINT16 signalDetCutDisRelayId);
/*
* 功能描述：自复式紧急停车按钮处理
@@ -853,6 +855,142 @@ UINT8 GetSwitchCollToleratePos(const UINT16 switchId);
*/
UINT8 CheckSwitchCollTolerateState(UINT16 switchId);
/*
* 功能描述：宁象市域铁路紧急停车按钮处理
* 参数说明：UINT16 esbId ESB ID
* 返 回 值：无
* Created By LQ 2025.03.28
*/
void EsbNXRailBtnProc(UINT16 esbId);
/*
* 功能描述：宁象市域铁路紧急停车取消按钮处理
* 参数说明：UINT16 esbId ESB ID
* 返 回 值：无
* Created By LQ 2025.03.28
*/
void EsbNXRailCancelBtnProc(UINT16 esbId);
/*
* 功能描述：宁象市域铁路紧急停车取消按钮有效标志处理
* 参数说明：const UINT16 wEsbId ESB ID
* const UINT16 wCancelEsbRelayId ESB取消按钮采集继电器ID
* 返回值 ：无
* Created By LQ 2025.03.30
*/
void EsbNXRailCancelBtnValidFlagProc(const UINT16 wEsbId, const UINT16 wCancelEsbRelayId);
/*
* 功能描述：宁象市域铁路紧急停车旁路按钮处理
* 参数说明：UINT16 esbId ESB ID
* 返 回 值：无
* Created By LQ 2025.03.30
*/
void EsbNXRailCutBtnProc(UINT16 esbId);
/*
* 功能描述：宁象市域铁路紧急停车旁路按钮按下状态处理
* 参数说明：const UINT16 wEsbId ESB ID
* const UINT16 wCutEsbRelayId 紧急旁路按钮采集继电器ID
* 返回值 ：无
* Created By LQ 2025.03.30
*/
void EsbNXRailCutBtnPressStateProc(const UINT16 wEsbId, const UINT16 wCutEsbRelayId);
/*
* 功能描述：宁象市域铁路ESB指示灯和ESB旁路指示灯输出处理
* 参数说明：const UINT16 wEsbId ESB ID
* 返 回 值：无
* Created By LQ 2025.03.30
*/
void EsbNXRailDisplayDrivOutput(const UINT16 wEsbId);
/*
* 功能描述：屏蔽门异常打开处理
* 参数说明：无
* 返 回 值：无
* Created By LQ 2025.05.23
*/
void PsdExceptOpenProc(void);
/*
* 功能描述：自复式扣车旁路按钮处理
* 参数说明：const UINT16 signalId 信号机ID
* 返 回 值：无
* Created By LQ 2025.06.20
*/
void SignalZfsDetainCutBtnPro(const UINT16 signalId);
/*
* 功能描述：自复式扣车旁路按钮按下状态处理
* 参数说明：const UINT16 wSignalId 信号机ID
* const UINT16 wDetCutBtnRelayId 扣车旁路按钮采集继电器ID
* 返 回 值：无
* Created By LQ 2025.06.20
*/
void ZfsDetCutBtnPressStateProc(const UINT16 wSignalId, const UINT16 wDetCutBtnRelayId);
/*
* 功能描述：自复式扣车旁路按钮有效状态处理
* 参数说明：const UINT16 wSignalId 信号机ID
* const UINT16 wDetCutBtnRelayId 扣车旁路按钮采集继电器ID
* 返 回 值：无
* Created By LQ 2025.06.20
*/
void ZfsDetCutBtnValidStateProc(const UINT16 wSignalId, const UINT16 wDetCutBtnRelayId);
/*
* 功能描述：获取SPKS按钮采集容忍结果
* 参数说明：const UINT16 wSpksId SPKS编号
* 返 回 值：CI_ERROR 0 容忍结束
* CI_SUCCESS 1 继续容忍
* Created By LQ 2025.06.26
*/
UINT8 GetSpksBtnCollTolerateRet(const UINT16 wSpksId);
/*
* 功能描述：获取Psd门开继电器采集容忍结果
* 参数说明：const UINT16 wPsdId PSD编号
* 返 回 值：CI_ERROR 0 容忍结束
* CI_SUCCESS 1 继续容忍
* Created By LQ 2025.06.26
*/
UINT8 GetPsdRelayCollTolerateRet(const UINT16 wPsdId);
/*
* 功能描述：获取Esb采集容忍结果
* 参数说明：const UINT16 wEsbId ESB编号
* 返 回 值：CI_ERROR 0 容忍结束
* CI_SUCCESS 1 继续容忍
* Created By LQ 2025.06.26
*/
UINT8 GetEsbCollTolerateRet(const UINT16 wEsbId);
/*
* 功能描述：获取扣车按钮1采集容忍结果
* 参数说明：const UINT16 wSignalId 信号机编号
* 返 回 值：CI_ERROR 0 容忍结束
* CI_SUCCESS 1 继续容忍
* Created By LQ 2025.06.26
*/
UINT8 GetFstDetBtnCollTolerateRet(const UINT16 wSignalId);
/*
* 功能描述：获取扣车按钮2采集容忍结果
* 参数说明：const UINT16 wSignalId 信号机编号
* 返 回 值：CI_ERROR 0 容忍结束
* CI_SUCCESS 1 继续容忍
* Created By LQ 2025.06.26
*/
UINT8 GetSndDetBtnCollTolerateRet(const UINT16 wSignalId);
/*
* 功能描述： 设置所有道岔转辙机位置
* 参数说明： UINT16 switchCurSum 道岔总数
* 返回值 ： 无
*/
void SetAllSingleSwitchZzjState(UINT16 switchCurSum);
#ifdef __cplusplus
}
#endif
TSCP/src/APP/ciapp/IO/InputDataProcess.c
+2489 -538
View File
File diff suppressed because it is too large Load Diff
TSCP/src/APP/ciapp/IO/InputDataProcess.h
+95
View File
@@ -451,6 +451,101 @@ void LogRouteCleanOldPhySecLockProc(const UINT16 wPreRouteId);
*/
void OtherPartRouteCleanLogRouteProc(const UINT16 wCurRouteId);
/*
* 功能描述：处理OC->CI的PSD数据
* 参数说明： void
* 返回值 ： void
*/
void ProcessOCToCiPsdData(void);
/*
* 功能描述： 处理OC到CI的不一致继电器数据
* 参数说明： void
* 返回值 ： 0:处理失败
* 1:处理成功
*/
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
+148 -37
View File
@@ -387,6 +387,13 @@ UINT8 GetAtsBackInfoParam(const UINT8 functionId,const UINT8 deviceStateType, co
returnValue = CI_BACK_ROUTE_XUANPAI_OVERTIME;/*进路选排超时*/
break;
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:
if (SIGNAL_OPEN==deviceState )
@@ -685,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;
@@ -834,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;
@@ -860,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;
@@ -886,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;
@@ -898,6 +918,33 @@ UINT8 GetAtsBackInfoParam(const UINT8 functionId,const UINT8 deviceStateType, co
case ETYPE_OTHER_DOWNWASH_NOT_ALLOW_PASS:
returnValue = CI_BACK_WASH_PASS_ALLOW_NOT; /*洗车库/线未同意通过*/
break;
case ETYPE_LOGSEC_CONTINUOUS:
returnValue = CI_BACK_DYM_ROUTE_CONTINUOUS;
break;
case ETYPE_PART_ROUTE_RES:
returnValue = CI_BACK_DYM_ROUTE_RES;
break;
case ETYPE_PART_ROUTE_MATCH_ROUTE:
returnValue = CI_BACK_DYM_ROUTE_MATCH_ROUTE;
break;
case ETYPE_PART_ROUTE_SCREEN:
returnValue = CI_BACK_DYM_ROUTE_SCREEN;
break;
case ETYPE_LOGSEC_CBTC_PROPERTY:
returnValue = CI_BACK_DYM_ROUTE_SEC_CBTC;
break;
case ETYPE_PART_ROUTE_REPEAT:
returnValue = CI_BACK_DYM_ROUTE_REPEAT;
break;
case ETYPE_PART_ROUTE_SEC_ATTR:
returnValue = CI_BACK_DYM_ROUTE_SEC_ATTR;
break;
case ETYPE_PART_ROUTE_TRAIN_COMM:
returnValue = CI_BACK_DYM_ROUTE_TRAIN_COMM;
break;
case ETYPE_PART_ROUTE_TRAIN_POS:
returnValue = CI_BACK_DYM_ROUTE_TRAIN_POS;
break;
default:/*数据错误*/
returnValue = 0U;
break;
@@ -916,14 +963,18 @@ CI_SUCCESS
*/
UINT8 CiToAtsBackInfoFunctionJudge(const UINT8 functionId,const UINT8 deviceType)
{
if ((functionId > 0u) && (deviceType>0u) )
UINT8 cRetVal = CI_ERROR;
if ((functionId > 0U) && (deviceType>0U))
{
return CI_SUCCESS;
cRetVal = CI_SUCCESS;
}
else
{
return CI_ERROR;
cRetVal = CI_ERROR;
}
return cRetVal;
}
@@ -1723,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);/*设置指示灯通信一般*/
@@ -3340,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个相邻联锁 通信良好*/
@@ -5719,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))/*倒计时数值在合理范围内*/
@@ -5743,19 +5793,10 @@ UINT16 GetOverlapUnlockBackTime(const UINT16 overlapId, UINT16 OverlapUnLockCoun
}
}
if(0u < laborUnlockStartCycNum)/*已经设置人工解锁*/
if (0u < laborUnlockStartCycNum)/*已经设置人工解锁*/
{
/*比较两个时间，返回最小的。因为在解锁；逻辑是以最小倒计时解锁的*/
if(autotimeData > labortimeData)
{
returnTime = labortimeData;
}
else
{
returnTime = autotimeData;
}
/*有人工解锁，就用人工解锁时间*/
returnTime = labortimeData;
}
else
{
@@ -6241,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);
@@ -6260,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)
{
@@ -6295,7 +6340,6 @@ void OverlapTimeDataBackProcess(const UINT16 wOverlapId)
}
}
wRouteStopSteadyPhySecId = GetRouteStopSteadyPhySecId(wRLockBelongRouteId);/*获取进路停稳物理区段ID*/
wOverlapAllClearRes = OverlapAllSecOccuClearCheck(wOverlapId, &wTmpOvlpOccuSecId, &chTmpOvlpOccuSecSta);
if ((wRouteLastPhySectionId == wRouteStopSteadyPhySecId) && (CI_SUCCESS == wOverlapAllClearRes))
{/*倒计时未超时*/
@@ -6313,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);
@@ -6326,24 +6370,41 @@ void OverlapTimeDataBackProcess(const UINT16 wOverlapId)
}
else
{
/*占用类型故障*/
}
if (0u < wTimeData)/*存在倒计时*/
{
if (wTimeData > UINT8_MAX)
{/*当倒计时时间超出最大值时，则同一周期发两包数，一包为高字节，一包为低字节*/
SetCiSendCmdBackInfoData(CI_BACK_COUNT_OVERLAP_UNLOCK_HIGH, CI_DEVICE_TYPE_PHYSEC, pOverlapPhySecBuf[0], (UINT8)(wTimeData >> 8), 0U);
/*解决问题：
物理区段占用变空闲容忍时，CT/UT占用起始时间有效，但占用标志已经变成了未占用；此时要是有人工解锁，倒计时会消失占用变空闲时间*/
if ((0U < dwLaborUnlockStartCycNum) && (CI_SUCCESS == wOverlapAllClearRes))
{
wTimeData = GetOverlapLaborUnlockBackTime(wOverlapId);
}
else
{
SetOverlapUnlockTime(wOverlapId, 0U);
}
SetCiSendCmdBackInfoData(CI_BACK_COUNT_OVERLAP_UNLOCK, CI_DEVICE_TYPE_PHYSEC, pOverlapPhySecBuf[0], (UINT8)wTimeData, 0U);
}
SetOverlapUnlockTime(wOverlapId, wTimeData);
}
else
{
SetOverlapUnlockTime(wOverlapId, 0U);/*清除倒计时，因为区段再次占用时，要重新以区段占用开始时间作为倒计时参考，重新记时*/
/*人工解锁倒计时*/
if ((0U < dwLaborUnlockStartCycNum) && (CI_SUCCESS == wOverlapAllClearRes))
{
wTimeData = GetOverlapLaborUnlockBackTime(wOverlapId);
}
else
{
SetOverlapUnlockTime(wOverlapId, 0U);/*清除倒计时，因为区段再次占用时，要重新以区段占用开始时间作为倒计时参考，重新记时*/
}
}
if (0u < wTimeData)/*存在倒计时*/
{
if (wTimeData > UINT8_MAX)
{/*当倒计时时间超出最大值时，则同一周期发两包数，一包为高字节，一包为低字节*/
SetCiSendCmdBackInfoData(CI_BACK_COUNT_OVERLAP_UNLOCK_HIGH, CI_DEVICE_TYPE_PHYSEC, pOverlapPhySecBuf[0], (UINT8)(wTimeData >> 8), 0U);
}
SetCiSendCmdBackInfoData(CI_BACK_COUNT_OVERLAP_UNLOCK, CI_DEVICE_TYPE_PHYSEC, pOverlapPhySecBuf[0], (UINT8)wTimeData, 0U);
}
SetOverlapUnlockTime(wOverlapId, wTimeData);
}
else
{
@@ -6524,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));
chMainValid = GetHLHTHeadCtxValid(CI_SYSTEM_TYPE_VOBC, (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;
@@ -8538,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/Indicator/IndicatorConfigDataManage.c
+1 -1
View File
@@ -18,7 +18,7 @@ UINT16 LocalCiIndicatorIdBuf[INDICATOR_SUM_MAX] = {0u};/*
INT16 IndicatorCurSum = 0; /*指示器当前总数*/
OCStationIndicConfigDataStru g_OCStationIndicConfigDataStru[INDICATOR_SUM_MAX] = { 0u };
UINT16 g_OCStationIndicatorCurSum = 0; /*本联锁OC站（集中站和非集中站）指示器总数,不涉及主备跟随，取值范围0-1000*/
UINT16 g_OCStationIndicatorCurSum = 0; /*本联锁OC站（集中站和非集中站）指示器总数,不涉及主备跟随，取值范围 [0,2000) 暂无使用*/
TSCP/src/APP/ciapp/Indicator/IndicatorDefine.h
+1 -1
View File
@@ -14,7 +14,7 @@
/*总数最大值*/
#define INDICATOR_SUM_MAX ((UINT16)1000) /*指示器最大数量,每个联锁40个指示灯，总共按20个联锁 */
#define INDICATOR_SUM_MAX ((UINT16)2000) /*指示器最大数量,每个联锁40个指示灯，总共按20个联锁 */
#define INDICATOR_RELAY_SUM_MAX ((UINT16)5) /*指示器相关继电器最大数量*/
#define RTNINDICATOR_SUM_MAX ((UINT8)2U) /*一个虚拟联锁集中区无人折返最大数量*/
TSCP/src/APP/ciapp/Initial/ConfigDataReadManage.c
+74 -3
View File
@@ -919,7 +919,7 @@ UINT8 ReadConfigureData(void)
g_ret = ReadEaConfigData(g_szEaConfig);
if (-1 == g_ret)
{
rtnVal = 37u;
rtnVal = 40u;
debug_infor_printf((const)"ReadEaConfigData errcode =%d, ReadEaConfigData", rtnVal);
}
else
@@ -1041,7 +1041,26 @@ UINT8 ReadConfigureData(void)
if (0 == g_ret)
{
debug_infor_printf((const)"PhySectionNearConfigDataManage Error\n");
rtnVal = 37u;
rtnVal = 41u;
}
else
{
; /*不处理*/
}
}
else
{
; /*不处理*/
}
if (0U == rtnVal)
{
/*读取物理区段在计轴中的索引*/
g_ret = (INT16)ReadPhySecIndexInAxle(LocalCiId, PhysicalSectionConfigDataStru);
if (0 == g_ret)
{
debug_infor_printf((const)"ReadPhySecIndexInAxle Error\n");
rtnVal = 42u;
}
else
{
@@ -1064,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
{
/*不处理*/
}
}
@@ -1280,7 +1314,8 @@ UINT8 SetautoRouteOpposedRoute(UINT16 autoRouteRouteId,UINT8 routeType)
autoRouteSum = GetAutoRouteRouteCurSum();/*自动进路数目*/
autoReturnSum = GetAutoReturnRouteCurSum();/*自动折返进路数目*/
allAutoReturnSum = GetAllAutoReturnRouteCurSum();/*全自动折返进路数目*/
if ((autoRouteSum >= AUTO_ROUTE_SUM_MAX) || (autoReturnSum >= AUTO_RETURN_SUM_MAX))
if ((AUTO_ROUTE_SUM_MAX <= autoRouteSum) || (AUTO_RETURN_SUM_MAX<=autoReturnSum )
||(ALL_AUTO_RETURN_SUM_MAX <= allAutoReturnSum))
{/*配置数据总数错误*/
returnValue = CI_ERROR;
}
@@ -3427,3 +3462,39 @@ UINT16 GetTiocDeviceConfigData(UINT32* pConfigDataAddrBuf,UINT16* pConfigDataLen
return wRetSum;
}
/*********************************************
*函数功能：读取指定CI与指定设备通信关系配置数据
*参数说明：const UINT8 chCiId 联锁ID
* const UINT8 chSystemType 设备类型
* UINT8 szDeviceIdBuf[TRANSMIT_OBJECT_DEVICE_SUM_MAX] 输出的设备ID
*返回值：通信关系数
* by cgh 20250605
*********************************************/
UINT8 ReadCiTransmitSpecifyDevData(const UINT8 chCiId, const UINT8 chSystemType, UINT8 szDeviceIdBuf[TRANSMIT_OBJECT_DEVICE_SUM_MAX])
{
UINT16 ii = 0U;
UINT8 chReval = 0U;
if ((0U != chCiId) && (NULL != szDeviceIdBuf))
{
for (ii = 0U; ii < dquCICfgDtStr.TrsmtRlsDtStrLen; ii++)
{
if ((chCiId == dquCICfgDtStr.TrsmtRlsDtStr[ii].CiId) && (chSystemType == dquCICfgDtStr.TrsmtRlsDtStr[ii].SystemType))
{
chReval = dquCICfgDtStr.TrsmtRlsDtStr[ii].DeviceSum;
(void)CommonMemCpy((void*)(szDeviceIdBuf), (UINT32)(sizeof(UINT8) * TRANSMIT_OBJECT_DEVICE_SUM_MAX), (const void*)(dquCICfgDtStr.TrsmtRlsDtStr[ii].DeviceIdBuf), (UINT32)(sizeof(UINT8) * TRANSMIT_OBJECT_DEVICE_SUM_MAX));
}
else
{
;
}
}
}
else
{
chReval = UINT8_MAX;
}
return chReval;
}
TSCP/src/APP/ciapp/Initial/ConfigDataReadManage.h
+10
View File
@@ -160,6 +160,16 @@ INT8 OcConnectConfigDataToDevStruct(SignalConfigDataStruct* pSignalCfgData, Phys
*返回值：静态数据数量
*********************************************/
UINT16 GetTiocDeviceConfigData(UINT32* pConfigDataAddrBuf, UINT16* pConfigDataLenBuf, UINT16 wBufMaxLen);
/*********************************************
*函数功能：读取指定CI与指定设备通信关系配置数据
*参数说明：const UINT8 chCiId 联锁ID
* const UINT8 chSystemType 设备类型
* UINT8 szDeviceIdBuf[TRANSMIT_OBJECT_DEVICE_SUM_MAX] 输出的设备ID
*返回值：通信关系数
* by cgh 20250605
*********************************************/
UINT8 ReadCiTransmitSpecifyDevData(const UINT8 chCiId, const UINT8 chSystemType, UINT8 szDeviceIdBuf[TRANSMIT_OBJECT_DEVICE_SUM_MAX]);
#endif
TSCP/src/APP/ciapp/Initial/InitialProcess.c
+500 -83
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,18 +66,25 @@ UINT8 InitialProcess(void)
}
/*读取联锁配置数据*/
if (0u != ReadConfigureData())
{
if (CI_SUCCESS == ret)
{
if (0u != ReadConfigureData())
{
#ifdef PLATFORM_2OO2
(void)printf("ReadConfigureData Error\n");
debug_infor_printf((const)"ReadConfigureData Error\n");
(void)printf("ReadConfigureData Error\n");
debug_infor_printf((const)"ReadConfigureData Error\n");
#endif
ret = CI_ERROR;
ret = CI_ERROR;
}
}
}
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; /*自复式未配置扣车按钮继电器，初始化扣车按钮未激活*/
@@ -586,19 +592,21 @@ UINT8 InitialSignalData(void)
SignalDataStru[signalId].DetainBtnErrFlag = SIGNAL_ZFS_BTN_ERR_FLAG_NO; /*扣车按钮故障标志*/
SignalDataStru[signalId].CancelDetainBtnErrFlag = SIGNAL_ZFS_BTN_ERR_FLAG_NO; /*取消扣车按钮故障标志*/
SignalDataStru[signalId].DetainBtnPressCycNum = 0U; /*扣车按钮1按下周期*/
SignalDataStru[signalId].DetainSndBtnPressCycNum = 0U; /*扣车按钮2按下周期*/
SignalDataStru[signalId].CancelDetainBtnPressCycNum = 0U; /*取消扣车按钮正常按下周期*/
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; /*扣车旁路按钮正常按下周期*/
SignalDataStru[signalId].DetCutBtnErrTrigPressCycNum = 0U; /*扣车旁路按钮误触发按下周期*/
SignalDataStru[signalId].cDetCutBtnErrFlag = SIGNAL_ZFS_BTN_ERR_FLAG_NO; /*扣车旁路按钮故障标志*/
SignalDataStru[signalId].cDetCutBtnRelayDownState = SIGNAL_RELAY_ERROR_DOWN_YES; /*扣车旁路按钮采集继电器落下状态初始化为异常落下*/
/*初始化信号机临时限速状态有效*/
SignalDataStru[signalId].LinShiXianSuSetFlag = SIGNAL_LINSHIXIANSUSET_STATE_YES;/*临时限速有效*/
routeSum = GetRouteCurSum();
for (jj = 0u; jj < routeSum; jj++)
{
@@ -667,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;
}
/* 设置自动信号属性 */
@@ -756,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;
@@ -780,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;
@@ -797,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;
@@ -857,7 +887,12 @@ 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;
PhysicalSectionDataStru[ii].chDirectResetBack = PHY_RESET_BACK_RECIVE_YES;
PhysicalSectionDataStru[ii].JumpLockStateToZC = PHYSICAL_SECTION_JUMP_LOCK_NO;
PhysicalSectionDataStru[ii].wPhyErrUnlockTime = 0U;
PhysicalSectionDataStru[ii].cAreaUrgentBrakeState = PHYSEC_AREA_URGENT_NO;
@@ -879,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
@@ -942,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;
@@ -1012,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;
}
@@ -1057,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;
}
}
@@ -1123,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;
}
@@ -1143,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
{
@@ -1217,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;
@@ -1224,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
{
@@ -1258,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*/
@@ -1285,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;
}
@@ -1363,6 +1442,26 @@ UINT8 InitialPsdData(void)
/*视频清客驱动状态初始化为无效。关联列车ID清0*/
PsdDataStru[psdId].chVideoQkDriveState = VIDEO_QK_DRIVE_STATE_INVALID;
PsdDataStru[psdId].wVideoQkRelateVobcId = 0U;
/*屏蔽门故障隔离、被隔离、开关状态、开关门故障状态信息初始化*/
PsdDataStru[psdId].psdFaultQStataOne = UINT32_MAX;
PsdDataStru[psdId].psdFaultQStataTwo = UINT32_MAX;
PsdDataStru[psdId].psdDoorIStateOne = UINT32_MAX;
PsdDataStru[psdId].psdDoorIStateTwo = UINT32_MAX;
PsdDataStru[psdId].psdDoorsStateOne = UINT32_MAX;
PsdDataStru[psdId].psdDoorsStateTwo = UINT32_MAX;
PsdDataStru[psdId].psdOpenErrState = PSD_OPEN_CLOSE_ERROR;
PsdDataStru[psdId].psdCloseErrState = PSD_OPEN_CLOSE_ERROR;
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;
@@ -1452,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;
@@ -1468,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;
}
}
@@ -1497,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*/
@@ -1511,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;
@@ -1541,33 +1642,48 @@ UINT8 InitialRouteData(void)
RouteDataStru[routeId].NeedOpenNotTrueRepeatStartCount = 0u;/*需开放不满足时重开起始周期*/
RouteDataStru[routeId].DCQState = ROUTE_DCQ_NOT_REQUEST;/*无调车请求*/
RouteDataStru[routeId].DCTYState = ROUTE_DCT_NOT_AGREE; /*无调车同意*/
RouteDataStru[routeId].dwDcAgreeBtnPressCycNum = 0U; /*调车同意按钮按下起始周期*/
RouteDataStru[routeId].chDcAgreeButtonErrState = ROUTE_DC_AGREE_BUTTON_OK; /*调车同意按钮未故障*/
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].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;
}
}
@@ -1853,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;
@@ -2111,6 +2233,11 @@ void ResetDynamicState(const UINT8 ciId)
PhysicalSectionDataStru[ii].FLockType = PHY_SEC_FLOCK_TYPE_NONE;
PhysicalSectionDataStru[ii].JumpLockStateToZC = PHYSICAL_SECTION_JUMP_LOCK_NO;
PhysicalSectionDataStru[ii].wPhyErrUnlockTime = 0U;
PhysicalSectionDataStru[ii].PhySecPreResetState = PHYSICAL_SECTION_PRE_RESET_NO;
PhysicalSectionDataStru[ii].chPreResetBack = PHY_RESET_BACK_RECIVE_YES;
PhysicalSectionDataStru[ii].chDirectResetRst = PHYSICAL_DIRECT_RESET_NO;
PhysicalSectionDataStru[ii].chDirectResetBack = PHY_RESET_BACK_RECIVE_YES;
}
else
{
@@ -2163,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) &&
@@ -2186,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
{
@@ -2223,6 +2351,7 @@ void ResetDynamicState(const UINT8 ciId)
SetSignalDetainBtnActFlag(devId, SIGNAL_ZFS_BTN_ACT_FLAG_YES); /*设置信号机扣车按钮有效状态*/
/*由于互联互通需判断保护区段的有效性，而自家CI的相邻CI不会判断。为了保证改动量最小，所以对于非互联互通信号机，其保护区段有效性一直设置为有效，不影响逻辑*/
SetSignalProSecValid(devId,SIGNAL_PRO_SEC_VALID);
SetDetCutBtnState(devId, SIGNAL_DETAIN_CUT_VALID_NO);
}
}
@@ -2245,6 +2374,7 @@ void ResetDynamicState(const UINT8 ciId)
PsdDataStru[devId].PsdState = PSD_STATE_CLOSE;
}
PsdDataStru[devId].MutualLockRemoveState = PSD_MUTUALLOCK_REMOVE_NO;
PsdDataStru[devId].cPsdExceptOpenState = PSD_EXCEPT_OPEN_YES; /*重置为PSD异常打开*/
}
}
@@ -2284,6 +2414,7 @@ void ResetDynamicState(const UINT8 ciId)
* 修改：在进路空闲等状态下。通信中断需要进路置成安全状态
* 修改20160511：增加自动解锁正常、自动解锁异常两种进路状态不置安全态，
当进路状态为自动解锁正常、自动解锁异常置安全态后，进路的保护区段无法解锁
* 修改：保留进路状态，避免空闲进路清零后，本联锁始端信号机为终端信号机的折返进路状态非法
*/
throughRtId = GetRouteThroughRouteId(devId);
OverlapLockedId = GetRouteOverlapLockedId(devId);
@@ -2302,6 +2433,7 @@ void ResetDynamicState(const UINT8 ciId)
{
(void)memset(&RouteDataStru[ii], 0, devLen);
RouteDataStru[devId].RouteId = devId;
RouteDataStru[devId].RouteState = devState;
RouteDataStru[devId].ThroughRouteId = throughRtId;
RouteDataStru[devId].OverlapLockedId = OverlapLockedId;
}
@@ -2438,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;
@@ -2450,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))
{
@@ -2624,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; /*车库门旁路状态*/
@@ -2655,6 +2789,7 @@ void ResetDynamicStateHlht(const UINT8 ciId)
UINT16 ii = 0u;
UINT16 devId = 0u;/*不对Id进行清除，清除Id后则设备Id为其他设备属性还存在，Id为静态属性，一旦设置为0后就不能更改*/
UINT16 devLen = 0u;
UINT8 belongCiId = 0U;
/*重置非本联锁道岔动态数据*/
for (ii = 1u; ii < SWITCH_SUM_MAX; ii++)
@@ -2671,6 +2806,7 @@ void ResetDynamicStateHlht(const UINT8 ciId)
/*设置道岔当前位置 【挤岔】*/
SwitchDataStru[devId].SwitchCurPosition = SWITCH_POSITION_JICHA; /*道岔当前位置*/
SwitchDataStru[devId].SingleSwitchCurPosition = SWITCH_POSITION_JICHA; /*单独道岔当前位置*/
SwitchDataStru[devId].LockStatus = SWITCH_LOCK_STATUS_NO;
}
}
@@ -2692,6 +2828,7 @@ void ResetDynamicStateHlht(const UINT8 ciId)
PhysicalSectionDataStru[ii].CurAndMergeOccupyState = SECTION_OCCUPY_YES;
PhysicalSectionDataStru[ii].PreOccupyState = SECTION_OCCUPY_YES;
PhysicalSectionDataStru[ii].CurOccupyState = SECTION_OCCUPY_YES;
PhysicalSectionDataStru[ii].PhySecPreResetState = PHYSICAL_SECTION_PRE_RESET_NO;
}
}
@@ -2775,6 +2912,17 @@ void ResetDynamicStateHlht(const UINT8 ciId)
spksDataBuff[devId].cutStatus = SPKS_CUT_NO; /*SPKS旁路状态：未按下*/
}
}
for (ii = 1u; ii < AUTO_ROUTE_SUM_MAX; ii++)
{
devId = ii;
belongCiId = GetAutoRouteBelongCiId(devId);
if (belongCiId == ciId)
{
/*非本联锁重置状态*/
AutoRouteDataStru[devId].AutoRouteSetFlag = AUTO_ROUTE_SET_NO; /*自动进路未办理*/
}
}
}
/*
@@ -2799,6 +2947,7 @@ void InitOcData(void)
for (k = 0U; k < OC_COLL_BOARD_POS_NUM; k++)
{
m_OcConvertedPtDataArr[i].BoardDatas[j].PosValueBuf[k] = 0u;
m_OcConvertedPtDataArr[i].BoardDatas[j].TolerateCycNum[k] = 0u;
}
}
@@ -2811,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;
}
@@ -3113,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;
@@ -3133,6 +3281,10 @@ UINT8 InitialRtnIndicStaData(void)
NonReturnDataStru[wNonAutoReturnId].RtnRelayAdhesionState.RelayUpCycNum = 0U;
}
/*初始化车车结构体成员*/
NonReturnDataStruCC[wNonAutoReturnId].IndicatorDevID = wNonAutoReturnId;
NonReturnDataStruCC[wNonAutoReturnId].cmdSetTrainId = 0U;
}
}
else
@@ -3193,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/InvadeSection/InvadeSectionDefine.h
+1 -1
View File
@@ -14,7 +14,7 @@
#ifndef __INVADESECTION_DEFINE_H_
#define __INVADESECTION_DEFINE_H_
#define INVA_SECT_N_COND_SWIT_SUM_MAX ((UINT16)300) /*侵限区段与相关条件道岔数据条目最大数量*/
#define INVA_SECT_N_COND_SWIT_SUM_MAX ((UINT16)400) /*侵限区段与相关条件道岔数据条目最大数量*/
#define COND_SWITCH_SUM_MAX ((UINT16)16) /*单一侵限区段与相关条件道岔数据条目内,条件道岔最大数量*/
TSCP/src/APP/ciapp/LogRecord/LogRecord.c
+221 -103
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();
@@ -484,8 +503,8 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
UINT16 deviceNum = 0u;
UINT8 localCiType = 0u;
UINT16 wNonAutoReturnCurSum = 0U;/*无人折返按钮当前总数*/
NonAutoReturnDataStruct* pNonAutoReturnData = NULL;/*无人折返数据结构体指针*/
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)
@@ -526,7 +546,18 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
outString[outStringLength++] = newPhysicalSectionData[deviceId].CurMergeOccupyState;/*当前融合占用状态*/
outString[outStringLength++] = newPhysicalSectionData[deviceId].PreAndMergeOccupyState;/*之前与占用融合占用状态*/
outString[outStringLength++] = newPhysicalSectionData[deviceId].CurAndMergeOccupyState;/*当前与占用融合占用状态*/
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; /*物理区段停止检查标志(未设置/设置) (动态字段)*/
@@ -544,8 +575,6 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
outStringLength += 4u;
LongToChar(newPhysicalSectionData[deviceId].FaultUnlockStartCycNum,&outString[outStringLength]);/*区故解解锁延时开始周期*/
outStringLength += 4u;
LongToChar(newPhysicalSectionData[deviceId].SectionResetStartCycNum,&outString[outStringLength]);/*区段计轴复位开始周期*/
outStringLength += 4u;
outString[outStringLength++] = newPhysicalSectionData[deviceId].FLockType; /*物理区段封锁产生的原因,SPKS或其他原因*/
outString[outStringLength++] = newPhysicalSectionData[deviceId].UtOrCtOccFlag; /*获取物理区段占用标志*/
ShortToChar(newPhysicalSectionData[deviceId].SecProUseBelongRouteId,&outString[outStringLength]);/*征用所属进路ID*/
@@ -558,8 +587,14 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
outString[outStringLength++] = newPhysicalSectionData[deviceId].chABLTrainFlag; /*物理区段ABL列车占用状态*/
outString[outStringLength++] = newPhysicalSectionData[deviceId].chPreABLTrainFlag; /*物理区段之前ABL列车占用状态*/
outString[outStringLength++] = newPhysicalSectionData[deviceId].cPhySecInHumidRailFlag; /*物理区段湿轨标志：0x55 无效；0xAA 有效*/
LongToChar(newPhysicalSectionData[deviceId].UtOrCtOccuStartCycNum, &outString[outStringLength]);/*区段UT或CT占用起始周期号*/
outStringLength += 4u;
}
}
else
{
/*数据一致，不处理*/
}
}
if (0u == outStringLength)
@@ -606,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)
@@ -621,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;/*之前驱动颜色*/
@@ -633,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自动扣车标志*/
@@ -652,6 +694,7 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
outString[outStringLength++] = newSignalData[deviceId].GreenDsBreakFlag;/*绿灯丝断丝标志状态*/
outString[outStringLength++] = newSignalData[deviceId].YellowDsBreakFlag;/*黄灯丝断丝标志状态*/
outString[outStringLength++] = newSignalData[deviceId].WhiteDsBreakFlag;/*白灯丝断丝标志状态*/
outString[outStringLength++] = newSignalData[deviceId].BlueDsBreakFlag;/*蓝灯丝断丝标志状态*/
outString[outStringLength++] = newSignalData[deviceId].RedYellowDsBreakFlag;/*红黄灯丝断丝标志状态*/
outString[outStringLength++] = newSignalData[deviceId].RedWhiteDsBreakFlag;/*红白灯丝断丝标志状态*/
outString[outStringLength++] = newSignalData[deviceId].GreenYellowDsBreakFlag;/*绿黄灯丝断丝标志状态*/
@@ -659,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数量*/
@@ -668,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;
}
}
@@ -683,16 +726,28 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
outString[outStringLength++] = newSignalData[deviceId].CancelDetainBtnErrFlag; /*取消扣车按钮故障标志*/
outString[outStringLength++] = newSignalData[deviceId].CancelDetainBtnValidFlag; /*取消扣车按钮有效标志*/
outString[outStringLength++] = newSignalData[deviceId].CancelDetainRelayDownState; /*取消扣车按钮采集继电器落下状态*/
LongToChar(newSignalData[deviceId].DetainBtnPressCycNum, &outString[outStringLength]); /*扣车按钮按下周期*/
LongToChar(newSignalData[deviceId].DetainBtnPressCycNum, &outString[outStringLength]); /*扣车按钮1按下周期*/
outStringLength += 4u;
LongToChar(newSignalData[deviceId].DetainSndBtnPressCycNum, &outString[outStringLength]); /*扣车按钮2按下周期*/
outStringLength += 4U;
LongToChar(newSignalData[deviceId].CancelDetainBtnPressCycNum, &outString[outStringLength]); /*取消扣车按钮正常按下周期*/
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++;
LongToChar(newSignalData[deviceId].DetCutBtnPressCycNum, &outString[outStringLength]); /*扣车旁路按钮正常按下周期*/
outStringLength += 4U;
LongToChar(newSignalData[deviceId].DetCutBtnErrTrigPressCycNum, &outString[outStringLength]); /*扣车旁路按钮误触发按下周期*/
outStringLength += 4U;
outString[outStringLength] = newSignalData[deviceId].cDetCutBtnErrFlag; /*扣车旁路按钮故障标志：0x55未故障，0xaa故障*/
outStringLength++;
outString[outStringLength] = newSignalData[deviceId].cDetCutBtnRelayDownState; /*扣车旁路按钮采集继电器落下状态：0x55：正常采集落下，0xaa：通信异常落下*/
outStringLength++;
}
}
else
@@ -762,6 +817,7 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
outString[outStringLength++] = pNewEsbData[deviceId].EssSteadyState;/*ESS稳灯状态（用于虚拟联锁向ATS反馈）--0x55 需要设置稳灯；0xaa不需要设置稳灯*/
outString[outStringLength++] = pNewEsbData[deviceId].EssFlashState;/*ESS闪灯状态（用于虚拟联锁向ATS反馈）--0x55 需要设置闪灯；0xaa不需要设置闪灯*/
outString[outStringLength++] = pNewEsbData[deviceId].EsbErrorFlag;/*自复式紧急停车按钮故障标志，0x55未故障，0xaa故障*/
outString[outStringLength++] = pNewEsbData[deviceId].EsbRelayDownState;/*紧急关闭按钮采集继电器落下状态，0x55：正常采集落下，0xaa：通信异常落下*/
outString[outStringLength++] = pNewEsbData[deviceId].CancelEsbErrorFlag;/*自复式取消紧急停车按钮故障标志，0x55未故障，0xaa故障*/
outString[outStringLength++] = pNewEsbData[deviceId].CancelEsbValidFlag;/*取消紧急关闭按钮有效标志，0x55无效，0xaa有效*/
outString[outStringLength++] = pNewEsbData[deviceId].CancelEsbRelayDownState;/*取消紧急关闭按钮采集继电器落下状态，0x55：正常采集落下，0xaa：通信异常落下*/
@@ -771,6 +827,12 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
outStringLength += 4u;
LongToChar(pNewEsbData[deviceId].CancelEsbErrTriggerPressCycNum, &outString[outStringLength]);/*取消紧急关闭按钮误触发按下周期*/
outStringLength += 4U;
outString[outStringLength++] = pNewEsbData[deviceId].EsbCutErrorFlag; /*紧急关闭旁路按钮故障标志，0x55未故障，0xaa故障*/
outString[outStringLength++] = pNewEsbData[deviceId].EsbCutRelayDownState; /*紧急关闭旁路按钮采集继电器落下状态，0x55：正常采集落下，0xaa：通信异常落下*/
LongToChar(pNewEsbData[deviceId].EsbCutPressCycNum, &outString[outStringLength]); /*紧急关闭旁路按钮按下周期*/
outStringLength += 4u;
LongToChar(pNewEsbData[deviceId].EsbCutErrTriggerPressCycNum, &outString[outStringLength]); /*紧急关闭旁路按钮误触发按下周期*/
outStringLength += 4U;
}
}
else
@@ -936,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)
@@ -976,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;/*列车驶入标志*/
@@ -994,7 +1061,9 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
outStringLength += 4u;
outString[outStringLength++] = newRouteData[deviceId].DCQState;/*调车请求状态*/
outString[outStringLength++] = newRouteData[deviceId].DCTYState;/*调车同意状态*/
LongToChar(newRouteData[deviceId].dwDcAgreeBtnPressCycNum, &outString[outStringLength]);/*调车同意按钮按下起始周期*/
outStringLength += 4u;
outString[outStringLength++] = newRouteData[deviceId].chDcAgreeButtonErrState;/*调车同意按钮故障状态*/
outString[outStringLength++] = newRouteData[deviceId].DCTYNotSatisfySignalReOpenFlag;/*调车同意不满足-信号重开标志*/
LongToChar(newRouteData[deviceId].DCTYNotSatisfyStartCount,&outString[outStringLength]);/*调车同意不满足-起始周期*/
outStringLength += 4u;
@@ -1006,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;
}
}
@@ -1027,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;
}
@@ -1044,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;
}
@@ -1063,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;
}
@@ -1083,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; /*关联组合进路声光报警是否延时标志*/
@@ -1094,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
@@ -1236,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)
@@ -1257,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]);/*逻辑延时解锁周期号*/
@@ -1268,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
@@ -1322,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
@@ -1463,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)
@@ -1483,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;/*屏蔽门驱动状态*/
@@ -1492,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;/*站台开门按钮状态*/
@@ -1528,8 +1620,11 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
outString[outStringLength++] = newPsdData[deviceId].chVideoQkDriveState; /*视频清客驱动状态*/
ShortToChar(newPsdData[deviceId].wVideoQkRelateVobcId, &outString[outStringLength]);/*视频清客对应列车ID*/
outStringLength += 2u;
outString[outStringLength] = newPsdData[deviceId].cPsdExceptOpenState; /*屏蔽门异常打开状态：0x55-异常打开，0xAA-未异常打开*/
outStringLength++;
LongToChar(newPsdData[deviceId].dwPsdRelayDownCycNum, &outString[outStringLength]); /*PSD门关继电器落下起始周期*/
outStringLength += 4U;
}
}
else
{
@@ -1572,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)
{/*比较数据一致*/
@@ -1592,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; /*车库门旁路状态*/;
@@ -1600,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;
@@ -1649,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 )
{/*比较数据一致*/
@@ -1674,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; /*列车同意防淹门关门请求状态*/
}
}
@@ -1730,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)
{/*比较数据一致*/
@@ -1750,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;/*保护区段人工解锁设置状态*/
@@ -1766,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：成功）*/
@@ -1844,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)
@@ -1858,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;
}
}
@@ -1997,7 +2104,8 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
LongToChar(pNewSpksData[deviceId].flockStartNum, &outString[outStringLength]);
outStringLength += 4U;
outString[outStringLength++] = pNewSpksData[deviceId].TotalSpksDriveOutDis;
LongToChar(pNewSpksData[deviceId].dwSpksBtnPressCycNum, &outString[outStringLength]); /*SPKS按钮按下起始周期号*/
outStringLength += 4U;
}
}
else
@@ -2015,7 +2123,7 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
else
{
#ifdef PLATFORM_2OO2
debug_infor_printf((const)"\nSpksData:%d\spksId(2)-status-cutStatus-flockStartNum(4)-TotalSpksDriveOutDis:%d", (UINT16)sizeof(SpksDataStruct), outStringLength);
debug_infor_printf((const)"\nSpksData:%d\nspksId(2)-status-cutStatus-flockStartNum(4)-TotalSpksDriveOutDis:%d", (UINT16)sizeof(SpksDataStruct), outStringLength);
debug_out_array(0xAA, outString, outStringLength);
#endif
@@ -2115,6 +2223,9 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
LongToChar(pNewTrainInfoData[deviceId].dwDelayTime, &outString[outStringLength]);/*消息延迟时间*/
outStringLength += 4u;
LongToChar(pNewTrainInfoData[deviceId].dwStartFlyCycNum, &outString[outStringLength]);/*列车飞车起始周期号*/
outStringLength += 4U;
ShortToChar(pNewTrainInfoData[deviceId].wGroupOtherTrainId, &outString[outStringLength]);/* 编组另一列车ID*/
outStringLength += 2u;
@@ -2251,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位置*/
}
@@ -2669,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)
@@ -2690,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
+36 -7
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); /*获取防护道岔数据*/
@@ -586,20 +588,30 @@ void SetRouteRelProSwitchLockSta(const UINT16 routeId, const UINT8 lockCommand)
if (CI_SUCCESS == retVal)
{
for (ii= 0u; ii < routeProtectSwitchSum; ii++)
for (ii = 0u; ii < routeProtectSwitchSum; ii++)
{
protectSwitchId = routeProtectSwitchStru[ii].ProtectSwitchId;
SetSwitchLockStatus(SWITCH_PLOCKTYPE_ROUTE,routeId,protectSwitchId, lockCommand); /*设置道岔防护锁闭状态*/
/*RC 13.0.0 修：不检查防护道岔中双动道岔另一端*/
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
if (SWITCH_TYPE_DOUBLE == GetSwitchType(protectSwitchId))
{ /*双动道岔*/
SetSwitchLockStatus(SWITCH_PLOCKTYPE_ROUTE,routeId,GetDSwitchOtherId(protectSwitchId), lockCommand); /*设置道岔防护锁闭状态*/
if (SWITCH_TYPE_DOUBLE == GetSwitchType(protectSwitchId))
{ /*双动道岔*/
SetSwitchLockStatus(SWITCH_PLOCKTYPE_ROUTE, routeId, GetDSwitchOtherId(protectSwitchId), lockCommand); /*设置道岔防护锁闭状态*/
}
else
{
}
#endif
}
else
{
/*防护道岔不在防护位置或防护道岔存在反向驱动，不设置防护锁闭*/
}
#endif
}
}
else
@@ -1379,6 +1391,7 @@ void RouteRecoverOpenProc(const UINT16 routeId)
UINT8 recoverState = ROUTE_RECOVER_STA_STAY;/*当前恢复重开状态*/
UINT8 errType = CI_ERROR;
UINT8 localCiType = GetLocalCiType();/*获得联锁类型*/
UINT16 wStartSignalId = 0U; /*进路始端信号机ID*/
routeState = GetRouteState(routeId);
recoverState = GetRouteRecoverOpenFlag(routeId);
@@ -1396,6 +1409,7 @@ void RouteRecoverOpenProc(const UINT16 routeId)
errType = RecoverOpenRouteCheckCLD(routeId);
}
wStartSignalId = GetRouteStartSignalId(routeId); /*获取进路始端信号机ID*/
if (errType == CI_SUCCESS)
{
SetRouteOpenSigStartCycNum(routeId, Get2oo2CurCycleNum());
@@ -1410,6 +1424,9 @@ void RouteRecoverOpenProc(const UINT16 routeId)
else
{
SetRouteRecoverState(routeId, ROUTE_RECOVER_STA_STAY);/*一旦出现PSD、SPKS、扣车以外的条件不满足，将进路恢复状态设置为不可恢复*/
/*开放条件检查失败，设置对应始端信号机扣车旁路按钮无效*/
SetDetCutBtnState(wStartSignalId, SIGNAL_DETAIN_CUT_VALID_NO);
}
}
}
@@ -1922,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/InterlockCommonManage.h
+1
View File
@@ -41,6 +41,7 @@
#include "../LogicManage/TradInterlockLogicManage.h"
#include "../Train/TrainDefine.h"
#include "LogicalRouteDataManage.h"
#include "../EnvelopeManage/EnvelopeManageAPI.h"
#ifdef SCADE_MODE
#include "../LogicManage/General/LogicManageScadeInterface.h"
TSCP/src/APP/ciapp/LogicManage/InterlockLogicManage.c
+1175 -235
View File
File diff suppressed because it is too large Load Diff
TSCP/src/APP/ciapp/LogicManage/InterlockLogicManage.h
+41 -2
View File
@@ -365,9 +365,11 @@ void SetOverlapLockState(const UINT16 overlapId, const UINT8 lockState, const UI
/*
* 功能描述： 办理普通进路逻辑管理
* 参数说明： const UINT16 routeId, 进路ID
* const UINT8 chSendLevel 命令发送等级
* 返回值 ： void
* BY cgh 20250828
*/
void SetCommonRouteLogicManage(const UINT16 routeId);
void SetCommonRouteLogicManage(const UINT16 routeId, const UINT8 chSendLevel);
/*
* 功能描述： 办理引导进路逻辑管理
@@ -947,7 +949,7 @@ UINT8 CheckPhysecFlockReasonSpksId(const UINT16 phySectionId, UINT16* spksId, UI
*
*修改：mpt 2022年3月9日 增加保护区段人工解锁逻辑
*/
UINT8 LaborUnlockOverlapProc(const UINT8 overlapId);
UINT8 LaborUnlockOverlapProc(const UINT16 overlapId);
/*
* 功能描述： 设置联锁锁闭保护区段标志管理
* 参数说明： const UINT16 routeId, 进路ID
@@ -1131,6 +1133,43 @@ void RouteTrainResUnlockManage(void);
*/
void LeadRouteFirstXuanPaiManage(const UINT16 routeId);
/*
* 功能描述： 设置OC-P旁路状态确认标志
* 参数说明： UINT8 setFlag,设置标志
* UINT16 pscId PSC设备ID
* 返回值 ：无
*/
void SetOcPscPlConfirmFlag(UINT8 setFlag, const UINT16 ocPId);
/*
* 功能描述： 保护区段状态更新
* 参数说明： const UINT16 wRouteId 进路ID
* 返回值 ：无
* by cgh 20250928
*/
void OverlapStateUpdateManage(void);
/*
* 功能描述： 更新列车向后跳跃允许状态处理
* 参数说明： 无
* 返回值 ： 无
* Create: fan 20250725
*/
void TrainJumpBackApplyProc(void);
/*
* 功能描述： 办理联挂进路逻辑管理
* 参数说明： const UINT16 wRouteId
* 返回值 ： 无
* Create: 20250917
*/
void SetCouplinkRouteLogicManage(const UINT16 wRouteId);
/*
* 功能描述： 锁闭道岔逻辑管理
* 参数说明： void
* 返回值 ：
*/
void lockSwitchLogicManage(void);
#ifdef __cplusplus
}
#endif
TSCP/src/APP/ciapp/LogicManage/RouteRecoverManage.c
+200 -132
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,24 +325,36 @@ UINT8 OpenCbtcLTrainRouteErrProcess(const UINT16 routeId, const UINT8 checkStep)
{
routeReverseProperty = GetRouteReverseProperty(routeId);
airShaftRouteType = GetAirShaftRouteType(routeId);
if ((ROUTE_REVERSE_PROPERTY_YES == routeReverseProperty) || (ROUTE_TYPE_AIRSHAFT == airShaftRouteType))
{ /*反向进路需检查所有区段的占用状态，之前由于不检查占用状态导致信号出清进路内方第一区段，信号机重开的问题*/
/*风井进路不允许追踪办理，故开放条件需增加对进路内方所有区段的占用状态检查*/
devId = 0u;
devState = 0u;
checkResult = RouteAllSecOccuClearCheck(routeId,&devId, &devState);
if (checkResult == CI_SUCCESS)
chRouteCouplinkFlag = GetRouteCouplinkFlag(routeId); /*获取进路联挂标志*/
if ((ROUTE_REVERSE_PROPERTY_YES == routeReverseProperty)|| (ROUTE_TYPE_AIRSHAFT == airShaftRouteType))
{
if (ROUTE_COUPLINK_FLAG_YES == chRouteCouplinkFlag)
{
/* 通过检查 */
reResult = CI_SUCCESS;
/* 反向联挂进路允许追踪，区段条件在OpenCbtcRouteSectionErrCheck */
/*存在联挂标志，不在查反向进路全部空闲，其他条件检查;风井进路设置不上联挂标志所以需要检查全部区段空闲*/
}
else
{
/* 记录故障码 */
SetErrorData(functionId,CI_DEVICE_TYPE_PHYSEC,devId,ETYPE_PS_MERGY_OCU_STATE,devState,sendLevel);
/* 失败返回 */
reResult = CI_ERROR;
/*反向进路需检查所有区段的占用状态，之前由于不检查占用状态导致信号出清进路内方第一区段，信号机重开的问题*/
/*风井进路不允许追踪办理，故开放条件需增加对进路内方所有区段的占用状态检查*/
devId = 0u;
devState = 0u;
checkResult = RouteAllSecOccuClearCheck(routeId, &devId, &devState);
if (checkResult == CI_SUCCESS)
{
/* 通过检查 */
reResult = CI_SUCCESS;
}
else
{
/* 记录故障码 */
SetErrorData(functionId, CI_DEVICE_TYPE_PHYSEC, devId, ETYPE_PS_MERGY_OCU_STATE, devState, sendLevel);
/* 失败返回 */
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;
checkResult = RouteAllSecOccuClearCheck(routeId, &devId, &devState);
if (checkResult == CI_SUCCESS)
chRouteCouplinkFlag = GetRouteCouplinkFlag(routeId); /*获取进路联挂标志*/
if (ROUTE_COUPLINK_FLAG_YES == chRouteCouplinkFlag)
{
checkResult = SetCouplinkRouteSecOccCheck(routeId, &devId, &devState);
}
else
{
checkResult = RouteAllSecOccuClearCheck(routeId, &devId, &devState);
}
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;
checkResult = RouteAllSecOccuClearCheck(routeId,&devId, &devState);
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)
@@ -1991,7 +2022,16 @@ UINT8 KeepCbtcReturnRouteErrProcess(const UINT16 routeId)
}
else if(RC_WORK_MODE_CI == rcWorkMode)
{
checkResult = RouteAllSecOccuClearCheck(routeId, &devId, &devState);
chRouteCouplinkFlag = GetRouteCouplinkFlag(routeId); /*获取进路联挂标志*/
if (ROUTE_COUPLINK_FLAG_YES == chRouteCouplinkFlag)
{
checkResult = KeepCouplinkRouteSecOccCheck(routeId, &devId, &devState);
}
else
{
checkResult = RouteAllSecOccuClearCheck(routeId, &devId, &devState);
}
if (CI_SUCCESS == checkResult)
{
/* 通过检查 */
@@ -3011,10 +3051,9 @@ UINT8 RecoverOpenRouteCheckCLD(const UINT16 routeId)
UINT8 routeType = 0u; /*进路类型*/
UINT8 errType = CI_ERROR;/*定义检查失败时的错误类型*/
UINT8 jkjRelayValidFlag = 0u; /*初始化应急盘继电器有效状态*/
UINT16 jkjRelayId = GetJkjRelayId();
jkjRelayValidFlag = GetCiJkjFlag();
routeType = GetRouteType(routeId); /*获取进路类型*/
if ((jkjRelayId > 0u) && (JKJ_REYLAY_VALID == jkjRelayValidFlag))
if (JKJ_REYLAY_VALID == jkjRelayValidFlag)
{/*应急盘继电器有效状态,不允许信号重开*/
errType = CI_ERROR;
}
@@ -3585,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;
@@ -3647,8 +3689,6 @@ static UINT8 OpenBlocRouteOverlapErrCheck(const UINT16 routeId)
reResult = CI_ERROR;
}
}
}
else
{
@@ -3691,43 +3731,49 @@ static UINT8 OpenBlocRouteOverlapErrCheck(const UINT16 routeId)
}
}
/*保护区段关联防护道岔【位置正确】*/
if(CI_SUCCESS == reResult)
if (FUNC_SWITCH_ON == cSndSideProFuncSwitch)
{
devId = 0u;
devState = 0u;
checkResult = OvlpRelatedProtSwitchPosCheck(overlapId,&devId,&devState);
if (checkResult == CI_SUCCESS)
/*二级侧防开关配置为支持二级侧防时，可不检查保护区段防护道岔位置及可动性，通过检查侧防条件防护*/
}
else
{
/*保护区段关联防护道岔【位置正确】*/
if (CI_SUCCESS == reResult)
{
/* 通过检查 */
reResult = CI_SUCCESS;
devId = 0u;
devState = 0u;
checkResult = OvlpRelatedProtSwitchPosCheck(overlapId, &devId, &devState);
if (checkResult == CI_SUCCESS)
{
/* 通过检查 */
reResult = CI_SUCCESS;
}
else
{
/* 失败返回 */
reResult = CI_ERROR;
}
}
else
/*保护区段关联防护道岔【防护锁闭】或【单锁且防护锁闭】*/
if (CI_SUCCESS == reResult)
{
/* 失败返回 */
reResult = CI_ERROR;
devId = 0u;
devState = 0u;
checkResult = OvlpRelatedProtSwitchLockCheck(overlapId, &devId, &devState);
if (checkResult == CI_SUCCESS)
{
/* 通过检查 */
reResult = CI_SUCCESS;
}
else
{
/* 失败返回 */
reResult = CI_ERROR;
}
}
}
/*保护区段关联防护道岔【防护锁闭】或【单锁且防护锁闭】*/
if (CI_SUCCESS == reResult)
{
devId = 0u;
devState = 0u;
checkResult = OvlpRelatedProtSwitchLockCheck(overlapId,&devId, &devState);
if (checkResult == CI_SUCCESS)
{
/* 通过检查 */
reResult = CI_SUCCESS;
}
else
{
/* 失败返回 */
reResult = CI_ERROR;
}
}
if (CI_SUCCESS == reResult)
{
/*检查进路侵限条件状态*/
@@ -3743,13 +3789,21 @@ static UINT8 OpenBlocRouteOverlapErrCheck(const UINT16 routeId)
/*保护区段侧防条件检查*/
if ((CI_SUCCESS == reResult) || (CI_ROUTE_RECOVER_ERR == reResult))
{
/*检查保护区段侧防道岔区段状态*/
devId = 0u;
devState = 0u;
checkResult = OverlapLateralDfnCheck(overlapId, &devId, &devState);
if (CI_ERROR == checkResult)
if (FUNC_SWITCH_ON == cSndSideProFuncSwitch)
{
reResult = checkResult;
/*仅在二级侧防开关配置为支持二级侧防时才进行侧防条件检查*/
/*检查保护区段侧防道岔区段状态*/
devId = 0u;
devState = 0u;
checkResult = OlapSideProtectConditionCheck(overlapId, 0U, 0U);
if (CI_ERROR == checkResult)
{
reResult = checkResult;
}
}
else
{
/*不处理*/
}
}
@@ -3797,6 +3851,23 @@ static UINT8 OpenBlocRouteOverlapErrCheck(const UINT16 routeId)
}
}
/*检查照查继电器状态*/
if ((CI_SUCCESS == reResult) || (CI_ROUTE_RECOVER_ERR == reResult))
{
checkResult = OverlapZhaoChaRelayCheck(overlapId, ESEND_LEVEL_ZERO);
if (CI_ERROR == checkResult)
{
reResult = checkResult;
}
else
{
;
}
}
}
else
{
@@ -4249,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();
/* 联锁逻辑检查 */
@@ -4276,16 +4348,30 @@ static UINT8 OpenCbtcRouteSectionErrCheck(const UINT16 routeId)
}
else if (RC_WORK_MODE_CI == rcWorkMode)
{/*CI*/
/* 进路始端信号机【未跨压】且内方第一逻辑区段【空闲】*/
startSignalId = GetRouteStartSignalId(routeId);
devId = GetRouteInFirstLogSecId(routeId);
devState = GetLogSecCurOccupyState(devId);
if ((GetSignalCrossState(startSignalId) == SIGNAL_CROSS_STATE_NO) &&
(devState == SECTION_OCCUPY_NO))
chSigCrossState = GetSignalCrossState(startSignalId);
if (SIGNAL_CROSS_STATE_NO == chSigCrossState)
{
/* 通过检查 */
reResult = CI_SUCCESS;
chRouteCouplinkFlag = GetRouteCouplinkFlag(routeId); /*获取进路联挂标志*/
if (ROUTE_COUPLINK_FLAG_YES == chRouteCouplinkFlag)
{
/*联挂进路区段占用检查*/
reResult = SetCouplinkRouteSecOccCheck(routeId, &devId, &devState);
}
else
{
devId = GetRouteInFirstLogSecId(routeId);
devState = GetLogSecCurOccupyState(devId);
if (SECTION_OCCUPY_NO == devState)
{
/* 通过检查 */
reResult = CI_SUCCESS;
}
else
{
reResult = CI_ERROR;
}
}
}
else
{
@@ -4639,26 +4725,23 @@ static UINT8 RouteIntruSecVainSPKSErrCheck(const UINT16 routeId)
*/
static UINT8 RouteRelayZhaoChaErrCheck(UINT16 const routeId)
{
/* 局部变量定义初始化 */
UINT16 relayId = 0U;
UINT8 relayState = 0U;
UINT8 zcPhySecSum = 0U; /*照查物理区段数目*/
UINT16* pZcPhySecIdBuf = NULL; /*照查物理区段ID数组*/
UINT8 ii = 0U;
/* 局部变量定义初始化 */
UINT16 relayId = 0U;
UINT8 relayState = 0U;
UINT8 zcPhySecSum = 0U; /*照查物理区段数目*/
UINT16* pZcPhySecIdBuf = NULL; /*照查物理区段ID数组*/
UINT8 ii = 0U;
UINT16 thisRealyId = 0U;
UINT8 thisRelayState = 0U;
UINT8 thisRelayState = 0U;
UINT8 routeState = 0U;
UINT8 retVal = CI_ERROR; /*函数返回值*/
UINT16 pDevId = 0U;
UINT8 pDevState = 0U;
UINT8 chRouteLevel = 0U;
UINT8 chErrTemp = 0U;
/* 对端照查检查 */
zcPhySecSum = GetRouteThatZhaoChaPhySecSum(routeId); /*获取照查物理区段数目*/
/* 对端照查检查 */
zcPhySecSum = GetRouteThatZhaoChaPhySecSum(routeId); /*获取照查物理区段数目*/
pZcPhySecIdBuf = GetRouteThatZhaoChaPhySecIdBuf(routeId); /*获取照查物理区段ID数组*/
/*进路监督级别确认*/
chRouteLevel = GetRouteLevel(routeId);
if (NULL == pZcPhySecIdBuf)
{
@@ -4668,14 +4751,14 @@ static UINT8 RouteRelayZhaoChaErrCheck(UINT16 const routeId)
{
retVal = CI_SUCCESS;
for (ii = 0u; ii < zcPhySecSum; ii++)
{
retVal = RoutePhySecZhaoChaErrCheck(routeId,pZcPhySecIdBuf[ii]);
for (ii = 0u; ii < zcPhySecSum; ii++)
{
retVal = RoutePhySecZhaoChaErrCheck(routeId, pZcPhySecIdBuf[ii]);
if (CI_ERROR == retVal)
{
break;
}
else if(CI_ROUTE_RECOVER_ERR == retVal) /*YF00083-1013,出现一个封锁即跳出，防止两个物理区段，一个封锁在前检查，一个未封锁在后检查覆盖掉retVal的值*/
else if (CI_ROUTE_RECOVER_ERR == retVal) /*YF00083-1013,出现一个封锁即跳出，防止两个物理区段，一个封锁在前检查，一个未封锁在后检查覆盖掉retVal的值*/
{
chErrTemp++; /*有一个SPKS封锁就计数一次*/
}
@@ -4688,24 +4771,13 @@ static UINT8 RouteRelayZhaoChaErrCheck(UINT16 const routeId)
{
retVal = CI_ROUTE_RECOVER_ERR; /*出现过一个SPKS封锁，就赋值返回值为SPKS封锁*/
}
}
}
}
if ((CI_SUCCESS == retVal) || (CI_ROUTE_RECOVER_ERR == retVal))
if ((CI_SUCCESS == retVal) || (CI_ROUTE_RECOVER_ERR == retVal))
{/*照查物理区段检查通过,检查本端照查继电器*/
if (ROUTE_LEVEL_BLOC == chRouteLevel)
{
thisRealyId = GetRouteThisZhaoChaRelayId(routeId); /*后备模式本端照查继电器ID*/
}
else if (ROUTE_LEVEL_CBTC == chRouteLevel)
{
thisRealyId = GetRouteCbtcThisZhaoChaRelayId(routeId);/*CBTC模式本端照查继电器ID*/
}
else
{
; /*非法监督模式，继电器ID为0，在下面不会处理*/
}
thisRealyId = GetRouteThisZhaoChaRelayId(routeId); /*本端照查继电器ID*/
thisRelayState = GetRelayCollState(thisRealyId); /*获取指定ID继电器的状态*/
routeState = GetRouteState(routeId); /*获取进路状态*/
@@ -4713,20 +4785,27 @@ static UINT8 RouteRelayZhaoChaErrCheck(UINT16 const routeId)
{/*存在本端照查继电器*/
if ((ROUTE_STATE_FIRST_LOCKERR == routeState) ||
(ROUTE_STATE_YUXIAN_LOCK == routeState) ||
(ROUTE_STATE_NEAR_LOCKERR == routeState) ||
(ROUTE_STATE_YUXIAN_OPEN == routeState) ||
(ROUTE_STATE_NEAR_OPEN == routeState) ||
(ROUTE_STATE_YUXIAN_OPEN == routeState))
(ROUTE_STATE_NEAR_LOCK == routeState) ||
(ROUTE_STATE_NEAR_LOCKERR == routeState) ||
(ROUTE_STATE_DELAY_UNLOCK == routeState) ||
(ROUTE_STATE_AUTO_UNLOCK == routeState) ||
(ROUTE_STATE_AUTO_UNLOCKERR == routeState) ||
(ROUTE_STATE_HALF_UNLOCKDELAY == routeState) ||
(ROUTE_STATE_LEAD_LOCKERR == routeState) ||
(ROUTE_STATE_LEAD_OPEN == routeState))
{
/*进路状态初锁异常，预先锁闭，接近锁闭异常，接近开放，预先开放，
需判断本端照查的状态*/
if(RELAY_STATE_UP == thisRelayState)
/*需判断本端照查的状态*/
if (RELAY_STATE_UP == thisRelayState)
{
retVal = CI_ERROR;
}
}
else if (ROUTE_STATE_FIRST_LOCK == routeState)
else if ((ROUTE_STATE_FIRST_LOCK == routeState) ||
(ROUTE_STATE_LEAD_LOCK == routeState))
{
if(RELAY_STATE_UP == thisRelayState)
if (RELAY_STATE_UP == thisRelayState)
{
/*等待，返回等待标志*/
retVal = RELAY_STATE_WAITE;
@@ -4740,40 +4819,29 @@ static UINT8 RouteRelayZhaoChaErrCheck(UINT16 const routeId)
}
if ((CI_SUCCESS == retVal) || (CI_ROUTE_RECOVER_ERR == retVal))
if ((CI_SUCCESS == retVal) || (CI_ROUTE_RECOVER_ERR == retVal))
{/*本端照查继电器检查通过，检查对端照查继电器*/
if (ROUTE_LEVEL_BLOC == chRouteLevel)
{
relayId = GetRouteThatZhaoChaRelayId(routeId); /*后备模式对端照查继电器ID*/
}
else if (ROUTE_LEVEL_CBTC == chRouteLevel)
{
relayId = GetRouteCbtcThatZhaoChaRelayId(routeId);/*CBTC模式对端照查继电器ID*/
}
else
{
; /*非法监督模式，继电器ID为0，在下面不会处理*/
}
if(0u != relayId)
{/*存在对端照查继电器*/
relayId = GetRouteThatZhaoChaRelayId(routeId); /*对端照查继电器ID*/
relayState = GetRelayCollState(relayId);
if (0u != relayId)
{/*存在对端照查继电器*/
/* 照查吸起检查*/
if (RELAY_STATE_UP == relayState)
{
/*检查通过*/
}
else
{
retVal = CI_ERROR;
}
}
relayState = GetRelayCollState(relayId);
/* 照查吸起检查*/
if (RELAY_STATE_UP == relayState)
{
/*检查通过*/
}
else
{
retVal = CI_ERROR;
}
}
}
return retVal;
}
/*
TSCP/src/APP/ciapp/LogicManage/TradInterlockLogicManage.c
+155 -114
View File
@@ -50,58 +50,116 @@ void JKJRelayLogicProcess(void)
{
UINT16 wJkjRelayId = 0u;
UINT8 JkjRelayState = CI_ERROR;
UINT32 JkjRelayCycNum = 0u;
UINT32 JkjValidCycNum = 0u;
UINT32 yjValidCycNum = 0u;
UINT32 curCycNum = 0u;
UINT8 checkRes = CI_TIME_OUT;
UINT8 tmpRet =CI_ERROR;
UINT8 ii = 0u;
UINT8 haveYjkBreakFlag = 0u;
UINT8 ocYjkBreakFlag = 0u;
wJkjRelayId = GetJkjRelayId();
JkjRelayState = GetRelayCollState(wJkjRelayId); /*JKJ应急盘继电器采集状态*/
JkjRelayCycNum = GetRelayStateUpdateCycNum(wJkjRelayId); /*JKJ应急盘继电器状态更新周期*/
JkjValidCycNum = GetJkjRelayValidCycNum(); /*JKJ应急盘状态有效周期*/
yjValidCycNum = GetJkjRelayValidCycNum(); /*JKJ应急盘状态有效周期*/
curCycNum = Get2oo2CurCycleNum();
if ((wJkjRelayId > 0u) && (RELAY_STATE_DOWN == JkjRelayState))
for (ii = 0u; ii < m_OcToCiOrginDataNum; ii++)
{
curCycNum = Get2oo2CurCycleNum();
if (0u == JkjRelayCycNum)
{/*若未计时，则设置起始周期*/
tmpRet = SetRelayStateUpdateCycNum(wJkjRelayId,curCycNum);
if (CI_ERROR == tmpRet)
{
/*错误处理*/
}
if (OC_HAVE_YJK == m_OcToCiOrginDataArr[ii].chHaveYjk)
{/*任意一个OC具备应急控*/
haveYjkBreakFlag = 1u;
break;
}
checkRes = SystemOverTimeCheck(JkjRelayCycNum,JKJ_REYLAY_VALID_CYCLE_NUM);
if (CI_TIME_OUT == checkRes)
{ /*应急盘有效*/
SetCiJkjFlag(JKJ_REYLAY_VALID); /*设置JKJ应急盘有效标志为有效*/
if (0u == JkjValidCycNum) /*之前没有设置应急盘有效开始周期*/
{
SetJkjRelayValidCycNum(curCycNum); /*设置JKJ应急盘有效周期*/
}
else
{
; /*继续*/
}
}
else if ((wJkjRelayId > 0u) && (RELAY_STATE_UP == JkjRelayState))
{
tmpRet = SetRelayStateUpdateCycNum(wJkjRelayId, 0u); /*清除JKJ继电器有效起始周期号*/
if (CI_ERROR == tmpRet)
{
/*错误处理*/
}
/*应急盘无效*/
SetCiJkjFlag(JKJ_REYLAY_INVALID); /*设置JKJ应急盘继电器有效标志为无效*/
SetJkjRelayValidCycNum(0u); /*设置JKJ应急盘无效周期*/
for (ii = 0u; ii < m_OcToCiOrginDataNum; ii++)
{
if (OC_CTLMODE_YJK == m_OcToCiOrginDataArr[ii].chControlMode)
{/*任意一个OC是应急控*/
ocYjkBreakFlag = 1u;
break;
}
else
{
; /*继续*/
}
}
if (wJkjRelayId > 0u)
{
/*配置了继电器*/
if (RELAY_STATE_DOWN == JkjRelayState)
{/*落下*/
if (0u == yjValidCycNum)
{/*未计时*/
SetJkjRelayValidCycNum(curCycNum); /*设置应急有效周期*/
}
else
{
; /*不做处理*/
}
checkRes = SystemOverTimeCheck(yjValidCycNum, JKJ_REYLAY_VALID_CYCLE_NUM);
if (CI_TIME_OUT == checkRes)
{ /*应急有效*/
SetCiJkjFlag(JKJ_REYLAY_VALID); /*设置应急盘有效标志为有效*/
}
else
{
; /*不做处理*/
}
}
else if (RELAY_STATE_UP == JkjRelayState)
{/*吸起*/
/*应急无效*/
SetCiJkjFlag(JKJ_REYLAY_INVALID); /*设置应急盘有效标志为无效*/
SetJkjRelayValidCycNum(0u); /*设置应急无效周期*/
}
else
{
/*应急无效*/
SetCiJkjFlag(JKJ_REYLAY_VALID); /*设置应急盘有效标志为无效*/
SetJkjRelayValidCycNum(curCycNum); /*设置应急无效周期*/
}
}
else if(1u == haveYjkBreakFlag)
{
/*OC具备应急控*/
if (1u == ocYjkBreakFlag)
{/*有一个OC处于应急控,则应急有效*/
if (0u == yjValidCycNum)
{/*未计时*/
SetJkjRelayValidCycNum(curCycNum); /*设置应急有效周期*/
}
else
{
; /*不做处理*/
}
checkRes = SystemOverTimeCheck(yjValidCycNum, JKJ_REYLAY_VALID_CYCLE_NUM);
if (CI_TIME_OUT == checkRes)
{ /*应急有效*/
SetCiJkjFlag(JKJ_REYLAY_VALID); /*设置应急盘有效标志为有效*/
}
else
{
; /*不做处理*/
}
}
else
{/*应急无效*/
SetCiJkjFlag(JKJ_REYLAY_INVALID); /*设置应急盘有效标志为无效*/
SetJkjRelayValidCycNum(0u); /*设置应急无效周期*/
}
}
else
{
/*应急盘无效*/
SetCiJkjFlag(JKJ_REYLAY_INVALID); /*设置JKJ应急盘继电器有效标志为无效*/
SetJkjRelayValidCycNum(0u); /*设置JKJ应急盘继电器无效周期*/
/*JKJ未配置，OC无应急控功能，应急盘无效*/
SetCiJkjFlag(JKJ_REYLAY_INVALID); /*设置应急盘有效标志为无效*/
SetJkjRelayValidCycNum(0u); /*设置应急无效周期*/
}
}
/*
@@ -815,9 +873,6 @@ void RouteLogicProcess(void)
/*扣车、SPKS、PSD导致信号关闭又重开处理*/
RouteRecoverOpenProc(routeId);
/*进路调车同意逻辑处理*/
RouteDCTYLogicM(routeId);
/*根据进路状态清理相关标志*/
ClearSomeFlagDependRouteState(routeId);
/*cgh-合并CID-2349-5：*/
@@ -4360,37 +4415,22 @@ void NonRouteCancelDeal(UINT8 nonRouteId)
void UpdateZhaoChaDeal(const UINT16 routeId, const UINT8 routeState)
{
UINT16 wSelfRealyId = 0U; /*本模式本端照查ID*/
UINT16 wOtherRealyId = 0U; /*本模式本端照查ID*/
UINT8 relauDrvState = 0U;
UINT8 chRouteLevel = GetRouteLevel(routeId);
UINT8 chOverTimeCheck = 0U;
UINT32 dwTimeOutCycCount = 0U;
UINT32 dwRouteLockStartCycNum = 0U;
if (ROUTE_LEVEL_BLOC == chRouteLevel)
{
wSelfRealyId = GetRouteThisZhaoChaRelayId(routeId); /*后备模式本端照查继电器ID*/
wOtherRealyId = GetRouteCbtcThisZhaoChaRelayId(routeId); /*CBTC模式本端照查继电器ID*/
}
else if (ROUTE_LEVEL_CBTC == chRouteLevel)
{
wSelfRealyId = GetRouteCbtcThisZhaoChaRelayId(routeId); /*CBTC模式本端照查继电器ID*/
wOtherRealyId = GetRouteThisZhaoChaRelayId(routeId); /*后备模式本端照查继电器ID*/
}
else
{
; /*非法监督模式，继电器ID为0，在下面不会处理*/
}
wSelfRealyId = GetRouteThisZhaoChaRelayId(routeId); /*本端照查继电器ID*/
dwRouteLockStartCycNum = GetRouteLockStartCycNum(routeId);
dwTimeOutCycCount = GetSystemParaSignalCloseCyc();
if ((routeState == ROUTE_STATE_IDLE) ||
(routeState == ROUTE_STATE_FIRST_XUANPAI) ||
(routeState == ROUTE_STATE_XUANPAI) ||
(routeState == ROUTE_STATE_LEAD_FIRST_XUANPAI) ||
(routeState == ROUTE_STATE_LEAD_XUANPAI))
if (0U < wSelfRealyId)
{
/*进路空闲 两种模式照查都吸起*/
if (0U < wSelfRealyId)
if ((routeState == ROUTE_STATE_IDLE) ||
(routeState == ROUTE_STATE_FIRST_XUANPAI) ||
(routeState == ROUTE_STATE_XUANPAI) ||
(routeState == ROUTE_STATE_LEAD_FIRST_XUANPAI) ||
(routeState == ROUTE_STATE_LEAD_XUANPAI))
{
relauDrvState = GetRelayDriveState(wSelfRealyId);
if (RELAY_DRIVE_STATE_NULL == relauDrvState)
@@ -4398,34 +4438,15 @@ void UpdateZhaoChaDeal(const UINT16 routeId, const UINT8 routeState)
(void)SetRelayDriveState(wSelfRealyId, RELAY_STATE_UP);
}
}
if (0U < wOtherRealyId)
{
relauDrvState = GetRelayDriveState(wOtherRealyId);
if (RELAY_DRIVE_STATE_NULL == relauDrvState)
{
(void)SetRelayDriveState(wOtherRealyId, RELAY_STATE_UP);
}
}
}
else
{
/*进路锁闭 本模式照查落下，另一模式照查吸起*/
if (0U < wOtherRealyId)
{
relauDrvState = GetRelayDriveState(wOtherRealyId);
if (RELAY_DRIVE_STATE_NULL == relauDrvState)
{
(void)SetRelayDriveState(wOtherRealyId, RELAY_STATE_UP);
}
}
if (0U < wSelfRealyId)
else
{
(void)SetRelayDriveState(wSelfRealyId, RELAY_STATE_DOWN);
relauDrvState = GetRelayCollState(wSelfRealyId);
if (RELAY_STATE_DOWN != relauDrvState)
{ /*照查继电器未落下*/
chOverTimeCheck = CheckRelayDriveOutTime(wSelfRealyId, dwTimeOutCycCount);
if (CI_ERROR == chOverTimeCheck)
chOverTimeCheck = SystemOverTimeCheck(dwRouteLockStartCycNum, dwTimeOutCycCount);
if (CI_TIME_OUT == chOverTimeCheck)
{/*照查超时超时*/
/*xxxxx宕机*/
@@ -6099,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
{
@@ -6124,16 +6145,16 @@ UINT16 GetReturnId(const UINT16 routeId)
{
/*当前状态是接近锁闭异常*/
/* 如果是差至，如果列车驶入过进路，同时之前状态必须为接近锁闭正常（列车压入，信号关闭）
/* 如果是差至，如果列车驶入过进路，同时之前状态必须为接近锁闭开放
* 否则不认为是同一列车跨入中途折返处理
*/
if((ROUTE_STATE_NEAR_LOCK == preRouteState) && (TRAIN_ENTER_ROUTE_FLAG_YES == GetTrainEnterRouteFlag(routeId)))
if((ROUTE_STATE_NEAR_OPEN == preRouteState) && (TRAIN_ENTER_ROUTE_FLAG_YES == GetTrainEnterRouteFlag(routeId)))
{
returnSigId = GetRouteChaZhiSignalId(routeId); /*获取差置信号机ID*/
}
else
{
returnSigId = 0u;
returnSigId = 0U;
}
}
}
@@ -6166,6 +6187,8 @@ void DTrainReturnUnlockRouteAllLockP(const UINT16 routeId)
UINT8 chLockBelRouteType = 0U;/*区段锁闭所属进路进路类型*/
UINT8 chTrainEnterRouteFlag = 0U;/*列车驶入进路标志*/
UINT8 chRouteInOutSecOccupy = 0U;/*进路内外方同时占压标志*/
UINT32 dwRoutLockCycNum = 0U;
UINT32 dwReturnRoutLockCycNum = 0U;
routeState = GetRouteState(routeId); /*获取进路状态*/
routeType = GetRouteType(routeId);
@@ -6207,14 +6230,16 @@ void DTrainReturnUnlockRouteAllLockP(const UINT16 routeId)
wLockRouteStartSigId = GetRouteStartSignalId(lockBelongRouteId);/*获取进路始端信号机ID*/
chTrainEnterRouteFlag = CheckTrainEnterRoute(lockBelongRouteId);/*获取列车驶入进路标志*/
chRouteInOutSecOccupy = RouteInOutSecOccupy(lockBelongRouteId);/*进路内外方同时占用标志*/
dwRoutLockCycNum = GetRouteLockStartCycNum(routeId); /*获取进路锁闭起始周期*/
dwReturnRoutLockCycNum = GetRouteLockStartCycNum(lockBelongRouteId);/*获取折出进路锁闭起始周期*/
if ((ROUTE_STATE_NEAR_OPEN == chLockBelRouteState) && (ROUTE_TYPE_DIAOCHE == chLockBelRouteType) &&
(returnSigId == wLockRouteStartSigId) &&
(returnSigId == wLockRouteStartSigId) && (dwReturnRoutLockCycNum > dwRoutLockCycNum) &&
((CI_SUCCESS == chTrainEnterRouteFlag) ||
((CI_SUCCESS == chRouteInOutSecOccupy) && (ROUTE_TYPE_LIECHE == routeType))))
{
/*折出进路是调车进路&&状态是接近开放&&折出进路始端信号机是本进路折返信号机 &&（有车驶入 或 待解锁进路为列车进路是折出进路时内外方区段同时占压）*/
/*by cgh 20250414增加条件：折出进路锁闭时间晚于需中途解锁进路*/
/*解锁成功*/
SetRoutePhySectionLockState(routeId, PHYSICAL_SECTION_LOCK_NO); /*设置进路区段未锁闭*/
@@ -6224,10 +6249,10 @@ void DTrainReturnUnlockRouteAllLockP(const UINT16 routeId)
SetRouteStateDeal(routeId, ROUTE_STATE_IDLE); /*设置进路状态为空闲*/
}
if ((ROUTE_TYPE_LIECHE == chLockBelRouteType) && (ROUTE_STATE_NEAR_LOCK == chLockBelRouteState)
&& (returnSigId == wLockRouteStartSigId))
&& (returnSigId == wLockRouteStartSigId) && (dwReturnRoutLockCycNum > dwRoutLockCycNum))
{
/*折出进路是列车进路 且 进路状态是接近锁闭正常 且 折出进路始端信号机是本进路折返信号机*/
/*by cgh 20250414增加条件：折出进路锁闭时间晚于需中途解锁进路*/
/*解锁成功*/
SetRoutePhySectionLockState(routeId, PHYSICAL_SECTION_LOCK_NO); /*设置进路区段未锁闭*/
/*设置进路逻辑区段: 未锁闭*/
@@ -6265,6 +6290,8 @@ void DTrainRtnUnlockRemoteRAllLockP(const UINT16 routeId)
UINT8 chLockBelRouteType = 0U;/*区段锁闭所属进路进路类型*/
UINT8 chTrainEnterRouteFlag = 0U;/*列车驶入进路标志*/
UINT8 chRouteInOutSecOccupy = 0U;/*进路内外方同时占压标志*/
UINT32 dwRoutLockCycNum = 0U;
UINT32 dwReturnRoutLockCycNum = 0U;
routeState = GetRouteState(routeId); /*获取进路状态*/
routeType = GetRouteType(routeId);
@@ -6312,13 +6339,16 @@ void DTrainRtnUnlockRemoteRAllLockP(const UINT16 routeId)
wLockRouteStartSigId = GetRouteStartSignalId(lockBelongRouteId);/*获取进路始端信号机ID*/
chTrainEnterRouteFlag = CheckTrainEnterRoute(lockBelongRouteId);/*获取列车驶入进路标志*/
chRouteInOutSecOccupy = RouteInOutSecOccupy(lockBelongRouteId);/*进路内外方同时占用标志*/
dwRoutLockCycNum = GetRouteLockStartCycNum(routeId); /*获取进路锁闭起始周期*/
dwReturnRoutLockCycNum = GetRouteLockStartCycNum(lockBelongRouteId);/*获取折出进路锁闭起始周期*/
if ((ROUTE_STATE_NEAR_OPEN == chLockBelRouteState) && (ROUTE_TYPE_DIAOCHE == chLockBelRouteType) &&
(returnSigId == wLockRouteStartSigId) &&
(returnSigId == wLockRouteStartSigId) && (dwReturnRoutLockCycNum > dwRoutLockCycNum) &&
((CI_SUCCESS == chTrainEnterRouteFlag) ||
((CI_SUCCESS == chRouteInOutSecOccupy) && (ROUTE_TYPE_LIECHE== routeType))))
{
/*折出进路是调车进路&&状态是接近开放&&折出进路始端信号机是本进路折返信号机 &&（有车驶入 或 待解锁进路为列车进路是折出进路时内外方区段同时占压）*/
/*by cgh 20250414增加条件：折出进路锁闭时间晚于需中途解锁进路*/
/*解锁成功*/
SetRoutePhySectionLockState(routeId, PHYSICAL_SECTION_LOCK_NO); /*设置进路区段未锁闭*/
/*设置进路逻辑区段: 未锁闭*/
@@ -6326,9 +6356,10 @@ void DTrainRtnUnlockRemoteRAllLockP(const UINT16 routeId)
SetRouteStateDeal(routeId, ROUTE_STATE_IDLE); /*设置进路状态为空闲*/
}
if ((ROUTE_TYPE_LIECHE== chLockBelRouteType) && (ROUTE_STATE_NEAR_LOCK == chLockBelRouteState)
&& (returnSigId == wLockRouteStartSigId))
&& (returnSigId == wLockRouteStartSigId) && (dwReturnRoutLockCycNum > dwRoutLockCycNum))
{
/*折出进路是列车进路 且 进路状态是接近锁闭正常 且 折出进路始端信号机是本进路折返信号机*/
/*by cgh 20250414增加条件：折出进路锁闭时间晚于需中途解锁进路*/
/*解锁成功*/
SetRoutePhySectionLockState(routeId, PHYSICAL_SECTION_LOCK_NO); /*设置进路区段未锁闭*/
/*设置进路逻辑区段: 未锁闭*/
@@ -7090,37 +7121,47 @@ void CancelWashWorkLogicM(void)
* 功能描述： 进路调车同意逻辑管理
* 参数说明： void
* 返回值 ： void
* by cgh 20250523
*/
void RouteDCTYLogicM(UINT16 routeId)
void RouteDCTYLogic(UINT16 routeId)
{
UINT8 routeType = 0u;
UINT8 routeState = 0u;
UINT16 routeDCQJId = 0u;
UINT8 routeType = 0U;
UINT8 routeState = 0U;
UINT16 routeDCQJId = 0U;
UINT16 routeDCQJTwoId = 0U;
routeType = GetRouteType(routeId);/*进路类型*/
routeState = GetRouteState(routeId);/*进路状态*/
routeDCQJId = GetRouteDCQJId(routeId);
if ((routeDCQJId >0u) && (ROUTE_TYPE_DIAOCHE == routeType))
routeDCQJTwoId = GetRouteDCQJTwoId(routeId);
if ((0U < routeDCQJId) && (0U < routeDCQJTwoId) && (ROUTE_TYPE_DIAOCHE == routeType))
{/*调车请求继电器ID存在，且是调车进路*/
if((ROUTE_STATE_FIRST_LOCK == routeState) ||
(ROUTE_STATE_FIRST_LOCKERR == routeState) ||
(ROUTE_STATE_YUXIAN_LOCK == routeState) ||
(ROUTE_STATE_YUXIAN_OPEN == routeState) ||
(ROUTE_STATE_NEAR_OPEN == routeState) ||
(ROUTE_STATE_NEAR_LOCK == routeState) ||
(ROUTE_STATE_NEAR_LOCKERR == routeState)||
(ROUTE_STATE_LEAD_LOCK == routeState) ||
(ROUTE_STATE_LEAD_LOCKERR == routeState) ||
(ROUTE_STATE_LEAD_OPEN == routeState) ||
(ROUTE_STATE_DELAY_UNLOCK == routeState) ||
(ROUTE_STATE_NEAR_LOCK == routeState))
{/*进路是完整锁闭:进路初锁、进路初锁异常、预先锁闭、预先开放、接近开放、接近锁闭异常、接近锁闭正常
、引导锁闭、引导锁闭异常、引导开放、延时解锁*/
(void)SetRouteDCQState(routeId,ROUTE_DCQ_REQUEST);/*设置进路调车请求状态为调车请求*/
(ROUTE_STATE_AUTO_UNLOCK == routeState) ||
(ROUTE_STATE_AUTO_UNLOCKERR == routeState) ||
(ROUTE_STATE_DELAY_UNLOCK == routeState))
{
/*进路存在锁闭:进路初锁、进路初锁异常、预先锁闭、预先开放、接近开放、接近锁闭异常、接近锁闭正常、延时解锁、自动解锁正常、自动解锁异常*/
SetRouteDCQState(routeId,ROUTE_DCQ_REQUEST);/*设置进路调车请求状态调车请求有效*/
}
else
{/*非完整锁闭设置进路调车请求状态为非调车请求*/
(void)SetRouteDCQState(routeId,ROUTE_DCQ_NOT_REQUEST);
{
/*其它情况设置进路调车请求状态为调车请求无效;调车同意状态无效*/
SetRouteDCQState(routeId,ROUTE_DCQ_NOT_REQUEST);
SetRouteDCTYState(routeId, ROUTE_DCT_NOT_AGREE);
}
}
else
{
; /*不处理*/
}
}
/*
TSCP/src/APP/ciapp/LogicManage/TradInterlockLogicManage.h
+2 -1
View File
@@ -776,8 +776,9 @@ void CancelWashWorkLogicM(void);
* 功能描述： 进路调车同意逻辑管理
* 参数说明： void
* 返回值 ： void
* by cgh 20250523
*/
void RouteDCTYLogicM(UINT16 routeId);
void RouteDCTYLogic(UINT16 routeId);
/*
* 功能描述： 调车进路调车同意联锁条件检查
TSCP/src/APP/ciapp/LogicProcess/InterlockLogicCheck.c
+2906 -853
View File
File diff suppressed because it is too large Load Diff
TSCP/src/APP/ciapp/LogicProcess/InterlockLogicCheck.h
+241 -39
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);
/*
* 功能描述： 锁闭点式进路区段联锁条件检查
* 参数说明：
@@ -1021,14 +1045,6 @@ CI_ERROR:
*/
UINT8 CheckRouteZongRenJieFeasibility(const UINT16 routeId);
/*
* 功能描述： 检查调车进路总人解的可行性。只要进路有一个区段可以直接解锁或变绿光带都认为总人解可行。注：调车进路总人解不可调用该函数
* 参数说明： const UINT16 routeId, 进路ID
* 返回值 ： UINT8
CI_SUCCESS:总人解可执行
CI_ERROR:总人解不可执行
*/
UINT8 CheckDiaoCheRouteZRJFeasibility(const UINT16 routeId);
/*
锁闭本联锁保护区段条件检查
@@ -1173,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_点式进路开放信号保护区段联锁条件检查 */
/*
* 功能描述： 点式进路开放信号保护区段联锁条件检查
@@ -1497,6 +1524,7 @@ UINT8 AxisSecAllSwitchPosCheck(UINT16 const axisSecId,UINT16 *pDevId,UINT8 *pDev
* 参数说明： UINT16 const routeId, 进路编号
* 返回值 ： CI_ERROR
* CI_SUCCESS
* qw.liu 修改 进路外方第一区段道岔位置检查不使用接近区段，改为直接查逻辑区段
*/
UINT8 RouteOutfirstPhySecSwiPosCheck(UINT16 const routeId);
/*
@@ -1869,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);
/*
* 功能描述： 进路区段全部联络线设备条件满足检查
@@ -2211,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);
/*
* 功能描述： 部分进路区段全部联络线设备条件满足检查
@@ -2294,7 +2306,7 @@ UINT16 SearchNonMainRoute(UINT8 cRouteSum, UINT16 wRouteIdBuff[]);
UINT8 SwitchRelLogSecLSXSStateCheck(UINT16 switchId, UINT16* pLogSecId, UINT8* pLogState);
/*
* 功能描述： 信号保持开放时进路照查条件满足检查
* 功能描述： 进路照查容忍条件满足检查
* 参数说明： UINT16 const routeId, 进路号
* 返回值 ： CI_ERROR 失败
* CI_SUCCESS 成功
@@ -2506,16 +2518,7 @@ UINT8 CheckRouteZhefanJiesuo(UINT16 const routeId);
*/
UINT8 CheckOverlapPhysecOtherLock(UINT16 const overlapId, UINT16* pDevId, UINT8* pDevState);
/*
* 功能描述：保护区段侧防条件检查
* 参数说明：UINT16 const overlapId, OverlapID
* UINT16* pDevId 设备Id（返回）
* UINT8* pDevState 设备状态（返回）
* 返回值 ：0 检查失败
* 1 检查成功
* Created By LQ 2024.01.05
*/
UINT8 OverlapLateralDfnCheck(UINT16 const overlapId, UINT16* pDevId, UINT8* pDevState);
/*
* 功能描述： 检查保护区段的CBTC区域属性
@@ -2614,13 +2617,15 @@ UINT8 CtTrainHeadSuspCheck(const UINT16 wTrainId, const UINT8 cLogSecSeqDir, con
* 功能描述：车辆段部分进路的逻辑区段序列和列车位置检查
* 输入参数：const UINT8 cLogSecSum 逻辑区段数量
* const UINT16* pLogSecIdBuff 逻辑区段序列
* const UINT16 wTrainId
* const UINT16 wTrainId 列车ID
* const UINT8 cFunctionId 函数ID
* const UINT8 cSendLevel 报警发送级别
* 输出参数：无
* 返回值 ：CI_ERROR 0 失败
* CI_SUCCESS 1 成功
* Created By LQ 2024.09.05
*/
UINT8 LogSecSeqAndTrainPosCheckCLD(const UINT8 cLogSecSum, const UINT16* pLogSecIdBuff, const UINT16 wTrainId);
UINT8 LogSecSeqAndTrainPosCheckCLD(const UINT8 cLogSecSum, const UINT16* pLogSecIdBuff, const UINT16 wTrainId, const UINT8 cFunctionId, const UINT8 cSendLevel);
/*
* 功能描述：车辆段部分进路的逻辑区段序列与进路匹配检查
@@ -2719,5 +2724,202 @@ UINT8 OverlapProSwUsingCheck(const UINT16 wOverlapId, UINT16* pDevId, UINT8* pDe
*/
UINT8 RouteRelAllSwitchPosCheck(UINT16 const routeId);
/*
*函数功能：保护区段照查继电器检查
*参数说明：const UINT16 wOverlapId保护区段ID
* UINT8 chSendLevel, 故障码发送级别
*返回值：CI_ERROR 失败
* CI_SUCCESS 成功
* RELAY_STATE_WAITE 本端照查继电器条件不满足--等待
* by cgh 20250617
*/
UINT8 OverlapZhaoChaRelayCheck(const UINT16 wOverlapId, UINT8 chSendLevel);
/*
* 功能描述： 进路区段全部防护锁闭检查
* 参数说明： UINT16 routeId, 进路号
* 返回值 ： CI_ERROR
* CI_SUCCESS 区段状态均为防护锁闭
* by fan 20250724
*/
UINT8 RouteAllSecProtectLockCheck(UINT16 const routeId);
/*
* 功能描述： 逻辑区段关联计轴无休眠车检查
* 参数说明： UINT16 logSectionId, 逻辑区段ID
* 返回值 ： CI_ERROR 存在休眠车
* CI_SUCCESS 检查通过
* by fan 20250728
*/
UINT8 LogSecRelateNoSleepTrainCheck(UINT16 const logSectionId);
/*
* 功能描述：校验指定进路是否非场段进路或为场段出库/出段进路
* 参数说明：UINT16 wRouteId 进路ID
* 返 回 值：CI_ERROR 其它进路
* CI_SUCCESS 非场段进路或为场段出库/出段进路
* Created By LQ 2025.08.05
*/
UINT8 RouteCldAttrCheck(UINT16 wRouteId);
/*
* 功能描述：保护区段占用解锁条件检查
* 参数说明：UINT16 overlapId 保护区段ID
* UINT8 functionId 函数ID
* 返 回 值：CI_ERROR 0 失败
* CI_SUCCESS 1 成功
* 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);
/*
* 功能描述：单个侧防条件检查
* 参数说明：SideProtecStru SidePretectData 一项侧防条件
* UINT16 wDevId 设备ID
* UINT8 cDevType 设备类型
* UINT8 functionId 函数ID
* UINT8 sendLevel 发送等级
* 返 回 值：CI_ERROR 0 失败
* CI_SUCCESS 1 成功
*/
UINT8 SingleSideProtectCheck(SideProtecStru SidePretectData, UINT16 wDevId, UINT8 cDevType, UINT8 functionId, UINT8 sendLevel);
/*
* 功能描述：侧防道岔位置检查
* 参数说明：SideProtecSwitchData* pSideProtecSwitchBuf 道岔侧防条件
* UINT8 chSideProtecSwitchNum 侧防道岔数量
* 返 回 值：CI_ERROR 0 侧防道岔位置连通
* CI_SUCCESS 1 侧防道岔位置不连通
*/
UINT8 SideProtectSwitchPosCheck(SideProtecSwitchData* pSideProtecSwitchBuf, UINT8 chSideProtecSwitchNum);
/*
* 功能描述：侧防物理区段条件检查
* 参数说明：SideProtecStru SidePretectData 侧防条件
* UINT8 functionId 函数ID
* UINT8 sendLevel 发送等级
* 返 回 值： CI_ERROR 失败
* CI_SUCCESS 成功
*/
UINT8 SideProtectPhySecCheck(SideProtecStru SidePretectData, UINT8 functionId, UINT8 sendLevel);
/*
* 功能描述： 检查进路侧防条件
* 参数说明：UINT16 routeId 进路ID
UINT8 functionId 函数ID
UINT8 sendLevel 发送等级
* 返回值 ： CI_ERROR
* CI_SUCCESS
* 创建 ：
*/
UINT8 RouteSideProtectConditionCheck(UINT16 routeId, UINT8 functionId, UINT8 sendLevel);
/*
* 功能描述： 检查保护区段侧防条件
* 参数说明：UINT16 wOverlapId 保护区段ID
UINT8 functionId 函数ID
UINT8 sendLevel 发送等级
* 返回值 ： CI_ERROR
* CI_SUCCESS
* 创建 ：
*/
UINT8 OlapSideProtectConditionCheck(UINT16 wOverlapId, UINT8 functionId, UINT8 sendLevel);
/*
* 功能描述：侧防区段道岔位置检查
* 参数说明：UINT16 const physicalId, 物理区段ID
* SideProtecStru SidePretectData 侧防数据
* 返 回 值：CI_ERROR 0 失败
* CI_SUCCESS 1 成功
*/
UINT8 SideProtectPhySecSwtPosCheck(const UINT16 physicalId, SideProtecStru SidePretectData);
/*
* 功能描述：检查保护区段道岔及防护道岔位置是否正确
* 参数说明：const UINT16 overlapId overlap ID
* 返 回 值：CI_ERROR 0 道岔位置错误
* CI_SUCCESS 1 道岔位置正确
* Created By LQ 2025.09.28
*/
UINT8 CheckOverlapSwitchPosRight(const UINT16 overlapId);
/*
*函数功能：保护区段之前人工解锁状态检查
*参数说明：const UINT16 wRouteId 进路ID
* UINT16 *pDevId, 设备Id（返回）
* UINT8 *pDevState, 设备状态（返回）
* 返回值 ： CI_ERROR
* CI_SUCCESS
* by cgh 20250929
*/
UINT8 OverlapPreLaborUnLockStateCheck(UINT16 const wRouteId, UINT16* pDevId, UINT8* pDevState);
/*
* 功能描述：侧防关键道岔检查
* 参数说明：UINT16 wSwitchId 关键道岔ID
* UINT16 wDevId 设备ID
* UINT8 cDevType 设备类型
* 返 回 值：CI_ERROR 0 失败
* CI_SUCCESS 1 成功
* Created By LQ 2025.09.29
*/
UINT8 SingleSideKeySwitchCheck(UINT16 wSwitchId, UINT16 wDevId, UINT8 cDevType);
/*
* 功能描述：物理区段锁闭码位侧防条件检查
* 参数说明：UINT16 wPhySecId 物理区段ID
* 返 回 值：CI_ERROR 0 失败
* CI_SUCCESS 1 成功
* Created By LQ 2025.09.29
*/
UINT8 PhySecLockMaskSideProtectCheck(UINT16 wPhySecId);
/*
*函数功能：自动通过进路办理联挂属性检查
*参数说明： const UINT16 wAutoRouteId 进路ID
* const UINT8 chFunctionId 函数ID
* 返回值 ： CI_ERROR
* CI_SUCCESS
* by lyj 20250929
*/
UINT8 AutoRouteCouplinkStateCheck(const UINT16 wAutoRouteId, const UINT8 chFunctionId);
/*
*函数功能：自动折返进路办理联挂属性检查
*参数说明： const UINT16 wAutoRouteId 进路ID
* const UINT8 chFunctionId 函数ID
* 返回值 ： CI_ERROR
* CI_SUCCESS
* by lyj 20250929
*/
UINT8 AutoReturnRouteCouplinkCheck(const UINT16 wAutoRouteId, const UINT8 chFunctionId);
/*
*函数功能：全自动折返进路办理联挂属性检查
*参数说明： const UINT16 wAutoRouteId 进路ID
* const UINT8 chFunctionId 函数ID
* 返回值 ： CI_ERROR
* CI_SUCCESS
* by lyj 20250929
*/
UINT8 AllAutoReturnRCouplinkCheck(const UINT16 wAutoRouteId, const UINT8 chFunctionId);
#endif
TSCP/src/APP/ciapp/LogicProcess/InterlockLogicProcess.c
+1060 -596
View File
File diff suppressed because it is too large Load Diff
TSCP/src/APP/ciapp/LogicProcess/InterlockLogicProcess.h
+25 -7
View File
@@ -325,10 +325,11 @@ UINT8 PhySectionDelayUnlockProcess(const UINT16 routeId, UINT16* phySectionId);
/* C25_解锁进路overlap逻辑处理 */
/*
* 功能描述： 解锁进路overlap逻辑处理
* 参数说明： const UINT16 routeId
* 返回值 ： CI_ERROR
* CI_SUCCESS
* CI_UNLOCK_OVERLAP_REQURE 向ZC申请解锁保护区段
* 参数说明： const UINT16 routeId 进路号
* 返回值 ： CI_ERROR 0x00 失败
* CI_SUCCESS 0x01 成功
* CI_UNLOCK_OVERLAP_REQURE 0x02 向ZC/车申请解锁保护区段
* CI_OVERLAP_OCC_UNLOCK 0x06 保护区段执行占用特殊解锁
* 故障编码： EFUNC_UNLOCK_OVER_LAP
*/
UINT8 UnlockRouteOverlapLogicProcess(const UINT16 routeId, UINT16* overlapId, UINT16* pTrainId);
@@ -687,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
@@ -823,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
+395 -42
View File
@@ -28,24 +28,48 @@ 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);
/*进路状态空闲或初选或自动解锁异常（ARB且故障锁闭）*/
if ((ROUTE_STATE_IDLE == devState) || (ROUTE_STATE_FIRST_XUANPAI == devState) || (ROUTE_STATE_AUTO_UNLOCKERR == devState))
if ((ROUTE_COUPLINK_FLAG_YES == chRouteCouplinkFlag) && (ROUTE_LEVEL_CBTC == chRouteLevel))
{
/* 返回成功 */
reResult = CI_SUCCESS;
/* 进路状态条件：进路状态空闲、进路初选、自动解锁正常、自动解锁异常（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
{
/* 记录故障码 */
SetErrorData(functionId, CI_DEVICE_TYPE_ROUTE, routeId, ETYPE_ROUTE_STATE, devState, sendLevel);
/* 失败返回 */
reResult = CI_ERROR;
/*进路状态空闲或初选或自动解锁异常（ARB且故障锁闭）*/
if ((ROUTE_STATE_IDLE == devState) || (ROUTE_STATE_FIRST_XUANPAI == 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;
}
}
/*信号联锁条件检查*/
/*if ((CI_SUCCESS == reResult) && (CI_ERROR == SetLTrainRouteSignalCheck(routeId,functionId,sendLevel)))*/
if ((CI_SUCCESS == reResult) && (CI_ERROR == SetBlocRouteSignalCheck(routeId, functionId, sendLevel)))
@@ -181,6 +205,7 @@ UINT8 SetLeadRouteP(const UINT16 routeId)
UINT16 devId = 0u; /*设备ID*/
UINT8 devState = 0u; /*设备状态*/
UINT8 reResult = CI_SUCCESS; /*返回值*/
UINT8 cFuncSwitch = FUNC_SWITCH_ON; /*引导进路是否检查防淹门开关*/
/* 联锁条件检查 */
devId = routeId;
@@ -217,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;
@@ -226,8 +251,17 @@ UINT8 SetLeadRouteP(const UINT16 routeId)
if (CI_SUCCESS == reResult)
{
/*防淹门联锁条件检查*/
reResult = BlocRouteFloodGateCheck(routeId,functionId,sendLevel);
cFuncSwitch = GetCiFunctionSwitchConfig(FUNC_LEADROUTE_FLOODGATE_CHECK);
if (FUNC_SWITCH_OFF == cFuncSwitch)
{
/*引导进路办理不检查防淹门状态*/
}
else
{
/*引导进路办理检查防淹门状态*/
reResult = BlocRouteFloodGateCheck(routeId, functionId, sendLevel);
}
}
return reResult;
@@ -660,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)
{
/* 失败返回 */
@@ -1995,8 +2029,6 @@ UINT8 CancelDTrainRouteP(const UINT16 routeId)
UINT8 devState = 0u; /*设备状态*/
UINT16 cancleZhaoChaRelayId = 0u; /*取消照查继电器ID*/
UINT8 relayState = 0u; /*继电器采集状态*/
UINT8 chRouteLevel = 0U;
/* 联锁条件检查 */
/*进路内所有区段正常锁闭*/
@@ -2034,19 +2066,8 @@ UINT8 CancelDTrainRouteP(const UINT16 routeId)
}
if (CI_SUCCESS == reResult)
{/*检查取消照查继电器状态是否吸起*/
chRouteLevel = GetRouteLevel(routeId);
if (ROUTE_LEVEL_BLOC == chRouteLevel)
{
cancleZhaoChaRelayId = GetRouteCancleZhaoChaRelayId(routeId); /*后备模式取消照查继电器ID*/
}
else if (ROUTE_LEVEL_CBTC == chRouteLevel)
{
cancleZhaoChaRelayId = GetRouteCbtcCancelZhaochaRelay(routeId);/*CBTC模式取消照查继电器ID*/
}
else
{
; /*非法监督模式，继电器ID为0，在下面不会处理*/
}
cancleZhaoChaRelayId = GetRouteCancleZhaoChaRelayId(routeId); /*取消照查继电器ID*/
if((0u != cancleZhaoChaRelayId) && (0xFFFFu != cancleZhaoChaRelayId))
{
/*取消继电器有效：取消继电器采集状态为：吸起*/
@@ -2186,7 +2207,8 @@ UINT8 SetLTrainRouteSectionCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel
UINT16 devId = 0u; /*设备ID*/
UINT8 devState = 0u; /*设备状态*/
UINT8 chRouteCouplinkFlag = 0U;
UINT8 chRouteLevel = 0U;
/* 联锁逻辑检查 */
/* 进路内所有区段未被封锁 */
@@ -2211,7 +2233,17 @@ UINT8 SetLTrainRouteSectionCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel
{
devId = 0u;
devState = 0u;
checkResult = RouteAllSecOccuClearCheck(routeId,&devId, &devState);
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)
{
/* 通过检查 */
@@ -2219,8 +2251,17 @@ UINT8 SetLTrainRouteSectionCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel
}
else
{
/* 记录故障码 */
SetErrorData(functionId,CI_DEVICE_TYPE_PHYSEC,devId,ETYPE_PS_MERGY_OCU_STATE,devState,sendLevel);
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;
}
@@ -2373,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)
{
/* 通过检查 */
@@ -2385,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;
}
@@ -2396,6 +2437,7 @@ UINT8 SetLTrainRouteSwitchCheck(UINT16 routeId, UINT8 functionId, UINT8 sendLeve
/* 失败返回 */
reResult = CI_ERROR;
}
#endif
if (CI_SUCCESS == reResult)
{
@@ -2528,9 +2570,288 @@ UINT8 SetLTrainRouteSwitchCheck(UINT16 routeId, UINT8 functionId, UINT8 sendLeve
}
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;
}
/*
* 功能描述：办理引导进路道岔联锁条件检查
* 参数说明：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;
@@ -2895,7 +3216,8 @@ UINT8 LockLTrainRouteSectionCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLeve
UINT16 devId = 0u; /*设备ID*/
UINT8 devState = 0u; /*设备状态*/
UINT8 chRouteCouplinkFlag = 0U;
UINT8 chRouteLevel = 0U;
/* 联锁逻辑检查 */
/* 进路内所有区段未被封锁 */
@@ -2920,7 +3242,17 @@ UINT8 LockLTrainRouteSectionCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLeve
{
devId = 0u;
devState = 0u;
checkResult = RouteAllSecOccuClearCheck(routeId,&devId, &devState);
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)
{
/* 通过检查 */
@@ -2928,8 +3260,17 @@ UINT8 LockLTrainRouteSectionCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLeve
}
else
{
/* 记录故障码 */
SetErrorData(functionId,CI_DEVICE_TYPE_PHYSEC,devId,ETYPE_PS_MERGY_OCU_STATE,devState,sendLevel);
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;
}
@@ -4115,6 +4456,7 @@ UINT8 SetLeadRouteCheck(const UINT16 routeId)
UINT16 devId = 0u; /*设备ID*/
UINT8 devState = 0u; /*设备状态*/
UINT8 reResult = CI_ERROR; /*返回值*/
UINT8 cFuncSwitch = FUNC_SWITCH_ON; /*引导进路是否检查防淹门开关*/
/* 联锁条件检查 */
devId = routeId;
@@ -4195,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)
{
/* 失败返回 */
@@ -4214,7 +4556,18 @@ UINT8 SetLeadRouteCheck(const UINT16 routeId)
/*防淹门联锁条件检查*/
if (CI_SUCCESS == reResult)
{
reResult = BlocRouteFloodGateCheck(routeId, functionId, sendLevel);
cFuncSwitch = GetCiFunctionSwitchConfig(FUNC_LEADROUTE_FLOODGATE_CHECK);
if (FUNC_SWITCH_OFF == cFuncSwitch)
{
/*引导进路锁闭不检查防淹门状态*/
}
else
{
/*引导进路锁闭检查防淹门状态*/
reResult = BlocRouteFloodGateCheck(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
+21 -4
View File
@@ -49,6 +49,8 @@
#define MASK_TYPE_SWITCH_BYPASS ((UINT8)0x0D) /*定义道岔旁路码位*/
#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 */
@@ -62,11 +64,12 @@
#define MASK_TYPE_SIGNAL_REDCLOSE ((UINT8)0x15) /*定义信号机红灭码位*/
#define MASK_TYPE_SIGNAL_GREENCLOSE ((UINT8)0x16) /*定义信号机绿灭码位*/
#define MASK_TYPE_SIGNAL_YELLOWCLOSE ((UINT8)0x17) /*定义信号机黄灭码位*/
#define MASK_TYPE_SIGNAL_REDBREAK ((UINT8)0x18) /*定义信号机红断码位*/
#define MASK_TYPE_SIGNAL_REDBREAK ((UINT8)0x18) /*定义信号机红断码位--暂无使用*/
#define MASK_TYPE_SIGNAL_GREENBREAK ((UINT8)0x19) /*定义信号机绿断码位*/
#define MASK_TYPE_SIGNAL_YELLOWBREAK ((UINT8)0x1a) /*定义信号机黄断码位*/
#define MASK_TYPE_SIGNAL_WHITEBREAK ((UINT8)0x1b) /*定义信号机白断码位*/
#define MASK_TYPE_SIGNAL_BREAK ((UINT8)0x1c) /*定义信号机断丝码位*/
#define MASK_TYPE_SIGNAL_BLUEBREAK ((UINT8)0x25) /*定义信号机蓝断码位*/
#define MASK_TYPE_SIGNAL_BREAK ((UINT8)0x1c) /*定义信号机断丝码位 （对全电子联锁=红灯断丝）*/
#define MASK_TYPE_SIGNAL_FENGSUO ((UINT8)0x1d) /*定义信号机封锁码位*/
#define MASK_TYPE_SIGNAL_OPENSTATE ((UINT8)0x1e) /*定义信号机开放状态码位*/
@@ -90,6 +93,9 @@
#define MASK_TYPE_SIGNAL_DET_ERR ((UINT8)0x5c) /*信号机扣车按钮故障状态码位*/
#define MASK_TYPE_SIGNAL_AUTO_DERAIN ((UINT8)0x5e) /*信号机自动扣车码位*/
#define MASK_TYPE_SIGNAL_DET_CUT_VALID ((UINT8)0xA6) /*信号机扣车旁路按钮有效状态码位*/
#define MASK_TYPE_SIGNAL_DET_CUT_ERR ((UINT8)0xA7) /*信号机扣车旁路按钮故障状态码位*/
#define MASK_ZC_CI_SIG_ENGINEERV_NEAR ((UINT8)0x97) /*定义信号机工程车接近码位*/
#define MASK_CI_ZC_SIG_ENGINCROSS_STE ((UINT8)0x98) /*定义信号机工程车关灯码位*/
@@ -112,7 +118,12 @@
#define MASK_TYPE_PHYSECTION_HEAD_XTD ((UINT8)0x31) /*定义物理区段运行方向下行状态码位*/
#define MASK_TYPE_PHYSECTION_HEAD_STD ((UINT8)0x32) /*定义物理区段运行方向上行状态码位*/
#define MASK_TYPE_LIECHE_STOPSTATE ((UINT8)0x3a) /*定义列车停稳信息状态码位*/
#define MASK_TYPE_PHYSEC_CENTERDETAIN_UP ((UINT8)0x3d) /*定义物理区段CI-ATS中心上行扣车状态状态码位 (兼容28.0.0.14使用)*/
#define MASK_TYPE_PHYSEC_CENTERDETAIN_DOWN ((UINT8)0x3e) /*定义物理区段CI-ATS中心下行扣车状态状态码位 (兼容28.0.0.14使用)*/
#define MASK_TYPE_PHYSEC_STATIONDETAIN_UP ((UINT8)0x3f) /*定义物理区段CI-ATS车站上行扣车状态状态码位 (兼容28.0.0.14使用)*/
#define MASK_TYPE_PHYSEC_STATIONDETAIN_DOWN ((UINT8)0x40) /*定义物理区段CI-ATS车站下行扣车状态状态码位 (兼容28.0.0.14使用)*/
#define MASK_TYPE_AXISSECTION_DETAIN_UP ((UINT8)0x41) /*定义区段CI-ZC上行扣车状态状态码位 (兼容28.0.0.14使用)*/
#define MASK_TYPE_AXISSECTION_DETAIN_DOWN ((UINT8)0x42) /*定义区段CI-ZC下行扣车状态状态码位 (兼容28.0.0.14使用)*/
/*逻辑区段相关码位*/
#define MASK_TYPE_LOGICSECTION_UTOCCUPY ((UINT8)0x33) /*定义逻辑区段非通信车占用码位*/
@@ -130,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) /*定义逻辑区段紧急临时限速码位*/
/*保护区段相关码位*/
@@ -156,6 +167,9 @@
#define MASK_TYPE_ROUTE_DC_QINGQIU ((UINT8)0x51) /*定义进路调车请求状态码位(CI-ATS)*/
#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)*/
/*站台相关码位*/
@@ -169,6 +183,8 @@
#define MASK_TYPE_ESP_FLASH_STATE ((UINT8)0x9b) /*定义ESS闪灯灯状态码位*/
#define MASK_TYPE_CANCEL_ESP_FAULT ((UINT8)0x9c) /*定义取消紧急关闭按钮故障码位*/
#define MASK_TYPE_ESP_FAULT ((UINT8)0x9d) /*定义紧急关闭按钮故障码位*/
#define MASK_TYPE_CUT_ESP_FAULT ((UINT8)0xA3) /*定义紧急关闭旁路按钮故障码位*/
#define MASK_TYPE_ESP_PRESS_STATE ((UINT8)0xA4) /*定义紧急关闭按钮按下状态码位*/
/*站台安全门相关码位*/
#define MASK_TYPE_PSD_STATE ((UINT8)0x60) /*定义站台安全门状态码位-ZC,LEU用*/
@@ -186,6 +202,7 @@
#define MASK_TYPE_PSD_PDB_FLASH_STATE ((UINT8)0xA0) /*定义清客确认箱PDB按钮指示灯闪灯状态码位*/
#define MASK_TYPE_PSD_VIDEO_QK_LU ((UINT8)0xA1) /*定义清客按钮箱视频清客表示灯（绿)状态码位*/
#define MASK_TYPE_PSD_VIDEO_QK_HONG ((UINT8)0xA2) /*定义清客按钮箱视频清客表示灯（红)状态码位*/
#define MASK_TYPE_PSD_EXCEPT_OPEN ((UINT8)0xA5) /*定义站台安全门异常打开码位*/
/*车库门相关码位*/
#define MASK_TYPE_GARAGEDOOR_OPEN_STATE ((UINT8)0x62) /*定义车库门开门状态码位（CI->ATS）*/
TSCP/src/APP/ciapp/NonAutoReturn/NonAutoReturnDataManage.c
+14 -3
View File
@@ -15,7 +15,8 @@
NonAutoReturnDataStruct NonReturnDataStru[NON_AUTO_RETURN_SUM_MAX]; /*无人自动折返动态结构体*/
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
+119
View File
@@ -873,3 +873,122 @@ UINT8 GetOverlapProSwitchPos(const UINT16 wOverlapId, const UINT16 wProSwitchId)
return cRetVal;
}
/*
* 功能描述： 获取指定ID保护区段本端照查继电器ID
* 参数说明： const UINT16 overlapId, 保护区段ID
* 返回值 ： 本端照查继电器ID
* by cgh 20250617
*/
UINT16 GetOverlapThisZhaoChaRelayId(const UINT16 overlapId)
{
UINT16 bufIndex = 0U; /*数组下标*/
UINT16 reVal = CI_ERROR;
bufIndex = GetOverlapConfigBufIndex(overlapId); /*获取数组下标*/
if (bufIndex < OVERLAP_SUM_MAX)
{
reVal = OverlapConfigDataStru[bufIndex].wOverlapThisZhaoChaRelayId;
}
else
{
;
}
return reVal;
}
/*
* 功能描述： 获取指定ID保护区段对端照查继电器ID
* 参数说明： const UINT16 overlapId, 保护区段ID
* 返回值 ： 对端照查继电器ID
* by cgh 20250617
*/
UINT16 GetOverlapThatZhaoChaRelayId(const UINT16 overlapId)
{
UINT16 bufIndex = 0U; /*数组下标*/
UINT16 reVal = CI_ERROR;
bufIndex = GetOverlapConfigBufIndex(overlapId); /*获取数组下标*/
if (bufIndex < OVERLAP_SUM_MAX)
{
reVal = OverlapConfigDataStru[bufIndex].wOverlapThatZhaoChaRelayId;
}
else
{
;
}
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
+34 -2
View File
@@ -19,7 +19,7 @@
#include "CommonTypes.h"
#include "../System/CiSystemDefine.h"
#include "../System/SystemParameterManage.h"
#include "RouteConfigDataManage.h"
#ifdef __cplusplus
@@ -72,7 +72,9 @@ typedef struct S_OverlapConfigDataStruct
UINT16 OverlapRouteSum; /*保护区段进路总数*/
UINT16 OverlapRouteIdBuf[OVERLAP_ROUTE_SUM_MAX]; /*保护区段进路数组*/
UINT16 AxisSecFarId; /*保护区段最远端计轴区段ID*/
UINT16 wOverlapThisZhaoChaRelayId; /*保护区段本端照查继电器ID*/
UINT16 wOverlapThatZhaoChaRelayId; /*保护区段对端照查继电器ID*/
SideProtecGroupStru SideProtecGroupData; /*保护区段侧防条件*/
} OverlapConfigDataStruct;
extern OverlapConfigDataStruct OverlapConfigDataStru[OVERLAP_SUM_MAX]; /*定义OVERLAP数据配置结构体,cgh-合并CID-2539-1：此处声明不进行初始化，统一放到InitAllStaticDataStr函数中进行初始化，为解决生成内核过大得问题*/
@@ -373,6 +375,36 @@ UINT8 CheckOtherCiOlpHaveLocalCiPSw(const UINT16 wOverlapId);
*/
UINT8 GetOverlapProSwitchPos(const UINT16 wOverlapId, const UINT16 wProSwitchId);
/*
* 功能描述： 获取指定ID保护区段本端照查继电器ID
* 参数说明： const UINT16 overlapId, 保护区段ID
* 返回值 ： 本端照查继电器ID
* by cgh 20250617
*/
UINT16 GetOverlapThisZhaoChaRelayId(const UINT16 overlapId);
/*
* 功能描述： 获取指定ID保护区段对端照查继电器ID
* 参数说明： const UINT16 overlapId, 保护区段ID
* 返回值 ： 对端照查继电器ID
* 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
+194 -18
View File
@@ -14,8 +14,8 @@
OverlapDataStruct OverlapDataStru[OVERLAP_SUM_MAX]; /*定义OVERLAP数据结构体*/
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
@@ -51,7 +60,7 @@ UINT16 GetOverlapBelongRouteId(const UINT16 overlapId)
/*
* 功能描述： 设置指定ID保护区段组解锁起始周期号
* 功能描述： 设置指定ID保护区段所属进路
* 参数说明： const UINT16 overlapId, 保护区段ID
* const UINT16 belongRouteId, 所属进路号
* 返回值 ： 无
@@ -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,17 +118,27 @@ void SetOverlapRelateProtSwLockSta(const UINT16 overlapId, const UINT8 lockComma
for (ii= 0u; ii < overlapProtectSwitchSum; ii++)
{
protectSwitchId = overlapProtectSwitchStru[ii].ProtectSwitchId;
SetSwitchLockStatus(SWITCH_PLOCKTYPE_OVERLAP,overlapId,protectSwitchId, lockCommand); /*设置道岔防护锁闭状态*/
/*RC 13.0.0 修：不检查防护道岔中双动道岔另一端*/
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
if (SWITCH_TYPE_DOUBLE == GetSwitchType(protectSwitchId))
{ /*双动道岔*/
SetSwitchLockStatus(SWITCH_PLOCKTYPE_OVERLAP,overlapId,GetDSwitchOtherId(protectSwitchId), lockCommand); /*设置道岔防护锁 闭状态*/
if (SWITCH_TYPE_DOUBLE == GetSwitchType(protectSwitchId))
{ /*双动道岔*/
SetSwitchLockStatus(SWITCH_PLOCKTYPE_OVERLAP, overlapId, GetDSwitchOtherId(protectSwitchId), lockCommand); /*设置道岔防护锁 闭状态*/
}
else
{
}
#endif
}
else
{
/*防护道岔不在防护位置或防护道岔存在反向驱动时，不设置防护锁闭*/
}
#endif
}
}
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
+117
View File
@@ -1042,3 +1042,120 @@ UINT8 CheckPsdBelSendRange(const UINT16 wCheckPsdId)
return retVal;
}
/*
* 功能描述： 获取指定ID屏蔽门控制类型
* 参数说明： const UINT16 doorId, 屏蔽门ID
* 返回值 ： UINT8 控制类型（0x55 OC-P控制 0xAA RCI控制）
*/
UINT8 GetPsdControlType(const UINT16 doorId)
{
UINT16 bufIndex = 0u; /*数组下标*/
UINT8 retVal = PSD_CONTROL_TYPE_RCI;
bufIndex = GetPsdConfigBufIndex(doorId); /*获取屏蔽门数组下标*/
if (bufIndex < PSD_SUM_MAX)
{
retVal = PsdConfigDataStru[bufIndex].chPsdControlType;
}
else
{
retVal = PSD_CONTROL_TYPE_RCI;
}
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
+40
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; /*停止探测继电器*/
@@ -64,6 +66,12 @@ typedef struct S_PsdConfigDataStruct
UINT16 wPcbIndicatorRelayId; /*再关门按钮指示灯继电器*/
UINT16 wVideoQkLight1RelayId; /*清客按钮箱视频清客指示灯1（绿）继电器*/
UINT16 wVideoQkLight2RelayId; /*清客按钮箱视频清客指示灯2（红）继电器*/
UINT16 wPsdFstProLinkId; /*屏蔽门防护link1ID*/
UINT16 wPsdSndProLinkId; /*屏蔽门防护link2ID*/
UINT16 wPsdTrdProLinkId; /*屏蔽门防护link3ID*/
UINT8 chPsdControlType; /*屏蔽门控制类型*/
UINT16 IncloudeEsbIdBuf[PSD_INCLUDE_ESB_NUM]; /*屏蔽门包含ESB ID*/
UINT8 IncloudeEsbNum; /*包含ESB数量*/
} PsdConfigDataStruct;
@@ -411,6 +419,38 @@ UINT16 GetPsdVideoQkLight2RelayId(const UINT16 wDoorId);
*/
UINT8 CheckPsdBelSendRange(const UINT16 wCheckPsdId);
/*
* 功能描述： 获取指定ID屏蔽门控制类型
* 参数说明： const UINT16 doorId, 屏蔽门ID
* 返回值 ： 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
+615 -8
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
{
@@ -1443,14 +1458,14 @@ UINT8 SetPsdCmdCyclePsc(const UINT16 doorId, const UINT32 doorCycle)
}
/*
* 功能描述： 设置指定ID屏蔽门确认PSC互锁解除标志
* 功能描述： 设置指定ID屏蔽门旁路标志
* 参数说明： const UINT16 doorId, 屏蔽门ID
* const UINT8 setFlag, 屏蔽门旁路设置状态
* 返回值 ：无
*
*/
void SetPsdPscConfirmFlag(const UINT16 doorId,const UINT8 setFlag)
void SetPsdConfirmFlag(const UINT16 doorId,const UINT8 setFlag)
{
/*变量初始化*/
UINT16 bufIndex = 0u;
@@ -1467,13 +1482,13 @@ void SetPsdPscConfirmFlag(const UINT16 doorId,const UINT8 setFlag)
}
/*
* 功能描述： 获取指定ID屏蔽门确认PSC旁路标志
* 功能描述： 获取指定ID屏蔽门旁路标志
* 参数说明： const UINT16 doorId, 屏蔽门ID
*
* 返回值 ： 0: 获取失败
* >0: 获取成功
*/
UINT8 GetPsdPscPlFlag(const UINT16 doorId)
UINT8 GetPsdPlFlag(const UINT16 doorId)
{
/*变量初始化*/
UINT16 bufIndex = 0u; /*数组下标*/
@@ -1532,7 +1547,7 @@ void SetNearCiPscPlFlag(const UINT16 psdId,const UINT16 pscId,const UINT8 setFla
if(psdCiId == localCiId)
{
/*设置PSC对应PSD旁路*/
SetPsdPscConfirmFlag(psdId, setFlag);
SetPsdConfirmFlag(psdId, setFlag);
}
}
else
@@ -1544,12 +1559,12 @@ void SetNearCiPscPlFlag(const UINT16 psdId,const UINT16 pscId,const UINT8 setFla
else
{
/*获取PSD旁路标志*/
pscPlFlag = GetPsdPscPlFlag(psdId);
pscPlFlag = GetPsdPlFlag(psdId);
if(psdCiId == localCiId)
{
if(CI_PSC_PL_CONFIRM_YES == pscPlFlag)
{
SetPsdPscConfirmFlag(psdId, CI_PSC_PL_CONFIRM_NO);
SetPsdConfirmFlag(psdId, CI_PSC_PL_CONFIRM_NO);
}
else
{
@@ -2510,3 +2525,595 @@ UINT16 GePsdVideoQkRelateVobcId(const UINT16 wPsdId)
}
return retVal;
}
/*
* 功能描述：设置指定ID屏蔽门异常打开状态
* 参数说明：const UINT16 wPsdId 屏蔽门ID
* const UINT8 cExceptOpenState 屏蔽门异常打开状态
* 返 回 值：无
* Created By LQ 2025.05.22
*/
void SetPsdExceptOpenState(const UINT16 wPsdId, const UINT8 cExceptOpenState)
{
UINT16 bufIndex = 0U;
bufIndex = GetPsdConfigBufIndex(wPsdId); /*获取屏蔽门数组下标*/
if ((PSD_SUM_MAX > bufIndex) && ((PSD_EXCEPT_OPEN_YES == cExceptOpenState) || (PSD_EXCEPT_OPEN_NO == cExceptOpenState)))
{
PsdDataStru[bufIndex].cPsdExceptOpenState = cExceptOpenState; /*设置屏蔽门异常打开状态*/
}
else
{
; /*不处理*/
}
}
/*
* 功能描述：获取指定ID屏蔽门异常打开状态
* 参数说明：const UINT16 wPsdId 屏蔽门ID
* 返 回 值：0x55 异常打开
* 0xAA 未异常打开
* Created By LQ 2025.05.22
*/
UINT8 GePsdExceptOpenState(const UINT16 wPsdId)
{
UINT16 bufIndex = 0U;
UINT8 cRetVal = PSD_EXCEPT_OPEN_YES;
bufIndex = GetPsdConfigBufIndex(wPsdId); /*获取屏蔽门数组下标*/
if (PSD_SUM_MAX > bufIndex)
{
cRetVal = PsdDataStru[bufIndex].cPsdExceptOpenState;
}
else
{
/*返回异常打开*/
}
return cRetVal;
}
/*
* 功能描述： 设置指定ID屏蔽门故障隔离信息
* 参数说明： const UINT16 doorId, 屏蔽门ID
* const UINT32 faultQStateOne, 故障隔离信息高四字节
* * const UINT32 faultQStateTwo, 故障隔离信息低四字节
* 返回值 ： 无
*/
void SetPsdFaultQState(const UINT16 doorId, const UINT32 faultQStateOne, const UINT32 faultQStateTwo)
{
UINT16 bufIndex = 0u; /*数组下标*/
bufIndex = GetPsdConfigBufIndex(doorId); /*获取屏蔽门数组下标*/
if (PSD_SUM_MAX > bufIndex)
{
PsdDataStru[bufIndex].psdFaultQStataOne = faultQStateOne;
PsdDataStru[bufIndex].psdFaultQStataTwo = faultQStateTwo;
}
else
{
/*不处理*/
}
}
/*
* 功能描述： 获取指定ID屏蔽门故障隔离信息
* 参数说明： const UINT16 doorId, 屏蔽门ID
* UINT8 psdFlag,前四个字节还是后四个字节(0u为高四个字节，1u为低四个字节)
* 返回值 ： 0: 获取数据失败
* >0: 屏蔽门故障隔离信息
*/
UINT32 GetPsdFaultQState(const UINT16 doorId, UINT8 psdFlag)
{
UINT16 bufIndex = 0u; /*数组下标*/
UINT32 retVal = UINT32_MAX;
bufIndex = GetPsdConfigBufIndex(doorId); /*获取屏蔽门数组下标*/
if ((PSD_SUM_MAX > bufIndex) && (HIGH_FOUR_CHAR == psdFlag))
{
retVal = PsdDataStru[bufIndex].psdFaultQStataOne;/*高四字节*/
}
else if ((PSD_SUM_MAX > bufIndex) && (LOW_FOUR_CHAR == psdFlag))
{
retVal = PsdDataStru[bufIndex].psdFaultQStataTwo;/*低四字节*/
}
else
{
retVal = UINT32_MAX;
}
return retVal;
}
/*
* 功能描述： 设置指定ID屏蔽门被隔离信息
* 参数说明： const UINT16 doorId, 屏蔽门ID
* const UINT32 doorsIStateOne, 被隔离信息高四字节
* * const UINT32 doorsIStateTwo, 被隔离信息低四字节
* 返回值 ： 无
*/
void SetPsdDoorIState(const UINT16 doorId, const UINT32 doorsIStateOne, const UINT32 doorsIStateTwo)
{
UINT16 bufIndex = 0u; /*数组下标*/
bufIndex = GetPsdConfigBufIndex(doorId); /*获取屏蔽门数组下标*/
if (PSD_SUM_MAX > bufIndex)
{
PsdDataStru[bufIndex].psdDoorIStateOne = doorsIStateOne;
PsdDataStru[bufIndex].psdDoorIStateTwo = doorsIStateTwo;
}
else
{
/*不处理*/
}
}
/*
* 功能描述： 获取指定ID屏蔽门被隔离信息
* 参数说明： const UINT16 doorId, 屏蔽门ID
* UINT8 psdFlag,前四个字节还是后四个字节(0u为高四个字节，1u为低四个字节)
* 返回值 ： 0: 获取数据失败
* >0: 屏蔽门被隔离信息
*/
UINT32 GetPsdDoorIState(const UINT16 doorId, UINT8 psdFlag)
{
UINT16 bufIndex = 0u; /*数组下标*/
UINT32 retVal = UINT32_MAX;
bufIndex = GetPsdConfigBufIndex(doorId); /*获取屏蔽门数组下标*/
if ((PSD_SUM_MAX > bufIndex) && (HIGH_FOUR_CHAR == psdFlag))
{
retVal = PsdDataStru[bufIndex].psdDoorIStateOne;/*高四字节*/
}
else if ((PSD_SUM_MAX > bufIndex) && (LOW_FOUR_CHAR == psdFlag))
{
retVal = PsdDataStru[bufIndex].psdDoorIStateTwo;/*低四字节*/
}
else
{
retVal = UINT32_MAX;
}
return retVal;
}
/*
* 功能描述： 设置指定ID屏蔽门，单扇门开关状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
* const UINT32 doorStateOne, 单扇门开关状态高四字节
* * const UINT32 doorStateTwo, 单扇门开关状态低四字节
* 返回值 ： 无
*/
void SetPsdDoorState(const UINT16 doorId, const UINT32 doorStateOne, const UINT32 doorStateTwo)
{
UINT16 bufIndex = 0u; /*数组下标*/
bufIndex = GetPsdConfigBufIndex(doorId); /*获取屏蔽门数组下标*/
if (PSD_SUM_MAX > bufIndex)
{
PsdDataStru[bufIndex].psdDoorsStateOne = doorStateOne;
PsdDataStru[bufIndex].psdDoorsStateTwo = doorStateTwo;
}
else
{
/*不处理*/
}
}
/*
* 功能描述： 获取指定ID屏蔽门,单扇门开关状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
* UINT8 psdFlag,前四个字节还是后四个字节(0u为高四个字节，1u为低四个字节)
* 返回值 ： 0: 获取数据失败
* >0: 屏蔽门单扇门开关状态
*/
UINT32 GetPsdDoorState(const UINT16 doorId, UINT8 psdFlag)
{
UINT16 bufIndex = 0u; /*数组下标*/
UINT32 retVal = UINT32_MAX;
bufIndex = GetPsdConfigBufIndex(doorId); /*获取屏蔽门数组下标*/
if ((PSD_SUM_MAX > bufIndex) && (HIGH_FOUR_CHAR == psdFlag))
{
retVal = PsdDataStru[bufIndex].psdDoorsStateOne;/*高四字节*/
}
else if ((PSD_SUM_MAX > bufIndex) && (LOW_FOUR_CHAR == psdFlag))
{
retVal = PsdDataStru[bufIndex].psdDoorsStateTwo;/*低四字节*/
}
else
{
retVal = UINT32_MAX;
}
return retVal;
}
/*
* 功能描述： 设置指定ID开门故障状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
* const UINT8 openErrState,开门故障状态
* 返回值 ： 无
*/
void SetOpenErrState(const UINT16 doorId, const UINT8 openErrState)
{
UINT16 bufIndex = 0u; /*数组下标*/
bufIndex = GetPsdConfigBufIndex(doorId); /*获取屏蔽门数组下标*/
if (PSD_SUM_MAX > bufIndex)
{
if ((PSD_OPEN_CLOSE_NORMAL == openErrState) || (PSD_OPEN_CLOSE_ERROR == openErrState))
{
PsdDataStru[bufIndex].psdOpenErrState = openErrState;
}
else
{/*不处理*/
}
}
}
/*
* 功能描述： 设置指定ID关门故障状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
* const UINT8 closeErrState,关门故障状态
* 返回值 ： 无
*/
void SetCloseErrState(const UINT16 doorId, const UINT8 closeErrState)
{
UINT16 bufIndex = 0u; /*数组下标*/
bufIndex = GetPsdConfigBufIndex(doorId); /*获取屏蔽门数组下标*/
if (PSD_SUM_MAX > bufIndex)
{
if ((PSD_OPEN_CLOSE_NORMAL == closeErrState) || (PSD_OPEN_CLOSE_ERROR == closeErrState))
{
PsdDataStru[bufIndex].psdCloseErrState = closeErrState;
}
else
{/*不处理*/
}
}
}
/*
* 功能描述： 获取指定ID开门故障状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
* 返回值 ： UINT8 开门故障状态
*/
UINT8 GetOpenErrState(const UINT16 doorId)
{
UINT16 bufIndex = 0u; /*数组下标*/
UINT8 retVal = PSD_OPEN_CLOSE_ERROR;
bufIndex = GetPsdConfigBufIndex(doorId); /*获取屏蔽门数组下标*/
if (PSD_SUM_MAX > bufIndex)
{
retVal = PsdDataStru[bufIndex].psdOpenErrState;
}
else
{/*不处理*/
}
return retVal;
}
/*
* 功能描述： 获取指定ID关门故障状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
* 返回值 ： UINT8 关门故障状态
*/
UINT8 GetCloseErrState(const UINT16 doorId)
{
UINT16 bufIndex = 0u; /*数组下标*/
UINT8 retVal = PSD_OPEN_CLOSE_ERROR;
bufIndex = GetPsdConfigBufIndex(doorId); /*获取屏蔽门数组下标*/
if (PSD_SUM_MAX > bufIndex)
{
retVal = PsdDataStru[bufIndex].psdCloseErrState;
}
else
{/*不处理*/
}
return retVal;
}
/*
* 功能描述：获取指定ID屏蔽门门关继电器落下起始周期号
* 参数说明：const UINT16 doorId 屏蔽门ID
* 返 回 值：门开继电器落下起始周期号
* Created By LQ 2025.06.26
*/
UINT32 GetPsdRelayDownCycNum(const UINT16 doorId)
{
UINT16 bufIndex = 0u; /*数组下标*/
UINT32 retVal = CI_ERROR;
bufIndex = GetPsdConfigBufIndex(doorId); /*获取屏蔽门数组下标*/
if (bufIndex < PSD_SUM_MAX)
{
retVal = PsdDataStru[bufIndex].dwPsdRelayDownCycNum;
}
else
{
retVal = CI_ERROR;
}
return retVal;
}
/*
* 功能描述：设置指定ID屏蔽门门关继电器落下起始周期号
* 参数说明：const UINT16 doorId 屏蔽门ID
* const UINT32 startCycNum 起始周期号
* 返 回 值：无
* Created By LQ 2025.06.26
*/
void SetPsdRelayDownCycNum(const UINT16 doorId, const UINT32 startCycNum)
{
UINT16 bufIndex = 0u; /*数组下标*/
bufIndex = GetPsdConfigBufIndex(doorId); /*获取屏蔽门数组下标*/
if (bufIndex < PSD_SUM_MAX)
{
PsdDataStru[bufIndex].dwPsdRelayDownCycNum = startCycNum;
}
else
{
/*不处理*/
}
}
/*
* 功能描述：获取指定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
+229 -4
View File
@@ -22,6 +22,7 @@
#include "CommonTypes.h"
#include "../System/CiSystemDefine.h"
#include "../Relay/RelayConfigDataManage.h"
#include "CiInterfaceDefine.h"
#ifdef __cplusplus
extern "C" {
@@ -81,9 +82,30 @@ typedef struct S_PsdDataStruct
UINT8 chCleFarePDBFlaLigFlag; /*清客确认箱PDB按钮指示灯闪灯标志*//*by cgh 20230529*/
UINT8 chVideoQkDriveState; /*视频清客驱动状态 by cgh 20231214*/
UINT16 wVideoQkRelateVobcId; /*视频清客对应列车ID by cgh 20231214*/
UINT32 psdFaultQStataOne; /*单扇门故障隔离信息前四个字节*/
UINT32 psdFaultQStataTwo; /*单扇门故障隔离信息后四个字节*/
UINT32 psdDoorIStateOne; /*单扇门被隔离信息前四字节*/
UINT32 psdDoorIStateTwo; /*单扇门被隔离信息后四字节*/
UINT32 psdDoorsStateOne; /*每扇屏蔽门的开关状态前四个字节*/
UINT32 psdDoorsStateTwo; /*每扇屏蔽门的开关状态后四个字节*/
UINT8 psdOpenErrState; /*开门故障状态*/
UINT8 psdCloseErrState; /*关门故障状态*/
UINT8 cPsdExceptOpenState; /*屏蔽门异常打开状态：0x55-异常打开，0xAA-未异常打开*/
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操作命令
@@ -159,6 +181,13 @@ void ResetPsdData(const UINT16 psdId);
*/
PsdDataStruct *GetPsdData(void);
/*
* 功能描述：获取指定ID屏蔽门数据CC
* 参数说明：无
* 返 回 值：车车屏蔽门动态数据
*/
PsdDataStructCC* GetPsdDataCC(void);
/*
* 功能描述： 获取指定ID屏蔽门互锁解除状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
@@ -518,23 +547,23 @@ UINT32 GetPsdCmdCyclePsc(const UINT16 doorId);
UINT8 SetPsdCmdCyclePsc(const UINT16 doorId, const UINT32 doorCycle);
/*
* 功能描述： 设置指定ID屏蔽门确认PSC互锁解除标志
* 功能描述： 设置指定ID屏蔽门旁路标志
* 参数说明： const UINT16 doorId, 屏蔽门ID
* const UINT8 setFlag, 屏蔽门旁路设置状态
* 返回值 ：无
*
*/
void SetPsdPscConfirmFlag(const UINT16 doorId,const UINT8 setFlag);
void SetPsdConfirmFlag(const UINT16 doorId,const UINT8 setFlag);
/*
* 功能描述： 获取指定ID屏蔽门确认PSC旁路标志
* 功能描述： 获取指定ID屏蔽门旁路标志
* 参数说明： const UINT16 doorId, 屏蔽门ID
*
* 返回值 ： 0: 获取失败
* >0: 获取成功
*/
UINT8 GetPsdPscPlFlag(const UINT16 doorId);
UINT8 GetPsdPlFlag(const UINT16 doorId);
/*
* 功能描述： PSC同时与另一联锁通信时，PSC旁路命令处理
@@ -872,6 +901,202 @@ void SetPsdVideoQkRelateVobcId(const UINT16 wPsdId, const UINT16 wVobcId);
*/
UINT16 GePsdVideoQkRelateVobcId(const UINT16 wPsdId);
/*
* 功能描述：设置指定ID屏蔽门异常打开状态
* 参数说明：const UINT16 wPsdId 屏蔽门ID
* const UINT8 cExceptOpenState 屏蔽门异常打开状态
* 返 回 值：无
* Created By LQ 2025.05.22
*/
void SetPsdExceptOpenState(const UINT16 wPsdId, const UINT8 cExceptOpenState);
/*
* 功能描述：获取指定ID屏蔽门异常打开状态
* 参数说明：const UINT16 wPsdId 屏蔽门ID
* 返 回 值：0x55 异常打开
* 0xAA 未异常打开
* Created By LQ 2025.05.22
*/
UINT8 GePsdExceptOpenState(const UINT16 wPsdId);
/*
* 功能描述： 设置指定ID屏蔽门故障隔离信息
* 参数说明： const UINT16 doorId, 屏蔽门ID
* const UINT32 faultQStateOne, 故障隔离信息高四字节
* * const UINT32 faultQStateTwo, 故障隔离信息低四字节
* 返回值 ： 无
*/
void SetPsdFaultQState(const UINT16 doorId, const UINT32 faultQStateOne, const UINT32 faultQStateTwo);
/*
* 功能描述： 获取指定ID屏蔽门故障隔离信息
* 参数说明： const UINT16 doorId, 屏蔽门ID
* UINT8 psdFlag,前四个字节还是后四个字节(0u为高四个字节，1u为低四个字节)
* 返回值 ： 0: 获取数据失败
* >0: 屏蔽门故障隔离信息
*/
UINT32 GetPsdFaultQState(const UINT16 doorId, UINT8 psdFlag);
/*
* 功能描述： 设置指定ID屏蔽门被隔离信息
* 参数说明： const UINT16 doorId, 屏蔽门ID
* const UINT32 doorsIStateOne, 被隔离信息高四字节
* * const UINT32 doorsIStateTwo, 被隔离信息低四字节
* 返回值 ： 无
*/
void SetPsdDoorIState(const UINT16 doorId, const UINT32 doorsIStateOne, const UINT32 doorsIStateTwo);
/*
* 功能描述： 获取指定ID屏蔽门被隔离信息
* 参数说明： const UINT16 doorId, 屏蔽门ID
* UINT8 psdFlag,前四个字节还是后四个字节(0u为高四个字节，1u为低四个字节)
* 返回值 ： 0: 获取数据失败
* >0: 屏蔽门被隔离信息
*/
UINT32 GetPsdDoorIState(const UINT16 doorId, UINT8 psdFlag);
/*
* 功能描述： 设置指定ID屏蔽门，单扇门开关状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
* const UINT32 doorStateOne, 单扇门开关状态高四字节
* * const UINT32 doorStateTwo, 单扇门开关状态低四字节
* 返回值 ： 无
*/
void SetPsdDoorState(const UINT16 doorId, const UINT32 doorStateOne, const UINT32 doorStateTwo);
/*
* 功能描述： 获取指定ID屏蔽门,单扇门开关状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
* UINT8 psdFlag,前四个字节还是后四个字节(0u为高四个字节，1u为低四个字节)
* 返回值 ： 0: 获取数据失败
* >0: 屏蔽门单扇门开关状态
*/
UINT32 GetPsdDoorState(const UINT16 doorId, UINT8 psdFlag);
/*
* 功能描述： 设置指定ID开门故障状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
* const UINT8 openErrState,开门故障状态
* 返回值 ： 无
*/
void SetOpenErrState(const UINT16 doorId, const UINT8 openErrState);
/*
* 功能描述： 设置指定ID关门故障状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
* const UINT8 closeErrState,关门故障状态
* 返回值 ： 无
*/
void SetCloseErrState(const UINT16 doorId, const UINT8 closeErrState);
/*
* 功能描述： 获取指定ID开门故障状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
* 返回值 ： UINT8 开门故障状态
*/
UINT8 GetOpenErrState(const UINT16 doorId);
/*
* 功能描述： 获取指定ID关门故障状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
* 返回值 ： UINT8 关门故障状态
*/
UINT8 GetCloseErrState(const UINT16 doorId);
/*
* 功能描述：获取指定ID屏蔽门门关继电器落下起始周期号
* 参数说明：const UINT16 doorId 屏蔽门ID
* 返 回 值：门开继电器落下起始周期号
* Created By LQ 2025.06.26
*/
UINT32 GetPsdRelayDownCycNum(const UINT16 doorId);
/*
* 功能描述：设置指定ID屏蔽门门关继电器落下起始周期号
* 参数说明：const UINT16 doorId 屏蔽门ID
* const UINT32 startCycNum 起始周期号
* 返 回 值：无
* Created By LQ 2025.06.26
*/
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
+42 -3
View File
@@ -67,15 +67,36 @@
#define PSD_FAULT_ISOLATION_SCX ((UINT8)0x81U) /*试车线屏蔽门设置故障隔离信息：1和8门隔离*/
#define PSD_OPEN_STATE_SCX ((UINT32)0xFFFFFF7EU) /*试车线故障隔离时屏蔽门打开状态，除1和8门外，全部打开*/
/*屏蔽门驱动电源状态*/
#define PSD_DRIVE_POWER_NORMAL ((UINT8)0x55U) /*驱动电源状态正常*/
#define PSD_DRIVE_POWER_ERROR ((UINT8)0xAAU) /*驱动电源状态故障*/
/*屏蔽门控制电源状态*/
#define PSD_CONTROL_POWER_NORMAL ((UINT8)0x55U) /*控制电源状态正常*/
#define PSD_CONTROL_POWER_ERROR ((UINT8)0xAAU) /*控制电源状态故障*/
/*屏蔽门边缘控制器状态*/
#define PSD_EDGE_CONTROLLER_NORMAL ((UINT8)0x55U) /*边缘控制器状态正常*/
#define PSD_EDGE_CONTROLLER_ERROR ((UINT8)0xAAU) /*边缘控制器状态故障*/
/*屏蔽门障碍物报警状态*/
#define PSD_ALARM_OBS_NO ((UINT8)0xAAU) /*无故障物*/
#define PSD_ALARM_OBS_YES ((UINT8)0x55U) /*有故障物*/
/*屏蔽门开关门故障状态*/
#define PSD_OPEN_CLOSE_NORMAL ((UINT8)0x55U) /*开关门故障状态为正常*/
#define PSD_OPEN_CLOSE_ERROR ((UINT8)0xAAU) /*开关门故障状态为故障*/
/*燕房线FAO编组信息定义*/
#define PSD_FOUR_EDIT_GROUP_FAO_YF ((UINT8)0x01U) /*四编组*/
#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) /*屏蔽门打开之前信号关闭*/
@@ -87,6 +108,10 @@
#define PSD_VIRTUAL_ATTR_YES ((UINT8)0x55U) /*是虚拟屏蔽门*/
#define PSD_VIRTUAL_ATTR_NO ((UINT8)0xaaU) /*不是虚拟屏蔽门*/
/*屏蔽门控制类型*/
#define PSD_CONTROL_TYPE_OC_P ((UINT8)0x55u) /*由OC-P控制*/
#define PSD_CONTROL_TYPE_RCI ((UINT8)0xAAu) /*由RCI控制*/
/*障碍物信息*/
#define PSD_REMORA_YES ((UINT8)0xAAU) /*有障碍物*/
#define PSD_REMORA_NO ((UINT8)0x55U) /*已检测且无障碍物*/
@@ -172,4 +197,18 @@
#define VIDEO_QK_DRIVE_STATE_TESTING ((UINT8)0xccU) /*视频清客驱动状态—检测中*/
#define VIDEO_QK_DRIVE_STATE_INVALID ((UINT8)0xffU) /*视频清客驱动状态—无效*/
/*屏蔽门异常打开状态*/
#define PSD_EXCEPT_OPEN_NO ((UINT8)0xAAU) /*未异常打开*/
#define PSD_EXCEPT_OPEN_YES ((UINT8)0x55U) /*异常打开*/
/*OC-P旁路状态确认*/
#define OC_PSC_PL_CONFIRM_YES ((UINT8)0xaaU) /*OC-P旁路状态已确认*/
#define OC_PSC_PL_CONFIRM_NO ((UINT8)0x55U) /*OC-P旁路状态未确认*/
/*获取屏蔽门信息*/
#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
+29 -10
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) /*物理区段故障占用取消二次命令*/
@@ -147,7 +144,10 @@
#define ATS_CMD_OPEN_XIANSU_SIGNAL_SECOND ((UINT8)0x9e) /*开放限速信号二次*/
#define ATS_CMD_OPEN_XIANSU_SIGNAL_SPECIAL ((UINT8)0xa6) /*限速信号特殊开放*/
#define ATS_CMD_OC_P_PL_ONE ((UINT8)0xa8) /*设置OC-P旁路一次命令*/
#define ATS_CMD_OC_P_PL_TWO ((UINT8)0xa9) /*设置OC-P旁路二次命令*/
#define ATS_CMD_QUXIAO_OC_P_PL_ONE ((UINT8)0xaa) /*取消OC-P旁路一次命令*/
#define ATS_CMD_QUXIAO_OC_P_PL_TWO ((UINT8)0xab) /*取消OC-P旁路二次命令*/
#define ATS_CMD_GET_CTRL_POWER ((UINT8)0x81) /* 获取联锁控制权*/
#define ATS_CMD_RELEASE_CTRL_POWER ((UINT8)0x82) /* 释放联锁控制权*/
@@ -162,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) /*物理区段征用申请*/
@@ -213,7 +218,7 @@
#define VOBCTOCI_COMMAND_TYPE_PSDCHECK ((UINT8)0x00) /*查询PSD命令*/
#define VOBCTOCI_COMMAND_TYPE_PSDOPEN ((UINT8)0x55) /*打开PSD命令*/
#define VOBCTOCI_COMMAND_TYPE_PSDCLOSE ((UINT8)0xAA) /*关闭PSD命令*/
#define VOBCTOCI_COMMAND_TYPE_PSDCHECK_FAOHLHT ((UINT8)0xFF) /*查询PSD命令(新机场线查询命令)*/
#define VOBCTOCI_COMMAND_TYPE_PSDCHECK_FAOHLHT ((UINT8)0xFF) /*查询PSD命令(新机场线查询命令)、PSD命令默认值*/
/****联锁到ATS反馈信息宏定义****/
/*反馈信息类型*/
@@ -245,6 +250,8 @@
#define CI_BACK_GROUP_AUTO_ROUTE_SET_ERR ((UINT8)0x7e) /*组合自动进路自动属性设置失败*/
#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) /*进路始端信号机开放*/
@@ -285,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) /*道岔引导总锁*/
@@ -298,7 +306,8 @@
#define CI_BACK_SWT_POS_ERROR ((UINT8)0x37) /*道岔位置错误*/
#define CI_BACK_SWT_MOVE_VALID ((UINT8)0x00) /*道岔不可动作*/
#define CI_BACK_SWT_MOVE_OT ((UINT8)0x39) /*道岔动作超时*/
#define CI_BACK_SWT_BYPASS_CANCEL_NO ((UINT8)0x93) /*联络线道岔旁路未及时取消*/
#define CI_BACK_SWT_BYPASS_CANCEL_NO ((UINT8)0x93) /*联络线道岔旁路未及时取消*/
#define CI_BACK_SWT_MOVE ((UINT8)0xA3) /*道岔转动中*/
/* zt 删除单轨相关代码 2022-02-15 */
#define CI_BACK_SWT_USING ((UINT8)0x3f) /*道岔征用中*/
#define CI_BACK_SWT_MOVE_ERR ((UINT8)0x84) /*道岔搬动失败*/
@@ -404,8 +413,16 @@
#define CI_BACK_SEC_UPDATA_ERROR ((UINT8)0x00) /* 区段更新失败 */
#define CI_BACK_SWT_UPDATA_ERROR ((UINT8)0x00) /* 道岔更新失败 */
/*动态路径命令反馈*/
#define CI_BACK_DYM_ROUTE_CONTINUOUS ((UINT8)0xA5) /*动态路径命令条件不满足：逻辑区段不连续*/
#define CI_BACK_DYM_ROUTE_RES ((UINT8)0xA6) /*动态路径命令条件不满足：列车占压逻辑区段资源不齐全或不唯一*/
#define CI_BACK_DYM_ROUTE_MATCH_ROUTE ((UINT8)0xA7) /*动态路径命令条件不满足：逻辑区段序列未匹配到进路*/
#define CI_BACK_DYM_ROUTE_SCREEN ((UINT8)0xA8) /*动态路径命令条件不满足：列车未完成筛选*/
#define CI_BACK_DYM_ROUTE_SEC_CBTC ((UINT8)0xA9) /*动态路径命令条件不满足：逻辑区段非CBTC区域*/
#define CI_BACK_DYM_ROUTE_REPEAT ((UINT8)0xAA) /*动态路径命令条件不满足：重复办理*/
#define CI_BACK_DYM_ROUTE_SEC_ATTR ((UINT8)0xAB) /*动态路径命令条件不满足：场段仅支持休眠唤醒轨一个区段的动态路径办理*/
#define CI_BACK_DYM_ROUTE_TRAIN_COMM ((UINT8)0xAC) /*动态路径命令条件不满足：场段RC与列车通信中断*/
#define CI_BACK_DYM_ROUTE_TRAIN_POS ((UINT8)0xAD) /*动态路径命令条件不满足：场段列车不完全处在休眠唤醒轨*/
#define CI_BACK_DATA_INFO_TYPE_ERR ((UINT8)0xf1) /* CI与其他子系统数据接口信息类型错误 */
#define CI_BACK_DATA_SEND_FLAG_ERR ((UINT8)0xf2) /* CI与其他子系统数据发送方标识信息错误 */
@@ -435,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
+2033 -979
View File
File diff suppressed because it is too large Load Diff
TSCP/src/APP/ciapp/ParsePack/ParsePackAtsData.h
+139 -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接收的操作命令结构体数组长度
@@ -366,6 +391,117 @@ UINT16 TransCiToAtsSwitchZzjInfo(OcToATSSwitchZzjData* ciSendAtsSwitchZzjData, U
*/
static UINT8 TransCiToAtsPowerModeState(UINT8 ciToXianDiData, UINT8 MoveNum, UINT8 powerState, UINT8 BitValY, UINT8 BitValN);
/*
* 功能描述： 组OC-P信息到ATS
* 参数说明：入参
* UINT8* ciToXianDiDataBuffer 存放信息的buffer
* UINT16* ii 偏移量
* 出参
* 无
* 返回值 ： 无
*/
void PackOcPscDataToAts(UINT8* ciToXianDiDataBuffer, UINT16* ii);
/*
* 功能描述： 组PSD信息到ATS
* 参数说明：入参
* UINT8* ciToXianDiDataBuffer 存放信息的buffer
* UINT16* ii 偏移量
* 出参
* 无
* 返回值 ： 无
*/
void PackPsdDataToAts(UINT8* ciToXianDiDataBuffer, UINT16* ii);
/*
* 功能描述： 获取确认OC-P旁路状态
* 参数说明： UINT8 index, OC-P系统对应的数组下标
*
* 返回值 ： 0x55 旁路状态已确认
* 0xaa 旁路状态未确认
*/
UINT8 GetOcPscConfirmFlag(UINT8 index);
/*
* 功能描述： 组通信联锁信息到ATS
* 参数说明：入参
* UINT8* ciToXianDiDataBuffer 存放信息的buffer
* UINT16* ii 偏移量
* 出参
* 无
* 返回值 ： 无
*/
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
+641 -61
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,15 +137,18 @@ UINT8 InitAxleToCiDataStru(void)
UINT8 belongAxleSysId = 0u; /*物理区段所属计轴ID*/
UINT16 axlePhySecSum = 0u; /*计轴系统包含物理区段数目*/
UINT8 pyhIsThisLine = 0u;
UINT8 cPrtclVerBtwCiAndAxle = 0U; /*联锁和计轴间的协议校验版本号*/
UINT8 chAxisLogId = 0U;
ciId = GetSystemParaLocalCiId();
ciName = (CI_SYSTEM_TYPE_CI) * 256U + ciId;
rtn = DsuRsspInitWl((const)DataPath,0,NULL,ciName, 0, &dsuRsspInfo);
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,73 +156,93 @@ UINT8 InitAxleToCiDataStru(void)
{
axleId = deviceIdBuf[i];
axleName = (CI_SYSTEM_TYPE_AXIS) * 256u + axleId;
cPrtclVerBtwCiAndAxle = GetCiAndAxisPrtclCheckVer(); /*获取协议校验版本号*/
if (20U <= cPrtclVerBtwCiAndAxle)
{
rtn = dquDevName2HlhtId(axleName, 0U, &axieEtcsId); /*获取计轴互联互通ID*/
rtn &= dquDevName2HlhtId(ciName, 0U, &ciEtcsId); /*获取CI互联互通ID*/
}
else
{
/*使用设备ID作为互联互通ID*/
rtn = GetRsspiAddr(axleName, ciName, &axieEtcsId, &ciEtcsId);
}
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;/*防护代码，防止越界*/
}
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); /*默认设置下标为无效位置*/
for (j = 0u; j < phySecCurSum; j++) /*遍历物理区段*/
else
{
phySecId = GetPhySecId(j);
belongCiId = GetPhySecBelongCiId(phySecId);
belongAxleSysId = GetPhySecBelongAxisSysId(phySecId);
pyhIsThisLine = GetPhyIsThisLineState(phySecId); /*是否本线路*/
if ((0U < phySecId) && (phySecId < PHYSICAL_SECTION_SUM_MAX) && (belongCiId == ciId)
&& (belongAxleSysId == axleId) && (DEV_IS_THIS_LINE_YES == pyhIsThisLine))
axisToCiDataStru[axleId].deviceType = CI_SYSTEM_TYPE_AXIS;
axisToCiDataStru[axleId].axisSystemId = deviceIdBuf[i];
axisToCiDataStru[axleId].axisEtcsId = axieEtcsId;
axisToCiDataStru[axleId].ciEtcsId = ciEtcsId;
(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++) /*遍历物理区段*/
{
axlePhySecSum = axisToCiDataStru[axleId].SectionSum;
if (CI_INCLUDE_AXIS_MAX_SUM > axlePhySecSum)
phySecId = GetPhySecId(j);
belongCiId = GetPhySecBelongCiId(phySecId);
belongAxleSysId = GetPhySecBelongAxisSysId(phySecId);
pyhIsThisLine = GetPhyIsThisLineState(phySecId); /*是否本线路*/
if ((0U < phySecId) && (phySecId < PHYSICAL_SECTION_SUM_MAX) && (belongCiId == ciId)
&& (belongAxleSysId == axleId) && (DEV_IS_THIS_LINE_YES == pyhIsThisLine))
{
axisToCiDataStru[axleId].axisDataStr[axlePhySecSum].PhySecId = phySecId;
axisToCiDataStru[axleId].axisDataStr[axlePhySecSum].gdRelayState = RELAY_STATE_DOWN;
axisToCiDataStru[axleId].axisDataStr[axlePhySecSum].faultInfo = 0u;
axisToCiDataStru[axleId].axisDataStr[axlePhySecSum].showAndReplyInfo = 0u;
axisToCiDataStru[axleId].axisDataStr[axlePhySecSum].PreResetRst = RELAY_STATE_DOWN;
axisToCiDataStru[axleId].axisDataStr[axlePhySecSum].State = RELAY_STATE_DOWN;
axlePhySecSum = axisToCiDataStru[axleId].SectionSum;
axisToCiDataStru[axleId].PhySecIdx[phySecId] = (UINT8)(axlePhySecSum);
if (CI_INCLUDE_AXIS_MAX_SUM > axlePhySecSum)
{
axisToCiDataStru[axleId].axisDataStr[axlePhySecSum].PhySecId = phySecId;
axisToCiDataStru[axleId].axisDataStr[axlePhySecSum].gdRelayState = RELAY_STATE_DOWN;
axisToCiDataStru[axleId].axisDataStr[axlePhySecSum].faultInfo = 0u;
axisToCiDataStru[axleId].axisDataStr[axlePhySecSum].showAndReplyInfo = 0u;
axisToCiDataStru[axleId].axisDataStr[axlePhySecSum].PreResetRst = RELAY_STATE_DOWN;
axisToCiDataStru[axleId].axisDataStr[axlePhySecSum].chPreResetBack = RELAY_STATE_UP;
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].SectionSum++;
axisToCiDataStru[axleId].PhySecIdx[phySecId] = (UINT8)(axlePhySecSum);
axisToCiDataStru[axleId].dwLastRecvDataCycNum = 0U;
axisToCiDataStru[axleId].SectionSum++;
}
else /*超出最大*/
{
rtn = CI_ERROR;
break;
}
}
else /*超出最大*/
else
{
rtn = CI_ERROR;
break;
; /*不处理*/
}
}
}
}
else
{
;
}
if (CI_ERROR == rtn)
{
debug_infor_printf((const)"InitAxleToCiDataStru fail,dquDevName2HlhtId error\r\n");
break;
}
else
{
; /*继续初始化*/
}
}
}
else
{
rtn = CI_SUCCESS;
;
}
}
if (CI_ERROR == rtn)
else
{
debug_infor_printf((const)"InitAxleToCiDataStru fail.\r\n");
debug_infor_printf((const)"InitAxleToCiDataStru fail,DsuRsspInitWl error\r\n");
}
return rtn;
@@ -255,7 +278,12 @@ UINT8 ParseAxisToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength, cons
UINT32 galAxisDataVer = 0u; /*计轴系统数据版本号*/
UINT32 ciAndAxisTimeOutCout = 0u; /*联锁与计轴通信中断周期数*/
UINT32 ciCurappCycleTime = 0u; /*联锁当前周期*/
UINT16 axisDevName = 0u; /*计轴名称：类型+ID*/
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数组*/
@@ -273,6 +301,9 @@ UINT8 ParseAxisToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength, cons
axisToCiDataStru[systemId].axisDataStr[jj].faultInfo = 0u;
axisToCiDataStru[systemId].axisDataStr[jj].showAndReplyInfo = 0u;
axisToCiDataStru[systemId].axisDataStr[jj].PreResetRst = RELAY_STATE_DOWN;
axisToCiDataStru[systemId].axisDataStr[jj].chPreResetBack = RELAY_STATE_UP;
axisToCiDataStru[systemId].axisDataStr[jj].chDirectResetRst = RELAY_STATE_DOWN;
axisToCiDataStru[systemId].axisDataStr[jj].chDirectResetBack = RELAY_STATE_UP;
axisToCiDataStru[systemId].axisDataStr[jj].State = RELAY_STATE_DOWN;
}
@@ -311,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)
{
@@ -450,6 +481,258 @@ UINT8 ParseAxisToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength, cons
retVal = CI_ERROR;
}
}
else if (AXIS_TYPE_FUHAOSHENG == acFty)
{
phySecNum = dataBuf[ii++]; /*获取计轴区段数量*/
wPhySecCurSum = axisToCiDataStru[systemId].SectionSum;
if ((AXIS_TO_CI_SECTION_SUM_MAX > phySecNum) && (wPhySecCurSum == phySecNum))
{
/*计轴设备工作健康状态只解析不处理*/
ii++;
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 if((0x00U == (dataBuf[ii] & 0x03U)) || (0x01U == (dataBuf[ii] & 0x03U)))
{ /*01B:区段占用*/
axisToCiDataStru[systemId].axisDataStr[axisDataStrIdx].gdRelayState = RELAY_STATE_DOWN;
}
else
{
retVal = CI_ERROR;
debug_infor_printf((const)"\nwIndexInAxle:%d OccState ERROR\n", wIndexInAxle);
}
}
else
{
;
}
if (CI_SUCCESS == retVal)
{
if (0x01U == ((dataBuf[ii] >> 2U) & 0x01U))
{
/*计轴受扰*/
axisToCiDataStru[systemId].axisDataStr[axisDataStrIdx].State = RELAY_STATE_DOWN;
}
else
{
/*默认状态*/
axisToCiDataStru[systemId].axisDataStr[axisDataStrIdx].State = RELAY_STATE_UP;
}
}
else
{
;
}
if (CI_SUCCESS == retVal)
{
if (0x01U == ((dataBuf[ii] >> 3U) & 0x01U))
{
/*未接受到计轴立即复位命令*/
axisToCiDataStru[systemId].axisDataStr[axisDataStrIdx].chDirectResetBack = RELAY_STATE_DOWN;
}
else
{
/*接受到计轴立即复位命令*/
axisToCiDataStru[systemId].axisDataStr[axisDataStrIdx].chDirectResetBack = RELAY_STATE_UP;
}
}
else
{
;
}
if (CI_SUCCESS == retVal)
{
if (0x01U == ((dataBuf[ii] >> 4U) & 0x01U))
{
/*计轴立即复位成功*/
axisToCiDataStru[systemId].axisDataStr[axisDataStrIdx].chDirectResetRst = RELAY_STATE_UP;
}
else
{
/*计轴立即复位未执行或者执行未成功*/
axisToCiDataStru[systemId].axisDataStr[axisDataStrIdx].chDirectResetRst = RELAY_STATE_DOWN;
}
}
else
{
;
}
if (CI_SUCCESS == retVal)
{
if (0x01U == ((dataBuf[ii] >> 5U) & 0x01U))
{
/*未接受到计轴预复位命令*/
axisToCiDataStru[systemId].axisDataStr[axisDataStrIdx].chPreResetBack = RELAY_STATE_DOWN;
}
else
{
/*接受到计轴预复位命令*/
axisToCiDataStru[systemId].axisDataStr[axisDataStrIdx].chPreResetBack = RELAY_STATE_UP;
}
}
else
{
;
}
if (CI_SUCCESS == retVal)
{
if (0x01U == ((dataBuf[ii] >> 6U) & 0x01U))
{
/*计轴预复位成功*/
axisToCiDataStru[systemId].axisDataStr[axisDataStrIdx].PreResetRst = RELAY_STATE_UP;
}
else
{
/*计轴预复位未执行或者执行未成功*/
axisToCiDataStru[systemId].axisDataStr[axisDataStrIdx].PreResetRst = RELAY_STATE_DOWN;
}
}
else
{
;
}
/*计轴区段状态*/
ii++;
if (CI_SUCCESS != retVal)
{
retVal = CI_ERROR;
break; /*解析失败，停止解析，返回失败*/
}
else
{
/*继续解析*/
}
}
if (CI_SUCCESS == retVal)
{
/*包含的计轴磁头数量*/
ii++;
}
else
{
;
}
}
else
{
retVal = CI_ERROR;
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;
@@ -458,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)
@@ -469,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)
@@ -515,6 +813,9 @@ UINT8 ParseAxisToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength, cons
axisToCiDataStru[systemId].axisDataStr[jj].faultInfo = 0u;
axisToCiDataStru[systemId].axisDataStr[jj].showAndReplyInfo = 0u;
axisToCiDataStru[systemId].axisDataStr[jj].PreResetRst = RELAY_STATE_DOWN;
axisToCiDataStru[systemId].axisDataStr[jj].chPreResetBack = RELAY_STATE_UP;
axisToCiDataStru[systemId].axisDataStr[jj].chDirectResetRst = RELAY_STATE_DOWN;
axisToCiDataStru[systemId].axisDataStr[jj].chDirectResetBack = RELAY_STATE_UP;
axisToCiDataStru[systemId].axisDataStr[jj].State = RELAY_STATE_DOWN;
}
@@ -528,17 +829,6 @@ UINT8 ParseAxisToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength, cons
return retVal;
}
/*
* 功能描述： 获取计轴采集数据结构体数组
* 参数说明： void
* 返回值 ： NULL: 获取失败
* !NULL: 采集板结构体数组指针
*/
AxisToCiDataStruct* GetCollAxisDataStruct(void)
{
return axisToCiDataStru;
}
/*
* 功能描述： 清除Axis数据
* 参数说明： void
@@ -592,6 +882,15 @@ UINT8 PackCiToAxisData(UINT8 axisSysId)
UINT16 dstDevId = 0u;
UINT8 outnetSafeSendRtn = 0u;
UINT16 axisDevName = 0u; /*计轴名称：类型+ID*/
UINT8* pDataByteIndex = NULL; /*数据比特位索引地址*/
UINT8 chDataCurPos = 0U;/*数据当前位置*/
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)
{
@@ -742,6 +1041,213 @@ UINT8 PackCiToAxisData(UINT8 axisSysId)
{
}
}
else if (AXIS_TYPE_FUHAOSHENG == acFty)
{
phyCount = axisToCiDataStru[axisSysId].SectionSum;
CiToAxisDataBuffer[ii] = (UINT8)(phyCount);
ii++;
for (jj = 0U; jj < phyCount; jj++)
{
/*先处理计轴直接复位*/
/*每一个字节存储4个区段复位命令*/
chDataCurPos = jj % SEC_NUM_PER_BYTE;
if (0U == chDataCurPos)
{
pDataByteIndex = &CiToAxisDataBuffer[ii];
ii++;
}
else
{
/*没有满一个字节，继续等待*/
;
}
chOffset = chDataCurPos * BIT_NUM_PER_SEC;
wIndexInAxle += 1U;
phySecId = GetPhyIdByIndexInAxle(axisSysId, wIndexInAxle); /*区段ID*/
fwCycle = GetPhySecResetStartCycNum(phySecId);
if (0U < fwCycle)
{
resetType = GetPhySecSectionResetType(phySecId);
if (PHYSICAL_SECTION_PRE_RESET_NO == resetType)
{
/*处理直接复位*/
chSecResetBackState = GetPhySecDirectResetBack(phySecId);
if (PHY_RESET_BACK_RECIVE_NO == chSecResetBackState)
{
/*发送*/
*pDataByteIndex = *pDataByteIndex | ((UINT8)(0X02U << chOffset));
}
else
{
/*不发送*/
*pDataByteIndex = *pDataByteIndex | ((UINT8)(0X00U << chOffset));
}
}
else if (PHYSICAL_SECTION_PRE_RESET_YES == resetType)
{
/*预复位等待不发送*/
*pDataByteIndex = *pDataByteIndex | ((UINT8)(0X00U << chOffset));
}
else
{
retVal = CI_ERROR;
}
}
else
{
/*不发送*/
*pDataByteIndex = *pDataByteIndex | ((UINT8)(0X00U << chOffset));
}
if (CI_ERROR == retVal)
{
break;
}
else
{
; /*继续*/
}
}
if (CI_SUCCESS == retVal)
{
wIndexInAxle = 0U;
for (jj = 0U; jj < phyCount; jj++)
{
/*处理计轴预复位*/
/*每一个字节存储4个区段复位命令*/
chDataCurPos = jj % SEC_NUM_PER_BYTE;
if (0U == chDataCurPos)
{
pDataByteIndex = &CiToAxisDataBuffer[ii];
ii++;
}
else
{
/*没有满一个字节，继续等待*/
;
}
chOffset = chDataCurPos * BIT_NUM_PER_SEC;
wIndexInAxle += 1U;
phySecId = GetPhyIdByIndexInAxle(axisSysId, wIndexInAxle); /*区段ID*/
fwCycle = GetPhySecResetStartCycNum(phySecId);
if (0U < fwCycle)
{
resetType = GetPhySecSectionResetType(phySecId);
if (PHYSICAL_SECTION_PRE_RESET_NO == resetType)
{
/*直接复位等待不发送*/
/*不发送*/
*pDataByteIndex = *pDataByteIndex | ((UINT8)(0X00U << chOffset));
}
else if (PHYSICAL_SECTION_PRE_RESET_YES == resetType)
{
chSecResetBackState = GetPhySecPreResetBack(phySecId);
if (PHY_RESET_BACK_RECIVE_NO == chSecResetBackState)
{
/*发送*/
*pDataByteIndex = *pDataByteIndex | ((UINT8)(0X02U << chOffset));
}
else
{
/*不发送*/
*pDataByteIndex = *pDataByteIndex | ((UINT8)(0X00U << chOffset));
}
}
else
{
retVal = CI_ERROR;
}
}
else
{
/*不发送*/
*pDataByteIndex = *pDataByteIndex | ((UINT8)(0X00U << chOffset));
}
if (CI_ERROR == retVal)
{
break;
}
else
{
; /*继续*/
}
}
}
else
{
; /*不继续组包*/
}
}
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;
@@ -769,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/*日志打印宏*/
@@ -951,6 +1458,79 @@ static UINT8 GetPhySecIdxInAxisDataStr(const UINT8 axleId, const UINT16 phySecId
return rtn;
}
/*
* 功能描述： 计算物理区段在计轴系统中的下标
* 参数说明： const UINT8 chAxleId, 计轴系统ID
* const UINT16 wIndexInAxle, 计轴系统中物理区段的序号
* UINT8* pAxleDataStrIdx, 计轴系统里物理区段ID下标
* 返回值 ： CI_ERROR: 获取失败
* CI_SUCCESS: 获取成功
* by cgh 20250415
*/
UINT8 GetInAxlePhySecIdx(const UINT8 chAxleId, const UINT16 wIndexInAxle, UINT8* pAxleDataStrIdx)
{
UINT8 ret = CI_ERROR; /*返回值*/
UINT16 wTempPhyId = 0U; /*临时记录的物理区段ID*/
if ((NULL != pAxleDataStrIdx) && (AXIS_TO_CI_SUM_MAX > chAxleId))
{
wTempPhyId = GetPhyIdByIndexInAxle(chAxleId, wIndexInAxle); /*获取计轴系统区段序号对应物理区段ID*/
if ((0U < wTempPhyId) && (PHYSICAL_SECTION_SUM_MAX > wTempPhyId))
{
*pAxleDataStrIdx = axisToCiDataStru[chAxleId].PhySecIdx[wTempPhyId];/*AxisDataStr里物理区段ID下标*/
}
else
{
*pAxleDataStrIdx = AXISDATASTR_IDX;
}
if (AXISDATASTR_IDX != (*pAxleDataStrIdx))
{
ret = CI_SUCCESS;
}
else
{
/*返回error*/
}
}
else
{
/*返回error*/
}
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
+26 -11
View File
@@ -41,7 +41,8 @@
#include "../LogRecord/LogRecord.h"
#endif
#define SEC_NUM_PER_BYTE ((UINT8)4) /*每一个字节包含区段数目*/
#define BIT_NUM_PER_SEC ((UINT8)(8 / SEC_NUM_PER_BYTE)) /*每一个区段所占比特位数目*/
/*与联锁通信的区段信息*/
typedef struct S_AxisDataStruct
@@ -50,10 +51,12 @@ typedef struct S_AxisDataStruct
UINT8 gdRelayState; /*股道继电器状态，落下：0x55，吸起：0xaa*/
UINT8 showAndReplyInfo; /*bit0、bit1复零反馈，bit2、bit3预留，bit4到bit7表示信息（动态字段）*/
UINT8 faultInfo; /*故障信息，bit0区段故障、bit1板卡故障、bit2区段上电、bit3通信故障、bit4负轴故障、bit5磁头故障、bit6预留、bit7轨旁上电(动态字段)*/
UINT8 PreResetRst; /*预复位结果*/
UINT8 chPreResetBack; /*预复位命令反馈*/
UINT8 chDirectResetRst; /*直接复位结果*/
UINT8 chDirectResetBack; /*直接复位命令反馈*/
UINT8 State; /*状态*/
UINT8 chResetCmdTagBack; /*复位命令标签反馈*/
} AxisCollDataStruct;
typedef struct S_AxisToCiDataStruct
@@ -65,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;
@@ -85,14 +89,6 @@ extern "C" {
*/
UINT8 ParseAxisToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength, const UINT8 systemId);
/*
* 功能描述： 获取计轴采集数据结构体数组
* 参数说明： void
* 返回值 ： NULL: 获取失败
* !NULL: 采集板结构体数组指针
*/
AxisToCiDataStruct* GetCollAxisDataStruct(void);
#if 0
/*
* 功能描述： 解析处理计轴通信采集数据
@@ -126,6 +122,25 @@ UINT8 PackCiToAxisData( UINT8 axisSysId);
*/
UINT8 InitAxleToCiDataStru(void);
/*
* 功能描述： 计算物理区段在计轴系统中的下标
* 参数说明： const UINT8 chAxleId, 计轴系统ID
* const UINT16 wIndexInAxle, 计轴系统中物理区段的序号
* UINT8* pAxleDataStrIdx, 计轴系统里物理区段ID下标
* 返回值 ： CI_ERROR: 获取失败
* CI_SUCCESS: 获取成功
* by cgh 20250415
*/
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
+6230 -2340
View File
File diff suppressed because it is too large Load Diff
TSCP/src/APP/ciapp/ParsePack/ParsePackCiData.h
+252 -25
View File
@@ -58,6 +58,8 @@
#define MANUFAC_DEF_STATUS_PACKET ((UINT16)0x020c) /*厂商自定义信息类型*/
#define MANUFAC_DEF_INFO_VER_WL ((UINT8)0x01) /*厂商自定义信息版本（微联）*/
#define PSD_NUM_PER_BYTE ((UINT8)2) /*PSD字节常量*/
#define BIT_NUM_PER_PSD ((UINT8)(8U / PSD_NUM_PER_BYTE)) /*PSD字节常量*/
#define ESB_NUM_PER_BYTE ((UINT8)4) /*紧急停车按钮字节常量*/
@@ -69,6 +71,9 @@
#define TSR_NUM_PER_BYTE ((UINT8)4) /*TSR按钮字节常量*/
#define BIT_NUM_PER_TSR ((UINT8)(8U / TSR_NUM_PER_BYTE)) /*TSR字节常量*/
#define DEV_NUM_PER_BYTE ((UINT8)4U) /*每一个字节包含的设备数目*/
#define BIT_NUM_PER_DEV ((UINT8)(8U / DEV_NUM_PER_BYTE)) /*每一个设备所占比特位数目*/
#define PACKET_LENGTH_LEN ((UINT8)2) /*数据总长度*/
#define PACKET_TYPE_LEN ((UINT8)2) /*数据类型长度*/
@@ -95,15 +100,16 @@
#define PHYSEC_LOCKDIRECTION_OPPST_YES ((UINT8)0xAA) /*取反*/
#define PHYSEC_LOCKDIRECTION_OPPST_DEFAULT ((UINT8)0xFF) /*默认值*/
#define CICI_VERSION ((UINT16)23) /*cici接口版本号，每次修改接口需要升级版本号——Last Modified On 2025.03.10*/
#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_SIGNAL_LEN ((UINT16)9)/*一个信号机数据长度*/
#define CICI_ONE_PSD_LEN ((UINT16)4)/*一个屏蔽门数据长度*/
#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数据长度*/
@@ -120,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
{
@@ -233,9 +247,18 @@ extern "C" {
UINT8 cSourceCiId; /*发送方联锁ID*/
UINT8 cTargetCiId; /*接收方联锁ID*/
UINT8 cPlatFormNum; /*区间雨雪站台数量*/
UINT32 dwPlatFormId[CI_TO_CI_AREA_SNOW_SUM_MAX]; /*区间雨雪站台互联互通ID数组*/
AreaSnowInfoStruct szPlatFormInfo[CI_TO_CI_AREA_SNOW_SUM_MAX]; /*区间雨雪信息数组*/
} ToCiAreaSnowStruct;
/*相邻RC间的区间ITE切除信息*/
typedef struct S_ToCiAreaIteCutStruct
{
UINT8 cSourceCiId; /*发送方联锁ID*/
UINT8 cTargetCiId; /*接收方联锁ID*/
UINT8 cAreaIteCutNum; /*区间ITE切除数量*/
UINT16 wAreaIteCutId[CI_TO_CI_AREA_SNOW_SUM_MAX]; /*区间ID数组*/
} ToCiAreaIteCutStruct;
/*******************************全局变量声明*******************************/
extern ToCiCommandDataStruct RecvCiCmdDataStru[RECVCI_CMD_DATA_STRU_SUM_MAX];
extern UINT16 RecvCiCmdDataStruCurSum;
@@ -252,22 +275,19 @@ extern "C" {
extern UINT8 SendCiDrCmdSum;
extern ToCiAreaSnowStruct szRecvCiAreaSnow[CI_COM_CI_MAX_NUM];
extern ToCiAreaSnowStruct szSendCiAreaSnow[CI_COM_CI_MAX_NUM];
/*
* 功能描述： 解析CI数据
* 参数说明： void
* 返回值 ： 0: 解析失败
* 1: 解析成功
*/
UINT8 ParseCiToCiData(void);
extern ToCiAreaIteCutStruct szRecvCiAreaIteCut[CI_COM_CI_MAX_NUM];
extern ToCiAreaIteCutStruct szSendCiAreaIteCut[CI_COM_CI_MAX_NUM];
/*
* 功能描述： 解析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间单帧数据
@@ -721,21 +741,23 @@ UINT8 CiToCiEnvelopeCheck(const UINT8* dataBuf, UINT16* index);
* 功能描述： 添加相邻联锁发送给本联锁的区间雨雪信息
* 参数说明： UINT8 cSrcCiId 发送方CI
* UINT8 cDstCiId 接收方CI
* UINT32 dwAreaSnowId 区间雨雪站台ID
* 返回值 ： 无
* Created By LQ 2023.11.16
* UINT16 wAreaSnowId 区间ID
* UINT8 cAreaSnowLevel 区间湿轨级别
* 返 回 值： 无
* Modified By LQ 2025.5.28
*/
void AddCiRecvAreaSnowInfo(UINT8 cSrcCiId, UINT8 cDstCiId, UINT32 dwAreaSnowId);
void AddCiRecvAreaSnowInfo(UINT8 cSrcCiId, UINT8 cDstCiId, UINT16 wAreaSnowId, UINT8 cAreaSnowLevel);
/*
* 功能描述： 添加本联锁发送给指定ID相邻联锁的区间雨雪信息
* 参数说明： UINT8 cSrcCiId 发送方CI
* UINT8 cDstCiId 接收方CI
* UINT32 dwAreaSnowId 区间雨雪站台ID
* 返回值 ： 无
* Created By LQ 2023.11.16
* UINT16 wAreaId 区间ID
* UINT8 cAreaSnowLevel 区间湿轨等级
* 返 回 值： 无
* Modified By LQ 2025.05.28
*/
void AddCiSendAreaSnowInfo(UINT8 cSrcCiId, UINT8 cDstCiId, UINT32 dwAreaSnowId);
void AddCiSendAreaSnowInfo(UINT8 cSrcCiId, UINT8 cDstCiId, UINT16 wAreaId, UINT8 cAreaSnowLevel);
/*
* 功能描述： 获取相邻联锁发送给本联锁的区间雨雪信息
@@ -909,6 +931,211 @@ UINT8 PackHlhtPacketHeadPha1(UINT8 dstCiId, UINT8 * pInputData, UINT16 * pHeadDa
*/
UINT8 InitNeedOlapUsingOtherCiProSw(void);
/*
* 功能描述：清除相邻联锁发送给本联锁的区间ITE切除信息
* 参数说明：const UINT8 cSrcCiId 发送方CI
* 返 回 值：无
* Created By LQ 2025.04.14
*/
void ClearCiRecvAreaIteCutInfo(const UINT8 cSrcCiId);
/*
* 功能描述：清除本联锁发送给相邻联锁的区间ITE切除信息
* 参数说明：无
* 返 回 值：无
* Created By LQ 2025.04.14
*/
void ClearCiSendAreaIteCutInfo(void);
/*
* 功能描述： 获取相邻联锁发送给本联锁的区间ITE切除信息
* 参数说明： 无
* 返 回 值： 接收其它联锁的区间ITE切除信息
* Created By LQ 2025.04.14
*/
ToCiAreaIteCutStruct* GetCiRecvAreaIteCutInfo(void);
/*
* 功能描述：获取本联锁发送给指定ID相邻联锁的区间ITE切除信息
* 参数说明：const UINT8 cTargetCiId 目标联锁
* 返 回 值：发送给其它联锁的区间ITE切除信息
* Created By LQ 2023.11.16
*/
ToCiAreaIteCutStruct* GetCiSendAreaIteCutInfo(const UINT8 cTargetCiId);
/*
* 功能描述：添加相邻联锁发送给本联锁的区间ITE切除信息
* 参数说明：UINT8 cSrcCiId 发送方CI
* UINT8 cDstCiId 接收方CI
* UINT16 wAreaId 区间ID
* 返 回 值：无
* Created By LQ 2025.04.14
*/
void AddCiRecvAreaIteCutInfo(UINT8 cSrcCiId, UINT8 cDstCiId, UINT16 wAreaId);
/*
* 功能描述：添加本联锁发送给指定ID相邻联锁的区间ITE切除信息
* 参数说明：UINT8 cSrcCiId 发送方CI
* UINT8 cDstCiId 接收方CI
* UINT16 wAreaId 区间ID
* 返 回 值：无
* Created By LQ 2025.04.14
*/
void AddCiSendAreaIteCutInfo(UINT8 cSrcCiId, UINT8 cDstCiId, UINT16 wAreaId);
/*
* 功能描述：校验相邻CI发送的待解析的区间ITE切除数据
* 参数说明：const UINT8* dataBuf 待解析的数据；
* UINT16* index 索引
* 返 回 值：0 校验失败
* 1 校验成功
* Created By LQ 2024.04.15
*/
UINT8 CheckCiToCiAreaIteCutData(const UINT8* dataBuf, UINT16* index);
/*
* 功能描述：组互联互通厂商自定义帧
* 参数说明：UINT8 *pInputData 输入数据指针
* UINT16 *pItemLen 该项数据在输入数据中的长度（出参）
* const UINT8 dstCiId 目标联锁ID
* 返 回 值：CI_SUCCESS 1 组包成功
* CI_ERROR 0 组包失败
* Created By LQ 2025.05.23
*/
UINT8 PackManufacDefPacket(UINT8* pInputBuf, UINT16* pItemLen, const UINT8 dstCiId);
/*
* 功能描述：解析互联互通厂商自定义帧
* 参数说明：const UINT8 *pInputData 输入数据指针
* UINT16 *pItemLen 该项数据在输入数据中的长度
* const UINT8 srcCiId 源联锁ID
* 返 回 值：CI_SUCCESS 1 解析成功
* CI_ERROR 0 解析失败
* Created By LQ 2025.05.26
*/
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
+514 -56
View File
@@ -31,6 +31,8 @@
PlatHeartDataStruct RecvHeartDataStru = { 0U }; /*平台心跳帧数据结构*/
PlatGPIODataStruct RecvPlatDataStruGPIO = { 0U };/*平台0x2D帧数据结构 GPIO采集状态*/
PlatGPIOToleranceDataStruct gPlatDataGPIOTolercance = { 0U };/*平台硬件采集故障容忍*/
/*
* 功能描述： 信号机相关码位处理
@@ -61,7 +63,13 @@ UINT8 SignalMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* da
UINT8 detainBtnErrFlag = SIGNAL_ZFS_BTN_ERR_FLAG_NO; /*扣车按钮故障标志*/
UINT8 SignalCrossState = 0U;
UINT8 SigVobcCrossInPhyOccSta = 0U;
UINT8 chDsFlag = SIGNAL_DS_BREAK_YES;
UINT8 CiPattern = 0u;
UINT8 chDsnLinSwitch = 0U;
UINT8 cDevState = 0U;
chDsnLinSwitch = GetCiFunctionSwitchConfig(FUNC_DSN_LINE_SWITCH);
CiPattern = GetLocalCiPattern();
switch (MaskType)
{
case MASK_TYPE_SIGNAL_RED:/*红灯码位*/
@@ -280,9 +288,70 @@ UINT8 SignalMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* da
}
break;
case MASK_TYPE_SIGNAL_BREAK:/*信号机断丝码位*/
if (SIGNAL_SHOWCOLOUR_REDBREAK == GetSignalCurColor(DeviceId))
if ((CI_PATTERN_FULL_ELECTRONIC == CiPattern) && (FUNC_SWITCH_OFF == chDsnLinSwitch))/*全电子联锁*/
{
getState = GetSignalCurColor(DeviceId); /*OC通信中断未设置断丝标志但信号机颜色为红断*/
chDsFlag = GetSignalDsBreakFlag(DeviceId);
if ((SIGNAL_DS_BREAK_YES == chDsFlag)||(SIGNAL_SHOWCOLOUR_REDBREAK == getState))
{
; /*0为断丝*/
}
else
{
SetMaskValue(MaskId, dataBuf);
}
}
else
{
getState = GetSignalCurColor(DeviceId);
if (SIGNAL_SHOWCOLOUR_REDBREAK == getState)
{
; /*0断丝*/
}
else
{
SetMaskValue(MaskId, dataBuf);
}
}
break;
case MASK_TYPE_SIGNAL_GREENBREAK:/*信号机断丝码位*/
chDsFlag = GetSignalGreenDsBreakFlag(DeviceId);
if (SIGNAL_DS_BREAK_YES== chDsFlag)
{
; /*0为断丝*/
}
else
{
SetMaskValue(MaskId, dataBuf);
}
break;
case MASK_TYPE_SIGNAL_YELLOWBREAK:/*信号机断丝码位*/
chDsFlag = GetSignalYellowDsBreakFlag(DeviceId);
if (SIGNAL_DS_BREAK_YES == chDsFlag)
{
; /*0为断丝*/
}
else
{
SetMaskValue(MaskId, dataBuf);
}
break;
case MASK_TYPE_SIGNAL_WHITEBREAK:/*信号机断丝码位*/
chDsFlag = GetSignalWhiteDsBreakFlag(DeviceId);
if (SIGNAL_DS_BREAK_YES == chDsFlag)
{
; /*0为断丝*/
}
else
{
SetMaskValue(MaskId, dataBuf);
}
break;
case MASK_TYPE_SIGNAL_BLUEBREAK:/*信号机断丝码位*/
chDsFlag = GetSignalBlueDsBreakFlag(DeviceId);
if (SIGNAL_DS_BREAK_YES == chDsFlag)
{
; /*0为断丝*/
}
else
{
@@ -402,6 +471,28 @@ UINT8 SignalMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* da
/*码位值发0*/
}
break;
case MASK_TYPE_SIGNAL_DET_CUT_VALID:
cDevState = GetDetCutBtnState(DeviceId);
if (SIGNAL_DETAIN_CUT_VALID_YES == cDevState)
{
SetMaskValue(MaskId, dataBuf); /*扣车旁路按钮有效，码位值发1*/
}
else
{
/*扣车旁路按钮无效，码位值发0*/
}
break;
case MASK_TYPE_SIGNAL_DET_CUT_ERR:
cDevState = GetSignalDetCutBtnErrFlag(DeviceId);
if (SIGNAL_ZFS_BTN_ERR_FLAG_YES == cDevState)
{
SetMaskValue(MaskId, dataBuf); /*扣车旁路按钮故障，码位值发1*/
}
else
{
/*扣车旁路按钮未故障，码位值发0*/
}
break;
default:
returnValue = CI_ERROR;
break;
@@ -648,6 +739,18 @@ UINT8 SwitchMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* da
SetMaskValue(MaskId, dataBuf);
}
break;
case MASK_TYPE_SWITCH_JICHA:
/*道岔静态红闪或动态红闪码位: 兼容28.0.0.14数据结构使用*/
switchCurPosition = GetSwitchJichaState(DeviceId);
if ((SWITCH_POSITION_SUDDEN_JICHA == switchCurPosition)|| (SWITCH_POSITION_DYNAMIC_JICHA == switchCurPosition))
{
; /*有效值为0*/
}
else
{
SetMaskValue(MaskId, dataBuf);
}
break;
default:
returnValue = CI_ERROR;
break;
@@ -695,7 +798,8 @@ UINT8 PhySectionMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8
UINT8 phySecStopSteadyFlag = 0u;
UINT8 chPhyFree = CI_ERROR;
UINT8 gdDLline = 0u; /*线路是否采用轨道电路*/
funcSwitchJumpLockDriveSwitch = GetCiFunctionSwitchConfig(FUNC_SWITCH_JUMPLOCK_DRIVE_SWITCH);
UINT8 cFuncRet = CI_ERROR;
funcSwitchJumpLockDriveSwitch = GetCiFunctionSwitchConfig(FUNC_SWITCH_JUMPLOCK_DRIVE_SWITCH);
/*判断是否采用轨道电路*/
gdDLline = GetCiFunctionSwitchConfig(FUNC_CLD_GD_DIANLU_LINE);
@@ -729,14 +833,22 @@ 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*/
SetMaskValue(MaskId, dataBuf);
cFuncRet = PhySecLockMaskSideProtectCheck(DeviceId); /*侧防条件检查*/
if (CI_SUCCESS== cFuncRet)
{
SetMaskValue(MaskId, dataBuf);
}
else
{
/*侧防条件不满足，发0未锁闭*/
}
}
else
{
@@ -1098,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:
@@ -1276,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;
@@ -1391,6 +1516,8 @@ UINT8 OverlapMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* d
returnValue = CI_ERROR;
}
if (CI_SUCCESS == returnValue)
{
SetMaskValue(MaskId, dataBuf);
@@ -1456,6 +1583,7 @@ UINT8 RouteMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* dat
UINT8 firstLogicOccuState = GetLogSecCurOccupyState(GetRouteInFirstLogSecId(DeviceId));
UINT8 dcQState = GetRouteDCQState(DeviceId);/*进路调车请求状态*/
UINT8 dcTState = GetRouteDCTYState(DeviceId);/*进路调车同意状态*/
UINT8 chDCAgreeBtnErrState = GetRouteDcAgreeButtonErrState(DeviceId);/*进路调车同意按钮故障状态*/
UINT8 RouteCiId = 0u; /*进路所属联锁*/
UINT8 CiTypeOfRoute = 0u; /*当前进路所属联锁类型*/
UINT8 ciTrainTestState = 0u; /*试车线联锁状态*/
@@ -1656,6 +1784,20 @@ UINT8 RouteMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* dat
}
break;
case MASK_TYPE_ROUTE_DC_AGREE_ERR:/*调车同意按钮故障码位*/
{
if (ROUTE_DC_AGREE_BUTTON_OK == chDCAgreeBtnErrState)
{
/*调车同意按钮未故障，置1*/
SetMaskValue(MaskId, dataBuf);
}
else
{
/*调车同意按钮故障，置0*/
}
}
break;
case MASK_TYPE_AUTOROUTE_STATE:/*自动通过进路状态码位*/
if (AUTO_ROUTE_SET_YES == GetAutoRouteSetFlag(DeviceId))
{/*自动通过进路办理标志*/
@@ -1761,6 +1903,9 @@ UINT8 PlatMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* data
UINT8 chPsdVideoQkDriveState = 0U;/*清客确认箱视频清客驱动状态*/
UINT8 chRtnIndicatorDevId = 0U;/*无人折返报警灯设备ID*/
UINT8 chNonRrnAdhesionState = 0U;/*无人折返按钮粘连状态*/
UINT8 cEsbCutErrFlag = ESB_ERROR_FLAG_NO; /*紧急关闭旁路按钮故障标志*/
UINT16 wEsbCollRelayId = 0U; /*ESB采集继电器ID*/
UINT8 cPsdExceptOpenState = 0U; /*屏蔽门异常打开状态*/
chRtnIndicatorDevId = GetIndicatorRelNonReturnId(DeviceId);
virtualZDZFBelongCiId = GetVirtualZDZFBelongCiId();
@@ -1872,6 +2017,29 @@ UINT8 PlatMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* data
/*码位值发0*/
}
break;
case MASK_TYPE_CUT_ESP_FAULT:
cEsbCutErrFlag = GetEsbCutErrFlag(DeviceId);
if (ESB_ERROR_FLAG_YES == cEsbCutErrFlag)
{
SetMaskValue(MaskId, dataBuf);
}
else
{
/*码位值发0*/
}
break;
case MASK_TYPE_ESP_PRESS_STATE:
wEsbCollRelayId = GetEsbRelayId(DeviceId); /*获取ESB采集继电器*/
RelayCollState = GetRelayCollState(wEsbCollRelayId); /*获取ESB采集继电器状态*/
if (RELAY_STATE_UP == RelayCollState)
{
SetMaskValue(MaskId, dataBuf); /*ESB未按下，发1*/
}
else
{
/*ESB按下，发0*/
}
break;
case MASK_TYPE_PSD_STATE_ATS:/*站台屏蔽门状态码位;给ATS*/
/*获取屏蔽门互锁解除状态、门状态*/
mutualLockState = GetPsdMutualLockRemoveState(DeviceId);
@@ -2089,6 +2257,17 @@ UINT8 PlatMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* data
/*视频清客驱动状态为无人或者无效，红灯码位无效*/
}
break;
case MASK_TYPE_PSD_EXCEPT_OPEN: /*站台屏蔽门异常打开状态码位-给ZC/ATS用*/
cPsdExceptOpenState = GePsdExceptOpenState(DeviceId);
if (PSD_EXCEPT_OPEN_NO == cPsdExceptOpenState)
{
SetMaskValue(MaskId, dataBuf); /*PSD未异常打开，码位组1*/
}
else
{
/*PSD异常打开，码位组0*/
}
break;
default:
returnValue = CI_ERROR;
break;
@@ -2623,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)
{
@@ -2639,9 +2821,13 @@ UINT8 OverlapValidMaskCheck(const UINT16 rtOverlapLockedId)
/*保护区段与逻辑区段一致，不检查占压*/
|| (SECTION_OCCUPY_YES == GetPhySecCurMergeState(overlapContainPhySecIdBuf[ii])))
#endif
{
returnValue = CI_ERROR;
break;
{
returnValue = CI_ERROR;
break;
}
else
{
/*不处理*/
}
}
@@ -2664,7 +2850,7 @@ UINT8 OverlapValidMaskCheck(const UINT16 rtOverlapLockedId)
(SWITCH_LOCK_FENGSUO_NO == GetSwitchFLockState(condSwiDataIdBuf[ii].SwitchId)) &&
(condSwiDataIdBuf[ii].SwitchPosition == GetSwitchCurPosition(condSwiDataIdBuf[ii].SwitchId)))
{
/* 保护区段所包含的道岔为：非引导总锁且未封锁且道岔位置正确，才发送码位*/
/* 保护区段所包含的道岔为：非引导总锁且未封锁且道岔位置正确，非连通位置不存在侵入，才发送码位*/
}
else
@@ -2675,6 +2861,10 @@ UINT8 OverlapValidMaskCheck(const UINT16 rtOverlapLockedId)
}
}
}
else
{
/*不处理*/
}
if (CI_SUCCESS == returnValue)
{ /*保护区段关联防护道岔*/
@@ -2686,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
{
@@ -2701,6 +2890,10 @@ UINT8 OverlapValidMaskCheck(const UINT16 rtOverlapLockedId)
}
}
}
else
{
/*不处理*/
}
if (CI_SUCCESS == returnValue)
{
@@ -2714,6 +2907,10 @@ UINT8 OverlapValidMaskCheck(const UINT16 rtOverlapLockedId)
returnValue = CI_ERROR;
}
}
else
{
/*不处理*/
}
if (CI_SUCCESS == returnValue)
{
@@ -2726,6 +2923,10 @@ UINT8 OverlapValidMaskCheck(const UINT16 rtOverlapLockedId)
returnValue = CI_ERROR;
}
}
else
{
/*不处理*/
}
/*检查保护区段关联防淹门状态*/
if (CI_SUCCESS == returnValue)
@@ -2735,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)
{
@@ -2744,7 +2954,53 @@ UINT8 OverlapValidMaskCheck(const UINT16 rtOverlapLockedId)
{
returnValue = CI_ERROR;
}
else
{
/*不处理*/
}
}
else
{
/*不处理*/
}
/*检查照查继电器状态*/
if (CI_SUCCESS == returnValue)
{
returnValue = OverlapZhaoChaRelayCheck(rtOverlapLockedId, ESEND_LEVEL_ZERO);
if (CI_SUCCESS == returnValue)
{
returnValue = CI_SUCCESS;
}
else
{
/*等待本端照查继电器落下或对端检查不过，反馈失败*/
returnValue = CI_ERROR;
}
}
else
{
/*不处理*/
}
if (CI_SUCCESS == returnValue)
{
if (FUNC_SWITCH_ON == cSndSideProFuncSwitch)
{
/*仅在二级侧防开关配置为支持二级侧防时才进行侧防条件检查*/
returnValue = OlapSideProtectConditionCheck(rtOverlapLockedId, 0U, 0U);/*检查保护区段侧防条件*/
}
else
{
/*不处理*/
}
}
else
{
/*不处理*/
}
}
else
{
@@ -2764,18 +3020,29 @@ UINT8 OverlapValidMaskCheck(const UINT16 rtOverlapLockedId)
void PackCiToCimCommData(void)
{
/*变量初始化*/
UINT16 i = 0u;
UINT8 j = 0u;
UINT8 ciToCimDataBuffer[CI_TO_CIM_DATA_LEN_MAX] = { 0u };
UINT16 i = 0U;
UINT8 j = 0U;
UINT8 ciToCimDataBuffer[CI_TO_CIM_DATA_LEN_MAX] = { 0U };
UINT8 deviceSum = 0u; /*通信设备数*/
UINT8* pDeviceIdBuf = NULL; /*设备ID数组*/
UINT8 transmitState = 0u; /*通信状态*/
UINT8 transmitDevSum = 0U;
UINT16 transmitDevIndex = 0U;
UINT8 cLocalWorkMode = 0U; /*工作模式*/
UINT8 cLocalCiId = 0U; /*本控区ID*/
UINT32 dwCurCycNum = 0U; /*当前周期号*/
UINT32 dwRecvCycNum = 0U; /*接收到对方数据时的周期号*/
UINT16 wTempCommVobcNumIndex = 0U; /*通信车数量索引位置*/
UINT8 cCommVobcNum = 0U; /*通信车数量*/
UINT8 cVobcToCiDataSum = 0U;
VobcToCiDataStruct* pstrVobcToCiData = NULL;
UINT32 dwCommBadCycCount = 0U;
ciToCimDataBuffer[i++] = GetLocalRcWorkMode();
ciToCimDataBuffer[i++] =GetSystemParaLocalCiId ();
cLocalWorkMode = GetLocalRcWorkMode();
cLocalCiId = GetSystemParaLocalCiId();
dwCurCycNum = Get2oo2CurCycleNum();
ciToCimDataBuffer[i++] = cLocalWorkMode;
ciToCimDataBuffer[i++] = cLocalCiId;
transmitDevIndex = i;
i++;
@@ -2788,7 +3055,19 @@ void PackCiToCimCommData(void)
transmitState = Get2oo2CiAndOtherSysCommState(CI_SYSTEM_TYPE_ZC, 0U);
ciToCimDataBuffer[i++] = CI_SYSTEM_TYPE_ZC;
ciToCimDataBuffer[i++] = pDeviceIdBuf[0];
ciToCimDataBuffer[i++] = 0U;
/*组ZC通信冗余周期*/
dwRecvCycNum = GetCiTransmitRecvDataCycNum(cLocalCiId, CI_SYSTEM_TYPE_ZC, pDeviceIdBuf[0]);
if ((0U != dwRecvCycNum) && (UINT8_MAX > (dwCurCycNum - dwRecvCycNum)))
{
ciToCimDataBuffer[i] = (UINT8)(dwCurCycNum - dwRecvCycNum); /*组通信设备冗余周期*/
}
else
{
ciToCimDataBuffer[i] = (UINT8)UINT8_MAX; /*组通信设备冗余周期*/
}
i++;
if (TRANSMIT_2OO2_STATE_GOOD == transmitState)
{
ciToCimDataBuffer[i++] = CI_AND_OTHER_TRANSMIT_GOOD;
@@ -2813,7 +3092,19 @@ void PackCiToCimCommData(void)
transmitDevSum++;
ciToCimDataBuffer[i++] = CI_SYSTEM_TYPE_TMC;
ciToCimDataBuffer[i++] = pDeviceIdBuf[0];
ciToCimDataBuffer[i++] = 0U;
/*组TMC通信冗余周期*/
dwRecvCycNum = GetCiTransmitRecvDataCycNum(cLocalCiId, CI_SYSTEM_TYPE_TMC, pDeviceIdBuf[0]);
if ((0U != dwRecvCycNum) && (UINT8_MAX > (dwCurCycNum - dwRecvCycNum)))
{
ciToCimDataBuffer[i] = (UINT8)(dwCurCycNum - dwRecvCycNum); /*组通信设备冗余周期*/
}
else
{
ciToCimDataBuffer[i] = (UINT8)UINT8_MAX; /*组通信设备冗余周期*/
}
i++;
if (TRANSMIT_2OO2_STATE_GOOD == transmitState)
{
ciToCimDataBuffer[i++] = CI_AND_OTHER_TRANSMIT_GOOD;
@@ -2840,8 +3131,19 @@ void PackCiToCimCommData(void)
transmitDevSum++;
ciToCimDataBuffer[i++] = CI_SYSTEM_TYPE_OC;
ciToCimDataBuffer[i++] = pDeviceIdBuf[j];
/*通信良好*/
ciToCimDataBuffer[i++] = 0U;
/*组OC通信冗余周期*/
dwRecvCycNum = GetCiTransmitRecvDataCycNum(cLocalCiId, CI_SYSTEM_TYPE_OC, pDeviceIdBuf[j]);
if ((0U != dwRecvCycNum) && (UINT8_MAX > (dwCurCycNum - dwRecvCycNum)))
{
ciToCimDataBuffer[i] = (UINT8)(dwCurCycNum - dwRecvCycNum); /*组通信设备冗余周期*/
}
else
{
ciToCimDataBuffer[i] = (UINT8)UINT8_MAX; /*组通信设备冗余周期*/
}
i++;
if (TRANSMIT_2OO2_STATE_GOOD == transmitState)
{
ciToCimDataBuffer[i++] = CI_AND_OTHER_TRANSMIT_GOOD;
@@ -2873,8 +3175,19 @@ void PackCiToCimCommData(void)
ciToCimDataBuffer[i++] = CI_SYSTEM_TYPE_PSC;
/*填ID*/
ciToCimDataBuffer[i++] = pDeviceIdBuf[j];
/*通信良好*/
ciToCimDataBuffer[i++] = 0U;
/*组PSC通信冗余周期*/
dwRecvCycNum = GetCiTransmitRecvDataCycNum(cLocalCiId, CI_SYSTEM_TYPE_PSC, pDeviceIdBuf[j]);
if ((0U != dwRecvCycNum) && (UINT8_MAX > (dwCurCycNum - dwRecvCycNum)))
{
ciToCimDataBuffer[i] = (UINT8)(dwCurCycNum - dwRecvCycNum); /*组通信设备冗余周期*/
}
else
{
ciToCimDataBuffer[i] = (UINT8)UINT8_MAX; /*组通信设备冗余周期*/
}
i++;
if (TRANSMIT_2OO2_STATE_GOOD == transmitState)
{
ciToCimDataBuffer[i++] = CI_AND_OTHER_TRANSMIT_GOOD;
@@ -2905,8 +3218,19 @@ void PackCiToCimCommData(void)
transmitDevSum++;
ciToCimDataBuffer[i++] = CI_SYSTEM_TYPE_AXIS;
ciToCimDataBuffer[i++] = pDeviceIdBuf[j];
/*通信良好*/
ciToCimDataBuffer[i++] = 0U;
/*组计轴通信冗余周期*/
dwRecvCycNum = GetCiTransmitRecvDataCycNum(cLocalCiId, CI_SYSTEM_TYPE_AXIS, pDeviceIdBuf[j]);
if ((0U != dwRecvCycNum) && (UINT8_MAX > (dwCurCycNum - dwRecvCycNum)))
{
ciToCimDataBuffer[i] = (UINT8)(dwCurCycNum - dwRecvCycNum); /*组通信设备冗余周期*/
}
else
{
ciToCimDataBuffer[i] = (UINT8)UINT8_MAX; /*组通信设备冗余周期*/
}
i++;
if (TRANSMIT_2OO2_STATE_GOOD == transmitState)
{
ciToCimDataBuffer[i++] = CI_AND_OTHER_TRANSMIT_GOOD;
@@ -2925,22 +3249,32 @@ 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];
ciToCimDataBuffer[i++] = 0U;
/*通信良好*/
/*组相邻RC/CI通信冗余周期*/
dwRecvCycNum = GetCiTransmitRecvDataCycNum(cLocalCiId, CI_SYSTEM_TYPE_RCI, pDeviceIdBuf[j]);
if ((0U != dwRecvCycNum) && (UINT8_MAX > (dwCurCycNum - dwRecvCycNum)))
{
ciToCimDataBuffer[i] = (UINT8)(dwCurCycNum - dwRecvCycNum); /*组通信设备冗余周期*/
}
else
{
ciToCimDataBuffer[i] = (UINT8)UINT8_MAX; /*组通信设备冗余周期*/
}
i++;
if (TRANSMIT_2OO2_STATE_GOOD == transmitState)
{
ciToCimDataBuffer[i++] = CI_AND_OTHER_TRANSMIT_GOOD;
@@ -2971,7 +3305,7 @@ void PackCiToCimCommData(void)
ciToCimDataBuffer[i++] = CI_SYSTEM_TYPE_XIANDI;
ciToCimDataBuffer[i++] = pDeviceIdBuf[j];
ciToCimDataBuffer[i++] = 0U;
ciToCimDataBuffer[i++] = (UINT8)UINT8_MAX;
/*通信良好*/
if (TRANSMIT_2OO2_STATE_GOOD == transmitState)
{
@@ -3004,7 +3338,7 @@ void PackCiToCimCommData(void)
ciToCimDataBuffer[i++] = CI_SYSTEM_TYPE_ATS;
ciToCimDataBuffer[i++] = pDeviceIdBuf[j];
ciToCimDataBuffer[i++] = 0U;
ciToCimDataBuffer[i++] = (UINT8)UINT8_MAX;
/*通信良好*/
if (TRANSMIT_2OO2_STATE_GOOD == transmitState)
{
@@ -3023,6 +3357,42 @@ void PackCiToCimCommData(void)
}
ciToCimDataBuffer[transmitDevIndex] =transmitDevSum;
/*组通信车通信冗余周期*/
wTempCommVobcNumIndex = i; /*通信车数量索引位置*/
i++;
cVobcToCiDataSum = GetVobcToCiSum();
pstrVobcToCiData = GetVobcToCiDataStru();
if ((0U < cVobcToCiDataSum) && (VOBC_TO_CI_SUM_MAX > cVobcToCiDataSum) && (NULL != pstrVobcToCiData))
{
dwCommBadCycCount = GetCiAndVobcTransBadEnsureCnt();
for (j = 0U; j < cVobcToCiDataSum; j++)
{
if (dwCommBadCycCount >= (dwCurCycNum - pstrVobcToCiData[j].ComStartCycle))
{
ciToCimDataBuffer[i] = (UINT8)pstrVobcToCiData[j].VobcId; /*组通信车ID*/
i++;
ciToCimDataBuffer[i] = (UINT8)(dwCurCycNum - pstrVobcToCiData[j].ComStartCycle); /*组通信车冗余周期*/
i++;
cCommVobcNum++;
}
else
{
/*通信超时，继续检查下一个列车的通信周期*/
}
}
}
else
{
cCommVobcNum = 0U;
}
ciToCimDataBuffer[wTempCommVobcNumIndex] = cCommVobcNum; /*组通信车数量*/
debug_infor_printf((const)"\nCIM_SEND_COMM:%d", i);
debug_out_array(0xAA, ciToCimDataBuffer, i);
/*发送CIM*/
(void)DarkInfoPack(CIM_INFO_COMM_STATE, ciToCimDataBuffer, i);
@@ -3623,13 +3993,13 @@ void PackCiToCimVerData(void)
ciToCimDataBuffer[i++] = (UINT8)((pTiocFsVersion[2] << 4U) + pTiocFsVersion[3]);
/*组软件版本号*/
ciToCimDataBuffer[i++] = VER_SOFT_PRODUCT;
ciToCimDataBuffer[i++] = VER_SOFT_MODUAL_APP >> 2U;
ciToCimDataBuffer[i++] = (VER_SOFT_MODUAL_APP << 6U) + (VER_SOFT_MIANVERSION & (UINT8)0x3F);
ciToCimDataBuffer[i++] = VER_SOFT_MODUAL_APP;
ciToCimDataBuffer[i++] = VER_SOFT_MIANVERSION;
ciToCimDataBuffer[i++] = VER_SOFT_SUBVERSION;
/*组集成版本号*/
ciToCimDataBuffer[i++] = VER_INTE_PROJECT;
ciToCimDataBuffer[i++] = VER_INTE_PRODUCT;
ciToCimDataBuffer[i++] = (UINT8)((UINT8)VER_INTE_EXE << 1U) + ((UINT8)VER_INTE_TIME >> 7U);
ciToCimDataBuffer[i++] = VER_INTE_EXE;
ciToCimDataBuffer[i++] = VER_INTE_TIME;
/*发送CIM*/
(void)DarkInfoPack(CIM_INFO_VER_INFO, ciToCimDataBuffer, i);
@@ -3659,14 +4029,20 @@ 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;
UINT32 switchCollTolerateCycNum = 0U;
UINT8 chSwitchBDState = SEND_CIM_COLLTOLERATE_NO;
UINT8 chSignalDsState = 0xFFU;
/*发送道岔数据*/
pSwitchData = GetSwitchData();
deviceNum = GetSwitchCurSum();
ShortToChar(deviceNum, &ciToCimDataBuffer[ii]);/*道岔ID*/
ShortToChar(deviceNum, &ciToCimDataBuffer[ii]);/*道岔数量*/
ii += 2u;
for (jj = 0u; jj < deviceNum; jj++)/*本联锁和相邻联锁发送给本联锁的道岔总数目*/
{
@@ -3680,8 +4056,8 @@ void PackCiToCimDeviceData(void)
ShortToChar(pSwitchData[deviceId].SwitchId, &ciToCimDataBuffer[ii]);/*道岔ID*/
ii += 2u;
chSwitchJichaState = GetSwitchJichaState(deviceId);
chSwitchCurPos = GetSingleSwitchCurPosition(pSwitchData[deviceId].SwitchId);/*道岔状态*/
if (SWITCH_POSITION_DYNAMIC_JICHA == chSwitchJichaState)
{
ciToCimDataBuffer[ii++] = 0x20U;/*道岔动态红闪*/
@@ -3693,7 +4069,7 @@ void PackCiToCimDeviceData(void)
}
else
{
ciToCimDataBuffer[ii++] = pSwitchData[deviceId].SingleSwitchCurPosition;/*单独道岔当前位置*/
ciToCimDataBuffer[ii++] = chSwitchCurPos;/*单独道岔当前位置*/
}
@@ -3702,13 +4078,35 @@ void PackCiToCimDeviceData(void)
ciToCimDataBuffer[ii++] = pSwitchData[deviceId].SwitchByPassState; /*道岔旁路状态*/
ciToCimDataBuffer[ii++] = pSwitchData[deviceId].ConnetSwitchDsState; /*联络线道岔单锁状态*/
switchCollTolerateCycNum = GetSwitchCollTolerateCycNum(pSwitchData[deviceId].SwitchId);
if (0u < switchCollTolerateCycNum)
{
if (SWITCH_POSITION_DINGWEI == chSwitchCurPos)
{
chSwitchBDState = SEND_CIM_COLLTOLERATE_DW;/*是容忍后定位*/
}
else if (SWITCH_POSITION_FANWEI == chSwitchCurPos)
{
chSwitchBDState = SEND_CIM_COLLTOLERATE_FW;/*是容忍后反位*/
}
else
{
chSwitchBDState = SEND_CIM_COLLTOLERATE_NO;
}
}
else
{
chSwitchBDState = SEND_CIM_COLLTOLERATE_NO;/*无波动*/
}
ciToCimDataBuffer[ii++] = chSwitchBDState; /*道岔波动状态*/
}
/*发送信号机数据*/
deviceNum = GetSignalCurSum();
pSignalData = GetSignalData();
ShortToChar(deviceNum, &ciToCimDataBuffer[ii]);/*PSD ID*/
ShortToChar(deviceNum, &ciToCimDataBuffer[ii]);/*信号机数量*/
ii += 2u;
for (jj = 0u; jj < deviceNum; jj++)/*本联锁和相邻联锁发送给本联锁的信号机总数目*/
{
@@ -3722,14 +4120,15 @@ void PackCiToCimDeviceData(void)
ciToCimDataBuffer[ii++] = pSignalData[deviceId].CancelDetainBtnErrFlag;/*取消扣车按钮故障标志*/
ciToCimDataBuffer[ii++] = pSignalData[deviceId].DetainBtnErrFlag;/*扣车按钮故障标志*/
ciToCimDataBuffer[ii++] = pSignalData[deviceId].RealyDetainFlag;/*硬线扣车标志*/
ciToCimDataBuffer[ii++] = pSignalData[deviceId].DsBreakFlag;/*灯丝断丝标志状态*/
chSignalDsState = GetSignalCurBreakFlag(pSignalData[deviceId].SignalId);/*灯丝断丝标志状态*/
ciToCimDataBuffer[ii++] = chSignalDsState;
}
/*************************************发送PSD状态数据********************************************/
/*发送状态数据*/
deviceNum = GetPsdSum();
pPsdData = GetPsdData();
ShortToChar(deviceNum, &ciToCimDataBuffer[ii]);/*PSD ID*/
ShortToChar(deviceNum, &ciToCimDataBuffer[ii]);/*PSD数量*/
ii += 2u;
for (jj = 0u; jj < deviceNum; jj++)/*本联锁和相邻联锁发送给本联锁的Psd总数目*/
{
@@ -3766,13 +4165,15 @@ void PackCiToCimDeviceData(void)
ciToCimDataBuffer[ii++] = pPsdData[deviceId].chVideoQkDriveState; /*视频清客驱动状态*/
ShortToChar(pPsdData[deviceId].wVideoQkRelateVobcId, &ciToCimDataBuffer[ii]);/*视频清客对应列车ID*/
ii += 2u;
ciToCimDataBuffer[ii] = pPsdData[deviceId].cPsdExceptOpenState; /*屏蔽门异常打开状态：0x55-异常打开，0xAA-未异常打开*/
ii++;
}
/*发送状态数据*/
deviceNum = GetEsbSum();
pEsbData = GetEsbData();
ShortToChar(deviceNum, &ciToCimDataBuffer[ii]);/*PSD ID*/
ShortToChar(deviceNum, &ciToCimDataBuffer[ii]);/*ESB数量*/
ii += 2u;
for (jj = 0u; jj < deviceNum; jj++)/*本联锁和相邻联锁发送给本联锁的Psd总数目*/
{
@@ -3796,7 +4197,7 @@ void PackCiToCimDeviceData(void)
/*发送状态数据*/
deviceNum = GetSpksSum();
pSpksData = GetSpksData();
ShortToChar(deviceNum, &ciToCimDataBuffer[ii]);/*PSD ID*/
ShortToChar(deviceNum, &ciToCimDataBuffer[ii]);/*SPKS数量*/
ii += 2u;
for (jj = 0u; jj < deviceNum; jj++)/*本联锁和相邻联锁发送给本联锁的Psd总数目*/
{
@@ -3840,7 +4241,7 @@ void PackCiToCimDeviceData(void)
/*打印洗车机数据*/
pWashMachineData = GetWashMachineData();
deviceNum = GetWashMachineSum();
ShortToChar(deviceNum, &ciToCimDataBuffer[ii]);/*PSD ID*/
ShortToChar(deviceNum, &ciToCimDataBuffer[ii]);/*洗车机数量*/
ii += 2u;
for (jj = 0u; jj < deviceNum; jj++)
{
@@ -3881,7 +4282,8 @@ void PackCiToCimDeviceData(void)
/*打印车库门数据*/
deviceNum = GetGaragedoorSum();
pGrageDoorData = GetGaragedoorData();
ShortToChar(deviceNum, &ciToCimDataBuffer[ii]);/*PSD ID*/
pGrageDoorDataCC = GetGaragedoorDataCC();
ShortToChar(deviceNum, &ciToCimDataBuffer[ii]);/*车库门数量*/
ii += 2u;
for (jj = 0u; jj < deviceNum; jj++)
{
@@ -3894,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; /*车库门旁路状态*/;
@@ -3902,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;
@@ -3914,7 +4316,8 @@ void PackCiToCimDeviceData(void)
/*打印防淹门数据*/
deviceNum = GetFloodGateCurSum();
pFloodGateData = GetFloodGateData();
ShortToChar(deviceNum, &ciToCimDataBuffer[ii]);/*PSD ID*/
pFloodGateDataCC = GetFloodGateDataCC();
ShortToChar(deviceNum, &ciToCimDataBuffer[ii]);/*防淹门数量*/
ii += 2u;
for (jj = 0u; jj < deviceNum; jj++)
{
@@ -3941,13 +4344,15 @@ 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; /*防淹门接近区段是否有非通信车标志*/
}
/*发送CIM*/
debug_infor_printf((const)"\nCIM_SEND_DEVSTATE:%d", ii);
debug_out_array(0xAA, ciToCimDataBuffer, ii);
(void)DarkInfoPack(CIM_INFO_DEVICE_STATE, ciToCimDataBuffer, ii);
}
@@ -4753,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;
@@ -4774,3 +5179,56 @@ void PackCiToCimFlyProtectData(void)
}
/*
* 功能描述： 组包发送CIM双系IO采集不一致信息
* 参数说明： void
* 返回值 ： 无
*/
void PackCiToCimCollDiffData(void)
{
/*变量初始化*/
UINT8 ciToCimDataBuffer[CI_TO_CIM_DATA_LEN_MAX] = { 0U };
UINT16 ii = 0u;
UINT8 jj = 0u;
UINT8 kk = 0u;
UINT8 diffPointSum = 0u;/*每个OC的不一致点位数*/
IODiffDataStruct* tempDiffData = NULL;
tempDiffData = GetIODiffData();/*获取比较不一致的数据*/
ciToCimDataBuffer[ii++] = gDiffDataOcNum;
if (NULL != tempDiffData)
{
for (jj = 0u; jj < OC_SUM_MAX; jj++)
{/*遍历每个OC*/
diffPointSum = tempDiffData[jj].DiffPointNum;/*不一致的点位数*/
if (0u < diffPointSum)
{
ciToCimDataBuffer[ii++] = tempDiffData[jj].OcId;/*OC id*/
ciToCimDataBuffer[ii++] = diffPointSum;
for (kk = 0u; kk < diffPointSum; kk++)
{/*遍历不一致的点位*/
ciToCimDataBuffer[ii++] = tempDiffData[jj].LocalBoardAdd[kk]; /*不一致点位对应的板卡地址*/
ciToCimDataBuffer[ii++] = tempDiffData[jj].OtherBoardAdd[kk]; /*对系的板卡地址*/
ciToCimDataBuffer[ii++] = tempDiffData[jj].TheDiffPoint[kk]; /*点位*/
}
}
else
{/*没有不一致点位，不处理*/
}
}
}
else
{/*不处理*/
}
(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
+8
View File
@@ -61,6 +61,7 @@ extern "C" {
extern PlatHeartDataStruct RecvHeartDataStru;
extern PlatGPIODataStruct RecvPlatDataStruGPIO;
extern PlatGPIOToleranceDataStruct gPlatDataGPIOTolercance;
/*
* 功能描述： 信号机相关码位处理
@@ -380,6 +381,13 @@ void ParasePlantIOData(UINT8* dataBuf);
*/
void PackCiToCimFlyProtectData(void);
/*
* 功能描述： 组包发送CIM双系IO采集不一致信息
* 参数说明： void
* 返回值 ： 无
*/
void PackCiToCimCollDiffData(void);
#ifdef __cplusplus
}
#endif
TSCP/src/APP/ciapp/ParsePack/ParsePackDefine.h
+2 -1
View File
@@ -38,7 +38,7 @@
/*CI 和 CI*/
#define RECVCI_CMD_DATA_STRU_SUM_MAX ((UINT16)100) /*CI接受其他联锁数据结构体数组最大值*/
#define SENDCI_CMD_DATA_STRU_SUM_MAX ((UINT16)100) /*CI发送到其他联锁数据结构体数组最大值*/
#define CI_TO_CI_DATA_LEN_MAX ((UINT16)5000) /*联锁到CI组包数据最大值*/
#define CI_TO_CI_DATA_LEN_MAX ((UINT16)5700) /*联锁到CI组包数据最大值*/
#define CI_TO_CI_AREA_SNOW_SUM_MAX ((UINT8)4) /*相邻RC间发送的区间雨雪数量最大值*/
#define CI_TO_CI_LEAVE_LOGSEC_ROUTE_NUM ((UINT16)100) /*相邻RC间发送的离去逻辑区段检查数量最大值*/
@@ -103,6 +103,7 @@
#define CIM_INFO_SIGNAL_DRIVOUT ((UINT16)0x2010) /*发送CIM信号机驱动超时信息*/
#define CIM_INFO_UNIT_ALARM ((UINT16)0x2011) /*发送CIM执行单元报警*/
#define CIM_INFO_FLYPROTECT_ALARM ((UINT16)0x2012) /*发送CIM飞车宕机报警*/
#define CIM_INFO_IO_COLL_DIFF_ALARM ((UINT16)0x2013) /*发送CIM IO双系采集不一致报警*/
#define CI_AND_OTHER_TRANSMIT_GOOD ((UINT8)0x55) /*CI与其他系统双网通信正常*/
#define CI_AND_OTHER_TRANSMIT_LINK ((UINT8)0x5A) /*CI与其他系统单网通信正常*/
TSCP/src/APP/ciapp/ParsePack/ParsePackGateWayData.c
+1066 -370
View File
File diff suppressed because it is too large Load Diff
TSCP/src/APP/ciapp/ParsePack/ParsePackGateWayData.h
+52 -11
View File
@@ -33,22 +33,24 @@
#define CONFIRM_FIRST_REPEAT ((UINT8)2u) /*重复确认*/
#define CONFIRM_FIRST_TRAINID ((UINT8)3u) /*刷新列车*/
#define CONFIRM_FIRST_LGCID ((UINT8)4u) /*确认逻辑区段*/
#define CONFIRM_FIRST_OTHER_DEV_OP ((UINT8)14U) /*其它操作站正在操作*/
#define CONFIRM_SECOND_SUCCESS ((UINT8)1u) /*二次确认成功*/
#define CONFIRM_SECOND_CRC ((UINT8)2u) /*CRC校验失败*/
#define CONFIRM_SECOND_CRC ((UINT8)2u) /*信息帧校验失败*/
#define CONFIRM_SECOND_TRAINID ((UINT8)3u) /*刷新列车*/
#define CONFIRM_SECOND_LGCID ((UINT8)4u) /*确认逻辑区段*/
#define CONFIRM_SECOND_FIRST ((UINT8)5u) /*首次筛选确认失败*/
#define CONFIRM_SECOND_DIFF ((UINT8)6u) /*二次消息与一次不一致*/
#define CONFIRM_FIRST_NOT_EA ((UINT8)7u) /*列车未进入疏散*/
#define CONFIRM_FIRST_EING ((UINT8)9u) /*列车正在疏散*/
#define CONFIRM_TRAIN_IN_EA ((UINT8)9u) /*列车正在疏散*/
#define CONFIRM_EA_SECOND_CRC ((UINT8)3u) /*CRC失败*/
#define CONFIRM_EA_SECOND_CRC ((UINT8)3u) /*信息帧校验失败*/
#define CONFIRM_EA_SECOND_FIRST ((UINT8)4u) /*未执行一次命令*/
#define CONFIRM_SECOND_NOT_EA ((UINT8)5u) /*列车未进入疏散*/
#define CONFIRM_SECOND_EA_TRAINID ((UINT8)8u) /*与首次列车编号不一致*/
#define CONFIRM_SECOND_TIOC ((UINT8)10u) /*相邻控区通信中断*/
#define CONFIRM_EALINE_DIFFERENT ((UINT8)11U) /*取消防护区域上下行属性与已建立防护区域上下行属性不一致*/
#define CONFIRM_EA_SND_LINE_DIFF ((UINT8)11U) /*取消区间疏散一二次命令的线路上下行属性不一致*/
#define MSG_TYPE_WLB_SET ((UINT8)0xaau) /*全线列车紧急制动设置*/
#define MSG_TYPE_WLB_CANCEL ((UINT8)0x55u) /*全线列车紧急制动取消*/
@@ -63,8 +65,9 @@
#define CONFIRM_WLB_SND_UNKNOWN ((UINT8)0u) /*二次回复未知*/
#define CONFIRM_WLB_SND_SUCCESS ((UINT8)1u) /*二次回复成功*/
#define CONFIRM_WLB_SND_CRC ((UINT8)3u) /*二次回复CRC失败*/
#define CONFIRM_WLB_SND_CRC ((UINT8)3u) /*信息帧校验失败*/
#define CONFIRM_WLB_SND_FIRST ((UINT8)4u) /*二次回复未执行首次确认*/
#define CONFIRM_WLB_SND_INFO_DIFF ((UINT8)8u) /*一二次命令信息不一致*/
#define CONFIRM_DA_FST_UNKNOWN ((UINT8)0u) /*取消脱轨防护区首次回复未知*/
#define CONFIRM_DA_FST_SUCCESS ((UINT8)1u) /*取消脱轨防护区首次回复成功*/
@@ -73,10 +76,11 @@
#define CONFIRM_DA_SND_UNKNOWN ((UINT8)0u) /*取消脱轨防护区再次回复未知*/
#define CONFIRM_DA_SND_SUCCESS ((UINT8)1u) /*取消脱轨防护区再次回复成功*/
#define CONFIRM_DA_SND_CRC ((UINT8)3u) /*取消脱轨防护区再次回复CRC失败*/
#define CONFIRM_DA_SND_CRC ((UINT8)3u) /*取消脱轨防护区再次回复信息帧校验失败*/
#define CONFIRM_DA_SND_FIRST ((UINT8)4u) /*取消脱轨防护区再次回复未执行首次*/
#define CONFIRM_DA_SND_DIFF ((UINT8)8u) /*取消脱轨防护区再次回复列车ID与一次不一致*/
#define CONFIRM_DA_SND_DERAIL ((UINT8)9u) /*取消脱轨防护区再次回复列车当前处于脱轨状态*/
#define CONFIRM_DA_SND_LINE_DIFF ((UINT8)11U) /*取消脱轨防护一二次命令线路属性不一致*/
#define DA_AREA_UP ((UINT8)0x55u) /* 上行区域 */
#define DA_AREA_DOWN ((UINT8)0xaau) /* 下行区域 */
@@ -110,7 +114,7 @@ typedef struct
UINT32 dwCycle; /*首次消息接收周期号*/
UINT8 chAtsId; /*ATS编号*/
UINT8 chStation; /*车站编号*/
UINT8 chIndex; /*操作站编号*/
UINT16 wIndex; /*操作站编号*/
UINT8 chTiocId; /*TIOC编号*/
UINT32 dwTime; /*时间*/
UINT8 chTrainNum; /*列车数量*/
@@ -123,7 +127,7 @@ typedef struct
UINT8 chFlag; /*消息有效性*/
UINT8 chTiocId; /*TIOC编号*/
UINT8 chStation; /*车站编号*/
UINT8 chIndex; /*操作站编号*/
UINT16 wIndex; /*操作站编号*/
UINT32 dwTime; /*时间*/
UINT8 chOpStatus; /*操作结果*/
UINT32 dwCrc32; /*CRC*/
@@ -136,7 +140,7 @@ typedef struct
UINT32 dwCycle; /*首次消息接收周期号*/
UINT8 chAtsId; /*ATS编号*/
UINT8 chStation; /*车站编号*/
UINT8 chIndex; /*操作站编号*/
UINT16 wIndex; /*操作站编号*/
UINT8 chTiocId; /*TIOC编号*/
UINT32 dwTime; /*时间*/
UINT8 chTrainNum; /*列车数量*/
@@ -151,7 +155,7 @@ typedef struct
UINT32 dwCycle; /*消息接收周期号*/
UINT8 chAtsId; /*ATS编号*/
UINT8 chStation; /*车站编号*/
UINT8 chIndex; /*操作站编号*/
UINT16 wIndex; /*操作站编号*/
UINT8 chTiocId; /*TIOC编号*/
UINT32 dwEaTrainId; /*列车互联互通编号*/
UINT32 dwTime; /*时间*/
@@ -167,7 +171,7 @@ typedef struct
UINT32 dwCycle; /*消息接收周期号*/
UINT8 chAtsId; /*ATS编号*/
UINT8 chStation; /*车站编号*/
UINT8 chIndex; /*操作站编号*/
UINT16 wIndex; /*操作站编号*/
UINT8 chTiocId; /*TIOC编号*/
UINT32 dwTime; /*时间*/
UINT8 chType; /*设置/取消*/
@@ -184,7 +188,7 @@ typedef struct
UINT32 dwCycle; /*消息接收周期号*/
UINT8 chAtsId; /*ATS编号*/
UINT8 chStation; /*车站编号*/
UINT8 chIndex; /*操作站编号*/
UINT16 wIndex; /*操作站编号*/
UINT8 chTiocId; /*TIOC编号*/
UINT32 dwDaTrainId; /*列车互联互通编号*/
UINT32 dwTime; /*时间*/
@@ -214,6 +218,11 @@ extern AtsMsgCfmStru g_strAtsDaCfmFst;
extern AtsDaMsgStru g_strAtsDaMsgSnd;
extern AtsMsgCfmStru g_strAtsDaCfmSnd;
extern AtsMsgCfmStru g_strSndAtsCfmFst; /*第二个ATS的远程筛选首次确认*/
extern AtsMsgCfmStru g_strSndAtsEaCfmFst; /*第二个ATS的取消区间疏散首次确认*/
extern AtsMsgCfmStru g_strSndAtsWlbCfmFst; /*第二个ATS的设置/取消全线列车紧急制动首次确认*/
extern AtsMsgCfmStru g_strSndAtsDaCfmFst; /*第二个ATS的取消脱轨防护区首次确认*/
/**
* @brief 获取远程筛选ATS首次消息
@@ -408,4 +417,36 @@ void ClearAtsDaMsgSecond(void);
*/
UINT8 WlbUrgentIdCheck(const UINT8 cDeviceType, const UINT16 wDeviceId);
/**
* @brief 清除第二个ATS的远程筛选一次确认信息
* @param 无
* @return 无
* @note Created By LQ 2025.05.29
*/
void ClearSndAtsScreenFstCfmMsg(void);
/**
* @brief 清除第二个ATS的取消区间疏散一次确认信息
* @param 无
* @return 无
* @note Created By LQ 2025.05.29
*/
void ClearSndAtsEaFstCfmMsg(void);
/**
* @brief 清除第二个ATS的全线紧急制动一次确认信息
* @param 无
* @return 无
* @note Created By LQ 2025.05.29
*/
void ClearSndAtsWlbFstCfmMsg(void);
/**
* @brief 清除第二个ATS的取消脱轨防护一次确认信息
* @param 无
* @return 无
* @note Created By LQ 2025.05.29
*/
void ClearSndAtsDaFstCfmMsg(void);
#endif
TSCP/src/APP/ciapp/ParsePack/ParsePackITEData.c
+20 -10
View File
@@ -68,24 +68,24 @@ UINT8 ParseIteToCiData(const UINT8* dataBuf, const UINT16 dataLength, const UINT
UINT8 ii = 0U;
UINT8 retVal = CI_ERROR;
UINT8 cGalHeadSavedFlag = CI_ERROR;
IteToCiDataStruct parseCheckIte = { 0 };
UINT8 chFind = CI_ERROR;
if (IteToCiSum < ITE_TO_CI_SUM_MAX)
{
(void)CommonMemSet(&(IteToCiDataStru[IteToCiSum]), (UINT32)sizeof(IteToCiDataStruct), 0U, (UINT32)sizeof(IteToCiDataStruct)); /*ÇĺÄڴ棏ˇŔÖšÔŕĘýžÝ*/
retVal = ParseIteToCiDataFrame(dataBuf, dataLength, systemId, &(IteToCiDataStru[IteToCiSum]), &cGalHeadSavedFlag, logId);
retVal = ParseIteToCiDataFrame(dataBuf, dataLength, systemId, &parseCheckIte, &cGalHeadSavedFlag, logId);
if (CI_SUCCESS == retVal)
{
IteToCiSum++;
/*遍历所有通信的ITE，查找ITE通信结构体中是否已存在当前ITE*/
for (ii = 0u; ii < (IteToCiSum - 1U); ii++)
for (ii = 0u; ii < IteToCiSum; ii++)
{
if ((IteToCiDataStru[ii].wIteId == IteToCiDataStru[IteToCiSum - 1U].wIteId) && (IteToCiDataStru[ii].wIteLogId == IteToCiDataStru[IteToCiSum - 1U].wIteLogId))
if ((IteToCiDataStru[ii].wIteId == parseCheckIte.wIteId) && (IteToCiDataStru[ii].wIteLogId == parseCheckIte.wIteLogId))
{
/*目标ITE已存在于通信结构体中，将解析出的数据拷入之前存储的地址*/
(void)CommonMemCpy(&(IteToCiDataStru[ii]), (UINT32)sizeof(IteToCiDataStruct), &(IteToCiDataStru[IteToCiSum - 1U]), (UINT32)sizeof(IteToCiDataStruct));
IteToCiSum--;
(void)CommonMemSet(&(IteToCiDataStru[ii]), (UINT32)sizeof(IteToCiDataStruct), 0U, (UINT32)sizeof(IteToCiDataStruct)); /*清内存，防止脏数据*/
(void)CommonMemCpy(&(IteToCiDataStru[ii]), (UINT32)sizeof(IteToCiDataStruct), &parseCheckIte, (UINT32)sizeof(IteToCiDataStruct));
chFind = CI_SUCCESS;
break;
}
else
@@ -93,6 +93,16 @@ UINT8 ParseIteToCiData(const UINT8* dataBuf, const UINT16 dataLength, const UINT
/*继续查找*/
}
}
if (CI_ERROR == chFind)
{
/*未找到 新建立通信 进行存储*/
(void)CommonMemCpy(&(IteToCiDataStru[IteToCiSum]), (UINT32)sizeof(IteToCiDataStruct), &parseCheckIte, (UINT32)sizeof(IteToCiDataStruct));
IteToCiSum++;
}
else
{
; /*已存在并更新*/
}
}
else
{
@@ -156,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]);
@@ -373,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
+234 -65
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_ERROR == oc2ciParseResult)
if (CI_SUCCESS == oc2ciParseResult)
{
/*解析OC数据错误处理，这个错误已经处理，连续10个周期，会通信中断，导向安全*/
}
else if (CI_CHECK_LEN_ERROR == 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
{
/*其它值，什么也不做*/
/*解析OC数据错误处理，未同步数据，在ProcessOcToCiDat中会通信中断*/
}
}
else
@@ -283,8 +274,17 @@ UINT8 ParseOtherSysToCiData(void)
{
debug_infor_printf((const)"\nATS_RECV:%d", dataLen);
checkResult = ParseAtsOrXianDiToCiDataFrame(data, (UINT16)dataLen);
(void)DarkInfoPack(CIM_INFO_ATS_TO_RCI_DATA, 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
{
@@ -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
{
; /*非主系不组包*/
}
(void)DarkInfoPack(CIM_INFO_ATS_TO_RCI_DATA, data, (UINT16)dataLen);
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,51 +342,108 @@ UINT8 ParseOtherSysToCiData(void)
#endif/*平台打印结束*/
#endif
/*判断是否是同一条线路的联锁，不同线路联锁使用互联互通联锁接口，同一条线路使用自家联锁接口*/
sameLineCi = IsSameLineCI(devId, GetSystemParaLocalCiId());
if (SAME_LINE_YES == sameLineCi) /*同线*/
cLocalDevType = Get2oo2SheBeiType();
cLocalCiId = GetSystemParaLocalCiId();
startLockFlag = GetStartLockFlag();
if (devType == cLocalDevType)
{
startLockFlag = GetStartLockFlag();
if (CI_START_LOCK_NO == startLockFlag)
/*解析RC间或CI间数据*/
/*判断是否是同一条线路的联锁，不同线路联锁使用互联互通联锁接口，同一条线路使用自家联锁接口*/
sameLineCi = IsSameLineCI(devId, cLocalCiId);
if (SAME_LINE_YES == sameLineCi) /*同线*/
{
checkResult = ParseCiToCiDataCheck(data, (UINT16)dataLen, &errorNO_Type); /*相邻CI间数据传输的校验*/
if (CI_SUCCESS != checkResult)
if (CI_START_LOCK_NO == startLockFlag)
{
debug_infor_printf((const)"check parse ci step %d error", errorNO_Type);
}
else
{
checkResult = ParseCiToCiDataFrame(data, (UINT16)dataLen);
if (CI_SUCCESS != checkResult) /*错误*/
checkResult = ParseCiToCiDataCheck(data, (UINT16)dataLen, &errorNO_Type); /*相邻CI间数据传输的校验*/
if (CI_SUCCESS != checkResult)
{
debug_infor_printf((const)"parse ci id %d error", devId);
debug_infor_printf((const)"check parse ci step %d error", errorNO_Type);
}
else
{
checkResult = ParseCiToCiDataFrame(data, (UINT16)dataLen, devId);
if (CI_SUCCESS != checkResult) /*错误*/
{
debug_infor_printf((const)"parse ci id %d error", devId);
}
else
{
}
}
}
else
{
}
}
else if (SAME_LINE_NO == sameLineCi) /*不同线*/
{
checkResult = ParseCiToCiDataFrameHLHT(data, (UINT16)dataLen, devId);
if (CI_ERROR == checkResult) /*错误*/
{
debug_infor_printf((const)"parse hlht ci id %d error", devId);
}
else
{
}
}
else
{
}
}
else if (SAME_LINE_NO == sameLineCi) /*不同线*/
{
checkResult = ParseCiToCiDataFrameHLHT(data, (UINT16)dataLen, devId);
if (CI_ERROR == checkResult) /*错误*/
{
debug_infor_printf((const)"parse hlht ci id %d error", devId);
}
else
{
debug_infor_printf((const)"ci id %d sameLineCi:%d error", devId, sameLineCi);
}
}
else
{
debug_infor_printf((const)"ci id %d sameLineCi:%d error", devId, sameLineCi);
}
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);
checkResult = ParseVobcToCiDataFrame(data, (UINT16)dataLen, devId, srcDevLogicId);
if (CI_ERROR == checkResult) /*错误*/
if (RC_WORK_MODE_TIOC == cWorkMode)
{
debug_infor_printf((const)"parse vobc id %d,logic id %d error", devId, srcDevLogicId);
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;
@@ -1008,11 +1171,15 @@ UINT8 PackCiToOtherSysData(void)
; /*do nothing*/
}
}
else
{
PackCiToVobcFlyProtectData(); /*组飞车特控报文*/
}
#ifdef APPCI_MAINTAIN_DEBUG
#ifdef PLATFORM_2OO2
/*cgh-合并CID-2349-1：*/
/*发送给维护机设备通信状态*/
debug_infor_printf((const)"\nCIM_SEND_COMM\n");
PackCiToCimCommData();
/*发送给维护机信号机断丝状态*/
debug_infor_printf((const)"\nCIM_SEND_DS\n");
@@ -1031,6 +1198,8 @@ UINT8 PackCiToOtherSysData(void)
PackCiToCimDeviceData();
/*发送维护机飞车报警*/
PackCiToCimFlyProtectData();
/*发送维护机IO双系采集不一致报警*/
PackCiToCimCollDiffData();
/*发送给AIM退出运营信息*/
AIMOutput();
/*发送给维护机执行单元报警信息*/
TSCP/src/APP/ciapp/ParsePack/ParsePackOcData.c
+1371 -927
View File
File diff suppressed because it is too large Load Diff
TSCP/src/APP/ciapp/ParsePack/ParsePackOcData.h
+135 -26
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控制命令*/
@@ -69,6 +70,15 @@
#define OC_BOARD_STATE_NORMAL ((UINT8)0) /*oc板卡状态正常*/
#define OC_HAVE_YJK ((UINT8)0x55) /*OC具备应急控*/
#define OC_NOT_YJK ((UINT8)0xAA) /*OC不具备应急控*/
#define OC_CTLMODE_YJK ((UINT8)0x55) /*OC主控状态是应急控*/
#define OC_CTLMODE_JK ((UINT8)0xAA) /*OC主控状态是机控*/
#define CHANGE_JK_COMMAND ((UINT16)0x00AA) /*切换机控申请命令*/
#define CHANGE_NO_COMMAND ((UINT16)0x00FF) /*无切换命令*/
typedef struct s_OcDevState
{
UINT16 OcId;/*oc id*/
@@ -82,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编号*/
@@ -117,6 +141,23 @@ typedef struct s_PlusBox
UINT8 chAsState; /*空开状态 高四位表示1空开状态，第四位表示2空开状态，0x5正常，0xa故障（对于信号机插箱，只有一个空开，高四位有效；对于转辙机插箱高、低四位均有效）*/
}OcPlusBox;
typedef struct s_PsdInfo
{
UINT16 wPsdId; /*编号*/
UINT8 OpenErrState; /*开门故障状态*/
UINT8 CloseErrState; /*关门故障状态*/
UINT8 OpenOrCloseState; /*开关门状态*/
UINT8 InterlockRelState; /*互锁解除状态*/
UINT32 psdFaultQStataOne; /*故障隔离信息高四个字节*/
UINT32 psdFaultQStataTwo; /*故障隔离信息低四个字节*/
UINT32 psdDoorsStateOne; /*每扇屏蔽门的开关状态高四个字节*/
UINT32 psdDoorsStateTwo; /*每扇屏蔽门的开关状态低四个字节*/
UINT32 psdDoorIStateOne; /*每扇屏蔽门的被隔离信息高四个字节*/
UINT32 psdDoorIStateTwo; /*每扇屏蔽门的被隔离信息低四个字节*/
UINT8 psdAlarmState; /*障碍物报警状态*/
}OcToCiPsdInfo;
typedef struct S_OcToCiDataStruct
{
UINT16 OcId; /*OC编号*/
@@ -127,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-双路空开异常*/
@@ -145,11 +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[MAX_OC_DEVICE_PSD_MAX];/*屏蔽门信息*/
UINT8 chHaveYjk; /*是否具备应急控*/
UINT8 chControlMode; /*主控状态*/
UINT8 chOcYjpComm; /*OC与YJP通信状态*/
UINT32 ComStartCycle; /*通信开始周期，使用该周期判断OC与CI中断*/
UINT16 RecvErrorDevTypeCycle; /*收到错误设备类型周期*/
}OcToCiOriginDataStruct;
@@ -159,6 +215,7 @@ typedef struct S_OcBoardDataStruct1
UINT8 BoardAddress; /*板子地址*/
UINT8 BoardState; /*板卡状态，0x55：正常，0xaa：故障*/
UINT8 PosValueBuf[OC_COLL_BOARD_POS_NUM]; /*板子各位置数据*/
UINT32 TolerateCycNum[OC_COLL_BOARD_POS_NUM];/*板子各位置容忍周期*/
}CollBoardData;
typedef struct S_OcCollBoardDataStruct
@@ -266,6 +323,14 @@ extern OcFaultStateStruct m_OcFaultState[OC_SUM_MAX];/*CI
#define LEN_OC_UP_TO_END_200(startIndex,gdBoardNo,diBoardNo,doBoardNo,siBoardNo,soBoardNo,sorBoardNo,pbNo,swapSysBoardNo) LEN_OC_UP_TO_SWAPSYSBOARD_NO_200((startIndex),(gdBoardNo),(diBoardNo),(doBoardNo),(siBoardNo),(soBoardNo),(sorBoardNo),(pbNo))+(swapSysBoardNo)
/*OC-300接口使用*/
/*计算OC从开始到结束，参数devNo:设备数量，参数gdBoardNo：轨道板数量, 参数diBoardNo：di板数量 参数doBoardNo：do板数量 参数siBoardNo:si板数量 参数soBoardNo:so板数量 参数sorBoardNo:sor板数量 参数pbNo:执行电插箱数量 参数swapSysBoardNo:切系板卡数量*/
#define LEN_OC_UP_TO_PSD_NO_300(startIndex,gdBoardNo,diBoardNo,doBoardNo,siBoardNo,soBoardNo, sorBoardNo,pbNo, swapSysBoardNo) LEN_OC_UP_TO_SWAPSYSBOARD_NO_200((startIndex),(gdBoardNo),(diBoardNo),(doBoardNo),(siBoardNo),(soBoardNo),(sorBoardNo), (pbNo))+(swapSysBoardNo)+1U
/*计算OC从开始到结束，参数devNo:设备数量，参数gdBoardNo：轨道板数量, 参数diBoardNo：di板数量 参数doBoardNo：do板数量 参数siBoardNo:si板数量 参数soBoardNo:so板数量 参数sorBoardNo:sor板数量 参数pbNo:执行电插箱数量 参数swapSysBoardNo:切系板卡数量 参数psdNo:屏蔽门数量*/
#define LEN_OC_UP_TO_END_300(startIndex,gdBoardNo,diBoardNo,doBoardNo,siBoardNo,soBoardNo,sorBoardNo,pbNo,swapSysBoardNo, psdNo) LEN_OC_UP_TO_PSD_NO_300((startIndex),(gdBoardNo),(diBoardNo),(doBoardNo),(siBoardNo),(soBoardNo),(sorBoardNo),(pbNo), swapSysBoardNo)+33*(psdNo) + (0u == psdNo?0u:4u)
#ifdef __cplusplus
extern "C" {
@@ -314,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设备
@@ -382,7 +447,7 @@ INT16 GetIndexBySwitchId(UINT16 swId);
*/
INT16 GetIndexByGdId(UINT16 gdId);
#if 0
/*
* 功能描述： 校验Oc到CI的单帧数据长度合法性
* 参数说明： const UINT8* dataBuf, 数据缓冲区
@@ -399,6 +464,50 @@ UINT8 CheckOc2CiDataLenValid(const UINT8* dataBuf, const UINT16 totalLength);
*
*/
void ResetOcOriginalState(const UINT8 ocId);
#endif
/*
* 功能描述：为指定OC->CI的结构设置缺省值(安全值)
* 参数说明： index:OC id对应的数组下标
* 返回值 ： 0:失败
* 1:成功
*/
void SetOcToCiDefaultDataStru(UINT8 index);
/*
* 功能描述：获取要发送给OC的控权切换命令
* 参数说明： 无
* 返回值 ： 控权切换命令
*/
UINT16 GetKqChangeCommand(void);
/*
* 功能描述： 获取点位采集容忍起始周期
* 参数说明： const UINT16 switchId, 道岔ID
* 返回值 ： UINT32 采集容忍起始周期
*/
UINT32 GetPointTolerateCycNum(const UINT16 ocId, const UINT8 boardNum, const UINT8 pointNum);
/*
* 功能描述： 设置道岔采集容忍起始周期
* 参数说明： const UINT16 ocId, OC ID
* const UINT8 boardNum, 板卡ID
* const UINT8 pointNum，点位ID
* const UINT32 cycNum 周期号
* 返回值 ： 无
*/
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
+184 -40
View File
@@ -75,23 +75,23 @@ static UINT8 ParseSnowData(UINT8* dataBuf, UINT16 dataLen);
static UINT8 ParseWLSData(UINT8* dataBuf, UINT16 dataLen);
/*
* 功能描述：解析ITE全线切除信息
* 功能描述：解析ITE切除信息
* 参数说明：const UINT8* dataBuf, 数据缓冲区
* const UINT16 dataLength, 数据长度
* 返 回 值：CI_ERROR 0 数据解析失败
* CI_SUCCESS 1 数据解析成功
* Created By LQ 2024.07.12
*/
static UINT8 ParseIteLineCutData(UINT8* dataBuf, UINT16 dataLen);
static UINT8 ParseIteCutData(UINT8* dataBuf, UINT16 dataLen);
/*
* 功能描述：组ITE全线切除信息
* 功能描述：组ITE切除信息
* 参数说明：UINT8* TiocToTmcDataBuffer 数据地址
* 返 回 值：0 组数据失败
* 其他 整包数据长度
* Created By LQ 2024.07.12
*/
static UINT16 PackToTmcIteLineCutData(UINT8* TiocToTmcDataBuffer);
static UINT16 PackToTmcIteCutData(UINT8* TiocToTmcDataBuffer);
/*
* 功能描述：解析全线通信车信息
@@ -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();
/* 清空接收数据 */
@@ -253,9 +253,9 @@ UINT8 ParseTmcToTiocDataFrame(UINT8* dataBuf, UINT16 dataLength, UINT8 systemId)
break;
case TMC_TO_TIOC_ITELINECUT_MSG:
/* 解析ITE全线切除信息 */
retVal = ParseIteLineCutData(&dataBuf[ii], wMsgCheckLen);
retVal = ParseIteCutData(&dataBuf[ii], wMsgCheckLen);
dwParseStep |= 0x00010U;
debug_infor_printf((const)"\n ParseIteLineCutData:%d", retVal);
debug_infor_printf((const)"\n ParseIteCutData:%d", retVal);
break;
case TMC_TO_TIOC_LINECT_MSG:
/* 解析全线通信车信息 */
@@ -652,11 +652,12 @@ static UINT8 ParseSnowData(UINT8* dataBuf, UINT16 dataLen)
UINT8 cRetVal = CI_ERROR;
UINT16 ii = 0u;
UINT8 jj = 0U;
UINT32 dwPlatFormId = 0U; /*站台互联互通ID*/
UINT16 wPlatFormId = 0U; /*站台互联互通ID*/
UINT8 cPlatFormNum = 0U; /*站台数量*/
UINT8 cTmepNum = 0U;
UINT8 cPlatFormBelongCiId = 0U; /*站台关联Link所属CI*/
UINT8 cLocalCiId = 0U;
UINT8 cSnowLevel = 0U; /*湿轨等级*/
if (NULL == dataBuf)
{
@@ -667,14 +668,23 @@ static UINT8 ParseSnowData(UINT8* dataBuf, UINT16 dataLen)
cRetVal = CI_SUCCESS;
}
/*全线雨雪模式命令有效标志位 */
/*解析全线雨雪/湿轨信息*/
if (CI_SUCCESS == cRetVal)
{
g_TmcToTiocDataStru.cSnowValidFlag = dataBuf[ii];
g_TmcToTiocDataStru.cSnowValidFlag = dataBuf[ii]; /*全线雨雪/湿轨模式*/
ii++;
if ((CI_ALL_SNOW_VALID == g_TmcToTiocDataStru.cSnowValidFlag) || (CI_ALL_SNOW_UNVALID == g_TmcToTiocDataStru.cSnowValidFlag))
{
cRetVal = CI_SUCCESS;
cSnowLevel = dataBuf[ii]; /*全线湿轨等级*/
ii++;
if ((CI_SNOW_LEVEL_DEFAULT == cSnowLevel) || (CI_SNOW_LEVEL_ONE == cSnowLevel) || (CI_SNOW_LEVEL_TWO == cSnowLevel))
{
g_TmcToTiocDataStru.cSnowLevel = cSnowLevel;
}
else
{
cRetVal = CI_ERROR;
}
}
else
{
@@ -693,17 +703,21 @@ static UINT8 ParseSnowData(UINT8* dataBuf, UINT16 dataLen)
cLocalCiId = GetSystemParaLocalCiId();
for (jj = 0U; jj < cPlatFormNum; jj++)
{
dwPlatFormId = LongFromChar(&dataBuf[ii]); /*解析区间雨雪站台ID*/
ii += 4U;
wPlatFormId = ShortFromChar(&dataBuf[ii]); /*解析区间雨雪站台ID*/
ii += 2U;
cSnowLevel = dataBuf[ii]; /*区间湿轨等级*/
ii++;
cPlatFormBelongCiId = GetAreaSnowPlatFormBelongCiId((UINT16)dwPlatFormId); /*获取区间雨雪站台所属控区*/
if (0U < dwPlatFormId)
if ((0U < wPlatFormId) && (UINT16_MAX > wPlatFormId)
&& (CI_SNOW_LEVEL_DEFAULT == cSnowLevel) || (CI_SNOW_LEVEL_ONE == cSnowLevel) || (CI_SNOW_LEVEL_TWO == cSnowLevel))
{
cPlatFormBelongCiId = GetAreaSnowPlatFormBelongCiId(wPlatFormId); /*获取区间雨雪站台所属控区*/
if ((cLocalCiId == cPlatFormBelongCiId) && (0U != cLocalCiId))
{
if (LOCAL_AREA_SNOW_SUM_MAX > cTmepNum)
{
g_TmcToTiocDataStru.szAreaSnowPlatFormId[cTmepNum] = dwPlatFormId;
g_TmcToTiocDataStru.szAreaSnowInfo[cTmepNum].wAreaId = wPlatFormId;
g_TmcToTiocDataStru.szAreaSnowInfo[cTmepNum].cAreaSnowLevel = cSnowLevel;
cTmepNum++;
}
else
@@ -719,7 +733,7 @@ static UINT8 ParseSnowData(UINT8* dataBuf, UINT16 dataLen)
}
else
{
/*雨雪模式编号ID非法*/
/*雨雪模式编号ID非法或区间湿轨等级非法，返回失败*/
cRetVal = CI_ERROR;
}
}
@@ -860,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);
@@ -908,7 +922,7 @@ UINT8 PackTiocToTmcData( UINT8 deviceId)
wMagLen = PackToTmcWLScreenData(&TiocToTmcDataBuffer[ii]);
break;
case 3u:
wMagLen = PackToTmcIteLineCutData(&TiocToTmcDataBuffer[ii]);
wMagLen = PackToTmcIteCutData(&TiocToTmcDataBuffer[ii]);
break;
case 4U:
wMagLen = PackToTmcLineCTData(&TiocToTmcDataBuffer[ii]);
@@ -1169,7 +1183,8 @@ static UINT16 PackToTmcSnowData(UINT8* TiocToTmcDataBuffer)
UINT8 snowModelFlag = 0u; /*全线雨雪模式标志*/
UINT8 cFunRetVal = CI_ERROR;
UINT8 cAreaSnowNum = 0U; /*本地区间雨雪站台数量*/
UINT32* pAreaSnowId = NULL; /*本地区间雨雪站台ID数组*/
AreaSnowInfoStruct* pAreaSnowData = NULL; /*本地区间雨雪信息数组*/
UINT8 cSnowLevel = 0U; /*湿轨级别*/
snowModelFlag = GetAllSnowModel();
@@ -1191,14 +1206,30 @@ static UINT16 PackToTmcSnowData(UINT8* TiocToTmcDataBuffer)
{
TiocToTmcDataBuffer[ii++] = 0x55u; /* 全线雨雪模式命令有效 */
}
else
else if (CI_ALL_SNOW_UNVALID == snowModelFlag)
{
TiocToTmcDataBuffer[ii++] = 0xAAu; /* 全线雨雪模式命令无效 */
}
else
{
cFunRetVal = CI_ERROR; /*全线湿轨状态错误，返回失败*/
}
cSnowLevel = GetAllSnowLevel();
if ((CI_SNOW_LEVEL_DEFAULT == cSnowLevel) || (CI_SNOW_LEVEL_ONE == cSnowLevel)|| (CI_SNOW_LEVEL_TWO == cSnowLevel))
{
TiocToTmcDataBuffer[ii] = cSnowLevel; /*组全线湿轨级别*/
ii++;
}
else
{
cFunRetVal = CI_ERROR; /*全线湿轨级别错误，返回失败*/
}
/*组区间雨雪状态信息*/
cAreaSnowNum = GetLocalAreaSnowNum();
pAreaSnowId = GetLocalAreaSnowId();
pAreaSnowData = GetLocalAreaSnow();
if (LOCAL_AREA_SNOW_SUM_MAX >= cAreaSnowNum)
{
@@ -1207,8 +1238,19 @@ static UINT16 PackToTmcSnowData(UINT8* TiocToTmcDataBuffer)
for (jj = 0U; jj < cAreaSnowNum; jj++)
{
LongToChar(pAreaSnowId[jj], &TiocToTmcDataBuffer[ii]); /*组区间雨雪站台ID*/
ii += 4U;
if ((0U < pAreaSnowData[jj].wAreaId) && (UINT16_MAX > pAreaSnowData[jj].wAreaId)
&& ((CI_SNOW_LEVEL_DEFAULT == pAreaSnowData[jj].cAreaSnowLevel) || (CI_SNOW_LEVEL_ONE == pAreaSnowData[jj].cAreaSnowLevel) || (CI_SNOW_LEVEL_TWO == pAreaSnowData[jj].cAreaSnowLevel)))
{
ShortToChar(pAreaSnowData[jj].wAreaId, &TiocToTmcDataBuffer[ii]); /*组区间ID*/
ii += 2U;
TiocToTmcDataBuffer[ii] = pAreaSnowData[jj].cAreaSnowLevel; /*组区间湿轨级别*/
ii++;
}
else
{
cFunRetVal = CI_ERROR; /*区间信息非法，返回失败*/
break;
}
}
}
else
@@ -1328,21 +1370,28 @@ static UINT16 PackToTmcWLScreenData(UINT8* TiocToTmcDataBuffer)
}
/*
* 功能描述：解析ITE全线切除信息
* 功能描述：解析ITE切除信息
* 参数说明：const UINT8* dataBuf, 数据缓冲区
* const UINT16 dataLength, 数据长度
* 返 回 值：CI_ERROR 0 数据解析失败
* CI_SUCCESS 1 数据解析成功
* Created By LQ 2024.07.12
*/
static UINT8 ParseIteLineCutData(UINT8* dataBuf, UINT16 dataLen)
static UINT8 ParseIteCutData(UINT8* dataBuf, UINT16 dataLen)
{
UINT8 cRetVal = CI_ERROR;
UINT8 cIteLineCutState = 0U; /*ITE全线切除状态*/
UINT16 ii = 0u;
UINT16 ii = 0U;
UINT8 jj = 0U;
UINT16 wPlatFormId = 0U; /*站台ID*/
UINT8 cPlatFormNum = 0U; /*站台数量*/
UINT8 cTmepNum = 0U;
UINT8 cPlatFormBelongCiId = 0U; /*站台关联Link所属CI*/
UINT8 cLocalCiId = 0U;
if (NULL != dataBuf)
{
cRetVal = CI_SUCCESS;
cIteLineCutState = dataBuf[ii];
ii++;
@@ -1350,20 +1399,83 @@ static UINT8 ParseIteLineCutData(UINT8* dataBuf, UINT16 dataLen)
{
g_TmcToTiocDataStru.cIteLineCutState = cIteLineCutState; /*存储解析的ITE全线切除状态*/
if (dataLen == ii)
/*解析区间ITE切除信息*/
cPlatFormNum = dataBuf[ii]; /*解析区间ITE切除数量*/
ii++;
if (ALL_AREA_SNOW_SUM_MAX >= cPlatFormNum)
{
cRetVal = CI_SUCCESS;
cLocalCiId = GetSystemParaLocalCiId();
for (jj = 0U; jj < cPlatFormNum; jj++)
{
wPlatFormId = ShortFromChar(&dataBuf[ii]); /*解析区间ID*/
ii += 2U;
if ((0U < wPlatFormId) && (UINT16_MAX > wPlatFormId))
{
cPlatFormBelongCiId = GetAreaSnowPlatFormBelongCiId(wPlatFormId); /*获取区间所属控区*/
if ((cLocalCiId == cPlatFormBelongCiId) && (0U != cLocalCiId))
{
if (LOCAL_AREA_SNOW_SUM_MAX > cTmepNum)
{
g_TmcToTiocDataStru.szAreaIteCutId[cTmepNum] = wPlatFormId;
cTmepNum++;
}
else
{
debug_infor_printf((const)"ParseIteCutData: Local AreaIteCutNum Exceed Max\n");
cRetVal = CI_ERROR; /*本控区区间ITE切除数量超限，停止遍历，返回失败*/
}
}
else
{
/*非本控区，不保存*/
}
}
else
{
debug_infor_printf((const)"ParseIteCutData: Area Id Error\n");
cRetVal = CI_ERROR; /*区间编号ID非法*/
}
if (CI_SUCCESS != cRetVal)
{
break; /*解析失败，停止解析*/
}
else
{
/*继续解析*/
}
}
g_TmcToTiocDataStru.cAreaIteCutNum = cTmepNum;
if (CI_SUCCESS == cRetVal)
{
if (dataLen == ii)
{
/*解析成功*/
}
else
{
debug_infor_printf((const)"ParseIteCutData: MsgLen Is Error\n");
cRetVal = CI_ERROR; /*长度不一致，返回失败*/
}
}
else
{
/*不处理*/
}
}
else
{
debug_infor_printf((const)"ParseIteLineCutData Error: MsgLen Is Error\n");
cRetVal = CI_ERROR; /*长度不一致，返回失败*/
debug_infor_printf((const)"ParseIteCutData: TMC AreaIteCutNum Exceed Max\n");
cRetVal = CI_ERROR; /*区间ITE切除数量超限，返回失败*/
}
}
else
{
cRetVal = CI_ERROR; /*状态非法，返回失败*/
debug_infor_printf((const)"ParseIteLineCutData Error: IteLineCutState[0x%2x] Is Invalid\n", cIteLineCutState);
debug_infor_printf((const)"ParseIteCutData: IteLineCutState[0x%2x] Is Invalid\n", cIteLineCutState);
}
}
else
@@ -1375,22 +1487,27 @@ static UINT8 ParseIteLineCutData(UINT8* dataBuf, UINT16 dataLen)
}
/*
* 功能描述：组ITE全线切除信息
* 功能描述：组ITE切除信息
* 参数说明：UINT8* TiocToTmcDataBuffer 数据地址
* 返 回 值：0 组数据失败
* 其他 整包数据长度
* Created By LQ 2024.07.12
*/
static UINT16 PackToTmcIteLineCutData(UINT8* TiocToTmcDataBuffer)
static UINT16 PackToTmcIteCutData(UINT8* TiocToTmcDataBuffer)
{
UINT16 ii = 0U;
UINT16 wMagLen = 0U;
UINT16 wMagLenIndex = 0U;
UINT16 wRetVal = 0U;
UINT8 cIteLineCutState = 0U; /*ITE全线切除状态*/
UINT8 cAreaIteCutNum = 0U; /*本地区间ITE切除数量*/
UINT16* pAreaIteCutId = NULL; /*本地区间ITE切除ID数组*/
UINT8 jj = 0U;
UINT8 cFunRetVal = CI_ERROR;
if (NULL != TiocToTmcDataBuffer)
{
cFunRetVal = CI_SUCCESS;
wMagLenIndex = ii;
ii += 2U;
@@ -1410,15 +1527,42 @@ static UINT16 PackToTmcIteLineCutData(UINT8* TiocToTmcDataBuffer)
{
TiocToTmcDataBuffer[ii] = CI_ITE_LINE_CUT_DEFAULT; /* 组默认值 */
}
ii++;
/* 填写数据长度 */
wMagLen = ii - wMagLenIndex;
wRetVal = wMagLen;
wMagLen -= 2U;
/*组区间ITE切除信息*/
cAreaIteCutNum = GetLocalAreaIteCutNum();
pAreaIteCutId = GetLocalAreaIteCutId();
ShortToChar(wMagLen, &TiocToTmcDataBuffer[wMagLenIndex]);
if ((LOCAL_AREA_SNOW_SUM_MAX >= cAreaIteCutNum) && (NULL != pAreaIteCutId))
{
TiocToTmcDataBuffer[ii] = cAreaIteCutNum; /*组区间ITE切除数量*/
ii++;
for (jj = 0U; jj < cAreaIteCutNum; jj++)
{
ShortToChar(pAreaIteCutId[jj], &TiocToTmcDataBuffer[ii]); /*组区间ID*/
ii += 2U;
}
}
else
{
debug_infor_printf((const)"PackToTmcIteCutData: Local AreaIteCutNum Exceed Max\n");
cFunRetVal = CI_ERROR; /*区间ITE切除数量超限，返回失败*/
}
if (CI_SUCCESS == cFunRetVal)
{
/* 填写数据长度 */
wMagLen = ii - wMagLenIndex;
wRetVal = wMagLen;
wMagLen -= 2U;
ShortToChar(wMagLen, &TiocToTmcDataBuffer[wMagLenIndex]);
}
else
{
/*组包失败，返回0*/
}
}
else
{
TSCP/src/APP/ciapp/ParsePack/ParsePackTmcData.h
+4 -2
View File
@@ -57,15 +57,17 @@ typedef struct S_TsrInputInfoStruct
TsrDataStruct szTsrInfo[TSR_MAX_SUM]; /* 限速信息 */
} TsrInputInfoStruct;
/*TMC->TIOC缓冲数据*/
typedef struct S_TmcToTiocDataStruct
{
TsrInputInfoStruct tsrInputInfoStru;/* 临时限速信息 */
UINT8 cSnowValidFlag; /* 全线雨雪模式命令有效标志 */
UINT8 cSnowLevel; /*全线湿轨等级*/
UINT8 cAreaSnowPlatFormNum; /*区间雨雪站台数量*/
UINT32 szAreaSnowPlatFormId[LOCAL_AREA_SNOW_SUM_MAX]; /*区间雨雪站台ID数组*/
AreaSnowInfoStruct szAreaSnowInfo[LOCAL_AREA_SNOW_SUM_MAX]; /*区间雨雪数组*/
UINT8 cIteLineCutState; /* ITE全线切除状态 */
UINT8 cAreaIteCutNum; /*区间ITE切除数量*/
UINT16 szAreaIteCutId[ALL_AREA_SNOW_SUM_MAX]; /*区间ITE切除ID数组*/
UINT8 cLineCtNum; /*全线通信车数量*/
UINT16 szLineCtId[TRAIN_SUM_MAX]; /*全线通信车ID数组*/
} TmcToTiocDataStruct;

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