Part I: Circuit Fundamentals | Chapter 2

RC, RL & RLC Circuits

Transient analysis: time constants, step responses, and oscillatory behaviour in reactive networks.

Reactive Elements: Capacitors & Inductors

Unlike resistors, capacitors and inductors store energy and introduce memory into circuits — their behaviour depends on the history of voltage or current, making the governing equations differential rather than algebraic.

Capacitor

Current is proportional to the rate of change of voltage:

\[ i = C \frac{dv}{dt} \]

Stores energy in the electric field: \( E = \tfrac{1}{2}CV^2 \). Cannot change voltage instantaneously.

Inductor

Voltage is proportional to the rate of change of current:

\[ v = L \frac{di}{dt} \]

Stores energy in the magnetic field: \( E = \tfrac{1}{2}LI^2 \). Cannot change current instantaneously.

First-Order Circuits: RC and RL

A series RC circuit driven by a step voltage \( V_s \) (switch closed at \( t=0 \)) obeys:

\[ RC \frac{dv_C}{dt} + v_C = V_s \implies v_C(t) = V_s\!\left(1 - e^{-t/\tau}\right),\quad \tau = RC \]

The time constant \( \tau = RC \) determines how quickly the capacitor charges. After one time constant the voltage reaches 63.2 % of its final value; after \( 5\tau \) it is within 1 % of \( V_s \).

Analogously, for a series RL circuit the time constant is:

\[ \tau = \frac{L}{R}, \qquad i_L(t) = \frac{V_s}{R}\!\left(1 - e^{-t/\tau}\right) \]

Natural and Forced Responses

Any first-order response splits into a natural (homogeneous) response that decays exponentially and a forced (particular) response that matches the driving source at steady state:

\[ x(t) = x_{\text{forced}} + \bigl(x(0) - x_{\text{forced}}\bigr)\,e^{-t/\tau} \]

Second-Order Circuits: RLC

A series RLC circuit driven by a voltage step satisfies the second-order ODE:

\[ L\frac{d^2i}{dt^2} + R\frac{di}{dt} + \frac{i}{C} = \frac{dV_s}{dt} \]

The characteristic equation \( s^2 + 2\alpha s + \omega_0^2 = 0 \) has parameters:

Resonant frequency

\[ \omega_0 = \frac{1}{\sqrt{LC}} \]

Damping coefficient

\[ \alpha = \frac{R}{2L} \]

Damping ratio

\[ \zeta = \frac{\alpha}{\omega_0} = \frac{R}{2}\sqrt{\frac{C}{L}} \]

Three Damping Regimes

Underdamped (\(\zeta < 1\))

Oscillates and decays. Damped frequency \(\omega_d = \sqrt{\omega_0^2 - \alpha^2}\). Fast settling but with overshoot.

Critically damped (\(\zeta = 1\))

Fastest possible settling without oscillation. \( R_c = 2\sqrt{L/C} \). Ideal for many control applications.

Overdamped (\(\zeta > 1\))

Two real negative poles; exponential decay without oscillation, but slower than critically damped.

Quality Factor Q

The quality factor measures how underdamped the resonator is — the ratio of energy stored to energy dissipated per cycle:

\[ Q = \frac{\omega_0 L}{R} = \frac{1}{R}\sqrt{\frac{L}{C}} = \frac{1}{2\zeta} \]

High-Q circuits (small R) ring for many cycles; low-Q circuits are heavily damped. Q also equals the ratio of resonant frequency to bandwidth: \( Q = \omega_0 / \Delta\omega \).

Python: RC & RLC Transient Simulation

Simulate RC charging and discharging, then compute and plot the exact RLC step response for all three damping regimes using analytical solutions derived from the characteristic equation.

RC Charging/Discharging & RLC Damping Regimes

Python

rc_rl_rlc.py122 lines

import numpy as np
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

# ---- RC charging / discharging ----
R = 1000.0   # 1 kOhm
C = 100e-6   # 100 uF
tau_RC = R * C
Vs = 5.0     # step voltage

t = np.linspace(0, 5*tau_RC, 1000)
V_charge   = Vs * (1 - np.exp(-t / tau_RC))
V_discharge = Vs * np.exp(-t / tau_RC)
I_charge   = (Vs / R) * np.exp(-t / tau_RC)   # mA
I_discharge = -(Vs / R) * np.exp(-t / tau_RC)

print('=== RC Circuit ===')
print(f'R = {R:.0f} Ohm, C = {C*1e6:.0f} uF')
print(f'tau = RC = {tau_RC*1000:.2f} ms')
print(f'V at t=tau  (charge):    {Vs*(1-np.exp(-1)):.4f} V  (63.2% of Vs)')
print(f'V at t=5tau (charge):    {Vs*(1-np.exp(-5)):.4f} V  (~99.3% of Vs)')

# ---- RLC step response: three damping cases ----
L = 10e-3    # 10 mH
C2 = 100e-9  # 100 nF
Vs2 = 1.0    # step amplitude
omega_0 = 1.0 / np.sqrt(L * C2)
print()
print('=== RLC Circuit ===')
print(f'L = {L*1e3:.1f} mH, C = {C2*1e9:.1f} nF')
print(f'omega_0 = {omega_0:.2f} rad/s = {omega_0/(2*np.pi):.2f} Hz')

# Critical damping: R_c = 2*sqrt(L/C)
R_crit = 2 * np.sqrt(L / C2)
R_under = R_crit * 0.1   # underdamped (low resistance)
R_over  = R_crit * 5.0   # overdamped  (high resistance)
print(f'R_crit = {R_crit:.2f} Ohm')
print(f'R_under = {R_under:.2f} Ohm  (zeta = {R_under/(2*np.sqrt(L/C2)):.3f})')
print(f'R_over  = {R_over:.2f} Ohm   (zeta = {R_over/(2*np.sqrt(L/C2)):.3f})')

t2 = np.linspace(0, 10 / omega_0, 2000)

def rlc_step(R_val, L_val, C_val, Vs_val, t_arr):
    'Solve series RLC step response using exact analytical solution.'
    alpha = R_val / (2 * L_val)
    omega0 = 1.0 / np.sqrt(L_val * C_val)
    d2 = omega0**2 - alpha**2
    if d2 > 0:
        # Underdamped
        omega_d = np.sqrt(d2)
        A = -Vs_val
        B = -alpha * Vs_val / omega_d
        return Vs_val + np.exp(-alpha * t_arr) * (A * np.cos(omega_d * t_arr) + B * np.sin(omega_d * t_arr))
    elif d2 < 0:
        # Overdamped
        s1 = -alpha + np.sqrt(alpha**2 - omega0**2)
        s2 = -alpha - np.sqrt(alpha**2 - omega0**2)
        A = Vs_val * s2 / (s2 - s1)
        B = -Vs_val * s1 / (s2 - s1)
        return Vs_val + A * np.exp(s1 * t_arr) + B * np.exp(s2 * t_arr)
    else:
        # Critically damped
        return Vs_val * (1 - (1 + alpha * t_arr) * np.exp(-alpha * t_arr))

V_under = rlc_step(R_under, L, C2, Vs2, t2)
V_crit  = rlc_step(R_crit,  L, C2, Vs2, t2)
V_over  = rlc_step(R_over,  L, C2, Vs2, t2)

# ---- Plots ----
fig, axes = plt.subplots(1, 3, figsize=(16, 5))
fig.patch.set_facecolor('#0a0a0a')
for ax in axes:
    ax.set_facecolor('#111827')
    for spine in ax.spines.values():
        spine.set_color('#374151')

# Plot 1: RC charge / discharge
ax = axes[0]
t_ms = t * 1000
ax.plot(t_ms, V_charge,    color='#34d399', lw=2.2, label='Charging')
ax.plot(t_ms, V_discharge, color='#f87171', lw=2.2, label='Discharging', ls='--')
ax.axvline(tau_RC*1000, color='#fbbf24', ls=':', lw=1.5, label=f'tau = {tau_RC*1000:.1f} ms')
ax.set_xlabel('Time (ms)', color='#9ca3af')
ax.set_ylabel('Voltage (V)', color='#9ca3af')
ax.set_title('RC Charge / Discharge', color='#d1d5db', fontsize=12, pad=10)
ax.tick_params(colors='#9ca3af')
ax.legend(fontsize=8, facecolor='#1f2937', edgecolor='#374151', labelcolor='#d1d5db')
ax.grid(True, color='#1f2937', alpha=0.8)

# Plot 2: RLC step response
ax = axes[1]
t_us = t2 * 1e6
ax.plot(t_us, V_under, color='#34d399', lw=2.2, label=f'Underdamped (zeta={R_under/R_crit:.2f})')
ax.plot(t_us, V_crit,  color='#fbbf24', lw=2.2, label='Critically damped (zeta=1)')
ax.plot(t_us, V_over,  color='#f87171', lw=2.2, label=f'Overdamped (zeta={R_over/R_crit:.1f})')
ax.axhline(Vs2, color='#6b7280', ls=':', lw=1, label='Final value')
ax.set_xlabel('Time (us)', color='#9ca3af')
ax.set_ylabel('Voltage (V)', color='#9ca3af')
ax.set_title('RLC Step Response', color='#d1d5db', fontsize=12, pad=10)
ax.tick_params(colors='#9ca3af')
ax.legend(fontsize=7, facecolor='#1f2937', edgecolor='#374151', labelcolor='#d1d5db')
ax.grid(True, color='#1f2937', alpha=0.8)

# Plot 3: RC current
ax = axes[2]
ax.plot(t_ms, I_charge*1000,    color='#34d399', lw=2.2, label='Charge current')
ax.plot(t_ms, I_discharge*1000, color='#f87171', lw=2.2, ls='--', label='Discharge current')
ax.axhline(0, color='#6b7280', lw=0.8)
ax.axvline(tau_RC*1000, color='#fbbf24', ls=':', lw=1.5, label=f'tau = {tau_RC*1000:.1f} ms')
ax.set_xlabel('Time (ms)', color='#9ca3af')
ax.set_ylabel('Current (mA)', color='#9ca3af')
ax.set_title('RC Charging Current', color='#d1d5db', fontsize=12, pad=10)
ax.tick_params(colors='#9ca3af')
ax.legend(fontsize=8, facecolor='#1f2937', edgecolor='#374151', labelcolor='#d1d5db')
ax.grid(True, color='#1f2937', alpha=0.8)

plt.tight_layout(pad=2.0)
plt.savefig('output.png', dpi=140, bbox_inches='tight', facecolor='#0a0a0a')
print()
print('Plot saved to output.png')

Click Run to execute the Python code

Code will be executed with Python 3 on the server

← Ohm & Kirchhoff Next: AC & Phasors →