An experiential learning framework for teaching non-holonomic mobile robot kinematics and control using a ROS 2-enabled differential drive platform

Abstract

In senior-level robotics courses, students often struggle to connect analytical models of differential drive kinematics and control with the behavior of real mobile robots, particularly when non-holonomic constraints and ROS2 based software architectures are involved. This article presents an experiential learning framework for teaching non-holonomic mobile robot kinematics, odometry, and closed-loop control using a ROS2 enabled Ati Sherpa RP differential drive platform. The four-week module combines platform-specific derivation of inverse and forward Jacobians with simulation-based validation in IR Sim and subsequent deployment to physical hardware. The framework was implemented with final-year mechanical engineering students, and its educational effectiveness was evaluated using pre-/post-quizzes, rubric-based assessment of simulation and hardware exercises, and a post-module survey. Results show marked conceptual gains (pre-quiz mean 46% vs. post-quiz mean 81%, Cohen’s $d = 2.7$ ) in students’ ability to derive and interpret differential drive kinematics, implement Jacobian-based motion models, and tune PI controllers, with gains concentrated on the hardest conceptual items involving non-holonomic constraints. Hardware deployment success (9 of 10 teams within the specified error bounds) further corroborates the practical effectiveness of the framework. Students reported increased confidence in applying kinematic models and valued the transparent linkage between equations, code, and robot motion. The proposed framework offers a reproducible, ROS2-compatible approach for aligning mathematical theory, software implementation, and authentic laboratory practice in mechanical engineering education.

Keywords

Non-holonomic mobile robots differential drive robots robotics education ROS2 experiential learning kinematic modeling

Introduction

Mobile robotic platforms have become integral components in modern engineering programs where they are used to support instruction in kinematics, feedback control, and autonomous navigation.^1,2 Among the range of mobile robot architectures that are commonly deployed in educational laboratories, the differential drive configuration is most commonly adopted, especially because the mechanical simplicity of this configuration matches the trends of industrial services. Nonetheless, students have a tendency to fail to translate theoretical descriptions of the differential drive mechanics into practical control systems that can work satisfactorily on a real or simulated robotic system.³ These systems also introduce a key implementation challenge associated with non-holonomic motion constraints. Given that the lateral translation is impossible in these robots, students need to learn to coordinate the linear and angular velocities to move in the desired direction precisely. Although most of these limitations are well documented in the standard robotics literature, students often find it challenging to apply forward and inverse kinematics, odometry, and closed-loop control algorithms in practice. This gap can be exacerbated when students must integrate their models into a full-featured robotics middleware such as ROS2, where seemingly minor modeling inaccuracies in the kinematic layer can propagate and degrade high-level navigation behavior. Some educational robotics frameworks emphasize abstract kinematic models and simulation with limited exposure to deployment-level software.^2–4 In contrast, other approaches prioritize project work and software tools, sometimes without making the underlying Jacobian structure explicitly.^3–5 Consequently, students can obtain functional demonstrations without knowing the detailed kinematic and control principles that guide robot movement. This paper presents an education-oriented framework for teaching non-holonomic mobile robot kinematics and control using a complete and platform-calibrated development workflow. The proposed methodology guides the learners from geometric modeling and Jacobian derivation to odometry calculation, and proportional–integral (PI) control in order to manage the robot in tracking a trajectory and navigate autonomously using the Ati Sherpa RP differential drive robot as a case study. In contrast to black-box methods, the framework is more focused on transparency and mathematical clarity, such that the exploration of the effects of modeling assumptions and parameter choices on robot behavior occurs directly in a simulated setting, through the engagement of an IR Sim–enabled simulation environment by the learner. The proposed framework is justified with the help of the series of instructional simulation experiments aimed to strengthen the essential learning goals, such as tracking of the static trajectory, controlling dynamic motion, and regulation of the closed-loop goal. These experiments are carefully designed to put the students in situations where they are subjected to typical issues like curvature issues, heading issues and convergence under the non-holonomic constraint. More so, the framework is also directly compatible with the ROS2 Navigation Stack, and can be extended smoothly to localization, mapping and sensor fusion in more advanced coursework. While prior frameworks have made valuable contributions to robotics education, they can be broadly characterized by two limitations. Frameworks focused on abstract modelling and simulation^2,4 provide strong theoretical grounding, but offer limited exposure to deployment-level software, leaving students without the experience needed to transfer their models to a physical platform. Conversely, frameworks that emphasize project work and software toolchains^3,5 allow students to achieve functional demonstrations without necessarily understanding the kinematic and control principles that govern robot behavior. To substantiate the claim that no existing work combines all three design axes (transparent Jacobian derivation, code-identical simulation-to-hardware transfer, and constructive alignment for mechanical engineering students), we extended our literature review beyond the frameworks summarised in Table 1. Amorim et al.⁶ presented a goal-to-goal interface for teaching differential robot control, covering kinematics but not addressing ROS2 integration or simulation-to-hardware continuity. Pinto et al.⁷ introduced a comprehensive ROS2-based undergraduate course with simulation and hands-on activities, yet the focus is on the course implementation rather than a transferable framework, and the underlying kinematic derivations are not explicitly required of students. Ventuzelos et al.⁸ demonstrated teaching ROS1/2 using a differential-drive robot in both simulation and hardware, but the work does not provide constructive alignment between learning outcomes and assessment instruments. At the hardware level, recent platforms such as PlatROB⁹ and the differential wheeled mobile robot prototype,¹⁰ provide open-source, low-cost solutions compatible with ROS/ROS2. Yet, neither includes a scaffolded pedagogical framework linking mathematical derivation to code. None of these works simultaneously satisfies the three axes that define the proposed framework. The present manuscript, therefore, contributes not a single novel element but the first validated integration of all three axes within a single module specifically targeting mechanical engineering students.

Table 1.

Comparison of the proposed framework with representative prior works across the three contribution axes. $✓$ = fully addressed; $\circ$ = partially addressed; $\times$ = not addressed.

Prior work	Platform-calibrated transparent Jacobian derivation	Simulation-to-hardware code continuity via ROS 2	Constructively aligned assessment for ME students
Verner & Ahlgren¹	$\circ$	$\times$	$\times$
Zhong et al.²	$\circ$	$\times$	$\times$
Ma et al.³	$\times$	$\times$	$\circ$
Mysorewala & Cheded⁴	$\times$	$\circ$	$\times$
Liang & Du⁵	$\times$	$\times$	$\times$
Proposed work	$✓$	$✓$	$✓$

The present work addresses both limitations through three specific contributions that, taken together, distinguish it from the existing literature:

Platform-calibrated, transparent Jacobian derivation. Unlike approaches that provide pre-built kinematic libraries or black-box motion primitives, this framework requires students to derive platform-specific forward and inverse Jacobians from first principles, and to validate them against a physically measurable outcome — the circular trajectory radius $R = v / ω$ — making every modeling assumption explicit and empirically testable within the simulation environment.

Simulation-to-hardware continuity via ROS2. The identical Python codebase developed in the IR Sim environment is deployed to the physical Ati Sherpa RP via ROS2 node wrappers without architectural change. This direct transfer gives students concrete empirical evidence of the degree to which their kinematic model holds on real hardware, and makes discrepancies — arising from wheel slip, encoder noise, or parameter mismatch — a structured learning object rather than an incidental outcome.

Constructively aligned assessment for Mechanical Engineering. The framework is designed specifically for students whose background is strongest in engineering mathematics and classical control, but who lack prior exposure to robotics middleware.^1,2 Learning outcomes, instructional activities, and assessment instruments are explicitly aligned (Table 2), and the module has been validated with a cohort of $N = 32$ final-year Mechanical Engineering students, providing performance and perception evidence that is directly relevant to this under-served audience in the robotics education literature.

While each of the three contributions above has precedent in isolation, their simultaneous integration within a single, constructively aligned module has not been reported for Mechanical Engineering students, as summarised in Table 1. Prior frameworks that achieve simulation-to-hardware transfer—such as the FPGA-based approach of Mysorewala and Cheded⁴—do so without requiring students to derive the underlying kinematic Jacobians from first principles, relying instead on the provided motion libraries that treat the kinematic layer as a black box. Frameworks that emphasize transparent mathematical derivation, such as that of Zhong et al.,² typically conclude at the simulation stage and do not demonstrate code-identical deployment to physical hardware or report hardware-validated performance metrics. Constructive alignment of learning outcomes with rubric-based assessment has been advocated broadly in STEM and robotics education,² but has not been applied specifically to the kinematics-to-hardware pipeline for non-holonomic robots in a Mechanical Engineering program context, where the prerequisite profile—strong in engineering mathematics and classical control, with no prior robotics middleware experience—differs substantially from Computer Science or Robotics cohorts.^1,2 The contribution of this work is therefore not any single element in isolation, but their combination: a module in which the same mathematical derivation, the same Python codebase, and the same rubric-based assessment instruments span theoretical derivation, simulation validation, and physical hardware deployment, validated with a cohort of final-year ME students for whom this integrated combination has been absent from the published literature.

Table 2.

Alignment of learning outcomes with activities and assessments.

Learning outcome	Description (LO1–LO5)	Primary activities / experiments	Assessment instruments	Evidence type
LO1 (Modelling)	Derive platform-specific forward and inverse Jacobian matrices for a differential drive robot.	Module A derivations, Experiment 1 circular trajectory setup.	Pre/post quiz items on kinematics; correctness of Jacobian implementation in simulation code.	Quiz score improvement; rubric rating for Jacobian functions.
LO2 (Implementation)	Translate mathematical models into modular computational nodes within ROS2.	Module B IR Sim implementation, ROS2 node development.	Code quality rubric (modularity, vectorisation, ROS2 interfaces).	Proportion of teams meeting “proficient” criteria.
LO3 (Control)	Design and tune a PI kinematic controller to minimise trajectory tracking errors $ρ$ , $α$ .	Experiment 3 PI control in simulation and hardware.	Lab report section on controller design; trajectory error plots.	Closed-loop error metrics; rubric rating for tuning rationale.
LO4 (Analysis)	Evaluate impact of non-holonomic constraints on trajectory generation and stability.	Analysis of Experiments 1 and 2 (radius, zero crossings).	Written explanations in the lab report; quiz on conceptual items on constraints	Quality of explanations; correct interpretation of ${\dot{y}}_{R} = 0$ .
LO5 (Deployment)	Bridge simulation and reality by deploying code on a physical system and analysing discrepancies.	Module C hardware runs (Figure $-$ 8 path) and comparison with IR Sim data.	Hardware demonstration rubric (pass/fail).	Position and heading error within thresholds.

Educational methodology & learning outcomes

The curriculum adopts a scaffolded pedagogy, which is designed explicitly in such a way that students are introduced to theories of derivation, which in turn would lead to the integration of physical hardware. The method puts more emphasis on active experimentation so that abstract kinematic concepts are reinforced through feedback loops that get driven by simulations. We use the term framework as defined by Biggs and Tang,¹¹ who established constructive alignment as the connection between intended learning outcomes, teaching activities, and assessment instruments–the essential structure of any pedagogical framework. In the robotics education literature, the term framework has been used to describe transferable structures that can be instantiated on different platforms: Verma and Kandasamy¹² present a software framework for educational mobile robots designed for versatility across platforms; Forbrig and Wurdel¹³ propose MecQaBot, a modular methodology for teaching autonomous mobile robotics that separates core pedagogy from platform specifics. Following this established usage, the present work is a framework in that it specifies a structured, transferable set of learning outcomes, instructional activities, and assessment instruments that can be instantiated on any differential drive robot without modification to the core pedagogical logic. The Ati Sherpa RP serves as a reference implementation–one concrete instantiation used to validate and reproduce the framework’s results. This is analogous to a reference system in a software framework paper. Transferability is achieved by design: the only platform-specific inputs to the entire module are the wheel radius $r$ and track width $d$ (Table 3). All other elements–the kinematic derivation activities, the IR Sim simulation environment, the ROS 2 node architecture, the control laws (Eqs. 8–11), and the assessment rubrics (Table 2)–are independent of the Ati Sherpa RP and transfer without modification to any differential drive robot running ROS 2 (e.g., TurtleBot 3, Clearpath Jackal, or custom builds). Subramanian’s comprehensive guide on building autonomous mobile robots from scratch using ROS¹⁴ similarly emphasises that simulation and hardware share the same core algorithms, reinforcing the feasibility of platform-agnostic design. The framework has been instantiated on two additional platforms (TurtleBot 3 and a locally constructed differential drive robot) with no changes beyond substituting $r$ and $d$ ; the learning outcomes and student performance metrics remained consistent with those reported here.

Target audience and prerequisites

We use the term framework in the sense established in engineering education research:^1,2 a structured, transferable set of learning outcomes, instructional activities, and assessment instruments that can be instantiated on any compatible platform.

The Ati Sherpa RP plays the role of reference implementation—the concrete instantiation used to validate and reproduce the framework’s results—analogous to the role a reference system plays in a framework paper.

Transferability is achieved by design: the only platform-specific inputs to the entire module are the wheel radius $r$ and the track width $d$ (Table 3).

Table 3.

Physical parameters of the Ati Sherpa RP (Ati Motors inc., 2025).

Parameter	Symbol	Value	Description
Wheel Radius	$r$	$0.10 m$	Diameter is 200 mm (Solid Rubber)
Track Width	$d$	$0.46 m$	Distance between left and right wheels
Max Linear Speed	$v_{max}$	$0.8 m / s$	Rated top speed
Chassis Length	$L_{c}$	$0.598 m$	Front-to-back length

All other elements—the kinematic derivation activities, the IR Sim simulation environment, the ROS 2 node architecture, and the assessment rubrics—are independent of the Ati Sherpa RP and transfer without modification to any differential drive robot running ROS 2. The module is intended for senior undergraduate or first–stage postgraduate students in Mechanical Engineering, Robotics, Mechatronics, or Computer Science programs. In the present study, the framework was implemented within a senior-level Mechanical Engineering Mobile Robotics elective. In the cohort studied ( $N = 32$ ), pre-quiz scores averaged 46% (SD = 14%) and no participant had prior ROS2 experience, consistent with the theory-practice gap documented for undergraduate control and robotics program.^1,2 To be effective with this framework, students are expected to have the following prerequisite competencies:

Mathematical Foundations: The ability to use linear algebra (matrices, eigenvectors, and the inverse and forward transformations) and elementary differential calculus.

Control Theory: A foundational understanding of rudimentary feedback control ideas, especially the structure and tuning of Proportional–Integral–Derivative (PID) controllers.

Software Knowledge: Intermediate proficiency in Python or C++. It is also recommended to be familiar with the Linux command line, but in particular, there is no requirement of specific knowledge of ROS2 (Robot Operating System), as these concepts are introduced gradually in the framework.

Learning objectives

At the end of this course of study, participants will show the following technical skills. The alignment of learning outcomes with activities, assessment instruments, and evidence types is summarised in Table 2.

Teaching workflow and module structure

The education system is designed into three progressive units, whereby students must certify their knowledge in each level before graduating to the sophisticated level hardware installation.

Module A: Theoretical Derivation (Week 1) –

Focus: Mathematical formulation and ROS2 orientation.

–

Activity: Participants derive the governing kinematic equations manually. A focused two-hour workshop introduces ROS2 node structure, topic types, and parameter files at the level required to deploy the derived models; no prior ROS2 knowledge is assumed. Students command a constant speed ( $v = 0.5$ m/s, $ω = 0.3$ rad/s) and record the resulting odometry.

Module B: Simulation and Visualization (Weeks 2–3) –

Focus: Software implementation and logic validation.

–

Activity: Students implement their derived models in Python using the IR Sim environment. This phase focuses on debugging logic errors (e.g., incorrect matrix transformations) in a risk-free environment. Visual odometry feedback allows students to “see” the math in action.

Module C: Hardware Deployment and Analysis (Week 4) –

Focus: Real-world application.

–

Activity: Validated code is deployed to the physical system. Students perform the “Figure $-$ 8” maneuver and compare the real-world trajectory against their simulation data, analyzing sources of error such as wheel slip or uneven terrain.

A natural question is whether students would benefit more from building the entire software stack from the ground up, without relying on a middleware such as ROS2. In our experience, and consistent with the cognitive-load literature on scaffolded instruction,^15,16 a hybrid approach is most effective at this level. Students derive and implement all kinematic and control logic from first principles - no pre-built kinematic libraries are used, and no black-box motion primitives are provided. ROS2 serves exclusively as the communication and deployment infrastructure: it provides the publisher/subscriber transport between nodes and the hardware abstraction layer, but contributes nothing to the kinematic or control mathematics that are the actual learning objectives. Building the full ROS2 stack from scratch would redirect a substantial portion of student cognitive effort toward middleware configuration and inter-process communication, at the expense of the kinematic content, the module is designed to teach. The framework, therefore, exposes ROS2 minimally and incrementally - node interfaces, topic types, and parameter files - introduced through a focused two-hour workshop at the start of Module A (see Section 2.1), so that students engage with the software only at the level required to deploy the mathematics they have already derived.

Kinematic modeling

To be able to control the robot’s motion, the relationship between the task space (robot’s pose) and the joint space (wheel velocities) must be established.¹⁷ The Inertial Frame $I$ can be considered the map for the entire world. The Robot Frame $R$ is placed at the midpoint of the driven wheel axle - the standard convention for differential drive kinematic derivation which, for the Ati Sherpa RP, coincides approximately with the geometric centre of the chassis owing to the symmetric placement of the two driven wheels. All kinematic equations that follow assume this placement.

Assumptions

The following assumptions are considered:^18,19

Pure Rolling – the point on the wheels where contact occurs meets the pure rolling condition (no longitudinal slip).

No Lateral Slip – the robot will never be able to move sideways.

Rigid Body – the chassis and wheels do not deform.

Inverse Kinematics provides the answer to this question: “If we know the desired robot velocity, how quickly should we turn the wheels?” We denote our desired robot velocity vector by

v = [v, ω]^{⊤}

, where

v

represents the robot’s linear velocity and

ω

represents the robot’s angular velocity. Here,

r

(m) denotes the radius of each driven wheel and

d

(m) denotes the track width, defined as the distance between the contact points of the left and right wheels on the ground. For the Ati Sherpa RP the case-study values are

r = 0.10

m and

d = 0.46

m (Table 3). The right and left wheel velocities in relation to the chassis must be determined to calculate the following:²⁰

v_{R} = v + \frac{ω \cdot d}{2}

(1)

v_{L} = v - \frac{ω \cdot d}{2}

(2)

To convert the linear wheel velocities into angular velocities, we must take the Inverse Kinematics Matrix and rearrange to yield:

[\begin{matrix} ω_{R} \\ ω_{L} \end{matrix}] = [\begin{matrix} \frac{1}{r} & \frac{d}{2 r} \\ \frac{1}{r} & - \frac{d}{2 r} \end{matrix}] [\begin{matrix} v \\ ω \end{matrix}]

(3)

Equation 3 – Inverse Kinematics Model.

Table 4.

Nomenclature

Symbol	Description	Unit
$v$	Linear velocity of the robot chassis	m/s
$ω$	Angular velocity of the robot chassis	rad/s
$v_{R}, v_{L}$	Linear velocities of the right and left wheels	m/s
$ω_{R}, ω_{L}$	Angular velocities of the right and left wheels	rad/s
$r$	Wheel radius of the Ati Sherpa RP	m (0.10)
$d$	Track width (distance between wheels)	m (0.46)
$x, y$	Global position coordinates in the inertial frame	m
$θ$	Robot heading angle (yaw)	rad
$ρ$	Euclidean position error to the goal	m
$α$	Heading error to the goal	rad
$K_{ρ}$	Proportional control gain for linear velocity	–
$K_{α}$	Proportional control gain for angular velocity	–
$R (θ)$	Instantaneous rotation matrix	–
${\dot{y}}_{R}$	Lateral velocity in the robot frame (non-holonomic constraint)	m/s (0)
$K_{I ρ}$	Integral control gain for linear velocity	–
$K_{I α}$	Integral control gain for angular velocity	–

Forward kinematics (Odometry)

The differential drive mobile robots use a forward kinematic algorithm for odometry, which allows the robot to calculate its global position $[x, y, θ]^{⊤}$ from the readings of internal sensors alone.21 This calculation is done in two steps, the first step being to convert the measured angular velocities for both right ( $ω_{R}$ ) and left ( $ω_{L}$ ) wheels to local velocities relative to the robot body. The chassis linear velocity $v$ can be determined from the average of both wheels’ linear contributions, while the difference after scaling by the track width ( $d$ ) gives the chassis angular velocity ( $ω$ ). The second step is to convert the calculated local body velocities into world coordinates (global axes) based on the instantaneous heading angle $θ$ of the robot. This transformation uses the rotation matrix $R (θ)$ to ensure that the non-holonomic constraints that prevent lateral sliding are maintained.²² The final Jacobian, Forward Kinematic Jacobian (Equation 7), expresses the relationships between the geometries through one matrix that will be used to integrate the velocity numerically over time to update the position of the robot.²³ Using the inverted relationships described above, we can compute the local velocities of the robot:

v = \frac{r}{2} (ω_{R} + ω_{L})

(4)

ω = \frac{r}{d} (ω_{R} - ω_{L})

(5)

To compute the global velocities (

\dot{x}

\dot{y}

\dot{θ}

) of the robot in the inertial frame, we employ the rotation matrix above to convert our local velocities into global coordinates.

To convert local body velocities into global coordinates, the rotation matrix $R (θ)$ is written in its standard $3 \times 3$ form for a ground vehicle. The local velocity vector is expressed as $[v, 0, ω]^{⊤}$ , where the zero in the second entry explicitly encodes the non-holonomic (no lateral slip) constraint ${\dot{y}}_{R} = 0$ :

[\begin{matrix} \dot{x} \\ \dot{y} \\ \dot{θ} \end{matrix}] = \underset{R (θ)}{\underset{⏟}{[\begin{matrix} \cos θ & - \sin θ & 0 \\ \sin θ & \cos θ & 0 \\ 0 & 0 & 1 \end{matrix}]}} [\begin{matrix} v \\ 0 \\ ω \end{matrix}]

(6)

The zero second row of the velocity vector confirms that no lateral motion is possible in the robot frame, consistent with the pure-rolling and no-lateral-slip assumptions stated above. Dropping the zero lateral-velocity row (since ${\dot{y}}_{R} = 0$ by the non-holonomic constraint) and substituting Equations 4 and 5 into the remaining two rows of Equation 6 gives the compact Forward Kinematic Jacobian: Substituting the wheel velocities as shown above gives the Forward Kinematic Jacobian for differential drive mobile robots :

[\begin{matrix} \dot{x} \\ \dot{y} \\ \dot{θ} \end{matrix}] = [\begin{matrix} \frac{r}{2} \cos θ & \frac{r}{2} \cos θ \\ \frac{r}{2} \sin θ & \frac{r}{2} \sin θ \\ \frac{r}{d} & - \frac{r}{d} \end{matrix}] [\begin{matrix} ω_{R} \\ ω_{L} \end{matrix}]

(7)

Equation 7: Forward Kinematics Model.

Note that the two columns of the upper $2 \times 2$ block are identical because both wheels contribute equally to translational velocity (Equation 4); the sign difference in the bottom row reflects the opposing contributions to angular velocity (Equation 5).

Control system design

To transition the robot from its initial position $q_{start}$ to the target position $q_{goal}$ , we require a high-quality, high-performance, closed-loop controller.²⁴

PI kinematic controller

We will use a proportional–integral control algorithm to reduce the position ( $ρ$ ) and heading ( $α$ ) error. This methodology is particularly suitable for educational frameworks as it demonstrates the direct relationship between error states and control effort.²⁵ The first step in the process is to compute the errors.

ρ = \sqrt{(x_{goal} - x)^{2} + (y_{goal} - y)^{2}}

(8)

α = atan 2 (y_{goal} - y, x_{goal} - x) - θ

(9)

The second step is to define the control laws to achieve the objective.^26,27 The control laws governing the linear and angular command velocities are defined as proportional–integral (PI) laws to reduce both position error

ρ

and heading error

α

v_{cmd} = K_{ρ} ρ + K_{I ρ} \int_{0}^{t} ρ d τ

(10)

ω_{cmd} = K_{α} α + K_{I α} \int_{0}^{t} α d τ

(11)

where

K_{ρ}

and

K_{α}

are the proportional gains for linear and angular velocity respectively, and

K_{I ρ}

K_{I α}

are the corresponding integral gains. In a discrete-time implementation, the integral terms are accumulated as a running sum (

\sum ρ Δ t

and

\sum α Δ t

) and reset whenever the sign of the respective error changes, to prevent integral windup. To limit the control inputs and prevent actuator saturation, the maximum linear velocity is capped at

v_{max} = 0.8

m/s.²⁸

Educational study design

Participants and context

The framework was implemented in a senior-level elective course on Mobile Robotics is offered within the Mechanical Engineering program. The study cohort comprised $N = 32$ students in their final year of study, organized into teams of three to four for laboratory activities. All participants had completed prerequisite courses in engineering mathematics, classical control, and introductory programming in Python or C++, but none had prior experience with ROS2 or with implementing kinematic controllers on mobile robots. The module spanned four weeks and replaced the existing set of ad hoc laboratory exercises for differential-drive platforms.

The module constitutes a structured four-week segment of a three-credit-hour senior elective in Mobile Robotics, offered in the final year of the B.E. in Mechanical Engineering program, as a technical elective following prerequisite courses in classical control and engineering mathematics.

Data sources

To evaluate the educational effectiveness of the framework, multiple data sources were collected: (i) scores on a written quiz assessing derivation and interpretation of differential drive kinematics and non-holonomic constraints (aligned with LO1 and LO4), (ii) marks for the simulation-based lab report (LO2–LO4), (iii) performance on the hardware demonstration rubric (LO3 and LO5), and (iv) a short post-module survey capturing student self-reported confidence in applying kinematic models and deploying ROS2-based control nodes. The quiz was administered before Module A and after completion of Module C, enabling comparison of conceptual understanding before and after the experiential sequence.

Alignment of learning outcomes and assessments

Learning outcomes LO1–LO5 were constructively aligned with specific tasks and assessment components. LO1 (modeling) was evaluated via derivation items on the written quiz and through the correctness of the implemented Jacobian matrices in the simulation code. LO2 (implementation) was assessed using rubric criteria for code modularity, readability, and correct use of ROS2 node interfaces in the simulation and hardware phases. LO3 (control) and LO4 (analysis) were evaluated by examining trajectory tracking error plots, stability of the PI controller under different gain selections, and students’ qualitative discussion of non-holonomic effects in their lab reports. LO5 (deployment) was primarily assessed through the pass/fail hardware demonstration, where each team was required to navigate a predefined path within specified position and heading error bounds.

Data analysis

Quantitative data from quizzes and graded components were analyzed using descriptive statistics (mean, standard deviation) and paired comparisons of pre- and post-quiz scores to estimate conceptual gains in kinematics and control. Survey responses were analyzed using Likert-scale summaries to characterize changes in self-reported confidence, and open-ended comments were coded inductively to identify recurring themes regarding perceived benefits and challenges of the framework. This mixed-methods approach provides both numerical evidence of improved performance and qualitative insight into how students experienced the experiential learning sequence.

Educational evaluation and results

Conceptual understanding of kinematics and constraints

Pre- and post-quiz results indicated substantial gains in students’ ability to derive and interpret the kinematic relationships of a differential drive robot. The average score on items targeting LO1 and LO4 increased from 46% ( $SD = 14 %$ ) before Module A to 81% ( $SD = 10 %$ ) after Module C, with the largest improvements observed on questions involving the non-holonomic constraint and the geometric interpretation of radius $R = v / ω$ . In their lab reports, over 85% of teams correctly explained how incorrect values of wheel radius or track width manifests as systematic deviations from a circular path in Experiment 1, suggesting that the combination of derivation and visual simulation effectively reinforced the link between parameters and global motion.

Development of implementation and control skills

Analysis of the simulation code and lab reports showed that all teams successfully implemented the inverse and forward Jacobians in the IR Sim environment and were able to generate stable circular and lemniscate trajectories. Common initial errors included missing time-step normalization in numerical integration loops and incorrect sign conventions for angular velocity; these issues were generally identified and corrected by students themselves after inspecting odometry plots and trajectory shapes in Experiment 2. By the end of the module, 28 out of 32 students achieved full marks on the rubric criteria related to correct the Jacobian implementation and properly encapsulate the kinematic logic in reusable functions, supporting LO2.

Closed-loop control performance on hardware

In the hardware deployment phase, 9 out of 10 teams met the predefined performance thresholds for the Figure $-$ 8 trajectory, remaining within $0.1 m$ position error and an acceptable heading deviation at the designated waypoints. Teams that initially struggled with convergence typically selected overly conservative angular gains $K_{α}$ , leading to slow orientation corrections, and refined their parameters after observing “orbiting” behavior around the goal, as anticipated in Experiment 3. These observations suggest that the PI controller implementation provided a concrete vehicle for students to connect abstract notions of asymptotic stability and gain tuning with observable robot behavior, thereby supporting LO3 and LO5.

Student perceptions of the experiential framework

Survey data indicated that students’ self-reported confidence in applying differential drive kinematics in code increased from “low” or “moderate” in 72% of responses before the module to “high” or “very high” in 78% of responses afterward. Qualitative comments emphasized the value of the simulation-first approach (seeing the effect of wrong parameters immediately in the trajectory) and the satisfaction of transferring identical code to the Ati Sherpa RP without major modifications, which students associated with a stronger sense of authenticity in the lab experience. Some students noted the steep initial learning curve of ROS2, pointing to the importance of providing minimal working examples and template nodes early in the module. Overall, the data support the claim that the framework effectively bridges the gap between theoretical derivations and real-world implementation in a way that is perceived as meaningful and engaging to senior mechanical engineering students.

Instructional experiments: Ati sherpa RP as a case study platform

The validation of the framework took place through three separate experiments to enhance the theoretical foundation with programmer implementations. These three experiments aim to facilitate students’ transition from open-loop verification to closed-loop autonomous control. The following experiments use the Ati Sherpa RP as the reference platform for framework validation. The framework is inherently platform-agnostic: adopting it for a different differential drive robot requires only that the platform-specific wheel radius $r$ and track width $d$ be substituted into Equations 3–7; the module structure, derivation activities, IR Sim implementation, ROS 2 node architecture, and assessment rubrics remain unchanged. Case-study parameter values for the Ati Sherpa RP are $r = 0.10$ m and $d = 0.46$ m (Table 3); institutions using other platforms should substitute their own measured values and re-tune the PI gains accordingly (Experiment 3).

System description: The Ati sherpa RP

The Ati Sherpa RP (Ati Motors Inc., Version 1.0, May 2025) is a modular mobile robotic platform designed for educational, research, and light-duty material transport applications.²⁹ The chassis is constructed from aluminum 2020 T-slot extrusion profiles and encased in a protective sheet-metal shell; the exposed 2020 slots provide mounting points for additional sensors or electronics. The differential drive architecture comprises two rear 200 mm cast-iron drive wheels with solid rubber tires (Shore hardness 90–95 A), each driven by a 750 W brushless DC (BLDC) motor with an integrated Twara motor driver operating at 24 V (48 V secondary mode) and a 20:1 gearbox. Two passive caster wheels (72 mm) provide frontal support. The key physical parameters used in the kinematic model are the wheel radius $r = 0.10$ m and the track width $d = 0.46$ m (Table 3).

Wheel velocity measurement. Wheel angular velocities $ω_{R}$ and $ω_{L}$ are measured via quadrature encoders integrated with the BLDC motors. Encoder ticks are transmitted to the single-board computer (SBC) over the CAN 2.0b bus (1 Mbps) via a Twara CAN-USB transceiver. The encoder driver node, which publishes $ω_{R}$ and $ω_{L}$ as a ROS 2 topic is provided to students as a tested template package; students are not required to implement low-level CAN communication.

Compute platform. The SBC is a Raspberry Pi 5 (8 GB, standard configuration) or an NVIDIA Jetson Orin Nano (optional), running Ubuntu 20.04 with a Docker container that hosts Ubuntu 22.04 and ROS 2 Humble Hawksbill.²⁹ This Docker-based architecture allows hardware-agnostic software deployment and rapid environment cloning.

Sensors. The platform integrates a SlamTec RPLidar C1 for 2D LiDAR mapping and obstacle detection, and an Intel RealSense D435i for 3D depth perception and inertial measurement. A Sony DualShock 4 joystick enables manual teleoperation via Bluetooth. These sensors support advanced extensions of the framework (SLAM, sensor fusion) but are not activated during the kinematic experiments described in Experiments 1–3.

Student-developed nodes. Figure 1 presents the complete system architecture, distinguishing hardware components (gray), provided nodes (orange), and student-developed nodes (green). Students develop three ROS 2 nodes from scratch: the Kinematics Node (Equations 3–7), the Odometry Node (Equations 4–7), and the PI Controller Node (Equations 8–11). The provided encoder driver and joystick nodes are used without modification.

Figure 1.

System architecture of the Ati Sherpa RP platform. Hardware components (gray) interface with ROS2 middleware. Student-developed nodes (green) implement kinematics, odometry, and PI control. Provided nodes (orange) are used as-is. Dashed arrows indicate encoder feedback.

Experiment 1 – Static Trajectory (Circular Path)

Objective: To validate both the Forward and Inverse Jacobians developed.

Student Activity: Students are informed of the physical parameters that are used to define the Sherpa Robot’s configuration, such as platform-specific track width and wheel radius (case study values: $d = 0.46 m$ , $r = 0.10 m$ for the Ati Sherpa RP; substitute your platform’s values accordingly), then create the Python Inverse Kinematics Program (implementing Equation 3).

Learning Outcome: The geometric relationship between the wheel speeds of each of the wheels and the global chassis of the robot ( $R = v / ω$ ). Students command a constant speed ( $v = 0.5$ m/s, $ω = 0.3$ rad/s) and record the resulting odometry.

Student Observation: Students observe that if they incorrectly define the robot’s parameters, the robot does not travel in a closed circular path. This visual information provides the student with additional validation of the model they used to define the robot.

Result: The results of the simulation indicated by Experiment 1 in Figure 2 demonstrate that when the geometric relationships constrained by the robot’s differential drive system have been correctly defined, a perfectly circular trajectory with a consistent radius ( $1.66 m$ ) will be achieved. Therefore, the validity of the derivation of both Jacobians has been achieved through this experiment.

Figure 2.

Simulation results of Experiment 1. The horizontal and vertical axes show the $x$ - and $y$ -position of the robot in the inertial frame (meters), respectively. The trajectory demonstrates a closed circular path of radius $R = v / ω = 1.66$ m, confirming the validity of the derived forward and inverse Jacobians. The first green marker indicates the robot’s starting pose; the second green marker indicates the robot’s final pose after one full revolution, showing that the trajectory closes correctly.

Experiment 2: Dynamic trajectory (Lemniscate)

Purpose: To analyze the stability of the robot when subjected to time-changing inputs as well as changes in direction.

Student Activity: Students are tasked with creating a velocity profile over time ( $ω (t) = 0.4 \cos (0.2 t)$ ) and must assess how the robot behaves when the angular velocity reaches zero ( $ω = 0$ ) (inflection point).

Learning Outcome: –

Reinforced Concept: The non-singular nature of differential drive robots through zero crossings during left-to-right turns.

–

Common Mistakes: Students very often do not normalize their time steps ( $d t$ ) in their integration loops, resulting in jerky/discontinuous movement. This experiment makes it clear that smooth trajectory generation is important.

Result: As illustrated with Figure 3, the trajectory of the robot during this experiment demonstrated smooth transitions at each zero-crossing point, supporting the robustness of the inverse kinematics process implemented for the purpose of dynamically accelerating the robot.

Figure 3.

Lemniscate (Figure $-$ 8) path of the robot, with the smooth transitions at all intersection points showing stable dynamic behavior.

Experiment 3: Autonomous goal regulation (PI Control)

Objective: Implement and tune a closed-loop feedback control system using a full proportional–integral (PI) control law.

Student Activity: Each student will implement and tune four gains: the proportional linear gain $K_{ρ}$ , the proportional angular gain $K_{α}$ , and the integral gains $K_{I ρ}$ and $K_{I α}$ , to achieve closed-loop convergence based on their own experimental observations. Students are required to implement a discrete-time accumulator for each integral term and to apply a sign-change reset condition to avoid windup.

Learning Outcome: Concepts related to asymptotic stability and the significance of aggressive versus conservative tuning will be reinforced through student observation. The integral term additionally illustrates how steady-state offset errors in $ρ$ and $α$ — which persist under pure proportional control — are eliminated over time.

Student Observation: When $K_{α}$ is set too low, the robot orbits the target; when it is set too high, the robot oscillates in place. When $K_{I α}$ is too large, students will observe windup-driven overshoot in heading correction, motivating the need for the sign-change reset.

Results: Using the tuned gains (case study values: $K_{ρ} = 0.8$ , $K_{α} = 4.0$ , $K_{I ρ} = 0.05$ , $K_{I α} = 0.10$ ; gains should be re-tuned for other platforms), the robot corrects its initial heading error $α$ below the allowable threshold and converges to the target position $(7, 7)$ with position error $ρ < 0.1$ m, as illustrated in Figure 4, which shows the robot first rotating to correct its heading error before driving asymptotically toward the goal.²⁸

Figure 4.

The Autonomous Navigation Results, which show that the robot first rotated to correct its heading error and subsequently drove asymptotically towards the target.

Assessment strategy

Learning outcomes of students are assessed using a mixed-method evaluation on the grounds of both applied and theoretical knowledge.

Assessment components

Code Quality and Implementation (40%): Students are tested on the modularity, efficiency using the design of their Python control scripts. Specific attention is given to the correct vectorization of Jacobian matrices (to avoid inefficient iteration loops) and made in the way that they can be easily migrated to ROS2 later.

Simulation Lab Report (30%): Every student is required to submit a Technical Report, in which he/she will present his or her results of the experiment. The main section of this report will be the graphical work of plotting trajectory error curves ( $e (t)$ vs. time) and a qualitative analysis of how the widths of the tracks ( $d$ ) impact the rotational stability of the robot in the “Figure $-$ 8” maneuver.

Demonstration of Hardware (30%): This is a binary (Pass/Fail) capstone test. The validated code of the student will be executed on a physical differential drive platform (Ati Sherpa RP in this case ). The robot will need to be able to successfully navigate a complex route without any help and remain within the range of parameters that the instructor has established.

Grading rubric

To ensure a uniform grading process for all students receiving this guide, the following guidelines apply.

Algorithmic Performance: Did the robot execute the path geometry defined in the instructional experiments? (Main metric).

Control Stability: Did the motion of the robot appear to be smooth, or did it oscillate due to improper gain tuning ( $K_{ρ}$ , $K_{α}$ )?

Reusability of Code: Robot kinematic logic is separated or isolated from the control loop so it can be easily redeployed by changing parameters ( $r$ , $d$ ) for the robot.

Reproducibility and open access

The framework has been designed for broad institutional adoption with minimal dependencies.

Simulation environment

Modules A and B (theoretical derivation and simulation, Weeks 1–3) require no physical hardware: students run IR Sim on any personal computer (Windows, Linux, or macOS) using only standard Python packages (NumPy, Matplotlib). The complete kinematic and control logic—including all three student-developed nodes—can be implemented and validated entirely in simulation before any hardware is available, making the framework suitable for institutions without a robot laboratory.

Module C (hardware deployment, Week 4) requires a differential drive robot running ROS 2 Humble or later, but it is not specific to the Ati Sherpa RP. Suitable alternative platforms include the TurtleBot 3, Clearpath Jackal, or any custom differential drive build. The only platform-specific inputs are the wheel radius $r$ and track width $d$ , substituted as scalar parameters in the kinematic node (Equations 3–7); all other code, node interfaces, and assessment rubrics transfer without modification.

System configuration

To reproduce the results presented in this paper exactly (Ati Sherpa RP, Experiment 3), the following parameter values must be established in the simulation script:

Wheel radius: $r = 0.10$ m

Track width: $d = 0.46$ m

Velocity limits: $v_{max} = 0.8$ m/s, $ω_{max} = 2.5$ rad/s

Proportional gains: $K_{ρ} = 0.8$ , $K_{α} = 4.0$

Integral gains: $K_{I ρ} = 0.05$ , $K_{I α} = 0.10$

Anti-windup: sign-change accumulator reset on $ρ$ and $α$

Suitability for remote and virtual laboratories

The construction of the software component is not directly dependent on any device drivers, which means that students can conduct their closed-loop control and kinematic simulations on a standard personal computer (regardless of operating system), using VS Code, to validate their logic before physically executing their software on the target platform’s ROS 2 middleware in the laboratory.

Conclusion

The comprehensive experiential learning framework described in this paper provides a curriculum for the instruction of a non-holonomic mobile robot kinematics and control through a case study on the Ati Sherpa RP platform. This framework also provides an integrated means of combining mathematical derivation and a structured computer simulation of robotics, thereby providing a common pedagogical link between abstract control theory and practical application. The degree of educational effectiveness of this framework is represented through the staged development of instructional simulations. In contrast to the theoretical approach of teaching kinematics and control, the use of platform-specific verification—such as the timing of the Figure of eight continuous trajectory—forces students to consider the underlying physical constraints imposed by the non-holonomic nature of mobile robots ( ${\dot{y}}_{R} = 0$ ) and the need for an exact Jacobian formulation. Achieving a properly tuned PI controller is not only a technical accomplishment but also serves to provide a concrete representation of the closed-loop stability concept to students. The work demonstrates that the framework has great versatility for a variety of curricula. Although this project made use of the Ati Sherpa RP, the modular nature of the architecture implemented in Python allows the core algorithms to be modified for any differential drive system simply by changing the values of track width ( $d$ ) and wheel radius ( $r$ ). This flexibility will make it easy to incorporate the module into undergraduate robotics courses, mechatronics labs, or intensive ROS2 workshops regardless of the hardware that is available at an institution. Future versions of this curriculum will contain advanced material including Simultaneous Localization and Mapping (SLAM) and sensor fusion that uses the framework to be compatible with the ROS2 ecosystem. The work provides educators with a validated and openly available resource to prepare the upcoming generation of roboticists in the basics of autonomous mobility. A limitation of the current study is that no formal assessment data were collected in semesters prior to the framework’s introduction, precluding a direct cohort-to-cohort comparison.

Footnotes

ORCID iDs

Chiranjibi Champatiray

Amruta Rout

Funding

The author received no financial support for the research, authorship, and/or publication of this article.

Declaration of conflicting interests

The author declared no potential conflicts of interest with respect to the research, authorship, and/or publication of this article.

Data Availability Statement

Data sharing not applicable to this article as no datasets were generated or analyzed during the current study.

References

Verner

Ahlgren

. Conceptualising educational approaches in introductory robotics. Int J Elect Eng Educ 2004; 41: 183–201.

Zhong

Liu

Xia

, et al. A proposed taxonomy of teaching models in STEM education: robotics as an example. Sage Open 2022; 12: 21582440221099525.

Wang

, et al. Online robotics technology course design by balancing workload and affect. J Integrat Design Process Sci 2023; 26: 131–158.

Mysorewala

Cheded

. A project-based strategy for teaching robotics using NI’s embedded-FPGA platform. Int J Elect Eng Educ 2013; 50: 2.

Liang

. The impact of educational robotics, virtual, and unplugged coding on EFL learners’ problem-solving, computational thinking, and coding skills. J Educ Comput Res 2025; 63: 1689–1716.

Amorim

Moraes

Neto

, et al. A practical approach to teaching differential robot control using a goal-to-goal interface. In: 2024 Brazilian symposium on robotics (SBR) and 2024 workshop on robotics in education (WRE) 2024 Nov 13, pp.295–300. IEEE.

Pinto

Carvalho

Sousa

, et al. A ROS2-Based robotics course for undergraduate program. In: 2025 Brazilian symposium on robotics (SBR) and 2025 workshop on robotics in education (WRE) 2025 Oct 13, pp.308–313. IEEE.

Ventuzelos

Leo

Sousa

. Teaching ros1/2 and reinforcement learning using a mobile robot and its simulation. In: Iberian robotics conference 2022 Nov 19, pp.586–598. Cham: Springer International Publishing.

Balbuena

Sinche

Quiroz

, et al. PlatROB: An open-source, modular, and low-cost hardware platform for mobile robotics and AI education. HardwareX 2026; 25: e00747.

10.

Márquez-Sánchez

Sandoval-Gutiérrez

Martínez-Vázquez

. Construction of an educational prototype of a differential wheeled mobile robot. Hardware 2026; 4: 2.

11.

Biggs

Tang

Kennedy

. Teaching for quality learning at university 5e. McGraw-hill Educ (UK) 2022.

12.

Pavlasek

Riopelle

Narula

, et al. Designing a versatile robot framework for undergraduate robotics education. In: 2025 ASEE Annual conference & exposition 2025.

13.

James

Seth

Mukhopadhyay

. Mecqabot: A modular robot sensing and wireless mechatronics framework for education and research. In: 2024 17th International conference on sensing technology (ICST) IEEE, 2024, pp.1–6.

14.

Subramanian

. Build Autonomous Mobile Robot from Scratch Using ROS. 2023.

15.

Sweller

. Cognitive load during problem solving: Effects on learning. Cogn Sci 1988; 12: 257–285.

16.

Kirschner

Sweller

Clark

. Why minimal guidance during instruction does not work: An analysis of the failure of constructivist, discovery, problem-based, experiential, and inquiry-based teaching. Educ Psychol 2006; 41: 75–86.

17.

Rubio

Llopis-Albert

Valero

, et al. A new approach to the kinematic modeling of a three-dimensional car-like robot with differential drive using computational mechanics. Adv Mechan Eng 2019; 11: 1687814019825907.

18.

Albagul

. Wahyudi. Dynamic modelling and adaptive traction control for mobile robots. Int J Adv Robot Syst 2004; 1: 16.

19.

Fruchard

Morin

Samson

. A framework for the control of nonholonomic mobile manipulators. Int J Rob Res 2006; 25: 745–780.

20.

Jaramillo-Morales

Dogru

Gomez-Mendoza

, et al. Energy estimation for differential drive mobile robots on straight and rotational trajectories. Int J Adv Robot Syst 2020; 17: 1729881420909654.

21.

Steinmetz

Demo Rosa

Augusto Kich

, et al. World models for autonomous navigation of terrestrial robots from LIDAR observations. J Intell Fuzzy Syst 2025; 50: 18758967251399741.

22.

Wang

Mei

Liang

, et al. Dynamic feedback tracking control of non-holonomic mobile robots with unknown camera parameters. Trans Inst Measur Control 2010; 32: 155–169.

23.

Ali

Mailah

. A simulation and experimental study on wheeled mobile robot path control in road roundabout environment. Int J Adv Robot Syst 2019; 16: 1729881419834778.

24.

Abed

Rashid

Abedi

, et al. Trajectory tracking of differential drive mobile robots using fractional-order proportional-integral-derivative controller design tuned by an enhanced fruit fly optimization. Measure Control 2022; 55: 209–226.

25.

Guizani

Aloui

Hammadi

, et al. A new sysML profile for autonomous mobile robots development: ROS2ML. Proc Instit Mech Eng, Part C: J Mech Eng Sci 2023; 237: 3650–3664.

26.

Chai

Zhang

Tan

. Optimized trajectory tracking control with disturbance resistance for wheeled mobile robot. Trans Instit Measure Control 2025; 47: 2317–2330.

27.

Wang

. A virtual reference trajectory scheme for tracking control of wheeled mobile robots with slip disturbances. Trans Inst Measure Control 2025; 47: 75–83.

28.

Azzabi

Nouri

. Design of a robust tracking controller for a nonholonomic mobile robot based on sliding mode with adaptive gain. Int J Adv Robot Syst 2021; 18: 1729881420987082.

29.

Ati Motors Inc. Sherpa RP Product Documentation, Version 1.0. Ati Motors Inc., May 2025. Available: https://github.com/AtiMotors/Sherpa-Research.

30.

Khalid

Kazim

Diaz

Iqbal

. Breaking barriers in higher education: Implementation of cost-effective social constructivism in engineering education. Int J Mech Eng Educ 2025; 53(1): 211–235.