#include "EnvelopeManage.h"


/*- 静态数据定义 */
static UINT8 gs_ELMWorkFlag = ELM_WORK_ERROR;     /** 包络正常工作标志*/
static EnvelopeStruct gs_arEnvelope[ENVELOPE_SUM_MAX] = {0u};         /*包络存储空间*/
static EnvelopeMapStruct gs_arACRelEnvelopeMap[AXIS_SECTION_SUM_MAX] = {0u};    /*计轴关联的包络映射表*/
static TrainMapStruct gs_arTrainRelEnvelopeMap[LINE_MAX_TRAIN] = {0u};     /*列车ID转换成列车关联的包络映射表索引数组*/

/**
 * @brief  检测需要操作的目标内存区是否在可用内存区内
 * @param[in] MemAreaStruct targetArea  需要操作的目标内存区
 * @param[in] MemAreaStruct valiArea  可用内存区
 * @return CI_SUCCESS 需要操作的内存区正确，返回成功
 *         CI_ERROR   需要操作的内存区错误，返回失败
 * @note 需要操作的目标内存区完全包含于可用内存区时，则认为合法；
		 可用内存区采用是一个左闭右开区间
		 目标内存区采用的是一个左闭右开区间
 */
UINT8 elm_IsMemAreaOK(MemAreaStruct targetArea,MemAreaStruct valiArea)
{
	/*- 局部变量定义*/
	UINT8 ret = CI_ERROR;   /*函数返回值*/

	/** 判断内存操作区是否在可用内存区内 */
	if ((targetArea.pStartVaild >= valiArea.pStartVaild) && 
		(targetArea.pStartVaild <= targetArea.pEndVaild) &&
		(targetArea.pEndVaild <= valiArea.pEndVaild)) 
	{
		/** 内存操作区在可用内存区内，设置返回值为正确 */
		ret = CI_SUCCESS;
	}
	else
	{
		/** 内存操作区不在可用内存区内，返回错误 */
	}

	/** 返回函数执行结果*/
	return ret;
}

/**
 * @brief 检测包络内存区操作是否正确
 * @param[in] EnvelopeStruct *pEnvelope 需要操作的内存区起始地址
 * @param[in] UINT16 size 需要操作的内存区个数
 * @return CI_SUCCESS 需要操作的内存区正确，返回成功
 *         CI_ERROR   需要操作的内存区错误，返回失败
 * @note 通过指针地址及大小计算需要操作的包络内存区是否在可用的地址空间
 */
UINT8 elm_IsEnvelopeMemOK(IN EnvelopeStruct *pEnvelope, UINT16 size)
{
	/*- 局部变量定义*/
	UINT8 ret = CI_ERROR;
	MemAreaStruct valiArea = {0u};   /*可用内存区*/
	MemAreaStruct targetArea = {0u};  /*目标内存区*/

	/** 判断入口参数是否正确 */
	if (NULL == pEnvelope)
	{
		/** 入口参数错误，返回错误*/
	}
	else
	{
		/*- 设置可用地址空间 */
		valiArea.pStartVaild = &gs_arEnvelope[0];
		valiArea.pEndVaild = &gs_arEnvelope[ENVELOPE_SUM_MAX];

		/*- 设置目标内存空间*/
		targetArea.pStartVaild = pEnvelope;
		targetArea.pEndVaild = pEnvelope + size;

		/*- 进行内存区合法性检测*/
		ret = elm_IsMemAreaOK(targetArea,valiArea);
	}
	
	/** 返回函数执行结果*/
	return ret;

}

/**
 * @brief 检测计轴关联的包络映射表内存区操作是否正确
 * @param[in] EnvelopeMapStruct *pRelEnvelope 需要操作的内存区起始地址
 * @param[in] UINT16 size 需要操作的内存区个数
 * @return CI_SUCCESS 需要操作的内存区正确，返回成功
 *         CI_ERROR   需要操作的内存区错误，返回失败
 * @note 通过指针地址及大小计算需要操作的包络内存区是否在可用的地址空间
 */
UINT8 elm_IsACRelEnvelopeMapMemOK(IN EnvelopeMapStruct *pRelEnvelope, UINT16 size)
{
	/*- 局部变量定义*/
	UINT8 ret = CI_ERROR;
	MemAreaStruct valiArea = {0u};   /*可用内存区*/
	MemAreaStruct targetArea = {0u};  /*目标内存区*/

	/** 判断入口参数是否正确 */
	if (NULL == pRelEnvelope)
	{
		/** 入口参数错误，返回错误*/
	}
	else
	{
		/*- 设置可用地址空间 */
		valiArea.pStartVaild = &gs_arACRelEnvelopeMap[0];
		valiArea.pEndVaild = &gs_arACRelEnvelopeMap[AXIS_SECTION_SUM_MAX];

		/*- 设置目标内存空间*/
		targetArea.pStartVaild = pRelEnvelope;
		targetArea.pEndVaild = pRelEnvelope + size;

		/*- 进行内存区合法性检测*/
		ret = elm_IsMemAreaOK(targetArea,valiArea);
	}
	
	/** 返回函数执行结果*/
	return ret;

}


/**
 * @brief 检测计轴关联的包络映射表内存区操作是否正确
 * @param[in] TrainMapStruct *pRelEnvelope 需要操作的内存区起始地址
 * @param[in] UINT16 size 需要操作的内存区个数
 * @return CI_SUCCESS 需要操作的内存区正确，返回成功
 *         CI_ERROR   需要操作的内存区错误，返回失败
 * @note 通过指针地址及大小计算需要操作的包络内存区是否在可用的地址空间
 */
UINT8 elm_IsTrainRelEnvelopeMapMemOK(IN TrainMapStruct *pRelEnvelope, UINT16 size)
{
	/*- 局部变量定义*/
	UINT8 ret = CI_ERROR;
	MemAreaStruct valiArea = {0u};   /*可用内存区*/
	MemAreaStruct targetArea = {0u};  /*目标内存区*/

	/** 判断入口参数是否正确 */
	if (NULL == pRelEnvelope)
	{
		/** 入口参数错误，返回错误*/
	}
	else
	{
		/*- 设置可用地址空间 */
		valiArea.pStartVaild = &gs_arTrainRelEnvelopeMap[0];
		valiArea.pEndVaild = &gs_arTrainRelEnvelopeMap[LINE_MAX_TRAIN];

		/*- 设置目标内存空间*/
		targetArea.pStartVaild = pRelEnvelope;
		targetArea.pEndVaild = pRelEnvelope + size;

		/*- 进行内存区合法性检测*/
		ret = elm_IsMemAreaOK(targetArea,valiArea);
	}
	
	/** 返回函数执行结果*/
	return ret;

}

/**
 * @brief 判断索引是否正确
 * @param[in] UINT16 EnvelopeID 包络索引ID
 * @param[in] UINT16 size 需要操作的内存区个数
 * @return CI_SUCCESS 包络ID合法，返回成功
 *         CI_ERROR   包络ID非法，返回失败
 * @note 无
 */
UINT8 elm_IsEnvelopeIDOK(UINT16 EnvelopeID)
{
	/*- 局部变量定义 */
	UINT8 ret = CI_ERROR;     /*函数返回值*/

	/** 判断包络ID是否合法*/
	if ((ENVELOPE_UNVAILD_INDEX != EnvelopeID) && (EnvelopeID < ENVELOPE_SUM_MAX))
	{
		/** ID合法，设置返回值为成功*/
		ret = CI_SUCCESS;
	}
	else
	{
		/** ID不合法*/
	}
	return ret;
}

/**
 * @brief 判断包络是否存在
 * @param[in] UINT16 EnvelopeID 包络ID
 * @return ENVELOPE_UNEXIT 包络不存在
 *         ENVELOPE_EXIT   包络存在
 * @note 通过判断包络存储空间是否被占用，判断包络是否存在
 */
UINT8 elm_IsEnvelopeExit(UINT16 EnvelopeID)
{
	/*- 局部变量定义 */
	UINT8 ret = ENVELOPE_UNEXIT;     /*函数返回值*/
	UINT8 funRet = CI_ERROR;

	/** 判断包络ID是否正确 */
	funRet = elm_IsEnvelopeIDOK(EnvelopeID);

	/*- 包络ID正确则返回包络空间是否存在标识*/
	if (CI_SUCCESS == funRet)
	{
		ret = gs_arEnvelope[EnvelopeID].exitFlag;
	}
	else
	{
		/*不处理*/
	}

	return ret;
}

/**
 * @brief 判断包络信息是否正确
 * @param[in] const EnvelopeMapStruct *pRelEnvelope 包络信息
 * @param[in] UINT16 EnvelopeID 包络ID
 * @return CI_SUCCESS 包络ID合法，返回成功
 *         CI_ERROR   包络ID非法，返回失败
 * @note 无
 */
UINT8 elm_IsEnvelopeInfoOk(IN const EnvelopeStruct *pEnvelope,UINT16 EnvelopeID)
{
	/*- 局部变量定义 */
	UINT8 ret = CI_ERROR;

	/** 判断入口参数是否正确*/
	if (NULL == pEnvelope)
	{
		/** 指针非法*/
	}
	else
	{
		/** 判断包络信息是否合法 */
		if ((pEnvelope->id == EnvelopeID) && 
			((TYPE_UKT_ENVELOPE == pEnvelope->envelopeType) || (TYPE_UCT_ENVELOPE == pEnvelope->envelopeType) || (TYPE_CT_ENVELOPE == pEnvelope->envelopeType)) &&
			(pEnvelope->ACCnt > 0u))
		{
			/** 合法，设置返回值为正确*/
			ret = CI_SUCCESS;
		}
		else
		{
			/** 非法，设置返回值为错误*/
			ret = CI_ERROR;
		}
	}

	/** 函数返回 */
	return ret;
}


/**
 * @brief 重置包络存储空间
 * @param[in] EnvelopeStruct *pEnvelope 需要操作的内存区起始地址
 * @param[in] UINT16 size 需要操作的内存区个数
 * @return CI_SUCCESS 需要操作的内存区正确，返回成功
 *         CI_ERROR   需要操作的内存区错误，返回失败
 * @note 将指定的包络空间初始化成0
 */
UINT8 elm_ResetEnvelope(INOUT EnvelopeStruct *pEnvelope, UINT16 size)
{
	/*- 局部变量定义*/
	UINT8 ret = CI_ERROR;

	/*- 指定的区域是否合法 */
	ret = elm_IsEnvelopeMemOK(pEnvelope,size);

	/** 判读是否可以进行初始化*/
	if (CI_SUCCESS == ret)
	{
		/** 初始化对应内存区域为0*/
		(void)CommonMemSet(pEnvelope, (UINT32)(sizeof(EnvelopeStruct)*size),0u, (UINT32)(sizeof(EnvelopeStruct)*size));
		ret = CI_SUCCESS;
	}
	else
	{
		/** 内存区非法，不进行写操作*/
	}

	/** 返回函数执行结果*/
	return ret;
}

/**
 * @brief 重置计轴关联的包络映射表
 * @param[in] EnvelopeMapStruct *pEnvelope 需要操作的内存区起始地址
 * @param[in] UINT16 size 需要操作的内存区个数
 * @return CI_SUCCESS 需要操作的内存区正确，返回成功
 *         CI_ERROR   需要操作的内存区错误，返回失败
 * @note 将指定的包络空间初始化成0
 */
UINT8 elm_ResetACRelEnvelopeMap(INOUT EnvelopeMapStruct *pRelEnvelopeMap, UINT16 size)
{
	/*- 局部变量定义*/
	UINT8 ret = CI_ERROR;

	/*- 指定的区域是否合法 */
	ret = elm_IsACRelEnvelopeMapMemOK(pRelEnvelopeMap,size);

	/** 判读是否可以进行初始化*/
	if (CI_SUCCESS == ret)
	{
		/** 初始化对应内存区域为0*/
		(void)CommonMemSet(pRelEnvelopeMap, (UINT32)(sizeof(EnvelopeMapStruct)*size),0u, (UINT32)(sizeof(EnvelopeMapStruct)*size));
		ret = CI_SUCCESS;
	}
	else
	{
		/** 内存区非法，不进行写操作*/
	}

	/** 返回函数执行结果*/
	return ret;
}

/**
 * @brief 重置列车关联的包络映射表
 * @param[in] UINT16 *pEnvelope 需要操作的内存区起始地址
 * @param[in] UINT16 size 需要操作的内存区个数
 * @return CI_SUCCESS 需要操作的内存区正确，返回成功
 *         CI_ERROR   需要操作的内存区错误，返回失败
 * @note 将指定的包络空间初始化成0
 */
UINT8 elm_ResetTrainRelEnvelopeMap(INOUT TrainMapStruct *pRelEnvelopeMap, UINT16 size)
{
	/*- 局部变量定义*/
	UINT8 ret = CI_ERROR;

	/*- 指定的区域是否合法 */
	ret = elm_IsTrainRelEnvelopeMapMemOK(pRelEnvelopeMap,size);

	/** 判读是否可以进行初始化*/
	if (CI_SUCCESS == ret)
	{
		/** 初始化列车ID转换成列车关联的包络映射表索引数组*/
		(void)CommonMemSet(pRelEnvelopeMap, (UINT32)(sizeof(TrainMapStruct)*size),0u, (UINT32)(sizeof(TrainMapStruct)*size));
		ret = CI_SUCCESS;
	}
	else
	{
		/** 内存区非法，不进行写操作*/
	}

	/** 返回函数执行结果*/
	return ret;
}


/**
 * @brief 初始化包络存储空间
 * @return CI_SUCCESS 需要操作的内存区正确，返回成功
 *         CI_ERROR   需要操作的内存区错误，返回失败
 * @note 将指定的包络空间初始化成0
 */
UINT8 elm_InitEnvelope(void)
{
	return elm_ResetEnvelope(&gs_arEnvelope[0],ENVELOPE_SUM_MAX);
}

/**
 * @brief 初始化计轴关联的包络映射表
 * @return CI_SUCCESS 需要操作的内存区正确，返回成功
 *         CI_ERROR   需要操作的内存区错误，返回失败
 * @note 将指定的包络空间初始化成0
 */
UINT8 elm_InitACRelEnvelopeMap(void)
{
	return elm_ResetACRelEnvelopeMap(&gs_arACRelEnvelopeMap[0],AXIS_SECTION_SUM_MAX);
}

/**
 * @brief 初始化列车关联的包络映射表
 * @return CI_SUCCESS 需要操作的内存区正确，返回成功
 *         CI_ERROR   需要操作的内存区错误，返回失败
 * @note 将指定的包络空间初始化成0
 */
UINT8 elm_InitTrainRelEnvelopeMap(void)
{
	return elm_ResetTrainRelEnvelopeMap(&gs_arTrainRelEnvelopeMap[0],LINE_MAX_TRAIN);
}


/**
 * @brief 设置包络管理模块是否可正常处理
 * @param[in] UINT8 workFlag
 * @note 无
 */
void elm_SetELMWorkFlag(UINT8 workFlag)
{
	if (ELM_WORK_OK == workFlag)
	{
		gs_ELMWorkFlag = workFlag;
	}
	else
	{
		gs_ELMWorkFlag = ELM_WORK_ERROR;
	}

}



/**
 * @brief 设置包络存储空间可用标识
 * @param[in] UINT16 index 数组下标
 * @param[in] UINT8 value 需要设置的值
 * @return CI_SUCCESS 设置成功，返回成功
 *         CI_ERROR   设置错误，返回失败
 * @note 
 */
UINT8 elm_SetEnvelopeValidFlag(UINT16 index,UINT8 value)
{
	/*- 局部变量定义*/
	UINT8 ret = CI_ERROR;    /*返回值*/


	/**入口参数合法性校验*/
	if ((0u != index) && (index < ENVELOPE_SUM_MAX) && 
		((ENVELOPE_UNEXIT == value) || (ENVELOPE_EXIT == value)))
	{
		/** 设置包络存储空间 */
		gs_arEnvelope[index].exitFlag = value;
		ret = CI_SUCCESS;
	}
	else
	{
		/** 入口参数校验失败，不进行设置*/
	}
	return ret;
}


/**
 * @brief 更新计轴区段关联的包络
 * @param[in] UINT8 flag 操作标识
 * @param[in] UINT16 buffIndex 计轴数组索引
 * @param[in] UINT16 envelopeID 包络ID
 * @return CI_SUCCESS 删除成功，返回成功
 *         CI_ERROR   删除错误，返回失败
 * @note 包络的ID和存储空间数组索引保持一致
         计轴区段映射到存储空间，使用计轴区段的索引
 */
UINT8 elm_SetACRelEnvelopeMap(UINT8 flag,UINT16 ACIndex,UINT16 envelopeID)
{
	/*- 局部变量定义 */
	UINT8 ret = CI_ERROR;
	UINT8 cycle = 0u;
	UINT8 continueCycle = 0u;
	UINT16 tempEnvelopeID = 0u;

	/** 入口参数校验 */
	if (((OP_ADD != flag) && (OP_DEL != flag)) ||
		(ACIndex >= AXIS_SECTION_SUM_MAX))
	{
		/** 入口参数错误，返回错误*/
	}
	else
	{
		if (OP_ADD == flag)
		{
			/** 计轴上存在包络则不更新*/
			for (cycle = 0u; cycle < gs_arACRelEnvelopeMap[ACIndex].envelopeCnt;cycle++)
			{
				tempEnvelopeID = gs_arACRelEnvelopeMap[ACIndex].envelopeId[cycle];
				if (tempEnvelopeID == envelopeID)
				{
					break;
				}
			}

			if ((cycle == gs_arACRelEnvelopeMap[ACIndex].envelopeCnt) && (gs_arACRelEnvelopeMap[ACIndex].envelopeCnt < (SECTION_REL_ENVELOPE_SUM_MAX - 1u)))
			{
				gs_arACRelEnvelopeMap[ACIndex].envelopeId[cycle] = envelopeID;
				gs_arACRelEnvelopeMap[ACIndex].envelopeCnt++;
			}
			else
			{
				/** 无需处理*/
			}
			ret = CI_SUCCESS;
		}
		else
		{
			/** 计轴上存在包络则不更新*/
			for (cycle = 0u; cycle < gs_arACRelEnvelopeMap[ACIndex].envelopeCnt;cycle++)
			{
				tempEnvelopeID = gs_arACRelEnvelopeMap[ACIndex].envelopeId[cycle];
				if (tempEnvelopeID == envelopeID)
				{
					gs_arACRelEnvelopeMap[ACIndex].envelopeId[cycle] = 0u;
					break;
				}
			}

			/** 继续挪动数据*/
			if (cycle == gs_arACRelEnvelopeMap[ACIndex].envelopeCnt)
			{
				/** 计轴上不存在需要删除的序列，错误*/;
			}
			else if (cycle == (gs_arACRelEnvelopeMap[ACIndex].envelopeCnt - 1u))
			{
				/** 无需挪动数据,数量减1*/
				gs_arACRelEnvelopeMap[ACIndex].envelopeCnt--;
				ret = CI_SUCCESS;
			}
			else
			{
				/** 挪动数据*/
				for (continueCycle = cycle; continueCycle < (gs_arACRelEnvelopeMap[ACIndex].envelopeCnt - 1u); continueCycle++)
				{
					gs_arACRelEnvelopeMap[ACIndex].envelopeId[continueCycle] = gs_arACRelEnvelopeMap[ACIndex].envelopeId[continueCycle + 1U];
				}

				/** 数量减1*/
				gs_arACRelEnvelopeMap[ACIndex].envelopeCnt--;
				ret = CI_SUCCESS;
			}
		}
	}	
	return ret;
}

/**
 * @brief 更新列车关联的包络
 * @param[in] UINT16 trainID 列车ID
 * @param[in] UINT16 envelopeID 包络ID
 * @return CI_SUCCESS 删除成功，返回成功
 *         CI_ERROR   删除错误，返回失败
 * @note 
 */
UINT8 elm_SetTrainRelEnvelopeMap(UINT8 flag,UINT16 trainID,UINT16 envelopeID)
{
	/*- 局部变量定义*/
	UINT8 ret = CI_ERROR;
	UINT8 cycle = 0u;
	UINT8 continueCycle = 0u;
	UINT16 tempEnvelopeID = 0u;

	/** 入口参数校验 */
	ASSERT_RET_VALUE((OP_ADD != flag) && (OP_DEL != flag),ret,0x80000000u);
	ASSERT_RET_VALUE((0u == trainID) || (trainID >= LINE_MAX_TRAIN),ret,0x40000000u);
	ASSERT_RET_VALUE(ENVELOPE_UNVAILD_INDEX == envelopeID,ret,0x20000000u);

	if (OP_ADD == flag)
	{
		/** 计轴上存在包络则不更新*/
		for (cycle = 0u; cycle < gs_arTrainRelEnvelopeMap[trainID].envelopeCnt;cycle++)
		{
			tempEnvelopeID = gs_arTrainRelEnvelopeMap[trainID].envelopeId[cycle];
			if (tempEnvelopeID == envelopeID)
			{
				break;
			}
		}

		if ((cycle == gs_arTrainRelEnvelopeMap[trainID].envelopeCnt) && (gs_arTrainRelEnvelopeMap[trainID].envelopeCnt < (TRAIN_REL_ENVELOPE_SUM_MAX - 1u)))
		{
			gs_arTrainRelEnvelopeMap[trainID].envelopeId[cycle] = envelopeID;
			gs_arTrainRelEnvelopeMap[trainID].envelopeCnt++;
			ret = CI_SUCCESS;
		}
		else
		{
			/** 无需处理*/
		}
	}
	else 
	{
		/** 计轴上存在包络则不更新*/
		for (cycle = 0u; cycle < gs_arTrainRelEnvelopeMap[trainID].envelopeCnt;cycle++)
		{
			tempEnvelopeID = gs_arTrainRelEnvelopeMap[trainID].envelopeId[cycle];
			if (tempEnvelopeID == envelopeID)
			{
				gs_arTrainRelEnvelopeMap[trainID].envelopeId[cycle] = 0u;
				break;
			}
		}

		/** 继续挪动数据*/
		if (cycle == gs_arTrainRelEnvelopeMap[trainID].envelopeCnt)
		{
			/** 计轴上不存在需要删除的序列，错误*/;
		}
		else if (cycle == (gs_arTrainRelEnvelopeMap[trainID].envelopeCnt - 1u))
		{
			/** 无需挪动数据,数量减1*/
			gs_arTrainRelEnvelopeMap[trainID].envelopeCnt--;
			ret = CI_SUCCESS;
		}
		else
		{
			/** 挪动数据*/
			for (continueCycle = cycle; continueCycle < (gs_arTrainRelEnvelopeMap[trainID].envelopeCnt - 1u); continueCycle++)
			{
				gs_arTrainRelEnvelopeMap[trainID].envelopeId[continueCycle] = gs_arTrainRelEnvelopeMap[trainID].envelopeId[continueCycle + 1U];
			}

			/** 数量减1*/
			gs_arTrainRelEnvelopeMap[trainID].envelopeCnt--;
			ret = CI_SUCCESS;
		}
	}

	/** 函数返回*/
	return ret;
}

/**
 * @brief 在指定空间上存储包络
 * @param[in] const EnvelopeStruct *pSrcEnnelope 需要存储的包络地址
 * @param[in] UINT16 index 需要存储到目标内存区域索引
 * @return CI_SUCCESS 设置成功，返回成功
 *         CI_ERROR   设置错误，返回失败
 * @note 
 */
UINT8 elm_SetEnvelopeByIndex(IN const EnvelopeStruct *pSrcEnnelope,UINT16 index)
{
	UINT8 ret = CI_ERROR;

	/** 检查索引是否正确 */
	ret = elm_IsEnvelopeIDOK(index);

	/** 判断入口参数是否正确 */
	if ((NULL == pSrcEnnelope) || (CI_ERROR == ret))
	{
		/** 入口参数校验失败 */
	}
	else
	{
		/** 设置内存区 */
		ret = CommonMemCpy(&gs_arEnvelope[index], (UINT32)sizeof(EnvelopeStruct),pSrcEnnelope, (UINT32)sizeof(EnvelopeStruct));

		if (CI_SUCCESS == ret)
		{
			/** 设置包络空间被使用 */
			ret = elm_SetEnvelopeValidFlag(index,ENVELOPE_EXIT);
		}
	}
	return ret;
}


/**
 * @brief 设置包络的起点和终点位置
 * @param[in] UINT16 envelopid 包络ID
 * @param[in] LOD_STRU startPoint 起点位置
 * @param[in] LOD_STRU endPoint 终点位置
 * @return CI_SUCCESS 设置成功，返回成功
 *         CI_ERROR   设置错误，返回失败
 * @note 无
 */
UINT8 elm_SetEnvelopeLoc(UINT16 envelopid,LOD_STRU startPoint,LOD_STRU endPoint)
{
	/*- 局部变量定义*/ 
	UINT8 ret = CI_ERROR;
	UINT8 funRet = CI_ERROR;

	/** 判断包络ID是否正确 */
	funRet = elm_IsEnvelopeIDOK(envelopid);

	if ((CI_SUCCESS == funRet) && (gs_arEnvelope[envelopid].id == envelopid))
	{
		gs_arEnvelope[envelopid].startPos = startPoint;
		gs_arEnvelope[envelopid].endPos = endPoint;
		ret = CI_SUCCESS;
	}
	else
	{
		/** 入口参数不正确*/
	}
	return ret;
}

/**
 * @brief 设置包络的起点方向
 * @param[in] UINT16 envelopid 包络ID
 * @param[in] UINT8 cStartDir 起点方向
 * @return CI_SUCCESS 设置成功，返回成功
 *         CI_ERROR   设置错误，返回失败
 */
UINT8 elm_SetEnvelopeStartDir(UINT16 envelopid, UINT8 cStartDir)
{
	/*- 局部变量定义*/
	UINT8 ret = CI_ERROR;
	UINT8 funRet = CI_ERROR;

	/** 判断包络ID是否正确 */
	funRet = elm_IsEnvelopeIDOK(envelopid);

	if ((CI_SUCCESS == funRet) && (gs_arEnvelope[envelopid].id == envelopid)
		&& ((EMAP_SAME_DIR == cStartDir) || (EMAP_CONVER_DIR == cStartDir)))
	{
		gs_arEnvelope[envelopid].startPos.Dir = cStartDir;
		ret = CI_SUCCESS;
	}
	else
	{
		/** 入口参数不正确*/
	}

	return ret;
}

/**
 * @brief 设置包络的终点方向
 * @param[in] UINT16 envelopid 包络ID
 * @param[in] UINT8 cEndDir 终点方向
 * @return CI_SUCCESS 设置成功，返回成功
 *         CI_ERROR   设置错误，返回失败
 */
UINT8 elm_SetEnvelopeEndDir(UINT16 envelopid, UINT8 cEndDir)
{
	/*- 局部变量定义*/
	UINT8 ret = CI_ERROR;
	UINT8 funRet = CI_ERROR;

	/** 判断包络ID是否正确 */
	funRet = elm_IsEnvelopeIDOK(envelopid);

	if ((CI_SUCCESS == funRet) && (gs_arEnvelope[envelopid].id == envelopid)
		&& ((EMAP_SAME_DIR == cEndDir) || (EMAP_CONVER_DIR == cEndDir)))
	{
		gs_arEnvelope[envelopid].endPos.Dir = cEndDir;
		ret = CI_SUCCESS;
	}
	else
	{
		/** 入口参数不正确*/
	}

	return ret;
}

/**
 * @brief 设置包络的计轴区段信息
 * @param[in] UINT16 envelopid 包络ID
 * @param[in] LOD_STRU startPoint 起点位置
 * @param[in] LOD_STRU endPoint 终点位置
 * @return CI_SUCCESS 设置成功，返回成功
 *         CI_ERROR   设置错误，返回失败
 * @note 无
 */
UINT8 elm_SetEnvelopeACInfo(UINT16 envelopid,UINT8 acCnt,IN const UINT16 acID[SECTION_IN_ENVELOPE_SUM_MAX])
{
	/*- 局部变量定义*/ 
	UINT8 ret = CI_ERROR;
	UINT8 funRet = CI_ERROR;

	/** 判断包络ID是否正确 */
	funRet = elm_IsEnvelopeIDOK(envelopid);

	/** 判断是否可以设置信息*/
	if ((CI_SUCCESS == funRet) && (gs_arEnvelope[envelopid].id == envelopid))
	{
		/*- 更新计轴信息 */
		(void)CommonMemSet(gs_arEnvelope[envelopid].ACID, (UINT32)(sizeof(UINT16) * gs_arEnvelope[envelopid].ACCnt), 0u , (UINT32)(sizeof(UINT16) * gs_arEnvelope[envelopid].ACCnt));
		(void)CommonMemCpy(gs_arEnvelope[envelopid].ACID, (UINT32)(sizeof(UINT16) * SECTION_IN_ENVELOPE_SUM_MAX) , acID , (UINT32)(sizeof(UINT16) * acCnt));
		gs_arEnvelope[envelopid].ACCnt = acCnt;
		ret = CI_SUCCESS;
	}
	else
	{
		/** 入口参数错误 */
	}
	return ret;
}


/**
 * @brief 设置包络前方列车
 * @param[in] INT16 envelopid 包络id
 * @param[in] UINT16 tainid 列车id
 * @return CI_SUCCESS 设置成功，返回成功
 *         CI_ERROR   设置错误，返回失败
 * @note 无
 */
UINT8 elm_SetEnvelopeHeadTrainID(UINT16 envelopid,UINT16 tainid)
{
	/*- 局部变量定义*/ 
	UINT8 ret = CI_ERROR;
	UINT8 funRet = CI_ERROR;

	/** 判断包络ID是否正确 */
	funRet = elm_IsEnvelopeIDOK(envelopid);

	/** 判断是否可以设置信息*/
	if ((CI_SUCCESS == funRet) && (gs_arEnvelope[envelopid].id == envelopid))
	{
		gs_arEnvelope[envelopid].headTrainID = tainid;
		ret = CI_SUCCESS;
	}
	else
	{
		/** 入口参数错误 */
	}
	return ret;
}

/**
 * @brief 设置包络后方列车
 * @param[in] INT16 envelopid 包络id
 * @param[in] UINT16 tainid 列车id
 * @return CI_SUCCESS 设置成功，返回成功
 *         CI_ERROR   设置错误，返回失败
 * @note 无
 */
UINT8 elm_SetEnvelopeTailTrainID(UINT16 envelopid,UINT16 tainid)
{
	/*- 局部变量定义*/ 
	UINT8 ret = CI_ERROR;
	UINT8 funRet = CI_ERROR;

	/** 判断包络ID是否正确 */
	funRet = elm_IsEnvelopeIDOK(envelopid);

	/** 判断是否可以设置信息*/
	if ((CI_SUCCESS == funRet) && (gs_arEnvelope[envelopid].id == envelopid))
	{
		gs_arEnvelope[envelopid].tailTrainID = tainid;
		ret = CI_SUCCESS;
	}
	else
	{
		/** 入口参数错误 */
	}
	return ret;
}


/**
 * @brief 设置包络类型 
 * @param[in] UINT16 envelopeId 包络id 
 * @param[in] UINT8 envelopType 包络类型
 * @param[out] 无
 * @return CI_SUCCESS 设置成功，返回成功
 *         CI_ERROR   设置错误，返回失败
 * @note 无
 */
UINT8 elm_SetEnvelopeType(UINT16 envelopeId,UINT8 envelopType)
{
	/*- 局部变量定义*/ 
	UINT8 ret = CI_ERROR;
	UINT8 funRet = CI_ERROR;

	/** 判断包络ID是否正确 */
	funRet = elm_IsEnvelopeIDOK(envelopeId);

	/** 入口参数校验 */
	ASSERT_RET_VALUE(CI_ERROR == funRet,ret,0x80000000u);
	ASSERT_RET_VALUE((TYPE_UKT_ENVELOPE != envelopType) && (TYPE_UCT_ENVELOPE != envelopType) && (TYPE_CT_ENVELOPE != envelopType),ret,0x40000000u);


	/** 设置包络类型 */
	gs_arEnvelope[envelopeId].envelopeType = envelopType;
	ret = CI_SUCCESS;

	return ret;
}

/**
 * @brief 设置包络管理模块是否可正常处理
 * @return ELM_WORK_ERROR 不可正常工作
           ELM_WORK_OK 可正常工作
 * @note 无
 */
UINT8 elm_GetELMWorkFlag(void)
{
	return gs_ELMWorkFlag;
}


/**
 * @brief 获取可用的存储空间索引下标
 * @param[in] 
 * @param[out]
 * @return ENVELOPE_UNVAILD_INDEX  无可用的存储空间下标
		   非ENVELOPE_UNVAILD_INDEX  合法的可用的 存储空间下标
 * @note 
 */
UINT16 elm_GetEnvelopeValidIndex(void)
{
	/*- 局部变量定义*/
	UINT16 ret = ENVELOPE_UNVAILD_INDEX;    /** */
	UINT16 cycle = 0u;

	/** 查找可用的空间*/
	for (cycle = 1u; cycle < ENVELOPE_SUM_MAX;cycle++)
	{
		/**判断空间是否可用*/
		if (ENVELOPE_UNEXIT == gs_arEnvelope[cycle].exitFlag)
		{
			/**空间可用，返回可用空间的索引，并退出循环*/
			ret = cycle;
			break;
		}
		else
		{
			/**查找下一个可用的空间*/
		}
	}

	return ret;
}

/**
 * @brief 拷贝列车ID关联的包络信息映射表地址
 * @param[in] UINT16 trainID 列车ID
 * @return 关联的包络地址
 * @note 如果处理错误，返回NULL
 */
const TrainMapStruct * elm_GetTrainRelEnvelopeMapPtr(UINT16 trainID)
{
	const TrainMapStruct * ret = NULL;

	/** 入口参数校验 */
	ASSERT_RET_VALUE((0u == trainID) || (trainID >= LINE_MAX_TRAIN),ret,0x80000000u);

	ret = &gs_arTrainRelEnvelopeMap[trainID];
	return ret;
}


/**
 * @brief 获取列车ID关联的包络信息
 * @param[in] UINT16 trainID 列车ID
 * @param[out] UINT16 envelopeID[TRAIN_REL_ENVELOPE_SUM_MAX] 关联的包络ID
 * @return 关联的包络数量
 * @note 如果处理错误，返回TRAIN_REL_ENVELOPE_SUM_MAX
 */
UINT8 elm_GetRelELIdByTrainID(UINT16 trainID, UINT16 envelopeID[TRAIN_REL_ENVELOPE_SUM_MAX])
{
	UINT8 ret = TRAIN_REL_ENVELOPE_SUM_MAX;
	UINT8 cycle = 0u;

	/** 入口参数校验 */
	ASSERT_RET_VALUE((0u == trainID) || (trainID >= LINE_MAX_TRAIN),ret,0x80000000u);
	ASSERT_RET_VALUE(NULL == envelopeID,ret,0x40000000u);
	ASSERT_RET_VALUE(TRAIN_REL_ENVELOPE_SUM_MAX <= gs_arTrainRelEnvelopeMap[trainID].envelopeCnt,ret,0x10000000u);

	for (cycle = 0u; cycle < gs_arTrainRelEnvelopeMap[trainID].envelopeCnt;cycle++)
	{
		envelopeID[cycle] = gs_arTrainRelEnvelopeMap[trainID].envelopeId[cycle];
	}
	ret = gs_arTrainRelEnvelopeMap[trainID].envelopeCnt;
	return ret;
}

/**
 * @brief 获取列车ID关联的对应包络类型的包络信息
 * @param[in] UINT8 envelopeType 包络类型
 * @param[in] UINT16 trainID 列车ID
 * @param[out] UINT16 envelopeID[TRAIN_REL_ENVELOPE_SUM_MAX] 关联的包络ID
 * @return 关联的包络数量
 * @note 如果处理错误，返回TRAIN_REL_ENVELOPE_SUM_MAX
 */
UINT8 elm_GetRelELIdByTrainIDAndType(UINT8 envelopeType, UINT16 trainID, UINT16 envelopeID[TRAIN_REL_ENVELOPE_SUM_MAX])
{
	UINT8 ret = TRAIN_REL_ENVELOPE_SUM_MAX;
	UINT8 cycle = 0u;
	UINT8 sucFlag = 0u;
	UINT8 elmCnt = 0u;
	const EnvelopeStruct *pTemp = NULL;

	/** 入口参数校验 */
	ASSERT_RET_VALUE((0u == trainID) || (trainID >= LINE_MAX_TRAIN),ret,0x80000000u);
	ASSERT_RET_VALUE((TYPE_CT_ENVELOPE != envelopeType) && (TYPE_UCT_ENVELOPE != envelopeType),ret,0x40000000u);
	ASSERT_RET_VALUE(NULL == envelopeID,ret,0x20000000u);
	ASSERT_RET_VALUE(TRAIN_REL_ENVELOPE_SUM_MAX <= gs_arTrainRelEnvelopeMap[trainID].envelopeCnt,ret,0x10000000u);

	/** 清除缓存 */
	for (cycle = 0u; cycle < TRAIN_REL_ENVELOPE_SUM_MAX; cycle++)
	{
		envelopeID[cycle] = ENVELOPE_UNVAILD_INDEX;
	}

	/*- 查询包络关联的包络ID数量 */
	for (cycle = 0u; cycle < gs_arTrainRelEnvelopeMap[trainID].envelopeCnt;cycle++)
	{
		pTemp = elm_GetEnvelopeInfoPtr(gs_arTrainRelEnvelopeMap[trainID].envelopeId[cycle]);

		if (NULL == pTemp)
		{
			/** 列车关联的包络ID中间存在一个无效的包络ID */
			break;
		}
		else if (pTemp->envelopeType == envelopeType)
		{
			/** 记录列车关联的包络数量*/
			envelopeID[elmCnt] = gs_arTrainRelEnvelopeMap[trainID].envelopeId[cycle];
			elmCnt++;
		}
		else
		{
			/** 存在有效的包络ID，但不符合包络类型，继续遍历 */
			sucFlag = 1u;
		}
	}

	/** 处理返回值 */
	if (cycle == gs_arTrainRelEnvelopeMap[trainID].envelopeCnt)
	{
		if (TYPE_CT_ENVELOPE == envelopeType)
		{
			if ((0u == sucFlag) && ((0u == elmCnt) || (1u == elmCnt)))
			{
				ret = elmCnt;
			}
			else
			{
				/** 说明通信车包络是UCT包络 */
				ret = TRAIN_REL_ENVELOPE_SUM_MAX;
			}
		}
		else
		{
			ret = elmCnt;
		}
	}
	else
	{
		/** 处理失败 */
		for (cycle = 0u; cycle < TRAIN_REL_ENVELOPE_SUM_MAX;cycle++)
		{
			envelopeID[cycle] = ENVELOPE_UNVAILD_INDEX;
		}
		ret = TRAIN_REL_ENVELOPE_SUM_MAX;
	}

	return ret;
}

/**
 * @brief 获取计轴数组索引关联的包络个数和包络ID
 * @param[in] UINT16 ACIndex 计轴数组索引
 * @param[out] UINT16 envelopeId[SECTION_REL_ENVELOPE_SUM_MAX] 关联的包络ID
 * @return 关联的包络数量
 * @note 如果处理错误，返回SECTION_REL_ENVELOPE_SUM_MAX
 *		 集成 bug 20220420 wqm 增加超限检查
 */
UINT8 elm_GetACRelEnvelopeCnt(UINT16 ACIndex,INOUT UINT16 envelopeId[SECTION_REL_ENVELOPE_SUM_MAX])
{
	/*- 局部定义 */
	UINT8 ret = SECTION_REL_ENVELOPE_SUM_MAX;

	if ((0U == ACIndex) || (  AXIS_SECTION_SUM_MAX<=ACIndex) || (NULL == envelopeId))
	{
		/** 入口参数错误 */
	}
	else
	{
		/* 集成 bug 20220420 wqm 增加超限检查*/
		/** 判断包络个数是否超限*/
		if (SECTION_REL_ENVELOPE_SUM_MAX < gs_arACRelEnvelopeMap[ACIndex].envelopeCnt)
		{
			/** 包络个数超限时，也应该拷贝正常大小的包络ID，先清空返回数组*/
			(void)CommonMemSet(&envelopeId[0], (UINT32)(sizeof(UINT16) * SECTION_REL_ENVELOPE_SUM_MAX), 0u, (UINT32)(sizeof(UINT16) * SECTION_REL_ENVELOPE_SUM_MAX));

			/** 拷贝包络ID */
			(void)CommonMemCpy(&envelopeId[0], (UINT32)(sizeof(UINT16) * SECTION_REL_ENVELOPE_SUM_MAX), \
				&gs_arACRelEnvelopeMap[ACIndex].envelopeId[0], (UINT32)(sizeof(UINT16) * SECTION_REL_ENVELOPE_SUM_MAX));

			/** 返回处理失败*/
			ret = SECTION_REL_ENVELOPE_SUM_MAX;

		}
		/** 判断是否存在包络 */
		else if (0u != gs_arACRelEnvelopeMap[ACIndex].envelopeCnt)
		{
			/** 存在则先清空返回数组*/
			(void)CommonMemSet(&envelopeId[0], (UINT32)(sizeof(UINT16) * SECTION_REL_ENVELOPE_SUM_MAX), 0u , (UINT32)(sizeof(UINT16) * SECTION_REL_ENVELOPE_SUM_MAX));

			/** 拷贝包络ID */
			(void)CommonMemCpy(&envelopeId[0], (UINT32)(sizeof(UINT16) * gs_arACRelEnvelopeMap[ACIndex].envelopeCnt), \
				&gs_arACRelEnvelopeMap[ACIndex].envelopeId[0], (UINT32)(sizeof(UINT16) * gs_arACRelEnvelopeMap[ACIndex].envelopeCnt));
			
			/** 设置返回值*/
			ret = gs_arACRelEnvelopeMap[ACIndex].envelopeCnt;

		}
		else
		{
			/** 无需拷贝，设置返回值 */
			ret = gs_arACRelEnvelopeMap[ACIndex].envelopeCnt;
		}
		
	}

	/** 函数返回*/
	return ret;
}



/**
 * @brief 通过包络ID获取包络的信息
 * @param[in] UINT16 envelopeId 包络ID
 * @return 包络信息存储地址
 * @note 包络ID和包络索引一回事，包络指针只能使用，不能通过指针修改对应的值
         此函数无法实现出口不唯一，代码走查保证了没有问题 ，故通过注释消除代码规则不符合项
 */
const EnvelopeStruct* elm_GetEnvelopeInfoPtr(UINT16 envelopeId)
{
	/*- 局部变量定义 */
	UINT8 funRet = ENVELOPE_UNEXIT;
	const EnvelopeStruct* ret = NULL;

	/** 判断包络是否存在 */
	funRet = elm_IsEnvelopeExit(envelopeId);

	if (ENVELOPE_UNEXIT == funRet)
	{
		ret = NULL;
	}
	else
	{
		funRet = elm_IsEnvelopeInfoOk(&gs_arEnvelope[envelopeId], envelopeId);

		if (CI_ERROR == funRet)
		{
			ret = NULL;
		}
		else
		{
			ret = &gs_arEnvelope[envelopeId];
		}
	}
	return ret;
}



/**
 * @brief 清空指定包络
 * @param[in] UINT16 envelopeId 包络ID
 * @return CI_SUCCESS 处理成功
 *         CI_ERROR   处理错误
 * @note 无
 */
UINT8 elm_ClearEnvelope(UINT16 envelopeId)
{
	/*- 局部变量定义*/ 
	UINT8 ret = CI_ERROR;
	UINT8 funRet = CI_ERROR;

	/** 判断包络ID是否正确 */
	funRet = elm_IsEnvelopeIDOK(envelopeId);

	if (CI_SUCCESS == funRet)
	{
		ret = elm_ResetEnvelope(&gs_arEnvelope[envelopeId], 1u);
	}
	else
	{
		/** 入口参数错误*/
	}
	return ret;
}


/**
 * @brief 将列车ID加入到包络包含的列车序列中
 * @param[in] UINT8 flag 栈头还是栈尾
 * @param[in] UINT8 trainId 列车ID
 * @param[in] UINT16 envelopeID 包络ID
 * @param[out] 无
 * @return 
 * @note 
 */
UINT8 elm_PushToTrainSeq(UINT8 flag,UINT16 envelopeID,UINT16 trainId)
{
	UINT8 ret = CI_ERROR;
	UINT8 cycle = 0u;
	const EnvelopeStruct* pTempconst = NULL;  /* 用于ID的合法性判断 */
	EnvelopeStruct* pTemp = NULL;  /* 指向包络存储地址 */

	pTempconst = elm_GetEnvelopeInfoPtr(envelopeID);

	/** 入口参数检验 */
	ASSERT_RET_VALUE((ELM_HEAD != flag) && (ELM_TAIL != flag),ret,0x80000000u);
	ASSERT_RET_VALUE(NULL == pTempconst,ret,0x40000000u);
	ASSERT_RET_VALUE((0u == trainId) || (trainId > LINE_MAX_TRAIN),ret,0x20000000u);    /** 序列中可以存在影藏车ID */

	/** 获取包络的地址 */
	pTemp = &gs_arEnvelope[envelopeID];

	if ((NULL != pTemp ) && (pTemp->trianCnt < (TRAIN_IN_ENVELOPE_SUM_MAX - 1u)))
	{
		if (ELM_HEAD == flag)
		{
			pTemp->trainID[pTemp->trianCnt] = trainId;
			pTemp->trianCnt++;
		}
		else
		{
			/** 先挪动 */
			for (cycle = pTemp->trianCnt; 0u != cycle; cycle--)
			{
				pTemp->trainID[cycle] = pTemp->trainID[cycle - 1u];
			}
			pTemp->trainID[0u] = trainId;
			pTemp->trianCnt++;
		}
		ret = CI_SUCCESS;
	}
	else
	{
		/** 地址空间不对，或者数组空间不够*/
	}

	return ret;
}

/**
 * @brief 在列车序列中删除列车ID
 * @param[in] UINT16 envelopeID 包络ID
 * @param[in] UINT8 trainId 列车ID
 * @param[out] 无
 * @return 
 * @note 
 */
UINT8 elm_DeleteTrainFromSeq(UINT16 envelopeID,UINT16 trainId)
{
	UINT8 ret = CI_ERROR;
	UINT8 cycle = 0u;
	UINT8 index = 0u;
	UINT8 trainCnt = 0u;
	const EnvelopeStruct* pTempconst = NULL;  /* 用于ID的合法性判断 */
	EnvelopeStruct* pTemp = NULL;  /* 指向包络存储地址 */

	pTempconst = elm_GetEnvelopeInfoPtr(envelopeID);

	/** 入口参数检验 */
	ASSERT_RET_VALUE(NULL == pTempconst,ret,0x80000000u);
	ASSERT_RET_VALUE((0u == trainId) || (trainId > LINE_MAX_TRAIN),ret,0x40000000u);  /** 序列中可以存在影藏车ID */

	/** 获取包络的地址 */
	pTemp = &gs_arEnvelope[envelopeID];

	/** 获取最初的数量 */
	trainCnt = pTemp->trianCnt;

	/** 删除包络ID */
	for (cycle = 0; cycle < trainCnt;cycle++)
	{
		if (pTemp->trainID[cycle] == trainId)
		{
			pTemp->trainID[cycle] = 0u;
			pTemp->trianCnt--;
			break;
		}
		else
		{
			/** 无需删除 */
		}
	}

	/** 移动 */
	for (cycle = 0; cycle < trainCnt;cycle++)
	{
		if (0u == pTemp->trainID[cycle])
		{
			/** 跳过*/
		}
		else
		{
			pTemp->trainID[index] = pTemp->trainID[cycle];
			/** 地址偏移 */
			index++;
		}
	}

	ret = CI_SUCCESS;
	return ret;
}


/**
 * @brief 包络包含的计轴栈中进行头部弹出或者尾部弹出
 * @param[in] UINT8 flag 栈头或者栈尾进行弹出
 * @param[in] UINT16 envelopeID 包络ID
 * @param[out] 无
 * @return CI_SUCCESS 处理成功
 *         CI_ERROR   处理错误
 * @note 无
 */
UINT8 elm_PopEnvelopACSeq(UINT8 flag, UINT16 envelopeID)
{
	UINT8 ret = CI_ERROR;
	UINT8 cycle = 0u;
	UINT8 acCnt = 0u;
	UINT8 funRet = ENVELOPE_UNEXIT;

	/** 入口参数校验 */
	ASSERT_RET_VALUE((ELM_HEAD != flag) && (ELM_TAIL != flag),ret,0x80000000u);
		 
	/** 判断包络是否存在 */
	funRet = elm_IsEnvelopeExit(envelopeID);

	if ((ENVELOPE_EXIT == funRet) && (0u < gs_arEnvelope[envelopeID].ACCnt) && (gs_arEnvelope[envelopeID].ACCnt < (SECTION_IN_ENVELOPE_SUM_MAX - 1u)))
	{
		if (ELM_HEAD == flag)
		{
			acCnt = gs_arEnvelope[envelopeID].ACCnt;
			gs_arEnvelope[envelopeID].ACID[acCnt-1u] = 0u;
			gs_arEnvelope[envelopeID].ACCnt--;
		}
		else
		{
			gs_arEnvelope[envelopeID].ACID[0u] = 0u;
			gs_arEnvelope[envelopeID].ACCnt--;

			for (cycle = 0u; cycle < gs_arEnvelope[envelopeID].ACCnt ; cycle++)
			{
				gs_arEnvelope[envelopeID].ACID[cycle] = gs_arEnvelope[envelopeID].ACID[cycle+1u];
				gs_arEnvelope[envelopeID].ACID[cycle+1u] = 0u;
			}
		}

		/** 设置函数返回值*/
		ret = CI_SUCCESS;
	}
	else
	{
		/** 包络不存在，则不处理 */
	}

	return ret;
}


/**
 * @brief 包络包含的计轴栈中进行头部压出或者尾部压出
 * @param[in] UINT8 flag 栈头或者栈尾进行弹出
 * @param[in] UINT16 envelopeID 包络ID
 * @param[in] UINT16 ACID 计轴ID
 * @param[out] 无
 * @return CI_SUCCESS 处理成功
 *         CI_ERROR   处理错误
 * @note 无
 */
UINT8 elm_PushEnvelopeACSeq(UINT8 flag, UINT16 envelopeID,UINT16 ACID)
{
	UINT8 ret = CI_ERROR;
	UINT8 cycle = 0u;
	UINT8 acCnt = 0u;
	UINT8 funRet = ENVELOPE_UNEXIT;

	/** 入口参数校验 */
	ASSERT_RET_VALUE((ELM_HEAD != flag) && (ELM_TAIL != flag),ret,0x80000000u);

	/** 判断包络是否存在 */
	funRet = elm_IsEnvelopeExit(envelopeID);

	if ((ENVELOPE_EXIT == funRet) && (gs_arEnvelope[envelopeID].ACCnt < (SECTION_IN_ENVELOPE_SUM_MAX - 1u)))
	{
		if (ELM_HEAD == flag)
		{
			acCnt = gs_arEnvelope[envelopeID].ACCnt;
			gs_arEnvelope[envelopeID].ACID[acCnt] = ACID;
			gs_arEnvelope[envelopeID].ACCnt++;
		}
		else
		{
			/** 先挪动 */
			for (cycle = gs_arEnvelope[envelopeID].ACCnt; 0u != cycle; cycle--)
			{
				gs_arEnvelope[envelopeID].ACID[cycle] = gs_arEnvelope[envelopeID].ACID[cycle - 1u];
			}

			gs_arEnvelope[envelopeID].ACID[0u] = ACID;
			gs_arEnvelope[envelopeID].ACCnt++;
		}

		ret = CI_SUCCESS;
	}
	else
	{
		/** 包络不存在，则不处理 */
	}
	return ret;
}

/**
 * @brief 设置包络中列车的激活端
 * @param[in] UINT16 envelopeID 包络ID
 * @param[in] UINT8 trainId 列车ID
 * @param[in] UINT8 ACTPort 列车激活端
 * @param[out] 无
 * @return 无
 * @note 无
 */
void elm_SetTrainACTPortInELM(UINT16 envelopeID,UINT16 trainId,UINT8 ACTPort)
{
	UINT8 cycle = 0u;
	UINT8 funRet = ENVELOPE_UNEXIT;

	/** 判断包络是否存在 */
	funRet = elm_IsEnvelopeExit(envelopeID);

	if (ENVELOPE_EXIT == funRet)
	{
		for (cycle = 0u; cycle < gs_arEnvelope[envelopeID].trianCnt;cycle++)
		{
			if (gs_arEnvelope[envelopeID].trainID[cycle] == trainId)
			{
				gs_arEnvelope[envelopeID].ACTPort[cycle] = ACTPort;
				break;
			}
			else
			{
				/** 继续遍历 */
			}
		}
	}
	else
	{
		/** 包络不存在，不处理 */
	}
}



/**
 * @brief 获取包络中列车的激活端
 * @param[in] UINT16 envelopeID 包络ID
 * @param[in] UINT8 trainId 列车ID
 * @param[out] 无
 * @return UINT8 列车激活端
 * @note 无
 */
UINT8 elm_GetTrainACTPortInELM(UINT16 envelopeID,UINT16 trainId)
{
	UINT8 ret = 0u;
	UINT8 cycle = 0u;
	UINT8 funRet = ENVELOPE_UNEXIT;

	/** 判断包络是否存在 */
	funRet = elm_IsEnvelopeExit(envelopeID);

	if (ENVELOPE_EXIT == funRet)
	{
		for (cycle = 0u; cycle < gs_arEnvelope[envelopeID].trianCnt;cycle++)
		{
			if (gs_arEnvelope[envelopeID].trainID[cycle] == trainId)
			{
				ret = gs_arEnvelope[envelopeID].ACTPort[cycle];
				break;
			}
			else
			{
				/** 继续遍历 */
			}
		}
	}
	else
	{
		/** 包络不存在，不处理 */
	}
	return ret;
}

/**
 * @brief 设置UCT包络转UKT包络起始时间
 * @param[in] UINT16 wEnvelopid 包络ID
 * @param[in] UINT8 dwCycNum 周期号
 * @return CI_SUCCESS 1 设置成功
 *         CI_ERROR 0 设置失败
 * note Created By LQ 2024.07.14
 */
UINT8 elm_SetUCTToUKTStartCycNum(UINT16 wEnvelopid, UINT32 dwCycNum)
{
	UINT8 cRetVal = CI_ERROR;
	UINT8 cFunRetVal = CI_ERROR;

	/** 判断包络ID是否正确 */
	cFunRetVal = elm_IsEnvelopeIDOK(wEnvelopid);

	if ((CI_SUCCESS == cFunRetVal) && (gs_arEnvelope[wEnvelopid].id == wEnvelopid))
	{
		gs_arEnvelope[wEnvelopid].dwUCTToUKTStartCycNum = dwCycNum;
		cRetVal = CI_SUCCESS;
	}
	else
	{
		/*入参非法，返回失败*/
	}

	return cRetVal;
}