Radar Gesture Detection

After interning at Zadar Labs, a radar startup in the Bay Area, I brought home a spare TI IWR6843 and started experimenting with its gesture-detection demo. The technology was impressive, but the gestures were the ones TI shipped. I wanted to train a network to detect my own — starting with a wave.

The sensor is a four-receiver, three-transmitter array transmitting at 60 GHz and measuring what comes back. It puts the signals through three stages of FFT — range, Doppler, and angle — to build a detection matrix of what is moving and where.

I wrote a Python script to capture that output in real time, pulling six features per frame: velocity, range, horizontal angle, and several correlation metrics.

A gesture is not a frame, it is a movement, so single frames carry almost nothing. I used a sliding window of fifteen consecutive frames, flattened into a ninety-feature input vector — fifteen frames by six features.

That feeds a network with two hidden layers, trained by gradient descent over a hundred epochs. I kept the problem honest and small to start: two classes, a wave and a no-gesture baseline, reaching about 98.1 % accuracy.

Collection is the unglamorous part: sitting in front of the radar performing the same wave over and over while the script counts frames into a dataset, then checking that the classes are actually separable before training anything.

For deployment the trained model is converted from NumPy arrays into C header files and compiled into the radar's firmware. Raw confidence alone was too twitchy, so I added temporal filtering — both confidence within a frame and persistence across frames — before a gesture counts as detected.

After reflashing, the gestures are recognised in real time on the radar's own ARM processor at thirty frames per second.

It works: a wave in front of the sensor prints wave, and the rest of the time it prints no gesture. The repository carries the whole pipeline — capture, dataset checks, training, C export, parity checks between the Python and embedded versions — along with later three- and four-class iterations beyond the original two.