dsp281x_spi.c

代码用于测试dsp2812的硬件功能

//###########################################################################
//
// FILE:   DSP281x_Spi.c;
// TITLE:  DSP281x SPI Initialization & Support Functions;
//		   Driving program for MAX7219 driving the 8 digit LED displays ;
// WRITER: ZHANG X.L.
//
///###########################################################################

#include "DSP281x_Device.h"     // DSP281x Headerfile Include File
#include "DSP281x_Examples.h"   // DSP281x Examples Include File


#define FIFO 0

SPIDATA sdat,rdat;
SPIDATA sdata[],rdata[];
const Uint16 ini_7219[4]={0x0c01,0x0a04,0x0b07,0x09ff};
SPIDATA SecDiv = 0x0000;
SPIDATA timeover = 0x0000 ;

void Init_7219(void);
interrupt void SpiTxIntAISR(void);
interrupt void SpiRxIntAISR(void);

//---------------------------------------------------------------------------
// InitSPI: This function initializes the SPI(s) to a known state.
// Attention:as on the DSP2812_V1 board the SPI uses the same GPIO with the ps
// controller,the initialization functions,InitSpi() and InitPort_PS(),can't be
// used in InitDSP() at the same time.
//---------------------------------------------------------------------------
void InitSpi(void)
{
	// Initialize SPI-A:
#if FIFO		// FIFO enhancement is used;
/*	SpiaRegs.SPICCR.bit.SPISWRESET = 0;	// SPI software reset before the configuration changed;
	SpiaRegs.SPICCR.bit.CLKPOLARITY = 0; // 0,Transmit data on the rising edge of SPICLK;1,falling edge;
	SpiaRegs.SPICCR.bit.SPILBK = 0;	// Disable the SPI loop back module;
	//SpiaRegs.SPICCR.bit.SPILBK = 1;	// $;enable the SPI loop back module;
	SpiaRegs.SPICCR.bit.SPICHAR = 15;	// A single character's length during a shift squence;
*/ 	SpiaRegs.SPICCR.all = 0x000F;
/*	SpiaRegs.SPICTL.bit.OVERRUNINTENA = 1; // Enable receiver overrun flag bit(SPISTS.7) interrupts;
	SpiaRegs.SPICTL.bit.CLK_PHASE = 1;	// 0,No half-cycle delay;1,half-cycle delay;
	SpiaRegs.SPICTL.bit.MASTER_SLAVE = 1;	// SPI configured as a master;
	SpiaRegs.SPICTL.bit.TALK = 1; // Enable transmission;
	SpiaRegs.SPICTL.bit.SPIINTENA = 1; //Enable SPI interrupts;
*/ 	SpiaRegs.SPICTL.all = 0x001F;
	SpiaRegs.SPIST.all = 0x0000;
	SpiaRegs.SPIBRR = 0x63; // SPI baund rate = LSPCLK / 4  or = LSPCLK / SPIBRR;
						 // SPI baund rate = 30MHz / 100 = 0.3MHz;
/*	0xc028  1100 0000 0010 1000
	SpiaRegs.SPIFFTX.bit.SPIRST = 1;	// SPI FIFO can resume transmit or receive
	SpiaRegs.SPIFFTX.bit.SPIFFENA = 1;	// Enable SPI FIFO enhancements;
	SpiaRegs.SPIFFTX.bit.TXFIFO = 0;	// Reset transmit FIFO,the FIFO pointer is set to zero;
	//SpiaRegs.SPIFFTX.bit.TXFFINTCLR = 1;// Clear TXFFINT flag in bit 7;
	SpiaRegs.SPIFFTX.bit.TXFFIENA = 1;	// Enable the TX FIFO interrupt based on the TXFFIVL match;
	SpiaRegs.SPIFFTX.bit.TXFFIL = 0x01000;	// Set the transmit interrupt level is 8 words;
*/	SpiaRegs.SPIFFTX.all = 0xC028;
/*	0x0028 0000 0000 0010 1000;
	//SpiaRegs.SPIFFRX.bit.RXFFOVFCLR = 1;	// Clear TXFFOVCLR flag in bit 15;
	SpiaRegs.SPIFFRX.bit.RXFIFORESET = 0;
	//SpiaRegs.SPIFFRX.bit.RXFFINTCLR = 1;
	SpiaRegs.SPIFFRX.bit.RXFFIENA = 1;
	SpiaRegs.SPIFFRX.bit.RXFFIL = 0x01000;
*/ 	SpiaRegs.SPIFFRX.all = 0x0028;
	SpiaRegs.SPIFFCT.all = 0x0000;	// FIFO transmit delay is 0;
/*	0x0010 0000 0000 0001 0000;
	SpiaRegs.SPIPRI.bit.FREE = 1; // Free run,regardless of suspend;
*/ 	SpiaRegs.SPIPRI.all = 0x0010

	SpiaRegs.SPICCR.bit.SPISWRESET = 1; // Renable SPI;
	SpiaRegs.SPIFFTX.bit.TXFIFO = 1; 	// Renable transmit FIFO
	SpiaRegs.SPIFFRX.bit.RXFIFORESET =1;// 

#else		// FIFO enhancements is not used;
	SpiaRegs.SPICCR.all = 0x000F;
	SpiaRegs.SPICTL.all = 0x000E;
	SpiaRegs.SPISTS.all = 0x0000;
	SpiaRegs.SPIBRR = 0xFF;

	//SpiaRegs.SPIFFTX.bit.SPIFFENA = 0;	// Disable SPI FIFO enhancements;

	SpiaRegs.SPIFFTX.all = 0xA000;	// Default,SPI FIFO enhancements disabled;
	SpiaRegs.SPIFFRX.all = 0x201F;
	SpiaRegs.SPIFFCT.all = 0x0000;
	SpiaRegs.SPIPRI.all = 0x0010;

	SpiaRegs.SPICCR.bit.SPISWRESET = 1; // Renable SPI;
#endif
	EALLOW; 
	GpioMuxRegs.GPFMUX.all |=0x000F;	// GPIOF0~GPIOF3 are used as SPI; 
	PieVectTable.SPIRXINTA = &SpiRxIntAISR;
	PieVectTable.SPITXINTA = &SpiTxIntAISR;
	EDIS;

	Init_7219();
}

//----------------------------------------------------------------------------
// Function:transmit or receive a Uint16 charater from the SPI;
//----------------------------------------------------------------------------
void SpiTx(Uint16 oData)
{
	SpiaRegs.SPITXBUF = oData;
	while(SpiaRegs.SPISTS.bit.INT_FLAG != 1);// Wait for transmit;
	SpiaRegs.SPIRXBUF = SpiaRegs.SPIRXBUF;// Dummy read the SPIRXBUF to clear INT_FLAG;
}

Uint16 SpiRx(void)
{
	Uint16 SpiaIData = 0x0000;
	while( !SpiaRegs.SPISTS.bit.INT_FLAG );
	SpiaIData = SpiaRegs.SPITXBUF ;
	return( SpiaIData );
}

//----------------------------------------------------------------------------
//Function:SPI interrupt service routine;
//FIFO mode or nonFIFO mode;
//----------------------------------------------------------------------------
interrupt void SpiTxIntAISR(void)
{
#if FIFO
 	
 	    
    SpiaRegs.SPIFFTX.bit.TXFFINTCLR=1;  // Clear Interrupt flag
	PieCtrlRegs.PIEACK.all = PIEACK_GROUP6;  		// Issue PIE ACK
#else

	SpiaRegs.SPIFFTX.bit.TXFFINTCLR=1;  // Clear Interrupt flag
	PieCtrlRegs.PIEACK.all = PIEACK_GROUP6;  		// Issue PIE ACK
#endif

}

interrupt void SpiRxIntAISR(void)
{   
#if FIFO   
    
	SpiaRegs.SPIFFRX.bit.RXFFOVFCLR=1;  // Clear Overflow flag
	SpiaRegs.SPIFFRX.bit.RXFFINTCLR=1; 	// Clear Interrupt flag
	PieCtrlRegs.PIEACK.all = PIEACK_GROUP6;       // Issue PIE ack
#else
	

	SpiaRegs.SPIFFRX.bit.RXFFOVFCLR=1;  // Clear Overflow flag
	SpiaRegs.SPIFFRX.bit.RXFFINTCLR=1; 	// Clear Interrupt flag
	PieCtrlRegs.PIEACK.all = PIEACK_GROUP6;       // Issue PIE ack
#endif
}

//----------------------------------------------------------------------------
// Function:Initialize the 7219 to drive 8 digits LED displays;
// code B decode ;
//----------------------------------------------------------------------------
void Init_7219(void)
{
	Uint16 i = 0 ;
	Uint16 temp = 0;
	for( i = 0; i < 4; i++)
		SpiTx(ini_7219[i]);
	for( i = 0x0001 ; i < 0x0009 ; i++)
	{
		temp = 0x000A | ( i << 8 );
		SpiTx(temp);
	}
#ifdef	CLOCK_3MINS
	SpiTx( 0x0500 );
	SpiTx( 0x0700 );
	SpiTx( 0x0800 );
#endif

//	for(;;);	// $;

	// Second Div ;
	// 0x0F4240 =1,000,000;
	// CPUTimer0Period,uint:uS;
	SecDiv = ( Uint16 )( 0x0F4240 / CPUTimer0Period );	
}

//----------------------------------------------------------------------------
// Function : Use the 8 digits LED displays as a clock;
// The clock will work for 3 minutes;
//----------------------------------------------------------------------------
void clock_3mins(void)
{
	static Uint16 SecDivCount = 0x0000 , time_second = 0x0000 ;
	Uint16 tmin = 0x0000,t10sec = 0x0000,tsec = 0x0000;
	if( time_second == 0x00B4)		// If time_second is equal to 180 seconds,game is over;
	{
		timeover = 0x0001;
		return;
	}
	if( SecDivCount < (SecDiv - 0x0001) )
	{
		SecDivCount++;
	}
	else
	{
		SecDivCount = 0x0000;
		time_second++;
		tmin = 0x0500 + time_second / 0x003C;			// unit : min;
		t10sec = 0x0700 + time_second % 0x003C / 0x000A;	// unit : 10s;
		tsec = 0x0800 + time_second % 0x003C % 0x000A;	// unit : s
		SpiTx( tmin );
		SpiTx( t10sec );
		SpiTx( tsec );
	}
}
//////////////////////////////////////////////////////////////////////
// Function:the digit led displays show a 8 desimalist digit;
// Dat_dec8 < 99 999 999 = 0x5F5E0FF;
//////////////////////////////////////////////////////////////////////
void DigDisplay_dec8(Uint32 Dat_dec8)
{
	Uint16 i , temp_dec8;
	for( i = 8 ; i > 0 ; i--)
	{
	 	temp_dec8 =  ( i << 8 ) | ((Uint16)( Dat_dec8 % 10));
		Dat_dec8 /= 10;
		SpiTx(temp_dec8); 
	}	
}

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