ESP 32 UWB Board to Measurment of data rate

Hi All,

I am trying to measure a data rate and throughput of a UWB based simple data transfer. I am using the ESP 32 UWB module, which is based on the DWM1000 UWB chip and programmed on using Arduino.

Can anyone support me with it.

Thak you,

You do realise that the DW1000 is not really designed for data transfer don’t you? It can do it but the performance isn’t going to be as good as other radio technologies.

Where are you having problems? Assuming you have some form of two way communication going the basic setup will be very simple: start a timer. Send a known amount of data, splitting it into multiple packets as needed. Stop the timer once you get an acknowledgment that the last of the data has all been received.

That is true, it is not intended for the use of data transmission but I am trying to run an experiment how much data does it transfer. I have a sample code of sender and reciever. I need some support how to modify the code.

Sender Code


  • Copyright (c) 2015 by Thomas Trojer
  • Decawave DW1000 library for arduino.
  • Licensed under the Apache License, Version 2.0 (the “License”);
  • you may not use this file except in compliance with the License.
  • You may obtain a copy of the License at
  • Unless required by applicable law or agreed to in writing, software
  • distributed under the License is distributed on an “AS IS” BASIS,
  • WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  • See the License for the specific language governing permissions and
  • limitations under the License.
  • @file BasicReceiver.ino
  • Use this to test simple sender/receiver functionality with two
  • DW1000. Complements the “BasicSender” example sketch.
  • @todo
    • move strings to flash (less RAM consumption)


#include <SPI.h>
#include <DW1000.h>

// connection pins
const uint8_t PIN_RST = 9; // reset pin
const uint8_t PIN_IRQ = 2; // irq pin
const uint8_t PIN_SS = SS; // spi select pin

// DEBUG packet sent status and count
volatile boolean received = false;
volatile boolean error = false;
volatile int16_t numReceived = 0; // todo check int type
String message;

void setup() {
// DEBUG monitoring
Serial.println(F(“### DW1000-arduino-receiver-test ###”));
// initialize the driver
DW1000.begin(PIN_IRQ, PIN_RST);;
Serial.println(F(“DW1000 initialized …”));
// general configuration
Serial.println(F(“Committed configuration …”));
// DEBUG chip info and registers pretty printed
char msg[128];
Serial.print("Device ID: "); Serial.println(msg);
Serial.print("Unique ID: "); Serial.println(msg);
Serial.print("Network ID & Device Address: "); Serial.println(msg);
Serial.print("Device mode: "); Serial.println(msg);
// attach callback for (successfully) received messages
// start reception

void handleReceived() {
// status change on reception success
received = true;

void handleError() {
error = true;

void receiver() {
// so we don’t need to restart the receiver manually

void loop() {
// enter on confirmation of ISR status change (successfully received)
if (received) {
// get data as string
Serial.print(“Received message … #”); Serial.println(numReceived);
Serial.print("Data is … "); Serial.println(message);
Serial.print("FP power is [dBm] … "); Serial.println(DW1000.getFirstPathPower());
Serial.print("RX power is [dBm] … "); Serial.println(DW1000.getReceivePower());
Serial.print("Signal quality is … "); Serial.println(DW1000.getReceiveQuality());
received = false;
if (error) {
Serial.println(“Error receiving a message”);
error = false;
Serial.print("Error data is … "); Serial.println(message);

What are you aiming for - a reliable point to point data link or a broadcast system where you send data out to anyone listening but don’t know/care if they miss bits?

Fire and forget broadcasts is easy, loop sending a data packet a number of times. Time how long it took.

If you want a reliable data link then things get more complicated. The first thing to do is make it so that the receiver sends an acknowledgment back. This doesn’t have to be long, a half dozen bytes indicating that you received a packet, the first couple of bytes of that packet, maybe how long it was.

The transmitter sends its data and then waits in receive mode until it either gets an acknowledgment or it times out. If it gets the acknowledgment it moves on to the next block of data to send, if it times out it sends the same data again.
Data rate measurement is again a case of looping around sending a fixed amount of data. The difference is you stop timing not when you send the last data but when you receive the last acknowledgment.

Your final data rate will depend on how many packets get lost in transit. At short ranges this should be almost zero but at longer ranges you can expect some losses.
This also means that packet size matters, smaller packets mean more transfers for a fixed amount of data. Each packet has it’s own header (which takes time to send) and it’s own pause waiting for the acknowledgment. But smaller will also be more reliable (a packet fails if a single bit is corrupted, more bits means more opportunities for corruption) and have a smaller penalty if a message is lost. It becomes a trade off between performance under perfect conditions and performance when things aren’t as reliable.