[参考译文] CC1352P7：cc1352p7

要传输长度字节大于255的数据包、需要使用高级 TX 命令。

当您没有分享您正在做的事情时、无法判断您在做什么错。

示例：

#define PAYLOAD_LENGTH          1024
#define SIZE_OF_LENGHT_FIELD    2
#define PACKET_INTERVAL         500000

static RF_Object rfObject;
static RF_Handle rfHandle;

static uint8_t packet[PAYLOAD_LENGTH + SIZE_OF_LENGHT_FIELD];
static uint16_t seqNumber;

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


    RF_cmdPropTxAdv.pktLen = PAYLOAD_LENGTH + SIZE_OF_LENGHT_FIELD; // For the advanced TX command, pktLen must cover length + payload
    RF_cmdPropTxAdv.pPkt = packet;
    RF_cmdPropTxAdv.startTrigger.triggerType = TRIG_NOW;
    RF_cmdPropTxAdv.condition.rule = 1;
    RF_cmdPropTxAdv.pktConf.bUseCrc = 1;

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

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

    while(1)
    {
        uint16_t j;
        uint8_t i = 0;

        // For the advanced TX command, the length must manually be written to the packet
        packet[i++] = (uint8_t)(PAYLOAD_LENGTH >> 8);
        packet[i++] = (uint8_t)(PAYLOAD_LENGTH);

        packet[i++] = (uint8_t)(seqNumber >> 8);
        packet[i++] = (uint8_t)(seqNumber++);

        for (j = i; j < PAYLOAD_LENGTH + SIZE_OF_LENGHT_FIELD; j++)
        {
            packet[j] = j - i + 1;
        }

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

        RF_yield(rfHandle);

        usleep(PACKET_INTERVAL);
    }
}

Siri

我看不到您已经进行了任何更改来支持2字节长长度字段。

我还强烈建议您将 rfPacketRX 示例作为起点、并在开始将任何其他外设包括在示例中之前使这些示例有效。

在做一些测试时、我意识到标头的解读会因使用正常的50kbps PHY 或 SLR PHY 而不同。

以下代码使 TX 和 RX 能够使用 SLR 发送和接收1024字节长的数据包(请注意、TX 与我在上面发布的内容略有不同)

发送：

/* Packet TX Configuration */
#define PAYLOAD_LENGTH          1024 // Max 255 if SIZE_OF_LENGHT_FIELD = 1
#define SIZE_OF_LENGHT_FIELD    2
#define PACKET_INTERVAL         500000  /* Set packet interval to 500000 us or 500 ms */


/***** Prototypes *****/

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

static uint8_t packet[PAYLOAD_LENGTH + SIZE_OF_LENGHT_FIELD];
static uint16_t seqNumber;

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

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 = PAYLOAD_LENGTH + SIZE_OF_LENGHT_FIELD; // For the advanced TX command, pktLen must cover length + payload
    RF_cmdPropTxAdv.pPkt = packet;
    RF_cmdPropTxAdv.startTrigger.triggerType = TRIG_NOW;
    RF_cmdPropTxAdv.condition.rule = 1;     // Not set in sysConfig like for the RF_cmdPropTx
    RF_cmdPropTxAdv.pktConf.bUseCrc = 1;    // Not set in sysConfig like for the RF_cmdPropTx

    /* 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)
    {
        uint16_t j;
        uint8_t i = 0;

        // For the advanced TX command, the length must manually be written to the packet
        if (SIZE_OF_LENGHT_FIELD == 1)
        {
            packet[i++] = (uint8_t)(PAYLOAD_LENGTH);
        }
        else // SIZE_OF_LENGHT_FIELD = 2
        {
            // Normal PHY
            //packet[i++] = (uint8_t)(PAYLOAD_LENGTH >> 8);
            //packet[i++] = (uint8_t)(PAYLOAD_LENGTH);

            // SLR PHY 
            packet[i++] = (uint8_t)(PAYLOAD_LENGTH);
            packet[i++] = (uint8_t)(PAYLOAD_LENGTH >> 8);
        }

        packet[i++] = (uint8_t)(seqNumber >> 8);
        packet[i++] = (uint8_t)(seqNumber++);

        for (j = i; j < PAYLOAD_LENGTH + SIZE_OF_LENGHT_FIELD; j++)
        {
            packet[j] = j - 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);
    }
}

接收：

/* Packet RX Configuration */
#define DATA_ENTRY_HEADER_SIZE 8   /* Constant header size of a Generic Data Entry */
#define MAX_LENGTH             1024 /* Max length byte the radio will accept */
                                   /* Must be less than 256 if SIZE_OF_LENGHT_FIELD = 1 */
#define NUM_DATA_ENTRIES       2   /* NOTE: Only two data entries supported at the moment */
#define SIZE_OF_LENGHT_FIELD   2
#define NUM_APPENDED_BYTES     1 +  SIZE_OF_LENGHT_FIELD /* The Data Entries data field will contain:
                                                          * 1 or 2 header byte(s) (containing the length)
                                                          * A maximum of MAX_LENGTH payload bytes
                                                          * 1 status byte (RF_cmdPropRxAdv.rxConf.bAppendStatus = 0x1) */



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

/***** Variable declarations *****/
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) */
#if defined(__TI_COMPILER_VERSION__)
#pragma DATA_ALIGN (rxDataEntryBuffer, 4);
static uint8_t
rxDataEntryBuffer[RF_QUEUE_DATA_ENTRY_BUFFER_SIZE(NUM_DATA_ENTRIES,
                                                  MAX_LENGTH,
                                                  NUM_APPENDED_BYTES)];
#elif defined(__IAR_SYSTEMS_ICC__)
#pragma data_alignment = 4
static uint8_t
rxDataEntryBuffer[RF_QUEUE_DATA_ENTRY_BUFFER_SIZE(NUM_DATA_ENTRIES,
                                                  MAX_LENGTH,
                                                  NUM_APPENDED_BYTES)];
#elif defined(__GNUC__)
static uint8_t
rxDataEntryBuffer[RF_QUEUE_DATA_ENTRY_BUFFER_SIZE(NUM_DATA_ENTRIES,
                                                  MAX_LENGTH,
                                                  NUM_APPENDED_BYTES)]
                                                  __attribute__((aligned(4)));
#else
#error This compiler is not supported.
#endif

/* Receive dataQueue for RF Core to fill in data */
static dataQueue_t dataQueue;
static rfc_dataEntryGeneral_t* currentDataEntry;
static uint16_t packetLength;
static uint8_t* packetDataPointer;
static rfc_propRxOutput_t rxStatistics;

static uint8_t packet[MAX_LENGTH + NUM_APPENDED_BYTES];

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

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;
    RF_cmdPropRxAdv.condition.rule = 1;
    RF_cmdPropRxAdv.pktConf.bUseCrc = 0x1;
    RF_cmdPropRxAdv.rxConf.bIncludeHdr = 0x1;
    RF_cmdPropRxAdv.rxConf.bAppendStatus = 0x1;
    RF_cmdPropRxAdv.endTrigger.triggerType = 0x1;
    RF_cmdPropRxAdv.pktConf.bCrcIncHdr = 0x1;   // Field specific for the advanced RX command

    if (SIZE_OF_LENGHT_FIELD == 1)
    {
        RF_cmdPropRxAdv.hdrConf.numHdrBits = 8; // Field specific for the advanced RX command
        RF_cmdPropRxAdv.hdrConf.numLenBits = 8; // Field specific for the advanced RX command
    }
    else // SIZE_OF_LENGHT_FIELD = 2
    {
        RF_cmdPropRxAdv.hdrConf.numHdrBits = 16;// Field specific for the advanced RX command
        RF_cmdPropRxAdv.hdrConf.numLenBits = 16;// Field specific for the advanced RX command
    }

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

    /* Enter RX mode and stay forever in RX */
    RF_EventMask terminationReason = 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)
    {
        GPIO_toggle(CONFIG_GPIO_RLED);

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

        if (SIZE_OF_LENGHT_FIELD == 1)
        {
            packetLength      = *(uint8_t*)(&currentDataEntry->data);
            packetDataPointer = (uint8_t*)(&currentDataEntry->data + SIZE_OF_LENGHT_FIELD);

            /* Copy the payload + the status byte to the packet variable */
            memcpy(packet, packetDataPointer, (packetLength + SIZE_OF_LENGHT_FIELD));
        }
        else // SIZE_OF_LENGHT_FIELD = 2
        {
            packetLength         = ((uint16_t)((*(uint8_t*)(&currentDataEntry->data+1)) << 8) |
                                    (uint16_t)(*(uint8_t*)(&currentDataEntry->data)));
            packetDataPointer = (uint8_t*)(&currentDataEntry->data + SIZE_OF_LENGHT_FIELD);

            /* Copy the payload and the status bytes to the packet variable */
            memcpy(packet, packetDataPointer, (packetLength + NUM_APPENDED_BYTES - SIZE_OF_LENGHT_FIELD));
        }
        RFQueue_nextEntry();
    }
}

Siri