yc.c

详细介绍了arm7-at91r40008,的开发全过程

						YCTemp[k].YcDataMax[i] = YCTemp[k].YcData[i];
					}
					
					if (YCTemp[k].YcData[i] < YCTemp[k].YcDataMin[i])
					{
						YCTemp[k].YcDataMin[i] = YCTemp[k].YcData[i];
					}
				}
			}
		}
	}
	
	SumCount++;
}

/*------------------------------------------------------------------*/
/*函数名称：AppYcMean()												*/
/*函数功能：遥测滤波，算出最终有效值，写入数据库					*/
/*------------------------------------------------------------------*/
void AppYcMean(void)
{
	INT8U	i, k;
	INT16S	yc[DEFYCNUM];
	INT32S	sum;
	struct DBInfo	info;

 	info.DevID = ROOTID;
	info.Type = YCDATA;
	info.Num = 13;
	
	for (k=0; k<MAXYCFD; k++)
	{
		if ((TGSH && (k==1)) || (k==0))
		{
			for (i=0; i<TMPYCNUM; i++)
			{
				sum = (YCTemp[k].YcDataSum[i] - YCTemp[k].YcDataMin[i] - YCTemp[k].YcDataMax[i]) / (SumCount - 2);
				if (abs(sum) < YCParas[k].ToZero[i])
					sum = 0;
				
				if ((i > 1) && (i < 6))	//I
					sum = sum * 1000;
				else
					sum = sum * 2200;
				
				yc[i] = (long long)sum * MyCfg.Ai[k*DEFYCNUM+i].Xs1 / MyCfg.Ai[k*DEFYCNUM+i].Xs2 / YCPara.Value[k*TMPYCNUM+i];   
			}
			
			yc[10] = yc[6] + yc[7];
			yc[11] = yc[8] + yc[9];
			sum = MySqrtInt((int)yc[10] * (int)yc[10] + (int)yc[11] * (int)yc[11]);
			if (sum == 0)
				yc[12] = 0;
			else
			{
				yc[12] = (int)yc[10] * 1000 / sum;
				if (yc[12] > 1000)
					yc[12] = 1000;
			}
			
			info.Start = k * DEFYCNUM;
			DBWrite((INT8U*)yc, &info);
		}
	}
	
	SumCount = 0;
}

/*------------------------------------------------------------------*/
/*函数名称：Frequency_Treatment()									*/
/*函数功能：计算工频，并维护同步采样脉冲频率						*/
/*------------------------------------------------------------------*/
void Frequency_Treatment(void)
{
	u_int	temp ;
	
	if ( (at91_tc_get_status ( &TC2_DESC ) & (TC_ETRGS|TC_LDRAS) ) == (TC_ETRGS|TC_LDRAS) )
	{
       	temp = TC2_DESC.tc_base->TC_RA ;				// 读取一个周波的计数值
		if ( ( temp > Hz_High ) && ( temp < Hz_Low ) )	// 防止工频越限
		{
       		TC1_DESC.tc_base->TC_RC = temp >> 1 ;		// 调整AD采样频率
			Frequency_Lose = 0 ;		
		}
		
		Frequency = ( MCK >> 5 ) * 100 / temp ;		// 计算工频,单位0.01Hz
	}
	else
	{
		Frequency = 0;
	}

	Frequency_Lose ++;
	if (Frequency_Lose >= 3)      // 长时间丢失工频信号
	{
		// 重新初始化TC1和TC2,防止计数器错误
		
		// 以50Hz默认频率采样
		TC1_DESC.tc_base->TC_RC = 20625;	//dingding
		
		Frequency_Lose = 0 ;
	}

}

/*------------------------------------------------------------------*/
/*函数名称：CalYcpara()												*/
/*函数功能：系数整定&&写参数文件									*/
/*输入说明：angel ==0 0度整定；    angel == 90 90度整定；			*/
/*------------------------------------------------------------------*/
void CalYcPara(u_char angel)
{
	INT8U	i, k;
	static INT8U	flag = 0;
	struct YCPara_t *tmp = (struct YCPara_t*)YcTmpBuf;
	
	if (flag == 0)
		memset (YcTmpBuf, 0, sizeof (YcTmpBuf));

	tmp->Flag = YCPARANORMAL;
	
	for (k=0; k<MAXYCFD; k++)
	{
		if ((TGSH && (k==1)) || (k==0))
		{
			if (angel == 0)		//0度整定
			{
				for (i=0; i<8; i++)		//Uab, Ucb, Ia, Ib, Ic, Io, Pa, Pc
				{
					if (YCTemp[k].YcData[i] == 0)
						tmp->Value[k*TMPYCNUM + i] = 1000;	//防止参数为零
					else
						tmp->Value[k*TMPYCNUM + i] = YCTemp[k].YcData[i];
						
					//对Io简单处理
					if (i == 5)
						tmp->Value[k*TMPYCNUM + i] = YCTemp[k].YcData[4];
				}
				flag |= 0x01;
			}
			
			if (angel == 90)	//90度整定
			{
				for (i=8; i<10; i++)		//Qa, Qc
				{
					if (YCTemp[k].YcData[i] == 0)
						tmp->Value[k*TMPYCNUM + i] = 1000;	//防止参数为零
					else
						tmp->Value[k*TMPYCNUM + i] = YCTemp[k].YcData[i];
				}
				flag |= 0x02;
			}
			
			if (angel == 100)	//零序整定
			{
				tmp->Flag = YCPARANORMAL|YCPARAZERO;
				
				if (YCTemp[k].YcData[5] == 0)
					tmp->Value[k*TMPYCNUM + 5] = 1000;	//防止参数为零
				else
					tmp->Value[k*TMPYCNUM + 5] = YCTemp[k].YcData[5];
				
				YCPara.Value[k*TMPYCNUM + 5] = tmp->Value[k*TMPYCNUM + 5];
				flag |= 0x04;
			}
			
		}
	}
	if((flag & 0x03) == 0x03)
	{
		flag &= 0xFC;
		memcpy (&YCPara, tmp, sizeof (struct YCPara_t));
		SetYcPara(tmp);
	}
   
	if(flag & 0x04)	//零序
	{
		flag &= 0xFB;
		SetYcPara(tmp);
	}
}

/*------------------------------------------------------------------*/
/*函数名称：MakeQuxian()											*/
/*函数功能：生成采样曲线											*/
/*输入说明：Num－－馈线号，从1开始									*/
/*------------------------------------------------------------------*/
INT8U* MakeQuxian(INT8U Num)
{
	INT8U	cur, i, j;
	INT16U	k;

	memset (YcTmpBuf, 0, sizeof (YcTmpBuf));

	if ((Num == 0) || Num > 2)
		return (NULL);
		
	cur = (CurAD + ADAINUM - 32) % ADAINUM;
	
	for (i=0; i<5; i++)
	{
		for (j=0; j<32; j++)
		{
			k = i * ADAINUM + ((cur + j) % ADAINUM);
			YcTmpBuf[i*32 + j] = ADData[Num - 1].Data[k];
		}
	}
	
	return ((INT8U*)YcTmpBuf);
}

/*------------------------------------------------------------------*/
/*函数名称：LB()													*/
/*函数功能：录波													*/
/*输入说明：FDIndex:从0开始											*/
/*------------------------------------------------------------------*/
void LB(INT16U FDIndex)
{
	INT8U	start, end , i, j;
	INT16U	num, k, max;
	struct LBInfo_t	lb;
	struct DBInfo	info;
	
	if (FDIndex >= MAXYCFD)
		return;
	
	memset (&info,  0, sizeof (struct DBInfo));
	memset (YcTmpBuf, 0, sizeof (YcTmpBuf));
	
	end = CurAD - 2;
	if (Lb[FDIndex].State & LBSTART)
	{
		start = (CurAD + 2) % ADAINUM;
		info.Start = 0;
		Lb[FDIndex].Num = 0;
		Lb[FDIndex].Cur = start;
	}
	else
	{
		start = Lb[FDIndex].Cur;
		info.Start = 0xFFFF;
	}
	
	num = (end + ADAINUM - start) % ADAINUM;
		
	if (((Lb[FDIndex].Flag & LBFault) == LBFault) || (NVRAMSIZE == 0x8000))
		max = LBFAULTSIZE;
	else
		max = LBMAX;
	
	if (Lb[FDIndex].Num + num > max)
		num = max - Lb[FDIndex].Num;

	if (num == 0)
		return;
	else if (num > 32)
		num = 32;
	
	for (i=0; i<ADNUM; i++)
	{
		for (j=0; j<num; j++)
		{
			k = i * ADAINUM + ((start + j) % ADAINUM);
			YcTmpBuf[i*num + j] = ADData[FDIndex].Data[k];
		}
	}
	
	info.Num = num<<8;
	info.Type = LBDATAUA;
	info.DevID = 0;
	info.SuperID = FDIndex;
	DBWrite((INT8U*)YcTmpBuf, &info);
	
	k = (info.Num & 0xFF) * ADBIT + (info.Num >>8);
	if (k == num)
	{
		Lb[FDIndex].State = LBING;
		Lb[FDIndex].Cur = (Lb[FDIndex].Cur + num) % ADAINUM;
		Lb[FDIndex].Num += num;
		
		if (Lb[FDIndex].Num >= max)
		{
			info.Type = LBINFO;
			info.Num = sizeof (struct LBInfo_t);
			info.DevID = 0;
			info.SuperID = FDIndex;
			
			memset ((INT8U*)&lb, 0, info.Num);
			lb.Flag = 0x3F;
			lb.FDIndex = info.SuperID;
			lb.Length = Lb[FDIndex].Num;
			GetTime((void*)&lb.Time, ABSTIME);
			DBWrite((INT8U*)&lb, &info);
			
			
			memset (&Lb[FDIndex], 0, sizeof(struct LB_t));
			Lb[FDIndex].State = LBEND;
		}
	}
	else
	{
		//??
		ErrorInfo(OSPrioCur, "录波失败");
	}

}

/*------------------------------------------------------------------*/
/*函数名称：MySqrtInt()												*/
/*函数功能：整数开方												*/
/*输入说明：<Sur>被开方数											*/
/*输出说明：平方根													*/
/*------------------------------------------------------------------*/
u_int MySqrtInt(u_int Sur)
{
	u_int Const1 = 0x40000000, Const2 = 0x80000000;
	u_int Root = 0, Count = 0;
	u_int TempRoot, TempSur;
	
	while (Count < 16)
	{
		TempRoot = (unsigned long)((Root+Const1)>>Count);
		Const1 = (unsigned long)(Const1>>1) ;
		TempSur = Sur;
		Sur -= TempRoot;
		if (TempSur < TempRoot)
		{
			Sur = TempSur;
		}
		else
		{
			TempSur = Sur;
			Root += Const2;
		}
		Const2 = (unsigned long)(Const2>>1);
		Count++;
	}
	
	return ((unsigned long)(Root>>16));
}