📄 lib.c

📁 各种实用的子程序
💻 C
📖 第 1 页 / 共 5 页
字号:
上一页 1 2 3 45
		}

		Cur_FixVal_Buff.wStatus=ClearSts;                              //清暂存区状态
		return true;
	}
	else
		return false;
//		return true;

}
//********************************************************************************************
//下装定值
//*******************************************************************************************
// MMI下发定值时，转换放在入口指针里的定值，校验其合理性，将其放在暂存区Cur_FixVal_Buff
//首先校验CRC码
//然后判断定值是否是BCD码
//转换定值
//然后判断定值区是否在范围内
//********************************************************************************************
 uint8 MMI_Change_Run(ValRepBuff *MMI_Rep_Buff)
 {
	 uint8 i,uType,uType1,uLen,j,uValSum;
	 uint8 *ptr;
     uint16 Value;
	 uint16 *pBuff;
	 bool bErrb=false;

	 if(Cur_FixVal_Buff.wStatus!=SetSts)
	 {
		 Cur_FixVal_Buff.wStatus=SetSts;
		
		 bErrb=false;
		 pBuff=(uint16 *)&Cur_FixVal_Buff.Set_Buff;
		 uValSum=sizeof(SetBuff)/2-2;
		 for(i=0;i<uValSum;i++)
		 {
			 uType=MMI_Rep_Buff->ValBuff[i].uType; //定值属性
			 uType1=uType&0x4f;
			 Value=MMI_Rep_Buff->ValBuff[i].uHiByte;	
			 Value <<= 8;   //未转换的定值
			 Value +=MMI_Rep_Buff->ValBuff[i].uLoByte;
			 if((uType1!=0)&&(uType1!=0x40))
			 { //转换除KG以外的定值
				 if (uType1==0x0e)					 
				 {
					 Value=Value;
					 *pBuff++=Value;//检查有无越限，填越限报文
				 }
				 else if(BCD_Check(Value))                //入口参数:定值序号
				 {
					 if(uType1==0x04) 
						 Value=MMI_Change_Hex_Time_s(uType,Value);
					 else if (uType1==0x0f)
					 {
						 Value=BcdHex(Value);
					 }
					 else 
						 Value=MMI_Change_Hex_Others(uType,Value);//转换其他定值
					 //
					 j=Value_Check(i,Value);
					if(j==DisAvailable)		//检查有无越限，填越限报文
					{
						Cur_FixVal_Buff.wStatus=ClearSts;
						Err_buf.SetNO=i+1;
						Err_buf.Errtype=OVER_DATA;
						return		0x5a;
					}						              
					*pBuff++=Value;//检查有无越限，填越限报文
				 }
				 else
				 {
					 Cur_FixVal_Buff.wStatus=ClearSts;
					Err_buf.SetNO=i+1;
					Err_buf.Errtype=NOT_BCD;
					return		0x5a;
					//*pBuff++;
				 }
			 }
			 else *pBuff++=Value;		 //转换KG									 			
		 }
/*		 if(bErrb)
		 {
			 Cur_FixVal_Buff.wStatus=ClearSts;          //清暂存区状态
			 return false;
		 }*/
		 Cur_FixVal_Buff.uSur=Id_Mmi;		 
		 //校验和计算
		 ptr=(uint8 *)&Cur_FixVal_Buff.Set_Buff;
		 uLen=sizeof(SetBuff)-4;
		 Cur_FixVal_Buff.Set_Buff.wCrc=CalSum16(ptr,uLen);          //8位和校验 按字节校验？？
		 
		ptr=(uint8 *)&Cur_FixVal_Buff;
		ptr +=4;
		uLen=sizeof(Cur_FixVal_Buff);
		uLen -=4;
		Cur_FixVal_Buff.wCrc=CalSum16(ptr,uLen);          //8位和校验 按字节校验？？	

		 return 0x1;
	}
	else
	{
		Cur_FixVal_Buff.wStatus=ClearSts;
		Err_buf.SetNO=0xff;
		Err_buf.Errtype=DATA_ERR;						//校验或者状态不对
		return 0x5a;
	}
 }

//***********************************************************************************888
 //检验校验和          入口参数:所要检验CRC的结构名称(适用于ValRepBuff结构)
bool Crc_Check(uint8 *pBuff,uint8 uLen)
{
	uint8 uSum,i;
	uSum=0;
//	if(ValRepBuff->uStatus!=Available)
//		return false;
    for(i=0;i<uLen;i++)
		uSum+=pBuff[i];
//	uSum+=ValRepBuff->utype;
	if(uSum==pBuff[i])
		return true;
	return false;
}
//检查校验和            入口参数:所要检验CRC的结构名称(适用于FixValueBuff结构)
/* bool	Set_Check_1(FixValueBuff *pReadFixvalBuff)
{
	uint8	i,uSum1,uSum2,ulen,*pBuff;
	uSum1=0,uSum2=0;
	if(pReadFixvalBuff->uStatus!=SetSts) return false;	//标志字节OK?
	ulen=sizeof(FixValueBuff);							//计算结构的长度
	pBuff=(uint8 *)pReadFixvalBuff+1;					//指针赋值
	for(i=0;i<ulen-2;i++)
	{
		uSum1+=*pBuff;
		pBuff++;
	}
	ulen=sizeof(pReadFixvalBuff->Set_Buff);
	pBuff=(uint8 *)&pReadFixvalBuff->Set_Buff+1;
	for(i=0;i<ulen-2;i++)
	{
		uSum2+=*pBuff;
		pBuff++;
	}
	if(uSum1==pReadFixvalBuff->uCrc&&uSum2==pReadFixvalBuff->Set_Buff.uCrc)return true;
	else	
		return false;
}*/
//
//************************************************************************************888
bool BCD_Check(uint16 wBcd)      //BCD码检查 入口参数 待检查的16位数                     
{
	//
	uint16 i,wBcdByte;
	for(i=0;i<4;i++)
	{
		wBcdByte=wBcd&0xf;
		if(wBcdByte>9)// || (wBcdByte<0))
			return false;
		wBcd >>=4;
	}
	return true;
  
}
//****************************************************************************************
//填出错缓冲报告 入口参数:i出错定值序号,j出错类型
void Write_ErrBuff(uint8 i,uint8 j)  
{
	uint8 uWritepointer;
	uWritepointer=Set_Err_Buff.uWritepointer;
    Set_Err_Buff.Err_Buff[uWritepointer].SetNO=i;          //出错定值序号，FF表示整体出错
    Set_Err_Buff.Err_Buff[uWritepointer].Errtype=j;        //出错类型
    Set_Err_Buff.uWritepointer++;
    Set_Err_Buff.uWritepointer %=FixNumb;   //环行缓冲
}
//*****************************************************************************************
uint16 MMI_Change_Hex_Others(uint8 uType,uint16 Value)//转换除时间KG以外的定值
{
	uint16 Val_ZS,Val_XS,Val;
	Val=Value;
	uType&=0x30;
	switch(uType)
	{
	case 0:
		//0位小数
		Val_ZS=Value;                    //整数部分
		Val_XS=0;                        //小数部分
		break;
	case 0x10:              
		//1位小数
		Val_ZS=Value>>4;
		Val_XS=Val<<12;
		break;
	case 0x20:           
		//2位小数
		Val_ZS=Value>>8;
		Val_XS=Val<<8;
		break;
	case 0x30:        
		//3位小数
		Val_ZS=Value>>12;
		Val_XS=Val<<4;
	}
	Val_ZS=BcdHex(Val_ZS);
	Val_XS=FraHex(Val_XS);
	Value=Val_ZS<<8;
	Value+=Val_XS>>8;
	return Value;
}
uint16 MMI_Change_Hex_Time_s(uint8 uType,uint16 Value)//转换时间秒
{
	//
	Value=BcdHex(Value);
	uType&=0x30;
	switch(uType)
	{
	case 0:
		//0位小数
		Value=Value*0x64;
		break;
	case 0x10:              
		//1位小数
		Value=Value*10;
		break;
	case 0x20:           
		//2位小数
		break;
	case 0x30:        
		//3位小数
		Value=Value/10;
	}
	return Value;
	
}
uint16 MMI_Change_Hex_Time_m(uint8 uType,uint16 Value)//转换时间分
{
	//
	Value=BcdHex(Value);
	uType&=0x30;
	switch(uType)
	{
	case 0:
		//0位小数
		Value=Value*6000;
		break;
	case 0x10:              
		//1位小数
		Value=Value*600;
		break;
	case 0x20:           
		//2位小数
		Value=Value*60;
		break;
	case 0x30:        
		//3位小数
		Value=Value*6;
	}
	return Value;
	
}
//*****************************************************************************************
////检查定值是否超出范围  入口参数 待检的定值序号和定值
uint8 Value_Check(uint8 i,uint16 Value)  
{
	uint16 Val_Max,Val_Min;
	//
	Val_Max=FixValueTable[i].MaxValue.uHiByte;
	Val_Max	<<=8;   //获取最大值
	Val_Max +=FixValueTable[i].MaxValue.uLoByte;
	Val_Min=FixValueTable[i].MinValue.uHiByte;
	Val_Min	<<=8;   //获取最小值
	Val_Min+=FixValueTable[i].MinValue.uLoByte;
	if(Value>Val_Max||(Value<Val_Min))                               //检查是否超出上限
	{
//		Write_ErrBuff(i,2);
		return DisAvailable;
	}	
	return Available;
}
//********************************************************************************************
//浮点数转16进制
uint16 wHex;
uint16 Float_Hex(uint8 uLowByte,uint8 uHighByte)
{	
	wHex=0;
	if(uHighByte&0x80)           //80ff
	{
		uHighByte=~uHighByte;
		uHighByte++;
		wHex +=uLowByte;
		wHex >>=uHighByte;
	}
	else
	{
		wHex +=uLowByte;
		wHex <<=uHighByte;
	}
	return wHex;
}
//全整数(BUBY 2003 12 4)
uint16 Float_Hex1(uint8 uLowByte,uint8 uHighByte)
{
	wHex=0;
	if(uHighByte&0x80)        //6C8   
	{
		uHighByte=~uHighByte;
		uHighByte++;
		wHex +=uLowByte;
		wHex >>=(uHighByte+8);
		//wHex >>=uHighByte;
	}
	else          //6000->0DBB   //10->0x4A0
	{
		wHex +=uLowByte;
		if(uHighByte>=8)
			wHex <<=(uHighByte-8);
		else
			wHex >>=(8-uHighByte);
	}
	return wHex;
}
//14位整数,2位小数(BUBY 2003 12 4)
uint16 Float_Hex2(uint8 uLowByte,uint8 uHighByte)
{
	wHex=0;
	if(uHighByte&0x80)
	{
		uHighByte=~uHighByte;
		uHighByte++;
		wHex +=uLowByte;               
		wHex >>=(uHighByte+6);//0.25->FF80->1 
		//wHex >>=uHighByte;
	}
	else           
	{
		wHex +=uLowByte;                    //16->0X580->
		if(uHighByte>=6)
			wHex <<=(uHighByte-6);
		else
			wHex >>=(6-uHighByte);
	}
	return wHex;
}
//******************************************************************************************
// CAN下发定值时，放在CAN_Rep_Buff的定值转换,校验其合理性，将其放在暂存区Run_FixVal_Buff
//首先校验CRC码
//转换定值
//然后判断定值区是否在范围内
//********************************************************************************************
bool CAN_Change_Run(ValRepBuff *CAN_Rep_Buff)
 {
	 uint8 i,uType,Errb,*ptr,uLen,j,uValSum;
     uint16 Value,Value1,Val_ZS,Val_XS;
	 uint16 *pBuff;

	if(Cur_FixVal_Buff.wStatus==ClearSts)
	{
		 Cur_FixVal_Buff.wStatus=SetSts;
		 //计算校验和  入口参数:所要检验的结构名称(适用于ValRepBuff结构)
		 
		   //校验和正确，转换定值
		 pBuff=(uint16*)&Cur_FixVal_Buff.Set_Buff;

		 uValSum=sizeof(SetBuff)/2-2;
		 for(i=0;i<uValSum;i++)
		 {
			 uType=FixValueTable[i].MaxValue.uType&0xf;       //定值属性  ????
  
			 if(uType)
			 {
				 if     (uType==0xf)         //全整数(BUB
上一页 1 2 3 45
💿 文件大小 15 K
👤 上传用户 IsabellaJ
📂 所属分类数据结构
📄 代码行数 1,858 行
💻 语言类型 C语言
🏷️ 相关标签

#程序
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -