【学习探索】Hello：LaunchPad（从）--SPI--EK LM3S811（主）

#include "msp430g2553.h"



 



unsigned char temp[5];



static unsigned char num;



 



void main(void)



{



  WDTCTL = WDTPW + WDTHOLD;                 // Stop watchdog timer



  



  /*if (CALBC1_1MHZ ==0xFF || CALDCO_1MHZ == 0xFF)                                     



 

{  



   

while(1);                              

// If calibration constants erased 

// do not load, trap CPU!!



  } 



 

//8Mhz



 

  BCSCTL1 = CALBC1_8MHZ;//0x0C;                    // Set range



 

  DCOCTL = CALDCO_8MHZ;//0x60;                     // Set DCO step +

modulation */



  



  P1SEL = BIT1 + BIT2 + BIT4;



  P1SEL2 = BIT1 + BIT2 + BIT4;



  UCA0CTL1 = UCSWRST;                       // **Put state machine in reset**









  UCA0CTL0 |= UCMSB + UCSYNC + UCMODE_2;               // 3-pin, 8-bit SPI slave 



//官方例程此处注释有误，变成了master

  UCA0CTL1 &= ~UCSWRST;                     // **Initialize USCI state machine**



  IE2 |= UCA0RXIE;                          // Enable USCI0 RX interrupt



  temp[0] = '-';



  temp[1] = '-';



  temp[2] = '-';



  temp[3] = '-';



  temp[4] = '-';



  num = 0;



 



  __bis_SR_register(LPM4_bits + GIE);       // Enter LPM4, enable interrupts



}



 



// Echo character



#pragma vector=USCIAB0RX_VECTOR



__interrupt void USCI0RX_ISR (void)



{



  temp[num] = UCA0RXBUF;



  while (!(IFG2 & UCA0TXIFG));



  UCA0TXBUF = temp[num];



  num++;

  



  if(num == 5)

     num = 0;



}

//*****************************************************************************



 



#include "inc/hw_memmap.h"



#include "inc/hw_ssi.h"



#include "inc/hw_types.h"



#include "driverlib/ssi.h"



#include "driverlib/gpio.h"



#include "driverlib/sysctl.h"



#include "driverlib/uart.h"



#include "utils/uartstdio.h"



 



//*****************************************************************************



//



//! \addtogroup ssi_examples_list



//! <h1>SPI Master

(spi_master)</h1>



//!



//! This example shows how to configure the

SSI0 as SPI Master.  The code will



//! send three characters on the master Tx

then polls the receive FIFO until



//! 3 characters are received on the master

Rx.



//!



//! This example uses the following

peripherals and I/O signals.  You must



//! review these and change as needed for

your own board:



//! - SSI0 peripheral



//! - GPIO Port

A peripheral (for SSI0 pins)



//! - SSI0CLK - PA2



//! - SSI0Fss - PA3



//! - SSI0Rx  - PA4



//! - SSI0Tx  - PA5



//!



//! The following UART signals are

configured only for displaying console



//! messages for this example.  These are not required for operation of SSI0.



//! - UART0 peripheral



//! - GPIO Port

A peripheral (for UART0 pins)



//! - UART0RX - PA0



//! - UART0TX - PA1



//!



//! This example uses the following

interrupt handlers.  To use this example



//! in your own application you must add

these interrupt handlers to your



//! vector table.



//! - None.



//!



//



//*****************************************************************************



 



//*****************************************************************************



//



// Number of bytes to send and receive.



//



//*****************************************************************************



#define NUM_SSI_DATA 5



 



//*****************************************************************************



//



// This function sets up UART0 to be used

for a console to display information



// as the example is running.



//



//*****************************************************************************



void



InitConsole(void)



{



   

//



   

// Enable GPIO port A which is used for UART0 pins.



   

// TODO: change this to whichever GPIO port you are using.



   

//



   

SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);



 



   

//



   

// Configure the pin muxing for UART0 functions on port A0 and A1.



   

// This step is not necessary if your part does not support pin muxing.



   

// TODO: change this to select the port/pin you are using.



   

//



   

GPIOPinConfigure(GPIO_PA0_U0RX);



   

GPIOPinConfigure(GPIO_PA1_U0TX);



 



   

//



   

// Select the alternate (UART) function for these pins.



   

// TODO: change this to select the port/pin you are using.



   

//



   

GPIOPinTypeUART(GPIO_PORTA_BASE, GPIO_PIN_0 | GPIO_PIN_1);



 



   

//



   

// Initialize the UART for console I/O.



   

//



    UARTStdioInit(0);



}



 



//*****************************************************************************



//



// Configure SSI0

 in master Freescale (SPI) mode. 

This example will send out



// 3 bytes of data, then wait for 3 bytes

of data to come in.  This will all be



// done using the polling method.



//



//*****************************************************************************



int



main(void)



{



   

unsigned long ulDataTx[NUM_SSI_DATA];



   

unsigned long ulDataRx[NUM_SSI_DATA];



   

unsigned long ulindex;



 



    //



   

// Set the clocking to run directly from the external

crystal/oscillator.



   

// TODO: The SYSCTL_XTAL_ value must be changed to match the value of

the



   

// crystal on your board.



   

//



   

SysCtlClockSet(SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |



                   SYSCTL_XTAL_6MHZ);



 



   

//



   

// Set up the serial console to use for displaying messages.  This is



   

// just for this example program and is not needed for SSI operation.



   

//



   

InitConsole();



 



   

//



   

// Display the setup on the console.



   

//



   

UARTprintf("SSI ->\n");



   

UARTprintf("  Mode:

SPI\n");



   

UARTprintf("  Data:

8-bit\n\n");



    



   

/*SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);



   

GPIOPinTypeGPIOOutput(GPIO_PORTA_BASE, GPIO_PIN_3);



   

GPIOPinWrite(GPIO_PORTA_BASE, GPIO_PIN_3,0);



   

GPIOPinWrite(GPIO_PORTA_BASE, GPIO_PIN_3,GPIO_PIN_3);



   

GPIOPinWrite(GPIO_PORTA_BASE, GPIO_PIN_3,~0);



   

GPIOPinWrite(GPIO_PORTA_BASE, GPIO_PIN_3,GPIO_PIN_3);



   

SysCtlPeripheralDisable(SYSCTL_PERIPH_GPIOA);*/



   

//



   

// The SSI0 peripheral must be enabled for use.



   

//



   

SysCtlPeripheralEnable(SYSCTL_PERIPH_SSI0);



 



   

//



   

// For this example SSI0 is used with PortA[5:2].  The actual port and pins



   

// used may be different on your part, consult the data sheet for more



   

// information.  GPIO port A needs

to be enabled so these pins can be used.



   

// TODO: change this to whichever GPIO port you are using.



   

//



   

SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);



 



   

//



   

// Configure the pin muxing for SSI0 functions on port A2, A3, A4, and

A5.



   

// This step is not necessary if your part does not support pin muxing.



   

// TODO: change this to select the port/pin you are using.



   

//



   

GPIOPinConfigure(GPIO_PA2_SSI0CLK);



   

GPIOPinConfigure(GPIO_PA3_SSI0FSS);



   

GPIOPinConfigure(GPIO_PA4_SSI0RX);



   

GPIOPinConfigure(GPIO_PA5_SSI0TX);



 



   

//



   

// Configure the GPIO settings for the SSI pins.  This function also gives



   

// control of these pins to the SSI hardware.  Consult the data sheet to



   

// see which functions are allocated per pin.



   

// The pins are assigned as follows:



   

//      PA5 - SSI0Tx



   

//      PA4 - SSI0Rx



   

//      PA3 - SSI0Fss



   

//      PA2 - SSI0CLK



   

// TODO: change this to select the port/pin you are using.



   

//



   

GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_5 | GPIO_PIN_4 | GPIO_PIN_3 |



                   GPIO_PIN_2);



   

//GPIOPinTypeSSI(GPIO_PORTA_BASE, GPIO_PIN_5 | GPIO_PIN_4 | GPIO_PIN_2);



 



   

//



   

// Configure and enable the SSI port for SPI master mode.  Use SSI0,



   

// system clock supply, idle clock level low and active low clock in



   

// freescale SPI mode, master mode, 1MHz SSI frequency, and 8-bit data.



   

// For SPI mode, you can set the polarity of the SSI clock when the SSI



   

// unit is idle.  You can also

configure what clock edge you want to



   

// capture data on.  Please

reference the datasheet for more information on



   

// the different SPI modes.



   

//



   

//SSIConfigSetExpClk(SSI0_BASE, SysCtlClockGet(), SSI_FRF_TI,



   

//                  

SSI_MODE_MASTER, 500000, 8);



   

SSIConfigSetExpClk(SSI0_BASE, SysCtlClockGet(), SSI_FRF_MOTO_MODE_1,



                       SSI_MODE_MASTER, 500000,

8);



 



   

//



   

// Enable the SSI0 module.



   

//



   

SSIEnable(SSI0_BASE);



 



   

//



   

// Read any residual data from the SSI port.  This makes sure the receive



   

// FIFOs are empty, so we don't read any unwanted junk.  This is done here



   

// because the SPI SSI mode is full-duplex, which allows you to send and



   

// receive at the same time.  The

SSIDataGetNonBlocking function returns



   

// "true" when data was returned, and "false" when

no data was returned.



   

// The "non-blocking" function checks if there is any data in

the receive



   

// FIFO and does not "hang" if there isn't.



   

//



   

while(SSIDataGetNonBlocking(SSI0_BASE, &ulDataRx[0]))



    {



    }



 



   

//



   

// Initialize the data to send.



   

//



   

ulDataTx[0] = 'H';//s



   

ulDataTx[1] = 'e';//p



   

ulDataTx[2] = 'l';//i



   

ulDataTx[3] = 'l';//i



   

ulDataTx[4] = 'o';//i



 



   

//



   

// Display indication that the SSI is transmitting data.



   

//



   

UARTprintf("Sent:\n  ");



 



   

//



   

// Send 3 bytes of data.



   

//



    



   

//SSIDataPut(SSI0_BASE, 'A');



    



   

for(ulindex = 0; ulindex < NUM_SSI_DATA; ulindex++)



    {



       

//



       

// Display the data that SSI is transferring.



       

//



       

UARTprintf("'%c' ", ulDataTx[ulindex]);



 



       

//



       

// Send the data using the "blocking" put function.  This function



       

// will wait until there is room in the send FIFO before returning.



       

// This allows you to assure that all the data you send makes it into



       

// the send FIFO.



       

//



       

SSIDataPut(SSI0_BASE, ulDataTx[ulindex]);



    }



 



   

//



   

// Wait until SSI0 is done transferring all the data in the transmit

FIFO.



   

//



   

while(!SSIBusy(SSI0_BASE))



    {



    }



 



   

//



   

// Display indication that the SSI is receiving data.



   

//



   

UARTprintf("\nReceived:\n 

");



 



   

//



   

// Receive 3 bytes of data.



   

//



   

for(ulindex = 0; ulindex < NUM_SSI_DATA; ulindex++)



    {



       

//



       

// Receive the data using the "blocking" Get function. This

function



       

// will wait until there is data in the receive FIFO before returning.



       

//



       

SSIDataGet(SSI0_BASE, &ulDataRx[ulindex]);



 



       

//



       

// Since we are using 8-bit data, mask off the MSB.



       

//



       

ulDataRx[ulindex] &= 0x00FF;



 



       

//



       

// Display the data that SSI0 received.



       

//



       

UARTprintf("'%c' ", ulDataRx[ulindex]);



    }



   

UARTprintf("\n");



 



   

while(1);



   

//



   

// Return no errors



   

//



   

//return(0);



}