diff --git a/.gitattributes b/.gitattributes index 486a232..64500de 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1 +1,2 @@ *.zip filter=lfs diff=lfs merge=lfs -text +*.rar filter=lfs diff=lfs merge=lfs -text diff --git a/TSCP/src/APP/PU13_integration_config/ci_integrate_config.h b/TSCP/src/APP/PU13_integration_config/ci_integrate_config.h index a17f79b..0837b44 100644 --- a/TSCP/src/APP/PU13_integration_config/ci_integrate_config.h +++ b/TSCP/src/APP/PU13_integration_config/ci_integrate_config.h @@ -30,6 +30,6 @@ #define VER_INTE_PROJECT 220 /*项目编号*/ #define VER_INTE_PRODUCT 40 /*产品编号*/ #define VER_INTE_EXE 1 /*可执行编号*/ -#define VER_INTE_TIME 127 /*集成次数编号*/ +#define VER_INTE_TIME 131 /*集成次数编号*/ #endif/*endif of #define _CI_INTEGRATE_CONFIG_H*/ \ No newline at end of file diff --git a/TSCP/src/APP/ciapp/2oo2/2oo2DataTransferManage.c b/TSCP/src/APP/ciapp/2oo2/2oo2DataTransferManage.c index 28f01c3..bce22ab 100644 --- a/TSCP/src/APP/ciapp/2oo2/2oo2DataTransferManage.c +++ b/TSCP/src/APP/ciapp/2oo2/2oo2DataTransferManage.c @@ -1629,11 +1629,31 @@ UINT32 GetCiAppData(UINT8 *pCiAppDataPointer) pCiAppDataPointer[curIndex] = gCbtcCrossStructZc[ii].wTrainId; curIndex += 1u; } - + /*ATS/锟街碉拷/锟斤拷锟斤拷一锟斤拷锟斤拷锟筋及确锟斤拷锟斤拷息同锟斤拷*/ + /*锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷*/ + (void)CommonMemCpy((void *)(pCiAppDataPointer + curIndex), (UINT32)sizeof(AtsFollowUpCmdFstStru), (const void *)(&gDansuoCancleMsgFst), (UINT32)sizeof(AtsFollowUpCmdFstStru)); + curIndex = curIndex + (UINT32)sizeof(AtsFollowUpCmdFstStru); + (void)CommonMemCpy((void *)(pCiAppDataPointer + curIndex), (UINT32)sizeof(RCIFollowUpReplyStru), (const void *)(&gDansuoCancleReplyFst), (UINT32)sizeof(RCIFollowUpReplyStru)); + curIndex = curIndex + (UINT32)sizeof(RCIFollowUpReplyStru); + /*锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟*/ + (void)CommonMemCpy((void *)(pCiAppDataPointer + curIndex), (UINT32)sizeof(AtsFollowUpCmdFstStru), (const void *)(&gSwitchUnflockMsgFst), (UINT32)sizeof(AtsFollowUpCmdFstStru)); + curIndex = curIndex + (UINT32)sizeof(AtsFollowUpCmdFstStru); + (void)CommonMemCpy((void *)(pCiAppDataPointer + curIndex), (UINT32)sizeof(RCIFollowUpReplyStru), (const void *)(&gSwitchUnflockReplyFst), (UINT32)sizeof(RCIFollowUpReplyStru)); + curIndex = curIndex + (UINT32)sizeof(RCIFollowUpReplyStru); + /*锟斤拷锟轿斤拷锟斤拷锟斤拷锟*/ + (void)CommonMemCpy((void *)(pCiAppDataPointer + curIndex), (UINT32)sizeof(AtsFollowUpCmdFstStru), (const void *)(&gSecUnflockMsgFst), (UINT32)sizeof(AtsFollowUpCmdFstStru)); + curIndex = curIndex + (UINT32)sizeof(AtsFollowUpCmdFstStru); + (void)CommonMemCpy((void *)(pCiAppDataPointer + curIndex), (UINT32)sizeof(RCIFollowUpReplyStru), (const void *)(&gSecUnflockReplyFst), (UINT32)sizeof(RCIFollowUpReplyStru)); + curIndex = curIndex + (UINT32)sizeof(RCIFollowUpReplyStru); + /*锟脚号伙拷锟斤拷锟斤拷锟斤拷锟*/ + (void)CommonMemCpy((void *)(pCiAppDataPointer + curIndex), (UINT32)sizeof(AtsFollowUpCmdFstStru), (const void *)(&gSignalUnflockMsgFst), (UINT32)sizeof(AtsFollowUpCmdFstStru)); + curIndex = curIndex + (UINT32)sizeof(AtsFollowUpCmdFstStru); + (void)CommonMemCpy((void *)(pCiAppDataPointer + curIndex), (UINT32)sizeof(RCIFollowUpReplyStru), (const void *)(&gSignalUnflockReplyFst), (UINT32)sizeof(RCIFollowUpReplyStru)); + curIndex = curIndex + (UINT32)sizeof(RCIFollowUpReplyStru); /*锟斤拷锟斤拷一锟斤拷CRC*/ crcLength = curIndex - crcIndex; crcResult = Tioc_CommonCrc32(pCiAppDataPointer + crcIndex, crcLength); - debug_infor_printf((const)"2oo2 RecvCiCmdDataStruCurSum-gDyTestNum CRC:%x, Length:%d\n", crcResult, crcLength); + debug_infor_printf((const)"2oo2 RecvCiCmdDataStruCurSum-FollowUpCmd CRC:%x, Length:%d\n", crcResult, crcLength); } return curIndex; } @@ -2477,7 +2497,27 @@ UINT8 SetCiAppData(const UINT8 *pCiAppDataPointer,const UINT32 len) gCbtcCrossStructZc[ii].wTrainId = pCiAppDataPointer[curIndex]; curIndex += 1u; } - + /*同锟斤拷一锟斤拷锟斤拷锟筋及锟斤拷锟斤拷*/ + /*锟斤拷锟斤拷锟斤拷锟斤拷*/ + (void)CommonMemCpy((void *)(&gDansuoCancleMsgFst), (UINT32)sizeof(AtsFollowUpCmdFstStru), (const void *)(pCiAppDataPointer + curIndex), (UINT32)sizeof(AtsFollowUpCmdFstStru)); + curIndex = curIndex + (UINT32)sizeof(AtsFollowUpCmdFstStru); + (void)CommonMemCpy((void *)(&gDansuoCancleReplyFst), (UINT32)sizeof(RCIFollowUpReplyStru), (const void *)(pCiAppDataPointer + curIndex), (UINT32)sizeof(RCIFollowUpReplyStru)); + curIndex = curIndex + (UINT32)sizeof(RCIFollowUpReplyStru); + /*锟斤拷锟斤拷锟斤拷锟*/ + (void)CommonMemCpy((void *)(&gSwitchUnflockMsgFst), (UINT32)sizeof(AtsFollowUpCmdFstStru), (const void *)(pCiAppDataPointer + curIndex), (UINT32)sizeof(AtsFollowUpCmdFstStru)); + curIndex = curIndex + (UINT32)sizeof(AtsFollowUpCmdFstStru); + (void)CommonMemCpy((void *)(&gSwitchUnflockReplyFst), (UINT32)sizeof(RCIFollowUpReplyStru), (const void *)(pCiAppDataPointer + curIndex), (UINT32)sizeof(RCIFollowUpReplyStru)); + curIndex = curIndex + (UINT32)sizeof(RCIFollowUpReplyStru); + /*锟斤拷锟轿斤拷锟*/ + (void)CommonMemCpy((void *)(&gSecUnflockMsgFst), (UINT32)sizeof(AtsFollowUpCmdFstStru), (const void *)(pCiAppDataPointer + curIndex), (UINT32)sizeof(AtsFollowUpCmdFstStru)); + curIndex = curIndex + (UINT32)sizeof(AtsFollowUpCmdFstStru); + (void)CommonMemCpy((void *)(&gSecUnflockReplyFst), (UINT32)sizeof(RCIFollowUpReplyStru), (const void *)(pCiAppDataPointer + curIndex), (UINT32)sizeof(RCIFollowUpReplyStru)); + curIndex = curIndex + (UINT32)sizeof(RCIFollowUpReplyStru); + /*锟脚号伙拷锟斤拷锟*/ + (void)CommonMemCpy((void *)(&gSignalUnflockMsgFst), (UINT32)sizeof(AtsFollowUpCmdFstStru), (const void *)(pCiAppDataPointer + curIndex), (UINT32)sizeof(AtsFollowUpCmdFstStru)); + curIndex = curIndex + (UINT32)sizeof(AtsFollowUpCmdFstStru); + (void)CommonMemCpy((void *)(&gSignalUnflockReplyFst), (UINT32)sizeof(RCIFollowUpReplyStru), (const void *)(pCiAppDataPointer + curIndex), (UINT32)sizeof(RCIFollowUpReplyStru)); + curIndex = curIndex + (UINT32)sizeof(RCIFollowUpReplyStru); rtn = 1U; } } diff --git a/TSCP/src/APP/ciapp/ERROR/ErrorDefine.h b/TSCP/src/APP/ciapp/ERROR/ErrorDefine.h index a77aafe..894ef75 100644 --- a/TSCP/src/APP/ciapp/ERROR/ErrorDefine.h +++ b/TSCP/src/APP/ciapp/ERROR/ErrorDefine.h @@ -111,6 +111,10 @@ #define EFUNC_OVERLAP_VALIDMASK_CHECK ((UINT8)0x4A) /*函数：OverlapValidMaskCheck 计算保护区段有效码位检查*/ #define EFUNC_ROUTE_LOCK_DRIVE_SWITCH ((UINT8)0xD2) /*RouteLockDriveSwitch 锁闭道岔*/ #define EFUNC_ROUTE_COUPLINK_SET ((UINT8)0xD7) /*SetCouplinkRouteLogicManage 办理联挂进路逻辑管理*/ +#define EFUNC_FOLLOWUP_SWITCH_DANSUO_CANCLE ((UINT8)0xD8) /*FollowUpSwitchUnFlockCheck 一二次道岔单解命令*/ +#define EFUNC_FOLLOWUP_SWITCH_UNFLOCK ((UINT8)0xD9) /*FollowUpSwitchUnFlockCheck 一二次道岔解封命令*/ +#define EFUNC_FOLLOWUP_SEC_UNFLOCK ((UINT8)0xDA) /*FollowUpSecUnFlockCheck 一二次区段解封命令*/ +#define EFUNC_FOLLOWUP_SIGNAL_UNFLOCK ((UINT8)0xDB) /*FollowUpSwitchUnFlockCheck 一二次信号解封命令*/ /*车辆段联锁逻辑检查*/ #define EFUNC_SET_LEAD_ROUTE_CHECK ((UINT8)0x4B) /*办理引导进路检查*/ @@ -219,7 +223,8 @@ #define EFUNC_PARSE_LOCAL_RC2CI_DATA ((UINT8)0xD5U) /*函数：ParseRcToLocalCiDataFrame*/ #define EFUNC_PARSE_LOCAL_CI2CI_DATA ((UINT8)0xD6U) /*函数：ParseCiToCiDataFrame*/ #define EFUNC_PARSE_LOCAL_OC2CI_DATA ((UINT8)0xD7U) /*函数：ParseOcToCiDataFrame*/ - +#define EFUNC_CONNECT_ROUTE_RELEASE ((UINT8)0xD8U) /*函数：ConnectRouteReleaseManage*/ +#define EFUNC_PARSE_GATEWAY2CI_DATA ((UINT8)0xD9U) /*函数：ParseGateWayToCiDataProc*/ /*************************************************分界线******************************************************************************/ /*************************************************分界线******************************************************************************/ @@ -242,6 +247,7 @@ #define ETYPE_GROUP_AUTO_ROUTE_STATE ((UINT8)0x16) /*组合自动进路*/ #define ETYPE_ROUTE_APPLY_SWITCH_MOVE ((UINT8)0xA4) /*进路道岔单操中*/ #define ETYPE_COUPLINK_ROUTE_IDLE ((UINT8)0xA5) /*联挂进路内无被联挂车*/ +#define ETYPE_CONNECT_ROUTE_RELEASE ((UINT8)0xA6) /*联络线接车进路解锁条件不满足*/ #define ETYPE_COMM_WITH_VOBC ((UINT8)0x11) /*与VOBC通信*/ @@ -254,6 +260,7 @@ #define ETYPE_COMM_WITH_TMC ((UINT8)0x17) /*与TMC通信*/ #define ETYPE_COMM_WITH_RC ((UINT8)0x18U) /*与RC通信*/ #define ETYPE_COMM_WITH_OC ((UINT8)0x19U) /*与OC通信*/ +#define ETYPE_COMM_WITH_GATEWAY ((UINT8)0x1AU) /*与网关通信*/ /* 信号机故障类型编码 (UINT8)0x21-(UINT8)0x3f */ /* 设备类型 CI_DEVICE_TYPE_SIGNAL */ diff --git a/TSCP/src/APP/ciapp/IO/DeviceRelayDataProcess.c b/TSCP/src/APP/ciapp/IO/DeviceRelayDataProcess.c index 23563d9..6fa4bff 100644 --- a/TSCP/src/APP/ciapp/IO/DeviceRelayDataProcess.c +++ b/TSCP/src/APP/ciapp/IO/DeviceRelayDataProcess.c @@ -22,6 +22,7 @@ #include "AxisAssertManage.h" #include "AxisAssertDataPrepare.h" #include "dquCIInit.h" +#include "ReverseCutConfigDataManage.h" /*信号机继电器延时驱动时间(周期)*/ #define SIG_RELAY_DRV_DELAY_TIME ((UINT32)3) @@ -39,6 +40,17 @@ static void IsOccPhyHasOccAc(void); * 返回值 ： 无 */ static void DriveSwitchRelayState(const UINT16 switchId, const UINT8 driveSwitchPos); + +/*道岔冗余采集相关函数声明*/ +static UINT8 SwitchRedunFusionHunXianProc(UINT8 cMainOcPos, const UINT8 *pRedunPos, INOUT UINT8 *pHunXianStt); +static UINT8 CalcRedunSwitchFinalFusionPos(UINT8 cMainOcPos, const UINT8 *pRedunPosForFusion, UINT8 cConflictTag); +static UINT8 GetSwitchRedunFusionPos(UINT16 switchId, UINT8 cMainOcPos, UINT8 *pRedunPos, UINT8 *pHunXianStt); +static UINT8 GetMainOcSwitchColPos(UINT16 switchId); +static UINT8 GetRedunSwitchColPos(UINT16 switchId, UINT8 ocIndex, UINT8 *pHunXianStt, UINT8 *pCombineStt); +static void SwitchRedunFaultProc(UINT16 switchId, UINT8 ocIndex, UINT8 cCombineState); +static void SwitchRedunHunXianProc(UINT16 switchId, UINT8 ocIndex, UINT8 cCurrHunXianState, UINT8 cCombineState); +static UINT8 SwitchRedunCombineProc(UINT8 cDBJ1State, UINT8 cDBJ2State, UINT8 cFBJ1State, UINT8 cFBJ2State); + /* zt 删除单轨相关代码 2022-02-15 */ /******************************信号机相关继电器处理****************************/ @@ -79,6 +91,8 @@ void OcSwitchDeviceOutput(void) UINT8 mainOcId = 0u;/*主控OCId*/ UINT8 chLocalCiOCSswitch = 0U; UINT8 chSwitchLastValidDrvPos = 0U; + UINT16 wReverseBoardId = 0U; + UINT8 chReverseState = 0U; chLocalCiOCSswitch = GetLocalCiOCSswitch(); @@ -142,6 +156,26 @@ void OcSwitchDeviceOutput(void) }/*for*/ + /*更新倒切状态*/ + for (ii = 0u; ii < switchCurSum; ii++) + { + switchId = GetSwitchId(ii); + wReverseBoardId = GetSwitchRelateReverseBoardId(switchId); + if (0U != wReverseBoardId) + { + /*配置倒切*/ + chReverseState = GetReverseBoardState(wReverseBoardId); + if (REVERSE_STATE_NEW_SYSTEM != chReverseState) + { + (void)SetSwitchExpDrvPosition(switchId, SWITCH_DRIVE_POS_INVALID);/*非新建系统侧 ,设置期望驱动位置为无效，接口处转为0x55aa道岔位置保持*/ + } + } + else + { + ;/*未配置倒切，正常输出驱动，认为在新建系统侧*/ + } + } + /*道岔驱动状态更新*/ for (ii = 0u; ii < switchCurSum; ii++) { @@ -5271,7 +5305,7 @@ void SwitchRelayToDeviceStateProc(void) switchId = GetSwitchId(ii); /*获取道岔ID*/ - if ((0u != switchId) && (switchId < SWITCH_SUM_MAX)) + if ((0u != switchId) && (SWITCH_SUM_MAX > switchId)) { belongCiId = GetSwitchBelongCiId(switchId); /*获取道岔所属联锁ID*/ @@ -5286,15 +5320,6 @@ void SwitchRelayToDeviceStateProc(void) ZFbRelayId = GetSwitchZFbRelayId(switchId); /*获取道岔总反位表示继电器ID*/ DFHRelayId = GetSwitchDFHRelayId(switchId); /*获取道岔DFH继电器ID*/ - if (REVERSE_MODE_SHADOW == chTiocSysMode) - { - /*影子模式下使用影子模式继电器*/ - DbRelayId = GetSwitchShadowDbRelayId(switchId); - FbRelayId = GetSwitchShadowFbRelayId(switchId); - ZDbRelayId = DbRelayId; - ZFbRelayId = FbRelayId; - DFHRelayId = 0u; - } /*更新道岔位置*/ YcRelayState = GetRelayCollState(YcRelayId); /*道岔允操继电器状态*/ DbRelayState = GetRelayCollState(DbRelayId); /*道岔定表继电器状态*/ @@ -7125,7 +7150,6 @@ void PsdRelayToDeviceStateProc(void) { ; } - } } @@ -7313,7 +7337,11 @@ UINT8 PsdDeviceToRelayStateProc(void) UINT8 relayFlag = CI_ERROR; UINT8 chKeepCloseType = FUNC_SWITCH_OFF; UINT8 cFuncRet = 0u; - + UINT16 trainZeroSpeedRelayId = 0U; /*列车非零速继电器ID*/ + UINT8 chTrainZeroSpeedState = 0U; /*非零速状态*/ + UINT32 curCycle = 0U; + UINT16 wReverseBoard = 0U; + UINT8 chReverseState = 0U; vobcInterFlag = GetCiFunctionSwitchConfig(VOBC_INTERFACE_IDENTITY);/*获取VOBC接口标识*/ @@ -7324,246 +7352,302 @@ UINT8 PsdDeviceToRelayStateProc(void) psdVirtualState = GetPsdVirtualAttribute(psdId); if (PSD_VIRTUAL_ATTR_NO == psdVirtualState) {/*非虚拟屏蔽门才驱动相关继电器*/ - psdEditGroupInfo = GetPsdEditGroupInfoFromPsdData(psdId); - /*编组定义统一化处理*/ - if ((LINE_HLHT == vobcInterFlag) || (LINE_FAOHLHT == vobcInterFlag) || (LINE_FAOHLHT_ONESELF == vobcInterFlag) || (LINE_FAOHLHT_ONESELFSECOND == vobcInterFlag)) + wReverseBoard = GetPsdRelateReverseBoardId(psdId); + chReverseState = GetReverseBoardState(wReverseBoard); + if((0U == wReverseBoard)||(REVERSE_STATE_NEW_SYSTEM == chReverseState)) { - /*互联互通和FAO互联互通的编组信息由VOBC发送*/ - } - else if (LINE_FAO == vobcInterFlag) - { - if (PSD_FOUR_EDIT_GROUP_FAO_YF == psdEditGroupInfo)/*燕房线4编组*/ + psdEditGroupInfo = GetPsdEditGroupInfoFromPsdData(psdId); + /*编组定义统一化处理*/ + if ((LINE_HLHT == vobcInterFlag) || (LINE_FAOHLHT == vobcInterFlag) || (LINE_FAOHLHT_ONESELF == vobcInterFlag) || (LINE_FAOHLHT_ONESELFSECOND == vobcInterFlag)) { - psdEditGroupInfo = PSD_FOUR_EDIT_GROUP; + /*互联互通和FAO互联互通的编组信息由VOBC发送*/ } - else if (PSD_SIX_EDIT_GROUP_FAO_YF == psdEditGroupInfo)/*燕房线6编组*/ + else if (LINE_FAO == vobcInterFlag) { - psdEditGroupInfo = PSD_SIX_EDIT_GROUP; + if (PSD_FOUR_EDIT_GROUP_FAO_YF == psdEditGroupInfo)/*燕房线4编组*/ + { + psdEditGroupInfo = PSD_FOUR_EDIT_GROUP; + } + else if (PSD_SIX_EDIT_GROUP_FAO_YF == psdEditGroupInfo)/*燕房线6编组*/ + { + psdEditGroupInfo = PSD_SIX_EDIT_GROUP; + } + else + { + /*编组信息错误*/ + } } else { - /*编组信息错误*/ + /*线路信息错误，do nothing*/ } - } - else - { - /*线路信息错误，do nothing*/ - } - if (PSD_FOUR_EDIT_GROUP == psdEditGroupInfo) - {/*四编组屏蔽门*/ - psdKMRelayId = GetFourGroupPsdOpenDrvRelayId(psdId); - } - else if (PSD_SIX_EDIT_GROUP == psdEditGroupInfo) - {/*六编组屏蔽门*/ - psdKMRelayId = GetSixGroupPsdOpenDrvRelayId(psdId); - } - else if (PSD_EIGHT_EDIT_GROUP == psdEditGroupInfo) - {/*八编组屏蔽门*/ - psdKMRelayId = GetEightGroupPsdOpenDrvRelayId(psdId); - } - else if (PSD_THREE_EDIT_GROUP == psdEditGroupInfo) - { - /*三编组屏蔽门*/ - psdKMRelayId = GetThreeGroupPsdOpenDrvRelayId(psdId); - } - else - {/*编组无效*/ - psdKMRelayId = 0u; - } - psdGMRelayId = GetPsdCloseDriveRelayId(psdId); - psdDriveState = GetPsdDriveState(psdId); - if (PSD_DRIVE_STATE_CLOSE == psdDriveState)/*驱动为关门*/ - { - relayFlag = SetRelayDriveState(psdGMRelayId, RELAY_DRIVE_STATE_UP); - if (CI_ERROR == relayFlag) - {/*关门继电器*/ - reVal = CI_ERROR; + if (PSD_FOUR_EDIT_GROUP == psdEditGroupInfo) + {/*四编组屏蔽门*/ + psdKMRelayId = GetFourGroupPsdOpenDrvRelayId(psdId); + } + else if (PSD_SIX_EDIT_GROUP == psdEditGroupInfo) + {/*六编组屏蔽门*/ + psdKMRelayId = GetSixGroupPsdOpenDrvRelayId(psdId); + } + else if (PSD_EIGHT_EDIT_GROUP == psdEditGroupInfo) + {/*八编组屏蔽门*/ + psdKMRelayId = GetEightGroupPsdOpenDrvRelayId(psdId); + } + else if (PSD_THREE_EDIT_GROUP == psdEditGroupInfo) + { + /*三编组屏蔽门*/ + psdKMRelayId = GetThreeGroupPsdOpenDrvRelayId(psdId); } else - { - tmpPsdKMRelayId = GetFourGroupPsdOpenDrvRelayId(psdId); - if (tmpPsdKMRelayId > 0u) - { - relayFlag = SetRelayDriveState(tmpPsdKMRelayId, RELAY_DRIVE_STATE_DOWN); - /*所有开门继电器驱落下*/ - if (CI_ERROR == relayFlag) - {/*开门继电器*/ - reVal = CI_ERROR; - } - - } - tmpPsdKMRelayId = GetSixGroupPsdOpenDrvRelayId(psdId); - if (tmpPsdKMRelayId > 0u) - { - relayFlag = SetRelayDriveState(tmpPsdKMRelayId, RELAY_DRIVE_STATE_DOWN); - /*所有开门继电器驱落下*/ - if (CI_ERROR == relayFlag) - {/*开门继电器*/ - reVal = CI_ERROR; - } - } - - - tmpPsdKMRelayId = GetEightGroupPsdOpenDrvRelayId(psdId); - if (tmpPsdKMRelayId > 0u) - { - /*所有开门继电器驱落下*/ - relayFlag = SetRelayDriveState(tmpPsdKMRelayId, RELAY_DRIVE_STATE_DOWN); - if (CI_ERROR == relayFlag) - {/*开门继电器*/ - reVal = CI_ERROR; - } - } - tmpPsdKMRelayId = GetThreeGroupPsdOpenDrvRelayId(psdId); - if (tmpPsdKMRelayId > 0u) - { - /*所有开门继电器驱落下*/ - relayFlag = SetRelayDriveState(tmpPsdKMRelayId, RELAY_DRIVE_STATE_DOWN); - if (CI_ERROR == relayFlag) - {/*开门继电器*/ - reVal = CI_ERROR; - } - } - + {/*编组无效*/ + psdKMRelayId = 0u; } - } - else if (PSD_DRIVE_STATE_OPEN == psdDriveState)/*驱动为开门*/ - { - if (0u != psdKMRelayId) - {/*获取继电器有效*/ - /*修改前：互锁解除时不响应VOBC的开关PSD命令，对外驱动无效*/ - /*修改后：对外输出时不再判断是否互锁解除状态（需求变化）*/ - relayFlag = SetRelayDriveState(psdGMRelayId, RELAY_DRIVE_STATE_DOWN); + psdGMRelayId = GetPsdCloseDriveRelayId(psdId); + psdDriveState = GetPsdDriveState(psdId); + if (PSD_DRIVE_STATE_CLOSE == psdDriveState)/*驱动为关门*/ + { + relayFlag = SetRelayDriveState(psdGMRelayId, RELAY_DRIVE_STATE_UP); if (CI_ERROR == relayFlag) {/*关门继电器*/ reVal = CI_ERROR; } else { - relayFlag = SetRelayDriveState(psdKMRelayId, RELAY_DRIVE_STATE_UP); + tmpPsdKMRelayId = GetFourGroupPsdOpenDrvRelayId(psdId); + if (tmpPsdKMRelayId > 0u) + { + relayFlag = SetRelayDriveState(tmpPsdKMRelayId, RELAY_DRIVE_STATE_DOWN); + /*所有开门继电器驱落下*/ + if (CI_ERROR == relayFlag) + {/*开门继电器*/ + reVal = CI_ERROR; + } + + } + tmpPsdKMRelayId = GetSixGroupPsdOpenDrvRelayId(psdId); + if (tmpPsdKMRelayId > 0u) + { + relayFlag = SetRelayDriveState(tmpPsdKMRelayId, RELAY_DRIVE_STATE_DOWN); + /*所有开门继电器驱落下*/ + if (CI_ERROR == relayFlag) + {/*开门继电器*/ + reVal = CI_ERROR; + } + } + + + tmpPsdKMRelayId = GetEightGroupPsdOpenDrvRelayId(psdId); + if (tmpPsdKMRelayId > 0u) + { + /*所有开门继电器驱落下*/ + relayFlag = SetRelayDriveState(tmpPsdKMRelayId, RELAY_DRIVE_STATE_DOWN); + if (CI_ERROR == relayFlag) + {/*开门继电器*/ + reVal = CI_ERROR; + } + } + tmpPsdKMRelayId = GetThreeGroupPsdOpenDrvRelayId(psdId); + if (tmpPsdKMRelayId > 0u) + { + /*所有开门继电器驱落下*/ + relayFlag = SetRelayDriveState(tmpPsdKMRelayId, RELAY_DRIVE_STATE_DOWN); + if (CI_ERROR == relayFlag) + {/*开门继电器*/ + reVal = CI_ERROR; + } + } + + } + } + else if (PSD_DRIVE_STATE_OPEN == psdDriveState)/*驱动为开门*/ + { + if (0u != psdKMRelayId) + {/*获取继电器有效*/ + /*修改前：互锁解除时不响应VOBC的开关PSD命令，对外驱动无效*/ + /*修改后：对外输出时不再判断是否互锁解除状态（需求变化）*/ + relayFlag = SetRelayDriveState(psdGMRelayId, RELAY_DRIVE_STATE_DOWN); if (CI_ERROR == relayFlag) - {/*开门继电器*/ + {/*关门继电器*/ reVal = CI_ERROR; } + else + { + relayFlag = SetRelayDriveState(psdKMRelayId, RELAY_DRIVE_STATE_UP); + if (CI_ERROR == relayFlag) + {/*开门继电器*/ + reVal = CI_ERROR; + } + } + + } - - } - } - else if (PSD_DRIVE_STATE_INVALID == psdDriveState) - {/*驱动无效*/ - chKeepCloseType = GetCiFunctionSwitchConfig(FUNC_PSD_KEEP_CLOSE_TYPE); - if (FUNC_SWITCH_ON == chKeepCloseType) - { - /*获取PSD打开关闭状态*/ - cFuncRet = GetPsdState(psdId); - if (PSD_STATE_OPEN == cFuncRet) + else if (PSD_DRIVE_STATE_INVALID == psdDriveState) + {/*驱动无效*/ + chKeepCloseType = GetCiFunctionSwitchConfig(FUNC_PSD_KEEP_CLOSE_TYPE); + if (FUNC_SWITCH_ON == chKeepCloseType) { - ctmpPsdGMRelayState = RELAY_DRIVE_STATE_DOWN; - ctmpPsdKMRelayState = RELAY_DRIVE_STATE_UP; + /*获取PSD打开关闭状态*/ + cFuncRet = GetPsdState(psdId); + if (PSD_STATE_OPEN == cFuncRet) + { + ctmpPsdGMRelayState = RELAY_DRIVE_STATE_DOWN; + ctmpPsdKMRelayState = RELAY_DRIVE_STATE_UP; + } + else + { + ctmpPsdGMRelayState = RELAY_DRIVE_STATE_UP ; + ctmpPsdKMRelayState = RELAY_DRIVE_STATE_DOWN; + } + + } + relayFlag = SetRelayDriveState(psdGMRelayId, ctmpPsdGMRelayState); + + if (CI_ERROR == relayFlag) + {/*关门继电器*/ + reVal = CI_ERROR; } else { - ctmpPsdGMRelayState = RELAY_DRIVE_STATE_UP ; - ctmpPsdKMRelayState = RELAY_DRIVE_STATE_DOWN; + tmpPsdKMRelayId = GetFourGroupPsdOpenDrvRelayId(psdId); + if (tmpPsdKMRelayId > 0u) + { + /*所有开门继电器驱落下*/ + relayFlag = SetRelayDriveState(tmpPsdKMRelayId, ctmpPsdKMRelayState); + if (CI_ERROR == relayFlag) + {/*开门继电器*/ + reVal = CI_ERROR; + } + + } + tmpPsdKMRelayId = GetSixGroupPsdOpenDrvRelayId(psdId); + if (tmpPsdKMRelayId > 0u) + { + /*所有开门继电器驱落下*/ + relayFlag = SetRelayDriveState(tmpPsdKMRelayId, ctmpPsdKMRelayState); + if (CI_ERROR == relayFlag) + {/*开门继电器*/ + reVal = CI_ERROR; + } + } + + + tmpPsdKMRelayId = GetEightGroupPsdOpenDrvRelayId(psdId); + if (tmpPsdKMRelayId > 0u) + { + /*所有开门继电器驱落下*/ + relayFlag = SetRelayDriveState(tmpPsdKMRelayId, ctmpPsdKMRelayState); + if (CI_ERROR == relayFlag) + {/*开门继电器*/ + reVal = CI_ERROR; + } + } + tmpPsdKMRelayId = GetThreeGroupPsdOpenDrvRelayId(psdId); + if (tmpPsdKMRelayId > 0u) + { + /*所有开门继电器驱落下*/ + relayFlag = SetRelayDriveState(tmpPsdKMRelayId, ctmpPsdKMRelayState); + if (CI_ERROR == relayFlag) + {/*开门继电器*/ + reVal = CI_ERROR; + } + } } - - } - relayFlag = SetRelayDriveState(psdGMRelayId, ctmpPsdGMRelayState); - - if (CI_ERROR == relayFlag) - {/*关门继电器*/ - reVal = CI_ERROR; } else - { - tmpPsdKMRelayId = GetFourGroupPsdOpenDrvRelayId(psdId); - if (tmpPsdKMRelayId > 0u) - { - /*所有开门继电器驱落下*/ - relayFlag = SetRelayDriveState(tmpPsdKMRelayId, ctmpPsdKMRelayState); - if (CI_ERROR == relayFlag) - {/*开门继电器*/ - reVal = CI_ERROR; - } - - } - tmpPsdKMRelayId = GetSixGroupPsdOpenDrvRelayId(psdId); - if (tmpPsdKMRelayId > 0u) - { - /*所有开门继电器驱落下*/ - relayFlag = SetRelayDriveState(tmpPsdKMRelayId, ctmpPsdKMRelayState); - if (CI_ERROR == relayFlag) - {/*开门继电器*/ - reVal = CI_ERROR; - } - } - - - tmpPsdKMRelayId = GetEightGroupPsdOpenDrvRelayId(psdId); - if (tmpPsdKMRelayId > 0u) - { - /*所有开门继电器驱落下*/ - relayFlag = SetRelayDriveState(tmpPsdKMRelayId, ctmpPsdKMRelayState); - if (CI_ERROR == relayFlag) - {/*开门继电器*/ - reVal = CI_ERROR; - } - } - tmpPsdKMRelayId = GetThreeGroupPsdOpenDrvRelayId(psdId); - if (tmpPsdKMRelayId > 0u) - { - /*所有开门继电器驱落下*/ - relayFlag = SetRelayDriveState(tmpPsdKMRelayId, ctmpPsdKMRelayState); - if (CI_ERROR == relayFlag) - {/*开门继电器*/ - reVal = CI_ERROR; - } - } + {/*不应出现的值*/ + reVal = CI_ERROR; } - } - else - {/*不应出现的值*/ - reVal = CI_ERROR; - } - if ((LINE_FAOHLHT == vobcInterFlag)||(LINE_CC == vobcInterFlag) || (LINE_FAOHLHT_ONESELF == vobcInterFlag) || (LINE_FAOHLHT_ONESELFSECOND == vobcInterFlag)) - {/*当前只有互联互通FAO线路有间隙探测功能*/ - /*联锁根据VOBC启动间隙探测命令和停止间隙探测命令来驱动相应继电器*/ - startJXTCRelayId = GetPsdDetStartRelayId(psdId); /*获取启动间隙探测继电器ID*/ - stopJXTCRelayId = GetPsdDetStopRelayId(psdId); /*获取停止间隙探测继电器ID*/ - JXCTInterfaceType = GetCiFunctionSwitchConfig(FUNC_JXTC_INTERFACE_MODE);/*获取接口方式*/ - /*启动间隙探测继电器ID有效*/ - if ((0u != startJXTCRelayId) && (0u != stopJXTCRelayId)) - { - /*采用脉冲*/ - if (FUNC_SWITCH_ON == JXCTInterfaceType) + if ((LINE_FAOHLHT == vobcInterFlag)||(LINE_CC == vobcInterFlag) || (LINE_FAOHLHT_ONESELF == vobcInterFlag) || (LINE_FAOHLHT_ONESELFSECOND == vobcInterFlag)) + {/*当前只有互联互通FAO线路有间隙探测功能*/ + /*联锁根据VOBC启动间隙探测命令和停止间隙探测命令来驱动相应继电器*/ + startJXTCRelayId = GetPsdDetStartRelayId(psdId); /*获取启动间隙探测继电器ID*/ + stopJXTCRelayId = GetPsdDetStopRelayId(psdId); /*获取停止间隙探测继电器ID*/ + JXCTInterfaceType = GetCiFunctionSwitchConfig(FUNC_JXTC_INTERFACE_MODE);/*获取接口方式*/ + /*启动间隙探测继电器ID有效*/ + if ((0u != startJXTCRelayId) && (0u != stopJXTCRelayId)) { - /*处理启动和停止驱动*/ - ProcessJXTCPulseInterfStartDrv(startJXTCRelayId, stopJXTCRelayId, psdId); - ProcessJXTCPulseInterfStopDrv(startJXTCRelayId, stopJXTCRelayId, psdId); - - } - /*电平模式*/ - else - { - /* Vobc给联锁发的启动、停止命令，联锁去驱动对应继电器。*/ - JXTCStartState = GetStartDetectionState(psdId); - JXTCStopState = GetStopDetectionState(psdId); - if (JXTC_START_DETECTION_YES == JXTCStartState) + /*采用脉冲*/ + if (FUNC_SWITCH_ON == JXCTInterfaceType) { - if (0u == GetStartDetectionCycNum(psdId)) - {/*若未计时，则设置驱动启动探测继电器周期*/ - SetStartDetectionCycNum(psdId, Get2oo2CurCycleNum()); - } - relayFlag = SetRelayDriveState(startJXTCRelayId, RELAY_DRIVE_STATE_UP); - if (CI_ERROR == relayFlag) - {/*启动探测继电器吸起*/ - reVal = CI_ERROR; + /*处理启动和停止驱动*/ + ProcessJXTCPulseInterfStartDrv(startJXTCRelayId, stopJXTCRelayId, psdId); + ProcessJXTCPulseInterfStopDrv(startJXTCRelayId, stopJXTCRelayId, psdId); + + } + /*电平模式*/ + else + { + /* Vobc给联锁发的启动、停止命令，联锁去驱动对应继电器。*/ + JXTCStartState = GetStartDetectionState(psdId); + JXTCStopState = GetStopDetectionState(psdId); + if (JXTC_START_DETECTION_YES == JXTCStartState) + { + if (0u == GetStartDetectionCycNum(psdId)) + {/*若未计时，则设置驱动启动探测继电器周期*/ + SetStartDetectionCycNum(psdId, Get2oo2CurCycleNum()); + } + relayFlag = SetRelayDriveState(startJXTCRelayId, RELAY_DRIVE_STATE_UP); + if (CI_ERROR == relayFlag) + {/*启动探测继电器吸起*/ + reVal = CI_ERROR; + } + else + { + relayFlag = SetRelayDriveState(stopJXTCRelayId, RELAY_DRIVE_STATE_DOWN); + if (CI_ERROR == relayFlag) + {/*停止探测继电器落下*/ + reVal = CI_ERROR; + } + } } else { + SetStartDetectionCycNum(psdId, 0u); /*清除间隙探测开始时间*/ + relayFlag = SetRelayDriveState(startJXTCRelayId, RELAY_DRIVE_STATE_DOWN); + if (CI_ERROR == relayFlag) + {/*启动探测继电器落下*/ + reVal = CI_ERROR; + } + } + + /*停止间隙探测继电器ID有效*/ + if (JXTC_STOP_DETECTION_YES == JXTCStopState) + { /*停止探测状态时，设置停止探测继电器吸起*/ + if (0u == GetStopDetectionCycNum(psdId)) + {/*若未计时，则设置驱动停止探测继电器周期*/ + SetStopDetectionCycNum(psdId, Get2oo2CurCycleNum()); + } + else + { + + } + relayFlag = SetRelayDriveState(stopJXTCRelayId, RELAY_DRIVE_STATE_UP); + if (CI_ERROR == relayFlag) + {/*停止探测继电器吸起*/ + reVal = CI_ERROR; + } + else + { + relayFlag = SetRelayDriveState(startJXTCRelayId, RELAY_DRIVE_STATE_DOWN); + if (CI_ERROR == relayFlag) + {/*启动探测继电器落下*/ + reVal = CI_ERROR; + } + } + } + else + { + if (CI_TIME_OUT == SystemOverTimeCheck(GetStopDetectionCycNum(psdId), GetwJXTCStopDetectTime())) + { + SetStopDetectionCycNum(psdId, 0u); /*清除间隙探测停止时间*/ + } + else + { + /*未到时间不处理*/ + } relayFlag = SetRelayDriveState(stopJXTCRelayId, RELAY_DRIVE_STATE_DOWN); if (CI_ERROR == relayFlag) {/*停止探测继电器落下*/ @@ -7571,93 +7655,121 @@ UINT8 PsdDeviceToRelayStateProc(void) } } } - else - { - SetStartDetectionCycNum(psdId, 0u); /*清除间隙探测开始时间*/ - relayFlag = SetRelayDriveState(startJXTCRelayId, RELAY_DRIVE_STATE_DOWN); + } + + vobcDoorStateRelayId = GetPsdDoorStateRelayId(psdId); /*获取车门关门状态继电器ID*/ + if (0u != vobcDoorStateRelayId) + {/*获取车门关门状态继电器ID有效*/ + doorState = GetVOBCDoorState(psdId); + if (PSD_DOOR_CLOSEDANDLOCKED_VALID == doorState) + {/*车门关门状态为关闭且锁闭*/ + relayFlag = SetRelayDriveState(vobcDoorStateRelayId, RELAY_DRIVE_STATE_UP); if (CI_ERROR == relayFlag) - {/*启动探测继电器落下*/ + {/*启动车门关门继电器*/ reVal = CI_ERROR; } } - - /*停止间隙探测继电器ID有效*/ - if (JXTC_STOP_DETECTION_YES == JXTCStopState) - { /*停止探测状态时，设置停止探测继电器吸起*/ - if (0u == GetStopDetectionCycNum(psdId)) - {/*若未计时，则设置驱动停止探测继电器周期*/ - SetStopDetectionCycNum(psdId, Get2oo2CurCycleNum()); - } - else - { - - } - relayFlag = SetRelayDriveState(stopJXTCRelayId, RELAY_DRIVE_STATE_UP); + else if (PSD_DOOR_CLOSEDANDLOCKED_INVALID == doorState) + {/*车门关门状态为非关闭且锁闭*/ + relayFlag = SetRelayDriveState(vobcDoorStateRelayId, RELAY_DRIVE_STATE_DOWN); if (CI_ERROR == relayFlag) - {/*停止探测继电器吸起*/ + {/*停止车门关门继电器*/ reVal = CI_ERROR; } - else - { - relayFlag = SetRelayDriveState(startJXTCRelayId, RELAY_DRIVE_STATE_DOWN); + } + else + { + /*车门关门状态无效无操作继电器*/ + } + } + /*站台清客，闪灯稳灯处理*/ + StationCearPassenagerProcess(psdId); + /*by cgh 成都四线清客需求--清客确认箱发车按钮指示灯闪灯处理*/ + PsdCleFarePDBFlashProcess(psdId); + /*成都13、27、30三线再开门/再关门按钮表示灯处理*/ + PsdOpenAndCloseBsdProc(psdId); + /*by cgh 屏蔽门视频清客处理*/ + PsdVideoQkDriveStateProc(psdId); + } + else if (LINE_HLHT == vobcInterFlag) + {/*厦门3 间隙探测继电器处理*/ + trainZeroSpeedRelayId = GetPsdDetStartRelayId(psdId); /*获取列车非零零速继电器ID，复用启动探测继电器*/ + stopJXTCRelayId = GetPsdDetStopRelayId(psdId); /*获取停止间隙探测继电器ID*/ + JXCTInterfaceType = GetCiFunctionSwitchConfig(FUNC_JXTC_INTERFACE_MODE);/*获取接口方式*/ + /*启动间隙探测继电器ID有效*/ + if ((0u != trainZeroSpeedRelayId) && (0u != stopJXTCRelayId)) + { + /*采用脉冲*/ + if (FUNC_SWITCH_ON == JXCTInterfaceType) + { + /*厦门3 间隙探测相关继电器电平式*/ + } + /*电平模式*/ + else + { + chTrainZeroSpeedState = GetTrainZeroSpeedState(psdId); + JXTCStopState = GetStopDetectionState(psdId); + if (PSD_TRAIN_ZERO_SPEED_NO == chTrainZeroSpeedState) + {/*列车非零速*/ + relayFlag = SetRelayDriveState(trainZeroSpeedRelayId, RELAY_DRIVE_STATE_UP); /*非零速继电器吸起*/ if (CI_ERROR == relayFlag) - {/*启动探测继电器落下*/ + { reVal = CI_ERROR; } + else + { + /*不处理*/ + } + } + else + {/*列车零速*/ + relayFlag = SetRelayDriveState(trainZeroSpeedRelayId, RELAY_DRIVE_STATE_DOWN); /*非零速继电器落下*/ + if (CI_ERROR == relayFlag) + { + reVal = CI_ERROR; + } + else + { + /*不处理*/ + } + } + + /*停止间隙探测继电器ID有效*/ + if (JXTC_STOP_DETECTION_YES == JXTCStopState) + { /*停止探测状态时，设置停止探测继电器吸起*/ + relayFlag = SetRelayDriveState(stopJXTCRelayId, RELAY_DRIVE_STATE_UP); /*停止探测继电器吸起*/ + if (CI_ERROR == relayFlag) + { + reVal = CI_ERROR; + } + else + { + /*不处理*/ + } + } + else + { + relayFlag = SetRelayDriveState(stopJXTCRelayId, RELAY_DRIVE_STATE_DOWN); /*停止探测继电器落下*/ + if (CI_ERROR == relayFlag) + { + reVal = CI_ERROR; + } + else + { + /*不处理*/ + } } } - else - { - if (CI_TIME_OUT == SystemOverTimeCheck(GetStopDetectionCycNum(psdId), GetwJXTCStopDetectTime())) - { - SetStopDetectionCycNum(psdId, 0u); /*清除间隙探测停止时间*/ - } - else - { - /*未到时间不处理*/ - } - relayFlag = SetRelayDriveState(stopJXTCRelayId, RELAY_DRIVE_STATE_DOWN); - if (CI_ERROR == relayFlag) - {/*停止探测继电器落下*/ - reVal = CI_ERROR; - } - } } } - - vobcDoorStateRelayId = GetPsdDoorStateRelayId(psdId); /*获取车门关门状态继电器ID*/ - if (0u != vobcDoorStateRelayId) - {/*获取车门关门状态继电器ID有效*/ - doorState = GetVOBCDoorState(psdId); - if (PSD_DOOR_CLOSEDANDLOCKED_VALID == doorState) - {/*车门关门状态为关闭且锁闭*/ - relayFlag = SetRelayDriveState(vobcDoorStateRelayId, RELAY_DRIVE_STATE_UP); - if (CI_ERROR == relayFlag) - {/*启动车门关门继电器*/ - reVal = CI_ERROR; - } - } - else if (PSD_DOOR_CLOSEDANDLOCKED_INVALID == doorState) - {/*车门关门状态为非关闭且锁闭*/ - relayFlag = SetRelayDriveState(vobcDoorStateRelayId, RELAY_DRIVE_STATE_DOWN); - if (CI_ERROR == relayFlag) - {/*停止车门关门继电器*/ - reVal = CI_ERROR; - } - } - else - { - /*车门关门状态无效无操作继电器*/ - } + else + { + /*不处理*/ } - /*站台清客，闪灯稳灯处理*/ - StationCearPassenagerProcess(psdId); - /*by cgh 成都四线清客需求--清客确认箱发车按钮指示灯闪灯处理*/ - PsdCleFarePDBFlashProcess(psdId); - /*成都13、27、30三线再开门/再关门按钮表示灯处理*/ - PsdOpenAndCloseBsdProc(psdId); - /*by cgh 屏蔽门视频清客处理*/ - PsdVideoQkDriveStateProc(psdId); + } + else + { + ;/*配置有倒切且非新设系统：输出驱动无效，周期已设置所有继电器驱动无效*/ } } else @@ -11529,6 +11641,8 @@ void ConnectLineRelayToDevStateProc(void) UINT8 DxrelayColleState = 0u; OcConnetDataCfgStruct* pOcConnetDataCfgStru = NULL; UINT8 chBlocOpenColor = 0U; + UINT16 wFirstDsRealy = 0U; + UINT8 chFirstDsColleState = 0U; /*获取配置信息*/ ocConnetDataDevNum = GetOcConnetDataDevNum(); @@ -11555,67 +11669,85 @@ void ConnectLineRelayToDevStateProc(void) LxrelayId = GetSignalLxRelayId(devId); YxrelayId = GetSignalYxRelayId(devId); DxrelayId = GetSignalDxRelayId(devId); - + wFirstDsRealy = GetSignalFirstDsRelayId(devId); + LxrelayColleState = GetRelayCollState(LxrelayId); YxrelayColleState = GetRelayCollState(YxrelayId); DxrelayColleState = GetRelayCollState(DxrelayId); - - if (RELAY_STATE_UP == LxrelayColleState) + if ((0U < wFirstDsRealy) && (RELAY_SUM_MAX > wFirstDsRealy)) { - /*对两个继电器都吸起的异常情况做防护*/ - if ((RELAY_STATE_UP == YxrelayColleState) || (RELAY_STATE_UP == DxrelayColleState)) + chFirstDsColleState = GetRelayCollState(wFirstDsRealy); + } + else + { + chFirstDsColleState = RELAY_STATE_UP; /*邻线未配置DJ，依据其他继电器显示颜色*/ + } + + if (RELAY_STATE_UP == chFirstDsColleState) + { + if (RELAY_STATE_UP == LxrelayColleState) { - /*设置红灯*/ - (void)SetSignalCurColor(devId, SIGNAL_SHOWCOLOUR_RED); - } - else - { - /*若配置后备开放颜色按照后备开放显示*/ - chBlocOpenColor = GetSignalBlockOpenColorValue(devId); - if (0U != chBlocOpenColor) + /*对两个继电器都吸起的异常情况做防护*/ + if ((RELAY_STATE_UP == YxrelayColleState) || (RELAY_STATE_UP == DxrelayColleState)) { - (void)SetSignalCurColor(devId, chBlocOpenColor); + /*设置红灯*/ + (void)SetSignalCurColor(devId, SIGNAL_SHOWCOLOUR_RED); } else { - /*设置黄灯*/ - (void)SetSignalCurColor(devId, SIGNAL_SHOWCOLOUR_YELLOW); + /*若配置后备开放颜色按照后备开放显示*/ + chBlocOpenColor = GetSignalBlockOpenColorValue(devId); + if (0U != chBlocOpenColor) + { + (void)SetSignalCurColor(devId, chBlocOpenColor); + } + else + { + /*设置黄灯*/ + (void)SetSignalCurColor(devId, SIGNAL_SHOWCOLOUR_YELLOW); + } } } - } - else if (RELAY_STATE_UP == YxrelayColleState) - { - /*对两个继电器都吸起的异常情况做防护*/ - if ((RELAY_STATE_UP == LxrelayColleState) || (RELAY_STATE_UP == DxrelayColleState)) + else if (RELAY_STATE_UP == YxrelayColleState) { - /*设置红灯*/ - (void)SetSignalCurColor(devId, SIGNAL_SHOWCOLOUR_RED); + /*对两个继电器都吸起的异常情况做防护*/ + if ((RELAY_STATE_UP == LxrelayColleState) || (RELAY_STATE_UP == DxrelayColleState)) + { + /*设置红灯*/ + (void)SetSignalCurColor(devId, SIGNAL_SHOWCOLOUR_RED); + } + else + { + /*设置红黄灯*/ + (void)SetSignalCurColor(devId, SIGNAL_SHOWCOLOUR_REDYELLOW); + } + } + else if (RELAY_STATE_UP == DxrelayColleState) + { + /*对两个继电器都吸起的异常情况做防护*/ + if ((RELAY_STATE_UP == LxrelayColleState) || (RELAY_STATE_UP == YxrelayColleState)) + { + /*设置红灯*/ + (void)SetSignalCurColor(devId, SIGNAL_SHOWCOLOUR_RED); + } + else + { + /*设置白灯*/ + (void)SetSignalCurColor(devId, SIGNAL_SHOWCOLOUR_WHITE); + } } else - { - /*设置红黄灯*/ - (void)SetSignalCurColor(devId, SIGNAL_SHOWCOLOUR_REDYELLOW); - } - } - else if (RELAY_STATE_UP == DxrelayColleState) - { - /*对两个继电器都吸起的异常情况做防护*/ - if ((RELAY_STATE_UP == LxrelayColleState) || (RELAY_STATE_UP == YxrelayColleState)) { /*设置红灯*/ (void)SetSignalCurColor(devId, SIGNAL_SHOWCOLOUR_RED); } - else - { - /*设置白灯*/ - (void)SetSignalCurColor(devId, SIGNAL_SHOWCOLOUR_WHITE); - } } else { - /*设置红灯*/ - (void)SetSignalCurColor(devId, SIGNAL_SHOWCOLOUR_RED); + /*设置红断*/ + (void)SetSignalCurColor(devId, SIGNAL_SHOWCOLOUR_REDBREAK); } + } } } @@ -11825,6 +11957,13 @@ void UpdateConnectDriveRelayOutput(void) UINT8 checkTimeState = CI_TIME_NO; OcConnetDataCfgStruct* pOcConnetDataCfgStru = NULL; UINT8 ciToAtsSendFlag = 0U; + UINT16 wMainRelay = 0U; + UINT16 wAckRelay = 0U; + UINT16 wCMainRelay = 0U; + UINT8 chCheckFlag = 0U; + UINT8 chSigState = 0U; + UINT16 wFirseDsRelay = 0U; + /*获取配置信息*/ ocConnetDataDevNum = GetOcConnetDataDevNum(); @@ -11857,16 +11996,22 @@ void UpdateConnectDriveRelayOutput(void) LxrelayId = GetSignalLxDrvRelayId(devId); YxrelayId = GetSignalYxDrvRelayId(devId); DxrelayId = GetSignalDxDrvRelayId(devId); - + wMainRelay = GetSignalMainDrvRelayId(devId); + wAckRelay = GetSignalAckDrvRelayId(devId); + wCMainRelay = GetSignalCMainDrvRelayId(devId); + wFirseDsRelay = GetSignalFirstDsDrvRelayId(devId); /*信号开放*/ if (SIGNAL_OPEN == devState) { if (SIGNAL_SHOWCOLOUR_REDYELLOW == signalColor) { - /*驱动YXJ吸起*/ + /*驱动YXJ吸起/次控继电器吸起*/ (void)SetRelayDriveState(YxrelayId, RELAY_DRIVE_STATE_UP); (void)SetRelayDriveState(LxrelayId, RELAY_DRIVE_STATE_DOWN); (void)SetRelayDriveState(DxrelayId, RELAY_DRIVE_STATE_DOWN); + (void)SetRelayDriveState(wAckRelay, RELAY_DRIVE_STATE_UP); + (void)SetRelayDriveState(wMainRelay, RELAY_DRIVE_STATE_DOWN); + (void)SetRelayDriveState(wCMainRelay, RELAY_DRIVE_STATE_DOWN); } else if ((SIGNAL_SHOWCOLOUR_WHITE == signalColor) || (SIGNAL_SHOWCOLOUR_RED_WHITE == signalColor)) { @@ -11874,23 +12019,55 @@ void UpdateConnectDriveRelayOutput(void) (void)SetRelayDriveState(DxrelayId, RELAY_DRIVE_STATE_UP); (void)SetRelayDriveState(LxrelayId, RELAY_DRIVE_STATE_DOWN); (void)SetRelayDriveState(YxrelayId, RELAY_DRIVE_STATE_DOWN); + (void)SetRelayDriveState(wMainRelay, RELAY_DRIVE_STATE_DOWN); + (void)SetRelayDriveState(wAckRelay, RELAY_DRIVE_STATE_DOWN); + (void)SetRelayDriveState(wCMainRelay, RELAY_DRIVE_STATE_DOWN); } else { - /*驱动LXJ吸起*/ + /*驱动LXJ吸起/次控继电器吸起/主控继电器吸起*/ (void)SetRelayDriveState(LxrelayId, RELAY_DRIVE_STATE_UP); (void)SetRelayDriveState(YxrelayId, RELAY_DRIVE_STATE_DOWN); (void)SetRelayDriveState(DxrelayId, RELAY_DRIVE_STATE_DOWN); + (void)SetRelayDriveState(wMainRelay, RELAY_DRIVE_STATE_UP); + (void)SetRelayDriveState(wAckRelay, RELAY_DRIVE_STATE_UP); + + /*复杂主控继电器驱动*/ + chCheckFlag = GetCMainRelayDriveState(wCMainRelay,devId); + if (CI_SUCCESS == chCheckFlag) + { + (void)SetRelayDriveState(wCMainRelay, RELAY_DRIVE_STATE_UP); + } + else + { + (void)SetRelayDriveState(wCMainRelay, RELAY_DRIVE_STATE_DOWN); + } } } else { - /*驱动LXJ,YXJ,DXJ落下*/ + /*驱动落下*/ (void)SetRelayDriveState(LxrelayId, RELAY_DRIVE_STATE_DOWN); (void)SetRelayDriveState(YxrelayId, RELAY_DRIVE_STATE_DOWN); (void)SetRelayDriveState(DxrelayId, RELAY_DRIVE_STATE_DOWN); + (void)SetRelayDriveState(wMainRelay, RELAY_DRIVE_STATE_DOWN); + (void)SetRelayDriveState(wAckRelay, RELAY_DRIVE_STATE_DOWN); + (void)SetRelayDriveState(wCMainRelay, RELAY_DRIVE_STATE_DOWN); } + /*驱动 1DJ 状态*/ + chSigState = GetSignalCurColor(devId); + + if (SIGNAL_SHOWCOLOUR_REDBREAK == chSigState) + { + (void)SetRelayDriveState(wFirseDsRelay, RELAY_DRIVE_STATE_DOWN); + } + else + { + (void)SetRelayDriveState(wFirseDsRelay, RELAY_DRIVE_STATE_UP); + } + + /*检查驱采是否一致，不一致报混线*/ LxCollerelayId = GetSignalLxRelayId(devId); ProcessCoupleRelayHunXianState(LxrelayId, LxCollerelayId); @@ -15286,10 +15463,24 @@ void SetAllSingleSwitchCurPosition(UINT16 switchCurSum) UINT16 switchId = 0U; /*道岔ID*/ UINT8 belongCiId = 0U; /*道岔所属联锁ID*/ UINT16 ii = 0U; /*循环索引*/ + UINT8 jj = 0U; /*循环索引*/ UINT8 chSwitchColPos = SWITCH_POSITION_INVALID; /*道岔当前位置*/ UINT8 chSwitchTolPos = SWITCH_POSITION_INVALID; /*道岔容忍后位置*/ UINT8 ocId = 0u; UINT8 chLocalCiOCSswitch = 0u; + UINT8 RedunCollCfg = 0u; + UINT8 chMainOcCollPos = SWITCH_POSITION_INVALID; /*（道岔冗余采集）主控转辙机板的道岔位置*/ + UINT8 chRedunOcCollPos[SWITCH_REDUN_COLL_MAX] = { 0u }; /*（道岔冗余采集）OC采集自动开闭器的道岔位置*/ + UINT8 chRedunOcHunXianStt[SWITCH_REDUN_COLL_MAX] = { 0u }; /*（道岔冗余采集）OC采集自动开闭器混线状态*/ + UINT8 chRedunCollCombineStt[SWITCH_REDUN_COLL_MAX] = { 0u }; /*（道岔冗余采集）OC采集自动开闭器继电器状态组合*/ + + for (jj = 0u; jj < SWITCH_REDUN_COLL_MAX; jj++) + { + /*道岔冗余采集位置初始化成无效、未混线*/ + chRedunOcCollPos[jj] = SWITCH_POSITION_INVALID; + chRedunOcHunXianStt[jj] = RELAY_HUNXIAN_STATE_NO; + } + chLocalCiOCSswitch = GetLocalCiOCSswitch(); localCiId = GetSystemParaLocalCiId(); /*获取本机联锁ID*/ for (ii = 0U; ii < switchCurSum; ii++) @@ -15305,26 +15496,653 @@ void SetAllSingleSwitchCurPosition(UINT16 switchCurSum) if ((belongCiId == localCiId) && (0U != localCiId)) { - /*通过主控OC找到采集状态*/ - ocId = GetSwitchMainCotrolOCId(switchId); - if ((0u < ocId)|| (OC_S_OFF == chLocalCiOCSswitch)) - {/*当前有主控或OC-S开关关闭*/ - chSwitchColPos = GetOcSwitchState(switchId, ocId); - SetSwitchCollPos(switchId, chSwitchColPos); + /*冗余采集处理*/ + RedunCollCfg = GetSwitchRedunCollCfg(switchId); + if (REDUN_COLL_YES == RedunCollCfg) + { + /*具备道岔冗余采集*/ + /*获取主控转辙机板的采集位置*/ + chMainOcCollPos = GetMainOcSwitchColPos(switchId); + /*记录*/ + SetSwitchMainCollPos(switchId, chMainOcCollPos); + /*获取OC采集的自动开闭器接点位置*/ + for (jj = 0u; jj < SWITCH_REDUN_COLL_MAX; jj++) + { + chRedunOcCollPos[jj] = GetRedunSwitchColPos(switchId, jj, &chRedunOcHunXianStt[jj], &chRedunCollCombineStt[jj]); + } + + /*冗余采集融合处理*/ + chSwitchColPos = GetSwitchRedunFusionPos(switchId, chMainOcCollPos, chRedunOcCollPos, chRedunOcHunXianStt); + + /*冗余采集故障和混线处理*/ + for (jj = 0u; jj < SWITCH_REDUN_COLL_MAX; jj++) + { + SwitchRedunFaultProc(switchId, jj, chRedunOcCollPos[jj]); + SwitchRedunHunXianProc(switchId, jj, chRedunOcHunXianStt[jj], chRedunCollCombineStt[jj]); + /*记录*/ + SetSwitchRedunCurrHunXianStt(switchId, jj, chRedunOcHunXianStt[jj]); + } + + /*设置道岔采集位置*/ + SetSwitchCollPos(switchId, chSwitchColPos); + /*对锁闭道岔容忍，设置道岔单独位置*/ chSwitchTolPos = GetSwitchCollToleratePos(switchId); - SetSingleSwitchCurPosition(switchId, chSwitchTolPos);/*设置道岔单独位置*/ + SetSingleSwitchCurPosition(switchId, chSwitchTolPos); } else - {/*OCS开关打开且道岔当前无主控状态，则设置四开*/ - SetSwitchCollPos(switchId, SWITCH_POSITION_SIKAI);/*置采集位置为四开*/ - SetSingleSwitchCurPosition(switchId, SWITCH_POSITION_SIKAI);/*设置道岔单独位置*/ + { + /*不具备道岔冗余采集，直接从主控转辙机板获取*/ + /*通过主控OC找到采集状态*/ + ocId = GetSwitchMainCotrolOCId(switchId); + if ((0u < ocId) || (OC_S_OFF == chLocalCiOCSswitch)) + { + /*当前有主控或OC-S开关关闭*/ + chSwitchColPos = GetOcSwitchState(switchId, ocId); + SetSwitchCollPos(switchId, chSwitchColPos); + + chSwitchTolPos = GetSwitchCollToleratePos(switchId); + SetSingleSwitchCurPosition(switchId, chSwitchTolPos);/*设置道岔单独位置*/ + } + else + { + /*OCS开关打开且道岔当前无主控状态，则设置四开*/ + SetSwitchCollPos(switchId, SWITCH_POSITION_SIKAI);/*置采集位置为四开*/ + SetSingleSwitchCurPosition(switchId, SWITCH_POSITION_SIKAI);/*设置道岔单独位置*/ + } } } } } } +/* +* 功能描述：道岔冗余采集道岔位置当前混线判断 +* 参数说明：UINT8 cMainOcPos 主控转辙机板位置 +* UINT8 *pRedunPos OC/OC-S冗余采集位置 +* UINT8 *pHunXianStt OC/OC-S冗余采集混线状态 +* 返回值 ：两路冗余采集是否定反位冲突 CI_ERROR有冲突 CI_SUCCESS无冲突 +* 注意事项：本函数暂只支持SWITCH_REDUN_COLL_MAX为2，若修改宏值需重写 +*/ +static UINT8 SwitchRedunFusionHunXianProc(UINT8 cMainOcPos, const UINT8 *pRedunPos, INOUT UINT8 *pHunXianStt) +{ + UINT8 cConflictTag = CI_ERROR; + + if ((NULL == pRedunPos) || (NULL == pHunXianStt)) + { + /*入参非法*/ + } + else + { + cConflictTag = CI_SUCCESS; + + /*融合混线判断（用动表一致性判断前的位置）*/ + if (((SWITCH_POSITION_DINGWEI == cMainOcPos) && (SWITCH_POSITION_FANWEI == pRedunPos[0])) + || ((SWITCH_POSITION_FANWEI == cMainOcPos) && (SWITCH_POSITION_DINGWEI == pRedunPos[0]))) + { + /*主控转辙机板与道岔冗余采集存在定反表冲突，判冗余采集混线*/ + pHunXianStt[0] = RELAY_HUNXIAN_STATE_YES; + } + else + { + /*nothing*/ + } + + if (((SWITCH_POSITION_DINGWEI == cMainOcPos) && (SWITCH_POSITION_FANWEI == pRedunPos[1])) + || ((SWITCH_POSITION_FANWEI == cMainOcPos) && (SWITCH_POSITION_DINGWEI == pRedunPos[1]))) + { + /*主控转辙机板与道岔冗余采集存在定反表冲突，判冗余采集混线*/ + pHunXianStt[1] = RELAY_HUNXIAN_STATE_YES; + } + else + { + /*nothing*/ + } + + if (((SWITCH_POSITION_DINGWEI == pRedunPos[0]) && (SWITCH_POSITION_FANWEI == pRedunPos[1])) + || ((SWITCH_POSITION_FANWEI == pRedunPos[0]) && (SWITCH_POSITION_DINGWEI == pRedunPos[1]))) + { + /*记录冗余采集定反位冲突标志有效*/ + cConflictTag = CI_ERROR; + if ((SWITCH_POSITION_DINGWEI == cMainOcPos) || (SWITCH_POSITION_FANWEI == cMainOcPos)) + { + /*和主控转辙机板冲突的采集判混线，上面已处理*/ + } + else + { + /*两路道岔冗余采集之间存在定反位冲突，且主控转辙机板无表示，判两路冗余采集均混线*/ + pHunXianStt[0] = RELAY_HUNXIAN_STATE_YES; + pHunXianStt[1] = RELAY_HUNXIAN_STATE_YES; + } + } + else + { + /*nothing*/ + } + } + + return cConflictTag; +} + +/* +* 功能描述：道岔冗余采集道岔位置融合 +* 参数说明：UINT8 cMainOcPos 主控转辙机板位置 +* UINT8 *pRedunPos OC/OC-S冗余采集位置 +* UINT8 *pHunXianStt OC/OC-S冗余采集混线状态 +* 返回值 ：融合位置 +* 注意事项：本函数暂只支持SWITCH_REDUN_COLL_MAX为2，若修改宏值需重写 +*/ +static UINT8 GetSwitchRedunFusionPos(UINT16 switchId, UINT8 cMainOcPos, INOUT UINT8 *pRedunPos, INOUT UINT8 *pHunXianStt) +{ + UINT8 cFusionPos = SWITCH_POSITION_INVALID; + UINT8 cConflictTag = CI_ERROR; + UINT8 cSwitchLastDrvPos = 0u; + UINT32 dwDrvStartCyc = 0u; + UINT8 i = 0u; + UINT8 cHunXianRecovStt = 0u; + UINT8 RedunPosForFusion[SWITCH_REDUN_COLL_MAX] = { 0u }; + + if ((NULL == pRedunPos) || (NULL == pHunXianStt)) + { + /*入参非法*/ + } + else + { + /*冗余采集混线判断（定反互斥）*/ + cConflictTag = SwitchRedunFusionHunXianProc(cMainOcPos, pRedunPos, pHunXianStt); + + /*动表一致性判断*/ + cSwitchLastDrvPos = GetSwitchLastValidDrvPos(switchId); + dwDrvStartCyc = GetSwitchDriveStartCycNum(switchId); + for (i = 0u; i < SWITCH_REDUN_COLL_MAX; i++) + { + if (((SWITCH_POSITION_DINGWEI == pRedunPos[i]) && (SWITCH_DRIVE_POS_FANWEI == cSwitchLastDrvPos)) + || ((SWITCH_POSITION_FANWEI == pRedunPos[i]) && (SWITCH_DRIVE_POS_DINGWEI == cSwitchLastDrvPos))) + { + /*动表不一致*/ + if (0u < dwDrvStartCyc) + { + /*有驱动命令，移动中*/ + pRedunPos[i] = SWITCH_POSITION_MOVE; + } + else + { + /*无驱动命令，四开*/ + pRedunPos[i] = SWITCH_POSITION_SIKAI; + } + } + else + { + /*未发生动表不一致*/ + } + } + + /*混线的道岔以四开参与融合，这里用局部变量处理，是为了避免混线恢复当周期，无法将采集故障周期号清空，会多报一周期采集故障报警*/ + for (i = 0u; i < SWITCH_REDUN_COLL_MAX; i++) + { + cHunXianRecovStt = GetSwitchRedunHunXianRecovStt(switchId, i); + if (REDUN_HX_RECOV_ALL != cHunXianRecovStt) + { + RedunPosForFusion[i] = SWITCH_POSITION_SIKAI; + } + else + { + RedunPosForFusion[i] = pRedunPos[i]; + } + /*记录道岔位置*/ + SetSwitchRedunCollPos(switchId, i, RedunPosForFusion[i]); + } + + /*计算最终融合道岔位置*/ + cFusionPos = CalcRedunSwitchFinalFusionPos(cMainOcPos, RedunPosForFusion, cConflictTag); + } + + return cFusionPos; +} + +/* +* 功能描述：计算道岔冗余采集最终融合道岔位置 +* 参数说明：UINT8 cMainOcPos 主控转辙机板位置 +* UINT8 *pRedunPosForFusion OC/OC-S冗余采集位置 +* UINT8 cConflictTag 两路冗余采集是否定反位冲突 CI_ERROR有冲突 CI_SUCCESS无冲突 +* 返回值 ：最终融合道岔位置 +* 注意事项：本函数暂只支持SWITCH_REDUN_COLL_MAX为2，若修改宏值需重写 +*/ +static UINT8 CalcRedunSwitchFinalFusionPos(UINT8 cMainOcPos, const UINT8 *pRedunPosForFusion, UINT8 cConflictTag) +{ + UINT8 cFusionPos = SWITCH_POSITION_INVALID; /*融合道岔位置*/ + + if (NULL == pRedunPosForFusion) + { + /*入参非法*/ + } + else + { + if ((SWITCH_POSITION_DINGWEI == cMainOcPos) + || (SWITCH_POSITION_FANWEI == cMainOcPos) + || (SWITCH_POSITION_MOVE == cMainOcPos)) + { + /*主控转辙机板位置有效，融合位置使用主控转辙机板的位置*/ + cFusionPos = cMainOcPos; + } + else + { + /*否则检查是否存在冲突，先赋值为四开*/ + cFusionPos = SWITCH_POSITION_SIKAI; + if (CI_SUCCESS == cConflictTag) + { + /*无冲突，任一冗余采集有效位置即最终位置*/ + if ((SWITCH_POSITION_DINGWEI == pRedunPosForFusion[0]) || (SWITCH_POSITION_DINGWEI == pRedunPosForFusion[1])) + { + cFusionPos = SWITCH_POSITION_DINGWEI; + } + else if ((SWITCH_POSITION_FANWEI == pRedunPosForFusion[0]) || (SWITCH_POSITION_FANWEI == pRedunPosForFusion[1])) + { + cFusionPos = SWITCH_POSITION_FANWEI; + } + else if ((SWITCH_POSITION_MOVE == pRedunPosForFusion[0]) || (SWITCH_POSITION_MOVE == pRedunPosForFusion[1])) + { + cFusionPos = SWITCH_POSITION_MOVE; + } + else + { + /*道岔四开*/ + } + } + else + { + /*有冲突，道岔四开*/ + } + } + } + + return cFusionPos; +} + +/* +* 功能描述： 从主控转辙机板获取道岔位置 +* 参数说明： UINT16 switchId 道岔ID +* 返回值 ： 道岔位置 +*/ +static UINT8 GetMainOcSwitchColPos(UINT16 switchId) +{ + UINT8 ocId = 0u; + UINT8 chLocalCiOCSswitch = 0u; + UINT8 chSwitchColPos = SWITCH_POSITION_INVALID; /*道岔当前位置*/ + + chLocalCiOCSswitch = GetLocalCiOCSswitch(); + ocId = GetSwitchMainCotrolOCId(switchId); + if ((0u < ocId) || (OC_S_OFF == chLocalCiOCSswitch)) + { + /*当前有主控或OC-S开关关闭*/ + chSwitchColPos = GetOcSwitchState(switchId, ocId); + } + else + { + /*OCS开关打开且道岔当前无主控状态，则设置四开*/ + chSwitchColPos = SWITCH_POSITION_SIKAI; + } + + return chSwitchColPos; +} + +/* +* 功能描述：从冗余采集获取道岔位置 +* 参数说明：UINT16 switchId 道岔ID +* UINT8 ocIndex 下标 +* UINT8 *pHunXianStt 混线状态 +* 返回值 ：道岔位置 +*/ +static UINT8 GetRedunSwitchColPos(UINT16 switchId, UINT8 ocIndex, UINT8 *pHunXianStt, UINT8 *pCombineStt) +{ + UINT8 chSwitchColPos = SWITCH_POSITION_INVALID; /*道岔当前位置*/ + UINT16 wDBJ1RelayId = 0u; /*DBJ1继电器ID*/ + UINT16 wDBJ2RelayId = 0u; /*DBJ2继电器ID*/ + UINT16 wFBJ1RelayId = 0u; /*FBJ1继电器ID*/ + UINT16 wFBJ2RelayId = 0u; /*FBJ2继电器ID*/ + UINT8 cDBJ1CollState = 0u; /*DBJ1继电器状态*/ + UINT8 cDBJ2CollState = 0u; /*DBJ2继电器状态*/ + UINT8 cFBJ1CollState = 0u; /*FBJ1继电器状态*/ + UINT8 cFBJ2CollState = 0u; /*FBJ2继电器状态*/ + UINT8 cCombineCollState = 0u; /*DBJ1/2/FBJ1/2结合状态*/ + UINT32 dwSwitchDrvStartCyc = 0u; /*道岔驱动起始周期*/ + UINT8 cHunXianState = RELAY_HUNXIAN_STATE_NO; /*混线状态*/ + + /*获取冗余采集继电器ID和状态*/ + wDBJ1RelayId = GetSwitchRedunDBJ1RelayId(switchId, ocIndex); + wDBJ2RelayId = GetSwitchRedunDBJ2RelayId(switchId, ocIndex); + wFBJ1RelayId = GetSwitchRedunFBJ1RelayId(switchId, ocIndex); + wFBJ2RelayId = GetSwitchRedunFBJ2RelayId(switchId, ocIndex); + cDBJ1CollState = GetRelayCollState(wDBJ1RelayId); + cDBJ2CollState = GetRelayCollState(wDBJ2RelayId); + cFBJ1CollState = GetRelayCollState(wFBJ1RelayId); + cFBJ2CollState = GetRelayCollState(wFBJ2RelayId); + cCombineCollState = SwitchRedunCombineProc(cDBJ1CollState, cDBJ2CollState, cFBJ1CollState, cFBJ2CollState); + dwSwitchDrvStartCyc = GetSwitchDriveStartCycNum(switchId); + /*记录采集状态*/ + SetSwitchRedunCombineStt(switchId, ocIndex, cCombineCollState); + + switch (cCombineCollState) + { + case 0b00000011u: + /*反位（混线、动表一致性在后面处理）*/ + chSwitchColPos = SWITCH_POSITION_FANWEI; + break; + + case 0b00001010u: + /*有驱动命令时，移动中*/ + if (0u < dwSwitchDrvStartCyc) + { + chSwitchColPos = SWITCH_POSITION_MOVE; + } + else + { + chSwitchColPos = SWITCH_POSITION_SIKAI; + } + break; + + case 0b00001100u: + /*定位（混线、动表一致性在后面处理）*/ + chSwitchColPos = SWITCH_POSITION_DINGWEI; + break; + + case 0b00000000u: + case 0b00000010u: + case 0b00001000u: + /*故障*/ + chSwitchColPos = SWITCH_POSITION_SIKAI; + break; + + case 0b00000001u: + case 0b00000100u: + /*道岔转动中判混线，否则判故障*/ + chSwitchColPos = SWITCH_POSITION_SIKAI; + if (0u < dwSwitchDrvStartCyc) + { + cHunXianState = RELAY_HUNXIAN_STATE_YES; + } + else + { + /*nothing*/ + } + break; + + /*case 0b00000101u: + case 0b00000110u: + case 0b00000111u: + case 0b00001001u: + case 0b00001011u: + case 0b00001101u: + case 0b00001110u: + case 0b00001111u:*/ + default: + /*混线*/ + chSwitchColPos = SWITCH_POSITION_SIKAI; + cHunXianState = RELAY_HUNXIAN_STATE_YES; + break; + } + + if ((NULL == pHunXianStt) || (NULL == pCombineStt)) + { + /*入参异常*/ + } + else + { + /*赋值混线输出*/ + *pHunXianStt = cHunXianState; + *pCombineStt = cCombineCollState; + } + + return chSwitchColPos; +} + +/* +* 功能描述：道岔冗余采集故障处理 +* 参数说明：UINT16 switchId 道岔ID +* UINT8 ocIndex 下标 +* UINT8 cCombineState 当周期冗余采集状态 +* 返回值 ：无 +*/ +static void SwitchRedunFaultProc(UINT16 switchId, UINT8 ocIndex, UINT8 cCombineState) +{ + UINT32 dwRedunFaultStCyc = 0u; /*冗余采集故障起始周期号*/ + UINT32 dwCurrCycleNum = 0u; /*当前周期号*/ + + dwRedunFaultStCyc = GetSwitchRedunFaultStCyc(switchId, ocIndex); + if (0u < dwRedunFaultStCyc) + { + /*之前已经采集故障*/ + if ((SWITCH_POSITION_DINGWEI == cCombineState) + || (SWITCH_POSITION_FANWEI == cCombineState) + || (SWITCH_POSITION_MOVE == cCombineState)) + { + /*故障恢复，清空周期号*/ + SetSwitchRedunFaultStCyc(switchId, ocIndex, 0u); + } + else + { + /*维持故障记录*/ + } + } + else + { + /*之前未采集故障*/ + if ((SWITCH_POSITION_DINGWEI == cCombineState) + || (SWITCH_POSITION_FANWEI == cCombineState) + || (SWITCH_POSITION_MOVE == cCombineState)) + { + /*未发生故障*/ + } + else + { + /*发生故障，记录周期号*/ + dwCurrCycleNum = Get2oo2CurCycleNum(); + SetSwitchRedunFaultStCyc(switchId, ocIndex, dwCurrCycleNum); + } + } +} + +/* +* 功能描述：道岔冗余采集混线处理 +* 参数说明：UINT16 switchId 道岔ID +* UINT8 ocIndex 下标 +* UINT8 cCurrHunXianState 当周期混线状态 +* UINT8 cCombineState 当周期冗余采集状态 +* 返回值 ：无 +*/ +static void SwitchRedunHunXianProc(UINT16 switchId, UINT8 ocIndex, UINT8 cCurrHunXianState, UINT8 cCombineState) +{ + UINT32 dwJudgHunXianCycleNum = 0u; /*判断混线起始周期号*/ + UINT32 dwRealHunXianCycleNum = 0u; /*真实混线起始周期号*/ + UINT32 dwCurrCycleNum = 0u; /*当前周期号*/ + UINT32 dwRedunCollHunXianCycCfg = 0u; /*道岔冗余采集报警容忍时间*/ + UINT8 cTimeCount = 0u; /*超时判断*/ + UINT8 cLastHunXianRecovStt = 0u; /*之前混线状态*/ + UINT8 cHunXianRecovStt = 0u; /*混线（恢复）状态*/ + UINT32 dwSwitchDrvStartCyc = 0u; /*道岔驱动起始周期号*/ + + dwCurrCycleNum = Get2oo2CurCycleNum(); + dwRedunCollHunXianCycCfg = GetSwitchRedunCollHunXianCycCfg(); + dwSwitchDrvStartCyc = GetSwitchDriveStartCycNum(switchId); + cLastHunXianRecovStt = GetSwitchRedunHunXianRecovStt(switchId, ocIndex); + + /*判断混线判断*/ + if (RELAY_HUNXIAN_STATE_YES == cCurrHunXianState) + { + /*当前周期混线*/ + dwJudgHunXianCycleNum = GetSwitchRedunJudgHunXianStCyc(switchId, ocIndex); + if (0u == dwJudgHunXianCycleNum) + { + /*本周期混线且之前未混线，记录混线起始周期号*/ + SetSwitchRedunJudgHunXianStCyc(switchId, ocIndex, dwCurrCycleNum); + } + else + { + /*nothing*/ + } + + if (0u == dwSwitchDrvStartCyc) + { + /*没有驱动命令，直接判混线*/ + SetSwitchRedunHunXianRecovStt(switchId, ocIndex, 0u); + } + else + { + /*有驱动命令，超时后判混线*/ + cTimeCount = SystemOverTimeCheck(dwJudgHunXianCycleNum, dwRedunCollHunXianCycCfg); + if (CI_TIME_OUT == cTimeCount) + { + SetSwitchRedunHunXianRecovStt(switchId, ocIndex, 0u); + } + else + { + /*nothing*/ + } + } + } + + /*真实混线判断*/ + dwRealHunXianCycleNum = GetSwitchRedunRealHunXianStCyc(switchId, ocIndex); + if ((RELAY_HUNXIAN_STATE_YES == cCurrHunXianState) && (0u == dwRealHunXianCycleNum)) + { + /*本周期混线且之前未混线，记录混线起始周期号*/ + SetSwitchRedunRealHunXianStCyc(switchId, ocIndex, dwCurrCycleNum); + } + else if (RELAY_HUNXIAN_STATE_NO == cCurrHunXianState) + { + /*本周期未混线，清空混线起始周期号*/ + SetSwitchRedunRealHunXianStCyc(switchId, ocIndex, 0u); + } + else + { + /*nothing*/ + } + + /*判断混线状态清空时机： + ①之前没混线，有驱动命令，容忍时间内混线恢复（只清空周期号）； + ②采集到过1100、0011、1010，且未连续容忍时间发生真实混线*/ + /*条件①*/ + if ((RELAY_HUNXIAN_STATE_NO == cCurrHunXianState) && (0u < dwSwitchDrvStartCyc) && (REDUN_HX_RECOV_ALL == cLastHunXianRecovStt)) + { + dwJudgHunXianCycleNum = GetSwitchRedunJudgHunXianStCyc(switchId, ocIndex); + cTimeCount = SystemOverTimeCheck(dwJudgHunXianCycleNum, dwRedunCollHunXianCycCfg); + if (CI_TIME_OUT == cTimeCount) + { + /*已经超过容忍时间，混线还没恢复，不能直接恢复*/ + } + else + { + /*还没到容忍时间，清空混线周期号*/ + SetSwitchRedunJudgHunXianStCyc(switchId, ocIndex, 0u); + } + } + else + { + /*nothing*/ + } + + /*条件②*/ + cHunXianRecovStt = GetSwitchRedunHunXianRecovStt(switchId, ocIndex); + if (REDUN_HX_RECOV_ALL == cHunXianRecovStt) + { + /*未判断混线*/ + } + else + { + /*判断混线有效，检查是否真实混线超时*/ + dwRealHunXianCycleNum = GetSwitchRedunRealHunXianStCyc(switchId, ocIndex); + cTimeCount = SystemOverTimeCheck(dwRealHunXianCycleNum, dwRedunCollHunXianCycCfg); + if (CI_TIME_OUT == cTimeCount) + { + /*真实混线超时，清空混线恢复状态*/ + SetSwitchRedunHunXianRecovStt(switchId, ocIndex, 0u); + } + else if (0b00001100u == cCombineState) + { + /*采集到定位（1100）*/ + SetSwitchRedunHunXianRecovStt(switchId, ocIndex, REDUN_HX_RECOV_1100); + } + else if (0b00001010u == cCombineState) + { + /*采集到移动中（1010）*/ + SetSwitchRedunHunXianRecovStt(switchId, ocIndex, REDUN_HX_RECOV_1010); + } + else if (0b00000011u == cCombineState) + { + /*采集到反位（0011）*/ + SetSwitchRedunHunXianRecovStt(switchId, ocIndex, REDUN_HX_RECOV_0011); + } + else + { + /*nothing*/ + } + + /*检查全部混线恢复状态是否都采集到过*/ + cHunXianRecovStt = GetSwitchRedunHunXianRecovStt(switchId, ocIndex); + if (REDUN_HX_RECOV_ALL == cHunXianRecovStt) + { + /*采集到过全部混线恢复状态，恢复判断混线*/ + SetSwitchRedunJudgHunXianStCyc(switchId, ocIndex, 0u); + } + else + { + /*nothing*/ + } + } +} + +/* +* 功能描述：道岔冗余采集继电器组合处理 +* 参数说明：UINT16 cDBJ1State DBJ1状态 +* UINT16 cDBJ1State DBJ2状态 +* UINT16 cDBJ1State FBJ1状态 +* UINT16 cDBJ1State FBJ2状态 +* 返回值 ：继电器组合（0000|DBJ1|DBJ2|FBJ1|FBJ2） +*/ +static UINT8 SwitchRedunCombineProc(UINT8 cDBJ1State, UINT8 cDBJ2State, UINT8 cFBJ1State, UINT8 cFBJ2State) +{ + UINT8 cCombineCollState = 0u; + + /*将继电器状态转为bit位，便于后续判断*/ + if (RELAY_STATE_UP == cDBJ1State) + { + cCombineCollState |= 0b00001000u; + } + else + { + /*nothing*/ + } + + if (RELAY_STATE_UP == cDBJ2State) + { + cCombineCollState |= 0b00000100u; + } + else + { + /*nothing*/ + } + + if (RELAY_STATE_UP == cFBJ1State) + { + cCombineCollState |= 0b00000010u; + } + else + { + /*nothing*/ + } + + if (RELAY_STATE_UP == cFBJ2State) + { + cCombineCollState |= 0b00000001u; + } + else + { + /*nothing*/ + } + + return cCombineCollState; +} + /* * 功能描述： 设置所有道岔转辙机位置 * 参数说明： UINT16 switchCurSum 道岔总数 @@ -16429,6 +17247,7 @@ UINT8 GetSwitchCollToleratePos(const UINT16 switchId) UINT8 switchCurPosition = 0u; UINT8 faultFlag = GetSwitchFaultState(switchId); /*获取道岔是否板卡均故障*/ UINT16 switch2ndId = GetDSwitchOtherId(switchId); /*双动道岔*/ + UINT8 cRedunCollCfg = GetSwitchRedunCollCfg(switchId); /*获取是否冗余采集*/ curCycNum = Get2oo2CurCycleNum(); chSwitchColPos = GetSwitchCollPos(switchId); @@ -16438,7 +17257,7 @@ UINT8 GetSwitchCollToleratePos(const UINT16 switchId) { if (SWITCH_POSITION_SIKAI == chSwitchColPos) { - if (SWITCH_FAULT_STATE_NO == faultFlag) /*板卡无故障*/ + if ((SWITCH_FAULT_STATE_NO == faultFlag) || (REDUN_COLL_YES == cRedunCollCfg)) /*板卡无故障，或具备冗余采集*/ { chSwitch1CollTolerateState = CheckSwitchCollTolerateState(switchId); chSwitch2CollTolerateState = CheckSwitchCollTolerateState(switch2ndId); @@ -18540,4 +19359,70 @@ void FindSwitchPostionCmdOut(UINT16 switchId) SetSwitchThisOcFindCmdCycNum(switchId, otherOcId, 0u); } +} + +/* +* 功能描述： 更新倒切柜状态 +* 参数说明： void +* 返回值 ： 无 +* Create Fan 20260608 +*/ +void ReverseStateUpdateProc(void) +{ + UINT16 ii = 0u; /*游标*/ + UINT16 wOpenRelay = 0U;/*常开采集继电器*/ + UINT16 wCloseRelay = 0U; /*常闭采集继电器*/ + UINT8 chReverseOpenState = 0U;/*常开采集结果*/ + UINT8 chReverseCloseState = 0U;/*常闭采集结果*/ + UINT16 wBoardNum = 0U;/*板卡个数*/ + wOpenRelay = GetReverseSwitchOpenRelay(); + wCloseRelay = GetReverseSwitchCloseRelay(); + if ((0U == wOpenRelay) || (0U == wCloseRelay)) + { + /*认为未配置倒切继电器 设置状态为本联锁控*/ + SetReverseSwitchState(REVERSE_STATE_NEW_SYSTEM); + for (ii = 0U; ii < REVERSE_BOARD_SUM_MAX ; ii++) + { + SetReverseBoardState(REVERSE_STATE_NEW_SYSTEM, ii); + } + } + else + { + chReverseOpenState = GetRelayCollState(wOpenRelay); + chReverseCloseState = GetRelayCollState(wCloseRelay); + if ((RELAY_STATE_UP == chReverseOpenState)&&(RELAY_STATE_DOWN == chReverseCloseState)) + { + SetReverseSwitchState(REVERSE_STATE_NEW_SYSTEM); + } + else if ((RELAY_STATE_DOWN == chReverseOpenState) && (RELAY_STATE_UP == chReverseCloseState)) + { + SetReverseSwitchState(REVERSE_STATE_OLD_SYSTEM); + } + else + { + SetReverseSwitchState(REVERSE_STATE_ABNORMAL);/*异常状态*/ + } + + /*遍历板卡倒切状态*/ + wBoardNum = GetReverseBoardNum(); + for (ii = 0U; ii < wBoardNum; ii++) + { + wOpenRelay = GetReverseBoardOpenRelay(ii);/*板卡常开采集继电器*/ + wCloseRelay = GetReverseBoardCloseRelay(ii);/*板卡常闭采集继电器*/ + chReverseOpenState = GetRelayCollState(wOpenRelay); + chReverseCloseState = GetRelayCollState(wCloseRelay); + if ((RELAY_STATE_UP == chReverseOpenState) && (RELAY_STATE_DOWN == chReverseCloseState)) + { + SetReverseBoardState(REVERSE_STATE_NEW_SYSTEM, ii); + } + else if ((RELAY_STATE_DOWN == chReverseOpenState) && (RELAY_STATE_UP == chReverseCloseState)) + { + SetReverseBoardState(REVERSE_STATE_OLD_SYSTEM, ii); + } + else + { + SetReverseBoardState(REVERSE_STATE_ABNORMAL, ii);/*异常状态*/ + } + } + } } \ No newline at end of file diff --git a/TSCP/src/APP/ciapp/IO/DeviceRelayDataProcess.h b/TSCP/src/APP/ciapp/IO/DeviceRelayDataProcess.h index b21e27b..a4e0a89 100644 --- a/TSCP/src/APP/ciapp/IO/DeviceRelayDataProcess.h +++ b/TSCP/src/APP/ciapp/IO/DeviceRelayDataProcess.h @@ -1193,6 +1193,14 @@ void SwitchDoubleMainProtect(UINT16 switchId); */ void FindSwitchPostionCmdOut(UINT16 switchId); +/* +* 功能描述： 更新倒切柜状态 +* 参数说明： void +* 返回值 ： 无 +* Create Fan 20260608 +*/ +void ReverseStateUpdateProc(void); + #ifdef __cplusplus } diff --git a/TSCP/src/APP/ciapp/IO/InputDataProcess.c b/TSCP/src/APP/ciapp/IO/InputDataProcess.c index 8b7d74d..2cf8e36 100644 --- a/TSCP/src/APP/ciapp/IO/InputDataProcess.c +++ b/TSCP/src/APP/ciapp/IO/InputDataProcess.c @@ -24,6 +24,7 @@ #include "../IO/DeviceRelayDataProcess.h" #include "MSCP_APP_API.h" #include "LightTestButtonDataManage.h" +#include "InterlockLogicManage.h" extern PlatformToCiDataStruct platformToCiDataStru[PLATFORM_TO_CI_SUM_MAX]; /*引用站台门与CI通信数据结构体*/ extern unsigned long TimeStamp = 0u; @@ -430,12 +431,10 @@ void InputDataProcess(void) /*处理设备状态*/ ProcessDeviceLogicState(); - /*处理LEU数据*/ ProcessLeuToCiData(); if (RC_WORK_MODE_TIOC == cRcWorkMode) { - /*处理物理区段上的占用落到计轴区段 */ ProcessPhyOCcStateToAxisSection(); @@ -445,8 +444,10 @@ void InputDataProcess(void) /* 列车处理 */ TrainMainProc(); cost[5] = MSCP_GetTick(); + /*回收列车资源*/ (void)TrainResRecycle(); + if (FUNC_SWITCH_ON == chSwitch) { /* 列车占压计轴区段计算 */ @@ -521,6 +522,9 @@ void InputDataProcess(void) /*处理屏蔽门数据*/ ProcessPsdData(); + /*新增ATS/ 现地 / 网关一二次命令帧处理*/ + AtsFollowUpCmdProcess(); + /*处理ATS数据*/ (void)ProcessAtsOrXianDiToCiData(); @@ -2015,6 +2019,22 @@ void ProcessVobcToCiData(void) } else if ((LINE_HLHT == chLineIdentity) || (LINE_FAO == chLineIdentity)) { + /*厦门3处理列车非零速信息*/ + if (CI_VOBC_TRAIN_ZERO_SPEED_NO == VobcToCiDataStru[ii].chTrainZeroState) + {/*列车非零速*/ + SetTrainZeroSpeedState(vobcToCiDataStru[ii].PsdData[jj].PsdId, PSD_TRAIN_ZERO_SPEED_NO); /*设置列车非零速*/ + SetStopDetectionState(vobcToCiDataStru[ii].PsdData[jj].PsdId, JXTC_STOP_DETECTION_NO); /*设置屏蔽门未停止间隙探测*/ + } + else if (CI_VOBC_TRAIN_ZERO_SPEED_YES == VobcToCiDataStru[ii].chTrainZeroState) + {/*列车零速*/ + SetTrainZeroSpeedState(vobcToCiDataStru[ii].PsdData[jj].PsdId, PSD_TRAIN_ZERO_SPEED_YES); /*设置列车零速*/ + SetStopDetectionState(vobcToCiDataStru[ii].PsdData[jj].PsdId, JXTC_STOP_DETECTION_NO); /*设置屏蔽门未停止间隙探测*/ + } + else + { + /*没有非零速信息时，不处理*/ + } + switch (vobcToCiDataStru[ii].PsdData[jj].CmdType) { case VOBCTOCI_COMMAND_TYPE_PSDOPEN: @@ -2050,7 +2070,7 @@ void ProcessVobcToCiData(void) default: /*查询命令或错误命令*/ break; - } + } } else { @@ -4546,6 +4566,42 @@ UINT8 ProcessAtsOrXianDiToCiData(void) (void)CancelPsdExceptState(CmdDeviceId); } break; + case ATS_CMD_CONNECT_ROUTE_RELEASE_ONE: /*联络线接车进路解锁一次*/ + belongVirCIid = GetRouteBelongVirCiId(CmdDeviceId); + OrderCheckReVal = CheckOrderWhetherDoing(virCiID, belongVirCIid, cmdType, CmdDeviceId); + if (CI_SUCCESS == OrderCheckReVal) + { + checkRetVal = AFFIRM_SUCCESS; + } + else + { + checkRetVal = AFFIRM_FAIL; + } + SetCiSendCmdBackData_OrderBack(commandId, CmdDeviceId, cmdDevType, terminalId, AtsOrXianDiToCiCmdStru[ii].CommandType, RESPONSE_FIRST, checkRetVal, virCiID); + break; + case ATS_CMD_CONNECT_ROUTE_RELEASE_TWO: /*联络线接车进路解锁二次*/ + checkRetVal = CheckSecondOrderValid(commandId, CmdDeviceId, cmdDevType, terminalId, AtsOrXianDiToCiCmdStru[ii].CommandType, virCiID); + if (CI_SUCCESS == checkRetVal) + { + belongVirCIid = GetRouteBelongVirCiId(CmdDeviceId); + OrderCheckReVal = CheckOrderWhetherDoing(virCiID, belongVirCIid, cmdType, CmdDeviceId); + if (CI_SUCCESS == OrderCheckReVal) + { + checkRetVal = AFFIRM_SUCCESS; + /*联络线接车进路解锁处理*/ + ConnectRouteReleaseManage(CmdDeviceId); + } + else + { + checkRetVal = AFFIRM_FAIL; + } + } + else + { + checkRetVal = AFFIRM_FAIL; + } + SetCiSendCmdBackData_OrderBack(commandId, CmdDeviceId, cmdDevType, terminalId, AtsOrXianDiToCiCmdStru[ii].CommandType, RESPONSE_SECOND, checkRetVal, virCiID); + break; default: localVirCiType = GetLocalVirCiType(virCiID); if (CI_TYPE_SCX == localVirCiType) @@ -4916,6 +4972,9 @@ void ProcessDeviceLogicState(void) /*倒切设备继电器处理*/ RvrsCutRlyToDvicSttPrc(); } + + /*倒切柜的倒切开关/板卡采集状态更新*/ + ReverseStateUpdateProc(); } @@ -6445,9 +6504,14 @@ static void ProcessPsdData(void) SetStartDetectionState(psdId,JXTC_START_DETECTION_NO); SetStopDetectionState(psdId,JXTC_STOP_DETECTION_YES); } + else if(LINE_HLHT == chLineIdentity) + {/*厦门3 HLHT线路，站台无车发送停止探测命令并且屏蔽门设置零速*/ + SetStopDetectionState(psdId, JXTC_STOP_DETECTION_YES); /*设置屏蔽门停止间隙探测状态为停止*/ + SetTrainZeroSpeedState(psdId, PSD_TRAIN_ZERO_SPEED_YES); /*设置屏蔽门非零速状态为零速*/ + } else { - ; + ;/*无处理*/ } } else @@ -6582,7 +6646,7 @@ static void ProcessPsdData(void) } } } -#endif +#endif curPsdDrvState = GetPsdDriveState(psdId); SetPsdPreDriveState(psdId,curPsdDrvState); /*生成本周期PSD的驱动状态*/ @@ -8356,6 +8420,8 @@ void ClearPsdVobcContext(const UINT16 vobcId) { ; /*不处理*/ } + /*厦门3间隙探测-CI与VOBC通信中断，设置屏蔽门非零速状态为零速*/ + PsdDataStru[bufIndex].chTrainZeroSpeedState = PSD_TRAIN_ZERO_SPEED_YES; } } @@ -12793,10 +12859,13 @@ void ProcessIvocToRCData(void) { /*不处于MMI本地湿轨，不处理*/ } + + SetPbtacsTrainTransState(pIvocToRcDataStru[ii].VobcId, TRAIN_COMM_STATE_GOOD); /*设置与PBTACS车通信正常*/ } else { - + SetPbtacsTrainTransState(pIvocToRcDataStru[ii].VobcId, TRAIN_COMM_STATE_BAD); /*设置与PBTACS车通信中断（暂不考虑分界点列车的通信状态）*/ + /*从PSD数据中删除该VOBC产生的上下文信息*/ ClearPsdVobcContext(pIvocToRcDataStru[ii].VobcId); ProcessIvocLoseCom(pIvocToRcDataStru[ii]); @@ -12845,8 +12914,6 @@ static void ClearPsdData(const UINT16 psdId) UINT8 psdSum = 0u; UINT16 platformPsdId = 0u; UINT8 chRcWorkMode = 0u; - - chRcWorkMode = GetLocalRcWorkMode(); bufIndex = GetPsdConfigBufIndex(psdId); if ((0u != psdId) && (PSD_INVALID_ID != psdId)&&(PSD_SUM_MAX > bufIndex)) @@ -12857,8 +12924,7 @@ static void ClearPsdData(const UINT16 psdId) PsdDataStru[bufIndex].PsdCmd = PSD_DEFAULT_CONTROL_CMD; PsdDataStru[bufIndex].VOBCDoorState = PSD_DOOR_CLOSEDANDLOCKED_INVALID; PsdDataStru[bufIndex].psdEditGroupInfo = 0u;/*清除编组信息*/ - - + if (RC_WORK_MODE_TIOC == chRcWorkMode) { SetPsdEditGroupInfoDataCC(psdId, PSD_EDIT_GROUP_DEFAULT); /*设置RC的PSD编组信息为默认值*/ diff --git a/TSCP/src/APP/ciapp/IO/OutputDataProcess.c b/TSCP/src/APP/ciapp/IO/OutputDataProcess.c index f270d07..d37fbb8 100644 --- a/TSCP/src/APP/ciapp/IO/OutputDataProcess.c +++ b/TSCP/src/APP/ciapp/IO/OutputDataProcess.c @@ -400,6 +400,10 @@ UINT8 GetAtsBackInfoParam(const UINT8 functionId,const UINT8 deviceStateType, co case ETYPE_COUPLINK_ROUTE_IDLE: returnValue = CI_BACK_COUPLINK_ROUTE_IDLE; /*联挂进路内无被联挂车*/ break; + case ETYPE_CONNECT_ROUTE_RELEASE: + returnValue = CI_BACK_CONNECT_ROUTE_RELEASE; /*联络线接车进路解锁条件不满足*/ + break; + /*信号机故障反馈*/ case ETYPE_SIG_START_OPEN_STATE: @@ -1890,6 +1894,30 @@ void IndicatorStateProc(void) } } + else if (INDICATOR_TYPE_XDC_DCGDJ == devType) + { /*蓄电池电池供电*/ + + devRelaySum = GetIndicatorRelaySum(devId); /*获取相关继电器总数*/ + devRelayIdBuf = GetIndicatorRelayIdBuf(devId); /*获取相关继电器ID buf*/ + + if ((0U == devRelaySum) || (NULL == devRelayIdBuf)) + { + SetIndicatorState(devId, INDICATOR_SHOW_YES); /*设置红灯报警*/ + } + else + { + relayCollState = GetRelayCollState(devRelayIdBuf[0]); + if (RELAY_STATE_DOWN == relayCollState) + { /*继电器落下*/ + + SetIndicatorState(devId, INDICATOR_SHOW_NO); /*设置绿灯*/ + } + else + { + SetIndicatorState(devId, INDICATOR_SHOW_YES); /*设置红灯*/ + } + } + } else if (INDICATOR_TYPE_PORT_RONGSI == devType) { devRelaySum = GetIndicatorRelaySum(devId); /*获取相关继电器总数*/ diff --git a/TSCP/src/APP/ciapp/Indicator/IndicatorDefine.h b/TSCP/src/APP/ciapp/Indicator/IndicatorDefine.h index 4fa2358..30f818f 100644 --- a/TSCP/src/APP/ciapp/Indicator/IndicatorDefine.h +++ b/TSCP/src/APP/ciapp/Indicator/IndicatorDefine.h @@ -67,6 +67,7 @@ #define INDICATOR_TYPE_DOWNWASH_ALLOW_PASS ((UINT8)0x29) /* 降级模式洗车同意通过指示灯 */ #define INDICATOR_TYPE_DOWNWASH_APPLY ((UINT8)0x63) /* 降级模式洗车请求指示灯 */ #define INDICATOR_TYPE_DOWNWASH_PASS_APPLY ((UINT8)0x64) /* 降级模式反向通过请求指示灯 */ +#define INDICATOR_TYPE_XDC_DCGDJ ((UINT8)0x65) /* 蓄电池供电报警指示灯 */ #define INDICATOR_TYPE_ATS_CONFIRM_RELAY_INTERFACE ((UINT8)0x27) /*相邻联锁继电接口确认状态指示灯*/ diff --git a/TSCP/src/APP/ciapp/Initial/ConfigDataReadManage.c b/TSCP/src/APP/ciapp/Initial/ConfigDataReadManage.c index 71fc38d..6448b8c 100644 --- a/TSCP/src/APP/ciapp/Initial/ConfigDataReadManage.c +++ b/TSCP/src/APP/ciapp/Initial/ConfigDataReadManage.c @@ -531,7 +531,7 @@ UINT8 ReadConfigureData(void) g_ret = ReadReverseCutConfigData(LocalCiId, gstReverseCutCfgData); if (-1 == g_ret) { - rtnVal = 28u;/*读保护区段配置数据失败*/ + rtnVal = 28u;/*读倒切配置数据失败-OC配置数据表单30*/ debug_infor_printf((const)"ReadReverseCutConfigData fail."); } else if (0 < g_ret) @@ -810,6 +810,25 @@ UINT8 ReadConfigureData(void) ; /*不处理*/ } + + if (0u == rtnVal) + { + g_ret = ReadReverseSwitchConfigData(LocalCiId, &gLocalReverseData); + if (-1 == g_ret) + { + rtnVal = 39u;/*读板卡配置数据失败-OC配置数据表单40、41*/ + debug_infor_printf((const)"ReadReverseSwitchConfigData fail."); + } + else + { + /*无操作*/ + } + } + else + { + ; /*不处理*/ + } + if (0u == rtnVal) { /*读系统参数配置数据*/ @@ -2011,6 +2030,23 @@ INT8 OcConnectConfigDataToDevStruct(SignalConfigDataStruct* pSignalCfgData, Phys pSignalCfgData[j].DxRelayId = pConnectCfgData[i].OcConnetRelayDataBuf[k].RelayId; pSignalCfgData[j].DxDrvRelayId = pConnectCfgData[i].OcConnetRelayDataBuf[k].DrvRelayId; } + else if (SIGNAL_DJ_TYPE == pConnectCfgData[i].OcConnetRelayDataBuf[k].RelayType) + { + pSignalCfgData[j].FirDsRelayId = pConnectCfgData[i].OcConnetRelayDataBuf[k].RelayId; + pSignalCfgData[j].wFirstDsDrvRelayId = pConnectCfgData[i].OcConnetRelayDataBuf[k].DrvRelayId; + } + else if (SIGNAL_MAINJ_TYPE == pConnectCfgData[i].OcConnetRelayDataBuf[k].RelayType) + { + pSignalCfgData[j].wMainDrvRelayId = pConnectCfgData[i].OcConnetRelayDataBuf[k].DrvRelayId; + } + else if (SIGNAL_ACKJ_TYPE == pConnectCfgData[i].OcConnetRelayDataBuf[k].RelayType) + { + pSignalCfgData[j].wAckDrvRelayId = pConnectCfgData[i].OcConnetRelayDataBuf[k].DrvRelayId; + } + else if (SINNAL_CMAINJ_TYPE == pConnectCfgData[i].OcConnetRelayDataBuf[k].RelayType) + { + pSignalCfgData[j].wCMainDrvRelayId = pConnectCfgData[i].OcConnetRelayDataBuf[k].DrvRelayId; + } else { ; /*不处理*/ diff --git a/TSCP/src/APP/ciapp/Initial/InitialProcess.c b/TSCP/src/APP/ciapp/Initial/InitialProcess.c index 0cba77c..85ef212 100644 --- a/TSCP/src/APP/ciapp/Initial/InitialProcess.c +++ b/TSCP/src/APP/ciapp/Initial/InitialProcess.c @@ -871,6 +871,17 @@ UINT8 InitialSwitchData(void) SwitchDataStru[switchId].belongOCData[jj].FindPostionCmd = NO_FIND_CMD; SwitchDataStru[switchId].belongOCData[jj].OutMainControlCmdCycNum = 0u; } + + for (jj = 0u; jj < SWITCH_REDUN_COLL_MAX; jj++) + { + SwitchDataStru[switchId].RedunCollData[jj].dwRedunJudgHunXianStCyc = 0u; + SwitchDataStru[switchId].RedunCollData[jj].dwRedunRealHunXianStCyc = 0u; + SwitchDataStru[switchId].RedunCollData[jj].cHunXianRecovStt = REDUN_HX_RECOV_ALL; + SwitchDataStru[switchId].RedunCollData[jj].dwRedunFaultStCyc = 0u; + SwitchDataStru[switchId].RedunCollData[jj].cCollPos = SWITCH_POSITION_INVALID; + SwitchDataStru[switchId].RedunCollData[jj].cCombineStt = 0u; + SwitchDataStru[switchId].RedunCollData[jj].cCurrHunxianStt = RELAY_HUNXIAN_STATE_NO; + } } reVal = CI_SUCCESS; return reVal; @@ -1515,6 +1526,8 @@ UINT8 InitialPsdData(void) { PsdDataStru[psdId].ibpButtonState = PSD_RELATED_BUTTON_STATE_DEFAULT; /*IBP盘发车按钮状态初始化*/ } + /*初始化零速状态*/ + PsdDataStru[psdId].chTrainZeroSpeedState = PSD_TRAIN_ZERO_SPEED_YES; /*零速*/ } reVal = CI_SUCCESS; return reVal; @@ -1717,6 +1730,8 @@ UINT8 InitialRouteData(void) RouteDataStru[routeId].chCouplinkSuccessFlag = ROUTE_COUPLINK_RESULT_NOT; /*初始化联挂成功标志为未收到*/ RouteDataStru[routeId].chCouplinkErrorFlag = ROUTE_COUPLINK_RESULT_NOT; /*初始化联挂失败标志为未收到*/ RouteDataStru[routeId].dwRouteIdleCycNum = 0U; /*进路空闲起始周期号*/ + RouteDataStru[routeId].chRouteConnReleaseFlag = ROUTE_CONNECT_RELEASE_NO; /*进路联络线解锁标志*/ + /*初始化车车结构体成员*/ RouteDataStruCC[routeId].RouteId = routeId; diff --git a/TSCP/src/APP/ciapp/LightTestButtonManage/LightTestButtonDefine.h b/TSCP/src/APP/ciapp/LightTestButtonManage/LightTestButtonDefine.h index b3fb543..2c73d2d 100644 --- a/TSCP/src/APP/ciapp/LightTestButtonManage/LightTestButtonDefine.h +++ b/TSCP/src/APP/ciapp/LightTestButtonManage/LightTestButtonDefine.h @@ -20,7 +20,7 @@ #define LIGHTTESTBUTTON_LIGHT_MAX_NUM ((UINT8)13U) /* 试灯表示灯支持最大数 */ -#define LIGHTTESTBUTTON_LIGHT_SUPPORT_MAX_NUM ((UINT8)39U) +#define LIGHTTESTBUTTON_LIGHT_SUPPORT_MAX_NUM ((UINT8)208U) /* 试灯按钮可配置最大数量 */ #define LIGHTTESTBUTTON_BUTTON_MAX_NUM ((UINT16)70U) diff --git a/TSCP/src/APP/ciapp/LogRecord/LogRecord.c b/TSCP/src/APP/ciapp/LogRecord/LogRecord.c index e12c75c..4bd4c45 100644 --- a/TSCP/src/APP/ciapp/LogRecord/LogRecord.c +++ b/TSCP/src/APP/ciapp/LogRecord/LogRecord.c @@ -988,7 +988,27 @@ UINT8 RecordDeviceDataLog(UINT8 Flag) ShortToChar(newSwitchData[deviceId].PLockedAxisSecIdArr[jj], &outString[outStringLength]); outStringLength += 2u; } - + + outString[outStringLength] = newSwitchData[deviceId].cMainOcCollPos; + outStringLength += 1u; + + for (jj = 0u; jj < SWITCH_REDUN_COLL_MAX; jj++) + { + LongToChar(newSwitchData[deviceId].RedunCollData[jj].dwRedunJudgHunXianStCyc, &outString[outStringLength]); + outStringLength += 4u; + LongToChar(newSwitchData[deviceId].RedunCollData[jj].dwRedunRealHunXianStCyc, &outString[outStringLength]); + outStringLength += 4u; + outString[outStringLength] = newSwitchData[deviceId].RedunCollData[jj].cHunXianRecovStt; + outStringLength += 1u; + LongToChar(newSwitchData[deviceId].RedunCollData[jj].dwRedunFaultStCyc, &outString[outStringLength]); + outStringLength += 4u; + outString[outStringLength] = newSwitchData[deviceId].RedunCollData[jj].cCombineStt; + outStringLength += 1u; + outString[outStringLength] = newSwitchData[deviceId].RedunCollData[jj].cCollPos; + outStringLength += 1u; + outString[outStringLength] = newSwitchData[deviceId].RedunCollData[jj].cCurrHunxianStt; + outStringLength += 1u; + } } } else @@ -1207,6 +1227,7 @@ UINT8 RecordDeviceDataLog(UINT8 Flag) outString[outStringLength++] = newRouteData[deviceId].chRoutCouplinkFlag; /*进路联挂标志*/ outString[outStringLength++] = newRouteData[deviceId].chCouplinkSuccessFlag; /*进路联挂成功*/ outString[outStringLength++] = newRouteData[deviceId].chCouplinkErrorFlag; /*进路联挂失败*/ + outString[outStringLength++] = newRouteData[deviceId].chRouteConnReleaseFlag; /*进路联络线解锁标志*/ } } else @@ -1707,6 +1728,8 @@ UINT8 RecordDeviceDataLog(UINT8 Flag) outString[outStringLength++] = newPsdData[deviceId].ibpButtonState;/*IBP盘发车按钮状态*/ LongToChar(newPsdData[deviceId].IBPPressCycNum, &outString[outStringLength]); /*IBP盘发车按钮按下周期*/ outStringLength += 4U; + outString[outStringLength] = newPsdData[deviceId].chTrainZeroSpeedState; /*非零速状态*/ + outStringLength++; } } else @@ -2456,6 +2479,12 @@ UINT8 RecordDeviceDataLog(UINT8 Flag) LongToChar(pNewTrainInfoData[deviceId].dwMinSafeHeadOffset, &outString[outStringLength]);/*延时小前所处link偏移量*/ outStringLength += 4u; outString[outStringLength++] = pNewTrainInfoData[deviceId].chMinSafeHeadDir;/* 延时小前方向 */ + + outString[outStringLength] = pNewTrainInfoData[deviceId].chPbtacsTransState; /*RC与PBTACS列车通信状态：0x55-通信正常，0xAA-通信中断，0xFF-未知*/ + outStringLength++; + + LongToChar(pNewTrainInfoData[deviceId].dwPbtacsTransBadCyc, &outString[outStringLength]); /*RC与PBTACS列车通信中断周期*/ + outStringLength += 4U; } diff --git a/TSCP/src/APP/ciapp/LogicManage/InterlockCommonManage.c b/TSCP/src/APP/ciapp/LogicManage/InterlockCommonManage.c index f44d4c6..cf7004f 100644 --- a/TSCP/src/APP/ciapp/LogicManage/InterlockCommonManage.c +++ b/TSCP/src/APP/ciapp/LogicManage/InterlockCommonManage.c @@ -1875,8 +1875,9 @@ void SetRouteOvlpOtherCiShrFlg(const UINT16 wRouteId, const UINT16 wOverlapId,co void ClearSomeFlagDependRouteState(const UINT16 routeId) { UINT8 routeState = GetRouteState(routeId); - UINT16 startSignalId = 0u; - UINT16 EnginVehicCroCloBelongRoute = 0u; + UINT16 startSignalId = 0U; + UINT16 EnginVehicCroCloBelongRoute = 0U; + UINT8 chZrenjieFlag = 0U; /*清理工程车跨压关信号所属进路,清理工程车跨压状态*/ if ((ROUTE_STATE_YUXIAN_LOCK != routeState) @@ -1925,6 +1926,17 @@ void ClearSomeFlagDependRouteState(const UINT16 routeId) { /*不处理*/ } + /*无总人解标志且不处于延时解锁状态，清除联络线解锁标志*/ + chZrenjieFlag = GetRouteZongRenJieFlag(routeId); + if ((ROUTE_ZONGRENJIE_SET_NO == chZrenjieFlag) && (ROUTE_STATE_DELAY_UNLOCK != routeState)) + { + SetRouteConnectReleaseFlag(routeId, ROUTE_CONNECT_RELEASE_NO); /*清除联络线解锁标志*/ + } + else + { + /*不处理*/ + } + } /* diff --git a/TSCP/src/APP/ciapp/LogicManage/InterlockLogicManage.c b/TSCP/src/APP/ciapp/LogicManage/InterlockLogicManage.c index 76a1b69..77c1032 100644 --- a/TSCP/src/APP/ciapp/LogicManage/InterlockLogicManage.c +++ b/TSCP/src/APP/ciapp/LogicManage/InterlockLogicManage.c @@ -21,6 +21,7 @@ #include "LogicalRouteDataManage.h" #include "../LogicProcess/LogicalRouteLogicCheck.h" #include "../LogicManage/TradInterlockLogicManage.h" +#include "../ParsePack/ParsePackAtsData.h" #include "ParsePackZcData.h" @@ -145,6 +146,7 @@ void InterlockLogicMainProc(void) UINT8 localCiType = GetLocalCiType(); UINT8 cRcWorkMode = GetLocalRcWorkMode(); UINT8 cControlState = GetLocalCiBackUpPattern(); + signed long long cost[20] = {0U}; cost[0] = MSCP_GetTick(); if (SYSTEM_WORK_MODE_MAIN == cControlState) @@ -221,16 +223,30 @@ void InterlockLogicMainProc(void) /*跳跃锁闭逻辑处理*/ JumpLockManage(); } + else + { + if ((RC_WORK_MODE_TIOC == cRcWorkMode) && (SYSTEM_WORK_MODE_BACKUP == cControlState)) + { + /*信号已开放进路的共享资源处理*/ + OpenedRouteShareResPro(); + } + else + { + /*不处理*/ + } + } + cost[3] = MSCP_GetTick(); + /*进路列车释放解锁逻辑管理*/ RouteTrainResUnlockManage(); + /*逻辑区段资源管理*/ LogicSecResManage(); cost[4] = MSCP_GetTick(); debug_infor_printf((const)"\n JKJRelayLogicProcess :%dms RouteLogicManage:%dms LogicSecResManage:%dms JumpLockManage:%dms \n",(cost[1]-cost[0])/1000,(cost[2]-cost[1])/1000,(cost[3]-cost[2])/1000,(cost[4]-cost[3])/1000); - } @@ -4397,17 +4413,18 @@ UINT8 AutoSigRouteQuXiaoProc(const UINT16 routeId) */ void RouteZongRenJieProc(const UINT16 routeId) { - UINT8 routeState = 0u; /*进路状态*/ - UINT16 startSignalId = 0u; + UINT8 routeState = 0U; /*进路状态*/ + UINT16 startSignalId = 0U; UINT8 checkResult = CI_ERROR;/*区段是否有车占用*/ - UINT16 firstOccuSecId = 0u;/*进路内方第一个占用的物理区段ID*/ - UINT8 devState = 0u; - UINT8 trainEnterSta = 0u;/*进路列车驶入标志*/ - UINT8 checkZongRenJieResult = 0u; - UINT8 routeDelayUnlockflag = 0u; - UINT8 checkResultSecAndQXZC = 0u; /*RouteExceptLastSecOccuClrCheck此函数的检查结果*/ - UINT8 cSignalColor = 0u; - UINT8 cSignalOpenState = 0u; + UINT16 firstOccuSecId = 0U;/*进路内方第一个占用的物理区段ID*/ + UINT8 devState = 0U; + UINT8 trainEnterSta = 0U;/*进路列车驶入标志*/ + UINT8 checkZongRenJieResult = 0U; + UINT8 routeDelayUnlockflag = 0U; + UINT8 checkResultSecAndQXZC = 0U; /*RouteExceptLastSecOccuClrCheck此函数的检查结果*/ + UINT8 cSignalColor = 0U; + UINT8 cSignalOpenState = 0U; + UINT8 chRouteConnectFlag = 0U; /*获取进路动态字段*/ routeState = GetRouteState(routeId); /*获取进路状态*/ @@ -4419,143 +4436,145 @@ void RouteZongRenJieProc(const UINT16 routeId) if (SIGNAL_OPEN == cSignalOpenState) { /*信号未关闭*/ - (void)DriveSignalClose(startSignalId); /*驱动信号关闭*/ -#if 0 - SetRouteZongRenJieCloseFlag(routeId, ROUTE_ZRJ_CLOSE_FLAG_YES); /*进路信号关闭是总人解导致*/ -#endif - return; } else { /*信号已关闭*/ (void)SetRouteZongRenJieFlag(routeId, ROUTE_ZONGRENJIE_SET_NO); /*取消进路总人解标志*/ -#if 0 - zrjCloseSigFlag = GetRouteZongRenJieCloseFlag(routeId); /*或取进路的总人解关信号标志*/ - SetRouteZongRenJieCloseFlag(routeId, ROUTE_ZRJ_CLOSE_FLAG_NO); /*用完清除*/ -#endif - } - checkResult = RouteAllSecOccuClearCheck(routeId, &firstOccuSecId, &devState); - trainEnterSta = GetRouteTrainEnterFlag(routeId); - - /*总人解进路处理*/ - if ((ROUTE_STATE_XUANPAI == routeState) || (ROUTE_STATE_FIRST_XUANPAI == routeState)) - { - /*进路选排或初选*/ - - /*取消进路选排*/ - SetRouteStateManage(routeId, ROUTE_STATE_IDLE); /*-->设置进路空闲*/ - - } - else if ((ROUTE_STATE_FIRST_LOCK == routeState) || - (ROUTE_STATE_FIRST_LOCKERR == routeState) || - (ROUTE_STATE_YUXIAN_LOCK == routeState)) - { - /*进路初锁||进路初锁异常||进路预先锁闭*/ - /*总人解逻辑处理*/ - checkZongRenJieResult = CheckRouteZongRenJieFeasibility(routeId); - /* 获取进路延时解锁属性*/ - routeDelayUnlockflag = GetRouteNeedDelayUnlock(routeId); - if (CI_SUCCESS == checkZongRenJieResult) + /*是否联络线接车进路解锁*/ + chRouteConnectFlag = GetRouteConnectReleaseFlag(routeId); + if (ROUTE_CONNECT_RELEASE_YES == chRouteConnectFlag) { - /*进路需要延时解锁*/ - if (ROUTE_NEED_DELAY_UNLOCK == routeDelayUnlockflag) - { - /*进路内无占用*/ - if (CI_SUCCESS == checkResult) - { - /*-->设置进路延时解锁*/ - SetRouteStateManage(routeId, ROUTE_STATE_DELAY_UNLOCK); - /*进路内无占压，延时后全部解锁*/ - SetRouteZongRenJieDelayType(routeId, ROUTE_ZRJ_DELAY_TYPE_IDLE); - } - else - { - /*车身后变绿光带*/ - SetRoutePhySecExpLockToOccupy(routeId); - SetRouteStateManage(routeId, ROUTE_STATE_AUTO_UNLOCKERR); - } - } - else - { - - if (CI_SUCCESS == checkResult) - {/*已无占用*/ - SetRouteStateManage(routeId, ROUTE_STATE_IDLE); /*-->设置进路空闲*/ - } - else - { - /*车身后变绿光带*/ - SetRoutePhySecExpLockToOccupy(routeId); - - SetRouteStateManage(routeId, ROUTE_STATE_AUTO_UNLOCKERR); - } - } + /*执行联络线接车进路解锁*/ + ConnectRouteReleaseProc(routeId); } else { - /*进路不能取消*/ - } - } - else if (ROUTE_STATE_NEAR_LOCKERR == routeState) - { - /*总人解逻辑处理*/ - checkZongRenJieResult = CheckRouteZongRenJieFeasibility(routeId); - if (CI_SUCCESS == checkZongRenJieResult) - { - SetRouteStateManage(routeId, ROUTE_STATE_DELAY_UNLOCK); /*-->设置进路延时解锁*/ + checkResult = RouteAllSecOccuClearCheck(routeId, &firstOccuSecId, &devState); + trainEnterSta = GetRouteTrainEnterFlag(routeId); - if (CI_SUCCESS == checkResult) + /*总人解进路处理*/ + if ((ROUTE_STATE_XUANPAI == routeState) || (ROUTE_STATE_FIRST_XUANPAI == routeState)) { - /*进路内无占压，延时后全部解锁*/ - SetRouteZongRenJieDelayType(routeId, ROUTE_ZRJ_DELAY_TYPE_IDLE); + /*进路选排或初选*/ + + /*取消进路选排*/ + SetRouteStateManage(routeId, ROUTE_STATE_IDLE); /*-->设置进路空闲*/ + + } + else if ((ROUTE_STATE_FIRST_LOCK == routeState) || + (ROUTE_STATE_FIRST_LOCKERR == routeState) || + (ROUTE_STATE_YUXIAN_LOCK == routeState)) + { + /*进路初锁||进路初锁异常||进路预先锁闭*/ + /*总人解逻辑处理*/ + checkZongRenJieResult = CheckRouteZongRenJieFeasibility(routeId); + /* 获取进路延时解锁属性*/ + routeDelayUnlockflag = GetRouteNeedDelayUnlock(routeId); + if (CI_SUCCESS == checkZongRenJieResult) + { + /*进路需要延时解锁*/ + if (ROUTE_NEED_DELAY_UNLOCK == routeDelayUnlockflag) + { + /*进路内无占用*/ + if (CI_SUCCESS == checkResult) + { + /*-->设置进路延时解锁*/ + SetRouteStateManage(routeId, ROUTE_STATE_DELAY_UNLOCK); + /*进路内无占压，延时后全部解锁*/ + SetRouteZongRenJieDelayType(routeId, ROUTE_ZRJ_DELAY_TYPE_IDLE); + } + else + { + /*车身后变绿光带*/ + SetRoutePhySecExpLockToOccupy(routeId); + SetRouteStateManage(routeId, ROUTE_STATE_AUTO_UNLOCKERR); + } + } + else + { + + if (CI_SUCCESS == checkResult) + {/*已无占用*/ + SetRouteStateManage(routeId, ROUTE_STATE_IDLE); /*-->设置进路空闲*/ + } + else + { + /*车身后变绿光带*/ + SetRoutePhySecExpLockToOccupy(routeId); + + SetRouteStateManage(routeId, ROUTE_STATE_AUTO_UNLOCKERR); + } + } + } + else + { + /*进路不能取消*/ + } + } + else if (ROUTE_STATE_NEAR_LOCKERR == routeState) + { + /*总人解逻辑处理*/ + checkZongRenJieResult = CheckRouteZongRenJieFeasibility(routeId); + if (CI_SUCCESS == checkZongRenJieResult) + { + SetRouteStateManage(routeId, ROUTE_STATE_DELAY_UNLOCK); /*-->设置进路延时解锁*/ + + if (CI_SUCCESS == checkResult) + { + /*进路内无占压，延时后全部解锁*/ + SetRouteZongRenJieDelayType(routeId, ROUTE_ZRJ_DELAY_TYPE_IDLE); + } + else + { + + /*延时后部分绿光带，即一个占压的物理区段之前的物理区段变绿光带*/ + SetRouteZongRenJieDelayType(routeId, ROUTE_ZRJ_DELAY_TYPE_EXP_TO_OCCUPY); + } + } + else + { + /*进路不能取消*/ + } + } + else if ((ROUTE_STATE_LEAD_LOCK == routeState) || (ROUTE_STATE_LEAD_LOCKERR == routeState)) + { /*引导锁闭||引导锁闭异常*/ + /*人解引导进路解锁原则：修改20180809 + 当进路内方空闲或最后一个区段占用时，立即解锁； + 当非最后一个区段占用且无驶入，则延时解锁，其他场景不解锁*/ + + checkResultSecAndQXZC = RouteExceptLastSecOccuClrCheck(routeId); + if (CI_SUCCESS == checkResultSecAndQXZC) + { /*所有区段空闲或最后一个区段占用*/ + + /*总人解办理*/ + SetRouteStateManage(routeId, ROUTE_STATE_DELAY_UNLOCK); /*-->设置进路延时解锁*/ + /*延时后全部解锁*/ + SetRouteZongRenJieDelayType(routeId, ROUTE_ZRJ_DELAY_TYPE_IDLE);/*延时结束后所有区段解锁*/ + } + else if ((ROUTE_TRAIN_ENTER_FLAG_NO == trainEnterSta) && (CI_ERROR_QXZC != checkResultSecAndQXZC)) + {/*当总人解引导进路时，有取消照查继电器且未吸起则不能解锁引导进路*/ + /*总人解办理*/ + SetRouteStateManage(routeId, ROUTE_STATE_DELAY_UNLOCK); /*-->设置进路延时解锁*/ + /*延时后全部解锁*/ + SetRouteZongRenJieDelayType(routeId, ROUTE_ZRJ_DELAY_TYPE_IDLE);/*延时结束后所有区段解锁*/ + } + else + { + /*不解锁*/ + } + } else { + /*进路状态不满足*/ + /* 记录故障码 */ + SetErrorData(EFUNC_ROUTE_ZRJ_DEAL, CI_DEVICE_TYPE_ROUTE, routeId, ETYPE_ROUTE_STATE, routeState, ESEND_LEVEL_ATS); + } + } - /*延时后部分绿光带，即一个占压的物理区段之前的物理区段变绿光带*/ - SetRouteZongRenJieDelayType(routeId, ROUTE_ZRJ_DELAY_TYPE_EXP_TO_OCCUPY); - } - } - else - { - /*进路不能取消*/ - } - } - else if ((ROUTE_STATE_LEAD_LOCK == routeState) || (ROUTE_STATE_LEAD_LOCKERR == routeState)) - { /*引导锁闭||引导锁闭异常*/ - /*人解引导进路解锁原则：修改20180809 - 当进路内方空闲或最后一个区段占用时，立即解锁； - 当非最后一个区段占用且无驶入，则延时解锁，其他场景不解锁*/ - - checkResultSecAndQXZC = RouteExceptLastSecOccuClrCheck(routeId); - if (CI_SUCCESS == checkResultSecAndQXZC) - { /*所有区段空闲或最后一个区段占用*/ - - /*总人解办理*/ - SetRouteStateManage(routeId, ROUTE_STATE_DELAY_UNLOCK); /*-->设置进路延时解锁*/ - /*延时后全部解锁*/ - SetRouteZongRenJieDelayType(routeId, ROUTE_ZRJ_DELAY_TYPE_IDLE);/*延时结束后所有区段解锁*/ - } - else if ((ROUTE_TRAIN_ENTER_FLAG_NO == trainEnterSta) && (CI_ERROR_QXZC != checkResultSecAndQXZC)) - {/*当总人解引导进路时，有取消照查继电器且未吸起则不能解锁引导进路*/ - /*总人解办理*/ - SetRouteStateManage(routeId, ROUTE_STATE_DELAY_UNLOCK); /*-->设置进路延时解锁*/ - /*延时后全部解锁*/ - SetRouteZongRenJieDelayType(routeId, ROUTE_ZRJ_DELAY_TYPE_IDLE);/*延时结束后所有区段解锁*/ - } - else - { - /*不解锁*/ - } - - } - else - { - /*进路状态不满足*/ - /* 记录故障码 */ - SetErrorData(EFUNC_ROUTE_ZRJ_DEAL, CI_DEVICE_TYPE_ROUTE, routeId, ETYPE_ROUTE_STATE, routeState, ESEND_LEVEL_ATS); } } @@ -16979,4 +16998,1152 @@ UINT8 GetLocalCiIsScx(void) ;/*返回CI_ERROR;*/ } return chRtn; +} + +/* +* 功能描述： 联络线进路解锁管理 +* 参数说明： const UINT16 wRouteId 进路ID +* 返回值 ： 无 +* Create:lyj 20260603 +*/ +void ConnectRouteReleaseManage(const UINT16 wRouteId) +{ + UINT8 chLocalCiId = 0U; /*本地联锁ID*/ + UINT8 chBelongCiId = 0U; /*进路所属联锁ID*/ + UINT8 chAutoSigRouteState = 0U; /*自动信号进路状态*/ + UINT16 wQXzhaochaRelay = 0U; + UINT8 chColleState = 0U; + UINT8 chvirCiId = 0U; + UINT8 chVirCiType = 0U; + UINT8 chRouteState = 0U; + UINT8 chConnectType = 0U; + + if ((0U < wRouteId) && (ROUTE_SUM_MAX > wRouteId)) + { + chLocalCiId = GetSystemParaLocalCiId(); /*获取本机联锁ID*/ + chBelongCiId = GetRouteBelongCiId(wRouteId); /*获取进路所属联锁ID*/ + if ((chLocalCiId == chBelongCiId) && (0U != chBelongCiId)) + { + chConnectType = GetRouteConnectType(wRouteId); /*获取进路联络线属性*/ + if (ROUTE_TYPE_CONNECT == chConnectType) + { + chAutoSigRouteState = GetRouteAutoSigSetState(wRouteId); /*获取进路自动信号状态*/ + chRouteState = GetRouteState(wRouteId); + /*不是自动信号，并且进路不处于延时解锁*/ + if ((ROUTE_AUTOSIGROUTE_NO == chAutoSigRouteState) && (ROUTE_STATE_DELAY_UNLOCK != chRouteState)) + { + wQXzhaochaRelay = GetRouteCancleZhaoChaRelayId(wRouteId); + if ((0U < wQXzhaochaRelay) && (RELAY_SUM_MAX > wQXzhaochaRelay)) + { + chColleState = GetRelayCollState(wQXzhaochaRelay); + if (RELAY_STATE_DOWN == chColleState) + { + SetRouteConnectReleaseFlag(wRouteId, ROUTE_CONNECT_RELEASE_YES); /*设置联络线解锁标志*/ + chvirCiId = GetRouteBelongVirCiId(wRouteId); + chVirCiType = GetLocalVirCiType(chvirCiId); + /*调用总人解函数设置总人解标志*/ + if (CI_TYPE_CLD == chVirCiType) + { + /*总人解*/ + ZongRenJieRouteM(wRouteId); + } + else + {/*总人解*/ + RouteZongRenJieLogicManage(wRouteId); + } + + } + else + { + SetErrorData(EFUNC_CONNECT_ROUTE_RELEASE, CI_DEVICE_TYPE_ROUTE, wRouteId, ETYPE_CONNECT_ROUTE_RELEASE, 0U, ESEND_LEVEL_ATS); + } + } + else + { + SetErrorData(EFUNC_CONNECT_ROUTE_RELEASE, CI_DEVICE_TYPE_ROUTE, wRouteId, ETYPE_CONNECT_ROUTE_RELEASE, 0U, ESEND_LEVEL_ATS); + } + } + else + { + SetErrorData(EFUNC_CONNECT_ROUTE_RELEASE, CI_DEVICE_TYPE_ROUTE, wRouteId, ETYPE_CONNECT_ROUTE_RELEASE, 0U, ESEND_LEVEL_ATS); + } + } + else + { + SetErrorData(EFUNC_CONNECT_ROUTE_RELEASE, CI_DEVICE_TYPE_ROUTE, wRouteId, ETYPE_CONNECT_ROUTE_RELEASE, 0U, ESEND_LEVEL_ATS); + } + + } + else + { + /*不处理-ATS命令处理防护了*/ + } + + } + else + { + /*不处理-ATS命令处理防护了*/ + } + +} + + +/* +* 功能描述: 新增一二次命令管理 +* 参数说明： 无 +* 返回值 ： void +* BY fan 20260602 +*/ +void AtsFollowUpCmdProcess(void) +{ + /*依次进行各种消息检查及处理*/ + + /*道岔单解*/ + FollowUpDansuoCanclMsgProc(); + /*道岔解封*/ + FollowUpSwitchUnFlockMsgProc(); + /*区段解封*/ + FollowUpSecUnFlockMsgProc(); + /*信号机解封*/ + FollowUpSignalUnFlockMsgProc(); +} + +/* +* 功能描述: 道岔单解命令管理 +* 参数说明： 无 +* 返回值 ： void +* BY fan 20260602 +*/ +void FollowUpDansuoCanclMsgProc(void) +{ + AtsFollowUpCmdFstStru * strMsgFst = NULL;/*首次消息指针*/ + AtsFollowUpCmdSndStru * strMsgSnd = NULL;/*再次消息指针*/ + RCIFollowUpReplyStru * strCfmFst = NULL;/*首次回复指针*/ + RCIFollowUpReplyStru *strCfmSnd = NULL;/*二次回复指针*/ + UINT8 chLocalId = 0U; + UINT32 dwCycle = 0U; + UINT8 chRtn = CI_ERROR;/*中间获取结果*/ + UINT8 szCrcTmp[1024] = { 0U }; + UINT16 ii = 0U; + UINT32 dwCrc = 0U;/*二次消息CRC计算*/ + chLocalId = GetSystemParaLocalCiId(); + dwCycle = Get2oo2CurCycleNum(); + + /*获取对应一次、二次命令 以及首次、再次确认消息*/ + strMsgFst = GetAtsFollowUpMsgFst(ATS_CI_INFO_FST_DS_CANCEL); + strMsgSnd = GetAtsFollowUpMsgSnd(ATS_CI_INFO_SND_DS_CANCEL); + strCfmFst = GetAtsFollowUpReplyFst(RCI_ATS_INFO_FST_DS_CANCEL); + strCfmSnd = GetAtsFollowUpReplySnd(RCI_ATS_INFO_SND_DS_CANCEL); + if ((NULL == strMsgFst) || (NULL == strMsgSnd) + || (NULL == strCfmFst) || (NULL == strCfmSnd)) + { + ; + } + else + { + if ((strMsgFst->chFlag != FLAG_SET) && (strMsgSnd->chFlag != FLAG_SET)) + { + ; /* 没有新消息，什么也不做 */ + } + else if (FLAG_SET == strMsgFst->chFlag) + { + /* 一次消息有效 */ + if (strMsgFst->dwCycle == dwCycle) + { + strCfmFst->chFlag = FLAG_SET; + strCfmFst->chTiocId = chLocalId; + strCfmFst->chRtuId = strMsgFst->chRtuId; + strCfmFst->chAtsId = strMsgFst->chAtsId; + strCfmFst->wIndex = strMsgFst->wIndex; + strCfmFst->dwTime = dwCycle; + + if ((SWITCH_SUM_MAX <= strMsgFst->wDevId)||(chLocalId != strMsgFst->chTiocId)) + {/* 获取设备ID出错，返回不属于本集中区*/ + strCfmFst->chOpStatus = CONFIRM_FST_BELONGERROR; + } + else + { + strCfmFst->chOpStatus = FollowUpDansuoCancleCheck(strMsgFst->wDevId, ATS_CI_INFO_FST_DS_CANCEL); + } + + szCrcTmp[ii] = strMsgFst->chAtsId; + ii++; + szCrcTmp[ii] = strMsgFst->chRtuId; + ii++; + ShortToChar(strMsgFst->wIndex, &szCrcTmp[ii]); + ii += 2U; + LongToChar(strMsgFst->dwTime, &szCrcTmp[ii]); + ii += 4U; + ShortToChar(strMsgFst->wDevId, &szCrcTmp[ii]); + ii += 2U; + strCfmFst->dwCrc32 = Tioc_CommonCrc32(szCrcTmp, ii); /* ATS编号、车站编号、操作站编号、ID、下发时间 计算CRC */ + debug_infor_printf((char*)"\n FollowUpDansuoCanclMsgProc DevId:%d, First Reply:%d \n", strMsgFst->wDevId, strCfmFst->chOpStatus); + if (CONFIRM_REPLY_SUCCESS != strCfmFst->chOpStatus) + { + ClearAtsCmdMsgFst(ATS_CI_INFO_FST_DS_CANCEL); + } + else + { + strMsgFst->chFlag = FLAG_UNSET; + } + } + else + { + ;/* 接收到对应一次消息非本周期 */ + } + } + else + { + /* 二次命令处理 */ + if (strMsgSnd->dwCycle == dwCycle) + { + strCfmSnd->chFlag = FLAG_SET; + strCfmSnd->chTiocId = chLocalId; + strCfmSnd->chRtuId = strMsgSnd->chRtuId; + strCfmSnd->chAtsId = strMsgSnd->chAtsId; + strCfmSnd->wIndex = strMsgSnd->wIndex; + strCfmSnd->dwTime = dwCycle; + + if(0u == strMsgFst->chFlag) + { + /*对应一次命令已清零*/ + strCfmSnd->chOpStatus = CONFIRM_SND_FIRST_NOTFIND; + } + else if ((strMsgSnd->chAtsId != strMsgFst->chAtsId) + ||(strMsgSnd->chRtuId != strMsgFst->chRtuId) + || (strMsgSnd->wIndex != strMsgFst->wIndex) + || (strMsgSnd->chTiocId != strMsgFst->chTiocId) + || (strMsgSnd->wDevId != strMsgFst->wDevId)) + { + strCfmSnd->chOpStatus = CONFIRM_SND_DIFFCMD; + } + else + { + szCrcTmp[ii] = strMsgSnd->chTiocId; + ii++; + LongToChar(strCfmFst->dwTime, &szCrcTmp[ii]); + ii += 4u; + ShortToChar(strMsgSnd->wDevId, &szCrcTmp[ii]); + ii += 2u; + debug_infor_printf((char*)"\nSecondRecvCrc: 1.Tioc:%d , 2.Time:%d 3.Id:%d", strMsgSnd->chTiocId, strCfmFst->dwTime, strMsgSnd->wDevId ); + dwCrc = Tioc_CommonCrc32(szCrcTmp, ii); + if (dwCrc != strMsgSnd->dwCrc32) + { + /* 计算的CRC32与ATS二次消息CRC32不一致 */ + strCfmSnd->chOpStatus = CONFIRM_SND_CRCFAIL; + } + else + { + strCfmSnd->chOpStatus = FollowUpDansuoCancleCheck(strMsgSnd->wDevId, ATS_CI_INFO_SND_DS_CANCEL); + } + } + ii = 0U; + szCrcTmp[ii] = strMsgSnd->chAtsId; + ii++; + szCrcTmp[ii] = strMsgSnd->chRtuId; + ii++; + ShortToChar(strMsgSnd->wIndex, &szCrcTmp[ii]); + ii += 2U; + LongToChar(strMsgSnd->dwTime, &szCrcTmp[ii]); + ii += 4u; + ShortToChar(strMsgSnd->wDevId, &szCrcTmp[ii]); + ii += 2u; + strCfmSnd->dwCrc32 = Tioc_CommonCrc32(szCrcTmp, ii); /* ATS编号、Rtu编号、操作站编号、二次下发时间、设备ID 计算CRC */ + debug_infor_printf((char*)"\n FollowUpDansuoCanclMsgProc DevId:%d, Second Reply:%d \n", strMsgSnd->wDevId, strCfmSnd->chOpStatus); + /*已处理*/ + ClearAtsCmdMsgFst(ATS_CI_INFO_FST_DS_CANCEL); + ClearAtsCmdReplyFst(RCI_ATS_INFO_FST_DS_CANCEL); + ClearAtsCmdMsgSnd(ATS_CI_INFO_SND_DS_CANCEL); + } + } + /*命令超时处理*/ + chRtn = SystemOverTimeCheck(strMsgFst->dwCycle, FOLLOWUP_CONFIRM_TIMEOUT); + if (CI_TIME_OUT == chRtn) + { + ClearAtsCmdMsgFst(ATS_CI_INFO_FST_DS_CANCEL); + ClearAtsCmdReplyFst(RCI_ATS_INFO_FST_DS_CANCEL); + ClearAtsCmdMsgSnd(ATS_CI_INFO_SND_DS_CANCEL); + ClearAtsCmdReplySnd(RCI_ATS_INFO_SND_DS_CANCEL); + } + } +} + +/* +* 功能描述: 道岔单解命令状态检查,返回成功或检查失败原因 +* 参数说明： + UINT16 wDevId命令中设备 + UINT16 wMsgType, 命令类型 +* 返回值 ： +1 成功 +2：道岔未设置单锁 +3：道岔不属于本集中区 +5：已办理非进路调车 +* BY fan 20260603 +*/ +UINT8 FollowUpDansuoCancleCheck(UINT16 wDevId, UINT16 wMsgType) +{ + UINT8 chRtn = CONFIRM_FST_BELONGERROR; + UINT8 chDevBelongCi = 0U;/*设备所属联锁*/ + UINT8 chLocalId = GetSystemParaLocalCiId(); + UINT8 localCiType = 0U; + UINT8 chNonRouteCheck = CI_ERROR; + UINT8 chState = 0U;/*当前状态*/ + UINT8 switchType = GetSwitchType(wDevId); + UINT16 switch2ndId = 0U;/*双动*/ + UINT8 functionId = EFUNC_FOLLOWUP_SWITCH_DANSUO_CANCLE; + UINT8 chVir = 0U;/*设备所属虚拟联锁ID*/ + chDevBelongCi = GetSwitchBelongCiId(wDevId); + + if (chDevBelongCi == chLocalId) + { + /*道岔1锁闭状态 =【单锁】或【单锁且防护锁闭】*/ + chState = GetSwitchLockStatus(wDevId); + if ((SWITCH_LOCK_STATUS_DANSUO == chState) || (SWITCH_LOCK_STATUS_DAP == chState)) + { + /*【单锁】或【单锁且防护锁闭】*/ + chRtn = CONFIRM_REPLY_SUCCESS; + if (SWITCH_TYPE_DOUBLE == switchType) + { + switch2ndId = GetDSwitchOtherId(wDevId); + chState = GetSwitchLockStatus(switch2ndId); + if ((SWITCH_LOCK_STATUS_DANSUO == chState) || (SWITCH_LOCK_STATUS_DAP == chState)) + { + chRtn = CONFIRM_REPLY_SUCCESS; + } + else + { + chRtn = CONFIRM_FST_UNSET; + SetErrorData(functionId, CI_DEVICE_TYPE_SWITCH, switch2ndId, ETYPE_SWT_LOCK_STATUS, SWITCH_LOCK_STATUS_DANSUO_NO, ESEND_LEVEL_ZERO); + /* 失败返回 */ + } + } + if (CONFIRM_REPLY_SUCCESS == chRtn) + { + chVir = GetSwitchBelongVirCiId(wDevId); + localCiType = GetLocalVirCiType(chVir); + if (CI_TYPE_CLD == localCiType) + { + chNonRouteCheck = CheckSwitchBelongNonRoute(wDevId); + if (CI_SUCCESS == chNonRouteCheck) + { /*道岔属于已办理非进路*/ + chRtn = CONFIRM_DEVICE_NONROUTE_SET; + debug_infor_printf((char*)"FollowUpDansuoCancleCheck Fail: Swicth%d SetNonRoute\n", wDevId); + } + else if (SWITCH_TYPE_DOUBLE == switchType) + { + chNonRouteCheck = CheckSwitchBelongNonRoute(switch2ndId); + if (CI_SUCCESS == chNonRouteCheck) + { /*道岔属于已办理非进路*/ + chRtn = CONFIRM_DEVICE_NONROUTE_SET; + debug_infor_printf((char*)"FollowUpDansuoCancleCheck Fail: Swicth%d SetNonRoute\n", switch2ndId); + } + else + { + ;/*无非进路检查 返回成功*/ + } + } + else + { + chRtn = CONFIRM_REPLY_SUCCESS; + } + } + else + { + ;/*无非进路检查 返回成功*/ + } + } + } + else + { + chRtn = CONFIRM_FST_UNSET; + SetErrorData(functionId, CI_DEVICE_TYPE_SWITCH, wDevId, ETYPE_SWT_LOCK_STATUS, SWITCH_LOCK_STATUS_DANSUO_NO, ESEND_LEVEL_ZERO); + } + } + else + { + chRtn = CONFIRM_FST_BELONGERROR; + } + + if ((CONFIRM_REPLY_SUCCESS == chRtn) && (ATS_CI_INFO_SND_DS_CANCEL == wMsgType)) + { + /*二次通过，执行操作*/ + if (SWITCH_TYPE_DOUBLE == switchType) + {/*双动道岔*/ + switch2ndId = GetDSwitchOtherId(wDevId); + SetSwitchLockStatus(SWITCH_PLOCKTYPE_DANSUO, 0u, switch2ndId, SWITCH_LOCK_DANSUO_CANCEL); /*取消另一道岔单锁*/ + } + + SetSwitchLockStatus(SWITCH_PLOCKTYPE_DANSUO, 0u, wDevId, SWITCH_LOCK_DANSUO_CANCEL); /*取消道岔单锁*/ + } + return chRtn; +} + +/* +* 功能描述: 道岔解封命令管理 +* 参数说明： 无 +* 返回值 ： void +* BY fan 20260602 +*/ +void FollowUpSwitchUnFlockMsgProc(void) +{ + AtsFollowUpCmdFstStru * strMsgFst = NULL;/*首次消息指针*/ + AtsFollowUpCmdSndStru * strMsgSnd = NULL;/*再次消息指针*/ + RCIFollowUpReplyStru * strCfmFst = NULL;/*首次回复指针*/ + RCIFollowUpReplyStru *strCfmSnd = NULL;/*二次回复指针*/ + UINT8 chLocalId = 0U; + UINT32 dwCycle = 0U; + UINT8 chRtn = CI_ERROR;/*中间获取结果*/ + UINT8 szCrcTmp[1024] = { 0U }; + UINT16 ii = 0U; + UINT32 dwCrc = 0U;/*二次消息CRC计算*/ + chLocalId = GetSystemParaLocalCiId(); + dwCycle = Get2oo2CurCycleNum(); + + /*获取对应一次、二次命令 以及首次、再次确认消息*/ + strMsgFst = GetAtsFollowUpMsgFst(ATS_CI_INFO_FST_SWIUNFLOCK); + strMsgSnd = GetAtsFollowUpMsgSnd(ATS_CI_INFO_SND_SWIUNFLOCK); + strCfmFst = GetAtsFollowUpReplyFst(RCI_ATS_INFO_FST_SWIUNFLOCK); + strCfmSnd = GetAtsFollowUpReplySnd(RCI_ATS_INFO_SND_SWIUNFLOCK); + if ((NULL == strMsgFst) || (NULL == strMsgSnd) + || (NULL == strCfmFst) || (NULL == strCfmSnd)) + { + ; + } + else + { + if ((strMsgFst->chFlag != FLAG_SET) && (strMsgSnd->chFlag != FLAG_SET)) + { + ; /* 没有新消息，什么也不做 */ + } + else if (strMsgFst->chFlag == FLAG_SET) + { + /* 一次消息有效 */ + if (strMsgFst->dwCycle == dwCycle) + { + strCfmFst->chFlag = FLAG_SET; + strCfmFst->chTiocId = chLocalId; + strCfmFst->chAtsId = strMsgFst->chAtsId; + strCfmFst->chRtuId = strMsgFst->chRtuId; + strCfmFst->wIndex = strMsgFst->wIndex; + strCfmFst->dwTime = dwCycle; + + if((SWITCH_SUM_MAX <= strMsgFst->wDevId) || (chLocalId != strMsgFst->chTiocId)) + {/* 获取设备ID出错，返回不属于本集中区*/ + strCfmFst->chOpStatus = CONFIRM_FST_BELONGERROR; + } + else + { + strCfmFst->chOpStatus = FollowUpSwitchUnFlockCheck(strMsgFst->wDevId, ATS_CI_INFO_FST_SWIUNFLOCK); + } + + szCrcTmp[ii] = strMsgFst->chAtsId; + ii++; + szCrcTmp[ii] = strMsgFst->chRtuId; + ii++; + ShortToChar(strMsgFst->wIndex, &szCrcTmp[ii]); + ii += 2U; + LongToChar(strMsgFst->dwTime, &szCrcTmp[ii]); + ii += 4U; + ShortToChar(strMsgFst->wDevId, &szCrcTmp[ii]); + ii += 2U; + strCfmFst->dwCrc32 = Tioc_CommonCrc32(szCrcTmp, ii); /* ATS编号、Rtu编号、操作站编号、一次下发时间、设备ID 计算CRC */ + + debug_infor_printf((char*)"\n FollowUpSwitchUnFlockMsgProc DevId:%d, First Reply:%d \n", strMsgFst->wDevId, strCfmFst->chOpStatus); + if (CONFIRM_REPLY_SUCCESS != strCfmFst->chOpStatus) + { + ClearAtsCmdMsgFst(ATS_CI_INFO_FST_SWIUNFLOCK); + } + else + { + strMsgFst->chFlag = FLAG_UNSET; + } + } + else + { + ;/* 接收到对应一次消息非本周期*/ + } + } + else + { + /* 二次命令处理*/ + if (strMsgSnd->dwCycle == dwCycle) + { + strCfmSnd->chFlag = FLAG_SET; + strCfmSnd->chTiocId = chLocalId; + strCfmSnd->chRtuId = strMsgSnd->chRtuId; + strCfmSnd->chAtsId = strMsgSnd->chAtsId; + strCfmSnd->wIndex = strMsgSnd->wIndex; + strCfmSnd->dwTime = dwCycle; + + if (0u == strMsgFst->chFlag) + { + /*对应一次命令已清零*/ + strCfmSnd->chOpStatus = CONFIRM_SND_FIRST_NOTFIND; + } + else if ((strMsgSnd->chAtsId != strMsgFst->chAtsId) + || (strMsgSnd->chRtuId != strMsgFst->chRtuId) + || (strMsgSnd->wIndex != strMsgFst->wIndex) + || (strMsgSnd->chTiocId != strMsgFst->chTiocId) + || (strMsgSnd->wDevId != strMsgFst->wDevId)) + { + strCfmSnd->chOpStatus = CONFIRM_SND_DIFFCMD; + } + else + { + szCrcTmp[ii] = strMsgSnd->chTiocId; + ii++; + LongToChar(strCfmFst->dwTime, &szCrcTmp[ii]); + ii += 4u; + ShortToChar(strMsgSnd->wDevId, &szCrcTmp[ii]); + ii += 2u; + dwCrc = Tioc_CommonCrc32(szCrcTmp, ii); + if (dwCrc != strMsgSnd->dwCrc32) + { + /* 计算的CRC32与ATS二次消息CRC32不一致 */ + strCfmSnd->chOpStatus = CONFIRM_SND_CRCFAIL; + } + else + { + strCfmSnd->chOpStatus = FollowUpSwitchUnFlockCheck(strMsgSnd->wDevId, ATS_CI_INFO_SND_SWIUNFLOCK); + } + } + ii = 0U; + szCrcTmp[ii] = strMsgSnd->chAtsId; + ii++; + szCrcTmp[ii] = strMsgSnd->chRtuId; + ii++; + ShortToChar(strMsgSnd->wIndex, &szCrcTmp[ii]); + ii += 2U; + LongToChar(strMsgSnd->dwTime, &szCrcTmp[ii]); + ii += 4u; + ShortToChar(strMsgSnd->wDevId, &szCrcTmp[ii]); + ii += 2u; + strCfmSnd->dwCrc32 = Tioc_CommonCrc32(szCrcTmp, ii); /* ATS编号、车站编号、操作站编号、ID 计算CRC*/ + debug_infor_printf((char*)"\n FollowUpSwitchUnFlockMsgProc DevId:%d, Second Reply:%d \n", strMsgSnd->wDevId, strCfmSnd->chOpStatus); + /*清除已处理命令*/ + ClearAtsCmdMsgFst(ATS_CI_INFO_FST_SWIUNFLOCK); + ClearAtsCmdReplyFst(RCI_ATS_INFO_FST_SWIUNFLOCK); + ClearAtsCmdMsgSnd(ATS_CI_INFO_SND_SWIUNFLOCK); + } + } + + /*超时处理*/ + chRtn = SystemOverTimeCheck(strMsgFst->dwCycle, FOLLOWUP_CONFIRM_TIMEOUT); + if (CI_TIME_OUT == chRtn) + { + ClearAtsCmdMsgFst(ATS_CI_INFO_FST_SWIUNFLOCK); + ClearAtsCmdReplyFst(RCI_ATS_INFO_FST_SWIUNFLOCK); + ClearAtsCmdMsgSnd(ATS_CI_INFO_SND_SWIUNFLOCK); + ClearAtsCmdReplySnd(RCI_ATS_INFO_SND_SWIUNFLOCK); + } + } +} + +/* +* 功能描述: 道岔解封命令状态检查,返回成功或检查失败原因，二次操作时执行命令 +* 参数说明： +UINT16 wDevId命令中设备 +UINT16 wMsgType, 命令类型 +* 返回值 ： +1 成功 +2：道岔未设置封锁 +3：道岔不属于本集中区 +5：已办理非进路调车 +* BY fan 20260603 +*/ +UINT8 FollowUpSwitchUnFlockCheck(UINT16 wDevId, UINT16 wMsgType) +{ + UINT8 chRtn = CONFIRM_FST_BELONGERROR; + UINT8 chDevBelongCi = 0U;/*设备所属联锁*/ + UINT8 chLocalId = GetSystemParaLocalCiId(); + UINT8 localCiType = 0U; + UINT8 chNonRouteCheck = CI_ERROR; + UINT8 chState = 0U;/*当前状态*/ + UINT8 switchType = GetSwitchType(wDevId); + UINT16 switch2ndId = 0U;/*双动*/ + UINT8 functionId = EFUNC_FOLLOWUP_SWITCH_UNFLOCK; + UINT8 chVir = 0U;/*设备所属虚拟联锁ID*/ + chDevBelongCi = GetSwitchBelongCiId(wDevId); + + if (chDevBelongCi == chLocalId) + { + /*道岔状态封锁*/ + chState = GetSwitchFLockState(wDevId); + if(SWITCH_LOCK_FENGSUO_YES == chState) + { + /*存在封锁*/ + chRtn = CONFIRM_REPLY_SUCCESS; + if (SWITCH_TYPE_DOUBLE == switchType) + { + switch2ndId = GetDSwitchOtherId(wDevId); + chState = GetSwitchFLockState(switch2ndId); + if (SWITCH_LOCK_FENGSUO_YES == chState) + { + chRtn = CONFIRM_REPLY_SUCCESS; + } + else + { + chRtn = CONFIRM_FST_UNSET; + SetErrorData(functionId, CI_DEVICE_TYPE_SWITCH, switch2ndId, ETYPE_SWT_FLOCK_STATE, SWITCH_LOCK_FENGSUO_NO, ESEND_LEVEL_ZERO); + } + } + if (CONFIRM_REPLY_SUCCESS == chRtn) + { + chVir = GetSwitchBelongVirCiId(wDevId); + localCiType = GetLocalVirCiType(chVir); + if (CI_TYPE_CLD == localCiType) + { + chNonRouteCheck = CheckSwitchBelongNonRoute(wDevId); + if (CI_SUCCESS == chNonRouteCheck) + { /*道岔属于已办理非进路*/ + chRtn = CONFIRM_DEVICE_NONROUTE_SET; + debug_infor_printf((char*)"FollowUpSwitchUnFlockCheck Fail: Swicth%d SetNonRoute\n", wDevId); + } + else if (SWITCH_TYPE_DOUBLE == switchType) + { + chNonRouteCheck = CheckSwitchBelongNonRoute(switch2ndId); + if (CI_SUCCESS == chNonRouteCheck) + { /*道岔属于已办理非进路*/ + chRtn = CONFIRM_DEVICE_NONROUTE_SET; + debug_infor_printf((char*)"FollowUpSwitchUnFlockCheck Fail: Swicth%d SetNonRoute\n", switch2ndId); + } + else + { + ;/*无非进路检查 返回成功*/ + } + } + else + { + chRtn = CONFIRM_REPLY_SUCCESS; + } + } + else + { + ;/*无非进路检查 返回成功*/ + } + } + } + else + { + chRtn = CONFIRM_FST_UNSET; + SetErrorData(functionId, CI_DEVICE_TYPE_SWITCH, wDevId, ETYPE_SWT_FLOCK_STATE, SWITCH_LOCK_FENGSUO_NO, ESEND_LEVEL_ZERO); + } + } + else + { + chRtn = CONFIRM_FST_BELONGERROR; + } + + if ((CONFIRM_REPLY_SUCCESS == chRtn) && (ATS_CI_INFO_SND_SWIUNFLOCK == wMsgType)) + { + /*二次通过，执行操作*/ + if (SWITCH_TYPE_DOUBLE == switchType) + {/*双动道岔*/ + switch2ndId = GetDSwitchOtherId(wDevId); + SetSwitchFLockState(switch2ndId, SWITCH_LOCK_FENGSUO_NO); /*取消另一道岔封锁*/ + } + SetSwitchFLockState(wDevId, SWITCH_LOCK_FENGSUO_NO); /*取消道岔封锁*/ + + } + return chRtn; +} + +/* +* 功能描述: 区段解封命令管理 +* 参数说明： 无 +* 返回值 ： void +* BY fan 20260604 +*/ +void FollowUpSecUnFlockMsgProc(void) +{ + AtsFollowUpCmdFstStru * strMsgFst = NULL;/*首次消息指针*/ + AtsFollowUpCmdSndStru * strMsgSnd = NULL;/*再次消息指针*/ + RCIFollowUpReplyStru * strCfmFst = NULL;/*首次回复指针*/ + RCIFollowUpReplyStru *strCfmSnd = NULL;/*二次回复指针*/ + UINT8 chLocalId = 0U; + UINT32 dwCycle = 0U; + UINT8 chRtn = CI_ERROR;/*中间获取结果*/ + UINT8 szCrcTmp[1024] = { 0U }; + UINT16 ii = 0U; + UINT32 dwCrc = 0U;/*二次消息CRC计算*/ + chLocalId = GetSystemParaLocalCiId(); + dwCycle = Get2oo2CurCycleNum(); + + /*获取对应一次、二次命令 以及首次、再次确认消息*/ + strMsgFst = GetAtsFollowUpMsgFst(ATS_CI_INFO_FST_SECUNFLOCK); + strMsgSnd = GetAtsFollowUpMsgSnd(ATS_CI_INFO_SND_SECUNFLOCK); + strCfmFst = GetAtsFollowUpReplyFst(RCI_ATS_INFO_FST_SECUNFLOCK); + strCfmSnd = GetAtsFollowUpReplySnd(RCI_ATS_INFO_SND_SECUNFLOCK); + if ((NULL == strMsgFst) || (NULL == strMsgSnd) + || (NULL == strCfmFst) || (NULL == strCfmSnd)) + { + ; + } + else + { + if ((strMsgFst->chFlag != FLAG_SET) && (strMsgSnd->chFlag != FLAG_SET)) + { + ; /* 没有新消息，什么也不做 */ + } + else if (strMsgFst->chFlag == FLAG_SET) + { + /* 一次消息有效 */ + if (strMsgFst->dwCycle == dwCycle) + { + strCfmFst->chFlag = FLAG_SET; + strCfmFst->chTiocId = chLocalId; + strCfmFst->chAtsId = strMsgFst->chAtsId; + strCfmFst->chRtuId = strMsgFst->chRtuId; + strCfmFst->wIndex = strMsgFst->wIndex; + strCfmFst->dwTime = dwCycle; + + if ((PHYSICAL_SECTION_SUM_MAX <= strMsgFst->wDevId) || (chLocalId != strMsgFst->chTiocId)) + {/* 获取设备ID出错，返回不属于本集中区*/ + strCfmFst->chOpStatus = CONFIRM_FST_BELONGERROR; + } + else + { + strCfmFst->chOpStatus = FollowUpSecUnFlockCheck(strMsgFst->wDevId, ATS_CI_INFO_FST_SECUNFLOCK); + } + + szCrcTmp[ii] = strMsgFst->chAtsId; + ii++; + szCrcTmp[ii] = strMsgFst->chRtuId; + ii++; + ShortToChar(strMsgFst->wIndex, &szCrcTmp[ii]); + ii += 2U; + LongToChar(strMsgFst->dwTime, &szCrcTmp[ii]); + ii += 4U; + ShortToChar(strMsgFst->wDevId, &szCrcTmp[ii]); + ii += 2U; + strCfmFst->dwCrc32 = Tioc_CommonCrc32(szCrcTmp, ii); /* ATS编号、Rtu编号、操作站编号、下发时间、设备ID 计算CRC */ + debug_infor_printf((char*)"\n FollowUpSecUnFlockMsgProc DevId:%d, First Reply:%d \n", strMsgFst->wDevId, strCfmFst->chOpStatus); + if (CONFIRM_REPLY_SUCCESS != strCfmFst->chOpStatus) + { + ClearAtsCmdMsgFst(ATS_CI_INFO_FST_SECUNFLOCK); + } + else + { + strMsgFst->chFlag = FLAG_UNSET; + } + } + else + { + ;/* 接收到对应一次消息非本周期*/ + } + } + else + { + /* 二次命令处理*/ + if (strMsgSnd->dwCycle == dwCycle) + { + strCfmSnd->chFlag = FLAG_SET; + strCfmSnd->chTiocId = chLocalId; + strCfmSnd->chRtuId = strMsgSnd->chRtuId; + strCfmSnd->chAtsId = strMsgSnd->chAtsId; + strCfmSnd->wIndex = strMsgSnd->wIndex; + strCfmSnd->dwTime = dwCycle; + + if (0u == strMsgFst->chFlag) + { + /*对应一次命令已清零*/ + strCfmSnd->chOpStatus = CONFIRM_SND_FIRST_NOTFIND; + } + else if ((strMsgSnd->chAtsId != strMsgFst->chAtsId) + || (strMsgSnd->chRtuId != strMsgFst->chRtuId) + || (strMsgSnd->wIndex != strMsgFst->wIndex) + || (strMsgSnd->chTiocId != strMsgFst->chTiocId) + || (strMsgSnd->wDevId != strMsgFst->wDevId)) + { + strCfmSnd->chOpStatus = CONFIRM_SND_DIFFCMD; + } + else + { + szCrcTmp[ii] = strMsgSnd->chTiocId; + ii++; + LongToChar(strCfmFst->dwTime, &szCrcTmp[ii]); + ii += 4u; + ShortToChar(strMsgSnd->wDevId, &szCrcTmp[ii]); + ii += 2u; + dwCrc = Tioc_CommonCrc32(szCrcTmp, ii); + if (dwCrc != strMsgSnd->dwCrc32) + { + /* 计算的CRC32与ATS二次消息CRC32不一致 */ + strCfmSnd->chOpStatus = CONFIRM_SND_CRCFAIL; + } + else + { + strCfmSnd->chOpStatus = FollowUpSecUnFlockCheck(strMsgSnd->wDevId, ATS_CI_INFO_SND_SECUNFLOCK); + } + } + ii = 0U; + szCrcTmp[ii] = strMsgSnd->chAtsId; + ii++; + szCrcTmp[ii] = strMsgSnd->chRtuId; + ii++; + ShortToChar(strMsgSnd->wIndex, &szCrcTmp[ii]); + ii += 2U; + LongToChar(strMsgSnd->dwTime, &szCrcTmp[ii]); + ii += 4u; + ShortToChar(strMsgSnd->wDevId, &szCrcTmp[ii]); + ii += 2u; + strCfmSnd->dwCrc32 = Tioc_CommonCrc32(szCrcTmp, ii); /* ATS编号、车站编号、操作站编号、下发时间、ID*/ + debug_infor_printf((char*)"\n FollowUpSecUnFlockMsgProc DevId:%d, Second Reply:%d \n", strMsgSnd->wDevId, strCfmSnd->chOpStatus); + /*已处理*/ + ClearAtsCmdMsgFst(ATS_CI_INFO_FST_SECUNFLOCK); + ClearAtsCmdReplyFst(RCI_ATS_INFO_FST_SECUNFLOCK); + ClearAtsCmdMsgSnd(ATS_CI_INFO_SND_SECUNFLOCK); + } + } + + chRtn = SystemOverTimeCheck(strMsgFst->dwCycle, FOLLOWUP_CONFIRM_TIMEOUT); + if (CI_TIME_OUT == chRtn) + { + ClearAtsCmdMsgFst(ATS_CI_INFO_FST_SECUNFLOCK); + ClearAtsCmdReplyFst(RCI_ATS_INFO_FST_SECUNFLOCK); + ClearAtsCmdMsgSnd(ATS_CI_INFO_SND_SECUNFLOCK); + ClearAtsCmdReplySnd(RCI_ATS_INFO_SND_SECUNFLOCK); + } + } +} + +/* +* 功能描述: 区段解封命令状态检查,返回成功或检查失败原因，二次操作时执行命令 +* 参数说明： +UINT16 wDevId命令中设备 +UINT16 wMsgType, 命令类型 +* 返回值 ： +1 成功 +2：未设置人工区段封锁 +3：不属于本集中区 +* BY fan 20260604 +*/ +UINT8 FollowUpSecUnFlockCheck(UINT16 wDevId, UINT16 wMsgType) +{ + UINT8 chRtn = CONFIRM_FST_BELONGERROR; + UINT8 chDevBelongCi = 0U;/*设备所属联锁*/ + UINT8 chLocalId = GetSystemParaLocalCiId(); + UINT8 chState = 0U;/*当前状态*/ + UINT8 flockType = 0u;/*封锁类型*/ + chDevBelongCi = GetPhySecBelongCiId(wDevId); + + if (chDevBelongCi == chLocalId) + { + /*检查状态封锁*/ + chState = GetPhySecFLockState(wDevId); + flockType = GetPhySecFLockType(wDevId); /*物理区段封锁类型*/ + if (PHYSICAL_SECTION_FLOCK_YES == chState) + { + if ((PHY_SEC_FLOCK_TYPE_SPKSCMD == flockType)|| (PHY_SEC_FLOCK_TYPE_CMD == flockType)) + {/*物理区段封锁*/ + chRtn = CONFIRM_REPLY_SUCCESS; + } + else + { + /*SPKS封锁不能取消封锁*/ + chRtn = CONFIRM_FST_UNSET; + SetErrorData(EFUNC_FOLLOWUP_SEC_UNFLOCK,CI_DEVICE_TYPE_PHYSEC,wDevId, ETYPE_PS_FLOCK_STATE, flockType, ESEND_LEVEL_ZERO); + } + } + else + { + chRtn = CONFIRM_FST_UNSET; + SetErrorData(EFUNC_FOLLOWUP_SEC_UNFLOCK, CI_DEVICE_TYPE_PHYSEC, wDevId, ETYPE_PS_UNFLOCK_STATE, chState, ESEND_LEVEL_ZERO); + } + } + else + { + chRtn = CONFIRM_FST_BELONGERROR; + } + + if ((CONFIRM_REPLY_SUCCESS == chRtn) && (ATS_CI_INFO_SND_SECUNFLOCK == wMsgType)) + { + /*二次通过，执行操作*/ + if (PHY_SEC_FLOCK_TYPE_CMD == flockType) + { + (void)SetPhySecFLockState(wDevId, PHYSICAL_SECTION_FLOCK_NO);/*设置物理区段封锁状态为未封锁*/ + SetPhySecFLockType(wDevId, PHY_SEC_FLOCK_TYPE_NONE);/*封锁类型设置成无封锁*/ + } + else + { + /*已检查spks或存在CMD，此处必有SPKS*/ + SetPhySecFLockType(wDevId, PHY_SEC_FLOCK_TYPE_SPKS); + } + } + return chRtn; +} + + +/* +* 功能描述: 信号机解封命令管理 +* 参数说明： 无 +* 返回值 ： void +* BY fan 20260604 +*/ +void FollowUpSignalUnFlockMsgProc(void) +{ + AtsFollowUpCmdFstStru * strMsgFst = NULL;/*首次消息指针*/ + AtsFollowUpCmdSndStru * strMsgSnd = NULL;/*再次消息指针*/ + RCIFollowUpReplyStru * strCfmFst = NULL;/*首次回复指针*/ + RCIFollowUpReplyStru *strCfmSnd = NULL;/*二次回复指针*/ + UINT8 chLocalId = 0U; + UINT32 dwCycle = 0U; + UINT8 chRtn = CI_ERROR;/*中间获取结果*/ + UINT8 szCrcTmp[1024] = { 0U }; + UINT16 ii = 0U; + UINT32 dwCrc = 0U;/*二次消息CRC计算*/ + chLocalId = GetSystemParaLocalCiId(); + dwCycle = Get2oo2CurCycleNum(); + + /*获取对应一次、二次命令 以及首次、再次确认消息*/ + strMsgFst = GetAtsFollowUpMsgFst(ATS_CI_INFO_FST_SIGUNFLOCK); + strMsgSnd = GetAtsFollowUpMsgSnd(ATS_CI_INFO_SND_SIGUNFLOCK); + strCfmFst = GetAtsFollowUpReplyFst(RCI_ATS_INFO_FST_SIGUNFLOCK); + strCfmSnd = GetAtsFollowUpReplySnd(RCI_ATS_INFO_SND_SIGUNFLOCK); + if ((NULL == strMsgFst) || (NULL == strMsgSnd) + || (NULL == strCfmFst) || (NULL == strCfmSnd)) + { + ; + } + else + { + if ((strMsgFst->chFlag != FLAG_SET) && (strMsgSnd->chFlag != FLAG_SET)) + { + ; /* 没有新消息，什么也不做 */ + } + else if (strMsgFst->chFlag == FLAG_SET) + { + /* 一次消息有效 */ + if (strMsgFst->dwCycle == dwCycle) + { + strCfmFst->chFlag = FLAG_SET; + strCfmFst->chTiocId = chLocalId; + strCfmFst->chAtsId = strMsgFst->chAtsId; + strCfmFst->chRtuId = strMsgFst->chRtuId; + strCfmFst->wIndex = strMsgFst->wIndex; + strCfmFst->dwTime = dwCycle; + + if ((SIGNAL_SUM_MAX <= strMsgFst->wDevId) || (chLocalId != strMsgFst->chTiocId)) + {/* 获取设备ID出错，返回不属于本集中区*/ + strCfmFst->chOpStatus = CONFIRM_FST_BELONGERROR; + } + else + { + strCfmFst->chOpStatus = FollowUpSignalUnFlockCheck(strMsgFst->wDevId, ATS_CI_INFO_FST_SIGUNFLOCK); + } + + szCrcTmp[ii] = strMsgFst->chAtsId; + ii++; + szCrcTmp[ii] = strMsgFst->chRtuId; + ii++; + ShortToChar(strMsgFst->wIndex, &szCrcTmp[ii]); + ii += 2U; + LongToChar(strMsgFst->dwTime, &szCrcTmp[ii]); + ii += 4U; + ShortToChar(strMsgFst->wDevId, &szCrcTmp[ii]); + ii += 2U; + strCfmFst->dwCrc32 = Tioc_CommonCrc32(szCrcTmp, ii); /* ATS编号、Rtu编号、操作站编号、下发时间、设备ID 计算CRC */ + + debug_infor_printf((char*)"\n FollowUpSignalUnFlockMsgProc DevId:%d, First Reply:%d \n", strMsgFst->wDevId, strCfmFst->chOpStatus); + if (CONFIRM_REPLY_SUCCESS != strCfmFst->chOpStatus) + { + ClearAtsCmdMsgFst(ATS_CI_INFO_FST_SIGUNFLOCK); + } + else + { + strMsgFst->chFlag = FLAG_UNSET; + } + } + else + { + ;/* 接收到对应一次消息非本周期*/ + } + } + else + { + /* 二次命令处理*/ + if (strMsgSnd->dwCycle == dwCycle) + { + strCfmSnd->chFlag = FLAG_SET; + strCfmSnd->chTiocId = chLocalId; + strCfmSnd->chRtuId = strMsgSnd->chRtuId; + strCfmSnd->chAtsId = strMsgSnd->chAtsId; + strCfmSnd->wIndex = strMsgSnd->wIndex; + strCfmSnd->dwTime = dwCycle; + + if (0u == strMsgFst->chFlag) + { + /*对应一次命令已清零*/ + strCfmSnd->chOpStatus = CONFIRM_SND_FIRST_NOTFIND; + } + else if ((strMsgSnd->chAtsId != strMsgFst->chAtsId) + || (strMsgSnd->chRtuId != strMsgFst->chRtuId) + || (strMsgSnd->wIndex != strMsgFst->wIndex) + || (strMsgSnd->chTiocId != strMsgFst->chTiocId) + || (strMsgSnd->wDevId != strMsgFst->wDevId)) + { + strCfmSnd->chOpStatus = CONFIRM_SND_DIFFCMD; + } + else + { + szCrcTmp[ii] = strMsgSnd->chTiocId; + ii++; + LongToChar(strCfmFst->dwTime, &szCrcTmp[ii]); + ii += 4u; + ShortToChar(strMsgSnd->wDevId, &szCrcTmp[ii]); + ii += 2u; + dwCrc = Tioc_CommonCrc32(szCrcTmp, ii); + if (dwCrc != strMsgSnd->dwCrc32) + { + /* 计算的CRC32与ATS二次消息CRC32不一致 */ + strCfmSnd->chOpStatus = CONFIRM_SND_CRCFAIL; + } + else + { + strCfmSnd->chOpStatus = FollowUpSignalUnFlockCheck(strMsgSnd->wDevId, ATS_CI_INFO_SND_SIGUNFLOCK); + } + } + ii = 0U; + szCrcTmp[ii] = strMsgSnd->chAtsId; + ii++; + szCrcTmp[ii] = strMsgSnd->chRtuId; + ii++; + ShortToChar(strMsgSnd->wIndex, &szCrcTmp[ii]); + ii += 2U; + LongToChar(strMsgSnd->dwTime, &szCrcTmp[ii]); + ii += 4u; + ShortToChar(strMsgSnd->wDevId, &szCrcTmp[ii]); + ii += 2u; + strCfmSnd->dwCrc32 = Tioc_CommonCrc32(szCrcTmp, ii); /* ATS编号、车站编号、操作站编号、下发时间、ID 计算CRC */ + debug_infor_printf((char*)"\n FollowUpSignalUnFlockMsgProc DevId:%d, Second Reply:%d \n", strMsgSnd->wDevId, strCfmSnd->chOpStatus); + /*清除已处理命令*/ + ClearAtsCmdMsgFst(ATS_CI_INFO_FST_SIGUNFLOCK); + ClearAtsCmdReplyFst(RCI_ATS_INFO_FST_SIGUNFLOCK); + ClearAtsCmdMsgSnd(ATS_CI_INFO_SND_SIGUNFLOCK); + } + } + + chRtn = SystemOverTimeCheck(strMsgFst->dwCycle, FOLLOWUP_CONFIRM_TIMEOUT); + if (CI_TIME_OUT == chRtn) + { + ClearAtsCmdMsgFst(ATS_CI_INFO_FST_SIGUNFLOCK); + ClearAtsCmdReplyFst(RCI_ATS_INFO_FST_SIGUNFLOCK); + ClearAtsCmdMsgSnd(ATS_CI_INFO_SND_SIGUNFLOCK); + ClearAtsCmdReplySnd(RCI_ATS_INFO_SND_SIGUNFLOCK); + } + } +} + +/* +* 功能描述: 信号机解封命令状态检查,返回成功或检查失败原因，二次操作时执行命令 +* 参数说明： +UINT16 wDevId命令中设备 +UINT16 wMsgType, 命令类型 +* 返回值 ： +1 成功 +2：未设置信号机封锁 +3：不属于本集中区 +5：所属非进路已办理 +* BY fan 20260604 +*/ +UINT8 FollowUpSignalUnFlockCheck(UINT16 wDevId, UINT16 wMsgType) +{ + UINT8 chRtn = CONFIRM_FST_BELONGERROR; + UINT8 chDevBelongCi = 0U;/*设备所属联锁*/ + UINT8 chLocalId = GetSystemParaLocalCiId(); + UINT8 chState = 0U;/*当前状态*/ + UINT8 localCiType = 0U; + UINT8 chNonRouteCheck = CI_ERROR; + UINT8 chVir = 0U;/*设备所属虚拟联锁ID*/ + chDevBelongCi = GetSignalBelongCiId(wDevId); + + if (chDevBelongCi == chLocalId) + { + /*检查状态封锁*/ + chState = GetSignalFLockState(wDevId); + if (SIGNAL_FENGSUO_YES == chState) + { + chVir = GetSignalBelongVirCiId(wDevId); + localCiType = GetLocalVirCiType(chVir); + if (CI_TYPE_CLD == localCiType) + { + chNonRouteCheck = CheckSignalBelongNonRoute(wDevId); + if (CI_SUCCESS == chNonRouteCheck) + { /*信号机属于已办理非进路*/ + chRtn = CONFIRM_DEVICE_NONROUTE_SET; + debug_infor_printf((char*)"FollowUpSignalUnFlockCheck Fail: Signal %d SetNonRoute\n", wDevId); + } + else + { + chRtn = CONFIRM_REPLY_SUCCESS; + } + } + else + { + chRtn = CONFIRM_REPLY_SUCCESS; + } + } + else + { + chRtn = CONFIRM_FST_UNSET; + SetErrorData(EFUNC_FOLLOWUP_SIGNAL_UNFLOCK, CI_DEVICE_TYPE_SIGNAL, wDevId, ETYPE_SIG_FLOCK_STATE, chState, ESEND_LEVEL_ZERO); + } + } + else + { + chRtn = CONFIRM_FST_BELONGERROR; + } + + if ((CONFIRM_REPLY_SUCCESS == chRtn) && (ATS_CI_INFO_SND_SIGUNFLOCK == wMsgType)) + { + /*二次通过，执行操作*/ + SetSignalFLockState(wDevId, SIGNAL_FENGSUO_NO); /*设置信号机未封锁*/ + } + return chRtn; +} + +/* +* 功能描述：信号已开放进路的共享资源处理 +* 参数说明：无 +* 返 回 值：无 +* Created By LQ 2026.06.09 +*/ +void OpenedRouteShareResPro(void) +{ + UINT8 cLocalCiId = 0U; /*本控区ID*/ + UINT16 wRouteCurSum = 0U; /*信号机数量*/ + UINT16 ii = 0U; + UINT16 wRouteId = 0U; /*进路ID*/ + UINT8 cRouteBelongCiId = 0U; /*进路所属控区ID*/ + UINT8 cRouteCurState = 0U; /*进路当前状态*/ + + cLocalCiId = GetSystemParaLocalCiId(); + wRouteCurSum = GetRouteCurSum(); + + for (ii = 0U; ii < wRouteCurSum; ii++) + { + wRouteId = GetRouteId(ii); + cRouteBelongCiId = GetRouteBelongCiId(wRouteId); /*获取进路所属联锁ID*/ + + /*判断是否为本控区进路*/ + if (cLocalCiId == cRouteBelongCiId) + { + cRouteCurState = GetRouteState(wRouteId); /*获取进路本周期状态*/ + + /*判断进路信号是否开放*/ + if ((ROUTE_STATE_YUXIAN_OPEN == cRouteCurState) || (ROUTE_STATE_NEAR_OPEN == cRouteCurState)) + { + /*进路状态为预先开放 或 接近开放，设置进路内逻辑区段资源共享标志为共享*/ + SetRouteLgcSecShareFlag(wRouteId, LOGIC_SECTION_RES_SHARE_YES); + } + else + { + /*其它场景，不处理*/ + } + } + else + { + /*非本控区进路，不处理*/ + } + } } \ No newline at end of file diff --git a/TSCP/src/APP/ciapp/LogicManage/InterlockLogicManage.h b/TSCP/src/APP/ciapp/LogicManage/InterlockLogicManage.h index e8e3a69..7307c7f 100644 --- a/TSCP/src/APP/ciapp/LogicManage/InterlockLogicManage.h +++ b/TSCP/src/APP/ciapp/LogicManage/InterlockLogicManage.h @@ -1175,6 +1175,116 @@ void AxisJumpLockStateManage(const UINT16 axisSectionId); * 返回值 ：CI_SUCCESS 是试车线（含合设） CI_ERROR */ UINT8 GetLocalCiIsScx(void); +/* +* 功能描述： 联络线进路解锁管理 +* 参数说明： const UINT16 wRouteId 进路ID +* 返回值 ： 无 +* Create:lyj 20260603 +*/ +void ConnectRouteReleaseManage(const UINT16 wRouteId); + +/* +* 功能描述: 新增一二次命令管理 +* 参数说明： 无 +* 返回值 ： void +* BY fan 20260602 +*/ +void AtsFollowUpCmdProcess(void); + +/* +* 功能描述: 道岔单解命令管理 +* 参数说明： 无 +* 返回值 ： void +* BY fan 20260602 +*/ +void FollowUpDansuoCanclMsgProc(void); + +/* +* 功能描述: 道岔单解命令状态检查,返回成功或检查失败原因 +* 参数说明： +UINT16 wDevId命令中设备 +UINT16 wMsgType, 命令类型 +* 返回值 ： +1 成功 +2：道岔未设置单锁 +3：道岔不属于本集中区 +5：已办理非进路调车 +* BY fan 20260603 +*/ +UINT8 FollowUpDansuoCancleCheck(UINT16 wDevId, UINT16 wMsgType); + +/* +* 功能描述: 道岔解封命令管理 +* 参数说明： 无 +* 返回值 ： void +* BY fan 20260602 +*/ +void FollowUpSwitchUnFlockMsgProc(void); + +/* +* 功能描述: 道岔解封命令状态检查,返回成功或检查失败原因，二次操作时执行命令 +* 参数说明： +UINT16 wDevId命令中设备 +UINT16 wMsgType, 命令类型 +* 返回值 ： +1 成功 +2：道岔未设置封锁 +3：道岔不属于本集中区 +5：已办理非进路调车 +* BY fan 20260603 +*/ +UINT8 FollowUpSwitchUnFlockCheck(UINT16 wDevId, UINT16 wMsgType); + +/* +* 功能描述: 区段解封命令管理 +* 参数说明： 无 +* 返回值 ： void +* BY fan 20260604 +*/ +void FollowUpSecUnFlockMsgProc(void); + +/* +* 功能描述: 区段解封命令状态检查,返回成功或检查失败原因，二次操作时执行命令 +* 参数说明： +UINT16 wDevId命令中设备 +UINT16 wMsgType, 命令类型 +* 返回值 ： +1 成功 +2：未设置人工区段封锁 +3：不属于本集中区 +* BY fan 20260604 +*/ +UINT8 FollowUpSecUnFlockCheck(UINT16 wDevId, UINT16 wMsgType); + +/* +* 功能描述: 信号机解封命令管理 +* 参数说明： 无 +* 返回值 ： void +* BY fan 20260604 +*/ +void FollowUpSignalUnFlockMsgProc(void); + +/* +* 功能描述: 信号机解封命令状态检查,返回成功或检查失败原因，二次操作时执行命令 +* 参数说明： +UINT16 wDevId命令中设备 +UINT16 wMsgType, 命令类型 +* 返回值 ： +1 成功 +2：未设置信号机封锁 +3：不属于本集中区 +5：所属非进路已办理 +* BY fan 20260604 +*/ +UINT8 FollowUpSignalUnFlockCheck(UINT16 wDevId, UINT16 wMsgType); + +/* +* 功能描述：信号已开放进路的共享资源处理 +* 参数说明：无 +* 返 回 值：无 +* Created By LQ 2026.06.09 +*/ +void OpenedRouteShareResPro(void); #ifdef __cplusplus } diff --git a/TSCP/src/APP/ciapp/LogicProcess/InterlockLogicCheck.c b/TSCP/src/APP/ciapp/LogicProcess/InterlockLogicCheck.c index 9fac982..fdd0991 100644 --- a/TSCP/src/APP/ciapp/LogicProcess/InterlockLogicCheck.c +++ b/TSCP/src/APP/ciapp/LogicProcess/InterlockLogicCheck.c @@ -7159,7 +7159,7 @@ UINT8 RouteExceptLastSecOccuClrCheck(UINT16 const routeId) UINT16 cancleZhaoChaRelayId = 0u; /*取消照查继电器ID*/ UINT8 relayState = 0u; /*继电器采集状态*/ UINT8 sendLevel = ESEND_LEVEL_ATS; /*发送ATS*/ - + UINT8 chRConnectReleaseFlag = 0U; /* 区段占用检查 */ if (0u == checkSum) { @@ -7211,10 +7211,20 @@ UINT8 RouteExceptLastSecOccuClrCheck(UINT16 const routeId) } else { - /* 记录故障码 */ - SetErrorData(functionId, CI_DEVICE_TYPE_RELAY, devId, ETYPE_CANCLE_ZHAOCHA, devState, sendLevel); - /* 失败返回 */ - result = CI_ERROR_QXZC; + chRConnectReleaseFlag = GetRouteConnectReleaseFlag(routeId); + if (ROUTE_CONNECT_RELEASE_YES == chRConnectReleaseFlag) + { + /* 通过检查 */ + result = CI_SUCCESS; + } + else + { + /* 记录故障码 */ + SetErrorData(functionId, CI_DEVICE_TYPE_RELAY, devId, ETYPE_CANCLE_ZHAOCHA, devState, sendLevel); + /* 失败返回 */ + result = CI_ERROR_QXZC; + } + } } @@ -7802,37 +7812,61 @@ UINT8 OtherCiDevStatusCheck(UINT16 const routeId,const RouteOtherCheckStruct *pO */ static UINT8 CheckRelationSignalOnSameOpen(UINT16 const routeId,UINT16 const relationSignalId,UINT8 const devStatus) { - UINT8 routeState = 0u,routeLeadProperty = 0u; + UINT8 routeState = 0U; + UINT8 routeLeadProperty = 0U; UINT8 ret = CI_SUCCESS; UINT8 routeType = 0u; /*进路类型*/ UINT8 relationSignalOpenColor = GetSignalCurColor(relationSignalId); UINT8 cRouteStartSigOpenColor = 0U; /*进路始端信号机开放颜色*/ - + UINT8 cRouteToLeadFlag = 0U; + UINT8 chOpenCloseState = 0U; routeState = GetRouteState(routeId); routeLeadProperty = GetRouteLeadProperty(routeId);/*获取进路引导属性*/ routeType = GetRouteType(routeId); /*获取进路类型*/ - if ((routeState != 0u) && (relationSignalOpenColor != 0u)) + + if ((routeState != 0U) && (relationSignalOpenColor != 0U)) { /* 如果信号开放，则检查本进路将要开放的信号是否比当前的开放的级别要高 */ - if (SIGNAL_OPEN == GetSignalOpenCloseState(relationSignalOpenColor)) + chOpenCloseState = GetSignalOpenCloseState(relationSignalOpenColor); + if (SIGNAL_OPEN == chOpenCloseState) { switch (relationSignalOpenColor) { case SIGNAL_SHOWCOLOUR_REDYELLOW: /* 红黄灯,即信号开放必须是引导信号 */ - - if (((ROUTE_LEAD_PROPERTY_YES == routeLeadProperty) || (ROUTE_LEAD_PROPERTY_CBTC_YES == routeLeadProperty)) - && ((ROUTE_STATE_LEAD_LOCK == routeState) + if ((ROUTE_LEAD_PROPERTY_YES == routeLeadProperty) || (ROUTE_LEAD_PROPERTY_CBTC_YES == routeLeadProperty)) + { + /* 进路为可引导*/ + if ((ROUTE_STATE_LEAD_LOCK == routeState) || (ROUTE_STATE_LEAD_LOCKERR == routeState) - || (ROUTE_STATE_LEAD_OPEN == routeState))) - {/* 进路为可引导，且进路状态为<引导锁闭>或<引导锁闭异常>或<引导开放> ,即进路将引导开放,关联 */ - ret = CI_SUCCESS; + || (ROUTE_STATE_LEAD_OPEN == routeState)) + { + /* 进路状态为<引导锁闭>或<引导锁闭异常>或<引导开放> */ + ret = CI_SUCCESS; + } + else + { + cRouteToLeadFlag = GetRouteToLeadFlag(routeId); /*获取引导进路转换标志*/ + if ((ROUTE_TO_LEAD_FLAG_YES == cRouteToLeadFlag) && + ((ROUTE_STATE_YUXIAN_LOCK == routeState) || (ROUTE_STATE_NEAR_LOCK == routeState) + || (ROUTE_STATE_FIRST_LOCKERR == routeState) || (ROUTE_STATE_NEAR_LOCKERR == routeState))) + { + /*列车进路转引导，转换标志有效，列车进路接近锁闭或者预先锁闭或初锁异常或接近锁闭异常可以转引导*/ + ret = CI_SUCCESS; + } + else + { + ret = CI_ERROR; + } + + } } else { ret = CI_ERROR; } + break; case SIGNAL_SHOWCOLOUR_WHITE: if (ROUTE_TYPE_DIAOCHE == routeType) @@ -10844,7 +10878,7 @@ UINT8 CheckRouteZongRenJieFeasibility(const UINT16 routeId) UINT8 sectionSum = 0u;/*进路包含的物理区段数量*/ /*故障发送级别*/ UINT8 sendLevel = ESEND_LEVEL_ATS; /*发送ATS*/ UINT16 secIdx = 0u;/*进路内包含的物理区段遍历索引变量*/ - + UINT8 chRouteConnectFlag = 0U; /*联锁条件检查*/ /* 进路内所有区段锁闭状态【正常锁闭】*/ devId = 0u; @@ -10967,10 +11001,20 @@ UINT8 CheckRouteZongRenJieFeasibility(const UINT16 routeId) } else { - /* 记录故障码 */ - SetErrorData(functionId, CI_DEVICE_TYPE_RELAY, devId, ETYPE_CANCLE_ZHAOCHA, devState, sendLevel); - /* 失败返回 */ - reResult = CI_ERROR; + chRouteConnectFlag = GetRouteConnectReleaseFlag(routeId); + if (ROUTE_CONNECT_RELEASE_YES == chRouteConnectFlag) + { + /* 通过检查 */ + reResult = CI_SUCCESS; + } + else + { + /* 记录故障码 */ + SetErrorData(functionId, CI_DEVICE_TYPE_RELAY, devId, ETYPE_CANCLE_ZHAOCHA, devState, sendLevel); + /* 失败返回 */ + reResult = CI_ERROR; + } + } } diff --git a/TSCP/src/APP/ciapp/LogicProcess/InterlockLogicProcess.c b/TSCP/src/APP/ciapp/LogicProcess/InterlockLogicProcess.c index a2a6580..643e003 100644 --- a/TSCP/src/APP/ciapp/LogicProcess/InterlockLogicProcess.c +++ b/TSCP/src/APP/ciapp/LogicProcess/InterlockLogicProcess.c @@ -6362,13 +6362,15 @@ UINT8 RouteOtherSecAutoUnlockProcess(UINT16 const routeId, UINT16* phySectionId) UINT8 sendLevel = ESEND_LEVEL_ZERO; /*不发送ATS*/ UINT8 chPhySecCurMergeState = 0U;/*物理区段当前融合状态*/ UINT8 chPhySecPreMergeState = 0U;/*物理区段之前融合状态*/ + UINT8 chPhyOtherLineFlag = 0U; + UINT16 wFrontPhyId = 0U; /*联锁检查*/ if(CI_SUCCESS == reResult) { /*找到属于当前进路的第一个【正常锁闭】区段*/ - if (nlockSectionId > 0u) + if (0U < nlockSectionId) { reResult = CI_SUCCESS; } @@ -6378,98 +6380,27 @@ UINT8 RouteOtherSecAutoUnlockProcess(UINT16 const routeId, UINT16* phySectionId) reResult = CI_ERROR; /*返回ID = 0*/ - *phySectionId = 0u; + *phySectionId = 0U; } } - if(CI_SUCCESS == reResult) + if (CI_SUCCESS == reResult) { - /*进路为【折返进路】且解锁区段为折返区段*/ - if ((routeType == ROUTE_TYPE_RETURN) - && (nlockSectionId == returnSecId)) + /* 判断是否联络线对方区段 */ + chPhyOtherLineFlag = GetPhyIsThisLineState(nlockSectionId); + if ((DEV_IS_THIS_LINE_NO == chPhyOtherLineFlag) && (UINT16_MAX == nextSecId) && (ROUTE_TYPE_RETURN != routeType)) { - /*折返解锁*/ - /*折返区段【空闲】之前【占用】*/ - chPhySecCurMergeState = GetPhySecCurMergeState(returnSecId); - chPhySecPreMergeState = GetPhySecPreMergeState(returnSecId); - - if ((SECTION_OCCUPY_NO == chPhySecCurMergeState) && - (SECTION_OCCUPY_YES == chPhySecPreMergeState)) + /*区段不是本线路，且不存在下一个区段,且进路不为折返*/ + wFrontPhyId = GetRoutePhySecFrontPhyId(routeId, nlockSectionId); + chPhySecPreMergeState = GetPhySecPreMergeState(wFrontPhyId); + chPhySecCurMergeState = GetPhySecCurMergeState(wFrontPhyId); + /* 前一区段当前空闲，之前占用 */ + if ((SECTION_OCCUPY_YES == chPhySecPreMergeState) && (SECTION_OCCUPY_NO == chPhySecCurMergeState)) { - reResult = CI_SUCCESS; - } - else - { - /* 失败返回 */ - reResult = CI_ERROR; - *phySectionId = nlockSectionId; - } - - if(CI_SUCCESS == reResult) - { - /*折出进路第一个区段【占用】*/ - chPhySecCurMergeState = GetPhySecCurMergeState(backSecId); - - if (SECTION_OCCUPY_YES == chPhySecCurMergeState) - { - /*折返正常*/ - reResult = CI_SUCCESS; - } - else - { - /*折返异常*/ - /* 记录故障码 */ - SetErrorData(functionId,CI_DEVICE_TYPE_PHYSEC,backSecId,ETYPE_PS_RUNLOCK_ERROR,chPhySecCurMergeState,sendLevel); - /* 失败返回 */ - reResult = RETURN_AUTOLOCK_ERR_EXCEPT; - *phySectionId = nlockSectionId; - } - } - if(CI_SUCCESS == reResult) - { - /*折返进路锁闭时间早于折出进路 且 折出进路状态为【接近锁闭正常】*/ - if ((returnRouteLockTime < backRouteLockTime) - && ((ROUTE_STATE_NEAR_LOCK == backRouteState) - || (ROUTE_STATE_AUTO_UNLOCK == backRouteState))) - { - reResult = CI_SUCCESS; - *phySectionId = nlockSectionId; - } - else - { - /*折返异常*/ - /* 记录故障码 */ - SetErrorData(functionId,CI_DEVICE_TYPE_ROUTE, wPhySecRLockId,ETYPE_PS_RUNLOCK_ERROR, backRouteState,sendLevel); - /* 失败返回 */ - reResult = RETURN_AUTOLOCK_ERR_EXCEPT; - *phySectionId = nlockSectionId; - } - } - } - else - { - /*正常解锁*/ - /*当前区段之前【当前空闲】【之前占用】*/ - chPhySecCurMergeState = GetPhySecCurMergeState(nlockSectionId); - chPhySecPreMergeState = GetPhySecPreMergeState(nlockSectionId); - - if ((SECTION_OCCUPY_NO == chPhySecCurMergeState) && - (SECTION_OCCUPY_YES == chPhySecPreMergeState)) - { - reResult = CI_SUCCESS; - } - else - { - /* 失败返回 */ - reResult = CI_ERROR; - *phySectionId = nlockSectionId; - - } - if(CI_SUCCESS == reResult) - { - /* 下一区段【占用】*/ - chPhySecCurMergeState = GetPhySecCurMergeState(nextSecId); - if (SECTION_OCCUPY_YES == chPhySecCurMergeState) + chPhySecPreMergeState = GetPhySecPreMergeState(nlockSectionId); + chPhySecCurMergeState = GetPhySecCurMergeState(nlockSectionId); + /* 待解锁区段当前空闲，之前占用 */ + if ((SECTION_OCCUPY_YES == chPhySecPreMergeState) && (SECTION_OCCUPY_NO == chPhySecCurMergeState)) { /*正常解锁区段*/ reResult = CI_SUCCESS; @@ -6477,59 +6408,171 @@ UINT8 RouteOtherSecAutoUnlockProcess(UINT16 const routeId, UINT16* phySectionId) } else { - if (validReturnSigId > 0u)/*通过进路转折返进路*/ - { - /*折出进路第一个区段占用*/ - chPhySecCurMergeState = GetPhySecCurMergeState(backSecId); + /* 失败返回 */ + reResult = CI_ERROR; + *phySectionId = nlockSectionId; + } + } + else + { + /* 失败返回 */ + reResult = CI_ERROR; + *phySectionId = nlockSectionId; + } - if (SECTION_OCCUPY_YES == chPhySecCurMergeState) - { - /*折返正常*/ - reResult = CI_SUCCESS; - } - else - { - /*折返异常*/ - /* 记录故障码 */ - SetErrorData(functionId,CI_DEVICE_TYPE_PHYSEC,backSecId,ETYPE_PS_RUNLOCK_ERROR, chPhySecCurMergeState,sendLevel); - /* 失败返回 */ - reResult = RETURN_AUTOLOCK_ERR_EXCEPT; - *phySectionId = nlockSectionId; - } - if(CI_SUCCESS == reResult) - { - /*折返进路锁闭时间早于折出进路 且 折出进路状态为【接近锁闭正常】*/ - if ((((INT32)(backRouteLockTime- returnRouteLockTime)) > 0 ) - &&(backRouteState == ROUTE_STATE_NEAR_LOCK)) - { - reResult = CI_SUCCESS; - *phySectionId = nlockSectionId; - } - else - { - /*折返异常*/ - /* 记录故障码 */ - SetErrorData(functionId,CI_DEVICE_TYPE_ROUTE, wPhySecRLockId,ETYPE_PS_RUNLOCK_ERROR, backRouteState,sendLevel); - /* 失败返回 */ - reResult = RETURN_AUTOLOCK_ERR_EXCEPT; - *phySectionId = nlockSectionId; - } - } + } + else + { + /*进路为【折返进路】且解锁区段为折返区段*/ + if ((ROUTE_TYPE_RETURN == routeType) + && (nlockSectionId == returnSecId)) + { + /*折返解锁*/ + /*折返区段【空闲】之前【占用】*/ + chPhySecCurMergeState = GetPhySecCurMergeState(returnSecId); + chPhySecPreMergeState = GetPhySecPreMergeState(returnSecId); + + if ((SECTION_OCCUPY_NO == chPhySecCurMergeState) && + (SECTION_OCCUPY_YES == chPhySecPreMergeState)) + { + reResult = CI_SUCCESS; + } + else + { + /* 失败返回 */ + reResult = CI_ERROR; + *phySectionId = nlockSectionId; + } + + if (CI_SUCCESS == reResult) + { + /*折出进路第一个区段【占用】*/ + chPhySecCurMergeState = GetPhySecCurMergeState(backSecId); + + if (SECTION_OCCUPY_YES == chPhySecCurMergeState) + { + /*折返正常*/ + reResult = CI_SUCCESS; } else - {/*通过进路解锁异常*/ - /*下一区段【空闲】（飞车）*/ - /* 解锁异常 */ + { + /*折返异常*/ /* 记录故障码 */ - SetErrorData(functionId,CI_DEVICE_TYPE_PHYSEC,nextSecId,ETYPE_PS_AUNLOCK_ERROR, chPhySecCurMergeState,sendLevel); + SetErrorData(functionId, CI_DEVICE_TYPE_PHYSEC, backSecId, ETYPE_PS_RUNLOCK_ERROR, chPhySecCurMergeState, sendLevel); + /* 失败返回 */ + reResult = RETURN_AUTOLOCK_ERR_EXCEPT; + *phySectionId = nlockSectionId; + } + } + if (CI_SUCCESS == reResult) + { + /*折返进路锁闭时间早于折出进路 且 折出进路状态为【接近锁闭正常】*/ + if ((returnRouteLockTime < backRouteLockTime) + && ((ROUTE_STATE_NEAR_LOCK == backRouteState) + || (ROUTE_STATE_AUTO_UNLOCK == backRouteState))) + { + reResult = CI_SUCCESS; + *phySectionId = nlockSectionId; + } + else + { + /*折返异常*/ + /* 记录故障码 */ + SetErrorData(functionId, CI_DEVICE_TYPE_ROUTE, wPhySecRLockId, ETYPE_PS_RUNLOCK_ERROR, backRouteState, sendLevel); /* 失败返回 */ reResult = RETURN_AUTOLOCK_ERR_EXCEPT; *phySectionId = nlockSectionId; } } } + else + { + /*正常解锁*/ + /*当前区段之前【当前空闲】【之前占用】*/ + chPhySecCurMergeState = GetPhySecCurMergeState(nlockSectionId); + chPhySecPreMergeState = GetPhySecPreMergeState(nlockSectionId); + + if ((SECTION_OCCUPY_NO == chPhySecCurMergeState) && + (SECTION_OCCUPY_YES == chPhySecPreMergeState)) + { + reResult = CI_SUCCESS; + } + else + { + /* 失败返回 */ + reResult = CI_ERROR; + *phySectionId = nlockSectionId; + + } + if (CI_SUCCESS == reResult) + { + /* 下一区段【占用】*/ + chPhySecCurMergeState = GetPhySecCurMergeState(nextSecId); + if (SECTION_OCCUPY_YES == chPhySecCurMergeState) + { + /*正常解锁区段*/ + reResult = CI_SUCCESS; + *phySectionId = nlockSectionId; + } + else + { + if (0U < validReturnSigId)/*通过进路转折返进路*/ + { + /*折出进路第一个区段占用*/ + chPhySecCurMergeState = GetPhySecCurMergeState(backSecId); + + if (SECTION_OCCUPY_YES == chPhySecCurMergeState) + { + /*折返正常*/ + reResult = CI_SUCCESS; + } + else + { + /*折返异常*/ + /* 记录故障码 */ + SetErrorData(functionId, CI_DEVICE_TYPE_PHYSEC, backSecId, ETYPE_PS_RUNLOCK_ERROR, chPhySecCurMergeState, sendLevel); + /* 失败返回 */ + reResult = RETURN_AUTOLOCK_ERR_EXCEPT; + *phySectionId = nlockSectionId; + } + if (CI_SUCCESS == reResult) + { + /*折返进路锁闭时间早于折出进路 且 折出进路状态为【接近锁闭正常】*/ + if (0 < (((INT32)(backRouteLockTime - returnRouteLockTime))) + && (ROUTE_STATE_NEAR_LOCK == backRouteState)) + { + reResult = CI_SUCCESS; + *phySectionId = nlockSectionId; + } + else + { + /*折返异常*/ + /* 记录故障码 */ + SetErrorData(functionId, CI_DEVICE_TYPE_ROUTE, wPhySecRLockId, ETYPE_PS_RUNLOCK_ERROR, backRouteState, sendLevel); + /* 失败返回 */ + reResult = RETURN_AUTOLOCK_ERR_EXCEPT; + *phySectionId = nlockSectionId; + } + } + } + else + {/*通过进路解锁异常*/ + /*下一区段【空闲】（飞车）*/ + /* 解锁异常 */ + /* 记录故障码 */ + SetErrorData(functionId, CI_DEVICE_TYPE_PHYSEC, nextSecId, ETYPE_PS_AUNLOCK_ERROR, chPhySecCurMergeState, sendLevel); + /* 失败返回 */ + reResult = RETURN_AUTOLOCK_ERR_EXCEPT; + *phySectionId = nlockSectionId; + } + } + } + } } + } + + return reResult; } @@ -7044,6 +7087,7 @@ UINT8 RouteCancelLogicProcess(UINT16 const routeId) /*故障发送级别*/ UINT8 sendLevel = ESEND_LEVEL_ATS; /*发送ATS*/ UINT8 cRouteType = 0U; /*进路类型*/ + UINT8 chRConnectReleaseFlag = 0U; /*联锁条件检查*/ /* 进路内所有区段锁闭状态【正常锁闭】*/ @@ -7131,10 +7175,20 @@ UINT8 RouteCancelLogicProcess(UINT16 const routeId) } else { - /* 记录故障码 */ - SetErrorData(functionId,CI_DEVICE_TYPE_RELAY,devId,ETYPE_CANCLE_ZHAOCHA,devState,sendLevel); - /* 失败返回 */ - reResult = CI_ERROR; + chRConnectReleaseFlag = GetRouteConnectReleaseFlag(routeId); + if (ROUTE_CONNECT_RELEASE_YES == chRConnectReleaseFlag) + { + /* 通过检查 */ + reResult = CI_SUCCESS; + } + else + { + /* 记录故障码 */ + SetErrorData(functionId, CI_DEVICE_TYPE_RELAY, devId, ETYPE_CANCLE_ZHAOCHA, devState, sendLevel); + /* 失败返回 */ + reResult = CI_ERROR; + } + } } @@ -13105,4 +13159,84 @@ void UpdateRouteCouplinkFlag(const UINT16 wRouteId) /*不处理*/ } +} +/* +* 功能描述： 联络线接车进路解锁处理 +* 参数说明： const UINT16 wRouteId 进路ID +* 返回值 ： 无 +* Create: lyj 20260603 +*/ +void ConnectRouteReleaseProc(const UINT16 wRouteId) +{ + UINT8 chRouteState = 0U; /*进路状态*/ + UINT8 chResult = 0U; + UINT16 wFirstOccuSecId = 0U;/*进路内方第一个占用的物理区段ID*/ + UINT8 chDevState = 0U; + UINT8 chTrainEnterSta = 0U; + UINT8 chZongRenJieResult = 0U; + + if ((0U < wRouteId) && (ROUTE_SUM_MAX > wRouteId)) + { + chRouteState = GetRouteState(wRouteId); + + if ((ROUTE_STATE_FIRST_LOCK == chRouteState) + || (ROUTE_STATE_FIRST_LOCKERR == chRouteState) + || (ROUTE_STATE_YUXIAN_LOCK == chRouteState) + || (ROUTE_STATE_NEAR_LOCKERR == chRouteState)) + { + chZongRenJieResult = CheckRouteZongRenJieFeasibility(wRouteId); + chResult = RouteAllSecOccuClearCheck(wRouteId, &wFirstOccuSecId, &chDevState); + if (CI_SUCCESS == chZongRenJieResult) + { + SetRouteStateManage(wRouteId, ROUTE_STATE_DELAY_UNLOCK); /*-->设置进路延时解锁*/ + + if (CI_SUCCESS == chResult) + { + /*进路内无占压，延时后全部解锁*/ + SetRouteZongRenJieDelayType(wRouteId, ROUTE_ZRJ_DELAY_TYPE_IDLE); + } + else + { + /*延时后部分绿光带，即一个占压的物理区段之前的物理区段变绿光带*/ + SetRouteZongRenJieDelayType(wRouteId, ROUTE_ZRJ_DELAY_TYPE_EXP_TO_OCCUPY); + } + } + else + { + /*进路不能解锁*/ + } + + } + else if ((ROUTE_STATE_LEAD_LOCK == chRouteState) || (ROUTE_STATE_LEAD_LOCKERR == chRouteState)) + { + chTrainEnterSta = GetRouteTrainEnterFlag(wRouteId); + chZongRenJieResult = RouteExceptLastSecOccuClrCheck(wRouteId); + if (CI_SUCCESS == chZongRenJieResult) + { + /*所有区段空闲或最后一个区段占用*/ + SetRouteStateManage(wRouteId, ROUTE_STATE_DELAY_UNLOCK); /*-->设置进路延时解锁*/ + /*延时后全部解锁*/ + SetRouteZongRenJieDelayType(wRouteId, ROUTE_ZRJ_DELAY_TYPE_IDLE);/*延时结束后所有区段解锁*/ + } + else if (ROUTE_TRAIN_ENTER_FLAG_NO == chTrainEnterSta) + { + SetRouteStateManage(wRouteId, ROUTE_STATE_DELAY_UNLOCK); /*-->设置进路延时解锁*/ + /*延时后全部解锁*/ + SetRouteZongRenJieDelayType(wRouteId, ROUTE_ZRJ_DELAY_TYPE_IDLE);/*延时结束后所有区段解锁*/ + } + else + { + /*不解锁*/ + } + } + else + { + /*记录进路状态不满足*/ + SetErrorData(EFUNC_ROUTE_ZRJ_DEAL, CI_DEVICE_TYPE_ROUTE, wRouteId, ETYPE_ROUTE_STATE, chRouteState, ESEND_LEVEL_ATS); + } + } + else + { + /*不处理；进路ID异常，不做报警*/ + } } \ No newline at end of file diff --git a/TSCP/src/APP/ciapp/LogicProcess/InterlockLogicProcess.h b/TSCP/src/APP/ciapp/LogicProcess/InterlockLogicProcess.h index 57a3165..c516182 100644 --- a/TSCP/src/APP/ciapp/LogicProcess/InterlockLogicProcess.h +++ b/TSCP/src/APP/ciapp/LogicProcess/InterlockLogicProcess.h @@ -841,6 +841,13 @@ UINT8 SetRouteCouplinkProcess(const UINT16 wRouteId, const UINT8 functionId, con * Create: 20250919 */ void UpdateRouteCouplinkFlag(const UINT16 wRouteId); +/* +* 功能描述： 联络线接车进路解锁处理 +* 参数说明： const UINT16 wRouteId 进路ID +* 返回值 ： 无 +* Create: lyj 20260603 +*/ +void ConnectRouteReleaseProc(const UINT16 wRouteId); #ifdef __cplusplus } diff --git a/TSCP/src/APP/ciapp/PSD/PSDConfigDataManage.c b/TSCP/src/APP/ciapp/PSD/PSDConfigDataManage.c index 2f1df0e..7157403 100644 --- a/TSCP/src/APP/ciapp/PSD/PSDConfigDataManage.c +++ b/TSCP/src/APP/ciapp/PSD/PSDConfigDataManage.c @@ -1183,3 +1183,51 @@ UINT16 GetIbpConfmRelayId(const UINT16 doorId) } return retVal; } + +/* +* 功能描述： 设置倒切板卡 +* 参数说明： const UINT16 PsdId, 屏蔽门ID，UINT16 wBoardId 板卡Id +* 返回值 ： CI_SUCCESS CI_ERROR +*/ +UINT8 SetPsdRelateReverseRelay(const UINT16 PsdId, UINT16 wBoardId) +{ + UINT16 bufIndex = 0u; /*数组下标*/ + UINT8 chRet = CI_ERROR; + bufIndex = GetPsdConfigBufIndex(PsdId); /*获取数组下标*/ + + if (bufIndex < PSD_SUM_MAX) + { + PsdConfigDataStru[bufIndex].wReverseBoardId = wBoardId; + chRet = CI_SUCCESS; + } + else + { + ; + } + return chRet; +} + +/* +* 功能描述： 获取倒切板卡 +* 参数说明： const UINT16 wPsdId, 屏蔽门ID +* 返回值 ： UINT16_MAX: 获取数据失败 +* 0: 无倒切 +* [1,65534]板卡ID +*/ +UINT16 GetPsdRelateReverseBoardId(const UINT16 wPsdId) +{ + UINT16 bufIndex = 0u; /*数组下标*/ + UINT16 retVal = UINT16_MAX; + + bufIndex = GetPsdConfigBufIndex(wPsdId); /*获取数组下标*/ + + if (bufIndex < PSD_SUM_MAX) + { + retVal = PsdConfigDataStru[bufIndex].wReverseBoardId; + } + else + { + retVal = UINT16_MAX; + } + return retVal; +} diff --git a/TSCP/src/APP/ciapp/PSD/PSDConfigDataManage.h b/TSCP/src/APP/ciapp/PSD/PSDConfigDataManage.h index caa656a..c1e571d 100644 --- a/TSCP/src/APP/ciapp/PSD/PSDConfigDataManage.h +++ b/TSCP/src/APP/ciapp/PSD/PSDConfigDataManage.h @@ -73,6 +73,7 @@ typedef struct S_PsdConfigDataStruct UINT16 IncloudeEsbIdBuf[PSD_INCLUDE_ESB_NUM]; /*屏蔽门包含ESB ID*/ UINT8 IncloudeEsbNum; /*包含ESB数量*/ UINT16 wIbpRelayId; /*IBP盘发车按钮继电器ID*/ + UINT16 wReverseBoardId; /*所属倒切板卡Id*/ } PsdConfigDataStruct; @@ -461,6 +462,23 @@ UINT16* GetPsdIncloudeEsbIdBuf(const UINT16 psdId); */ UINT16 GetIbpConfmRelayId(const UINT16 doorId); +/* +* 功能描述： 设置倒切板卡 +* 参数说明： const UINT16 PsdId, 屏蔽门ID，UINT16 wBoardId 板卡Id +* 返回值 ： CI_SUCCESS CI_ERROR +*/ +UINT8 SetPsdRelateReverseRelay(const UINT16 PsdId,UINT16 wBoardId); + +/* +* 功能描述： 获取倒切板卡 +* 参数说明： const UINT16 wPsdId, 屏蔽门ID +* 返回值 ： UINT16_MAX: 获取数据失败 +* 0: 无倒切 +* [1,65534]板卡ID +*/ +UINT16 GetPsdRelateReverseBoardId(const UINT16 wPsdId); + + #ifdef __cplusplus } #endif diff --git a/TSCP/src/APP/ciapp/PSD/PSDDataManage.c b/TSCP/src/APP/ciapp/PSD/PSDDataManage.c index 36eba83..d692c3d 100644 --- a/TSCP/src/APP/ciapp/PSD/PSDDataManage.c +++ b/TSCP/src/APP/ciapp/PSD/PSDDataManage.c @@ -851,7 +851,7 @@ UINT32 GetStartDetectionCycNum(const UINT16 doorId) * 返回值 ： 无 * */ -void SetStartDetectionState(const UINT16 doorId, const UINT32 detectionState) +void SetStartDetectionState(const UINT16 doorId, const UINT8 detectionState) { UINT16 bufIndex = 0u; /*数组下标*/ @@ -861,7 +861,7 @@ void SetStartDetectionState(const UINT16 doorId, const UINT32 detectionState) { if ((JXTC_START_DETECTION_NO == detectionState) || (JXTC_START_DETECTION_YES == detectionState) ) { - PsdDataStru[bufIndex].StartDetectionState = (UINT8)(detectionState); + PsdDataStru[bufIndex].StartDetectionState = detectionState; } else { @@ -906,7 +906,7 @@ UINT8 GetStartDetectionState(const UINT16 doorId) * 返回值 ： 无 * */ -void SetStopDetectionState(const UINT16 doorId, const UINT32 detectionState) +void SetStopDetectionState(const UINT16 doorId, const UINT8 detectionState) { UINT16 bufIndex = 0u; /*数组下标*/ @@ -916,7 +916,7 @@ void SetStopDetectionState(const UINT16 doorId, const UINT32 detectionState) { if ((JXTC_STOP_DETECTION_NO == detectionState) || (JXTC_STOP_DETECTION_YES == detectionState) ) { - PsdDataStru[bufIndex].StopDetectionState = (UINT8)(detectionState); + PsdDataStru[bufIndex].StopDetectionState = detectionState; } else { @@ -1405,7 +1405,7 @@ UINT16 GetPsdEditGroupInfoFromPsdData(const UINT16 doorId) * 返回值 ： 无 * */ -void SetVOBCDoorState(const UINT16 doorId, const UINT32 doorState) +void SetVOBCDoorState(const UINT16 doorId, const UINT8 doorState) { UINT16 bufIndex = 0u; /*数组下标*/ @@ -1415,7 +1415,7 @@ void SetVOBCDoorState(const UINT16 doorId, const UINT32 doorState) { if ((PSD_DOOR_CLOSEDANDLOCKED_VALID == doorState) || (PSD_DOOR_CLOSEDANDLOCKED_INVALID == doorState)) { - PsdDataStru[bufIndex].VOBCDoorState = (UINT8)(doorState); + PsdDataStru[bufIndex].VOBCDoorState = doorState; } else { @@ -3416,4 +3416,58 @@ UINT8 GetPsdStateToVobc(const UINT16 doorId) } } return chRet; +} + +/* +* 功能描述：设置列车非零速状态 +* 参数说明： const UINT16 doorId, 屏蔽门ID +* const UINT32 detectionState, 非零速状态 +* 返回值 ： 无 +* +*/ +void SetTrainZeroSpeedState(const UINT16 doorId, const UINT8 detectionState) +{ + UINT16 bufIndex = 0u; /*数组下标*/ + + bufIndex = GetPsdConfigBufIndex(doorId); /*获取屏蔽门数组下标*/ + + if (bufIndex < PSD_SUM_MAX) + { + if ((PSD_TRAIN_ZERO_SPEED_NO == detectionState) || (PSD_TRAIN_ZERO_SPEED_YES == detectionState)) + { + PsdDataStru[bufIndex].chTrainZeroSpeedState = detectionState; + } + else + { + /*不做处理*/ + } + + } + else + { + /*不做处理*/ + } +} +/* +* 功能描述： 获取列车非零速状态 +* 参数说明： const UINT16 doorId, 屏蔽门ID +* 返回值 ： 0: 获取数据失败 +* >0: 非零速状态 +*/ +UINT8 GetTrainZeroSpeedState(const UINT16 doorId) +{ + UINT16 bufIndex = 0u; /*数组下标*/ + UINT8 retVal = CI_ERROR; + + bufIndex = GetPsdConfigBufIndex(doorId); /*获取屏蔽门数组下标*/ + + if (bufIndex < PSD_SUM_MAX) + { + retVal = PsdDataStru[bufIndex].chTrainZeroSpeedState; + } + else + { + retVal = CI_ERROR; + } + return retVal; } \ No newline at end of file diff --git a/TSCP/src/APP/ciapp/PSD/PSDDataManage.h b/TSCP/src/APP/ciapp/PSD/PSDDataManage.h index 40963f7..e749f06 100644 --- a/TSCP/src/APP/ciapp/PSD/PSDDataManage.h +++ b/TSCP/src/APP/ciapp/PSD/PSDDataManage.h @@ -98,6 +98,7 @@ typedef struct S_PsdDataStruct UINT32 JXTCMutualLockStartCycNum; /*间隙探测互锁解除起始时间*/ UINT8 ibpButtonState; /*IBP盘发车按钮状态(动态字段)*/ UINT32 IBPPressCycNum; /*IBP按下起始周期*/ + UINT8 chTrainZeroSpeedState; /*列车非零速状态*/ } PsdDataStruct; /*屏蔽门数据结构体*/ @@ -386,7 +387,7 @@ UINT32 GetStartDetectionCycNum(const UINT16 doorId); * 返回值 ： 无 * */ -void SetStartDetectionState(const UINT16 doorId, const UINT32 detectionState); +void SetStartDetectionState(const UINT16 doorId, const UINT8 detectionState); /* * 功能描述： 获取开始启动探测状态 * 参数说明： const UINT16 routeId, 进路ID @@ -402,7 +403,7 @@ UINT8 GetStartDetectionState(const UINT16 doorId); * 返回值 ： 无 * */ -void SetStopDetectionState(const UINT16 doorId, const UINT32 detectionState); +void SetStopDetectionState(const UINT16 doorId, const UINT8 detectionState); /* * 功能描述： 获取停止探测状态 @@ -541,7 +542,7 @@ UINT16 GetPsdEditGroupInfoFromPsdData(const UINT16 doorId); * 返回值 ： 无 * */ -void SetVOBCDoorState(const UINT16 doorId, const UINT32 doorState); +void SetVOBCDoorState(const UINT16 doorId, const UINT8 doorState); /* * 功能描述： 获取VOBC2CI车门状态信息 @@ -1185,6 +1186,23 @@ UINT8 SetIBPPressCycNum(const UINT16 doorId, const UINT32 startCycNum); * 返回值 ：屏蔽门状态 */ UINT8 GetPsdStateToVobc(const UINT16 doorId); + +/* +* 功能描述：设置列车非零速状态 +* 参数说明： const UINT16 doorId, 屏蔽门ID +* const UINT32 detectionState, 非零速状态 +* 返回值 ： 无 +* +*/ +void SetTrainZeroSpeedState(const UINT16 doorId, const UINT8 detectionState); + +/* +* 功能描述： 获取列车非零速状态 +* 参数说明： const UINT16 doorId, 屏蔽门ID +* 返回值 ： 0: 获取数据失败 +* >0: 非零速状态 +*/ +UINT8 GetTrainZeroSpeedState(const UINT16 doorId); #ifdef __cplusplus } #endif diff --git a/TSCP/src/APP/ciapp/PSD/PSDDefine.h b/TSCP/src/APP/ciapp/PSD/PSDDefine.h index ccb324b..d1c7470 100644 --- a/TSCP/src/APP/ciapp/PSD/PSDDefine.h +++ b/TSCP/src/APP/ciapp/PSD/PSDDefine.h @@ -17,7 +17,7 @@ /*屏蔽门总数最大值*/ -#define PSD_SUM_MAX ((UINT16)150U) /*定义屏蔽门数量最大值*/ +#define PSD_SUM_MAX ((UINT16)200U) /*定义屏蔽门数量最大值*/ /*和屏蔽门关联的出站进路数目最大值*/ #define RALATED_OUT_STATION_ROUTE_SUM_MAX ((UINT16)10U) /*屏蔽门关联的出站进路数目最大值*/ @@ -228,4 +228,8 @@ #define CI_IVOC_PSD_STATE_OPEN ((UINT8)0x55U) /*CI到IVOC屏蔽门打开*/ #define CI_IVOC_PSD_STATE_PANGLU ((UINT8)0xCCU) /*CI到IVOC屏蔽门互锁解除*/ #define CI_IVOC_PSD_STATE_OPEN_EXCEPT ((UINT8)0x33U) /*CI到IVOC屏蔽门异常打开*/ + +#define PSD_TRAIN_ZERO_SPEED_YES ((UINT8)0x55U) /*列车零速*/ +#define PSD_TRAIN_ZERO_SPEED_NO ((UINT8)0xAAU) /*列车非零速*/ + #endif diff --git a/TSCP/src/APP/ciapp/ParsePack/CiInterfaceDefine.h b/TSCP/src/APP/ciapp/ParsePack/CiInterfaceDefine.h index 96ca9c3..59b3e6a 100644 --- a/TSCP/src/APP/ciapp/ParsePack/CiInterfaceDefine.h +++ b/TSCP/src/APP/ciapp/ParsePack/CiInterfaceDefine.h @@ -164,6 +164,8 @@ #define ATS_CMD_APPLY_PASSXICHE ((UINT8)0xB2) /*现地请求反向洗车命令-降级模式*/ #define ATS_CMD_CANCEL_PASSXICHE ((UINT8)0xB3) /*现地取消反向洗车命令-降级模式*/ #define ATS_CMD_CANCEL_PSD_EXCEPT ((UINT8)0xBA) /*现地取消站台门异常状态*/ +#define ATS_CMD_CONNECT_ROUTE_RELEASE_ONE ((UINT8)0xBB) /*联络线接车进路解锁一次*/ +#define ATS_CMD_CONNECT_ROUTE_RELEASE_TWO ((UINT8)0xBC) /*联络线接车进路解锁二次*/ /****联锁到其他联锁的命令宏定义****/ #define CI_CMD_PHYSEC_USING_APPLY ((UINT16)0x0001) /*物理区段征用申请*/ @@ -246,9 +248,10 @@ #define CI_BACK_GROUP_AUTO_ROUTE_SET_ERR ((UINT8)0x7e) /*组合自动进路自动属性设置失败*/ -#define CI_BACK_AUTO_TRIGGER_SET_ERR (UINT8)0x85 /*进路的自动触发标志设置失败*/ +#define CI_BACK_AUTO_TRIGGER_SET_ERR ((UINT8)0x85) /*进路的自动触发标志设置失败*/ #define CI_BACK_LEAD_ROUTE_CANCEL ((UINT8)0xA4) /*引导进路无法使用总取消解锁反馈*/ #define CI_BACK_COUPLINK_ROUTE_IDLE ((UINT8)0xAF) /*联挂进路内无被联挂车*/ +#define CI_BACK_CONNECT_ROUTE_RELEASE ((UINT8)0xBB) /*联络线接车进路解锁条件不满足*/ /*信号机故障反馈*/ #define CI_BACK_SIG_START_OPEN ((UINT8)0x11) /*进路始端信号机开放*/ @@ -469,6 +472,48 @@ #define CI_BACK_ALLAUTO_RETURN_FLOOD_STATE_ERR ((UINT8)0x9C) /*全自动折返进路存在防淹门不满足*/ #define CI_BACK_ALLAUTO_RETURN_COUPROUTE_SET ((UINT8)0xB2) /*全自动折返联挂进路已办理*/ +#define ATS_CI_INFO_TYPE_FIRST_LEN ((UINT16)11) /*ATS首次命令长度*/ +#define ATS_CI_INFO_TYPE_SND_LEN ((UINT16)15) /*ATS再次命令长度*/ + +/* ATS二次命令帧首次消息结构体 */ +typedef struct +{ + UINT8 chFlag; /*首次消息接收状态*/ + UINT32 dwCycle; /*首次消息接收周期号*/ + UINT8 chAtsId; /*ATS编号:不为0时发送网关*/ + UINT8 chRtuId; /*Rtu编号：不为0时发送现地，全0发ATS*/ + UINT16 wIndex; /*操作站编号*/ + UINT8 chTiocId; /*TIOC编号*/ + UINT32 dwTime; /*请求时间*/ + UINT16 wDevId; /*操作设备ID*/ +}AtsFollowUpCmdFstStru; + +/* ATS二次命令帧再次消息结构体 */ +typedef struct +{ + UINT8 chFlag; /*首次消息接收状态*/ + UINT32 dwCycle; /*再次消息接收周期号*/ + UINT8 chAtsId; /*ATS编号:不为0时发送网关*/ + UINT8 chRtuId; /*Rtu编号：不为0时发送现地，全0发ATS*/ + UINT16 wIndex; /*操作站编号*/ + UINT8 chTiocId; /*TIOC编号*/ + UINT32 dwTime; /*请求时间*/ + UINT16 wDevId; /*操作设备ID*/ + UINT32 dwCrc32; /*再次发送中Crc*/ +}AtsFollowUpCmdSndStru; + +/*二次命令帧反馈信息结构体 */ +typedef struct +{ + UINT8 chFlag; /*消息有效性*/ + UINT8 chTiocId; /*TIOC编号*/ + UINT8 chAtsId; /*Ats编号: 判断组包对象使用，不包含在组包内容中*/ + UINT8 chRtuId; /*Rtu编号*/ + UINT16 wIndex; /*操作站编号*/ + UINT32 dwTime; /*时间*/ + UINT8 chOpStatus; /*操作结果*/ + UINT32 dwCrc32; /*CRC*/ +}RCIFollowUpReplyStru; #endif diff --git a/TSCP/src/APP/ciapp/ParsePack/ParsePackAtsData.c b/TSCP/src/APP/ciapp/ParsePack/ParsePackAtsData.c index 72da56d..e5a52e2 100644 --- a/TSCP/src/APP/ciapp/ParsePack/ParsePackAtsData.c +++ b/TSCP/src/APP/ciapp/ParsePack/ParsePackAtsData.c @@ -46,6 +46,36 @@ PSCToCiDataStruct* pscCiSendToAtsDataStru = NULL; ReciveAtsCmdDataCycInfo szReciveAtsCmdDataCycInfo[ATS_SUM_MAX * 2U] = {0U}; /*收到ATS命令数据周期号信息数组*/ UINT16 gReciveAtsCmdDataDeviceSum = 0U; /*收到ATS命令数据设备数目*/ +AtsFollowUpCmdFstStru gDansuoCancleMsgFst = { 0u }; /*取消单锁首次消息*/ +RCIFollowUpReplyStru gDansuoCancleReplyFst = { 0u }; /*取消单锁首次确认*/ +AtsFollowUpCmdSndStru gDansuoCancleMsgSnd = { 0u }; /*取消单锁二次消息*/ +RCIFollowUpReplyStru gDansuoCancleReplySnd = { 0u }; /*取消单锁二次确认*/ + +AtsFollowUpCmdFstStru gSwitchUnflockMsgFst = { 0u }; /*道岔解封首次消息*/ +RCIFollowUpReplyStru gSwitchUnflockReplyFst = { 0u }; /*道岔解封首次确认*/ +AtsFollowUpCmdSndStru gSwitchUnflockMsgSnd = { 0u }; /*道岔解封二次消息*/ +RCIFollowUpReplyStru gSwitchUnflockReplySnd = { 0u }; /*道岔解封二次确认*/ + +AtsFollowUpCmdFstStru gSecUnflockMsgFst = { 0u }; /*区段解封首次消息*/ +RCIFollowUpReplyStru gSecUnflockReplyFst = { 0u }; /*区段解封首次确认*/ +AtsFollowUpCmdSndStru gSecUnflockMsgSnd = { 0u }; /*区段解封二次消息*/ +RCIFollowUpReplyStru gSecUnflockReplySnd = { 0u }; /*区段解封二次确认*/ + +AtsFollowUpCmdFstStru gSignalUnflockMsgFst = { 0u }; /*信号机解封首次消息*/ +RCIFollowUpReplyStru gSignalUnflockReplyFst = { 0u }; /*信号机解封首次确认*/ +AtsFollowUpCmdSndStru gSignalUnflockMsgSnd = { 0u }; /*信号机解封二次消息*/ +RCIFollowUpReplyStru gSignalUnflockReplySnd = { 0u }; /*信号机解封二次确认*/ + +AtsFollowUpCmdFstStru gZRJMsgFst = { 0u }; /*总人解首次消息*/ +RCIFollowUpReplyStru gZRJReplyFst = { 0u }; /*总人解首次确认*/ +AtsFollowUpCmdSndStru gZRJMsgSnd = { 0u }; /*总人解二次消息*/ +RCIFollowUpReplyStru gZRJReplySnd = { 0u }; /*总人解二次确认*/ + +AtsFollowUpCmdFstStru gCanclPsdExceptMsgFst = { 0u }; /*解除站台门异常首次消息*/ +RCIFollowUpReplyStru gCanclPsdExceptReplyFst = { 0u }; /*解除站台门异常首次确认*/ +AtsFollowUpCmdSndStru gCanclPsdExceptMsgSnd = { 0u }; /*解除站台门异常二次消息*/ +RCIFollowUpReplyStru gCanclPsdExceptReplySnd = { 0u }; /*解除站台门异常二次确认*/ + /* * 功能描述： 组包Ci到Ats逻辑区段已征用信息 * 参数说明： const UINT8* pDataBuf, 数据缓冲区 @@ -189,7 +219,6 @@ UINT8 ParseAtsOrXianDiToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLengt UINT32 dwCiAndAtsTimeOutTime = 0u; /*联锁与ATS通信中断时间*/ UINT32 dwCiCurappCycleTime = 0u; /*联锁当前周期*/ INT32 remainValidiy = 0; /*剩余时间是否有效*/ - UINT16 wApplyDataLenth = 0U; /*应用层数据长度*/ UINT16 wTmpDataLen = 0U; /*数据长度临时记录变量*/ UINT16 wMsgLen = 0U; /*一条应用数据长度*/ UINT16 wMsgType = 0U; /*报文类型*/ @@ -198,7 +227,14 @@ UINT8 ParseAtsOrXianDiToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLengt UINT8 chCurSystemAreaState = 0U; /*当前系统区域状态*/ UINT32 dwReciveCmdDataAtsCycNum = 0U; /*收到ATS命令数据时ATS周期号*/ UINT32 dwSystemUpdateMainUseCycNum = 0U; /*系统主用起始周期号*/ - + UINT16 wPreCmdNum = 0U;/*上周期命令数：用于命令帧校验通过、二次信息校验失败时清除本次收到命令帧*/ + UINT16 wCurCmdNum = 0U;/*命令帧解析后当前命令总数*/ + AtsFollowUpCmdFstStru tempFstCmd[FOLLOWUP_MSGID_MAX] = { 0U };/*一次命令临时存储*/ + AtsFollowUpCmdSndStru tempSndCmd[FOLLOWUP_MSGID_MAX] = { 0U };/*二次命令临时存储*/ + UINT16 wIndex = 0U;/*临时信息存储索引*/ + UINT16 wMsgTypeTmp = 0U;/*拷贝回全局变量的信息类型*/ + AtsFollowUpCmdFstStru *pGlobalFst = NULL; + AtsFollowUpCmdSndStru *pGlobalSnd = NULL; if ((NULL!= dataBuf) && (0u < dataLength)) { chAtsInterfaceType = GetCiFunctionSwitchConfig(FUNC_ATS_INTERFACE_IDENTIFIER); @@ -261,6 +297,8 @@ UINT8 ParseAtsOrXianDiToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLengt else { chRetVal = CI_SUCCESS; + /*先获取上一周期是存储进路办理命令数*/ + wPreCmdNum = GetCiRevCmdStruCurSum(); while (wTmpDataLen < hlhtGalHead.totalDataLen) { @@ -321,6 +359,83 @@ UINT8 ParseAtsOrXianDiToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLengt debug_infor_printf((const)"\nATS/Xiandi %d Not Deal Cmd,Because chCurSystemAreaState %d\n", chDeciveId, chCurSystemAreaState); } break; + case ATS_CI_INFO_FST_DS_CANCEL: + case ATS_CI_INFO_FST_SWIUNFLOCK: + case ATS_CI_INFO_FST_FAULTUNLOCK: + case ATS_CI_INFO_FST_SECUNFLOCK: + case ATS_CI_INFO_FST_SIGUNFLOCK: + case ATS_CI_INFO_FST_ZONGRENJIE: + case ATS_CI_INFO_FST_PSD_UNEXCEPT: + chCurSystemAreaState = GetLocalCiBackUpPattern(); + if (SYSTEM_WORK_MODE_MAIN == chCurSystemAreaState) + { + /*主用解析操作命令，必须检查当前该包数据是否已经处理过*/ + dwReciveCmdDataAtsCycNum = GetReciveCmdDataAtsCycNum(chDevType, chDeciveId); + dwSystemUpdateMainUseCycNum = GetSystemUpdateMainUseCycNum(); + + if ((dwReciveCmdDataAtsCycNum < hlhtGalHead.crntOwnMsgSN) || + (dwSystemUpdateMainUseCycNum <= hlhtGalHead.recvOppMsgSN)) + { + /*当前ATS发送数据时的周期号大于接收到ATS数据时ATS周期号 + 或当前ATS发送数据时的联锁周期号大于等于当前系统升级主用起始周期号*/ + wIndex = (wMsgType - ATS_CI_INFO_FST_DS_CANCEL) / 4; + if ((FOLLOWUP_MSGID_MAX > wIndex)&&(ATS_CI_INFO_TYPE_FIRST_LEN == wMsgCheckLen)) + { + chRetVal = ProcessCmdFirstMsgCheck(dataBuf, ii, &tempFstCmd[wIndex]); + ii += ATS_CI_INFO_TYPE_FIRST_LEN; + chExistCmdDataFlag = 1U; /*先设置存在命令数据标志有效，数据解析不过在下面置为无效*/ + } + else + { + chRetVal = CI_ERROR;/*越界防护*/ + } + + } + else + { + ii += wMsgCheckLen; + /*已经被另外一机处理过了*/ + debug_infor_printf((const)"\nATS/Xiandi %d Not Deal FstCmd%d,Because curCmd has been processed by another System,dwReciveCmdDataAtsCycNum %d dwSystemUpdateMainUseCycNum %d\n", chDeciveId, wMsgType, dwReciveCmdDataAtsCycNum, dwSystemUpdateMainUseCycNum); + } + } + break; + case ATS_CI_INFO_SND_DS_CANCEL: + case ATS_CI_INFO_SND_SWIUNFLOCK: + case ATS_CI_INFO_SND_FAULTUNLOCK: + case ATS_CI_INFO_SND_SECUNFLOCK: + case ATS_CI_INFO_SND_SIGUNFLOCK: + case ATS_CI_INFO_TYPE_SND_ZRJ: + case ATS_CI_INFO_SND_PSD_UNEXCEPT: + chCurSystemAreaState = GetLocalCiBackUpPattern(); + if (SYSTEM_WORK_MODE_MAIN == chCurSystemAreaState) + { + /*主用解析操作命令，必须检查当前该包数据是否已经处理过*/ + dwReciveCmdDataAtsCycNum = GetReciveCmdDataAtsCycNum(chDevType, chDeciveId); + dwSystemUpdateMainUseCycNum = GetSystemUpdateMainUseCycNum(); + + if ((dwReciveCmdDataAtsCycNum < hlhtGalHead.crntOwnMsgSN) || + (dwSystemUpdateMainUseCycNum <= hlhtGalHead.recvOppMsgSN)) + { + wIndex = (wMsgType - ATS_CI_INFO_SND_DS_CANCEL) / 4; + if ((FOLLOWUP_MSGID_MAX > wIndex) && (ATS_CI_INFO_TYPE_SND_LEN == wMsgCheckLen)) + { + chRetVal = ProcessCmdSndMsgCheck(dataBuf, ii, &tempSndCmd[wIndex]); + ii += ATS_CI_INFO_TYPE_SND_LEN; + chExistCmdDataFlag = 1U; /*先设置存在命令数据标志有效，数据解析不过在下面置为无效*/ + } + else + { + chRetVal = CI_ERROR;/*越界防护*/ + } + } + else + { + ii += wMsgCheckLen; + /*已经被另外一机处理过了*/ + debug_infor_printf((const)"\nATS/Xiandi %d Not Deal SndCmd%d,Because curCmd has been processed by another System,dwReciveCmdDataAtsCycNum %d dwSystemUpdateMainUseCycNum %d\n", chDeciveId, wMsgType, dwReciveCmdDataAtsCycNum, dwSystemUpdateMainUseCycNum); + } + } + break; default: chRetVal = CI_ERROR; break; @@ -340,21 +455,51 @@ UINT8 ParseAtsOrXianDiToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLengt } - if (CI_SUCCESS == chRetVal) + /*校验数据长度*/ + if ((hlhtGalHead.totalDataLen != ii - (UINT16)31U) || (dataLength != hlhtGalHead.totalDataLen+ (UINT16)31U)) { - /*校验数据长度*/ - if (hlhtGalHead.totalDataLen != ii - 31U) - { - /* 31为应用数据帧头长度 */ - chRetVal = CI_ERROR; + /* 31为应用数据帧头长度 */ + chRetVal = CI_ERROR; + debug_infor_printf((char*)"Lenght Error \n"); + } + if (CI_SUCCESS != chRetVal) + { + /*清除本次存储的命令信息*/ + wCurCmdNum = GetCiRevCmdStruCurSum();/*当前命令信息数*/ + ToaClearCmd(); + for (wIndex = wPreCmdNum; wIndex <= wCurCmdNum; wIndex++) + { + (void)CommonMemSet(&CiRevCmdDataStru[wIndex], (UINT32)sizeof(CommandDataStruct), 0u, (UINT32)sizeof(CommandDataStruct)); } } else { - ; + /*将临时一二次信息拷贝到全局变量*/ + for (wIndex = 0U; wIndex < FOLLOWUP_MSGID_MAX; wIndex++) + { + if (FLAG_SET == tempFstCmd[wIndex].chFlag) + { + wMsgTypeTmp = ATS_CI_INFO_FST_DS_CANCEL + wIndex*(UINT16)4U; + pGlobalFst = GetAtsFollowUpMsgFst(wMsgTypeTmp); + if (NULL != pGlobalFst) + { + (void)CommonMemCpy((void *)(pGlobalFst), (UINT32)sizeof(AtsFollowUpCmdFstStru), (const void *)(&tempFstCmd[wIndex]), (UINT32)sizeof(AtsFollowUpCmdFstStru)); + } + } + if (FLAG_SET == tempSndCmd[wIndex].chFlag) + { + wMsgTypeTmp = ATS_CI_INFO_SND_DS_CANCEL + wIndex*(UINT16)4U; + pGlobalSnd = GetAtsFollowUpMsgSnd(wMsgTypeTmp); + if (NULL != pGlobalSnd) + { + (void)CommonMemCpy((void *)(pGlobalSnd), (UINT32)sizeof(AtsFollowUpCmdSndStru), (const void *)(&tempSndCmd[wIndex]), (UINT32)sizeof(AtsFollowUpCmdSndStru)); + } + } + } } + if (CI_SUCCESS == chRetVal) { /*数据经过校验，需要存储通用报文上下文*/ @@ -578,6 +723,12 @@ UINT8 PackCiToAtsOrXianDiData(const UINT8 deviceId, const UINT8 targetDevType, c ; /*继续组包*/ } } + + if (CI_SUCCESS == chReval) + { + /*进行一次、二次回复单独信息帧组包*/ + chReval = PackCiToAtsFollowUpMsg(ciToXianDiDataBuffer, &ii, targetDevType, PACK_ATS_TYPE_CENTER); + } } else { @@ -1297,6 +1448,9 @@ UINT8 FindFirstOrder(UINT8 SecondOrder) case ATS_CMD_EMERG_XS_CANCEL_TWO: reVal = ATS_CMD_EMERG_XS_CANCEL_ONE; /*取消紧急临时限速一次*/ break; + case ATS_CMD_CONNECT_ROUTE_RELEASE_TWO: /*联络线接车进路解锁二次*/ + reVal = ATS_CMD_CONNECT_ROUTE_RELEASE_ONE; /*联络线接车进路解锁一次*/ + break; default: reVal = 0u; break; @@ -3622,7 +3776,8 @@ UINT8 ReciveAtsCmdDeal(const UINT8* dataBuf, UINT16* dataIndex,const UINT16 wDat } if (CI_ERROR == chRetVal) - {/*包内有数据错误，丢包处理*/ + { + /*包内有数据错误，丢包处理*/ /*清除这本包数据*/ ToaClearCmd(); commandTotalSum = 0u; @@ -3930,4 +4085,504 @@ void PackRcOrCiDeciveCommonState(UINT8* ciToXianDiDataBuffer, UINT16* ii) { /*入参检查失败，不处理*/ } +} + +/** +* @brief 获取ATS对应的首次消息 +* @param[in] const UINT16 wMsgType, 命令类型 +* @return 获取ATS二次信息帧中的首次消息 +* @note by fan 20260602 +*/ +AtsFollowUpCmdFstStru * GetAtsFollowUpMsgFst(UINT16 chMsgType) +{ + AtsFollowUpCmdFstStru* rtnVal = NULL; + switch (chMsgType) + { + case ATS_CI_INFO_FST_DS_CANCEL: + rtnVal = &gDansuoCancleMsgFst; + break; + case ATS_CI_INFO_FST_SWIUNFLOCK: + rtnVal = &gSwitchUnflockMsgFst; + break; + case ATS_CI_INFO_FST_FAULTUNLOCK: + break; + case ATS_CI_INFO_FST_SECUNFLOCK: + rtnVal = &gSecUnflockMsgFst; + break; + case ATS_CI_INFO_FST_SIGUNFLOCK: + rtnVal = &gSignalUnflockMsgFst; + break; + case ATS_CI_INFO_FST_ZONGRENJIE: + break; + case ATS_CI_INFO_FST_PSD_UNEXCEPT: + break; + default: + break; + } + return rtnVal; +} + +/** +* @brief 获取ATS对应的二次消息 +* @param[in] const UINT16 wMsgType, 命令类型 +* @return 获取ATS二次信息帧中的再次消息 +* @note by fan 20260602 +*/ +AtsFollowUpCmdSndStru * GetAtsFollowUpMsgSnd(UINT16 chMsgType) +{ + AtsFollowUpCmdSndStru* rtnVal = NULL; + switch (chMsgType) + { + case ATS_CI_INFO_SND_DS_CANCEL: + rtnVal = &gDansuoCancleMsgSnd; + break; + case ATS_CI_INFO_SND_SWIUNFLOCK: + rtnVal = &gSwitchUnflockMsgSnd; + break; + case ATS_CI_INFO_SND_FAULTUNLOCK: + break; + case ATS_CI_INFO_SND_SECUNFLOCK: + rtnVal = &gSecUnflockMsgSnd; + break; + case ATS_CI_INFO_SND_SIGUNFLOCK: + rtnVal = &gSignalUnflockMsgSnd; + break; + case ATS_CI_INFO_TYPE_SND_ZRJ: + break; + case ATS_CI_INFO_SND_PSD_UNEXCEPT: + break; + default: + break; + } + return rtnVal; +} + +/** +* @brief 获取ATS对应的首次反馈消息 +* @param[in] const UINT16 wMsgType, 命令类型 +* @return 获取ATS二次信息帧中的首次反馈 +* @note by fan 20260602 +*/ +RCIFollowUpReplyStru * GetAtsFollowUpReplyFst(UINT16 chMsgType) +{ + RCIFollowUpReplyStru* rtnVal = NULL; + switch (chMsgType) + { + case RCI_ATS_INFO_FST_DS_CANCEL: + rtnVal = &gDansuoCancleReplyFst; + break; + case RCI_ATS_INFO_FST_SWIUNFLOCK: + rtnVal = &gSwitchUnflockReplyFst; + break; + case RCI_ATS_INFO_FST_FAULTUNLOCK: + break; + case RCI_ATS_INFO_FST_SECUNFLOCK: + rtnVal = &gSecUnflockReplyFst; + break; + case RCI_ATS_INFO_FST_SIGUNFLOCK: + rtnVal = &gSignalUnflockReplyFst; + break; + case RCI_ATS_INFO_FST_ZONGRENJIE: + break; + case RCI_ATS_INFO_FST_PSD_UNEXCEPT: + break; + default: + break; + } + return rtnVal; +} + +/** +* @brief 获取ATS对应的再次反馈消息 +* @param[in] const UINT16 wMsgType, 命令类型 +* @return 获取ATS二次信息帧中的再次反馈 +* @note by fan 20260602 +*/ +RCIFollowUpReplyStru * GetAtsFollowUpReplySnd(UINT16 chMsgType) +{ + RCIFollowUpReplyStru* rtnVal = NULL; + switch (chMsgType) + { + case RCI_ATS_INFO_SND_DS_CANCEL: + rtnVal = &gDansuoCancleReplySnd; + break; + case RCI_ATS_INFO_SND_SWIUNFLOCK: + rtnVal = &gSwitchUnflockReplySnd; + break; + case RCI_ATS_INFO_SND_FAULTUNLOCK: + break; + case RCI_ATS_INFO_SND_SECUNFLOCK: + rtnVal = &gSecUnflockReplySnd; + break; + case RCI_ATS_INFO_SND_SIGUNFLOCK: + rtnVal = &gSignalUnflockReplySnd; + break; + case RCI_ATS_INFO_SND_ZRJ: + break; + case RCI_ATS_INFO_SND_PSD_UNEXCEPT: + break; + default: + break; + } + return rtnVal; +} + +/** +* @brief 清除1次ATS命令信息 +* @param[in] const UINT16 wMsgType, 命令类型 +* @return void +* @note by fan 20260603 +*/ +void ClearAtsCmdMsgFst(UINT16 chMsgType) +{ + switch (chMsgType) + { + case ATS_CI_INFO_FST_DS_CANCEL: + (void)CommonMemSet((void*)&gDansuoCancleMsgFst, (UINT32)sizeof(gDansuoCancleMsgFst), (UINT8)0U, (UINT32)sizeof(gDansuoCancleMsgFst)); + break; + case ATS_CI_INFO_FST_SWIUNFLOCK: + (void)CommonMemSet((void*)&gSwitchUnflockMsgFst, (UINT32)sizeof(gSwitchUnflockMsgFst), (UINT8)0U, (UINT32)sizeof(gSwitchUnflockMsgFst)); + break; + case ATS_CI_INFO_FST_FAULTUNLOCK: + break; + case ATS_CI_INFO_FST_SECUNFLOCK: + (void)CommonMemSet((void*)&gSecUnflockMsgFst, (UINT32)sizeof(gSecUnflockMsgFst), (UINT8)0U, (UINT32)sizeof(gSecUnflockMsgFst)); + break; + case ATS_CI_INFO_FST_SIGUNFLOCK: + (void)CommonMemSet((void*)&gSignalUnflockMsgFst, (UINT32)sizeof(gSignalUnflockMsgFst), (UINT8)0U, (UINT32)sizeof(gSignalUnflockMsgFst)); + break; + case ATS_CI_INFO_FST_ZONGRENJIE: + break; + case ATS_CI_INFO_FST_PSD_UNEXCEPT: + break; + default: + break; + } +} + +/** +* @brief 清除首次反馈信息 +* @param[in] const UINT16 wMsgType, 命令类型 +* @return void +* @note by fan 20260603 +*/ +void ClearAtsCmdReplyFst(UINT16 chMsgType) +{ + switch (chMsgType) + { + case RCI_ATS_INFO_FST_DS_CANCEL: + (void)CommonMemSet((void*)&gDansuoCancleReplyFst, (UINT32)sizeof(gDansuoCancleReplyFst), (UINT8)0U, (UINT32)sizeof(gDansuoCancleReplyFst)); + break; + case RCI_ATS_INFO_FST_SWIUNFLOCK: + (void)CommonMemSet((void*)&gSwitchUnflockReplyFst, (UINT32)sizeof(gSwitchUnflockReplyFst), (UINT8)0U, (UINT32)sizeof(gSwitchUnflockReplyFst)); + break; + case RCI_ATS_INFO_FST_FAULTUNLOCK: + break; + case RCI_ATS_INFO_FST_SECUNFLOCK: + (void)CommonMemSet((void*)&gSecUnflockReplyFst, (UINT32)sizeof(gSecUnflockReplyFst), (UINT8)0U, (UINT32)sizeof(gSecUnflockReplyFst)); + break; + case RCI_ATS_INFO_FST_SIGUNFLOCK: + (void)CommonMemSet((void*)&gSignalUnflockReplyFst, (UINT32)sizeof(gSignalUnflockReplyFst), (UINT8)0U, (UINT32)sizeof(gSignalUnflockReplyFst)); + break; + case RCI_ATS_INFO_FST_ZONGRENJIE: + break; + case RCI_ATS_INFO_FST_PSD_UNEXCEPT: + break; + default: + break; + } +} +/** +* @brief 清除2次ATS命令信息 +* @param[in] const UINT16 wMsgType, 命令类型 +* @return void +* @note by fan 20260603 +*/ +void ClearAtsCmdMsgSnd(UINT16 chMsgType) +{ + switch (chMsgType) + { + case ATS_CI_INFO_SND_DS_CANCEL: + (void)CommonMemSet((void*)&gDansuoCancleMsgSnd, (UINT32)sizeof(gDansuoCancleMsgSnd), (UINT8)0U, (UINT32)sizeof(gDansuoCancleMsgSnd)); + break; + case ATS_CI_INFO_SND_SWIUNFLOCK: + (void)CommonMemSet((void*)&gSwitchUnflockMsgSnd, (UINT32)sizeof(gSwitchUnflockMsgSnd), (UINT8)0U, (UINT32)sizeof(gSwitchUnflockMsgSnd)); + break; + case ATS_CI_INFO_SND_FAULTUNLOCK: + break; + case ATS_CI_INFO_SND_SECUNFLOCK: + (void)CommonMemSet((void*)&gSecUnflockMsgSnd, (UINT32)sizeof(gSecUnflockMsgSnd), (UINT8)0U, (UINT32)sizeof(gSecUnflockMsgSnd)); + break; + case ATS_CI_INFO_SND_SIGUNFLOCK: + (void)CommonMemSet((void*)&gSignalUnflockMsgSnd, (UINT32)sizeof(gSignalUnflockMsgSnd), (UINT8)0U, (UINT32)sizeof(gSignalUnflockMsgSnd)); + break; + case ATS_CI_INFO_TYPE_SND_ZRJ: + break; + case ATS_CI_INFO_SND_PSD_UNEXCEPT: + break; + default: + break; + } +} + +/** +* @brief 清除再次反馈信息 +* @param[in] const UINT16 wMsgType, 命令类型 +* @return void +* @note by fan 20260603 +*/ +void ClearAtsCmdReplySnd(UINT16 chMsgType) +{ + switch (chMsgType) + { + case RCI_ATS_INFO_SND_DS_CANCEL: + (void)CommonMemSet((void*)&gDansuoCancleReplySnd, (UINT32)sizeof(gDansuoCancleReplySnd), (UINT8)0U, (UINT32)sizeof(gDansuoCancleReplySnd)); + break; + case RCI_ATS_INFO_SND_SWIUNFLOCK: + (void)CommonMemSet((void*)&gSwitchUnflockReplySnd, (UINT32)sizeof(gSwitchUnflockReplySnd), (UINT8)0U, (UINT32)sizeof(gSwitchUnflockReplySnd)); + break; + case RCI_ATS_INFO_SND_FAULTUNLOCK: + break; + case RCI_ATS_INFO_SND_SECUNFLOCK: + (void)CommonMemSet((void*)&gSecUnflockReplySnd, (UINT32)sizeof(gSecUnflockReplySnd), (UINT8)0U, (UINT32)sizeof(gSecUnflockReplySnd)); + break; + case RCI_ATS_INFO_SND_SIGUNFLOCK: + (void)CommonMemSet((void*)&gSignalUnflockReplySnd, (UINT32)sizeof(gSignalUnflockReplySnd), (UINT8)0U, (UINT32)sizeof(gSignalUnflockReplySnd)); + break; + case RCI_ATS_INFO_SND_ZRJ: + break; + case RCI_ATS_INFO_SND_PSD_UNEXCEPT: + break; + default: + break; + } +} +/** +* @brief 收到ATS/网关首次信息解析检查处理 +* @param[in] const UINT8* dataBuf, 数据缓冲区 +* @param[in] UINT16* dataIndex, 数据索引 +* @param[Out] AtsFollowUpCmdFstStru* pMsgFst 首次信息变量指针 +* @return CI_ERROR 失败 CI_SUCCESS 成功 +* @note by fan 20260602 +*/ +UINT8 ProcessCmdFirstMsgCheck(const UINT8* dataBuf, UINT16 dataIndex, AtsFollowUpCmdFstStru* pMsgFst) +{ + UINT8 chRetVal = CI_ERROR; + UINT16 ii = 0U; + UINT32 dwCurCyc = Get2oo2CurCycleNum(); + if ((NULL != dataBuf) && (0U != dataIndex)&&(NULL != pMsgFst)) + { + chRetVal = CI_SUCCESS; + ii = dataIndex; + /*无条件更新最新一次命令*/ + pMsgFst->chAtsId = dataBuf[ii++]; + pMsgFst->chRtuId = dataBuf[ii++]; + pMsgFst->wIndex = ShortFromChar(&dataBuf[ii]); /* 操作站编号 */ + ii += 2u; + pMsgFst->chTiocId = dataBuf[ii++]; + pMsgFst->dwTime = LongFromChar(&dataBuf[ii]); /* 请求时间 */ + ii += 4u; + pMsgFst->wDevId = ShortFromChar(&dataBuf[ii]); /* 设备编号 */ + ii += 2u; + if (((0U == pMsgFst->chAtsId) || (0U == pMsgFst->chRtuId)) + &&(0UwIndex) + && (0U < pMsgFst->wDevId) && (UINT16_MAX > pMsgFst->wDevId) + && (0U < pMsgFst->chTiocId) && (CI_SUM_MAX> pMsgFst->chTiocId)) + { + pMsgFst->chFlag = FLAG_SET; + pMsgFst->dwCycle = dwCurCyc; + } + else + { + chRetVal = CI_ERROR; + } + } + return chRetVal; +} + +/** +* @brief 收到ATS/网关再次命令检查处理 +* @param[in] const UINT8* dataBuf, 数据缓冲区 +* @param[in] UINT16* dataIndex, 数据索引 +* @param[Out] AtsFollowUpCmdSndStru* pMsgSnd 再次信息变量指针 +* @return CI_ERROR 失败 CI_SUCCESS 成功 +* @note by fan 20260602 +*/ +UINT8 ProcessCmdSndMsgCheck(const UINT8* dataBuf, UINT16 dataIndex, AtsFollowUpCmdSndStru* pMsgSnd) +{ + UINT8 chRetVal = CI_ERROR; + UINT16 ii = 0U; + UINT32 dwCurCyc = Get2oo2CurCycleNum(); + if ((NULL != dataBuf) && (0U != dataIndex) && (NULL != pMsgSnd)) + { + chRetVal = CI_SUCCESS; + ii = dataIndex; + pMsgSnd->chAtsId = dataBuf[ii++]; + pMsgSnd->chRtuId = dataBuf[ii++]; + pMsgSnd->wIndex = ShortFromChar(&dataBuf[ii]); /* 操作站编号 */ + ii += 2u; + pMsgSnd->chTiocId = dataBuf[ii++]; + pMsgSnd->dwTime = LongFromChar(&dataBuf[ii]); /* 请求时间 */ + ii += 4u; + pMsgSnd->wDevId = ShortFromChar(&dataBuf[ii]); /* 设备编号 */ + ii += 2u; + pMsgSnd->dwCrc32 = LongFromChar(&dataBuf[ii]); /* CRC32 */ + ii += 4u; + if (((0U == pMsgSnd->chAtsId) || (0U == pMsgSnd->chRtuId)) + && (0UwIndex) + && (0U < pMsgSnd->wDevId) && (UINT16_MAX > pMsgSnd->wDevId) + && (0U < pMsgSnd->chTiocId) && (CI_SUM_MAX> pMsgSnd->chTiocId)) + { + pMsgSnd->chFlag = FLAG_SET; + pMsgSnd->dwCycle = dwCurCyc; + } + else + { + chRetVal = CI_ERROR; + } + } + return chRetVal; +} +/** +* @brief ATS/网关/现地 二次命令回复处理 +* @brief 发送ATS通用站场状态处理 +* @param[in] UINT8* ciToXianDiDataBuffer CI组包给ATS或现地的数据数组 +* @param[out] UINT16* wDataIndex CI组包给ATS或现地的数据索引 +* @param[in] const UINT8 chTargetType, 目标系统类型 +* @param[in] const UINT8 chAtsType, ats(设备0x03)类型 +* @return 无 +* @note by fan 20260602 +*/ +UINT8 PackCiToAtsFollowUpMsg(UINT8* ciToXianDiDataBuffer, UINT16* wDataIndex, UINT8 chTargetType, UINT8 chAtsType) +{ + UINT8 reVal = CI_ERROR; + UINT16 ii = 0U;/*游标*/ + UINT16 j = 0U; + UINT16 wMsgIndex = 0u;/*命令帧类型 遍历使用*/ + RCIFollowUpReplyStru * strCfmTemp = NULL;/*回复信息指针*/ + UINT16 wMagDataLenIndex = 0U; + UINT16 wMagLen = 0U;/*单信息长度记录*/ + UINT8 chPackCheck = CI_ERROR;/*检查组包设备是否与消息对应*/ + UINT32 dwCurCyc = Get2oo2CurCycleNum(); + if ((NULL != ciToXianDiDataBuffer) && (NULL != wDataIndex) && + ((CI_SYSTEM_TYPE_XIANDI == chTargetType)||(CI_SYSTEM_TYPE_ATS == chTargetType))) + { + ii = *wDataIndex; + for (j = 0U; j < FOLLOWUP_MSGID_MAX; j++) + { + wMsgIndex = (UINT16)0x0300U + j* (UINT16)4U + (UINT16)2U; + /*获取首次消息反馈*/ + strCfmTemp = GetAtsFollowUpReplyFst(wMsgIndex); + /*校验内容：消息有效、消息属于对应设备*/ + if ((NULL != strCfmTemp)&&(dwCurCyc == strCfmTemp->dwTime)) + { + if ((0U < strCfmTemp->chAtsId) && (CI_SYSTEM_TYPE_ATS == chTargetType) && (PACK_ATS_TYPE_GATEWAY == chAtsType)) + { + /*atsID不为0、对应设备为网关*/ + chPackCheck = CI_SUCCESS; + } + else if ((0U < strCfmTemp->chRtuId) && (CI_SYSTEM_TYPE_XIANDI == chTargetType)) + { + /*Rtu ID不为0、对应设备为现地*/ + chPackCheck = CI_SUCCESS; + } + else if ((0U == strCfmTemp->chAtsId)&&(0U == strCfmTemp->chRtuId)&&(CI_SYSTEM_TYPE_ATS == chTargetType) && (PACK_ATS_TYPE_CENTER == chAtsType)) + { + /*全0 给ATS组包*/ + chPackCheck = CI_SUCCESS; + } + else + { + chPackCheck = CI_ERROR;/*非本设备*/ + } + if(CI_SUCCESS == chPackCheck) + { + wMagDataLenIndex = ii; + ii += 2U; + ShortToChar(wMsgIndex, &ciToXianDiDataBuffer[ii]);/* 报文类型 */ + ii += 2u; + /* 预留2字节 */ + ii += 2u; + ciToXianDiDataBuffer[ii++] = strCfmTemp->chTiocId; /*RC/CI编号*/ + ciToXianDiDataBuffer[ii++] = strCfmTemp->chRtuId; /*RTU id*/ + ShortToChar(strCfmTemp->wIndex , &ciToXianDiDataBuffer[ii]);/* 操作站 */ + ii += 2u; + LongToChar(strCfmTemp->dwTime, &ciToXianDiDataBuffer[ii]); /* 收到请求时间 */ + ii += 4U; + ciToXianDiDataBuffer[ii++] = strCfmTemp->chOpStatus; /*反馈*/ + LongToChar(strCfmTemp->dwCrc32, &ciToXianDiDataBuffer[ii]); /* CRC */ + ii += 4U; + wMagLen = ii - wMagDataLenIndex - 2U; + /* 组数据长度 */ + ShortToChar(wMagLen, &ciToXianDiDataBuffer[wMagDataLenIndex]); + /*修改反馈状态*/ + } + } + if ((NULL != strCfmTemp)&& (dwCurCyc != strCfmTemp->dwTime)) + { + /*非本周期*/ + strCfmTemp->chFlag = FLAG_UNSET; + } + wMsgIndex = (UINT16)0x0300U + j* (UINT16)4U + (UINT16)4U; + /*获取再次次消息反馈*/ + strCfmTemp = GetAtsFollowUpReplySnd(wMsgIndex); + if ((NULL != strCfmTemp) && (dwCurCyc == strCfmTemp->dwTime)) + { + /*校验内容：本周期消息、消息属于对应设备*/ + if ((0U < strCfmTemp->chAtsId) && (CI_SYSTEM_TYPE_ATS == chTargetType) && (PACK_ATS_TYPE_GATEWAY == chAtsType)) + { + /*atsID不为0、对应设备为网关*/ + chPackCheck = CI_SUCCESS; + } + else if ((0U < strCfmTemp->chRtuId) && (CI_SYSTEM_TYPE_XIANDI == chTargetType)) + { + /*Rtu ID不为0、对应设备为现地*/ + chPackCheck = CI_SUCCESS; + } + else if ((0U == strCfmTemp->chAtsId)&&(0U == strCfmTemp->chRtuId)&&(CI_SYSTEM_TYPE_ATS == chTargetType) && (PACK_ATS_TYPE_CENTER == chAtsType)) + { + /*全0 给ATS组包*/ + chPackCheck = CI_SUCCESS; + } + else + { + chPackCheck = CI_ERROR;/*非本设备*/ + } + if (CI_SUCCESS == chPackCheck) + { + wMagDataLenIndex = ii; + ii += 2U; + ShortToChar(wMsgIndex, &ciToXianDiDataBuffer[ii]);/* 报文类型 */ + ii += 2u; + /* 预留2字节 */ + ii += 2u; + ciToXianDiDataBuffer[ii++] = strCfmTemp->chTiocId; /*RC/CI编号*/ + ciToXianDiDataBuffer[ii++] = strCfmTemp->chRtuId; /*RTU id*/ + ShortToChar(strCfmTemp->wIndex, &ciToXianDiDataBuffer[ii]);/* 操作站 */ + ii += 2u; + LongToChar(strCfmTemp->dwTime, &ciToXianDiDataBuffer[ii]); /* 收到请求时间 */ + ii += 4U; + ciToXianDiDataBuffer[ii++] = strCfmTemp->chOpStatus; /*反馈*/ + LongToChar(strCfmTemp->dwCrc32, &ciToXianDiDataBuffer[ii]); /* CRC */ + ii += 4U; + wMagLen = ii - wMagDataLenIndex - 2U; + /* 组数据长度 */ + ShortToChar(wMagLen, &ciToXianDiDataBuffer[wMagDataLenIndex]); + /* 清零二次反馈*/ + } + } + if ((NULL != strCfmTemp) && (dwCurCyc != strCfmTemp->dwTime)) + { + /*非本周期*/ + ClearAtsCmdReplySnd(wMsgIndex); + } + } + *wDataIndex = ii; + reVal = CI_SUCCESS; + } + else + { + ;/*失败*/ + } + return reVal; } \ No newline at end of file diff --git a/TSCP/src/APP/ciapp/ParsePack/ParsePackAtsData.h b/TSCP/src/APP/ciapp/ParsePack/ParsePackAtsData.h index e55a942..f1fc982 100644 --- a/TSCP/src/APP/ciapp/ParsePack/ParsePackAtsData.h +++ b/TSCP/src/APP/ciapp/ParsePack/ParsePackAtsData.h @@ -75,11 +75,57 @@ #define RCI_ATS_INFO_TYPE_DEVICE_STATE ((UINT16)0x0203U) /*RCI->ATS设备状态信息，间隔1周期发送*/ #define ATS_CI_INFO_TYPE_HEART_STATE ((UINT16)0x0204U) /*ATS->CI心跳状态信息，周期发送*/ #define ATS_CI_INFO_TYPE_CMD_CONTROL ((UINT16)0x0205U) /*ATS->CI命令控制信息，ATS触发发送*/ +#define ATS_CI_INFO_TYPE_GATEWAY_COMMON ((UINT16)0x0206U) /*网关->CI既有信息帧 ATS触发发送*/ +#define RCI_ATS_INFO_TYPE_GATEWAY_COMMON ((UINT16)0x0207U) /*RC->网关既有信息汇报，周期发送*/ +#define RCI_ATS_INFO_TYPE_GATEWAY_HEART ((UINT16)0x0208U) /*CI->网关周期心跳*/ +#define ATS_CI_INFO_FST_DS_CANCEL ((UINT16)0x0301U) /*ATS->CI道岔单解一次命令，ATS触发发送*/ +#define RCI_ATS_INFO_FST_DS_CANCEL ((UINT16)0x0302U) /*RCI->ATS道岔单解首次回复，触发单解一次后发送*/ +#define ATS_CI_INFO_SND_DS_CANCEL ((UINT16)0x0303U) /*ATS->CI道岔单解二次命令，ATS触发发送*/ +#define RCI_ATS_INFO_SND_DS_CANCEL ((UINT16)0x0304U) /*RCI->ATS道岔单解再次回复，触发单解二次后发送*/ +#define ATS_CI_INFO_FST_SWIUNFLOCK ((UINT16)0x0305U) /*ATS->CI道岔解封一次命令，ATS触发发送*/ +#define RCI_ATS_INFO_FST_SWIUNFLOCK ((UINT16)0x0306U) /*RCI->ATS道岔解封首次回复，触发解封一次后发送*/ +#define ATS_CI_INFO_SND_SWIUNFLOCK ((UINT16)0x0307U) /*ATS->CI道岔解封二次命令，ATS触发发送*/ +#define RCI_ATS_INFO_SND_SWIUNFLOCK ((UINT16)0x0308U) /*RCI->ATS道岔解封再次回复，触发解封二次后发送*/ +#define ATS_CI_INFO_FST_FAULTUNLOCK ((UINT16)0x0309U) /*ATS->CI 区故解 预留*/ +#define RCI_ATS_INFO_FST_FAULTUNLOCK ((UINT16)0x030AU) /*RCI->ATS区故解一次回复 预留*/ +#define ATS_CI_INFO_SND_FAULTUNLOCK ((UINT16)0x030BU) /*ATS->CI区故解二次 预留*/ +#define RCI_ATS_INFO_SND_FAULTUNLOCK ((UINT16)0x030CU) /*RCI->ATS区故解二次 预留*/ +#define ATS_CI_INFO_FST_SECUNFLOCK ((UINT16)0x030DU) /*ATS->CI区段解封一次命令，ATS触发发送*/ +#define RCI_ATS_INFO_FST_SECUNFLOCK ((UINT16)0x030EU) /*RCI->ATS区段解封首次回复，触发解封一次后发送*/ +#define ATS_CI_INFO_SND_SECUNFLOCK ((UINT16)0x030FU) /*ATS->CI区段解封二次命令，ATS触发发送*/ +#define RCI_ATS_INFO_SND_SECUNFLOCK ((UINT16)0x0310U) /*RCI->ATS区段解封再次回复，触发解封二次后发送*/ +#define ATS_CI_INFO_FST_SIGUNFLOCK ((UINT16)0x0311U) /*ATS->CI信号机解封一次命令，ATS触发发送*/ +#define RCI_ATS_INFO_FST_SIGUNFLOCK ((UINT16)0x0312U) /*RCI->ATS信号机解封首次回复，触发解封一次后发送*/ +#define ATS_CI_INFO_SND_SIGUNFLOCK ((UINT16)0x0313U) /*ATS->CI信号机解封二次命令，ATS触发发送*/ +#define RCI_ATS_INFO_SND_SIGUNFLOCK ((UINT16)0x0314U) /*RCI->ATS信号机解封再次回复，触发解封二次后发送*/ +#define ATS_CI_INFO_FST_ZONGRENJIE ((UINT16)0x0315U) /*ATS->CI总人解一次命令，ATS触发发送*/ +#define RCI_ATS_INFO_FST_ZONGRENJIE ((UINT16)0x0316U) /*RCI->ATS总人解首次回复，触发一次后发送*/ +#define ATS_CI_INFO_TYPE_SND_ZRJ ((UINT16)0x0317U) /*ATS->CI总人解二次命令，ATS触发发送*/ +#define RCI_ATS_INFO_SND_ZRJ ((UINT16)0x0318U) /*RCI->ATS总人解再次回复，触发二次后发送*/ +#define ATS_CI_INFO_FST_PSD_UNEXCEPT ((UINT16)0x0319U) /*ATS->CI站台门异常解除一次命令，ATS触发发送*/ +#define RCI_ATS_INFO_FST_PSD_UNEXCEPT ((UINT16)0x031AU) /*RCI->ATS站台门异常解除首次回复，触发一次后发送*/ +#define ATS_CI_INFO_SND_PSD_UNEXCEPT ((UINT16)0x031BU) /*ATS->CI站台门异常解除二次命令，ATS触发发送*/ +#define RCI_ATS_INFO_SND_PSD_UNEXCEPT ((UINT16)0x031CU) /*RCI->ATS站台门异常解除再次回复，触发二次后发送*/ + #define SHOW_2OO2_STATE_MAIN ((UINT8)0x55U) /*显示主备系状态-主系*/ #define SHOW_2OO2_STATE_BACKUP ((UINT8)0xaaU) /*显示主备系状态-备系*/ #define SHOW_2OO2_STATE_UNKNOW ((UINT8)0xFFU) /*显示主备系状态-未知*/ +#define CONFIRM_REPLY_SUCCESS ((UINT8)1u) /*确认成功*/ +#define CONFIRM_FST_UNSET ((UINT8)2u) /*首次回复未设置该状态*/ +#define CONFIRM_FST_BELONGERROR ((UINT8)3u) /*首次回复设备不属于本集中区*/ +#define CONFIRM_DEVICE_NONROUTE_SET ((UINT8)5u) /*回复非进路调车已办理*/ + +#define CONFIRM_SND_DIFFCMD ((UINT8)2u) /*再次回复操作不一致*/ +#define CONFIRM_SND_FIRST_NOTFIND ((UINT8)3u) /*再次回首次命令未执行*/ +#define CONFIRM_SND_CRCFAIL ((UINT8)4u) /*再次回复CRC校验失败*/ + +#define FOLLOWUP_CONFIRM_TIMEOUT ((UINT16)400u) /*首次消息等待二次消息超时时间*/ +#define PACK_ATS_TYPE_CENTER ((UINT8) 0xAAU)/*ATS二次信息回复组包中区分ATS与网关使用后，代表ATS*/ +#define PACK_ATS_TYPE_GATEWAY ((UINT8) 0x55U) /*ATS二次信息回复组包中区分ATS与网关使用后，代表网关*/ +#define FOLLOWUP_MSGID_MAX ((UINT16)7) /*暂定二次命令种类，遍历使用*/ + /*执行电插箱相关信息*/ typedef struct s_PlusBoxDataSendATS { @@ -143,6 +189,36 @@ extern UINT32 FirstCmdId; /* extern ReciveAtsCmdDataCycInfo szReciveAtsCmdDataCycInfo[ATS_SUM_MAX * 2U]; /*收到ATS命令数据周期号信息数组*/ extern UINT16 gReciveAtsCmdDataDeviceSum; /*收到ATS命令数据设备数目*/ +extern AtsFollowUpCmdFstStru gDansuoCancleMsgFst;/*取消单锁首次消息*/ +extern RCIFollowUpReplyStru gDansuoCancleReplyFst;/*取消单锁首次确认*/ +extern AtsFollowUpCmdSndStru gDansuoCancleMsgSnd; /*取消单锁二次消息*/ +extern RCIFollowUpReplyStru gDansuoCancleReplySnd; /*取消单锁二次确认*/ + +extern AtsFollowUpCmdFstStru gSwitchUnflockMsgFst; /*道岔解封首次消息*/ +extern RCIFollowUpReplyStru gSwitchUnflockReplyFst; /*道岔解封首次确认*/ +extern AtsFollowUpCmdSndStru gSwitchUnflockMsgSnd; /*道岔解封二次消息*/ +extern RCIFollowUpReplyStru gSwitchUnflockReplySnd; /*道岔解封二次确认*/ + +extern AtsFollowUpCmdFstStru gSecUnflockMsgFst; /*区段解封首次消息*/ +extern RCIFollowUpReplyStru gSecUnflockReplyFst; /*区段解封首次确认*/ +extern AtsFollowUpCmdSndStru gSecUnflockMsgSnd; /*区段解封二次消息*/ +extern RCIFollowUpReplyStru gSecUnflockReplySnd; /*区段解封二次确认*/ + +extern AtsFollowUpCmdFstStru gSignalUnflockMsgFst; /*信号机解封首次消息*/ +extern RCIFollowUpReplyStru gSignalUnflockReplyFst; /*信号机解封首次确认*/ +extern AtsFollowUpCmdSndStru gSignalUnflockMsgSnd; /*信号机解封二次消息*/ +extern RCIFollowUpReplyStru gSignalUnflockReplySnd; /*信号机解封二次确认*/ + +extern AtsFollowUpCmdFstStru gZRJMsgFst; /*总人解首次消息*/ +extern RCIFollowUpReplyStru gZRJReplyFst; /*总人解首次确认*/ +extern AtsFollowUpCmdSndStru gZRJMsgSnd; /*总人解二次消息*/ +extern RCIFollowUpReplyStru gZRJReplySnd; /*总人解二次确认*/ + +extern AtsFollowUpCmdFstStru gCanclPsdExceptMsgFst; /*解除站台门异常首次消息*/ +extern RCIFollowUpReplyStru gCanclPsdExceptReplyFst; /*解除站台门异常首次确认*/ +extern AtsFollowUpCmdSndStru gCanclPsdExceptMsgSnd; /*解除站台门异常二次消息*/ +extern RCIFollowUpReplyStru gCanclPsdExceptReplySnd; /*解除站台门异常二次确认*/ + /* * 功能描述： 解析操作命令数据帧 * 参数说明： const UINT8* dataBuf, 数据缓冲区 @@ -502,6 +578,30 @@ void SendAtsCommonStationStateDeal(UINT8* ciToXianDiDataBuffer, UINT16* wDataInd */ UINT8 ReciveAtsCmdDeal(const UINT8* dataBuf, UINT16* dataIndex, const UINT16 wDataLength); +/** +* @brief 收到ATS二次命令帧中一次命令解析处理 +* @param[in] const UINT8* dataBuf, 数据缓冲区 +* @param[in] UINT16 dataIndex, 数据索引 +* @param[in] const UINT16 dataLength, 数据长度 +* @param[in] const UINT16 wMsgType, 帧类型 +* @param[in]AtsFollowUpCmdFstStru* pTempTotalFstMsg, 解析中临时存储本次解析一次命令空间 +* @return CI_ERROR 失败 CI_SUCCESS 成功 +* @note by fan 20260602 +*/ +UINT8 ReciveAtsFollowUpFstCmd(const UINT8* dataBuf, UINT16 dataIndex, const UINT16 wDataLength, const UINT16 wMsgType, AtsFollowUpCmdFstStru* pTempTotalFstMsg); + +/** +* @brief 收到ATS二次命令帧中二次命令解析处理 +* @param[in] const UINT8* dataBuf, 数据缓冲区 +* @param[in] UINT16 dataIndex, 数据索引 +* @param[in] const UINT16 dataLength, 数据长度 +* @param[in] const UINT16 wMsgType, 帧类型 +* @param[in]AtsFollowUpCmdSndStru* pTempTotalSndMsg, 解析中临时存储本次解析二次命令空间 +* @return CI_ERROR 失败 CI_SUCCESS 成功 +* @note by fan 20260602 +*/ +UINT8 ReciveAtsFollowUpSndCmd(const UINT8* dataBuf, UINT16 dataIndex, const UINT16 wDataLength, const UINT16 wMsgType, AtsFollowUpCmdSndStru* pTempTotalSndMsg); + /** * @brief 更新ATS命令数据周期号信息 * @param[in] UINT8 chDeviceType 设备类型 @@ -529,6 +629,100 @@ UINT32 GetReciveCmdDataAtsCycNum(UINT8 chDeviceType, UINT8 chDeviceId); */ void PackRcOrCiDeciveCommonState(UINT8* ciToXianDiDataBuffer, UINT16* ii); +/** +* @brief 获取ATS对应的首次消息 +* @param[in] const UINT16 wMsgType, 命令类型 +* @return 获取ATS二次信息帧中的首次消息 +* @note by fan 20260602 +*/ +AtsFollowUpCmdFstStru * GetAtsFollowUpMsgFst(UINT16 chMsgType); + +/** +* @brief 获取ATS对应的二次消息 +* @param[in] const UINT16 wMsgType, 命令类型 +* @return 获取ATS二次信息帧中的再次消息 +* @note by fan 20260602 +*/ +AtsFollowUpCmdSndStru * GetAtsFollowUpMsgSnd(UINT16 chMsgType); + +/** +* @brief 获取ATS对应的首次反馈消息 +* @param[in] const UINT16 wMsgType, 命令类型 +* @return 获取ATS二次信息帧中的首次反馈 +* @note by fan 20260602 +*/ +RCIFollowUpReplyStru * GetAtsFollowUpReplyFst(UINT16 chMsgType); +/** +* @brief 获取ATS对应的再次反馈消息 +* @param[in] const UINT16 wMsgType, 命令类型 +* @return 获取ATS二次信息帧中的再次反馈 +* @note by fan 20260602 +*/ +RCIFollowUpReplyStru * GetAtsFollowUpReplySnd(UINT16 chMsgType); + +/** +* @brief 清除1次ATS命令信息 +* @param[in] const UINT16 wMsgType, 命令类型 +* @return void +* @note by fan 20260603 +*/ +void ClearAtsCmdMsgFst(UINT16 chMsgType); + +/** +* @brief 清除2次ATS命令信息 +* @param[in] const UINT16 wMsgType, 命令类型 +* @return void +* @note by fan 20260603 +*/ +void ClearAtsCmdMsgSnd(UINT16 chMsgType); + +/** +* @brief 清除再次反馈信息 +* @param[in] const UINT16 wMsgType, 命令类型 +* @return void +* @note by fan 20260603 +*/ +void ClearAtsCmdReplySnd(UINT16 chMsgType); + +/** +* @brief 清除首次反馈信息 +* @param[in] const UINT16 wMsgType, 命令类型 +* @return void +* @note by fan 20260603 +*/ +void ClearAtsCmdReplyFst(UINT16 chMsgType); + +/** +* @brief ATS/网关/现地 二次命令回复处理 +* @brief 发送ATS通用站场状态处理 +* @param[in] UINT8* ciToXianDiDataBuffer CI组包给ATS或现地的数据数组 +* @param[out] UINT16* wDataIndex CI组包给ATS或现地的数据索引 +* @param[in] const UINT8 chTargetType, 目标系统类型 +* @param[in] const UINT8 chAtsType, ats(设备0x03)类型 +* @return 无 +* @note by fan 20260602 +*/ +UINT8 PackCiToAtsFollowUpMsg(UINT8* ciToXianDiDataBuffer, UINT16* wDataIndex, UINT8 chTargetType, UINT8 chAtsType); +/** +* @brief 收到ATS/网关首次信息解析检查处理 +* @param[in] const UINT8* dataBuf, 数据缓冲区 +* @param[in] UINT16* dataIndex, 数据索引 +* @param[Out] AtsFollowUpCmdFstStru* pMsgFst 首次信息变量指针 +* @return CI_ERROR 失败 CI_SUCCESS 成功 +* @note by fan 20260602 +*/ +UINT8 ProcessCmdFirstMsgCheck(const UINT8* dataBuf, UINT16 dataIndex, AtsFollowUpCmdFstStru* pMsgFst); + +/** +* @brief 收到ATS/网关再次命令检查处理 +* @param[in] const UINT8* dataBuf, 数据缓冲区 +* @param[in] UINT16* dataIndex, 数据索引 +* @param[Out] AtsFollowUpCmdSndStru* pMsgSnd 再次信息变量指针 +* @return CI_ERROR 失败 CI_SUCCESS 成功 +* @note by fan 20260602 +*/ +UINT8 ProcessCmdSndMsgCheck(const UINT8* dataBuf, UINT16 dataIndex, AtsFollowUpCmdSndStru* pMsgSnd); + #ifdef __cplusplus } #endif diff --git a/TSCP/src/APP/ciapp/ParsePack/ParsePackCommon.c b/TSCP/src/APP/ciapp/ParsePack/ParsePackCommon.c index 4bbfdf2..8879c5f 100644 --- a/TSCP/src/APP/ciapp/ParsePack/ParsePackCommon.c +++ b/TSCP/src/APP/ciapp/ParsePack/ParsePackCommon.c @@ -26,7 +26,7 @@ #include "../DataManage/PlatDataManage.h" #include "dquCIInterFace.h" #include "NonAutoReturnDataManage.h" - +#include "ReverseCutDataManage.h" #include "2oo2InterfaceDataManage.h" PlatHeartDataStruct RecvHeartDataStru = { 0U }; /*平台心跳帧数据结构*/ @@ -4338,6 +4338,8 @@ void PackCiToCimDeviceData(void) UINT32 switchCollTolerateCycNum = 0U; UINT8 chSwitchBDState = SEND_CIM_COLLTOLERATE_NO; UINT8 chSignalDsState = 0xFFU; + UINT8 chReverseState = 0xFFU; + const ReverseSwitchCfgDataStru* pReverseCfg = NULL; /*发送道岔数据*/ pSwitchData = GetSwitchData(); @@ -4657,9 +4659,35 @@ void PackCiToCimDeviceData(void) ciToCimDataBuffer[ii++] = pFloodGateDataCC[deviceId].FloodGateCloseApplyIvocSum; /*防淹门关门申请列车数量*/ ciToCimDataBuffer[ii++] = pFloodGateDataCC[deviceId].FloodGateCloseAnsIvocSum; /*防淹门关门允许，列车回复数量*/ ciToCimDataBuffer[ii++] = pFloodGateDataCC[deviceId].FloodGateAccessUTFlag; /*防淹门接近区段是否有非通信车标志*/ - - } + + /*打印倒切柜数据*/ + pReverseCfg = GetReverseCfgData(); + if (NULL != pReverseCfg) + { + if (0U == pReverseCfg->wId) + { + ciToCimDataBuffer[ii++] = 0U;/*倒切开关数量发0*/ + } + else + { + ciToCimDataBuffer[ii++] = 1U;/*倒切开关数量发1*/ + ShortToChar(pReverseCfg->wId, &ciToCimDataBuffer[ii]);/*倒切开关ID (初始化字段)*/ + ii += 2u; + chReverseState = GetReverseSwitchState(); + ciToCimDataBuffer[ii++] = chReverseState;/*倒切开关状态*/ + ShortToChar(pReverseCfg->wRelateBoardNum, &ciToCimDataBuffer[ii]);/*倒切板卡数量*/ + ii += 2u; + for (jj = 0u; jj wRelateBoardNum; jj++) + { + ShortToChar(pReverseCfg->strRelateBoardBuf[jj].wReversBoardId, &ciToCimDataBuffer[ii]);/*倒切板卡ID*/ + ii += 2u; + chReverseState = GetReverseBoardState(pReverseCfg->strRelateBoardBuf[jj].wReversBoardId); + ciToCimDataBuffer[ii++] = chReverseState;/*倒切板卡状态*/ + } + } + } + /*发送CIM*/ debug_infor_printf((const)"\nCIM_SEND_DEVSTATE:%d", ii); debug_out_array(0xAA, ciToCimDataBuffer, ii); @@ -5549,4 +5577,131 @@ void PackCiToCimCollDiffData(void) /*发送维护机*/ (void)DarkInfoPack(CIM_INFO_IO_COLL_DIFF_ALARM, ciToCimDataBuffer, ii); +} + +/* +* 功能描述： 组包发送CIM双系IO采集不一致信息 +* 参数说明： void +* 返回值 ： 无 +*/ +void PackCiToCimSwitchRedunAlarmData(void) +{ + UINT16 wSwitchCurSum = 0u; + UINT32 dwRedunHunXianAlarmCfg = 0u; + UINT16 i = 0u; + UINT16 wSwitchId = 0u; + UINT8 cRedunCollCfg = 0u; + UINT16 cAlarmCount = 0u; + UINT32 dwHunXianStCyc = 0u; + UINT8 cRedunHunXianStt = 0u; + UINT32 dwFaultStCyc = 0u; + UINT8 j = 0u; + UINT32 dwSwitchDrvStCyc = 0u; + UINT8 cTimeOut = 0u; + UINT16 wRelayId = 0u; + UINT16 wBelongOcId = 0u; + UINT16 wIndex = 1u; /*组包下标，跳过1字节道岔总数*/ + UINT8 ciToCimDataBuffer[CI_TO_CIM_DATA_LEN_MAX] = { 0U }; /*数组长度5000字节，大于500个道岔*2个OC*4字节报警，暂无需越界防护*/ + + wSwitchCurSum = GetSwitchCurSum(); + dwRedunHunXianAlarmCfg = GetSwitchRedunCollHunXianCycCfg(); + for (i = 0u; i < wSwitchCurSum; i++) + { + wSwitchId = GetSwitchId(i); + cRedunCollCfg = GetSwitchRedunCollCfg(wSwitchId); + if (REDUN_COLL_YES == cRedunCollCfg) + { + for (j = 0u; j < SWITCH_REDUN_COLL_MAX; j++) + { + /*混线报警*/ + cRedunHunXianStt = GetSwitchRedunHunXianRecovStt(wSwitchId, j); + if (REDUN_HX_RECOV_ALL != cRedunHunXianStt) + { + /*判断混线有效，如果道岔驱动中，容忍报警时间再报警，否则直接报警*/ + dwHunXianStCyc = GetSwitchRedunJudgHunXianStCyc(wSwitchId, j); + dwSwitchDrvStCyc = GetSwitchDriveStartCycNum(wSwitchId); + cTimeOut = SystemOverTimeCheck(dwHunXianStCyc, dwRedunHunXianAlarmCfg); + if ((0u == dwSwitchDrvStCyc) || (CI_TIME_OUT == cTimeOut)) + { + /*报警*/ + cAlarmCount += 1u; + /*道岔ID*/ + ShortToChar(wSwitchId, &ciToCimDataBuffer[wIndex]); + wIndex += 2u; + /*所属OC ID，任选一个冗余采集继电器查询*/ + wRelayId = GetSwitchRedunDBJ1RelayId(wSwitchId, j); + wBelongOcId = GetRelayBelongOCId(wRelayId); + ciToCimDataBuffer[wIndex] = (UINT8)wBelongOcId; + wIndex += 1u; + /*混线报警*/ + ciToCimDataBuffer[wIndex] = REDUN_ALARM_HUNXIAN; + wIndex += 1u; + /*报混线则不报采集故障*/ + continue; + } + else + { + /*不报警*/ + } + } + else + { + /*未混线，不报警*/ + } + + /*采集故障报警*/ + dwFaultStCyc = GetSwitchRedunFaultStCyc(wSwitchId, j); + if (0u < dwFaultStCyc) + { + /*采集故障有效，如果道岔驱动中，容忍报警时间再报警，否则直接报警*/ + dwSwitchDrvStCyc = GetSwitchDriveStartCycNum(wSwitchId); + cTimeOut = SystemOverTimeCheck(dwFaultStCyc, dwRedunHunXianAlarmCfg); + if ((0u == dwSwitchDrvStCyc) || (CI_TIME_OUT == cTimeOut)) + { + /*报警*/ + cAlarmCount += 1u; + /*道岔ID*/ + ShortToChar(wSwitchId, &ciToCimDataBuffer[wIndex]); + wIndex += 2u; + /*所属OC ID，任选一个冗余采集继电器查询*/ + wRelayId = GetSwitchRedunDBJ1RelayId(wSwitchId, j); + wBelongOcId = GetRelayBelongOCId(wRelayId); + ciToCimDataBuffer[wIndex] = (UINT8)wBelongOcId; + wIndex += 1u; + /*采集故障报警*/ + ciToCimDataBuffer[wIndex] = REDUN_ALARM_FAULT; + wIndex += 1u; + } + else + { + /*不报警*/ + } + } + else + { + /*未故障，不报警*/ + } + } + } + else + { + /*道岔不具备冗余采集，不报警*/ + } + } + + if ((UINT16)UINT8_MAX < cAlarmCount) + { + /*报警数量非法，导向报警数量为0*/ + ciToCimDataBuffer[0] = 0u; + (void)debug_infor_printf((const)"SwtRedunCollAlarm Err = %d\n", cAlarmCount); + (void)DarkInfoPack(CIM_INFO_SWT_REDUN_COLL_ALARM, ciToCimDataBuffer, 1u); + } + else + { + /*输出报警*/ + ciToCimDataBuffer[0] = (UINT8)cAlarmCount; + (void)debug_infor_printf((const)"SwtRedunCollAlarm = %d:", cAlarmCount); + (void)debug_out_array(0xAA, ciToCimDataBuffer, wIndex); + (void)DarkInfoPack(CIM_INFO_SWT_REDUN_COLL_ALARM, ciToCimDataBuffer, wIndex); + } } \ No newline at end of file diff --git a/TSCP/src/APP/ciapp/ParsePack/ParsePackCommon.h b/TSCP/src/APP/ciapp/ParsePack/ParsePackCommon.h index 9adef2f..dad98d2 100644 --- a/TSCP/src/APP/ciapp/ParsePack/ParsePackCommon.h +++ b/TSCP/src/APP/ciapp/ParsePack/ParsePackCommon.h @@ -388,6 +388,13 @@ void PackCiToCimFlyProtectData(void); */ void PackCiToCimCollDiffData(void); +/* +* 功能描述： 组包发送CIM双系IO采集不一致信息 +* 参数说明： void +* 返回值 ： 无 +*/ +void PackCiToCimSwitchRedunAlarmData(void); + #ifdef __cplusplus } #endif diff --git a/TSCP/src/APP/ciapp/ParsePack/ParsePackDefine.h b/TSCP/src/APP/ciapp/ParsePack/ParsePackDefine.h index efae5c4..384a4cc 100644 --- a/TSCP/src/APP/ciapp/ParsePack/ParsePackDefine.h +++ b/TSCP/src/APP/ciapp/ParsePack/ParsePackDefine.h @@ -87,23 +87,24 @@ #define CI_TO_AXIS_DATA_LEN_MAX ((UINT16)3000) /*联锁到AXIS组包数据最大值*/ /*CI 和 CIM*/ -#define CI_TO_CIM_DATA_LEN_MAX ((UINT16)5000) /*CI到CIM数据最大值*/ -#define CI_TO_AIM_DATA_LEN_MAX ((UINT16)5000) /*CI到AIM数据最大值*/ -#define CIM_INFO_RCI_TO_ATS_DATA ((UINT16)0x2001) /*发送CIM ATS状态信息*/ -#define CIM_INFO_ATS_TO_RCI_DATA ((UINT16)0x2002) /*发送CIM ATS状态信息*/ -#define CIM_INFO_VER_INFO ((UINT16)0x2003) /*发送CIM版本号信息*/ -#define CIM_INFO_COMM_STATE ((UINT16)0x2004) /*发送CIM设备通信状态信息*/ -#define CIM_INFO_SIGNAL_DS_STATE ((UINT16)0x2005) /*发送CIM信号机断丝状态信息*/ -#define CIM_INFO_RELAY_DRVANDCOLLDEF ((UINT16)0x2006) /*发送CIM继电器驱动回采不一致报警*/ -#define CIM_INFO_PSD_ALARM ((UINT16)0x2007) /*发送CIM屏蔽门报警帧类型*/ -#define CIM_INFO_DEVICE_STATE ((UINT16)0x2008) /*发送CIM设备状态信息*/ -#define CIM_INFO_MAINTENANCE ((UINT16)0x2009) /*发送CIM维护信息*/ -#define CIM_INFO_LEU_STATE ((UINT16)0x200A) /*发送CIMLEU状态*/ -#define CIM_INFOR_RELAY_HUNXIAN_STATE ((UINT16)0x200F) /*发送CIM继电器混线状态信息*/ -#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_TO_CIM_DATA_LEN_MAX ((UINT16)5000) /*CI到CIM数据最大值*/ +#define CI_TO_AIM_DATA_LEN_MAX ((UINT16)5000) /*CI到AIM数据最大值*/ +#define CIM_INFO_RCI_TO_ATS_DATA ((UINT16)0x2001) /*发送CIM ATS状态信息*/ +#define CIM_INFO_ATS_TO_RCI_DATA ((UINT16)0x2002) /*发送CIM ATS状态信息*/ +#define CIM_INFO_VER_INFO ((UINT16)0x2003) /*发送CIM版本号信息*/ +#define CIM_INFO_COMM_STATE ((UINT16)0x2004) /*发送CIM设备通信状态信息*/ +#define CIM_INFO_SIGNAL_DS_STATE ((UINT16)0x2005) /*发送CIM信号机断丝状态信息*/ +#define CIM_INFO_RELAY_DRVANDCOLLDEF ((UINT16)0x2006) /*发送CIM继电器驱动回采不一致报警*/ +#define CIM_INFO_PSD_ALARM ((UINT16)0x2007) /*发送CIM屏蔽门报警帧类型*/ +#define CIM_INFO_DEVICE_STATE ((UINT16)0x2008) /*发送CIM设备状态信息*/ +#define CIM_INFO_MAINTENANCE ((UINT16)0x2009) /*发送CIM维护信息*/ +#define CIM_INFO_LEU_STATE ((UINT16)0x200A) /*发送CIMLEU状态*/ +#define CIM_INFOR_RELAY_HUNXIAN_STATE ((UINT16)0x200F) /*发送CIM继电器混线状态信息*/ +#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 CIM_INFO_SWT_REDUN_COLL_ALARM ((UINT16)0x2014) /*发送CIM道岔冗余采集报警*/ #define CI_AND_OTHER_TRANSMIT_GOOD ((UINT8)0x55) /*CI与其他系统双网通信正常*/ #define CI_AND_OTHER_TRANSMIT_LINK ((UINT8)0x5A) /*CI与其他系统单网通信正常*/ diff --git a/TSCP/src/APP/ciapp/ParsePack/ParsePackGateWayData.c b/TSCP/src/APP/ciapp/ParsePack/ParsePackGateWayData.c index a14b801..4ee6fc0 100644 --- a/TSCP/src/APP/ciapp/ParsePack/ParsePackGateWayData.c +++ b/TSCP/src/APP/ciapp/ParsePack/ParsePackGateWayData.c @@ -5,6 +5,9 @@ #include "dquCIInterFace.h" #include "WLBrakeDataManage.h" #include "RRMManageAPI.h" +#include "../ParsePack/ParsePackAtsData.h" +#include "../HLHTMsgHead/HLHTCommonDataPacketHead.h" +#include "../HLHTMsgHead/HLHTHeadContexManage.h" AtsScreenMsgFstStru g_strAtsMsgFst = { 0u }; /*远程筛选首次消息*/ AtsMsgCfmStru g_strAtsCfmFst = { 0u }; /*远程筛选首次确认*/ @@ -32,12 +35,13 @@ AtsMsgCfmStru g_strSndAtsWlbCfmFst = { 0U }; /* AtsMsgCfmStru g_strSndAtsDaCfmFst = { 0U }; /*第二个ATS的取消脱轨防护区首次确认*/ /** -* @brief 解析网关数据帧 +* @brief 解析网关数据帧---无GAL部分消息反馈内容 * @param const UINT8* dataBuf, 数据缓冲区 -* @param const UINT16 dataLength, 数据长度 +* @param[out] UINT16* dataIndex, 数据索引 +* @param[in] const UINT16 dataLength, 数据长度 * @return CI_SUCCESS:成功；CI_ERROR:失败 */ -UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength) +UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, UINT16* dataIndex, const UINT16 dataLength) { UINT8 chRtn = CI_ERROR; UINT8 chRtn1 = CI_SUCCESS; @@ -71,10 +75,10 @@ UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength) UINT8 szCrcTmp[1024] = { 0U }; - if ((NULL != dataBuf) && (0u < dataLength)) + if ((NULL != dataBuf) && (0u < dataLength)&&(NULL !=dataIndex)) { + ii = *dataIndex; chLocalId = GetSystemParaLocalCiId(); - /* 消息数量 */ chMsgNum = dataBuf[ii++]; /* 数据版本号 */ @@ -1557,7 +1561,7 @@ UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength) if (CI_SUCCESS == chRtn) { - ; /*不处理*/ + *dataIndex = ii; } else { @@ -1839,13 +1843,12 @@ void ClearAtsDaMsgSecond(void) } /** -* @brief 组TIOC到网关数据 +* @brief 组TIOC到网关数据--既有信息 * @param 无 * @return CI_ERROR失败；CI_SUCCESS成功 */ -UINT8 PackTiocToGateWayData(const UINT8 deviceId, const UINT8 targetDevType) +UINT8 PackTiocToGateWayData(UINT8* szToGateWayDataBuf, const UINT8 targetDevType, UINT16* wDataIndex) { - UINT8 szToGateWayDataBuf[CI_TO_ATS_DATA_LEN_MAX] = { 0u }; UINT16 ii = 0u; UINT16 jj = 0U; UINT16 wMsgNumIndex = 0u; @@ -1861,7 +1864,6 @@ UINT8 PackTiocToGateWayData(const UINT8 deviceId, const UINT8 targetDevType) UINT8 chTrainIndex = 0u; UINT32 dwTrainId = 0u; UINT16 wMsgLen = 0u; - UINT16 wDstDevId = 0u; UINT16 wTrainLgcId = 0u; UINT8 chEaNum = 0u; UINT16 wEaTrainid = 0u; @@ -1894,826 +1896,820 @@ UINT8 PackTiocToGateWayData(const UINT8 deviceId, const UINT8 targetDevType) TrainFlyProtectStru * pFlyData = NULL; wRcId = (UINT16)chLocalId; /* RC编号，不带类型 */ - - /* 留出消息条数填充位置 */ - ii++; - - chRtn = GetCiEmapCheckVer(chLocalId, &dwDataVer, targetDevType); - if (CI_SUCCESS == chRtn) - {/* 组数据版本 */ - LongToChar(dwDataVer, &szToGateWayDataBuf[ii]); - ii += 4u; - } - else + if ((NULL != szToGateWayDataBuf) && (NULL != wDataIndex)) { - ; - } + ii = *wDataIndex; + wMsgNumIndex = ii; + /* 留出消息条数填充位置 */ + ii++; - if (CI_SUCCESS == chRtn) - {/* 组协议版本 */ - LongToChar(GATE_WAY_PRTCL_VER, &szToGateWayDataBuf[ii]); - ii += 4u; - } - else - { - ; - } - if (0U == dwFlyProtectOverCyc) - { + chRtn = GetCiEmapCheckVer(chLocalId, &dwDataVer, targetDevType); if (CI_SUCCESS == chRtn) - {/* 组TIOC汇报给ATS的远程筛选列车信息 */ - szToGateWayDataBuf[ii++] = MSG_TYPE_REPORT; /* 汇报远程筛选列车信息帧 */ - wMsgLenIndex = ii; /* 记录帧长度存放下标 */ - ii += 2u; - szToGateWayDataBuf[ii++] = MSG_TYPE_REPORT; - ShortToChar(GATE_WAY_APP_PRTCL_VER, &szToGateWayDataBuf[ii]); /* 应用协议版本号 */ - ii += 2u; - szToGateWayDataBuf[ii++] = chLocalId; /* TIOC编号 */ - chAtsScreenNum = GetAtsScreenNum(); - szToGateWayDataBuf[ii++] = chAtsScreenNum; /* 远程筛选列车数量 */ - for (chTrainIndex = 0u; chTrainIndex < chAtsScreenNum; chTrainIndex++) - { - wTrainId = GetAtsScreenTrainIdByIndex(chTrainIndex); - chRtn = dquDevName2HlhtId(wTrainId, wTrainLgcId, &dwTrainId); - chScreenType = GetAtsScreenTypeByIndex(chTrainIndex); - wLgcId = GetAtsScreenLgcIdByIndex(chTrainIndex); - chTrainPosMonitorState = GetTrainPosMonitorState(wTrainId); - chTrainNvramFlag = GetTrainNvramPosFlag(wTrainId); + {/* 组数据版本 */ + LongToChar(dwDataVer, &szToGateWayDataBuf[ii]); + ii += 4u; + } + else + { + ; + } - LongToChar(dwTrainId, &szToGateWayDataBuf[ii]); /* 列车ID */ - ii += 4u; - - if (TRAIN_SCREEN_TYPE_LU == chScreenType) + if (CI_SUCCESS == chRtn) + {/* 组协议版本 */ + LongToChar(GATE_WAY_PRTCL_VER, &szToGateWayDataBuf[ii]); + ii += 4u; + } + else + { + ; + } + if (0U == dwFlyProtectOverCyc) + { + if (CI_SUCCESS == chRtn) + {/* 组TIOC汇报给ATS的远程筛选列车信息 */ + szToGateWayDataBuf[ii++] = MSG_TYPE_REPORT; /* 汇报远程筛选列车信息帧 */ + wMsgLenIndex = ii; /* 记录帧长度存放下标 */ + ii += 2u; + szToGateWayDataBuf[ii++] = MSG_TYPE_REPORT; + ShortToChar(GATE_WAY_APP_PRTCL_VER, &szToGateWayDataBuf[ii]); /* 应用协议版本号 */ + ii += 2u; + szToGateWayDataBuf[ii++] = chLocalId; /* TIOC编号 */ + chAtsScreenNum = GetAtsScreenNum(); + szToGateWayDataBuf[ii++] = chAtsScreenNum; /* 远程筛选列车数量 */ + for (chTrainIndex = 0u; chTrainIndex < chAtsScreenNum; chTrainIndex++) { - if ((TRAIN_POS_MONITOR_VALID == chTrainPosMonitorState) || (TRAIN_NVRAM_POS_FLAG_NO == chTrainNvramFlag)) - { - szToGateWayDataBuf[ii++] = TRAIN_SCREEN_TYPE_LU; /* 远程筛选类别 */ - } - else - { - szToGateWayDataBuf[ii++] = TRAIN_SCREEN_TYPE_POSTION_LOST; /* 监督位置无效筛选 */ - } - - } - else - { - szToGateWayDataBuf[ii++] = chScreenType; - } + wTrainId = GetAtsScreenTrainIdByIndex(chTrainIndex); + chRtn = dquDevName2HlhtId(wTrainId, wTrainLgcId, &dwTrainId); + chScreenType = GetAtsScreenTypeByIndex(chTrainIndex); + wLgcId = GetAtsScreenLgcIdByIndex(chTrainIndex); + chTrainPosMonitorState = GetTrainPosMonitorState(wTrainId); + chTrainNvramFlag = GetTrainNvramPosFlag(wTrainId); - ShortToChar(wLgcId, &szToGateWayDataBuf[ii]); /* 列车所处逻辑区段 */ - ii += 2u; - } - wMsgLen = (ii - wMsgLenIndex - 2u); - ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]); /* 帧长度 */ - chMsgNum++; /* 消息数量递增 */ - } - else - { - ; - } - - if (CI_SUCCESS == chRtn) - { - if (FLAG_SET == g_strAtsCfmFst.chFlag) - { - szToGateWayDataBuf[ii++] = MSG_TYPE_CONFIRM_FIRST; /* 帧类型 */ - wMsgLenIndex = ii; /* 记录帧长度存放下标 */ - ii += 2u; - szToGateWayDataBuf[ii++] = MSG_TYPE_CONFIRM_FIRST; - szToGateWayDataBuf[ii++] = chLocalId; /* TIOC编号 */ - szToGateWayDataBuf[ii++] = g_strAtsCfmFst.chStation; /* 车站编号 */ - ShortToChar(g_strAtsCfmFst.wIndex, &szToGateWayDataBuf[ii]); /* 操作站编号 */ - ii += 2U; - LongToChar(g_strAtsCfmFst.dwTime, &szToGateWayDataBuf[ii]); /* 时间 */ - ii += 4u; - szToGateWayDataBuf[ii++] = g_strAtsCfmFst.chOpStatus; /* 确认结果 */ - LongToChar(g_strAtsCfmFst.dwCrc32, &szToGateWayDataBuf[ii]); /* CRC */ - ii += 4u; - wMsgLen = (ii - wMsgLenIndex - 2u); - ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]); /* 帧长度 */ - chMsgNum++; /* 消息数量递增 */ - } - else - { - ; - } - g_strAtsCfmFst.chFlag = FLAG_UNSET; - } - else - { - ; - } - - if (CI_SUCCESS == chRtn) - { - /*组第二个ATS的远程筛选首次确认信息*/ - if (FLAG_SET == g_strSndAtsCfmFst.chFlag) - { - szToGateWayDataBuf[ii] = MSG_TYPE_CONFIRM_FIRST; /* 帧类型 */ - ii++; - wMsgLenIndex = ii; /* 记录帧长度存放下标 */ - ii += 2U; - szToGateWayDataBuf[ii] = MSG_TYPE_CONFIRM_FIRST; - ii++; - szToGateWayDataBuf[ii] = chLocalId; /* TIOC编号 */ - ii++; - szToGateWayDataBuf[ii] = g_strSndAtsCfmFst.chStation; /* 车站编号 */ - ii++; - ShortToChar(g_strSndAtsCfmFst.wIndex, &szToGateWayDataBuf[ii]); /* 操作站编号 */ - ii += 2U; - LongToChar(g_strSndAtsCfmFst.dwTime, &szToGateWayDataBuf[ii]); /* 时间 */ - ii += 4U; - szToGateWayDataBuf[ii] = g_strSndAtsCfmFst.chOpStatus; /* 确认结果 */ - ii++; - LongToChar(g_strSndAtsCfmFst.dwCrc32, &szToGateWayDataBuf[ii]); /* CRC */ - ii += 4U; - wMsgLen = (ii - wMsgLenIndex - 2U); - ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]); /* 帧长度 */ - chMsgNum++; /* 消息数量递增 */ - - /*组包后清除第二个ATS的确认信息*/ - ClearSndAtsScreenFstCfmMsg(); - } - else - { - ; - } - } - else - { - ; - } - - if (CI_SUCCESS == chRtn) - { - if (FLAG_SET == g_strAtsCfmSnd.chFlag) - { - szToGateWayDataBuf[ii++] = MSG_TYPE_CONFIRM_SECOND; /* 帧类型 */ - wMsgLenIndex = ii; /* 记录帧长度存放下标 */ - ii += 2u; - szToGateWayDataBuf[ii++] = MSG_TYPE_CONFIRM_SECOND; - szToGateWayDataBuf[ii++] = chLocalId; /* TIOC编号 */ - szToGateWayDataBuf[ii++] = g_strAtsCfmSnd.chStation; /* 车站编号 */ - ShortToChar(g_strAtsCfmSnd.wIndex, &szToGateWayDataBuf[ii]); /* 操作站编号 */ - ii += 2U; - LongToChar(g_strAtsCfmSnd.dwTime, &szToGateWayDataBuf[ii]); /* 时间 */ - ii += 4u; - szToGateWayDataBuf[ii++] = g_strAtsCfmSnd.chOpStatus; /* 确认结果 */ - LongToChar(g_strAtsCfmSnd.dwCrc32, &szToGateWayDataBuf[ii]); /* CRC */ - ii += 4u; - wMsgLen = (ii - wMsgLenIndex - 2u); - ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]); /* 帧长度 */ - chMsgNum++; /* 消息数量递增 */ - } - else - { - ; - } - g_strAtsCfmSnd.chFlag = FLAG_UNSET; - } - else - { - ; - } - - if (CI_SUCCESS == chRtn) - { - /* 组TIOC汇报给ATS的区间疏散信息 */ - szToGateWayDataBuf[ii++] = MSG_TYPE_EA_REPORT; /* 区间疏散汇报消息 */ - wMsgLenIndex = ii; /* 记录帧长度存放下标 */ - ii += 2u; - szToGateWayDataBuf[ii++] = MSG_TYPE_EA_REPORT; - ShortToChar(GATE_WAY_APP_PRTCL_VER, &szToGateWayDataBuf[ii]); /* 应用协议版本号 */ - ii += 2u; - szToGateWayDataBuf[ii++] = chLocalId; /* TIOC编号 */ - - chEaNum = GetEaNum(); - if (EA_MAX_NUM < chEaNum) - { - chRtn = CI_ERROR; - } - else - { - chEaSendNum = 0u; - wEaNumIndex = ii; /* 记录汇报数量存储下标 */ - ii++; - - for (chEaIndex = 0u; chEaIndex < chEaNum; chEaIndex++) - { - wEaTrainid = GetEvacuatingTrainIdByIndex(chEaIndex); - chRtn = dquDevName2HlhtId(wEaTrainid, wTrainLgcId, &dwEaTrainHlhtId); - chEaLgcNum = EaGetLgcNum(chEaIndex); - pEaLgcId = EaGetLgcId(chEaIndex); - chEaBuidFlag = GetEaBuildedFlag(chEaIndex); - chEaSrcId = GetEaSrcTiocByIndex(chEaIndex); - chPaType = GetPaTypeByIndex(chEaIndex); - chEaConfigId = GetEaConfigID(chEaIndex); - chEaAreaLineType = GetEaAreaLineType(chEaIndex); - if ((NULL == pEaLgcId) || (CI_ERROR == chRtn) || (EA_SECTION_MAX_NUM < chEaLgcNum) - || ((PA_TYPE_DA != chPaType) && (PA_TYPE_EA != chPaType))) - { - chRtn = CI_ERROR; - break; - } - else - { - if ((chEaSrcId == chLocalId) && (PA_TYPE_EA == chPaType)) - { - chEaSendNum++; - LongToChar(dwEaTrainHlhtId, &szToGateWayDataBuf[ii]); /* 区间疏散列车互联互通ID */ - ii += 4u; - - szToGateWayDataBuf[ii++] = chEaConfigId; /* 防护区域ID，*/ - - szToGateWayDataBuf[ii++] = chEaBuidFlag; /* 防护区域建立标志 */ - - szToGateWayDataBuf[ii++] = chEaAreaLineType; /* 上下行区域 */ - - szToGateWayDataBuf[ii++] = chEaLgcNum; /* 逻辑区段数量 */ - for (chEaLgcIndex = 0u; chEaLgcIndex < chEaLgcNum; chEaLgcIndex++) - { - ShortToChar(pEaLgcId[chEaLgcIndex], &szToGateWayDataBuf[ii]); - ii += 2u; - } - } - else - { - ; /* 本控区非建立控区，不汇报给ATS */ - } - } - } - - szToGateWayDataBuf[wEaNumIndex] = chEaSendNum; /* 组汇报数量 */ - - wMsgLen = (ii - wMsgLenIndex - 2u); - ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]); /* 帧长度 */ - chMsgNum++; /* 消息数量递增 */ - } - } - else - { - ; - } - - if (CI_SUCCESS == chRtn) - { - if (FLAG_SET == g_strAtsEaCfmFst.chFlag) - { - szToGateWayDataBuf[ii++] = MSG_TYPE_EA_CONFIRM_FIRST; /* 帧类型 */ - wMsgLenIndex = ii; /* 记录帧长度存放下标 */ - ii += 2u; - szToGateWayDataBuf[ii++] = MSG_TYPE_EA_CONFIRM_FIRST; - szToGateWayDataBuf[ii++] = chLocalId; /* TIOC编号 */ - szToGateWayDataBuf[ii++] = g_strAtsEaCfmFst.chStation; /* 车站编号 */ - ShortToChar(g_strAtsEaCfmFst.wIndex, &szToGateWayDataBuf[ii]); /* 操作站编号 */ - ii += 2U; - LongToChar(g_strAtsEaCfmFst.dwTime, &szToGateWayDataBuf[ii]); /* 时间 */ - ii += 4u; - szToGateWayDataBuf[ii++] = g_strAtsEaCfmFst.chOpStatus; /* 确认结果 */ - LongToChar(g_strAtsEaCfmFst.dwCrc32, &szToGateWayDataBuf[ii]); /* CRC */ - ii += 4u; - wMsgLen = (ii - wMsgLenIndex - 2u); - ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]); /* 帧长度 */ - chMsgNum++; /* 消息数量递增 */ - } - else - { - ; - } - g_strAtsEaCfmFst.chFlag = FLAG_UNSET; - } - else - { - ; - } - - if (CI_SUCCESS == chRtn) - { - /*组第二个ATS的取消区间疏散首次确认信息*/ - if (FLAG_SET == g_strSndAtsEaCfmFst.chFlag) - { - szToGateWayDataBuf[ii] = MSG_TYPE_EA_CONFIRM_FIRST; /* 帧类型 */ - ii++; - wMsgLenIndex = ii; /* 记录帧长度存放下标 */ - ii += 2U; - szToGateWayDataBuf[ii] = MSG_TYPE_EA_CONFIRM_FIRST; - ii++; - szToGateWayDataBuf[ii] = chLocalId; /* TIOC编号 */ - ii++; - szToGateWayDataBuf[ii] = g_strSndAtsEaCfmFst.chStation; /* 车站编号 */ - ii++; - ShortToChar(g_strSndAtsEaCfmFst.wIndex, &szToGateWayDataBuf[ii]); /* 操作站编号 */ - ii += 2U; - LongToChar(g_strSndAtsEaCfmFst.dwTime, &szToGateWayDataBuf[ii]); /* 时间 */ - ii += 4U; - szToGateWayDataBuf[ii] = g_strSndAtsEaCfmFst.chOpStatus; /* 确认结果 */ - ii++; - LongToChar(g_strSndAtsEaCfmFst.dwCrc32, &szToGateWayDataBuf[ii]); /* CRC */ - ii += 4U; - wMsgLen = (ii - wMsgLenIndex - 2U); - ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]); /* 帧长度 */ - chMsgNum++; /* 消息数量递增 */ - - /*组包后清除第二个ATS的确认信息*/ - ClearSndAtsEaFstCfmMsg(); - } - else - { - ; - } - } - else - { - ; - } - - if (CI_SUCCESS == chRtn) - { - if (FLAG_SET == g_strAtsEaCfmSnd.chFlag) - { - szToGateWayDataBuf[ii++] = MSG_TYPE_EA_CONFIRM_SECOND; /* 帧类型 */ - wMsgLenIndex = ii; /* 记录帧长度存放下标 */ - ii += 2u; - szToGateWayDataBuf[ii++] = MSG_TYPE_EA_CONFIRM_SECOND; - szToGateWayDataBuf[ii++] = chLocalId; /* TIOC编号 */ - szToGateWayDataBuf[ii++] = g_strAtsEaCfmSnd.chStation; /* 车站编号 */ - ShortToChar(g_strAtsEaCfmSnd.wIndex, &szToGateWayDataBuf[ii]); /* 操作站编号 */ - ii += 2U; - LongToChar(g_strAtsEaCfmSnd.dwTime, &szToGateWayDataBuf[ii]); /* 时间 */ - ii += 4u; - szToGateWayDataBuf[ii++] = g_strAtsEaCfmSnd.chOpStatus; /* 确认结果 */ - LongToChar(g_strAtsEaCfmSnd.dwCrc32, &szToGateWayDataBuf[ii]); /* CRC */ - ii += 4u; - wMsgLen = (ii - wMsgLenIndex - 2u); - ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]); /* 帧长度 */ - chMsgNum++; /* 消息数量递增 */ - } - else - { - ; - } - g_strAtsEaCfmSnd.chFlag = FLAG_UNSET; - } - else - { - ; - } - - if (CI_SUCCESS == chRtn) - { - /* 组TIOC汇报给ATS的全线列车紧急制动信息 */ - szToGateWayDataBuf[ii++] = MSG_TYPE_WLB_REPORT; /* 全线列车紧急制动汇报消息 */ - wMsgLenIndex = ii; /* 记录帧长度存放下标 */ - ii += 2u; - szToGateWayDataBuf[ii++] = MSG_TYPE_WLB_REPORT; - szToGateWayDataBuf[ii++] = chLocalId; /* TIOC编号 */ - - wWlbSum = 0U; - wWlbSumIndex = ii; - ii += 2U; - - /*组全线紧急制动信息*/ - chWlbState = WlbGetState(); - if (WLB_UNSET != chWlbState) - { - wWlbSum++; - szToGateWayDataBuf[ii++] = WLB_TYPE_RC; /* 制动类型 */ - ShortToChar(wRcId, &szToGateWayDataBuf[ii]); /* RC编号 */ - ii += 2u; - } - else - { - /* 未设置，不组包 */ - } - - /*组区域紧急制动信息*/ - wPhyCurSum = GetPhySecCurSum(); - for (jj = 0U; jj < wPhyCurSum; jj++) - { - wPhySecId = GetPhySecId(jj); - cPhySecAreaUrgentState = GetPhySecAreaUrgentState(wPhySecId); - if (PHYSEC_AREA_URGENT_NO != cPhySecAreaUrgentState) - { - wWlbSum++; - szToGateWayDataBuf[ii++] = WLB_TYPE_PHYSEC; /* 制动类型 */ - ShortToChar(wPhySecId, &szToGateWayDataBuf[ii]); /* 物理区段编号 */ - ii += 2U; - } - else - { - /*不组包*/ - } - } - - ShortToChar(wWlbSum, &szToGateWayDataBuf[wWlbSumIndex]); /* 组紧急制动数量 */ - - wMsgLen = (ii - wMsgLenIndex - 2u); - ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]); /* 帧长度 */ - chMsgNum++; /* 消息数量递增 */ - } - else - { - ; - } - - if (CI_SUCCESS == chRtn) - { - if (FLAG_SET == g_strAtsWlbCfmFst.chFlag) - { - szToGateWayDataBuf[ii++] = MSG_TYPE_WLB_CONFIRM_FIRST; /* 帧类型 */ - wMsgLenIndex = ii; /* 记录帧长度存放下标 */ - ii += 2u; - szToGateWayDataBuf[ii++] = MSG_TYPE_WLB_CONFIRM_FIRST; - szToGateWayDataBuf[ii++] = chLocalId; /* TIOC编号 */ - szToGateWayDataBuf[ii++] = g_strAtsWlbCfmFst.chStation; /* 车站编号 */ - ShortToChar(g_strAtsWlbCfmFst.wIndex, &szToGateWayDataBuf[ii]); /* 操作站编号 */ - ii += 2U; - LongToChar(g_strAtsWlbCfmFst.dwTime, &szToGateWayDataBuf[ii]); /* 时间 */ - ii += 4u; - szToGateWayDataBuf[ii++] = g_strAtsWlbCfmFst.chOpStatus; /* 确认结果 */ - LongToChar(g_strAtsWlbCfmFst.dwCrc32, &szToGateWayDataBuf[ii]); /* CRC */ - ii += 4u; - wMsgLen = (ii - wMsgLenIndex - 2u); - ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]); /* 帧长度 */ - chMsgNum++; /* 消息数量递增 */ - } - else - { - ; - } - g_strAtsWlbCfmFst.chFlag = FLAG_UNSET; - } - else - { - ; - } - - if (CI_SUCCESS == chRtn) - { - /*组第二个ATS的全线紧急制动首次确认信息*/ - if (FLAG_SET == g_strSndAtsWlbCfmFst.chFlag) - { - szToGateWayDataBuf[ii] = MSG_TYPE_WLB_CONFIRM_FIRST; /* 帧类型 */ - ii++; - wMsgLenIndex = ii; /* 记录帧长度存放下标 */ - ii += 2U; - szToGateWayDataBuf[ii] = MSG_TYPE_WLB_CONFIRM_FIRST; - ii++; - szToGateWayDataBuf[ii] = chLocalId; /* TIOC编号 */ - ii++; - szToGateWayDataBuf[ii] = g_strSndAtsWlbCfmFst.chStation; /* 车站编号 */ - ii++; - ShortToChar(g_strSndAtsWlbCfmFst.wIndex, &szToGateWayDataBuf[ii]); /* 操作站编号 */ - ii += 2U; - LongToChar(g_strSndAtsWlbCfmFst.dwTime, &szToGateWayDataBuf[ii]); /* 时间 */ - ii += 4U; - szToGateWayDataBuf[ii] = g_strSndAtsWlbCfmFst.chOpStatus; /* 确认结果 */ - ii++; - LongToChar(g_strSndAtsWlbCfmFst.dwCrc32, &szToGateWayDataBuf[ii]); /* CRC */ - ii += 4U; - wMsgLen = (ii - wMsgLenIndex - 2U); - ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]); /* 帧长度 */ - chMsgNum++; /* 消息数量递增 */ - - /*组包后清除第二个ATS的确认信息*/ - ClearSndAtsWlbFstCfmMsg(); - } - else - { - ; - } - } - else - { - ; - } - - if (CI_SUCCESS == chRtn) - { - if (FLAG_SET == g_strAtsWlbCfmSnd.chFlag) - { - szToGateWayDataBuf[ii++] = MSG_TYPE_WLB_CONFIRM_SECOND; /* 帧类型 */ - wMsgLenIndex = ii; /* 记录帧长度存放下标 */ - ii += 2u; - szToGateWayDataBuf[ii++] = MSG_TYPE_WLB_CONFIRM_SECOND; - szToGateWayDataBuf[ii++] = chLocalId; /* TIOC编号 */ - szToGateWayDataBuf[ii++] = g_strAtsWlbCfmSnd.chStation; /* 车站编号 */ - ShortToChar(g_strAtsWlbCfmSnd.wIndex, &szToGateWayDataBuf[ii]); /* 操作站编号 */ - ii += 2U; - LongToChar(g_strAtsWlbCfmSnd.dwTime, &szToGateWayDataBuf[ii]); /* 时间 */ - ii += 4u; - szToGateWayDataBuf[ii++] = g_strAtsWlbCfmSnd.chOpStatus; /* 确认结果 */ - LongToChar(g_strAtsWlbCfmSnd.dwCrc32, &szToGateWayDataBuf[ii]); /* CRC */ - ii += 4u; - wMsgLen = (ii - wMsgLenIndex - 2u); - ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]); /* 帧长度 */ - chMsgNum++; /* 消息数量递增 */ - } - else - { - ; - } - g_strAtsWlbCfmSnd.chFlag = FLAG_UNSET; - } - else - { - ; - } - - if (CI_SUCCESS == chRtn) - { - /* 组TIOC汇报给ATS的脱轨防护区域信息 */ - szToGateWayDataBuf[ii++] = MSG_TYPE_DA_REPORT; /* 脱轨防护区域汇报消息 */ - wMsgLenIndex = ii; /* 记录帧长度存放下标 */ - ii += 2u; - szToGateWayDataBuf[ii++] = MSG_TYPE_DA_REPORT; - ShortToChar(GATE_WAY_APP_PRTCL_VER, &szToGateWayDataBuf[ii]); /* 应用协议版本号 */ - ii += 2u; - szToGateWayDataBuf[ii++] = chLocalId; /* TIOC编号 */ - - chEaNum = GetEaNum(); - if (EA_MAX_NUM < chEaNum) - { - chRtn = CI_ERROR; - } - else - { - chEaSendNum = 0u; - wEaNumIndex = ii; /* 记录汇报数量存储下标 */ - ii++; - - for (chEaIndex = 0u; chEaIndex < chEaNum; chEaIndex++) - { - wEaTrainid = GetEvacuatingTrainIdByIndex(chEaIndex); - chRtn = dquDevName2HlhtId(wEaTrainid, wTrainLgcId, &dwEaTrainHlhtId); - chEaLgcNum = EaGetLgcNum(chEaIndex); - pEaLgcId = EaGetLgcId(chEaIndex); - chEaBuidFlag = GetEaBuildedFlag(chEaIndex); - chEaSrcId = GetEaSrcTiocByIndex(chEaIndex); - chPaType = GetPaTypeByIndex(chEaIndex); - chEaAreaLineType = GetEaAreaLineType(chEaIndex); - - if ((NULL == pEaLgcId) || (CI_ERROR == chRtn) || (EA_SECTION_MAX_NUM < chEaLgcNum) - || ((PA_TYPE_DA != chPaType) && (PA_TYPE_EA != chPaType))) - { - chRtn = CI_ERROR; - break; - } - else - { - if ((chEaSrcId == chLocalId) && (PA_TYPE_DA == chPaType)) - { - chEaSendNum++; - LongToChar(dwEaTrainHlhtId, &szToGateWayDataBuf[ii]); /* 区间疏散列车互联互通ID */ - ii += 4u; - - szToGateWayDataBuf[ii++] = chEaAreaLineType; /* 上下行区域 */ - - szToGateWayDataBuf[ii++] = chEaLgcNum; /* 逻辑区段数量 */ - for (chEaLgcIndex = 0u; chEaLgcIndex < chEaLgcNum; chEaLgcIndex++) - { - ShortToChar(pEaLgcId[chEaLgcIndex], &szToGateWayDataBuf[ii]); - ii += 2u; - } - } - else - { - ; /* 本控区非建立控区，不汇报给ATS */ - } - } - } - - szToGateWayDataBuf[wEaNumIndex] = chEaSendNum; /* 组汇报数量 */ - - wMsgLen = (ii - wMsgLenIndex - 2u); - ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]); /* 帧长度 */ - chMsgNum++; /* 消息数量递增 */ - } - } - else - { - ; - } - - if (CI_SUCCESS == chRtn) - { - if (FLAG_SET == g_strAtsDaCfmFst.chFlag) - { - szToGateWayDataBuf[ii++] = MSG_TYPE_DA_CONFIRM_FIRST; /* 帧类型 */ - wMsgLenIndex = ii; /* 记录帧长度存放下标 */ - ii += 2u; - szToGateWayDataBuf[ii++] = MSG_TYPE_DA_CONFIRM_FIRST; - szToGateWayDataBuf[ii++] = chLocalId; /* TIOC编号 */ - szToGateWayDataBuf[ii++] = g_strAtsDaCfmFst.chStation; /* 车站编号 */ - ShortToChar(g_strAtsDaCfmFst.wIndex, &szToGateWayDataBuf[ii]); /* 操作站编号 */ - ii += 2U; - LongToChar(g_strAtsDaCfmFst.dwTime, &szToGateWayDataBuf[ii]); /* 时间 */ - ii += 4u; - szToGateWayDataBuf[ii++] = g_strAtsDaCfmFst.chOpStatus; /* 确认结果 */ - LongToChar(g_strAtsDaCfmFst.dwCrc32, &szToGateWayDataBuf[ii]); /* CRC */ - ii += 4u; - wMsgLen = (ii - wMsgLenIndex - 2u); - ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]); /* 帧长度 */ - chMsgNum++; /* 消息数量递增 */ - } - else - { - ; - } - g_strAtsDaCfmFst.chFlag = FLAG_UNSET; - } - else - { - ; - } - - if (CI_SUCCESS == chRtn) - { - /*组第二个ATS的取消防护区域首次确认信息*/ - if (FLAG_SET == g_strSndAtsDaCfmFst.chFlag) - { - szToGateWayDataBuf[ii] = MSG_TYPE_DA_CONFIRM_FIRST; /* 帧类型 */ - ii++; - wMsgLenIndex = ii; /* 记录帧长度存放下标 */ - ii += 2U; - szToGateWayDataBuf[ii] = MSG_TYPE_DA_CONFIRM_FIRST; - ii++; - szToGateWayDataBuf[ii] = chLocalId; /* TIOC编号 */ - ii++; - szToGateWayDataBuf[ii] = g_strSndAtsDaCfmFst.chStation; /* 车站编号 */ - ii++; - ShortToChar(g_strSndAtsDaCfmFst.wIndex, &szToGateWayDataBuf[ii]); /* 操作站编号 */ - ii += 2U; - LongToChar(g_strSndAtsDaCfmFst.dwTime, &szToGateWayDataBuf[ii]); /* 时间 */ - ii += 4U; - szToGateWayDataBuf[ii] = g_strSndAtsDaCfmFst.chOpStatus; /* 确认结果 */ - ii++; - LongToChar(g_strSndAtsDaCfmFst.dwCrc32, &szToGateWayDataBuf[ii]); /* CRC */ - ii += 4U; - wMsgLen = (ii - wMsgLenIndex - 2U); - ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]); /* 帧长度 */ - chMsgNum++; /* 消息数量递增 */ - - /*组包后清除第二个ATS的确认信息*/ - ClearSndAtsDaFstCfmMsg(); - } - else - { - ; - } - } - else - { - ; - } - - if (CI_SUCCESS == chRtn) - { - if (FLAG_SET == g_strAtsDaCfmSnd.chFlag) - { - szToGateWayDataBuf[ii++] = MSG_TYPE_DA_CONFIRM_SECOND; /* 帧类型 */ - wMsgLenIndex = ii; /* 记录帧长度存放下标 */ - ii += 2u; - szToGateWayDataBuf[ii++] = MSG_TYPE_DA_CONFIRM_SECOND; - szToGateWayDataBuf[ii++] = chLocalId; /* TIOC编号 */ - szToGateWayDataBuf[ii++] = g_strAtsDaCfmSnd.chStation; /* 车站编号 */ - ShortToChar(g_strAtsDaCfmSnd.wIndex, &szToGateWayDataBuf[ii]); /* 操作站编号 */ - ii += 2U; - LongToChar(g_strAtsDaCfmSnd.dwTime, &szToGateWayDataBuf[ii]); /* 时间 */ - ii += 4u; - szToGateWayDataBuf[ii++] = g_strAtsDaCfmSnd.chOpStatus; /* 确认结果 */ - LongToChar(g_strAtsDaCfmSnd.dwCrc32, &szToGateWayDataBuf[ii]); /* CRC */ - ii += 4u; - wMsgLen = (ii - wMsgLenIndex - 2u); - ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]); /* 帧长度 */ - chMsgNum++; /* 消息数量递增 */ - } - else - { - ; - } - g_strAtsDaCfmSnd.chFlag = FLAG_UNSET; - } - else - { - ; - } - - if (CI_SUCCESS == chRtn) - { - /* 组TIOC汇报给ATS的列车信息 */ - rrm_GetInfToATSUCTInfo(&strTrainInfo); - szToGateWayDataBuf[ii++] = MSG_TYPE_TRIAN_INFO_REPORT; /* 汇报远程筛选列车信息帧 */ - wMsgLenIndex = ii; /* 记录帧长度存放下标 */ - ii += 2u; - szToGateWayDataBuf[ii++] = MSG_TYPE_TRIAN_INFO_REPORT; - ShortToChar(GATE_WAY_APP_PRTCL_VER, &szToGateWayDataBuf[ii]); /* 应用协议版本号 */ - ii += 2u; - szToGateWayDataBuf[ii++] = chLocalId; /* TIOC编号 */ - szToGateWayDataBuf[ii++] = strTrainInfo.trainCnt; /* 列车数量 */ - for (chTrainIndex = 0u; chTrainIndex < strTrainInfo.trainCnt; chTrainIndex++) - { - (void)dquDevName2HlhtId(strTrainInfo.TrainID[chTrainIndex], wTrainLgcId, &dwTrainId); - LongToChar(dwTrainId, &szToGateWayDataBuf[ii]); /* 列车互联互通ID */ - ii += 4u; - - ShortToChar(strTrainInfo.TailSecID[chTrainIndex], &szToGateWayDataBuf[ii]); /* 列车车尾所处逻辑区段 */ - ii += 2u; - } - wMsgLen = (ii - wMsgLenIndex - 2u); - ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]); /* 帧长度 */ - chMsgNum++; /* 消息数量递增 */ - } - else - { - ; - } - } - else - { - /*组飞车宕机信息*/ - szToGateWayDataBuf[ii++] = MSG_TYPE_TRAIN_FLY_INFO; /* 帧类型 */ - wMsgLenIndex = ii; /* 记录帧长度存放下标 */ - ii += 2u; - szToGateWayDataBuf[ii++] = MSG_TYPE_TRAIN_FLY_INFO; - - ShortToChar(GATE_WAY_APP_PRTCL_VER, &szToGateWayDataBuf[ii]); /* 应用协议版本号 */ - ii += 2u; - szToGateWayDataBuf[ii++] = chLocalId; /* TIOC编号 */ - - FlyProtectTrainNum = GetFlyProtectNum(); - if (SHUT_DOWN_TRAIN_NUMMAX < FlyProtectTrainNum) - { - chRtn = CI_ERROR; - } - else - { - szToGateWayDataBuf[ii++] = FlyProtectTrainNum; /*组飞车列车数量*/ - for (chIndex = 0U; chIndex < FlyProtectTrainNum; chIndex++) - { - pFlyData = GetFlyProtectData(chIndex); - wTrainId = pFlyData->wTrainId; - TrainFlyAxis = pFlyData->flyProtectSecCnt; - chRtn = dquDevName2HlhtId((UINT16)(CI_SYSTEM_TYPE_IVOC * 256U) + wTrainId, 0U, &dwTrainId); /*两字节列车ID转换为4字节互联互通ID*/ - if (chRtn == CI_SUCCESS) - {/*互联互通ID查询成功*/ LongToChar(dwTrainId, &szToGateWayDataBuf[ii]); /* 列车ID */ ii += 4u; - /** 获取通信车对应的包络id */ - - if (TRAIN_FLYALARM_SECNUM_MAX < TrainFlyAxis) + + if (TRAIN_SCREEN_TYPE_LU == chScreenType) { - chRtn = CI_ERROR; + if ((TRAIN_POS_MONITOR_VALID == chTrainPosMonitorState) || (TRAIN_NVRAM_POS_FLAG_NO == chTrainNvramFlag)) + { + szToGateWayDataBuf[ii++] = TRAIN_SCREEN_TYPE_LU; /* 远程筛选类别 */ + } + else + { + szToGateWayDataBuf[ii++] = TRAIN_SCREEN_TYPE_POSTION_LOST; /* 监督位置无效筛选 */ + } + } else { - szToGateWayDataBuf[ii++] = TrainFlyAxis; /* 计轴数量 */ - /* 获取计轴 id*/ - for (jj = 0U; jj < TrainFlyAxis; jj++) + szToGateWayDataBuf[ii++] = chScreenType; + } + + ShortToChar(wLgcId, &szToGateWayDataBuf[ii]); /* 列车所处逻辑区段 */ + ii += 2u; + } + wMsgLen = (ii - wMsgLenIndex - 2u); + ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]); /* 帧长度 */ + chMsgNum++; /* 消息数量递增 */ + } + else + { + ; + } + + if (CI_SUCCESS == chRtn) + { + if (FLAG_SET == g_strAtsCfmFst.chFlag) + { + szToGateWayDataBuf[ii++] = MSG_TYPE_CONFIRM_FIRST; /* 帧类型 */ + wMsgLenIndex = ii; /* 记录帧长度存放下标 */ + ii += 2u; + szToGateWayDataBuf[ii++] = MSG_TYPE_CONFIRM_FIRST; + szToGateWayDataBuf[ii++] = chLocalId; /* TIOC编号 */ + szToGateWayDataBuf[ii++] = g_strAtsCfmFst.chStation; /* 车站编号 */ + ShortToChar(g_strAtsCfmFst.wIndex, &szToGateWayDataBuf[ii]); /* 操作站编号 */ + ii += 2U; + LongToChar(g_strAtsCfmFst.dwTime, &szToGateWayDataBuf[ii]); /* 时间 */ + ii += 4u; + szToGateWayDataBuf[ii++] = g_strAtsCfmFst.chOpStatus; /* 确认结果 */ + LongToChar(g_strAtsCfmFst.dwCrc32, &szToGateWayDataBuf[ii]); /* CRC */ + ii += 4u; + wMsgLen = (ii - wMsgLenIndex - 2u); + ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]); /* 帧长度 */ + chMsgNum++; /* 消息数量递增 */ + } + else + { + ; + } + g_strAtsCfmFst.chFlag = FLAG_UNSET; + } + else + { + ; + } + + if (CI_SUCCESS == chRtn) + { + /*组第二个ATS的远程筛选首次确认信息*/ + if (FLAG_SET == g_strSndAtsCfmFst.chFlag) + { + szToGateWayDataBuf[ii] = MSG_TYPE_CONFIRM_FIRST; /* 帧类型 */ + ii++; + wMsgLenIndex = ii; /* 记录帧长度存放下标 */ + ii += 2U; + szToGateWayDataBuf[ii] = MSG_TYPE_CONFIRM_FIRST; + ii++; + szToGateWayDataBuf[ii] = chLocalId; /* TIOC编号 */ + ii++; + szToGateWayDataBuf[ii] = g_strSndAtsCfmFst.chStation; /* 车站编号 */ + ii++; + ShortToChar(g_strSndAtsCfmFst.wIndex, &szToGateWayDataBuf[ii]); /* 操作站编号 */ + ii += 2U; + LongToChar(g_strSndAtsCfmFst.dwTime, &szToGateWayDataBuf[ii]); /* 时间 */ + ii += 4U; + szToGateWayDataBuf[ii] = g_strSndAtsCfmFst.chOpStatus; /* 确认结果 */ + ii++; + LongToChar(g_strSndAtsCfmFst.dwCrc32, &szToGateWayDataBuf[ii]); /* CRC */ + ii += 4U; + wMsgLen = (ii - wMsgLenIndex - 2U); + ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]); /* 帧长度 */ + chMsgNum++; /* 消息数量递增 */ + + /*组包后清除第二个ATS的确认信息*/ + ClearSndAtsScreenFstCfmMsg(); + } + else + { + ; + } + } + else + { + ; + } + + if (CI_SUCCESS == chRtn) + { + if (FLAG_SET == g_strAtsCfmSnd.chFlag) + { + szToGateWayDataBuf[ii++] = MSG_TYPE_CONFIRM_SECOND; /* 帧类型 */ + wMsgLenIndex = ii; /* 记录帧长度存放下标 */ + ii += 2u; + szToGateWayDataBuf[ii++] = MSG_TYPE_CONFIRM_SECOND; + szToGateWayDataBuf[ii++] = chLocalId; /* TIOC编号 */ + szToGateWayDataBuf[ii++] = g_strAtsCfmSnd.chStation; /* 车站编号 */ + ShortToChar(g_strAtsCfmSnd.wIndex, &szToGateWayDataBuf[ii]); /* 操作站编号 */ + ii += 2U; + LongToChar(g_strAtsCfmSnd.dwTime, &szToGateWayDataBuf[ii]); /* 时间 */ + ii += 4u; + szToGateWayDataBuf[ii++] = g_strAtsCfmSnd.chOpStatus; /* 确认结果 */ + LongToChar(g_strAtsCfmSnd.dwCrc32, &szToGateWayDataBuf[ii]); /* CRC */ + ii += 4u; + wMsgLen = (ii - wMsgLenIndex - 2u); + ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]); /* 帧长度 */ + chMsgNum++; /* 消息数量递增 */ + } + else + { + ; + } + g_strAtsCfmSnd.chFlag = FLAG_UNSET; + } + else + { + ; + } + + if (CI_SUCCESS == chRtn) + { + /* 组TIOC汇报给ATS的区间疏散信息 */ + szToGateWayDataBuf[ii++] = MSG_TYPE_EA_REPORT; /* 区间疏散汇报消息 */ + wMsgLenIndex = ii; /* 记录帧长度存放下标 */ + ii += 2u; + szToGateWayDataBuf[ii++] = MSG_TYPE_EA_REPORT; + ShortToChar(GATE_WAY_APP_PRTCL_VER, &szToGateWayDataBuf[ii]); /* 应用协议版本号 */ + ii += 2u; + szToGateWayDataBuf[ii++] = chLocalId; /* TIOC编号 */ + + chEaNum = GetEaNum(); + if (EA_MAX_NUM < chEaNum) + { + chRtn = CI_ERROR; + } + else + { + chEaSendNum = 0u; + wEaNumIndex = ii; /* 记录汇报数量存储下标 */ + ii++; + + for (chEaIndex = 0u; chEaIndex < chEaNum; chEaIndex++) + { + wEaTrainid = GetEvacuatingTrainIdByIndex(chEaIndex); + chRtn = dquDevName2HlhtId(wEaTrainid, wTrainLgcId, &dwEaTrainHlhtId); + chEaLgcNum = EaGetLgcNum(chEaIndex); + pEaLgcId = EaGetLgcId(chEaIndex); + chEaBuidFlag = GetEaBuildedFlag(chEaIndex); + chEaSrcId = GetEaSrcTiocByIndex(chEaIndex); + chPaType = GetPaTypeByIndex(chEaIndex); + chEaConfigId = GetEaConfigID(chEaIndex); + chEaAreaLineType = GetEaAreaLineType(chEaIndex); + if ((NULL == pEaLgcId) || (CI_ERROR == chRtn) || (EA_SECTION_MAX_NUM < chEaLgcNum) + || ((PA_TYPE_DA != chPaType) && (PA_TYPE_EA != chPaType))) { - wPhySecId = pFlyData->flyProtectSec[jj]; - ShortToChar(wPhySecId, &szToGateWayDataBuf[ii]); - ii += 2u; + chRtn = CI_ERROR; + break; + } + else + { + if ((chEaSrcId == chLocalId) && (PA_TYPE_EA == chPaType)) + { + chEaSendNum++; + LongToChar(dwEaTrainHlhtId, &szToGateWayDataBuf[ii]); /* 区间疏散列车互联互通ID */ + ii += 4u; + + szToGateWayDataBuf[ii++] = chEaConfigId; /* 防护区域ID，*/ + + szToGateWayDataBuf[ii++] = chEaBuidFlag; /* 防护区域建立标志 */ + + szToGateWayDataBuf[ii++] = chEaAreaLineType; /* 上下行区域 */ + + szToGateWayDataBuf[ii++] = chEaLgcNum; /* 逻辑区段数量 */ + for (chEaLgcIndex = 0u; chEaLgcIndex < chEaLgcNum; chEaLgcIndex++) + { + ShortToChar(pEaLgcId[chEaLgcIndex], &szToGateWayDataBuf[ii]); + ii += 2u; + } + } + else + { + ; /* 本控区非建立控区，不汇报给ATS */ + } } } - } - else - { /*组包失败*/ - chRtn = CI_ERROR; + szToGateWayDataBuf[wEaNumIndex] = chEaSendNum; /* 组汇报数量 */ + + wMsgLen = (ii - wMsgLenIndex - 2u); + ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]); /* 帧长度 */ + chMsgNum++; /* 消息数量递增 */ } } - wMsgLen = (ii - wMsgLenIndex - 2u); - ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]); /* 帧长度 */ - } + else + { + ; + } - if (CI_SUCCESS == chRtn) - { - debug_infor_printf((const)"\n GATEWAY_FLY_SHUT_DOWN \n"); - chMsgNum = 1U; - } - } - if (CI_SUCCESS == chRtn) - { - /* 组包成功，填入消息数量 */ - szToGateWayDataBuf[wMsgNumIndex] = chMsgNum; - wDstDevId = (UINT16)(((UINT16)targetDevType << 8U) | (UINT16)deviceId); - chRtn = OutnetSafeSend(wDstDevId, 0u, &szToGateWayDataBuf[0], ii); - if (CI_SUCCESS == chRtn) - { - debug_infor_printf((const)"\nGATEWAY_SEND:%d", ii); - debug_out_array(0xAA, szToGateWayDataBuf, ii); + if (CI_SUCCESS == chRtn) + { + if (FLAG_SET == g_strAtsEaCfmFst.chFlag) + { + szToGateWayDataBuf[ii++] = MSG_TYPE_EA_CONFIRM_FIRST; /* 帧类型 */ + wMsgLenIndex = ii; /* 记录帧长度存放下标 */ + ii += 2u; + szToGateWayDataBuf[ii++] = MSG_TYPE_EA_CONFIRM_FIRST; + szToGateWayDataBuf[ii++] = chLocalId; /* TIOC编号 */ + szToGateWayDataBuf[ii++] = g_strAtsEaCfmFst.chStation; /* 车站编号 */ + ShortToChar(g_strAtsEaCfmFst.wIndex, &szToGateWayDataBuf[ii]); /* 操作站编号 */ + ii += 2U; + LongToChar(g_strAtsEaCfmFst.dwTime, &szToGateWayDataBuf[ii]); /* 时间 */ + ii += 4u; + szToGateWayDataBuf[ii++] = g_strAtsEaCfmFst.chOpStatus; /* 确认结果 */ + LongToChar(g_strAtsEaCfmFst.dwCrc32, &szToGateWayDataBuf[ii]); /* CRC */ + ii += 4u; + wMsgLen = (ii - wMsgLenIndex - 2u); + ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]); /* 帧长度 */ + chMsgNum++; /* 消息数量递增 */ + } + else + { + ; + } + g_strAtsEaCfmFst.chFlag = FLAG_UNSET; + } + else + { + ; + } + + if (CI_SUCCESS == chRtn) + { + /*组第二个ATS的取消区间疏散首次确认信息*/ + if (FLAG_SET == g_strSndAtsEaCfmFst.chFlag) + { + szToGateWayDataBuf[ii] = MSG_TYPE_EA_CONFIRM_FIRST; /* 帧类型 */ + ii++; + wMsgLenIndex = ii; /* 记录帧长度存放下标 */ + ii += 2U; + szToGateWayDataBuf[ii] = MSG_TYPE_EA_CONFIRM_FIRST; + ii++; + szToGateWayDataBuf[ii] = chLocalId; /* TIOC编号 */ + ii++; + szToGateWayDataBuf[ii] = g_strSndAtsEaCfmFst.chStation; /* 车站编号 */ + ii++; + ShortToChar(g_strSndAtsEaCfmFst.wIndex, &szToGateWayDataBuf[ii]); /* 操作站编号 */ + ii += 2U; + LongToChar(g_strSndAtsEaCfmFst.dwTime, &szToGateWayDataBuf[ii]); /* 时间 */ + ii += 4U; + szToGateWayDataBuf[ii] = g_strSndAtsEaCfmFst.chOpStatus; /* 确认结果 */ + ii++; + LongToChar(g_strSndAtsEaCfmFst.dwCrc32, &szToGateWayDataBuf[ii]); /* CRC */ + ii += 4U; + wMsgLen = (ii - wMsgLenIndex - 2U); + ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]); /* 帧长度 */ + chMsgNum++; /* 消息数量递增 */ + + /*组包后清除第二个ATS的确认信息*/ + ClearSndAtsEaFstCfmMsg(); + } + else + { + ; + } + } + else + { + ; + } + + if (CI_SUCCESS == chRtn) + { + if (FLAG_SET == g_strAtsEaCfmSnd.chFlag) + { + szToGateWayDataBuf[ii++] = MSG_TYPE_EA_CONFIRM_SECOND; /* 帧类型 */ + wMsgLenIndex = ii; /* 记录帧长度存放下标 */ + ii += 2u; + szToGateWayDataBuf[ii++] = MSG_TYPE_EA_CONFIRM_SECOND; + szToGateWayDataBuf[ii++] = chLocalId; /* TIOC编号 */ + szToGateWayDataBuf[ii++] = g_strAtsEaCfmSnd.chStation; /* 车站编号 */ + ShortToChar(g_strAtsEaCfmSnd.wIndex, &szToGateWayDataBuf[ii]); /* 操作站编号 */ + ii += 2U; + LongToChar(g_strAtsEaCfmSnd.dwTime, &szToGateWayDataBuf[ii]); /* 时间 */ + ii += 4u; + szToGateWayDataBuf[ii++] = g_strAtsEaCfmSnd.chOpStatus; /* 确认结果 */ + LongToChar(g_strAtsEaCfmSnd.dwCrc32, &szToGateWayDataBuf[ii]); /* CRC */ + ii += 4u; + wMsgLen = (ii - wMsgLenIndex - 2u); + ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]); /* 帧长度 */ + chMsgNum++; /* 消息数量递增 */ + } + else + { + ; + } + g_strAtsEaCfmSnd.chFlag = FLAG_UNSET; + } + else + { + ; + } + + if (CI_SUCCESS == chRtn) + { + /* 组TIOC汇报给ATS的全线列车紧急制动信息 */ + szToGateWayDataBuf[ii++] = MSG_TYPE_WLB_REPORT; /* 全线列车紧急制动汇报消息 */ + wMsgLenIndex = ii; /* 记录帧长度存放下标 */ + ii += 2u; + szToGateWayDataBuf[ii++] = MSG_TYPE_WLB_REPORT; + szToGateWayDataBuf[ii++] = chLocalId; /* TIOC编号 */ + + wWlbSum = 0U; + wWlbSumIndex = ii; + ii += 2U; + + /*组全线紧急制动信息*/ + chWlbState = WlbGetState(); + if (WLB_UNSET != chWlbState) + { + wWlbSum++; + szToGateWayDataBuf[ii++] = WLB_TYPE_RC; /* 制动类型 */ + ShortToChar(wRcId, &szToGateWayDataBuf[ii]); /* RC编号 */ + ii += 2u; + } + else + { + /* 未设置，不组包 */ + } + + /*组区域紧急制动信息*/ + wPhyCurSum = GetPhySecCurSum(); + for (jj = 0U; jj < wPhyCurSum; jj++) + { + wPhySecId = GetPhySecId(jj); + cPhySecAreaUrgentState = GetPhySecAreaUrgentState(wPhySecId); + if (PHYSEC_AREA_URGENT_NO != cPhySecAreaUrgentState) + { + wWlbSum++; + szToGateWayDataBuf[ii++] = WLB_TYPE_PHYSEC; /* 制动类型 */ + ShortToChar(wPhySecId, &szToGateWayDataBuf[ii]); /* 物理区段编号 */ + ii += 2U; + } + else + { + /*不组包*/ + } + } + + ShortToChar(wWlbSum, &szToGateWayDataBuf[wWlbSumIndex]); /* 组紧急制动数量 */ + + wMsgLen = (ii - wMsgLenIndex - 2u); + ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]); /* 帧长度 */ + chMsgNum++; /* 消息数量递增 */ + } + else + { + ; + } + + if (CI_SUCCESS == chRtn) + { + if (FLAG_SET == g_strAtsWlbCfmFst.chFlag) + { + szToGateWayDataBuf[ii++] = MSG_TYPE_WLB_CONFIRM_FIRST; /* 帧类型 */ + wMsgLenIndex = ii; /* 记录帧长度存放下标 */ + ii += 2u; + szToGateWayDataBuf[ii++] = MSG_TYPE_WLB_CONFIRM_FIRST; + szToGateWayDataBuf[ii++] = chLocalId; /* TIOC编号 */ + szToGateWayDataBuf[ii++] = g_strAtsWlbCfmFst.chStation; /* 车站编号 */ + ShortToChar(g_strAtsWlbCfmFst.wIndex, &szToGateWayDataBuf[ii]); /* 操作站编号 */ + ii += 2U; + LongToChar(g_strAtsWlbCfmFst.dwTime, &szToGateWayDataBuf[ii]); /* 时间 */ + ii += 4u; + szToGateWayDataBuf[ii++] = g_strAtsWlbCfmFst.chOpStatus; /* 确认结果 */ + LongToChar(g_strAtsWlbCfmFst.dwCrc32, &szToGateWayDataBuf[ii]); /* CRC */ + ii += 4u; + wMsgLen = (ii - wMsgLenIndex - 2u); + ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]); /* 帧长度 */ + chMsgNum++; /* 消息数量递增 */ + } + else + { + ; + } + g_strAtsWlbCfmFst.chFlag = FLAG_UNSET; + } + else + { + ; + } + + if (CI_SUCCESS == chRtn) + { + /*组第二个ATS的全线紧急制动首次确认信息*/ + if (FLAG_SET == g_strSndAtsWlbCfmFst.chFlag) + { + szToGateWayDataBuf[ii] = MSG_TYPE_WLB_CONFIRM_FIRST; /* 帧类型 */ + ii++; + wMsgLenIndex = ii; /* 记录帧长度存放下标 */ + ii += 2U; + szToGateWayDataBuf[ii] = MSG_TYPE_WLB_CONFIRM_FIRST; + ii++; + szToGateWayDataBuf[ii] = chLocalId; /* TIOC编号 */ + ii++; + szToGateWayDataBuf[ii] = g_strSndAtsWlbCfmFst.chStation; /* 车站编号 */ + ii++; + ShortToChar(g_strSndAtsWlbCfmFst.wIndex, &szToGateWayDataBuf[ii]); /* 操作站编号 */ + ii += 2U; + LongToChar(g_strSndAtsWlbCfmFst.dwTime, &szToGateWayDataBuf[ii]); /* 时间 */ + ii += 4U; + szToGateWayDataBuf[ii] = g_strSndAtsWlbCfmFst.chOpStatus; /* 确认结果 */ + ii++; + LongToChar(g_strSndAtsWlbCfmFst.dwCrc32, &szToGateWayDataBuf[ii]); /* CRC */ + ii += 4U; + wMsgLen = (ii - wMsgLenIndex - 2U); + ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]); /* 帧长度 */ + chMsgNum++; /* 消息数量递增 */ + + /*组包后清除第二个ATS的确认信息*/ + ClearSndAtsWlbFstCfmMsg(); + } + else + { + ; + } + } + else + { + ; + } + + if (CI_SUCCESS == chRtn) + { + if (FLAG_SET == g_strAtsWlbCfmSnd.chFlag) + { + szToGateWayDataBuf[ii++] = MSG_TYPE_WLB_CONFIRM_SECOND; /* 帧类型 */ + wMsgLenIndex = ii; /* 记录帧长度存放下标 */ + ii += 2u; + szToGateWayDataBuf[ii++] = MSG_TYPE_WLB_CONFIRM_SECOND; + szToGateWayDataBuf[ii++] = chLocalId; /* TIOC编号 */ + szToGateWayDataBuf[ii++] = g_strAtsWlbCfmSnd.chStation; /* 车站编号 */ + ShortToChar(g_strAtsWlbCfmSnd.wIndex, &szToGateWayDataBuf[ii]); /* 操作站编号 */ + ii += 2U; + LongToChar(g_strAtsWlbCfmSnd.dwTime, &szToGateWayDataBuf[ii]); /* 时间 */ + ii += 4u; + szToGateWayDataBuf[ii++] = g_strAtsWlbCfmSnd.chOpStatus; /* 确认结果 */ + LongToChar(g_strAtsWlbCfmSnd.dwCrc32, &szToGateWayDataBuf[ii]); /* CRC */ + ii += 4u; + wMsgLen = (ii - wMsgLenIndex - 2u); + ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]); /* 帧长度 */ + chMsgNum++; /* 消息数量递增 */ + } + else + { + ; + } + g_strAtsWlbCfmSnd.chFlag = FLAG_UNSET; + } + else + { + ; + } + + if (CI_SUCCESS == chRtn) + { + /* 组TIOC汇报给ATS的脱轨防护区域信息 */ + szToGateWayDataBuf[ii++] = MSG_TYPE_DA_REPORT; /* 脱轨防护区域汇报消息 */ + wMsgLenIndex = ii; /* 记录帧长度存放下标 */ + ii += 2u; + szToGateWayDataBuf[ii++] = MSG_TYPE_DA_REPORT; + ShortToChar(GATE_WAY_APP_PRTCL_VER, &szToGateWayDataBuf[ii]); /* 应用协议版本号 */ + ii += 2u; + szToGateWayDataBuf[ii++] = chLocalId; /* TIOC编号 */ + + chEaNum = GetEaNum(); + if (EA_MAX_NUM < chEaNum) + { + chRtn = CI_ERROR; + } + else + { + chEaSendNum = 0u; + wEaNumIndex = ii; /* 记录汇报数量存储下标 */ + ii++; + + for (chEaIndex = 0u; chEaIndex < chEaNum; chEaIndex++) + { + wEaTrainid = GetEvacuatingTrainIdByIndex(chEaIndex); + chRtn = dquDevName2HlhtId(wEaTrainid, wTrainLgcId, &dwEaTrainHlhtId); + chEaLgcNum = EaGetLgcNum(chEaIndex); + pEaLgcId = EaGetLgcId(chEaIndex); + chEaBuidFlag = GetEaBuildedFlag(chEaIndex); + chEaSrcId = GetEaSrcTiocByIndex(chEaIndex); + chPaType = GetPaTypeByIndex(chEaIndex); + chEaAreaLineType = GetEaAreaLineType(chEaIndex); + + if ((NULL == pEaLgcId) || (CI_ERROR == chRtn) || (EA_SECTION_MAX_NUM < chEaLgcNum) + || ((PA_TYPE_DA != chPaType) && (PA_TYPE_EA != chPaType))) + { + chRtn = CI_ERROR; + break; + } + else + { + if ((chEaSrcId == chLocalId) && (PA_TYPE_DA == chPaType)) + { + chEaSendNum++; + LongToChar(dwEaTrainHlhtId, &szToGateWayDataBuf[ii]); /* 区间疏散列车互联互通ID */ + ii += 4u; + + szToGateWayDataBuf[ii++] = chEaAreaLineType; /* 上下行区域 */ + + szToGateWayDataBuf[ii++] = chEaLgcNum; /* 逻辑区段数量 */ + for (chEaLgcIndex = 0u; chEaLgcIndex < chEaLgcNum; chEaLgcIndex++) + { + ShortToChar(pEaLgcId[chEaLgcIndex], &szToGateWayDataBuf[ii]); + ii += 2u; + } + } + else + { + ; /* 本控区非建立控区，不汇报给ATS */ + } + } + } + + szToGateWayDataBuf[wEaNumIndex] = chEaSendNum; /* 组汇报数量 */ + + wMsgLen = (ii - wMsgLenIndex - 2u); + ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]); /* 帧长度 */ + chMsgNum++; /* 消息数量递增 */ + } + } + else + { + ; + } + + if (CI_SUCCESS == chRtn) + { + if (FLAG_SET == g_strAtsDaCfmFst.chFlag) + { + szToGateWayDataBuf[ii++] = MSG_TYPE_DA_CONFIRM_FIRST; /* 帧类型 */ + wMsgLenIndex = ii; /* 记录帧长度存放下标 */ + ii += 2u; + szToGateWayDataBuf[ii++] = MSG_TYPE_DA_CONFIRM_FIRST; + szToGateWayDataBuf[ii++] = chLocalId; /* TIOC编号 */ + szToGateWayDataBuf[ii++] = g_strAtsDaCfmFst.chStation; /* 车站编号 */ + ShortToChar(g_strAtsDaCfmFst.wIndex, &szToGateWayDataBuf[ii]); /* 操作站编号 */ + ii += 2U; + LongToChar(g_strAtsDaCfmFst.dwTime, &szToGateWayDataBuf[ii]); /* 时间 */ + ii += 4u; + szToGateWayDataBuf[ii++] = g_strAtsDaCfmFst.chOpStatus; /* 确认结果 */ + LongToChar(g_strAtsDaCfmFst.dwCrc32, &szToGateWayDataBuf[ii]); /* CRC */ + ii += 4u; + wMsgLen = (ii - wMsgLenIndex - 2u); + ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]); /* 帧长度 */ + chMsgNum++; /* 消息数量递增 */ + } + else + { + ; + } + g_strAtsDaCfmFst.chFlag = FLAG_UNSET; + } + else + { + ; + } + + if (CI_SUCCESS == chRtn) + { + /*组第二个ATS的取消防护区域首次确认信息*/ + if (FLAG_SET == g_strSndAtsDaCfmFst.chFlag) + { + szToGateWayDataBuf[ii] = MSG_TYPE_DA_CONFIRM_FIRST; /* 帧类型 */ + ii++; + wMsgLenIndex = ii; /* 记录帧长度存放下标 */ + ii += 2U; + szToGateWayDataBuf[ii] = MSG_TYPE_DA_CONFIRM_FIRST; + ii++; + szToGateWayDataBuf[ii] = chLocalId; /* TIOC编号 */ + ii++; + szToGateWayDataBuf[ii] = g_strSndAtsDaCfmFst.chStation; /* 车站编号 */ + ii++; + ShortToChar(g_strSndAtsDaCfmFst.wIndex, &szToGateWayDataBuf[ii]); /* 操作站编号 */ + ii += 2U; + LongToChar(g_strSndAtsDaCfmFst.dwTime, &szToGateWayDataBuf[ii]); /* 时间 */ + ii += 4U; + szToGateWayDataBuf[ii] = g_strSndAtsDaCfmFst.chOpStatus; /* 确认结果 */ + ii++; + LongToChar(g_strSndAtsDaCfmFst.dwCrc32, &szToGateWayDataBuf[ii]); /* CRC */ + ii += 4U; + wMsgLen = (ii - wMsgLenIndex - 2U); + ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]); /* 帧长度 */ + chMsgNum++; /* 消息数量递增 */ + + /*组包后清除第二个ATS的确认信息*/ + ClearSndAtsDaFstCfmMsg(); + } + else + { + ; + } + } + else + { + ; + } + + if (CI_SUCCESS == chRtn) + { + if (FLAG_SET == g_strAtsDaCfmSnd.chFlag) + { + szToGateWayDataBuf[ii++] = MSG_TYPE_DA_CONFIRM_SECOND; /* 帧类型 */ + wMsgLenIndex = ii; /* 记录帧长度存放下标 */ + ii += 2u; + szToGateWayDataBuf[ii++] = MSG_TYPE_DA_CONFIRM_SECOND; + szToGateWayDataBuf[ii++] = chLocalId; /* TIOC编号 */ + szToGateWayDataBuf[ii++] = g_strAtsDaCfmSnd.chStation; /* 车站编号 */ + ShortToChar(g_strAtsDaCfmSnd.wIndex, &szToGateWayDataBuf[ii]); /* 操作站编号 */ + ii += 2U; + LongToChar(g_strAtsDaCfmSnd.dwTime, &szToGateWayDataBuf[ii]); /* 时间 */ + ii += 4u; + szToGateWayDataBuf[ii++] = g_strAtsDaCfmSnd.chOpStatus; /* 确认结果 */ + LongToChar(g_strAtsDaCfmSnd.dwCrc32, &szToGateWayDataBuf[ii]); /* CRC */ + ii += 4u; + wMsgLen = (ii - wMsgLenIndex - 2u); + ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]); /* 帧长度 */ + chMsgNum++; /* 消息数量递增 */ + } + else + { + ; + } + g_strAtsDaCfmSnd.chFlag = FLAG_UNSET; + } + else + { + ; + } + + if (CI_SUCCESS == chRtn) + { + /* 组TIOC汇报给ATS的列车信息 */ + rrm_GetInfToATSUCTInfo(&strTrainInfo); + szToGateWayDataBuf[ii++] = MSG_TYPE_TRIAN_INFO_REPORT; /* 汇报远程筛选列车信息帧 */ + wMsgLenIndex = ii; /* 记录帧长度存放下标 */ + ii += 2u; + szToGateWayDataBuf[ii++] = MSG_TYPE_TRIAN_INFO_REPORT; + ShortToChar(GATE_WAY_APP_PRTCL_VER, &szToGateWayDataBuf[ii]); /* 应用协议版本号 */ + ii += 2u; + szToGateWayDataBuf[ii++] = chLocalId; /* TIOC编号 */ + szToGateWayDataBuf[ii++] = strTrainInfo.trainCnt; /* 列车数量 */ + for (chTrainIndex = 0u; chTrainIndex < strTrainInfo.trainCnt; chTrainIndex++) + { + (void)dquDevName2HlhtId(strTrainInfo.TrainID[chTrainIndex], wTrainLgcId, &dwTrainId); + LongToChar(dwTrainId, &szToGateWayDataBuf[ii]); /* 列车互联互通ID */ + ii += 4u; + + ShortToChar(strTrainInfo.TailSecID[chTrainIndex], &szToGateWayDataBuf[ii]); /* 列车车尾所处逻辑区段 */ + ii += 2u; + } + wMsgLen = (ii - wMsgLenIndex - 2u); + ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]); /* 帧长度 */ + chMsgNum++; /* 消息数量递增 */ + } + else + { + ; + } } else { - ; + /*组飞车宕机信息*/ + szToGateWayDataBuf[ii++] = MSG_TYPE_TRAIN_FLY_INFO; /* 帧类型 */ + wMsgLenIndex = ii; /* 记录帧长度存放下标 */ + ii += 2u; + szToGateWayDataBuf[ii++] = MSG_TYPE_TRAIN_FLY_INFO; + + ShortToChar(GATE_WAY_APP_PRTCL_VER, &szToGateWayDataBuf[ii]); /* 应用协议版本号 */ + ii += 2u; + szToGateWayDataBuf[ii++] = chLocalId; /* TIOC编号 */ + + FlyProtectTrainNum = GetFlyProtectNum(); + if (SHUT_DOWN_TRAIN_NUMMAX < FlyProtectTrainNum) + { + chRtn = CI_ERROR; + } + else + { + szToGateWayDataBuf[ii++] = FlyProtectTrainNum; /*组飞车列车数量*/ + for (chIndex = 0U; chIndex < FlyProtectTrainNum; chIndex++) + { + pFlyData = GetFlyProtectData(chIndex); + wTrainId = pFlyData->wTrainId; + TrainFlyAxis = pFlyData->flyProtectSecCnt; + chRtn = dquDevName2HlhtId((UINT16)(CI_SYSTEM_TYPE_IVOC * 256U) + wTrainId, 0U, &dwTrainId); /*两字节列车ID转换为4字节互联互通ID*/ + if (chRtn == CI_SUCCESS) + {/*互联互通ID查询成功*/ + LongToChar(dwTrainId, &szToGateWayDataBuf[ii]); /* 列车ID */ + ii += 4u; + /** 获取通信车对应的包络id */ + + if (TRAIN_FLYALARM_SECNUM_MAX < TrainFlyAxis) + { + chRtn = CI_ERROR; + } + else + { + szToGateWayDataBuf[ii++] = TrainFlyAxis; /* 计轴数量 */ + /* 获取计轴 id*/ + for (jj = 0U; jj < TrainFlyAxis; jj++) + { + wPhySecId = pFlyData->flyProtectSec[jj]; + ShortToChar(wPhySecId, &szToGateWayDataBuf[ii]); + ii += 2u; + } + } + + } + else + { /*组包失败*/ + chRtn = CI_ERROR; + } + } + wMsgLen = (ii - wMsgLenIndex - 2u); + ShortToChar(wMsgLen, &szToGateWayDataBuf[wMsgLenIndex]); /* 帧长度 */ + } + + if (CI_SUCCESS == chRtn) + { + debug_infor_printf((char*)"\n GATEWAY_FLY_SHUT_DOWN \n"); + chMsgNum = 1U; + } + } + if (CI_SUCCESS == chRtn) + { + /* 组包成功，填入消息数量 */ + szToGateWayDataBuf[wMsgNumIndex] = chMsgNum; + *wDataIndex = ii; } } else { ; } - + return chRtn; } @@ -2813,4 +2809,580 @@ void ClearSndAtsWlbFstCfmMsg(void) void ClearSndAtsDaFstCfmMsg(void) { (void)CommonMemSet((void*)&g_strSndAtsDaCfmFst, (UINT32)sizeof(AtsMsgCfmStru), (UINT8)0U, (UINT32)sizeof(AtsMsgCfmStru)); +} + +/** +* @brief 解析网关数据帧--按照接口类型区分有无GAL +* @param const UINT8* dataBuf, 数据缓冲区 +* @param const UINT16 dataLength, 数据长度 +* @return CI_SUCCESS:成功；CI_ERROR:失败 +* @note Created By fan 20260604 +*/ +UINT8 ParseGateWayToCiDataProc(const UINT8* dataBuf, const UINT16 dataLength) +{ + UINT8 chAtsInterfaceType = 0U; /*ATS接口类型*/ + UINT8 chGalHeadSaved = 0u; /*通用头是否已保存标志，1保存；0未保存*/ + UINT16 ii = 0U; /*数据索引*/ + UINT8 chRetVal = CI_ERROR; + HLHTGALInfoStruct hlhtGalHead = { 0U }; /*互联互通报文头*/ + UINT8 chHeadReval = CI_ERROR; /*互联互通报文头检查结果*/ + UINT16 wTiocRcvAtsGtwyDevTypeId = 0U; + UINT8 chLocalCiId = GetSystemParaLocalCiId();/*联锁ID*/ + UINT16 wRemoteDevName = 0U; /*对方设备信息*/ + UINT32 dwErrCode = 0U; /*通用报文头错误码记录*/ + UINT32 dwCurCycNum = Get2oo2CurCycleNum(); /*当前周期号*/ + UINT32 dwCiAndAtsTimeOutTime = 0u; /*联锁与ATS通信中断时间*/ + INT32 remainValidiy = 0; /*剩余时间是否有效*/ + UINT32 dwCiCurappCycleTime = 0u; /*联锁当前周期*/ + UINT16 wMsgLen = 0U; /*一条应用数据长度*/ + UINT16 wTmpDataLen = 0U; /*数据长度临时记录变量*/ + UINT16 wMsgType = 0U; /*报文类型*/ + UINT16 wMsgCheckLen = 0U; /* 单帧数据长度*/ + UINT8 chCurSystemAreaState = 0U; /*当前系统区域状态*/ + UINT32 dwReciveCmdDataAtsCycNum = 0U; /*收到ATS命令数据时ATS周期号*/ + UINT32 dwSystemUpdateMainUseCycNum = 0U; /*系统主用起始周期号*/ + UINT8 chExistCmdDataFlag = 0U; /*存在命令数据标志*/ + UINT8 chDeciveId = 0U; /*网关ID*/ + AtsFollowUpCmdFstStru tempFstCmd[FOLLOWUP_MSGID_MAX] = { 0U };/*一次命令临时存储*/ + AtsFollowUpCmdSndStru tempSndCmd[FOLLOWUP_MSGID_MAX] = { 0U };/*二次命令临时存储*/ + UINT16 wIndex = 0U;/*临时信息存储索引*/ + UINT16 wMsgTypeTmp = 0U;/*拷贝回全局变量的信息类型*/ + AtsFollowUpCmdFstStru *pGlobalFst = NULL; + AtsFollowUpCmdSndStru *pGlobalSnd = NULL; + wTiocRcvAtsGtwyDevTypeId = GetTiocTrnsmtGtwyDevTypeId(); + chDeciveId =(UINT8)(wTiocRcvAtsGtwyDevTypeId & 0x00FFU); + if ((NULL != dataBuf) && (0u < dataLength)) + { + chAtsInterfaceType = GetCiFunctionSwitchConfig(FUNC_GATEWAY_INTERFACE_IDENTIFIER); + + if (ATS_INTERFACE_EXIST_GAL != chAtsInterfaceType) + { + /*旧数据结构只有命令信息*/ + chRetVal = ParseGateWayToCiDataFrame(dataBuf, &ii, dataLength); + } + else + { + /*新数据结构存在GAL报文头，且存在心跳帧或命令信息帧*/ + /*解析通用消息包头*/ + hlhtGalHead.devInterInfoType = ShortFromChar(&dataBuf[ii]); + ii += 2U; + hlhtGalHead.sourceId = LongFromChar(&dataBuf[ii]); + ii += 4U; + hlhtGalHead.destId = LongFromChar(&dataBuf[ii]); + ii += 4U; + hlhtGalHead.emapVerCrc = LongFromChar(&dataBuf[ii]); + ii += 4U; + hlhtGalHead.crntOwnMsgSN = LongFromChar(&dataBuf[ii]); + ii += 4U; + hlhtGalHead.comPeriod = ShortFromChar(&dataBuf[ii]); + ii += 2U; + hlhtGalHead.recvOppMsgSN = LongFromChar(&dataBuf[ii]); + ii += 4U; + hlhtGalHead.preOwnMsgSN = LongFromChar(&dataBuf[ii]); + ii += 4U; + hlhtGalHead.prtclVer = dataBuf[ii++]; + hlhtGalHead.totalDataLen = ShortFromChar(&dataBuf[ii]); + ii += 2U; + + wRemoteDevName = (CI_SYSTEM_TYPE_RCI)* 256U + chLocalCiId; + chHeadReval = HLHTRecvCommonPacketHeadCheck(wTiocRcvAtsGtwyDevTypeId, wRemoteDevName, ATS_CI_INTERFACE_INFOTYPE, 1U, &hlhtGalHead, &dwErrCode, 0U, CI_SYSTEM_TYPE_ATS); + + debug_infor_printf((char*)"\nGateWay%#x GAL Check Result:%d errCode:%d\n", wTiocRcvAtsGtwyDevTypeId, chHeadReval, dwErrCode); /*0x55正确，0xaa错误，0x33初始通信帧*/ + + if (HLHT_HEAD_SUCCESS == chHeadReval) + { + dwCiAndAtsTimeOutTime = GetCiAndAtsTransBadEnsureTime(); + dwCiCurappCycleTime = GetSystemParaAppCycleTime(); + /*计算消息的时效性*/ + remainValidiy = HLHTCommonMsgRemainingValidity(dwCiAndAtsTimeOutTime, dwCurCycNum, dwCiCurappCycleTime, hlhtGalHead.recvOppMsgSN, hlhtGalHead.crntOwnMsgSN, hlhtGalHead.preOwnMsgSN, hlhtGalHead.comPeriod); + + if (remainValidiy > 0) + { + /*解析应用数据*/ + if (0u == hlhtGalHead.totalDataLen) + { + /* 仅有GAL头信息 */ + chRetVal = CI_ERROR; + } + else if (6u > hlhtGalHead.totalDataLen) + { + /* 数据长度错误,返回失败 */ + chRetVal = CI_ERROR; + } + else + { + chRetVal = CI_SUCCESS; + /*先获取上一周期是存储进路办理命令数*/ + while (wTmpDataLen < hlhtGalHead.totalDataLen) + { + /* 一条应用数据长度 */ + wMsgLen = ShortFromChar(&dataBuf[ii]); + ii += 2u; + wTmpDataLen += 2U; + wTmpDataLen += wMsgLen; + if (0u == wMsgLen) + { + ; /* 无处理，继续解析下一包 */ + } + else + { + /* 获取报文类型 */ + wMsgType = ShortFromChar(&dataBuf[ii]); + ii += 2u; + + /* 跳过预留 */ + ii += 2u; + wMsgCheckLen = wMsgLen - 4u; + switch (wMsgType) + { + case ATS_CI_INFO_TYPE_HEART_STATE: + /* 解析心跳信息 */ + ii += wMsgCheckLen; + break; + case ATS_CI_INFO_TYPE_GATEWAY_COMMON: + /* 解析既有信息 */ + chRetVal = ParseGateWayToCiDataFrame(dataBuf, &ii, wMsgCheckLen); + chExistCmdDataFlag = 1U; /*先设置存在命令数据标志有效，数据解析不过在下面置为无效*/ + break; + case ATS_CI_INFO_FST_DS_CANCEL: + case ATS_CI_INFO_FST_SWIUNFLOCK: + case ATS_CI_INFO_FST_FAULTUNLOCK: + case ATS_CI_INFO_FST_SECUNFLOCK: + case ATS_CI_INFO_FST_SIGUNFLOCK: + case ATS_CI_INFO_FST_ZONGRENJIE: + case ATS_CI_INFO_FST_PSD_UNEXCEPT: + chCurSystemAreaState = GetLocalCiBackUpPattern(); + if (SYSTEM_WORK_MODE_MAIN == chCurSystemAreaState) + { + /*主用解析操作命令，必须检查当前该包数据是否已经处理过*/ + dwReciveCmdDataAtsCycNum = GetReciveCmdDataAtsCycNum(CI_SYSTEM_TYPE_ATS, chDeciveId); + dwSystemUpdateMainUseCycNum = GetSystemUpdateMainUseCycNum(); + + if ((dwReciveCmdDataAtsCycNum < hlhtGalHead.crntOwnMsgSN) || + (dwSystemUpdateMainUseCycNum <= hlhtGalHead.recvOppMsgSN)) + { + /*当前ATS发送数据时的周期号大于接收到ATS数据时ATS周期号 + 或当前ATS发送数据时的联锁周期号大于等于当前系统升级主用起始周期号*/ + wIndex = (wMsgType - ATS_CI_INFO_FST_DS_CANCEL) / 4; + if ((FOLLOWUP_MSGID_MAX > wIndex) && (ATS_CI_INFO_TYPE_FIRST_LEN == wMsgCheckLen)) + { + chRetVal = ProcessCmdFirstMsgCheck(dataBuf, ii, &tempFstCmd[wIndex]); + ii += ATS_CI_INFO_TYPE_FIRST_LEN; + chExistCmdDataFlag = 1U; /*先设置存在命令数据标志有效，数据解析不过在下面置为无效*/ + } + else + { + chRetVal = CI_ERROR;/*越界防护*/ + } + + } + else + { + ii += wMsgCheckLen; + /*已经被另外一机处理过了*/ + debug_infor_printf((char*)"\nATS/Xiandi %d Not Deal FstCmd%d,Because curCmd has been processed by another System,dwReciveCmdDataAtsCycNum %d dwSystemUpdateMainUseCycNum %d\n", chDeciveId, wMsgType, dwReciveCmdDataAtsCycNum, dwSystemUpdateMainUseCycNum); + } + } + break; + case ATS_CI_INFO_SND_DS_CANCEL: + case ATS_CI_INFO_SND_SWIUNFLOCK: + case ATS_CI_INFO_SND_FAULTUNLOCK: + case ATS_CI_INFO_SND_SECUNFLOCK: + case ATS_CI_INFO_SND_SIGUNFLOCK: + case ATS_CI_INFO_TYPE_SND_ZRJ: + case ATS_CI_INFO_SND_PSD_UNEXCEPT: + chCurSystemAreaState = GetLocalCiBackUpPattern(); + if (SYSTEM_WORK_MODE_MAIN == chCurSystemAreaState) + { + /*主用解析操作命令，必须检查当前该包数据是否已经处理过*/ + dwReciveCmdDataAtsCycNum = GetReciveCmdDataAtsCycNum(CI_SYSTEM_TYPE_ATS, chDeciveId); + dwSystemUpdateMainUseCycNum = GetSystemUpdateMainUseCycNum(); + + if ((dwReciveCmdDataAtsCycNum < hlhtGalHead.crntOwnMsgSN) || + (dwSystemUpdateMainUseCycNum <= hlhtGalHead.recvOppMsgSN)) + { + wIndex = (wMsgType - ATS_CI_INFO_SND_DS_CANCEL) / 4; + if ((FOLLOWUP_MSGID_MAX > wIndex) && (ATS_CI_INFO_TYPE_SND_LEN == wMsgCheckLen)) + { + chRetVal = ProcessCmdSndMsgCheck(dataBuf, ii, &tempSndCmd[wIndex]); + ii += ATS_CI_INFO_TYPE_SND_LEN; + chExistCmdDataFlag = 1U; /*先设置存在命令数据标志有效，数据解析不过在下面置为无效*/ + } + else + { + chRetVal = CI_ERROR;/*越界防护*/ + } + } + else + { + ii += wMsgCheckLen; + /*已经被另外一机处理过了*/ + debug_infor_printf((char*)"\nATS/Xiandi %d Not Deal SndCmd%d,Because curCmd has been processed by another System,dwReciveCmdDataAtsCycNum %d dwSystemUpdateMainUseCycNum %d\n", chDeciveId, wMsgType, dwReciveCmdDataAtsCycNum, dwSystemUpdateMainUseCycNum); + } + } + break; + default: + chRetVal = CI_ERROR; + break; + } + } + if (CI_ERROR == chRetVal) + { + chExistCmdDataFlag = 0U; + break; + } + else + { + ; /*do nothing*/ + } + } + } + + /*校验数据长度*/ + if ((hlhtGalHead.totalDataLen != ii - (UINT16)31U) || (dataLength != hlhtGalHead.totalDataLen + (UINT16)31U)) + { + /* 31为应用数据帧头长度 */ + chRetVal = CI_ERROR; + debug_infor_printf((char*)"ParseGateWayToCiDataProc HlhtGal Length Error\n"); + } + + if (CI_SUCCESS != chRetVal) + { + /*清除本次存储的命令信息*/ + ClearCurGateWayMsg(); + } + else + { + /*将临时一二次信息拷贝到全局变量*/ + for (wIndex = 0U; wIndex < FOLLOWUP_MSGID_MAX; wIndex++) + { + if (FLAG_SET == tempFstCmd[wIndex].chFlag) + { + wMsgTypeTmp = ATS_CI_INFO_FST_DS_CANCEL + wIndex*(UINT16)4U; + pGlobalFst = GetAtsFollowUpMsgFst(wMsgTypeTmp); + if (NULL != pGlobalFst) + { + (void)CommonMemCpy((void *)(pGlobalFst), (UINT32)sizeof(AtsFollowUpCmdFstStru), (const void *)(&tempFstCmd[wIndex]), (UINT32)sizeof(AtsFollowUpCmdFstStru)); + } + } + if (FLAG_SET == tempSndCmd[wIndex].chFlag) + { + wMsgTypeTmp = ATS_CI_INFO_SND_DS_CANCEL + wIndex*(UINT16)4U; + pGlobalSnd = GetAtsFollowUpMsgSnd(wMsgTypeTmp); + if (NULL != pGlobalSnd) + { + (void)CommonMemCpy((void *)(pGlobalSnd), (UINT32)sizeof(AtsFollowUpCmdSndStru), (const void *)(&tempSndCmd[wIndex]), (UINT32)sizeof(AtsFollowUpCmdSndStru)); + } + } + } + } + + if (CI_SUCCESS == chRetVal) + { + /*数据经过校验，需要存储通用报文上下文*/ + SetHLHTHeadCtxComPeriod(CI_SYSTEM_TYPE_ATS, chDeciveId, hlhtGalHead.comPeriod); + SetHLHTHeadCtxSrcCrntSN(CI_SYSTEM_TYPE_ATS, chDeciveId, hlhtGalHead.crntOwnMsgSN); + SetHLHTHeadCtxSrcOppSN(CI_SYSTEM_TYPE_ATS, chDeciveId, hlhtGalHead.recvOppMsgSN); + SetHLHTHeadCtxSrcOwnSN(CI_SYSTEM_TYPE_ATS, chDeciveId, hlhtGalHead.preOwnMsgSN); + SetHLHTHeadCtxCiRcvSN(CI_SYSTEM_TYPE_ATS, chDeciveId, dwCurCycNum); + SetHLHTHeadCtxCiRcvLogId(CI_SYSTEM_TYPE_ATS, chDeciveId, 0U); + + chGalHeadSaved = 1U; + + if (1U == chExistCmdDataFlag) + { + UpdateAtsCmdDataCycInfo(CI_SYSTEM_TYPE_ATS, chDeciveId); + } + else + { + ; /*不更新最近一次收到ATS命令数据周期号*/ + } + } + else + { + ; + } + } + else + { + chRetVal = CI_ERROR; + } + } + else if (HLHT_HEAD_INIT == chHeadReval) + { + if (dwCurCycNum > 0U)/*判断序号大于0，因为把0当做无效序号*/ + { + SetHLHTHeadCtxComPeriod(CI_SYSTEM_TYPE_ATS, chDeciveId, hlhtGalHead.comPeriod); + SetHLHTHeadCtxSrcCrntSN(CI_SYSTEM_TYPE_ATS, chDeciveId, hlhtGalHead.crntOwnMsgSN); + SetHLHTHeadCtxSrcOppSN(CI_SYSTEM_TYPE_ATS, chDeciveId, hlhtGalHead.recvOppMsgSN); + SetHLHTHeadCtxSrcOwnSN(CI_SYSTEM_TYPE_ATS, chDeciveId, hlhtGalHead.preOwnMsgSN); + SetHLHTHeadCtxCiRcvSN(CI_SYSTEM_TYPE_ATS, chDeciveId, dwCurCycNum); + SetHLHTHeadCtxCiRcvLogId(CI_SYSTEM_TYPE_ATS, chDeciveId, 0U); + + chGalHeadSaved = 1U; + } + + chRetVal = CI_ERROR; + } + else + { + /*记录校验失败信息*/ + if (GAL_COMPARE_INFO_TYPE_ERR == (dwErrCode & GAL_COMPARE_INFO_TYPE_ERR)) + { + /*记录接口信息类型错误*/ + SetErrorData(EFUNC_PARSE_GATEWAY2CI_DATA, CI_SYSTEM_TYPE_ATS, wTiocRcvAtsGtwyDevTypeId, ETYPE_COMM_WITH_GATEWAY, CI_BACK_DATA_INFO_TYPE_ERR, ESEND_LEVEL_ZERO); + } + else if (GAL_COMPARE_SEND_FLAG_ERR == (dwErrCode & GAL_COMPARE_SEND_FLAG_ERR)) + { + /*发送方标识信息错误*/ + SetErrorData(EFUNC_PARSE_GATEWAY2CI_DATA, CI_SYSTEM_TYPE_ATS, wTiocRcvAtsGtwyDevTypeId, ETYPE_COMM_WITH_GATEWAY, CI_BACK_DATA_SEND_FLAG_ERR, ESEND_LEVEL_ZERO); + } + else if (GAL_COMPARE_RECV_FLAG_ERR == (dwErrCode & GAL_COMPARE_RECV_FLAG_ERR)) + { + /*数据接收方标志信息错误*/ + SetErrorData(EFUNC_PARSE_GATEWAY2CI_DATA, CI_SYSTEM_TYPE_ATS, wTiocRcvAtsGtwyDevTypeId, ETYPE_COMM_WITH_GATEWAY, CI_BACK_DATA_RECV_FLAG_ERR, ESEND_LEVEL_ZERO); + } + else if (GAL_COMPARE_EMAP_VER_COMP_ERR == (dwErrCode & GAL_COMPARE_EMAP_VER_COMP_ERR)) + { + /*数据版本校验失败信息*/ + SetErrorData(EFUNC_PARSE_GATEWAY2CI_DATA, CI_SYSTEM_TYPE_ATS, wTiocRcvAtsGtwyDevTypeId, ETYPE_COMM_WITH_GATEWAY, CI_BACK_DATA_VER_CHECK_FAIL, ESEND_LEVEL_ATS); + } + else if (GAL_COMPARE_PROTOCOL_VER_ERR == (dwErrCode & GAL_COMPARE_PROTOCOL_VER_ERR)) + { + /*数据协议版本号错误*/ + SetErrorData(EFUNC_PARSE_GATEWAY2CI_DATA, CI_SYSTEM_TYPE_ATS, wTiocRcvAtsGtwyDevTypeId, ETYPE_COMM_WITH_GATEWAY, CI_BACK_DATA_PROTOCOL_VER_ERR, ESEND_LEVEL_ZERO); + } + else if (GAL_COMPARE_MSG_BDS_SN_ERR == (dwErrCode & GAL_COMPARE_MSG_BDS_SN_ERR)) + { + /*双方序列号错误*/ + SetErrorData(EFUNC_PARSE_GATEWAY2CI_DATA, CI_SYSTEM_TYPE_ATS, wTiocRcvAtsGtwyDevTypeId, ETYPE_COMM_WITH_GATEWAY, CI_BACK_DATA_MSG_BDS_SN_ERR, ESEND_LEVEL_ZERO); + } + else if (GAL_COMPARE_APP_LEN_ERR == (dwErrCode & GAL_COMPARE_APP_LEN_ERR)) + { + /*应用层数据长度无效*/ + SetErrorData(EFUNC_PARSE_GATEWAY2CI_DATA, CI_SYSTEM_TYPE_ATS, wTiocRcvAtsGtwyDevTypeId, ETYPE_COMM_WITH_GATEWAY, CI_BACK_DATA_APP_LEN_ERR, ESEND_LEVEL_ZERO); + } + else + { + /*记录通信故障码*/ + SetErrorData(EFUNC_PARSE_GATEWAY2CI_DATA, CI_SYSTEM_TYPE_ATS, wTiocRcvAtsGtwyDevTypeId, ETYPE_COMM_WITH_GATEWAY, CI_ERROR, ESEND_LEVEL_ZERO); + } + chRetVal = CI_ERROR; + } + } + + if ((CI_ERROR == chRetVal) && (0u == chGalHeadSaved)) + { + /*如果通用头已经保存了，则不执行清除通用头操作，否则，出错后也将清除通用头*/ + ClearHlhtHeadCtx(CI_SYSTEM_TYPE_ATS, chDeciveId); + } + else + { + ; /*do nothing*/ + } + } + else + { + /*数据无效*/ + chRetVal = CI_ERROR; + } + return chRetVal; +} + +/* +* 功能描述： 组网关数据-按照接口类型区分有无GAL +* 参数说明： QueueStruct* ciToAtsDataQueue, 组包发送队列地址 +* const UINT8 deviceId, 目标系统ID +* const UINT8 targetDevType, 目标系统类型 +* const UINT8 frame,帧类型 +* UINT8* chSendXiandiorAtsBuf 码位数据数组首地址 +* 返回值 ： 0: 组包失败 +* 1: 组包成功 +* fan 20260604 +*/ +UINT8 PackCiToGateWayDataProc(const UINT8 deviceId, const UINT8 targetDevType) +{ + UINT8 ciToGateWayBuffer[CI_TO_ATS_DATA_LEN_MAX] = { 0u }; + UINT16 ii = 0u; + UINT8 chReval = CI_ERROR; + UINT8 chAtsInterfaceType = 0U; /*ATS接口类型*/ + UINT8 chLocalCiId = GetSystemParaLocalCiId(); /*本地联锁ID*/ + UINT32 dwCiEtcsId = 0U; /*联锁互联互通ID*/ + UINT32 dwAtsEtcsId = 0U; /*ATS互联互通ID*/ + UINT32 dwEmapCheckVer = 0U; /*电子地图校验版本号*/ + UINT32 dwHlhtHSrcSN = 0U; /*向CI发送数据的一方发送报文时当前的SN*/ + UINT32 dwHlhtHRcvSN = 0U; /*CI接收到数据时本身的SN*/ + UINT32 dwCurCycleNum = Get2oo2CurCycleNum(); /*联锁应用周期号*/ + UINT32 dwAppCycleTime = GetSystemParaAppCycleTime(); /*联锁应用周期*/ + UINT16 wAppDataLenIndex = 0U; /* 应用数据长度位置 */ + UINT16 wAppDataLen = 0u; /* 应用数据长度 */ + UINT16 wMagLen = 0u; /* 单包数据长度 */ + UINT16 wMagDataLenIndex = 0U; /* 消息数据长度位置 */ + UINT16 dstDevId = 0u; + UINT8 chCurSystemAreaState = GetLocalCiBackUpPattern(); /*当前系统区域状态*/ + UINT32 dwFlyProtectOverCyc = GetFlyProtectOverCyc(); /*飞车*/ + chAtsInterfaceType = GetCiFunctionSwitchConfig(FUNC_GATEWAY_INTERFACE_IDENTIFIER); + if (ATS_INTERFACE_EXIST_GAL != chAtsInterfaceType) + { + /*旧数据结构运行无需GAL报文头*/ + chReval = PackTiocToGateWayData(ciToGateWayBuffer, targetDevType, &ii); + + } + else + { + /*新数据结构运行需要GAL报文头*/ + /*首先获取组包时所需的信息，获取成功才继续组包*/ + /*先用设备ID,后续可能用互联互通ID*/ + dwCiEtcsId = (UINT32)(CI_SYSTEM_TYPE_RCI * 256U + chLocalCiId); + dwAtsEtcsId = (UINT32)(targetDevType * 256U + deviceId); + chReval = GetCiEmapCheckVer(chLocalCiId, &dwEmapCheckVer, targetDevType); + dwHlhtHSrcSN = GetHLHTHeadCtxSrcCrntSN(targetDevType, deviceId); + dwHlhtHRcvSN = GetHLHTHeadCtxCiRcvSN(targetDevType, deviceId); + + if (CI_SUCCESS == chReval) + { + /*组GAL包头*/ + ShortToChar(ATS_CI_INTERFACE_INFOTYPE, &ciToGateWayBuffer[ii]);/*接口信息类型*/ + ii += 2u; + LongToChar(dwCiEtcsId, &ciToGateWayBuffer[ii]);/*发送方标识信息*/ + ii += 4u; + LongToChar(dwAtsEtcsId, &ciToGateWayBuffer[ii]);/*接收方标识信息*/ + ii += 4u; + LongToChar(dwEmapCheckVer, &ciToGateWayBuffer[ii]);/*电子地图版本校验信息*/ + ii += 4u; + LongToChar(dwCurCycleNum, &ciToGateWayBuffer[ii]);/*本方消息序列号*/ + ii += 4u; + ShortToChar((UINT16)dwAppCycleTime, &ciToGateWayBuffer[ii]);/*设备通讯周期*/ + ii += 2u; + LongToChar(dwHlhtHSrcSN, &ciToGateWayBuffer[ii]);/*对方消息序列号：recvOppMsgSN记录收到对方上一条消息中的对方消息序列号*/ + ii += 4u; + LongToChar(dwHlhtHRcvSN, &ciToGateWayBuffer[ii]);/*收到上一条消息时本方序列号*/ + ii += 4u; + + ciToGateWayBuffer[ii++] = 1U; /*CI_ATS接口协议版本号*/ + /*应用层数据长度*/ + wAppDataLenIndex = ii; + ii += 2u; + + wMagDataLenIndex = ii; + ii += 2U; + if (RC_WORK_MODE_CI == CI_SYSTEM_TYPE_RCI) + { + ShortToChar(RCI_ATS_INFO_TYPE_GATEWAY_HEART, &ciToGateWayBuffer[ii]);/* 报文类型 */ + ii += 2u; + /* 预留2字节 */ + ii += 2u; + } + else + { + ShortToChar(ATS_CI_INFO_TYPE_GATEWAY_COMMON, &ciToGateWayBuffer[ii]);/* 报文类型 */ + ii += 2u; + /* 预留2字节 */ + ii += 2u; + + chReval = PackTiocToGateWayData(ciToGateWayBuffer, targetDevType, &ii); + } + wMagLen = ii - wMagDataLenIndex - 2U; + /* 组数据长度 */ + ShortToChar(wMagLen, &ciToGateWayBuffer[wMagDataLenIndex]); + /*进行一次、二次回复单独信息帧组包*/ + /*主用模式、未飞车*/ + if ((CI_SUCCESS == chReval)&& (SYSTEM_WORK_MODE_MAIN == chCurSystemAreaState)&& ( 0U == dwFlyProtectOverCyc)) + { + chReval = PackCiToAtsFollowUpMsg(ciToGateWayBuffer, &ii, targetDevType, PACK_ATS_TYPE_GATEWAY); + } + } + + /* 填充数据长度 */ + if (CI_SUCCESS == chReval) + { + wAppDataLen = ii - wAppDataLenIndex - 2U; + ShortToChar(wAppDataLen, &ciToGateWayBuffer[wAppDataLenIndex]); + } + else + { + ; + } + } + if ((ii > CI_TO_ATS_DATA_LEN_MAX) || (CI_ERROR == chReval)) + { + chReval = CI_ERROR; + } + else + { + /* 向外发送 */ + dstDevId = ((UINT16)((UINT16)targetDevType << 8u) | ((UINT16)deviceId)); + chReval = OutnetSafeSend(dstDevId, 0u, &ciToGateWayBuffer[0], ii); + if (CI_SUCCESS == chReval) + { + debug_infor_printf((char*)"\nGATEWAY_SEND:%d", ii); + debug_out_array(0xAA, ciToGateWayBuffer, ii); + } + else + { + ; + } + } + + return chReval; +} + +/* +* 功能描述： 网关信息解析失败、清除既有已经存储的本周期收到网关信息 +* 参数说明： 无 +* 返回值 ：无 +* fan 20260604 +*/ +void ClearCurGateWayMsg(void) +{ + /*远程筛选消息*/ + UINT32 dwCurCycNum = Get2oo2CurCycleNum(); /*当前周期号*/ + if (dwCurCycNum == g_strAtsMsgFst.dwCycle) + { + ClearAtsMsgFirst(); + } + if (dwCurCycNum == g_strAtsMsgSnd.dwCycle) + { + ClearAtsMsgSecond(); + } + if (FLAG_SET == g_strSndAtsCfmFst.chFlag)/*第二个反馈信息解析时直接存储至反馈并设置标志*/ + { + ClearSndAtsScreenFstCfmMsg(); + } + if (dwCurCycNum == g_strAtsEaMsgFst.dwCycle) + { + ClearAtsEaMsgFirst(); + } + if (dwCurCycNum == g_strAtsEaMsgSnd.dwCycle) + { + ClearAtsEaMsgSecond(); + } + if (FLAG_SET == g_strSndAtsEaCfmFst.chFlag)/*第二个反馈信息解析时直接存储至反馈并设置标志*/ + { + ClearSndAtsEaFstCfmMsg(); + } + if (dwCurCycNum == g_strAtsWlbMsgFst.dwCycle) + { + ClearAtsWlbMsgFirst(); + } + if (dwCurCycNum == g_strAtsWlbMsgSnd.dwCycle) + { + ClearAtsWlbMsgSecond(); + } + if (FLAG_SET == g_strSndAtsWlbCfmFst.chFlag)/*第二个反馈信息解析时直接存储至反馈并设置标志*/ + { + ClearSndAtsWlbFstCfmMsg(); + } + if (dwCurCycNum == g_strAtsDaMsgFst.dwCycle) + { + ClearAtsDaMsgFirst(); + } + if (dwCurCycNum == g_strAtsDaMsgSnd.dwCycle) + { + ClearAtsDaMsgSecond(); + } + if (FLAG_SET == g_strSndAtsDaCfmFst.chFlag)/*第二个反馈信息解析时直接存储至反馈并设置标志*/ + { + ClearSndAtsDaFstCfmMsg(); + } } \ No newline at end of file diff --git a/TSCP/src/APP/ciapp/ParsePack/ParsePackGateWayData.h b/TSCP/src/APP/ciapp/ParsePack/ParsePackGateWayData.h index 3ab0acb..b54ba8d 100644 --- a/TSCP/src/APP/ciapp/ParsePack/ParsePackGateWayData.h +++ b/TSCP/src/APP/ciapp/ParsePack/ParsePackGateWayData.h @@ -253,20 +253,21 @@ extern AtsMsgCfmStru * GetAtsCfmFst(void); extern AtsMsgCfmStru * GetAtsCfmSnd(void); /** -* @brief 获取远程筛选二次确认消息 +* @brief 组TIOC到网关数据--既有信息 * @param 无 -* @return 远程筛选二次确认消息 +* @return CI_ERROR失败；CI_SUCCESS成功 */ -extern UINT8 PackTiocToGateWayData(const UINT8 deviceId, const UINT8 targetDevType); +UINT8 PackTiocToGateWayData(UINT8* szToGateWayDataBuf, const UINT8 targetDevType, UINT16* wDataIndex); /** -* @brief 解析网关数据帧 +* @brief 解析网关数据帧---无GAL部分消息反馈内容 * @param const UINT8* dataBuf, 数据缓冲区 -* @param const UINT16 dataLength, 数据长度 +* @param[out] UINT16* dataIndex, 数据索引 +* @param[in] const UINT16 dataLength, 数据长度 * @return CI_SUCCESS:成功；CI_ERROR:失败 */ -extern UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, const UINT16 dataLength); +UINT8 ParseGateWayToCiDataFrame(const UINT8* dataBuf, UINT16* dataIndex, const UINT16 dataLength); /** * @brief 清除1次ATS筛选信息 @@ -449,4 +450,34 @@ void ClearSndAtsWlbFstCfmMsg(void); */ void ClearSndAtsDaFstCfmMsg(void); +/** +* @brief 解析网关数据帧--按照接口类型区分有无GAL +* @param const UINT8* dataBuf, 数据缓冲区 +* @param const UINT16 dataLength, 数据长度 +* @note Created By fan 20260604 +* @return CI_SUCCESS:成功；CI_ERROR:失败 +*/ +UINT8 ParseGateWayToCiDataProc(const UINT8* dataBuf, const UINT16 dataLength); + +/* +* 功能描述： 组网关数据-按照接口类型区分有无GAL +* 参数说明： QueueStruct* ciToAtsDataQueue, 组包发送队列地址 +* const UINT8 deviceId, 目标系统ID +* const UINT8 targetDevType, 目标系统类型 +* const UINT8 frame,帧类型 +* UINT8* chSendXiandiorAtsBuf 码位数据数组首地址 +* 返回值 ： 0: 组包失败 +* 1: 组包成功 +* fan 20260604 +*/ +UINT8 PackCiToGateWayDataProc(const UINT8 deviceId, const UINT8 targetDevType); + +/* +* 功能描述： 网关信息解析失败、清除既有已经存储的本周期收到网关信息 +* 参数说明： 无 +* 返回值 ：无 +* fan 20260604 +*/ +void ClearCurGateWayMsg(void); + #endif \ No newline at end of file diff --git a/TSCP/src/APP/ciapp/ParsePack/ParsePackManage.c b/TSCP/src/APP/ciapp/ParsePack/ParsePackManage.c index 812b205..8b7fa8f 100644 --- a/TSCP/src/APP/ciapp/ParsePack/ParsePackManage.c +++ b/TSCP/src/APP/ciapp/ParsePack/ParsePackManage.c @@ -290,7 +290,7 @@ UINT8 ParseOtherSysToCiData(void) debug_infor_printf((const)"\nGATEWAY_RECV:%d", dataLen); debug_out_array(0xAA, data, (UINT16)dataLen); - checkResult = ParseGateWayToCiDataFrame(data, (UINT16)dataLen); + checkResult = ParseGateWayToCiDataProc(data, (UINT16)dataLen); } if (CI_ERROR == checkResult) @@ -881,7 +881,7 @@ UINT8 PackCiToOtherSysData(void) if (chTiocRcvAtsGtwyDevTypeId == deviceIdBuf[ii]) { /*组ATS站场帧数据*/ - reVal = PackTiocToGateWayData(deviceIdBuf[ii], CI_SYSTEM_TYPE_ATS); + reVal = PackCiToGateWayDataProc(deviceIdBuf[ii], CI_SYSTEM_TYPE_ATS); if (CI_ERROR == reVal) { @@ -1256,6 +1256,8 @@ UINT8 PackCiToOtherSysData(void) PackCiToCimFlyProtectData(); /*发送维护机IO双系采集不一致报警*/ PackCiToCimCollDiffData(); + /*发送道岔冗余采集报警*/ + PackCiToCimSwitchRedunAlarmData(); /*发送给AIM退出运营信息*/ AIMOutput(); /*发送给维护机执行单元报警信息*/ diff --git a/TSCP/src/APP/ciapp/ParsePack/ParsePackVobcData.c b/TSCP/src/APP/ciapp/ParsePack/ParsePackVobcData.c index 8668268..a999066 100644 --- a/TSCP/src/APP/ciapp/ParsePack/ParsePackVobcData.c +++ b/TSCP/src/APP/ciapp/ParsePack/ParsePackVobcData.c @@ -1584,6 +1584,7 @@ static UINT8 ParseVobcToCiDataFrameHLHT(const UINT8* dataBuf, const UINT16 dataL UINT16 wMsgLen = 0U; /*应用数据长度*/ UINT32 dwCiAndVobcTransBadTime = 0U; /*ci和VOBC通信中断时间*/ UINT32 dwAppCycleTime = 0U; /*ci周期*/ + UINT8 trainZeroSpeedState = 0U; /*列车零速状态*/ ci_vobcPrtclVersion = GetVersionOfVOBCToCI(); vobcName = (CI_SYSTEM_TYPE_VOBC)*256U + systemId; @@ -1769,7 +1770,6 @@ static UINT8 ParseVobcToCiDataFrameHLHT(const UINT8* dataBuf, const UINT16 dataL ii += 4U; vobcToCiDataStru->signalID = signalId; /*将信号机ID保存到结构体*/ - } else { @@ -1784,6 +1784,23 @@ static UINT8 ParseVobcToCiDataFrameHLHT(const UINT8* dataBuf, const UINT16 dataL vobcToCiDataStru->ComStartCycle = Get2oo2CurCycleNum(); } break; + case VOBC_CI_INFO_TYPE_MANU_DEFINED: + {/*只解析报文内容*/ + /*列车零速状态*/ + trainZeroSpeedState = dataBuf[ii]; + ii += 1U; + if ((CI_VOBC_TRAIN_ZERO_SPEED_YES == trainZeroSpeedState) || (CI_VOBC_TRAIN_ZERO_SPEED_NO == trainZeroSpeedState)) + { + vobcToCiDataStru->chTrainZeroState = trainZeroSpeedState; + } + else + { + retVal = CI_ERROR; + } + ii += 9U; /*预留*/ + + } + break; case VOBC_CI_INFO_TYPE_BLOCLINK: /*点连式信息帧*/ { retVal = ParseVobcBlocLinkData(&dataBuf[ii], wMsgLen-4U, vobcToCiDataStru); diff --git a/TSCP/src/APP/ciapp/ParsePack/ParsePackVobcData.h b/TSCP/src/APP/ciapp/ParsePack/ParsePackVobcData.h index 960f44f..4e4507f 100644 --- a/TSCP/src/APP/ciapp/ParsePack/ParsePackVobcData.h +++ b/TSCP/src/APP/ciapp/ParsePack/ParsePackVobcData.h @@ -267,6 +267,9 @@ #define CI_VOBC_FLOOD_STATE_OPEN ((UINT8)0xaaU) /*CI-VOBC点连式防淹门开启锁定状态且无关门请求*/ #define CI_VOBC_FLOOD_STATE_CLOSE ((UINT8)0x55U) /*CI-VOBC点连式防淹非开启锁定状态或有关门请求*/ +#define CI_VOBC_TRAIN_ZERO_SPEED_NO ((UINT8)0xAAU) /*CI-VOBC列车非零速*/ +#define CI_VOBC_TRAIN_ZERO_SPEED_YES ((UINT8)0x55U) /*CI-VOBC列车零速*/ + #ifdef __cplusplus extern "C" { diff --git a/TSCP/src/APP/ciapp/QueryFiles/dquCIInit.c b/TSCP/src/APP/ciapp/QueryFiles/dquCIInit.c index c1aa19d..783914d 100644 --- a/TSCP/src/APP/ciapp/QueryFiles/dquCIInit.c +++ b/TSCP/src/APP/ciapp/QueryFiles/dquCIInit.c @@ -393,13 +393,10 @@ UINT8 RelayInit(CHAR* FSName) debug_infor_printf((const)"ReverseCutConfigDataStructInit fail.\r\n"); } - if (RC_WORK_MODE_TIOC == cLocalWorkType) + funcRtn *= GatewayConfigDataStructInit(FSName); + if (0u == funcRtn) { - funcRtn *= GatewayConfigDataStructInit(FSName); - if (0u == funcRtn) - { - debug_infor_printf((const)"GatewayConfigDataStructInit fail.\r\n"); - } + debug_infor_printf((const)"GatewayConfigDataStructInit fail.\r\n"); } /******************************************************************************** @@ -518,6 +515,12 @@ UINT8 RelayInit(CHAR* FSName) debug_infor_printf((const)"AxisSecProtectSwitchInit fail.\r\n"); } + /* 倒切配置数据---在可能配置倒切的设备初始化后 */ + funcRtn *= ReverseSwitchConfigDataStructInit(FSName); + if (0u == funcRtn) + { + debug_infor_printf((const)"ReverseSwitchConfigDataStructInit fail.\r\n"); + } return funcRtn; } @@ -1474,7 +1477,7 @@ UINT8 SglCfgDtStruFromDquSignalStr(DSU_SIGNAL_STRU* pSgnl,SignalConfigDataStruct pSgnlCfgDtStr->startSigRouBuf[pSgnlCfgDtStr->startSigRouSum] = pCurrentRouteStru->wId; pSgnlCfgDtStr->startSigRouSum ++; - if (0u==(pCurrentRouteStru->wRouteType & 0x0200u)) + if (0u==(pCurrentRouteStru->dwRouteType & 0x0200u)) {/*非ZC自动办理的进路*/ pSgnlCfgDtStr->startSigCiRouteSum++; } @@ -1730,7 +1733,7 @@ UINT8 SwitchCfgDtStruFromDquPointStr(DSU_POINT_STRU* pPoint,SwitchConfigDataStru UINT16 i=0u; UINT16 j=0u; UINT8 rtnvalue = 0u; - + UINT8 CiPattern = 0u; /*入口参数防护*/ if((NULL == pPoint) || (NULL == pSwitchCfgDtStr)) @@ -1745,15 +1748,25 @@ UINT8 SwitchCfgDtStruFromDquPointStr(DSU_POINT_STRU* pPoint,SwitchConfigDataStru if (1u == rtnvalue) { + /*冗余采集相关变量初始化为默认值*/ + CiPattern = GetLocalCiPattern(); + pSwitchCfgDtStr->RedunCollCfg = REDUN_COLL_NO; + for (i = 0u; i < SWITCH_REDUN_COLL_MAX; i++) + { + pSwitchCfgDtStr->RedunCollRelayStru[i].wRedunDb1RelayId = 0u; + pSwitchCfgDtStr->RedunCollRelayStru[i].wRedunDb2RelayId = 0u; + pSwitchCfgDtStr->RedunCollRelayStru[i].wRedunFb1RelayId = 0u; + pSwitchCfgDtStr->RedunCollRelayStru[i].wRedunFb2RelayId = 0u; + } + pSwitchCfgDtStr->SwitchId = pPoint->wId; pSwitchCfgDtStr->BelongCiId = (UINT8)pPoint->wManagePhysicalCI; pSwitchCfgDtStr->BelongVirCI = (UINT8)pPoint->wBelongVirCI;/*所属虚拟联锁编号*/ pSwitchCfgDtStr->dwSwitchKilo = pPoint->dwPointKilo; /* 公里标 */ pSwitchCfgDtStr->chKiloType = pPoint->dwPointKiloPlueMinusSign; - if (pSwitchCfgDtStr->SwitchId < SWITCH_SUM_MAX) + pSwitchCfgDtStr->wReverseBoardId = 0U;/*初始化无倒切*/ + if (SWITCH_SUM_MAX > pSwitchCfgDtStr->SwitchId) { - - /*将OC配置表数据存储到道岔配置数据结构体*/ rtnvalue = SwitchCfgDtStruFromOCconfigStr(pSwitchCfgDtStr); @@ -1784,9 +1797,27 @@ UINT8 SwitchCfgDtStruFromDquPointStr(DSU_POINT_STRU* pPoint,SwitchConfigDataStru pSwitchCfgDtStr->ZDbRelayId = (RelayData.pRelayPointStr + j)->wRelayZongDingBiaoId; pSwitchCfgDtStr->ZFbRelayId = (RelayData.pRelayPointStr + j)->wRelayZongFanBiaoId; pSwitchCfgDtStr->DFHRelayId = (RelayData.pRelayPointStr + j)->wDFHId; - pSwitchCfgDtStr->wShadowDbRelayId = (RelayData.pRelayPointStr + j)->wRelayShadowDingBiaoId; - pSwitchCfgDtStr->wShadowFbRelayId = (RelayData.pRelayPointStr + j)->wRelayShadowFanBiaoId; - if (pSwitchCfgDtStr->SwitchId > 0u) + + for (i = 0u; i < SWITCH_REDUN_COLL_MAX; i++) + { + if ((0u == pSwitchCfgDtStr->RedunCollRelayStru[i].wRedunDb1RelayId) + && (0u == pSwitchCfgDtStr->RedunCollRelayStru[i].wRedunDb2RelayId) + && (0u == pSwitchCfgDtStr->RedunCollRelayStru[i].wRedunFb1RelayId) + && (0u == pSwitchCfgDtStr->RedunCollRelayStru[i].wRedunFb2RelayId)) + { + pSwitchCfgDtStr->RedunCollRelayStru[i].wRedunDb1RelayId = (RelayData.pRelayPointStr + j)->wRelayRedunDB1Id; + pSwitchCfgDtStr->RedunCollRelayStru[i].wRedunDb2RelayId = (RelayData.pRelayPointStr + j)->wRelayRedunDB2Id; + pSwitchCfgDtStr->RedunCollRelayStru[i].wRedunFb1RelayId = (RelayData.pRelayPointStr + j)->wRelayRedunFB1Id; + pSwitchCfgDtStr->RedunCollRelayStru[i].wRedunFb2RelayId = (RelayData.pRelayPointStr + j)->wRelayRedunFB2Id; + break; + } + else + { + /*继续遍历*/ + } + } + + if (0u < pSwitchCfgDtStr->SwitchId) { if (0u == pSwitchCfgDtStr->DbRelayId) { @@ -1814,7 +1845,6 @@ UINT8 SwitchCfgDtStruFromDquPointStr(DSU_POINT_STRU* pPoint,SwitchConfigDataStru DebugPrintAppError(ERROR_SWITCH_FCJ_NOT_CONFIG, CI_DEVICE_TYPE_SWITCH, (UINT32)(pSwitchCfgDtStr->SwitchId), PRINT_ONCE); } } - break; } } @@ -1833,6 +1863,31 @@ UINT8 SwitchCfgDtStruFromDquPointStr(DSU_POINT_STRU* pPoint,SwitchConfigDataStru } } } + + if (CI_PATTERN_FULL_ELECTRONIC == CiPattern) + { + pSwitchCfgDtStr->RedunCollCfg = REDUN_COLL_YES; + for (i = 0u; i < SWITCH_REDUN_COLL_MAX; i++) + { + if ((0u == pSwitchCfgDtStr->RedunCollRelayStru[i].wRedunDb1RelayId) + || (0u == pSwitchCfgDtStr->RedunCollRelayStru[i].wRedunDb2RelayId) + || (0u == pSwitchCfgDtStr->RedunCollRelayStru[i].wRedunFb1RelayId) + || (0u == pSwitchCfgDtStr->RedunCollRelayStru[i].wRedunFb2RelayId)) + { + /*冗余采集继电器无效，不具备冗余采集*/ + pSwitchCfgDtStr->RedunCollCfg = REDUN_COLL_NO; + break; + } + else + { + /*全电子联锁，冗余采集继电器有效，具备冗余采集*/ + } + } + } + else + { + /*传统计算机联锁不支持道岔冗余采集*/ + } } } return rtnvalue; @@ -3809,6 +3864,7 @@ UINT8 PsdCfgDtStruFromDquEmergStr(DSU_SCREEN_STRU * pScreen,PsdConfigDataStruct* pPsdCfgDtStr->VirtualAttribute = PSD_VIRTUAL_ATTR_YES; /*初始化为虚拟属性*/ pPsdCfgDtStr->chPsdControlType = PSD_CONTROL_TYPE_RCI; /*初始化为RCI控制*/ pPsdCfgDtStr->wIbpRelayId = 0U; + pPsdCfgDtStr->wReverseBoardId = 0U;/*初始化无倒切*/ if ((UINT16_MAX != pScreen->wLocalPlatformId) && (0U != pScreen->wLocalPlatformId)) { stationId = dsuStaticHeadStru.pStationStru[dsuStationIndex[pScreen->wLocalPlatformId]].wStationID; @@ -5021,12 +5077,12 @@ UINT8 RouteCfgDtStruFrmLSRouteStr( LS_RouteStruct * pLSRouteStr,RouteConfigDataS if ((CI_ERROR != ciType)&&(CI_ERROR!= rtnvalue)) { /*进路属性*/ - if (0x01u == (pDsuRouteStr->wRouteType & 0x01u)) + if (0x01u == (pDsuRouteStr->dwRouteType & 0x01u)) { /*进路类型为列车进路*/ pRouteCfgDtStr->RouteType = ROUTE_TYPE_LIECHE; } - else if (0x02u == (pDsuRouteStr->wRouteType & 0x02u)) + else if (0x02u == (pDsuRouteStr->dwRouteType & 0x02u)) { /*进路类型为折返进路*/ pRouteCfgDtStr->RouteType = ROUTE_TYPE_RETURN; @@ -5040,16 +5096,16 @@ UINT8 RouteCfgDtStruFrmLSRouteStr( LS_RouteStruct * pLSRouteStr,RouteConfigDataS { } } - else if (0x0100u == (pDsuRouteStr->wRouteType & 0x0100u)) + else if (0x0100u == (pDsuRouteStr->dwRouteType & 0x0100u)) { /*进路类型为调车进路*/ pRouteCfgDtStr->RouteType = ROUTE_TYPE_DIAOCHE; } - else if (0u == pDsuRouteStr->wRouteType) + else if (0u == pDsuRouteStr->dwRouteType) { pRouteCfgDtStr->RouteType = 0u; } - else if (0u != (0xffu&pDsuRouteStr->wRouteType)) + else if (0u != (0xffu&pDsuRouteStr->dwRouteType)) { /*类型不为0,且低字节不为0,进路类型为列车进路*/ pRouteCfgDtStr->RouteType = ROUTE_TYPE_LIECHE; @@ -5062,7 +5118,7 @@ UINT8 RouteCfgDtStruFrmLSRouteStr( LS_RouteStruct * pLSRouteStr,RouteConfigDataS /*设置配置进路类型*/ pRouteCfgDtStr->ConfigRouteType = pRouteCfgDtStr->RouteType; /*车辆段折返进路,调整配置进路类型*/ - if (0x02u == (pDsuRouteStr->wRouteType & 0x02u)) + if (0x02u == (pDsuRouteStr->dwRouteType & 0x02u)) { pRouteCfgDtStr->ConfigRouteType = ROUTE_TYPE_RETURN; } @@ -5070,7 +5126,7 @@ UINT8 RouteCfgDtStruFrmLSRouteStr( LS_RouteStruct * pLSRouteStr,RouteConfigDataS { } - if (0x0800u == (pDsuRouteStr->wRouteType & 0x0800u)) + if (0x0800u == (pDsuRouteStr->dwRouteType & 0x0800u)) { /*风井进路*/ pRouteCfgDtStr->AirShaftRouteType = ROUTE_TYPE_AIRSHAFT; } @@ -5079,7 +5135,7 @@ UINT8 RouteCfgDtStruFrmLSRouteStr( LS_RouteStruct * pLSRouteStr,RouteConfigDataS } /*自动触发进路属性*/ - if (0x1000u == (pDsuRouteStr->wRouteType & 0x1000u)) + if (0x1000u == (pDsuRouteStr->dwRouteType & 0x1000u)) {/*自动触发进路*/ pRouteCfgDtStr->AutoTriggerType = ROUTE_TYPE_AUTO_TRIGGER; } @@ -5089,7 +5145,7 @@ UINT8 RouteCfgDtStruFrmLSRouteStr( LS_RouteStruct * pLSRouteStr,RouteConfigDataS /*设置进路入库属性*/ pRouteCfgDtStr->cRouteRukuProperty = ROUTE_RUKU_PROPERTY_NO; - if (0x0010U == (pDsuRouteStr->wRouteType & 0x0010U)) + if (0x0010U == (pDsuRouteStr->dwRouteType & 0x0010U)) { pRouteCfgDtStr->cRouteRukuProperty = ROUTE_RUKU_PROPERTY_YES; } @@ -5108,13 +5164,22 @@ UINT8 RouteCfgDtStruFrmLSRouteStr( LS_RouteStruct * pLSRouteStr,RouteConfigDataS { } /*进路联挂属性*/ - if (0x8000U == (pDsuRouteStr->wRouteType & 0x8000U)) + if (0x8000U == (pDsuRouteStr->dwRouteType & 0x8000U)) { pRouteCfgDtStr->chRouteCouplinkType = ROUTE_TYPE_COUPLINK; } else { + } + /*进路联络线属性*/ + if (0x10000U == (pDsuRouteStr->dwRouteType & 0x10000U)) + { + pRouteCfgDtStr->chRouteConnectType = ROUTE_TYPE_CONNECT; + } + else + { + } /*自动进路属性*/ @@ -6139,7 +6204,7 @@ UINT8 RouteCfgDtStruFrmLSRouteStr( LS_RouteStruct * pLSRouteStr,RouteConfigDataS { routeEndSignal =dsuStaticHeadStru.pRouteStru[dsuRouteIndex[LSData.pLSRouteStr[i].wRouteId]].wEndSignalId; if((routeStartSignal == routeEndSignal) && - (0x02u == (dsuStaticHeadStru.pRouteStru[dsuRouteIndex[LSData.pLSRouteStr[i].wRouteId]].wRouteType & 0x02u))) + (0x02u == (dsuStaticHeadStru.pRouteStru[dsuRouteIndex[LSData.pLSRouteStr[i].wRouteId]].dwRouteType & 0x02u))) {/*此条折返进路的终端信号机为当前进路的始端信号机*/ /*风井折返进路和普通折返进路*/ if(ROUTE_SIGNAL_OPPOSED_ROUTE_SUM_MAX > index) { @@ -11644,6 +11709,162 @@ UINT8 ReverseCutCfgDtStruFromDquStr(Relay_ReverseCutStruct* pReverseCutRelay, Re return rtnvalue; } +/********************************************* +*函数功能：初始化倒切开关配置数据结构体----对外结构体 +*参数说明：FSName文件指针 +*返回值：0，失败；1，成功 +*********************************************/ +UINT8 ReverseSwitchConfigDataStructInit(CHAR * FSName) +{ + + UINT8 rtnvalue = 0u; + UINT8 callFun = 0u; + UINT16 i = 0u; + + if (NULL != FSName) + { + + callFun = InitRelay_ReverseSwitchStru(FSName); + callFun *= InitRelay_ReverseBoardStru(FSName); + } + else + { + rtnvalue = 0u; + } + /*电子地图初始化失败，函数失败退出*/ + if (0u == callFun) + { + rtnvalue = 0u; + } + else + { + rtnvalue = 1u; + } + + if ((1u == rtnvalue)&&(CI_SUM_MAX > RelayDataLen.RelayReverseSwitchStrLen)) + { + dquCICfgDtStr.wRelayReverseSwitchStrLen = RelayDataLen.RelayReverseSwitchStrLen; + for (i = 0u; iwId = pReverseSwitchRelay->wReversSwitchId; + for (jj = 0u; jjwColCloseRelayId == RelayData.pRelayCfgDtStr[jj].RelayId) + { + chFindClose = CI_SUCCESS; + } + else if (pReverseSwitchRelay->wColOpenRelayId == RelayData.pRelayCfgDtStr[jj].RelayId) + { + pReverseSwitchCfgDtStr->chBelongCiId = RelayData.pRelayCfgDtStr[jj].BelongCiId; + chFindOpen = CI_SUCCESS; + } + else + { + ; + } + if ((CI_SUCCESS == chFindOpen) && (CI_SUCCESS == chFindClose)) + { + break;/*均找到*/ + } + } + + if ((CI_ERROR == chFindOpen) || (CI_ERROR == chFindClose)) + { + /*返回失败*/ + rtnvalue = 0u; + debug_infor_printf((char*)"\nOpenRelay :%d CloseRelay：%d, Not Find In RelayTable \n", pReverseSwitchRelay->wColOpenRelayId, pReverseSwitchRelay->wColCloseRelayId); + } + else + { + rtnvalue = 1u; + pReverseSwitchCfgDtStr->wColCloseRelayId = pReverseSwitchRelay->wColCloseRelayId; + pReverseSwitchCfgDtStr->wColOpenRelayId = pReverseSwitchRelay->wColOpenRelayId; + pReverseSwitchCfgDtStr->wRelateBoardNum = pReverseSwitchRelay->wRelateBoardNum; + if ((0U < pReverseSwitchCfgDtStr->wRelateBoardNum) && (REVERSE_BOARD_SUM_MAX >= pReverseSwitchCfgDtStr->wRelateBoardNum)) + { + for (kk = 0u; kk < pReverseSwitchCfgDtStr->wRelateBoardNum; kk++) + { + pReverseSwitchCfgDtStr->strRelateBoardBuf[kk].wReversBoardId = pReverseSwitchRelay->strRelateBoardBuf[kk].wReversBoardId; + pReverseSwitchCfgDtStr->strRelateBoardBuf[kk].chDevType = pReverseSwitchRelay->strRelateBoardBuf[kk].chDevType; + pReverseSwitchCfgDtStr->strRelateBoardBuf[kk].wBoardColCloseRelayId = pReverseSwitchRelay->strRelateBoardBuf[kk].wBoardColCloseRelayId; + pReverseSwitchCfgDtStr->strRelateBoardBuf[kk].wBoardColOpenRelayId = pReverseSwitchRelay->strRelateBoardBuf[kk].wBoardColOpenRelayId; + pReverseSwitchCfgDtStr->strRelateBoardBuf[kk].wDevId = pReverseSwitchRelay->strRelateBoardBuf[kk].wDevId; + chFindClose = CI_ERROR; + chFindOpen = CI_ERROR; + for (jj = 0u; jjstrRelateBoardBuf[kk].wBoardColCloseRelayId == RelayData.pRelayCfgDtStr[jj].RelayId) + { + chFindClose = CI_SUCCESS; + } + else if (pReverseSwitchCfgDtStr->strRelateBoardBuf[kk].wBoardColOpenRelayId == RelayData.pRelayCfgDtStr[jj].RelayId) + { + pReverseSwitchCfgDtStr->chBelongCiId = RelayData.pRelayCfgDtStr[jj].BelongCiId; + chFindOpen = CI_SUCCESS; + } + else + { + ; + } + if ((CI_SUCCESS == chFindOpen) && (CI_SUCCESS == chFindClose)) + { + break;/*均找到*/ + } + } + + if ((CI_ERROR == chFindOpen) || (CI_ERROR == chFindClose)) + { + rtnvalue = 0u; + debug_infor_printf((char*)"\nBoard: %d openRelay:%d closeRelay:%d, Not Find In RelayTable \n", pReverseSwitchCfgDtStr->strRelateBoardBuf[kk].wReversBoardId, + pReverseSwitchCfgDtStr->strRelateBoardBuf[kk].wBoardColOpenRelayId, pReverseSwitchCfgDtStr->strRelateBoardBuf[kk].wBoardColCloseRelayId); + break; + } + } + } + } + } + else + { + /*返回失败*/ + rtnvalue = 0u; + } + return rtnvalue; +} + /********************************************* *函数功能：初始化TIOCATS设备网关配置数据结构体----对外结构体 *参数说明：FSName文件指针 @@ -14336,7 +14557,6 @@ static UINT8 RciSerialCommDataInit(void) UINT16 ii = 0U; /*循环变量*/ UINT8 chLocalCiId = 0U; /*本地联锁ID*/ UINT16 wDataLen = 0U; /*数据宽度*/ - UINT16 wTempData = 0U; /*临时数据*/ UINT16 val = 0U; /*临时承接变量*/ UINT8 chCiDevId = 0U; /*CI设备ID*/ UINT8 chCiDevType = 0U; /*CI设备类型*/ @@ -14366,7 +14586,7 @@ static UINT8 RciSerialCommDataInit(void) chCiDevId = (UINT8)(val & 0x00FF); chCiDevType = (UINT8)((val & 0xFF00) >> 8); - if ((chLocalCiId == chCiDevType) && (chLocalRcWorkMode == chCiDevType)) + if ((chLocalCiId == chCiDevId) && (chLocalRcWorkMode == chCiDevType)) { /*设置本联锁串口通信标志*/ chRtnValue &= SetLocalSerialCommFlag(SERIAL_COMM_YES); diff --git a/TSCP/src/APP/ciapp/QueryFiles/dquCIInit.h b/TSCP/src/APP/ciapp/QueryFiles/dquCIInit.h index fff1284..35217f3 100644 --- a/TSCP/src/APP/ciapp/QueryFiles/dquCIInit.h +++ b/TSCP/src/APP/ciapp/QueryFiles/dquCIInit.h @@ -176,6 +176,9 @@ typedef struct ReverseCutCfgDataStru stReverseCutCfgDtStr[REVERSE_CUT_SUM_MAX]; /*倒切设备配置数据*/ UINT16 wReverseCutCfgLen; + ReverseSwitchCfgDataStru stReverseSwitchCfgDtStr[CI_SUM_MAX]; /*倒切设备开关板卡配置数据*/ + UINT16 wRelayReverseSwitchStrLen; /*倒切开关个数*/ + EaConfigStru szEaCfgDtStr[EA_CFG_SUM_MAX]; /*防护区域配置数据*/ UINT16 wEaCfgLen; /*防护区域配置数据长度*/ @@ -1088,5 +1091,20 @@ UINT8 PsdRelateEsbConfigDataInit(UINT16 wPsdIndex); */ UINT8 RciCommonConfigDataInit(CHAR* FSName); +/********************************************* +*函数功能：初始化倒切开关配置数据结构体----对外结构体 +*参数说明：FSName文件指针 +*返回值：0，失败；1，成功 +*********************************************/ +UINT8 ReverseSwitchConfigDataStructInit(CHAR * FSName); + +/********************************************* +*函数功能：倒切开关配置数据结构体计算 +*参数说明：pReverseSwitchRelay继电器初始化数据指针 +pReverseSwitchCfgDtStr配置数据结构体指针 +*返回值：0，失败；1，成功 +*********************************************/ +UINT8 ReverseSiwtchCfgDtStruFromDquStr(Relay_ReverseSwitchStruct* pReverseSwitchRelay, ReverseSwitchCfgDataStru* pReverseSwitchCfgDtStr); + #endif diff --git a/TSCP/src/APP/ciapp/QueryFiles/dquCIInterFace.c b/TSCP/src/APP/ciapp/QueryFiles/dquCIInterFace.c index 7000617..fa12b9e 100644 --- a/TSCP/src/APP/ciapp/QueryFiles/dquCIInterFace.c +++ b/TSCP/src/APP/ciapp/QueryFiles/dquCIInterFace.c @@ -4137,6 +4137,70 @@ INT16 ReadReverseCutConfigData(const UINT8 ciId, ReverseCutCfgDataStru* pstRever return DataNum; } +/********************************************* +*函数功能：本联锁倒切设备关联对应板卡配置数据 +*参数说明：ciId联锁ID， pLocalReverseData 本联锁倒切设备配置数据结构体指针 +*返回值：-1 失败 其他 成功 +*********************************************/ +INT16 ReadReverseSwitchConfigData(const UINT8 ciId, ReverseSwitchCfgDataStru* pLocalReverseData) +{ + UINT16 i = 0u; + INT16 DataNum = -1; + UINT16 jj = 0U; + if ((0u == ciId) || (NULL == pLocalReverseData)) + { + DataNum = -1; + } + else + { + DataNum = 0; + } + + if (0 == DataNum) + { + for (i = 0u; iwColCloseRelayId = dquCICfgDtStr.stReverseSwitchCfgDtStr[i].wColCloseRelayId; + pLocalReverseData->wColOpenRelayId = dquCICfgDtStr.stReverseSwitchCfgDtStr[i].wColOpenRelayId; + if ((0U == pLocalReverseData->wColCloseRelayId) || (UINT16_MAX == pLocalReverseData->wColCloseRelayId) + || (0U == pLocalReverseData->wColOpenRelayId) || (UINT16_MAX == pLocalReverseData->wColOpenRelayId)) + { + DataNum = -1;/*本联锁配置有倒切开关但采集错误*/ + } + else + { + pLocalReverseData->wRelateBoardNum = dquCICfgDtStr.stReverseSwitchCfgDtStr[i].wRelateBoardNum; + pLocalReverseData->wId = dquCICfgDtStr.stReverseSwitchCfgDtStr[i].wId; + pLocalReverseData->chBelongCiId = ciId; + for (jj = 0u; jj < dquCICfgDtStr.stReverseSwitchCfgDtStr[i].wRelateBoardNum; jj++) + { + pLocalReverseData->strRelateBoardBuf[jj].wReversBoardId = dquCICfgDtStr.stReverseSwitchCfgDtStr[i].strRelateBoardBuf[jj].wReversBoardId; + pLocalReverseData->strRelateBoardBuf[jj].chDevType = dquCICfgDtStr.stReverseSwitchCfgDtStr[i].strRelateBoardBuf[jj].chDevType; + pLocalReverseData->strRelateBoardBuf[jj].wBoardColCloseRelayId = dquCICfgDtStr.stReverseSwitchCfgDtStr[i].strRelateBoardBuf[jj].wBoardColCloseRelayId; + pLocalReverseData->strRelateBoardBuf[jj].wBoardColOpenRelayId = dquCICfgDtStr.stReverseSwitchCfgDtStr[i].strRelateBoardBuf[jj].wBoardColOpenRelayId; + if ((0U == pLocalReverseData->strRelateBoardBuf[jj].wBoardColCloseRelayId) || (UINT16_MAX == pLocalReverseData->strRelateBoardBuf[jj].wBoardColCloseRelayId) + || (0U == pLocalReverseData->strRelateBoardBuf[jj].wBoardColOpenRelayId) || (UINT16_MAX == pLocalReverseData->strRelateBoardBuf[jj].wBoardColOpenRelayId)) + { + DataNum = -1;/*配置有倒切板卡但采集错误*/ + break; + } + pLocalReverseData->strRelateBoardBuf[jj].wDevId = dquCICfgDtStr.stReverseSwitchCfgDtStr[i].strRelateBoardBuf[jj].wDevId; + } + } + break; + } + } + } + else + { + ; + } + + return DataNum; +} + /************************************************** *函数功能：取VOBC设备编号相应位数，查询vobc索引 diff --git a/TSCP/src/APP/ciapp/QueryFiles/dquCIInterFace.h b/TSCP/src/APP/ciapp/QueryFiles/dquCIInterFace.h index 133f09f..4ee1668 100644 --- a/TSCP/src/APP/ciapp/QueryFiles/dquCIInterFace.h +++ b/TSCP/src/APP/ciapp/QueryFiles/dquCIInterFace.h @@ -418,6 +418,13 @@ INT16 ReadCutoffPointConfigData(const UINT8 ciId, CfpConfigStru* pstCutoffConfig *返回值：本地关联分界点ID *********************************************/ INT16 ReadReverseCutConfigData(const UINT8 ciId, ReverseCutCfgDataStru* pstReverseConfigData); + +/********************************************* +*函数功能：本联锁倒切设备关联对应板卡配置数据 +*参数说明：ciId联锁ID， pLocalReverseData 本联锁到期配置数据结构体指针 +*返回值：-1 失败 其他 成功 +*********************************************/ +INT16 ReadReverseSwitchConfigData(const UINT8 ciId, ReverseSwitchCfgDataStru* pLocalReverseData); /************************************************************************ 功能：HlhtID转vobc内部编号 输入： diff --git a/TSCP/src/APP/ciapp/QueryFiles/dquCIJDQStruFrmChar.c b/TSCP/src/APP/ciapp/QueryFiles/dquCIJDQStruFrmChar.c index 5afb0b5..3f57f37 100644 --- a/TSCP/src/APP/ciapp/QueryFiles/dquCIJDQStruFrmChar.c +++ b/TSCP/src/APP/ciapp/QueryFiles/dquCIJDQStruFrmChar.c @@ -404,32 +404,34 @@ UINT8 R_PointStructFromChar(UINT8 * pDataAddr,Relay_PointStruct* pSwitchStr) } if (CI_TRADITION_RAILWAY == lineIdentity) {/*城轨线路*/ - pSwitchStr->wPointId = dquCiShortFromChar(pData); /*道岔ID*/ + pSwitchStr->wPointId = dquCiShortFromChar(pData); /*道岔ID*/ + pData += 2u; + pSwitchStr->wOcId = dquCiShortFromChar(pData); /*OC ID*/ + pData += 2u; + pSwitchStr->wRelayDingBiaoId = dquCiShortFromChar(pData); /*定表继电器ID */ + pData += 2u; + pSwitchStr->wRelayFanBiaoId = dquCiShortFromChar(pData); /*反表继电器ID */ pData += 2u; - /*跳过OCID*/ - pData += 2u; - pSwitchStr->wRelayDingBiaoId = dquCiShortFromChar(pData); /*定表继电器ID */ - pData += 2u; - pSwitchStr->wRelayFanBiaoId = dquCiShortFromChar(pData); /*反表继电器ID */ + pSwitchStr->wRelayYunCaoId = dquCiShortFromChar(pData); /*允操继电器ID*/ pData += 2u; - - pSwitchStr->wRelayYunCaoId = dquCiShortFromChar(pData); /*允操继电器ID*/ - pData += 2u; - pSwitchStr->wRelayDingCaoId = dquCiShortFromChar(pData); /*定操继电器ID */ + pSwitchStr->wRelayDingCaoId = dquCiShortFromChar(pData); /*定操继电器ID */ pData += 2u; - pSwitchStr->wRelayFanCaoId = dquCiShortFromChar(pData); /*反操继电器ID */ + pSwitchStr->wRelayFanCaoId = dquCiShortFromChar(pData); /*反操继电器ID */ pData += 2u; - pSwitchStr->wRelayZongDingBiaoId = dquCiShortFromChar(pData); /*总定表继电器ID */ + pSwitchStr->wRelayZongDingBiaoId = dquCiShortFromChar(pData); /*总定表继电器ID */ pData += 2u; - pSwitchStr->wRelayZongFanBiaoId = dquCiShortFromChar(pData); /*总反表继电器ID */ + pSwitchStr->wRelayZongFanBiaoId = dquCiShortFromChar(pData); /*总反表继电器ID */ pData += 2u; - pSwitchStr->wDFHId = dquCiShortFromChar(pData); /*DFH继电器ID*/ + pSwitchStr->wDFHId = dquCiShortFromChar(pData); /*DFH继电器ID*/ pData += 2u; - - pSwitchStr->wRelayShadowDingBiaoId = dquCiShortFromChar(pData); /*定表继电器ID */ + pSwitchStr->wRelayRedunDB1Id = dquCiShortFromChar(pData); /*（北京10冗余采集）DBJ1继电器ID*/ pData += 2u; - pSwitchStr->wRelayShadowFanBiaoId = dquCiShortFromChar(pData); /*反表继电器ID */ + pSwitchStr->wRelayRedunDB2Id = dquCiShortFromChar(pData); /*（北京10冗余采集）DBJ2继电器ID*/ + pData += 2u; + pSwitchStr->wRelayRedunFB1Id = dquCiShortFromChar(pData); /*（北京10冗余采集）FBJ1继电器ID*/ + pData += 2u; + pSwitchStr->wRelayRedunFB2Id = dquCiShortFromChar(pData); /*（北京10冗余采集）FBJ2继电器ID*/ pData += 2u; }/* zt 删除单轨相关代码 2022-02-15 */ else @@ -1192,4 +1194,155 @@ UINT8 R_OCIndicStruFromChar(UINT8* pDataAddr, OCStationIndicConfigDataStru* pInd return reVal; } +/********************************************* +*函数功能：从数据到倒切开关配置继电器结构体 +*参数说明：pDataAddr数据地址， Relay_ReverseSwitchStruct 倒切开关继电器配置数据结构体指针 +*返回值：0，失败；1，成功 +*********************************************/ +UINT8 R_ReverseSwitchStrFromChar(UINT8 * pDataAddr, Relay_ReverseSwitchStruct * pReverseStr) +{ + UINT8 * pData = pDataAddr; + UINT8 rtnvalue = 0u; + UINT16 j = 0U; + UINT16 wTemp = 0U; + if ((NULL == pDataAddr) || (NULL == pReverseStr)) + { + rtnvalue = 0u; + + } + else + { + rtnvalue = 1U; + } + + if (1u == rtnvalue) + { + pReverseStr->wReversSwitchId = dquCiShortFromChar(pData); /*ID*/ + pData += 2u; + + pReverseStr->ocId = dquCiShortFromChar(pData); /*Oc ID*/ + pData += 2u; + + pReverseStr->wColOpenRelayId = dquCiShortFromChar(pData); /*常开继电器*/ + pData += 2u; + + pReverseStr->wColCloseRelayId = dquCiShortFromChar(pData); /*常闭继电器*/ + pData += 2u; + + if ((0U == pReverseStr->wColOpenRelayId) + ||(0U == pReverseStr->wColCloseRelayId) + || (pReverseStr->wColOpenRelayId == pReverseStr->wColCloseRelayId)) + { + rtnvalue = 0u; + } + else + { + pReverseStr->wRelateBoardNum = dquCiShortFromChar(pData); /*板卡个数*/ + pData += 2u; + + if ((0U < pReverseStr->wRelateBoardNum)&&(OC_RELAY_REVERSE_BOARD_MAX >= pReverseStr->wRelateBoardNum)) + { + for (j = 0U; j < pReverseStr->wRelateBoardNum; j++) + { + wTemp = dquCiShortFromChar(pData); /*板卡id*/ + pData += 2u; + if ((0U == wTemp) || (UINT16_MAX == wTemp)) + { + rtnvalue = 0U; + break; + } + else + { + pReverseStr->strRelateBoardBuf[j].wReversBoardId = wTemp; + } + } + } + else + { + rtnvalue = 0u; + debug_infor_printf((char*)"\nR_ReverseSwitchStrFromChar BoardNum%d", pReverseStr->wRelateBoardNum); + } + } + } + + return rtnvalue; + +} + +/********************************************* +*函数功能：从数据到倒切板卡结构体 +*参数说明：pDataAddr数据地址， Relay_ReverseBoardStruct 倒切板卡继电器配置数据结构体指针 +*返回值：0，失败；1，成功 +*********************************************/ +UINT8 R_ReverseBoardStrFromChar(UINT8 * pDataAddr, Relay_ReverseBoardStruct * pReverseStr) +{ + UINT8 * pData = pDataAddr; + UINT8 rtnvalue = 0u; + UINT16 wBoardId = 0U; + if ((NULL == pDataAddr) || (NULL == pReverseStr)) + { + rtnvalue = 0u; + + } + else + { + rtnvalue = 1U; + } + + if (1u == rtnvalue) + { + wBoardId = dquCiShortFromChar(pData); /*ID*/ + pData += 2u; + + if (0U == wBoardId) + { + rtnvalue = 0U; + } + else + { + pReverseStr->wReversBoardId = wBoardId; /*板卡ID*/ + + pReverseStr->wBoardColOpenRelayId = dquCiShortFromChar(pData); /*常开继电器*/ + pData += 2u; + + pReverseStr->wBoardColCloseRelayId = dquCiShortFromChar(pData); /*常闭继电器*/ + pData += 2u; + + if ((0U == pReverseStr->wBoardColCloseRelayId) + ||(0U == pReverseStr->wBoardColOpenRelayId) + || (pReverseStr->wBoardColOpenRelayId == pReverseStr->wBoardColCloseRelayId)) + { + rtnvalue = 0U; + } + else + { + pReverseStr->chDevType = *pData;/*类型*/ + pData++; + + pReverseStr->wDevId = dquCiShortFromChar(pData); /*设备ID*/ + pData += 2u; + + if ((OC_LEN_REVERSE_TYPE_PSD == pReverseStr->chDevType) || (OC_LEN_REVERSE_TYPE_SWITCH == pReverseStr->chDevType)) + { + if ((0U < pReverseStr->wDevId) && (UINT16_MAX != pReverseStr->wDevId)) + { + rtnvalue = 1U; + } + else + { + rtnvalue = 0U; + } + } + else + { + rtnvalue = 0U; + } + } + } + } + + return rtnvalue; + +} + diff --git a/TSCP/src/APP/ciapp/QueryFiles/dquCIJDQStruFrmChar.h b/TSCP/src/APP/ciapp/QueryFiles/dquCIJDQStruFrmChar.h index 9df9f0c..4746325 100644 --- a/TSCP/src/APP/ciapp/QueryFiles/dquCIJDQStruFrmChar.h +++ b/TSCP/src/APP/ciapp/QueryFiles/dquCIJDQStruFrmChar.h @@ -150,4 +150,18 @@ UINT8 R_ReverseCutStrFromChar(UINT8 * pDataAddr, Relay_ReverseCutStruct * pRever * cgh-合并CID-3037-3： *********************************************/ UINT8 R_OCIndicStruFromChar(UINT8* pDataAddr, OCStationIndicConfigDataStru* pIndicStru); + +/********************************************* +*函数功能：从数据到倒切开关配置继电器结构体 +*参数说明：pDataAddr数据地址， Relay_ReverseSwitchStruct 倒切开关继电器配置数据结构体指针 +*返回值：0，失败；1，成功 +*********************************************/ +UINT8 R_ReverseSwitchStrFromChar(UINT8 * pDataAddr, Relay_ReverseSwitchStruct * pReverseStr); + +/********************************************* +*函数功能：从数据到倒切板卡结构体 +*参数说明：pDataAddr数据地址， Relay_ReverseBoardStruct 倒切板卡继电器配置数据结构体指针 +*返回值：0，失败；1，成功 +*********************************************/ +UINT8 R_ReverseBoardStrFromChar(UINT8 * pDataAddr, Relay_ReverseBoardStruct * pReverseStr); #endif diff --git a/TSCP/src/APP/ciapp/QueryFiles/dquCIJDQStruInit.c b/TSCP/src/APP/ciapp/QueryFiles/dquCIJDQStruInit.c index 2e4f329..d7c93c7 100644 --- a/TSCP/src/APP/ciapp/QueryFiles/dquCIJDQStruInit.c +++ b/TSCP/src/APP/ciapp/QueryFiles/dquCIJDQStruInit.c @@ -468,8 +468,8 @@ UINT8 InitRelay_PointStru(CHAR* CIDataName) if (CI_PATTERN_TRADITIONAL == localCiPattern) { excelId = CI_DATA_TYPE; - sheetId = RELAY_SIGNAL; - rowLen = LEN_RELAY_SIGNAL; + sheetId = RELAY_POINT; + rowLen = LEN_RELAY_POINT; } else { @@ -1642,3 +1642,191 @@ UINT8 InitRelay_ReverseCutStru(CHAR* CIDataName) return rtnValue; } +/********************************************* +*函数功能：填充倒切开关继电器结构体数组---内部用 +*参数说明：CIDataName件指针 +*返回值：0，失败；1，成功 +*********************************************/ +UINT8 InitRelay_ReverseSwitchStru(CHAR* CIDataName) +{ + UINT8 funcRtn = 0u; + Relay_ReverseSwitchStruct* pReverseSwitchStr = NULL; /*倒切开关变量*/ + UINT8* pDataAddr = NULL; /*数据地址*/ + UINT32 DataSize = 0U; /*数据大小（字节数）*/ + UINT16 j = 0U; + UINT8 rtnValue = 0u; + + /*已经初始化了，不用老是调用执行过程 全电子不用初始化这张表*/ + if (NULL != RelayData.pRelayReverseSwitchStr) + { + rtnValue = 1u; + } + else + { + /*读取倒切设备继电器数据表*/ + funcRtn = dquGetConfigData(CIDataName, OC_DATA_TYPE, OC_RELAY_REVERSE_SWITCH_ID, &pDataAddr, &DataSize); + if (0u == funcRtn) + { + /*函数调用失败*/ + rtnValue = 0u; + } + else + { + + if ((0u != DataSize% OC_LEN_REVERSE_SWITCH_LEN)) + { /*求得个数不为整数，数据错误*/ + debug_infor_printf((char* )"\nCI_RELAY_DATA,REVERSE_Switch len %d not equal to fs", OC_LEN_REVERSE_SWITCH_LEN); + rtnValue = 0u; + } + else + { + RelayDataLen.RelayReverseSwitchStrLen = (UINT16)(DataSize / OC_LEN_REVERSE_SWITCH_LEN);/*计算结构体个数*/ + + if (OC_LEN_REVERSE_SWITCH_LEN > DataSize) + {/*不足一个*/ + RelayData.pRelayReverseSwitchStr = (Relay_ReverseSwitchStruct *)MyNew((UINT32)sizeof(Relay_ReverseSwitchStruct)); + RelayDataLen.RelayReverseSwitchStrLen = 0u; + rtnValue = 1u; + } + else + { + + /*动态申请空间*/ + RelayData.pRelayReverseSwitchStr = (Relay_ReverseSwitchStruct *)MyNew((UINT32)(sizeof(Relay_ReverseSwitchStruct) * RelayDataLen.RelayReverseSwitchStrLen)); + + if (NULL == RelayData.pRelayReverseSwitchStr) + {/*动态申请空间失败*/ + RelayDataLen.RelayReverseSwitchStrLen = 0u; + rtnValue = 0u; + } + else + { + /*内存先设为无效*/ + (void)CommonMemSet(RelayData.pRelayReverseSwitchStr, (UINT32)(sizeof(Relay_ReverseSwitchStruct) * RelayDataLen.RelayReverseSwitchStrLen), + (UINT8)0x00, (UINT32)(sizeof(Relay_ReverseSwitchStruct) * RelayDataLen.RelayReverseSwitchStrLen)); + /*解析数据到 结构体数组 */ + rtnValue = 1u; + for (j = 0u; j < RelayDataLen.RelayReverseSwitchStrLen; j++) + { + pReverseSwitchStr = RelayData.pRelayReverseSwitchStr + j; + + /*填充数据结构体*/ + rtnValue &= R_ReverseSwitchStrFromChar(pDataAddr, pReverseSwitchStr); + pDataAddr += OC_LEN_REVERSE_SWITCH_LEN; + if (1U != rtnValue) + { + break; + } + } + } + } + } + } + } + return rtnValue; +} + +/********************************************* +*函数功能：填充倒切板卡继电器结构体数组---内部用 +*参数说明：CIDataName件指针 +*返回值：0，失败；1，成功 +*********************************************/ +UINT8 InitRelay_ReverseBoardStru(CHAR* CIDataName) +{ + UINT8 funcRtn = 0u; + UINT8* pDataAddr = NULL; /*数据地址*/ + UINT32 DataSize = 0U; /*数据大小（字节数）*/ + Relay_ReverseBoardStruct tempBoardStru = {0}; /*倒切板卡临时存储*/ + Relay_ReverseSwitchStruct* pReverseSwitchStr = NULL;/*倒切开关指针*/ + Relay_ReverseBoardStruct* pReverseBoard = NULL; /*倒切板卡指针*/ + UINT16 j = 0U; + UINT16 ii = 0U; + UINT16 kk = 0U; + UINT8 rtnValue = 0u; + UINT16 wLen = 0U; + UINT8 chFind = CI_ERROR; + + if (NULL == RelayData.pRelayReverseSwitchStr) + { + /*需要先初始化倒切开关继电器*/ + rtnValue = 0u; + } + else + { + /*读取倒切板卡继电器数据表*/ + funcRtn = dquGetConfigData(CIDataName, OC_DATA_TYPE, OC_RELAY_REVERSE_BOARD_ID, &pDataAddr, &DataSize); + if (0u == funcRtn) + { + /*函数调用失败*/ + rtnValue = 0u; + } + else + { + + if ((0u != DataSize% OC_LEN_REVERSE_BOARD_LEN)) + { /*求得个数不为整数，数据错误*/ + debug_infor_printf((char*)"\nCI_RELAY_DATA,REVERSE_Board len %d not equal to fs", OC_LEN_REVERSE_BOARD_LEN); + rtnValue = 0u; + } + else + { + wLen = (UINT16)(DataSize / OC_LEN_REVERSE_BOARD_LEN);/*计算结构体个数*/ + + if ((0U == RelayDataLen.RelayReverseSwitchStrLen)&&(RelayDataLen.RelayReverseSwitchStrLen == wLen)) + { + /*无开关*/ + rtnValue = 1u; + } + else if ((0U == RelayDataLen.RelayReverseSwitchStrLen) || (0U == wLen)||(CI_SUM_MAX <= RelayDataLen.RelayReverseSwitchStrLen)) + { + /*板卡与开关配置不一致*/ + debug_infor_printf((char*)"\n InitRelay_ReverseBoardStru len %d Error \n", wLen); + rtnValue = 0u; + } + else + { + /*初始化到对应开关数据，板卡数据的空间已经申请在开关数据结构体内*/ + rtnValue = 1u; + for (ii = 0U; ii < wLen; ii++) + { + /*填充数据结构体*/ + rtnValue &= R_ReverseBoardStrFromChar(pDataAddr, &tempBoardStru); + pDataAddr += OC_LEN_REVERSE_BOARD_LEN; + chFind = CI_ERROR; + if (1U == rtnValue) + { + for (j = 0U; j < RelayDataLen.RelayReverseSwitchStrLen; j++) + { + pReverseSwitchStr = RelayData.pRelayReverseSwitchStr + j; + for (kk = 0U; kk < pReverseSwitchStr->wRelateBoardNum; kk++) + { + /*遍历查找对应倒切板卡*/ + if (pReverseSwitchStr->strRelateBoardBuf[kk].wReversBoardId == tempBoardStru.wReversBoardId) + { + pReverseBoard = &pReverseSwitchStr->strRelateBoardBuf[kk]; + (void)CommonMemCpy((void *)(pReverseBoard), (UINT32)sizeof(Relay_ReverseBoardStruct), (const void *)(&tempBoardStru), (UINT32)sizeof(Relay_ReverseBoardStruct)); + chFind = CI_SUCCESS; + break; + } + } + if (CI_SUCCESS == chFind) + { + break; + } + } + } + + if ((CI_ERROR == chFind)||(0U == rtnValue)) + { + rtnValue = 0u; + debug_infor_printf((char*)"\n InitRelay_ReverseBoardStru Board%d Not Find \n", tempBoardStru.wReversBoardId); + break; + } + } + } + } + } + } + return rtnValue; +} + diff --git a/TSCP/src/APP/ciapp/QueryFiles/dquCIJDQStruInit.h b/TSCP/src/APP/ciapp/QueryFiles/dquCIJDQStruInit.h index 1344741..db8afea 100644 --- a/TSCP/src/APP/ciapp/QueryFiles/dquCIJDQStruInit.h +++ b/TSCP/src/APP/ciapp/QueryFiles/dquCIJDQStruInit.h @@ -36,6 +36,7 @@ typedef struct SConfig_RelayDataStruct Relay_WashMachineStruct *pRelayWashMachineStr; /*洗车机继电器结构体*/ Relay_DCAgreeStruct *pRelayDCAgreeStr;/*调车同意继电器结构体*/ Relay_ReverseCutStruct *pRelayReverseCutStr;/*倒切设备继电器结构体*/ + Relay_ReverseSwitchStruct* pRelayReverseSwitchStr; /*倒切开关继电器结构体*/ } RelayDataStruct_Config; /*继电器数组长度结构体*/ typedef struct S_RelayDataStructLen @@ -58,6 +59,7 @@ typedef struct S_RelayDataStructLen UINT16 RelayMonoRailPointStrLen ; /*单轨道岔继电器结构体数组长度*/ UINT16 RelayDCAgreeStrLen;/*调车同意继电器结构体数量*/ UINT16 RelayReverseCutStrLen;/*倒切设备继电器结构体数量*/ + UINT16 RelayReverseSwitchStrLen;/*倒切开关继电器结构体数量*/ } RelayDataStruct_ConfigLen; /*********定义全局的继电器信息数据变量*******/ @@ -173,5 +175,19 @@ UINT8 InitRelay_DCAgreeStru(CHAR* CIDataName); *********************************************/ UINT8 InitRelay_ReverseCutStru(CHAR* CIDataName); +/********************************************* +*函数功能：填充倒切开关继电器结构体数组---内部用 +*参数说明：CIDataName件指针 +*返回值：0，失败；1，成功 +*********************************************/ +UINT8 InitRelay_ReverseSwitchStru(CHAR* CIDataName); + +/********************************************* +*函数功能：填充倒切板卡继电器结构体数组---内部用 +*参数说明：CIDataName件指针 +*返回值：0，失败；1，成功 +*********************************************/ +UINT8 InitRelay_ReverseBoardStru(CHAR* CIDataName); + #endif diff --git a/TSCP/src/APP/ciapp/QueryFiles/dqucijdqstru.h b/TSCP/src/APP/ciapp/QueryFiles/dqucijdqstru.h index 960f9c0..6e70cc8 100644 --- a/TSCP/src/APP/ciapp/QueryFiles/dqucijdqstru.h +++ b/TSCP/src/APP/ciapp/QueryFiles/dqucijdqstru.h @@ -111,7 +111,7 @@ #define SWITCH_BOARD_MODE_MAX 5U /*一个OC中道岔最多的模块数*/ /*道岔继电器配置表*/ #define OC_SWITCH_RELAY_ID ((UINT8)4) -#define LEN_OC_SWITCH_RELAY ((UINT8)24) +#define LEN_OC_SWITCH_RELAY ((UINT8)28) /*信号机配置表*/ #define OC_SIGNAL_ID ((UINT8)5) #define LEN_OC_SIGNAL ((UINT8)24) @@ -201,6 +201,15 @@ /* 试灯继电器表 */ #define OC_RELAY_LIGHTTESTBUTTON_ID ((UINT8)39) +/*北京10倒切板卡采集需求*/ +#define OC_RELAY_REVERSE_SWITCH_ID ((UINT8)42)/*倒切开关*/ +#define OC_RELAY_REVERSE_BOARD_ID ((UINT8)43)/*倒切板卡*/ +#define OC_RELAY_REVERSE_BOARD_MAX ((UINT16)42)/*倒切板卡个数最大值*/ +#define OC_LEN_REVERSE_SWITCH_LEN ((UINT8)94) +#define OC_LEN_REVERSE_BOARD_LEN ((UINT8)9) +#define OC_LEN_REVERSE_TYPE_SWITCH ((UINT8)0x01) +#define OC_LEN_REVERSE_TYPE_PSD ((UINT8)0x10) + /*紧急停车按钮继电器结构体*/ typedef struct S_Relay_EmegencyStopStruct { @@ -275,10 +284,13 @@ typedef struct S_Relay_PhysicalSegmentStruct typedef struct S_Relay_PointStruct { UINT16 wPointId; /*道岔ID*/ + UINT16 wOcId; /*OC ID*/ UINT16 wRelayDingBiaoId; /*定表继电器ID*/ UINT16 wRelayFanBiaoId; /*反表继电器ID*/ - UINT16 wRelayShadowDingBiaoId; /*定表继电器ID*/ - UINT16 wRelayShadowFanBiaoId; /*反表继电器ID*/ + UINT16 wRelayRedunDB1Id; /*（北京10道岔冗余采集）定表继电器1ID*/ + UINT16 wRelayRedunDB2Id; /*（北京10道岔冗余采集）定表继电器2ID*/ + UINT16 wRelayRedunFB1Id; /*（北京10道岔冗余采集）反表继电器1ID*/ + UINT16 wRelayRedunFB2Id; /*（北京10道岔冗余采集）反表继电器2ID*/ UINT16 wRelayYunCaoId; /*允操继电器ID*/ UINT16 wRelayDingCaoId; /*定操继电器ID*/ UINT16 wRelayFanCaoId; /*反操继电器ID*/ @@ -482,4 +494,23 @@ typedef struct S_Relay_ReverseCutStruct UINT16 wReverseCutRelayId; /*倒切继电器ID*/ }Relay_ReverseCutStruct; +typedef struct S_Relay_ReverseBoardStruct +{ + UINT16 wReversBoardId; /*倒切板卡D*/ + UINT8 chDevType; /*设备类型*/ + UINT16 wDevId; /*板卡配置设备 ID*/ + UINT16 wBoardColOpenRelayId; /* 常开采集继电器ID */ + UINT16 wBoardColCloseRelayId; /* 常闭采集继电器ID */ +}Relay_ReverseBoardStruct; + +typedef struct S_Relay_ReverseSwitchStruct +{ + UINT16 wReversSwitchId; /*倒切开关ID*/ + UINT16 ocId; /*OC ID*/ + UINT16 wColOpenRelayId; /* 常开采集继电器ID */ + UINT16 wColCloseRelayId; /* 常闭采集继电器ID */ + UINT16 wRelateBoardNum; /*关联板卡个数*/ + Relay_ReverseBoardStruct strRelateBoardBuf[OC_RELAY_REVERSE_BOARD_MAX]; /*关联板卡数据*/ +}Relay_ReverseSwitchStruct; + #endif diff --git a/TSCP/src/APP/ciapp/Relay/RelayDefine.h b/TSCP/src/APP/ciapp/Relay/RelayDefine.h index e5246ec..771b7f1 100644 --- a/TSCP/src/APP/ciapp/Relay/RelayDefine.h +++ b/TSCP/src/APP/ciapp/Relay/RelayDefine.h @@ -97,6 +97,11 @@ #define SIGNAL_DXJ_TYPE ((UINT8)0x0A) /*DXJ继电器*/ #define CHECK_ZCJ_TYPE ((UINT8)0x0B) /*ZCJ继电器*/ #define SWITCH_IBP_TYPE ((UINT8)0x0C) /*IBP继电器*/ +#define SIGNAL_DJ_TYPE ((UINT8)0x0F) /*信号机灯丝继电器*/ +#define SIGNAL_MAINJ_TYPE ((UINT8)0x10) /*信号机主控继电器*/ +#define SIGNAL_ACKJ_TYPE ((UINT8)0x11) /*信号机次控继电器*/ +#define SINNAL_CMAINJ_TYPE ((UINT8)0x12) /*信号机复杂主控继电器*/ + /*继电器混线相关*/ #define RELAY_HUNXIAN_NUM ((UINT8)10) /*继电器混线容忍最大周期*/ diff --git a/TSCP/src/APP/ciapp/ReverseCut/ReverseCutConfigDataManage.c b/TSCP/src/APP/ciapp/ReverseCut/ReverseCutConfigDataManage.c index f268dd8..32fbe1b 100644 --- a/TSCP/src/APP/ciapp/ReverseCut/ReverseCutConfigDataManage.c +++ b/TSCP/src/APP/ciapp/ReverseCut/ReverseCutConfigDataManage.c @@ -10,12 +10,16 @@ ********************************************************/ #include "ReverseCutConfigDataManage.h" +#include "../Switch/SwitchConfigDataManage.h" +#include "../PSD/PSDConfigDataManage.h" ReverseCutCfgDataStru gstReverseCutCfgData[REVERSE_CUT_SUM_MAX] = { 0U }; /*定义倒切装置数据配置结构体*/ UINT16 gReverseCutCfgIdBuf[REVERSE_CUT_SUM_MAX] = { 0U }; /*定义倒切装置数据配置ID 缓存*/ INT16 gReverseCutCfgSum = 0; /*定义倒切装置数据配置总数 */ +ReverseSwitchCfgDataStru gLocalReverseData = { 0U };/*定义属于本联锁的倒切柜数据*/ + /* * 功能描述： 获取倒切装置当前总数 @@ -139,9 +143,13 @@ UINT8 ReverseCutConfigDataManage(void) UINT16 jj = 0u; /*游标*/ UINT16 wReverseCutDataSum = 0u; /*信号机设备配置数据总数*/ UINT8 ret = CI_ERROR; - UINT8 localCiId = GetSystemParaLocalCiId(); - - /*保存信号机ID索引数组*/ + UINT16 wDevId = 0u; + UINT16 wLocalSwitchSum = 0U;/*本地道岔*/ + UINT16 wLocalPsdSum = 0U;/*本地PSD*/ + UINT8 localCiId = GetSystemParaLocalCiId(); /*获取本机联锁ID*/ + UINT8 belongCiId = 0u;/*设备配置初始化所属联锁*/ + UINT8 chFind = CI_ERROR; + /*保存倒切ID索引数组*/ wReverseCutDataSum = GetReverseCutCurSum(); if (wReverseCutDataSum < REVERSE_CUT_SUM_MAX) {/*配置数据总数错误*/ @@ -163,6 +171,162 @@ UINT8 ReverseCutConfigDataManage(void) ret = CI_SUCCESS; } - return ret; + if (CI_SUCCESS == ret) + { + if (0U != gLocalReverseData.wId) + { + wLocalSwitchSum = GetSwitchCurSum(); + wLocalPsdSum = GetPsdSum(); + /*本联锁具备倒切*/ + for (ii = 0u; ii < gLocalReverseData.wRelateBoardNum; ii++) + { + chFind = CI_ERROR; + if (CI_DEVICE_TYPE_SWITCH == gLocalReverseData.strRelateBoardBuf[ii].chDevType) + { + for (jj = 0u; jj < wLocalSwitchSum; jj++) + { + wDevId = GetSwitchId(jj); /*获取道岔ID*/ + belongCiId = GetSwitchBelongCiId(wDevId); /*获取所属联锁ID*/ + if ((wDevId == gLocalReverseData.strRelateBoardBuf[ii].wDevId) && (belongCiId == localCiId)) + { + /*设置对应倒切继电器*/ + chFind = SetSwitchRelateReverseBoardId(wDevId, gLocalReverseData.strRelateBoardBuf[ii].wReversBoardId); + break; + } + } + } + else if (CI_DEVICE_TYPE_PSD == gLocalReverseData.strRelateBoardBuf[ii].chDevType) + { + for (jj = 0u; jj < wLocalPsdSum; jj++) + { + wDevId = GetPsdId(jj); /*获取屏蔽门ID*/ + belongCiId = GetPsdBelongCiId(wDevId); /*获取所属联锁ID*/ + if ((wDevId == gLocalReverseData.strRelateBoardBuf[ii].wDevId) && (belongCiId == localCiId)) + { + /*设置对应倒切继电器*/ + chFind = SetPsdRelateReverseRelay(wDevId, gLocalReverseData.strRelateBoardBuf[ii].wReversBoardId); + break; + } + } + } + else + { + chFind = CI_ERROR; + } + if (CI_ERROR == chFind) + { + ret = CI_ERROR; + break; + } + } + } + } + + return ret; +} + +/* +* 功能描述： 获取本集中区倒切开关常开继电器 +* 参数说明： 无 +* 返回值 ： 0: 无倒切 +* [1,65534]继电器ID +*/ +UINT16 GetReverseSwitchOpenRelay(void) +{ + return gLocalReverseData.wColOpenRelayId; +} + +/* +* 功能描述： 获取本集中区倒切开关常闭继电器 +* 参数说明： 无 +* 返回值 ： 0: 无倒切 +* [1,65534]继电器ID +*/ +UINT16 GetReverseSwitchCloseRelay(void) +{ + return gLocalReverseData.wColCloseRelayId; +} + +/* +* 功能描述： 获取本集中区指定索引倒切板卡常开继电器 +* 参数说明： wIndex 索引 +* 返回值 ： 0: 无倒切 +* [1,65534]继电器ID +* UINT16_MAX 错误 +*/ +UINT16 GetReverseBoardOpenRelay(UINT16 wIndex) +{ + UINT16 chRetVal =UINT16_MAX; + if (0U == gLocalReverseData.wRelateBoardNum) + { + chRetVal = 0U; + } + else if (wIndex < gLocalReverseData.wRelateBoardNum) + { + chRetVal = gLocalReverseData.strRelateBoardBuf[wIndex].wBoardColOpenRelayId; + } + else + { + ;/*错误*/ + } + return chRetVal; +} + +/* +* 功能描述： 获取本集中区指定索引倒切板卡常闭继电器 +* 参数说明： wIndex 索引 +* 返回值 ： 0: 无倒切 +* [1,65534]继电器ID +*/ +UINT16 GetReverseBoardCloseRelay(UINT16 wIndex) +{ + UINT16 chRetVal = UINT16_MAX; + if (0U == gLocalReverseData.wRelateBoardNum) + { + chRetVal = 0U; + } + else if (wIndex < gLocalReverseData.wRelateBoardNum) + { + chRetVal = gLocalReverseData.strRelateBoardBuf[wIndex].wBoardColCloseRelayId; + } + else + { + ;/*错误*/ + } + return chRetVal; +} + +/* +* 功能描述： 获取本集中区倒切板卡数量 +* 参数说明： 无 +* 返回值 ： 0: 无倒切 [1,42]板卡数量 +*/ +UINT16 GetReverseBoardNum(void) +{ + UINT16 chRetVal = 0U; + if (0U == gLocalReverseData.wRelateBoardNum) + { + chRetVal = 0U; + } + else if (REVERSE_BOARD_SUM_MAX >= gLocalReverseData.wRelateBoardNum) + { + chRetVal = gLocalReverseData.wRelateBoardNum; + } + else + { + chRetVal = REVERSE_BOARD_SUM_MAX; + } + return chRetVal; +} + +/** +* @brief 获取本集中区倒切配置数据 +* @param[in] 无 +* @return 本集中区倒切配置数据 +* @note by fan 20260610 +*/ +const ReverseSwitchCfgDataStru * GetReverseCfgData(void) +{ + return &gLocalReverseData; +} -} \ No newline at end of file diff --git a/TSCP/src/APP/ciapp/ReverseCut/ReverseCutConfigDataManage.h b/TSCP/src/APP/ciapp/ReverseCut/ReverseCutConfigDataManage.h index 32598fa..996c7ad 100644 --- a/TSCP/src/APP/ciapp/ReverseCut/ReverseCutConfigDataManage.h +++ b/TSCP/src/APP/ciapp/ReverseCut/ReverseCutConfigDataManage.h @@ -31,11 +31,34 @@ extern "C" { UINT16 wReverseRelayId; /*倒切继电器ID (配置数据)*/ }ReverseCutCfgDataStru; + typedef struct S_ReverseBoardStruct + { + UINT16 wReversBoardId; /*倒切板卡D*/ + UINT8 chDevType; /*设备类型*/ + UINT16 wDevId; /*板卡配置设备 ID*/ + UINT16 wBoardColOpenRelayId; /* 常开采集继电器ID */ + UINT16 wBoardColCloseRelayId; /* 常闭采集继电器ID */ + }ReverseBoardStruct; + + /*倒切开关及板卡配置数据结构体*/ + typedef struct S_ReverseSwitchDataStruct + { + UINT16 wId; /*倒切开关编号*/ + UINT16 wColOpenRelayId; /* 常开采集继电器ID */ + UINT16 wColCloseRelayId; /* 常闭采集继电器ID */ + UINT16 wRelateBoardNum; /*关联板卡个数*/ + UINT8 chBelongCiId;/*所属联锁*/ + ReverseBoardStruct strRelateBoardBuf[REVERSE_BOARD_SUM_MAX]; /*关联板卡数据*/ + }ReverseSwitchCfgDataStru; + + + + /*******************************全局变量声明*******************************/ extern ReverseCutCfgDataStru gstReverseCutCfgData[REVERSE_CUT_SUM_MAX]; /*定义倒切装置数据配置结构体*/ extern UINT16 gReverseCutCfgIdBuf[REVERSE_CUT_SUM_MAX]; /*定义倒切装置数据配置ID 缓存*/ extern INT16 gReverseCutCfgSum; /*定义倒切装置数据配置总数 */ - + extern ReverseSwitchCfgDataStru gLocalReverseData;/*定义属于本联锁的倒切柜数据*/ /* * 功能描述： 获取倒切装置当前总数 * 参数说明： void @@ -83,6 +106,54 @@ extern "C" { * CI_ERROR,整理失败 */ UINT8 ReverseCutConfigDataManage(void); + + /* + * 功能描述： 获取本集中区倒切开关常开继电器 + * 参数说明： 无 + * 返回值 ： 0: 无倒切 + * [1,65534]继电器ID + */ + UINT16 GetReverseSwitchOpenRelay(void); + + /* + * 功能描述： 获取本集中区倒切开关常闭继电器 + * 参数说明： 无 + * 返回值 ： 0: 无倒切 + * [1,65534]继电器ID + */ + UINT16 GetReverseSwitchCloseRelay(void); + + /* + * 功能描述： 获取本集中区指定索引倒切板卡常开继电器 + * 参数说明： wIndex 索引 + * 返回值 ： 0: 无倒切 + * [1,65534]继电器ID + * UINT16_MAX 错误 + */ + UINT16 GetReverseBoardOpenRelay(UINT16 wIndex); + + /* + * 功能描述： 获取本集中区指定索引倒切板卡常闭继电器 + * 参数说明： wIndex 索引 + * 返回值 ： 0: 无倒切 + * [1,65534]继电器ID + */ + UINT16 GetReverseBoardCloseRelay(UINT16 wIndex); + + /* + * 功能描述： 获取本集中区倒切板卡数量 + * 参数说明： 无 + * 返回值 ： 0: 无倒切 [1,42]板卡数量 + */ + UINT16 GetReverseBoardNum(void); + + /** + * @brief 获取本集中区倒切配置数据 + * @param[in] 无 + * @return 本集中区倒切配置数据 + * @note by fan 20260610 + */ + const ReverseSwitchCfgDataStru * GetReverseCfgData(void); #ifdef __cplusplus } #endif diff --git a/TSCP/src/APP/ciapp/ReverseCut/ReverseCutDataManage.c b/TSCP/src/APP/ciapp/ReverseCut/ReverseCutDataManage.c index 14ee6d2..d2528bd 100644 --- a/TSCP/src/APP/ciapp/ReverseCut/ReverseCutDataManage.c +++ b/TSCP/src/APP/ciapp/ReverseCut/ReverseCutDataManage.c @@ -16,6 +16,7 @@ ReverseCutDataStru gstReverseCutData[REVERSE_CUT_SUM_MAX] = { 0U }; /* UINT8 gTiocSystemMode = 0U; /*TIOC主机模式 (影子模式 主控模式)*/ UINT8 gTiocSystemCutState = 0U; /*TIOC能否倒切状态 (能否倒切或默认)*/ UINT8 gTiocCanntCutReason = 0U; /*不可倒切原因*/ +LocalReverseBoardDataStru gstReversetData = { 0U }; /*本集中区倒切状态存储、周期刷新*/ /* @@ -235,6 +236,78 @@ UINT8 ReverseCutDataManageInit(void) ;/* 初始化失败 */ } + if (CI_SUCCESS == ret) + { + /*初始化为非控制侧*/ + gstReversetData.chSwitchState = REVERSE_STATE_OLD_SYSTEM; + for (i = 0u; i < REVERSE_BOARD_SUM_MAX; i++) + { + gstReversetData.localReverBoardState[i] = REVERSE_STATE_OLD_SYSTEM; + } + } + return ret; +} +/* +* 功能描述： 设置倒切开关状态 +* 参数说明： const UINT8 chReverseCutState,倒切状态 0xAA新建 0x55既有 0xFF异常 +* 返回值 ： 无 +*/ +void SetReverseSwitchState(const UINT8 chReverseCutState) +{ + if ((REVERSE_STATE_NEW_SYSTEM == chReverseCutState) + || (REVERSE_STATE_OLD_SYSTEM == chReverseCutState) + ||(REVERSE_STATE_ABNORMAL == chReverseCutState)) + { + gstReversetData.chSwitchState = chReverseCutState; + } +} + +/* +* 功能描述： 设置指定索引倒切板卡状态 +* 参数说明： const UINT8 chReverseCutState,倒切状态0xAA新建 0x55既有 0xFF异常 wIndex索引 +* 返回值 ： 无 +*/ +void SetReverseBoardState(const UINT8 chReverseCutState, const UINT16 wIndex) +{ + if ((REVERSE_STATE_NEW_SYSTEM == chReverseCutState) + || (REVERSE_STATE_OLD_SYSTEM == chReverseCutState) + ||(REVERSE_STATE_ABNORMAL == chReverseCutState)) + { + if(wIndex < REVERSE_BOARD_SUM_MAX) + { + gstReversetData.localReverBoardState[wIndex] = chReverseCutState; + } + } +} + +/* +* 功能描述： 获取倒切开关状态 +* 参数说明： 无 +* 返回值 ：0xAA新建 0x55既有 0xFF异常 +*/ +UINT8 GetReverseSwitchState(void) +{ + UINT8 ret = gstReversetData.chSwitchState; + return ret; +} + +/* +* 功能描述： 获取指定ID指定索引倒切板卡状态 +* 参数说明： const UINT16 wBoardId,倒切板卡Id +* 返回值 ：0xAA新建 0x55既有 0xFF异常 +*/ +UINT8 GetReverseBoardState(const UINT16 wBoardId) +{ + UINT8 ret = REVERSE_STATE_ABNORMAL; + UINT16 jj = 0U;/*索引*/ + for (jj = 0U; jj < gLocalReverseData.wRelateBoardNum; jj++) + { + if (wBoardId == gLocalReverseData.strRelateBoardBuf[jj].wReversBoardId) + { + ret = gstReversetData.localReverBoardState[jj]; + break; + } + } return ret; } \ No newline at end of file diff --git a/TSCP/src/APP/ciapp/ReverseCut/ReverseCutDataManage.h b/TSCP/src/APP/ciapp/ReverseCut/ReverseCutDataManage.h index 3e9445e..c672e8e 100644 --- a/TSCP/src/APP/ciapp/ReverseCut/ReverseCutDataManage.h +++ b/TSCP/src/APP/ciapp/ReverseCut/ReverseCutDataManage.h @@ -30,6 +30,15 @@ extern "C" { UINT16 wReverseState; /*倒切状态*/ }ReverseCutDataStru; + /*倒切状态数据结构体*/ + typedef struct S_ReverseDataStruct + { + UINT8 chSwitchState; /*倒切开关状态*/ + UINT8 localReverBoardState[REVERSE_BOARD_SUM_MAX];/*倒切板卡状态数组*/ + }LocalReverseBoardDataStru; + + + /*******************************全局变量声明*******************************/ extern ReverseCutDataStru gstReverseCutData[REVERSE_CUT_SUM_MAX]; /*定义倒切装置数据动态数据结构体*/ extern UINT8 gTiocSystemMode; @@ -109,6 +118,34 @@ void SetReverseCutState(const UINT16 wReverseCutId, const UINT8 chReverseCutStat */ UINT8 ReverseCutDataManageInit(void); +/* +* 功能描述： 设置倒切开关状态 +* 参数说明： const UINT8 chReverseCutState,倒切状态 0xAA新建 0x55既有 0xFF异常 +* 返回值 ： 无 +*/ +void SetReverseSwitchState(const UINT8 chReverseCutState); + +/* +* 功能描述： 设置指定索引倒切板卡状态 +* 参数说明： const UINT8 chReverseCutState,倒切状态0xAA新建 0x55既有 0xFF异常 wIndex索引 +* 返回值 ： 无 +*/ +void SetReverseBoardState(const UINT8 chReverseCutState, const UINT16 wIndex); + +/* +* 功能描述： 获取倒切开关状态 +* 参数说明： 无 +* 返回值 ：0xAA新建 0x55既有 0xFF异常 +*/ +UINT8 GetReverseSwitchState(void); + +/* +* 功能描述： 获取指定ID指定索引倒切板卡状态 +* 参数说明： const UINT16 wBoardId,倒切板卡Id +* 返回值 ：0xAA新建 0x55既有 0xFF异常 +*/ +UINT8 GetReverseBoardState(const UINT16 wBoardId); + #ifdef __cplusplus } #endif diff --git a/TSCP/src/APP/ciapp/ReverseCut/ReverseCutDefine.h b/TSCP/src/APP/ciapp/ReverseCut/ReverseCutDefine.h index 0d4b91c..0758472 100644 --- a/TSCP/src/APP/ciapp/ReverseCut/ReverseCutDefine.h +++ b/TSCP/src/APP/ciapp/ReverseCut/ReverseCutDefine.h @@ -31,4 +31,12 @@ #define REVERSE_REASON_OC_COMM_ERR ((UINT8)0x01) /*不可倒切原因 OC通信故障*/ #define REVERSE_REASON_IVOC_COMM_ERR ((UINT8)0x02) /*不可倒切原因 IVOC通信故障*/ #define REVERSE_REASON_AXLE_COMM_ERR ((UINT8)0x04) /*不可倒切原因 计轴系统通信故障*/ + +/*倒切设备总数最大值*/ +#define REVERSE_BOARD_SUM_MAX ((UINT16)42) /*定义倒切板卡最大值*/ + +/*倒切状态*/ +#define REVERSE_STATE_NEW_SYSTEM ((UINT8)0xAAU) /*新建系统侧*/ +#define REVERSE_STATE_OLD_SYSTEM ((UINT8)0x55U) /*既有系统侧*/ +#define REVERSE_STATE_ABNORMAL ((UINT8)0xFFU) /*采集异常*/ #endif \ No newline at end of file diff --git a/TSCP/src/APP/ciapp/Route/RouteConfigDataManage.c b/TSCP/src/APP/ciapp/Route/RouteConfigDataManage.c index c23eb69..6d1f390 100644 --- a/TSCP/src/APP/ciapp/Route/RouteConfigDataManage.c +++ b/TSCP/src/APP/ciapp/Route/RouteConfigDataManage.c @@ -3726,4 +3726,76 @@ UINT8 GetRouteConfigDirection(const UINT16 routeId) retVal = CI_ERROR; } return retVal; +} + +/* +* 功能描述： 获取进路联络线属性 +* 参数说明： const UINT16 wRouteId, 进路ID +* 返回值 ： 进路联络线属性 +* +* BY LYJ 20260602 +*/ +UINT8 GetRouteConnectType(const UINT16 wRouteId) +{ + UINT8 chRetVal = 0U; + UINT16 bufIndex = 0U; + bufIndex = GetRouteConfigBufIndex(wRouteId); /*获取进路数组下标*/ + + if (ROUTE_SUM_MAX > bufIndex) + { + chRetVal = RouteConfigDataStru[bufIndex].chRouteConnectType; + } + else + { + /*不处理*/ + } + + return chRetVal; +} + +/* +* 功能描述： 获取进路指定区段的前一个区段 +* 参数说明： const UINT16 wRouteId, 进路ID +* const UINT16 wPhySecId,物理区段ID +* 返回值 ： 进路指定区段的前一个区段 +* +* BY LYJ 20260603 +*/ +UINT16 GetRoutePhySecFrontPhyId(const UINT16 wRouteId, const UINT16 wPhySecId) +{ + UINT16 wFroutPhySecId = 0U; + UINT8 chRoutePhySum = 0U; + RoutePhysicalSectionStruct* pRoutePhyBuf = NULL; + UINT8 ii = 0U; + + chRoutePhySum = GetRoutePhysicalSectionSum(wRouteId); + pRoutePhyBuf = GetRouteSectionData(wRouteId); + if (NULL != pRoutePhyBuf) + { + for (ii = 0U;ii < chRoutePhySum;ii++) + { + if (pRoutePhyBuf[ii].PhysicalSectionId == wPhySecId) + { + if (0U < ii) + { + wFroutPhySecId = pRoutePhyBuf[ii - 1U].PhysicalSectionId; + } + else + { + /*进路第一个区段属于邻线，进路是邻线，不在本线处理*/ + } + break; + } + else + { + /*不处理*/ + } + } + } + else + { + /*不处理*/ + } + + return wFroutPhySecId; } \ No newline at end of file diff --git a/TSCP/src/APP/ciapp/Route/RouteConfigDataManage.h b/TSCP/src/APP/ciapp/Route/RouteConfigDataManage.h index 76ee4e4..1ec65ce 100644 --- a/TSCP/src/APP/ciapp/Route/RouteConfigDataManage.h +++ b/TSCP/src/APP/ciapp/Route/RouteConfigDataManage.h @@ -317,6 +317,7 @@ typedef struct S_RouteConfigDataStruct UINT8 cRouteRukuProperty; /*是否为入库进路：0x55 入库进路；0xaa 非入库进路*/ SideProtecGroupStru RouteSideProtecData;/*进路侧防条件*/ UINT8 chRouteCouplinkType; /*进路联挂属性：0x55 配置联挂属性；0xaa 未配置联挂属性*/ + UINT8 chRouteConnectType; /*进路联络线属性：0x55 配置联络线属性；0xaa 未配置联络线属性*/ }RouteConfigDataStruct; /*******************************全局变量声明*******************************/ @@ -1427,6 +1428,23 @@ UINT8 GetPhySecInRoutePosIndex(const UINT16 routeId, const UINT16 phySectionId); ** by LYJ 20260330 */ UINT8 GetRouteConfigDirection(const UINT16 routeId); +/* +* 功能描述： 获取进路联络线属性 +* 参数说明： const UINT16 wRouteId, 进路ID +* 返回值 ： 进路联络线属性 +* +* BY LYJ 20260602 +*/ +UINT8 GetRouteConnectType(const UINT16 wRouteId); +/* +* 功能描述： 获取进路指定区段的前一个区段 +* 参数说明： const UINT16 wRouteId, 进路ID +* const UINT16 wPhySecId,物理区段ID +* 返回值 ： 进路指定区段的前一个区段 +* +* BY LYJ 20260603 +*/ +UINT16 GetRoutePhySecFrontPhyId(const UINT16 wRouteId, const UINT16 wPhySecId); #ifdef __cplusplus } diff --git a/TSCP/src/APP/ciapp/Route/RouteDataManage.c b/TSCP/src/APP/ciapp/Route/RouteDataManage.c index 52f5ef6..1b0f6a4 100644 --- a/TSCP/src/APP/ciapp/Route/RouteDataManage.c +++ b/TSCP/src/APP/ciapp/Route/RouteDataManage.c @@ -6192,4 +6192,54 @@ UINT32 GetRouteIdleCycNum(const UINT16 routeId) } return reVal; +} + +/* +* 功能描述：设置指定进路联络线解锁标志 +* 参数说明：const UINT16 routeId 需设置的进路ID +* const UINT8 setFlag 需设置标志 +* 返 回 值：无 +* Created lyj 2026.06.03 +*/ +void SetRouteConnectReleaseFlag(const UINT16 routeId, const UINT8 setFlag) +{ + UINT16 bufIndex = 0U; /*数组下标*/ + bufIndex = GetRouteConfigBufIndex(routeId); /*获取进路数组下标*/ + if (ROUTE_SUM_MAX > bufIndex) + { + if ((ROUTE_CONNECT_RELEASE_YES == setFlag) || (ROUTE_CONNECT_RELEASE_NO == setFlag)) + { + RouteDataStru[bufIndex].chRouteConnReleaseFlag = setFlag; + } + else + { + /*不处理*/ + } + } + else + { + /*不处理*/ + } +} +/* +* 功能描述：获取指定进路联络线解锁标志 +* 参数说明：const UINT16 routeId 进路ID +* 返 回 值：进路联络线解锁标志 +* Created lyj 2026.06.03 +*/ +UINT8 GetRouteConnectReleaseFlag(const UINT16 routeId) +{ + UINT16 bufIndex = 0U; /*数组下标*/ + UINT8 chRetVal = ROUTE_CONNECT_RELEASE_NO; + bufIndex = GetRouteConfigBufIndex(routeId); /*获取进路数组下标*/ + if (ROUTE_SUM_MAX > bufIndex) + { + chRetVal = RouteDataStru[bufIndex].chRouteConnReleaseFlag; + } + else + { + /*不处理*/ + } + + return chRetVal; } \ No newline at end of file diff --git a/TSCP/src/APP/ciapp/Route/RouteDataManage.h b/TSCP/src/APP/ciapp/Route/RouteDataManage.h index 4db2edf..e43273f 100644 --- a/TSCP/src/APP/ciapp/Route/RouteDataManage.h +++ b/TSCP/src/APP/ciapp/Route/RouteDataManage.h @@ -113,6 +113,7 @@ typedef struct S_RouteDataStruct UINT8 chCouplinkSuccessFlag; /*进路联挂成功*/ UINT8 chCouplinkErrorFlag; /*进路联挂失败*/ UINT32 dwRouteIdleCycNum; /*进路空闲起始周期号*/ + UINT8 chRouteConnReleaseFlag; /*进路联络线解锁标志*/ } RouteDataStruct; /*进路动态数据结构体-车车*/ @@ -1787,6 +1788,21 @@ void SetRouteStopensureFlagCC(const UINT16 routeId, const UINT8 stopensureFlag); * by cgh 20251210 */ UINT32 GetRouteIdleCycNum(const UINT16 routeId); +/* +* 功能描述：设置指定进路联络线解锁标志 +* 参数说明：const UINT16 routeId 需设置的进路ID +* const UINT8 setFlag 需设置标志 +* 返 回 值：无 +* Created lyj 2026.06.03 +*/ +void SetRouteConnectReleaseFlag(const UINT16 routeId, const UINT8 setFlag); +/* +* 功能描述：获取指定进路联络线解锁标志 +* 参数说明：const UINT16 routeId 进路ID +* 返 回 值：进路联络线解锁标志 +* Created lyj 2026.06.03 +*/ +UINT8 GetRouteConnectReleaseFlag(const UINT16 routeId); #ifdef __cplusplus } diff --git a/TSCP/src/APP/ciapp/Route/RouteDefine.h b/TSCP/src/APP/ciapp/Route/RouteDefine.h index 3720948..94922e3 100644 --- a/TSCP/src/APP/ciapp/Route/RouteDefine.h +++ b/TSCP/src/APP/ciapp/Route/RouteDefine.h @@ -100,6 +100,7 @@ #define ROUTE_TYPE_AUTO_TRIGGER ((UINT8)0x66) /*自动触发进路*/ #define ROUTE_TYPE_RUKU ((UINT8)0x77) /*入库进路*/ #define ROUTE_TYPE_COUPLINK ((UINT8)0x88) /*联挂进路*/ +#define ROUTE_TYPE_CONNECT ((UINT8)0x99) /*联络线进路*/ /*进路状态*/ #define ROUTE_STATE_IDLE ((UINT8)0x01) /*进路空闲*/ @@ -401,5 +402,10 @@ #define SIDE_PROTECT_SWITCH_NUM_MAX ((UINT8)5) /*侧防道岔数量*/ #define SIDE_PROTECT_PHYSEC_NUM_MAX ((UINT8)10) /*侧防物理区段数量*/ #define SIDE_PROTECT_NUM_MAX ((UINT8)10) /*侧防条件数量*/ + + +#define ROUTE_CONNECT_RELEASE_YES ((UINT8)0x55) /*进路联络线解锁标志有效*/ +#define ROUTE_CONNECT_RELEASE_NO ((UINT8)0xaa) /*进路联络线解锁标志无效*/ + #endif diff --git a/TSCP/src/APP/ciapp/Section/LogicSectionDataManage.c b/TSCP/src/APP/ciapp/Section/LogicSectionDataManage.c index d39455f..3525814 100644 --- a/TSCP/src/APP/ciapp/Section/LogicSectionDataManage.c +++ b/TSCP/src/APP/ciapp/Section/LogicSectionDataManage.c @@ -2812,7 +2812,7 @@ UINT8 GetLogSecResShareFlag(const UINT16 wLgcSecId) /*返回错误*/ funRetVal = CI_ERROR; } - return LOGIC_SECTION_RES_SHARE_YES; + return funRetVal; } /* diff --git a/TSCP/src/APP/ciapp/Section/SectionDefine.h b/TSCP/src/APP/ciapp/Section/SectionDefine.h index 6516f2b..336405b 100644 --- a/TSCP/src/APP/ciapp/Section/SectionDefine.h +++ b/TSCP/src/APP/ciapp/Section/SectionDefine.h @@ -18,7 +18,7 @@ #define PHYSICAL_SECTION_SUM_MAX ((UINT16)1000) /*定义物理区段数量最大值*/ #define AXIS_SECTION_SUM_MAX ((UINT16)2000) /*定义计轴区段数量最大值*/ #define AXIS_INCLUDE_LOG_SUM_MAX ((UINT16)50) /*定义计轴包含逻辑区段数量最大值*/ -#define LOGIC_SECTION_SUM_MAX ((UINT16)2000) /*定义逻辑区段数量最大值*/ +#define LOGIC_SECTION_SUM_MAX ((UINT16)3000) /*定义逻辑区段数量最大值*/ #define PHYSICAL_INCLUDE_AXIS_SUM_MAX ((UINT16)10) /*定义物理区段包含计轴区段数量最大值*/ #define AXIS_INCLUDE_SWITCH_SUM_MAX ((UINT16)4) /*定义计轴区段包含的道岔数量最大值*/ #define AXIS_INCLUDE_LINK_SUM_MAX ((UINT16)5) /*定义计轴区段包含的LINK最大值*/ diff --git a/TSCP/src/APP/ciapp/Signal/SignalConfigDataManage.c b/TSCP/src/APP/ciapp/Signal/SignalConfigDataManage.c index a193dab..fe397c1 100644 --- a/TSCP/src/APP/ciapp/Signal/SignalConfigDataManage.c +++ b/TSCP/src/APP/ciapp/Signal/SignalConfigDataManage.c @@ -1888,4 +1888,93 @@ UINT16 GetSignalOutFirstLogSec(const UINT16 signalId) } } return retVal; -} \ No newline at end of file +} + +/* +* 功能描述： 获取指定ID信号机1灯丝驱动继电器ID（联络线使用） +* 参数说明： const UINT16 signalId, 信号机ID +* 返回值 ： 0: 获取数据失败 +* >0: 信号1灯丝驱动继电器ID +*/ +UINT16 GetSignalFirstDsDrvRelayId(const UINT16 signalId) +{ + UINT16 bufIndex = 0U; /*数组下标*/ + UINT16 retVal = CI_ERROR; + + bufIndex = GetSignalConfigBufIndex(signalId); /*获取区段数组下标*/ + if (SIGNAL_SUM_MAX > bufIndex) + { + retVal = SignalConfigDataStru[bufIndex].wFirstDsDrvRelayId; + } + else + { + retVal = CI_ERROR; + } + return retVal; +} +/* +* 功能描述： 获取指定ID信号机主控驱动继电器ID（联络线使用） +* 参数说明： const UINT16 signalId, 信号机ID +* 返回值 ： 0: 获取数据失败 +* >0: 信号主控驱动继电器ID +*/ +UINT16 GetSignalMainDrvRelayId(const UINT16 signalId) +{ + UINT16 bufIndex = 0U; /*数组下标*/ + UINT16 retVal = CI_ERROR; + + bufIndex = GetSignalConfigBufIndex(signalId); /*获取区段数组下标*/ + if (SIGNAL_SUM_MAX > bufIndex) + { + retVal = SignalConfigDataStru[bufIndex].wMainDrvRelayId; + } + else + { + retVal = CI_ERROR; + } + return retVal; +} +/* +* 功能描述： 获取指定ID信号机次控驱动继电器ID（联络线使用） +* 参数说明： const UINT16 signalId, 信号机ID +* 返回值 ： 0: 获取数据失败 +* >0: 信号次控驱动继电器ID +*/ +UINT16 GetSignalAckDrvRelayId(const UINT16 signalId) +{ + UINT16 bufIndex = 0U; /*数组下标*/ + UINT16 retVal = CI_ERROR; + + bufIndex = GetSignalConfigBufIndex(signalId); /*获取区段数组下标*/ + if (SIGNAL_SUM_MAX > bufIndex) + { + retVal = SignalConfigDataStru[bufIndex].wAckDrvRelayId; + } + else + { + retVal = CI_ERROR; + } + return retVal; +} +/* +* 功能描述： 获取指定ID信号机复杂主控驱动继电器ID（联络线使用） +* 参数说明： const UINT16 signalId, 信号机ID +* 返回值 ： 0: 获取数据失败 +* >0: 信号复杂主控驱动继电器ID +*/ +UINT16 GetSignalCMainDrvRelayId(const UINT16 signalId) +{ + UINT16 bufIndex = 0U; /*数组下标*/ + UINT16 retVal = CI_ERROR; + + bufIndex = GetSignalConfigBufIndex(signalId); /*获取区段数组下标*/ + if (SIGNAL_SUM_MAX > bufIndex) + { + retVal = SignalConfigDataStru[bufIndex].wCMainDrvRelayId; + } + else + { + retVal = CI_ERROR; + } + return retVal; +} diff --git a/TSCP/src/APP/ciapp/Signal/SignalConfigDataManage.h b/TSCP/src/APP/ciapp/Signal/SignalConfigDataManage.h index 80a0591..71585b7 100644 --- a/TSCP/src/APP/ciapp/Signal/SignalConfigDataManage.h +++ b/TSCP/src/APP/ciapp/Signal/SignalConfigDataManage.h @@ -102,6 +102,11 @@ typedef struct S_SignalConfigDataStruct UINT16 LxDrvRelayId; /*列车信号驱动继电器ID(配置字段-联络线使用)*/ UINT16 YxDrvRelayId; /*引导信号驱动继电器ID(配置字段-联络线使用)*/ UINT16 DxDrvRelayId; /*调车信号驱动继电器ID(配置字段-联络线使用)*/ + UINT16 wFirstDsDrvRelayId; /*1灯丝驱动继电器ID(配置字段-联络线使用)*/ + UINT16 wMainDrvRelayId; /*信号机主控驱动继电器ID(配置字段-联络线使用)*/ + UINT16 wAckDrvRelayId; /*信号机次控驱动继电器ID(配置字段-联络线使用)*/ + UINT16 wCMainDrvRelayId; /*信号机复杂主控驱动继电器ID(配置字段-联络线使用)*/ + } SignalConfigDataStruct; typedef struct S_OC_SignalConfigDataStruct @@ -744,6 +749,34 @@ UINT16 GetSignalDxDrvRelayId(const UINT16 signalId); * >0: 逻辑区段ID */ UINT16 GetSignalOutFirstLogSec(const UINT16 signalId); +/* +* 功能描述： 获取指定ID信号机1灯丝驱动继电器ID（联络线使用） +* 参数说明： const UINT16 signalId, 信号机ID +* 返回值 ： 0: 获取数据失败 +* >0: 信号1灯丝驱动继电器ID +*/ +UINT16 GetSignalFirstDsDrvRelayId(const UINT16 signalId); +/* +* 功能描述： 获取指定ID信号机主控驱动继电器ID（联络线使用） +* 参数说明： const UINT16 signalId, 信号机ID +* 返回值 ： 0: 获取数据失败 +* >0: 信号主控驱动继电器ID +*/ +UINT16 GetSignalMainDrvRelayId(const UINT16 signalId); +/* +* 功能描述： 获取指定ID信号机次控驱动继电器ID（联络线使用） +* 参数说明： const UINT16 signalId, 信号机ID +* 返回值 ： 0: 获取数据失败 +* >0: 信号次控驱动继电器ID +*/ +UINT16 GetSignalAckDrvRelayId(const UINT16 signalId); +/* +* 功能描述： 获取指定ID信号机复杂主控驱动继电器ID（联络线使用） +* 参数说明： const UINT16 signalId, 信号机ID +* 返回值 ： 0: 获取数据失败 +* >0: 信号复杂主控驱动继电器ID +*/ +UINT16 GetSignalCMainDrvRelayId(const UINT16 signalId); #ifdef __cplusplus } diff --git a/TSCP/src/APP/ciapp/Signal/SignalDataManage.c b/TSCP/src/APP/ciapp/Signal/SignalDataManage.c index 6af206e..1971e01 100644 --- a/TSCP/src/APP/ciapp/Signal/SignalDataManage.c +++ b/TSCP/src/APP/ciapp/Signal/SignalDataManage.c @@ -5791,4 +5791,71 @@ void SetSignalCrossStateCC(const UINT16 signalId, const UINT8 signalCrossState, { /*不处理*/ } +} + +/* +* 功能描述：获取复杂主控继电器驱动状态 +* 参数说明：const UINT16 wCMainlRralyId, 继电器ID +* const UINT16 wSignalId, 信号机ID +* 返 回 值：驱动状态 +* Created LYJ 2026.6.2 +*/ +UINT8 GetCMainRelayDriveState(const UINT16 wCMainlRralyId, const UINT16 wSignalId) +{ + UINT8 chRet = CI_ERROR; + UINT16 wSigOutPhyId = 0U; + UINT16 wSigInPhyId = 0U; + UINT16 wLockRouteId = 0U; + UINT8 chOccState = 0U; + UINT8 chLockState = 0U; + UINT8 chFengSuoState = 0U; + UINT8 chJLockState = 0U; + UINT16 wQXzhaochaRelay = 0U; + UINT8 chColleState = 0U; + + if ((0U < wCMainlRralyId) && (RELAY_SUM_MAX > wCMainlRralyId)) + { + wSigOutPhyId = GetSignalOutFirstPhySecId(wSignalId); /*信号机外方区段*/ + chOccState = GetPhySecCurMergeState(wSigOutPhyId); /*占用状态*/ + chLockState = GetPhySecLockState(wSigOutPhyId); /*锁闭状态*/ + chFengSuoState = GetPhySecFLockState(wSigOutPhyId); /*封锁状态*/ + chJLockState = GetPhySecJumpLockState(wSigOutPhyId); /*跳跃锁闭状态*/ + /*信号机外方区段，未锁闭，未占用，未封锁*/ + if ((SECTION_OCCUPY_NO == chOccState) && (PHYSICAL_SECTION_LOCK_NO == chLockState) + && (PHYSICAL_SECTION_FLOCK_NO == chFengSuoState) && (PHYSICAL_SECTION_JUMP_LOCK_NO == chJLockState)) + { + wSigInPhyId = GetSignalInFirstPhySecId(wSignalId,0U); /*信号机内方区段*/ + wLockRouteId = GetPhySecRLockBelongRouteId(wSigInPhyId); /*锁闭所属进路*/ + wQXzhaochaRelay = GetRouteCancleZhaoChaRelayId(wLockRouteId); /*进路配置的取消照查继电器*/ + + /*信号机为始端的进路 配置的取消照查继电器落下*/ + if ((0U < wQXzhaochaRelay) && (RELAY_SUM_MAX > wQXzhaochaRelay)) + { + chColleState = GetRelayCollState(wQXzhaochaRelay); + if (RELAY_STATE_DOWN == chColleState) + { + chRet = CI_SUCCESS; + } + else + { + /*不处理*/ + } + } + else + { + /*不处理*/ + } + } + else + { + /*不处理*/ + } + + } + else + { + /*不处理*/ + } + + return chRet; } \ No newline at end of file diff --git a/TSCP/src/APP/ciapp/Signal/SignalDataManage.h b/TSCP/src/APP/ciapp/Signal/SignalDataManage.h index e426e20..7a8f931 100644 --- a/TSCP/src/APP/ciapp/Signal/SignalDataManage.h +++ b/TSCP/src/APP/ciapp/Signal/SignalDataManage.h @@ -1248,6 +1248,14 @@ UINT8 GetSignalCrossTacsTrainIdCC(const UINT16 signalId); * Created By LQ 2025.11.05 */ void SetSignalCrossStateCC(const UINT16 signalId, const UINT8 signalCrossState, const UINT8 wTrainId); +/* +* 功能描述：获取复杂主控继电器驱动状态 +* 参数说明：const UINT16 wCMainlRralyId, 信号机ID +* const UINT16 wSignalId, 信号机ID +* 返 回 值：驱动状态 +* Created LYJ 2026.6.2 +*/ +UINT8 GetCMainRelayDriveState(const UINT16 wCMainlRralyId, const UINT16 wSignalId); #ifdef __cplusplus } diff --git a/TSCP/src/APP/ciapp/Switch/SwitchConfigDataManage.c b/TSCP/src/APP/ciapp/Switch/SwitchConfigDataManage.c index 171097d..f8e1f07 100644 --- a/TSCP/src/APP/ciapp/Switch/SwitchConfigDataManage.c +++ b/TSCP/src/APP/ciapp/Switch/SwitchConfigDataManage.c @@ -46,7 +46,7 @@ UINT16 GetSwitchCurSum(void) UINT16 retVal = 0u; if (SwitchCurSum >= (INT16)SWITCH_SUM_MAX) { - retVal = SWITCH_SUM_MAX; + retVal = SWITCH_SUM_MAX; } else if (SwitchCurSum < 0) { @@ -227,31 +227,6 @@ UINT16 GetSwitchDbRelayId(const UINT16 switchId) return retVal; } -/* -* 功能描述： 获取指定ID道岔影子模式定位表示继电器ID -* 参数说明： const UINT16 switchId, 道岔ID -* 返回值 ： 0: 获取数据失败 -* >0: 定位表示继电器ID -*/ -UINT16 GetSwitchShadowDbRelayId(const UINT16 switchId) -{ - UINT16 bufIndex = 0u; /*数组下标*/ - UINT16 retVal = CI_ERROR; - - bufIndex = GetSwitchConfigBufIndex(switchId); /*获取道岔数组下标*/ - - if (bufIndex < SWITCH_SUM_MAX) - { - retVal = SwitchConfigDataStru[bufIndex].wShadowDbRelayId; - } - else - { - retVal = CI_ERROR; - } - return retVal; -} - - /* * 功能描述： 获取指定ID道岔反位表示继电器ID * 参数说明： const UINT16 switchId, 道岔ID @@ -276,31 +251,6 @@ UINT16 GetSwitchFbRelayId(const UINT16 switchId) return retVal; } -/* -* 功能描述： 获取指定ID道岔影子模式反位表示继电器ID -* 参数说明： const UINT16 switchId, 道岔ID -* 返回值 ： 0: 获取数据失败 -* >0: 反位表示继电器ID -*/ -UINT16 GetSwitchShadowFbRelayId(const UINT16 switchId) -{ - UINT16 bufIndex = 0u; /*数组下标*/ - UINT16 retVal = CI_ERROR; - - bufIndex = GetSwitchConfigBufIndex(switchId); /*获取道岔数组下标*/ - - if (bufIndex < SWITCH_SUM_MAX) - { - retVal = SwitchConfigDataStru[bufIndex].wShadowFbRelayId; - } - else - { - retVal = CI_ERROR; - } - return retVal; -} - - /* * 功能描述： 获取指定ID道岔允操继电器ID * 参数说明： const UINT16 switchId, 道岔ID @@ -1762,3 +1712,172 @@ UINT16 GetSwitchThisOcOtherSwitchId(UINT16 switchId, UINT8 ocId) return retVal; } +/* +* 功能描述：获取指定ID道岔是否具备冗余采集 +* 参数说明：const UINT16 switchId, 道岔ID +* 返回值 ：REDUN_COLL_YES: 具备道岔冗余采集 +* REDUN_COLL_NO: 不具备道岔冗余采集 +* CI_ERROR: ID有误 +*/ +UINT8 GetSwitchRedunCollCfg(const UINT16 switchId) +{ + UINT16 bufIndex = 0u; /*数组下标*/ + UINT8 retVal = CI_ERROR; + + bufIndex = GetSwitchConfigBufIndex(switchId); /*获取道岔数组下标*/ + + if (SWITCH_SUM_MAX > bufIndex) + { + retVal = SwitchConfigDataStru[bufIndex].RedunCollCfg; + } + else + { + retVal = CI_ERROR; + } + return retVal; +} + +/* +* 功能描述：获取指定ID道岔的冗余表示DBJ1继电器ID +* 参数说明：const UINT16 switchId, 道岔ID +* 返回值 ：0: ID有误 +* 其他：继电器ID +*/ +UINT16 GetSwitchRedunDBJ1RelayId(const UINT16 switchId, const UINT16 ocIndex) +{ + UINT16 bufIndex = 0u; /*数组下标*/ + UINT16 retVal = 0u; + + bufIndex = GetSwitchConfigBufIndex(switchId); /*获取道岔数组下标*/ + + if ((SWITCH_SUM_MAX > bufIndex) && (SWITCH_REDUN_COLL_MAX > ocIndex)) + { + retVal = SwitchConfigDataStru[bufIndex].RedunCollRelayStru[ocIndex].wRedunDb1RelayId; + } + else + { + retVal = 0u; + } + return retVal; +} + +/* +* 功能描述：获取指定ID道岔的冗余表示DBJ2继电器ID +* 参数说明：const UINT16 switchId, 道岔ID +* 返回值 ：0: ID有误 +* 其他：继电器ID +*/ +UINT16 GetSwitchRedunDBJ2RelayId(const UINT16 switchId, const UINT16 ocIndex) +{ + UINT16 bufIndex = 0u; /*数组下标*/ + UINT16 retVal = 0u; + + bufIndex = GetSwitchConfigBufIndex(switchId); /*获取道岔数组下标*/ + + if ((SWITCH_SUM_MAX > bufIndex) && (SWITCH_REDUN_COLL_MAX > ocIndex)) + { + retVal = SwitchConfigDataStru[bufIndex].RedunCollRelayStru[ocIndex].wRedunDb2RelayId; + } + else + { + retVal = 0u; + } + return retVal; +} + +/* +* 功能描述：获取指定ID道岔的冗余表示FBJ1继电器ID +* 参数说明：const UINT16 switchId, 道岔ID +* 返回值 ：0: ID有误 +* 其他：继电器ID +*/ +UINT16 GetSwitchRedunFBJ1RelayId(const UINT16 switchId, const UINT16 ocIndex) +{ + UINT16 bufIndex = 0u; /*数组下标*/ + UINT16 retVal = 0u; + + bufIndex = GetSwitchConfigBufIndex(switchId); /*获取道岔数组下标*/ + + if ((SWITCH_SUM_MAX > bufIndex) && (SWITCH_REDUN_COLL_MAX > ocIndex)) + { + retVal = SwitchConfigDataStru[bufIndex].RedunCollRelayStru[ocIndex].wRedunFb1RelayId; + } + else + { + retVal = 0u; + } + return retVal; +} + +/* +* 功能描述：获取指定ID道岔的冗余表示FBJ2继电器ID +* 参数说明：const UINT16 switchId, 道岔ID +* 返回值 ：0: ID有误 +* 其他：继电器ID +*/ +UINT16 GetSwitchRedunFBJ2RelayId(const UINT16 switchId, const UINT16 ocIndex) +{ + UINT16 bufIndex = 0u; /*数组下标*/ + UINT16 retVal = 0u; + + bufIndex = GetSwitchConfigBufIndex(switchId); /*获取道岔数组下标*/ + + if ((SWITCH_SUM_MAX > bufIndex) && (SWITCH_REDUN_COLL_MAX > ocIndex)) + { + retVal = SwitchConfigDataStru[bufIndex].RedunCollRelayStru[ocIndex].wRedunFb2RelayId; + } + else + { + retVal = 0u; + } + return retVal; +} + +/* +* 功能描述： 设置倒切板卡 +* 参数说明： const UINT16 switchId, 道岔ID，UINT16 wBoardId倒切板卡Id +* 返回值 ： CI_SUCCESS CI_ERROR +*/ +UINT8 SetSwitchRelateReverseBoardId(const UINT16 switchId, UINT16 wBoardId) +{ + UINT16 bufIndex = 0u; /*数组下标*/ + UINT8 chRet = CI_ERROR; + bufIndex = GetSwitchConfigBufIndex(switchId); /*获取道岔数组下标*/ + + if (bufIndex < SWITCH_SUM_MAX) + { + SwitchConfigDataStru[bufIndex].wReverseBoardId = wBoardId; + chRet = CI_SUCCESS; + } + else + { + ; + } + return chRet; +} + +/* +* 功能描述： 获取倒切板卡id +* 参数说明： const UINT16 switchId, 道岔ID +* 返回值 ： UINT16_MAX: 获取数据失败 +* 0: 无倒切 +* [1,65534]倒切板卡Id +*/ +UINT16 GetSwitchRelateReverseBoardId(const UINT16 switchId) +{ + UINT16 bufIndex = 0u; /*数组下标*/ + UINT16 retVal = UINT16_MAX; + + bufIndex = GetSwitchConfigBufIndex(switchId); /*获取道岔数组下标*/ + + if (bufIndex < SWITCH_SUM_MAX) + { + retVal = SwitchConfigDataStru[bufIndex].wReverseBoardId; + } + else + { + retVal = UINT16_MAX; + } + return retVal; +} + diff --git a/TSCP/src/APP/ciapp/Switch/SwitchConfigDataManage.h b/TSCP/src/APP/ciapp/Switch/SwitchConfigDataManage.h index 0d9219b..2bb12c3 100644 --- a/TSCP/src/APP/ciapp/Switch/SwitchConfigDataManage.h +++ b/TSCP/src/APP/ciapp/Switch/SwitchConfigDataManage.h @@ -33,6 +33,15 @@ typedef struct S_ZzjPowerConfigDataStruct UINT16 ZzjFanweiPower2; /*转辙机J1反表灯_供电2*/ }ZzjPowerConfigDataStruct; +typedef struct S_SwitchRedunCollCfgDataStru +{ + UINT16 wRedunDb1RelayId; /*（北京10道岔冗余采集）道岔定表继电器1ID*/ + UINT16 wRedunDb2RelayId; /*（北京10道岔冗余采集）道岔定表继电器2ID*/ + UINT16 wRedunFb1RelayId; /*（北京10道岔冗余采集）道岔反表继电器1ID*/ + UINT16 wRedunFb2RelayId; /*（北京10道岔冗余采集）道岔反表继电器2ID*/ +} +SwitchRedunCollCfgDataStru; + typedef struct S_SwitchBelongOCConfigDataStr/*道岔所属OC配置数据*/ { UINT8 OcId; /*当前OC*/ @@ -59,8 +68,6 @@ typedef struct S_SwitchConfigDataStruct UINT16 FbRelayId; /*道岔反表继电器ID (配置字段) 即单开反表表示继电器ID*/ UINT16 YcRelayId; /*道岔允操继电器ID (配置字段) 即单开定位操作继电器ID*/ UINT16 DcRelayId; /*道岔定操继电器ID (配置字段) 即单开反位操作继电器ID*/ - UINT16 wShadowDbRelayId; /*影子模式道岔定表继电器ID (配置字段) 迪斯尼*/ - UINT16 wShadowFbRelayId; /*影子模式道岔反表继电器ID (配置字段) 迪斯尼*/ /*以下为单轨道岔相关继电器*/ UINT16 GZJId; /*故障继电器ID (配置字段)*/ UINT16 JTYJaId; /*现场状态继电器ID (配置字段)*/ @@ -111,7 +118,9 @@ typedef struct S_SwitchConfigDataStruct UINT8 chSwitchBelongOcNum;/*道岔所属OC数*/ SwitchBelongOCConfigDataStr belongOCConfigData[SWITCH_BELONG_OC_MAX];/*道岔所属各OC的配置情况*/ - + UINT8 RedunCollCfg; /*道岔是否具备冗余采集*/ + SwitchRedunCollCfgDataStru RedunCollRelayStru[SWITCH_REDUN_COLL_MAX]; + UINT16 wReverseBoardId; /*所属倒切板卡ID*/ } SwitchConfigDataStruct; @@ -543,22 +552,6 @@ UINT16 GetSwitchProtectSwitchNum(const UINT16 wSwitchId); */ UINT16* GetSwitchProtectSwitchIdBuf(const UINT16 wSwitchId); -/* -* 功能描述： 获取指定ID道岔影子模式反位表示继电器ID -* 参数说明： const UINT16 switchId, 道岔ID -* 返回值 ： 0: 获取数据失败 -* >0: 反位表示继电器ID -*/ -UINT16 GetSwitchShadowFbRelayId(const UINT16 switchId); - -/* -* 功能描述： 获取指定ID道岔影子模式定位表示继电器ID -* 参数说明： const UINT16 switchId, 道岔ID -* 返回值 ： 0: 获取数据失败 -* >0: 定位表示继电器ID -*/ -UINT16 GetSwitchShadowDbRelayId(const UINT16 switchId); - /** * @brief 获取道岔公里标 * @param const UINT16 switchId 道岔ID @@ -684,6 +677,63 @@ UINT8 GetSwitchWhetherBelongThisOc(UINT16 switchId, UINT8 ocId); * Add by mpt 20260404 */ UINT16 GetSwitchThisOcOtherSwitchId(UINT16 switchId, UINT8 ocId); + +/* +* 功能描述：获取指定ID道岔是否具备冗余采集 +* 参数说明：const UINT16 switchId, 道岔ID +* 返回值 ：REDUN_COLL_YES: 具备道岔冗余采集 +* REDUN_COLL_NO: 不具备道岔冗余采集 +* CI_ERROR: ID有误 +*/ +UINT8 GetSwitchRedunCollCfg(const UINT16 switchId); + +/* +* 功能描述：获取指定ID道岔的冗余表示DBJ1继电器ID +* 参数说明：const UINT16 switchId, 道岔ID +* 返回值 ：0: ID有误 +* 其他：继电器ID +*/ +UINT16 GetSwitchRedunDBJ1RelayId(const UINT16 switchId, const UINT16 ocIndex); + +/* +* 功能描述：获取指定ID道岔的冗余表示DBJ2继电器ID +* 参数说明：const UINT16 switchId, 道岔ID +* 返回值 ：0: ID有误 +* 其他：继电器ID +*/ +UINT16 GetSwitchRedunDBJ2RelayId(const UINT16 switchId, const UINT16 ocIndex); + +/* +* 功能描述：获取指定ID道岔的冗余表示FBJ1继电器ID +* 参数说明：const UINT16 switchId, 道岔ID +* 返回值 ：0: ID有误 +* 其他：继电器ID +*/ +UINT16 GetSwitchRedunFBJ1RelayId(const UINT16 switchId, const UINT16 ocIndex); + +/* +* 功能描述：获取指定ID道岔的冗余表示FBJ2继电器ID +* 参数说明：const UINT16 switchId, 道岔ID +* 返回值 ：0: ID有误 +* 其他：继电器ID +*/ +UINT16 GetSwitchRedunFBJ2RelayId(const UINT16 switchId, const UINT16 ocIndex); + +/* +* 功能描述： 设置倒切板卡 +* 参数说明： const UINT16 switchId, 道岔ID，UINT16 wBoardId倒切板卡Id +* 返回值 ： CI_SUCCESS CI_ERROR +*/ +UINT8 SetSwitchRelateReverseBoardId(const UINT16 switchId, UINT16 wBoardId); +/* +* 功能描述： 获取倒切板卡id +* 参数说明： const UINT16 switchId, 道岔ID +* 返回值 ： UINT16_MAX: 获取数据失败 +* 0: 无倒切 +* [1,65534]倒切板卡Id +*/ +UINT16 GetSwitchRelateReverseBoardId(const UINT16 switchId); + #ifdef __cplusplus } #endif diff --git a/TSCP/src/APP/ciapp/Switch/SwitchDataManage.c b/TSCP/src/APP/ciapp/Switch/SwitchDataManage.c index 4523ebe..4e412ad 100644 --- a/TSCP/src/APP/ciapp/Switch/SwitchDataManage.c +++ b/TSCP/src/APP/ciapp/Switch/SwitchDataManage.c @@ -2876,7 +2876,7 @@ void SetHlhtCiSwitchPlockStatus(const UINT16 switchId, const UINT8 lockStatus) if (SWITCH_SUM_MAX > bufIndex) { - if ((SWITCH_LOCK_STATUS_PROTECT == lockStatus) || (SWITCH_LOCK_STATUS_NO == lockStatus)) + if ((SWITCH_LOCK_STATUS_PROTECT == lockStatus) || (SWITCH_LOCK_STATUS_NO == lockStatus) || (SWITCH_LOCK_STATUS_DAP == lockStatus)) { SwitchDataStru[bufIndex].LockStatus = lockStatus; } @@ -3650,3 +3650,302 @@ void SetSwitchThisOcFindCmdCycNum(const UINT16 switchId, const UINT8 ocId, const } } +/* +* 功能描述： 设置判断混线起始周期号 +* 参数说明： const UINT16 switchId, 道岔ID +* const UINT8 ocIndex OC下标 +* UINT32 cycNum 周期号 +* 返回值 ：void +* add by wyd 20260604 +*/ +void SetSwitchRedunJudgHunXianStCyc(const UINT16 switchId, const UINT8 chOCIndex, const UINT32 cycNum) +{ + UINT16 bufIndex = 0u; /*数组下标*/ + bufIndex = GetSwitchConfigBufIndex(switchId); /*获取道岔数组下标*/ + + if ((SWITCH_SUM_MAX > bufIndex) && (SWITCH_REDUN_COLL_MAX > chOCIndex)) + { + SwitchDataStru[bufIndex].RedunCollData[chOCIndex].dwRedunJudgHunXianStCyc = cycNum; + } + else + { + /*nothing*/ + } +} + +/* +* 功能描述：获取判断混线起始周期号 +* 参数说明：const UINT16 switchId, 道岔ID +* const UINT8 ocIndex OC下标 +* 返回值 ：周期号 +* add by wyd 20260604 +*/ +UINT32 GetSwitchRedunJudgHunXianStCyc(const UINT16 switchId, const UINT8 chOCIndex) +{ + UINT16 bufIndex = 0u; /*数组下标*/ + UINT32 cycNum = 0u; + + bufIndex = GetSwitchConfigBufIndex(switchId); /*获取道岔数组下标*/ + + if ((SWITCH_SUM_MAX > bufIndex) && (SWITCH_REDUN_COLL_MAX > chOCIndex)) + { + cycNum = SwitchDataStru[bufIndex].RedunCollData[chOCIndex].dwRedunJudgHunXianStCyc; + } + else + { + /*nothing*/ + } + + return cycNum; +} + +/* +* 功能描述： 设置实际混线起始周期号 +* 参数说明： const UINT16 switchId, 道岔ID +* const UINT8 ocIndex OC下标 +* UINT32 cycNum 周期号 +* 返回值 ：void +* add by wyd 20260604 +*/ +void SetSwitchRedunRealHunXianStCyc(const UINT16 switchId, const UINT8 chOCIndex, const UINT32 cycNum) +{ + UINT16 bufIndex = 0u; /*数组下标*/ + bufIndex = GetSwitchConfigBufIndex(switchId); /*获取道岔数组下标*/ + + if ((SWITCH_SUM_MAX > bufIndex) && (SWITCH_REDUN_COLL_MAX > chOCIndex)) + { + SwitchDataStru[bufIndex].RedunCollData[chOCIndex].dwRedunRealHunXianStCyc = cycNum; + } + else + { + /*nothing*/ + } +} + +/* +* 功能描述：获取实际混线起始周期号 +* 参数说明：const UINT16 switchId, 道岔ID +* const UINT8 ocIndex OC下标 +* 返回值 ：周期号 +* add by wyd 20260604 +*/ +UINT32 GetSwitchRedunRealHunXianStCyc(const UINT16 switchId, const UINT8 chOCIndex) +{ + UINT16 bufIndex = 0u; /*数组下标*/ + UINT32 cycNum = 0u; + + bufIndex = GetSwitchConfigBufIndex(switchId); /*获取道岔数组下标*/ + + if ((SWITCH_SUM_MAX > bufIndex) && (SWITCH_REDUN_COLL_MAX > chOCIndex)) + { + cycNum = SwitchDataStru[bufIndex].RedunCollData[chOCIndex].dwRedunRealHunXianStCyc; + } + else + { + /*nothing*/ + } + + return cycNum; +} + +/* +* 功能描述： 设置混线恢复状态 +* 参数说明： const UINT16 switchId, 道岔ID +* const UINT8 ocIndex OC下标 +* const UINT8 cHunXianStt 混线恢复状态 +* REDUN_HX_RECOV_1100、REDUN_HX_RECOV_1010、REDUN_HX_RECOV_0011：设置 +* 0：清除 +* 返回值 ：void +* add by wyd 20260604 +*/ +void SetSwitchRedunHunXianRecovStt(const UINT16 switchId, const UINT8 chOCIndex, const UINT8 cHunXianStt) +{ + UINT16 bufIndex = 0u; /*数组下标*/ + bufIndex = GetSwitchConfigBufIndex(switchId); /*获取道岔数组下标*/ + + if ((SWITCH_SUM_MAX > bufIndex) && (SWITCH_REDUN_COLL_MAX > chOCIndex)) + { + if ((REDUN_HX_RECOV_1100 == cHunXianStt) || (REDUN_HX_RECOV_1010 == cHunXianStt) + || (REDUN_HX_RECOV_0011 == cHunXianStt) || (REDUN_HX_RECOV_ALL == cHunXianStt)) + { + /*记录混线恢复采集*/ + SwitchDataStru[bufIndex].RedunCollData[chOCIndex].cHunXianRecovStt |= cHunXianStt; + } + else + { + /*清空混线恢复采集*/ + SwitchDataStru[bufIndex].RedunCollData[chOCIndex].cHunXianRecovStt = 0u; + } + } + else + { + /*nothing*/ + } +} + +/* +* 功能描述：获取混线恢复状态 +* 参数说明：const UINT16 switchId, 道岔ID +* const UINT8 ocIndex OC下标 +* 返回值 ：混线恢复状态 +* add by wyd 20260604 +*/ +UINT8 GetSwitchRedunHunXianRecovStt(const UINT16 switchId, const UINT8 chOCIndex) +{ + UINT16 bufIndex = 0u; /*数组下标*/ + UINT8 RtnValue = 0u; + + bufIndex = GetSwitchConfigBufIndex(switchId); /*获取道岔数组下标*/ + + if ((SWITCH_SUM_MAX > bufIndex) && (SWITCH_REDUN_COLL_MAX > chOCIndex)) + { + RtnValue = SwitchDataStru[bufIndex].RedunCollData[chOCIndex].cHunXianRecovStt; + } + else + { + /*nothing*/ + } + + return RtnValue; +} + +/* +* 功能描述： 设置采集故障起始周期号 +* 参数说明： const UINT16 switchId, 道岔ID +* const UINT8 ocIndex OC下标 +* UINT32 cycNum 周期号 +* 返回值 ：void +* add by wyd 20260604 +*/ +void SetSwitchRedunFaultStCyc(const UINT16 switchId, const UINT8 chOCIndex, const UINT32 cycNum) +{ + UINT16 bufIndex = 0u; /*数组下标*/ + bufIndex = GetSwitchConfigBufIndex(switchId); /*获取道岔数组下标*/ + + if ((SWITCH_SUM_MAX > bufIndex) && (SWITCH_REDUN_COLL_MAX > chOCIndex)) + { + SwitchDataStru[bufIndex].RedunCollData[chOCIndex].dwRedunFaultStCyc = cycNum; + } + else + { + /*nothing*/ + } +} + +/* +* 功能描述：获取采集故障起始周期号 +* 参数说明：const UINT16 switchId, 道岔ID +* const UINT8 ocIndex OC下标 +* 返回值 ：周期号 +* add by wyd 20260604 +*/ +UINT32 GetSwitchRedunFaultStCyc(const UINT16 switchId, const UINT8 chOCIndex) +{ + UINT16 bufIndex = 0u; /*数组下标*/ + UINT32 cycNum = 0u; + + bufIndex = GetSwitchConfigBufIndex(switchId); /*获取道岔数组下标*/ + + if ((SWITCH_SUM_MAX > bufIndex) && (SWITCH_REDUN_COLL_MAX > chOCIndex)) + { + cycNum = SwitchDataStru[bufIndex].RedunCollData[chOCIndex].dwRedunFaultStCyc; + } + else + { + /*nothing*/ + } + + return cycNum; +} + +/* +* 功能描述： 设置冗余采集组合状态 +* 参数说明： const UINT16 switchId, 道岔ID +* const UINT8 ocIndex OC下标 +* UINT32 cycNum 周期号 +* 返回值 ：void +* add by wyd 20260604 +*/ +void SetSwitchRedunCombineStt(const UINT16 switchId, const UINT8 chOCIndex, const UINT8 setValue) +{ + UINT16 bufIndex = 0u; /*数组下标*/ + bufIndex = GetSwitchConfigBufIndex(switchId); /*获取道岔数组下标*/ + + if ((SWITCH_SUM_MAX > bufIndex) && (SWITCH_REDUN_COLL_MAX > chOCIndex)) + { + SwitchDataStru[bufIndex].RedunCollData[chOCIndex].cCombineStt = setValue; + } + else + { + /*nothing*/ + } +} + +/* +* 功能描述： 设置主控转辙机板采集道岔位置 +* 参数说明： const UINT16 switchId, 道岔ID +* const UINT8 ocIndex OC下标 +* UINT32 cycNum 周期号 +* 返回值 ：void +* add by wyd 20260604 +*/ +void SetSwitchMainCollPos(const UINT16 switchId, const UINT8 setValue) +{ + UINT16 bufIndex = 0u; /*数组下标*/ + bufIndex = GetSwitchConfigBufIndex(switchId); /*获取道岔数组下标*/ + + if (SWITCH_SUM_MAX > bufIndex) + { + SwitchDataStru[bufIndex].cMainOcCollPos = setValue; + } + else + { + /*nothing*/ + } +} + +/* +* 功能描述： 设置冗余采集采集道岔位置 +* 参数说明： const UINT16 switchId, 道岔ID +* const UINT8 ocIndex OC下标 +* UINT32 cycNum 周期号 +* 返回值 ：void +* add by wyd 20260604 +*/ +void SetSwitchRedunCollPos(const UINT16 switchId, const UINT8 chOCIndex, const UINT8 setValue) +{ + UINT16 bufIndex = 0u; /*数组下标*/ + bufIndex = GetSwitchConfigBufIndex(switchId); /*获取道岔数组下标*/ + + if ((SWITCH_SUM_MAX > bufIndex) && (SWITCH_REDUN_COLL_MAX > chOCIndex)) + { + SwitchDataStru[bufIndex].RedunCollData[chOCIndex].cCollPos = setValue; + } + else + { + /*nothing*/ + } +} + +/* +* 功能描述： 设置冗余采集当周期混线状态 +* 参数说明： const UINT16 switchId, 道岔ID +* const UINT8 ocIndex OC下标 +* UINT32 cycNum 周期号 +* 返回值 ：void +* add by wyd 20260604 +*/ +void SetSwitchRedunCurrHunXianStt(const UINT16 switchId, const UINT8 chOCIndex, const UINT8 setValue) +{ + UINT16 bufIndex = 0u; /*数组下标*/ + bufIndex = GetSwitchConfigBufIndex(switchId); /*获取道岔数组下标*/ + + if ((SWITCH_SUM_MAX > bufIndex) && (SWITCH_REDUN_COLL_MAX > chOCIndex)) + { + SwitchDataStru[bufIndex].RedunCollData[chOCIndex].cCurrHunxianStt = setValue; + } + else + { + /*nothing*/ + } +} \ No newline at end of file diff --git a/TSCP/src/APP/ciapp/Switch/SwitchDataManage.h b/TSCP/src/APP/ciapp/Switch/SwitchDataManage.h index 68b0d2e..ce86761 100644 --- a/TSCP/src/APP/ciapp/Switch/SwitchDataManage.h +++ b/TSCP/src/APP/ciapp/Switch/SwitchDataManage.h @@ -27,6 +27,21 @@ #ifdef __cplusplus extern "C" { #endif + +typedef struct S_SwitchRedunCollStruct +{ + UINT32 dwRedunJudgHunXianStCyc; /*（北京10道岔冗余采集）判断混线起始周期号，道岔移动中混线容忍用。 + 设置时机为采集到混线，清零时机为容忍时间内未采集到混线，或采集到定、反、移动中*/ + UINT32 dwRedunRealHunXianStCyc; /*（北京10道岔冗余采集）实际混线起始周期号，混线恢复用。 + 设置时机为采集到混线，清零时机为未采集到混线*/ + UINT8 cHunXianRecovStt; /*（北京10道岔冗余采集）混线恢复状态。 + bit0=1：采集到1100，bit1=1：采集到1010，bi2=1：采集到0011 + bit0、1、2均为1表示未混线*/ + UINT32 dwRedunFaultStCyc; /*（北京10道岔冗余采集）采集故障（四开）起始周期号*/ + UINT8 cCombineStt; /*（打印用）继电器采集组合*/ + UINT8 cCollPos; /*（打印用）冗余采集位置*/ + UINT8 cCurrHunxianStt; /*（打印用）当周期混线状态*/ +}SwitchRedunCollStruct; /*道岔数据结构体*/ typedef struct S_SwitchOcDataStruct @@ -103,8 +118,8 @@ typedef struct S_SwitchDataStruct UINT8 PLockedAxisSecNum;/*被防护锁闭的计轴区段id数量，只能在本文件使用*/ UINT16 PLockedAxisSecIdArr[SWITCH_MAX_PROTECT_LOCKED_NUM];/*被防护锁闭的计轴区段id数组，只能在本文件使用*/ - - + SwitchRedunCollStruct RedunCollData[SWITCH_REDUN_COLL_MAX]; + UINT8 cMainOcCollPos; /*（打印用）主控转辙机板道岔位置*/ } SwitchDataStruct; /*道岔数据结构体*/ @@ -927,6 +942,125 @@ UINT32 GetSwitchThisOcFindCmdCycNum(const UINT16 switchId, const UINT8 ocId); * add mpt by 20260402 */ void SetSwitchThisOcFindCmdCycNum(const UINT16 switchId, const UINT8 ocId, const UINT32 cycNum); + +/* +* 功能描述： 设置判断混线起始周期号 +* 参数说明： const UINT16 switchId, 道岔ID +* const UINT8 ocIndex OC下标 +* UINT32 cycNum 周期号 +* 返回值 ：void +* add by wyd 20260604 +*/ +void SetSwitchRedunJudgHunXianStCyc(const UINT16 switchId, const UINT8 chOCIndex, const UINT32 cycNum); + +/* +* 功能描述：获取判断混线起始周期号 +* 参数说明：const UINT16 switchId, 道岔ID +* const UINT8 ocIndex OC下标 +* 返回值 ：周期号 +* add by wyd 20260604 +*/ +UINT32 GetSwitchRedunJudgHunXianStCyc(const UINT16 switchId, const UINT8 chOCIndex); + +/* +* 功能描述： 设置实际混线起始周期号 +* 参数说明： const UINT16 switchId, 道岔ID +* const UINT8 ocIndex OC下标 +* UINT32 cycNum 周期号 +* 返回值 ：void +* add by wyd 20260604 +*/ +void SetSwitchRedunRealHunXianStCyc(const UINT16 switchId, const UINT8 chOCIndex, const UINT32 cycNum); + +/* +* 功能描述：获取实际混线起始周期号 +* 参数说明：const UINT16 switchId, 道岔ID +* const UINT8 ocIndex OC下标 +* 返回值 ：周期号 +* add by wyd 20260604 +*/ +UINT32 GetSwitchRedunRealHunXianStCyc(const UINT16 switchId, const UINT8 chOCIndex); + +/* +* 功能描述： 设置混线恢复状态 +* 参数说明： const UINT16 switchId, 道岔ID +* const UINT8 ocIndex OC下标 +* const UINT8 cHunXianStt 混线恢复状态 +* REDUN_HX_RECOV_1100、REDUN_HX_RECOV_1010、REDUN_HX_RECOV_0011：设置 +* 0：清除 +* 返回值 ：void +* add by wyd 20260604 +*/ +void SetSwitchRedunHunXianRecovStt(const UINT16 switchId, const UINT8 chOCIndex, const UINT8 cHunXianStt); + +/* +* 功能描述：获取混线恢复状态 +* 参数说明：const UINT16 switchId, 道岔ID +* const UINT8 ocIndex OC下标 +* 返回值 ：混线恢复状态 +* add by wyd 20260604 +*/ +UINT8 GetSwitchRedunHunXianRecovStt(const UINT16 switchId, const UINT8 chOCIndex); + +/* +* 功能描述： 设置采集故障起始周期号 +* 参数说明： const UINT16 switchId, 道岔ID +* const UINT8 ocIndex OC下标 +* UINT32 cycNum 周期号 +* 返回值 ：void +* add by wyd 20260604 +*/ +void SetSwitchRedunFaultStCyc(const UINT16 switchId, const UINT8 chOCIndex, const UINT32 cycNum); + +/* +* 功能描述：获取采集故障起始周期号 +* 参数说明：const UINT16 switchId, 道岔ID +* const UINT8 ocIndex OC下标 +* 返回值 ：周期号 +* add by wyd 20260604 +*/ +UINT32 GetSwitchRedunFaultStCyc(const UINT16 switchId, const UINT8 chOCIndex); + +/* +* 功能描述： 设置冗余采集组合状态 +* 参数说明： const UINT16 switchId, 道岔ID +* const UINT8 ocIndex OC下标 +* UINT32 cycNum 周期号 +* 返回值 ：void +* add by wyd 20260604 +*/ +void SetSwitchRedunCombineStt(const UINT16 switchId, const UINT8 chOCIndex, const UINT8 setValue); + +/* +* 功能描述： 设置主控转辙机板采集道岔位置 +* 参数说明： const UINT16 switchId, 道岔ID +* const UINT8 ocIndex OC下标 +* UINT32 cycNum 周期号 +* 返回值 ：void +* add by wyd 20260604 +*/ +void SetSwitchMainCollPos(const UINT16 switchId, const UINT8 setValue); + +/* +* 功能描述： 设置冗余采集采集道岔位置 +* 参数说明： const UINT16 switchId, 道岔ID +* const UINT8 ocIndex OC下标 +* UINT32 cycNum 周期号 +* 返回值 ：void +* add by wyd 20260604 +*/ +void SetSwitchRedunCollPos(const UINT16 switchId, const UINT8 chOCIndex, const UINT8 setValue); + +/* +* 功能描述： 设置冗余采集当周期混线状态 +* 参数说明： const UINT16 switchId, 道岔ID +* const UINT8 ocIndex OC下标 +* UINT32 cycNum 周期号 +* 返回值 ：void +* add by wyd 20260604 +*/ +void SetSwitchRedunCurrHunXianStt(const UINT16 switchId, const UINT8 chOCIndex, const UINT8 setValue); + #ifdef __cplusplus } #endif diff --git a/TSCP/src/APP/ciapp/Switch/SwitchDefine.h b/TSCP/src/APP/ciapp/Switch/SwitchDefine.h index d143ac3..b604ec0 100644 --- a/TSCP/src/APP/ciapp/Switch/SwitchDefine.h +++ b/TSCP/src/APP/ciapp/Switch/SwitchDefine.h @@ -155,6 +155,7 @@ #define SWITCH_BELONG_OC_MAX 2U /*道岔所属OC最多数*/ +#define SWITCH_REDUN_COLL_MAX 2U /*道岔冗余采集最多数*/ #define MAIN_CONTROL 0x55U /*主控*/ #define STANDBY_CONTROL 0xAAU /*备控*/ @@ -168,9 +169,21 @@ #define SWITCH_BOARD_FAULT ((UINT8)0xff) /*转辙机板故障*/ #define SWITCH_BOARD_NORMAL ((UINT8)0x55) /*转辙机板正常*/ -#define FIND_DINGWEI_CMD ((UINT8)0x1) /*寻定*/ -#define FIND_FANWEI_CMD ((UINT8)0x2) /*寻反*/ -#define INIT_FIND_CMD ((UINT8)0x3) /*初始寻*/ -#define NO_FIND_CMD ((UINT8)0x0) /*无寻位置指令*/ +#define FIND_DINGWEI_CMD ((UINT8)0x1) /*寻定*/ +#define FIND_FANWEI_CMD ((UINT8)0x2) /*寻反*/ +#define INIT_FIND_CMD ((UINT8)0x3) /*初始寻*/ +#define NO_FIND_CMD ((UINT8)0x0) /*无寻位置指令*/ + +#define REDUN_COLL_YES ((UINT8)0xAAu) /*具备道岔冗余采集*/ +#define REDUN_COLL_NO ((UINT8)0x55u) /*不具备道岔冗余采集*/ + +#define REDUN_HX_RECOV_1100 ((UINT8)0x01u) /*混线恢复采集到过1100*/ +#define REDUN_HX_RECOV_1010 ((UINT8)0x02u) /*混线恢复采集到过1010*/ +#define REDUN_HX_RECOV_0011 ((UINT8)0x04u) /*混线恢复采集到过0011*/ +#define REDUN_HX_RECOV_ALL ((UINT8)0x07u) /*全部混线恢复采集*/ + +#define REDUN_ALARM_HUNXIAN ((UINT8)0x55u) /*冗余采集混线报警*/ +#define REDUN_ALARM_FAULT ((UINT8)0xAAu) /*冗余采集故障报警*/ + #endif diff --git a/TSCP/src/APP/ciapp/System/SystemConfigDefine.h b/TSCP/src/APP/ciapp/System/SystemConfigDefine.h index d1c1b07..e3da949 100644 --- a/TSCP/src/APP/ciapp/System/SystemConfigDefine.h +++ b/TSCP/src/APP/ciapp/System/SystemConfigDefine.h @@ -62,7 +62,7 @@ #define VER_MAIN_SUBCI_CI_CID ((UINT8)27) /*子系统主版本号*/ #define VER_SUB_SUBCI_CI_CID ((UINT8)0) /*子系统子版本号*/ #define VER_BRUNCH_CI_CID ((UINT8)0) /*分支版本号..........主线填0....分支填1 调试填2 */ -#define VER_RETURN_SUBCI_CI_CID ((UINT8)0) /*子系统回归版本号*/ +#define VER_RETURN_SUBCI_CI_CID ((UINT8)1) /*子系统回归版本号*/ #ifdef SCADE_MODE /*SCADE软件版本号*/ @@ -76,13 +76,13 @@ #define VER_SOFT_PRODUCT ((UINT8)40) /*产品编号*/ #define VER_SOFT_MODUAL_APP ((UINT8)1) /*模块编号*/ #define VER_SOFT_MIANVERSION ((UINT8)27) /*主版本号*/ -#define VER_SOFT_SUBVERSION ((UINT8)1) /*子版本号*/ +#define VER_SOFT_SUBVERSION ((UINT8)2) /*子版本号*/ #endif /*可兼容的公共数据结构版本号*/ #define VER_1_PUBLIC_FS_1 ((UINT8)31) -#define VER_1_PUBLIC_FS_2 ((UINT8)7) +#define VER_1_PUBLIC_FS_2 ((UINT8)8) #define VER_1_PUBLIC_FS_3 ((UINT8)0) #define VER_1_PUBLIC_FS_4 ((UINT8)0) @@ -98,7 +98,7 @@ /*可兼容的私有数据结构版本号*/ -#define VER_1_PRIVATE_FS_1 ((UINT8)52) +#define VER_1_PRIVATE_FS_1 ((UINT8)53) #define VER_1_PRIVATE_FS_2 ((UINT8)0) #define VER_2_PRIVATE_FS_1 ((UINT8)0xFF) @@ -108,7 +108,7 @@ #define VER_3_PRIVATE_FS_2 ((UINT8)0xFF) /*可兼容OC数据结构版本号*/ -#define VER_1_OCDATA_FS_1 ((UINT8)37) /*oc 3.0 较新数据版本*/ +#define VER_1_OCDATA_FS_1 ((UINT8)38) /*oc 3.0 较新数据版本*/ #define VER_1_OCDATA_FS_2 ((UINT8)0) #define VER_2_OCDATA_FS_1 ((UINT8)0xFF) diff --git a/TSCP/src/APP/ciapp/System/SystemParameterManage.c b/TSCP/src/APP/ciapp/System/SystemParameterManage.c index 32b74fb..7d27700 100644 --- a/TSCP/src/APP/ciapp/System/SystemParameterManage.c +++ b/TSCP/src/APP/ciapp/System/SystemParameterManage.c @@ -125,9 +125,10 @@ static UINT16 g_TiocFsVersion[TIOCFS_VERSION_LENGTH] = { 0u };/* TIOC UINT32 gSystemUpdateMainUseCycNum = 0U; /*系统升级主用起始周期号*/ -static UINT32 wSwitchMachineCutInterval = 0U; /*RC/CI系统控制转辙机板主控切换间隔时间(单位：S)*/ -static UINT32 wSwitchMachineDrvingCutInterval = 0U; /*RC/CI系统驱动道岔后控制转辙机板主控切换时间(单位：S)*/ -static UINT32 wSwitchLastDrvValidTime = 0U; /*RC/CI系统上一次驱动道岔有效时间*/ +static UINT32 wSwitchMachineCutInterval = 0U; /*RC/CI系统控制转辙机板主控切换间隔时间(单位：S)*/ +static UINT32 wSwitchMachineDrvingCutInterval = 0U; /*RC/CI系统驱动道岔后控制转辙机板主控切换时间(单位：S)*/ +static UINT32 wSwitchLastDrvValidTime = 0U; /*RC/CI系统上一次驱动道岔有效时间*/ +static UINT32 dwSwitchRedunCollTolTime = 0U; /*道岔冗余采集报警容忍时间*/ /* * 功能描述： 系统参数时间转周期数 * 参数说明： void @@ -361,6 +362,9 @@ void SystemParaTimeToCycleCount(void) paraVal = GetSystemParaValue(SWITCH_LAST_DRV_TIME); wSwitchLastDrvValidTime = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime); /*RC/CI系统上一次驱动道岔有效时间*/ + + paraVal = GetSystemParaValue(SWITCH_REDUN_COLL_ALARM_TIME); + dwSwitchRedunCollTolTime = TimeToCycleCount((UINT32)paraVal, appCycleTime); /*道岔冗余采集报警容忍时间*/ } /* @@ -3429,16 +3433,30 @@ UINT8 GetLocalSerialCommFlag(void) * @return CI_SUCCESS 设置成功 CI_ERROR 设置失败 * @note by cgh 20260507 */ -UINT8 SetLocalSerialCommData(UINT8 chGroupIndex,UINT8 chPortIndex,UINT16 wSerialCommCiId,UINT8 chSerialCommPort) +UINT8 SetLocalSerialCommData(UINT8 chGroupIndex, UINT8 chPortIndex, UINT16 wSerialCommCiId, UINT8 chSerialCommPort) { UINT8 chReval = CI_ERROR; + UINT8 chDevType = 0U; /*设备类型*/ + UINT8 chDevId = 0U; /*设备ID*/ + UINT8 chLocalRcWorkMode = 0u; /*本地RC工作模式*/ - if ((SERIAL_GROUP_SUM_MAX > chGroupIndex) && (CI_SUM_MAX > wSerialCommCiId) && (SERIAL_PORT_SUM_MAX > chPortIndex)) + if ((SERIAL_GROUP_SUM_MAX > chGroupIndex) && (SERIAL_PORT_SUM_MAX > chPortIndex)) { - gSzSerialCommData[chGroupIndex].wSerialCommOtherCiId = wSerialCommCiId; - gSzSerialCommData[chGroupIndex].chSerialCommPort[chPortIndex] = chSerialCommPort; + chLocalRcWorkMode = GetLocalRcWorkMode(); + chDevType = (UINT8)((wSerialCommCiId & 0xFF00U) >> 8U); + chDevId = (UINT8)(wSerialCommCiId & 0x00FFU); - chReval = CI_SUCCESS; + if ((0u ==wSerialCommCiId) || ((chLocalRcWorkMode == chDevType) && (CI_SUM_MAX > chDevId))) + { + gSzSerialCommData[chGroupIndex].wSerialCommOtherCiId = wSerialCommCiId; + gSzSerialCommData[chGroupIndex].chSerialCommPort[chPortIndex] = chSerialCommPort; + + chReval = CI_SUCCESS; + } + else + { + ; /*初始化失败*/ + } } else { @@ -3514,4 +3532,15 @@ UINT8 IsSerialDevice(UINT16 DeviceName, UINT8* pSerialGroup) } return chReval; +} + +/** +* @brief 获取道岔冗余采集故障报警容忍时间（ms） +* @param[in] void +* @return 道岔冗余采集故障报警容忍时间（ms） +* @note by wyd 20260605 +*/ +UINT32 GetSwitchRedunCollHunXianCycCfg(void) +{ + return dwSwitchRedunCollTolTime; } \ No newline at end of file diff --git a/TSCP/src/APP/ciapp/System/SystemParameterManage.h b/TSCP/src/APP/ciapp/System/SystemParameterManage.h index 654d97b..534f5cd 100644 --- a/TSCP/src/APP/ciapp/System/SystemParameterManage.h +++ b/TSCP/src/APP/ciapp/System/SystemParameterManage.h @@ -109,6 +109,7 @@ extern "C" { #define FUNC_OVERLAP_UT_UNLOCK_MODE ((UINT8)74) /*UT列车占压停车区域时，保护区段解锁方式*/ #define FUNC_PSD_EXCEPT_CANCLE_TYPE ((UINT8)75) /*屏蔽门异常打开后解除异常方式：0xAA 需ATS发 0xBA命令；0x55未异常打开自动解除*/ #define FUNC_PSD_KEEP_CLOSE_TYPE ((UINT8)76) /*联锁系统输出打开/关闭站台门命令原则*/ +#define FUNC_GATEWAY_INTERFACE_IDENTIFIER ((UINT8)77) /*联锁与网关接口标识：01：不存在GAL报文头 02：存在GAL报文头*/ #define CiSum_ID ((UINT16)1)/*实际联锁集中站数量 编号*/ @@ -191,6 +192,7 @@ extern "C" { #define SWITCH_MACHINE_CUT_INTERVAL (77U) /*RC/CI系统控制转辙机板主控切换间隔时间(单位：S)*/ #define SWITCH_MACHINE_CUT_DRV_INTERVAL (78U) /*RC/CI系统驱动道岔后控制转辙机板主控切换时间(单位：S)*/ #define SWITCH_LAST_DRV_TIME (79U) /*RC/CI系统上一次驱动道岔有效时间*/ +#define SWITCH_REDUN_COLL_ALARM_TIME (80U) /*道岔冗余采集报警容忍时间（ms）*/ #define FUNC_SWITCH_ON ((UINT8)0xAA) /*功能配置开关打开*/ #define FUNC_SWITCH_OFF ((UINT8)0x55) /*功能配置开关关闭*/ @@ -1636,6 +1638,14 @@ SerialCommData* GetLocalSerialCommData(void); */ UINT8 IsSerialDevice(UINT16 DeviceName, UINT8* pSerialGroup); +/** +* @brief 获取道岔冗余采集故障报警容忍时间（ms） +* @param[in] void +* @return 道岔冗余采集故障报警容忍时间（ms） +* @note by wyd 20260605 +*/ +UINT32 GetSwitchRedunCollHunXianCycCfg(void); + #ifdef __cplusplus } #endif diff --git a/TSCP/src/APP/ciapp/Train/TrainDataManage.c b/TSCP/src/APP/ciapp/Train/TrainDataManage.c index 222b597..d83cd1e 100644 --- a/TSCP/src/APP/ciapp/Train/TrainDataManage.c +++ b/TSCP/src/APP/ciapp/Train/TrainDataManage.c @@ -185,12 +185,6 @@ static void SetTrainAtsScreenProc(void); */ static UINT32 GetTrainTransBadCyc(const UINT16 wTrainId); -/* -* 功能描述： 获取指定列车通信(IVOC)中断周期号 -* 参数说明： const UINT16 wTrainId, 列车ID -* 返回值 ： 列车通信中断周期号 -*/ -static UINT32 GetTrainIvocTransBadCyc(const UINT16 wTrainId); /* * 功能描述： 设置指定列车包络能否转为UCT * 参数说明： const UINT16 wTrainId, 列车ID @@ -366,7 +360,8 @@ UINT8 TrainDataModuleInit(void) gstTrainInfo[chCycle].chTrainPostionMode = 0U; /*列车位置模式*/ - + gstTrainInfo[chCycle].chPbtacsTransState = TRAIN_COMM_STATE_UNKNOWN; /*初始化与PBTACS车未通信*/ + gstTrainInfo[chCycle].dwPbtacsTransBadCyc = 0U; gszTrainId[gTrainSum] = gstTrainInfo[chCycle].wTrainId; gTrainSum++; @@ -415,7 +410,6 @@ UINT8 TrainDataModuleInit(void) gTrainInfoTemp[chCycle].chIvocSpeedDir = 0u; /*Ivoc速度方向*/ gTrainInfoTemp[chCycle].wIvocTrainSpeed = 0u; /*Ivoc列车速度*/ gTrainInfoTemp[chCycle].dwIvocDelayTime = 0u; /*Ivoc消息延迟时间*/ - } @@ -542,33 +536,6 @@ UINT8 GetTrainTransitmitStat(const UINT16 wTrainId) return chRetVal; } - -/* -* 功能描述： 获取指定列车(IVOC)通信状态 -* 参数说明： const UINT16 wTrainId, 列车ID -* 返回值 ： 0: 获取数据失败 -* 0x55: 通信状态良好 -* 0xAA: 丢失通信 -* 0xFF: 通信状态未知 -* 创建: qw.liu 2022-02-24 -*/ -UINT8 GetTrainIvocTransitmitStat(const UINT16 wTrainId) -{ - UINT8 chRetVal = CI_ERROR; - UINT16 wBufIndex = 0U; - - wBufIndex = GetTrainBufIndex(wTrainId); - if (TRAIN_SUM_MAX > wBufIndex) - { - chRetVal = gstTrainInfo[wBufIndex].chIvocTransmitStat; - } - else - { - chRetVal = CI_ERROR; - } - - return chRetVal; -} /* * 功能描述： 获取指定列车等级 * 参数说明： const UINT16 wTrainId, 列车ID @@ -1119,47 +1086,6 @@ UINT8 SetTrainTransmitStat(const UINT16 wTrainId,const UINT8 chTrainmitStat) return chRetVal; } - -/* -* 功能描述： 设置指定列车(IVOC)通信状态 -* 参数说明： const UINT16 wTrainId, 列车ID -* const UINT8 chTrainmitStat 通信状态 -* 返回值 ：CI_ERROR: 设置数据失败 -CI_SUCCESS:设置数据成功 -* 0x55 : 通信状态良好 -* 0xAA : 丢失通信 -* 0xFF : 通信状态未知 -* 创建 : qw.liu 2025 - 05 - 08 -*/ -UINT8 SetTrainIvocTransmitStat(const UINT16 wTrainId, const UINT8 chTrainmitStat) -{ - UINT8 chRetVal = CI_ERROR; - UINT16 wBufIndex = 0U; - - wBufIndex = GetTrainBufIndex(wTrainId); - if (TRAIN_SUM_MAX > wBufIndex) - { - if ((TRAIN_COMM_STATE_GOOD == chTrainmitStat) - || (TRAIN_COMM_STATE_BAD == chTrainmitStat) - || (TRAIN_COMM_STATE_UNKNOWN == chTrainmitStat)) - { - gstTrainInfo[wBufIndex].chIvocTransmitStat = chTrainmitStat; - - gstTrainInfo[wBufIndex].dwIvocTransBadCyc = Get2oo2CurCycleNum(); - chRetVal = CI_SUCCESS; - } - else - { - chRetVal = CI_ERROR; - } - } - else - { - chRetVal = CI_ERROR; - } - - return chRetVal; -} /* * 功能描述： 设置指定列车运行等级 * 参数说明： const UINT16 wTrainId, 列车ID @@ -3091,6 +3017,9 @@ void ClearTrainInfo(UINT16 wTrainId) gstTrainInfo[wBufIndex].strJumpBackData.chJumpBackApplyState = TRAIN_JUMP_BACK_STATE_INVALID;/*初始化未申请*/ gstTrainInfo[wBufIndex].strJumpBackData.chJumpBackReplyState = TRAIN_JUMP_BACK_STATE_NONE;/*初始化允许默认值*/ gstTrainInfo[wBufIndex].strJumpBackData.dwJumpBackApplySn = 0U;/*初始化默认序列号*/ + + gstTrainInfo[wBufIndex].chPbtacsTransState = TRAIN_COMM_STATE_UNKNOWN; /*重置与PBTACS车未通信*/ + gstTrainInfo[wBufIndex].dwPbtacsTransBadCyc = 0U; } else { @@ -4396,7 +4325,6 @@ void NeighborOutTrainProc(UINT8 chTiocId) { SetTrainMsgFromTiocId(wTrainId, 0u); (void)SetTrainTransmitStat(wTrainId, TRAIN_COMM_STATE_BAD); - (void)SetTrainIvocTransmitStat(wTrainId, TRAIN_COMM_STATE_BAD); } else { @@ -4453,7 +4381,6 @@ void NeighborGoodTrainProc(UINT8 chTiocId) { SetTrainMsgFromTiocId(wTrainId, 0u); (void)SetTrainTransmitStat(wTrainId, TRAIN_COMM_STATE_BAD); - (void)SetTrainIvocTransmitStat(wTrainId, TRAIN_COMM_STATE_BAD); } else { @@ -6531,28 +6458,6 @@ static UINT32 GetTrainTransBadCyc(const UINT16 wTrainId) return dwRetVal; } -/* -* 功能描述： 获取指定列车通信(IVOC)中断周期号 -* 参数说明： const UINT16 wTrainId, 列车ID -* 返回值 ： 列车通信中断周期号 -*/ -static UINT32 GetTrainIvocTransBadCyc(const UINT16 wTrainId) -{ - UINT32 dwRetVal = 0u; - UINT16 wBufIndex = 0U; - - wBufIndex = GetTrainBufIndex(wTrainId); - if (TRAIN_SUM_MAX > wBufIndex) - { - dwRetVal = gstTrainInfo[wBufIndex].dwIvocTransBadCyc; - } - else - { - ; - } - - return dwRetVal; -} /* * 功能描述： 获取指定列车反馈区间疏散数量 * 参数说明： const UINT16 wTrainId, 列车ID @@ -7814,23 +7719,21 @@ UINT8 GetTrainResRecycleOTStat(const UINT16 wTrainId) UINT16 wBufIndex = 0U; UINT32 overtimeCycleCount = 0U; - - overtimeCycleCount = GetSystemParaTrainReCycleCount(); + overtimeCycleCount = GetSystemParaTrainReCycleCount(); /*获取资源回收超限时间*/ wBufIndex = GetTrainBufIndex(wTrainId); if (TRAIN_SUM_MAX > wBufIndex) { - trainTransimitStat = GetTrainIvocTransitmitStat(wTrainId); - trainLoseCommCyc = GetTrainIvocTransBadCyc(wTrainId); + trainTransimitStat = GetPbtacsTrainTransState(wTrainId); /*获取与PBTACS车的通信状态*/ + trainLoseCommCyc = GetPbtacsTrainTransBadCyc(wTrainId); /*列车通信不好*/ if (TRAIN_COMM_STATE_BAD == trainTransimitStat) { - overtimeStat = SystemOverTimeCheck(trainLoseCommCyc, overtimeCycleCount); if (CI_TIME_OUT == overtimeStat) { - /*超时，*/ + /*超时*/ chRetVal = CI_SUCCESS; } else @@ -13000,7 +12903,6 @@ void InputMainTrainInformation(UINT16 wTrainId) if (TRAIN_COMM_STATE_GOOD == chTransmitStat) { (void)SetTrainTransmitStat(wTrainId, TRAIN_COMM_STATE_BAD); - (void)SetTrainIvocTransmitStat(wTrainId, TRAIN_COMM_STATE_BAD); SetTrainLevel(wTrainId, TRAIN_LEVEL_UR); } else @@ -13863,7 +13765,6 @@ static void DoubleTrianComStateJuge(const UINT16 wTrainId, const UINT8 chComBadF if (0u == trainMsgFromTiocId) { (void)SetTrainTransmitStat(wTrainId, TRAIN_COMM_STATE_BAD); - (void)SetTrainIvocTransmitStat(wTrainId, TRAIN_COMM_STATE_BAD); } else {/*什么也不执行*/ @@ -13875,19 +13776,6 @@ static void DoubleTrianComStateJuge(const UINT16 wTrainId, const UINT8 chComBadF if (0U == chComBadFlag) {/*前面没设置通信中断*/ (void)SetTrainTransmitStat(wTrainId, TRAIN_COMM_STATE_GOOD); - if (CI_SUCCESS == chIvocCtxValid) - { - (void)SetTrainIvocTransmitStat(wTrainId, TRAIN_COMM_STATE_GOOD); - } - } - - if (CI_ERROR == chIvocCtxValid) - { - chTransmitStat = GetTrainIvocTransitmitStat(wTrainId); - if (TRAIN_COMM_STATE_GOOD == chTransmitStat) - { - (void)SetTrainIvocTransmitStat(wTrainId, TRAIN_COMM_STATE_BAD); - } } } @@ -14060,3 +13948,96 @@ UINT16* GetBlocLinkLogSecBuf(const UINT16 wTrainId) } return pLogSecBuf; } + +/* +* 功能描述：设置指定PBTACS列车通信状态 +* 参数说明：const UINT16 wTrainId, 列车ID +* const UINT8 chTrainmitStat 通信状态 +* 返 回 值：无 +* Created By LQ 2026.06.09 +*/ +void SetPbtacsTrainTransState(const UINT16 wTrainId, const UINT8 chTrainmitStat) +{ + UINT16 wBufIndex = 0U; + UINT32 dwCurCycNum = 0U; + + wBufIndex = GetTrainBufIndex(wTrainId); + if ((TRAIN_SUM_MAX > wBufIndex) + && ((TRAIN_COMM_STATE_GOOD == chTrainmitStat) || (TRAIN_COMM_STATE_BAD == chTrainmitStat) || (TRAIN_COMM_STATE_UNKNOWN == chTrainmitStat))) + { + gstTrainInfo[wBufIndex].chPbtacsTransState = chTrainmitStat; + + if (TRAIN_COMM_STATE_BAD == chTrainmitStat) + { + if (0U == gstTrainInfo[wBufIndex].dwPbtacsTransBadCyc) + { + dwCurCycNum = Get2oo2CurCycleNum(); + gstTrainInfo[wBufIndex].dwPbtacsTransBadCyc = dwCurCycNum; /*设置通信中断时间*/ + } + else + { + /*已设置通信中断时间，不再重复刷新*/ + } + } + else + { + gstTrainInfo[wBufIndex].dwPbtacsTransBadCyc = 0U; + } + } + else + { + /*异常分支，不处理*/ + } + +} + +/* +* 功能描述：获取指定PBTACS列车通信状态 +* 参数说明：const UINT16 wTrainId 列车ID +* 返 回 值：0 获取数据失败 +* 0x55 通信状态良好 +* 0xAA 丢失通信 +* 0xFF 通信状态未知 +* Created By LQ 2026.06.09 +*/ +UINT8 GetPbtacsTrainTransState(const UINT16 wTrainId) +{ + UINT8 chRetVal = CI_ERROR; + UINT16 wBufIndex = 0U; + + wBufIndex = GetTrainBufIndex(wTrainId); + if (TRAIN_SUM_MAX > wBufIndex) + { + chRetVal = gstTrainInfo[wBufIndex].chPbtacsTransState; + } + else + { + chRetVal = CI_ERROR; + } + + return chRetVal; +} + +/* +* 功能描述：获取指定PBTACS列车通信中断周期号 +* 参数说明：const UINT16 wTrainId 列车ID +* 返 回 值：列车通信中断周期号 +* Created By LQ 2026.06.09 +*/ +UINT32 GetPbtacsTrainTransBadCyc(const UINT16 wTrainId) +{ + UINT32 dwRetVal = 0U; + UINT16 wBufIndex = 0U; + + wBufIndex = GetTrainBufIndex(wTrainId); + if (TRAIN_SUM_MAX > wBufIndex) + { + dwRetVal = gstTrainInfo[wBufIndex].dwPbtacsTransBadCyc; + } + else + { + ; + } + + return dwRetVal; +} \ No newline at end of file diff --git a/TSCP/src/APP/ciapp/Train/TrainDataManage.h b/TSCP/src/APP/ciapp/Train/TrainDataManage.h index b77f917..09a55d2 100644 --- a/TSCP/src/APP/ciapp/Train/TrainDataManage.h +++ b/TSCP/src/APP/ciapp/Train/TrainDataManage.h @@ -227,7 +227,6 @@ typedef struct S_TrainInfoStru UINT16 wTrainSpeed; /*速度*/ UINT8 chTrainZeroState; /*列车零速状态*/ UINT8 chTransmitStat; /*与列车传输状态*/ - UINT8 chIvocTransmitStat; /*与IVOC列车传输状态*/ UINT8 chHeadScreenStat; /*列车前筛标志*/ UINT8 chTailScreenStat; /*列车后筛标志*/ TrainSafeLocStru strSafeLoc; /*列车安全位置*/ @@ -253,7 +252,6 @@ typedef struct S_TrainInfoStru UINT8 chStopSteadyState; /*列车停准停稳状态*/ UINT8 chSleepCancleFlag; /*清除休眠车标志*/ UINT32 dwTransBadCyc; /*通信中断周期*/ - UINT32 dwIvocTransBadCyc; /*通信中断周期*/ UINT8 chEaNum; /*通信列车回复的区间疏散数量*/ TrainEaStru strTrainEaInfo[EA_MAX_NUM]; /*列车恢复区间疏散信息*/ UINT8 chEaCmd; /*区间疏散命令*/ @@ -297,6 +295,8 @@ typedef struct S_TrainInfoStru UINT8 chTrainPostionMode; /*列车位置模式，0x10 使用IVOC位置，0x14使用VOBC位置*/ BlocLinkInfoStru strBlocLinkData; /*点连式信息*/ + UINT8 chPbtacsTransState; /*RC与PBTACS列车通信状态（该变量用于资源回收功能）：0x55-通信正常，0xAA-通信中断，0xFF-未知*/ + UINT32 dwPbtacsTransBadCyc; /*RC与PBTACS列车通信中断周期（该变量用于资源回收功能）*/ }TrainInfoStru; @@ -438,16 +438,6 @@ UINT16 GetTrainBufIndex(const UINT16 wTrainId); */ UINT8 GetTrainTransitmitStat(const UINT16 wTrainId); -/* -* 功能描述： 获取指定列车(IVOC)通信状态 -* 参数说明： const UINT16 wTrainId, 列车ID -* 返回值 ： 0: 获取数据失败 -* 0x55: 通信状态良好 -* 0xAA: 丢失通信 -* 0xFF: 通信状态未知 -* 创建: qw.liu 2022-02-24 -*/ -UINT8 GetTrainIvocTransitmitStat(const UINT16 wTrainId); /* * 功能描述： 获取指定列车最小安全前端偏移量 * 参数说明： const UINT16 wTrainId, 列车ID @@ -607,19 +597,6 @@ CI_SUCCESS: */ UINT8 SetTrainTransmitStat(const UINT16 wTrainId, const UINT8 chTrainmitStat); - -/* -* 功能描述： 设置指定列车(IVOC)通信状态 -* 参数说明： const UINT16 wTrainId, 列车ID -* const UINT8 chTrainmitStat 通信状态 -* 返回值 ：CI_ERROR: 设置数据失败 -CI_SUCCESS:设置数据成功 -* 0x55 : 通信状态良好 -* 0xAA : 丢失通信 -* 0xFF : 通信状态未知 -* 创建 : qw.liu 2025 - 05 - 08 -*/ -UINT8 SetTrainIvocTransmitStat(const UINT16 wTrainId, const UINT8 chTrainmitStat); /* * 功能描述： 设置指定列车运行等级 * 参数说明： const UINT16 wTrainId, 列车ID @@ -3128,6 +3105,34 @@ UINT8 GetBlocLinkLogSecNum(const UINT16 wTrainId); */ UINT16* GetBlocLinkLogSecBuf(const UINT16 wTrainId); +/* +* 功能描述：设置指定PBTACS列车通信状态 +* 参数说明：const UINT16 wTrainId, 列车ID +* const UINT8 chTrainmitStat 通信状态 +* 返 回 值：无 +* Created By LQ 2026.06.09 +*/ +void SetPbtacsTrainTransState(const UINT16 wTrainId, const UINT8 chTrainmitStat); + +/* +* 功能描述：获取指定PBTACS列车通信状态 +* 参数说明：const UINT16 wTrainId 列车ID +* 返 回 值：0 获取数据失败 +* 0x55 通信状态良好 +* 0xAA 丢失通信 +* 0xFF 通信状态未知 +* Created By LQ 2026.06.09 +*/ +UINT8 GetPbtacsTrainTransState(const UINT16 wTrainId); + +/* +* 功能描述：获取指定PBTACS列车通信中断周期号 +* 参数说明：const UINT16 wTrainId 列车ID +* 返 回 值：列车通信中断周期号 +* Created By LQ 2026.06.09 +*/ +UINT32 GetPbtacsTrainTransBadCyc(const UINT16 wTrainId); + #ifdef __cplusplus } #endif diff --git a/TSCP/src/dqu_common/dqu_emap_common/dquStructInit.c b/TSCP/src/dqu_common/dqu_emap_common/dquStructInit.c index b580655..174718d 100644 --- a/TSCP/src/dqu_common/dqu_emap_common/dquStructInit.c +++ b/TSCP/src/dqu_common/dqu_emap_common/dquStructInit.c @@ -1760,7 +1760,7 @@ static UINT8 ROUTE_STRU_init_FAO(UINT8 * pDataAdd, DSU_ROUTE_STRU * pRouteStru) } /*进路性质*/ - pRouteStru->wRouteType = ShortFromChar(pData); + pRouteStru->dwRouteType = ShortFromChar(pData); pData += 2; /*起始信号机编号*/ @@ -1902,7 +1902,7 @@ static UINT8 ROUTE_STRU_init_HLT(UINT8 * pDataAdd, DSU_ROUTE_STRU * pRouteStru) } /*进路性质*/ - pRouteStru->wRouteType = ShortFromChar(pData); + pRouteStru->dwRouteType = ShortFromChar(pData); pData += 2U; /*起始信号机编号*/ @@ -2148,7 +2148,7 @@ static UINT8 ROUTE_STRU_init_CPK(UINT8 * pDataAdd, DSU_ROUTE_STRU * pRouteStru) } /*进路性质*/ - pRouteStru->wRouteType = ShortFromChar(pData); + pRouteStru->dwRouteType = ShortFromChar(pData); pData += 2; /*起始信号机编号*/ @@ -2273,6 +2273,9 @@ static UINT8 ROUTE_STRU_init_CC(UINT8 * pDataAdd, DSU_ROUTE_STRU * pRouteStru) static UINT16 maxCBTCAccessLinkNum = MAX_CBTC_ACCESS_LINK_NUM;/*进路包含的实际CBTC接近区段最大数量*/ static UINT16 maxBLOCAccessLinkNum = MAX_BLOC_ACCESS_LINK_NUM;/*进路包含的实际点式接近区段最大数量*/ UINT8 reval = 0U;/*初始赋值为失败*/ + UINT8 chDataType = 0U; + chDataType = GetLocalPublicDataType(); /*区分分支，与主线*/ + /*输入参数空指针防护*/ if ((NULL != pDataAdd) && (NULL != pRouteStru)) { @@ -2287,8 +2290,17 @@ static UINT8 ROUTE_STRU_init_CC(UINT8 * pDataAdd, DSU_ROUTE_STRU * pRouteStru) } /*进路性质*/ - pRouteStru->wRouteType = ShortFromChar(pData); - pData += 2U; + if (0x01 == chDataType) + { + /*主线扩大字段*/ + pRouteStru->dwRouteType = LongFromChar(pData); + pData += 4U; + } + else + { + pRouteStru->dwRouteType = ShortFromChar(pData); + pData += 2U; + } /*起始信号机编号*/ pRouteStru->wStartSignalId = ShortFromChar(pData); diff --git a/TSCP/src/dqu_common/dqu_emap_common/dsuStruct.h b/TSCP/src/dqu_common/dqu_emap_common/dsuStruct.h index f7d048e..0d93e59 100644 --- a/TSCP/src/dqu_common/dqu_emap_common/dsuStruct.h +++ b/TSCP/src/dqu_common/dqu_emap_common/dsuStruct.h @@ -502,7 +502,7 @@ typedef struct DSU_RouteStruct { UINT16 wId; /*编号*/ CHAR szCaption [24]; /*进路名称*/ - UINT16 wRouteType; /*进路性质*/ + UINT32 dwRouteType; /*进路性质*/ UINT16 wStartSignalId; /*起始信号机编号*/ UINT16 wEndSignalId; /*终止信号机编号*/ UINT16 wOrgnLkId; /*起点所处link编号*/ /*新增---严广学*/ diff --git a/TSCP/src/protocol/fsfb/common_fsfb/FsfbRecordDelare.h b/TSCP/src/protocol/fsfb/common_fsfb/FsfbRecordDelare.h index 56ea088..c42065f 100644 --- a/TSCP/src/protocol/fsfb/common_fsfb/FsfbRecordDelare.h +++ b/TSCP/src/protocol/fsfb/common_fsfb/FsfbRecordDelare.h @@ -1,15 +1,15 @@ /******************************************************** * -* 文件名 ： FsfbRecordDelare.h -* 版权说明： 北京交控科技有限工司 -* 版本号 ： 1.0 -* 创建时间： 2013.09.09 -* 作者 ： 王佩佩 -* 功能描述： FSFB协议记录相关宏定义。 -* 使用注意： +* 锟侥硷拷锟紽sfbRecordDelare.hare.h +* 锟斤拷权说锟斤拷锟斤拷 锟斤拷锟斤拷锟斤拷锟截科硷拷锟斤拷锟睫癸拷司 +* 锟芥本锟斤拷 锟斤拷 1.0 +* 锟斤拷锟斤拷时锟戒： 2013.09.09 +* 锟斤拷锟斤拷 锟斤拷 锟斤拷锟斤拷锟斤拷 +* 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷 FSFB协锟斤拷锟铰硷拷锟截宏定锟藉。 +* 使锟斤拷注锟解： * -* 修改记录： -* 2010.05.10 修改 追加FSFB新周期开始标识。 +* 锟睫改硷拷录锟斤拷 +* 2010.05.10 锟睫革拷 追锟斤拷FSFB锟斤拷锟斤拷锟节匡拷始锟斤拷识锟斤拷 * ********************************************************/ @@ -19,93 +19,93 @@ /******************************************************************************** -宏定义 +锟疥定锟斤拷 ********************************************************************************/ -/* 各个标志位 */ -#define FSFB_CYCLE_TAG (0xF4FB) /* FSFB新周期开始标识 */ -#define IN_RED (0x01) /*输入红网处理*/ -#define IN_BLUE (0x02) /*输入蓝网处理*/ -#define IN_FRAME_LEN_ERR (0x03) /*输入数据帧长度错误*/ -#define IN_READ_FRAME_ERR (0x04) /*读取数据帧长度错误*/ -#define IN_READ_FRAME (0x05) /*读取数据帧*/ -#define IN_CRC_ERR (0x06) /*CRC错误*/ -#define IN_NO_LNK (0x07) /*无链路*/ -#define IN_CAT_ERR (0x08) /*输入帧种类错误*/ -#define IN_ADDR_ERR (0x09) /*输入帧种类错误*/ -#define IN_SSR_STATUS_ERR (0x0A) /*输入SSR收状态错误*/ -#define IN_SSR_SSE_TC_ERR (0x0B) /*输入SSR的SSE序号错误*/ -#define IN_ABT_STATUS (0x0C) /*输入ABT收状态*/ -#define IN_ABT_SVC_ERR (0x0D) /*输入ABT的SVC错误*/ -#define IN_ABT_OLD_ERR (0x0E) /*输入ABT旧序号错误*/ -#define IN_ABT_SSE_BTC (0x0F) /*输入ABT发SSE或BTC*/ -#define IN_BTD_LEN_ERR (0x10) /*输入BTD的长度错误*/ -#define IN_BTD_STATUS (0x11) /*输入BTD收状态*/ -#define IN_BTD_LOST_ERR (0x12) /*输入BTD丢失超容忍*/ -#define IN_BTD_DELAY_ERR (0x13) /*输入BTD延迟超容忍*/ -#define IN_BTD_SVC_ERR (0x14) /*输入BTD的SVC错误*/ -#define OUT_APP (0x15) /*输出数据*/ -#define OUT_FRAME_LEN_ERR (0x16) /*输出应用帧数据长度错误*/ -#define OUT_READ_ERR (0x17) /*输出读应用数据错误*/ -#define OUT_APP_FRAME (0x18) /*输出应用帧数据*/ -#define OUT_FRAME_TYPE_ERR (0x19) /*输出帧类型错误*/ -#define OUT_ADDR_ERR (0x1A) /*输出地址错误*/ -#define OUT_FIND_LNK_ERR (0x1B) /*输出查询链路错误*/ -#define OUT_INSERT_NODE_ERR (0x1C) /*输出插入节点错误*/ -#define OUT_INIT_NODE_ERR (0x1D) /*输出初始化节点错误*/ -#define OUT_DATA_TYPE (0x1E) /*输出数据类型*/ -#define OUT_LNK (0x1F) /*输出链路*/ -#define OUT_RP_LNK (0x20) /*输出RP链路*/ -#define OUT_ALL_LEN_ERR (0x21) /*输出数据总长度错误*/ +/* 锟斤拷锟斤拷锟斤拷志位 */ +#define FSFB_CYCLE_TAG (0xF4FB) /* FSFB锟斤拷锟斤拷锟节匡拷始锟斤拷识 */ +#define IN_RED (0x01) /*锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟*/ +#define IN_BLUE (0x02) /*锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷*/ +#define IN_FRAME_LEN_ERR (0x03) /*锟斤拷锟斤拷锟斤拷锟斤拷帧锟斤拷锟饺达拷锟斤拷*/ +#define IN_READ_FRAME_ERR (0x04) /*锟斤拷取锟斤拷锟斤拷帧锟斤拷锟饺达拷锟斤拷*/ +#define IN_READ_FRAME (0x05) /*锟斤拷取锟斤拷锟斤拷帧*/ +#define IN_CRC_ERR (0x06) /*CRC锟斤拷锟斤拷*/ +#define IN_NO_LNK (0x07) /*锟斤拷锟斤拷路*/ +#define IN_CAT_ERR (0x08) /*锟斤拷锟斤拷帧锟斤拷锟斤拷锟斤拷锟*/ +#define IN_ADDR_ERR (0x09) /*锟斤拷锟斤拷帧锟斤拷锟斤拷锟斤拷锟*/ +#define IN_SSR_STATUS_ERR (0x0A) /*锟斤拷锟斤拷SSR锟斤拷状态锟斤拷锟斤拷*/ +#define IN_SSR_SSE_TC_ERR (0x0B) /*锟斤拷锟斤拷SSR锟斤拷SSE锟斤拷糯锟斤拷锟*/ +#define IN_ABT_STATUS (0x0C) /*锟斤拷锟斤拷ABT锟斤拷状态*/ +#define IN_ABT_SVC_ERR (0x0D) /*锟斤拷锟斤拷ABT锟斤拷SVC锟斤拷锟斤拷*/ +#define IN_ABT_OLD_ERR (0x0E) /*锟斤拷锟斤拷ABT锟斤拷锟斤拷糯锟斤拷锟*/ +#define IN_ABT_SSE_BTC (0x0F) /*锟斤拷锟斤拷ABT锟斤拷SSE锟斤拷BTC*/ +#define IN_BTD_LEN_ERR (0x10) /*锟斤拷锟斤拷BTD锟侥筹拷锟饺达拷锟斤拷*/ +#define IN_BTD_STATUS (0x11) /*锟斤拷锟斤拷BTD锟斤拷状态*/ +#define IN_BTD_LOST_ERR (0x12) /*锟斤拷锟斤拷BTD锟斤拷失锟斤拷锟斤拷锟斤拷*/ +#define IN_BTD_DELAY_ERR (0x13) /*锟斤拷锟斤拷BTD锟接迟筹拷锟斤拷锟斤拷*/ +#define IN_BTD_SVC_ERR (0x14) /*锟斤拷锟斤拷BTD锟斤拷SVC锟斤拷锟斤拷*/ +#define OUT_APP (0x15) /*锟斤拷锟斤拷锟斤拷锟*/ +#define OUT_FRAME_LEN_ERR (0x16) /*锟斤拷锟接︼拷锟街★拷锟斤拷莩锟斤拷却锟斤拷锟*/ +#define OUT_READ_ERR (0x17) /*锟斤拷锟斤拷锟接︼拷锟斤拷锟斤拷荽锟斤拷锟*/ +#define OUT_APP_FRAME (0x18) /*锟斤拷锟接︼拷锟街★拷锟斤拷锟*/ +#define OUT_FRAME_TYPE_ERR (0x19) /*锟斤拷锟街★拷锟斤拷痛锟斤拷锟*/ +#define OUT_ADDR_ERR (0x1A) /*锟斤拷锟斤拷锟街凤拷锟斤拷锟*/ +#define OUT_FIND_LNK_ERR (0x1B) /*锟斤拷锟斤拷锟窖拷锟铰凤拷锟斤拷锟*/ +#define OUT_INSERT_NODE_ERR (0x1C) /*锟斤拷锟斤拷锟斤拷锟节碉拷锟斤拷锟*/ +#define OUT_INIT_NODE_ERR (0x1D) /*锟斤拷锟斤拷锟绞硷拷锟斤拷诘锟斤拷锟斤拷*/ +#define OUT_DATA_TYPE (0x1E) /*锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟*/ +#define OUT_LNK (0x1F) /*锟斤拷锟斤拷锟铰*/ +#define OUT_RP_LNK (0x20) /*锟斤拷锟絉P锟斤拷路*/ +#define OUT_ALL_LEN_ERR (0x21) /*锟斤拷锟斤拷锟斤拷锟斤拷艹锟斤拷却锟斤拷锟*/ -#define FSFB_RCV_TAG 0xF4 /* FSFB输入单元标识 */ -#define FSFB_OUT_TAG 0xF5 /* FSFB输出单元标识 */ -#define FSFB_MSG_IN_TAG 0x04 /* FSFB输入一帧消息起始标识(B 0000 0100) */ -#define FSFB_MSG_OUT_TAG 0x08 /* FSFB输出一帧消息起始标识(B 0000 1000) */ -#define FSFB_NODE_OUT_TAG 0x0C /* FSFB输出一帧消息起始标识(B 0000 1100) */ -#define FSFB_OUT_E_TAG 0x0F /* FSFB输出单元结束标识(B 0000 1111) */ +#define FSFB_RCV_TAG 0xF4 /* FSFB锟斤拷锟诫单元锟斤拷识 */ +#define FSFB_OUT_TAG 0xF5 /* FSFB锟斤拷锟斤拷锟皆拷锟绞 */ +#define FSFB_MSG_IN_TAG 0x04 /* FSFB锟斤拷锟斤拷一帧锟斤拷息锟斤拷始锟斤拷识(B 0000 0100) */ +#define FSFB_MSG_OUT_TAG 0x08 /* FSFB锟斤拷锟揭恢★拷锟较拷锟绞硷拷锟绞(B 0000 1000) */ +#define FSFB_NODE_OUT_TAG 0x0C /* FSFB锟斤拷锟揭恢★拷锟较拷锟绞硷拷锟绞(B 0000 1100) */ +#define FSFB_OUT_E_TAG 0x0F /* FSFB锟斤拷锟斤拷锟皆拷锟斤拷锟斤拷锟绞(B 0000 1111) */ /************************************************************************ - * 错误码编码原则，协议错误码一共16bit - * D15~D12：保留 - * D11~D10：错误等级 - * D9~D8：模块位置 - * D7~D4：包括各个模块特有的错误，在模块不同时次4位代表的含义不同 - * 区别于队列链表等底层错误 - * D3~D0：函数出错处理，不论模块是否相同此4位代表的含义相同 + * 锟斤拷锟斤拷锟斤拷锟斤拷锟皆拷锟叫拷锟斤拷锟斤拷锟斤拷一锟斤拷16bit + * D15~D12锟斤拷锟斤拷锟斤拷 + * D11~D10锟斤拷锟斤拷锟斤拷燃锟 + * D9~D8锟斤拷模锟斤拷位锟斤拷 + * D7~D4锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷模锟斤拷锟斤拷锟叫的达拷锟斤拷锟斤拷模锟介不同时锟斤拷4位锟斤拷锟斤拷锟侥猴拷锟藉不同 + * 锟斤拷锟斤拷锟节讹拷锟斤拷锟斤拷锟斤拷锟饺底诧拷锟斤拷锟 + * D3~D0锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷模锟斤拷锟角凤拷锟斤拷同锟斤拷4位锟斤拷锟斤拷锟侥猴拷锟斤拷锟斤拷同 ************************************************************************/ -/* 错误等级 */ +/* 锟斤拷锟斤拷燃锟 */ #define FSFB_ERR 0x0800 #define FSFB_WARN 0x0400 -/* 模块位置 */ -#define FSFB_RECEIVE 0x0200 /* 输入模块 */ -#define FSFB_OUTPUT 0x0100 /* 输出模块 */ +/* 模锟斤拷位锟斤拷 */ +#define FSFB_RECEIVE 0x0200 /* 锟斤拷锟斤拷模锟斤拷 */ +#define FSFB_OUTPUT 0x0100 /* 锟斤拷锟侥ｏ拷锟 */ -/* 各模块特有错误 */ +/* 锟斤拷模锟斤拷锟斤拷锟叫达拷锟斤拷 */ #define FSFB_ERROR_NULL 0x0000 -/* 输入 */ -#define FSFB_MSG_TYPE_ILLEGAL 0x0010 /* 不是FSFB消息 */ -#define FSFB_MSG_OLD_ERR 0x0020 /* 非最新报文 */ -#define FSFB_DEL_MSG_LNK_ERR 0x0030 /* 临时报文删除失败 */ -#define FSFB_MSG_NOT_NODE_ERR 0x0040 /* 报文信息与通信节点信息不一致 */ -#define FSFB_MSG_LEN_ERR 0x0050 /* 报文长度不正 */ -#define FSFB_MSG_FMT_ILLEGAL 0x0060 /* 报文格式不对 */ -#define FSFB_SSR_NOT_ILLEGAL 0x0070 /* 不是对应SSR报文信息 */ -#define FSFB_MSG_REPLACE_ERR 0x0080 /* 覆盖节点失败 */ -#define FSFB_MSG_NO_REPLACENODE 0x0090 /* 不存在覆盖节点 */ -#define FSFB_MSG_NO_INVALID 0x00A0 /* BSD解码失败 */ +/* 锟斤拷锟斤拷 */ +#define FSFB_MSG_TYPE_ILLEGAL 0x0010 /* 锟斤拷锟斤拷FSFB锟斤拷息 */ +#define FSFB_MSG_OLD_ERR 0x0020 /* 锟斤拷锟斤拷锟铰憋拷锟斤拷 */ +#define FSFB_DEL_MSG_LNK_ERR 0x0030 /* 锟斤拷时锟斤拷锟斤拷删锟斤拷失锟斤拷 */ +#define FSFB_MSG_NOT_NODE_ERR 0x0040 /* 锟斤拷锟斤拷锟斤拷息锟斤拷通锟脚节碉拷锟斤拷息锟斤拷一锟斤拷 */ +#define FSFB_MSG_LEN_ERR 0x0050 /* 锟斤拷锟侥筹拷锟饺诧拷锟斤拷 */ +#define FSFB_MSG_FMT_ILLEGAL 0x0060 /* 锟斤拷锟侥革拷式锟斤拷锟斤拷 */ +#define FSFB_SSR_NOT_ILLEGAL 0x0070 /* 锟斤拷锟角讹拷应SSR锟斤拷锟斤拷锟斤拷息 */ +#define FSFB_MSG_REPLACE_ERR 0x0080 /* 锟斤拷锟角节碉拷失锟斤拷 */ +#define FSFB_MSG_NO_REPLACENODE 0x0090 /* 锟斤拷锟斤拷锟节革拷锟角节碉拷 */ +#define FSFB_MSG_NO_INVALID 0x00A0 /* BSD锟斤拷锟斤拷失锟斤拷 */ #define FSFB_MSG_CRC_ERR 0x00B0 -/* 输出 */ -#define FSFB_DBGET_ERR 0x0050 /* 数据库查询错误 */ -/* 函数出错处理，底层处理错误 */ -#define FSFB_QUEUE_READ 0x0001 /* 队列读有错 */ -#define FSFB_QUEUE_WRITE 0x0002 /* 队列写有错 */ -#define FSFB_QUEUE_INTEGRITY 0x0003 /* 队列中数据不完整（包括scan有错，应用给出错误）*/ -#define FSFB_LNK_PUSH 0x0004 /* 链路管理表节点压栈错误 */ -#define FSFB_LNK_POP 0x0005 /* 序列号缓存链表节点出栈错误 */ +/* 锟斤拷锟 */ +#define FSFB_DBGET_ERR 0x0050 /* 锟斤拷锟捷匡拷锟窖拷锟斤拷锟 */ +/* 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟阶层处锟斤拷锟斤拷锟斤拷 */ +#define FSFB_QUEUE_READ 0x0001 /* 锟斤拷锟叫讹拷锟叫达拷 */ +#define FSFB_QUEUE_WRITE 0x0002 /* 锟斤拷锟斤拷写锟叫达拷 */ +#define FSFB_QUEUE_INTEGRITY 0x0003 /* 锟斤拷锟斤拷锟斤拷锟斤拷锟捷诧拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷scan锟叫达拷锟斤拷应锟矫革拷锟斤拷锟斤拷锟斤拷*/ +#define FSFB_LNK_PUSH 0x0004 /* 锟斤拷路锟斤拷锟斤拷锟斤拷锟节碉拷压栈锟斤拷锟斤拷 */ +#define FSFB_LNK_POP 0x0005 /* 锟斤拷锟叫号伙拷锟斤拷锟斤拷锟斤拷锟节碉拷锟秸伙拷锟斤拷锟 */ diff --git a/TSCP/src/protocol/sfp_record_cbtc1/common_sfp_nr_config/sfpConfig.h b/TSCP/src/protocol/sfp_record_cbtc1/common_sfp_nr_config/sfpConfig.h index e2bc929..dcc2033 100644 --- a/TSCP/src/protocol/sfp_record_cbtc1/common_sfp_nr_config/sfpConfig.h +++ b/TSCP/src/protocol/sfp_record_cbtc1/common_sfp_nr_config/sfpConfig.h @@ -21,6 +21,7 @@ #define PRTCL_RECORD_SIMPLIFY_BIN /*二进制记录开关*/ #define USE_DSU_SFP /*使用SFP查询函数*/ +#define SWAP_CRC /*交换CRC*/ #else #endif diff --git a/鏁版嵁/鏍囧噯绔欒溅杞8.2+鍏叡V31.8+V56.0IVOC+V53.0RCI_CI+V38.0RCI_OC+V22.0ATS+V1.0TMC+V13.0AIM鍙夾ID-20260612(1).zip b/鏁版嵁/鏍囧噯绔欒溅杞8.2+鍏叡V31.8+V56.0IVOC+V53.0RCI_CI+V38.0RCI_OC+V22.0ATS+V1.0TMC+V13.0AIM鍙夾ID-20260612(1).zip new file mode 100644 index 0000000..cf19332 --- /dev/null +++ b/鏁版嵁/鏍囧噯绔欒溅杞8.2+鍏叡V31.8+V56.0IVOC+V53.0RCI_CI+V38.0RCI_OC+V22.0ATS+V1.0TMC+V13.0AIM鍙夾ID-20260612(1).zip @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d1dc9a95e598cdd85b0bbf171c66ebe17a1aeb460fe964094ca2bdce987ce6d7 +size 70112826 diff --git a/鏁版嵁/鐢靛瓙鍦板浘鏁版嵁V2.3-CBTC-23.zip b/鏁版嵁/鐢靛瓙鍦板浘鏁版嵁V2.3-CBTC-23.zip deleted file mode 100644 index 6ed369c..0000000 --- a/鏁版嵁/鐢靛瓙鍦板浘鏁版嵁V2.3-CBTC-23.zip +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:317f27bac6cf058ba0dd48be8f9b696d6d8198ae06088f663b2860b616b502ad -size 7770464 diff --git a/鏁版嵁/鐢靛瓙鍦板浘鏁版嵁V2.3-CBTC-26 -璋冭瘯鏁版嵁-2.rar b/鏁版嵁/鐢靛瓙鍦板浘鏁版嵁V2.3-CBTC-26 -璋冭瘯鏁版嵁-2.rar new file mode 100644 index 0000000..79580b9 --- /dev/null +++ b/鏁版嵁/鐢靛瓙鍦板浘鏁版嵁V2.3-CBTC-26 -璋冭瘯鏁版嵁-2.rar @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5ef182bc4393b037277d199adce26bc5a730b6c6c18552f449a2a09204448419 +size 6703137 diff --git a/鏁版嵁/鐢靛瓙鍦板浘鏁版嵁V2.3-杞﹁溅-13.zip b/鏁版嵁/鐢靛瓙鍦板浘鏁版嵁V2.3-杞﹁溅-13.zip deleted file mode 100644 index 47ea567..0000000 --- a/鏁版嵁/鐢靛瓙鍦板浘鏁版嵁V2.3-杞﹁溅-13.zip +++ /dev/null @@ -1,3 +0,0 @@ -version https://git-lfs.github.com/spec/v1 -oid sha256:647c2cd5e43e68537bf4a5bab8f144cb192012119d331691906292f415728027 -size 6086186 diff --git a/鏁版嵁/鐢靛瓙鍦板浘鏁版嵁V2.3-杞﹁溅-16 -璋冭瘯鏁版嵁-2.rar b/鏁版嵁/鐢靛瓙鍦板浘鏁版嵁V2.3-杞﹁溅-16 -璋冭瘯鏁版嵁-2.rar new file mode 100644 index 0000000..d95ddca --- /dev/null +++ b/鏁版嵁/鐢靛瓙鍦板浘鏁版嵁V2.3-杞﹁溅-16 -璋冭瘯鏁版嵁-2.rar @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7ece85f8102a1245506c3cd2bb6ef40a3fdc1ded0274715aeb1e702d8a8505b8 +size 5345627