Stability augmentation

Sam's level 2 rating for instrument approaches in turbulence leaves the team two options. They could enlarge the fin and rudder, adding weight and drag on every flight and, as Lesson 8 showed, making the spiral less stable. Or they could add a yaw damper: a small servo that moves the rudder in proportion to yaw rate, adding yaw damping electronically. Hélène Lavoie, the flight controls lead, argues for the second, and most turboprop commuters agree with her. This lesson explains how stability augmentation works, designs the Tern's yaw damper with a simple root locus, and shows why the yaw rate signal must pass through a washout filter.

Feedback changes the derivatives

A stability augmentation system, or SAS, feeds back a measured motion variable to a control surface to change the aircraft's apparent stability derivatives. Feeding yaw rate to the rudder, \(\delta_r = K r\), adds a yawing moment \(N_{\delta_r}K r\), so the effective yaw damping becomes

With \(N_{\delta_r}\) negative for the Tern's sign convention, a positive gain makes \(N_r'\) more negative: more yaw damping, exactly as if the fin had grown. In the same way, pitch rate fed to the elevator adds pitch damping (a pitch damper), roll rate fed to the ailerons adds roll damping, and angle of attack fed to the elevator adds pitch stiffness. Augmentation of stiffness, as opposed to damping, is the basis of the relaxed-stability fly-by-wire aircraft of Lesson 12.

An SAS differs from an autopilot in its purpose. An autopilot holds a heading or altitude chosen by the pilot. An SAS only changes how the aircraft responds; the pilot still flies it, and the SAS works alongside the pilot's inputs. Because it acts only on rates and does not command an attitude, a stability augmentation system usually has limited authority, a few degrees of rudder in the Tern's case, so that a failure, such as a servo moving to full deflection, can be overpowered by the pilot or tolerated safely. That limited authority is central to the safety assessment that Transport Canada will review.

Root locus design

The effect of the gain is easiest to see on a root locus: a plot of how the closed-loop eigenvalues move in the complex plane as the gain rises from zero. At zero gain the roots are the open-loop modes of Lesson 8. As gain rises, the Dutch roll pair moves left, away from the imaginary axis, and its damping ratio rises. Eventually, at high gain, the pair bends back toward the real axis as the rudder feedback starts to interact with the other modes and with the filter introduced below. The designer picks the gain that gives the wanted damping with some margin either side, and checks that the other modes are not harmed.

# Yaw damper for the Tern Block 2: rudder driven by washed-out yaw rate. Find how the gain
# moves the Dutch roll and spiral roots, and what the washout does in a steady turn.
import math
def charpoly(A):
    """Coefficients of det(sI - A), highest power first (Faddeev-LeVerrier)."""
    n = len(A); M = [[0.0] * n for _ in range(n)]; c = [1.0]
    I = [[1.0 if i == j else 0.0 for j in range(n)] for i in range(n)]
    for k in range(1, n + 1):
        AM = [[sum(A[i][l] * M[l][j] for l in range(n)) for j in range(n)] for i in range(n)]
        M = [[AM[i][j] + c[-1] * I[i][j] for j in range(n)] for i in range(n)]
        AM = [[sum(A[i][l] * M[l][j] for l in range(n)) for j in range(n)] for i in range(n)]
        c.append(-sum(AM[i][i] for i in range(n)) / k)
    return c

def roots(c, it=500):
    """All roots of a polynomial by the Durand-Kerner iteration."""
    n = len(c) - 1; a = [x / c[0] for x in c]
    z = [complex(0.4, 0.9) ** k for k in range(n)]
    for _ in range(it):
        new = []
        for i in range(n):
            p = sum(a[k] * z[i] ** (n - k) for k in range(n + 1))
            d = 1
            for j in range(n):
                if j != i: d *= (z[i] - z[j])
            new.append(z[i] - p / d)
        z = new
    return sorted(z, key=lambda r: -abs(r))

def describe(s):
    import math
    if abs(s.imag) < 1e-6:
        t = -1 / s.real if s.real < 0 else 1 / s.real
        kind = 'time constant' if s.real < 0 else 'doubles every'
        val = t if s.real < 0 else math.log(2) / s.real
        return f"real root {s.real:+.4f}: {kind} {val:.2f} s"
    wn = abs(s); z = -s.real / wn
    return f"pair {s.real:+.4f} +/- {abs(s.imag):.4f}j: wn {wn:.3f} rad/s, zeta {z:.3f}, period {2*math.pi/abs(s.imag):.1f} s"

m, Ixx, Izz, S, b, g, rho, u0 = 6500.0, 30000.0, 52000.0, 28.0, 17.0, 9.81, 0.909, 105.0
QS = 0.5 * rho * u0 ** 2 * S; k = b / (2 * u0)
Yb = -0.75 * QS / m
Lb, Lp, Lr = -0.099 * QS * b / Ixx, -0.50 * k * QS * b / Ixx, 0.120 * k * QS * b / Ixx
Nb, Np, Nr = 0.109 * QS * b / Izz, -0.040 * k * QS * b / Izz, -0.130 * k * QS * b / Izz
Ldr, Ndr, Ydr = 0.010 * QS * b / Ixx, -0.070 * QS * b / Izz, 0.17 * QS / m
tw = 1.5                                   # washout time constant, s
def closed(K, washout=True):
    # states [beta, p, r, phi, z]; z is the washout filter state, rudder = K*(r - z)
    if washout:
        A = [[Yb / u0, 0, -1 + Ydr / u0 * K, g / u0, -Ydr / u0 * K],
             [Lb, Lp, Lr + Ldr * K, 0, -Ldr * K],
             [Nb, Np, Nr + Ndr * K, 0, -Ndr * K],
             [0, 1, 0, 0, 0],
             [0, 0, 1 / tw, 0, -1 / tw]]
    else:
        A = [[Yb / u0, 0, -1 + Ydr / u0 * K, g / u0],
             [Lb, Lp, Lr + Ldr * K, 0], [Nb, Np, Nr + Ndr * K, 0], [0, 1, 0, 0]]
    return roots(charpoly(A))
print(" gain K (deg rudder per deg/s)   Dutch roll wn, zeta     spiral root")
for K in (0.0, 0.2, 0.4, 0.6, 0.8, 1.0):
    r = closed(K)
    dr = max([s for s in r if s.imag > 1e-6], key=lambda s: s.imag)
    real = [s.real for s in r if abs(s.imag) < 1e-6]
    sp = min(real, key=abs)
    print(f"        {K:4.1f}                     {abs(dr):.2f}, {-dr.real/abs(dr):.3f}          {sp:+.4f}")
K = 0.6
r = closed(K, washout=False)
dr = max([s for s in r if s.imag > 1e-6], key=lambda s: s.imag)
sp = min([s.real for s in r if abs(s.imag) < 1e-6], key=abs)
print(f"\nwithout washout, K = {K}: Dutch roll zeta {-dr.real/abs(dr):.3f}, spiral root {sp:+.4f}")
# steady 25 deg banked turn at u0: yaw rate r = g tan(phi)/u0
r_turn = g * math.tan(25 / 57.3) / u0
print(f"steady turn yaw rate {r_turn*57.3:.2f} deg/s: rudder opposing the turn without washout {K*r_turn*57.3:.1f} deg")
print(f"with washout (tau {tw} s) the steady rudder decays to zero: after 3 tau, {K*r_turn*57.3*math.exp(-3):.2f} deg")

 gain K (deg rudder per deg/s)   Dutch roll wn, zeta     spiral root
         0.0                     2.34, 0.113          +0.0003
         0.2                     2.25, 0.242          +0.0003
         0.4                     2.12, 0.379          +0.0003
         0.6                     1.92, 0.527          +0.0003
         0.8                     1.56, 0.658          +0.0003
         1.0                     1.23, 0.642          +0.0003

without washout, K = 0.6: Dutch roll zeta 0.512, spiral root -0.0661
steady turn yaw rate 2.50 deg/s: rudder opposing the turn without washout 1.5 deg
with washout (tau 1.5 s) the steady rudder decays to zero: after 3 tau, 0.07 deg

The gain sweep shows the Dutch roll damping ratio rising from 0.113 with no damper to 0.242, 0.379 and 0.527 at gains of 0.2, 0.4 and 0.6 degrees of rudder per degree per second of yaw rate. At 0.8 the damping ratio peaks at about 0.66 while the frequency falls sharply, and at 1.0 the damping begins to fall again. Hélène picks 0.6, which gives a damping ratio of 0.53 at a natural frequency of 1.92 rad/s, far above the level 1 minimum and comfortably short of the turning point. The roll mode is barely affected, and the spiral root, almost at the origin, does not move.

Why the washout filter is needed

A plain yaw rate damper has a flaw. In a steady coordinated turn the aircraft yaws continuously at the turn rate. A damper fed with raw yaw rate cannot tell the steady turn from a Dutch roll oscillation and applies rudder to oppose it, so the pilot must hold opposite rudder to keep the ball centred. For the Tern at 25 degrees of bank and cruise speed, the yaw rate is 2.5 degrees per second and the plain damper would hold 1.5 degrees of rudder against the turn, a force pilots notice and dislike.

The fix is a washout filter, a high-pass filter with transfer function \(\tau_w s/(\tau_w s + 1)\). It passes the oscillating yaw rate of the Dutch roll, whose period is under 3 seconds, almost unchanged, but gradually removes any steady yaw rate. With \(\tau_w = 1.5\) s the damper's steady rudder in a turn decays to under 5 percent within 4.5 seconds, and the pilot feels nothing. The cost is visible in the program: without washout the damper also stabilizes the spiral strongly, moving its root to −0.066, because it damps every yaw rate. With washout, the spiral returns to almost neutral. Designers choose the time constant as a compromise, long enough not to rob the Dutch roll of damping and short enough not to fight turns.

Implementation and safety

The Tern's yaw damper uses yaw rate from the attitude and heading reference system, a small electric servo connected to the rudder control circuit through a clutch, and a computer that runs the filter and gain at about 50 times per second. Its authority is limited to about 5 degrees of rudder, and the clutch can be overpowered by the pilot. The damper is engaged after take-off and disengaged before touchdown, because some rudder movement from the damper in the flare would be unwelcome; on the Tern it stays engaged on approach, where Sam's complaint arose, and disengages automatically below a set radio altitude. The safety assessment considers failures such as a hard-over servo, an oscillating servo and loss of the rate signal, and shows that each is either controllable with normal pilot skill or extremely improbable.

Pitch dampers follow the same pattern. Many jets have one to restore short-period damping at high altitude, where Lesson 7 showed that aerodynamic damping falls. The Swift 900 study of Lesson 12 goes further, replacing mechanical controls with a full-authority system, but the basic idea of feeding back rates to change the aircraft's apparent dynamics is the same.