Sauron

From noisy RF to intelligent positioning.

Comment

Inspiration

This project started with a phone call none of us will ever forget.

One of our teammates lost a family member in a natural disaster. Gone. Buried under rubble before rescue teams could reach them in time. We sat together in silence the night we found out, and somewhere between the grief and the helplessness, a question kept circling: what if they had been found just a few hours sooner?

Rescue teams do incredible work, but they are fighting against time, noise, and debris that swallows signals whole. Thermal cameras fail through thick concrete. Acoustic sensors get drowned out. Dogs get tired. And meanwhile, somewhere under all that weight, a phone might still be quietly broadcasting a Wi-Fi probe or a Bluetooth beacon, crying out in a language no one is listening for.

We decided we would learn to listen.

What We Built

We built a distributed RF localization system, a network of rotating sensor nodes that passively detect Wi-Fi and Bluetooth signals from a target phone and estimate its location through a heatmap, even in noisy, obstructed environments like collapsed structures.

Each node is made up of:

  • An ESP32-S3 with an external 2.4 GHz antenna for sensitive signal reception
  • A servo motor that rotates the node, turning omnidirectional scans into directional ones
  • A parabolic dish that acts as a passive reflector to sharpen angle estimation
  • A WS2812 LED ring for live visual feedback of signal strength
  • Its own power bank with 18650 cells so voltage spikes from the servo never crash the ESP32

A Raspberry Pi Zero 2 W sits at the center, aggregating RSSI, angle, and timestamp data from every node through an API. On top of that, a drone running its own Raspberry Pi acts as a mobile node, flying toward stronger signal regions and feeding new vantage points back into the system in real time.

The math is not classical triangulation. We do not have UWB, and we do not have true beamforming. What we have is something more honest: hybrid angle and signal based localization, where each node contributes a tuple of \( (\theta, \text{RSSI}) \) and the system fuses these into a probability surface. A point \( (x, y) \) gets a score roughly like

$$ S(x, y) = \sum_{i=1}^{N} w_i \cdot f(\text{RSSI}_i, d_i(x,y)) \cdot g(\theta_i, \phi_i(x,y)) $$

where \( d_i \) and \( \phi_i \) are the predicted distance and angle from node \( i \) to the point, and \( w_i \) weights nodes by signal stability. The highest scoring region becomes our best guess.

How We Built It

We built it the way four friends build anything: arguing, laughing, breaking things, and starting over.

Chahel took the lead on the node hardware, wiring the ESP32-S3 boards, figuring out why the servos kept browning out the microcontrollers (answer: shared ground, always shared ground), and designing the rotating dish mounts so they would not wobble mid scan.

Pratheek owned the signal processing side, writing the ESP32 firmware that captures RSSI samples, tags them with servo angle, and streams them to the central Pi. He also built the signal variance metric that lets us flag zones where debris is likely distorting the signal.

Harshith built the central aggregation layer on the Raspberry Pi, the API that every node talks to, and the heatmap visualization that turns a storm of noisy RSSI values into something a human can actually read and act on.

Garvin took on the drone subsystem, writing the onboard Pi logic that pulls data from the central API, performs its own scans mid flight, and implements a simple gradient ascent so the drone naturally drifts toward the strongest signal cluster.

Challenges We Faced

The hardest challenge was not technical. It was emotional. Working on this while grieving is its own kind of weight. Some nights we could not look at the project at all. Other nights it was the only thing keeping us moving, because building something felt better than sitting with the feeling that nothing could have been done.

Technically, the challenges came in waves.

RSSI is a liar. Signal strength swings wildly even in open air. Behind a wall it becomes almost unreadable. We had to build statistical smoothing and variance tracking just to get numbers we could trust.

Servo power spikes crashed everything. Our first nodes reset themselves every few seconds. We learned the hard way that servos draw sharp current bursts and that ESP32s hate sharing a rail with them. Separate power banks and shared grounds fixed it.

The ESP32-S3 did not fit the breadboard. A tiny, stupid, humbling problem that cost us an hour until we gave up and used jumper wires off board like adults.

Triangulation without true distance is hard. We had to accept that we were not building GPS. We were building a probability map. Once we stopped chasing precision and started chasing confidence, everything got easier.

What We Learned

We learned that passive RF localization is real, and it is buildable, even on a student budget of around $150 in parts.

We learned that antennas matter, that grounds matter more, and that no amount of software will save you from a bad power supply.

We learned that the difference between a prototype and a system is mounting, labeling, and the discipline to test one thing at a time.

And we learned something none of us expected to learn from a circuit board: that grief can be a kind of fuel, if you let it point somewhere useful. We cannot bring anyone back. But maybe, someday, a version of this system helps someone else bring someone home.

That is enough reason to keep building.

Share this project:

Updates