fft.c

dsp2407,采集卡

//***************************************************//
#define		__FFT_INC_
#include 	".\DAT\DEF.H"

compx EE(compx b1,compx b2)
{
	compx b3;

	b3.real=b1.real*b2.real-b1.imag*b2.imag;
	b3.imag=b1.real*b2.imag+b1.imag*b2.real;

	return(b3);
}

void DataMove(UINT *DataSource)
{
	UINT i;
	UINT data;

	for(i=1;i<=MAXADTOTALDOT;i++)
	{
		data=*DataSource;
		#if(test)
			*DataSource=data<<2;
		#endif
		s[i].real=((float)(int)(data<<2));
		s[i].imag=0.0;
		DataSource++;
	}
}

void DataReturn(void)
{
	UINT i;

	#if(test)
		i=MAXADTOTALDOT;
	#else
		i=RETURNWAVECNT;
	#endif

	do
	{
		s[i].real*=VoltRatio;
		s[i].imag*=VoltRatio;
	}
	while(--i>0);

	s[1].real/=2.0;
}

void CalVolt1(void)
{
	ClrWdt();
	if(n_AdDot>=MAXADTOTALDOT)
	{
		DataMove((UINT *)&AD_Adata);
		ClrWdt();
		FFT((compx *)s,MAXADTOTALDOT);
		DataReturn();
		ClrWdt();
		memcpy((UINT *)&VoltFrequency,
			   (UINT *)&s[1],
			   4*(1+1)*sizeof(UINT));

		#if(test)
			ClrWdt();
			DataMove((UINT *)&AD_Bdata);
			ClrWdt();
			FFT((compx *)s,MAXADTOTALDOT);
			ClrWdt();
			DataReturn();

			ClrWdt();
			DataMove((UINT *)&AD_Cdata);
			ClrWdt();
			FFT((compx *)s,MAXADTOTALDOT);
			ClrWdt();
			DataReturn();
		#endif
	}
	else
	{
		memset((UINT *)&VoltFrequency,
			   0,
			   4*(1+1)*sizeof(UINT));
	}
}

void CalVolt2(void)
{
	if(n_AdDot>=MAXADTOTALDOT)
	{
		ClrWdt();
		DataMove((UINT *)&AD_Adata);
		ClrWdt();
		FFT((compx *)s,MAXADTOTALDOT);
		ClrWdt();
		DataReturn();
		ClrWdt();
		memcpy((UINT *)&Aphase[n_AdCnt].DC_R,
			   (UINT *)&s[1],
			   4*(RETURNWAVECNT+1)*sizeof(UINT));

		ClrWdt();
		DataMove((UINT *)&AD_Bdata);
		ClrWdt();
		FFT((compx *)s,MAXADTOTALDOT);
		ClrWdt();
		DataReturn();
		ClrWdt();
		memcpy((UINT *)&Bphase[n_AdCnt].DC_R,
			   (UINT *)&s[1],
			   4*(RETURNWAVECNT+1)*sizeof(UINT));

		ClrWdt();
		DataMove((UINT *)&AD_Cdata);
		ClrWdt();
		FFT((compx *)s,MAXADTOTALDOT);
		ClrWdt();
		DataReturn();
		ClrWdt();
		memcpy((UINT *)&Cphase[n_AdCnt].DC_R,
			   (UINT *)&s[1],
			   4*(RETURNWAVECNT+1)*sizeof(UINT));

		Aphase[n_AdCnt].Ok=1;
		Bphase[n_AdCnt].Ok=1;
		Cphase[n_AdCnt].Ok=1;
	}
	else
	{
		ClrWdt();
		memset((UINT *)&Aphase[n_AdCnt].DC_R,
			   0,
			   4*(RETURNWAVECNT+1)*sizeof(UINT));

		ClrWdt();
		memset((UINT *)&Bphase[n_AdCnt].DC_R,
			   0,
			   4*(RETURNWAVECNT+1)*sizeof(UINT));

		ClrWdt();
		memset((UINT *)&Cphase[n_AdCnt].DC_R,
			   0,
			   4*(RETURNWAVECNT+1)*sizeof(UINT));
	}
}

void CalFrequency(void)
{
	ULONG templong;

	templong=VoltFrequency.Frequency.ULONGData;
	VoltFrequency.Frequency.FloatData=(float)templong/FreqMultiple;
}

void FFT(compx *xin,UINT N)
{
	int f,m,nv2,nm1,i,k,j=1,l;
	compx v,w,t;
	int le,lei,ip;
	float pi,x,y;

	nv2=N/2;
	f=N;
	for(m=1;(f=f/2)!=1;m++){;}
	nm1=N-1;

	for(i=1;i<=nm1;i++)
	{
		ClrWdt();
		if(i<j)
		{
			t=xin[j];
			xin[j]=xin[i];
			xin[i]=t;
		}

		k=nv2;
		while(k<j)
		{
			j=j-k;
			k=k/2;
		}

		j=j+k;
	}

	ClrWdt();
	for(l=1;l<=m;l++)
	{
		le=pow2(l);
		lei=le/2;
		pi=3.14159265;
		v.real=1.0;
		v.imag=0.0;
		w.real=cos(pi/lei);
		w.imag=-sin(pi/lei);
		for(j=1;j<=lei;j++)
		{
			for(i=j;i<=N;i=i+le)
			{
				ClrWdt();
				ip=i+lei;
				t=EE(xin[ip],v);
				xin[ip].real=xin[i].real-t.real;
				xin[ip].imag=xin[i].imag-t.imag;
				xin[i].real=xin[i].real+t.real;
				xin[i].imag=xin[i].imag+t.imag;
			}
			v=EE(v,w);
		}
	}
}

UINT pow2(UINT x)
{
	return(1<<x);
}