/********************************************************
*                                                                                                            
* 文 件 名： SystemParameterManage.c   
* 版权说明： 北京交控科技有限公司 
* 创建时间： 2012-03-21
* 作    者： 联锁组
* 功能描述： 系统参数管理  
* 修改记录：   
*
********************************************************/ 

#include "SystemParameterManage.h"
#include "../QueryFiles/dquCIPZStru.h"



UINT8 LocalCiId = 0u;                        /*本机联锁ID*/

static UINT8 LocalCiPattern = 0u; /*本联锁模式*/
static UINT8 LocalCiIsDistributedIO = 0u;/*本联锁是否是分布式IO联锁*/
static UINT16 LocalUTProtectSecUnlockTime = 0u;/*本联锁UT保护区段解锁停稳时间（s）*/
static UINT16 LocalCTProtectSecUnlockTime = 0u;/*本联锁CT保护区段解锁停稳时间（s）*/
static UINT16 LocalUTNearUnLockTime = 0u;/*本联锁UT接近延时解锁超限时间（s）*/
static UINT16 LocalCTNearUnLockTime = 0u;/*本联锁CT接近延时解锁超限时间（s）*/
static UINT8 LocalWaysidePattern = 0u; /*本联锁轨旁继电器接口类型*/
/* RC合并新增，用于区分TIOC功能或者联锁联锁 */
static UINT8 LocalRcWorkMode = 0u; /* RC工作模式 */
static UINT8 gLocalRcLinkLineAttr = 0u; /* RC联络线属性 */

UINT8 gLocalOcType = 0u;                        /*OC数据结构类型*/
UINT8 gLocalPublicDataType = 0u;                        /*数据类型（区分28.0.0.11和最新公共数据结构使用）*/


SystemParameterStructNew SystemParameterStruNew;/*系统参数：按行配置*/

DquCiFuncSwitchStructNew CiFuncSwitConfStruNew[CI_FUNCTION_SWITCH_SUM_MAX];/*功能开关结构体数据*/


UINT32 StartUnlockCount = 0u;                   /*上电解锁超限周期数 (初始化字段)*/
UINT32 RouteXuanPaiCount = 0u;                  /*进路选排超限周期数 (初始化字段)*/
UINT32 RouteLockCount = 0u;                     /*进路锁闭超限周期数 (初始化字段)*/
UINT32 OverlapLockCount = 0u;                   /*保护区段锁闭超限周期数 (初始化字段)*/
UINT32 RouteOpenSignalCount = 0u;               /*进路开放超限时间(单位:s) (配置字段)*/
UINT32 BlocRouteDelayCount = 0u;                /*点式进路延时解锁周期数 (初始化字段)*/
UINT32 CbtcRouteDelayCount = 0u;                /*CBTC进路延时解锁周期数 (初始化字段)*/
UINT32 LeadRouteFaultOpenCount = 0u;            /*引导进路内方区段故障信号开放持续周期数 (初始化字段)*/
UINT32 SecDelayUnlockCount = 0u;                /*区段延时解锁周期数 (初始化字段)*/
UINT32 SignalOpenCount = 0u;                    /*信号开放超限周期数 (初始化字段)*/
UINT32 SignalCloseCount = 0u;                   /*信号关闭超限周期数 (初始化字段)*/
UINT32 SwitchMoveCount = 0u;                    /*道岔动作超限周期数 (初始化字段)*/
UINT32 SwitchDriveCount = 0u;                   /*道岔驱动超限周期数 (初始化字段)*/
UINT32 ProtectSecUnlockCount = 0u;              /*防护区段解锁停稳周期数 (初始化字段)*/
UINT32 OccupyToIdleCount = 0u;                  /*占用变空闲计时周期数 (初始化字段)*/
UINT32 FaultUnlockCount = 0u;                   /*白光带区故解计时周期数 (初始化字段)*/
UINT32 SectionResetCount = 0u;                  /*计轴复位超时周期数 (初始化字段)*/
UINT32 NonRouteXuanPaiCount = 0u;               /*非进路选排总周期数 (初始化字段)*/
UINT32 NonRouteDelayUnlockCount = 0u;           /*非进路延时解锁总周期数 (初始化字段)*/
UINT32 SwitchDriveCuoFengCount = 0u;            /*进路选排道岔错峰周期 (初始化字段)*/
UINT32 ZuheRouteXuanPaiCount = 0u;              /*组合进路选排周期 (初始化字段)*/
UINT32 CiAndZcTransmitBadEnsureCount = 0u;      /*联锁与ZC通信中断确认周期(初始化字段)*/
UINT32 CiAndCiTransmitBadEnsureCount = 0u;      /*联锁与联锁通信中断确认周期(初始化字段)*/
UINT32 CiAndVobcTransmitBadEnsureCount = 0u;    /*联锁与Vobc通信中断确认周期(初始化字段)*/
UINT32 VobcAndCiBackUpCommBadCount = 0U;        /*联锁与Ivoc或Vobc后备通道通信中断确认周期(初始化字段)*/
UINT32 CiAndPsdTransmitBadEnsureCount = 0u;     /*联锁与PSD通信中断确认周期(初始化字段)*/
UINT32 TiocAndTmcTransmitBadEnsureCnt = 0u;     /*TIOC与TMC通信中断确认周期(初始化字段)*/
UINT32 WaitZCResponseCount = 0u;                 /*等待ZC反馈时间（申请关闭车库门）(初始化字段)*/
UINT32 SecJumpLockDelayUnlockCount = 0u;			/*区段跳跃锁闭延时解锁周期数（初始化字段）*/
UINT32 GaragedoorOperateCount = 0u;              /*车库门动作超时周期数（初始化字段）*/
UINT32 CtProtectSecUnlockCount = 0u;				 /*通信车占用防护区段解锁停稳周期数 (初始化字段)*/
UINT32 SingleSwitchMoveCount = 0u;				 /*单轨单开道岔驱动超限周期数 (初始化字段)*/
UINT32 ThreeSwitchMoveCount = 0u;				 /*单轨三开道岔驱动超限周期数 (初始化字段)*/
UINT32 FiveSwitchMoveCount = 0u;				   	 /*单轨五开道岔驱动超限周期数 (初始化字段)*/
UINT32 gapDetectTimeCount = 0u;				   	 /*间隙探测时间超限周期数 (初始化字段)*/
UINT32 psdButtonPressTimeCount = 0u;				 /*站台按钮吸起失效时间超限周期数 (初始化字段)*/
UINT32 DCTYWaitSignalOpenCount = 0u;		 /*调车同意等待信号开放时间(单位:s)*/
UINT32 CiAndPscTransBadEnsureCount = 0u;		 /*联锁与Psc通信中断确认周期最大容忍时间(单位:s)*/
UINT32 ZFWJRelayDriveTimeCount = 0u;    			 /*计轴总复位命令驱动最长时间(单位:s)*/
UINT32 DHFRelayValidTimeCount = 0u;    			 /*道岔到位后DFH继电器吸起容忍时间(毫秒)*/
UINT32 FirstOrderTimeCount = 0u;                   /*一次命令有效时间(秒)。*/
UINT32 JXTCPulseContinueTimeCount = 0u;           /*间隙探测脉冲持续时间*/
UINT32 labarUnlockOverlapTimeCount = 0u;           /*人工解锁保护区段延时解锁时间*/
UINT32 sigCollectRongrenCount = 0u;				/*OC信号机全灭容忍时间*/
UINT32 AxleSectionUtRedundanceCount = 0U;		 /*计轴区段UT占用冗余周期数*/
UINT8  versionOfZCToCI = 0u;                      /*ZC-CI接口协议版本号，add by sds 2019-1-21*/
UINT8  versionOfVOBCToCI = 0u;                    /*VOBC-CI接口协议版本号，add by sds 2019-1-21*/
UINT8  versionOfTMCToTIOC = 0u;                   /*TMC-TIOC接口协议版本号*/

UINT16 wTsrMaxCmdSum = 0u;							/* 当前控区临时限速最大命令数量 */
UINT16 wTsrMaxSecSum = 0u;							/* 当前控区临时限速最大区段数量 */

UINT32 CiAndAxleTransBadEnsureCnt = 0u;    /*联锁与计轴系统通信中断确认周期(初始化字段)*/
UINT32 CiAndAxleTransBadEnsureTime = 0u; /*联锁与计轴系统通信中断确认时间(初始化字段)*/
UINT32 CiAndOcTransmitBadEnsureCount = 0u;    /*联锁与Oc通信中断确认周期(初始化字段)*/
UINT32 CiAndOcTransmitBadEnsureTime = 0u; /*联锁与Oc通信中断确认时间(初始化字段)*/
UINT32 psdDrivCloseMaxTimeCount = 0u;           /*屏蔽门关闭最大时间*/
UINT32 psdDrivOpenMaxTimeCount = 0u;           /*屏蔽门打开最大时间*/
UINT32 SpksIndicDelayCount = 0u;				/*SPKS按钮指示灯点亮延时时间*/
UINT32 mjjsOpenDelayCount = 0u;			    	/*门禁解锁延时时间延时时间*/
UINT8 ciAndAxisPrtclCheckVer = 0u;				/*联锁与计轴之间的协议版本号*/
UINT32 dwSelfButCollCount = 0u;			    	/*自复式按钮对应继电器采集时间*/
UINT32 dwSelfButErrCount = 0u;			    	/*自复式扣车/紧急按钮故障判断时间*/
UINT32 dwTrainRecycleCount = 0u;                /*资源回收计时周期数 (初始化字段)*/
UINT32 dwSelfCancelButErrCount = 0u;			/*自复式取消扣车/紧急按钮故障判断时间*/
UINT32 dwRouteNearestTrainRenJieCount = 0U;		/*进路最接近的列车需要对进路总人解时延时等待换端时间*/
UINT32 dwSGBJRouteDelayOpenCount = 0U;		/*声光报警进路延时开放周期数*/
UINT32 dwFloodGateDelayCloseCount = 0U;		/*防淹门接近区段占用延迟关门周期数*/
UINT32 dwSwitchBypassWaitCount = 0U;		/*本线联络线道岔未及时取消旁路等待周期数*/
UINT32 dwSelfCancelButErrTriggerCount = 0U;		/*自复式取消扣车/紧急按钮误触发判断时间*/
UINT16 wArbNearSecProtectDistance = 0U;		/*ARB防护距离*/
UINT32 dwArbNearSecNoUtCount = 0U;		/*ARB防护时间周期*/
UINT32 dwNonReturnBtnErrEnsureTime = 0U;/*无人折返按钮故障判断周期数*/
UINT32 dwOcCollTolerateCount = 0U;  /*OC采集容忍周期数*/
UINT8 gCTFlyingRedunCount = 0u;
UINT32 LineMinTrainLength = 0U; /*公共数据-线路最小车长*/
CiOcRelateion CiOcRelationArr[CI_SUM_MAX];/*ci oc关系数组*/

static UINT16 g_TiocFsVersion[TIOCFS_VERSION_LENGTH] = { 0u };/* TIOC数据版本号 */

/*
* 功能描述： 系统参数时间转周期数
* 参数说明： void    
* 返回值  ： void      
*/
void SystemParaTimeToCycleCount(void)
{
	UINT16 paraVal = 0u;/*参数值*/

	UINT32 appCycleTime = 0u;
	
	appCycleTime = GetSystemParaValue(AppCycleTime_ID);
	
	paraVal = GetSystemParaValue(StartUnlockTime_ID);
	StartUnlockCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);                           /*上电解锁超限周期数 (初始化字段)*/
	
	paraVal = GetSystemParaValue(RouteXuanPaiTime_ID);
	RouteXuanPaiCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);                         /*进路选排超限周期数 (初始化字段)*/
	
	paraVal = GetSystemParaValue(RouteLockTime_ID);
	RouteLockCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);                               /*进路锁闭超限周期数 (初始化字段)*/
	
	paraVal = GetSystemParaValue(OverlapLockTime_ID);
	OverlapLockCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);                           /*保护区段锁闭超限周期数 (初始化字段)*/
	
	paraVal = GetSystemParaValue(RouteOpenSigTime_ID);
	RouteOpenSignalCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);                      /*进路开放超限时间(单位:s) (配置字段)*/
	
	paraVal = LocalUTNearUnLockTime;
	BlocRouteDelayCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);                     /*点式进路延时解锁周期数 (初始化字段)*/
	
	paraVal = LocalCTNearUnLockTime;
	CbtcRouteDelayCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);                     /*CBTC进路延时解锁周期数 (初始化字段)*/
	
	paraVal = GetSystemParaValue(LeadRouteFaultOpenTime_ID);
	LeadRouteFaultOpenCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);             /*引导进路内方区段故障信号开放持续周期数 (初始化字段)*/
	
	paraVal = GetSystemParaValue(SecDelayUnlockTime_ID);
	SecDelayUnlockCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);                     /*区段延时解锁周期数 (初始化字段)*/
	
	paraVal = GetSystemParaValue(SignalOpenTime_ID);
	SignalOpenCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);                             /*信号开放超限周期数 (初始化字段)*/
	
	paraVal = GetSystemParaValue(SignalCloseTime_ID);
	SignalCloseCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);                           /*信号关闭超限周期数 (初始化字段)*/
	
	paraVal = GetSystemParaValue(SwitchMoveTime_ID);
	SwitchMoveCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);                             /*道岔动作超限周期数 (初始化字段)*/
	
	paraVal = GetSystemParaValue(SwitchDriveTime_ID);
	SwitchDriveCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);                           /*道岔驱动超限周期数 (初始化字段)*/
	
	paraVal = LocalUTProtectSecUnlockTime;
	ProtectSecUnlockCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);                 /*防护区段解锁停稳周期数 (初始化字段)*/
	
	paraVal = GetSystemParaValue(OccupyToIdleTime_ID);
	OccupyToIdleCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);                         /*占用变空闲计时周期数 (初始化字段)*/
    
	paraVal = GetSystemParaValue(FaultUnlockTime_ID);
	FaultUnlockCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);                           /*白光带区故解计时周期数 (初始化字段)*/
    
	paraVal = GetSystemParaValue(SectionResetTime_ID);
	SectionResetCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);                         /*计轴复位超时周期数 (初始化字段)*/
    
	paraVal = GetSystemParaValue(NonRouteXuanPaiTime_ID);
	NonRouteXuanPaiCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);                   /*非进路选排总周期数 (初始化字段)*/
    
	paraVal = GetSystemParaValue(NonRouteDelayUnlockTime_ID);
	NonRouteDelayUnlockCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);           /*非进路延时解锁总周期数 (初始化字段)*/
    
	paraVal = GetSystemParaValue(SwitchDriveCuoFengTime_ID);
	SwitchDriveCuoFengCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);             /*进路选排道岔错峰周期 (初始化字段)*/
    
	paraVal = GetSystemParaValue(ZuheRouteXuanPaiTime_ID);
	ZuheRouteXuanPaiCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);                 /*组合进路选排周期 (初始化字段)*/
    
	paraVal = GetSystemParaValue(WaitZCResponseTime_ID);
	WaitZCResponseCount = TimeToCycleCount((UINT32)paraVal,appCycleTime);							 /*等待ZC反馈时间（申请关闭车库门）(初始化字段)*/
	
	paraVal = GetSystemParaValue(SecJumpLockDelayUnlockTime_ID);
	SecJumpLockDelayUnlockCount = TimeToCycleCount((UINT32)paraVal * 1000U,appCycleTime);		 /*区段跳跃锁闭延时解锁周期数(初始化字段)*/
    
	paraVal = GetSystemParaValue(GaragedoorOperateTime_ID);
	GaragedoorOperateCount = TimeToCycleCount((UINT32)paraVal * 1000U,appCycleTime);                /*车库门动作超时周期数（初始化字段）*/
	
	paraVal = LocalCTProtectSecUnlockTime;
	CtProtectSecUnlockCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);              /*通信车占用进路内最后一个区段下的防护区段解锁停稳周期数 (初始化字段)*/
	
	paraVal = GetSystemParaValue(SingleSwitchMoveTime_ID);
	SingleSwitchMoveCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);				  /*单轨单开道岔驱动超限周期数 (初始化字段)*/
	
	paraVal = GetSystemParaValue(ThreeSwitchMoveTime_ID);
	ThreeSwitchMoveCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);					  /*单轨三开道岔驱动超限周期数 (初始化字段)*/
	
	paraVal = GetSystemParaValue(FiveSwitchMoveTime_ID);
	FiveSwitchMoveCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);					  /*单轨五开道岔驱动超限时间(s)*/
	
	paraVal = GetSystemParaValue(gapDetectTime_ID);
	gapDetectTimeCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);							  /*间隙探测超限周期数 (初始化字段)*/
	
	paraVal = GetSystemParaValue(psdButtonPressTime_ID);
	psdButtonPressTimeCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);				  /*站台按钮吸起失效超限周期数 (初始化字段)*/
    
	paraVal = GetSystemParaValue(DCTYWaitSignalOpenCount_ID);
	DCTYWaitSignalOpenCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);		  /*调车同意等待信号重开时间(初始化字段)*/
	
	paraVal = GetSystemParaValue(ZFWJRelayDriveTime_ID);
	ZFWJRelayDriveTimeCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);			      /*计轴总复位命令驱动最长周期数(初始化字段)*/

	paraVal = GetSystemParaValue(CiAndAxleTransmitBadEnsureTime_ID);
	CiAndAxleTransBadEnsureTime = paraVal; /*设置CI-计轴系统通信故障判断时间值*/
	CiAndAxleTransBadEnsureCnt = TimeToCycleCount((UINT32)paraVal, appCycleTime); /*CI-计轴系统通信故障判断时间(初始化字段)*/

	paraVal = GetSystemParaValue(CiAndOCTransmitBadEnsureTime_ID);
	CiAndOcTransmitBadEnsureTime = paraVal; /*设置CI-OC通信故障判断时间值*/
	CiAndOcTransmitBadEnsureCount = TimeToCycleCount((UINT32)paraVal, appCycleTime); /*CI-OC通信故障判断时间(初始化字段)*/

	paraVal = GetSystemParaValue(DHFRelayValidTime_ID);
	DHFRelayValidTimeCount = TimeToCycleCount((UINT32)paraVal, appCycleTime);			      /*道岔到位后DFH继电器吸起容忍时间(初始化字段)*/

	paraVal = GetSystemParaValue(FirstOrderTime_ID);
	FirstOrderTimeCount = TimeToCycleCount((UINT32)paraVal*1000U, appCycleTime);			      /*一次命令有效时间(秒)(初始化字段)*/

	paraVal = GetSystemParaValue(JXTCPulseContinueTime_ID);
	JXTCPulseContinueTimeCount = TimeToCycleCount((UINT32)paraVal, appCycleTime);			      /*间隙探测脉冲持续时间(初始化字段)*/

	paraVal = GetSystemParaValue(LABAR_UNLOCK_OVERLAP_time);
	labarUnlockOverlapTimeCount = TimeToCycleCount((UINT32)paraVal*1000U, appCycleTime);			      /*人工解锁保护区段延时解锁时间*/

	paraVal = GetSystemParaValue(CONFIG_SIG_RONGREN_MAX_TIME);										
	sigCollectRongrenCount = TimeToCycleCount((UINT32)paraVal, appCycleTime);					/*驱动亮灯之后采集全灭容忍时间*/

	paraVal = GetSystemParaValue(AXLE_SEG_UT_REDUNDANCE_ID);
	AxleSectionUtRedundanceCount = TimeToCycleCount((UINT32)paraVal, appCycleTime);			      /*间隙探测脉冲持续时间(初始化字段)*/

	paraVal = GetSystemParaValue(CONFIG_PSD_CLOSE_MAX_TIME);
	psdDrivCloseMaxTimeCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);			      /*屏蔽门关门超限时间*/

	paraVal = GetSystemParaValue(CONFIG_PSD_OPEN_MAX_TIME);
	psdDrivOpenMaxTimeCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);			      /*屏蔽门开门超限时间*/

	paraVal = GetSystemParaValue(CONFIG_SPKSDELAY_TIME);
	SpksIndicDelayCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);					/*SPKS按钮指示灯点亮延时时间(秒)*/

	ciAndAxisPrtclCheckVer = (UINT8)SystemParameterStruNew.VerSionBtwAxisAndCi;                     /*联锁与计轴间的协议检验版本号*/

	/************************************以下为从公共查询函数中获取********************************/
	CiAndZcTransmitBadEnsureCount = TimeToCycleCount(SystemParameterStruNew.CiAndZcTransmitBadEnsureTime, appCycleTime);        /*联锁与ZC通信中断确认周期(初始化字段)*/

	CiAndCiTransmitBadEnsureCount = TimeToCycleCount(SystemParameterStruNew.CiAndCiTransmitBadEnsureTime, appCycleTime);        /*联锁与联锁通信中断确认周期(初始化字段)*/

	CiAndVobcTransmitBadEnsureCount = TimeToCycleCount(SystemParameterStruNew.CiAndVobcTransmitBadEnsureTime, appCycleTime);    /*联锁与Vobc通信中断确认周期(初始化字段)*/

	VobcAndCiBackUpCommBadCount = TimeToCycleCount(SystemParameterStruNew.dwVobcCiBackUpCommErrorTime, appCycleTime);    /*联锁与Ivoc或VOBC后备通道通信中断确认周期(初始化字段)*/

	CiAndPsdTransmitBadEnsureCount = TimeToCycleCount(SystemParameterStruNew.CiAndPsdTransmitBadEnsureTime, appCycleTime);       /*联锁与Psd通信中断确认周期(初始化字段)*/
	
	TiocAndTmcTransmitBadEnsureCnt = TimeToCycleCount(SystemParameterStruNew.TmcOcCommunicationErrorTime, appCycleTime);       /*联锁与Psd通信中断确认周期(初始化字段)*/

	versionOfZCToCI =  (UINT8)SystemParameterStruNew.dwVersionOfZCToCI;                                                                   /*ZC-CI接口协议版本号，add by sds 2019-1-21*/
    
	versionOfVOBCToCI = (UINT8)SystemParameterStruNew.dwVersionOfVOBCToCI;                                                                /*VOBC-CI接口协议版本号，add by sds 2019-1-21*/
	
	CiAndPscTransBadEnsureCount = TimeToCycleCount(SystemParameterStruNew.CiAndPscTransmitBadEnsureTime, appCycleTime);           /*联锁与PSC通信中断确认周期(初始化字段)*/

	wTsrMaxCmdSum = SystemParameterStruNew.MaxTsrNum;			/* 临时限速数量 */
	wTsrMaxSecSum = SystemParameterStruNew.MaxSectionOfTsr;		/* 临时限速区段数量 */

	paraVal = GetSystemParaValue(CT_FlYING_REDUN_TIME_ID);
	gCTFlyingRedunCount = (UINT8)TimeToCycleCount((UINT32)paraVal, appCycleTime);			      /*飞车宕机容忍周期数初始化*/

	paraVal = GetSystemParaValue(CONFIG_MJJSOPENDELAY_TIME);
	mjjsOpenDelayCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);					/*SPKS按钮指示灯点亮延时时间(秒)*/

	paraVal = GetSystemParaValue(ZFS_BUTTON_RELAY_COLL_TIME);
	dwSelfButCollCount = TimeToCycleCount((UINT32)paraVal, appCycleTime);			      /*自复式按钮对应继电器采集时间（ms）(初始化字段)*/

	paraVal = GetSystemParaValue(ZFS_BUTTON_FAULT_ENSURE_TIME);
	dwSelfButErrCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);			      /*自复式扣车/紧急按钮故障判断时间（s）*/

	paraVal = GetSystemParaValue(TRAIN_RECYCLE_RES_TIME);
	dwTrainRecycleCount = TimeToCycleCount((UINT32)paraVal, appCycleTime);			      /*资源回收计时时间（ms）*/

	paraVal = GetSystemParaValue(ZFS_CANCEL_BTN_ERR_ENSURE_TIME);
	dwSelfCancelButErrCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);    /*自复式取消扣车/紧急按钮故障判断时间（s）*/

	paraVal = GetSystemParaValue(ROUTE_NEAREST_TRAIN_RENJIE_TIME);
	dwRouteNearestTrainRenJieCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);		/*进路最接近的列车需要总人解进路时延时等待时间（s）*/

	paraVal = GetSystemParaValue(SGBJ_ROUTE_DELAY_OPEN_TIME);
	dwSGBJRouteDelayOpenCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);		/*声光报警进路延时开放等待时间（s）*/

	paraVal = GetSystemParaValue(FLOODGATE_ACCESS_OCC_DELAY_OPEN_TIME);
	dwFloodGateDelayCloseCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);		/*防淹门接近区段占用延迟关门时间(S)*/

	paraVal = GetSystemParaValue(SWITCH_BYPASS_DELAY_TIME);
	dwSwitchBypassWaitCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);		/*本线路联络线道岔未及时取消旁路等待时间(S)*/

	paraVal = GetSystemParaValue(ZFS_CANCEL_BTN_ERR_TRIGGER_TIME);
	dwSelfCancelButErrTriggerCount = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);  /*自复式取消扣车/紧急按钮误触发判断时间（s）*/

	wArbNearSecProtectDistance = GetSystemParaValue(ARB_CHECK_ALXE_SEC_LEN);

	paraVal = GetSystemParaValue(ARB_CHECK_ALXE_TIME); 
	dwArbNearSecNoUtCount = TimeToCycleCount((UINT32)paraVal, appCycleTime);			      /*ARB区段检查相邻区段上次UT占用经过时间  (配置单位ms)*/

	LineMinTrainLength = SystemParameterStruNew.dwLineMinTrainLength;        /*公共数据-线路最小车长*/

	paraVal = GetSystemParaValue(NONRETURN_BTN_ERR_ENSURE_TIME);
	dwNonReturnBtnErrEnsureTime = TimeToCycleCount((UINT32)paraVal * 1000U, appCycleTime);			      /*无人折返按钮故障判断时间（秒/S）*/

	paraVal = GetSystemParaValue(OC_COLL_TOLERATE_TIME);
	dwOcCollTolerateCount = TimeToCycleCount((UINT32)paraVal, appCycleTime);  /*C采集容忍周期数（ESB/PSD/SPKS/扣车）（ms）*/
}

/*
* 功能描述： 时间转周期数
* 参数说明： const UINT32 deviceTime, 设备时间
*			 const UINT32 appTime, 应用时间   
* 返回值  ： 周期数      
*/
UINT32 TimeToCycleCount(const UINT32 deviceTime, const UINT32 appTime)
{
	UINT32 rev = 0u;/*商*/

    /*appTime作为除数*/
    if (appTime == 0u)
    {
        /*除数不能为0*/

    }
    else
    {
        rev = deviceTime / appTime;
        
        if (deviceTime % appTime != 0u)
        {/*不能整除*/
            
            rev++;
	    }
    }	

	return rev;
}

/*
* 功能描述： 获取联锁应用周期(单位:ms)
* 参数说明： void    
* 返回值  ： UINT8      
*/
UINT32 GetSystemParaAppCycleTime(void)
{
	UINT32 appCycle = 0u;
	appCycle = (UINT32)GetSystemParaValue(AppCycleTime_ID);
    return appCycle;
}

/*
* 功能描述： 获取本机联锁ID
* 参数说明： void    
* 返回值  ： UINT8      
*/
UINT8 GetSystemParaLocalCiId(void)
{
    return LocalCiId;
}

/*
* 功能描述： 获取配置参数值
* 参数说明： UINT16 paraID,参数ID    
* 返回值  ：
*			UINT16，参数值      
*/
UINT16 GetSystemParaValue(UINT16 paraID)
{
	UINT16 retVal = 0u;

	if (CI_SYSTEM_PARA_SUM_MAX > paraID)
	{
		retVal = SystemParameterStruNew.ParaStru[paraID].SysParaValue;
	}
	else
	{
		;
	}
	
	return retVal;
}

/*
* 功能描述： 获取联锁总数
* 参数说明： void    
* 返回值  ： UINT8      
*/
UINT8 GetSystemParaCiSum(void)
{
	UINT8 CiSum = (UINT8)GetSystemParaValue(CiSum_ID);
    return CiSum;
}


/*
* 功能描述： 获取系统参数上电解锁超限周期数
* 参数说明： void    
* 返回值  ： 上电解锁超限周期数      
*/
UINT32 GetSystemParaStartUnlockCyc(void)
{
    return StartUnlockCount;
}


/*
* 功能描述： 获取系统参数进路选排超限周期数
* 参数说明： void    
* 返回值  ： 进路选排超限周期数      
*/
UINT32 GetSystemParaRouteXuanPaiCyc(void)
{
    return RouteXuanPaiCount;
}

/*
* 功能描述： 获取系统参数进路锁闭超限周期数
* 参数说明： void    
* 返回值  ： 进路选排超限周期数      
*/
UINT32 GetSystemParaRouteLockCyc(void)
{
    return RouteLockCount;
}

/*
* 功能描述： 获取系统参数保护区段锁闭超限周期数
* 参数说明： void    
* 返回值  ： 进路选排超限周期数      
*/
UINT32 GetSystemParaOverlapLockCyc(void)
{
    return OverlapLockCount;
}

/*
* 功能描述： 获取系统参数进路开放信号超限周期数
* 参数说明： void    
* 返回值  ： 进路选排超限周期数      
*/
UINT32 GetSystemParaRouteOpenSigCyc(void)
{
    return RouteOpenSignalCount;
}

/*
* 功能描述： 获取系统参数点式进路延时解锁周期数
* 参数说明： void    
* 返回值  ： 点式进路延时解锁周期数      
*/
UINT32 GetSystemParaBlocRouteDelayCyc(void)
{
    return BlocRouteDelayCount;
}


/*
* 功能描述： 获取系统参数CBTC进路延时解锁周期数
* 参数说明： void    
* 返回值  ： CBTC进路延时解锁周期数      
*/
UINT32 GetSystemParaCbtcRouteDelayCyc(void)
{
    return CbtcRouteDelayCount;
}

/*
* 功能描述： 获取资源取消申请延时周期数，调用总人解延时时间
* 参数说明： void
* 返回值  ： 资源取消申请延时周期数
*/
UINT32 GetRouteResCancelApplyCyc(void)
{
	UINT32 ResCancelApplyCycleCount = 0U;

	ResCancelApplyCycleCount = GetSystemParaCbtcRouteDelayCyc();

	return ResCancelApplyCycleCount;
}

/*
* 功能描述： 获取进路最接近的列车需要总人解进路时延时等待周期数
* 参数说明： void
* 返回值  ： CBTC进路延时解锁周期数
*/
UINT32 GetRouteTrainRanJieDelayCyc(void)
{
	return dwRouteNearestTrainRenJieCount;
}

/*
* 功能描述： 获取系统参数引导进路内方区段故障信号开放持续周期数
* 参数说明： void    
* 返回值  ： 引导进路内方区段故障信号开放持续周期数      
*/
UINT32 GetSystemParaLeadFaultOpenCyc(void)
{
    return LeadRouteFaultOpenCount;
}


/*
* 功能描述： 获取系统参数区段延时解锁周期数
* 参数说明： void    
* 返回值  ： 区段延时解锁周期数      
*/
UINT32 GetSystemParaSecDelayUnlockCyc(void)
{
    return SecDelayUnlockCount;
}


/*
* 功能描述： 获取系统参数信号开放超限周期数
* 参数说明： void    
* 返回值  ： 信号开放超限周期数      
*/
UINT32 GetSystemParaSignalOpenCyc(void)
{
    return SignalOpenCount;
}


/*
* 功能描述： 获取系统参数信号关闭超限周期数
* 参数说明： void    
* 返回值  ： 信号关闭超限周期数      
*/
UINT32 GetSystemParaSignalCloseCyc(void)
{
    return SignalCloseCount;
}


/*
* 功能描述： 获取系统参数道岔动作周期数
* 参数说明： void    
* 返回值  ： 道岔动作周期数      
*/
UINT32 GetSystemParaSwitchMoveCyc(void)
{
    return SwitchMoveCount;
}


/*
* 功能描述： 获取系统参数道岔驱动周期数
* 参数说明： void    
* 返回值  ： 道岔驱动周期数      
*/
UINT32 GetSystemParaSwitchDriveCyc(void)
{
    return SwitchDriveCount;
}


/*
* 功能描述： 获取系统参数防护区段解锁停稳周期数
* 参数说明： void    
* 返回值  ： 防护区段解锁停稳周期数
*/
UINT32 GetSystemParaProtSecUnlockCyc(void)
{
    return ProtectSecUnlockCount;
}


/*
* 功能描述： 获取CT车占用进路内最后一个区段情况下的解锁停稳周期数
* 参数说明： void   
* 返回值  ： 通信车占用防护区段解锁停稳周期数
*/
UINT32 GetSystemParaCtProtSecUnlockCyc(void)
{
    return CtProtectSecUnlockCount;
}

/*
* 功能描述： 获取系统参数占用变空闲计时周期数
* 参数说明： void    
* 返回值  ： 占用变空闲计时周期数      
*/
UINT32 GetSystemParaOccuToIdleCyc(void)
{
    return OccupyToIdleCount;
}

/*
* 功能描述： 获取系统参数白光带区故解计时周期数
* 参数说明： void    
* 返回值  ： 计时周期数      
*/
UINT32 GetSystemParaFaultUnlockCyc(void)
{
    return FaultUnlockCount;
}

/*
* 功能描述： 获取系统参数计轴复位超时周期数
* 参数说明： void    
* 返回值  ： 计时周期数      
*/
UINT32 GetSystemParaSectionResetCount(void)
{
    return SectionResetCount;
}

/*
* 功能描述： 资源回收超时周期数
* 参数说明： void
* 返回值  ： 计时周期数
*/
UINT32 GetSystemParaTrainReCycleCount(void)
{
	return dwTrainRecycleCount;
}
/*
* 功能描述： 时间参数超时检查
* 参数说明： UINT32 StartCount 开始时间
*			 UINT32 MaxCount   最大时间 
* 返回值  ： CI_TIME_NO        未计时
*			 CI_TIME_IN        未超时          
*			 CI_TIME_OUT       超时
*/
UINT8 SystemOverTimeCheck(UINT32 StartCount, UINT32 MaxCount)
{
    UINT32 nowTime = 0u;
    UINT32 subTime = 0u;
	UINT8 retVal = CI_TIME_OUT;

    nowTime = Get2oo2CurCycleNum();

    if (StartCount == 0u)
    {
        /*未计时*/
        retVal = CI_TIME_NO;
    }
    else
    {
        subTime = nowTime - StartCount;
        if (subTime <= MaxCount)
        {
            /*未超时*/
            retVal = CI_TIME_IN;
        }
        else
        {
            /*超时*/
            retVal = CI_TIME_OUT;
        }
    }
	return retVal;
}

/*
* 功能描述： 检查时间是否达到或超过最大值
* 参数说明： UINT32 StartCount 开始时间
*			 UINT32 MaxCount   最大时间
* 返回值  ： CI_TIME_NO        未计时
*			 CI_TIME_IN        未超时
*			 CI_TIME_OUT       超时
*/
UINT8 SystemOverOrEqualTimeCheck(UINT32 StartCount, UINT32 MaxCount)
{
	UINT32 nowTime = 0U;
	UINT32 subTime = 0U;
	UINT8 retVal = CI_TIME_OUT;

	nowTime = Get2oo2CurCycleNum();

	if (StartCount == 0U)
	{
		/*起始时间为0，未计时*/
		retVal = CI_TIME_NO;
	}
	else
	{
		subTime = nowTime - StartCount;
		if (subTime < MaxCount)
		{
			/*起始时间小于最大值，未超时*/
			retVal = CI_TIME_IN;
		}
		else
		{
			/*起始时间大于等于最大值，超时*/
			retVal = CI_TIME_OUT;
		}
	}

	return retVal;
}


/*
* 功能描述： 获取系统参数非进路选排总周期数
* 参数说明： void    
* 返回值  ： 计时周期数      
*/
UINT32 GetSystemParaNonRouteXuanPaiCnt(void)
{
    return NonRouteXuanPaiCount;
}


/*
* 功能描述： 获取系统参数非进路延时解锁总周期数
* 参数说明： void    
* 返回值  ： 计时周期数      
*/
UINT32 GetSystemParaNonRDelayUnlockCnt(void)
{
    return NonRouteDelayUnlockCount;
}

/*
* 功能描述： 获取进路选排道岔错峰总周期数
* 参数说明： void    
* 返回值  ： 计时周期数      
*/
UINT32 GetSystemParaSwDrvCuoFengCnt(void)
{
    return SwitchDriveCuoFengCount;
}


/*
* 功能描述： 获取组合进路选排总周期数
* 参数说明： void    
* 返回值  ： 计时周期数      
*/
UINT32 GetSystemParaZuheRXuanPaiCnt(void)
{
    return ZuheRouteXuanPaiCount;
}

/*
* 功能描述： 获取联锁与ZC通信中断确认周期数
* 参数说明： void    
* 返回值  ： 计时周期数
*/
UINT32 GetCiAndZcTransBadEnsureCnt(void)
{
    return CiAndZcTransmitBadEnsureCount;
}

/*
* 功能描述： 获取TIOC与TMC通信中断确认周期数
* 参数说明： void
* 返回值  ： 计时周期数
*/
UINT32 GetTiocAndTmcTransBadEnsureCnt(void)
{
	return TiocAndTmcTransmitBadEnsureCnt;
}

/*
* 功能描述： 获取联锁与计轴系统通信中断确认周期数
* 参数说明： void
* 返回值  ： 计时周期数
*/
UINT32 GetCiAndAxleTransBadEnsureCnt(void)
{
	return CiAndAxleTransBadEnsureCnt;
}

/*
* 功能描述： 获取联锁与OC通信中断确认周期数
* 参数说明： void
* 返回值  ： 计时周期数
*/
UINT32 GetCiAndOcTransmitBadEnsureCnt(void)
{
	return CiAndOcTransmitBadEnsureCount; /*暂定10个周期，3秒，后续增加配置*/
}

/*
* 功能描述： 获取联锁与联锁通信中断确认周期数
* 参数说明： void    
* 返回值  ： 计时周期数
*/
UINT32 GetCiAndCiTransBadEnsureCnt(void)
{
    return CiAndCiTransmitBadEnsureCount;
}

/*
* 功能描述： 获取联锁与Vobc通信中断确认周期数
* 参数说明： void    
* 返回值  ： 计时周期数
*/
UINT32 GetCiAndVobcTransBadEnsureCnt(void)
{
    return CiAndVobcTransmitBadEnsureCount;
}

/*
* 功能描述： 获取联锁与PSD通信中断确认周期数
* 参数说明： void    
* 返回值  ： 计时周期数
*/
UINT32 GetCiAndPsdTransBadEnsureCnt(void)
{
    return CiAndPsdTransmitBadEnsureCount;
}

/*
* 功能描述： 获取本联锁类型
* 参数说明： void    
* 返回值  ： 本联锁类型    
*/
UINT8 GetLocalCiType(void)
{
    return SystemParameterStruNew.CiType;
}


/*
* 功能描述： 获取等待ZC反馈时间
* 参数说明： void    
* 返回值  ： 等待ZC反馈时间    
*/
UINT32 GetWaitZCResponseCount(void)
{
    return WaitZCResponseCount;
}

/*
* 功能描述： 获取系统参数区段跳跃锁闭延时解锁周期数
* 参数说明： void    
* 返回值  ： 区段跳跃锁闭延时解锁周期数      
*/
UINT32 GetSysParaSecJLokDelayUnlockCyc(void)
{
	return SecJumpLockDelayUnlockCount;
}


/*
* 功能描述： 获取指定联锁功能开关配置值
* 参数说明： INT32 FunctionConfigIndex 指定联锁功能开关配置索引
	CLOSE_OPENED_SIG_LOCK_SWITCH 	封锁道岔后关闭已开放信号
	CLOSE_OPENED_SIG_LOCK_SIGNAL 	封锁信号机后关闭已开放信号
	CHECK_SWITCH_LOCKING_BEFORE_LOCKING_SWITCH_CONF	封锁道岔时检查道岔锁闭
	CHECK_SWITCH_DANLOCK_FLOCKING_SWITCH_CONF			封锁道岔时检查道岔单锁
	
* 返回值  ： 指定联锁功能开关配置值0xAA或0x55或0xFF
*/
UINT8 GetCiFunctionSwitchConfig(UINT8 FunctionConfigIndex)
{
	UINT8 retVal = FUNC_SWITCH_UNDEF;

	if(CI_FUNCTION_SWITCH_SUM_MAX > FunctionConfigIndex)
	{
		retVal = CiFuncSwitConfStruNew[FunctionConfigIndex].wCiFuncSwitchVal;
	}
	else
	{
		retVal = FUNC_SWITCH_UNDEF;

		DebugPrintAppError(ERROR_INDEX_EXCEED,CI_DEVICE_TYPE_FS_TABLE,((UINT32)CI_SYSTEM_PARAMETER_DATA_TYPE<<24u)+((UINT32)CI_SYSTEM_CI_FUNC_SWITCH_ID<<16u)+ (UINT32)CI_FUNCTION_SWITCH_SUM_MAX,PRINT_CYCLE);
	}
	
	return retVal;
}

/*
* 功能描述： 获取联锁与联锁通信中断确认时间单位毫秒
* 参数说明：
无
* 返回值  ： 联锁与联锁通信中断确认时间单位毫秒
*/
UINT32 GetCiAndCiTransmitBadEnsureTime(void)
{
	return SystemParameterStruNew.CiAndCiTransmitBadEnsureTime;
}
/*
* 功能描述： 获取联锁与Vobc通信中断确认时间单位毫秒
* 参数说明：
无
* 返回值  ： 联锁与Vobc通信中断确认时间单位毫秒
*/
UINT32 GetCiAndVobcTransBadEnsureTime(void)
{
	return SystemParameterStruNew.CiAndVobcTransmitBadEnsureTime;
}

/*
* 功能描述： 获取联锁与ZC通信中断确认时间单位毫秒
* 参数说明：
无
* 返回值  ： 联锁与ZC通信中断确认时间单位毫秒
*/
UINT32 GetCiAndZcTransmitBadEnsureTime(void)
{
	return SystemParameterStruNew.CiAndZcTransmitBadEnsureTime;
}

/*
* 功能描述： 获取TIOC与TMC通信中断确认时间单位毫秒
* 参数说明：
无
* 返回值  ： TIOC与TMC通信中断确认时间单位毫秒
*/
UINT32 GetTiocAndTmcTransBadEnsureTime(void)
{
	return SystemParameterStruNew.TmcOcCommunicationErrorTime;
}


/*
* 功能描述： 获取联锁与计轴系统通信中断确认时间单位毫秒
* 参数说明：
无
* 返回值  ： 联锁与计轴系统通信中断确认时间单位毫秒
*/
UINT32 GetCiAndAxleTransBadEnsureTime(void)
{
	return CiAndAxleTransBadEnsureTime;
}

/*
* 功能描述： 获取联锁与OC通信中断确认时间单位毫秒
* 参数说明：
无
* 返回值  ： 联锁与OC通信中断确认时间单位毫秒
*/
UINT32 GetCiAndOcTransmitBadEnsureTime(void)
{
	return CiAndOcTransmitBadEnsureTime;
}

/*
* 功能描述： 获取系统参数车库门动作超时周期数
* 参数说明： void    
* 返回值  ： 计时周期数      
*/
UINT32 GetSysParaGaragedoorOperateCnt(void)
{
	return GaragedoorOperateCount;
}
/* zt 删除单轨相关代码 2022-02-15 */

/*
* 功能描述： 获取间隙探测超限周期数
* 参数说明： void    
* 返回值  ： 间隙探测超限周期数      
*/
UINT32 GetGapDetectCount(void)
{
	return gapDetectTimeCount;
}

/*
* 功能描述： 获取站台按钮吸起失效超限周期数
* 参数说明： void    
* 返回值  ： 站台按钮吸起失效超限周期数      
*/
UINT32 GetPsdButtonPressCount(void)
{
	return psdButtonPressTimeCount;
}

/*
* 功能描述： 获取计轴总复位驱动失效超限周期数
* 参数说明： void    
* 返回值  ： 计轴总复位驱动失效超限周期数      
*/
UINT32 GetZFWJRelayDriveTimeCount(void)
{
	return ZFWJRelayDriveTimeCount;
}

/*
* 功能描述： 道岔到位后DFH继电器吸起容忍周期数
* 参数说明： void    
* 返回值  ： DFH继电器吸起容忍周期数  
*/
UINT32 GetDHFRelayValidTimeCount(void)
{
	return DHFRelayValidTimeCount;
}


/*
* 功能描述： 获取ZC-CI接口协议版本号
* 参数说明： void    
* 返回值  ： ZC-CI接口协议版本号      
*/
UINT8 GetVersionOfZCToCI(void)
{
	return versionOfZCToCI;
}

/*
* 功能描述： 获取TMC-TIOC接口协议版本号
* 参数说明： void
* 返回值  ： TMC-TIOC接口协议版本号
*/
UINT8 GetVersionOfTMCToTIOC(void)
{
	return versionOfZCToCI;
}

/*
* 功能描述： 获取VOBC-CI接口协议版本号
* 参数说明： void    
* 返回值  ： VOBC-CI接口协议版本号      
*/
UINT8 GetVersionOfVOBCToCI(void)
{
	return versionOfVOBCToCI;
}

/*
* 功能描述： 获取联锁与Psc通信中断确认周期数
* 参数说明： void    
* 返回值  ： 计时周期数
*/
UINT32 GetCiAndPscTransBadEnsureCnt(void)
{
	return CiAndPscTransBadEnsureCount;
}



/*
* 功能描述： 获取调车同意等待信号开放周期数
* 参数说明： void    
* 返回值  ： 计时周期数
*/
UINT32 GetSysParaDCTYWaitSigOpenCnt(void)
{
	return DCTYWaitSignalOpenCount;
}

/*
* 获取本联锁模式
* 参数说明：void
* 返回值：联锁模式
*/
UINT8 GetLocalCiPattern(void)
{
	return LocalCiPattern;
}




/*
* 获取正线TIOC动态测试开关
* 参数说明：void
* 返回值：正线动态测试开关
*/
UINT8 GetZXDynamicTestSwitch(void)
{
	return SystemParameterStruNew.chZXDynamicTestSwitch;
}

/*
* 获取TIOC动态测试开关
* 参数说明：void
* 返回值：TIOC动态测试开关
*/
UINT8 GetDynamicTestSwitch(void)
{
	return SystemParameterStruNew.chDynamicTestSwitch;
}

/*
* 设置本联锁模式
* 参数说明：本方CI模式
* 返回值：是否设置成功
*/
UINT8 SetLocalCiPattern(UINT8 localCiPattern)
{
	UINT8 rtn = 0u; /*返回值*/

	if ((CI_PATTERN_TRADITIONAL == localCiPattern) || (CI_PATTERN_FULL_ELECTRONIC == localCiPattern))
	{
		LocalCiPattern = localCiPattern;
		rtn = 1u;
	}

	return rtn;
}

/*
* 设置本联锁集中式/分布式IO
* 参数说明：本方CI IO集成方式
* 返回值：是否设置成功
*/
UINT8 SetLocalCiDistributedIO(UINT8 distributedIO)
{
	UINT8 rtn = 0u; /*返回值*/

	if ((CI_CENTER_IO == distributedIO) || (CI_DISTRIBUTED_IO == distributedIO))
	{
		LocalCiIsDistributedIO = distributedIO;
		rtn = 1u;
	}

	return rtn;
}

/*
* 获取本联锁IO设备集成方式
* 参数说明：本方CI IO集成方式
* 返回值：IO集成方式
*/
UINT8 GetLocalCiDistributedIO(void)
{
	return LocalCiIsDistributedIO;
}

/*
* 功能描述：设置本联锁UT保护区段延时解锁停稳时间
* 参数说明：延时解锁停稳时间 
* 返回值：void
*/
void SetLocalCiUTProtSecUnlockTime(UINT16 localUTProtectSecUnlockTime)
{	
	LocalUTProtectSecUnlockTime = localUTProtectSecUnlockTime;
}

/*
* 功能描述：设置本联锁CT保护区段延时解锁停稳时间
* 参数说明：延时解锁停稳时间 
* 返回值：void
*/
void SetLocalCiCTProtSecUnlockTime(UINT16 localCTProtectSecUnlockTime)
{	
	LocalCTProtectSecUnlockTime = localCTProtectSecUnlockTime;
}

/********/
/*
* 功能描述：设置本联锁UT接近延时解锁超限时间
* 参数说明：延时解锁停稳时间 
* 返回值：void
*/
void SetLocalCiUTNearUnLockTime(UINT16 localUTNearUnLockTime)
{	
	LocalUTNearUnLockTime = localUTNearUnLockTime;
}

/*
* 功能描述：设置本联锁CT接近延时解锁超限时间
* 参数说明：延时解锁停稳时间 
* 返回值：void
*/
void SetLocalCiCTNearUnLockTime(UINT16 localCTNearUnLockTime)
{	
	LocalCTNearUnLockTime = localCTNearUnLockTime;
}
/*
* 功能描述： 设置一次命令有效周期数
* 参数说明： void    
* 返回值  ： 一次命令有效周期数  
*/
UINT32 GetFirstOrderTimeCount(void)
{
	return FirstOrderTimeCount;
}


/*
* 功能描述： 获取间隙探测脉冲持续周期数
* 参数说明： void    
* 返回值  ： 间隙探测脉冲持续周期数 
*/
UINT32 GetJXTCPulseContinueTimeCount(void)
{
	return JXTCPulseContinueTimeCount;
}

/*
* 功能描述： 获取计轴区段非通信车占压冗余周期数
* 参数说明： void
* 返回值  ： UINT32
* 创建    ：qw.liu 2022-02-22
*/
UINT32 GetSysParaAxleUtRedunCount(void)
{
	return AxleSectionUtRedundanceCount;
}

/*
* 功能描述： 获取信号机点灯区段长大计轴长度
* 参数说明： void
* 返回值  ： UINT32
* 创建    ：qw.liu 2022-02-22
*/
UINT16 GetSigLightUpBigAxleSecLen(void)
{
	UINT16 wSigLightUpBigAxleSecLen = 0U;

	wSigLightUpBigAxleSecLen = GetSystemParaValue(SIGNAL_LIGHTUP_BIG_ALXE_SEC_LEN_ID);

	return wSigLightUpBigAxleSecLen;
}

/*
* 功能描述： 获取信号机点灯区段延长计轴长度
* 参数说明： void
* 返回值  ： UINT32
* 创建    ：qw.liu 2022-02-22
*/
UINT16 GetSigLightUpExAxleSecLen(void)
{
	UINT16 wSigLightUpExAxleSecLen = 0U;

	wSigLightUpExAxleSecLen = GetSystemParaValue(SIGNAL_LIGHTUP_EX_ALXE_SEC_LEN_ID);

	return wSigLightUpExAxleSecLen;
}

/*
* 功能描述： 获取跨压信号机最大距离
* 参数说明： void
* 返回值  ： UINT32
* 创建    ：qw.liu 2022-03-03
*/
UINT16 GetSigCrossMaxLen(void)
{
	UINT16 wSigCrossMaxLen = 0U;

	wSigCrossMaxLen = GetSystemParaValue(SIGNAL_CROSS_MAX_LEN_ID);

	return wSigCrossMaxLen;
}


/*
* 功能描述： 获取线路最小车长
* 参数说明： void
* 返回值  ： UINT32
* 创建    ： 2022-03-12
*/
UINT32 GetShortestTrainLen(void)
{
	return LineMinTrainLength;
}


/*
* 获取 全线免筛开关
* 参数说明：UINT8
* 返回值：全线免筛开关
*/
UINT8 GetWLSFunSwitch(void)
{
	return SystemParameterStruNew.chWLSFunSwitch;
}

/*
* 功能描述： 获取TIOC数据版本号存放地址
* 参数说明： void
* 返回值  ： NULL 失败
*			 其他 成功
* 创建    ： 2022-03-12
*/
UINT16* GetTiocFsVersion(void)
{
	return g_TiocFsVersion;
}

/*
* 功能描述： 设置TIOC数据版本号存放地址
* 参数说明： UINT8* pSrcFsVersion 电子地图版本号存放地址
* 创建    ： 2022-03-12
*/

void SetTiocFsVersion(UINT8* pSrcFsVersion)
{
	UINT8 index = 0u;

	if (NULL != pSrcFsVersion)
	{
		g_TiocFsVersion[index] = (UINT16)pSrcFsVersion[index];
		index++;
		g_TiocFsVersion[index] = (UINT16)pSrcFsVersion[index];
		index++;
		g_TiocFsVersion[index] = (UINT16)(pSrcFsVersion[index] << 4u) + (UINT16)(pSrcFsVersion[index + 1u] >> 4u);
		index++;
		g_TiocFsVersion[index] = (UINT16)((UINT16)pSrcFsVersion[index] & 0x0Fu);
	}
	else
	{
	}
}

/*
* 功能描述： 校验TIOC公共数据结构版本号
* 参数说明： UINT8* pSrcFsVersion 公共数据结构版本号存放地址
* 返回值：CI_SUCCESS 兼容  CI_ERROR 不兼容
* 创建    ： 20240605 LC
*/
UINT8 CheckTiocPublicFsVersion(UINT8* pSrcFsVersion)
{
	UINT8 retVal = CI_ERROR;

	if (NULL != pSrcFsVersion)
	{
		SetLocalPublicDataType(DATA_TYPE_NEW);
		/*查询公共数据结构版本号是否属于可兼容的版本 
		28.0.0.14及其升级版本只支持配置到第三个兼容数据结构 VER_3_PUBLIC*/
		if ((VER_1_PUBLIC_FS_1 == pSrcFsVersion[0]) && (VER_1_PUBLIC_FS_2 == pSrcFsVersion[1]) && (VER_1_PUBLIC_FS_3 == pSrcFsVersion[2]) && (VER_1_PUBLIC_FS_4 == pSrcFsVersion[3]))
		{
			retVal = CI_SUCCESS;
		}
		else if ((VER_2_PUBLIC_FS_1 == pSrcFsVersion[0]) && (VER_2_PUBLIC_FS_2 == pSrcFsVersion[1]) && (VER_2_PUBLIC_FS_3 == pSrcFsVersion[2]) && (VER_2_PUBLIC_FS_4 == pSrcFsVersion[3]))
		{
			retVal = CI_SUCCESS;
		}
		else if ((VER_3_PUBLIC_FS_1 == pSrcFsVersion[0]) && (VER_3_PUBLIC_FS_2 == pSrcFsVersion[1]) && (VER_3_PUBLIC_FS_3 == pSrcFsVersion[2]) && (VER_3_PUBLIC_FS_4 == pSrcFsVersion[3]))
		{
			SetLocalPublicDataType(DATA_TYPE_OLD);
			retVal = CI_SUCCESS;
		}
		else
		{
			/*返回失败*/
		}
	}
	else
	{
		/*返回失败*/
	}
	return retVal;
}


/*
* 功能描述： 校验TIOC私有数据结构版本号
* 参数说明： UINT8* pSrcFsVersion 私有数据结构版本号存放地址
* 返回值：CI_SUCCESS 兼容  CI_ERROR 不兼容
* 创建    ： 20240605 LC
*/
UINT8 CheckTiocPrivateFsVersion(UINT8* pSrcFsVersion)
{
	UINT8 retVal = CI_ERROR;

	if (NULL != pSrcFsVersion)
	{
		/*查询私有数据结构版本号是否属于可兼容的版本*/
		if ((VER_1_PRIVATE_FS_1 == pSrcFsVersion[0]) && (VER_1_PRIVATE_FS_2 == pSrcFsVersion[1]))
		{
			retVal = CI_SUCCESS;
		}
		else if ((VER_2_PRIVATE_FS_1 == pSrcFsVersion[0]) && (VER_2_PRIVATE_FS_2 == pSrcFsVersion[1]))
		{
			retVal = CI_SUCCESS;
		}
		else if ((VER_3_PRIVATE_FS_1 == pSrcFsVersion[0]) && (VER_3_PRIVATE_FS_2 == pSrcFsVersion[1]))
		{
			retVal = CI_SUCCESS;
		}
		else
		{
			/*返回失败*/
		}
	}
	else
	{
		/*返回失败*/
	}
	return retVal;
}

/*
* 功能描述： 校验OC数据结构版本号
* 参数说明： UINT8* pSrcFsVersion 私有数据结构版本号存放地址
* 返回值：CI_SUCCESS 兼容  CI_ERROR 不兼容
* 创建    ： 20250210 fan
*/
UINT8 CheckTiocOcFsVersion(UINT8* pSrcFsVersion)
{
	UINT8 retVal = CI_ERROR;

	if (NULL != pSrcFsVersion)
	{
		/*查询OC数据结构版本号是否属于可兼容的版本*/
		if ((VER_1_OCDATA_FS_1 == pSrcFsVersion[0]) && (VER_1_OCDATA_FS_2 == pSrcFsVersion[1]))
		{
			retVal = SetLocalOcPattern(DATA_TYPE_NEW);
		}
		else if ((VER_2_OCDATA_FS_1 == pSrcFsVersion[0]) && (VER_2_OCDATA_FS_2 == pSrcFsVersion[1]))
		{
			retVal = SetLocalOcPattern(DATA_TYPE_OLD);
		}
		else
		{
			/*返回失败*/
		}
	}
	else
	{
		/*返回失败*/
	}
	return retVal;
}


/*********************************************
*函数功能：获取静态数据
*参数说明：UINT32* pConfigDataAdderBuf 静态数据存放地址,UINT16 pConfigDataLenBuf 静态数据长度存放地址,UINT16 wBufMaxLen数组容量
*返回值：静态数据数量
*********************************************/
UINT16 GetTiocSystemParameterData(UINT32* pConfigDataAdderBuf, UINT16* pConfigDataLenBuf, UINT16 wBufMaxLen)
{
	UINT16 wRetSum = 0u;
	UINT16 wTmpConfigDataSum = 0u;
	UINT16 wTmpLen = 0u;

	if ((NULL != pConfigDataAdderBuf) && (NULL != pConfigDataLenBuf) && (0u != wBufMaxLen) && (UINT16_MAX != wBufMaxLen))
	{
		/*本联锁模式*/
		wTmpLen = 1u + wTmpConfigDataSum;
		
			pConfigDataAdderBuf[wTmpConfigDataSum] = &LocalCiPattern;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT8);
			wTmpConfigDataSum++;
		
		
		/*本联锁是否是分布式IO联锁*/
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &LocalCiIsDistributedIO;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT8);
			wTmpConfigDataSum++;
		}
		else
		{
			;/*无处理 */
		}
		/*本联锁UT保护区段解锁停稳时间（s）*/
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &LocalUTProtectSecUnlockTime;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT16);
			wTmpConfigDataSum++;
		}
		else
		{
			;/*无处理 */
		}
		/*本联锁CT保护区段解锁停稳时间（s）*/
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &LocalCTProtectSecUnlockTime;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT16);
			wTmpConfigDataSum++;
		}
		else
		{
			;/*无处理 */
		}
		/*本联锁UT接近延时解锁超限时间（s）*/
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &LocalUTNearUnLockTime;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT16);
			wTmpConfigDataSum++;
		}
		else
		{
			;/*无处理 */
		}
		/*本联锁CT接近延时解锁超限时间（s）*/
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &LocalCTNearUnLockTime;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT16);
			wTmpConfigDataSum++;
		}
		else
		{
			;/*无处理 */
		}

		/*本联锁OC数据结构类型*/
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &gLocalOcType;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT8);
			wTmpConfigDataSum++;
		}
		else
		{
			;/*无处理 */
		}
		/*上电解锁超限周期数*/
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &StartUnlockCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/*无处理 */
		}
		/*进路选排超限周期数*/
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &RouteXuanPaiCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/*无处理 */
		}
		/*进路锁闭超限周期数*/
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &RouteLockCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/*无处理 */
		}
		/*保护区段锁闭超限周期数*/
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &OverlapLockCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/*无处理 */
		}
		/*进路开放超限时间*/
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &RouteOpenSignalCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/*无处理 */
		}
		/*点式进路延时解锁周期数*/
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &BlocRouteDelayCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/*无处理 */
		}
		/*CBTC进路延时解锁周期数*/
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &CbtcRouteDelayCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/*无处理 */
		}
		/*引导进路内方区段故障信号开放持续周期数*/
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &LeadRouteFaultOpenCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/*区段延时解锁周期数 */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &SecDelayUnlockCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/*信号开放超限周期数*/
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &SignalOpenCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/*信号关闭超限周期数*/
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &SignalCloseCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/*道岔动作超限周期数*/
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &SwitchMoveCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/*道岔驱动超限周期数*/
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &SwitchDriveCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/*防护区段解锁停稳周期数  */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &ProtectSecUnlockCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 占用变空闲计时周期数 */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &OccupyToIdleCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 白光带区故解计时周期数 */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &FaultUnlockCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 计轴复位超时周期数 */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &SectionResetCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 非进路选排总周期数 */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &NonRouteXuanPaiCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 非进路延时解锁总周期数 */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &NonRouteDelayUnlockCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 进路选排道岔错峰周期 */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &SwitchDriveCuoFengCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 组合进路选排周期 */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &ZuheRouteXuanPaiCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 联锁与ZC通信中断确认周期 */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &CiAndZcTransmitBadEnsureCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 联锁与联锁通信中断确认周期 */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &CiAndCiTransmitBadEnsureCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 联锁与Vobc通信中断确认周期  */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &CiAndVobcTransmitBadEnsureCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}

		/* 联锁与IVOC后备通道通信中断确认周期  */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &VobcAndCiBackUpCommBadCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}

		/* 联锁与PSD通信中断确认周期  */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &CiAndPsdTransmitBadEnsureCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/*  等待ZC反馈时间 */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &WaitZCResponseCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/*  区段跳跃锁闭延时解锁周期数 */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &SecJumpLockDelayUnlockCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 车库门动作超时周期数  */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &GaragedoorOperateCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 通信车占用防护区段解锁停稳周期数  */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &CtProtectSecUnlockCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 单轨单开道岔驱动超限周期数  */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &SingleSwitchMoveCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/*  单轨三开道岔驱动超限周期数 */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &ThreeSwitchMoveCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 单轨五开道岔驱动超限周期数  */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &FiveSwitchMoveCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 间隙探测时间超限周期数  */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &gapDetectTimeCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}

		/* 站台按钮吸起失效时间超限周期数  */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &psdButtonPressTimeCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 调车同意等待信号开放时间  */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &DCTYWaitSignalOpenCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 联锁与Psc通信中断确认周期最大容忍时间  */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &CiAndPscTransBadEnsureCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 计轴总复位命令驱动最长时间  */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &ZFWJRelayDriveTimeCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 道岔到位后DFH继电器吸起容忍时间  */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &DHFRelayValidTimeCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 一次命令有效时间  */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &FirstOrderTimeCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 间隙探测脉冲持续时间  */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &JXTCPulseContinueTimeCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 人工解锁保护区段延时解锁时间  */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &labarUnlockOverlapTimeCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 驱动亮灯之后采集全灭容忍时间  */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &sigCollectRongrenCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 计轴区段UT占用冗余周期数  */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &AxleSectionUtRedundanceCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 屏蔽门关门超限时间  */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &psdDrivCloseMaxTimeCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 屏蔽门开门超限时间  */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &psdDrivOpenMaxTimeCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* SPKS按钮指示灯点亮延时时间(秒)  */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &SpksIndicDelayCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* AXIS-CI接口协议版本号  */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &ciAndAxisPrtclCheckVer;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT8);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/*  ZC-CI接口协议版本号 */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &versionOfZCToCI;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT8);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* VOBC-CI接口协议版本号  */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &versionOfVOBCToCI;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT8);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 联锁与计轴系统通信中断确认周期  */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &CiAndAxleTransBadEnsureCnt;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 联锁与计轴系统通信中断确认时间  */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &CiAndAxleTransBadEnsureTime;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 联锁与Oc通信中断确认周期  */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &CiAndOcTransmitBadEnsureCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 联锁与Oc通信中断确认时间  */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &CiAndOcTransmitBadEnsureTime;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 飞车宕机容忍周期数初始化 */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &gCTFlyingRedunCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* SPKS按钮指示灯点亮延时时间(秒) */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &mjjsOpenDelayCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 自复式按钮对应继电器采集时间（ms）(初始化字段) */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &dwSelfButCollCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 自复式扣车/紧急按钮故障判断时间（s） */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &dwSelfButErrCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 资源回收计时时间（ms） */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &dwTrainRecycleCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 自复式取消扣车/紧急按钮故障判断时间（s） */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &dwSelfCancelButErrCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 进路最接近的列车需要总人解进路时延时等待时间（s） */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &dwRouteNearestTrainRenJieCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 声光报警进路延时开放时间（s） */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &dwSGBJRouteDelayOpenCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}

		/* 防淹门接近区段占用延迟关门时间(S) */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &dwFloodGateDelayCloseCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}

		/* 本线路联络线道岔未及时取消旁路等待时间(S) */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &dwSwitchBypassWaitCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 自复式取消扣车/紧急按钮误触发判断时间（s） */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &dwSelfCancelButErrTriggerCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* ARB防护距离（米/M） */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &wArbNearSecProtectDistance;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT16);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* ARB防护时间周期） */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &dwArbNearSecNoUtCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* 无人折返按钮故障判断时间（秒/S） */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &dwNonReturnBtnErrEnsureTime;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}

		/* OC采集容忍周期数 */
		wTmpLen = 1U + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &dwOcCollTolerateCount;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT32);
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}

		/* ci-oc关系数组  */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &CiOcRelationArr;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(CiOcRelateion)*CI_SUM_MAX;
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}
		/* TIOC数据版本号  */
		wTmpLen = 1u + wTmpConfigDataSum;
		if (wBufMaxLen >= wTmpLen)
		{
			pConfigDataAdderBuf[wTmpConfigDataSum] = &g_TiocFsVersion;
			pConfigDataLenBuf[wTmpConfigDataSum] = (UINT16)sizeof(UINT16)*TIOCFS_VERSION_LENGTH;
			wTmpConfigDataSum++;
		}
		else
		{
			;/* 无处理 */
		}

	}
	else
	{
		;/*无处理*/
	}
	wRetSum = wTmpConfigDataSum;
	return wRetSum;
}

/*
* 功能描述： 获取飞车宕机容忍周期数
* 参数说明： void
* 返回值  ： 飞车宕机容忍周期数
*/
UINT8 GetCTFlyingRedunCount(void)
{
	return gCTFlyingRedunCount;
}

/*
* 功能描述： 获取本控区临时限速最大数量
* 参数说明： void
* 返回值  ： 本控区临时限速最大数量
*/
UINT16 GetTsrMaxCmdSum(void)
{
	return wTsrMaxCmdSum;
}

/*
* 功能描述： 获取单个临时限速的最大区段数量
* 参数说明： void
* 返回值  ： 单个临时限速的最大区段数量
*/
UINT16 GetTsrMaxSecSum(void)
{
	return wTsrMaxSecSum;
}

/*
* 功能描述： 获取系统定义逻辑方向与上下行方向的关系
* 参数说明： void
* 返回值  ： 系统定义逻辑方向与上下行方向的关系
*/
UINT8 GetLinkLogicDirUpAndDown(void)
{
	return SystemParameterStruNew.LinkLogicDirUpAndDown;
}

/*
* 获取区间疏散前查距离
* 参数说明：void
* 返回值：区间疏散前查距离
*/
UINT32 GetEaFrontDis(void)
{
	return SystemParameterStruNew.dwEaFrontDis;
}

/*
* 获取区间疏散后查距离
* 参数说明：void
* 返回值：区间疏散后查距离
*/
UINT32 GetEaBehindDis(void)
{
	return SystemParameterStruNew.dwEaBehindDis;
}


/*
* 设置RC工作模式
* 参数说明：UINT8 localRcWorkMode RC工作模式
* 返回值：1u成功 0u失败
*/
UINT8 SetLocalRcWorkMode(UINT8 localRcWorkMode)
{
	UINT8 rtn = 0u; /*返回值*/

	if ((RC_WORK_MODE_CI == localRcWorkMode) || (RC_WORK_MODE_TIOC == localRcWorkMode))
	{
		LocalRcWorkMode = localRcWorkMode;
		rtn = 1u;
	}

	return rtn;
}

/*
* 获取RC工作模式
* 参数说明：无
* 返回值：RC工作模式
*/
UINT8 GetLocalRcWorkMode(void)
{
	return LocalRcWorkMode;
}
/*
* 功能描述： 获取人工解锁保护区段延时解锁周期数
* 参数说明： void    
* 返回值  ： 人工解锁保护区段延时解锁周期数
*/
UINT32 GetlabarUnlockOverlapTimeCount(void)
{
	return labarUnlockOverlapTimeCount;
}
/*
* 功能描述： 获取屏蔽门关闭超限时间
* 参数说明： void
* 返回值  ： 屏蔽门关闭超限时间
* cgh-合并CID-2349-4：
*/
UINT32 GetPsdDrivCloseMaxCount(void)
{
	return psdDrivCloseMaxTimeCount;
}
/*
* 功能描述： 获取屏蔽门打开超限时间
* 参数说明： void
* 返回值  ： 屏蔽门打开超限时间
* cgh-合并CID-2349-4：
*/
UINT32 GetPsdDrivOpenMaxCount(void)
{
	return psdDrivOpenMaxTimeCount;
}
/*
* 功能描述： 驱动亮灯之后采集全灭容忍时间
* 参数说明： void    
* 返回值  ： 驱动亮灯之后采集全灭容忍时间
*/
UINT32 GetSigCollectRongernCount(void)
{
	return sigCollectRongrenCount;
}

/*
* 功能描述： SPKS按钮指示灯点亮延时周期
* 参数说明： void
* 返回值  ： SPKS按钮指示灯点亮延时周期
*/
UINT32 GetSpksIndicDelayCount(void)
{
	return SpksIndicDelayCount;
}
/*
* 功能描述： 获取联锁与计轴间协议检验版本号
* 参数说明： void
* 返回值  ： 联锁与计轴间协议检验版本号
* cgh-合并CID-3037-13：
*/
UINT8 GetCiAndAxisPrtclCheckVer(void)
{
	return ciAndAxisPrtclCheckVer;
}
/*
* 设置本联锁轨旁继电器接口类型
* 参数说明：本方轨旁继电器接口
* 返回值：无
*/
void SetLocalWaysidePattern(UINT8 localWaysidePattern)
{

	if ((RELAY_PATTERN_TRADITIONAL == localWaysidePattern) || (RELAY_PATTERN_FULL_ELECTRONIC == localWaysidePattern))
	{
		LocalWaysidePattern = localWaysidePattern;
	}
	else
	{
		/*默认全电子*/
		LocalWaysidePattern = RELAY_PATTERN_FULL_ELECTRONIC;
	}
}
/*
* 获取本联锁轨旁继电器接口类型
* 参数说明：void
* 返回值：轨旁继电器接口类型
*/
UINT8 GetLocalWaysidePattern(void)
{
	return LocalWaysidePattern;
}

/*
* 功能描述： 门禁解锁延时周期
* 参数说明： void
* 返回值  ： 门禁解锁延时时间延时时间
*/
UINT32 GetMjjsOpenDelayCount(void)
{
	return mjjsOpenDelayCount;
}

/*
* 功能描述： 获取自复式按钮对应继电器采集时间
* 参数说明： void
* 返回值  ： 自复式按钮对应继电器采集时间
*/
UINT32 GetSelfButCollCount(void)
{
	return dwSelfButCollCount;
}

/*
* 功能描述： 获取自复式扣车/紧急按钮故障判断时间
* 参数说明： void
* 返回值  ： 自复式按钮故障判断时间
*/
UINT32 GetSelfButErrCount(void)
{
	return dwSelfButErrCount;
}

/*
* 功能描述： 获取自复式取消扣车/紧急按钮故障判断时间
* 参数说明： void
* 返回值  ： 自复式按钮故障判断时间
*/
UINT32 GetSelfCancelButErrCount(void)
{
	return dwSelfCancelButErrCount;
}

/*
* 功能描述： 获取声光报警进路延时开放时间
* 参数说明： void
* 返回值  ： 声光报警进路延时开放时间
*/
UINT32 GetSGBJRouteDelayOpenCount(void)
{
	return dwSGBJRouteDelayOpenCount;
}

/*
* 功能描述：获取唤醒过程检查SPKS状态开关
* 参数说明：无
* 返回值：唤醒过程检查SPKS状态开关
*/
UINT8 GetAwakeCheckSpksSwitch(void)
{
	return SystemParameterStruNew.cAwakeCheckSpksSwitch;
}

/*
* 功能描述：获取IVOC或VOBC与RC后备通道通信故障判断时间(ms)
* 参数说明：无
* 返回值：IVOC与RC后备通道通信故障判断时间
*/
UINT32 GetVobcCiBackUpCommErrorTime(void)
{
	return SystemParameterStruNew.dwVobcCiBackUpCommErrorTime;
}

/*
* 功能描述： 获取IVOC或VOBC与RC后备通道通信故障判断周期数
* 参数说明： void
* 返回值  ： 计时周期数
*/
UINT32 GetVobcCiBackUpCommErrorCount(void)
{
	return VobcAndCiBackUpCommBadCount;
}

/*
* 功能描述： 获取防淹门接近区段占用延迟关门时间
* 参数说明： void
* 返回值  ： 防淹门接近区段占用延迟关门时间
*/
UINT32 GetFloodGateDelayCloseCount(void)
{
	return dwFloodGateDelayCloseCount;
}

/*
* 功能描述： 获取本线路联络线道岔未及时取消旁路等待时间
* 参数说明： void
* 返回值  ： 本线路联络线道岔未及时取消旁路等待时间
*/
UINT32 GetSwitchBypassWaitCount(void)
{
	return dwSwitchBypassWaitCount;
}

/*
* 功能描述：获取撞软墙功能开关
* 参数说明：无
* 返回值：0x55 开关打开
*        0xaa 开关关闭
*/
UINT8 GetHitSoftWallSwitch(void)
{
	return SystemParameterStruNew.dwHitSoftWallSwitch;
}

/*
* 功能描述：获取保护区段锁闭方式开关
* 参数说明：无
* 返回值：0x01  ATS锁闭
*        0x02 CI锁闭
*/
UINT8 GetOverlapLockTypeSwitch(void)
{
	return SystemParameterStruNew.dwOverlapLockType;
}

/*
* 功能描述： 获取UDP传输日志时分包大小(byte)
* 参数说明： void
* 返回值  ： UINT16  分包大小
* 创建    ： 20240214 LC
*/
UINT16 GetLogSubPackDataLength(void)
{
	UINT16 wRtn = 0U;

	wRtn = GetSystemParaValue(LOG_SUBPACK_DATA_LENGTH);

	return wRtn;
}

/*
* 功能描述： 获取自复式取消扣车/紧急按钮误触发判断时间
* 参数说明： void
* 返回值  ： 自复式取消扣车/紧急按钮误触发判断时间
*/
UINT32 GetSelfCancelButErrTriggerCount(void)
{
	return dwSelfCancelButErrTriggerCount;
}

/*
* 设置其他联锁配置参数
* 参数说明：UINT8* pDataAddr 数据地址
* 返回值：CI_SUCCESS 成功   CI_ERROR 失败
* by cgh 20240605
*/
UINT8 SetOtherCiPara(UINT8* pDataAddr)
{
	UINT8 rtn = CI_ERROR; /*返回值*/
	UINT16 val = 0U;
	UINT16 wParaVal = 0U;/*参数值*/

	if(NULL != pDataAddr)
	{
		if (CI_SUM_MAX > *pDataAddr)
		{
			if (((CI_PATTERN_TRADITIONAL == pDataAddr[1]) || (CI_PATTERN_FULL_ELECTRONIC == pDataAddr[1]))
				&& ((CI_CENTER_IO == pDataAddr[2]) || (CI_DISTRIBUTED_IO == pDataAddr[2]))
				&& ((RC_WORK_MODE_CI == pDataAddr[12]) || (RC_WORK_MODE_TIOC == pDataAddr[12])))
			{
				SystemParameterStruNew.otherCICiParaStru[*pDataAddr].chOtherCiId = pDataAddr[0];
				SystemParameterStruNew.otherCICiParaStru[*pDataAddr].chOtherCiType = pDataAddr[1];
				SystemParameterStruNew.otherCICiParaStru[*pDataAddr].chOtherCiDistributedIO = pDataAddr[2];

				wParaVal = ShortFromChar(&pDataAddr[3]);
				SystemParameterStruNew.otherCICiParaStru[*pDataAddr].wOtherCiUTProSecUnlockCyc = TimeToCycleCount((UINT32)wParaVal * 1000U, 300U);
				wParaVal = ShortFromChar(&pDataAddr[5]);
				SystemParameterStruNew.otherCICiParaStru[*pDataAddr].wOtherCiCTProSecUnlockCyc = TimeToCycleCount((UINT32)wParaVal * 1000U, 300U);
				wParaVal = ShortFromChar(&pDataAddr[7]);
				SystemParameterStruNew.otherCICiParaStru[*pDataAddr].wOtherCiUTNearUnLockCyc = TimeToCycleCount((UINT32)wParaVal * 1000U, 300U);
				wParaVal = ShortFromChar(&pDataAddr[9]);
				SystemParameterStruNew.otherCICiParaStru[*pDataAddr].wOtherCiCTNearUnLockCyc = TimeToCycleCount((UINT32)wParaVal * 1000U, 300U);

				SystemParameterStruNew.otherCICiParaStru[*pDataAddr].chOtherCiWaysidePattern = pDataAddr[11];
				SystemParameterStruNew.otherCICiParaStru[*pDataAddr].chOtherCiRcWorkMode = pDataAddr[12];

				rtn = CI_SUCCESS; /*返回值*/
			}
			else
			{
				; /*返回错误*/
			}
		}
		else
		{
			; /*返回错误*/
		}
		
	}
	else
	{
		; /*返回错误*/
	}

	return rtn;
}

/*
* 获取其他联锁配置参数
* 参数说明：const UINT8 chOtherCiId 其他联锁ID
* 返回值：CI_SUCCESS 成功   CI_ERROR 失败
* by cgh 20240605
*/
OtherCiParaStruct GetOtherCiPara(const UINT8 chOtherCiId)
{
	OtherCiParaStruct chReval = { 0U };

	if (CI_SUM_MAX > chOtherCiId)
	{
		chReval = SystemParameterStruNew.otherCICiParaStru[chOtherCiId];
	}
	else
	{
		; /*返回0*/
	}

	return chReval;
}

/*
* 功能描述：获取无C轨站型B轨有UT车时可追踪功能开关
* 参数说明：无
* 返回值：aa关闭 55打开
* by cgh 20240815
*/
UINT8 GetNoCGFollowUtSwitch(void)
{
	return SystemParameterStruNew.chNoCGFollowUtSwitch;
}

/*
* 功能描述： 获取ARB区段向相邻区段检查长度(m)
* 参数说明： void
* 返回值  ： UINT16 wArbCheckMaxLen 检查长度
* by fan 20240820
*/
UINT16 GetArbCheckAxisLen(void)
{
	return wArbNearSecProtectDistance;
}

/*
* 功能描述： 获取ARB区段防护周期
* 参数说明： void
* 返回值  ： UINT32 防护周期
* by fan 20240820
*/
UINT32 GetArbProtectCheckTime(void)
{
	return dwArbNearSecNoUtCount;
}

/*
* 功能描述： 获取无人折返按钮故障判断周期数
* 参数说明： void
* 返回值  ： 无人折返按钮故障判断周期数
* by cgh 20240905
*/
UINT32 GetdwNonReturnBtnErrEnsureCount(void)
{
	return dwNonReturnBtnErrEnsureTime;
}

/*
* 设置本联锁OC版本
* 参数说明：OC版本
* 返回值：成功 CI_SUCCESS  失败CI_ERROR
* Create: fan 20250210
*/
UINT8 SetLocalOcPattern(UINT8 localOcPattern)
{
	UINT8 rtn = CI_ERROR; /*返回值*/

	if ((DATA_TYPE_NEW == localOcPattern) || (DATA_TYPE_OLD == localOcPattern))
	{
		gLocalOcType = localOcPattern;
		rtn = CI_SUCCESS;
	}

	return rtn;
}

/*
* 获取本联锁OC版本
* 参数说明：OC版本
* 返回值：0x55 较新版本  0xaa 较旧版本
* Create: fan 20250210
*/
UINT8 GetLocalOcPattern(void)
{
	return gLocalOcType;
}

/*
* 函数功能：设置RC联络线属性
* 参数说明：UINT8 cLinkLineAttr RC联络线属性
* 返 回 值：1 成功 
*           0 失败
*/
UINT8 SetLocalRcLinkLineAttr(UINT8 cLinkLineAttr)
{
	UINT8 rtn = CI_ERROR; /*返回值*/

	if ((RC_LINK_LINE_YES == cLinkLineAttr) || (RC_LINK_LINE_NO == cLinkLineAttr))
	{
		gLocalRcLinkLineAttr = cLinkLineAttr;
		rtn = CI_SUCCESS;
	}
	else
	{
		/*入参非法，返回失败*/
	}

	return rtn;
}

/*
* 函数功能：获取RC联络线属性
* 参数说明：无
* 返回值：RC入口属性
*/
UINT8 GetLocalRcLinkLineAttr(void)
{
	return gLocalRcLinkLineAttr;
}

/*
* 设置当前公共数据版本类型
* 参数说明：公共数据版本
* 返回值：成功 CI_SUCCESS  失败CI_ERROR
* Create: fan 20250521
*/
void SetLocalPublicDataType(UINT8 localPublicData)
{
	if ((DATA_TYPE_NEW == localPublicData) || (DATA_TYPE_OLD == localPublicData))
	{
		gLocalPublicDataType = localPublicData;
	}
}

/*
* 获取当前公共数据版本类型
* 参数说明：无
* 返回值：0x55 较新版本  0xaa 较旧版本
* Create: fan 20250521
*/
UINT8 GetLocalPublicDataType(void)
{
	return gLocalPublicDataType;
}

/*
* 功能描述：获取OC采集容忍周期数
* 参数说明：void
* 返 回 值：OC采集容忍周期数
* Created By LQ 2025.06.30
*/
UINT32 GetOcCollTolerateCount(void)
{
	return dwOcCollTolerateCount;
}