Overview
Autonomous Romi obstacle-course robot for the ME405 final project
Team Members
John Tomas, Kaden Guevarra
Project Overview
In ME405 Mechatronics, our term project culminated in a fully integrated autonomous two-wheeled differential-drive robot based on the Pololu Romi platform. Our team built a complete mechatronic system that combined embedded hardware, real-time MicroPython firmware, cooperative task scheduling, multi-sensor instrumentation, closed-loop motor control, and observer-based state estimation into one final robot capable of navigating the printed obstacle course.
Our final Romi used a standard differential-drive base with motors and encoders, a Nucleo L476RG running MicroPython, a modified Shoe of Brian interface board, a BNO055 IMU, a QTRX-MD-07A analog reflectance sensor array, and front bumper switch assemblies. The line sensor handled most of the path tracking, the encoders supported motion control and distance-based actions, the bump sensors handled wall interaction, and the IMU with the state estimator improved heading awareness and motion prediction during turns and transitions. The result was a robot that demonstrated end-to-end capability in hardware integration, embedded software design, controls, and navigation logic.
Development Approach
Our development process emphasized modularity, repeatability, and progressive integration. Rather than building one large monolithic program at the end, we developed reusable drivers and subsystem tasks across the quarter, then combined them into the final robot. Individual work on motor control, encoder measurement, line sensing, IMU communication, bump sensing, and user interaction was gradually integrated into a larger cooperative multitask system.
This approach made it easier to verify each subsystem separately before combining them into the final navigation task. It also gave us a cleaner tuning workflow, since gains, thresholds, and motion behaviors could be adjusted while keeping the rest of the architecture intact.
Software Architecture
Our software stack was designed to be modular, readable, and scalable from early bring-up through final navigation. We implemented structured MicroPython code using classes for hardware drivers and interfaces, functions for reusable logic, and generator-based tasks to enforce periodic execution of each subsystem. Shared variables and queues provided clear boundaries between sensing, estimation, control, and decision-making tasks under a cooperative scheduler.
This organization allowed the robot to run line following, motor control, bump detection, user interaction, IMU sensing, and estimation concurrently with predictable timing. It also made debugging easier because each task had a specific responsibility and a defined data interface. As a result, the navigation layer could remain focused on commanding behaviors instead of directly managing low-level hardware details.
Hardware Integration
Our hardware work focused on building a reliable robot that could survive repeated testing and final demonstration runs. We assembled the Romi drivetrain, integrated the Nucleo and Shoe of Brian stack, wired the IMU over I2C, connected the analog line sensor array to the controller, and added front-mounted bumper switches for wall contact detection. We also used stand-offs and sensor mounting hardware to keep the reflectance sensor at an effective height above the floor for repeatable measurements during line following.
Clean wiring and practical sensor placement were important because the robot depended on multiple sensing systems at once. The final hardware layout had to preserve visibility of the line, protect the front sensor array, and support reliable access to encoder, bumper, and IMU information during autonomous motion.
Navigation Objective
The culminating deliverable of the term was a navigation task built specifically for the final obstacle course. During operation, the robot had to move through the course by switching between line following, straight segments, distance-based moves, controlled turns, bump-based wall interaction, and final alignment maneuvers. This required stable motor control underneath the higher-level navigation logic at all times.
Our final navigation implementation used a structured finite-state approach to transition between behaviors as the robot moved through the course. Instead of depending on a single one-off run, the goal was to make the robot respond consistently to real track conditions using calibrated sensing, distance estimates, heading information, and state-based decision logic.
Final Outcome
In the final demonstration, our robot successfully completed the main required course tasks with an official runtime of exactly 2:00. The completed system showed that we were able to integrate sensing, control, estimation, and navigation into one functioning embedded robot platform. Together, the pages on this site document the final hardware, software, state machines, and results of the project.
Repository
Firmware and documentation for the project are available on GitHub.