Pneumatic Rover
Air-Powered Autonomous Rover · MAE 106
Final Build — 40-psi Air-Powered Autonomous Rover
Objective
The goal of this MAE 106 final project was to design, build, and program a fully autonomous rover that could navigate a constrained trench course—making a 90° entry turn and tracking down the channel—within strict time regulations and from multiple starting positions. The catch: the rover is air-powered, driven entirely by a 40-psi tire feeding a pneumatic piston, with no traditional drive motor.
My Role
I worked in a two-person team (Group 401) and owned the Electrical, Controls, and Experimental work. I integrated every electrical and pneumatic subsystem, authored the C++ control code that makes the rover autonomous, and ran the controlled experiments that optimized propulsion performance. I also contributed to mechanical assembly and testing throughout.
SolidWorks CAD (Side Profile)
Final Rover (Side Profile)Rover at a Glance
Core Contributions
Electrical & Pneumatic Integration
Integrated all electrical and pneumatic systems—activating a solenoid (propulsion) and servo (steering), and reading a limit switch and magnetometer (position). The build wired together a MOSFET, battery, Arduino, a 40-psi tire, and multiple Teflon-sealed valves.
Autonomous Control Software (C++)
Led development of the C++ code that drives the rover through the course within time regulations from different starting positions. It fuses a magnetometer, a digital filter, and feedback control for heading, and uses a cam–limit-switch system for position.
Propulsion Design & Optimization
Designed, assembled, and iteratively refined the hopper propulsion system. Ran controlled experiments to optimize piston actuation timing, yielding a 233% increase in range.
Testing & Assembly
Contributed to mechanical assembly and ran the controlled test campaign—10 runs per firing setup at a fixed 40 psi—to characterize and tune the rover before competition.
Electrical Integration
A single Arduino UNO orchestrates every actuator and sensor on the rover. The piston solenoid is switched through a MOSFETso the microcontroller's logic-level pin can gate the high-current 12 V propulsion circuit, while a 25 kg servo drives the steering rack directly off a PWM pin.
For feedback, the Arduino reads a magnetometer (heading, over I²C) and a cam-driven limit switch (wheel ticks for distance). A 12 V battery powers the system and is stepped down to 6 V for the servo. I handled all of the wiring, soldering, and bring-up of these subsystems.
Pneumatic Power Path
A standard tire pumped to 40 psiacts as the rover's onboard air reservoir. Air routes through a safety / fill valve and a network of Teflon-sealed valves into the solenoid, which gates the supply to the piston.
When the code drives the solenoid HIGH, air extends the piston; when it drops LOW, a return spring retracts it. Rapidly cycling this valve is exactly what the control software tunes to produce forward motion—covered in the propulsion section below.
Sensing, Filtering & Feedback
The rover has no map and no remote control—it reasons about the world from two signals. A magnetometer, fused with an IMU for tilt compensation, yields an absolute heading, while a cam-driven limit switch counts wheel ticks to estimate distance traveled.
Raw magnetometer readings are noisy, so the heading is smoothed with a single-pole digital low-pass filter before it ever reaches the controller. A proportional feedback law then maps the heading error into a servo command, steering the rover back toward the target channel heading.
Finite-State Mission Logic
The course is handled by a finite-state machine. Each loop reads the sensors, updates the filtered heading and tick count, then runs the active state—letting the same code start from different positions and still complete the run on time.
Wait
Hold motionless through the mandatory start delay (~15 s) before any actuation is allowed.
Drive Straight
Pulse the solenoid on a fixed interval to launch the rover straight out of the start box.
Turn In
Use proportional feedback on the filtered heading to rotate ~90° onto the channel heading, then settle within an acceptable error band.
Track Channel
Continue firing while a lower-gain proportional law keeps the rover centered down the trench.
Stop
Cut propulsion once the run timer expires, ending the attempt safely within regulations.
Heading Estimation & Control Law
A condensed look at the core control path: tilt-compensated heading, tick-based odometry, the low-pass filter, and the proportional steering law that runs every loop.
// --- Tilt-compensated heading: magnetometer + IMU ---
float heading = computeHeading(); // atan2 of E/N projection
filteredHeading = averagingFilter(heading, filterStrength);
// --- Cam + limit-switch odometry (distance from wheel ticks) ---
distanceTraveled = 3.1416 * 0.137795 * n_ticks; // 2*pi*r * tick/2
// --- Single-pole digital low-pass filter ---
float averagingFilter(float x, float k) {
float y = (1 - k) * x + k * filteredSignal_previous;
filteredSignal_previous = y;
return y;
}
// --- Proportional steering toward the channel heading (North) ---
if (filteredHeading > north && filteredHeading < south) {
errorCase4 = 70.0 / (south - north) * (filteredHeading - north);
turnAmount = 90 - Kp * errorCase4; // steer one direction
} else {
errorCase4 = 70.0 / (360 - south + north) * (north - filteredHeading);
turnAmount = 90 + Kp * errorCase4; // steer the other
}
myservo.write(constrain(turnAmount, 20, 160));Excerpt — Arduino / C++ control loop
The Hopper
With no drive motor, forward motion comes entirely from the piston. I settled on a hopper design: the piston is mounted at -35° from horizontal with a rubber stopper on its tip. Each firing pushes the rover forward and slightly up; a return spring resets the stroke. The shallow angle and tuned timing keep the rover from tipping while still generating real thrust.
The original one-way-bearing concept couldn't move the rover more than ~5 ft. After redesigning around the hopper and tuning its actuation, the rover covered 16 ft in testing and reliably cleared the first checkpoint in competition.
Optimizing Piston Timing
I treated average speed as the performance criterion and ran a controlled experiment varying the piston's ON and OFFfiring intervals (10 runs per setup, tire held at 40 psi). Symmetric 1 s / 1 s timing netted 0 ft/s—the rover hopped forward, then bounced back. Tightening both intervals to 0.1 s produced the peak 2.84 ft/s.
The fastest setup wasn't the best race setup: high speed traded against distance and consistency (its run-to-run standard deviation was the largest). For the competition I chose a steadier setup that balanced speed, range, and repeatability. Altogether, the redesign and timing optimization delivered a 233% increase in range.
The measured impulse response—a staircase in position and a sawtooth in velocity—tracks a MATLAB simulation closely. Discrepancies trace mainly to the rover hopping off the ground (so the limit switch under-counts ticks) and to tire pressure sagging with each successive fire.
Outcome
With no drive motor, every foot of travel came from the piston. The original one-way-bearing concept couldn't move the rover more than ~5 ft. After redesigning around the hopper and tuning its firing intervals, the rover covered 16 ft in testing and reliably cleared the first checkpoint in competition.
The fastest setup wasn't the best race setup: peak speed traded against distance and run-to-run consistency. For the competition I chose a steadier configuration that balanced speed, range, and repeatability. Altogether the redesign and timing optimization delivered a 233% increase in range.
The most rewarding part was getting a fully autonomous, air-powered vehicle—no map, no remote—to reason from just a magnetometer and wheel ticks and complete the run on time.
By the Numbers
MAE 106 · Electrical · Controls · Experimental