Consider a single-degree-of-freedom (1-DOF) translational mass moving on a horizontal surface with coordinate \( x(t) \) and velocity \( v(t) = \dot{x}(t) \). A generic force balance from Newton's second law can be written as

\[ m \ddot{x}(t) = F_{\text{ext}}(t) - F_{\text{spring}}(x(t)) - F_{\text{fric}}(v(t)), \]

where \( m \) is the mass, \( F_{\text{ext}}(t) \) is an external applied force, \( F_{\text{spring}}(x) \) may be, for example, a linear spring \( F_{\text{spring}} = k x \), and \( F_{\text{fric}}(v) \) is the friction force. Throughout this lesson, we will treat friction as a function of relative velocity \( v \) (and, for stick–slip, also of the contact state).

At the modeling level, we distinguish several idealized friction laws:

• Viscous friction: force proportional to velocity, \( F_{\text{fric}} \propto v \).
• Coulomb (dry) friction: force with almost constant magnitude opposing motion.
• Stribeck friction: velocity-dependent transition from static to kinetic friction.
• Stick–slip: piecewise behavior where the body alternates between sticking (no motion) and slipping.

The following diagram summarizes the modeling hierarchy used in this lesson.

flowchart TD
  A["Relative motion v(t)"] --> B["Friction modeling choice"]
  B --> C["Linear model: \nviscous"]
  B --> D["Nonlinear model: \nCoulomb"]
  B --> E["Nonlinear model: \nStribeck"]
  E --> F["Stick-slip: piecewise \ncontact state"]
  C --> G["Linear ODE: suitable \nfor analytical solution"]
  D --> H["Non-smooth ODE: \nsign(v)"]
  E --> I["Smooth/softened \nnonlinearity vs \nmagnitude of v"]
  F --> J["Event-based simulation: 'stick' and 'slip' modes"]
        

Viscous friction models energy dissipation proportional to relative velocity. The friction force is defined as

\[ F_{\text{visc}}(v) = b v, \]

where \( b \gt 0 \) is the viscous damping coefficient with units \( \text{N}\cdot\text{s}/\text{m} \). If we consider a mass–spring–damper system with viscous friction only, the equation of motion becomes

\[ m \ddot{x}(t) + b \dot{x}(t) + k x(t) = F_{\text{ext}}(t). \]

This is a linear second-order ordinary differential equation (ODE). For free vibration \( F_{\text{ext}}(t) = 0 \), we obtain

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

Using standard ODE theory, we can show that the total mechanical energy

\[ E(t) = \frac{1}{2} m \dot{x}^2(t) + \frac{1}{2} k x^2(t) \]

decreases monotonically in time. Indeed,

\[ \frac{\mathrm{d}E}{\mathrm{d}t} = m \dot{x}(t)\ddot{x}(t) + k x(t)\dot{x}(t) = \dot{x}(t)\bigl(m\ddot{x}(t) + k x(t)\bigr). \]

Using the equation of motion with \( F_{\text{ext}}(t) = 0 \) we get \( m\ddot{x}(t) + k x(t) = -b\dot{x}(t) \), hence

\[ \frac{\mathrm{d}E}{\mathrm{d}t} = \dot{x}(t)\bigl(-b\dot{x}(t)\bigr) = -b \dot{x}^2(t) \le 0. \]

Thus, viscous friction always dissipates energy (never generates it), which is consistent with physical intuition and will be a key property when we later study stability of dynamic systems.

Coulomb friction describes dry contact between two solid surfaces. For sliding motion \( v \neq 0 \), the friction force magnitude is approximately constant and independent of the sliding speed. Denote by \( F_c \gt 0 \) the kinetic (or dynamic) friction level. The Coulomb friction force is modeled as

\[ F_{\text{C}}(v) = \begin{cases} F_c, & v \lt 0,\\[4pt] -F_c, & v \gt 0, \end{cases} \]

where the sign convention above assumes that positive \( v \) corresponds to motion in the positive direction of \( x \), and friction always opposes motion. Alternatively, we can write

\[ F_{\text{C}}(v) = -F_c \,\mathrm{sign}\bigl(v\bigr), \qquad v \neq 0, \]

where the sign function is

\[ \mathrm{sign}(v) = \begin{cases} 1, & v \gt 0,\\ 0, & v = 0,\\ -1, & v \lt 0. \end{cases} \]

At \( v = 0 \), the Coulomb model by itself is not sufficient to distinguish between sticking and sliding. Physically, when the contact is at rest, the friction can take any value between \( -F_s \) and \( F_s \), where \( F_s \ge F_c \) is the static friction threshold. A static friction model can be expressed as

\[ |F_{\text{fric}}| \le F_s, \quad v = 0. \]

If the externally applied force satisfies \( |F_{\text{ext}} - F_{\text{spring}}| \le F_s \), the mass remains stuck with \( v(t) = 0 \). Once the net force magnitude exceeds \( F_s \), sliding begins and the friction magnitude reduces to approximately \( F_c \).

The equation of motion with Coulomb friction becomes

\[ m \ddot{x}(t) + k x(t) + F_{\text{C}}\bigl(\dot{x}(t)\bigr) = F_{\text{ext}}(t), \]

which is a nonlinear and non-smooth ODE because of the discontinuity in \( F_{\text{C}}(v) \) at \( v = 0 \).

Experimental measurements of friction in many engineering systems show that the friction level is not exactly constant during sliding. Instead, starting from rest, the friction typically:

1. Reaches a static friction peak \( F_s \) when motion initiates.
2. Decreases to a lower Coulomb friction level \( F_c \) for moderate velocity.
3. Increases again due to viscous effects at higher velocities.

This behavior is captured by the Stribeck friction law. A commonly used Stribeck model is

\[ F_{\text{S}}(v) = \left( F_c + \bigl(F_s - F_c\bigr) \exp\!\bigl(-(|v|/v_s)^{\alpha}\bigr) \right)\mathrm{sign}(v) + b v, \]

where:

• \( F_s \) is the static friction level.
• \( F_c \) is the Coulomb (kinetic) friction level.
• \( v_s \gt 0 \) is the characteristic Stribeck velocity.
• \( \alpha \gt 0 \) shapes the exponential decay.
• \( b \ge 0 \) is the viscous coefficient.

For small velocities \( |v| \ll v_s \), the exponential factor is close to one, so the friction magnitude is close to \( F_s \). For moderate velocities, the exponential term decays and the friction magnitude approaches \( F_c \). For large velocities, the viscous term \( b v \) dominates.

In contrast to pure Coulomb friction, the Stribeck law is continuous in \( v \) for \( v \neq 0 \), and can be made differentiable at \( v = 0 \) using appropriate regularizations of the sign function. This is useful when numerical solvers require smooth right-hand sides.

Stick–slip is a dynamic phenomenon where an object alternates between sticking (no motion relative to the surface) and slipping (finite relative velocity). It arises naturally when:

• Static friction is higher than kinetic friction, \( F_s \gt F_c \), and
• The external or elastic forces are slowly varying or oscillatory.

Consider again a mass–spring system with a constant external force \( F_0 \) and static friction \( F_s \). Let the mass be initially at rest at \( x(0)=0 \), \( \dot{x}(0)=0 \). The net force on the mass while it is sticking is balanced by friction:

\[ F_{\text{ext}}(t) - k x(t) - F_{\text{fric}}(t) = 0,\quad |F_{\text{fric}}(t)| \le F_s, \quad \dot{x}(t) = 0. \]

As the spring is slowly stretched by the external force, the elastic force \( k x(t) \) increases until the net force trying to move the mass exceeds the static friction threshold:

\[ |F_{\text{ext}}(t) - k x(t)| \gt F_s. \]

At this point, sticking is no longer possible and the mass starts sliding. The friction force then drops to approximately \( F_c \), leading to a rapid slip until the spring force and friction balance again and a new sticking phase begins. This alternation between sticking and slipping can lead to oscillatory motion even under constant or slowly varying loading.

In numerical simulation, stick–slip leads to mode switching between:

• A stick mode with \( \dot{x} = 0 \) and algebraic balance of forces.
• A slip mode with \( \dot{x} \neq 0 \) governed by a differential equation including kinetic friction.

A simple yet practically useful friction model that captures sticking and Coulomb sliding can be written as a piecewise definition. Let \( F_s \) be the static friction threshold and \( F_c \le F_s \) the kinetic friction magnitude. The net driving force is

\[ F_{\text{net}}(t) = F_{\text{ext}}(t) - k x(t). \]

We define:

\[ F_{\text{fric}}(t) = \begin{cases} -F_{\text{net}}(t), & \dot{x}(t) = 0 \ \text{and}\ |F_{\text{net}}(t)| \le F_s \quad (\text{stick}),\\[4pt] -F_c \,\mathrm{sign}\bigl(\dot{x}(t)\bigr), & \text{otherwise} \quad (\text{slip}). \end{cases} \]

In the stick regime, the friction force exactly balances the net force to maintain zero velocity; in the slip regime, the static constraint is released and the friction magnitude is limited to \( F_c \).

The full equation of motion combining spring and friction is then

\[ m \ddot{x}(t) = F_{\text{net}}(t) - F_{\text{fric}}(t) = F_{\text{ext}}(t) - k x(t) - F_{\text{fric}}(t), \]

where \( F_{\text{fric}}(t) \) is given by the piecewise rule above. In simulation, this definition is frequently implemented algorithmically rather than in closed-form analytical expressions.

When integrating the equations of motion numerically, one must decide at each time step whether the system is in stick or slip mode. A simple explicit algorithm proceeds as follows:

flowchart TD
  S["Start step with x, v"] --> N["Compute F_net = F_ext - k x"]
  N --> C1{"Is v = 0 and |F_net| <= F_s ?"}
  C1 --> ST["Stick: set a = 0, v_new = 0, x_new = x"]
  C1 --> SL["Slip: set F_f = -F_c sign(v) or Stribeck(v)"]
  SL --> D["Compute a = (F_net - F_f)/m"]
  D --> UP["Update v, x with integrator"]
  ST --> END["End step"]
  UP --> END
        

In practice, one also needs to detect the transition from stick to slip (when \( |F_{\text{net}}| \gt F_s \)) and from slip to stick (when the velocity crosses zero and the elastic force is insufficient to initiate motion again). More advanced friction models (such as LuGre) introduce additional internal state variables to describe microscopic bristle deformation, but those are beyond the scope of this introductory lesson.

For Python, we can use numpy for numerical operations and scipy.integrate.solve_ivp for ODE integration. The following example simulates a mass–spring system with Stribeck friction and a constant external force.

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

# Parameters
m  = 1.0      # mass [kg]
k  = 50.0     # spring stiffness [N/m]
Fs = 8.0      # static friction level [N]
Fc = 5.0      # Coulomb friction level [N]
vs = 0.1      # Stribeck velocity [m/s]
alpha = 1.0   # Stribeck shape exponent
b  = 0.5      # viscous coefficient [N*s/m]
F0 = 7.0      # constant external force [N]

def stribeck_friction(v):
    if abs(v) < 1e-6:
        # Regularized sign for very small velocities
        s = 0.0
    else:
        s = copysign(1.0, v)
    mag = Fc + (Fs - Fc) * np.exp(- (abs(v) / vs)**alpha)
    return mag * s + b * v

def mass_spring_stribeck(t, z):
    x, v = z
    F_ext = F0
    Fspring = k * x
    Ffric = stribeck_friction(v)
    a = (F_ext - Fspring - Ffric) / m
    return [v, a]

t_span = (0.0, 5.0)
z0 = [0.0, 0.0]  # initial position and velocity

sol = solve_ivp(mass_spring_stribeck, t_span, z0, max_step=1e-3, dense_output=True)

t = np.linspace(t_span[0], t_span[1], 2000)
x = sol.sol(t)[0]
v = sol.sol(t)[1]

plt.figure()
plt.plot(t, x)
plt.xlabel("t [s]")
plt.ylabel("x(t) [m]")
plt.title("Mass-spring with Stribeck friction: position")
plt.grid(True)

plt.figure()
plt.plot(t, v)
plt.xlabel("t [s]")
plt.ylabel("v(t) [m/s]")
plt.title("Mass-spring with Stribeck friction: velocity")
plt.grid(True)

plt.show()
      

This code illustrates how to embed the friction law directly into the ODE right-hand side. Regularization of the sign function near \( v = 0 \) can help numerical stability when simulating near stick–slip transitions.

In C++, we can implement the same mass–spring system using a simple explicit Euler integrator. For more advanced projects, linear algebra libraries such as Eigen can be used, but here we restrict ourselves to scalar computations to keep the focus on system dynamics.

#include <iostream>
#include <cmath>

double stribeck_friction(double v, double Fs, double Fc,
                         double vs, double alpha, double b)
{
    double s = 0.0;
    if (std::abs(v) > 1e-6) {
        s = (v > 0.0) ? 1.0 : -1.0;
    }
    double mag = Fc + (Fs - Fc) * std::exp(- std::pow(std::abs(v) / vs, alpha));
    return mag * s + b * v;
}

int main()
{
    // Parameters
    double m  = 1.0;
    double k  = 50.0;
    double Fs = 8.0;
    double Fc = 5.0;
    double vs = 0.1;
    double alpha = 1.0;
    double b  = 0.5;
    double F0 = 7.0;

    double t  = 0.0;
    double dt = 1e-4;
    double t_end = 5.0;

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

    while (t < t_end) {
        double F_ext = F0;
        double Fspring = k * x;
        double Ffric = stribeck_friction(v, Fs, Fc, vs, alpha, b);
        double a = (F_ext - Fspring - Ffric) / m;

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

        t += dt;

        // For demonstration, print every 1000 steps
        if (static_cast<int>(t / dt) % 1000 == 0) {
            std::cout << t << " " << x << " " << v << std::endl;
        }
    }

    return 0;
}
      

Explicit Euler is only conditionally stable, especially for stiff systems (large \( k \) or small \( m \)). Nevertheless, it is useful for illustrating how friction terms enter the numerical update.

In Java, we can implement a similar simulation using plain arrays or lists. Libraries such as Apache Commons Math provide more sophisticated ODE solvers, but a basic custom integrator is sufficient to understand the system dynamics.

public class MassSpringFriction {

    public static double stribeckFriction(double v,
                                          double Fs, double Fc,
                                          double vs, double alpha, double b) {
        double s = 0.0;
        if (Math.abs(v) > 1e-6) {
            s = (v > 0.0) ? 1.0 : -1.0;
        }
        double mag = Fc + (Fs - Fc) * Math.exp(-Math.pow(Math.abs(v) / vs, alpha));
        return mag * s + b * v;
    }

    public static void main(String[] args) {
        double m  = 1.0;
        double k  = 50.0;
        double Fs = 8.0;
        double Fc = 5.0;
        double vs = 0.1;
        double alpha = 1.0;
        double b  = 0.5;
        double F0 = 7.0;

        double t  = 0.0;
        double dt = 1e-4;
        double tEnd = 5.0;

        double x = 0.0;
        double v = 0.0;

        int step = 0;
        while (t < tEnd) {
            double Fext = F0;
            double Fspring = k * x;
            double Ffric = stribeckFriction(v, Fs, Fc, vs, alpha, b);
            double a = (Fext - Fspring - Ffric) / m;

            v += dt * a;
            x += dt * v;
            t += dt;

            if (step % 1000 == 0) {
                System.out.println(t + " " + x + " " + v);
            }
            step++;
        }
    }
}
      

This Java example mirrors the C++ code and emphasizes that friction modeling is largely language-agnostic: what matters is the correct mathematical representation inside the time-stepping loop.

In MATLAB, we typically use ode45 (or other ODE solvers) for continuous-time simulation, and Simulink for block-diagram-based modeling. The following script models a mass–spring system with Coulomb and viscous friction:

function mass_spring_friction_demo
    % Parameters
    m  = 1.0;
    k  = 50.0;
    Fc = 5.0;
    b  = 0.5;
    F0 = 7.0;

    tspan = [0, 5];
    z0 = [0; 0];  % [x; v]

    [t, z] = ode45(@(t, z) rhs(t, z, m, k, Fc, b, F0), tspan, z0);

    x = z(:, 1);
    v = z(:, 2);

    figure;
    plot(t, x);
    xlabel('t [s]');
    ylabel('x(t) [m]');
    title('Mass-spring with Coulomb and viscous friction');
    grid on;

    figure;
    plot(t, v);
    xlabel('t [s]');
    ylabel('v(t) [m/s]');
    title('Velocity');
    grid on;
end

function dz = rhs(t, z, m, k, Fc, b, F0)
    x = z(1);
    v = z(2);

    Fext = F0;
    Fspring = k * x;

    if abs(v) < 1e-6
        s = 0;
    else
        s = sign(v);
    end

    Ffric = Fc * s + b * v;

    a = (Fext - Fspring - Ffric) / m;
    dz = [v; a];
end
      

In Simulink, the same system can be modeled using blocks:

• Use an Integrator block cascaded with another Integrator to represent velocity and position.
• Compute Fspring = k*x using a Gain block.
• Implement friction using either the built-in Coulomb & Viscous Friction block (in Simscape) or a custom MATLAB Function block.
• Sum the forces and divide by \( m \) using a Gain block to obtain acceleration.

Simulink provides a convenient way to later connect such frictional mechanical models to control systems, sensors, and actuators.

In Wolfram Mathematica, we can use NDSolve to integrate the ODE with a friction term. The example below uses a Stribeck-type friction model in a mass–spring system under constant load:

(* Parameters *)
m  = 1.0;
k  = 50.0;
Fs = 8.0;
Fc = 5.0;
vs = 0.1;
alpha = 1.0;
b  = 0.5;
F0 = 7.0;

stribeck[v_] := Module[{s, mag},
  s = If[Abs[v] > 10.^-6, Sign[v], 0.0];
  mag = Fc + (Fs - Fc)*Exp[-(Abs[v]/vs)^alpha];
  mag*s + b*v
];

eq = m*x''[t] + k*x[t] + stribeck[x'[t]] == F0;
ic = {x[0] == 0, x'[0] == 0};

sol = NDSolve[{eq, ic}, x, {t, 0, 5}][[1]];

Plot[Evaluate[x[t] /. sol], {t, 0, 5},
  AxesLabel -> {"t [s]", "x(t) [m]"},
  PlotLabel -> "Mass-spring with Stribeck friction"
]

Plot[Evaluate[x'[t] /. sol], {t, 0, 5},
  AxesLabel -> {"t [s]", "v(t) [m/s]"},
  PlotLabel -> "Velocity"
]
      

Mathematica's symbolic and numeric capabilities make it particularly suitable for exploring how different friction laws influence the qualitative behavior of solutions, including stick–slip-like oscillations.

Problem 1 (Energy Dissipation with Viscous Friction):
Consider the free mass–spring–damper system

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

Show that the mechanical energy \( E(t) = \frac{1}{2}m\dot{x}^2(t) + \frac{1}{2}k x^2(t) \) satisfies \( \frac{\mathrm{d}E}{\mathrm{d}t} \le 0 \), and interpret the result physically.

Solution:
Differentiating \( E(t) \) gives

\[ \frac{\mathrm{d}E}{\mathrm{d}t} = m \dot{x}(t)\ddot{x}(t) + k x(t)\dot{x}(t) = \dot{x}(t)\bigl(m\ddot{x}(t) + k x(t)\bigr). \]

Using the equation of motion \( m\ddot{x}(t) + k x(t) = -b\dot{x}(t) \), we obtain

\[ \frac{\mathrm{d}E}{\mathrm{d}t} = \dot{x}(t)\bigl(-b\dot{x}(t)\bigr) = -b\dot{x}^2(t) \le 0, \]

since \( b \gt 0 \) and \( \dot{x}^2(t) \ge 0 \). Physically, this means that viscous friction always dissipates energy and never injects energy into the system; the system's total mechanical energy is non-increasing over time.

Problem 2 (Equilibrium under Coulomb Friction):
Consider a mass–spring system with Coulomb friction and constant external load:

\[ m \ddot{x}(t) + k x(t) + F_{\text{C}}\bigl(\dot{x}(t)\bigr) = F_0, \]

where \( F_{\text{C}}(v) = -F_c\,\mathrm{sign}(v) \) for \( v \neq 0 \), and static friction magnitude is \( F_s \ge F_c \). Assume the mass is initially at rest at \( x(0)=0 \), \( \dot{x}(0)=0 \).

1. Find the condition on \( F_0 \) for which the mass never moves (perfect sticking).
2. If \( F_0 \gt F_s \), find the static equilibrium position \( x^* \) at which the mass can eventually come to rest after sliding.

Solution:
(1) While the mass is at rest, we have \( \dot{x} = 0 \) and friction adjusts so that

\[ k x(t) + F_{\text{fric}}(t) = F_0, \quad |F_{\text{fric}}(t)| \le F_s. \]

Since the initial state is \( x(0)=0 \), the initial net force is \( F_0 - k x(0) = F_0 \). For sticking to persist, we need \( |F_0 - k x(t)| \le F_s \). In particular, at \( t = 0 \) this implies

\[ |F_0| \le F_s. \]

If \( |F_0| \le F_s \) and no other disturbances act, the mass may remain at rest forever.

(2) If \( F_0 \gt F_s \), static friction cannot balance the net force at rest, and the mass starts to move. After transient motion, it may settle to a new equilibrium with zero velocity \( \dot{x} = 0 \), for which the kinetic friction must satisfy

\[ k x^* + F_{\text{C}}(0^+) = F_0, \]

where \( F_{\text{C}}(0^+) \) denotes the kinetic friction level just after sliding starts, of magnitude \( F_c \) and sign opposite to the velocity. Assuming the mass eventually slides in the positive direction (\( v \gt 0 \)), we have \( F_{\text{C}} = -F_c \), hence

\[ k x^* - F_c = F_0 \quad \Rightarrow \quad x^* = \frac{F_0 + F_c}{k}. \]

Thus, the final static displacement includes the contribution of the external load plus an offset due to the kinetic friction level.

Problem 3 (Onset of Sliding in Stick–Slip):
Consider again the combined piecewise friction model from Section 6. Suppose that \( F_{\text{ext}}(t) = k_l u(t) \) is generated by another spring of stiffness \( k_l \), where the input \( u(t) \) is slowly increasing. Derive an expression for the relative displacement at which the mass first starts to slide.

Solution:
Let \( x_l(t) = u(t) \) be the displacement at the far end of the loading spring. The force transmitted through the loading spring is \( F_{\text{ext}} = k_l (x_l - x) \). While the mass is sticking (\( \dot{x} = 0 \), \( x = x_0 \) constant), the net driving force on the mass is

\[ F_{\text{net}}(t) = k_l(x_l(t) - x_0) - k x_0. \]

Sliding begins when \( |F_{\text{net}}(t)| \gt F_s \). Assuming the initial displacement is \( x_0 = 0 \), the condition becomes

\[ |k_l x_l(t)| \gt F_s \quad \Rightarrow \quad |x_l(t)| \gt \frac{F_s}{k_l}. \]

Therefore, the mass starts sliding when the loading spring has been stretched by \( F_s/k_l \). This simple formula underlies many stick–slip and friction-oscillation models used in tribology and seismology.

Problem 4 (Nonlinearity of Coulomb Friction):
Show that the system

\[ m \ddot{x}(t) + F_{\text{C}}\bigl(\dot{x}(t)\bigr) = F_{\text{ext}}(t) \]

with \( F_{\text{C}}(v) = -F_c\,\mathrm{sign}(v) \) is nonlinear in the sense of superposition, even if \( F_{\text{ext}}(t) \) is linear in time.

Solution:
A system is linear if for any two inputs \( F_1(t) \), \( F_2(t) \) and any scalars \( a, b \), the response to \( aF_1 + bF_2 \) is \( a x_1 + b x_2 \), where \( x_1 \) and \( x_2 \) are the responses to \( F_1 \) and \( F_2 \) respectively. The term \( F_{\text{C}}(\dot{x}) = -F_c\,\mathrm{sign}(\dot{x}) \) is nonlinear in \( \dot{x} \) because:

• The sign function is not homogeneous: \( \mathrm{sign}(a v) = a \,\mathrm{sign}(v) \) does not hold for arbitrary \( a \).
• It is not additive: \( \mathrm{sign}(v_1 + v_2) \neq \mathrm{sign}(v_1) + \mathrm{sign}(v_2) \) in general.

Therefore, the mapping from \( F_{\text{ext}} \) to \( x \) does not satisfy the superposition principle. This formally classifies Coulomb friction as a nonlinear system element.

Problem 5 (Approximate Linearization of Stribeck Friction):
For the Stribeck model

\[ F_{\text{S}}(v) = \left( F_c + \bigl(F_s - F_c\bigr) \exp\!\bigl(-(|v|/v_s)^{\alpha}\bigr) \right)\mathrm{sign}(v) + b v, \]

consider small velocities \( |v| \ll v_s \). Derive a first-order approximation \( F_{\text{S}}(v) \approx k_{\text{eq}} v \) for some equivalent viscous coefficient \( k_{\text{eq}} \) and explain under which conditions this approximation might be used in control design.

Solution (sketch):
For \( |v| \ll v_s \), the exponential term can be expanded:

\[ \exp\!\bigl(-(|v|/v_s)^{\alpha}\bigr) \approx 1 - (|v|/v_s)^{\alpha} + \cdots. \]

Thus,

\[ F_{\text{S}}(v) \approx \bigl(F_c + (F_s - F_c)\bigr)\mathrm{sign}(v) - (F_s - F_c)(|v|/v_s)^{\alpha}\mathrm{sign}(v) + b v. \]

The first term is approximately \( F_s \mathrm{sign}(v) \), corresponding to static friction, while the second term introduces a velocity-dependent correction. For small enough velocities and in a statistical sense (e.g., averaging over small fluctuations), the nonlinear part can be approximated by an equivalent viscous coefficient \( k_{\text{eq}} \) determined experimentally by fitting a line through the measured friction curve near \( v = 0 \). In control-oriented modeling, this linearization is used to represent friction as an additional damping term around a nominal operating point, with the understanding that it is valid only for small perturbations.

In this lesson, we introduced friction modeling for translational mechanical systems at increasing levels of fidelity:

• Viscous friction as a linear, energy-dissipating term proportional to velocity.
• Coulomb (dry) friction as a non-smooth, nonlinear force opposing motion with approximately constant magnitude.
• Stribeck friction as a more realistic velocity-dependent model capturing the transition from static to kinetic friction and viscous behavior.
• Stick–slip as a mode-switching phenomenon arising from the interplay between elastic forces and friction thresholds.

We formulated these friction laws mathematically, embedded them into Newtonian equations of motion, and implemented them in multiple programming environments (Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica). In subsequent chapters on input–output descriptions and linearization, these friction models will serve as canonical examples of nonlinear and non-smooth elements in dynamic systems.