Flow Lab

Syllabus / Module 13: Applications: Control Systems

Lesson 13.1

Feedback & Block Diagrams

Open vs closed loop, block diagram algebra, disturbance rejection, sensitivity, and the cruise-control example.

Written byClaude Sonnet

🌊
Why this matters for simulation: An autopilot is a feedback loop wrapped around the flight dynamics.

By the end of this lesson you can…

  • Tell an open-loop controller from a closed-loop one, and name the plant, controller, sensor, reference, error and disturbance in a block diagram.
  • Reduce a block diagram with a summing junction to a single transfer function using the rule forward over one plus loop, and write the three transfer functions from $R$, $D$ and $N$ to $Y$.
  • Derive the closed-loop pole $-(1+K)/\tau$ of a first-order plant under proportional feedback and compute the time constant $\tau/(1+K)$ for a given gain.
  • Compute the steady-state error $1/(1+K)$ and the disturbance rejection of proportional control, and say why a finite gain never makes the error zero.
  • Define the sensitivity $S = 1/(1+L)$ and the complementary sensitivity $T = L/(1+L)$, show $S + T = 1$, and use $S$ to estimate how a plant error changes the closed loop.
  • Explain the cost of high gain: sensor noise driven into the actuator, and instability once a delay is present, using the critical gain from the phase condition.
  • Connect the idea to the yaw damper of lesson 12.6, where feeding back $-Kr$ moved the Dutch roll pole.
On this page
·
  1. Open loop and closed loop
  2. A cruise-control plant
  3. Block diagram algebra
  4. Proportional feedback moves the pole
  5. Steady-state error and disturbance rejection
  6. Sensitivity and robustness
  7. The cost: noise
  8. The cost: delay and the edge of instability
  9. Back to the aircraft
  10. Worked examples
  11. Playground: the loop as a simulation
  12. The exercise
  13. Concept checks
  14. Problems
  15. What comes next
  16. Key Takeaways

6.5 Convolution & Transfer Functions ended with a transfer function: a ratio of polynomials in ss whose poles say how a system rings after a kick. Every system there was left alone to respond. This lesson closes the loop. We measure the output, compare it with what we wanted, and push the input to make the difference smaller. It is the idea behind a thermostat, a cruise control, the fan of a wind tunnel and the yaw damper of 12.6 Lateral-Directional Modes, where feeding the yaw rate back to the rudder pulled the Dutch roll pole left. Here the idea is stripped to its simplest case: a plant with one pole, a controller with one gain. Even that case shows what feedback gives (a faster pole, a smaller error) and what it charges (noise, delay, instability).

▶ Video Open loop and closed loop on a hill, the block diagram and its algebra, the pole sliding left as the gain grows, the error and the hill shrinking as one over one plus K, and the delay that eventually breaks the loopcaptions only
Transcript
  1. A cruise control that ignores the speedometer is open loop. It applies a calibrated command and never looks at the result. At t equals 10 the speed is 0.6321, at 30 it is 0.9502, and a hill at 30 seconds takes it down to 0.0473, still falling, because nothing pushes back. Closed loop adds a sensor. The speed is subtracted from the reference r to give the error e, the controller K turns it into a command u, the plant P responds, and the disturbance d, the hill, enters beside the command. The price is that the output now feeds its own input.
  2. Put u equals K times r minus y into the plant and divide by 1 plus K. It is again a first-order lag. The pole is the root of tau s plus 1 plus K, so it moves from minus 1 over tau to minus 1 plus K over tau. With tau equal 10, K equals 1, 4, 9 and 19 puts the pole at minus 0.2, minus 0.5, minus 1 and minus 2, and the time constant shrinks from 10 seconds to 5, 2, 1 and 0.5. At K equals 4 the speed is 0.7947 at t equals 10 where open loop managed 0.6321, and the time to 90 percent of the final value is 4.6 seconds against 23.0.
  3. Let the loop settle. The speed ends at K r plus d over 1 plus K, so with no hill the steady-state error is 1 over 1 plus K. At K equals 1 the speed settles at 0.4988 and the error is 0.5. At K equals 4 it is 0.8000, error 0.2. At 9, 0.9000 and 0.1. At 19, 0.9500 and 0.05. Feedback makes the error small but never zero, because to hold a nonzero output the plant needs a nonzero command, and the controller needs a nonzero error to produce it.
  4. Now the hill, d equals minus 1 at t equals 30. The disturbance enters through P over 1 plus L, which at zero frequency is 1 over 1 plus K. Open loop has no defence: 0.9502 before the hill, 0.0473 and falling after. At K equals 4 the speed goes from 0.8000 to 0.6000, a dent of 0.2. At K equals 1 it falls from 0.4988 to 0.0012. The dents at K equal 4, 9 and 19 are 0.2000, 0.1000 and 0.0500. The hill that costs open loop everything dents the closed loop by 1 over 1 plus K.
  5. How much does feedback protect against a plant that is not what we modelled? Define the sensitivity S as 1 over 1 plus L, with T equal L over 1 plus L, so S plus T equals 1. A fractional error in the plant reaches the closed loop multiplied by S. At K equals 4, S is 0.2000 at zero frequency, 0.2774 at 0.1 radians per second, 0.7211 at 0.5, and 0.8989 at 1, while T falls from 0.8000 to 0.3578. Feedback is strong at low frequency and weakens as the plant's lag removes loop gain: good where L is large, neutral where it is small.
  6. The sensor is not ideal. Add noise of rms 0.1 metres per second. The transfer function from noise to output is minus T, so the loop that follows the reference follows the noise too, and the command carries K times it. At K equals 4 the command jitters by 0.3996 and the speed by 0.0078. At K equals 19 the command jitters by 1.8786, against a sensor of 0.1, while the speed, a low-pass filter, barely moves, 0.0197. The cost lands on the actuator. At K equals 19 the opening command is 19, nineteen times the open-loop value, and a real throttle saturates long before that.
  7. A measurement delay of theta seconds multiplies the loop gain by e to the minus s theta. Stability is lost when the loop gain reaches 1 at a phase of minus 180 degrees, which needs arctan of tau omega plus omega theta equal pi. For a delay of 1 second that happens at 1.632 radians per second, giving a critical gain of 16.351. A delay of 0.5 seconds allows 32.056, and 2 seconds only 8.502. Running the loop with a delay of 1, the largest speed over the last 10 seconds is 0.8943 at K equals 14.5, ringing and decaying, 1.4339 at 16, barely decaying, 78.25 at 18 and 6496.8 at 20. Even at K equals 4 the sensitivity peaks at 1.396, so disturbances near that frequency are amplified.
  8. So what did a bare gain buy? A faster pole, minus 1 plus K over tau, an error of 1 over 1 plus K, and a hill or plant error cut by the same factor. What it charged: noise on the command, and a critical gain of 16.351 once there is a 1 second delay. The yaw damper of lesson 12.6 is the same mechanism in state space, with the Dutch roll damping going from 0.2065 to 0.733 and the spiral root from minus 0.00678 to minus 0.173. The next lesson in build order, 13.2, is not yet written. It makes the pole picture precise: step responses, rise time, overshoot, settling time and the final value theorem behind 1 over 1 plus K.

Open loop and closed loop

A cruise control that ignores the speedometer is open loop. You calibrate it once, “this throttle position holds 2525 m/s on flat road”, and it applies that throttle forever. It works while the world matches the calibration; a hill or a headwind changes the answer and nothing notices.

A closed-loop (feedback) controller measures the result and acts on the difference. The speedometer reading is subtracted from the wanted speed, and the throttle is changed in proportion to what is left. The parts have standard names:

  • the plant PP: the thing being controlled (the car, a room, an aircraft);
  • the controller CC: the rule that turns error into command (here a pure gain KK);
  • the sensor: what measures the output (here ideal, later noisy or delayed);
  • the reference rr: what we want; the output yy: what we get;
  • the error e=r−ymeasurede = r - y_{\text{measured}}, and the command u=Keu = K e;
  • the disturbance dd: anything we did not command that pushes the plant, such as a hill.

The price of closing the loop is that the output now feeds its own input, so the system can chase its tail. Everything below is about when that helps and when it hurts.

A cruise-control plant

Let yy be the speed deviation from cruise in m/s. Newton gives mv˙=F−bv+Fhillm\dot v = F - bv + F_{\text{hill}} with linearised drag bvbv. Take m=1000m = 1000 kg and b=100b = 100 N s/m (assumed round numbers, in the right range for a car around 3030 m/s, from memory). Dividing by bb and calling τ=m/b\tau = m/b gives the plant

τ y˙=−y+u+d,τ=10 s,P(s)=1τs+1.\tau\,\dot y = -y + u + d, \qquad \tau = 10\ \text{s}, \qquad P(s) = \frac{1}{\tau s + 1} .

Here u=F/bu = F/b is the command expressed as the steady speed it would buy, and dd the hill in the same units: d=−1d = -1 is a hill that, left alone, takes 11 m/s off the speed. This is the form of 3.4 Linear First-Order Equations & Integrating Factors, and its transfer function is the first-order lag of 6.5 Convolution & Transfer Functions. Open loop, u=r=1u = r = 1 gives y=1−e−t/10y = 1 - e^{-t/10}: 0.63210.6321 at t=10t = 10 s and 0.95020.9502 at 3030 s. A hill of d=−1d = -1 at t=30t = 30 s sends the car to the bottom: y(59.99)=0.0473y(59.99) = 0.0473 and falling toward 00. The hill ate the whole command and nothing pushed back.

Block diagram algebra

A block diagram draws signals as arrows and operations as boxes. Three pieces are enough: a box multiplies a signal by its transfer function, a summing junction adds or subtracts, and a branch point copies a signal to two places. Boxes in series multiply and boxes in parallel add.

For the loop above, the controller sees e=r−(y+n)e = r - (y + n), where nn is sensor noise, and the plant sees Ke+dK e + d. Write that out in the ss domain, with L=KPL = KP the loop gain (multiply the blocks around the loop once):

Y=P (K(R−Y−N)+D)⟹(1+L) Y=L R+P D−L N.Y = P\,(K(R - Y - N) + D) \quad\Longrightarrow\quad (1 + L)\,Y = L\,R + P\,D - L\,N .

Solving for YY gives the three transfer functions every control course keeps returning to:

Y=L1+L R  +  P1+L D  −  L1+L N.Y = \frac{L}{1+L}\,R \;+\; \frac{P}{1+L}\,D \;-\; \frac{L}{1+L}\,N .

The rule behind the algebra is forward over one plus loop: the transfer function around a negative-feedback loop is the forward path divided by one plus the loop gain. Reference and noise share the factor L/(1+L)L/(1+L): a loop that follows the reference well follows the sensor noise too.

Proportional feedback moves the pole

Put u=K(r−y)u = K(r - y) into the plant equation with no noise:

τy˙=−y+K(r−y)+d  ⟹  τ1+K y˙=−y+K r+d1+K.\tau\dot y = -y + K(r - y) + d \;\Longrightarrow\; \frac{\tau}{1+K}\,\dot y = -y + \frac{K\,r + d}{1+K} .

It is again a first-order lag. The time constant has shrunk from τ\tau to τ/(1+K)\tau/(1+K) and the pole has moved from −1/τ-1/\tau to

scl=−1+Kτ.s_{\text{cl}} = -\frac{1+K}{\tau} .

The pole is the root of 1+L(s)=01 + L(s) = 0: 1+K/(τs+1)=01 + K/(\tau s + 1) = 0 gives τs+1+K=0\tau s + 1 + K = 0. In state-space language (7.1 Systems & State Space and 7.2 Linear Systems & the Eigenvalue Method) the plant is x˙=Ax+Bu\dot x = Ax + Bu with A=−1/τA = -1/\tau, and feeding back u=−Kxu = -Kx gives Acl=A−BKA_{\text{cl}} = A - BK: the eigenvalue moves by exactly the gain. That is the whole mechanism; lesson 13.6 will do it for matrices.

The lab simulates the loop at K=1,4,9,19K = 1, 4, 9, 19 with the exact plant step yn+1=a yn+(1−a)(un+dn)y_{n+1} = a\,y_n + (1-a)(u_n + d_n), a=e−Δt/τa = e^{-\Delta t/\tau}, Δt=0.01\Delta t = 0.01 s, reference r=1r = 1 from t=0t = 0 and a hill d=−1d = -1 at t=30t = 30 s. Measured values at t=29.99t = 29.99 and 59.9959.99 s:

KKpoleτ/(1+K)\tau/(1+K)error 1/(1+K)1/(1+K)y(29.99)y(29.99)y(59.99)y(59.99)hill dent
11−0.2-0.255 s0.50.50.49880.49880.00120.00120.49750.4975
44−0.5-0.522 s0.20.20.80000.80000.60000.60000.20000.2000
99−1-111 s0.10.10.90000.90000.80000.80000.10000.1000
1919−2-20.50.5 s0.050.050.95000.95000.90000.90000.05000.0500

At K=4K = 4 the speed is 0.79470.7947 at t=10t = 10 s, where open loop managed 0.63210.6321. The time to reach 90%90\% of the final value is τclln⁡10=4.6\tau_{\text{cl}}\ln 10 = 4.6 s against 23.023.0 s open loop.

◆ Interactive The cruise-control loop: slide the gain, the hill, a measurement delay and sensor noise, and watch the response, the command, the sensitivity and the pole

Loading simulation…

Steady-state error and disturbance rejection

Let the loop settle. Setting y˙=0\dot y = 0 in the last equation gives

y∞=K r+d1+K.y_\infty = \frac{K\,r + d}{1+K} .

With d=0d = 0 the speed settles at K/(1+K)K/(1+K) of the reference, so the steady-state error is

e∞=r−y∞=11+K r.e_\infty = r - y_\infty = \frac{1}{1+K}\,r .

Open loop had zero error only because the model was perfect. Closed loop has an error by design, 0.20.2 at K=4K = 4, 0.050.05 at K=19K = 19. And the disturbance enters through P/(1+L)P/(1+L), which at zero frequency is 1/(1+K)1/(1+K): the hill that dented open loop by 11 dents the closed loop by 1/(1+K)1/(1+K), the “hill dent” column. Feedback buys a factor 1+K1+K against disturbances, and against plant changes too.

Notice what feedback did not do. It did not remove the error. No finite KK makes 1/(1+K)1/(1+K) zero. The remedy is to make the controller remember the error (integral action), the subject of 13.3 PID Control. For now, a bare gain trades error for gain, and the cost of gain is the rest of this lesson.

Sensitivity and robustness

How much does feedback protect against a plant that is not what we modelled? Write the reference-to-output transfer function as T=L/(1+L)T = L/(1+L), the complementary sensitivity, and define the sensitivity

S=11+L,S+T=1.S = \frac{1}{1+L}, \qquad S + T = 1 .

Differentiating T=KP/(1+KP)T = KP/(1+KP) with respect to PP gives dT/dP=K/(1+KP)2dT/dP = K/(1+KP)^2, so

dT/TdP/P=KP(1+KP)2⋅1+KPKP=S.\frac{dT/T}{dP/P} = \frac{KP}{(1+KP)^2}\cdot\frac{1+KP}{KP} = S .

A fractional error in the plant arrives at the closed-loop response multiplied by SS. Open loop passes it at full strength. For K=4K = 4 the lab’s ∣S(iω)∣|S(i\omega)| is

ω\omega (rad/s)000.10.10.50.511
∣S∣\lvert S\rvert0.20000.20000.27740.27740.72110.72110.89890.8989
∣T∣\lvert T\rvert0.80000.80000.78450.78450.56570.56570.35780.3578

These come from ∣S(iω)∣=1+ω2τ2 / (1+K)2+ω2τ2|S(i\omega)| = \sqrt{1 + \omega^2\tau^2}\,/\,\sqrt{(1+K)^2 + \omega^2\tau^2}. Feedback is strong at low frequency and weakens as the plant’s lag removes loop gain; beyond about 11 rad/s, well above any speed change a car makes, SS creeps toward 11 and feedback does nothing. The loop is good where LL is large and neutral where it is small.

The cost: noise

The sensor is not ideal. Add noise nn of rms 0.10.1 m/s, uniform and sampled at 2020 Hz (seeded generator, so the run repeats). The transfer function from NN to YY is −T-T: the loop that follows the reference follows the noise, and the command u=K(r−y−n)u = K(r - y - n) carries KK times it. Measured over t∈[10,30]t \in [10, 30] s as the rms difference between the noisy and the clean run:

KKcommand jitterspeed jitter
440.39960.39960.00780.0078
19191.87861.87860.01970.0197

The throttle jitters by about KσK\sigma: 0.400.40 at K=4K = 4 and 1.881.88 at K=19K = 19, against a sensor of 0.10.1. The car, a low-pass filter, barely moves (0.0080.008 and 0.0200.020 m/s). The cost lands on the actuator, whose limits the sim ignores: at K=19K = 19 the opening command is u(0)=19u(0) = 19, nineteen times the open-loop value, and a real throttle saturates long before that.

The cost: delay and the edge of instability

A measurement delay of θ\theta seconds multiplies the loop gain by e−sθe^{-s\theta}: L(s)=Ke−sθ/(τs+1)L(s) = K e^{-s\theta}/(\tau s + 1). A delay adds phase lag proportional to frequency, and nothing in the first-order lag can fight it. Stability is lost when, at some frequency ω\omega, the loop gain reaches magnitude 11 at a phase of −180∘-180^\circ, so that the feedback, meant to be negative, comes back positive. That requires

arctan⁡(τω)+ωθ=π,Kc=1+τ2ω2.\arctan(\tau\omega) + \omega\theta = \pi, \qquad K_c = \sqrt{1 + \tau^2\omega^2} .

For θ=1\theta = 1 s the lab finds ω=1.632\omega = 1.632 rad/s and Kc=16.351K_c = 16.351. Without delay no gain is critical. With θ=0.5\theta = 0.5 s the limit is Kc=32.056K_c = 32.056, and with θ=2\theta = 2 s only 8.5028.502. Running the loop at θ=1\theta = 1 and watching max⁡∣y∣\max|y| over the last 1010 s: at K=14.5K = 14.5 it is 0.89430.8943 (ringing, decaying), at K=16K = 16 it is 1.43391.4339 (barely decaying), at K=18K = 18 it is 78.2578.25 and at K=20K = 20 it is 6496.86496.8.

The sensitivity shows the squeeze before the break. With θ=1\theta = 1 and K=4K = 4 the peak of ∣S∣|S| over 00 to 55 rad/s is 1.3961.396, at ω=1.2\omega = 1.2: disturbances near that frequency are amplified, not rejected. A famous result (from memory, the Bode sensitivity integral) says that for stable loops of this kind the area below ∣S∣=1|S| = 1 is paid for by area above it: pushing SS down at low frequency raises it somewhere else.

Back to the aircraft

12.6 Lateral-Directional Modes built a yaw damper without calling it feedback: the rudder was moved by δr=−Kr\delta_r = -Kr from a rate gyro. That is proportional feedback from a measured state, and the closed loop matrix was Acl=A−K bre3TA_{\text{cl}} = A - K\,\mathbf b_r\mathbf e_3^{\mathsf T}, with Nr→Nr−5.0643KN_r \to N_r - 5.0643K (numbers from that lesson’s sim, not this one). The Dutch roll damping went from ζ=0.2065\zeta = 0.2065 at K=0K = 0 to 0.7330.733 at K=0.5K = 0.5, and the slow spiral root moved from −0.00678-0.00678 to −0.173-0.173: a side effect that fought steady turns. A faster, better-damped mode, bought with a gain, with a cost visible only in what else the feedback touched.

Worked examples

Hill at gain 4. τ=10\tau = 10, K=4K = 4, r=1r = 1, d=−1d = -1 after t=30t = 30. Closed-loop equation: 105y˙=−y+(4r+d)/5\tfrac{10}{5}\dot y = -y + (4r + d)/5. Pole −5/10=−0.5-5/10 = -0.5, τcl=2\tau_{\text{cl}} = 2 s. Before the hill y∞=4/5=0.8y_\infty = 4/5 = 0.8; after it (4−1)/5=0.6(4 - 1)/5 = 0.6. Dent 0.2=1/(1+K)0.2 = 1/(1+K) of the open-loop 11. The table’s K=4K = 4 row agrees: 0.80000.8000 and 0.60000.6000.

Playground: the loop as a simulation

🐍 PythonClosed-loop cruise control: the table of poles and levels
⌘/Ctrl + Enter
🐍 PythonDelay: the same loop with a 1 s measurement delay, below and above the critical gain
⌘/Ctrl + Enter

The exercise

Implement the four formulas of the lesson and test them against the loop.

🧪 Coding exerciseExercise: pole, error, sensitivity and the final speed
⌘/Ctrl + Enter

Concept checks

✅ Concept check

A plant with $\tau = 10$ s is under proportional feedback with $K = 9$. What is the closed-loop time constant in seconds?

✅ Concept check

With $K = 19$ and a unit step reference, what is the steady-state error?

✅ Concept check

Why can a proportional controller never give exactly zero steady-state error on this plant?

✅ Concept checkselect all that apply

Select everything that gets worse as $K$ is raised in the lab.

Problems

✏️ Pen & paperA thermostat●○○

A room has τT˙=−T+u+d\tau\dot T = -T + u + d with τ=20\tau = 20 min, TT the temperature deviation in degrees and uu in degrees of steady temperature. A thermostat applies u=K(r−T)u = K(r - T) with K=9K = 9. Find the closed-loop pole, the time constant, the steady-state error for a 11 degree step in rr, and the change in TT when an open door adds d=−2d = -2.

Show worked solution

The pole is −(1+K)/τ=−10/20=−0.5-(1+K)/\tau = -10/20 = -0.5 per minute, so τcl=2\tau_{\text{cl}} = 2 min. The error is 1/(1+K)=0.11/(1+K) = 0.1 degree. The door changes T∞T_\infty by d/(1+K)=−2/10=−0.2d/(1+K) = -2/10 = -0.2 degree, against −2-2 open loop.

✏️ Pen & paperA speedometer that reads high●●○

The sensor multiplies the output by HH, so e=r−Hye = r - Hy. Show that Y/R=KP/(1+KPH)Y/R = KP/(1 + KPH) and find y∞y_\infty for P(0)=1P(0) = 1, K=9K = 9, H=1.1H = 1.1 and r=1r = 1. Compare with H=1H = 1 and say which speed the controller thinks it has reached.

Show worked solution

From Y=P K(R−HY)Y = P\,K(R - HY), (1+KPH)Y=KPR(1 + KPH)Y = KPR. At s=0s = 0: y∞=9/(1+9.9)=0.8257y_\infty = 9/(1 + 9.9) = 0.8257. With H=1H = 1: 9/10=0.99/10 = 0.9. The measured speed in the first case is 1.1×0.8257=0.90831.1 \times 0.8257 = 0.9083, and the controller sees an error of 1−0.9083=0.0917=1/(1+KH)1 - 0.9083 = 0.0917 = 1/(1 + KH), the usual formula applied to the reading: it works on the reading, not the speed.

✏️ Pen & paperHow much does a wrong plant gain matter?●●●

The true plant has static gain g=0.8g = 0.8 instead of 11: T0(0)=Kg/(1+Kg)T_0(0) = Kg/(1 + Kg). (a) Find the closed-loop final speed for K=4K = 4 and compare the fractional change with the open-loop 20%20\%. (b) Compare with the first-order estimate S δS\,\delta. (c) What KK keeps the closed-loop change under 1%1\%?

Show worked solution

(a) T(0)=3.2/4.2=0.7619T(0) = 3.2/4.2 = 0.7619 against 0.80.8 for g=1g = 1: a change of 4.76%4.76\%. Open loop changes by 20%20\%. (b) S(0)=1/(1+K)=0.2S(0) = 1/(1+K) = 0.2, so the estimate is 0.2×20%=4%0.2 \times 20\% = 4\%; the exact value is a bit larger because SS itself changes as gg moves. (c) The ratio T(g=0.8)/T(g=1)=0.8(1+K)/(1+0.8K)T(g{=}0.8)/T(g{=}1) = 0.8(1+K)/(1+0.8K) must be at least 0.990.99: 0.8+0.8K≥0.99+0.792K0.8 + 0.8K \ge 0.99 + 0.792K, so K≥0.19/0.008=23.75K \ge 0.19/0.008 = 23.75.

✏️ Pen & paperChecking the critical gain by hand●●●

For τ=10\tau = 10 s and θ=1\theta = 1 s verify that ω=1.632\omega = 1.632 rad/s satisfies the phase condition, compute KcK_c, and explain why a first-order plant with no delay is stable for every KK.

Show worked solution

arctan⁡(16.32)=π/2−arctan⁡(1/16.32)=1.5708−0.0612=1.5096\arctan(16.32) = \pi/2 - \arctan(1/16.32) = 1.5708 - 0.0612 = 1.5096, and ωθ=1.632\omega\theta = 1.632: the sum is 3.1416=π3.1416 = \pi. Then Kc=1+16.322=267.3=16.35K_c = \sqrt{1 + 16.32^2} = \sqrt{267.3} = 16.35. Without delay the phase of LL is −arctan⁡(τω)-\arctan(\tau\omega), which never reaches −180∘-180^\circ (its limit is −90∘-90^\circ), so the loop never has a frequency where it turns positive.

What comes next

This lesson used one gain and one pole, and judged the response by looking at plots. The next lesson in the course, 13.2 (13.2 Transfer Functions & Time Response), makes that precise: first- and second-order step responses, rise time, overshoot and settling time, the final value theorem behind the 1/(1+K)1/(1+K) above, and how pole locations map to what a response looks like. A lagging sensor or actuator adds a second pole, the road to the oscillatory instability previewed above.

Key Takeaways

  • Open loop applies a calibrated command and ignores the result; closed loop measures the output, forms the error e=r−ye = r - y, and acts on it. Plant, controller, sensor, reference, error and disturbance are the parts.
  • Block-diagram algebra: boxes in series multiply, a negative loop is forward over one plus loop gain, and Y=L1+LR+P1+LD−L1+LNY = \tfrac{L}{1+L}R + \tfrac{P}{1+L}D - \tfrac{L}{1+L}N with L=KPL = KP.
  • For P=1/(τs+1)P = 1/(\tau s + 1) with gain KK the pole moves from −1/τ-1/\tau to −(1+K)/τ-(1+K)/\tau and the time constant to τ/(1+K)\tau/(1+K) (1010 s to 22 s at K=4K = 4, 11 s at K=9K = 9).
  • The steady-state error is 1/(1+K)1/(1+K) and a constant disturbance is reduced by the same factor (0.20.2 at K=4K = 4, 0.050.05 at K=19K = 19); no finite gain makes the error zero.
  • Sensitivity S=1/(1+L)S = 1/(1+L) and T=L/(1+L)T = L/(1+L) satisfy S+T=1S + T = 1; a fractional plant error reaches the closed loop multiplied by SS, which is small only where the loop gain is large.
  • Costs: sensor noise reaches the command as roughly KσK\sigma (0.400.40 at K=4K = 4, 1.881.88 at K=19K = 19 for σ=0.1\sigma = 0.1), and a measurement delay of 11 s makes the loop unstable above Kc=16.351K_c = 16.351.
  • The yaw damper of 12.6 is the same mechanism in state space, Acl=A−BKA_{\text{cl}} = A - BK (ζ\zeta from 0.20650.2065 to 0.7330.733).
  • Next: 13.2 Transfer Functions & Time Response (13.2) turns the first-order pole picture into time-response specifications and the final value theorem.
Finished this lesson?

Mark it complete to track your progress (saved in this browser). Reading every section does this for you.

Where this leads

These later lessons build directly on this one: