LAUNCHXL-CC1310: How can exit SPI_transfer in callback mode.

I have another question.

How much length can get SPI data withou CSN handling?

I refered 'spislave' & 'spimaster' example.

it doesn't control CSN pin during 30bytes sending in example.

Please refer to the documentation of the SPI driver here: SPI.h File Reference (ti.com)

I am afraid I do not fully understand exactly what you are trying to do and how it fails.

I recommend that you start with the SPI master and slave example in the SDK, and get it to operate as wanted (correct, number of bytes, correct use of CSn etc.) before you start including the RF driver into the application.

If you are not able to get the master/slave communication up and running, you can share the code with me, so that I can test it.

It needs to be able to run on the CC1310 LP and I would need both master and slave code.

A figure of the SPI data you want to transmit (or that your master transmits if it is not the CC1310) would be needed to be able to guide you on how the slave needs to be configured to be able to receive those data.

Siri

Hi Siri,

As i understood SPI slave callback mode, SPI slave get data from master until specified count. ( In code, "transaction.count = SPI_MSG_LENGTH" )

So i expected that SPI callback always call after SPI transfer end even though SPI_transfer is fail.

But callback sometimes doesn't work. So i need to exit SPI transfer. 

in my code, if doesn't work callback, can't work after "while(transferOK2)".

i need function like "SPI_Params.transferTimeout". but it can use only SPI blocking mode. right?

So i asked function like "transfertimeout" in callback mode.

Other question is about SPI frame format.

In TRM, SPI need to control CSN like below mentioned.

But in SDK example "spislave_CC1310_LAUNCHXL_tirtos_ccs" and "spimaster_CC1310_LAUNCHXL_tirtos_ccs", 

CSN doesn't de-assertion during send 30-Bytes data.

So what is correct information? can i use SPI slave send about 200-bytes data without CSN de-assertion from master ?

below is master SPI waveform ( Y : CSN, B : SPI clock, G : SPI MOSI )

There are no timeout in SPI_MODE_CALLBACK. This is stated in the documentation I sent you.

If you are using SPI_MODE_CALLBACK, and set the transaction.count = 20; on the slave device, you will get a callback after you have received 20 bytes.

That means that if you only transmit 10 bytes from you master in one transaction (transaction.count = 10), you will not get a callback on the slave before you have done two transfers from the master.

That means that if you want to cancel the SPI transfer BEFORE 20 bytes are received, you need to use the SPI_transferCancel().

I have simplified the Master and Slave examples for you, so that you can use these examples and monitor the SPI lines together with the two LEDs, so that you better can understand how this works.

Slave:

#define THREADSTACKSIZE (1024)

#define SPI_MSG_LENGTH  (20)

unsigned char slaveRxBuffer[SPI_MSG_LENGTH];
unsigned char slaveTxBuffer[SPI_MSG_LENGTH];

sem_t slaveSem;

void transferCompleteFxn(SPI_Handle handle, SPI_Transaction *transaction)
{
    sem_post(&slaveSem);
}

void *slaveThread(void *arg0)
{
    SPI_Handle      slaveSpi;
    SPI_Params      spiParams;
    SPI_Transaction transaction;
    uint32_t        i;
    bool            transferOK;
    int32_t         status;

    status = sem_init(&slaveSem, 0, 0);
    if (status != 0)
    {
        while(1);
    }

    GPIO_init();
    SPI_init();

    SPI_Params_init(&spiParams);
    spiParams.frameFormat = SPI_POL0_PHA1;
    spiParams.mode = SPI_SLAVE;
    spiParams.transferCallbackFxn = transferCompleteFxn;
    spiParams.transferMode = SPI_MODE_CALLBACK;
    slaveSpi = SPI_open(Board_SPI_SLAVE, &spiParams);

    if (slaveSpi == NULL)
    {
        while (1);
    }

    for(i = 0; i < SPI_MSG_LENGTH; i++)
        slaveTxBuffer[i] = SPI_MSG_LENGTH - i;

    while(1)
    {
        GPIO_write(Board_GPIO_LED1, 1);
        transaction.count = SPI_MSG_LENGTH;
        transaction.txBuf = (void *) slaveTxBuffer;
        transaction.rxBuf = (void *) slaveRxBuffer;

        transferOK = SPI_transfer(slaveSpi, &transaction);

        if (transferOK)
        {
            // Wait until transfer has completed
            sem_wait(&slaveSem);
            GPIO_toggle(Board_GPIO_LED0);
        }
        GPIO_write(Board_GPIO_LED1, 0);
    }
}

Master:

#define THREADSTACKSIZE (1024)

#define SPI_MSG_LENGTH  (20)

unsigned char masterRxBuffer[SPI_MSG_LENGTH];
unsigned char masterTxBuffer[SPI_MSG_LENGTH];

sem_t transactionSem;

void TransmitReceiveFxn(uint_least8_t index)
{
    sem_post(&transactionSem);
}

uint8_t i = 0;

void *masterThread(void *arg0)
{
    SPI_Handle      masterSpi;
    SPI_Params      spiParams;
    SPI_Transaction transaction;
    bool            transferOK;
    int32_t         status;

    GPIO_init();
    SPI_init();

    GPIO_setConfig(Board_GPIO_BUTTON1, GPIO_CFG_IN_PU | GPIO_CFG_IN_INT_FALLING);
    GPIO_setCallback(Board_GPIO_BUTTON1, TransmitReceiveFxn);
    GPIO_enableInt(Board_GPIO_BUTTON1);

    status = sem_init(&transactionSem, 0, 0);
    if (status != 0)
    {
        while(1);
    }

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

    for(i = 0; i < SPI_MSG_LENGTH; i++)
        masterTxBuffer[i] = i + 1;

    while(1)
    {
        // Press a button to start a transaction
        sem_wait(&transactionSem);

        GPIO_write(Board_GPIO_LED1, 1);

        transaction.count = (SPI_MSG_LENGTH / 2); // Set different length to see how this affects the slave
        transaction.txBuf = (void *) masterTxBuffer;
        transaction.rxBuf = (void *) masterRxBuffer;

        transferOK = SPI_transfer(masterSpi, &transaction);
        if (transferOK)
        {
            GPIO_toggle(Board_GPIO_LED0);
        }
        GPIO_write(Board_GPIO_LED1, 0);
    }
}

Siri

Hi Siri,

I already knew this example. it is that i mentioned.

As far as i understand, CC1310 can't work SPI callback if doesn't get data that number of transaction.count. right?

I need to find other method to progress code regardless number of SPI data.

By the way, could you tell me about frame format?

Chanbin Park said:

Other question is about SPI frame format.

In TRM, SPI need to control CSN like below mentioned.

But in SDK example "spislave_CC1310_LAUNCHXL_tirtos_ccs" and "spimaster_CC1310_LAUNCHXL_tirtos_ccs", 

CSN doesn't de-assertion during send 30-Bytes data.

So what is correct information? can i use SPI slave send about 200-bytes data without CSN de-assertion from master ?

Thank you.

I got it what you mean.

I wanted to insert exception handling in my code. such as unstable connection or something like that.

Thank you.