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-CC1352P: 利用rfEchoTx和rfEchoRx的接收信号强度的条件更改一个输出端口的值?

Part Number: LAUNCHXL-CC1352P
Other Parts Discussed in Thread: CC1352P

rfEchoTx和rfEchoRx的分别会有一个接收信号强度,我用这个接收信号强度为条件,控制一个IO口的输出值作为射频开关的切换条件,当接收信号强度降低一定阈值后,缩短发送时间,并变换IO值,一共进行四次,选择四次中接收信号强度最高的那次IO输出值作为继续正常发送状态的开关值,我对rfEchoTx代码进行了以下改动:

#define PACKET_INTERVAL_CHANGE     (uint32_t)(4000000*0.5f)
定义了缩短发送时间的时间间隔0.5s;

     /* Get current time */
    curtime = RF_getCurrentTime();
 
 int state = 0;//If the state is 1, normal communication is corrected, and the state switch is 0.With an initial value of 0, initialization begins
 float LastRssi = -300;//Record the last received signal strength, the initial value is a small value
 int maxAnt = 0;//天线端口选择信号,0_ant00,1_ant01,2_ant10,3_ant11
定义state表示当前是正常发送时间间隔还是缩短发送时间间隔,LastRssi记录上一次接收到的接收信号强度;

    while(1)
    {
        /* Create packet with incrementing sequence number and random payload */

        if(state){
            txPacket[0] = (uint8_t)(seqNumber >> 8);
                    txPacket[1] = (uint8_t)(seqNumber++);
                    uint8_t i;
                    for (i = 2; i < PAYLOAD_LENGTH; i++)
                    {
                        txPacket[i] = rand();
                    }
        /* Set absolute TX time to utilize automatic power management */
        curtime += PACKET_INTERVAL;
        RF_cmdPropTx.startTime = curtime;

        //GPIO_toggle(CONFIG_GPIO_0);
        //uint8_t ant = GPIO_read(CONFIG_GPIO_0);

        /* Transmit a packet and wait for its echo.
         * - When the first of the two chained commands (TX) completes, the
         * RF_EventCmdDone event is raised but not RF_EventLastCmdDone
         * - The RF_EventLastCmdDone in addition to the RF_EventCmdDone events
         * are raised when the second, and therefore last, command (RX) in the
         * chain completes
         * -- If the RF core successfully receives the echo it will also raise
         * the RF_EventRxEntryDone event
         * -- If the RF core times out while waiting for the echo it does not
         * raise the RF_EventRxEntryDone event
         */
        RF_EventMask terminationReason =
                RF_runCmd(rfHandle, (RF_Op*)&RF_cmdPropTx, RF_PriorityNormal,
                          echoCallback, (RF_EventCmdDone | RF_EventRxEntryDone |
                          RF_EventLastCmdDone));

            if(rxStatistics.lastRssi < LastRssi -30 ){
                state = 0;
                LastRssi = rxStatistics.lastRssi;
            }
            else{
                state = 1;
                LastRssi = rxStatistics.lastRssi;
            }
        }
        else{
            int currAnt = 0;//Current antenna status(0_ant00,1_ant01,2_ant10,3_ant11)
            float currRssi;
            float maxRssi;

            txPacket[0] = (uint8_t)(seqNumber >> 8);
            txPacket[1] = (uint8_t)(seqNumber++);
            uint8_t a;
                     for (a = 2; a < PAYLOAD_LENGTH; a++)
                     {
                         txPacket[a] = 0;
                     }

                    GPIO_write(CONFIG_GPIO_0,0);

                    curtime += PACKET_INTERVAL_CHANGE;
                    RF_cmdPropTx.startTime = curtime;

                    RF_runCmd(rfHandle, (RF_Op*)&RF_cmdPropRx, RF_PriorityNormal,
                        echoCallback, (RF_EventRxEntryDone |
                        RF_EventLastCmdDone));

                    currRssi = rxStatistics.lastRssi;
                    maxRssi = currRssi;
                    maxAnt = currAnt;
                    currAnt++;

            txPacket[0] = (uint8_t)(seqNumber >> 8);
            txPacket[1] = (uint8_t)(seqNumber++);
            uint8_t b;
                    for (b = 2; b < PAYLOAD_LENGTH; b++)
                    {
                        txPacket[b] = 3;
                    }



                    curtime += PACKET_INTERVAL_CHANGE;
                    RF_cmdPropTx.startTime = curtime;

                    RF_runCmd(rfHandle, (RF_Op*)&RF_cmdPropRx, RF_PriorityNormal,
                        echoCallback, (RF_EventRxEntryDone |
                        RF_EventLastCmdDone));

                    currRssi = rxStatistics.lastRssi;
                    if(currRssi>maxRssi){
                        maxRssi = currRssi;
                        maxAnt = currAnt;
                    }
                    currAnt++;

            txPacket[0] = (uint8_t)(seqNumber >> 8);
            txPacket[1] = (uint8_t)(seqNumber++);
            uint8_t c;
                      for (c = 2; c < PAYLOAD_LENGTH; c++)
                         {
                            txPacket[c] = 2;
                         }

                    GPIO_write(CONFIG_GPIO_0,0);

                    curtime += PACKET_INTERVAL_CHANGE;
                    RF_cmdPropTx.startTime = curtime;

                    RF_runCmd(rfHandle, (RF_Op*)&RF_cmdPropRx, RF_PriorityNormal,
                        echoCallback, (RF_EventRxEntryDone |
                        RF_EventLastCmdDone));

                    currRssi = rxStatistics.lastRssi;
                    if(currRssi>maxRssi){
                        maxRssi = currRssi;
                        maxAnt = currAnt;
                    }
                    currAnt++;

           txPacket[0] = (uint8_t)(seqNumber >> 8);
           txPacket[1] = (uint8_t)(seqNumber++);
           uint8_t d;
                    for (d = 2; d < PAYLOAD_LENGTH; d++)
                    {
                     txPacket[d] = 3;
                    }

                    GPIO_write(CONFIG_GPIO_0,1);

                    curtime += PACKET_INTERVAL_CHANGE;
                    RF_cmdPropTx.startTime = curtime;

                    RF_runCmd(rfHandle, (RF_Op*)&RF_cmdPropRx, RF_PriorityNormal,
                        echoCallback, (RF_EventRxEntryDone |
                        RF_EventLastCmdDone));

                    currRssi = rxStatistics.lastRssi;
                    if(currRssi>maxRssi){
                        maxRssi = currRssi;
                        maxAnt = currAnt;
                    }

            state = 1;
            if(maxAnt < 2){
                GPIO_write(CONFIG_GPIO_0,0);//Set the antenna optimally
            }
            else{
                GPIO_write(CONFIG_GPIO_0,1);
            }
        }
然后在进行发送时,初始state变量为0,进入到缩短时间间隔的发送状态,然后进行四次发送,完成后state置为1,下次进入到正常时间间隔的发送状态;

我的问题,当我开始发送时,进入到缩短时间间隔的发送状态后,无法接收到由RX端回传回来的数据,TX板子的红灯常亮,直到四次发送完成退出缩短发生时间间隔后的状态,接收回传信号就正常了,请问会是什么问题呢?

  • 您好,您的问题我正在查看,请提供一下sdk的版本以及您这边使用的demo,我对照一下例程,为您查看一下,谢谢。

  • sdk版本:simplelink_cc13xx_cc26xx_sdk_7_10_00_98

    dome:nortos下的cc1352p的rfEchoTx和rfEchoRx两个dome

  • ok

    您这边用的两个开发板都是ti官方的吧?

  • 好的,我这边对照着你发的代码,这需要一些时间,谢谢、。

  • 您好,可以进行以下测试,定位问题:

    1.取消state标志位变量,直接进行缩短时间的发送事件测试,然后查看接收端状态,看是否正常数据回传,另外我这边查看代码您这边写了四个发送,您试着改为一个,进行单独测试修改时间后的代码,以下是修改时间的变量。

    “/* Set packet interval to 1000ms */
    #define PACKET_INTERVAL (uint32_t)(4000000*1.0f)”,

    查看接收回传状态。

    2.取消state标志位变量,增加为两个发送,然后查看接收回传状态,看是什么情况。

    经过以上两个操作基本可以定位问题,

    我认为是接收这块的问题“RF_runCmd(rfHandle, (RF_Op*)&RF_cmdPropTx, RF_PriorityNormal,
    echoCallback, (RF_EventCmdDone | RF_EventRxEntryDone |
    RF_EventLastCmdDone));”,您这边先测试。

  • 另外我想问一下 您这边state标志位为0状态时的代码,是不是只有一个

    RF_runCmd(rfHandle, (RF_Op*)&RF_cmdPropTx, RF_PriorityNormal,
    echoCallback, (RF_EventCmdDone | RF_EventRxEntryDone |
    RF_EventLastCmdDone))

    您这边可以尝试 像state=1的时候 再添加一个RF_runCmd(rfHandle, (RF_Op*)&RF_cmdPropTx, RF_PriorityNormal,
    echoCallback, (RF_EventCmdDone | RF_EventRxEntryDone |
    RF_EventLastCmdDone))

    绝对会出现问题,我认为问题大概率是您的接收回传出现错误了

  • 在这个逻辑里,是先发送30个包然后会有接收回传数据功能。是一个信号链。

    如果您这边30发完了,就需要在callback里面去写逻辑标志位,去选择发送数据包。

  • 我先学习一下,然后再跟您交流

  • 好的,有问题随时交流。

  • 我的调试:

    ①取消state,缩短发送时间,在一个循环中,只发送一次数据,执行一次RF_runCmd,可以正常通信;

    ②取消state,在一次循环中,发送两次数据,第一次以正常时间间隔发生,第二为缩短后的时间间隔发送,可以正常通信;

    ③使用state,在if(state==1)时正常时间间隔执行一次RF_runCmd,else时发送缩短时间执行一次RF_runCmd,结果为state为0时无法收到回传信号

    而交换条件,if(state==1)发送缩短时间执行一次RF_runCmd,else时正常时间间隔执行一次RF_runCmd,结果为state为0时无法收到回传信号

    因此,只要是进入else语句,就无法接收回传信号,与发送间隔无关。

    请问还有什么调试的方式找到问题吗?

  • ③使用state,在if(state==1)时正常时间间隔执行一次RF_runCmd,else时发送缩短时间执行一次RF_runCmd,结果为state为0时无法收到回传信号

    而交换条件,if(state==1)发送缩短时间执行一次RF_runCmd,else时正常时间间隔执行一次RF_runCmd,结果为state为0时无法收到回传信号

    从这里可以看出,你的stat标志位变量定义出现问题,

    在这个逻辑里,是先发送30个包然后会有接收回传数据功能。是一个信号链。

    如果您这边30发完了,就需要在callback里面去写逻辑标志位,去选择发送数据包。

    建议您这边在进行callback中来写逻辑判断,当完成一次callback时,再去更新state标志位变量,因为代码示例中提到 发送与回传接收是同一个信号链上的,

    当30个包发送完之后再去进行callback接收数据,所以如果30个 没有发送完毕 去调用其他事件,肯定会出错。

  • 建议您这边仔细参考例程以及api函数说明,您的代码逻辑方面有问题,demo中的用法与您这边的理解不太可以对接的上。谢谢我在下面放了链接以及api函数说明希望可以帮助到您:

    https://dev.ti.com/tirex/content/simplelink_academy_cc13xx_cc26xxsdk_6_40_00_00/modules/prop_rf/prop_01_basic/prop_01_basic.html

    dev.ti.com/.../index-cc13xx_cc26xx.html

  • 您好,我做了新的调试

    int state = 0;
    
     while(1)
        {
            if(state){
                txPacket[0] = (uint8_t)(seqNumber >> 8);
                        txPacket[1] = (uint8_t)(seqNumber++);
                        uint8_t i;
                        for (i = 2; i < PAYLOAD_LENGTH; i++)
                        {
                            txPacket[i] = rand();
                        }
    
            curtime += PACKET_INTERVAL;
            RF_cmdPropTx.startTime = curtime;
    
            RF_EventMask terminationReason =
                    RF_runCmd(rfHandle, (RF_Op*)&RF_cmdPropTx, RF_PriorityNormal,
                              echoCallback, (RF_EventCmdDone | RF_EventRxEntryDone |
                              RF_EventLastCmdDone));
            state = 0;
            }
            
            else{
    
                txPacket[0] = (uint8_t)(seqNumber >> 8);
                txPacket[1] = (uint8_t)(seqNumber++);
                uint8_t a;
                         for (a = 2; a < PAYLOAD_LENGTH; a++)
                         {
                             txPacket[a] = 0;
                         }
    
                        //GPIO_write(CONFIG_GPIO_0,0);
    
                        curtime += PACKET_INTERVAL_CHANGE;
                        RF_cmdPropTx.startTime = curtime;
    
                        RF_runCmd(rfHandle, (RF_Op*)&RF_cmdPropRx, RF_PriorityNormal,
                            echoCallback, (RF_EventRxEntryDone |
                            RF_EventLastCmdDone));
                state = 1;
            }

    结果是,代码首先state=0进入了else中,此时无法接收到回传数据,等到一定时间后,进入到了state=1的状态,能够正常发送和接收,但后续的state=0确并不会执行,为什么会这样呢?

  • 建议您这边在进行callback中来写逻辑判断,当完成一次callback时,再去更新state标志位变量,因为代码示例中提到 发送与回传接收是同一个信号链上的,

    当30个包发送完之后再去进行callback接收数据,所以如果30个 没有发送完毕 去调用其他事件,肯定会出错。

    您好,我们不提供代码编写技术支持,我们只会为您提供思路。

  • 您可以把state定义为全局变量,然后在callback函数中去修改state状态,在您以上书写的发送函数中单独写一个state标志位的判断,然后确定收发状态。