CCS/CC1350: fastest way to continuously send packets

If you want to transmit several packets after each other as fast as possible (and have the radio automatically send preamble, sync, crc. etc. ) you can use command chaining, and chain the TX command to itself. However, using this method, there will still be a small gap between the packets.

If you want true back-to-back transmission, you can achieve this by using infnite length and then write the preamble, sync word, payload, and CRC manually to a data queue. An example on how this can be done can be found here:

e2e.ti.com/.../2184712

BR
Siri

Siri, thanks for your response!

If I use one of the methods I described in the original question, which is to have run_cmd(tx) in a while loop, is the 10ms window for each TX command expected? Or can I expect a much faster rate than this? In terms of speed, is it faster to chain commands together than to have multiple run_cmd()?

In addition, in the example code that you pointed me to, does the board send 100 packets every 1.5s, or does it send 1 packet every 1.5s for 100 times? If it's the latter, would it be ok to move to packetCounter out of the callback function and into the while(1) loop?

Thanks!

Command chaining would be faster that calling the command over and over again manually. What do you mean by an iteration taking 10 ms. How long time the complete loop will take will depend of the data rate you are using and the packet length. What you should look at it the time from exiting TX until entering TX again. With command chaining I would assume that this would take 200-300 us. I have done some measurements with RX-TX and TX-RX, and I would assume that TX-TX would be about the same:

e2e.ti.com/.../562134

The txSyncPacket is sent 100 taimes back-to-back, and this is repeated every 1.5 s.

Siri

I am sorry that I wasn't being clear - my loop is basically just calling tx over and over again and I measured the data rate on the receiver to be about 6 kbps, which means each tx command took roughly 8ms to complete, I was wondering if this is something I would expect.

In the easylink sample code, a 10 ms delay is added to each transmit, and removing this delay caused the packets to be lost/ dropped, and I was wondering if this also suggests that's how long it takes for the transmitter to send a packet.

I modified WakeOnRadioRx to incorporate the code you posted, but it hung on transmit. Here is the code:

/***** Includes *****/
#include <stdlib.h>
#include "RFQueue.h"

/* XDCtools Header files */
#include <xdc/std.h>
#include <xdc/runtime/Assert.h>

/* BIOS Header files */
#include <ti/sysbios/BIOS.h>
#include <ti/sysbios/knl/Semaphore.h>
#include <ti/sysbios/knl/Task.h>

/* TI-RTOS Header files */
#include <ti/drivers/rf/RF.h>
#include <ti/drivers/PIN.h>
#include <ti/display/Display.h>

#include <ti/devices/DeviceFamily.h>
#include DeviceFamily_constructPath(driverlib/cpu.h)

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

/* RF settings */
#include "smartrf_settings/smartrf_settings.h"

/***** Defines *****/
/* Wake-on-Radio configuration */
#define WOR_WAKEUPS_PER_SECOND 2

/* TX number of random payload bytes */
#define PAYLOAD_LENGTH 30

/* WOR Example configuration defines */
#define WOR_PREAMBLE_TIME_RAT_TICKS(x) \
((uint32_t)(4000000*(1.0f/(x))))

/* TX task stack size and priority */
#define TX_TASK_STACK_SIZE 1024
#define TX_TASK_PRIORITY 2

static uint32_t sTime;

/***** Prototypes *****/
static void txTaskFunction(UArg arg0, UArg arg1);
static void initializeTxAdvCmdFromTxCmd(rfc_CMD_PROP_TX_ADV_t* RF_cmdPropTxAdv, rfc_CMD_PROP_TX_t* RF_cmdPropTx);


/***** Variable declarations *****/
/* TX task objects and task stack */
static Task_Params txTaskParams;
Task_Struct txTask; /* not static so you can see in ROV */
static uint8_t txTaskStack[TX_TASK_STACK_SIZE];

/* TX packet payload (length +1 to fit length byte) and sequence number */
static uint8_t packet[PAYLOAD_LENGTH +1];
static uint16_t seqNumber;

/* RF driver objects and handles */
static RF_Object rfObject;
static RF_Handle rfHandle;

/* Pin driver objects and handles */
static PIN_Handle ledPinHandle;
static PIN_Handle buttonPinHandle;
static PIN_State ledPinState;
static PIN_State buttonPinState;

/* TX Semaphore */
static Semaphore_Struct txSemaphore;
static Semaphore_Handle txSemaphoreHandle;

/* Advanced TX command for sending long preamble */
static rfc_CMD_PROP_TX_ADV_t RF_cmdPropTxAdv;

/*
* Application LED pin configuration table:
* - All LEDs board LEDs are off.
*/
PIN_Config pinTable[] =
{
Board_PIN_LED0 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MAX,
Board_PIN_LED1 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MAX,
#if defined Board_CC1352R1_LAUNCHXL
Board_DIO30_RFSW | PIN_GPIO_OUTPUT_EN | PIN_GPIO_HIGH | PIN_PUSHPULL | PIN_DRVSTR_MAX,
#endif
PIN_TERMINATE
};

/*
* Application button pin configuration table:
* - Buttons interrupts are configured to trigger on falling edge.
*/
PIN_Config buttonPinTable[] = {
Board_PIN_BUTTON0 | PIN_INPUT_EN | PIN_PULLUP | PIN_IRQ_NEGEDGE,
PIN_TERMINATE
};


/***** Function definitions *****/
/* Pin interrupt Callback function board buttons configured in the pinTable. */
void buttonCallbackFunction(PIN_Handle handle, PIN_Id pinId) {

/* Simple debounce logic, only toggle if the button is still pushed (low) */
CPUdelay((uint32_t)((48000000/3)*0.050f));
if (!PIN_getInputValue(pinId)) {
/* Post TX semaphore to TX task */
Semaphore_post(txSemaphoreHandle);
}
}

#define PACKET_INTERVAL (uint32_t)(4000000*1.5f) /* Set packet interval to 1.5 s */

#define TX_BUFFERS_TO_SEND 100

/* The buffer below contains a packet that is sent back-to-back TX_BUFFERS_TO_SEND every PACKET_INTERVAL. */
static uint8_t txSyncPacket[] = {
/**********************************************/
0x55, 0x55, 0x55, 0x55, // Preamble
0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55,
0x91, 0xD3, 0x91, 0xD3, // Sync Word
0x01, // Length byte
0xAA, // 1 dummy byte payload
/**********************************************/
};

static rfc_dataEntryPointer_t txEntry;
static dataQueue_t txQueue;

static uint8_t packetCounter = 0;

/***** Prototypes *****/
static void txTaskFunction(UArg arg0, UArg arg1);

/***** Variable declarations *****/
static Task_Params txTaskParams;
Task_Struct txTask; /* not static so you can see in ROV */
static uint8_t txTaskStack[TX_TASK_STACK_SIZE];

static RF_Object rfObject;
static RF_Handle rfHandle;

volatile uint8_t packetSent = false;


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

/*
* ======== main ========
*/
int main(void)
{
/* Call driver init functions. */
Board_initGeneral();
Display_init();

/* Open LED pins */
ledPinHandle = PIN_open(&ledPinState, pinTable);
Assert_isTrue(ledPinHandle != NULL, NULL);

/* Open Button pins */
buttonPinHandle = PIN_open(&buttonPinState, buttonPinTable);
Assert_isTrue(buttonPinHandle != NULL, NULL);

/* Initialize task */
TxTask_init(ledPinHandle);

/* Start BIOS */
BIOS_start();

return (0);
}

/***** Function definitions *****/
void TxTask_init(PIN_Handle inPinHandle)
{
pinHandle = inPinHandle;

Task_Params_init(&txTaskParams);
txTaskParams.stackSize = TX_TASK_STACK_SIZE;
txTaskParams.priority = TX_TASK_PRIORITY;
txTaskParams.stack = &txTaskStack;
txTaskParams.arg0 = (UInt)1000000;

Task_construct(&txTask, txTaskFunction, &txTaskParams, NULL);
}

static void txTaskFunction(UArg arg0, UArg arg1)
{
RF_Params rfParams;
RF_Params_init(&rfParams);

/* Configure TX Entry */
txEntry.pNextEntry = (uint8_t*)&txEntry;
txEntry.status = DATA_ENTRY_PENDING;
txEntry.config.type = DATA_ENTRY_TYPE_PTR;
txEntry.pData = (uint8_t*)txSyncPacket;
txEntry.length = sizeof(txSyncPacket);

/* Configure CMD_PROP_TX_ADV */
RF_cmdPropTxAdv.pPkt = (uint8_t*)&txQueue;
RF_cmdPropTxAdv.pktLen = 0;
RF_cmdPropTxAdv.startTrigger.triggerType = TRIG_ABSTIME;
RF_cmdPropTxAdv.startTrigger.pastTrig = 1;
RF_cmdPropTxAdv.startTime = 0;

txQueue.pCurrEntry = (uint8_t*)&txEntry;
txQueue.pLastEntry = NULL;

/* Request access to the radio */
rfHandle = RF_open(&rfObject, &RF_prop, (RF_RadioSetup*)&RF_cmdPropRadioDivSetup, &rfParams);

/* Set the frequency */
RF_postCmd(rfHandle, (RF_Op*)&RF_cmdFs, RF_PriorityNormal, NULL, 0);

/* Get current time */
sTime = RF_getCurrentTime();
while(true)
{
/* Set absolute TX time to utilize automatic power management */
sTime += PACKET_INTERVAL;
RF_cmdPropTxAdv.startTime = sTime;
packetCounter = 0;
txQueue.pCurrEntry = (uint8_t*)&txEntry;

/* Send packet */
RF_EventMask result = RF_runCmd(rfHandle, (RF_Op*)&RF_cmdPropTxAdv, RF_PriorityNormal, &callback, RF_EventTxEntryDone);
while(!packetSent);
packetSent = false;
}
}

void callback(RF_Handle h, RF_CmdHandle ch, RF_EventMask e)
{
if (e & RF_EventTxEntryDone)
{
packetCounter++;

if (packetCounter == (TX_BUFFERS_TO_SEND - 1))
{
txQueue.pLastEntry = txQueue.pCurrEntry;
}
}
else if (e & RF_EventLastCmdDone)
{
packetSent = true;
}
}

Siri, could you please take a look at the above documents when you have a chance?

Thanks

I am sorry, but I am not quite sure I understand what exactly you are trying to achieve, as you are asking about a lot of different things. For example, you cannot use the WOR example on the RX side, and then transmit packets back-to back on the TX side, and expect that to work (The WOR example expects a long "normal" preamble, as used in the WOR TX example).

If you want to run WOR, you should use the WOR example we provide, and use a long "normal" preamble.

What are you trying to achieve with sending packets back-to back and use WOR?
If you need an application that transmit packets back to back, you need to make sure you have a receiver that can receive and process the packets fast enough.

I am not trying to get WOR working, I am trying to modify WOR so the back to back TX works, since they both used the advanced TX command. I wasn't able to use your code directly, and I thought it might be some setting issues, which is why I started with WOR.

My RX is always receiving.

Hi Siri,

Thank you very much for the response! I set up the latest SDK with the code example that you provided and used another launchpad as the receiver, it seems to be able to receive the data! However, if I change the dummy load from 0xAA to something else, or change the length of the load, the receiver is unable to receive any packets again...Is there a filter being set somewhere? My receiver is just running the sample PacketRx code.

Is .formatConf.nSwBits = 0x8, only need to be set on the TX side under radio settings?