Space Vacuum

Background

I'm a big fan of opening stuff up, checking what's inside, and then repurposing them into other stuff. And this project came mostly from that. But anyway, my main roomba broke down and I needed to change it's wheel module, so I found an old model for around $7 online (thank god for online auctions), bought it and saved the main roomba by changing the wheel module. But now I had a whole new robot to play with, and I new that it could be controlled through a serial port it exposes.

Back in 2000-tenish (2016 exactly) I participated on in Arduino's Hackster Contest for the MKR1000 board. I apparently got a good idea and received one of the boards. It was a lot of fun and everything, but then it got forgotten (by, you guessed it, me). I was diving into my junk drawers to see what I could use for this project and rediscovered the MKR1000. So it was decided: the roomba would be connected to the internet.

After trying for a few hours with the MKR, it betrayed me by now working as I wanted it to work so I just cut the middle man out and directly connected my Raspi 4 to the roomba.

Okay so now we got the RPi4 and the roomba. The first one's UART is on 3.3V and the other one on 5V, so naturally a level shifter is needed to not burn up anything. So I bought one.

As I wanted to power the RPi4 with the roomba's power supply, I needed a buck converter to lower the output voltage for the board. However, I was already pissed that I needed to buy a level shifter, so I improvised instead. I had an old Arduino Mega that betrayed me a few years ago, for some reason it would turn on but would not communicate over serial, so it was impossible to upload code to it. That's what I get for not buying the OG Arduinos I guess.

But the current was not enough to power the RPi4, so I just used the Mega's 5V for the level shifter and connected an external battery pack to the RPi4 (thank you JAXA).

As far as I was concerned, the electronics were done (thank god). Onto the fun part: Software.

The hardware was as junky as it could get in my honest opinion. Except for the level shifter, everything was recycled. And as Dostoievski once said in Crime and Punishment:

To combat bad hardware one needs to double down on software.

Automotive software has a lot of regulations, which should lead to good and reliable software. But I was more interested in using software tools and frameworks that strive to survive in the worst environment: Space. When every high energy particle tries to screw up with your bits and flips, one needs reliable software to compensate the hardware-hijacking life throws at you.

So yeah, if you guessed we are using Fprime for this project, you are lying and I know you are. Fprime is a NASA Jet Propulsion Lab Flight Software Framework used in some of the most ambitious space missions. It's a modular, reusable, and highly reliable framework designed to handle the challenges of operating in the harsh and unpredictable environment of space. With a focus on fault tolerance and robustness, Fprime enables developers to create flight software that can manage spacecraft systems, execute commands, and respond to unexpected anomalies autonomously. It has been used in multiple CubeSat missions, and also with the Mars DroneIngenuity (Rest in Peace, we will miss you).

With Fprime, we get a nice GUI to control and monitor the roomba:

So now it was simply a matter of encoding the roomba's Serial Command Interface (SCI) into the Framework, which is rather simple as shown below, and sending the data package to the linux uart drivers component included in the Fprime Framework.

void Roomba::Control_cmdHandler(FwOpcodeType opCode, U32 cmdSeq) {
    Fw::Buffer buff = this->allocate_out(0, 1);
    U8 data = RoombaSCI::CONTROL;
    buff.getSerializeRepr().serialize(data);
    this->drvDataOut_out(0, buff);
    this->cmdResponse_out(opCode, cmdSeq, Fw::CmdResponse::OK);
}

For the dispenser, I was going to design something on Fusion 360 and 3D print it, then redesign it and reprint it again because I never get it right the first time. But then I remembered I hate doing CADs and that 3D printing would add at least 20 cents to the project's budget, which is too much for a junk-based robot. So I went to a local Caffè and waited for somebody to finish their cup of coffee, and stole the paper cup. Add a servo to it and voilà, you have a dog food dispenser (I found the servo on the ground I swear, don't add it to the BOM).

Once the hardware was sorted out, I knew the fun wouldn’t stop there. I wanted to take it up a notch by integrating some basic AI into the mix. I figured that if I could get the Roomba to recognize when a dog is around, it could then open the food dispenser automatically—because, you know, why not add some smarts to the junkyard bot? Enter YOLOv11 (You Only Look Once, version 11), the object detection model that’s efficient enough to run on the Raspberry Pi without frying the circuits.

After a few hours of messing around with TensorFlow Lite and optimizing the model for the Pi, I managed to get a Python script up and running. The script uses the onboard camera (hooked into the Pi) to process the video feed and run YOLOv11 on each frame. Once it recognizes a dog, the script sends a signal to the servo controlling the lid of the food dispenser. As soon as the lid opens, the dog gets its reward. There’s a slight delay, but nothing that a hungry dog would complain about. It’s a simple but satisfying loop: camera sees dog, YOLOv11 recognizes it, the servo moves, and boom, food delivery. The script runs in the background, constantly checking for that four-legged friend to come close enough.

Watching the Roomba move around, dispensing food when it detected the dog, was a nice payoff after all the tweaking. It’s a straightforward solution that shows how combining old hardware and a bit of Python can create something functional without overcomplicating things. The system works reliably, and it's satisfying to see it come together—especially given how much of it was built from repurposed parts.

Alex's Friendly Robot

This project is all about creating a robot that feels like a friend and gets stuff done. Using an old Roomba, a Raspberry Pi, and a bit of creativity, the robot moves around and does something super practical—feeding the dog. The real charm here is the simple, hands-on approach: repurposing forgotten parts to give them a new life. It’s not just a robot—it’s a companion that makes daily life easier. With movement and sound, and the bonus of object recognition for the dog, this bot not only helps around the house, but does it in a way that’s personal and fun.

Kevin's Data Dumpster Dive

This project takes junk and turns it into something useful by collecting data in real-time. The Roomba, equipped with a camera and object recognition, detects the dog and knows when to open the food dispenser. It’s not just about the tech, though—it’s about making these random old parts work together in a meaningful way. Instead of just collecting dust, the Roomba is now collecting data, helping out around the house, and even making life a little easier for the dog. It shows that with a little creativity and the right tools, even the most forgotten pieces of hardware can serve a purpose.

Griffin's Automated Personal Assistant

Imagine having a robot friend that automatically feeds the dog without you having to do a thing. That’s what this project is all about: taking everyday tasks and automating them in a simple, effective way. The Roomba moves around, detects when the dog is near, and opens the food dispenser without any input from you. It’s a no-fuss solution that saves time and effort, showing how even a junky robot can be transformed into something practical. It’s the kind of project that takes a small idea and turns it into a solution that makes life just a little bit easier.

Roomba in Action

Here are a few takes of the roomba in action.

Here is the wiring diagram.