Cruise control aims to maintain a desired vehicle longitudinal speed \( v(t) \) despite disturbances such as road grade and aerodynamic drag. The driver specifies a reference speed \( r(t) \) (e.g., 100 km/h), and a feedback controller manipulates throttle to keep the tracking error \( e(t) = r(t) - v(t) \) close to zero. We restrict attention to a single-input single-output (SISO) linear time-invariant model of longitudinal dynamics.

Classical cruise control loops are typically implemented with proportional-integral-derivative (PID) structures tested in Chapters 11–12. In this case study we:

• Derive a first-order LTI model of the vehicle longitudinal motion around a constant cruising speed.
• Form the closed-loop transfer function with proportional (P) and proportional-integral (PI) controllers.
• Design PI gains to satisfy transient specifications (overshoot, settling time) and zero steady-state error.
• Interpret the design in the frequency domain using loop gain and bandwidth concepts from earlier chapters.

flowchart TD
  R["Reference speed r(t)"] --> E["Error e(t) = r(t) - v(t)"]
  E --> C["Controller C(s) (P or PI)"]
  C --> U["Throttle / engine input u(t)"]
  U --> P["Vehicle dynamics G(s)"]
  P --> Y["Vehicle speed v(t)"]
  Y -->|"feedback"| E
        

The diagram summarizes the unity-feedback structure studied extensively in earlier chapters: the plant transfer function \( G(s) \) represents vehicle dynamics, while the controller \( C(s) \) shapes closed-loop poles and steady-state accuracy.

Consider a simplified longitudinal model for a vehicle of mass \( m \). Let \( v(t) \) be the forward velocity, \( u(t) \) the traction force generated by the powertrain (assumed approximately proportional to throttle command near the operating point), and \( F_r(v) \) the aggregate resistance force (rolling resistance, drag, small road grade). The mechanical balance is

\[ m \frac{dv(t)}{dt} = u(t) - F_r\bigl(v(t)\bigr). \]

For cruising around a nominal speed \( v_0 \), we linearize \( F_r(v) \) as \( F_r(v) \approx F_r(v_0) + b\,(v(t)-v_0) \) with \( b > 0 \) an effective viscous damping coefficient. Let \( \Delta v(t) = v(t)-v_0 \), \( \Delta u(t) = u(t)-u_0 \) where \( u_0 = F_r(v_0) \) corresponds to constant-speed equilibrium. The linearized dynamics become

\[ m \frac{d\Delta v(t)}{dt} = \Delta u(t) - b\,\Delta v(t), \]

or equivalently

\[ m \frac{d\Delta v(t)}{dt} + b\,\Delta v(t) = \Delta u(t). \]

Taking Laplace transforms with zero initial condition gives

\[ m s \Delta V(s) + b \Delta V(s) = \Delta U(s) \quad \Rightarrow \quad \Delta V(s) = \frac{1}{m s + b} \Delta U(s). \]

Hence the plant transfer function from force input to speed output is

\[ G_F(s) = \frac{\Delta V(s)}{\Delta U(s)} = \frac{1}{m s + b}. \]

In practice, the controller acts on throttle or torque command \( w(t) \) rather than force directly. If the engine and drivetrain near \( v_0 \) can be approximated by a static gain \( K_u \) so that \( \Delta u(t) \approx K_u\, w(t) \), then the plant from control input \( w(t) \) to speed becomes

\[ G(s) = \frac{\Delta V(s)}{W(s)} = \frac{K_u}{m s + b}. \]

This is a standard first-order plant with time constant \( \tau = \dfrac{m}{b} \) and DC gain \( G(0) = \dfrac{K_u}{b} \), concepts already studied in Chapters 5–6.

We first analyze a proportional controller \( C(s) = K_p \). With unity feedback and reference \( R(s) \), the closed-loop transfer function from reference speed to vehicle speed is

\[ T_p(s) = \frac{V(s)}{R(s)} = \frac{C(s)G(s)}{1 + C(s)G(s)} = \frac{K_p \dfrac{K_u}{m s + b}}{1 + K_p \dfrac{K_u}{m s + b}} = \frac{K_p K_u}{m s + b + K_p K_u}. \]

Thus, the closed-loop pole is at

\[ s_p = -\frac{b + K_p K_u}{m}. \]

Since \( m > 0 \), \( b > 0 \), and \( K_u > 0 \), any \( K_p > - b/K_u \) yields \( s_p < 0 \) and a stable closed-loop. For \( K_p > 0 \), increasing \( K_p \) moves the pole left along the real axis, reducing the time constant and producing faster transient response.

Let the driver command a step in reference speed of magnitude \( V_{\text{ref}} \), so \( r(t) = V_{\text{ref}}\,u(t) \) and \( R(s) = \dfrac{V_{\text{ref}}}{s} \). The steady-state speed is found via the final value theorem:

\[ v_{\text{ss}} = \lim_{t → \infty} v(t) = \lim_{s \rightarrow 0} s V(s) = \lim_{s \rightarrow 0} s\, T_p(s) R(s) = \lim_{s \rightarrow 0} s \frac{K_p K_u}{m s + b + K_p K_u} \cdot \frac{V_{\text{ref}}}{s} = \frac{K_p K_u}{b + K_p K_u} V_{\text{ref}} \]

The steady-state error \( e_{\text{ss}} = V_{\text{ref}} - v_{\text{ss}} \) is therefore

\[ e_{\text{ss}} = V_{\text{ref}} - \frac{K_p K_u}{b + K_p K_u} V_{\text{ref}} = \frac{b}{b + K_p K_u} V_{\text{ref}}. \]

For any finite \( K_p \), this error is nonzero. Increasing \( K_p \) reduces \( e_{\text{ss}} \) but at the cost of higher control effort and potential sensitivity to unmodeled dynamics. To guarantee zero steady-state error to a step in reference speed (Type 1 closed-loop), we must introduce integral action, as in Chapters 8 and 11.

We now consider a proportional-integral controller \( C(s) = K_p + \dfrac{K_i}{s} \). The loop transfer function is

\[ L(s) = C(s)G(s) = \left(K_p + \frac{K_i}{s}\right) \frac{K_u}{m s + b} = \frac{K_u (K_p s + K_i)}{s (m s + b)}. \]

The closed-loop characteristic equation with unity feedback is \( 1 + L(s) = 0 \), i.e.,

\[ 1 + \frac{K_u (K_p s + K_i)}{s (m s + b)} = 0 \quad \Rightarrow \quad s (m s + b) + K_u (K_p s + K_i) = 0. \]

Expanding yields

\[ m s^2 + (b + K_u K_p) s + K_u K_i = 0. \]

Dividing by \( m \) we obtain a normalized second-order characteristic polynomial

\[ s^2 + \frac{b + K_u K_p}{m} s + \frac{K_u K_i}{m} = 0. \]

We now match this to the standard second-order form (Chapter 6)

\[ s^2 + 2 \zeta \omega_n s + \omega_n^2 = 0, \]

where \( \zeta \) is the damping ratio and \( \omega_n \) the natural frequency. Equating coefficients gives

\[ 2 \zeta \omega_n = \frac{b + K_u K_p}{m}, \qquad \omega_n^2 = \frac{K_u K_i}{m}. \]

Hence the controller parameters can be expressed as

\[ K_p = \frac{2 \zeta \omega_n m - b}{K_u}, \qquad K_i = \frac{\omega_n^2 m}{K_u}. \]

The design procedure is:

1. Choose maximum overshoot \( M_p \). From Chapter 6, solve for damping ratio \( \zeta \) via \( M_p = e^{-\pi \zeta / \sqrt{1-\zeta^2}} \) for \( 0 < \zeta < 1 \).
2. Choose desired 2 % settling time \( T_s \). For a second-order system, \( T_s \approx \dfrac{4}{\zeta \omega_n} \); thus \( \omega_n \approx \dfrac{4}{\zeta T_s} \).
3. Insert \( \zeta \) and \( \omega_n \) into the formulas for \( K_p \) and \( K_i \).

Because a PI controller introduces an integrator in the loop, the closed-loop system becomes Type 1. Therefore, for a step in reference speed, the steady-state error is zero (Chapter 8) provided the closed-loop is stable.

From Chapters 13–18, we know that low-frequency loop gain controls tracking and disturbance rejection, while high-frequency behavior affects noise amplification and robustness to unmodeled dynamics. With PI control, the loop transfer function is

\[ L(s) = \frac{K_u (K_p s + K_i)}{s (m s + b)}. \]

At low frequencies (\( s = j\omega \) with \( \omega \to 0 \)), the dominant term is the integrator:

\[ |L(j\omega)| \approx \frac{K_u K_i}{\omega b}, \quad \omega \to 0, \]

so the magnitude tends to infinity as \( \omega \to 0 \), enforcing zero steady-state error for step inputs. At mid frequencies, the proportional term \( K_p \) and plant dynamics shape the bandwidth; the approximate closed-loop bandwidth \( \omega_b \) is often of the same order as \( \omega_n \) chosen in Section 4.

Stability margins can be assessed from the Bode plot of \( L(j\omega) \): gain margin, phase margin, and delay margin (Chapters 17–18). In practice, one may adjust \( K_p \) and \( K_i \) slightly from the nominal pole-placement values to trade off:

• larger phase margin (more damping, reduced overshoot),
• robustness against parametric variations in \( m \) and \( b \),
• reduced sensitivity to higher-order engine dynamics not captured in the model.

We now implement cruise control design in Python using the python-control library for LTI models, together with numpy and matplotlib for numerical computation and plotting. The code below constructs the plant \( G(s) \), designs a PI controller via pole placement, and simulates the step response for a reference speed change.

import numpy as np
import matplotlib.pyplot as plt
import control as ct  # pip install control

# Physical parameters (example)
m = 1000.0   # kg
b = 50.0     # N*s/m (effective drag)
Ku = 500.0   # N per unit control input (normalized throttle)

# Desired specs
Mp = 0.1       # max overshoot <= 10%
Ts = 5.0       # 2% settling time around 5 s

# Compute zeta from Mp (approximate inverse of Mp-zeta relation)
# Here we choose a typical damping ratio for 10% overshoot:
zeta = 0.6

# Natural frequency from settling time formula Ts ≈ 4/(zeta*wn)
wn = 4.0 / (zeta * Ts)

# PI gains from section 4 formulas
Kp = (2.0 * zeta * wn * m - b) / Ku
Ki = (wn**2 * m) / Ku

print("PI gains:")
print("Kp =", Kp)
print("Ki =", Ki)

# Define plant G(s) = Ku / (m s + b)
numG = [Ku]
denG = [m, b]
G = ct.TransferFunction(numG, denG)

# Controller C(s) = Kp + Ki/s
C = ct.TransferFunction([Kp, Ki], [1, 0])

# Closed-loop transfer function from reference to speed
T = ct.feedback(C * G, 1)

# Step response for a step in reference speed (1 m/s step)
t = np.linspace(0, 20, 1000)
t, y = ct.step_response(T, t)

plt.figure()
plt.plot(t, y)
plt.axhline(1.0, linestyle="--")
plt.xlabel("Time [s]")
plt.ylabel("Speed [m/s]")
plt.title("Cruise Control: Closed-Loop Step Response (PI)")
plt.grid(True)
plt.show()
      

Students can experiment with m, b, and Ku to explore robustness to parameter variations and observe changes in overshoot and settling time.

The following C++ code simulates the continuous-time vehicle model with a discrete-time PI controller using forward Euler integration. For simplicity, we use a fixed time step \( h \) and approximate \( \dfrac{dv}{dt} \approx \dfrac{v_{k+1} - v_k}{h} \).

#include <iostream>
#include <vector>

int main() {
    // Physical parameters
    double m  = 1000.0;   // kg
    double b  = 50.0;     // N*s/m
    double Ku = 500.0;    // N per control unit

    // PI gains (for example, from Python design)
    double Kp = 0.8;
    double Ki = 0.4;

    // Simulation parameters
    double h   = 0.01;   // time step [s]
    double T   = 20.0;   // total simulation time [s]
    int    N   = static_cast<int>(T / h);

    // Reference speed (step)
    double v_ref = 10.0; // m/s

    // State variables
    double v  = 0.0;     // current speed
    double ei = 0.0;     // integral of error

    std::vector<double> time;
    std::vector<double> v_hist;

    for (int k = 0; k <= N; ++k) {
        double t = k * h;
        double e = v_ref - v;
        ei += e * h;  // integrate error

        // PI controller
        double u_ctrl = Kp * e + Ki * ei;  // control signal (normalized)

        // Plant dynamics: m dv/dt = Ku*u_ctrl - b*v
        double dv = (Ku * u_ctrl - b * v) / m;

        // Euler integration
        v += dv * h;

        time.push_back(t);
        v_hist.push_back(v);
    }

    // Print some samples
    for (size_t i = 0; i < time.size(); i += 200) {
        std::cout << "t = " << time[i]
                  << " s, v = " << v_hist[i] << " m/s" << std::endl;
    }

    return 0;
}
      

This simple numerical simulation illustrates how continuous-time design is implemented as a discrete-time algorithm in an embedded controller, albeit without explicit discretization theory (which is deferred to more advanced courses).

In Java, an object-oriented design can encapsulate the controller and plant. The snippet below provides a minimal simulation framework with a discrete-time PI controller acting on the first-order vehicle model.

public class CruiseControlSimulation {

    static class Vehicle {
        double m;   // mass
        double b;   // drag coefficient
        double Ku;  // engine gain
        double v;   // speed state

        Vehicle(double m, double b, double Ku) {
            this.m = m;
            this.b = b;
            this.Ku = Ku;
            this.v = 0.0;
        }

        // One Euler step: dv/dt = (Ku*u - b*v)/m
        void step(double u, double h) {
            double dv = (Ku * u - b * v) / m;
            v += dv * h;
        }
    }

    static class PIController {
        double Kp;
        double Ki;
        double ei;  // integral of error

        PIController(double Kp, double Ki) {
            this.Kp = Kp;
            this.Ki = Ki;
            this.ei = 0.0;
        }

        double compute(double r, double y, double h) {
            double e = r - y;
            ei += e * h;
            return Kp * e + Ki * ei;
        }
    }

    public static void main(String[] args) {
        double m  = 1000.0;
        double b  = 50.0;
        double Ku = 500.0;

        // Example gains
        double Kp = 0.8;
        double Ki = 0.4;

        Vehicle veh = new Vehicle(m, b, Ku);
        PIController ctrl = new PIController(Kp, Ki);

        double h = 0.01;
        double T = 20.0;
        int N = (int) (T / h);

        double v_ref = 10.0; // desired speed [m/s]

        for (int k = 0; k <= N; ++k) {
            double t = k * h;
            double u = ctrl.compute(v_ref, veh.v, h);
            veh.step(u, h);

            if (k % 200 == 0) {
                System.out.println("t = " + t + " s, v = " + veh.v + " m/s");
            }
        }
    }
}
      

This structure mirrors typical industrial software patterns, separating plant model, controller, and simulation loop into distinct classes.

MATLAB provides a high-level environment for control design and analysis. The script below constructs the plant and PI controller, forms the closed-loop system, and plots the step response. The same transfer functions can be used to configure a Simulink model.

% Physical parameters
m  = 1000;   % kg
b  = 50;     % N*s/m
Ku = 500;    % N per control unit

% Desired design parameters (example)
zeta = 0.6;
Ts   = 5.0;
wn   = 4/(zeta*Ts);

Kp = (2*zeta*wn*m - b)/Ku;
Ki = (wn^2*m)/Ku;

fprintf('PI gains: Kp = %.3f, Ki = %.3f\n', Kp, Ki);

% Plant G(s) = Ku / (m s + b)
s = tf('s');
G = Ku / (m*s + b);

% PI controller C(s) = Kp + Ki/s
C = Kp + Ki/s;

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

% Step response (1 m/s step)
figure;
step(T);
grid on;
title('Cruise Control Closed-Loop Step Response (PI)');
ylabel('Speed [m/s]');
xlabel('Time [s]');

% --- Simulink notes (conceptual) ---
% In Simulink, one can create a block diagram:
% - Use a Step block as reference r(t)
% - Sum block to compute e(t) = r(t) - v(t)
% - PI controller implemented via Gain (Kp) and Integrator blocks (Ki*1/s)
% - First-order Transfer Fcn block for G(s) = Ku/(m*s + b)
% - Feedback connection from output v(t) to the Sum block
      

Simulink allows real-time tuning of Kp and Ki while observing the speed response, closely mimicking the workflow of industrial cruise control tuning.

Wolfram Mathematica supports symbolic and numerical control analysis. The following code defines the plant and PI controller as transfer-function models, computes the closed-loop system, and generates a step response.

(* Physical parameters *)
m  = 1000.0;
b  = 50.0;
Ku = 500.0;

(* Desired damping and settling time *)
zeta = 0.6;
Ts   = 5.0;
wn   = 4.0/(zeta*Ts);

Kp = (2.0*zeta*wn*m - b)/Ku;
Ki = (wn^2*m)/Ku;

Print["Kp = ", Kp, ", Ki = ", Ki];

s = LaplaceTransformVariable;

(* Plant G(s) = Ku / (m s + b) *)
G = TransferFunctionModel[Ku/{m, b}, s];

(* PI controller C(s) = Kp + Ki/s *)
C = TransferFunctionModel[{Kp, Ki}/{1, 0}, s];

(* Closed-loop transfer function *)
T = SystemsModelFeedbackConnect[Series[C, G]];

(* Step response *)
StepResponsePlot[T, {t, 0, 20},
  PlotLabel -> "Cruise Control Step Response (PI)",
  Frame -> True,
  FrameLabel -> {"Time [s]", "Speed [m/s]"}
]
      

Mathematica makes it straightforward to analytically inspect poles of the closed-loop system and verify that they match the designed second-order polynomial from Section 4.

The following diagram summarizes a typical workflow for classical cruise-control design, linking modeling, specification, controller synthesis, and validation steps.

flowchart TD
  M["Model vehicle dynamics: m dv/dt = u - b v"] --> L["Obtain transfer function G(s) = Ku/(m s + b)"]
  L --> S["Specify performance: overshoot, settling time, steady-state error"]
  S --> D["Design controller C(s): choose P or PI"]
  D --> A["Analyze closed-loop poles and frequency response"]
  A --> TST["Simulate step response and disturbances"]
  TST --> IMP["Implement and test on hardware (with safety limits)"]
        

Problem 1 (Closed-Loop with P Control): Consider the vehicle plant \( G(s) = \dfrac{K_u}{m s + b} \) with \( m > 0 \), \( b > 0 \), \( K_u > 0 \), and a proportional controller \( C(s) = K_p \). Derive:

1. The closed-loop transfer function \( T_p(s) = \dfrac{V(s)}{R(s)} \).
2. The steady-state error to a unit step in reference speed.

Solution:

1. With unity feedback, the closed-loop transfer function is

\[ T_p(s) = \frac{C(s)G(s)}{1 + C(s)G(s)} = \frac{K_p \dfrac{K_u}{m s + b}}{1 + K_p \dfrac{K_u}{m s + b}} = \frac{K_p K_u}{m s + b + K_p K_u}. \]

2. For a unit step reference \( r(t) = u(t) \), \( R(s) = \dfrac{1}{s} \). The steady-state value of \( v(t) \) is

\[ v_{\text{ss}} = \lim_{t → \infty} v(t) = \lim_{s \rightarrow 0} s V(s) = \lim_{s \rightarrow 0} s T_p(s) R(s) = \lim_{s \rightarrow 0} s \frac{K_p K_u}{m s + b + K_p K_u} \cdot \frac{1}{s} = \frac{K_p K_u}{b + K_p K_u}. \]

The steady-state error is therefore

\[ e_{\text{ss}} = 1 - v_{\text{ss}} = 1 - \frac{K_p K_u}{b + K_p K_u} = \frac{b}{b + K_p K_u}. \]

Thus, proportional control alone cannot eliminate the steady-state error; only \( K_p \rightarrow \infty \) would drive \( e_{\text{ss}} \) to zero, which is not practical due to saturation and robustness limits.

Problem 2 (PI Design via Pole Placement): For the same plant \( G(s) = \dfrac{K_u}{m s + b} \), suppose \( m = 1000 \), \( b = 50 \), \( K_u = 500 \). Design a PI controller \( C(s) = K_p + \dfrac{K_i}{s} \) to achieve:

• maximum overshoot \( M_p \approx 10\% \),
• 2 % settling time \( T_s \approx 5 \,\text{s} \).

Use the approximate formulas from Section 4 and compute numeric values for \( K_p \) and \( K_i \).

Solution:

For \( M_p \approx 10\% \), a typical damping ratio choice is \( \zeta \approx 0.6 \). The 2 % settling time formula is \( T_s \approx \dfrac{4}{\zeta \omega_n} \), so

\[ \omega_n \approx \frac{4}{\zeta T_s} = \frac{4}{0.6 \cdot 5} \approx 1.333\,\text{rad/s}. \]

From Section 4, the PI gains satisfy

\[ K_p = \frac{2 \zeta \omega_n m - b}{K_u}, \qquad K_i = \frac{\omega_n^2 m}{K_u}. \]

Substitute numerical values:

\[ 2 \zeta \omega_n m \approx 2 \cdot 0.6 \cdot 1.333 \cdot 1000 \approx 1599.6, \]

\[ K_p \approx \frac{1599.6 - 50}{500} = \frac{1549.6}{500} \approx 3.10. \]

For \( K_i \),

\[ \omega_n^2 \approx 1.333^2 \approx 1.777, \quad K_i \approx \frac{1.777 \cdot 1000}{500} \approx 3.55. \]

So one possible choice is \( K_p \approx 3.1 \), \( K_i \approx 3.6 \). Simulations (Sections 6–10) can verify whether the actual overshoot and settling time match the approximate second-order design.

Problem 3 (Type and Steady-State Error): For the cruise control system with PI controller as in Problem 2, classify the closed-loop system type (with respect to reference input) and determine the steady-state error to:

1. A step in reference speed.
2. A ramp in reference speed \( r(t) = a t \) with slope \( a \).

Solution:

The loop transfer function contains an integrator due to the \( K_i/s \) term, so the loop has one pole at the origin. With unity feedback, the closed-loop system with respect to reference is Type 1 (Chapter 8).

1. For a step input, a Type 1 system has \( e_{\text{ss}} = 0 \) provided the closed-loop is stable. Thus, the PI controller eliminates steady-state error to step changes in reference speed.

2. For a ramp input \( r(t) = a t \), Type 1 systems exhibit a finite steady-state error proportional to the ramp slope and inversely proportional to the velocity error constant \( K_v \). The standard result from Chapter 8 is

\[ e_{\text{ss}} = \frac{a}{K_v}, \quad K_v = \lim_{s \rightarrow 0} s\, L(s). \]

For the cruise control loop, one can compute \( K_v \) explicitly from \( L(s) = \dfrac{K_u (K_p s + K_i)}{s (m s + b)} \), but the key qualitative conclusion is that the error remains nonzero for ramps.

Problem 4 (Effect of Mass Variation): Suppose the vehicle mass increases from \( m \) to \( m' = (1+\delta)m \) (e.g., additional passengers or cargo), with \( \delta > 0 \) but the controller gains \( K_p, K_i \) remain unchanged. How does this affect the closed-loop characteristic polynomial and approximate natural frequency and damping ratio?

Solution:

With the new mass \( m' \), the characteristic polynomial becomes

\[ m' s^2 + (b + K_u K_p) s + K_u K_i = 0 \quad \Rightarrow \quad s^2 + \frac{b + K_u K_p}{m'} s + \frac{K_u K_i}{m'} = 0. \]

Comparing to \( s^2 + 2 \zeta' \omega_n' s + (\omega_n')^2 \) yields

\[ 2 \zeta' \omega_n' = \frac{b + K_u K_p}{m'}, \qquad (\omega_n')^2 = \frac{K_u K_i}{m'}. \]

Since \( m' > m \), both \( \dfrac{b + K_u K_p}{m'} \) and \( \dfrac{K_u K_i}{m'} \) are smaller than their original values, so \( \omega_n' < \omega_n \) and the closed-loop response becomes slower. The damping ratio \( \zeta' \) may also change slightly; however, for moderate \( \delta \) the qualitative behavior (underdamped vs. overdamped) is usually preserved. This illustrates the importance of robustness margins in the design.

In this lesson we derived a first-order longitudinal model for vehicle cruise control, starting from Newton's law and linearizing around a constant cruising speed. We formed the closed-loop transfer function for proportional and PI controllers and showed that PI control yields a Type 1 system with zero steady-state error to step reference inputs. Using the second-order standard form, we related time-domain specifications (overshoot and settling time) to the closed-loop poles and extracted explicit formulas for PI gains.

We then interpreted the design using frequency-response concepts (loop gain, bandwidth, robustness margins) and provided implementations in Python, C++, Java, MATLAB/Simulink, and Mathematica. These implementations demonstrate how abstract transfer-function designs map to executable simulations and, ultimately, to embedded software for cruise control systems.