[参考译文] CC1310：在非 RTOS 中、使用 EasyLink API 无法在射频 RX 与射频 TX 之间切换、反之亦然

https://e2e.ti.com/support/wireless-connectivity/sub-1-ghz-group/sub-1-ghz/f/sub-1-ghz-forum/1462897/cc1310-unable-to-switch-between-rf-rx-to-rf-tx-and-vice-versa-in-no-rtos-with-easylink-api

工具与软件：

您好！

  我的应用要求 CC1310在空闲条件下保持射频 RX 和 UART RX 模式、并且每当在 UART RX 上接收到任何数据时、切换到射频 TX 模式、通过射频发送数据并切换回射频 RX 模式。 此外,只要在 RF 上收到任何数据,就会在 UART TX 上发送数据。 所以、基本来说、它就是 UART 到 RF <-> RF 到 UART 的转换器。 我正在非 RTOS 模式下使用 EasyLink API。 我在 UART 上正确接收到数据、并且每当我尝试切换到 RF TX 模式并在 RF 上发送数据时、CC1310就会进入未知状态。 请帮助。 以下是我的代码片段-  

#include <stdlib.h>
#include <stdbool.h>
#include <stdint.h>

/* TI Drivers */
#include <ti/drivers/rf/RF.h>
#include <ti/drivers/PIN.h>
#include <ti/drivers/Power.h>
#include <ti/drivers/UART.h>
#include <ti/devices/DeviceFamily.h>
#include DeviceFamily_constructPath(driverlib/interrupt.h)
#include <ti/devices/cc13x0/driverlib/sys_ctrl.h>
#include <ti/devices/cc13x0/driverlib/interrupt.h>

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

/* Application Header files */
#include "smartrf_settings/smartrf_settings.h"

/* EasyLink API Header files */
#include "easylink/EasyLink.h"

/* Undefine to not use async mode */
#define RFEASYLINKECHO_ASYNC

#define RFEASYLINKECHO_PAYLOAD_LENGTH     30
// UART buffer
#define UART_BUFFER_SIZE 5
static uint8_t uartRxBuffer[UART_BUFFER_SIZE];
static uint8_t uartTxBuffer[UART_BUFFER_SIZE];

// RF buffer
#define RF_BUFFER_SIZE 128
static uint8_t rfRxBuffer[RF_BUFFER_SIZE];
static uint8_t rfTxBuffer[RF_BUFFER_SIZE];

// UART handle
static UART_Handle uartHandle;

// Function prototypes
void uartInit(void);
void easyLinkInit(void);
void uartRxCallback(UART_Handle handle, void *rxBuf, size_t count);
void transmitOverRF(uint8_t *data, uint8_t length);
void receiveOverRF(void);
void transmitOverUART(uint8_t *data, uint8_t length);
void processEvents(void);
void receiveCallback(EasyLink_RxPacket *rxPacket, EasyLink_Status status);
void transmitCallback(EasyLink_Status status);
/* Pin driver handle */
static PIN_Handle pinHandle;
static PIN_State pinState;

/*
 * Application LED pin configuration table:
 *   - All LEDs board LEDs are off.
 */
PIN_Config pinTable[] = {
    Board_PIN_LED1 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MAX,
    Board_PIN_LED2 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MAX,
    PIN_TERMINATE
};

static volatile bool bEchoDoneFlag;

static bool bBlockTransmit = false;

EasyLink_TxPacket txPacket = {{0}, 0, 0, {0}};



void *mainThread(void *arg0)
{
    uint32_t absTime;
    /* Open LED pins */
    pinHandle = PIN_open(&pinState, pinTable);
    if (pinHandle == NULL)
    {
        while(1);
    }

    /* Clear LED pins */
    PIN_setOutputValue(pinHandle, Board_PIN_LED1, 0);
    PIN_setOutputValue(pinHandle, Board_PIN_LED2, 0);

#ifndef RFEASYLINKECHO_ASYNC
    EasyLink_RxPacket rxPacket = {{0}, 0, 0, 0, 0, {0}};
#endif //RFEASYLINKECHO_ASYNC
     uartInit();
    // Initialize the EasyLink parameters to their default values
    EasyLink_Params easyLink_params;
    EasyLink_Params_init(&easyLink_params);

    /*
     * Initialize EasyLink with the settings found in easylink_config.h
     * Modify EASYLINK_PARAM_CONFIG in easylink_config.h to change the default
     * PHY
     */
    if (EasyLink_init(&easyLink_params) != EasyLink_Status_Success){
        while(1);
    }

    /*
     * If you wish to use a frequency other than the default, use
     * the following API:
     * EasyLink_setFrequency(868000000);
     */
    while(1) {
        //processEvents();
        receiveOverRF();
    }
   
}
// UART initialization
void uartInit(void) {
    UART_init();
    UART_Params uartParams;
    UART_Params_init(&uartParams);

    uartParams.readMode = UART_MODE_CALLBACK;
    uartParams.writeMode = UART_MODE_BLOCKING;
    uartParams.readCallback = uartRxCallback;
    uartParams.readDataMode = UART_DATA_BINARY;
    uartParams.writeDataMode = UART_DATA_BINARY;
    uartParams.baudRate = 115200;

    uartHandle = UART_open(Board_UART0, &uartParams);

    if (uartHandle == NULL) {
        // UART initialization failed
        while (1);
    }

    // Start UART read
    UART_read(uartHandle, uartRxBuffer, UART_BUFFER_SIZE);
}

// EasyLink (RF) initialization
void easyLinkInit(void) {
    if (EasyLink_init(EasyLink_Phy_50kbps2gfsk) != EasyLink_Status_Success) {
        // EasyLink initialization failed
        while (1);
    }
}

// UART RX callback function
void uartRxCallback(UART_Handle handle, void *rxBuf, size_t count) {
    if (count > 0) {
        // Copy received data into RF transmit buffer
        memcpy(rfTxBuffer, rxBuf, count);

        // Transmit data over RF
        ///transmitOverRF(rfTxBuffer, count);
        //Event_post(eventHandle, EVENT_UART_TO_RF);
        transmitOverRF(rfTxBuffer, sizeof(rfTxBuffer));
    }

    // Restart UART read
    UART_read(uartHandle, uartRxBuffer, UART_BUFFER_SIZE);
}

// Process events
/*void processEvents(void) {
    uint32_t events = Event_pend(eventHandle, Event_Id_NONE,
                                 EVENT_UART_TO_RF | EVENT_RF_TO_UART,
                                 BIOS_WAIT_FOREVER);

    if (events & EVENT_UART_TO_RF) {
        // Transmit over RF non-blocking
        transmitOverRF(rfTxBuffer, sizeof(rfTxBuffer));
    }

    if (events & EVENT_RF_TO_UART) {
        // Transmit over UART non-blocking
        transmitOverUART(rfRxBuffer, sizeof(rfRxBuffer));
    }
}*/
void simpleDelay(uint32_t delayInMs) {
    uint32_t i;
    for (i = 0; i < delayInMs * 1000; i++) {
        __nop();  // Do nothing, just waste time
    }
}
// Abort RX and switch to TX mode
void abortRxAndSwitchToTx(void) {
    // Abort any ongoing RX operation
    EasyLink_abort();

    // Delay to ensure RX operation is properly aborted before switching to TX
    simpleDelay(10);  // Adjust this delay as necessary
    // Now the RF driver is free to transmit
    
}
// Transmit data over RF
void transmitOverRF(uint8_t *data, uint8_t length) {
    EasyLink_TxPacket txPacket = {0};

    memcpy(txPacket.payload, data, length);
    txPacket.len = length;
    txPacket.dstAddr[0] = 0xAA; // Example destination address
    txPacket.absTime = 0;       // Transmit immediately
    /*while(EasyLink_abort() != EasyLink_Status_Aborted);
    if (EasyLink_transmit(&txPacket) == EasyLink_Status_Success) {
        // Transmission successful, switch to RX mode
        receiveOverRF();
    } else {
        // Transmission failed
    }*/
    abortRxAndSwitchToTx();
    if(EasyLink_transmit(&txPacket) == EasyLink_Status_Success){
        receiveOverRF();
    }
    //EasyLink_transmitAsync(&txPacket, transmitCallback);
}

// Callback function for transmit completion
void transmitCallback(EasyLink_Status status) {
    if (status == EasyLink_Status_Success) {
        // Transmission successful, go back to RF RX mode
        receiveOverRF();
    } else {
        //System_printf("RF TX failed with status: %d\n", status);
    }
}
// Receive data over RF
void receiveOverRF(void) {
    EasyLink_RxPacket rxPacket = {0};

    // Receive data asynchronously
    //EasyLink_receiveAsync(&rxPacket, receiveCallback);
    if (EasyLink_receive(&rxPacket) == EasyLink_Status_Success) {
        // Copy received data into UART transmit buffer
        memcpy(uartTxBuffer, rxPacket.payload, rxPacket.len);

        // Transmit data over UART
        transmitOverUART(uartTxBuffer, rxPacket.len);
    }
    
}
// Callback function for receive completion
void receiveCallback(EasyLink_RxPacket *rxPacket, EasyLink_Status status) {
    if (status == EasyLink_Status_Success) {
        // Copy received RF data into UART transmit buffer
        memcpy(uartTxBuffer, rxPacket->payload, rxPacket->len);

        // Post RF-to-UART event
        //Event_post(eventHandle, EVENT_RF_TO_UART);
        transmitOverUART(uartTxBuffer, sizeof(uartTxBuffer));
    } else if(status == EasyLink_Status_Aborted){
        //System_printf("RF RX failed with status: %d\n", status);
        EasyLink_transmitAsync(&txPacket, transmitCallback);
    }

    // Restart RX to continue listening
    receiveOverRF();
}
// Transmit data over UART
void transmitOverUART(uint8_t *data, uint8_t length) {
    UART_write(uartHandle, data, length);
}