[参考译文] CC1310：配置为4Mbps 模式、执行无线传输(传输完成、生成中断)。问题：在操作一段时间后、可以接收到发送的无线消息；但是、发送器无法获取相关信息

admin

Other Parts Discussed in Thread: CC1310

请注意，本文内容源自机器翻译，可能存在语法或其它翻译错误，仅供参考。如需获取准确内容，请参阅链接中的英语原文或自行翻译。

https://e2e.ti.com/support/wireless-connectivity/sub-1-ghz-group/sub-1-ghz/f/sub-1-ghz-forum/1267995/cc1310-configured-for-4-mbps-mode-performing-a-wireless-transmission-transmission-completed-interrupt-generated-problem-after-a-certain-period-of-operation-the-wireless-message-sent-can-be-received-however-the-transmitter-can

器件型号：CC1310

团队成员

将 CC1310配置为4Mbps、写入 NO-RTOS 代码、执行以下周期性操作：
(1)睡眠500ms 后，执行无线传输状态的配置(RF_tran_init)
(2)然后读取传感器信息(16字节),执行无线传输( RF_TRANG_OP )
(3)无线电传输操作启动，计时器启动；(WAIT_WLPKK_TRAN)
(4)如果在1ms 内执行 TX_CALLBACK 中断、则继续执行以下步骤(6)；
(5)如果计时器过期超过1ms、且计时器也跳出了无线传输的等待过程、请转到下面的步骤(6)
(6)确定上述操作是否已执行5次；如果小于5次、则跳转到(2)、然后再输入(7)
(7)休眠500 ms

附件 rf_tran 4Mbps.c 包含以上特定代码;它还包含简化的 main()函数。
对于 main 函数(),也调用 rf_recv 函数(对于相应的代码,见附件 rf_recv.c )

CC1310每500ms 读取一次传感器信息、以无线方式发送一次；执行5次。
使用侦听器(配置为无线接收状态的另一个 CC1310单板)从上述五个无线数据包中获取信息、并使用计时器获取五个无线数据包之间的间隔。

当无线传输过程开始时、TX_CALLBACK 中断服务非常正常。对于5个无线数据包的4个间隔、所有4个间隔都约为2.4ms。
但是、经过一段时间工作后、发送无线数据包的间隔大约为3.1ms、即没有收到 TX_CALLBACK 中断服务。 1ms 计时器、其将代码"拉"出其持续等待 TX_CALLBACK 中断的状态。
注：侦听器在每个周期中始终完全可用于5个无线数据包。也就是说、TX_CALLBACK 中断服务或无线传输操作是否顺利完成。可以通过无线方式接收。

有时、上述3.1ms 的问题仅发生在工作超过10小时后、有时发生在半小时后。
出现上述问题后，无法自动恢复，问题将继续存在。仅对单板执行下电上电操作、以恢复正常运行。注意：上述操作(1)会在 CC1310上执行所有、配置4Mbps、以及执行无线初始化操作

上面 rf_tran 4Mbps.c 文件中将 CC1310配置为4Mbps 的代码是通过参考 TI 例程 rfPacketErrorRate (相应的"提取")获得的。
请指出是否在上述代码中错过了关键处理、然后造成了某些状态。是否触发了某个异常、因此无线数据包已成功发送、但未产生 TX_CALLBACK 中断？

rf_tran 4 Mbps.c.

#include <stdlib.h>
#include <ti/drivers/rf/RF.h>
#include <ti/drivers/PIN.h>
#include "Board.h"
#include "RFQueue.h"
#include <smartrf_settings/smartrf_settings.h>
#include <smartrf_settings/smartrf_settings_predefined.h>

/***** Defines *****/
#define NUM_DATA_ENTRIES        1
#define NUM_APPENDED_BYTES      0   // -- For the HS command (6 bytes total):  packet length (2 bytes) + Timestamp (4 bytes)
                                    // -- For other Sub-1 GHz commands (6 bytes total): packet length (1 bytes) + Timestamp (4 bytes) + status (1 byte)
                                    // -- For 200 Kbps IEEE 802.15.4g commands (5 bytes total): Timestamp (4 bytes) + status (1 byte)
                                    // -- For BLE (9 bytes total), but max payload is well under the max length supported by the sub-1 phys: Timestamp (4 bytes) + status (1 byte) + RSSI (1 byte) + CRC (3 bytes)
/***** Prototypes *****/
static void tx_callback(RF_Handle h, RF_CmdHandle ch, RF_EventMask e);

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

static volatile RF_CmdHandle cmdHandle;

static uint8_t txDataEntryBuffer[RF_QUEUE_DATA_ENTRY_BUFFER_SIZE(NUM_DATA_ENTRIES,
                                                                 MAX_LENGTH,
                                                                 NUM_APPENDED_BYTES)];

/* TX queue or RF Core to read data from */
static dataQueue_t  txDataQueue;
static rfc_dataEntryGeneral_t* tx_currentDataEntry;
static uint8_t *pPacket;

/* Runs the transmitting part of the test application and returns a result. */
void  RF_tran_init (uint16_t  freq_MHz,  uint8_t  N_dBm)
{
    RF_Params rfParams;
    RF_Params_init(&rfParams);

    if( RFQueue_defineQueue(&txDataQueue,
                            txDataEntryBuffer,
                            sizeof(txDataEntryBuffer),
                            NUM_DATA_ENTRIES,
                            MAX_LENGTH + NUM_APPENDED_BYTES)  )  {
        //while(true);  // Failed to allocate space for all data entries
    }

    RF_cmdTxHS.pQueue = &txDataQueue;
    RF_cmdTxHS.startTrigger.triggerType = TRIG_NOW; //TRIG_ABSTIME
    RF_cmdTxHS.startTrigger.pastTrig = 1;
    RF_cmdTxHS.startTime = 0;

    //---START  //copy from ZhuYanjie
//  RF_cmdTxHS.pNextOp=(rfc_radioOp_t *)&RF_cmdRxHS;
    RF_cmdTxHS.pktConf.bCheckQAtEnd=0;
    RF_cmdTxHS.pktConf.bFsOff=0;
    RF_cmdTxHS.pktConf.bUseCrc=1;
    RF_cmdTxHS.pktConf.bVarLen=1;
    RF_cmdTxHS.condition.rule=COND_STOP_ON_FALSE;
	//----END   //copy from ZhuYanjie

    //smartrf_settings_predefined.c  //-10, 0, 1, 2, 3.....11, 12, 13((12.5 dBm rounded to integer),   14('14' requires CCFG_FORCE_VDDR_HH= 1)
    RF_cmdRadioSetup_hsm.txPower = RF_TxPowerTable_findValue((RF_TxPowerTable_Entry *)RF_PROP_txPowerTable, N_dBm).rawValue;
    {
        uint8_t i = 0;
        do
        {
            if ((pOverrides_fsk[i] & 0x0000FFFF) ==  0x000088A3)
            {   //RangeExtender_Dis                       //RangeExtender_En,  868M                    //RangeExtender_En,  915M  
                pOverrides_fsk[i] = (uint32_t)0x00FB88A3; //pOverrides_fsk[i] = (uint32_t)0x000188A3;  //pOverrides_fsk[i] = (uint32_t)0x000388A3;
            }
        } while ((pOverrides_fsk[i++] != 0xFFFFFFFF));

        i = 0;
        do
        {
            if ((pOverrides_lrm[i] & 0x0000FFFF) ==  0x000088A3)
            {   //RangeExtender_Dis                       //RangeExtender_En,  868M                    //RangeExtender_En,  915M  
                pOverrides_lrm[i] = (uint32_t)0x00FB88A3; //pOverrides_lrm[i] = (uint32_t)0x000188A3;  //pOverrides_lrm[i] = (uint32_t)0x000388A3;
            }
        } while ((pOverrides_lrm[i++] != 0xFFFFFFFF));

        i = 0;
        do
        {
            if ((pOverrides_sl_lr[i] & 0x0000FFFF) ==  0x000088A3)
            {   //RangeExtender_Dis                         //RangeExtender_En,  868M                    //RangeExtender_En,  915M  
                pOverrides_sl_lr[i] = (uint32_t)0x00FB88A3; //pOverrides_sl_lr[i] = (uint32_t)0x000188A3;//pOverrides_sl_lr[i] = (uint32_t)0x000388A3;
            }
        } while ((pOverrides_sl_lr[i++] != 0xFFFFFFFF));

        i = 0;
        do
        {
            if ((pOverrides_ook[i] & 0x0000FFFF) ==  0x000088A3)
            {
                pOverrides_ook[i] = (uint32_t)0x00FB88A3;
            }
        } while ((pOverrides_ook[i++] != 0xFFFFFFFF));
    }

    //RfSetup_Hsm   //4Mbps
    rfHandle = RF_open(&rfObject, &RF_prop_hsm, (RF_RadioSetup*)&RF_cmdRadioSetup_hsm, &rfParams);
    
    // Set the frequency
    RF_cmdFs_preDef.frequency = freq_MHz;  //0x393, 915M     //0x364,  868M    //915, 903, 907, 911, 919, 923, 927
    RF_cmdFs_preDef.fractFreq = 0; //fractFreq
    RF_runCmd(rfHandle, (RF_Op*)&RF_cmdFs_preDef, RF_PriorityNormal, NULL, 0);
    
}

void  RF_tran_op (uint8_t sn8b,  uint16_t  pkg_Len,  uint8_t  *ptr)
{
    tx_currentDataEntry = (rfc_dataEntryGeneral_t*)&txDataEntryBuffer;
    pPacket = &tx_currentDataEntry->data;

    pPacket[0] = 0;
    pPacket[1] = sn8b;
    tx_currentDataEntry->length= (pkg_Len +2) ;
    memcpy( &pPacket[2],  ptr, pkg_Len );

    cmdHandle = RF_postCmd(rfHandle, (RF_Op*)&RF_cmdTxHS, RF_PriorityNormal, &tx_callback, 0);

    delta_txTrig_txOK++;
    
    if(pkg_Len< 100) wait_WLpkg_tran( 1 );
    else             wait_WLpkg_tran( 6 ); //1022-bytes, wl_pkg tran,  3.4 Mbps
}

void  RF_tran_close ()
{
    RF_close(rfHandle);
}

void tx_callback(RF_Handle h, RF_CmdHandle ch, RF_EventMask e)
{
    cur_RF_EventMask = e ;
    if(e & RF_EventLastCmdDone)
    {
        if(delta_txTrig_txOK>0)
            delta_txTrig_txOK--;
    }
}
/* HIGHSPEED RX FRAME (HSM)
 * +-------------------------------------------------------------+
 * |_LEN_|_____________PAYLOAD(sz)__________|_TIMESTAMP_|_STATUS_|
 * |     |_SERIAL_|__________DATA___________|           |        |
 * |2B   |2B      | Upto 252B               | 4B        | 1B     |
 * +-------------------------------------------------------------+
 * Note that HSM mode can transfer up to 4KB of payload but are hard-coded for a maximum of 254B in this example
#define RX_FRAME_HSM_OFFSET_LEN            0
#define RX_FRAME_HSM_OFFSET_SERIAL         2
#define RX_FRAME_HSM_OFFSET_DATA           4
#define RX_FRAME_HSM_OFFSET_TIMESTAMP(sz)  (RX_FRAME_HSM_OFFSET_SERIAL + sz)   */











void  wait_WLpkg_tran( uint8_t  N_ms )
{
    Timer_start();
            cnt_N_ms= 0;
    while( (cnt_N_ms< N_ms) && (delta_txTrig_txOK>0) ) {}
    Timer_stop();
}

void *mainThread(void *arg0)
{
    uint8_t  buf[16];
    uint8_t  curPat;

    //.............
    //other code
    //.............
    while(1) {
        usleep( GAP_500ms );
        
        //------------//------------//------------//------------//------------
        // WL_tran
        //------------//------------//------------//------------//------------
        RF_tran_init  ( curWL_freq,  curWL_dBm );
        for(curPat=0; curPat<5; curPat++) { //
            get_sensor_info ( &buf[0] ) ;
            RF_tran_op ( curPat,  16,  &buf[0] );  //2+16
        }
        RF_tran_close ( );

        //------------//------------//------------//------------//------------
        // WL_recv
        //------------//------------//------------//------------//------------
        RF_recv_init ( curWL_freq );  //1.46ms
		wait_WLpkg_recv( 5 );
		//other code
        RF_recv_close ( );
    }//---- while(1) ----//
}

rf_recv.c

#include <ti/drivers/rf/RF.h>
#include <ti/drivers/PIN.h>
#include "Board.h"
#include "RFQueue.h"
#include <smartrf_settings/smartrf_settings.h>
#include <smartrf_settings/smartrf_settings_predefined.h>

#include "cap_self.h"

/***** Defines *****/
#define NUM_DATA_ENTRIES        2   // NOTE: Only two data entries supported at the moment
#define NUM_APPENDED_BYTES      6   // -- For the HS command (6 bytes total):  packet length (2 bytes) + Timestamp (4 bytes)
                                    // -- For other Sub-1 GHz commands (6 bytes total): packet length (1 bytes) + Timestamp (4 bytes) + status (1 byte)
                                    // -- For 200 Kbps IEEE 802.15.4g commands (5 bytes total): Timestamp (4 bytes) + status (1 byte)
                                    // -- For BLE (9 bytes total), but max payload is well under the max length supported by the sub-1 phys: Timestamp (4 bytes) + status (1 byte) + RSSI (1 byte) + CRC (3 bytes)
#define ABORT_GRACEFUL          1   // Option for the RF cancel command
#define ABORT_ABRUPT            0   // Option for the RF cancel command

/***** Prototypes *****/
static void rx_callback(RF_Handle h, RF_CmdHandle ch, RF_EventMask e);

/***** Variable declarations *****/
uint16_t  payload_sz = 0;

static uint16_t* crcOk;
static int8_t* rssi;

static RF_Object rfObject;
static RF_Handle rfHandle;
static RF_CmdHandle rxCmdHndl = 0; // Handle needed to abort the RX command //rockywjj-note: must use it.
static volatile RF_RatConfigCompare ratCompareConfig;
static volatile RF_RatHandle ratHandle = RF_ALLOC_ERROR;
static volatile RF_Stat ratStatus;
static volatile uint16_t nRxPkts = 0, nMissPkts = 0, nExpPkts = 0;

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

rfc_dataEntryGeneral_t* currentDataEntry;
rfc_hsRxOutput_t rxStatistics_hs; // Output structure for CMD_HS_RX
rfc_propRxOutput_t rxStatistics_prop; // Output structure for CMD_PROP_RX

void  RF_recv_init ( uint16_t  freq_MHz )
{
    RF_Params rfParams;
    RF_Params_init(&rfParams);

    if( RFQueue_defineQueue(&rxDataQueue,
                            rxDataEntryBuffer,
                            sizeof(rxDataEntryBuffer),
                            NUM_DATA_ENTRIES,
                            MAX_LENGTH + NUM_APPENDED_BYTES))  {
        //while(true);  // Failed to allocate space for all data entries
    }

    RF_RatConfigCompare_init((RF_RatConfigCompare *)&ratCompareConfig);
    //ratCompareConfig.callback = (RF_RatCallback)&rx_timeoutCb;
    ratCompareConfig.channel  = RF_RatChannelAny;

    RF_cmdPropRx.pQueue = &rxDataQueue;
    RF_cmdPropRx.pOutput = (uint8_t*)&rxStatistics_prop;
    RF_cmdPropRx.maxPktLen = MAX_LENGTH;
    RF_cmdPropRx.pktConf.bRepeatOk = 1;
    RF_cmdPropRx.pktConf.bRepeatNok = 1;
    RF_cmdPropRx.rxConf.bAutoFlushCrcErr = 1;
    RF_cmdPropRx.rxConf.bAutoFlushIgnored = 1;
    RF_cmdPropRx.rxConf.bAppendTimestamp = 1;
    RF_cmdPropRx.rxConf.bAppendStatus = 0x1,

    RF_cmdRxHS.pOutput = &rxStatistics_hs;
    RF_cmdRxHS.pQueue = &rxDataQueue;
    RF_cmdRxHS.maxPktLen = MAX_LENGTH;
    RF_cmdRxHS.pktConf.bRepeatOk = 1;
    RF_cmdRxHS.pktConf.bRepeatNok = 1;
    RF_cmdRxHS.rxConf.bAutoFlushCrcErr = 1;
    RF_cmdRxHS.rxConf.bAppendTimestamp = 1;

    //RangeExtender_Dis                             //RangeExtender_En,  868M                          //RangeExtender_En,  915M
    RF_cmdPropRadioDivSetup_fsk.txPower   = 0xA73A; //RF_cmdPropRadioDivSetup_fsk.txPower   = 0x00C6;  //RF_cmdPropRadioDivSetup_fsk.txPower   = 0x00C9;
    RF_cmdPropRadioDivSetup_lrm.txPower   = 0xA73A; //RF_cmdPropRadioDivSetup_lrm.txPower   = 0x00C6;  //RF_cmdPropRadioDivSetup_lrm.txPower   = 0x00C9;
    RF_cmdPropRadioDivSetup_sl_lr.txPower = 0xA73A; //RF_cmdPropRadioDivSetup_sl_lr.txPower = 0x00C6;  //RF_cmdPropRadioDivSetup_sl_lr.txPower = 0x00C9;
    {
        uint8_t i = 0;
        do
        {
            if ((pOverrides_fsk[i] & 0x0000FFFF) ==  0x000088A3)
            {   //RangeExtender_Dis                       //RangeExtender_En,  868M                    //RangeExtender_En,  915M  
                pOverrides_fsk[i] = (uint32_t)0x00FB88A3; //pOverrides_fsk[i] = (uint32_t)0x000188A3;  //pOverrides_fsk[i] = (uint32_t)0x000388A3;
            }
        } while ((pOverrides_fsk[i++] != 0xFFFFFFFF));

        i = 0;
        do
        {
            if ((pOverrides_lrm[i] & 0x0000FFFF) ==  0x000088A3)
            {   //RangeExtender_Dis                       //RangeExtender_En,  868M                    //RangeExtender_En,  915M  
                pOverrides_lrm[i] = (uint32_t)0x00FB88A3; //pOverrides_lrm[i] = (uint32_t)0x000188A3;  //pOverrides_lrm[i] = (uint32_t)0x000388A3;
            }
        } while ((pOverrides_lrm[i++] != 0xFFFFFFFF));

        i = 0;
        do
        {
            if ((pOverrides_sl_lr[i] & 0x0000FFFF) ==  0x000088A3)
            {   //RangeExtender_Dis                         //RangeExtender_En,  868M                    //RangeExtender_En,  915M  
                pOverrides_sl_lr[i] = (uint32_t)0x00FB88A3; //pOverrides_sl_lr[i] = (uint32_t)0x000188A3;//pOverrides_sl_lr[i] = (uint32_t)0x000388A3;
            }
        } while ((pOverrides_sl_lr[i++] != 0xFFFFFFFF));
    }
    

    //RfSetup_Hsm   //4Mbps
    rfHandle = RF_open(&rfObject, &RF_prop_hsm, (RF_RadioSetup*)&RF_cmdRadioSetup_hsm, &rfParams);
    
    // Set the frequency
    RF_cmdFs_preDef.frequency = freq_MHz;  //0x393, 915M     //0x364,  868M    //915, 903, 907, 911, 919, 923, 927
    RF_cmdFs_preDef.fractFreq = 0; //fractFreq
    RF_runCmd(rfHandle, (RF_Op*)&RF_cmdFs_preDef, RF_PriorityNormal, NULL, 0);

    // Enter RX mode and stay forever in RX
    // RfSetup_Hsm
    rxCmdHndl = RF_postCmd(rfHandle, (RF_Op*)&RF_cmdRxHS, RF_PriorityNormal, &rx_callback, RF_EventRxEntryDone);

    crcOk = &rxStatistics_hs.nRxOk;
    rssi = &rxStatistics_hs.lastRssi;
    *crcOk = 0;
    *rssi = 0;
}

void  RF_recv_close ( )
{
	(void)RF_ratDisableChannel(rfHandle, ratHandle); // Stop the RAT Compare
	ratHandle = RF_ALLOC_ERROR;
		            
	(void)RF_cancelCmd(rfHandle, rxCmdHndl, ABORT_ABRUPT); // Force abort
	(void)RF_pendCmd(rfHandle, rxCmdHndl, 0);
    RF_close(rfHandle);
}

void rx_callback(RF_Handle h, RF_CmdHandle ch, RF_EventMask e)
{
    if (e & RF_EventRxEntryDone)
    { /* Get current unhandled data entry, point to next entry */
        currentDataEntry = RFQueue_getDataEntry();
        RFQueue_nextEntry();
        {
            payload_sz = ( ((*(uint8_t*)(&currentDataEntry->data + 1)) << 8) | (*(uint8_t*)(&currentDataEntry->data    ))); //Num of [ser2B, payload]
            pktSeqNum16b  = ( ((*(uint8_t*)(&currentDataEntry->data + 2)) << 8) | (*(uint8_t*)(&currentDataEntry->data + 3))); //val of  ser2B
            CAP_pkg_rssi   = (0xFF - *rssi);     *rssi = 0;
            pkg_crcOk  =  *crcOk;            *crcOk = 0;
            memcpy( WL_CMD_58B,  (&currentDataEntry->data+4),  (payload_sz-2) );
        }
        packetReceived = true;
    }
}
uint8_t  free_air_rssi(void)
{
    uint8_t  u_rssi;
    u_rssi = 0xFF - RF_getRssi(rfHandle); //(0xFF - *rssi);     *rssi = 0;
    return  u_rssi;
}
/* HIGHSPEED RX FRAME (HSM)
 * +-------------------------------------------------------------+
 * |_LEN_|_____________PAYLOAD(sz)__________|_TIMESTAMP_|_STATUS_|
 * |     |_SERIAL_|__________DATA___________|           |        |
 * |2B   |2B      | Upto 252B               | 4B        | 1B     |
 * +-------------------------------------------------------------+
 * Note that HSM mode can transfer up to 4KB of payload but are hard-coded for a maximum of 254B in this example
#define RX_FRAME_HSM_OFFSET_LEN            0
#define RX_FRAME_HSM_OFFSET_SERIAL         2
#define RX_FRAME_HSM_OFFSET_DATA           4
#define RX_FRAME_HSM_OFFSET_TIMESTAMP(sz)  (RX_FRAME_HSM_OFFSET_SERIAL + sz)   */

// TimeStamp-4B,  UNIT-0.25us (4M)
//
// ( 256-2) byte,  0.89ms ---> 2.3 Mbps (2.283)
// ( 512-2) byte,  1.42ms ---> 2.9 Mbps (2.903)
// (1024-2) byte,  1.42ms ---> 3.4 Mbps (3.351)

此致

亚历克斯

2 年多前