Introduction to Cyber-Physical Systems

What Is a Cyber-Physical System?

A cyber-physical system (CPS) is an integration of computation, networking, and physical processes. Embedded computers measure a physical process, decide what to do, and act on it, usually in a feedback loop where the physical process affects the computation and the computation affects the physical process.

A car's brake controller, an insulin pump, a power substation, and a robotic arm on an assembly line are all CPS. What they share is not a technology but a problem: the software is only correct if the physical outcome is correct, and the physical outcome depends on when the software acts, not just what it computes.

Anatomy of a CPS

Almost every CPS can be decomposed into the same six building blocks. Learning to identify them is the first step in analyzing any system.

Every step takes time, and the plant does not wait. The interval between sensing and actuating, called the sensor-to-actuator latency, is a design parameter with direct physical consequences.

CPS and Related Terms

Several overlapping terms describe parts of the same landscape. They emphasize different things.

Key Concepts

These ideas recur throughout the rest of the series. Each one is a place where traditional computing assumptions break down.

Example: A Sampled Thermostat as a Hybrid System

A thermostat is the simplest complete CPS. The room temperature evolves continuously according to Newton's law of cooling. The controller is a two-state machine (heater on, heater off) with hysteresis: it switches on below the setpoint minus a band and off above the setpoint plus the band, which prevents rapid toggling.

The twist is that the controller only samples the temperature every ts seconds. Between samples the plant keeps evolving. The simulation below integrates the continuous dynamics with a small step dt and runs the discrete controller at the slower sampling period.

def simulate(t_end=3600.0, dt=0.1, ts=10.0, setpoint=21.0, band=0.5):
    ambient, k, heat = 10.0, 0.0012, 0.03
    temp, heater, t, next_sample = 15.0, False, 0.0, 0.0
    log, switches = [], 0
    while t < t_end:
        if t >= next_sample:
            reading = temp
            if heater and reading >= setpoint + band:
                heater, switches = False, switches + 1
            elif not heater and reading <= setpoint - band:
                heater, switches = True, switches + 1
            next_sample += ts
        dtemp = -k * (temp - ambient) + (heat if heater else 0.0)
        temp += dtemp * dt
        t += dt
        log.append(temp)
    settled = log[len(log) // 2:]
    return switches, min(settled), max(settled)

for ts in (1.0, 10.0, 60.0):
    n, lo, hi = simulate(ts=ts)
    print(f'sample period {ts:5.1f} s  switches {n:3d}  range {lo:5.2f} to {hi:5.2f} C')

Output:

sample period   1.0 s  switches  49  range 20.49 to 21.51 C
sample period  10.0 s  switches  43  range 20.38 to 21.62 C
sample period  60.0 s  switches  25  range 19.91 to 22.31 C

Example: When Delay Destabilizes Control

Consider an unstable plant dx/dt = a·x + b·u with a = 1, like an inverted pendulum near upright. A proportional controller u = -K·x with K = 2 stabilizes it in continuous time. On a computer, the controller samples every h seconds and holds its output constant between samples (zero-order hold), which turns the plant into a discrete-time system x[k+1] = a_d·x[k] + b_d·u[k].

If computation and communication take one full sample period, the control applied at step k was computed from x[k-1]. The code below compares the closed loop with and without that one-sample delay. The system is stable when the largest eigenvalue magnitude (spectral radius) is below 1.

import numpy as np

a, b, gain = 1.0, 1.0, 2.0

def closed_loop(h, delayed):
    ad = np.exp(a * h)
    bd = (ad - 1.0) / a * b
    if delayed:
        m = np.array([[ad, -bd * gain], [1.0, 0.0]])
    else:
        m = np.array([[ad - bd * gain]])
    return max(abs(np.linalg.eigvals(m)))

for h in (0.05, 0.2, 0.5, 0.8, 1.0):
    r0 = closed_loop(h, False)
    r1 = closed_loop(h, True)
    s0 = 'stable' if r0 < 1 else 'unstable'
    s1 = 'stable' if r1 < 1 else 'unstable'
    print(f'h={h:4.2f}  no delay: {r0:5.3f} {s0:8s}  one-sample delay: {r1:5.3f} {s1}')

Output:

h=0.05  no delay: 0.949 stable    one-sample delay: 0.942 stable
h=0.20  no delay: 0.779 stable    one-sample delay: 0.665 stable
h=0.50  no delay: 0.351 stable    one-sample delay: 1.139 unstable
h=0.80  no delay: 0.226 stable    one-sample delay: 1.566 unstable
h=1.00  no delay: 0.718 stable    one-sample delay: 1.854 unstable

Application Domains

CPS appear wherever computers act on the physical world. A few domains dominate research and practice, and each has its own constraints.

Cross-Cutting Challenges

The Series

Primary Reference

Chapters most relevant to each part of this series:

Tutorials, Tools, and Interactive Learning

Further Reading