AutoDump: Autonomous Self-Emptying Trash Rover

A Raspberry Pi rover that finds full bins, docks, and auto-dumps into a central can using computer vision and sensors for hands-free, efficient trash management.

Comment

Inspiration

When you're intensely focused, even minor interruptions can break your momentum.
We noticed a simple but real problem at our own desks:

  • You build up "micro-trash" (snack wrappers, sticky notes, coffee pods).
  • You don't want to get up every few minutes and lose your creative flow.
  • But letting clutter pile up makes your workspace distracting and less usable.

Traditional solutions are binary: either a big trash can across the room (flow break) or trash all over your desk (mental clutter). We wanted something in between.

That became AutoDump: a compact, personality-driven desk companion that quietly manages your trash for you, allowing you to stay in the flow and keep your space clean.

What it does

AutoDump is a Raspberry Pi-orchestrated trash rover designed for your room or desk setup:

  • Lives near your desk as a small "smart bin" with a friendly persona.
  • Uses camera and ultrasonic sensing to navigate, align, and perform a controlled dump.
  • Commands the OpenRB-150 to drive the wheels and Arduino to move the Dumping mechanism
  • Activates a servo-driven dumping mechanism to empty into a larger central bin
  • Uses an ARUCO marker placed at the desk to recognize and precisely localize its reset position after each dump cycle, ensuring it consistently returns to the same “home” spot.

The goal is to reduce tiny context switches, avoid clutter, and make trash management feel seamless and enjoyable, rather than annoying.

How we built it

System architecture

  • Raspberry Pi (orchestrator)
    Runs the high-level state machine: idle → search → align → dock → dump → reset.
    Processes camera input for trash can detection and alignment.
    Sends motion and dump commands to the OpenRB-150.

  • OpenRB-150 + motors
    Drives the rover's wheels based on Pi commands.
    Handles low-level motor control, allowing the Pi to focus on vision and high-level logic.

  • Arduino boards
    Drive low-level I/O for ultrasonic and dump servos.
    Offload sensor/actuator tasks from the Pi to keep vision responsive.

  • Perception & sensing
    Camera: identifies the target can / docking marker and helps with final alignment.
    Ultrasonic sensor: measures approach distance, prevents collisions, and confirms dock range.

  • Dumping mechanism
    A servo-actuated linkage or inner bin mounted on a pivot.
    Once docked, the Pi signals the controller, the servo executes a controlled tilt to dump into the central container, and the mechanism returns to its home position.

  • Mechanical design
    Chassis and mounts assembled from available materials and 3D-printedt parts.
    The component layout was chosen for easy wiring, debugging, and stability during motion and dumping such as the mounting of camera and ultrasonic sensor position.

Challenges

  • Signal jitters
    We chose to use Arduino and OpenRB-150 as I/O controllers after encountering issues with signal jitters on the Raspberry Pi GPIO pins. The jitter caused abrupt servo movements and occasional unresponsiveness when the CPU was overloaded.

  • Coordinating multiple controllers
    Making the Raspberry Pi and I/O controllers (Arduinos and OpenRB-150) communicate reliably via serial (protocol design, timing, error handling) while also running vision and sensors pushed us to define a straightforward, minimal command interface.

  • Robust docking in messy reality
    Small changes in bin position, lighting, and floor friction broke naive approaches. We iterated by combining visual alignment with ultrasonic thresholds, adding conservative stopping distances, and implementing simple failsafes.

  • Mechanical reliability
    The dump system needed enough torque and travel without jamming. We tuned servo angles, linkages, and hard stops repeatedly to ensure a consistent full dump.

  • Time pressure debugging
    Every change touched hardware and software. We learned to prioritize a stable, testable pipeline over fragile extra features.

What we learned

  • How to design an end-to-end cyber-physical system that closes the loop from sensing → decision → actuation → verification.
  • Practical integration of:
    • High-level control and vision on a Raspberry Pi
    • Real-time motor and servo control on the OpenRB-150 and Arduinos
  • The value of simple, well-defined states instead of one monolithic script.
  • That reliability and safety around a focused use case impress more than bolting on unstable "smart" features.

Next steps

Given more time, we'd like to:

  • Support multiple bins and routes for building-wide deployment
  • Improve vision robustness across different bin types and environments
  • Add remote monitoring and analytics for facilities staff
  • Improve system's processing and response time performance with RTOS (Real-Time Operating System)
  • Design a better power management system (central battery plus optional UPS for the Pi for voltage stability)

Built With

Share this project:

Updates