set.c

lpc2136芯片的硬件全部功能示例程序

/*************************************************************
		WPD800 定值处理程序
		修改历史    2007-10-10  zaken create version 1.0


*************************************************************/

#include "main.h"
#include "string.h"
#include "wpd800.h"
#include "function.h"
#include "Set.h"


BYTE setbuf[256];//原始定值缓冲区
TSET runset;  //运行定值区
T_SETINFO *pSInfo;//定值的附加信息

const TSETTABLE tSetTable[]=
{
  {"控制字",0x00,0x00,0x00,0x00,0xff,0xff,0x00,0x00,0x00},//0000～FFFF  
  {"电流Ⅰ段",0x23,0x20,0x00,0x13,0x00,0x10,0x13,0x00,0x10},//0.20～100.0
  {"电流Ⅱ段",0x23,0x20,0x00,0x13,0x00,0x10,0x13,0x00,0x10},//0.20～100.0
  {"电流Ⅲ段",0x23,0x20,0x00,0x13,0x00,0x10,0x13,0x00,0x10},//0.20～100.0
  {"电流Ⅰ段时间",0x24,0x00,0x00,0x24,0x00,0x20,0x24,0x00,0x00},//0.00～20.00
  {"电流Ⅱ段时间",0x24,0x10,0x00,0x24,0x00,0x20,0x24,0x00,0x20},//0.10～20.00
  {"电流Ⅲ段时间",0x24,0x10,0x00,0x24,0x00,0x20,0x24,0x00,0x20},//0.10～20.00
  {"ＣＴ变比",0x31,0x01,0x00,0x21,0x00,0x10,0x21,0x10,0x00},//0.001～10.00	0.1	500/5
  {"ＰＴ变比",0x21,0x01,0x00,0x21,0x00,0x10,0x21,0x10,0x00},//0.01～10.00	0.1 10K/100
};


//控制字解释表
const char *szI1FX[]	={"电流Ⅰ段不带方向","电流Ⅰ段带方向  "};
const char *szI2FX[]	={"电流Ⅱ段不带方向","电流Ⅱ段带方向  "};
const char *szI3FX[]	={"电流Ⅲ段不带方向","电流Ⅲ段带方向  "};

const char *szI1UBS[]	={"电流Ⅰ段无压闭锁","电流Ⅰ段电压闭锁"};
const char *szI2UBS[]	={"电流Ⅱ段无压闭锁","电流Ⅱ段电压闭锁"};
const char *szI3UBS[]	={"电流Ⅲ段无压闭锁","电流Ⅲ段电压闭锁"};
const char *szIJSUBS[]	={"电流加速无压闭锁","电流加速电压闭锁"};

const TKGTABLE tKgTable[]=
{
	{1,{0,0,0}, szI1FX},
	{1,{1,0,0}, szI2FX},
	{1,{2,0,0}, szI3FX},
	{1,{3,0,0}, szI1UBS},
	{1,{4,0,0}, szI2UBS},
	{1,{5,0,0}, szI3UBS},
};
	
const int SET_NUMBER=sizeof(tSetTable)/sizeof(tSetTable[0]);
const int KG_NUMBER=sizeof(tKgTable)/sizeof(tKgTable[0]);

const int SET_SIZE=SET_NUMBER*3+sizeof(T_SETINFO);
bool Transfor_Set(int i,DWORD *pS,DWORD dK,BYTE type);


//读取默认定值
void Set_ReadDefault(BYTE *pSet)
{
	WORD cnt;
	for(cnt =0; cnt < SET_NUMBER; cnt++)
	{
		pSet[0] =tSetTable[cnt].tDef.byAttrib;
		pSet[1] =tSetTable[cnt].tDef.byValLo;
		pSet[2] =tSetTable[cnt].tDef.byValHi;
		pSet +=3;
	}
}
//从E2PRom中读取定值
bool Set_Read(BYTE *pS)
{

	//目前未写
	return TRUE;
}
//从E2PRom中写定值
bool Set_Write(BYTE *Ps)
{
	WORD crc;
	//目前未写
	if(Ps!=setbuf)
	{
		memcpy(setbuf,Ps,SET_NUMBER*3);
	}
	pSInfo->type=IEDTYPE;
	pSInfo->version=VERSION;
	pSInfo->setnum=SET_NUMBER;
	//计算CRC
	crc=CrcCalc(setbuf,SET_SIZE);
	setbuf[SET_SIZE]=LOBYTE(crc);
	setbuf[SET_SIZE+1]=HIBYTE(crc);
	//保存定值
	return TRUE;
}
bool Make_Set(BYTE *Ps)
{
	DWORD dK;
	bool status=TRUE;
	//转换控制字
	
	if(!Transfor_Set(SET_KG,(DWORD *)&(runset.wKG),1,SETTYPE_HEX))
		status=FALSE;
	//控制字赋值
	{
		if(runset.wKG & 0x0001)//KG0
			runset.bKG_I1FX=TRUE;
		else
			runset.bKG_I1FX=FALSE;
		if(runset.wKG & 0x0002)//KG1
			runset.bKG_I2FX=TRUE;
		else
			runset.bKG_I2FX=FALSE;
		if(runset.wKG & 0x0004)//KG2
			runset.bKG_I3FX=TRUE;
		else
			runset.bKG_I3FX=FALSE;
		if(runset.wKG & 0x0008)//KG3
			runset.bKG_I1UBS=TRUE;
		else
			runset.bKG_I1UBS=FALSE;
		if(runset.wKG & 0x0010)//KG4
			runset.bKG_I2UBS=TRUE;
		else
			runset.bKG_I2UBS=FALSE;
		if(runset.wKG & 0x0020)//KG5
			runset.bKG_I3UBS=TRUE;
		else
			runset.bKG_I3UBS=FALSE;		
		
	}
	//转换电流
	dK=1;//未写电流系数
	if(!Transfor_Set(SET_I1,(DWORD *)&(runset.dI1),1,SETTYPE_A))
	status=FALSE;
	if(!Transfor_Set(SET_I2,(DWORD *)&(runset.dI2),1,SETTYPE_A))
	status=FALSE;
	if(!Transfor_Set(SET_I3,(DWORD *)&(runset.dI3),1,SETTYPE_A))
	status=FALSE;
	//转换时间
	dK=1000;
	if(!Transfor_Set(SET_T1,(DWORD *)&(runset.dT1),1,SETTYPE_S))
	status=FALSE;
	if(!Transfor_Set(SET_T2,(DWORD *)&(runset.dT2),1,SETTYPE_S))
	status=FALSE;
	if(!Transfor_Set(SET_T3,(DWORD *)&(runset.dT3),1,SETTYPE_S))
	status=FALSE;
	//转换CT PT变比
	dK=65536;
	if(!Transfor_Set(SET_CT,(DWORD *)&(runset.dCT),1,SETTYPE_FACTOR))
	return status;
	if(!Transfor_Set(SET_PT,(DWORD *)&(runset.dPT),1,SETTYPE_FACTOR))
	return status;
}

//初始化定值，并且转换
bool Set_Init(void)
{
	memset(setbuf,0,sizeof(setbuf));
	memset(&runset,0,sizeof(runset));
	pSInfo=(T_SETINFO *)(&setbuf[SET_NUMBER*3]);
	if(!Set_Read(setbuf))
	{
		//Set_ReadDefault(setbuf);
		RECORD_ERR_FLAG(6);//纪录E2PROM错误
		return FALSE;
	}
	//检查CRC 
	if(!CrcOk(setbuf,SET_SIZE))
	{
		RECORD_ERR_FLAG(5);//纪录定值错误
	}
	//检查定值的装置类型和版本号
	if(/*pSInfo->version!=VERSION ||*/ pSInfo->type!=IEDTYPE || pSInfo->setnum!=SET_NUMBER)
	{
		RECORD_ERR_FLAG(5);
	}
	if(IS_ERR_FLAG(5))//定值出错
	{
		Set_ReadDefault(setbuf);//采用莫认定值
		Set_Write(setbuf);
		return FALSE;
	}	
	return Make_Set(setbuf);
	
}
///////以下为定值处理函数////////////////////////
//获取定值类型
BYTE GetSetType( TSETVAL *v)
{
  return ((v->byAttrib)&SETATTRIB_TYPEMASK);
}

bool IsBcdSet( TSETVAL *v)
{
  if(GetSetType(v) == SETTYPE_HEX)	return FALSE;
  if(!IsBcdb(v->byValLo))	return FALSE;
  if(!IsBcdb(v->byValHi))	return FALSE;
  return TRUE;
}

//将定值转换成16进制,并检查定值的范围
//将整定值原始值转换成16进制定点数
//bset[0]=定值属性
//bset[1]=定值数值的低字节
//bset[2]=定值数值的高字节
//hset=结果,其中高16位为整数部分,低16位为小数部分
bool SetToHex( TSETVAL *bset,long *hset)
{
  BYTE attrib;
  DWORD vs;
  if (!IsBcdSet(bset))	return FALSE;
  attrib=bset->byAttrib;
  if(attrib & SETATTRIB_DOT2)
  {
    if(attrib & SETATTRIB_DOT1)
	{
	  //3位小数
      vs  =((DWORD)(bset->byValLo))<<4;
      vs +=((DWORD)(bset->byValHi))<<12;
    }
    else
	{ 
	  //2位小数
      vs=((DWORD)(bset->byValLo))<<8;
      vs+=((DWORD)(bset->byValHi))<<16;
    }
  }
  else
  {
    if(attrib & SETATTRIB_DOT1)
	{
	  //1位小数
      vs=((DWORD)(bset->byValLo))<<12;
      vs+=((DWORD)(bset->byValHi))<<20;
    }
    else
	{ 
	  //无小数
      vs=((DWORD)(bset->byValLo))<<16;
      vs+=((DWORD)(bset->byValHi))<<24;
    }
  }
  vs =FixHex(vs);
  if(attrib & SETATTRIB_SIG)	
  {
	  *hset =~(long)vs;
  }
  else
  {
	  *hset=(long)vs;
  }
  return TRUE;
}
bool HexSetRange(int i,long *pHex,BYTE type)
{
  long lMin,lMax;
  //整定值
  if(GetSetType(( TSETVAL *)(&tSetTable[i].tMin))!=type)
  	return FALSE;
  if(!SetToHex(( TSETVAL *)(setbuf+i*3),pHex))
  {
     return FALSE;
  }
  SetToHex(( TSETVAL *)(&tSetTable[i].tMin),&lMin);
  SetToHex(( TSETVAL *)(&tSetTable[i].tMax),&lMax);
  if((*pHex < lMin) || (*pHex > lMax))
  {
    return FALSE;
  }
  return TRUE;
}
//转换定值
//i=定值序号
//pS=存放转换后的定值指针
//dK=放大系数
bool Transfor_Set(int i,DWORD *pS,DWORD dK,BYTE type)
{
  long d;
  //检查定值序号
  if(i < 0 || i >= SET_NUMBER)	return FALSE;
  //转换定值
  if(!HexSetRange(i,&d,type))
  {
    return FALSE;
  }
  *pS=dK*d;
  return TRUE;
}