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

Badra

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

over 4 years ago

0 AdrianFer over 4 years ago

TI__Expert 3580 points

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.

0 Badra over 4 years ago in reply to AdrianFer

Intellectual 260 points

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

0 Badra over 4 years ago in reply to Badra

Intellectual 260 points

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;

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

0 Badra over 4 years ago in reply to Badra

Intellectual 260 points

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;

static uint16_t seqNumber;

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

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} };

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

void txTask_init(PIN_Handle inPinHandle) {
pinHandle = inPinHandle;

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;

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

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;

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_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);
}

0 Badra over 4 years ago in reply to AdrianFer

Intellectual 260 points

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;

static uint16_t seqNumber;

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

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} };

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

void txTask_init(PIN_Handle inPinHandle) {
pinHandle = inPinHandle;

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;

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

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;

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

void rxTask_init(PIN_Handle ledPinHandle) {
pinHandle = ledPinHandle;

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

0 Badra over 4 years ago in reply to Badra

Intellectual 260 points

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

}

0 YiKai Chen over 4 years ago

Guru 735475 points

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

Bluetooth®︎

Bluetooth forum

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