Skip to content
TechMonster™

Robotics & Humanoid Systems Engineering

Make C++ move in the physical world.

Make C++ move in the physical world. This is the robotics specialization: you build the real-time stack behind humanoid and mobile robots — the rotation math and kinematics that place a limb where you want it, the dynamics and classical control (PID through MPC) that make it move stably, the Kalman-filter state estimation and sensor fusion that tell the robot where it is, the perception and SLAM that let it see and map, the ROS 2 / embedded / real-time-Linux software layer (with CAN and EtherCAT to the actuators), and finally physics simulation plus the learning layer (RL, imitation, and vision-language-action policies) that increasingly drives modern humanoids. The capstone trains and deploys a locomotion or manipulation policy in simulation with a C++ control loop — no hardware required. Built on the C++ and systems foundations of the program, this is Branch C of the Zero-to-Low-Level-Systems-Elite path — covering the C++ robotics software used in humanoid and mobile robots.

6 phases · 48 projects · v1.1.0

Target roles: Robotics Software Engineer, Humanoid / Controls Engineer, Perception / SLAM Engineer, Embedded Robotics Engineer

Stack: C++17/20, Eigen, ROS 2, Python, MuJoCo / GPU-accelerated simulators

PHASE 1 · 8 projects

Robot Math & Kinematics

Place a robot in space: coordinate frames, rotations (matrices and quaternions), homogeneous transforms, forward and inverse kinematics, and Jacobians — implemented with Eigen.

  1. 01 · featured

    Coordinate Frames & Points

    Build intuition for coordinate frames — world, body, and sensor — by representing 3D points with Eigen::Vector3d, applying (R, t) transforms to move points between frames, and chaining transforms across a camera→body→world sensor pipeline.

    C++20 · Eigen · g++

  2. 02 · featured

    Rotations in 2D & Rotation Matrices

    Derive the 2D rotation matrix from first principles, verify its SO(2) properties (orthogonality, det=1, inverse=transpose) using Eigen::Matrix2d, compose rotations, and preview why 3D rotations do not commute.

    C++20 · Eigen · g++

  3. 03 · featured

    3D Rotations: Matrices, Euler Angles & Axis-Angle

    Build the SO(3) elementary rotation matrices (Rx, Ry, Rz), compose ZYX Euler angles, demonstrate gimbal lock numerically, and implement Rodrigues' rotation formula — then use Eigen::AngleAxisd to verify and convert between all three representations.

    C++20 · Eigen · g++

  4. 04 · featured

    Quaternions

    Build unit quaternions from axis-angle, rotate vectors with the sandwich product, compose rotations via quaternion multiplication, interpolate orientations with SLERP, and convert between all representations using Eigen::Quaterniond.

    C++20 · Eigen · g++

  5. 05 · featured

    Homogeneous Transforms (SE(3))

    Construct 4×4 SE(3) homogeneous transform matrices, transform points and free vectors using homogeneous coordinates, compose multi-frame chains by matrix multiplication, compute analytical inverses, and use Eigen::Isometry3d for clean rigid-body transform operations.

    C++20 · Eigen · g++

  6. 06 · featured

    Forward Kinematics

    Implement Denavit-Hartenberg (DH) forward kinematics for a 3-DOF planar arm and a 6-DOF serial arm using Eigen::Isometry3d chains, verify at zero config and known analytical poses, and build geometric invariant tests.

    C++20 · Eigen · g++

  7. 07 · featured

    Inverse Kinematics

    Implement analytical IK (law of cosines, elbow-up/down) for a 2-link arm and Jacobian-based numerical IK (Newton's method + damped least squares) for a 3-DOF arm, demonstrating multiple solutions, singularity detection, and the tradeoff of the damping parameter.

    C++20 · Eigen · g++

  8. 08 · featured

    Jacobians & a Kinematics Lab

    Derive and implement the geometric Jacobian analytically from FK joint frames, verify it against numerical finite differences, use SVD for singularity detection, and run a complete kinematics lab tracking a circular trajectory with FK + IK + Jacobian-based velocity control end-to-end.

    C++20 · Eigen · g++

PHASE 2 · 8 projects

Dynamics & Classical Control

Make it move stably: rigid-body dynamics, the control loop, PID control, state-space models, stability, and trajectory generation.

  1. 01 · featured

    The Control Loop

    Build and instrument a discrete-time sense–think–act control loop in C++, comparing open-loop vs closed-loop feedback on a simulated robot joint.

    C++17 · chrono · control theory

  2. 02 · featured

    PID Control

    Implement a full discrete-time PID controller in C++ with anti-windup and derivative-kick prevention, and tune it on a simulated 1-DOF mass-damper system.

    C++17 · control theory · numerical simulation

  3. 03 · featured

    Rigid-Body Dynamics

    Derive and simulate pendulum and cart equations of motion in C++ using Euler and RK4 integration, and verify correctness with an energy conservation check.

    C++17 · numerical integration · classical mechanics

  4. 04 · featured

    State-Space Models

    Represent cart and cart-pole systems in state-space form (ẋ = Ax + Bu), discretize them, simulate with Eigen, and analyze stability via eigenvalues of A.

    C++17 · Eigen · linear algebra · control theory

  5. 05 · featured

    Stability & Optimal Feedback (LQR)

    Implement pole placement and an iterative DARE solver in C++ to compute LQR gains, then stabilize a 4-state cart-pole system and explore how Q and R weights shape the response.

    C++17 · Eigen · optimal control · linear algebra

  6. 06 · featured

    Trajectory Generation

    Implement trapezoidal velocity profiles and cubic/quintic polynomial splines in C++, then combine feedforward trajectory commands with PD feedback to demonstrate high-accuracy joint tracking.

    C++17 · numerical methods · control theory

  7. 07 · featured

    Multi-Joint & Cascade Control

    Simulate a 2-link planar robot arm with coupled dynamics in C++/Eigen, implement cascade position/velocity control, and demonstrate gravity compensation reducing steady-state error by 100x.

    C++17 · Eigen · robot dynamics · control theory

  8. 08 · featured

    Control Lab: Balance the Cart-Pole

    Phase 2 capstone: simulate the full nonlinear cart-pole in C++/Eigen with RK4, design and tune both a PID and an LQR controller, close the loop, and measure settling time, steady-state error, and disturbance recovery.

    C++17 · Eigen · control theory · LQR · PID · simulation

PHASE 3 · 8 projects

State Estimation & Sensor Fusion

Know where you are despite noise: sensors and noise models, the Kalman filter and EKF, sensor fusion, and localization.

  1. 01 · featured

    Sensors & Noise

    Simulate IMU, wheel-encoder, and lidar sensors with realistic Gaussian noise, bias, and drift; measure RMSE against ground truth to understand why raw sensor readings are insufficient for robot state estimation.

    C++17 · Eigen · C++ STL <random>

  2. 02 · featured

    Probability for Estimation

    Implement the Bayesian predict-update cycle from scratch using Gaussian beliefs, computing Kalman gain and fusing two independent sensor measurements to show how uncertainty shrinks with each observation.

    C++17 · Eigen · C++ STL <random>

  3. 03 · featured

    The Kalman Filter

    Implement the five Kalman filter equations in C++/Eigen: a scalar 1-D filter for a constant signal and a 2-D constant-velocity tracker that infers unmeasured velocity from noisy position observations.

    C++17 · Eigen

  4. 04 · featured

    The Extended Kalman Filter

    Implement an EKF for 2-D robot pose estimation with unicycle kinematics and range-bearing landmark measurements, deriving and coding the motion and measurement Jacobians by hand.

    C++17 · Eigen

  5. 05 · featured

    IMU & Orientation Estimation

    Simulate gyroscope drift and accelerometer tilt estimation, then implement the complementary filter to fuse both sensors; compare RMSE to show the fused estimate beats either sensor alone.

    C++17 · Eigen · C++ STL <random>

  6. 06 · featured

    Multi-Sensor Fusion

    Fuse wheel odometry (20 Hz) and GPS (2 Hz) in an asynchronous Kalman filter with a shared 4-D state vector, demonstrating that adding a noisier sensor still reduces overall RMSE.

    C++17 · Eigen

  7. 07 · featured

    Localization

    Implement EKF localisation and a Monte Carlo particle filter (MCL) on a 5-landmark map; simulate the kidnapped robot problem and show the particle filter recovering in under 10 steps while the EKF diverges.

    C++17 · Eigen · C++ STL <random>

  8. 08 · featured

    Estimation Lab: Track a Moving Robot

    Phase finale: fuse simulated noisy odometry and range-bearing measurements in a complete EKF to track a robot driving a figure-eight trajectory; produce an ASCII plot of estimate vs ground truth and report RMS position and heading error.

    C++17 · Eigen

PHASE 4 · 8 projects

Perception & SLAM

See and map the world: computer vision for robots, depth and point clouds, visual odometry, SLAM, and detection for manipulation.

  1. 01 · featured

    Images & Computer Vision Basics

    Learn to represent camera frames as NumPy arrays, apply color-space conversions, Gaussian blurring, Sobel/Canny edge detection, and thresholding — building the image-processing foundation every robot perception pipeline depends on.

    Python · OpenCV · NumPy

  2. 02 · featured

    Feature Detection & Matching

    Detect Harris corners, extract ORB keypoints and binary descriptors, match them across image pairs with Lowe's ratio test, and apply RANSAC to filter geometrically inconsistent outliers — building the front-end of a Visual Odometry / SLAM pipeline.

    Python · OpenCV · NumPy

  3. 03 · featured

    Camera Geometry & Calibration

    Implement the pinhole projection equation and intrinsic matrix K, model radial lens distortion, simulate Zhang's chessboard calibration procedure, and back-project pixels to 3D rays — mastering the geometric model every robot vision pipeline depends on.

    Python · OpenCV · NumPy

  4. 04 · featured

    Depth & Point Clouds

    Derive the stereo disparity-to-depth equation, compute a depth map from a synthetic stereo pair using StereoBM, back-project a depth image to a 3D point cloud, and apply voxel downsampling, rigid transformation, and surface normal estimation.

    Python · OpenCV · NumPy

  5. 05 · featured

    Visual Odometry

    Implement a monocular Visual Odometry pipeline on a synthetic frame sequence: feature tracking, Essential Matrix estimation, pose chaining, and trajectory drift analysis — connecting the theory of camera geometry to an end-to-end running VO system.

    Python · OpenCV · NumPy

  6. 06 · featured

    SLAM: Simultaneous Localization and Mapping

    Understand the SLAM problem (chicken-and-egg, front-end/back-end split, loop closure), implement a 2D pose-graph with odometry and loop closure edges, run gradient-descent pose-graph optimization, and analyze how loop closure corrects drift.

    Python · NumPy

  7. 07 · featured

    Object Detection & Pose for Manipulation

    Implement template matching with NMS, decode a YOLO-style grid output, recover 6-DOF object pose with solvePnP from 2D–3D correspondences, and compute a gripper approach vector — completing the perception-to-grasp pipeline for robot manipulation.

    Python · OpenCV · NumPy

  8. 08 · featured

    Perception Lab: Visual Odometry / Mapping

    Assemble the whole phase into one self-grading lab: synthesize a frame sequence, run an ORB + Essential-Matrix visual-odometry pipeline, triangulate a sparse 3D map, align the estimate to ground truth with Umeyama, and report ATE-RMS — the standard accuracy metric used by KITTI, TUM-RGBD, and EuRoC. Includes an optional real KITTI-snippet path.

    Python · OpenCV · NumPy

PHASE 5 · 8 projects

Robot Software: ROS 2, Embedded & Real-Time

Build the robot's nervous system: ROS 2 nodes/topics/services/actions, simulation integration, real-time Linux, and fieldbus (CAN, EtherCAT) to the actuators.

  1. 01 · featured

    ROS 2 Architecture

    Build and run a minimal rclcpp node in a colcon workspace, then inspect the live compute graph with the ROS 2 CLI to understand nodes, DDS, and the workspace overlay.

    ROS 2 · C++ · rclcpp · colcon · ament_cmake

  2. 02 · featured

    Topics, Messages & Pub/Sub

    Implement a ROS 2 C++ talker/listener pair with standard and custom message types, then inspect live message flow with ros2 topic echo and hz while experimenting with QoS policies.

    ROS 2 · C++ · rclcpp · std_msgs · rosidl · DDS

  3. 03 · featured

    Services & Actions

    Implement a ROS 2 service server/client for synchronous battery queries and an action server/client for long-running joint motion with real-time feedback and cancellation support.

    ROS 2 · C++ · rclcpp · rclcpp_action · rosidl

  4. 04 · featured

    Robot Description & TF

    Write a two-link arm URDF, launch robot_state_publisher to broadcast its TF tree, then implement a C++ TransformBroadcaster for a moving sensor and a TransformListener that looks up the frame in real time.

    ROS 2 · C++ · URDF · tf2_ros · robot_state_publisher · RViz

  5. 05 · featured

    Simulation with Gazebo

    Spawn a diff-drive robot URDF into Gazebo Fortress, configure the ROS-Gazebo bridge for cmd_vel and IMU topics, drive the robot with velocity commands, and read simulated sensor data from a C++ subscriber node.

    ROS 2 · C++ · Gazebo Fortress · ros_gz_bridge · URDF · sensor_msgs

  6. 06 · featured

    Real-Time Linux & the Control Thread

    Write a 1 kHz C++ control loop that measures its own wakeup jitter, then elevate it to SCHED_FIFO scheduling and compare p50/p99/p99.9 latency histograms to demonstrate the impact of real-time scheduling.

    ROS 2 · C++ · Linux · PREEMPT_RT · pthread · SCHED_FIFO · clock_nanosleep

  7. 07 · featured

    Embedded & Fieldbus: CAN & EtherCAT

    Set up a virtual CAN interface, implement a C++ SocketCAN sender and receiver for simulated joint torque commands, then study the EtherCAT protocol and SOEM to understand how humanoid robots synchronize 30+ joints at 1 kHz.

    ROS 2 · C++ · SocketCAN · CAN bus · EtherCAT · SOEM · Linux

  8. 08 · featured

    ROS 2 Robot Lab

    Assemble a complete robot software stack: an odometry/IMU complementary filter node feeding a two-thread velocity controller (SCHED_FIFO RT thread + ROS 2 publisher), all launched together driving a Gazebo diff-drive robot to a goal position.

    ROS 2 · C++ · rclcpp · Gazebo · SCHED_FIFO · std::atomic · ros_gz_bridge · TF

PHASE 6 · 8 projects

Simulation, Learning & the Capstone

Bring it to life in sim: physics simulation (MuJoCo/Isaac), advanced control (MPC, whole-body), the learning layer (RL, imitation, VLA), and a deployed policy with a C++ control loop.

  1. 01 · featured

    Physics Simulation

    Install MuJoCo, author a two-link arm MJCF model, run a timed simulation loop with sinusoidal torque control, read joint state and contact forces, and measure real-time throughput.

    Python 3.10+ · MuJoCo 3.x · NumPy

  2. 02 · featured

    Model Predictive Control

    Implement a random-shooting MPC on a cart-pole balancing task in NumPy, compare against PID on large disturbances, and build the layered control architecture mental model used in production humanoid robots.

    Python 3.10+ · NumPy · SciPy

  3. 03 · featured

    Whole-Body Control for Humanoids

    Implement forward kinematics, Jacobians, ZMP balance analysis, and a prioritized task-space QP for a planar biped that simultaneously balances and reaches, capturing the mathematical core of production humanoid WBC.

    Python 3.10+ · NumPy · SciPy

  4. 04 · featured

    Reinforcement Learning for Control

    Train a PPO policy on InvertedPendulum-v4 in MuJoCo, plot the S-shaped training curve, implement a reward shaping wrapper, and understand the three RL failure modes that practitioners encounter on real robot projects.

    Python 3.10+ · MuJoCo 3.x · gymnasium · stable-baselines3 · NumPy

  5. 05 · featured

    Imitation Learning

    Collect expert PPO demonstrations, train a behavior cloning policy via supervised regression, evaluate the distributional shift gap vs the expert, implement one DAgger iteration, and understand the IL+RL combination pipeline used in modern humanoid manipulation.

    Python 3.10+ · MuJoCo 3.x · gymnasium · stable-baselines3 · PyTorch · NumPy

  6. 06 · featured

    Vision-Language-Action Models

    Implement a minimal language-conditioned policy, analyze CLIP semantic alignment, study a vision-language-action model action tokenization and π0 diffusion action heads, and understand the data/scaling story and current limitations of VLAs for humanoid manipulation.

    Python 3.10+ · PyTorch · transformers (the open model hub) · NumPy

  7. 07 · featured

    Sim-to-Real Transfer

    Implement a domain randomization wrapper for MuJoCo, train and compare nominal vs randomized policies on perturbed environments, run minimal system identification, analyze the full deploy pipeline latency budget, and measure transfer success rate.

    Python 3.10+ · MuJoCo 3.x · gymnasium · stable-baselines3 · NumPy · SciPy

  8. 08 · featured

    Sim-to-Control: A Locomotion Policy (Track Capstone)

    Build a complete quadruped simulation in MuJoCo (MJCF model, 8 DOFs, contact sensors), implement a classical PD trotting gait controller, train a PPO locomotion policy with shaped reward, evaluate and compare both on forward speed, fall rate, and Cost of Transport, then write a structured report covering the control architecture, two engineering tradeoffs, and the sim-to-real gap.

    Python 3.10+ · MuJoCo 3.x · gymnasium · stable-baselines3 · NumPy · PyTorch

Next step

Request Robotics & Humanoid Systems Engineering

An advisor reviews the fit and confirms terms in writing. A request is not an acceptance and nothing is charged until you agree.