Compiler/CC2650: CC2650 can't run to main( ), when i transplant program from CC13x0 to CC2650 in the simplelink_cc13x0_sdk_2_30_00_20 SDK

Hi Siri，

Can you give me some advice about the follow code.

/***** Includes *****/
/* Standard C Libraries */
#include <stdlib.h>

/* TI Drivers */
#include <ti/drivers/rf/RF.h>
#include <ti/drivers/PIN.h>
#include <ti/drivers/pin/PINCC26XX.h>

/* Driverlib Header files */
#include DeviceFamily_constructPath(driverlib/rf_prop_mailbox.h)

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

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

/***** Defines *****/
/* Packet TX/RX Configuration */
#define PAYLOAD_LENGTH      30
/* Set packet interval to 1000ms */
#define PACKET_INTERVAL     (uint32_t)(4000000*1.0f)
/* Set Receive timeout to 500ms */
#define RX_TIMEOUT          (uint32_t)(4000000*0.5f)
/* NOTE: Only two data entries supported at the moment */
#define NUM_DATA_ENTRIES    2
/* The Data Entries data field will contain:
 * 1 Header byte (RF_cmdPropRx.rxConf.bIncludeHdr = 0x1)
 * Max 30 payload bytes
 * 1 status byte (RF_cmdPropRx.rxConf.bAppendStatus = 0x1) */
#define NUM_APPENDED_BYTES  2

/* Log radio events in the callback */
//#define LOG_RADIO_EVENTS

/***** Prototypes *****/
//static void echoCallback(RF_Handle h, RF_CmdHandle ch, RF_EventMask e);
static void txCallback(RF_Handle h, RF_CmdHandle ch, RF_EventMask e);
static void rxCallback(RF_Handle h, RF_CmdHandle ch, RF_EventMask e);
static void transmit();
static void receive();

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

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

/* Buffer which contains all Data Entries for receiving data.
 * Pragmas are needed to make sure this buffer is aligned to a 4 byte boundary
 * (requirement from the RF core)
 */
#if defined(__TI_COMPILER_VERSION__)
#pragma DATA_ALIGN(rxDataEntryBuffer, 4)
static uint8_t
rxDataEntryBuffer[RF_QUEUE_DATA_ENTRY_BUFFER_SIZE(NUM_DATA_ENTRIES,
                                                  PAYLOAD_LENGTH,
                                                  NUM_APPENDED_BYTES)];
#elif defined(__IAR_SYSTEMS_ICC__)
#pragma data_alignment = 4
static uint8_t
rxDataEntryBuffer[RF_QUEUE_DATA_ENTRY_BUFFER_SIZE(NUM_DATA_ENTRIES,
                                                  PAYLOAD_LENGTH,
                                                  NUM_APPENDED_BYTES)];
#elif defined(__GNUC__)
static uint8_t
rxDataEntryBuffer[RF_QUEUE_DATA_ENTRY_BUFFER_SIZE(NUM_DATA_ENTRIES,
                                                  PAYLOAD_LENGTH,
                                                  NUM_APPENDED_BYTES)]
                                                  __attribute__((aligned(4)));
#else
#error This compiler is not supported
#endif //defined(__TI_COMPILER_VERSION__)

/* Receive Statistics */
static rfc_propRxOutput_t rxStatistics;

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

static uint8_t txPacket[PAYLOAD_LENGTH];
static uint8_t rxPacket[PAYLOAD_LENGTH + NUM_APPENDED_BYTES - 1];
static uint16_t seqNumber;
static uint16_t snumber = 0;
int nReceived = 0;
static uint32_t curtime;

static volatile bool bRxSuccess = false;

#ifdef LOG_RADIO_EVENTS
static volatile RF_EventMask eventLog[32];
static volatile uint8_t evIndex = 0;
#endif // LOG_RADIO_EVENTS

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

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

    /* Open LED pins */
    ledPinHandle = PIN_open(&ledPinState, pinTable);
    if (ledPinHandle == NULL)
    {
        while(1);
    }

    if(RFQueue_defineQueue(&dataQueue,
                           rxDataEntryBuffer,
                           sizeof(rxDataEntryBuffer),
                           NUM_DATA_ENTRIES,
                           PAYLOAD_LENGTH + NUM_APPENDED_BYTES))
    {
        /* Failed to allocate space for all data entries */
        PIN_setOutputValue(ledPinHandle, Board_PIN_LED1, 1);
        PIN_setOutputValue(ledPinHandle, Board_PIN_LED2, 1);
        while(1);
    }
    
    /* Modify CMD_PROP_TX and CMD_PROP_RX commands for application needs */
//    RF_cmdPropTx.pktLen = PAYLOAD_LENGTH;
//    RF_cmdPropTx.pPkt = txPacket;
//    RF_cmdPropTx.startTrigger.triggerType = TRIG_ABSTIME;
//    RF_cmdPropTx.startTrigger.pastTrig = 1;
//    RF_cmdPropTx.startTime = 0;
    RF_cmdIeeeTx.payloadLen = PAYLOAD_LENGTH;
    RF_cmdIeeeTx.pPayload = txPacket;
    RF_cmdIeeeTx.startTrigger.triggerType = TRIG_ABSTIME;
    RF_cmdIeeeTx.startTrigger.pastTrig = 1;
    RF_cmdIeeeTx.startTime = 0;
    
    
    /* Set the Data Entity queue for received data */
    RF_cmdIeeeRx.pRxQ = &dataQueue;
    /* Discard ignored packets from Rx queue */
    RF_cmdIeeeRx.rxConfig.bAutoFlushIgn = 1;
    /* Discard packets with CRC error from Rx queue */
    RF_cmdIeeeRx.rxConfig.bAutoFlushCrc = 1;

    RF_cmdIeeeRx.rxConfig.bIncludePhyHdr = 1;
    RF_cmdIeeeRx.rxConfig.bIncludeCrc = 1;
    RF_cmdIeeeRx.rxConfig.bAppendRssi = 1;
    RF_cmdIeeeRx.rxConfig.bAppendCorrCrc = 1;
    RF_cmdIeeeRx.rxConfig.bAppendSrcInd = 0;
    RF_cmdIeeeRx.rxConfig.bAppendTimestamp = 1;
    RF_cmdIeeeRx.pOutput = (rfc_ieeeRxOutput_t *)&rxStatistics;
    /* Receive operation will end RX_TIMEOUT ms after command starts */
    //RF_cmdIeeeRx.endTrigger.triggerType = TRIG_REL_PREVEND;
    //RF_cmdIeeeRx.endTime = RX_TIMEOUT;

    /* Request access to the radio */
//    rfHandle = RF_open(&rfObject, &RF_prop,
//                       (RF_RadioSetup*)&RF_cmdPropRadioDivSetup, &rfParams);
    
        /* Request access to the radio */
    rfHandle = RF_open(&rfObject, &RF_ieee, (RF_RadioSetup*)&RF_cmdRadioSetup, &rfParams);

//    /* Set the frequency */
//    RF_postCmd(rfHandle, (RF_Op*)&RF_cmdFs, RF_PriorityNormal, NULL, 0);
    /* Set the frequency */
    RF_runCmd(rfHandle, (RF_Op*)&RF_cmdFs, RF_PriorityNormal, NULL, 0);
    
    /* Get current time */
    curtime = RF_getCurrentTime();
    
    while(1)
    {
        transmit();
        receive();
    }
}

static void txCallback(RF_Handle h, RF_CmdHandle ch, RF_EventMask e)
{
    if(e & RF_EventCmdDone)
    {
        /* Successful TX */
        /* Toggle LED1, clear LED2 to indicate TX */
        PIN_setOutputValue(ledPinHandle, Board_PIN_LED1,
            !PIN_getOutputValue(Board_PIN_LED1));
        PIN_setOutputValue(ledPinHandle, Board_PIN_LED2, 0);
    }
    else
    {
        /* Error Condition: set both LEDs */
        PIN_setOutputValue(ledPinHandle, Board_PIN_LED1, 1);
        PIN_setOutputValue(ledPinHandle, Board_PIN_LED2, 1);
    }
    //printf("Packet sent!\n");
}

static void rxCallback(RF_Handle h, RF_CmdHandle ch, RF_EventMask e)
{
#ifdef LOG_RADIO_EVENTS
    eventLog[evIndex++ & 0x1F] = e;
#endif// LOG_RADIO_EVENTS
    //printf("rxCallback!\n");
    if (e & RF_EventRxEntryDone)
    {
        /* Successful RX */
        bRxSuccess = true;
        //printf("packet received\n");

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

        /* Handle the packet data, located at &(currentDataEntry->data):
         * - Length is the first byte with the current configuration
         * - Data starts from the second byte
         */
        packetLength = *(uint8_t *)(&(currentDataEntry->data));
        packetDataPointer = (uint8_t *)(&(currentDataEntry->data) + 1);

        /* Copy the payload + status byte to the rxPacket variable */
        memcpy(rxPacket, packetDataPointer, (packetLength + 1));
        /* Toggle LED1, clear LED2 to indicate RX */
        PIN_setOutputValue(ledPinHandle, Board_PIN_LED1, !PIN_getOutputValue(Board_PIN_LED1));
        PIN_setOutputValue(ledPinHandle, Board_PIN_LED2, 0);
        nReceived++;
        RFQueue_nextEntry();
    }
    else if (!(e & RF_EventRxEntryDone))
    {
        if (bRxSuccess == true)
        {
            //printf("scomplete\n");
            /* Received packet successfully but RX command didn't complete at
             * the same time RX_ENTRY_DONE event was raised. Reset the flag
             */
            bRxSuccess = false;
        }
        else
        {
            /* RX timed out */
            /* Set LED2, clear LED1 to indicate TX */
            //printf("timeout!\n");
            PIN_setOutputValue(ledPinHandle, Board_PIN_LED1, 0);
            PIN_setOutputValue(ledPinHandle, Board_PIN_LED2, 1);
        }
    }
    else
    {
        //printf("error!\n");
        /* Error Condition: set both LEDs */
        PIN_setOutputValue(ledPinHandle, Board_PIN_LED1, 1);
        PIN_setOutputValue(ledPinHandle, Board_PIN_LED2, 1);
    }
}
void transmit()
{
    int n;
    for (n = 0; n < 10; n++)
    {
        /* Create packet with incrementing sequence number and random payload */
        txPacket[0] = (uint8_t)(seqNumber >> 8);
        txPacket[1] = (uint8_t)(seqNumber++);
        uint8_t i;
        for (i = 2; i < PAYLOAD_LENGTH; i++)
        {
            txPacket[i] = snumber;
            //txPacket[i] = rand();
        }
        snumber++;

        /* Set absolute TX time to utilize automatic power management */
        //curtime += PACKET_INTERVAL;
        //RF_cmdPropTx.startTime = curtime;
        //RF_EventMask terminationReason = RF_runCmd(rfHandle, (RF_Op*)&RF_cmdPropTx, RF_PriorityNormal, txCallback, RF_EventCmdDone);

        RF_ScheduleCmdParams scheduleParam;
        RF_ScheduleCmdParams_init(&scheduleParam);
        
        scheduleParam.priority = RF_PriorityNormal;
        scheduleParam.endTime = 0;

        RF_CmdHandle txCmd = RF_runScheduleCmd(rfHandle, (RF_Op*)&RF_cmdIeeeTx, &scheduleParam, txCallback, RF_EventCmdDone|RF_EventLastFGCmdDone);

    }
}

void receive()
{
    nReceived = 0;
    while (nReceived <= 10)
    {
        //printf("loop!\n");
        //RF_EventMask terminationReason = RF_runCmd(rfHandle, (RF_Op*)&RF_cmdPropRx, RF_PriorityNormal, rxCallback, RF_EventRxEntryDone);
        
        RF_ScheduleCmdParams scheduleParam;
        RF_ScheduleCmdParams_init(&scheduleParam);
        scheduleParam.priority = RF_PriorityNormal;
        scheduleParam.endTime = 0;        
        
        RF_CmdHandle rxCmd = RF_runScheduleCmd(rfHandle, (RF_Op*)&RF_cmdIeeeRx, &scheduleParam, rxCallback, RF_EventRxEntryDone);
    }
}

Is there any error in this code?

Thank you！

HI,Siri. i'm back,i'll continue to explore this application. It still has problems, I am still analyzing the problem.

I used IRA to debug CC26X0 in the past . So I spent one day familiar with the CCS Development Environment.
I want to say the new CCS V8 is batter than old Version,i used the CCS3 a few years ago .

The environment I use is:  CCS Development Environment: Code Composer Studio Version: 8.3.0.00009 

                                         SDK: simplelink_cc13x0_sdk_2_30_00_20

I use the tirtos_cc13xx_cc26xx_2_21_00_06/rfPacketTx_CC2650DK_7ID_TI test this Development Environment.
The Development Environment system works is ok.The cc2650 mcu control LED work is ok.

I strictly follow your instructions to modify the configuration and related files.
The first problem is about the third picture you provided .

Do we need repair ${COM_TI_SIMPLELINK_CC13X0_SDK_INSTALL_DIR}/kernel/tirtos/packages/ti/dpl/lib/dpl_cc13x0.aem3 to
${COM_TI_SIMPLELINK_CC13X0_SDK_INSTALL_DIR}/kernel/tirtos/packages/ti/dpl/lib/dpl_cc26x0.aem3 ?

This point i'm not sure.
I test repair it to dpl_cc26x0.aem3 ,i have'n discover any difference. So i follow your instruction keep on use dpl_cc13x0.aem3.

The new problem is When i debug ,CCS can't run to main too. It's dead again.

The code run to ti_sysbios_rom_cortexm_cc13xx_CC13xx_checkRevision__E()……Why?I can't understand.

This phenomenon is  similar to the earliest phenomena.

And i test it with two different computers ,i get the same phenomenon .

I worry about that :your simplelink_academy_cc13x0sdk_2_20_03_05  have some special setting .So you can success ,and I failed. 

I suggest you confirm on the new CCS and simplelink_cc13x0_sdk_2_30_00_20 SDK system .

Looking forward to your new instructions. Now,I'm trying to modify other parameters. 

My ultimate goal is run ieeeRx and  ieeeTx  in the CC2630(5*5),  i think there's a lot of work to do, good luck for me. 

Hi,
I've been testing it for three days.
I report the status of CC2650 7X7 using the CC13x0 SDK simplelink_cc13x0_sdk_2_30_00_20.
CCS Development Environment: Code Composer Studio Version: 8.3.0.00009
SDK: simplelink_cc13x0_sdk_2_30_00_20

In this SDK,The CCS8 Program compilation speed is faster than IAR8.3.
1. Test experiment of IO about control LED and BUTTON; test result: OK.
2. Test experiment of IEEE Radio TX data and IEEE Radio RX data in one program ; test result: OK.
(
PS:During the test Radio, it would be a failure to run Radio RX before the TX.
I haven't had enough time to find out why,i think it's my mistake about code .
Now i using IEEE Radio TX before the RX. It's OK.
)
So i'm sure this development environment can be run success in the cc2650F128(7X7).

@SIri Thank you for your technical support..

Beacuse of My ultimate goal is running CC2630(5*5) using this SDK,
SO i want to keep this thread until finished this function.
It can be used as a reference for other electronic engineers.

OK,I'm going to start the modify program from CC2650(7X7) to CC2630(5x5).
I've been successful modify program on the tirtos_cc13xx_cc26xx_2_21_01_08 before.
I worry about the heard file of simplelink_cc13x0_sdk_2_30_00_20 can't support CC2630/CC2650(5x5) harware.
Please wait for my feedback.

HI,

I agree with you. 

I have tested the cc2630(5X5) run in this SDK,It's OK.

First it need repair CC1310_LAUNCHXL.h and board.h……,then it  need repair the key of settings as described below:

@Siri Thank you again .