Many control problems in robotics and mechatronics reduce to controlling the translational motion of masses along (approximately) straight lines: a robot’s linear slide, a gantry axis, or a linear motor moving a payload. In this lesson we restrict attention to single-axis translational motion under a set of standard assumptions that lead to linear time-invariant models.

Let \( y(t) \) denote a displacement coordinate along a fixed axis, and let \( F(t) \) denote an external force applied by an actuator (e.g., a voice-coil motor). For each rigid body of mass \( m \) we impose Newton’s second law:

\[ \sum F(t) = m\,\ddot{y}(t). \]

Under the modeling assumptions below, the resulting equations of motion are linear with constant coefficients, i.e., LTI:

\[ a_n \frac{\mathrm{d}^n y(t)}{\mathrm{d}t^n} + a_{n-1} \frac{\mathrm{d}^{n-1} y(t)}{\mathrm{d}t^{n-1}} + \cdots + a_1 \dot{y}(t) + a_0 y(t) = b_m \frac{\mathrm{d}^m u(t)}{\mathrm{d}t^m} + \cdots + b_0 u(t), \]

where \( u(t) \) is a chosen input (often \( u(t) = F(t) \)) and the coefficients \( a_k, b_k \) are constants determined by physical parameters and geometry.

We will repeatedly use the following linearization assumptions:

• Small displacements so that springs obey Hooke’s law and geometry is approximately linear.
• Velocities in a range where viscous damping dominates and can be modeled as proportional to velocity.
• Rigid bodies with lumped masses and negligible flexibility of links (flexibility appears only in springs).
• Parameter constancy (mass, stiffness, damping do not explicitly depend on time).

The modeling workflow can be summarized as:

flowchart TD
  A["Physical system description (masses, springs, dampers, constraints)"] --> B["Choose coordinates y(t)"]
  B --> C["Draw free-body diagrams"]
  C --> D["Apply Newton's law: sum F = m * y_ddot"]
  D --> E["Substitute element laws (spring, damper, etc.)"]
  E --> F["Collect terms into LTI ODE"]
  F --> G["(Optional) Move to Laplace domain"]
        

Mechanical translational systems are built from a small set of idealized elements: masses, springs, and dampers. We adopt a one-dimensional axis with a chosen positive direction, and define displacements with respect to an inertial reference.

2.1 Mass (Inertial Element)

A rigid body of mass \( m \) moving with displacement \( y(t) \) along our axis obeys:

\[ F_m(t) = m\,\ddot{y}(t), \]

where \( F_m(t) \) is the net force acting on the mass along the axis. This is the inertial force required to produce the acceleration.

2.2 Linear Spring

For an ideal linear spring with stiffness \( k \), attached between two points with displacements \( y_1(t) \) and \( y_2(t) \), we define the extension:

\[ \Delta(t) = y_1(t) - y_2(t). \]

The spring force acting on the point at \( y_1(t) \) in the positive direction is:

\[ F_k(t) = -k\,\Delta(t) = -k\left(y_1(t) - y_2(t)\right). \]

The negative sign enforces that the spring resists extension or compression: if \( y_1(t) > y_2(t) \), then \( \Delta(t) > 0 \) and the force on the first point is negative (pulling it back).

2.3 Viscous Damper

An ideal viscous damper with coefficient \( b \) between points with displacements \( y_1(t) \), \( y_2(t) \), and velocities \( \dot{y}_1(t) \), \( \dot{y}_2(t) \) obeys:

\[ F_b(t) = -b \left(\dot{y}_1(t) - \dot{y}_2(t)\right). \]

Again the force opposes relative motion: if point 1 moves faster than point 2 in the positive direction, the damper exerts a negative force on point 1.

2.4 Linear vs Nonlinear Effects

In reality, springs may stiffen or soften with deflection, and friction often contains dry (Coulomb) components. A typical Coulomb friction model at a contact is:

\[ F_{\text{Coulomb}}(t) = F_c \,\operatorname{sgn}\!\big(\dot{y}(t)\big), \]

which is nonlinear and discontinuous. In many control designs for small-velocity operation, one replaces this with a viscous approximation \( F(t) \approx b_{\text{eq}} \dot{y}(t) \), yielding an LTI model that captures small-signal behavior.

Consider the canonical single-degree-of-freedom translational system: a mass \( m \) attached to a fixed wall by a spring of stiffness \( k \) and a viscous damper with coefficient \( b \), driven by an external force \( F(t) \).

3.1 Free-Body Diagram and Newton’s Law

Let \( y(t) \) be the displacement of the mass from its equilibrium position, with positive direction to the right. The forces acting on the mass are:

• Inertial force: \( m\,\ddot{y}(t) \) (implicit in Newton’s law).
• Spring force: \( -k\,y(t) \) (assuming the wall is fixed at \( y=0 \)).
• Damper force: \( -b\,\dot{y}(t) \).
• External input force: \( F(t) \) (e.g., actuator force).

Applying Newton’s law along the axis:

\[ \sum F(t) = m\,\ddot{y}(t) \quad \Rightarrow \quad F(t) - b\,\dot{y}(t) - k\,y(t) = m\,\ddot{y}(t). \]

Rearranging:

\[ m\,\ddot{y}(t) + b\,\dot{y}(t) + k\,y(t) = F(t). \]

This is a second-order linear ODE with constant coefficients. For zero input \( F(t) \equiv 0 \), the homogeneous equation is:

\[ m\,\ddot{y}(t) + b\,\dot{y}(t) + k\,y(t) = 0. \]

3.2 Characteristic Equation (Preview)

Seeking exponential solutions \( y(t) = \mathrm{e}^{\lambda t} \) for the homogeneous equation leads to the characteristic polynomial:

\[ m\lambda^2 + b\lambda + k = 0. \]

The roots \( \lambda_1, \lambda_2 \) determine the natural modes of the system. Later chapters (on time response and stability) will interpret these roots in terms of damping ratio and natural frequency; here we emphasize the modeling step that produces the polynomial.

Many robotic and mechatronic systems involve several masses coupled by springs and dampers. A simple example is two carriages on a linear guide coupled by a spring and damper, with one carriage actuated.

4.1 Two-Mass Example

Consider two masses \( m_1, m_2 \) with displacements \( y_1(t), y_2(t) \). Mass \( m_1 \) is attached to a fixed wall by a spring \( k_1 \) and a damper \( b_1 \). Between the masses there is a spring \( k_2 \) and damper \( b_2 \). An external force \( F(t) \) acts on \( m_1 \).

Force balance on each mass gives:

\[ \begin{aligned} m_1 \ddot{y}_1(t) &= F(t) - b_1 \dot{y}_1(t) - k_1 y_1(t) - b_2\left(\dot{y}_1(t) - \dot{y}_2(t)\right) - k_2\left(y_1(t) - y_2(t)\right), \\ m_2 \ddot{y}_2(t) &= - b_2\left(\dot{y}_2(t) - \dot{y}_1(t)\right) - k_2\left(y_2(t) - y_1(t)\right). \end{aligned} \]

4.2 Matrix Form

Let \( \mathbf{y}(t) = \begin{bmatrix} y_1(t) \\ y_2(t) \end{bmatrix} \) and \( \mathbf{f}(t) = \begin{bmatrix} F(t) \\ 0 \end{bmatrix} \). We can write:

\[ \mathbf{M}\,\ddot{\mathbf{y}}(t) + \mathbf{B}\,\dot{\mathbf{y}}(t) + \mathbf{K}\,\mathbf{y}(t) = \mathbf{f}(t), \]

with

\[ \mathbf{M} = \begin{bmatrix} m_1 & 0 \\ 0 & m_2 \end{bmatrix},\quad \mathbf{B} = \begin{bmatrix} b_1 + b_2 & -b_2 \\ -b_2 & b_2 \end{bmatrix},\quad \mathbf{K} = \begin{bmatrix} k_1 + k_2 & -k_2 \\ -k_2 & k_2 \end{bmatrix}. \]

This form generalizes to \( n \)-mass systems, giving the standard \( \mathbf{M}\ddot{\mathbf{y}} + \mathbf{B}\dot{\mathbf{y}} + \mathbf{K}\mathbf{y} = \mathbf{f} \) structure widely used in robotics and vibration theory.

flowchart TD
  W["Wall"] --- S1["Spring k1"] --- B1["Damper b1"] --- M1["Mass m1"]
  M1 --- S2["Spring k2"] --- B2["Damper b2"] --- M2["Mass m2"]
  M1 --> F["Applied force F(t)"]
  W:::fixed
  classDef fixed fill:#f0f0f0,stroke:#000,stroke-width:1px;
        

Complex mechanical networks are often reduced to simpler equivalents. For LTI modeling, we frequently replace groups of springs or dampers with an equivalent element so that we can write compact equations.

5.1 Springs in Parallel

Two springs with stiffnesses \( k_1 \), \( k_2 \) in parallel between the same nodes experience the same displacement \( \Delta(t) \) but carry forces \( F_1(t) \), \( F_2(t) \). Total force:

\[ F_{\text{tot}}(t) = F_1(t) + F_2(t) = k_1\Delta(t) + k_2\Delta(t) = (k_1 + k_2)\Delta(t). \]

Hence the equivalent stiffness is:

\[ k_{\text{eq}} = k_1 + k_2. \]

5.2 Springs in Series

For springs in series, the same force \( F(t) \) passes through both springs, but the total displacement is the sum of individual displacements. With stiffnesses \( k_1 \), \( k_2 \) and displacements \( \Delta_1(t) \), \( \Delta_2(t) \),

\[ F(t) = k_1\Delta_1(t) = k_2\Delta_2(t),\quad \Delta_{\text{tot}}(t) = \Delta_1(t) + \Delta_2(t). \]

We want \( F(t) = k_{\text{eq}}\Delta_{\text{tot}}(t) \). Using \( \Delta_1(t) = F(t)/k_1 \), \( \Delta_2(t) = F(t)/k_2 \), we obtain:

\[ \Delta_{\text{tot}}(t) = \frac{F(t)}{k_1} + \frac{F(t)}{k_2} = F(t)\left(\frac{1}{k_1} + \frac{1}{k_2}\right) = \frac{F(t)}{k_{\text{eq}}}. \]

Therefore:

\[ \frac{1}{k_{\text{eq}}} = \frac{1}{k_1} + \frac{1}{k_2}. \]

The same reasoning applies to viscous dampers (replace \( k_i \) with \( b_i \)) because damper forces are proportional to relative velocities and the superposition principles are identical.

You have already studied the Laplace transform in Chapter 2. We now apply it to the single-DOF mass–spring–damper model, assuming zero initial conditions for simplicity.

Starting from \( m\,\ddot{y}(t) + b\,\dot{y}(t) + k\,y(t) = F(t) \), take the Laplace transform of both sides under zero initial conditions:

\[ m s^2 Y(s) + b s Y(s) + k Y(s) = F(s). \]

Factorizing:

\[ \left(m s^2 + b s + k\right)Y(s) = F(s). \]

For nonzero initial conditions you would obtain additional terms in \( Y(s) \) involving initial displacement and velocity; for now we focus on the zero-initial-condition mapping from input force to displacement:

\[ \frac{Y(s)}{F(s)} = \frac{1}{m s^2 + b s + k}. \]

In Chapter 4 this ratio will be formally named the transfer function from input force to output displacement, and its poles will be related to the characteristic roots \( \lambda_1, \lambda_2 \) discussed earlier.

Python is widely used in robotics for rapid prototyping. Libraries such as numpy and scipy handle numerical integration, while the python-control package (often used in robotics research) provides higher-level tools for LTI systems.

7.1 Time-Domain Simulation via scipy.integrate

We simulate the mass–spring–damper system with a unit step force \( F(t) = 1 \) for \( t \ge 0 \). We convert the second-order ODE to a first-order system by defining the state vector \( z(t) = \begin{bmatrix} y(t) \\ \dot{y}(t) \end{bmatrix} \).

import numpy as np
from scipy.integrate import solve_ivp
import matplotlib.pyplot as plt

# Physical parameters
m = 1.0   # mass [kg]
b = 0.4   # damping [N s/m]
k = 4.0   # stiffness [N/m]

def msd_ode(t, z):
    """
    z[0] = y (displacement)
    z[1] = v = dy/dt (velocity)
    """
    y, v = z
    F = 1.0  # unit step force for all t >= 0
    a = (F - b * v - k * y) / m
    return [v, a]

# Initial conditions: y(0) = 0, dy/dt(0) = 0
z0 = [0.0, 0.0]

t_span = (0.0, 10.0)
t_eval = np.linspace(t_span[0], t_span[1], 1000)

sol = solve_ivp(msd_ode, t_span, z0, t_eval=t_eval)

t = sol.t
y = sol.y[0, :]

plt.figure()
plt.plot(t, y)
plt.xlabel("t [s]")
plt.ylabel("y(t) [m]")
plt.title("Mass-spring-damper response to unit step force")
plt.grid(True)
plt.show()
      

7.2 Laplace-Domain Model via python-control

The python-control library allows direct manipulation of LTI models. For our single-DOF system, the Laplace-domain model (previewing the transfer function) is represented as:

import control as ct

m = 1.0
b = 0.4
k = 4.0

# Numerator and denominator of Y(s)/F(s)
num = [1.0]            # 1 in the numerator
den = [m, b, k]        # m s^2 + b s + k

G = ct.TransferFunction(num, den)

# Compute and plot the step response (force step -> displacement)
t, y = ct.step_response(G)

import matplotlib.pyplot as plt
plt.figure()
plt.plot(t, y)
plt.xlabel("t [s]")
plt.ylabel("y(t) [m]")
plt.title("Step response via python-control")
plt.grid(True)
plt.show()
      

In later chapters, tools like python-control will be used to connect these plant models to controllers designed using classical control techniques.

C++ remains the dominant language in real-time robotics (for example, in ROS controllers). Linear mechanical models are often implemented using the Eigen library for matrices and vectors.

Below, we simulate a two-mass system in Section 4 using a simple explicit Euler method. This illustrative code could be integrated into a ROS node that runs at a fixed control period.

#include <iostream>
#include <Eigen/Dense>

int main() {
    // Physical parameters
    double m1 = 1.0;
    double m2 = 0.5;
    double b1 = 0.4;
    double b2 = 0.2;
    double k1 = 4.0;
    double k2 = 2.0;

    // Mass, damping, stiffness matrices (2x2)
    Eigen::Matrix2d M;
    Eigen::Matrix2d B;
    Eigen::Matrix2d K;

    M << m1, 0.0,
          0.0, m2;

    B << b1 + b2, -b2,
          -b2,      b2;

    K << k1 + k2, -k2,
          -k2,      k2;

    // State: y = [y1, y2], v = [v1, v2]
    Eigen::Vector2d y;
    Eigen::Vector2d v;

    y << 0.0, 0.0;  // initial displacements
    v << 0.0, 0.0;  // initial velocities

    double dt = 0.001;        // integration step [s]
    double t_final = 5.0;
    int steps = static_cast<int>(t_final / dt);

    for (int k = 0; k < steps; ++k) {
        double t = k * dt;

        // External force applied to mass 1 (unit step)
        Eigen::Vector2d f;
        f << 1.0, 0.0;

        // Acceleration: M * a = f - B * v - K * y
        Eigen::Vector2d a = M.ldlt().solve(f - B * v - K * y);

        // Explicit Euler integration
        v = v + dt * a;
        y = y + dt * v;

        // Print a few samples
        if (k % 1000 == 0) {
            std::cout << "t = " << t
                      << "  y1 = " << y(0)
                      << "  y2 = " << y(1) << std::endl;
        }
    }

    return 0;
}
      

In a robotic joint controller, such a model can be used for simulation, feedforward compensation, or model-based disturbance rejection, with Eigen handling the matrix operations efficiently.

Java is commonly used in some robotics ecosystems (e.g., educational robots and industrial HMIs). Libraries such as WPILib (in competitive robotics) provide high-level control abstractions, but the underlying dynamics often correspond to simple translational models.

The following Java example integrates the single-DOF mass–spring–damper with Euler’s method. It can be embedded into a periodic control loop on a real robot.

public class MassSpringDamperSim {
    public static void main(String[] args) {
        double m = 1.0;
        double b = 0.4;
        double k = 4.0;

        double y = 0.0;  // displacement
        double v = 0.0;  // velocity

        double dt = 0.001;
        double tFinal = 10.0;
        int steps = (int) (tFinal / dt);

        for (int i = 0; i < steps; i++) {
            double t = i * dt;

            // Unit step force
            double F = 1.0;

            // Acceleration from m * y_ddot + b * y_dot + k * y = F
            double a = (F - b * v - k * y) / m;

            // Euler integration
            v = v + dt * a;
            y = y + dt * v;

            if (i % 1000 == 0) {
                System.out.printf("t = %.3f, y = %.5f%n", t, y);
            }
        }
    }
}
      

In Java-based robotics frameworks, you would typically wrap such dynamics into a class that also exposes methods for applying different input forces and reading the resulting position and velocity, mirroring real actuators and encoders.

MATLAB and Simulink are standard tools in control engineering and robotics. The Robotics System Toolbox and standard Simulink libraries allow graphical modeling of mass–spring–damper systems, which can be combined with controllers and sensor models.

10.1 MATLAB Script Using ode45

% Parameters
m = 1.0;
b = 0.4;
k = 4.0;

% ODE: m*ydd + b*yd + k*y = F(t), with F(t) = 1
msd = @(t, z) [ ...
    z(2);                           % z(1) = y, z(2) = dy/dt
    (1.0 - b * z(2) - k * z(1)) / m % acceleration
];

tspan = [0 10];
z0 = [0; 0];  % initial displacement and velocity

[t, z] = ode45(msd, tspan, z0);

y = z(:, 1);

figure;
plot(t, y, 'LineWidth', 1.5);
xlabel('t [s]');
ylabel('y(t) [m]');
title('Mass-spring-damper response (MATLAB)');
grid on;
      

10.2 Simulink Block Diagram (Conceptual)

In Simulink, one typically implements the same model using:

• Two integrator blocks in series (for velocity and position).
• Gain blocks for stiffness \( k \) and damping \( b \).
• Summing junctions implementing \( F(t) - b\,\dot{y}(t) - k\,y(t) \).

This graphical form mirrors the ODE and is easily extended to multi-DOF systems using matrix gain blocks and vector signals.

Wolfram Mathematica provides symbolic and numeric tools to work with mechanical models. It can derive analytical solutions when possible and otherwise solve numerically.

(* Parameters *)
m = 1.0;
b = 0.4;
k = 4.0;

(* ODE: m y''[t] + b y'[t] + k y[t] == 1 for t >= 0, with zero ICs *)
ode = m*y''[t] + b*y'[t] + k*y[t] == 1;

ics = {y[0] == 0, y'[0] == 0};

sol = NDSolve[{ode, ics}, y, {t, 0, 10}];

Plot[Evaluate[y[t] /. sol], {t, 0, 10},
     AxesLabel -> {"t", "y(t)"},
     PlotLabel -> "Mass-spring-damper response in Mathematica"]
      

Mathematica can also manipulate the Laplace-domain representation symbolically and derive expressions for the impulse or step response, providing useful cross-checks for numerical simulations.

In this lesson we developed LTI models for mechanical translational systems using Newton’s law and idealized element relations for masses, springs, and dampers. We derived single- and multi-DOF equations of motion, expressed them in compact matrix form \( \mathbf{M}\ddot{\mathbf{y}} + \mathbf{B}\dot{\mathbf{y}} + \mathbf{K}\mathbf{y} = \mathbf{f} \), and constructed equivalent stiffness and damping for series and parallel combinations. By applying the Laplace transform, we obtained algebraic input–output relations that preview the notion of transfer functions. Finally, we implemented these models in Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica, connecting mechanical modeling with the computational tools used in modern robotics and control.