spi_slave.c

SPI次机通信程序

//###########################################################################
//  
// Original Source by MARK
//
// $Sanch Release: 2AD-2DA-slave V1.00 $
// $Release Date:       MARCH 31, 2009 $
//###########################################################################

//#include "DSP280x_Device.h"     // DSP280x Headerfile Include File
//#include "DSP280x_Examples.h"   // DSP280x Examples Include File
#include "DSP28x_Project.h"     // Device Headerfile and Examples Include File
// Prototype statements for functions found within this file.
// interrupt void ISRTimer2(void);
interrupt void spiTxFifoIsr(void);
interrupt void spiRxFifoIsr(void);
void delay_loop(void);
void spi_fifo_init(void);	
void error();
Uint16 sdata=0x0A001; // Send data buffer
Uint16 sdata_head=0x0A000;//
Uint16 sdata_address_l00=0x0A101;//
Uint16 sdata_address_h00=0x0A202;//
Uint16 sdata_address_l01=0x0A303;//
Uint16 sdata_address_h01=0x0A404;//
Uint16 sdata_over=0x0AFFF;//
Uint16 sdata_head_temp=0x0A000;//
Uint16 sdata_address_l00_temp=0x0A100;//
Uint16 sdata_address_h00_temp=0x0A200;//
Uint16 sdata_address_l01_temp=0x0A300;//
Uint16 sdata_address_h01_temp=0x0A400;//
Uint16 sdata_over_temp=0x0AFFF;//
Uint16 sdata_point=0;  // Keep track of where we are 
                     // in the data stream to check received data 


Uint16 rdata=0; // Receive data buffer
Uint16 rdata_temp=0;//
Uint16 rdata_head=0;//
Uint16 rdata_address_l00=0;//
Uint16 rdata_address_h00=0;//
Uint16 rdata_address_l01=0;//
Uint16 rdata_address_h01=0;//
Uint16 rdata_over=0;//                     
void main(void)
{
// Initialize System Control:
// PLL, WatchDog, enable Peripheral Clocks
// This example function is found in the DSP280x_SysCtrl.c file.
   InitSysCtrl();

// 2. Initalize GPIO: 
// InitGpio();  // 
// Setup only the GP I/O only for SPI-A functionality
   InitSpiaGpio();

// 3. Initialize PIE vector table:
// Disable and clear all CPU interrupts
   DINT;
   IER = 0x0000;
   IFR = 0x0000;

// Initialize PIE control registers to their default state:
// This function is found in the DSP280x_PieCtrl.c file.
   InitPieCtrl();

// Initialize the PIE vector table with pointers to the shell Interrupt 
   InitPieVectTable();

// Interrupts that are used in this example are re-mapped to
// ISR functions found within this file.  
   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

	
// 4. Initialize all the Device Peripherals:
   spi_fifo_init();	  // Initialize the SPI only

	
//specific code, enable interrupts:
// Enable interrupts
   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
	
// Step 6. IDLE loop. Just sit and loop forever (optional):	
	for(;;);

} 	


void spi_fifo_init()										
{
// Initialize SPI FIFO registers
   SpiaRegs.SPICCR.bit.SPISWRESET=0; // Reset SCI

   SpiaRegs.SPICCR.all=0x000F;       //1f 16-bit character, Loopback mode 
   // .7SPI复位 .6时钟极性0上升沿传送1下降
   SpiaRegs.SPICTL.all=0x0013;       //13 Interrupt enabled, Master/Slave XMIT enabled
   //.3时钟相位  .4接受溢出中断使能
   SpiaRegs.SPISTS.all=0x0000;
   //SpiaRegs.SPIBRR=0x007F;           // Baud rate
   SpiaRegs.SPIFFTX.all=0xC028;      // Enable FIFO's, set TX FIFO level to 8
   SpiaRegs.SPIFFRX.all=0x0028;      // Set RX FIFO level to 31
   SpiaRegs.SPIFFCT.all=0x00;
  //SpiaRegs.SPIPRI.all=0x0040;
   SpiaRegs.SPIPRI.all=0x0011;       //0位为1三线模式
    
   SpiaRegs.SPICCR.bit.SPISWRESET=1;  // Enable SCI

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

interrupt void spiTxFifoIsr(void)
{
	if(sdata_point==5)//防止8位一组的数据被破坏了
		{
		sdata_head_temp=sdata_head;
		sdata_address_l00_temp=sdata_address_l00;//
		sdata_address_h00_temp=sdata_address_h00;//
		sdata_address_l01_temp=sdata_address_l01;//
		sdata_address_h01_temp=sdata_address_h01;//
		sdata_over_temp=sdata_over;// 
		} 
	if(SpiaRegs.SPIFFTX.bit.TXFFST==0)    //发送
		{
		if(sdata_point==0)
 	    sdata=sdata_head_temp;      // Send data
		else if(sdata_point==1)
 	    sdata=sdata_address_l00_temp;      // Send data
		else if(sdata_point==2)
 	    sdata=sdata_address_h00_temp;      // Send data
		else if(sdata_point==3)
 	    sdata=sdata_address_l01_temp;      // Send data
		else if(sdata_point==4)
 	    sdata=sdata_address_h01_temp;      // Send data
		else if(sdata_point==5)
 	    sdata=sdata_over_temp;      // Send data
		SpiaRegs.SPITXBUF=sdata;
		}
	sdata_point++;
	if(sdata_point>=6)
	sdata_point=0;


    SpiaRegs.SPIFFTX.bit.TXFFINTCLR=1;  // Clear Interrupt flag
	PieCtrlRegs.PIEACK.all|=0x20;  		// Issue PIE ACK
}  
interrupt void spiRxFifoIsr(void)
{
    rdata=SpiaRegs.SPIRXBUF; 

    if((rdata&0x0f000)==0x0A000)
    	{
    	rdata_temp=rdata;
		if( (rdata_temp&0x0ff00)==0x0A000 )
		rdata_head=rdata_temp;
		else if( (rdata_temp&0x0ff00)==0x0A100 )
		rdata_address_l00=rdata_temp;
		else if( (rdata_temp&0x0ff00)==0x0A200 )
		rdata_address_h00=rdata_temp;
		else if( (rdata_temp&0x0ff00)==0x0A300 )
		rdata_address_l01=rdata_temp;
		else if( (rdata_temp&0x0ff00)==0x0A400 )
		rdata_address_h01=rdata_temp;
		else if( (rdata_temp&0x0ff00)==0x0AF00 )
		rdata_over=rdata_temp;
		} 
	SpiaRegs.SPIFFRX.bit.RXFFOVFCLR=1;  // Clear Overflow flag
	SpiaRegs.SPIFFRX.bit.RXFFINTCLR=1; 	// Clear Interrupt flag
	PieCtrlRegs.PIEACK.all|=0x20;       // Issue PIE ack

} 

  


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