LAUNCHXL-CC1310: CC1310

No sure I understand the problem, and an SPI plot of what you are trying to achieve would be helpful.

However, if you want to read 8 bytes from the slave, the Master needs to generate the clock and send something on the MOSI line. If there are no requirements ton the slave side as to what that is, you can send whatever dummy bytes you want.

Assuming that you need something like this:

The transaction needs to be 10 bytes (the two mode change bytes and the 8 dummy bytes), and the Slave will transmit 8 data bytes after the mode change bytes are received. The two first bytes received will be don't care, unless the slave is sending something useful here.

As I said, it is not possible to answer more specific when I do not know exactly what you are trying to do.

Siri

I took the following SPI Master example from the SDK and simplified it a alot.

unsigned char masterRxBuffer[8];
unsigned char masterTxBuffer[8] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

void *masterThread(void *arg0)
{
    SPI_Handle      masterSpi;
    SPI_Params      spiParams;
    SPI_Transaction transaction;

    /* Open SPI as master (default) */
    SPI_Params_init(&spiParams);
    spiParams.frameFormat = SPI_POL0_PHA1;
    spiParams.bitRate = 4000000;
    masterSpi = SPI_open(Board_SPI_MASTER, &spiParams);
    if (masterSpi == NULL) {
        while (1);
    }

    transaction.txBuf = (void *) masterTxBuffer;
    transaction.rxBuf = (void *) masterRxBuffer;

    while(1)
    {
        transaction.count = 2;
        
        // Whatever the MODE CHANGE instruction is
        masterTxBuffer[0] = 0x55;
        masterTxBuffer[1] = 0xCC;

        SPI_transfer(masterSpi, &transaction);

        transaction.count = 8;
        // 8 dummy bytes when receiving 8 bytes from the slave
        masterTxBuffer[0] = 0x00;
        masterTxBuffer[1] = 0x00;

        SPI_transfer(masterSpi, &transaction);

        usleep(10000);
    }
}

On the SPI it looks like this:

My master is not connected to any slave, so nothing is returned on the MISO, and there are no Interrupt line

SIri

If the timing of the CSn signal is a problem or not for your slave module, you need to ask the the slave module provider, I cannot answer that.

If you want to control the CSn manually, you can set .csnPin = PIN_UNASSIGNED in spiCC26XXDMAHWAttrs, and then set up the CSn signal to be controlled by the application (look at the post i referred to Jan. 26th on how to do this).

You application could look something like this:

unsigned char masterRxBuffer[1];
unsigned char masterTxBuffer[1];

void *masterThread(void *arg0)
{
    SPI_Handle      masterSpi;
    SPI_Params      spiParams;
    SPI_Transaction transaction;

    /* Open SPI as master (default) */
    SPI_Params_init(&spiParams);
    spiParams.frameFormat = SPI_POL0_PHA1;
    spiParams.bitRate = 250000;
    masterSpi = SPI_open(Board_SPI_MASTER, &spiParams);
    if (masterSpi == NULL) 
    {
        while (1);
    }

    transaction.txBuf = (void *) masterTxBuffer;
    transaction.rxBuf = (void *) masterRxBuffer;
    transaction.count = 1;

    GPIO_setConfig(Board_SPI0_CSN, GPIO_CFG_OUTPUT | GPIO_CFG_OUT_HIGH);

    while(1)
    {
        GPIO_write(Board_SPI0_CSN, 0);
        masterTxBuffer[0] = 0x55;
        SPI_transfer(masterSpi, &transaction);
        GPIO_write(Board_SPI0_CSN, 1);

        CPUdelay(DELAY_TIME);

        GPIO_write(Board_SPI0_CSN, 0);
        masterTxBuffer[0] = 0xCC;
        SPI_transfer(masterSpi, &transaction);
        GPIO_write(Board_SPI0_CSN, 1);

        CPUdelay(DELAY_TIME);

        uint8_t i = 0;
        for(i = 0; i < 8; i++)
        {
            GPIO_write(Board_SPI0_CSN, 0);
            masterTxBuffer[0] = 0x00;
            SPI_transfer(masterSpi, &transaction);
            GPIO_write(Board_SPI0_CSN, 1);
            CPUdelay(DELAY_TIME);
        }
        usleep(10000);
    }
}

Siri