This thread has been locked.

If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.

CC2650EM-7ID-RD: Sending received data from CC2650 over UART

Part Number: CC2650EM-7ID-RD
Other Parts Discussed in Thread: CC2650, SYSBIOS

Hello, 

I'm using the rfEasyLink example from ti resource explorer, so I loaded rfEasyLinkRx on the first CC2650 and rfEasyLinkTx on the other CC2650.

Now, I am trying to send the data received from the CC2650 receiver over UART to my computer, I would like to use the uartecho example.

I actually have two questions:

1-Am I sending the data (between the CC2650 Rx and the CC2650 TX) via BLE?, Otherwise, what type of protocol used to carry out this communication in the rfEasyLink example.

2-How can I combine the two codes (rfEasyLinkRx and uartecho) to send the data received from the CC2650 via UART. However, if there is any other solution to do that?

I will appreciate any support

Best regards

  • Hello - the rfEasyLink TX/RX examples use our EasyLink APIs to configure the lower-level RF drivers to transmit packets. For more information on the EasyLink API and usage refer to the Proprietary RF User's guide

    To print out data received, the direction you are going is correct. The UART drivers should allow you to do print out your received messages to a serial monitor. Alternatively, you can set breakpoints & debug your application to see the incoming packets.

    If you are interested in BLE on the CC2650, you can learn more about our bluetooth stack here: https://www.ti.com/tool/BLE-STACK

    Alternatively, we recommend you check our our latest bluetooth MCU offerings with the http://ti.com/product/cc2640 and http://ti.com/product/cc2642R devices.

  • Hello, 

    Thank you for your prompt reply, I'm trying to read the documentation, but things are still not clear for me, since I'm new with RTOS and BLE programming

    Best regards

  • Hello,

    I'm starting with the easyLink exemple just to get familiare with TI-RTOS programming then I will switch to BLE.

    I create tow Tasks (in RX code) one for uart driver and the other for RF driver. Here below my codes for transmitter CC2650 and Receiver CC2650.

    I tested the uart driver and it's working well. but when I try to printing out the received data from the TX CC2650 (rxPaquet) i got only zeros!

    Could you please help me figure out why i didn't get the right data?

    Best regards

    ******************************TX Code***********************

    /* XDCtools Header files */
    #include <stdlib.h>
    #include <xdc/std.h>
    #include <xdc/runtime/System.h>
    #include <xdc/runtime/Error.h>

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

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

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

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

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

    #define RFEASYLINKTX_TASK_STACK_SIZE 1024
    #define RFEASYLINKTX_TASK_PRIORITY 2

    #define RFEASYLINKTX_BURST_SIZE 10
    #define RFEASYLINKTXPAYLOAD_LENGTH 30

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

    /* 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_LED1 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MAX,
    Board_LED2 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MAX,
    PIN_TERMINATE
    };

    static uint16_t seqNumber;

    #ifdef RFEASYLINKTX_ASYNC
    static Semaphore_Handle txDoneSem;
    #endif //RFEASYLINKTX_ASYNC

    #ifdef RFEASYLINKTX_ASYNC
    void txDoneCb(EasyLink_Status status)
    {
    if (status == EasyLink_Status_Success)
    {
    /* Toggle LED1 to indicate TX */
    PIN_setOutputValue(pinHandle, Board_LED1,!PIN_getOutputValue(Board_LED1));
    }
    else if(status == EasyLink_Status_Aborted)
    {
    /* Toggle LED2 to indicate command aborted */
    PIN_setOutputValue(pinHandle, Board_LED2,!PIN_getOutputValue(Board_LED2));
    }
    else
    {
    /* Toggle LED1 and LED2 to indicate error */
    PIN_setOutputValue(pinHandle, Board_LED1,!PIN_getOutputValue(Board_LED1));
    PIN_setOutputValue(pinHandle, Board_LED2,!PIN_getOutputValue(Board_LED2));
    }

    Semaphore_post(txDoneSem);
    }
    #endif //RFEASYLINKTX_ASYNC

    static void rfEasyLinkTxFnx(UArg arg0, UArg arg1)
    {
    uint8_t txBurstSize = 0;

    #ifdef RFEASYLINKTX_ASYNC
    /* Create a semaphore for Async */
    Semaphore_Params params;
    Error_Block eb;

    /* Init params */
    Semaphore_Params_init(&params);
    Error_init(&eb);

    /* Create semaphore instance */
    txDoneSem = Semaphore_create(0, &params, &eb);
    #endif //TX_ASYNC

    EasyLink_init(EasyLink_Phy_Custom);

    /* If you wich to use a frequency other than the default use
    * the below API
    * EasyLink_setFrequency(868000000);
    */

    /* Set output power to 12dBm */
    EasyLink_setRfPwr(12);

    while(1) {
    EasyLink_TxPacket txPacket = { {0}, 0, 0, {0} };

    /* Create packet with incrementing sequence number and random payload */
    txPacket.payload[0] = (uint8_t)(seqNumber >> 8);
    txPacket.payload[1] = (uint8_t)(seqNumber++);
    uint8_t i;
    for (i = 2; i < RFEASYLINKTXPAYLOAD_LENGTH; i++)
    {
    txPacket.payload[i] = 0xFF;
    }

    txPacket.len = RFEASYLINKTXPAYLOAD_LENGTH;
    txPacket.dstAddr[0] = 0xaa;

    /* Add a Tx delay for > 500ms, so that the abort kicks in and brakes the burst */
    if(txBurstSize++ >= RFEASYLINKTX_BURST_SIZE)
    {
    /* Set Tx absolute time to current time + 1s */
    txPacket.absTime = EasyLink_getAbsTime() + EasyLink_ms_To_RadioTime(1000);
    txBurstSize = 0;
    }
    /* Else set the next packet in burst to Tx in 100ms */
    else
    {
    /* Set Tx absolute time to current time + 100ms */
    txPacket.absTime = EasyLink_getAbsTime() + EasyLink_ms_To_RadioTime(100);
    }

    #ifdef RFEASYLINKTX_ASYNC
    EasyLink_transmitAsync(&txPacket, txDoneCb);
    /* Wait 300ms for Tx to complete */
    if(Semaphore_pend(txDoneSem, (300000 / Clock_tickPeriod)) == FALSE)
    {
    /* TX timed out, abort */
    if(EasyLink_abort() == EasyLink_Status_Success)
    {
    /*
    * Abort will cause the txDoneCb to be called, and the txDoneSem ti
    * Be released. So we must consume the txDoneSem
    * */
    Semaphore_pend(txDoneSem, BIOS_WAIT_FOREVER);
    }
    }
    #else
    EasyLink_Status result = EasyLink_transmit(&txPacket);

    if (result == EasyLink_Status_Success)
    {
    /* Toggle LED1 to indicate TX */
    PIN_setOutputValue(pinHandle, Board_LED1,!PIN_getOutputValue(Board_LED1));
    }
    else
    {
    /* Toggle LED1 and LED2 to indicate error */
    PIN_setOutputValue(pinHandle, Board_LED1,!PIN_getOutputValue(Board_LED1));
    PIN_setOutputValue(pinHandle, Board_LED2,!PIN_getOutputValue(Board_LED2));
    }
    #endif //RFEASYLINKTX_ASYNC
    }
    }

    void txTask_init(PIN_Handle inPinHandle) {
    pinHandle = inPinHandle;

    Task_Params_init(&txTaskParams);
    txTaskParams.stackSize = RFEASYLINKTX_TASK_STACK_SIZE;
    txTaskParams.priority = RFEASYLINKTX_TASK_PRIORITY;
    txTaskParams.stack = &txTaskStack;
    txTaskParams.arg0 = (UInt)1000000;

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

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

    /* Open LED pins */
    pinHandle = PIN_open(&pinState, pinTable);
    if(!pinHandle) {
    System_abort("Error initializing board LED pins\n");
    }

    /* Clear LED pins */
    PIN_setOutputValue(pinHandle, Board_LED1, 0);
    PIN_setOutputValue(pinHandle, Board_LED2, 0);

    txTask_init(pinHandle);

    /* Start BIOS */
    BIOS_start();

    return (0);
    }

    ****************************** RX Code ***********************************************

    * ======== rfEasyLinkRx.c ========
    */
    /* XDCtools Header files */
    #include <xdc/std.h>
    #include <xdc/runtime/System.h>
    #include <xdc/runtime/Error.h>

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

    /* TI-RTOS Header files */
    #include <ti/drivers/PIN.h>
    #include <ti/drivers/UART.h>

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

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

    /***** Defines *****/
    #define UARTTASKSTACKSIZE 768

    /* Undefine to remove address filter and async mode */
    #define RFEASYLINKRX_ASYNC
    #define RFEASYLINKRX_ADDR_FILTER

    #define RFEASYLINKEX_TASK_STACK_SIZE 1024
    #define RFEASYLINKEX_TASK_PRIORITY 2 


    /***** Variable declarations *****/
    static Task_Params rxTaskParams;
    Task_Struct rxTask; /* not static so you can see in ROV */
    static uint8_t rxTaskStack[RFEASYLINKEX_TASK_STACK_SIZE];


    Task_Struct uart_taskStruct;
    Char uart_taskStack[UARTTASKSTACKSIZE];

    /* Pin driver handle */
    static PIN_Handle ledPinHandle;
    static PIN_State ledPinState;

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

    /* The RX Output struct contains statistics about the RX operation of the radio */
    PIN_Handle pinHandle;

    #ifdef RFEASYLINKRX_ASYNC
    static Semaphore_Handle rxDoneSem;
    #endif

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

    #ifdef RFEASYLINKRX_ASYNC
    void rxDoneCb(EasyLink_RxPacket * rxPacket, EasyLink_Status status)
    {
    if (status == EasyLink_Status_Success)
    {
    /* Toggle LED2 to indicate RX */

    PIN_setOutputValue(pinHandle, Board_LED2,!PIN_getOutputValue(Board_LED2));
    }
    else if(status == EasyLink_Status_Aborted)
    {
    /* Toggle LED1 to indicate command aborted */
    PIN_setOutputValue(pinHandle, Board_LED1,!PIN_getOutputValue(Board_LED1));
    }
    else
    {
    /* Toggle LED1 and LED2 to indicate error */
    PIN_setOutputValue(pinHandle, Board_LED1,!PIN_getOutputValue(Board_LED1));
    PIN_setOutputValue(pinHandle, Board_LED2,!PIN_getOutputValue(Board_LED2));
    }

    Semaphore_post(rxDoneSem);
    }
    #endif

    static void rfEasyLinkRxFnx(UArg arg0, UArg arg1)
    {
    const char echoPrompt[] = "Hello World \n";

    UART_Handle uart;
    Task_Params uart_taskParams;
    UART_Params uartParams;


    Task_Params_init(&uart_taskParams);
    uart_taskParams.stackSize = UARTTASKSTACKSIZE;
    uart_taskParams.stack = &uart_taskStack;
    uart_taskParams.priority = 1;

    /* Create a UART with data processing off. */
    UART_Params_init(&uartParams);
    uartParams.writeDataMode = UART_DATA_BINARY;
    uartParams.readDataMode = UART_DATA_BINARY;
    uartParams.readReturnMode = UART_RETURN_FULL;
    uartParams.readEcho = UART_ECHO_OFF;
    uartParams.baudRate = 1500000;
    uart = UART_open(Board_UART0, &uartParams);

    if (uart == NULL) {
    System_abort("Error opening the UART");
    }

    #ifndef RFEASYLINKRX_ASYNC
    EasyLink_RxPacket rxPacket = {0};
    #endif

    #ifdef RFEASYLINKRX_ASYNC
    /* Create a semaphore for Async*/
    Semaphore_Params params;
    Error_Block eb;

    /* Init params */
    Semaphore_Params_init(&params);
    Error_init(&eb);

    /* Create semaphore instance */
    rxDoneSem = Semaphore_create(0, &params, &eb);
    #endif //RFEASYLINKRX_ASYNC

    EasyLink_init(EasyLink_Phy_Custom);

    /* If you wich to use a frequency other than the default use
    * the below API
    * EasyLink_setFrequency(868000000);
    */

    #ifdef RFEASYLINKRX_ADDR_FILTER
    uint8_t addrFilter = 0xaa;
    EasyLink_enableRxAddrFilter(&addrFilter, 1, 1);
    #endif //RFEASYLINKRX_ADDR_FILTER

    while(1) {
    #ifdef RFEASYLINKRX_ASYNC
    EasyLink_RxPacket rxPacket = {{0}, 0, 0, 0, 0, {0}};
    EasyLink_receiveAsync(rxDoneCb, 0);

    UART_write(uart, rxPacket.payload, sizeof(rxPacket.len));

    //UART_write(uart, echoPrompt, sizeof(echoPrompt));


    /* Wait 300ms for Rx */
    if(Semaphore_pend(rxDoneSem, (300000 / Clock_tickPeriod)) == FALSE)
    {
    /* RX timed out abort */
    if(EasyLink_abort() == EasyLink_Status_Success)
    {
    /* Wait for the abort */
    Semaphore_pend(rxDoneSem, BIOS_WAIT_FOREVER);
    }
    }
    #else
    rxPacket.absTime = 0;
    EasyLink_Status result = EasyLink_receive(&rxPacket);

    if (result == EasyLink_Status_Success)
    {
    /* Toggle LED2 to indicate RX */
    PIN_setOutputValue(pinHandle, Board_LED2,!PIN_getOutputValue(Board_LED2));

    }
    else
    {
    /* Toggle LED1 and LED2 to indicate error */
    PIN_setOutputValue(pinHandle, Board_LED1,!PIN_getOutputValue(Board_LED1));
    PIN_setOutputValue(pinHandle, Board_LED2,!PIN_getOutputValue(Board_LED2));
    }
    #endif //RX_ASYNC
    }
    }

    void rxTask_init(PIN_Handle ledPinHandle) {
    pinHandle = ledPinHandle;

    Task_Params_init(&rxTaskParams);
    rxTaskParams.stackSize = RFEASYLINKEX_TASK_STACK_SIZE;
    rxTaskParams.priority = RFEASYLINKEX_TASK_PRIORITY;
    rxTaskParams.stack = &rxTaskStack;
    rxTaskParams.arg0 = (UInt)1000000;

    Task_construct(&rxTask, rfEasyLinkRxFnx, &rxTaskParams, NULL);
    }

    /*
    * ======== main ========
    */
    int main(void)
    { //Task_Params uart_taskParams;
    /* Call board init functions. */
    Board_initGeneral();
    Board_initUART();

    /* Open LED pins */
    ledPinHandle = PIN_open(&ledPinState, pinTable);
    if(!ledPinHandle) {
    System_abort("Error initializing board LED pins\n");
    }

    /* Clear LED pins */
    PIN_setOutputValue(ledPinHandle, Board_LED1, 0);
    PIN_setOutputValue(ledPinHandle, Board_LED2, 0);

    rxTask_init(ledPinHandle);

    /* Start BIOS */
    BIOS_start();

    return (0);
    }

  • hello

    I'm starting with the easyLink exemple just to get familiare with TI-RTOS programming then I will switch to BLE.

    I create two Tasks one for uart driver and the other for RF driver, Here below my codes for transmitter CC2650 and Receiver CC2650.

    I tested the uart driver and it worked well. but when i try printing out the received data from the TX CC2650 i got only zeros!

    Could you please help me figure out why i didn't get the right data

    Best regards

    *********************** TX *****************************


    /*
    * ======== rfEasyLinkRx.c ========
    */
    /* XDCtools Header files */
    #include <stdlib.h>
    #include <xdc/std.h>
    #include <xdc/runtime/System.h>
    #include <xdc/runtime/Error.h>

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

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

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

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

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

    #define RFEASYLINKTX_TASK_STACK_SIZE 1024
    #define RFEASYLINKTX_TASK_PRIORITY 2

    #define RFEASYLINKTX_BURST_SIZE 10
    #define RFEASYLINKTXPAYLOAD_LENGTH 30

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

    /* 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_LED1 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MAX,
    Board_LED2 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MAX,
    PIN_TERMINATE
    };

    static uint16_t seqNumber;

    #ifdef RFEASYLINKTX_ASYNC
    static Semaphore_Handle txDoneSem;
    #endif //RFEASYLINKTX_ASYNC

    #ifdef RFEASYLINKTX_ASYNC
    void txDoneCb(EasyLink_Status status)
    {
    if (status == EasyLink_Status_Success)
    {
    /* Toggle LED1 to indicate TX */
    PIN_setOutputValue(pinHandle, Board_LED1,!PIN_getOutputValue(Board_LED1));
    }
    else if(status == EasyLink_Status_Aborted)
    {
    /* Toggle LED2 to indicate command aborted */
    PIN_setOutputValue(pinHandle, Board_LED2,!PIN_getOutputValue(Board_LED2));
    }
    else
    {
    /* Toggle LED1 and LED2 to indicate error */
    PIN_setOutputValue(pinHandle, Board_LED1,!PIN_getOutputValue(Board_LED1));
    PIN_setOutputValue(pinHandle, Board_LED2,!PIN_getOutputValue(Board_LED2));
    }

    Semaphore_post(txDoneSem);
    }
    #endif //RFEASYLINKTX_ASYNC

    static void rfEasyLinkTxFnx(UArg arg0, UArg arg1)
    {
    uint8_t txBurstSize = 0;

    #ifdef RFEASYLINKTX_ASYNC
    /* Create a semaphore for Async */
    Semaphore_Params params;
    Error_Block eb;

    /* Init params */
    Semaphore_Params_init(&params);
    Error_init(&eb);

    /* Create semaphore instance */
    txDoneSem = Semaphore_create(0, &params, &eb);
    #endif //TX_ASYNC

    EasyLink_init(EasyLink_Phy_Custom);

    /* If you wich to use a frequency other than the default use
    * the below API
    * EasyLink_setFrequency(868000000);
    */

    /* Set output power to 12dBm */
    EasyLink_setRfPwr(12);

    while(1) {
    EasyLink_TxPacket txPacket = { {0}, 0, 0, {0} };

    /* Create packet with incrementing sequence number and random payload */
    txPacket.payload[0] = (uint8_t)(seqNumber >> 8);
    txPacket.payload[1] = (uint8_t)(seqNumber++);
    uint8_t i;
    for (i = 2; i < RFEASYLINKTXPAYLOAD_LENGTH; i++)
    {
    txPacket.payload[i] = 0xFF;
    }

    txPacket.len = RFEASYLINKTXPAYLOAD_LENGTH;
    txPacket.dstAddr[0] = 0xaa;

    /* Add a Tx delay for > 500ms, so that the abort kicks in and brakes the burst */
    if(txBurstSize++ >= RFEASYLINKTX_BURST_SIZE)
    {
    /* Set Tx absolute time to current time + 1s */
    txPacket.absTime = EasyLink_getAbsTime() + EasyLink_ms_To_RadioTime(1000);
    txBurstSize = 0;
    }
    /* Else set the next packet in burst to Tx in 100ms */
    else
    {
    /* Set Tx absolute time to current time + 100ms */
    txPacket.absTime = EasyLink_getAbsTime() + EasyLink_ms_To_RadioTime(100);
    }

    #ifdef RFEASYLINKTX_ASYNC
    EasyLink_transmitAsync(&txPacket, txDoneCb);
    /* Wait 300ms for Tx to complete */
    if(Semaphore_pend(txDoneSem, (300000 / Clock_tickPeriod)) == FALSE)
    {
    /* TX timed out, abort */
    if(EasyLink_abort() == EasyLink_Status_Success)
    {
    /*
    * Abort will cause the txDoneCb to be called, and the txDoneSem ti
    * Be released. So we must consume the txDoneSem
    * */
    Semaphore_pend(txDoneSem, BIOS_WAIT_FOREVER);
    }
    }
    #else
    EasyLink_Status result = EasyLink_transmit(&txPacket);

    if (result == EasyLink_Status_Success)
    {
    /* Toggle LED1 to indicate TX */
    PIN_setOutputValue(pinHandle, Board_LED1,!PIN_getOutputValue(Board_LED1));
    }
    else
    {
    /* Toggle LED1 and LED2 to indicate error */
    PIN_setOutputValue(pinHandle, Board_LED1,!PIN_getOutputValue(Board_LED1));
    PIN_setOutputValue(pinHandle, Board_LED2,!PIN_getOutputValue(Board_LED2));
    }
    #endif //RFEASYLINKTX_ASYNC
    }
    }

    void txTask_init(PIN_Handle inPinHandle) {
    pinHandle = inPinHandle;

    Task_Params_init(&txTaskParams);
    txTaskParams.stackSize = RFEASYLINKTX_TASK_STACK_SIZE;
    txTaskParams.priority = RFEASYLINKTX_TASK_PRIORITY;
    txTaskParams.stack = &txTaskStack;
    txTaskParams.arg0 = (UInt)1000000;

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

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

    /* Open LED pins */
    pinHandle = PIN_open(&pinState, pinTable);
    if(!pinHandle) {
    System_abort("Error initializing board LED pins\n");
    }

    /* Clear LED pins */
    PIN_setOutputValue(pinHandle, Board_LED1, 0);
    PIN_setOutputValue(pinHandle, Board_LED2, 0);

    txTask_init(pinHandle);

    /* Start BIOS */
    BIOS_start();

    return (0);
    }

    ******************************** RX **************************************

    /*
    * ======== rfEasyLinkRx.c ========
    */
    /* XDCtools Header files */
    #include <xdc/std.h>
    #include <xdc/runtime/System.h>
    #include <xdc/runtime/Error.h>

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

    /* TI-RTOS Header files */
    #include <ti/drivers/PIN.h>
    #include <ti/drivers/UART.h>

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

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

    /***** Defines *****/
    #define UARTTASKSTACKSIZE 768

    /* Undefine to remove address filter and async mode */
    #define RFEASYLINKRX_ASYNC
    #define RFEASYLINKRX_ADDR_FILTER

    #define RFEASYLINKEX_TASK_STACK_SIZE 1024
    #define RFEASYLINKEX_TASK_PRIORITY 2 //it was 2 before

    /***** Variable declarations *****/
    static Task_Params rxTaskParams;
    Task_Struct rxTask; /* not static so you can see in ROV */
    static uint8_t rxTaskStack[RFEASYLINKEX_TASK_STACK_SIZE];


    Task_Struct uart_taskStruct;
    Char uart_taskStack[UARTTASKSTACKSIZE];

    /* Pin driver handle */
    static PIN_Handle ledPinHandle;
    static PIN_State ledPinState;

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

    /* The RX Output struct contains statistics about the RX operation of the radio */
    PIN_Handle pinHandle;

    #ifdef RFEASYLINKRX_ASYNC
    static Semaphore_Handle rxDoneSem;
    #endif

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


    #ifdef RFEASYLINKRX_ASYNC
    void rxDoneCb(EasyLink_RxPacket * rxPacket, EasyLink_Status status)
    {
    if (status == EasyLink_Status_Success)
    {
    /* Toggle LED2 to indicate RX */

    PIN_setOutputValue(pinHandle, Board_LED2,!PIN_getOutputValue(Board_LED2));
    }
    else if(status == EasyLink_Status_Aborted)
    {
    /* Toggle LED1 to indicate command aborted */
    PIN_setOutputValue(pinHandle, Board_LED1,!PIN_getOutputValue(Board_LED1));
    }
    else
    {
    /* Toggle LED1 and LED2 to indicate error */
    PIN_setOutputValue(pinHandle, Board_LED1,!PIN_getOutputValue(Board_LED1));
    PIN_setOutputValue(pinHandle, Board_LED2,!PIN_getOutputValue(Board_LED2));
    }

    Semaphore_post(rxDoneSem);
    }
    #endif

    static void rfEasyLinkRxFnx(UArg arg0, UArg arg1)
    {
    const char echoPrompt[] = "Hello Badra \n";
    int i;
    UART_Handle uart;
    Task_Params uart_taskParams;
    UART_Params uartParams;


    Task_Params_init(&uart_taskParams);
    uart_taskParams.stackSize = UARTTASKSTACKSIZE;
    uart_taskParams.stack = &uart_taskStack;
    uart_taskParams.priority = 1;

    /* Create a UART with data processing off. */
    UART_Params_init(&uartParams);
    uartParams.writeDataMode = UART_DATA_BINARY;
    uartParams.readDataMode = UART_DATA_BINARY;
    uartParams.readReturnMode = UART_RETURN_FULL;
    uartParams.readEcho = UART_ECHO_OFF;
    uartParams.baudRate = 1500000;
    uart = UART_open(Board_UART0, &uartParams);

    if (uart == NULL) {
    System_abort("Error opening the UART");
    }

    #ifndef RFEASYLINKRX_ASYNC
    EasyLink_RxPacket rxPacket = {0};
    #endif

    #ifdef RFEASYLINKRX_ASYNC
    /* Create a semaphore for Async*/
    Semaphore_Params params;
    Error_Block eb;

    /* Init params */
    Semaphore_Params_init(&params);
    Error_init(&eb);

    /* Create semaphore instance */
    rxDoneSem = Semaphore_create(0, &params, &eb);
    #endif //RFEASYLINKRX_ASYNC

    EasyLink_init(EasyLink_Phy_Custom);

    /* If you wich to use a frequency other than the default use
    * the below API
    * EasyLink_setFrequency(868000000);
    */

    #ifdef RFEASYLINKRX_ADDR_FILTER
    uint8_t addrFilter = 0xaa;
    EasyLink_enableRxAddrFilter(&addrFilter, 1, 1);
    #endif //RFEASYLINKRX_ADDR_FILTER

    while(1) {
    #ifdef RFEASYLINKRX_ASYNC
    EasyLink_RxPacket rxPacket = {{0}, 0, 0, 0, 0, {0}};
    onst char echoPrompt[] = "Hello Badra \n";

    EasyLink_receiveAsync(rxDoneCb, 0);
    //for (i = 0; i>30; i++){
    UART_write(uart, rxPacket.payload, sizeof(rxPacket.len));
    //UART_write(uart, echoPrompt, sizeof(echoPrompt));

    //}
    /* Wait 300ms for Rx */
    if(Semaphore_pend(rxDoneSem, (300000 / Clock_tickPeriod)) == FALSE)
    {
    /* RX timed out abort */
    if(EasyLink_abort() == EasyLink_Status_Success)
    {
    /* Wait for the abort */
    Semaphore_pend(rxDoneSem, BIOS_WAIT_FOREVER);
    }
    }
    #else
    rxPacket.absTime = 0;
    EasyLink_Status result = EasyLink_receive(&rxPacket);

    if (result == EasyLink_Status_Success)
    {
    /* Toggle LED2 to indicate RX */
    PIN_setOutputValue(pinHandle, Board_LED2,!PIN_getOutputValue(Board_LED2));

    }
    else
    {
    /* Toggle LED1 and LED2 to indicate error */
    PIN_setOutputValue(pinHandle, Board_LED1,!PIN_getOutputValue(Board_LED1));
    PIN_setOutputValue(pinHandle, Board_LED2,!PIN_getOutputValue(Board_LED2));
    }
    #endif //RX_ASYNC
    }
    }

    void rxTask_init(PIN_Handle ledPinHandle) {
    pinHandle = ledPinHandle;

    Task_Params_init(&rxTaskParams);
    rxTaskParams.stackSize = RFEASYLINKEX_TASK_STACK_SIZE;
    rxTaskParams.priority = RFEASYLINKEX_TASK_PRIORITY;
    rxTaskParams.stack = &rxTaskStack;
    rxTaskParams.arg0 = (UInt)1000000;

    Task_construct(&rxTask, rfEasyLinkRxFnx, &rxTaskParams, NULL);
    }

    /*
    * ======== main ========
    */
    int main(void)
    { //Task_Params uart_taskParams;
    /* Call board init functions. */
    Board_initGeneral();
    Board_initUART();

    /* Open LED pins */
    ledPinHandle = PIN_open(&ledPinState, pinTable);
    if(!ledPinHandle) {
    System_abort("Error initializing board LED pins\n");
    }


    /* Clear LED pins */
    PIN_setOutputValue(ledPinHandle, Board_LED1, 0);
    PIN_setOutputValue(ledPinHandle, Board_LED2, 0);

    rxTask_init(ledPinHandle);

    /* Start BIOS */
    BIOS_start();

    return (0);
    }

  • hello

    I'm starting with the easyLink exemple just to get familiare with TI-RTOS programming then I will switch to BLE.

    I create two Tasks one for uart driver and the other for RF driver, Here below my codes for transmitter CC2650 and Receiver CC2650.

    I tested the uart driver and it worked well. but when i try printing out the received data from the TX CC2650 i got only zeros!

    Could you please help me figure out why i didn't get the right data

    Best regards

    *********************** TX *****************************


    /*
    * ======== rfEasyLinkRx.c ========
    */
    /* XDCtools Header files */
    #include <stdlib.h>
    #include <xdc/std.h>
    #include <xdc/runtime/System.h>
    #include <xdc/runtime/Error.h>

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

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

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

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

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

    #define RFEASYLINKTX_TASK_STACK_SIZE 1024
    #define RFEASYLINKTX_TASK_PRIORITY 2

    #define RFEASYLINKTX_BURST_SIZE 10
    #define RFEASYLINKTXPAYLOAD_LENGTH 30

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

    /* 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_LED1 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MAX,
    Board_LED2 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MAX,
    PIN_TERMINATE
    };

    static uint16_t seqNumber;

    #ifdef RFEASYLINKTX_ASYNC
    static Semaphore_Handle txDoneSem;
    #endif //RFEASYLINKTX_ASYNC

    #ifdef RFEASYLINKTX_ASYNC
    void txDoneCb(EasyLink_Status status)
    {
    if (status == EasyLink_Status_Success)
    {
    /* Toggle LED1 to indicate TX */
    PIN_setOutputValue(pinHandle, Board_LED1,!PIN_getOutputValue(Board_LED1));
    }
    else if(status == EasyLink_Status_Aborted)
    {
    /* Toggle LED2 to indicate command aborted */
    PIN_setOutputValue(pinHandle, Board_LED2,!PIN_getOutputValue(Board_LED2));
    }
    else
    {
    /* Toggle LED1 and LED2 to indicate error */
    PIN_setOutputValue(pinHandle, Board_LED1,!PIN_getOutputValue(Board_LED1));
    PIN_setOutputValue(pinHandle, Board_LED2,!PIN_getOutputValue(Board_LED2));
    }

    Semaphore_post(txDoneSem);
    }
    #endif //RFEASYLINKTX_ASYNC

    static void rfEasyLinkTxFnx(UArg arg0, UArg arg1)
    {
    uint8_t txBurstSize = 0;

    #ifdef RFEASYLINKTX_ASYNC
    /* Create a semaphore for Async */
    Semaphore_Params params;
    Error_Block eb;

    /* Init params */
    Semaphore_Params_init(&params);
    Error_init(&eb);

    /* Create semaphore instance */
    txDoneSem = Semaphore_create(0, &params, &eb);
    #endif //TX_ASYNC

    EasyLink_init(EasyLink_Phy_Custom);

    /* If you wich to use a frequency other than the default use
    * the below API
    * EasyLink_setFrequency(868000000);
    */

    /* Set output power to 12dBm */
    EasyLink_setRfPwr(12);

    while(1) {
    EasyLink_TxPacket txPacket = { {0}, 0, 0, {0} };

    /* Create packet with incrementing sequence number and random payload */
    txPacket.payload[0] = (uint8_t)(seqNumber >> 8);
    txPacket.payload[1] = (uint8_t)(seqNumber++);
    uint8_t i;
    for (i = 2; i < RFEASYLINKTXPAYLOAD_LENGTH; i++)
    {
    txPacket.payload[i] = 0xFF;
    }

    txPacket.len = RFEASYLINKTXPAYLOAD_LENGTH;
    txPacket.dstAddr[0] = 0xaa;

    /* Add a Tx delay for > 500ms, so that the abort kicks in and brakes the burst */
    if(txBurstSize++ >= RFEASYLINKTX_BURST_SIZE)
    {
    /* Set Tx absolute time to current time + 1s */
    txPacket.absTime = EasyLink_getAbsTime() + EasyLink_ms_To_RadioTime(1000);
    txBurstSize = 0;
    }
    /* Else set the next packet in burst to Tx in 100ms */
    else
    {
    /* Set Tx absolute time to current time + 100ms */
    txPacket.absTime = EasyLink_getAbsTime() + EasyLink_ms_To_RadioTime(100);
    }

    #ifdef RFEASYLINKTX_ASYNC
    EasyLink_transmitAsync(&txPacket, txDoneCb);
    /* Wait 300ms for Tx to complete */
    if(Semaphore_pend(txDoneSem, (300000 / Clock_tickPeriod)) == FALSE)
    {
    /* TX timed out, abort */
    if(EasyLink_abort() == EasyLink_Status_Success)
    {
    /*
    * Abort will cause the txDoneCb to be called, and the txDoneSem ti
    * Be released. So we must consume the txDoneSem
    * */
    Semaphore_pend(txDoneSem, BIOS_WAIT_FOREVER);
    }
    }
    #else
    EasyLink_Status result = EasyLink_transmit(&txPacket);

    if (result == EasyLink_Status_Success)
    {
    /* Toggle LED1 to indicate TX */
    PIN_setOutputValue(pinHandle, Board_LED1,!PIN_getOutputValue(Board_LED1));
    }
    else
    {
    /* Toggle LED1 and LED2 to indicate error */
    PIN_setOutputValue(pinHandle, Board_LED1,!PIN_getOutputValue(Board_LED1));
    PIN_setOutputValue(pinHandle, Board_LED2,!PIN_getOutputValue(Board_LED2));
    }
    #endif //RFEASYLINKTX_ASYNC
    }
    }

    void txTask_init(PIN_Handle inPinHandle) {
    pinHandle = inPinHandle;

    Task_Params_init(&txTaskParams);
    txTaskParams.stackSize = RFEASYLINKTX_TASK_STACK_SIZE;
    txTaskParams.priority = RFEASYLINKTX_TASK_PRIORITY;
    txTaskParams.stack = &txTaskStack;
    txTaskParams.arg0 = (UInt)1000000;

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

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

    /* Open LED pins */
    pinHandle = PIN_open(&pinState, pinTable);
    if(!pinHandle) {
    System_abort("Error initializing board LED pins\n");
    }

    /* Clear LED pins */
    PIN_setOutputValue(pinHandle, Board_LED1, 0);
    PIN_setOutputValue(pinHandle, Board_LED2, 0);

    txTask_init(pinHandle);

    /* Start BIOS */
    BIOS_start();

    return (0);
    }

    ******************************** RX **************************************

    /*
    * ======== rfEasyLinkRx.c ========
    */
    /* XDCtools Header files */
    #include <xdc/std.h>
    #include <xdc/runtime/System.h>
    #include <xdc/runtime/Error.h>

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

    /* TI-RTOS Header files */
    #include <ti/drivers/PIN.h>
    #include <ti/drivers/UART.h>

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

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

    /***** Defines *****/
    #define UARTTASKSTACKSIZE 768

    /* Undefine to remove address filter and async mode */
    #define RFEASYLINKRX_ASYNC
    #define RFEASYLINKRX_ADDR_FILTER

    #define RFEASYLINKEX_TASK_STACK_SIZE 1024
    #define RFEASYLINKEX_TASK_PRIORITY 2 //it was 2 before

    /***** Variable declarations *****/
    static Task_Params rxTaskParams;
    Task_Struct rxTask; /* not static so you can see in ROV */
    static uint8_t rxTaskStack[RFEASYLINKEX_TASK_STACK_SIZE];


    Task_Struct uart_taskStruct;
    Char uart_taskStack[UARTTASKSTACKSIZE];

    /* Pin driver handle */
    static PIN_Handle ledPinHandle;
    static PIN_State ledPinState;

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

    /* The RX Output struct contains statistics about the RX operation of the radio */
    PIN_Handle pinHandle;

    #ifdef RFEASYLINKRX_ASYNC
    static Semaphore_Handle rxDoneSem;
    #endif

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


    #ifdef RFEASYLINKRX_ASYNC
    void rxDoneCb(EasyLink_RxPacket * rxPacket, EasyLink_Status status)
    {
    if (status == EasyLink_Status_Success)
    {
    /* Toggle LED2 to indicate RX */

    PIN_setOutputValue(pinHandle, Board_LED2,!PIN_getOutputValue(Board_LED2));
    }
    else if(status == EasyLink_Status_Aborted)
    {
    /* Toggle LED1 to indicate command aborted */
    PIN_setOutputValue(pinHandle, Board_LED1,!PIN_getOutputValue(Board_LED1));
    }
    else
    {
    /* Toggle LED1 and LED2 to indicate error */
    PIN_setOutputValue(pinHandle, Board_LED1,!PIN_getOutputValue(Board_LED1));
    PIN_setOutputValue(pinHandle, Board_LED2,!PIN_getOutputValue(Board_LED2));
    }

    Semaphore_post(rxDoneSem);
    }
    #endif

    static void rfEasyLinkRxFnx(UArg arg0, UArg arg1)
    {
    const char echoPrompt[] = "Hello Badra \n";
    int i;
    UART_Handle uart;
    Task_Params uart_taskParams;
    UART_Params uartParams;


    Task_Params_init(&uart_taskParams);
    uart_taskParams.stackSize = UARTTASKSTACKSIZE;
    uart_taskParams.stack = &uart_taskStack;
    uart_taskParams.priority = 1;

    /* Create a UART with data processing off. */
    UART_Params_init(&uartParams);
    uartParams.writeDataMode = UART_DATA_BINARY;
    uartParams.readDataMode = UART_DATA_BINARY;
    uartParams.readReturnMode = UART_RETURN_FULL;
    uartParams.readEcho = UART_ECHO_OFF;
    uartParams.baudRate = 1500000;
    uart = UART_open(Board_UART0, &uartParams);

    if (uart == NULL) {
    System_abort("Error opening the UART");
    }

    #ifndef RFEASYLINKRX_ASYNC
    EasyLink_RxPacket rxPacket = {0};
    #endif

    #ifdef RFEASYLINKRX_ASYNC
    /* Create a semaphore for Async*/
    Semaphore_Params params;
    Error_Block eb;

    /* Init params */
    Semaphore_Params_init(&params);
    Error_init(&eb);

    /* Create semaphore instance */
    rxDoneSem = Semaphore_create(0, &params, &eb);
    #endif //RFEASYLINKRX_ASYNC

    EasyLink_init(EasyLink_Phy_Custom);

    /* If you wich to use a frequency other than the default use
    * the below API
    * EasyLink_setFrequency(868000000);
    */

    #ifdef RFEASYLINKRX_ADDR_FILTER
    uint8_t addrFilter = 0xaa;
    EasyLink_enableRxAddrFilter(&addrFilter, 1, 1);
    #endif //RFEASYLINKRX_ADDR_FILTER

    while(1) {
    #ifdef RFEASYLINKRX_ASYNC
    EasyLink_RxPacket rxPacket = {{0}, 0, 0, 0, 0, {0}};
    onst char echoPrompt[] = "Hello Badra \n";

    EasyLink_receiveAsync(rxDoneCb, 0);
    //for (i = 0; i>30; i++){
    UART_write(uart, rxPacket.payload, sizeof(rxPacket.len));
    //UART_write(uart, echoPrompt, sizeof(echoPrompt));

    //}
    /* Wait 300ms for Rx */
    if(Semaphore_pend(rxDoneSem, (300000 / Clock_tickPeriod)) == FALSE)
    {
    /* RX timed out abort */
    if(EasyLink_abort() == EasyLink_Status_Success)
    {
    /* Wait for the abort */
    Semaphore_pend(rxDoneSem, BIOS_WAIT_FOREVER);
    }
    }
    #else
    rxPacket.absTime = 0;
    EasyLink_Status result = EasyLink_receive(&rxPacket);

    if (result == EasyLink_Status_Success)
    {
    /* Toggle LED2 to indicate RX */
    PIN_setOutputValue(pinHandle, Board_LED2,!PIN_getOutputValue(Board_LED2));

    }
    else
    {
    /* Toggle LED1 and LED2 to indicate error */
    PIN_setOutputValue(pinHandle, Board_LED1,!PIN_getOutputValue(Board_LED1));
    PIN_setOutputValue(pinHandle, Board_LED2,!PIN_getOutputValue(Board_LED2));
    }
    #endif //RX_ASYNC
    }
    }

    void rxTask_init(PIN_Handle ledPinHandle) {
    pinHandle = ledPinHandle;

    Task_Params_init(&rxTaskParams);
    rxTaskParams.stackSize = RFEASYLINKEX_TASK_STACK_SIZE;
    rxTaskParams.priority = RFEASYLINKEX_TASK_PRIORITY;
    rxTaskParams.stack = &rxTaskStack;
    rxTaskParams.arg0 = (UInt)1000000;

    Task_construct(&rxTask, rfEasyLinkRxFnx, &rxTaskParams, NULL);
    }

    /*
    * ======== main ========
    */
    int main(void)
    { //Task_Params uart_taskParams;
    /* Call board init functions. */
    Board_initGeneral();
    Board_initUART();

    /* Open LED pins */
    ledPinHandle = PIN_open(&ledPinState, pinTable);
    if(!ledPinHandle) {
    System_abort("Error initializing board LED pins\n");
    }


    /* Clear LED pins */
    PIN_setOutputValue(ledPinHandle, Board_LED1, 0);
    PIN_setOutputValue(ledPinHandle, Board_LED2, 0);

    rxTask_init(ledPinHandle);

    /* Start BIOS */
    BIOS_start();

    return (0);
    }

  • Hello,

    I started with the rfEasyLink example just to get familiar with TI-Rtos programming.

    I create two Tasks, one for uart driver and the other for RF driver. Here my codes for transmitter CC2650 and Receiver CC2650.

    I tested the uart driver and it worked well. but when I try printing out the received data from TX CC2650 I got only zeros!

    Could you please help me to figure out why I did not get the right data?

    Best regards

    **************************** TX *******************************

    /*

    *   ======== rfEasyLinkTx.c ========

    */

    /* XDCtools Header files */

    #include <stdlib.h>

    #include <xdc/std.h>

    #include <xdc/runtime/System.h>

    #include <xdc/runtime/Error.h>

     

    /* BIOS Header files */

    #include <ti/sysbios/BIOS.h>

    #include <ti/sysbios/knl/Task.h>

    #include <ti/sysbios/knl/Semaphore.h>

    #include <ti/sysbios/knl/Clock.h>

     

    /* TI-RTOS Header files */

    #include <ti/drivers/PIN.h>

     

    /* Board Header files */

    #include "Board.h"

     

    /* EasyLink API Header files */

    #include "easylink/EasyLink.h"

     

    /* Undefine to not use async mode */

    #define RFEASYLINKTX_ASYNC

     

    #define RFEASYLINKTX_TASK_STACK_SIZE   1024

    #define RFEASYLINKTX_TASK_PRIORITY     2

     

    #define RFEASYLINKTX_BURST_SIZE         10

    #define RFEASYLINKTXPAYLOAD_LENGTH     30

     

    Task_Struct txTask;   /* not static so you can see in ROV */

    static Task_Params txTaskParams;

    static uint8_t txTaskStack[RFEASYLINKTX_TASK_STACK_SIZE];

     

    /* 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_LED1 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MAX,

       Board_LED2 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MAX,

       PIN_TERMINATE

    };

     

    static uint16_t seqNumber;

     

    #ifdef RFEASYLINKTX_ASYNC

    static Semaphore_Handle txDoneSem;

    #endif //RFEASYLINKTX_ASYNC

     

    #ifdef RFEASYLINKTX_ASYNC

    void txDoneCb(EasyLink_Status status)

    {

       if (status == EasyLink_Status_Success)

       {

           /* Toggle LED1 to indicate TX */

           PIN_setOutputValue(pinHandle, Board_LED1,!PIN_getOutputValue(Board_LED1));

       }

       else if(status == EasyLink_Status_Aborted)

       {

           /* Toggle LED2 to indicate command aborted */

           PIN_setOutputValue(pinHandle, Board_LED2,!PIN_getOutputValue(Board_LED2));

       }

       else

       {

           /* Toggle LED1 and LED2 to indicate error */

           PIN_setOutputValue(pinHandle, Board_LED1,!PIN_getOutputValue(Board_LED1));

           PIN_setOutputValue(pinHandle, Board_LED2,!PIN_getOutputValue(Board_LED2));

       }

     

       Semaphore_post(txDoneSem);

    }

    #endif //RFEASYLINKTX_ASYNC

     

    static void rfEasyLinkTxFnx(UArg arg0, UArg arg1)

    {

       uint8_t txBurstSize = 0;

     

    #ifdef RFEASYLINKTX_ASYNC

       /* Create a semaphore for Async */

       Semaphore_Params params;

       Error_Block eb;

     

       /* Init params */

       Semaphore_Params_init(&params);

       Error_init(&eb);

     

       /* Create semaphore instance */

       txDoneSem = Semaphore_create(0, &params, &eb);

    #endif //TX_ASYNC

     

       EasyLink_init(EasyLink_Phy_Custom);

     

       /* If you wich to use a frequency other than the default use

         * the below API

         * EasyLink_setFrequency(868000000);

         */

     

       /* Set output power to 12dBm */

       EasyLink_setRfPwr(12);

     

       while(1) {

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

     

           /* Create packet with incrementing sequence number and random payload */

           txPacket.payload[0] = (uint8_t)(seqNumber >> 8);

           txPacket.payload[1] = (uint8_t)(seqNumber++);

           uint8_t i;

           for (i = 2; i < RFEASYLINKTXPAYLOAD_LENGTH; i++)

           {

             txPacket.payload[i] = 0xFF;

           }

     

           txPacket.len = RFEASYLINKTXPAYLOAD_LENGTH;

           txPacket.dstAddr[0] = 0xaa;

     

           /* Add a Tx delay for > 500ms, so that the abort kicks in and brakes the burst */

           if(txBurstSize++ >= RFEASYLINKTX_BURST_SIZE)

           {

             /* Set Tx absolute time to current time + 1s */

             txPacket.absTime = EasyLink_getAbsTime() + EasyLink_ms_To_RadioTime(1000);

             txBurstSize = 0;

           }

           /* Else set the next packet in burst to Tx in 100ms */

           else

           {

             /* Set Tx absolute time to current time + 100ms */

             txPacket.absTime = EasyLink_getAbsTime() + EasyLink_ms_To_RadioTime(100);

           }

     

    #ifdef RFEASYLINKTX_ASYNC

           EasyLink_transmitAsync(&txPacket, txDoneCb);

           /* Wait 300ms for Tx to complete */

           if(Semaphore_pend(txDoneSem, (300000 / Clock_tickPeriod)) == FALSE)

           {

               /* TX timed out, abort */

               if(EasyLink_abort() == EasyLink_Status_Success)

               {

                   /*

                     * Abort will cause the txDoneCb to be called, and the txDoneSem ti

                     * Be released. So we must consume the txDoneSem

                     * */

                   Semaphore_pend(txDoneSem, BIOS_WAIT_FOREVER);

               }

           }

    #else

           EasyLink_Status result = EasyLink_transmit(&txPacket);

     

           if (result == EasyLink_Status_Success)

           {

               /* Toggle LED1 to indicate TX */

               PIN_setOutputValue(pinHandle, Board_LED1,!PIN_getOutputValue(Board_LED1));

           }

           else

           {

               /* Toggle LED1 and LED2 to indicate error */

               PIN_setOutputValue(pinHandle, Board_LED1,!PIN_getOutputValue(Board_LED1));

               PIN_setOutputValue(pinHandle, Board_LED2,!PIN_getOutputValue(Board_LED2));

           }

    #endif //RFEASYLINKTX_ASYNC

       }

    }

     

    void txTask_init(PIN_Handle inPinHandle) {

       pinHandle = inPinHandle;

     

       Task_Params_init(&txTaskParams);

       txTaskParams.stackSize = RFEASYLINKTX_TASK_STACK_SIZE;

       txTaskParams.priority = RFEASYLINKTX_TASK_PRIORITY;

       txTaskParams.stack = &txTaskStack;

       txTaskParams.arg0 = (UInt)1000000;

     

       Task_construct(&txTask, rfEasyLinkTxFnx, &txTaskParams, NULL);

    }

     

    /*

    * ======== main ========

    */

    int main(void)

    {

       /* Call board init functions. */

       Board_initGeneral();

     

       /* Open LED pins */

       pinHandle = PIN_open(&pinState, pinTable);

       if(!pinHandle) {

           System_abort("Error initializing board LED pins\n");

       }

     

       /* Clear LED pins */

       PIN_setOutputValue(pinHandle, Board_LED1, 0);

       PIN_setOutputValue(pinHandle, Board_LED2, 0);

     

       txTask_init(pinHandle);

     

       /* Start BIOS */

       BIOS_start();

     

       return (0);

    }

     

    **************************** RX *******************************

    /*

    * ======== rfEasyLinkRx.c ========

    */

    /* XDCtools Header files */

    #include <xdc/std.h>

    #include <xdc/runtime/System.h>

    #include <xdc/runtime/Error.h>

     

    /* BIOS Header files */

    #include <ti/sysbios/BIOS.h>

    #include <ti/sysbios/knl/Task.h>

    #include <ti/sysbios/knl/Semaphore.h>

    #include <ti/sysbios/knl/Clock.h>

     

    /* TI-RTOS Header files */

    #include <ti/drivers/PIN.h>

    #include <ti/drivers/UART.h>

     

    /* Board Header files */

    #include "Board.h"

     

    /* EasyLink API Header files */

    #include "easylink/EasyLink.h"

     

    /***** Defines *****/

    #define UARTTASKSTACKSIZE     768

     

    /* Undefine to remove address filter and async mode */

    #define RFEASYLINKRX_ASYNC

    #define RFEASYLINKRX_ADDR_FILTER

     

    #define RFEASYLINKEX_TASK_STACK_SIZE 1024

    #define RFEASYLINKEX_TASK_PRIORITY   2 //it was 2 before

     

    /***** Variable declarations *****/

    static Task_Params rxTaskParams;

    Task_Struct rxTask;   /* not static so you can see in ROV */

    static uint8_t rxTaskStack[RFEASYLINKEX_TASK_STACK_SIZE];

     

     

    Task_Struct uart_taskStruct;

    Char uart_taskStack[UARTTASKSTACKSIZE];

     

    /* Pin driver handle */

    static PIN_Handle ledPinHandle;

    static PIN_State ledPinState;

     

    /*

    * Application LED pin configuration table:

    *   - All LEDs board LEDs are off.

    */

    PIN_Config pinTable[] = {

       Board_LED1 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MAX,

       Board_LED2 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_LOW | PIN_PUSHPULL | PIN_DRVSTR_MAX,

       PIN_TERMINATE

    };

     

    /* The RX Output struct contains statistics about the RX operation of the radio */

    PIN_Handle pinHandle;

     

    #ifdef RFEASYLINKRX_ASYNC

    static Semaphore_Handle rxDoneSem;

    #endif

     

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

     

     

    #ifdef RFEASYLINKRX_ASYNC

    void rxDoneCb(EasyLink_RxPacket * rxPacket, EasyLink_Status status)

    {

       if (status == EasyLink_Status_Success)

       {

           /* Toggle LED2 to indicate RX */

     

           PIN_setOutputValue(pinHandle, Board_LED2,!PIN_getOutputValue(Board_LED2));

       }

       else if(status == EasyLink_Status_Aborted)

       {

           /* Toggle LED1 to indicate command aborted */

           PIN_setOutputValue(pinHandle, Board_LED1,!PIN_getOutputValue(Board_LED1));

       }

       else

       {

           /* Toggle LED1 and LED2 to indicate error */

           PIN_setOutputValue(pinHandle, Board_LED1,!PIN_getOutputValue(Board_LED1));

           PIN_setOutputValue(pinHandle, Board_LED2,!PIN_getOutputValue(Board_LED2));

       }

     

       Semaphore_post(rxDoneSem);

    }

    #endif

     

    static void rfEasyLinkRxFnx(UArg arg0, UArg arg1)

    {

       const char echoPrompt[] = "Hello Badra \n";

       int i;

       UART_Handle uart;

       Task_Params uart_taskParams;

       UART_Params uartParams;

     

     

       Task_Params_init(&uart_taskParams);

       uart_taskParams.stackSize = UARTTASKSTACKSIZE;

       uart_taskParams.stack = &uart_taskStack;

       uart_taskParams.priority = 1;

     

       /* Create a UART with data processing off. */

       UART_Params_init(&uartParams);

       uartParams.writeDataMode = UART_DATA_BINARY;

       uartParams.readDataMode = UART_DATA_BINARY;

       uartParams.readReturnMode = UART_RETURN_FULL;

       uartParams.readEcho = UART_ECHO_OFF;

       uartParams.baudRate = 1500000;

       uart = UART_open(Board_UART0, &uartParams);

     

       if (uart == NULL) {

           System_abort("Error opening the UART");

       }

     

    #ifndef RFEASYLINKRX_ASYNC

       EasyLink_RxPacket rxPacket = {0};

    #endif

     

    #ifdef RFEASYLINKRX_ASYNC

       /* Create a semaphore for Async*/

       Semaphore_Params params;

       Error_Block eb;

     

       /* Init params */

       Semaphore_Params_init(&params);

       Error_init(&eb);

     

       /* Create semaphore instance */

       rxDoneSem = Semaphore_create(0, &params, &eb);

    #endif //RFEASYLINKRX_ASYNC

     

       EasyLink_init(EasyLink_Phy_Custom);

     

       /* If you wich to use a frequency other than the default use

         * the below API

         * EasyLink_setFrequency(868000000);

         */

     

    #ifdef RFEASYLINKRX_ADDR_FILTER

       uint8_t addrFilter = 0xaa;

       EasyLink_enableRxAddrFilter(&addrFilter, 1, 1);

    #endif //RFEASYLINKRX_ADDR_FILTER

     

       while(1) {

    #ifdef RFEASYLINKRX_ASYNC

           EasyLink_RxPacket rxPacket = {{0}, 0, 0, 0, 0, {0}};

           onst char echoPrompt[] = "Hello Badra \n";

          

           EasyLink_receiveAsync(rxDoneCb, 0);

           //for (i = 0; i>30; i++){

           UART_write(uart, rxPacket.payload, sizeof(rxPacket.len));

           //UART_write(uart, echoPrompt, sizeof(echoPrompt));

     

           //}

           /* Wait 300ms for Rx */

           if(Semaphore_pend(rxDoneSem, (300000 / Clock_tickPeriod)) == FALSE)

           {

               /* RX timed out abort */

               if(EasyLink_abort() == EasyLink_Status_Success)

               {

                   /* Wait for the abort */

                   Semaphore_pend(rxDoneSem, BIOS_WAIT_FOREVER);

               }

           }

    #else

           rxPacket.absTime = 0;

           EasyLink_Status result = EasyLink_receive(&rxPacket);

     

           if (result == EasyLink_Status_Success)

           {

               /* Toggle LED2 to indicate RX */

               PIN_setOutputValue(pinHandle, Board_LED2,!PIN_getOutputValue(Board_LED2));

              

           }

           else

           {

               /* Toggle LED1 and LED2 to indicate error */

               PIN_setOutputValue(pinHandle, Board_LED1,!PIN_getOutputValue(Board_LED1));

               PIN_setOutputValue(pinHandle, Board_LED2,!PIN_getOutputValue(Board_LED2));

           }

    #endif //RX_ASYNC

       }

    }

     

    void rxTask_init(PIN_Handle ledPinHandle) {

       pinHandle = ledPinHandle;

     

       Task_Params_init(&rxTaskParams);

       rxTaskParams.stackSize = RFEASYLINKEX_TASK_STACK_SIZE;

       rxTaskParams.priority = RFEASYLINKEX_TASK_PRIORITY;

       rxTaskParams.stack = &rxTaskStack;

       rxTaskParams.arg0 = (UInt)1000000;

     

       Task_construct(&rxTask, rfEasyLinkRxFnx, &rxTaskParams, NULL);

    }

     

    /*

    * ======== main ========

    */

    int main(void)

    {   //Task_Params uart_taskParams;

       /* Call board init functions. */

       Board_initGeneral();

       Board_initUART();

     

     

     

       /* Open LED pins */

       ledPinHandle = PIN_open(&ledPinState, pinTable);

       if(!ledPinHandle) {

           System_abort("Error initializing board LED pins\n");

       }

     

     

       /* Clear LED pins */

       PIN_setOutputValue(ledPinHandle, Board_LED1, 0);

       PIN_setOutputValue(ledPinHandle, Board_LED2, 0);

     

       rxTask_init(ledPinHandle);

     

       /* Start BIOS */

       BIOS_start();

     

       return (0);

    }

     

  • I don’t think it would be much helpful by studying rfEasyLink example to get familiar with TI RTOS and BLE Stack. I would suggest you to study from Simplelink Academy at