CC1311P3: RF RX with Unlimited packet length

The device supports unlimited length, and this can be achieved by settings maxPktLen in the CMD_PROP_RX/CMD_PROP_RX_ADV to 0.

When using unlimited length you need to use the partial read entries to read out the data.

The radio will not start receiving before a sync word is found, but by setting sync length to a minimum the device will most likely trigger on noise once you enter RX, and it will start receiving.

We have not done any testing on this, as receiving continously will not be OK from a power consmuption point of view, and also you will have no way of knowing if there are bit errors in your received data. 

Siri

I used the rfPacketRX example and modified it to use partial read entries and infinite packet length mode.

I set the sync word to be 8 bits.

What I see is that is takes maybe a couple of second before it starts receiving something, and then I get the RF_EventRxEntryDone interrupt at a fixed rate, as long as I handle the queue.

If I want it to starts filling up the data entries tight away, what I had to do was to lower the sync trehold, so that it would find a "sync" word in noise immediately, and start receiving.

However, to be able to receive som useful data, you need to search for a real sync word from the data you are sending.

If you only sync on noise, the receiver will be bit synced to the noise, so that when your real data comes along that you are interested in, you will not receive the properly as thy are not in bit sync with the noise that you triggered on.

I will assume that the data you want to receive have some kind of bit patterrn that can be used for bit syncing?

I did a test where I transmit a continous preamble and use 8 bits of that preamble as sync word

As you can see the preamble is received in the partail read buffers:

Code shown below:

/* Standard C Libraries */
#include <stdlib.h>

/* TI Drivers */
#include <ti/drivers/rf/RF.h>
#include <ti/drivers/GPIO.h>

/* Driverlib Header files */
#include DeviceFamily_constructPath(driverlib/rf_prop_mailbox.h)

/* Board Header files */
#include "ti_drivers_config.h"

/* Application Header files */
#include "RFQueue.h"
#include <ti_radio_config.h>

/***** Prototypes *****/
static void callback(RF_Handle h, RF_CmdHandle ch, RF_EventMask e);

/***** Variable declarations *****/
static RF_Object rfObject;
static RF_Handle rfHandle;

#define PARTIAL_RX_ENTRY_HEADER_SIZE    12
#define DATA_BUFFER_SIZE                20

/* Buffer which contains all Data Entries for receiving data.
 * Pragmas are needed to make sure this buffer is 4 byte aligned (requirement from the RF Core) */
#if defined(__GNUC__)
static uint8_t rxDataEntryBuf1[PARTIAL_RX_ENTRY_HEADER_SIZE + DATA_BUFFER_SIZE] __attribute__((aligned(4)));
static uint8_t rxDataEntryBuf2[PARTIAL_RX_ENTRY_HEADER_SIZE + DATA_BUFFER_SIZE] __attribute__((aligned(4)));
#else
#error This compiler is not supported.
#endif

rfc_dataEntryPartial_t* partialReadEntry1 = (rfc_dataEntryPartial_t*)&rxDataEntryBuf1;
rfc_dataEntryPartial_t* partialReadEntry2 = (rfc_dataEntryPartial_t*)&rxDataEntryBuf2;
rfc_dataEntryPartial_t* currentReadEntry = (rfc_dataEntryPartial_t*)&rxDataEntryBuf1;

// Receive dataQueue for RF Core to fill in data
static dataQueue_t dataQueue;
static uint8_t* packetDataPointer;

/***** Function definitions *****/

void *mainThread(void *arg0)
{
    RF_Params rfParams;
    RF_Params_init(&rfParams);
    partialReadEntry1->length = DATA_BUFFER_SIZE + 4;
    partialReadEntry1->config.type = DATA_ENTRY_TYPE_PARTIAL;
    partialReadEntry1->status = DATA_ENTRY_PENDING;

    partialReadEntry2->length = DATA_BUFFER_SIZE + 4;
    partialReadEntry2->config.type = DATA_ENTRY_TYPE_PARTIAL;
    partialReadEntry2->status = DATA_ENTRY_PENDING;

    partialReadEntry1->pNextEntry = (uint8_t*)partialReadEntry2;
    partialReadEntry2->pNextEntry = (uint8_t*)partialReadEntry1;

    dataQueue.pCurrEntry = (uint8_t*)partialReadEntry1;
    dataQueue.pLastEntry = NULL;

    RF_cmdPropRx.syncWord = 0x55555555;
    RF_cmdPropRx.pQueue = &dataQueue;
    RF_cmdPropRx.maxPktLen = 0;
    RF_cmdPropRadioDivSetup.formatConf.nSwBits = 8;

    rfHandle = RF_open(&rfObject, &RF_prop, (RF_RadioSetup*)&RF_cmdPropRadioDivSetup, &rfParams);

    RF_postCmd(rfHandle, (RF_Op*)&RF_cmdFs, RF_PriorityNormal, NULL, 0);

    RF_runCmd(rfHandle, (RF_Op*)&RF_cmdPropRx, RF_PriorityNormal, &callback, RF_EventRxEntryDone);

    while(1);
}

void callback(RF_Handle h, RF_CmdHandle ch, RF_EventMask e)
{
    if (e & RF_EventRxEntryDone)
    {
        GPIO_toggle(CONFIG_GPIO_RLED);

        // Get a pointer to the first byte
        packetDataPointer = &currentReadEntry->rxData;
        //---------------------------------------------------------------------------
        // Implement code for handling the incoming data
        // .
        // .
        // .
        // .
        //---------------------------------------------------------------------------
        currentReadEntry->status = DATA_ENTRY_PENDING;
        currentReadEntry = (rfc_dataEntryPartial_t*)currentReadEntry->pNextEntry;

    }
}

Siri