LAUNCHXL-CC1310: 私有射频+组网

我正在使用高速模式进行射频传输。我已经完成了高速的通信，计划要加入组网功能，即在组网下轮询高速传输数据。（以RF_PacketRX和RF_PacketTX为基础）

其过程为：1、子节点发送组网包，2、主节点接收包并保存地址.3、主节点发送轮询命令，4、子节点接受命令，对应地址的节点发送数据

但是代码写好后，调试中卡在了第2步，猜测可能是RX回调出现错误。

我会将主要代码附在下方，请帮我查看一下问题。谢谢

//TX代码
#include <xdc/std.h>
#include <stdint.h>
#include <stdlib.h>
#include <unistd.h>
#include <xdc/runtime/System.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/Event.h>
#include <ti/sysbios/knl/Clock.h>
/* TI Drivers */
#include <ti/drivers/rf/RF.h>
#include <ti/drivers/PIN.h>
#include <ti/drivers/pin/PINCC26XX.h>
#include <ti/drivers/UART.h>
/* Driverlib Header files */
#include DeviceFamily_constructPath(driverlib/rf_prop_mailbox.h)
#include DeviceFamily_constructPath(driverlib/rf_hs_mailbox.h)
/* Board Header files */
#include "Board.h"
#include "smartrf_settings/smartrf_settings.h"
#include "RFQueue.h"
#include "rfPacketTx.h"
#include "RadioProtocol.h"
#include "NodeTask.h"
/***** Defines *****/
#define RADIO_EVENT_ALL0xFFFFFFFF
#define RADIO_EVENT_SEND_ADC_DATA0x00010000//(uint32_t)(1 << 4)//
#define RADIO_EVENT_SEND_ACK0x00100000//(uint32_t)(1 << 5)
#define RADIO_EVENT_SEND_HEADER0x00000001//(uint32_t)(1 << 0)//
#define RADIO_EVENT_SEND_HEADER_MORE0x00000010//(uint32_t)(1 << 1)//
#define RADIO_EVENT_SEND_FAIL0x01000000//(uint32_t)(1 << 6)
#define RADIO_EVENT_RECEIEVE_ACK0x00000100//(uint32_t)(1 << 2)//
#define RADIO_EVENT_RECEIEVE_UART_CMD0x00001000//(uint32_t)(1 << 3)//


/* Packet TX Configuration */
#define PACKER_LEN20
#define PAYLOAD_LENGTH500
#define DATA_ENTRY_HEADER_SIZE  8// Constant header size of a Generic Data Entry
#define MAX_LENGTHPAYLOAD_LENGTH  // Set the length of the data entry
#define NUM_DATA_ENTRIES_TX1
#define NUM_DATA_ENTRIES2  /* NOTE: Only two data entries supported at the moment */
#define NUM_APPENDED_BYTES_TX  0
#define NUM_APPENDED_BYTES2  /* 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 PACKET_INTERVAL50000// Set packet interval to 50000 us or 50 ms


#define EASYLINK_RF_EVENT_MASK  ( RF_EventLastCmdDone | RF_EventCmdAborted | RF_EventCmdStopped | \RF_EventCmdCancelled | RF_EventCmdPreempted |RF_EventTxEntryDone| \RF_EventRxEntryDone)


/***** Prototypes *****/
static void rfTXTaskFunction(UArg arg0, UArg arg1);
static void sendAdcPacket(uint8_t* packet);
static void txDataCallback(RF_Handle h, RF_CmdHandle ch, RF_EventMask e);
void rxCallback(RF_Handle h, RF_CmdHandle ch, RF_EventMask e);
static void sendHeaderPacket(void);
static void sendAckPacket(void);
void sendAdcData(uint8_t* adcvaluePacket);
void sendHeader(void);
void sendAck(void);
void receiveAckPacket(void);
void setRxConfiger(void);
void setTxConfiger(void);
void sendHeaderPacketmore(void);

//static ConcentratorRadio_PacketReceivedCallback packetReceivedCallback;
/***** Variable declarations *****/
static RF_Object rfObject;
static RF_Handle rfHandle;
UART_Handle uart;
RF_Params rfParams;




uint8_t* pPacket;
uint8_t* SendAdcPacket;
uint8_t  ReceiveUartCmd;


uint32_t cmdStatus;
extern bool net_OK=false;



#pragma DATA_ALIGN (rxDataEntryBuffer, 4);
static uint8_t
rxDataEntryBuffer[RF_QUEUE_DATA_ENTRY_BUFFER_SIZE(NUM_DATA_ENTRIES,MAX_LENGTH,NUM_APPENDED_BYTES)];

#pragma DATA_ALIGN (txDataEntryBuffer, 4);
static uint8_t
txDataEntryBuffer[RF_QUEUE_DATA_ENTRY_BUFFER_SIZE(NUM_DATA_ENTRIES_TX,MAX_LENGTH,NUM_APPENDED_BYTES_TX)];


/* Receive dataQueue for RF Core to fill in data */
static dataQueue_t dataQueue;
static rfc_dataEntryGeneral_t* currentDataEntry;
///////////////////////////////////////////////RX/TX
static uint16_t packetLength;
static uint8_t* packetDataPointer;
static rfc_propRxOutput_t rxStatistics;





Semaphore_Struct radioAccessSem;  /* not static so you can see in ROV */
static Semaphore_Handle radioAccessSemHandle;
Event_Struct radioOperationEvent; /* not static so you can see in ROV */
static Task_Params rfTXRadioTaskParams;
Task_Struct rfTXRadioTask;/* not static so you can see in ROV */
static Event_Handle radioOperationEventHandle;




static uint8_t nodeRadioTaskStack[1024];
//uint8_t rfSendPacket[PACKER_LEN]={0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F,0x10};//,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,


/***** Function definitions *****/
void rfTXTask_init(void) {/* Create semaphore used for exclusive radio access */Semaphore_Params semParam;Semaphore_Params_init(&semParam);Semaphore_construct(&radioAccessSem, 1, &semParam);radioAccessSemHandle = Semaphore_handle(&radioAccessSem);/* Create event used internally for state changes */Event_Params eventParam;Event_Params_init(&eventParam);Event_construct(&radioOperationEvent, &eventParam);radioOperationEventHandle = Event_handle(&radioOperationEvent);/* Create the radio protocol task */Task_Params_init(&rfTXRadioTaskParams);rfTXRadioTaskParams.stackSize = 1024;rfTXRadioTaskParams.priority = 3;rfTXRadioTaskParams.stack = &nodeRadioTaskStack;Task_construct(&rfTXRadioTask, rfTXTaskFunction, &rfTXRadioTaskParams, NULL);
}



static void rfTXTaskFunction(UArg arg0, UArg arg1)
{
//RF_Params rfParams;RF_Params_init(&rfParams);RF_cmdTxHS.pQueue = &dataQueue;RF_cmdTxHS.startTrigger.triggerType = TRIG_NOW;/* Request access to the radio */rfHandle = RF_open(&rfObject, &RF_prop_ghs, (RF_RadioSetup*)&RF_cmdPropRadioDivSetup_ghs, &rfParams);//rfHandle = RF_open(&rfObject, &RF_prop_hsm_4mbps, (RF_RadioSetup*)&RF_cmdRadioSetup_hsm_4mbps, &rfParams);/* Set the frequency */RF_postCmd(rfHandle, (RF_Op*)&RF_cmdFs, RF_PriorityNormal, NULL, 0);if( RFQueue_defineQueue(&dataQueue,txDataEntryBuffer,sizeof(txDataEntryBuffer),NUM_DATA_ENTRIES_TX,MAX_LENGTH + NUM_APPENDED_BYTES_TX)){/* Failed to allocate space for all data entries */while(true);}if( RFQueue_defineQueue(&dataQueue,rxDataEntryBuffer,sizeof(rxDataEntryBuffer),NUM_DATA_ENTRIES, MAX_LENGTH + NUM_APPENDED_BYTES)){/* Failed to allocate space for all data entries */while(1);}while(1)//counter++ < 100{/* Wait for an event */uint32_t events = Event_pend(radioOperationEventHandle, 0, RADIO_EVENT_ALL, BIOS_WAIT_FOREVER);if (events & RADIO_EVENT_SEND_ADC_DATA)//发送数据ok{sendAdcPacket(SendAdcPacket);UART_write(uart, "数据队列", 8);//RF_yield(rfHandle);}if (events & RADIO_EVENT_SEND_ACK)//发送ACK{sendAckPacket();UART_write(uart, "ACK队列发送", 10);//RF_yield(rfHandle);}if (events & RADIO_EVENT_SEND_HEADER)//发送包头ok{sendHeaderPacket();//RF_yield(rfHandle);UART_write(uart, "包头发送", 8);Event_post(radioOperationEventHandle, RADIO_EVENT_RECEIEVE_ACK);}if (events & RADIO_EVENT_RECEIEVE_ACK)//接收ACK-ok{UART_write(uart, "dengdai", 8);receiveAckPacket();if(net_OK==true){UART_write(uart, "netok", 8);}else{Event_post(radioOperationEventHandle, RADIO_EVENT_SEND_HEADER_MORE);}}if (events & RADIO_EVENT_SEND_HEADER_MORE)//再次发送包头ok{sendHeaderPacketmore();//RF_yield(rfHandle);UART_write(uart, "包头发送", 8);Event_post(radioOperationEventHandle, RADIO_EVENT_RECEIEVE_ACK);}if (events & RADIO_EVENT_RECEIEVE_UART_CMD)//接收CMD-ok{receUartCmd(ReceiveUartCmd);// RF_yield(rfHandle);}}
}

void setRxConfiger(void){RF_close(rfHandle);RF_cmdRxHS.pQueue = &dataQueue;RF_cmdRxHS.rxConf.bAutoFlushCrcErr = 1;RF_cmdRxHS.maxPktLen = MAX_LENGTH;RF_cmdRxHS.pktConf.bRepeatOk = 1;RF_cmdRxHS.pktConf.bRepeatNok = 1;RF_cmdRxHS.pOutput = (rfc_hsRxOutput_t*)&rxStatistics;rfHandle = RF_open(&rfObject, &RF_prop_ghs, (RF_RadioSetup*)&RF_cmdPropRadioDivSetup_ghs, &rfParams);//rfHandle = RF_open(&rfObject, &RF_prop_hsm_4mbps, (RF_RadioSetup*)&RF_cmdRadioSetup_hsm_4mbps, &rfParams);/* Set the frequency */RF_postCmd(rfHandle, (RF_Op*)&RF_cmdFs, RF_PriorityNormal, NULL, 0);RF_EventMask terminationReason = RF_postCmd(rfHandle, (RF_Op*)&RF_cmdRxHS, RF_PriorityNormal, rxCallback,EASYLINK_RF_EVENT_MASK);switch(terminationReason){case RF_EventLastCmdDone:// A stand-alone radio operation command or the last radio// operation command in a chain finished.break;case RF_EventCmdCancelled:// Command cancelled before it was started; it can be caused// by RF_cancelCmd() or RF_flushCmd().break;case RF_EventCmdAborted:// Abrupt command termination caused by RF_cancelCmd() or// RF_flushCmd().break;case RF_EventCmdStopped:// Graceful command termination caused by RF_cancelCmd() or// RF_flushCmd().break;default:// Uncaught error eventbreak;}uint32_t cmdStatus = ((volatile RF_Op*)&RF_cmdTxHS)->status;switch(cmdStatus){case HS_DONE_OK:// Operation ended normallybreak;case HS_DONE_TXBUF:// Tx queue was empty at start of operationbreak;case HS_DONE_STOPPED:// Operation stopped after stop commandbreak;case HS_DONE_ABORT:// Operation aborted by abort commandbreak;default:// Uncaught error eventbreak;}
}

void setTxConfiger(void){RF_close(rfHandle);RF_cmdTxHS.pQueue = &dataQueue;RF_cmdTxHS.startTrigger.triggerType = TRIG_NOW;rfHandle = RF_open(&rfObject, &RF_prop_ghs, (RF_RadioSetup*)&RF_cmdPropRadioDivSetup_ghs, &rfParams);//rfHandle = RF_open(&rfObject, &RF_prop_hsm_4mbps, (RF_RadioSetup*)&RF_cmdRadioSetup_hsm_4mbps, &rfParams);/* Set the frequency */RF_postCmd(rfHandle, (RF_Op*)&RF_cmdFs, RF_PriorityNormal, NULL, 0);RF_EventMask terminationReason = RF_postCmd(rfHandle, (RF_Op*)&RF_cmdTxHS, RF_PriorityNormal, txDataCallback,EASYLINK_RF_EVENT_MASK);switch(terminationReason){case RF_EventLastCmdDone:// A stand-alone radio operation command or the last radio// operation command in a chain finished.break;case RF_EventCmdCancelled:// Command cancelled before it was started; it can be caused// by RF_cancelCmd() or RF_flushCmd().break;case RF_EventCmdAborted:// Abrupt command termination caused by RF_cancelCmd() or// RF_flushCmd().break;case RF_EventCmdStopped:// Graceful command termination caused by RF_cancelCmd() or// RF_flushCmd().break;default:// Uncaught error eventbreak;}uint32_t cmdStatus = ((volatile RF_Op*)&RF_cmdTxHS)->status;switch(cmdStatus){case HS_DONE_OK:// Operation ended normallybreak;case HS_DONE_TXBUF:// Tx queue was empty at start of operationbreak;case HS_DONE_STOPPED:// Operation stopped after stop commandbreak;case HS_DONE_ABORT:// Operation aborted by abort commandbreak;default:// Uncaught error eventbreak;}
}
static void sendAdcPacket(uint8_t* packet)
{currentDataEntry = (rfc_dataEntryGeneral_t*)&txDataEntryBuffer;pPacket= &currentDataEntry->data;currentDataEntry->length = PAYLOAD_LENGTH;pPacket[0]=0x01;pPacket[1]=0x01;pPacket[2]=0xFF;
//pPacket[3]=(uint8_t)(seqNumber >> 8);
//pPacket[4]=(uint8_t)(seqNumber++);uint16_t i;for (i =3 ; i < PAYLOAD_LENGTH; i++){if(i > PACKER_LEN+2){pPacket[i]= 0xCC;}else {pPacket[i]=packet[i-3];}}UART_write(uart, pPacket,PAYLOAD_LENGTH );setTxConfiger();/* Sleep for PACKET_INTERVAL us *///usleep(5000000);sleep(1);

}
static void sendHeaderPacket(void)
{currentDataEntry = (rfc_dataEntryGeneral_t*)&txDataEntryBuffer;pPacket= &currentDataEntry->data;currentDataEntry->length = 3;pPacket[0]=0x04;pPacket[1]=0x01;pPacket[2]=0xFF;RF_EventMask terminationReason = RF_postCmd(rfHandle, (RF_Op*)&RF_cmdTxHS, RF_PriorityNormal, txDataCallback,EASYLINK_RF_EVENT_MASK);//uint32_t cmdStatus = ((volatile RF_Op*)&RF_cmdTxHS)->status;/* Sleep for PACKET_INTERVAL us *///usleep(5000000);sleep(1);

}

void sendHeaderPacketmore(void){currentDataEntry = (rfc_dataEntryGeneral_t*)&txDataEntryBuffer;pPacket= &currentDataEntry->data;currentDataEntry->length = 3;pPacket[0]=0x04;pPacket[1]=0x01;pPacket[2]=0xFF;setTxConfiger();
}

static void sendAckPacket(void)
{currentDataEntry = (rfc_dataEntryGeneral_t*)&txDataEntryBuffer;pPacket= &currentDataEntry->data;currentDataEntry->length = 3;pPacket[0]=0x08;pPacket[1]=0x01;pPacket[2]=0xFF;setTxConfiger();/* Sleep for PACKET_INTERVAL us *///usleep(5000000);sleep(1);

}static void txDataCallback(RF_Handle h, RF_CmdHandle ch, RF_EventMask e)
 {if((e & RF_EventTxEntryDone)||(e & RF_EventLastCmdDone)){Semaphore_post(radioAccessSemHandle);}else{}
 }void sendAdcData(uint8_t* adcvaluePacket)
{/* Get radio access semaphore */Semaphore_pend(radioAccessSemHandle, BIOS_WAIT_FOREVER);/* Save data to send */SendAdcPacket = adcvaluePacket;/* Raise RADIO_EVENT_SEND_ADC_DATA event */Event_post(radioOperationEventHandle, RADIO_EVENT_SEND_ADC_DATA);return ;
}

void sendHeader(void)
{/* Get radio access semaphore */Semaphore_pend(radioAccessSemHandle, BIOS_WAIT_FOREVER);/* Raise RADIO_EVENT_SEND_ADC_DATA event */Event_post(radioOperationEventHandle, RADIO_EVENT_SEND_HEADER);return ;
}

void sendAck(void)
{/* Get radio access semaphore */Semaphore_pend(radioAccessSemHandle, BIOS_WAIT_FOREVER);/* Raise RADIO_EVENT_SEND_ADC_DATA event */Event_post(radioOperationEventHandle, RADIO_EVENT_SEND_ACK);return ;
}



void receiveAckPacket(void){setRxConfiger();
}

void rxCallback(RF_Handle h, RF_CmdHandle ch, RF_EventMask e)
{memset(&rxStatistics, 0, sizeof(rfc_propRxOutput_t));/* Get current unhandled data entry */currentDataEntry = RFQueue_getDataEntry();packetLength= ((*(uint8_t*)(&currentDataEntry->data + 1)) << 8) | (*(uint8_t*)(&currentDataEntry->data));//*(uint8_t*)(&currentDataEntry->data);packetDataPointer = (uint8_t*)(&currentDataEntry->data+2);uint8_t  Packet[4];if ((e & RF_EventRxEntryDone)||(e & RF_EventLastCmdDone)){/* Copy the payload to the packet variable */memcpy(Packet, packetDataPointer, (packetLength));if((Packet[0]==0x04)&&(Packet[2]==0x01)){//接收组网ACknet_OK=true;}if(Packet[0]==0x02){ReceiveUartCmd=Packet[3];Event_post(radioOperationEventHandle, RADIO_EVENT_RECEIEVE_UART_CMD);}}
//UART_write(uart, Packet, 500);RFQueue_nextEntry();}

//RX代码
/* Standard C Libraries */
#include <stdlib.h>
#include <unistd.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/Event.h>
#include <ti/sysbios/knl/Clock.h>
/* TI Drivers */
#include <ti/drivers/rf/RF.h>
#include <ti/drivers/PIN.h>
#include <ti/drivers/UART.h>
/* Driverlib Header files */
#include DeviceFamily_constructPath(driverlib/rf_prop_mailbox.h)
#include DeviceFamily_constructPath(driverlib/rf_hs_mailbox.h)
/* Board Header files */
#include "Board.h"
/* Application Header files */
#include "RFQueue.h"
#include "smartrf_settings/smartrf_settings.h"
#include "rfPacketRx.h"
#include "RadioProtocol.h"
#include "ConcentratorTask.h"
/***** Defines *****/

/* Packet RX Configuration */
#define DATA_ENTRY_HEADER_SIZE 8  /* Constant header size of a Generic Data Entry */
#define MAX_LENGTH500 /* Max length byte the radio will accept */
#define NUM_DATA_ENTRIES_TX1
#define NUM_DATA_ENTRIES2  /* NOTE: Only two data entries supported at the moment */
#define NUM_APPENDED_BYTES_TX  0
#define NUM_APPENDED_BYTES2  /* 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 EASYLINK_RF_EVENT_MASK  ( RF_EventLastCmdDone | RF_EventCmdAborted | RF_EventCmdStopped | \RF_EventCmdCancelled | RF_EventCmdPreempted |RF_EventTxEntryDone| \RF_EventRxEntryDone)

#define COLLECTOR_ADDRESS0xFF
#define DATA_HEADER0x01
#define UART_CMD_HEADER0x02
#define INTO_NET_HEADER0x04
#define ACK_HEADER0x08


#define RADIO_EVENT_ALL0xFFFFFFFF
#define RADIO_EVENT_RECEIVED_HEADER_PACKET(uint32_t)(1 << 0)
#define RADIO_EVENT_SEND_UART_CMD_PACKET(uint32_t)(1 << 1)
#define RADIO_EVENT__RECEIVED_ADC_PACKET(uint32_t)(1 << 2)
#define RADIO_EVENT_SEND_ACK_PACKET(uint32_t)(1 << 3)
#define RADIO_EVENT_INVALID_PACKET_RECEIVED(uint32_t)(1 << 4)
/***** Prototypes *****/
static void rxCallback(RF_Handle h, RF_CmdHandle ch, RF_EventMask e);
static void txCallback(RF_Handle h, RF_CmdHandle ch, RF_EventMask e);
static void rfRXTaskFunction(UArg arg0, UArg arg1);
void sendUartCmd(uint8_t* uartcmd);
void sendAck(void);
void setRxConfiger(void);
void setTxConfiger(void);



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

/* Pin driver handle */
static PIN_Handle ledPinHandle;

UART_Handle uart;
UART_Params uartParams;
RF_Params rfParams;



uint32_t cmdStatus;







#pragma DATA_ALIGN (rxDataEntryBuffer, 4);
static uint8_t
rxDataEntryBuffer[RF_QUEUE_DATA_ENTRY_BUFFER_SIZE(NUM_DATA_ENTRIES,MAX_LENGTH,NUM_APPENDED_BYTES)];

#pragma DATA_ALIGN (txDataEntryBuffer, 4);
static uint8_t
txDataEntryBuffer[RF_QUEUE_DATA_ENTRY_BUFFER_SIZE(NUM_DATA_ENTRIES_TX,MAX_LENGTH,NUM_APPENDED_BYTES_TX)];


/* Receive dataQueue for RF Core to fill in data */
static dataQueue_t dataQueue;
static rfc_dataEntryGeneral_t* currentDataEntry;
///////////////////////////////////////////////RX/TX
static uint16_t packetLength;
static uint8_t* packetDataPointer;
static rfc_propRxOutput_t rxStatistics;




uint8_t* pPacket;




static Task_Params concentratorRadioTaskParams;
Task_Struct concentratorRadioTask; /* not static so you can see in ROV */
Event_Struct radioOperationEvent;  /* not static so you can see in ROV */
static Event_Handle radioOperationEventHandle;
Semaphore_Struct radioAccessSem;  /* not static so you can see in ROV */
static Semaphore_Handle radioAccessSemHandle;

static uint8_t concentratorRadioTaskStack[1024];





uint8_t*  ReceivePacket;
uint8_tReceiveAddr;
uint8_t*  SendPacket;
uint8_t*  input_uartcmd;
//static uint8_t  Packet[MAX_LENGTH + NUM_APPENDED_BYTES - 1]; /* The length byte is stored in a separate variable */



/***** Function definitions *****/
void rfRXTask_init(void) {Semaphore_Params semParam;Semaphore_Params_init(&semParam);Semaphore_construct(&radioAccessSem, 1, &semParam);radioAccessSemHandle = Semaphore_handle(&radioAccessSem);/* Create event used internally for state changes */Event_Params eventParam;Event_Params_init(&eventParam);Event_construct(&radioOperationEvent, &eventParam);radioOperationEventHandle = Event_handle(&radioOperationEvent);/* Create the radio protocol task */Task_Params_init(&concentratorRadioTaskParams);concentratorRadioTaskParams.stackSize = 1024;concentratorRadioTaskParams.priority = 3;concentratorRadioTaskParams.stack = &concentratorRadioTaskStack;Task_construct(&concentratorRadioTask, rfRXTaskFunction, &concentratorRadioTaskParams, NULL);
}



static void rfRXTaskFunction(UArg arg0, UArg arg1)
{
//RF_Params rfParams;RF_Params_init(&rfParams);if( RFQueue_defineQueue(&dataQueue,rxDataEntryBuffer,sizeof(rxDataEntryBuffer),NUM_DATA_ENTRIES, MAX_LENGTH + NUM_APPENDED_BYTES)){/* Failed to allocate space for all data entries */while(1);}if( RFQueue_defineQueue(&dataQueue,txDataEntryBuffer,sizeof(txDataEntryBuffer),NUM_DATA_ENTRIES_TX,MAX_LENGTH + NUM_APPENDED_BYTES_TX)){/* Failed to allocate space for all data entries */while(true);}/* Set the Data Entity queue for received data */RF_cmdRxHS.pQueue = &dataQueue;RF_cmdRxHS.rxConf.bAutoFlushCrcErr = 1;RF_cmdRxHS.maxPktLen = MAX_LENGTH;RF_cmdRxHS.pktConf.bRepeatOk = 1;RF_cmdRxHS.pktConf.bRepeatNok = 1;RF_cmdRxHS.pOutput = (rfc_hsRxOutput_t*)&rxStatistics;rfHandle = RF_open(&rfObject, &RF_prop_ghs, (RF_RadioSetup*)&RF_cmdPropRadioDivSetup_ghs, &rfParams);//rfHandle = RF_open(&rfObject, &RF_prop_hsm_4mbps, (RF_RadioSetup*)&RF_cmdRadioSetup_hsm_4mbps, &rfParams);/* Set the frequency */RF_postCmd(rfHandle, (RF_Op*)&RF_cmdFs, RF_PriorityNormal, NULL, 0);RF_EventMask terminationReason = RF_postCmd(rfHandle, (RF_Op*)&RF_cmdRxHS,RF_PriorityNormal, rxCallback,EASYLINK_RF_EVENT_MASK);cmdStatus = ((volatile RF_Op*)&RF_cmdTxHS)->status;while (1) {uint32_t events = Event_pend(radioOperationEventHandle, 0, RADIO_EVENT_ALL, BIOS_WAIT_FOREVER);if(events & RADIO_EVENT_RECEIVED_HEADER_PACKET) {//接收包头组网okUART_write(uart, "组网收到",8 );copyAddr(ReceiveAddr);//保存地址UART_write(uart, "保存地址",8 );Event_post(radioOperationEventHandle, RADIO_EVENT_SEND_ACK_PACKET);}if(events & RADIO_EVENT_SEND_ACK_PACKET) {//发送ACK命令UART_write(uart, "发送ACK命令",6 );sendAck();//发送命令}if(events & RADIO_EVENT_SEND_UART_CMD_PACKET) {//发送串口命令UART_write(uart, "发送串口命令",6 );sendUartCmd(input_uartcmd);//发送命令Event_post(radioOperationEventHandle, RADIO_EVENT__RECEIVED_ADC_PACKET);}/* If valid packet received */if(events & RADIO_EVENT__RECEIVED_ADC_PACKET) {//接收ADC数据oksetRxConfiger();UART_write(uart, "接收adc数据",6 );rece_AdcData(ReceivePacket);//保存数据UART_write(uart, ReceivePacket, 500);/* Go back to RX */}/* If invalid packet received */if(events & RADIO_EVENT_INVALID_PACKET_RECEIVED) {//错误数据UART_write(uart, "错误",6 );//重发/收}}


}

void setRxConfiger(void){RF_close(rfHandle);RF_cmdRxHS.pQueue = &dataQueue;RF_cmdRxHS.rxConf.bAutoFlushCrcErr = 1;RF_cmdRxHS.maxPktLen = MAX_LENGTH;RF_cmdRxHS.pktConf.bRepeatOk = 1;RF_cmdRxHS.pktConf.bRepeatNok = 1;RF_cmdRxHS.pOutput = (rfc_hsRxOutput_t*)&rxStatistics;rfHandle = RF_open(&rfObject, &RF_prop_ghs, (RF_RadioSetup*)&RF_cmdPropRadioDivSetup_ghs, &rfParams);//rfHandle = RF_open(&rfObject, &RF_prop_hsm_4mbps, (RF_RadioSetup*)&RF_cmdRadioSetup_hsm_4mbps, &rfParams);/* Set the frequency */RF_postCmd(rfHandle, (RF_Op*)&RF_cmdFs, RF_PriorityNormal, NULL, 0);RF_EventMask terminationReason = RF_postCmd(rfHandle, (RF_Op*)&RF_cmdRxHS, RF_PriorityNormal, rxCallback,EASYLINK_RF_EVENT_MASK);switch(terminationReason){case RF_EventLastCmdDone:// A stand-alone radio operation command or the last radio// operation command in a chain finished.break;case RF_EventCmdCancelled:// Command cancelled before it was started; it can be caused// by RF_cancelCmd() or RF_flushCmd().break;case RF_EventCmdAborted:// Abrupt command termination caused by RF_cancelCmd() or// RF_flushCmd().break;case RF_EventCmdStopped:// Graceful command termination caused by RF_cancelCmd() or// RF_flushCmd().break;default:// Uncaught error eventbreak;}uint32_t cmdStatus = ((volatile RF_Op*)&RF_cmdTxHS)->status;switch(cmdStatus){case HS_DONE_OK:// Operation ended normallybreak;case HS_DONE_TXBUF:// Tx queue was empty at start of operationbreak;case HS_DONE_STOPPED:// Operation stopped after stop commandbreak;case HS_DONE_ABORT:// Operation aborted by abort commandbreak;default:// Uncaught error eventbreak;}
}

void setTxConfiger(void){RF_close(rfHandle);RF_cmdTxHS.pQueue = &dataQueue;RF_cmdTxHS.startTrigger.triggerType = TRIG_NOW;rfHandle = RF_open(&rfObject, &RF_prop_ghs, (RF_RadioSetup*)&RF_cmdPropRadioDivSetup_ghs, &rfParams);//rfHandle = RF_open(&rfObject, &RF_prop_hsm_4mbps, (RF_RadioSetup*)&RF_cmdRadioSetup_hsm_4mbps, &rfParams);/* Set the frequency */RF_postCmd(rfHandle, (RF_Op*)&RF_cmdFs, RF_PriorityNormal, NULL, 0);RF_EventMask terminationReason = RF_runCmd(rfHandle, (RF_Op*)&RF_cmdTxHS, RF_PriorityNormal, txCallback,EASYLINK_RF_EVENT_MASK);switch(terminationReason){case RF_EventLastCmdDone:// A stand-alone radio operation command or the last radio// operation command in a chain finished.break;case RF_EventCmdCancelled:// Command cancelled before it was started; it can be caused// by RF_cancelCmd() or RF_flushCmd().break;case RF_EventCmdAborted:// Abrupt command termination caused by RF_cancelCmd() or// RF_flushCmd().break;case RF_EventCmdStopped:// Graceful command termination caused by RF_cancelCmd() or// RF_flushCmd().break;default:// Uncaught error eventbreak;}uint32_t cmdStatus = ((volatile RF_Op*)&RF_cmdTxHS)->status;switch(cmdStatus){case HS_DONE_OK:// Operation ended normallybreak;case HS_DONE_TXBUF:// Tx queue was empty at start of operationbreak;case HS_DONE_STOPPED:// Operation stopped after stop commandbreak;case HS_DONE_ABORT:// Operation aborted by abort commandbreak;default:// Uncaught error eventbreak;}
}

void rxCallback(RF_Handle h, RF_CmdHandle ch, RF_EventMask e)
{PIN_setOutputValue(ledPinHandle, Board_PIN_LED2,!PIN_getOutputValue(Board_PIN_LED2));/* Get current unhandled data entry */memset(&rxStatistics, 0, sizeof(rfc_propRxOutput_t));currentDataEntry = RFQueue_getDataEntry();packetLength= ((*(uint8_t*)(&currentDataEntry->data + 1)) << 8) | (*(uint8_t*)(&currentDataEntry->data));//*(uint8_t*)(&currentDataEntry->data);packetDataPointer = (uint8_t*)(&currentDataEntry->data+2);uint8_t  Packet[MAX_LENGTH];if ((e & RF_EventRxEntryDone)||(e & RF_EventLastCmdDone))//RF_EventRxEntryDone{/* Copy the payload to the packet variable */memcpy(Packet, packetDataPointer, (packetLength));if((Packet[0]==INTO_NET_HEADER)&&(Packet[2]==COLLECTOR_ADDRESS)){//组网ReceiveAddr=Packet[1];Event_post(radioOperationEventHandle, RADIO_EVENT_RECEIVED_HEADER_PACKET);}if((Packet[0]==DATA_HEADER)&&(Packet[2]==COLLECTOR_ADDRESS)){//数据ReceivePacket=Packet;Event_post(radioOperationEventHandle, RADIO_EVENT__RECEIVED_ADC_PACKET);}} else {Event_post(radioOperationEventHandle, RADIO_EVENT_INVALID_PACKET_RECEIVED);}
//UART_write(uart, Packet, 500);RFQueue_nextEntry();}
void sendUartCmd(uint8_t* uartcmd)
{Semaphore_pend(radioAccessSemHandle, BIOS_WAIT_FOREVER);currentDataEntry = (rfc_dataEntryGeneral_t*)&txDataEntryBuffer;uartcmd= &currentDataEntry->data;currentDataEntry->length = 4;uartcmd[0]=0x02;uartcmd[1]=0x01;uartcmd[2]=0xFF;uartcmd[3]=0x01;setTxConfiger();
}
void sendAck(void)
{Semaphore_pend(radioAccessSemHandle, BIOS_WAIT_FOREVER);uint8_t* uartcmd;currentDataEntry = (rfc_dataEntryGeneral_t*)&txDataEntryBuffer;uartcmd= &currentDataEntry->data;currentDataEntry->length = 4;uartcmd[0]=0x04;uartcmd[1]=0x01;uartcmd[2]=0xFF;setTxConfiger();
}
static void txCallback(RF_Handle h, RF_CmdHandle ch, RF_EventMask e)
{if((e & RF_EventTxEntryDone)||(e & RF_EventLastCmdDone)){/* Successful TX */Semaphore_post(radioAccessSemHandle);}else{UART_write(uart, "0xFFFF",6 );}
}

jinfang li：

第1步中TX事件释放使用一个布尔量检测是否组网，如果为false，则会不断发送组网包

,

Shuyang Zhong：

Hi Jinfang,

有试过在RX callback里面加断点调试吗？有什么发现没有？

另外UART_write最好不要放到callback函数里面，可以注释掉UART_write试一下。

Best regards,

Shuyang

,

jinfang li：

进不去RX回调那里，UART_write注释之后也是这样情况。无论是RF_runCmd()还是RF_postCmd()都一样，RF_cmdRxHS的status是2