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


#include "RouteDataManage.h"
#include "LogicSectionDataManage.h"
#include "AxisSort.h"
#include "AxisSort_api.h" 
#include "InterlockCommonManage.h"

RouteDataStruct RouteDataStru[ROUTE_SUM_MAX];   /*定义进路数据结构体*/


/*
* 功能描述： 获取指定ID进路数据
* 参数说明：
* 返回值  ：
            RouteDataStruct *
*/
RouteDataStruct *GetRouteData(void)
{
    return RouteDataStru;
}


/*
* 功能描述： 获取指定ID进路状态
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 进路状态
*/
UINT8 GetRouteState(const UINT16 routeId)
{
    UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

    bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

    if (bufIndex < ROUTE_SUM_MAX)
    {
        retVal = RouteDataStru[bufIndex].RouteState;
    }
    else
    {
        retVal = CI_ERROR;
    }
	return retVal;
}

/*
* 功能描述： 获取指定ID进路前一个状态
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 进路状态
*/
UINT8 GetRoutePreState(const UINT16 routeId)
{
    UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 returnValue = CI_ERROR;
	
    bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/
	
    if (bufIndex < ROUTE_SUM_MAX)
    {
        returnValue = RouteDataStru[bufIndex].RoutePreState;
    }

	return returnValue;
}

/*
* 功能描述： 设置指定ID进路状态
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT8 routeState, 进路状态
* 返回值  ： CI_ERROR
*            CI_SUCCESS
* edit cgh 20250224
*/
UINT8 SetRouteState(const UINT16 routeId, const UINT8 routeState)
{
    UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_SUCCESS;
	UINT32 dwCurCycleNum = 0U;

    bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

    if (bufIndex >= ROUTE_SUM_MAX)
    {
        retVal = CI_ERROR;
    }

	if(CI_SUCCESS == retVal)
	{
		if (0u == RouteStateValidCheck(routeState))
		{
			retVal = CI_ERROR;
		}
	}

	if(CI_SUCCESS == retVal)
	{
		dwCurCycleNum = Get2oo2CurCycleNum();
		if (ROUTE_STATE_IDLE == routeState)
		{  /*进路空闲*/

			RouteDataStru[bufIndex].XuanPaiStartCycNum = 0u;  /*清除进路选排起始周期*/
			RouteDataStru[bufIndex].RouteLockStartCycNum = 0u;  /*清除进路锁闭起始周期号*/
			RouteDataStru[bufIndex].DelayUnlockStartCycNum = 0u;  /*清除进路延时解锁起始周期号*/
			RouteDataStru[bufIndex].LeadFaultOpenStartCycNum = 0u;  /*清除进路引导故障起始周期号*/
			RouteDataStru[bufIndex].ZongQuXiaoFlag = ROUTE_ZONGQUXIAO_SET_NO;  /*清除进路总取消标志*/
			RouteDataStru[bufIndex].ZongRenJieFlag = ROUTE_ZONGRENJIE_SET_NO;  /*清除进路总人解标志*/
			RouteDataStru[bufIndex].RepeatOpenFlag = ROUTE_REPEATOPEN_SET_NO;  /*清除进路信号重开标志*/
			RouteDataStru[bufIndex].chRouteXiansuConfirm = ROUTE_XIANSU_CONFIRM_NO;  /*清除进路信号重开标志*/
			RouteDataStru[bufIndex].StopCheckFlag = ROUTE_STOPCHECK_SET_NO;  /*清除进路停止检查标志*/
			RouteDataStru[bufIndex].StopKeepCheckFlag = ROUTE_STOPCHECK_SET_NO;  /*清除进路保持停止检查标志*/
			RouteDataStru[bufIndex].BelongLongRouteId = 0u;  /*清除进路所属长调进路*/
			RouteDataStru[bufIndex].StopensureFlag = ROUTE_STOPENSURE_NO;  /*清除进路停车保证标志*/
			RouteDataStru[bufIndex].RecoverOpenState = ROUTE_RECOVER_STA_INIT;/*空闲也清除进路恢复状态，用于下一次进路状态流转*/
			RouteDataStru[bufIndex].cResReqOtherCIId = 0u;
			RouteDataStru[bufIndex].dwFirstElockStartCycNum = 0u;
			RouteDataStru[bufIndex].dwDelayOpenStartCycNum = 0U;  /*清除声光报警进路延时开放起始周期*/
			ClearRouteResReqTrainBuf(routeId);
		}
		else if ((ROUTE_STATE_FIRST_XUANPAI == routeState) 
			|| (ROUTE_STATE_LEAD_FIRST_XUANPAI == routeState)
			|| (ROUTE_STATE_HALF_FIRST_XUAN == routeState))
		{ /*进路初选 引导初选 部分进路初选*/

			RouteDataStru[bufIndex].XuanPaiStartCycNum = dwCurCycleNum;  /*设置进路选排起始周期*/
		}
		else if ((ROUTE_STATE_XUANPAI == routeState)||(ROUTE_STATE_HALF_XUANPAI == routeState) || (ROUTE_STATE_LEAD_XUANPAI == routeState))
		{ /*进路选排 引导选排 部分进路选排*/

			if (0u == RouteDataStru[bufIndex].XuanPaiStartCycNum)
			{
				RouteDataStru[bufIndex].XuanPaiStartCycNum = dwCurCycleNum;  /*设置进路选排起始周期*/
			}
		}
		else if ((ROUTE_STATE_FIRST_LOCK == routeState) 
			|| (ROUTE_STATE_LEAD_LOCK == routeState)
			|| (ROUTE_STATE_HALF_LOCK == routeState))
		{ /*进路初锁*//*引导锁闭*//*部分锁闭*/

			RouteDataStru[bufIndex].XuanPaiStartCycNum = 0u;  /*清除进路选排起始周期*/

			if (ROUTE_STATE_FIRST_LOCK == routeState)
			{
				RouteDataStru[bufIndex].RecoverOpenState = ROUTE_RECOVER_STA_INIT;/*初锁意味着重新完整锁闭，准备开信号*/
			}
		}
		else if (ROUTE_STATE_DELAY_UNLOCK == routeState)
		{ /*延时解锁*/

			RouteDataStru[bufIndex].cResReqOtherCIId = 0u;
			ClearRouteResReqTrainBuf(routeId);
			RouteDataStru[bufIndex].DelayUnlockStartCycNum = dwCurCycleNum;  /*设置进路延时解锁起始周期号*/
		}
		else if ((ROUTE_STATE_NEAR_LOCKERR == routeState) || (ROUTE_STATE_AUTO_UNLOCKERR == routeState)|| (ROUTE_STATE_FIRST_LOCKERR == routeState))
		{ /*接近锁闭异常或自动解锁异常+进路初锁异常*/

			RouteDataStru[bufIndex].DelayUnlockStartCycNum = 0u;  /*清除进路延时解锁起始周期号*/
		}
		else
		{/*不处理*/
		}

		if ((ROUTE_STATE_YUXIAN_OPEN == routeState) ||
			(ROUTE_STATE_NEAR_OPEN == routeState) ||
			(ROUTE_STATE_LEAD_OPEN == routeState))
		{ /*预先开放||接近开放||引导开放*/

			RouteDataStru[bufIndex].RepeatOpenFlag = ROUTE_REPEATOPEN_SET_NO;  /*清除进路信号重开标志*/
		}

		if (ROUTE_STATE_HALF_UNLOCKDELAY == routeState)
		{ /*列车脚下区段全部锁闭后，或列车丢失通信后倒计时开始进入此状态*/
			if (0U == RouteDataStru[bufIndex].dwFirstElockStartCycNum)
			{
				RouteDataStru[bufIndex].dwFirstElockStartCycNum = dwCurCycleNum;  /*设置进路第一个锁闭的逻辑区段延时设置区段故障起始周期号*/
			}
			else
			{
				; /*周期有效不再更新，防止相邻联锁重复刷新周期号*/
			}

			/*必须放在这；相邻联锁设置进路状态使用的是此函数，不放在这设置不了*/
			SetRouFirDelayErlockStaCycNum(routeId,dwCurCycleNum);
		}

		RouteDataStru[bufIndex].RoutePreState = RouteDataStru[bufIndex].RouteState;/*保存当前进路状态*/
		RouteDataStru[bufIndex].RouteState = routeState; /*进路状态*/

		if ((ROUTE_STATE_AUTO_UNLOCK==RouteDataStru[bufIndex].RoutePreState) || (ROUTE_STATE_AUTO_UNLOCKERR== RouteDataStru[bufIndex].RoutePreState))
		{
			/*进路之前处于自动解锁或者自动解锁异常，并且进路当前不处于自动解锁、不处于自动解锁异常*/
			if ((ROUTE_STATE_AUTO_UNLOCK != routeState) && (ROUTE_STATE_AUTO_UNLOCKERR != routeState))
			{
				RouteDataStru[bufIndex].RouteLockStartCycNum = 0U;
			}
		}

		if ((ROUTE_STATE_FIRST_LOCK == routeState) || (ROUTE_STATE_FIRST_LOCKERR == routeState)
			|| (ROUTE_STATE_YUXIAN_LOCK == routeState) || (ROUTE_STATE_YUXIAN_OPEN == routeState)
			|| (ROUTE_STATE_NEAR_LOCK == routeState) || (ROUTE_STATE_NEAR_LOCKERR == routeState) || (ROUTE_STATE_NEAR_OPEN == routeState)
			|| (ROUTE_STATE_LEAD_LOCK == routeState) || (ROUTE_STATE_LEAD_LOCKERR == routeState) || (ROUTE_STATE_LEAD_OPEN == routeState)
			|| (ROUTE_STATE_HALF_LOCK == routeState))
		{
			RouteDataStru[bufIndex].XuanPaiStartCycNum = 0U;
			/*设置进路锁闭起始周期号*/
			if (0U == RouteDataStru[bufIndex].RouteLockStartCycNum)
			{
				RouteDataStru[bufIndex].RouteLockStartCycNum = dwCurCycleNum;
			}
		}
	}



    return retVal;
}

/*
* 功能描述： 获取指定ID进路监督级别变化周期号
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 监督级别变化周期号
* by cgh 20240325
*/
UINT32 GetRouteLevelChangeCyc(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT32 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (bufIndex < ROUTE_SUM_MAX)
	{
		retVal = RouteDataStru[bufIndex].RouteLevelChangeCyc;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 获取指定ID进路监督级别
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 进路监督级别
*/
UINT8 GetRouteLevel(const UINT16 routeId)
{
    UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

    bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

    if (bufIndex < ROUTE_SUM_MAX)
    {
        retVal = RouteDataStru[bufIndex].RouteLevel;
    }
    else
    {
        retVal = CI_ERROR;
    }
	return retVal;
}


/*
* 功能描述： 设置指定ID进路监督级别
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT8 routeLevel, 进路级别
* 返回值  ： 无
*             
*/
void SetRouteLevel(const UINT16 routeId, const UINT8 routeLevel)
{
    UINT16 bufIndex = 0U;  /*数组下标*/
	UINT32 dwCurCyc = 0U;

    bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

    if (bufIndex < ROUTE_SUM_MAX)
    {
      
        if ((ROUTE_LEVEL_CBTC == routeLevel) || (ROUTE_LEVEL_BLOC == routeLevel))
        {
			RouteDataStru[bufIndex].RoutePreLevel = RouteDataStru[bufIndex].RouteLevel;/*保存当前进路监督级别*/
            RouteDataStru[bufIndex].RouteLevel = routeLevel; /*进路级别*/
        }
        else
        {
            /*不做处理*/
        }

		if (routeLevel == (UINT8)(~RouteDataStru[bufIndex].RoutePreLevel))
		{
			dwCurCyc = Get2oo2CurCycleNum();
			RouteDataStru[bufIndex].RouteLevelChangeCyc = dwCurCyc;/*进路监督级别发生变化周期号*/
		}
		else
		{
			/*不做处理*/
		}
    }
    else
    {
        /*不做处理*/
    }
}


/*
* 功能描述： 获取指定ID进路对应的自动进路ID
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 自动进路ID
*/
UINT16 GetRouteAutoRouteId(const UINT16 routeId)
{
    UINT16 bufIndex = 0u;  /*数组下标*/
	UINT16 retVal = CI_ERROR;

    bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

    if (bufIndex < ROUTE_SUM_MAX)
    {
        retVal = RouteDataStru[bufIndex].AutoRouteId;
    }
    else
    {
        retVal = CI_ERROR;
    }
	return retVal;
}

/*
* 功能描述： 获取指定ID进路自动折返进路设置状态
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 自动进路设置状态
*/
UINT16 GetRouteAutoReturnId(const UINT16 routeId)
{
    UINT16 bufIndex = 0u;  /*数组下标*/
	UINT16 retVal = CI_ERROR;

    bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

    if (bufIndex < ROUTE_SUM_MAX)
    {
        retVal = RouteDataStru[bufIndex].AutoReturnId;
    }
    else
    {
        retVal = CI_ERROR;
    }
	return retVal;
}




/*
* 功能描述： 设置指定ID进路自动折返进路Id
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT8 autoRouteState, 自动进路设置状态
* 返回值  ： CI_ERROR: 设置数据失败
*            CI_SUCCESS: 设置数据成功
*/
UINT8 SetRouteAutoReturnId(const UINT16 routeId, const UINT16 autoDataId)
{
    UINT16 bufIndex = 0u;  /*数组下标*/
    UINT8 autoRouteProperty = GetRouteAutoRouteProperty(routeId);
    RouteDataStruct *routeDataStru = GetRouteData();
	UINT8 retVal = CI_SUCCESS;
    bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

    if (bufIndex < ROUTE_SUM_MAX)
    {
        if (0u == autoDataId)
        {
            routeDataStru[bufIndex].AutoReturnId = 0u; /*取消自动进路设置状态*/

            retVal = CI_SUCCESS;
        }
        else if ((autoRouteProperty == ROUTE_AUTOROUTE_PROPERTY_YES) && 
            (routeDataStru[bufIndex].AutoRouteId == 0u) &&
            (routeDataStru[bufIndex].AutoReturnId == 0u)&&
			(routeDataStru[bufIndex].AllAutoReturnId == 0u))
        {
            /*自动折返自动进路不能同时设置*/
            routeDataStru[bufIndex].AutoReturnId = autoDataId; /*自动进路设置状态*/

            retVal = CI_SUCCESS;
        }
        else
        {
            /*routeDataStru[bufIndex].AutoReturnId = 0u;*/ /*自动进路设置状态*/

            retVal = CI_ERROR;
        }
    }
    else
    {
        retVal = CI_ERROR;
    }
	return retVal;
}

/*
* 功能描述： 获取指定ID进路自动信号属性失效设置状态
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 自动信号属性失效设置状态
*/
UINT8 GetRouteAutoSigLoseEfficacyFlag(const UINT16 routeId)
{
    UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 autoSigPropertyLoseEfficacyFlag = 0u;

    bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

    if (bufIndex < ROUTE_SUM_MAX)
    {
        autoSigPropertyLoseEfficacyFlag = RouteDataStru[bufIndex].AutoSigPropertyLoseEfficacyFlag;
    }
    else
    {
        autoSigPropertyLoseEfficacyFlag = CI_ERROR;
    }
	return autoSigPropertyLoseEfficacyFlag;
}


/*
* 功能描述： 设置指定ID进路自动信号属性失效标志
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT8 autoSigPropertyLoseEfficacyFlag, 进路自动信号属性失效设置标志
* 返回值  ： 0: 设置数据失败
*            1: 设置数据成功
*/
UINT8 SetRouteAutoSigLoseEfficacyFlag(const UINT16 routeId, const UINT8 autoSigPropertyLoseEfficacyFlag)
{
    UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;
	UINT8 curLoseEfficacyFlag = 0u;
	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/
    if (ROUTE_SUM_MAX > bufIndex)
    {
		retVal = CI_SUCCESS;
		curLoseEfficacyFlag = RouteDataStru[bufIndex].AutoSigPropertyLoseEfficacyFlag;
		if (ROUTE_AUTOSIG_LOSE_DSSET_YES == autoSigPropertyLoseEfficacyFlag)
		{
			if(ROUTE_AUTOSIG_LOSE_SET_INVALID == curLoseEfficacyFlag)
			{/*指定进路不具备"自动信号属性"，自动信号属性失效标志对其不起作用*/
				retVal = CI_ERROR;
			}
			else if ((ROUTE_AUTOSIG_LOSE_REVSET_YES == curLoseEfficacyFlag) || (ROUTE_AUTOSIG_LOSE_REVDSSET_YES == curLoseEfficacyFlag))
			{
				/*当前已被设置过失效标志，此时需要设置成反向进路和断丝都设置失效标志*/
				RouteDataStru[bufIndex].AutoSigPropertyLoseEfficacyFlag = ROUTE_AUTOSIG_LOSE_REVDSSET_YES; /*自动信号属性失效标志*/
				retVal = CI_SUCCESS;	
			}
			else
			{/*未被设置过失效标志*/
				RouteDataStru[bufIndex].AutoSigPropertyLoseEfficacyFlag = ROUTE_AUTOSIG_LOSE_DSSET_YES; /*自动信号属性失效标志*/
				retVal = CI_SUCCESS;			
			}
		}
		else if (ROUTE_AUTOSIG_LOSE_DSSET_NO == autoSigPropertyLoseEfficacyFlag)
		{
			if(ROUTE_AUTOSIG_LOSE_SET_INVALID == curLoseEfficacyFlag)
			{/*指定进路不具备"自动信号属性"，自动信号属性失效标志对其不起作用*/
				retVal = CI_ERROR;
			}
			else if ((ROUTE_AUTOSIG_LOSE_DSSET_YES == curLoseEfficacyFlag) || (ROUTE_AUTOSIG_LOSE_SET_NO == curLoseEfficacyFlag))
			{
				/*当前只被因为断丝设置过失效标志或者有效*/
				RouteDataStru[bufIndex].AutoSigPropertyLoseEfficacyFlag = ROUTE_AUTOSIG_LOSE_SET_NO; /*自动信号属性有效标志*/
				retVal = CI_SUCCESS;
			}
			else
			{/*当前被反向进路设置过自动信号属性失效标志*/
				RouteDataStru[bufIndex].AutoSigPropertyLoseEfficacyFlag = ROUTE_AUTOSIG_LOSE_REVSET_YES; /*自动信号属性失效标志*/
				retVal = CI_SUCCESS;			
			}
		}
        else if (ROUTE_AUTOSIG_LOSE_REVSET_YES == autoSigPropertyLoseEfficacyFlag)
        {
        	if(ROUTE_AUTOSIG_LOSE_SET_INVALID == curLoseEfficacyFlag)
        	{/*指定进路不具备"自动信号属性"，自动信号属性失效标志对其不起作用*/
        		retVal = CI_ERROR;
        	}
			else if ((ROUTE_AUTOSIG_LOSE_DSSET_YES == curLoseEfficacyFlag) || (ROUTE_AUTOSIG_LOSE_REVDSSET_YES == curLoseEfficacyFlag))
			{
				/*当前已被设置过失效标志，此时需要设置成反向进路和断丝都设置失效标志*/
				RouteDataStru[bufIndex].AutoSigPropertyLoseEfficacyFlag = ROUTE_AUTOSIG_LOSE_REVDSSET_YES; /*自动信号属性失效标志*/
				retVal = CI_SUCCESS;	
			}
			else
			{/*未被设置过失效标志*/
	            RouteDataStru[bufIndex].AutoSigPropertyLoseEfficacyFlag = ROUTE_AUTOSIG_LOSE_REVSET_YES; /*自动信号属性失效标志*/
	            retVal = CI_SUCCESS;			
			}
        }
		else if (ROUTE_AUTOSIG_LOSE_SET_NO == autoSigPropertyLoseEfficacyFlag)
		{
			if(ROUTE_AUTOSIG_LOSE_SET_INVALID == curLoseEfficacyFlag)
			{/*指定进路不具备"自动信号属性"，自动信号属性失效标志对其不起作用*/
				retVal = CI_ERROR;
			}
			else if ((ROUTE_AUTOSIG_LOSE_REVSET_YES == curLoseEfficacyFlag) || (ROUTE_AUTOSIG_LOSE_SET_NO == curLoseEfficacyFlag))
			{
				/*当前只被因为反向进路设置过失效标志或者有效*/
				RouteDataStru[bufIndex].AutoSigPropertyLoseEfficacyFlag = ROUTE_AUTOSIG_LOSE_SET_NO; /*自动信号属性有效标志*/
				retVal = CI_SUCCESS;
			}
			else
			{/*当前被因为断丝设置过自动信号属性失效标志*/
				RouteDataStru[bufIndex].AutoSigPropertyLoseEfficacyFlag = ROUTE_AUTOSIG_LOSE_DSSET_YES; /*自动信号属性失效标志*/
				retVal = CI_SUCCESS;			
			}
		}
        else
        {
            retVal = CI_ERROR;
        }
    }
    else
    {
        retVal = CI_ERROR;

    }

	return retVal;
}


/*
* 功能描述： 获取指定ID进路自动进路设置状态
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ：  ROUTE_AUTOROUTE_NONE      0x01    无自动属性
              ROUTE_AUTOROUTE_NORMAL    0x02    普通自动进路
              ROUTE_AUTOROUTE_RETURN    0x03    自动折返进路
              ROUTE_AUTOROUTE_ERROR     0xFF    错误自动属性
*/
UINT8 GetRouteAutoRouteSetState(const UINT16 routeId)
{
    UINT16 const autoRouteId = GetRouteAutoRouteId(routeId);
    UINT16 const autoReturnId = GetRouteAutoReturnId(routeId);
    UINT16 const allAutoReturnId = GetRouteAllAutoReturnId(routeId);
	UINT8 retVal = 0u;
    if (((0u < autoRouteId) && ((0u < autoReturnId)||(0u < allAutoReturnId)))||((0u < autoReturnId )&&(0u < allAutoReturnId )))
    {
        retVal = ROUTE_AUTOROUTE_ERROR;
    }
    else if ((0u < autoRouteId ) && (0u ==autoReturnId)&&(0u == allAutoReturnId ))
    {
        retVal = ROUTE_AUTOROUTE_NORMAL;
    }
    else if ((0u ==autoRouteId ) && (0u < autoReturnId)&&(0u == allAutoReturnId))
    {
        retVal = ROUTE_AUTOROUTE_RETURN;
    }
    else if ((0u == autoRouteId) && (0u < allAutoReturnId)&& (0u ==autoReturnId ))
    {
        retVal = ROUTE_ALLAUTOROUTE_RETURN;
    }
    else
    {
        retVal = ROUTE_AUTOROUTE_NONE;
    }
	return retVal;
}

/*
* 功能描述： 获取指定ID进路自动信号设置状态
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ：  ROUTE_AUTOSIGROUTE_YES   0xaa    进路是自动信号进路
              ROUTE_AUTOSIGROUTE_NO    0x55    进路不是自动信号进路
*/
UINT8 GetRouteAutoSigSetState(const UINT16 routeId)
{
	UINT8 autoSigRouteState = 0u;
    UINT8  autoSigProperty = GetRouteAutoSigProperty(routeId);/*获取进路自动信号属性*/
    UINT8  autoSigPropertyLoseEfficacyFlag = GetRouteAutoSigLoseEfficacyFlag(routeId);/*获取进路自动信号属性失效标志*/
	if(ROUTE_AUTOSIG_PROPERTY_YES == autoSigProperty)
	{
		if(ROUTE_AUTOSIG_LOSE_SET_NO == autoSigPropertyLoseEfficacyFlag)
		{
			autoSigRouteState = ROUTE_AUTOSIGROUTE_YES;
		}
		else
		{
			autoSigRouteState = ROUTE_AUTOSIGROUTE_NO;
		}
			
	}
	else
	{
		autoSigRouteState = ROUTE_AUTOSIGROUTE_NO;
	}
	return autoSigRouteState;
    
}

/*
* 功能描述： 设置指定ID进路自动进路Id
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT8 autoDataId, 自动进路ID
* 返回值  ： CI_ERROR: 设置数据失败
*            CI_SUCCESS: 设置数据成功
*/
UINT8 SetRouteAutoRouteId(const UINT16 routeId, const UINT16 autoDataId)
{
    UINT16 bufIndex = 0u;  /*数组下标*/
    UINT8 autoRouteProperty = GetRouteAutoRouteProperty(routeId);
	UINT8 retVal = CI_SUCCESS;


    bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

    if (bufIndex < ROUTE_SUM_MAX)
    {
        if (autoDataId == 0u)
        {
            RouteDataStru[bufIndex].AutoRouteId = 0u; /*取消自动进路设置状态*/

            retVal = CI_SUCCESS;
        }
        else if ((autoRouteProperty == ROUTE_AUTOROUTE_PROPERTY_YES) && 
            (RouteDataStru[bufIndex].AutoReturnId == 0u) &&
            (RouteDataStru[bufIndex].AutoRouteId == 0u)&&
			(RouteDataStru[bufIndex].AllAutoReturnId == 0u))
        {
            /*自动折返自动进路不能同时设置*/
            RouteDataStru[bufIndex].AutoRouteId = autoDataId; /*自动进路设置状态*/
			SetRouteLgcSecShareFlag(routeId, LOGIC_SECTION_RES_SHARE_YES);

            retVal = CI_SUCCESS;
        }
        else
        {
            /*RouteDataStru[bufIndex].AutoRouteId = 0;*/ /*自动进路设置状态*/

            retVal = CI_ERROR;
        }
    }
    else
    {
        retVal = CI_ERROR;
    }
	return retVal;
}

/*
* 功能描述： 获取指定ID进路选排起始周期号
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 选排起始周期号
*/
UINT32 GetRouteXuanPaiStartCycNum(const UINT16 routeId)
{
    UINT16 bufIndex = 0u;  /*数组下标*/
	UINT32 retVal = CI_ERROR;

    bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

    if (bufIndex < ROUTE_SUM_MAX)
    {
        retVal = RouteDataStru[bufIndex].XuanPaiStartCycNum;
    }
    else
    {
        retVal = CI_ERROR;
    }
	return retVal;
}


/*
* 功能描述：设置指定ID进路选排起始周期号
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT32 startCycNum, 起始周期号
* 返回值  ： 0: 设置数据失败
*           >0: 设置数据成功
*/
UINT8 SetRouteXuanPaiStartCycNum(const UINT16 routeId, const UINT32 startCycNum)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (bufIndex < ROUTE_SUM_MAX)
	{
		RouteDataStru[bufIndex].XuanPaiStartCycNum = startCycNum;
		retVal = CI_SUCCESS;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}
/*
* 功能描述： 获取指定ID进路信号开放起始周期号
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 选排起始周期号
*/
UINT32 GetRouteOpenSigStatrtCycNum(const UINT16 routeId)
{
    UINT16 bufIndex = 0u;  /*数组下标*/
	UINT32 retVal = CI_ERROR;

    bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

    if (bufIndex < ROUTE_SUM_MAX)
    {
        retVal = RouteDataStru[bufIndex].RouteOpenSigStatrtCycNum;
    }
    else
    {
        retVal = CI_ERROR;
    }
	return retVal;
}

/*
* 功能描述： 设定指定ID进路信号开放起始周期号
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 无
*           
*/
void SetRouteOpenSigStartCycNum(const UINT16 routeId, const UINT32 signalOpenStartCycNum)
{
    UINT16 bufIndex = 0u;  /*数组下标*/

    bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

    if (bufIndex < ROUTE_SUM_MAX)
    {
        RouteDataStru[bufIndex].RouteOpenSigStatrtCycNum = signalOpenStartCycNum; /*引导进路内方故障信号开放起始周期号*/

    }
    else
    {
        /*不设置*/
    }
}


/*
* 功能描述： 获取指定ID进路延时解锁起始周期号
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 点式延时解锁起始周期号
*/
UINT32 GetRouteDelayUnlockStartCycNum(const UINT16 routeId)
{
    UINT16 bufIndex = 0u;  /*数组下标*/
	UINT32 retVal = CI_ERROR;

    bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

    if (bufIndex < ROUTE_SUM_MAX)
    {
        retVal = RouteDataStru[bufIndex].DelayUnlockStartCycNum;
    }
    else
    {
        retVal = CI_ERROR;
    }
	return retVal;
}


/*
* 功能描述： 获取指定ID进路引导进路内方故障信号开放起始周期号
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 引导进路内方故障信号开放起始周期号
*/
UINT32 GetRouteLeadFaultOpenStartCyc(const UINT16 routeId)
{
    UINT16 bufIndex = 0u;  /*数组下标*/
	UINT32 retVal = CI_ERROR;

    bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

    if (bufIndex < ROUTE_SUM_MAX)
    {
        retVal = RouteDataStru[bufIndex].LeadFaultOpenStartCycNum;
    }
    else
    {
        retVal = CI_ERROR;
    }
	return retVal;
}


/*
* 功能描述： 设置指定ID进路引导进路内方故障信号开放起始周期号
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT32 faultOpenStartCycNum, 引导进路内方故障信号开放起始周期号
* 返回值  ： 无
*             
*/
void SetRouteLeadFaultOpenStartCyc(const UINT16 routeId, const UINT32 faultOpenStartCycNum)
{
    UINT16 bufIndex = 0u;  /*数组下标*/

    bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

    if (bufIndex < ROUTE_SUM_MAX)
    {
        RouteDataStru[bufIndex].LeadFaultOpenStartCycNum = faultOpenStartCycNum; /*引导进路内方故障信号开放起始周期号*/
    }
    else
    {
       /*不做处理*/
    }
}


/*
* 功能描述： 获取指定ID进路锁闭起始周期号
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 锁闭起始周期号
*/
UINT32 GetRouteLockStartCycNum(const UINT16 routeId)
{
    UINT16 bufIndex = 0u;  /*数组下标*/
	UINT32 retVal = CI_ERROR;

    bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

    if (bufIndex < ROUTE_SUM_MAX)
    {
        retVal = RouteDataStru[bufIndex].RouteLockStartCycNum;
    }
    else
    {
        retVal = CI_ERROR;
    }
	return retVal;
}

/*
* 功能描述： 获取进路Overlap锁闭起始周期
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 锁闭起始周期号
*/
UINT32 GetOverlapLockStartCycNum(const UINT16 routeId)
{
    UINT16 bufIndex = 0u;  /*数组下标*/
	UINT32 retVal = CI_ERROR;

    bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

    if (bufIndex < ROUTE_SUM_MAX)
    {
        retVal = RouteDataStru[bufIndex].OverlapLockStartCycNum;
    }
    else
    {
        retVal = CI_ERROR;
    }
	return retVal;
}


/*
* 功能描述： 设置进路Overlap锁闭起始周期
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT8 lockFlag, 锁闭标志
* 返回值  ： 0: 设置数据失败
*            1: 设置数据成功
*/
UINT8 SetOverlapLockStartCycNum(const UINT16 routeId, const UINT32 startCycNum)
{
    UINT16 bufIndex = 0u;  /*数组下标*/
    UINT8 overlapSum = 0u;
	UINT8 retVal = CI_SUCCESS;
    bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

    if (bufIndex < ROUTE_SUM_MAX)
    {
        overlapSum = GetRouteOverlapSum(routeId);
        if ((overlapSum > 0u)  && (overlapSum <= ROUTE_PROTECTSECGROUP_SUM_MAX))
        {
            RouteDataStru[bufIndex].OverlapLockStartCycNum = startCycNum; /*引导进路内方故障信号开放起始周期号*/
        }

        retVal = CI_SUCCESS;
    }
    else
    {
        retVal = CI_ERROR;
    }
	return retVal;
}


/*
* 功能描述： 获取进路Overlap锁闭ID
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 总取消状态
*/
UINT16 GetRouteOverlapLockedId(const UINT16 routeId)
{
    UINT16 bufIndex = 0u;  /*数组下标*/
	UINT16 retVal = CI_ERROR;

    bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

    if (bufIndex < ROUTE_SUM_MAX)
    {
        retVal = RouteDataStru[bufIndex].OverlapLockedId;
    }
    else
    {
        retVal = CI_ERROR;
    }
	return retVal;
}

/*
* 功能描述： 获取进路Overlap锁闭标志
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 
            ROUTE_OVERLAP_SET_NO                0x55	未设置
            ROUTE_OVERLAP_SET_YES               0xaa	设置
            ROUTE_OVERLAP_SET_NULL              0xff	无保护区段
*/
UINT8 GetRouteOverlapLockFlag(const UINT16 routeId)
{
    UINT16 bufIndex = 0u;  /*数组下标*/
    /*进路防护进路数据*/
    UINT8  overlapSum = GetRouteOverlapSum(routeId);
    UINT16*  pOverlapIdBuf = GetRouteOverlapIdBuf(routeId);
    UINT8 ii = 0u;
	UINT8 retVal = ROUTE_OVERLAP_SET_NULL;

    bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

    if (bufIndex >= ROUTE_SUM_MAX)
    {
        retVal = ROUTE_OVERLAP_SET_NULL;
    }
	else
	{
		if (overlapSum > 0u)
		{
			for (ii = 0u; ii < overlapSum; ii++)
			{
				if (pOverlapIdBuf[ii] ==  RouteDataStru[bufIndex].OverlapLockedId)
				{
					/*锁闭*/
					retVal = ROUTE_OVERLAP_SET_YES;
					break;
				}
			}
			if(ii == overlapSum)
			{
				/*未锁闭*/
				retVal = ROUTE_OVERLAP_SET_NO;
			}

		}
		else
		{
			/*没有保护进路*/
			retVal = ROUTE_OVERLAP_SET_NULL;
		}
	}
	return retVal;

}

/*
* 功能描述： 设置进路Overlap锁闭ID
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT8 lockFlag, 锁闭标志
* 返回值  ： void
*/
void SetRouteOverlapLockedId(const UINT16 routeId, const UINT16 OverlapId)
{
    UINT16 bufIndex = 0u;  /*数组下标*/
    /*进路防护进路数据*/
    UINT8 const overlapSum = GetRouteOverlapSum(routeId);
    UINT16* const pOverlapIdBuf = GetRouteOverlapIdBuf(routeId);
    UINT8 ii = 0u;
	UINT8 retVal = CI_SUCCESS;
    bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/


    if (bufIndex >= ROUTE_SUM_MAX)
    {
        retVal = CI_ERROR;
    }
	else
	{
		if (overlapSum > 0u)
		{
			if (OverlapId == 0u)
			{
				/*取消Overlap锁闭*/
				RouteDataStru[bufIndex].OverlapLockedId = OverlapId;
				retVal = CI_SUCCESS;
			}
			else
			{
				/*设置Overlap锁闭*/
				for (ii = 0u; ii < overlapSum; ii++)
				{
					if (pOverlapIdBuf[ii] ==  OverlapId)
					{
						RouteDataStru[bufIndex].OverlapLockedId = OverlapId; /*进路overlap锁闭标志*/
						retVal = CI_SUCCESS;
						break;
					}
				}
				if(ii == overlapSum)
				{
					retVal = CI_ERROR;
				}
				
			}
		}
		else
		{
			retVal = CI_ERROR;
		}
	}
	if(CI_ERROR ==  retVal)
	{
		debug_infor_printf((const)"SetRouteOverlapLockedId ERROR routeId:%d    OverlapId: %d\n", routeId, OverlapId);
	}
}


/*
* 功能描述： 获取指定ID进路总取消状态
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 总取消状态
*/
UINT8 GetRouteZongQuXiaoFlag(const UINT16 routeId)
{
    UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

    bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

    if (bufIndex < ROUTE_SUM_MAX)
    {
        retVal = RouteDataStru[bufIndex].ZongQuXiaoFlag;
    }
    else
    {
        retVal = CI_ERROR;
    }
	return retVal;
}


/*
* 功能描述： 设置指定ID进路总取消状态
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT8 cancelState, 总取消状态
* 返回值  ： void
*/
void SetRouteZongQuXiaoFlag(const UINT16 routeId, const UINT8 cancelState)
{
    UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_SUCCESS;

    bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

    if (bufIndex < ROUTE_SUM_MAX)
    {
        if ((ROUTE_ZONGQUXIAO_SET_NO == cancelState) || (ROUTE_ZONGQUXIAO_SET_YES == cancelState))
        {

            RouteDataStru[bufIndex].ZongQuXiaoFlag = cancelState; /*进路总取消状态*/

            retVal = CI_SUCCESS;
        }
        else
        {
            retVal = CI_ERROR;
        }
    }
    else
    {
        retVal = CI_ERROR;
    }
	if (CI_ERROR == retVal)
	{
		debug_infor_printf((const)"SetRouteZongQuXiaoFlag ERROR, RouteId:%d, cancelState:%d\n", routeId,cancelState);
	}
}


/*
* 功能描述： 获取指定ID进路总人解状态
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 总人解状态
*/
UINT8 GetRouteZongRenJieFlag(const UINT16 routeId)
{
    UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

    bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

    if (bufIndex < ROUTE_SUM_MAX)
    {
        retVal = RouteDataStru[bufIndex].ZongRenJieFlag;
    }
    else
    {
        retVal = CI_ERROR;
    }
	return retVal;
}


/*
* 功能描述： 设置指定ID进路总人解状态
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT8 cancelState, 总人解状态
* 返回值  ： 0: 设置数据失败
*            1: 设置数据成功
*/
UINT8 SetRouteZongRenJieFlag(const UINT16 routeId, const UINT8 cancelState)
{
    UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

    bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

    if (bufIndex < ROUTE_SUM_MAX)
    {
        if ((ROUTE_ZONGRENJIE_SET_NO == cancelState) || (ROUTE_ZONGRENJIE_SET_YES == cancelState))
        {
            RouteDataStru[bufIndex].ZongRenJieFlag = cancelState; /*进路总人解状态*/

            retVal = CI_SUCCESS;
        }
        else
        {
            retVal = CI_ERROR;
        }
    }
    else
    {
        retVal = CI_ERROR;
    }
	return retVal;
}


/*
* 功能描述： 获取指定ID进路重开标志
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 重开状态
*/
UINT8 GetRouteRepeatOpenFlag(const UINT16 routeId)
{
    UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

    bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

    if (bufIndex < ROUTE_SUM_MAX)
    {
        retVal = RouteDataStru[bufIndex].RepeatOpenFlag;
    }
    else
    {
        retVal = CI_ERROR;
    }
	return retVal;
}


/*
* 功能描述： 设置指定ID进路重开标志
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT8 repeatOpenFlag, 重开标志
* 返回值  ： 无
*            
*/
void SetRouteRepeatOpenFlag(const UINT16 routeId, const UINT8 repeatOpenFlag)
{
    UINT16 bufIndex = 0u;  /*数组下标*/

    bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

    if (bufIndex < ROUTE_SUM_MAX)
    {
        if ((ROUTE_REPEATOPEN_SET_NO == repeatOpenFlag) || (ROUTE_REPEATOPEN_SET_YES == repeatOpenFlag))
        {

            RouteDataStru[bufIndex].RepeatOpenFlag = repeatOpenFlag; /*进路信号重开状态*/

        }
        else
        {
            /*不做处理*/
        }
    }
    else
    {
        /*不做处理*/
    }
}

/*
* 功能描述： 获取指定ID进路停止检查状态
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 停止检查状态
*/
UINT8 GetRouteStopCheckFlag(const UINT16 routeId)
{
    UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

    bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

    if (bufIndex < ROUTE_SUM_MAX)
    {
        retVal = RouteDataStru[bufIndex].StopCheckFlag;
    }
    else
    {
        retVal = CI_ERROR;
    }
	return retVal;
}


/*
* 功能描述： 设置指定ID进路停止检查状态
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT8 stopCheckState, 停止检查状态
* 返回值  ： 0: 设置数据失败
*            1: 设置数据成功
*/
UINT8 SetRouteStopCheckFlag(const UINT16 routeId, const UINT8 stopCheckState)
{
    UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_SUCCESS;

    bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

    if (bufIndex < ROUTE_SUM_MAX)
    {
        if ((ROUTE_STOPCHECK_SET_NO == stopCheckState) || (ROUTE_STOPCHECK_SET_YES == stopCheckState))
        {
            RouteDataStru[bufIndex].StopCheckFlag = stopCheckState; /*进路停止检查状态*/

            retVal = CI_SUCCESS;
        }
        else
        {
            retVal = CI_ERROR;
        }
    }
    else
    {
        retVal = CI_ERROR;
    }
	return retVal;
}


/*
* 功能描述： 获取指定ID进路所属长调进路ID
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 所属长调进路ID
*/
UINT16 GetRouteBelongLongRouteId(const UINT16 routeId)
{
    UINT16 bufIndex = 0u;  /*数组下标*/
	UINT16 retVal = CI_ERROR;

    bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

    if (bufIndex < ROUTE_SUM_MAX)
    {
        retVal = RouteDataStru[bufIndex].BelongLongRouteId;
    }
    else
    {
        retVal = CI_ERROR;
    }
	return retVal;
}


/*
* 功能描述： 设置指定ID进路所属长调进路ID
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT16 belongLongRouteId, 所属长调进路ID
* 返回值  ： 无
*             
*/
void SetRouteBelongLongRouteId(const UINT16 routeId, const UINT16 belongLongRouteId)
{
    UINT16 bufIndex = 0u;  /*数组下标*/

    bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

    if (bufIndex < ROUTE_SUM_MAX)
    {
        RouteDataStru[bufIndex].BelongLongRouteId = belongLongRouteId; /*进路所属长调进路ID*/
    }
    else
    {
        /*不做处理*/
    }
}


/*
* 功能描述： 进路状态有效性检查
* 参数说明： const UINT8 routeState, 进路状态
* 返回值  ： 0: 数据无效
*            1: 数据有效
*/
UINT8 RouteStateValidCheck(const UINT8 routeState)
{
	UINT8 retVal = CI_SUCCESS;
    if ((ROUTE_STATE_IDLE == routeState) ||
        (ROUTE_STATE_FIRST_XUANPAI == routeState) ||
        (ROUTE_STATE_XUANPAI ==routeState) ||
        (ROUTE_STATE_FIRST_LOCK == routeState) ||
        (ROUTE_STATE_FIRST_LOCKERR == routeState) ||
        (ROUTE_STATE_YUXIAN_LOCK == routeState) ||
        (ROUTE_STATE_YUXIAN_OPEN == routeState) ||
        (ROUTE_STATE_NEAR_LOCK == routeState) ||
        (ROUTE_STATE_NEAR_LOCKERR == routeState) ||
        (ROUTE_STATE_NEAR_OPEN == routeState) ||
        (ROUTE_STATE_DELAY_UNLOCK == routeState) ||
        (ROUTE_STATE_AUTO_UNLOCK == routeState) ||
        (ROUTE_STATE_AUTO_UNLOCKERR == routeState) ||
		(ROUTE_STATE_LEAD_FIRST_XUANPAI == routeState) ||
        (ROUTE_STATE_LEAD_XUANPAI == routeState) ||
        (ROUTE_STATE_LEAD_LOCK == routeState) ||
        (ROUTE_STATE_LEAD_LOCKERR == routeState) ||
		(ROUTE_STATE_LEAD_OPEN == routeState) ||
		(ROUTE_STATE_HALF_FIRST_XUAN == routeState) ||
		(ROUTE_STATE_HALF_XUANPAI == routeState) ||
		(ROUTE_STATE_HALF_LOCK == routeState) ||
		(ROUTE_STATE_HALF_UNLOCK == routeState) ||
		(ROUTE_STATE_HALF_UNLOCKDELAY == routeState))
    {
        retVal = CI_SUCCESS;
    }
    else
    {
        retVal = CI_ERROR;
    }
	return retVal;
}

/*
* 功能描述： 获取指定ID通过进路ID
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 进路状态
*/
UINT16 GetRouteThroughRouteId(const UINT16 routeId)
{
    UINT16 bufIndex = 0u;  /*数组下标*/
    UINT16 retVal = CI_ERROR;
    
    bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/
    
    if ((bufIndex < ROUTE_SUM_MAX) && 
        (GetConfigRouteType(routeId) == ROUTE_TYPE_RETURN))
    {
        retVal = RouteDataStru[bufIndex].ThroughRouteId;
    }
    else
    {
        retVal = CI_ERROR;
    }
	return retVal;
}
/*
* 功能描述： 设置指定ID进路全自动折返进路Id
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT16 autoDataId, 全自动进路Id
* 返回值  ： CI_ERROR: 设置数据失败
*            CI_SUCCESS: 设置数据成功
*/
UINT8 SetRouteAllAutoReturnId(const UINT16 routeId, const UINT16 autoDataId)
{
    UINT16 bufIndex = 0u;  /*数组下标*/
    UINT8 autoRouteProperty = GetRouteAutoRouteProperty(routeId);
    RouteDataStruct *routeDataStru = GetRouteData();
	UINT8 returnValue = CI_ERROR;
    bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

    if (bufIndex < ROUTE_SUM_MAX)
    {
        if (0u == autoDataId)
        {
            routeDataStru[bufIndex].AllAutoReturnId = 0u; /*取消自动进路设置状态*/

            returnValue = CI_SUCCESS;
        }
        else if ((autoRouteProperty == ROUTE_AUTOROUTE_PROPERTY_YES) && 
            (routeDataStru[bufIndex].AutoRouteId == 0u) &&
            (routeDataStru[bufIndex].AutoReturnId == 0u)&&
			(routeDataStru[bufIndex].AllAutoReturnId == 0u))
        {
            /*全自动折返/自动折返/自动进路不能同时设置*/
            routeDataStru[bufIndex].AllAutoReturnId = autoDataId; /*全自动进路设置状态*/

            returnValue = CI_SUCCESS;
        }
        else
        {
            /*routeDataStru[bufIndex].AutoReturnId = 0u;*/ /*自动进路设置状态*/

            returnValue = CI_ERROR;
        }
    }

	return returnValue;
}
/*
* 功能描述： 获取指定ID进路全自动折返进路ID
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 全自动折返进路id
*/
UINT16 GetRouteAllAutoReturnId(const UINT16 routeId)
{
    UINT16 bufIndex = 0u;  /*数组下标*/
	UINT16 allAutoReturnId = CI_ERROR;

    bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

    if (bufIndex < ROUTE_SUM_MAX)
    {
        allAutoReturnId = RouteDataStru[bufIndex].AllAutoReturnId;
    }

	return allAutoReturnId;
}


/*
* 功能描述： 获取指定ID进路停车保证标志
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*            1: 获取数据成功
*/
UINT8 GetRouteStopensureFlag(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 stopensureFlag = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (bufIndex < ROUTE_SUM_MAX)
	{
		stopensureFlag = RouteDataStru[bufIndex].StopensureFlag;
	}

	return stopensureFlag;

}

/*
* 功能描述： 设置指定ID进路停车保证标志
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 无
*             
*/
void SetRouteStopensureFlag(const UINT16 routeId, const UINT8 stopensureFlag)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (bufIndex < ROUTE_SUM_MAX)
	{
		if ((ROUTE_STOPENSURE_YES == stopensureFlag) || (ROUTE_STOPENSURE_NO == stopensureFlag))
		{

			RouteDataStru[bufIndex].StopensureFlag = stopensureFlag;  /*停车保证标志*/

		}
	}
}

/*
* 功能描述： 获取指定ID进路资源取消标志
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*            1: 获取数据成功
*/
UINT8 GetRouteResourceCancelFlag(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 resourcecancelFlag = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (bufIndex < ROUTE_SUM_MAX)
	{
		resourcecancelFlag = RouteDataStru[bufIndex].ResourcecancelFlag;
	}

	return resourcecancelFlag;

}
/*
* 功能描述： 设置指定ID进路资源取消标志
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 无
*
*/
void SetRouteResourceCancelFlag(const UINT16 routeId, const UINT8 resourcecancelFlag)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (bufIndex < ROUTE_SUM_MAX)
	{
		if ((ROUTE_RESOURCECANCEL_YES == resourcecancelFlag) || (ROUTE_RESOURCECANCEL_NO == resourcecancelFlag))
		{

			RouteDataStru[bufIndex].ResourcecancelFlag = resourcecancelFlag;  /*资源取消标志*/

		}
	}
}

#if 0
/*
* 功能描述： 获取指定进路始端ID信号机由SPKS关闭标志
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*			>0: 由SPKS导致信号关闭标志      
*/
UINT8 GetSPKSToRouteCloseFlag(const UINT16 routeId)
{
    UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 reVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/
	
	if (bufIndex < ROUTE_SUM_MAX)
	{
		reVal = RouteDataStru[bufIndex].SPKSToRouteCloseFlag;
	}
	return reVal;
}


/*
* 功能描述： 设置指定进路始端ID信号机由SPKS关闭标志
* 参数说明： const UINT16 routeId, 进路ID
			 const UINT8 closeFlag, 由SPKS导致信号关闭标志
* 返回值  ： 0: 获取数据失败
*			>0:  获取成功      
*/
UINT8 SetSPKSToRouteCloseFlag(const UINT16 routeId,const UINT8 closeFlag)
{
	UINT16 bufIndex = 0u;
	UINT8 reVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/
	if (bufIndex < ROUTE_SUM_MAX)
	{
		RouteDataStru[bufIndex].SPKSToRouteCloseFlag = closeFlag;
		reVal = CI_SUCCESS;
	}

	return reVal;
}
#endif

/*
* 功能描述： 获取指定ID进路停止保持检查状态
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 停止保持检查状态
*/
UINT8 GetRouteStopKeepCheckFlag(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (bufIndex < ROUTE_SUM_MAX)
	{
		retVal = RouteDataStru[bufIndex].StopKeepCheckFlag;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}


/*
* 功能描述： 设置指定ID进路停止保持检查状态
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT8 stopKeepCheckState, 停止保持检查状态
* 返回值  ： 0: 设置数据失败
*            1: 设置数据成功
*/
UINT8 SetRouteStopKeepCheckFlag(const UINT16 routeId, const UINT8 stopKeepCheckState)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_SUCCESS;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (bufIndex < ROUTE_SUM_MAX)
	{
		if ((ROUTE_STOPCHECK_SET_NO == stopKeepCheckState) || (ROUTE_STOPCHECK_SET_YES == stopKeepCheckState))
		{
			RouteDataStru[bufIndex].StopKeepCheckFlag = stopKeepCheckState; /*进路停止保持检查状态*/

			retVal = CI_SUCCESS;
		}
		else
		{
			retVal = CI_ERROR;
		}
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 获取指定ID进路带动道岔单操状态
* 参数说明： const UINT16 routeId, 进路ID    
*			UINT8 *pRouteAssoSwitSingOperStat 进路带动道岔单操状态
* 返回值  ： 无
*			 
*/
void GetRoutAssoSwitSingOperStat(const UINT16 routeId, UINT8 *pRouteAssoSwitSingOperStat)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if(NULL != pRouteAssoSwitSingOperStat)
	{
		if (bufIndex < ROUTE_SUM_MAX)
		{
			*pRouteAssoSwitSingOperStat = RouteDataStru[bufIndex].RouteAssoSwitSingOperStat;
		}
	
	}
}

/*
* 功能描述： 设置指定ID进路带动道岔单操状态
* 参数说明： const UINT16 routeId, 进路ID
*					UINT8 RouteAssoSwitSingOperStat 带动道岔单操状态
* 返回值  ： 无
*			 
*/
void SetRoutAssoSwitSingOperStat(const UINT16 routeId, UINT8 RouteAssoSwitSingOperStat)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (bufIndex < ROUTE_SUM_MAX)
	{
		RouteDataStru[bufIndex].RouteAssoSwitSingOperStat = RouteAssoSwitSingOperStat;
	}

}

/*
* 功能描述： 获取指定ID进路状态标志
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 进路状态标志
*/
UINT8 GetRouteStateFlag(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (bufIndex < ROUTE_SUM_MAX)
	{
		retVal = RouteDataStru[bufIndex].RouteStateFlag;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}


/*
* 功能描述： 设置指定ID进路状态标志
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT8 routeLevel, 进路状态标志
* 返回值  ： void
*/
void SetRouteStateFlag(const UINT16 routeId, const UINT8 routeStateFlag)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_SUCCESS;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (bufIndex < ROUTE_SUM_MAX)
	{
		RouteDataStru[bufIndex].RouteStateFlag = routeStateFlag; /*进路状态标志*/

		retVal = CI_SUCCESS;
	}
	else
	{
		retVal = CI_ERROR;
	}
	if (CI_ERROR == retVal)
	{
		debug_infor_printf((const)"SetRouteStateFlag ERROR,  RouteId:%d  ,  routeStateFlag: %d \n", routeId, routeStateFlag);
	}
}

#if 0
/*
* 功能描述： 设置指定进路的SPKS恢复需要重开信号标志
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT32 flag, SPKS恢复需要重开信号标志
* 返回值  ： 0: 设置数据失败
*            1: 设置数据成功
*/
UINT8 SetRouteSpksReOpenSigFlag(const UINT16 routeId, const UINT8 flag)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_SUCCESS;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (bufIndex < ROUTE_SUM_MAX)
	{
		if ((ROUTE_SPKS_RE_OPEN_SIG_YES == flag) || (ROUTE_SPKS_RE_OPEN_SIG_NO == flag))
		{
			RouteDataStru[bufIndex].SpksReOpenSigFlag = flag;

			retVal = CI_SUCCESS;
		}
		else
		{
			retVal = CI_ERROR;
		}
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}
/*
* 功能描述： 设置指定进路的扣车恢复需要重开信号标志
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT32 flag, 扣车恢复需要重开信号标志
* 返回值  ： 0: 设置数据失败
*            1: 设置数据成功
*/
UINT8 SetRouteDetainReOpenSigFlag(const UINT16 routeId, const UINT8 flag)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_SUCCESS;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (bufIndex < ROUTE_SUM_MAX)
	{
		if ((ROUTE_DETAIN_RE_OPEN_SIG_YES == flag) || (ROUTE_DETAIN_RE_OPEN_SIG_NO == flag))
		{
			RouteDataStru[bufIndex].DetainReOpenSigFlag = flag;

			retVal = CI_SUCCESS;
		}
		else
		{
			retVal = CI_ERROR;
		}
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 获取指定进路的SPKS恢复需要重开信号标志
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 进路的SPKS恢复需要重开信号标志
*/
UINT8 GetRouteSpksReOpenSigFlag(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (bufIndex < ROUTE_SUM_MAX)
	{
		retVal = RouteDataStru[bufIndex].SpksReOpenSigFlag;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 获取指定进路的扣车恢复需要重开信号标志
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0:获取数据失败
*           >0:进路的扣车恢复需要重开信号标志
*/
UINT8 GetRouteDetainReOpenSigFlag(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (bufIndex < ROUTE_SUM_MAX)
	{
		retVal = RouteDataStru[bufIndex].DetainReOpenSigFlag;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 设置指定进路的扣车导致信号关闭标志
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT32 flag, 扣车导致信号关闭标志
* 返回值  ： 0: 设置数据失败
*            1: 设置数据成功
*/
UINT8 SetRouteDetainCloseFlag(const UINT16 routeId, const UINT8 flag)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_SUCCESS;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (bufIndex < ROUTE_SUM_MAX)
	{
		if ((ROUTE_DETAIN_CLOSE_SIG_YES == flag) || (ROUTE_DETAIN_CLOSE_SIG_NO == flag))
		{
			RouteDataStru[bufIndex].DetainToRouteCloseFlag = flag;

			retVal = CI_SUCCESS;
		}
		else
		{
			retVal = CI_ERROR;
		}
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 获取指定进路的扣车导致信号关闭标志
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 进路的扣车导致信号关闭标志
*/
UINT8 GetRouteDetainToRouteCloseFlag(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (bufIndex < ROUTE_SUM_MAX)
	{
		retVal = RouteDataStru[bufIndex].DetainToRouteCloseFlag;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}
#endif

/*
* 功能描述： 设置指定进路的列车驶入进路标志
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT32 flag, 列车驶入进路标志
* 返回值  ： 无
*            
*/
void SetRouteTrainEnterFlag(const UINT16 routeId, const UINT8 flag)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (bufIndex < ROUTE_SUM_MAX)
	{
		if ((ROUTE_TRAIN_ENTER_FLAG_YES == flag) || (ROUTE_TRAIN_ENTER_FLAG_NO == flag))
		{
			RouteDataStru[bufIndex].TrainEnterFlag = flag;

		}
		else
		{
			/*不做处理*/
		}
	}
	else
	{
		/*不做处理*/
	}
}
/*
* 功能描述： 获取指定进路的列车驶入进路标志
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 进路的列车驶入进路标志
*/
UINT8 GetRouteTrainEnterFlag(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (bufIndex < ROUTE_SUM_MAX)
	{
		retVal = RouteDataStru[bufIndex].TrainEnterFlag;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 设置指定进路的总人解延时类型
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT32 delayType, 总人解延时类型
* 返回值  ： 无
*             
*/
void SetRouteZongRenJieDelayType(const UINT16 routeId, const UINT8 delayType)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (bufIndex < ROUTE_SUM_MAX)
	{
		if ((ROUTE_ZRJ_DELAY_TYPE_IDLE == delayType) || (ROUTE_ZRJ_DELAY_TYPE_ALL_EXP == delayType) || (ROUTE_ZRJ_DELAY_TYPE_EXP_TO_OCCUPY == delayType) || (ROUTE_ZRJ_DELAY_TYPE_INVALID == delayType))
		{
			RouteDataStru[bufIndex].ZongRenJieDelayType = delayType;
		}
		else
		{
			/*不做处理*/
		}
	}
	else
	{
		/*不做处理*/
	}
}


/*
* 功能描述： 设置指定进路的总取消延时标志
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT32 delayflag, 总取消延时标志
* 返回值  ： 无
*             
*/
void SetRouteZongQuXiaoDelayFlag(const UINT16 routeId, const UINT8 delayflag)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (bufIndex < ROUTE_SUM_MAX)
	{
		if ((ROUTE_ZQX_DELAY_YES == delayflag) || (ROUTE_ZQX_DELAY_NO == delayflag))
		{
			RouteDataStru[bufIndex].CancleDelayflag = delayflag;
		}
		else
		{
			/*不做处理*/
		}
	}
	else
	{
		/*不做处理*/
	}
}


/*
* 功能描述： 获取指定进路的总取消延时标志
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 进路的总取消标志
*/
UINT8 GetRouteZongQuXiaoDelayFlag(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/
	if (bufIndex < ROUTE_SUM_MAX)
	{
		retVal = RouteDataStru[bufIndex].CancleDelayflag;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 获取指定进路的总人解延时类型
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 进路的总人解延时类型
*/
UINT8 GetRouteZongRenJieDelayType(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (bufIndex < ROUTE_SUM_MAX)
	{
		retVal = RouteDataStru[bufIndex].ZongRenJieDelayType;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 设置指定进路的SPKS、PSD、扣车恢复重开信号标志
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT32 flag, 总人解延时类型
* 返回值  ： 无
*            
*/
void SetRouteRecoverState(const UINT16 routeId, const UINT8 flag)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (bufIndex < ROUTE_SUM_MAX)
	{
		if ((ROUTE_RECOVER_STA_INIT == flag) || (ROUTE_RECOVER_STA_WAIT == flag) || (ROUTE_RECOVER_STA_STAY == flag))
		{
			RouteDataStru[bufIndex].RecoverOpenState = flag;

		}
		else
		{
			/*不做处理*/
		}
	}
	else
	{
		/*不做处理*/
	}
}

/*
* 功能描述： 获取指定进路的SPKS、PSD、扣车恢复重开信号标志
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: SPKS、PSD、扣车恢复重开信号标志
*/
UINT8 GetRouteRecoverOpenFlag(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (bufIndex < ROUTE_SUM_MAX)
	{
		retVal = RouteDataStru[bufIndex].RecoverOpenState;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 设置指定进路的列车是否驶入过该进路标志，该标志用于中途折返
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT8 flag, 列车是否驶入过该进路标志
* 返回值  ： 无
*             
*/
void SetTrainEnterRouteFlag(const UINT16 routeId, const UINT8 flag)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (bufIndex < ROUTE_SUM_MAX)
	{
		if ((TRAIN_ENTER_ROUTE_FLAG_YES == flag) || (TRAIN_ENTER_ROUTE_FLAG_NO == flag))
		{
			RouteDataStru[bufIndex].TrainEnterRouteFlag = flag;
		}
		else
		{
			/*不做处理*/
		}
	}
	else
	{
		/*不做处理*/
	}
}
/*
* 功能描述： 获取指定进路的列车是否驶入过该进路标志，该标志用于中途折返
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 进路的列车是否驶入过该进路标志
*/
UINT8 GetTrainEnterRouteFlag(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (bufIndex < ROUTE_SUM_MAX)
	{
		retVal = RouteDataStru[bufIndex].TrainEnterRouteFlag;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 获取指定ID进路期望锁闭保护区段ID
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 进路期望锁闭保护区段ID
*/
UINT16 GetRouteAtsExpLkOverlapId(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT16 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (bufIndex < ROUTE_SUM_MAX)
	{
		retVal = RouteDataStru[bufIndex].atsExptLkOverlapId;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}


/*
* 功能描述： 设置指定ID进路期望锁闭保护区段ID
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT16 expLkOverlapId, ats或现地发送的期望锁闭保护区段Id
* 返回值  ： 无
*             
*/
void SetRouteAtsExpLkOverlapId(const UINT16 routeId, const UINT16 expLkOverlapId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if ((bufIndex < ROUTE_SUM_MAX) && (UINT16_MAX != expLkOverlapId))
	{
		RouteDataStru[bufIndex].atsExptLkOverlapId = expLkOverlapId; /*ats或现地发送的期望锁闭保护区段ID*/
	}
	else
	{
		/*不做处理*/
	}
}


/*
* 功能描述： 获取其它联锁进路保护区段UT解锁周期数
* 参数说明： const UINT16 routeId,进路ID
* 返回值  ： 0: 设置数据失败
*            其它: 周期数
*/
UINT16 GetOtherCIRouteOvlpUTUnlockCnt(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT16 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/
	if (bufIndex < ROUTE_SUM_MAX)
	{
		retVal = RouteDataStru[bufIndex].OtherCIRouteOvlpUTUnlockCount;
	}
	return retVal;
}

/*
* 功能描述： 设置其它联锁进路保护区段UT解锁周期数
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT16 count, 其它联锁进路保护区段解锁周期数
* 返回值  ： 无
*            
*/
void SetOtherCIRouteOvlpUTUnlockCnt(const UINT16 routeId,const UINT16 count)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/
	if (bufIndex < ROUTE_SUM_MAX)
	{
		if (count != RouteDataStru[bufIndex].OtherCIRouteOvlpUTUnlockCount)
		{
			RouteDataStru[bufIndex].OtherCIRouteOvlpUTUnlockCount = count;
		}
	}
}

/*
* 功能描述： 获取其它联锁进路保护区段CT解锁周期数
* 参数说明： const UINT16 routeId,进路ID
* 返回值  ： 0: 设置数据失败
*            其它: 周期数
*/
UINT16 GetOtherCIRouteOverlapCTUnlockCount(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT16 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/
	if (bufIndex < ROUTE_SUM_MAX)
	{
		retVal = RouteDataStru[bufIndex].OtherCIRouteOvlpCTUnlockCount;
	}
	return retVal;
}

/*
* 功能描述： 设置其它联锁进路保护区段CT解锁周期数
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT16 count, 其它联锁进路保护区段解锁周期数
* 返回值  ： 无
*            
*/
void SetOtherCIRouteOverlapCTUnlockCount(const UINT16 routeId,const UINT16 count)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/
	if (bufIndex < ROUTE_SUM_MAX)
	{
		if (count != RouteDataStru[bufIndex].OtherCIRouteOvlpCTUnlockCount)
		{
			RouteDataStru[bufIndex].OtherCIRouteOvlpCTUnlockCount = count;
		}
	}
}


/*
* 功能描述： 设置指定进路的需开放不满足时重开信号标志
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT32 flag, 重开信号标志
* 返回值  ： 无
*             
*/
void SetRouteNeedOpenReopenFlag(const UINT16 routeId, const UINT8 flag)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (bufIndex < ROUTE_SUM_MAX)
	{
		if ((ROUTE_NEEDOPEN_REOPEN_NO == flag) || (ROUTE_NEEDOPEN_REOPEN_YES == flag) )
		{
			RouteDataStru[bufIndex].NeedOpenNotTrueRepeatFlag = flag;
		}
		else
		{
			/*不做处理*/
		}
	}
	else
	{
		/*不做处理*/
	}
}

/*
* 功能描述： 获取指定进路的需开放不满足时重开信号标志
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 重开信号标志
*/
UINT8 GetRouteNeedOpenReopenFlag(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (bufIndex < ROUTE_SUM_MAX)
	{
		retVal = RouteDataStru[bufIndex].NeedOpenNotTrueRepeatFlag;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}


/*
* 功能描述： 获取指定ID进路需开放不满足时起始信号机重开起始周期号
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 重开起始周期号
*/
UINT32 GetRouteNeedOpenNotTrueSigRepeatOpenStartCycNum(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT32 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (bufIndex < ROUTE_SUM_MAX)
	{
		retVal = RouteDataStru[bufIndex].NeedOpenNotTrueRepeatStartCount;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 设定指定ID进路需开放不满足时起始信号机重开起始周期号
* 参数说明： const UINT16 routeId, 进路ID
*			const UINT32 signalOpenStartCycNum， 信号开放起始周期
* 返回值  ：无
*            
*/
void SetRouteNeedOpenNotTrueSigRepeatOpenStartCycNum(const UINT16 routeId, const UINT32 signalOpenStartCycNum)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (bufIndex < ROUTE_SUM_MAX)
	{
		RouteDataStru[bufIndex].NeedOpenNotTrueRepeatStartCount = signalOpenStartCycNum; 
	}
	else
	{
		/*不做处理*/
	}
}


/*
* 功能描述： 设置指定进路的调车请求状态
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT8 dcqState, 调车请求状态
* 返回值  ： 无
* by cgh 20250523
*/
void SetRouteDCQState(const UINT16 routeId, const UINT8 dcqState)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		if ((ROUTE_DCQ_REQUEST == dcqState) || (ROUTE_DCQ_NOT_REQUEST == dcqState) )
		{
			RouteDataStru[bufIndex].DCQState = dcqState;
		}
		else
		{
			;
		}
	}
	else
	{
		;
	}
}

/*
* 功能描述： 获取指定进路的调车请求状态
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 调车请求状态
*/
UINT8 GetRouteDCQState(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		retVal = RouteDataStru[bufIndex].DCQState;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 设置指定进路的调车同意状态
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT8 dcTyState, 调车请求状态
* 返回值  ： 无
* by cgh 20250523
*/
void SetRouteDCTYState(const UINT16 routeId, const UINT8 dcTyState)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		if ((ROUTE_DCT_AGREE == dcTyState) || (ROUTE_DCT_NOT_AGREE == dcTyState) )
		{
			RouteDataStru[bufIndex].DCTYState = dcTyState;
		}
		else
		{
			;
		}
	}
	else
	{
		;
	}
}

/*
* 功能描述： 获取指定进路的调车同意状态
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 调车同意状态
*/
UINT8 GetRouteDCTYState(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if  (ROUTE_SUM_MAX > bufIndex)
	{
		retVal = RouteDataStru[bufIndex].DCTYState;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}


/*
* 功能描述： 获取指定进路的调车同意不满足信号重开标志
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 调车同意重开标志
*/
UINT8 GetRouteDCTYNotSatisfySignalReOpenFlag(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if  (ROUTE_SUM_MAX > bufIndex)
	{
		retVal = RouteDataStru[bufIndex].DCTYNotSatisfySignalReOpenFlag;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 设置指定进路的调车同意不满足信号重开标志
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT32 dcTyState, 调车同意重开标志
* 返回值  ： 无
*             
*/
void SetRouteDCTYNotSatisfySignalReOpenFlag(const UINT16 routeId, const UINT8 dcTyFlag)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		if ((ROUTE_DCTY_REOPEN == dcTyFlag) || (ROUTE_DCTY_REOPEN_NO == dcTyFlag) )
		{
			RouteDataStru[bufIndex].DCTYNotSatisfySignalReOpenFlag = dcTyFlag;
		}
		else
		{
			/*不做处理*/
		}
	}
	else
	{
		/*不做处理*/
	}
}

/*
* 功能描述： 获取指定进路的调车同意起始周期
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 调车同意起始周期
*/
UINT32 GetRouteDCTYNotSatisfyStartCnt(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT32 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		retVal = RouteDataStru[bufIndex].DCTYNotSatisfyStartCount;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 设置指定进路的调车同意不满足起始周期
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT32 dcTyState, 调车同意起始周期
* 返回值  ： 无
*             
*/
void SetRouteDCTYNotSatisfyStartCnt(const UINT16 routeId, const UINT32 dcTyCount)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		RouteDataStru[bufIndex].DCTYNotSatisfyStartCount = dcTyCount;	
	}
	else
	{
		/*不做处理*/
	}
}
/*
* 功能描述： 设置指定点式进路终端信号机亮灯状态检查不通过，信号保持容忍开放状态开始周期
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT32 CycleNum, 周期号
* 返回值  ： 0: 设置数据失败
*            1: 设置数据成功
*/
UINT8 SetRouteKeepSigTolerateCyc(const UINT16 routeId, const UINT32 dwCycleNum)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		RouteDataStru[bufIndex].RouteKeepSignalTolerateCycNum = dwCycleNum;
		retVal = CI_SUCCESS;

	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}
/*
* 功能描述： 获取指定点式进路终端信号机亮灯状态检查不通过，信号保持容忍开放状态开始周期
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 容忍周期数
*/
UINT32 GetRouteKeepSigTolerateCyc(const UINT16 routeId,  UINT32 *pTolerateCycNum)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT32 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/
	if(NULL != pTolerateCycNum)
	{
		if (ROUTE_SUM_MAX > bufIndex)
		{
			*pTolerateCycNum = RouteDataStru[bufIndex].RouteKeepSignalTolerateCycNum;
			retVal = CI_SUCCESS;
		}
		else
		{
			retVal = CI_ERROR;
		}
	}
	else
	{
		retVal = CI_ERROR;
	}

	return retVal;
}


/*
* 功能描述： 设置存在自动信号进路取消标志
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT8 cmdFlag  命令标志
* 返回值  ： 无
*/
void SetCancleAutoSigCmdFlag(const UINT16 routeId,const UINT8 cmdFlag)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/
	if (ROUTE_SUM_MAX > bufIndex)
	{
		RouteDataStru[bufIndex].CancleAutoSigCmd = cmdFlag;
	}
	else
	{
		/*不做处理*/
	}
}

/*
* 功能描述： 获取指定进路的取消命令
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 进路的取消命令
*/
UINT8 GetCancleAutoSigCmdFlag(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		retVal = RouteDataStru[bufIndex].CancleAutoSigCmd;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return(retVal);
}

/*
* 功能描述： 设置自动信号取消状态
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT8 cancleState 进路取消状态
* 返回值  ： 无
*/
void SetAutoSigCancleState(const UINT16 routeId,const UINT8 cancleState)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/
	if (ROUTE_SUM_MAX > bufIndex)
	{
		RouteDataStru[bufIndex].AutoSigCancleState = cancleState;
	}
	else
	{
		/*不做处理*/
	}
}

/*
* 功能描述： 获取指定进路的取消状态
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 进路的取消状态
*/
UINT8 GetAutoSigCancleState(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		retVal = RouteDataStru[bufIndex].AutoSigCancleState;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return(retVal);
}

/*
* 功能描述： 获取指定进路的停车保证申请列车ID
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 停车保证申请列车ID
*/
UINT16 GetRouteStopEnassureTrainId(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT16 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		retVal = RouteDataStru[bufIndex].wStopEnsureTrainId;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 设置进路需询问停车保证的列车ID号
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT16 wTrainId 列车编号
* 返回值  ： 无
*/
void SetRouteStopEnsureTrainId(const UINT16 routeId, const UINT16 wTrainId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/
	if (ROUTE_SUM_MAX > bufIndex)
	{
		RouteDataStru[bufIndex].wStopEnsureTrainId = wTrainId;
	}
	else
	{
		/*不做处理*/
	}
}

/*
* 功能描述： 获取指定进路的资源取消允许列车ID
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 停车保证申请列车ID
*/
UINT16 GetRouteResourceCancelTrainId(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT16 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		retVal = RouteDataStru[bufIndex].wResourceCancelTrainId;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 设置进路需询问资源取消的列车ID号
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT16 wTrainId 列车编号
* 返回值  ： 无
*/
void SetRouteResourceCancelTrainId(const UINT16 routeId, const UINT16 wTrainId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/
	if (ROUTE_SUM_MAX > bufIndex)
	{
		RouteDataStru[bufIndex].wResourceCancelTrainId = wTrainId;
	}
	else
	{
		/*不做处理*/
	}
}

/*
* 功能描述： 获取指定进路需要折返解锁的列车ID
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 停车保证申请列车ID
*/
UINT16 GetRouteZhefanJiesuoTrainId(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT16 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		retVal = RouteDataStru[bufIndex].wZhefanjiesuoTrainId;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 设置指定进路需要折返解锁的列车ID号
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT16 wTrainId 列车编号
* 返回值  ： 无
*/
void SetRouteZhefanJiesuoTrainId(const UINT16 routeId, const UINT16 wTrainId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/
	if (ROUTE_SUM_MAX > bufIndex)
	{
		RouteDataStru[bufIndex].wZhefanjiesuoTrainId = wTrainId;
	}
	else
	{
		/*不做处理*/
	}
}


/*
* 功能描述： 获取进路接近区段上最近的列车
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0u 无车接近
*			 接近列车的边编号
*/
UINT16 GetRouteNearestTrainId(const UINT16 wRouteId)
{
	UINT16 wRetVal = 0u;
	UINT16 wLogSecId = 0u;
	UINT8 cRouteDir = CI_SYSTEM_DIRECTION_NONE;
	UINT8 cLogSecLinkSum = 0u;
	UINT16 * pLogSecLinkIdBuf = NULL;
	UINT8 cLinkIndex = 0u;
	UINT8 i = 0u;
	UINT8 cTrainRunDir = 0u;
	UINT8 cSysLogDir = CI_SYSTEM_DIRECTION_NONE;/* 系统定义的逻辑方向 */

	UINT16 cSignalId = 0u;
	LOD_STRU pLgcStartPoint = { 0u }; /*占压的逻辑区段始端位置*/
	LOD_STRU pSignalProtePoint = { 0u }; /*信号机位置*/
	LOD_STRU pTrainMinTailPoint = { 0u }; /*列车安全车尾位置*/
	UINT8 cDirChangedNum1 = 0U;			/*方向变化点数量1*/
	UINT8 cDirChangedNum2 = 0U;			/*方向变化点数量2*/
	UINT8 chTrainLevel = 0U;		/*列车运行级别*/

	TRAIN_SEQUANCE_s tmpTrainInfo = { 0u };

	/* 获取接近区段上最近的占压逻辑区段 */
	wLogSecId = GetRouteHaveTrainNearLogSecId(wRouteId);
	cLogSecLinkSum = GetSecIntrudeLinkSum(wLogSecId);
	pLogSecLinkIdBuf = GetSecIntrudeLinkIdBuf(wLogSecId);

	/*获取进路始端信号机*/
	cSignalId = GetRouteStartSignalId(wRouteId);

	/* 查询到逻辑区段关联的link序列 */
	if ((0u != cLogSecLinkSum) && (NULL != pLogSecLinkIdBuf))
	{
		/* 根据进路防护方向与link上的列车排序获得最近的列车 */
		cRouteDir = GetSignalDirection(cSignalId);/*信号机防护方向*/

		pLgcStartPoint.Lnk = pLogSecLinkIdBuf[0U];
		pLgcStartPoint.Off = 0U;

		pSignalProtePoint.Lnk = GetSignalProtectLink(cSignalId);
		pSignalProtePoint.Off = GetSignalProtectLinkOff(cSignalId);

		cDirChangedNum1 = GetDirChangeNumBtwPoints(&pLgcStartPoint, &pSignalProtePoint);			/*查占压区段到信号机之间link序列有多少方向变化点*/
		/*根据方向变换点数量转换方向*/
		cRouteDir = TransDirByChangeNum(cRouteDir, cDirChangedNum1);



		if (DIR_SAME == cRouteDir)
		{
			for (i = 0u; i < cLogSecLinkSum; i++)
			{
				cLinkIndex = cLogSecLinkSum - i;
				cLinkIndex--;
				tmpTrainInfo.u16TrainID = NAME_FAILUREAREA;
				tmpTrainInfo.u8TrainType = TYPE_FAILURE;

				tmpTrainInfo = as_GetLinkLastTrain(pLogSecLinkIdBuf[cLinkIndex]);
				cTrainRunDir = GetTrainDir(tmpTrainInfo.u16TrainID);
				/*获取列车安全车尾到逻辑区段link起点是否有方向变化点*/
				pTrainMinTailPoint.Lnk = GetTrainMinTailLink(tmpTrainInfo.u16TrainID);
				pTrainMinTailPoint.Off = GetTrainMinTailOffset(tmpTrainInfo.u16TrainID);

				cDirChangedNum2 = GetDirChangeNumBtwPoints(&pLgcStartPoint, &pTrainMinTailPoint);			/*查安全车尾到逻辑区段link起点有多少方向变化点*/
				/*根据方向变换点数量转换方向*/
				cTrainRunDir = TransDirByChangeNum(cTrainRunDir, cDirChangedNum2);

				/*获取列车运行级别*/
				chTrainLevel = GetTrainLevel(tmpTrainInfo.u16TrainID);
				if (0U != cTrainRunDir)
				{
					if ((NAME_FAILUREAREA != tmpTrainInfo.u16TrainID) && (TYPE_FAILURE != tmpTrainInfo.u8TrainType)
						&& (cTrainRunDir == cRouteDir) && (TRAIN_LEVEL_VBTC == chTrainLevel))
					{
						wRetVal = tmpTrainInfo.u16TrainID;
						break;
					}
					else
					{
						;
					}
				}
				else
				{
					/*无操作*/
				}
			}
		}
		else if (DIR_CONVERT == cRouteDir)
		{
			for (i = 0u; i < cLogSecLinkSum; i++)
			{
				tmpTrainInfo.u16TrainID = NAME_FAILUREAREA;
				tmpTrainInfo.u8TrainType = TYPE_FAILURE;

				tmpTrainInfo = as_GetLinkFirstTrain(pLogSecLinkIdBuf[i]);
				cTrainRunDir = GetTrainDir(tmpTrainInfo.u16TrainID);
				/*获取列车安全车尾到逻辑区段link起点是否有方向变化点*/
				pTrainMinTailPoint.Lnk = GetTrainMinTailLink(tmpTrainInfo.u16TrainID);
				pTrainMinTailPoint.Off = GetTrainMinTailOffset(tmpTrainInfo.u16TrainID);

				cDirChangedNum2 = GetDirChangeNumBtwPoints(&pLgcStartPoint, &pTrainMinTailPoint);			/*查安全车尾到逻辑区段link起点有多少方向变化点*/
				/*根据方向变换点数量转换方向*/
				cTrainRunDir = TransDirByChangeNum(cTrainRunDir, cDirChangedNum2);

				/*获取列车运行级别*/
				chTrainLevel = GetTrainLevel(tmpTrainInfo.u16TrainID);
				if (0U != cTrainRunDir)
				{
					if ((NAME_FAILUREAREA != tmpTrainInfo.u16TrainID) && (TYPE_FAILURE != tmpTrainInfo.u8TrainType)
						&& (cTrainRunDir == cRouteDir) && (TRAIN_LEVEL_VBTC == chTrainLevel))
					{
						wRetVal = tmpTrainInfo.u16TrainID;
						break;
					}
					else
					{
						;

					}
				}
				else
				{
					/*无操作*/
				}
			}
		}
		else
		{
			/*无操作*/
		}

	}
	else
	{
		;
	}
	return wRetVal;
}

/*
* 功能描述： 获取进路接近区段上最近的列车，不判列车与进路的方向
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0u 无车接近
*			 接近列车的边编号
*/
UINT16 GetRouteNODirNearestTrainId(const UINT16 wRouteId)
{
	UINT16 wRetVal = 0u;
	UINT16 wLogSecId = 0u;
	UINT8 cRouteLevel = ROUTE_LEVEL_BLOC;        /*进路监督级别*/
	UINT8 cRouteDir = CI_SYSTEM_DIRECTION_NONE;
	UINT8 cLogSecLinkSum = 0u;
	UINT16 * pLogSecLinkIdBuf = NULL;
	UINT8 cLinkIndex = 0u;
	UINT8 i = 0u;
	UINT8 cSysLogDir = CI_SYSTEM_DIRECTION_NONE;/* 系统定义的逻辑方向 */
	UINT16 cSignalId = 0u;
	LOD_STRU pLgcStartPoint = { 0u }; /*占压的逻辑区段始端位置*/
	LOD_STRU pSignalProtePoint = { 0u }; /*信号机位置*/
	LOD_STRU pTrainMinTailPoint = { 0u }; /*列车安全车尾位置*/
	UINT8 cDirChangedNum1 = 0U;			/*方向变化点数量1*/

	TRAIN_SEQUANCE_s tmpTrainInfo = { 0u };
	
	LOD_STRU pLgcEndPoint = { 0u }; /*占压的逻辑区段终端位置*/

	cRouteLevel = GetRouteLevel(wRouteId);    /*获取进路监督级别*/
	cSignalId = GetRouteStartSignalId(wRouteId);

	/* 获取接近区段上最近的占压逻辑区段 */
	wLogSecId = GetRouteHaveTrainNearLogSecId(wRouteId);
	cLogSecLinkSum = GetSecIntrudeLinkSum(wLogSecId);
	pLogSecLinkIdBuf = GetSecIntrudeLinkIdBuf(wLogSecId);

	/* 查询到逻辑区段关联的link序列 */
	if ((0u != cLogSecLinkSum) && (NULL != pLogSecLinkIdBuf))
	{
		/* 根据进路防护方向与link上的列车排序获得最近的列车 */
		cRouteDir = GetSignalDirection(cSignalId);/*信号机防护方向*/

		pLgcStartPoint.Lnk = pLogSecLinkIdBuf[0U];
		pLgcStartPoint.Off = 0U;

		pSignalProtePoint.Lnk = GetSignalProtectLink(cSignalId);
		pSignalProtePoint.Off = GetSignalProtectLinkOff(cSignalId);

		cDirChangedNum1 = GetDirChangeNumBtwPoints(&pLgcStartPoint, &pSignalProtePoint);			/*查占压区段到信号机之间link序列有多少方向变化点*/
		/*根据方向变换点数量转换方向*/
		cRouteDir = TransDirByChangeNum(cRouteDir, cDirChangedNum1);

		/*进路方向与逻辑方向一致*/
		if (DIR_SAME == cRouteDir)
		{
			for (i = 0u; i < cLogSecLinkSum; i++)
			{
				cLinkIndex = cLogSecLinkSum - i;
				cLinkIndex--;
				tmpTrainInfo.u16TrainID = NAME_FAILUREAREA;
				tmpTrainInfo.u8TrainType = TYPE_FAILURE;

				tmpTrainInfo = as_GetLinkLastTrain(pLogSecLinkIdBuf[cLinkIndex]);/*获取最后一列车的信息*/
				
				/*判断不是故障列车且ID不在故障区域使用*/
				if ((NAME_FAILUREAREA != tmpTrainInfo.u16TrainID) && (TYPE_FAILURE != tmpTrainInfo.u8TrainType))	/*不查列车方向*/
				{
					wRetVal = tmpTrainInfo.u16TrainID;
					break;
				}
				else
				{
					/*继续查找*/
				}
			}
		}
		/*进路方向与逻辑方向相反*/
		else if (DIR_CONVERT == cRouteDir)
		{
			for (i = 0u; i < cLogSecLinkSum; i++)
			{
				tmpTrainInfo.u16TrainID = NAME_FAILUREAREA;
				tmpTrainInfo.u8TrainType = TYPE_FAILURE;

				tmpTrainInfo = as_GetLinkFirstTrain(pLogSecLinkIdBuf[i]);/*获取第一列车的信息*/
				
				/*判断不是故障列车且ID不在故障区域使用*/
				if ((NAME_FAILUREAREA != tmpTrainInfo.u16TrainID) && (TYPE_FAILURE != tmpTrainInfo.u8TrainType))
				{
					wRetVal = tmpTrainInfo.u16TrainID;
					break;
				}
				else
				{
					/*继续查找*/

				}
			}
		}
		else
		{
			/*无操作*/
		}


	}
	else
	{
		;
	}

	return wRetVal;
}



/*
* 功能描述： 进路资源传递保护区段资源
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0u 无车接近
*			 接近列车的边编号
* 修复bug YF0083-119
*/
void RouteResourceToOverlap(const UINT16 wRouteId)
{
	UINT16 wRouteLockOverlapId = 0u;
	UINT8 cOverlapCiId = 0u;
	UINT8 cLocalCiId = 0u;/*本联锁ID*/
	UINT8 cTrainSum = 0u;
	LogicTrainResStruct * pLogicTrainResData = NULL;
	UINT16 wRouteLastLogicSectionId = 0u;
	UINT8 ii = 0u;

	wRouteLockOverlapId = GetRouteOverlapLockedId(wRouteId);
	if (0u != wRouteLockOverlapId)
	{
		cOverlapCiId = GetOverlapBelongCiId(wRouteLockOverlapId);
		cLocalCiId = GetSystemParaLocalCiId();

		if ((0u != cLocalCiId) && (cOverlapCiId == cLocalCiId))
		{
			wRouteLastLogicSectionId = GetRouteInLastLogSecId(wRouteId);
			cTrainSum = GetLogSecTrainInfoSum(wRouteLastLogicSectionId);
			pLogicTrainResData = GetLogSecTrainInfo(wRouteLastLogicSectionId);

			if ((0u != cTrainSum) && (NULL != pLogicTrainResData))
			{
				for (ii = 0u; ii < cTrainSum; ii++)
				{
					/* 将所有列车申请添加到保护区段的逻辑区段中 */
					SetOverlapTrainLockApply(wRouteLockOverlapId, pLogicTrainResData[ii].wTrainId);
				}
			}
			else
			{

			}
		}
		else
		{

		}
	}
	else
	{

	}

}


/*
* 功能描述： 获取指定ID进路发送资源请求的其他联锁ID
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 联锁编号
*/
UINT8 GetRouteResReqOtherCIId(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (bufIndex < ROUTE_SUM_MAX)
	{
		retVal = RouteDataStru[bufIndex].cResReqOtherCIId;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}


/*
* 功能描述： 设置指定ID进路发送资源请求的其他联锁ID
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT8 cOtherCiId, 联锁编号
* 返回值  ： 无
*
*/
void SetRouteResReqOtherCIId(const UINT16 routeId, const UINT8 cOtherCiId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (bufIndex < ROUTE_SUM_MAX)
	{
		RouteDataStru[bufIndex].cResReqOtherCIId = cOtherCiId;
	}
	else
	{
		/*不做处理*/
	}
}

/*
* 功能描述： 获取指定ID进路发送资源请求的列车
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 联锁编号
*/
UINT16 * GetRouteResReqTrainIdBuf(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT16 * retVal = NULL;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (bufIndex < ROUTE_SUM_MAX)
	{
		retVal = RouteDataStru[bufIndex].wszResReqTrainId;
	}
	else
	{
		retVal = NULL;
	}

	return retVal;
}


/*
* 功能描述： 设置指定ID进路发送资源请求的列车ID
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT8 wTrainId, 列车
* 返回值  ： 无
* 修复bug YF0083-119
*/
void SetRouteResReqTrainId(const UINT16 routeId, const UINT16 wTrainId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 ii = 0U;
	UINT8 chReqTrainSum = 0U;
	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/
	if (( ROUTE_SUM_MAX> bufIndex )&& (0u != wTrainId))
	{
		chReqTrainSum = RouteDataStru[bufIndex].chResReqTrainSum;

		if ((ROUTE_APPLY_RECD_TRAIN_SUM_MAX - 1U) > chReqTrainSum)
		{
			for (ii = 0U; ii < chReqTrainSum; ii++)
			{
				if (RouteDataStru[bufIndex].wszResReqTrainId[ii] == wTrainId)
				{
					break;
				}
				else
				{
					; /*继续执行*/
				}
			}

			if (ii == chReqTrainSum)
			{
				RouteDataStru[bufIndex].wszResReqTrainId[chReqTrainSum] = wTrainId;
				RouteDataStru[bufIndex].chResReqTrainSum = chReqTrainSum + 1U;
			}
			else
			{

			}
		}
		else
		{

		}
	}
	else
	{
		/*不做处理*/
	}
}

/*
* 功能描述： 清理指定ID进路发送资源请求的列车
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 无
*
*/
void ClearRouteResReqTrainBuf(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 ii = 0U;
	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/
	if (ROUTE_SUM_MAX> bufIndex)
	{
		
		for (ii = 0U; ii < ROUTE_APPLY_RECD_TRAIN_SUM_MAX; ii++)
		{
			RouteDataStru[bufIndex].wszResReqTrainId[ii] = 0;
				
		}

		RouteDataStru[bufIndex].chResReqTrainSum = 0U;
	}
	else
	{
		/*不做处理*/
	}
}

/*
* 功能描述： 删除指定需请求列车ID
* 参数说明： UINT16 routeId,   进路ID
*			 UINT16 wTrainId   列车ID
* 返回值  ：
* 修复bug YF0083-119
*/
void RemoveRouteReqResTrain(UINT16 routeId, UINT16 wTrainId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 ii = 0U;
	UINT8 jj = 0U;
	UINT8 chReqTrainSum = 0U;
	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/
	if (ROUTE_SUM_MAX> bufIndex)
	{
		chReqTrainSum = RouteDataStru[bufIndex].chResReqTrainSum;

		if ((ROUTE_APPLY_RECD_TRAIN_SUM_MAX - 1U) > chReqTrainSum)
		{
			for (ii = 0U; ii < chReqTrainSum; ii++)
			{
				if (RouteDataStru[bufIndex].wszResReqTrainId[ii] == wTrainId)
				{
					break;
				}
				else
				{
					; /*继续执行*/
				}
			}

			if (ii == chReqTrainSum)
			{
				/*未找到 无需继续*/
			}
			else
			{
				for (jj = ii + 1U; jj < chReqTrainSum; jj++)
				{
					RouteDataStru[bufIndex].wszResReqTrainId[jj - 1U] = RouteDataStru[bufIndex].wszResReqTrainId[jj];
				}
				RouteDataStru[bufIndex].wszResReqTrainId[jj] = 0U;

				
				RouteDataStru[bufIndex].chResReqTrainSum -= 1U;

				if (0u == RouteDataStru[bufIndex].chResReqTrainSum)
				{
					RouteDataStru[bufIndex].cResReqOtherCIId = 0U;
				}
				else
				{

				}
			}
		}
		else
		{

		}
	}
	else
	{
		/*不做处理*/
	}
		


}

/*
* 功能描述： 获取指定进路请求列车数量
* 参数说明： const UINT16 wRouteId, 进路ID
*
* 返回值  ： 数量
*/
UINT8 GetRouteResReqTrainSum(const UINT16 wRouteId)
{
	UINT16 wBufIndex = 0u;  /*数组下标*/
	UINT8 chRetVal = CI_ERROR;

	wBufIndex = GetRouteConfigBufIndex(wRouteId);  /*获取区段数组下标*/

	if (ROUTE_SUM_MAX > wBufIndex)
	{
		if (ROUTE_APPLY_RECD_TRAIN_SUM_MAX > RouteDataStru[wBufIndex].chResReqTrainSum)
		{
			chRetVal = RouteDataStru[wBufIndex].chResReqTrainSum;
		}
		else
		{
			chRetVal = CI_ERROR;
		}
	}
	else
	{
		chRetVal = CI_ERROR;
	}
	return chRetVal;
}

/*
* 功能描述： 获取指定进路的停车保证申请命令的周期号
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 周期号
*/
UINT32 GetRouteStopEnassureCyc(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT32 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		retVal = RouteDataStru[bufIndex].dwStopEnsureCyc;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 设置进路需询问停车保证申请命令的周期号
* 参数说明： const UINT16 routeId, 进路ID
*           const UINT32 dwCyc 周期号
* 返回值  ： 无
*/
void SetRouteStopEnsureCyc(const UINT16 routeId, const UINT32 dwCyc)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/
	if (ROUTE_SUM_MAX > bufIndex)
	{
		RouteDataStru[bufIndex].dwStopEnsureCyc = dwCyc;
	}
	else
	{
		/*不做处理*/
	}
}

/*
* 功能描述： 获取指定进路的资源取消允许命令的周期号
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 周期号
*/
UINT32 GetRouteResourceCancelCyc(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT32 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		retVal = RouteDataStru[bufIndex].dwResourceCancelCyc;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 设置进路需询问资源取消允许命令的周期号
* 参数说明： const UINT16 routeId, 进路ID
*           const UINT32 dwCyc 周期号
* 返回值  ： 无
*/
void SetRouteResourceCancelCyc(const UINT16 routeId, const UINT32 dwCyc)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/
	if (ROUTE_SUM_MAX > bufIndex)
	{
		RouteDataStru[bufIndex].dwResourceCancelCyc = dwCyc;
	}
	else
	{
		/*不做处理*/
	}
}

/*
* 功能描述： 获取指定进路需要列车折返解锁的周期号
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 周期号
*/
UINT32 GetRouteZhefanJiesuoCyc(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT32 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		retVal = RouteDataStru[bufIndex].dwRouteZhefanjiesuoCyc;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 设置指定进路需要列车折返解锁的周期号
* 参数说明： const UINT16 routeId, 进路ID
*           const UINT32 dwCyc 周期号
* 返回值  ： 无
*/
void SetRouteZhefanJiesuoCyc(const UINT16 routeId, const UINT32 dwCyc)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/
	if (ROUTE_SUM_MAX > bufIndex)
	{
		RouteDataStru[bufIndex].dwRouteZhefanjiesuoCyc = dwCyc;
	}
	else
	{
		/*不做处理*/
	}
}
/*
* @brief 设置ITS申请路径命令包含的TrainID
* @details 记录ITS申请路径命令对指定进路的列车ID，以便进路初锁时，逻辑区段资源上可添加该列车ID。
* @param const UINT16 routeId 进路ID
*        const UINT16 trainID 列车ID
* @note 创建 WQM 20220310
*/
void SetITSRouteApplyTrainIDInfo(const UINT16 routeId, const UINT16 trainId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 i = 0u;
	UINT8 trainIdSum = 0u;

	/** 入参检查*/
	if ((0u < routeId) && (ROUTE_SUM_MAX > routeId) && (TRAIN_ID_MIN < trainId) && (TRAIN_ID_MAX > trainId))
	{
		bufIndex = GetRouteConfigBufIndex(routeId);  /** 获取进路数组下标*/
		trainIdSum = RouteDataStru[bufIndex].ITSRouteApplyTrainIdSum; /** 获取ITS申请路径命令的列车ID记录的总数量*/
		/** 若数组下标合法且列车ID数量合法*/
		if (ROUTE_APPLY_RECD_TRAIN_SUM_MAX >= trainIdSum)
		{
			/** 列车ID数量为0*/
			if (0u == trainIdSum)
			{
				/*还未记录列车Id*/
				RouteDataStru[bufIndex].ITSRouteApplyTrainIdBuf[trainIdSum] = trainId; /** 记录该列车ID*/
				RouteDataStru[bufIndex].ITSRouteApplyTrainIdSum++; /** 列车ID数量加1*/
			}
			/** 已有记录的列车Id*/
			else
			{
				
				/** 列车ID数量不为0，遍历列车ID数量*/
				for (i = 0u; i < trainIdSum; i++)
				{
					/** 查询已记录的列车Id是否与当前期望记录的列车Id相同*/
					if (trainId == RouteDataStru[bufIndex].ITSRouteApplyTrainIdBuf[i])
					{
						break; /** 已记录的列车Id中有与期望记录的列车ID相同，跳出循环*/
					}
					else
					{

					}
				}

				/** 索引下标等于列车ID数量，即未查询到期望记录的列车ID；且增加一个列车ID后不会越界*/
				if ((i == trainIdSum) && (ROUTE_APPLY_RECD_TRAIN_SUM_MAX > trainIdSum))
				{
					/*列车Id还未记录，且列车ID数量还未超限，需在数组最后添加*/
					RouteDataStru[bufIndex].ITSRouteApplyTrainIdBuf[trainIdSum] = trainId; /** 记录该列车ID*/
					RouteDataStru[bufIndex].ITSRouteApplyTrainIdSum++; /** 列车ID数量加1*/
				}
				else
				{
					/*已存在列车Id或列车ID数量已超限，无需再处理*/
				}
			}
		}
		else
		{
			/*不做处理*/
		}
	}
	else
	{
		/*不做处理*/
	}
}

/*
* @brief 获取指定进路ITS申请路径命令的列车ID记录的总数量
* @param const UINT16 routeId 进路ID
* @return UINT8 retVal 记录的列车ID总数量
* @retval CI_ERROR 默认返回值
*		  记录的列车ID总数量
* @note 创建 WQM 20220310
*/
UINT8 GetITSRouteApplyTrainIdSum(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	/** 入参检查*/
	if ((0u < routeId) && (ROUTE_SUM_MAX > routeId))
	{
		bufIndex = GetRouteConfigBufIndex(routeId);  /** 获取进路数组下标*/
		/** 数组下标合法*/
		retVal = RouteDataStru[bufIndex].ITSRouteApplyTrainIdSum; /** 返回记录的列车ID总数量*/
		
	}
	else
	{
		/*返回失败*/
	}
	return retVal;
}

/*
* @brief 获取指定进路ITS申请路径命令记录的列车ID数组
* @param const UINT16 routeId 进路ID
* @return UINT16 * retVal 记录的列车ID数组
* @retval NULL 默认返回值
*		  记录的列车ID数组
* @note 创建 WQM 20220310
*/
UINT16 * GetITSRouteApplyTrainIdBuf(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT16 * retVal = NULL;

	/** 入参检查*/
	if ((0u < routeId) && (ROUTE_SUM_MAX > routeId))
	{
		bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/
		 /** 数组下标合法*/
		retVal = RouteDataStru[bufIndex].ITSRouteApplyTrainIdBuf; /** 返回记录的列车ID数组指针*/
		
	}
	else
	{
		
	}
	return retVal;
}

/*
* @brief 清空指定进路ITS申请路径命令记录的列车ID信息
* @param const UINT16 routeId 进路ID
* @note 创建 WQM 20220310
*/
void ClearITSRouteApplyTrainIDInfo(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 i = 0u; /*索引*/

	/** 入参检查*/
	if ((0u < routeId) && (ROUTE_SUM_MAX > routeId))
	{
		bufIndex = GetRouteConfigBufIndex(routeId);  /** 获取进路数组下标*/
		/** 索引未越界，遍历列车ID数组*/
		for (i = 0u; i < ROUTE_APPLY_RECD_TRAIN_SUM_MAX; i++)
		{				
			RouteDataStru[bufIndex].ITSRouteApplyTrainIdBuf[i] = 0u; /** 清空通过ITS申请路径命令记录的列车ID数组*/
		}		
		RouteDataStru[bufIndex].ITSRouteApplyTrainIdSum = 0u; /** 清空ITS申请路径命令的列车ID记录的总数量*/
		
	}
	else
	{
		/*不做处理*/
	}
}

/*
* @brief 设置进路保护区段需置共享资源CIId
* @details 记录CiID，该联锁收到后需置保护区段为共享资源
* @param const UINT16 routeId 进路ID
*        const UINT8 chCiId   CiID
* @return 无
*/
void SetRouteOvlapShrCiId(const UINT16 routeId, const UINT8 chCiId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	/** 获取进路数组下标*/
	bufIndex = GetRouteConfigBufIndex(routeId);  
	/** 若数组下标合法且列车ID数量合法*/
	if (ROUTE_SUM_MAX > bufIndex)
	{
		RouteDataStru[bufIndex].chShareOverlapCiId = chCiId;
	}
	else
	{
		/*不做处理*/
	}
}

/*
* @brief 获取路保护区段需置共享资源CIId
* @param const UINT16 routeId 进路ID
* @return UINT8 retVal 记录的Ci ID
* @retval CI_ERROR 默认返回值
*		  记录的需请求得CiId
*/
UINT8 GetRouteOvlapShrCiId(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /** 获取进路数组下标*/
													/** 数组下标合法*/
	if(ROUTE_SUM_MAX > bufIndex)
	{
		retVal = RouteDataStru[bufIndex].chShareOverlapCiId; /** 返回记录的列车ID总数量*/
	}
	else
	{
		/*返回失败*/
	}

	return retVal;
}

/*
* @brief 获取进路限速确认状态
* @param const UINT16 routeId 进路ID
* @return UINT8 retVal 记录的Ci ID
* @retval CI_ERROR 默认返回值
*		  进路限速确认状态
*/
UINT8 GetRouteXiansuConfirmStt(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /** 获取进路数组下标*/
												 /** 数组下标合法*/
	if (ROUTE_SUM_MAX > bufIndex)
	{
		retVal = RouteDataStru[bufIndex].chRouteXiansuConfirm; /** 返回进路限速状态*/
	}
	else
	{
		/*返回失败*/
	}

	return retVal;
}

/*
* @brief 设置进路限速确认状态
* @details 设置限速确认后，点式进路不检查限速状态
* @param const UINT16 routeId 进路ID
*        const UINT8 chXianSuRemoveStt   chXianSuRemoveStt
* @return 无
*/
void SetRouteXianSuConfirmStt(const UINT16 routeId, const UINT8 chXianSuConfirmStt)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /** 获取进路数组下标*/
												 /** 数组下标合法*/
	if (ROUTE_SUM_MAX > bufIndex)
	{
		if ((ROUTE_XIANSU_CONFIRM_NO == chXianSuConfirmStt)
			|| (ROUTE_XIANSU_CONFIRM_YES == chXianSuConfirmStt))
		{
			RouteDataStru[bufIndex].chRouteXiansuConfirm= chXianSuConfirmStt; /** 返回进路限速状态*/
		}
		else
		{
			;
		}
	}
	else
	{
		/*返回失败*/
	}

}
/*
*功能描述： 设置保护区段需要由联锁锁闭标志
* 参数说明： const UINT16 routeId, 进路ID
* const UINT8 flag 标志
* 返回值  ： 无
* cgh-合并CID-2539-10
*/
void SetRouteOverlapNeedCIlockFlag(const UINT16 routeId, const UINT8 flag)
{
	UINT16 bufIndex = 0;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标,错误返回MAX，返回值>0*/
	if (ROUTE_SUM_MAX > bufIndex)
	{
		if ((OVERLAPCILOCK_YES == flag) || (OVERLAPCILOCK_NO == flag))
		{
			RouteDataStru[bufIndex].OverlapNeedCIlockFlag = flag;
		}

	}
	else
	{
		/*不做处理*/
	}
}

/*
* 功能描述： 获取保护区段需要由联锁锁闭标志
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT8 flag 标志
* 返回值  ： 无
* cgh-合并CID-2539-10
*/
UINT8 GetRouteOverlapNeedCIlockFlag(const UINT16 routeId)
{
	UINT16 bufIndex = 0;  /*数组下标*/
	UINT8 reVal = 0u;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标,错误返回MAX，返回值>0*/
	if (ROUTE_SUM_MAX > bufIndex)
	{
		reVal = RouteDataStru[bufIndex].OverlapNeedCIlockFlag;
	}
	else
	{
		/*不做处理*/
	}
	return reVal;
}

/*
* 功能描述： 设置保护区段在锁闭过程中标志
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT8 flag 标志
* 返回值  ： 无
* cgh-合并CID-2539-10
*/
void SetRouteOverlapLockProcFlag(const UINT16 routeId, const UINT8 flag)
{
	UINT16 bufIndex = 0;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标,错误返回MAX，返回值>0*/
	if (ROUTE_SUM_MAX > bufIndex)
	{
		RouteDataStru[bufIndex].OverlapLockProcFlag = flag;
	}
	else
	{
		/*不做处理*/
	}
}

/*
* 功能描述： 获取保护区段在锁闭过程中标志
* 参数说明： const UINT16 routeId, 进路ID
*
* 返回值  ： >0 保护区段在锁闭过程中标志
*            0 获取失败
* cgh-合并CID-2539-10：
*/
UINT8 GetRouteOverlapLockProcFlag(const UINT16 routeId)
{
	UINT16 bufIndex = 0;  /*数组下标*/
	UINT8 reVal = 0u;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标,错误返回MAX，返回值>0*/
	if (ROUTE_SUM_MAX > bufIndex)
	{
		reVal = RouteDataStru[bufIndex].OverlapLockProcFlag;
	}
	else
	{
		/*不做处理*/
	}
	return reVal;
}
/*
* 功能描述： 设置进路是否具有组合进路命令标志
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT8 flag 标志
* 返回值  ： 无
* cgh-合并CID-2539-10：
*/
void SetRouteGroupRouteCmdFlag(const UINT16 routeId, const UINT8 flag)
{
	UINT16 bufIndex = 0;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标,错误返回MAX，返回值>0*/
	if (ROUTE_SUM_MAX > bufIndex)
	{
		RouteDataStru[bufIndex].GroupRouteCmdFlag = flag;
	}
	else
	{
		/*不做处理*/
	}
}

/*
* 功能描述： 获取进路是否具有组合进路命令标志
* 参数说明： const UINT16 routeId, 进路ID
*
* 返回值  ： >0 组合进路命令标志
*            0 获取失败
* cgh-合并CID-2539-10：
*/
UINT8 GetRouteGroupRouteCmdFlag(const UINT16 routeId)
{
	UINT16 bufIndex = 0;  /*数组下标*/
	UINT8 reVal = 0u;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标,错误返回MAX，返回值>0*/
	if (ROUTE_SUM_MAX > bufIndex)
	{
		reVal = RouteDataStru[bufIndex].GroupRouteCmdFlag;
	}
	else
	{
		/*不做处理*/
	}
	return reVal;
}

/*
* 功能描述： 设置进路的自动触发标志
* 参数说明： UINT16 routeId 需设的自动触发进路
*            UINT8 setFlag  需设置的自动触发标志
* 返回值  ：无
* cgh-合并CID-3037-4：
*/
void SetRouteAutoTriggerFlag(UINT16 routeId, UINT8 setFlag)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		if ((AUTO_TRIGGER_SET_YES == setFlag) || (AUTO_TRIGGER_SET_NO == setFlag))
		{
			RouteDataStru[bufIndex].AutoTriggerFlag = setFlag;   /*设置自动触发标志*/
		}
	}
}

/*
* 功能描述： 获取指定进路的自动触标志
* 参数说明： const UINT16 routeId, 进路ID
*
* 返回值  ： >0 组合进路命令标志
*            0 获取失败
* cgh-合并CID-3037-4：
*/
UINT8 GetRouteAutoTriggerFlag(const UINT16 routeId)
{
	UINT16 bufIndex = 0;  /*数组下标*/
	UINT8 reVal = 0u;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标,错误返回MAX，返回值>0*/
	if (ROUTE_SUM_MAX > bufIndex)
	{	
		reVal = RouteDataStru[bufIndex].AutoTriggerFlag;
	}
	else
	{
		/*不做处理*/
	}
	return reVal;
}

/**
* @brief 获取进路当前正常锁闭逻辑区段
* @param[in] const UINT16 wRouteId 进路ID
* @param[out] UINT16 szLgcId[MAX_ROUTE_IN_LT_NUM] 逻辑区段ID
* @return 正常锁闭逻辑区段数量
*/
UINT16 GetRouteLockLgc(const UINT16 wRouteId, UINT16 szLgcId[MAX_ROUTE_IN_LT_NUM])
{
	UINT16 wLgcNum = 0u;
	UINT16 wLgcIndex = 0u;
	UINT16 * pRouteLgc = NULL;
	UINT8 chLockState = 0u;
	UINT16 wRtn = 0u;
	wLgcNum = GetRouteLogSectionSum(wRouteId);
	pRouteLgc = GetRouteLogSectionIdBuf(wRouteId);
	if ((0u == wLgcNum) || (NULL == pRouteLgc))
	{
		; /* 入参或数据有误 */
	}
	else
	{
		for (wLgcIndex = 0u; wLgcIndex < wLgcNum; wLgcIndex++)
		{
			chLockState = GetLogSecLockState(pRouteLgc[wLgcIndex]);
			if (LOG_SECTION_LOCK_NORMAL == chLockState)
			{
				szLgcId[wRtn++] = pRouteLgc[wLgcIndex];
			}
			else
			{
				; /* 逻辑区段非正常锁闭状态 */
			}
		}
	}
	return wRtn;
}

/*
* 功能描述： 获取指定ID进路半截锁闭可动道岔标志
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 半截锁闭可动道岔标志
*/
UINT8 GetHalfRouteSwitchMoveValid(const UINT16 routeId)
{
	UINT16 bufIndex = 0;  /*数组下标*/
	UINT8 reVal = 0u;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标,错误返回MAX，返回值>0*/
	if (ROUTE_SUM_MAX > bufIndex)
	{
		reVal = RouteDataStru[bufIndex].HalfRouteDataSt.HalfRouteSwitchMoveValid;
	}
	else
	{
		/*不做处理*/
	}
	return reVal;
}

/*
* 功能描述： 设置指定ID进路半截锁闭可动道岔标志
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT8 switchMoveValid, 可动道岔标志
* 返回值  ： CI_ERROR
*            CI_SUCCESS
*/
void SetHalfRouteSwitchMoveValid(const UINT16 routeId, const UINT8 switchMoveValid)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		if ((ROUTE_HALF_SWITCH_MOVE_VALID == switchMoveValid) || (ROUTE_HALF_SWITCH_MOVE_INVALID == switchMoveValid))
		{
			RouteDataStru[bufIndex].HalfRouteDataSt.HalfRouteSwitchMoveValid = switchMoveValid;   /*设置可动道岔标志*/
		}
		else
		{
			RouteDataStru[bufIndex].HalfRouteDataSt.HalfRouteSwitchMoveValid = ROUTE_HALF_SWITCH_MOVE_INVALID;
		}
	}
}

/*
* 功能描述： 获取指定ID进路半截锁闭资源申请列车ID
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 半截锁闭资源申请列车ID
*/
UINT16 GetHalfRouteResReqTrainId(const UINT16 routeId)
{
	UINT16 bufIndex = 0;  /*数组下标*/
	UINT16 reVal = 0u;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标,错误返回MAX，返回值>0*/
	if (ROUTE_SUM_MAX > bufIndex)
	{
		reVal = RouteDataStru[bufIndex].HalfRouteDataSt.HalfResReqTrainId;
	}
	else
	{
		/*不做处理*/
	}
	return reVal;
}

/*
* 功能描述： 设置指定ID进路半截锁闭资源申请列车ID
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT8 trainId, 列车ID
* 返回值  ： CI_ERROR
*            CI_SUCCESS
*/
void SetHalfRouteResReqTrainId(const UINT16 routeId, const UINT16 trainId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		if ((0U != trainId) && (UINT16_MAX!= trainId))
		{
			RouteDataStru[bufIndex].HalfRouteDataSt.HalfResReqTrainId = trainId;   /*设置列车ID*/
		}
		else
		{
			RouteDataStru[bufIndex].HalfRouteDataSt.HalfResReqTrainId = 0U;
		}
	}
}

/*
* 功能描述： 获取指定ID进路半截锁闭逻辑区段数量
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 进路半截锁闭逻辑区段数量
*/
UINT8 GetHalfRouteLockLgcSecSum(const UINT16 routeId)
{
	UINT16 bufIndex = 0;  /*数组下标*/
	UINT8 reVal = 0u;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标,错误返回MAX，返回值>0*/
	if (ROUTE_SUM_MAX > bufIndex)
	{
		reVal = RouteDataStru[bufIndex].HalfRouteDataSt.RouteLockLgcSecNum;
	}
	else
	{
		/*不做处理*/
	}
	return reVal;
}


/*
* 功能描述： 获取指定ID进路半截锁闭逻辑区段ID数组
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： NULL: 获取数据失败
*           !NULL: 锁闭逻辑区段ID数组
*/
UINT16 * GetHalfRouteLockLgcSecIdBuf(const UINT16 routeId)
{
	UINT16 bufIndex = 0;  /*数组下标*/
	UINT16 * reVal = NULL;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标,错误返回MAX，返回值>0*/
	if (ROUTE_SUM_MAX > bufIndex)
	{
		reVal = RouteDataStru[bufIndex].HalfRouteDataSt.RouteLockLgcSecIdBuf;
	}
	else
	{
		/*不做处理*/
	}
	return reVal;
}

/*
* 功能描述： 设置指定ID进路半截锁闭逻辑区段数据
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT8 lgcSecNum, 逻辑区段数量
*			 const UINT16 *pLgcSecIdBuf 逻辑区段ID数组
* 返回值  ： 无
*             
*/
void SetHalfRouteLockLgcSec(const UINT16 routeId,const UINT8 lgcSecNum, const UINT16 *pLgcSecIdBuf)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 ii = 0U;
	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		if ((NULL != pLgcSecIdBuf) && (MAX_ROUTE_IN_LT_NUM > lgcSecNum))
		{
			(void)CommonMemSet(RouteDataStru[bufIndex].HalfRouteDataSt.RouteLockLgcSecIdBuf,\
				(UINT32)sizeof(RouteDataStru[bufIndex].HalfRouteDataSt.RouteLockLgcSecIdBuf),\
				0, (UINT32)sizeof(RouteDataStru[bufIndex].HalfRouteDataSt.RouteLockLgcSecIdBuf));
			for (ii = 0U; ii < lgcSecNum; ii++)
			{
				RouteDataStru[bufIndex].HalfRouteDataSt.RouteLockLgcSecIdBuf[ii] = pLgcSecIdBuf[ii];
			}
			RouteDataStru[bufIndex].HalfRouteDataSt.RouteLockLgcSecNum = lgcSecNum;
		}
		else
		{
			(void)CommonMemSet(RouteDataStru[bufIndex].HalfRouteDataSt.RouteLockLgcSecIdBuf, \
				(UINT32)sizeof(RouteDataStru[bufIndex].HalfRouteDataSt.RouteLockLgcSecIdBuf), \
				0, (UINT32)sizeof(RouteDataStru[bufIndex].HalfRouteDataSt.RouteLockLgcSecIdBuf));
			RouteDataStru[bufIndex].HalfRouteDataSt.RouteLockLgcSecNum = 0U;
		}
	}
}

/*
* 功能描述： 获取指定ID进路列车脚下逻辑区段数量
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 进路列车脚下逻辑区段数量
*/
UINT8 GetHalfRouteTrainLocLgcSecNum(const UINT16 routeId)
{
	UINT16 bufIndex = 0;  /*数组下标*/
	UINT8 reVal = 0u;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标,错误返回MAX，返回值>0*/
	if (ROUTE_SUM_MAX > bufIndex)
	{
		reVal = RouteDataStru[bufIndex].HalfRouteDataSt.TrainLocLgcSecNum;
	}
	else
	{
		/*不做处理*/
	}
	return reVal;
}


/*
* 功能描述： 获取指定ID进路半截锁闭列车脚下逻辑区段ID数组
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： NULL: 获取数据失败
*           !NULL: 锁闭列车脚下逻辑区段ID数组
*/
UINT16 * GetHalfRouteTrainLocLgcSecIdBuf(const UINT16 routeId)
{
	UINT16 bufIndex = 0;  /*数组下标*/
	UINT16 * reVal = NULL;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标,错误返回MAX，返回值>0*/
	if (ROUTE_SUM_MAX > bufIndex)
	{
		reVal = RouteDataStru[bufIndex].HalfRouteDataSt.TrainLocLgcSecIdBuf;
	}
	else
	{
		/*不做处理*/
	}
	return reVal;
}

/*
* 功能描述： 设置指定ID进路半截锁闭列车脚下逻辑区段信息
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT8 lgcSecNum, 逻辑区段数量
*			 const UINT16 *pLgcSecIdBuf 逻辑区段ID数组
* 返回值  ： 无
*
*/
void SetHalfRouteTrainLocLgcSec(const UINT16 routeId, const UINT8 lgcSecNum, const UINT16 *pLgcSecIdBuf)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 ii = 0U;
	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		if ((NULL != pLgcSecIdBuf) && (ROUTE_TRAIN_LOC_MAX_LGC_SUM > lgcSecNum))
		{
			(void)CommonMemSet(RouteDataStru[bufIndex].HalfRouteDataSt.TrainLocLgcSecIdBuf, \
				(UINT32)sizeof(RouteDataStru[bufIndex].HalfRouteDataSt.TrainLocLgcSecIdBuf), \
				0, (UINT32)sizeof(RouteDataStru[bufIndex].HalfRouteDataSt.TrainLocLgcSecIdBuf));
			for (ii = 0U; ii < lgcSecNum; ii++)
			{
				RouteDataStru[bufIndex].HalfRouteDataSt.TrainLocLgcSecIdBuf[ii] = pLgcSecIdBuf[ii];
			}
			RouteDataStru[bufIndex].HalfRouteDataSt.TrainLocLgcSecNum = lgcSecNum;
		}
		else
		{
			(void)CommonMemSet(RouteDataStru[bufIndex].HalfRouteDataSt.TrainLocLgcSecIdBuf, \
				(UINT32)sizeof(RouteDataStru[bufIndex].HalfRouteDataSt.TrainLocLgcSecIdBuf), \
				0, (UINT32)sizeof(RouteDataStru[bufIndex].HalfRouteDataSt.TrainLocLgcSecIdBuf));
			RouteDataStru[bufIndex].HalfRouteDataSt.TrainLocLgcSecNum = 0U;
		}
	}
}


/*
* 功能描述： 设置指定ID进路半截锁闭列车脚下逻辑区段信息
* 参数说明： const UINT16 routeId, 进路ID
*            OUT UINT16 szRouteHalfPhySecData[ROUTE_PHYSICALSECTION_SUM_MAX] 输出物理区段ID数组
*			 
* 返回值  ： 0失败 >0物理区段数量
*
*/
UINT8 GetRouteHalfPhysicalSecData(const UINT16 routeId,OUT UINT16 szRouteHalfPhySecData[ROUTE_PHYSICALSECTION_SUM_MAX])
{
	UINT16 bufIndex = 0;  /*数组下标*/
	UINT8 reVal = 0u;
	UINT8 ii = 0U; /*循环变量*/
	UINT8 jj = 0U;
	UINT16 phySecId = 0U;
	UINT8 phySecSum = 0U;
	UINT16 szTmpPhySecIdBuf[ROUTE_PHYSICALSECTION_SUM_MAX] = { 0U };
	
	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标,错误返回MAX，返回值>0*/
	/*入参检查*/
	if (NULL != szRouteHalfPhySecData)
	{
		if (ROUTE_SUM_MAX > bufIndex)
		{
			/*遍历进路所有逻辑区段*/
			for (ii = 0U; ii < RouteDataStru[bufIndex].HalfRouteDataSt.RouteLockLgcSecNum; ii++)
			{
				phySecId =GetLgcSecRelativePhySecId( RouteDataStru[bufIndex].HalfRouteDataSt.RouteLockLgcSecIdBuf[ii]);

				/*去重*/
				for (jj = 0U; jj < phySecSum; jj++)
				{
					if (szTmpPhySecIdBuf[jj] == phySecId)
					{
						break;
					}
					else
					{
						;  /* 继续执行*/
					}
				}

				/*未重复*/
				if (jj == phySecSum)
				{
					if (phySecSum < ROUTE_PHYSICALSECTION_SUM_MAX)
					{
						szTmpPhySecIdBuf[phySecSum++] = phySecId;
					}
					else
					{
						break;
					}
				}
			}

			/*执行完成，未越界*/
			if (ii == RouteDataStru[bufIndex].HalfRouteDataSt.RouteLockLgcSecNum)
			{
				reVal = phySecSum;
				for (ii = 0U; ii < phySecSum; ii++)
				{
					szRouteHalfPhySecData[ii] = szTmpPhySecIdBuf[ii];
				}
			}

		}
		else
		{
			/*检查失败*/
			reVal = 0u;
		}
	}
	else
	{
		/*检查失败*/
		reVal = 0u;
	}

	return reVal;
}


/*
* 功能描述： 设置指定ID进路半截锁闭列车脚下物理区段信息
* 参数说明： const UINT16 routeId, 进路ID
*            OUT UINT16 szRouteHalfPhySecData[ROUTE_PHYSICALSECTION_SUM_MAX] 输出物理区段ID数组
*
* 返回值  ： 0失败 >0物理区段数量
*
*/
UINT8 GetRouteTrainLocPhySecData(const UINT16 routeId, OUT UINT16 szRouteTrainLocPhySecData[ROUTE_PHYSICALSECTION_SUM_MAX])
{
	UINT16 bufIndex = 0;  /*数组下标*/
	UINT8 reVal = 0u;
	UINT8 ii = 0U; /*循环变量*/
	UINT8 jj = 0U;
	UINT16 phySecId = 0U;
	UINT8 phySecSum = 0U;
	UINT16 szTmpPhySecIdBuf[ROUTE_PHYSICALSECTION_SUM_MAX] = { 0U };
	UINT8 funcRet = 0U;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

												 /*入参检查*/
	if (NULL != szRouteTrainLocPhySecData)
	{
		if (ROUTE_SUM_MAX > bufIndex)
		{
			/*遍历车脚下所有逻辑区段*/
			for (ii = 0U; ii < RouteDataStru[bufIndex].HalfRouteDataSt.TrainLocLgcSecNum; ii++)
			{
				funcRet = CheckLgcSecInHalfRoute(routeId, RouteDataStru[bufIndex].HalfRouteDataSt.TrainLocLgcSecIdBuf[ii]);		/*包含在部分进路中的逻辑区段才计入*/
				if (CI_SUCCESS == funcRet)
				{
					phySecId = GetLgcSecRelativePhySecId(RouteDataStru[bufIndex].HalfRouteDataSt.TrainLocLgcSecIdBuf[ii]);
					/*去重*/
					for (jj = 0U; jj < phySecSum; jj++)
					{
						if (szTmpPhySecIdBuf[jj] == phySecId)
						{
							break;
						}
						else
						{
							;  /* 继续执行*/
						}
					}

					/*未重复*/
					if (jj == phySecSum)
					{
						if (phySecSum < ROUTE_PHYSICALSECTION_SUM_MAX)
						{
							szTmpPhySecIdBuf[phySecSum++] = phySecId;
						}
						else
						{
							break;
						}
					}
				}
				else
				{
					;		/*不是本部分进路内物理区段，不计入*/
				}
			}

			/*执行完成，未越界*/
			if (ii == RouteDataStru[bufIndex].HalfRouteDataSt.TrainLocLgcSecNum)
			{
				reVal = phySecSum;
				for (ii = 0U; ii < phySecSum; ii++)
				{
					szRouteTrainLocPhySecData[ii] = szTmpPhySecIdBuf[ii];
				}
			}

		}
		else
		{
			/*检查失败*/
			reVal = 0u;
		}
	}
	else
	{
		/*检查失败*/
		reVal = 0u;
	}

	return reVal;
}
/*
* 功能描述： 设置指定ID进路半截锁闭防护道岔信息
* 参数说明： const UINT16 routeId, 进路ID
*            OUT RouteProtectSwitchStruct szRouteProtectSwitchStruct[ROUTE_PHYSICALSECTION_SUM_MAX] 输出物理区段ID数组
*
* 返回值  ： 0失败 >0物理区段数量
*
*/
UINT8 GetRouteHalfProSwData(const UINT16 routeId, OUT RouteProtectSwitchStruct szRouteProSwitchStruct[ROUTE_PROTECTSWI_SUM_MAX])
{
	UINT16 bufIndex = 0;  /*数组下标*/
	UINT8 reVal = 0u;
	UINT8 keepWork = CI_ERROR;
	UINT8 ii = 0U; /*循环变量*/
	UINT8 jj = 0U;
	UINT8 kk = 0U;
	UINT16 phySecId = 0U;
	UINT8 phySecSum = 0U;
	UINT8 proSwSum = 0U;
	UINT8 outTmpProSwSum = 0U;
	RouteProtectSwitchStruct szTmpProSwStru[ROUTE_PROTECTSWI_SUM_MAX] = { 0U };
	LogsecSwitchStruct *pLgcProSwStru = NULL;
	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标,错误返回MAX，返回值>0*/
												 /*入参检查*/
	if (NULL != szRouteProSwitchStruct)
	{
		if (ROUTE_SUM_MAX > bufIndex)
		{
			keepWork = CI_SUCCESS;
			/*遍历进路所有逻辑区段*/
			for (ii = 0U; ii < RouteDataStru[bufIndex].HalfRouteDataSt.RouteLockLgcSecNum; ii++)
			{
				proSwSum = GetLgcRelateProSwSum( RouteDataStru[bufIndex].HalfRouteDataSt.RouteLockLgcSecIdBuf[ii]);
				pLgcProSwStru = GetLgcRelateProSwStru(RouteDataStru[bufIndex].HalfRouteDataSt.RouteLockLgcSecIdBuf[ii]);
			
				if (NULL != pLgcProSwStru)
				{
					/*去重并添加*/
					for (jj = 0U; jj < proSwSum; jj++)
					{
						for (kk = 0U; kk < outTmpProSwSum; kk++)
						{
							if (pLgcProSwStru[jj].SwitchId == szTmpProSwStru[kk].ProtectSwitchId)
							{
								break;
							}
							else
							{
								/*继续执行*/
							}
						}
						if (kk == outTmpProSwSum)
						{
							if (ROUTE_PROTECTSWI_SUM_MAX > outTmpProSwSum)
							{
								szTmpProSwStru[outTmpProSwSum].ProtectSwitchId = pLgcProSwStru[jj].SwitchId;
								szTmpProSwStru[outTmpProSwSum].ProtectPosition = pLgcProSwStru[jj].SwitchPosition;
								outTmpProSwSum++;
							}
							else
							{
								break;
							}
						}
					}
				}
				else
				{
					keepWork = CI_ERROR;
				}

				/*未重复*/
				if (jj != proSwSum)
				{
					keepWork = CI_ERROR;
				}
				else
				{
					;
				}

				if (CI_ERROR == keepWork)
				{
					break;
				}
				else
				{
					;
				}
			}

			/*执行完成，未越界*/
			if (ii == RouteDataStru[bufIndex].HalfRouteDataSt.RouteLockLgcSecNum)
			{
				reVal = outTmpProSwSum;
				for (ii = 0U; ii < outTmpProSwSum;ii++)
				{
					szRouteProSwitchStruct[ii] = szTmpProSwStru[ii];
				}
			}

		}
		else
		{
			/*检查失败*/
			reVal = 0u;
		}
	}
	else
	{
		/*检查失败*/
		reVal = 0u;
	}

	return reVal;
}

/*
* 功能描述： 获取指定ID进路列车脚下资源是否包含该逻辑区段
* 参数说明： const UINT16 routeId, 进路ID
*			 const UINT16 lgcSecId
* 返回值  ： CI_SUCCESS: 不在列车脚下资源中
*            CI_ERROR: 在列车脚下资源中
*/
UINT8  CheckLgcSecNotInTrainLoc(const UINT16 routeId,const UINT16 lgcSecId)
{
	UINT16 bufIndex = 0;  /*数组下标*/
	UINT8 reVal = CI_ERROR;
	UINT8 ii = 0U;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标,错误返回MAX，返回值>0*/
	if (ROUTE_SUM_MAX > bufIndex)
	{
		for (ii = 0U; ii < RouteDataStru[bufIndex].HalfRouteDataSt.TrainLocLgcSecNum; ii++)
		{
			if (lgcSecId == RouteDataStru[bufIndex].HalfRouteDataSt.TrainLocLgcSecIdBuf[ii])
			{
				break;
			}
			else
			{
				; /*继续执行*/
			}
		}

		if (ii == RouteDataStru[bufIndex].HalfRouteDataSt.TrainLocLgcSecNum)
		{
			/*未找到相同的逻辑区段*/
			reVal = CI_SUCCESS;
		}
		
	}
	else
	{
		/*不做处理*/
	}
	return reVal;
}


/*
* 功能描述： 设置列车脚下所属进路为halfunlock
* 参数说明： const UINT16 routeId, 进路ID
*			 
* 返回值  ： 无
*            
*/
void  SetTrainLocRouteHalfUnlock(const UINT16 routeId)
{
	UINT16 bufIndex = 0;  /*数组下标*/
	UINT16 rLockRouteId = 0U;
	UINT8 reVal = CI_ERROR;
	UINT8 ii = 0U;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标,错误返回MAX，返回值>0*/
	if (ROUTE_SUM_MAX > bufIndex)
	{
		for (ii = 0U; ii < RouteDataStru[bufIndex].HalfRouteDataSt.TrainLocLgcSecNum; ii++)
		{
			rLockRouteId = GetLogSecLockBelongRoute(RouteDataStru[bufIndex].HalfRouteDataSt.TrainLocLgcSecIdBuf[ii]);
			SetRouteStateManage(rLockRouteId,ROUTE_STATE_HALF_UNLOCK);
		}

	}
	else
	{
		/*不做处理*/
	}
}
/*
* 功能描述： 获取指定ID进路列车脚下资源包含该逻辑区段
* 参数说明： const UINT16 routeId, 进路ID
*			 const UINT16 lgcSecId
* 返回值  ： CI_SUCCESS: 在列车脚下资源中
*            CI_ERROR: 不在列车脚下资源中
*/
UINT8  CheckLgcSecHaveTrainLoc(const UINT16 routeId, const UINT16 lgcSecId)
{
	UINT16 bufIndex = 0;  /*数组下标*/
	UINT8 reVal = CI_ERROR;
	UINT8 ii = 0U;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标,错误返回MAX，返回值>0*/
	if (ROUTE_SUM_MAX > bufIndex)
	{
		for (ii = 0U; ii < RouteDataStru[bufIndex].HalfRouteDataSt.TrainLocLgcSecNum; ii++)
		{
			if (lgcSecId == RouteDataStru[bufIndex].HalfRouteDataSt.TrainLocLgcSecIdBuf[ii])
			{
				reVal = CI_SUCCESS;
				break;
			}
			else
			{
				; /*继续执行*/
			}
		}

		if (ii == RouteDataStru[bufIndex].HalfRouteDataSt.TrainLocLgcSecNum)
		{
			/*未找到相同的逻辑区段*/
			reVal = CI_ERROR;
		}
		else
		{

		}

	}
	else
	{
		/*不做处理*/
		reVal = CI_ERROR;
	}
	return reVal;
}

/*
* 功能描述： 获取指定ID进路列车脚下资源包含该逻辑区段
* 参数说明： const UINT16 routeId, 进路ID
*			 const UINT16 lgcSecId
* 返回值  ： CI_SUCCESS: 在半截预锁闭中
*            CI_ERROR: 不在半截预锁闭中
*/
UINT8  CheckLgcSecInHalfRoute(const UINT16 routeId, const UINT16 lgcSecId)
{
	UINT16 bufIndex = 0;  /*数组下标*/
	UINT8 reVal = CI_ERROR;
	UINT8 ii = 0U;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标,错误返回MAX，返回值>0*/
	if (ROUTE_SUM_MAX > bufIndex)
	{
		for (ii = 0U; ii < RouteDataStru[bufIndex].HalfRouteDataSt.RouteLockLgcSecNum; ii++)
		{
			if (lgcSecId == RouteDataStru[bufIndex].HalfRouteDataSt.RouteLockLgcSecIdBuf[ii])
			{
				reVal = CI_SUCCESS;
				break;
			}
			else
			{
				; /*继续执行*/
			}
		}

		if (ii == RouteDataStru[bufIndex].HalfRouteDataSt.RouteLockLgcSecNum)
		{
			/*未找到相同的逻辑区段*/
			reVal = CI_ERROR;
		}
		else
		{

		}

	}
	else
	{
		/*不做处理*/
		reVal = CI_ERROR;
	}
	return reVal;
}
/*
* 功能描述： 获取指定ID进路所属动态进路ID
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 所属动态进路ID
*/
UINT16 GetRouteBelongDrId(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT16 retVal = 0u;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标,错误返回MAX，返回值>0*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		retVal = RouteDataStru[bufIndex].wBelongDrId;
	}
	else
	{
		retVal = 0u;
	}
	return retVal;
}


/*
* 功能描述： 设置指定ID进路所属动态进路ID
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT16 belongDrId, 所属动态进路ID
* 返回值  ： 无
*
*/
void SetRouteBelongDrId(const UINT16 routeId, const UINT16 belongDrId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		RouteDataStru[bufIndex].wBelongDrId = belongDrId; /*进路所属动态进路ID*/
	}
	else
	{
		/*不做处理*/
	}
}
/*
* 功能描述： 获取指定ID进路第一个锁闭的逻辑区段延时设置区段故障起始周期号
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 锁闭起始周期号
*/
UINT32 GetRouFirstElockStaCycNum(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT32 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标,错误返回MAX，返回值>0*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		retVal = RouteDataStru[bufIndex].dwFirstElockStartCycNum;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}
/*
* 功能描述：设置指定ID进路第一个锁闭的逻辑区段延时设置区段故障起始周期号
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT32 startCycNum, 起始周期号
* 返回值  ： 0: 设置数据失败
*           >0: 设置数据成功
*/
UINT8 SetRouFirstElockStaCycNum(const UINT16 routeId, const UINT32 startCycNum)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标,错误返回MAX，返回值>0*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		RouteDataStru[bufIndex].dwFirstElockStartCycNum = startCycNum;
		retVal = CI_SUCCESS;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 获取进路接近区段是否有可疑列车
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： CI_ERROR 接近区段有可疑列车
*			 CI_SUCCESS 接近区段无可疑列车
* edit cgh 20241128
*/
UINT8 GetRouteSuspiciousInNearSec(const UINT16 routeId)
{
	UINT8 wRetVal = CI_ERROR;		/*返回值*/
	UINT16 wLogSecId = 0u;
	UINT8 logSecIndex = 0u;
	UINT8 logSecBelongCiId = 0U;
	UINT8 ii = 0U;
	UINT8 jj = 0U;
	UINT8 localCiId = 0U;
	UINT8 funcRet = 0U;
	UINT8 cTrainRunDir = 0u;
	UINT8 nearCbtcSecConditionSum = 0u;	/*CBTC接近区段条件数量*/
	RouteNearLogicSectionStruct* nearLogicSecStru = NULL;	/*接近逻辑区段结构数组*/
	UINT8 chRouteNearSecSearchState = ROUTE_NEAR_SEC_HAVE_UT;/*进路接近区段查询状态为有故障车*/

	/* 获取接近区段上最近的占压逻辑区段 */
	localCiId = GetSystemParaLocalCiId();
	nearCbtcSecConditionSum = GetRouteCbtcNearSecConditionSum(routeId);	/*获取CBTC进路接近逻辑区段条件数目*/
	nearLogicSecStru = GetRouteCbtcNearLogSectionStru(routeId);	/*获取CBTC进路接近逻辑区段结构体*/

	if ((0u < nearCbtcSecConditionSum)
		&& (ROUTE_NEARSEC_CONDITION_SUM_MAX >= nearCbtcSecConditionSum)
		&& (NULL != nearLogicSecStru))
	{/*具有多组接近区段*/

		for (ii = 0U; ii < nearCbtcSecConditionSum; ii++)
		{
			funcRet = GetRouteNearSecFitSwIndex(routeId, ii);

			if (CI_SUCCESS == funcRet)
			{
				/*当前接近区段符合道岔位置，退出循环*/
				break;
			}
		}

		/*具备一个完全符合道岔位置的接近区段*/
		if ((ii != nearCbtcSecConditionSum)
			&&(0U!=nearLogicSecStru[ii].NearLogicSecSum))
		{
			/*遍历该接近区段所有逻辑区段*/
			for (logSecIndex =0U; logSecIndex<nearLogicSecStru[ii].NearLogicSecSum; logSecIndex++)
			{
				wLogSecId = nearLogicSecStru[ii].NearLogicSecIdBuf[logSecIndex];

				funcRet = GetLogicSupicTrainStat(wLogSecId); /*获取是否具备可疑车*/
				logSecBelongCiId = GetLogSecBelongCiId(wLogSecId);

				if ((CI_SUCCESS == funcRet)
					&&(localCiId== logSecBelongCiId)&&(0U!=localCiId))
				{
					wRetVal = CI_SUCCESS;
				}
				else
				{
					if ((localCiId != logSecBelongCiId) && (0U != localCiId))
					{

						AddCiSendToCiCmdInfo((UINT8)CI_CMD_ROUTE_NEAR_STATE_SEARCH, routeId, 0U, logSecBelongCiId);
						chRouteNearSecSearchState = GetRouteNearSecSearchState(routeId);
						if (ROUTE_NEAR_SEC_NOT_HAVE_UT == chRouteNearSecSearchState)
						{
							/*无故障车回收资源*/
							wRetVal = CI_SUCCESS;
						}
						else
						{
							wRetVal = CI_ERROR; /*有故障车不回收资源*/
						}
					}
					else
					{
						wRetVal = CI_ERROR;
					}
					break;
				}
			}

		}
		else
		{
			/*没有符合位置的*/
			wRetVal = CI_ERROR;
		}
	}
	else
	{
		/*入参检查失败*/
		wRetVal = CI_ERROR;
	}
	
	return wRetVal;

}
	
/*
* 功能描述： 获取进路接近区段符合道岔位置
* 参数说明： const UINT16 nearSecIndex,接近区段下标
* 返回值  ： CI_ERROR 不符合道岔位置
*			 CI_SUCCESS 符合道岔位置
*/
UINT8 GetRouteNearSecFitSwIndex(const UINT16 routeId,const UINT8 nearSecIndex)
{
	UINT8 retVal = CI_ERROR;		/*返回值*/
	UINT16 wLogSecId = 0u;
	UINT8 cLinkIndex = 0u;
	UINT16 switchId = 0U;
	UINT8 switchPos = 0U;
	UINT8 switchCurPosition = 0U;
	UINT8 ii = 0U;
	UINT8 jj = 0U;
	UINT8 funcRet = 0U;
	UINT8 nearCbtcSecConditionSum = 0u;	/*CBTC接近区段条件数量*/
	RouteNearLogicSectionStruct* nearLogicSecStru = NULL;	/*接近逻辑区段结构数组*/



	/* 获取接近区段上最近的占压逻辑区段 */

	nearCbtcSecConditionSum = GetRouteCbtcNearSecConditionSum(routeId);	/*获取CBTC进路接近逻辑区段条件数目*/
	nearLogicSecStru = GetRouteCbtcNearLogSectionStru(routeId);	/*获取CBTC进路接近逻辑区段结构体*/

	if ((0u < nearCbtcSecConditionSum)
		&& (ROUTE_NEARSEC_CONDITION_SUM_MAX >= nearCbtcSecConditionSum)
		&& (NULL != nearLogicSecStru)
		&&(nearSecIndex<nearCbtcSecConditionSum))
	{/*具有多组接近区段*/

		/*无道岔置成功*/
		retVal = CI_SUCCESS;

		for (ii = 0u; ii < nearLogicSecStru[nearSecIndex].SwitchSum; ii++)
		{
			switchId = nearLogicSecStru[nearSecIndex].ConditionSwitchStru[ii].SwitchId;
			switchPos = nearLogicSecStru[nearSecIndex].ConditionSwitchStru[ii].SwitchPosition;

			switchCurPosition = GetSwitchCurPosition(switchId);


			if (((SWITCH_POSITION_DINGWEI == switchPos) ||
				(SWITCH_POSITION_FANWEI == switchPos))
				&& (switchPos == switchCurPosition))
			{/*规定位置*/
				
			}
			else
			{
				retVal = CI_ERROR;
				break;
			}

		}/*遍历道岔数据*/

		
	}/*有岔区段*/
	else
	{
		retVal = CI_ERROR;
	}
	
	return retVal;
}
	
/*
* 功能描述：删除进路内列车资源
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT16 trainId, 列车ID
* 返回值  ：无
*/
void RemoveRouteInCiRes(const UINT16 routeId,const UINT16 trainId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 jj = 0U;
	UINT16 wRouteInLgcSecSum = 0U;
	UINT16 *pRouteInLgcSecBuf = NULL;

	wRouteInLgcSecSum = GetRouteLogSectionSum(routeId);
	pRouteInLgcSecBuf = GetRouteLogSectionIdBuf(routeId);
	if (0U != wRouteInLgcSecSum)
	{
		for (jj = 0U; jj < wRouteInLgcSecSum; jj++)
		{
			RemoveLogSecTrainInfoById(pRouteInLgcSecBuf[jj], trainId);
		}
	}
}

/*
* 功能描述： 设置指定进路资源取消申请的延时标志
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT32 delayflag, 资源取消申请延时标志
* 返回值  ： 无
*
*/
void SetRouteResCancelDelayFlag(const UINT16 routeId, const UINT8 delayflag)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (bufIndex < ROUTE_SUM_MAX)
	{
		if ((RUUTE_RESCANCEL_DELAY_YES == delayflag) || (RUUTE_RESCANCEL_DELAY_NO == delayflag))
		{
			RouteDataStru[bufIndex].CancelResDelayflag = delayflag;
		}
		else
		{
			/*不做处理*/
		}
	}
	else
	{
		/*不做处理*/
	}
}


/*
* 功能描述： 获取指定进路资源取消申请的延时标志
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 进路的资源取消申请延时标志
*/
UINT8 GetRouteResCancelDelayFlag(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标,错误返回MAX，返回值>0*/
	if (ROUTE_SUM_MAX > bufIndex)
	{
		retVal = RouteDataStru[bufIndex].CancelResDelayflag;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述：设置指定进路声光报警延时开放起始周期号
* 参数说明：const UINT16 routeId, 进路ID
*           const UINT32 dwCyc 周期号
* 返回值  ：无
*/
void SetRouteDelayOpenStartCyc(const UINT16 routeId, const UINT32 dwCyc)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标,错误返回MAX，返回值>0*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		RouteDataStru[bufIndex].dwDelayOpenStartCycNum = dwCyc;
	}
	else
	{
		/*不做处理*/
	}
}

/*
* 功能描述： 获取指定进路声光报警延时开放起始周期号
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 延时开放起始周期号
*/
UINT32 GetRouteDelayOpenStartCyc(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT32 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标,错误返回MAX，返回值>0*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		retVal = RouteDataStru[bufIndex].dwDelayOpenStartCycNum;
	}
	else
	{
		retVal = CI_ERROR;
	}

	return retVal;
}

/*
* 功能描述：设置进路需要驱动声光报警标志
* 参数说明：UINT16 routeId 需设置的进路ID
*           UINT8 setFlag  需设置标志
* 返回值  ：无
*/
void SetRouteDriveSGBJFlag(UINT16 routeId, UINT8 setFlag)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		if ((ROUTE_DRIVE_SGBJ_VALID == setFlag) || (ROUTE_DRIVE_SGBJ_INVALID == setFlag))
		{
			RouteDataStru[bufIndex].cRouteNeedDriveSGBJFlag = setFlag;   /*设置声光报警标志*/
		}
		else
		{
			/*不处理*/
		}
	}
	else
	{
		/*不处理*/
	}
}

/*
* 功能描述： 获取指定进路需要驱动声光报警标志
* 参数说明： const UINT16 routeId 进路ID
* 返回值  ： >0 声光报警标志
*             0 获取失败
*/
UINT8 GetRouteDriveSGBJFlag(const UINT16 routeId)
{
	UINT16 bufIndex = 0;  /*数组下标*/
	UINT8 reVal = 0u;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标,错误返回MAX，返回值>0*/
	if (ROUTE_SUM_MAX > bufIndex)
	{
		reVal = RouteDataStru[bufIndex].cRouteNeedDriveSGBJFlag;
	}
	else
	{
		/*不做处理*/
	}
	return reVal;
}

/*
* 功能描述：设置指定进路关联组合进路声光报警延时标志
* 参数说明：UINT16 routeId 需设置的进路ID
*           UINT8 setFlag  需设置标志
* 返回值  ：无
*/
void SetRelZuHeRouteSGBJDelayFlag(UINT16 routeId, UINT8 setFlag)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		if ((ROUTE_SGBJ_DELAY_OPEN_VALID == setFlag) || (ROUTE_SGBJ_DELAY_OPEN_INVALID == setFlag))
		{
			RouteDataStru[bufIndex].cRelZuHeRouteSGBJDelayFlag = setFlag;   /*设置声光报警延时标志*/
		}
		else
		{
			/*不处理*/
		}
	}
	else
	{
		/*不处理*/
	}
}

/*
* 功能描述： 获取指定进路关联组合进路声光报警延时标志
* 参数说明： const UINT16 routeId 进路ID
* 返回值  ： >0 声光报警延时标志
*             0 获取失败
*/
UINT8 GetRelZuHeRouteSGBJDelayFlag(const UINT16 routeId)
{
	UINT16 bufIndex = 0;  /*数组下标*/
	UINT8 reVal = 0u;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标,错误返回MAX，返回值>0*/
	if (ROUTE_SUM_MAX > bufIndex)
	{
		reVal = RouteDataStru[bufIndex].cRelZuHeRouteSGBJDelayFlag;
	}
	else
	{
		/*不做处理*/
	}
	return reVal;
}


/* 功能描述： 检查进路是否处于已办理状态（车库门关门防护使用）
*  参数说明： const UINT16 routeId    进路ID
*  返回值：  CI_ERROR，入参失败
*					ROUTE_TRANSACT_YES      进路已办理
*					ROUTE_TRANSACT_NO        进路未办理
*/

UINT8 CheckRouteTransactState(const UINT16 routeId)
{
	UINT8 retVal = CI_ERROR;
	UINT8 routeState = 0U;
	UINT16 lastPhyLockId = 0U;  /*进路最后一个物理区段ID*/
	UINT8 lastPhyLockState = 0U;  /*最后一个物理区段锁闭状态*/

	routeState = GetRouteState(routeId);  /*获取进路状态*/
	lastPhyLockId = GetRouteLastPhySectionId(routeId);
	lastPhyLockState = GetPhySecLockState(lastPhyLockId);

	if ((0U != routeId) && (ROUTE_SUM_MAX > routeId))
	{
		if (((ROUTE_STATE_IDLE != routeState)
			&& (ROUTE_STATE_FIRST_XUANPAI != routeState)
			&& (ROUTE_STATE_XUANPAI != routeState)
			&& (ROUTE_STATE_LEAD_FIRST_XUANPAI != routeState)
			&& (ROUTE_STATE_LEAD_XUANPAI != routeState)
			&& (ROUTE_STATE_LEAD_LOCK != routeState)
			&& (ROUTE_STATE_LEAD_LOCKERR != routeState)
			&& (ROUTE_STATE_LEAD_OPEN != routeState))
			|| (((ROUTE_STATE_FIRST_XUANPAI == routeState) || (ROUTE_STATE_XUANPAI == routeState))
				&& ((PHYSICAL_SECTION_LOCK_NORMAL == lastPhyLockState) ||
					(PHYSICAL_SECTION_LOCK_DELAY == lastPhyLockState) ||
					(PHYSICAL_SECTION_LOCK_FAULTDELAY == lastPhyLockState))))

		{/*当进路状态为预选或选排且最后一个区段为锁闭状态则仍判断为已办理状态*/
			retVal = ROUTE_TRANSACT_YES;
		}
		else
		{
			retVal = ROUTE_TRANSACT_NO;
		}
	}
	else
	{
		/*返回检查失败*/
	}
	return retVal;
}


/* 功能描述： 获取进路内的的CT占压逻辑区段（存在UT占压返回失败）
*  参数说明： const UINT16 garageDoorId   车库门
*            logSecId[MAX_ROUTE_IN_LT_NUM]   逻辑区段ID
*            UINT8 logSecNum   逻辑区段数量
*  返回值：  CI_ERROR，查询失败,logSecId[0U]返回UT占压的逻辑区段
*           CI_SUCCESS 查询成功
*/
UINT8 GetCTLogSecOfRoute(const UINT16 routeId, OUT UINT16 logSecId[MAX_ROUTE_IN_LT_NUM], OUT UINT8 logSecNum)
{
	UINT8 retVal = CI_ERROR;
	UINT8 i = 0U;
	UINT16* logSecinRouteIdbuff = NULL;  /*逻辑区段数据*/
	UINT16 logSecRouteNum = 0U;    /*逻辑区段数目*/
	UINT8 tmplogState = 0U;      /*逻辑区段占压状态*/
	UINT8 wlogSecCount = 0U;


	logSecRouteNum = GetRouteLogSectionSum(routeId); /*获得进路包含的逻辑区段数目*/
	logSecinRouteIdbuff = GetRouteLogSectionIdBuf(routeId); /*进路逻辑区段数据*/
	if (0U < logSecRouteNum)
	{
		retVal = CI_SUCCESS;
		/*从进路终端向前查找被占压的逻辑区段*/
		for (i = 0U; i < logSecRouteNum; i++)
		{
			tmplogState = GetLogSecCurCtOrUtOccupyState(logSecinRouteIdbuff[i]);
			if (LOGICSECTION_OCCUPY_NO == tmplogState)
			{
				/*检查下一个*/
			}
			else if (LOGICSECTION_OCCUPY_CT == tmplogState)
			{
				logSecId[wlogSecCount] = logSecinRouteIdbuff[i];
				wlogSecCount++;
			}
			else
			{
				/*UT占用，检查失败*/
				logSecId[0U] = logSecinRouteIdbuff[i];
				retVal = CI_ERROR;
				break;
			}

		}
	}
	logSecNum = wlogSecCount;
	return retVal;
}

/*
* 功能描述： 获取指定ID进路之前监督级别
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 进路之前监督级别
*/
UINT8 GetRoutePreLevel(const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (bufIndex < ROUTE_SUM_MAX)
	{
		retVal = RouteDataStru[bufIndex].RoutePreLevel;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述：设置进路驱动过声光报警标志
* 参数说明：UINT16 routeId 需设置的进路ID
*           UINT8 setFlag  需设置标志
* 返 回 值：无
* Created By LQ 2024.08.19
*/
void SetRouteHasDrivedSGBJFlag(UINT16 routeId, UINT8 setFlag)
{
	UINT16 bufIndex = 0U;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		if ((ROUTE_HAS_DRIVED_SGBJ_VALID == setFlag) || (ROUTE_HAS_DRIVED_SGBJ_INVALID == setFlag))
		{
			RouteDataStru[bufIndex].cRouteDrivedSGBJFlag = setFlag;   /*设置进路驱动过声光报警标志*/
		}
		else
		{
			/*不处理*/
		}
	}
	else
	{
		/*不处理*/
	}
}

/*
* 功能描述： 获取指定进路需要驱动声光报警标志
* 参数说明： const UINT16 routeId 进路ID
* 返 回 值： 0x55 未驱动过
*            0xAA 驱动过
* Created By LQ 2024.08.19
*/
UINT8 GetRouteHasDrivedSGBJFlag(const UINT16 routeId)
{
	UINT16 bufIndex = 0U;  /*数组下标*/
	UINT8 reVal = ROUTE_HAS_DRIVED_SGBJ_INVALID;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/
	if (ROUTE_SUM_MAX > bufIndex)
	{
		reVal = RouteDataStru[bufIndex].cRouteDrivedSGBJFlag;
	}
	else
	{
		/*不做处理*/
	}

	return reVal;
}

/*
* 功能描述：设置进路接近区段状态查询结果
* 参数说明：UINT16 routeId 需设置的进路ID
*           UINT8 setFlag  需设置标志
* 返 回 值：无
* by cgh 20241128
*/
void SetRouteNearSecSearchState(UINT16 routeId, UINT8 setFlag)
{
	UINT16 bufIndex = 0U;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		if ((ROUTE_NEAR_SEC_HAVE_UT == setFlag) || (ROUTE_NEAR_SEC_NOT_HAVE_UT == setFlag))
		{
			RouteDataStru[bufIndex].chRouteNearSecSearchState = setFlag;
		}
		else
		{
			/*不处理*/
		}
	}
	else
	{
		/*不处理*/
	}
}

/*
* 功能描述： 获取指定进路接近区段状态查询结果
* 参数说明： const UINT16 routeId 进路ID
* 返 回 值： ROUTE_NEAR_SEC_HAVE_UT 接近区段有故障车
*	         ROUTE_NEAR_SEC_NOT_HAVE_UT 接近区段无故障车
* by cgh 20241128
*/
UINT8 GetRouteNearSecSearchState(const UINT16 routeId)
{
	UINT16 bufIndex = 0U;  /*数组下标*/
	UINT8 reVal = ROUTE_NEAR_SEC_HAVE_UT;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		reVal = RouteDataStru[bufIndex].chRouteNearSecSearchState;
	}
	else
	{
		/*不做处理*/
	}

	return reVal;
}

/*
* 功能描述： 获取进路其他控区接近区段是否有可疑列车
* 参数说明： const UINT16 routeId, 进路ID
*            UINT8* chOtherCiId 其它联锁ID
* 返回值  ： CI_ERROR 接近区段有可疑列车
*			 CI_SUCCESS 接近区段无可疑列车
* edit cgh 20241128
*/
UINT8 GetRouteOtherCiNearSecState(const UINT16 routeId)
{
	UINT8 wRetVal = CI_ERROR;
	UINT16 wLogSecId = 0U;
	UINT8 logSecIndex = 0u;
	UINT8 logSecBelongCiId = 0U;
	UINT8 ii = 0U;
	UINT8 localCiId = 0U;
	UINT8 funcRet = CI_ERROR;
	UINT8 nearCbtcSecConditionSum = 0u;	/*CBTC接近区段条件数量*/
	RouteNearLogicSectionStruct* nearLogicSecStru = NULL;	/*接近逻辑区段结构数组*/


	/* 获取接近区段上最近的占压逻辑区段 */
	localCiId = GetSystemParaLocalCiId();
	nearCbtcSecConditionSum = GetRouteCbtcNearSecConditionSum(routeId);	/*获取CBTC进路接近逻辑区段条件数目*/
	nearLogicSecStru = GetRouteCbtcNearLogSectionStru(routeId);	/*获取CBTC进路接近逻辑区段结构体*/

	if ((0u < nearCbtcSecConditionSum)
		&& (ROUTE_NEARSEC_CONDITION_SUM_MAX >= nearCbtcSecConditionSum)
		&& (NULL != nearLogicSecStru))
	{/*具有多组接近区段*/

		for (ii = 0U; ii < nearCbtcSecConditionSum; ii++)
		{
			funcRet = GetRouteNearSecFitSwIndex(routeId, ii);

			if (CI_SUCCESS == funcRet)
			{
				/*当前接近区段符合道岔位置，退出循环*/
				break;
			}
			else
			{
				;/*继续查找*/
			}
		}

		/*具备一个完全符合道岔位置的接近区段*/
		if ((ii != nearCbtcSecConditionSum)
			&& (0U != nearLogicSecStru[ii].NearLogicSecSum))
		{
			wRetVal = CI_SUCCESS;
			/*遍历该接近区段所有逻辑区段*/
			for (logSecIndex = 0U; logSecIndex < nearLogicSecStru[ii].NearLogicSecSum; logSecIndex++)
			{
				wLogSecId = nearLogicSecStru[ii].NearLogicSecIdBuf[logSecIndex];
				logSecBelongCiId = GetLogSecBelongCiId(wLogSecId);

				if ((localCiId == logSecBelongCiId) && (0U != localCiId))
				{
					funcRet = GetLogicSupicTrainStat(wLogSecId); /*获取是否具备可疑车*/
					if (CI_ERROR == funcRet)
					{
						/*有可疑车，退出*/
						wRetVal = CI_ERROR;
						break;
					}
					else
					{
						; /*继续找*/
					}
				}
				else
				{
					; /*不属于本联锁不检查*/
				}
			}

		}
		else
		{

			/*没有符合位置的*/
			wRetVal = CI_ERROR;
		}
	}
	else
	{
		wRetVal = CI_ERROR;
	}

	return wRetVal;
}

/*
* 功能描述：设置指定进路办理相邻控区道岔检查标志
* 参数说明：UINT16 routeId 需设置的进路ID
*           UINT8 setFlag  需设置标志
* 返 回 值：无
* by cgh 20241202
*/
void SetRouteApplySwitchCheckFlag(UINT16 routeId, UINT8 setFlag)
{
	UINT16 bufIndex = 0U;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		if ((ROUTE_APPLY_SWITCH_CHECK_NO == setFlag) || (ROUTE_APPLY_SWITCH_CHECK_YES == setFlag)
			|| (ROUTE_APPLY_SWITCH_CHECK_DEF == setFlag))
		{
			RouteDataStru[bufIndex].chRouteApplySwitchCheckFlag = setFlag;
			if (ROUTE_APPLY_SWITCH_CHECK_DEF == setFlag)
			{
				/*清零相邻联锁记录进路错误*/
				SetRouteApplySwitchCheckErrorData(routeId, 0U, 0U, 0U, 0U);
			}
			else
			{
				;/*不处理*/
			}
		}
		else
		{
			; /*不处理*/
		}
	}
	else
	{
		; /*不处理*/
	}
}

/*
* 功能描述： 获取指定进路办理相邻控区道岔检查标志
* 参数说明： const UINT16 routeId 进路ID
* 返 回 值： 进路办理相邻控区道岔检查标志
* by cgh 20241202
*/
UINT8 GetRouteApplySwitchCheckFlag(const UINT16 routeId)
{
	UINT16 bufIndex = 0U;  /*数组下标*/
	UINT8 reVal = ROUTE_APPLY_SWITCH_CHECK_NO;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		reVal = RouteDataStru[bufIndex].chRouteApplySwitchCheckFlag;
	}
	else
	{
		; /*不做处理*/
	}

	return reVal;
}

/*
* 功能描述： 设置指定进路的调车同意按钮故障状态
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT8 chDcAgreeButtonErrState, 调车同意按钮故障状态
* 返回值  ：无
* by cgh 20250523
*/
void SetRouteDcAgreeButtonErrState(const UINT16 routeId, const UINT8 chDcAgreeButtonErrState)
{
	UINT16 bufIndex = 0U;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		if ((ROUTE_DC_AGREE_BUTTON_ERR == chDcAgreeButtonErrState) || (ROUTE_DC_AGREE_BUTTON_OK == chDcAgreeButtonErrState))
		{
			RouteDataStru[bufIndex].chDcAgreeButtonErrState = chDcAgreeButtonErrState;

		}
		else
		{
			;
		}
	}
	else
	{
		;
	}
}

/*
* 功能描述： 获取指定进路的调车同意按钮故障状态
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 调车同意按钮故障状态
* by cgh 20250523
*/
UINT8 GetRouteDcAgreeButtonErrState(const UINT16 routeId)
{
	UINT16 bufIndex = 0U;  /*数组下标*/
	UINT8 retVal = ROUTE_DC_AGREE_BUTTON_ERR;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		retVal = RouteDataStru[bufIndex].chDcAgreeButtonErrState;
	}
	else
	{
		;
	}
	return retVal;
}

/*
* 功能描述： 设置指定进路的调车同意按钮按下起始周期
* 参数说明： const UINT16 routeId, 进路ID
*            const UINT32 dwDcAgreeBtnPressCycNum, 调车同意按钮按下起始周期
* 返回值  ：无
* by cgh 20250523
*/
void SetRouteDcAgreeBtnPressCycNum(const UINT16 routeId, const UINT32 dwDcAgreeBtnPressCycNum)
{
	UINT16 bufIndex = 0U;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		RouteDataStru[bufIndex].dwDcAgreeBtnPressCycNum = dwDcAgreeBtnPressCycNum;
	}
	else
	{
		;
	}
}

/*
* 功能描述： 获取指定进路的调车同意按钮按下起始周期
* 参数说明： const UINT16 routeId, 进路ID
* 返回值  ： 调车同意按钮按下起始周期
* by cgh 20250523
*/
UINT32 GetRouteDcAgreeBtnPressCycNum(const UINT16 routeId)
{
	UINT16 bufIndex = 0U;  /*数组下标*/
	UINT32 retVal = 0U;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		retVal = RouteDataStru[bufIndex].dwDcAgreeBtnPressCycNum;
	}
	else
	{
		;
	}
	return retVal;
}

/*
* 功能描述：设置指定进路转引导进路标志
* 参数说明：UINT16 routeId 需设置的进路ID
*           UINT8 setFlag  需设置标志
* 返 回 值：无
* Created By LQ 2025.08.04
*/
void SetRouteToLeadFlag(UINT16 routeId, UINT8 setFlag)
{
	UINT16 bufIndex = 0U;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		if ((ROUTE_TO_LEAD_FLAG_NO == setFlag) || (ROUTE_TO_LEAD_FLAG_YES == setFlag))
		{
			RouteDataStru[bufIndex].cRouteToLeadFlag = setFlag;
		}
		else
		{
			; /*不处理*/
		}
	}
	else
	{
		; /*不处理*/
	}
}

/*
* 功能描述：获取指定进路转引导进路标志
* 参数说明：const UINT16 routeId 进路ID
* 返 回 值：0x55 无效
*           0xAA 有效
* Created By LQ 2025.08.04
*/
UINT8 GetRouteToLeadFlag(const UINT16 routeId)
{
	UINT16 bufIndex = 0U;  /*数组下标*/
	UINT8 reVal = ROUTE_TO_LEAD_FLAG_NO;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		reVal = RouteDataStru[bufIndex].cRouteToLeadFlag;
	}
	else
	{
		; /*不做处理*/
	}

	return reVal;
}

/*
* 功能描述：设置指定进路办理相邻控区检查错误记录
* 参数说明：UINT16 routeId 需设置的进路ID
*           UINT16 devID  设备ID UINT8 devType 设备类型，UINT8 devState 设备状态 UINT8 errorType
* 返 回 值：无
* by fan 20250922
*/
void SetRouteApplySwitchCheckErrorData(UINT16 routeId, UINT16 devID, UINT8 devType, UINT8 devState, UINT8 errorType)
{
	UINT16 bufIndex = 0U;  /*数组下标*/

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		RouteDataStru[bufIndex].OtherCiRecordDevID = devID;
		RouteDataStru[bufIndex].OtherCiRecordDevState = devState;
		RouteDataStru[bufIndex].OtherCiRecordDevType = devType;
		RouteDataStru[bufIndex].OtherCiRecordErrorType = errorType;
	}
	else
	{
		; /*不处理*/
	}
}

/*
* 功能描述：获取指定进路办理相邻控区检查错误记录
* 参数说明：UINT16 routeId 进路ID
* 返 回 值：UINT16 设备ID
* 输出参数 UINT8 *devType设备类型, UINT8* devState设备状态，UINT8* errorType 错误类型
* by fan 20250922
*/
UINT16 GetRouteApplySwitchCheckErrorData(UINT16 routeId, UINT8 *devType, UINT8* devState, UINT8* errorType)
{
	UINT16 bufIndex = 0U;  /*数组下标*/
	UINT16 rtnDevId = 0U;

	bufIndex = GetRouteConfigBufIndex(routeId);  /*获取进路数组下标*/

	if (ROUTE_SUM_MAX > bufIndex)
	{
		rtnDevId = RouteDataStru[bufIndex].OtherCiRecordDevID;
		*devType = RouteDataStru[bufIndex].OtherCiRecordDevType;
		*devState = RouteDataStru[bufIndex].OtherCiRecordDevState;
		*errorType = RouteDataStru[bufIndex].OtherCiRecordErrorType;
	}
	else
	{
		; /*不处理*/
	}
	return rtnDevId;
}