基于TMS320F28335的ADS1248芯片驱动源码

// ASSUMPTIONS:
//            SCLK        GPIO18
//            DIN         GPIO16
//            DOUT        GPIO17
//            /DRDY       GPIO13
//            /CS         GPIO19
//            START       GPIO15
//            /RESET      GPIO14

#include "DSP2833x_Device.h"     // DSP2833x Headerfile Include File
#include "DSP2833x_Examples.h"   // DSP2833x Examples Include File

#define ADS1248_CMD_WAKEUP    	0x00
#define ADS1248_CMD_SLEEP     	0x03
#define ADS1248_CMD_SYNC     	0x05
#define ADS1248_CMD_RESET    	0x07
#define ADS1248_CMD_NOP    		0xFF
// Data Read
#define ADS1248_CMD_RDATA    	0x13
#define ADS1248_CMD_RDATAC    	0x15
#define ADS1248_CMD_SDATAC    	0x17
// Read Register
#define ADS1248_CMD_RREG    	0x20
// Write Register
#define ADS1248_CMD_WREG    	0x40
// Calibration
#define ADS1248_CMD_SYSOCAL    	0x60
#define ADS1248_CMD_SYSGCAL    	0x61
#define ADS1248_CMD_SELFOCAL    0x62


/* ADS1248 Register Definitions */
#define ADS1248_0_MUX0   		0x00
#define ADS1248_1_VBIAS     	0x01
#define ADS1248_2_MUX1	     	0x02
#define ADS1248_3_SYS0	    	0x03
#define ADS1248_4_OFC0	    	0x04
#define ADS1248_5_OFC1	    	0x05
#define ADS1248_6_OFC2	    	0x06
#define ADS1248_7_FSC0	    	0x07
#define ADS1248_8_FSC1	    	0x08
#define ADS1248_9_FSC2	    	0x09
#define ADS1248_10_IDAC0	   	0x0A
#define ADS1248_11_IDAC1	   	0x0B
#define ADS1248_12_GPIOCFG    	0x0C
#define ADS1248_13_GPIODIR    	0x0D
#define ADS1248_14_GPIODAT    	0x0E

// Define Reference Select
#define ADS1248_REF0			0x00
#define ADS1248_REF1			0x08
#define ADS1248_INT				0x10
#define ADS1248_INT_REF0		0x18
// Define Internal Reference
#define ADS1248_INT_VREF_OFF	0x00
#define ADS1248_INT_VREF_ON		0x20
#define ADS1248_INT_VREF_CONV	0x40


/* Error Return Values */
#define ADS1248_NO_ERROR        0
#define ADS1248_ERROR			-1

//void spi_xmit(Uint16 a);
void spi_xmit(unsigned char a);
void spi_fifo_init(void);
void spi_init(void);
unsigned char ADS1248ReceiveByte(void);
int ADS1248SetIntRef(int sRef);
int ADS1248SetVoltageReference(int VoltageRef);

void ADS1248SendByte(unsigned char Byte);
void ADS1248SetReset(int nReset);
int ADS1248GetID(void);
void ADS1248WriteRegister(int StartAddress, int NumRegs, unsigned * pData);
void ADS1248ReadRegister(int StartAddress, int NumRegs, unsigned * pData);
long ADS1248ReadData(void);

Uint16 * pData;
unsigned sdata1;
unsigned sdata2;
int i;
Uint16 senddata;
unsigned rdata = 2;
int ii = 0;
unsigned char data_rdyn;
long ADC_result_data = 100;
int flag_start = 1;

void main(void)
{
   InitSysCtrl();
   InitGpio();
   InitSpiaGpio();
   DINT;
   InitPieCtrl();
   IER = 0x0000;
   IFR = 0x0000;
   InitPieVectTable();

   spi_fifo_init();	  // Initialize the Spi FIFO
   spi_init();		  // init SPI

   // START拉高
   GpioDataRegs.GPADAT.bit.GPIO15 = 1;DELAY_US(2);

   ADS1248SetReset(0);		//复位
   DELAY_US(100000);
   ADS1248SetReset(1);
   DELAY_US(1000000);

   sdata1 = 0x01;	// Burnout current source off,Positive input channel:000 = AIN0,Negative input channel:001 = AIN1
   ADS1248WriteRegister(ADS1248_0_MUX0, 0x01, &sdata1);
   DELAY_US(1000);

   sdata1 = 0x00; //Bias voltage not enabled;
   ADS1248WriteRegister(ADS1248_1_VBIAS, 0x01, &sdata1);
   DELAY_US(100);

//   sdata1 = 0x40;
   sdata1 = 0x20; //Internal oscillator in use;Internal reference is always on;REF0 input pair selected;Normal operation
   ADS1248WriteRegister(ADS1248_2_MUX1, 0x01, &sdata1);
   DELAY_US(100);

   sdata1 = 0x06; // PGA = 1;output data rate of the ADC: 320SPS
   ADS1248WriteRegister(ADS1248_3_SYS0, 0x01, &sdata1);
   DELAY_US(100);

    使用默认值
//   sdata1 = 0x00;
//   ADS1248WriteRegister(ADS1248_4_OFC0, 0x01, &sdata1);
//   DELAY_US(100);
//
//   sdata1 = 0x00;
//   ADS1248WriteRegister(ADS1248_5_OFC1, 0x01, &sdata1);
//   DELAY_US(100);
//
//   sdata1 = 0x00;
//   ADS1248WriteRegister(ADS1248_6_OFC2, 0x01, &sdata1);
//   DELAY_US(100);

//   sdata1 = 0x00;
//   ADS1248WriteRegister(ADS1248_7_FSC0, 0x01, &sdata1);
//   DELAY_US(100);

//   sdata1 = 0x00;
//   ADS1248WriteRegister(ADS1248_8_FSC1, 0x01, &sdata1);
//   DELAY_US(100);
//
//   sdata1 = 0x00;
//   ADS1248WriteRegister(ADS1248_9_FSC2, 0x01, &sdata1);					//配置该寄存器似乎有问题
//   DELAY_US(100);

   sdata1 = 0x04;  // DOUT/DRDY pin functions only as Data Out;current source DACs = 500μA
   ADS1248WriteRegister(ADS1248_10_IDAC0, 0x01, &sdata1);
   DELAY_US(100);

   sdata1 = 0x89;	//first current source DAC:10x0 = IEXT1;the second current source DAC:10x1 = IEXT2;
   ADS1248WriteRegister(ADS1248_11_IDAC1, 0x01, &sdata1);
   DELAY_US(100);

//   sdata1 = 0x00; //
//   ADS1248WriteRegister(ADS1248_12_GPIOCFG, 0x01, &sdata1);
//   DELAY_US(100);
   // START拉低
   GpioDataRegs.GPADAT.bit.GPIO15 = 0;
   DELAY_US(20);
//
//   GpioDataRegs.GPADAT.bit.GPIO15 = 1;DELAY_US(20);
//   while((data_rdyn = GpioDataRegs.GPADAT.bit.GPIO13) == 0)
//   while(1)
//   {
//	   DELAY_US(5);
//	   ADC_result_data = ADS1248ReadData();
//	   DELAY_US(5);
while(1){
		flag_start = 1;
		// 启动转换
	    GpioDataRegs.GPADAT.bit.GPIO15 = 1;					// start_high
	    DELAY_US(100);										// 延时
	    GpioDataRegs.GPADAT.bit.GPIO15 = 0;					// start_low
	    DELAY_US(1);

	    // 判断转换标志位：/RDY
	    while(flag_start)
	    {
		   data_rdyn = GpioDataRegs.GPADAT.bit.GPIO13;
		   if(data_rdyn == 0)
		   {
			   ADC_result_data = ADS1248ReadData();
			   DELAY_US(1000);
			   flag_start = 0;
		   }
	    }


	// 读取寄存器的值
//	GpioDataRegs.GPADAT.bit.GPIO15 = 1;					// start_high
//	DELAY_US(100);
//	ADS1248ReadRegister(ADS1248_11_IDAC1, 0x01, &sdata2);
//	DELAY_US(100);

   }

}

long ADS1248ReadData(void)
{
	long Data;
	// assert CS to start transfer
//	ADS1248AssertCS(0);
	// send the command byte
	ADS1248SendByte(ADS1248_CMD_RDATA);
	DELAY_US(50);	// 延时必须大于50us，否则读取不正确
	// get the conversion result
	Data = ADS1248ReceiveByte();
	Data = (Data << 8) | ADS1248ReceiveByte();
	Data = (Data << 8) | ADS1248ReceiveByte();
	// sign extend data if the MSB is high (24 to 32 bit sign extension)
//	if (Data & 0x800000)
//		Data |= 0xff000000;
	// de-assert CS
//	ADS1248AssertCS(1);
	return Data;
}


int ADS1248GetID(void)
{
	unsigned Temp;
	ADS1248ReadRegister(ADS1248_10_IDAC0, 0x01, &Temp);
	return ((Temp>>4) & 0x0f);
}

// Relate to Mux1
int ADS1248SetIntRef(int sRef)
{
	unsigned Temp;
	int dError = ADS1248_NO_ERROR;
	ADS1248ReadRegister(ADS1248_2_MUX1, 0x01, &Temp);
	Temp &= 0x1f;
	switch(sRef) {
		case 0:
			Temp |= ADS1248_INT_VREF_OFF;
			break;
		case 1:
			Temp |= ADS1248_INT_VREF_ON;
			break;
		case 2:
		case 3:
			Temp |= ADS1248_INT_VREF_CONV;
			break;
		default:
			Temp |= ADS1248_INT_VREF_OFF;
			dError = ADS1248_ERROR;

	}
	// write the register value containing the new value back to the ADS
	ADS1248WriteRegister(ADS1248_2_MUX1, 0x01, &Temp);
	return dError;
}

int ADS1248SetVoltageReference(int VoltageRef)
{
	unsigned Temp;
	int dError = ADS1248_NO_ERROR;
	ADS1248ReadRegister(ADS1248_2_MUX1, 0x01, &Temp);
	Temp &= 0xe7;
	switch(VoltageRef) {
		case 0:
			Temp |= ADS1248_REF0;
			break;
		case 1:
			Temp |= ADS1248_REF1;
			break;
		case 2:
			Temp |= ADS1248_INT;
			break;
		case 3:
			Temp |= ADS1248_INT_REF0;
			break;
		default:
			Temp |= ADS1248_REF0;
			dError = ADS1248_ERROR;
	}
	// write the register value containing the new value back to the ADS
	ADS1248WriteRegister(ADS1248_2_MUX1, 0x01, &Temp);
	return dError;
}

void ADS1248SetReset(int nReset)
{
	// This example is using PORT6 for GPIO Reset Control, ADS1248_RESET is defined in ads1248.h
	if (!nReset)								// nReset=0 is RESET low, nReset=1 is RESET high
		GpioDataRegs.GPADAT.bit.GPIO14 = 0;
	else
		GpioDataRegs.GPADAT.bit.GPIO14 = 1;
}

void ADS1248WriteRegister(int StartAddress, int NumRegs, unsigned * pData)
{
	int i;
	// set the CS low
//	ADS1248AssertCS(0);
	// send the command byte
	ADS1248SendByte(ADS1248_CMD_WREG | (StartAddress & 0x0f));
	ADS1248SendByte((NumRegs-1) & 0x0f);
	// send the data bytes
	for (i=0; i < NumRegs; i++)
	{
		ADS1248SendByte(*pData++);
	}
	// set the CS back high
//	ADS1248AssertCS(1);
}

void ADS1248ReadRegister(int StartAddress, int NumRegs, unsigned * pData)
{
	int i;
	// send the command byte
	ADS1248SendByte(ADS1248_CMD_RREG | (StartAddress & 0x0f));
	ADS1248SendByte((NumRegs-1) & 0x0f);
	DELAY_US(100);
	// get the register content
	for (i=0; i< NumRegs; i++)
	{
		*pData++ = ADS1248ReceiveByte();
	}
	return;
}

void ADS1248SendByte(unsigned char Byte)
{
//	SpiaRegs.SPITXBUF = Byte;
	spi_xmit(Byte);
}

unsigned char ADS1248ReceiveByte(void)
{
	unsigned char Result = 0;
	int16 result_0 = 0;
//	unsigned int flag = 1;								// 这里做了一个取巧，因为读出来了多个无效数据，无效数据均为0，因此增加一个标志位，将无效数据屏蔽掉。

	ADS1248SendByte(ADS1248_CMD_NOP);					// Send out NOP to initiate SCLK
//	while(flag){
		while(SpiaRegs.SPIFFRX.bit.RXFFST == 0)	{}			// 因为连续发送了三个指令，接收也是连续接收了多个字符？
		result_0 = SpiaRegs.SPIRXBUF;							// Capture the receive buffer and return the Result
//		if(result_0 != 0)
//			flag = 0;
//	}
	Result = result_0 & 0x00ff;							// Capture the receive buffer and return the Result
	return Result;
}

void spi_xmit(unsigned char a)
{
	Uint16 senddata;
	senddata = (a << 8) & 0xff00;				// 发送数据小于16位必须采用左对齐，首先发送最高位
    SpiaRegs.SPITXBUF = senddata;
}

void spi_fifo_init()
{
// Initialize SPI FIFO registers
    SpiaRegs.SPIFFTX.all=0xE040;
    SpiaRegs.SPIFFRX.all=0x204f;
    SpiaRegs.SPIFFCT.all=0x0;
}

void spi_init()
{
//	SpiaRegs.SPICCR.all =0x000F;	             // Reset on, rising edge, 16-bit char bits
	SpiaRegs.SPICCR.all =0x0007;	             // Reset on, rising edge, 8-bit char bits
	SpiaRegs.SPICTL.all =0x0006;    		     // Enable master mode, normal phase,
                                                 // enable talk, and SPI int disabled.
	SpiaRegs.SPIBRR =0x007F;					 // SPI速率
//    SpiaRegs.SPICCR.all =0x009F;		         // Relinquish SPI from Reset，16-bit char bits
	SpiaRegs.SPICCR.all =0x0097;		         // Relinquish SPI from Reset，8-bit char bits
    SpiaRegs.SPICCR.bit.SPILBK = 0;				 // spi 自测模式禁止
    SpiaRegs.SPIPRI.bit.FREE = 1;                // Set so breakpoints don't disturb xmission
}



 spi总线发送数据，读寄存器的值
//spi_xmit(ADS1248_CMD_RREG | (StartAddress & 0x0f));
//spi_xmit((NumRegs-1) & 0x0f);
	   spi_xmit(0x55);
//
 读取寄存器接收的值
		for (i=0; i< NumRegs; i++)
		{
			*pData++ = ADS1248ReceiveByte();
		}
	   while(SpiaRegs.SPIFFRX.bit.RXFFST !=1) { }
	   rdata = SpiaRegs.SPIRXBUF;
	   // 发送nop
	   spi_xmit(sdata);
 CS 拉高
	   GpioDataRegs.GPADAT.bit.GPIO19 = 1;

//===========================================================================
// No more.
//===========================================================================