Part III: Analog Electronics | Chapter 9

Feedback & Stability

Negative feedback theory, loop gain, closed-loop gain, Barkhausen criterion, Bode stability analysis, gain margin, phase margin, and the Nyquist criterion

1. The Power of Negative Feedback

Negative feedback is the most powerful technique in analog circuit design. By feeding a fraction \( \beta \) of the output back to the input in opposition to the input signal, it simultaneously achieves multiple improvements:

✓Gain stabilized against component variations

✓Bandwidth extended by factor (1 + Aβ)

✓Nonlinearity and distortion reduced

✓Input impedance increased (series feedback)

✓Output impedance reduced (shunt feedback)

✓Noise referred to input may be reduced

The price paid for all these benefits is a reduction in gain by the factor\( (1 + A\beta) \), where \( T = A\beta \) is called the loop gain. When \( T \gg 1 \), the closed-loop gain is determined almost entirely by the passive feedback network.

2. Closed-Loop Gain Formula

Consider a forward amplifier with gain \( A \) and feedback network with factor \( \beta \). At the summing junction:\( \varepsilon = X_{in} - \beta X_{out} \), and\( X_{out} = A\varepsilon \). Solving:

\[ A_f = \frac{A}{1 + A\beta} = \frac{A}{1 + T} \]

When \( T = A\beta \gg 1 \):

\[ A_f \approx \frac{1}{\beta} \]

The closed-loop gain becomes independent of the amplifier gain \( A \) and depends only on the feedback fraction \( \beta \) — set by stable passive components like resistors.

3. Barkhausen Criterion for Oscillation

If the feedback inadvertently becomes positive (loop phase shift = 180°), the system may oscillate. The Barkhausen criterion states that sustained oscillation occurs when the loop gain satisfies both conditions simultaneously:

Magnitude Condition

\( |A\beta| = 1 \)

Phase Condition

\( \angle A\beta = -180° \)

Intentionally designed oscillators (Wien bridge, phase-shift oscillator) use these conditions constructively. In amplifiers, the designer must ensure sufficient gain and phase margins to prevent inadvertent oscillation.

4. Bode Stability: Gain & Phase Margin

Bode stability analysis examines the open-loop transfer function \( T(j\omega) = A(j\omega)\beta \):

Gain Margin (GM)

The additional gain (in dB) needed to bring the system to the edge of instability. Measured at the phase crossover frequency where \( \angle T = -180° \).

\( \text{GM} = -|T(j\omega_{pc})|_{\text{dB}} \)

Phase Margin (PM)

The additional phase lag needed to reach −180°. Measured at the gain crossover frequency where \( |T| = 1 \) (0 dB).

\( \text{PM} = 180° + \angle T(j\omega_{gc}) \)

Practical design rules: GM > 6 dB and PM > 45° for robust stability. PM > 60° gives a well-damped transient response (overshoot < 10%).

5. Python: Bode Plot, Gain & Phase Margin

Plot open-loop vs closed-loop Bode diagrams for a two-pole amplifier (A₀ = 10⁵, poles at 1 kHz and 100 kHz), identify gain and phase crossover frequencies, and show how feedback extends bandwidth.

Python

script.py121 lines

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.gridspec as gridspec

plt.style.use('dark_background')
fig = plt.figure(figsize=(14, 11))
fig.patch.set_facecolor('#0a0a0a')
gs = gridspec.GridSpec(2, 2, figure=fig, hspace=0.48, wspace=0.38)

# Open-loop transfer function: two-pole system
# A(jw) = A0 / ((1 + jw/wp1)(1 + jw/wp2))
A0   = 1e5
wp1  = 2 * np.pi * 1e3    # pole 1 at 1 kHz
wp2  = 2 * np.pi * 1e5    # pole 2 at 100 kHz
f    = np.logspace(1, 8, 3000)
w    = 2 * np.pi * f

def open_loop(w):
    return A0 / ((1 + 1j*w/wp1) * (1 + 1j*w/wp2))

A_OL   = open_loop(w)
mag_OL = 20 * np.log10(np.abs(A_OL))
ph_OL  = np.degrees(np.unwrap(np.angle(A_OL)))

# Closed-loop for several beta values
betas  = [0, 1e-4, 1e-3, 1e-2, 0.1]
labels = ['Open-loop', 'beta=1e-4', 'beta=1e-3', 'beta=0.01', 'beta=0.1']
colors = ['#9ca3af', '#fbbf24', '#34d399', '#60a5fa', '#f87171']

# ---- Plot 1: Magnitude Bode ----
ax1 = fig.add_subplot(gs[0, :])
ax1.set_facecolor('#0f0f0f')
for beta, lbl, col in zip(betas, labels, colors):
    if beta == 0:
        mag = mag_OL
    else:
        A_CL = A_OL / (1 + A_OL * beta)
        mag  = 20 * np.log10(np.abs(A_CL))
    lw = 2.0 if beta > 0 else 1.2
    ls = '--' if beta == 0 else '-'
    ax1.semilogx(f, mag, color=col, linewidth=lw, linestyle=ls, label=lbl)

# Gain margin annotation: find freq where phase = -180 deg
ph_crossings = np.where(np.diff(np.sign(ph_OL + 180)))[0]
if len(ph_crossings) > 0:
    idx_pm = ph_crossings[0]
    f_pc   = f[idx_pm]
    gm_val = -mag_OL[idx_pm]   # how much gain margin in dB
    ax1.axvline(f_pc, color='#a78bfa', linewidth=1, linestyle=':', alpha=0.7)
    ax1.annotate(f'f_pc = {f_pc/1e3:.1f} kHz
GM = {gm_val:.1f} dB',
                 xy=(f_pc, 0), xytext=(f_pc*2, 20),
                 arrowprops=dict(arrowstyle='->', color='#a78bfa'), color='#a78bfa', fontsize=8)

ax1.set_xlabel('Frequency (Hz)', color='#9ca3af')
ax1.set_ylabel('Gain (dB)', color='#9ca3af')
ax1.set_title('Open-Loop vs Closed-Loop Gain — Feedback Extends Bandwidth', color='#6ee7b7', fontsize=11)
ax1.legend(fontsize=8, framealpha=0.2, loc='lower left')
ax1.set_ylim(-10, 110)
ax1.grid(True, color='#1f2937', which='both', alpha=0.6)
ax1.tick_params(colors='#9ca3af')
for sp in ax1.spines.values(): sp.set_edgecolor('#374151')

# ---- Plot 2: Phase Bode ----
ax2 = fig.add_subplot(gs[1, 0])
ax2.set_facecolor('#0f0f0f')
ax2.semilogx(f, ph_OL, color='#34d399', linewidth=2, label='Open-loop phase')
ax2.axhline(-180, color='#f87171', linewidth=1.2, linestyle='--', label='-180 deg (instability)')

# Phase margin: gain crossover frequency (|A_OL| = 0 dB)
gc_crossings = np.where(np.diff(np.sign(mag_OL)))[0]
if len(gc_crossings) > 0:
    idx_gc = gc_crossings[0]
    f_gc   = f[idx_gc]
    pm_val = ph_OL[idx_gc] + 180
    ax2.axvline(f_gc, color='#fbbf24', linewidth=1, linestyle=':', alpha=0.8)
    ax2.annotate(f'f_gc = {f_gc/1e3:.0f} kHz
PM = {pm_val:.1f} deg',
                 xy=(f_gc, ph_OL[idx_gc]), xytext=(f_gc/10, -120),
                 arrowprops=dict(arrowstyle='->', color='#fbbf24'), color='#fbbf24', fontsize=8)

ax2.set_xlabel('Frequency (Hz)', color='#9ca3af')
ax2.set_ylabel('Phase (degrees)', color='#9ca3af')
ax2.set_title('Phase Response & Phase Margin', color='#6ee7b7', fontsize=10)
ax2.legend(fontsize=8, framealpha=0.2)
ax2.tick_params(colors='#9ca3af')
ax2.grid(True, color='#1f2937', which='both', alpha=0.6)
for sp in ax2.spines.values(): sp.set_edgecolor('#374151')

# ---- Plot 3: Bandwidth vs feedback factor ----
ax3 = fig.add_subplot(gs[1, 1])
ax3.set_facecolor('#0f0f0f')
beta_arr  = np.logspace(-6, 0, 200)
# For single-pole: CL gain = A0/(1+A0*beta), CL BW = wp1*(1+A0*beta)
f_p1      = wp1 / (2 * np.pi)
CL_gain   = A0 / (1 + A0 * beta_arr)
CL_BW     = f_p1 * (1 + A0 * beta_arr)

ax3_2 = ax3.twinx()
l1, = ax3.semilogx(beta_arr, 20*np.log10(CL_gain), color='#34d399', linewidth=2, label='Closed-loop gain (dB)')
l2, = ax3_2.semilogx(beta_arr, CL_BW / 1e3, color='#fbbf24', linewidth=2, label='Bandwidth (kHz)')

ax3.set_xlabel('Feedback factor beta', color='#9ca3af')
ax3.set_ylabel('Gain (dB)', color='#34d399')
ax3_2.set_ylabel('Bandwidth (kHz)', color='#fbbf24')
ax3.set_title('Gain-BW Trade-off vs Feedback Factor', color='#6ee7b7', fontsize=10)
ax3.tick_params(colors='#9ca3af')
ax3_2.tick_params(colors='#fbbf24')
ax3.grid(True, color='#1f2937', which='both', alpha=0.6)
for sp in ax3.spines.values(): sp.set_edgecolor('#374151')
lines = [l1, l2]
ax3.legend(lines, [l.get_label() for l in lines], fontsize=7, framealpha=0.2)

plt.suptitle('Feedback & Stability: Bode Analysis, Gain/Phase Margins', color='#6ee7b7', fontsize=13, y=1.01)
plt.savefig('output.png', dpi=130, bbox_inches='tight', facecolor='#0a0a0a')
print('Saved output.png')
print('Two-pole open-loop system:')
print(f'  A0 = {A0:.0e}  ({20*np.log10(A0):.0f} dB)')
print(f'  Pole 1: {wp1/(2*np.pi):.0f} Hz')
print(f'  Pole 2: {wp2/(2*np.pi):.0f} Hz')

Click Run to execute the Python code

Code will be executed with Python 3 on the server

← Op-Amps Next: Boolean Logic →