Analysis of Numerical Simulation for Nonlinear Robot Control Based on Dynamic Modeling Using Low-Cost and Open-Source Technology

Abstract

Professors, students, and researchers from universities around the world use software distributed under licenses for numerical simulation purposes, which requires a computer with considerable hardware capabilities. This implies a high cost of simulations in engineering applications that require dynamic modeling using numerical methods, particularly in robotics and nonlinear control. This article compares and analyzes the performance of a frugal simulation scheme based on the use of low-cost, free, and open-source technology, specifically a low-power, single-board minicomputer (Raspberry Pi) in conjunction with GNU-Octave software. The benchmark is a numerical simulation of trajectory tracking control in the joint space of a Selective Conformal Assembly Robot Arm (SCARA). To perform this task, a system of coupled nonlinear differential equations is solved in matrix form using a numerical method known as an ODE solver. This solution includes the control law and the dynamic system model derived from Euler–Lagrange formalism. The time complexity and accuracy are analyzed to compare the performance of the frugal simulation tool with that of a conventional simulation setup consisting of a personal computer and MATLAB^TM running the same simulation code. The analysis shows minimal deviations in the numerical solutions and reasonable time complexity. Moreover, the frugality score of this approach and the low acquisition cost of the simulation tool enable the creation of simulation laboratories at universities with limited budgets for education and research.

1. Introduction

The post-pandemic environment presents a daunting picture due to the global economic crisis and an uncertain future. Furthermore, Tilak and Kumar [1] cite global figures indicating that up to 25% of students struggle to participate in the learning process in the absence of digital tools. The digital transition faces several challenges, with technology playing a decisive role; it must be integrated as a relevant tool for developing and implementing experiments across Science, Technology, Engineering, and Mathematics (STEM) areas [2]. From an institutional perspective, it is suggested to leverage advances in e-learning and to continue to use online tools to enhance teaching and learning [3]. In engineering education, it is especially important to train students in competencies and skills for developing an agile mindset, curiosity, reflection (in/on action), innovation, creativity, and technological knowledge [4].

While core engineering courses may be taught face-to-face or online, complementary studies within a particular discipline typically require laboratory experience. In this manner, simulation-based research or education is of special interest, as evidenced by Magana and Jong [5], who highlighted (a) approaches for modeling-and-simulation-centric course design; (b) teaching practices and pedagogy for modeling and simulation implementation; and (c) evidence of learning with and about modeling and simulation practices.

The effect of simulations is greatly enhanced by using modern technologies [6]. However, simulation software is often licensed and requires periodic fees and expensive, high-performance computers. This constraint, in addition to the global economic crisis, makes developing simulations for simulation-based learning at home, or even equipping a low-budget university simulation lab, unattainable for many students and researchers. In this regard, an emerging concept, frugal innovation (FI), which emphasizes doing more with less, has gained wide acceptance among academic communities. In this sense, Bhatti et al. [7] refer to “Means and ends” to describe an innovation that can be a process as well as an outcome to achieve affordability. “To do more with less” suggests efficiency in processes and outcomes through the use of technology, resulting in deriving more from limited resources within a contextually constraining environment, thereby enhancing adaptability. “For many” describes the generation of economic and social value that achieves affordability and large scale. The result of these motivations, processes, and ends is frugal innovations that are affordable to consumers, adaptable to contextual circumstances, and accessible to vast populations. Applications of frugal engineering are reported in [8,9,10].

The problem of performing computer simulations at the lowest possible cost but with an acceptable level of quality [11] has been approached from two different technological perspectives: one related to open-source software (OSS) and the other to open-source hardware (OSH).

From the OSS perspective, Wajid et al. [12] designed a free, easily distributable, customized operating system based on Ubuntu for electrical/electronic and computer engineering, while Tapaskar et al. [13] highlight the use of OSS tools in postgraduate engineering curricula. Lotfi et al. [14] focused on promoting the use of OSS such as Python, GNU-Octave, Modelica, Java, and Gazebo in mechatronics and robotics engineering education, where a DC motor is used to show the application of OSS for analysis and model simulation. Saluja et al. [15] proposed a system to provide a new approach to learning and teaching software engineering processes for graduate or post-graduate students, and Park [16] developed an automatic GNU Octave code for educational purposes to calculate the response of a multibody closed-chain system.

From an OSH perspective, several papers have focused on replacing personal computers with single-board minicomputers. Raikar et al. [17] suggested that Raspberry Pi (RPi) can be used for practicing most laboratory courses in the computer science engineering curriculum, while Alex David et al. [18] designed a DC motor test bench online lab using RPi for possible applications in electrical engineering education. Fernández et al. [19] described the development of a remote Arduino lab to support online IoT learning experimentation environments connected to RPi, and Mbanisi et al. [20] analyzed the limitations and potential of open-source hardware such as Arduino, RPi, and BeagleBone for use in engineering education and research. Fuentes et al. [21] used RPi devices to encourage students to work autonomously for practical computer organization and a design course, and Vaca et al. [22] described the design and development of a remote laboratory based on RPi with applications in electronics and control engineering. Particular emphasis is placed on the use of simulations in robotics, where opportunities are addressed in the development and validation of open-source simulation platforms [23].

This work combines the technological perspectives of OSS and OSH to propose a low-cost scheme that is used as a computational simulation tool based on open-source hardware and software. This frugal approach employs a Raspberry Pi single-board minicomputer and GNU-Octave. The objective of this article is to analyze and compare the performance of the proposed frugal simulation scheme in relation to a conventional simulation setup consisting of a personal computer and MATLAB^TM running the same simulation code. The benchmark is a numerical simulation of trajectory tracking control in the joint space of a Selective Conformal Assembly Robot Arm (SCARA).

Related works have compared the performance of numerical simulation tools, focusing on analyzing the results of the software used, rather than the computer equipment used for the simulations. For instance, Mikac et al. [24] compared the performance of MATLAB^TM and Scilab for calculations and operations involving algebra, matrices, signals, and disk access. Idoko et al. [25] compared the computational performance of MATLAB^TM, COMSOL, and Python software for thermofluid dynamics simulation and structural analysis, while Herho et al. [26] evaluated different free and open-source software, such as Python, R, GNU Octave, and Julia, to simulate the dynamics of a double pendulum based on the equations of motion. Meanwhile, Rooney and Matthews [27] compared the performance of the Raspberry Pi 4 and Raspberry Pi Zero W development boards in executing the fast Fourier transform written in C and Rust. Furthermore, the benchmark used in this work is more comprehensive than those described in the reviewed literature. For this reason, the feasibility of the proposed scheme is demonstrated by larger scope simulations, not just from the perspective of engineering education but also considering applications for research, such as nonlinear control of robotic systems based on dynamic models.

The remainder of this paper is organized in the following manner: Section 2 describes the general features of GNU Octave and RPi; Section 3 presents the benchmark case study; Section 4 details the algorithm used for simulations; Section 5 shows the results and comparisons; Section 6 provides discussions; and finally, conclusions are given in Section 7.

2. Details of Open-Source Technology

2.1. Raspberry Pi

Raspberry Pi (RPi) is a single-board computer known as a minicomputer due to its size, which is comparable to that of a credit card, as shown in Figure 1. RPi was developed by the Raspberry Pi Foundation and first released in 2012. Subsequent versions, Raspberry Pi 2, Raspberry Pi 3, and Raspberry Pi 4, were released in 2015, 2016, and 2019, respectively. In this work, Raspberry Pi 3 B+ was used; its specifications are illustrated in

Table 1. Main specifications of Raspberry Pi 3 B+.

Attribute	Value
Processor	Broadcom BCM2837B0, Cortex-A53 64-bit SoC @ 1.4GHz
Memory	1GB LPDDR2 SDRAM
Connectivity	2.4 GHz and 5 GHz IEEE 802.11.b/g/n/ac wireless LAN, Bluetooth 4.2, BLE
	Gigabit Ethernet over USB 2.0 (maximum throughput of 300 Mbps)
	4 USB 2.0 ports
Multimedia	H.264, MPEG-4 decode (1080p30)
	H.264 encode (1080p30)
	OpenGL ES 1.1, 2.0 graphics
SD card support	Micro SD format for loading operating systems such as Raspbian and data storage

.

An RPi minicomputer requires the Raspberry Pi operating system, which is based on Debian and optimized for the Raspberry Pi hardware. This OS comes with over 35,000 packages, including GNU-Octave.

2.2. GNU-Octave

GNU-Octave is open-source and free software for numerical and scientific computing, implemented in the high-level language Octave. Octave is actively used for data analysis, image processing, computer vision, economic research, data mining, machine learning, signal processing, and many more scientific applications [28]. Octave requires minimal hardware resources, a key characteristic of this work, in which Octave 4.0.3 is used on a Raspberry Pi 3 B+, as shown in Figure 2.

Octave has a community-maintained repository of packages called Octave Packages for solving numerical computational problems. For instance, there are packages for control, communications, and instrumentation, which attempt to maintain syntax compatibility with the major functions of MATLAB^TM. However, using Octave for nonlinear control-law simulations based on the dynamic system model requires implementing algorithms for numerical approximation.

3. Benchmark Case Study

In courses on robotics, control engineering, and nonlinear systems, a common case study concerns robot manipulators. The analysis first focuses on the dynamic behavior of a robot system through mathematical modeling. These equations are then used to derive a control law for trajectory tracking. Finally, the dynamic model and controller are solved using powerful software for numerical simulation, optimization, and research.

3.1. Scara Robot Manipulator

The Selective Compliant Assembly Robot Arm (SCARA) is a rigid-link system with $n=4$ degrees of freedom (dof). According to Figure 3, each joint is represented by generalized coordinated $q_i$, $i=1,2,\dots n$. The SCARA robot is modeled by nonlinear ordinary differential equations through Euler–Lagrange formalism [29], which is expressed in matrix notation as follows:

$$\mathit{M}\left(q_i\right){\ddot{q}}_i+\mathit{C}\left(q_i,{\dot{q}}_i\right){\dot{q}}_i+\mathit{G}\left(q_i\right)={\mathit{\tau }}_{\mathit{i}},$$

(1)

$$\begin{array}{cc}\left[\begin{array}{cccc}{M}_{11}& M_{12}& M_{13}& M_{14}\\ M_{12}& M_{22}& M_{23}& M_{24}\\ M_{13}& M_{23}& M_{33}& M_{34}\\ M_{14}& M_{24}& M_{34}& M_{44}\end{array}\right]\left[\begin{array}{c}{\ddot{q}}_1\\ {\ddot{q}}_2\\ {\ddot{q}}_3\\ {\ddot{q}}_4\end{array}\right]\hfill & +\end{array}\left[\begin{array}{cccc}{C}_{11}& C_{12}& C_{13}& C_{14}\\ C_{12}& C_{22}& C_{23}& C_{24}\\ C_{13}& C_{23}& C_{33}& C_{34}\\ C_{14}& C_{24}& C_{34}& C_{44}\end{array}\right]\left[\begin{array}{c}{\dot{q}}_1\\ {\dot{q}}_2\\ {\dot{q}}_3\\ {\dot{q}}_4\end{array}\right]+\left[\begin{array}{c}0\\ 0\\ 0\\ m_{4}g\end{array}\right]=\left[\begin{array}{c}{\tau }_1\\ {\tau }_2\\ {\tau }_3\\ {\tau }_4\end{array}\right],$$

(2)

$$\begin{array}{lll}{M}_{11}\hfill & =& I_1+I_2+I_3+I_4+m_1{l{c}_1}^2+m_2{l_1}^2+m_2\left[{l{c}_2}^2+2l_{1}l{c}_{2}cos\left(q_2\right)\right]+\hfill \\ \hfill & & \left(m_3+m_4\right)\left({l_1}^2+{l_2}^2\right)+2l_1{l}_{2}cos\left(q_2\right),\hfill \\ M_{12}& =& I_2+I_3+I_4+m_2\left[{l{c}_2}^2+l_{1}l{c}_{2}cos\left(q_2\right)\right]+\left(m_3+m_4\right)\left[{l_2}^2+l_1{l}_{2}cos\left(q_2\right)\right],\\ M_{13}& =& M_{23}=M_{33}=I_3+I_4,\\ M_{14}& =& M_{24}=M_{34}=0,\\ M_{22}& =& I_2+I_3+I_4+m_2{l_{\mathrm{c}}}^2+(m_3+m_4){l_2}^2\\ M_{44}& =& m_4,\end{array}$$

$$\begin{array}{lll}{C}_{11}\hfill & =& -m_2{l}_{1}l{c}_{2}sin\left(q_2\right){\dot{q}}_2-\left(m_3+m_4\right)l_1{l}_{2}sin\left(q_2\right){\dot{q}}_2,\hfill \\ C_{12}& =& -m_2{l}_{1}l{c}_{2}sin\left(q_2\right)\left({\dot{q}}_1+{\dot{q}}_2\right)-\left(m_3+m_4\right)l_1{l}_{2}sin\left(q_2\right)\left({\dot{q}}_1+{\dot{q}}_2\right),\\ C_{21}& =& m_2{l}_{1}l{c}_{2}sin\left(q_2\right){\dot{q}}_1+\left(m_3+m_4\right)l_1{l}_{2}sin\left(q_2\right){\dot{q}}_1,\\ C_{13}& =& C_{14}=C_{22}=C_{23}=C_{24}=C_{31}=C_{32}=C_{33}=C_{34}=0,\\ C_{41}& =& C_{42}=C_{43}=C_{44}=0,\end{array}$$

where $\mathit{M}\left(q_i\right)\in {\mathbb{R}}^{n\times n}$ is the inertia matrix, $\mathit{C}\left(q_i,{\dot{q}}_i\right)\in {\mathbb{R}}^{n\times n}$ is the Coriolis and centrifugal forces matrix, $\mathit{G}\left(q_i\right)\in {\mathbb{R}}^n$ is the vector of gravitational forces, and ${\mathit{\tau }}_{\mathit{i}}\left(t\right)\in {\mathbb{R}}^n$ is the vector of input torques. $I_i$, $m_i$, $l_i$, and $l{c}_i$ are the moment of inertia, mass, final length, and the position of the mass center, for each rigid-link, respectively.

3.2. Control Law for Trajectory Tracking

Modern control theory requires a dynamical model of the system to develop a control law, and diverse control strategies, including backstepping, sliding modes, adaptive, robust, and state feedback, have been broadly applied in robotics. For trajectory tracking, a computed-torque control approach based on the Lyapunov method is implemented in this work, as in [29,30,31]. The controller is given by

$${\mathit{\tau }}_{\mathit{i}}=\mathit{M}\left(q_i\right){\ddot{q}}_d+\mathit{C}\left(q_i,{\dot{q}}_i\right){\dot{q}}_d+\mathit{G}\left(q_i\right)-k_p{\tilde{q}}_i-k_d{\dot{\tilde{q}}}_i,$$

(3)

where $k_p$ and $k_d$ are positive gains, $q_d$ is the desired trajectory, and ${\tilde{q}}_i$ is the tracking error, defined as

$${\tilde{q}}_i=q_i-q_d.$$

(4)

The desired trajectory for each joint is expressed by

$$q_d=q_{din}+{\displaystyle \frac{q_{df}-q_{din}}{2}}\left[1-cos\left({\displaystyle \frac{\pi t}{t_f}}\right)\right],$$

(5)

where $q_{din}$ and $q_{df}$ are the initial and final positions of the desired trajectory, t is the time used in the simulation step, and $t_f$ is the total simulation duration.

The control objective is to ensure that the tracking error converges to zero in a finite time. For demonstration purposes, it is necessary to perform numerical approximations using simulations, since analytical solutions are often abstract and complex mathematical expressions. For this reason, this study uses numerical simulation of SCARA robot tracking control as a benchmark.

4. Algorithm for Simulations

The closed-loop control applied in this benchmark case study, shown in Figure 4, requires feedback from the full state to form the control law (3), which also includes the dynamic model of the system expressed in matrix form. To that end, a double integral must be evaluated by implementing an algorithm to obtain a numerical solution. Moreover, the code needs to work with matrix expressions and support cyclic iterations of a system of nonlinear coupled ordinary differential equations (ODEs).

Numerical ODE Solver

A numerical solution of an ODE with initial values is achieved using a numerical method known as a solver. For instance, ode45 integrates a system of non-stiff first-order ODE based on Runge–Kutta and Dormand–Prince methods. The general syntax of the ode45 for both MATLAB^TM and GNU-Octave is given by [32]

$$[\mathrm{t},\mathrm{y}]=\mathrm{ode}45 (\mathrm{fun}, \mathrm{trange}, \mathrm{init}, \mathrm{ode}\_\mathrm{opt}),$$

where fun is a function handle that defines the first-order ODE, $y^{\prime }=f(t,y)$. trange specifies the time interval over which the ODE will be evaluated. Typically, it is a two-element vector specifying the initial and final times. If there are more than two elements, then the solution will also be evaluated at these intermediate time instances. init contains the initial value for the unknowns. The optional fourth argument ode_opt specifies non-default options to the ODE solver. ode45 returns two outputs: variable t is a column vector and contains the times where the solution was found, and the output y is a matrix in which each column refers to a different unknown of the problem and each row corresponds to a time in t.

The numerical simulation code has been divided into two files, projectileode45.m and SCARA_inicio_ode45.m, following the steps listed below. The complete code is shown in Figure 5 and Figure 6.

1.

The function handle projectileode45.m to be integrated, where the system of second-order differential equations that models the robotic system and its controller must be rewritten as a system of coupled first-order differential equations.

(a)

Define the name of the function and output/input arguments.

• The output argument will be a column vector of the derivatives.
• The input arguments will be the time t and system state x.

(b)

Establish the desired trajectory equations.

• The first and second derivatives of the desired trajectory are required.

(c)

Set parameter values.

• Parameters of the dynamical system and controller.

(d)

Build matrix M and C and vector G.

(e)

Establish the controller equation.

(f)

Solve dynamical equations for major order derivatives.

(g)

Form the vector of derivatives to be integrated.

2.

Settings of the solver and plotting results SCARA_inicio_ode45.m.

(a)

Initialize time complexity counting using tic() function.

(b)

Specify the time interval tspan=0:0.01:10.

(c)

Set initial values for each state variable.

(d)

Specify non-default options for the ODE solver,

odeset(’RelTol’,1e-4,’AbsTol’,1e-3,’NormControl’,’on’).

(e)

Build ode45 solver syntax.

(f)

Define the desired trajectory.

(g)

Plot customized figures.

(h)

Stop time complexity counting by the toc() function.

5. Results

The experimental setup of the low-cost computational tool GNU-Octave + RPi 3B+ is shown in Figure 7. Regarding trajectory tracking control, the parameters of the SCARA robot manipulator are listed in

Table 2. Parameters of the SCARA robot manipulator.

Mass	Length	Moment of Inertia
$m_1=15$ kg	$l_1=0.5$ m	$I_1=0.02087m_1$
$m_2=12$ kg	$l_2=0.4$ m	$I_2=0.08m_2$
$m_3=m_4=3$ kg	$l_{c1}=0.25$ m	$I_3=0.05m_3$
$g=9.81$${\displaystyle \frac{\mathrm{m}}{{\mathrm{s}}^2}}$	$l_{c2}=0.2$ m	$I_4=0.02m_4$

.

The gains of the controller were set as $k_p=50$ and $k_d=6$. The initial and final position for the desired trajectory, as well as initial position values for each one of the joints $q_i$, $i=1,2,3,4$, are given by

$$\begin{array}{ccc}{q}_{di{n}_i}\hfill & =& \left[-\pi \pi -{\displaystyle \frac{\pi }{2}}{\displaystyle \frac{\pi }{4}}\right]rad,\hfill \\ \\ q_{d{f}_i}\hfill & =& \left[\pi -\pi {\displaystyle \frac{\pi }{2}}-{\displaystyle \frac{\pi }{2}}\right]rad,\hfill \\ \\ q_i\left(0\right)\hfill & =& \left[-{\displaystyle \frac{\pi }{2}}{\displaystyle \frac{\pi }{4}}-{\displaystyle \frac{\pi }{5}}{\displaystyle \frac{\pi }{2}}\right]rad.\hfill \end{array}$$

All of the numerical simulations were run within a time span of $\left[0:0.01:10\right]$ seconds. Taking the benchmark for numerical simulation analysis, the performance of tracking control can be analyzed using the plot shown in Figure 8, where the dotted lines are used for the desired trajectory, the solid lines are used for trajectory tracking, and the magenta line is used for tracking error. The controller causes the robotic manipulator to follow the desired trajectory in joint space and the error tends to zero as time goes to infinity.

To compare the performance of the frugal simulation tool, the same benchmark case was simulated in MATLAB^TM and GNU-Octave running on a laptop computer with the specifications listed in

Table 3. Specifications of the laptop computer used.

Attribute	Value
Model	Acer Aspire F5-573
Processor	Intel(R) Core(TM) i5-7200U CPU @ 3.10 GHz
RAM	16.0 GB
Cache	3 MB
OS	Windows 10 Home x64
GPU	Intel HD Graphics 620

. The plots of these simulations are similar to those shown in Figure 8; for this reason, these figures are not included, although an analysis of the data from both solutions is presented in more detail below.

5.1. Time Complexity and the Standard Error of the Mean $\alpha$

Time complexity is calculated using the wall clock time elapsed between two execution points, which is obtained with the functions tic() and toc(), since it can include the time that the computer spends processing other tasks or doing nothing at all. To this end, the time complexity of the numerical simulations is computed as the average of 10 continuous executions, which is shown in

Table 4. Time complexity for each computer simulation tool.

Computer Simulation Tool	Value
MATLABTM + laptop computer	0.86 s
Octave + laptop computer	1.081 s
Octave + RPi 3B+ minicomputer	7.32 s

.

Validation of the results obtained using the proposed frugal simulation scheme GNU-Octave + RPi 3B+ was performed by verifying that the values are close to the data produced using the conventional simulation scheme used for comparison software + laptop computer.

Table 5. Standard error for results obtained from GNU-Octave + RPi 3B+ versus reference approaches.

Variable	MATLABTM + Laptop vs. GNU-Octave + RPi 3B+	GNU-Octave + Laptop vs. GNU-Octave +RPi 3B+
$q_1$	0.0014844	0.0014845
$q_2$	0.0044081	0.0044079
$q_3$	0.00067653	0.00067652
$q_4$	$2.2541\times {10}^{-9}$	$2.4897\times {10}^{-9}$
${\dot{q}}_1$	0.010358	0.010358
${\dot{q}}_2$	0.027507	0.027507
${\dot{q}}_3$	0.02343	0.02343
${\dot{q}}_4$	$2.0697\times {10}^{-8}$	$2.3447\times {10}^{-8}$

shows the results of the standard error of the mean $\alpha$ (6) calculated for each of the variables solved using the ode45 solver in the benchmark case, where the results provided by MATLAB^TM and GNU-Octave on a laptop computer are used as reference values.

$$\alpha =\sqrt{{\displaystyle \frac{{\sum }_{i=1}^n{\left(x_{i_{ref}}-x_{i_{RPi}}\right)}^2}{n\left(n-1\right)}}},$$

(6)

where $x_{ref}$ is the reference value, $x_{RPi}$ is the value given by the proposed tool GNU-Octave + RPi 3B+, and n is the total of values reached during a numerical simulation.

5.2. Frugality Score

Recently, the frugality score has been used as a parameter to measure both the consumption of computational resources and the performance of the proposed frugal innovation. Therefore, an equation is proposed to calculate a frugality score based on the equations provided by Sowiński et al. [8] and Evchenko et al. [33] that measures the frugal innovation proposal, serving as a reference for comparison with other similar proposals. This frugality score is given by

$$Fru{g}_{lc}^{hc}={\alpha }_{all}-{\displaystyle \frac{w}{1+\frac{1}{t_{lc}-t_{hc}}}},$$

(7)

where $Fru{g}_{lc}^{hc}$ is the frugality score, $lc$ denotes a parameter related to the low-cost and open-source tool GNU-Octave + RPi 3B+, and $hc$ is used to licensed software + laptop. The mean of all standard errors of the mean, shown in Table 5, is given by ${\alpha }_{all}$, which is a measure of the performance of the numerical approximation. The index w defines the weight of frugality; it can vary from 0 to 1. The values of time complexity are expressed by $t_{lc}$ and $t_{hc}$. With this definition of frugality, a score function is bounded within a fixed range $\left[-1,{\alpha }_{all}\right]$.

It is important to note the importance of varying w. If $w=0$, the frugal proposal will be weighted only by the standard errors of the mean without regard to the time complexity value. When $w=1$, the frugality score will weigh the fastest approach—that is, the smallest difference between the time complexity values.

Using data from Table 4 and Table 5, frugality lines are plotted for $w=0:0.1:1$. For this purpose, five cases have been considered.

• Case 1. The frugality score is used to compare the reference simulation tool MATLAB^TM + laptop versus the proposed simulation tool GNU-Octave + RPi 3B+, with $t_{hc}=0.86$ and $t_{lc}=7.32$, respectively.
• Case 2. The frugality score is used to compare the reference simulation tool GNU-Octave + laptop versus the proposed simulation tool GNU-Octave + RPi 3B+, with $t_{hc}=1.081$ and $t_{lc}=7.32$, respectively.
• Case 3. A hypothetical case where a supposed frugal simulation tool results in a complexity time equal to that of MATLAB^TM + laptop, $t_{hc}=t_{lc}=0.86$.
• Case 4. A hypothetical case of a frugal simulation scheme that results in a complexity time lower $t_{lc}=4$ than that of the proposed GNU-Octave + RPi 3B+ scheme $t_{lc}=7.32$.
• Case 5. The hypothetical case of a frugal simulation scheme that would take less complexity time $t_{lc}=0.8$ than the reference simulation tool MATLAB^TM + laptop $t_{hc}=0.86$.

The slopes of the frugality lines shown in Figure 9 are negative for simulation tools that have a complexity time greater than that of the conventional numerical simulation tool MATLAB^TM + laptop. The horizontal black line representing hypothetical case 3 exhibits a slope of 0, so the frugality score is related only to the standard error of the mean. In hypothetical case 4, a supposed frugal simulation scheme is analyzed that improves the results of the proposed GNU-Octave + RPi 3B+ scheme. The slope of the green line remains negative because the complexity time of this hypothetical tool is greater than the time spent by the reference scheme, but the slope of case 4 is less than the slope of the proposed simulation scheme in cases 1 and 2. Finally, the red line in case 5 shows that the slope becomes positive when the complexity time of a hypothetical simulation scheme is less than that of the reference simulation tool.

6. Discussion

Analysis of the results of the standard error of the mean shows that the error increases for velocity variables in relation to position variables. This may be caused by the solution strategy employed by the ode45 solver, which is designed to solve first-order differential equations. Therefore, the system of second-order differential equations that models the robotic system and its controller must be rewritten as a system of coupled first-order differential equations, resulting in an array with more elements. For this work, the augmented array of variables to be solved by ode45 was formed, placing the velocities in the first elements and the accelerations in the complementary elements. In this way, as mentioned in [34], when elements are repeatedly inserted or removed from the end of an array, Octave detects it as stack usage and attempts to use a smarter memory management strategy by pre-allocating the array in bigger chunks. This memory management is limited when the GNU-Octave + RPi 3B+ approach is used.

Although the complexity time of the proposed frugal simulation scheme is seven times greater than the conventional simulation scheme, the low cost is a key criterion for assessing the usefulness of the proposed simulation approach. While traditional simulation tools require a costly computer (USD 669.00), a Raspberry Pi 3B+ minicomputer is cheaper (USD 35.00). In addition, the cost of a perpetual MATLAB^TM license is USD 2250.00. Otherwise, GNU-Octave is free. The low cost of the computational tool is not the only advantage; it is also affordable for most people, as it does not require learning a new programming language. The code used is identical to that used in the licensed software widely available in the literature.

In addition, a frugality score is calculated to establish a baseline value that can be used to compare similar frugal innovations, in which a better proposal would be one that minimizes time complexity and retains the accuracy derived from the mean standard error.

7. Conclusions

In this study, a frugal simulation tool based on low-cost, open-source technology was compared with other relevant technologies, with the results validating its use in educational or research applications involving the nonlinear control of robotic systems. Furthermore, performance analysis of the simulations indicated minimal differences between the simulation approaches. This demonstrates the frugality of the proposed approach, in which technology is used to get more out of less in a contextually restrictive environment in order to achieve flexibility. Thus, the proposed simulation tool has a social impact because it can be implemented in universities with a limited budget and, individually, each student or researcher can build their own simulation lab at home for online education, complementary studies, or research.

This study is limited by the technical specifications of the computer equipment used. The Raspberry Pi minicomputer, like other development boards, is continually evolving; increased hardware capabilities will enable improved performance, reducing computation time for hardware-in-the-loop applications. Therefore, efforts will continue to design low-cost laboratory equipment for trajectory tracking of a SCARA robot prototype by implementing a nonlinear control law that executes on a Raspberry Pi minicomputer. In addition, an internet-connected graphical user interface (GUI) is expected to be designed for a real-time remote control application.