Part III: Analog Electronics | Chapter 8

Operational Amplifiers

The ideal op-amp, golden rules, inverting and non-inverting configurations, summing and difference amplifiers, integrators, and differentiators

1. The Ideal Op-Amp

An operational amplifier is a differential-input, single-output voltage amplifier with very high open-loop gain \( A_{OL} \). The ideal op-amp has three defining properties:

Infinite Open-Loop Gain

\( A_{OL} \to \infty \)

Real: 10⁵–10⁶ V/V

Infinite Input Impedance

\( Z_{in} \to \infty \)

Real: 10⁶–10¹² Ω

Zero Output Impedance

\( Z_{out} = 0 \)

Real: ~75 Ω

The output is: \( V_{out} = A_{OL}(V^+ - V^-) \). With \( A_{OL} \to \infty \), even a microvolt difference drives the output to the supply rail — so op-amps are always used with negative feedback.

2. The Golden Rules of Op-Amp Analysis

When an op-amp is operating in its linear region with negative feedback, two rules simplify analysis:

Rule 1: Virtual Short

The differential input voltage is zero: \( V^+ = V^- \). Feedback forces the inverting input to track the non-inverting input.

Rule 2: No Input Current

Zero current flows into either input: \( I^+ = I^- = 0 \). Follows from infinite input impedance.

These two rules are sufficient to analyze virtually any linear op-amp circuit without knowing the internal architecture. They hold as long as the output is not saturated.

3. Inverting Amplifier

Inverting amplifier: feedback resistor R_f connects output back to inverting input

Applying the golden rules: \( V^- = V^+ = 0 \) (virtual ground), so\( I_{in} = V_{in}/R_{in} \). Since no current enters the op-amp input, this same current flows through \( R_f \):

\[ V_{out} = -\frac{R_f}{R_{in}} V_{in} \]

The gain magnitude is \( |A_v| = R_f/R_{in} \), set entirely by the ratio of two resistors — independent of the op-amp's open-loop gain (as long as it is large).

4. Standard Op-Amp Configurations

Non-Inverting Amplifier

\( V_{out} = \left(1 + \dfrac{R_f}{R_1}\right) V_{in} \)

No phase inversion; input impedance is ideally infinite

Voltage Follower (Buffer)

\( V_{out} = V_{in} \)

Non-inverting with R_f = 0, R_1 = ∞; unity gain, maximum bandwidth

Summing Amplifier

\( V_{out} = -R_f\!\left(\frac{V_1}{R_1}+\frac{V_2}{R_2}+\cdots\right) \)

Weighted sum of multiple inputs — basis of DAC circuits

Integrator

\( V_{out} = -\dfrac{1}{RC}\int V_{in}\,dt \)

Replace R_f with capacitor C; differentiator swaps R and C

5. Python: Op-Amp Circuit Simulations

Simulate: (1) non-inverting amplifier closed-loop gain vs frequency, (2) integrator step response with saturation, and (3) three-input summing amplifier combining 200 Hz, 800 Hz, and 1600 Hz signals.

Python

script.py102 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, 10))
fig.patch.set_facecolor('#0a0a0a')
gs = gridspec.GridSpec(2, 3, figure=fig, hspace=0.5, wspace=0.38)

# --- 1. Inverting amplifier gain vs frequency ---
ax1 = fig.add_subplot(gs[0, :2])
ax1.set_facecolor('#0f0f0f')

f = np.logspace(1, 7, 2000)
A_OL_DC = 1e5          # open-loop DC gain
f_unity  = 1e6         # unity-gain frequency of op-amp (1 MHz GBW)
A_OL = A_OL_DC / (1 + 1j * f * A_OL_DC / f_unity)

configs = [
    ('Non-inv gain=+2',  1/2,   '#34d399'),
    ('Non-inv gain=+5',  1/5,   '#6ee7b7'),
    ('Non-inv gain=+10', 1/10,  '#fbbf24'),
    ('Non-inv gain=+50', 1/50,  '#f87171'),
]

for label, beta, color in configs:
    # Closed-loop: Af = A_OL / (1 + A_OL*beta)
    A_CL = A_OL / (1 + A_OL * beta)
    ax1.semilogx(f, 20*np.log10(np.abs(A_CL)), color=color, linewidth=1.8, label=label)

ax1.semilogx(f, 20*np.log10(np.abs(A_OL)), color='#9ca3af', linewidth=1.2,
             linestyle='--', label='Open-loop A_OL')
ax1.set_xlabel('Frequency (Hz)', color='#9ca3af')
ax1.set_ylabel('Gain (dB)', color='#9ca3af')
ax1.set_title('Op-Amp Closed-Loop Gain vs Frequency (Non-Inverting)', 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')

# --- 2. Integrator step response ---
ax2 = fig.add_subplot(gs[0, 2])
ax2.set_facecolor('#0f0f0f')
t = np.linspace(0, 0.01, 1000)    # 0 to 10 ms
R = 10e3                            # 10 kohm
C = 1e-6                            # 1 uF
tau = R * C                         # 10 ms

# Step input Vin = 1V for t>0, Vout = -1/(RC) * integral(Vin) = -t/RC
# With saturation at +-12 V
Vin_step = np.ones_like(t)
Vin_step[0] = 0
Vout_integrator = -t / tau          # ideal integrator output
Vout_integrator = np.clip(Vout_integrator, -12, 12)

ax2.plot(t * 1000, Vin_step, color='#60a5fa', linewidth=1.8, label='V_in (step)')
ax2.plot(t * 1000, Vout_integrator, color='#34d399', linewidth=2, label='V_out (integrator)')
ax2.axhline(-12, color='#f87171', linewidth=1, linestyle='--', label='Rail = -12V')
ax2.set_xlabel('Time (ms)', color='#9ca3af')
ax2.set_ylabel('Voltage (V)', color='#9ca3af')
ax2.set_title('Integrator Step Response', color='#6ee7b7', fontsize=10)
ax2.legend(fontsize=7, framealpha=0.2)
ax2.tick_params(colors='#9ca3af')
ax2.grid(True, color='#1f2937', alpha=0.6)
for sp in ax2.spines.values(): sp.set_edgecolor('#374151')

# --- 3. Summing amplifier with 3 inputs ---
ax3 = fig.add_subplot(gs[1, :])
ax3.set_facecolor('#0f0f0f')
t2 = np.linspace(0, 0.01, 2000)

V1 = 1.0 * np.sin(2 * np.pi * 200  * t2)     # 200 Hz
V2 = 0.5 * np.sin(2 * np.pi * 800  * t2)     # 800 Hz
V3 = 0.25 * np.sin(2 * np.pi * 1600 * t2)    # 1600 Hz

# Summing amplifier: Vout = -(Rf/R1)*V1 - (Rf/R2)*V2 - (Rf/R3)*V3
# Using Rf=R1=R2=R3=10k => unity weights each
Rf = 10e3; R1 = 10e3; R2 = 10e3; R3 = 10e3
Vout_sum = -(Rf/R1)*V1 - (Rf/R2)*V2 - (Rf/R3)*V3

ax3.plot(t2 * 1000, V1,       color='#60a5fa', linewidth=1.2, alpha=0.7, label='V1: 200 Hz (1.0 V)')
ax3.plot(t2 * 1000, V2,       color='#a78bfa', linewidth=1.2, alpha=0.7, label='V2: 800 Hz (0.5 V)')
ax3.plot(t2 * 1000, V3,       color='#fbbf24', linewidth=1.2, alpha=0.7, label='V3: 1600 Hz (0.25 V)')
ax3.plot(t2 * 1000, Vout_sum, color='#34d399', linewidth=2.2, label='V_out = -(V1+V2+V3)')

ax3.set_xlabel('Time (ms)', color='#9ca3af')
ax3.set_ylabel('Voltage (V)', color='#9ca3af')
ax3.set_title('Summing Amplifier: Three-Input Signal Combination', color='#6ee7b7', fontsize=11)
ax3.legend(fontsize=8, framealpha=0.2)
ax3.tick_params(colors='#9ca3af')
ax3.grid(True, color='#1f2937', alpha=0.6)
for sp in ax3.spines.values(): sp.set_edgecolor('#374151')

plt.suptitle('Operational Amplifier Circuits: Gain, Integration & Summing', color='#6ee7b7', fontsize=13, y=1.01)
plt.savefig('output.png', dpi=130, bbox_inches='tight', facecolor='#0a0a0a')
print('Saved output.png')
print('Op-Amp simulations complete:')
print('  1. Closed-loop gain vs frequency for non-inverting configs')
print('  2. Integrator step response (R=10k, C=1uF, tau=10ms)')
print('  3. Summing amplifier with 3 sinusoidal inputs')

Click Run to execute the Python code

Code will be executed with Python 3 on the server

← Amplifier Fundamentals Next: Feedback & Stability →