In previous chapters, you modeled physical systems (mechanical, electrical, electromechanical) by linear ODEs with constant coefficients. For a single-input, single-output (SISO) LTI system, we typically write

\[ a_n \frac{d^n y(t)}{dt^n} + a_{n-1} \frac{d^{n-1} y(t)}{dt^{n-1}} + \cdots + a_1 \frac{dy(t)}{dt} + a_0 y(t) = \\ b_m \frac{d^m u(t)}{dt^m} + b_{m-1} \frac{d^{m-1} u(t)}{dt^{m-1}} + \cdots + b_1 \frac{du(t)}{dt} + b_0 u(t), \]

where \( u(t) \) is the input and \( y(t) \) is the output. Working directly in the time domain with derivatives is often cumbersome for analysis and design.

The transfer function is an algebraic object in the complex variable \( s \) that encodes the same linear dynamics, but in a form that is much easier to manipulate, connect in feedback, and later interpret in terms of stability and performance. Under appropriate conditions, we will derive

\[ G(s) \triangleq \frac{Y(s)}{U(s)} = \frac{b_m s^m + b_{m-1} s^{m-1} + \cdots + b_0} {a_n s^n + a_{n-1} s^{n-1} + \cdots + a_0}, \]

where \( U(s) \) and \( Y(s) \) are the Laplace transforms of \( u(t) \) and \( y(t) \). This object \( G(s) \) will be our central tool for the next several chapters.

flowchart TD
  A["Physical system (mechanical, electrical, etc.)"] --> B["Modeling: linear ODE with constant coefficients"]
  B --> C["Apply Laplace transform (zero initial conditions)"]
  C --> D["Algebraic relation: P(s) Y(s) = Q(s) U(s)"]
  D --> E["Define transfer function G(s) = Y(s)/U(s)"]
  E --> F["Use G(s) for analysis and later controller design"]
        

Recall the (unilateral) Laplace transform of a signal \( x(t) \), assumed to be of exponential order:

\[ X(s) = \mathcal{L}\{x(t)\}(s) = \int_0^{\infty} x(t)e^{-st}\,dt, \quad s \in \mathbb{C},\ \Re(s) \gt \sigma_0. \]

A key property you reviewed in Chapter 2 is the transform of derivatives. For a sufficiently smooth function \( y(t) \),

\[ \mathcal{L}\left\{\frac{d^k y(t)}{dt^k}\right\}(s) = s^k Y(s) - s^{k-1} y(0^-) - s^{k-2} y'(0^-) - \cdots - y^{(k-1)}(0^-), \]

where \( 0^- \) denotes the left limit at the origin. For control analysis, we almost always consider the response starting from a rest state, i.e., all initial conditions are zero:

\[ y(0^-) = y'(0^-) = \cdots = y^{(n-1)}(0^-) = 0. \]

Under this zero initial condition assumption, the derivative property simplifies to

\[ \mathcal{L}\left\{\frac{d^k y(t)}{dt^k}\right\}(s) = s^k Y(s). \]

The transfer function therefore captures the mapping from input to output for the forced response assuming the system starts from rest. Contributions from nonzero initial conditions can be treated separately (still using Laplace transforms), but they are not part of the transfer function.

Consider again the general nth-order SISO LTI ODE

\[ a_n \frac{d^n y(t)}{dt^n} + a_{n-1} \frac{d^{n-1} y(t)}{dt^{n-1}} + \cdots + a_1 \frac{dy(t)}{dt} + a_0 y(t) = \\ b_m \frac{d^m u(t)}{dt^m} + b_{m-1} \frac{d^{m-1} u(t)}{dt^{m-1}} + \cdots + b_1 \frac{du(t)}{dt} + b_0 u(t). \]

Apply the Laplace transform to both sides, under zero initial conditions. Using linearity and the derivative property we obtain

\[ a_n s^n Y(s) + a_{n-1} s^{n-1} Y(s) + \cdots + a_1 s Y(s) + a_0 Y(s) = \\ b_m s^m U(s) + b_{m-1} s^{m-1} U(s) + \cdots + b_1 s U(s) + b_0 U(s). \]

Factor out \( Y(s) \) and \( U(s) \):

\[ \underbrace{\left(a_n s^n + a_{n-1} s^{n-1} + \cdots + a_1 s + a_0\right)}_{P(s)} Y(s) = \underbrace{\left(b_m s^m + b_{m-1} s^{m-1} + \cdots + b_1 s + b_0\right)}_{Q(s)} U(s). \]

Assuming \( P(s) \neq 0 \) in the region of interest, we can write

\[ \frac{Y(s)}{U(s)} = \frac{Q(s)}{P(s)}. \]

This motivates the following definition.

Definition (Transfer Function). The transfer function of a causal LTI system is

\[ G(s) \triangleq \frac{Y(s)}{U(s)} \quad \text{under zero initial conditions}, \]

where \( Y(s) \) and \( U(s) \) are the Laplace transforms of the output and input, respectively. For ODE models with constant coefficients, \( G(s) \) is a rational function:

\[ G(s) = \frac{Q(s)}{P(s)} = \frac{b_m s^m + b_{m-1} s^{m-1} + \cdots + b_0} {a_n s^n + a_{n-1} s^{n-1} + \cdots + a_0}, \]

with real coefficients \( a_i, b_j \) determined by the physical parameters (mass, damping, resistance, etc.).

A useful terminology:

• Proper transfer function: \( m \leq n \).
• Strictly proper transfer function: \( m \lt n \).
• The relative degree is \( n - m \).

In most physical systems used for actuation in robotics, the transfer function is strictly proper: outputs cannot instantaneously react to changes in input.

For a causal LTI system, the impulse response \( g(t) \) is the output when the input is the Dirac delta \( \delta(t) \). A fundamental result (which you have seen in the context of convolution) is:

\[ y(t) = (g * u)(t) = \int_0^t g(t - \lambda)\,u(\lambda)\,d\lambda. \]

Taking the Laplace transform and using the convolution property,

\[ \mathcal{L}\{y(t)\}(s) = \mathcal{L}\{g * u\}(s) = \mathcal{L}\{g\}(s)\,\mathcal{L}\{u\}(s) = G(s) U(s), \]

so the transfer function is simply the Laplace transform of the impulse response:

\[ G(s) = \mathcal{L}\{g(t)\}(s). \]

Conversely, given \( G(s) \), the impulse response can be obtained (at least in principle) via the inverse Laplace transform:

\[ g(t) = \mathcal{L}^{-1}\{G(s)\}(t). \]

This duality between time-domain convolution and frequency-domain multiplication will later be essential when we analyze the time response of systems using only their transfer functions.

5.1 First-Order System (Typical Thermal or Simple RC Circuit)

Consider a first-order system described by

\[ T \frac{dy(t)}{dt} + y(t) = K u(t), \]

where \( T \gt 0 \) is a time constant and \( K \) is a static gain. Taking Laplace transforms with zero initial conditions:

\[ T s Y(s) + Y(s) = K U(s). \]

Factor \( Y(s) \):

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

This is a strictly proper transfer function of relative degree 1.

5.2 Mass–Spring–Damper System (Translational Mechanics)

Consider a standard mass–spring–damper system with mass \( m \), damping \( c \), stiffness \( k \), input force \( u(t) \), and output displacement \( y(t) \):

\[ m \frac{d^2 y(t)}{dt^2} + c \frac{dy(t)}{dt} + k y(t) = u(t). \]

Apply the Laplace transform (zero initial conditions):

\[ m s^2 Y(s) + c s Y(s) + k Y(s) = U(s). \]

Factor \( Y(s) \) and solve for the transfer function \( G(s) = Y(s)/U(s) \):

\[ (m s^2 + c s + k) Y(s) = U(s) \quad \Rightarrow \quad G(s) = \frac{1}{m s^2 + c s + k}. \]

The transfer function is strictly proper with relative degree \( 2 \). Later, we will study how the coefficients \( m, c, k \) influence the time response and stability.

5.3 DC Motor (Armature-Controlled, Speed Output)

In robotics, DC motors are widely used as actuators. An armature-controlled DC motor model (after linearization and combining electrical and mechanical dynamics) often leads to a second-order transfer function from input voltage \( u(t) \) to angular velocity \( \omega(t) \):

\[ G(s) = \frac{\Omega(s)}{U(s)} = \frac{K_t}{J L s^2 + (J R + b L) s + (b R + K_e K_t)}, \]

where \( J \) is rotor inertia, \( b \) viscous friction, \( R \) armature resistance, \( L \) inductance, \( K_t \) torque constant, and \( K_e \) back-EMF constant. This transfer function is the starting point for many robot joint control designs.

flowchart TD
  P["Physical parameters (m,c,k,J,R,L,...)"] --> ODE["Differential equation in y(t) and u(t)"]
  ODE --> LAPLACE["Apply Laplace transform (zero IC)"]
  LAPLACE --> ALG["Algebraic relation in Y(s), U(s)"]
  ALG --> G["Form transfer function G(s) = Y(s)/U(s)"]
  G --> TOOLS["Use G(s) in software tools (Python, C++, Java, MATLAB, Mathematica)"]
        

We now show how to encode a simple transfer function, for example \( G(s) = \dfrac{K}{T s + 1} \), in common programming environments. Such representations are often used as components in robotic simulation and control stacks.

6.1 Python (with python-control and Robotics Context)

The python-control library is widely used for control analysis and interfaces well with robotics packages (e.g. for modeling actuators in simulation). Example:

import control as ctl  # python-control library
import numpy as np

K = 2.0   # static gain
T = 0.5   # time constant

# Transfer function G(s) = K / (T s + 1)
num = [K]
den = [T, 1.0]
G = ctl.TransferFunction(num, den)
print("G(s) =", G)

# Example input: unit step response (relevant for servo motion in robotics)
t = np.linspace(0, 5, 500)
t, y = ctl.step_response(G, T=t)

# For robotic applications, this G(s) might approximate a DC motor speed loop
# in a simulation environment (e.g., within a ROS-based testbench).
      

6.2 C++ (Basic Transfer Function Class, Usable in ROS/robotics Nodes)

In C++ robotics software (e.g. ROS controllers), transfer functions can be implemented using standard containers and complex arithmetic.

#include <iostream>
#include <vector>
#include <complex>

class TransferFunction {
public:
    // G(s) = num(s) / den(s)
    std::vector<double> num;
    std::vector<double> den;

    TransferFunction(const std::vector<double>& n,
                     const std::vector<double>& d)
        : num(n), den(d) {}

    std::complex<double> eval(const std::complex<double>& s) const {
        std::complex<double> N(0.0, 0.0), D(0.0, 0.0);
        for (std::size_t i = 0; i < num.size(); ++i) {
            int p = static_cast<int>(num.size() - 1 - i);
            N += num[i] * std::pow(s, p);
        }
        for (std::size_t i = 0; i < den.size(); ++i) {
            int p = static_cast<int>(den.size() - 1 - i);
            D += den[i] * std::pow(s, p);
        }
        return N / D;
    }
};

int main() {
    double K = 2.0;
    double T = 0.5;

    std::vector<double> num{K};
    std::vector<double> den{T, 1.0};

    TransferFunction G(num, den);

    // Evaluate G(j*omega) at omega = 1 rad/s (for analysis)
    std::complex<double> s(0.0, 1.0);
    std::complex<double> Gjw = G.eval(s);

    std::cout << "G(j*1) = " << Gjw << std::endl;

    // In a robotics context, this class can be used inside a ROS node
    // to approximate continuous dynamics or to design simple controllers.
    return 0;
}
      

6.3 Java (Simple Transfer Function Class, Robotics-Style)

Java is used in some robotics frameworks (e.g. FRC’s WPILib ecosystem). A minimalistic transfer function representation can look like:

public class TransferFunction {
    // G(s) = num(s) / den(s)
    private double[] num;
    private double[] den;

    public TransferFunction(double[] num, double[] den) {
        this.num = num;
        this.den = den;
    }

    // Evaluate G(s) for complex s = sigma + j*omega
    public Complex eval(Complex s) {
        Complex N = Complex.ZERO;
        Complex D = Complex.ZERO;

        for (int i = 0; i < num.length; i++) {
            int p = num.length - 1 - i;
            N = N.add(s.pow(p).multiply(num[i]));
        }
        for (int i = 0; i < den.length; i++) {
            int p = den.length - 1 - i;
            D = D.add(s.pow(p).multiply(den[i]));
        }
        return N.divide(D);
    }

    public static void main(String[] args) {
        double K = 2.0;
        double T = 0.5;
        double[] num = {K};
        double[] den = {T, 1.0};

        TransferFunction G = new TransferFunction(num, den);
        Complex s = new Complex(0.0, 1.0); // j*1
        Complex Gjw = G.eval(s);
        System.out.println("G(j*1) = " + Gjw);
    }
}
      

In robotics-oriented Java libraries (such as those used in mobile robot simulators or education platforms), similar abstractions are used to build higher-level models of drivetrain or arm dynamics.

6.4 MATLAB/Simulink (Control System Toolbox)

MATLAB’s Control System Toolbox and Simulink are heavily used for modeling robotic actuators and plants.

K = 2.0;
T = 0.5;

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

% Step response (typical for servo systems)
figure;
step(G);
grid on;
title('Step response of first-order system');

% In Simulink, you would:
% 1. Create a new model.
% 2. Insert a Transfer Fcn block and set Numerator: [K], Denominator: [T 1].
% 3. Connect a Step block as input and a Scope block to visualize y(t).
      

6.5 Wolfram Mathematica

Mathematica has symbolic support for transfer functions via TransferFunctionModel:

K = 2.0;
T = 0.5;

(* Transfer function G(s) = K / (T s + 1) *)
G = TransferFunctionModel[ K/(T*s + 1), s ]

(* Compute impulse and step responses symbolically or numerically *)
g[t_] = InverseLaplaceTransform[K/(T*s + 1), s, t];
yStep[t_] = InverseLaplaceTransform[ (K/(T*s + 1))*(1/s), s, t];

(* For robotics applications, such symbolic forms can help
   derive closed-form expressions for actuator responses. *)
      

In this lesson, we systematically derived transfer functions from LTI differential equations using the Laplace transform under zero initial conditions. We showed that physical ODE models give rise to rational functions \( G(s) = Y(s)/U(s) \), and that these transfer functions are equivalent to the Laplace transforms of impulse responses. We worked through canonical examples, including first-order systems, mass–spring–damper dynamics, and a DC motor model relevant to robotic actuators. Finally, we illustrated how to encode transfer functions in several computational environments (Python, C++, Java, MATLAB/Simulink, and Mathematica), laying the foundation for later analysis and controller design based on transfer functions.