[参考译文] LP-EM-CC1354P10：如何使用高级数据包格式发送超过 255 字节的数据

嗨、Anbu

您选择的 PHY 不使用正常的数据包格式、其中长度是同步后的前 1 或两个字节。 它使用符合 IEEE 802.15.4g 标准的数据包格式、其中 SYNC 后的前两个字节包括模式切换设置、有关 CRC 长度的信息、白化以及 11 位长数据包长度字段。

以下代码可用于发送和接收采用此格式的 2047 字节长数据包：

TX：

// Packet TX Configuration
#define PAYLOAD_LENGTH      2045                            // Max 2045, as the length in the header is 11 bits, and can be max 2047

#define SIZE_OF_HEADER      2                               // Do Not Change
#define LENGTH_IN_HEADER    PAYLOAD_LENGTH + SIZE_OF_HEADER // Max 2047 (11 bits)

#define _802_15_4_G_HEADER  0x18                            // MS = 0
                                                            // FCS = 1 (2 byte CRC)
                                                            // DW = 1 (Data Whitening enabled)

#define PACKET_INTERVAL     500000                          // Set packet interval to 500000 us or 500 ms

static RF_Object rfObject;
static RF_Handle rfHandle;

uint16_t header;
uint8_t packet[SIZE_OF_HEADER + PAYLOAD_LENGTH];
uint16_t seqNumber;

void *mainThread(void *arg0)
{
    RF_Params rfParams;
    RF_Params_init(&rfParams);

    GPIO_setConfig(CONFIG_GPIO_GLED, GPIO_CFG_OUT_STD | GPIO_CFG_OUT_LOW);

    GPIO_write(CONFIG_GPIO_GLED, CONFIG_GPIO_LED_OFF);

    RF_cmdPropTxAdv.pktLen = LENGTH_IN_HEADER;
    RF_cmdPropTxAdv.pPkt = packet;

    // 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);

    while(1)
    {
        // IEEE_802_15_4_g Header (2 byte CRC, whitening, 11 bits length)
        header = (_802_15_4_G_HEADER << 8) + (LENGTH_IN_HEADER & 0x07FF);

        packet[0] = (uint8_t)(header);
        packet[1] = (uint8_t)(header >> 8);

        for (uint16_t i = 2; i < PAYLOAD_LENGTH + SIZE_OF_HEADER; i++)
        {
            packet[i] = (i - 1);
        }

        // Send packet
        RF_runCmd(rfHandle, (RF_Op*)&RF_cmdPropTxAdv, RF_PriorityNormal, NULL, 0);

        GPIO_toggle(CONFIG_GPIO_GLED);

        // Power down the radio
        RF_yield(rfHandle);

        // Sleep for PACKET_INTERVAL us
        usleep(PACKET_INTERVAL);
    }
}

接收：

#define DATA_ENTRY_HEADER_SIZE 8    // Constant header size of a Generic Data Entry
#define NUM_DATA_ENTRIES       2    // NOTE: Only two data entries supported at the moment

#define SIZE_OF_HEADER         2    // Cannot be changed (IEEE_802_15_4_g)

// Optional appended bytes at the end of the packet
//  -------------------------------------------------------
//  | CRC1 | CRC0 | RSSI | TS0 | TS1 | TS2 | TS3 | Status |
//  -------------------------------------------------------

#define CRC                     0   // 2 if .rxConf.bIncludeCrc = 0x1, 0 otherwise
#define RSSI                    0   // 1 if .rxConf.bAppendRssi = 0x1, 0 otherwise
#define TIMESTAMP               0   // 4 if .rxConf.bAppendTimestamp = 0x1, 0 otherwise
#define STATUS                  0   // 1 if .rxConf.bAppendStatus = 0x1, 0 otherwise

#define NUM_APPENDED_BYTES      CRC + RSSI + TIMESTAMP + STATUS

#define MAX_LENGTH              2047 // Max length byte the radio will accept

#define PAYLOAD_LENGTH          (MAX_LENGTH - SIZE_OF_HEADER)

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

static RF_Object rfObject;
static RF_Handle rfHandle;

/* 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) */
static uint8_t rxDataEntryBuffer[RF_QUEUE_DATA_ENTRY_BUFFER_SIZE(NUM_DATA_ENTRIES,
                                                                 MAX_LENGTH,
                                                                 NUM_APPENDED_BYTES)]
                                                                 __attribute__((aligned(4)));
// Receive dataQueue for RF Core to fill in data
dataQueue_t dataQueue;
rfc_dataEntryGeneral_t* currentDataEntry;
uint16_t packetLength;
uint8_t* packetDataPointer;
rfc_propRxOutput_t rxStatistics;

uint8_t packet[PAYLOAD_LENGTH + NUM_APPENDED_BYTES];

void *mainThread(void *arg0)
{
    RF_Params rfParams;
    RF_Params_init(&rfParams);

    GPIO_setConfig(CONFIG_GPIO_RLED, GPIO_CFG_OUT_STD | GPIO_CFG_OUT_LOW);
    GPIO_write(CONFIG_GPIO_RLED, CONFIG_GPIO_LED_OFF);

    if( RFQueue_defineQueue(&dataQueue,
                            rxDataEntryBuffer,
                            sizeof(rxDataEntryBuffer),
                            NUM_DATA_ENTRIES,
                            MAX_LENGTH + NUM_APPENDED_BYTES))
    {
        // Failed to allocate space for all data entries
        while(1);
    }

    // Modify CMD_PROP_RX command for application needs
    // Set the Data Entity queue for received data
    RF_cmdPropRxAdv.pQueue = &dataQueue;

    // Discard ignored packets from Rx queue
    RF_cmdPropRxAdv.rxConf.bAutoFlushIgnored = 1;

    // Discard packets with CRC error from Rx queue
    RF_cmdPropRxAdv.rxConf.bAutoFlushCrcErr = 1;

    // Implement packet length filtering to avoid PROP_ERROR_RXBUF
    RF_cmdPropRxAdv.maxPktLen = MAX_LENGTH;
    RF_cmdPropRxAdv.pktConf.bRepeatOk = 1;
    RF_cmdPropRxAdv.pktConf.bRepeatNok = 1;
    RF_cmdPropRxAdv.pOutput = (uint8_t*)&rxStatistics;

    // Optional bytes to append:
    RF_cmdPropRxAdv.rxConf.bIncludeCrc = 0x0;
    RF_cmdPropRxAdv.rxConf.bAppendRssi = 0x0;
    RF_cmdPropRxAdv.rxConf.bAppendTimestamp = 0x0;
    RF_cmdPropRxAdv.rxConf.bAppendStatus = 0x0;

    // 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);

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

    while(1);
}

void callback(RF_Handle h, RF_CmdHandle ch, RF_EventMask e)
{
    if (e & RF_EventRxEntryDone)
    {
        // Toggle pin to indicate RX
        GPIO_toggle(CONFIG_GPIO_RLED);

        // Get current unhandled data entry
        currentDataEntry = RFQueue_getDataEntry();

        packetLength = 0x07FF & (((uint16_t)((*(uint8_t*)(&currentDataEntry->data+1)) << 8) |
                                  (uint16_t)(*(uint8_t*)(&currentDataEntry->data))));
        packetDataPointer = (uint8_t*)(&currentDataEntry->data + SIZE_OF_HEADER);

        // Copy the payload and the status bytes to the packet variable
        memcpy(packet, packetDataPointer, (packetLength + NUM_APPENDED_BYTES));

        RFQueue_nextEntry();
    }
}

BR

Siri

如果您在未进行修改的情况下运行我与您共享的代码、它的工作原理是：

我共享的 RX 代码对 RX 使用重复模式：

RF_cmdPropRxAdv.pktConf.bRepeatOk = 1;
RF_cmdPropRxAdv.pktConf.bRepeatNok = 1;

因此、  除非您（例如）在某处设置断点、否则永远不会从 RF_runCmd（因为这是一个分块命令）返回。

在无线电位于 RX 中时设置断点将停止 CPU、但射频内核仍将运行、因此您将耗尽数据条目来存储接收到的数据包 (RX 命令的状态将为 PROP_ERROR_RXBUF)

如果您希望能够为每个接收到的数据包设置断点、则需要关闭重复模式、并 在 while 循环中调用 RF_runCmd（为每个接收到的数据包调用一次）。

Siri

下面是 RX 和 TX 的示例、其中展示了如何使用 高级命令来传输数据包、并且长度字段为 2 字节长。

假设您已从 SysConfig 中选择 500kbps PHY（该 PHY 使用高级命令和 IEEE802.15.4g 格式）。

这些代码还将与其他使用相同格式的 PHY 配合使用。

启用 CRC 并附加所有状态字节。

当接收到具有“CRC OK“（CRC 正常）的数据包时、RX 将退出。 我使用非阻塞 RX、因此器件可以在等待接收数据包的同时执行其他任务（使 LED 闪烁）。

TX：

/* Standard C Libraries */
#include <stdlib.h>
#include <unistd.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"
#include <ti_radio_config.h>

#define PAYLOAD_LENGTH      500     // MAX 4093
#define PACKET_INTERVAL     500000  // Set packet interval to 500000 us or 500 ms
#define LENGTH_FIELD        2

uint8_t packet[LENGTH_FIELD + PAYLOAD_LENGTH];

static RF_Object rfObject;
static RF_Handle rfHandle;

static uint16_t seqNumber;

void *mainThread(void *arg0)
{
    RF_Params rfParams;
    RF_Params_init(&rfParams);

    GPIO_setConfig(CONFIG_GPIO_GLED, GPIO_CFG_OUT_STD | GPIO_CFG_OUT_LOW);

    GPIO_write(CONFIG_GPIO_GLED, CONFIG_GPIO_LED_OFF);

    // Setting in the CMD_PROP_RADIO_DIV_SETUP and CMD_PROP_TX_ADV command that needs to be changed from 
    // what SysConfig generated. It is assume that settings using the 802.15.4g format is selected in SysConfig
    RF_cmdPropRadioDivSetup.formatConf.nSwBits = 0x20;
    RF_cmdPropRadioDivSetup.formatConf.whitenMode = 0x0;

    RF_cmdPropTxAdv.startTrigger.triggerType = 0x0;
    RF_cmdPropTxAdv.startTrigger.pastTrig = 0x0;
    RF_cmdPropTxAdv.numHdrBits = 0x0;
    RF_cmdPropTxAdv.pktLen = LENGTH_FIELD + PAYLOAD_LENGTH;
    RF_cmdPropTxAdv.preTrigger.triggerType = 0x0;
    RF_cmdPropTxAdv.preTrigger.pastTrig = 0x0;
    RF_cmdPropTxAdv.syncWord = 0x930B51DE;
    RF_cmdPropTxAdv.pPkt = packet;

    // 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);

    while(1)
    {
        // |---------------------------------------------------------------------------------------------------------------
        // | PAYLOAD_LENGTH1 | PAYLOAD_LENGTH0 | SEQ1 | SEQ0 | Data0 | Data1 | ............... | Data(PAYLOAD_LENGTH - 3) |
        // |---------------------------------------------------------------------------------------------------------------

        packet[0] = (uint8_t)(PAYLOAD_LENGTH >> 8);
        packet[1] = (uint8_t)(PAYLOAD_LENGTH);
        packet[2] = (uint8_t)(seqNumber >> 8);
        packet[3] = (uint8_t)(seqNumber++);

        uint16_t i;
        for (i = 4; i < (LENGTH_FIELD + PAYLOAD_LENGTH); i++)
        {
            packet[i] = i - 4;
        }

        RF_runCmd(rfHandle, (RF_Op*)&RF_cmdPropTxAdv, RF_PriorityNormal, NULL, 0);

        GPIO_toggle(CONFIG_GPIO_GLED);

        // Power down the radio
        RF_yield(rfHandle);

        // Sleep for PACKET_INTERVAL us
        usleep(PACKET_INTERVAL);
    }
}

接收：

/* 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>

// DATA ENTRIES
#define DATA_ENTRY_HEADER_SIZE  8       // Constant header size of a Generic Data Entry
#define NUM_DATA_ENTRIES        2       // NOTE: Only two data entries supported at the moment

// Optional appended bytes at the end of the packet
//  -------------------------------------------------------
//  | CRC1 | CRC0 | RSSI | TS0 | TS1 | TS2 | TS3 | Status |
//  -------------------------------------------------------

#define CRC                     2       // 2 if .rxConf.bIncludeCrc = 0x1, 0 otherwise
#define RSSI                    1       // 1 if .rxConf.bAppendRssi = 0x1, 0 otherwise
#define TIMESTAMP               4       // 4 if .rxConf.bAppendTimestamp = 0x1, 0 otherwise
#define STATUS                  1       // 1 if .rxConf.bAppendStatus = 0x1, 0 otherwise

#define LENGTH_FIELD            2       // RF_cmdPropRx.rxConf.bIncludeHdr = 0x1
#define MAX_LENGTH              500     // Max length the radio will accept (can max be 4093)

#define NUM_APPENDED_BYTES  LENGTH_FIELD + CRC + RSSI + TIMESTAMP + STATUS

uint8_t packet[MAX_LENGTH + NUM_APPENDED_BYTES - LENGTH_FIELD]; // Length stored in packetLength variable so no need to make room for that
uint16_t packetLength;

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

static RF_Object rfObject;
static RF_Handle rfHandle;

static uint8_t rxDataEntryBuffer[RF_QUEUE_DATA_ENTRY_BUFFER_SIZE(NUM_DATA_ENTRIES,
                                                                 MAX_LENGTH,
                                                                 NUM_APPENDED_BYTES)]
                                                                 __attribute__((aligned(4)));
static dataQueue_t dataQueue;
static rfc_dataEntryGeneral_t* currentDataEntry;

static uint8_t* packetDataPointer;
rfc_propRxOutput_t rxStatistics;
bool packetReceived = false;

uint16_t crc;
int8_t rssi;
uint32_t timestamp;
uint8_t status;

void *mainThread(void *arg0)
{
    RF_Params rfParams;
    RF_Params_init(&rfParams);

    GPIO_setConfig(CONFIG_GPIO_RLED, GPIO_CFG_OUT_STD | GPIO_CFG_OUT_LOW);
    GPIO_setConfig(CONFIG_GPIO_GLED, GPIO_CFG_OUT_STD | GPIO_CFG_OUT_LOW);
    GPIO_write(CONFIG_GPIO_RLED, CONFIG_GPIO_LED_OFF);
    GPIO_write(CONFIG_GPIO_GLED, CONFIG_GPIO_LED_OFF);

    if( RFQueue_defineQueue(&dataQueue,
                            rxDataEntryBuffer,
                            sizeof(rxDataEntryBuffer),
                            NUM_DATA_ENTRIES,
                            MAX_LENGTH + NUM_APPENDED_BYTES))
    {
        while(1);
    }

    // Setting in the CMD_PROP_RADIO_DIV_SETUP and CMD_PROP_RX_ADV command that needs to be changed from 
    // what SysConfig generated. It is assume that settings using the 802.15.4g format is selected in SysConfig
    RF_cmdPropRadioDivSetup.formatConf.nSwBits = 0x20;
    RF_cmdPropRadioDivSetup.formatConf.whitenMode = 0x0;

    RF_cmdPropRxAdv.pktConf.bRepeatNok = 0x1;
    RF_cmdPropRxAdv.pktConf.bCrcIncHdr = 0x1;

    RF_cmdPropRxAdv.pktConf.filterOp = 0x0;
    RF_cmdPropRxAdv.rxConf.bAutoFlushCrcErr = 0x1;
    RF_cmdPropRxAdv.syncWord0 = 0x930B51DE;
    RF_cmdPropRxAdv.maxPktLen = MAX_LENGTH;
    RF_cmdPropRxAdv.hdrConf.numLenBits = 0x10;
    RF_cmdPropRxAdv.lenOffset = 0x00;
    RF_cmdPropRxAdv.pQueue = &dataQueue;

    // Optional bytes to append:
    RF_cmdPropRxAdv.rxConf.bIncludeCrc = 0x1;
    RF_cmdPropRxAdv.rxConf.bAppendRssi = 0x1;
    RF_cmdPropRxAdv.rxConf.bAppendTimestamp = 0x1;
    RF_cmdPropRxAdv.rxConf.bAppendStatus = 0x1;

    // Optional (for debugging)
    RF_cmdPropRxAdv.pOutput = (uint8_t*)&rxStatistics;

    // 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);

    while(1)
    {
        RF_postCmd(rfHandle, (RF_Op*)&RF_cmdPropRxAdv, RF_PriorityNormal, &callback, RF_EventRxEntryDone);

        while(!packetReceived)
        {
            // Do something else while waiting for a packet to be received
            GPIO_toggle(CONFIG_GPIO_GLED);
        }
        packetReceived = false;
    }
}

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

        currentDataEntry = RFQueue_getDataEntry();

        packetLength        = ((uint16_t)(*(uint8_t*)(&currentDataEntry->data + 1) << 8) |
                               (uint16_t)(*(uint8_t*)(&currentDataEntry->data + 0) << 0));

        packetDataPointer   = (uint8_t*)(&currentDataEntry->data + LENGTH_FIELD);

        memcpy(packet, packetDataPointer, (packetLength + NUM_APPENDED_BYTES - LENGTH_FIELD));

        crc                 = ((uint16_t)(packet[packetLength + 0] << 8) +
                               (uint16_t)(packet[packetLength + 1] << 0));

        rssi                = packet[packetLength + 2];

        timestamp           = ((uint32_t)(packet[packetLength + 3] << 0 ) +
                               (uint32_t)(packet[packetLength + 4] << 8 ) +
                               (uint32_t)(packet[packetLength + 5] << 16) +
                               (uint32_t)(packet[packetLength + 6] << 24));

        status              = packet[packetLength + 7];

        RFQueue_nextEntry();

        packetReceived = true;
    }
}

BR

Siri

请参阅 out rfUARTBridge 示例。

Siri