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

Compare commits

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

12 Commits
stable/9.4.1分支 ... 2b9c6c8c83

Author SHA1 Message Date
lh 2b9c6c8c83 1.4线模式和仲裁模式的通用接口封装 
2.离线系拉低主地/备地为离线地
3.修复仲裁IP配置错误
 2026-08-27 14:46:23 +08:00
lh ca6366a59b 组播接收后做2取交互，组播接收的数据不作用于通信状态判断 2026-08-25 20:05:05 +08:00
lh f70644f743 等待时间使用宏定义 2026-08-24 17:14:17 +08:00
lh 2bd874bd40 1.增加阶段时间打印 
2.修改超时接收逻辑
3.增加未知地->离线地逻辑
 2026-08-24 16:25:16 +08:00
lh 7dd0b7aa68 一主三备完成 2026-08-21 19:43:34 +08:00
lh e0b03e011f 通信bug修复 2026-08-21 17:22:07 +08:00
lh 18003863ae bug修改中 2026-08-21 16:15:59 +08:00
lh 8e7cd0ea12 同时上电，一主三备正常，待遍历异常场景 2026-08-21 15:05:48 +08:00
lh eb5bdc8177 状态转换开发中 2026-08-20 18:54:04 +08:00
lh c7c357249a 仲裁版本开发，第一次提交，剩余状态转换功能 2026-08-19 19:47:55 +08:00
lh 6f48be84e9 9.3.1首版首轮基线版本 2026-08-13 18:58:25 +08:00
lh 65594a600d [9.3.1] 9.3.1首版首轮代码，基线版本 2026-06-30 11:09:21 +08:00
213 changed files with 14003 additions and 23136 deletions
Expand all files Collapse all files
TSCP/Makefile
+5 -2
View File
@@ -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
+231 -35
View File
@@ -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_CpuUsageGet_Enable = 0x55,/**< 获取cpu使用率功能开关 */
.M_OutnetRaw_Enable = 0x55, /**< 外网透传通信功能开关 */
.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_INTE_PRODUCT >> 2U;
appVersBuffer[ii++] = (VER_INTE_PRODUCT << 6U) + (VER_INTE_EXE & (UINT8)0x3F);
appVersBuffer[ii++] = VER_INTE_TIME;
appVersBuffer[ii++] = VER_SOFT_PRODUCT;
appVersBuffer[ii++] = VER_SOFT_MODUAL_APP >> 2U;
appVersBuffer[ii++] = (VER_SOFT_MODUAL_APP << 6U) + (VER_SOFT_MIANVERSION & (UINT8)0x3F);
appVersBuffer[ii++] = VER_SOFT_SUBVERSION;
/*设置平台调用获取外网信息函数*/
MSCP_SetSrcId(SetOutNetPara);
/*设置内网参数*/
@@ -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);
MSCP_SetFollowData(gFollowData, gFollowDataLen);
//gFollowDataLen = GetCiAppData(gFollowData);
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), \
(const void*)gTransmitObjTypeId, objLen * sizeof(UINT16));
CommonMemCpy(&pOutBuf[tempLen], 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
+3 -3
View File
@@ -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
+1 -1
View File
@@ -30,6 +30,6 @@
#define VER_INTE_PROJECT 220 /*项目编号*/
#define VER_INTE_PRODUCT 40 /*产品编号*/
#define VER_INTE_EXE 1 /*可执行编号*/
#define VER_INTE_TIME 101 /*集成次数编号*/
#define VER_INTE_TIME 77 /*集成次数编号*/
#endif/*endif of #define _CI_INTEGRATE_CONFIG_H*/
TSCP/src/APP/ciapp/2oo2/2oo2DataTransferManage.c
+6 -201
View File
@@ -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));
curIndex = curIndex + (UINT32)(sizeof(AreaSnowInfoStruct) * 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;
(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(UINT32) * LOCAL_AREA_SNOW_SUM_MAX);
#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));
curIndex = curIndex + (UINT32)(sizeof(AreaSnowInfoStruct) * 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);
(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(UINT32) * LOCAL_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.c
+349 -349
View File
File diff suppressed because it is too large Load Diff
TSCP/src/APP/ciapp/2oo2/2oo2InterfaceDataManage.h
+1 -1
View File
@@ -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
+4 -10
View File
@@ -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
+1 -7
View File
@@ -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
-1
View File
@@ -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
+118 -246
View File
@@ -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,44 +103,24 @@ 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
else if (((TYPE_CT_ENVELOPE == pTempEnvelope->envelopeType) || (TYPE_UCT_ENVELOPE == pTempEnvelope->envelopeType)) &&
(FLAG_SET == funRtn) && (0u == pTempEnvelope->tailTrainID))
{
chNoSleepCheck = CI_SUCCESS;
for (ii = 0U; ii < pTempEnvelope->trianCnt; ii++)
{
cSleepState = GetTrainSleepState(pTempEnvelope->trainID[ii]);
if (TRAIN_SLEEP_YES == cSleepState)
{
chNoSleepCheck = CI_ERROR;
break;
}
}
if (CI_ERROR == chNoSleepCheck)
{
/*相邻计轴存在休眠车*/
ret = AAM_SLEEP_OCC;
}
else if (((TYPE_CT_ENVELOPE == pTempEnvelope->envelopeType) || (TYPE_UCT_ENVELOPE == pTempEnvelope->envelopeType)) &&
(FLAG_SET == funRtn) && (0u == pTempEnvelope->tailTrainID))
{
/** 好车远离 */
ret = AAM_GOOD_FAR_AWAY;
/** 好车远离 */
ret = AAM_GOOD_FAR_AWAY;
}
else if (((TYPE_CT_ENVELOPE == pTempEnvelope->envelopeType) || (TYPE_UCT_ENVELOPE == pTempEnvelope->envelopeType)) &&
(FLAG_UNSET == funRtn) && (0u == pTempEnvelope->headTrainID))
{
/** 好车接近 */
ret = AAM_GOOD_NEAR;
}
else
{
/** 坏车接近 */
ret = AAM_BAD_NEAR;
}
}
else if (((TYPE_CT_ENVELOPE == pTempEnvelope->envelopeType) || (TYPE_UCT_ENVELOPE == pTempEnvelope->envelopeType)) &&
(FLAG_UNSET == funRtn) && (0u == pTempEnvelope->headTrainID))
{
/** 好车接近 */
ret = AAM_GOOD_NEAR;
}
else
{
/** 坏车接近 */
ret = AAM_BAD_NEAR;
}
}
}
}
@@ -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;
UINT16 acSameID[AC_MAXCNT_IN_SWITCH] = { 0U };
UINT8 acConvertCnt = 0U;
UINT16 acConvertID[AC_MAXCNT_IN_SWITCH] = { 0U };
UINT32 errorCode = 0U;
UINT8 acSameCnt = 0u;
UINT16 acSameID[AC_MAXCNT_IN_SWITCH] = { 0u };
UINT8 acConvertCnt = 0u;
UINT16 acConvertID[AC_MAXCNT_IN_SWITCH] = { 0u };
UINT32 errorCode = 0u;
UINT8 sameTrainType = AAM_BAD_NEAR;
UINT8 convertTrainType = AAM_BAD_NEAR;
UINT8 tmpRedunTime = 0U;
UINT8 tmppassTrainType = 0U;
UINT8 tmpRedunTime = 0u;
UINT8 tmppassTrainType = 0u;
UINT8 tmpACStatus = AAM_STATUS_OCC;
UINT8 maxRedunTimes = 0u;
UINT8 chSwitch = 0U;
UINT8 chSwitch = 0u;
UINT32 dwArbCheckDistance = 0U; /*RC16.0： 系统配置ARB区段向外检查距离*/
UINT8 chRedunArbFlag = REDUN_OVER_ARB_NO; /*判断冗余计时结束后可否ARB标志*/
UINT8 dwCiAndAxleTransBadEnsureCnt = 0U; /*判断与计轴通信中断周期数*/
UINT32 dwCurAxleOccStartCycNum = 0U; /*本计轴区段占用起始周期*/
UINT8 ii = 0U;
UINT32 dwNearAxleOccStartCycNum = 0U; /*相邻计轴区段占用起始周期*/
UINT8 cAcRelEnvelopeCnt = 0U;
EnvelopeStruct strEnvelopeInfo[SECTION_REL_ENVELOPE_SUM_MAX] = { 0U };
UINT8 cOccCheckFlag = CI_ERROR;
UINT16 wCurRelPhySecId = 0U;
UINT16 wNearRelPhySecId = 0U;
UINT8 cAxisCommBadArbFlag = AAM_COMM_BAD_ARB_NO;
UINT8 chPhyTrainCheck = CI_SUCCESS;
UINT8 cAcCbtcAttr = 0U; /*计轴区段CBTC区域属性*/
chSwitch = aam_PrepareArbSwitch();
if (CI_SUCCESS == chSwitch)
@@ -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))
{
@@ -449,14 +409,90 @@ static UINT8 aam_AxisErrorJudge(UINT16 acID,UINT16 acIndex)
AAM_LOG(AAM_LOG_FATAL, "info:AC%d keep ARB Fail, NearByTrainCheck:%d.\n", acID, chNearbyCheck);
}
else
{
/*ARB计轴区段同向相邻计轴区段连续占用*/
funRtn = aam_ArbContinuousOccCheck(acID, acSameCnt, acSameID);
{
cOccCheckFlag = CI_SUCCESS;
dwCiAndAxleTransBadEnsureCnt = GetCiAndAxleTransBadEnsureCnt(); /*获取判断与计轴通信中断超时周期数*/
wCurRelPhySecId = GetAxisSecRelativePhySecId(acID);
if (0U != wCurRelPhySecId)
{
dwCurAxleOccStartCycNum = GetSecColOccupyStartCycNum(wCurRelPhySecId);
for (ii = 0U; ii < acSameCnt; ii++)
{
wNearRelPhySecId = GetAxisSecRelativePhySecId(acSameID[ii]);
if (0U != wNearRelPhySecId)
{
cAcRelEnvelopeCnt = elm_GetEnvelopeInAC(acSameID[ii], strEnvelopeInfo);
dwNearAxleOccStartCycNum = GetSecColOccupyStartCycNum(wNearRelPhySecId);
if (((0U == cAcRelEnvelopeCnt) || (SECTION_REL_ENVELOPE_SUM_MAX == cAcRelEnvelopeCnt))
&& ((dwCurAxleOccStartCycNum + dwCiAndAxleTransBadEnsureCnt) < dwNearAxleOccStartCycNum))
{
cOccCheckFlag = CI_ERROR; /*相邻计轴区段无包络且占用起始时间超过了“与计轴通信中断超时判断时间”*/
}
else
{
/*相邻计轴区段占用起始周期未超过“与计轴通信中断超时判断时间”，继续检查*/
}
}
else
{
cOccCheckFlag = CI_ERROR;
}
/*ARB计轴区段反向相邻计轴区段连续占用*/
funRtn &= aam_ArbContinuousOccCheck(acID, acConvertCnt, acConvertID);
if (CI_ERROR == cOccCheckFlag)
{
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 */
@@ -2020,166 +2054,4 @@ UINT8 aam_GetAxisStatusAPI(UINT16 ACID)
acIndex = aam_PrepareACIndex(ACID);
reVal = aam_GetAxisStatus(acIndex);
return reVal;
}
/**
* 函数功能：检查计轴所在物理区段均无故障车
* 输入参数：UINT16 ACID 计轴区段id
* 返回值：CI_SUCCESS 无故障车
* CI_ERROR 存在故障车
* Create By fan 2025.06 18
*/
UINT8 aam_CheckPhyTrain(UINT16 ACID)
{
UINT8 reVal = CI_ERROR;
UINT16 wPhySecId = 0U; /*计轴所属物理区段*/
UINT8 phyAcNum = 0u; /*物理区段关联计轴数*/
UINT16* pACBuff = NULL;
UINT16 wAxisSecId = 0U; /*计轴区段id*/
UINT8 linkNum = 0U; /*ilnk数量*/
UINT16* pLinkBuf = NULL; /*link数组*/
UINT8 jj = 0U;
UINT8 ii = 0U;
UINT8 k = 0U;
TRAIN_SEQUANCE_s linkInctrainList[SIZE_MAX_TRAINOFAC] = { 0u }; /*link上的列车序列*/
UINT8 cLinkIncTrainSum = 0u; /*link列车数量*/
wPhySecId = aam_PrepareACBelongPhyid(ACID);
phyAcNum = GetPAxisSectionSum(wPhySecId);
pACBuff = GetPAxisSectionIdBuf(wPhySecId);
if ((0U != phyAcNum) && (NULL != pACBuff))
{
reVal = CI_SUCCESS;
for (ii = 0; ii < phyAcNum; ii++)
{
/*检查计轴上link有隐藏车*/
wAxisSecId = pACBuff[ii];
linkNum = GetAxisLinkSum(wAxisSecId);
pLinkBuf = GetAxisLinkIdBuf(wAxisSecId);
if ((0U != linkNum) && (NULL != pLinkBuf))
{
for (jj = 0; jj < linkNum; jj++)
{
cLinkIncTrainSum = as_GetLinkTrainList(pLinkBuf[jj], linkInctrainList, SIZE_MAX_TRAINOFAC);
for (k = 0U; k < cLinkIncTrainSum; k++)
{
if (NAME_FAILUREAREA != linkInctrainList[k].u16TrainID)
{
; /*继续*/
}
else
{
reVal = CI_ERROR; /*存在故障车，停止检查。返回失败*/
break;
}
}
if (CI_ERROR == reVal)
{
break;
}
}
}
else
{
/*获取失败 */
reVal = CI_ERROR;
}
if (CI_ERROR == reVal)
{
break;
}
}
}
else
{
reVal = CI_ERROR;
}
return reVal;
}
/*
* 函数功能：ARB区段连续占用检查
* 输入参数：UINT16 wAcId 计轴区段ID
* UINT8 cNearAcNum 相邻计轴区段数量
* UINT16 pNearAcId[AC_MAXCNT_IN_SWITCH] 相邻计轴区段ID
* 返 回 值：CI_SUCCESS 1 成功
* CI_ERROR 0 失败
* Created By LQ 2025.08.07
*/
UINT8 aam_ArbContinuousOccCheck(UINT16 wAcId, UINT8 cNearAcNum, UINT16 pNearAcId[AC_MAXCNT_IN_SWITCH])
{
UINT8 cRetVal = CI_ERROR;
UINT16 wBufIndex = 0U;
UINT16 wCurRelPhySecId = 0U; /*本计轴区段所属物理区段ID*/
UINT8 dwCiAndAxleTransBadEnsureCnt = 0U; /*判断与计轴通信中断周期数*/
UINT32 dwCurAxleOccStartCycNum = 0U; /*本计轴区段占用起始周期*/
UINT8 ii = 0U;
UINT16 wNearRelPhySecId = 0U; /*相邻计轴区段所属物理区段ID*/
UINT8 cAcRelEnvelopeCnt = 0U;
EnvelopeStruct strEnvelopeInfo[SECTION_REL_ENVELOPE_SUM_MAX] = { 0U };
UINT32 dwNearAxleOccStartCycNum = 0U; /*相邻计轴区段占用起始周期*/
UINT8 cRcId = 0U;
UINT8 cFunRtn = 0U;
UINT16 wNearAcIndex = 0U;
wBufIndex = GetAxisSecConfigBufIndex(wAcId); /*获取区段数组下标*/
if ((AXIS_SECTION_SUM_MAX > wBufIndex) && (AC_MAXCNT_IN_SWITCH > cNearAcNum) && (NULL != pNearAcId))
{
wCurRelPhySecId = GetAxisSecRelativePhySecId(wAcId);
if (0U != wCurRelPhySecId)
{
cRetVal = CI_SUCCESS;
dwCiAndAxleTransBadEnsureCnt = GetCiAndAxleTransBadEnsureCnt(); /*获取判断与计轴通信中断超时周期数*/
dwCurAxleOccStartCycNum = GetSecColOccupyStartCycNum(wCurRelPhySecId);
for (ii = 0U; ii < cNearAcNum; ii++)
{
wNearRelPhySecId = GetAxisSecRelativePhySecId(pNearAcId[ii]);
if (0U != wNearRelPhySecId)
{
cAcRelEnvelopeCnt = elm_GetEnvelopeInAC(pNearAcId[ii], strEnvelopeInfo);
dwNearAxleOccStartCycNum = GetSecColOccupyStartCycNum(wNearRelPhySecId);
if (((0U == cAcRelEnvelopeCnt) || (SECTION_REL_ENVELOPE_SUM_MAX == cAcRelEnvelopeCnt))
&& ((dwCurAxleOccStartCycNum + dwCiAndAxleTransBadEnsureCnt) < dwNearAxleOccStartCycNum))
{
cRetVal = CI_ERROR; /*相邻计轴区段无包络且占用起始时间超过了“与计轴通信中断超时判断时间”*/
cFunRtn = aam_PrepareACIsSelf(pNearAcId[ii], &cRcId); /*判断相邻区段是否为本控区区段*/
if (ELM_BELONG_OWNER == cFunRtn)
{
wNearAcIndex = aam_PrepareACIndex(pNearAcId[ii]);
(void)aam_ClearPassTrainFlag(wNearAcIndex); /*清除好车通过标志*/
(void)aam_ClearRedunTime(wNearAcIndex); /*清除冗余计时*/
aam_SetAxisStatus(wNearAcIndex, AAM_STATUS_OCC); /*设置占用*/
AAM_LOG(AAM_LOG_FATAL, "info:AC%d Set Occ Because Of Near Sec%d Keep Arb Fail\n", pNearAcId[ii], wAcId);
}
else
{
/*非本控区区段，不处理*/
}
}
else
{
/*相邻计轴区段占用起始周期未超过“与计轴通信中断超时判断时间”，继续检查*/
}
}
else
{
cRetVal = CI_ERROR; /*异常场景，返回失败*/
}
}
}
else
{
cRetVal = CI_ERROR; /*异常场景，返回失败*/
}
}
else
{
cRetVal = CI_ERROR; /*入参非法，返回失败*/
}
return cRetVal;
}
TSCP/src/APP/ciapp/AxisAssert/AxisAssertManageAPI.h
-20
View File
@@ -213,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
+135 -232
View File
@@ -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 };
UINT32 dwFindLen = 0u;/*信号机点灯防护距离*/
UINT16 wTrainId = 0u;
UINT32 dwDis = UINT32_MAX;
UINT32 dwDisTail = UINT32_MAX;
UINT32 dwDisHead = UINT32_MAX;
struct_PathPoint TrainPoint = { 0u };
struct_PathPoint TrainHeadPoint = { 0u };
struct_PathPoint TrainTailPoint = { 0u };
struct_PathPoint CutoffPoint = { 0u };
UINT8 cTrainTailDir = 0U; /*列车安全车尾方向*/
UINT8 cTrainHeadDir = 0U; /*列车安全车头方向*/
UINT32 dwFindLen = 0u;
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;
chLocalId = GetSystemParaLocalCiId();
dwFindLen *= 100u;
/* 获取本联锁边界点数量 */
wCutoffPointSum = GetCfpSum();
@@ -400,122 +405,157 @@ 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;
LinkPoint.dwOffset = 0U;
/* 获取边界点信息 */
CutoffPoint.wLinkId = GetCfpLink(wCutoffPointId);
CutoffPoint.dwOffset = GetCfpOffset(wCutoffPointId);
wOtherCfpId = 0U;
chOtherFlag = FLAG_UNSET;
chBreakFlag = FLAG_UNSET;
dwLinkLen = 0U;
if ((CI_SUCCESS == cFunRetVal)&&(MAX_CFG_LIGHTUPLINK_NUM>=wLinkSum))
wTrainId = 0u;
TrainPoint.wLinkId = 0u;
TrainPoint.dwOffset = 0u;
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);
if ((SECTION_OCCUPY_NO != chOccState) && (0u != chTrainNum))
{
/* 找到有车占用的区段 */
chBreakFlag = FLAG_SET;
}
else
{
;
}
}
else
{
chOtherFlag = FLAG_SET;
}
if (j < wLinkSum)
{
/* 更新已经计算的最远无车位置*/
LinkPoint.wLinkId = wLinkId;
if ((FLAG_SET == chOtherFlag)||(FLAG_SET == chBreakFlag))
{
if (DIR_SAME == cDir)
{
LinkPoint.dwOffset = 0U;
}
else
{
LinkPoint.dwOffset = GetLinkLengthById(wLinkId);
}
}
else
{
if (DIR_SAME == cDir)
{
LinkPoint.dwOffset = GetLinkLengthById(wLinkId);
}
else
{
LinkPoint.dwOffset = 0U;
}
if (j < wLinkSum - 1U)
{ /*检查是否有方向变化点，此处检查，当前link已按既定方向查找完，查下一link，若此时中间有方向变化点，则跨过方向变化点，到下一link改变方向查*/
cDirectionPointfirst = GetLinkLogicDirChangedById(wszLinkIdBuf[j]);
cDirectionPointsecond = GetLinkLogicDirChangedById(wszLinkIdBuf[(j + 1U)]); /*wLinkSum已检查越界*/
if (((LINK_DIRCHANGE_BEGIN == cDirectionPointfirst) || (LINK_DIRCHANGE_END == cDirectionPointfirst))
&& (cDirectionPointsecond == cDirectionPointfirst))
{
cDir = ConvertTrainDir(cDir); /*有方向变化点，转换方向*/
}
else
{
; /*没有反向变换点，不考虑变方向*/
}
}
dwLinkLen += GetLinkLengthById(wLinkId); /*未中断遍历，无车且属于本联锁，更新已计算link总长*/
}
}
else
{
; /*最后一个link 无需更新*/
}
wPhySecId = GetLinkRelatedPhySec(wLinkId);
chOccState = GetPhySecCurOccupyState(wPhySecId);
chTrainNum = as_GetLinkTrainNum(wLinkId);
if ((dwFindLen <= dwLinkLen)|| (FLAG_SET == chOtherFlag) || (FLAG_SET == chBreakFlag))
if ((SECTION_OCCUPY_NO != chOccState) && (0u != chTrainNum))
{
/*距离足够 或查找到相邻RC，或查找到占用，停止计算*/
/* 找到有车占用的区段 */
break;
}
else
{
; /*无处理*/
;
}
/*检查是否有方向变化点，此处检查，当前link已按既定方向查找完，查下一link，若此时中间有方向变化点，则跨过方向变化点，到下一link改变方向查*/
if (j < (wLinkSum - 1U))
{
cDirectionPointfirst = GetLinkLogicDirChangedById(wszLinkIdBuf[j]);
cDirectionPointsecond = GetLinkLogicDirChangedById(wszLinkIdBuf[(j + 1U)]); /*todo越界*/
if (((LINK_DIRCHANGE_BEGIN == cDirectionPointfirst) || (LINK_DIRCHANGE_END == cDirectionPointfirst))
&& (cDirectionPointsecond == cDirectionPointfirst))
{
cDir = ConvertTrainDir(cDir); /*有方向变化点，转换方向*/
}
else
{
; /*没有反向变换点，不考虑变方向*/
}
}
else
{
; /*最后一个link不需要考虑方向变化点的问题，防止数组越界*/
}
}
/* 获取列车ID 获取距离分界点最近的列车*/
if ((j < wLinkSum) && (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 寻找对应联锁及分界点列车信息*/
OtherCfpTrainInfoCal(LinkPoint.wLinkId, LinkPoint.dwOffset, dwLinkLen, &tmpTrainInfo);
strTmp = as_GetLinkLastTrain(wLinkId);
}
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
{
@@ -1591,141 +1631,4 @@ 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
-17
View File
@@ -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
+21 -273
View File
@@ -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_AllSnowLevel = CI_SNOW_LEVEL_DEFAULT; /*全线湿轨级别：0-默认值；1-一级；2-二级*/
UINT8 g_AllSnowModel = CI_ALL_SNOW_UNVALID; /*全线雨雪模式命令*/
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); /*获取区段数组下标*/
/**区段下标合法*/
@@ -6238,7 +6182,7 @@ UINT8 CheckLogJumpLockApply(UINT16 logSectionId)
logicCheck = LogicIntruSecVainCheck(logSectionId, &devId, &devState); /*逻辑区段侵限检查*/
logSecLockState = GetLogSecLogLockState(logSectionId);
logSecLockRouteNum = GetLogSecLockBelLogRouteSum(logSectionId);
if (NULL == pLgcSecSwitchStru)
{
reVal = CI_ERROR;
@@ -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;
}
@@ -11199,171 +11114,4 @@ 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
+6 -80
View File
@@ -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
+13 -88
View File
@@ -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);
}
retVal = CI_ERROR;
}
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系电源插箱空开断开*/
/* 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);
}
retVal = CI_ERROR;
}
else
{
retVal = CI_SUCCESS;
gPlatDataGPIOTolercance.powerBNode_TolCyc = 0U;
}
return retVal;
}
@@ -520,16 +484,11 @@ 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 */
@@ -537,27 +496,11 @@ UINT8 CheckRCIAPowerModeFaultState(void)
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);
}
retVal = CI_ERROR;
}
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);
}
retVal = CI_ERROR;
}
else
{
retVal = CI_SUCCESS;
gPlatDataGPIOTolercance.powerBMode_TolCyc = 0U;
}
return retVal;
TSCP/src/APP/ciapp/DataManage/PlatDataManage.h
+2 -11
View File
@@ -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
+1 -17
View File
@@ -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
-275
View File
@@ -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;
@@ -801,275 +796,5 @@ UINT8 GetCancelEsbRelayDownState(const UINT16 esbId)
; /*数组下标不合法，不执行状态更新*/
}
return reVal;
}
/*
* 功能描述：设置紧急关闭旁路按钮按下周期
* 输入参数：const UINT16 esbId Esb ID
* const UINT32 startCycNum 周期号
* 输出参数：无
* 返 回 值：无
* Cretaed By LQ 2025.03.28
*/
void SetEsbCutPressCycNum(const UINT16 esbId, const UINT32 startCycNum)
{
UINT16 bufIndex = 0U;
bufIndex = GetEsbConfigBufIndex(esbId); /*获取数组下标*/
if (ESB_SUM_MAX > bufIndex)
{
EsbDataStru[bufIndex].EsbCutPressCycNum = startCycNum; /*紧急旁路按钮正常按下起始周期*/
}
else
{
; /*不处理*/
}
}
/*
* 功能描述：获取紧急关闭旁路按钮按下周期
* 输入参数：const UINT16 esbId Esb ID
* 输出参数：无
* 返 回 值：紧急关闭旁路按钮按下周期
* Cretaed By LQ 2025.03.28
*/
UINT32 GetEsbCutPressCycNum(const UINT16 esbId)
{
UINT16 bufIndex = 0u; /*数组下标*/
UINT32 reVal = CI_ERROR;
bufIndex = GetEsbConfigBufIndex(esbId); /*获取数组下标*/
if (ESB_SUM_MAX > bufIndex)
{
reVal = EsbDataStru[bufIndex].EsbCutPressCycNum;
}
else
{
/*下标非法，返回0*/
}
return reVal;
}
/*
* 功能描述：设置紧急关闭旁路按钮误触发按下周期
* 输入参数：const UINT16 esbId Esb ID
* const UINT32 startCycNum 周期号
* 输出参数：无
* 返 回 值：无
* Cretaed By LQ 2025.03.28
*/
void SetEsbCutErrTrigPressCycNum(const UINT16 esbId, const UINT32 startCycNum)
{
UINT16 bufIndex = 0U;
bufIndex = GetEsbConfigBufIndex(esbId); /*获取数组下标*/
if (ESB_SUM_MAX > bufIndex)
{
EsbDataStru[bufIndex].EsbCutErrTriggerPressCycNum = startCycNum; /*紧急旁路按钮误触发按下周期*/
}
else
{
; /*不处理*/
}
}
/*
* 功能描述：获取紧急关闭旁路按钮误触发按下周期
* 输入参数：const UINT16 esbId Esb ID
* 输出参数：无
* 返 回 值：紧急关闭旁路按钮误触发按下周期
* Cretaed By LQ 2025.03.28
*/
UINT32 GetEsbCutErrTrigPressCycNum(const UINT16 esbId)
{
UINT16 bufIndex = 0u; /*数组下标*/
UINT32 reVal = CI_ERROR;
bufIndex = GetEsbConfigBufIndex(esbId); /*获取数组下标*/
if (ESB_SUM_MAX > bufIndex)
{
reVal = EsbDataStru[bufIndex].EsbCutErrTriggerPressCycNum;
}
else
{
/*下标非法，返回0*/
}
return reVal;
}
/*
* 功能描述：设置紧急关闭旁路按钮采集继电器落下状态
* 参数说明：const UINT16 esbId 紧急停车按钮ID
* const UINT8 cRelayDownState 继电器落下状态
* 返回值：无
* Created By LQ 2025.03.28
*/
void SetEsbCutRelayDownState(const UINT16 esbId, const UINT8 cRelayDownState)
{
UINT16 bufIndex = 0U;
bufIndex = GetEsbConfigBufIndex(esbId); /*获取数组下标*/
if (ESB_SUM_MAX > bufIndex)
{
if ((ESB_RELAY_ERROR_DOWN_NO == cRelayDownState) || (ESB_RELAY_ERROR_DOWN_YES == cRelayDownState))
{
EsbDataStru[bufIndex].EsbCutRelayDownState = cRelayDownState;
}
else
{
; /*设置状态不合法，不进项状态更新*/
}
}
else
{
; /*数组下标不合法，不执行状态更新*/
}
}
/*
* 功能描述： 获取紧急关闭旁路按钮采集继电器落下状态
* 参数说明： const UINT16 esbId 紧急停车按钮ID
* 返回值 ： 0: 获取数据失败
* 0x55: 正常落下
* 0xaa: 通信异常落下
* Created By LQ 2025.03.28
*/
UINT8 GetEsbCutRelayDownState(const UINT16 esbId)
{
UINT16 bufIndex = 0U;
UINT8 reVal = CI_ERROR;
bufIndex = GetEsbConfigBufIndex(esbId); /*获取数组下标*/
if (ESB_SUM_MAX > bufIndex)
{
reVal = EsbDataStru[bufIndex].EsbCutRelayDownState;
}
else
{
; /*数组下标不合法，不执行状态更新*/
}
return reVal;
}
/*
* 功能描述：设置指定ID紧急关闭旁路按钮故障标志
* 参数说明：const UINT16 esbId, 紧急关闭按钮ID
* const UINT8 cEsbCutErrFlag 紧急关闭旁路按钮故障标志
* 返回值：无
* Created By LQ 2025.03.28
*/
void SetEsbCutErrFlag(const UINT16 esbId, const UINT8 cEsbCutErrFlag)
{
UINT16 bufIndex = 0U;
bufIndex = GetEsbConfigBufIndex(esbId); /*获取数组下标*/
if (ESB_SUM_MAX > bufIndex)
{
if ((ESB_ERROR_FLAG_NO == cEsbCutErrFlag) || (ESB_ERROR_FLAG_YES == cEsbCutErrFlag))
{
EsbDataStru[bufIndex].EsbCutErrorFlag = cEsbCutErrFlag;
}
else
{
; /*设置状态不合法，不进项状态更新*/
}
}
else
{
; /*数组下标不合法，不执行状态更新*/
}
}
/*
* 功能描述： 获取指定ID紧急关闭旁路按钮故障标志
* 参数说明： const UINT16 esbId, 紧急关闭按钮ID
* 返回值 ： 0: 获取数据失败
* 0x55: 未故障
* 0xaa: 故障
* Created By LQ 2025.03.28
*/
UINT8 GetEsbCutErrFlag(const UINT16 esbId)
{
UINT16 bufIndex = 0U;
UINT8 reVal = CI_ERROR;
bufIndex = GetEsbConfigBufIndex(esbId); /*获取数组下标*/
if (bufIndex < ESB_SUM_MAX)
{
reVal = EsbDataStru[bufIndex].EsbCutErrorFlag;
}
else
{
; /*数组下标不合法，不执行状态更新*/
}
return reVal;
}
/*
* 功能描述：设置紧急停车按钮采集继电器落下状态
* 参数说明：const UINT16 esbId 紧急停车按钮ID
* const UINT8 cRelayDownState 继电器落下状态
* 返回值：无
* Created By LQ 2025.04.01
*/
void SetEsbRelayDownState(const UINT16 esbId, const UINT8 cRelayDownState)
{
UINT16 bufIndex = 0U;
bufIndex = GetEsbConfigBufIndex(esbId); /*获取数组下标*/
if (ESB_SUM_MAX > bufIndex)
{
if ((ESB_RELAY_ERROR_DOWN_NO == cRelayDownState) || (ESB_RELAY_ERROR_DOWN_YES == cRelayDownState))
{
EsbDataStru[bufIndex].EsbRelayDownState = cRelayDownState;
}
else
{
; /*设置状态不合法，不进项状态更新*/
}
}
else
{
; /*数组下标不合法，不执行状态更新*/
}
}
/*
* 功能描述： 获取紧急停车按钮采集继电器落下状态
* 参数说明： const UINT16 esbId, 紧急停车按钮ID
* 返回值 ： 0: 获取数据失败
* 0x55: 正常落下
* 0xaa: 通信异常落下
* Created By LQ 2025.04.01
*/
UINT8 GetEsbRelayDownState(const UINT16 esbId)
{
UINT16 bufIndex = 0U;
UINT8 reVal = CI_ERROR;
bufIndex = GetEsbConfigBufIndex(esbId); /*获取数组下标*/
if (ESB_SUM_MAX > bufIndex)
{
reVal = EsbDataStru[bufIndex].EsbRelayDownState;
}
else
{
; /*数组下标不合法，不执行状态更新*/
}
return reVal;
}
TSCP/src/APP/ciapp/ESB/ESBDataManage.h
-97
View File
@@ -38,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
+60 -184
View File
@@ -1161,7 +1161,7 @@ void elm_CTEnvelopeTrack(void)
}
else if ((CI_SUCCESS == funRet) && (1u == relEnvelopeCnt))
{
/* 只有CT包络才涉及B轨UT可追踪功能*/
/* 只有CT包络才设计B轨UT可追踪功能*/
elm_DealNoCGFollowUt(relEnvelopeID[0u], trainID[cycle]);
/** 维护日志--调试级别*/
@@ -1277,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虚拟筛选标志*/
elm_DealAgVirScreenFlag(wEnvelopeID, wTrainId);
/*处理BG虚拟筛选标志*/
elm_DealBgVirScreenFlag(wEnvelopeID, wTrainId);
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
{
@@ -1516,183 +1571,4 @@ 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
+72 -95
View File
@@ -106,7 +106,7 @@ static UINT8 elm_UKTAdjacentSwProtect(void)
nearTrainType = aam_SearchNearbyTrainType(pACIdbuff[cycleAc], EMAP_SAME_DIR, acSameCnt, acSameID);
}
if ((AAM_BAD_NEAR == nearTrainType)|| (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)
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); /*飞车标志*/
}
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();
}
/** 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++)
@@ -2668,19 +2640,10 @@ 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);
headNeedScreen = LINE_MAX_TRAIN == pEnvelopeInfo->headTrainID ? NEED_SCREEN : UNNEED_SCREEN;
tailNeedScreen = LINE_MAX_TRAIN == pEnvelopeInfo->tailTrainID ? NEED_SCREEN : UNNEED_SCREEN;
if (TRAIN_NVRAM_POS_FLAG_NO == chTrainNvramPosFlag)
{
headNeedScreen = LINE_MAX_TRAIN == pEnvelopeInfo->headTrainID ? NEED_SCREEN : UNNEED_SCREEN;
tailNeedScreen = LINE_MAX_TRAIN == pEnvelopeInfo->tailTrainID ? NEED_SCREEN : UNNEED_SCREEN;
wls_SetTrainControlStatus(cycle, IN_CONTROL_STATUS, headNeedScreen, tailNeedScreen);
}
else
{
ELM_LOG(ELM_LOG_FATAL, " not Add In Control Train,Because UseNvram Pos\n");
}
wls_SetTrainControlStatus(cycle,IN_CONTROL_STATUS,headNeedScreen,tailNeedScreen);
}
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; /* 包络数量 */
UINT16 arEnvelopID[TRAIN_SUM_MAX_IN_OC] = { 0U }; /*包络ID数组*/
UINT16 acCnt = 0U; /** 前方计轴数量*/
UINT16 acID[AC_MAXCNT_IN_SWITCH * AC_MAXCNT_IN_SWITCH] = { 0U };
UINT16 mergeACIndex = 0U;
UINT8 envelopeCnt = 0u; /* 包络数量 */
UINT16 arEnvelopID[TRAIN_SUM_MAX_IN_OC] = { 0u }; /*包络ID数组*/
UINT16 acCnt = 0u; /** 前方计轴数量*/
UINT16 acID[AC_MAXCNT_IN_SWITCH * AC_MAXCNT_IN_SWITCH] = { 0u };
UINT8 acStatus = ELM_AC_OCC;
UINT16 mergeACIndex = 0u;
UINT16 mergeACCntMax = (SECTION_IN_ENVELOPE_SUM_MAX + 2U * AC_MAXCNT_IN_SWITCH * AC_MAXCNT_IN_SWITCH);
UINT16 mergeACID[SECTION_IN_ENVELOPE_SUM_MAX + 2U * AC_MAXCNT_IN_SWITCH * AC_MAXCNT_IN_SWITCH] = { 0U };
UINT8 includeCnt = 0U;
UINT16 includeELMid[TRAIN_SUM_MAX_IN_OC] = { 0U }; /** 重合的包络id */
UINT16 mergeACID[SECTION_IN_ENVELOPE_SUM_MAX + 2U * AC_MAXCNT_IN_SWITCH * AC_MAXCNT_IN_SWITCH] = { 0u };
UINT8 includeCnt = 0u;
UINT16 includeELMid[TRAIN_SUM_MAX_IN_OC] = { 0u }; /** 重合的包络id */
/** 获取列车包络 */
pEnvelop = elm_GetEnvelopeInfoPtr(envelopeId);
@@ -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
{
/* 查询后方计轴区段*/
acCnt = elm_GetEnvelopTailACIDs(pEnvelop, acID);
/** 获取车尾包络计轴占用状态 */
acStatus = elm_PrepareACStatus(pEnvelop->ACID[0]);
/** 合并车尾后方的计轴 */
mergeACIndex = elm_PrepareMergeUINT16Array(mergeACID, mergeACCntMax, mergeACIndex, acID, (AC_MAXCNT_IN_SWITCH * AC_MAXCNT_IN_SWITCH), acCnt);
/** 合并包络包含的计轴区段 */
mergeACIndex = elm_PrepareMergeUINT16Array(mergeACID, mergeACCntMax, mergeACIndex, pEnvelop->ACID, SECTION_IN_ENVELOPE_SUM_MAX, pEnvelop->ACCnt);
/** 设置错误码*/
ASSER_ERROR(mergeACIndex > mergeACCntMax, errorCode, 0x40000000U);
if (0U == errorCode)
/** 判断包络尾是否占用，如果占用，则需要查询下一个计轴*/
if (ELM_AC_OCC == acStatus)
{
(void)CommonMemSet(&acID, (UINT32)((AC_MAXCNT_IN_SWITCH*AC_MAXCNT_IN_SWITCH)*sizeof(UINT16)),0U, (UINT32)((AC_MAXCNT_IN_SWITCH*AC_MAXCNT_IN_SWITCH)*sizeof(UINT16)));/*先清空数组防止脏数据*/
/* 查询前方计轴*/
acCnt = elm_GetEnvelopHeadACIDs(pEnvelop, acID);
/* 查询后方计轴，车尾计轴占用，存在道岔四开，为了确保能然后后端，需要查询安全车尾所属计轴的相邻计轴区段*/
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, 0x20000000U);
ASSER_ERROR(mergeACIndex > mergeACCntMax, errorCode, 0x04000000u);
}
else
{
/** 先合并包络包含的计轴区段 */
mergeACIndex = elm_PrepareMergeUINT16Array(mergeACID, mergeACCntMax, mergeACIndex, pEnvelop->ACID, SECTION_IN_ENVELOPE_SUM_MAX, pEnvelop->ACCnt);
/** 设置错误码*/
ASSER_ERROR(mergeACIndex > mergeACCntMax, errorCode, 0x02000000u);
}
if (0u == errorCode)
{
/** 获取车头包络计轴占用状态 */
acStatus = elm_PrepareACStatus(pEnvelop->ACID[pEnvelop->ACCnt - 1U]);
/** 判断包络头是否占用，如果占用，则需要查询下一个计轴 */
if (ELM_AC_OCC == acStatus)
{
/* 查询前方计轴,此处查询四开道岔的相邻计轴其实属于一个冗余的处理，因为如果车头压入了岔区且占用，直接进行了删车，但是此处再这样处理一个是为了统一设计，另外做一个冗余防护*/
acCnt = elm_GetEnvelopHeadACIDs(pEnvelop, acID);
/** 合并车头前方的计轴 */
mergeACIndex = elm_PrepareMergeUINT16Array(mergeACID, mergeACCntMax, mergeACIndex, acID, (AC_MAXCNT_IN_SWITCH * AC_MAXCNT_IN_SWITCH), acCnt);
/** 设置错误码*/
ASSER_ERROR(mergeACIndex > mergeACCntMax, errorCode, 0x04000000u);
}
else
{
/** 无需处理*/
}
/** 判断是否处理成功 */
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++)
{
@@ -3117,17 +3104,7 @@ UINT8 elm_UCTEnvelopeLeaveAC(UINT8 flag,IN const EnvelopeStruct* pEnvelope,UINT1
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);
}
elm_AddFlyingTrain(trainID[cycle], pEnvelop->id);
}
flyCheck++;
}
TSCP/src/APP/ciapp/EnvelopeManage/EnvelopeLogicProcess.h
-18
View File
@@ -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
+15 -27
View File
@@ -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,37 +653,26 @@ 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)
{
if (LINE_MAX_TRAIN == pEnvelopeInfo->headTrainID)
{
ELM_LOG(ELM_LOG_FATAL, " delete Head suspicious,");
(void)elm_SetEnvelopeHeadTrainID(pEnvelopeInfo->id, 0u);
}
else
{
/* 不处理 */
}
if (LINE_MAX_TRAIN == pEnvelopeInfo->tailTrainID)
{
ELM_LOG(ELM_LOG_FATAL, " delete Tail suspicious,");
(void)elm_SetEnvelopeTailTrainID(pEnvelopeInfo->id, 0u);
}
else
{
/* 不处理 */
}
ELM_LOG(ELM_LOG_FATAL," delete Head suspicious,");
(void)elm_SetEnvelopeHeadTrainID(pEnvelopeInfo->id,0u);
}
else
{
ELM_LOG(ELM_LOG_FATAL, " not finish suspicious,because use nvram pos");
/* 不处理 */
}
ELM_LOG(ELM_LOG_FATAL, "\n");
if (LINE_MAX_TRAIN == pEnvelopeInfo->tailTrainID)
{
ELM_LOG(ELM_LOG_FATAL," delete Tail suspicious,");
(void)elm_SetEnvelopeTailTrainID(pEnvelopeInfo->id,0u);
}
else
{
/* 不处理 */
}
ELM_LOG(ELM_LOG_FATAL,"\n");
}
}
else
TSCP/src/APP/ciapp/EnvelopeManage/UCTEnvelopeTrack.c
+25 -103
View File
@@ -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);
ASSER_ERROR(CI_ERROR == funRtn, errorCode, 0x00000400u);
funRtn = elm_SetEnvelopeHeadTrainID(ptemp->id, LINE_MAX_TRAIN);
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)
&& ((pPretemp->startPos.Lnk == wAgLink) || (pPretemp->endPos.Lnk == wAgLink))
&& (1U == ptemp->ACCnt))
{/* B轨UT可追踪开关打开，UCT仅处于B轨，相邻区段是A轨，CT包络在A轨，此场景不延伸 */
if ((FUNC_SWITCH_ON == chBgUtSwitch) && (LINK_REL_PHYSEC_BG == chBgAtt) && (wNextLinkId == wAgLink) && ((pPretemp->startPos.Lnk == wAgLink) || (pPretemp->endPos.Lnk == wAgLink)))
{/* B轨UT可追踪开关打开，UCT处于B轨，相邻区段是A轨，CT包络在A轨，此场景不延伸 */
ret = 0x55u;
}
else
@@ -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];
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);
funRtn = elm_UCTEnvelopeHeadHandle(endLineFlag,ptemp,acSameID[0u],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);
ASSER_ERROR(CI_ERROR == funRtn, errorCode, 0x00000800u);
funRtn = elm_SetEnvelopeTailTrainID(ptemp->id, LINE_MAX_TRAIN);
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)
&& ((pBacktemp->startPos.Lnk == wAgLink) || (pBacktemp->endPos.Lnk == wAgLink))
&& (1U == ptemp->ACCnt))
{/* B轨UT可追踪开关打开，UCT仅处于B轨，相邻区段是A轨，CT包络在A轨，此场景不延伸 */
if ((FUNC_SWITCH_ON == chBgUtSwitch) && (LINK_REL_PHYSEC_BG == chBgAtt) && (wNextLinkId == wAgLink) && ((pBacktemp->startPos.Lnk == wAgLink) || (pBacktemp->endPos.Lnk == wAgLink)))
{/* B轨UT可追踪开关打开，UCT处于B轨，相邻区段是A轨，CT包络在A轨，此场景不延伸 */
ret = 0x55u;
}
else
@@ -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,32 +3028,8 @@ static UINT8 elm_UCTEnvelopeTailMoving(const EnvelopeStruct *ptemp)
if (0u == errorCode)
{
endLineFlag = (0u == acConvertCnt) ? CI_SUCCESS : CI_ERROR;
wInputAcId = acConvertID[0U];
pBacktemp = elm_GetEnvelopeInfoPtr(backEnvelope);
if (NULL != pBacktemp)
{
for (cycle = 0U; cycle < pBacktemp->ACCnt; cycle++)
{
if (ptemp->ACID[0U] == pBacktemp->ACID[cycle])
{
wInputAcId = ptemp->ACID[0U];
break; /*后方包络与本包络起点处于同一计轴区段，停止遍历*/
}
else
{
/*继续遍历查找*/
}
}
}
else
{
/*不处理*/
}
/*若后方包络位于本包络起点计轴区段，则使用本包络起点计轴区段作为入参，否则使用本包络起点后方计轴区段作为入参*/
funRtn = elm_UCTEnvelopeTailHandle(endLineFlag, ptemp, wInputAcId, backEnvelope, cTailDirChangeFlag);
ASSER_ERROR(CI_ERROR == funRtn, errorCode, 0x00400000u);
funRtn = elm_UCTEnvelopeTailHandle(endLineFlag,ptemp,acConvertID[0u],backEnvelope, cTailDirChangeFlag);
ASSER_ERROR(CI_ERROR == funRtn,errorCode,0x00400000u);
if (CI_ERROR != funRtn)
{
@@ -3295,11 +3242,10 @@ static UINT8 elm_UCTEnvelopeMoving(const EnvelopeStruct* ptemp)
* @return CI_ERROR 转换失败
* CI_SUCCESS 转换成功
* @note CT包络转换成UCT时，需要满足：
1，无前端可疑
2、包络内包含的道岔无四开且占用，
3，不为休眠车,
4、列车车长不小于两倍线路最小车长
* by cgh 20250915
1，无前端可疑
2、包络内包含的道岔无四开且占用，
3，不为休眠车,
4、列车车长不小于两倍线路最小车长
*/
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);
@@ -3352,28 +3296,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);
TSCP/src/APP/ciapp/IO/DeviceRelayDataProcess.c
+406 -1721
View File
File diff suppressed because it is too large Load Diff
TSCP/src/APP/ciapp/IO/DeviceRelayDataProcess.h
+8 -139
View File
@@ -95,8 +95,8 @@ UINT8 GetSignalShowColor(const UINT16 signalId);
/*
* 功能描述： 信号机双系板卡故障，信号机当前设置颜色
* 参数说明：
UINT16 signalId：信号机id
UINT8 ocId OC ID
UINT16 signalId：信号机id
UINT8 ocId OC ID
* 返回值 ： 信号机颜色
*/
UINT8 GetOcBoardFaultSignalColor(UINT16 signalId, UINT8 ocId);
@@ -269,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 signalDetDisRelayId 扣车表示灯继电器ID
* const UINT16 signalDetCutDisRelayId 扣车旁路表示灯继电器
* 返 回 值：无
* Modified By LQ 2025.07.03
* 功能描述：驱动自复式扣车指示灯
* 参数说明：const UINT16 signalId, 信号机ID
* const UINT16 signalDetainDisplayId, 扣车表示灯继电器1ID
* 返回值：无
*
*/
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
+92 -446
View File
@@ -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->szAreaSnowInfo); /*更新本地区间雨雪状态信息*/
SetLocalAreaSnowInfo(pTmcInputData->cAreaSnowPlatFormNum, pTmcInputData->szAreaSnowPlatFormId); /*更新本地区间雨雪状态信息*/
}
}
}
@@ -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)
{
@@ -2847,8 +2732,8 @@ UINT8 ProcessAtsOrXianDiToCiData(void)
/*未取消引导总锁*/
ClearCiRevCmdData();/*CI接收命令数据队列*/
}
}
}
else
{/*设置引导总锁*/
for (ii = 0u; ii < AtsOrXianDiToCiCmdSum; ii++)
@@ -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,20 +6609,13 @@ 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
{
/*逻辑区段均空闲，物理区段尚未融合空闲，暂不更新*/
}
/*重新设置物理区段UT或CT占用开始时间*/
SetSecUtOrCtOccuStartCycNum(phySectionId, dwSystemCyc);
}
else if (LOGICSECTION_OCCUPY_UT == curUtOrCtOccFlag)
{
@@ -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;/*折返进路的终端信号机*/
UINT16 wStartSignalId = 0U;/*待信号特开进路的始端信号机*/
UINT8 nextRouteDirection = 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)
{
/*信号机正确*/
if(wEndSignalId == wStartSignalId)
/*获取锁闭进路*/
nextRouteDirection = GetRouteDirection(nextRouteId);
returnRouteDirection = GetRouteDirection(returnRouteId);
haveDirChangeAfterRoute = GetRouteHaveDirChangePointAfter(returnRouteId);
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); /*折返进路对应的通过进路方向*/
/*检查信号机一致*/
if(wEndSignalId == wStartSignalId)
haveDirChangeAfterRoute = GetRouteHaveDirChangePointAfter(returnRouteId);
haveDirChangeInRoute = GetRouteHaveDirChangePointIn(returnRouteId);
saveReRouteDir = returnRouteDirection; /*保存进路实际方向*/
/*进路后方或进路内存在方向变化点*/
if((ROUTE_HAVE_DIR_CHANGE_POINT == haveDirChangeAfterRoute) ||
(ROUTE_HAVE_DIR_CHANGE_POINT == haveDirChangeInRoute) )
{
if(CI_SYSTEM_DIRECTION_UP == returnRouteDirection)
{
returnRouteDirection = CI_SYSTEM_DIRECTION_DOWN;
}
else if(CI_SYSTEM_DIRECTION_DOWN == returnRouteDirection)
{
returnRouteDirection = CI_SYSTEM_DIRECTION_UP;
}
else
{
/*不做处理*/
}
}
/*方向相同*/
if(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,9 +10006,7 @@ 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_POS_MONITOR_VALID != chTrainPosMonitorState))
|| (TRAIN_VIR_SCREEN_PASS_FLAG_INVALID == chVirTailScreenPassFlag))
{
/*有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();
if ((0U != cAreaHumidRailNum) && (LOCAL_AREA_SNOW_SUM_MAX >= cAreaHumidRailNum) && (NULL != pAreaHumidRailData))
pAreaHumidRailId = GetLocalAreaSnowId();
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]);
}
}
}
@@ -12335,222 +12199,4 @@ 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
-15
View File
@@ -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
+3 -38
View File
@@ -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
+1 -1
View File
@@ -18,7 +18,7 @@ UINT16 LocalCiIndicatorIdBuf[INDICATOR_SUM_MAX] = {0u};/*
INT16 IndicatorCurSum = 0; /*指示器当前总数*/
OCStationIndicConfigDataStru g_OCStationIndicConfigDataStru[INDICATOR_SUM_MAX] = { 0u };
UINT16 g_OCStationIndicatorCurSum = 0; /*本联锁OC站（集中站和非集中站）指示器总数,不涉及主备跟随，取值范围 [0,2000) 暂无使用*/
UINT16 g_OCStationIndicatorCurSum = 0; /*本联锁OC站（集中站和非集中站）指示器总数,不涉及主备跟随，取值范围0-1000*/
TSCP/src/APP/ciapp/Indicator/IndicatorDefine.h
+1 -1
View File
@@ -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
+3 -59
View File
@@ -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;
}
else
{
; /*不处理*/
}
}
else
{
; /*不处理*/
}
if (0U == rtnVal)
{
/*读取物理区段在计轴中的索引*/
g_ret = (INT16)ReadPhySecIndexInAxle(LocalCiId, PhysicalSectionConfigDataStru);
if (0 == g_ret)
{
debug_infor_printf((const)"ReadPhySecIndexInAxle Error\n");
rtnVal = 42u;
rtnVal = 37u;
}
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 )
||(ALL_AUTO_RETURN_SUM_MAX <= allAutoReturnSum))
if ((autoRouteSum >= AUTO_ROUTE_SUM_MAX) || (autoReturnSum >= AUTO_RETURN_SUM_MAX))
{/*配置数据总数错误*/
returnValue = CI_ERROR;
}
@@ -3446,40 +3426,4 @@ UINT16 GetTiocDeviceConfigData(UINT32* pConfigDataAddrBuf,UINT16* pConfigDataLen
return wRetSum;
}
/*********************************************
*函数功能：读取指定CI与指定设备通信关系配置数据
*参数说明：const UINT8 chCiId 联锁ID
* const UINT8 chSystemType 设备类型
* UINT8 szDeviceIdBuf[TRANSMIT_OBJECT_DEVICE_SUM_MAX] 输出的设备ID
*返回值：通信关系数
* by cgh 20250605
*********************************************/
UINT8 ReadCiTransmitSpecifyDevData(const UINT8 chCiId, const UINT8 chSystemType, UINT8 szDeviceIdBuf[TRANSMIT_OBJECT_DEVICE_SUM_MAX])
{
UINT16 ii = 0U;
UINT8 chReval = 0U;
if ((0U != chCiId) && (NULL != szDeviceIdBuf))
{
for (ii = 0U; ii < dquCICfgDtStr.TrsmtRlsDtStrLen; ii++)
{
if ((chCiId == dquCICfgDtStr.TrsmtRlsDtStr[ii].CiId) && (chSystemType == dquCICfgDtStr.TrsmtRlsDtStr[ii].SystemType))
{
chReval = dquCICfgDtStr.TrsmtRlsDtStr[ii].DeviceSum;
(void)CommonMemCpy((void*)(szDeviceIdBuf), (UINT32)(sizeof(UINT8) * TRANSMIT_OBJECT_DEVICE_SUM_MAX), (const void*)(dquCICfgDtStr.TrsmtRlsDtStr[ii].DeviceIdBuf), (UINT32)(sizeof(UINT8) * TRANSMIT_OBJECT_DEVICE_SUM_MAX));
}
else
{
;
}
}
}
else
{
chReval = UINT8_MAX;
}
return chReval;
}
TSCP/src/APP/ciapp/Initial/ConfigDataReadManage.h
-10
View File
@@ -160,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
+1 -53
View File
@@ -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
+1 -1
View File
@@ -14,7 +14,7 @@
#ifndef __INVADESECTION_DEFINE_H_
#define __INVADESECTION_DEFINE_H_
#define INVA_SECT_N_COND_SWIT_SUM_MAX ((UINT16)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
+8 -44
View File
@@ -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：通信异常落下*/
@@ -791,13 +770,7 @@ UINT8 RecordDeviceDataLog(UINT8 Flag)
LongToChar(pNewEsbData[deviceId].CancelEsbPressCycNum, &outString[outStringLength]);/*取消紧急关闭按钮按下周期*/
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;
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
-5
View File
@@ -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
-1
View File
@@ -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.c
+152 -754
View File
File diff suppressed because it is too large Load Diff
TSCP/src/APP/ciapp/LogicManage/InterlockLogicManage.h
+3 -28
View File
@@ -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
*/
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
+71 -69
View File
@@ -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;
}
@@ -3795,23 +3796,6 @@ static UINT8 OpenBlocRouteOverlapErrCheck(const UINT16 routeId)
reResult = checkResult;
}
}
/*检查照查继电器状态*/
if ((CI_SUCCESS == reResult) || (CI_ROUTE_RECOVER_ERR == reResult))
{
checkResult = OverlapZhaoChaRelayCheck(overlapId, ESEND_LEVEL_ZERO);
if (CI_ERROR == checkResult)
{
reResult = checkResult;
}
else
{
;
}
}
}
else
@@ -4655,23 +4639,26 @@ static UINT8 RouteIntruSecVainSPKSErrCheck(const UINT16 routeId)
*/
static UINT8 RouteRelayZhaoChaErrCheck(UINT16 const routeId)
{
/* 局部变量定义初始化 */
UINT16 relayId = 0U;
UINT8 relayState = 0U;
UINT8 zcPhySecSum = 0U; /*照查物理区段数目*/
UINT16* pZcPhySecIdBuf = NULL; /*照查物理区段ID数组*/
UINT8 ii = 0U;
/* 局部变量定义初始化 */
UINT16 relayId = 0U;
UINT8 relayState = 0U;
UINT8 zcPhySecSum = 0U; /*照查物理区段数目*/
UINT16* pZcPhySecIdBuf = NULL; /*照查物理区段ID数组*/
UINT8 ii = 0U;
UINT16 thisRealyId = 0U;
UINT8 thisRelayState = 0U;
UINT8 thisRelayState = 0U;
UINT8 routeState = 0U;
UINT8 retVal = CI_ERROR; /*函数返回值*/
UINT16 pDevId = 0U;
UINT8 pDevState = 0U;
UINT8 chRouteLevel = 0U;
UINT8 chErrTemp = 0U;
/* 对端照查检查 */
zcPhySecSum = GetRouteThatZhaoChaPhySecSum(routeId); /*获取照查物理区段数目*/
/* 对端照查检查 */
zcPhySecSum = GetRouteThatZhaoChaPhySecSum(routeId); /*获取照查物理区段数目*/
pZcPhySecIdBuf = GetRouteThatZhaoChaPhySecIdBuf(routeId); /*获取照查物理区段ID数组*/
/*进路监督级别确认*/
chRouteLevel = GetRouteLevel(routeId);
if (NULL == pZcPhySecIdBuf)
{
@@ -4681,14 +4668,14 @@ static UINT8 RouteRelayZhaoChaErrCheck(UINT16 const routeId)
{
retVal = CI_SUCCESS;
for (ii = 0u; ii < zcPhySecSum; ii++)
{
retVal = RoutePhySecZhaoChaErrCheck(routeId, pZcPhySecIdBuf[ii]);
if (CI_ERROR == retVal)
for (ii = 0u; ii < zcPhySecSum; ii++)
{
retVal = RoutePhySecZhaoChaErrCheck(routeId,pZcPhySecIdBuf[ii]);
if (CI_ERROR == retVal)
{
break;
}
else if (CI_ROUTE_RECOVER_ERR == retVal) /*YF00083-1013,出现一个封锁即跳出，防止两个物理区段，一个封锁在前检查，一个未封锁在后检查覆盖掉retVal的值*/
else if(CI_ROUTE_RECOVER_ERR == retVal) /*YF00083-1013,出现一个封锁即跳出，防止两个物理区段，一个封锁在前检查，一个未封锁在后检查覆盖掉retVal的值*/
{
chErrTemp++; /*有一个SPKS封锁就计数一次*/
}
@@ -4701,13 +4688,24 @@ static UINT8 RouteRelayZhaoChaErrCheck(UINT16 const routeId)
{
retVal = CI_ROUTE_RECOVER_ERR; /*出现过一个SPKS封锁，就赋值返回值为SPKS封锁*/
}
}
}
}
}
if ((CI_SUCCESS == retVal) || (CI_ROUTE_RECOVER_ERR == retVal))
if ((CI_SUCCESS == retVal) || (CI_ROUTE_RECOVER_ERR == retVal))
{/*照查物理区段检查通过,检查本端照查继电器*/
if (ROUTE_LEVEL_BLOC == chRouteLevel)
{
thisRealyId = GetRouteThisZhaoChaRelayId(routeId); /*后备模式本端照查继电器ID*/
}
else if (ROUTE_LEVEL_CBTC == chRouteLevel)
{
thisRealyId = GetRouteCbtcThisZhaoChaRelayId(routeId);/*CBTC模式本端照查继电器ID*/
}
else
{
; /*非法监督模式，继电器ID为0，在下面不会处理*/
}
thisRealyId = GetRouteThisZhaoChaRelayId(routeId); /*本端照查继电器ID*/
thisRelayState = GetRelayCollState(thisRealyId); /*获取指定ID继电器的状态*/
routeState = GetRouteState(routeId); /*获取进路状态*/
@@ -4715,32 +4713,25 @@ 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_AUTO_UNLOCK == routeState) ||
(ROUTE_STATE_AUTO_UNLOCKERR == routeState) ||
(ROUTE_STATE_HALF_UNLOCKDELAY == routeState) ||
(ROUTE_STATE_LEAD_LOCKERR == routeState) ||
(ROUTE_STATE_LEAD_OPEN == routeState))
(ROUTE_STATE_NEAR_OPEN == routeState) ||
(ROUTE_STATE_YUXIAN_OPEN == routeState))
{
/*需判断本端照查的状态*/
if (RELAY_STATE_UP == thisRelayState)
/*进路状态初锁异常，预先锁闭，接近锁闭异常，接近开放，预先开放，
需判断本端照查的状态*/
if(RELAY_STATE_UP == thisRelayState)
{
retVal = CI_ERROR;
}
}
else if ((ROUTE_STATE_FIRST_LOCK == routeState) ||
(ROUTE_STATE_LEAD_LOCK == routeState))
else if (ROUTE_STATE_FIRST_LOCK == routeState)
{
if (RELAY_STATE_UP == thisRelayState)
if(RELAY_STATE_UP == thisRelayState)
{
/*等待，返回等待标志*/
retVal = RELAY_STATE_WAITE;
}
}
}
else
{
/*进路状态为其它值，此时不处理*/
@@ -4749,29 +4740,40 @@ static UINT8 RouteRelayZhaoChaErrCheck(UINT16 const routeId)
}
if ((CI_SUCCESS == retVal) || (CI_ROUTE_RECOVER_ERR == retVal))
if ((CI_SUCCESS == retVal) || (CI_ROUTE_RECOVER_ERR == retVal))
{/*本端照查继电器检查通过，检查对端照查继电器*/
relayId = GetRouteThatZhaoChaRelayId(routeId); /*对端照查继电器ID*/
if (0u != relayId)
{/*存在对端照查继电器*/
relayState = GetRelayCollState(relayId);
/* 照查吸起检查*/
if (RELAY_STATE_UP == relayState)
{
/*检查通过*/
}
else
{
retVal = CI_ERROR;
}
if (ROUTE_LEVEL_BLOC == chRouteLevel)
{
relayId = GetRouteThatZhaoChaRelayId(routeId); /*后备模式对端照查继电器ID*/
}
else if (ROUTE_LEVEL_CBTC == chRouteLevel)
{
relayId = GetRouteCbtcThatZhaoChaRelayId(routeId);/*CBTC模式对端照查继电器ID*/
}
else
{
; /*非法监督模式，继电器ID为0，在下面不会处理*/
}
if(0u != relayId)
{/*存在对端照查继电器*/
relayState = GetRelayCollState(relayId);
/* 照查吸起检查*/
if (RELAY_STATE_UP == relayState)
{
/*检查通过*/
}
else
{
retVal = CI_ERROR;
}
}
}
return retVal;
}
/*
TSCP/src/APP/ciapp/LogicManage/TradInterlockLogicManage.c
+108 -149
View File
@@ -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 haveYjkBreakFlag = 0u;
UINT8 ocYjkBreakFlag = 0u;
UINT8 tmpRet =CI_ERROR;
wJkjRelayId = GetJkjRelayId();
JkjRelayState = GetRelayCollState(wJkjRelayId); /*JKJ应急盘继电器采集状态*/
yjValidCycNum = GetJkjRelayValidCycNum(); /*JKJ应急盘状态有效周期*/
curCycNum = Get2oo2CurCycleNum();
for (ii = 0u; ii < m_OcToCiOrginDataNum; ii++)
{
if (OC_HAVE_YJK == m_OcToCiOrginDataArr[ii].chHaveYjk)
{/*任意一个OC具备应急控*/
haveYjkBreakFlag = 1u;
break;
}
else
{
; /*继续*/
}
}
JkjRelayCycNum = GetRelayStateUpdateCycNum(wJkjRelayId); /*JKJ应急盘继电器状态更新周期*/
JkjValidCycNum = GetJkjRelayValidCycNum(); /*JKJ应急盘状态有效周期*/
for (ii = 0u; ii < m_OcToCiOrginDataNum; ii++)
{
if (OC_CTLMODE_YJK == m_OcToCiOrginDataArr[ii].chControlMode)
{/*任意一个OC是应急控*/
ocYjkBreakFlag = 1u;
break;
}
else
{
; /*继续*/
}
}
if (wJkjRelayId > 0u)
if ((wJkjRelayId > 0u) && (RELAY_STATE_DOWN == JkjRelayState))
{
/*配置了继电器*/
if (RELAY_STATE_DOWN == JkjRelayState)
{/*落下*/
if (0u == yjValidCycNum)
{/*未计时*/
SetJkjRelayValidCycNum(curCycNum); /*设置应急有效周期*/
}
else
curCycNum = Get2oo2CurCycleNum();
if (0u == JkjRelayCycNum)
{/*若未计时，则设置起始周期*/
tmpRet = SetRelayStateUpdateCycNum(wJkjRelayId,curCycNum);
if (CI_ERROR == tmpRet)
{
; /*不做处理*/
}
checkRes = SystemOverTimeCheck(yjValidCycNum, JKJ_REYLAY_VALID_CYCLE_NUM);
if (CI_TIME_OUT == checkRes)
{ /*应急有效*/
SetCiJkjFlag(JKJ_REYLAY_VALID); /*设置应急盘有效标志为有效*/
}
else
{
; /*不做处理*/
/*错误处理*/
}
}
else if (RELAY_STATE_UP == JkjRelayState)
{/*吸起*/
/*应急无效*/
SetCiJkjFlag(JKJ_REYLAY_INVALID); /*设置应急盘有效标志为无效*/
SetJkjRelayValidCycNum(0u); /*设置应急无效周期*/
}
else
{
/*应急无效*/
SetCiJkjFlag(JKJ_REYLAY_VALID); /*设置应急盘有效标志为无效*/
SetJkjRelayValidCycNum(curCycNum); /*设置应急无效周期*/
checkRes = SystemOverTimeCheck(JkjRelayCycNum,JKJ_REYLAY_VALID_CYCLE_NUM);
if (CI_TIME_OUT == checkRes)
{ /*应急盘有效*/
SetCiJkjFlag(JKJ_REYLAY_VALID); /*设置JKJ应急盘有效标志为有效*/
if (0u == JkjValidCycNum) /*之前没有设置应急盘有效开始周期*/
{
SetJkjRelayValidCycNum(curCycNum); /*设置JKJ应急盘有效周期*/
}
}
}
else if(1u == haveYjkBreakFlag)
else if ((wJkjRelayId > 0u) && (RELAY_STATE_UP == JkjRelayState))
{
/*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); /*设置应急无效周期*/
tmpRet = SetRelayStateUpdateCycNum(wJkjRelayId, 0u); /*清除JKJ继电器有效起始周期号*/
if (CI_ERROR == tmpRet)
{
/*错误处理*/
}
/*应急盘无效*/
SetCiJkjFlag(JKJ_REYLAY_INVALID); /*设置JKJ应急盘继电器有效标志为无效*/
SetJkjRelayValidCycNum(0u); /*设置JKJ应急盘无效周期*/
}
else
{
/*JKJ未配置，OC无应急控功能，应急盘无效*/
SetCiJkjFlag(JKJ_REYLAY_INVALID); /*设置应急盘有效标志为无效*/
SetJkjRelayValidCycNum(0u); /*设置应急无效周期*/
/*应急盘无效*/
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*/
dwRouteLockStartCycNum = GetRouteLockStartCycNum(routeId);
if (ROUTE_LEVEL_BLOC == chRouteLevel)
{
wSelfRealyId = GetRouteThisZhaoChaRelayId(routeId); /*后备模式本端照查继电器ID*/
wOtherRealyId = GetRouteCbtcThisZhaoChaRelayId(routeId); /*CBTC模式本端照查继电器ID*/
}
else if (ROUTE_LEVEL_CBTC == chRouteLevel)
{
wSelfRealyId = GetRouteCbtcThisZhaoChaRelayId(routeId); /*CBTC模式本端照查继电器ID*/
wOtherRealyId = GetRouteThisZhaoChaRelayId(routeId); /*后备模式本端照查继电器ID*/
}
else
{
; /*非法监督模式，继电器ID为0，在下面不会处理*/
}
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 ((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);
}
}
else
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);
if (CI_TIME_OUT == chOverTimeCheck)
chOverTimeCheck = CheckRelayDriveOutTime(wSelfRealyId, dwTimeOutCycCount);
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); /*设置进路区段未锁闭*/
/*设置进路逻辑区段: 未锁闭*/
@@ -7120,48 +7089,38 @@ void CancelWashWorkLogicM(void)
/*
* 功能描述： 进路调车同意逻辑管理
* 参数说明： void
* 返回值 ： void
* by cgh 20250523
* 返回值 ： void
*/
void RouteDCTYLogic(UINT16 routeId)
void RouteDCTYLogicM(UINT16 routeId)
{
UINT8 routeType = 0U;
UINT8 routeState = 0U;
UINT16 routeDCQJId = 0U;
UINT16 routeDCQJTwoId = 0U;
UINT8 routeType = 0u;
UINT8 routeState = 0u;
UINT16 routeDCQJId = 0u;
routeType = GetRouteType(routeId);/*进路类型*/
routeState = GetRouteState(routeId);/*进路状态*/
routeDCQJId = GetRouteDCQJId(routeId);
routeDCQJTwoId = GetRouteDCQJTwoId(routeId);
if ((0U < routeDCQJId) && (0U < routeDCQJTwoId) && (ROUTE_TYPE_DIAOCHE == routeType))
if ((routeDCQJId >0u) && (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_AUTO_UNLOCKERR == routeState) ||
(ROUTE_STATE_DELAY_UNLOCK == routeState))
{
/*进路存在锁闭:进路初锁、进路初锁异常、预先锁闭、预先开放、接近开放、接近锁闭异常、接近锁闭正常、延时解锁、自动解锁正常、自动解锁异常*/
SetRouteDCQState(routeId,ROUTE_DCQ_REQUEST);/*设置进路调车请求状态调车请求有效*/
(ROUTE_STATE_LEAD_LOCK == routeState) ||
(ROUTE_STATE_LEAD_LOCKERR == routeState) ||
(ROUTE_STATE_LEAD_OPEN == routeState) ||
(ROUTE_STATE_DELAY_UNLOCK == routeState) ||
(ROUTE_STATE_NEAR_LOCK == routeState))
{/*进路是完整锁闭:进路初锁、进路初锁异常、预先锁闭、预先开放、接近开放、接近锁闭异常、接近锁闭正常
、引导锁闭、引导锁闭异常、引导开放、延时解锁*/
(void)SetRouteDCQState(routeId,ROUTE_DCQ_REQUEST);/*设置进路调车请求状态为调车请求*/
}
else
{
/*其它情况设置进路调车请求状态为调车请求无效;调车同意状态无效*/
SetRouteDCQState(routeId,ROUTE_DCQ_NOT_REQUEST);
SetRouteDCTYState(routeId, ROUTE_DCT_NOT_AGREE);
{/*非完整锁闭设置进路调车请求状态为非调车请求*/
(void)SetRouteDCQState(routeId,ROUTE_DCQ_NOT_REQUEST);
}
}
else
{
; /*不处理*/
}
}
/*
TSCP/src/APP/ciapp/LogicManage/TradInterlockLogicManage.h
+2 -3
View File
@@ -775,10 +775,9 @@ void CancelWashWorkLogicM(void);
/*
* 功能描述： 进路调车同意逻辑管理
* 参数说明： void
* 返回值 ： void
* by cgh 20250523
* 返回值 ： void
*/
void RouteDCTYLogic(UINT16 routeId);
void RouteDCTYLogicM(UINT16 routeId);
/*
* 功能描述： 调车进路调车同意联锁条件检查
TSCP/src/APP/ciapp/LogicProcess/InterlockLogicCheck.c
+513 -832
View File
File diff suppressed because it is too large Load Diff
TSCP/src/APP/ciapp/LogicProcess/InterlockLogicCheck.h
+17 -82
View File
@@ -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 UINT8 cFunctionId 函数ID
* const UINT8 cSendLevel 报警发送级别
* const UINT16 wTrainId
* 输出参数：无
* 返回值 ：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* 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, 进路号
* 功能描述： 进路关联所有道岔位置正确检查
* 参数说明： UINT16 const routeId, 进路号）
* 返回值 ： CI_ERROR
* CI_SUCCESS 区段状态均为防护锁闭
* by fan 20250724
* CI_SUCCESS
* BY CGH 20250224
*/
UINT8 RouteAllSecProtectLockCheck(UINT16 const routeId);
/*
* 功能描述： 逻辑区段关联计轴无休眠车检查
* 参数说明： UINT16 logSectionId, 逻辑区段ID
* 返回值 ： CI_ERROR 存在休眠车
* CI_SUCCESS 检查通过
* by fan 20250728
*/
UINT8 LogSecRelateNoSleepTrainCheck(UINT16 const logSectionId);
/*
* 功能描述：校验指定进路是否非场段进路或为场段出库/出段进路
* 参数说明：UINT16 wRouteId 进路ID
* 返 回 值：CI_ERROR 其它进路
* CI_SUCCESS 非场段进路或为场段出库/出段进路
* Created By LQ 2025.08.05
*/
UINT8 RouteCldAttrCheck(UINT16 wRouteId);
/*
* 功能描述：保护区段占用解锁条件检查
* 参数说明：UINT16 overlapId 保护区段ID
* UINT8 functionId 函数ID
* 返 回 值：CI_ERROR 0 失败
* CI_SUCCESS 1 成功
* Created By LQ 2025.08.18
*/
UINT8 OverlapOccuUnlockCheck(UINT16 overlapId, UINT8 functionId);
/*
* 功能描述：列车占用完全在指定区段检查
* 输入参数：const UINT16 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);
UINT8 RouteRelAllSwitchPosCheck(UINT16 const routeId);
#endif
TSCP/src/APP/ciapp/LogicProcess/InterlockLogicProcess.c
+126 -118
View File
@@ -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);
}
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) ||
(ROUTE_STATE_FIRST_LOCKERR == devState) ||
(ROUTE_STATE_YUXIAN_LOCK == devState) ||
(ROUTE_STATE_NEAR_LOCK == devState) ||
(ROUTE_STATE_NEAR_LOCKERR == devState))
if (devState == ROUTE_STATE_LEAD_LOCK)
{
/* 通过检查 */
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);
}
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);
}
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_SUCCESS 0x01 成功
* CI_UNLOCK_OVERLAP_REQURE 0x02 向ZC/车申请解锁保护区段
* CI_OVERLAP_OCC_UNLOCK 0x06 保护区段执行占用特殊解锁
* 返回值 ： CI_ERROR
* CI_SUCCESS
* CI_UNLOCK_OVERLAP_REQURE 向ZC申请解锁保护区段
* 故障编码： 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();
@@ -6531,21 +6510,12 @@ UINT8 UnlockRouteOverlapLogicProcess(UINT16 const routeId, UINT16* overlapId,UIN
}
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;
}
/* 记录故障码 */
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
{
/*如果进路内所有区段状态均为防护锁闭，可解锁*/
chProtectCheck = RouteAllSecProtectLockCheck(routeId);
if (CI_SUCCESS == chProtectCheck)
phySecSum = GetRoutePhysicalSectionSum(routeId);
/*如果进路只有一个区段，并且该区段被前一条进路防护锁闭 可以解锁*/
if ((PHYSICAL_SECTION_LOCK_PROTECT == devState)&&(1U== phySecSum))
{
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 == cCrossState) && (CI_SUCCESS == checkResult))
if ((SIGNAL_CROSS_STATE_NO == GetSignalCrossState(startSignalId)) && (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);
}
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
+4 -5
View File
@@ -325,11 +325,10 @@ UINT8 PhySectionDelayUnlockProcess(const UINT16 routeId, UINT16* phySectionId);
/* C25_解锁进路overlap逻辑处理 */
/*
* 功能描述： 解锁进路overlap逻辑处理
* 参数说明： const UINT16 routeId 进路号
* 返回值 ： CI_ERROR 0x00 失败
* CI_SUCCESS 0x01 成功
* CI_UNLOCK_OVERLAP_REQURE 0x02 向ZC/车申请解锁保护区段
* CI_OVERLAP_OCC_UNLOCK 0x06 保护区段执行占用特殊解锁
* 参数说明： const UINT16 routeId
* 返回值 ： CI_ERROR
* CI_SUCCESS
* CI_UNLOCK_OVERLAP_REQURE 向ZC申请解锁保护区段
* 故障编码： EFUNC_UNLOCK_OVER_LAP
*/
UINT8 UnlockRouteOverlapLogicProcess(const UINT16 routeId, UINT16* overlapId, UINT16* pTrainId);
TSCP/src/APP/ciapp/LogicProcess/TradInterlockLogicProcess.c
+20 -29
View File
@@ -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);
}
reResult = BlocRouteFloodGateCheck(routeId,functionId,sendLevel);
}
return reResult;
@@ -2005,7 +1995,9 @@ UINT8 CancelDTrainRouteP(const UINT16 routeId)
UINT8 devState = 0u; /*设备状态*/
UINT16 cancleZhaoChaRelayId = 0u; /*取消照查继电器ID*/
UINT8 relayState = 0u; /*继电器采集状态*/
UINT8 chRouteLevel = 0U;
/* 联锁条件检查 */
/*进路内所有区段正常锁闭*/
checkResult = RouteAllSecLockStateCheck(routeId,PHYSICAL_SECTION_LOCK_NORMAL,&devId,&devState);
@@ -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);
}
reResult = BlocRouteFloodGateCheck(routeId, functionId, sendLevel);
if (CI_ERROR == reResult)
{
/* 失败返回 */
TSCP/src/APP/ciapp/Mask/MaskDefine.h
+3 -17
View File
@@ -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
-50
View File
@@ -872,54 +872,4 @@ 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
+1 -18
View File
@@ -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
+1 -1
View File
@@ -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
-24
View File
@@ -1040,29 +1040,5 @@ 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
-11
View File
@@ -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
+7 -353
View File
@@ -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
{
@@ -2509,350 +2509,4 @@ UINT16 GePsdVideoQkRelateVobcId(const UINT16 wPsdId)
retVal = CI_ERROR;
}
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
+4 -134
View File
@@ -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
-35
View File
@@ -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
+5 -18
View File
@@ -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) /*进路始端信号机开放*/
@@ -302,8 +298,7 @@
#define CI_BACK_SWT_POS_ERROR ((UINT8)0x37) /*道岔位置错误*/
#define CI_BACK_SWT_MOVE_VALID ((UINT8)0x00) /*道岔不可动作*/
#define CI_BACK_SWT_MOVE_OT ((UINT8)0x39) /*道岔动作超时*/
#define CI_BACK_SWT_BYPASS_CANCEL_NO ((UINT8)0x93) /*联络线道岔旁路未及时取消*/
#define CI_BACK_SWT_MOVE ((UINT8)0xA3) /*道岔转动中*/
#define CI_BACK_SWT_BYPASS_CANCEL_NO ((UINT8)0x93) /*联络线道岔旁路未及时取消*/
/* 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
+8 -430
View File
@@ -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))
@@ -2667,26 +2611,18 @@ UINT16 TransCiToAtsSwitchZzjInfo(OcToATSSwitchZzjData* ciSendAtsSwitchZzjData, U
}
else
{
chSingleSwitchCurPosition = GetSingleSwitchCurPosition(m_OcToCiOrginDataArr[kk].OcDevices[ii].DeviceId);
if (SWITCH_POSITION_JICHA == chSingleSwitchCurPosition)
chSwitchDriveFlag = GetSwitchDrivedFlag(m_OcToCiOrginDataArr[kk].OcDevices[ii].DeviceId);
if (SWITCH_DRIVED_FLAG_YES == chSwitchDriveFlag)
{
/*道岔当前挤岔，转辙机判断为故障*/
ciSendAtsSwitchZzjData[wSwitchNum].szSwitchIncldeZzjState[jj] = OC_TO_ATS_SWITCH_ZZJ_ALARM;
/*道岔被驱动过取消驱动，此转辙机状态设置为正常*/
ciSendAtsSwitchZzjData[wSwitchNum].szSwitchIncldeZzjState[jj] = OC_TO_ATS_SWITCH_ZZJ_NORMAL;
}
else
{
chSwitchDriveFlag = GetSwitchDrivedFlag(m_OcToCiOrginDataArr[kk].OcDevices[ii].DeviceId);
if (SWITCH_DRIVED_FLAG_YES == chSwitchDriveFlag)
{
/*道岔被驱动过取消驱动，此转辙机状态设置为正常*/
ciSendAtsSwitchZzjData[wSwitchNum].szSwitchIncldeZzjState[jj] = OC_TO_ATS_SWITCH_ZZJ_NORMAL;
}
else
{
/*道岔没被驱动四开，此转辙机状态设置为正常*/
ciSendAtsSwitchZzjData[wSwitchNum].szSwitchIncldeZzjState[jj] = OC_TO_ATS_SWITCH_ZZJ_ALARM;
}
/*道岔没被驱动四开，此转辙机状态设置为正常*/
ciSendAtsSwitchZzjData[wSwitchNum].szSwitchIncldeZzjState[jj] = OC_TO_ATS_SWITCH_ZZJ_ALARM;
}
}
}
}
@@ -2734,362 +2670,4 @@ 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
-42
View File
@@ -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
+15 -366
View File
@@ -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,13 +153,22 @@ UINT8 InitAxleToCiDataStru(void)
{
axleId = deviceIdBuf[i];
axleName = (CI_SYSTEM_TYPE_AXIS) * 256u + axleId;
cPrtclVerBtwCiAndAxle = GetCiAndAxisPrtclCheckVer(); /*获取协议校验版本号*/
rtn = dquDevName2HlhtId(axleName, 0U, &axieEtcsId); /*获取计轴互联互通ID*/
rtn &= dquDevName2HlhtId(ciName, 0U, &ciEtcsId); /*获取CI互联互通ID*/
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获取成功*/
{
if (axleId >= AXIS_TO_CI_SUM_MAX)
if(axleId>=AXIS_TO_CI_SUM_MAX)
{
break;/*防护代码，防止越界*/
}
@@ -174,7 +184,7 @@ UINT8 InitAxleToCiDataStru(void)
belongCiId = GetPhySecBelongCiId(phySecId);
belongAxleSysId = GetPhySecBelongAxisSysId(phySecId);
pyhIsThisLine = GetPhyIsThisLineState(phySecId); /*是否本线路*/
if ((0U < phySecId) && (phySecId < PHYSICAL_SECTION_SUM_MAX) && (belongCiId == ciId)
if ((0U < phySecId) && (phySecId < PHYSICAL_SECTION_SUM_MAX) && (belongCiId == ciId)
&& (belongAxleSysId == axleId) && (DEV_IS_THIS_LINE_YES == pyhIsThisLine))
{
axlePhySecSum = axisToCiDataStru[axleId].SectionSum;
@@ -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 wPhySecCurSum = 0U; /*本控区物理区段数目*/
UINT16 wIndexInAxle = 0U; /*物理区段的索引号*/
UINT16 axisDevName = 0u; /*计轴名称：类型+ID*/
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
+2 -16
View File
@@ -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.c
+140 -1908
View File
File diff suppressed because it is too large Load Diff
TSCP/src/APP/ciapp/ParsePack/ParsePackCiData.h
+12 -114
View File
@@ -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_PSD_LEN ((UINT16)5)/*一个屏蔽门数据长度*/
#define CICI_ONE_SIGNAL_LEN ((UINT16)9)/*一个信号机数据长度*/
#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
* UINT8 cAreaSnowLevel 区间湿轨级别
* 返 回 值： 无
* Modified By LQ 2025.5.28
* UINT32 dwAreaSnowId 区间雨雪站台ID
* 返回值 ： 无
* 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
* UINT8 cAreaSnowLevel 区间湿轨等级
* 返 回 值： 无
* Modified By LQ 2025.05.28
* UINT32 dwAreaSnowId 区间雨雪站台ID
* 返回值 ： 无
* 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
+38 -406
View File
@@ -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;
@@ -2792,10 +2638,10 @@ UINT8 OverlapValidMaskCheck(const UINT16 rtOverlapLockedId)
/*保护区段与逻辑区段一致，不检查占压*/
|| (SECTION_OCCUPY_YES == GetPhySecCurMergeState(overlapContainPhySecIdBuf[ii])))
#endif
{
returnValue = CI_ERROR;
break;
#endif
{
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;
UINT8 j = 0U;
UINT8 ciToCimDataBuffer[CI_TO_CIM_DATA_LEN_MAX] = { 0U };
UINT16 i = 0u;
UINT8 j = 0u;
UINT8 ciToCimDataBuffer[CI_TO_CIM_DATA_LEN_MAX] = { 0u };
UINT8 deviceSum = 0u; /*通信设备数*/
UINT8* pDeviceIdBuf = NULL; /*设备ID数组*/
UINT8 transmitState = 0u; /*通信状态*/
UINT8 transmitDevSum = 0U;
UINT16 transmitDevIndex = 0U;
UINT8 cLocalWorkMode = 0U; /*工作模式*/
UINT8 cLocalCiId = 0U; /*本控区ID*/
UINT32 dwCurCycNum = 0U; /*当前周期号*/
UINT32 dwRecvCycNum = 0U; /*接收到对方数据时的周期号*/
UINT16 wTempCommVobcNumIndex = 0U; /*通信车数量索引位置*/
UINT8 cCommVobcNum = 0U; /*通信车数量*/
UINT8 cVobcToCiDataSum = 0U;
VobcToCiDataStruct* pstrVobcToCiData = NULL;
UINT32 dwCommBadCycCount = 0U;
cLocalWorkMode = GetLocalRcWorkMode();
cLocalCiId = GetSystemParaLocalCiId();
dwCurCycNum = Get2oo2CurCycleNum();
ciToCimDataBuffer[i++] = cLocalWorkMode;
ciToCimDataBuffer[i++] = cLocalCiId;
ciToCimDataBuffer[i++] = GetLocalRcWorkMode();
ciToCimDataBuffer[i++] =GetSystemParaLocalCiId ();
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];
/*组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++;
ciToCimDataBuffer[i++] = 0U;
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];
/*组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++;
ciToCimDataBuffer[i++] = 0U;
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通信冗余周期*/
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++;
/*通信良好*/
ciToCimDataBuffer[i++] = 0U;
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通信冗余周期*/
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++;
/*通信良好*/
ciToCimDataBuffer[i++] = 0U;
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];
/*组计轴通信冗余周期*/
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++;
/*通信良好*/
ciToCimDataBuffer[i++] = 0U;
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通信冗余周期*/
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++;
ciToCimDataBuffer[i++] = 0U;
/*通信良好*/
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_MIANVERSION;
ciToCimDataBuffer[i++] = VER_SOFT_MODUAL_APP >> 2U;
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++] = chSignalDsState;
ciToCimDataBuffer[ii++] = pSignalData[deviceId].DsBreakFlag;/*灯丝断丝标志状态*/
}
/*************************************发送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
+2 -8
View File
@@ -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
+1 -2
View File
@@ -38,7 +38,7 @@
/*CI 和 CI*/
#define RECVCI_CMD_DATA_STRU_SUM_MAX ((UINT16)100) /*CI接受其他联锁数据结构体数组最大值*/
#define SENDCI_CMD_DATA_STRU_SUM_MAX ((UINT16)100) /*CI发送到其他联锁数据结构体数组最大值*/
#define CI_TO_CI_DATA_LEN_MAX ((UINT16)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
+371 -1067
View File
File diff suppressed because it is too large Load Diff
TSCP/src/APP/ciapp/ParsePack/ParsePackGateWayData.h
+11 -52
View File
@@ -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
+8 -18
View File
@@ -68,24 +68,24 @@ UINT8 ParseIteToCiData(const UINT8* dataBuf, const UINT16 dataLength, const UINT
UINT8 ii = 0U;
UINT8 retVal = CI_ERROR;
UINT8 cGalHeadSavedFlag = CI_ERROR;
IteToCiDataStruct parseCheckIte = { 0 };
UINT8 chFind = CI_ERROR;
if (IteToCiSum < ITE_TO_CI_SUM_MAX)
{
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), &parseCheckIte, (UINT32)sizeof(IteToCiDataStruct));
chFind = CI_SUCCESS;
(void)CommonMemCpy(&(IteToCiDataStru[ii]), (UINT32)sizeof(IteToCiDataStruct), &(IteToCiDataStru[IteToCiSum - 1U]), (UINT32)sizeof(IteToCiDataStruct));
IteToCiSum--;
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
+7 -16
View File
@@ -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
+34 -438
View File
@@ -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;
}
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)
{
deviceSum = pOcData->OcDeviceNum + 1u; /*设备数量+控权切换*/
}
else
{
deviceSum = pOcData->OcDeviceNum;
}
ShortToChar(deviceSum, &Ci2OcDataBuffer[ii]);/*设备数量*/
ShortToChar(pOcData->OcDeviceNum, &Ci2OcDataBuffer[ii]);/*设备数量*/
ii += 2u;
for (kk = 0u; kk < pOcData->OcDeviceNum; kk++)/*遍历设备*/
{
@@ -355,21 +336,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);
wSwitchIncludeZzjIndex += 1U + (UINT16)(dataBuf[wSwitchIncludeZzjIndex] * 1U) + 4U;
wZzjStateNumber = wZzjStateNumber + (dataBuf[wSwitchIncludeZzjIndex] * 1U);
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)
{
@@ -924,87 +886,18 @@ 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)
{/*校验总数据长度*/
tmpTotalLen = LEN_OC_UP_TO_END_200(wDevInfoIndex, gdBoardNumber, diBoardNumber, doBoardNumber, siBoardNumber, soBoardNumber, (UINT16)sorBoardNumber, chPbNumber, SwapBoardNumber);
tmpTotalLen -= wOffSet;
if (totalLength == tmpTotalLen)
{
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 -= wOffSet;
if (totalLength == tmpTotalLen)
{
retVal = CI_SUCCESS;
}
else
{
retVal = CI_CHECK_LEN_ERROR;
}
}
retVal = CI_SUCCESS;
}
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
{
}
retVal = CI_CHECK_LEN_ERROR;
}
}
}
else if (FUNC_SWITCH_OFF == chSwitch)
{
@@ -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子系统状态*/
@@ -1929,10 +1686,6 @@ UINT8 ParseOcToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength,const U
SetHLHTHeadCtxSrcOppSN(CI_SYSTEM_TYPE_OC, systemId, hlhtGalHead.recvOppMsgSN);
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总数量*/
{
@@ -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
-78
View File
@@ -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
+39 -183
View File
@@ -75,23 +75,23 @@ static UINT8 ParseSnowData(UINT8* dataBuf, UINT16 dataLen);
static UINT8 ParseWLSData(UINT8* dataBuf, UINT16 dataLen);
/*
* 功能描述：解析ITE切除信息
* 功能描述：解析ITE全线切除信息
* 参数说明：const UINT8* dataBuf, 数据缓冲区
* const UINT16 dataLength, 数据长度
* 返 回 值：CI_ERROR 0 数据解析失败
* CI_SUCCESS 1 数据解析成功
* Created By LQ 2024.07.12
*/
static UINT8 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]; /*全线湿轨等级*/
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;
}
cRetVal = CI_SUCCESS;
}
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*/
ii += 2U;
cSnowLevel = dataBuf[ii]; /*区间湿轨等级*/
ii++;
dwPlatFormId = LongFromChar(&dataBuf[ii]); /*解析区间雨雪站台ID*/
ii += 4U;
if ((0U < wPlatFormId) && (UINT16_MAX > wPlatFormId)
&& (CI_SNOW_LEVEL_DEFAULT == cSnowLevel) || (CI_SNOW_LEVEL_ONE == cSnowLevel) || (CI_SNOW_LEVEL_TWO == cSnowLevel))
cPlatFormBelongCiId = GetAreaSnowPlatFormBelongCiId((UINT16)dwPlatFormId); /*获取区间雨雪站台所属控区*/
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.szAreaSnowInfo[cTmepNum].cAreaSnowLevel = cSnowLevel;
g_TmcToTiocDataStru.szAreaSnowPlatFormId[cTmepNum] = dwPlatFormId;
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; /*本地区间雨雪信息数组*/
UINT8 cSnowLevel = 0U; /*湿轨级别*/
UINT32* pAreaSnowId = NULL; /*本地区间雨雪站台ID数组*/
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)
&& ((CI_SNOW_LEVEL_DEFAULT == pAreaSnowData[jj].cAreaSnowLevel) || (CI_SNOW_LEVEL_ONE == pAreaSnowData[jj].cAreaSnowLevel) || (CI_SNOW_LEVEL_TWO == pAreaSnowData[jj].cAreaSnowLevel)))
{
ShortToChar(pAreaSnowData[jj].wAreaId, &TiocToTmcDataBuffer[ii]); /*组区间ID*/
ii += 2U;
TiocToTmcDataBuffer[ii] = pAreaSnowData[jj].cAreaSnowLevel; /*组区间湿轨级别*/
ii++;
}
else
{
cFunRetVal = CI_ERROR; /*区间信息非法，返回失败*/
break;
}
LongToChar(pAreaSnowId[jj], &TiocToTmcDataBuffer[ii]); /*组区间雨雪站台ID*/
ii += 4U;
}
}
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;
UINT8 jj = 0U;
UINT16 wPlatFormId = 0U; /*站台ID*/
UINT8 cPlatFormNum = 0U; /*站台数量*/
UINT8 cTmepNum = 0U;
UINT8 cPlatFormBelongCiId = 0U; /*站台关联Link所属CI*/
UINT8 cLocalCiId = 0U;
UINT16 ii = 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)
{
/*解析成功*/
}
else
{
debug_infor_printf((const)"ParseIteCutData: MsgLen Is Error\n");
cRetVal = CI_ERROR; /*长度不一致，返回失败*/
}
}
else
{
/*不处理*/
}
if (dataLen == ii)
{
cRetVal = CI_SUCCESS;
}
else
{
debug_infor_printf((const)"ParseIteCutData: TMC AreaIteCutNum Exceed Max\n");
cRetVal = CI_ERROR; /*区间ITE切除数量超限，返回失败*/
debug_infor_printf((const)"ParseIteLineCutData Error: MsgLen Is Error\n");
cRetVal = CI_ERROR; /*长度不一致，返回失败*/
}
}
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,42 +1410,15 @@ static UINT16 PackToTmcIteCutData(UINT8* TiocToTmcDataBuffer)
{
TiocToTmcDataBuffer[ii] = CI_ITE_LINE_CUT_DEFAULT; /* 组默认值 */
}
ii++;
/*组区间ITE切除信息*/
cAreaIteCutNum = GetLocalAreaIteCutNum();
pAreaIteCutId = GetLocalAreaIteCutId();
/* 填写数据长度 */
wMagLen = ii - wMagLenIndex;
wRetVal = wMagLen;
wMagLen -= 2U;
if ((LOCAL_AREA_SNOW_SUM_MAX >= cAreaIteCutNum) && (NULL != pAreaIteCutId))
{
TiocToTmcDataBuffer[ii] = cAreaIteCutNum; /*组区间ITE切除数量*/
ii++;
for (jj = 0U; jj < cAreaIteCutNum; jj++)
{
ShortToChar(pAreaIteCutId[jj], &TiocToTmcDataBuffer[ii]); /*组区间ID*/
ii += 2U;
}
}
else
{
debug_infor_printf((const)"PackToTmcIteCutData: Local AreaIteCutNum Exceed Max\n");
cFunRetVal = CI_ERROR; /*区间ITE切除数量超限，返回失败*/
}
if (CI_SUCCESS == cFunRetVal)
{
/* 填写数据长度 */
wMagLen = ii - wMagLenIndex;
wRetVal = wMagLen;
wMagLen -= 2U;
ShortToChar(wMagLen, &TiocToTmcDataBuffer[wMagLenIndex]);
}
else
{
/*组包失败，返回0*/
}
ShortToChar(wMagLen, &TiocToTmcDataBuffer[wMagLenIndex]);
}
else
{
TSCP/src/APP/ciapp/ParsePack/ParsePackTmcData.h
+2 -4
View File
@@ -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
+71 -499
View File
@@ -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)
{/*列车号与刚添加的列车号一致*/
CopyVobcToCiMsg(&parseCheckVobcStruc,&(VobcToCiDataStru[ii]));
chFind = CI_SUCCESS;
/*遍历到最后一个数据*/
if (ii == VobcToCiSum - 1u)
{
break;
}
}
if (CI_ERROR == chFind)
{
(void)CommonMemSet(&(VobcToCiDataStru[VobcToCiSum]), (UINT32)sizeof(VobcToCiDataStruct), 0U, (UINT32)sizeof(VobcToCiDataStruct));/*清内存，防止脏数据*/
CopyVobcToCiMsg(&parseCheckVobcStruc, &(VobcToCiDataStru[VobcToCiSum]));
VobcToCiSum++;
}
else
{
; /*已存在并更新*/
if (VobcToCiDataStru[ii].VobcId == VobcToCiDataStru[VobcToCiSum - 1U].VobcId)
{/*列车号与刚添加的列车号一致*/
CopyVobcToCiMsg(&(VobcToCiDataStru[VobcToCiSum-1U]),&(VobcToCiDataStru[ii]));
VobcToCiSum--;
}
}
}
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;
@@ -1577,13 +1578,16 @@ static UINT8 ParseVobcToCiDataFrameHLHT(const UINT8* dataBuf, const UINT16 dataL
ii++;
}
}
/*修改于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_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*/
}
pDataBuf[ii] = CI_ALL_SNOW_VALID;
}
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;
cSnowLevel = pAreaSnowData[jj].cAreaSnowLevel;
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非法，返回失败*/
}
LongToChar(pAreaSnowId[jj], &pDataBuf[ii]); /*组区间雨雪站台ID*/
ii += 4U;
}
}
else
@@ -9884,21 +9802,9 @@ static UINT8 PackCiToIvocSnowAndUrgentInfo(UINT8* pDataBuf, UINT16* pDataLength,
{
if (LOCAL_AREA_SNOW_SUM_MAX > cAreaSnowTotalNum)
{
wSnowPlatId = pRecvCiAreaSnow[kk].szPlatFormInfo[jj].wAreaId;
cSnowLevel = pRecvCiAreaSnow[kk].szPlatFormInfo[jj].cAreaSnowLevel;
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非法，返回失败*/
}
LongToChar(pRecvCiAreaSnow[kk].dwPlatFormId[jj], &pDataBuf[ii]); /*组区间雨雪站台ID*/
ii += 4U;
cAreaSnowTotalNum++;
}
else
{
@@ -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;
if ((0U<wSnowPlatId) && (UINT16_MAX>wSnowPlatId))
{
ShortToChar(wSnowPlatId, &pDataBuf[ii]); /*组区间雨雪站台ID*/
ii += 2U;
}
else
{
chRetVal = CI_ERROR; /*区间雨雪站台ID非法，返回失败*/
}
LongToChar(pAreaSnowId[jj], &pDataBuf[ii]); /*组区间雨雪站台ID*/
ii += 4U;
}
}
else
@@ -11008,17 +10906,9 @@ static UINT8 PackCiToIvocBackUpReqStateInfo(UINT8* pDataBuf, UINT16* wDataLength
{
if (ALL_AREA_SNOW_SUM_MAX > chAreaSnowTotalNum)
{
wSnowPlatId = pRecvCiAreaSnow[kk].szPlatFormInfo[jj].wAreaId;
if ((0U < wSnowPlatId) && (UINT16_MAX > wSnowPlatId))
{
ShortToChar(wSnowPlatId, &pDataBuf[ii]); /*组区间雨雪站台ID*/
ii += 2U;
chAreaSnowTotalNum++;
}
else
{
chRetVal = CI_ERROR; /*区间雨雪站台Id非法，返回失败*/
}
LongToChar(pRecvCiAreaSnow[kk].dwPlatFormId[jj], &pDataBuf[ii]); /*组区间雨雪站台ID*/
ii += 4U;
chAreaSnowTotalNum++;
}
else
{
@@ -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; /*传出数据长度*/
}
else
{
chRetVal = CI_ERROR; /*组包失败，返回失败*/
}
*wDataLength = ii; /*传出数据长度*/
chRetVal = CI_SUCCESS;
}
else
{
@@ -12437,244 +12249,4 @@ 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
-31
View File
@@ -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
+109 -184
View File
@@ -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通信*/
@@ -131,121 +128,102 @@ UINT8 ParseZcToCiDataFrame(UINT8* dataBuf, UINT16 dataLength, UINT8 systemId)
/*报文有效，继续解析*/
retVal = CI_SUCCESS;
{
if (DATA_TYPE_NEW == chDataType)
while (wTmpDataLen < hlhtGalHead.totalDataLen)
{
while (wTmpDataLen < hlhtGalHead.totalDataLen)
/* 一条应用数据长度 */
wMsgLen = ShortFromChar(&dataBuf[ii]);
ii += 2u;
wTmpDataLen += 2U;
wTmpDataLen += wMsgLen;
if (0u == wMsgLen)
{
/* 一条应用数据长度 */
wMsgLen = ShortFromChar(&dataBuf[ii]);
ii += 2u;
wTmpDataLen += 2U;
wTmpDataLen += wMsgLen;
if (0u == wMsgLen)
{
; /* 无处理，继续解析下一包 */
}
else if (5u > wMsgLen)
{
/* 单包长度不对 */
retVal = CI_ERROR;
debug_infor_printf((const)"ParseZcToCiDataFrame_Error wMsgLen\n");
}
else
{
/* 获取报文类型 */
wMsgType = ShortFromChar(&dataBuf[ii]);
ii += 2u;
/* 跳过预留 */
ii += 2u;
wMsgCheckLen = wMsgLen - 4u;/*单个应用报文解析长度，删除预留2和类型2字节*/
switch (wMsgType)
{
case ZC_TO_TIOC_MASK_MSG:
/* 解析ZC-CI码位信息 */
retVal = ParseMaskData(&dataBuf[ii], wMsgCheckLen);
dwStep |= 0x10000U;
break;
case ZC_TO_TIOC_TSR_MSG:
/* 解析临时限速信息 */
retVal = ParseZcTsrData(&dataBuf[ii], wMsgCheckLen);
dwStep |= 0x01000U;
break;
case ZC_TO_TIOC_WLB_MSG:
/* 解析紧急制动信息 */
retVal = ParseZcEbData(&dataBuf[ii], wMsgCheckLen);
dwStep |= 0x00100U;
break;
case ZC_TO_TIOC_SNOW_MSG:
/*解析ZC-CI雨雪模式信息*/
retVal = ParseZcSnowData(&dataBuf[ii], wMsgCheckLen);
dwStep |= 0x00010U;
break;
case ZC_TO_TIOC_ITELINECUT_MSG:
/*解析ZC-CI的ITE切除信息*/
retVal = ParseZcIteCutData(&dataBuf[ii], wMsgCheckLen);
dwStep |= 0x00001U;
break;
default:
retVal = CI_ERROR;
break;
}
if (CI_SUCCESS == retVal)
{
/* 解析成功，跳过该数据包 */
ii += wMsgCheckLen;
}
else
{
debug_infor_printf((const)"ParseZcToCiDataFrame_Error Step: 0x%5x\n", dwStep);
ClearZcData(); /*任意步骤没解析通过则清空*/
}
}
if (CI_ERROR == retVal) /*解析失败*/
{
break;
}
else
{
; /*do nothing*/
}
; /* 无处理，继续解析下一包 */
}
if (CI_SUCCESS == retVal)
else if (5u > wMsgLen)
{
/*校验数据长度*/
if (ii > dataLength)
{
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(); /*没解析通过则清空*/
/* 单包长度不对 */
retVal = CI_ERROR;
debug_infor_printf((const)"ParseZcToCiDataFrame_Error wMsgLen\n");
}
else
{
; /*继续*/
/* 获取报文类型 */
wMsgType = ShortFromChar(&dataBuf[ii]);
ii += 2u;
/* 跳过预留 */
ii += 2u;
wMsgCheckLen = wMsgLen - 4u;/*单个应用报文解析长度，删除预留2和类型2字节*/
switch (wMsgType)
{
case ZC_TO_TIOC_MASK_MSG:
/* 解析ZC-CI码位信息 */
retVal = ParseMaskData(&dataBuf[ii], wMsgCheckLen);
dwStep |= 0x10000U;
break;
case ZC_TO_TIOC_TSR_MSG:
/* 解析临时限速信息 */
retVal = ParseZcTsrData(&dataBuf[ii], wMsgCheckLen);
dwStep |= 0x01000U;
break;
case ZC_TO_TIOC_WLB_MSG:
/* 解析紧急制动信息 */
retVal = ParseZcEbData(&dataBuf[ii], wMsgCheckLen);
dwStep |= 0x00100U;
break;
case ZC_TO_TIOC_SNOW_MSG:
/*解析ZC-CI雨雪模式信息*/
retVal = ParseZcSnowData(&dataBuf[ii], wMsgCheckLen);
dwStep |= 0x00010U;
break;
case ZC_TO_TIOC_ITELINECUT_MSG:
/*解析ZC-CI的ITE切除信息*/
retVal = ParseZcIteLineCutData(&dataBuf[ii], wMsgCheckLen);
dwStep |= 0x00001U;
break;
default:
retVal = CI_ERROR;
break;
}
if (CI_SUCCESS == retVal)
{
/* 解析成功，跳过该数据包 */
ii += wMsgCheckLen;
}
else
{
debug_infor_printf((const)"ParseZcToCiDataFrame_Error Step: 0x%5x\n", dwStep);
ClearZcData(); /*任意步骤没解析通过则清空*/
}
}
if (CI_ERROR == retVal) /*解析失败*/
{
break;
}
else
{
; /*do nothing*/
}
}
if (CI_SUCCESS == retVal)
{
/*校验数据长度*/
if (ii > dataLength)
{
retVal = CI_ERROR;
}
}
if (CI_SUCCESS == retVal)
{
/*更新通信周期*/
dwCurCyc = Get2oo2CurCycleNum();
funRet = SetCiTransmitRecvDataCycNum(localCiId, CI_SYSTEM_TYPE_ZC, sourceId[0], dwCurCyc);
if (CI_ERROR == funRet)
if (SetCiTransmitRecvDataCycNum(GetSystemParaLocalCiId(), CI_SYSTEM_TYPE_ZC, sourceId[0], Get2oo2CurCycleNum()) == CI_ERROR)
{/*更新周期失败*/
}
@@ -253,8 +231,7 @@ UINT8 ParseZcToCiDataFrame(UINT8* dataBuf, UINT16 dataLength, UINT8 systemId)
{/*更新周期成功*/
/*更新与ZC通信状态：判断与ZC是否通信中断*/
funRet = UpdateCiTransmitState(localCiId, CI_SYSTEM_TYPE_ZC, sourceId[0]);
if (CI_ERROR == funRet)
if (UpdateCiTransmitState(GetSystemParaLocalCiId(), CI_SYSTEM_TYPE_ZC, sourceId[0]) == CI_ERROR)
{
/*更新通信状态失败*/
}
@@ -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); /*获取区间雨雪站台所属控区*/
if ((0U < wPlatFormId)&& (UINT16_MAX > wPlatFormId))
cPlatFormBelongCiId = GetAreaSnowPlatFormBelongCiId(dwPlatFormId); /*获取区间雨雪站台所属控区*/
if (0U != dwPlatFormId)
{
if (cLocalCiId == cPlatFormBelongCiId)
{
/*站台属于本控区*/
if (LOCAL_AREA_SNOW_SUM_MAX > cTmepNum)
{
ZcToCiDataStru.szAreaSnowInfo[cTmepNum].wAreaId = wPlatFormId;
ZcToCiDataStru.szAreaSnowInfo[cTmepNum].cAreaSnowLevel = CI_SNOW_LEVEL_DEFAULT; /*CI模式，湿轨等级为默认值(适配TMC)*/
ZcToCiDataStru.szAreaSnowPlatFormId[cTmepNum] = (UINT32)dwPlatFormId;
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;/*通用报文头中的应用层报文长度(0x202报文长度)*/
ii += 2u; /*预留*/
}
else
{
;/*杭德线路无0x202报文长度、类型及预留*/
}
ShortToChar(TIOC_TO_ZC_MASK_MSG, &CiToZcDataBuffer[ii]);/*接口信息类型*/
ii += 2u;
ii += 2u; /*预留*/
/*组码位信息*/
(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]);
}
/*通用应用层报文总长度*/
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切除数量*/
ii++;
if (ALL_AREA_SNOW_SUM_MAX >= cPlatFormNum)
if (dataLen == ii)
{
ZcToCiDataStru.cAreaIteCutNum = cPlatFormNum;
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");
cRetVal = CI_ERROR; /*区间ID非法，返回失败*/
break;
}
}
if (CI_SUCCESS == cRetVal)
{
if (dataLen != ii)
{
debug_infor_printf((const)"ParseZcIteCutData: Msg Len Error\n");
cRetVal = CI_ERROR;
}
else
{
/*不处理*/
}
}
else
{
/*不处理*/
}
cRetVal = CI_SUCCESS;
}
else
{
debug_infor_printf((const)"ParseZcIteCutData: ZC AreaIteCutNum Error\n");
cRetVal = CI_ERROR; /*ZC区间ITE切除数量超限，返回失败*/
debug_infor_printf((const)"ParseZcIteLineCutData Error: MsgLen Is Error\n");
cRetVal = CI_ERROR; /*长度不一致，返回失败*/
}
}
else
{
debug_infor_printf((const)"ParseZcIteCutData Error: IteLineCutState Error\n");
debug_infor_printf((const)"ParseZcIteLineCutData Error: IteLineCutState Is Invalid\n");
cRetVal = CI_ERROR; /*状态非法，返回失败*/
}
}
TSCP/src/APP/ciapp/ParsePack/ParsePackZcData.h
+4 -6
View File
@@ -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.c
+298 -666
View File
File diff suppressed because it is too large Load Diff
TSCP/src/APP/ciapp/QueryFiles/dquCIInit.h
+2 -8
View File
@@ -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) /*终点到起点*/
@@ -59,9 +58,8 @@
/*dquCICfgDtStr.OCPhySecCfgStr中成员个数*/
#define OC_PHYSEC_CFG_STR_MEMBER_NUM ((UINT8)6)
#define AXIS_TYPE_YONGLIE ((UINT8)(0x01)) /*永列*/
#define AXIS_TYPE_KEANDA ((UINT8)(0x02)) /*科安达*/
#define AXIS_TYPE_FUHAOSHENG ((UINT8)(0x03)) /*富豪盛*/
#define AXIS_TYPE_YONGLIE ((UINT8)(0x01)) /*永列*/
#define AXIS_TYPE_KEANDA ((UINT8)(0x02)) /*科安达*/
#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
-72
View File
@@ -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
-10
View File
@@ -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
+22 -32
View File
@@ -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 chLocalCiPattern = 0u; /*本CI模式*/
UINT8 rtnvalue = 1u;
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;
if (CI_PATTERN_FULL_ELECTRONIC == chLocalCiPattern)
{
pDCAgreeStr->DCRouteDCQJTwoId = dquCiShortFromChar(pData); /*调车同意-调车请求继电器2ID*/
pData += 2U;
}
else
{
pDCAgreeStr->DCRouteDCQJTwoId = 0U;
}
pData += 2u;
pDCAgreeStr->DCRouteTAJId = dquCiShortFromChar(pData); /*调车同意-调车同意按钮继电器ID*/
pData += 2U;
pData += 2u;
rtnvalue = 1U;
rtnvalue = 1u;
}
return rtnvalue;
TSCP/src/APP/ciapp/QueryFiles/dquCIJDQStruInit.c
+38 -62
View File
@@ -1464,100 +1464,76 @@ UINT8 InitRelay_FloodGateStru(CHAR* CIDataName)
*********************************************/
UINT8 InitRelay_DCAgreeStru(CHAR* CIDataName)
{
UINT8 funcRtn = 0U;
UINT8 funcRtn = 0u;
Relay_DCAgreeStruct* pDCAgreeStr = NULL; /*调车同意继电器变量*/
UINT8* pDataAddr = NULL; /*数据地址*/
UINT32 DataSize = 0U; /*数据大小（字节数）*/
UINT16 j = 0U;
UINT8 rtnValue = 0U;
UINT8* pDataAddr; /*数据地址*/
UINT32 DataSize; /*数据大小（字节数）*/
UINT16 j;
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);
if(0U == funcRtn)
funcRtn = dquGetConfigData(CIDataName,CI_DATA_TYPE, RELAY_DCAGREE_ID,&pDataAddr,&DataSize);
if(0u == funcRtn)
{
/*没有表初始化成功*/
rtnValue = 1U;
debug_infor_printf((const)"\nOC_DCAgree_RELAY_ID NO IN FS\n");
/*函数调用失败*/
rtnValue = 0u;
}
else
{
rtnValue = 1U;
if ((0U != DataSize) && (0U != wRealRowCount))
if(0u != (DataSize%LEN_RELAY_DCAGREE_ID))
{ /*求得个数不为整数，数据错误*/
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;
}
else
{
if (0U != (DataSize % wRealRowCount))
{
/*求得个数不为整数，数据错误*/
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);
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));
RelayData.pRelayDCAgreeStr = (Relay_DCAgreeStruct *) MyNew ((UINT32)(sizeof(Relay_DCAgreeStruct) * RelayDataLen.RelayDCAgreeStrLen));
if (NULL == RelayData.pRelayDCAgreeStr)
if(NULL == RelayData.pRelayDCAgreeStr)
{/*动态申请空间失败*/
RelayDataLen.RelayDCAgreeStrLen = 0U;
rtnValue = 0U;
RelayDataLen.RelayDCAgreeStrLen = 0u;
rtnValue = 0u;
}
else
{
/*内存先设为无效*/
(void)memset(RelayData.pRelayDCAgreeStr, 0x00, sizeof(Relay_DCAgreeStruct) * RelayDataLen.RelayDCAgreeStrLen);
/*解析数据到 默认行车序列 结构体数组 */
for (j = 0u; j < RelayDataLen.RelayDCAgreeStrLen; j++)
(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;
pDCAgreeStr = RelayData.pRelayDCAgreeStr + j;
/*填充数据结构体*/
rtnValue &= R_DCAgreeStructFromChar(pDataAddr,pDCAgreeStr);
pDataAddr += LEN_RELAY_DCAGREE_ID;
/*填充数据结构体*/
rtnValue &= R_DCAgreeStructFromChar(pDataAddr, pDCAgreeStr);
pDataAddr += dwRowLen;
}
else
{
break;
}
}
}
}
}
else
{
;
}
}
}
return rtnValue;
TSCP/src/APP/ciapp/QueryFiles/dquCILSStru.h
-2
View File
@@ -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
-8
View File
@@ -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
+49 -57
View File
@@ -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,61 +1568,55 @@ UINT8 InitLS_OverlapLockCondStru(CHAR *LSDataName)
else
{
/*求得个数*/
if ((0U != DataSize) && (0U != rowLen))
{
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);
rtnValue = 0u;
}
else
{
realRowLen = (UINT16)(DataSize / rowLen);
LSDataLen.LSOverlapLockCondStruLen = (UINT16)rowLen;
if (DataSize < realRowLen)
{
rtnValue = 0U;
}
else
{
/*动态申请空间*/
LSData.pLSOverlapLockCondStru = (LS_OveralpLockCondStru*)MyNew((UINT32)(sizeof(LS_OveralpLockCondStru) * LSDataLen.LSOverlapLockCondStruLen));
/*动态申请空间失败*/
if (NULL == LSData.pLSOverlapLockCondStru)
{
/*将数组长度清0，防护数组访问越界*/
LSDataLen.LSOverlapLockCondStruLen = 0u;
rtnValue = 0u;
}
else
{
/*内存先设为无效*/
(void)memset(LSData.pLSOverlapLockCondStru, 0x00, sizeof(LS_OveralpLockCondStru) * LSDataLen.LSOverlapLockCondStruLen);
/*解析数据到 默认行车序列 结构体数组 */
rtnValue = 1u;
for (j = 0u; j < LSDataLen.LSOverlapLockCondStruLen; j++)
{
pTempLSProtSecLockCondStru = LSData.pLSOverlapLockCondStru + j;
/*填充数据结构体*/
rtnValue &= LS_OverlapLockCondStruFromChar(pDataAddr, pTempLSProtSecLockCondStru);
pDataAddr += realRowLen;
}
}
}
}
if((DataSize % OVERLAP_LOCK_COND_DATA_LEN) != 0u)
{
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);
rtnValue = 0u;
}
else
{
rtnValue = 1U;
}
/*获取保护区段锁闭条件表条目数量*/
LSDataLen.LSOverlapLockCondStruLen = (UINT16)(DataSize/OVERLAP_LOCK_COND_DATA_LEN);
if(DataSize < OVERLAP_LOCK_COND_DATA_LEN)
{
LSData.pLSOverlapLockCondStru = (LS_OveralpLockCondStru *) MyNew ((UINT32)sizeof(LS_OveralpLockCondStru));
rtnValue = 1u;
}
else
{
/*动态申请空间*/
LSData.pLSOverlapLockCondStru = (LS_OveralpLockCondStru *) MyNew ((UINT32)(sizeof(LS_OveralpLockCondStru) * LSDataLen.LSOverlapLockCondStruLen));
/*动态申请空间失败*/
if(NULL == LSData.pLSOverlapLockCondStru)
{
/*将数组长度清0，防护数组访问越界*/
LSDataLen.LSOverlapLockCondStruLen = 0u;
rtnValue = 0u;
}
else
{
/*内存先设为无效*/
(void)memset(LSData.pLSOverlapLockCondStru, 0x00, sizeof(LS_OveralpLockCondStru) * LSDataLen.LSOverlapLockCondStruLen);
/*解析数据到 默认行车序列 结构体数组 */
rtnValue = 1u;
for(j=0u; j < LSDataLen.LSOverlapLockCondStruLen; j++)
{
pTempLSProtSecLockCondStru = LSData.pLSOverlapLockCondStru + j;
/*填充数据结构体*/
rtnValue &=LS_OverlapLockCondStruFromChar(pDataAddr, pTempLSProtSecLockCondStru);
pDataAddr += OVERLAP_LOCK_COND_DATA_LEN;
}
}
}
}
}
}
@@ -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
-2
View File
@@ -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.c
+161 -917
View File
File diff suppressed because it is too large Load Diff
TSCP/src/APP/ciapp/QueryFiles/dquMaskInit.h
+1 -43
View File
@@ -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
+3 -5
View File
@@ -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
-50
View File
@@ -1656,55 +1656,5 @@ UINT16 GetRelayBelongOCId(const UINT16 relayId)
{
retVal = CI_ERROR;
}
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
-19
View File
@@ -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
-14
View File
@@ -16,9 +16,6 @@
RelayDataStruct RelayDataStru[RELAY_SUM_MAX]; /*定义继电器配置数据结构体数组*/
IODiffDataStruct IODiffDataStru[OC_SUM_MAX]; /*定义IO双系采集不一致信息*/
UINT8 gDiffDataOcNum = 0u; /*定义IO双系采集不一致所对应的OC数量*/
/*
* 功能描述： 获取指定ID继电器数据
* 参数说明：
@@ -919,15 +916,4 @@ UINT8 GetRelayBCollBoardState(const UINT16 wRelayId)
}
return retVal;
}
/*
* 功能描述： 获取IO双系采集不一致数据
* 参数说明：
* 返回值 ：
RelayDataStruct*
*/
IODiffDataStruct* GetIODiffData(void)
{
return IODiffDataStru;
}
TSCP/src/APP/ciapp/Relay/RelayDataManage.h
-20
View File
@@ -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
-13
View File
@@ -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
+1 -2
View File
@@ -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_DELAY != LockStatus)))
|| ((PHYSICAL_SECTION_LOCK_NORMAL != LockStatus) && (PHYSICAL_SECTION_LOCK_PROTECT != LockStatus)))
{
(*pLockStat) = SEC_LOCK_ERROR;
(*pLockDir) = 0u;

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