This thread has been locked.

If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.

[参考译文] LAUNCHXL-CC1310:TMS320F28379D 跟进

Guru**** 2612995 points
Other Parts Discussed in Thread: TMS320F28379D

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

https://e2e.ti.com/support/wireless-connectivity/sub-1-ghz-group/sub-1-ghz/f/sub-1-ghz-forum/988458/launchxl-cc1310-tms320f28379d-follow-up

器件型号:LAUNCHXL-CC1310
Thread 中讨论的其他器件:SYSBIOSTMS320F28379D

你(们)好  

你好。

我的客户跟进上一个帖子

https://e2e.ti.com/support/wireless-connectivity/sub-1-ghz/f/sub-1-ghz-forum/976410/launchxl-cc1310-tms320f28379d-problem

信息:


因此、在过去的2周内、我尝试使用 rfPacketRx 示例、并建议您替换发布和打开 rfHandle 的位置。
我还尝试了对信标函数的集成、但是、我发现我的程序仍然在停止、并且在首次加载数据后没有接收到任何内容。
当我查看它的停止位置时、它位于276行(请参阅随附的代码)、程序进入未捕获的错误事件状态、如 rf_mailbox.h 中所述

您知道我可以通过什么方法解决这个问题吗?


/*
*版权所有(c) 2019、德州仪器(TI)公司
*保留所有权利。
*
*以源代码和二进制形式重新分发和使用、有无
*如果满足以下条件、则允许进行修改
符合*:
*
**源代码的重新分发必须保留上述版权
*注意、此条件列表和以下免责声明。
*
**二进制形式的再发行必须复制上述版权
*请注意、中的此条件列表和以下免责声明
*随分发提供的文档和/或其他材料。
*
**德州仪器公司的名称和名称均不相同
*其贡献者可用于认可或推广衍生产品
*未经特定的事先书面许可。
*
*本软件由版权所有者和贡献者"按原样"提供
*以及任何明示或暗示的保证、包括但不限于:
*特定适销性和适用性的隐含保证
*不承认目的。 在任何情况下、版权所有者不得或
*派遣国应对任何直接、间接、偶然、特殊、
*典型或必然的损害(包括但不限于
*采购替代货物或服务;丧失使用、数据或利润;
*或业务中断)、无论原因是什么以及任何责任理论、
*无论是合同、严格责任还是侵权行为(包括疏忽或)
*否则)因使用本软件而以任何方式产生、
*即使被告知可能会发生此类损坏。
*

/***** 包括***** /
/*标准 C 库*/
#include

/* TI 驱动程序*/
#include
#include
//#include
#include
#include

/* Driverlib 头文件*/
#include DeviceFamily_constructPath (driverlib/rf_prop_mailbox.h)

/*板头文件*/
#include "Board.h"

/*应用程序头文件*/
#include "RFQueue.h"
#include "smartrf_settings/smartrf_settings.h"

/***** 定义了***** /

/*数据包 RX 配置*/
#define DATA_Entry_header_size 8 //通用数据条目的恒定标头大小*/
#define MAX_LENGTH 30 //对讲机将接受的最大长度字节*/
#define NUM_DATA_ENTRIES 2 //注意:目前仅支持两个数据条目*/
#define NUM_SUBSTED_Bytes 2 //数据条目数据字段将包含:
* 1标头字节(RF_cmdPropRx.rxConf.bIncludeHdr = 0x1)
*最多30个有效载荷字节
* 1个状态字节(RF_cmdPropRx.rxConf.bAppendStatus = 0x1)*

//静态信标_Structt 信标;
静态 Semaphore_handle semHandle;

//sem_t semHandle;
uint32_t cmdStatus;
/***** 原型***** /
静态空回调(rf_handle h、rf_CmdHandle ch、rf_EventMask e);

/***** 变量声明***** /
静态 RF_Object rfObject;
静态 RF_Handle rfHandle;

/*引脚驱动器手柄*/
静态 PIN_Handle ledPinHandle;
静态 PIN_STATE ledPinState;

int potatotrack = 0;
/*缓冲区,包含用于接收数据的所有数据条目。
需要* pragma 以确保此缓冲区是4字节对齐的(RF 内核的要求)*/
#if defined (__TI_Compiler_version__)
#pragma DATA_ALIGN (rxDataEntryBuffer、4);
静态 uint8_t rxDataEntryBuffer[rf_queue_data_entry_buffer_size (
num_data_entries、max_length、NUM_apped_Bytes)];
#Elif defined (_IAR_systems_icc_)
#pragma DATA_alignment= 4.
静态 uint8_t
rxDataEntryBuffer[RF_queue_data_entry_buffer_size (NUM_DATA_entries、
MAX_LENGTH、
num_apped_Bytes)];
#Elif defined (_GNU_)
静态 uint8_t
rxDataEntryBuffer[RF_queue_data_entry_buffer_size (NUM_DATA_entries、
MAX_LENGTH、
num_apped_bytes)]
__attribute__((aligned(4)));
其他
错误不支持此编译器。
#endif

/*接收用于射频内核的数据队列以填充数据*/
静态 dataQueue_t dataQueue;
静态 RFC_dataEntryGeneral_t* currentDataEntry;
静态 uint8_t packetLength;
静态 uint8_t* packetDataPointer;

静态 uint8_t packet[MAX_LENGTH + NUM_SUBSTED_BYTES - 1];//长度字节存储在单独的变量中*/

/*
*应用 LED 引脚配置表:
*-所有 LED 板 LED 均熄灭。
*
PIN_Config pinTable[]={
Board_PIN_LED2 | PIN_GPIO_OUTP_EN | PIN_GPIO_LOW | PIN_PushPull
| PIN_DRVSTR_MAX、
PIN_TERMINATE };

/***** 函数定义***** /

void * mainThread (void * arg0)

// SEM_INIT (semHandle、0、0);
Potatotrack = 1;
rf_params rfParams;
rf_params_init (&rfParams);

Potatotrack = 2;
/*打开 LED 引脚*/
ledPinHandle = PIN_OPEN (&ledPinState、pinTable);
if (ledPinHandle ==空)

while (1)

Potatotrack = 3;

if (RFQueue_defineQueue (&dataQueue、rxDataEntryBuffer、
sizeof (rxDataEntryBuffer)、
num_data_entries、
max_length + NUM_apped_bytes))

/*未能为所有数据条目分配空间*/
while (1)

Potatotrack = 4;
/*根据应用需求修改 CMD_PROP_RX 命令*/
/*为接收的数据设置数据实体队列*/
RF_cmdPropRx.pQueue =&dataQueue;
/*丢弃来自 Rx 队列的已忽略的数据包*/
rf_cmdProprx.rxConf.bAutoFlushIgnored = 1;
/*丢弃来自 Rx 队列的 CRC 错误数据包*/
rf_cmdPropRx.rxConf.bAutoFlushCrcErr = 1;
/*实施数据包长度过滤以避免 PROP_ERROR_RXBUF */
RF_cmdPropRx.maxPktLen = MAX_LENGTH;
rf_cmdPropRx.pktConf.bRepeatOk = 1;
rf_cmdPropRx.pktConf.bRepeatNok = 1;

Potatotrack = 5;
/*请求对讲机的访问*/
#IF 已定义(DeviceFamily_CC26X0R2)
rfHandle = RF_OPEN (&rfObject、&RF_prop、(RF_RadioSetup*)&RF_cmdPropRadioSetup、&rfParams);
其他
rfHandle = rf_open (&rfObject、&rf_prop、
(RF_RadioSetup*)&RF_cmdPropRadioDivSetup、&rfParams);
#endif// DeviceFamily_CC26X0R2

Potatotrack = 6;
/*设置频率*/
rf_postCmd (rfHandle、(rf_Op*)&rf_cmdf、rf_PriorityNormal、NULL、0);

Potatotrack = 61;
/*进入 RX 模式并一直保持在 RX 中*/
RF_EventMask terminationReason = RF_postCmd (rfHandle、
(RF_OP*)&RF_cmdPropRx、
RF_PriorityNormal、回调(&R)、
RF_EventRxEntryDone);
Potatotrack = 7;

交换机(终端重新接通)

案例 RF_EventLastCmdDone:
//独立无线电操作命令或最后一个无线电
//链中的操作命令已完成。
中断;
案例 RF_EventCmd 取消:
//命令在启动前被取消;这可能是导致的
//按 RF_cancelCmd ()或 RF_flushCmd ()。
中断;
案例 RF_EventCmdAborted:
//由 RF_cancelCmd ()或导致命令终止突然
// rf_flushCmd ()。
中断;
案例 RF_EventCmdStopped:
// RF_cancelCmd ()或导致正常命令终止
// rf_flushCmd ()。
中断;
默认值:
//未捕捉错误事件
while (1)

Potatotrack = 8;

cmdStatus =((volatile RF_OP*)&RF_cmdPropRx)->status;
交换机(cmdStatus)

案例 PROP_DONE_OK:
//接收到的数据包,CRC 正常
Potatotrack = 81;
中断;
PROP_DONE_RXERR 案例:
//接收到的数据包带有 CRC 错误
Potatotrack = 82;
中断;
案例 PROP_DONE_RXTIMEOUT:
//同步搜索时观察到的结束触发
Potatotrack = 83;
中断;
案例 PROP_DONE_break:
//在命令为时接收数据包时观察到结束触发
//配置的 endType 设置为1
Potatotrack = 84;
中断;
案例 PROP_DONE_ENDended:
//观察完结束触发后收到的数据包;如果
//命令配置为 endType 设置为0,即结束触发器
//不会终止正在进行的接收
Potatotrack = 85;
中断;
案例 PROP_DONE_STOPPED:
//命令启动后接收到 CMD_STOP,如果发现 SYNC,
//数据包被接收
Potatotrack = 86;
中断;
案例 PROP_DONE_ABORT:
//命令启动后收到 CMD_ABORT
Potattrack = 87;
中断;
PROP_ERROR_RXBUF 案例:
//没有足够大的 RX 缓冲区来存放处可用的接收数据
//数据包开始
Potatotrack = 88;
中断;
PROP_ERROR_RXFULL 案例:
//在接收部分读取期间超出 RX 缓冲区空间
Potattrack = 89;
中断;
案例 PROP_ERROR_PAR:
//观察到非法参数
Potatotrack = 810;
中断;
PROP_ERROR_NO_SETUP 案例:
//在受支持的中未设置无线电的情况下发送命令
//模式使用 CMD_PROP_RADIO_SETUP 或 CMD_RADIO_SETUP
Potatotrack = 811;
中断;
案例 PROP_ERROR_NO_FS:
//发送命令而不对合成器进行编程
Potatotrack = 812;
中断;
案例 PROP_ERROR_RXOVF:
操作期间观察到// RX 溢出
Potatotrack = 813;
中断;
默认值:
//未捕获的错误事件-这些可能来自
// rf_mailbox.h 中定义的状态池
Potattrack = 814;
while (1)

Potatotrack = 9;

while (1)

Semaphore_pend (semHandle、BIOS_wait_forever);


空回调(rf_handle h、rf_CmdHandle ch、rf_EventMask e)

Potattrack = 91;
IF (e 和 RF_EventRxEntryDone)

Potatotrack = 10;
/*切换引脚以指示 RX */
PIN_setOutputValue (ledPinHandle、Board_PIN_LED2、
!PIN_getOutputValue (Board_PIN_LED2);
Potatotrack = 11;
/*获取当前未处理的数据输入*/
currentDataEntry = RFQueue_getDataEntry();
Potatotrack = 12;
/*处理位于&currentDataEntry->data 的数据包数据:
*-长度是当前配置的第一个字节
*-数据从第二个字节开始*/
packetLength =*(uint8_t*)(&currentDataEntry ->数据);
packetDataPointer =(uint8_t*)(&currentDataEntry->data+1);

Potatotrack = 13;
/*将有效载荷+状态字节复制到数据包变量*/
memcpy (packet、packetDataPointer、(packetLength + 1));
Potatotrack = 14;
RFQueue_nextEntry();
Potatotrack = 15;
Semaphore_post (semHandle);

此致

Aosker

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

    我采用了 rfPacketRX、并使用默认的50kbps 设置测试了类似的器件。

    每次接收到一个数据包时、LED 都会切换、直到它在信标上返回到挂起状态。

    代码如下所示:

    /***** Includes *****/
    /* Standard C Libraries */
    #include <stdlib.h>
    
    /* TI Drivers */
    #include <ti/drivers/rf/RF.h>
    #include <ti/drivers/PIN.h>
    
    #include <ti/sysbios/BIOS.h>
    #include <ti/sysbios/knl/Semaphore.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 RX Configuration */
    #define DATA_ENTRY_HEADER_SIZE 8  /* Constant header size of a Generic Data Entry */
    #define MAX_LENGTH             30 /* Max length byte the radio will accept */
    #define NUM_DATA_ENTRIES       2  /* NOTE: Only two data entries supported at the moment */
    #define NUM_APPENDED_BYTES     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) */
    
    static Semaphore_Struct rxSemaphore;
    static Semaphore_Handle rxSemaphoreHandle;
    
    /***** Prototypes *****/
    static void callback(RF_Handle h, RF_CmdHandle ch, RF_EventMask e);
    
    /***** 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 4 byte aligned (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,
                                                      MAX_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,
                                                      MAX_LENGTH,
                                                      NUM_APPENDED_BYTES)];
    #elif defined(__GNUC__)
    static uint8_t
    rxDataEntryBuffer[RF_QUEUE_DATA_ENTRY_BUFFER_SIZE(NUM_DATA_ENTRIES,
                                                      MAX_LENGTH,
                                                      NUM_APPENDED_BYTES)]
                                                      __attribute__((aligned(4)));
    #else
    #error This compiler is not supported.
    #endif
    
    /* 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 packet[MAX_LENGTH + NUM_APPENDED_BYTES - 1]; /* The length byte is stored in a separate variable */
    
    /*
     * Application LED pin configuration table:
     *   - All LEDs board LEDs are off.
     */
    PIN_Config pinTable[] =
    {
        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);
    
        Semaphore_construct(&rxSemaphore, 0, NULL);
        rxSemaphoreHandle = Semaphore_handle(&rxSemaphore);
    
        /* Open LED pins */
        ledPinHandle = PIN_open(&ledPinState, pinTable);
        if (ledPinHandle == NULL)
        {
            while(1);
        }
    
        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);
        }
    
        /* Modify CMD_PROP_RX command for application needs */
        /* Set the Data Entity queue for received data */
        RF_cmdPropRx.pQueue = &dataQueue;
        /* Discard ignored packets from Rx queue */
        RF_cmdPropRx.rxConf.bAutoFlushIgnored = 1;
        /* Discard packets with CRC error from Rx queue */
        RF_cmdPropRx.rxConf.bAutoFlushCrcErr = 1;
        /* Implement packet length filtering to avoid PROP_ERROR_RXBUF */
        RF_cmdPropRx.maxPktLen = MAX_LENGTH;
        RF_cmdPropRx.pktConf.bRepeatOk = 1;
        RF_cmdPropRx.pktConf.bRepeatNok = 1;
    
        /* Request access to the radio */
    #if defined(DeviceFamily_CC26X0R2)
        rfHandle = RF_open(&rfObject, &RF_prop, (RF_RadioSetup*)&RF_cmdPropRadioSetup, &rfParams);
    #else
        rfHandle = RF_open(&rfObject, &RF_prop, (RF_RadioSetup*)&RF_cmdPropRadioDivSetup, &rfParams);
    #endif// DeviceFamily_CC26X0R2
    
        /* Set the frequency */
        RF_postCmd(rfHandle, (RF_Op*)&RF_cmdFs, RF_PriorityNormal, NULL, 0);
    
        /* Enter RX mode and stay forever in RX */
        RF_postCmd(rfHandle, (RF_Op*)&RF_cmdPropRx, RF_PriorityNormal, &callback, RF_EventRxEntryDone);
    
       while(1)
       {
           Semaphore_pend(rxSemaphoreHandle, BIOS_WAIT_FOREVER);
           PIN_setOutputValue(ledPinHandle, Board_PIN_LED2, !PIN_getOutputValue(Board_PIN_LED2));
       }
    
    }
    
    void callback(RF_Handle h, RF_CmdHandle ch, RF_EventMask e)
    {
        if (e & RF_EventRxEntryDone)
        {
            /* 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 + the status byte to the packet variable */
            memcpy(packet, packetDataPointer, (packetLength + 1));
    
            RFQueue_nextEntry();
    
            Semaphore_post(rxSemaphoreHandle);
        }
    }
    

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

    非常感谢您的 Siri。
    现在、当我尝试运行您的代码时、它会卡在这个 while 循环中、等待 rxSemaphoreHandle。


    while (1)

    Semaphore_pend (rxSemaphoreHandle、BIOS_WAIT_FOREVE);
    PIN_setOutputValue (ledPinHandle、Board_PIN_LED2、!PIN_getOutputValue (Board_PIN_LED2));

    我看了 rxSemaphoreHandle 中的内容、似乎没有任何变化。 我认为这可能是因为我们在这里使用信标、所以我尝试将其注释掉并再次运行。 考虑到该 while 循环位于主方法的末尾、它仍会卡在代码末尾。

    因此、我有一个奇怪的奇偶校验、这可能是缺少回送设置(我不太确定在哪里设置)、或者此接收器与发送器的数据速率不匹配。

    在这两种情况下、我都附上了用于发送器的代码。

    另外、当我在另一侧传输数据时运行 Smart RF Studio 的 Packet Rx 示例时、我能够轻松地接收数据包。 尽管错误率相对较高、但我仍在接收数据!

    提前非常感谢、但请告诉我该代码中缺少的内容!

  • 请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。
    /*
    版权所有(c) 2019、德州仪器(TI)公司
    *保留所有权利。
    *
    *
    只要
    符合以下条件*、允许以源代码和二进制形式重新分发和使用:
    *
    *源代码的重新分发必须保留上述版权
    声明*、此条件列表和以下免责声明。
    *
    ***二进制形式的再发行必须在
    
    *随发行提供的文档和/或其他材料中复制上述版权声明、本条件列表和以下免责声明。
    *
    ***未经
    
    事先书面许可、不得使用德州仪器公司的名称或*其贡献者的名称认可或推广从本软件衍生的产品*。
    *
    *本软件由版权所有者和贡献者"按原样"提供
    *、
    
    不承担任何明示或暗示的保证、包括但不限于*适销性和特定用途适用性的暗示保证*。 在任何情况下、版权所有者或
    *贡献者都不对任何直接、间接、偶然、特殊、
    *模范、 或相应的损害(包括但不限于
    *采购替代产品或服务;丧失使用、数据或利润;
    *或业务中断)、但出于任何责任理论
    、*无论是在合同中、严格责任还是由于
    使用本软件而以任何方式产生的侵权行为(包括疏忽或*其他)
    、*即使已获悉可能会发生此类损坏。
    */*****
    
    包括***** //*
    标准 C 库*//#include
    
    //#include 
    //
    ////* TI 驱动程序*//
    #include 
    //#include 
    //#include 
    //#include 
    //
    //////* Driverlib 头文件*//
    #include DeviceFamily_constructPath (driverlib/rf_prop_mailbox.h)
    //
    //////////*板头文件*//
    #include "Board.h"
    //#include "smartrf_settings/smartrf_settings.h"
    /***** 定义了***** /*
    
    进行功率测量*/
    //#define POWER_MEASement
    //数据包 TX 配置*/
    #define PAYLOAD_LENGTH 100
    #ifdef power_measurement
    #define packet_interval 5 /*对于功率测量、将数据包间隔设置为5s */
    #else
    #define PACKET_INTERVAL 500000 //将数据包间隔设置为500000us 或500ms */
    #endif
    
    #define SPI_MSG_LENGTH (40)
    #define SLAVE_MSG ("123456 ")
    /***** 原型***** //======
    
    spislave.c =====
    #include 
    //#include 
    
    /* TI 驱动程序*/
    #include 
    #include 
    #include 
    //#include 
    
    /* Driverlib 头文件*/
    #include DeviceFamily_constructPath (driverlib/rf_prop_mailbox.h)
    
    /*板头文件*/
    //#include "Board.h"
    #include "smartrf_settings/smartrf_settings.h"
    //#include "RFQueue.c"
    
    #include 
    #include 
    #include 
    
    /* POSIX 头文件*/
    #include 
    #include 
    #include 
    
    /*驱动程序头文件*/
    #include 
    #include 
    #include 
    
    /*示例/板头文件*/
    #include "Board.h"
    
    #define THREADSTACKSIZE (1024)
    
    #define SPI_MSG_LENGTH (40)
    #define SLAVE_MSG ("123456 ")
    
    #define MAX_LOOP (1000)
    int potatotrack = 0;
    static Display_Handle display;
    
    unsigned char slaveRxBuffer[SPI_MSG_length];
    unsigned char slaveTxBuffer[SPI_MSG_length];
    
    //在传输完成之前阻止从器件的信号量*
    / SEM_t slaveSem;
    
    uint16_t phaseBI;
    uintuint16 uintuintuintt inuintuintuintuintuintuintuint16
    kv;uintuintuintuintuintuintt
    
    uint16_t DCLinkI;
    uint16_t AuxT;
    uint16_t BattT;
    
    uint16_t HALL1;
    uint16_t hall2;
    uint16_t hall3;
    
    static rf_Object rfObject;
    static rfHandle rfHandle;
    rf_Params rfParams;
    
    //引脚驱动程序句柄*/
    static PIN_Handle ledPinHandle;
    static PIN_State ledPinState;
    
    static uint8_t packet[PAYLOY];
    static uint16_t seqpinHandle
    
    
    
    
    
    ;spi_SPI transfer_SPI translation_SPI;statuint32_spi_spi_spi_transaction_spiff;states
    
    int32_t status;
    /*
    
    应用 LED 引脚配置表:
    *-所有 LED 板 LED 均已关闭。
    */
    
    PIN_Config pinTable[]=
    {
    Board_PIN_LED1 | PIN_GPIO_OUTP_EN | PIN_GPIO_LOW | PIN_PushPull
    | PIN_DRVSTR_MAX、
    #ifdef power_measurement
    #if defined (Board_CC1350_LAUNCHXL)
    BOARD_DIO30_SWPWR | PIN_GPIO_OUTP_EN | PIN_GPIO_HIGH | PIN_PushPull | PIN_DRVSTR_MAX、
    #endif
    #endif
    PIN_TERMINATE };
    
    /*
    === transferCompleteFxn ===
    * SPI_TRANSFCTION ()的回调函数。
    //
    void transferCompleteFxn (SPI_Handle handle、SPI_Transaction *事务)
    {
    SEM_post (&slaveSem);
    }
    
    /*
    === slaveThread ====
    *从器件 SPI 在同时接收
    来自主器件的*消息的同时向主器件发送消息。
    //
    void * slaveThread (void * arg0)
    {
    
    Potatotrack = 1;
    /*
    * Board_SPI_MASTER_READY 和 Board_SPI_SLAVE_READY 是连接的 GPIO 引脚
    主器件和从器件之间的*。 这些引脚用于同步
    *通过一个小的"握手"来控制主器件和从器件应用。 引脚
    *稍后用于同步传输并确保主设备不会
    *开始传输、直至从设备就绪。 这些引脚的行为
    *不同的 spimaster 和 spislave 示例:
    *
    * spislave 示例:
    * * Board_SPI_MASTER_READY 配置为输入引脚。 期间
    * "握手"读取此引脚、高电平值将指示
    * 主设备已准备好运行应用程序。 之后、引脚为
    * 读取以确定主器件是否已打开其 SPI 引脚。
    * 当主器件打开其 SPI 时、它将把这个引脚拉低。
    *
    * * Board_SPI_SLAVE_READY 配置为输出引脚。 期间
    * "握手"此引脚从低电平更改为高电平输出。 这种情况
    * 通知主器件从器件已准备好运行应用程序。
    * 之后、从器件使用该引脚向主器件发出通知
    * 已准备好进行传输。 当准备好进行传输时、该引脚将会
    * 下拉至低电平。
    *
    *下面我们设置 Board_SPI_MASTER_READY 和 Board_SPI_SLAVE_READY 初始值
    *"握手"的条件。
    *
    GPIO_setConfig (Board_SPI_SLAVE_READY、GPIO_CFG_OUTPUT | GPIO_CFG_OUT_LOW);
    GPIO_setConfig (Board_SPI_MASTER_READY、GPIO_CFG_INPUT);
    Potatotrack = 2;
    /*
    *握手-将 Board_SPI_SLAVE_READY 设置为高电平以指示从器件就绪
    *以运行。 等待 Board_SPI_MASTER_READY 变为高电平。
    *
    GPIO_WRITE (Board_SPI_SLAVE_READY、1);
    // while (GPIO_Read (Board_SPI_MASTER_READY)= 0){}
    Potatotrack = 3;
    /*
    *创建同步信标;该信标将阻止从器件
    *直到传输完成。 从机配置为回调模式
    *以便我们配置 SPI 传输、然后通知主器件
    *从设备已准备就绪。 但是、我们仍然必须等待电流传输
    *在设置下一个之前完成。 因此、我们等待 slaveSem;
    *一旦传输完成、回调函数将解除阻止
    *从属设备。
    *
    状态= SEM_INIT (&slaveSem、0、0);
    Potatotrack = 4;
    如果(状态!= 0)
    {
    // display_printf (display、0、0、"创建 slaveSem\n"error creating slaveSem\n");
    
    while (1)
    ;
    }
    Potatotrack = 5;
    
    /*
    *等待主器件 SPI 打开。 配置 SPI 引脚时、将会发生这种情况
    *时钟可以从低电平切换到高电平(或从高电平切换到低电平、具体取决于
    *极性)。 如果使用3引脚 SPI 且从器件在之前已打开
    *假设主器件、时钟转换可能会导致从器件移出位
    *这是一个实际的传输。 我们可以通过打开来防止这种行为
    *首先主设备,然后打开从设备。
    //
    while (GPIO_Read (Board_SPI_MASTER_READY)){}
    Potatotrack = 6;
    /*
    *在回调模式下以从器件身份打开 SPI;回调模式用于允许我们这样做
    *配置传输、然后将 Board_SPI_SLAVE_READY 设置为高电平。
    *
    SPI_Params_init (&spiParams);
    Potatotrack = 7;
    // spiParams.frameFormat = SPI_POL1_PHA0;
    spiParams.frameFormat = SPI_POL1_PHA1;//获取旧 ALG 变为//
    spiParams.frameFormat = SPI_POL0_PHA1;
    Potatotrack = 8;
    spiParams.mode = SPI_SLAVE;
    Potatotrack = 9;
    // spiParams.transferCallbackFxn = transferCompleteFxn;
    potatotrack = 10;
    // spiParams.bitrate = 50000;
    // potatotrack = 111;
    // spiParams.transferMode = SPI_MODE_callback;
    Potatotrack = 11;
    slaveSpi = SPI_open (Board_SPI_slave、&spiParams);
    Potatotrack = 12;
    if (slaveSpi ==空)
    {
    // Display_printf (display、0、0、"初始化从器件 SPI\n"时出错);
    while (1)
    ;
    }
    其他
    {
    display_printf (display、0、0、"已初始化从属 SPI \n");
    }
    Potatotrack = 13;
    
    /*将消息复制到发送缓冲区*/
    strncpy ((char *) slaveTxBuffer、SLAVE_MSG、SPI_MSG_LENGTH);
    Potatotrack = 14;
    I = 0;
    // memset (((void *) slaveRxBuffer、0、SPI_MSG_length);
    // for (I = 0;I < MAX_LOOP;I++){
    rfHandle = rf_open (&rfObject、&rf_prop、
    (RF_RadioSetup*)&RF_cmdPropRadioDivSetup、
    rfParams (&R);
    Potatotrack = 111;
    /*设置频率*/
    rf_postCmd (rfHandle、(rf_Op*)&rf_cmdf、rf_PriorityNormal、NULL、0);
    Potatotrack = 12;
    while (真)
    {
    /*初始化从属 SPI 事务结构*//
    slaveTxBuffer[sizeof (slave_MSG)- 1]=(I % 10)+'0';
    Potatotrack = 15;
    memset ((void *) slaveRxBuffer、0、SPI_MSG_LENGTH);
    Potatotrack = 16;
    transaction.count = SPI_MSG_length;
    Potatotrack = 17;
    transaction.txBuf =(void *) slaveTxBuffer;
    Potatotrack = 18;
    transaction.rxBuf =(void *) slaveRxBuffer;
    Potatotrack = 19;
    /*打开用户 LED 指示灯,指示正在进行 SPI 传输*/
    GPIO_TOGGLE (Board_GPIO_LED1);
    Potatotrack = 20;
    
    
    rf_params_init (&rfParams);
    
    Potatotrack = 51;
    /*打开 LED 引脚*//
    ledPinHandle = PIN_OPEN (&ledPinState、pinTable);
    // Potatotrack = 61;
    // if (ledPinHandle == NULL)
    // {
    // while (1)
    // {
    // Potatotrack = 661;
    //}
    //}
    Potatotrack = 71;
    rf_cmdPropTx.pktLen =有效载荷长度;
    Potatotrack = 81;
    rf_cmdPropTx.startTrigger.triggerType = trig_now;
    Potattrack = 91;
    //初始化 SPI
    //将 SPI 设置为从模式
    //和 SPI_MODE_BLOCKING。
    Potatotrack = 101;
    /*请求对讲机的访问权限*/
    
    
    //
    / while (1)
    // {
    // memset ((void *) slaveRxBuffer、0、SPI_MSG_LENGTH);
    // Potatotrack = 13;
    // transaction.count = SPI_MSG_length;
    // Potatotrack = 14;
    // transaction.txBuf =(void *) slaveTxBuffer;
    // Potatotrack = 15;
    // transaction.rxBuf =(void *) slaveRxBuffer;
    // Potatotrack = 16;
    // //读取要通过 SPI 读取的字节
    //
    
    //////}
    
    /*
    *设置 SPI 传输;Board_SPI_SLAVE_READY 将设置为通知
    *主设备从设备就绪。
    *
    transferOK = SPI_transfer (slaveSpi、事务);
    Potatotrack = 21;
    
    如果(转让)
    {
    GPIO_WRITE (Board_SPI_SLAVE_READY、0);
    Potatotrack = 211;
    // 等待传输完成
    // SEM_WAIT (slaveSem);
    Potatotrack = 22;
    
    // *驱动 Board_SPI_SLAVE_READY 高电平以指示从器件未就绪
    // *用于另一个传输。
    
    GPIO_WRITE (Board_SPI_SLAVE_READY、1);
    Potatotrack = 23;
    
    phaseAI = slaveRxBuffer[0]* 256 + slaveRxBuffer[1];
    phaseBI = slaveRxBuffer[2]* 256 + slaveRxBuffer[3];
    
    CoilT = slaveRxBuffer[4]* 256 + slaveRxBuffer[5];
    BattT = slaveRxBuffer[6]* 256 + slaveRxBuffer[7];
    AuxT = slaveRxBuffer[8]* 256 + slaveRxBuffer[9];
    
    HALL1 = slaveRxBuffer[10]* 256 + slaveRxBuffer[11];
    hall2 = slaveRxBuffer[12]* 256 + slaveRxBuffer[13];
    hall3 = slaveRxBuffer[14]* 256 + slaveRxBuffer[15];
    
    DCLinkI = slaveRxBuffer[16]* 256 + slaveRxBuffer[17];
    DCLinkV = slaveRxBuffer[18]* 256 + slaveRxBuffer[19];
    // display_printf (display、0、0、"从机接收到:%s"、slaveRxBuffer);
    
    Potatotrack = 17;
    
    //将 rxBuf 复制到数据包
    Potatotrack = 18;
    memcpy (packet、slaveRxBuffer、PAYLOAD_LENGTH);
    Potatotrack = 19;
    rf_cmdPropTx.pPkt=数据包;
    /*发送数据包*/
    Potatotrack = 20;
    rf_runCmd (rfHandle、(rf_Op*)&rf_cmdPropTx、rf_PriorityNormal、NULL、
    0);
    }
    其他
    {
    // display_printf (display、0、0、"从器件 SPI 传输失败");
    Potatotrack = 233;
    }
    
    睡眠(1);
    i++;
    Potatotrack = 24;
    }
    
    SPI_Close (slaveSpi);
    Display_printf (display、0、0、"Clearing Buffer");
    Potatotrack = 25;
    /*示例完成-将引脚设置为已知状态*/
    GPIO_setConfig (Board_SPI_MASTER_READY、GPIO_CFG_OUTPUT | GPIO_CFG_OUT_LOW);
    GPIO_WRITE (Board_SPI_SLAVE_READY、0);
    Potatotrack = 26;
    display_printf (display、0、0、"\nDone");
    Potatotrack = 27;
    返回(NULL);
    }
    
    /*
    ==== mainThread ====
    //
    void * mainThread (void * arg0)
    {
    pthread_t thread0;
    pthread_attr_t atttrs;
    struct sched_param primParam;
    int retc;
    int detachState;
    
    /*调用驱动程序初始化函数。 *
    display_init();
    GPIO_init();
    spi_init();
    
    /*配置 LED 引脚*/
    GPIO_setConfig (Board_GPIO_LED0、GPIO_CFG_OUT_STD | GPIO_CFG_OUT_LOW);
    GPIO_setConfig (Board_GPIO_LED1、GPIO_CFG_OUT_STD | GPIO_CFG_OUT_LOW);
    
    /*打开输出的显示屏*/
    Display = Display_open (Display_Type_UART、NULL);
    if (显示== NULL)
    {
    /*无法打开显示驱动程序*/
    while (1)
    ;
    }
    
    /*打开用户 LED */
    GPIO_WRITE (Board_GPIO_LED0、Board_GPIO_LED_ON);
    
    display_printf (display、0、0、"启动 SPI 从设备示例");
    display_printf (
    显示屏、
    0、
    0、
    "此示例要求外部电线"
    "已连接至接头引脚。 有关详细信息、请参阅 Board.html。\n");
    
    /*创建应用程序线程*/
    pthread_attr_init (atttrs);
    
    detachState = pthread_create_detached;
    /*设置优先级和堆栈大小属性*/
    retc = pthread_attr_setdetachstate (&attrs、detachState);
    如果(retc!= 0)
    {
    /* pthread_attr_setdetachstate()失败*/
    while (1)
    ;
    }
    
    retc |= pthread_attr_setstacksize (&attrs、THREADSTACKSIZE);
    如果(retc!= 0)
    {
    /* pthread_attr_setstacksize()失败*/
    while (1)
    ;
    }
    
    /*创建从线程*/
    priParam.sched_priority = 1;
    pthread_attr_setschedparam (&attrs、&priParam);
    
    retc = pthread_create (&thread0、&attrs、slaveThread、NULL);
    如果(retc!= 0)
    {
    /* pthread_create()失败*/
    while (1)
    ;
    }
    
    返回(空);
    }
    
    // SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSPLITTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
    
    //
    
    
    //////////////////////// define PAYLOAD_LENGTH 10
    //
    //////////// static RF_Object rfobject rfobject rfobject;
    //static RF_handle rfHandle rfHandle;
    //
    
    
    
    
    
    
    
    
    
    
    
    
    
    // spirt_translength = rft_tract/rf_rf_tract/rf_rf_rf_rf_tractuF;//*暂存= rfrf_rf_rf_rftRF/rf_tract/rf_rf_tractu/rf_tractuF = rf_rf_rs/rft_rf_rf_rftRF/rf_rf_rf_rf_rgrft_rulk/rf_rg/
    //
    // SPI_Params rspiParams;
    // spiParams_init
    (&spiParams);
    // spiParams.frameFormat = SPI_POL1_PHA1;
    // spiParams.mode = SPI_SLAVE;
    // spiParams.init = SPI_MODE_REACK_SPIRF/ spiSpiParams.pitrate
    = 2000000;
    // spiParams.mode = SPIF/
    Spi_Transaction/spirtf
    
    
    
    
    
    ;// spi_parkitrf_parf/ spirtum.rf = SPrf_params.rf;// spi_transferrf_rf = spi_rf;// spirtum.rf = spi_parallf;// spi_transliftum_spi_spirtum.rf = spi_transliftum.rf;// spi_spi_spi_transferrf = spi_spi_spi_
    //
    // RF_postCmd (rfHandle、 (RF_OP*)&RF_cmdF、RF_PriorityNormal、NULL、0);
    //
    while (1)
    //{
    // SPI_transfer (spiHandle、&spiTransaction);
    // memcpy (rfPacket、spiRxBuffer、PAYLOAD_LENGTH);
    // rf_runCmd (rfHandle、(rf_Op*)&rf_cmdPropTx、rf_PriorityNormal、NULL、0);
    //}
    //}
    //
    //
    ////
    //////
    //////
    //
    //
    
    /////////SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSPPPPPPPPPPPPPPPPPLLLLLLLLLLLLLLLLIIIIIIIIIIIIIIIIIIIIIIIIITTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
    
    //***** 变量声明***** //
    
    /////int potatotrack = 0;
    //
    // spi_handle slaveSpi;
    //spi_Params spiParams;
    //spi_transaction transaction;
    //uint32_t i;
    //bool transferOK;
    //int32_t status;
    //unsigned char slaveRxBuffer[SPI_MSG_length];
    //unsigned char slaveTxBuffer[SPI_Number_length];
    //static
    RF_Object rfObject;
    //static RF_handle rfHandle;
    ////
    ////* pin 驱动程序配置/intle/static/static/pin
    t/static rfobject rfobject rfobject
    
    
    ;// static rfHandle/static/static/static/trle /trlength/ static/static/in/in/in/intry_dr/ static/intry_dr/ static/pin handle;////// pin /tr
    
    
    
    
    //*-所有 LED 板 LED 均关闭。
    //*//
    //PIN_Config pinTable[]=
    // {
    // BOARD_PIN_LED1 | PIN_GPIO_OUTP_EN | PIN_GPIO_LOW | PIN_PushPull
    // | PIN_DRVSTR_MAX、
    //#ifdef power_measurement
    //#if defined (Board_CC1350_LAUNCHXL)
    // BOARD_DIO30_SWPWR | PIN_GPIO_OUTP_EN | PIN_GPIO_HIGH | PIN_PushPull | PIN_DRVSTR_MAX、
    //#endif
    //#endif
    // PIN_TERMINATE };
    //
    //***** 函数定义***** ///void
    * mainThread (void * arg0)
    //{
    //
    potatotrack = 1;
    // spiParams.frameFormat = SPI_POL1_PHA1;//获取旧 ALG 转接
    // spiParams.frameFormat = SPI_POL0_PHA1;
    //potatotrack = 8;
    // potatotrack = 2;
    // potattrack
    =// potxn/ pix/potattrack =
    
    10;// potattrack =// potattrack =// potattrack = potxn;// potattrack =// potattrack =// potattrack =// potxn;// f2;// potattrack = p
    //// spiParams.bitrate = 500000;
    // potatotrack = 3;
    /// spiParams.transferMode = SPI_MODE_BLOCKING;
    //potatotrack = 11;
    // potatotrack = 4;
    // RF_pinparams.transferMode;
    // RF_params_init(&rfpintrack/* pinattrack
    
    =
    
    
    6;// pinatle/ pintrack = 6;// pinatointo/ pine/pintrack = 6;// pinattrack =开放 pine/pine/pintrack = 6;// pinatopine/pintrack = 6;//
    // if (ledPinHandle == NULL)
    //{
    // while (1)
    // {
    // Potatotrack = 66;
    //}
    //}
    // potatotrack = 7;
    // RF_cmdProptTx.pktLen = PAYLOAD_LENGTH;
    // potatotrack = 8;
    // RF_cmdProptTx.startTrigger.triggerType = TRIG_NOW;
    // potatotrack = 9;
    // Init SPI
    ////设置 SPI_Slave 和 SPI_Mode。
    //
    // slaveSpi = SPI_open (Board_SPI_slave、&spiParams);
    // potatotrack = 10;
    ////////请求对无线电的访问*//
    rfHandle = RF_open (&rfObject、&RF_prop、
    // (RF_RadioSetup*)&RF_cmdPropDivSetup、&rfParams);
    // potatotrack = 11;
    //////////设置频率*//
    RF_postCmd (rfHandle、(RRF_OP*)&RF_cmdF、RF_PriorityNormal、NULL、0);
    // potatotrack = 12;
    // while (1)
    //{
    // memset ((void *) slaveRxBuffer、0、SPI_MSG_LENGTH);
    // Potatotrack = 13;
    // transaction.count = SPI_MSG_length;
    // Potatotrack = 14;
    // transaction.txBuf =(void *) slaveTxBuffer;
    // Potatotrack = 15;
    // transaction.rxBuf =(void *) slaveRxBuffer;
    // Potatotrack = 16;
    // //读取要通过 SPI 读取的字节
    // SPI_transfer (slaveSpi、&transaction);
    // Potatotrack = 17;
    //
    // //将 rxBuf 复制到数据包
    // Potatotrack = 18;
    // memcpy (packet、slaveRxBuffer、PAYLOAD_LENGTH);
    // Potatotrack = 19;
    // RF_cmdPropTx.pPkt=数据包;
    // /*发送数据包*/
    // Potatotrack = 20;
    // rf_runCmd (rfHandle、(rf_Op*)&rf_cmdPropTx、rf_PriorityNormal、NULL、0);
    //
    //}
    //}
    
    // SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSLITTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
    
    // void * mainThread (void * arg0)
    //{
    // RF_Params rfParams;
    // pinHandle_init (&rfParams);
    //
    ////////// Pinle/=
    Open //*
    =//*(//)/pinHandle/=/pinle/=/*
    
    while (1);
    ////
    
    //#ifdef power_measurement
    //#if defined (Board_CC1350_LAUNCHXL)
    //////将 PA 有效引脚路由到 Board_DIO30_SWPWR *//
    // PINCC26XX_setMux (ledPinHandle、Board_DIO30_SWPWR、PINTx_TRF/ TRIP_TRIPD/ TRF_TRIPD/ TRF_TRF_TRIPD/ TRF_TRIPD/ TRF_TRIPF
    
    
    
    
    = TRIPD/ TRIPD/ TRIPTx_TRIPD/ TRIPF = TRF_TRIP.xx //#TRIP_TRIP_TRIP_TRIPF = TRIPD/ TRIP_TRIPF = TRIPD/ TRIP_TRIP_TRIPF =
    
    //
    //////////*请求访问无线电*//
    //#if define (DeviceFamily_CC26X0R2)
    // rfHandle = RF_open (&rfObject、&RF_prop、(RF_DeviceSetup*)&RF_cmdPropRadioSetup、&rfParams);
    //#else
    // rfHandle = RF_DeviceSetup*
    
    
    
    、&rf*、RF_Prop*、RF_RadioSet*、RF_RadioSet*、#rf&rf2 (#rf2)// rf2 RF_Proped&rf2、RF_N、RF_RF_RF_RF_N、RF_N RF_RF_N、RF_N RF_N RF/RF_N RF_N RF/#rf2 RF_N RF/RF_N RF/RF_N RF_N RF/RF/RF_N RF_N RF/RF_N
    //
    // while (1)
    //{
    // /*创建具有递增序列号和随机有效载荷的数据包*//
    packet[0]=(uint8_t)(seqNumber >> 8);
    // packet[1]=(uint8_t)(seqNumber++);
    // uint8_t i;
    // 对于(i = 2;i < PAYLOAD_LENGTH;i++)
    // {
    // packet[i]= rand();
    //}
    //
    // /*发送数据包*/
    // RF_EventMask terminationReason= RF_runCmd (rfHandle、(RF_OP*)&RF_cmdPropTx、
    // RF_PriorityNormal、NULL、0);
    //
    // switch (terminationReason)
    // {
    // 案例 RF_EventLastCmdDone:
    // //独立无线电操作命令或最后一个无线电
    // //链中的操作命令已完成。
    // 中断;
    // Case RF_EventCmd Cancelled:
    // //命令在启动前已取消;可能是由
    //引起的 //按 RF_cancelCmd ()或 RF_flushCmd ()。
    // 中断;
    // 案例 RF_EventCmdAborted:
    // //由 RF_cancelCmd ()或
    //引起的命令终止突然 // rf_flushCmd ()。
    // 中断;
    // 案例 RF_EventCmdStopPed:
    // //由 RF_cancelCmd ()或
    //引起的正常命令终止 // rf_flushCmd ()。
    // 中断;
    // 默认值:
    // //未捕捉错误事件
    // while (1);
    //}
    //
    // uint32_t cmdStatus =(volatile rf_Op*)&rf_cmdPropTx)->status;
    // switch (cmdStatus)
    // {
    // 案例 PROP_DONE_OK:
    // //数据包传输成功
    // 中断;
    // 案例 PROP_DONE_STOPPED:
    // //在发送数据包并完成时接收到 CMD_STOP
    // //发送数据包
    // 中断;
    // 案例 PROP_DONE_ABORT:
    // //发送数据包时接收到 CMD_ABORT
    // 中断;
    // 案例 PROP_ERROR_PAR:
    // //观察到的非法参数
    // 中断;
    // 案例 PROP_ERROR_NO_SETUP:
    // //未在受支持的
    //中设置无线电而发送的命令 //使用 CMD_PROP_RADIO_SETUP 或 CMD_RADIO_SETUP 的模式
    // 中断;
    // 案例 PROP_ERROR_NO_FS:
    // //发送命令而不对合成器进行编程
    // 中断;
    // 案例 PROP_ERROR_TXUNF:
    // //运行期间观察到的 TX 下溢
    // 中断;
    // 默认值:
    // //未捕获的错误事件-这些可能来自
    // // rf_mailbox.h 中定义的状态池
    // while (1);
    //}
    //
    //#ifndef power_measurement
    // PIN_setOutputValue (ledPinHandle、Board_PIN_LED1、!PIN_getOutputValue (Board_PIN_LED1));
    //#endif
    // /*关闭无线电*//
    RF_Yield (rfHandle);
    //
    //#ifdef power_measurement
    // /* packet_interval s 的休眠*/
    // 睡眠(packet_interval);
    //#else
    // /* packet_interval us 的睡眠*//
    usleep (packet_interval);
    //#endif
    //
    }
    //} 
  • 请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。

    发送的数据包使用 PAYLOAD_LENGTH 100、然后将接收器上的最大数据包长度设置为30 (如果使用的是我的代码)。

    请注意、我的代码的工作方式是、它只接收 CRC 正常的数据包。 所有其它数据包将被丢弃。

    BR

    Siri

  • 请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。
    很好,这真的很好!
    我可以看到正在接收数据、尽管数据在稍微有点古怪的 rxDataEntryBuffer 上、但我仍然在接收数据!
    
    现在、我非常抱歉将其拖出来、但你们是唯一能够帮助我解决这个问题的人。
    我现在尝试反之 SPI 集成、其中 CC1310现在是主器件。
    我已经尝试集成一些独立 SPI 主器件代码、这些代码与另一个 TMS320F28379D launchpad 独立工作。
    程序再次卡在下一行。
    
    transferOK = SPI_transfer (masterSpi、&transaction);
    
    
    
    我知道、在您上次在另一侧为我校正时(当 CC1310是从器件和 TMS320F28379D)、应该发生这些事件的序列、 但这个射频示例不同、我真的看不到一个很明显的地方可以放置一次性设置的东西。
    
    您能告诉我一切是否都是它的本意吗?
    
    
    
    谢谢您是一个传奇人物 
  • 请注意,本文内容源自机器翻译,可能存在语法或其它翻译错误,仅供参考。如需获取准确内容,请参阅链接中的英语原文或自行翻译。

    /*
    *版权所有(c) 2019、德州仪器(TI)公司
    *保留所有权利。
    *
    *以源代码和二进制形式重新分发和使用、有无
    *如果满足以下条件、则允许进行修改
    符合*:
    *
    **源代码的重新分发必须保留上述版权
    *注意、此条件列表和以下免责声明。
    *
    **二进制形式的再发行必须复制上述版权
    *请注意、中的此条件列表和以下免责声明
    *随分发提供的文档和/或其他材料。
    *
    **德州仪器公司的名称和名称均不相同
    *其贡献者可用于认可或推广衍生产品
    *未经特定的事先书面许可。
    *
    *本软件由版权所有者和贡献者"按原样"提供
    *以及任何明示或暗示的保证、包括但不限于:
    *特定适销性和适用性的隐含保证
    *不承认目的。 在任何情况下、版权所有者不得或
    *派遣国应对任何直接、间接、偶然、特殊、
    *典型或必然的损害(包括但不限于
    *采购替代货物或服务;丧失使用、数据或利润;
    *或业务中断)、无论原因是什么以及任何责任理论、
    *无论是合同、严格责任还是侵权行为(包括疏忽或)
    *否则)因使用本软件而以任何方式产生、
    *即使被告知可能会发生此类损坏。
    *

    /***** 包括***** /
    /*标准 C 库*/
    #include

    #include
    #include


    /* TI 驱动程序*/
    #include
    #include

    #include
    #include
    #include

    /* Driverlib 头文件*/
    #include DeviceFamily_constructPath (driverlib/rf_prop_mailbox.h)

    #include
    #include
    #include

    /*板头文件*/
    #include "Board.h"

    /*应用程序头文件*/
    #include "RFQueue.h"
    #include "smartrf_settings/smartrf_settings.h"

    /***** 定义了***** /

    /*数据包 RX 配置*/
    #define DATA_Entry_header_size 8 //通用数据条目的恒定标头大小*/
    #define MAX_LENGTH 30 //对讲机将接受的最大长度字节*/
    #define NUM_DATA_ENTRIES 2 //注意:目前仅支持两个数据条目*/
    #define NUM_SUBSTED_Bytes 2 //数据条目数据字段将包含:
    * 1标头字节(RF_cmdPropRx.rxConf.bIncludeHdr = 0x1)
    *最多30个有效载荷字节
    * 1个状态字节(RF_cmdPropRx.rxConf.bAppendStatus = 0x1)*

    /***** 原型***** /
    静态空回调(rf_handle h、rf_CmdHandle ch、rf_EventMask e);

    /***** 变量声明***** /
    静态 RF_Object rfObject;
    静态 RF_Handle rfHandle;

    /*引脚驱动器手柄*/
    静态 PIN_Handle ledPinHandle;
    静态 PIN_STATE ledPinState;

    /*缓冲区,包含用于接收数据的所有数据条目。
    需要* pragma 以确保此缓冲区是4字节对齐的(RF 内核的要求)*/
    #if defined (__TI_Compiler_version__)
    #pragma DATA_ALIGN (rxDataEntryBuffer、4);
    静态 uint8_t
    rxDataEntryBuffer[RF_queue_data_entry_buffer_size (NUM_DATA_entries、
    MAX_LENGTH、
    num_apped_Bytes)];
    #Elif defined (_IAR_systems_icc_)
    #pragma DATA_alignment= 4.
    静态 uint8_t
    rxDataEntryBuffer[RF_queue_data_entry_buffer_size (NUM_DATA_entries、
    MAX_LENGTH、
    num_apped_Bytes)];
    #Elif defined (_GNU_)
    静态 uint8_t
    rxDataEntryBuffer[RF_queue_data_entry_buffer_size (NUM_DATA_entries、
    MAX_LENGTH、
    num_apped_bytes)]
    __attribute__((aligned(4)));
    其他
    错误不支持此编译器。
    #endif

    /*接收用于射频内核的数据队列以填充数据*/
    静态 dataQueue_t dataQueue;
    静态 RFC_dataEntryGeneral_t* currentDataEntry;
    静态 uint8_t packetLength;
    静态 uint8_t* packetDataPointer;


    //SPI
    SPI_Handle masterSpi;
    SPI_Params spiParams;
    SPI_Transaction 事务;
    uint32_t i;
    bool transferOK;
    int32_t status;


    #define SPI_MSG_LENGTH (30)
    #define MASTER_MSG ("123 567 ")
    int potatotrack=0;
    #define MAX_LOOP (1000)

    unsigned char masterRxBuffer[SPI_MSG_length];
    unsigned char masterTxBuffer[SPI_MSG_length];


    //potattrack=5;
    /*将 SPI 作为主器件打开(默认)*/

    //potattrack=9;

    //#define THREADSTACKSIZE (1024)

    静态 uint8_t packet[MAX_LENGTH + NUM_SUBSTED_BYTES - 1];//长度字节存储在单独的变量中*/

    /*
    *应用 LED 引脚配置表:
    *-所有 LED 板 LED 均熄灭。
    *
    PIN_Config pinTable[]=

    BOARD_PIN_LED2 | PIN_GPIO_OUTP_EN | PIN_GPIO_LOW | PIN_PushPull | PIN_DRVSTR_MAX、
    PIN_TERMINATE
    };

    /***** 函数定义***** /

    void * mainThread (void * arg0)


    rf_params rfParams;
    rf_params_init (&rfParams);

    /*打开 LED 引脚*/
    ledPinHandle = PIN_OPEN (&ledPinState、pinTable);
    if (ledPinHandle ==空)

    while (1);

    if (RFQueue_defineQueue (&dataQueue、
    rxDataEntryBuffer、
    sizeof (rxDataEntryBuffer)、
    num_data_entries、
    max_length + NUM_apped_bytes))

    /*未能为所有数据条目分配空间*/
    while (1);

    /*根据应用需求修改 CMD_PROP_RX 命令*/
    /*为接收的数据设置数据实体队列*/
    RF_cmdPropRx.pQueue =&dataQueue;
    /*丢弃来自 Rx 队列的已忽略的数据包*/
    rf_cmdProprx.rxConf.bAutoFlushIgnored = 1;
    /*丢弃来自 Rx 队列的 CRC 错误数据包*/
    rf_cmdPropRx.rxConf.bAutoFlushCrcErr = 1;
    /*实施数据包长度过滤以避免 PROP_ERROR_RXBUF */
    RF_cmdPropRx.maxPktLen = MAX_LENGTH;
    rf_cmdPropRx.pktConf.bRepeatOk = 1;
    rf_cmdPropRx.pktConf.bRepeatNok = 1;

    /*请求对讲机的访问*/
    #IF 已定义(DeviceFamily_CC26X0R2)
    rfHandle = RF_OPEN (&rfObject、&RF_prop、(RF_RadioSetup*)&RF_cmdPropRadioSetup、&rfParams);
    其他
    rfHandle = RF_OPEN (&rfObject、&RF_prop、(RF_RadioSetup*)&RF_cmdPropRadioDivSetup、&rfParams);
    #endif// DeviceFamily_CC26X0R2

    /*设置频率*/
    rf_postCmd (rfHandle、(rf_Op*)&rf_cmdf、rf_PriorityNormal、NULL、0);


    /*进入 RX 模式并一直保持在 RX 中*/
    RF_EventMask terminationReason= RF_runCmd (rfHandle、(RF_OP*)&RF_cmdPropRx、
    RF_PriorityNormal、回调(&R)、
    RF_EventRxEntryDone);

    // if (transferOK){
    // Display_printf (display、0、0、"Master received:%s"、masterRxBuffer);
    //}
    //否则{
    // Display_printf (display、0、0、"unsuccessful master SPI transfer");
    //}
    Potattrack=21;
    /*在开始下一个 SPI 传输前睡眠一位*/
    //睡眠(3);
    Potattrack=22;


    switch (terminationReason)

    案例 RF_EventLastCmdDone:
    //独立无线电操作命令或最后一个无线电
    //链中的操作命令已完成。
    中断;
    案例 RF_EventCmd 取消:
    //命令在启动前被取消;这可能是导致的
    //按 RF_cancelCmd ()或 RF_flushCmd ()。
    中断;
    案例 RF_EventCmdAborted:
    //由 RF_cancelCmd ()或导致命令终止突然
    // rf_flushCmd ()。
    中断;
    案例 RF_EventCmdStopped:
    // RF_cancelCmd ()或导致正常命令终止
    // rf_flushCmd ()。
    中断;
    默认值:
    //未捕捉错误事件
    while (1);

    uint32_t cmdStatus =(volatile rf_Op*)&rf_cmdPropRx)-> status;
    switch (cmdStatus)

    案例 PROP_DONE_OK:
    //接收到的数据包,CRC 正常
    中断;
    PROP_DONE_RXERR 案例:
    //接收到的数据包带有 CRC 错误
    中断;
    案例 PROP_DONE_RXTIMEOUT:
    //同步搜索时观察到的结束触发
    中断;
    案例 PROP_DONE_break:
    //在命令为时接收数据包时观察到结束触发
    //配置的 endType 设置为1
    中断;
    案例 PROP_DONE_ENDended:
    //观察完结束触发后收到的数据包;如果
    //命令配置为 endType 设置为0,即结束触发器
    //不会终止正在进行的接收
    中断;
    案例 PROP_DONE_STOPPED:
    //命令启动后接收到 CMD_STOP,如果发现 SYNC,
    //数据包被接收
    中断;
    案例 PROP_DONE_ABORT:
    //命令启动后收到 CMD_ABORT
    中断;
    PROP_ERROR_RXBUF 案例:
    //没有足够大的 RX 缓冲区来存放处可用的接收数据
    //数据包开始
    中断;
    PROP_ERROR_RXFULL 案例:
    //在接收部分读取期间超出 RX 缓冲区空间
    中断;
    案例 PROP_ERROR_PAR:
    //观察到非法参数
    中断;
    PROP_ERROR_NO_SETUP 案例:
    //在受支持的中未设置无线电的情况下发送命令
    //模式使用 CMD_PROP_RADIO_SETUP 或 CMD_RADIO_SETUP
    中断;
    案例 PROP_ERROR_NO_FS:
    //发送命令而不对合成器进行编程
    中断;
    案例 PROP_ERROR_RXOVF:
    操作期间观察到// RX 溢出
    中断;
    默认值:
    //未捕获的错误事件-这些可能来自
    // rf_mailbox.h 中定义的状态池
    while (1);

    while (1);

    空回调(rf_handle h、rf_CmdHandle ch、rf_EventMask e)

    IF (e 和 RF_EventRxEntryDone)

    //potattrack=6;
    spiParams.frameFormat = SPI_POL0_PHA1;
    //potattrack=7;
    spiParams.bitrate = 100000;
    //potattrack=8;
    SPI_Params_init (&spiParams);
    masterSpi = SPI_open (Board_SPI_master、&spiParams);
    /*切换引脚以指示 RX */
    PIN_setOutputValue (ledPinHandle、Board_PIN_LED2、
    !PIN_getOutputValue (Board_PIN_LED2);

    // strncpy (((char *) masterTxBuffer、(unsigned char) rxDataEntryBuffer、SPI_MSG_length);
    strncpy ((char *) masterTxBuffer、rxDataEntryBuffer、SPI_MSG_length);

    memset ((void *) masterRxBuffer、0、SPI_MSG_LENGTH);
    Potattrack=15;
    transaction.count = SPI_MSG_length;
    Potattrack=16;
    transaction.txBuf =(void *) masterTxBuffer;
    Potattrack=17;
    transaction.rxBuf =(void *) masterRxBuffer;
    Potattrack=18;

    GPIO_TOGGLE (Board_GPIO_LED1);
    Potattrack=19;
    /*执行 SPI 传输*/
    transferOK = SPI_transfer (masterSpi、事务);
    Potattrack=20;


    /*获取当前未处理的数据输入*/
    currentDataEntry = RFQueue_getDataEntry();

    /*处理位于&currentDataEntry->data 的数据包数据:
    *-长度是当前配置的第一个字节
    *-数据从第二个字节开始*/
    packetLength =*(uint8_t*)(&currentDataEntry ->数据);
    packetDataPointer =(uint8_t*)(&currentDataEntry->data+1);

    /*将有效载荷+状态字节复制到数据包变量*/
    memcpy (packet、packetDataPointer、(packetLength + 1));

    RFQueue_nextEntry();

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

    我已经建议您在一个月前(3月9日)使用信标执行此操作。 当您不遵循我给您的建议时、会很难为您提供帮助。 您需要将所有 UART 内容从回调中移出。

    此外、它不是要通过 SPI 传输的 rxDataEntryBuffer、而是要发送的"数据包"。

    首先使用信标启动并运行射频部件、但您切换 LED (不要在回调中执行此操作、而是在信标上挂起后通过 SPI 发送数据。

    启动并运行之后、您可以用 SPI 代码替换 LED 切换。

    Siri

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

    你(们)好、Siri

    客户 Shaetrun Pathmanathan 不知道为什么他的账户无法回复您的信息、

    客户回复:

    Heya Siri,
    感谢您的耐心等待。
    我让 LED 切换、数据包被接收!
    我尝试按照您的建议切换 LED 并进行切换。
    现在、我要尝试用我在初级侧 TMS320F28379D 中使用的主 SPI 代码替换它。
    我尝试像您所说的那样传输数据包、但代码此时再次挂起:

    transferOK = SPI_transfer (masterSpi、事务);

    我尝试检查正在传递的变量 SPI_transfer 和 masterSpi 为空、但事务变量似乎有某种形式的地址进入它。
    我一直在努力进一步研究保持是什么、但我看不到任何明显的东西。
    上一次、您会想到找我吗?

    谢谢您3000!

    代码;

    /***** 包括***** /
    /*标准 C 库*/
    #include

    /* TI 驱动程序*/
    #include
    #include

    #include
    #include
    #include
    #include

    /* Driverlib 头文件*/
    #include DeviceFamily_constructPath (driverlib/rf_prop_mailbox.h)

    /*板头文件*/
    #include "Board.h"

    /*应用程序头文件*/
    #include "RFQueue.h"
    #include "smartrf_settings/smartrf_settings.h"

    /***** 定义了***** /

    /*数据包 RX 配置*/
    #define DATA_Entry_header_size 8 //通用数据条目的恒定标头大小*/
    #define MAX_LENGTH 30 //对讲机将接受的最大长度字节*/
    #define NUM_DATA_ENTRIES 2 //注意:目前仅支持两个数据条目*/
    #define NUM_SUBSTED_Bytes 2 //数据条目数据字段将包含:
    * 1标头字节(RF_cmdPropRx.rxConf.bIncludeHdr = 0x1)
    *最多30个有效载荷字节
    * 1个状态字节(RF_cmdPropRx.rxConf.bAppendStatus = 0x1)*

    静态信标_StructrxSemaphore;
    静态 Semaphore_handle rxSemaphoreHandle;

    //SPI 数据
    #define THREADSTACKSIZE (1024)

    /***** 原型***** /
    静态空回调(rf_handle h、rf_CmdHandle ch、rf_EventMask e);

    /***** 变量声明***** /
    静态 RF_Object rfObject;
    静态 RF_Handle rfHandle;

    /*引脚驱动器手柄*/
    静态 PIN_Handle ledPinHandle;
    静态 PIN_STATE ledPinState;

    /*缓冲区,包含用于接收数据的所有数据条目。
    需要* pragma 以确保此缓冲区是4字节对齐的(RF 内核的要求)*/
    #if defined (__TI_Compiler_version__)
    #pragma DATA_ALIGN (rxDataEntryBuffer、4);
    静态 uint8_t
    rxDataEntryBuffer[RF_queue_data_entry_buffer_size (NUM_DATA_entries、
    MAX_LENGTH、
    num_apped_Bytes)];
    #Elif defined (_IAR_systems_icc_)
    #pragma DATA_alignment= 4.
    静态 uint8_t
    rxDataEntryBuffer[RF_queue_data_entry_buffer_size (NUM_DATA_entries、
    MAX_LENGTH、
    num_apped_Bytes)];
    #Elif defined (_GNU_)
    静态 uint8_t
    rxDataEntryBuffer[RF_queue_data_entry_buffer_size (NUM_DATA_entries、
    MAX_LENGTH、
    num_apped_bytes)]
    __attribute__((aligned(4)));
    其他
    错误不支持此编译器。
    #endif

    /*接收用于射频内核的数据队列以填充数据*/
    静态 dataQueue_t dataQueue;
    静态 RFC_dataEntryGeneral_t* currentDataEntry;
    静态 uint8_t packetLength;
    静态 uint8_t* packetDataPointer;


    静态 uint8_t packet[MAX_LENGTH + NUM_SUBSTED_BYTES - 1];//长度字节存储在单独的变量中*/

    SPI_Handle masterSpi;
    SPI_Params spiParams;
    SPI_Transaction 事务;
    uint32_t i;
    bool transferOK;
    int32_t status;

    #define SPI_MSG_LENGTH (MAX_LENGTH + NUM_SUBSCED_BYIES - 1)
    #define MASTER_MSG ("123 567 ")
    int potatotrack=0;
    #define MAX_LOOP (1000)

    //unsigned char masterRxBuffer[packetLength ];
    //unsigned char masterTxBuffer[packetLength ];

    unsigned char masterRxBuffer[SPI_MSG_length];
    unsigned char masterTxBuffer[SPI_MSG_length];

    /*
    *应用 LED 引脚配置表:
    *-所有 LED 板 LED 均熄灭。
    *
    PIN_Config pinTable[]=

    BOARD_PIN_LED2 | PIN_GPIO_OUTP_EN | PIN_GPIO_LOW | PIN_PushPull | PIN_DRVSTR_MAX、
    PIN_TERMINATE
    };

    /***** 函数定义***** /

    void * mainThread (void * arg0)

    // SPI_Handle masterSpi;
    // SPI_Params spiParams;
    // SPI_Transaction 事务;
    // uint32_t i;
    // btransferool OK;
    // int32_t status;
    Potatotrack=1;


    rf_params rfParams;
    rf_params_init (&rfParams);

    Semaphore_construction (&rxSemaphore、0、NULL);
    rxSemaphoreHandle = semaphore_handle (&rxSemaphore);

    /*打开 LED 引脚*/
    ledPinHandle = PIN_OPEN (&ledPinState、pinTable);
    if (ledPinHandle ==空)

    while (1);

    if (RFQueue_defineQueue (&dataQueue、
    rxDataEntryBuffer、
    sizeof (rxDataEntryBuffer)、
    num_data_entries、
    max_length + NUM_apped_bytes))

    /*未能为所有数据条目分配空间*/
    while (1);

    /*根据应用需求修改 CMD_PROP_RX 命令*/
    /*为接收的数据设置数据实体队列*/
    RF_cmdPropRx.pQueue =&dataQueue;
    /*丢弃来自 Rx 队列的已忽略的数据包*/
    rf_cmdProprx.rxConf.bAutoFlushIgnored = 1;
    /*丢弃来自 Rx 队列的 CRC 错误数据包*/
    rf_cmdPropRx.rxConf.bAutoFlushCrcErr = 1;
    /*实施数据包长度过滤以避免 PROP_ERROR_RXBUF */
    RF_cmdPropRx.maxPktLen = MAX_LENGTH;
    rf_cmdPropRx.pktConf.bRepeatOk = 1;
    rf_cmdPropRx.pktConf.bRepeatNok = 1;

    /*请求对讲机的访问*/
    #IF 已定义(DeviceFamily_CC26X0R2)
    rfHandle = RF_OPEN (&rfObject、&RF_prop、(RF_RadioSetup*)&RF_cmdPropRadioSetup、&rfParams);
    其他
    rfHandle = RF_OPEN (&rfObject、&RF_prop、(RF_RadioSetup*)&RF_cmdPropRadioDivSetup、&rfParams);
    #endif// DeviceFamily_CC26X0R2

    /*设置频率*/
    rf_postCmd (rfHandle、(rf_Op*)&rf_cmdf、rf_PriorityNormal、NULL、0);

    /*进入 RX 模式并一直保持在 RX 中*/
    rf_postCmd (rfHandle、(rf_Op*)&rf_cmdPropRx、rf_PriorityNormal、&callback、rf_EventRxEntryDone);

    SPI_Params_init (&spiParams);
    Potattrack=6;
    spiParams.frameFormat = SPI_POL0_PHA1;
    Potattrack=7;
    spiParams.bitrate = 100000;
    Potattrack=8;
    masterSpi = SPI_open (Board_SPI_master、&spiParams);
    Potattrack=9;

    while (1)

    Semaphore_pend (rxSemaphoreHandle、BIOS_WAIT_FOREVE);
    PIN_setOutputValue (ledPinHandle、Board_PIN_LED2、!PIN_getOutputValue (Board_PIN_LED2));

    // memcpy (masterTxBuffer、packet、(packetLength + 1));
    Potattrack=14;
    memset ((void *) masterRxBuffer、0、SPI_MSG_LENGTH);
    Potattrack=15;
    transaction.count = packetLength;
    Potattrack=16;
    transaction.txBuf =(void *)数据包;
    Potattrack=17;
    transaction.rxBuf =(void *) masterRxBuffer;
    Potattrack=18;

    /*切换用户 LED、指示正在进行 SPI 传输*/
    GPIO_TOGGLE (Board_GPIO_LED1);
    Potattrack=19;
    /*执行 SPI 传输*/
    transferOK = SPI_transfer (masterSpi、事务);
    Potattrack=20;


    空回调(rf_handle h、rf_CmdHandle ch、rf_EventMask e)

    IF (e 和 RF_EventRxEntryDone)

    /*获取当前未处理的数据输入*/
    currentDataEntry = RFQueue_getDataEntry();

    /*处理位于&currentDataEntry->data 的数据包数据:
    *-长度是当前配置的第一个字节
    *-数据从第二个字节开始*/
    packetLength =*(uint8_t*)(&currentDataEntry ->数据);
    packetDataPointer =(uint8_t*)(&currentDataEntry->data+1);

    /*将有效载荷+状态字节复制到数据包变量*/
    memcpy (packet、packetDataPointer、(packetLength + 1));

    RFQueue_nextEntry();

    Semaphore_post (rxSemaphoreHandle);

    此致

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

    以下代码接收射频数据包并通过 SPI (仅有效载荷)进行传输:

    /***** Includes *****/
    /* Standard C Libraries */
    #include <stdlib.h>
    
    /* TI Drivers */
    #include <ti/drivers/rf/RF.h>
    #include <ti/drivers/PIN.h>
    #include <ti/drivers/SPI.h>
    #include <ti/drivers/spi/SPICC26X2DMA.h>
    
    #include <ti/sysbios/BIOS.h>
    #include <ti/sysbios/knl/Semaphore.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 RX Configuration */
    #define DATA_ENTRY_HEADER_SIZE 8  /* Constant header size of a Generic Data Entry */
    #define MAX_LENGTH             30 /* Max length byte the radio will accept */
    #define NUM_DATA_ENTRIES       2  /* NOTE: Only two data entries supported at the moment */
    #define NUM_APPENDED_BYTES     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) */
    
    static Semaphore_Struct rxSemaphore;
    static Semaphore_Handle rxSemaphoreHandle;
    
    /***** Prototypes *****/
    static void callback(RF_Handle h, RF_CmdHandle ch, RF_EventMask e);
    
    /***** 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 4 byte aligned (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,
                                                      MAX_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,
                                                      MAX_LENGTH,
                                                      NUM_APPENDED_BYTES)];
    #elif defined(__GNUC__)
    static uint8_t
    rxDataEntryBuffer[RF_QUEUE_DATA_ENTRY_BUFFER_SIZE(NUM_DATA_ENTRIES,
                                                      MAX_LENGTH,
                                                      NUM_APPENDED_BYTES)]
                                                      __attribute__((aligned(4)));
    #else
    #error This compiler is not supported.
    #endif
    
    /* 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;
    
    SPI_Handle      spiHandle;
    SPI_Transaction spiTransaction;
    
    static uint8_t spiPacket[MAX_LENGTH]; // Only transmit payload on SPI
    static uint8_t rfPacket[MAX_LENGTH + NUM_APPENDED_BYTES - 1]; /* The length byte is stored in a separate variable */
    
    /*
     * Application LED pin configuration table:
     *   - All LEDs board LEDs are off.
     */
    PIN_Config pinTable[] =
    {
        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);
    
        Semaphore_construct(&rxSemaphore, 0, NULL);
        rxSemaphoreHandle = Semaphore_handle(&rxSemaphore);
    
        /* Open LED pins */
        ledPinHandle = PIN_open(&ledPinState, pinTable);
        if (ledPinHandle == NULL)
        {
            while(1);
        }
    
        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);
        }
    
        SPI_Params      spiParams;
    
        SPI_init();
        SPI_Params_init(&spiParams);
        spiParams.frameFormat           = SPI_POL0_PHA0;
        spiParams.mode                  = SPI_MASTER;
        spiParams.transferMode          = SPI_MODE_BLOCKING;
        spiParams.bitRate               = 4000000;
    
        spiHandle = SPI_open(Board_SPI_MASTER, &spiParams);
    
        if (spiHandle == NULL)
        {
            while (1);
        }
    
        spiTransaction.txBuf = spiPacket;
    
        /* Modify CMD_PROP_RX command for application needs */
        /* Set the Data Entity queue for received data */
        RF_cmdPropRx.pQueue = &dataQueue;
        /* Discard ignored packets from Rx queue */
        RF_cmdPropRx.rxConf.bAutoFlushIgnored = 1;
        /* Discard packets with CRC error from Rx queue */
        RF_cmdPropRx.rxConf.bAutoFlushCrcErr = 1;
        /* Implement packet length filtering to avoid PROP_ERROR_RXBUF */
        RF_cmdPropRx.maxPktLen = MAX_LENGTH;
        RF_cmdPropRx.pktConf.bRepeatOk = 1;
        RF_cmdPropRx.pktConf.bRepeatNok = 1;
    
        /* Request access to the radio */
        rfHandle = RF_open(&rfObject, &RF_prop, (RF_RadioSetup*)&RF_cmdPropRadioDivSetup, &rfParams);
    
        /* Set the frequency */
        RF_postCmd(rfHandle, (RF_Op*)&RF_cmdFs, RF_PriorityNormal, NULL, 0);
    
        /* Enter RX mode and stay forever in RX */
        RF_postCmd(rfHandle, (RF_Op*)&RF_cmdPropRx, RF_PriorityNormal, &callback, RF_EventRxEntryDone);
    
       while(1)
       {
           Semaphore_pend(rxSemaphoreHandle, BIOS_WAIT_FOREVER);
           PIN_setOutputValue(ledPinHandle, Board_PIN_LED2, !PIN_getOutputValue(Board_PIN_LED2));
           memcpy(spiPacket, rfPacket, packetLength);
           spiTransaction.count = packetLength;
           SPI_transfer(spiHandle, &spiTransaction);
       }
    
    }
    
    void callback(RF_Handle h, RF_CmdHandle ch, RF_EventMask e)
    {
        if (e & RF_EventRxEntryDone)
        {
            /* 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 + the status byte to the packet variable */
            memcpy(rfPacket, packetDataPointer, (packetLength + 1));
    
            RFQueue_nextEntry();
    
            Semaphore_post(rxSemaphoreHandle);
        }
    }
    

    Siri