Template

Robotics Engineer — Competency Roadmap

Work towards being a robotics engineer: bringing together mechanics, electronics, control theory, perception and software so that a physical machine can sense its surroundings and act in them.

This roadmap provides a comprehensive path across the mechanical, electrical, control, software, and perception domains that define modern robotics engineering. At 12 hours per week the tasks here come to roughly four to five months of project-driven work. That covers the map; robotics rewards far more time than that in each area, and a personalised plan decides which ones deserve yours. The journey begins with core math and embedded electronics, builds up kinematic modeling and ROS 2 middleware in simulation, and culminates in physical hardware integration, SLAM, motion planning, and production-ready portfolio engineering. You will finish with fully demonstrated capabilities: a physical and simulated autonomous mobile robot pipeline, custom PCB and embedded motor drivers, and a public technical portfolio detailing your system architecture and control validation.

By the end: You will be able to design, simulate, build, and program an autonomous robotic system from scratch—integrating custom electronics, low-level microcontroller firmware, real-time control loops, ROS 2 middleware, and sensor-based SLAM and navigation.

Starting levelBeginnerStyleBuilding things
12h / week11 phases24 tasks~222h total

This is the map — make this roadmap yours

It shows what this journey generally looks like. Tell Kaidoro your version of the goal and it builds the plan around where you are actually starting, what to do first, the hours you really have, and what you have already finished.

1

Engineering Mathematics & Foundational Programming

Establish the indispensable mathematical foundations in linear algebra, calculus, and spatial representations alongside modern C++ and Python tooling.

  • Build a matrix and vector math library in modern C++
    ~8hBuild1 resource

    Robotics computations rely on spatial transformations; building your own linear algebra engine solidifies coordinate frame intuitions and C++ memory management.

    You'll learn

    • Eigen — standard C++ linear algebra template library
    • Homogeneous Transformations — 4x4 matrix representations combining 3D rotation and translation
    • CMake — cross-platform build automation toolchain
    • GoogleTest — C++ unit testing framework

    Write a lightweight 3D linear algebra library from scratch using modern C++ (C++17/20) with CMake. Implement vectors, 3x3/4x4 matrices, dot/cross products, matrix inversion, and basic transformation arithmetic without external linear algebra libraries.

    Done when: All unit tests pass using GoogleTest, validating matrix multiplication, determinants, and homogeneous coordinate transformations against known analytical solutions.

    How to work through it

    1. Set up a C++ project repository configured with CMake and GoogleTest
    2. Implement Vector3 and Matrix3x3 structs with operator overloading for standard arithmetic
    3. Implement Matrix4x4 homogeneous transformation utilities and inversion algorithms
    4. Write unit tests verifying transformation chains and edge-case matrix inversions
  • Implement rotation representations and coordinate conversions in Python
    ~6hBuild

    Quaternions avoid singularities in 3D rotation, making them the industry standard representation across robotics middleware and simulation.

    You'll learn

    • Quaternions — 4D hypercomplex numbers avoiding gimbal lock in 3D rotations
    • Gimbal Lock — loss of one degree of freedom in three-dimensional, three-gimbal mechanisms
    • SLERP — spherical linear interpolation for constant-speed rotational transitions

    Develop a standalone Python module capable of converting between Euler angles (Roll-Pitch-Yaw), Rotation Matrices, and Unit Quaternions. Include functions to detect and demonstrate gimbal lock in Euler representations, and benchmark interpolation using SLERP (Spherical Linear Interpolation).

    Done when: You can input arbitrary 3D orientations, convert losslessly across all three representations, and plot SLERP trajectory outputs with matplotlib without singularities.

    How to work through it

    1. Implement Euler angle to 3x3 rotation matrix conversions under extrinsic and intrinsic conventions
    2. Implement unit quaternion construction, normalization, and conversion to/from rotation matrices
    3. Code a SLERP function to interpolate smoothly between two 3D orientations
    4. Create a script generating 3D coordinate frame plots illustrating gimbal lock versus quaternion interpolation
  • Solve numerical differential equations for classic dynamic systems
    ~6hBuild

    Robotics physics engines and state estimators fundamentally operate as numerical integrators of continuous-time differential equations.

    You'll learn

    • Runge-Kutta Methods — family of iterative methods for numerical solutions of ODEs
    • State-Space Representation — mathematical model of a physical system as a set of input, output, and state variables
    • Energy Conservation Drift — numerical error accumulation altering simulated physical totals

    Implement numerical integration methods (Euler, Verlet, and Runge-Kutta 4th Order / RK4) in Python to simulate the physics of a simple pendulum and an inverted cart-pole. Compare integration stability, energy drift, and step-size sensitivity over time.

    Done when: The RK4 simulator outputs time-series plots showing conservation of mechanical energy over a 60-second unforced pendulum simulation.

    How to work through it

    1. Derive equations of motion for a simple unforced pendulum using Newtonian dynamics
    2. Implement Forward Euler and RK4 numerical integration functions in Python
    3. Simulate the pendulum with both methods and plot position, velocity, and total energy curves
    4. Extend the simulator to handle state-space representation of a cart-pole system
2

Embedded Systems, Actuators & Circuit Design

Develop low-level hardware fluency by interfacing microcontrollers with sensors, designing power distribution, and controlling DC/stepper motors. Can run in parallel with early software modeling.

  • Build bare-metal and RTOS motor control firmware on an STM32 or ESP32
    ~10hBuild

    Microcontrollers bridge high-level robotic computation with raw electrical signals and microsecond-critical hardware timing.

    You'll learn

    • Quadrature Encoders — incremental rotary sensors producing two out-of-phase square waves
    • H-Bridge — electronic circuit enabling voltage to be applied across a load in either direction
    • FreeRTOS — real-time operating system for microcontrollers with deterministic scheduling
    • Interrupt Service Routine (ISR) — hardware-triggered callback executing critical low-level code

    Configure an embedded microcontroller (STM32 via STM32CubeIDE or ESP32 via ESP-IDF) to control a brushed DC motor with a quadrature encoder. Set up hardware timers for PWM signal generation, external interrupt routines for encoder pulse counting, and UART communication for command parsing.

    Done when: The microcontroller receives target velocity commands over UART and maintains accurate RPM readings streamed back in real time over serial at 100 Hz.

    How to work through it

    1. Configure hardware timer peripheral for high-frequency PWM generation driving an H-bridge
    2. Set up timer quadrature decoder mode or GPIO pin interrupts to decode optical encoder ticks
    3. Implement a FreeRTOS task or non-blocking timer interrupt running at 100 Hz to compute instantaneous RPM
    4. Implement a simple serial command interpreter to accept speed targets and telemetry requests
  • Interface digital sensors over I2C and SPI buses
    ~8hBuild

    Robotics perception relies entirely on continuous, uncorrupted data streaming across standard hardware serial protocols.

    You'll learn

    • I2C Protocol — two-wire multi-master serial communication bus (SDA/SCL)
    • SPI Protocol — high-speed four-wire synchronous serial data protocol (MOSI/MISO/SCK/CS)
    • IMU Registers — hardware-level memory locations storing digital sensor readouts and settings

    Write embedded driver routines to communicate with an Inertial Measurement Unit (IMU, e.g., MPU6050 or BNO055) via I2C and an SPI device (e.g., flash memory or secondary sensor). Handle registers, bitmasks, timing clocks, and interrupt lines without relying on high-level pre-baked Arduino libraries.

    Done when: The firmware reads calibrated raw 3-axis accelerometer, gyroscope, and temperature registers at 200 Hz with verifiable zero-packet corruption.

    How to work through it

    1. Read device datasheets to map out register addresses, control bits, and read/write protocols
    2. Initialize hardware I2C peripheral and implement register write/read helper functions with error handling
    3. Configure sensor sampling rate, full-scale range (e.g. ±2g, ±250 deg/s), and internal low-pass filters
    4. Stream sensor readings to a PC logging terminal and confirm physical tilt matches accelerometer vector shifts
  • Design and assemble a power distribution and motor driver PCB in KiCad
    ~12hBuild

    Robotic prototypes frequently fail from flaky breadboards and noisy electrical power; PCB design produces reliable, noise-immune field hardware.

    You'll learn

    • KiCad — open-source electronics design automation (EDA) suite
    • Buck Converter — step-down DC-to-DC switch-mode power converter
    • Ground Plane — low-impedance common return path minimizing electrical noise on PCBs

    Design a custom schematic and two-layer printed circuit board (PCB) in KiCad for a robot power board. Include a buck converter to step down battery power (e.g., 12V LiPo to 5V/3.3V), reverse polarity protection, dual H-bridge motor drivers, and connector breakouts for sensors and microcontrollers.

    Done when: Design rule checks (DRC) pass with zero errors, Gerber files are generated, and a thermal/trace-width calculation document is finalized for 5A continuous draw.

    How to work through it

    1. Create electrical schematics with voltage regulators, decoupling capacitors, and protection diodes
    2. Select components ensuring appropriate current, voltage ratings, and package footprints
    3. Route a 2-layer PCB layout with dedicated ground planes, wide power traces, and proper component clearances
    4. Run KiCad DRC check and export manufacturing Gerber files, drill files, and BOM
3

Classical & State-Space Control Theory

Implement classical feedback control algorithms and state-space regulators on simulated and embedded systems to achieve stable, accurate trajectory tracking.

  • Implement and tune a digital PID controller with anti-windup
    ~8hBuild

    PID control remains the foundational workhorse for industrial actuators, mobile robots, and quadcopter attitude loops.

    You'll learn

    • Integrator Windup — condition where actuator saturation causes error integral to accumulate excessively
    • Derivative Kick / Filtering — techniques to smooth abrupt setpoint changes and noise in PID controllers
    • Ziegler-Nichols Method — heuristic tuning procedure for parameterizing PID loops

    Write a robust PID controller in C++ and flash it to the microcontroller to control DC motor rotational speed and position. Include derivative filtering to reject high-frequency sensor noise and integrator anti-windup clamping to prevent severe overshoot caused by actuator saturation.

    Done when: The closed-loop motor step response reaches target RPM within 200 ms with under 5% overshoot and zero steady-state error under applied mechanical friction.

    How to work through it

    1. Code the discrete PID mathematical equation with configurable proportional, integral, and derivative gains
    2. Add back-calculation or clamping integrator anti-windup logic
    3. Implement a low-pass filter on the derivative error term to attenuate encoder quantization noise
    4. Execute manual Ziegler-Nichols tuning while logging step-response data to a serial plotter
  • Build a simulated Linear Quadratic Regulator (LQR) for inverted cart-pole balance
    ~8hBuild

    State-space control and LQR represent the leap from single-input single-output (SISO) PID to multi-variable optimal control required by complex robots.

    You'll learn

    • LQR (Linear Quadratic Regulator) — optimal control algorithm balancing state error against actuation effort
    • Algebraic Riccati Equation — matrix equation whose solution yields optimal state-feedback gains
    • Controllability Matrix — algebraic test verifying whether an arbitrary state can be reached by inputs

    Linearize the nonlinear cart-pole equations around the unstable upright equilibrium, construct the continuous system state-space matrices (A, B, C, D), and solve the Algebraic Riccati Equation to compute optimal LQR gain matrix K. Simulate closed-loop response to impulse disturbances in Python.

    Done when: The simulated cart-pole recovers to the upright vertical position when disturbed by an impulse force displacing the pole by 15 degrees.

    How to work through it

    1. Linearize cart-pole nonlinear dynamics around theta = 0 using Taylor series expansion
    2. Formulate the system state vector x = [cart_pos, cart_vel, pole_angle, pole_ang_vel]^T
    3. Define state cost matrix Q and control cost matrix R, and solve the continuous Riccati equation
    4. Simulate closed-loop dynamics u = -Kx and verify stability criteria using pole placement analysis
4

Kinematics, Dynamics & Simulation Engines

Model multi-link serial manipulators and mobile robot kinematic chains mathematically, validating forward and inverse solutions inside Gazebo or Webots simulations.

  • Compute forward and inverse kinematics for a 3-DOF robotic arm
    ~8hBuild

    Kinematics maps joint actuators to physical Cartesian space—the fundamental geometry behind all robotic manipulation and locomotion.

    You'll learn

    • Denavit-Hartenberg (DH) Parameters — four parameters describing spatial relationship between two robot joints
    • Forward Kinematics — calculating tool position from known joint angles
    • Inverse Kinematics — calculating required joint angles to place tool at target position

    Derive Denavit-Hartenberg (DH) parameters for a 3-degree-of-freedom planar/spatial robotic arm. Write a Python module solving Forward Kinematics (FK) via transformation matrices and Inverse Kinematics (IK) analytically and geometrically for arbitrary end-effector targets.

    Done when: The IK solver accurately calculates joint angles for any valid (X, Y, Z) point in the workspace and identifies unreachable coordinate requests as out-of-bounds.

    How to work through it

    1. Assign coordinate frames to each link using standard Denavit-Hartenberg conventions
    2. Construct individual Homogeneous Transformation matrices and chain them to compute end-effector pose
    3. Derive closed-form geometric inverse kinematics equations for joint angles given target (X, Y, Z)
    4. Plot the arm links in 3D using matplotlib and verify end-effector reaches commanded coordinates
  • Build URDF and SDF robot models and simulate differential drive physics in Gazebo
    ~10hBuild1 resource

    Accurate simulation models allow rapid software and control testing without hardware destruction or costly prototype builds.

    You'll learn

    • URDF (Unified Robot Description Format) — XML specification representing robot kinematic and physical structure
    • Inertia Tensor — 3x3 symmetric matrix representing rotational inertia around coordinate axes
    • Gazebo — open-source 3D dynamic multi-robot simulator

    Construct a Unified Robot Description Format (URDF) file including links, joints, visual geometries, collision boundaries, and mass/inertia tensors for a two-wheeled differential drive mobile robot. Import the model into Gazebo Harmonic / Classic with physics parameters, surface friction, and realistic ground contact.

    Done when: The robot spawns cleanly in Gazebo, sits stably on the simulated terrain without drifting or shaking, and responds accurately to differential wheel torque commands.

    How to work through it

    1. Draft the XML URDF specifying base_link, left_wheel, right_wheel, and caster_wheel
    2. Compute analytical moment of inertia tensors for cylinders and boxes representing the chassis and wheels
    3. Add Gazebo-specific tags including friction coefficients (mu1, mu2) and joint control plugins
    4. Launch Gazebo world and verify robot behavior under gravity and commanded wheel velocities
5

Robot Middleware (ROS 2) & Software Architecture

Master the modern robotics software standard (ROS 2 Humble/Iron) on Ubuntu Linux, implementing distributed node graphs, custom interfaces, launch systems, and lifecycle nodes.

  • Develop a distributed ROS 2 node graph in C++ and Python
    ~10hBuild1 resource

    ROS 2 is the ubiquitous industry communication spine connecting perception, planning, control, and hardware drivers.

    You'll learn

    • ROS 2 (Robot Operating System 2) — standard framework and middleware for robot software development
    • DDS (Data Distribution Service) — underlying publish-subscribe transport protocol in ROS 2
    • Quality of Service (QoS) — configurable delivery policies (reliability, durability, history) for DDS data
    • ROS 2 Actions — non-blocking asynchronous request-response architecture with periodic feedback

    Set up a ROS 2 workspace using colcon on Ubuntu Linux. Create custom packages with custom message, service, and action interfaces (.msg, .srv, .action). Build publisher, subscriber, service server, and action client nodes communicating over DDS middleware with configurable Quality of Service (QoS) profiles.

    Done when: An action server node simulates long-running robot trajectory execution, emitting continuous progress feedback and allowing graceful preemption/cancellation by the client.

    How to work through it

    1. Install ROS 2 on Ubuntu and configure bash environment and colcon build tools
    2. Define custom ROS 2 message and action definitions for robot motion commands
    3. Write a C++ publisher and Python subscriber demonstrating intra-process zero-copy communication
    4. Implement a full ROS 2 Action Server with execution loops, feedback topics, and abort handlers
  • Create a comprehensive launch pipeline with robot_state_publisher and TF2
    ~8hBuild

    TF2 dynamic coordinate transform management is the backbone of all spatial awareness, sensor fusion, and localization in ROS 2.

    You'll learn

    • TF2 Transform Library — ROS 2 library tracking coordinate frames over time in a tree structure
    • Xacro — XML macro language used to modularize and parameterize URDF descriptions
    • RViz2 — primary 3D visualizer for sensor data and state inspection in ROS 2

    Construct a ROS 2 launch file orchestrating simulated Gazebo worlds, URDF parsing via xacro, robot_state_publisher, and TF2 coordinate frame transforms. Verify coordinate trees (map -> odom -> base_link -> laser_frame) maintain rigid spatial coherence during movement.

    Done when: Visualizing the running robot in RViz2 shows zero TF frame errors, with all link transforms updating smoothly at 50 Hz as the robot drives around the virtual world.

    How to work through it

    1. Convert static URDF to modular XACRO with parameterized dimensions, meshes, and plugins
    2. Write Python-based ROS 2 launch files to start Gazebo, spawn the robot, and launch RViz2
    3. Integrate robot_state_publisher and joint_state_publisher nodes
    4. Inspect the active TF coordinate tree using tf2_tools view_frames and rviz2 visualization
6

State Estimation & Sensor Fusion

Estimate accurate robot state and orientation by fusing noisy sensors with linear and Extended Kalman Filters (EKF).

  • Implement an Extended Kalman Filter (EKF) for fused IMU and wheel odometry
    ~10hBuild1 resource

    Individual sensors suffer from drift, noise, and bias; Kalman filtering provides mathematically optimal state estimation from noisy measurements.

    You'll learn

    • Kalman Filter — optimal recursive estimation algorithm for linear Gaussian systems
    • Extended Kalman Filter (EKF) — nonlinear adaptation of Kalman filter utilizing first-order Taylor series Jacobians
    • Covariance Matrix — square matrix giving the pairwise covariance between elements of a state vector

    Derive discrete-time prediction and update equations fusing noisy wheel encoder odometry and 6-DOF IMU data. Implement the EKF algorithm in Python or C++, modeling process and measurement covariance matrices (Q and R) to estimate true robot (x, y, yaw) pose.

    Done when: The EKF state estimate shows over 50% reduction in accumulated localization drift compared to raw wheel odometry across a simulated 100-meter multi-turn course.

    How to work through it

    1. Define the non-linear differential drive kinematic motion model (f(x, u)) and measurement model (h(x))
    2. Calculate analytical Jacobian matrices (F_k and H_k) for linearized covariance propagation
    3. Implement the two-step EKF algorithm: Predict state/covariance, then Update with sensor measurements
    4. Inject Gaussian noise and bias into simulated sensor feeds to test EKF convergence and robustness
  • Deploy robot_localization node in ROS 2
    ~6hBuild

    Using industry-standard packages like robot_localization ensures your custom robots integrate seamlessly with Nav2 and mapping stacks.

    You'll learn

    • robot_localization — widely adopted ROS 2 package providing multi-sensor state estimation
    • Sensor Covariance Tuning — empirical calibration of measurement uncertainties for sensor fusion

    Configure the standard robot_localization package in ROS 2 to fuse simulated IMU, wheel odometry, and simulated GPS/beacon topics into continuous odom->base_link transforms.

    Done when: The robot publishes fused odometry on /odometry/filtered and smoothly maintains correct global position during rapid turning and sudden accelerations.

    How to work through it

    1. Create robot_localization configuration YAML specifying active input topics and matrix variable masks
    2. Tune process noise covariance and sensor measurement covariance values in YAML
    3. Launch ekf_node alongside your simulated robot in Gazebo
    4. Verify filtered odometry topic outputs against ground-truth simulation positions in RViz2
7

Perception, Computer Vision & Point Clouds

Extract meaningful environmental geometry and objects from 2D LiDAR scans, RGB camera streams, and 3D depth point clouds.

  • Build a 2D LiDAR obstacle detection and line-extraction pipeline
    ~8hBuild

    2D range finding is the core sensor modality for planar mobile robot obstacle avoidance and 2D grid mapping.

    You'll learn

    • LaserScan — 2D LiDAR range and intensity data array format in ROS
    • RANSAC — iterative algorithm estimating mathematical model parameters from data containing outliers
    • Euclidean Clustering — grouping points in geometric proximity into distinct object clusters

    Write a C++ ROS 2 node subscribing to sensor_msgs/LaserScan. Implement the Split-and-Merge or RANSAC algorithm to extract planar walls and cluster nearby obstacle points into bounding safety zones.

    Done when: The node extracts wall segments and outputs real-time visualization markers of obstacle centroids to RViz2 at 20 Hz without frame drops.

    How to work through it

    1. Subscribe to /scan topic and convert polar range/angle data into Cartesian (X, Y) points
    2. Implement euclidean clustering to segment distinct obstacle objects
    3. Implement RANSAC (Random Sample Consensus) line fitting to identify straight wall boundaries
    4. Publish visualization_msgs/MarkerArray messages to display detected objects in RViz2
  • Process 3D Point Clouds using OpenCV and PCL
    ~10hBuild1 resource

    3D spatial awareness is required for navigating uneven terrain, aerial robotics, and robotic arm pick-and-place manipulation.

    You'll learn

    • PCL (Point Cloud Library) — standalone open-source library for 2D/3D image and point cloud processing
    • Voxel Grid Downsampling — spatial binning technique reducing point cloud density
    • Plane Segmentation — extracting planar geometric equations from 3D point distributions

    Interface an RGB-D camera in simulation (or real Intel RealSense / OAK-D). Write a C++ processing node utilizing the Point Cloud Library (PCL) to perform pass-through voxel filtering, plane segmentation (ground removal), and object bounding box generation.

    Done when: The pipeline processes raw 3D point clouds at over 15 FPS, successfully stripping the ground floor and outputting 3D bounding boxes around table-top obstacles.

    How to work through it

    1. Set up RGB-D sensor plugin in Gazebo or connect physical depth camera via USB 3.0
    2. Apply VoxelGrid downsampling to reduce point density while preserving structural geometry
    3. Execute SACSegmentation to isolate and remove the dominant ground plane
    4. Extract Euclidean cluster extraction on remaining points to output 3D oriented bounding boxes
8

SLAM & Autonomous Navigation (Nav2)

Construct 2D/3D maps of unknown environments, localize within them, and plan collision-free paths using the ROS 2 Navigation Stack (Nav2).

  • Map an unknown simulated environment using Cartographer or SLAM Toolbox
    ~8hBuild

    Simultaneous Localization and Mapping (SLAM) solves the chicken-and-egg problem of mapping an unknown world while tracking position within it.

    You'll learn

    • SLAM (Simultaneous Localization and Mapping) — algorithm constructing a map while localizing within it
    • Occupancy Grid — spatial discretization representing world cells as free, occupied, or unknown
    • Loop Closure — recognizing previously visited locations to eliminate accumulated map drift

    Integrate slam_toolbox with your simulated mobile robot. Drive the robot around an unfamiliar multi-room simulated world via teleoperation, recording LiDAR scans and odometry to generate a 2D occupancy grid map, and save the resulting map file (.yaml and .pgm).

    Done when: The SLAM node closes loops during circuit traversal without double-wall artifacts and exports a crisp, accurate occupancy grid map of the entire environment.

    How to work through it

    1. Configure slam_toolbox parameters for online asynchronous mapping mode
    2. Drive the robot through a maze/building world using keyboard or joystick teleop
    3. Verify graph optimization and loop closure events trigger when revisiting known areas
    4. Use nav2_map_server map_saver_cli to persist the completed grid map
  • Configure and tune autonomous navigation with the ROS 2 Nav2 stack
    ~12hBuild

    Autonomous point-to-point navigation is the core functional requirement for industrial AGVs, warehouse robots, and domestic vacuum cleaners.

    You'll learn

    • Nav2 (Navigation 2) — ROS 2 autonomous navigation framework
    • Costmap2D — 2D grid representation mapping obstacle proximity into cost gradients
    • AMCL (Adaptive Monte Carlo Localization) — particle-filter-based 2D robot pose tracking system
    • Behavior Trees — hierarchical control architecture used to structure high-level robot decisions and recovery

    Configure the complete ROS 2 Nav2 stack on your mapped environment. Set up costmaps (global and local), AMCL (Adaptive Monte Carlo Localization), global path planning algorithms (NavFn / Smac Planner), local trajectory controllers (DWB / MPPI), and behavior trees for recovery.

    Done when: The robot autonomously navigates between distant waypoints in the map, avoiding dynamically placed unknown obstacles and successfully executing recovery behaviors if blocked.

    How to work through it

    1. Configure global and local costmap layers including inflation and obstacle observation buffers
    2. Set up AMCL for probabilistic particle filter localization against the saved static map
    3. Configure global planner (Smac/A*) and local controller (DWB/MPPI) YAML files
    4. Send target navigation goals in RViz2 and tune recovery behaviors for blocked corridors
9

Physical Robot Hardware Integration

Transition from simulation to real physical hardware: assemble a mobile base (TurtleBot, custom chassis, or Raspberry Pi robot), bring up low-level micro-ROS communication, and validate navigation in the physical world.

  • Bridge embedded microcontrollers to ROS 2 using micro-ROS
    ~10hBuild

    micro-ROS brings standard ROS 2 nodes, topics, and serialization directly down to bare-metal microcontrollers without custom serial protocols.

    You'll learn

    • micro-ROS — framework putting ROS 2 directly onto resource-constrained microcontrollers
    • XRCE-DDS — lightweight DDS protocol optimized for microcontrollers over constrained channels
    • Single-Board Computer (SBC) — compact computer (e.g., Raspberry Pi) running Linux onboard the robot

    Flash micro-ROS firmware onto your STM32 or ESP32 microcontroller connected over USB-serial or Wi-Fi to a single-board computer (Raspberry Pi 4/5 or Jetson Nano). Publish raw wheel encoder odometry and subscribe to /cmd_vel motor command topics natively as ROS 2 entities.

    Done when: Publishing geometry_msgs/Twist messages to /cmd_vel from a PC causes the physical robot wheels to rotate at precisely commanded speeds, streaming real-time joint telemetry back to ROS 2.

    How to work through it

    1. Install micro-ROS Agent on the Single Board Computer (SBC)
    2. Integrate micro-ROS client library into your microcontroller firmware project
    3. Create micro-ROS publishers for wheel ticks/odometry and subscribers for velocity setpoints
    4. Test low-latency bi-directional message exchange over serial transport
  • Assemble, calibrate, and navigate the physical robot in a real room
    ~14hBuild

    Conquering real-world hardware issues—such as wheel slippage, sensor noise, voltage drops, and mechanical backlash—is what turns theoretical knowledge into genuine robotics engineering competency.

    You'll learn

    • Wheel Slip & Backlash — non-ideal mechanical behaviors causing discrepancies between odometry and reality
    • Hardware-in-the-Loop (HIL) — testing software algorithms against real physical actuators and sensor noise

    Mount the SBC, microcontroller, power distribution PCB, 2D LiDAR, and battery onto the physical mobile chassis. Calibrate wheel radius, track width, and IMU offsets. Run SLAM to map a real room, and execute autonomous Nav2 point-to-point path following.

    Done when: The physical robot navigates autonomously across your room to a target coordinate within 5 cm accuracy, reliably stopping before unexpected physical obstacles.

    How to work through it

    1. Mount mechanical components, route cabling securely, and power SBC and motor drivers from battery
    2. Calibrate physical wheel diameter and wheelbase by measuring actual distance traveled versus odometry ticks
    3. Execute slam_toolbox on the physical LiDAR scan stream to map your room
    4. Launch full Nav2 stack on the SBC and command navigation goals in the physical environment
10

Advanced Topics & Industrial Systems Architecture

Explore professional specialization areas including Model Predictive Control (MPC), robotic manipulation (MoveIt 2), and real-time Linux configuration.

  • Configure real-time Linux with PREEMPT_RT kernel patch
    ~8hLearn

    High-performance industrial robotics and safety-critical control loops require deterministic execution guarantees that standard desktop OS kernels cannot provide.

    You'll learn

    • PREEMPT_RT — patch converting Linux into a hard real-time operating system
    • SCHED_FIFO — deterministic first-in, first-out real-time priority scheduling policy in POSIX
    • Cyclic Jitter — deviation from true periodic timing in cyclic tasks

    Compile and install a Linux kernel with the PREEMPT_RT real-time patch on Ubuntu. Write a C++ program with memory locking (mlockall), fixed thread priority scheduling (SCHED_FIFO), and measure jitter over a 1 kHz cyclic execution loop.

    Done when: The cyclic test logs worst-case execution latency under 50 microseconds over 1,000,000 continuous iterations under CPU stress loading.

    How to work through it

    1. Download and patch Linux kernel source with matching PREEMPT_RT patch release
    2. Configure kernel options, compile, and install RT kernel packages on Ubuntu
    3. Write a C++ real-time timer loop setting POSIX realtime scheduling policies and locking virtual memory
    4. Benchmark timer jitter under synthetic system load using cyclictest
  • Implement a 6-DOF manipulator pick-and-place pipeline using MoveIt 2
    ~12hBuild1 resource

    MoveIt 2 is the industrial standard framework for multi-axis manipulator motion planning, obstacle avoidance, and kinematic reachability.

    You'll learn

    • MoveIt 2 — state-of-the-art motion planning framework for manipulation in ROS 2
    • OMPL (Open Motion Planning Library) — sampling-based motion planning library (RRT, PRM)
    • Planning Scene — dynamic spatial representation of robot and environmental collision objects

    Set up MoveIt 2 in ROS 2 for an open-source 6-DOF robotic manipulator in simulation. Configure kinematics solvers (KDL/TRAC-IK), define planning scenes with collision geometry, and write a C++ script executing trajectory planning to pick an object and place it at a goal receptacle.

    Done when: The manipulator plans collision-free trajectories around obstacles in the workspace and successfully completes a continuous pick-and-place loop in RViz/Gazebo.

    How to work through it

    1. Generate MoveIt configuration package using MoveIt Setup Assistant for a 6-DOF URDF
    2. Configure OMPL motion planners and define kinematic planning groups
    3. Write C++ node using MoveGroupInterface to specify Cartesian waypoints and obstacle constraints
    4. Execute and visualize collision-free planning and simulated hardware execution
11

Portfolio Engineering & Industry Preparation

Package your technical achievements into open-source repositories, architectural documentation, demonstration videos, and prepare for robotics technical interviews.

  • Document and open-source complete robot architecture on GitHub
    ~10hApply

    Robotics hiring managers evaluate tangible proof of cross-disciplinary capability; clean architecture, documentation, and reproducibility stand out immediately.

    You'll learn

    • Docker for Robotics — containerizing ROS 2 and GUI visualization tools for clean reproducibility
    • System Architecture Documentation — visual and structural communication of complex multi-tier systems

    Create public, production-grade GitHub repositories containing your physical/simulated robot packages, URDFs, custom PCBs (schematics and Gerbers), firmware code, and ROS 2 launch pipelines. Include detailed READMEs, system block diagrams, wiring schematics, and Dockerized build files for one-command reproduction.

    Done when: A third party can clone your repository, run docker compose up, and immediately launch your simulated robot navigation world without dependency errors.

    How to work through it

    1. Structure clean ROS 2 packages adhering to standard colcon directory conventions
    2. Write high-level architectural block diagrams illustrating hardware-software interfaces and ROS topic graphs
    3. Create Dockerfile and DevContainer configs encapsulating ROS 2 dependencies and simulation assets
    4. Record and embed clear video demonstrations showcasing SLAM, navigation, and physical hardware operation
  • Drill robotics technical interview questions and systems design
    ~12hPractice

    Robotics interviews probe the intersection of low-level software, real-time constraints, physics, and high-level autonomy.

    You'll learn

    • Robotics Systems Design — end-to-end methodology for sizing compute, sensors, actuators, and software topologies
    • Technical Communication — explaining cross-disciplinary engineering trade-offs under interview constraints

    Practice solving core robotics technical interview problems covering C++ memory management, linear algebra/quaternion derivations, control loop tuning trade-offs, state estimation concepts (Kalman filter proofs), and high-level autonomous system architecture design.

    Done when: You can walk through and solve five complete multi-domain robotics design prompts (e.g. designing an automated warehouse forklift end-to-end) on a whiteboard or document within 45 minutes each.

    How to work through it

    1. Review core data structures, algorithms, and modern C++ smart pointers/threading
    2. Practice live derivations of 2D/3D kinematic transformation matrices and simple PID discretization
    3. Drill systems design prompts: sensor selection, compute budget, power architecture, and fail-safe recovery logic
    4. Conduct mock technical interview sessions focusing on concise, structured communication

How the plan fits together

11 phases in 5 stages. Anything on the same row can be worked on at the same time, and 2 of them can start straight away.

An arrow points from a phase to the work it unlocks: before starting any phase, every phase with an arrow into it has to be finished first.

STARTSTAGE 2STAGE 3STAGE 4STAGE 51Engineering Mathematics &Foundational Programming3 tasks · ~20h2Embedded Systems,Actuators & Circuit Design3 tasks · ~30h3Classical & State-SpaceControl Theory2 tasks · ~16h4Kinematics, Dynamics &Simulation Engines2 tasks · ~18h5Robot Middleware (ROS 2) &Software Architecture2 tasks · ~18h6State Estimation & SensorFusion2 tasks · ~16h7Perception, ComputerVision & Point Clouds2 tasks · ~18h8SLAM & AutonomousNavigation (Nav2)2 tasks · ~20h9Physical Robot HardwareIntegration2 tasks · ~24h10Advanced Topics &Industrial SystemsArchitecture2 tasks · ~20h11Portfolio Engineering &Industry Preparation2 tasks · ~22h
Solid arrow
Must be finished before the phase it points to
Dashed arrow
Same rule, but the prerequisite sits more than one stage back

Resources

25 in this plan's library, beyond the links on individual tasks.

Learning & Reference

Textbooks, documentation, and foundational theory materials.

  • Articulated Robotics: ROS 2 Tutorials

    Highly practical walkthroughs that take you from an empty workspace to building URDF models, configuring ros2_control, and simulating in Gazebo.

    articulatedrobotics.xyz · Josh Newans (Articulated Robotics) · 100% Free

  • Control Bootcamp (Video Series & Code)

    A state-space control series covering linear and non-linear system dynamics, stability analysis, controllability/observability, and modern optimal control.

    youtube.com · Steve Brunton (University of Washington) · YouTube series · 100% Free

  • Control Systems Lectures & MATLAB Tech Talks

    Bridges theoretical control mathematics and physical implementation with visual intuitions for transfer functions, Bode plots, and state-space representations.

    engineeringmedia.com · Brian Douglas / Engineering Media & MathWorks · 100% Free

  • Control Systems Lectures by Brian Douglas

    Provides crystal-clear physical and mathematical intuition for Bode plots, PID tuning, and state-space control methods.

    youtube.com · Brian Douglas · YouTube series · Free · Intermediate

  • Embedded Systems - Shape the World: Microcontroller Input/Output

    Teaches low-level microcontroller fundamentals using ARM Cortex-M architecture to control GPIOs, PWM, timers, ADC, and serial protocols.

    edx.org · University of Texas at Austin / edX (Prof. Jonathan Valvano, Ramesh Yerraballi) · Free to audit (paid option available for verified certificate)

  • Essence of Linear Algebra

    Essential visual intuition for matrices, transformations, and coordinate frames before diving into kinematic calculations.

    youtube.com · 3Blue1Brown · YouTube series · Free · Beginner

  • Introduction to Linear Algebra (MIT OpenCourseWare 18.06)

    Solid linear algebra is the absolute baseline for 3D coordinate transformations, Jacobian calculations, and state-space equations in robotics.

    ocw.mit.edu · MIT OpenCourseWare (Prof. Gilbert Strang) · MIT OpenCourseWare · 100% Free

  • Kalman and Bayesian Filters in Python

    An intuitive, code-first guide to Bayesian filtering implementing Kalman filters, EKF, and UKF with interactive Jupyter notebooks.

    github.com · Roger R. Labbe Jr. / GitHub · Book · 100% Free (Creative Commons & MIT License)

  • Learn C++ Tutorials

    High-performance robotics software and middleware are written in modern C++, and this tutorial covers C++ fundamentals up to modern concepts.

    learncpp.com · LearnCpp.com (Alex) · 100% Free

  • Mobile Sensing and Robotics / Sensors and State Estimation Lecture Series

    Covers geometric robot perception, LiDAR point cloud processing, Iterative Closest Point (ICP), feature matching, and sensor calibration.

    youtube.com · Prof. Dr. Cyrill Stachniss (University of Bonn) · YouTube series · 100% Free

  • Modern Robotics: Mechanics, Planning, and Control

    The modern standard textbook for rigid body kinematics and dynamics using screw theory and Lie group representations.

    modernrobotics.northwestern.edu · Cambridge University Press / Kevin M. Lynch and Frank C. Park (Northwestern University) · Book · Free preprint PDF and lecture videos available online from Northwestern University; commercial hardback is paid.

  • Probabilistic Robotics

    The definitive academic reference for uncertainty modeling, non-parametric state estimation, particle filtering, and Gaussian filters.

    mitpress.mit.edu · MIT Press (Sebastian Thrun, Wolfram Burgard, Dieter Fox) · Book · Paid textbook (approx. $75–$95 depending on retailer)

  • REP 2000 & ROS 2 Developer Quality Standards (ROS Index)

    Provides coding standards, testing patterns, and packaging guidelines to make portfolio repositories meet tier-1 open-source standards.

    ros.org · Open Robotics Community · 100% Free

  • ROSCon Conference Presentations & Video Archive

    Shows industrial robotic architectures, production test benches, and engineering standards in real commercial deployments.

    roscon.ros.org · Open Source Robotics Foundation (OSRF) / Open Robotics · 100% Free

Open Source Stacks

Key frameworks, middleware, and libraries.

  • Gazebo Simulation Documentation

    Gazebo is the open-source 3D physics simulator used to model multi-link manipulators and mobile robots before deploying to physical hardware.

    gazebosim.org · Open Robotics / Open Source Robotics Foundation (OSRF) · 100% Free (Open Source)

  • micro-ROS Documentation & Tutorials

    Micro-ROS puts standard ROS 2 node architecture directly onto microcontrollers to allow direct publishing and subscribing without custom parsers.

    micro-ROS Consortium & eProsima · 100% Free (Open Source)

  • MoveIt 2 Documentation & Tutorials

    The primary manipulation framework for ROS 2 covering inverse kinematics, collision scenes, trajectory generation, and pick-and-place pipelines.

    moveit.picknik.ai · PickNik Robotics / MoveIt Project · 100% Free (Open Source)

  • Navigation 2 (Nav2) Documentation & Setup Guides

    The official documentation for the ROS 2 autonomous mobile robot navigation stack covering costmaps, behavior trees, planners, and controllers.

    docs.nav2.org · Open Navigation LLC & ROS 2 Nav2 Maintainers · 100% Free (Open Source)

  • OpenCV Documentation & Tutorials

    OpenCV is the foundational library for real-time computer vision covering camera calibration, stereo vision, visual odometry, and optical flow.

    docs.opencv.org · OpenCV Foundation / Open Source Vision Foundation · 100% Free (Open Source)

  • Real-Time Linux (PREEMPT_RT) Documentation

    Explains how to configure and patch the Linux kernel with PREEMPT_RT to run hard real-time ros2_control hardware loops without scheduling jitter.

    wiki.linuxfoundation.org · The Linux Foundation · 100% Free

  • ROS 2 Official Documentation

    The primary reference for modern robot middleware covering DDS communication, writing C++/Python nodes, custom interfaces, and lifecycle nodes.

    docs.ros.org · Open Robotics / Open Source Robotics Foundation · 100% Free (Open Source)

  • SLAM Toolbox Documentation & Tutorials

    SLAM Toolbox is the standard 2D graph-based SLAM package in the ROS 2 ecosystem for mapping large-scale indoor environments.

    github.com · Steve Macenski / Open Navigation LLC · 100% Free (Open Source)

Hardware & Electronics

Microcontroller toolchains, EDA, and components.

  • KiCad EDA

    Open-source schematic capture and PCB layout tool essential for designing motor drivers, sensor breakout boards, and power distribution systems.

    kicad.org · KiCad Developers · Software · Free · Beginner to Intermediate

  • KiCad EDA Documentation & Getting Started Guide

    KiCad is the standard open-source EDA suite for schematic capture and multi-layer PCB layout required for custom robotics boards.

    docs.kicad.org · KiCad Project / CERN & Community Contributors · 100% Free (Open Source)

  • TurtleBot 4 User Manual

    Demonstrates complete physical hardware integration for an autonomous mobile robot including compute, power, stereo cameras, and LiDAR.

    turtlebot.github.io · Clearpath Robotics · 100% Free to read (Physical robot kit sold commercially)