Translational mechanical systems in control engineering include vehicle bodies on suspensions, linear actuators driving loads, and moving machine elements on guides. The common modeling starting point is Newton’s second law, which relates the net external force on a body to its acceleration. In vector form, for a body of constant mass \( m \),

\[ \sum \mathbf{F}(t) = m\,\mathbf{a}(t). \]

In this chapter we restrict attention to translational motion along a line, so the vector equation reduces to a scalar equation along a chosen coordinate axis, for example,

\[ \sum F_x(t) = m\,\ddot{x}(t), \]

where \( x(t) \) is the displacement coordinate, \( \dot{x}(t) \) the velocity, and \( \ddot{x}(t) \) the acceleration along the chosen axis. The right-hand side defines the inertial force associated with translational acceleration.

We recall and specialize Newton’s three laws of motion for translational dynamics of a rigid body modeled as a point mass:

• First Law (Law of Inertia). A body remains at rest or in uniform straight-line motion if the net external force on it is zero:

  \[ \sum F = 0 \quad \Rightarrow \quad \ddot{x}(t) = 0. \]

• Second Law. The acceleration of a body is proportional to the net external force and inversely proportional to its mass:

  \[ \sum F(t) = m\,\ddot{x}(t), \quad m > 0. \]

• Third Law. For every action force there is an equal and opposite reaction force. If body A exerts a force \( F_{A\to B} \) on body B, then body B exerts \( F_{B\to A} = -F_{A\to B} \) on body A.

In modeling, the third law implies that internal forces between parts of the chosen system cancel pairwise when we consider the system as a whole. Therefore, only external forces appear in the free-body diagram and in the resulting equations of motion.

We also adopt the following modeling assumptions for this lesson:

• The mass \( m \) is constant in time.
• Motion is described relative to an inertial reference frame (no large accelerations of the frame itself).
• Deformations of the body are neglected; it is treated as a point mass for translational motion.

Let \( x(t) \) denote the translational coordinate along a chosen axis. The velocity and acceleration are defined as time derivatives:

\[ v(t) = \dot{x}(t) = \frac{d x(t)}{d t}, \qquad a(t) = \ddot{x}(t) = \frac{d^2 x(t)}{d t^2}. \]

In initial value problems (IVPs), we specify initial conditions at some reference time, typically \( t = 0 \):

\[ x(0) = x_0, \qquad \dot{x}(0) = v_0. \]

Combining these kinematic relations with Newton’s second law yields a second-order ODE of the form

\[ m\,\ddot{x}(t) = \sum_{i} F_i\bigl(x(t), \dot{x}(t), t\bigr), \]

where the forces \( F_i \) may depend on position, velocity, and time. In subsequent lessons we will introduce specific force models (springs, dampers, friction), but in this lesson we emphasize the structural procedure that leads from physical description to ODE.

A crucial modeling decision is the choice of system boundary. Once the system is chosen (for example, a cart and its payload), all interactions across this boundary appear as external forces. Typical forces in translational mechanical systems include:

• Body forces: forces that act throughout the volume of the body, such as gravity, often modeled as \( W = m g \) acting at the center of mass.
• Contact forces: forces exerted at points or surfaces of contact, such as:
  • normal or reaction forces from guides and supports,
  • actuator forces (e.g., from hydraulic or electric actuators),
  • friction forces (to be treated more systematically in a later lesson).

When constructing a free-body diagram:

• Include only external forces crossing the system boundary.
• Do not include internal forces between parts of the system; they cancel by Newton’s third law.
• Resolve forces into components along the chosen coordinate axis before applying Newton’s second law.

flowchart LR
  F["All forces on system"] --> FB["Body forces (e.g. gravity)"]
  F --> FC["Contact forces"]
  FC --> FN["Normal / reaction"]
  FC --> FA["Actuation (e.g. motor, cylinder)"]
  FC --> FF["Resistive (e.g. friction)"]
        

Free-body diagrams provide a graphical representation that bridges physical description and mathematics. A disciplined procedure avoids missing forces or sign errors. The following workflow is useful for translational systems modeled as point masses:

flowchart TD
  A["Define system boundary (choose body)"] --> B["Choose coordinate axis and positive direction"]
  B --> C["Isolate body and remove surroundings"]
  C --> D["Draw all external forces (body and contact) as arrows"]
  D --> E["Resolve forces along coordinate axis"]
  E --> F["Apply sum F = m a along axis"]
  F --> G["Obtain ODE with initial conditions"]
        

Once the free-body diagram is complete, the algebraic step \( \sum F = m a \) along the chosen axis is often straightforward. The primary modeling effort lies in choosing the system, identifying external forces, and organizing them correctly in the FBD.

Consider a cart of mass \( m \) moving horizontally on a frictionless track. An actuator applies a horizontal force \( u(t) \) to the right. Let \( x(t) \) denote the horizontal displacement of the cart, with the positive direction to the right. The modeling steps are:

1. System boundary: the cart plus payload (modeled as a single lumped mass \( m \)).
2. Coordinate and sign convention: horizontal axis to the right is positive; \( x(t) \) measures position along the track.
3. Free-body diagram: in the vertical direction, weight \( W = m g \) is balanced by the normal reaction from the track; there is no vertical acceleration. In the horizontal direction, the only external force is the actuator force \( u(t) \).
4. Apply Newton’s second law along the horizontal axis:

   \[ \sum F_x(t) = u(t) = m\,\ddot{x}(t). \]

The governing ODE for the cart is therefore

\[ m\,\ddot{x}(t) = u(t). \]

For a constant input \( u(t) = F_0 \) and initial conditions \( x(0) = x_0 \), \( \dot{x}(0) = v_0 \), the ODE becomes \( \ddot{x}(t) = \frac{F_0}{m} \), whose solution is obtained by two integrations:

\[ \dot{x}(t) = v_0 + \frac{F_0}{m} t, \]

\[ x(t) = x_0 + v_0 t + \frac{1}{2}\frac{F_0}{m} t^2. \]

This quadratic time dependence is characteristic of constant acceleration motion. Later chapters will interpret such ODEs in terms of system order and response characteristics.

Next, consider a mass \( m \) constrained to move vertically along a guide. Let \( y(t) \) denote the vertical displacement measured upward from a reference level. The body is subject to:

• its weight \( W = m g \) acting downward,
• an actuator force \( u(t) \) acting upward (e.g., a hoist or linear motor).

Choosing upward as the positive direction, the free-body diagram includes:

• a downward arrow \( m g \),
• an upward arrow \( u(t) \).

Applying Newton’s second law along the vertical axis (positive upward) gives

\[ \sum F_y(t) = u(t) - m g = m\,\ddot{y}(t). \]

Hence the governing ODE is

\[ m\,\ddot{y}(t) = u(t) - m g. \]

For a constant control force \( u(t) = U_0 \), the acceleration is \( \ddot{y}(t) = \frac{U_0}{m} - g \). In particular:

• If \( U_0 = m g \), then \( \ddot{y}(t) = 0 \) and the mass moves with constant velocity (including the case of rest).
• If \( U_0 > m g \), the mass accelerates upward.
• If \( U_0 < m g \), the mass accelerates downward.

This example illustrates how external forces that oppose gravity can be interpreted as control inputs that regulate translational motion, a recurring theme in control engineering.

We now simulate the horizontal cart of Section 6 under a constant force input using a simple explicit Euler integration scheme. The governing ODE is

\[ m\,\ddot{x}(t) = F_0, \quad x(0) = 0, \quad \dot{x}(0) = 0. \]

Introducing velocity \( v(t) = \dot{x}(t) \), we obtain the first-order system

\[ \dot{x}(t) = v(t), \qquad \dot{v}(t) = \frac{F_0}{m}. \]

A basic Python implementation using NumPy is shown below. For more advanced applications, the scipy.integrate module (e.g., solve_ivp) is widely used for system dynamics simulations.

import numpy as np

# Parameters
m = 2.0          # mass [kg]
F0 = 10.0        # constant force [N]
t_final = 2.0    # final time [s]
dt = 0.001       # time step [s]

# Time grid
t = np.arange(0.0, t_final + dt, dt)

# State variables: position x, velocity v
x = np.zeros_like(t)
v = np.zeros_like(t)

# Initial conditions
x[0] = 0.0
v[0] = 0.0

# Explicit Euler integration
for k in range(len(t) - 1):
    a = F0 / m          # acceleration
    v[k + 1] = v[k] + a * dt
    x[k + 1] = x[k] + v[k] * dt

# Analytical solution for comparison
x_exact = 0.5 * (F0 / m) * t**2

# Simple check at final time
print("Numerical x(T) =", x[-1])
print("Analytical x(T) =", x_exact[-1])
      

Decreasing the time step \( \Delta t \) improves the agreement between the numerical and analytical solutions, consistent with the numerical concepts introduced in Chapter 2.

The same simple explicit Euler scheme can be implemented in C++. Advanced system dynamics simulations in C++ often rely on libraries such as Boost.Odeint, which provides high-order ODE solvers. Here we implement the integrator directly for transparency.

#include <iostream>
#include <cmath>

int main() {
    // Parameters
    const double m = 2.0;      // mass [kg]
    const double F0 = 10.0;    // constant force [N]
    const double t_final = 2.0;
    const double dt = 0.001;

    // Number of steps
    int n_steps = (int)(t_final / dt);

    // State variables
    double x = 0.0;  // position
    double v = 0.0;  // velocity

    double t = 0.0;
    for (int k = 0; k < n_steps; ++k) {
        double a = F0 / m;
        v = v + a * dt;
        x = x + v * dt;
        t = t + dt;
    }

    // Analytical solution at t_final
    double x_exact = 0.5 * (F0 / m) * t_final * t_final;

    std::cout << "Numerical x(T) = " << x << std::endl;
    std::cout << "Analytical x(T) = " << x_exact << std::endl;

    return 0;
}
      

For more complex systems (e.g., coupled masses, nonlinear forces), one would typically encapsulate the ODE right-hand side in a callable object and pass it to a library such as Boost.Odeint for robust time integration.

In Java, we can implement the same dynamics using arrays and a loop. For industrial-strength simulations, libraries such as Apache Commons Math provide ODE solvers, but here we show the core logic explicitly.

public class TranslationalMassSimulation {
    public static void main(String[] args) {
        double m = 2.0;        // mass [kg]
        double F0 = 10.0;      // constant force [N]
        double tFinal = 2.0;   // final time [s]
        double dt = 0.001;     // time step [s]

        int nSteps = (int)(tFinal / dt) + 1;

        double[] t = new double[nSteps];
        double[] x = new double[nSteps];
        double[] v = new double[nSteps];

        // Initial conditions
        t[0] = 0.0;
        x[0] = 0.0;
        v[0] = 0.0;

        for (int k = 0; k < nSteps - 1; k++) {
            double a = F0 / m;
            v[k + 1] = v[k] + a * dt;
            x[k + 1] = x[k] + v[k] * dt;
            t[k + 1] = t[k] + dt;
        }

        double xExact = 0.5 * (F0 / m) * tFinal * tFinal;
        System.out.println("Numerical x(T) = " + x[nSteps - 1]);
        System.out.println("Analytical x(T) = " + xExact);
    }
}
      

This Java code mirrors the Python and C++ implementations. For later lessons, the same structure can be extended to handle more complex ODEs representing multi-degree-of-freedom translational systems.

11.1 MATLAB Script with ode45

MATLAB offers high-level ODE solvers (e.g., ode45) and tight integration with Simulink. The following script simulates the constant-force mass system:

% Parameters
m = 2.0;        % mass [kg]
F0 = 10.0;      % constant force [N]

% ODE: x1 = x, x2 = v
% x1' = x2
% x2' = F0 / m
odefun = @(t, x)[x(2); F0 / m];

tspan = [0 2];          % time interval
x0 = [0; 0];            % initial conditions [x(0); v(0)]

[t, x] = ode45(odefun, tspan, x0);

% Analytical solution for comparison
x_exact = 0.5 * (F0 / m) * t.^2;

plot(t, x(:, 1), 'LineWidth', 1.5);
hold on;
plot(t, x_exact, '--', 'LineWidth', 1.5);
xlabel('t [s]');
ylabel('x(t) [m]');
legend('ode45', 'analytical');
grid on;
      

In Simulink, the same system can be represented by cascading two integrator blocks: the first integrates acceleration to velocity, the second integrates velocity to position. A constant block provides \( F_0 / m \) to the acceleration input.

11.2 Wolfram Mathematica with NDSolve

Wolfram Mathematica provides symbolic and numerical solvers via NDSolve. The following code simulates the same ODE:

m = 2.0;
F0 = 10.0;

(* Define ODE and initial conditions *)
sol = NDSolve[
  {
    m x''[t] == F0,
    x[0] == 0,
    x'[0] == 0
  },
  x,
  {t, 0, 2}
];

(* Evaluate numerical and analytical solutions at t = 2 *)
xNum = x[2] /. sol[[1]];
xExact = 0.5 * (F0 / m) * 2^2;

Print["Numerical x(2) = ", xNum];
Print["Analytical x(2) = ", xExact];
      

Mathematica is especially useful later when deriving analytical solutions for more involved force laws (e.g., piecewise or nonlinear), complementing the numerical approaches discussed here.

The following problems reinforce the concepts of Newton’s laws, free-body diagrams, and the derivation of translational equations of motion.

Problem 1 (Horizontal Mass with Constant Force).
A mass \( m \) moves on a frictionless horizontal track. A constant horizontal force \( F_0 \) is applied to the right. At \( t = 0 \) the mass is at rest at \( x(0) = 0 \). Derive the equation of motion and find \( x(t) \).

Solution.
Choose the mass as the system and the horizontal axis to the right as positive. The only horizontal external force is \( F_0 \) to the right, so Newton’s second law gives

\[ \sum F_x(t) = F_0 = m\,\ddot{x}(t). \]

Thus

\[ \ddot{x}(t) = \frac{F_0}{m}. \]

Integrating once:

\[ \dot{x}(t) = \frac{F_0}{m} t + C_1. \]

The initial condition \( \dot{x}(0) = 0 \) implies \( C_1 = 0 \). Integrating again:

\[ x(t) = \frac{1}{2}\frac{F_0}{m} t^2 + C_2. \]

With \( x(0) = 0 \), we obtain \( C_2 = 0 \), so

\[ x(t) = \frac{1}{2}\frac{F_0}{m} t^2. \]

Problem 2 (Sinusoidal Forcing of a Translational Mass).
For the same horizontal mass system, the applied force is now time-varying: \( u(t) = F_0 \sin(\omega t) \). The mass is initially at rest at the origin: \( x(0) = 0 \), \( \dot{x}(0) = 0 \). Derive \( x(t) \).

Solution.
Newton’s second law gives

\[ m\,\ddot{x}(t) = F_0 \sin(\omega t), \quad \text{so} \quad \ddot{x}(t) = \frac{F_0}{m}\sin(\omega t). \]

Integrate once to obtain the velocity:

\[ \dot{x}(t) = \int \frac{F_0}{m} \sin(\omega t)\,dt = -\frac{F_0}{m\omega} \cos(\omega t) + C_1. \]

Using \( \dot{x}(0) = 0 \):

\[ 0 = -\frac{F_0}{m\omega} \cos(0) + C_1 \quad \Rightarrow \quad C_1 = \frac{F_0}{m\omega}. \]

Hence

\[ \dot{x}(t) = \frac{F_0}{m\omega}\bigl(1 - \cos(\omega t)\bigr). \]

Integrating again:

\[ x(t) = \int \dot{x}(t)\,dt = \frac{F_0}{m\omega}\left( t - \frac{1}{\omega}\sin(\omega t) \right) + C_2. \]

Using \( x(0) = 0 \) gives \( C_2 = 0 \), so

\[ x(t) = \frac{F_0}{m\omega}\left( t - \frac{1}{\omega}\sin(\omega t) \right) = \frac{F_0}{m\omega^2}\bigl(\omega t - \sin(\omega t)\bigr). \]

Problem 3 (Mass on a Frictionless Inclined Plane).
A block of mass \( m \) slides on a frictionless plane inclined at a fixed angle \( \alpha \) above the horizontal. Let \( s(t) \) denote the displacement of the block measured along the plane, positive downward along the incline. Derive the equation of motion for \( s(t) \).

Solution.
The weight \( m g \) acts vertically downward. Resolving it into components: the component along the plane (positive downward) is \( m g \sin(\alpha) \). There are no other forces along the plane (normal reaction is perpendicular to the plane). Applying Newton’s second law along the incline:

\[ \sum F_s(t) = m g \sin(\alpha) = m\,\ddot{s}(t). \]

Therefore, the equation of motion is

\[ \ddot{s}(t) = g \sin(\alpha). \]

The acceleration is constant and independent of the mass, a classic result of motion on a frictionless incline.

Problem 4 (Two Masses in Contact on a Frictionless Surface).
Two blocks with masses \( m_1 \) and \( m_2 \) are in contact on a frictionless horizontal surface. A constant horizontal force \( F_0 \) is applied to block 1 in the positive direction. Determine:

1. the common acceleration \( a \) of the blocks,
2. the contact force \( N \) exerted by block 2 on block 1.

Solution.
Consider the two blocks together as a single system of mass \( m_1 + m_2 \). The only external horizontal force is \( F_0 \), so

\[ F_0 = (m_1 + m_2)\,a \quad \Rightarrow \quad a = \frac{F_0}{m_1 + m_2}. \]

To find the contact force, consider block 2 alone. The only horizontal force on block 2 is the contact force \( N \) from block 1, which accelerates block 2 with acceleration \( a \). Thus

\[ N = m_2\,a = m_2\,\frac{F_0}{m_1 + m_2}. \]

By Newton’s third law, block 2 exerts a force \( -N \) on block 1.

Problem 5 (Vertical Equilibrium Condition).
Revisit the vertical mass system of Section 7 with equation \( m\,\ddot{y}(t) = u(t) - m g \), where upward is positive. Show that the condition for zero acceleration (dynamic equilibrium) is \( u(t) = m g \), and interpret this physically.

Solution.
Setting \( \ddot{y}(t) = 0 \) in the equation of motion gives

\[ 0 = u(t) - m g \quad \Rightarrow \quad u(t) = m g. \]

When the upward actuator force equals the weight, the net force is zero, so the mass has zero acceleration. It either remains at rest or moves with constant velocity, depending on its initial state, in accordance with Newton’s first law.

In this lesson we:

• Reviewed Newton’s three laws and specialized the second law to one-dimensional translational motion.
• Defined displacement, velocity, and acceleration, and connected them to second-order ODEs via \( \sum F = m a \).
• Emphasized the importance of system boundaries and classification of forces into body and contact forces.
• Developed a systematic workflow for constructing free-body diagrams that directly lead to governing ODEs.
• Worked through canonical examples (horizontal and vertical motion) and implemented numerical simulations in Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica.

These foundations underlie all subsequent mechanical modeling in the course, including the mass–spring–damper systems of the next lesson and more complex coupled translational dynamics.