Part VI · Chapter 18

Motor Drives

DC motor models, H-bridge circuits, PWM speed control, brushless DC motors, 3-phase inverters, and field-oriented control — converting electrical power to precisely controlled mechanical motion.

1. DC Motor Electrical Model

A brushed DC motor is modeled as a resistor, inductor, and back-EMF voltage source in series. The armature circuit equation is:

\[ V = I_a R_a + L_a \frac{di_a}{dt} + K_e\,\omega \]

\(K_e\omega\) = back-EMF (opposes increasing speed); \(K_e\) = back-EMF constant (V·s/rad)

The mechanical equation relates electromagnetic torque to shaft dynamics:

\[ J\frac{d\omega}{dt} = T_{em} - B\omega - T_{load} \qquad T_{em} = K_t\,I_a \]

For ideal motor: \(K_t = K_e\) (same constant, SI units). Steady-state speed: \(\omega_{ss} = (V - I_{a,ss} R_a)/K_e\)

Speed regulation is the fractional speed drop from no-load to full-load: \(SR = (\omega_{NL} - \omega_{FL})/\omega_{FL}\). Small \(R_a\)gives good regulation. The mechanical time constant is \(\tau_m = J R_a / (K_e K_t)\), and electrical time constant \(\tau_e = L_a / R_a\).

2. H-Bridge — Bidirectional Control

An H-bridge uses four switches (MOSFETs) to apply positive or negative voltage to the motor, enabling forward, reverse, and braking. It is named for its circuit topology resembling the letter H.

Dead time must be inserted between turning one switch OFF and the complementary switch ON to prevent shoot-through (simultaneous conduction of top and bottom switches, which would short the supply). Typical dead time: 50–200 ns.

3. PWM Speed Control

Pulse-width modulation (PWM) varies the average voltage applied to the motor by switching rapidly between full supply and zero. The average voltage is:

\[ \langle V \rangle = D \cdot V_{supply} \]

\(D\) = duty cycle (0 to 1). Switching frequency typically 10–50 kHz for motors.

The motor inductance \(L_a\) acts as a low-pass filter — at sufficiently high switching frequency, the current ripple is negligible and the motor responds to the average voltage. The current ripple is \(\Delta I_a = V_{supply}\,D(1-D)/(f_{sw}\,L_a)\).

Sign-Magnitude PWM

Direction set by sign of command. Magnitude sets duty cycle. Simple control, but current can become discontinuous near zero speed.

Locked Anti-Phase PWM

D = 50% = zero, D > 50% = forward, D < 50% = reverse. Continuous current (both polarities available). Better for smooth low-speed control.

4. Brushless DC Motors & 3-Phase Inverters

Brushless DC (BLDC) motors replace mechanical commutation (brushes and commutator) with electronic commutation. The stator has three-phase windings; the rotor has permanent magnets. A 3-phase inverter (6 switches) creates the rotating magnetic field:

\[ v_a = V_{dc} \sin(\theta) \qquad v_b = V_{dc}\sin(\theta - 120°) \qquad v_c = V_{dc}\sin(\theta + 120°) \]

6-Step (Trapezoidal) Commutation

Commutate every 60° using Hall-effect sensors. Simple, efficient. Produces torque ripple due to step transitions.

Sinusoidal (FOC)

Field-Oriented Control (vector control) injects sinusoidal currents. Minimal torque ripple, excellent efficiency. Requires encoder/resolver. Used in servo drives, EV traction motors.

V/f Control for Induction Motors

Induction motors run from the AC grid. Speed is controlled by varying frequency with a variable-frequency drive (VFD). To maintain constant flux, the voltage-to-frequency ratio is kept constant: \(V/f = \text{const}\). For example, if rated at 400 V / 50 Hz, running at 25 Hz requires 200 V. Above rated frequency, the voltage is held at rated and the motor operates in flux-weakening (field-weakening) mode.

5. Field-Oriented Control (FOC)

FOC transforms the 3-phase AC quantities into a rotating d-q reference frame aligned with the rotor flux. In this frame, the flux-producing component \(i_d\) and torque-producing component \(i_q\) can be controlled independently — just like in a separately-excited DC motor.

Measure i_a, i_b→Clarke (αβ)→Park (dq)→PI Controllers→Inv. Park→SVPWM→Inverter

For maximum torque per ampere, set \(i_d^* = 0\) (IPMSM adds reluctance torque). The torque command \(T^* = \tfrac{3}{2}p\,\lambda_r\,i_q^*\) where \(p\)is pole pairs and \(\lambda_r\) is rotor flux linkage. FOC enables smooth torque from zero speed and is the standard for EV motors, CNC machines, and industrial servo drives.

Python Simulation

DC motor speed and current responses at different PWM duty cycles, steady-state speed vs duty cycle (theory vs simulation), torque-speed characteristics, power analysis, and load-step response.

Python

script.py185 lines

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

plt.style.use('dark_background')
fig = plt.figure(figsize=(14, 12), facecolor='#0a0a0a')
gs = gridspec.GridSpec(3, 2, figure=fig, hspace=0.5, wspace=0.4)

# DC Motor parameters
R_a = 1.0      # armature resistance (Ohm)
L_a = 5e-3     # armature inductance (H)
K_e = 0.1      # back-EMF constant (V.s/rad)
K_t = 0.1      # torque constant (N.m/A)
J = 0.01       # rotor inertia (kg.m^2)
B = 0.005      # friction coefficient (N.m.s/rad)
T_load = 0.05  # constant load torque (N.m)

V_supply = 24.0  # DC supply voltage

dt = 1e-4       # 0.1 ms time step
T_sim = 1.0     # 1 second simulation
t = np.arange(0, T_sim, dt)
N = len(t)

def simulate_motor(D, V_supply, R_a, L_a, K_e, K_t, J, B, T_load, dt, N):
    V_in = D * V_supply   # effective voltage via PWM
    i_a = 0.0; omega = 0.0
    i_arr = np.zeros(N); omega_arr = np.zeros(N)
    for k in range(N):
        back_emf = K_e * omega
        v_L = V_in - R_a * i_a - back_emf
        i_a = i_a + v_L * dt / L_a
        i_a = max(0.0, i_a)   # diode clamp (no regen)
        T_em = K_t * i_a
        domega = (T_em - B * omega - T_load) / J
        omega = max(0.0, omega + domega * dt)
        i_arr[k] = i_a
        omega_arr[k] = omega
    return i_arr, omega_arr

# ── Plot 1: Speed vs time for different duty cycles ───────────────────
ax1 = fig.add_subplot(gs[0, 0])
D_list = [0.3, 0.5, 0.7, 1.0]
colors_d = ['#f87171', '#fbbf24', '#34d399', '#38bdf8']
for D, col in zip(D_list, colors_d):
    i_arr, omega_arr = simulate_motor(D, V_supply, R_a, L_a, K_e, K_t, J, B, T_load, dt, N)
    rpm = omega_arr * 60 / (2 * np.pi)
    ax1.plot(t, rpm, color=col, lw=1.5, label=f'D={D}  ({rpm[-1]:.0f} RPM)')
ax1.set_title('DC Motor Speed vs PWM Duty Cycle', color='#34d399', fontsize=11)
ax1.set_xlabel('Time (s)', color='#9ca3af', fontsize=9)
ax1.set_ylabel('Speed (RPM)', color='#9ca3af', fontsize=9)
ax1.tick_params(colors='#6b7280', labelsize=8)
ax1.legend(fontsize=8, facecolor='#111', edgecolor='#374151', labelcolor='#d1d5db')
ax1.set_facecolor('#0f0f0f')
for sp in ax1.spines.values(): sp.set_edgecolor('#374151')

# ── Plot 2: Armature current vs time ─────────────────────────────────
ax2 = fig.add_subplot(gs[0, 1])
for D, col in zip(D_list, colors_d):
    i_arr, _ = simulate_motor(D, V_supply, R_a, L_a, K_e, K_t, J, B, T_load, dt, N)
    ax2.plot(t, i_arr, color=col, lw=1.5, label=f'D={D}')
ax2.set_title('Armature Current vs Duty Cycle', color='#34d399', fontsize=11)
ax2.set_xlabel('Time (s)', color='#9ca3af', fontsize=9)
ax2.set_ylabel('I_a (A)', color='#9ca3af', fontsize=9)
ax2.tick_params(colors='#6b7280', labelsize=8)
ax2.legend(fontsize=8, facecolor='#111', edgecolor='#374151', labelcolor='#d1d5db')
ax2.set_facecolor('#0f0f0f')
for sp in ax2.spines.values(): sp.set_edgecolor('#374151')

# ── Plot 3: Steady-state speed vs duty cycle ──────────────────────────
ax3 = fig.add_subplot(gs[1, 0])
D_range = np.linspace(0, 1.0, 50)
ss_rpm = []
for D in D_range:
    i_arr, omega_arr = simulate_motor(D, V_supply, R_a, L_a, K_e, K_t, J, B, T_load, dt, N)
    ss_rpm.append(omega_arr[-1] * 60 / (2 * np.pi))
# Theoretical steady-state: omega = (D*V - I_ss*R_a) / K_e
# I_ss = (T_load + B*omega_ss) / K_t  -> solve quadratic
omega_theory = []
for D in D_range:
    V = D * V_supply
    # (D*V - R_a*(T_load + B*omega)/K_t) / K_e = omega
    # K_e*omega + R_a*B*omega/K_t = V - R_a*T_load/K_t
    denom = K_e + R_a * B / K_t
    omega_ss = (V - R_a * T_load / K_t) / denom
    omega_theory.append(max(0, omega_ss * 60 / (2 * np.pi)))

ax3.plot(D_range, ss_rpm, 'o', color='#f87171', ms=4, label='Simulated SS')
ax3.plot(D_range, omega_theory, color='#34d399', lw=2, label='Theoretical')
ax3.set_title('Steady-State Speed vs Duty Cycle', color='#34d399', fontsize=11)
ax3.set_xlabel('Duty Cycle D', color='#9ca3af', fontsize=9)
ax3.set_ylabel('Speed (RPM)', color='#9ca3af', fontsize=9)
ax3.tick_params(colors='#6b7280', labelsize=8)
ax3.legend(fontsize=8, facecolor='#111', edgecolor='#374151', labelcolor='#d1d5db')
ax3.set_facecolor('#0f0f0f')
for sp in ax3.spines.values(): sp.set_edgecolor('#374151')

# ── Plot 4: Torque-speed characteristic ──────────────────────────────
ax4 = fig.add_subplot(gs[1, 1])
D_ts_list = [0.4, 0.6, 0.8, 1.0]
colors_ts = ['#f87171', '#fbbf24', '#34d399', '#38bdf8']
T_load_range = np.linspace(0, 0.5, 200)
for D, col in zip(D_ts_list, colors_ts):
    V = D * V_supply
    # For each torque: I_a = T/K_t, omega = (V - R_a*I_a)/K_e
    I_a_ts = T_load_range / K_t
    omega_ts = np.maximum(0, (V - R_a * I_a_ts) / K_e)
    rpm_ts = omega_ts * 60 / (2 * np.pi)
    ax4.plot(T_load_range, rpm_ts, color=col, lw=2, label=f'D={D}')
ax4.set_title('Torque-Speed Characteristics', color='#34d399', fontsize=11)
ax4.set_xlabel('Load Torque (N.m)', color='#9ca3af', fontsize=9)
ax4.set_ylabel('Speed (RPM)', color='#9ca3af', fontsize=9)
ax4.tick_params(colors='#6b7280', labelsize=8)
ax4.legend(fontsize=8, facecolor='#111', edgecolor='#374151', labelcolor='#d1d5db')
ax4.set_facecolor('#0f0f0f')
for sp in ax4.spines.values(): sp.set_edgecolor('#374151')

# ── Plot 5: Motor power and efficiency ───────────────────────────────
ax5 = fig.add_subplot(gs[2, 0])
D_pw = 0.8
i_arr_pw, omega_arr_pw = simulate_motor(D_pw, V_supply, R_a, L_a, K_e, K_t, J, B, T_load, dt, N)
P_in_pw = D_pw * V_supply * i_arr_pw
P_mech = K_t * i_arr_pw * omega_arr_pw
P_copper = R_a * i_arr_pw**2
eta_motor = np.where(P_in_pw > 0.01, P_mech / P_in_pw * 100, 0)

ax5.plot(t, P_in_pw, color='#f87171', lw=1.3, label='P_in (W)')
ax5.plot(t, P_mech, color='#34d399', lw=1.3, label='P_mech (W)')
ax5.plot(t, P_copper, color='#fbbf24', lw=1.3, ls='--', label='P_copper (W)')
ax5_r = ax5.twinx()
ax5_r.plot(t, eta_motor, color='#a78bfa', lw=1.3, ls=':', label='Eff. (%)')
ax5_r.set_ylabel('Efficiency (%)', color='#a78bfa', fontsize=9)
ax5_r.tick_params(colors='#6b7280', labelsize=8)
ax5.set_title(f'Power Analysis (D={D_pw})', color='#34d399', fontsize=11)
ax5.set_xlabel('Time (s)', color='#9ca3af', fontsize=9)
ax5.set_ylabel('Power (W)', color='#9ca3af', fontsize=9)
ax5.tick_params(colors='#6b7280', labelsize=8)
lines1, lbl1 = ax5.get_legend_handles_labels()
lines2, lbl2 = ax5_r.get_legend_handles_labels()
ax5.legend(lines1 + lines2, lbl1 + lbl2, fontsize=8, facecolor='#111', edgecolor='#374151', labelcolor='#d1d5db')
ax5.set_facecolor('#0f0f0f')
for sp in ax5.spines.values(): sp.set_edgecolor('#374151')

# ── Plot 6: Acceleration profile with step load torque change ─────────
ax6 = fig.add_subplot(gs[2, 1])
# Same motor, D=0.7, but load torque doubles at t=0.5s
D_step = 0.7
V_in_s = D_step * V_supply
i_a = 0.0; omega = 0.0
i_step_arr = np.zeros(N); omega_step_arr = np.zeros(N)
for k in range(N):
    T_l = T_load if t[k] < 0.5 else 0.15   # torque step at 0.5s
    back_emf = K_e * omega
    v_L = V_in_s - R_a * i_a - back_emf
    i_a = max(0.0, i_a + v_L * dt / L_a)
    T_em = K_t * i_a
    domega = (T_em - B * omega - T_l) / J
    omega = max(0.0, omega + domega * dt)
    i_step_arr[k] = i_a
    omega_step_arr[k] = omega

rpm_step = omega_step_arr * 60 / (2 * np.pi)
ax6.plot(t, rpm_step, color='#34d399', lw=1.8, label='Speed (RPM)')
ax6r = ax6.twinx()
ax6r.plot(t, i_step_arr, color='#f87171', lw=1.3, ls='--', label='I_a (A)')
ax6r.set_ylabel('I_a (A)', color='#f87171', fontsize=9)
ax6r.tick_params(colors='#6b7280', labelsize=8)
ax6.axvline(0.5, color='#fbbf24', lw=1.5, ls=':', alpha=0.8)
ax6.text(0.52, 10, 'Load step', color='#fbbf24', fontsize=8)
ax6.set_title(f'Speed & Current: Load Torque Step (D={D_step})', color='#34d399', fontsize=11)
ax6.set_xlabel('Time (s)', color='#9ca3af', fontsize=9)
ax6.set_ylabel('Speed (RPM)', color='#9ca3af', fontsize=9)
ax6.tick_params(colors='#6b7280', labelsize=8)
lines1, lbl1 = ax6.get_legend_handles_labels()
lines2, lbl2 = ax6r.get_legend_handles_labels()
ax6.legend(lines1 + lines2, lbl1 + lbl2, fontsize=8, facecolor='#111', edgecolor='#374151', labelcolor='#d1d5db')
ax6.set_facecolor('#0f0f0f')
for sp in ax6.spines.values(): sp.set_edgecolor('#374151')

fig.suptitle('DC Motor Drives', color='#34d399', fontsize=14, fontweight='bold', y=0.98)
plt.savefig('output.png', dpi=130, bbox_inches='tight', facecolor='#0a0a0a')
print('Saved output.png')

Click Run to execute the Python code

Code will be executed with Python 3 on the server

← Ch 17: Switching Converters Next: PCB Design →