Dw1000 extended data issue

hi,
i am trying to utilise the extended data frame by sending 1000 bytes from one dw1000 to another one, but i only get 121 bytes in receiving side, my configuration in both ends are

static dwt_config_t config = {
5, /* Channel number. /
DWT_PRF_64M, /
Pulse repetition frequency. /
DWT_PLEN_1024, /
Preamble length. Used in TX only. /
DWT_PAC32, /
Preamble acquisition chunk size. Used in RX only. /
10, /
TX preamble code. Used in TX only. /
10, /
RX preamble code. Used in RX only. /
0, /
0 to use standard SFD, 1 to use non-standard SFD. /
DWT_BR_6M8, /
Data rate. /
DWT_PHRMODE_EXT, /
PHY header mode. /
(1025 + 64 - 32) /
SFD timeout (preamble length + 1 + SFD length - PAC size). Used in RX only. */
};

but it doesnt sent/receive the complete packet.
kindly help me to sort this out.

Regards
hmdra…

Hi,
The information does say that much , other then your RF config. ie. nothing about your extended frame configuration.

See section 3.4 Extended Length Data Frames in the User manual for what is involved for sending 1023 bytes of data.

Leo

Hi DecaLeo,
Thank you for your response…

the below buffer is the thing wich we are going to send…

uint8_t one_kb[2000] = {“Here the message which the decawave going to send.
Here the message which the decawave going to send.
Here the message which the decawave going to send.
Here the message which the decawave going to send.”};

the below code is for configuring the DW1000

/* Reset DW1000 */
reset_DW1000();

/* Set SPI clock to 2MHz */
port_set_dw1000_slowrate();

/* Init the DW1000 */
if (dwt_initialise(DWT_LOADUCODE) == DWT_ERROR)
{
//Init of DW1000 Failed
while (1) {};
}

// Set SPI to 8MHz clock
port_set_dw1000_fastrate();

/* Configure DW1000. */
dwt_configure(&config);

then finallly the i send the message here by using the below commands…

dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_TXFRS);
dwt_writetxdata(strlen(one_kb), one_kb, 0); /* Zero offset in TX buffer. /
dwt_writetxfctrl(strlen(one_kb), 0, 1); /
Zero offset in TX buffer, ranging. /
/
Start transmission, indicating that a response is expected so that reception is enabled automatically after the frame is sent and the delay

  • set by dwt_setrxaftertxdelay() has elapsed. */
    dwt_starttx(DWT_START_TX_IMMEDIATE);

but i got only 124 bytes in my receiving side…

in the receving side the configuration are the same, i enable the receive option by entering the below function.

/* Activate reception immediately. */
dwt_rxenable(DWT_START_RX_IMMEDIATE);

/* Poll for reception of a frame or error/timeout. See NOTE 5 below. */
while (!((status_reg = dwt_read32bitreg(SYS_STATUS_ID)) & (SYS_STATUS_RXFCG | SYS_STATUS_ALL_RX_TO | SYS_STATUS_ALL_RX_ERR)))
{};

if (status_reg & SYS_STATUS_RXFCG)
{
uint32 frame_len;

/* Clear good RX frame event in the DW1000 status register. */
dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_RXFCG);

/* A frame has been received, read it into the local buffer. */
frame_len = dwt_read32bitreg(RX_FINFO_ID) & RX_FINFO_RXFLEN_MASK;

if (frame_len <= RX_BUF_LEN)
{
  dwt_readrxdata(Receive_Buf, frame_len, 0);
 
}

is that clear to you, if not i ll send the programming file for your reference…

Thanks and regards
hmdra

Hi ,
No point sending us your code. We’re not in a position to review programs designed by customers.
Instead we have made a huge effort to have required information in teh user manual, datat sheet and various application notes.
So, Please read the user manual on extended frame handling which tells you what register to set like TX Frame control, RX Frame Control and more. This all is described in section 3.4 in the UM as previously mentioned.
Leo

Did you figure it out? I have the same problem and same settings.

I don’t know if you found a solution to this, but I had a similar issue that might be related.

I found I could only receive about 172 bytes of data, despite sending nearer 450.

I found the solution was to break up writing to and reading from the TX and RX buffers - reading too many bytes from the RX buffer in one operation in mine caused most of the message to read as zeros, and similarly writing too many bytes to the TX buffer resulted in nothing after the 170th byte to be written.

So on the TX end, I did

int section_size = 50;
int whole_sections = (sizeof(resp_message) - 2) / section_size;
int last_section_size = (sizeof(resp_message) - 2) % section_size;
for (int i = 0; i < whole_sections; i++)
{
  dwt_writetxdata(section_size + 2, &resp_message[i * section_size], i * section_size);
}
dwt_writetxdata(last_section_size + 2, &resp_message[whole_sections * section_size], whole_sections * section_size);

and similarly for the RX:

int section_size = 50;
int whole_sections = frame_len / section_size;
int last_section = frame_len % 40;
for (int i = 0; i < whole_sections; i++)
{
  dwt_readrxdata(&rx_buffer[i * section_size], section_size, i * section_size);
}
dwt_readrxdata(&rx_buffer[whole_sections * section_size], last_section, whole_sections * section_size);

This is similar to another issue I’ve found with the DWM1001, where reading from the accumulator also needed to be split up into smaller reads. If this is expected behaviour, I think it probably ought to be mentioned in the documentation.