Robot Right View
Operator UI (Drone Undetected Undetected)
Robot Detecting + Following a Drone
Robot Left View
Operator UI (Drone Detected)

Triple D — Detect · Decide · Defeat

A small, low-cost sentry that spots an incoming drone, decides if it's a threat, and stops it without firing a shot — entirely on its own, on-device, with no internet and no human in the loop.

It hears, sees, judges, and acts in seconds — faster than a person could.

Track: Autonomous Navigation & Edge AI (Hardware+)

Team: Brian Jing · Mikey Nguyen · Victor Lopez · Kevin Pyo

Inspiration

We began with the obvious idea: an RC car with a camera that does search-and-rescue. The problem is that it's too obvious. The same cheap autonomy that finds a lost hiker also helps an enemy find a target. If everyone can build the offense, the real value is in building the defense. So we flipped it: instead of a robot that hunts, we built one that guards.

Two things pushed us toward drones specifically:

The supply line is the soft spot. Firestorm 3D-prints drones right at the edge of the battlefield, but those printers still have to be flown or trucked in. Hit the transport and you don't take out one drone, you take out the factory that makes all of them. Guarding high-value assets like that is where a cheap autonomous sentry earns its keep.
Fiber-optic drones break the usual defenses. These FPV drones fly on a hair-thin fiber-optic cable instead of radio, so you can't jam them — there's no signal to attack. Today's answers are mostly manual (a person with a laser or a net), which doesn't scale and can't watch a position 24/7. A machine can. That gap is the whole opportunity.

The pitch in one line: a fully autonomous, always-on, offline sentry that hears a drone coming, confirms it on camera, decides friend-or-foe by itself, and neutralizes it non-kinetically — no operator, no connection, cheap enough to deploy in numbers.

Autonomy isn't a nice-to-have here, it's the requirement. A fiber-optic drone closing on a target leaves only seconds, and the battlefield it's flying over usually has no reliable connection to call home. There's no time and no link to ask a human, so the machine has to be trusted to act alone.

What it does

Everything runs on two cheap boards. The pipeline is simple:

[Car: Arduino UNO]  ── USB ──►  [Brain: Arduino Uno Q, runs Python]
  microphone                     DETECT   hear the drone
  distance sensor                DECIDE   confirm it on camera + sensor fusion
  motors + effects               DEFEAT   identify friend/foe, then act

Detect (ears). Listening is cheap, so it's always on. A drone's whine is a high, steady pitch — easy to flag. The camera stays off until the mic hears something worth looking at, which saves power and lets it stand watch indefinitely.
Decide (eyes). A sound wakes the camera, which runs a small drone-detection model on the device. It needs to see the drone across several frames before it believes it, so one bad frame can't set it off.
Identify (judgment). Once it's sure there's a drone, it decides friend or foe by itself. Friendly drones carry a shared secret code and answer a challenge; anything that can't answer is treated as hostile. This is the safeguard that lets it act alone — it won't touch one of your own.
Defeat (hands). Against a hostile drone it acts on its own with non-kinetic effects: a decoy to pull it away, and a laser aimed at the trailing fiber cable. Non-kinetic by design, so an autonomous mistake breaks a link, it doesn't blow something up.

The car itself never makes a single decision — it's a dumb body, and all the intelligence lives in the software brain. That's what makes the system portable to any robot, not just this car.

Safety doesn't come from a human babysitting it — there's no time or connection for that. It comes from the design: the friend-or-foe check before it ever engages, the non-kinetic effects, and a decision log it writes for every action it takes. The result is a system you can trust to run unattended.

How we built it

Two cheap boards, one repo. The car (an Arduino UNO) is a dumb body: it samples the mic, reads the distance sensor, drives the motors, and runs whatever one-word command it's told. The brain (an Arduino Uno Q running Python) does all the thinking, talking to the car over a plain, human-readable serial link you can watch live while debugging.

The brain is a clean pipeline where each stage is one job, and the smart part is sensor fusion — instead of trusting any single sensor, we combine them into one confidence score and only act when it crosses a line:

$$ S = 0.30\,(\text{sound}) + 0.40\,(\text{camera}) + 0.30\,(\text{closing in}) $$

Hostile when $S \ge 0.60$. Sound is sensitive but vague, the camera is specific but expensive, and "is it diving at us?" breaks the tie. No one signal can trigger a response alone.

The AI runs on the device's own processor — no cloud, no GPU. The camera model only loads when sound says it's worth it, and the whole thing works offline by design. There's also a live dashboard, built with zero outside libraries so it runs anywhere, showing the mic, the camera, and a top-down view of the tracked drone.

Challenges we ran into

Fiber-optic drones are genuinely hard. No radio link means jamming is off the table, so we had to think physically — cut the cable, lure the drone — instead of reaching for the usual electronic counters.
There's almost no good data for this. Off-the-shelf models spot cars and people well, not military drones — solid public datasets barely exist, so training the camera took far longer than we expected. We started out trying to tell drones apart from airplanes and helicopters (three categories), but the extra ones just confused the model and hurt accuracy on the one that actually matters. We narrowed it down to a single question — is that a drone? — and it got noticeably sharper.
Acoustic detection is stubborn. A drone's whine shifts with distance, propellers, and background noise, and clean labeled audio is scarce, so getting it to reliably hear a drone took a lot of trial and tuning.
Cheap hardware, real physics. One microphone tells you a drone is there, not which direction — that needs more sensors. And a basic Arduino can only hear so cleanly, enough to pick out a drone's whine but no more.
Hours, not weeks. A closing drone gives you seconds to act, and a hackathon gives you a day to build. We had to prove the whole idea worked before we trusted any of the hardware.
Knowing what not to do. We kept catching ourselves about to overclaim, and pulled back every time.

Accomplishments that we're proud of

It runs end-to-end with no hardware at all. A "mock" mode plays a scripted threat a few seconds in, so anyone can watch the full detect → decide → defeat sequence on a laptop. That let us prove the logic first, then swap in real parts one at a time without rewrites.
It's honest. The demo tracks the fiber instead of pretending to cut a moving hair-thin cable. We'd rather under-promise than oversell — which matters more in defense than anywhere else.
Safe autonomy. The friend-or-foe check, the non-kinetic effects, and the decision log are the guardrails that let it run alone without being the "scary autonomous weapon" — trusted to act on its own, designed so a mistake is harmless.
Truly offline. No cloud, no GPU, no internet — the AI, the camera model, and even the dashboard all run on the device itself.

What we learned

The "no internet" rule made it better, not worse. It forced simple, rugged choices a connected system would have skipped.
Cheap-and-always-on beats expensive-and-occasional. Using sound to wake the camera is the difference between a sentry that watches all day and one that dies in an hour.
Trust comes from combining sensors, not from one clever model.
Safe autonomy is a design problem, not a babysitting problem. The way to trust a machine that acts alone is to build the guardrails in — friend-or-foe first, non-kinetic effects, a full log — not to bolt a human on top.

What's next for Triple D

More microphones for direction-finding, a stronger handshake for friend-or-foe, the real laser and decoy hardware behind the existing controls, and a swarm of these sentries handing off targets to each other over an offline mesh — many cheap units guarding one asset, which is exactly the kind of scalable, connectivity-independent defense the threat calls for.