CCS/TM4C1294NCPDT: TM4C1294NCPDT

On an SPI every transaction is both a write and a read. A write started by the master generates the clocks that both write to the slave and read from the slave. At the same time the slave reads from the master and writes to the master. Sometimes, you only need one operation, write or read. In that case the other data is dummy data and can be ignored.

To read from a slave device the TM4C must call SSIDataPut(). You can supply dummy data. That initiates the transaction and data clocked out of the slave will be stored in the FIFO. Then a call to SSIDataGet() will read the data from the FIFO.

Did you check the signal on PD0 (SSI2Tx) with a scope or logic analyzer? Do you have PD0 connected to PD1 (SSI2Rx)?

Here is an example project that can be run on an EK-TM4c1294XL Launchpad. It uses SSI0. To see the data received being echoed back, connect PA4 to PA5 with a jumper wire. Use Code Composer Studio "File" -> "Import" to import this project into your workspace.

/cfs-file/__key/communityserver-discussions-components-files/908/5808.SPI_5F00_Master.zip

Are you trying to do something like this?

The code looks like this:

#include <stdbool.h>
#include <stdint.h>
#include "inc/hw_memmap.h"
#include "inc/hw_types.h"
#include "inc/hw_ssi.h"
#include "driverlib/gpio.h"
#include "driverlib/pin_map.h"
#include "driverlib/ssi.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
//!
//! 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        4
#define SENSOR1             GPIO_PIN_0
#define SENSOR2             GPIO_PIN_1
#define SENSOR3             GPIO_PIN_2
#define SENSOR4             GPIO_PIN_3

unsigned int writeReadSensor(unsigned int sensor, unsigned int size,  unsigned int *buffer);

//*****************************************************************************
//
// 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)
{
    uint32_t ui32SysClock;

    uint32_t pui32DataSensor1[NUM_SSI_DATA];
    uint32_t pui32DataSensor2[NUM_SSI_DATA];
    uint32_t pui32DataSensor3[NUM_SSI_DATA];
    uint32_t pui32DataSensor4[NUM_SSI_DATA];

    ui32SysClock = SysCtlClockFreqSet((SYSCTL_XTAL_25MHZ |
                                       SYSCTL_OSC_MAIN |
                                       SYSCTL_USE_OSC), 25000000);

    //
    // 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);
    // Use GPIOH pins for manual chip selects
    SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOH);

    //
    // 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_PA4_SSI0XDAT0); // TX
    GPIOPinConfigure(GPIO_PA5_SSI0XDAT1); // RX

    //
    // 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 - SSI0Rx
    //      PA4 - SSI0Tx
    //      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_2);
    GPIOPinTypeGPIOOutput(GPIO_PORTH_BASE, SENSOR1 | SENSOR2 | SENSOR3 | SENSOR4);
    // Start with all chip selects high (inactive)
    GPIOPinWrite(GPIO_PORTH_BASE, (SENSOR1 | SENSOR2 | SENSOR3 | SENSOR4),  0x0F);


    //
    // 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, ui32SysClock, SSI_FRF_MOTO_MODE_0,
                       SSI_MODE_MASTER, 1000000, 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, &pui32DataSensor1[0]))
    {
    }

    // send a 0xAA to sensor 2
    pui32DataSensor2[0] = 0xAA;
    writeReadSensor(SENSOR2, 1, pui32DataSensor2);
    // read a byte from sensor 2
    writeReadSensor(SENSOR2, 1, pui32DataSensor2);

    // read 3 bytes from sensor 3
    writeReadSensor(SENSOR3, 3, pui32DataSensor3);

    // read 1 bytes from sensor 4
    writeReadSensor(SENSOR4, 1, pui32DataSensor4);

    // read 1 bytes from sensor 1
    writeReadSensor(SENSOR1, 1, pui32DataSensor1);

    // Return no errors
    //
    return(0);
}

unsigned int writeReadSensor(unsigned int sensor, unsigned int size,  unsigned int *buffer)
{
    unsigned int i;

    if(size > NUM_SSI_DATA)
    {
        size = NUM_SSI_DATA;
    }
    GPIOPinWrite(GPIO_PORTH_BASE, sensor,  0); // Chip select goes low
    for(i = 0; i < size; i++)
    {
        SSIDataPut(SSI0_BASE, buffer[i]); // send from the buffer
        SSIDataGet(SSI0_BASE, &buffer[i]); // read into the buffer
    }
    GPIOPinWrite(GPIO_PORTH_BASE, sensor,  sensor); // Chip select goes high
    return size; // return number of bytes sent and received
}

The project is also attached:

/cfs-file/__key/communityserver-discussions-components-files/908/SPI0_5F00_ManualCS.zip