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

#include "PSDDataManage.h"
#include "../ParsePack/ParsePackDefine.h"

PsdDataStruct PsdDataStru[PSD_SUM_MAX];   /*定义屏蔽门数据结构体*/

/*
* 功能描述： 获取指定ID屏蔽门数据
* 参数说明： 
* 返回值  ： PsdDataStruct *
*/
PsdDataStruct *GetPsdData(void)
{
    return PsdDataStru;
}

/*
* 功能描述： 获取指定ID屏蔽门互锁解除状态
* 参数说明： const UINT16 doorId, 屏蔽门ID    
* 返回值  ： 0: 获取数据失败
*			>0: 互锁解除状态      
*/
UINT8 GetPsdMutualLockRemoveState(const UINT16 doorId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		retVal = PsdDataStru[bufIndex].MutualLockRemoveState;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}


/*
* 功能描述： 设置指定ID屏蔽门互锁解除状态
* 参数说明： const UINT16 doorId, 屏蔽门ID  
*			 const UINT8 mutualLockState, 互锁解除状态
* 返回值  ： 0: 设置失败
*			 1: 设置成功      
*/
UINT8 SetPsdMutualLockRemoveState(const UINT16 doorId, const UINT8 mutualLockState)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		if ((PSD_MUTUALLOCK_REMOVE_NO == mutualLockState) || (PSD_MUTUALLOCK_REMOVE_YES == mutualLockState)
			|| (PSD_ATS_MUTUALLOCK_REMOVE_YES == mutualLockState) || (PSD_ATS_AND_JD_MUTUALLOCK_REMOVE_YES == mutualLockState))
		{
			PsdDataStru[bufIndex].MutualLockRemoveState = mutualLockState;  /*屏蔽门互锁解除状态*/

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


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

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取道岔数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		retVal = PsdDataStru[bufIndex].PsdState;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}


/*
* 功能描述： 设置指定ID屏蔽门状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
*			 const UINT8 doorState, 屏蔽门状态
* 返回值  ： 0: 设置失败
*			 1: 设置成功      
*/
UINT8 SetPsdState(const UINT16 doorId, const UINT8 doorState)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		if ((PSD_STATE_CLOSE == doorState) || (PSD_STATE_OPEN == doorState))
		{
			PsdDataStru[bufIndex].PsdState = doorState;  /*屏蔽门状态*/

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

/*
* 功能描述： 获取指定ID屏蔽门按钮状态
* 参数说明： const UINT16 doorId, 屏蔽门ID    
* 返回值  ： 0: 获取数据失败
*			>0: 屏蔽门按钮状态      
*/
UINT8 GetPsdButtonState(const UINT16 doorId)
{
	UINT16 bufIndex = 0u;                      /*数组下标*/
	UINT8 retVal = 0u;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		retVal = PsdDataStru[bufIndex].DoorButtonState;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 设置指定ID屏蔽门按钮状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
*			 const UINT8 buttonState, 屏蔽门按钮状态
* 返回值  ： 0: 设置失败
*			 1: 设置成功      
*/
UINT8 SetPsdButtonState(const UINT16 doorId, const UINT8 buttonState)
{
	UINT16 bufIndex = 0u;                      /*数组下标*/
	UINT8 retVal = 0u;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		if ((PSD_BUTTON_STATE_DOWN == buttonState) || (PSD_BUTTON_STATE_UP == buttonState))
		{
			PsdDataStru[bufIndex].DoorButtonState = buttonState;  /*站台按钮状态*/

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

}

/*
* 功能描述： 获取指定ID屏蔽门驱动状态
* 参数说明： const UINT16 doorId, 屏蔽门ID    
* 返回值  ： 0: 获取数据失败
*			>0: 屏蔽门驱动状态      
*/
UINT8 GetPsdDriveState(const UINT16 doorId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		retVal = PsdDataStru[bufIndex].PsdDriveState;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}


/*
* 功能描述： 设置指定ID屏蔽门驱动状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
*			 const UINT8 doorDriveState, 屏蔽门驱动状态
* 返回值  ： 无
*			       
*/
void SetPsdDriveState(const UINT16 doorId, const UINT8 doorDriveState)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		if ((PSD_DRIVE_STATE_CLOSE == doorDriveState) || (PSD_DRIVE_STATE_OPEN == doorDriveState) || (PSD_DRIVE_STATE_INVALID == doorDriveState))
		{
			PsdDataStru[bufIndex].PsdDriveState = doorDriveState;  /*屏蔽门驱动状态*/
		}
		else
		{
			/*不做处理*/
		}
	}
	else
	{
		/*不做处理*/
	}
}

#if 0
/*
* 功能描述： 获取指定ID屏蔽门状态转移标志
* 参数说明： const UINT16 doorId, 屏蔽门ID    
* 返回值  ： 0: 获取数据失败
*			>0: 屏蔽门状态转移标志     
*/
UINT8 GetPsdStateTransferFlag(const UINT16 doorId)
{
	UINT16 bufIndex = 0u;  					  /*数组下标*/
	UINT8 retVal = 0u;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		retVal = PsdDataStru[bufIndex].PsdStateTransferFlag;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;

}
#endif

#if 0
/*
* 功能描述： 设置指定ID屏蔽门状态转移标志
* 参数说明： const UINT16 doorId, 屏蔽门ID
*			 const UINT8 PsdStateTransferFlag, 状态转移标志
* 返回值  ： 0: 设置失败
*			 1: 设置成功      
*/
UINT8 SetPsdStateTransferFlag(const UINT16 doorId, const UINT8 PsdStateTransferFlag)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = 0u;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		if ((PSD_INITIAL_STATE == PsdStateTransferFlag) || 
			(PSD_OPEN_CMD == PsdStateTransferFlag)      || 
			(PSD_OPEN_STATE == PsdStateTransferFlag)    ||
			(PSD_CLOSE_CMD == PsdStateTransferFlag)     ||
			(PSD_CLOSE_STATE== PsdStateTransferFlag)    
		   )
		{
			PsdDataStru[bufIndex].PsdStateTransferFlag = PsdStateTransferFlag;  /*屏蔽门状态转移标志*/

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

}
#endif

#if 0
/*
* 功能描述： 获取指定ID屏蔽门对应的办理成功的进路数目  
* 参数说明： const UINT16 doorId, 屏蔽门ID    
* 返回值  ： 0: 获取数据失败
*			>0: 屏蔽门开放导致信号关闭的进路数目   
*/
UINT8 GetBuildedOutStationRouteSum(const UINT16 doorId)
{
	UINT16 bufIndex = 0u;  					  /*数组下标*/
	UINT8 retVal = 0u;	

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		retVal = PsdDataStru[bufIndex].BuildedOutStationRouteSum;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;

}

/*
* 功能描述： 设置指定ID屏蔽门对应的办理成功的进路数目
* 参数说明： const UINT16 doorId, 屏蔽门ID
*			 const UINT8 routeSum, 对应的办理成功的进路数目
* 返回值  ： 0: 设置失败
*			 1: 设置成功      
*/
UINT8 SetBuildedOutStationRouteSum(const UINT16 doorId,const UINT8 routeSum)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = 0u;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
	if (bufIndex < PSD_SUM_MAX)
	{
		PsdDataStru[bufIndex].BuildedOutStationRouteSum = routeSum;
		retVal = CI_SUCCESS;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;


}
#endif

#if 0
/*
* 功能描述： 获取指定ID屏蔽门对应的办理成功的进路Id数组
* 参数说明： const UINT16 doorId, 屏蔽门ID    
* 返回值  ： NULL: 获取数据失败
*			!NULL: 对应的办理成功的进路Id数组
*/
UINT16 * GetBuildedOutStationRouteIdBuf(const UINT16 doorId)
{
	UINT16 bufIndex = 0u;  					  /*数组下标*/
	UINT16 * retVal = NULL;	

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		retVal = PsdDataStru[bufIndex].BuildedOutStationRouteIdBuf;
	}
	else
	{
		retVal = NULL;
	}
	return retVal;

}


/*
* 功能描述： 获取出站进路信号关闭是否在指定ID屏蔽门打开之前的标志数组
* 参数说明： const UINT16 doorId, 屏蔽门ID    
* 返回值  ： NULL: 获取数据失败
*			!NULL: 出站进路信号关闭是否在指定ID屏蔽门打开之前的标志数组
*/
UINT8 * GetPsdOpenBeforeOutStationRouteIsBuildedFlagBuf(const UINT16 doorId)
{
	UINT16 bufIndex = 0u;  					  /*数组下标*/
	UINT8 * retVal = NULL;	

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		retVal = PsdDataStru[bufIndex].PsdOpenBeforeOutStationRouteIsBuildedFlagBuf;
	}
	else
	{
		retVal = NULL;
	}
	return retVal;

}
#endif 
/*
* 功能描述： 设置PSD的VOBC操作命令
* 参数说明： const UINT16 doorId,屏蔽门ID  
*			 const UINT16 vobcId,操作屏蔽门的VOBC ID
			 const UINT8 operCmd,来自VOBC的开关门命令
* 返回值  ： 无
*			   
*/
void SetPsdVobcCmd(const UINT16 doorId, const UINT16 vobcId,const UINT8 operCmd)
{
	UINT16 bufIndex = 0u;  /*数组下标*/


	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		if (PsdDataStru[bufIndex].SrcVobcId == vobcId)
		{
			PsdDataStru[bufIndex].PsdCmd=operCmd;
		}
		else
		{
			/*另一个VOBC开始操作该屏蔽门，对之前VOBC操作该屏蔽门产生的上下文进行复位*/
			PsdDataStru[bufIndex].SrcVobcId = vobcId;
			PsdDataStru[bufIndex].PsdCmd=operCmd;
			/*PsdDataStru[bufIndex].ClosedRouteId = 0;*/
			/*PsdDataStru[bufIndex].LastDriState=PSD_DRIVE_STATE_INVALID;*/
		}
		PsdDataStru[bufIndex].CmdSetCycle = Get2oo2CurCycleNum();
	}
	else
	{
		/*不做处理*/
	}
}

#if 0
/*
* 功能描述： 设置因该PSD打开而导致始端信号关闭的进路ID
* 参数说明： const UINT16 doorId,屏蔽门ID  
*			 const UINT16 routeId,因该PSD打开而导致始端信号关闭的进路ID
* 返回值  ： 0: 设置失败
*			 1: 设置成功 
*/
UINT8 SetPsdClosedRouteId(const UINT16 doorId,const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_SUCCESS;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		PsdDataStru[bufIndex].ClosedRouteId = routeId;
		retVal = CI_SUCCESS;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}
#endif

/*
* 功能描述： 置对应PSD状态为默认态
* 参数说明： const UINT16 psdId,PSD ID
* 返回值  ： 无
*			   
*/
void ResetPsdData(const UINT16 psdId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetPsdConfigBufIndex(psdId);  /*获取屏蔽门数组下标*/

	if (PSD_SUM_MAX > bufIndex)
	{
		/*PsdDataStru[bufIndex].SrcVobcId = 0;*/
		PsdDataStru[bufIndex].PsdCmd=PSD_DEFAULT_CONTROL_CMD;
		/*站台轨无车时不再清除PSD控制命令（含打开、关闭和查询）起始周期*/
		/*PsdDataStru[bufIndex].CmdSetCycle = 0;*/

		PsdDataStru[bufIndex].PsdDriveState=PSD_DRIVE_STATE_INVALID;
		PsdDataStru[bufIndex].PsdPreDriveState=PSD_DRIVE_STATE_INVALID;
	}
	else
	{
		/*不做处理*/
	}
}
#if 0
/*
* 功能描述： 获取因该PSD打开而导致始端信号关闭的进路ID
* 参数说明： const UINT16 doorId,屏蔽门ID  
* 返回值  ： 因该PSD打开而导致始端信号关闭的进路ID 
*/
UINT16 GetPsdClosedRouteId(const UINT16 doorId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT16 routeId=0u;
	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		routeId=PsdDataStru[bufIndex].ClosedRouteId;
	}
	else
	{
		routeId=0u;
	}
	return routeId;
}
#endif

/*
* 功能描述： 获得PSD的VOBC控制命令
* 参数说明： const UINT16 doorId,屏蔽门ID  
* 返回值  ： PSD的VOBC控制命令
*/
UINT8 GetPsdVobcCmd(const UINT16 doorId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 ctrlCmd;
	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		ctrlCmd=PsdDataStru[bufIndex].PsdCmd;
	}
	else
	{
		ctrlCmd=PSD_DEFAULT_CONTROL_CMD;
	}
	return ctrlCmd;
}
/*
* 功能描述： 获得当前控制该PSD的VOBC的ID
* 参数说明： const UINT16 doorId,屏蔽门ID  
* 返回值  ： 控制该PSD的VOBC的ID;如果没有控制该PSD的VOBC,返回0
*/
UINT16 GetPsdVobcId(const UINT16 doorId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT16 vobcId = 0u;
	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		vobcId=PsdDataStru[bufIndex].SrcVobcId;
	}
	else
	{
		vobcId=0u;
	}
	return vobcId;
}

#if 0
/*
* 功能描述： 设置PSD的上一次的驱动状态
* 参数说明： const UINT16 doorId,屏蔽门ID
			 const UINT8 driSta,该PSD的驱动状态
* 返回值  ： 0: 设置失败
*			 1: 设置成功 
*/
UINT8 SetPsdLastDriState(const UINT16 doorId,const UINT8 driSta)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal= CI_ERROR;
	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		if ((PSD_DRIVE_STATE_CLOSE == driSta) || (PSD_DRIVE_STATE_OPEN == driSta) || (PSD_DRIVE_STATE_INVALID == driSta))
		{
			PsdDataStru[bufIndex].LastDriState=driSta;
			retVal=CI_SUCCESS;
		}
		else
		{
			retVal=CI_ERROR;
		}
	}
	else
	{
		retVal=CI_ERROR;
	}
	return retVal;
}
/*
* 功能描述： 获得该PSD的上一次的驱动状态
* 参数说明： const UINT16 doorId,屏蔽门ID  
* 返回值  ： 该PSD的上一次的驱动状态
*/
UINT8 GetPsdLastDriState(const UINT16 doorId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 driSta=PSD_DRIVE_STATE_INVALID;
	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		driSta=PsdDataStru[bufIndex].LastDriState;
	}
	else
	{
		driSta=PSD_DRIVE_STATE_INVALID;
	}
	return driSta;
}
#endif

/*
* 功能描述： 获得该PSD的控制命令的设置周期
* 参数说明： const UINT16 doorId,屏蔽门ID 
* 返回值  ： 该PSD的控制命令的设置周期
*/
UINT32 GetPsdCmdSetCycle(const UINT16 doorId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT32 setCycle=0u;
	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		setCycle=PsdDataStru[bufIndex].CmdSetCycle;
	}
	else
	{
		setCycle=0u;
	}
	return setCycle;
}
/*
* 功能描述： 获取PSD的障碍物状态
* 参数说明： const UINT16 doorId,屏蔽门ID
			 
* 返回值  ： 0: 获取失败
*			 >0: 获取成功 
*/
UINT8 GetPsdRemoraState(const UINT16 doorId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		retVal = PsdDataStru[bufIndex].PsdRemoraState;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}
/*
* 功能描述： 设置PSD的障碍物状态
* 参数说明： const UINT16 doorId,屏蔽门ID
			 const UINT8 driSta,该PSD的障碍物状态
* 返回值  ： 0: 设置失败
*			 1: 设置成功 
*/
UINT8 SetPsdRemoraState(const UINT16 doorId, const UINT8 remoraState)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_SUCCESS;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		if ((PSD_REMORA_YES == remoraState) || (PSD_REMORA_NO == remoraState) )
		{
			PsdDataStru[bufIndex].PsdRemoraState = remoraState;  /*屏蔽门驱动状态*/

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

/*
* 功能描述： 获取PSD的间隙探测互锁解除状态
* 参数说明： const UINT16 doorId,屏蔽门ID
			 
* 返回值  ： 0: 获取失败
*			 >0: 获取成功 
*/
UINT8 GetJXTCMutualLockState(const UINT16 doorId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		retVal = PsdDataStru[bufIndex].JXTCMutualLockState;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}
/*
* 功能描述： 设置PSD的障碍物状态
* 参数说明： const UINT16 doorId,屏蔽门ID
			 const UINT8 mutualLockState,该间隙探测互锁解除状态
* 返回值  ： 0: 设置失败
*			 1: 设置成功 
*/
UINT8 SetJXTCMutualLockState(const UINT16 doorId, const UINT8 mutualLockState)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_SUCCESS;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		if ((JXTC_MUTUALLOCK_REMOVE_YES == mutualLockState) || (JXTC_MUTUALLOCK_REMOVE_NO == mutualLockState) )
		{
			PsdDataStru[bufIndex].JXTCMutualLockState = mutualLockState;  /*间隙探测互锁解除状态*/

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

/*
* 功能描述：设置指定PSD启动探测周期号
* 参数说明： const UINT16 doorId, 屏蔽门ID
*            const UINT32 startCycNum, 起始周期号
* 返回值  ： 无
*            
*/
void SetStartDetectionCycNum(const UINT16 doorId, const UINT32 startCycNum)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		PsdDataStru[bufIndex].StartDetectionCycNum = startCycNum;
	}
	else
	{
		/*不做处理*/
	}
}
/*
* 功能描述： 获取启动探测起始周期号
* 参数说明： const UINT16 doorId, 进路ID
* 返回值  ： 0: 获取数据失败
*           >0: 起始周期号
*/
UINT32 GetStartDetectionCycNum(const UINT16 doorId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT32 retVal = CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		retVal = PsdDataStru[bufIndex].StartDetectionCycNum;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}
/*
* 功能描述：设置开始启动探测状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
*            const UINT32 detectionState, 启动状态
* 返回值  ： 无
*            
*/
void SetStartDetectionState(const UINT16 doorId, const UINT32 detectionState)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		if ((JXTC_START_DETECTION_NO == detectionState) || (JXTC_START_DETECTION_YES == detectionState) )
		{
			PsdDataStru[bufIndex].StartDetectionState = (UINT8)(detectionState);
		}
		else
		{
			/*不做处理*/
		}
		
	}
	else
	{
		/*不做处理*/
	}
}
/*
* 功能描述： 获取开始启动探测状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
* 返回值  ： 0: 获取数据失败
*           >0: 选排起始周期号
*/
UINT8 GetStartDetectionState(const UINT16 doorId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		retVal = PsdDataStru[bufIndex].StartDetectionState;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}


/*
* 功能描述：设置停止探测状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
*            const UINT32 detectionState, 停止探测状态
* 返回值  ： 无
*            
*/
void SetStopDetectionState(const UINT16 doorId, const UINT32 detectionState)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		if ((JXTC_STOP_DETECTION_NO == detectionState) || (JXTC_STOP_DETECTION_YES == detectionState) )
		{
			PsdDataStru[bufIndex].StopDetectionState = (UINT8)(detectionState);
		}
		else
		{
			/*不做处理*/
		}

	}
	else
	{
		/*不做处理*/
	}
}
/*
* 功能描述： 获取停止探测状态
* 参数说明： const UINT16 routeId, 屏蔽门ID
* 返回值  ： 0: 获取数据失败
*           >0: 选排起始周期号
*/
UINT8 GetStopDetectionState(const UINT16 doorId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		retVal = PsdDataStru[bufIndex].StopDetectionState;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}
#if 0
/*
* 功能描述： 设置因VOBC关PSD而需要被重开的进路
* 参数说明： const UINT16 doorId,屏蔽门ID
*			 const UINT16 routeId,进路ID
* 返回值  ： 0: 设置失败
*			 1: 设置成功
*/
UINT8 SetPsdToBeOpenedRoute(const UINT16 doorId, const UINT16 routeId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_SUCCESS;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		PsdDataStru[bufIndex].ToBeOpenedRouteId = routeId;

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

/*
* 功能描述： 获取因VOBC关PSD而需要被重开的进路
* 参数说明： const UINT16 doorId,屏蔽门ID
* 返回值  ： 0:  没有因VOBC关PSD而需要被重开的进路或是查找失败
*			 >0: 因VOBC关PSD而需要被重开的进路
*/
UINT16 GetPsdToBeOpenedRoute(const UINT16 doorId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT16 retVal = CI_ERROR;
	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		retVal = PsdDataStru[bufIndex].ToBeOpenedRouteId;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}
#endif

/*
* 功能描述： 获取指定ID屏蔽门开门按钮状态
* 参数说明： const UINT16 doorId, 屏蔽门ID    
* 返回值  ： 0: 获取数据失败
*			>0: 屏蔽门开门按钮状态      
*/
UINT8 GetPsdOpenButtonState(const UINT16 doorId)
{
	UINT16 bufIndex = 0u;                      /*数组下标*/
	UINT8 retVal = 0u;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		retVal = PsdDataStru[bufIndex].doorOpenButtonState;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 设置指定ID屏蔽门开门按钮状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
*			 const UINT8 buttonState, 屏蔽门开门按钮状态
* 返回值  ： 0: 设置失败
*			 1: 设置成功      
*/
UINT8 SetPsdOpenButtonState(const UINT16 doorId, const UINT8 buttonState)
{
	UINT16 bufIndex = 0u;                      /*数组下标*/
	UINT8 retVal = 0u;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		if ((PSD_OPEN_BUTTON_STATE_VALID == buttonState) || (PSD_OPEN_BUTTON_STATE_INVALID == buttonState))
		{
			PsdDataStru[bufIndex].doorOpenButtonState = buttonState;  /*站台按钮状态*/

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

}

/*
* 功能描述： 获取指定ID屏蔽门发车按钮状态
* 参数说明： const UINT16 doorId, 屏蔽门ID    
* 返回值  ： 0: 获取数据失败
*			>0: 屏蔽门发车按钮状态      
*/
UINT8 GetPsdDepartButtonState(const UINT16 doorId)
{
	UINT16 bufIndex = 0u;                      /*数组下标*/
	UINT8 retVal = 0u;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		retVal = PsdDataStru[bufIndex].doorDepartButtonState;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 设置指定ID屏蔽门发车按钮状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
*			 const UINT8 buttonState, 屏蔽门发车按钮状态
* 返回值  ： 0: 设置失败
*			 1: 设置成功      
*/
UINT8 SetPsdDepartButtonState(const UINT16 doorId, const UINT8 buttonState)
{
	UINT16 bufIndex = 0u;                      /*数组下标*/
	UINT8 retVal = 0u;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		if ((PLATFORM_DEPAR_BUTTON_STATE_VALID == buttonState) || (PLATFORM_DEPAR_BUTTON_STATE_INVALID == buttonState))
		{
			PsdDataStru[bufIndex].doorDepartButtonState = buttonState;  /*站台按钮状态*/

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

}

/*
* 功能描述：设置指定ID屏蔽门PCB按下起始周期号
* 参数说明： const UINT16 doorId, 屏蔽门ID
*            const UINT32 startCycNum, 起始周期号
* 返回值  ： 0: 设置数据失败
*           >0: 设置数据成功
*/
UINT8 SetPCBPressCycNum(const UINT16 doorId, const UINT32 startCycNum)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		PsdDataStru[bufIndex].PCBPressCycNum = startCycNum;
		retVal = CI_SUCCESS;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}
/*
* 功能描述： 获取指定ID屏蔽门PCB按下起始周期号
* 参数说明： const UINT16 doorId，屏蔽门ID
* 返回值  ： 0: 获取数据失败
*           >0: 起始周期号
*/
UINT32 GetPCBPressCycNum(const UINT16 doorId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT32 retVal = CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		retVal = PsdDataStru[bufIndex].PCBPressCycNum;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述：设置指定ID屏蔽门POB按下起始周期号
* 参数说明： const UINT16 doorId, 屏蔽门ID
*            const UINT32 startCycNum, 起始周期号
* 返回值  ： 0: 设置数据失败
*           >0: 设置数据成功
*/
UINT8 SetPOBPressCycNum(const UINT16 doorId, const UINT32 startCycNum)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		PsdDataStru[bufIndex].POBPressCycNum = startCycNum;
		retVal = CI_SUCCESS;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}
/*
* 功能描述： 获取指定ID屏蔽门POB按下起始周期号
* 参数说明： const UINT16 doorId，屏蔽门ID
* 返回值  ： 0: 获取数据失败
*           >0: 起始周期号
*/
UINT32 GetPOBPressCycNum(const UINT16 doorId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT32 retVal = CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		retVal = PsdDataStru[bufIndex].POBPressCycNum;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述：设置指定ID屏蔽门PSB按下起始周期号
* 参数说明： const UINT16 doorId, 屏蔽门ID
*            const UINT32 startCycNum, 起始周期号
* 返回值  ： 0: 设置数据失败
*           >0: 设置数据成功
*/
UINT8 SetPSBPressCycNum(const UINT16 doorId, const UINT32 startCycNum)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		PsdDataStru[bufIndex].PSBPressCycNum = startCycNum;
		retVal = CI_SUCCESS;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}
/*
* 功能描述： 获取指定ID屏蔽门PSB按下起始周期号
* 参数说明： const UINT16 doorId，屏蔽门ID
* 返回值  ： 0: 获取数据失败
*           >0: 起始周期号
*/
UINT32 GetPSBPressCycNum(const UINT16 doorId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT32 retVal = CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		retVal = PsdDataStru[bufIndex].PSBPressCycNum;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 设置指定ID屏蔽门按钮旁路状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
*            UINT8 setFlag  需设置的按钮旁路状态
* 返回值  ： PSD_BUTTON_PANGLU_STATE_VALID    0x55  有效
*            PSD_BUTTON_PANGLU_STATE_INVALID  0xaa  无效
*/
UINT8 SetPsdButtonPangluState(const UINT16 doorId, const UINT8 setFlag)
{
	UINT16 bufIndex = 0u;                      /*数组下标*/
	UINT8 retVal = 0u;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		if ((PSD_BUTTON_PANGLU_STATE_VALID == setFlag) || (PSD_BUTTON_PANGLU_STATE_INVALID == setFlag))
		{
			PsdDataStru[bufIndex].PsdButtonPangluState = setFlag;   /*设置按钮旁路状态*/
			retVal = CI_SUCCESS;
		}
		else
		{
			retVal = CI_ERROR;
		}
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 获取指定ID屏蔽门按钮旁路状态
* 参数说明： const UINT16 doorId, 屏蔽门ID   
* 返回值  ：0: 获取数据失败
*			>0: 站台安全门按钮旁路状态
*/
UINT8 GetPsdButtonPangluState(const UINT16 doorId)
{
	UINT16 bufIndex = 0u;                      /*数组下标*/
	UINT8 retVal = 0u;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*站台安全门按钮旁路状态*/

	if (bufIndex < PSD_SUM_MAX)
	{
		retVal = PsdDataStru[bufIndex].PsdButtonPangluState;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;  
}

/*
* 功能描述： 获取指定ID屏蔽门编组信息
* 参数说明： const UINT16 doorId, 屏蔽门ID    
* 返回值  ： 0: 获取编组信息失败
*			>0: 编组信息      
*/
UINT16 GetPsdEditGroupInfoFromPsdData(const UINT16 doorId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT16 retVal = CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		retVal = PsdDataStru[bufIndex].psdEditGroupInfo;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述：设置VOBC2CI车门状态信息
* 参数说明： const UINT16 doorId, 屏蔽门ID
*            const UINT32 doorState, 车门状态
* 返回值  ： 无
*           
*/
void SetVOBCDoorState(const UINT16 doorId, const UINT32 doorState)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		if ((PSD_DOOR_CLOSEDANDLOCKED_VALID == doorState) || (PSD_DOOR_CLOSEDANDLOCKED_INVALID == doorState))
		{
			PsdDataStru[bufIndex].VOBCDoorState = (UINT8)(doorState);
		}
		else
		{
			/*不做处理*/
		}
	}
	else
	{
		/*不做处理*/
	}
}

/*
* 功能描述： 获取VOBC2CI车门状态信息
* 参数说明： const UINT16 doorId, 屏蔽门ID
* 返回值  ： UINT8,车门状态信息
*			0: 获取车门状态信息失败
*			>0: 获取车门状态信息成功      
*/
UINT8 GetVOBCDoorState(const UINT16 doorId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		retVal = PsdDataStru[bufIndex].VOBCDoorState;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 获取指定ID屏蔽门Psc周期
* 参数说明： const UINT16 doorId, 屏蔽门ID    
* 返回值  ： 0: 获取数据失败
*			>0: 屏蔽门命令设置周期 
*/
UINT32 GetPsdCmdCyclePsc(const UINT16 doorId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT32 retVal = 0u;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取道岔数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		retVal = PsdDataStru[bufIndex].CmdSetCyclePsc;
	}
	else
	{
		retVal = 0u;
	}
	return retVal;
}


/*
* 功能描述： 设置指定ID屏蔽门状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
*			 const UINT8 doorState, 屏蔽门命令设置周期
* 返回值  ： 0: 设置失败
*			 1: 设置成功      
*/
UINT8 SetPsdCmdCyclePsc(const UINT16 doorId, const UINT32 doorCycle)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_SUCCESS;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		PsdDataStru[bufIndex].CmdSetCyclePsc = doorCycle;  /*屏蔽门命令设置周期*/

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

/*
* 功能描述： 设置指定ID屏蔽门旁路标志
* 参数说明： const UINT16 doorId, 屏蔽门ID
*            const UINT8 setFlag, 屏蔽门旁路设置状态
* 返回值  ：无
*			       
*/

void SetPsdConfirmFlag(const UINT16 doorId,const UINT8 setFlag)
{
	/*变量初始化*/
	UINT16 bufIndex = 0u;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
	if(bufIndex < PSD_SUM_MAX)
	{
		PsdDataStru[bufIndex].PscPlConfirmFlag = setFlag;
	}
	else
	{
		/*不做处理*/
	}
}

/*
* 功能描述： 获取指定ID屏蔽门旁路标志
* 参数说明： const UINT16 doorId, 屏蔽门ID
*            
* 返回值  ： 0: 获取失败
*			 >0: 获取成功      
*/
UINT8 GetPsdPlFlag(const UINT16 doorId)
{
	/*变量初始化*/
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = 0u;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if(bufIndex < PSD_SUM_MAX)
	{
		retVal = PsdDataStru[bufIndex].PscPlConfirmFlag;
	}
	else 
	{
		/*不做处理*/
	}
	return(retVal);
}

/*
* 功能描述： PSC同时与另一联锁通信时，PSC旁路命令处理
* 参数说明： UINT8 psdId psd ID
*            UINT16 pscId psc设备ID 
*            UINT8 setFlag,设置标志
* 返回值  ：无
*/
void SetNearCiPscPlFlag(const UINT16 psdId,const UINT16 pscId,const UINT8 setFlag)
{
	/*变量初始化*/
	UINT8 i = 0u;
	UINT8 transmitState = 0u;
	UINT8 localCiId = 0u;
	UINT8 psdCiId = 0u;
	UINT8 pscPlFlag = 0u;
	UINT16 savePscId = 0u;
	UINT8 lowBytePscId = 0u;
	UINT8 funcId = EFUNC_SETNEARCIPSCPLFLAG;
	UINT8 sendLevel = ESEND_LEVEL_ATS;

	/*赋值*/
	savePscId = pscId;
	lowBytePscId =(UINT8)(savePscId & 0x00FFu);
	localCiId = GetSystemParaLocalCiId();/*获取CI ID*/
	psdCiId = GetPsdBelongCiId(psdId);
	
    
	/*更新PSC与CI通信状态*/
	(void)UpdateCiTransmitState(localCiId, CI_SYSTEM_TYPE_PSC, lowBytePscId);
	transmitState = GetCiTransmitState(CI_SYSTEM_TYPE_PSC, lowBytePscId);
	/*设置PSC旁路*/
	if(CI_PSC_PL_CONFIRM_YES == setFlag)
	{
		/*通信异常常*/
		if(TRANSMIT_STATE_GOOD != transmitState)
		{
			/*本联锁*/
			if(psdCiId == localCiId)
			{
				/*设置PSC对应PSD旁路*/
				SetPsdConfirmFlag(psdId, setFlag);
			}
		}
		else
		{
			/*报警*/
			SetErrorData(funcId,CI_SYSTEM_TYPE_PSC,pscId,ETYPE_COMM_WITH_PSC,transmitState,sendLevel);
		}
	}
	else
	{
		/*获取PSD旁路标志*/
		pscPlFlag = GetPsdPlFlag(psdId);
		if(psdCiId == localCiId)
		{
			if(CI_PSC_PL_CONFIRM_YES == pscPlFlag)
			{
				SetPsdConfirmFlag(psdId, CI_PSC_PL_CONFIRM_NO);
			}
			else
			{
				/*报警*/
				SetErrorData(funcId,CI_SYSTEM_TYPE_PSC,pscId,ETYPE_PSC_CONFIRM_PL_STATE,CI_PSC_PL_CONFIRM_NO,sendLevel);
			}
		}
	}
}

/*
* 功能描述： 设置间隙探测启动继电器吸起周期
* 参数说明： UINT16 psdId 屏蔽门ID
*            UINT32 cycNum 设置周期
* 返回值  ： 无
*			    
*/
void SetJXTCStartUpCycNum(UINT16 psdId, UINT32 cycNum)
{
    /*变量初始化*/

    UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetPsdConfigBufIndex(psdId);  /*获取屏蔽门数组下标*/
	if (PSD_SUM_MAX > bufIndex)
	{
		PsdDataStru[bufIndex].JXTCStartCycNum = cycNum; /*设置周期*/
	}
	else
	{
		/*不做处理*/
	}
}


/*
* 功能描述： 获取间隙探测启动继电器吸起周期
* 参数说明： UINT16 psdId 屏蔽门ID
*            
* 返回值  ：0：返回错误
*           大于0：开始周期
*			    
*/
UINT32 GetJXTCStartUpCycNum(UINT16 psdId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT32 retVal = CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(psdId);  /*获取屏蔽门数组下标*/

	if (PSD_SUM_MAX > bufIndex)
	{
		retVal = PsdDataStru[bufIndex].JXTCStartCycNum;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 设置间隙探测停止继电器吸起周期
* 参数说明： UINT16 psdId 屏蔽门ID
*            UINT32 cycNum 设置周期
* 返回值  ： 无
*			    
*/
void SetJXTCStopUpCycNum(UINT16 psdId, UINT32 cycNum)
{
    /*变量初始化*/

    UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetPsdConfigBufIndex(psdId);  /*获取屏蔽门数组下标*/
	if (PSD_SUM_MAX > bufIndex)
	{
		PsdDataStru[bufIndex].JXTCStopCycNum = cycNum; /*设置周期*/
	}
	else
	{
		/*不做处理*/
	}
}

/*
* 功能描述： 获取间隙探测停止继电器吸起周期
* 参数说明： UINT16 psdId 屏蔽门ID
*            
* 返回值  ：0：返回错误
*           大于0：开始周期
*			    
*/
UINT32 GetJXTCStopUpCycNum(UINT16 psdId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT32 retVal = CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(psdId);  /*获取屏蔽门数组下标*/

	if (PSD_SUM_MAX > bufIndex)
	{
		retVal = PsdDataStru[bufIndex].JXTCStopCycNum;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 设置启动间隙探测跳转状态
* 参数说明： UINT16 psdId 屏蔽门ID
*            
* 返回值  ：无
*			    
*/
void SetJXTCStartState(UINT16 psdId, UINT8 jxtcState)
{
	/*变量初始化*/

    UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetPsdConfigBufIndex(psdId);  /*获取屏蔽门数组下标*/
	if (PSD_SUM_MAX > bufIndex)
	{
		PsdDataStru[bufIndex].JXTCStartState = jxtcState; /*设置状态*/
	}
	else
	{
		/*不做处理*/
	}

}

/*
* 功能描述： 获取启动间隙探测所处状态步骤
* 参数说明： UINT16 psdId 屏蔽门ID
*            
* 返回值  ：0：返回错误
*           大于0：间隙探测所处步骤
*			    
*/
UINT8 GetJXTCStartState(UINT16 psdId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(psdId);  /*获取屏蔽门数组下标*/

	if (PSD_SUM_MAX > bufIndex)
	{
		retVal = PsdDataStru[bufIndex].JXTCStartState;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 设置停止间隙探测跳转状态
* 参数说明： UINT16 psdId 屏蔽门ID
*            
* 返回值  ：无
*			    
*/
void SetJXTCStopState(UINT16 psdId, UINT8 jxtcState)
{
	/*变量初始化*/

    UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetPsdConfigBufIndex(psdId);  /*获取屏蔽门数组下标*/
	if (PSD_SUM_MAX > bufIndex)
	{
		PsdDataStru[bufIndex].JXTCStopState = jxtcState; /*设置状态*/
	}
	else
	{
		/*不做处理*/
	}

}

/*
* 功能描述： 获取停止间隙探测所处状态步骤
* 参数说明： UINT16 psdId 屏蔽门ID
*            
* 返回值  ：0：返回错误
*           大于0：间隙探测所处步骤
*			    
*/
UINT8 GetJXTCStopState(UINT16 psdId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(psdId);  /*获取屏蔽门数组下标*/

	if (PSD_SUM_MAX > bufIndex)
	{
		retVal = PsdDataStru[bufIndex].JXTCStopState;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 设置间隙探测驱动启动标志
* 参数说明： UINT16 psdId 屏蔽门ID
*            UINT8 jxtcDriveFlag 间隙探测驱动启动标志
* 返回值  ：无
*			    
*/
void SetJXTCDriveStartFlag(UINT16 psdId, UINT8 jxtcDriveFlag)
{
	/*变量初始化*/

    UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetPsdConfigBufIndex(psdId);  /*获取屏蔽门数组下标*/
	if (PSD_SUM_MAX > bufIndex)
	{
		PsdDataStru[bufIndex].JXTCStartFlag = jxtcDriveFlag; /*设置状态*/
	}
	else
	{
		/*不做处理*/
	}

}

/*
* 功能描述： 获取间隙探测驱动启动标志
* 参数说明： UINT16 psdId 屏蔽门ID
*            
* 返回值  ：0：返回错误
*           大于0：间隙探测驱动启动标志
*			    
*/
UINT8 GetJXTCDriveStartFlag(UINT16 psdId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(psdId);  /*获取屏蔽门数组下标*/

	if (PSD_SUM_MAX > bufIndex)
	{
		retVal = PsdDataStru[bufIndex].JXTCStartFlag;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 设置间隙探测驱动停止标志
* 参数说明： UINT16 psdId 屏蔽门ID
*            UINT8 jxtcDriveFlag 间隙探测驱动停止标志
* 返回值  ：无
*			    
*/
void SetJXTCDriveStopFlag(UINT16 psdId, UINT8 jxtcDriveFlag)
{
	/*变量初始化*/

    UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetPsdConfigBufIndex(psdId);  /*获取屏蔽门数组下标*/
	if (PSD_SUM_MAX > bufIndex)
	{
		PsdDataStru[bufIndex].JXTCStopFlag = jxtcDriveFlag; /*设置状态*/
	}
	else
	{
		/*不做处理*/
	}

}

/*
* 功能描述： 获取间隙探测驱动停止标志
* 参数说明： UINT16 psdId 屏蔽门ID
*            
* 返回值  ：0：返回错误
*           大于0：间隙探测驱动停止标志
*			    
*/
UINT8 GetJXTCDriveStopFlag(UINT16 psdId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(psdId);  /*获取屏蔽门数组下标*/

	if (PSD_SUM_MAX > bufIndex)
	{
		retVal = PsdDataStru[bufIndex].JXTCStopFlag;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}


/*
* 功能描述： 获取指定ID屏蔽门上周期驱动状态
* 参数说明： const UINT16 doorId, 屏蔽门ID    
* 返回值  ： 0: 获取数据失败
*			>0: 屏蔽门驱动状态      
*/
UINT8 GetPsdPreDriveState(const UINT16 doorId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (PSD_SUM_MAX > bufIndex)
	{
		retVal = PsdDataStru[bufIndex].PsdPreDriveState;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}


/*
* 功能描述： 设置指定ID屏蔽门上周期驱动状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
*			 const UINT8 doorDriveState, 屏蔽门驱动状态
* 返回值  ： void      
*/
void SetPsdPreDriveState(const UINT16 doorId, const UINT8 doorDriveState)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (PSD_SUM_MAX > bufIndex)
	{
		if ((PSD_DRIVE_STATE_CLOSE == doorDriveState) || (PSD_DRIVE_STATE_OPEN == doorDriveState) || (PSD_DRIVE_STATE_INVALID == doorDriveState))
		{
			PsdDataStru[bufIndex].PsdPreDriveState = doorDriveState;  /*屏蔽门驱动状态*/			
		}
		
	}
	
}
/*
* 功能描述： 设置屏蔽门驱动开门开始周期
* 参数说明： UINT16 psdId 屏蔽门ID
*            UINT32 cycNum 设置周期
* 返回值  ： 无
* cgh-合并CID-2349-4：
*
*/
void SetPsdDriveOpenStartCycNum(UINT16 psdId, UINT32 cycNum)
{
	/*变量初始化*/

	UINT16 bufIndex = 0;  /*数组下标*/

	bufIndex = GetPsdConfigBufIndex(psdId);  /*获取屏蔽门数组下标*/
	if (PSD_SUM_MAX > bufIndex)
	{
		PsdDataStru[bufIndex].psdDriveOpenStartNum = cycNum; /*设置周期*/
	}
	else
	{
		/*不做处理*/
	}
}

/*
* 功能描述： 获取psd驱动开门开始周期
* 参数说明： UINT16 psdId 屏蔽门ID
*
* 返回值  ：0：返回错误
*           大于0：开始周期
*cgh-合并CID-2349-4：
*/
UINT32 GetPsdDriveOpenStartCycNum(UINT16 psdId)
{
	UINT16 bufIndex = 0;  /*数组下标*/
	UINT32 retVal = CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(psdId);  /*获取屏蔽门数组下标*/

	if (PSD_SUM_MAX > bufIndex)
	{
		retVal = PsdDataStru[bufIndex].psdDriveOpenStartNum;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 设置屏蔽门驱动关闭开始周期
* 参数说明： UINT16 psdId 屏蔽门ID
*            UINT32 cycNum 设置周期
* 返回值  ： 无
* cgh-合并CID-2349-4：
*
*/
void SetPsdDriveCloseStartCycNum(UINT16 psdId, UINT32 cycNum)
{
	/*变量初始化*/

	UINT16 bufIndex = 0;  /*数组下标*/

	bufIndex = GetPsdConfigBufIndex(psdId);  /*获取屏蔽门数组下标*/
	if (PSD_SUM_MAX > bufIndex)
	{
		PsdDataStru[bufIndex].psdDriveCloseStartNum = cycNum; /*设置周期*/
	}
	else
	{
		/*不做处理*/
	}
}

/*
* 功能描述： 获取psd驱动关闭开始周期
* 参数说明： UINT16 psdId 屏蔽门ID
*
* 返回值  ：0：返回错误
*           大于0：开始周期
* cgh-合并CID-2349-4：
*
*/
UINT32 GetPsdDriveCloseStartCycNum(UINT16 psdId)
{
	UINT16 bufIndex = 0;  /*数组下标*/
	UINT32 retVal = CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(psdId);  /*获取屏蔽门数组下标*/

	if (PSD_SUM_MAX > bufIndex)
	{
		retVal = PsdDataStru[bufIndex].psdDriveCloseStartNum;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 获取清客标志
* 参数说明： const UINT16 doorId, 屏蔽门ID
* 返回值  ： 0: 获取数据失败
*			>0: 屏蔽门状态
* cgh-合并CID-2349-4\cgh-合并CID-3037-1：：
*/
UINT8 GetClearPassenagerFlag(const UINT16 doorId)
{
	UINT16 bufIndex = 0;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取道岔数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		retVal = PsdDataStru[bufIndex].clearPassengerFlag;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 设置清客标志
* 参数说明： UINT16 psdId 屏蔽门ID
*            UINT8 clearPassenagerFlag 清客标志
* 返回值  ： 无
* cgh-合并CID-2349-4：
*
*/
void SetClearPassenagerFlag(const UINT16 psdId, UINT8 clearPassenagerFlag)
{
	/*变量初始化*/

	UINT16 bufIndex = 0;  /*数组下标*/

	bufIndex = GetPsdConfigBufIndex(psdId);  /*获取屏蔽门数组下标*/
	if (PSD_SUM_MAX > bufIndex)
	{
		PsdDataStru[bufIndex].clearPassengerFlag = clearPassenagerFlag; /*设置周期*/
	}
	else
	{
		/*不做处理*/
	}
}

/*
* 功能描述： 获取清客按钮是否已驱过稳灯标志
* 参数说明： const UINT16 doorId, 屏蔽门ID
* 返回值  ： 0: 获取数据失败
*			>0: 屏蔽门状态
* cgh-合并CID-2349-4\cgh-合并CID-3037-1：：
*/
UINT8 GetSteadyLightFlag(const UINT16 doorId)
{
	UINT16 bufIndex = 0;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取道岔数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		retVal = PsdDataStru[bufIndex].steadyLightFlag;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 设置清客按钮已驱过稳灯标志
* 参数说明： UINT16 psdId 屏蔽门ID
*            UINT8 clearPassenagerFlag 清客标志
* 返回值  ： 无
* cgh-合并CID-2349-4\cgh-合并CID-3037-1：：
*
*/
void SetSteadyLightFlag(const UINT16 psdId, UINT8 steadyLightFlag)
{
	/*变量初始化*/

	UINT16 bufIndex = 0;  /*数组下标*/

	bufIndex = GetPsdConfigBufIndex(psdId);  /*获取屏蔽门数组下标*/
	if (PSD_SUM_MAX > bufIndex)
	{
		PsdDataStru[bufIndex].steadyLightFlag = steadyLightFlag; /*设置周期*/
	}
	else
	{
		/*不做处理*/
	}
}

/*
* 功能描述：设置指定ID屏蔽门清客确认箱PCB按下起始周期号
* 参数说明： const UINT16 doorId, 屏蔽门ID
*            const UINT32 startCycNum, 起始周期号
* 返回值  ： 0: 设置数据失败
*           >0: 设置数据成功
* 增加：by cgh 20230526
*/
UINT8 SetCleFarePCBPressCycNum(const UINT16 doorId, const UINT32 startCycNum)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		PsdDataStru[bufIndex].dwCleFarePCBPressCycNum = startCycNum;
		retVal = CI_SUCCESS;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}
/*
* 功能描述： 获取指定ID屏蔽门清客确认箱PCB按下起始周期号
* 参数说明： const UINT16 doorId，屏蔽门ID
* 返回值  ： 0: 获取数据失败
*           >0: 起始周期号
*增加： by cgh 20230526
*/
UINT32 GetCleFarePCBPressCycNum(const UINT16 doorId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT32 retVal = CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		retVal = PsdDataStru[bufIndex].dwCleFarePCBPressCycNum;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}
/*
* 功能描述： 获取指定ID屏蔽门清客确认箱PCB按钮状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
* 返回值  ： 0: 获取数据失败
*			>0: 屏蔽门按钮状态
* * 增加：by cgh 20230526
*/
UINT8 GetCleFarePCBButtonState(const UINT16 doorId)
{
	UINT16 bufIndex = 0u;                      /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		retVal = PsdDataStru[bufIndex].chCleFarePCBButtonState;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 设置指定ID屏蔽门清客确认箱PCB按钮状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
*			 const UINT8 buttonState, 屏蔽门按钮状态
* 返回值  ： 0: 设置失败
*			 1: 设置成功
* * 增加：by cgh 20230526
*/
UINT8 SetCleFarePCBButtonState(const UINT16 doorId, const UINT8 buttonState)
{
	UINT16 bufIndex = 0u;                      /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		if ((QK_PSD_BUTTON_STATE_DOWN == buttonState) || (QK_PSD_BUTTON_STATE_UP == buttonState))
		{
			PsdDataStru[bufIndex].chCleFarePCBButtonState = buttonState;  /*清客确认箱PCB按钮状态*/

			retVal = CI_SUCCESS;
		}
		else
		{
			retVal = CI_ERROR;
		}
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}
/*
* 功能描述： 获取指定ID屏蔽门清客确认箱PCB按钮记忆状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
* 返回值  ： 0: 获取数据失败
*			>0: 屏蔽门按钮记忆状态
* * 增加：by cgh 20230526
*/
UINT8 GetCleFarePCBButKeepState(const UINT16 doorId)
{
	UINT16 bufIndex = 0u;                      /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		retVal = PsdDataStru[bufIndex].chCleFarePCBButKeepState;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 设置指定ID屏蔽门清客确认箱PCB按钮记忆状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
*			 const UINT8 buttonState, 屏蔽门按钮记忆状态
* 返回值  ： 0: 设置失败
*			 1: 设置成功
* * 增加：by cgh 20230526
*/
UINT8 SetCleFarePCBButKeepState(const UINT16 doorId, const UINT8 buttonState)
{
	UINT16 bufIndex = 0u;                      /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		if ((QK_PSD_BUTTON_STATE_UP == buttonState) || (QK_PSD_BUTTON_STATE_DOWN == buttonState))
		{
			PsdDataStru[bufIndex].chCleFarePCBButKeepState = buttonState;  /*清客确认箱PCB按钮记忆状态*/

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

/*
* 功能描述： 设置指定ID屏蔽门清客确认箱PDB按钮指示灯闪灯标志
* 参数说明： const UINT16 doorId, 屏蔽门ID
*			 const UINT8 buttonState, 清客确认箱PDB按钮指示灯闪灯标志
* 返回值  ： 0: 设置失败
*			 1: 设置成功
* * 增加：by cgh 20230529
*/
UINT8 SetCleFarePDBFlaLigFlag(const UINT16 doorId, const UINT8 buttonState)
{
	UINT16 bufIndex = 0u;                      /*数组下标*/
	UINT8 retVal =CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		if ((QK_BUTTON_FLASH_LIGHT_NO == buttonState) || (QK_BUTTON_FLASH_LIGHT_YES == buttonState))
		{
			PsdDataStru[bufIndex].chCleFarePDBFlaLigFlag = buttonState;  /*清客确认箱PCB按钮记忆状态*/

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

/*
* 功能描述： 获取指定ID屏蔽门清客确认箱PDB按钮指示灯闪灯标志
* 参数说明： const UINT16 doorId, 屏蔽门ID
* 返回值  ： 0: 获取数据失败
*			>0: 清客确认箱PDB按钮指示灯闪灯标志
* * 增加：by cgh 20230529
*/
UINT8 GetCleFarePDBFlaLigFlag(const UINT16 doorId)
{
	UINT16 bufIndex = 0u;                      /*数组下标*/
	UINT8 retVal =CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		retVal = PsdDataStru[bufIndex].chCleFarePDBFlaLigFlag;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 设置本OC所有屏蔽门清客确认箱PCB按钮记忆状态
* 参数说明： const UINT16 wOcId  OC ID
			const UINT8 buttonState, 屏蔽门按钮记忆状态
* 返回值  ： 无
* * 增加：by cgh 20230605
*/
void SetAllCleFarePCBButKeepSta(const UINT16 wOcId,const UINT8 buttonState)
{
	UINT16 ii = 0U;					/*游标*/
	UINT16 wPsdSum = 0U;			/*psd总数*/
	UINT16 wPsdId = 0U;				/*屏蔽门ID*/
	UINT16 wCleFarePCBButtonRelayId = 0U;/*屏蔽门对应清客确认箱PCB按钮继电器*/
	UINT16 wPsdCleFarePCBDelayCiId = 0U; /*屏蔽门对应清客确认箱PCB按钮继电器所属联锁ID*/
	UINT16 wPsdBufIndex = 0U;/*指定ID屏蔽门索引号*/

	wPsdSum = GetPsdSum();
	for (ii = 0u; ii < wPsdSum; ii++)
	{
		wPsdId = GetPsdId(ii);
		if ((0u < wPsdId) && (PSD_SUM_MAX > wPsdId))
		{
			wCleFarePCBButtonRelayId = GetCleFarePCBButRelayId(wPsdId);
			wPsdBufIndex = GetPsdConfigBufIndex(wPsdId);
			if (PSD_SUM_MAX > wPsdBufIndex)
			{
				if ((0U == wCleFarePCBButtonRelayId) || (UINT16_MAX == wCleFarePCBButtonRelayId))
				{
					; /*继电器ID无效，则不需要重新设置状态*/
				}
				else
				{
					wPsdCleFarePCBDelayCiId = GetRelayBelongOCId(wCleFarePCBButtonRelayId);
					if (wOcId == wPsdCleFarePCBDelayCiId)
					{
						if ((QK_PSD_BUTTON_STATE_UP == buttonState) || (QK_PSD_BUTTON_STATE_DOWN == buttonState))
						{
							PsdDataStru[wPsdBufIndex].chCleFarePCBButKeepState = buttonState;  /*清客确认箱PCB按钮记忆状态*/
						}
						else
						{
							; /*非法状态，不设置*/
						}
					}
					else
					{
						; /*不属于本OC不处理*/
					}
				}
			}
			else
			{
				; /*屏蔽门ID索引编号无效，不处理*/
			}	
		}
		else
		{
			; /*屏蔽门ID无效，不处理*/
		}
	}
}

/*
* 功能描述： 设置指定ID屏蔽门视频清客驱动状态
* 参数说明： const UINT16 wPsdId, 屏蔽门ID
*			 const UINT8 chSetState, 屏蔽门视频清客驱动状态
* 返回值  ： 无
* 增加：by cgh 20231214
*/
void SetPsdVideoQkDriveState(const UINT16 wPsdId, const UINT8 chSetState)
{
	UINT16 bufIndex = 0U;                      /*数组下标*/

	bufIndex = GetPsdConfigBufIndex(wPsdId);  /*获取屏蔽门数组下标*/

	if (PSD_SUM_MAX > bufIndex)
	{
		if ((VIDEO_QK_DRIVE_STATE_NO == chSetState) || (VIDEO_QK_DRIVE_STATE_HAVE == chSetState) ||
			(VIDEO_QK_DRIVE_STATE_TESTING == chSetState) || (VIDEO_QK_DRIVE_STATE_INVALID == chSetState))
		{
			PsdDataStru[bufIndex].chVideoQkDriveState = chSetState;  /*屏蔽门视频清客驱动状态*/
		}
		else
		{
			; /*不处理*/
		}
	}
	else
	{
		; /*不处理*/
	}
}

/*
* 功能描述： 获取指定ID屏蔽门视频清客驱动状态
* 参数说明： const UINT16 wPsdId, 屏蔽门ID
* 返回值  ： 0: 获取数据失败
*			>0: 屏蔽门视频清客驱动状态
* * 增加：by cgh 20231214
*/
UINT8 GePsdVideoQkDriveState(const UINT16 wPsdId)
{
	UINT16 bufIndex = 0U;                      /*数组下标*/
	UINT8 retVal = CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(wPsdId);  /*获取屏蔽门数组下标*/

	if (PSD_SUM_MAX > bufIndex)
	{
		retVal = PsdDataStru[bufIndex].chVideoQkDriveState;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述： 设置指定ID屏蔽门视频清客关联VOBC ID
* 参数说明： const UINT16 wPsdId, 屏蔽门ID
*			 const UINT16 wVobcId, 屏蔽门视频清客关联VOBC ID
* 返回值  ：无
* 增加：by cgh 20231214
*/
void SetPsdVideoQkRelateVobcId(const UINT16 wPsdId, const UINT16 wVobcId)
{
	UINT16 bufIndex = 0U;                      /*数组下标*/

	bufIndex = GetPsdConfigBufIndex(wPsdId);  /*获取屏蔽门数组下标*/

	if (PSD_SUM_MAX > bufIndex)
	{
		PsdDataStru[bufIndex].wVideoQkRelateVobcId = wVobcId;  /*屏蔽门视频清客关联VOBC ID*/
	}
	else
	{
		; /*不处理*/
	}
}

/*
* 功能描述： 获取指定ID屏蔽门视频清客关联VOBC ID
* 参数说明： const UINT16 wPsdId, 屏蔽门ID
* 返回值  ： 0: 获取数据失败
*			>0: 屏蔽门视频清客驱动状态
* * 增加：by cgh 20231214
*/
UINT16 GePsdVideoQkRelateVobcId(const UINT16 wPsdId)
{
	UINT16 bufIndex = 0U;                      /*数组下标*/
	UINT16 retVal = CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(wPsdId);  /*获取屏蔽门数组下标*/

	if (PSD_SUM_MAX > bufIndex)
	{
		retVal = PsdDataStru[bufIndex].wVideoQkRelateVobcId;
	}
	else
	{
		retVal = CI_ERROR;
	}
	return retVal;
}

/*
* 功能描述：设置指定ID屏蔽门异常打开状态
* 参数说明：const UINT16 wPsdId 屏蔽门ID
*			const UINT8 cExceptOpenState 屏蔽门异常打开状态
* 返 回 值：无
* Created By LQ 2025.05.22
*/
void SetPsdExceptOpenState(const UINT16 wPsdId, const UINT8 cExceptOpenState)
{
	UINT16 bufIndex = 0U;

	bufIndex = GetPsdConfigBufIndex(wPsdId);  /*获取屏蔽门数组下标*/

	if ((PSD_SUM_MAX > bufIndex) && ((PSD_EXCEPT_OPEN_YES == cExceptOpenState) || (PSD_EXCEPT_OPEN_NO == cExceptOpenState)))
	{
		PsdDataStru[bufIndex].cPsdExceptOpenState = cExceptOpenState;  /*设置屏蔽门异常打开状态*/
	}
	else
	{
		; /*不处理*/
	}
}

/*
* 功能描述：获取指定ID屏蔽门异常打开状态
* 参数说明：const UINT16 wPsdId 屏蔽门ID
* 返 回 值：0x55 异常打开
*           0xAA 未异常打开
* Created By LQ 2025.05.22
*/
UINT8 GePsdExceptOpenState(const UINT16 wPsdId)
{
	UINT16 bufIndex = 0U;
	UINT8 cRetVal = PSD_EXCEPT_OPEN_YES;

	bufIndex = GetPsdConfigBufIndex(wPsdId);  /*获取屏蔽门数组下标*/

	if (PSD_SUM_MAX > bufIndex)
	{
		cRetVal = PsdDataStru[bufIndex].cPsdExceptOpenState;
	}
	else
	{
		/*返回异常打开*/
	}

	return cRetVal;
}

/*
* 功能描述： 设置指定ID屏蔽门故障隔离信息
* 参数说明： const UINT16 doorId, 屏蔽门ID
*			 const UINT32 faultQStateOne, 故障隔离信息高四字节
* *			 const UINT32 faultQStateTwo, 故障隔离信息低四字节
* 返回值  ： 无
*/
void SetPsdFaultQState(const UINT16 doorId, const UINT32 faultQStateOne, const UINT32 faultQStateTwo)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
	if (PSD_SUM_MAX > bufIndex)
	{
		PsdDataStru[bufIndex].psdFaultQStataOne = faultQStateOne;
		PsdDataStru[bufIndex].psdFaultQStataTwo = faultQStateTwo;
	}
	else
	{
		/*不处理*/
	}
}

/*
* 功能描述： 获取指定ID屏蔽门故障隔离信息
* 参数说明： const UINT16 doorId, 屏蔽门ID
*			 UINT8 psdFlag,前四个字节还是后四个字节(0u为高四个字节，1u为低四个字节)
* 返回值  ： 0: 获取数据失败
*			>0: 屏蔽门故障隔离信息
*/
UINT32 GetPsdFaultQState(const UINT16 doorId, UINT8 psdFlag)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT32 retVal = UINT32_MAX;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if ((PSD_SUM_MAX > bufIndex) && (HIGH_FOUR_CHAR == psdFlag))
	{
		retVal = PsdDataStru[bufIndex].psdFaultQStataOne;/*高四字节*/
	}
	else if ((PSD_SUM_MAX > bufIndex) && (LOW_FOUR_CHAR == psdFlag))
	{
		retVal = PsdDataStru[bufIndex].psdFaultQStataTwo;/*低四字节*/
	}
	else
	{
		retVal = UINT32_MAX;
	}
	return retVal;
}

/*
* 功能描述： 设置指定ID屏蔽门被隔离信息
* 参数说明： const UINT16 doorId, 屏蔽门ID
*			 const UINT32 doorsIStateOne, 被隔离信息高四字节
* *			 const UINT32 doorsIStateTwo, 被隔离信息低四字节
* 返回值  ： 无
*/
void SetPsdDoorIState(const UINT16 doorId, const UINT32 doorsIStateOne, const UINT32 doorsIStateTwo)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
	if (PSD_SUM_MAX > bufIndex)
	{
		PsdDataStru[bufIndex].psdDoorIStateOne = doorsIStateOne;
		PsdDataStru[bufIndex].psdDoorIStateTwo = doorsIStateTwo;
	}
	else
	{
		/*不处理*/
	}

}

/*
* 功能描述： 获取指定ID屏蔽门被隔离信息
* 参数说明： const UINT16 doorId, 屏蔽门ID
*			 UINT8 psdFlag,前四个字节还是后四个字节(0u为高四个字节，1u为低四个字节)
* 返回值  ： 0: 获取数据失败
*			>0: 屏蔽门被隔离信息
*/
UINT32 GetPsdDoorIState(const UINT16 doorId, UINT8 psdFlag)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT32 retVal = UINT32_MAX;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if ((PSD_SUM_MAX > bufIndex) && (HIGH_FOUR_CHAR == psdFlag))
	{
		retVal = PsdDataStru[bufIndex].psdDoorIStateOne;/*高四字节*/
	}
	else if ((PSD_SUM_MAX > bufIndex) && (LOW_FOUR_CHAR == psdFlag))
	{
		retVal = PsdDataStru[bufIndex].psdDoorIStateTwo;/*低四字节*/
	}
	else
	{
		retVal = UINT32_MAX;
	}
	return retVal;
}

/*
* 功能描述： 设置指定ID屏蔽门，单扇门开关状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
*			 const UINT32 doorStateOne, 单扇门开关状态高四字节
* *			 const UINT32 doorStateTwo, 单扇门开关状态低四字节
* 返回值  ： 无
*/
void SetPsdDoorState(const UINT16 doorId, const UINT32 doorStateOne, const UINT32 doorStateTwo)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
	if (PSD_SUM_MAX > bufIndex)
	{
		PsdDataStru[bufIndex].psdDoorsStateOne = doorStateOne;
		PsdDataStru[bufIndex].psdDoorsStateTwo = doorStateTwo;
	}
	else
	{
		/*不处理*/
	}

}

/*
* 功能描述： 获取指定ID屏蔽门,单扇门开关状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
*			 UINT8 psdFlag,前四个字节还是后四个字节(0u为高四个字节，1u为低四个字节)
* 返回值  ： 0: 获取数据失败
*			>0: 屏蔽门单扇门开关状态
*/
UINT32 GetPsdDoorState(const UINT16 doorId, UINT8 psdFlag)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT32 retVal = UINT32_MAX;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if ((PSD_SUM_MAX > bufIndex) && (HIGH_FOUR_CHAR == psdFlag))
	{
		retVal = PsdDataStru[bufIndex].psdDoorsStateOne;/*高四字节*/
	}
	else if ((PSD_SUM_MAX > bufIndex) && (LOW_FOUR_CHAR == psdFlag))
	{
		retVal = PsdDataStru[bufIndex].psdDoorsStateTwo;/*低四字节*/
	}
	else
	{
		retVal = UINT32_MAX;
	}
	return retVal;
}


/*
* 功能描述： 设置指定ID开门故障状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
*			 const UINT8 openErrState,开门故障状态
* 返回值  ： 无
*/
void SetOpenErrState(const UINT16 doorId, const UINT8 openErrState)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
	if (PSD_SUM_MAX > bufIndex)
	{
		if ((PSD_OPEN_CLOSE_NORMAL == openErrState) || (PSD_OPEN_CLOSE_ERROR == openErrState))
		{
			PsdDataStru[bufIndex].psdOpenErrState = openErrState;
		}
		else
		{/*不处理*/
		}
	}
}

/*
* 功能描述： 设置指定ID关门故障状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
*			 const UINT8 closeErrState,关门故障状态
* 返回值  ： 无
*/
void SetCloseErrState(const UINT16 doorId, const UINT8 closeErrState)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
	if (PSD_SUM_MAX > bufIndex)
	{
		if ((PSD_OPEN_CLOSE_NORMAL == closeErrState) || (PSD_OPEN_CLOSE_ERROR == closeErrState))
		{
			PsdDataStru[bufIndex].psdCloseErrState = closeErrState;
		}
		else
		{/*不处理*/
		}
	}
}

/*
* 功能描述： 获取指定ID开门故障状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
* 返回值  ： UINT8 开门故障状态
*/
UINT8 GetOpenErrState(const UINT16 doorId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = PSD_OPEN_CLOSE_ERROR;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
	if (PSD_SUM_MAX > bufIndex)
	{
		retVal = PsdDataStru[bufIndex].psdOpenErrState;
	}
	else
	{/*不处理*/
	}

	return retVal;
}

/*
* 功能描述： 获取指定ID关门故障状态
* 参数说明： const UINT16 doorId, 屏蔽门ID
* 返回值  ： UINT8 关门故障状态
*/
UINT8 GetCloseErrState(const UINT16 doorId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT8 retVal = PSD_OPEN_CLOSE_ERROR;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/
	if (PSD_SUM_MAX > bufIndex)
	{
		retVal = PsdDataStru[bufIndex].psdCloseErrState;
	}
	else
	{/*不处理*/
	}

	return retVal;
}

/*
* 功能描述：获取指定ID屏蔽门门关继电器落下起始周期号
* 参数说明：const UINT16 doorId  屏蔽门ID
* 返 回 值：门开继电器落下起始周期号
* Created By LQ 2025.06.26
*/
UINT32 GetPsdRelayDownCycNum(const UINT16 doorId)
{
	UINT16 bufIndex = 0u;  /*数组下标*/
	UINT32 retVal = CI_ERROR;

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		retVal = PsdDataStru[bufIndex].dwPsdRelayDownCycNum;
	}
	else
	{
		retVal = CI_ERROR;
	}

	return retVal;
}

/*
* 功能描述：设置指定ID屏蔽门门关继电器落下起始周期号
* 参数说明：const UINT16 doorId  屏蔽门ID
*           const UINT32 startCycNum  起始周期号
* 返 回 值：无
* Created By LQ 2025.06.26
*/
void SetPsdRelayDownCycNum(const UINT16 doorId, const UINT32 startCycNum)
{
	UINT16 bufIndex = 0u;  /*数组下标*/

	bufIndex = GetPsdConfigBufIndex(doorId);  /*获取屏蔽门数组下标*/

	if (bufIndex < PSD_SUM_MAX)
	{
		PsdDataStru[bufIndex].dwPsdRelayDownCycNum = startCycNum;
	}
	else
	{
		/*不处理*/
	}
}