数据提交

2.离线系拉低主地/备地为离线地
3.修复仲裁IP配置错误

TSCP/Makefile

@@ -109,12 +109,15 @@ INCLUDES += -I ./src/APP \
             -I ./src/MSCP/SFM \
             -I ./src/MSCP/PFM \
             -I ./src/MSCP_CFG \
-            
+            -I ./src/MSCP/Area\
+            -I ./src/MSCP/OFM\
+            -I ./src/MSCP/Arb
 #LIBS += -L/path/to/my/lib/$(PLATFORM)/usr/lib -lmylib
 #LIBS += -L../mylib/$(OUTPUT_DIR) -lmylib
 
 #Compiler flags for build profiles
-CCFLAGS_release += -O0
+CCFLAGS_release += -O2
+#CCFLAGS_release += -g -O2 
 CCFLAGS_debug += -g -O0 -fno-builtin
 CCFLAGS_coverage += -g -O0 -ftest-coverage -fprofile-arcs -nopipe -Wc,-auxbase-strip,$@
 LDFLAGS_coverage += -ftest-coverage -fprofile-arcs

TSCP/src/APP/APP_API.c

@@ -226,7 +226,7 @@ void APP_API_Data_Init()
 	UINT8 funcRetVal = 0U;
 	funcRetVal = dquGetFSVersion(DataPath, szFSFILEVersionFS);
 
-#if (kPLATFORM==kVXWORKS)
+#if 0//(kPLATFORM==kVXWORKS)
 	/*文件配置*/
 	STRU_APP_CFG_T AppCfgInterface = {
 			.FS_NAME = "RCI.FS",			/**< FS文件名称 */
@@ -238,16 +238,16 @@ void APP_API_Data_Init()
 			.M_InnetSafe_Enable = 0x55,	/**< 内网安全通信功能开关 */
 			.M_InnetRaw_Enable = 0xAA,	/**< 内网透传通信功能开关 */
 			.M_OutnetSafe_Enable = 0x55,/**< 外网安全通信功能开关 */
-			.M_OutnetRaw_Enable = 0xAA,	/**< 外网透传通信功能开关 */
+			.M_OutnetRaw_Enable = 0x55,	/**< 外网透传通信功能开关 */
-			.M_CpuUsageGet_Enable = 0x55,/**< 获取cpu使用率功能开关 */
+			.M_CpuUsageGet_Enable = 0xAA,/**< 获取cpu使用率功能开关 */
 			.M_RemoteUpdate_Enable = 0x55,/**< 远程部署内网安全通信功能开关 */
 			.ID_Maintenance = DEVICE_TYPE_AIM,
 			.Start_Path = "/emmc1",	/**< 程序启动路径 */
 			.reboot_replycount = 10,	/**< 重启确认报文回复次数 */
-			.M_AutoReboot_Count = 3,	/**< 自动重启次数 */
+			.M_AutoReboot_Count = 0,	/**< 自动重启次数 */
 			.M_AutoClear_Days = 1,		/**< 连续运行多久清空宕机次数的天数 */
 			.CPU[0].IP_2oo2 = "192.168.0.11",     /**< 2oo2通信IP */
-			.CPU[0].IP_2x2 = "192.168.1.62",       /**< 2x2通信IP */
+//			.CPU[0].IP_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 */
 			/*适用透传通道-选配*/
@@ -257,7 +257,7 @@ void APP_API_Data_Init()
 			.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_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 */
 			/*适用透传通道-选配*/
@@ -267,7 +267,7 @@ void APP_API_Data_Init()
 			.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_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 */
 			/*适用透传通道-选配*/
@@ -277,7 +277,7 @@ void APP_API_Data_Init()
 			.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_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 */
 			/*适用透传通道-选配*/
@@ -338,6 +338,204 @@ void APP_API_Data_Init()
 			.INNET_COM_CFG[0].Port_Safe_P = 55003,  /**< 紫网安全端口 */
 	};
 	MSCP_Set_APP_ConfigData(&AppCfgInterface);
+#else
+	    /*↑↑用户初始化代码↑↑*/
+	    /*↓↓基本数据初始化配置示例↓↓*/
+	    STRU_APP_CFG_T AppCfgInterface = {
+	            .FS_NAME = "RCI.FS",         /**< FS文件名称 */
+	            .APP_NAME = "RCOCI",           /**< 应用文件名称 */
+	            .CYC_TIME = 300,            /**< 系统周期（ms） */
+	            .app_num = 1,               /**< app任务数1-4 */
+	            .M_2oo2_Enable = 0x55,      /**< 2oo2功能开关，开0x55，关0xAA */
+	            .M_2x2_Enable = 0x55,       /**< 2x2功能开关，开0x55，关0xAA*/
+	            .M_4x2_Enable = 0x55,       /**< 4x2功能开关，开0x55，关0xAA*/
+				.M_Arb_Enable = 0x55,		/**< 仲裁功能开关 */
+	            .M_2x2_Com_Cfg = 0x00,      /**< 2x2通信功能配置，串口0x00，网卡0x01*/
+	            .M_InnetSafe_Enable = 0x55, /**< 内网安全通信功能开关，开0x55，关0xAA */
+	            .M_InnetRaw_Enable = 0x55,  /**< 内网透传通信功能开关，开0x55，关0xAA */
+	            .M_OutnetSafe_Enable = 0x55,/**< 外网安全通信功能开关，开0x55，关0xAA */
+	            .M_OutnetRaw_Enable = 0x55, /**< 外网透传通信功能开关，开0x55，关0xAA */
+	            .M_CpuUsageGet_Enable = 0xAA,/**< 外网透传通信功能开关，开0x55，关0xAA */
+	            .M_RemoteUpdate_Enable = 0xAA,/**< 远程部署内网安全通信功能开关，开0x55，关0xAA */
+	            .ID_Maintenance = 0xF800,   /**< 设置维护终端ID */
+	            .Start_Path = "./emmc1",    /**< 程序启动路径 */
+	            .reboot_replycount = 10,    /**< 重启确认报文回复次数 */
+	            .M_AutoReboot_Count = 0,    /**< 自动重启次数 */
+	            .M_AutoClear_Days = 1,      /**< 连续运行多久清空宕机次数的天数 */
+	            /*CPU1-1 IP配置*/
+	            .CPU[0].IP_2oo2 = "192.168.0.11",     /**< 2oo2通信IP */
+	            .CPU[0].IP_4x2 = "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_Area = "10.3.1.61",      /**< 4x2通信IP */
+	            .CPU[0].IP_Sync_Time_A = "192.168.1.62",   /**< 时间同步网络A网IP */
+	            .CPU[0].IP_Sync_Time_B = "10.3.1.61",      /**< 时间同步网络B网IP */
+	            /*CPU1-1适用透传通道-选配*/
+	            .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,   /**< 暗文日志记录发送端口 */
+	            /*CPU1-2 IP配置*/
+	            .CPU[1].IP_2oo2 = "192.168.0.12",     /**< 2oo2通信IP */
+	            .CPU[1].IP_4x2 = "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_Area = "10.3.1.63",      /**< 4x2通信IP */
+	            .CPU[1].IP_Sync_Time_A = "192.168.2.62",   /**< 时间同步网络A网IP */
+	            .CPU[1].IP_Sync_Time_B = "10.3.1.63",      /**< 时间同步网络B网IP */
+	            /*CPU1-2适用透传通道-选配*/
+	            .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,   /**< 暗文日志记录发送端口 */
+	            /*CPU2-1 IP配置*/
+	            .CPU[2].IP_2oo2 = "192.168.0.11",     /**< 2oo2通信IP */
+	            .CPU[2].IP_4x2 = "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_Area = "10.4.1.62",      /**< 4x2通信IP */
+	            .CPU[2].IP_Sync_Time_A = "192.168.1.64",   /**< 时间同步网络A网IP */
+	            .CPU[2].IP_Sync_Time_B = "10.4.1.62",      /**< 时间同步网络B网IP */
+	            /*CPU2-1适用透传通道-选配*/
+	            .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,   /**< 暗文日志记录发送端口 */
+	            /*CPU2-2 IP配置*/
+	            .CPU[3].IP_2oo2 = "192.168.0.12",     /**< 2oo2通信IP */
+	            .CPU[3].IP_4x2 = "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_Area = "10.4.1.64",      /**< 4x2通信IP */
+	            .CPU[3].IP_Sync_Time_A = "192.168.2.64",   /**< 时间同步网络A网IP */
+	            .CPU[3].IP_Sync_Time_B = "10.4.1.64",      /**< 时间同步网络B网IP */
+	            /*CPU2-2适用透传通道-选配*/
+	            .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,   /**< 暗文日志记录发送端口 */
+	            /*CPU3-1 IP配置*/
+	            .CPU[4].IP_2oo2 = "192.168.0.11",     /**< 2oo2通信IP */
+	            .CPU[4].IP_4x2 = "192.168.1.162",       /**< 2x2通信IP */
+	            .CPU[4].IP_Out = "192.168.1.162",       /**< 外网通信IP */
+	            .CPU[4].IP_Maintain = "192.168.146.201",  /**< 维护通信IP */
+	            .CPU[4].IP_Area = "10.3.1.161",      /**< 4x2通信IP */
+	            .CPU[4].IP_Sync_Time_A = "192.168.1.162",   /**< 时间同步网络A网IP */
+	            .CPU[4].IP_Sync_Time_B = "10.3.1.161",      /**< 时间同步网络B网IP */
+	            /*CPU3-1适用透传通道-选配*/
+	            .CPU[4].IP_Com = "192.168.1.162",       /**< 通用通信IP */
+	            .CPU[4].IP_Com_Extend = "192.168.1.162",/**< 通用通信扩展IP */
+	            .CPU[4].Logger_PortBase = 55031,         /**< 明文日志记录发送端口 */
+	            .CPU[4].Logger_PortCiphertext = 55002,   /**< 暗文日志记录发送端口 */
+	            /*CPU3-2 IP配置*/
+	            .CPU[5].IP_2oo2 = "192.168.0.12",     /**< 2oo2通信IP */
+	            .CPU[5].IP_4x2 = "192.168.2.162",       /**< 2x2通信IP */
+	            .CPU[5].IP_Out = "192.168.2.162",       /**< 外网通信IP */
+	            .CPU[5].IP_Maintain = "192.168.18.202",  /**< 维护通信IP */
+	            .CPU[5].IP_Area = "10.3.1.163",      /**< 4x2通信IP */
+	            .CPU[5].IP_Sync_Time_A = "192.168.2.162",   /**< 时间同步网络A网IP */
+	            .CPU[5].IP_Sync_Time_B = "10.3.1.163",      /**< 时间同步网络B网IP */
+	            /*CPU3-2适用透传通道-选配*/
+	            .CPU[5].IP_Com = "192.168.2.162",       /**< 通用通信IP */
+	            .CPU[5].IP_Com_Extend = "192.168.2.162",/**< 通用通信扩展IP */
+	            .CPU[5].Logger_PortBase = 55032,         /**< 明文日志记录发送端口 */
+	            .CPU[5].Logger_PortCiphertext = 55002,   /**< 暗文日志记录发送端口 */
+	            /*CPU4-1 IP配置*/
+	            .CPU[6].IP_2oo2 = "192.168.0.11",     /**< 2oo2通信IP */
+	            .CPU[6].IP_4x2 = "192.168.1.164",       /**< 2x2通信IP */
+	            .CPU[6].IP_Out = "192.168.1.164",       /**< 外网通信IP */
+	            .CPU[6].IP_Maintain = "192.168.146.203",  /**< 维护通信IP */
+				.CPU[6].IP_Area = "10.4.1.162",      /**< 4x2通信IP */
+	            .CPU[6].IP_Sync_Time_A = "192.168.1.164",   /**< 时间同步网络A网IP */
+	            .CPU[6].IP_Sync_Time_B = "10.4.1.162",      /**< 时间同步网络B网IP */
+	            /*CPU4-1适用透传通道-选配*/
+	            .CPU[6].IP_Com = "192.168.1.164",       /**< 通用通信IP */
+	            .CPU[6].IP_Com_Extend = "192.168.1.164",/**< 通用通信扩展IP */
+	            .CPU[6].Logger_PortBase = 55041,         /**< 明文日志记录发送端口 */
+	            .CPU[6].Logger_PortCiphertext = 55002,   /**< 暗文日志记录发送端口 */
+	            /*CPU4-2 IP配置*/
+	            .CPU[7].IP_2oo2 = "192.168.0.12",     /**< 2oo2通信IP */
+	            .CPU[7].IP_4x2 = "192.168.2.164",       /**< 2x2通信IP */
+	            .CPU[7].IP_Out = "192.168.2.164",       /**< 外网通信IP */
+	            .CPU[7].IP_Maintain = "192.168.18.204",  /**< 维护通信IP */
+	            .CPU[7].IP_Area = "10.4.1.164",      /**< 4x2通信IP */
+	            .CPU[7].IP_Sync_Time_A = "192.168.2.164",   /**< 时间同步网络A网IP */
+	            .CPU[7].IP_Sync_Time_B = "10.4.1.164",      /**< 时间同步网络B网IP */
+	            /*CPU4-2适用透传通道-选配*/
+	            .CPU[7].IP_Com = "192.168.2.164",       /**< 通用通信IP */
+	            .CPU[7].IP_Com_Extend = "192.168.2.164",/**< 通用通信扩展IP */
+	            .CPU[7].Logger_PortBase = 55042,         /**< 明文日志记录发送端口 */
+	            .CPU[7].Logger_PortCiphertext = 55002,   /**< 暗文日志记录发送端口 */
+	            /*组播地址配置*/
+	            .IP_Area_G_Multicast = "239.0.0.10",       /**< 组播通信IP */
+				.IP_Area_P_Multicast = "239.0.0.20",       /**< 组播通信IP */
+				.Multicast_Flag = 1u,                      /**< 单播：0  组播：1 */
+	            /*通用端口配置，平台固定通信端口禁止使用:51001、51002、51003、52001、52002、52003*/
+	            .Port_Outnet_Safe = 54001,       /**< 外网安全通信端口 */
+	            .Port_Innet_Safe = 53001,        /**< 内网安全通信端口 */
+	            .Port_Outnet_Raw = 54002,        /**< 外网透明传输端口 */
+	            .Port_Remote_Update = 50000,     /**< 远程部署通信端口 */
+	            /*透传配置-选配*/
+	            .Port_Innet_Raw_Num = 1,     /**< 内网透传端口数量0-9 */
+	            .Port_Innet_Raw_Extend_Num = 1, /**< 内网透传扩展端口数量0-9 */
+	            /*透传通道-Number 1根据数量两个通道的数量，按序号累加以此类推（0-17）*/
+	            .Innet_Raw_Parameter[0].Port_Innet_Raw = 3956,           /**< 内网透明传输端口 */
+	            .Innet_Raw_Parameter[0].Port_Type_Enable = RAW_COM_UDP,  /**< 内网透明UDP传输模式 */
+	            .Innet_Raw_Parameter[0].Server_DevId = 0,                /**< 服务端设备类型和id */
+	            .Innet_Raw_Parameter[0].TIME_STAMP_ENABLE = 0XAA,        /**< 2取2乘时间戳使能开关 */
+	            .Innet_Raw_Parameter[0].INNET_2oo2_RAW = 0X55,           /**< 透传通道2取开关，开0x55，关0xAA  */
+	            .Innet_Raw_Parameter[0].INNET_2x2_RAW = 0XAA,            /**< 透传通道2乘开关，开0x55，关0xAA */
+	            .Innet_Raw_Parameter[0].IP_InnetRaw_maddr = "224.0.0.31",/**< 内网透传的组播IP */
+	            /*扩展通道-Number 1 根据数量两个通道的数量，按序号累加以此类推（0-17）*/
+	            .Innet_Raw_Parameter[1].Port_Innet_Raw = 3957,           /**< 内网透明传输端口 */
+	            .Innet_Raw_Parameter[1].Port_Type_Enable = RAW_COM_BROADCAST, /**< 内网透明广播传输模式 */
+	            .Innet_Raw_Parameter[1].Server_DevId = 0,                /**< 服务端设备类型和id */
+	            .Innet_Raw_Parameter[1].TIME_STAMP_ENABLE = 0XAA,        /**< 2取2乘时间戳使能开关 */
+	            .Innet_Raw_Parameter[1].INNET_2oo2_RAW = 0X55,           /**< 透传通道2取开关，开0x55，关0xAA  */
+	            .Innet_Raw_Parameter[1].INNET_2x2_RAW = 0XAA,            /**< 透传通道2乘开关，开0x55，关0xAA  */
+	            .Innet_Raw_Parameter[1].IP_InnetRaw_maddr = "224.0.0.32",/**< 内网透传的组播IP */
+	            /*外网通信配置-红网*/
+	            .OutNetRed.CC_G_IP_A = "192.168.1.60",     /**< 通控的内网IP */
+	            .OutNetRed.CC_P_IP_A = "192.168.2.60",     /**< 通控的内网IP */
+	            .OutNetRed.CC_G_IP_B = "192.168.1.160",     /**< 通控的内网IP */
+	            .OutNetRed.CC_P_IP_B = "192.168.2.160",     /**< 通控的内网IP */
+	            .OutNetRed.EXTEND_G_IP_A = "192.168.1.70", /**< 扩展板卡的内网IP */
+	            .OutNetRed.EXTEND_P_IP_A = "192.168.2.70", /**< 扩展板卡的内网IP */
+	            .OutNetRed.EXTEND_G_IP_B = "192.168.1.71", /**< 扩展板卡的内网IP */
+	            .OutNetRed.EXTEND_P_IP_B = "192.168.2.71", /**< 扩展板卡的内网IP */
+	            .OutNetRed.OutnetSafe_Port = 54001,      /**< 外网安全通信端口 */
+	            .OutNetRed.OutnetRaw_Port = 54002,       /**< 外网透传通信端口 */
+	            /*外网通信配置-蓝网*/
+	            .OutNetBlue.CC_G_IP_A = "192.168.1.61",     /**< 通控的内网IP */
+	            .OutNetBlue.CC_P_IP_A = "192.168.2.61",     /**< 通控的内网IP */
+	            .OutNetBlue.CC_G_IP_B = "192.168.1.161",     /**< 通控的内网IP */
+	            .OutNetBlue.CC_P_IP_B = "192.168.2.161",     /**< 通控的内网IP */
+	            .OutNetBlue.EXTEND_G_IP_A = "192.168.1.170", /**< 扩展板卡的内网IP */
+	            .OutNetBlue.EXTEND_P_IP_A = "192.168.2.170", /**< 扩展板卡的内网IP */
+	            .OutNetBlue.EXTEND_G_IP_B = "192.168.1.171", /**< 扩展板卡的内网IP */
+	            .OutNetBlue.EXTEND_P_IP_B = "192.168.2.171", /**< 扩展板卡的内网IP */
+	            .OutNetBlue.OutnetSafe_Port = 54001,      /**< 外网安全通信端口 */
+	            .OutNetBlue.OutnetRaw_Port = 54002,       /**< 外网透传通信端口 */
+	            /*日志记录目标设备IP配置*/
+	            .Logger_G_IP_A = "192.168.146.100",         /**< A地绿网日志记录IP */
+	            .Logger_P_IP_A = "192.168.18.100",          /**< A地紫网日志记录IP */
+				.Logger_G_IP_B = "192.168.146.200",			/**< B地绿网日志记录IP */
+				.Logger_P_IP_B = "192.168.18.200",			/**< B地绿网日志记录IP */
+	            /*内网通信设备注册最大支持0-255，注意：IP配置方式比较特别，与前面配置区分*/
+	            .INNET_COM_NUM = 1,                     /**< 内网通信设备数量0-255 */
+	            .INNET_COM_CFG[0].InnetID = 0xF800,     /**< 内网通信ID */
+	            .INNET_COM_CFG[0].IP_G = (CM_UINT32)inet_addr("172.25.0.100"),/**< 绿网IP*/
+	            .INNET_COM_CFG[0].Port_Raw_G = 55003,   /**< 绿网透传端口 */
+	            .INNET_COM_CFG[0].Port_Safe_G = 55004,  /**< 绿网安全端口 */
+	            .INNET_COM_CFG[0].IP_P = (CM_UINT32)inet_addr("172.17.0.100"),/**< 紫网IP */
+	            .INNET_COM_CFG[0].Port_Raw_P = 55003,   /**< 紫网透传端口 */
+	            .INNET_COM_CFG[0].Port_Safe_P = 55004,  /**< 紫网安全端口 */
+				/*第三方仲裁通信配置*/
+				.Arb_CFG.IP_Arb_G = "10.3.1.200",
+				.Arb_CFG.IP_Arb_P = "10.4.1.200",
+	    };
+	    /*调用参数设置初始化接口*/
+	    MSCP_Set_APP_ConfigData(&AppCfgInterface);
 #endif
 
 	/*组FS版本号*/
@@ -349,10 +547,10 @@ void APP_API_Data_Init()
 
 	/*组软件版本号*/
 	ii = 0U;
-	appVersBuffer[ii++] = VER_INTE_PROJECT;
+	appVersBuffer[ii++] = VER_SOFT_PRODUCT;
-	appVersBuffer[ii++] = VER_INTE_PRODUCT >> 2U;
+	appVersBuffer[ii++] = VER_SOFT_MODUAL_APP >> 2U;
-	appVersBuffer[ii++] = (VER_INTE_PRODUCT << 6U) + (VER_INTE_EXE & (UINT8)0x3F);
+	appVersBuffer[ii++] = (VER_SOFT_MODUAL_APP << 6U) + (VER_SOFT_MIANVERSION & (UINT8)0x3F);
-	appVersBuffer[ii++] = VER_INTE_TIME;
+	appVersBuffer[ii++] = VER_SOFT_SUBVERSION;
 	/*设置平台调用获取外网信息函数*/
 	MSCP_SetSrcId(SetOutNetPara);
 	/*设置内网参数*/
@@ -366,16 +564,16 @@ void APP_API_Data_Init()
 * - ENUM_CM_TRUE 成功
 * - ENUM_CM_FALSE 失败（平台立即宕机）
 * @details
-* 当本系热备状态为：ENUM_2x2_SHUTDOWN，时
+* 当本系热备状态为：ENUM_4x2_SHUTDOWN，时
 * 本函数不执行；
-* 当本系热备状态为：ENUM_2x2_OFFLINE，ENUM_2x2_PRE_MASTER，ENUM_2x2_SLAVE，时
+* 当本系热备状态为：ENUM_4x2_OFFLINE，ENUM_4x2_PRE_MASTER，ENUM_4x2_SLAVE，时
 * 本函数被周期执行，但 ENUM_MSG_OUTNET_SAFE 报文不会真实输出；
-* 当本系热备状态为：ENUM_2x2_MASTER，时
+* 当本系热备状态为：ENUM_4x2_MASTER，时
 * 本函数被周期执行，并且所有输出信息被真实输出。
 */
 ENUM_CM_RETURN APP_API_MainFunc(void)
 {
-	ENUM_CM_RETURN retVal = ENUM_CM_NULL;
+	ENUM_CM_RETURN retVal = ENUM_CM_FALSE;
 	CM_UINT64 startCycTick = 0u;
 	CM_UINT64 endCycTick = 0u;
 
@@ -393,8 +591,9 @@ ENUM_CM_RETURN APP_API_MainFunc(void)
 	endCycTick = MSCP_GetTick();
 	debug_infor_printf("app proc end at %llu us,used %d us\n", endCycTick, (CM_INT32)((endCycTick - startCycTick) / 1000));
 
-	gFollowDataLen = GetCiAppData(gFollowData);
+	//gFollowDataLen = GetCiAppData(gFollowData);
-	MSCP_SetFollowData(gFollowData, gFollowDataLen);
+	memset(gFollowData,0x02,1024*500);
+	MSCP_SetFollowData(gFollowData, 1024*500);
 
 	return retVal;
 }
@@ -405,11 +604,11 @@ ENUM_CM_RETURN APP_API_MainFunc(void)
 * - ENUM_CM_TRUE 成功
 * - ENUM_CM_FALSE 失败（平台立即宕机）
 * @details
-* 当本系热备状态为：ENUM_2x2_SHUTDOWN，时
+* 当本系热备状态为：ENUM_4x2_SHUTDOWN，时
 * 本函数不执行；
-* 当本系热备状态为：ENUM_2x2_OFFLINE，ENUM_2x2_PRE_MASTER，ENUM_2x2_SLAVE，时
+* 当本系热备状态为：ENUM_4x2_OFFLINE，ENUM_4x2_PRE_MASTER，ENUM_4x2_SLAVE，时
 * 本函数被周期执行，但 ENUM_MSG_OUTNET_SAFE 报文不会真实输出；
-* 当本系热备状态为：ENUM_2x2_MASTER，时
+* 当本系热备状态为：ENUM_4x2_MASTER，时
 * 本函数被周期执行，并且所有输出信息被真实输出。
 */
 ENUM_CM_RETURN APP_API_MainFunc2(void)
@@ -425,11 +624,11 @@ ENUM_CM_RETURN APP_API_MainFunc2(void)
 * - ENUM_CM_TRUE 成功
 * - ENUM_CM_FALSE 失败（平台立即宕机）
 * @details
-* 当本系热备状态为：ENUM_2x2_SHUTDOWN，时
+* 当本系热备状态为：ENUM_4x2_SHUTDOWN，时
 * 本函数不执行；
-* 当本系热备状态为：ENUM_2x2_OFFLINE，ENUM_2x2_PRE_MASTER，ENUM_2x2_SLAVE，时
+* 当本系热备状态为：ENUM_4x2_OFFLINE，ENUM_4x2_PRE_MASTER，ENUM_4x2_SLAVE，时
 * 本函数被周期执行，但 ENUM_MSG_OUTNET_SAFE 报文不会真实输出；
-* 当本系热备状态为：ENUM_2x2_MASTER，时
+* 当本系热备状态为：ENUM_4x2_MASTER，时
 * 本函数被周期执行，并且所有输出信息被真实输出。
 */
 ENUM_CM_RETURN APP_API_MainFunc3(void)
@@ -452,11 +651,11 @@ ENUM_CM_RETURN APP_API_MainFunc4(void)
 * - ENUM_CM_TRUE 成功
 * - ENUM_CM_FALSE 失败（平台立即宕机）
 * @details
-* 当本系热备状态为：ENUM_2x2_SHUTDOWN，时
+* 当本系热备状态为：ENUM_4x2_SHUTDOWN，时
 * 本函数不执行；
-* 当本系热备状态为：ENUM_2x2_OFFLINE，ENUM_2x2_PRE_MASTER，ENUM_2x2_SLAVE，时
+* 当本系热备状态为：ENUM_4x2_OFFLINE，ENUM_4x2_PRE_MASTER，ENUM_4x2_SLAVE，时
 * 本函数被周期执行，但 ENUM_MSG_OUTNET_SAFE 报文不会真实输出；
-* 当本系热备状态为：ENUM_2x2_MASTER，时
+* 当本系热备状态为：ENUM_4x2_MASTER，时
 * 本函数被周期执行，并且所有输出信息被真实输出。
 */
 ENUM_CM_RETURN APP_API_MainFunc5(void)
@@ -494,7 +693,7 @@ ENUM_CM_RETURN APP_API_InputFunc(void)
 * - ENUM_CM_TRUE 成功
 * - ENUM_CM_FALSE 失败（平台立即宕机）
 * @details
-* 当本系热备状态为：ENUM_2x2_OFFLINE，ENUM_2x2_SLAVE，且收到了邻系正确的跟随数据时
+* 当本系热备状态为：ENUM_4x2_OFFLINE，ENUM_4x2_SLAVE，且收到了邻系正确的跟随数据时
 * 本函数将在APP_API_MainFunc()之前执行；
 * 否则，本函数不执行。
 * 应用跟随数据的最大长度不得超过1024*1000字节
@@ -505,7 +704,8 @@ ENUM_CM_RETURN APP_API_FollowUp(IN const CM_UINT8 Data[MSCP_FOLLOW_BUFF_SIZE], I
 	ENUM_CM_RETURN retVal = ENUM_CM_FALSE;
 	UINT8 setRtn = 0u;
 
-	setRtn = SetCiAppData(Data, Len);
+	//setRtn = SetCiAppData(Data, Len);
+	setRtn = 1;
 	if (1u == setRtn)
 	{
 		retVal = ENUM_CM_TRUE;
@@ -559,10 +759,6 @@ 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;
@@ -624,8 +820,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((void*)&pOutBuf[tempLen], objLen * sizeof(UINT16), \
+				CommonMemCpy(&pOutBuf[tempLen], objLen * sizeof(UINT16), \
-					(const void*)gTransmitObjTypeId, objLen * sizeof(UINT16));
+					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));

TSCP/src/APP/APP_API.h

@@ -40,11 +40,11 @@ extern "C" {
     * - ENUM_CM_TRUE 成功
     * - ENUM_CM_FALSE 失败（平台立即宕机）
     * @note
-    * 当本系热备状态为：ENUM_2x2_SHUTDOWN，时
+    * 当本系热备状态为：ENUM_4x2_SHUTDOWN，时
     * 本函数不执行；
-    * 当本系热备状态为：ENUM_2x2_OFFLINE，ENUM_2x2_PRE_MASTER，ENUM_2x2_SLAVE，时
+    * 当本系热备状态为：ENUM_4x2_OFFLINE，ENUM_4x2_PRE_MASTER，ENUM_4x2_SLAVE，时
     * 本函数被周期执行，但 ENUM_MSG_OUTNET_SAFE 报文不会真实输出；
-    * 当本系热备状态为：ENUM_2x2_MASTER，时
+    * 当本系热备状态为：ENUM_4x2_MASTER，时
     * 本函数被周期执行，并且所有输出信息被真实输出。
     */
     ENUM_CM_RETURN APP_API_MainFunc(void);

TSCP/src/APP/PU13_integration_config/ci_integrate_config.h

@@ -30,6 +30,6 @@
 #define VER_INTE_PROJECT            220  /*项目编号*/
 #define VER_INTE_PRODUCT            40   /*产品编号*/
 #define VER_INTE_EXE                1   /*可执行编号*/
-#define VER_INTE_TIME               101   /*集成次数编号*/
+#define VER_INTE_TIME               77   /*集成次数编号*/
 
 #endif/*endif of #define _CI_INTEGRATE_CONFIG_H*/

TSCP/src/APP/ciapp/2oo2/2oo2DataTransferManage.c

@@ -688,9 +688,6 @@ UINT32 GetCiAppData(UINT8 *pCiAppDataPointer)
 	UINT32 curIndex = 0u;         /*记录移动下标*/
 	UINT32 curResult = 0u;        /*拷贝结构中有效的id数据*/
 	UINT8 ii= 0u;
-	UINT32 crcIndex = 0u;		  /*用于计算CRC的下标*/
-	UINT32 crcLength = 0u;		  /*用于计算CRC的长度*/
-	UINT32 crcResult = 0u;		  /*用于存放CRC值*/
 	
 	if (NULL != pCiAppDataPointer)
 	{
@@ -731,20 +728,10 @@ UINT32 GetCiAppData(UINT8 *pCiAppDataPointer)
 		(void)memcpy(pCiAppDataPointer + curIndex, &g_AllSnowModel, sizeof(UINT8));
 		curIndex = curIndex + (UINT32)sizeof(UINT8);
 
-		/*拷贝全线湿轨级别*/
-		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT8), (const void*)(&g_AllSnowLevel), (UINT32)sizeof(UINT8));
-		curIndex = curIndex + (UINT32)sizeof(UINT8);
-
 		/*拷贝应急盘继电器有效周期*/
 		(void)memcpy(pCiAppDataPointer + curIndex, &JkjRelayValidCycNum, sizeof(UINT32));
 	    curIndex = curIndex + (UINT32)sizeof(UINT32);
 
-		/*计算一次CRC*/
-		crcLength = curIndex - crcIndex;
-		crcResult = Tioc_CommonCrc32(pCiAppDataPointer + crcIndex, crcLength);
-		debug_infor_printf((const)"2oo2 AllSignalBrightFlag-JkjRelayValidCycNum CRC:%x, Length:%d\n", crcResult, crcLength);
-		crcIndex = curIndex;
-
 		/*拷贝总复位状态有效周期*/
 		(void)memcpy(pCiAppDataPointer + curIndex, &ZFWValidCycNum, sizeof(UINT32));
 		curIndex = curIndex + (UINT32)sizeof(UINT32);
@@ -785,12 +772,6 @@ UINT32 GetCiAppData(UINT8 *pCiAppDataPointer)
         (void)memcpy(pCiAppDataPointer + curIndex, &SendCiCmdDataStruCurSum, sizeof(UINT16));
 	    curIndex = curIndex + (UINT32)sizeof(UINT16);
 
-		/*计算一次CRC*/
-		crcLength = curIndex - crcIndex;
-		crcResult = Tioc_CommonCrc32(pCiAppDataPointer + crcIndex, crcLength);
-		debug_infor_printf((const)"2oo2 ZFWValidCycNum-SendCiCmdDataStruCurSum CRC:%x, Length:%d\n", crcResult, crcLength);
-		crcIndex = curIndex;
-
         /*拷贝与联锁通信的Vobc数目*/
         (void)memcpy(pCiAppDataPointer + curIndex, &VobcToCiSum, sizeof(UINT8));
 	    curIndex = curIndex + (UINT32)sizeof(UINT8);
@@ -836,12 +817,6 @@ UINT32 GetCiAppData(UINT8 *pCiAppDataPointer)
         curResult = CopyValidGetDataStru(pCiAppDataPointer + curIndex, (void *)SwitchDataStru, SWITCH_SUM_MAX, (UINT16)sizeof(SwitchDataStruct));
 		curIndex = curIndex + curResult;
 
-		/*计算一次CRC*/
-		crcLength = curIndex - crcIndex;
-		crcResult = Tioc_CommonCrc32(pCiAppDataPointer + crcIndex, crcLength);
-		debug_infor_printf((const)"2oo2 VobcToCiSum-SwitchDataStru CRC:%x, Length:%d\n", crcResult, crcLength);
-		crcIndex = curIndex;
-
         /*拷贝计轴区段数据结构体*/
         curResult = CopyValidGetDataStru(pCiAppDataPointer + curIndex, (void *)AxisSectionDataStru, AXIS_SECTION_SUM_MAX, (UINT16)sizeof(AxisSectionDataStruct));
 		curIndex = curIndex + curResult;
@@ -882,12 +857,6 @@ UINT32 GetCiAppData(UINT8 *pCiAppDataPointer)
         (void)memcpy(pCiAppDataPointer + curIndex, NonRouteDataStruArr, NONROUTE_ID_NUM_MAX*sizeof(NonRouteDataStruct));
 	    curIndex = curIndex + (UINT32)(NONROUTE_ID_NUM_MAX*sizeof(NonRouteDataStruct));
 
-		/*计算一次CRC*/
-		crcLength = curIndex - crcIndex;
-		crcResult = Tioc_CommonCrc32(pCiAppDataPointer + crcIndex, crcLength);
-		debug_infor_printf((const)"2oo2 AxisSectionDataStru-NonRouteDataStruArr CRC:%x, Length:%d\n", crcResult, crcLength);
-		crcIndex = curIndex;
-
         /*拷贝指示器数据结构体*/
         (void)memcpy(pCiAppDataPointer + curIndex, IndicatorDataStru, (INDICATOR_SUM_MAX)*sizeof(IndicatorDataStruct));
 	    curIndex = curIndex + (UINT32)((INDICATOR_SUM_MAX)*sizeof(IndicatorDataStruct));
@@ -939,12 +908,6 @@ UINT32 GetCiAppData(UINT8 *pCiAppDataPointer)
         (void)memcpy(pCiAppDataPointer + curIndex, AllAutoReturnDataStru, (ALL_AUTO_RETURN_SUM_MAX)*sizeof(AllAutoReturnDataStruct));
 	    curIndex = curIndex + (UINT32)((ALL_AUTO_RETURN_SUM_MAX)*sizeof(AllAutoReturnDataStruct));
 		
-		/*计算一次CRC*/
-		crcLength = curIndex - crcIndex;
-		crcResult = Tioc_CommonCrc32(pCiAppDataPointer + crcIndex, crcLength);
-		debug_infor_printf((const)"2oo2 IndicatorDataStru-AllAutoReturnDataStru CRC:%x, Length:%d\n", crcResult, crcLength);
-		crcIndex = curIndex;
-
         /*拷贝车库门数据结构体*/
         (void)memcpy(pCiAppDataPointer + curIndex, GaragedoorDataStru, (GARAGE_DOOR_SUM_MAX)*sizeof(GaragedoorDataStruct));
 	    curIndex = curIndex + (UINT32)((GARAGE_DOOR_SUM_MAX)*sizeof(GaragedoorDataStruct));
@@ -985,12 +948,6 @@ UINT32 GetCiAppData(UINT8 *pCiAppDataPointer)
 		(void)memcpy(pCiAppDataPointer + curIndex, ocHLHTHeadCtxs, (OC_SUM_MAX) * sizeof(HLHTHeadContextStru));
 		curIndex = curIndex + (UINT32)((OC_SUM_MAX) * sizeof(HLHTHeadContextStru));
 
-		/*计算一次CRC*/
-		crcLength = curIndex - crcIndex;
-		crcResult = Tioc_CommonCrc32(pCiAppDataPointer + crcIndex, crcLength);
-		debug_infor_printf((const)"2oo2 GaragedoorDataStru-ocHLHTHeadCtxs CRC:%x, Length:%d\n", crcResult, crcLength);
-		crcIndex = curIndex;
-
 		/*与本CI通信的TMC系统互联互通报文头上下文数据*/
 		(void)memcpy(pCiAppDataPointer + curIndex, tmcHLHTHeadCtxs, (TMC_SUM_MAX) * sizeof(HLHTHeadContextStru));
 		curIndex = curIndex + (UINT32)((TMC_SUM_MAX) * sizeof(HLHTHeadContextStru));
@@ -1032,12 +989,6 @@ UINT32 GetCiAppData(UINT8 *pCiAppDataPointer)
 		(void)memcpy(pCiAppDataPointer + curIndex, m_Switches, m_SwitchNum * sizeof(OcDeviceStruct));
 		curIndex = curIndex + (UINT32)(m_SwitchNum * sizeof(OcDeviceStruct));
 
-		/*计算一次CRC*/
-		crcLength = curIndex - crcIndex;
-		crcResult = Tioc_CommonCrc32(pCiAppDataPointer + crcIndex, crcLength);
-		debug_infor_printf((const)"2oo2 tmcHLHTHeadCtxs-m_Switches CRC:%x, Length:%d\n", crcResult, crcLength);
-		crcIndex = curIndex;
-
 		/*与本CI通信的OC DI上下文数据*/
 		curIndex += CopyValidGetDataStru(pCiAppDataPointer + curIndex, (void*)m_OcConvertedPtDataArr, (OC_SUM_MAX), (UINT16)sizeof(OcCollBoardDataStruct));
 
@@ -1075,12 +1026,6 @@ UINT32 GetCiAppData(UINT8 *pCiAppDataPointer)
 		(void)memcpy(pCiAppDataPointer + curIndex, &CiSendBackDataTempStruSum, sizeof(UINT16));
 		curIndex = curIndex + (UINT32)sizeof(UINT16);
 
-		/*计算一次CRC*/
-		crcLength = curIndex - crcIndex;
-		crcResult = Tioc_CommonCrc32(pCiAppDataPointer + crcIndex, crcLength);
-		debug_infor_printf((const)"2oo2 m_OcConvertedPtDataArr-CiSendBackDataTempStruSum CRC:%x, Length:%d\n", crcResult, crcLength);
-		crcIndex = curIndex;
-
 		/*拷贝虚拟联锁数据*/
 		for(ii = 0u;ii<g_VirtualCIStructData.virtualCiNum;ii++)
 		{
@@ -1143,21 +1088,8 @@ UINT32 GetCiAppData(UINT8 *pCiAppDataPointer)
 		(void)memcpy(pCiAppDataPointer + curIndex, &LocalAreaSnowNum, sizeof(UINT8));
 		curIndex = curIndex + (UINT32)sizeof(UINT8);
 
-		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(AreaSnowInfoStruct)* LOCAL_AREA_SNOW_SUM_MAX), (const void*)(szLocalAreaSnow), (UINT32)(sizeof(AreaSnowInfoStruct) * LOCAL_AREA_SNOW_SUM_MAX));
+		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(UINT32)* LOCAL_AREA_SNOW_SUM_MAX), (const void*)(szLocalAreaSnowId), (UINT32)(sizeof(UINT32) * LOCAL_AREA_SNOW_SUM_MAX));
-		curIndex = curIndex + (UINT32)(sizeof(AreaSnowInfoStruct) * LOCAL_AREA_SNOW_SUM_MAX);
+		curIndex = curIndex + (UINT32)(sizeof(UINT32) * LOCAL_AREA_SNOW_SUM_MAX);
-
-		/*拷贝本地区间ITE切除信息*/
-		pCiAppDataPointer[curIndex] = gLocalAreaIteCutNum;
-		curIndex += 1U;
-
-		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(UINT16) * ALL_AREA_SNOW_SUM_MAX), (const void*)(gSzLocalAreaIteCutId), (UINT32)(sizeof(UINT16) * ALL_AREA_SNOW_SUM_MAX));
-		curIndex = curIndex + (UINT32)(sizeof(UINT16) * ALL_AREA_SNOW_SUM_MAX);
-
-		/*计算一次CRC*/
-		crcLength = curIndex - crcIndex;
-		crcResult = Tioc_CommonCrc32(pCiAppDataPointer + crcIndex, crcLength);
-		debug_infor_printf((const)"2oo2 m_OcConvertedPtDataArr-CiSendBackDataTempStruSum CRC:%x, Length:%d\n", crcResult, crcLength);
-		crcIndex = curIndex;
 
 #if 1
 		/* 拷贝排序信息 */
@@ -1194,12 +1126,6 @@ UINT32 GetCiAppData(UINT8 *pCiAppDataPointer)
 		(void)memcpy(pCiAppDataPointer + curIndex, &gTiocCanntCutReason, sizeof(UINT8));
 		curIndex = curIndex + (UINT32)sizeof(UINT8);
 		
-		/*计算一次CRC*/
-		crcLength = curIndex - crcIndex;
-		crcResult = Tioc_CommonCrc32(pCiAppDataPointer + crcIndex, crcLength);
-		debug_infor_printf((const)"2oo2 g_CutoffPointDataBuf-gTiocCanntCutReason CRC:%x, Length:%d\n", crcResult, crcLength);
-		crcIndex = curIndex;
-
 		/*拷贝无直轨计轴占用信息*/
 		curIndex = ToaGetTransferData(pCiAppDataPointer, curIndex);
 
@@ -1247,16 +1173,6 @@ UINT32 GetCiAppData(UINT8 *pCiAppDataPointer)
 		curIndex = curIndex + (UINT32)sizeof(g_strAtsDaMsgSnd);
 		(void)CommonMemCpy((void *)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_strAtsDaCfmSnd), (const void *)(&g_strAtsDaCfmSnd), (UINT32)sizeof(g_strAtsDaCfmSnd));
 		curIndex = curIndex + (UINT32)sizeof(g_strAtsDaCfmSnd);
-
-		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(AtsMsgCfmStru), (const void*)(&g_strSndAtsCfmFst), (UINT32)sizeof(AtsMsgCfmStru));
-		curIndex = curIndex + (UINT32)sizeof(AtsMsgCfmStru);
-		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(AtsMsgCfmStru), (const void*)(&g_strSndAtsEaCfmFst), (UINT32)sizeof(AtsMsgCfmStru));
-		curIndex = curIndex + (UINT32)sizeof(AtsMsgCfmStru);
-		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(AtsMsgCfmStru), (const void*)(&g_strSndAtsWlbCfmFst), (UINT32)sizeof(AtsMsgCfmStru));
-		curIndex = curIndex + (UINT32)sizeof(AtsMsgCfmStru);
-		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(AtsMsgCfmStru), (const void*)(&g_strSndAtsDaCfmFst), (UINT32)sizeof(AtsMsgCfmStru));
-		curIndex = curIndex + (UINT32)sizeof(AtsMsgCfmStru);
-
 		/*拷贝异地试车线SQAJ状态*/
 		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT8), (const void*)(&comm_Train_Test_SQAJ_SCX_State), (UINT32)sizeof(UINT8));
 		curIndex = curIndex + (UINT32)sizeof(UINT8);
@@ -1277,12 +1193,6 @@ UINT32 GetCiAppData(UINT8 *pCiAppDataPointer)
 		(void)CommonMemCpy((void *)(pCiAppDataPointer + curIndex), (UINT32)sizeof(LeuToCiDataStru), (const void *)LeuToCiDataStru, (UINT32)sizeof(LeuToCiDataStru));
 		curIndex = curIndex + (UINT32)((LEU_TO_CI_SUM_MAX) * sizeof(LeuToCiDataStruct));
 
-		/*计算一次CRC*/
-		crcLength = curIndex - crcIndex;
-		crcResult = Tioc_CommonCrc32(pCiAppDataPointer + crcIndex, crcLength);
-		debug_infor_printf((const)"2oo2 ToaGetTransferData-LeuToCiDataStru CRC:%x, Length:%d\n", crcResult, crcLength);
-		crcIndex = curIndex;
-
 		/* 拷贝停止运营信息 */
 		curIndex = Deploy_GetTransferData(pCiAppDataPointer, curIndex);
 
@@ -1295,21 +1205,13 @@ UINT32 GetCiAppData(UINT8 *pCiAppDataPointer)
 		curIndex = curIndex + (UINT32)sizeof(LineCommTrainStruct);
 
 		/*同步相邻联锁区间雨雪发送信息*/
-		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(ToCiAreaSnowStruct)* CI_COM_CI_MAX_NUM), (void*)(szSendCiAreaSnow), (UINT32)(sizeof(ToCiAreaSnowStruct)* CI_COM_CI_MAX_NUM));
+		(void)CommonMemCpy((const void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(ToCiAreaSnowStruct)* CI_COM_CI_MAX_NUM), (void*)(szSendCiAreaSnow), (UINT32)(sizeof(ToCiAreaSnowStruct)* CI_COM_CI_MAX_NUM));
 		curIndex = curIndex + (UINT32)(sizeof(ToCiAreaSnowStruct) * CI_COM_CI_MAX_NUM);
 
 		/*同步相邻联锁区间接收雨雪信息*/
-		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(ToCiAreaSnowStruct)* CI_COM_CI_MAX_NUM), (void*)(szRecvCiAreaSnow), (UINT32)(sizeof(ToCiAreaSnowStruct)* CI_COM_CI_MAX_NUM));
+		(void)CommonMemCpy((const void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(ToCiAreaSnowStruct)* CI_COM_CI_MAX_NUM), (void*)(szRecvCiAreaSnow), (UINT32)(sizeof(ToCiAreaSnowStruct)* CI_COM_CI_MAX_NUM));
 		curIndex = curIndex + (UINT32)(sizeof(ToCiAreaSnowStruct) * CI_COM_CI_MAX_NUM);
 
-		/*同步相邻联锁区间ITE切除接收信息*/
-		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(ToCiAreaIteCutStruct)* CI_COM_CI_MAX_NUM), (void*)(szRecvCiAreaIteCut), (UINT32)(sizeof(ToCiAreaIteCutStruct)* CI_COM_CI_MAX_NUM));
-		curIndex = curIndex + (UINT32)(sizeof(ToCiAreaIteCutStruct) * CI_COM_CI_MAX_NUM);
-
-		/*同步相邻联锁区间ITE切除发送信息*/
-		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(ToCiAreaIteCutStruct)* CI_COM_CI_MAX_NUM), (void*)(szSendCiAreaIteCut), (UINT32)(sizeof(ToCiAreaIteCutStruct)* CI_COM_CI_MAX_NUM));
-		curIndex = curIndex + (UINT32)(sizeof(ToCiAreaIteCutStruct) * CI_COM_CI_MAX_NUM);
-
 		/*拷贝虚拟无人折返信息*/
 		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(VirtualZDZFAJDataStruct), (const void*)(&VirtualZDZFAJData), (UINT32)sizeof(VirtualZDZFAJDataStruct));
 		curIndex = curIndex + (UINT32)sizeof(VirtualZDZFAJDataStruct);
@@ -1323,43 +1225,6 @@ UINT32 GetCiAppData(UINT8 *pCiAppDataPointer)
 		/* 拷贝本地雨雪命令 */
 		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT8), (const void*)(&g_LocalSnowModel), (UINT32)sizeof(UINT8));
 		curIndex = curIndex + (UINT32)sizeof(UINT8);
-
-		/*拷贝本地相邻联锁接受命令信息*/
-		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT16), (const void*)(&RecvCiCmdDataStruCurSum), (UINT32)sizeof(UINT16));
-		curIndex = curIndex + (UINT32)sizeof(UINT16);
-
-		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(ToCiCommandDataStruct)* RECVCI_CMD_DATA_STRU_SUM_MAX), (void*)(&RecvCiCmdDataStru), (UINT32)(sizeof(ToCiCommandDataStruct)* RECVCI_CMD_DATA_STRU_SUM_MAX));
-		curIndex = curIndex + (UINT32)(sizeof(ToCiCommandDataStruct) * RECVCI_CMD_DATA_STRU_SUM_MAX);
-
-		/*拷贝本地相邻联锁发送命令信息*/
-		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT16), (const void*)(&SendCiCmdDataStruCurSum), (UINT32)sizeof(UINT16));
-		curIndex = curIndex + (UINT32)sizeof(UINT16);
-
-		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(ToCiCommandDataStruct)* RECVCI_CMD_DATA_STRU_SUM_MAX), (void*)(&SendCiCmdDataStru), (UINT32)(sizeof(ToCiCommandDataStruct)* RECVCI_CMD_DATA_STRU_SUM_MAX));
-		curIndex = curIndex + (UINT32)(sizeof(ToCiCommandDataStruct) * RECVCI_CMD_DATA_STRU_SUM_MAX);
-
-		/*拷贝本地相邻联锁接受动态进路命令信息*/
-		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT8), (const void*)(&RecvCiDrCmdSum), (UINT32)sizeof(UINT8));
-		curIndex = curIndex + (UINT32)sizeof(UINT8);
-
-		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(ToCiDrCmdDataStruct)* RECVCI_CMD_DATA_STRU_SUM_MAX), (void*)(&RecvCiDrCmdDataStru), (UINT32)(sizeof(ToCiDrCmdDataStruct)* RECVCI_CMD_DATA_STRU_SUM_MAX));
-		curIndex = curIndex + (UINT32)(sizeof(ToCiDrCmdDataStruct) * RECVCI_CMD_DATA_STRU_SUM_MAX);
-
-		/*拷贝本地相邻联锁发送动态进路命令信息*/
-		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT8), (const void*)(&SendCiDrCmdSum), (UINT32)sizeof(UINT8));
-		curIndex = curIndex + (UINT32)sizeof(UINT8);
-
-		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(ToCiDrCmdDataStruct)* RECVCI_CMD_DATA_STRU_SUM_MAX), (void*)(&SendCiDrCmdDataStru), (UINT32)(sizeof(ToCiDrCmdDataStruct)* RECVCI_CMD_DATA_STRU_SUM_MAX));
-		curIndex = curIndex + (UINT32)(sizeof(ToCiDrCmdDataStruct) * RECVCI_CMD_DATA_STRU_SUM_MAX);
-
-		/*拷贝平台IO电源采集容忍数据*/
-		(void)CommonMemCpy((void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(PlatGPIOToleranceDataStruct), (void*)(&gPlatDataGPIOTolercance), (UINT32)sizeof(PlatGPIOToleranceDataStruct));
-		curIndex = curIndex + (UINT32)sizeof(PlatGPIOToleranceDataStruct);
-
-		/*计算一次CRC*/
-		crcLength = curIndex - crcIndex;
-		crcResult = Tioc_CommonCrc32(pCiAppDataPointer + crcIndex, crcLength);
-		debug_infor_printf((const)"2oo2 Deploy_GetTransferData-g_LocalSnowModel CRC:%x, Length:%d\n", crcResult, crcLength);
 	}
 	return curIndex;
 }
@@ -1421,10 +1286,6 @@ UINT8 SetCiAppData(const UINT8 *pCiAppDataPointer,const UINT32 len)
 			(void)memcpy(&g_AllSnowModel, pCiAppDataPointer + curIndex, sizeof(UINT8));
 			curIndex = curIndex + (UINT32)sizeof(UINT8);
 
-			/*同步全线湿轨级别*/
-			(void)CommonMemCpy((void*)(&g_AllSnowLevel), (UINT32)sizeof(UINT8), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT8));
-			curIndex = curIndex + (UINT32)sizeof(UINT8);
-
 			/*拷贝应急盘继电器有效周期*/
 			(void)memcpy(&JkjRelayValidCycNum, pCiAppDataPointer + curIndex, sizeof(UINT32));
 			curIndex = curIndex + (UINT32)sizeof(UINT32);
@@ -1787,15 +1648,8 @@ UINT8 SetCiAppData(const UINT8 *pCiAppDataPointer,const UINT32 len)
 			LocalAreaSnowNum = pCiAppDataPointer[curIndex];
 			curIndex += 1U;
 
-			(void)CommonMemCpy((const void*)(szLocalAreaSnow), (UINT32)(sizeof(AreaSnowInfoStruct) * LOCAL_AREA_SNOW_SUM_MAX), (const void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(AreaSnowInfoStruct) * LOCAL_AREA_SNOW_SUM_MAX));
+			(void)CommonMemCpy((const void*)(szLocalAreaSnowId), (UINT32)(sizeof(UINT32) * LOCAL_AREA_SNOW_SUM_MAX), (void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(UINT32) * LOCAL_AREA_SNOW_SUM_MAX));
-			curIndex = curIndex + (UINT32)(sizeof(AreaSnowInfoStruct) * LOCAL_AREA_SNOW_SUM_MAX);
+			curIndex = curIndex + (UINT32)(sizeof(UINT32) * LOCAL_AREA_SNOW_SUM_MAX);
-
-			/*设置本地区间ITE切除信息*/
-			gLocalAreaIteCutNum = pCiAppDataPointer[curIndex];
-			curIndex += 1U;
-
-			(void)CommonMemCpy((const void*)(gSzLocalAreaIteCutId), (UINT32)(sizeof(UINT16) * ALL_AREA_SNOW_SUM_MAX), (const void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(UINT16) * ALL_AREA_SNOW_SUM_MAX));
-			curIndex = curIndex + (UINT32)(sizeof(UINT16) * ALL_AREA_SNOW_SUM_MAX);
 
 #if 1
 			/* 拷贝排序信息 */
@@ -1880,15 +1734,6 @@ UINT8 SetCiAppData(const UINT8 *pCiAppDataPointer,const UINT32 len)
 			(void)CommonMemCpy((void *)(&g_strAtsDaCfmSnd), (UINT32)sizeof(g_strAtsDaCfmSnd), (const void *)(pCiAppDataPointer + curIndex), (UINT32)sizeof(g_strAtsDaCfmSnd));
 			curIndex = curIndex + (UINT32)sizeof(g_strAtsDaCfmSnd);
 
-			(void)CommonMemCpy((void*)(&g_strSndAtsCfmFst), (UINT32)sizeof(AtsMsgCfmStru), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(AtsMsgCfmStru));
-			curIndex = curIndex + (UINT32)sizeof(AtsMsgCfmStru);
-			(void)CommonMemCpy((void*)(&g_strSndAtsEaCfmFst), (UINT32)sizeof(AtsMsgCfmStru), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(AtsMsgCfmStru));
-			curIndex = curIndex + (UINT32)sizeof(AtsMsgCfmStru);
-			(void)CommonMemCpy((void*)(&g_strSndAtsWlbCfmFst), (UINT32)sizeof(AtsMsgCfmStru), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(AtsMsgCfmStru));
-			curIndex = curIndex + (UINT32)sizeof(AtsMsgCfmStru);
-			(void)CommonMemCpy((void*)(&g_strSndAtsDaCfmFst), (UINT32)sizeof(AtsMsgCfmStru), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(AtsMsgCfmStru));
-			curIndex = curIndex + (UINT32)sizeof(AtsMsgCfmStru);
-
 			/*拷贝异地试车线SQAJ状态*/
 			(void)CommonMemCpy((void*)(&comm_Train_Test_SQAJ_SCX_State), (UINT32)sizeof(UINT8), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT8));
 			curIndex = curIndex + (UINT32)sizeof(UINT8);
@@ -1929,14 +1774,6 @@ UINT8 SetCiAppData(const UINT8 *pCiAppDataPointer,const UINT32 len)
 			(void)CommonMemCpy((void*)(szRecvCiAreaSnow), (UINT32)(sizeof(ToCiAreaSnowStruct)* CI_COM_CI_MAX_NUM), (const void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(ToCiAreaSnowStruct)* CI_COM_CI_MAX_NUM));
 			curIndex = curIndex + (UINT32)(sizeof(ToCiAreaSnowStruct) * CI_COM_CI_MAX_NUM);
 
-			/*同步相邻联锁区间ITE切除接收信息*/
-			(void)CommonMemCpy((void*)(szRecvCiAreaIteCut), (UINT32)(sizeof(ToCiAreaIteCutStruct)* CI_COM_CI_MAX_NUM), (const void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(ToCiAreaIteCutStruct)* CI_COM_CI_MAX_NUM));
-			curIndex = curIndex + (UINT32)(sizeof(ToCiAreaIteCutStruct) * CI_COM_CI_MAX_NUM);
-
-			/*同步相邻联锁区间ITE切除发送信息*/
-			(void)CommonMemCpy((void*)(szSendCiAreaIteCut), (UINT32)(sizeof(ToCiAreaIteCutStruct)* CI_COM_CI_MAX_NUM), (const void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(ToCiAreaIteCutStruct)* CI_COM_CI_MAX_NUM));
-			curIndex = curIndex + (UINT32)(sizeof(ToCiAreaIteCutStruct) * CI_COM_CI_MAX_NUM);
-
 			/*拷贝虚拟无人折返信息*/
 			(void)CommonMemCpy((void*)(&VirtualZDZFAJData), (UINT32)sizeof(VirtualZDZFAJDataStruct), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(VirtualZDZFAJDataStruct));
 			curIndex = curIndex + (UINT32)sizeof(VirtualZDZFAJDataStruct);
@@ -1951,38 +1788,6 @@ UINT8 SetCiAppData(const UINT8 *pCiAppDataPointer,const UINT32 len)
 			/*同步本地雨雪命令*/
 			(void)CommonMemCpy((void*)(&g_LocalSnowModel), (UINT32)sizeof(UINT8), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT8));
 			curIndex = curIndex + (UINT32)sizeof(UINT8);
-
-			/*拷贝本地相邻联锁接受命令信息*/
-			(void)CommonMemCpy((void*)(&RecvCiCmdDataStruCurSum), (UINT32)sizeof(UINT16), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT16));
-			curIndex = curIndex + (UINT32)sizeof(UINT16);
-
-			(void)CommonMemCpy((void*)(&RecvCiCmdDataStru), (UINT32)(sizeof(ToCiCommandDataStruct)* RECVCI_CMD_DATA_STRU_SUM_MAX), (const void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(ToCiCommandDataStruct)* RECVCI_CMD_DATA_STRU_SUM_MAX));
-			curIndex = curIndex + (UINT32)(sizeof(ToCiCommandDataStruct) * RECVCI_CMD_DATA_STRU_SUM_MAX);
-
-			/*拷贝本地相邻联锁发送命令信息*/
-			(void)CommonMemCpy((void*)(&SendCiCmdDataStruCurSum), (UINT32)sizeof(UINT16), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT16));
-			curIndex = curIndex + (UINT32)sizeof(UINT16);
-
-			(void)CommonMemCpy((void*)(&SendCiCmdDataStru), (UINT32)(sizeof(ToCiCommandDataStruct)* RECVCI_CMD_DATA_STRU_SUM_MAX), (const void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(ToCiCommandDataStruct)* RECVCI_CMD_DATA_STRU_SUM_MAX));
-			curIndex = curIndex + (UINT32)(sizeof(ToCiCommandDataStruct) * RECVCI_CMD_DATA_STRU_SUM_MAX);
-
-			/*拷贝本地相邻联锁接受动态进路命令信息*/
-			(void)CommonMemCpy((void*)(&RecvCiDrCmdSum), (UINT32)sizeof(UINT8), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT8));
-			curIndex = curIndex + (UINT32)sizeof(UINT8);
-
-			(void)CommonMemCpy((void*)(&RecvCiDrCmdDataStru), (UINT32)(sizeof(ToCiDrCmdDataStruct)* RECVCI_CMD_DATA_STRU_SUM_MAX), (const void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(ToCiDrCmdDataStruct)* RECVCI_CMD_DATA_STRU_SUM_MAX));
-			curIndex = curIndex + (UINT32)(sizeof(ToCiDrCmdDataStruct) * RECVCI_CMD_DATA_STRU_SUM_MAX);
-
-			/*拷贝本地相邻联锁发送动态进路命令信息*/
-			(void)CommonMemCpy((void*)(&SendCiDrCmdSum), (UINT32)sizeof(UINT8), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(UINT8));
-			curIndex = curIndex + (UINT32)sizeof(UINT8);
-
-			(void)CommonMemCpy((void*)(&SendCiDrCmdDataStru), (UINT32)(sizeof(ToCiDrCmdDataStruct)* RECVCI_CMD_DATA_STRU_SUM_MAX), (const void*)(pCiAppDataPointer + curIndex), (UINT32)(sizeof(ToCiDrCmdDataStruct)* RECVCI_CMD_DATA_STRU_SUM_MAX));
-			curIndex = curIndex + (UINT32)(sizeof(ToCiDrCmdDataStruct) * RECVCI_CMD_DATA_STRU_SUM_MAX);
-
-			/*拷贝平台IO电源采集容忍数据*/
-			(void)CommonMemCpy((void*)(&gPlatDataGPIOTolercance), (UINT32)sizeof(PlatGPIOToleranceDataStruct), (const void*)(pCiAppDataPointer + curIndex), (UINT32)sizeof(PlatGPIOToleranceDataStruct));
-			curIndex = curIndex + (UINT32)sizeof(PlatGPIOToleranceDataStruct);
 #endif
 			rtn = 1u;
 		}

TSCP/src/APP/ciapp/2oo2/2oo2InterfaceDataManage.h

@@ -386,7 +386,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/AutoRoute/AutoRouteDataManage.c

@@ -107,13 +107,7 @@ 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

@@ -56,13 +56,7 @@ 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/AxisAssert/AxisAssertDefine.h

@@ -25,7 +25,6 @@
 #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

@@ -53,9 +53,6 @@ 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);
@@ -106,24 +103,6 @@ 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 
-				{
-					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))
 				{
@@ -143,8 +122,6 @@ static UINT8 aam_SearchNearestTrainInNextAC(UINT16 baseACID, UINT8 Dir, UINT8 en
 					ret = AAM_BAD_NEAR;
 				}
 			}
-				
-			}
 		}
 	}
 	else
@@ -179,6 +156,8 @@ 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;
@@ -302,23 +281,30 @@ static UINT8 aam_AxisErrorJudge(UINT16 acID,UINT16 acIndex)
 	UINT8 ret = CI_ERROR;
 	UINT8 funRtn = CI_ERROR;
 	UINT8 chNearbyCheck = CI_ERROR;
-	UINT8 acSameCnt = 0U;
+	UINT8 acSameCnt = 0u;
-	UINT16 acSameID[AC_MAXCNT_IN_SWITCH] = { 0U };
+	UINT16 acSameID[AC_MAXCNT_IN_SWITCH] = { 0u };
-	UINT8 acConvertCnt = 0U;
+	UINT8 acConvertCnt = 0u;
-	UINT16 acConvertID[AC_MAXCNT_IN_SWITCH] = { 0U };
+	UINT16 acConvertID[AC_MAXCNT_IN_SWITCH] = { 0u };
-	UINT32 errorCode = 0U;
+	UINT32 errorCode = 0u;
 	UINT8 sameTrainType = AAM_BAD_NEAR;
 	UINT8 convertTrainType = AAM_BAD_NEAR;
-	UINT8 tmpRedunTime = 0U;
+	UINT8 tmpRedunTime = 0u;
-	UINT8 tmppassTrainType = 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)
@@ -367,32 +353,6 @@ 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))
 			{
@@ -450,13 +410,89 @@ static UINT8 aam_AxisErrorJudge(UINT16 acID,UINT16 acIndex)
 					}
 					else
 					{
-						/*ARB计轴区段同向相邻计轴区段连续占用*/
+						cOccCheckFlag = CI_SUCCESS;
-						funRtn = aam_ArbContinuousOccCheck(acID, acSameCnt, acSameID);
+						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计轴区段反向相邻计轴区段连续占用*/
+								if (CI_ERROR == cOccCheckFlag)
-						funRtn &= aam_ArbContinuousOccCheck(acID, acConvertCnt, acConvertID);
+								{
+									break;
+								}
+								else
+								{
+									;
+								}
+							}
 
-						if (CI_SUCCESS != funRtn)
+							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)
 						{
 							/** 清除本计轴区段之前的冗余计时位 */
 							funRtn = aam_ClearPassTrainFlag(acIndex);
@@ -466,7 +502,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 Continuous Occ\n", acID);
+							AAM_LOG(AAM_LOG_FATAL, "info:AC%d  Keep ARB Fail Because Of Near Sec Occ\n", acID);
 						}
 						else
 						{
@@ -851,11 +887,9 @@ 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 */
@@ -2021,165 +2055,3 @@ 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

@@ -213,24 +213,4 @@ 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

@@ -370,22 +370,27 @@ 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 };
-	struct_PathPoint LinkPoint = { 0u };
+	UINT16 wTrainId = 0u;
-	UINT32 dwFindLen = 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;
 	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();
@@ -400,26 +405,27 @@ 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);
 
-			/*重置计算位置 */
+			/* 获取边界点信息 */
-			LinkPoint.wLinkId =0U;
+			CutoffPoint.wLinkId = GetCfpLink(wCutoffPointId);
-			LinkPoint.dwOffset = 0U;
+			CutoffPoint.dwOffset = GetCfpOffset(wCutoffPointId);
 
-			wOtherCfpId = 0U;
+			wTrainId = 0u;
-			chOtherFlag = FLAG_UNSET;
+			TrainPoint.wLinkId = 0u;
-			chBreakFlag = FLAG_UNSET;
+			TrainPoint.dwOffset = 0u;
-			dwLinkLen = 0U;
+
-			if ((CI_SUCCESS == cFunRetVal)&&(MAX_CFG_LIGHTUPLINK_NUM>=wLinkSum))
+			TrainTailPoint.wLinkId = 0U;
+			TrainTailPoint.dwOffset = 0U;
+			TrainHeadPoint.wLinkId = 0U;
+			TrainHeadPoint.dwOffset = 0U;
+
+			if (CI_SUCCESS == cFunRetVal)
 			{
 				/* 区段查找成功,查到区段上的列车 */
 				for (j = 0u;j < wLinkSum;j++)
 				{
 					wLinkId = wszLinkIdBuf[j];
-					chLinkCIId = (UINT8)GetLinkManageTiocById(wLinkId);				
-					if (chLinkCIId == chLocalId)
-					{
 					wPhySecId = GetLinkRelatedPhySec(wLinkId);
 					chOccState = GetPhySecCurOccupyState(wPhySecId);
 					chTrainNum = as_GetLinkTrainNum(wLinkId);
@@ -427,46 +433,18 @@ void  CutoffPointOutput(void)
 					if ((SECTION_OCCUPY_NO != chOccState) && (0u != chTrainNum))
 					{
 						/* 找到有车占用的区段 */
-							chBreakFlag = FLAG_SET;
+						break;
 					}
 					else
 					{
 						;
 					}
-					}
+
-					else
+					/*检查是否有方向变化点，此处检查，当前link已按既定方向查找完，查下一link，若此时中间有方向变化点，则跨过方向变化点，到下一link改变方向查*/
+					if (j < (wLinkSum - 1U))
 					{
-						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已检查越界*/
+						cDirectionPointsecond = GetLinkLogicDirChangedById(wszLinkIdBuf[(j + 1U)]);		/*todo越界*/
 						if (((LINK_DIRCHANGE_BEGIN == cDirectionPointfirst) || (LINK_DIRCHANGE_END == cDirectionPointfirst))
 							&& (cDirectionPointsecond == cDirectionPointfirst))
 						{
@@ -477,45 +455,107 @@ void  CutoffPointOutput(void)
 							;	/*没有反向变换点，不考虑变方向*/
 						}
 					}
-							dwLinkLen += GetLinkLengthById(wLinkId); /*未中断遍历，无车且属于本联锁，更新已计算link总长*/
-						}
-					}
 					else
 					{
-						; /*最后一个link 无需更新*/
+						;			/*最后一个link不需要考虑方向变化点的问题，防止数组越界*/
-					}
-					
-					if ((dwFindLen <= dwLinkLen)|| (FLAG_SET == chOtherFlag) || (FLAG_SET == chBreakFlag))
-					{
-						/*距离足够 或查找到相邻RC，或查找到占用，停止计算*/
-						break;
-					}
-					else
-					{
-						; /*无处理*/
 					}
 				}
 
 				/* 获取列车ID 获取距离分界点最近的列车*/
-				if ((j < wLinkSum) && (dwFindLen > dwLinkLen))
+				if (j < wLinkSum)
 				{
-					if (FLAG_UNSET == chOtherFlag)
+					if (DIR_SAME == cDir)
 					{
-						CfpTrainInfoCal(LinkPoint.wLinkId, LinkPoint.dwOffset, dwLinkLen, &tmpTrainInfo, cDir);
+						strTmp = as_GetLinkFirstTrain(wLinkId);
 					}
 					else
 					{
-						/*找到不属于本联锁link 寻找对应联锁及分界点列车信息*/
+						strTmp = as_GetLinkLastTrain(wLinkId);
-						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
 			{
@@ -1592,140 +1632,3 @@ 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_CI, 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

@@ -350,23 +350,6 @@ 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/DeviceDataManage.c

@@ -44,9 +44,7 @@ UINT8 ciMode = CI_MODE_CI_LOCAL;										                  /*
 
 UINT8 g_AllTsrFlag = CI_ALL_TSR_UNVALID;												  /* 临时限速标志 */
 
-UINT8 g_AllSnowModel = CI_ALL_SNOW_UNVALID;                                                 /*全线雨雪模式命令：0x55-有效；0xAA-无效*/
+UINT8 g_AllSnowModel = CI_ALL_SNOW_UNVALID;                                                 /*全线雨雪模式命令*/
-
-UINT8 g_AllSnowLevel = CI_SNOW_LEVEL_DEFAULT;                                                 /*全线湿轨级别：0-默认值；1-一级；2-二级*/
 
 UINT8 g_IteLineCutState = CI_ITE_LINE_CUT_DEFAULT;                                          /*ITE全线切除状态：0x55：切除ITE；0xAA：使用ITE；0xFF：默认值*/
 
@@ -84,7 +82,7 @@ UINT8 SwitchBlockLinkState = RECOVER_SWITCH_BLOCK_LINK; /*
 CtrlPowerStruct ctrlpowerFlag[VIRTUAL_CI_MAX] = { 0u };
 
 UINT8 LocalAreaSnowNum = 0U;  /*本地区间雨雪站台数量*/
-AreaSnowInfoStruct szLocalAreaSnow[LOCAL_AREA_SNOW_SUM_MAX] = { 0U };  /*本地区间雨雪数组*/
+UINT32 szLocalAreaSnowId[LOCAL_AREA_SNOW_SUM_MAX] = { 0U };  /*本地区间雨雪站台ID数组*/
 
 LineCommTrainStruct gStrLineCommTrain = { 0U };  /*全线通信车结构体*/
 
@@ -92,9 +90,6 @@ UINT32 gFlyProtectOverCyc = 0U;										                  /*
 
 UINT8 g_LocalSnowModel = CI_LOCAL_SNOW_UNVALID;   /*本地雨雪模式命令*/
 
-UINT8 gLocalAreaIteCutNum = 0U;  /*本地区间ITE切除数量*/
-UINT16 gSzLocalAreaIteCutId[ALL_AREA_SNOW_SUM_MAX] = { 0U };  /*本地区间ITE切除ID数组——需要存储ZC发送的所有区间ID*/
-
 /******************************联锁标志数据管理****************************/
 
 
@@ -1329,18 +1324,6 @@ 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))
 	{
@@ -1394,8 +1377,6 @@ 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))
@@ -2167,8 +2148,6 @@ 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;
 
@@ -2195,6 +2174,7 @@ 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道岔区段封锁状态*/
@@ -2533,9 +2513,8 @@ UINT8 GetSwitchMoveEarlyValidState(UINT16 switchId, UINT8	oper_src, UINT8 sendLe
 			}
 		}
 	}
-	/*道岔可动*/
-#endif
 
+	/*道岔可动*/
 	return reVal;
 }
 
@@ -2598,9 +2577,9 @@ UINT8 GetSwitchMoveValidState(UINT16 switchId,UINT8	oper_src,UINT8 sendLevel)
 	/*判断是否采用轨道电路*/
 	gdDLline = GetCiFunctionSwitchConfig(FUNC_CLD_GD_DIANLU_LINE);
 
-	if ((JKJ_REYLAY_VALID == JkjRelayValid) && (CI_TYPE_CLD == ciType))
+	if ((JkjRelayId > 0u) && (JKJ_REYLAY_VALID == JkjRelayValid) && (CI_TYPE_CLD == ciType))
 	{/*应急盘继电器有效状态*/
-		SetErrorData(functionId, CI_DEVICE_TYPE_RELAY, 0u, ETYPE_JKJ_WORK, RELAY_STATE_DOWN, ESEND_LEVEL_ATS);/*增加OC应急控功能，继电器ID填0*/
+		SetErrorData(functionId, CI_DEVICE_TYPE_RELAY, JkjRelayId, ETYPE_JKJ_WORK, RELAY_STATE_DOWN, ESEND_LEVEL_ATS);
 		reVal = CI_ERROR;
 	}
 	else
@@ -5149,9 +5128,6 @@ 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)
@@ -5288,7 +5264,6 @@ 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:       /*车库门*/
@@ -5406,6 +5381,7 @@ void SetAllTsrFlag(UINT8 setFlag)
 * 参数说明： void
 * 返回值  ：0x55: 有效 0xAA:无效
 */
+
 UINT8 GetAllSnowModel(void)
 {
 	return g_AllSnowModel;
@@ -5428,37 +5404,6 @@ 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
@@ -6221,7 +6166,6 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
 	UINT16 bufIndex = 0u;  /*数组下标*/
 	UINT8 logSecLockState = 0U;
 	UINT8 logSecLockRouteNum = 0U;
-	UINT8 chFailStep = 0U;
 
 	bufIndex = GetlogSectionBufIndex(logSectionId);  /*获取区段数组下标*/
 	/**区段下标合法*/
@@ -6253,7 +6197,6 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
 			{
 				/*调车进路锁闭*/
 				reVal = CI_ERROR;
-				chFailStep  = 1U;
 			}
 		}
 		if (CI_SUCCESS == reVal)
@@ -6262,7 +6205,6 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
 			{
 				/*逻辑区段存在逻辑进路锁闭锁闭*/
 				reVal = CI_ERROR;
-				chFailStep = 2U;
 			}
 		}
 
@@ -6282,7 +6224,6 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
 						|| ((LOGICSECTION_OCCUPY_CT == curLogSecOccState) && (CI_ERROR == checkSulicTrain)))
 					{
 						reVal = CI_ERROR;
-						chFailStep =3U;
 						break;
 					}
 					else
@@ -6316,7 +6257,6 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
 					{
 						/*返回失败*/
 						reVal = CI_ERROR;
-						chFailStep = 4U;
 					}
 					else
 					{
@@ -6335,14 +6275,12 @@ 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))
@@ -6356,8 +6294,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
@@ -6383,7 +6321,6 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
 						if ((pLgcSecSwitchStru[ii].SwitchPosition != switchCurPosition) || (CI_ERROR == retFlag) || (SWITCH_LOCK_FENGSUO_YES == switchFLockState))
 						{/*（判断当前计轴包含的道岔位置与道岔当前的位置有一个不同）或（某个道岔上一次驱动仍然有效）或（道岔封锁）*/
 							reVal = CI_ERROR;
-							chFailStep = 8U;
 							break;
 						}
 						else
@@ -6414,7 +6351,6 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
 							if (FLOOD_GATE_OPEN != floodState)
 							{
 								reVal = CI_ERROR;
-								chFailStep = 9U;
 								break;
 							}
 							else
@@ -6440,7 +6376,6 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
 				|| ((LOGICSECTION_OCCUPY_CT == curLogSecOccState) && (CI_ERROR == checkSulicTrain)))
 			{
 				reVal = CI_ERROR;
-				chFailStep = 10U;
 			}
 			else
 			{
@@ -6460,7 +6395,6 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
 				if (CI_ERROR == checkResult)
 				{
 					reVal = CI_ERROR;
-					chFailStep = 11U;
 				}
 				else
 				{
@@ -6472,30 +6406,11 @@ 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;
 }
 
@@ -10701,10 +10616,10 @@ UINT8 GetDiaoCheRouteOpenState(const UINT16 wRouteId)
 /*
 * 功能描述：设置本地区间雨雪站台信息
 * 参数说明：const UINT8 cAreaSnowNum 区间雨雪数量
-*			const AreaSnowInfoStruct pAreaSnowBuf[LOCAL_AREA_SNOW_SUM_MAX] 区间雨雪数组
+*			const UINT32 pAreaSnowIdBuf[] 区间雨雪ID数组
 * 返回值  ：无
 */
-void SetLocalAreaSnowInfo(const UINT8 cAreaSnowNum, const AreaSnowInfoStruct pAreaSnowBuf[LOCAL_AREA_SNOW_SUM_MAX])
+void SetLocalAreaSnowInfo(const UINT8 cAreaSnowNum, const UINT32 pAreaSnowIdBuf[])
 {
 	UINT8 ii = 0U;
 	UINT8 jj = 0U;
@@ -10717,20 +10632,20 @@ void SetLocalAreaSnowInfo(const UINT8 cAreaSnowNum, const AreaSnowInfoStruct pAr
 	UINT8 cPhySecBelongCiId = 0U;  /*SPKS关联物理区段的所属控区*/
 	UINT8 cLocalCiId = 0U;  /*本地CI ID*/
 
-	if ((LOCAL_AREA_SNOW_SUM_MAX >= cAreaSnowNum) && (NULL != pAreaSnowBuf))
+	if ((LOCAL_AREA_SNOW_SUM_MAX >= cAreaSnowNum) && (NULL != pAreaSnowIdBuf))
 	{
 		/*清除本地区间雨雪站台信息和发送给相邻联锁的区间雨雪信息*/
 		ClearCiSendAreaSnowInfo();
-		(void)CommonMemSet(szLocalAreaSnow, (UINT32)(sizeof(AreaSnowInfoStruct) * LOCAL_AREA_SNOW_SUM_MAX), 0U, (UINT32)(sizeof(AreaSnowInfoStruct) * LOCAL_AREA_SNOW_SUM_MAX));
+		(void)CommonMemSet(szLocalAreaSnowId, (UINT32)(sizeof(UINT32) * LOCAL_AREA_SNOW_SUM_MAX), 0U, (UINT32)(sizeof(UINT32) * LOCAL_AREA_SNOW_SUM_MAX));
 
 		LocalAreaSnowNum = cAreaSnowNum;
 		for (ii = 0U; ii < cAreaSnowNum; ii++)
 		{
-			szLocalAreaSnow[ii] = pAreaSnowBuf[ii];  /*存储本控区的区间雨雪状态信息*/
+			szLocalAreaSnowId[ii] = pAreaSnowIdBuf[ii];  /*存储本控区的区间雨雪状态信息*/
 
-			/*判断是否需要向相邻联锁发送本控区的区间雨雪信息*/
+			/*判断是否需要向相邻联锁发送本控区的区间雨雪站台*/
 			cLocalCiId = GetSystemParaLocalCiId();
-			cPlatFormRelSpksNum = GetPlatFormRelSpksNum(pAreaSnowBuf[ii].wAreaId, szPlatFormRelSpksId);  /*获取站台关联的SPKS*/
+			cPlatFormRelSpksNum = GetPlatFormRelSpksNum((UINT16)pAreaSnowIdBuf[ii], szPlatFormRelSpksId);  /*获取站台关联的SPKS*/
 
 			if (CI_ERROR != cPlatFormRelSpksNum)
 			{
@@ -10749,7 +10664,7 @@ void SetLocalAreaSnowInfo(const UINT8 cAreaSnowNum, const AreaSnowInfoStruct pAr
 
 							if ((cLocalCiId != cPhySecBelongCiId) && (0U != cLocalCiId) && (0U != cPhySecBelongCiId))
 							{
-								AddCiSendAreaSnowInfo(cLocalCiId, cPhySecBelongCiId, pAreaSnowBuf[ii].wAreaId, pAreaSnowBuf[ii].cAreaSnowLevel);  /*站台关联有非本控区的区段，向区段所属CI发送站台ID*/
+								AddCiSendAreaSnowInfo(cLocalCiId, cPhySecBelongCiId, pAreaSnowIdBuf[ii]);  /*站台关联有非本控区的区段，向区段所属CI发送站台ID*/
 							}
 							else
 							{
@@ -10786,13 +10701,13 @@ UINT8 GetLocalAreaSnowNum(void)
 }
 
 /*
-* 功能描述：获取本地区间雨雪信息
+* 功能描述：获取本地区间雨雪站台ID
 * 参数说明：无
-* 返回值  ：区间雨雪信息
+* 返回值  ：区间雨雪站台ID
 */
-AreaSnowInfoStruct* GetLocalAreaSnow(void)
+UINT32* GetLocalAreaSnowId(void)
 {
-	return szLocalAreaSnow;
+	return szLocalAreaSnowId;
 }
 
 
@@ -11200,170 +11115,3 @@ 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;
-}

TSCP/src/APP/ciapp/DataManage/DeviceDataManage.h

@@ -15,14 +15,6 @@
 #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"
@@ -164,7 +156,6 @@ typedef struct S_LineCommTrainStruct
 	UINT16 szCommTrainNumID[TRAIN_SUM_MAX];	 /*全线通信车ID数组*/
 }LineCommTrainStruct;
 
-
 /*******************************全局变量声明*******************************/
 extern UINT8 AllSignalBrightFlag;					                  /*全站亮灯标志*/
 
@@ -190,8 +181,6 @@ extern UINT8 g_AllTsrFlag;												  /*
 
 extern UINT8 g_AllSnowModel;                                                 /*全线雨雪模式命令*/
 
-extern UINT8 g_AllSnowLevel;                                                 /*全线湿轨级别：0-默认值；1-一级；2-二级*/
-
 extern UINT8 g_IteLineCutState;                                          /*ITE全线切除状态：0x55：切除ITE；0xAA：使用ITE；0xFF：默认值*/
 
 extern UINT8 g_AllLineTsrState;                                          /*全线临时限速状态*/
@@ -230,16 +219,13 @@ extern UINT8 SwitchBlockLinkState; /*
 extern CtrlPowerStruct ctrlpowerFlag[VIRTUAL_CI_MAX];
 
 extern UINT8 LocalAreaSnowNum;  /*本地区间雨雪站台数量*/
-extern AreaSnowInfoStruct szLocalAreaSnow[LOCAL_AREA_SNOW_SUM_MAX];  /*本地区间雨雪数组*/
+extern UINT32 szLocalAreaSnowId[LOCAL_AREA_SNOW_SUM_MAX];  /*本地区间雨雪站台ID数组*/
 
 extern LineCommTrainStruct gStrLineCommTrain;  /*全线通信车结构体*/
 
 extern UINT32 gFlyProtectOverCyc;										                  /*飞车宕机报警起始周期*/
 extern UINT8 g_LocalSnowModel;     /*本地雨雪模式命令*/
 
-extern UINT8 gLocalAreaIteCutNum;  /*本地区间ITE切除数量*/
-extern UINT16 gSzLocalAreaIteCutId[ALL_AREA_SNOW_SUM_MAX];  /*本地区间ITE切除ID数组*/
-
 /******************************联锁标志数据管理****************************/
 
 /*
@@ -1381,24 +1367,6 @@ 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
@@ -1742,10 +1710,10 @@ UINT8 GetDiaoCheRouteOpenState(const UINT16 wRouteId);
 /*
 * 功能描述：设置本地区间雨雪站台信息
 * 参数说明：const UINT8 cAreaSnowNum 区间雨雪数量
-*			const AreaSnowInfoStruct pAreaSnowBuf[LOCAL_AREA_SNOW_SUM_MAX] 区间雨雪数组
+*			const UINT32 pAreaSnowIdBuf[] 区间雨雪ID数组
 * 返回值  ：无
 */
-void SetLocalAreaSnowInfo(const UINT8 cAreaSnowNum, const AreaSnowInfoStruct pAreaSnowBuf[LOCAL_AREA_SNOW_SUM_MAX]);
+void SetLocalAreaSnowInfo(const UINT8 cAreaSnowNum, const UINT32 pAreaSnowIdBuf[]);
 
 /*
 * 功能描述：获取本地区间雨雪站台数量
@@ -1755,11 +1723,11 @@ void SetLocalAreaSnowInfo(const UINT8 cAreaSnowNum, const AreaSnowInfoStruct pAr
 UINT8 GetLocalAreaSnowNum(void);
 
 /*
-* 功能描述：获取本地区间雨雪信息
+* 功能描述：获取本地区间雨雪站台ID
 * 参数说明：无
-* 返回值  ：区间雨雪信息
+* 返回值  ：区间雨雪站台ID
 */
-AreaSnowInfoStruct* GetLocalAreaSnow(void);
+UINT32* GetLocalAreaSnowId(void);
 
 
 /*
@@ -1856,46 +1824,4 @@ 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);
-
 #endif

TSCP/src/APP/ciapp/DataManage/PlatDataManage.c

@@ -17,7 +17,7 @@
 
 extern PlatHeartDataStruct RecvHeartDataStru ;  /*平台心跳帧数据结构*/
 extern PlatGPIODataStruct RecvPlatDataStruGPIO;/*平台0x2D帧数据结构 GPIO采集状态*/
-extern PlatGPIOToleranceDataStruct gPlatDataGPIOTolercance;/*平台硬件采集故障容忍记录数据*/
+
 
 
 
@@ -427,36 +427,18 @@ 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系电源故障状态*/
-		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)"PLATIO_A_Node_Power_FaultState StartTime%d\n", dwErrorStartCyc);
-		}
 	}
 	else
 	{
 		retVal = CI_SUCCESS;
-		gPlatDataGPIOTolercance.powerANode_TolCyc = 0U;
 	}
 	return retVal;
 }
@@ -471,36 +453,18 @@ UINT8 CheckRCIBPowerFaultState(void)
 {
 	UINT8 retVal = CI_ERROR;
 	UINT8 cxBBreakFlag = 0U; /*B系电源插箱空开断开检查*/
-	UINT8 chCheckState = 0U;
+
-	UINT32 dwErrorStartCyc = 0U;
-	UINT32 dwCurCyc = 0U;
 	cxBBreakFlag = GetPowerBNodeStatue();
-	dwErrorStartCyc = gPlatDataGPIOTolercance.powerBNode_TolCyc;
+
-	dwCurCyc = Get2oo2CurCycleNum();
 	/* 1、B系电源插箱空开断开 */
 	if (NODE_STATUS_BREAK == cxBBreakFlag)
 	{
 		/*B系电源故障状态*/
-		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)"PLATIO_B_Node_Power_FaultState StartTime%d\n", dwErrorStartCyc);
-		}
 	}
 	else
 	{
 		retVal = CI_SUCCESS;
-		gPlatDataGPIOTolercance.powerBNode_TolCyc = 0U;
 	}
 	return retVal;
 }
@@ -520,44 +484,23 @@ UINT8 CheckRCIAPowerModeFaultState(void)
 	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 */
 
 	if (((CHECK_VOLTAGE_ZERO == vol1Flag) || (CHECK_VOLTAGE_ZERO == vol3Flag))
 		&& ((POWER_STATUS_ABNORMAL == powerAPUBAState) || (POWER_STATUS_ABNORMAL == powerBPUBAState)))
-	{
-		/*检查容忍*/
-		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)"PLATIO_A_Mode_Power_FaultState StartTime%d\n", dwErrorStartCyc);
-		}
 	}
 	else
 	{
 		retVal = CI_SUCCESS;
-		gPlatDataGPIOTolercance.powerAMode_TolCyc = 0U;
 	}
 	
 	return retVal;
@@ -577,43 +520,25 @@ 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采集，只判断电源电压*/
 	if (((CHECK_VOLTAGE_ZERO == vol2Flag) || (CHECK_VOLTAGE_ZERO == vol4Flag))
 		&& ((POWER_STATUS_ABNORMAL == powerAPUBBState) || (POWER_STATUS_ABNORMAL == powerBPUBBState)))
-	{
-		/*检查容忍*/
-		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)"PLATIO_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

@@ -16,7 +16,7 @@
 
 #include "CommonTypes.h"
 #include "../System/CiSystemDefine.h"
-#include "../System/SystemParameterManage.h"
+
 
 
 #define BOARD_TYPE_CCUA   ((UINT8)0x09)     /*通控板A*/
@@ -60,8 +60,6 @@
 
 #define VOLTAGE_MAX_TO_0        ((UINT16)500U)           /*电压判断为0的阈值*/
 
-#define IO_POWERSTATE_TOLERANCE   ((UINT8)0x02)           /*平台电源报警容忍周期数，容忍3周期，超过2周期报警*/
-
 /*平台心跳帧信息结构*/
 typedef struct S_PlatHeartDataStruct
 {
@@ -103,14 +101,7 @@ typedef struct S_PlatGPIODataStruct
 }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

@@ -109,7 +109,6 @@
 #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_SET_LEAD_ROUTE_CHECK          ((UINT8)0x4B)    /*办理引导进路检查*/    
@@ -136,6 +135,7 @@
 #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,8 +178,6 @@
 #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逻辑进路信号开放处理*/
@@ -212,8 +210,6 @@
 
 #define EFUNC_FIRSTLEAVE_LOGSEC_CHECK        ((UINT8)0xD1)		/*离去逻辑区段检查RouteLeaveLogSecCheck*/
 
-#define EFUNC_OVERLAP_ZHAOCHA_CHECK          ((UINT8)0xD3)		/*保护区段照查条件检查*/
-
 
 /*************************************************分界线******************************************************************************/
 /*************************************************分界线******************************************************************************/
@@ -234,7 +230,6 @@
 #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_COMM_WITH_VOBC		((UINT8)0x11)	/*与VOBC通信*/
@@ -318,7 +313,6 @@
 #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 */        
 /* 设备类型 
@@ -385,16 +379,6 @@
 #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

@@ -160,17 +160,12 @@ 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;
@@ -803,273 +798,3 @@ 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

@@ -38,17 +38,12 @@ 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;
 
 /*******************************全局变量声明*******************************/
@@ -315,98 +310,6 @@ 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

@@ -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,9 +1277,16 @@ 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);
@@ -1316,10 +1323,58 @@ void elm_DealNoCGFollowUt(UINT16 wEnvelopeID,UINT16 wTrainId)
 		{
 			if (0U == errorCode)
 			{
-				/*处理AG虚拟筛选标志*/
+				chLinkRelPhySecAGorBGAttr = GetLinkRelPhySecAGorBGAttr(safeLoc.endPos.Lnk);
-				elm_DealAgVirScreenFlag(wEnvelopeID, wTrainId);
+				chEnvelopLinkABGAttr = GetLinkRelPhySecAGorBGAttr(pEnvelop->endPos.Lnk);
-				/*处理BG虚拟筛选标志*/
+				wLinkRelatedPhySec = GetLinkRelatedPhySec(pEnvelop->endPos.Lnk);
-				elm_DealBgVirScreenFlag(wEnvelopeID, wTrainId);
+				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
 			{
@@ -1517,182 +1572,3 @@ 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/EnvelopeLogicProcess.c

@@ -106,7 +106,7 @@ static UINT8 elm_UKTAdjacentSwProtect(void)
 						nearTrainType = aam_SearchNearbyTrainType(pACIdbuff[cycleAc], EMAP_SAME_DIR, acSameCnt, acSameID);
 					}
 
-					if ((AAM_BAD_NEAR == nearTrainType)|| (AAM_SLEEP_OCC == nearTrainType))
+					if (AAM_BAD_NEAR == 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) || (AAM_SLEEP_OCC == nearTrainType))
+						if (AAM_BAD_NEAR == 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]);
@@ -330,12 +330,6 @@ static void elm_FlyingProtect(void)
 	UINT16 wTrainId = 0U;
 	UINT8 chTimeCheck = 0u;
 	UINT32 dwFlyOverCyc = 0U;
-	UINT8 cNvramFlag = 0U;  /*列车使用NVRAM标志*/
-	UINT8 cPosMonistorState = 0U;  /*列车位置监督状态*/
-	UINT8 cFuncSwitch = 0U;  /*使用NVRAM位置且位置监督无效的列车飞车不宕机开关：0xAA-飞车不宕机 0x55-飞车宕机*/
-
-	/*周期清除使用NVRAM位置且位置监督无效的飞车信息*/
-	ClearNvramFlyingTrain();
 
 	chCTCheck = elm_FlyingProtect_CT(); /*检查CT飞车*/
 	elm_FlyingProtect_UCT();/*UCT包络飞车删除为UKT*/
@@ -350,7 +344,7 @@ static void elm_FlyingProtect(void)
 	{
 		/** 获取数据配置的飞车宕机最大冗余时间 */
 		maxShutdownRedunTime = elm_PrepareCTFlyingRedunTime();
-		cFuncSwitch = GetCiFunctionSwitchConfig(FUNC_NVRAM_TRAIN_FlYING_OVER);
+
 		for (ii = 0U; ii < trainCnt; ii++)
 		{
 			wTrainId = GetTrainId(ii);
@@ -358,23 +352,13 @@ static void elm_FlyingProtect(void)
 			{
 				dwFlyStartCyc = GetTrainStartFlyProtectCycNum(wTrainId);
 				chTimeCheck = SystemOverTimeCheck(dwFlyStartCyc, (UINT32)maxShutdownRedunTime);
-
 				if (CI_TIME_OUT== chTimeCheck) 
-				{
-					cNvramFlag = GetTrainNvramPosFlag(wTrainId);
-					cPosMonistorState = GetTrainPosMonitorState(wTrainId);
-					if ((TRAIN_NVRAM_POS_FLAG_YES == cNvramFlag) && (TRAIN_POS_MONITOR_VALID != cPosMonistorState) && (FUNC_SWITCH_ON == cFuncSwitch))
-					{
-						/*使用NVRAM位置且位置监督无效的列车飞车后，若NVRAM列车飞车不宕机开关打开，RC仅向列车发飞车特控报文，不宕机*/
-					}
-					else
 				{
 					SetFlyProtectOverCyc(dwCurCyc); /*飞车标志*/
 				}
-				}
 				else
 				{
-					; /*未超过冗余时间或列车通信中断*/
+					; /*未超过冗余时间*/
 				}
 			}
 		}
@@ -2052,8 +2036,6 @@ 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();
@@ -2073,17 +2055,8 @@ void elm_SafeProtectProcess(void)
 		funRet = elm_UTLosingProtect();     
 		ASSER_ERROR(CI_ERROR == funRet,errorCode,0x40000000u);
 
-		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();
@@ -2622,7 +2595,6 @@ 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++)
@@ -2667,10 +2639,6 @@ UINT8 elm_UCTEnvelopeLeaveAC(UINT8 flag,IN const EnvelopeStruct* pEnvelope,UINT1
 
 			 if ((NULL != pEnvelopeInfo) && 
 				 ((TYPE_CT_ENVELOPE == pEnvelopeInfo->envelopeType) || (TYPE_UCT_ENVELOPE == pEnvelopeInfo->envelopeType)))
-			 {
-				 chTrainNvramPosFlag = GetTrainNvramPosFlag(cycle);
-
-				 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;
@@ -2678,11 +2646,6 @@ UINT8 elm_UCTEnvelopeLeaveAC(UINT8 flag,IN const EnvelopeStruct* pEnvelope,UINT1
 				 wls_SetTrainControlStatus(cycle,IN_CONTROL_STATUS,headNeedScreen,tailNeedScreen);
 			 }
 			 else
-				 {
-					 ELM_LOG(ELM_LOG_FATAL, " not Add In Control Train,Because UseNvram Pos\n");
-				 }		
-			 }
-			 else
 			 {
 				 /* 无需处理 */
 			 }
@@ -2801,24 +2764,25 @@ UINT8 elm_UCTEnvelopeLeaveAC(UINT8 flag,IN const EnvelopeStruct* pEnvelope,UINT1
  * @return CI_ERROR 查询失败
 		   CI_SUCCESS 查询成功
  * @note
- *  edit cgh 20250724 目前只用于RRM
+ *  by cgh 20240514 目前只用于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;     /* 包络数量 */
+	 UINT8 envelopeCnt = 0u;     /* 包络数量 */
-	 UINT16 arEnvelopID[TRAIN_SUM_MAX_IN_OC] = { 0U };  /*包络ID数组*/
+	 UINT16 arEnvelopID[TRAIN_SUM_MAX_IN_OC] = { 0u };  /*包络ID数组*/
-	 UINT16 acCnt = 0U;   /** 前方计轴数量*/
+	 UINT16 acCnt = 0u;   /** 前方计轴数量*/
-	 UINT16 acID[AC_MAXCNT_IN_SWITCH * AC_MAXCNT_IN_SWITCH] = { 0U };
+	 UINT16 acID[AC_MAXCNT_IN_SWITCH * AC_MAXCNT_IN_SWITCH] = { 0u };
-	 UINT16 mergeACIndex = 0U;
+	 UINT8 acStatus = ELM_AC_OCC;
+	 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 };
+	 UINT16 mergeACID[SECTION_IN_ENVELOPE_SUM_MAX + 2U * AC_MAXCNT_IN_SWITCH * AC_MAXCNT_IN_SWITCH] = { 0u };
-	 UINT8 includeCnt = 0U;
+	 UINT8 includeCnt = 0u;
-	 UINT16 includeELMid[TRAIN_SUM_MAX_IN_OC] = { 0U };  /** 重合的包络id */
+	 UINT16 includeELMid[TRAIN_SUM_MAX_IN_OC] = { 0u };  /** 重合的包络id */
 
 	 /** 获取列车包络 */
 	 pEnvelop = elm_GetEnvelopeInfoPtr(envelopeId);
@@ -2827,36 +2791,63 @@ UINT8 elm_UCTEnvelopeLeaveAC(UINT8 flag,IN const EnvelopeStruct* pEnvelope,UINT1
 	 if ((NULL == pEnvelop) || (NULL == preEnvelope) || (NULL == backEnvelope))
 	 {
 		 /** 设置错误码*/
-		 ASSER_ERROR(CI_ERROR == funRet, errorCode, 0x80000000U);
+		 ASSER_ERROR(CI_ERROR == funRet, errorCode, 0x08000000u);
 	 }
 	 else
 	 {
-		 /* 查询后方计轴区段*/
+		 /** 获取车尾包络计轴占用状态 */
+		 acStatus = elm_PrepareACStatus(pEnvelop->ACID[0]);
+
+		 /** 判断包络尾是否占用，如果占用，则需要查询下一个计轴*/
+		 if (ELM_AC_OCC == acStatus)
+		 {
+			 /* 查询后方计轴，车尾计轴占用，存在道岔四开，为了确保能然后后端，需要查询安全车尾所属计轴的相邻计轴区段*/
 			 acCnt = elm_GetEnvelopTailACIDs(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, 0x40000000U);
+			 ASSER_ERROR(mergeACIndex > mergeACCntMax, errorCode, 0x04000000u);
 
-		 if (0U == errorCode)
+		 }
+		 else
 		 {
-			 (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)));/*先清空数组防止脏数据*/
+			 /** 先合并包络包含的计轴区段 */
-			 /* 查询前方计轴*/
+			 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, 0x20000000U);
+				 ASSER_ERROR(mergeACIndex > mergeACCntMax, errorCode, 0x04000000u);
+
+			 }
+			 else
+			 {
+				 /** 无需处理*/
+			 }
 
 			 /** 判断是否处理成功 */
-			 if (0U == errorCode)
+			 if (0u == errorCode)
 			 {
 				 /** 获取前方计轴包含的包络 */
 				 envelopeCnt = elm_MergeEnvelope(mergeACID, (UINT8)mergeACIndex, arEnvelopID);
@@ -2865,7 +2856,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, 0x10000000U);
+				 ASSER_ERROR(CI_SUCCESS != funRet, errorCode, 0x08000000u);
 			 }
 			 else
 			 {
@@ -2879,7 +2870,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;
  }
 
@@ -3064,13 +3055,9 @@ UINT8 elm_UCTEnvelopeLeaveAC(UINT8 flag,IN const EnvelopeStruct* pEnvelope,UINT1
 	 UINT32 dwFlyStartCyc = 0U;
 	 UINT8 chTimeCheck = 0U;
 	 UINT8 flyCheck = 0U;
-	 UINT8 cNvramFlag = 0U;  /*列车使用NVRAM标志*/
-	 UINT8 cPosMonistorState = 0U;  /*列车位置监督状态*/
-	 UINT8 cFuncSwitch = 0U;  /*使用NVRAM位置且位置监督无效的列车飞车不宕机开关：0xAA-飞车不宕机 0x55-飞车宕机*/
-
 	 /** CT飞车防护*/
 	 trainCnt = elm_PrepareCommTrainID(trainID);
-	 cFuncSwitch = GetCiFunctionSwitchConfig(FUNC_NVRAM_TRAIN_FlYING_OVER);
+
 	 /** 遍历所有的通信车 */
 	 for (cycle = 0u; cycle < trainCnt; cycle++)
 	 {
@@ -3116,19 +3103,9 @@ UINT8 elm_UCTEnvelopeLeaveAC(UINT8 flag,IN const EnvelopeStruct* pEnvelope,UINT1
 					 dwFlyStartCyc = GetTrainStartFlyProtectCycNum(trainID[cycle]);
 					 chTimeCheck = SystemOverTimeCheck(dwFlyStartCyc, (UINT32)maxShutdownRedunTime);
 					 if (CI_TIME_OUT == chTimeCheck)
-					 {
-						 cNvramFlag = GetTrainNvramPosFlag(trainID[cycle]);
-						 cPosMonistorState = GetTrainPosMonitorState(trainID[cycle]);
-						 if ((TRAIN_NVRAM_POS_FLAG_YES == cNvramFlag) && (TRAIN_POS_MONITOR_VALID != cPosMonistorState) && (FUNC_SWITCH_ON == cFuncSwitch))
-						 {
-							 /*使用NVRAM位置且位置监督无效的列车飞车后，若NVRAM列车飞车不宕机开关打开，RC仅向列车发飞车特控报文，不宕机*/
-							 AddNvramFlyingTrain(trainID[cycle]);
-						 }
-						 else
 					 {
 						 elm_AddFlyingTrain(trainID[cycle], pEnvelop->id);
 					 }
-					 }
 					 flyCheck++;
 				 }
 				 else

TSCP/src/APP/ciapp/EnvelopeManage/EnvelopeLogicProcess.h

@@ -486,22 +486,4 @@ 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

@@ -634,7 +634,6 @@ 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();
@@ -654,10 +653,6 @@ 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);
-					chTrainNvramPosFlag = GetTrainNvramPosFlag(cycle);
-
-					if (TRAIN_NVRAM_POS_FLAG_NO == chTrainNvramPosFlag)
-					{
 					if (LINE_MAX_TRAIN == pEnvelopeInfo->headTrainID)
 					{
 						ELM_LOG(ELM_LOG_FATAL," delete Head suspicious,");
@@ -677,13 +672,6 @@ void elm_WLScreenProcess(void)
 					{
 						/* 不处理 */
 					}
-						
-					}
-					else
-					{
-						ELM_LOG(ELM_LOG_FATAL, " not finish suspicious,because use nvram pos");
-					}
-
 					ELM_LOG(ELM_LOG_FATAL,"\n");
 				}
 			}

TSCP/src/APP/ciapp/EnvelopeManage/UCTEnvelopeTrack.c

@@ -1990,15 +1990,16 @@ 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_DeleteCTOrUCTEnvelope(ptemp->id);
+				funRtn = elm_SetEnvelopeHeadTrainID(ptemp->id, LINE_MAX_TRAIN);
-				ASSER_ERROR(CI_ERROR == funRtn, errorCode, 0x00000400u);
+				ASSER_ERROR(CI_ERROR == funRtn, errorCode, 0x00001000u);
 			}
+
+			/** 则更新车头位置 */
+			funRtn = elm_SetUCTEnvelopeDot(ELM_HEAD, ptemp->ACID[ptemp->ACCnt - 1u], ptemp);
+			ASSER_ERROR(CI_ERROR == funRtn, errorCode, 0x00000800u);
 		}
 		ret = 0x55u;
 	}
@@ -2114,10 +2115,8 @@ static UINT8 elm_UCTEnvelopeHeadHandle(UINT8 endlineFlag, IN const EnvelopeStruc
 			wAgLink = GetBGLinkRelAGLinkId(wLinkId);
 			chBgUtSwitch = GetNoCGFollowUtSwitch();
 			wNextLinkId = FindAdjacentLinkIDSafe(wLinkId, ptemp->endPos.Dir, &wSwitchId, &cDirectionPointFlag);
-			if ((FUNC_SWITCH_ON == chBgUtSwitch) && (LINK_REL_PHYSEC_BG == chBgAtt) && (wNextLinkId == wAgLink) 
+			if ((FUNC_SWITCH_ON == chBgUtSwitch) && (LINK_REL_PHYSEC_BG == chBgAtt) && (wNextLinkId == wAgLink) && ((pPretemp->startPos.Lnk == wAgLink) || (pPretemp->endPos.Lnk == wAgLink)))
-				&& ((pPretemp->startPos.Lnk == wAgLink) || (pPretemp->endPos.Lnk == wAgLink))
+			{/* B轨UT可追踪开关打开，UCT处于B轨，相邻区段是A轨，CT包络在A轨，此场景不延伸 */
-				&& (1U == ptemp->ACCnt))
-			{/* B轨UT可追踪开关打开，UCT仅处于B轨，相邻区段是A轨，CT包络在A轨，此场景不延伸 */
 				ret = 0x55u;
 			}
 			else
@@ -2272,8 +2271,7 @@ 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);
 
@@ -2385,30 +2383,7 @@ static UINT8 elm_UCTEnvelopeHeadMoving(const EnvelopeStruct *ptemp)
 					if (0u == errorCode)
 					{
 						endLineFlag = (0u == acSameCnt) ? CI_SUCCESS : CI_ERROR;
-						wInputAcId = acSameID[0U];
+						funRtn = elm_UCTEnvelopeHeadHandle(endLineFlag,ptemp,acSameID[0u],preEnvelope, cHeadDirChangeFlag);
-						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)
@@ -2659,17 +2634,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_DeleteCTOrUCTEnvelope(ptemp->id);
+				funRtn = elm_SetEnvelopeTailTrainID(ptemp->id, LINE_MAX_TRAIN);
-				ASSER_ERROR(CI_ERROR == funRtn, errorCode, 0x00000800u);
+				ASSER_ERROR(CI_ERROR == funRtn, errorCode, 0x00002000u);
 			}
+
+			/** 则更新车尾位置 */
+			funRtn = elm_SetUCTEnvelopeDot(ELM_TAIL, ptemp->ACID[0u], ptemp);
+			ASSER_ERROR(CI_ERROR == funRtn, errorCode, 0x00001000u);
 		}
 		ret = 0x55u;
 	}
@@ -2786,10 +2761,8 @@ static UINT8 elm_UCTEnvelopeTailHandle(UINT8 endlineFlag, const EnvelopeStruct *
 			wAgLink = GetBGLinkRelAGLinkId(wLinkId);
 			chBgUtSwitch = GetNoCGFollowUtSwitch();
 			wNextLinkId = FindAdjacentLinkIDSafe(wLinkId, ~ptemp->startPos.Dir, &wSwitchId, &cDirectionPointFlag);
-			if ((FUNC_SWITCH_ON == chBgUtSwitch) && (LINK_REL_PHYSEC_BG == chBgAtt) && (wNextLinkId == wAgLink) 
+			if ((FUNC_SWITCH_ON == chBgUtSwitch) && (LINK_REL_PHYSEC_BG == chBgAtt) && (wNextLinkId == wAgLink) && ((pBacktemp->startPos.Lnk == wAgLink) || (pBacktemp->endPos.Lnk == wAgLink)))
-				&& ((pBacktemp->startPos.Lnk == wAgLink) || (pBacktemp->endPos.Lnk == wAgLink))
+			{/* B轨UT可追踪开关打开，UCT处于B轨，相邻区段是A轨，CT包络在A轨，此场景不延伸 */
-				&& (1U == ptemp->ACCnt))
-			{/* B轨UT可追踪开关打开，UCT仅处于B轨，相邻区段是A轨，CT包络在A轨，此场景不延伸 */
 				ret = 0x55u;
 			}
 			else
@@ -2943,8 +2916,6 @@ 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);
@@ -3057,31 +3028,7 @@ static UINT8 elm_UCTEnvelopeTailMoving(const EnvelopeStruct *ptemp)
 					if (0u == errorCode)
 					{
 						endLineFlag = (0u == acConvertCnt) ? CI_SUCCESS : CI_ERROR;
-						wInputAcId = acConvertID[0U];
+						funRtn = elm_UCTEnvelopeTailHandle(endLineFlag,ptemp,acConvertID[0u],backEnvelope, cTailDirChangeFlag);
-						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)
@@ -3299,7 +3246,6 @@ static UINT8 elm_UCTEnvelopeMoving(const EnvelopeStruct* ptemp)
 								 2、包络内包含的道岔无四开且占用，
 								 3，不为休眠车,
 								 4、列车车长不小于两倍线路最小车长
-* by cgh 20250915
  */
 static UINT8 elm_ConvertToUCTCheck(const EnvelopeStruct* ptemp)
 {
@@ -3310,8 +3256,6 @@ static UINT8 elm_ConvertToUCTCheck(const EnvelopeStruct* ptemp)
 	UINT8 chCanUct = FLAG_SET;
 	UINT32 minTrainLength = 0U;
 	UINT32 dwTempLength = 0U;
-	UINT8 chTrainNvramPosFlag = 0U;
-	UINT8 chTrainIsIsFollowUtFlag = 0U;/*是否为列车可追踪UT*/
 
 	/** 入口参数校验 */
 	ASSERT_RET_VALUE(NULL == ptemp,ret,0x80000000U);
@@ -3353,28 +3297,6 @@ 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条件 */
-	}
-
-	if (0U == errorCode)
-	{
-		/** 获取列车是否处于可追踪UT场景 */
-		chTrainIsIsFollowUtFlag = CheckTrainIsFollowUt(ptemp->id);
-		ASSER_ERROR(CI_SUCCESS == chTrainIsIsFollowUtFlag, errorCode, 0x02000000U);
-	}
-	else
-	{
-		; /* 不满足转为UCT条件 */
-	}
-	
 	/** 设置函数返回值 */
 	ASSERT_SETRET(0U == errorCode,ret,CI_SUCCESS,CI_ERROR);
 	ASSER_DEBUG(0U != errorCode,ELM_LOG_LOC(ELM_LOG_ERROR,"errorCode:0x%08x info:ELM%d can't convert to UCT!",errorCode,ptemp->id));

TSCP/src/APP/ciapp/IO/DeviceRelayDataProcess.h

@@ -269,7 +269,6 @@ void FloodGateDeviceToRelayStateProc(void);
 * 功能描述： 更新进路的调车同意逻辑状态
 * 参数说明： void
 * 返回值  ： void
-* BY CGH 20250523
 */
 void RouteDCTYRelayToDeviceStateProc(void);
 
@@ -683,14 +682,13 @@ void DetZfsCancelBtnPressStateProc(const UINT16 wSignalId, const UINT16 wCancelD
 void DetZfsCancelBtnActFlagProc(const UINT16 wSignalId, const UINT16 wCancelDetBtnRelayId);
 
 /*
-* 功能描述：驱动自复式扣车相关指示灯
+* 功能描述：驱动自复式扣车指示灯
-* 参数说明：const UINT16 signalId 信号机ID
+* 参数说明：const UINT16 signalId, 信号机ID
-*           const UINT16 signalDetDisRelayId 扣车表示灯继电器ID
+*           const UINT16 signalDetainDisplayId, 扣车表示灯继电器1ID
-*           const UINT16 signalDetCutDisRelayId 扣车旁路表示灯继电器
 * 返回值：无
-* Modified By LQ 2025.07.03
+*
 */
-void DriveZfsDetainBsRelay(const UINT16 signalId, const UINT16 signalDetDisRelayId, const UINT16 signalDetCutDisRelayId);
+void DriveZfsDetainBsRelay(const UINT16 signalId, const UINT16 signalDetainDisplayId);
 
 /*
 * 功能描述：自复式紧急停车按钮处理
@@ -855,135 +853,6 @@ 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);
-
 #ifdef __cplusplus
 }
 #endif

TSCP/src/APP/ciapp/IO/InputDataProcess.c

@@ -264,8 +264,6 @@ void InputDataProcess(void)
 	{
 		/*处理OC数据*/
 		(void)ProcessOcToCiRelayData();
-		/*处理采集不一致的点位*/
-		ProcessOcToCiRelayDiffData();
 		debug_infor_printf((const)"\nprocess oc_relay end\n");
 	}
 	else
@@ -334,9 +332,6 @@ void InputDataProcess(void)
 	/*处理PSC系统数据*/
 	ProcessPscToCiData();
 
-	/*处理OC-PSC一体化数据*/
-	ProcessOCToCiPsdData();
-
 	/*处理设备状态*/
 	ProcessDeviceLogicState();	
 
@@ -410,9 +405,6 @@ void InputDataProcess(void)
 	/*刷新物理区段与信号机的湿轨标志*/
 	UpdateHumidRailFlag();
 
-	/*PSD异常打开处理（需要先更新物理区段融合状态，再进行PSD异常打开判断）*/
-	PsdExceptOpenProc();
-
 	/*处理ATS数据*/
     if ((CI_TYPE_ZX == localCiType) || (CI_TYPE_SCX == localCiType))
     {
@@ -641,106 +633,17 @@ void ProcessAxleToCiData(void)
 						if (AXIS_TYPE_KEANDA == acFty)
 						{
 							if (RELAY_STATE_UP == axisToCiDataStru[axisSysId].axisDataStr[jj].PreResetRst)
-							{
+							{/*计轴预复位继电器吸起*/
-								/*计轴预复位继电器吸起*/
 								SetPhySecPreResetState(secId, PHYSICAL_SECTION_PRE_RESET_YES);	/*设置计轴预复位状态有效*/
 							}
 							else if (RELAY_STATE_DOWN == axisToCiDataStru[axisSysId].axisDataStr[jj].PreResetRst)
-							{
+							{/*计轴预复位继电器落下*/
-								/*计轴预复位继电器落下*/
 								SetPhySecPreResetState(secId, PHYSICAL_SECTION_PRE_RESET_NO);	/*设置计轴预复位状态无效*/
 							}
 							else
-							{
+							{/*继电器采集状态为异常值*/
-								/*异常值*/
 								SetPhySecPreResetState(secId, PHYSICAL_SECTION_PRE_RESET_NO);	/*设置计轴预复位状态无效*/
 							}
-
-							/*科安达无直接复位状态接口，但后面为了计轴复位统一处理，这里设置成无效*/
-							SetPhySecDirectResetState(secId, PHYSICAL_DIRECT_RESET_NO);	/*设置计轴直接复位状态无效*/
-						}
-						else if (AXIS_TYPE_FUHAOSHENG == acFty)
-						{
-							if ((RELAY_STATE_UP == axisToCiDataStru[axisSysId].axisDataStr[jj].PreResetRst)
-								&& (RELAY_STATE_UP == axisToCiDataStru[axisSysId].axisDataStr[jj].chDirectResetRst))
-							{
-								/*预复位和立即复位同时有效，导向异常*/
-								SetPhySecPreResetState(secId, PHYSICAL_SECTION_PRE_RESET_NO);	/*设置计轴预复位状态无效*/
-								SetPhySecDirectResetState(secId, PHYSICAL_DIRECT_RESET_NO);	/*设置计轴直接复位状态无效*/
-								SetPhySecPreResetBack(secId, PHY_RESET_BACK_RECIVE_YES);
-								SetPhySecDirectResetBack(secId, PHY_RESET_BACK_RECIVE_YES);
-							}
-							else
-							{
-								if (RELAY_STATE_UP == axisToCiDataStru[axisSysId].axisDataStr[jj].PreResetRst)
-								{
-									/*计轴预复位继电器吸起*/
-									SetPhySecPreResetState(secId, PHYSICAL_SECTION_PRE_RESET_YES);	/*设置计轴预复位状态有效*/
-								}
-								else if (RELAY_STATE_DOWN == axisToCiDataStru[axisSysId].axisDataStr[jj].PreResetRst)
-								{
-									/*计轴预复位继电器落下*/
-									SetPhySecPreResetState(secId, PHYSICAL_SECTION_PRE_RESET_NO);	/*设置计轴预复位状态无效*/
-								}
-								else
-								{
-									/*异常值*/
-									SetPhySecPreResetState(secId, PHYSICAL_SECTION_PRE_RESET_NO);	/*设置计轴预复位状态无效*/
-								}
-
-								if (RELAY_STATE_UP == axisToCiDataStru[axisSysId].axisDataStr[jj].chPreResetBack)
-								{
-									/*计轴预复位反馈-接收到*/
-									SetPhySecPreResetBack(secId, PHY_RESET_BACK_RECIVE_YES);	
-								}
-								else if (RELAY_STATE_DOWN == axisToCiDataStru[axisSysId].axisDataStr[jj].chPreResetBack)
-								{
-									/**计轴预复位反馈-未接收到*/
-									SetPhySecPreResetBack(secId, PHY_RESET_BACK_RECIVE_NO);	
-								}
-								else
-								{
-									/*异常值*/
-									SetPhySecPreResetBack(secId, PHY_RESET_BACK_RECIVE_YES);
-								}
-
-								if (RELAY_STATE_UP == axisToCiDataStru[axisSysId].axisDataStr[jj].chDirectResetRst)
-								{
-									/*计轴直接复位继电器吸起*/
-									SetPhySecDirectResetState(secId, PHYSICAL_DIRECT_RESET_YES);	/*设置计轴直接复位状态有效*/
-								}
-								else if (RELAY_STATE_DOWN == axisToCiDataStru[axisSysId].axisDataStr[jj].chDirectResetRst)
-								{
-									/*计轴直接复位继电器落下*/
-									SetPhySecDirectResetState(secId, PHYSICAL_DIRECT_RESET_NO);	/*设置计轴直接复位状态无效*/
-								}
-								else
-								{
-									/*异常值*/
-									SetPhySecDirectResetState(secId, PHYSICAL_DIRECT_RESET_NO);	/*设置计轴直接复位状态无效*/
-								}
-
-								if (RELAY_STATE_UP == axisToCiDataStru[axisSysId].axisDataStr[jj].chDirectResetBack)
-								{
-									/*计轴直接复位反馈-接收到*/
-									SetPhySecDirectResetBack(secId, PHY_RESET_BACK_RECIVE_YES);
-								}
-								else if (RELAY_STATE_DOWN == axisToCiDataStru[axisSysId].axisDataStr[jj].chDirectResetBack)
-								{
-									/**计轴直接复位反馈-未接收到*/
-									SetPhySecDirectResetBack(secId, PHY_RESET_BACK_RECIVE_NO);
-								}
-								else
-								{
-									/*异常值*/
-									SetPhySecDirectResetBack(secId, PHY_RESET_BACK_RECIVE_YES);
-								}
-							}
-							
-						}
-						else
-						{
-							; /*其他接口不处理*/
 						}
 					}
 				}
@@ -757,9 +660,6 @@ void ProcessAxleToCiData(void)
 
 					(void)SetPhySecCurAxisGdOccupyState(secId, SECTION_OCCUPY_FAULT);
 					SetPhySecPreResetState(secId, PHYSICAL_SECTION_PRE_RESET_NO);	/*设置计轴预复位状态无效*/
-					SetPhySecDirectResetState(secId, PHYSICAL_DIRECT_RESET_NO);	    /*设置计轴直接复位状态无效*/
-					SetPhySecPreResetBack(secId, PHY_RESET_BACK_RECIVE_YES);
-					SetPhySecDirectResetBack(secId, PHY_RESET_BACK_RECIVE_YES);
 					
 					if (dwCurCycNum == (dwLastRecvAxisDataCycNum + dwCommBadEnsureCount + 1U))
 					{
@@ -868,11 +768,6 @@ void ProcessOcToCiData(void)
 					if (m_Signals[jj].OcId == pTempOc->OcId)
 					{
 						m_Signals[jj].DeviceState = OC_SIGNAL_SHOWCOLOR_RED_BREAK;/*红断*/
-						  /*设置信号机板卡为故障*/
-						for (j = 0U; j < 2U; j++)
-						{
-							m_Signals[jj].BoardState[j] = 0xffU;
-						}
 					}
 				}
 				/*把转换后的道岔数据重置状态*/
@@ -926,11 +821,6 @@ void ProcessOcToCiData(void)
 				}
 				/*与OC通信中断，需清除屏蔽门清客确认箱PCB按钮记忆状态*/
 				SetAllCleFarePCBButKeepSta(pTempOc->OcId,QK_PSD_BUTTON_STATE_UP);
-
-				/*与OC通信中断，清除屏蔽门信息*/
-
-				SetOcToCiDefaultDataStru(ii);
-
 			}
 			else
 			{
@@ -1524,7 +1414,7 @@ void ProcessZcToCiData(void)
 				{
 					/* 设置雨雪模式 */
 					SetAllSnowModel(pZcToCiDataStru->cSnowValidFlag);
-					SetLocalAreaSnowInfo(pZcToCiDataStru->cAreaSnowPlatFormNum, pZcToCiDataStru->szAreaSnowInfo);  /*更新本地区间雨雪状态信息*/
+					SetLocalAreaSnowInfo(pZcToCiDataStru->cAreaSnowPlatFormNum, pZcToCiDataStru->szAreaSnowPlatFormId);  /*更新本地区间雨雪状态信息*/
 					SetLocalSnowModel(pZcToCiDataStru->chLocalSnowValidFlag);
 				}
 			}
@@ -1546,8 +1436,6 @@ void ProcessZcToCiData(void)
 			{
 				/* 设置ITE全线切除状态 */
 				SetIteLineCutState(pZcToCiDataStru->cIteLineCutState);
-				/* 设置区间ITE切除信息 */
-				SetLocalAreaIteCutInfo(pZcToCiDataStru->cAreaIteCutNum, pZcToCiDataStru->szAreaIteCutId);
 			}
 			else
 			{
@@ -1647,8 +1535,7 @@ void ProcessTmcToTiocData(void)
 			{
 				/* 设置雨雪模式 */
 				SetAllSnowModel(pTmcInputData->cSnowValidFlag);
-				SetAllSnowLevel(pTmcInputData->cSnowLevel);
+				SetLocalAreaSnowInfo(pTmcInputData->cAreaSnowPlatFormNum, pTmcInputData->szAreaSnowPlatFormId);  /*更新本地区间雨雪状态信息*/
-				SetLocalAreaSnowInfo(pTmcInputData->cAreaSnowPlatFormNum, pTmcInputData->szAreaSnowInfo);  /*更新本地区间雨雪状态信息*/
 			}
 		}		
 	}
@@ -1660,8 +1547,6 @@ void ProcessTmcToTiocData(void)
 		{
 			/* 设置ITE全线切除状态 */
 			SetIteLineCutState(pTmcInputData->cIteLineCutState);
-			/* 设置区间ITE切除信息 */
-			SetLocalAreaIteCutInfo(pTmcInputData->cAreaIteCutNum, pTmcInputData->szAreaIteCutId);
 		}
 		else
 		{
@@ -2364,7 +2249,7 @@ void UpdateAtsPscPlFlagData(UINT8 pscId)
 		for(i = 0u; i < pscToCiDataStru[pscId].psdSum; i++)
 		{
 			/*获取屏蔽门确认标志*/
-			getPscPlFlag = GetPsdPlFlag(pscToCiDataStru[pscId].psdDataStr[i].psdId);
+			getPscPlFlag = GetPsdPscPlFlag(pscToCiDataStru[pscId].psdDataStr[i].psdId);
 			psdVirArr = GetPsdVirtualAttribute(pscToCiDataStru[pscId].psdDataStr[i].psdId);
 			if(CI_PSC_PL_CONFIRM_YES == getPscPlFlag)
 			{
@@ -2936,7 +2821,7 @@ UINT8 ProcessAtsOrXianDiToCiData(void)
 					OrderCheckReVal = CheckOrderWhetherDoing(virCiID,belongVirCIid,cmdType,CmdDeviceId);
 					if(CI_SUCCESS == OrderCheckReVal)
 					{
-						SetCommonRouteLogicManage(CmdDeviceId, ESEND_LEVEL_ATS);
+						SetCommonRouteLogicManage(CmdDeviceId);
 					}			
 				}
 				else
@@ -3618,7 +3503,7 @@ UINT8 ProcessAtsOrXianDiToCiData(void)
 				{
 					checkRetVal = AFFIRM_SUCCESS;
 					/*设置人工解锁保护区段*/
-					(void)LaborUnlockOverlapProc(CmdDeviceId);
+					(void)LaborUnlockOverlapProc((UINT8)CmdDeviceId);
 				}
 				else
 				{
@@ -4167,45 +4052,8 @@ UINT8 ProcessAtsOrXianDiToCiData(void)
 				}
 				break;
 			}
-				/*OC-P旁路一次命令*/
-			case ATS_CMD_OC_P_PL_ONE:
-				SetCiSendCmdBackData_OrderBack(commandId, CmdDeviceId, cmdDevType, terminalId, AtsOrXianDiToCiCmdStru[ii].CommandType, RESPONSE_FIRST, AFFIRM_SUCCESS, virCiID);
-				break;
-				/*OC-P旁路二次命令*/
-			case ATS_CMD_OC_P_PL_TWO:
-				checkRetVal = CheckSecondOrderValid(commandId, CmdDeviceId, cmdDevType, terminalId, AtsOrXianDiToCiCmdStru[ii].CommandType, virCiID);
-				if (CI_SUCCESS == checkRetVal)
-				{
-					/*设置OC-P旁路确认标志*/
-					SetOcPscPlConfirmFlag(OC_PSC_PL_CONFIRM_YES, CmdDeviceId);
-					SetCiSendCmdBackData_OrderBack(commandId, CmdDeviceId, cmdDevType, terminalId, AtsOrXianDiToCiCmdStru[ii].CommandType, RESPONSE_SECOND, AFFIRM_SUCCESS, virCiID);
-				}
-				else
-				{
-					/*清空一次确认命令ID*/
-					SetCiSendCmdBackData_OrderBack(commandId, CmdDeviceId, cmdDevType, terminalId, AtsOrXianDiToCiCmdStru[ii].CommandType, RESPONSE_SECOND, AFFIRM_FAIL, virCiID);
-				}
-				break;
 
-				/*取消OC-P旁路一次命令*/
+
-			case ATS_CMD_QUXIAO_OC_P_PL_ONE:
-				SetCiSendCmdBackData_OrderBack(commandId, CmdDeviceId, cmdDevType, terminalId, AtsOrXianDiToCiCmdStru[ii].CommandType, RESPONSE_FIRST, AFFIRM_SUCCESS, virCiID);
-				break;
-				/*取消OC-P旁路二次命令*/
-			case ATS_CMD_QUXIAO_OC_P_PL_TWO:
-				checkRetVal = CheckSecondOrderValid(commandId, CmdDeviceId, cmdDevType, terminalId, AtsOrXianDiToCiCmdStru[ii].CommandType, virCiID);
-				if (CI_SUCCESS == checkRetVal)
-				{
-					/*设置PSC旁路取消标志*/
-					SetOcPscPlConfirmFlag(OC_PSC_PL_CONFIRM_NO, CmdDeviceId);
-					SetCiSendCmdBackData_OrderBack(commandId, CmdDeviceId, cmdDevType, terminalId, AtsOrXianDiToCiCmdStru[ii].CommandType, RESPONSE_SECOND, AFFIRM_SUCCESS, virCiID);
-				}
-				else
-				{
-					/*清空一次确认命令ID*/
-					SetCiSendCmdBackData_OrderBack(commandId, CmdDeviceId, cmdDevType, terminalId, AtsOrXianDiToCiCmdStru[ii].CommandType, RESPONSE_SECOND, AFFIRM_FAIL, virCiID);
-				}
-				break;
 
 			default:
 				cFunRetVal = VirtualDevCmdProc(CmdDeviceId, AtsOrXianDiToCiCmdStru[ii].CommandType);/*试车线虚拟设备状态处理*/
@@ -4251,6 +4099,7 @@ UINT8 ProcessAtsOrXianDiToCiDataCld(void)
 	UINT16 terminalId = 0u;                           /*终端id*/
 	UINT16 ii = 0u;									/*游标*/
 	UINT8 checkRetVal = CI_FALSE;
+	UINT16 jkjRelayId = GetJkjRelayId();
 	UINT8 jkjRelayValidFlag = 0u;
 
 	UINT8 localCiId = 0u;        /*本地联锁ID*/
@@ -4294,7 +4143,7 @@ UINT8 ProcessAtsOrXianDiToCiDataCld(void)
 
 	jkjRelayValidFlag = GetCiJkjFlag();
 	/*应急盘继电器有效状态*/
-	if (JKJ_REYLAY_VALID == jkjRelayValidFlag)
+	if ((jkjRelayId > 0u) && (JKJ_REYLAY_VALID == jkjRelayValidFlag))
 	{
 		for (ii = 0u; ii < AtsToCiCmdSum; ii++)
 		{
@@ -4311,7 +4160,7 @@ UINT8 ProcessAtsOrXianDiToCiDataCld(void)
 				SetCiSendCmdBackData_OrderBack(commandId,CmdDeviceId,cmdDevType,terminalId,AtsToCiCmdStru[ii].CommandType,0u,0u,virCiID);
 
 				/*记录故障码*/
-				SetErrorData(EFUNC_PARSE_ATS2CI_DATA, CI_DEVICE_TYPE_RELAY, 0u, ETYPE_JKJ_WORK, RELAY_STATE_DOWN, ESEND_LEVEL_ATS);/*增加OC应急控功能，继电器ID填0*/
+				SetErrorData(EFUNC_PARSE_ATS2CI_DATA,CI_DEVICE_TYPE_RELAY,jkjRelayId,ETYPE_JKJ_WORK,RELAY_STATE_DOWN,ESEND_LEVEL_ATS);
 
 				/*清空CI接收命令数据队列*/
 				ClearCiRevCmdData();
@@ -4647,7 +4496,7 @@ UINT8 ProcessAtsOrXianDiToCiDataCld(void)
 			if(ATS_ROUTE_SET_PROCESS_MAX >= routeCmdSum)
 			{
 				/*办理普通进路*/
-				SetCommonRouteLogicManage(CmdDeviceId, ESEND_LEVEL_ATS);
+				SetCommonRouteLogicManage(CmdDeviceId);
 			}
 			else
 			{
@@ -5005,7 +4854,7 @@ UINT8 ProcessAtsOrXianDiToCiDataCld(void)
 			{
 				checkRetVal = AFFIRM_SUCCESS;
 				/*设置人工解锁保护区段*/
-				(void)LaborUnlockOverlapProc(CmdDeviceId);
+				(void)LaborUnlockOverlapProc((UINT8)CmdDeviceId);
 			}
 			else
 			{
@@ -5723,7 +5572,7 @@ void ProcessDeviceLogicState(void)
 		/*不做处理*/
 	}
 
-	if ((m_GdNum > 0u)|| ((AXIS_TYPE_YONGLIE==acFty)|| (AXIS_TYPE_KEANDA == acFty) || (AXIS_TYPE_FUHAOSHENG == acFty))) /*有轨道板或计轴网络接口*/
+	if ((m_GdNum > 0u)|| ((AXIS_TYPE_YONGLIE==acFty)|| (AXIS_TYPE_KEANDA == acFty))) /*有轨道板或计轴网络接口*/
 	{
 		/*更新轨道区段采集状态*/
 		OcPhyStateToDeviceStatePro();
@@ -6349,7 +6198,7 @@ void UpdatePhySectionMergeLogicState(void)
     UINT8 phySecOccuChangeTimeState = CI_TIME_OUT;
 	/*物理区段CT或UT占用状态，设置为(UT)占用状态*/
 	UINT8 curUtOrCtOccFlag = LOGICSECTION_OCCUPY_UT;	
-	UINT8 chPreUtOrCtOccFlag = LOGICSECTION_OCCUPY_UT;
+	UINT8 utOrCtOccFlag = LOGICSECTION_OCCUPY_UT;
 
 	UINT32 secOccupy2IdleTimeReal = 0u;
 	UINT32 secOccupy2IdleTimeSysPara = 0u;
@@ -6760,21 +6609,14 @@ void UpdatePhySectionMergeLogicState(void)
 				if(SECTION_OCCUPY_YES == phySecCurOccuState)
 				{
 					curUtOrCtOccFlag = GetPhySecCurCtOrUtOccupyState(phySectionId);	/*获取物理区段当前CT或UT占用状态*/
-					chPreUtOrCtOccFlag = GetPhySecPreOccState(phySectionId);				/*获取物理区段之前CT或UT占用状态*/
+					utOrCtOccFlag = GetPhySecPreOccState(phySectionId);				/*获取物理区段之前CT或UT占用状态*/
 					dwSecUtOrCtOccuCyc = GetSecUtOrCtOccuStartCycNum(phySectionId);
 					/*倒计时过程中，物理区段车占用状态发生变化，并且解锁已开始倒计时*/
-					if((chPreUtOrCtOccFlag != curUtOrCtOccFlag) && (0u != dwSecUtOrCtOccuCyc))
+					if((utOrCtOccFlag != curUtOrCtOccFlag) && (0u != dwSecUtOrCtOccuCyc))
-					{
-						if (LOGICSECTION_OCCUPY_NO != curUtOrCtOccFlag)
 					{
 						/*重新设置物理区段UT或CT占用开始时间*/
 						SetSecUtOrCtOccuStartCycNum(phySectionId, dwSystemCyc);
 					}
-						else
-						{
-							/*逻辑区段均空闲，物理区段尚未融合空闲，暂不更新*/
-						}
-					}
 					else if (LOGICSECTION_OCCUPY_UT == curUtOrCtOccFlag)
 					{
 						/*UT占压 ABL级别跳变 重新设置物理区段UT或CT占用开始时间*/
@@ -7009,10 +6851,10 @@ void UpdatePhySectionMergeLogicState(void)
 				if(SECTION_OCCUPY_YES == phySecCurOccuState)
 				{
 					curUtOrCtOccFlag = GetPhySecCurCtOrUtOccupyState(phySectionId);	/*获取物理区段当前CT或UT占用状态*/
-					chPreUtOrCtOccFlag = GetPhySecPreOccState(phySectionId);				/*获取物理区段之前CT或UT占用状态*/
+					utOrCtOccFlag = GetPhySecPreOccState(phySectionId);				/*获取物理区段之前CT或UT占用状态*/
 					dwSecUtOrCtOccuCyc = GetSecUtOrCtOccuStartCycNum(phySectionId);
 					/*倒计时过程中，物理区段车占用状态发生变化，并且解锁已开始倒计时*/
-					if((chPreUtOrCtOccFlag != curUtOrCtOccFlag) && (0u != dwSecUtOrCtOccuCyc))
+					if((utOrCtOccFlag != curUtOrCtOccFlag) && (0u != dwSecUtOrCtOccuCyc))
 					{
 						/*重新设置物理区段UT或CT占用开始时间*/
 						SetSecUtOrCtOccuStartCycNum(phySectionId, dwSystemCyc);
@@ -7878,11 +7720,14 @@ static UINT8 RouteReturnToThroughCondCheck(const UINT16 signalId,UINT8* toCiId)
 	UINT16 nextRouteId = 0u;     /*下一个进路*/
 	UINT8 returnRouteIdBelongCiId = 0u;
 	UINT8 throughRouteIdBelongCiId = 0u;
+	UINT8 returnRouteDirection = 0u;
 	UINT16 reRouteNormalLockPhy = 0u;
 	UINT8 phyMergeState = 0u;
 	UINT16 nextRouteLockPhy = 0u;
-	UINT16 wEndSignalId = 0U;/*折返进路的终端信号机*/
+	UINT8 nextRouteDirection = 0u;
-	UINT16 wStartSignalId = 0U;/*待信号特开进路的始端信号机*/
+	UINT8 haveDirChangeAfterRoute = 0u;
+	UINT8 haveDirChangeInRoute = 0u;
+
 	if ((0u == signalId) || (signalId >= SIGNAL_SUM_MAX))
 	{
 		retVal = CI_ERROR;
@@ -7906,8 +7751,6 @@ static UINT8 RouteReturnToThroughCondCheck(const UINT16 signalId,UINT8* toCiId)
 
 		returnRouteId = GetPhySecRLockBelongRouteId(signalOutSecId);
 		nextRouteId = GetPhySecRLockBelongRouteId(signalInSecId);
-		wEndSignalId = GetRouteEndSignalId(returnRouteId);/*获取终端信号机*/
-		wStartSignalId = GetRouteStartSignalId(nextRouteId);/*待办理信号特开的进路始端信号机*/
 		throughRouteId = GetRouteThroughRouteId(returnRouteId);
 		returnRouteIdBelongCiId = GetRouteBelongCiId(returnRouteId);
 		throughRouteIdBelongCiId = GetRouteBelongCiId(throughRouteId);
@@ -7935,9 +7778,32 @@ static UINT8 RouteReturnToThroughCondCheck(const UINT16 signalId,UINT8* toCiId)
 			/*下一进路第一区段锁闭*/
 			if (PHYSICAL_SECTION_LOCK_NORMAL == nextRouteLockPhy)
 			{
+				/*获取锁闭进路*/
+				nextRouteDirection = GetRouteDirection(nextRouteId);
+				returnRouteDirection = GetRouteDirection(returnRouteId);
 
-				/*信号机正确*/
+				haveDirChangeAfterRoute = GetRouteHaveDirChangePointAfter(returnRouteId);
-				if(wEndSignalId == wStartSignalId)
+				haveDirChangeInRoute = GetRouteHaveDirChangePointIn(returnRouteId);
+
+				/*进路后方或进路内存在方向变化点*/
+				if((ROUTE_HAVE_DIR_CHANGE_POINT == haveDirChangeAfterRoute) || 
+					(ROUTE_HAVE_DIR_CHANGE_POINT == haveDirChangeInRoute))
+				{
+					if(CI_SYSTEM_DIRECTION_UP == returnRouteDirection)
+					{
+						returnRouteDirection = CI_SYSTEM_DIRECTION_DOWN;
+					}
+					else if(CI_SYSTEM_DIRECTION_DOWN == returnRouteDirection)
+					{
+						returnRouteDirection = CI_SYSTEM_DIRECTION_UP;
+					}
+					else
+					{
+						/*不做处理*/
+					}
+				}
+				/*方向相同*/
+				if(nextRouteDirection == returnRouteDirection)
 				{
 					if(0u != throughRouteId)
 					{/*returnRouteId和throughRouteId都不等于0u，说明returnRouteId确实是折返进路，throughRouteId是通过进路，且此时折返还未变成通过进路*/
@@ -7991,16 +7857,18 @@ static UINT8 RouteReturnToThroughCmdProc(const UINT16 signalId,const UINT8 fromC
 	UINT8 returnRouteState = 0u;
 	UINT8 returnRouteIdBelongCiId = 0u;
 	UINT8 throughRouteIdBelongCiId = 0u;
+	UINT8 returnRouteDirection = 0u;
 	UINT16 reRouteNormalLockPhy = 0u;
 	UINT8 phyMergeState = 0u;
 	UINT16 nextRouteLockPhy = 0u;
 	UINT16 lockPhyBelongRoute = 0u;
+	UINT8 nextRouteDirection = 0u;
+	UINT8 haveDirChangeAfterRoute = 0u;
+	UINT8 haveDirChangeInRoute = 0u;
 	UINT8 saveReRouteDir = 0u;
 	UINT8 throughRouteDir = 0u;
 	UINT16 wLastLgcSecId = 0U;
 	UINT8 chTrainSum = 0u;
-	UINT16 wEndSignalId = 0U;/*折返进路的终端信号机*/
-	UINT16 wStartSignalId = 0U;/*待信号特开进路的始端信号机*/
 	LogicTrainResStruct * pstLgcResInfo = NULL;
 	LogicTrainResStruct stTmpResInfo[LOGIC_SECTION_RES_SUM_MAX] = { 0U };
 
@@ -8027,8 +7895,6 @@ static UINT8 RouteReturnToThroughCmdProc(const UINT16 signalId,const UINT8 fromC
 		returnRouteId = GetPhySecRLockBelongRouteId(signalOutSecId);
 		nextRouteId = GetPhySecRLockBelongRouteId(signalInSecId);
 		throughRouteId = GetRouteThroughRouteId(returnRouteId);
-		wEndSignalId = GetRouteEndSignalId(returnRouteId);
-		wStartSignalId = GetRouteStartSignalId(nextRouteId);
 		returnRouteIdBelongCiId = GetRouteBelongCiId(returnRouteId);
 		throughRouteIdBelongCiId = GetRouteBelongCiId(throughRouteId);
 
@@ -8056,11 +7922,34 @@ static UINT8 RouteReturnToThroughCmdProc(const UINT16 signalId,const UINT8 fromC
 			{
 				/*获取锁闭进路*/
 				lockPhyBelongRoute = GetPhySecRLockBelongRouteId(signalInSecId);
-				saveReRouteDir = GetRouteDirection(returnRouteId);/*保存进路实际方向*/
+				nextRouteDirection = GetRouteDirection(lockPhyBelongRoute);
+				returnRouteDirection = GetRouteDirection(returnRouteId);
 				throughRouteDir = GetRouteDirection(throughRouteId); /*折返进路对应的通过进路方向*/
 
-				/*检查信号机一致*/
+				haveDirChangeAfterRoute = GetRouteHaveDirChangePointAfter(returnRouteId);
-				if(wEndSignalId == wStartSignalId)
+				haveDirChangeInRoute = GetRouteHaveDirChangePointIn(returnRouteId);
+
+				saveReRouteDir = returnRouteDirection; /*保存进路实际方向*/
+
+				/*进路后方或进路内存在方向变化点*/
+				if((ROUTE_HAVE_DIR_CHANGE_POINT == haveDirChangeAfterRoute) || 
+					(ROUTE_HAVE_DIR_CHANGE_POINT == haveDirChangeInRoute) )
+				{
+					if(CI_SYSTEM_DIRECTION_UP == returnRouteDirection)
+					{
+						returnRouteDirection = CI_SYSTEM_DIRECTION_DOWN;
+					}
+					else if(CI_SYSTEM_DIRECTION_DOWN == returnRouteDirection)
+					{
+						returnRouteDirection = CI_SYSTEM_DIRECTION_UP;
+					}
+					else
+					{
+						/*不做处理*/
+					}
+				}
+				/*方向相同*/
+				if(nextRouteDirection == returnRouteDirection)
 				{
 					/*清除折返进路*/
 					returnRouteState = GetRouteState(returnRouteId);
@@ -8788,7 +8677,7 @@ static void ProcessTctCiCmd(void)
 				case  CI_CMD_UNLOCK_OVERLAP_CMD:/*处理相邻联锁发送的解锁保护区段命令*/
 					deviceId = CiRecvCiCmdStru[ii].Param1;/*保护区段 id*/
 					/*设置人工解锁保护区段*/
-					(void)LaborUnlockOverlapProc(deviceId);
+					(void)LaborUnlockOverlapProc((UINT8)deviceId);
 
 					break;
 #if 0
@@ -9578,18 +9467,6 @@ UINT8 CheckIsGeneralOrder(UINT8 OrderType)
 	case ATS_CMD_SWITCH_FANWEI_TEST_TWO:
 		reVal = CI_ERROR;
 		break;
-	case ATS_CMD_OC_P_PL_ONE:
-		reVal = CI_ERROR;
-		break;
-	case ATS_CMD_OC_P_PL_TWO:
-		reVal = CI_ERROR;
-		break;
-	case ATS_CMD_QUXIAO_OC_P_PL_ONE:
-		reVal = CI_ERROR;
-		break;
-	case ATS_CMD_QUXIAO_OC_P_PL_TWO:
-		reVal = CI_ERROR;
-		break;
 	default:
 		reVal = CI_SUCCESS;
 		break;
@@ -10129,8 +10006,6 @@ static void IvocInputRefreshTrain(const VobcToCiDataStruct stIvocToCiData)
 		SetHeadITEResult(wTrainId, stIvocToCiData.wHeadITEResult);
 		SetTailAxisId(wTrainId, stIvocToCiData.wTailAxisId);
 		SetTailITEResult(wTrainId, stIvocToCiData.wTailITEResult);
-		SetTrainJumpBackApplyState(wTrainId, stIvocToCiData.chJumpBackApply);
-		SetTrainJumpBackApplySN(wTrainId, stIvocToCiData.dwJumpBackSn);
 	}
 	else
 	{
@@ -10645,8 +10520,6 @@ static void IvocInputCmdProc(const VobcToCiDataStruct stIvocToCiData)
 			/*不存在区间疏散命令*/
 			SetTrainEaCmdState(wTrainId, TRAIN_EA_CMD_STATE_INVALID);
 		}
-
-
 #if 0
 		/**跳跃锁闭驱动道岔功能开关打开，处理同一物理区段多逻辑区段申请跳跃锁闭错误*/
 		if (FUNC_SWITCH_ON == funcSwitchJumpLockDriveSwitch)
@@ -10706,7 +10579,6 @@ static void ProcessIvocLoseCom(const VobcToCiDataStruct stIvocToCiData)
 	UINT8 chLjkExistDBSwitch = 0U;
 	UINT8 chVirHeadScreenPassFlag = 0U;/*虚拟前筛标志*/
 	UINT8 chVirTailScreenPassFlag = 0U;/*虚拟后筛标志*/
-	UINT8 chTrainPosMonitorState = 0U; /*列车位置监督标志*/
 
 #if 0
 	UINT32 dwRecvIvocCount = 0U;
@@ -10750,12 +10622,10 @@ static void ProcessIvocLoseCom(const VobcToCiDataStruct stIvocToCiData)
 		/*有DB的线路，断通信清除虚拟筛选标志，有可疑可以继续向车或ATS申请原地筛选*/
 		chVirHeadScreenPassFlag = GetTrainVirHeadScreenPassFlag(wTrainId);
 		chVirTailScreenPassFlag = GetTrainVirTailScreenPassFlag(wTrainId);
-		chTrainPosMonitorState = GetTrainPosMonitorState(wTrainId);
 
 		if ((FUNC_SWITCH_OFF == chLjkExistDBSwitch)
 			|| (TRAIN_VIR_SCREEN_PASS_FLAG_INVALID == chVirHeadScreenPassFlag)
-			|| (TRAIN_VIR_SCREEN_PASS_FLAG_INVALID == chVirTailScreenPassFlag)
+			|| (TRAIN_VIR_SCREEN_PASS_FLAG_INVALID == chVirTailScreenPassFlag))
-			|| (TRAIN_POS_MONITOR_VALID != chTrainPosMonitorState))
 		{
 			/*有DB或有一端虚拟筛选标志是无效就清除两端的虚拟筛选*/
 			SetTrainVirHeadScreenPassFlag(wTrainId, TRAIN_VIR_SCREEN_PASS_FLAG_INVALID);
@@ -10773,12 +10643,6 @@ static void ProcessIvocLoseCom(const VobcToCiDataStruct stIvocToCiData)
 		SetTrainDerailment(wTrainId, TRAIN_DERAIL_NO);
 		/*通信中断设置区间疏散命令状态为无效*/
 		SetTrainEaCmdState(wTrainId, TRAIN_EA_CMD_STATE_INVALID);
-
-		/*通信中断设置向后跳跃未申请和序列号为0*/
-		SetTrainJumpBackApplyState(wTrainId, TRAIN_JUMP_BACK_STATE_INVALID);
-		SetTrainJumpBackApplySN(wTrainId, 0U);
-
-		SetTrainFlyProStartCycNum(wTrainId, 0U);  /*通信中断后，清除飞车起始周期号*/
 	}
 }
 
@@ -11778,7 +11642,7 @@ void UpdateHumidRailFlag(void)
 	UINT16 wPhySecId = 0U;
 	UINT8 cAllHumidRailState = CI_ALL_SNOW_UNVALID;  /*集中区湿轨状态*/
 	UINT8 cAreaHumidRailNum = 0U;  /*区间湿轨数量*/
-	AreaSnowInfoStruct* pAreaHumidRailData = NULL;
+	UINT32* pAreaHumidRailId = NULL;
 	ToCiAreaSnowStruct* pRecvCiAreaHumidRail = NULL;  /*相邻联锁发送的区间湿轨信息*/
 	UINT16 wCurSignalNum = 0U;
 	UINT16 wSignalId = 0U;
@@ -11815,13 +11679,13 @@ void UpdateHumidRailFlag(void)
 		{
 			/*** 处理本集中区的区间湿轨 ***/
 			cAreaHumidRailNum = GetLocalAreaSnowNum();
-			pAreaHumidRailData = GetLocalAreaSnow();
+			pAreaHumidRailId = GetLocalAreaSnowId();
-			if ((0U != cAreaHumidRailNum) && (LOCAL_AREA_SNOW_SUM_MAX >= cAreaHumidRailNum) && (NULL != pAreaHumidRailData))
+			if ((0U != cAreaHumidRailNum) && (LOCAL_AREA_SNOW_SUM_MAX >= cAreaHumidRailNum) && (NULL != pAreaHumidRailId))
 			{
 				/*本集中区存在区间湿轨，将其中属于本控区的物理区段湿轨标志置为有效*/
 				for (jj = 0U; jj < cAreaHumidRailNum; jj++)
 				{
-					SetPlatFormRelPSHumidRailFlag(pAreaHumidRailData[jj].wAreaId);
+					SetPlatFormRelPSHumidRailFlag(pAreaHumidRailId[jj]);
 				}
 			}
 			else
@@ -11838,7 +11702,7 @@ void UpdateHumidRailFlag(void)
 					/*相邻控区的区间湿轨覆盖有本控区的物理区段，将其中属于本控区的物理区段湿轨标志置为有效*/
 					for (jj = 0U; jj < pRecvCiAreaHumidRail[ii].cPlatFormNum; jj++)
 					{
-						SetPlatFormRelPSHumidRailFlag(pRecvCiAreaHumidRail[ii].szPlatFormInfo[jj].wAreaId);
+						SetPlatFormRelPSHumidRailFlag(pRecvCiAreaHumidRail[ii].dwPlatFormId[jj]);
 					}
 				}
 			}
@@ -12336,221 +12200,3 @@ void OtherPartRouteCleanLogRouteProc(const UINT16 wCurRouteId)
 		/*入参非法，不处理*/
 	}
 }
-
-/*
-* 功能描述：处理OC->CI的PSD数据
-* 参数说明： void
-* 返回值  ： void
-*/
-void ProcessOCToCiPsdData(void)
-{
-	UINT8 deviceOcSum = 0u;/*通信oc总数*/
-	UINT8* deviceIdBuf = NULL;/*通信设备ID数组*/
-	UINT8 ocId = 0u;
-	UINT8 deviceSum = 0u;/*oc发送psd设备总数*/
-	UINT16 ocToCiPsdId = 0u;/*psd id*/
-	UINT16 ii = 0u;
-	UINT16 jj = 0u;
-	UINT16 kk = 0u;
-	UINT8 findOcFlag = 0u;
-
-	deviceOcSum = GetCiTransmitSpecifySysDevSum(CI_SYSTEM_TYPE_OC);     /*获取通信OC设备总数*/
-	deviceIdBuf = GetCiTransmitSpecifySysDevBuf(CI_SYSTEM_TYPE_OC); /*获取通信OC设备ID数组*/
-	
-	for (ii = 0u; ii < deviceOcSum; ii++)
-	{/*找到OC id*/
-		findOcFlag = 0u;
-		ocId = deviceIdBuf[ii];
-		if ((0u < ocId) && (OC_SUM_MAX > ocId))
-		{
-			for (kk = 0u; kk < m_OcToCiOrginDataNum; kk++)
-			{
-				/*找到OC id对应的数组下标kk*/
-				if (m_OcToCiOrginDataArr[kk].OcId == ocId)
-				{
-					findOcFlag = 1u;
-					break;
-				}
-			}
-			if (1u == findOcFlag)
-			{
-				deviceSum = m_OcToCiOrginDataArr[kk].OCPsdNum;     /*获取OC发的PSD设备总数*/
-				for (jj = 0u; jj < deviceSum; jj++)
-				{
-					ocToCiPsdId = m_OcToCiOrginDataArr[kk].PsdInfo[jj].wPsdId;	/*psd id*/
-					if (0u < ocToCiPsdId)
-					{
-						/*屏蔽门开关状态更新*/
-						if (PSD_STATE_CLOSE_VIETNAM == m_OcToCiOrginDataArr[kk].PsdInfo[jj].OpenOrCloseState)
-						{
-							/*关门*/
-							(void)SetPsdState(ocToCiPsdId, PSD_STATE_CLOSE);
-						}
-						else if (PSD_STATE_OPEN_VIETNAM == m_OcToCiOrginDataArr[kk].PsdInfo[jj].OpenOrCloseState)
-						{
-							/*开门*/
-							(void)SetPsdState(ocToCiPsdId, PSD_STATE_OPEN);
-						}
-						else
-						{/*屏蔽门开关状态默认开门*/
-							(void)SetPsdState(ocToCiPsdId, PSD_STATE_OPEN);
-						}
-
-						/*互锁解除状态*/
-						if (PSD_MUTUALLOCK_REMOVE_YES == m_OcToCiOrginDataArr[kk].PsdInfo[jj].InterlockRelState)
-						{
-							/*互锁解除*/
-							(void)SetPsdMutualLockRemoveState(ocToCiPsdId, PSD_MUTUALLOCK_REMOVE_YES);
-						}
-						else if (PSD_MUTUALLOCK_REMOVE_NO == m_OcToCiOrginDataArr[kk].PsdInfo[jj].InterlockRelState)
-						{
-							/*未互锁解除*/
-							(void)SetPsdMutualLockRemoveState(ocToCiPsdId, PSD_MUTUALLOCK_REMOVE_NO);
-						}
-						else
-						{
-							(void)SetPsdMutualLockRemoveState(ocToCiPsdId, PSD_MUTUALLOCK_REMOVE_NO);
-						}
-
-						/*开门故障状态*/
-						SetOpenErrState(ocToCiPsdId, m_OcToCiOrginDataArr[kk].PsdInfo[jj].OpenErrState);
-
-						/*关门故障状态*/
-						SetCloseErrState(ocToCiPsdId, m_OcToCiOrginDataArr[kk].PsdInfo[jj].CloseErrState);
-
-						/*单扇门故障隔离信息*/
-						SetPsdFaultQState(ocToCiPsdId, m_OcToCiOrginDataArr[kk].PsdInfo[jj].psdFaultQStataOne, m_OcToCiOrginDataArr[kk].PsdInfo[jj].psdFaultQStataTwo);
-
-						/*单扇门开关状态*/
-						SetPsdDoorState(ocToCiPsdId, m_OcToCiOrginDataArr[kk].PsdInfo[jj].psdDoorsStateOne, m_OcToCiOrginDataArr[kk].PsdInfo[jj].psdDoorsStateTwo);
-
-						/*单扇门被隔离信息*/
-						SetPsdDoorIState(ocToCiPsdId, m_OcToCiOrginDataArr[kk].PsdInfo[jj].psdDoorIStateOne, m_OcToCiOrginDataArr[kk].PsdInfo[jj].psdDoorIStateTwo);
-
-						/*障碍物报警状态（预留）*/
-					}
-					else
-					{
-						/*psd id无效，不处理*/
-					}
-				}
-			}
-		}
-		else
-		{
-			/*oc id无效，不处理*/
-		}
-	}
-	
-}
-
-
-/*
-* 功能描述： 处理OC到CI的不一致继电器数据
-* 参数说明： void
-* 返回值  ： 0:处理失败
-*			 1:处理成功
-*/
-void ProcessOcToCiRelayDiffData(void)
-{
-	UINT8 i = 0u;
-	UINT8 j = 0u;
-	UINT8 k = 0u;
-	UINT16 ocId = 0u;
-	CollBoardData* pTempCollBoardData_ForProcess = NULL;
-	UINT8 BoardAddress_ForProcess = 0u;								/*板卡地址*/
-	UINT8 BoardAddress_ForProcessOther = 0u;						/*对系板卡地址*/
-	UINT8 cBoardState = RELAY_BOARD_FAULT_YES;						/*板卡状态初始化为故障*/
-	UINT8 cBoardStateOther = RELAY_BOARD_FAULT_YES;					/*对系板卡状态初始化为故障*/
-	UINT8 PosValue_ForProcess = 0u;									/*采集继电器当前地址的采集点数值:吸起、落下*/
-	UINT8 PosValue_ForProcessOther = 0u;							/*采集继电器对系地址的采集点数值:吸起、落下*/
-	UINT32 pointTolerateCyc = 0u;									/*点位不一致容忍周期*/
-	UINT8 timeState = 0U;
-	UINT32 curCycNum = 0u;
-
-	IODiffDataStruct* pTempIODiffData = NULL;				 /*记录点位采集不一致*/
-	curCycNum = Get2oo2CurCycleNum();
-
-	(void)CommonMemSet(&IODiffDataStru, (UINT32)((OC_SUM_MAX) * sizeof(IODiffDataStruct)), 0U, (UINT32)((OC_SUM_MAX) * sizeof(IODiffDataStruct)));		/*先清空结构体*/
-	gDiffDataOcNum = 0u;
-
-	pTempIODiffData = GetIODiffData();
-	if (NULL != pTempIODiffData)
-	{
-		for (i = 0u; i < OC_SUM_MAX; i++)                        /*指定ID继电器所属联锁ID*/
-		{
-			if (LocalOcIds[i] > 0u)/*oc id 有效*/
-			{
-				ocId = LocalOcIds[i];
-				if (OC_SUM_MAX > ocId)
-				{
-					pTempCollBoardData_ForProcess = m_OcConvertedPtDataArr[ocId].BoardDatas;
-					for (j = 0u; j < m_OcConvertedPtDataArr[ocId].OcBoardNum; j += 2u)/*遍历所有的OC板卡*/
-					{
-						BoardAddress_ForProcess = pTempCollBoardData_ForProcess[j].BoardAddress;/*板卡地址*/
-						BoardAddress_ForProcessOther = pTempCollBoardData_ForProcess[j + 1u].BoardAddress;/*对系板卡地址*/
-
-						cBoardState = pTempCollBoardData_ForProcess[j].BoardState;  /*板卡状态*/
-						cBoardStateOther = pTempCollBoardData_ForProcess[j + 1u].BoardState;  /*对系板卡状态*/
-
-						if ((RELAY_BOARD_FAULT_NO == cBoardState)&&(RELAY_BOARD_FAULT_NO == cBoardStateOther))
-						{	
-							/*板卡非故障*/
-							for (k = 0u; k < (UINT8)OC_COLL_BOARD_POS_NUM; k++)
-							{
-								PosValue_ForProcess = pTempCollBoardData_ForProcess[j].PosValueBuf[k];/*点值：吸起、落下*/
-								PosValue_ForProcessOther = pTempCollBoardData_ForProcess[j + 1u].PosValueBuf[k];/*对系板卡的点值*/
-
-								if (PosValue_ForProcess != PosValue_ForProcessOther)
-								{
-									/*不一致进行容忍*/
-									pointTolerateCyc = GetPointTolerateCycNum(ocId, j, k);/*该点位容忍周期*/
-									timeState = SystemOverTimeCheck(pointTolerateCyc, POINTTOLERATE_CYCNUM);
-									if (CI_TIME_NO == timeState) /*未计时，无容忍*/
-									{/*设置当前周期*/
-										SetPointTolerateCycNum(ocId, j, k, curCycNum);
-										debug_infor_printf((const)"IO Compare Diff Tolerate CycleNum = %d\n", curCycNum);
-									}
-									else if (CI_TIME_IN == timeState)/*容忍中*/
-									{/*不处理*/
-									}
-									else
-									{
-										/*点位采集不一致容忍超时，记录*/
-										pTempIODiffData[i].OcId = (UINT8)ocId;	/*OC ID*/
-										pTempIODiffData[i].LocalBoardAdd[pTempIODiffData[i].DiffPointNum] = BoardAddress_ForProcess;/*点位对应的板卡地址*/
-										pTempIODiffData[i].OtherBoardAdd[pTempIODiffData[i].DiffPointNum] = BoardAddress_ForProcessOther;/*对系板卡地址*/
-										pTempIODiffData[i].TheDiffPoint[pTempIODiffData[i].DiffPointNum] = k + 1u;/*不一致的点位*/
-										pTempIODiffData[i].DiffPointNum++;		/*点位数量*/
-									}
-								}
-								else
-								{/*该点位采集一致，清除容忍周期*/
-									SetPointTolerateCycNum(ocId, j, k, 0u);
-								}
-							}
-						}
-						else
-						{
-							/*板卡是故障，不记录，清除每个点位容忍周期*/
-							for (k = 0u; k < (UINT8)OC_COLL_BOARD_POS_NUM; k++)
-							{
-								SetPointTolerateCycNum(ocId, j, k, 0u);
-							}
-						}
-					}
-
-
-					if (0u != pTempIODiffData[i].DiffPointNum)
-					{/*该OC有点位不一致，不一致的OC数量加一*/
-						gDiffDataOcNum++;
-					}
-				}
-			}
-		}
-	}
-	else
-	{/*不处理*/
-	}
-	
-}

TSCP/src/APP/ciapp/IO/InputDataProcess.h

@@ -451,21 +451,6 @@ 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);
-
 #ifdef __cplusplus
 }
 #endif

TSCP/src/APP/ciapp/IO/OutputDataProcess.c

@@ -387,10 +387,6 @@ 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_SIG_START_OPEN_STATE:
 		if (SIGNAL_OPEN==deviceState  )
@@ -902,33 +898,6 @@ 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;
@@ -947,18 +916,14 @@ CI_SUCCESS
 */
 UINT8 CiToAtsBackInfoFunctionJudge(const UINT8 functionId,const UINT8 deviceType)
 {
-	UINT8 cRetVal = CI_ERROR;
+	if ((functionId > 0u) && (deviceType>0u) )
-
-	if ((functionId > 0U) && (deviceType>0U))
 	{
-		cRetVal = CI_SUCCESS;
+		return CI_SUCCESS;
 	}
 	else
 	{
-		cRetVal = CI_ERROR;
+		return CI_ERROR;
 	}
-
-	return cRetVal;
 }
 
 

TSCP/src/APP/ciapp/Indicator/IndicatorConfigDataManage.c

@@ -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,2000) 暂无使用*/
+UINT16 g_OCStationIndicatorCurSum = 0;   /*本联锁OC站（集中站和非集中站）指示器总数,不涉及主备跟随，取值范围0-1000*/
 
 
 

TSCP/src/APP/ciapp/Indicator/IndicatorDefine.h

@@ -14,7 +14,7 @@
 
 
 /*总数最大值*/
-#define INDICATOR_SUM_MAX              			       ((UINT16)2000)  /*指示器最大数量,每个联锁40个指示灯，总共按20个联锁 */
+#define INDICATOR_SUM_MAX              			       ((UINT16)1000)  /*指示器最大数量,每个联锁40个指示灯，总共按20个联锁 */
 #define INDICATOR_RELAY_SUM_MAX        			       ((UINT16)5)  /*指示器相关继电器最大数量*/
 #define RTNINDICATOR_SUM_MAX                           ((UINT8)2U)  /*一个虚拟联锁集中区无人折返最大数量*/
 

TSCP/src/APP/ciapp/Initial/ConfigDataReadManage.c

@@ -919,7 +919,7 @@ UINT8 ReadConfigureData(void)
 				g_ret = ReadEaConfigData(g_szEaConfig);
 				if (-1 == g_ret)
 				{
-					rtnVal = 40u;
+					rtnVal = 37u;
 					debug_infor_printf((const)"ReadEaConfigData errcode =%d, ReadEaConfigData", rtnVal);
 				}
 				else
@@ -1041,26 +1041,7 @@ UINT8 ReadConfigureData(void)
 				if (0 == g_ret)
 				{
 					debug_infor_printf((const)"PhySectionNearConfigDataManage Error\n");
-					rtnVal = 41u;
+					rtnVal = 37u;
-				}
-				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
 				{
@@ -1299,8 +1280,7 @@ UINT8 SetautoRouteOpposedRoute(UINT16 autoRouteRouteId,UINT8 routeType)
 	autoRouteSum = GetAutoRouteRouteCurSum();/*自动进路数目*/
 	autoReturnSum = GetAutoReturnRouteCurSum();/*自动折返进路数目*/
     allAutoReturnSum = GetAllAutoReturnRouteCurSum();/*全自动折返进路数目*/
-	if ((AUTO_ROUTE_SUM_MAX <= autoRouteSum) || (AUTO_RETURN_SUM_MAX<=autoReturnSum )
+	if ((autoRouteSum >= AUTO_ROUTE_SUM_MAX) || (autoReturnSum >= AUTO_RETURN_SUM_MAX))
-		||(ALL_AUTO_RETURN_SUM_MAX <= allAutoReturnSum))
 	{/*配置数据总数错误*/
 		returnValue = CI_ERROR;
 	}
@@ -3447,39 +3427,3 @@ 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

@@ -160,16 +160,6 @@ 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

@@ -586,7 +586,6 @@ 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;   /*取消扣车按钮有效标志*/
@@ -595,11 +594,7 @@ UINT8 InitialSignalData(void)
 			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;/*临时限速有效*/
 			
@@ -863,9 +858,6 @@ UINT8 InitialPhySectionData(void)
 		PhysicalSectionDataStru[ii].UtOrCtOccFlag = SECTION_OCCUPY_YES;
 		PhysicalSectionDataStru[ii].UtOrCtOccuStartCycNum = 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;
@@ -1371,19 +1363,6 @@ 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门关继电器落下起始周期*/
 	}
 	reVal = CI_SUCCESS;
 	return reVal;
@@ -1562,8 +1541,6 @@ 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;	/*设置自动信号取消命令无效*/
@@ -1591,11 +1568,6 @@ UINT8 InitialRouteData(void)
 				RouteDataStru[routeId].cRouteDrivedSGBJFlag = ROUTE_HAS_DRIVED_SGBJ_INVALID;      /*初始化进路未驱动过声光报警*/
 				RouteDataStru[routeId].chRouteNearSecSearchState = ROUTE_NEAR_SEC_HAVE_UT;      /*初始化进路接近区段查询状态为有故障车*/
 				RouteDataStru[routeId].chRouteApplySwitchCheckFlag = ROUTE_APPLY_SWITCH_CHECK_DEF;      /*初始化进路办理相邻控区道岔检查标志*/
-				RouteDataStru[routeId].OtherCiRecordDevID = 0U;
-				RouteDataStru[routeId].OtherCiRecordDevState = 0U;
-				RouteDataStru[routeId].OtherCiRecordDevType = 0U;
-				RouteDataStru[routeId].OtherCiRecordErrorType = 0U;
-				RouteDataStru[routeId].cRouteToLeadFlag = ROUTE_TO_LEAD_FLAG_NO;      /*初始化普通进路转引导进路标志为无效*/
 			}
 		}
 
@@ -2139,11 +2111,6 @@ 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
 		{
@@ -2256,7 +2223,6 @@ 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);
    	    }
 	}
 
@@ -2279,7 +2245,6 @@ 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异常打开*/
    	    }
 	}
 
@@ -2319,7 +2284,6 @@ void ResetDynamicState(const UINT8 ciId)
 			* 修改：在进路空闲等状态下。通信中断需要进路置成安全状态
 			* 修改20160511：增加自动解锁正常、自动解锁异常两种进路状态不置安全态，
 			当进路状态为自动解锁正常、自动解锁异常置安全态后，进路的保护区段无法解锁
-			* 修改：保留进路状态，避免空闲进路清零后，本联锁始端信号机为终端信号机的折返进路状态非法
 			*/
 			throughRtId = GetRouteThroughRouteId(devId);
 			OverlapLockedId = GetRouteOverlapLockedId(devId);
@@ -2338,7 +2302,6 @@ 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;
 			}
@@ -2692,7 +2655,6 @@ 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++)
@@ -2709,7 +2671,6 @@ void ResetDynamicStateHlht(const UINT8 ciId)
 			/*设置道岔当前位置 【挤岔】*/
 			SwitchDataStru[devId].SwitchCurPosition = SWITCH_POSITION_JICHA;		/*道岔当前位置*/
 			SwitchDataStru[devId].SingleSwitchCurPosition = SWITCH_POSITION_JICHA;	/*单独道岔当前位置*/
-			SwitchDataStru[devId].LockStatus = SWITCH_LOCK_STATUS_NO;
 		}
 	}
 
@@ -2731,7 +2692,6 @@ 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;
 		}
 	}
 
@@ -2815,17 +2775,6 @@ 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; /*自动进路未办理*/
-		}
-	}
 }
 
 /*
@@ -2850,7 +2799,6 @@ 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;
 			}
 
 		}

TSCP/src/APP/ciapp/InvadeSection/InvadeSectionDefine.h

@@ -14,7 +14,7 @@
 #ifndef __INVADESECTION_DEFINE_H_
 #define __INVADESECTION_DEFINE_H_
 
-#define INVA_SECT_N_COND_SWIT_SUM_MAX ((UINT16)400)	/*侵限区段与相关条件道岔数据条目最大数量*/
+#define INVA_SECT_N_COND_SWIT_SUM_MAX ((UINT16)300)	/*侵限区段与相关条件道岔数据条目最大数量*/
 
 #define COND_SWITCH_SUM_MAX ((UINT16)16)				/*单一侵限区段与相关条件道岔数据条目内,条件道岔最大数量*/
 

TSCP/src/APP/ciapp/LogRecord/LogRecord.c

@@ -526,13 +526,6 @@ 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].PhySecPreResetState;/*计轴预复位状态*/
-				outString[outStringLength++] = newPhysicalSectionData[deviceId].chPreResetBack;/*预复位命令反馈*/
-				outString[outStringLength++] = newPhysicalSectionData[deviceId].chDirectResetRst;/*直接复位结果*/
-				outString[outStringLength++] = newPhysicalSectionData[deviceId].chDirectResetBack;/*直接复位命令反馈*/
 				outString[outStringLength++] = newPhysicalSectionData[deviceId].StopSteadyFlag;/*停稳状态信息*/
                 outString[outStringLength++] = newPhysicalSectionData[deviceId].ArbState;/*ARB状态*/
 				outString[outStringLength++] = newPhysicalSectionData[deviceId].ProtectSecLockDelayTimeFlag;/*保护区段锁闭延时标志(动态字段)*/
@@ -551,6 +544,8 @@ 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*/
@@ -563,8 +558,6 @@ 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;
             }
         }
     }
@@ -659,7 +652,6 @@ 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;/*绿黄灯丝断丝标志状态*/
@@ -691,10 +683,8 @@ 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]);  /*扣车按钮1按下周期*/
+				LongToChar(newSignalData[deviceId].DetainBtnPressCycNum, &outString[outStringLength]);  /*扣车按钮按下周期*/
 				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]); /*取消扣车按钮误触发按下周期*/
@@ -703,16 +693,6 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 				outStringLength += 2u;
 				outString[outStringLength++] = newSignalData[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
@@ -782,7 +762,6 @@ 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：通信异常落下*/
@@ -792,12 +771,6 @@ 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
@@ -1021,9 +994,7 @@ 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;
@@ -1557,11 +1528,8 @@ 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
 		{
@@ -2029,8 +1997,7 @@ 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
@@ -2048,7 +2015,7 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
 	else
 	{
 #ifdef PLATFORM_2OO2
-		debug_infor_printf((const)"\nSpksData:%d\nspksId(2)-status-cutStatus-flockStartNum(4)-TotalSpksDriveOutDis:%d", (UINT16)sizeof(SpksDataStruct), outStringLength);
+		debug_infor_printf((const)"\nSpksData:%d\spksId(2)-status-cutStatus-flockStartNum(4)-TotalSpksDriveOutDis:%d", (UINT16)sizeof(SpksDataStruct), outStringLength);
 
 		debug_out_array(0xAA, outString, outStringLength);
 #endif		
@@ -2148,9 +2115,6 @@ 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;
 

TSCP/src/APP/ciapp/LogicManage/InterlockCommonManage.c

@@ -1379,7 +1379,6 @@ 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);
@@ -1397,7 +1396,6 @@ void RouteRecoverOpenProc(const UINT16 routeId)
 				errType = RecoverOpenRouteCheckCLD(routeId);
 			}
 			
-			wStartSignalId = GetRouteStartSignalId(routeId);  /*获取进路始端信号机ID*/
 			if (errType == CI_SUCCESS)
 			{
 				SetRouteOpenSigStartCycNum(routeId, Get2oo2CurCycleNum());
@@ -1412,9 +1410,6 @@ void RouteRecoverOpenProc(const UINT16 routeId)
 			else
 			{
 				SetRouteRecoverState(routeId, ROUTE_RECOVER_STA_STAY);/*一旦出现PSD、SPKS、扣车以外的条件不满足，将进路恢复状态设置为不可恢复*/
-
-				/*开放条件检查失败，设置对应始端信号机扣车旁路按钮无效*/
-				SetDetCutBtnState(wStartSignalId, SIGNAL_DETAIN_CUT_VALID_NO);
 			}
 		}
 	}

TSCP/src/APP/ciapp/LogicManage/InterlockCommonManage.h

@@ -41,7 +41,6 @@
 #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.h

@@ -365,11 +365,9 @@ 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, const UINT8 chSendLevel);
+void SetCommonRouteLogicManage(const UINT16 routeId);
 
 /*
 * 功能描述： 办理引导进路逻辑管理
@@ -949,7 +947,7 @@ UINT8 CheckPhysecFlockReasonSpksId(const UINT16 phySectionId, UINT16* spksId, UI
 *                   
 *修改：mpt 2022年3月9日 增加保护区段人工解锁逻辑
 */
-UINT8 LaborUnlockOverlapProc(const UINT16 overlapId);
+UINT8 LaborUnlockOverlapProc(const UINT8 overlapId);
 /*
 * 功能描述： 设置联锁锁闭保护区段标志管理
 * 参数说明： const UINT16 routeId, 进路ID
@@ -1133,29 +1131,6 @@ 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 20250617
-*/
-void OverlapZhaoChaRelayUpDateManage(void);
-/*
-* 功能描述： 更新列车向后跳跃允许状态处理
-* 参数说明： 无
-* 返回值  ： 无
-* Create: fan 20250725
-*/
-void TrainJumpBackApplyProc(void);
-
 #ifdef __cplusplus
 }
 #endif

TSCP/src/APP/ciapp/LogicManage/RouteRecoverManage.c

@@ -3011,9 +3011,10 @@ UINT8 RecoverOpenRouteCheckCLD(const UINT16 routeId)
 	UINT8 routeType = 0u;          /*进路类型*/
 	UINT8 errType = CI_ERROR;/*定义检查失败时的错误类型*/
 	UINT8 jkjRelayValidFlag = 0u; /*初始化应急盘继电器有效状态*/
+	UINT16 jkjRelayId = GetJkjRelayId();
 	jkjRelayValidFlag = GetCiJkjFlag();	
 	routeType = GetRouteType(routeId);                /*获取进路类型*/
-	if (JKJ_REYLAY_VALID == jkjRelayValidFlag)
+	if ((jkjRelayId > 0u) && (JKJ_REYLAY_VALID == jkjRelayValidFlag))
 	{/*应急盘继电器有效状态,不允许信号重开*/
 		errType = CI_ERROR;
 	}
@@ -3796,23 +3797,6 @@ 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
 	{
@@ -4667,11 +4651,14 @@ static UINT8 RouteRelayZhaoChaErrCheck(UINT16 const routeId)
 	UINT8 retVal = CI_ERROR;                      /*函数返回值*/
 	UINT16 pDevId = 0U;
 	UINT8 pDevState = 0U;
+	UINT8 chRouteLevel = 0U;
 	UINT8 chErrTemp = 0U;
 
     /* 对端照查检查 */
     zcPhySecSum = GetRouteThatZhaoChaPhySecSum(routeId);              /*获取照查物理区段数目*/
 	pZcPhySecIdBuf = GetRouteThatZhaoChaPhySecIdBuf(routeId);       /*获取照查物理区段ID数组*/
+	/*进路监督级别确认*/
+	chRouteLevel = GetRouteLevel(routeId);
 
 	if (NULL == pZcPhySecIdBuf)
 	{
@@ -4706,8 +4693,19 @@ static UINT8 RouteRelayZhaoChaErrCheck(UINT16 const routeId)
 
     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);               /*获取进路状态*/
 
@@ -4715,25 +4713,18 @@ static UINT8 RouteRelayZhaoChaErrCheck(UINT16 const routeId)
 		{/*存在本端照查继电器*/
 			if ((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_DELAY_UNLOCK == routeState) ||
+				(ROUTE_STATE_NEAR_OPEN == routeState) ||
-				(ROUTE_STATE_AUTO_UNLOCK == routeState) ||
+				(ROUTE_STATE_YUXIAN_OPEN == 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)
 				{
 					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)
 				{
@@ -4751,8 +4742,18 @@ static UINT8 RouteRelayZhaoChaErrCheck(UINT16 const routeId)
 
     if ((CI_SUCCESS == retVal) || (CI_ROUTE_RECOVER_ERR == retVal))
 	{/*本端照查继电器检查通过，检查对端照查继电器*/
-
+		if (ROUTE_LEVEL_BLOC == chRouteLevel)
-		relayId = GetRouteThatZhaoChaRelayId(routeId); /*对端照查继电器ID*/
+		{
+			relayId = GetRouteThatZhaoChaRelayId(routeId); /*后备模式对端照查继电器ID*/
+		}
+		else if (ROUTE_LEVEL_CBTC == chRouteLevel)
+		{
+			relayId = GetRouteCbtcThatZhaoChaRelayId(routeId);/*CBTC模式对端照查继电器ID*/
+		}
+		else
+		{
+			; /*非法监督模式，继电器ID为0，在下面不会处理*/
+		}
 
 		 if(0u != relayId)
 		 {/*存在对端照查继电器*/
@@ -4772,6 +4773,7 @@ static UINT8 RouteRelayZhaoChaErrCheck(UINT16 const routeId)
 	}
 
 	return retVal;
+
 }
 
 /*

TSCP/src/APP/ciapp/LogicManage/TradInterlockLogicManage.c

@@ -50,116 +50,58 @@ void JKJRelayLogicProcess(void)
 {
 	UINT16 wJkjRelayId = 0u;
 	UINT8 JkjRelayState = CI_ERROR;
-	UINT32 yjValidCycNum = 0u;
+	UINT32 JkjRelayCycNum = 0u;
+	UINT32 JkjValidCycNum = 0u;
 	UINT32 curCycNum = 0u;
 	UINT8 checkRes = CI_TIME_OUT;
-	UINT8 ii = 0u;
+	UINT8 tmpRet =CI_ERROR;
-	UINT8 haveYjkBreakFlag = 0u;
-	UINT8 ocYjkBreakFlag = 0u;
 
 	wJkjRelayId = GetJkjRelayId();
 	JkjRelayState =	GetRelayCollState(wJkjRelayId);                 /*JKJ应急盘继电器采集状态*/
-	yjValidCycNum = GetJkjRelayValidCycNum();                     /*JKJ应急盘状态有效周期*/
+	JkjRelayCycNum = GetRelayStateUpdateCycNum(wJkjRelayId);        /*JKJ应急盘继电器状态更新周期*/
+	JkjValidCycNum = GetJkjRelayValidCycNum();                     /*JKJ应急盘状态有效周期*/
+
+
+
+	if ((wJkjRelayId > 0u) && (RELAY_STATE_DOWN == JkjRelayState))
+	{
 		curCycNum = Get2oo2CurCycleNum();
-	
+		if (0u == JkjRelayCycNum)
-	for (ii = 0u; ii < m_OcToCiOrginDataNum; ii++)
+		{/*若未计时，则设置起始周期*/
+			tmpRet = SetRelayStateUpdateCycNum(wJkjRelayId,curCycNum);
+			if (CI_ERROR == tmpRet)
 			{
-		if (OC_HAVE_YJK == m_OcToCiOrginDataArr[ii].chHaveYjk)
+				/*错误处理*/
-		{/*任意一个OC具备应急控*/
-			haveYjkBreakFlag = 1u;
-			break;
-		}
-		else
-		{
-			; /*继续*/
 			}
 		}
-
+		checkRes = SystemOverTimeCheck(JkjRelayCycNum,JKJ_REYLAY_VALID_CYCLE_NUM);
-	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);    /*设置应急盘有效标志为有效*/
+			SetCiJkjFlag(JKJ_REYLAY_VALID);    /*设置JKJ应急盘有效标志为有效*/
-			}
+			if (0u == JkjValidCycNum)           /*之前没有设置应急盘有效开始周期*/
-			else
 			{				
-				; /*不做处理*/
+				SetJkjRelayValidCycNum(curCycNum);   /*设置JKJ应急盘有效周期*/
 			}
 		}
-		else if (RELAY_STATE_UP == JkjRelayState)
-		{/*吸起*/
-			/*应急无效*/
-			SetCiJkjFlag(JKJ_REYLAY_INVALID);           /*设置应急盘有效标志为无效*/
-			SetJkjRelayValidCycNum(0u);   /*设置应急无效周期*/
 	}
-		else
+	else if ((wJkjRelayId > 0u) && (RELAY_STATE_UP == JkjRelayState))
 	{
-			/*应急无效*/
+		tmpRet = SetRelayStateUpdateCycNum(wJkjRelayId, 0u);	/*清除JKJ继电器有效起始周期号*/
-			SetCiJkjFlag(JKJ_REYLAY_VALID);           /*设置应急盘有效标志为无效*/
+		if (CI_ERROR == tmpRet)
-			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
-	{
-		/*JKJ未配置，OC无应急控功能，应急盘无效*/
-		SetCiJkjFlag(JKJ_REYLAY_INVALID);           /*设置应急盘有效标志为无效*/
-		SetJkjRelayValidCycNum(0u);   /*设置应急无效周期*/
 		}
+		/*应急盘无效*/
+		SetCiJkjFlag(JKJ_REYLAY_INVALID);           /*设置JKJ应急盘继电器有效标志为无效*/
 
+		SetJkjRelayValidCycNum(0u);   /*设置JKJ应急盘无效周期*/
+	}
+	else
+	{
+		/*应急盘无效*/
+		SetCiJkjFlag(JKJ_REYLAY_INVALID);           /*设置JKJ应急盘继电器有效标志为无效*/
+		SetJkjRelayValidCycNum(0u);   /*设置JKJ应急盘继电器无效周期*/
+	}
 }
 
 /*
@@ -873,6 +815,9 @@ void RouteLogicProcess(void)
 		/*扣车、SPKS、PSD导致信号关闭又重开处理*/
 		RouteRecoverOpenProc(routeId);
 
+		/*进路调车同意逻辑处理*/
+		RouteDCTYLogicM(routeId);
+
 		/*根据进路状态清理相关标志*/
 		ClearSomeFlagDependRouteState(routeId);
 		/*cgh-合并CID-2349-5：*/
@@ -4415,22 +4360,37 @@ 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;
 
-	wSelfRealyId = GetRouteThisZhaoChaRelayId(routeId); /*本端照查继电器ID*/
+	if (ROUTE_LEVEL_BLOC == chRouteLevel)
-	dwRouteLockStartCycNum = GetRouteLockStartCycNum(routeId);
+	{
+		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，在下面不会处理*/
+	}
+
 	dwTimeOutCycCount = GetSystemParaSignalCloseCyc();
 
-	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))
+	{
+		/*进路空闲 两种模式照查都吸起*/
+		if (0U < wSelfRealyId)
 		{
 			relauDrvState = GetRelayDriveState(wSelfRealyId);
 			if (RELAY_DRIVE_STATE_NULL == relauDrvState)
@@ -4438,15 +4398,34 @@ 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)
 		{
 			(void)SetRelayDriveState(wSelfRealyId, RELAY_STATE_DOWN);
 			relauDrvState = GetRelayCollState(wSelfRealyId);
-
 			if (RELAY_STATE_DOWN != relauDrvState)
 			{ /*照查继电器未落下*/
-				chOverTimeCheck = SystemOverTimeCheck(dwRouteLockStartCycNum, dwTimeOutCycCount);
+				chOverTimeCheck = CheckRelayDriveOutTime(wSelfRealyId, dwTimeOutCycCount);
-				if (CI_TIME_OUT == chOverTimeCheck)
+				if (CI_ERROR == chOverTimeCheck)
 				{/*照查超时超时*/
 
 					/*xxxxx宕机*/
@@ -6145,16 +6124,16 @@ UINT16 GetReturnId(const UINT16	routeId)
 		{
 			/*当前状态是接近锁闭异常*/
 
-			/* 如果是差至，如果列车驶入过进路，同时之前状态必须为接近锁闭开放
+			/* 如果是差至，如果列车驶入过进路，同时之前状态必须为接近锁闭正常（列车压入，信号关闭）
 			* 否则不认为是同一列车跨入中途折返处理
 			*/
-			if((ROUTE_STATE_NEAR_OPEN == preRouteState) && (TRAIN_ENTER_ROUTE_FLAG_YES == GetTrainEnterRouteFlag(routeId)))
+			if((ROUTE_STATE_NEAR_LOCK == preRouteState) && (TRAIN_ENTER_ROUTE_FLAG_YES == GetTrainEnterRouteFlag(routeId)))
 			{
 				returnSigId = GetRouteChaZhiSignalId(routeId); /*获取差置信号机ID*/
 			}
 			else
 			{
-				returnSigId = 0U;
+				returnSigId = 0u;
 			}
 		}
 	}
@@ -6187,8 +6166,6 @@ 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);
@@ -6230,16 +6207,14 @@ 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) && (dwReturnRoutLockCycNum > dwRoutLockCycNum) &&
+						(returnSigId == wLockRouteStartSigId) &&
 						((CI_SUCCESS == chTrainEnterRouteFlag) ||
 							((CI_SUCCESS == chRouteInOutSecOccupy) && (ROUTE_TYPE_LIECHE == routeType))))
 					{
 						/*折出进路是调车进路&&状态是接近开放&&折出进路始端信号机是本进路折返信号机 &&（有车驶入 或 待解锁进路为列车进路是折出进路时内外方区段同时占压）*/
-						/*by cgh 20250414增加条件：折出进路锁闭时间晚于需中途解锁进路*/
+
 						/*解锁成功*/
 						SetRoutePhySectionLockState(routeId, PHYSICAL_SECTION_LOCK_NO); /*设置进路区段未锁闭*/
 
@@ -6249,10 +6224,10 @@ void DTrainReturnUnlockRouteAllLockP(const UINT16 routeId)
 						SetRouteStateDeal(routeId, ROUTE_STATE_IDLE); /*设置进路状态为空闲*/
 					}
 					if ((ROUTE_TYPE_LIECHE == chLockBelRouteType) && (ROUTE_STATE_NEAR_LOCK == chLockBelRouteState)
-						&& (returnSigId == wLockRouteStartSigId) && (dwReturnRoutLockCycNum > dwRoutLockCycNum))
+						&& (returnSigId == wLockRouteStartSigId))
 					{
 						/*折出进路是列车进路 且 进路状态是接近锁闭正常 且 折出进路始端信号机是本进路折返信号机*/
-						/*by cgh 20250414增加条件：折出进路锁闭时间晚于需中途解锁进路*/
+
 						/*解锁成功*/
 						SetRoutePhySectionLockState(routeId, PHYSICAL_SECTION_LOCK_NO); /*设置进路区段未锁闭*/
 						/*设置进路逻辑区段: 未锁闭*/
@@ -6290,8 +6265,6 @@ 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);
@@ -6339,16 +6312,13 @@ 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) && (dwReturnRoutLockCycNum > dwRoutLockCycNum) &&
+			(returnSigId == wLockRouteStartSigId) &&
 			((CI_SUCCESS == chTrainEnterRouteFlag) ||
 			((CI_SUCCESS == chRouteInOutSecOccupy) && (ROUTE_TYPE_LIECHE== routeType))))
 		{ 
 			/*折出进路是调车进路&&状态是接近开放&&折出进路始端信号机是本进路折返信号机 &&（有车驶入 或 待解锁进路为列车进路是折出进路时内外方区段同时占压）*/
-			/*by cgh 20250414增加条件：折出进路锁闭时间晚于需中途解锁进路*/
 			/*解锁成功*/
 			SetRoutePhySectionLockState(routeId, PHYSICAL_SECTION_LOCK_NO); /*设置进路区段未锁闭*/
 			/*设置进路逻辑区段: 未锁闭*/
@@ -6356,10 +6326,9 @@ void DTrainRtnUnlockRemoteRAllLockP(const UINT16 routeId)
 			SetRouteStateDeal(routeId, ROUTE_STATE_IDLE); /*设置进路状态为空闲*/
 		}
 		if ((ROUTE_TYPE_LIECHE== chLockBelRouteType) && (ROUTE_STATE_NEAR_LOCK == chLockBelRouteState)
-			&& (returnSigId == wLockRouteStartSigId) && (dwReturnRoutLockCycNum > dwRoutLockCycNum))
+			&& (returnSigId == wLockRouteStartSigId))
 		{
 			/*折出进路是列车进路 且 进路状态是接近锁闭正常 且 折出进路始端信号机是本进路折返信号机*/
-			/*by cgh 20250414增加条件：折出进路锁闭时间晚于需中途解锁进路*/
 			/*解锁成功*/
 			SetRoutePhySectionLockState(routeId, PHYSICAL_SECTION_LOCK_NO); /*设置进路区段未锁闭*/
 			/*设置进路逻辑区段: 未锁闭*/
@@ -7121,47 +7090,37 @@ void CancelWashWorkLogicM(void)
 * 功能描述： 进路调车同意逻辑管理
 * 参数说明： void
 * 返回值  ： void   
-* by cgh 20250523
 */
-void RouteDCTYLogic(UINT16 routeId)
+void RouteDCTYLogicM(UINT16 routeId)
 {
-	UINT8 routeType = 0U;
+	UINT8 routeType = 0u;
-	UINT8 routeState = 0U;
+	UINT8 routeState = 0u;
-	UINT16 routeDCQJId = 0U;
+	UINT16 routeDCQJId = 0u;
-	UINT16 routeDCQJTwoId = 0U;
-
 	routeType = GetRouteType(routeId);/*进路类型*/
 	routeState = GetRouteState(routeId);/*进路状态*/
 	routeDCQJId = GetRouteDCQJId(routeId);
-	routeDCQJTwoId = GetRouteDCQJTwoId(routeId);
+	if ((routeDCQJId >0u) && (ROUTE_TYPE_DIAOCHE == routeType))
-
-	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_AUTO_UNLOCK == routeState) ||
+			(ROUTE_STATE_LEAD_LOCK == routeState) ||
-			(ROUTE_STATE_AUTO_UNLOCKERR == routeState) ||
+			(ROUTE_STATE_LEAD_LOCKERR == routeState) ||
-			(ROUTE_STATE_DELAY_UNLOCK == routeState))
+			(ROUTE_STATE_LEAD_OPEN == routeState) || 
-		{
+			(ROUTE_STATE_DELAY_UNLOCK == routeState) ||
-			/*进路存在锁闭:进路初锁、进路初锁异常、预先锁闭、预先开放、接近开放、接近锁闭异常、接近锁闭正常、延时解锁、自动解锁正常、自动解锁异常*/
+			(ROUTE_STATE_NEAR_LOCK == routeState))
-			SetRouteDCQState(routeId,ROUTE_DCQ_REQUEST);/*设置进路调车请求状态调车请求有效*/
+		{/*进路是完整锁闭:进路初锁、进路初锁异常、预先锁闭、预先开放、接近开放、接近锁闭异常、接近锁闭正常
+		 、引导锁闭、引导锁闭异常、引导开放、延时解锁*/
+			(void)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

@@ -776,9 +776,8 @@ void CancelWashWorkLogicM(void);
 * 功能描述： 进路调车同意逻辑管理
 * 参数说明： void
 * 返回值  ： void   
-* by cgh 20250523
 */
-void RouteDCTYLogic(UINT16 routeId);
+void RouteDCTYLogicM(UINT16 routeId);
 
 /*
 * 功能描述： 调车进路调车同意联锁条件检查

TSCP/src/APP/ciapp/LogicProcess/InterlockLogicCheck.h

@@ -1021,6 +1021,14 @@ CI_ERROR:
 */
 UINT8 CheckRouteZongRenJieFeasibility(const UINT16 routeId);
 
+/*
+* 功能描述： 检查调车进路总人解的可行性。只要进路有一个区段可以直接解锁或变绿光带都认为总人解可行。注：调车进路总人解不可调用该函数
+* 参数说明： const UINT16 routeId, 进路ID
+* 返回值  ： UINT8
+CI_SUCCESS:总人解可执行
+CI_ERROR:总人解不可执行
+*/
+UINT8 CheckDiaoCheRouteZRJFeasibility(const UINT16 routeId);
 
 /*
 锁闭本联锁保护区段条件检查
@@ -1489,7 +1497,6 @@ UINT8 AxisSecAllSwitchPosCheck(UINT16 const axisSecId,UINT16 *pDevId,UINT8 *pDev
 * 参数说明： UINT16 const routeId,    进路编号
 * 返回值  ： CI_ERROR
 *            CI_SUCCESS
-* qw.liu	修改 进路外方第一区段道岔位置检查不使用接近区段，改为直接查逻辑区段
 */
 UINT8 RouteOutfirstPhySecSwiPosCheck(UINT16 const routeId);
 /*
@@ -2287,7 +2294,7 @@ UINT16 SearchNonMainRoute(UINT8 cRouteSum, UINT16 wRouteIdBuff[]);
 UINT8 SwitchRelLogSecLSXSStateCheck(UINT16 switchId, UINT16* pLogSecId, UINT8* pLogState);
 
 /*
-* 功能描述：  进路照查容忍条件满足检查
+* 功能描述： 信号保持开放时进路照查条件满足检查
 * 参数说明： UINT16 const routeId,  进路号
 * 返回值  ： CI_ERROR 失败
 *            CI_SUCCESS 成功
@@ -2607,15 +2614,13 @@ UINT8 CtTrainHeadSuspCheck(const UINT16 wTrainId, const UINT8 cLogSecSeqDir, con
 * 功能描述：车辆段部分进路的逻辑区段序列和列车位置检查
 * 输入参数：const UINT8 cLogSecSum 逻辑区段数量
 *           const UINT16* pLogSecIdBuff 逻辑区段序列
-*           const UINT16 wTrainId 列车ID
+*           const UINT16 wTrainId
-*           const UINT8 cFunctionId 函数ID
-*           const UINT8 cSendLevel 报警发送级别
 * 输出参数：无
 * 返回值  ：CI_ERROR 0 失败
 *           CI_SUCCESS 1 成功
-* Edit By cgh 2025.10.17
+* Created By LQ 2024.09.05
 */
-UINT8 LogSecSeqAndTrainPosCheckCLD(const UINT8 cLogSecSum, const UINT16* pLogSecIdBuff, const UINT16 wTrainId, const UINT8 cFunctionId, const UINT8 cSendLevel);
+UINT8 LogSecSeqAndTrainPosCheckCLD(const UINT8 cLogSecSum, const UINT16* pLogSecIdBuff, const UINT16 wTrainId);
 
 /*
 * 功能描述：车辆段部分进路的逻辑区段序列与进路匹配检查
@@ -2706,83 +2711,13 @@ UINT8 OtherCiOvlpRelProSwMovValCheck(const UINT16 wOverlapId);
 UINT8 OverlapProSwUsingCheck(const UINT16 wOverlapId, UINT16* pDevId, UINT8* pDevState, UINT8* pAlarmType);
 
 /*
-* 功能描述： 获取指定进路办理相邻控区道岔检查标志
+* 功能描述： 进路关联所有道岔位置正确检查
-* 参数说明： const UINT16 routeId 进路ID
+* 参数说明： UINT16 const routeId,    进路号）
-* 返 回 值： 进路办理相邻控区道岔检查标志
-* 输出参数：UINT16* switchID道岔ID、UINT8* chSwitchState道岔状态
-* by cgh 20241202
-*/
-UINT8 RouteRelAllSwitchPosCheck(UINT16 const routeId, UINT16* switchID, UINT8* chSwitchState);
-
-/*
-*函数功能：保护区段照查继电器检查
-*参数说明：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 区段状态均为防护锁闭
+*            CI_SUCCESS
-* by fan 20250724
+* BY CGH 20250224
 */
-UINT8 RouteAllSecProtectLockCheck(UINT16 const routeId);
+UINT8 RouteRelAllSwitchPosCheck(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 wPhySecId 物理区段ID
-*           const UINT16 wTrainId  列车ID
-* 输出参数：无
-* 返回值  ：CI_ERROR 0 不完全在
-*           CI_SUCCESS 1 完全在
-* by cgh 20251017
-*/
-UINT8 TrainOccSameSecCheck(const UINT16 wPhySecId, const UINT16 wTrainId);
-
-/*
-* 功能描述：占用是否属于同一区段检查
-* 输入参数：const UINT16 wBasePhySecId 基准物理区段ID
-*           const UINT16 wCheckPhySecId 待检查物理区段ID
-* 输出参数：无
-* 返回值  ：CI_ERROR 0 不属于
-*           CI_SUCCESS 1 属于
-* by cgh 20251017
-*/
-UINT8 OccBelSameSecCheck(const UINT16 wBasePhySecId, const UINT16 wCheckPhySecId);
 
 #endif
 

TSCP/src/APP/ciapp/LogicProcess/InterlockLogicProcess.c

@@ -1127,7 +1127,6 @@ UINT8 LockLeadRouteLogicProcess(UINT16 const routeId)
 
 /*故障发送级别*/
 	UINT8 sendLevel = 0u;
-	UINT8 cFuncSwitch = FUNC_SWITCH_ON;  /*引导进路是否检查防淹门开关*/
 
 
 	if (AutoSignalOrRouteValid(routeId) == CI_SUCCESS)
@@ -1161,9 +1160,19 @@ UINT8 LockLeadRouteLogicProcess(UINT16 const routeId)
 
 	if (CI_SUCCESS == reResult)
 	{
-		/*  进路状态为【引导选排】*/
+		/*  进路状态为
+			【引导选排】或
+			【进路初锁异常】或
+			【预先锁闭】或
+			【接近锁闭正常】或
+			【接近锁闭异常】
+		*/
 		devState = GetRouteState(routeId);
-		if (devState == ROUTE_STATE_LEAD_XUANPAI)
+		if ((devState == ROUTE_STATE_LEAD_XUANPAI) ||
+			(devState == ROUTE_STATE_FIRST_LOCKERR) ||
+			(devState == ROUTE_STATE_YUXIAN_LOCK) ||
+			(devState == ROUTE_STATE_NEAR_LOCK) ||
+			(devState == ROUTE_STATE_NEAR_LOCKERR))
 		{
 			/* 通过检查 */
 			reResult = CI_SUCCESS;
@@ -1250,18 +1259,7 @@ UINT8 LockLeadRouteLogicProcess(UINT16 const routeId)
 	if (CI_SUCCESS == reResult)
 	{
 		/*防淹门联锁条件检查*/
-		cFuncSwitch = GetCiFunctionSwitchConfig(FUNC_LEADROUTE_FLOODGATE_CHECK);
-
-		if (FUNC_SWITCH_OFF == cFuncSwitch)
-		{
-			/*引导进路锁闭不检查防淹门状态*/
-		}
-		else
-		{
-			/*引导进路锁闭检查防淹门状态*/
 		checkResult = BlocRouteFloodGateCheck(routeId, functionId, sendLevel);
-		}
-
 		if (CI_SUCCESS == checkResult)
 		{
 			reResult = CI_SUCCESS;
@@ -2405,21 +2403,6 @@ UINT8 LockRouteOverlapLogicProcess(UINT16 const routeId, UINT16 const overlapId,
 		}
 	}
 
-	/*保护区段照查条件检查*/
-	if (CI_SUCCESS == reResult)
-	{
-		checkResult = OverlapZhaoChaRelayCheck(overlapId, sendLevel);
-
-		if (CI_ERROR == checkResult)
-		{
-			reResult = CI_ERROR;
-		}
-		else
-		{
-			; /*保持之前检查结果，锁闭时先不检查本端是否满足*/
-		}
-	}
-
 	/*保护区段 内所有区段及保护区段防护道岔所在区段【未征用】*/
 	if (CI_SUCCESS == reResult)
 	{
@@ -3081,7 +3064,7 @@ UINT8 OpenBlocLTrainRouteLogicProcess(UINT16 const routeId)
 		else
 		{
 			/* 失败返回 */
-			reResult = checkResult;
+			reResult = CI_ERROR;
 		}
 	}
        
@@ -3680,7 +3663,7 @@ UINT8 OpenCbtcLTrainRouteLogicProcess(UINT16 const routeId)
 				else
 				{
 					/* 失败返回 */
-					reResult = checkResult;
+					reResult = CI_ERROR;
 				}
 			}
 
@@ -4257,7 +4240,7 @@ UINT8 OpenBlocReturnRouteLogicProcess(UINT16 const routeId)
 		else
 		{
 			/* 失败返回 */
-			reResult = checkResult;
+			reResult = CI_ERROR;
 		}
 	}
   
@@ -4813,7 +4796,7 @@ UINT8 OpenCbtcReturnRouteLogicProcess(UINT16 const routeId)
 		else
 		{
 			/* 失败返回 */
-			reResult = checkResult;
+			reResult = CI_ERROR;
 		}
 	}
   
@@ -5255,7 +5238,6 @@ UINT8 OpenLeadRouteLogicProcess(UINT16 const routeId)
     /* 取消标志 */
     UINT8 const zxqFlag = GetRouteZongQuXiaoFlag(routeId);
     UINT8 const zrjFlag = GetRouteZongRenJieFlag(routeId);
-	UINT8 cFuncSwitch = FUNC_SWITCH_ON;  /*引导进路是否检查防淹门开关*/
 
 
 	/* 获取扣车后是否关闭引导信号标志 */
@@ -5291,13 +5273,9 @@ UINT8 OpenLeadRouteLogicProcess(UINT16 const routeId)
 
     if (CI_SUCCESS == reResult)
 	{
-		/* 进路状态为【引导锁闭】或【进路初锁异常】或【预先锁闭】或【接近锁闭正常】或【接近锁闭异常】*/
+		/* 进路状态为【引导锁闭】*/
 		devState = GetRouteState(routeId);
-		if ((ROUTE_STATE_LEAD_LOCK == devState) ||
+		if (devState == ROUTE_STATE_LEAD_LOCK)
-			(ROUTE_STATE_FIRST_LOCKERR == devState) ||
-			(ROUTE_STATE_YUXIAN_LOCK == devState) ||
-			(ROUTE_STATE_NEAR_LOCK == devState) ||
-			(ROUTE_STATE_NEAR_LOCKERR == devState))
 		{
 			/* 通过检查 */
 			reResult = CI_SUCCESS;
@@ -5433,18 +5411,7 @@ UINT8 OpenLeadRouteLogicProcess(UINT16 const routeId)
 	if (CI_SUCCESS == reResult)
 	{
 		/*防淹门联锁条件检查*/
-		cFuncSwitch = GetCiFunctionSwitchConfig(FUNC_LEADROUTE_FLOODGATE_CHECK);
-
-		if (FUNC_SWITCH_OFF == cFuncSwitch)
-		{
-			/*引导进路开放不检查防淹门状态*/
-		}
-		else
-		{
-			/*引导进路开放检查防淹门状态*/
 		checkResult = BlocRouteFloodGateCheck(routeId,functionId,sendLevel);
-		}
-
 		if (CI_SUCCESS == checkResult)
 		{
 			reResult = CI_SUCCESS;
@@ -5522,7 +5489,9 @@ UINT8 KeepLeadRouteLogicProcess(UINT16 const routeId)
     /* 取消标志 */
     UINT8 const zxqFlag = GetRouteZongQuXiaoFlag(routeId);
     UINT8 const zrjFlag = GetRouteZongRenJieFlag(routeId);
-	UINT8 cFuncSwitch = FUNC_SWITCH_ON;  /*引导进路是否检查防淹门开关*/
+    /* 接发车属性 */
+
+
 
     /*引导信号开放时间状态*/
     UINT8 const leadSinalOpenState = SystemOverTimeCheck(GetRouteLeadFaultOpenStartCyc(routeId),
@@ -5756,18 +5725,7 @@ UINT8 KeepLeadRouteLogicProcess(UINT16 const routeId)
 	if (CI_SUCCESS == reResult)
 	{
 		/*防淹门联锁条件检查*/
-		cFuncSwitch = GetCiFunctionSwitchConfig(FUNC_LEADROUTE_FLOODGATE_CHECK);
-
-		if (FUNC_SWITCH_OFF == cFuncSwitch)
-		{
-			/*引导进路保持开放不检查防淹门状态*/
-		}
-		else
-		{
-			/*引导进路保持开放检查防淹门状态*/
 		checkResult = BlocRouteFloodGateCheck(routeId,functionId,sendLevel);
-		}
-
 		if (CI_SUCCESS == checkResult)
 		{
 			reResult = CI_SUCCESS;
@@ -5864,6 +5822,7 @@ UINT8 RouteFirstSecAutoUnlockProcess(UINT16 const routeId, UINT16* phySectionId)
 	UINT16 belongRouteID = 0U;
 	/*故障发送级别*/
     UINT8 sendLevel = ESEND_LEVEL_ZERO;    /*不发送ATS*/
+	UINT8 chRouteLevel = 0U;
 
 	/*第一个属于当前进路的【正常锁闭】区段*/
 	nlockSectionId = GetRouteFirstNormalLockSection(routeId);
@@ -5885,6 +5844,7 @@ UINT8 RouteFirstSecAutoUnlockProcess(UINT16 const routeId, UINT16* phySectionId)
 	returnRouteLockTime = GetRouteLockStartCycNum(routeId);
 	/*折出进路锁闭时间*/
 	backRouteLockTime = GetRouteLockStartCycNum(belongRouteID);
+	chRouteLevel = GetRouteLevel(routeId);
 
 	if(CI_SUCCESS == reResult)
 	{
@@ -5956,8 +5916,18 @@ UINT8 RouteFirstSecAutoUnlockProcess(UINT16 const routeId, UINT16* phySectionId)
 			/*进路内方第一区段由占用变空闲时才触发解锁流程，检查取消照查继电器(如果配置了)状态*/
 			if(CI_SUCCESS == reResult)
 			{
-				cancleZhaoChaRelayId = GetRouteCancleZhaoChaRelayId(routeId); /*取消照查继电器ID*/
+				if (ROUTE_LEVEL_BLOC == chRouteLevel)
-				
+				{
+					cancleZhaoChaRelayId = GetRouteCancleZhaoChaRelayId(routeId); /*后备模式取消照查继电器ID*/
+				}
+				else if (ROUTE_LEVEL_CBTC == chRouteLevel)
+				{
+					cancleZhaoChaRelayId = GetRouteCbtcCancelZhaochaRelay(routeId);/*CBTC模式取消照查继电器ID*/
+				}
+				else
+				{
+					; /*非法监督模式，继电器ID为0，在下面不会处理*/
+				}
 				if((0u != cancleZhaoChaRelayId) && (0xFFFFu != cancleZhaoChaRelayId))
 				{
 					/*取消继电器有效：取消继电器采集状态为：吸起*/
@@ -6040,8 +6010,18 @@ UINT8 RouteFirstSecAutoUnlockProcess(UINT16 const routeId, UINT16* phySectionId)
 			/*进路内方第一区段由占用变空闲时才触发解锁流程，检查取消照查继电器(如果配置了)状态*/
 			if(CI_SUCCESS == reResult)
 			{
-				cancleZhaoChaRelayId = GetRouteCancleZhaoChaRelayId(routeId); /*取消照查继电器ID*/
+				if (ROUTE_LEVEL_BLOC == chRouteLevel)
-				
+				{
+					cancleZhaoChaRelayId = GetRouteCancleZhaoChaRelayId(routeId); /*后备模式取消照查继电器ID*/
+				}
+				else if (ROUTE_LEVEL_CBTC == chRouteLevel)
+				{
+					cancleZhaoChaRelayId = GetRouteCbtcCancelZhaochaRelay(routeId);/*CBTC模式取消照查继电器ID*/
+				}
+				else
+				{
+					; /*非法监督模式，继电器ID为0，在下面不会处理*/
+				}
 				if((0u != cancleZhaoChaRelayId) && (0xFFFFu != cancleZhaoChaRelayId))
 				{
 					/*取消继电器有效：取消继电器采集状态为：吸起*/
@@ -6453,10 +6433,9 @@ UINT8 PhySectionDelayUnlockProcess(UINT16 const routeId, UINT16* phySectionId)
 /*
 * 功能描述： 解锁进路overlap逻辑处理
 * 参数说明： const UINT16 routeId   进路号
-* 返回值  ： CI_ERROR 0x00 失败
+* 返回值  ： CI_ERROR
-*            CI_SUCCESS 0x01 成功
+*            CI_SUCCESS
-*            CI_UNLOCK_OVERLAP_REQURE 0x02 向ZC/车申请解锁保护区段
+*           CI_UNLOCK_OVERLAP_REQURE 向ZC申请解锁保护区段
-*            CI_OVERLAP_OCC_UNLOCK 0x06 保护区段执行占用特殊解锁
 * 故障编码： EFUNC_UNLOCK_OVER_LAP
 */
 UINT8 UnlockRouteOverlapLogicProcess(UINT16 const routeId, UINT16* overlapId,UINT16* pTrainId)
@@ -6494,8 +6473,8 @@ UINT8 UnlockRouteOverlapLogicProcess(UINT16 const routeId, UINT16* overlapId,UIN
     UINT8 sendLevel = ESEND_LEVEL_ZERO; 	/*不发送ATS*/
 	UINT8 cIvocUnlockOverlapFlag = 0U;  /*列车同意解锁保护区段标志*/
 	UINT8 cRcWorkMode = 0U;
+	UINT8 phySecSum = 0U;
 	UINT8 chABLFlag = 0U; /*物理区段ABL占用标志*/
-	UINT8 chProtectCheck = 0U;
 
 	localCiId = GetSystemParaLocalCiId();
 
@@ -6530,22 +6509,13 @@ UINT8 UnlockRouteOverlapLogicProcess(UINT16 const routeId, UINT16* overlapId,UIN
 			reResult = CI_SUCCESS;
 		}
 		else
-		{
-			/*保护区段占用特殊解锁条件检查*/
-			checkResult = OverlapOccuUnlockCheck(overlapLockedId, functionId);
-			if (CI_SUCCESS == checkResult)
-			{
-				reResult = CI_OVERLAP_OCC_UNLOCK;
-				*overlapId = overlapLockedId;
-			}
-			else
 		{
 			/* 记录故障码 */
 			SetErrorData(functionId,CI_DEVICE_TYPE_PHYSEC,devId,ETYPE_PS_MERGY_OCU_STATE,devState,sendLevel);
 			/* 失败返回 */
 			reResult = CI_ERROR;
 			*overlapId = overlapLockedId;
-			}
+			
 		}
 	}
 
@@ -6573,10 +6543,7 @@ UINT8 UnlockRouteOverlapLogicProcess(UINT16 const routeId, UINT16* overlapId,UIN
 
 	if (CI_SUCCESS == reResult)
 	{
-		/*进路内最后一个区段【未锁闭】
+		/*进路状态【空闲】且进路内最后一个区段【未锁闭】*/
-		或【锁闭方向相反】
-		或【锁闭且占用，满足延迟解锁或停稳解锁条件】
-		或【区段未占用，且进路内区段均防护锁闭】*/
 		devId = GetRouteLastPhySectionId(routeId);
 		devState = GetPhySecLockState(devId);
 
@@ -6783,10 +6750,9 @@ UINT8 UnlockRouteOverlapLogicProcess(UINT16 const routeId, UINT16* overlapId,UIN
 				}
 				else
 				{
-					/*如果进路内所有区段状态均为防护锁闭，可解锁*/
+					phySecSum = GetRoutePhysicalSectionSum(routeId);
-					chProtectCheck = RouteAllSecProtectLockCheck(routeId);
+					/*如果进路只有一个区段，并且该区段被前一条进路防护锁闭 可以解锁*/
-					
+					if ((PHYSICAL_SECTION_LOCK_PROTECT == devState)&&(1U== phySecSum))
-					if (CI_SUCCESS == chProtectCheck)
 					{
 						reResult = CI_SUCCESS;
 						*overlapId = overlapLockedId;
@@ -6871,6 +6837,7 @@ UINT8 RouteCancelLogicProcess(UINT16 const routeId)
 	UINT8  relayState = 0u;              /*继电器采集状态*/
 /*故障发送级别*/
     UINT8 sendLevel = ESEND_LEVEL_ATS;		/*发送ATS*/
+	UINT8 chRouteLevel = 0U;
 	UINT8 cRouteType = 0U;  /*进路类型*/
 
 /*联锁条件检查*/
@@ -6943,8 +6910,19 @@ UINT8 RouteCancelLogicProcess(UINT16 const routeId)
 
 	if(CI_SUCCESS == reResult)
 	{
-		cancleZhaoChaRelayId = GetRouteCancleZhaoChaRelayId(routeId); /*取消照查继电器ID*/
+		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，在下面不会处理*/
+		}
 		if((0u != cancleZhaoChaRelayId) && (0xFFFFu != cancleZhaoChaRelayId))
 		{
 			/*取消继电器有效：取消继电器采集状态为：吸起*/
@@ -9307,7 +9285,6 @@ UINT8 OpenBlocRouteSectionCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel)
 	UINT8 routeState = 0u;
 	UINT8 chDsnFuncSwitch = 0U;		/* 无直轨计轴占用功能开关 */
 	UINT8 chXianSuFuncSwitch = 0U; /*后备模式信号开放是否检查区段临时限速开关*/
-	UINT8 cCrossState = 0U;  /*信号机跨压状态*/
 
 	chDsnFuncSwitch = GetCiFunctionSwitchConfig(FUNC_TOA_SWITCH);
 	chXianSuFuncSwitch = GetCiFunctionSwitchConfig(FUNC_XIANSU_SWITCH);
@@ -9346,8 +9323,7 @@ UINT8 OpenBlocRouteSectionCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel)
 		}
 		else
 		{
-			cCrossState = GetSignalCrossState(startSignalId);
+			if ((SIGNAL_CROSS_STATE_NO == GetSignalCrossState(startSignalId)) && (CI_SUCCESS == checkResult))
-			if ((SIGNAL_CROSS_STATE_NO == cCrossState) && (CI_SUCCESS == checkResult))
 			{
 				/* 通过检查 */
 				reResult = CI_SUCCESS;
@@ -9357,17 +9333,7 @@ UINT8 OpenBlocRouteSectionCheck(UINT16 routeId,UINT8 functionId,UINT8 sendLevel)
 				if (FUNC_SWITCH_ON != chDsnFuncSwitch)
 				{
 					/* 记录故障码 */
-					if (CI_SUCCESS == checkResult)
-					{
-						/*仅跨压，区段未占用，记录跨压报警*/
-						SetErrorData(functionId, CI_DEVICE_TYPE_SIGNAL, startSignalId, ETYPE_SIG_CROSS, cCrossState, sendLevel);
-					}
-					else
-					{
-						/*存在区段占用，记录占用报警*/
 					SetErrorData(functionId, CI_DEVICE_TYPE_PHYSEC, devId, ETYPE_PS_MERGY_OCU_STATE, cPhySecCurMergeState, sendLevel);
-					}
-					
 					/* 失败返回 */
 					reResult = CI_ERROR;
 				}
@@ -10591,6 +10557,7 @@ UINT8 RouteLogSecAutoUnlockProcess(UINT16 const routeId, UINT16* logSectionId)
 	UINT8 leavePhyCurOccState = 0u;
 	UINT8 reResult = CI_ERROR; /*返回值*/
 	UINT8 sendLevel = ESEND_LEVEL_ZERO;    /*不发送ATS*/
+	UINT8 chRouteLevel = 0U;
 
 	/*第一个属于当前进路的正常锁闭逻辑区段*/
 	nlockLogId = GetRouteFirstNormalLockLogId(routeId);
@@ -10624,8 +10591,19 @@ UINT8 RouteLogSecAutoUnlockProcess(UINT16 const routeId, UINT16* logSectionId)
 		/*进路内方第一区段由占用变空闲时才触发解锁流程，检查取消照查继电器(如果配置了)状态*/
 		if(CI_SUCCESS == reResult)
 		{
-			cancleZhaoChaRelayId = GetRouteCancleZhaoChaRelayId(routeId); /*取消照查继电器ID*/
+			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，在下面不会处理*/
+			}
 			if((0u != cancleZhaoChaRelayId) && (0xFFFFu != cancleZhaoChaRelayId))
 			{
 				/*取消继电器有效：取消继电器采集状态为：吸起*/
@@ -10918,8 +10896,10 @@ void RouteLgcSecResUnlockProcess(const UINT16 wRouteId)
 	UINT8 chRelayState = 0U;
 	UINT16 routeLogNum = 0u;
 	UINT16 wTrainId = 0U;
+	UINT8 chLogicTrainRetrunStt = 0U;
 	UINT16* routeLogIdBuf = NULL;
 	UINT8 cRouteState = 0U;
+	UINT8 chRouteLevel = 0U;
 	UINT8 chTrainLevel = 0U;
 	UINT8 chThreePointCheck = CI_ERROR;
 	UINT8 chLocalCi = 0U;
@@ -10934,8 +10914,19 @@ void RouteLgcSecResUnlockProcess(const UINT16 wRouteId)
 	if ((0u < routeLogNum)
 		&& (MAX_ROUTE_IN_LT_NUM > routeLogNum))
 	{
-		wRelayZhaoCId = GetRouteCancleZhaoChaRelayId(wRouteId); /*取消照查继电器ID*/
+		chRouteLevel = GetRouteLevel(wRouteId);
-		
+		if (ROUTE_LEVEL_BLOC == chRouteLevel)
+		{
+			wRelayZhaoCId = GetRouteCancleZhaoChaRelayId(wRouteId); /*后备模式取消照查继电器ID*/
+		}
+		else if (ROUTE_LEVEL_CBTC == chRouteLevel)
+		{
+			wRelayZhaoCId = GetRouteCbtcCancelZhaochaRelay(wRouteId);/*CBTC模式取消照查继电器ID*/
+		}
+		else
+		{
+			; /*非法监督模式，继电器ID为0，在下面不会处理*/
+		}
 		if ((0u != wRelayZhaoCId) && (0xFFFFU != wRelayZhaoCId))
 		{
 			/*取消继电器有效：取消继电器采集状态为：吸起*/
@@ -11009,6 +11000,7 @@ void RouteLgcSecResUnlockProcess(const UINT16 wRouteId)
 							chLgcResTrainSum = GetLogSecTrainInfoSum(wUnlockLgcSecId);
 							
 							wTrainId = GetLogSecTrainIdByIndex(wUnlockLgcSecId, 0);
+							chLogicTrainRetrunStt = GetLogSecTrainReturnState(wUnlockLgcSecId, wTrainId);
 						}
 						else
 						{
@@ -11024,6 +11016,21 @@ void RouteLgcSecResUnlockProcess(const UINT16 wRouteId)
 				else
 				{
 				}
+#if 0
+				if (CI_SUCCESS == chKeepWork)
+				{
+					if (LOGIC_SECTION_TRAIN_RETURN_NO != chLogicTrainRetrunStt)
+					{
+						chKeepWork = CI_ERROR;
+					}
+					else
+					{
+					}
+				}
+				else
+				{
+				}
+#endif
 				if (CI_SUCCESS == chKeepWork)
 				{
 					chLocalCi = GetSystemParaLocalCiId();
@@ -12433,6 +12440,7 @@ void OtherCiOlpProSwUseCancelPro(const UINT16 wSwitchId, const UINT16 wOverlapId
 	UINT16 wOverlapIndex = 0U;
 	UINT8 cLocalCiId = 0U;  /*本地联锁ID*/
 	UINT8 cOverlapBelongCiId = 0U;  /*保护区段所属联锁ID*/
+	UINT8 ii = 0U;
 	UINT8 cSwitchBelongCiId = 0U;  /*道岔所属联锁ID*/
 	UINT16 wUsingBelongOverlapId = 0U;  /*道岔征用所属保护区段ID*/
 	UINT8 cSwitchUsingState = 0U;  /*防护道岔征用状态*/

TSCP/src/APP/ciapp/LogicProcess/InterlockLogicProcess.h

@@ -325,11 +325,10 @@ UINT8 PhySectionDelayUnlockProcess(const UINT16 routeId, UINT16* phySectionId);
 /* C25_解锁进路overlap逻辑处理 */
 /*
 * 功能描述： 解锁进路overlap逻辑处理
-* 参数说明： const UINT16 routeId   进路号
+* 参数说明： const UINT16 routeId
-* 返回值  ： CI_ERROR 0x00 失败
+* 返回值  ： CI_ERROR
-*            CI_SUCCESS 0x01 成功
+*            CI_SUCCESS
-*            CI_UNLOCK_OVERLAP_REQURE 0x02 向ZC/车申请解锁保护区段
+*           CI_UNLOCK_OVERLAP_REQURE 向ZC申请解锁保护区段
-*            CI_OVERLAP_OCC_UNLOCK 0x06 保护区段执行占用特殊解锁
 * 故障编码： EFUNC_UNLOCK_OVER_LAP
 */
 UINT8 UnlockRouteOverlapLogicProcess(const UINT16 routeId, UINT16* overlapId, UINT16* pTrainId);

TSCP/src/APP/ciapp/LogicProcess/TradInterlockLogicProcess.c

@@ -181,7 +181,6 @@ UINT8 SetLeadRouteP(const UINT16 routeId)
     UINT16 devId = 0u;                   /*设备ID*/
     UINT8 devState = 0u;                 /*设备状态*/
     UINT8 reResult = CI_SUCCESS;          /*返回值*/
-	UINT8 cFuncSwitch = FUNC_SWITCH_ON;  /*引导进路是否检查防淹门开关*/
 
 /* 联锁条件检查 */
     devId = routeId;
@@ -227,17 +226,8 @@ UINT8 SetLeadRouteP(const UINT16 routeId)
 	if (CI_SUCCESS == reResult)
 	{
 		/*防淹门联锁条件检查*/
-		cFuncSwitch = GetCiFunctionSwitchConfig(FUNC_LEADROUTE_FLOODGATE_CHECK);
-
-		if (FUNC_SWITCH_OFF == cFuncSwitch)
-		{
-			/*引导进路办理不检查防淹门状态*/
-		}
-		else
-		{
-			/*引导进路办理检查防淹门状态*/
 		reResult = BlocRouteFloodGateCheck(routeId,functionId,sendLevel);
-		}
+		
 	}
 
     return reResult;
@@ -2005,6 +1995,8 @@ UINT8 CancelDTrainRouteP(const UINT16 routeId)
     UINT8 devState = 0u;                 /*设备状态*/
 	UINT16 cancleZhaoChaRelayId = 0u;    /*取消照查继电器ID*/
 	UINT8  relayState = 0u;              /*继电器采集状态*/
+	UINT8 chRouteLevel = 0U;
+    
     
 /* 联锁条件检查 */
 /*进路内所有区段正常锁闭*/
@@ -2042,8 +2034,19 @@ UINT8 CancelDTrainRouteP(const UINT16 routeId)
 	}
 	if (CI_SUCCESS == reResult)
 	{/*检查取消照查继电器状态是否吸起*/
-		cancleZhaoChaRelayId = GetRouteCancleZhaoChaRelayId(routeId); /*取消照查继电器ID*/
+		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，在下面不会处理*/
+		}
 		if((0u != cancleZhaoChaRelayId) && (0xFFFFu != cancleZhaoChaRelayId))
 		{
 			/*取消继电器有效：取消继电器采集状态为：吸起*/
@@ -2525,7 +2528,7 @@ UINT8 SetLTrainRouteSwitchCheck(UINT16 routeId, UINT8 functionId, UINT8 sendLeve
 		}
 		else
 		{
-			/*如果是进路防护道岔等待相邻联锁反馈道岔检查状态,先不检查防护道岔是否全在位置，继续等待*/
+			reResultP = CI_ERROR;
 		}
 
 		if (CI_ERROR == reResultP)
@@ -4112,7 +4115,6 @@ UINT8 SetLeadRouteCheck(const UINT16 routeId)
 	UINT16 devId = 0u;                   /*设备ID*/
 	UINT8 devState = 0u;                 /*设备状态*/
 	UINT8 reResult = CI_ERROR;          /*返回值*/
-	UINT8 cFuncSwitch = FUNC_SWITCH_ON;  /*引导进路是否检查防淹门开关*/
 
 /* 联锁条件检查 */
 	devId = routeId;
@@ -4212,18 +4214,7 @@ UINT8 SetLeadRouteCheck(const UINT16 routeId)
 	/*防淹门联锁条件检查*/
 	if (CI_SUCCESS == reResult)
 	{
-		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/Mask/MaskDefine.h

@@ -49,7 +49,6 @@
 #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数据结构使用*/
 
 /*单轨_道岔码位*/
 /* zt 删除单轨相关代码 2022-02-15 */
@@ -63,12 +62,11 @@
 #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_BLUEBREAK           ((UINT8)0x25)    /*定义信号机蓝断码位*/
+#define MASK_TYPE_SIGNAL_BREAK                      ((UINT8)0x1c)    /*定义信号机断丝码位*/
-#define MASK_TYPE_SIGNAL_BREAK                   ((UINT8)0x1c)    /*定义信号机断丝码位 （对全电子联锁=红灯断丝）*/
 #define MASK_TYPE_SIGNAL_FENGSUO                    ((UINT8)0x1d)    /*定义信号机封锁码位*/
 
 #define MASK_TYPE_SIGNAL_OPENSTATE                  ((UINT8)0x1e)    /*定义信号机开放状态码位*/
@@ -92,9 +90,6 @@
 #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)    /*定义信号机工程车关灯码位*/
 
@@ -117,12 +112,7 @@
 #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)	/*定义逻辑区段非通信车占用码位*/
@@ -166,7 +156,6 @@
 #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)*/
 
 
 /*站台相关码位*/
@@ -180,8 +169,6 @@
 #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用*/
@@ -199,7 +186,6 @@
 #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/Overlap/OverlapConfigDataManage.c

@@ -873,53 +873,3 @@ 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;
-}

TSCP/src/APP/ciapp/Overlap/OverlapConfigDataManage.h

@@ -72,8 +72,7 @@ typedef struct S_OverlapConfigDataStruct
 	UINT16 OverlapRouteSum;															/*保护区段进路总数*/
 	UINT16 OverlapRouteIdBuf[OVERLAP_ROUTE_SUM_MAX];								/*保护区段进路数组*/
 	UINT16 AxisSecFarId;                                						    /*保护区段最远端计轴区段ID*/
-	UINT16 wOverlapThisZhaoChaRelayId;                                              /*保护区段本端照查继电器ID*/
+
-	UINT16 wOverlapThatZhaoChaRelayId;                                              /*保护区段对端照查继电器ID*/
 } OverlapConfigDataStruct;
 
 extern OverlapConfigDataStruct OverlapConfigDataStru[OVERLAP_SUM_MAX];   /*定义OVERLAP数据配置结构体,cgh-合并CID-2539-1：此处声明不进行初始化，统一放到InitAllStaticDataStr函数中进行初始化，为解决生成内核过大得问题*/
@@ -374,22 +373,6 @@ 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);
-
 #ifdef __cplusplus
 }
 #endif

TSCP/src/APP/ciapp/Overlap/OverlapDataManage.c

@@ -51,7 +51,7 @@ UINT16 GetOverlapBelongRouteId(const UINT16 overlapId)
 
 
 /*
-* 功能描述： 设置指定ID保护区段所属进路
+* 功能描述： 设置指定ID保护区段组解锁起始周期号
 * 参数说明： const UINT16 overlapId, 保护区段ID   
 *			 const UINT16 belongRouteId, 所属进路号
 * 返回值  ： 无

TSCP/src/APP/ciapp/PSD/PSDConfigDataManage.c

@@ -1042,27 +1042,3 @@ 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;
-}

TSCP/src/APP/ciapp/PSD/PSDConfigDataManage.h

@@ -64,10 +64,6 @@ typedef struct S_PsdConfigDataStruct
 	UINT16 wPcbIndicatorRelayId;                                             /*再关门按钮指示灯继电器*/
 	UINT16 wVideoQkLight1RelayId;                                             /*清客按钮箱视频清客指示灯1（绿）继电器*/
 	UINT16 wVideoQkLight2RelayId;                                             /*清客按钮箱视频清客指示灯2（红）继电器*/
-	UINT16 wPsdFstProLinkId;                                                  /*屏蔽门防护link1ID*/
-	UINT16 wPsdSndProLinkId;                                                  /*屏蔽门防护link2ID*/
-	UINT16 wPsdTrdProLinkId;                                                  /*屏蔽门防护link3ID*/
-	UINT8 chPsdControlType;													  /*屏蔽门控制类型*/
 } PsdConfigDataStruct;
 
 
@@ -415,13 +411,6 @@ 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);
-
 #ifdef __cplusplus
 }
 #endif

TSCP/src/APP/ciapp/PSD/PSDDataManage.c

@@ -1443,14 +1443,14 @@ UINT8 SetPsdCmdCyclePsc(const UINT16 doorId, const UINT32 doorCycle)
 }
 
 /*
-* 功能描述： 设置指定ID屏蔽门旁路标志
+* 功能描述： 设置指定ID屏蔽门确认PSC互锁解除标志
 * 参数说明： const UINT16 doorId, 屏蔽门ID
 *            const UINT8 setFlag, 屏蔽门旁路设置状态
 * 返回值  ：无
 *			       
 */
 
-void SetPsdConfirmFlag(const UINT16 doorId,const UINT8 setFlag)
+void SetPsdPscConfirmFlag(const UINT16 doorId,const UINT8 setFlag)
 {
 	/*变量初始化*/
 	UINT16 bufIndex = 0u;
@@ -1467,13 +1467,13 @@ void SetPsdConfirmFlag(const UINT16 doorId,const UINT8 setFlag)
 }
 
 /*
-* 功能描述： 获取指定ID屏蔽门旁路标志
+* 功能描述： 获取指定ID屏蔽门确认PSC旁路标志
 * 参数说明： const UINT16 doorId, 屏蔽门ID
 *            
 * 返回值  ： 0: 获取失败
 *			 >0: 获取成功      
 */
-UINT8 GetPsdPlFlag(const UINT16 doorId)
+UINT8 GetPsdPscPlFlag(const UINT16 doorId)
 {
 	/*变量初始化*/
 	UINT16 bufIndex = 0u;  /*数组下标*/
@@ -1532,7 +1532,7 @@ void SetNearCiPscPlFlag(const UINT16 psdId,const UINT16 pscId,const UINT8 setFla
 			if(psdCiId == localCiId)
 			{
 				/*设置PSC对应PSD旁路*/
-				SetPsdConfirmFlag(psdId, setFlag);
+				SetPsdPscConfirmFlag(psdId, setFlag);
 			}
 		}
 		else
@@ -1544,12 +1544,12 @@ void SetNearCiPscPlFlag(const UINT16 psdId,const UINT16 pscId,const UINT8 setFla
 	else
 	{
 		/*获取PSD旁路标志*/
-		pscPlFlag = GetPsdPlFlag(psdId);
+		pscPlFlag = GetPsdPscPlFlag(psdId);
 		if(psdCiId == localCiId)
 		{
 			if(CI_PSC_PL_CONFIRM_YES == pscPlFlag)
 			{
-				SetPsdConfirmFlag(psdId, CI_PSC_PL_CONFIRM_NO);
+				SetPsdPscConfirmFlag(psdId, CI_PSC_PL_CONFIRM_NO);
 			}
 			else
 			{
@@ -2510,349 +2510,3 @@ 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
-	{
-		/*不处理*/
-	}
-}

TSCP/src/APP/ciapp/PSD/PSDDataManage.h

@@ -81,16 +81,6 @@ 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;
 
 extern PsdDataStruct PsdDataStru[PSD_SUM_MAX];   /*定义屏蔽门数据结构体*/
@@ -528,23 +518,23 @@ UINT32 GetPsdCmdCyclePsc(const UINT16 doorId);
 UINT8 SetPsdCmdCyclePsc(const UINT16 doorId, const UINT32 doorCycle);
 
 /*
-* 功能描述： 设置指定ID屏蔽门旁路标志
+* 功能描述： 设置指定ID屏蔽门确认PSC互锁解除标志
 * 参数说明： const UINT16 doorId, 屏蔽门ID
 *            const UINT8 setFlag, 屏蔽门旁路设置状态
 * 返回值  ：无
 *			       
 */
 
-void SetPsdConfirmFlag(const UINT16 doorId,const UINT8 setFlag);
+void SetPsdPscConfirmFlag(const UINT16 doorId,const UINT8 setFlag);
 
 /*
-* 功能描述： 获取指定ID屏蔽门旁路标志
+* 功能描述： 获取指定ID屏蔽门确认PSC旁路标志
 * 参数说明： const UINT16 doorId, 屏蔽门ID
 *            
 * 返回值  ： 0: 获取失败
 *			 >0: 获取成功      
 */
-UINT8 GetPsdPlFlag(const UINT16 doorId);
+UINT8 GetPsdPscPlFlag(const UINT16 doorId);
 
 /*
 * 功能描述： PSC同时与另一联锁通信时，PSC旁路命令处理
@@ -882,126 +872,6 @@ 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);
-
 #ifdef __cplusplus
 }
 #endif

TSCP/src/APP/ciapp/PSD/PSDDefine.h

@@ -67,25 +67,6 @@
 #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)            /*四编组*/
@@ -106,10 +87,6 @@
 #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)			/*已检测且无障碍物*/
@@ -195,16 +172,4 @@
 #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)		/*低四字节*/
-
 #endif

TSCP/src/APP/ciapp/ParsePack/CiInterfaceDefine.h

@@ -147,10 +147,7 @@
 #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)		/* 释放联锁控制权*/
@@ -216,7 +213,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命令(新机场线查询命令)、PSD命令默认值*/
+#define VOBCTOCI_COMMAND_TYPE_PSDCHECK_FAOHLHT            ((UINT8)0xFF)            /*查询PSD命令(新机场线查询命令)*/
 
 /****联锁到ATS反馈信息宏定义****/
 /*反馈信息类型*/
@@ -248,7 +245,6 @@
 #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_SIG_START_OPEN            ((UINT8)0x11)        /*进路始端信号机开放*/
@@ -303,7 +299,6 @@
 #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_MOVE         ((UINT8)0xA3)	/*道岔转动中*/
 /* zt 删除单轨相关代码 2022-02-15 */
 #define  CI_BACK_SWT_USING					((UINT8)0x3f)		/*道岔征用中*/
 #define	 CI_BACK_SWT_MOVE_ERR				((UINT8)0x84)		    /*道岔搬动失败*/
@@ -409,16 +404,8 @@
 #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与其他子系统数据发送方标识信息错误 */

TSCP/src/APP/ciapp/ParsePack/ParsePackAtsData.c

@@ -122,41 +122,6 @@ static UINT8 TransCiToAtsPSCState(UINT8 ciToXianDiData, UINT8 MoveNum, UINT8 Psc
 */
 static UINT8 TransCiToAtsPSCtypeState(UINT8 ciToXianDiData, UINT8 MoveNum, UINT8 PscStatetype, UINT8 PscState, UINT8 BitValY, UINT8 BitValN);
 
-/*
-* 功能描述： 转换Ci到ATS中PSD 驱动电源状态信息
-* 参数说明：入参
-*            UINT8 ciToXianDiData, CI到现地数据信息
-*			UINT8 MoveNum	左移位数
-*			UINT8 PsdState  psd驱动电源状态信息
-*			出参
-*			无
-* 返回值  ： 转换后输出数据
-*/
-static UINT8 TransCiToAtsDrvWorkState(UINT8 ciToXianDiData, UINT8 MoveNum, UINT8 PsdState);
-
-/*
-* 功能描述： 转换Ci到ATS中PSD 控制电源状态信息
-* 参数说明：入参
-*            UINT8 ciToXianDiData, CI到现地数据信息
-*			UINT8 MoveNum	左移位数
-*			UINT8 PsdState  psd控制电源状态信息
-*			出参
-*			无
-* 返回值  ： 转换后输出数据
-*/
-static UINT8 TransCiToAtsCtlWorkState(UINT8 ciToXianDiData, UINT8 MoveNum, UINT8 PsdState);
-
-/*
-* 功能描述： 转换Ci到ATS中PSD 边缘控制器状态
-* 参数说明：入参
-*            UINT8 ciToXianDiData, CI到现地数据信息
-*			UINT8 MoveNum	左移位数
-*			UINT8 PsdState  psd边缘控制器状态
-*			出参
-*			无
-* 返回值  ： 转换后输出数据
-*/
-static UINT8 TransCiToAtsPSDEdgeState(UINT8 ciToXianDiData, UINT8 MoveNum, UINT8 PsdState);
 
 /*
 * 功能描述： 解析操作命令数据帧
@@ -960,13 +925,6 @@ UINT8 PackCiToAtsOrXianDiData(const UINT8 deviceId, const UINT8 targetDevType, c
 			}
 		}
 
-		/*组OC-PSC一体化数据*/
-		PackOcPscDataToAts(ciToXianDiDataBuffer, &ii);
-
-		/*组PSD数据*/
-		PackPsdDataToAts(ciToXianDiDataBuffer, &ii);
-		
-		
 		ocDeviceSum = (UINT16)GetCiTransmitSpecifySysDevSum(CI_SYSTEM_TYPE_OC);     /*获取通信OC设备总数*/
 		pOcDeviceIdBuf = GetCiTransmitSpecifySysDevBuf(CI_SYSTEM_TYPE_OC); /*获取通信OC设备ID数组*/
 
@@ -1079,7 +1037,6 @@ UINT8 PackCiToAtsOrXianDiData(const UINT8 deviceId, const UINT8 targetDevType, c
 		{
 		}
 
-#if 0
 		/*存在PSC设备，才发送PSD隔离信息给ATS*/
 		if (NULL == pDeviceIdBuf)
 		{
@@ -1146,7 +1103,6 @@ UINT8 PackCiToAtsOrXianDiData(const UINT8 deviceId, const UINT8 targetDevType, c
 			/*重新填写PSD数量*/
 			ciToXianDiDataBuffer[ii - (psdSum * 28U) - 1U] = psdSum;
 		}
-#endif
 
 
 		/*组RCOCI设备状态 （电源/电源模块状态）2字节*/
@@ -1193,9 +1149,6 @@ UINT8 PackCiToAtsOrXianDiData(const UINT8 deviceId, const UINT8 targetDevType, c
 			/*不处理*/
 		}
 
-		/*组通信联锁信息*/
-		PackCiDataToAts(ciToXianDiDataBuffer, &ii);
-
 		/*预留40字节*/
 		ii += 40u;
 	}
@@ -1414,8 +1367,6 @@ void SetCiSendCmdBackData_OrderBack( const UINT32 commandId,const UINT16 deviceI
 			}
 		}
 	}
-	/*清除暂存一次命令后，将无效命令清除，并将数量置为有效命令的数量 YF0083-Bug-148*/
-	ClearCiSendBackDataTempStruData();
 
 	if (CiSendCmdStruCurSum < CI_TO_ATSORXIANDI_CMD_DATA_STRU_SUM_MAX)
 	{
@@ -1751,7 +1702,7 @@ UINT8 GetPscConfirmFlag(UINT8 pscId)
 			if(psdCiId == localCiId)
 			{
 				/*获取PSC对应PSD的互锁解除确认标志*/
-				pscPsdFlag = GetPsdPlFlag(pscToCiDataStru[pscId].psdDataStr[i].psdId);
+				pscPsdFlag = GetPsdPscPlFlag(pscToCiDataStru[pscId].psdDataStr[i].psdId);
 				if(CI_PSC_PL_CONFIRM_YES == pscPsdFlag)
 				{
 					retVal = CI_PSC_PL_CONFIRM_YES;
@@ -1896,12 +1847,6 @@ UINT8 FindFirstOrder(UINT8 SecondOrder)
 	 case ATS_CMD_SWITCH_FANWEI_TEST_TWO:
 		 reVal = ATS_CMD_SWITCH_FANWEI_TEST_ONE; /*道岔反位测试一次命令*/
 		 break;
-	 case ATS_CMD_OC_P_PL_TWO:
-		 reVal = ATS_CMD_OC_P_PL_ONE; /*OC-P旁路一次命令*/
-		 break;
-	 case ATS_CMD_QUXIAO_OC_P_PL_TWO:
-		 reVal = ATS_CMD_QUXIAO_OC_P_PL_ONE; /*取消OC-P旁路一次命令*/
-		 break;
 	  default:
 		  reVal = 0u;
 		  break;
@@ -2597,7 +2542,6 @@ UINT16 TransCiToAtsSwitchZzjInfo(OcToATSSwitchZzjData* ciSendAtsSwitchZzjData, U
 	UINT8 jj = 0U;/*道岔对应转辙机的索引*/
 	UINT8 mm = 0U;/*道岔状态四开时，判断是否有异常情况循环体*/
 	UINT8 chSwitchDriveFlag = 0U;/*道岔驱动过标志*/
-	UINT8 chSingleSwitchCurPosition = 0u;/*道岔当前单独位置*/
 
 	if ((NULL != ciSendAtsSwitchZzjData)
 		&& (NULL != wDataLength))
@@ -2666,14 +2610,6 @@ UINT16 TransCiToAtsSwitchZzjInfo(OcToATSSwitchZzjData* ciSendAtsSwitchZzjData, U
 								ciSendAtsSwitchZzjData[wSwitchNum].szSwitchIncldeZzjState[jj] = OC_TO_ATS_SWITCH_ZZJ_NORMAL;
 							}
 							else
-							{
-								chSingleSwitchCurPosition = GetSingleSwitchCurPosition(m_OcToCiOrginDataArr[kk].OcDevices[ii].DeviceId);
-								if (SWITCH_POSITION_JICHA == chSingleSwitchCurPosition)
-								{
-									/*道岔当前挤岔，转辙机判断为故障*/
-									ciSendAtsSwitchZzjData[wSwitchNum].szSwitchIncldeZzjState[jj] = OC_TO_ATS_SWITCH_ZZJ_ALARM;
-								}
-								else
 							{
 								chSwitchDriveFlag = GetSwitchDrivedFlag(m_OcToCiOrginDataArr[kk].OcDevices[ii].DeviceId);
 								if (SWITCH_DRIVED_FLAG_YES == chSwitchDriveFlag)
@@ -2686,7 +2622,7 @@ UINT16 TransCiToAtsSwitchZzjInfo(OcToATSSwitchZzjData* ciSendAtsSwitchZzjData, U
 									/*道岔没被驱动四开，此转辙机状态设置为正常*/
 									ciSendAtsSwitchZzjData[wSwitchNum].szSwitchIncldeZzjState[jj] = OC_TO_ATS_SWITCH_ZZJ_ALARM;
 								}
-								}
+								
 							}
 						}
 					}
@@ -2735,361 +2671,3 @@ static UINT8 TransCiToAtsPowerModeState(UINT8 ciToXianDiData, UINT8 MoveNum, UIN
 
 	return TransCiSendData;
 }
-
-/*
-* 功能描述： 转换Ci到ATS中PSD 驱动电源状态信息
-* 参数说明：入参
-*            UINT8 ciToXianDiData, CI到现地数据信息
-*			UINT8 MoveNum	左移位数
-*			UINT8 PsdState  psd驱动电源状态信息
-*			出参
-*			无
-* 返回值  ： 转换后输出数据
-*/
-static UINT8 TransCiToAtsDrvWorkState(UINT8 ciToXianDiData, UINT8 MoveNum, UINT8 PsdState)
-{
-	UINT8 TransCiSendData = 0u;
-
-	if (PSD_DRIVE_POWER_NORMAL == PsdState)
-	{/*PSD 驱动电源状态正常*/
-		TransCiSendData = ciToXianDiData | ((UINT8)(BIT_VAL_00000011B << MoveNum));
-	}
-	else if (PSD_DRIVE_POWER_ERROR == PsdState)
-	{/*故障*/
-		TransCiSendData = ciToXianDiData | ((UINT8)(BIT_VAL_00000000B << MoveNum));
-	}
-	else
-	{
-		TransCiSendData = ciToXianDiData | ((UINT8)(BIT_VAL_00000000B << MoveNum));
-	}
-
-	return TransCiSendData;
-}
-
-/*
-* 功能描述： 转换Ci到ATS中PSD 控制电源状态信息
-* 参数说明：入参
-*            UINT8 ciToXianDiData, CI到现地数据信息
-*			UINT8 MoveNum	左移位数
-*			UINT8 PsdState  psd控制电源状态信息
-*			出参
-*			无
-* 返回值  ： 转换后输出数据
-*/
-static UINT8 TransCiToAtsCtlWorkState(UINT8 ciToXianDiData, UINT8 MoveNum, UINT8 PsdState)
-{
-	UINT8 TransCiSendData = 0u;
-
-	if (PSD_CONTROL_POWER_NORMAL == PsdState)
-	{/*PSD 控制电源状态正常*/
-		TransCiSendData = ciToXianDiData | ((UINT8)(BIT_VAL_00000011B << MoveNum));
-	}
-	else if (PSD_CONTROL_POWER_ERROR == PsdState)
-	{/*故障*/
-		TransCiSendData = ciToXianDiData | ((UINT8)(BIT_VAL_00000000B << MoveNum));
-	}
-	else
-	{
-		TransCiSendData = ciToXianDiData | ((UINT8)(BIT_VAL_00000000B << MoveNum));
-	}
-
-	return TransCiSendData;
-}
-
-/*
-* 功能描述： 转换Ci到ATS中PSD 边缘控制器状态
-* 参数说明：入参
-*            UINT8 ciToXianDiData, CI到现地数据信息
-*			UINT8 MoveNum	左移位数
-*			UINT8 PsdState  psd边缘控制器状态
-*			出参
-*			无
-* 返回值  ： 转换后输出数据
-*/
-static UINT8 TransCiToAtsPSDEdgeState(UINT8 ciToXianDiData, UINT8 MoveNum, UINT8 PsdState)
-{
-	UINT8 TransCiSendData = 0u;
-
-	if (PSD_EDGE_CONTROLLER_NORMAL == PsdState)
-	{/*PSD 边缘控制器正常*/
-		TransCiSendData = ciToXianDiData | ((UINT8)(BIT_VAL_00000001B << MoveNum));
-	}
-	else if (PSD_EDGE_CONTROLLER_ERROR == PsdState)
-	{/*边缘控制器故障*/
-		TransCiSendData = ciToXianDiData | ((UINT8)(BIT_VAL_00000000B << MoveNum));
-	}
-	else
-	{
-		TransCiSendData = ciToXianDiData | ((UINT8)(BIT_VAL_00000000B << MoveNum));
-	}
-
-	return TransCiSendData;
-}
-
-
-/*
-* 功能描述： 组OC-P信息到ATS
-* 参数说明：入参
-*			UINT8* ciToXianDiDataBuffer 存放信息的buffer
-*			UINT16* ii 偏移量
-*			出参
-*			无
-* 返回值  ： 无
-*/
-void PackOcPscDataToAts(UINT8* ciToXianDiDataBuffer, UINT16* ii)
-{
-	UINT16 ocPscNum = 0u;
-	UINT16 ocId = 0u;				/*psd id*/
-	UINT8 ocPscConfirmFlag = 0u;
-	UINT16 jj = 0u;					/*游标*/
-	UINT16 index = 0u;
-	UINT16 temp_index = 0u;
-
-	if ((NULL != ciToXianDiDataBuffer) && (NULL != ii))
-	{
-		index = *ii;
-
-		/*OC一体机总数量,先不组，有psdNum才组*/
-		temp_index = index;
-		index += 2u;
-
-		for (jj = 0u; jj < m_OcToCiOrginDataNum; jj++)
-		{
-			if (0u < m_OcToCiOrginDataArr[jj].OCPsdNum)
-			{/*有PSD数量*/
-				ocPscNum++;
-
-				ShortToChar(m_OcToCiOrginDataArr[jj].OcId, &ciToXianDiDataBuffer[index]);
-				index += 2u;
-
-				/*OC-P驱动电源状态*/
-				ciToXianDiDataBuffer[index] = TransCiToAtsDrvWorkState(ciToXianDiDataBuffer[index], 6u, m_OcToCiOrginDataArr[jj].DrvPowerState);
-				/*OC-P控制电源状态*/
-				ciToXianDiDataBuffer[index] = TransCiToAtsCtlWorkState(ciToXianDiDataBuffer[index], 4u, m_OcToCiOrginDataArr[jj].CtlPowerState);
-				/*边缘控制器1状态*/
-				ciToXianDiDataBuffer[index] = TransCiToAtsPSDEdgeState(ciToXianDiDataBuffer[index], 2u, m_OcToCiOrginDataArr[jj].EdgeCtllerState1);
-				/*边缘控制器2状态*/
-				ciToXianDiDataBuffer[index] = TransCiToAtsPSDEdgeState(ciToXianDiDataBuffer[index], 0u, m_OcToCiOrginDataArr[jj].EdgeCtllerState2);
-				index++;
-
-				ocPscConfirmFlag = GetOcPscConfirmFlag(jj);
-
-				/*旁路状态转换*/
-				ciToXianDiDataBuffer[index] = TransCiToAtsPSCtypeState(ciToXianDiDataBuffer[index], 0u, ocPscConfirmFlag,
-					OC_PSC_PL_CONFIRM_YES, BIT_VAL_00000000B, BIT_VAL_00000001B);
-
-				index++;
-			}
-			else
-			{
-				/*不处理*/
-			}
-		}
-
-		/*组OC-P数量*/
-		ShortToChar(ocPscNum, &ciToXianDiDataBuffer[temp_index]);
-		*ii = index;
-	}
-	else
-	{/*不处理*/
-	}
-
-}
-
-
-/*
-* 功能描述： 组PSD信息到ATS
-* 参数说明：入参
-*			UINT8* ciToXianDiDataBuffer 存放信息的buffer
-*			UINT16* ii 偏移量
-*			出参
-*			无
-* 返回值  ： 无
-*/
-void PackPsdDataToAts(UINT8* ciToXianDiDataBuffer, UINT16* ii)
-{
-	UINT8 psdDeviceSum = 0u;/*PSD设备总数*/
-	UINT16 jj = 0u;	/*游标*/
-	UINT16 psdId = 0u;/*psd id*/
-	UINT16 index = 0u;
-	UINT16 index_psd = 0u;/*用于记录组PSD数量的偏移量*/
-	UINT32 tempPack = 0u;
-	UINT8 psdConType = PSD_CONTROL_TYPE_RCI;
-	UINT8 OcPsdSum = 0u;	/*属于OC-P的PSD数量*/
-
-
-	if ((NULL != ciToXianDiDataBuffer) && (NULL != ii))
-	{
-		index = *ii;
-
-		psdDeviceSum = GetPsdSum();/*PSD总数*/
-
-		index_psd = index;
-		ciToXianDiDataBuffer[index] = 0u;	/*PSD数量先组0*/
-		index += 1u;
-
-		for (jj = 0u; jj < psdDeviceSum; jj++)	/*遍历所有的PSD*/
-		{
-			psdId = GetPsdId(jj);/*PSD id*/
-			psdConType = GetPsdControlType(psdId);
-
-			if ((0u != psdId) && (PSD_CONTROL_TYPE_OC_P == psdConType))
-			{
-				OcPsdSum++;
-
-				ShortToChar(0u, &ciToXianDiDataBuffer[index]);	/*psd id*/
-				index += 2u;
-				ShortToChar(psdId, &ciToXianDiDataBuffer[index]);
-				index += 2u;
-
-				tempPack = GetPsdFaultQState(psdId, HIGH_FOUR_CHAR);
-				LongToChar(tempPack, &ciToXianDiDataBuffer[index]);/*故障主动隔离信息*/
-				index += 4u;
-				tempPack = GetPsdFaultQState(psdId, LOW_FOUR_CHAR);
-				LongToChar(tempPack, &ciToXianDiDataBuffer[index]);/*故障主动隔离信息*/
-				index += 4u;
-
-				tempPack = GetPsdDoorIState(psdId, HIGH_FOUR_CHAR);
-				LongToChar(tempPack, &ciToXianDiDataBuffer[index]);/*被隔离信息*/
-				index += 4u;
-				tempPack = GetPsdDoorIState(psdId, LOW_FOUR_CHAR);
-				LongToChar(tempPack, &ciToXianDiDataBuffer[index]);/*被隔离信息*/
-				index += 4u;
-
-				tempPack = GetPsdDoorState(psdId, HIGH_FOUR_CHAR);
-				LongToChar(tempPack, &ciToXianDiDataBuffer[index]);/*每扇屏蔽门的开关状态*/
-				index += 4u;
-				tempPack = GetPsdDoorState(psdId, LOW_FOUR_CHAR);
-				LongToChar(tempPack, &ciToXianDiDataBuffer[index]);/*每扇屏蔽门的开关状态*/
-				index += 4u;
-
-				tempPack = GetOpenErrState(psdId);
-				ciToXianDiDataBuffer[index++] = tempPack;			/*开门故障状态*/
-
-				tempPack = GetCloseErrState(psdId);
-				ciToXianDiDataBuffer[index++] = tempPack;			/*关门故障状态*/
-			}
-			else
-			{
-				/*不处理*/
-			}
-		}
-		debug_infor_printf("psd control type:%x\n", psdConType);
-		ciToXianDiDataBuffer[index_psd] = OcPsdSum;			/*填入PSD数量*/
-		
-		*ii = index;
-	}
-	else
-	{/*不处理*/
-	}
-}
-
-/*
-* 功能描述： 获取确认OC-P旁路状态
-* 参数说明： UINT8 index, OC-P系统对应的数组下标
-*
-* 返回值  ： 0x55 旁路状态已确认
-*			 0xaa 旁路状态未确认
-*/
-UINT8 GetOcPscConfirmFlag(UINT8 index)
-{
-	UINT8 retVal = OC_PSC_PL_CONFIRM_NO;
-	UINT8 i = 0u;
-	UINT8 ocPscPsdFlag = 0u;
-
-	/*防空*/
-	if (OC_SUM_MAX > index)
-	{
-		for (i = 0u; i < m_OcToCiOrginDataArr[index].OCPsdNum; i++)
-		{
-			/*获取OC-P对应PSD的旁路状态*/
-			ocPscPsdFlag = GetPsdPlFlag(m_OcToCiOrginDataArr[index].PsdInfo[i].wPsdId);
-			if (OC_PSC_PL_CONFIRM_YES == ocPscPsdFlag)
-			{
-				retVal = OC_PSC_PL_CONFIRM_YES;
-				break;
-			}
-			else
-			{
-				/*不做处理*/
-			}
-		}
-	}
-	else
-	{
-		/*不处理*/
-	}
-
-	return retVal;
-}
-
-/*
-* 功能描述： 组通信联锁信息到ATS
-* 参数说明：入参
-*			UINT8* ciToXianDiDataBuffer 存放信息的buffer
-*			UINT16* ii 偏移量
-*			出参
-*			无
-* 返回值  ： 无
-*/
-void PackCiDataToAts(UINT8* ciToXianDiDataBuffer, UINT16* ii)
-{
-	UINT16 index = 0u;
-	UINT8 transCiSum = 0u;
-	UINT8* pCiDeviceIdBuf = NULL;         /*OC设备ID数组*/
-	UINT8 jj = 0u;
-	UINT8 ciAndCiCommState = 0u;/*ci与ci通信状态*/
-	UINT8 ciToAtsTransState = 0u;
-	UINT8 ciId = 0u;
-
-	if ((NULL != ciToXianDiDataBuffer) && (NULL != ii))
-	{
-		index = *ii;
-
-		transCiSum = GetCiTransmitSpecifySysDevSum(CI_SYSTEM_TYPE_CI);
-		pCiDeviceIdBuf = GetCiTransmitSpecifySysDevBuf(CI_SYSTEM_TYPE_CI);
-
-		ciToXianDiDataBuffer[index++] = transCiSum;/*通信的联锁数量*/
-		if (NULL != pCiDeviceIdBuf)
-		{
-			for (jj = 0u; jj < transCiSum; jj++)
-			{
-				ciId = pCiDeviceIdBuf[jj];/*CI ID*/
-				ciAndCiCommState = Get2oo2CiAndOtherSysCommState(CI_SYSTEM_TYPE_CI, (UINT8)jj);/*与联锁通信状态*/
-
-				ciToXianDiDataBuffer[index++] = 0x00u;
-				ciToXianDiDataBuffer[index++] = ciId;	/*组ID*/
-
-				if (TRANSMIT_2OO2_STATE_GOOD == ciAndCiCommState)
-				{/*双网通信良好*/
-					ciToAtsTransState = TRANSMIT_CI_STATE_GOOD;
-				}
-				else if (TRANSMIT_2OO2_STATE_LINK == ciAndCiCommState)
-				{/*单网通信故障*/
-					ciToAtsTransState = TRANSMIT_CI_STATE_LINK;
-				}
-				else if (TRANSMIT_2OO2_STATE_BAD == ciAndCiCommState)
-				{/*双网通信故障*/
-					ciToAtsTransState = TRANSMIT_CI_STATE_BAD;
-				}
-				else
-				{
-					ciToAtsTransState = TRANSMIT_CI_STATE_BAD;
-				}
-
-				ciToXianDiDataBuffer[index++] = ciToAtsTransState;
-
-			}
-		}
-		else
-		{
-			/*不处理*/
-		}
-
-		*ii = index;
-	}
-	else
-	{
-		/*入参检查失败，不处理*/
-	}
-}

TSCP/src/APP/ciapp/ParsePack/ParsePackAtsData.h

@@ -366,48 +366,6 @@ 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);
-
 #ifdef __cplusplus
 }
 #endif

TSCP/src/APP/ciapp/ParsePack/ParsePackAxleData.c

@@ -137,6 +137,7 @@ UINT8 InitAxleToCiDataStru(void)
 	UINT8 belongAxleSysId = 0u; /*物理区段所属计轴ID*/
 	UINT16 axlePhySecSum = 0u; /*计轴系统包含物理区段数目*/
 	UINT8 pyhIsThisLine = 0u;
+	UINT8 cPrtclVerBtwCiAndAxle = 0U;  /*联锁和计轴间的协议校验版本号*/
 
 	ciId = GetSystemParaLocalCiId();
 	ciName = (CI_SYSTEM_TYPE_CI) * 256U + ciId;
@@ -152,9 +153,18 @@ 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);
+				}
 
 				if (CI_SUCCESS == rtn) /*GAL层互联互通ID获取成功*/
 				{
@@ -186,9 +196,6 @@ UINT8 InitAxleToCiDataStru(void)
 								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].PhySecIdx[phySecId] = (UINT8)(axlePhySecSum);
@@ -248,9 +255,7 @@ 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; /*物理区段的索引号*/
 
 	deviceSum = GetCiTransmitSpecifySysDevSum(CI_SYSTEM_TYPE_AXIS); /*获取通信Axis设备总数*/
 	deviceIdBuf = GetCiTransmitSpecifySysDevBuf(CI_SYSTEM_TYPE_AXIS); /*获取通信Axis设备ID数组*/
@@ -268,9 +273,6 @@ 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;
 				}
 
@@ -448,163 +450,6 @@ 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
 				{
 					retVal = CI_ERROR;
@@ -670,9 +515,6 @@ 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;
 			}
 
@@ -750,12 +592,6 @@ 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; /*物理区段的索引号*/
-
 	axisDevName = (CI_SYSTEM_TYPE_AXIS) * 256U + axisSysId;
 	if (AXIS_TO_CI_SUM_MAX > axisSysId)
 	{
@@ -906,154 +742,6 @@ 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
 		{
 			retVal = CI_ERROR;
@@ -1263,45 +951,6 @@ 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;
-}

TSCP/src/APP/ciapp/ParsePack/ParsePackAxleData.h

@@ -41,8 +41,7 @@
 #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
@@ -51,10 +50,8 @@ 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; /*状态*/
 
 } AxisCollDataStruct;
@@ -129,17 +126,6 @@ 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);
-
 
 #ifdef __cplusplus
 }

TSCP/src/APP/ciapp/ParsePack/ParsePackCiData.h

@@ -58,8 +58,6 @@
 
 #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)					/*紧急停车按钮字节常量*/
@@ -71,9 +69,6 @@
 #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)						/*数据类型长度*/
@@ -100,13 +95,13 @@
 #define PHYSEC_LOCKDIRECTION_OPPST_YES					((UINT8)0xAA)	/*取反*/
 #define PHYSEC_LOCKDIRECTION_OPPST_DEFAULT				((UINT8)0xFF)	/*默认值*/
 
-#define CICI_VERSION					((UINT16)29) /*cici接口版本号，每次修改接口需要升级版本号——Last Modified On 2025.09.22*/
+#define CICI_VERSION					((UINT16)23) /*cici接口版本号，每次修改接口需要升级版本号——Last Modified On 2025.03.10*/
 #define CICI_BEGIN_TO_STATION_LEN		((UINT16)16) /*从开始到站场长度止  cgh增加4个字节CI-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)11)/*一个信号机数据长度*/
+#define CICI_ONE_SIGNAL_LEN				((UINT16)9)/*一个信号机数据长度*/
-#define CICI_ONE_PSD_LEN				((UINT16)5)/*一个屏蔽门数据长度*/
+#define CICI_ONE_PSD_LEN				((UINT16)4)/*一个屏蔽门数据长度*/
 #define CICI_ONE_ESB_LEN				((UINT16)4)/*一个ESB数据长度*/
 #define CICI_ONE_ROUTE_LEN				((UINT16)12)/*一个进路数据长度*/
 #define CICI_ONE_PHYSEC_LOCKSTATE_LEN	((UINT16)10)/*一个物理区段锁闭状态数据长度*/
@@ -238,18 +233,9 @@ extern "C" {
 		UINT8 cSourceCiId;  /*发送方联锁ID*/
 		UINT8 cTargetCiId;  /*接收方联锁ID*/
 		UINT8 cPlatFormNum;  /*区间雨雪站台数量*/
-		AreaSnowInfoStruct szPlatFormInfo[CI_TO_CI_AREA_SNOW_SUM_MAX];  /*区间雨雪信息数组*/
+		UINT32 dwPlatFormId[CI_TO_CI_AREA_SNOW_SUM_MAX];  /*区间雨雪站台互联互通ID数组*/
 	} 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;
@@ -266,8 +252,6 @@ extern "C" {
 	extern UINT8 SendCiDrCmdSum;
 	extern ToCiAreaSnowStruct szRecvCiAreaSnow[CI_COM_CI_MAX_NUM];
 	extern ToCiAreaSnowStruct szSendCiAreaSnow[CI_COM_CI_MAX_NUM];
-	extern ToCiAreaIteCutStruct szRecvCiAreaIteCut[CI_COM_CI_MAX_NUM];
-	extern ToCiAreaIteCutStruct szSendCiAreaIteCut[CI_COM_CI_MAX_NUM];
 
 /*
 * 功能描述： 解析CI数据
@@ -737,23 +721,21 @@ UINT8 CiToCiEnvelopeCheck(const UINT8* dataBuf, UINT16* index);
 * 功能描述： 添加相邻联锁发送给本联锁的区间雨雪信息
 * 参数说明： UINT8 cSrcCiId 发送方CI
 *            UINT8 cDstCiId 接收方CI
-*			 UINT16 wAreaSnowId 区间ID
+*			 UINT32 dwAreaSnowId 区间雨雪站台ID
-*            UINT8 cAreaSnowLevel 区间湿轨级别
 * 返回值  ： 无
-* Modified By LQ 2025.5.28
+* Created By LQ 2023.11.16
 */
-void AddCiRecvAreaSnowInfo(UINT8 cSrcCiId, UINT8 cDstCiId, UINT16 wAreaSnowId, UINT8 cAreaSnowLevel);
+void AddCiRecvAreaSnowInfo(UINT8 cSrcCiId, UINT8 cDstCiId, UINT32 dwAreaSnowId);
 
 /*
 * 功能描述： 添加本联锁发送给指定ID相邻联锁的区间雨雪信息
 * 参数说明： UINT8 cSrcCiId 发送方CI
 *            UINT8 cDstCiId 接收方CI
-*			 UINT16 wAreaId 区间ID
+*			 UINT32 dwAreaSnowId 区间雨雪站台ID
-*            UINT8 cAreaSnowLevel 区间湿轨等级
 * 返回值  ： 无
-* Modified By LQ 2025.05.28
+* Created By LQ 2023.11.16
 */
-void AddCiSendAreaSnowInfo(UINT8 cSrcCiId, UINT8 cDstCiId, UINT16 wAreaId, UINT8 cAreaSnowLevel);
+void AddCiSendAreaSnowInfo(UINT8 cSrcCiId, UINT8 cDstCiId, UINT32 dwAreaSnowId);
 
 /*
 * 功能描述： 获取相邻联锁发送给本联锁的区间雨雪信息
@@ -927,90 +909,6 @@ 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);
-
 #ifdef __cplusplus
 }
 #endif

TSCP/src/APP/ciapp/ParsePack/ParsePackCommon.c

@@ -31,7 +31,6 @@
 
 PlatHeartDataStruct RecvHeartDataStru = { 0U };  /*平台心跳帧数据结构*/
 PlatGPIODataStruct RecvPlatDataStruGPIO = { 0U };/*平台0x2D帧数据结构 GPIO采集状态*/
-PlatGPIOToleranceDataStruct gPlatDataGPIOTolercance = { 0U };/*平台硬件采集故障容忍记录数据*/
 
 /*
 * 功能描述： 信号机相关码位处理
@@ -62,13 +61,7 @@ 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:/*红灯码位*/
@@ -287,70 +280,9 @@ UINT8 SignalMaskManage(UINT8 MaskType, UINT16 DeviceId, UINT16 MaskId, UINT8* da
 		}
 		break;
 	case MASK_TYPE_SIGNAL_BREAK:/*信号机断丝码位*/
-		if ((CI_PATTERN_FULL_ELECTRONIC == CiPattern) && (FUNC_SWITCH_OFF == chDsnLinSwitch))/*全电子联锁*/
+		if (SIGNAL_SHOWCOLOUR_REDBREAK == GetSignalCurColor(DeviceId))
 		{
-			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
 		{
@@ -470,28 +402,6 @@ 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;
@@ -738,18 +648,6 @@ 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;
@@ -1558,7 +1456,6 @@ 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;	/*试车线联锁状态*/
@@ -1759,20 +1656,6 @@ 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))
 		{/*自动通过进路办理标志*/
@@ -1878,9 +1761,6 @@ 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();
@@ -1992,29 +1872,6 @@ 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);
@@ -2232,17 +2089,6 @@ 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;
@@ -2899,22 +2745,6 @@ UINT8 OverlapValidMaskCheck(const UINT16 rtOverlapLockedId)
 				returnValue = CI_ERROR;
 			}
 		}
-
-		/*检查照查继电器状态*/
-		if (CI_SUCCESS == returnValue)
-		{
-			returnValue = OverlapZhaoChaRelayCheck(rtOverlapLockedId, ESEND_LEVEL_ZERO);
-
-			if (CI_SUCCESS == returnValue)
-			{
-				returnValue = CI_SUCCESS;
-			}
-			else
-			{
-				/*等待本端照查继电器落下或对端检查不过，反馈失败*/
-				returnValue = CI_ERROR; 
-			}
-		}
 	}
 	else
 	{
@@ -2934,29 +2764,18 @@ UINT8 OverlapValidMaskCheck(const UINT16 rtOverlapLockedId)
 void PackCiToCimCommData(void)
 {
 	/*变量初始化*/
-	UINT16 i = 0U;
+	UINT16 i = 0u;
-	UINT8 j = 0U;
+	UINT8 j = 0u;
-	UINT8 ciToCimDataBuffer[CI_TO_CIM_DATA_LEN_MAX] = { 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;
 
-	cLocalWorkMode = GetLocalRcWorkMode();
+
-	cLocalCiId = GetSystemParaLocalCiId();
+	ciToCimDataBuffer[i++] = GetLocalRcWorkMode();
-	dwCurCycNum = Get2oo2CurCycleNum();
+	ciToCimDataBuffer[i++] =GetSystemParaLocalCiId ();
-	ciToCimDataBuffer[i++] = cLocalWorkMode;
-	ciToCimDataBuffer[i++] = cLocalCiId;
 
 	transmitDevIndex = i;
 	i++;
@@ -2969,19 +2788,7 @@ 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;
@@ -3006,19 +2813,7 @@ 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;
@@ -3045,19 +2840,8 @@ void PackCiToCimCommData(void)
 			transmitDevSum++;
 			ciToCimDataBuffer[i++] = CI_SYSTEM_TYPE_OC;
 			ciToCimDataBuffer[i++] = pDeviceIdBuf[j];
-			
+			/*通信良好*/
-			/*组OC通信冗余周期*/
+			ciToCimDataBuffer[i++] = 0U;
-			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;
@@ -3089,19 +2873,8 @@ void PackCiToCimCommData(void)
 			ciToCimDataBuffer[i++] = CI_SYSTEM_TYPE_PSC;
 			/*填ID*/
 			ciToCimDataBuffer[i++] = pDeviceIdBuf[j];
-
+			/*通信良好*/
-			/*组PSC通信冗余周期*/
+			ciToCimDataBuffer[i++] = 0U;
-			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;
@@ -3132,19 +2905,8 @@ 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;
@@ -3177,18 +2939,8 @@ void PackCiToCimCommData(void)
 			ciToCimDataBuffer[i++] = CI_SYSTEM_TYPE_CI;
 			ciToCimDataBuffer[i++] = pDeviceIdBuf[j];
 
-			/*组相邻RC/CI通信冗余周期*/
+			ciToCimDataBuffer[i++] = 0U;
-			dwRecvCycNum = GetCiTransmitRecvDataCycNum(cLocalCiId, CI_SYSTEM_TYPE_CI, 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;
@@ -3219,7 +2971,7 @@ void PackCiToCimCommData(void)
 			ciToCimDataBuffer[i++] = CI_SYSTEM_TYPE_XIANDI;
 			ciToCimDataBuffer[i++] = pDeviceIdBuf[j];
 
-			ciToCimDataBuffer[i++] = (UINT8)UINT8_MAX;
+			ciToCimDataBuffer[i++] = 0U;
 			/*通信良好*/
 			if (TRANSMIT_2OO2_STATE_GOOD == transmitState)
 			{
@@ -3252,7 +3004,7 @@ void PackCiToCimCommData(void)
 			ciToCimDataBuffer[i++] = CI_SYSTEM_TYPE_ATS;
 			ciToCimDataBuffer[i++] = pDeviceIdBuf[j];
 
-			ciToCimDataBuffer[i++] = (UINT8)UINT8_MAX;
+			ciToCimDataBuffer[i++] = 0U;
 			/*通信良好*/
 			if (TRANSMIT_2OO2_STATE_GOOD == transmitState)
 			{
@@ -3271,42 +3023,6 @@ 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);
 
@@ -3907,13 +3623,13 @@ void PackCiToCimVerData(void)
 	ciToCimDataBuffer[i++] = (UINT8)((pTiocFsVersion[2] << 4U) + pTiocFsVersion[3]);
 	/*组软件版本号*/
 	ciToCimDataBuffer[i++] = VER_SOFT_PRODUCT;
-	ciToCimDataBuffer[i++] = VER_SOFT_MODUAL_APP;
+	ciToCimDataBuffer[i++] = VER_SOFT_MODUAL_APP >> 2U;
-	ciToCimDataBuffer[i++] = VER_SOFT_MIANVERSION;
+	ciToCimDataBuffer[i++] = (VER_SOFT_MODUAL_APP << 6U) + (VER_SOFT_MIANVERSION & (UINT8)0x3F);
 	ciToCimDataBuffer[i++] = VER_SOFT_SUBVERSION;
 	/*组集成版本号*/
 	ciToCimDataBuffer[i++] = VER_INTE_PROJECT;
 	ciToCimDataBuffer[i++] = VER_INTE_PRODUCT;
-	ciToCimDataBuffer[i++] = VER_INTE_EXE;
+	ciToCimDataBuffer[i++] = (UINT8)((UINT8)VER_INTE_EXE << 1U) + ((UINT8)VER_INTE_TIME >> 7U);
 	ciToCimDataBuffer[i++] = VER_INTE_TIME;
 	/*发送CIM*/
 	(void)DarkInfoPack(CIM_INFO_VER_INFO, ciToCimDataBuffer, i);
@@ -3946,15 +3662,11 @@ void PackCiToCimDeviceData(void)
 	FloodGateDataStruct* pFloodGateData = 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]);/*道岔数量*/
+	ShortToChar(deviceNum, &ciToCimDataBuffer[ii]);/*道岔ID*/
 	ii += 2u;
 	for (jj = 0u; jj < deviceNum; jj++)/*本联锁和相邻联锁发送给本联锁的道岔总数目*/
 	{
@@ -3968,8 +3680,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;/*道岔动态红闪*/
@@ -3981,7 +3693,7 @@ void PackCiToCimDeviceData(void)
 		}
 		else
 		{
-			ciToCimDataBuffer[ii++] = chSwitchCurPos;/*单独道岔当前位置*/
+			ciToCimDataBuffer[ii++] = pSwitchData[deviceId].SingleSwitchCurPosition;/*单独道岔当前位置*/
 		}
 
 
@@ -3990,35 +3702,13 @@ 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]);/*信号机数量*/
+	ShortToChar(deviceNum, &ciToCimDataBuffer[ii]);/*PSD ID*/
 	ii += 2u;
 	for (jj = 0u; jj < deviceNum; jj++)/*本联锁和相邻联锁发送给本联锁的信号机总数目*/
 	{
@@ -4032,15 +3722,14 @@ void PackCiToCimDeviceData(void)
 		ciToCimDataBuffer[ii++] = pSignalData[deviceId].CancelDetainBtnErrFlag;/*取消扣车按钮故障标志*/
 		ciToCimDataBuffer[ii++] = pSignalData[deviceId].DetainBtnErrFlag;/*扣车按钮故障标志*/
 		ciToCimDataBuffer[ii++] = pSignalData[deviceId].RealyDetainFlag;/*硬线扣车标志*/
-		chSignalDsState = GetSignalCurBreakFlag(pSignalData[deviceId].SignalId);/*灯丝断丝标志状态*/
+		ciToCimDataBuffer[ii++] = pSignalData[deviceId].DsBreakFlag;/*灯丝断丝标志状态*/
-		ciToCimDataBuffer[ii++] = chSignalDsState;
 	}
 
 	/*************************************发送PSD状态数据********************************************/
 	/*发送状态数据*/
 	deviceNum = GetPsdSum();
 	pPsdData = GetPsdData();
-	ShortToChar(deviceNum, &ciToCimDataBuffer[ii]);/*PSD数量*/
+	ShortToChar(deviceNum, &ciToCimDataBuffer[ii]);/*PSD ID*/
 	ii += 2u;
 	for (jj = 0u; jj < deviceNum; jj++)/*本联锁和相邻联锁发送给本联锁的Psd总数目*/
 	{
@@ -4077,15 +3766,13 @@ 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]);/*ESB数量*/
+	ShortToChar(deviceNum, &ciToCimDataBuffer[ii]);/*PSD ID*/
 	ii += 2u;
 	for (jj = 0u; jj < deviceNum; jj++)/*本联锁和相邻联锁发送给本联锁的Psd总数目*/
 	{
@@ -4109,7 +3796,7 @@ void PackCiToCimDeviceData(void)
 	/*发送状态数据*/
 	deviceNum = GetSpksSum();
 	pSpksData = GetSpksData();
-	ShortToChar(deviceNum, &ciToCimDataBuffer[ii]);/*SPKS数量*/
+	ShortToChar(deviceNum, &ciToCimDataBuffer[ii]);/*PSD ID*/
 	ii += 2u;
 	for (jj = 0u; jj < deviceNum; jj++)/*本联锁和相邻联锁发送给本联锁的Psd总数目*/
 	{
@@ -4153,7 +3840,7 @@ void PackCiToCimDeviceData(void)
 	/*打印洗车机数据*/
 	pWashMachineData = GetWashMachineData();
 	deviceNum = GetWashMachineSum();
-	ShortToChar(deviceNum, &ciToCimDataBuffer[ii]);/*洗车机数量*/
+	ShortToChar(deviceNum, &ciToCimDataBuffer[ii]);/*PSD ID*/
 	ii += 2u;
 	for (jj = 0u; jj < deviceNum; jj++)
 	{
@@ -4194,7 +3881,7 @@ void PackCiToCimDeviceData(void)
 	/*打印车库门数据*/
 	deviceNum = GetGaragedoorSum();
 	pGrageDoorData = GetGaragedoorData();
-	ShortToChar(deviceNum, &ciToCimDataBuffer[ii]);/*车库门数量*/
+	ShortToChar(deviceNum, &ciToCimDataBuffer[ii]);/*PSD ID*/
 	ii += 2u;
 	for (jj = 0u; jj < deviceNum; jj++)
 	{
@@ -4227,7 +3914,7 @@ void PackCiToCimDeviceData(void)
 	/*打印防淹门数据*/
 	deviceNum = GetFloodGateCurSum();
 	pFloodGateData = GetFloodGateData();
-	ShortToChar(deviceNum, &ciToCimDataBuffer[ii]);/*防淹门数量*/
+	ShortToChar(deviceNum, &ciToCimDataBuffer[ii]);/*PSD ID*/
 	ii += 2u;
 	for (jj = 0u; jj < deviceNum; jj++)
 	{
@@ -4261,8 +3948,6 @@ void PackCiToCimDeviceData(void)
 
 	}
 	/*发送CIM*/
-	debug_infor_printf((const)"\nCIM_SEND_DEVSTATE:%d", ii);
-	debug_out_array(0xAA, ciToCimDataBuffer, ii);
 	(void)DarkInfoPack(CIM_INFO_DEVICE_STATE, ciToCimDataBuffer, ii);
 
 }
@@ -5089,56 +4774,3 @@ 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
-	{/*不处理*/
-	}
-
-	debug_infor_printf((const)"IO Compare Diff OCnum = %d\n", gDiffDataOcNum);
-	debug_out_array(0xAA, ciToCimDataBuffer, ii);
-
-	/*发送维护机*/
-	(void)DarkInfoPack(CIM_INFO_IO_COLL_DIFF_ALARM, ciToCimDataBuffer, ii);
-}

TSCP/src/APP/ciapp/ParsePack/ParsePackCommon.h

@@ -45,6 +45,7 @@
 #include "../DataManage/PlatDataManage.h"
 #include "../IO/DeviceRelayDataProcess.h"
 
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -60,7 +61,7 @@ extern "C" {
 
 	extern PlatHeartDataStruct RecvHeartDataStru;
 	extern PlatGPIODataStruct RecvPlatDataStruGPIO;
-	extern PlatGPIOToleranceDataStruct gPlatDataGPIOTolercance;
+
 /*
 * 功能描述： 信号机相关码位处理
 * 参数说明： UINT8 MaskType, 码位类型
@@ -379,13 +380,6 @@ void ParasePlantIOData(UINT8* dataBuf);
 */
 void PackCiToCimFlyProtectData(void);
 
-/*
-* 功能描述： 组包发送CIM双系IO采集不一致信息
-* 参数说明： void
-* 返回值  ： 无
-*/
-void PackCiToCimCollDiffData(void);
-
 #ifdef __cplusplus
 }
 #endif

TSCP/src/APP/ciapp/ParsePack/ParsePackDefine.h

@@ -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)5700)	/*联锁到CI组包数据最大值*/
+#define CI_TO_CI_DATA_LEN_MAX					((UINT16)5000)	/*联锁到CI组包数据最大值*/
 #define CI_TO_CI_AREA_SNOW_SUM_MAX				((UINT8)4)  /*相邻RC间发送的区间雨雪数量最大值*/
 #define CI_TO_CI_LEAVE_LOGSEC_ROUTE_NUM  			   ((UINT16)100)	 /*相邻RC间发送的离去逻辑区段检查数量最大值*/
 
@@ -103,7 +103,6 @@
 #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

@@ -26,11 +26,6 @@ AtsMsgCfmStru g_strAtsDaCfmFst = { 0u };			/*ȡ
 AtsDaMsgStru g_strAtsDaMsgSnd = { 0u };				/*取消脱轨防护区再次消息*/
 AtsMsgCfmStru g_strAtsDaCfmSnd = { 0u };			/*取消脱轨防护区再次确认*/
 
-AtsMsgCfmStru g_strSndAtsCfmFst = { 0U };			/*第二个ATS的远程筛选首次确认*/
-AtsMsgCfmStru g_strSndAtsEaCfmFst = { 0U };			/*第二个ATS的取消区间疏散首次确认*/
-AtsMsgCfmStru g_strSndAtsWlbCfmFst = { 0U };		/*第二个ATS的设置/取消全线列车紧急制动首次确认*/
-AtsMsgCfmStru g_strSndAtsDaCfmFst = { 0U };			/*第二个ATS的取消脱轨防护区首次确认*/
-
 /**
 * @brief 解析网关数据帧
 * @param const UINT8* dataBuf, 数据缓冲区
@@ -45,27 +40,12 @@ UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength)
 	UINT32 dwPrtclMsg = 0u;
 	UINT8 chMsgId = 0u;
 	UINT16 ii = 0u;
-	UINT16 jj = 0U;
 	UINT32 dwDataVerLocal = 0u;
 	UINT8 chMsgIndex = 0u;
 	UINT8 chLocalId = 0u;
 	UINT8 chTrainIndex = 0u;
 	UINT16 wMsgLen = 0U;
 	UINT16 wMsgLenCount = 0U;
-	UINT8 cAtsId = 0U;
-	UINT8 cStation = 0U;
-	UINT16 wIndex = 0U;
-	UINT8 cAtsSendRcId = 0U;
-	UINT32 dwTime = 0U;
-	UINT8 cTrainNum = 0U;
-	AtsScreenTrainInfoStru strTrainInfo[TRAIN_SUM_MAX] = { 0U };
-	UINT32 dwTrainHlhtId = 0U;  /*列车互联互通ID*/
-	UINT8 cCmdType = 0U;  /*命令类型*/
-	UINT8 cLineAttr = 0U;  /*线路属性*/
-	UINT8 cDevType = 0U;  /*设备类型*/
-	UINT8 cDevNum = 0U;
-	UINT16 wDevId = 0U;
-	UINT8 szCrcTmp[1024] = { 0U };
 	
 	if ((NULL != dataBuf) && (0u < dataLength))
 	{
@@ -125,10 +105,6 @@ UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength)
 				{
 				case MSG_TYPE_REQUEST_FIRST:/* 远程筛选首次消息 */
 				{
-					wIndex = ShortFromChar(&dataBuf[ii + 2U]);
-					if ((FLAG_SET != g_strAtsMsgFst.chFlag) || (g_strAtsMsgFst.wIndex == wIndex))
-					{
-						/*未收到或重复收到同一个ATS的一次命令时，解析第一个ATS下发的远程筛选首次消息*/
 					g_strAtsMsgFst.dwCycle = Get2oo2CurCycleNum();
 					g_strAtsMsgFst.chAtsId = dataBuf[ii++];
 					if (0U < g_strAtsMsgFst.chAtsId)
@@ -143,9 +119,8 @@ UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength)
 					if (CI_SUCCESS == chRtn)
 					{
 						g_strAtsMsgFst.chStation = dataBuf[ii++];
-							g_strAtsMsgFst.wIndex = ShortFromChar(&dataBuf[ii]);
+						g_strAtsMsgFst.chIndex = dataBuf[ii++];
-							ii += 2U;
+						if (0U < g_strAtsMsgFst.chIndex)
-							if (0U < g_strAtsMsgFst.wIndex)
 						{
 							;
 						}
@@ -191,14 +166,18 @@ UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength)
 								{
 									chRtn = CI_ERROR;
 								}
+								g_strAtsMsgFst.strTrainInfo[chTrainIndex].wLgcId = ShortFromChar(&dataBuf[ii]);
+								ii += 2u;
+								if ((0U == g_strAtsMsgFst.strTrainInfo[chTrainIndex].dwTrainId)
+									|| (UINT32_MAX == g_strAtsMsgFst.strTrainInfo[chTrainIndex].dwTrainId))
+								{
+									chRtn = CI_ERROR;
+								}
 								else
 								{
 									; /*DO NOTHING*/
 								}
 
-									g_strAtsMsgFst.strTrainInfo[chTrainIndex].wLgcId = ShortFromChar(&dataBuf[ii]);
-									ii += 2u;
-
 								if ((0U == g_strAtsMsgFst.strTrainInfo[chTrainIndex].wLgcId)
 									|| (UINT16_MAX == g_strAtsMsgFst.strTrainInfo[chTrainIndex].wLgcId))
 								{
@@ -236,131 +215,10 @@ UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength)
 					{
 						; /*DO NOTHING*/
 					}
-					}
-					else
-					{
-					    /*解析第二个ATS下发的远程筛选首次消息*/
-						cAtsId = dataBuf[ii];  /*解析ATS ID*/
-						ii++;
-						if (0U < cAtsId)
-						{
-							cStation = dataBuf[ii];  /*解析车站编号*/
-							ii++;
-
-							wIndex = ShortFromChar(&dataBuf[ii]);  /*解析操作中编号*/
-							ii += 2U;
-
-							if (0U < wIndex)
-							{
-								cAtsSendRcId = dataBuf[ii];  /*解析RC ID*/
-								ii++;
-								if (cAtsSendRcId == chLocalId)
-								{
-									dwTime = LongFromChar(&dataBuf[ii]);  /*解析一次命令请求时间*/
-									ii += 4U;
-
-									cTrainNum = dataBuf[ii];
-									ii++;
-									if ((0U < cTrainNum) && (ATS_GATEWAY_CI_TRAIN_MAX > cTrainNum))
-									{
-										for (chTrainIndex = 0U; chTrainIndex < cTrainNum; chTrainIndex++)
-										{
-											strTrainInfo[chTrainIndex].dwTrainId = LongFromChar(&dataBuf[ii]);
-											ii += 4U;
-											if ((0U == strTrainInfo[chTrainIndex].dwTrainId)
-												|| (UINT32_MAX == strTrainInfo[chTrainIndex].dwTrainId))
-											{
-												debug_infor_printf((const)"ParseGateWayToCiDataFrame: Cmd Id[%d] Parse Train Id[%d] Error\n", MSG_TYPE_REQUEST_FIRST, strTrainInfo[chTrainIndex].dwTrainId);
-												chRtn = CI_ERROR;
-											}
-											else
-											{
-												; /*DO NOTHING*/
-											}
-
-											strTrainInfo[chTrainIndex].wLgcId = ShortFromChar(&dataBuf[ii]);
-											ii += 2U;
-
-											if ((0U == strTrainInfo[chTrainIndex].wLgcId)
-												|| (UINT16_MAX == strTrainInfo[chTrainIndex].wLgcId))
-											{
-												debug_infor_printf((const)"ParseGateWayToCiDataFrame: Cmd Id[%d] Parse LogSec Id[%d] Error\n", MSG_TYPE_REQUEST_FIRST, strTrainInfo[chTrainIndex].wLgcId);
-												chRtn = CI_ERROR;
-											}
-											else
-											{
-												; /*DO NOTHING*/
-											}
-
-											if (CI_SUCCESS == chRtn)
-											{
-												; /*不处理*/
-											}
-											else
-											{
-												break;
-											}
-										}
-									}
-									else
-									{
-										debug_infor_printf((const)"ParseGateWayToCiDataFrame: Cmd Id[%d] Parse Train Num[%d] Error\n", MSG_TYPE_REQUEST_FIRST, cTrainNum);
-										chRtn = CI_ERROR;
-									}
-								}
-								else
-								{
-									debug_infor_printf((const)"ParseGateWayToCiDataFrame: Cmd Id[%d] Parse Rc Id[%d] Error\n", MSG_TYPE_REQUEST_FIRST, cAtsSendRcId);
-									chRtn = CI_ERROR;
-								}
-							}
-							else
-							{
-								debug_infor_printf((const)"ParseGateWayToCiDataFrame: Cmd Id[%d] Parse WorkStation Id[%d] Error\n", MSG_TYPE_REQUEST_FIRST, wIndex);
-								chRtn = CI_ERROR;
-							}
-						}
-						else
-						{
-							debug_infor_printf((const)"ParseGateWayToCiDataFrame: Cmd Id[%d] Parse Ats Id[%d] Error\n", MSG_TYPE_REQUEST_FIRST, cAtsId);
-							chRtn = CI_ERROR;
-						}
-
-						if (CI_SUCCESS == chRtn)
-						{
-							g_strSndAtsCfmFst.chFlag = FLAG_SET;
-							g_strSndAtsCfmFst.chTiocId = cAtsSendRcId;
-							g_strSndAtsCfmFst.chStation = cStation;
-							g_strSndAtsCfmFst.wIndex = wIndex;
-							g_strSndAtsCfmFst.dwTime = dwTime;
-							g_strSndAtsCfmFst.chOpStatus = CONFIRM_FIRST_OTHER_DEV_OP;  /*反馈其它操作站站操作中*/
-
-							/*计算CRC*/
-							szCrcTmp[jj] = cAtsId;
-							jj++;
-							LongToChar(dwTime, &szCrcTmp[jj]);
-							jj += 4U;
-							szCrcTmp[jj] = cTrainNum;
-							jj++;
-							for (chTrainIndex = 0U; chTrainIndex < cTrainNum; chTrainIndex++)
-							{
-								LongToChar(strTrainInfo[chTrainIndex].dwTrainId, &szCrcTmp[jj]);
-								jj += 4U;
-								ShortToChar(strTrainInfo[chTrainIndex].wLgcId, &szCrcTmp[jj]);
-								jj += 2U;
-							}
-							g_strSndAtsCfmFst.dwCrc32 = Tioc_CommonCrc32(szCrcTmp, jj);
-						}
-						else
-						{
-							; /*DO NOTHING*/
-						}
-					}
 					break;
 				}
 				case MSG_TYPE_REQUEST_SECOND:/* 远程筛选二次消息 */
 				{
-
 					g_strAtsMsgSnd.dwCycle = Get2oo2CurCycleNum();
 					g_strAtsMsgSnd.chAtsId = dataBuf[ii++];
 					if (0U < g_strAtsMsgSnd.chAtsId)
@@ -375,9 +233,8 @@ UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength)
 					if (CI_SUCCESS==chRtn)
 					{
 						g_strAtsMsgSnd.chStation = dataBuf[ii++];
-						g_strAtsMsgSnd.wIndex = ShortFromChar(&dataBuf[ii]);
+						g_strAtsMsgSnd.chIndex = dataBuf[ii++];
-						ii += 2U;
+						if (0U < g_strAtsMsgSnd.chIndex)
-						if (0U < g_strAtsMsgSnd.wIndex)
 						{
 							;
 						}
@@ -473,10 +330,6 @@ UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength)
 				}
 				case MSG_TYPE_EA_CANCLE_FIRST:/* 区间疏散取消首次消息 */
 				{
-					wIndex = ShortFromChar(&dataBuf[ii + 2U]);
-					if ((FLAG_SET != g_strAtsEaMsgFst.chFlag) || (g_strAtsEaMsgFst.wIndex == wIndex))
-					{
-						/*未收到或重复收到同一个ATS的一次命令时，解析第一个ATS下发的取消区间疏散首次消息*/
 					g_strAtsEaMsgFst.dwCycle = Get2oo2CurCycleNum();	/* 接收到取消区间疏散消息的周期号 */
 					g_strAtsEaMsgFst.chAtsId = dataBuf[ii++];			/* ATS编号 */
 					if (0U < g_strAtsEaMsgFst.chAtsId)
@@ -491,9 +344,8 @@ UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength)
 					if (CI_SUCCESS == chRtn)
 					{
 						g_strAtsEaMsgFst.chStation = dataBuf[ii++];	/* 车站编号 */
-							g_strAtsEaMsgFst.wIndex = ShortFromChar(&dataBuf[ii]);	/* 操作站编号 */
+						g_strAtsEaMsgFst.chIndex = dataBuf[ii++];	/* ²Ù×÷Õ¾±àºÅ */
-							ii += 2U;
+						if (0U < g_strAtsEaMsgFst.chIndex)
-							if (0U < g_strAtsEaMsgFst.wIndex)
 						{
 							;
 						}
@@ -580,109 +432,7 @@ UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength)
 					{
 						;
 					}
-					}
-					else
-					{
-						/*解析第二个ATS下发的取消区间疏散首次消息*/
-						cAtsId = dataBuf[ii];  /* ATS编号 */
-						ii++;
-						if (0U < cAtsId)
-						{
-							cStation = dataBuf[ii]; 	/* 车站编号 */
-							ii++;
 
-							wIndex = ShortFromChar(&dataBuf[ii]);  /* 操作站编号 */
-							ii += 2U;
-							if (0U < wIndex)
-							{
-								cAtsSendRcId = dataBuf[ii];  /* TIOC编号 */
-								ii++;
-								if (cAtsSendRcId == chLocalId)
-								{
-									dwTrainHlhtId = LongFromChar(&dataBuf[ii]);	 /* 区间疏散列车互联互通编号 */
-									ii += 4U;
-									if ((0U < dwTrainHlhtId) && (UINT32_MAX > dwTrainHlhtId))
-									{
-										dwTime = LongFromChar(&dataBuf[ii]);  /* 命令下发消息时间 */
-										ii += 4U;
-
-										cCmdType = dataBuf[ii];  /* 类型 */
-										ii++;
-										if (ATS_EA_CMD_TYPE_CANCEL == cCmdType)
-										{
-											cLineAttr = dataBuf[ii];/* 线路属性 */
-											ii++;
-											if ((EA_AREA_ALL == cLineAttr) || (EA_AREA_UP == cLineAttr) || (EA_AREA_DOWN == cLineAttr))
-											{
-												;
-											}
-											else
-											{
-												debug_infor_printf((const)"ParseGateWayToCiDataFrame: Cmd Id[%d] Parse Line Attr[%d] Error\n", MSG_TYPE_EA_CANCLE_FIRST, cLineAttr);
-												chRtn = CI_ERROR;
-											}
-										}
-										else
-										{
-											debug_infor_printf((const)"ParseGateWayToCiDataFrame: Cmd Id[%d] Parse Cmd Type[%d] Error\n", MSG_TYPE_EA_CANCLE_FIRST, cCmdType);
-											chRtn = CI_ERROR;
-										}
-									}
-									else
-									{
-										debug_infor_printf((const)"ParseGateWayToCiDataFrame: Cmd Id[%d] Parse Train Id[%d] Error\n", MSG_TYPE_EA_CANCLE_FIRST, dwTrainHlhtId);
-										chRtn = CI_ERROR;
-									}
-								}
-								else
-								{
-									debug_infor_printf((const)"ParseGateWayToCiDataFrame: Cmd Id[%d] Parse Rc Id[%d] Error\n", MSG_TYPE_EA_CANCLE_FIRST, cAtsSendRcId);
-									chRtn = CI_ERROR;
-								}
-							}
-							else
-							{
-								debug_infor_printf((const)"ParseGateWayToCiDataFrame: Cmd Id[%d] Parse WorkStation Id[%d] Error\n", MSG_TYPE_EA_CANCLE_FIRST, wIndex);
-								chRtn = CI_ERROR;
-							}
-						}
-						else
-						{
-							debug_infor_printf((const)"ParseGateWayToCiDataFrame: Cmd Id[%d] Parse Ats Id[%d] Error\n", MSG_TYPE_EA_CANCLE_FIRST, cAtsId);
-							chRtn = CI_ERROR;
-						}
-
-						if (CI_SUCCESS == chRtn)
-						{
-							g_strSndAtsEaCfmFst.chFlag = FLAG_SET;
-							g_strSndAtsEaCfmFst.chTiocId = cAtsSendRcId;
-							g_strSndAtsEaCfmFst.chStation = cStation;
-							g_strSndAtsEaCfmFst.wIndex = wIndex;
-							g_strSndAtsEaCfmFst.dwTime = dwTime;
-							g_strSndAtsEaCfmFst.chOpStatus = CONFIRM_FIRST_OTHER_DEV_OP;  /*反馈其它操作站站操作中*/
-
-							/*计算CRC*/
-							szCrcTmp[jj] = cAtsId;
-							jj++;
-							szCrcTmp[jj] = cStation;
-							jj++;
-							ShortToChar(wIndex, &szCrcTmp[jj]);
-							jj += 2U;
-							LongToChar(dwTrainHlhtId, &szCrcTmp[jj]);
-							jj += 4U;
-							LongToChar(dwTime, &szCrcTmp[jj]);
-							jj += 4U;
-							szCrcTmp[jj] = cCmdType;
-							jj++;
-							szCrcTmp[jj] = cLineAttr;
-							jj++;
-							g_strSndAtsEaCfmFst.dwCrc32 = Tioc_CommonCrc32(szCrcTmp, jj);
-						}
-						else
-						{
-							;
-						}
-					}
 					break;
 				}
 				case MSG_TYPE_EA_CANCLE_SECOND:/* 区间疏散取消二次消息 */
@@ -701,9 +451,8 @@ UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength)
 					if (CI_SUCCESS == chRtn)
 					{
 						g_strAtsEaMsgSnd.chStation = dataBuf[ii++];		/* 车站编号 */
-						g_strAtsEaMsgSnd.wIndex = ShortFromChar(&dataBuf[ii]);	/* 操作站编号 */
+						g_strAtsEaMsgSnd.chIndex = dataBuf[ii++];		/* ²Ù×÷Õ¾±àºÅ */
-						ii += 2U;
+						if (0U < g_strAtsEaMsgSnd.chIndex)
-						if (0U < g_strAtsEaMsgSnd.wIndex)
 						{
 							;
 						}
@@ -806,10 +555,6 @@ UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength)
 				}
 				case MSG_TYPE_WLB_SET_FIRST:	/* 全线列车紧急制动一次命令 */
 				{
-					wIndex = ShortFromChar(&dataBuf[ii + 2U]);
-					if ((FLAG_SET != g_strAtsWlbMsgFst.chFlag) || (g_strAtsWlbMsgFst.wIndex == wIndex))
-					{
-						/*未收到或重复收到同一个ATS的一次命令时，解析第一个ATS下发的全线紧急制动首次消息*/
 					g_strAtsWlbMsgFst.dwCycle = Get2oo2CurCycleNum();	/* 接收到全线列车紧急制动命令周期号 */
 					g_strAtsWlbMsgFst.chAtsId = dataBuf[ii++];			/* ATS编号 */
 					if (0U < g_strAtsWlbMsgFst.chAtsId)
@@ -824,9 +569,8 @@ UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength)
 					if (CI_SUCCESS == chRtn)
 					{
 						g_strAtsWlbMsgFst.chStation = dataBuf[ii++];	/* 车站编号 */
-							g_strAtsWlbMsgFst.wIndex = ShortFromChar(&dataBuf[ii]);	/* 操作站编号 */
+						g_strAtsWlbMsgFst.chIndex = dataBuf[ii++];	/* ²Ù×÷Õ¾±àºÅ */
-							ii += 2U;
+						if (0U < g_strAtsWlbMsgFst.chIndex)
-							if (0U < g_strAtsWlbMsgFst.wIndex)
 						{
 							;
 						}
@@ -923,123 +667,7 @@ UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength)
 					{
 						;
 					}
-					}
-					else
-					{
-					    /*解析第二个ATS下发的全线紧急制动首次消息*/
-						cAtsId = dataBuf[ii];  /* ATS编号 */
-						ii++;
-						if (0U < cAtsId)
-						{
-							cStation = dataBuf[ii];  /* 车站编号 */
-							ii++;
 
-							wIndex = ShortFromChar(&dataBuf[ii]);  /* 操作站编号 */
-							ii += 2U;
-							if (0U < wIndex)
-							{
-								cAtsSendRcId = dataBuf[ii];  /* TIOC编号 */
-								ii++;
-								if (cAtsSendRcId == chLocalId)
-								{
-									cDevType = dataBuf[ii];  /* 制动类型：集中区制动或物理区段制动 */
-									ii++;
-									if ((WLB_TYPE_RC == cDevType) || (WLB_TYPE_PHYSEC == cDevType))
-									{
-										cDevNum = dataBuf[ii];  /* 数量 */
-										ii++;
-										if (1U == cDevNum)
-										{
-											wDevId = ShortFromChar(&dataBuf[ii]); /* ID */
-											ii += 2U;
-
-											chRtn = WlbUrgentIdCheck(cDevType, wDevId);  /*校验紧急ID是否合法*/
-											if (CI_SUCCESS == chRtn)
-											{
-												dwTime = LongFromChar(&dataBuf[ii]);  /* 下发消息时间 */
-												ii += 4U;
-
-												cCmdType = dataBuf[ii];  /* 命令类型 */
-												ii++;
-												if ((MSG_TYPE_WLB_SET == cCmdType) || (MSG_TYPE_WLB_CANCEL == cCmdType))
-												{
-													;
-												}
-												else
-												{
-													debug_infor_printf((const)"ParseGateWayToCiDataFrame: Cmd Id[%d] Parse Cmd Type[%d] Error\n", MSG_TYPE_WLB_SET_FIRST, cCmdType);
-													chRtn = CI_ERROR;
-												}
-											}
-											else
-											{
-												debug_infor_printf((const)"ParseGateWayToCiDataFrame: Cmd Id[%d] Parse Dev Id[%d] Error\n", MSG_TYPE_WLB_SET_FIRST, wDevId);
-												chRtn = CI_ERROR;
-											}
-										}
-										else
-										{
-											debug_infor_printf((const)"ParseGateWayToCiDataFrame: Cmd Id[%d] Parse Dev Num[%d] Error\n", MSG_TYPE_WLB_SET_FIRST, cDevNum);
-											chRtn = CI_ERROR;
-										}
-									}
-									else
-									{
-										debug_infor_printf((const)"ParseGateWayToCiDataFrame: Cmd Id[%d] Parse Dev Type[%d] Error\n", MSG_TYPE_WLB_SET_FIRST, cDevType);
-										chRtn = CI_ERROR;
-									}
-								}
-								else
-								{
-									debug_infor_printf((const)"ParseGateWayToCiDataFrame: Cmd Id[%d] Parse Rc Id[%d] Error\n", MSG_TYPE_WLB_SET_FIRST, cAtsSendRcId);
-									chRtn = CI_ERROR;
-								}
-							}
-							else
-							{
-								debug_infor_printf((const)"ParseGateWayToCiDataFrame: Cmd Id[%d] Parse WorkStation Id[%d] Error\n", MSG_TYPE_WLB_SET_FIRST, wIndex);
-								chRtn = CI_ERROR;
-							}
-						}
-						else
-						{
-							debug_infor_printf((const)"ParseGateWayToCiDataFrame: Cmd Id[%d] Parse Ats Id[%d] Error\n", MSG_TYPE_WLB_SET_FIRST, cAtsId);
-							chRtn = CI_ERROR;
-						}
-
-						if (CI_SUCCESS == chRtn)
-						{
-							g_strSndAtsWlbCfmFst.chFlag = FLAG_SET;
-							g_strSndAtsWlbCfmFst.chTiocId = cAtsSendRcId;
-							g_strSndAtsWlbCfmFst.chStation = cStation;
-							g_strSndAtsWlbCfmFst.wIndex = wIndex;
-							g_strSndAtsWlbCfmFst.dwTime = dwTime;
-							g_strSndAtsWlbCfmFst.chOpStatus = CONFIRM_FIRST_OTHER_DEV_OP;  /*反馈其它操作站站操作中*/
-
-							/*计算CRC*/
-							szCrcTmp[jj] = cAtsId;
-							jj++;
-							szCrcTmp[jj] = cStation;
-							jj++;
-							ShortToChar(wIndex, &szCrcTmp[jj]);
-							jj += 2U;
-							szCrcTmp[jj] = cDevType;
-							jj++;
-							szCrcTmp[jj] = cDevNum;
-							jj++;
-							ShortToChar(wDevId, &szCrcTmp[jj]);
-							jj += 2U;
-							LongToChar(dwTime, &szCrcTmp[jj]);
-							jj += 4U;
-							szCrcTmp[jj] = cCmdType;
-							jj++;
-							g_strSndAtsWlbCfmFst.dwCrc32 = Tioc_CommonCrc32(szCrcTmp, jj);
-						}
-						else
-						{
-							;
-						}
-					}
 					break;
 				}
 				case MSG_TYPE_WLB_SET_SECOND:	/* 全线列车紧急制动二次命令 */
@@ -1058,9 +686,8 @@ UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength)
 					if (CI_SUCCESS == chRtn)
 					{
 						g_strAtsWlbMsgSnd.chStation = dataBuf[ii++];		/* 车站编号 */
-						g_strAtsWlbMsgSnd.wIndex = ShortFromChar(&dataBuf[ii]);		/* 操作站编号 */
+						g_strAtsWlbMsgSnd.chIndex = dataBuf[ii++];		/* ²Ù×÷Õ¾±àºÅ */
-						ii += 2U;
+						if (0U < g_strAtsWlbMsgSnd.chIndex)
-						if (0U < g_strAtsWlbMsgSnd.wIndex)
 						{
 							;
 						}
@@ -1174,10 +801,6 @@ UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength)
 				}
 				case MSG_TYPE_DA_CANCLE_FIRST:/* 脱轨防护区取消首次消息 */
 				{
-					wIndex = ShortFromChar(&dataBuf[ii + 2U]);
-					if ((FLAG_SET != g_strAtsDaMsgFst.chFlag) || (g_strAtsDaMsgFst.wIndex == wIndex))
-					{
-						/*未收到或重复收到同一个ATS的一次命令时，解析第一个ATS下发的取消脱轨防护首次消息*/
 					g_strAtsDaMsgFst.dwCycle = Get2oo2CurCycleNum();	/* 接收到取消脱轨防护区消息的周期号 */
 					g_strAtsDaMsgFst.chAtsId = dataBuf[ii++];			/* ATS编号 */
 					if (0U < g_strAtsDaMsgFst.chAtsId)
@@ -1192,9 +815,8 @@ UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength)
 					if (CI_SUCCESS == chRtn)
 					{
 						g_strAtsDaMsgFst.chStation = dataBuf[ii++];	/* 车站编号 */
-							g_strAtsDaMsgFst.wIndex = ShortFromChar(&dataBuf[ii]);	/* 操作站编号 */
+						g_strAtsDaMsgFst.chIndex = dataBuf[ii++];	/* ²Ù×÷Õ¾±àºÅ */
-							ii += 2U;
+						if (0U < g_strAtsDaMsgFst.chIndex)
-							if (0U < g_strAtsDaMsgFst.wIndex)
 						{
 							;
 						}
@@ -1281,109 +903,7 @@ UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength)
 					{
 						;
 					}
-					}
-					else
-					{
-						/*解析第二个ATS下发的取消脱轨防护首次消息*/
-						cAtsId = dataBuf[ii];  /* ATS编号 */
-						ii++;
-						if (0U < cAtsId)
-						{
-							cStation = dataBuf[ii];  /* 车站编号 */
-							ii++;
 
-							wIndex = ShortFromChar(&dataBuf[ii]);  /* 操作站编号 */
-							ii += 2U;
-							if (0U < wIndex)
-							{
-								cAtsSendRcId = dataBuf[ii];  /* TIOC编号 */
-								ii++;
-								if (cAtsSendRcId == chLocalId)
-								{
-									dwTrainHlhtId = LongFromChar(&dataBuf[ii]);  /* 脱轨列车互联互通编号 */
-									ii += 4U;
-									if ((0U < dwTrainHlhtId) && (UINT32_MAX > dwTrainHlhtId))
-									{
-										dwTime = LongFromChar(&dataBuf[ii]);  /* 下发消息时间 */
-										ii += 4U;
-
-										cCmdType = dataBuf[ii];  /* 类型 */
-										ii++;
-										if (ATS_DA_CMD_TYPE_CANCEL == cCmdType)
-										{
-											cLineAttr = dataBuf[ii];  /* 线路属性 */
-											ii++;
-											if ((DA_AREA_ALL == cLineAttr) || (DA_AREA_UP == cLineAttr) || (DA_AREA_DOWN == cLineAttr))
-											{
-												;
-											}
-											else
-											{
-												debug_infor_printf((const)"ParseGateWayToCiDataFrame: Cmd Id[%d] Parse Line Attr[%d] Error\n", MSG_TYPE_DA_CANCLE_FIRST, cLineAttr);
-												chRtn = CI_ERROR;
-											}
-										}
-										else
-										{
-											debug_infor_printf((const)"ParseGateWayToCiDataFrame: Cmd Id[%d] Parse Cmd Type[%d] Error\n", MSG_TYPE_DA_CANCLE_FIRST, cCmdType);
-											chRtn = CI_ERROR;
-										}
-									}
-									else
-									{
-										debug_infor_printf((const)"ParseGateWayToCiDataFrame: Cmd Id[%d] Parse Train Id[%d] Error\n", MSG_TYPE_DA_CANCLE_FIRST, dwTrainHlhtId);
-										chRtn = CI_ERROR;
-									}
-								}
-								else
-								{
-									debug_infor_printf((const)"ParseGateWayToCiDataFrame: Cmd Id[%d] Parse Rc Id[%d] Error\n", MSG_TYPE_DA_CANCLE_FIRST, cAtsSendRcId);
-									chRtn = CI_ERROR;
-								}
-							}
-							else
-							{
-								debug_infor_printf((const)"ParseGateWayToCiDataFrame: Cmd Id[%d] Parse WorkStation Id[%d] Error\n", MSG_TYPE_DA_CANCLE_FIRST, wIndex);
-								chRtn = CI_ERROR;
-							}
-						}
-						else
-						{
-							debug_infor_printf((const)"ParseGateWayToCiDataFrame: Cmd Id[%d] Parse Ats Id[%d] Error\n", MSG_TYPE_DA_CANCLE_FIRST, cAtsId);
-							chRtn = CI_ERROR;
-						}
-
-						if (CI_SUCCESS == chRtn)
-						{
-							g_strSndAtsDaCfmFst.chFlag = FLAG_SET;
-							g_strSndAtsDaCfmFst.chTiocId = cAtsSendRcId;
-							g_strSndAtsDaCfmFst.chStation = cStation;
-							g_strSndAtsDaCfmFst.wIndex = wIndex;
-							g_strSndAtsDaCfmFst.dwTime = dwTime;
-							g_strSndAtsDaCfmFst.chOpStatus = CONFIRM_FIRST_OTHER_DEV_OP;  /*反馈其它操作站站操作中*/
-
-							/*计算CRC*/
-							szCrcTmp[jj] = cAtsId;
-							jj++;
-							szCrcTmp[jj] = cStation;
-							jj++;
-							ShortToChar(wIndex, &szCrcTmp[jj]);
-							jj += 2U;
-							LongToChar(dwTrainHlhtId, &szCrcTmp[jj]);
-							jj += 4U;
-							LongToChar(dwTime, &szCrcTmp[jj]);
-							jj += 4U;
-							szCrcTmp[jj] = cCmdType;
-							jj++;
-							szCrcTmp[jj] = cLineAttr;
-							jj++;
-							g_strSndAtsDaCfmFst.dwCrc32 = Tioc_CommonCrc32(szCrcTmp, jj);
-						}
-						else
-						{
-							;
-						}
-					}
 					break;
 				}
 				case MSG_TYPE_DA_CANCLE_SECOND:/* 脱轨防护区取消二次消息 */
@@ -1402,9 +922,8 @@ UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength)
 					if (CI_SUCCESS == chRtn)
 					{
 						g_strAtsDaMsgSnd.chStation = dataBuf[ii++];		/* 车站编号 */
-						g_strAtsDaMsgSnd.wIndex = ShortFromChar(&dataBuf[ii]);		/* 操作站编号 */
+						g_strAtsDaMsgSnd.chIndex = dataBuf[ii++];		/* ²Ù×÷Õ¾±àºÅ */
-						ii += 2U;
+						if (0U < g_strAtsDaMsgSnd.chIndex)
-						if (0U < g_strAtsDaMsgSnd.wIndex)
 						{
 							;
 						}
@@ -1553,12 +1072,7 @@ UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength)
 		ClearAtsWlbMsgSecond();
 		ClearAtsDaMsgFirst();
 		ClearAtsDaMsgSecond();
-		ClearSndAtsScreenFstCfmMsg();
-		ClearSndAtsEaFstCfmMsg();
-		ClearSndAtsWlbFstCfmMsg();
-		ClearSndAtsDaFstCfmMsg();
 	}
-
 	return chRtn;
 }
 
@@ -1946,8 +1460,7 @@ UINT8 PackTiocToGateWayData(const UINT8 deviceId, const UINT8 targetDevType)
 				szToGateWayDataBuf[ii++] = MSG_TYPE_CONFIRM_FIRST;
 				szToGateWayDataBuf[ii++] = chLocalId;							/* TIOC编号 */
 				szToGateWayDataBuf[ii++] = g_strAtsCfmFst.chStation;			/* 车站编号 */
-				ShortToChar(g_strAtsCfmFst.wIndex, &szToGateWayDataBuf[ii]);        /* 操作站编号 */
+				szToGateWayDataBuf[ii++] = g_strAtsCfmFst.chIndex;				/* ²Ù×÷Õ¾±àºÅ */
-				ii += 2U;
 				LongToChar(g_strAtsCfmFst.dwTime, &szToGateWayDataBuf[ii]);		/* 时间 */
 				ii += 4u;
 				szToGateWayDataBuf[ii++] = g_strAtsCfmFst.chOpStatus;			/* 确认结果 */
@@ -1968,46 +1481,6 @@ UINT8 PackTiocToGateWayData(const UINT8 deviceId, const UINT8 targetDevType)
 			;
 		}
 
-		if (CI_SUCCESS == chRtn)
-		{
-			/*组第二个ATS的远程筛选首次确认信息*/
-			if (FLAG_SET == g_strSndAtsCfmFst.chFlag)
-			{
-				szToGateWayDataBuf[ii] = MSG_TYPE_CONFIRM_FIRST;				/* 帧类型 */
-				ii++;
-				wMsgLenIndex = ii;												/* 记录帧长度存放下标 */
-				ii += 2U;
-				szToGateWayDataBuf[ii] = MSG_TYPE_CONFIRM_FIRST;
-				ii++;
-				szToGateWayDataBuf[ii] = chLocalId;							/* TIOC编号 */
-				ii++;
-				szToGateWayDataBuf[ii] = g_strSndAtsCfmFst.chStation;			/* 车站编号 */
-				ii++;
-				ShortToChar(g_strSndAtsCfmFst.wIndex, &szToGateWayDataBuf[ii]);        /* 操作站编号 */
-				ii += 2U;
-				LongToChar(g_strSndAtsCfmFst.dwTime, &szToGateWayDataBuf[ii]);		/* 时间 */
-				ii += 4U;
-				szToGateWayDataBuf[ii] = g_strSndAtsCfmFst.chOpStatus;			/* 确认结果 */
-				ii++;
-				LongToChar(g_strSndAtsCfmFst.dwCrc32, &szToGateWayDataBuf[ii]);	/* CRC */
-				ii += 4U;
-				wMsgLen = (ii - wMsgLenIndex - 2U);
-				ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]);		/* 帧长度 */
-				chMsgNum++;														/* 消息数量递增 */
-
-				/*组包后清除第二个ATS的确认信息*/
-				ClearSndAtsScreenFstCfmMsg();
-			}
-			else
-			{
-				;
-			}			
-		}
-		else
-		{
-			;
-		}
-
 		if (CI_SUCCESS == chRtn)
 		{
 			if (FLAG_SET == g_strAtsCfmSnd.chFlag)
@@ -2018,8 +1491,7 @@ UINT8 PackTiocToGateWayData(const UINT8 deviceId, const UINT8 targetDevType)
 				szToGateWayDataBuf[ii++] = MSG_TYPE_CONFIRM_SECOND;
 				szToGateWayDataBuf[ii++] = chLocalId;							/* TIOC编号 */
 				szToGateWayDataBuf[ii++] = g_strAtsCfmSnd.chStation;			/* 车站编号 */
-				ShortToChar(g_strAtsCfmSnd.wIndex, &szToGateWayDataBuf[ii]);    /* 操作站编号 */
+				szToGateWayDataBuf[ii++] = g_strAtsCfmSnd.chIndex;				/* ²Ù×÷Õ¾±àºÅ */
-				ii += 2U;
 				LongToChar(g_strAtsCfmSnd.dwTime, &szToGateWayDataBuf[ii]);		/* 时间 */
 				ii += 4u;
 				szToGateWayDataBuf[ii++] = g_strAtsCfmSnd.chOpStatus;			/* 确认结果 */
@@ -2129,8 +1601,7 @@ UINT8 PackTiocToGateWayData(const UINT8 deviceId, const UINT8 targetDevType)
 				szToGateWayDataBuf[ii++] = MSG_TYPE_EA_CONFIRM_FIRST;
 				szToGateWayDataBuf[ii++] = chLocalId;							/* TIOC编号 */
 				szToGateWayDataBuf[ii++] = g_strAtsEaCfmFst.chStation;			/* 车站编号 */
-				ShortToChar(g_strAtsEaCfmFst.wIndex, &szToGateWayDataBuf[ii]);  /* 操作站编号 */
+				szToGateWayDataBuf[ii++] = g_strAtsEaCfmFst.chIndex;				/* ²Ù×÷Õ¾±àºÅ */
-				ii += 2U;
 				LongToChar(g_strAtsEaCfmFst.dwTime, &szToGateWayDataBuf[ii]);		/* 时间 */
 				ii += 4u;
 				szToGateWayDataBuf[ii++] = g_strAtsEaCfmFst.chOpStatus;			/* 确认结果 */
@@ -2151,46 +1622,6 @@ UINT8 PackTiocToGateWayData(const UINT8 deviceId, const UINT8 targetDevType)
 			;
 		}
 
-		if (CI_SUCCESS == chRtn)
-		{
-			/*组第二个ATS的取消区间疏散首次确认信息*/
-			if (FLAG_SET == g_strSndAtsEaCfmFst.chFlag)
-			{
-				szToGateWayDataBuf[ii] = MSG_TYPE_EA_CONFIRM_FIRST;			/* 帧类型 */
-				ii++;
-				wMsgLenIndex = ii;												/* 记录帧长度存放下标 */
-				ii += 2U;
-				szToGateWayDataBuf[ii] = MSG_TYPE_EA_CONFIRM_FIRST;
-				ii++;
-				szToGateWayDataBuf[ii] = chLocalId;							/* TIOC编号 */
-				ii++;
-				szToGateWayDataBuf[ii] = g_strSndAtsEaCfmFst.chStation;			/* 车站编号 */
-				ii++;
-				ShortToChar(g_strSndAtsEaCfmFst.wIndex, &szToGateWayDataBuf[ii]);  /* 操作站编号 */
-				ii += 2U;
-				LongToChar(g_strSndAtsEaCfmFst.dwTime, &szToGateWayDataBuf[ii]);		/* 时间 */
-				ii += 4U;
-				szToGateWayDataBuf[ii] = g_strSndAtsEaCfmFst.chOpStatus;			/* 确认结果 */
-				ii++;
-				LongToChar(g_strSndAtsEaCfmFst.dwCrc32, &szToGateWayDataBuf[ii]);	/* CRC */
-				ii += 4U;
-				wMsgLen = (ii - wMsgLenIndex - 2U);
-				ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]);		/* 帧长度 */
-				chMsgNum++;														/* 消息数量递增 */
-
-				/*组包后清除第二个ATS的确认信息*/
-				ClearSndAtsEaFstCfmMsg();
-			}
-			else
-			{
-				;
-			}
-		}
-		else
-		{
-			;
-		}
-
 		if (CI_SUCCESS == chRtn)
 		{
 			if (FLAG_SET == g_strAtsEaCfmSnd.chFlag)
@@ -2201,8 +1632,7 @@ UINT8 PackTiocToGateWayData(const UINT8 deviceId, const UINT8 targetDevType)
 				szToGateWayDataBuf[ii++] = MSG_TYPE_EA_CONFIRM_SECOND;
 				szToGateWayDataBuf[ii++] = chLocalId;							/* TIOC编号 */
 				szToGateWayDataBuf[ii++] = g_strAtsEaCfmSnd.chStation;			/* 车站编号 */
-				ShortToChar(g_strAtsEaCfmSnd.wIndex, &szToGateWayDataBuf[ii]);  /* 操作站编号 */
+				szToGateWayDataBuf[ii++] = g_strAtsEaCfmSnd.chIndex;				/* ²Ù×÷Õ¾±àºÅ */
-				ii += 2U;
 				LongToChar(g_strAtsEaCfmSnd.dwTime, &szToGateWayDataBuf[ii]);		/* 时间 */
 				ii += 4u;
 				szToGateWayDataBuf[ii++] = g_strAtsEaCfmSnd.chOpStatus;			/* 确认结果 */
@@ -2290,8 +1720,8 @@ UINT8 PackTiocToGateWayData(const UINT8 deviceId, const UINT8 targetDevType)
 				szToGateWayDataBuf[ii++] = MSG_TYPE_WLB_CONFIRM_FIRST;
 				szToGateWayDataBuf[ii++] = chLocalId;							/* TIOC编号 */
 				szToGateWayDataBuf[ii++] = g_strAtsWlbCfmFst.chStation;			/* 车站编号 */
-				ShortToChar(g_strAtsWlbCfmFst.wIndex, &szToGateWayDataBuf[ii]); /* 操作站编号 */
+				szToGateWayDataBuf[ii++] = g_strAtsWlbCfmFst.chIndex;			/* ²Ù×÷Õ¾±àºÅ */
-				ii += 2U;
+
 				LongToChar(g_strAtsWlbCfmFst.dwTime, &szToGateWayDataBuf[ii]);	/* 时间 */
 				ii += 4u;
 				szToGateWayDataBuf[ii++] = g_strAtsWlbCfmFst.chOpStatus;		/* 确认结果 */
@@ -2312,46 +1742,6 @@ UINT8 PackTiocToGateWayData(const UINT8 deviceId, const UINT8 targetDevType)
 			;
 		}
 
-		if (CI_SUCCESS == chRtn)
-		{
-			/*组第二个ATS的全线紧急制动首次确认信息*/
-			if (FLAG_SET == g_strSndAtsWlbCfmFst.chFlag)
-			{
-				szToGateWayDataBuf[ii] = MSG_TYPE_WLB_CONFIRM_FIRST;			/* 帧类型 */
-				ii++;
-				wMsgLenIndex = ii;												/* 记录帧长度存放下标 */
-				ii += 2U;
-				szToGateWayDataBuf[ii] = MSG_TYPE_WLB_CONFIRM_FIRST;
-				ii++;
-				szToGateWayDataBuf[ii] = chLocalId;							/* TIOC编号 */
-				ii++;
-				szToGateWayDataBuf[ii] = g_strSndAtsWlbCfmFst.chStation;			/* 车站编号 */
-				ii++;
-				ShortToChar(g_strSndAtsWlbCfmFst.wIndex, &szToGateWayDataBuf[ii]); /* 操作站编号 */
-				ii += 2U;
-				LongToChar(g_strSndAtsWlbCfmFst.dwTime, &szToGateWayDataBuf[ii]);	/* 时间 */
-				ii += 4U;
-				szToGateWayDataBuf[ii] = g_strSndAtsWlbCfmFst.chOpStatus;		/* 确认结果 */
-				ii++;
-				LongToChar(g_strSndAtsWlbCfmFst.dwCrc32, &szToGateWayDataBuf[ii]);	/* CRC */
-				ii += 4U;
-				wMsgLen = (ii - wMsgLenIndex - 2U);
-				ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]);		/* 帧长度 */
-				chMsgNum++;														/* 消息数量递增 */
-
-				/*组包后清除第二个ATS的确认信息*/
-				ClearSndAtsWlbFstCfmMsg();
-			}
-			else
-			{
-				;
-			}
-		}
-		else
-		{
-			;
-		}
-
 		if (CI_SUCCESS == chRtn)
 		{
 			if (FLAG_SET == g_strAtsWlbCfmSnd.chFlag)
@@ -2362,8 +1752,8 @@ UINT8 PackTiocToGateWayData(const UINT8 deviceId, const UINT8 targetDevType)
 				szToGateWayDataBuf[ii++] = MSG_TYPE_WLB_CONFIRM_SECOND;
 				szToGateWayDataBuf[ii++] = chLocalId;							/* TIOC编号 */
 				szToGateWayDataBuf[ii++] = g_strAtsWlbCfmSnd.chStation;			/* 车站编号 */
-				ShortToChar(g_strAtsWlbCfmSnd.wIndex, &szToGateWayDataBuf[ii]); /* 操作站编号 */
+				szToGateWayDataBuf[ii++] = g_strAtsWlbCfmSnd.chIndex;			/* ²Ù×÷Õ¾±àºÅ */
-				ii += 2U;
+
 				LongToChar(g_strAtsWlbCfmSnd.dwTime, &szToGateWayDataBuf[ii]);	/* 时间 */
 				ii += 4u;
 				szToGateWayDataBuf[ii++] = g_strAtsWlbCfmSnd.chOpStatus;		/* 确认结果 */
@@ -2469,8 +1859,7 @@ UINT8 PackTiocToGateWayData(const UINT8 deviceId, const UINT8 targetDevType)
 				szToGateWayDataBuf[ii++] = MSG_TYPE_DA_CONFIRM_FIRST;
 				szToGateWayDataBuf[ii++] = chLocalId;							/* TIOC编号 */
 				szToGateWayDataBuf[ii++] = g_strAtsDaCfmFst.chStation;			/* 车站编号 */
-				ShortToChar(g_strAtsDaCfmFst.wIndex, &szToGateWayDataBuf[ii]);  /* 操作站编号 */
+				szToGateWayDataBuf[ii++] = g_strAtsDaCfmFst.chIndex;				/* ²Ù×÷Õ¾±àºÅ */
-				ii += 2U;
 				LongToChar(g_strAtsDaCfmFst.dwTime, &szToGateWayDataBuf[ii]);		/* 时间 */
 				ii += 4u;
 				szToGateWayDataBuf[ii++] = g_strAtsDaCfmFst.chOpStatus;			/* 确认结果 */
@@ -2491,46 +1880,6 @@ UINT8 PackTiocToGateWayData(const UINT8 deviceId, const UINT8 targetDevType)
 			;
 		}
 
-		if (CI_SUCCESS == chRtn)
-		{
-			/*组第二个ATS的取消防护区域首次确认信息*/
-			if (FLAG_SET == g_strSndAtsDaCfmFst.chFlag)
-			{
-				szToGateWayDataBuf[ii] = MSG_TYPE_DA_CONFIRM_FIRST;			/* 帧类型 */
-				ii++;
-				wMsgLenIndex = ii;												/* 记录帧长度存放下标 */
-				ii += 2U;
-				szToGateWayDataBuf[ii] = MSG_TYPE_DA_CONFIRM_FIRST;
-				ii++;
-				szToGateWayDataBuf[ii] = chLocalId;							/* TIOC编号 */
-				ii++;
-				szToGateWayDataBuf[ii] = g_strSndAtsDaCfmFst.chStation;			/* 车站编号 */
-				ii++;
-				ShortToChar(g_strSndAtsDaCfmFst.wIndex, &szToGateWayDataBuf[ii]);  /* 操作站编号 */
-				ii += 2U;
-				LongToChar(g_strSndAtsDaCfmFst.dwTime, &szToGateWayDataBuf[ii]);		/* 时间 */
-				ii += 4U;
-				szToGateWayDataBuf[ii] = g_strSndAtsDaCfmFst.chOpStatus;			/* 确认结果 */
-				ii++;
-				LongToChar(g_strSndAtsDaCfmFst.dwCrc32, &szToGateWayDataBuf[ii]);	/* CRC */
-				ii += 4U;
-				wMsgLen = (ii - wMsgLenIndex - 2U);
-				ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]);		/* 帧长度 */
-				chMsgNum++;														/* 消息数量递增 */
-
-				/*组包后清除第二个ATS的确认信息*/
-				ClearSndAtsDaFstCfmMsg();
-			}
-			else
-			{
-				;
-			}
-		}
-		else
-		{
-			;
-		}
-
 		if (CI_SUCCESS == chRtn)
 		{
 			if (FLAG_SET == g_strAtsDaCfmSnd.chFlag)
@@ -2541,8 +1890,7 @@ UINT8 PackTiocToGateWayData(const UINT8 deviceId, const UINT8 targetDevType)
 				szToGateWayDataBuf[ii++] = MSG_TYPE_DA_CONFIRM_SECOND;
 				szToGateWayDataBuf[ii++] = chLocalId;							/* TIOC编号 */
 				szToGateWayDataBuf[ii++] = g_strAtsDaCfmSnd.chStation;			/* 车站编号 */
-				ShortToChar(g_strAtsDaCfmSnd.wIndex, &szToGateWayDataBuf[ii]);  /* 操作站编号 */
+				szToGateWayDataBuf[ii++] = g_strAtsDaCfmSnd.chIndex;				/* ²Ù×÷Õ¾±àºÅ */
-				ii += 2U;
 				LongToChar(g_strAtsDaCfmSnd.dwTime, &szToGateWayDataBuf[ii]);		/* 时间 */
 				ii += 4u;
 				szToGateWayDataBuf[ii++] = g_strAtsDaCfmSnd.chOpStatus;			/* 确认结果 */
@@ -2734,47 +2082,3 @@ UINT8 WlbUrgentIdCheck(const UINT8 cDeviceType, const UINT16 wDeviceId)
 
 	return retVal;
 }
-
-/**
-* @brief 清除第二个ATS的远程筛选一次确认信息
-* @param 无
-* @return 无
-* @note Created By LQ 2025.05.29
-*/
-void ClearSndAtsScreenFstCfmMsg(void)
-{
-	(void)CommonMemSet((void*)&g_strSndAtsCfmFst, (UINT32)sizeof(AtsMsgCfmStru), (UINT8)0U, (UINT32)sizeof(AtsMsgCfmStru));
-}
-
-/**
-* @brief 清除第二个ATS的取消区间疏散一次确认信息
-* @param 无
-* @return 无
-* @note Created By LQ 2025.05.29
-*/
-void ClearSndAtsEaFstCfmMsg(void)
-{
-	(void)CommonMemSet((void*)&g_strSndAtsEaCfmFst, (UINT32)sizeof(AtsMsgCfmStru), (UINT8)0U, (UINT32)sizeof(AtsMsgCfmStru));
-}
-
-/**
-* @brief 清除第二个ATS的全线紧急制动一次确认信息
-* @param 无
-* @return 无
-* @note Created By LQ 2025.05.29
-*/
-void ClearSndAtsWlbFstCfmMsg(void)
-{
-	(void)CommonMemSet((void*)&g_strSndAtsWlbCfmFst, (UINT32)sizeof(AtsMsgCfmStru), (UINT8)0U, (UINT32)sizeof(AtsMsgCfmStru));
-}
-
-/**
-* @brief 清除第二个ATS的取消脱轨防护一次确认信息
-* @param 无
-* @return 无
-* @note Created By LQ 2025.05.29
-*/
-void ClearSndAtsDaFstCfmMsg(void)
-{
-	(void)CommonMemSet((void*)&g_strSndAtsDaCfmFst, (UINT32)sizeof(AtsMsgCfmStru), (UINT8)0U, (UINT32)sizeof(AtsMsgCfmStru));
-}

TSCP/src/APP/ciapp/ParsePack/ParsePackGateWayData.h

@@ -33,24 +33,22 @@
 #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)		/*信息帧校验失败*/
+#define CONFIRM_SECOND_CRC		((UINT8)2u)		/*CRC校验失败*/
 #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_TRAIN_IN_EA		((UINT8)9u)		/*列车正在疏散*/
+#define CONFIRM_FIRST_EING		((UINT8)9u)		/*列车正在疏散*/
 
-#define CONFIRM_EA_SECOND_CRC	((UINT8)3u)		/*信息帧校验失败*/
+#define CONFIRM_EA_SECOND_CRC	((UINT8)3u)		/*CRC失败*/
 #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)	/*全线列车紧急制动取消*/
@@ -65,9 +63,8 @@
 
 #define CONFIRM_WLB_SND_UNKNOWN	((UINT8)0u)	/*二次回复未知*/
 #define CONFIRM_WLB_SND_SUCCESS	((UINT8)1u)	/*二次回复成功*/
-#define CONFIRM_WLB_SND_CRC		((UINT8)3u)	/*信息帧校验失败*/
+#define CONFIRM_WLB_SND_CRC		((UINT8)3u)	/*二次回复CRC失败*/
 #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)	/*取消脱轨防护区首次回复成功*/
@@ -76,11 +73,10 @@
 
 #define CONFIRM_DA_SND_UNKNOWN	((UINT8)0u)	/*取消脱轨防护区再次回复未知*/
 #define CONFIRM_DA_SND_SUCCESS	((UINT8)1u)	/*取消脱轨防护区再次回复成功*/
-#define CONFIRM_DA_SND_CRC		((UINT8)3u)	/*取消脱轨防护区再次回复信息帧校验失败*/
+#define CONFIRM_DA_SND_CRC		((UINT8)3u)	/*取消脱轨防护区再次回复CRC失败*/
 #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)	/* 下行区域 */
@@ -114,7 +110,7 @@ typedef struct
 	UINT32 dwCycle;			/*首次消息接收周期号*/
 	UINT8 chAtsId;			/*ATS编号*/
 	UINT8 chStation;		/*车站编号*/
-	UINT16 wIndex;			/*操作站编号*/
+	UINT8 chIndex;			/*操作站编号*/
 	UINT8 chTiocId;			/*TIOC编号*/
 	UINT32 dwTime;			/*时间*/
 	UINT8 chTrainNum;		/*列车数量*/
@@ -127,7 +123,7 @@ typedef struct
 	UINT8 chFlag;			/*消息有效性*/
 	UINT8 chTiocId;			/*TIOC编号*/
 	UINT8 chStation;		/*车站编号*/
-	UINT16 wIndex;			/*操作站编号*/
+	UINT8 chIndex;			/*操作站编号*/
 	UINT32 dwTime;			/*时间*/
 	UINT8 chOpStatus;		/*操作结果*/
 	UINT32 dwCrc32;			/*CRC*/
@@ -140,7 +136,7 @@ typedef struct
 	UINT32 dwCycle;			/*首次消息接收周期号*/
 	UINT8 chAtsId;			/*ATS编号*/
 	UINT8 chStation;		/*车站编号*/
-	UINT16 wIndex;			/*操作站编号*/
+	UINT8 chIndex;			/*操作站编号*/
 	UINT8 chTiocId;			/*TIOC编号*/
 	UINT32 dwTime;			/*时间*/
 	UINT8 chTrainNum;		/*列车数量*/
@@ -155,7 +151,7 @@ typedef struct
 	UINT32 dwCycle;			/*消息接收周期号*/
 	UINT8 chAtsId;			/*ATS编号*/
 	UINT8 chStation;		/*车站编号*/
-	UINT16 wIndex;			/*操作站编号*/
+	UINT8 chIndex;			/*操作站编号*/
 	UINT8 chTiocId;			/*TIOC编号*/
 	UINT32 dwEaTrainId;		/*列车互联互通编号*/
 	UINT32 dwTime;			/*时间*/
@@ -171,7 +167,7 @@ typedef struct
 	UINT32 dwCycle;			/*消息接收周期号*/
 	UINT8 chAtsId;			/*ATS编号*/
 	UINT8 chStation;		/*车站编号*/
-	UINT16 wIndex;			/*操作站编号*/
+	UINT8 chIndex;			/*操作站编号*/
 	UINT8 chTiocId;			/*TIOC编号*/
 	UINT32 dwTime;			/*时间*/
 	UINT8 chType;			/*设置/取消*/
@@ -188,7 +184,7 @@ typedef struct
 	UINT32 dwCycle;			/*消息接收周期号*/
 	UINT8 chAtsId;			/*ATS编号*/
 	UINT8 chStation;		/*车站编号*/
-	UINT16 wIndex;			/*操作站编号*/
+	UINT8 chIndex;			/*操作站编号*/
 	UINT8 chTiocId;			/*TIOC编号*/
 	UINT32 dwDaTrainId;		/*列车互联互通编号*/
 	UINT32 dwTime;			/*时间*/
@@ -218,11 +214,6 @@ 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首次消息
@@ -417,36 +408,4 @@ 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

@@ -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)
 	{
-		retVal = ParseIteToCiDataFrame(dataBuf, dataLength, systemId, &parseCheckIte, &cGalHeadSavedFlag, logId);
+		(void)CommonMemSet(&(IteToCiDataStru[IteToCiSum]), (UINT32)sizeof(IteToCiDataStruct), 0U, (UINT32)sizeof(IteToCiDataStruct));  /*ÇĺÄڴ棏ˇŔÖšÔŕĘýžÝ*/
+
+		retVal = ParseIteToCiDataFrame(dataBuf, dataLength, systemId, &(IteToCiDataStru[IteToCiSum]), &cGalHeadSavedFlag, logId);
 		
 		if (CI_SUCCESS == retVal)
 		{
+			IteToCiSum++;
 			/*遍历所有通信的ITE，查找ITE通信结构体中是否已存在当前ITE*/
-			for (ii = 0u; ii < IteToCiSum; ii++)
+			for (ii = 0u; ii < (IteToCiSum - 1U); ii++)
 			{				
-				if ((IteToCiDataStru[ii].wIteId == parseCheckIte.wIteId) && (IteToCiDataStru[ii].wIteLogId == parseCheckIte.wIteLogId))
+				if ((IteToCiDataStru[ii].wIteId == IteToCiDataStru[IteToCiSum - 1U].wIteId) && (IteToCiDataStru[ii].wIteLogId == IteToCiDataStru[IteToCiSum - 1U].wIteLogId))
 				{
 					/*目标ITE已存在于通信结构体中，将解析出的数据拷入之前存储的地址*/
-					(void)CommonMemSet(&(IteToCiDataStru[ii]), (UINT32)sizeof(IteToCiDataStruct), 0U, (UINT32)sizeof(IteToCiDataStruct));  /*清内存，防止脏数据*/
+					(void)CommonMemCpy(&(IteToCiDataStru[ii]), (UINT32)sizeof(IteToCiDataStruct), &(IteToCiDataStru[IteToCiSum - 1U]), (UINT32)sizeof(IteToCiDataStruct));
-					(void)CommonMemCpy(&(IteToCiDataStru[ii]), (UINT32)sizeof(IteToCiDataStruct), &parseCheckIte, (UINT32)sizeof(IteToCiDataStruct));
+					IteToCiSum--;
-					chFind = CI_SUCCESS;
 					break;
 				}
 				else
@@ -93,16 +93,6 @@ 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
 		{

TSCP/src/APP/ciapp/ParsePack/ParsePackManage.c

@@ -237,7 +237,11 @@ UINT8 ParseOtherSysToCiData(void)
 				if (ocId == chLocalCiId)/*如果oc id所属的ci id为本机联锁id*/
 				{
 					oc2ciParseResult = ParseOcToCiDataFrame(data, (UINT16)dataLen, devId);
-					if (CI_CHECK_LEN_ERROR == oc2ciParseResult)
+					if (CI_ERROR == oc2ciParseResult)
+					{
+						/*解析OC数据错误处理，这个错误已经处理，连续10个周期，会通信中断，导向安全*/
+					}
+					else if (CI_CHECK_LEN_ERROR == oc2ciParseResult)
 					{
 						/*长度校验错误处理，把此OC原始缓存所有设备状态导向安全*/
 						/* 长度校验失败处理：
@@ -257,11 +261,7 @@ UINT8 ParseOtherSysToCiData(void)
 					}
 					else
 					{
-						/*其它值，清除缓存数据*/
+						/*其它值，什么也不做*/
-						ResetOcOriginalState(devId);
-						ConvertOcOriginDataToPtData();/*把解析的OC板卡数据转换为OC点位数据*/
-						ConvertOcOriginDataToOcSigSwDev();/*把解析的OC设备数据转换为OC 信号机和 OC 道岔设备数据和OC轨道区段数据*/
-						debug_infor_printf((const)"OC Id %d parse ERROR.", devId);
 					}
 				}
 				else
@@ -1008,18 +1008,11 @@ 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");
@@ -1038,8 +1031,6 @@ UINT8 PackCiToOtherSysData(void)
 	PackCiToCimDeviceData();
 	/*发送维护机飞车报警*/
 	PackCiToCimFlyProtectData();
-	/*发送维护机IO双系采集不一致报警*/
-	PackCiToCimCollDiffData();
 	/*发送给AIM退出运营信息*/
 	AIMOutput();
 	/*发送给维护机执行单元报警信息*/

TSCP/src/APP/ciapp/ParsePack/ParsePackOcData.c

@@ -93,7 +93,6 @@ UINT16 ConvertSigDrvColorToSigDrvCmd(const UINT16 signalId, const UINT8 drvColor
 	UINT16 retDrvCmd = 0u;
 	UINT8 ocHasBlue = 0u;
 	UINT8 funSwitchGreenYellow = GetCiFunctionSwitchConfig(CI_FUNCTION_SWITCH_SHOW_SIGNAL_GreenYellow);/*显示绿黄功能开关是否打开*/
-	UINT8 funSwitchALLCloseUseBlue = GetCiFunctionSwitchConfig(FUNC_SWITCH_ZX_ALLCLOSE_USEBLUE);/*杭德正线灭灯均转蓝灯功能开关*/
 	UINT8 ciType = GetLocalCiType();
 	switch (drvColor)
 	{
@@ -119,7 +118,7 @@ UINT16 ConvertSigDrvColorToSigDrvCmd(const UINT16 signalId, const UINT8 drvColor
 		retDrvCmd = OC_SIGNAL_DRIVECOLOR_GREEN;
 		break;
 	case SIGNAL_DRIVECOLOUR_YELLOWCLOSE:/*黄灭*/
-		if ((FUNC_SWITCH_ON == funSwitchGreenYellow)||(FUNC_SWITCH_ON == funSwitchALLCloseUseBlue))
+		if (FUNC_SWITCH_ON == funSwitchGreenYellow)
 		{
 			retDrvCmd = OC_SIGNAL_DRIVECOLOR_BLUE;
 		}
@@ -129,17 +128,10 @@ UINT16 ConvertSigDrvColorToSigDrvCmd(const UINT16 signalId, const UINT8 drvColor
 		}
 		break;
 	case SIGNAL_DRIVECOLOUR_REDCLOSE:/*红灭*/
-		if (FUNC_SWITCH_ON == funSwitchALLCloseUseBlue)
-		{
-			retDrvCmd = OC_SIGNAL_DRIVECOLOR_BLUE;/*杭德红灭驱蓝需求*/
-		}
-		else
-		{
 		retDrvCmd = OC_SIGNAL_DRIVECOLOR_CLOSE;
-		}
 		break;
 	case SIGNAL_DRIVECOLOUR_GREENCLOSE:/*绿灭*/
-		if ((FUNC_SWITCH_ON == funSwitchGreenYellow) || (FUNC_SWITCH_ON == funSwitchALLCloseUseBlue))
+		if (FUNC_SWITCH_ON == funSwitchGreenYellow)
 		{
 			retDrvCmd = OC_SIGNAL_DRIVECOLOR_BLUE;
 		}
@@ -248,8 +240,6 @@ UINT8 PackCiToOcData( UINT8 deviceId)
 	UINT16 OcDevName = 0U; /*OC名称：类型+ID*/
 	UINT8 chSwitch = GetCiFunctionSwitchConfig(FUNC_OC_100_OR_200);
 	UINT8 chLocalOcType = GetLocalOcPattern(); /*OC类型*/
-	UINT16 deviceSum = 0u;
-	UINT16 kqChangeCommand = 0u;/*控权切换命令*/
 #if 0
 	QueueClear(CiToOcDataQueue);	/*清队列*/
 #endif
@@ -303,16 +293,7 @@ UINT8 PackCiToOcData( UINT8 deviceId)
 		ii += 2u;
 		ii += 2u;/*预留2个字节*/
 
-		if (OC_HAVE_YJK == pOcData->chHaveYjk)
+		ShortToChar(pOcData->OcDeviceNum, &Ci2OcDataBuffer[ii]);/*设备数量*/
-		{
-			deviceSum = pOcData->OcDeviceNum + 1u;		/*设备数量+控权切换*/
-		}
-		else
-		{
-			deviceSum = pOcData->OcDeviceNum;
-		}
-		
-		ShortToChar(deviceSum, &Ci2OcDataBuffer[ii]);/*设备数量*/
 		ii += 2u;
 		for (kk = 0u; kk < pOcData->OcDeviceNum; kk++)/*遍历设备*/
 		{
@@ -356,21 +337,6 @@ UINT8 PackCiToOcData( UINT8 deviceId)
 			}
 		}/*此为oc设备组包完毕*/
 
-		if (OC_HAVE_YJK == pOcData->chHaveYjk)
-		{
-			Ci2OcDataBuffer[ii++] = CI_SYSTEM_TYPE_OC;/*控权切换*/
-			ShortToChar(pOcData->OcId, &Ci2OcDataBuffer[ii]);/*设备ID*/
-			ii += 2u;
-
-			kqChangeCommand = GetKqChangeCommand();
-			ShortToChar(kqChangeCommand, &Ci2OcDataBuffer[ii]);/*控权切换命令*/
-			ii += 2u;
-		}
-		else
-		{/*不处理*/
-		}
-
-
 		pBoardNumStartIndex = ii;/*结束赋值*/
 		ii += 2u;/*跳过，最后赋值*/
 
@@ -612,7 +578,7 @@ UINT8 PackCiToOcData( UINT8 deviceId)
 		(void)CommonMemCpy(&Ci2OcDataBuffer[ii], OC_TO_CI_DATA_LEN_MAX-ii, ciSiToOc, ciSiToOcIdx);
 		ii += ciSiToOcIdx;
 
-		if ((FUNC_SWITCH_ON == chSwitch)&&(DATA_TYPE_NEW == chLocalOcType))
+		if ((FUNC_SWITCH_ON == chSwitch)&&(OC_DATA_TYPE_NEW == chLocalOcType))
 		{
 			/*OC200 数据结构25以上才支持SOR*/
 			Ci2OcDataBuffer[ii] = sorBoardNum;
@@ -639,7 +605,7 @@ UINT8 PackCiToOcData( UINT8 deviceId)
 		}
 #endif
 		/*OC100、OC数据结构24 接口保留预留20字节*/
-		if ((FUNC_SWITCH_OFF == chSwitch) || (DATA_TYPE_OLD == chLocalOcType)) 
+		if ((FUNC_SWITCH_OFF == chSwitch) || (OC_DATA_TYPE_OLD == chLocalOcType)) 
 		{
 			Ci2OcDataBuffer[ii++] = 0xffu;
 			Ci2OcDataBuffer[ii++] = 0xffu;
@@ -730,7 +696,6 @@ UINT8 CheckOc2CiDataLenValid(const UINT8* dataBuf, const UINT16 totalLength)
 	UINT8 sorBoardNumber = 0u;/*SOR板卡数量*/
 	UINT16 SwapBoardNumber = 0U;/*切系板卡数量*/
 	UINT8 chPbNumber = 0u;	/*执行电插箱数量*/
-	UINT8 chPsdNumber = 0u;	/*屏蔽门数量*/
 
 	UINT16 upToGDNumber = 0u;
 	UINT16 upToDIBoardNumber = 0u;
@@ -740,10 +705,8 @@ UINT8 CheckOc2CiDataLenValid(const UINT8* dataBuf, const UINT16 totalLength)
 	UINT16 upToSORBoardNumber = 0u;
 	UINT16 upToPbNumer = 0u;/*到执行电插箱数据个数*/
 	UINT16 upToSwapSysBoardNumber = 0U;
-	UINT16 upToPsdNumber = 0U;
 	UINT16 tmpTotalLen = 0u;/*临时变量：总长度*/
 	UINT8 chSwitch = 0u;
-	UINT8 ocInterfaceFlag = 0u;/*与OC接口标识*/
 	UINT8 ii = 0U;/*设备数量的循环变量*/
 	UINT16 wDevInfoIndex = LEN_OC_UP_TO_DEV_NO-1U;/*道岔包含转辙机个数索引 oc200使用*/
 	UINT16 wZzjStateNumber = 0U;/*转辙机状态所占字节数*/
@@ -754,7 +717,6 @@ UINT8 CheckOc2CiDataLenValid(const UINT8* dataBuf, const UINT16 totalLength)
 	{
 		retVal = CI_SUCCESS;
 		chSwitch = GetCiFunctionSwitchConfig(FUNC_OC_100_OR_200);
-		ocInterfaceFlag = GetCiFunctionSwitchConfig(FUNC_OC_INTERFACE_CONF);
 		if (totalLength < LEN_OC_UP_TO_DEV_NO)
 		{/*校验OC数据从开始到设备数量截止，计算设备数量*/
 			retVal = CI_CHECK_LEN_ERROR;
@@ -772,7 +734,7 @@ UINT8 CheckOc2CiDataLenValid(const UINT8* dataBuf, const UINT16 totalLength)
 		if (CI_SUCCESS == retVal)
 		{/*校验OC数据从开头到轨道板数据截止，计算轨道板数量*/
 
-			if (DATA_TYPE_NEW == chLocalOcType)
+			if (OC_DATA_TYPE_NEW == chLocalOcType)
 			{
 				/*计算道岔数据长度*/
 				switchNum = dataBuf[LEN_OC_UP_TO_DEV_NO - 2U];
@@ -797,8 +759,8 @@ UINT8 CheckOc2CiDataLenValid(const UINT8* dataBuf, const UINT16 totalLength)
 				for (ii = 0U; ii < devNumber; ii++)
 				{
 					wSwitchIncludeZzjIndex += 4U;
-					wZzjStateNumber = wZzjStateNumber +(UINT16)(dataBuf[wSwitchIncludeZzjIndex] * 1U);
+					wZzjStateNumber = wZzjStateNumber + (dataBuf[wSwitchIncludeZzjIndex] * 1U);
-					wSwitchIncludeZzjIndex += 1U + (UINT16)(dataBuf[wSwitchIncludeZzjIndex] * 1U) + 4U;
+					wSwitchIncludeZzjIndex += 1U + dataBuf[wSwitchIncludeZzjIndex] * 1U + 4U;
 				}
 				upToGDNumber = LEN_OC_UP_TO_GD_NO_200_2(devNumber, wZzjStateNumber);
 				wDevInfoIndex = upToGDNumber;
@@ -870,7 +832,7 @@ UINT8 CheckOc2CiDataLenValid(const UINT8* dataBuf, const UINT16 totalLength)
 				soBoardNumber = ShortFromChar(&dataBuf[upToSOBoardNumber - 2U]);
 			}
 		}
-		if (DATA_TYPE_NEW == chLocalOcType)
+		if (OC_DATA_TYPE_NEW == chLocalOcType)
 		{
 			wOffSet = 0U;
 			if (CI_SUCCESS == retVal)
@@ -910,7 +872,7 @@ UINT8 CheckOc2CiDataLenValid(const UINT8* dataBuf, const UINT16 totalLength)
 
 		if (CI_SUCCESS == retVal)
 		{/*校验OC数据从开头到切系板卡数据截止，计算切系板卡数量*/
-			upToSwapSysBoardNumber = LEN_OC_UP_TO_SWAPSYSBOARD_NO_200(wDevInfoIndex, gdBoardNumber, diBoardNumber, doBoardNumber, siBoardNumber, soBoardNumber, (UINT16)sorBoardNumber, (UINT16)chPbNumber);
+			upToSwapSysBoardNumber = LEN_OC_UP_TO_SWAPSYSBOARD_NO_200(wDevInfoIndex, gdBoardNumber, diBoardNumber, doBoardNumber, siBoardNumber, soBoardNumber, (UINT16)sorBoardNumber, chPbNumber);
 			upToSwapSysBoardNumber -= wOffSet;
 			if (totalLength < upToSwapSysBoardNumber)
 			{
@@ -923,19 +885,9 @@ UINT8 CheckOc2CiDataLenValid(const UINT8* dataBuf, const UINT16 totalLength)
 			}
 		}
 
-		if (CI_SUCCESS == retVal)
-		{/*校验OC数据从开头到屏蔽门数据截至，计算屏蔽门数量*/
-			upToPsdNumber = LEN_OC_UP_TO_END_200(wDevInfoIndex, gdBoardNumber, diBoardNumber, doBoardNumber, siBoardNumber, soBoardNumber, (UINT16)sorBoardNumber, (UINT16)chPbNumber, SwapBoardNumber);
-			upToPsdNumber -= wOffSet;
-			if (totalLength < upToPsdNumber)
-			{
-				retVal = CI_CHECK_LEN_ERROR;
-			}
-			else if (totalLength == upToPsdNumber)
-			{/*长度已经相等，后面没有屏蔽门数据*/
 		if (CI_SUCCESS == retVal)
 		{/*校验总数据长度*/
-					tmpTotalLen = LEN_OC_UP_TO_END_200(wDevInfoIndex, gdBoardNumber, diBoardNumber, doBoardNumber, siBoardNumber, soBoardNumber, (UINT16)sorBoardNumber, (UINT16)chPbNumber, SwapBoardNumber);
+			tmpTotalLen = LEN_OC_UP_TO_END_200(wDevInfoIndex, gdBoardNumber, diBoardNumber, doBoardNumber, siBoardNumber, soBoardNumber, (UINT16)sorBoardNumber, chPbNumber, SwapBoardNumber);
 			tmpTotalLen -= wOffSet;
 			if (totalLength == tmpTotalLen)
 			{
@@ -947,65 +899,6 @@ UINT8 CheckOc2CiDataLenValid(const UINT8* dataBuf, const UINT16 totalLength)
 			}
 		}
 	}
-			else
-			{
-				/*后面还有数据，即OC-200 3.3、OC-300 1.0.1*/
-				if (OC200_VER3_2_AFTER == ocInterfaceFlag)
-				{/*OC-200 3.2之后的版本，有应急盘数据*/
-					if (OC_HAVE_YJK == dataBuf[upToPsdNumber])
-					{/*具备应急控*/
-						tmpTotalLen = upToPsdNumber + 3u;
-					}
-					else
-					{/*不具备应急控*/
-						tmpTotalLen = upToPsdNumber + 1u;
-					}
-
-					if (totalLength == tmpTotalLen)
-					{
-						retVal = CI_SUCCESS;
-					}
-					else
-					{
-						retVal = CI_CHECK_LEN_ERROR;
-					}
-				}
-				else if (OC300_VER1_0_1_ANDAFTER == ocInterfaceFlag)
-				{/*OC-300 1.0.1之后的版本，有屏蔽门数据和应急盘数据*/
-					chPsdNumber = dataBuf[upToPsdNumber];
-
-					if (CI_SUCCESS == retVal)
-					{/*校验总数据长度*/
-						tmpTotalLen = LEN_OC_UP_TO_END_300(wDevInfoIndex, gdBoardNumber, diBoardNumber, doBoardNumber, siBoardNumber, soBoardNumber, (UINT16)sorBoardNumber, (UINT16)chPbNumber, SwapBoardNumber, (UINT16)chPsdNumber);
-						tmpTotalLen -= wOffSet;
-
-						/*屏蔽门数据与应急控数据一起发*/
-						if (OC_HAVE_YJK == dataBuf[tmpTotalLen])
-						{/*具备应急控*/
-							tmpTotalLen += 3u;
-						}
-						else
-						{/*不具备应急控*/
-							tmpTotalLen += 1u;
-						}
-
-						if (totalLength == tmpTotalLen)
-						{
-							retVal = CI_SUCCESS;
-						}
-						else
-						{
-							retVal = CI_CHECK_LEN_ERROR;
-						}
-					}
-				}
-				else
-				{
-				}
-			}
-		}
-		
-	}
 	else if (FUNC_SWITCH_OFF == chSwitch)
 	{
 		/*OC-100接口*/
@@ -1192,24 +1085,6 @@ void ResetOcOriginalState(const UINT8 ocId)
 				pDIBoard->BoardCollData[jj] = 0xaau;/*置SOR板卡继电器数据全部落下*/
 			}
 		}
-
-		SetOcToCiDefaultDataStru(toFindIndex);/*置屏蔽门信息为安全侧*/
-
-		m_OcToCiOrginDataArr[toFindIndex].PowerAState = (UINT8)0xff;
-		m_OcToCiOrginDataArr[toFindIndex].PowerBState = (UINT8)0xff;
-		m_OcToCiOrginDataArr[toFindIndex].OCDevFaultState = (UINT8)0xff;
-		m_OcToCiOrginDataArr[toFindIndex].FanState = (UINT8)0xff;
-
-		for (ii = 0u; ii < m_OcToCiOrginDataArr[toFindIndex].OCBoardSwapSysNum; ii++)
-		{
-			m_OcToCiOrginDataArr[toFindIndex].SwapSysBoardId[ii] = 0U;
-		}
-		m_OcToCiOrginDataArr[toFindIndex].OCBoardSwapSysNum = 0U;
-
-		CommonMemSet(m_OcToCiOrginDataArr[toFindIndex].szPlusBox, (UINT32)(MAX_OC_PLUS_BOX_NUM)*(sizeof(OcPlusBox)), 0U, (UINT32)(MAX_OC_PLUS_BOX_NUM*(sizeof(OcPlusBox))));
-		m_OcToCiOrginDataArr[toFindIndex].chPbNum = 0U;
-
-		SetAllCleFarePCBButKeepSta(m_OcToCiOrginDataArr[toFindIndex].OcId, QK_PSD_BUTTON_STATE_UP);
 	}
 }
 
@@ -1257,17 +1132,11 @@ UINT8 ParseOcToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength,const U
 	UINT16 tmpGdId = 0u;/*临时变量：临时轨道Id*/
 	UINT16 curBoardNum = 0u; /*当前板子数量*/
 	UINT16 curBoardSwapSysNum = 0U;/*切系板卡数量*/
-	UINT8 curPsdNum = 0u;	/*PSD数量*/
-	UINT32 psdId = 0u;      /*PSD 编号*/
-	UINT16 psdIndexId = 0u; /*PSD 编号ID*/
-	UINT8 funcRet = 0u;		/*PSD编号查询id函数返回值*/
-
 	UINT32 galOcDataVer = 0U;
 	UINT8 chPbIndex = 0u;
 	UINT8 chSwitch = 0u;
 	UINT8 chZzjStateIndex = 0u;/*道岔对应转辙机状态索引*/
 	UINT8 chOcType = GetLocalOcPattern(); /*获取OC数据结构类型*/
-	UINT8 ocInterfaceFlag = 0u;	/*与OC接口标识*/
 
 	for (j=0u;j<m_OcToCiOrginDataNum;j++)
 	{
@@ -1296,7 +1165,6 @@ UINT8 ParseOcToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength,const U
 	{
 		/* 获取OC型号（0xaa:200，0x55:100） */
 		chSwitch = GetCiFunctionSwitchConfig(FUNC_OC_100_OR_200);
-		ocInterfaceFlag = GetCiFunctionSwitchConfig(FUNC_OC_INTERFACE_CONF);
 		sourceId = GetCiTransmitSpecifySysDevBuf(CI_SYSTEM_TYPE_OC);/*获取与本联锁通信的OC的ID*/
 		
 		ii+=4u;/*跳4个字节，以后oc处理*/
@@ -1357,11 +1225,15 @@ UINT8 ParseOcToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength,const U
 				
 				pTmpOcToCiData->OcId = systemId; /*oc id赋值*/
 
+				pTmpOcToCiData->ComStartCycle = Get2oo2CurCycleNum();/*保存收到OC数据时的通信开始周期*/
+
+				debug_infor_printf((const)"\nId:%d OC_COM:%d\n",pTmpOcToCiData->OcId,pTmpOcToCiData->ComStartCycle);
+
 				if (OC_CI_STATE_INFO == appInfoType)/*OC给CI的状态信息 0x8802*/
 				{
 					/*by cgh 20230831 增加转辙机状态接口*/
 					/*fan 20241120 适配4牵引 OC3.0 接口 支持OC数据结构配置中较新数据结构*/
-					if ((FUNC_SWITCH_ON == chSwitch)&&(DATA_TYPE_NEW == chOcType))
+					if ((FUNC_SWITCH_ON == chSwitch)&&(OC_DATA_TYPE_NEW == chOcType))
 					{			
 						/*************解析设备[道岔]***********/
 						tmpDeviceType = CI_DEVICE_TYPE_SWITCH;
@@ -1696,7 +1568,7 @@ UINT8 ParseOcToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength,const U
 					}
 
 					/*************解析SOR板卡  仅适配OC-200且较新OC***********/
-					if ((CI_SUCCESS == retVal) && (FUNC_SWITCH_ON == chSwitch)&& (DATA_TYPE_NEW == chOcType))
+					if ((CI_SUCCESS == retVal) && (FUNC_SWITCH_ON == chSwitch)&& (OC_DATA_TYPE_NEW == chOcType))
 					{
 						pTmpOcToCiData->OcSORBoardNum = dataBuf[ii++];/*Sor板卡数量*/
 						if (MAX_OC_SOR_BOARD_NUM >= pTmpOcToCiData->OcSORBoardNum)
@@ -1787,121 +1659,6 @@ UINT8 ParseOcToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength,const U
 							debug_infor_printf((const)"OcSwapSysBoardNum'index %d exceed macro %d.\n", curBoardSwapSysNum, MAX_OC_DEVICE_NUM);
 						}
 					}
-
-					if (OC200_VER3_2 == ocInterfaceFlag)
-					{/*OC200 3.2,无屏蔽门无应急盘*/
-						/*不处理*/
-					}
-					else if (OC200_VER3_2_AFTER == ocInterfaceFlag)
-					{/*OC200 3.2之后的版本，只有应急盘*/
-						/*************解析OC应急控状态信息***********/
-						if (CI_SUCCESS == retVal)
-						{
-							pTmpOcToCiData->chHaveYjk = dataBuf[ii++];
-							if (OC_HAVE_YJK == pTmpOcToCiData->chHaveYjk)
-							{/*具备应急控*/
-								pTmpOcToCiData->chControlMode = dataBuf[ii++];
-								pTmpOcToCiData->chOcYjpComm = dataBuf[ii++];
-							}
-							else
-							{/*不具备应急控*/
-							}
-						}
-					}
-					else if (OC300_VER1_0_1_ANDAFTER == ocInterfaceFlag)
-					{/*OC300 1.0.1之后的版本，有屏蔽门和应急盘*/
-						if (CI_SUCCESS == retVal)
-						{
-							/*************解析屏蔽门信息***********/
-							/*屏蔽门数量*/
-							pTmpOcToCiData->OCPsdNum = dataBuf[ii++];
-							curPsdNum = pTmpOcToCiData->OCPsdNum;
-							if (0u != curPsdNum)
-							{
-								/*驱动电源状态*/
-								pTmpOcToCiData->DrvPowerState = dataBuf[ii++];
-								/*控制电源状态*/
-								pTmpOcToCiData->CtlPowerState = dataBuf[ii++];
-								/*边缘控制器1状态*/
-								pTmpOcToCiData->EdgeCtllerState1 = dataBuf[ii++];
-								/*边缘控制器2状态*/
-								pTmpOcToCiData->EdgeCtllerState2 = dataBuf[ii++];
-
-
-
-								if (PSD_SUM_MAX >= curPsdNum)
-								{
-									for (j = 0u; j < curPsdNum; j++)
-									{
-										psdId = LongFromChar(&dataBuf[ii]);  /*获取屏蔽门ID*/
-										ii += 4u;
-										/*PSD编号*/
-										funcRet = dquQueryInDevIndex(QFUN_IDMAP_PSD_ID, psdId, &psdIndexId);
-										if (CI_SUCCESS == funcRet)
-										{
-											pTmpOcToCiData->PsdInfo[j].wPsdId = psdIndexId;
-											/*开门故障状态*/
-											pTmpOcToCiData->PsdInfo[j].OpenErrState = dataBuf[ii++];
-											/*关门故障状态*/
-											pTmpOcToCiData->PsdInfo[j].CloseErrState = dataBuf[ii++];
-											/*开关门状态*/
-											pTmpOcToCiData->PsdInfo[j].OpenOrCloseState = dataBuf[ii++];
-											/*互锁解除状态*/
-											pTmpOcToCiData->PsdInfo[j].InterlockRelState = dataBuf[ii++];
-											/*单扇门故障隔离信息高四位*/
-											pTmpOcToCiData->PsdInfo[j].psdFaultQStataOne = LongFromChar(&dataBuf[ii]);
-											ii += 4u;
-											/*单扇门故障隔离信息低四位*/
-											pTmpOcToCiData->PsdInfo[j].psdFaultQStataTwo = LongFromChar(&dataBuf[ii]);
-											ii += 4u;
-											/*单扇门开关状态高四位*/
-											pTmpOcToCiData->PsdInfo[j].psdDoorsStateOne = LongFromChar(&dataBuf[ii]);
-											ii += 4u;
-											/*单扇门开关状态低四位*/
-											pTmpOcToCiData->PsdInfo[j].psdDoorsStateTwo = LongFromChar(&dataBuf[ii]);
-											ii += 4u;
-											/*单扇门被隔离信息高四位*/
-											pTmpOcToCiData->PsdInfo[j].psdDoorIStateOne = LongFromChar(&dataBuf[ii]);
-											ii += 4u;
-											/*单扇门被隔离信息低四位*/
-											pTmpOcToCiData->PsdInfo[j].psdDoorIStateTwo = LongFromChar(&dataBuf[ii]);
-											ii += 4u;
-											/*障碍物报警状态*/
-											pTmpOcToCiData->PsdInfo[j].psdAlarmState = dataBuf[ii++];
-										}
-										else
-										{
-											/*本屏蔽门解析错误*/
-											ii += 29u;
-											retVal = CI_ERROR;
-											break;
-										}
-									}
-								}
-								else
-								{
-									/*屏蔽门数量超出索引，给出调试警告信息*/
-									retVal = CI_ERROR;
-									debug_infor_printf((const)"OcPscNum'index %d exceed macro %d.\n", curPsdNum, PSD_SUM_MAX);
-								}
-							}
-
-						}
-						/*************解析OC应急控状态信息***********/
-						if (CI_SUCCESS == retVal)
-						{
-							pTmpOcToCiData->chHaveYjk = dataBuf[ii++];
-							if (OC_HAVE_YJK == pTmpOcToCiData->chHaveYjk)
-							{/*具备应急控*/
-								pTmpOcToCiData->chControlMode = dataBuf[ii++];
-								pTmpOcToCiData->chOcYjpComm = dataBuf[ii++];
-							}
-							else
-							{/*不具备应急控*/
-							}
-						}
-					}
-					
 #endif
 #if 0
 					(void)memcpy(pTmpOcToCiData->OcSystemState,&dataBuf[ii],16);/*OC子系统状态*/
@@ -1930,10 +1687,6 @@ UINT8 ParseOcToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength,const U
 					SetHLHTHeadCtxSrcOwnSN(CI_SYSTEM_TYPE_OC, systemId, hlhtGalHead.preOwnMsgSN);
 					SetHLHTHeadCtxCiRcvSN(CI_SYSTEM_TYPE_OC, systemId, curntCycleNo);
 					
-					/*解析通过 更新通信周期*/
-					pTmpOcToCiData->ComStartCycle = Get2oo2CurCycleNum();/*保存收到OC数据时的通信开始周期*/
-					debug_infor_printf((const)"\nId:%d OC_COM:%d\n", pTmpOcToCiData->OcId, pTmpOcToCiData->ComStartCycle);
-					
 					if(findFlag ==0u) /*如果需要更新的oc索引没找到，则认为这包数据是新的oc数据,需要增加oc总数量*/
 					{
 						m_OcToCiOrginDataNum++;
@@ -2525,16 +2278,6 @@ UINT8 InitOcsBoardsIsScatter(void)
 	UINT16 boardId = 0u; /*板卡ID*/
 	UINT16 ocId = 0u; /*OC ID*/
 	UINT8 boardType = 0u; /*板卡类型*/
-	UINT16 jj = 0U;
-	UINT8 cLocalCiId = 0U;
-	UINT8 cOcBelongCiId = 0U;
-	UINT16 wRelayCurSum = 0U;
-	UINT16 wRelayId = 0U;
-	UINT16 wRelayBelongOCId = 0U;
-	UINT16 wRelayAForeBoardId = 0U;  /*A系前采板卡ID*/
-	UINT16 wRelayABackBoardId = 0U;  /*A系后采板卡ID*/
-	UINT16 wRelayBForeBoardId = 0U;  /*A系前采板卡ID*/
-	UINT16 wRelayBBackBoardId = 0U;  /*A系后采板卡ID*/
 
 	readRtn = dquGetConfigData((const)DataPath, OC_DATA_TYPE, OC_IN_OUT_TYPE_ID, &pData, &dataLen);
 	if (1u == readRtn) /*读取成功*/
@@ -2544,8 +2287,6 @@ UINT8 InitOcsBoardsIsScatter(void)
 			rowNum = dataLen / OC_IN_OUT_TYPE_LEN; /*计算表格中数据的个数*/
 			if ((BOARD_SUM_MAX*OC_SUM_MAX) >= rowNum)
 			{
-				cLocalCiId = GetSystemParaLocalCiId();
-				wRelayCurSum = GetRelayCurSum();
 				for (i = 0u; i < rowNum; i++)
 				{
 					boardId = ShortFromChar(&pData[offset]); /*板卡ID*/
@@ -2571,40 +2312,6 @@ UINT8 InitOcsBoardsIsScatter(void)
 					{
 						rtn = 0U;
 					}
-					
-					cOcBelongCiId = (UINT8)GetCiIdByOcId(ocId);
-					
-					if (cOcBelongCiId == cLocalCiId)
-					{
-						for (jj = 0U; jj < wRelayCurSum; jj++)
-						{
-							wRelayId = GetRelayId(jj);
-							wRelayBelongOCId = GetRelayBelongOCId(wRelayId);
-							if (wRelayBelongOCId == ocId)
-							{
-								wRelayAForeBoardId = GetRelayForeNodeCollAddrA(wRelayId);
-								wRelayABackBoardId = GetRelayBackNodeCollAddrA(wRelayId);
-								wRelayBForeBoardId = GetRelayForeNodeCollAddrB(wRelayId);
-								wRelayBBackBoardId = GetRelayBackNodeCollAddrB(wRelayId);
-								if ((boardId == wRelayAForeBoardId) || (boardId == wRelayABackBoardId) || (boardId == wRelayBForeBoardId) || (boardId == wRelayBBackBoardId))
-								{
-									SetRelayBoardType(wRelayId, boardType);
-								}
-								else
-								{
-									/*不处理*/
-								}
-							}
-							else
-							{
-								/*不处理*/
-							}
-						}
-					}
-					else
-					{
-						/*不处理*/
-					}
 				}
 				if (offset == dataLen) /*处理正确*/
 				{
@@ -2618,128 +2325,17 @@ UINT8 InitOcsBoardsIsScatter(void)
 }
 
 
-/*
+
-* 功能描述：为指定OC->CI的结构设置缺省值(安全值)
+
-* 参数说明： index , OC id对应的数组下标
+
-* 返回值  ： 无
+
-*/
+
-void SetOcToCiDefaultDataStru(UINT8 index)
+
-{
+
-	UINT8 curPsdNum = 0U;/*OC->CI的屏蔽门数量*/
+
-	UINT8 j = 0u;
+
-
+
-	if (OC_SUM_MAX <= index)
+
-	{
-		/*不处理*/
-	}
-	else
-	{
-		curPsdNum = m_OcToCiOrginDataArr[index].OCPsdNum;
-		m_OcToCiOrginDataArr[index].DrvPowerState = PSD_DRIVE_POWER_ERROR;/*驱动电源状态*/
-		m_OcToCiOrginDataArr[index].CtlPowerState = PSD_CONTROL_POWER_ERROR;/*控制电源状态*/
-		m_OcToCiOrginDataArr[index].EdgeCtllerState1 = PSD_EDGE_CONTROLLER_ERROR;/*边缘控制器1状态*/
-		m_OcToCiOrginDataArr[index].EdgeCtllerState2 = PSD_EDGE_CONTROLLER_ERROR;/*边缘控制器2状态*/
-		for (j = 0U; j < curPsdNum; j++)
-		{
-			m_OcToCiOrginDataArr[index].PsdInfo[j].OpenErrState = PSD_OPEN_CLOSE_ERROR;/*开门故障状态*/
-			m_OcToCiOrginDataArr[index].PsdInfo[j].CloseErrState = PSD_OPEN_CLOSE_ERROR;/*关门故障状态*/
-			m_OcToCiOrginDataArr[index].PsdInfo[j].OpenOrCloseState = PSD_STATE_OPEN_VIETNAM;/*开关门状态*/
-			m_OcToCiOrginDataArr[index].PsdInfo[j].InterlockRelState = PSD_MUTUALLOCK_REMOVE_NO;/*互锁解除状态*/
-			m_OcToCiOrginDataArr[index].PsdInfo[j].psdFaultQStataOne = UINT32_MAX;/*单扇门故障隔离信息*/
-			m_OcToCiOrginDataArr[index].PsdInfo[j].psdFaultQStataTwo = UINT32_MAX;
-			m_OcToCiOrginDataArr[index].PsdInfo[j].psdDoorsStateOne = UINT32_MAX;/*单扇门开关状态*/
-			m_OcToCiOrginDataArr[index].PsdInfo[j].psdDoorsStateTwo = UINT32_MAX;
-			m_OcToCiOrginDataArr[index].PsdInfo[j].psdDoorIStateOne = UINT32_MAX;/*单扇门被隔离信息*/
-			m_OcToCiOrginDataArr[index].PsdInfo[j].psdDoorIStateTwo = UINT32_MAX;
-			m_OcToCiOrginDataArr[index].PsdInfo[j].psdAlarmState = PSD_ALARM_OBS_YES;/*障碍物报警状态*/
-		}
-	}
-
-}
-
-/*
-* 功能描述：获取要发送给OC的控权切换命令
-* 参数说明： 无
-* 返回值  ： 控权切换命令
-*/
-UINT16 GetKqChangeCommand(void)
-{
-	UINT16 ii = 0u;
-	UINT16 command = CHANGE_NO_COMMAND;
-
-	for (ii = 0u; ii < m_OcToCiOrginDataNum; ii++)
-	{
-		if (OC_CTLMODE_YJK == m_OcToCiOrginDataArr[ii].chControlMode)
-		{
-			/*处于应急控的OC*/
-			if (CI_AND_OTHER_TRANSMIT_BAD == m_OcToCiOrginDataArr[ii].chOcYjpComm)
-			{
-				/*并且OC与应急盘通信中断*/
-			}
-			else
-			{
-				break;
-			}
-		}
-		else
-		{	
-			/*是机控,继续遍历*/
-		}
-	}
-
-	if((0 != ii)&& (ii == m_OcToCiOrginDataNum))
-	{/*所有处于应急控的OC与应急盘中断，或OC是机控*/
-		command = CHANGE_JK_COMMAND;
-	}
-	else
-	{
-		/*不处理*/
-	}
-
-	return command;
-}
-
-
-/*
-* 功能描述： 获取点位采集容忍起始周期
-* 参数说明： const UINT16 ocId, OC ID
-*			 const UINT8 boardNum, 板卡ID
-*			 const UINT8 pointNum，点位ID
-* 返回值  ： UINT32 采集容忍起始周期
-*/
-UINT32 GetPointTolerateCycNum(const UINT16 ocId, const UINT8 boardNum, const UINT8 pointNum)
-{
-	UINT32 retVal = CI_ERROR;
-
-	if ((OC_SUM_MAX > ocId) && (Oc_Max_Board_Num > boardNum) && (OC_COLL_BOARD_POS_NUM > pointNum))
-	{
-		retVal = m_OcConvertedPtDataArr[ocId].BoardDatas[boardNum].TolerateCycNum[pointNum];
-	}
-	else
-	{/*不处理*/
-	}
-
-	return retVal;
-}
-
-/*
-* 功能描述： 设置道岔采集容忍起始周期
-* 参数说明： 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)
-{
-	if ((OC_SUM_MAX > ocId) && (Oc_Max_Board_Num > boardNum) && (OC_COLL_BOARD_POS_NUM > pointNum))
-	{
-		m_OcConvertedPtDataArr[ocId].BoardDatas[boardNum].TolerateCycNum[pointNum] = cycNum;
-	}
-	else
-	{/*不处理*/
-	}
-}
 
 
 

TSCP/src/APP/ciapp/ParsePack/ParsePackOcData.h

@@ -69,15 +69,6 @@
 
 #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*/
@@ -126,23 +117,6 @@ 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编号*/
@@ -173,17 +147,6 @@ typedef struct S_OcToCiDataStruct
 	UINT16 OCBoardSwapSysNum;/*OC切系板卡数量*/
 	UINT8 SwapSysBoardId[MAX_OC_DEVICE_NUM];/*OC切系板卡ID*/
 
-	UINT8 OCPsdNum;/*屏蔽门数量*/
-	UINT8 DrvPowerState;/*驱动电源状态*/
-	UINT8 CtlPowerState;/*控制电源状态*/
-	UINT8 EdgeCtllerState1;/*边缘控制器1状态*/
-	UINT8 EdgeCtllerState2;/*边缘控制器2状态*/
-	OcToCiPsdInfo PsdInfo[PSD_SUM_MAX];/*屏蔽门信息*/
-
-	UINT8 chHaveYjk;	/*是否具备应急控*/
-	UINT8 chControlMode;	/*主控状态*/
-	UINT8 chOcYjpComm;	/*OC与YJP通信状态*/
-
 	UINT32 ComStartCycle;		/*通信开始周期，使用该周期判断OC与CI中断*/
 
 	UINT16 RecvErrorDevTypeCycle;		/*收到错误设备类型周期*/
@@ -196,7 +159,6 @@ 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
@@ -304,14 +266,6 @@ 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" {
@@ -446,38 +400,6 @@ UINT8 CheckOc2CiDataLenValid(const UINT8* dataBuf, const UINT16 totalLength);
 */
 void ResetOcOriginalState(const UINT8 ocId);
 
-/*
-* 功能描述：为指定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);
-
 #ifdef __cplusplus
 }
 #endif

TSCP/src/APP/ciapp/ParsePack/ParsePackTmcData.c

@@ -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 ParseIteCutData(UINT8* dataBuf, UINT16 dataLen);
+static UINT8 ParseIteLineCutData(UINT8* dataBuf, UINT16 dataLen);
 
 /*
-* 功能描述：组ITE切除信息
+* 功能描述：组ITE全线切除信息
 * 参数说明：UINT8* TiocToTmcDataBuffer 数据地址
 * 返 回 值：0 组数据失败
 *			其他 整包数据长度
 * Created By LQ 2024.07.12
 */
-static UINT16 PackToTmcIteCutData(UINT8* TiocToTmcDataBuffer);
+static UINT16 PackToTmcIteLineCutData(UINT8* TiocToTmcDataBuffer);
 
 /*
 * 功能描述：解析全线通信车信息
@@ -253,9 +253,9 @@ UINT8 ParseTmcToTiocDataFrame(UINT8* dataBuf, UINT16 dataLength, UINT8 systemId)
 								break;
 							case TMC_TO_TIOC_ITELINECUT_MSG:
 								/* 解析ITE全线切除信息 */
-								retVal = ParseIteCutData(&dataBuf[ii], wMsgCheckLen);
+								retVal = ParseIteLineCutData(&dataBuf[ii], wMsgCheckLen);
 								dwParseStep |= 0x00010U;
-								debug_infor_printf((const)"\n ParseIteCutData:%d", retVal);
+								debug_infor_printf((const)"\n ParseIteLineCutData:%d", retVal);
 								break;
 							case TMC_TO_TIOC_LINECT_MSG:
 								/* 解析全线通信车信息 */
@@ -652,12 +652,11 @@ static UINT8 ParseSnowData(UINT8* dataBuf, UINT16 dataLen)
 	UINT8 cRetVal = CI_ERROR;
 	UINT16 ii = 0u;
 	UINT8 jj = 0U;
-	UINT16 wPlatFormId = 0U;  /*站台互联互通ID*/
+	UINT32 dwPlatFormId = 0U;  /*站台互联互通ID*/
 	UINT8 cPlatFormNum = 0U;  /*站台数量*/
 	UINT8 cTmepNum = 0U;
 	UINT8 cPlatFormBelongCiId = 0U;  /*站台关联Link所属CI*/
 	UINT8 cLocalCiId = 0U;
-	UINT8 cSnowLevel = 0U;  /*湿轨等级*/
 
 	if (NULL == dataBuf)
 	{
@@ -668,23 +667,14 @@ 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))
 		{
-			cSnowLevel = dataBuf[ii];  /*全线湿轨等级*/
+			cRetVal = CI_SUCCESS;
-			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
 		{
@@ -703,21 +693,17 @@ static UINT8 ParseSnowData(UINT8* dataBuf, UINT16 dataLen)
 			cLocalCiId = GetSystemParaLocalCiId();
 			for (jj = 0U; jj < cPlatFormNum; jj++)
 			{
-				wPlatFormId = ShortFromChar(&dataBuf[ii]);  /*解析区间雨雪站台ID*/
+				dwPlatFormId = LongFromChar(&dataBuf[ii]);  /*解析区间雨雪站台ID*/
-				ii += 2U;
+				ii += 4U;
-				cSnowLevel = dataBuf[ii];  /*区间湿轨等级*/
-				ii++;
 
-				if ((0U < wPlatFormId) && (UINT16_MAX > wPlatFormId)
+				cPlatFormBelongCiId = GetAreaSnowPlatFormBelongCiId((UINT16)dwPlatFormId);  /*获取区间雨雪站台所属控区*/
-					&& (CI_SNOW_LEVEL_DEFAULT == cSnowLevel) || (CI_SNOW_LEVEL_ONE == cSnowLevel) || (CI_SNOW_LEVEL_TWO == cSnowLevel))
+				if (0U < dwPlatFormId)
 				{
-					cPlatFormBelongCiId = GetAreaSnowPlatFormBelongCiId(wPlatFormId);  /*获取区间雨雪站台所属控区*/
 					if ((cLocalCiId == cPlatFormBelongCiId) && (0U != cLocalCiId))
 					{
 						if (LOCAL_AREA_SNOW_SUM_MAX > cTmepNum)
 						{
-							g_TmcToTiocDataStru.szAreaSnowInfo[cTmepNum].wAreaId = wPlatFormId;
+							g_TmcToTiocDataStru.szAreaSnowPlatFormId[cTmepNum] = dwPlatFormId;
-							g_TmcToTiocDataStru.szAreaSnowInfo[cTmepNum].cAreaSnowLevel = cSnowLevel;
 							cTmepNum++;
 						}
 						else
@@ -733,7 +719,7 @@ static UINT8 ParseSnowData(UINT8* dataBuf, UINT16 dataLen)
 				}
 				else
 				{
-					/*雨雪模式编号ID非法或区间湿轨等级非法，返回失败*/
+					/*雨雪模式编号ID非法*/
 					cRetVal = CI_ERROR;
 				}
 			}
@@ -922,7 +908,7 @@ UINT8 PackTiocToTmcData( UINT8 deviceId)
 				wMagLen = PackToTmcWLScreenData(&TiocToTmcDataBuffer[ii]);
 				break;
 			case 3u:
-				wMagLen = PackToTmcIteCutData(&TiocToTmcDataBuffer[ii]);
+				wMagLen = PackToTmcIteLineCutData(&TiocToTmcDataBuffer[ii]);
 				break;
 			case 4U:
 				wMagLen = PackToTmcLineCTData(&TiocToTmcDataBuffer[ii]);
@@ -1183,8 +1169,7 @@ static UINT16 PackToTmcSnowData(UINT8* TiocToTmcDataBuffer)
 	UINT8 snowModelFlag = 0u;    /*全线雨雪模式标志*/
 	UINT8 cFunRetVal = CI_ERROR;
 	UINT8 cAreaSnowNum = 0U;  /*本地区间雨雪站台数量*/
-	AreaSnowInfoStruct* pAreaSnowData = NULL;  /*本地区间雨雪信息数组*/
+	UINT32* pAreaSnowId = NULL;  /*本地区间雨雪站台ID数组*/
-	UINT8 cSnowLevel = 0U;  /*湿轨级别*/
 
 	snowModelFlag = GetAllSnowModel();
 
@@ -1206,30 +1191,14 @@ static UINT16 PackToTmcSnowData(UINT8* TiocToTmcDataBuffer)
 		{
 			TiocToTmcDataBuffer[ii++] = 0x55u; /* 全线雨雪模式命令有效 */
 		}
-		else if (CI_ALL_SNOW_UNVALID == snowModelFlag)
+		else
 		{
 			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();
-		pAreaSnowData = GetLocalAreaSnow();
+		pAreaSnowId = GetLocalAreaSnowId();
 
 		if (LOCAL_AREA_SNOW_SUM_MAX >= cAreaSnowNum)
 		{
@@ -1238,19 +1207,8 @@ static UINT16 PackToTmcSnowData(UINT8* TiocToTmcDataBuffer)
 
 			for (jj = 0U; jj < cAreaSnowNum; jj++)
 			{
-				if ((0U < pAreaSnowData[jj].wAreaId) && (UINT16_MAX > pAreaSnowData[jj].wAreaId)
+				LongToChar(pAreaSnowId[jj], &TiocToTmcDataBuffer[ii]);  /*组区间雨雪站台ID*/
-					&& ((CI_SNOW_LEVEL_DEFAULT == pAreaSnowData[jj].cAreaSnowLevel) || (CI_SNOW_LEVEL_ONE == pAreaSnowData[jj].cAreaSnowLevel) || (CI_SNOW_LEVEL_TWO == pAreaSnowData[jj].cAreaSnowLevel)))
+				ii += 4U;
-				{
-					ShortToChar(pAreaSnowData[jj].wAreaId, &TiocToTmcDataBuffer[ii]);  /*组区间ID*/
-					ii += 2U;
-					TiocToTmcDataBuffer[ii] = pAreaSnowData[jj].cAreaSnowLevel;  /*组区间湿轨级别*/
-					ii++;
-				}
-				else
-				{
-					cFunRetVal = CI_ERROR;  /*区间信息非法，返回失败*/
-					break;
-				}
 			}
 		}
 		else
@@ -1370,28 +1328,21 @@ 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 ParseIteCutData(UINT8* dataBuf, UINT16 dataLen)
+static UINT8 ParseIteLineCutData(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++;
 
@@ -1399,83 +1350,20 @@ static UINT8 ParseIteCutData(UINT8* dataBuf, UINT16 dataLen)
 		{
 			g_TmcToTiocDataStru.cIteLineCutState = cIteLineCutState;  /*存储解析的ITE全线切除状态*/
 
-			/*解析区间ITE切除信息*/
-			cPlatFormNum = dataBuf[ii];  /*解析区间ITE切除数量*/
-			ii++;
-
-			if (ALL_AREA_SNOW_SUM_MAX >= cPlatFormNum)
-			{				
-				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)
 			{
-						/*解析成功*/
+				cRetVal = CI_SUCCESS;
 			}
 			else
 			{
-						debug_infor_printf((const)"ParseIteCutData: MsgLen Is Error\n");
+				debug_infor_printf((const)"ParseIteLineCutData Error: MsgLen Is Error\n");
 				cRetVal = CI_ERROR;  /*长度不一致，返回失败*/
 			}
 		}
 		else
-				{
-					/*不处理*/
-				}
-			}
-			else
-			{
-				debug_infor_printf((const)"ParseIteCutData: TMC AreaIteCutNum Exceed Max\n");
-				cRetVal = CI_ERROR;  /*区间ITE切除数量超限，返回失败*/
-			}
-		}
-		else
 		{
 			cRetVal = CI_ERROR;  /*状态非法，返回失败*/
-			debug_infor_printf((const)"ParseIteCutData: IteLineCutState[0x%2x] Is Invalid\n", cIteLineCutState);
+			debug_infor_printf((const)"ParseIteLineCutData Error: IteLineCutState[0x%2x] Is Invalid\n", cIteLineCutState);
 		}		
 	}
 	else
@@ -1487,27 +1375,22 @@ static UINT8 ParseIteCutData(UINT8* dataBuf, UINT16 dataLen)
 }
 
 /*
-* 功能描述：组ITE切除信息
+* 功能描述：组ITE全线切除信息
 * 参数说明：UINT8* TiocToTmcDataBuffer 数据地址
 * 返 回 值：0 组数据失败
 *			其他 整包数据长度
 * Created By LQ 2024.07.12
 */
-static UINT16 PackToTmcIteCutData(UINT8* TiocToTmcDataBuffer)
+static UINT16 PackToTmcIteLineCutData(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;
 
@@ -1527,31 +1410,9 @@ static UINT16 PackToTmcIteCutData(UINT8* TiocToTmcDataBuffer)
 		{
 			TiocToTmcDataBuffer[ii] = CI_ITE_LINE_CUT_DEFAULT;  /* 组默认值 */
 		}
+
 		ii++;
 
-		/*组区间ITE切除信息*/
-		cAreaIteCutNum = GetLocalAreaIteCutNum();
-		pAreaIteCutId = GetLocalAreaIteCutId();
-
-		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;
@@ -1560,11 +1421,6 @@ static UINT16 PackToTmcIteCutData(UINT8* TiocToTmcDataBuffer)
 		ShortToChar(wMagLen, &TiocToTmcDataBuffer[wMagLenIndex]);
 	}
 	else
-		{
-			/*组包失败，返回0*/
-		}
-	}
-	else
 	{
 		/*入参非法，返回0*/
 	}

TSCP/src/APP/ciapp/ParsePack/ParsePackTmcData.h

@@ -57,17 +57,15 @@ typedef struct S_TsrInputInfoStruct
 	TsrDataStruct szTsrInfo[TSR_MAX_SUM]; /* 限速信息 */
 } TsrInputInfoStruct;
 
+
 /*TMC->TIOC缓冲数据*/
 typedef struct S_TmcToTiocDataStruct
 {
 	TsrInputInfoStruct tsrInputInfoStru;/* 临时限速信息 */
 	UINT8 cSnowValidFlag;				/* 全线雨雪模式命令有效标志 */
-	UINT8 cSnowLevel;  /*全线湿轨等级*/
 	UINT8 cAreaSnowPlatFormNum;  /*区间雨雪站台数量*/
-	AreaSnowInfoStruct szAreaSnowInfo[LOCAL_AREA_SNOW_SUM_MAX];  /*区间雨雪数组*/
+	UINT32 szAreaSnowPlatFormId[LOCAL_AREA_SNOW_SUM_MAX];  /*区间雨雪站台ID数组*/
 	UINT8 cIteLineCutState;				/* ITE全线切除状态 */
-	UINT8 cAreaIteCutNum;  /*区间ITE切除数量*/
-	UINT16 szAreaIteCutId[ALL_AREA_SNOW_SUM_MAX];  /*区间ITE切除ID数组*/
 	UINT8 cLineCtNum;  /*全线通信车数量*/
 	UINT16 szLineCtId[TRAIN_SUM_MAX];  /*全线通信车ID数组*/
 } TmcToTiocDataStruct;

TSCP/src/APP/ciapp/ParsePack/ParsePackVobcData.c

@@ -382,14 +382,14 @@ static UINT8 PackCiToVobcSigInfo(UINT8* pDataBuf, UINT16* wDataLength, UINT16 wT
 static UINT8 PackCiToVobcBackUpStateData(UINT8* pDataBuf, UINT16* wDataLength, VobcToCiDataStruct* pstVobcToCiDataStru);
 
 /*
-* 功能描述：组包Ci到Ivoc的ITE切除状态
+* 功能描述：组包Ci到Ivoc的ITE全线切除状态
 * 参数说明：const UINT8* dataBuf 数据缓冲区（出参）
 *           const UINT16 *dataLength 数据长度（出参）
 * 返 回 值：CI_ERROR 0 失败
 *			CI_SUCCESS 1 成功
 * Created By LQ 2024.07.12
 */
-static UINT8 PackCiToIvocIteCutInfo(UINT8* pDataBuf, UINT16* wDataLength);
+static UINT8 PackCiToIvocIteLineCutInfo(UINT8* pDataBuf, UINT16* wDataLength);
 
 
 /*
@@ -449,8 +449,7 @@ UINT8 ParseVobcToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength, cons
 	UINT8 retVal = CI_SUCCESS;
 	UINT8 lineIdentity = 0u;						 /*线路标识*/
 	UINT8 galHeadSaved = 0u;
-	VobcToCiDataStruct parseCheckVobcStruc = { 0 };
+
-	UINT8 chFind = CI_ERROR;
 	lineIdentity = GetCiFunctionSwitchConfig(VOBC_INTERFACE_IDENTITY);/*获取线路标识*/
 	/*能处理的VOBC数量判断*/
 	if (VobcToCiSum >= VOBC_TO_CI_SUM_MAX)
@@ -460,21 +459,23 @@ UINT8 ParseVobcToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength, cons
 
 	if (CI_SUCCESS==retVal)
 	{
+		(void)memset(&(VobcToCiDataStru[VobcToCiSum]),0,sizeof(VobcToCiDataStruct));/*清内存，防止脏数据*/
+
 		if (LINE_HLHT == lineIdentity)/*互联互通线路*/
 		{
-			retVal = ParseVobcToCiDataFrameHLHT(dataBuf, dataLength, systemId, &parseCheckVobcStruc, &galHeadSaved,logId);
+			retVal = ParseVobcToCiDataFrameHLHT(dataBuf, dataLength, systemId, &(VobcToCiDataStru[VobcToCiSum]), &galHeadSaved,logId);
 		}
 		else if (LINE_FAO == lineIdentity)/*FAO线路*/
 		{
-			retVal = ParseVobcToCiDataFrameFAO(dataBuf,dataLength,systemId,&parseCheckVobcStruc);
+			retVal = ParseVobcToCiDataFrameFAO(dataBuf,dataLength,systemId,&(VobcToCiDataStru[VobcToCiSum]));
 		}
 		else if ((LINE_FAOHLHT == lineIdentity) || (LINE_FAOHLHT_ONESELF == lineIdentity)||(LINE_FAOHLHT_ONESELFSECOND == lineIdentity))/*FAO+HLHT线路*/
 		{
-			retVal = ParseVobcToCiDataFrameFAOHLHT(dataBuf, dataLength, systemId, &parseCheckVobcStruc, &galHeadSaved,logId);
+			retVal = ParseVobcToCiDataFrameFAOHLHT(dataBuf, dataLength, systemId, &(VobcToCiDataStru[VobcToCiSum]), &galHeadSaved,logId);
 		}
 		else if (LINE_CC == lineIdentity)/*车车线路*/
 		{
-			retVal = ParseIvocToCiDataFrameCC(dataBuf, dataLength, systemId, &parseCheckVobcStruc, &galHeadSaved, logId);
+			retVal = ParseIvocToCiDataFrameCC(dataBuf, dataLength, systemId, &(VobcToCiDataStru[VobcToCiSum]), &galHeadSaved, logId);
 		}
 		else
 		{
@@ -483,25 +484,21 @@ UINT8 ParseVobcToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength, cons
 
 		if(CI_SUCCESS == retVal)
 		{
+			VobcToCiSum++;
 			/*命令去重*/
 			for (ii = 0u; ii < VobcToCiSum; ii++)
 			{
-				if (VobcToCiDataStru[ii].VobcId == parseCheckVobcStruc.VobcId)
+				/*遍历到最后一个数据*/
-				{/*列车号与刚添加的列车号一致*/
+				if (ii == VobcToCiSum - 1u)
-					CopyVobcToCiMsg(&parseCheckVobcStruc,&(VobcToCiDataStru[ii]));					
+				{
-					chFind = CI_SUCCESS;
 					break;
 				}
+
+				if (VobcToCiDataStru[ii].VobcId == VobcToCiDataStru[VobcToCiSum - 1U].VobcId)
+				{/*列车号与刚添加的列车号一致*/
+					CopyVobcToCiMsg(&(VobcToCiDataStru[VobcToCiSum-1U]),&(VobcToCiDataStru[ii]));
+					VobcToCiSum--;
 				}
-			if (CI_ERROR == chFind)
-			{
-				(void)CommonMemSet(&(VobcToCiDataStru[VobcToCiSum]), (UINT32)sizeof(VobcToCiDataStruct), 0U, (UINT32)sizeof(VobcToCiDataStruct));/*清内存，防止脏数据*/
-				CopyVobcToCiMsg(&parseCheckVobcStruc, &(VobcToCiDataStru[VobcToCiSum]));
-				VobcToCiSum++;
-			}
-			else
-			{
-				; /*已存在并更新*/
 			}
 		}
 		else
@@ -1413,7 +1410,11 @@ static UINT8 ParseVobcToCiDataFrameHLHT(const UINT8* dataBuf, const UINT16 dataL
 	INT32 vobcInfoRemainValidiy = 0;
 	UINT8 headRet = HLHT_HEAD_ERROR;/*互联互通检查结果*/
 	UINT8 cTempPsdCmdCode = 0U;
+#if 0
 	UINT32 signalId = 0u;		/*VOBC->CI信号机ID*/
+	
+	
+#endif
     UINT8 ci_vobcPrtclVersion = 0u;
 
 	ci_vobcPrtclVersion = GetVersionOfVOBCToCI();
@@ -1561,7 +1562,7 @@ static UINT8 ParseVobcToCiDataFrameHLHT(const UINT8* dataBuf, const UINT16 dataL
 
 							cmdType = dataBuf[ii];/*获取屏蔽门命令*/
 							ii += 1u;
-							if ((VOBCTOCI_COMMAND_TYPE_PSDOPEN == cmdType) || (VOBCTOCI_COMMAND_TYPE_PSDCLOSE == cmdType) || (VOBCTOCI_COMMAND_TYPE_PSDCHECK_FAOHLHT == cmdType))  /*修缺陷YF0083-682，2023-07-03*/
+							if ((VOBCTOCI_COMMAND_TYPE_PSDOPEN == cmdType) || (VOBCTOCI_COMMAND_TYPE_PSDCLOSE == cmdType) || (VOBCTOCI_COMMAND_TYPE_PSDCHECK == cmdType))  /*修缺陷YF0083-682，2023-07-03*/
 							{
 								vobcToCiDataStru->PsdData[jj].CmdType = cmdType;
 
@@ -1578,12 +1579,15 @@ static UINT8 ParseVobcToCiDataFrameHLHT(const UINT8* dataBuf, const UINT16 dataL
 						}
 					}
 					
+
+					/*修改于20180111，修改原因：互联互通VOBC-CI接口回退（VOBC给CI不发送4字节信号机ID），适应越南线需求*/
+#if 0
 					/*增加新的接口：信号机的ID1~0xFFFFFFFF,0为默认值，VOBC最大安全前端前方沿列车运行方向可搜索到的最近的同向信号机。*/
 					signalId = LongFromChar(&dataBuf[ii]);	/*获取信号机ID*/
 					ii += 4u;
 
 					vobcToCiDataStru->signalID = signalId;	/*将信号机ID保存到结构体*/
-
+#endif
 				}
 				else
 				{
@@ -1908,23 +1912,22 @@ static UINT8 PackCiToVobcDataHLHT(VobcToCiDataStruct *vobcToCiDataStru)
 	UINT32 ciEtcsId = 0u;
 	UINT32 vobcEtcsId = 0u;
 	UINT32 emapCheckVer = 0u;
-#if 0
+	UINT16 trackIdRelatePhySecId = 0u;/*轨道区段关联的物理区段ID*/
+	UINT8 outStationSignalSum = 0u;/*出站信号机数目*/
 	UINT8 sigIdx = 0u;/*信号机索引*/
 	UINT8 sigDir = 0u;/*信号机运营方向*/
-	UINT16 trackIdRelatePhySecId = 0u;/*轨道区段关联的物理区段ID*/
 	UINT8 outStationSignalAllowOrNotUp = CI_VOBC_SIGNAL_DEFAULT;			/*上行信号机的允许或禁止状态*/
 	UINT8 outStationSignalAllowOrNotDown = CI_VOBC_SIGNAL_DEFAULT;			/*下行信号机的允许或禁止状态*/
-	UINT8 outStationSignalSum = 0u;/*出站信号机数目*/
-#endif
 	UINT8 ci_vobcPrtclVersion = 0u;
 	UINT8 mutualLockState = 0u;
 	UINT16 dstDevId = 0u;
 	UINT8 outnetSafeSendRtn = 0u;
 	UINT8 chPsdBelongCiId = 0U;
+	ci_vobcPrtclVersion = GetVersionOfVOBCToCI();
+#if 0
 	UINT8 outStationSignalAllowOrNot = CI_VOBC_SIGNAL_DEFAULT;			/*信号机的允许或禁止状态*/
 	UINT32 signalIdInterConn = 0u;	/*互联互通4字节信号机ID*/
-	ci_vobcPrtclVersion = GetVersionOfVOBCToCI();
+#endif
-
 
 	/*首先获取组包时所需的信息，获取成功才有必要继续组包*/
 	if ((CI_SUCCESS == dquDevName2HlhtId((CI_SYSTEM_TYPE_CI*256U) + localCiId,0U,&ciEtcsId)) && (CI_SUCCESS == dquDevName2HlhtId((CI_SYSTEM_TYPE_VOBC*256U) + (UINT8)(vobcToCiDataStru->VobcId),vobcToCiDataStru->vobcLogId,&vobcEtcsId)) && (CI_SUCCESS == GetCiEmapCheckVer(localCiId, &emapCheckVer, CI_SYSTEM_TYPE_VOBC)))
@@ -2024,7 +2027,7 @@ static UINT8 PackCiToVobcDataHLHT(VobcToCiDataStruct *vobcToCiDataStru)
 			}/*for (kk = 0; kk < vobcToCiDataStru->PsdSum; kk++)*/
 
 			/*修改于20180111，修改原因：互联互通VOBC-CI接口回退（VOBC给CI不发送4字节信号机ID，CI也不回复信号机ID），适应越南线需求*/
-
+#if 0
 			signalIdInterConn = vobcToCiDataStru->signalID;	/*互联互通4字节信号机ID*/
 			/*回复收到的信号机ID,依据CI-VOBCV3.0接口文档修改*/
 			LongToChar(signalIdInterConn,&CiToVobcDataBuffer[ii]);	
@@ -2034,7 +2037,7 @@ static UINT8 PackCiToVobcDataHLHT(VobcToCiDataStruct *vobcToCiDataStru)
 
 			if (CI_SUCCESS == retVal)
 			{
-				startSigColour = GetSignalCurColor(sigId);/*获取信号机当前显示颜色*/
+				startSigColour = GetSignalShowColor(sigId);/*获取信号机当前显示颜色*/
 				
 				if (SIGNAL_OPEN == GetSignalOpenCloseState(startSigColour))/*获取始端信号机开放状态*/
 				{/*信号开放*/
@@ -2048,8 +2051,8 @@ static UINT8 PackCiToVobcDataHLHT(VobcToCiDataStruct *vobcToCiDataStru)
 
 			/*CI接收到的VOBC发送的信号机ID的状态*/
 			CiToVobcDataBuffer[ii++] = outStationSignalAllowOrNot;              /*CI->VOBC信号机状态*/
+#endif
 
-#if 0
 			/*先查找轨道区段对应的物理区段，获取以此物理区段为外方第一区段的信号机的数目，遍历之*/
 			trackIdRelatePhySecId = GetTrackToPhySectionId(vobcToCiDataStru->trackSecID);
 			outStationSignalSum = GetPhySecAsOutFirstPhySecSigSum(trackIdRelatePhySecId);/*获取以本物理区段为外方第一区段的信号机数目*/
@@ -2090,7 +2093,7 @@ static UINT8 PackCiToVobcDataHLHT(VobcToCiDataStruct *vobcToCiDataStru)
 			/*CI->VOBC上行和下行出站信号机状态*/
 			CiToVobcDataBuffer[ii++] = outStationSignalAllowOrNotUp;              /*CI_VOBC上行出站信号机状态*/
 			CiToVobcDataBuffer[ii++] = outStationSignalAllowOrNotDown;             /*CI_VOBC下行出站信号机状态*/
-#endif
+
 			ShortToChar(CI_VOBC_INFO_TYPE_PSD_STATE,&CiToVobcDataBuffer[33]);/*屏蔽门控制报文类型，两字节*/
 		}
 		else if ((VOBC_CI_INFO_TYPE_HEART_FRAME == vobcToCiDataStru->appInfoType) && (curCycleNum == vobcToCiDataStru->ComStartCycle))
@@ -3324,8 +3327,6 @@ static UINT8 ParseIvocToCiDataFrameCC(const UINT8* pDataBuf, const UINT16 dataLe
 	UINT16 wHeadTrainId = 0U;/*前车ID*/
 	UINT16 wTrainRelLgcId = 0U;/*列车关联使用端*/
 	UINT16 wHeadSignalId = 0U;/*前方信号机ID*/
-	UINT8 chJumpBackState = 0U;/*向后跳跃申请*/
-	UINT32 dwJumpBackSN = 0U;/*向后跳跃申请序列号*/
 
 	vobcName = (CI_SYSTEM_TYPE_VOBC) * 256U + systemId;
 	ciName = (CI_SYSTEM_TYPE_CI) * 256U + localCiId;
@@ -4383,39 +4384,6 @@ static UINT8 ParseIvocToCiDataFrameCC(const UINT8* pDataBuf, const UINT16 dataLe
 						/*解析错误不继续解析*/
 					}
 
-					/*向后跳跃申请*/
-					if (CI_SUCCESS == chRetVal)
-					{
-						chJumpBackState = pDataBuf[ii];
-						ii++;
-						if ((TRAIN_JUMP_BACK_STATE_VALID == chJumpBackState)
-							|| (TRAIN_JUMP_BACK_STATE_INVALID == chJumpBackState))
-						{
-							/*解析通过*/
-							pstVobcToCiDataStru->chJumpBackApply = chJumpBackState;
-							dwJumpBackSN = LongFromChar(&pDataBuf[ii]);
-							ii += 4u;
-							if (((0U == dwJumpBackSN) && (TRAIN_JUMP_BACK_STATE_INVALID == chJumpBackState))
-								|| ((0U < dwJumpBackSN) && (TRAIN_JUMP_BACK_STATE_VALID == chJumpBackState)))
-							{
-								/*解析通过*/
-								pstVobcToCiDataStru->dwJumpBackSn = dwJumpBackSN;
-							}
-							else
-							{
-								chRetVal = CI_ERROR;
-							}
-						}
-						else
-						{
-							chRetVal = CI_ERROR;
-						}
-					}
-					else
-					{
-						; /*解析错误不继续解析*/
-					}
-
 					/*列车命令信息*/
 					if (CI_SUCCESS == chRetVal)
 					{
@@ -5088,10 +5056,10 @@ static UINT8 PackCiToIvocDataCC(VobcToCiDataStruct *pstVobcToCiDataStru)
 				debug_infor_printf((const)"\n VOBC: %d PackCiToVobcSigInfo Error \n", pstVobcToCiDataStru->VobcId);
 			}
 			
-			/*主用通道给IVOC组ITE切除状态*/
+			/*主用通道给IVOC组ITE全线切除状态*/
 			if (CI_SUCCESS == chRetVal)
 			{
-				chRetVal = PackCiToIvocIteCutInfo(cszCiToIvocDataBuf, &ii);
+				chRetVal = PackCiToIvocIteLineCutInfo(cszCiToIvocDataBuf, &ii);
 			}
 			else
 			{
@@ -5107,8 +5075,9 @@ static UINT8 PackCiToIvocDataCC(VobcToCiDataStruct *pstVobcToCiDataStru)
 			else
 			{
 				/*发生组包错误*/
-				debug_infor_printf((const)"\n VOBC: %d PackCiToIvocIteCutInfo Error \n", pstVobcToCiDataStru->VobcId);
+				debug_infor_printf((const)"\n VOBC: %d PackCiToIvocIteLineCutInfo Error \n", pstVobcToCiDataStru->VobcId);
 			}
+
 			/*主用通道给IVOC组列车位置监督状态*/
 			if (CI_SUCCESS == chRetVal)
 			{
@@ -5120,17 +5089,6 @@ static UINT8 PackCiToIvocDataCC(VobcToCiDataStruct *pstVobcToCiDataStru)
 				debug_infor_printf((const)"\n VOBC: %d PackCiToIvocFarNoOccuLogInfo Error \n", pstVobcToCiDataStru->VobcId);
 			}
 
-			/*主用通道给IVOC组向后跳跃申请回复信息*/
-			if (CI_SUCCESS == chRetVal)
-			{
-				chRetVal = PackCiToIvocJumpBackReply(cszCiToIvocDataBuf, &ii, pstVobcToCiDataStru->VobcId);
-			}
-			else
-			{
-				/*发生组包错误*/
-				debug_infor_printf((const)"\n VOBC: %d PackCiToIvocPosMonitorInfo Error \n", pstVobcToCiDataStru->VobcId);
-			}
-
 			if (CI_SUCCESS == chRetVal)
 			{
 				/*组包成功*/
@@ -5138,11 +5096,11 @@ static UINT8 PackCiToIvocDataCC(VobcToCiDataStruct *pstVobcToCiDataStru)
 			else
 			{
 				/*发生组包错误*/
-				debug_infor_printf((const)"\n VOBC: %d PackCiToIvocJumpBackReply Error \n", pstVobcToCiDataStru->VobcId);
+				debug_infor_printf((const)"\n VOBC: %d PackCiToIvocPosMonitorInfo Error \n", pstVobcToCiDataStru->VobcId);
 			}
 
 			/*预留10字节*/
-			ii += 5U;
+			ii += 10U;
 		}
 		else if ((IVOC_CI_INFO_TYPE_LOGOUT_ASK == pstVobcToCiDataStru->appInfoType) && (curCycleNum == pstVobcToCiDataStru->ComStartCycle))
 		{/*组注销请求回复帧*/
@@ -5468,7 +5426,7 @@ static UINT8 PackCiToIvocBackUpDataCC(VobcBackUpToCiDataStruct *pstVobcBackUpToC
 			/*组备用通道发给车的ITE全线切除信息*/
 			if (CI_SUCCESS == chRetVal)
 			{
-				chRetVal = PackCiToIvocIteCutInfo(cszCiToIvocDataBuf, &ii);
+				chRetVal = PackCiToIvocIteLineCutInfo(cszCiToIvocDataBuf, &ii);
 			}
 			else
 			{
@@ -5484,7 +5442,7 @@ static UINT8 PackCiToIvocBackUpDataCC(VobcBackUpToCiDataStruct *pstVobcBackUpToC
 			else
 			{
 				/*发生组包错误*/
-				debug_infor_printf((const)"\n VOBC_BACKUP: %d PackCiToIvocIteCutInfo Error \n", pstVobcBackUpToCiDataStru->VobcId);
+				debug_infor_printf((const)"\n VOBC_BACKUP: %d PackCiToIvocIteLineCutInfo Error \n", pstVobcBackUpToCiDataStru->VobcId);
 			}
 
 
@@ -5498,7 +5456,7 @@ static UINT8 PackCiToIvocBackUpDataCC(VobcBackUpToCiDataStruct *pstVobcBackUpToC
 				debug_infor_printf((const)"\n VOBC_BACKUP: %d PackCiToIvocFarNoOccuLogInfo Error \n", pstVobcBackUpToCiDataStru->VobcId);
 			}
 
-			/*预留8字节*/
+			/*预留10字节*/
 			ii += 8U;
 		}
 		else
@@ -6515,7 +6473,6 @@ static UINT8 PackCiToIvocFLockInfo(UINT8* pDataBuf, UINT16  *wDataLength)
 	UINT8 cAllLineTsrState = CI_ALL_LINE_TSR_UNVALID;/* 全线临时限速 */
 	UINT8 cAllLineTsrSpeed = 0U;/* 雨雪模式标志 */
 	UINT8 chSecFLockType = 0U;/*物理区段封锁类型*/
-	UINT8 cSnowLevel = 0U;  /*湿轨等级*/
 
 	if ((NULL == pDataBuf)
 		|| (NULL == wDataLength))
@@ -6555,23 +6512,10 @@ static UINT8 PackCiToIvocFLockInfo(UINT8* pDataBuf, UINT16  *wDataLength)
 
 		/* 雨雪模式 */
 		cSnowModel = GetAllSnowModel();
-		cSnowLevel = GetAllSnowLevel();
-
 		if (CI_ALL_SNOW_VALID == cSnowModel)
 		{
 			/* 雨雪 */
-			if (CI_SNOW_LEVEL_TWO == cSnowLevel)
+			pDataBuf[ii] = CI_ALL_SNOW_VALID;
-			{
-				pDataBuf[ii] = CI_SNOW_LEVEL_TWO;  /*雨雪模式有效且湿轨等级为二级时，发0x02*/
-			}
-			else if(CI_SNOW_LEVEL_ONE == cSnowLevel)
-			{
-				pDataBuf[ii] = CI_SNOW_LEVEL_ONE;  /*雨雪模式有效且湿轨等级为一级时，发0x01*/
-			}
-			else
-			{
-				pDataBuf[ii] = CI_ALL_SNOW_VALID;  /*雨雪模式有效且湿轨等级为默认值时，发0x55*/
-			}
 		}
 		else
 		{
@@ -6691,8 +6635,6 @@ static UINT8 PackCiToIvocCommTrainInfo(UINT8* pDataBuf, UINT16  *wDataLength)
 	UINT8 chLinkLogicDirUpAndDown = 0u;
 	UINT8 chTrainVirHeadScreenFlag = 0U;/*虚拟前筛标志*/
 	UINT8 chTrainVirTailScreenFlag = 0U;/*虚拟后筛标志*/
-	UINT8 chTrainNvramFlag = 0U;/*列车NVRAM标志*/
-	UINT8 chTrainReportState = 0U;/*列车汇报状态*/
 
 	if ((NULL == pDataBuf)
 		|| (NULL == wDataLength))
@@ -6828,18 +6770,8 @@ static UINT8 PackCiToIvocCommTrainInfo(UINT8* pDataBuf, UINT16  *wDataLength)
 					}
 					ii += 1U; /*列车信息一个字节偏移*/
 
-					chTrainNvramFlag = GetTrainNvramPosFlag(wTrainId);
-					chTrainReportState = GetTrainReportState(wTrainId);  /*该状态不检查非法值，直接发送*/
-					if (TRAIN_NVRAM_POS_FLAG_YES == chTrainNvramFlag)
-					{
-						chTrainReportState = (UINT8)(chTrainReportState | 0X40U);
-					}
-					else
-					{
-						chTrainReportState = (UINT8)(chTrainReportState | 0X00U);
-					}
 
-					pDataBuf[ii] = chTrainReportState;
+					pDataBuf[ii] = GetTrainReportState(wTrainId);  /*该状态不检查非法值，直接发送*/
 
 					ii += 1U;
 				}
@@ -9826,7 +9758,7 @@ static UINT8 PackCiToIvocSnowAndUrgentInfo(UINT8* pDataBuf, UINT16* pDataLength,
 	UINT16 kk = 0U;
 	UINT8 cAreaSnowTotalNum = 0U;  /*区间雨雪站台数量*/
 	UINT16 wAreaSnowNumIndex = 0U;
-	AreaSnowInfoStruct* pAreaSnowData = NULL;  /*区间雨雪信息数组*/
+	UINT32* pAreaSnowId = NULL;  /*区间雨雪站台ID数组*/
 	ToCiAreaSnowStruct* pRecvCiAreaSnow = NULL;  /*相邻联锁发送的区间雨雪信息*/
 	UINT8 cWlbState = 0U;  /*全线紧急制动状态*/
 	UINT8 cUrgentReason = 0U;  /*紧急原因*/
@@ -9834,8 +9766,6 @@ static UINT8 PackCiToIvocSnowAndUrgentInfo(UINT8* pDataBuf, UINT16* pDataLength,
 	EnvelopeStruct* strTrainEnvelope = NULL;  /*列车包络信息*/
 	UINT16 wAxisRelPhySecId = 0U;  /*计轴区段关联的物理区段ID*/
 	UINT8 cUrgentState = 0U;  /*发送给IVOC的紧急状态*/
-	UINT16 wSnowPlatId = 0U;
-	UINT8 cSnowLevel = 0U;  /*湿轨级别*/
 
 	if ((NULL != pDataBuf) && (NULL != pDataLength) && (0U != wTrainId) && (LINE_MAX_TRAIN > wTrainId))
 	{
@@ -9846,26 +9776,14 @@ static UINT8 PackCiToIvocSnowAndUrgentInfo(UINT8* pDataBuf, UINT16* pDataLength,
 		wAreaSnowNumIndex = ii;  /*跳过区间雨雪站台数量*/
 		ii++;
 		cAreaSnowTotalNum = GetLocalAreaSnowNum();
-		pAreaSnowData = GetLocalAreaSnow();
+		pAreaSnowId = GetLocalAreaSnowId();
 
 		if (LOCAL_AREA_SNOW_SUM_MAX >= cAreaSnowTotalNum)
 		{
 			for (jj = 0U; jj < cAreaSnowTotalNum; jj++)
 			{
-				wSnowPlatId = pAreaSnowData[jj].wAreaId;
+				LongToChar(pAreaSnowId[jj], &pDataBuf[ii]);  /*组区间雨雪站台ID*/
-				cSnowLevel = pAreaSnowData[jj].cAreaSnowLevel;
+				ii += 4U;
-				if ((0U < wSnowPlatId) && (UINT16_MAX > wSnowPlatId)
-					&& ((CI_SNOW_LEVEL_DEFAULT == cSnowLevel) || (CI_SNOW_LEVEL_ONE == cSnowLevel) || (CI_SNOW_LEVEL_TWO == cSnowLevel)))
-				{
-					ShortToChar(wSnowPlatId, &pDataBuf[ii]);  /*组区间ID*/
-					ii += 2U;
-					pDataBuf[ii] = cSnowLevel;  /*组区间湿轨级别*/
-					ii++;
-				}
-				else
-				{
-					retVal = CI_ERROR;  /*区间雨雪站台Id非法，返回失败*/
-				}
 			}
 		}
 		else
@@ -9884,23 +9802,11 @@ static UINT8 PackCiToIvocSnowAndUrgentInfo(UINT8* pDataBuf, UINT16* pDataLength,
 				{
 					if (LOCAL_AREA_SNOW_SUM_MAX > cAreaSnowTotalNum)
 					{
-						wSnowPlatId = pRecvCiAreaSnow[kk].szPlatFormInfo[jj].wAreaId;
+						LongToChar(pRecvCiAreaSnow[kk].dwPlatFormId[jj], &pDataBuf[ii]);  /*组区间雨雪站台ID*/
-						cSnowLevel = pRecvCiAreaSnow[kk].szPlatFormInfo[jj].cAreaSnowLevel;
+						ii += 4U;
-						if ((0U < wSnowPlatId) && (UINT16_MAX > wSnowPlatId)
-							&& ((CI_SNOW_LEVEL_DEFAULT == cSnowLevel) || (CI_SNOW_LEVEL_ONE == cSnowLevel) || (CI_SNOW_LEVEL_TWO == cSnowLevel)))
-						{
-							ShortToChar(wSnowPlatId, &pDataBuf[ii]);  /*组区间ID*/
-							ii += 2U;
-							pDataBuf[ii] = cSnowLevel;  /*组区间湿轨级别*/
-							ii++;
 						cAreaSnowTotalNum++;
 					}
 					else
-						{
-							retVal = CI_ERROR;  /*区间雨雪站台Id非法，返回失败*/
-						}
-					}
-					else
 					{
 						retVal = CI_ERROR;  /*区间雨雪数量超限，返回失败*/
 					}
@@ -10889,14 +10795,14 @@ static UINT8 PackCiToIvocBackUpReqStateInfo(UINT8* pDataBuf, UINT16* wDataLength
 	UINT16 kk = 0U;
 	UINT8 chAreaSnowTotalNum = 0U;  /*区间雨雪站台数量*/
 	UINT16 wAreaSnowNumIndex = 0U;
-	AreaSnowInfoStruct* pAreaSnowData = NULL;  /*区间雨雪信息数组*/
+	UINT32* pAreaSnowId = NULL;  /*区间雨雪站台ID数组*/
 	ToCiAreaSnowStruct* pRecvCiAreaSnow = NULL;  /*相邻联锁发送的区间雨雪信息*/
 	UINT8 chTsrSureFlag = GetTsrSureFlag();/* 限速确认标志位 */
 	UINT8 chAllLineTsrState = 0U;/*全线临时限速标志*/
 	UINT8 chAllLineTsrSpeed = 0U;/*全线临时限速值*/
 	UINT8 chWlbState = 0U;	/*全线紧急制动状态*/
 	UINT8 chSnowModel = 0U;	/* 雨雪模式 */
-	UINT16 wSnowPlatId = 0U;
+	
 
 	if ((NULL == pDataBuf) || (NULL == wDataLength))
 	{
@@ -10974,22 +10880,14 @@ static UINT8 PackCiToIvocBackUpReqStateInfo(UINT8* pDataBuf, UINT16* wDataLength
 		wAreaSnowNumIndex = ii;  /*跳过区间雨雪站台数量*/
 		ii++;
 		chAreaSnowTotalNum = GetLocalAreaSnowNum();
-		pAreaSnowData = GetLocalAreaSnow();
+		pAreaSnowId = GetLocalAreaSnowId();
 
 		if (ALL_AREA_SNOW_SUM_MAX >= chAreaSnowTotalNum)
 		{
 			for (jj = 0U; jj < chAreaSnowTotalNum; jj++)
 			{
-				wSnowPlatId = pAreaSnowData[jj].wAreaId;
+				LongToChar(pAreaSnowId[jj], &pDataBuf[ii]);  /*组区间雨雪站台ID*/
-				if ((0U<wSnowPlatId) && (UINT16_MAX>wSnowPlatId))
+				ii += 4U;
-				{
-					ShortToChar(wSnowPlatId, &pDataBuf[ii]);  /*组区间雨雪站台ID*/
-					ii += 2U;
-				}
-				else
-				{
-					chRetVal = CI_ERROR;  /*区间雨雪站台ID非法，返回失败*/
-				}
 			}
 		}
 		else
@@ -11008,19 +10906,11 @@ static UINT8 PackCiToIvocBackUpReqStateInfo(UINT8* pDataBuf, UINT16* wDataLength
 				{
 					if (ALL_AREA_SNOW_SUM_MAX > chAreaSnowTotalNum)
 					{
-						wSnowPlatId = pRecvCiAreaSnow[kk].szPlatFormInfo[jj].wAreaId;
+						LongToChar(pRecvCiAreaSnow[kk].dwPlatFormId[jj], &pDataBuf[ii]);  /*组区间雨雪站台ID*/
-						if ((0U < wSnowPlatId) && (UINT16_MAX > wSnowPlatId))
+						ii += 4U;
-						{
-							ShortToChar(wSnowPlatId, &pDataBuf[ii]);  /*组区间雨雪站台ID*/
-							ii += 2U;
 						chAreaSnowTotalNum++;
 					}
 					else
-						{
-							chRetVal = CI_ERROR;  /*区间雨雪站台Id非法，返回失败*/
-						}						
-					}
-					else
 					{
 						debug_infor_printf((const)"\n PackCiToIvocSnowAndUrgentInfo RecvCiAreaSnowSum_Error, sum : %d  _MAX: %d \n", pRecvCiAreaSnow, LOCAL_AREA_SNOW_SUM_MAX);
 						chRetVal = CI_ERROR;  /*区间雨雪数量超限，返回失败*/
@@ -12167,7 +12057,7 @@ static UINT8 PackCiToVobcBackUpStateData(UINT8* pDataBuf, UINT16* wDataLength,Vo
 		/*组备用通道发给车的ITE全线切除信息*/
 		if (CI_SUCCESS == chRetVal)
 		{
-			chRetVal = PackCiToIvocIteCutInfo(pDataBuf, &ii);
+			chRetVal = PackCiToIvocIteLineCutInfo(pDataBuf, &ii);
 		}
 		else
 		{
@@ -12183,7 +12073,7 @@ static UINT8 PackCiToVobcBackUpStateData(UINT8* pDataBuf, UINT16* wDataLength,Vo
 		else
 		{
 			/*发生组包错误*/
-			debug_infor_printf((const)"\n FAOHLHTVOBC_BACKUP: %d PackCiToIvocIteCutInfo Error \n", pstVobcToCiDataStru->VobcId);
+			debug_infor_printf((const)"\n FAOHLHTVOBC_BACKUP: %d PackCiToIvocIteLineCutInfo Error \n", pstVobcToCiDataStru->VobcId);
 		}
 
 		if (CI_SUCCESS == chRetVal)
@@ -12211,28 +12101,21 @@ static UINT8 PackCiToVobcBackUpStateData(UINT8* pDataBuf, UINT16* wDataLength,Vo
 }
 
 /*
-* 功能描述：组包Ci到Ivoc的ITE切除状态
+* 功能描述：组包Ci到Ivoc的ITE全线切除状态
 * 参数说明：const UINT8* dataBuf 数据缓冲区（出参）
 *           const UINT16 *dataLength 数据长度（出参）
 * 返 回 值：CI_ERROR 0 失败
 *			CI_SUCCESS 1 成功
-* Modified By LQ 2025.04.15
+* Created By LQ 2024.07.12
 */
-static UINT8 PackCiToIvocIteCutInfo(UINT8* pDataBuf, UINT16* wDataLength)
+static UINT8 PackCiToIvocIteLineCutInfo(UINT8* pDataBuf, UINT16* wDataLength)
 {
 	UINT8 chRetVal = CI_ERROR;
 	UINT16 ii = 0U;
 	UINT8 cIteLineCutState = CI_ITE_LINE_CUT_INVALID;/* ITE全线切除状态 */
-	UINT16 wAreaIteCutNumIndex = 0U;
-	UINT8 cAreaIteCutNum = 0U;  /*区间ITE切除数量*/	
-	UINT16* pAreaIteCutId = NULL;  /*区间ITE切除ID数组*/
-	UINT8 jj = 0U;	
-	ToCiAreaIteCutStruct* pRecvCiAreaIteCut = NULL;  /*相邻联锁发送的区间ITE切除信息*/
-	UINT16 kk = 0U;
 
 	if ((NULL != pDataBuf) && (NULL != wDataLength))
 	{
-		chRetVal = CI_SUCCESS;
 		ii = *wDataLength;
 
 		/* 组ITE全线切除状态 */
@@ -12245,82 +12128,11 @@ static UINT8 PackCiToIvocIteCutInfo(UINT8* pDataBuf, UINT16* wDataLength)
 		{
 			pDataBuf[ii] = CI_ITE_LINE_CUT_DEFAULT;  /* 组默认值 */
 		}
+
 		ii++;
 
-		/*组本地区间ITE切除信息*/
-		wAreaIteCutNumIndex = ii;  /*跳过区间ITE切除数量*/
-		ii++;
-		cAreaIteCutNum = GetLocalAreaIteCutNum();
-		pAreaIteCutId = GetLocalAreaIteCutId();
-
-		if ((ALL_AREA_SNOW_SUM_MAX >= cAreaIteCutNum) && (NULL != pAreaIteCutId))
-		{
-			for (jj = 0U; jj < cAreaIteCutNum; jj++)
-			{
-				ShortToChar(pAreaIteCutId[jj], &pDataBuf[ii]);  /*组区间ID*/
-				ii += 2U;
-			}
-		}
-		else
-		{
-			chRetVal = CI_ERROR;  /*区间ITE切除数量超限，返回失败*/
-			debug_infor_printf((const)"\n PackCiToIvocIteCutInfo: LocalAreaIteCutInfo Error\n");
-		}
-
-		/*组相邻联锁发送的区间ITE切除信息*/
-		pRecvCiAreaIteCut = GetCiRecvAreaIteCutInfo();
-		if (NULL != pRecvCiAreaIteCut)
-		{
-			for (kk = 0U; kk < CI_COM_CI_MAX_NUM; kk++)
-			{
-				if (0U != pRecvCiAreaIteCut[kk].cAreaIteCutNum)
-				{
-					for (jj = 0U; jj < pRecvCiAreaIteCut[kk].cAreaIteCutNum; jj++)
-					{
-						if (ALL_AREA_SNOW_SUM_MAX > cAreaIteCutNum)
-						{
-							ShortToChar(pRecvCiAreaIteCut[kk].wAreaIteCutId[jj], &pDataBuf[ii]);  /*组区间ID*/
-							ii += 2U;
-							cAreaIteCutNum++;
-						}
-						else
-						{
-							debug_infor_printf((const)"\n PackCiToIvocIteCutInfo: LocalAreaIteCutNum Error\n");
-							chRetVal = CI_ERROR;  /*区间ITE切除数量超限，返回失败*/
-							break;
-						}
-					}
-				}
-				else
-				{
-					/*继续遍历*/
-				}
-
-				if (CI_SUCCESS != chRetVal)
-				{
-					break;  /*组包失败，停止组包*/
-				}
-				else
-				{
-					/*继续组包*/
-				}
-			}
-		}
-		else
-		{
-			debug_infor_printf((const)"\n PackCiToIvocIteCutInfo: CiRecvAreaIteCutInfo Error\n");
-			chRetVal = CI_ERROR;  /*获取数据失败，返回失败*/
-		}
-
-		if (CI_SUCCESS == chRetVal)
-		{
-			pDataBuf[wAreaIteCutNumIndex] = cAreaIteCutNum;  /*组区间ITE切除数量*/
 		*wDataLength = ii;  /*传出数据长度*/
-		}
+		chRetVal = CI_SUCCESS;
-		else
-		{
-			chRetVal = CI_ERROR;  /*组包失败，返回失败*/
-		}
 	}
 	else
 	{
@@ -12438,243 +12250,3 @@ static UINT8 PackCiToIvocPosMonitorInfo(UINT8* pDataBuf, UINT16* wDataLength, co
 
 	return chRetVal;
 }
-
-/*
-* 功能描述： 组联锁到车载飞车宕机数据
-* 参数说明： 无
-* 返回值  ： 无
-* by cgh 20250630
-*/
-void PackCiToVobcFlyProtectData(void)
-{
-	UINT8 jj = 0U;
-	UINT8 chLineIdentity = GetCiFunctionSwitchConfig(VOBC_INTERFACE_IDENTITY);
-	UINT8 chFlyProtectTrainNum = GetFlyProtectNum(); /*飞车宕机数目*/
-	TrainFlyProtectStru* pFlyData = NULL; /*飞车宕机数据*/
-	UINT8 cNvramFlyProtectNum = 0U; /*使用NVRAM且位置监督无效的飞车数量*/
-	UINT16* pNvramFlyProtectId = NULL;  /*使用NVRAM且位置监督无效的飞车ID*/
-
-	cNvramFlyProtectNum = GetNvramFlyProtectNum();  /*获取使用NVRAM且位置监督无效的飞车数量*/
-	pNvramFlyProtectId = GetNvramFlyProtectId();  /*获取使用NVRAM且位置监督无效的飞车ID*/
-	if ((LINE_CC == chLineIdentity)
-		&& (SHUT_DOWN_TRAIN_NUMMAX > chFlyProtectTrainNum)
-		&& (SHUT_DOWN_TRAIN_NUMMAX > cNvramFlyProtectNum) && (NULL != pNvramFlyProtectId))
-	{
-		/*组飞车宕机的飞车特控报文*/
-		for (jj = 0U; jj < chFlyProtectTrainNum; jj++)
-		{
-			pFlyData = GetFlyProtectData(jj);
-			if (NULL != pFlyData)
-			{
-				PackCiToVobcFlyProtectInfo(pFlyData->wTrainId);
-			}
-			else
-			{
-				; /*不组包*/
-			}
-		}
-
-		/*组飞车不宕机的飞车特控报文*/
-		for (jj = 0U; jj < cNvramFlyProtectNum; jj++)
-		{
-			PackCiToVobcFlyProtectInfo(pNvramFlyProtectId[jj]);
-		}
-	}
-	else
-	{
-		; /*其它接口无此帧*/
-	}
-}
-
-/*
-* 功能描述：组RC到车载飞车宕机信息
-* 参数说明：const UINT16 wTrainId 列车ID
-* 返 回 值：无
-* Created By LQ 2025.09.15
-*/
-void PackCiToVobcFlyProtectInfo(const UINT16 wTrainId)
-{
-	UINT16 wBufIndex = 0U;
-	UINT8 ii = 0U;
-	UINT8 cszCiToIvocDataBuf[VOBC_TO_CI_DATA_LEN_MAX] = { 0U };/*CI到VOBC组帧数组*/
-	UINT16 wDataIndex = 0U; /*组包数据索引*/
-	UINT8 chLocalCiId = 0U;  /*本地联锁ID*/
-	UINT32 dwCiEtcsId = 0U; /*联锁互联互通编号*/
-	UINT32 dwVobcEtcsId = 0U; /*车载互联互通ID*/
-	UINT32 dwEmapCheckVer = 0U; /*电子地图数据版本号*/
-	UINT8 chTempResult = 0U;/*临时检查结果*/
-	UINT32 dwCurCycleNum = 0U; /*当前联锁周期号*/
-	UINT32 dwAppCycleTime = 0U;
-	UINT32 dwSrcCrntSN = 0U;
-	UINT32 dwCiRcvSN = 0U;
-	UINT16 wDstDevId = 0U; /*目的设备ID*/
-
-	wBufIndex = GetTrainBufIndex(wTrainId);
-	chLocalCiId = GetSystemParaLocalCiId();  /*本地联锁ID*/
-	if ((TRAIN_SUM_MAX > wBufIndex) && (0U != chLocalCiId))
-	{
-		dwCurCycleNum = Get2oo2CurCycleNum(); /*当前联锁周期号*/
-		dwAppCycleTime = GetSystemParaAppCycleTime();
-		for (ii = 0U; ii < VobcToCiSum; ii++)
-		{
-			if (VobcToCiDataStru[ii].VobcId == wTrainId)
-			{
-				break;
-			}
-			else
-			{
-				/*继续遍历比较*/
-			}
-		}
-
-		if (ii == VobcToCiSum)
-		{
-			; /*没找到当前和该车通信，不组包*/
-		}
-		else
-		{
-			/*开始组包*/
-			chTempResult = dquDevName2HlhtId((CI_SYSTEM_TYPE_CI * 256U) + chLocalCiId, 0U, &dwCiEtcsId);
-			chTempResult &= dquDevName2HlhtId((CI_SYSTEM_TYPE_VOBC * 256U) + (UINT8)(VobcToCiDataStru[ii].VobcId), VobcToCiDataStru[ii].vobcLogId, &dwVobcEtcsId);
-			chTempResult &= GetCiEmapCheckVer(chLocalCiId, &dwEmapCheckVer, CI_SYSTEM_TYPE_VOBC);
-
-			if (CI_SUCCESS == chTempResult)
-			{
-				dwSrcCrntSN = GetHLHTHeadCtxSrcCrntSN(CI_SYSTEM_TYPE_VOBC, (UINT8)(VobcToCiDataStru[ii].VobcId));
-				dwCiRcvSN = GetHLHTHeadCtxCiRcvSN(CI_SYSTEM_TYPE_VOBC, (UINT8)(VobcToCiDataStru[ii].VobcId));
-				wDataIndex = 0U;
-
-				ShortToChar(IVOC_CI_INTERFACE_INFOTYPE, &cszCiToIvocDataBuf[wDataIndex]);/*接口信息类型*/
-				wDataIndex += 2U;
-				LongToChar(dwCiEtcsId, &cszCiToIvocDataBuf[wDataIndex]);/*发送方标识信息*/
-				wDataIndex += 4U;
-				LongToChar(dwVobcEtcsId, &cszCiToIvocDataBuf[wDataIndex]);/*接收方标识信息*/
-				wDataIndex += 4U;
-				LongToChar(dwEmapCheckVer, &cszCiToIvocDataBuf[wDataIndex]);/*电子地图版本校验信息*/
-				wDataIndex += 4U;
-				LongToChar(dwCurCycleNum, &cszCiToIvocDataBuf[wDataIndex]);/*本方消息序列号*/
-				wDataIndex += 4U;
-				ShortToChar((UINT16)dwAppCycleTime, &cszCiToIvocDataBuf[wDataIndex]);/*设备通讯周期*/
-				wDataIndex += 2U;
-				LongToChar(dwSrcCrntSN, &cszCiToIvocDataBuf[wDataIndex]);/*对方消息序列号：recvOppMsgSN记录收到对方上一条消息中的对方消息序列号*/
-				wDataIndex += 4U;
-				LongToChar(dwCiRcvSN, &cszCiToIvocDataBuf[wDataIndex]);/*收到上一条消息时本方序列号*/
-				wDataIndex += 4U;
-				cszCiToIvocDataBuf[wDataIndex] = CI_VOBC_PRTCL_VER;/*HLHT+FAO_CI_VOBC接口协议版本号*/
-				wDataIndex++;
-
-				wDataIndex += 2U;/*通用报文头中的应用层报文总长度*/
-				/*以下为应用层数据*/
-				wDataIndex += 2U;/*报文长度*/
-				ShortToChar(CI_IVOC_INFO_TYPE_SPECIAL_CONTROL, &cszCiToIvocDataBuf[wDataIndex]);
-				wDataIndex += 2U;/*应用报文类型*/
-				wDataIndex += 2U;/*预留两个字节*/
-
-				/*特控报文*/
-				cszCiToIvocDataBuf[wDataIndex] = CI_IVOC_LOST_POSITION;
-				wDataIndex++;
-
-				/*应用层数据的报文长度 */
-				cszCiToIvocDataBuf[31U] = (UINT8)((UINT8)((wDataIndex - 33U) >> 8U) & 0xFFU);
-				cszCiToIvocDataBuf[32U] = (UINT8)((wDataIndex - 33U) & 0xFFU);
-
-				/*通用报文头中应用层报文总长度*/
-				cszCiToIvocDataBuf[29U] = (UINT8)((UINT8)((wDataIndex - 31U) >> 8U) & 0xFFU);
-				cszCiToIvocDataBuf[30U] = (UINT8)((wDataIndex - 31U) & 0xFFU);
-
-				wDstDevId = ((UINT16)(CI_SYSTEM_TYPE_VOBC << 8U) | VobcToCiDataStru[ii].VobcId);
-				chTempResult = OutnetSafeSend(wDstDevId, (VobcToCiDataStru[ii].vobcLogId), &cszCiToIvocDataBuf[0], wDataIndex);
-
-				if (1U == chTempResult)
-				{ /*写队列成功*/
-#ifdef LOGPRINT/*日志打印宏*/                 
-#ifdef PLATFORM_2OO2/*2oo2平台打印*/
-					debug_infor_printf((const)"\nVOBCFLYPROTECT_SEND:%d vobc:%d", wDataIndex, VobcToCiDataStru[ii].VobcId);
-					debug_out_array(0xAA, cszCiToIvocDataBuf, wDataIndex);
-#endif/*平台打印结束*/
-#endif
-				}
-				else
-				{
-					debug_infor_printf((const)"\nWrite VOBC %d FLYPROTECT Error, Len = %d\n", VobcToCiDataStru[ii].VobcId, wDataIndex);
-				}
-			}
-			else
-			{
-				/*不组包*/
-				debug_infor_printf((const)"\nvobc %d PackCiToVobcFlyProtectInfo error，dwCiEtcsId：%d dwVobcEtcsId：%d dwEmapCheckVer：%d \n", VobcToCiDataStru[ii].VobcId, dwCiEtcsId, dwVobcEtcsId, dwEmapCheckVer);
-			}
-		}
-	}
-	else
-	{
-		; /*其它接口无此帧*/
-	}
-
-}
-
-/*
-* 功能描述：组包Ci到Ivoc的向后跳跃申请回复
-* 参数说明： UINT8* dataBuf, 数据缓冲区
-*            UINT16 *dataLength, 数据长度 输出参数
-*			 UINT16 wTrainId 列车ID
-* 返 回 值：CI_ERROR 0 失败
-*			CI_SUCCESS 1 成功
-* Create： fan 20250725
-*/
-UINT8 PackCiToIvocJumpBackReply(UINT8* pDataBuf, UINT16* wDataLength, UINT16 wTrainId)
-{
-	UINT8 chRetVal = CI_ERROR;
-	UINT16 ii = 0U;
-	UINT8 chJumpBackReplyState = 0U;
-	UINT32 dwJumpBackSn = 0U;
-
-	if ((NULL == pDataBuf) || (NULL == wDataLength))
-	{
-		chRetVal = CI_ERROR;
-	}
-	else
-	{
-
-		ii = *wDataLength;
-		chRetVal = CI_SUCCESS;
-
-
-		chJumpBackReplyState = GetTrainJumpBackReplyState(wTrainId);
-		if ((TRAIN_JUMP_BACK_STATE_NONE == chJumpBackReplyState)
-			|| (TRAIN_JUMP_BACK_STATE_VALID == chJumpBackReplyState) || (TRAIN_JUMP_BACK_STATE_INVALID == chJumpBackReplyState))
-		{
-			pDataBuf[ii] = chJumpBackReplyState;
-			ii++;
-
-			if (TRAIN_JUMP_BACK_STATE_NONE == chJumpBackReplyState)
-			{
-				LongToChar(0U, &pDataBuf[ii]);
-				ii += 4U;
-			}
-			else
-			{
-				/*回复序列号*/
-				dwJumpBackSn = GetTrainJumpBackApplySN(wTrainId);
-				LongToChar(dwJumpBackSn, &pDataBuf[ii]);
-				ii += 4U;
-			}
-		}
-		else
-		{
-			chRetVal = CI_ERROR;
-		}
-	}
-
-	if (CI_SUCCESS == chRetVal)
-	{
-		*wDataLength = ii;
-	}
-	else
-	{
-		chRetVal = CI_ERROR;
-	}
-
-	return chRetVal;
-
-}

TSCP/src/APP/ciapp/ParsePack/ParsePackVobcData.h

@@ -102,7 +102,6 @@
 #define CI_IVOC_INFO_TYPE_LOGOUT_ACK ((UINT16)0x0204U)	/*OC->IVOC注销回复帧，非周期*/
 #define IVOC_CI_INFO_TYPE_HEART_FRAME ((UINT16)0x0205U)	/*IVOC->OC心跳帧，非周期*/
 #define CI_IVOC_INFO_TYPE_HEART_FRAME ((UINT16)0x0206U)	/*OC->IVOC心跳帧，非周期*/
-#define CI_IVOC_INFO_TYPE_SPECIAL_CONTROL ((UINT16)0x0208U)	/*rc->IVOC特控报文帧，非周期*/
 
 #define CI_IVOC_PRTCL_VER		((UINT8)0x01U)					/*CI_VOBC协议版本号*/
 #define CI_IVOC_BACKUP_PRTCL_VER		((UINT8)0x066)					/*CI_VOBC后备通道协议版本号*/
@@ -223,8 +222,6 @@
 
 #define CI_VOBC_BACKUP_SEND_ROUTE_SUM		((UINT8)5U)	/*CI到车载后备通道进路数量最大值*/
 
-#define CI_IVOC_LOST_POSITION	((UINT8)0x55U)		  /*CI到车载特控报文 丢位置*/
-
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -356,8 +353,6 @@ typedef struct S_VobcToCiDataStruct
 	UINT8 chNvramPosFlag;		/*NVNAM位置标识 0x55：列车使用NVRAM位置    0xaa：列车未使用NVRAM位置*/
 	UINT16 wHeadSigId;   /*前方信号机ID*/
 	UINT16 wHeadVobcId;                                           /*前车ID*/
-	UINT8 chJumpBackApply;		 /*向后跳跃申请*/
-	UINT32 dwJumpBackSn;		 /*向后跳跃申请序列号*/
 } VobcToCiDataStruct;
 
 /*使用后备模式与联锁通信的Vobc信息*/
@@ -688,32 +683,6 @@ UINT8 ParseFAOHLHTOtherTypeData(const UINT16 appInfoType, UINT8* dataBuf, UINT16
 */
 UINT8 ParseFAOHLHTBackUpControlData(UINT8* dataBuf, UINT16 dataLen, VobcToCiDataStruct* vobcToCiDataStru);
 
-/*
-* 功能描述： 组联锁到车载飞车宕机数据
-* 参数说明： 无
-* 返回值  ： 无
-* by cgh 20250630
-*/
-void PackCiToVobcFlyProtectData(void);
-
-/*
-* 功能描述：组RC到车载飞车宕机信息
-* 参数说明：const UINT16 wTrainId 列车ID
-* 返 回 值：无
-* Created By LQ 2025.09.15
-*/
-void PackCiToVobcFlyProtectInfo(const UINT16 wTrainId);
-
-/*
-* 功能描述：组包Ci到Ivoc的向后跳跃申请回复
-* 参数说明： UINT8* dataBuf, 数据缓冲区
-*            UINT16 *dataLength, 数据长度 输出参数
-*			 UINT16 wTrainId 列车ID
-* 返 回 值：CI_ERROR 0 失败
-*			CI_SUCCESS 1 成功
-* Create： fan 20250725
-*/
-UINT8 PackCiToIvocJumpBackReply(UINT8* pDataBuf, UINT16* wDataLength, UINT16 wTrainId);
 #ifdef __cplusplus
 }
 #endif

TSCP/src/APP/ciapp/ParsePack/ParsePackZcData.c

@@ -58,9 +58,6 @@ UINT8 ParseZcToCiDataFrame(UINT8* dataBuf, UINT16 dataLength, UINT8 systemId)
 	UINT16 wMsgLen = 0u;  /*单个应用信息长度记录*/
 	UINT16 wMsgType = 0u; /*单个应用信息报文类型*/
 	UINT16 wMsgCheckLen = 0u;			/* 用于解析校验的数据长度 */
-	UINT8 funRet = 0U;
-	UINT32 dwCurCyc = 0U;
-	UINT8 chDataType = 0U;
 
 	lineIdentity = GetCiFunctionSwitchConfig(VOBC_INTERFACE_IDENTITY);/*获取线路标识*/
 
@@ -69,7 +66,7 @@ UINT8 ParseZcToCiDataFrame(UINT8* dataBuf, UINT16 dataLength, UINT8 systemId)
 	zcName = (CI_SYSTEM_TYPE_ZC)*256U + systemId;
 	ciName = (CI_SYSTEM_TYPE_CI)*256U + localCiId;
 	curntCycleNo = Get2oo2CurCycleNum();
-	chDataType = GetLocalPublicDataType(); /*区分28.0.0.14与其他线路zc接口*/
+
 	if ((NULL != dataBuf) && (dataLength > 0u))
 	{
 		sourceId = GetCiTransmitSpecifySysDevBuf(CI_SYSTEM_TYPE_ZC);/*获取与本联锁通信的ZC的ID，目前一个联锁最多只与一个ZC通信*/
@@ -130,8 +127,6 @@ UINT8 ParseZcToCiDataFrame(UINT8* dataBuf, UINT16 dataLength, UINT8 systemId)
 				{
 					/*报文有效，继续解析*/
 					retVal = CI_SUCCESS;
-					{
-						if (DATA_TYPE_NEW == chDataType)
 					{
 						while (wTmpDataLen < hlhtGalHead.totalDataLen)
 						{
@@ -186,7 +181,7 @@ UINT8 ParseZcToCiDataFrame(UINT8* dataBuf, UINT16 dataLength, UINT8 systemId)
 									break;
 								case ZC_TO_TIOC_ITELINECUT_MSG:
 									/*解析ZC-CI的ITE切除信息*/
-										retVal = ParseZcIteCutData(&dataBuf[ii], wMsgCheckLen);
+									retVal = ParseZcIteLineCutData(&dataBuf[ii], wMsgCheckLen);
 									dwStep |= 0x00001U;
 									break;
 								default:
@@ -215,6 +210,7 @@ UINT8 ParseZcToCiDataFrame(UINT8* dataBuf, UINT16 dataLength, UINT8 systemId)
 								;  /*do nothing*/
 							}
 						}
+
 						if (CI_SUCCESS == retVal)
 						{
 							/*校验数据长度*/
@@ -223,29 +219,11 @@ UINT8 ParseZcToCiDataFrame(UINT8* dataBuf, UINT16 dataLength, UINT8 systemId)
 								retVal = CI_ERROR;
 							}
 						}
-						}
-						else
-						{
-							/*杭德线无报文类型、类型长度和预留，仅具备码位0201*/
-							wMsgCheckLen = hlhtGalHead.totalDataLen;
-							retVal = ParseMaskData(&dataBuf[ii], wMsgCheckLen);
-							if (CI_ERROR == retVal)
-							{
-								debug_infor_printf((const)"\nParseZcToCiDataFrame_Error MaskOnly\n");
-								ClearZcData(); /*没解析通过则清空*/
-							}
-							else
-							{
-								; /*继续*/
-							}
-						}
 
 						if (CI_SUCCESS == retVal)
 						{
 							/*更新通信周期*/
-							dwCurCyc = Get2oo2CurCycleNum();
+							if (SetCiTransmitRecvDataCycNum(GetSystemParaLocalCiId(), CI_SYSTEM_TYPE_ZC, sourceId[0], Get2oo2CurCycleNum()) == CI_ERROR)
-							funRet = SetCiTransmitRecvDataCycNum(localCiId, CI_SYSTEM_TYPE_ZC, sourceId[0], dwCurCyc);
-							if (CI_ERROR == funRet)
 							{/*更新周期失败*/
 
 							}
@@ -253,8 +231,7 @@ UINT8 ParseZcToCiDataFrame(UINT8* dataBuf, UINT16 dataLength, UINT8 systemId)
 							{/*更新周期成功*/
 
 							 /*更新与ZC通信状态：判断与ZC是否通信中断*/
-								funRet = UpdateCiTransmitState(localCiId, CI_SYSTEM_TYPE_ZC, sourceId[0]);
+								if (UpdateCiTransmitState(GetSystemParaLocalCiId(), CI_SYSTEM_TYPE_ZC, sourceId[0]) == CI_ERROR)
-								if (CI_ERROR == funRet)
 								{
 									/*更新通信状态失败*/
 								}
@@ -911,13 +888,12 @@ UINT8 ParseZcSnowData(UINT8* dataBuf, UINT16 dataLen)
 	UINT8 cRetVal = CI_ERROR;
 	UINT16 ii = 0u;
 	UINT8 jj = 0U;
-	UINT16 wPlatFormId = 0U;  /*站台互联互通ID*/
+	UINT16 dwPlatFormId = 0U;  /*站台互联互通ID*/
 	UINT8 cPlatFormNum = 0U;  /*ZC发送区间雨雪站台数量*/
 	UINT8 cTmepNum = 0U;/*本控区区间雨雪站台数量*/
 	UINT8 cPlatFormBelongCiId = 0U;  /*站台关联Link所属CI*/
 	UINT8 cLocalCiId = 0U;
 	UINT8 chLocalSnowValidFlag = 0U; /*本地雨雪命令有效标志*/
-	UINT8 cAllLineSnowLevel = 0U;  /*全线湿轨级别*/
 
 	if (NULL == dataBuf)
 	{
@@ -964,18 +940,17 @@ UINT8 ParseZcSnowData(UINT8* dataBuf, UINT16 dataLen)
 			cLocalCiId = GetSystemParaLocalCiId();
 			for (jj = 0U; jj < cPlatFormNum; jj++)
 			{
-				wPlatFormId = ShortFromChar(&dataBuf[ii]);  /*解析区间雨雪站台ID*/
+				dwPlatFormId = ShortFromChar(&dataBuf[ii]);  /*解析区间雨雪站台ID*/
 				ii += 2U;
-				cPlatFormBelongCiId = GetAreaSnowPlatFormBelongCiId(wPlatFormId);  /*获取区间雨雪站台所属控区*/
+				cPlatFormBelongCiId = GetAreaSnowPlatFormBelongCiId(dwPlatFormId);  /*获取区间雨雪站台所属控区*/
-				if ((0U < wPlatFormId)&& (UINT16_MAX > wPlatFormId))
+				if (0U != dwPlatFormId) 
 				{
 					if (cLocalCiId == cPlatFormBelongCiId)
 					{
 						/*站台属于本控区*/
 						if (LOCAL_AREA_SNOW_SUM_MAX > cTmepNum)
 						{
-							ZcToCiDataStru.szAreaSnowInfo[cTmepNum].wAreaId = wPlatFormId;
+							ZcToCiDataStru.szAreaSnowPlatFormId[cTmepNum] = (UINT32)dwPlatFormId;
-							ZcToCiDataStru.szAreaSnowInfo[cTmepNum].cAreaSnowLevel = CI_SNOW_LEVEL_DEFAULT;  /*CI模式，湿轨等级为默认值(适配TMC)*/
 							cTmepNum++;
 						}
 						else
@@ -993,7 +968,7 @@ UINT8 ParseZcSnowData(UINT8* dataBuf, UINT16 dataLen)
 				else
 				{
 					cRetVal = CI_ERROR;  /*区间雨雪站台Id非法，返回失败*/
-					debug_infor_printf((const)"ParseZcToCiSNOW_Error  wPlatFormId\n");
+					debug_infor_printf((const)"ParseZcToCiSNOW_Error  dwPlatFormId\n");
 				}
 			}
 
@@ -1068,7 +1043,6 @@ UINT8 PackCiToZcData( UINT8 deviceId)
 	UINT32 dwHlhtHSrcSN = 0u;
 	UINT32 dwHlhtHRcvSN = 0u;
 	UINT16 totallenIndex = 0U;
-	UINT8 chDataType = 0U;
 
 	localCi = GetSystemParaLocalCiId(); /*获取本地联锁ID*/
 	ci_zcPrtclVersion = GetVersionOfZCToCI();
@@ -1078,7 +1052,6 @@ UINT8 PackCiToZcData( UINT8 deviceId)
 	dwHlhtHSrcSN = GetHLHTHeadCtxSrcCrntSN(CI_SYSTEM_TYPE_ZC, deviceId);
 	dwHlhtHRcvSN = GetHLHTHeadCtxCiRcvSN(CI_SYSTEM_TYPE_ZC, deviceId);
 	CiEmapCheckVer = GetCiEmapCheckVer(localCi, &emapCheckVer, CI_SYSTEM_TYPE_ZC);
-	chDataType = GetLocalPublicDataType();
 	if ((CI_SUCCESS == CIName2HlhtId) && (CI_SUCCESS == ZCName2HlhtId) && (CI_SUCCESS == CiEmapCheckVer))
 	{
 		retVal = CI_SUCCESS;
@@ -1147,19 +1120,13 @@ UINT8 PackCiToZcData( UINT8 deviceId)
 
 			totallenIndex = ii;
 			ii += 2u;/*通用报文头中的应用层报文总长度*/
-			if (DATA_TYPE_NEW == chDataType)
+
-			{
 			ii += 2u;/*通用报文头中的应用层报文长度(0x202报文长度)*/
 
 			ShortToChar(TIOC_TO_ZC_MASK_MSG, &CiToZcDataBuffer[ii]);/*接口信息类型*/
 			ii += 2u;
 
 			ii += 2u; /*预留*/
-			}
-			else
-			{
-				;/*杭德线路无0x202报文长度、类型及预留*/
-			}
 
 			/*组码位信息*/
 			(void)MaskPack(CI_SYSTEM_TYPE_ZC,&CiToZcDataBuffer[ii]);	
@@ -1167,12 +1134,11 @@ UINT8 PackCiToZcData( UINT8 deviceId)
 
 			/*通用报文头中应用层报文总长度*/
 			ShortToChar(ii - totallenIndex - 2U, &CiToZcDataBuffer[totallenIndex]);
-			if (DATA_TYPE_NEW == chDataType)
+			
-			{
+			/*通用应用层报文总长度*/
-				/*通用应用层报文长度(0x202报文长度)*/
 			totallenIndex += 2U;
 			ShortToChar(ii - totallenIndex - 2U, &CiToZcDataBuffer[totallenIndex]);
-			}
+
 			/*清ZC数据*/
 			ClearZcData();
 
@@ -1356,25 +1322,21 @@ ZcToCiDataStruct* GetZcToCiDataStru(void)
 }
 
 /*
-* 功能描述：解析ZC到CI的ITE切除状态数据
+* 功能描述：解析ZC到CI的ITE全线切除状态数据
 * 参数说明：INT8* dataBuf 数据缓冲区
 *           UINT16 dataLength 数据长度
 * 返 回 值：CI_ERROR 0 数据解析失败
 *			CI_SUCCESS 1 数据解析成功
-* Edit By LQ 2025.04.15
+* Created By LQ 2024.07.12
 */
-UINT8 ParseZcIteCutData(UINT8* dataBuf, UINT16 dataLen)
+UINT8 ParseZcIteLineCutData(UINT8* dataBuf, UINT16 dataLen)
 {
 	UINT8 cRetVal = CI_ERROR;
 	UINT8 cIteLineCutState = CI_ITE_LINE_CUT_INVALID;  /*ZC发送的ITE全线切除状态*/
 	UINT16 ii = 0U;
-	UINT8 jj = 0U;
-	UINT16 wPlatFormId = 0U;  /*区间站台ID*/
-	UINT8 cPlatFormNum = 0U;  /*ZC发送区间ITE切除数量*/
 
 	if (NULL != dataBuf)
 	{
-		cRetVal = CI_SUCCESS;
 		/*解析ZC发送的ITE全线切除状态*/
 		cIteLineCutState = dataBuf[ii];
 		ii++;
@@ -1383,56 +1345,19 @@ UINT8 ParseZcIteCutData(UINT8* dataBuf, UINT16 dataLen)
 		{
 			ZcToCiDataStru.cIteLineCutState = cIteLineCutState;
 
-			cPlatFormNum = dataBuf[ii];  /*解析区间ITE切除数量*/
+			if (dataLen == ii)
-			ii++;
-
-			if (ALL_AREA_SNOW_SUM_MAX >= cPlatFormNum)
 			{
-				ZcToCiDataStru.cAreaIteCutNum = cPlatFormNum;
+				cRetVal = CI_SUCCESS;
-
-				for (jj = 0U; jj < cPlatFormNum; jj++)
-				{
-					wPlatFormId = ShortFromChar(&dataBuf[ii]);  /*解析区间ID*/
-					ii += 2U;
-
-					if ((0U < wPlatFormId) && (UINT16_MAX > wPlatFormId))
-					{
-						ZcToCiDataStru.szAreaIteCutId[jj] = wPlatFormId;
 			}
 			else
 			{
-						debug_infor_printf((const)"ParseZcIteCutData: PlatFormId Error\n");
+				debug_infor_printf((const)"ParseZcIteLineCutData Error: MsgLen Is Error\n");
-						cRetVal = CI_ERROR;  /*区间ID非法，返回失败*/	
+				cRetVal = CI_ERROR;  /*长度不一致，返回失败*/
-						break;
-					}
-				}
-
-				if (CI_SUCCESS == cRetVal)
-				{
-					if (dataLen != ii)
-					{
-						debug_infor_printf((const)"ParseZcIteCutData: Msg Len Error\n");
-						cRetVal = CI_ERROR;
-					}
-					else
-					{
-						/*不处理*/
 			}
 		}
 		else
 		{
-					/*不处理*/
+			debug_infor_printf((const)"ParseZcIteLineCutData Error: IteLineCutState Is Invalid\n");
-				}
-			}
-			else
-			{
-				debug_infor_printf((const)"ParseZcIteCutData: ZC AreaIteCutNum Error\n");
-				cRetVal = CI_ERROR;  /*ZC区间ITE切除数量超限，返回失败*/
-			}
-		}
-		else
-		{
-			debug_infor_printf((const)"ParseZcIteCutData Error: IteLineCutState Error\n");
 			cRetVal = CI_ERROR;  /*状态非法，返回失败*/
 		}
 	}

TSCP/src/APP/ciapp/ParsePack/ParsePackZcData.h

@@ -33,7 +33,7 @@
 #define ZC_TO_TIOC_TSR_MSG  ((UINT16)0x0203u)		 /*ZC发送TIOC临时限速信息类型*/
 #define ZC_TO_TIOC_WLB_MSG  ((UINT16)0x0204u)		 /*ZC发送TIOC紧急制动信息类型*/
 #define ZC_TO_TIOC_SNOW_MSG  ((UINT16)0x0205u)		 /*ZC发送TIOC雨雪模式信息类型*/
-#define ZC_TO_TIOC_ITELINECUT_MSG  ((UINT16)0x0206U) /*ZC发送TIOC的全线ITE切除状态信息类型*/
+#define ZC_TO_TIOC_ITELINECUT_MSG  ((UINT16)0x0206U) /*ZC发送TIOC的ITE切除状态信息类型*/
 #define ZC_TSR_VALID  ((UINT8)0x55U)		 /*ZC发送临时限速有效*/
 
 #ifdef __cplusplus
@@ -59,11 +59,9 @@ typedef struct S_ZcToCiDataStruct
 	EbInputInfoStruct esbInputInfoStruct; /*紧急制动信息*/
 	UINT8 cSnowValidFlag;				/* 全线雨雪模式命令有效标志 */
 	UINT8 cAreaSnowPlatFormNum;  /*区间雨雪站台数量*/
-	AreaSnowInfoStruct szAreaSnowInfo[LOCAL_AREA_SNOW_SUM_MAX];  /*区间雨雪数组*/
+	UINT32 szAreaSnowPlatFormId[LOCAL_AREA_SNOW_SUM_MAX];  /*区间雨雪站台ID数组*/
 	UINT8 chLocalSnowValidFlag;				/* 本地雨雪模式命令有效标志 */
 	UINT8 cIteLineCutState;				/* ITE全线切除状态 */
-	UINT8 cAreaIteCutNum;  /*区间ITE切除数量*/
-	UINT16 szAreaIteCutId[ALL_AREA_SNOW_SUM_MAX];  /*区间ITE切除ID数组*/
 } ZcToCiDataStruct;
 
 /*通信车位置信息*/
@@ -198,14 +196,14 @@ UINT8 ParseZcSnowData(UINT8* dataBuf, UINT16 dataLen);
 ZcToCiDataStruct* GetZcToCiDataStru(void);
 
 /*
-* 功能描述：解析ZC到CI的ITE切除状态数据
+* 功能描述：解析ZC到CI的ITE全线切除状态数据
 * 参数说明：INT8* dataBuf 数据缓冲区
 *           UINT16 dataLength 数据长度
 * 返 回 值：CI_ERROR 0 数据解析失败
 *			CI_SUCCESS 1 数据解析成功
 * Created By LQ 2024.07.12
 */
-UINT8 ParseZcIteCutData(UINT8* dataBuf, UINT16 dataLen);
+UINT8 ParseZcIteLineCutData(UINT8* dataBuf, UINT16 dataLen);
 
 #ifdef __cplusplus
 }

TSCP/src/APP/ciapp/QueryFiles/dquCIInit.h

@@ -32,7 +32,6 @@
 #include "NonAutoReturnConfigDataManage.h"
 #include "../SGBJ/SGBJConfigDataManage.h"
 #include "../Section/AxisSectionConfigDataManage.h"
-#include "../System/SystemParameterManage.h"
 
 #define ORIGIN_TO_TERMINAL	((UINT8)0x55)	/*起点到终点*/
 #define TERMINAL_TO_ORIGIN	((UINT8)0xAA)	/*终点到起点*/
@@ -61,7 +60,6 @@
 
 #define AXIS_TYPE_YONGLIE ((UINT8)(0x01)) /*永列*/
 #define AXIS_TYPE_KEANDA ((UINT8)(0x02)) /*科安达*/
-#define AXIS_TYPE_FUHAOSHENG  ((UINT8)(0x03)) /*富豪盛*/
 
 #define INDICATOR_MAX_SIZE	((UINT16)2000) /*报警灯最大数组大小*/
 
@@ -84,10 +82,6 @@
 #define LINK_LINXIAN_YES		((UINT8)0x55)	/*Link具有临线属性*/
 #define LINK_LINXIAN_NO			((UINT8)0xFF)	/*Link不具有临线属性*/
 
-/*临线属性*/
-#define LINK_SPECOAL_EA_YES		((UINT8)0x55)	/*Link具有特殊防护分区区域属性*/
-#define LINK_SPECOAL_EA_NO		((UINT8)0xAA)	/*Link不具有特殊防护分区区域属性*/
-
 typedef struct 
 {  
     RelayConfigDataStruct  RelayCfgDtStr[RELAY_SUM_MAX];                              /*继电器配置数据数组*/

TSCP/src/APP/ciapp/QueryFiles/dquCIInterFace.c

@@ -4560,75 +4560,3 @@ UINT8 EnsureNearAxleStorageLineAtrr(const UINT16 wAxleId)
 	return cRetVal;
 }
 
-/*
-* 功能描述：读取物理区段在计轴中的索引
-* 参数说明：const UINT8 chLocalCiId 本地联锁ID
-*			PhysicalSectionConfigDataStruct* pPhysicalSectionConfigDataStru 物理区段结构体
-* 返回值  ：CI_SUCCESS,成功
-*			CI_ERROR,失败
-* BY CGH 20250418
-*/
-UINT8 ReadPhySecIndexInAxle(const UINT8 chLocalCiId, PhysicalSectionConfigDataStruct* pPhysicalSectionConfigDataStru)
-{
-	UINT8 chReval = CI_ERROR;
-	UINT8 chDevSum = 0U; /*设备数目*/
-	UINT8* szDevIdBuf = NULL; /*设备ID数组*/
-	UINT8 ii = 0U;
-	UINT16 jj = 0U;
-	UINT16 wIndexInAxle = 0U; /*物理区段在计轴系统中的索引*/
-
-	if ((0U != chLocalCiId) && (NULL != pPhysicalSectionConfigDataStru))
-	{
-		chReval = CI_SUCCESS;
-		chDevSum = GetCiTransmitSpecifySysDevSum(CI_SYSTEM_TYPE_AXIS);
-		szDevIdBuf = GetCiTransmitSpecifySysDevBuf(CI_SYSTEM_TYPE_AXIS);
-		
-		for (ii = 0U; ii < chDevSum; ii++)
-		{
-			wIndexInAxle = 1U;
-			for (jj = 0U; jj < dquCICfgDtStr.PsclSgmtCfgDtStrLen; jj++)
-			{
-				if (dquCICfgDtStr.PsclSgmtCfgDtStr[jj].PhysicalSectionId < PHYSICAL_SECTION_SUM_MAX)
-				{
-					if (chLocalCiId == dquCICfgDtStr.PsclSgmtCfgDtStr[jj].BelongCiId)
-					{
-						if (szDevIdBuf[ii] == (UINT8)dquCICfgDtStr.PsclSgmtCfgDtStr[jj].BelongAxleSysID)
-						{
-							pPhysicalSectionConfigDataStru[dquCICfgDtStr.PsclSgmtCfgDtStr[jj].PhysicalSectionId].wIndexInAxle = wIndexInAxle;
-							wIndexInAxle++;
-						}
-						else
-						{
-							;
-						}					
-					}
-					else
-					{
-						; 
-					}
-				}
-				else
-				{
-					chReval = CI_ERROR;
-					break;
-				}			
-			}
-
-			if (CI_ERROR == chReval)
-			{
-				break;
-			}
-			else
-			{
-				;
-			}
-		}
-	}
-	else
-	{
-		;
-	}
-
-	return chReval;
-}
-

TSCP/src/APP/ciapp/QueryFiles/dquCIInterFace.h

@@ -497,16 +497,6 @@ UINT8 EnsureAxleBorderAtrr(const UINT16 wAxleId);
 *********************************************/
 UINT8 EnsureNearAxleStorageLineAtrr(const UINT16 wAxleId);
 
-/*
-* 功能描述：读取物理区段在计轴中的索引
-* 参数说明：const UINT8 chLocalCiId 本地联锁ID
-*			PhysicalSectionConfigDataStruct* pPhysicalSectionConfigDataStru 物理区段结构体
-* 返回值  ：CI_SUCCESS,成功
-*			CI_ERROR,失败
-* BY CGH 20250418
-*/
-UINT8 ReadPhySecIndexInAxle(const UINT8 chLocalCiId, PhysicalSectionConfigDataStruct* pPhysicalSectionConfigDataStru);
-
 #ifdef __cplusplus
 }
 #endif

TSCP/src/APP/ciapp/QueryFiles/dquCIJDQStruFrmChar.c

@@ -280,16 +280,6 @@ UINT8 R_ScreenStructFromChar(UINT8 * pDataAddr,Relay_ScreenStruct* pScrnStr, UIN
 			pData += 2U;
 		}
 
-		if (54U < rowLen)
-		{
-			pScrnStr->chControlType = *pData;	/*屏蔽门控制类型*/
-			pData += 1U;
-		}
-		else
-		{/*若没有这一列配置*/
-			pScrnStr->chControlType = PSD_CONTROL_TYPE_RCI;	/*由RCI控制*/
-		}
-
 		rtnvalue = 1u;
 	}
 
@@ -639,11 +629,25 @@ UINT8 R_ZhaoChaStruFromChar(UINT8 * pDataAddr,Relay_ZhaoChaStruct* pZCStr,UINT16
 			index += 2u;
 		}
 	}
+	else if (CI_PATTERN_FULL_ELECTRONIC == chLocalCiPattern)
+	{
+		if ((index + 6U) <= realRowLen)
+		{
+			pZCStr->wCbtcRelayBenDuanZcId = dquCiShortFromChar(pData);         /*CBTC本端继电器ID*/
+			pData += 2U;
+			index += 2U;
+			pZCStr->wCbtcRelayDuiDuanZcId = dquCiShortFromChar(pData);         /*CBTC对端继电器ID*/
+			pData += 2U;
+			index += 2U;
+			pZCStr->wCbtcCancelRelayId = dquCiShortFromChar(pData);            /*CBTC取消照查继电器ID*/
+			pData += 2U;
+			index += 2U;
+		}
+	}
 	else
 	{
 		; /*非法值*/
 	}
-
 	rtnvalue = 1U;
 	return rtnvalue;
 
@@ -965,37 +969,23 @@ UINT8 R_FloodGateStructFromChar(UINT8 * pDataAddr,Relay_FloodGateStruct* pFloodG
 UINT8 R_DCAgreeStructFromChar(UINT8 * pDataAddr,Relay_DCAgreeStruct * pDCAgreeStr)
 {
 	UINT8 * pData = pDataAddr;
-	UINT8 rtnvalue = 0U;
+	UINT8 rtnvalue = 1u;
-	UINT8 chLocalCiPattern = 0u; /*本CI模式*/
 
 	if ((NULL == pDataAddr) || (NULL == pDCAgreeStr))
 	{
-		 ;
+		rtnvalue = 0u;
 
 	}
-	else
+	if(1u == rtnvalue)
 	{
-		chLocalCiPattern = GetLocalCiPattern();
-
 		pDCAgreeStr->wRouteId = dquCiShortFromChar(pData);			/*进路ID*/
-		pData += 2U;
+		pData += 2u;
 		pDCAgreeStr->DCRouteDCQJId = dquCiShortFromChar(pData);		/*调车同意-调车请求继电器ID*/
-		pData += 2U;
+		pData += 2u;
-
-		if (CI_PATTERN_FULL_ELECTRONIC == chLocalCiPattern)
-		{
-			pDCAgreeStr->DCRouteDCQJTwoId = dquCiShortFromChar(pData);		/*调车同意-调车请求继电器2ID*/
-			pData += 2U;
-		}
-		else
-		{
-			pDCAgreeStr->DCRouteDCQJTwoId = 0U;
-		}
-
 		pDCAgreeStr->DCRouteTAJId = dquCiShortFromChar(pData);		/*调车同意-调车同意按钮继电器ID*/
-		pData += 2U;
+		pData += 2u;
 
-		rtnvalue = 1U;
+		rtnvalue = 1u;
 	}
 
 	return rtnvalue;

TSCP/src/APP/ciapp/QueryFiles/dquCIJDQStruInit.c

@@ -1464,101 +1464,77 @@ UINT8 InitRelay_FloodGateStru(CHAR* CIDataName)
 *********************************************/
 UINT8 InitRelay_DCAgreeStru(CHAR* CIDataName)
 {
-	UINT8 funcRtn = 0U;
+	UINT8 funcRtn = 0u;
 	Relay_DCAgreeStruct* pDCAgreeStr = NULL;   /*调车同意继电器变量*/
-	UINT8* pDataAddr = NULL;                                  /*数据地址*/
+	UINT8* pDataAddr;                                  /*数据地址*/
-	UINT32 DataSize = 0U;                                   /*数据大小（字节数）*/
+	UINT32 DataSize;                                   /*数据大小（字节数）*/
-	UINT16 j = 0U;
+	UINT16 j;
-	UINT8 rtnValue = 0U;
+	UINT8 rtnValue = 0u;
 	UINT8 localCiPattern = 0U;
-	UINT32 dwExcelId = 0u; /*excel id*/
-	UINT32 dwSheetId = 0u; /*sheet id*/
-	UINT32 dwRowLen = 0u; /*行长度*/
-	UINT16 wRealRowCount = 0U; /*行数*/
-
 	localCiPattern = GetLocalCiPattern();
 	
-	/*已经初始化了，不用老是调用执行过程*/
+	/*已经初始化了，不用老是调用执行过程 全电子不用初始化这张表*/
-	if(NULL != RelayData.pRelayDCAgreeStr)
+	if((NULL != RelayData.pRelayDCAgreeStr)||(CI_PATTERN_FULL_ELECTRONIC == localCiPattern))
 	{
-		rtnValue = 1U;
+		rtnValue = 1u;
 	}
 	else
 	{
-		if (CI_PATTERN_TRADITIONAL == localCiPattern)
-		{
-			dwExcelId = CI_DATA_TYPE;
-			dwSheetId = RELAY_DCAGREE_ID;
-		}
-		else
-		{
-			dwExcelId = OC_DATA_TYPE;
-			dwSheetId = OC_RELAY_DCAGREE_ID;
-		}
-
 		/*读取进路调车同意继电器数据表*/
-		funcRtn = dquGetConfigDataNew(CIDataName, dwExcelId, dwSheetId,&pDataAddr,&DataSize, &wRealRowCount);
+		funcRtn = dquGetConfigData(CIDataName,CI_DATA_TYPE, RELAY_DCAGREE_ID,&pDataAddr,&DataSize);
-		if(0U == funcRtn)
+		if(0u == funcRtn)
 		{
-			/*没有表初始化成功*/
+			/*函数调用失败*/
-			rtnValue = 1U;
+			rtnValue = 0u;
-			debug_infor_printf((const)"\nOC_DCAgree_RELAY_ID NO IN FS\n");
 		}
 		else
 		{
-			rtnValue = 1U;
 
-			if ((0U != DataSize) && (0U != wRealRowCount))
+			if(0u != (DataSize%LEN_RELAY_DCAGREE_ID))
-			{
+			{ /*求得个数不为整数，数据错误*/  
-				if (0U != (DataSize % wRealRowCount))
+				debug_infor_printf((const)"\nCI_RELAY_DATA,RELAY_DCAGREE len %d not equal to fs",LEN_RELAY_DCAGREE_ID);
-				{
+				DebugPrintAppError(ERROR_fs_columns_len_not_equal_to_ci_software,CI_DEVICE_TYPE_FS_TABLE,((UINT32)CI_DATA_TYPE<<8u)+RELAY_DCAGREE_ID,PRINT_ONCE);
-					/*求得个数不为整数，数据错误*/
+				rtnValue = 0u;
-					debug_infor_printf((const)"\nCI_RELAY_DATA,RELAY_DCAGREE len %d not equal to fs", (DataSize % wRealRowCount));
+			}
-					DebugPrintAppError(ERROR_fs_columns_len_not_equal_to_ci_software, CI_DEVICE_TYPE_FS_TABLE, ((UINT32)(dwExcelId << 8U)) + dwSheetId, PRINT_ONCE);
+			else
-					rtnValue = 0U;
+			{
+				RelayDataLen.RelayDCAgreeStrLen = (UINT16)(DataSize / LEN_RELAY_DCAGREE_ID);/*计算结构体个数*/
+
+				if(LEN_RELAY_DCAGREE_ID >DataSize )
+				{/*不足一个*/
+					RelayData.pRelayDCAgreeStr = (Relay_DCAgreeStruct *) MyNew ((UINT32)sizeof(Relay_DCAgreeStruct) );
+					rtnValue = 1u;
 				}
 				else
 				{
-					RelayDataLen.RelayDCAgreeStrLen = wRealRowCount;/*计算结构体个数*/
-					dwRowLen = DataSize / wRealRowCount;
 
 					/*动态申请空间*/
 					RelayData.pRelayDCAgreeStr = (Relay_DCAgreeStruct *) MyNew ((UINT32)(sizeof(Relay_DCAgreeStruct) * RelayDataLen.RelayDCAgreeStrLen));
 
 					if(NULL == RelayData.pRelayDCAgreeStr)
 					{/*动态申请空间失败*/
-						RelayDataLen.RelayDCAgreeStrLen = 0U;
+						RelayDataLen.RelayDCAgreeStrLen = 0u;
-						rtnValue = 0U;
+						rtnValue = 0u;
 					}
 					else
 					{
 						/*内存先设为无效*/
 						(void)memset(RelayData.pRelayDCAgreeStr, 0x00,sizeof(Relay_DCAgreeStruct) * RelayDataLen.RelayDCAgreeStrLen);
 						/*解析数据到 默认行车序列 结构体数组 */  
-
+						rtnValue = 1u;
 						for(j = 0u;j < RelayDataLen.RelayDCAgreeStrLen;j++)
-						{
-							if (1U == rtnValue)
 						{
 							pDCAgreeStr = RelayData.pRelayDCAgreeStr + j;
 
 							/*填充数据结构体*/
 							rtnValue &= R_DCAgreeStructFromChar(pDataAddr,pDCAgreeStr);
-								pDataAddr += dwRowLen;
+							pDataAddr += LEN_RELAY_DCAGREE_ID;
-							}
+
-							else
-							{
-								break;
 						}
 					}
 				}
 			}
 		}
-			else
-			{
-				;
-			}
-		}
 	}
 	return rtnValue;
 

TSCP/src/APP/ciapp/QueryFiles/dquCILSStru.h

@@ -331,8 +331,6 @@ typedef struct S_OverlapLockCondStruct
 	UINT16 szIncludeInvOppOverlapId[OVLP_LOCK_COND_MAX_INCL_INV_OPP_OVLP_NUM];		/*包含侵限敌对保护区段*/
 	UINT16 overlapLocProSwitchGroupID;												/*保护区段锁闭防护道岔组ID*/
 	UINT16 szIncludeFloodGateId[ROUTE_MAX_FLOOD_GATE_NUM];		                    /*包含防淹门ID*/
-	UINT16 wOverlapThisZhaoChaRelayId;                                              /*保护区段本端照查继电器ID*/
-	UINT16 wOverlapThatZhaoChaRelayId;                                              /*保护区段对端照查继电器ID*/
 } LS_OveralpLockCondStru;
 
 /*进路内多开道岔数据结构体*/

TSCP/src/APP/ciapp/QueryFiles/dquCILSStruFrmChar.c

@@ -733,14 +733,6 @@ UINT8 LS_OverlapLockCondStruFromChar(UINT8 * pDataAddr, LS_OveralpLockCondStru *
 			pData += LS_DATA_DUAL_BYTE_ELEM_LEN;
 		}
 
-		/*保护区段本端照查继电器ID*/
-		pOverlapLockCondStru->wOverlapThisZhaoChaRelayId = dquCiShortFromChar(pData);
-		pData += LS_DATA_DUAL_BYTE_ELEM_LEN;
-
-		/*保护区段对端照查继电器ID*/
-		pOverlapLockCondStru->wOverlapThatZhaoChaRelayId = dquCiShortFromChar(pData);
-		pData += LS_DATA_DUAL_BYTE_ELEM_LEN;
-
 		rtnvalue = 1u;
 	}
 	return rtnvalue;

TSCP/src/APP/ciapp/QueryFiles/dquCILSStruInit.c

@@ -1547,8 +1547,6 @@ UINT8 InitLS_OverlapLockCondStru(CHAR *LSDataName)
 	LS_OveralpLockCondStru* pTempLSProtSecLockCondStru = NULL;   /*临时长进路变量*/
 	UINT8* pDataAddr = NULL;         /*数据地址*/
 	UINT32 DataSize = 0u;          /*数据大小（字节数）*/
-	UINT32 rowLen = 0u;				/*读到的行数*/
-	UINT16 realRowLen = 0U;			/*实际表一行的长度*/
 	UINT16 j = 0u;
 	UINT8 rtnValue = 0u;
 	
@@ -1560,7 +1558,7 @@ UINT8 InitLS_OverlapLockCondStru(CHAR *LSDataName)
 	else
 	{
     	/*读取保护区段锁闭条件数据*/
-	   funcRtn = dquGetConfigDataNew(LSDataName, LS_DATA_TYPE, OVERLAP_LOCK_COND_DATA_ID, &pDataAddr, &DataSize, &rowLen);
+	   funcRtn = dquGetConfigData(LSDataName, LS_DATA_TYPE, OVERLAP_LOCK_COND_DATA_ID, &pDataAddr, &DataSize);
 
 	   if(funcRtn == 0u)
 	   {
@@ -1570,9 +1568,7 @@ UINT8 InitLS_OverlapLockCondStru(CHAR *LSDataName)
 	   else
 	   {
 		   /*求得个数*/
-		   if ((0U != DataSize) && (0U != rowLen))
+		   if((DataSize % OVERLAP_LOCK_COND_DATA_LEN) != 0u)
-		   {
-			   if (0U != DataSize % rowLen)
 		   {   
 			   debug_infor_printf((const)"\nCI_LS_DATA,OVERLAP_LOCK_COND len %d not equal to fs",PHYSICAL_INTRU_DATA_LEN);
 			   DebugPrintAppError(ERROR_fs_columns_len_not_equal_to_ci_software,CI_DEVICE_TYPE_FS_TABLE,(LS_DATA_TYPE<<8)+OVERLAP_LOCK_COND_DATA_ID,PRINT_ONCE);
@@ -1580,12 +1576,14 @@ UINT8 InitLS_OverlapLockCondStru(CHAR *LSDataName)
 		   }
 		   else
 		   {
-				   realRowLen = (UINT16)(DataSize / rowLen);
-				   LSDataLen.LSOverlapLockCondStruLen = (UINT16)rowLen;
 
-				   if (DataSize < realRowLen)
+				/*获取保护区段锁闭条件表条目数量*/
+				LSDataLen.LSOverlapLockCondStruLen = (UINT16)(DataSize/OVERLAP_LOCK_COND_DATA_LEN);
+
+				if(DataSize < OVERLAP_LOCK_COND_DATA_LEN)
 				{
-					   rtnValue = 0U;
+					LSData.pLSOverlapLockCondStru = (LS_OveralpLockCondStru *) MyNew ((UINT32)sizeof(LS_OveralpLockCondStru));
+					rtnValue = 1u;
 				}
 				else
 				{
@@ -1613,19 +1611,13 @@ UINT8 InitLS_OverlapLockCondStru(CHAR *LSDataName)
 							/*填充数据结构体*/
 							rtnValue &=LS_OverlapLockCondStruFromChar(pDataAddr, pTempLSProtSecLockCondStru);
 
-							   pDataAddr += realRowLen;
+							pDataAddr += OVERLAP_LOCK_COND_DATA_LEN;
 						}
 
 					}
 				}
 			}
 		}
-		   else
-		   {
-			   rtnValue = 1U;
-		   }
-		  
-		}
 	}
 
 	return rtnValue;
@@ -2043,7 +2035,7 @@ UINT8 InitLS_LogSecIntruStru_Each(CHAR* LSDataName)
 				if (0u != (DataSize % realRowCount))
 				{
 					debug_infor_printf((const)"\nTIOC_LS_DATA,nLGC_EACHOTHER_INTRU_TABLE len %d %d not equal to fs\n", DataSize, realRowCount);
-					DebugPrintAppError(ERROR_fs_columns_len_not_equal_to_ci_software, CI_DEVICE_TYPE_FS_TABLE, (LS_DATA_TYPE << 8) + LOGIC_SEC_EACHINTRU_DATA_ID, PRINT_ONCE);
+					DebugPrintAppError(ERROR_fs_columns_len_not_equal_to_ci_software, CI_DEVICE_TYPE_FS_TABLE, (LS_DATA_TYPE << 8) + GROUP_AUTO_ROUTE_DATA_ID, PRINT_ONCE);
 					rtnValue = 0u;
 				}
 				else
@@ -2080,7 +2072,7 @@ UINT8 InitLS_LogSecIntruStru_Each(CHAR* LSDataName)
 			}
 			else
 			{
-				debug_infor_printf((const)"\nLGC_EACHOTHER_INTRU_TABLE  DataSize %d  realRowCount %d\n ", DataSize, realRowCount);
+				debug_infor_printf((const)"\nGROUP_AUTO_ROUTE_DATA_ERR  DataSize %d  realRowCount %d\n ", DataSize, realRowCount);
 			}
 
 		}

TSCP/src/APP/ciapp/QueryFiles/dquCIPZStru.h

@@ -59,7 +59,5 @@
 #define CI_SYSTEM_SIGWITHFUSHISIG_ID  ((UINT8)0x0b)	/*信号机与复示信号机关系表*/
 #define CI_SYSTEM_SIGWITHFUSHISIG_LEN ((UINT8)12)   /*信号机与复示信号机关系表长度*/
 
-#define CI_SYSTEM_VERGE_KILL_ID			((UINT8)0x0F)  /*计轴器对应临线的公里标转换表*/
-
 #endif
 

TSCP/src/APP/ciapp/QueryFiles/dquMaskInit.h

@@ -41,7 +41,7 @@
 #define CI_ZC_SIGNAL_MASK_LEN ((UINT32)16)      /*CI-ZC信号机码位字节长度--1行长度*/
 
 #define CI_ZC_PSD_MASK_ID  ((UINT32)3)       /*CI-ZC屏蔽门码位*/
-#define CI_ZC_PSD_MASK_LEN ((UINT32)8)      /*CI-ZC屏蔽门码位字节长度--1行长度*/
+#define CI_ZC_PSD_MASK_LEN ((UINT32)6)      /*CI-ZC屏蔽门码位字节长度--1行长度*/
 
 #define CI_ZC_ESB_MASK_ID  ((UINT32)4)       /*CI-ZC紧急停车按钮码位*/
 #define CI_ZC_ESB_MASK_LEN ((UINT32)6)      /*CI-ZC屏紧急停车按钮码位字节长度--1行长度*/
@@ -263,21 +263,6 @@ UINT8  MaskCfgDtStruFrmCIZCSignalMask(UINT8 * FSDataName);
 *********************************************/
 UINT8  MaskCfgDtStruFrmZCCISignalMask(UINT8 * FSDataName);
 
-/* 20150531-针对数据结构28.0.0.14实现 */
-/*********************************************
-*函数功能：CI-ZC信号机码位
-*参数说明：FSDataName件指针
-*返回值：0，失败；1，成功
-*********************************************/
-UINT8  MaskCfgDtStruFrmCIZCSignalMask2(UINT8 * FSDataName);
-
-/* 20150531-针对数据结构28.0.0.14实现 */
-/*********************************************
-*函数功能：ZC-CI信号机码位
-*参数说明：FSDataName件指针
-*返回值：0，失败；1，成功
-*********************************************/
-UINT8  MaskCfgDtStruFrmZCCISignalMask2(UINT8 * FSDataName);
 
 /*********************************************
 *函数功能：CI-ZC屏蔽门码位
@@ -422,31 +407,4 @@ UINT8 MaskInit(UINT8 * FSDataName);
 *********************************************/
 UINT8 MaskCfgStruFrmCILEUSignalMask(UINT8 * FSDataName);
 
-/*********************************************
-*函数功能：CI到ATS码位表解析 适配28.0.0.14
-*参数说明：FSDataName件指针
-*返回值：0，失败；1，成功
-*********************************************/
-UINT8  MaskCfgDtStruFrmCIATSSwitchMask2(UINT8 * FSDataName);
-
-/*********************************************
-*函数功能：CI-ATS物理区段码位  适配28.0.0.14数据结构
-*参数说明：FSDataName件指针
-*返回值：0，失败；1，成功
-*********************************************/
-UINT8  MaskCfgDtStruFrmCIATSPhySecMask2(UINT8 * FSDataName);
-
-/*********************************************
-*函数功能：ZC-CI计轴区段码位-面向数据结构28.0.0.14
-*参数说明：FSName文件指针
-*返回值：0，失败；1，成功
-*********************************************/
-UINT8  MaskCfgStruFrmZCCIAxleSgmtMask2(UINT8 * FSDataName);
-/*********************************************
-*函数功能：CI-ZC计轴区段码位 （物理区段）-面向数据结构28.0.0.14
-*参数说明：FSName文件指针
-*返回值：0，失败；1，成功
-*********************************************/
-UINT8  MaskCfgStruFrmCIZCAxleSgmtMask2(UINT8 * FSDataName);
-
 #endif

TSCP/src/APP/ciapp/QueryFiles/dqucijdqstru.h

@@ -191,9 +191,6 @@
 #define OC_RELAY_REVERSE_CUT_ID	((UINT8)30)
 #define OC_LEN_REVERSE_CUT		((UINT8)2)
 
-/*调车同意继电器表ID*/
-#define OC_RELAY_DCAGREE_ID  ((UINT8)36)
-
 /*紧急停车按钮继电器结构体*/
 typedef struct S_Relay_EmegencyStopStruct
 {
@@ -244,7 +241,6 @@ typedef struct S_Relay_ScreenStruct
 	UINT16 wPcbBsdRelayId;  /*再关门按钮指示灯继电器*/
 	UINT16 wVideoQkLight1RelayId;                                             /*清客按钮箱视频清客指示灯1（绿）继电器*/
 	UINT16 wVideoQkLight2RelayId;                                             /*清客按钮箱视频清客指示灯2（红）继电器*/
-	UINT8 chControlType;		/*屏蔽门控制类型*/
 } Relay_ScreenStruct;
 
 /*物理区段继电器结构体*/
@@ -343,6 +339,9 @@ typedef struct S_Relay_ZhaoChaStruct
 	UINT16 wCancelRelayIdOnRelayInterface;			                                  /*继电接口下取消照查继电器ID */
 	UINT16 wRelayBenDuanZcIdOnRelayInterface;                       /*继电接口本端照查继电器ID*/     
 	UINT16 wRelayDuiDuanZcIdOnRelayInterface;                       /*继电接口对端照查继电器ID*/
+	UINT16 wCbtcRelayBenDuanZcId;                                         /*CBTC本端照查继电器ID*/
+	UINT16 wCbtcRelayDuiDuanZcId;                                         /*CBTC对端照查继电器ID*/
+	UINT16 wCbtcCancelRelayId;			                                  /*CBTC-取消照查继电器ID */
 } Relay_ZhaoChaStruct;
 
 /*表示报警灯继电器结构体*/
@@ -449,7 +448,6 @@ typedef struct S_Relay_DCAgreeStruct
 {
 	UINT16	wRouteId;	/*进路ID*/
 	UINT16	DCRouteDCQJId;/*调车进路调车请求继电器ID*/
-	UINT16	DCRouteDCQJTwoId;/*调车进路调车请求2继电器ID*/
 	UINT16	DCRouteTAJId;/*调车进路调车同意按钮继电器ID*/
 }Relay_DCAgreeStruct;
 

TSCP/src/APP/ciapp/Relay/RelayConfigDataManage.c

@@ -1658,53 +1658,3 @@ UINT16 GetRelayBelongOCId(const UINT16 relayId)
 	}
 	return retVal;
 }
-
-/*
-* 功能描述：设置指定ID继电器板卡类型
-* 参数说明：const UINT16 relayId 继电器ID
-*           const UINT8 cBoardType 板卡类型
-* 返 回 值：无
-* Created By LQ 2025.07.03
-*/
-void SetRelayBoardType(const UINT16 relayId, const UINT8 cBoardType)
-{
-	UINT16 bufIndex = 0u;  /*数组下标*/
-
-	bufIndex = GetRelayConfigBufIndex(relayId);  /*获取继电器数组下标*/
-
-	if ((bufIndex < RELAY_SUM_MAX) && ((RELAY_DO_BOARD == cBoardType) || (RELAY_DO_RELAY_BOARD == cBoardType) || (RELAY_SO_BOARD == cBoardType) 
-		|| (RELAY_THIRTY_SIX_DI_BOARD == cBoardType) || (RELAY_THIRTY_TWO_DI_BOARD == cBoardType) || (RELAY_SI_BOARD == cBoardType)))
-	{
-		RelayConfigDataStru[bufIndex].BoardType = cBoardType;
-	}
-	else
-	{
-		/*不处理*/
-	}
-}
-
-/*
-* 功能描述：获取指定ID继电器板卡类型
-* 参数说明：const UINT16 relayId 继电器ID
-* 返 回 值：0: 获取数据失败
-*			>0: 继电器板卡类型
-* Created By LQ 2025.07.03
-*/
-UINT8 GetRelayBoardType(const UINT16 relayId)
-{
-	UINT16 bufIndex = 0u;  /*数组下标*/
-	UINT8 retVal = CI_ERROR;
-
-	bufIndex = GetRelayConfigBufIndex(relayId);  /*获取继电器数组下标*/
-
-	if (bufIndex < RELAY_SUM_MAX)
-	{
-		retVal = RelayConfigDataStru[bufIndex].BoardType;
-	}
-	else
-	{
-		retVal = CI_ERROR;
-	}
-
-	return retVal;
-}

TSCP/src/APP/ciapp/Relay/RelayConfigDataManage.h

@@ -54,7 +54,6 @@ typedef struct S_RelayConfigDataStruct
 	UINT8 VirtualAttribute;			/*虚拟继电器属性*/
 	UINT16 LockExceptPhySecNum;		/*照查继电器关联的故障锁闭区段ID数量*/
 	UINT16 LockExceptPhySecIdBuf[MAX_LOCK_EXCEPT_SECTION_NUM];	/*照查继电器关联的故障锁闭区段ID数组*/
-	UINT8 BoardType;  /*所属板卡类型(仅初始化本控区继电器)*/
 } RelayConfigDataStruct;
 
 /*照查继电器联锁条件检查类型数据结构体*/
@@ -480,24 +479,6 @@ UINT16 GetOcConnetDataDevNum(void);
 */
 UINT16 GetRelayBelongOCId(const UINT16 relayId);
 
-/*
-* 功能描述：设置指定ID继电器板卡类型
-* 参数说明：const UINT16 relayId 继电器ID
-*           const UINT8 cBoardType 板卡类型
-* 返 回 值：无
-* Created By LQ 2025.07.03
-*/
-void SetRelayBoardType(const UINT16 relayId, const UINT8 cBoardType);
-
-/*
-* 功能描述：获取指定ID继电器板卡类型
-* 参数说明：const UINT16 relayId 继电器ID
-* 返 回 值：0: 获取数据失败
-*			>0: 继电器板卡类型
-* Created By LQ 2025.07.03
-*/
-UINT8 GetRelayBoardType(const UINT16 relayId);
-
 #ifdef __cplusplus
 }
 #endif

TSCP/src/APP/ciapp/Relay/RelayDataManage.c

@@ -16,9 +16,6 @@
 
 RelayDataStruct RelayDataStru[RELAY_SUM_MAX];                      /*定义继电器配置数据结构体数组*/
 
-IODiffDataStruct IODiffDataStru[OC_SUM_MAX];		/*定义IO双系采集不一致信息*/
-UINT8 gDiffDataOcNum = 0u;							/*定义IO双系采集不一致所对应的OC数量*/
-
 /*
 * 功能描述： 获取指定ID继电器数据
 * 参数说明： 
@@ -920,14 +917,3 @@ UINT8 GetRelayBCollBoardState(const UINT16 wRelayId)
 
 	return retVal;
 }
-
-/*
-* 功能描述： 获取IO双系采集不一致数据
-* 参数说明：
-* 返回值  ：
-			RelayDataStruct*
-*/
-IODiffDataStruct* GetIODiffData(void)
-{
-	return IODiffDataStru;
-}

TSCP/src/APP/ciapp/Relay/RelayDataManage.h

@@ -47,18 +47,6 @@ typedef struct S_RelayDataStruct
 
 extern RelayDataStruct RelayDataStru[RELAY_SUM_MAX];                      /*定义继电器配置数据结构体数组*/
 
-typedef struct S_IODiffDataStruct
-{
-	UINT8 OcId;	/*OC ID*/
-	UINT8 DiffPointNum;	/*不一致的点位数量*/
-	UINT8 LocalBoardAdd[IO_COLL_DIFF_MAX];/*点位对应的板卡地址*/
-	UINT8 OtherBoardAdd[IO_COLL_DIFF_MAX];/*对系板卡地址*/
-	UINT8 TheDiffPoint[IO_COLL_DIFF_MAX];/*不一致点位*/
-}IODiffDataStruct;
-
-extern IODiffDataStruct IODiffDataStru[OC_SUM_MAX];		/*定义IO双系采集不一致信息*/
-extern UINT8 gDiffDataOcNum;							/*定义IO双系采集不一致所对应的OC数量*/
-
 /*
 * 功能描述： 获取指定ID继电器数据
 * 参数说明： 
@@ -300,14 +288,6 @@ void SetRelayBCollBoardState(const UINT16 wRelayId, const UINT8 cBoardState);
 */
 UINT8 GetRelayBCollBoardState(const UINT16 wRelayId);
 
-/*
-* 功能描述： 获取IO双系采集不一致数据
-* 参数说明：
-* 返回值  ：
-			RelayDataStruct*
-*/
-IODiffDataStruct* GetIODiffData(void);
-
 #ifdef __cplusplus
 }
 #endif

TSCP/src/APP/ciapp/Relay/RelayDefine.h

@@ -32,9 +32,6 @@
 #define BOARD_COLL_DATA_LEN            ((UINT16)4)    /*定义采集板上采集数据字节数*/
 #define BOARD_DRV_DATA_LEN             ((UINT16)2)    /*定义驱动板上驱动数据字节数*/
 
-#define IO_COLL_DIFF_MAX			   ((UINT8)254)	  /*定义IO双系采集比较不一致点位的最大值*/
-#define POINTTOLERATE_CYCNUM		   ((UINT8)7)	  /*IO双系采集不一致最大容忍周期数*/
-
 /************************OC*************************/
 #define OC_BOARD_SUM_MAX						((UINT8)44)  /*一个OC对应最大44块板*/
 #define OC_COLL_BOARD_POS_NUM					((UINT16)40)   /*定义一块OC电路板采集点数目最大值*/
@@ -109,15 +106,5 @@
 #define RELAY_BOARD_FAULT_NO		   ((UINT8)0x55)	/*板卡状态未故障*/
 #define RELAY_BOARD_FAULT_YES		   ((UINT8)0xaa)	/*板卡状态故障*/
 
-/*继电器板卡类型*/
-#define RELAY_DO_BOARD		           ((UINT8)0x5a)	/*安全输出板*/
-#define RELAY_DO_RELAY_BOARD		   ((UINT8)0xc8)	/*安全输出继电器板*/
-#define RELAY_SO_BOARD	               ((UINT8)0x3c)	/*零散输出板*/
-#define RELAY_THIRTY_SIX_DI_BOARD	   ((UINT8)0xcc)	/*36路安全输入板*/
-#define RELAY_THIRTY_TWO_DI_BOARD	   ((UINT8)0x5c)	/*32路安全输入板*/
-#define RELAY_SI_BOARD	               ((UINT8)0xc3)	/*零散输入板*/
-
-
-
 #endif
 

TSCP/src/APP/ciapp/RemoteRM/RRMDataPrepare.c

@@ -799,8 +799,7 @@ void rrm_PrepareACLockStatAndDir(UINT16 ACID,UINT8 flag,OUT UINT8* pLockStat,OUT
 	LockDir = ConvertDirectionToLogic(tmpDir);
 
 	if (((0u == RLockBelongRouteId) && (0u == PLockBelongRouteId)) || (DIR_INVALID == LockDir) 
-		|| ((PHYSICAL_SECTION_LOCK_NORMAL != LockStatus) && (PHYSICAL_SECTION_LOCK_PROTECT != LockStatus)
+		|| ((PHYSICAL_SECTION_LOCK_NORMAL != LockStatus) && (PHYSICAL_SECTION_LOCK_PROTECT != LockStatus)))
-			&& (PHYSICAL_SECTION_LOCK_DELAY != LockStatus)))
 	{
 		(*pLockStat) = SEC_LOCK_ERROR;
 		(*pLockDir) = 0u;