[参考译文] CC1312R：特定数据包在从发件人传输后收到或丢弃的通知

玛丽·H：

  是的。  我的数据包的传输和接收必须同步，但只能同步数据内容。  我不在乎序言和同步词。 假设我有16个数据包。  每个数据包都是在固定的时间从发送器发送的。  在接收端，我有16个插槽可以接收所有数据包。  我需要知道，只有在接收端，哪些数据包是在固定时间内发送但未收到的，因此我可以将收到的数据包放在正确的插槽中，并将与丢失数据包对应的插槽留空。  TI 15.4堆栈的 ACK 数据包用于传输端还是接收端？  我不在乎发送器丢弃数据包，但接收方需要知道，因为它是一个持续传输的数据包流。

您能告诉我一些使用示例或文档吗？

像往常一样，谢谢你。

繁体中文

奇怪的是：这里的用例是什么？  

好奇 II：听起来您需要知道数据包收发的时间段。 在 TX 端，您可以添加序列号(或时间信息)，RX 将知道上次接收的数据包是否为序列号12，而接收到的数据包是否为编号14，表示数据包丢失。 RX 端也可以使用类似的方法。 如果 lat 数据包是在时间插槽4时收到的，并且您知道数据包之间的时间为50毫秒，并且在100毫秒后收到下一个数据包，那么您就知道这是在插槽6中。 这样做会奏效吗？  

通常，套件用作重新发送数据包的通知(未收到任何套件，请重新发送)。 从这个问题看来，这似乎不是一个选项？   

之三：

     我们对时间和速率有非常严格的要求。  因此，数据包的处理时间短得像我们可以处理的那样，每个插槽的频率不同。  为序列号添加额外字节不是一个选项。  因此，我的设计是向发送方和接收方提供同步信号(基于全球同步的 FPGA)，这样当发送短数据包时，接收方就会期望在该时间帧内收到信号， 因此，我们只能用收到的数据包填充正确的插槽，而更高级别的实用程序可以处理 FEC/重新传输。

    使用 RF_runCmd 启动接收器时，数据包的 rxCallback 就在同步信号的后面，因此它不有用。  我已经查看了所有的 rxCallback 事件，找不到任何可以使用的东西。  我想我可能需要降低到 SWI 级别，在该级别上对讲机检测到功率并开始接收，以与传输时间范围协调？

    有什么建议？

繁体中文

不确定您当前的方法是否有效。 即使您使用的 CC1200具有基于硬件的状态机，它提供了一个非常确定的接收链(无 SW 延迟)，接收也会由于调制解调器的延迟而延迟一些字节。 这意味着，如果您将 Rx 插槽设置为等于 TX 插槽，您将错过 Rx 数据包。 CC1312R 是一款基于软件的无线电，这意味着定时不是完全确定性的。 如果您尝试修改驱动程序，这将不会有帮助。 回叫基本上是 swi 处理。  

您是否能够根据 Rx 中可能附加的时隙对数据包进行排序？   

rf_cmdProprx.rxConf.bAppendTimestamp = 1； 

 请访问 dev.ti.com/.../time-synchronization.html

之三：

 如果我将 RF_cmdPropsx.rxConf.bAppendTimestamp 设置为1，那么每个数据包的 rxCallback 是否有与该时间戳关联的时间戳？ 如果时间戳与一百微秒内的接收相对应，则可能起作用。  我查看了该页面，但我不清楚在哪里查找时间戳。

繁体中文

之三：

  我在一些文档中找到了它：  RF_cmdPropx.rxConf.bAppendTimestamp = true；/*将 RX 时间戳附加到数据包有效负载*/

如果时间戳粒度以百微秒为单位，它将用于我的目的。

谢谢，

繁体中文

我建议您测试 https://dev.ti.com/tirex/explore/node?node=AKAX6KSybstfuDpGhvdR5w__BSEc4rl__LATEST 示例并检查分辨率/准确性。 我头上没有数字。  

之三：

  我相信时间戳是基于绝对开始时间的刻度。  我还找到了一个用于将刻度转换为微秒的实用程序：

RF_ConvertRatTicksToU。  我会快速尝试并告诉你。

谢谢，

繁体中文

以下是 https://software-dl.ti.com/simplelink/esd/simplelink_cc13x2_26x2_sdk/4.20.00.35/exports/docs/proprietary-rf/proprietary-rf-users-guide/proprietary-rf/time-synchronization.html

接收此数据包时，接收器必须从数据包有效负载读取时间戳，但还必须配置 RF 核心以向每个接收的数据包附加时间戳。 这是 RF 核心发出信号“找到同步”的时候，我们选择了名称 rxTimestamp：

//从 SmartRF Studio
 RFC_CMD_PROP_RX_t rxCommand 导出；

//将 RX 时间戳附加到有效负载
 RF_cmdPropx.rxConf.bAppendTimestamp =1；

//
此处未显示执行 RX 命令和设置 RX 数据队列的代码。 

//从
// RX 数据队列读取数据包内容时，rxTimestamp 在有效负载的后面：
RFC_dataEntryGeneral _t* currentDataEntry = RFQueue_getDataEntry ()；
//假设可变长度
 uint8_packetLength =*(uint8_currt*)(&DataEntry->DataInt->DataInt_Inte*->DataInte*8
；Timet_Inte*+_Inte*8) 

> memcpy (&rxTimestamp，&packetDataPointer + packetLength，4)；

//有效载荷
 UINT32_t txTimestamp 中有 TX 时间戳；
--> > memcpy (&rxTimestamp，packetDataPointer + packetLength，4)； 


上面的两行看起来不对。 我无法使用 Timtxestamp。 是 RX 
为接收前导码的时间安排时间？ 开始时间是多少 
RX 时间戳是指什么？ 

以下片段来自我的代码：

UINT32_t rxTime；

定义最大长度30 /*对讲机将接受的最大长度字节*/
#define NUM_apped_bytes 5 /*数据项数据字段将包含：
页眉中有* 1个地址字节
*最多30个有效负载字节
* 4时间戳字节*/

packetDataPointer =(uint8_t*)(&currentDataEntry ->数据)；
memcpy (rxBuf，packetDataPointer，payload_length)；      /*固定长度，因此没有长度字节*/
memcpy (&rxTime，packetDataPointer + payload_length，4)；

打印 rxTime 后，我希望看到接收开始后的嘀嗒声数。  但我只看到了

不一致的数据，例如：

0x0000000c
0x00000001
0x00000099
0x00000004
0x00000000
0x00000000

我没有做什么或出了什么问题？

繁体中文

您是否设置了：RF_cmdPropsx.rxConf.bAppendTimestamp =1；

是的，我做到了。   

此外，附加的时间戳与什么相关？  RF_cmdPropRx 的开始时间设置为0。

时间戳增量是否从0开始？  时间戳值是否会环绕？

我正在附加用于接收和读取时间戳的源代码。

如果您发现问题，请告诉我。  谢谢。

 /*
 * Copyright (c) 2019, Texas Instruments Incorporated
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * *  Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * *  Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * *  Neither the name of Texas Instruments Incorporated nor the names of
 *    its contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/***** Includes *****/
/* Standard C Libraries */
#include <stdlib.h>
#include <unistd.h>
#include <semaphore.h>
#include <ti/sysbios/knl/Semaphore.h>
#include <ti/sysbios/knl/Mailbox.h>
#include <ti/sysbios/BIOS.h>

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

/* Driverlib Header files */
#include DeviceFamily_constructPath(driverlib/rf_prop_mailbox.h)
#include <ti/drivers/GPIO.h>
#include <ti/drivers/UART2.h>


/* Board Header files */
#include "ti_drivers_config.h"
#include "RFQueue.h"
#include <ti_radio_config.h>

/***** Defines *****/

/* Packet RX Configuration */
#define DATA_ENTRY_HEADER_SIZE 8  /* Constant header size of a Generic Data Entry */
#define NUM_DATA_ENTRIES       32  /* NOTE: Only two data entries supported at the moment */
#define MAX_LENGTH             30 /* Max length byte the radio will accept */
#define NUM_APPENDED_BYTES     4  /* The Data Entries data field will contain:
				   * 1 address byte in the header
                                   * Max 30 payload bytes
                                   * 4 timestamp bytes */


/* Do power measurement */
//#define POWER_MEASUREMENT

/* Packet TX Configuration */
#define WRITE_SIZE	96	
#define NUM_HOPS	16
#define PAYLOAD_LENGTH     (WRITE_SIZE/NUM_HOPS) 
#ifdef POWER_MEASUREMENT
#define PACKET_INTERVAL     0  /* For power measurement set packet interval to 5s */
#else
#define PACKET_INTERVAL     0  /* Set packet interval to 500000us or 500ms */
#endif

/* semaphore object definitions */
sem_t hop_sem;
static hop_state = 0;
static hop_count = 0;

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


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


extern const Mailbox_Handle UART_mailbox;

/* 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 */
static uint8_t frame[128];
static uint16_t seqNumber;
static int tx_ready;

UART2_Handle uart;
static int packet_rx;
static char buffer[128];
static int numb = 0;


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

void *write_uart(void *arg0)
{
static int cnt = 0;
static c = 0;

    while(1)
    {

       	Semaphore_pend(&hop_sem, BIOS_WAIT_FOREVER);
        UART2_write(uart, frame, WRITE_SIZE, NULL);
	memset(frame, 'X', WRITE_SIZE);
	memset(frame, 0, WRITE_SIZE);
	if (++cnt == 1000)
	{
		cnt = 0;
        	PIN_setOutputValue(ledPinHandle, CONFIG_PIN_RLED,
                           !PIN_getOutputValue(CONFIG_PIN_RLED));
	}
    }
}



char pbuf[128];
void rxCallback(RF_Handle h, RF_CmdHandle ch, RF_EventMask e)
{
uint8_t timestamp[4];
uint32_t tstamp;

    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 */
	/* Configuring fixed length data, the length field no longer exists */
        packetDataPointer = (uint8_t*)(&currentDataEntry->data);

	//Mailbox_post(UART_mailbox, packetDataPointer, BIOS_NO_WAIT);
	/* Do not copy data */
	//memcpy(&frame[hop_count * PAYLOAD_LENGTH], packetDataPointer, PAYLOAD_LENGTH);
	/* Copy the timestamp, instead and send it to RPi for analysis */
	memcpy(&frame[hop_count * PAYLOAD_LENGTH, packetDataPointer + 6, 4);
	
        RFQueue_nextEntry();
    }
    /* If error or no-receive events, still advance the hop_count */
    if (++hop_count >= NUM_HOPS) /* Full frame, notify to write to uart */
    {
	hop_count = 0;
    	sem_post(&hop_sem);
    }
}



void hop_signal(uint_least8_t index)
{
static int cnt = 0;

        if (++cnt == 5000)
        {
                cnt = 0;
                PIN_setOutputValue(ledPinHandle, CONFIG_PIN_GLED,
                           !PIN_getOutputValue(CONFIG_PIN_GLED));
        }

}

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

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


    sem_init(&hop_sem, 0, 0);

    /* UART initialization */
    UART2_Params uartParams;

    /* Call driver init functions */
    GPIO_init();
    GPIO_setConfig(CONFIG_GPIO_0, GPIO_CFG_IN_PU | GPIO_CFG_IN_INT_FALLING);
    GPIO_setConfig(CONFIG_GPIO_1, GPIO_CFG_IN_PU | GPIO_CFG_IN_INT_FALLING);
    GPIO_setCallback(CONFIG_GPIO_1, hop_signal);
    GPIO_enableInt(CONFIG_GPIO_1);


    /* Create a UART with data processing off. */
    UART2_Params_init(&uartParams);
    //uartParams.baudRate = 230400;
    //uartParams.baudRate = 460800;
    uartParams.baudRate = 921600;
    //uartParams.baudRate = 1000000;

    uart = UART2_open(CONFIG_UART2_0, &uartParams);


    if (uart == NULL) {
        /* UART2_open() failed */
        while (1);
    }

    //UART_control(uart, UARTCC26XX_CMD_RX_FIFO_FLUSH, NULL);

    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.maxPktLen = PAYLOAD_LENGTH;
    RF_cmdPropRx.pktConf.bRepeatOk = 1;
    RF_cmdPropRx.pktConf.bRepeatNok = 1;
    RF_cmdPropRx.pktConf.bUseCrc = 0;
    RF_cmdPropRx.pktConf.bVarLen = 0x0;
    RF_cmdPropRx.rxConf.bAppendTimestamp = 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_PriorityHighest, NULL, 0);


    memset(frame, 'X', WRITE_SIZE);
    memset(frame, 0, WRITE_SIZE);
    /* Enter RX mode and stay forever in RX */
    RF_EventMask terminationReason = RF_runCmd(rfHandle, (RF_Op*)&RF_cmdPropRx,
                                               RF_PriorityNormal, &rxCallback,
                                               RF_EventRxEntryDone | RF_EventRxEmpty | RF_EventRxBufFull | RF_EventRxAborted);
}

之三：

  当数据包丢失后，我发现了我对时间戳的解释中的一个错误

到 RPi 上的接收应用程序。  修复后，我将获得更好的时间戳数据。

我将做更多的测试，看看此功能是否能解决我的问题。

一如既往地感谢您的帮助。

繁体中文

您好，Ter：

  我正在读取数据包后的4字节时间戳。  但是，时间戳值似乎会发生变化

一段时间后向右8位。  下面是一些示例输出：

时间戳对应于我传输的数据包的计时。  但是，之后

几百个值

0x0851f522
0x0851fab1.
0x08520044
0x085205d3
0x08520b97

突然，该值向右偏移8位

0x0008522d
0x00085216
0x0008521c
0x00085221
0x00085227

0x000854 ff
0x00085505

这种情况会一再发生。

0x00000855
0x00000855

我配置了6字节的固定长度数据包。  每次读取数据包数据后，  

我读取时间戳的后4个字节。  前几百个值始终正确。

然后，时间戳开始以不同的时间间隔移动。