CCS/CC2650: cc2650

Hi Ahmed,
The devices uses two completely different architectures even though some of the BLE-Stack API is similar. The major different is that CC26xx uses an RTOS. The closest I've got for you is this migration guide:

dev.ti.com/.../cc254x-to-cc2640.html

Hope it helps.

what is the another solution , can i using simple - peripheral CC2650 lp

Hi Joakim ,

i am starting working in the CC2650 Launchpad with ADS1293 and  I am using simple-peripheral CC2650lp  

this is my code :

// ADS1293.c

#include <xdc/runtime/Error.h>
#include <xdc/runtime/System.h>

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

#include <ti/drivers/SPI.h>
#include <ti/drivers/spi/SPICC26XXDMA.h>
#include <ti/drivers/dma/UDMACC26XX.h>

#include "ads1293.h"
#include "board.h"

PIN_Handle spiPinHandle;
PIN_State spiPinState;
SPI_Params spiParams;
SPI_Handle spiHandle = {0};
SPI_Transaction spiTransaction = {0};
uint16_t spiTxBuf = 0x8000;
uint16_t spiRxBuf = 0xFFFF;
uint16_t spiRxReadbackCmd[10] = {0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF};
uint16_t spiRxReadbackData[10] = {0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF};

int RegInitADS1293(void);

#define SPI_BIT_BANG 1

#if !defined(SPI_BIT_BANG)
PIN_Config spiPinTable[] = {
Board_SPI_ADS1293_CSB | PIN_GPIO_OUTPUT_EN | PIN_GPIO_HIGH | PIN_PUSHPULL | PIN_DRVSTR_MAX, /* ADS1293 chip select */
PIN_TERMINATE
};

uint16_t rx = 0xAAAA;
uint16_t tx = 0x5555;
SPI_Status stat;
volatile int regNum = 0;

void ADS1293TransferCallback(SPI_Handle cbHandle,SPI_Transaction *cbTransaction) {
tx = *((uint16_t *)(cbTransaction->txBuf));
if ((tx & 0x8000) != 0) {
rx = *((uint16_t *)(cbTransaction->rxBuf));
stat = cbTransaction->status;
if (regNum < 10) {
spiRxReadbackCmd[regNum] = tx;
spiRxReadbackData[regNum] = rx;
regNum++;
}
}
}

void ADS1293_WriteReg(uint16_t cmd,uint16_t data) {
spiTransaction.count = 1;
spiTxBuf = (((cmd << 8) & 0x7F00) | (data & 0x00FF));
spiRxBuf = 0xFFFF;
spiTransaction.txBuf = &spiTxBuf;
spiTransaction.rxBuf = &spiRxBuf;
SPI_transfer(spiHandle,&spiTransaction);
}

void ADS1293_ReadReg(uint16_t cmd) {
spiTransaction.count = 1;
spiTxBuf = (0x8000 | ((cmd << 8) & 0x7F00));
spiRxBuf = 0xFFFF;
spiTransaction.txBuf = &spiTxBuf;
spiTransaction.rxBuf = &spiRxBuf;
SPI_transfer(spiHandle,&spiTransaction);
}

void ADS1293_init() {
Board_initSPI();
SPI_Params_init(&spiParams);
spiParams.transferMode = SPI_MODE_BLOCKING;
// spiParams.transferMode = SPI_MODE_CALLBACK;
// spiParams.transferCallbackFxn = ADS1293TransferCallback;
spiParams.bitRate = 1000000;
spiParams.frameFormat = SPI_POL1_PHA0;
spiParams.dataSize = 16;
spiParams.mode = SPI_MASTER;

spiHandle = SPI_open(0,&spiParams);
if (spiHandle != NULL) {
ADS1293_ReadReg(0x0000);
ADS1293_ReadReg(0x0006);
ADS1293_ReadReg(0x0017);
ADS1293_ReadReg(0x001F);
}
}

#else // Code to bit-bang SPI transactions is below
PIN_Config spiPinTable[] = {
// Board_SPI_ADS1293_DRDYB | PIN_INPUT_EN | PIN_PULLUP, /* ADS1293 data ready interrupt pin */
// Board_SPI_ADS1293_CSB | PIN_GPIO_OUTPUT_EN | PIN_GPIO_HIGH | PIN_PUSHPULL | PIN_DRVSTR_MAX, /* ADS1293 chip select */
// Board_SPI0_MOSI | PIN_GPIO_OUTPUT_EN | PIN_GPIO_HIGH | PIN_PUSHPULL | PIN_DRVSTR_MAX, /* SPI master out - slave in */
// Board_SPI0_MISO | PIN_INPUT_EN | PIN_PULLUP, /* SPI master in - slave out */
// Board_SPI0_CLK | PIN_GPIO_OUTPUT_EN | PIN_GPIO_HIGH | PIN_PUSHPULL | PIN_DRVSTR_MAX, /* SPI clock */
// Board_RST_ADS1293 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_HIGH | PIN_PUSHPULL | PIN_DRVSTR_MAX, /* ADS1293 chip reset */
Board_SPI0_MOSI | PIN_GPIO_OUTPUT_EN | PIN_GPIO_HIGH | PIN_PUSHPULL | PIN_DRVSTR_MAX, /* SPI master out - slave in */
Board_SPI0_MISO | PIN_INPUT_EN | PIN_PULLUP, /* SPI master in - slave out */
Board_SPI0_CLK | PIN_GPIO_OUTPUT_EN | PIN_GPIO_HIGH | PIN_PUSHPULL | PIN_DRVSTR_MAX, /* SPI clock */
Board_SPI_ADS1293_CSB | PIN_GPIO_OUTPUT_EN | PIN_GPIO_HIGH | PIN_PUSHPULL | PIN_DRVSTR_MAX, /* ADS1293 chip select */
Board_RST_ADS1293 | PIN_GPIO_OUTPUT_EN | PIN_GPIO_HIGH | PIN_PUSHPULL | PIN_DRVSTR_MAX, /* ADS1293 chip reset */
PIN_TERMINATE
};

PIN_Handle ADS1293IrqPinHandle;
PIN_State ADS1293IrqPinState;
PIN_Config ADS1293IrqPinTable[] = {
Board_SPI_ADS1293_DRDYB | PIN_INPUT_EN | PIN_PULLUP, /* ADS1293 data ready interrupt pin */
PIN_TERMINATE
};
volatile int irqCounter = 0;

#define CH_DATA_SIZE 9 // 9 bytes when no status is used
#define PKT_DATA_SIZE 18
#define NUM_PKTS 9 // 8 when NUM_BUF = 16, 9 when 18
#define NUM_BUF 18 // 16 data + 2 error for supporting 320samples/sec
#define PAD_SIZE 0 // use this when no status byte is read
#define BUF_SIZE ((CH_DATA_SIZE * NUM_BUF) + PAD_SIZE)

uint8_t dataBufX[BUF_SIZE];
uint8_t dataBufY[BUF_SIZE];
uint8_t *recvBuf = dataBufX;
uint8_t *sendBuf = NULL;

void ADS1293_WriteReg(uint16_t regNum,uint16_t regData);
void ADS1293_StreamRead(uint8_t *buf,int bufcnt);

void ADS1293_DRDYB_Handler(PIN_Handle pinHandle, PIN_Id pinId) {
static int rPtr = 0;
static uint8_t *tmpBuf;

++irqCounter;
tmpBuf = &recvBuf[rPtr * CH_DATA_SIZE];
ADS1293_WriteReg(0x2F,0x70);
ADS1293_StreamRead(tmpBuf,CH_DATA_SIZE);
++rPtr;
if (rPtr == NUM_BUF-2) {
rPtr = 0;
sendBuf = recvBuf;
if (recvBuf == dataBufX)
recvBuf = dataBufY;
else
recvBuf = dataBufX;
}
}

void ADS1293_Sleep(int count) {
int i, j, k;

for (i = count;i > 0;i--) {
for (j = 0;j < 2;j++) {
k = j;
}
}
}

void ADS1293_StreamRead(uint8_t *buf,int bufcnt) {
int i, j;
uint8_t dataTx8;
uint8_t dataRx8;

dataTx8 = 0xD0;
PIN_setOutputValue(spiPinHandle, Board_SPI_ADS1293_CSB, 0);
ADS1293_Sleep(2);
for (i = 0;i < 8;i++) {
if (((0x80 >> i) & dataTx8) == 0)
PIN_setOutputValue(spiPinHandle, Board_SPI0_MOSI, 0);
else
PIN_setOutputValue(spiPinHandle, Board_SPI0_MOSI, 1);
ADS1293_Sleep(1);
PIN_setOutputValue(spiPinHandle, Board_SPI0_CLK, 0);
ADS1293_Sleep(1);
PIN_setOutputValue(spiPinHandle, Board_SPI0_CLK, 1);
ADS1293_Sleep(1);
}
for (i = 0;i < bufcnt;i++) {
dataRx8 = 0;
for (j = 0;j < 8;j++) {
PIN_setOutputValue(spiPinHandle, Board_SPI0_CLK, 0);
dataRx8 <<= 1;
if (PIN_getInputValue(Board_SPI0_MISO) == 0)
dataRx8 &= 0xFE;
else
dataRx8 |= 0x01;
ADS1293_Sleep(1);
PIN_setOutputValue(spiPinHandle, Board_SPI0_CLK, 1);
ADS1293_Sleep(1);
}
buf[i] = dataRx8;
}
ADS1293_Sleep(2);
PIN_setOutputValue(spiPinHandle, Board_SPI_ADS1293_CSB, 1);
ADS1293_Sleep(500);
}

void ADS1293_WriteReg(uint16_t regNum,uint16_t regData) {
int i;

spiTxBuf = (((regNum << 8) & 0x7F00) | (regData & 0x00FF));
PIN_setOutputValue(spiPinHandle, Board_SPI_ADS1293_CSB, 0);
ADS1293_Sleep(2);
for (i = 0;i < 16;i++) {
if (((0x8000 >> i) & spiTxBuf) == 0)
PIN_setOutputValue(spiPinHandle, Board_SPI0_MOSI, 0);
else
PIN_setOutputValue(spiPinHandle, Board_SPI0_MOSI, 1);
ADS1293_Sleep(1);
PIN_setOutputValue(spiPinHandle, Board_SPI0_CLK, 0);
ADS1293_Sleep(1);
PIN_setOutputValue(spiPinHandle, Board_SPI0_CLK, 1);
ADS1293_Sleep(1);
}
ADS1293_Sleep(2);
PIN_setOutputValue(spiPinHandle, Board_SPI_ADS1293_CSB, 1);
ADS1293_Sleep(2);
}

uint16_t ADS1293_ReadReg(uint16_t regNum) {
int i;
uint16_t dataRx;

spiTxBuf = (0x8000 | ((regNum << 8) & 0x7F00));
PIN_setOutputValue(spiPinHandle, Board_SPI_ADS1293_CSB, 0);
ADS1293_Sleep(2);
for (i = 0;i < 8;i++) {
if (((0x8000 >> i) & spiTxBuf) == 0)
PIN_setOutputValue(spiPinHandle, Board_SPI0_MOSI, 0);
else
PIN_setOutputValue(spiPinHandle, Board_SPI0_MOSI, 1);
ADS1293_Sleep(1);
PIN_setOutputValue(spiPinHandle, Board_SPI0_CLK, 0);
ADS1293_Sleep(1);
PIN_setOutputValue(spiPinHandle, Board_SPI0_CLK, 1);
ADS1293_Sleep(1);
}
dataRx = 0;
for (i = 0;i < 8;i++) {
PIN_setOutputValue(spiPinHandle, Board_SPI0_CLK, 0);
dataRx <<= 1;
if (PIN_getInputValue(Board_SPI0_MISO) == 0)
dataRx &= 0xFFFE;
else
dataRx |= 0x0001;
ADS1293_Sleep(1);
PIN_setOutputValue(spiPinHandle, Board_SPI0_CLK, 1);
ADS1293_Sleep(1);
}
ADS1293_Sleep(2);
PIN_setOutputValue(spiPinHandle, Board_SPI_ADS1293_CSB, 1);
ADS1293_Sleep(500);
return dataRx;
}

void ADS1293_init(void) {
// Set up SPI and initialize the ADS1293 registers
spiPinHandle = PIN_open(&spiPinState, spiPinTable);
if(!spiPinHandle) {
System_abort("Error initializing board SPI pins\n");
}
RegInitADS1293();
spiRxBuf = ADS1293_ReadReg(TI_ADS1293_CONFIG_REG); // Should return 0x00
spiRxReadbackCmd[0] = spiTxBuf;
spiRxReadbackData[0] = spiRxBuf;
spiRxBuf = ADS1293_ReadReg(TI_ADS1293_FLEX_CH1_CN_REG); // Should return 0x11
spiRxReadbackCmd[1] = spiTxBuf;
spiRxReadbackData[1] = spiRxBuf;
spiRxBuf = ADS1293_ReadReg(TI_ADS1293_FLEX_CH2_CN_REG); // Should return 0x19
spiRxReadbackCmd[2] = spiTxBuf;
spiRxReadbackData[2] = spiRxBuf;
spiRxBuf = ADS1293_ReadReg(TI_ADS1293_FLEX_CH3_CN_REG); // Should return 0x35
spiRxReadbackCmd[3] = spiTxBuf;
spiRxReadbackData[3] = spiRxBuf;
spiRxBuf = ADS1293_ReadReg(TI_ADS1293_FLEX_PACE_CN_REG); // Should return 0x00
spiRxReadbackCmd[4] = spiTxBuf;
spiRxReadbackData[4] = spiRxBuf;
spiRxBuf = ADS1293_ReadReg(TI_ADS1293_FLEX_VBAT_CN_REG); // Should return 0x00
spiRxReadbackCmd[5] = spiTxBuf;
spiRxReadbackData[5] = spiRxBuf;
spiRxBuf = ADS1293_ReadReg(TI_ADS1293_LOD_CN_REG); // Should return 0x00
spiRxReadbackCmd[6] = spiTxBuf;
spiRxReadbackData[6] = spiRxBuf;
spiRxBuf = ADS1293_ReadReg(TI_ADS1293_LOD_EN_REG); // Should return 0x7F
spiRxReadbackCmd[7] = spiTxBuf;
spiRxReadbackData[7] = spiRxBuf;
spiRxBuf = ADS1293_ReadReg(TI_ADS1293_LOD_CURRENT_REG); // Should return 0xFF
spiRxReadbackCmd[8] = spiTxBuf;
spiRxReadbackData[8] = spiRxBuf;
// Set up the ADS1293 IRQ on DRDYB line falling edge
ADS1293IrqPinHandle = PIN_open(&ADS1293IrqPinState, ADS1293IrqPinTable);
if(!ADS1293IrqPinHandle) {
System_abort("Error initializing ADS1293 IRQ pin\n");
}
if (PIN_registerIntCb(ADS1293IrqPinHandle,ADS1293_DRDYB_Handler) != PIN_SUCCESS) {
System_abort("Error initializing ADS1293 IRQ handler\n");
}
PIN_setInterrupt(ADS1293IrqPinHandle, Board_SPI_ADS1293_DRDYB | PIN_IRQ_NEGEDGE);
ADS1293_WriteReg(TI_ADS1293_CONFIG_REG, (TI_ADS1293_CONFIG_REG_VALUE | ADS1293_START_CONV));
}
#endif // Bit-banging SPI

int RegInitADS1293(void) {
#if defined(SPI_BIT_BANG)
ADS1293_Sleep(50000);
#endif
ADS1293_WriteReg(TI_ADS1293_CONFIG_REG, TI_ADS1293_CONFIG_REG_VALUE);
ADS1293_WriteReg(TI_ADS1293_FLEX_CH1_CN_REG, TI_ADS1293_FLEX_CH1_CN_REG_VALUE);
ADS1293_WriteReg(TI_ADS1293_FLEX_CH2_CN_REG, TI_ADS1293_FLEX_CH2_CN_REG_VALUE);
ADS1293_WriteReg(TI_ADS1293_FLEX_CH3_CN_REG, TI_ADS1293_FLEX_CH3_CN_REG_VALUE);
ADS1293_WriteReg(TI_ADS1293_FLEX_PACE_CN_REG, TI_ADS1293_FLEX_PACE_CN_REG_VALUE);
ADS1293_WriteReg(TI_ADS1293_FLEX_VBAT_CN_REG, TI_ADS1293_FLEX_VBAT_CN_REG_VALUE);
ADS1293_WriteReg(TI_ADS1293_LOD_CN_REG, TI_ADS1293_LOD_CN_REG_VALUE);
ADS1293_WriteReg(TI_ADS1293_LOD_EN_REG, TI_ADS1293_LOD_EN_REG_VALUE);
ADS1293_WriteReg(TI_ADS1293_LOD_CURRENT_REG, TI_ADS1293_LOD_CURRENT_REG_VALUE);
ADS1293_WriteReg(TI_ADS1293_LOD_AC_CN_REG, TI_ADS1293_LOD_AC_CN_REG_VALUE);
ADS1293_WriteReg(TI_ADS1293_CMDET_EN_REG, TI_ADS1293_CMDET_EN_REG_VALUE);
ADS1293_WriteReg(TI_ADS1293_CMDET_CN_REG, TI_ADS1293_CMDET_CN_REG_VALUE);
ADS1293_WriteReg(TI_ADS1293_RLD_CN_REG, TI_ADS1293_RLD_CN_REG_VALUE);
ADS1293_WriteReg(TI_ADS1293_WILSON_EN1_REG, TI_ADS1293_WILSON_EN1_REG_VALUE);
ADS1293_WriteReg(TI_ADS1293_WILSON_EN2_REG, TI_ADS1293_WILSON_EN2_REG_VALUE);
ADS1293_WriteReg(TI_ADS1293_WILSON_EN3_REG, TI_ADS1293_WILSON_EN3_REG_VALUE);
ADS1293_WriteReg(TI_ADS1293_WILSON_CN_REG, TI_ADS1293_WILSON_CN_REG_VALUE);
ADS1293_WriteReg(TI_ADS1293_REF_CN_REG, TI_ADS1293_REF_CN_REG_VALUE);
ADS1293_WriteReg(TI_ADS1293_OSC_CN_REG, TI_ADS1293_OSC_CN_REG_VALUE);
ADS1293_WriteReg(TI_ADS1293_AFE_RES_REG, TI_ADS1293_AFE_RES_REG_VALUE);
ADS1293_WriteReg(TI_ADS1293_AFE_SHDN_CN_REG, TI_ADS1293_AFE_SHDN_CN_REG_VALUE);
ADS1293_WriteReg(TI_ADS1293_AFE_FAULT_CN_REG, TI_ADS1293_AFE_FAULT_CN_REG_VALUE);
ADS1293_WriteReg(TI_ADS1293_AFE_DITHER_EN_REG, TI_ADS1293_AFE_DITHER_EN_REG_VALUE);
ADS1293_WriteReg(TI_ADS1293_AFE_PACE_CN_REG, TI_ADS1293_AFE_PACE_CN_REG_VALUE);
ADS1293_WriteReg(TI_ADS1293_R2_RATE_REG, TI_ADS1293_R2_RATE_REG_VALUE);
ADS1293_WriteReg(TI_ADS1293_R3_RATE1_REG, TI_ADS1293_R3_RATE1_REG_VALUE);
ADS1293_WriteReg(TI_ADS1293_R3_RATE2_REG, TI_ADS1293_R3_RATE2_REG_VALUE);
ADS1293_WriteReg(TI_ADS1293_R3_RATE3_REG, TI_ADS1293_R3_RATE3_REG_VALUE);
ADS1293_WriteReg(TI_ADS1293_P_DRATE_REG, TI_ADS1293_P_DRATE_REG_VALUE);
ADS1293_WriteReg(TI_ADS1293_DIS_EFILTER_REG, TI_ADS1293_DIS_EFILTER_REG_VALUE);
ADS1293_WriteReg(TI_ADS1293_DRDYB_SRC_REG, TI_ADS1293_DRDYB_SRC_REG_VALUE);
ADS1293_WriteReg(TI_ADS1293_SYNCOUTB_SRC_REG, TI_ADS1293_SYNCOUTB_SRC_REG_VALUE);
ADS1293_WriteReg(TI_ADS1293_MASK_DRDYB_REG, TI_ADS1293_MASK_DRDYB_REG_VALUE);
ADS1293_WriteReg(TI_ADS1293_MASK_ERR_REG, TI_ADS1293_MASK_ERR_REG_VALUE);
ADS1293_WriteReg(TI_ADS1293_ALARM_FILTER_REG, TI_ADS1293_ALARM_FILTER_REG_VALUE);
ADS1293_WriteReg(TI_ADS1293_CH_CNFG_REG, TI_ADS1293_CH_CNFG_REG_VALUE);
#if defined(SPI_BIT_BANG)
ADS1293_Sleep(50000);
#endif
return 0;
}

#if defined(LED_BLINK)
#define TASKSTACKSIZE 256

Task_Struct task0Struct;
Char task0Stack[TASKSTACKSIZE];

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

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

/*
* ======== heartBeatFxn ========
* Toggle the Board_LED1--the red LED. The Task_sleep() period is determined by heartBeatFxn's arg0, which
* is configured for the number of system clock ticks between beats and based on BEATS_PER_MINUTE.
*/

static int ledState[5] = {0, 1, 1, 1, 1};
#define BEATS_PER_MINUTE 72
#define ONE_BPS_PERIOD ((1000000.0 / ((double)sizeof(ledState) / (double)sizeof(ledState[0])) / (double)Clock_tickPeriod))
#define PERIOD_BETWEEN_BEATS (int)((60.0/(double)BEATS_PER_MINUTE) * ONE_BPS_PERIOD)

Void heartBeatFxn(UArg arg0, UArg arg1)
{
static int i = 0;

while (1) {
Task_sleep((UInt)arg0);
PIN_setOutputValue(ledPinHandle, Board_LED1, ledState[i]);
i = ((i + 1) % 5);
}
}

void LEDBlink_init(void)
{
Task_Params taskParams;

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

PIN_setOutputValue(ledPinHandle, Board_LED0, 1);
PIN_setOutputValue(ledPinHandle, Board_LED1, 1);

/* Construct heartBeat Task thread */
Task_Params_init(&taskParams);
taskParams.arg0 = PERIOD_BETWEEN_BEATS;
taskParams.stackSize = TASKSTACKSIZE;
taskParams.stack = &task0Stack;
Task_construct(&task0Struct, (Task_FuncPtr)heartBeatFxn, &taskParams, NULL);
}
#endif // LED_BLINK

and  i have this error :

Description Resource Path Location Type
#20 identifier "Board_RST_ADS1293" is undefined ads1293.c /simple_peripheral_cc2650lp_app/Application line 106 C/C++ Problem
#20 identifier "Board_SPI_ADS1293_CSB" is undefined ads1293.c /simple_peripheral_cc2650lp_app/Application line 105 C/C++ Problem
#20 identifier "Board_SPI_ADS1293_DRDYB" is undefined ads1293.c /simple_peripheral_cc2650lp_app/Application line 113 C/C++ Problem
gmake: *** [Application/ads1293.obj] Error 1 simple_peripheral_cc2650lp_app C/C++ Problem
gmake: Target 'all' not remade because of errors. simple_peripheral_cc2650lp_app C/C++ Problem
#179-D variable "devInfo11073CertProps" was declared but never referenced devinfoservice.c /simple_peripheral_cc2650lp_app/PROFILES line 188 C/C++ Problem
#179-D variable "devInfoFirmwareRevProps" was declared but never referenced devinfoservice.c /simple_peripheral_cc2650lp_app/PROFILES line 172 C/C++ Problem
#179-D variable "devInfoHardwareRevProps" was declared but never referenced devinfoservice.c /simple_peripheral_cc2650lp_app/PROFILES line 176 C/C++ Problem
#179-D variable "devInfoMfrNameProps" was declared but never referenced devinfoservice.c /simple_peripheral_cc2650lp_app/PROFILES line 184 C/C++ Problem
#179-D variable "devInfoSerialNumberProps" was declared but never referenced devinfoservice.c /simple_peripheral_cc2650lp_app/PROFILES line 168 C/C++ Problem
#179-D variable "devInfoSoftwareRevProps" was declared but never referenced devinfoservice.c /simple_peripheral_cc2650lp_app/PROFILES line 180 C/C++ Problem
#552-D variable "k" was set but never used ads1293.c /simple_peripheral_cc2650lp_app/Application line 153 C/C++ Problem
<a href="processors.wiki.ti.com/.../225"> function "LEDBlink_init" declared implicitly main.c /simple_peripheral_cc2650lp_app/Startup line 210 C/C++ Problem

please if you can help me 

thanks