Rocker-Bogie Rover: Build, Stereo Vision & ROS

Learning Goal: Construct a six-wheeled rocker-bogie Mars rover chassis, derive and program its 6-wheel steering kinematics, and implement autonomous obstacle negotiation using stereo-vision depth mapping and 3D point cloud processing.

Prerequisites

Mathematics: Basic vector calculus, coordinate transformations (homogeneous matrices), and trigonometry.
Programming: Intermediate Python (with NumPy) and basic C++ (for Arduino/ESP32 firmware).
Software Tools: Familiarity with Autodesk Fusion 360, OpenCV basics, and terminal-level Linux/ROS operations.
Hardware Requirements: Access to a 3D printer, DC motors with encoders, steering servos, a PCA9685 PWM controller, an Arduino/ESP32, and two synchronized USB cameras or a custom stereo module.

Estimated Total Study Time

48 Hours (including hands-on design, electrical prototyping, and software configuration).

Module 1: Physics and Kinematics of Rocker-Bogie Suspension

Understand the mechanical advantages, passive suspension physics, and weight distribution of the six-wheeled rocker-bogie mechanism. This module establishes why this specific geometry is favored for planetary exploration, detailing how it maintains traction without springs.

Knowledge Checkpoint

Define why a rocker-bogie suspension system does not utilize standard springs or shocks, and state the mechanical advantage of this choice.
Calculate how the motion of the left rocker is transferred to the right rocker via the differential bar (averaging mechanism) to stabilize the chassis pitch.
Explain the maximum vertical obstacle clearance height of a rocker-bogie chassis in relation to its wheel diameter.
Detail the physical load distribution change across all six wheels when the front wheel begins climbing an incline.

Module 2: CAD Design, 3D Printing, and Assembly

Translate physics into physical form. Design a custom, scale rocker-bogie suspension frame in Fusion 360, manage mechanical joint tolerances, apply structural reinforcements, and prepare parts for 3D printing.

Knowledge Checkpoint

Create a kinematic sketch in Fusion 360 showing the relative pivot locations of the rocker and bogie joints, verifying joint clearance through its entire motion range.
Determine the correct horizontal clearance (tolerances) for 3D-printed joint models to house deep-groove ball bearings without press-fit slipping.
Explain how print orientation affects the shear strength of the primary pivot pins (layer alignment vs. torsional stress direction).
Implement a mechanical design for the central differential pivot joint that connects the averaging bar to both the left and right rockers.

Module 3: Actuators, Power, and Microcontroller Integration

Implement control systems, power distribution, and actuation. This module deals with high-torque motor drivers, I2C PWM controllers, and the math/code needed to coordinate 6-wheel steering.

Core Concept: 6-Wheel Steering Kinematics

Standard 2WD or 4WD skid-steer setups drag wheels sideways during turns. A rocker-bogie system utilizes 4 independent corner steering servos and 6 drive motors to pivot cleanly. To avoid wheel slippage (scrubbing), you must program Ackerman Steering Kinematics extended for 6 wheels.

For any given turn angle, the rotation axes of all six wheels must intersect at a single point: the Instantaneous Center of Rotation (ICR).

   ICR (Instantaneous Center of Rotation)
    x ----------------------------------------
                            |                |
                            |                |
                      [Wheel Left Front]   [Wheel Right Front]
                         (Angle: θ_LF)        (Angle: θ_RF)
                            |                |
                            |                |
                      [Wheel Left Mid]     [Wheel Right Mid]
                         (Angle: 0)           (Angle: 0)
                            |                |
                            |                |
                      [Wheel Left Rear]    [Wheel Right Rear]
                         (Angle: θ_LR)        (Angle: θ_RR)

If the center-line wheel-to-wheel distance along the length is $L$ (front-to-mid, and mid-to-rear) and the lateral width distance is $W$ :

Calculate the turning radius $R$ of the non-steering middle wheels from the center axis.
Derive Steering Angles ( $\theta$ ): $\theta_{\text{front-inner}} = \tan^{-1}\left(\frac{L}{R - W/2}\right)$ $\theta_{\text{front-outer}} = \tan^{-1}\left(\frac{L}{R + W/2}\right)$
Derive Drive Wheel Velocities ( $v$ ): Because the wheels sit at different radial distances from the ICR, outer wheels must spin faster than inner wheels: $v_i = \omega \times \sqrt{d_{y,i}^2 + (R \pm W/2)^2}$ where $d_{y,i}$ is the longitudinal distance from the mid-wheel line, and $\omega$ is the target yaw rate.

Knowledge Checkpoint

Connect and configure the PCA9685 module over an I2C bus, setting the master frequency to 50Hz for standard analog/digital steering servos.
Write a C++/Python function that inputs a target robot turning radius $R$ and outputs individual target angles for each of the four corner steering servos using Ackerman kinematics.
Calculate the specific velocity scaling factors for the middle and outer wheels during a tight turn of radius $R = 1.0\text{ meter}$ .
Create a circuit wiring diagram that correctly isolates high-current motor power from logic power, preventing microcontroller brownouts during stall currents.

Module 4: Stereo Vision and Depth Map Generation

To navigate autonomously, the rover requires local 3D perception. This module covers setting up a synchronized stereo camera rig, calibrating camera parameters, and writing software in Python to calculate disparity maps.

Mathematical Underpinnings: Disparity to Depth

Stereo cameras mimic human binocular vision. By aligning two parallel cameras separated by a baseline distance ( $B$ ), we can calculate the depth ( $Z$ ) of any point based on its pixel shift (disparity, $d$ ) between the two images.

              Left Camera Center        Right Camera Center
                     O_L                       O_R
                      x ----------------------- x
                      |            B            |
                      |                         |
                      |----\               /----|
                      |     \             /     |
                      |      \   Point   /      |
                      |       \    P    /       |
                      |        \ (X,Y,Z)       |
                      |         \      /        |

Left Image Plane: |--[u_l]-------/ | Right Image Plane: |------------[u_r]-------|

The projection formulas are: $x_l = f \frac{X}{Z}, \quad x_r = f \frac{X - B}{Z}$

The horizontal shift between corresponding projection points is called disparity ( $d$ ): $d = u_l - u_r = f \frac{B}{Z}$

Thus, depth $Z$ can be solved as: $Z = \frac{f \times B}{d}$

Where:

$f$ is the camera focal length (calibrated in pixels).
$B$ is the baseline physical separation distance between camera sensors.
$d$ is the disparity (pixel difference).

Knowledge Checkpoint

Perform a checkerboard camera calibration to acquire focal length ( $f_x, f_y$ ) and principal point ( $c_x, c_y$ ) values.
Write an OpenCV Python script that rectifies raw left and right camera frames using calibration files so that epipolar lines are perfectly horizontal.
Explain the inverse relationship between disparity ( $d$ ) and depth ( $Z$ ). What happens to the depth estimation accuracy as the object moves far away?
Configure the parameter inputs for StereoSGBM (such as minDisparity, numDisparities, blockSize, and smoothness penalties P1 and P2) to minimize noise in the depth map.

Module 5: Point Cloud Processing (PCL)

Convert flat 2D depth frames into rich, spatial 3D point cloud coordinates. Isolate the traversable ground plane from vertical obstacles using geometric segmentation algorithms.

Step-by-Step Pipeline: Depth Map to Point Cloud

To convert an OpenCV depth image back to a physical 3D point cloud ( $X, Y, Z$ ), apply the inverse camera pinhole model to every pixel coordinate ( $u, v$ ) holding a valid depth value $Z$ :

Calculate Coordinate Transforms: $X = \frac{(u - c_x) \times Z}{f_x}$ $Y = \frac{(v - c_y) \times Z}{f_y}$ $Z = \text{Depth value at } (u,v)$
Compile Vector Matrix: Group these calculated $[X, Y, Z]^T$ coordinates together into a standard unstructured Point Cloud Array.
Execute Ground Plane Extraction (RANSAC): The RANSAC (Random Sample Consensus) algorithm iteratively models a ground plane equation: $A_x + B_y + C_z + D = 0$
- Step 1: Randomly select three sample points from the point cloud.
- Step 2: Compute the plane parameters $[A, B, C, D]$ .
- Step 3: Count the number of total points (inliers) that lie within a threshold distance ( $\epsilon$ ) of this plane.
- Step 4: Repeat for $N$ iterations; the plane equation that achieves the maximum number of inliers is classified as the Ground Plane.
- Step 5: Subtract the ground points. The remaining points with coordinates above the plane are segmented as Obstacles.
Obstacle Points (High Height) * * *
------------------------------------------------- [Threshold height ε] Ground Plane Inliers (RANSAC) . . . . . .

Knowledge Checkpoint

Write a custom Python function to generate point cloud coordinates ( $X, Y, Z$ ) from an OpenCV depth frame, using a vector-mapped NumPy algorithm rather than slow pixel-by-pixel loops.
Install the Open3D/PCL library and verify point cloud loading and display capabilities using standard PLY/PCD formats.
Write a script to isolate the ground plane from a 3D scene using a custom RANSAC plane-segmentation loop, outputting the remaining obstacle-only points.
Implement voxel grid downsampling on a raw point cloud to reduce computational load without losing critical obstacle boundaries.

Module 6: Autonomous Path Planning and Obstacle Avoidance in ROS

Integrate physical actuation, kinematic control, and 3D perception into the Robot Operating System (ROS). Feed point clouds into local costmaps to allow autonomous, collision-free obstacle negotiation.

Core Concept: Custom Point Cloud Costmap Integration

The ROS Navigation Stack (Move Base / Nav2) handles obstacle avoidance using 2D or 3D costmaps. To feed custom point clouds (sensor_msgs/PointCloud2) directly into costmaps for local path planning:

              [Custom Stereo Vision Node]
                           |
               (sensor_msgs/PointCloud2)
                           |
                           v
                 [ROS Navigation Node]
               (Costmap_2D Obstacle Layer)
                           |
         /-----------------+-----------------\
        |                                     |
        v                                     v
 [Local Costmap]                      [Global Costmap]

(Dynamic local obstacles) (Static base map files) | | -----------------+-----------------/ | v [Local Path Planner] (e.g., DWA / TEB) | (geometry_msgs/Twist) | v [6-Wheel Steering Controller]

Configure the Obstacle Layer inside your local costmap configuration YAML parameters file:

local_costmap:
  obstacle_layer:
    observation_sources: stereo_cloud
    stereo_cloud:
      sensor_frame: camera_link
      data_type: PointCloud2
      topic: /stereo_camera/point_cloud
      marking: true
      clearing: true
      min_obstacle_height: 0.1
      max_obstacle_height: 1.0
      obstacle_range: 2.5
      raytrace_range: 3.0

Execute Obstacle Processing: Setting marking: true inserts points within the height threshold into the grid as lethal navigation barriers. Setting clearing: true clears barriers when the sensor's line-of-sight passes through that space without hitting anything.
Generate Velocity Commands: The local path planner (like DWA or TEB) tracks these costmap updates and outputs target linear/angular velocities (geometry_msgs/Twist).
Distribute Kinematics: The custom motor controller driver intercepts this command and runs the 6-wheel Ackerman equations to move the rover safely around obstacles.

Knowledge Checkpoint

Launch the ROS Navigation core and verify that custom coordinate frames (such as odom, base_link, and camera_link) are correctly linked in your TF transform tree.
Configure the local costmap configuration file to subscribe to /stereo_camera/point_cloud as an active obstacle observation source.
Write a custom ROS subscriber node that takes in standard /cmd_vel (Twist) commands and publishes matching wheel speed and steering angle configurations to your actuators.
Tune costmap inflation radius values to ensure the six-wheeled rover maintains a safe physical clearance distance from obstacles.

Course Map

Key People Index

Donald Bickler
- Context: The principal mechanical engineer at NASA JPL who invented and patented the rocker-bogie suspension system, facilitating NASA's planetary exploration beginning with the Sojourner rover.
Cyrill Stachniss
- Context: Renowned robotics professor and researcher specializing in mobile robotics, photogrammetry, mapping, and SLAM. His educational lectures serve as the industry baseline for mathematical algorithms like RANSAC.
Nicolai (NicolaiAI)
- Context: Practical robotics engineer and computer vision educator whose detailed guides walk developers through camera calibration, rectification, and block matching in OpenCV.
James Bruton
- Context: Creative robotics developer and former toy designer who builds and documents complex, open-source mechanical systems, motor configurations, and ROS integrations.

Final Self-Assessment

Complete this comprehensive self-assessment to verify your mastery of the rocker-bogie autonomous navigation pipeline:

Structural Assembly: Construct a physical 6-wheeled rocker-bogie chassis where all joint pivots swing freely and the central differential bar balances rocker pitch changes.
Actuation Control: Connect all six drive motors and four corner steering servos to your controller via the PCA9685, verifying that each joint can be addressed individually.
Kinematic Logic: Implement the mathematical 6-wheel Ackerman equations in firmware so that steering angles adjust relative to a target Instantaneous Center of Rotation (ICR) without any wheel drag.
Camera Calibration: Calibrate a dual-camera setup using chessboard-pattern targets, achieving a projection reprojection error under 0.5 pixels.
Depth Reconstruction: Write a Python script to compute stereo disparity maps in real-time, outputting clean depth measurements of nearby objects.
Point Cloud Conversion: Convert depth maps to structured 3D coordinates ( $X, Y, Z$ ) using coordinate transform projection matrices.
RANSAC Segmentation: Apply the RANSAC algorithm to segment the ground plane, successfully separating flat, traversable ground from high-elevation obstacles.
Costmap Population: Feed your obstacle-only point cloud directly into the ROS local costmap as a /sensor_msgs/PointCloud2 topic, marking obstacle coordinates as navigation barriers.
Closed-Loop Navigation: Send a navigation target coordinate to the ROS navigation stack and verify that the rover calculates a safe path, commands steering servos, and navigates around obstacles without colliding.

Explore Further

Related Robotics Roadmaps

View All→

robotics

Rocker-Bogie Rover: Build, Stereo Vision & ROS

Prerequisites

Estimated Total Study Time

Module 1: Physics and Kinematics of Rocker-Bogie Suspension

Recommended Videos

Knowledge Checkpoint

Module 2: CAD Design, 3D Printing, and Assembly

Recommended Videos

Knowledge Checkpoint

Module 3: Actuators, Power, and Microcontroller Integration

Core Concept: 6-Wheel Steering Kinematics

Recommended Videos

Knowledge Checkpoint

Module 4: Stereo Vision and Depth Map Generation

Mathematical Underpinnings: Disparity to Depth

Recommended Videos

Knowledge Checkpoint

Module 5: Point Cloud Processing (PCL)

Step-by-Step Pipeline: Depth Map to Point Cloud

Recommended Videos

Knowledge Checkpoint

Module 6: Autonomous Path Planning and Obstacle Avoidance in ROS

Core Concept: Custom Point Cloud Costmap Integration

Recommended Videos

Knowledge Checkpoint

Course Map

Key People Index

Final Self-Assessment

Related Robotics Roadmaps

CDPR: Kinematics, Arduino & Winch Control

Building AGVs: QR Navigation & Lifter Systems

EMG Exoskeletons: Design, Control & Actuation

VR Digital Twins: Unity, ROS & Teleoperation