Blip

WORK IN PROGRESS: MANY FEATURES MAY BE BROKEN — proof of concept, v0.2.2-wip

Turn a tiny radar chip and an old phone into a people-spotting radar 📡

Ever wanted to know who is walking about, and how far away they are, without a camera? Blip does it with a tiny radar chip and a spare phone. The chip sends out invisible radio waves and listens for the echoes. When someone moves, the echo changes, and Blip works out where they are.

The phone is the screen. Blip makes its own Wi-Fi network; you join it, open a web page, and a glowing green radar scope appears, like something from a submarine film. Up to three people show up as dots with their distance, direction and speed. No app to install, no internet needed, no cloud, no camera.

How it works, in three steps

1. Plug a little ESP32 board into a radar chip (the Ai-Thinker RD-03D) and power it from USB.
2. Join the Wi-Fi network called Blip-Radar on any old phone, tablet or laptop.
3. Open the page and watch the dots move. Walk about and see yourself on the scope!

Good things to know

• It only sees things that move. Someone sitting very still fades from the scope.
• It also bounces off big metal things such as fridges, so a small room can look busy.
• A tiny optional screen (an OLED) can sit on the board and show the same picture. Blip finds it by itself when it starts.
• You can switch between tracking the one nearest person or up to three.

It is a slimmed-down take on Stevee87's Arduino-ESP32-Radarproject, which pairs the same radar with a XIAO ESP32-S3 and an Arduino GIGA R1 + display shield. The drawing is the easy part; a phone already does it.

Required Notice: Copyright Matthew Armstrong (https://github.com/The-Dorkknight).
Licensed under the PolyForm Noncommercial License 1.0.0 — source-available, free for non-commercial use. Provided as-is with no warranty and no liability. Not a medical device. Radar can see motion through thin walls: respect other people's privacy and the 24 GHz rules where you live.

Project started 2026-11-05 10:24.

📘 The whole manual and research notes as one PDF: docs/Blip-manual.pdf (also attached to every release).

Phone screenshot from the simulator (tools/sim_radar.py).

Bonus experiment: the Stetho add-on (parked)

The idea: use a second, very cheap radar-style module (a £3 CDM324 or HB100 Doppler sensor) as a stethoscope that listens to a heartbeat from a distance. A modded MAX4466 microphone board boosts the signal, and the ESP32 cleans up the sound (ducks knocks, lifts heart, lung and throat sounds, cuts hiss) and plays it live to the phone, to 3.5 mm earphones, or to a small speaker.

Status: abandoned, but kept as an optional install. The radar and phone scope are the project; the stethoscope is parked. The firmware, page and tests are still in the repo and still build, and you can switch it on in Settings, but nobody is working on it. Why, in the author's words: "Needing to build an ultra-low-noise, ultra-high-gain, fast-slew-rate instrumentation amplifier is just too much work for a 'fun' 30-minute project, but I encourage anyone gifted enough with analogue, or mad enough, to carry on my research 😉" Findings and test recordings are in docs/STETHO_SIGNAL_NOTES.md.

Simulator screenshot. The real thing never got past the noise floor.

What exists vs what doesn't

Bill of materials

Wiring

Pin numbers live in one place, firmware/platformio.ini; the diagrams are drawn from it.

Stetho front end: CDM324 → modded MAX4466

⚠ DC warning. When you desolder the mic capsule and wire the radar's IF pin onto its pads, also remove the mic bias resistor, or put a 10–47 µF DC-blocking cap in series with the IF lead. Otherwise ~1.5 mA of DC from VCC is pushed into the CDM324's mixer diode. Power the MAX4466 from 3V3, never 5 V. Full steps: hardware/max4466-mod.md.

RD-03D + CDM324 at the same time? They share the 24 GHz band. The RD-03D's sweep passes right over the CDM324's frequency, so expect a buzz in the Stetho audio and possibly a noisier RD-03D. Use an HB100 (10.5 GHz) for the Stetho, or fit a 5 V switch on the radar and choose Radar off while listening (PIN_RADAR_PWR). Details in DESIGN_NOTES.md §11.5.

One launcher: flash it, or try it first (double-click)

1. Unzip, then double-click Blip-Linux.sh (choose Run), Blip-Windows.bat or Blip-Mac.command (first time on a Mac: right-click → Open).
2. Your browser opens the Blip Flasher at http://127.0.0.1:8080/ (the red page). Only Python 3 is needed to open it.
   • Want to look around before you have hardware? The small Radar simulator › button (top right) opens the normal Blip page at /sim, with three pretend people wandering about and a synthetic Stetho signal; its ⚡ Flasher button brings you back. Start the launcher with --lan to open the simulator from your phone too (the terminal prints the address).
3. To flash a real board: plug the board in with a USB data cable, pick the board (C3 Super Mini / S3-Pico), the radar (RD-03D / LD2450) and how to flash, pick the port (or leave Auto-detect), press ⚡ Flash firmware.
   • Quick flash (default, recommended): writes the firmware that ships in firmware/prebuilt/. Nothing is hidden: the page shows the file, version, build date, size and full SHA-256, checks the file against manifest.json before writing, says whether it was built from exactly the source in your folder, and shows the exact esptool command. The first run installs only esptool into .venv (about 40 MB). No Git, no compiler.
   • Build from source: compiles your folder with PlatformIO so your own changes go in. The first build downloads the ESP32 toolchain (a few GB; needs the internet and Git; 5–15 minutes), later builds are quick.
   • The steps light up as it goes (Quick: Firmware → Flash tool → Upload → Boot; Source: Prepare → PlatformIO → Build → Upload → Boot) with a progress bar for the upload and the full log underneath (Copy puts it on the clipboard for a bug report).
   • If something fails, a tip explains the usual cause: serial-port permission on Linux, the board not in flashing mode (hold BOOT, tap RESET), no board or several boards found, no internet on the first run, Git missing, a port held by another program, your source newer than the bundled firmware.
   • Afterwards it shows the board's serial output (no terminal needed). Cancel stops any step.
   • Rather use another tool? Any ESP32 flasher can write firmware/prebuilt/blip-<env>-full.bin at address 0x0 (they are also attached to each GitHub release).
4. Wire the radar as above and power up. The LED on the C3 blinks slowly until frames arrive, then fast.
5. On the phone: join Wi-Fi Blip-Radar, password blipblip. The captive portal should open the scope; if not, browse to http://192.168.4.1/. It is the same green page as the simulator.

The flasher only answers this computer (127.0.0.1 / localhost): starting a flash needs a per-run token only the page has, and the board, radar and port are checked against fixed lists before anything runs. --no-flash hides it entirely.

Prefer the terminal? cd firmware && pio run -e c3-supermini -t upload (envs: c3-supermini, s3-pico, c3-supermini-ld2450, s3-pico-ld2450). After editing web/index.html run python3 tools/embed_web.py (the Flash tab does this for you).

Using it

Screen	What it does
	Scope — ±60° sector, rings every 2 m to 8 m, one coloured blip per tracked person with distance and radial speed. Trails fade over 4 s. Tracker ping is the original project's buzzer, done in the phone's speaker: faster and higher as the nearest person approaches. Mirror L/R flips the picture if you mount the radar the other way round. With the Smart filter on, Show filtered draws what it is hiding as dashed rings (ghost / clutter).
	Targets — the numbers behind the blips plus the raw JSON, handy when checking orientation.
	Stetho — the optional CW Doppler channel. Presets: Heart (S1/S2 heart sounds, 20–150 Hz), Lungs (breath hiss), Voice (throat/larynx buzz), Wide, Raw (plain Doppler warble). Listen on phone plays it live; Delay shows how far behind real time you are. Knocks are ducked and limited (red in the trace). Beat lock quietens the gaps between beats once a rhythm is found; Record 10 s → WAV saves a recording for tools/analyze_wav.py; Experiments has ADC averaging and the burst blanker (see docs/STETHO_SIGNAL_NOTES.md). Not a medical device.
	Chest motion view — the 100 Hz motion trace with heart-rate and breathing rates from the pattern trackers (a ? means only roughly steady); Beat thumps adds a synthetic thump on each detected beat.
	Clean-up on the node — noise suppression, bump rejection, AGC or manual gain; Sound out of the node — earphones or I2S amp, with its own volume.
	Settings — single/multi target mode (also on the Radar page as Track 1 / Track 3), Target filter (Raw / Smart, experimental) with Forget learned clutter, Auto-sleep, OLED (Auto-detect, or a fixed size), Stetho on/off, radar-off-while-listening, hotspot name and password (reboots).
	About — version, build date, board, pin map and counters.
	Flash (simulator on a PC only) — pick board, radar, Quick flash or Build from source, and port; see exactly what will be written; watch the board boot.

OLED mirror. Each person is a circle with their distance inside: big digit = metres, small raised digit = tenths, so "1⁹" = 1.9 m. The nearest person is solid. There's no status row, so the scope fills the panel. ◆ top-left = Smart filter on; Wi-Fi icon + number top-right = phones connected; the IP shows bottom-left only until a phone joins. These are exact renders of the firmware's drawing code, not photos:

How it works

Short version: the ESP32 parses 30-byte frames from the radar, keeps the latest three targets, and pushes them as JSON over a WebSocket 20 times a second to whoever is on the hotspot; the browser draws the scope on a canvas. The long version, including the frame format, is in HOW_IT_WORKS.md. The research — radar physics, why the RD-03D can't be a stethoscope and what can, pin choices — is in DESIGN_NOTES.md.

Radar options

Blip was written for the Ai-Thinker RD-03D (1.25 mm 4-pin socket, 8 m, up to 3 targets). The HLK-LD2450 (Hi-Link, 24 GHz, about 6 m, up to 3 targets with X/Y position) is supported too:

• It sends the same 30-byte frame (AA FF 03 00, three 8-byte slots, 55 CC), so the same parser reads it.
• It has no RD-03D configuration commands, so Blip skips the mode command. Single (nearest) is picked in firmware instead.
• Use the c3-supermini-ld2450 or s3-pico-ld2450 build environment (or add -DRADAR_LD2450=1). /api/status reports "model":"ld2450" while it is running.
• Its pins are on a 2.54 mm header, so jumper wires work. Check the labels on the module: its TX goes to the board's RX pin, and its RX to the board's TX.
• Weaker than the RD-03D on people who sit very still (the vendor notes this beyond about 2 m), and range is about 6 m.
• Still 24 GHz, so it clashes with a CDM324 in the same way. Use an HB100 for Stetho, or the radar power switch.
• Not tested on hardware yet. Check the angle direction on the Scope first (Mirror L/R in Settings if left and right are swapped).

Repository map

firmware/        PlatformIO project (src/main.cpp, include/rd03d.h, tracker.h, audio_dsp.h, stetho.h, oled.h, oled_draw.h, web_ui.h)
firmware/prebuilt/  bundled whole-chip images for the four builds + manifest.json (checksums, version, source hash)
web/index.html   the phone UI (single file; embedded gzipped into the firmware)
web/flasher.html   the flasher (served by the PC tool only; never in the firmware)
web/flash_home.html  the red home page the launcher opens, with the flasher inlined
tools/           sim_radar.py, flasher.py, serial_tail.py, make_prebuilt.py, make_pdf.py, embed_web.py, draw_illustrations.py, rd03d_py.py, tracker_py.py
tests/           native C++ tests (parser, audio DSP, tracker, OLED render), Python parser + tracker cross-check, flasher (with fake_pio.py), launcher test
hardware/        wiring, MAX4466 mod (with the DC warning), earphone / I2S amp outputs
examples/        synthetic RD-03D frames for replay; dsp_before.wav / dsp_after.wav
docs/            GitHub Pages site + images + Blip-manual.pdf (built by tools/make_pdf.py)

Source code: The-Dorkknight/blip-radar on GitHub