Construction of an Educational Prototype of a Differential Wheeled Mobile Robot

Abstract

This work presents the development of a differential-drive wheeled mobile robot educational prototype, manufactured using 3D additive techniques. The robot is powered by an embedded ARM-based computing system and uses open-source software. To validate the prototype, a trajectory-tracking task was successfully implemented. The aim of this contribution is to provide an easily replicable prototype for teaching automatic control and related engineering topics in academic settings.

1. Introduction

Wheeled mobile robots have recently become highly relevant in education, research, and industry. Their mechanical simplicity and versatility make them ideal platforms for hands-on exploration of fundamental concepts like kinematics, control, perception, and programming. In research, wheeled mobile robots are often used as testbeds to validate localization, trajectory planning, navigation, and cooperation algorithms. This work introduces an educational prototype of a differential wheeled mobile robot, highlighting its novel educational utility. The most relevant contributions in this area are presented below.

The literature related to educational differential wheeled mobile robots includes contributions in the following categories: educational prototypes and platforms for general robotics teaching [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]; the use of robots in STEM projects and active learning [16,17,18,19]; and experimentation, control, and programming of educational robots [20,21,22,23,24,25,26,27,28,29]. The tasks typically addressed in the context of education or research include environmental cleaning and maintenance [1,10,16], as well as autonomous navigation and trajectory tracking [13,18,22,26,27]. Regarding programming approaches, the reported methods include block-based programming [4,6,14,19,23], textual programming (Arduino, C/C++, Python, MicroPython, ROS, etc.) [1,2,3,7,8,9,10,11,12,13,15,16,17,18,20,21,22,24,25,26,27,29], and hybrid approaches [3,4,6,8,23]. Regarding the types of platforms employed, studies report the use of commercial robots [1,3,18,21,24], custom-built robots [2,5,6,8,10,11,12,13,14,15,16,17,19,20,22,26,27,28,29], and mixed platforms [4,7,8,23]. Regarding the main processing unit, the most frequently reported devices are: Arduino [2,4,11,12,22,29], LEGO [1,3,18,21], Raspberry Pi [7,12,18], ESP32 [5,20,24,26,27], and Micro:Bit [6]. Regarding the robot structure, reported designs include commercial kits (injection-molded plastic, LEGO, Microbit) [1,3,6,18,21,24]; 3D-printed components [6,7,8,28,29]; low-cost commercial components [4,14,16,18,19,20,23]; and metallic structures [10,12,17,20].

Previous commercial and educational robots (such as LEGO platforms, Jetbot, and Duckiebot) present limitations related to structural robustness, motor durability, and cost. LEGO kits lack the mechanical strength required to incorporate advanced sensors or support more complex experimentation; Jetbot uses plastic-geared motors that wear out with use; and Duckiebot is expensive for many institutions in Latin America. The proposed prototype overcomes these limitations by incorporating metal-geared motors that enhance durability, a 3D-printed chassis that enables structural customization, and a significantly lower total cost (approximately 250 USD), making it a more accessible and research-oriented alternative for robotics education.

On the other hand, the literature supports the technological decisions adopted in this prototype. 3D printing (primarily using PLA) has become a standard manufacturing method for educational robots, offering sufficient strength for academic applications, as discussed in [30]. It has also been demonstrated that the Jetson Nano can perform real-time AI inference with low latency, as shown in [31], making it a suitable embedded platform for robotics education and research. Furthermore, Python remains one of the most widely used languages in robotics education due to its extensive ecosystem of libraries for control, vision, simulation, and machine learning, as evidenced in [32]. These findings support the use of 3D printing, Jetson Nano, and Python in the proposed prototype.

Based on the review above, this work addresses the development of an educational prototype of a differential wheeled mobile robot. The intention is to use this prototype for undergraduate and graduate-level courses, as well as in research areas such as automatic control and artificial intelligence. A key feature of this prototype is its modular design, which allows for future functionality expansions by adding new hardware modules. For example, a camera can be added to perform vision-based tasks, and infrared sensors can be used for line-following applications. Additionally, as a custom-built solution, cost reduction was pursued, resulting in a prototype costing approximately $250 USD. This is significantly lower compared to commercial robots with similar capabilities, such as Jetbot [33], which ranges from $256 to $552 USD [34,35], or Duckiebot, priced at approximately $549 USD [36].

It is worth mentioning that these commercial robots [33,34,35,36] typically use plastic-geared motors, which are cheaper but less durable. In contrast, the proposed prototype uses metal-geared motors, which offer greater wear resistance and longer operational life. The robot structure is manufactured using additive techniques (3D printing), enabling easy modification when adding new hardware elements. For software, all codes are written in Python 3.12. Python offers a short learning curve, broad library support, a strong online community, and open-source licensing, which eliminates licensing costs. The main processing unit is the Jetson Nano development board, manufactured by NVIDIA. This embedded system is based on ARM architecture and has a GPU with 128 CUDA cores. These features support AI libraries and equip the robot with advanced processing capabilities for future applications.

The remainder of this article is organized as follows: Section 2 describes the design of the differential wheeled mobile robot. Assembly instructions are provided in Section 3. Operational guidelines are presented in Section 4. Section 5 outlines the validation process of the proposed prototype. Finally, Section 6 presents the conclusions of this work.

2. Design

The prototype’s design consists of three main components: additive manufacturing, hardware, and software. The following sections detail each component and the bill of materials.

2.1. Bill of Materials

Table 1. Bill of materials.

Quantity	Component	Source of Materials	Material Type	Cost
1	Jetson Nano	Amazon	Embedded System	$165
1	Chassis	Amazon	PLA (Plastic)	$5
2	GM 25-370 Motor with Encoder 12 V DC 140 RPM	Uelectronics	Electromechanical	$21.3
1	L298N Motor Driver Module	Uelectronics	Electronic Component	$3.2
1	Arduino Nano ATMEGA328P Dev Board USB-C with Male Headers	Uelectronics	Microcontroller	$4.5
2	Lipo Battery 3S 50C 2200 mAh 11.1 V	Amazon	Electrical Component	$30.7
1	Buck Converter	Amazon	Electronic Component	$5.3
2	Rocker Switch DPST 2-Position 15 A/8 A	Steren	Electromechanical	$2.7
2	TT Motor Wheel 65 × 15 mm	Uelectronics	Plastic Component	$2
1	Glass Marble	Amazon	Glass	$0.1
1	20 AWG Silicone Wire	Amazon	Cable	$1
1	M3 Screws	Amazon	Metal Hardware	$1.3
1	TX60 Male Connectors	Amazon	Electrical Connector	$3
1	USB-A to USB-C Cables 6-inch	Amazon	Cable	$2.2
1	5.5 mm × 2.1 mm Barrel Plug	Amazon	Electrical Connector	$0.4
1	Phenolic Perforated Board 4.5 cm × 4.5 cm	Steren	Fiberglass/Epoxy Board	$0.5
12	Nylon PCB Spacer M3 × 5 mm	Uelectronics	Plastic Spacer	$2

lists the materials required to construct the wheeled mobile robot prototype.

Because several components are sold in bulk, some clarifications are necessary: the table lists only the exact quantities used. About 360 g of PLA filament is needed for manufacturing all robot structural parts. Only one glass marble (a small glass sphere) is required; however, it can be replaced with a metal sphere, although the latter has a higher cost. Around 1 m of each red and black 20 AWG silicone wire is used. The wire color is optional. Only eight screws are required. Two male XT60 connectors are needed. Finally, one USB-A-to-USB-C cable is used.

In

Table 2. Design file summary (Please refer to the Supplementary Materials for details).

Design File Name	File Type	Description
3Dfiles	rar	STL files for Robot’s structural parts.
jetsonCode	rar	Jetson Nano’s Python scripts.
arduinoCode	Ino	Arduino’s codes.

, the design file summary is presented. The ‘archivo3D’ archive contains STL design files for 3D printing the robot’s structural parts: chassis base, chassis top cover, shaft couplings, and ball caster mounting. The ‘jetsonCode’ archive contains Python programs for implementing robot control and sensor integration. The ‘arduinoCode’ archive provides the firmware source code for the Arduino Nano microcontroller.

2.2. Additive Manufacturing

The robot’s chassis was designed in Tinkercad, a free, user-friendly online 3D design tool. The chassis consists of two parts: the base and the top cover. The chassis base contains motors, electronics, and batteries. The top cover supports the Jetson Nano board. Figure 1 shows the chassis view, Figure 2 displays the top cover, and Figure 3 shows the complete assembly. Custom shaft couplings were designed to attach the wheels to the motors (Figure 4). To support the chassis, a ball caster was designed using a glass marble and a 3D-printed mounting (Figure 5).

2.3. Hardware Integration

Figure 6 illustrates the overall hardware interaction diagram. The Jetson Nano board acts as the main control unit and communicates with the Arduino to generate control signals for the H-Bridge. The H-Bridge provides the necessary voltage to drive the motors, which are connected to encoders. These encoders generate pulses that the Arduino reads to close the feedback loop.

To facilitate the connections between the Arduino Nano and the other electronic components, a custom printed circuit board (PCB) was developed. Figure 7 shows the design of this board.

2.4. Software Design

The robot’s logic is implemented on the Jetson Nano development board. Although the Jetson Nano supports multiple programming languages, Python was selected because of its rich ecosystem of libraries, ease of use, and open-source nature. The Jetson Nano features a quad-core ARM Cortex-A57 processor, a 128-core Maxwell GPU, 4 GB of LPDDR4 RAM, and runs a customized Linux-based Ubuntu operating system with full support for AI libraries.

Figure 8 presents the main control program flowchart for the Jetson Nano. First, all initializations are performed. After checking if the total experiment time is reached, three functions are executed in the following order: ‘ReadEncoders’, ‘Controller’, and ‘Motors’. Continuously, total experiment time is rechecked and, if reached, the ‘Plot’ function is executed before the end of the program. As its name states, ‘ReadEncoders’ function reads the robot wheels’ angular velocities provided by the Arduino. The ‘Controller’ function calculates the automatic control law that guarantees trajectory-tracking tasks based on the previously read angular velocities. The ‘Motors’ function codifies the results of the ‘Controller’ function to send variables to Arduino in order to generate the corresponding PWM signals for H-Bridge driving.

The Arduino Nano main flowchart is shown in Figure 9a. First, general initialization, including variable setup, interrupt setup, and serial communication setup, is performed. The main loop is executed indefinitely and consists of calculating the wheels’ angular velocities, reading the PWM serial data sent by the Jetson Nano, decoding, and generating PWM signals. The Jetson Nano sends string data in the format: “D,value,I,value” where D and I stand for the right and left, respectively. Once a valid string is read, the decoding task consists of extracting right and left PWM data. The sign of each value determines the rotation direction. Arduino’s dedicated hardware is used for PWM generation.

To calculate the wheels’ angular velocities, an interrupt routine is required. The Encoder interrupt flowchart is shown in Figure 9b. The interrupt routine is triggered when a change is detected in Arduino’s PortD. The routine is as follows: (1) The PortD register is read. (2) A digital mask is applied to isolate pins D2–D5. D2 and D3 correspond to the right motor encoder, while D4 and D5 correspond to the left one. (3) Based on the signal transitions, the direction is determined. If a clockwise transition is detected, the encoder counter is incremented; otherwise, it is decremented.

2.5. Control Law

In automatic control, robots can be designed to perform various tasks; one such task is trajectory tracking. This task consists of guiding the robot along a predefined trajectory at a specified velocity. The reference trajectory is defined as a time-dependent function. Thus, at each time instant, the desired position $(x^{*},y^{*})$ and orientation $\left({\varphi }^{*}\right)$ are specified.

The control law used in this work is described in [37]. This control law is designed specifically for differential-drive mobile robots, such as the one proposed here. It was selected due to its low computational complexity and its robustness to moderate uncertainties in the robot’s kinematic parameters. These characteristics make it well suited for implementation on embedded systems. Additionally, this control law ensures the convergence of the robot’s position and orientation errors while relying only on simple algebraic operations and without requiring high-resolution measurements.

According to [37], the control law for the trajectory-tracking task is defined as:

$$\begin{gathered} {\upsilon }_f={\upsilon }_r\cos e_3+K_1{e}_1, \\ {\omega }_f={\omega }_r+{\upsilon }_r{K}_2{e}_2+K_3\sin e_3, \end{gathered}$$

(1)

where

$$\left(\begin{array}{c}{e}_1\\ e_2\\ e_3\end{array}\right)=\left(\begin{array}{ccc}\cos \varphi & \sin \varphi & 0\\ -\sin \varphi & \cos \varphi & 0\\ 0& 0& 1\end{array}\right)\left(\begin{array}{c}{x}^{*}-x\\ y^{*}-y\\ {\varphi }^{*}-\varphi \end{array}\right),$$

(2)

Let $(x,y)$ be the robot’s position and $\varphi$ the orientation angle, $K_1,K_2, K_3$ are the controller gains, while ${\upsilon }_r$ and ${\omega }_r$ denote the desired linear and angular velocities, respectively.

Regarding the values of the gains $K_1,K_2,$ and $K_3$, an experimental procedure was carried out based on the stability conditions established in [37]. First, it was verified that the gains satisfied the required positivity conditions, which are necessary to ensure system stability and adequate damping of errors. Then, a systematic exploration of gain values was performed directly on the robot, evaluating the effect of each gain set in terms of overshoot, reaction time, and smoothness of motion. Based on these criteria, the selected gains were $K_1=5$, $K_2=1$, and $K_3=5$, as this set provided the best balance between stability and trajectory-tracking accuracy.

It is important to note that this control law can be replaced by any other, which is highly desirable for both educational and research purposes.

3. Build Instructions

The construction of the prototype is divided into the following sections: chassis, hardware, and software, which are described in detail below.

3.1. Software

For the steps described in this section, the Jetson Nano board must be disconnected from the chassis and the Arduino Nano. The Jetson Nano should be connected to the necessary peripherals, including a monitor, keyboard, and mouse, as well as to a power supply (see Figure 10a). The Arduino Nano must be connected to a PC with the Arduino IDE installed (see Figure 10b).

To enable the robot’s functionality, both the Jetson Nano and the Arduino Nano must be programmed. The configuration and programming steps for the Jetson Nano are presented first, followed by those for the Arduino Nano.

Jetson Nano: The following instructions assume that the initial setup of the Jetson Nano has already been completed. For a full guide on the initial configuration, please refer to the official Nvidia documentation [38].

To run the software developed in this work, several Python libraries must be installed. It is strongly recommended to create a virtual environment. The required libraries are:

• Numpy 1.13.3
• Matplotlib 2.1.1
• Scipy 0.19.1
• Multiprocessing

Once the libraries are installed, the Supplementary Materials containing the robot’s code can be cloned. It is recommended to create a dedicated folder for this purpose.

Arduino Nano: The code for the Arduino Nano can also be found in the Supplementary Materials. After downloading the source code, it can be uploaded to the Arduino Nano using the Arduino IDE.

3.2. Chasis

The chassis, top cover, caster wheel base, and shaft couplings are fabricated using a 3D printer. The following specifications were used for 3D printing:

• Filament type: PLA
• Material used for chassis: 242 g
• Material used for top cover: 110 g
• Infill density: 30%
• Support type: Tree
• Bed adhesion: None

Figure 11 shows the printed chassis, and Figure 12 shows the top cover. Figure 13 displays the shaft couplings, and Figure 14 shows the caster wheel. For the caster wheel, a glass marble must be placed inside the printed base (see Figure 14b), and then the entire caster wheel should be press-fitted into the underside of the chassis (see Figure 15).

3.3. Hardware

Once the chassis and top cover are ready, the remaining components can be installed. The following steps should be followed for the chassis:

• Mount the motors to the chassis using two M3 screws for each motor.
• Install the H-Bridge and secure it with nylon standoffs and M3 screws.
• Insert the Arduino Nano into the PCB (the PCB should be fabricated according to the schematic shown in Figure 7).
• Attach the PCB to the chassis using nylon standoffs and M3 screws.
• Install both batteries.

Next, the electronic components must be connected as shown in Figure 16. The batteries should be connected last and only with the power switch in the OFF position. Connections for the encoders and motors should be verified against the component datasheets, as they may vary depending on the manufacturer.

The steps to install the components onto the chassis cover are as follows:

• Figure 17 shows the electrical connections for powering the Jetson Nano.
• Mount the Jetson Nano to the top cover using nylon standoffs and M3 screws.
• Fabricate a custom cable using a male XT60 connector and a switch with 20 AWG (American Wire Gauge) wire. This cable connects one battery to the voltage regulator (see Figure 17).
• Fabricate a barrel connector cable using 20 AWG wire. This cable connects the voltage regulator to the Jetson Nano (see Figure 17).
• Fabricate another custom cable using a male XT60 connector and a switch with 20 AWG wire. This cable connects one battery to the H-Bridge (see Figure 16).
• Place the fabricated cables and switches on the chassis cover.
• Install the voltage regulator and connect the fabricated cables.
• Connect the Arduino Nano to the Jetson Nano using a USB A to USB C cable.

Figure 18 shows the top cover with all components installed.

Finally, the shaft couplings are mounted onto the motor shafts (see Figure 19a), followed by the wheels (see Figure 19b). Figure 20 shows the fully assembled prototype, which has been internally named MiniRoby. If different wheels are used, the shaft couplings may need to be modified to fit the new wheel dimensions—this is one of the advantages of using 3D printing.

4. Operating Instructions

4.1. Functionality Verification

To perform the following verification steps, the robot must be placed on a platform such that the wheels do not touch the ground (see Figure 21). Additionally, a VNC connection must be configured in advance (although tools like PuTTY can be used, VNC is preferred for viewing the plots generated by the program). A PC is also required to establish the VNC connection. Figure 22 shows a general diagram of the components and their connections for VNC setup (several tutorials are available online for configuring VNC on Ubuntu).

Before using the prototype, it is essential to ensure that all components are functioning correctly. The following elements must be verified:

• The left and right motors are connected to the correct sides and rotate in the correct direction.
• The Arduino Nano properly reads the encoder signals.
• The Jetson Nano successfully communicates with the Arduino Nano.

To facilitate this process, a Python script has been developed for testing. To run the script, open the terminal and navigate to the “Test” folder, where the test.py script is located (this folder was downloaded in Section 3.1). Execute the following command:

sudo python3 test.py

This script will sequentially perform the following actions:

• Rotate the right wheel clockwise for 3 s while the left wheel remains stationary.
• Rotate the left wheel counterclockwise for 3 s while the right wheel remains stationary.
• Rotate both wheels clockwise for 3 s.
• Rotate both wheels counterclockwise for 3 s.
• Plot the angular velocity data for both wheels.

If everything is connected and functioning correctly, results similar to those in Figure 23 should be observed.

Potential errors and troubleshooting:

• Serial connection failure: This occurs when communication between the Arduino and Jetson Nano is not correctly established. Check the serial port name and/or the USB cable used.
• Wheel rotates in the wrong direction: If a wheel rotates in the opposite direction to what is expected, reverse the motor wire connections on the H-Bridge.
• One or both motors do not rotate: Check the wiring from the motor to the H-Bridge. If both motors fail to rotate, ensure that the motor switch is set to the ON position.

4.2. Execution of Experiments

Once all connections have been verified and the robot is operating correctly, experiments can be conducted. It is important to have a workspace free of obstacles, as this version of the prototype does not include obstacle detection sensors.

The following steps must be followed to execute an experiment:

• Place the robot in the workspace. The location where the robot is placed will be considered its initial position (0, 0).
• Ensure the switch associated with the motors is in the OFF position.
• Turn ON the switch connected to the Jetson Nano.
• Establish a VNC connection from the PC.
• Open the terminal and navigate to the experimento directory.
• Turn ON the switch associated with the motors.
• Run the following command:

sudo python3 principal.py

At this point, the robot will begin to move and execute the trajectory tracking task. The desired trajectory must be programmed in advance in the trajectory.py script.

• After completing the experiment, the robot will stop and the relevant variable plots will be displayed. These plots can be customized based on the problem under study.
• Turn OFF the switch associated with the motors.

These steps must be repeated each time a new experiment is performed. After each experiment, the plotted variable values are stored in plain text files, which can later be used in software such as MATLAB if needed.

5. Validation

To validate the functionality of the developed prototype, a series of experimental tests were conducted. The experiments consisted of tracking predefined trajectories, namely: linear, circular, sinusoidal, and complex trajectories. All tests were performed in an indoor obstacle-free environment.

First, the correct motion of the developed prototype is validated. The movements that a differential-drive robot can perform can be classified into two types: forward and backward motion, and turning (left or right). By combining these two basic movements, the robot can execute more complex maneuvers. To validate these basic movements, a dedicated test is conducted for each one. After validating the basic motions, the next step is to verify that the robot can perform the trajectory-tracking task. These tests are described in the following sections.

5.1. Robot Specifications

To conduct the experiments, it is first necessary to know the physical parameters of the robot, as these parameters determine the operating limits and directly influence the robot’s performance. These parameters are presented in

Table 3. Robot parameters.

Parameter	Value
Robot mass (with all components)	0.935 kg
Distance between wheels	18 cm
Wheel radius	3.25 cm
Maximum payload	3 kg
Linear velocity (min–max)	≈3.7–39 cm/s
Angular velocity (min–max)	≈0.4–4.2 rad/s
Chassis width	13.6 cm
Chassis length	17.5 cm
Robot height (with components)	11.2 cm
Motor operating voltage	11.1 V
Embedded system operating voltage	5 V

. Obtaining them does not require complex experimentation, as they correspond to characteristics directly associated with the system’s design. These specifications are essential, as they allow for a proper understanding of the experimental results presented in the following sections.

5.2. Forward Motion Test

This test is used to verify that the robot can move forward and backward, as well as to compare the physically measured distance traveled with the distance computed using the encoder sensors.

For this test, the robot is programmed to move 1 m in a straight line at a constant velocity. A starting mark is placed on the floor where the robot is positioned, and a second mark is placed at the point where the robot stops. The distance between these two marks is then measured. Using this information, the error between the robot’s computed distance and the actual distance traveled is calculated using the following formula:

$$e_d=desired\_distance-measured\_distance,$$

(3)

The mean error is also computed:

$${\overline{e}}_d={\displaystyle \frac{1}{n}}\sum e_d,$$

(4)

where $n$ is the number of samples. The standard deviation is calculated as follows:

$$s=\sqrt{{\displaystyle \frac{\sum {(e_d-{\overline{e}}_d)}^2}{n-1}}},$$

(5)

Table 4. Error results.

Sample	Forward	Backward
	${\mathit{e}}_{\mathit{d}\mathit{f}}\left(\mathbf{c}\mathbf{m}\right)$	${\mathit{e}}_{\mathit{d}\mathit{b}}\left(\mathbf{c}\mathbf{m}\right)$
1	0.5	−0.5
2	0.5	−0.7
3	0.8	−0.7
4	0.1	−0.8
5	0.5	−1
6	0.3	−1
7	0.2	−0.6
8	0.4	−0.8
9	0	−0.8
10	0.6	−0.8

presents the measured values for the forward and backward motion tests, both performed with a linear displacement of 1 m at a constant velocity of $19 \mathrm{m}/\mathrm{s}$. Based on these data, the mean error for forward motion is ${\bar{e}}_f=0.39$ cm, and for backward motion ${\bar{e}}_b=-0.77$ cm. The standard deviation for forward motion is $s_f=0.24$ cm, and for backward motion $s_b=0.157$ cm.

A sample size of 10 measurements was considered, given that the developed prototype is intended for academic and research purposes and is not designed to achieve industrial-grade or high-precision performance.

5.3. Turning Test

This test is carried out to verify the correct turning performance of the robot, both to the left and to the right, and to compare the physically measured turning angle with the angle calculated using the mathematical model.

For this test, a cross mark is drawn on the floor, and the robot is aligned with one of its arms. The robot is then programmed to rotate by a specific angle, either clockwise or counterclockwise, and the resulting angle is measured relative to the initial mark. The angular error is computed using the following expression:

$$e_{\theta }={\theta }_{desired}{-\theta }_{measured},$$

(6)

The mean angular error is calculated using:

$${\overline{e}}_{\theta }={\displaystyle \frac{1}{n}}\sum e_{\theta },$$

(7)

where $n$ is the number of samples. The standard deviation is computed using the following expression:

$$s_{\theta }=\sqrt{{\displaystyle \frac{\sum {(e_{\theta }-{\overline{e}}_{\theta })}^2}{n-1}}},$$

(8)

In

Table 5. Turning error results.

Sample	Clockwise (CW)	Counterclockwise (CCW)
	${\mathit{e}}_{\mathit{c}\mathit{w}}(°)$	${\mathit{e}}_{\mathit{c}\mathit{c}\mathit{w}}(°)$
1	−6	−4
2	−5	−4
3	−6	−3
4	−4	−3
5	−4	−4
6	−5	−2
7	−4	−3
8	−4	−4
9	−3	−4
10	−4	−6

, the measured values for the clockwise and counterclockwise turning tests are presented. In both cases, a constant angular velocity of $2.1 \mathrm{rad}/\mathrm{s}$ is used. From these data, the mean error for the clockwise turn is ${\bar{e}}_{\mathrm{cw}}=-{4.5}^{\circ }$, and for the counterclockwise turn ${\bar{e}}_{\mathrm{ccw}}=-{3.7}^{\circ }$. The standard deviation for the clockwise turn is $s_{\mathrm{cw}}={0.96}^{\circ }$, and for the counterclockwise turn is $s_{\mathrm{ccw}}={1.06}^{\circ }$.

5.4. Trajectory Tracking Test

To validate that the robot can perform the trajectory-tracking task, the following trajectories were executed: linear, circular, and sinusoidal. These trajectories were selected because they serve as the basis for more complex paths. Additionally, a complex trajectory that includes variations in both linear and angular velocity was also tested. This experiment also serves to validate that the selected embedded system is capable of executing, in real time, both the robot’s pose estimation and the control law required for trajectory tracking.

The robot was tested on a flat surface measuring 1 m × 1 m (the working area can be larger and does not need to be square; for these tests, only 1 m² was required). Since the selected control law for trajectory tracking requires both linear and angular reference velocities, these values must be provided as inputs. The parameters used for the linear, circular, and sinusoidal trajectories are listed in

Table 6. Parameters for the reference trajectories.

Trajectory	$\mathbf{Desired} \mathbf{Linear} \mathbf{Velocity} \mathbf{\left(}{\mathsf{\upsilon }}^{\mathit{*}}\mathbf{\right)}$	$\mathbf{Desired} \mathbf{Angular} \mathbf{Velocity} \mathbf{\left(}{\mathsf{\omega }}^{\mathit{*}}\mathbf{\right)}$
Lineal	0.15 m/s	0 rad/s
Circular	0.25 ms	0.5 rad/s
Sinusoidal	0.18 m/s	1.5(0.2pi)cos(0.2pi×t)
		t: time in seconds

. It is important to note that any method for generating reference trajectories may be employed, which is highly desirable in both educational and research contexts. In this regard, a complex trajectory was implemented using the method proposed in [39], which is based on Bézier polynomials to generate trajectories with smooth variations in linear and angular velocity. According to [39], the desired linear velocity ${\upsilon }^{\mathit{*}}$ and desired angular velocity ${\omega }^{\mathit{*}}$ are given by:

$${\upsilon }^{*}\left(t\right)=\psi (t,t_i,t_f)({\overline{\upsilon }}_f-{\overline{\upsilon }}_i)+{\overline{\upsilon }}_i,$$

(9)

$${\omega }^{*}\left(t\right)=\psi (t,t_i,t_f)({\overline{\omega }}_f-{\overline{\omega }}_i)+{\overline{\omega }}_i,$$

(10)

with $\psi$ defined as:

$$\psi (t,t_i,t_f)={\left({\displaystyle \frac{t-t_i}{t_f-t_i}}\right)}^3\times \left[r_1 - r_2\left({\displaystyle \frac{t-t_i}{t_f-t_i}}\right) + r_3{\left({\displaystyle \frac{t-t_i}{t_f-t_i}}\right)}^2\right],$$

(11)

where $t_i$ and $t_f$ are the initial and final times of the trajectory, respectively. The terms ${\overline{\upsilon }}_i$ and ${\overline{\upsilon }}_f$ correspond to the constant linear velocities between which the interpolation is performed over the interval $[t_i,t_f]$. Similarly, ${\overline{\omega }}_i$ and ${\overline{\omega }}_f$ are the constant angular velocities between which the interpolation is performed over the same interval. The coefficients $r_1, r_2,$ and $r_3$ correspond to the polynomial parameters, which, according to [40], are given by $r_1=10$, $r_2=15$, and $r_3=6$.

Accordingly, the parameters used for the complex trajectory based on Supplementary Materials are presented in

Table 7. Parameters for the complex trajectory.

Time (t)	$\mathbf{Desired} \mathbf{Linear} \mathbf{Velocity} \left({\mathsf{\upsilon }}^{\mathit{*}}\right)$	$\mathbf{Desired} \mathbf{Angular} \mathbf{Velocity} \left({\mathsf{\omega }}^{\mathit{*}}\right)$
0 ≤ t < 1	${\upsilon }^{*}\left(t\right);$ ${\upsilon }_i=0; {\upsilon }_f=0.095$	${\omega }^{*}\left(t\right);$  ${\omega }_i=0; {\omega }_f=0.35$
1 < t < 5	${\upsilon }^{*}=0.095$	${\omega }^{*}=0.35$.
5 ≤ t < 6	${\upsilon }^{*}\left(t\right);$  ${\upsilon }_i=0.095; {\upsilon }_f=0.08$	${\omega }^{*}\left(t\right);$  ${\omega }_i=0.35; {\omega }_f=-0.35$
6 ≤ t < 10	${\mathsf{\upsilon }}^{\mathrm{*}}=0.08$	${\omega }^{*}=-0.35$
10 ≤ t < 11	${\upsilon }^{*}\left(t\right);$  ${\upsilon }_i=0.08;{\upsilon }_f=0.075$	${\omega }^{*}\left(t\right);$  ${\omega }_i=-0.35; {\omega }_f=0.25$
11 ≤ t < 23	${\upsilon }^{\mathrm{*}}=0.075$	${\omega }^{*}=0.25$
23 ≤ t < 24	$v*\left(t\right);$  ${\upsilon }_i=0.075;{\upsilon }_f=0.08$	$\omega *\left(t\right);$  ${\omega }_i=0.25; {\omega }_f=-0.35$
24 ≤ t < 28	${\upsilon }^{\mathrm{*}}=0.08$	${\omega }^{*}=-0.35$
28 ≤ t < 30	${\upsilon }^{*}\left(t\right);$  ${\upsilon }_i=0.08; {\upsilon }_f=0.095$	${\omega }^{*}\left(t\right);$  ${\omega }_i=-0.35; {\omega }_f=0.35$
30 ≤ t < 38	${\upsilon }^{\mathrm{*}}=0.095$	${\omega }^{*}=0.35$
38 ≤ t < 40	${\upsilon }^{*}\left(t\right);$  ${\upsilon }_i=0.095; {\upsilon }_f=0.08$	${\omega }^{*}\left(t\right);$  ${\omega }_i=0.35; {\omega }_f=-0.3$
40 ≤ t < 44	${\mathsf{\upsilon }}^{\mathrm{*}}=0.08$	${\omega }^{*}=-0.3$
44 ≤ t < 45	${\upsilon }^{*}\left(t\right);$  ${\upsilon }_i=0.08; {\upsilon }_f=0.075$	${\omega }^{*}\left(t\right);$  ${\omega }_i=-0.3; {\omega }_f=0.25$
45 ≤ t < 56	${\upsilon }^{\mathrm{*}}=0.075$	${\omega }^{*}=0.25$
56 ≤ t < 58	${\upsilon }^{*}\left(t\right);$  ${\upsilon }_i=0.075; {\upsilon }_f=0.08$	${\omega }^{*}\left(t\right);$  ${\omega }_i=0.25; {\omega }_f=-0.3$
58 ≤ t < 62	${\upsilon }^{\mathrm{*}}=0.08$	${\omega }^{*}=-0.3$
62 ≤ t < 64	${\upsilon }^{*}\left(t\right);$  ${\upsilon }_i=0.08; {\upsilon }_f=0.088$	${\omega }^{*}\left(t\right);$  ${\omega }_i=-0.3; {\omega }_f=0.36$
64 ≤ t < 67	${\mathsf{\upsilon }}^{\mathrm{*}}=0.088$	${\omega }^{*}=0.36$
67 ≤ t < 68	${\upsilon }^{*}\left(t\right);$  ${\upsilon }_i=0.088;{\upsilon }_f =0$	${\omega }^{*}\left(t\right);$  ${\omega }_i=0.36; {\omega }_f=0$
t ≥ 68	${\upsilon }^{*}=0$	${\mathsf{\omega }}^{\mathrm{*}}=0$

${\upsilon }^{*}$ denotes the desired linear velocity and ω∗ denotes the desired angular velocity.

.

The following figures present the results of the trajectory tracking experiments for the four predefined paths. It is worth noting that the initial robot position (x,y) was arbitrarily set to (0.67,0). This initial offset was intentionally introduced to demonstrate that the robot can converge to and follow the desired trajectory despite an initial position error, thanks to the robustness of the selected control law. Figure 24 shows the result of the linear trajectory, Figure 25 shows the circular trajectory, Figure 26 shows the result for the sinusoidal trajectory, and Figure 27 presents the result for the complex trajectory.

On the other hand, Figure 28, Figure 29, Figure 30 and Figure 31 show the tracking and orientation errors for the linear, circular, sinusoidal, and complex trajectories. As can be observed in these plots, the errors are consistent with the values computed in the previous sections.

It is important to note that mean errors and standard deviations are not calculated for this test, as the purpose is solely to validate that the robot is suitable for the trajectory-tracking task. Computing mean errors and standard deviations in this experiment would instead evaluate the performance of the control law employed, which is not the intention of this work.

5.5. Discussion of Results

The experiments carried out allowed for the validation of the proposed platform. The first two tests were conducted to verify the robot’s linear and angular motion. A summary of these results is presented in

Table 8. Mean error and standard deviation for linear and angular motion tests.

Parameter	Forward [cm]	Backward [cm]	CW [°]	CCW [°]
Mean error [°]	0.39	−0.77	−4.5	−3.7
Standard deviation [°]	0.24	0.157	0.96	1.06

, where it can be observed that the experimental data exhibit reasonable linear accuracy, with mean errors of 0.39 cm (forward) and 0.77 cm (backward) for a 1-m displacement. The standard deviation (0.24 cm) indicates good repeatability of the system. For turning movements, the mean error was 4.5° clockwise and 3.7° counterclockwise, values that correspond to good angular accuracy for a differential-drive robot without external sensors. The angular standard deviation confirms that the behavior remains consistent across repetitions.

The third test focused on validating the ability of the prototype to perform the calculations required for the trajectory-tracking task using the selected embedded system. The results shown in Figure 28, Figure 29, Figure 30 and Figure 31 illustrate the temporal evolution of the robot’s position and orientation error while tracking four different trajectories: (i) linear, (ii) sinusoidal, (iii) circular, and (iv) a complex trajectory. In all cases, the embedded system executed the kinematic model calculations for position estimation and the control law used for trajectory tracking. This confirms that the selected hardware is capable of performing the required processing without perceptible delays.

The observed position and orientation errors remain within the ranges measured during the preliminary experimental tests, which confirms the consistency between the model, the implementation, and the actual performance of the proposed robot prototype. This experimental evidence demonstrates that the robot meets its design objective by performing trajectory tracking with reasonable accuracy, making it suitable for academic and research applications.

5.6. System Limitations

During the experiments, several limitations of the robot were identified, which are described below:

• When estimating the robot’s position and orientation exclusively using the kinematic model, a small error will always be present. This can be improved by incorporating position sensors, although doing so increases the cost of the prototype.
• In practice, no two motors are identical; manufacturing processes can introduce small differences that cause one motor to rotate slightly faster than the other. This may result in forward-motion and heading errors. Such discrepancies can be mitigated by introducing a compensation factor directly into the computed wheel velocities.
• The presented prototype is designed specifically for the trajectory-tracking task. For the robot to perform additional tasks, it is necessary to integrate other sensors. Obstacle-detection sensors or cameras for vision-based tasks can be incorporated. The selected embedded system allows the integration of these and other types of sensors due to its computational capabilities.
• The robot is designed to operate on flat surfaces. On irregular floors, dusty environments, or surfaces with varying friction, wheel slip may increase position and orientation errors. Operating on irregular terrain would require a different type of locomotion.
• The forward-motion and turning tests were performed only at the mean values of the linear and angular velocities. Additional experiments using the minimum and maximum allowable velocities should be conducted to obtain a more complete characterization of the robot’s performance and potentially more precise error estimates.
• For applications beyond academic and research environments, additional mechanisms would be required to ensure safe operation.

6. Conclusions

This work presented the development of a differential wheeled mobile robot prototype for educational and research purposes. The platform integrates a Jetson Nano as the main processing unit, selected for its computational capability and compatibility with Python-based AI libraries. The robot chassis was manufactured using 3D printing, allowing rapid modifications and enabling future functional extensions.

To evaluate the robot’s basic motion capabilities, linear and angular validation tests were conducted. The linear motion tests showed good accuracy, with mean errors of 0.39 cm in the forward direction and 0.77 cm in the backward direction for 1-m displacements, and a standard deviation of 0.24 cm, indicating high repeatability. For turning movements, performance was also consistent, with mean errors of 4.5° clockwise and 3.7° counterclockwise, and standard deviations below 1.1°, values that are acceptable for a robot without position sensors.

A third set of experiments validated the robot’s ability to perform trajectory-tracking tasks, where the embedded system executed in real time both the kinematic model calculations and the selected control law. The robot successfully followed four different trajectories, namely, linear, sinusoidal, circular, and a complex trajectory, showing stable evolution of position and orientation errors over time, even when the complex trajectory included variations in linear and angular velocity.

Overall, the results demonstrate that the proposed robot offers reliable performance in linear motion, turning, and trajectory tracking, while maintaining low cost and high reproducibility. The platform is compatible with other embedded systems, such as the Raspberry Pi or Jetson Orin Nano, requiring only minor adjustments to the main software. Furthermore, its modular design facilitates the integration of additional sensors, such as cameras for vision tasks, ultrasonic sensors for obstacle detection, or infrared sensors for line following, enabling more advanced autonomous navigation capabilities in future educational and research developments.

7. Future Work

Future work will focus on integrating additional sensors into the robot to enable new types of tasks. Among the planned additions are obstacle-detection sensors to support obstacle-avoidance behaviors. A vision system is also intended to be implemented so the robot can perform computer-vision tasks. Another planned capability is line following, using sensors to detect a painted line on the floor. With these sensors, the goal is to equip the robot for autonomous navigation. Finally, didactic materials and classroom evaluations will be developed to strengthen the educational value of the platform.