A block diagram is a directed interconnection of elementary operators acting on time signals. In this course (up to Chapter 7, Lesson 1), we restrict attention primarily to continuous-time LTI subsystems already introduced via convolution and transfer functions in Chapter 6.

A block diagram is not merely illustrative: it is a compact encoding of a set of equations that can be manipulated and simulated. Formally, each directed wire carries a signal \( x(t) \), and each block implements a mapping \( \mathcal{G} \) such that \( y(t) = (\mathcal{G}x)(t) \).

flowchart TD
  A["Physical laws / component relations"] --> B["Differential equation model"]
  B --> C["Laplace (assume zero initial conditions)"]
  C --> D["Transfer functions for subsystems"]
  D --> E["Choose interconnection (series/parallel/feedback)"]
  E --> F["Block diagram equations (internal signals)"]
  F --> G["Analysis and simulation"]
        

In this lesson we make the “block diagram equations” step precise, including the role of internal signals and the conditions under which a single transfer function summarizes the full input–output behavior.

Let \( \mathcal{S} \) denote a vector space of admissible real-valued signals (e.g., piecewise continuous signals of exponential order so that Laplace transforms exist, as in Chapter 2). A block is an operator \( \mathcal{G}: \mathcal{S} \to \mathcal{S} \). A wire carries an element of \( \mathcal{S} \).

A summing junction defines an algebraic constraint among incident signals. If signals \( x_1(t),\dots,x_m(t) \) enter a sum and the output is \( y(t) \) with signs \( \sigma_i \in \{+1,-1\} \), then:

\[ y(t) = \sum_{i=1}^{m} \sigma_i x_i(t). \]

A branching (pick-off) point encodes equality constraints: if a signal \( x(t) \) splits into multiple outgoing wires, then all outgoing signals are identical to the incoming one.

\[ x_{\text{out},1}(t) = x_{\text{out},2}(t) = \cdots = x_{\text{in}}(t). \]

Therefore, a complete block diagram can be translated into a finite set of operator equations in the unknown internal signals. Solving these equations yields the overall input–output map.

For a continuous-time LTI block, there exists an impulse response \( g(t) \) such that the output is the convolution of the input \( u(t) \) with \( g(t) \):

\[ y(t) = (g * u)(t) = \int_{0}^{t} g(t-\tau)\,u(\tau)\,d\tau. \]

Under the Laplace transform with zero initial conditions (the convention used when defining transfer functions from ODEs in Chapter 6), the convolution becomes multiplication:

\[ Y(s) = G(s)\,U(s), \quad G(s) = \mathcal{L}\{g(t)\}. \]

We interpret a single transfer-function block \( G(s) \) as the LTI operator that satisfies \( Y(s)=G(s)U(s) \) (zero initial conditions). In the time domain, that same block is equivalently the convolution operator induced by \( g(t) \).

Remark (why “zero initial conditions” matters). If an ODE has nonzero initial conditions, then \( Y(s) \) generally has additional terms independent of \( U(s) \). Transfer functions isolate the forced response; block diagrams can still represent nonzero initial conditions, but require additional inputs or initial state variables (treated carefully in Chapter 8).

Because a block diagram is a system of equations, interconnecting blocks corresponds to composing and coupling operators. For LTI transfer-function blocks, these interconnections produce algebraic identities. The next three results are the backbone of block-diagram reasoning.

4.1 Series connection

Consider two LTI blocks with transfer functions \( G_1(s) \) and \( G_2(s) \) connected in series: \( u \) enters \( G_1 \), its output enters \( G_2 \), producing \( y \).

\[ X(s) = G_1(s)U(s), \qquad Y(s) = G_2(s)X(s). \]

Theorem (series product): The overall transfer function is \( G_{\text{ser}}(s)=G_2(s)G_1(s) \).

Proof: Substitute \( X(s) \) into \( Y(s) \): \( Y(s)=G_2(s)\,G_1(s)\,U(s) \). Hence \( G_{\text{ser}}(s)=Y(s)/U(s)=G_2(s)G_1(s) \). □

4.2 Parallel connection

Consider two blocks driven by the same input \( u \), with outputs summed:

\[ Y(s) = G_1(s)U(s) + G_2(s)U(s). \]

Theorem (parallel sum): The equivalent transfer function is \( G_{\text{par}}(s)=G_1(s)+G_2(s) \).

Proof: Factor \( U(s) \): \( Y(s) = (G_1(s)+G_2(s))U(s) \). Thus \( G_{\text{par}}(s)=Y(s)/U(s)=G_1(s)+G_2(s) \). □

4.3 Negative feedback connection

Consider the standard single-loop negative feedback configuration with forward block \( G(s) \) and feedback block \( H(s) \). Let the reference input be \( R(s) \), the error signal be \( E(s) \), and the output be \( Y(s) \).

\[ E(s) = R(s) - H(s)Y(s), \qquad Y(s) = G(s)E(s). \]

Theorem (closed-loop transfer function): If \( 1 + G(s)H(s) \neq 0 \), then

\[ \frac{Y(s)}{R(s)} = \frac{G(s)}{1 + G(s)H(s)}. \]

Proof: Substitute \( E(s) \) into \( Y(s) \): \( Y(s) = G(s)\big(R(s)-H(s)Y(s)\big) \), hence \( Y(s) + G(s)H(s)Y(s) = G(s)R(s) \). Factor \( Y(s) \):

\[ \big(1 + G(s)H(s)\big)Y(s) = G(s)R(s). \]

If \( 1 + G(s)H(s) \neq 0 \), divide both sides to obtain the result. □

Interpretation: The block diagram encodes a coupled algebraic system in the transform domain. The “feedback denominator” \( 1+G(s)H(s) \) arises from eliminating the internal signal \( E(s) \). In time domain, the same elimination corresponds to solving an operator equation.

We now translate a familiar model from earlier chapters into a block diagram. Consider the mass–spring–damper equation (Chapter 3) with external force input \( f(t) \) and displacement output \( x(t) \):

\[ m\,\ddot{x}(t) + c\,\dot{x}(t) + k\,x(t) = f(t), \qquad m > 0,\; c \ge 0,\; k > 0. \]

Solving for acceleration gives an explicit “computational form”:

\[ \ddot{x}(t) = \frac{1}{m}\Big(f(t) - c\,\dot{x}(t) - k\,x(t)\Big). \]

Introduce two integrator relations (pure calculus, no state-space machinery required):

\[ \dot{x}(t) = \int \ddot{x}(t)\,dt, \qquad x(t) = \int \dot{x}(t)\,dt. \]

This directly yields a block diagram with (i) one summing junction to form \( f - c\dot{x} - kx \), (ii) a gain \( 1/m \), and (iii) two cascaded integrators.

flowchart TD
  F["f(t)"] --> S["sum: f - c*v - k*x"]
  X["x(t)"] --> K["gain: -k"] --> S
  V["v(t)=dx/dt"] --> C["gain: -c"] --> S
  S --> M["gain: 1/m"] --> A["a(t)=d2x/dt2"]
  A --> I1["integrator: 1/s"] --> V
  V --> I2["integrator: 1/s"] --> X
        

Consistency check via transfer functions (zero initial conditions). Taking Laplace transforms:

\[ \big(ms^2 + cs + k\big)X(s) = F(s) \quad \Longrightarrow \quad \frac{X(s)}{F(s)} = \frac{1}{ms^2 + cs + k}. \]

The integrator realization is therefore an exact block-diagram representation of the same input–output behavior, while also making internal signals \( \dot{x}(t) \) and \( \ddot{x}(t) \) explicit.

A block diagram defines equations among internal signals. For the diagram to represent a physically meaningful dynamic system, those equations should be well-posed (admit a unique solution for internal signals given inputs and initial conditions). A common pathology is an algebraic loop where an output depends instantaneously on itself without dynamic elements.

In the Laplace-domain (transfer-function) setting with proper rational functions, well-posedness is linked to the existence of inverse operators such as \( (1+G(s)H(s))^{-1} \) in Section 4.3.

Properness (review from Chapter 6, realizability intuition). A rational transfer function \( G(s)=\frac{N(s)}{D(s)} \) is:

• proper if \( \deg N(s) \le \deg D(s) \),
• strictly proper if \( \deg N(s) < \deg D(s) \).

Strictly proper blocks naturally correspond to systems with at least one integrator-like dynamic element; they tend to avoid instantaneous algebraic dependence. In contrast, non-proper transfer functions correspond to differentiation or anticipatory behavior, which typically requires idealized components and can complicate block-level realizations.

A useful mental model is that each block diagram is a “network” of operators. Whenever a loop contains at least one strictly proper transfer function, the loop tends to be dynamically well-defined; purely static loops require special care (addressed more directly in Chapter 15 when we discuss simulation issues).

For mapping intuition inside formulas, one may view an operator as:

\[ u(t)\; \text{→}\; y(t) \quad \text{via the rule } y = \mathcal{G}u. \]

We implement a standard block-diagram interconnection: unity negative feedback with a proportional gain \( K \) and a first-order plant \( G(s)=\frac{1}{s+1} \). This is a direct computational counterpart to Section 4.3.

Relevant libraries: control (python-control), scipy, numpy.

import numpy as np

# Transfer-function approach (block-level algebra)
# Requires: pip install control
import control as ctl

s = ctl.TransferFunction.s
G = 1/(s + 1)          # plant block
K = 5.0                # proportional controller block
H = 1                  # unity feedback sensor block

# Closed-loop from R to Y: (K*G) / (1 + K*G*H)
T = ctl.feedback(K*G, H)

t = np.linspace(0, 10, 1000)
t, y = ctl.step_response(T, T=t)

# Basic summary statistics
y_final = y[-1]
y_peak = np.max(y)
print("Final value:", float(y_final))
print("Peak value:", float(y_peak))

# Time-domain simulation "from scratch" of the block equations:
# Plant: dy/dt = -y + u
# Controller: u = K*(r - y)
# Reference: step r(t)=1
dt = 1e-3
Tend = 5.0
N = int(Tend/dt)
y2 = 0.0
ys = []
ts = []
for k in range(N):
    t_k = k*dt
    r = 1.0
    e = r - y2
    u = K*e
    dy = (-y2 + u)      # dy/dt
    y2 = y2 + dt*dy     # forward Euler step (numerical basics from Chapter 2)
    ts.append(t_k)
    ys.append(y2)

print("Final value (Euler sim):", ys[-1])
      

The first part manipulates blocks exactly (transfer-function algebra). The second part simulates the same block diagram by explicitly updating the internal signals using a simple numerical scheme.

In C++, we simulate the same unity-feedback block diagram by directly encoding the signal equations and integrating the plant ODE \( \dot{y}(t) = -y(t) + u(t) \). This is “block-diagram execution” in the time domain.

Relevant libraries: standard C++ (from-scratch). For more advanced work later: Eigen (linear algebra), Boost.Odeint (ODE solvers).

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

int main() {
    const double K = 5.0;     // controller gain
    const double dt = 1e-3;
    const double Tend = 5.0;
    const int N = static_cast<int>(Tend / dt);

    double y = 0.0;           // plant output
    std::vector<double> ys;
    ys.reserve(N);

    for (int k = 0; k < N; ++k) {
        const double r = 1.0;          // unit-step reference
        const double e = r - y;        // summing junction: e = r - y
        const double u = K * e;        // controller block
        const double dy = (-y + u);    // plant ODE: dy/dt = -y + u
        y = y + dt * dy;               // Euler integration step
        ys.push_back(y);
    }

    std::cout << "Final value: " << ys.back() << std::endl;
    return 0;
}
      

This code mirrors the block diagram equations one-to-one: the summing junction computes \( e \), the controller computes \( u \), and the plant block advances \( y \).

Java implementation follows the same structure. This is intentionally “low-level” to emphasize how block diagrams translate into explicit update rules.

Relevant libraries: from-scratch; for later extensions: Apache Commons Math (numerics), EJML (linear algebra).

public class BlockDiagramSim {
    public static void main(String[] args) {
        double K = 5.0;
        double dt = 1e-3;
        double Tend = 5.0;
        int N = (int)(Tend / dt);

        double y = 0.0;

        for (int k = 0; k < N; k++) {
            double r = 1.0;          // step reference
            double e = r - y;        // sum: e = r - y
            double u = K * e;        // controller
            double dy = (-y + u);    // plant: dy/dt = -y + u
            y = y + dt * dy;         // Euler step
        }

        System.out.println("Final value: " + y);
    }
}
      

MATLAB supports transfer-function blocks natively and provides direct functions for feedback interconnections. Simulink provides a graphical block diagram environment whose execution corresponds to the internal-signal equations.

Relevant toolboxes: Control System Toolbox, Simulink.

10.1 MATLAB (transfer function + feedback)

% Define Laplace variable and plant
s = tf('s');
G = 1/(s + 1);

% Controller gain
K = 5;

% Closed-loop with unity negative feedback
T = feedback(K*G, 1);

% Step response
step(T);
grid on;
title('Closed-loop step response: (K*G)/(1+K*G)');
      

10.2 Simulink (programmatically build a block diagram)

The script below creates a Simulink model with Step → Sum → Gain(K) → Transfer Fcn(1/(s+1)) and unity feedback.

modelName = 'ch7_l1_unity_feedback';
new_system(modelName);
open_system(modelName);

% Blocks
add_block('simulink/Sources/Step', [modelName '/Step']);
add_block('simulink/Math Operations/Sum', [modelName '/Sum']);
add_block('simulink/Math Operations/Gain', [modelName '/GainK']);
add_block('simulink/Continuous/Transfer Fcn', [modelName '/Plant']);
add_block('simulink/Sinks/Scope', [modelName '/Scope']);

% Configure blocks
set_param([modelName '/Sum'], 'Inputs', '+-');      % e = r - y
set_param([modelName '/GainK'], 'Gain', '5');
set_param([modelName '/Plant'], 'Numerator', '1', 'Denominator', '[1 1]'); % 1/(s+1)

% Wiring
add_line(modelName, 'Step/1', 'Sum/1');
add_line(modelName, 'Sum/1', 'GainK/1');
add_line(modelName, 'GainK/1', 'Plant/1');
add_line(modelName, 'Plant/1', 'Scope/1');
add_line(modelName, 'Plant/1', 'Sum/2');           % feedback

% Simulation settings
set_param(modelName, 'StopTime', '5');

% Run
sim(modelName);
      

This model is the literal graphical counterpart of the equations in Section 4.3.

Mathematica provides transfer-function objects and feedback interconnection utilities.

(* Define the plant G(s) = 1/(s+1) and proportional gain K *)
G = TransferFunctionModel[ {1}, {1, 1}, s ];
K = 5;

(* Closed-loop T(s) = (K G)/(1 + K G) with unity negative feedback *)
T = SystemsModelFeedbackConnect[ K G, 1 ];

(* Step response over [0, 10] *)
OutputResponse[T, UnitStep[t], {t, 0, 10}]
      

The object T is the block-diagram closed-loop map from reference input to output.

The problems below reinforce how block diagrams encode equations and how transfer-function identities follow from eliminating internal signals.

Problem 1 (Integrator realization of a second-order ODE): Consider the ODE \( \ddot{y}(t) + 3\dot{y}(t) + 2y(t) = u(t) \). Write it in the form \( \ddot{y}(t) = \alpha u(t) + \beta \dot{y}(t) + \gamma y(t) \) and specify the corresponding integrator-based block-diagram equations (signals and gains).

Solution: Solve for \( \ddot{y}(t) \):

\[ \ddot{y}(t) = u(t) - 3\dot{y}(t) - 2y(t). \]

Introduce internal signals \( v(t)=\dot{y}(t) \) and \( a(t)=\ddot{y}(t) \). Then:

\[ a(t) = u(t) - 3v(t) - 2y(t), \qquad v(t) = \int a(t)\,dt, \qquad y(t) = \int v(t)\,dt. \]

This is exactly the integrator chain with a summing junction forming \( u - 3v - 2y \).

Problem 2 (Transfer function consistency): For the same system in Problem 1, compute the transfer function \( G(s)=Y(s)/U(s) \) under zero initial conditions.

Solution: Laplace transform gives:

\[ (s^2 + 3s + 2)Y(s) = U(s) \quad \Longrightarrow \quad G(s)=\frac{Y(s)}{U(s)}=\frac{1}{s^2 + 3s + 2}. \]

Problem 3 (Internal-signal elimination in feedback): A feedback loop is defined by \( E(s)=R(s)-H(s)Y(s) \) and \( Y(s)=G(s)E(s) \). Eliminate \( E(s) \) and solve for \( Y(s)/R(s) \).

Solution: Substitute \( E(s) \):

\[ Y(s)=G(s)\big(R(s)-H(s)Y(s)\big) \;\Longrightarrow\; (1+G(s)H(s))Y(s)=G(s)R(s) \;\Longrightarrow\; \\ \frac{Y(s)}{R(s)}=\frac{G(s)}{1+G(s)H(s)}. \]

Problem 4 (Parallel interconnection with signs): Two blocks satisfy \( Y_1(s)=G_1(s)U(s) \) and \( Y_2(s)=G_2(s)U(s) \). The output is formed as \( Y(s)=Y_1(s)-Y_2(s) \). Find the equivalent transfer function.

Solution:

\[ Y(s)=\big(G_1(s) - G_2(s)\big)U(s) \quad \Longrightarrow \quad \frac{Y(s)}{U(s)}=G_1(s)-G_2(s). \]

Problem 5 (Block diagram as equations): Consider internal signals defined by \( x(t)=u(t)+y(t) \) and \( y(t)=(\mathcal{G}x)(t) \), where \( \mathcal{G} \) is an LTI operator with transfer function \( G(s) \). Derive the overall transfer function from \( u \) to \( y \) under zero initial conditions.

Solution: Take Laplace transforms:

\[ X(s)=U(s)+Y(s), \qquad Y(s)=G(s)X(s). \]

Substitute \( X(s) \): \( Y(s)=G(s)\big(U(s)+Y(s)\big) \), hence \( (1-G(s))Y(s)=G(s)U(s) \). If \( 1-G(s)\neq 0 \), then:

\[ \frac{Y(s)}{U(s)} = \frac{G(s)}{1-G(s)}. \]

This illustrates that “solving a block diagram” is algebraic elimination of internal signals in the transform domain.

We defined block diagrams as equation-level operator interconnections, established rigorous semantics for blocks and junctions, and proved the fundamental transfer-function identities for series, parallel, and negative feedback configurations under the zero-initial-condition convention. We also constructed an integrator-based realization of a second-order mechanical ODE and implemented block-diagram interconnections across Python, C++, Java, MATLAB/Simulink, and Wolfram Mathematica.

In Lesson 2, we will develop systematic block diagram algebra and reduction techniques, formalizing when and how complex diagrams can be collapsed into simpler equivalent representations.