ROS2-Powered Hexapod Robot Dorm Pet to torment my roommates with.
Solo Developer
August 2025 - May 2026
Ongoing. Slowly. When I find spare time!
Over the summer, I decided to start working on a personal robotics project to build my familiarity with ROS2 and overall robotics system design. I was inspired by the youtube channel "Make Your Pet" to build my own custom hexapod robot that could roam around my dorm room and interact with my roommates.
This summer I found myself with a lot of free time on my hands and wanted to actually learn ROS2 in a hands-on way by doing a project with it!
I'd done a bit of work the previous year with a simpler robot (the "CACTI" cheetah ball robot), but wanted to do something more complex that would really challenge me to learn new skills. The onboard computer for this project is a Raspberry Pi, which was substantially more powerful than the Arduino I used for CACTI, so I was excited to leverage that extra compute power to do some computer vision and reinforcement learning.
I decided on a hexapod robot because I liked the idea of a multi-legged platform that could navigate complex terrain, and also because I thought it would be fun to build a robot pet to annoy my roommates with.
My goal with this project is to learn ROS2, computer vision, and reinforcement learning by building a robot that can autonomously navigate my dorm room and interact with its environment.
Before diving into the build, I spent a few weeks researching hexapod kinematics, ROS2 architecture patterns, reinforcement learning for locomotion, and available hardware options. I used Obsidian to organize my notes into a connected knowledge graph, linking concepts across topics like inverse kinematics, sim-to-real transfer, sensor fusion, and mechanical design constraints.
My general philosophy towards this project was always that I wanted this to be a learning experience first and foremost, and my favorite way of learning something is to start with an end goal and work backwards. This meant I dove headfirst into the project with only a rough idea of what I wanted to build and a lot of questions about how to actually do it, and then spent a lot of time doing research and learning as I went along. I think this approach is really effective for me because it keeps me motivated and engaged with the project, and allows me to learn in a more hands-on way by immediately applying new concepts to the project as I learn them.
This research phase helped me identify the key technical challenges early on and informed a lot of the design decisions I made later, like choosing ROS2 over a simpler framework and prioritizing modularity in the software architecture so I could iterate quickly on individual components.
The main research concept of this project is: Emergent Complexity. How can we design a system that has 'character' without a strict set of preprogrammed behaviors? Inspired heavily by the way the video game Rain World handles its dynamic creature simulations.
Primary Goals: Functional Hardware Platform with variety of sensors and actuators; Interesting emergent behaviors via RL-based locomotion and interaction policies.
Technical Approach: ROS2-based software architecture; Simple hardware design using off-the-shelf components; Fun aesthetic design
Success Metrics: While the end result of the project is somewhat less important to me than the learning process, I will consider the project a full success if I am able to achieve the following:
The robot is a custom-built hexapod with 18 degrees of freedom (3 per leg) designed to be a functional and visually interesting platform for testing my locomotion and perception software. The mechanical design and pallete are both inspired by the angular aesthetics of several of my favorite fictional robots, such as BB-8 from Star Wars and the crab-like robots from Horizon: Zero Dawn.
The hardware design is intentionally simple and modular, using off-the-shelf components like the MG996R servos for actuation, a Servo2040 microcontroller for control and calibration, and a Raspberry Pi for onboard computation. The legs are designed to be easily replaceable, allowing for quick iteration on the mechanical design as I test different configurations and gaits.
The software is generally designed to be modular and flexible, to make updates and experinentation easier as I learn more about ROS2 and robotics system design.
The software architecture is built on ROS2, with a focus on modularity and flexibility. The main components of the software system include the low-level control node for servo actuation, a perception node for processing camera input and estimating the robot's state, and a reinforcement learning node that learns locomotion policies in simulation and transfers them to the real robot.
My Reinforcement Learning Pipeline is basically copied directly from my work on the Rice Robotics Quadruped - our system there is generalized enough to be easily adapted to the hexapod platform. The main idea is to use the Genesis simulator to train a locomotion policy in a simplified environment, using a reward function that encourages efficient and stable movement. The trained policy is then transferred to the real robot, where I can test its performance and make adjustments as needed.
Making the jump from simulation to reality is something I am quite curious about. I have not made it to the point of testing the sim-to-real transfer yet, but I am interested to see how well the policies trained in simulation will perform on the real robot, and what adjustments I will need to make to account for the differences between the sim and real environments. Adjusting a neural network is not as simple as adjusting a traditional control policy, so I am interested to see how I can iterate on the policy design and reward function to achieve better performance on the real robot without as much direct control over its behavior.
For perception, I am using a simple RGB camera mounted on the front of the robot along with a 1-axis YLIDAR module for depth sensing. The perception node processes the camera input to estimate the robot's state and its environment, which is then used by the RL policy for decision making.
I am still in the early stages of developing the perception system, but I am interested to see how well I can integrate the camera and LIDAR data to create a useful representation of the robot's surroundings for navigation and interaction.
My goal is ultimately to provide it with enough data for it to make decisions autonomously on where to move and how to interact with objects in the environment, but that is obviously a massive goal and one I am currently taking very small steps towards!
The project is currently in the hardware development and sofware prototyping phase. I have a general concept for the electrical, mechanical, and software design, but have not yet completed a working prototype for any of them.
Electrical-systems wise, I have all of the major components and have successfully set up communications between the Pi, the Microcontroller, and the sensor suite but need to design a power distribution board to fix some issues I'm having with the battery USB port providing insufficient power to my digital components.
Mechanically, I have a basic design for the full robot and have successfully 3D printed a few of the components, but need to adjust the sizing and figure out how how to securely mount the electronics and servos to the 3D-printed frame without damaging them. The exact length of the leg segments will also likely need iteration depending on how much torque the servos can provide.
Software-wise, I have set up the basic ROS2 architecture and have successfully implemented low-level control of the servos and basic processing of the camera, IMU, and LIDAR input, but have not yet implemented any of the reinforcement learning components or done any work on the perception system beyond basic views of the sensor feeds in a web interface. My next steps on the software side are to implement a simple RL training pipeline in simulation and start testing some basic locomotion policies on the real robot. I would also like to implement a SLAM system using the camera and LIDAR data to enable the robot to build a map of its environment and localize itself within that map, which I think would be a really fun feature to have and would also provide a lot of useful information for the RL policy to use for decision making.
This has been my first project with ROS2 and reinforcement learning, so I have been learning a lot as I go and am excited to continue iterating on the design and improving the robot's capabilities over time. My main focus right now is just getting a basic functional prototype up and running, but I have a lot of ideas for future improvements and features that I would like to implement as the project progresses.