ads8364.c

c6713的源代码

#include "IMU_GW.h"

extern unsigned short ads8364_ready;		
extern unsigned short ads8364_readNdx;		
extern unsigned long int ads8364_totalNdx;

extern unsigned short ADC_address[6];
extern short A0_temp[ADC_SAMPLE_SIZE];
extern short A1_temp[ADC_SAMPLE_SIZE];
extern short B0_temp[ADC_SAMPLE_SIZE];
extern short B1_temp[ADC_SAMPLE_SIZE];
extern short C0_temp[ADC_SAMPLE_SIZE];
extern short C1_temp[ADC_SAMPLE_SIZE];
extern float Ax,Ay,Az,Wx,Wy,Wz;
extern short AxSum,AySum,AzSum,WxSum,WySum,WzSum;
extern short AxMax,AxMax0,AxMin,AxMin0;
extern short AyMax,AyMax0,AyMin,AyMin0;
extern short AzMax,AzMax0,AzMin,AzMin0;
extern short WxMax,WxMax0,WxMin,WxMin0;
extern short WyMax,WyMax0,WyMin,WyMin0;
extern short WzMax,WzMax0,WzMin,WzMin0;
//extern volatile float* pAddr0;
extern volatile short* pAddr1;


/*******************************************************************************
 FUNC	: software_init__ADC
 DESC	: Initialize ADS8364, issue the Software Configuration command.  See ADS8364.h
 *******************************************************************************/
 //初始化8364  详细见ADS8364.h
void software_init_ADC()
{
	//初始化变量
	ads8364_ready   = 0;       // Initialize vars
	//周期模式
	software_cfig(CMD1);       // CMD1=0x0086,Cycle mode
	//初始化变量
    ads8364_readNdx = 0;
    //初始化变量
    ads8364_ready   = 1;
    //初始化变量
    ads8364_totalNdx = 0;
}

/*******************************************************************************
 FUNC	: software_cfig()
 DESC	: Software Configruation command - see ADS8364.h for CMD1 value
 ARGS	: cmd1 = configuration command value
 *******************************************************************************/
 //函数干什么用的：软件配置命令
 //参数：cmd1是指令
void software_cfig(unsigned short cmd1)
{
   //把cmd1的值传到地址ADC_Base里(对ADC_Base里的值进行初始化)
   *(unsigned volatile short *)ADC_Base = cmd1;// Initialize 
}

/*******************************************************************************
 FUNC	: software_cnvt()
 DESC	: Software Conversion command - see ADS8364.h for CMD0 value
 ARGS	: cmd0 = configure conversion command
 *******************************************************************************/
void software_cnvt(unsigned short cmd0, unsigned short reset)
{
	if(reset) //如果是reset
	{
		//地址ADC_Base里的值置为GBL_Reset
		*(unsigned volatile short *)ADC_Base = GBL_Reset;// Reset GBL_Reset=0x0007
	}
	*(unsigned volatile short *)ADC_Base = cmd0;// Start a Conversion
}

/*******************************************************************************
 FUNC	: software_read()
 DESC	: Software Read routines for the ADS8364 EVM
 ARGS	: Set Cycle Mode
 *******************************************************************************/
void software_read()
{
	//float tempF; 
	short temp;//,temp1; 
	
	ADC_address[0] =  (*(unsigned volatile short *)ADC_Base);
	A0_temp[ads8364_readNdx] = (*(volatile short *)ADC_Base);
	//tempF = (float)(A0_temp[ads8364_readNdx]*0.000076);
	//*(pAddr0++) = tempF;
	//*(pAddr1++)=A0_temp[ads8364_readNdx];
	temp = A0_temp[ads8364_readNdx];
	//temp1 = abs(temp);
	if(ads8364_readNdx%10==0)
	{
		WxMin=temp;
		WxMax=temp;
		WxMin0=temp;
		WxMax0=temp;
	}
	else if(ads8364_readNdx%10==1)
	{
		if(temp>WxMax)//if(temp1>abs(WxMax))
		{
			WxMax=temp;
			WxMin0=temp;
		}
		else
		{
			WxMin=temp;
			WxMax0=temp;
		}
	}
	else
	{
		if(temp>WxMax)//if(temp1>abs(WxMax))
		{
			WxMax0=WxMax;
			WxMax=temp;
		}
		//else if(temp1>abs(WxMax0))
		else if(temp>WxMax0)
		{
			WxMax0=temp;	
		}
		//if(temp1<abs(WxMin))
		if(temp<WxMin)
		{
			WxMin0=WxMin;
			WxMin=temp;
		}
		//else if(temp1<abs(WxMin0))
		else if(temp<WxMin0)
		{
			WxMin0=temp;
		}
	}
	WxSum = WxSum+temp;
	
	ADC_address[1] =  (*(unsigned volatile short *)ADC_Base);
	A1_temp[ads8364_readNdx] = (*(volatile short *)ADC_Base);
	//tempF = (float)(A1_temp[ads8364_readNdx]*0.000076);
	//*(pAddr0++) = tempF;
	//*(pAddr1++)=A1_temp[ads8364_readNdx];
	temp = A1_temp[ads8364_readNdx];
	//temp1 = abs(temp);
	if(ads8364_readNdx%10==0)
	{
		AxMin=temp;
		AxMax=temp;
		AxMin0=temp;
		AxMax0=temp;
	}
	else if(ads8364_readNdx%10==1)
	{
		//if(temp1>abs(AxMax))
		if(temp>AxMax)
		{
			AxMax=temp;
			AxMin0=temp;
		}
		else
		{
			AxMin=temp;
			AxMax0=temp;
		}
	}
	else
	{
		//if(temp1>abs(AxMax))
		if(temp>AxMax)
		{
			AxMax0=AxMax;
			AxMax=temp;
		}
		//else if(temp1>abs(AxMax0))
		else if(temp>AxMax0)
		{
			AxMax0=temp;	
		}
		//if(temp1<abs(AxMin))
		if(temp<AxMin)
		{
			AxMin0=AxMin;
			AxMin=temp;
		}
		//else if(temp1<abs(AxMin0))
		else if(temp<AxMin0)
		{
			AxMin0=temp;
		}
	}
	AxSum = AxSum+temp;
	
	ADC_address[2] =  (*(unsigned volatile short *)ADC_Base);
	B0_temp[ads8364_readNdx] = (*(volatile short *)ADC_Base);
	//tempF = (float)(B0_temp[ads8364_readNdx]*0.000076);
	//*(pAddr0++) = tempF;
	//*(pAddr1++)=B0_temp[ads8364_readNdx];
	temp = B0_temp[ads8364_readNdx];
	//temp1 = abs(temp);
	if(ads8364_readNdx%10==0)
	{
		WyMin=temp;
		WyMax=temp;
		WyMin0=temp;
		WyMax0=temp;
	}
	else if(ads8364_readNdx%10==1)
	{
		//if(temp1>abs(WyMax))
		if(temp>WyMax)
		{
			WyMax=temp;
			WyMin0=temp;
		}
		else
		{
			WyMin=temp;
			WyMax0=temp;
		}
	}
	else
	{
		//if(temp1>abs(WyMax))
		if(temp>WyMax)
		{
			WyMax0=WyMax;
			WyMax=temp;
		}
		//else if(temp1>abs(WyMax0))
		else if(temp>WyMax0)
		{
			WyMax0=temp;	
		}
		
		//if(temp1<abs(WyMin))
		if(temp<WyMin)
		{
			WyMin0=WyMin;
			WyMin=temp;
		}
		//else if(temp1<abs(WyMin0))
		else if(temp<WyMin0)
		{
			WyMin0=temp;
		}
	}
	WySum = WySum+temp;
	
	ADC_address[3] =  (*(unsigned volatile short *)ADC_Base);
	B1_temp[ads8364_readNdx] = (*(volatile short *)ADC_Base);
	//tempF = (float)(B1_temp[ads8364_readNdx]*0.000076);
	//*(pAddr0++) = tempF;
	//*(pAddr1++)=B1_temp[ads8364_readNdx];
	temp = B1_temp[ads8364_readNdx];
	//temp1 = abs(temp);
	if(ads8364_readNdx%10==0)
	{
		AyMin=temp;
		AyMax=temp;
		AyMin0=temp;
		AyMax0=temp;
	}
	else if(ads8364_readNdx%10==1)
	{
		//if(temp1>abs(AyMax))
		if(temp>AyMax)
		{
			AyMax=temp;
			AyMin0=temp;
		}
		else
		{
			AyMin=temp;
			AyMax0=temp;
		}
	}
	else
	{
		//if(temp1>abs(AyMax))
		if(temp>AyMax)
		{
			AyMax0=AyMax;
			AyMax=temp;
		}
		//else if(temp1>abs(AyMax0))
		else if(temp>AyMax0)
		{
			AyMax0=temp;	
		}
		
		//if(temp1<abs(AyMin))
		if(temp<AyMin)
		{
			AyMin0=AyMin;
			AyMin=temp;
		}
		//else if(temp1<abs(AyMin0))
		else if(temp<AyMin0)
		{
			AyMin0=temp;
		}
	}
	AySum = AySum+temp;

	ADC_address[4] =  (*(unsigned volatile short *)ADC_Base);
	C0_temp[ads8364_readNdx] = (*(volatile short *)ADC_Base);
	//tempF = (float)(C0_temp[ads8364_readNdx]*0.000076);
	//*(pAddr0++) = tempF;
	//*(pAddr1++)=C0_temp[ads8364_readNdx];
	temp = C0_temp[ads8364_readNdx];
	//temp1 = abs(temp);
	if(ads8364_readNdx%10==0)
	{
		WzMin=temp;
		WzMax=temp;
		WzMin0=temp;
		WzMax0=temp;
	}
	else if(ads8364_readNdx%10==1)
	{
		//if(temp1>abs(WzMax))
		if(temp>WzMax)
		{
			WzMax=temp;
			WzMin0=temp;
		}
		else
		{
			WzMin=temp;
			WzMax0=temp;
		}
	}
	else
	{
		//if(temp1>abs(WzMax))
		if(temp>WzMax)
		{
			WzMax0=WzMax;
			WzMax=temp;
		}
		//else if(temp1>abs(WzMax0))
		else if(temp>WzMax0)
		{
			WzMax0=temp;	
		}
		
		//if(temp1<abs(WzMin))
		if(temp<WzMin)
		{
			WzMin0=WzMin;
			WzMin=temp;
		}
		//else if(temp1<abs(WzMin0))
		else if(temp<WzMin0)
		{
			WzMin0=temp;
		}
	}
	WzSum = WzSum+temp;
	
	ADC_address[5] =  (*(unsigned volatile short *)ADC_Base);
	C1_temp[ads8364_readNdx] = (*(volatile short *)ADC_Base);
	//tempF = (float)(C1_temp[ads8364_readNdx]*0.000076);
	//*(pAddr0++) = tempF;
	//*(pAddr1++)=C1_temp[ads8364_readNdx];
	temp = C1_temp[ads8364_readNdx];
	//temp1 = abs(temp);
	if(ads8364_readNdx%10==0)
	{
		AzMin=temp;
		AzMax=temp;
		AzMin0=temp;
		AzMax0=temp;
	}
	else if(ads8364_readNdx%10==1)
	{
		//if(temp1>abs(AzMax))
		if(temp>AzMax)
		{
			AzMax=temp;
			AzMin0=temp;
		}
		else
		{
			AzMin=temp;
			AzMax0=temp;
		}
	}
	else
	{
		//if(temp1>abs(AzMax))
		if(temp>AzMax)
		{
			AzMax0=AzMax;
			AzMax=temp;
		}
		//else if(temp1>abs(AzMax0))
		else if(temp>AzMax0)
		{
			AzMax0=temp;	
		}
		
		//if(temp1<abs(AzMin))
		if(temp<AzMin)
		{
			AzMin0=AzMin;
			AzMin=temp;
		}
		//else if(temp1<abs(AzMin0))
		else if(temp<AzMin0)
		{
			AzMin0=temp;
		}
	}
	AzSum = AzSum+temp;

	ads8364_readNdx = ads8364_readNdx+1;
	if(ads8364_readNdx%10==0)
	{
		AxSum=AxSum-AxMin-AxMax-AxMin0-AxMax0;
		AySum=AySum-AyMin-AyMax-AyMin0-AyMax0;
		AzSum=AzSum-AzMin-AzMax-AzMin0-AzMax0;
		WxSum=WxSum-WxMin-WxMax-WxMin0-WxMax0;
		WySum=WySum-WyMin-WyMax-WyMin0-WyMax0;
		WzSum=WzSum-WzMin-WzMax-WzMin0-WzMax0;
		
		Ax=(float)(AxSum*0.000076/6.0);
		Ay=(float)(AySum*0.000076/6.0);
		Az=(float)(AzSum*0.000076/6.0);
		Wx=(float)(WxSum*0.000076/6.0);
		Wy=(float)(WySum*0.000076/6.0);
		Wz=(float)(WzSum*0.000076/6.0);
		AxSum=0;
		AySum=0;
		AzSum=0;
		WxSum=0;
		WySum=0;
		WzSum=0;
		ads8364_ready = 1;
	}
	
}
/*******************************************************************************
 FUNC	: ext5_isr()
 DESC	: EXT5 interrupt routine. Called when ADS8364 generates the EOC pulse.
 ARGS	: void
 RET	: void
 *******************************************************************************/
 //当产生EOC中断时产生EXT5中断
interrupt void ext5_isr()
{
	//
	if((ads8364_totalNdx-1)%3==0)//三个中断触发一次中断5
	{
   		software_read();	
   	}
   	ads8364_totalNdx++;
    if(ads8364_readNdx >= ADC_SAMPLE_SIZE)
    {
		ads8364_readNdx = 0;
	}
}  

/****************************************************************/
/* init_timer1                                                  */
/* This sets the DSP timer 1                                    */
/****************************************************************/
//初始化DSP的倍频参数
void init_timer1(void)
{
	//比如TIMER1_CTRL= 0x423
	//TIMER1_CTRL |= 0x303 的结果就是0x723
    *(unsigned volatile int *)TIMER1_CTRL  |= 0x303; 	          // CPU CLK/4, 50% PLS, INV
    
    *(unsigned volatile int *)TIMER1_PRD 	= CONVCLK_PERIOD;     // pulse width 1us
    *(unsigned volatile int *)TIMER1_COUNT 	= 0;	              // Set counter 0
    *(unsigned volatile int *)TIMER1_CTRL   = 0x03c3;
}