UWB Indoor Positioning System With ESP32 and Qorvo DWM3000

Okay, quick version: We've built a GPS tracker using ESP32 before, but GPS sucks indoors and UWB does not. I built a real-time indoor tracker using an ESP32 and Qorvo DWM3000 modules. You get centimeter-level-ish accuracy by measuring time of flight between a moving tag and fixed anchors. This writeup has the wiring, the firmware setup, the ranging math, the JSON format I used to stream data, and the Python visualization. Copy paste and go.

How it actually works (short and honest)

1. DWM3000 sends and listens to very short radio pulses and gives you timestamps.
2. We use Double-Sided Two-Way Ranging, or DS-TWR, to cancel clock offsets. That gives distances between tag and anchors.
3. With distances to three anchors you do trilateration and get an (x, y) fix. With a fourth anchor you can go 3D.
4. Tag runs on an ESP32, does the DS-TWR math, then sends distances or raw timing over Wi-Fi or serial to a computer. The computer runs Python to compute final position and plot it.

1. 4 × ESP32 dev boards (any common WROOM style)
2. 4 × Qorvo DWM3000 UWB modules
3. Breadboard, jumper wires, USB cables
4. PC or laptop for visualization
5. Python with these libs: pyserial, numpy, matplotlib, optionally scipy if you want least squares solver
6. Optional but useful: 3D printed mounts, tripods, stable USB power banks

1. Built on Qorvo DW3110, supports IEEE 802.15.4z and FiRa PHY/MAC.
2. Comes with an onboard UWB antenna, crystal oscillator, power management. No RF design required.
3. Channels: it supports Channel 5 (6.5 GHz) and Channel 9 (8 GHz). I used Channel 5.
4. Data rate: up to 6.8 Mbps which lets measurements run faster.
5. Range: open field up to ~200 m. Indoors expect 50 to 100 m useful range with typical accuracy near 10 cm depending on environment.
6. You must calibrate antenna delay or you will be off by a few cm. Typical TX antenna delay I used: 16350 ticks.

Hook each DWM3000 to an ESP32 over SPI. Same wiring for tag and anchors. Keep wires short.

1. ESP32 3V3 -> DWM3000 VIN
2. ESP32 GND -> DWM3000 GND
3. ESP32 GPIO18 -> DWM3000 SCK
4. ESP32 GPIO19 -> DWM3000 MISO
5. ESP32 GPIO23 -> DWM3000 MOSI
6. ESP32 GPIO5 -> DWM3000 CS
7. ESP32 GPIO27 -> DWM3000 IRQ
8. ESP32 GPIO22 -> DWM3000 RST

Label your boards as Anchor 1, Anchor 2, Anchor 3, Tag. Put anchors at similar heights and point the antenna roughly the same way.

1. Important: DWM3000 runs on 3.3 V. Do not feed it 5 V.

1. Arduino IDE with ESP32 board support installed.
2. Qorvo DWM3000 Arduino library (get it from Qorvo GitHub or the library manager).
3. Example sketches exist for tag and anchor. Use them as a base. I modified them to:
4. assign unique ANCHOR_ID values to anchors (for example 1, 2, 3)
5. set the tag ID and antenna delay values
6. send JSON over TCP or serial with measured distances and some raw info for debugging

Example of the JSON I used from the tag after each ranging cycle:

I find JSON easy to parse in Python and it is readable for debugging.

1. Initialize serial for debug.
2. initializeAnchors() with coordinates or IDs.
3. connectToWiFi() if you want Wi-Fi streaming.
4. DWM3000.begin(), hardReset(), check SPI, wait for IDLE, softReset, DWM3000.init().
5. Configure GPIOs and set antenna delay: DWM3000.setTXAntennaDelay(16350) (store and tweak if you calibrate).
6. DWM3000.setSenderID(TAG_ID) and configure as TX mode then clear system status.

If DWM3000.checkSPI() fails, stop and debug wiring.

DS-TWR is a three exchange trick so clocks do not mess you up:

1. Tag sends Poll at T1.
2. Anchor receives Poll at T2, then sends Response at T3.
3. Tag receives Response at T4 and sends Final with its timestamps. Anchor has its timestamps too.
4. Using T1..T6 (tag and anchor timestamps) you compute time of flight while canceling the unknown clock offset.

You do two round trips, combine them, and compute Time of Flight (ToF). Convert ToF ticks to seconds using the DWM3000 tick period and multiply by speed of light to get distance.

Why double-sided: single round trip will error if clocks run at slightly different speeds. Double-sided cancels most of that.

1. DWM3000 has internal TX and RX path delays. If you skip calibration you are off by a few centimeters.
2. Set antenna delay using setTXAntennaDelay and setRXAntennaDelay if available, and save it in firmware. I used TX delay 16350 as a starting point.
3. Calibration procedure: place tag and anchor at a known distance, measure ToF, adjust antenna delay until reported distance matches the known distance. Repeat for each unit.

1. UWB is resistant to multipath, but not magic. Poor anchor geometry and nearby metal cause problems.
2. Use median filtering or simple averaging on distance samples before trilateration.
3. Monitor RSSI and first path power to detect potential NLOS cases. If RSSI drops or first-path is weak, ignore or flag that sample.
4. Keep anchors away from metal racks and pipes if possible.

You get distances d1, d2, d3 to anchors at known positions (x1,y1), (x2,y2), (x3,y3).

Ideal math: solve circle intersection. In practice circles almost never intersect exactly because of noise. Use least squares to find best fit.

I used SciPy least_squares on the residuals function that computes differences between measured distances and distances from guessed (x,y). That gives stable results. If you do not want SciPy, you can implement a small iterative solver or do algebraic solution with matrix ops but least squares is easiest.

Install:

Flow:

1. Python listens on serial or TCP.
2. Parse incoming JSON with distances and anchor IDs.
3. Convert distances into meters.
4. Run least_squares to get x,y.
5. Real-time plot with matplotlib showing anchors as fixed points and tag as a moving dot. I also display RSSI over anchors for debugging.

If you want smooth movement, add a Kalman filter on the computed positions. That helps a lot when measurements jitter.

Quick test layout I used

1. Anchor 1 at (0.0, 0.0)
2. Anchor 2 at (3.0, 0.0)
3. Anchor 3 at (0.0, 3.0)

Bring the tag around and watch the Python plot. If the tag bounces or is wrong by 30 cm, check wiring, antenna delay, or anchor placement. With decent calibration and geometry, expect around 10 to 15 cm typical indoors.

1. Are all modules powered with clean 3.3 V?
2. SPI wiring correct and short?
3. Antenna orientation similar across anchors?
4. Anchors at similar heights?
5. Are anchors placed so geometry is not degenerate? Avoid all anchors in a line.
6. Check RSSI and first path values for NLOS. Filter those samples.
7. Re-run antenna delay calibration per unit.

1. Double-Sided Two-Way Ranging mode for tag-anchor distances.
2. Channel 5 (6.5 GHz) operation.
3. SPI communication to ESP32.
4. Antenna delay calibration. Typical start value: 16350 ticks.
5. High data rate 6.8 Mbps for faster cycles.
6. JSON over serial or TCP for sending measurements to host.
7. SciPy least_squares for trilateration on host.
8. Optional: Kalman filter for smoothing.

1. Add anchor 4 for 3D position.
2. Do TDoA with synchronized anchors for more scalable multi-tag setups.
3. Forward position over MQTT or WebSocket to a dashboard.
4. Fuse IMU data on the tag to survive short UWB dropouts.
5. Integrate with ROS for robot navigation.

This guide is based on the comprehensive material from: UWB Indoor Positioning System using ESP32