Autonomous garden robot

Piki: Real-Time Cat Detection with Horizon RDK X5 & Hardware-Accelerated AI

The Situation: A Common Problem

Neighborhood cats are a nuisance for many homeowners. Beyond the obvious frustration, they pose a serious health risk—cat feces can transmit parasites and bacteria like Toxoplasma gondii, creating an unsafe environment for children who play outdoors. Traditional solutions (fencing, netting, repellents) are either expensive, unsightly, or ineffective. There had to be a smarter way.

The Task: Building an Intelligent Deterrent

Piki is an autonomous, humane, and cost-effective cat deterrent system that solves this problem using real-time object detection and hardware acceleration. The core idea is simple: detect cats as they enter a monitored garden area, aim a camera at them, and trigger a harmless deterrent (water spray or ultrasonic sound) to train them to avoid the space.

But building this system efficiently on a resource-constrained single-board computer (SBC) is non-trivial. Object detection models are computationally expensive. Processing full-resolution stereo video in real-time demands intelligent hardware choices. This is where Horizon Robotics' RDK X5 platform shines.

The Action: Intelligent Hardware Architecture

Why RDK X5?

Unlike generic Linux SBCs, the RDK X5 (built on Rockchip RK3566/RK3568 processors) includes specialized hardware accelerators purpose-built for robotics and AI:

1. BPU (Bernoulli Processing Unit) The BPU is a dedicated neural processing unit optimized for inference. Instead of running YOLOv8 on the CPU (which would bottleneck the system), the model runs on the BPU—delivering real-time performance with minimal power consumption. This is the key to fast, responsive cat detection.

2. ISP (Image Signal Processor) The RDK X5 includes a sophisticated ISP that processes camera feeds in real-time. It handles:

  • Noise reduction for cleaner image data
  • Wide Dynamic Range (WDR) processing for varying lighting conditions
  • Stereo rectification to align left/right camera feeds

Without the ISP, the CPU would waste cycles on these preprocessing tasks.

3. Zero-Copy HBM (Horizon Buffer Memory) Here's where it gets elegant: the ISP outputs frames in NV12 format to a shared hardware buffer (HBM). The BPU can read this buffer directly without copying to CPU memory. This zero-copy pipeline means:

  • Minimal latency: Frame → BPU inference in microseconds
  • Low CPU overhead: The main processor isn't stalled waiting for I/O
  • Efficient power usage: No redundant data movement

The Hardware Pipeline

Piki uses dual stereo SC230AI cameras—one for the left "eye" and one for the right. Here's how the hardware pipeline works:

SC230AI Cameras (Left + Right)
    ↓
ISP → Noise reduction, WDR processing
    ↓
hobot_stereonet (ROS 2 Node on BPU)
    ├→ Stereo depth estimation (real-time 3D reconstruction)
    └→ Outputs: 1280×640 NV12 frame + depth map
    ↓
Piki Django Backend (ROS 2 Subscriber)
    ├→ Receives zero-copy HBM frame
    ├→ Slices 1280×640 stereo pair into 640×640 tiles
    └→ Sends each tile to YOLOv8 (BPU inference)
    ↓
Detection Results → Servo Aiming → Deterrent Trigger

Efficient Tiling for Full-Resolution Processing

A clever optimization: the stereonet outputs 1280×640 resolution, but the YOLO model expects 640×640 input. Rather than resize (which loses detail), Piki tiles the image:

  • Tile 1: Pixels 0-640 (left camera)
  • Tile 2: Pixels 640-1280 (right camera)

Each tile is processed independently by the BPU. The system even optimizes further: if motion is detected only in the left camera region, it processes a single tile instead of both. This means full-resolution detection without resize artifacts or wasted computation.

The Software: tROS2 & Robotics Integration

What is tROS2? tROS2 is Horizon's robotics operating system, built on ROS 2 (Humble) with Horizon-specific optimizations. It provides:

  1. hobot_dnn: Inference engine that talks directly to the BPU
  2. hobot_stereonet: Real-time stereo vision node that outputs calibrated depth maps
  3. ROS 2 DDS middleware: Zero-copy data sharing between nodes

Piki acts as a ROS 2 subscriber node, receiving camera frames and depth maps from hobot_stereonet:

# Subscribe to stereo camera feed (1280×640 NV12, zero-copy HBM)
self.subscription = self.create_subscription(
    Image, 
    topic="/image_left_raw",
    self.listener_callback_hbm
)

# Subscribe to real-time depth map (Mono16, millimeters)
self.create_subscription(
    Image, 
    "/StereoNetNode/stereonet_depth",
    self._depth_callback
)

This ROS 2 integration means:

  • Hardware-aware scheduling: tROS2 ensures the detector runs at the right priority
  • Deterministic real-time behavior: No unexpected latency spikes
  • Future extensibility: Other robotic nodes can consume Piki's detection results

The AI: YOLOv8 on the BPU

Piki uses YOLOv8 (640×640 resolution) compiled for the BPU using RKNN format. A critical optimization: the model is trained for NV12 input, not BGR. Why? Because:

  • Standard models expect RGB/BGR (color) images, requiring CPU-side color space conversion
  • NV12 models let the BPU handle color conversion internally
  • Net result: No CPU bottleneck in the inference pipeline

Detection results include bounding boxes with confidence scores. Piki applies Non-Maximum Suppression (NMS) at a 0.45 threshold to filter overlapping detections, then uses the embedded stereo calibration data (stored in the camera's EEPROM) to compute 3D coordinates:

Calibration Intrinsics (640×352 rectified resolution):
Focal Length (Fx, Fy): 257.85 pixels
Principal Point (Cx, Cy): (314.43, 159.98)

For each detected cat:
Depth from stereonet_depth map + 2D bounding box → 3D position
3D position + servo geometry → servo angle to aim

Control Loop: From Detection to Action

  1. Detect: YOLO runs on BPU → detections published to ROS 2 topic
  2. Localize: Stereo depth map + 2D box → 3D coordinates
  3. Aim: Servo motor angles computed from 3D position
  4. Act: Relay-controlled water valve or ultrasonic speaker triggered

The servo operates on GPIO pin 12 (±90° range), controlled via Python's gpiozero library. The entire loop (capture → detect → aim → spray) completes in under 200ms thanks to hardware acceleration.

The Result: A Practical, Intelligent System

Performance Metrics

  • Detection latency: ~50-100ms (BPU acceleration)
  • Full system latency (capture → deterrent): <200ms
  • Throughput: Real-time detection on 1280×640 stereo at 30 FPS
  • Power consumption: ~3-5W during active detection (vs. 15-20W on CPU-only SBCs)

User Experience

All control and monitoring happens through a Vue 3 web interface:

  • Live camera feed with detection overlays (MJPEG streaming)
  • Detection logs showing timestamps, confidence, and 3D coordinates
  • Fine-tunable settings: Adjust detection confidence, NMS threshold, deterrent sensitivity
  • Manual controls: Test servo aiming or trigger deterrent on demand

The backend is built with Django + Django Ninja (REST API) and Daphne (async ASGI server) for responsive streaming.

Generalization & Extensibility

While Piki is designed for cats, the hardware pipeline is agnostic to the object class:

  • Change the YOLOv8 model to detect birds, raccoons, or even humans
  • Reuse the stereo vision pipeline for 3D spatial awareness
  • Extend via ROS 2: publish detections for other nodes to consume
  • Run multiple instances of Piki on the same tROS2 system

Why This Approach Works

Hardware acceleration is not optional when building real-time AI systems on SBCs. The RDK X5 excels because:

  1. Specialized hardware: BPU + ISP + HBM eliminate CPU bottlenecks
  2. Zero-copy semantics: Data flows directly from camera → BPU → results
  3. Embedded calibration: Stereo cameras come factory-calibrated (no manual setup)
  4. Robotics-first design: tROS2 + ROS 2 DDS provide deterministic, low-latency middleware
  5. Power efficiency: Full AI pipeline consumes a fraction of CPU-only alternatives

Compare this to a generic Raspberry Pi running inference on CPU: you'd get 5-10 FPS at best, with high power consumption and noticeable latency. Piki on RDK X5 delivers smooth, real-time performance.

Conclusion: Smart Gardening Meets AI

Piki demonstrates that smart hardware choices enable smart applications. By leveraging Horizon's specialized processors, ISP, and robotics middleware, a cat deterrent system becomes more than a gimmick—it becomes a reliable, efficient tool.

The project is open-source, fully documented, and serves as a blueprint for anyone building:

  • Real-time AI detection systems
  • Stereo vision applications
  • Robotics projects on resource-constrained hardware
  • Smart home automations that demand low latency

Whether you're protecting your garden from cats or building the next generation of autonomous robots, the RDK X5 + Piki stack shows how thoughtful hardware-software co-design unlocks possibilities that CPU-only approaches cannot match.

Key Takeaway: Real-time AI isn't about throwing more compute at a problem—it's about choosing the right hardware and orchestrating data flow to eliminate bottlenecks. Piki does exactly that.