A robot transforms electrical energy into mechanical motion through actuators. For electric motors, the core quantities are torque \( \tau \), angular speed \( \omega \), and mechanical power \( P_m = \tau \omega \). Robots require actuators that can deliver:

• High torque at low speed (arms, grippers).
• High-speed continuous rotation (wheels, propellers).
• Precise positioning and holding (joints, platforms).
• Efficiency and thermal robustness under duty cycles.

The motor–drive unit is typically modeled as an electromechanical system with electrical dynamics producing current and mechanical dynamics producing motion. The high-level selection logic is:

flowchart TD
  S["Task requirements"] --> Q1["Need continuous rotation?"]
  Q1 -->|yes| Q2["Need very high efficiency \n& low maintenance?"]
  Q2 -->|yes| BLDC["Choose BLDC/PMSM"]
  Q2 -->|no| DC["Choose brushed DC"]
  Q1 -->|no| Q3["Need open-loop discrete steps?"]
  Q3 -->|yes| STEP["Choose stepper"]
  Q3 -->|no| SERVO["Choose servo module \n(motor + sensor + controller)"]
        

We now derive models for each motor type and relate them to torque–speed curves and control interfaces.

A brushed DC motor uses a commutator and brushes to keep torque direction fixed. Its modeling starts with an equivalent armature circuit and a rigid rotor. Let: armature voltage \( v \), current \( i \), resistance \( R \), inductance \( L \), rotor inertia \( J \), viscous friction \( b \), load torque \( \tau_L \).

2.1 Electrical dynamics

The back electromotive force (back-EMF) is proportional to speed: \( e = k_e \omega \). Kirchhoff’s law gives:

\[ v(t) = R i(t) + L \frac{di(t)}{dt} + k_e \omega(t). \]

2.2 Mechanical dynamics

Electromagnetic torque is proportional to current: \( \tau_m = k_t i \). Newton–Euler rotation yields:

\[ J\frac{d\omega(t)}{dt} + b\omega(t) = k_t i(t) - \tau_L(t). \]

2.3 Proof that \( k_t = k_e \) (SI units)

Consider conservation of power in steady state (no inductive storage): electrical power converted \( P_e = e i = k_e \omega i \) equals mechanical electromagnetic power \( P_m = \tau_m \omega = k_t i \omega \). Setting \( P_e = P_m \) for all \( i,\omega \) gives:

\[ k_e \omega i = k_t i \omega \quad \Rightarrow \quad k_e = k_t. \]

This equality holds when \( k_e \) is in V·s/rad and \( k_t \) in N·m/A.

2.4 State-space and transfer function

With state \( \mathbf{x}=[i\;\;\omega]^\top \) and input \( u=v \), and ignoring load torque for the plant model:

\[ \frac{d}{dt}\begin{bmatrix} i \\ \omega \end{bmatrix} = \begin{bmatrix} -\frac{R}{L} & -\frac{k_e}{L} \\ \frac{k_t}{J} & -\frac{b}{J} \end{bmatrix} \begin{bmatrix} i \\ \omega \end{bmatrix} + \begin{bmatrix} \frac{1}{L} \\ 0 \end{bmatrix} v. \]

Laplace transform yields:

\[ \Omega(s) = \frac{k_t}{(L s + R)(J s + b) + k_e k_t}\, V(s). \]

So the speed transfer function is:

\[ G_\omega(s) \equiv \frac{\Omega(s)}{V(s)} = \frac{k_t}{LJ s^2 + (Lb + RJ)s + (Rb + k_e k_t)}. \]

2.5 Torque–speed characteristic

At steady state (\( \dot{i}=0,\dot{\omega}=0 \)):

\[ v = R i + k_e \omega, \qquad b\omega = k_t i - \tau_L. \]

Eliminating \( i \) gives:

\[ \tau_m = k_t i = \frac{k_t}{R}(v - k_e \omega) \quad \Rightarrow \quad \omega = \omega_0 - \alpha \tau_m \]

where \( \omega_0 = \frac{v}{k_e} \) is no-load speed and \( \alpha = \frac{R}{k_e k_t} \) is the slope. Robots exploit this linear relation via voltage/PWM control.

BLDC motors remove brushes and use electronic commutation. They are often permanent-magnet synchronous machines with trapezoidal back-EMF. Let phase variables be \( v_a,v_b,v_c \), currents \( i_a,i_b,i_c \), and phase resistance/inductance \( R_s,L_s \). Back-EMFs are: \( e_a = k_e f_a(\theta)\omega \), \( e_b = k_e f_b(\theta)\omega \), \( e_c = k_e f_c(\theta)\omega \), where \( f_\bullet(\theta) \) are 120° shifted trapezoids with amplitude 1.

3.1 Electrical equations

\[ \begin{aligned} v_a &= R_s i_a + L_s \frac{di_a}{dt} + e_a(\theta,\omega),\\ v_b &= R_s i_b + L_s \frac{di_b}{dt} + e_b(\theta,\omega),\\ v_c &= R_s i_c + L_s \frac{di_c}{dt} + e_c(\theta,\omega), \end{aligned} \qquad i_a + i_b + i_c = 0. \]

3.2 Electromagnetic torque

Instantaneous converted power is \( P_e = e_a i_a + e_b i_b + e_c i_c \). Since \( P_e = \tau_m \omega \):

\[ \tau_m = \frac{e_a i_a + e_b i_b + e_c i_c}{\omega}. \]

For ideal six-step commutation, two phases conduct with currents \( i \) and \( -i \), the third is off. Over a 60° sector, \( f_a,f_b,f_c \) are constants in {1,0,-1}. Hence:

\[ \tau_m = k_t i, \quad k_t = k_e, \]

i.e., BLDC torque is again proportional to the commanded phase current. Compared to brushed DC, commutation is external (performed by an inverter), eliminating brush wear and enabling higher speed/efficiency.

3.3 Mechanical dynamics

\[ J\dot{\omega} + b\omega = \tau_m - \tau_L, \]

identical in structure to the DC motor. Control focuses on current shaping and rotor position estimation (Hall sensors or sensorless back-EMF).

A stepper motor advances in fixed angular increments when phase currents are switched in sequence. Typical step size is \( \Delta\theta = \frac{2\pi}{N_s} \) where \( N_s \) is steps per revolution. Hence position can be controlled open-loop if torque margin prevents slip.

4.1 Static torque–angle relation

For a 2-phase permanent-magnet stepper with rotor pole pairs \( p \), phase currents \( i_A,i_B \), and torque constant \( K \), the electromagnetic torque can be approximated by:

\[ \tau_m(\theta) = K\big(i_A \sin(p\theta) + i_B \cos(p\theta)\big). \]

If currents are commanded as \( i_A = I\cos\phi \), \( i_B = I\sin\phi \), then:

\[ \tau_m(\theta)= K I \sin(p\theta + \phi). \]

The equilibrium positions satisfy \( p\theta^\star + \phi = n\pi \), giving discrete steps. This also explains microstepping: by smoothly varying \( \phi \), one moves the equilibrium continuously.

4.2 Dynamic model

Linearizing around an equilibrium position \( \theta^\star \) yields a torsional spring approximation. Let small deviation be \( \tilde{\theta} = \theta - \theta^\star \). Since \( \sin(p\theta^\star+\phi)=0 \) and \( \cos(p\theta^\star+\phi)=\pm 1 \):

\[ \tau_m(\theta) \approx K I p \cos(p\theta^\star+\phi)\,\tilde{\theta} \equiv k_s \tilde{\theta}. \]

Therefore the small-signal dynamics with load torque are:

\[ J\ddot{\tilde{\theta}} + b\dot{\tilde{\theta}} + k_s \tilde{\theta} = -\tau_L. \]

This is a second-order system; high step rates can excite resonance, causing missed steps.

“Servo” in robotics refers not to a specific electromagnetic motor type, but to a closed-loop actuation module: motor (DC/BLDC), gear train, position sensor, and embedded controller. The output is typically position or velocity tracking.

5.1 Closed-loop position servo model

Suppose the internal motor can be approximated as a second-order plant from voltage to shaft angle: \( G_\theta(s) = \frac{\Theta(s)}{V(s)} \). With a PID controller \( C(s)=K_p + K_i/s + K_d s \), the closed-loop transfer function is:

\[ T(s)=\frac{C(s)G_\theta(s)}{1 + C(s)G_\theta(s)}. \]

flowchart LR
  R["theta_ref"] --> E["sum"]
  Y["theta"] -->|"-"| E
  E --> C["PID controller"]
  C --> D["motor+gear plant"]
  D --> Y
  Y --> S["sensor"]
  S -->|feedback| E
        

5.2 Standard 2nd-order design link

For many servos, dominant closed-loop behavior is tuned to:

\[ T(s) \approx \frac{\omega_n^2}{s^2 + 2\zeta\omega_n s + \omega_n^2}, \]

where \( \omega_n \) is natural frequency (bandwidth) and \( \zeta \) damping ratio (overshoot). Linear control knowledge directly applies: choose gains to meet rise time and overshoot requirements, while keeping actuator limits and gear backlash in mind (backlash is next lesson).

6.1 Python: DC motor simulation + PID speed control

import numpy as np
import matplotlib.pyplot as plt

# DC motor parameters (SI)
R = 1.2        # ohm
L = 2.0e-3     # H
ke = 0.08      # V*s/rad
kt = ke        # N*m/A (proved)
J = 5.0e-4     # kg*m^2
b = 1.0e-3     # N*m*s/rad

dt = 1e-4
T_end = 0.5
N = int(T_end/dt)

# PID gains for speed control
Kp, Ki, Kd = 0.4, 30.0, 0.0
omega_ref = 100.0  # rad/s

i = 0.0
omega = 0.0
e_int = 0.0
e_prev = 0.0

omega_log = np.zeros(N)
v_log = np.zeros(N)
t_log = np.arange(N)*dt

for k in range(N):
    # PID on speed
    e = omega_ref - omega
    e_int += e*dt
    e_der = (e - e_prev)/dt
    v = Kp*e + Ki*e_int + Kd*e_der
    e_prev = e

    # Electrical update: di/dt = (v - R i - ke omega)/L
    di = (v - R*i - ke*omega)/L
    i += di*dt

    # Mechanical update: domega/dt = (kt i - b omega)/J
    domega = (kt*i - b*omega)/J
    omega += domega*dt

    omega_log[k] = omega
    v_log[k] = v

plt.figure()
plt.plot(t_log, omega_log)
plt.xlabel("time (s)")
plt.ylabel("speed omega (rad/s)")
plt.title("PID Speed Control of a DC Motor")
plt.grid(True)
plt.show()
      

6.2 C++: Discrete-time motor model and PID class

#include <iostream>
#include <vector>
#include <cmath>

struct DCMotor {
    double R, L, ke, kt, J, b;
    double i = 0.0;
    double omega = 0.0;

    void step(double v, double dt) {
        double di = (v - R*i - ke*omega)/L;
        i += di*dt;
        double domega = (kt*i - b*omega)/J;
        omega += domega*dt;
    }
};

struct PID {
    double Kp, Ki, Kd;
    double eint = 0.0, eprev = 0.0;

    double update(double e, double dt) {
        eint += e*dt;
        double eder = (e - eprev)/dt;
        eprev = e;
        return Kp*e + Ki*eint + Kd*eder;
    }
};

int main() {
    DCMotor m{1.2, 2e-3, 0.08, 0.08, 5e-4, 1e-3};
    PID pid{0.4, 30.0, 0.0};

    double dt = 1e-4, Tend = 0.5;
    int N = (int)(Tend/dt);
    double omega_ref = 100.0;

    for(int k=0; k<N; ++k){
        double e = omega_ref - m.omega;
        double v = pid.update(e, dt);
        m.step(v, dt);
        if(k % 1000 == 0){
            std::cout << k*dt << "," << m.omega << std::endl;
        }
    }
    return 0;
}
      

6.3 Java: Same model with a simple PID

public class DCMotorPID {
    static class DCMotor {
        double R, L, ke, kt, J, b;
        double i = 0.0, omega = 0.0;
        DCMotor(double R,double L,double ke,double J,double b){
            this.R=R; this.L=L; this.ke=ke; this.kt=ke; this.J=J; this.b=b;
        }
        void step(double v, double dt){
            double di = (v - R*i - ke*omega)/L;
            i += di*dt;
            double domega = (kt*i - b*omega)/J;
            omega += domega*dt;
        }
    }

    static class PID {
        double Kp, Ki, Kd, eint=0.0, eprev=0.0;
        PID(double Kp,double Ki,double Kd){ this.Kp=Kp; this.Ki=Ki; this.Kd=Kd; }
        double update(double e, double dt){
            eint += e*dt;
            double eder = (e-eprev)/dt;
            eprev = e;
            return Kp*e + Ki*eint + Kd*eder;
        }
    }

    public static void main(String[] args){
        DCMotor m = new DCMotor(1.2, 2e-3, 0.08, 5e-4, 1e-3);
        PID pid = new PID(0.4, 30.0, 0.0);

        double dt=1e-4, Tend=0.5;
        int N=(int)(Tend/dt);
        double omegaRef=100.0;

        for(int k=0; k<N; k++){
            double e = omegaRef - m.omega;
            double v = pid.update(e, dt);
            m.step(v, dt);
            if(k % 1000 == 0){
                System.out.println((k*dt) + "," + m.omega);
            }
        }
    }
}
      

6.4 MATLAB / Simulink: State-space model and a basic speed loop

In MATLAB, define the state-space plant from Section 2.4:

% Parameters
R = 1.2; L = 2e-3; ke = 0.08; kt = ke;
J = 5e-4; b = 1e-3;

A = [-R/L,   -ke/L;
      kt/J,  -b/J];
B = [1/L; 0];
C = [0 1];   % output speed omega
D = 0;

sys = ss(A,B,C,D);

% PID gains
Kp = 0.4; Ki = 30; Kd = 0;

Cpid = pid(Kp,Ki,Kd);
Tcl = feedback(Cpid*sys, 1);

step(Tcl); grid on; title('Closed-loop speed response')
      

In Simulink: (i) place a State-Space block with matrices \( A,B,C,D \); (ii) connect a PID Controller block in series; (iii) close unity feedback; (iv) apply a step in speed reference.

Problem 1 (DC motor transfer function): Starting from \( v = R i + L\dot{i} + k_e \omega \) and \( J\dot{\omega} + b\omega = k_t i \), derive \( G_\omega(s)=\Omega(s)/V(s) \).

Solution:

Laplace transform: \( V = (R + Ls)I + k_e \Omega \) and \( (Js+b)\Omega = k_t I \). Eliminate \( I \):

\[ I = \frac{(Js+b)}{k_t}\Omega. \]

Substitute into electrical equation:

\[ V = (R+Ls)\frac{(Js+b)}{k_t}\Omega + k_e \Omega = \left(\frac{(R+Ls)(Js+b)}{k_t} + k_e\right)\Omega. \]

Therefore:

\[ G_\omega(s)=\frac{\Omega}{V}= \frac{k_t}{(R+Ls)(Js+b) + k_e k_t}. \]

Problem 2 (Steady-state speed under load): A DC motor has \( R=1\,\Omega \), \( k_e=k_t=0.1 \), \( b=0.01 \). It is driven by \( v=12\,\text{V} \) with load torque \( \tau_L=0.5\,\text{N·m} \). Find the steady-state speed.

Solution:

At steady state: \( v = R i + k_e \omega \), \( b\omega = k_t i - \tau_L \). From mechanical equation: \( k_t i = b\omega + \tau_L \) so \( i = (b\omega + \tau_L)/k_t \). Substitute in electrical:

\[ v = R\frac{b\omega + \tau_L}{k_t} + k_e \omega = \left(\frac{Rb}{k_t}+k_e\right)\omega + \frac{R\tau_L}{k_t}. \]

Plug values:

\[ 12 = \left(\frac{1\cdot 0.01}{0.1}+0.1\right)\omega + \frac{1\cdot 0.5}{0.1} = (0.1+0.1)\omega + 5. \]

Thus \( 7 = 0.2\omega \Rightarrow \omega = 35\,\text{rad/s} \).

Problem 3 (BLDC average torque): In ideal six-step BLDC commutation, two phases conduct with currents \( +i \) and \( -i \) while the back-EMFs in that sector are \( +k_e\omega \) and \( -k_e\omega \). Show that average torque equals \( k_e i \).

Solution:

Converted power in that sector: \( P_e = e_1 i + e_2 (-i) = k_e\omega i + (-k_e\omega)(-i)=2k_e\omega i \). But mechanical power is \( P_e=\tau_m\omega \), so

\[ \tau_m = \frac{P_e}{\omega} = \frac{2k_e\omega i}{\omega} = 2k_e i. \]

Each electrical sector spans 60°. Over a full electrical cycle (360°), only two thirds of phases conduct at any moment, so the cycle-average is:

\[ \bar{\tau}_m = \frac{1}{2}\cdot (2k_e i)=k_e i = k_t i. \]

Problem 4 (Stepper microstepping equilibrium): A 2-phase stepper follows \( \tau_m=K(I\cos\phi \sin(p\theta)+I\sin\phi \cos(p\theta)) \). Find equilibrium positions \( \theta^\star \).

Solution:

Combine as in Section 4: \( \tau_m = K I \sin(p\theta + \phi) \). Equilibria satisfy \( \tau_m=0 \):

\[ \sin(p\theta^\star + \phi)=0 \Rightarrow p\theta^\star + \phi = n\pi \Rightarrow \theta^\star = \frac{n\pi - \phi}{p}. \]

By varying \( \phi \) continuously, equilibrium moves smoothly (microstepping).

Problem 5 (Servo gain from desired pole placement): A servo can be approximated as \( G_\theta(s)=\frac{k}{s(Js+b)} \). Using proportional control \( C(s)=K_p \), find \( K_p \) to achieve closed-loop characteristic \( s^2 + 2\zeta\omega_n s + \omega_n^2 = 0 \).

Solution:

Closed-loop: \( T(s)=\frac{K_p G_\theta}{1+K_p G_\theta} \). Denominator:

\[ 1 + K_p\frac{k}{s(Js+b)} = 0 \Rightarrow s(Js+b) + K_p k = 0 \Rightarrow J s^2 + b s + K_p k = 0. \]

Divide by \( J \): \( s^2 + \frac{b}{J}s + \frac{K_p k}{J}=0 \). Match coefficients:

\[ \frac{b}{J}=2\zeta\omega_n,\qquad \frac{K_p k}{J}=\omega_n^2 \Rightarrow K_p = \frac{J\omega_n^2}{k}. \]

Note damping is fixed by physical friction; adding derivative feedback allows adjusting effective damping.

We derived electromechanical models for brushed DC motors, BLDC motors, stepper motors, and servo modules. The DC and BLDC models share the key relations \( e=k_e\omega \) and \( \tau=k_t i \) with \( k_t=k_e \) (proved via power balance). Stepper motors provide discrete equilibrium positions governed by sinusoidal torque–angle laws. Servo actuation frames motors inside a closed-loop position/velocity module, allowing linear control methods to be applied directly. These models are the foundation for the gearbox and transmission analysis in the next lesson.