ad.c

AD采样 定时器使用 定时器控制AD采样频率

#include "DSP28_Device.h"
#include "stdlib.h"
#include "math.h"

float	a1[16];
unsigned int a2=0;
float	adclo=0.0;
float a[20];
float v[1];
float r[21];
interrupt void ad(void);
void dly(unsigned long cnt);
void levinson(float *r,int p,float *a,float *v);
void yulewalk(float *x,int n,int p,float *a,float *v);
float shuchu[1000];//放在.ebss中,全局变量
float outp[300];
interrupt void ad(void);
static int processing(float *input, float *output);
//void dly(unsigned long cnt);
void main(void)
{

	
	InitSysCtrl();

	DINT;
	IER = 0x0000;
	IFR = 0x0000;

	InitPieCtrl();
	InitPieVectTable();	
	InitGpio();
	
	EALLOW;	// This is needed to write to EALLOW protected registers
	PieVectTable.ADCINT=&ad;
	EDIS;   // This is needed to disable write to EALLOW protected registers
    
    InitAdc();
	
    IER |= M_INT1;//使能CPUINT1	
	EINT;   // Enable Global interrupt INTM
	ERTM;	// Enable Global realtime interrupt DBGM
	EvaRegs.GPTCONA.all=0;
	EvaRegs.T1CMPR=0x0000;//设置T1比较值 
    EvaRegs.T1PR=0x0100;    
    EvaRegs.GPTCONA.bit.T1TOADC=2;
    EvaRegs.T1CON.all=0x1042;//X/4
    for(;;)
	{
			KickDog();
	}

} 	

interrupt void ad(void)
{
	IFR=0x0000;
	PieCtrl.PIEACK.all=0xffff;//响应中断
	a2++;
	shuchu[a2-1]=((float)AdcRegs.RESULT0)*3.0/65520.0+adclo;
	if(a2>=1000)
	{
	  // processing(shuchu,outp);
	  // yulewalk(outp,300,20,a,v);
	   a2=1000;
	}
	GpioDataRegs.GPADAT.all=0xffff;
	//dly(1000);
	GpioDataRegs.GPADAT.all=0x0000;
	AdcRegs.ADC_ST_FLAG.bit.INT_SEQ1_CLR=1;//清除INT_SEQ1位
	//AdcRegs.ADCTRL2.bit.SOC_SEQ1=1;//从当前停止的位置启动SEQ1
	AdcRegs.ADCTRL2.bit.RST_SEQ1=1;
}  
static int processing(float *input, float *output)
{
    int size=300;    
	int n=53; 
	float x1[353];
	float h[53]={
    	-0.000246
	-0.000000,
	0.000450,
	0.001196,
	0.002308,
	0.003765,
	0.005394,
	0.006840,
	0.007584,
	0.007024,
	0.004609,
	-0.000000,
	-0.006772,
	-0.015204,
	-0.024306,
	-0.032688,
	-0.038765,
	-0.041024,
	-0.038337,
	-0.030226,
	-0.017043,
	0.000000,
	0.018950,
	0.037392,
	0.052825,
	0.063076,
	0.066667,
	0.063076,
	0.052825,
	0.037392,
	0.018950,
	0.000000,
	-0.017043,
	-0.030226,
	-0.038337,
	-0.041024,
	-0.038765,
	-0.032688,
	-0.024306,
	-0.015204,
	-0.006772,
	-0.000000,
	0.004609,
	0.007024,
	0.007584,
	0.006840,
	0.005394,
	0.003765,
	0.002308,
	0.001196,
	0.000450,
	-0.000000,
	-0.000246
		};
 	int i,j;
	float sum;
		for(i=0;i<size;i++)
		{
			x1[n+i-1]=input[i];
		}
		for(j=0;j<(n-1);j++)
			{
				x1[n-j-2]=input[size-1-j];
			}

		for (i=0;i<size;i++)
		{
			sum=0.0;
			for(j=0;j<n;j++)
			{
            	sum+=h[j]*x1[i-j+n-1];			
			}	
	    output[i]=sum;
    }
    
    return(1);
}
void yulewalk(float *x,int n,int p,float *a,float *v)
{
	int i,k;
	float s,*r;
	r=(float*)malloc((p+1)*sizeof(float));
	for(k=0;k<=p;k++)
	{
		s=0.0;
		for(i=0;i<(n-k);i++)
		{
			s+=x[i]*x[i+k];
		}
		r[k]=s/n;
	}
	levinson(r,p,a,v);
	free(r);
}
void levinson(float *r,int p,float *a,float *v)
{
	int i,k;
	float q,*b;
	b=(float*)malloc((p+1)*sizeof(float));
	a[0]=1.0;
	a[1]=-r[1]/r[0];
	v[0]=(1-a[1]*a[1])*r[0];
	for(k=2;k<=p;k++)
	{
		q=0.0;
		for(i=0;i<k;i++)
		{
			q+=a[i]*r[k-i];
		}
		a[k]=-q/v[0];
		for(i=1;i<k;i++)
		{
			b[i]=a[i]+a[k]*a[k-i];
		}
		for(i=1;i<k;i++)
		{
			a[i]=b[i];
		}
		v[0]=(1-a[k]*a[k])*v[0];

	}
	free(b);
}

/*void dly(unsigned long cnt)
{
	unsigned long k;
	for(k=0;k<cnt;k++);
}
*/
//===========================================================================
// No more.
//===========================================================================