dsp28335杂记2

adc多通道配置

#define ADC_MODCLK 3
#define ADC_CKPS   0x1   // ADC module clock = HSPCLK/2*ADC_CKPS = 25.0MHz/(1*2) = 12.5MHz
#define ADC_SHCLK  0xf   // S/H width in ADC module periods = 16 ADC clocks

extern Uint16 SampleTable[6];//在main里面是Uint16 SampleTable[6]={0};

void ADC_Init(void)
{
	// Specific clock setting for this example:
	EALLOW;
	SysCtrlRegs.PCLKCR0.bit.ADCENCLK = 1;    // ADC
	EDIS;

	// Specific clock setting for this example:
	EALLOW;
	SysCtrlRegs.HISPCP.all = ADC_MODCLK;	// HSPCLK = SYSCLKOUT/(2*ADC_MODCLK)
	EDIS;

	InitAdc();  // For this example, init the ADC

	// Specific ADC setup for this example:
	AdcRegs.ADCTRL1.bit.ACQ_PS = ADC_SHCLK;  // ADC采样时间选择
	AdcRegs.ADCTRL3.bit.ADCCLKPS = ADC_CKPS; // ADC内核分频
	AdcRegs.ADCTRL1.bit.SEQ_CASC = 1;        // 1级联工作方式
	AdcRegs.ADCTRL3.bit.SMODE_SEL= 0;        // 顺序采样
	AdcRegs.ADCTRL1.bit.CONT_RUN = 1;        // 连续采样

	AdcRegs.ADCTRL1.bit.SEQ_OVRD = 1 ;       // 完成排序后，排序器指针回到最初状态
	AdcRegs.ADCMAXCONV.bit.MAX_CONV1 = 0x2;  // 最大通道个数
	AdcRegs.ADCCHSELSEQ1.bit.CONV00 = 0x0;   // A0 为采样通道
	AdcRegs.ADCCHSELSEQ1.bit.CONV01 = 0x1;   // A1 为采样通道
	AdcRegs.ADCCHSELSEQ1.bit.CONV02 = 0x2;   // A2 为采样通道

	// Start SEQ1
	AdcRegs.ADCTRL2.all = 0x2000;  //软件触发、PWM 触发等，使用软件触发
	//AdcRegs.ADCTRL2.bit.INT_ENA_SEQ1 = 0x1; //允许向CPU发出中断请求
}

void Read_ADCValue(void)
{
	while (AdcRegs.ADCST.bit.INT_SEQ1== 0);//等待 ADC 转换完成，然后清除状态标志
	AdcRegs.ADCST.bit.INT_SEQ1_CLR = 1;
	SampleTable[0] = AdcRegs.ADCRESULT0 >> 4;
	SampleTable[1] = AdcRegs.ADCRESULT1 >> 4;
	SampleTable[2] = AdcRegs.ADCRESULT2 >> 4;
}

SCI-A转rs232（MAX232）收发配置

void UARTa_Init(Uint32 baud)
{
	unsigned char scihbaud=0;
	unsigned char scilbaud=0;
	Uint16 scibaud=0;

	scibaud=37500000/(8*baud)-1;
	scihbaud=scibaud>>8;
	scilbaud=scibaud&0xff;

	EALLOW;
	SysCtrlRegs.PCLKCR0.bit.SCIAENCLK = 1;   // SCI-A
	EDIS;

	InitSciaGpio();

	//Initalize the SCI FIFO
	SciaRegs.SCIFFTX.all=0xE040;
	SciaRegs.SCIFFRX.all=0x204f;
	SciaRegs.SCIFFCT.all=0x0;

	// Note: Clocks were turned on to the SCIA peripheral
	// in the InitSysCtrl() function
	SciaRegs.SCICCR.all =0x0007;   // 1 stop bit,  No loopback
								   // No parity,8 char bits,
								   // async mode, idle-line protocol
	SciaRegs.SCICTL1.all =0x0003;  // enable TX, RX, internal SCICLK,
								   // Disable RX ERR, SLEEP, TXWAKE
	SciaRegs.SCICTL2.all =0x0003;
	SciaRegs.SCICTL2.bit.TXINTENA =1;
	SciaRegs.SCICTL2.bit.RXBKINTENA =1;
	SciaRegs.SCIHBAUD    =scihbaud;  // 9600 baud @LSPCLK = 37.5MHz.
	SciaRegs.SCILBAUD    =scilbaud;
//	SciaRegs.SCICCR.bit.LOOPBKENA =1; // Enable loop back
	SciaRegs.SCICTL1.all =0x0023;     // Relinquish SCI from Reset
}

// Transmit a character from the SCI'
void UARTa_SendByte(int a)
{
	while (SciaRegs.SCIFFTX.bit.TXFFST != 0);
	SciaRegs.SCITXBUF=a;
}

void UARTa_SendString(char * msg)
{
	int i=0;
	
	while(msg[i] != '\0')
	{
		UARTa_SendByte(msg[i]);
		i++;
	}
}
Uint16 UARTa_ReciveByte(void)
{
	while(SciaRegs.SCIFFRX.bit.RXFFST !=1);// wait for XRDY =1 for empty state
	return SciaRegs.SCIRXBUF.all;// Get character
}

char* UARTa_ReciveString(void)
{
    char buff[128] = {0};
	int i=0;
	while((buff[i] != '\0')
	{
		buff[i]=SciaRegs.SCIRXBUF.all;
		i++;
	}
	buff[i] = '\0';
	return buff;
}

SPI收发配置

void SPIA_Init(void)
{
	EALLOW;
	SysCtrlRegs.PCLKCR0.bit.SPIAENCLK = 1; // SPI-A
	EDIS;

	//InitSpiaGpio();
	EALLOW;
	GpioCtrlRegs.GPBPUD.bit.GPIO54 = 0;// Enable pull-up on GPIO54 (SPISIMOA)
    GpioCtrlRegs.GPBPUD.bit.GPIO55 = 0;// Enable pull-up on GPIO55 (SPISOMIA)
    GpioCtrlRegs.GPBPUD.bit.GPIO56 = 0;// Enable pull-up on GPIO56 (SPICLKA)
    GpioCtrlRegs.GPBPUD.bit.GPIO57 = 0;
	GpioCtrlRegs.GPBMUX2.bit.GPIO54 = 1;// Configure GPIO54 as SPISIMOA
    GpioCtrlRegs.GPBMUX2.bit.GPIO55 = 1;// Configure GPIO55 as SPISOMIA
    GpioCtrlRegs.GPBMUX2.bit.GPIO56 = 1;// Configure GPIO56 as SPICLKA
    GpioCtrlRegs.GPBMUX2.bit.GPIO57 = 1;// Configure GPIO57 as SPISTEA
    EDIS;
    
	// Initialize SPI FIFO registers
	SpiaRegs.SPIFFTX.all=0xE040;
	SpiaRegs.SPIFFRX.all=0x204f;
	SpiaRegs.SPIFFCT.all=0x0;

	SpiaRegs.SPICCR.all =0x000F;// Reset on, rising edge, 16-bit char bits
	SpiaRegs.SPICTL.all =0x0006; // Enable master mode, normal phase,
    // enable talk, and SPI int disabled.
	SpiaRegs.SPIBRR =0x007F;
	SpiaRegs.SPICCR.all =0x00DF;// Relinquish SPI from Reset
	SpiaRegs.SPIPRI.bit.FREE = 1;// Set so breakpoints don't disturb xmission
}

Uint16 SPIA_SendReciveData(Uint16 dat)
{
	// Transmit data
	SpiaRegs.SPITXBUF=dat;

	// Wait until data is received
	while(SpiaRegs.SPIFFRX.bit.RXFFST !=1);
	return SpiaRegs.SPIRXBUF;
}

SCI-B 转 rs485（SP3485）收发配置

#define RS485_DIR_SETH		(GpioDataRegs.GPBSET.bit.GPIO61=1)
#define RS485_DIR_SETL		(GpioDataRegs.GPBCLEAR.bit.GPIO61=1)

void RS485_Init(Uint32 baud)
{
	unsigned char scihbaud=0;
	unsigned char scilbaud=0;
	Uint16 scibaud=0;

	scibaud=37500000/(8*baud)-1;
	scihbaud=scibaud>>8;
	scilbaud=scibaud&0xff;


	EALLOW;
	SysCtrlRegs.PCLKCR0.bit.SCIBENCLK = 1;   // SCI-B
	EDIS;

	InitSciGpio();

	EALLOW;
	//RS485_EN端口配置
	GpioCtrlRegs.GPBMUX2.bit.GPIO61=0;
	GpioCtrlRegs.GPBDIR.bit.GPIO61=1;
	GpioCtrlRegs.GPBPUD.bit.GPIO61=0;
	GpioDataRegs.GPBSET.bit.GPIO61=1;
	EDIS;

	// Note: Clocks were turned on to the SCIA peripheral
	// in the InitSysCtrl() function
	ScibRegs.SCICCR.all =0x0007;   // 1 stop bit,  No loopback
								   // No parity,8 char bits,
								   // async mode, idle-line protocol
	ScibRegs.SCICTL1.all =0x0003;  // enable TX, RX, internal SCICLK,
								   // Disable RX ERR, SLEEP, TXWAKE
	ScibRegs.SCICTL2.all =0x0003;
	ScibRegs.SCICTL2.bit.TXINTENA =1;
	ScibRegs.SCICTL2.bit.RXBKINTENA =1;
	ScibRegs.SCIHBAUD    =scihbaud;  // 9600 baud @LSPCLK = 37.5MHz.
	ScibRegs.SCILBAUD    =scilbaud;
	ScibRegs.SCICTL1.all =0x0023;     // Relinquish SCI from Reset

}

// Transmit a character from the SCI'
void RS485_SendByte(int a)
{
	while (ScibRegs.SCICTL2.bit.TXEMPTY == 0);
	ScibRegs.SCITXBUF=a;
}

void RS485_SendString(char * msg)
{
	int i=0;

	while(msg[i] != '\0')
	{
		RS485_SendByte(msg[i]);
		i++;
	}
}

SPI收发配置+中断+loopback+看看就好，嘿嘿

Uint16 sdata[8];     // Send data buffer
Uint16 rdata[8];     // Receive data buffer
Uint16 errcounter;
Uint16 rdata_point; 
void spi_error(void);
interrupt void spiTxFifoIsr(void);
interrupt void spiRxFifoIsr(void);
void SPIA_INT_Init(void)
{
	EALLOW;
	SysCtrlRegs.PCLKCR0.bit.SPIAENCLK = 1;   // SPI-A
	EDIS;

	InitSpiaGpio();

	EALLOW;	// This is needed to write to EALLOW protected registers
	PieVectTable.SPIRXINTA = &spiRxFifoIsr;
	PieVectTable.SPITXINTA = &spiTxFifoIsr;
	EDIS;   // This is needed to disable write to EALLOW protected registers

	// Initialize SPI FIFO registers
	SpiaRegs.SPICCR.bit.SPISWRESET=0; // Reset SPI

	SpiaRegs.SPICCR.all=0x001F;       //16-bit character, Loopback mode
	SpiaRegs.SPICTL.all=0x0017;       //Interrupt enabled, Master/Slave XMIT enabled
	SpiaRegs.SPISTS.all=0x0000;
	SpiaRegs.SPIBRR=0x0063;           // Baud rate
	SpiaRegs.SPIFFTX.all=0xC028;      // Enable FIFO's, set TX FIFO level to 8
	SpiaRegs.SPIFFRX.all=0x0028;      // Set RX FIFO level to 8
	SpiaRegs.SPIFFCT.all=0x00;
	SpiaRegs.SPIPRI.all=0x0010;

	SpiaRegs.SPICCR.bit.SPISWRESET=1;  // Enable SPI

	SpiaRegs.SPIFFTX.bit.TXFIFO=1;
	SpiaRegs.SPIFFRX.bit.RXFIFORESET=1;

	// Enable interrupts required for this example
	PieCtrlRegs.PIECTRL.bit.ENPIE = 1;   // Enable the PIE block
	PieCtrlRegs.PIEIER6.bit.INTx1=1;     // Enable PIE Group 6, INT 1
	PieCtrlRegs.PIEIER6.bit.INTx2=1;     // Enable PIE Group 6, INT 2
	IER=0x20;                            // Enable CPU INT6
	EINT;                                // Enable Global Interrupts
}

interrupt void spiTxFifoIsr(void)
{
 	Uint16 i;
    for(i=0;i<8;i++)
    {
 	   SpiaRegs.SPITXBUF=sdata[i]; // Send data
    }

    for(i=0;i<8;i++)  // Increment data for next cycle
    {
 	   sdata[i]++;
    }
    SpiaRegs.SPIFFTX.bit.TXFFINTCLR=1;  // Clear Interrupt flag
	PieCtrlRegs.PIEACK.all|=0x20;  		// Issue PIE ACK
}

interrupt void spiRxFifoIsr(void)
{
    Uint16 i;
    for(i=0;i<8;i++)
    {
	    rdata[i]=SpiaRegs.SPIRXBUF;		// Read data
	}
	for(i=0;i<8;i++)                    // Check received data
	{
	    if(rdata[i] != rdata_point+i) 
	    	spi_error(); //运行一段时间后，在此处设置断点
	}
	rdata_point++;
	SpiaRegs.SPIFFRX.bit.RXFFOVFCLR=1;  // Clear Overflow flag
	SpiaRegs.SPIFFRX.bit.RXFFINTCLR=1; 	// Clear Interrupt flag
	PieCtrlRegs.PIEACK.all|=0x20;       // Issue PIE ack
}
void spi_error(void)
{
    errcounter++;
    asm("     ESTOP0");	 //Test failed!! Stop!
    for (;;);
}

模拟I2C驱动

#define IIC_SCL_SETH	(GpioDataRegs.GPBSET.bit.GPIO33=1)
#define IIC_SCL_SETL	(GpioDataRegs.GPBCLEAR.bit.GPIO33=1)

#define IIC_SDA_SETH	(GpioDataRegs.GPBSET.bit.GPIO32=1)
#define IIC_SDA_SETL	(GpioDataRegs.GPBCLEAR.bit.GPIO32=1)

#define READ_SDA   		(GpioDataRegs.GPBDAT.bit.GPIO32)

void IICA_Init(void)
{
	EALLOW;
	SysCtrlRegs.PCLKCR3.bit.GPIOINENCLK = 1;// 开启GPIO时钟
	GpioCtrlRegs.GPBPUD.bit.GPIO32 = 0;	  	//上拉
	GpioCtrlRegs.GPBDIR.bit.GPIO32 = 1;   	// 输出端口
	GpioCtrlRegs.GPBMUX1.bit.GPIO32 = 0;  	// IO口
	GpioCtrlRegs.GPBQSEL1.bit.GPIO32 = 3; 	// 不同步

	GpioCtrlRegs.GPBPUD.bit.GPIO33 = 0;	  	//上拉
	GpioCtrlRegs.GPBDIR.bit.GPIO33 = 1;   	// 输出端口
	GpioCtrlRegs.GPBMUX1.bit.GPIO33 = 0;  	// IO口
	GpioCtrlRegs.GPBQSEL1.bit.GPIO33 = 3;   // 不同步
	EDIS;
}
void SDA_OUT(void)
{
	EALLOW;
	GpioCtrlRegs.GPBDIR.bit.GPIO32=1;       //Output. SDA
	EDIS;
}
void SDA_IN(void)
{
	EALLOW;
	GpioCtrlRegs.GPBDIR.bit.GPIO32=0;       //Input, SDA
	EDIS;
}

//===starting......
//产生IIC起始信号
void IIC_Start(void)
{
	SDA_OUT();     //sda线输出
	IIC_SDA_SETH;
	IIC_SCL_SETH;
	DELAY_US(5);
	IIC_SDA_SETL;//START:when CLK is high,DATA change form high to low
	DELAY_US(6);
	IIC_SCL_SETL;//钳住I2C总线，准备发送或接收数据
}

//产生IIC停止信号
void IIC_Stop(void)
{
	SDA_OUT();//sda线输出
	IIC_SCL_SETL;
	IIC_SDA_SETL;//STOP:when CLK is high DATA change form low to high
	IIC_SCL_SETH;
 	DELAY_US(6);
 	IIC_SDA_SETH;//发送I2C总线结束信号
	DELAY_US(6);
}

//等待应答信号到来
unsigned char IIC_Wait_Ack(void)
{
	unsigned char tempTime=0;

	IIC_SDA_SETH;
	DELAY_US(1);
	SDA_IN();      //SDA设置为输入
	IIC_SCL_SETH;
	DELAY_US(1);
	while(READ_SDA)
	{
		tempTime++;
		if(tempTime>250)
		{
			IIC_Stop();
			return 1;
		}
	}
	IIC_SCL_SETL;//时钟输出0
	return 0;
}

//产生ACK应答
void IIC_Ack(void)
{
	IIC_SCL_SETL;
	SDA_OUT();
	IIC_SDA_SETL;
	DELAY_US(2);
	IIC_SCL_SETH;
	DELAY_US(5);
	IIC_SCL_SETL;
}

//产生NACK非应答
void IIC_NAck(void)
{
	IIC_SCL_SETL;
	SDA_OUT();
	IIC_SDA_SETH;
	DELAY_US(2);
	IIC_SCL_SETH;
	DELAY_US(5);
	IIC_SCL_SETL;
}

//IIC发送一个字节
void IIC_Send_Byte(unsigned char txd)
{
	unsigned char t;
	SDA_OUT();
	IIC_SCL_SETL;//拉低时钟开始数据传输
    for(t=0;t<8;t++)
    {
        if((txd&0x80)>0) //0x80  1000 0000
        	IIC_SDA_SETH;
		else
			IIC_SDA_SETL;
        txd<<=1;
        DELAY_US(2);   //对TEA5767这三个延时都是必须的
        IIC_SCL_SETH;
		DELAY_US(2);
		IIC_SCL_SETL;
		DELAY_US(2);
    }
}

//IIC读一个字节ack=1时，发送ACK，ack=0，发送nACK
unsigned char IIC_Read_Byte(unsigned char ack)
{
	unsigned char i,receive=0;
	SDA_IN();//SDA设置为输入
    for(i=0;i<8;i++ )
	{
    	IIC_SCL_SETL;
    	DELAY_US(2);
        IIC_SCL_SETH;
        receive<<=1;
        if(READ_SDA)receive++;
        DELAY_US(1);
    }
    if (!ack)
        IIC_NAck();//发送nACK
    else
        IIC_Ack(); //发送ACK
    return receive;
}

FLASH烧写配置

将工程目录“DSP2833x_Libraries”下的 28335_RAM_lnk.cmd 删除，然后从 TI 提供 给我 们的 库文件 中把 “ F28335.cmd” 拷贝 到现 在实 验文件 夹“DSP2833x_Libraries”目录下

main.c文件
#include "DSP2833x_Device.h" // DSP2833x Headerfile Include File
#include "DSP2833x_Examples.h" // DSP2833x Examples Include File

#include "leds.h"
#include "time.h"
#include "uart.h"
#include "stdio.h"

void main()
{
	Uint16 i=0;
	
	InitSysCtrl();
	InitPieCtrl();
	IER = 0x0000;
	IFR = 0x0000;
	InitPieVectTable();
	
	//复制对时间敏感代码和 FLASH 配置代码到 RAM 中
	// 包括 FLASH 初始化函数 InitFlash();
	// 链 接 后 将 产 生 RamfuncsLoadStart, RamfuncsLoadEnd, 和RamfuncsRunStart
	// 参数. 请参考 F28335.cmd 文件
	MemCopy(&RamfuncsLoadStart, &RamfuncsLoadEnd,&RamfuncsRunStart);
	// 调用 FLASH 初始化函数来设置 flash 等待状态
	// 这个函数必须在 RAM 中运行
	InitFlash();
	
	LED_Init();
	TIM0_Init(150,200000);//200ms
	UARTa_Init(4800);
	while(1)
	{
		// 上面的两条语句 + “F28335.cmd” 配置文件
	}
}

SD卡配置（SD 卡 2.0 协议）

//=======SD卡初始化流程
1、初始化与 SD 卡连接的硬件条件（ MCU 的 SPI 配置， IO 口配置）；
2、上电延时（ >74 个 CLK）；
3、复位卡（ CMD0），进入 IDLE 状态；
4、发送 CMD8，检查是否支持 2.0 协议；
5、根据不同协议检查 SD 卡（命令包括： CMD55、 CMD41、 CMD58 和 CMD1
等）；
6、取消片选，发多 8 个 CLK，结束初始化
//======SD 卡读取数据，这里通过 CMD17 来实现，
1、发送 CMD17；
2、接收卡响应 R1；
3、接收数据起始令牌 0XFE；
4、接收数据；
5、接收 2 个字节的 CRC，如果不使用 CRC，这两个字节在读取后可以丢掉。
6、禁止片选之后，发多 8 个 CLK；
//======SD 卡写数据通过 CMD24 来实现，
1、发送 CMD24;
2、接收卡响应 R1；
3、发送写数据起始令牌 0XFE；
4、发送数据；
5、发送 2 字节的伪 CRC；
6、禁止片选之后，发多 8 个 CLK；