A standard first-order LTI system with input \( u(t) \) and output \( y(t) \) can be written in the time domain as

\[ \tau \frac{\mathrm{d}y(t)}{\mathrm{d}t} + y(t) = K\,u(t), \quad t \ge 0 \]

where \( K \) is the static (steady-state) gain and \( \tau > 0 \) is the time constant (its time-domain meaning will be developed further in Lesson 3). The Laplace-domain transfer function, assuming zero initial condition, is

\[ G(s) = \frac{Y(s)}{U(s)} = \frac{K}{\tau s + 1}. \]

To characterize the dynamic behavior, we apply standard test inputs:

\[ u_{\text{step}}(t) = U_0\,u(t), \quad u_{\text{ramp}}(t) = R\,t\,u(t), \quad u_{\text{imp}}(t) = \delta(t), \]

where \( u(t) \) is the unit step and \( \delta(t) \) is the Dirac impulse. In motion-control and robotics, these correspond roughly to:

• Step in voltage/torque: a sudden command to a motor.
• Ramp in position: a constant-velocity reference trajectory.
• Impulse: an idealized shock or very short pulse of force/torque.

flowchart TD
  R["Input r(t): step / ramp / impulse"] --> L["Laplace transform: U(s)"]
  L --> G["First-order plant G(s) = K/(tau s + 1)"]
  G --> IL["Inverse Laplace"]
  IL --> Y["Time response y(t)"]

  Y --> A["Analyze: initial value, final value, slope"]
  A --> ROB["Interpret in robotics: joint/motor dynamics"]
        

In this lesson we explicitly compute \( y(t) \) for each of these standard inputs and relate the expressions to physical intuition.

2.1 Time-Domain Solution from the Differential Equation

Consider the first-order system driven by a constant step of amplitude \( U_0 \):

\[ \tau \frac{\mathrm{d}y(t)}{\mathrm{d}t} + y(t) = K U_0\,u(t), \quad t \ge 0, \quad y(0) = y_0. \]

For \( t > 0 \) we can treat the right-hand side as constant \( K U_0 \). We solve the linear ODE by the standard homogeneous + particular decomposition.

Homogeneous solution. Solve

\[ \tau \frac{\mathrm{d}y_h(t)}{\mathrm{d}t} + y_h(t) = 0 \quad \Rightarrow \quad \frac{\mathrm{d}y_h(t)}{\mathrm{d}t} = -\frac{1}{\tau} y_h(t). \]

Integrating gives

\[ y_h(t) = C\,\mathrm{e}^{-t/\tau}, \]

where \( C \) is a constant determined by the initial condition.

Particular solution. We seek a constant particular solution

\[ y_p(t) = \bar{y} \quad \Rightarrow \quad \tau \cdot 0 + \bar{y} = K U_0 \quad \Rightarrow \quad \bar{y} = K U_0. \]

Therefore the general solution for \( t \ge 0 \) is

\[ y(t) = K U_0 + C\,\mathrm{e}^{-t/\tau}. \]

Imposing the initial condition at \( t = 0 \) gives

\[ y(0) = y_0 = K U_0 + C \quad \Rightarrow \quad C = y_0 - K U_0. \]

Thus, the step response is

\[ y_{\text{step}}(t) = K U_0 + (y_0 - K U_0)\,\mathrm{e}^{-t/\tau}, \quad t \ge 0. \]

For the common case of zero initial condition \( y_0 = 0 \) (system initially at rest),

\[ y_{\text{step}}(t) = K U_0\left(1 - \mathrm{e}^{-t/\tau}\right)u(t). \]

This is the canonical first-order step response: a monotonic exponential rise from \( 0 \) to the steady-state value \( K U_0 \).

2.2 Verification Using the Transfer Function

Using the transfer function \( G(s) = K/(\tau s + 1) \) and the Laplace transform of a step, \( U(s) = U_0/s \), we obtain:

\[ Y(s) = G(s) U(s) = \frac{K}{\tau s + 1} \cdot \frac{U_0}{s} = \frac{K U_0}{s(\tau s + 1)}. \]

We perform partial fraction expansion:

\[ \frac{K U_0}{s(\tau s + 1)} = K U_0\left( \frac{1}{s} - \frac{1}{s + \frac{1}{\tau}} \right). \]

Using standard inverse Laplace transforms,

\[ \mathcal{L}^{-1}\left\{\frac{1}{s}\right\} = u(t), \quad \mathcal{L}^{-1}\left\{\frac{1}{s + \frac{1}{\tau}}\right\} = \mathrm{e}^{-t/\tau} u(t), \]

we recover

\[ y_{\text{step}}(t) = K U_0\left(1 - \mathrm{e}^{-t/\tau}\right)u(t), \]

which matches the time-domain derivation.

2.3 Initial Slope and Long-Time Behavior

Differentiating the step response for zero initial condition yields

\[ \frac{\mathrm{d}y_{\text{step}}(t)}{\mathrm{d}t} = \frac{K U_0}{\tau}\,\mathrm{e}^{-t/\tau}. \]

The initial slope at \( t = 0^+ \) is \( (K U_0)/\tau \), and as \( t \to \infty \), the exponential term decays to zero and

\[ \lim_{t \to \infty} y_{\text{step}}(t) = K U_0. \]

For \( t = \tau \), we obtain the classical value \( y_{\text{step}}(\tau) = K U_0(1 - \mathrm{e}^{-1}) \approx 0.632\,K U_0 \). The interpretation of \( \tau \) in terms of "speed of response" will be treated systematically in Lesson 3.

A ramp input is often used to model a constant-velocity reference in robotics, e.g., a joint angle increasing linearly with time:

\[ u_{\text{ramp}}(t) = R\,t\,u(t), \]

where \( R \) has units of rate (e.g. radians per second per unit input).

The Laplace transform of the ramp is \( U_{\text{ramp}}(s) = R/s^2 \), so the output in the Laplace domain is

\[ Y_{\text{ramp}}(s) = G(s) U_{\text{ramp}}(s) = \frac{K}{\tau s + 1} \cdot \frac{R}{s^2} = \frac{K R}{s^2(\tau s + 1)}. \]

We expand into partial fractions:

\[ \frac{K R}{s^2(\tau s + 1)} = K R\left( \frac{A}{s} + \frac{B}{s^2} + \frac{C}{\tau s + 1} \right). \]

Multiplying both sides by \( s^2(\tau s + 1) \):

\[ 1 = A s(\tau s + 1) + B(\tau s + 1) + C s^2. \]

Expanding and grouping terms in powers of \( s \):

\[ 1 = (A\tau + C)s^2 + (A + B\tau)s + B. \]

Comparing coefficients with \( 1 = 0\cdot s^2 + 0\cdot s + 1 \) yields

\[ B = 1, \quad A + B\tau = 0 \Rightarrow A = -\tau, \quad A\tau + C = 0 \Rightarrow C = \tau^2. \]

Thus

\[ Y_{\text{ramp}}(s) = K R\left( -\frac{\tau}{s} + \frac{1}{s^2} + \frac{\tau^2}{\tau s + 1} \right). \]

Using \( \mathcal{L}^{-1}\{1/s^2\} = t\,u(t) \), \( \mathcal{L}^{-1}\{1/s\} = u(t) \), and

\[ \mathcal{L}^{-1}\left\{\frac{1}{\tau s + 1}\right\} = \frac{1}{\tau}\,\mathrm{e}^{-t/\tau}u(t), \]

we obtain the ramp response

\[ y_{\text{ramp}}(t) = K R\left( t - \tau + \tau\,\mathrm{e}^{-t/\tau} \right)u(t) = K R\left( t - \tau\left(1 - \mathrm{e}^{-t/\tau}\right) \right)u(t). \]

As \( t \to \infty \), the exponential term vanishes and the output behaves approximately as

\[ y_{\text{ramp}}(t) \approx K R\left(t - \tau\right), \]

i.e. it is itself approximately a ramp of slope \( K R \) but delayed by \( \tau \). This delayed tracking behavior under ramp input is a crucial building block for understanding steady-state tracking error, which will be formalized later when system type and error constants are introduced.

The impulse response is the output of the system when the input is an ideal Dirac impulse:

\[ u_{\text{imp}}(t) = \delta(t), \quad U_{\text{imp}}(s) = 1. \]

Since \( Y(s) = G(s) U(s) \), the impulse response in the Laplace domain is simply

\[ Y_{\text{imp}}(s) = G(s) = \frac{K}{\tau s + 1}. \]

Therefore

\[ y_{\text{imp}}(t) = \mathcal{L}^{-1}\left\{ \frac{K}{\tau s + 1} \right\} = \frac{K}{\tau}\,\mathrm{e}^{-t/\tau}u(t). \]

The impulse response is a decaying exponential that starts at \( K/\tau \) and integrates to the DC gain:

\[ \int_{0}^{\infty} y_{\text{imp}}(t)\,\mathrm{d}t = \int_{0}^{\infty} \frac{K}{\tau}\,\mathrm{e}^{-t/\tau}\,\mathrm{d}t = K. \]

This integral identity is a special case of the general property that for a stable LTI system, the area under the impulse response equals the steady-state gain \( G(0) \).

There is also a simple relationship between the step and impulse responses. For the unit step input (\( U_0 = 1 \)) we have

\[ y_{\text{step}}(t) = K\left(1 - \mathrm{e}^{-t/\tau}\right)u(t). \]

Differentiating with respect to time (for \( t > 0 \)) gives

\[ \frac{\mathrm{d}y_{\text{step}}(t)}{\mathrm{d}t} = \frac{K}{\tau}\,\mathrm{e}^{-t/\tau} = y_{\text{imp}}(t), \]

which shows that, for a first-order system, the impulse response is the derivative of the step response. This is consistent with the Laplace-domain identity that differentiation in time corresponds to multiplication by \( s \) in the Laplace domain, and the fact that the step is (in a distributional sense) the integral of the impulse.

• Step response: monotonic exponential approach to \( K U_0 \), with initial slope \( (K U_0)/\tau \) and characteristic time scale \( \tau \).
• Ramp response: asymptotically a ramp with slope \( K R \), but with an effective delay \( \tau \). The transient term \( -K R\tau(1 - \mathrm{e}^{-t/\tau}) \) captures the initial lag.
• Impulse response: purely transient decaying exponential whose integral equals \( K \). It captures how the system reacts to very fast shocks and is the fundamental kernel that characterizes the LTI system.

In robotics, a motor or joint drive often behaves approximately as a first-order system over a suitable range. The shape of these responses determines how quickly a robot can respond to sudden commands (step), follow a smooth trajectory (ramp), or damp out impacts and measurement noise (impulse).

flowchart TD
  P0["Choose K, tau, dt, T"] --> P1["For each time step compute input u(t): step / ramp / discrete impulse"]
  P1 --> P2["Integrate ODE: tau dy/dt + y = K u(t) (e.g. Euler)"]
  P2 --> P3["Store y(t); plot or use in robot joint controller simulation"]
        

In Python, first-order responses can be computed either analytically (using numpy) or via control libraries such as python-control (often used together with robotics packages like roboticstoolbox-python for modeling joints and manipulators). Below we generate step, ramp, and approximate impulse responses.

import numpy as np
import matplotlib.pyplot as plt

# Parameters of first-order system: G(s) = K / (tau s + 1)
K = 2.0
tau = 0.5

# Time grid
t_end = 5.0
n_points = 2000
t = np.linspace(0.0, t_end, n_points)

# Analytical responses for unit inputs (U0 = 1, R = 1)
u_step = np.ones_like(t)          # unit step
u_ramp = t                        # unit ramp
# Approximate unit impulse as a narrow pulse of width dt and area 1
dt = t[1] - t[0]
u_imp = np.zeros_like(t)
u_imp[0] = 1.0 / dt

# Closed-form responses
y_step = K * (1.0 - np.exp(-t / tau))           # y_step(t)
y_ramp = K * (t - tau * (1.0 - np.exp(-t / tau)))  # y_ramp(t)
y_imp = (K / tau) * np.exp(-t / tau)            # y_imp(t)

# (Optional) numerical integration of the ODE tau dy/dt + y = K u(t)
def simulate_first_order(u):
    y = np.zeros_like(t)
    for k in range(1, len(t)):
        dydt = (-y[k-1] + K * u[k-1]) / tau
        y[k] = y[k-1] + dt * dydt
    return y

y_step_num = simulate_first_order(u_step)
y_ramp_num = simulate_first_order(u_ramp)
y_imp_num = simulate_first_order(u_imp)

# Plotting
plt.figure()
plt.plot(t, y_step, label="analytic step")
plt.plot(t, y_step_num, "--", label="numerical step")
plt.xlabel("t [s]")
plt.ylabel("y_step(t)")
plt.legend()

plt.figure()
plt.plot(t, y_ramp, label="analytic ramp")
plt.plot(t, y_ramp_num, "--", label="numerical ramp")
plt.xlabel("t [s]")
plt.ylabel("y_ramp(t)")
plt.legend()

plt.figure()
plt.plot(t, y_imp, label="analytic impulse")
plt.plot(t, y_imp_num, "--", label="numerical impulse")
plt.xlabel("t [s]")
plt.ylabel("y_imp(t)")
plt.legend()

plt.show()

# In a robotics context:
# - G(s) may model a motor velocity loop.
# - Libraries such as 'control' (python-control) can define tf(K, [tau, 1])
#   and compute step_response/impulse_response for joint-level design.
      

This code can be embedded in ROS-based robotics simulations by wrapping the integration loop in a node and replacing the fixed test input with real reference commands.

In embedded and robotics systems (e.g. using ROS, ros_control or Orocos), first-order models are often integrated in real time. The following C++ example uses explicit Euler integration for step/ramp/impulse responses. Linear algebra libraries like Eigen can be added for multi-axis systems.

#include <iostream>
#include <vector>
#include <cmath>

int main() {
    double K   = 2.0;
    double tau = 0.5;
    double dt  = 0.001;
    double T   = 5.0;

    int N = static_cast<int>(T / dt);
    std::vector<double> t_vec(N), y_vec(N);

    double y = 0.0; // initial condition

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

        // Choose test input:
        double u_step    = 1.0;           // unit step
        double u_ramp    = t;             // unit ramp
        double u_impulse = (k == 0) ? 1.0 / dt : 0.0; // discrete impulse

        double u = u_step; // switch to u_ramp or u_impulse for other tests

        // First-order ODE: tau dy/dt + y = K u
        double dydt = (-y + K * u) / tau;
        y += dt * dydt;

        t_vec[k] = t;
        y_vec[k] = y;
    }

    // Print a few samples
    for (int k = 0; k < N; k += N / 10) {
        std::cout << "t = " << t_vec[k]
                  << ", y = " << y_vec[k] << std::endl;
    }

    // In robotics, this loop can be placed inside a real-time control thread,
    // with u read from sensor-based trajectories or ROS topics.
    return 0;
}
      

In a ROS-based robot, one might encapsulate this dynamics in a controller plugin, using ros_control to interface with hardware and Eigen vectors to represent multi-joint states.

Java is frequently used in educational and industrial robotics (e.g., the WPILib library for FRC robots). Below is a simple discrete-time simulation of the first-order system, suitable for integration in a Java-based robot control framework, potentially combined with numeric libraries like EJML for matrix operations.

import java.util.ArrayList;
import java.util.List;

public class FirstOrderResponse {
    public static void main(String[] args) {
        double K   = 2.0;
        double tau = 0.5;
        double dt  = 0.001;
        double T   = 5.0;

        int N = (int) (T / dt);
        List<Double> tList = new ArrayList<>(N);
        List<Double> yList = new ArrayList<>(N);

        double y = 0.0; // initial condition

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

            double uStep    = 1.0;           // unit step
            double uRamp    = t;             // unit ramp
            double uImpulse = (k == 0) ? 1.0 / dt : 0.0; // discrete impulse

            double u = uStep; // choose the desired test input

            double dydt = (-y + K * u) / tau;
            y += dt * dydt;

            tList.add(t);
            yList.add(y);
        }

        for (int k = 0; k < N; k += N / 10) {
            System.out.printf("t = %.3f, y = %.4f%n", tList.get(k), yList.get(k));
        }

        // In Java-based robotics (e.g. WPILib), this logic can be placed inside
        // the periodic control loop to simulate plant dynamics or perform model-based control.
    }
}
      

MATLAB with the Control System Toolbox and Robotics System Toolbox is a standard environment for modeling robotic joints and drive systems. The following script defines the first-order transfer function and uses built-in functions to obtain step, ramp, and impulse responses. Simulink can then be used to build equivalent block diagrams for hardware-in-the-loop testing.

% Parameters
K   = 2.0;
tau = 0.5;

% Transfer function G(s) = K / (tau s + 1)
s = tf('s');
G = K / (tau * s + 1);

t = linspace(0, 5, 1000);

% Step response (unit step)
[y_step, t_step] = step(G, t);

% Ramp response: input r(t) = t * u(t)
u_ramp = t;  % unit ramp
[y_ramp, t_ramp, x_ramp] = lsim(G, u_ramp, t);

% Impulse response
[y_imp, t_imp] = impulse(G, t);

% Plot
figure;
plot(t_step, y_step, 'LineWidth', 1.5);
xlabel('t [s]'); ylabel('y_{step}(t)');
title('First-Order Step Response'); grid on;

figure;
plot(t_ramp, y_ramp, 'LineWidth', 1.5);
xlabel('t [s]'); ylabel('y_{ramp}(t)');
title('First-Order Ramp Response'); grid on;

figure;
plot(t_imp, y_imp, 'LineWidth', 1.5);
xlabel('t [s]'); ylabel('y_{imp}(t)');
title('First-Order Impulse Response'); grid on;

% In Simulink:
% - Use a Transfer Fcn block with numerator K and denominator [tau 1].
% - Drive it with Step, Ramp, and Pulse Generator sources.
% - Connect to Scope blocks to visualize the responses.
% With Robotics System Toolbox, these blocks can be integrated with robot models.
      

Wolfram Mathematica provides symbolic and numeric tools for control analysis via TransferFunctionModel and OutputResponse. This is particularly useful in robotics research where analytical expressions of responses are needed for proofs or design derivations.

(* Parameters *)
K   = 2.0;
tau = 0.5;

(* Continuous-time first-order system *)
sys = TransferFunctionModel[K/(tau*s + 1), s];

(* Time range *)
tmin = 0; tmax = 5;

(* Standard inputs *)
uStep[t_]    := UnitStep[t];
uRamp[t_]    := t * UnitStep[t];
uImpulse[t_] := DiracDelta[t];

(* Responses *)
yStep[t_]    = OutputResponse[sys, uStep[t], {t, tmin, tmax}];
yRamp[t_]    = OutputResponse[sys, uRamp[t], {t, tmin, tmax}];
yImpulse[t_] = OutputResponse[sys, uImpulse[t], {t, tmin, tmax}];

(* Plot step and impulse responses *)
Plot[{yStep[t], yImpulse[t]}, {t, tmin, tmax},
     PlotLegends -> {"step", "impulse"},
     AxesLabel -> {"t", "y(t)"}]

(* In a robotics context, sys can represent a joint velocity actuator.
   One can combine several such TransferFunctionModel objects symbolically
   to represent multi-link robot dynamics and derive closed-form responses. *)
      

In this lesson we derived the step, ramp, and impulse responses of a standard first-order LTI system characterized by \( G(s) = K/(\tau s + 1) \). We showed that:

• The step response is \( K U_0(1 - \mathrm{e}^{-t/\tau}) \), with final value \( K U_0 \) and characteristic time scale \( \tau \).
• The ramp response combines a linearly growing term \( K R t \) with a transient \( -K R\tau(1 - \mathrm{e}^{-t/\tau}) \), revealing a delayed tracking behavior.
• The impulse response is \( (K/\tau)\mathrm{e}^{-t/\tau} \), whose integral equals the DC gain \( K \) and which is the derivative of the step response.

Implementations in Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica illustrated how these analytical expressions and first-order ODEs can be used in simulation and robotic control software. In the next lesson, we will formalize the notion of time constant and speed of response based on these time-domain behaviors.