PID Control and Laplace Transform: From Mathematical Foundations to Real-World Applications

Introduction

#

Imagine you’re driving a car and trying to stay in the center of your lane. Your eyes see the offset (sensor), your brain computes how much to turn the wheel (controller), and your hands execute the correction (actuator). You don’t just react to where you are — you also consider how fast you’re drifting and how long you’ve been off-center. Congratulations: your brain is running a PID controller.

PID (Proportional-Integral-Derivative) control is the most widely used control algorithm in engineering. It’s inside everything from your home thermostat to SpaceX rockets. And the mathematical tool that makes analyzing these systems elegant and tractable is the Laplace transform.

This post covers:

1. Laplace Transform — what it is, why we need it, and how to use it
2. Transfer Functions — modeling physical systems as input-output relationships
3. PID Control — the algorithm, its mathematics, and tuning
4. Four Real-World Examples — motor/encoder, lane centering, volume control, thrust control

1. The Laplace Transform: Turning Calculus into Algebra

#

1.1 The Problem: Differential Equations Are Hard

#

Physical systems are described by differential equations. For example, a simple spring-mass-damper system:

Solving this directly requires guessing solution forms, matching boundary conditions, and handling convolutions. It’s tedious and error-prone.

What if we could convert these differential equations into simple algebraic equations? That’s exactly what the Laplace transform does.

Time Domain (hard)              Frequency Domain (easy)
─────────────────              ──────────────────────
Differential equations    →    Algebraic equations
Convolution              →    Multiplication
Solve with calculus      →    Solve with algebra
                  ↓ Laplace Transform ↓
        f(t)  ──────────────→  F(s)

        Solve algebraically in s-domain

        F(s)  ──────────────→  f(t)
                  ↑ Inverse Laplace ↑

1.2 Definition

#

The Laplace transform of a function $f(t)$ is defined as:

where:

• $t$ is time (real, $t \geq 0$)
• $s = \sigma + j\omega$ is a complex frequency variable
• $F(s)$ is the Laplace-domain representation of $f(t)$

Intuition: The Laplace transform decomposes a time signal into a sum of exponentially-weighted sinusoids. The variable $s$ encodes both growth/decay rate ($\sigma$) and oscillation frequency ($\omega$).

1.3 Why Does This Work?

#

The key insight is what happens to derivatives under the Laplace transform:

Differentiation in time becomes multiplication by $s$. This is the magic — every derivative turns into a power of $s$, converting differential equations into polynomials.

For example, starting from the spring-mass-damper equation (assuming zero initial conditions):

Applying the Laplace transform to both sides:

That’s it. A messy differential equation became a simple fraction. This fraction is called the transfer function.

1.4 Essential Laplace Transform Table

#

Here are the transforms you’ll use most often:

1.5 Key Properties

#

The Final Value Theorem is particularly useful — it tells us the steady-state value of a system’s output without solving the full time-domain response.

1.6 A Concrete Example: RC Circuit

#

Consider a simple resistor-capacitor circuit where we apply a voltage step $V_{in}$ and want to find the capacitor voltage $V_c(t)$:

    R
Vin ─┤├──┬── Vc(t)
          │
         ═╧═ C
          │
         GND

Time-domain equation (KVL):

Laplace transform (with $V_c(0) = 0$):

Inverse Laplace (partial fractions):

The transfer function $H(s) = \frac{1}{RCs + 1}$ completely describes how this circuit responds to any input. The time constant $\tau = RC$ determines how fast the system responds.

Vc(t)
 │    ┌─────────────────── Vin
 │   ╱
 │  ╱   63.2% at t = τ = RC
 │ ╱
 │╱
 └────────────────────────── t
 0    τ    2τ    3τ    4τ

2. Transfer Functions: The Language of Control Systems

#

2.1 What Is a Transfer Function?

#

A transfer function $G(s)$ describes the input-output relationship of a linear time-invariant (LTI) system:

              ┌──────────┐
  U(s) ─────→│   G(s)   │─────→ Y(s)
  (Input)     └──────────┘     (Output)

The transfer function tells us everything about how the system behaves — its speed, stability, oscillation, and steady-state accuracy.

2.2 Poles and Zeros: The DNA of a System

#

Every transfer function can be factored as:

• Zeros ($z_i$): values of $s$ where $G(s) = 0$ — they shape the response
• Poles ($p_i$): values of $s$ where $G(s) \to \infty$ — they determine stability and speed

The Golden Rule: A system is stable if and only if all poles have negative real parts (they lie in the left half of the complex plane).

  Imaginary (jω)
       │
  ×    │    ×         × = pole location
  (stable)  (unstable)
       │
───────┼──────── Real (σ)
       │
  ×    │    ×
  (stable)  (unstable)
       │
  LEFT │ RIGHT
 (stable)(unstable)

2.3 Standard Second-Order System

#

Many real systems can be approximated by the standard second-order form:

where:

• $\omega_n$ = natural frequency (how fast the system wants to oscillate)
• $\zeta$ = damping ratio (how quickly oscillations die out)

Step Response for different ζ:

y(t)
 │     ζ=0 (oscillates forever)
 │    ╱╲  ╱╲  ╱╲  ╱╲
 │   ╱  ╲╱  ╲╱  ╲╱  ╲
1├─·╱·····················─── ζ=1.0 (critically damped)
 │╱   \_____________________  ζ=0.7 (common target)
 │╱  ╱
 │  ╱    ζ=2.0 (overdamped, slow)
 │ ╱   ╱─────────────────────
 │╱  ╱
 └──────────────────────────── t

Engineers typically aim for $\zeta \approx 0.7$ — it gives a fast response with minimal overshoot (~5%).

3. PID Control: The Algorithm

#

3.1 The Control Loop

#

A standard feedback control loop looks like this:

                          ┌──────────────┐
  r(t) ──→(+)──→ e(t) ──→│     PID      │──→ u(t) ──→┌────────┐──→ y(t)
  (setpoint) │            │  Controller  │            │ Plant  │  (output)
             │            └──────────────┘            │ G(s)   │
             │  -                                     └────────┘
             │                                             │
             └─────────────────────────────────────────────┘
                            feedback (sensor)

• $r(t)$ = reference / setpoint (what you want)
• $y(t)$ = measured output (what you have)
• $e(t) = r(t) - y(t)$ = error (the difference)
• $u(t)$ = control signal (what you send to the actuator)
• $G(s)$ = plant (the physical system you’re controlling)

3.2 The PID Equation

#

The PID controller computes the control signal as:

Each term serves a specific purpose:

3.3 P — Proportional: “React to the Present”

#

The output is proportional to the current error. Bigger error → stronger correction.

Error:  e(t) = 10°C    →  Output: Kp × 10 = strong heating
Error:  e(t) = 1°C     →  Output: Kp × 1  = gentle heating
Error:  e(t) = 0°C     →  Output: Kp × 0  = no heating (problem!)

Problem: With P-only control, the system often settles at a steady-state error. Why? Because as the error decreases, so does the control effort — eventually the system reaches equilibrium before the error reaches zero.

           setpoint ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
y(t)                            _______________
 │                          ╱
 │                       ╱    ← steady-state error
 │                    ╱        (never reaches setpoint)
 │                 ╱
 │              ╱
 └──────────────────────────────────── t

$K_p$ too small: Sluggish response, large steady-state error. $K_p$ too large: Fast response, but oscillation and potential instability.

3.4 I — Integral: “Remember the Past”

#

The integral term accumulates past errors over time. Even if the current error is small, the accumulated error keeps growing, pushing the output harder until the error is truly zero.

Time     Error    Accumulated (∫e dt)    Action
───────────────────────────────────────────────
t=0      10       0                      Start accumulating
t=1      5        7.5                    Still accumulating
t=2      2        11.0                   Growing stronger
t=3      2        13.0                   Keeps pushing!
t=4      1        14.5                   Won't stop until e=0
t=5      0        15.0                   Finally stops growing

The I-term eliminates steady-state error — it’s the only term that guarantees zero error at steady state.

Problem — Integral Windup: If the actuator saturates (e.g., motor at max voltage), the integral keeps accumulating while the system can’t respond. When the error finally reverses, the bloated integral causes massive overshoot.

         saturation limit
─ ─ ─ ─ ─┬─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
          │  ╱╲
          │ ╱  ╲  ← overshoot from windup
          │╱    ╲___________________
          ╱
        ╱ │
      ╱   │
    ╱     │ ← integral accumulates during saturation
──────────┴─────────────────────────── t

Solution: Anti-windup — clamp the integral when the actuator is saturated.

3.5 D — Derivative: “Predict the Future”

#

The derivative term responds to the rate of change of the error. It acts like a “brake” — if the error is decreasing quickly, it reduces the control effort to prevent overshoot.

Scenario 1: Error decreasing fast (de/dt << 0)
→ D-term applies negative force → "Slow down, you're approaching target!"

Scenario 2: Error increasing (de/dt > 0)
→ D-term applies extra positive force → "Speed up, you're falling behind!"

Scenario 3: Error stable (de/dt ≈ 0)
→ D-term contributes nothing

Without D (P+I only):          With D (full PID):

y(t)                            y(t)
 │      ╱╲                      │
 │     ╱  ╲  ╱╲                 │        _______________
1├────╱────╲╱──╲────── ←oscillates  1├──────╱
 │   ╱                           │    ╱  ← smooth, fast settling
 │  ╱                            │  ╱
 │ ╱                             │ ╱
 └──────────────────── t         └──────────────────── t

Problem: The D-term amplifies high-frequency noise. In practice, a low-pass filter is applied:

where $N$ is the filter coefficient (typically 10–100).

3.6 Summary: What Each Term Does

#

 ┌──────────────────────────────────────────┐
 │              PID Controller              │
 │                                          │
 │  e(t) ──┬──→ [Kp × e] ──────┐           │
 │         │                     │           │
 │         ├──→ [Ki × ∫e dt] ──┼──→ Σ ──→ u(t)
 │         │                     │           │
 │         └──→ [Kd × de/dt] ──┘           │
 │                                          │
 └──────────────────────────────────────────┘

4. PID in the Laplace Domain

#

4.1 PID Transfer Function

#

Applying the Laplace transform to the PID equation (recall: differentiation → multiplication by $s$, integration → division by $s$):

Combining into a single fraction:

This is the PID transfer function. Notice:

• It has a pole at $s = 0$ (from the integral term) — this is what ensures zero steady-state error
• It has two zeros (from the numerator) — these can be placed to shape the response

4.2 Closed-Loop Transfer Function

#

The closed-loop transfer function with plant $G(s)$ and controller $C(s)$:

This is the most important equation in control theory. It tells us the complete behavior of the controlled system.

4.3 Using Laplace to Determine System Parameters

#

“How do we find the coefficients?” — This is a central question in control engineering. The Laplace transform enables a powerful workflow:

Step 1: Model the plant — Derive $G(s)$ from physics or system identification.

Step 2: Define requirements — Desired settling time, overshoot, steady-state error.

Step 3: Solve for PID gains — Use the closed-loop transfer function $T(s)$ and match it to the desired characteristic equation.

Example: Matching to a desired second-order response.

Suppose our plant is $G(s) = \frac{K}{s + a}$ and we want the closed-loop to behave like:

With a PI controller $C(s) = K_p + \frac{K_i}{s} = \frac{K_p s + K_i}{s}$:

Matching the denominator to $s^2 + 2\zeta\omega_n s + \omega_n^2$:

This is the power of the Laplace transform — it turns the “what PID gains should I use?” question into a straightforward algebraic calculation.

5. Example 1: DC Motor with Encoder

#

5.1 The System

#

A DC motor drives a wheel, and an encoder measures the angular position $\theta$. We want to control the motor’s angular velocity $\omega$.

                    ┌───────────────┐
  Voltage ─────────→│   DC Motor    │─────→ ω (angular velocity)
  u(t)              │               │        │
                    └───────────────┘        │
                           │                 │
                           └── Shaft ────────┤
                                             │
                    ┌───────────────┐         │
  ω_measured ←──────│   Encoder     │←────────┘
                    │ (quadrature)  │
                    └───────────────┘

5.2 Deriving the Plant Transfer Function

#

Motor physics (electrical and mechanical equations):

Electrical side (armature circuit):

where:

• $V$ = applied voltage
• $L$ = armature inductance
• $R$ = armature resistance
• $i$ = armature current
• $K_e$ = back-EMF constant
• $\omega$ = angular velocity

Mechanical side (Newton’s second law for rotation):

where:

• $J$ = moment of inertia
• $K_t$ = torque constant (for an ideal motor, $K_t = K_e = K_m$)
• $B$ = viscous friction coefficient

Laplace transform (zero initial conditions):

Substituting $I(s)$ into the electrical equation:

Simplification (for small motors, $L$ is often negligible: $L \approx 0$):

This simplifies to a first-order system:

where:

• $K_m = \frac{K_t}{RB + K_m^2}$ (motor gain — steady-state speed per volt)
• $\tau_m = \frac{RJ}{RB + K_m^2}$ (mechanical time constant)

5.3 Numerical Example

#

Typical small DC motor parameters:

Computing:

5.4 PID Design for the Motor

#

Requirement: Reach target speed in 50 ms with < 5% overshoot.

For < 5% overshoot: $\zeta \geq 0.7$. For 50 ms settling time ($t_s \approx \frac{4}{\zeta\omega_n}$):

Using PI control with $G(s) = \frac{1.11}{0.044s + 1}$:

5.5 Encoder Feedback

#

The encoder converts mechanical rotation into digital pulses:

Encoder Output (Quadrature):

Ch A: ──┐  ┌──┐  ┌──┐  ┌──
        │  │  │  │  │  │
        └──┘  └──┘  └──┘

Ch B:    ──┐  ┌──┐  ┌──┐  ┌──     ← 90° phase shift
           │  │  │  │  │  │
           └──┘  └──┘  └──┘

Direction: A leads B → Forward
           B leads A → Reverse

Velocity measurement:

where PPR = pulses per revolution (after quadrature decoding: 4× raw PPR).

5.6 Implementation (C Code)

#

// PID controller for DC motor speed control
typedef struct {
    float Kp, Ki, Kd;
    float integral;
    float prev_error;
    float integral_max;     // Anti-windup limit
    float dt;               // Sample period (seconds)
} PID_t;

float pid_compute(PID_t *pid, float setpoint, float measured) {
    float error = setpoint - measured;

    // Proportional
    float P = pid->Kp * error;

    // Integral with anti-windup
    pid->integral += error * pid->dt;
    if (pid->integral > pid->integral_max) pid->integral = pid->integral_max;
    if (pid->integral < -pid->integral_max) pid->integral = -pid->integral_max;
    float I = pid->Ki * pid->integral;

    // Derivative (on measurement to avoid derivative kick)
    float derivative = (error - pid->prev_error) / pid->dt;
    float D = pid->Kd * derivative;
    pid->prev_error = error;

    return P + I + D;
}

// Usage in timer ISR (e.g., every 1 ms)
void TIM2_IRQHandler(void) {
    float rpm_target = 3000.0f;
    float rpm_actual = encoder_get_rpm();

    float voltage = pid_compute(&motor_pid, rpm_target, rpm_actual);

    // Clamp output to valid PWM range
    if (voltage > 12.0f) voltage = 12.0f;
    if (voltage < 0.0f) voltage = 0.0f;

    set_pwm_duty(voltage / 12.0f);    // Normalize to 0.0–1.0
    clear_timer_flag();
}

6. Example 2: Lane Centering (Autonomous Driving)

#

6.1 The System

#

A camera detects the vehicle’s lateral offset $e_{\text{lat}}$ from the lane center, and a steering controller brings it back to center.

    ┌─────── Lane Boundary ───────────────────────┐
    │                                              │
    │        ┌───────┐                             │
    │        │       │  ← Vehicle                  │
    │        │  ╔═╗  │                             │
    │        │  ║ ║  │  e_lat                      │
    │   ─ ─ ─│─ ╟─╢ ─│─ ─ ─ ← Lane Center        │
    │        │  ║ ║  │  ↕ (lateral offset)         │
    │        │  ╚═╝  │                             │
    │        │       │                             │
    │        └───────┘                             │
    │                                              │
    └─────── Lane Boundary ───────────────────────┘

6.2 The Lateral Dynamics Model

#

For a vehicle moving at constant longitudinal velocity $v_x$, the bicycle model approximates lateral dynamics:

where:

• $y$ = lateral position
• $\psi$ = heading (yaw) angle
• $F_{yf}, F_{yr}$ = front/rear tire lateral forces
• $L_f, L_r$ = distance from CG to front/rear axle
• $m$ = vehicle mass, $I_z$ = yaw moment of inertia

For small angles, tire forces are proportional to slip angles:

After linearization around straight-line driving, the transfer function from steering angle $\delta$ to lateral offset $e_{\text{lat}}$ is approximately:

Simplified model (at constant speed, dominant dynamics):

This is an integrator (the $1/s$ term: steering angle integrates into lateral position) cascaded with a first-order lag.

6.3 PD Controller Design

#

For lane centering, we typically use a PD controller (not full PID) because:

• The plant already has an integrator ($1/s$) — adding another (Ki) can cause oscillation
• We want smooth, damped corrections (no jerky steering)

The control law in the time domain:

Physical interpretation:

• $K_p \cdot e_{\text{lat}}$: “You’re 30 cm to the right → steer left proportionally”
• $K_d \cdot \dot{e}_{\text{lat}}$: “You’re drifting right at 10 cm/s → steer left harder to counteract”

6.4 Adding a Heading Term

#

In practice, lane centering uses both lateral offset and heading error $e_\psi$ (the angle between the vehicle and the lane):

    Lane direction →
    ─────────────────────────────────────

              ╱  Vehicle heading
             ╱ }  e_ψ (heading error)
    ─ ─ ─ ─╱─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
           ╱     ↕ e_lat (lateral offset)
    ─────────────────────────────────────

6.5 Numerical Example

#

Scenario: Vehicle is 0.3 m right of center, drifting right at 0.1 m/s, heading error 2°.

The controller commands 4.6° of left steering — a smooth, gradual correction.

6.6 Speed-Dependent Gain Scheduling

#

At higher speeds, the same steering angle causes a larger lateral response. To maintain consistent behavior, gains are often scheduled based on speed:

Kp
 │╲
 │  ╲
 │    ╲
 │      ╲___________
 │
 └──────────────────── vx (speed)
   30    60    90    120 km/h

At low speed:  Aggressive corrections (parking)
At high speed: Gentle corrections (highway)

7. Example 3: Target Volume Control (Audio System)

#

7.1 The System

#

A digital audio system adjusts the output volume to match a target loudness level, measured in decibels (dB). The human ear perceives loudness logarithmically, and the audio amplifier has its own dynamics.

  Target     ┌─────────┐     Gain      ┌───────────┐     Actual
  Volume ──→ │   PID   │ ────────────→ │   Audio   │ ──→ Volume
  (dB)       │Controller│   (digital   │ Amplifier │     (dB)
             └─────────┘    gain)      │ + Speaker │
                  ↑                     └───────────┘
                  │                          │
                  │    ┌──────────┐          │
                  └────│ Loudness │←─────────┘
                       │  Meter   │  (microphone)
                       └──────────┘

7.2 The Plant Model

#

An audio amplifier with automatic gain control can be modeled as a first-order system with logarithmic scaling:

where:

• $L$ = output loudness level (dB)
• $G$ = applied gain (controlled by PID output)
• $L_{\text{in}}$ = input signal level
• $\tau_a$ = amplifier time constant

In the Laplace domain:

However, the feedback measurement (via microphone + RMS computation) adds its own delay:

Combined plant:

7.3 PID Design

#

Requirements:

• Settle to target volume within 200 ms
• No audible overshoot (< 2 dB, or $\approx$ 1.26× perceived)
• Eliminate steady-state offset (integral action needed)

Typical parameters for a conference room auto-volume system:

Using PI control (D-term omitted to avoid amplifying audio noise):

With the combined plant, the closed-loop characteristic equation is:

Expanding:

For desired $\zeta = 0.8$ and $t_s = 200$ ms ($\omega_n \approx 25$ rad/s), we can use pole placement or root locus to find suitable $K_p$ and $K_i$.

A good starting point using the dominant pole approximation:

7.4 Practical Considerations

#

Scenario: Noisy conference room

                    Target: 65 dB
                    ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
Measured    65 ───────────────────────────────────
Volume (dB) 60    ╱
            55  ╱
            50 ╱    ← speaker adjusting up

            Time →  0    100ms  200ms  300ms

When someone stops talking:
            70   ╲
            65 ───╲─────────────────────────────── Target
                   ╲___________________________

            → Gain increases to compensate for lost input

Anti-windup is critical: When the speaker is at maximum volume, the integral should stop accumulating. Otherwise, when the audio source suddenly gets louder, the overcharged integral causes painfully loud overshoot.

8. Example 4: Thrust Control (Drone / Rocket)

#

8.1 The System

#

A drone (or rocket) must maintain a target altitude by controlling the thrust of its motors. This is a classic control problem where gravity provides a constant disturbance.

                    ↑ Thrust T(t)
                    │
               ┌────┴────┐
               │  Drone   │ ← mass m
               │  ╔════╗  │
               │  ║    ║  │
               └──╨────╨──┘
                    │
                    ↓ Weight mg

  Altitude h(t)
       ↑
       │  Target: h_ref
       │

8.2 Deriving the Plant Transfer Function

#

Newton’s second law (vertical motion):

where:

• $h$ = altitude
• $T$ = thrust force
• $m$ = vehicle mass
• $g$ = gravitational acceleration (9.81 m/s²)
• $D(\dot{h})$ = aerodynamic drag (linearized: $D \approx b\dot{h}$)

Linearization around hover: At hover, $T_0 = mg$. Let $\delta T = T - T_0$ be the thrust deviation:

Laplace transform:

This is a double integrator (with damping). Without control, the system is marginally stable at best — any uncompensated thrust error leads to unbounded altitude drift.

8.3 Simplified Model (Neglecting Drag)

#

For a small drone at low speeds ($b \approx 0$):

This is a pure double integrator — the hardest type of plant to control because it has two poles at $s = 0$ (on the stability boundary).

8.4 PID Design

#

With a double-integrator plant, PD control is the minimum needed for stability:

Closed-loop with $G(s) = \frac{1}{ms^2}$:

The characteristic equation:

Using Routh-Hurwitz stability criteria, the system is stable when:

8.5 Numerical Example: Quadcopter Altitude Hold

#

Design for: $\zeta = 0.8$, $\omega_n = 5$ rad/s (settling time ~1 s)

For a third-order system, we place a dominant second-order pair plus a fast real pole at $s = -p$ where $p \gg \zeta\omega_n$:

Choosing $p = 10\zeta\omega_n = 40$ rad/s:

Matching coefficients with $ms^3 + K_d s^2 + K_p s + K_i$:

Verify stability: $K_d K_p = 72 \times 517.5 = 37{,}260 > mK_i = 1.5 \times 1500 = 2{,}250$ ✓

8.6 The Complete Altitude Control Loop

#

                         ┌──────────────────────────────┐
  h_ref ──→(+)──→ e ──→ │  PID: Kp·e + Ki∫e + Kd·ė    │──→ δT
  (target   │            └──────────────────────────────┘     │
  altitude) │                                                  │
            │  -                                               ▼
            │                                            T = mg + δT
            │                                                  │
            │           ┌──────────────────────┐               │
            │           │    Drone Physics     │               │
            └───────────│  m·ḧ = T - mg - bḣ  │←──────────────┘
                        └──────────────────────┘
                                 │
                                 ▼
                              h(t) (actual altitude)
                                 │
                        ┌────────┴────────┐
                        │   Barometer /   │
                        │   GPS / LiDAR   │
                        └─────────────────┘

Disturbance rejection (wind gust):

h(t)
 │
 │  Target ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
 │                      ╱╲
 │                     ╱  ╲  Wind gust
 │                    ╱    ╲____________________
 │  ──────────────────
 │
 └──────────────────────────────────────────────── t
                        ↑
                    P reacts immediately
                    D counteracts the rate
                    I corrects residual offset

8.7 Real-World Layers

#

In practice, drone altitude control uses a cascaded PID architecture:

  h_ref ──→ [Position PID] ──→ v_ref ──→ [Velocity PID] ──→ a_ref ──→ [Thrust Mapping] ──→ Motors
               (outer loop)                (inner loop)
               ~10 Hz                      ~50-100 Hz

Inner loop: Fast, stabilizes velocity (easier plant: single integrator)
Outer loop: Slow, tracks position (uses velocity as "actuator")

This cascade is more robust than a single PID because:

1. The inner loop linearizes the plant for the outer loop
2. Each loop can be tuned independently
3. The inner loop rejects disturbances before they affect position

9. Tuning Methods: Finding the Right Gains

#

9.1 Ziegler-Nichols Method (Experimental)

#

When you don’t have a mathematical model, Ziegler-Nichols provides a systematic approach:

Step 1: Set $K_i = 0$ and $K_d = 0$.

Step 2: Increase $K_p$ until the system oscillates with constant amplitude (marginally stable). Record this as $K_u$ (ultimate gain) and measure the oscillation period $T_u$.

Step 3: Calculate PID gains:

Step 2: Finding Ku and Tu

y(t)
 │     ╱╲    ╱╲    ╱╲    ╱╲
 │    ╱  ╲  ╱  ╲  ╱  ╲  ╱  ╲   ← Constant amplitude oscillation
─┼───╱────╲╱────╲╱────╲╱────╲──── setpoint
 │  ╱
 │ ╱    │←── Tu ──→│
 │╱
 └────────────────────────────── t
   At this point: Kp = Ku

9.2 Cohen-Coon Method (Model-Based)

#

If you can measure the system’s step response, extract three parameters:

Step Response:
y(t)
 │                    ___________________  K (steady-state gain)
 │                 ╱
 │               ╱
 │             ╱  ← steepest slope = R
 │           ╱
 │─────────╱
 │   L     │
 └─────────┴──────────────────────── t
     ↑ dead time (delay)

• $K$ = steady-state gain (final value / step size)
• $L$ = dead time (delay before response starts)
• $\tau$ = time constant (time to reach 63.2% of final value)
• $R = K / \tau$ (maximum slope)

9.3 Analytical Pole Placement (What We Did Above)

#

This is the Laplace-based approach we demonstrated in each example:

1. Model the plant as $G(s)$
2. Choose desired pole locations based on specs ($\zeta$, $\omega_n$)
3. Solve for PID gains algebraically

10. Common Pitfalls and Best Practices

#

10.1 Derivative Kick

#

When the setpoint changes abruptly, the derivative of the error spikes:

Solution: Differentiate only the measurement, not the error:

This gives the same damping behavior without the spike when $r$ changes.

10.2 Integral Windup Protection

#

// Anti-windup with back-calculation
float pid_with_anti_windup(PID_t *pid, float error, float u_saturated) {
    float u_raw = pid->Kp * error + pid->Ki * pid->integral + pid->Kd * deriv;

    // Back-calculation: reduce integral by saturation difference
    float saturation_error = u_saturated - u_raw;
    pid->integral += (error + saturation_error / pid->Kp) * pid->dt;

    return u_saturated;
}

10.3 Sample Rate Considerations

#

The PID controller runs in discrete time on a microcontroller. The sample rate must be:

11. Summary

#

The Laplace Transform Connection

#

The Laplace transform is not just “used for PID” — it is the fundamental language of linear control systems:

PID at a Glance

#

Four Examples Compared

#

PID control is deceptively simple in concept but endlessly deep in practice. The Laplace transform gives us the mathematical clarity to understand why each gain does what it does, and how to systematically design controllers for any linear system. Start with the math, verify with simulation, and tune on real hardware — that’s the engineering workflow.