NightSentinel began with a simple question: Could we build a security system that does more than detect motion?
Traditional motion lights react to almost anything. A branch, an animal, or a passing shadow can trigger the same response as a person. We wanted to create a system that could observe its surroundings, identify a person, physically track them, verify their distance using independent sensors, and respond only when multiple conditions agreed.
Our goal became an autonomous, edge-powered security platform that could see, verify, and deter without depending on cloud processing. What NightSentinel Does NightSentinel combines computer vision with several physical sensors:
- An NVIDIA Jetson runs a YOLO-based person-detection model.
- A Logitech C920 camera provides the live video feed.
- A servo physically turns the camera to follow a detected person.
- mmWave radar provides initial motion and presence detection.
- A JSN-SR04T ultrasonic sensor verifies the target’s distance.
- An LDR determines whether it is dark enough to activate the system.
- An Arduino Nano controls the sensors, servo, relay, and deterrent hardware.
- A web dashboard displays the live camera, system readiness, and verified events. Instead of trusting one sensor, NightSentinel uses sensor fusion. A visual detection alone is not enough to activate the deterrent. The system also considers distance, radar activity, lighting conditions, and the current safety state. How We Built It We divided NightSentinel into two cooperating systems.
The Jetson handles high-level intelligence. It processes camera frames, detects people, maintains a target across frames, and calculates where the camera should turn. We added smoothing, a tracking dead zone, safe servo limits, and temporary target retention so the camera would not constantly jitter or immediately lose someone who stopped moving.
The Arduino handles real-time hardware control. It reads the radar, ultrasonic sensor, and LDR while controlling the servo and relay. A serial bridge allows the Jetson and Arduino to exchange sensor readings, servo commands, and safety states.
We also created a browser-based command center that shows the live annotated camera feed, sensor status, latest detection, and recent activity on the local network.
Most importantly, we designed the deterrent around multiple safety gates. It can only be authorized when a person is detected, the target is within the configured range, the environment is dark, and the Jetson is actively online. Challenges We Faced This project did not begin smoothly.
One of our earliest problems was getting Ubuntu installed on the NVIDIA Jetson. We spent an entire day retrying the installation, checking the image, connections, and setup process without getting it to work. After stepping away and returning the next day, the installation finally completed. That experience established the pattern for the rest of the project: hardware integration often requires patience just as much as code.
We also had a frightening hardware failure when an Arduino began smoking during testing. We immediately disconnected power and stopped the test. It forced us to slow down, inspect the hardware, and become much more deliberate about checking wiring and power connections before energizing the system. It was an important reminder that mistakes in embedded development can have physical consequences.
Tracking introduced another set of problems. Early versions followed hands instead of complete people, overshot targets, moved too far ahead, or continued searching after the vision program had stopped. We gradually improved the behavior by rejecting very small detections, making targets “sticky,” smoothing their position, limiting servo movement per command, and adding an explicit online/offline handshake between the Jetson and Arduino. Now, when the program shuts down, the Arduino parks the camera instead of continuing to scan.
Even the webcam caused unexpected issues. Linux assigned it /dev/video1 instead of /dev/video0, and passing the device path directly did not work correctly with our vision library. We eventually discovered that using the numeric camera source solved the problem. What We Learned NightSentinel taught us that building an intelligent physical system is very different from building a model or circuit in isolation.
We learned how to:
- Run real-time computer vision on an edge device.
- Coordinate Python software with Arduino firmware.
- Build smoother physical target tracking.
- Parse and exchange structured serial messages.
- Combine independent sensors to reduce false activations.
- Design explicit failure and shutdown behavior.
- Treat hardware safety as part of the software architecture.
- Build a local dashboard around a live embedded system. Our biggest lesson was that no single sensor is completely reliable. Vision can briefly lose a stationary person, radar can detect motion without identifying its source, and ultrasonic readings can occasionally be invalid. Combining these signals makes NightSentinel more dependable than any individual component. What’s Next Our next steps include improving the dashboard, recording incident snapshots, adding structured AI-generated incident summaries, and continuing to refine tracking performance.
NightSentinel is more than a motion detector. It is a complete edge-intelligence system that observes, verifies, tracks, and responds—with safety built into every stage.
