A single robot joint driven by a rotary servo typically consists of:

• Power amplifier (servo drive) that regulates motor current or torque.
• Electric motor (often DC or permanent-magnet synchronous) producing torque.
• Gearbox with ratio \( N \) relating motor and joint speeds.
• Load inertia: link plus any payload reflected through the gear ratio.
• Sensor (e.g., encoder) providing joint position feedback.

In modern industrial drives, there is frequently a cascade of loops: an inner current (torque) loop, an intermediate speed loop, and an outer position loop. In this lesson we treat the inner current loop as sufficiently fast to be approximated as a static gain, yielding an effective torque source for the mechanical axis.

flowchart TD
  R["Position reference r(t)"] --> E["Error e(t)=r(t)-y(t)"]
  E --> C["Controller C(s) (e.g. PID)"]
  C --> A["Servo amplifier (current loop)"]
  A --> M["Motor + gearbox + joint (plant Gp(s))"]
  M --> S["Encoder / sensor"]
  S --> Y["Measured position y(t)"]
  Y --> E
        

The analysis below uses the classical single-loop feedback framework: plant transfer function \( G_p(s) \), controller \( C(s) \), unity feedback, and the usual closed-loop transfer function

\[ T(s) = \frac{Y(s)}{R(s)} = \frac{C(s) G_p(s)}{1 + C(s) G_p(s)}. \]

Consider a rotary motor driving a rigid joint through a gear ratio \( N \), where \( \theta_m(t) \) is motor angle and \( \theta(t) \) is joint angle. For a rigid gearbox with no backlash and negligible compliance,

\[ \theta_m(t) = N \, \theta(t), \quad \dot{\theta}_m(t) = N \, \dot{\theta}(t). \]

Let \( J_m \) be the motor inertia and \( J_L \) the load inertia at the joint. Referring the load to the motor side gives the equivalent inertia seen at the motor:

\[ J_{\text{eq}} = J_m + N^2 J_L. \]

With viscous damping coefficients \( b_m \) and \( b_L \) for motor and load, the equivalent damping is

\[ b_{\text{eq}} = b_m + N^2 b_L. \]

Denote the joint torque delivered by the motor at the motor shaft as \( T_m(t) \). Neglecting gravity and nonlinear friction, the mechanical equation of motion in terms of joint angle is

\[ J_{\text{eq}} \ddot{\theta}(t) + b_{\text{eq}} \dot{\theta}(t) = \frac{T_m(t)}{N}. \]

For a current-controlled motor drive, torque is approximately proportional to armature current \( i(t) \), \( T_m(t) = K_t i(t) \), and the inner current loop can be idealized as \( i(t) \approx K_c u(t) \), where \( u(t) \) is the controller output (current command) and \( K_c \) is an effective gain. Then

\[ J_{\text{eq}} \ddot{\theta}(t) + b_{\text{eq}} \dot{\theta}(t) = \frac{K_t K_c}{N} u(t). \]

Define the effective velocity constant and mechanical time constant

\[ K_v = \frac{K_t K_c}{N b_{\text{eq}}}, \quad \tau_m = \frac{J_{\text{eq}}}{b_{\text{eq}}}. \]

Taking Laplace transforms with zero initial conditions, \( \Theta(s) = \mathcal{L}\{\theta(t)\} \), \( U(s) = \mathcal{L}\{u(t)\} \), yields

\[ \left(J_{\text{eq}} s^2 + b_{\text{eq}} s\right) \Theta(s) = \frac{K_t K_c}{N} U(s) \quad \Rightarrow \quad G_p(s) = \frac{\Theta(s)}{U(s)} = \frac{K_v}{s(\tau_m s + 1)}. \]

Thus, the rigid linear axis behaves as an integrator cascaded with a first-order lag, parameterized by the effective gain \( K_v \) and time constant \( \tau_m \).

Consider unity feedback position control with a pure proportional controller \( C(s) = K_p \). The open-loop transfer function is

\[ L(s) = C(s) G_p(s) = \frac{K_p K_v}{s(\tau_m s + 1)}. \]

The characteristic equation of the closed loop is \( 1 + L(s) = 0 \), i.e.

\[ 1 + \frac{K_p K_v}{s(\tau_m s + 1)} = 0 \quad \Rightarrow \quad \tau_m s^2 + s + K_p K_v = 0. \]

Dividing by \( \tau_m \) gives

\[ s^2 + \frac{1}{\tau_m} s + \frac{K_p K_v}{\tau_m} = 0. \]

Comparing with the standard second-order characteristic polynomial

\[ s^2 + 2 \zeta \omega_n s + \omega_n^2 = 0, \]

we identify

\[ 2 \zeta \omega_n = \frac{1}{\tau_m}, \qquad \omega_n^2 = \frac{K_p K_v}{\tau_m}. \]

Eliminating \( \omega_n \), we obtain

\[ K_p = \frac{1}{4 \zeta^2 K_v \tau_m}, \qquad \omega_n = \frac{1}{2 \zeta \tau_m}. \]

Therefore, increasing \( K_p \) increases the natural frequency \( \omega_n \) (faster loop) but simultaneously decreases the damping ratio \( \zeta \). This trade-off is fundamental to proportional position control of a servo axis.

For a unit-step position command and a well-damped second-order model, standard time-domain specifications from previous chapters apply:

\[ M_p \approx \exp\!\left( -\frac{\pi \zeta}{\sqrt{1 - \zeta^2}} \right), \qquad t_s \approx \frac{4}{\zeta \omega_n} \]

where \( M_p \) is the maximum overshoot and \( t_s \) the 2% settling time. For robotic joints, values around \( \zeta \approx 0.6\text{–}0.8 \) typically provide a reasonable compromise between speed and overshoot.

Robot joints experience disturbance torques from gravity, friction, and interaction with the environment. Augmenting the mechanical model,

\[ J_{\text{eq}} \ddot{\theta}(t) + b_{\text{eq}} \dot{\theta}(t) = \frac{K_t K_c}{N} u(t) - T_d(t), \]

where \( T_d(t) \) is an external disturbance torque. In the Laplace domain,

\[ \Theta(s) = \frac{K_v}{s(\tau_m s + 1)} U(s) - \frac{1}{J_{\text{eq}} s^2 + b_{\text{eq}} s} T_d(s). \]

Under unity-feedback position control, the closed-loop response to disturbances is determined by the sensitivity function \( S(s) = 1 / (1 + C(s) G_p(s)) \). For a disturbance applied at the plant input, the transfer function from \( T_d(s) \) to \( \Theta(s) \) is proportional to \( S(s) \). High low-frequency loop gain is thus desirable to attenuate slowly varying disturbances such as static friction and gravity.

In practice, proportional control alone may not guarantee acceptable steady-state tracking in the presence of constant disturbance torque. Integrator action (e.g. in a PI or PID controller) is typically added in the outer loop to eliminate steady-state position error, as developed in the earlier PID chapters.

flowchart TD
  ST["Start: axis spec (stroke, load, speed)"] --> ID["Identify Jeq, beq, Kt, Kc, N"]
  ID --> MOD["Form plant Gp(s)=Kv/(s*(tau_m*s+1))"]
  MOD --> SPEC["Translate position specs to zeta, omega_n"]
  SPEC --> TUNE["Select controller gains (Kp, Ki, Kd)"]
  TUNE --> SIM["Simulate step and disturbance responses"]
  SIM --> IMPL["Implement in drive and verify on hardware"]
        

Using Python, we can model the rigid axis transfer function and design a proportional or PID controller with the python-control library. Below, we form \( G_p(s) \), select \( K_p \) from a target damping ratio \( \zeta \), and simulate the step response.

import numpy as np
import matplotlib.pyplot as plt

# Optional: python-control library (pip install control)
import control as ctl

# Physical parameters (example values)
J_eq = 0.01     # [kg*m^2]
b_eq = 0.001    # [N*m*s/rad]
K_t = 0.1       # [N*m/A]
K_c = 2.0       # [A/unit command]
N   = 50.0      # gear ratio

Kv = (K_t * K_c) / (N * b_eq)
tau_m = J_eq / b_eq

print("Kv =", Kv, "tau_m =", tau_m)

# Plant Gp(s) = Kv / (s * (tau_m*s + 1))
s = ctl.TransferFunction.s
Gp = Kv / (s * (tau_m * s + 1))

# Design Kp from desired zeta (using P-only design relation)
zeta = 0.7
Kp = 1.0 / (4.0 * (zeta**2) * Kv * tau_m)

C = ctl.TransferFunction([Kp], [1.0])
L = C * Gp
T = ctl.feedback(L, 1.0)  # unity feedback

t = np.linspace(0, 0.5, 1000)
t, y = ctl.step_response(T, t)

plt.figure()
plt.plot(t, y)
plt.xlabel("Time [s]")
plt.ylabel("Joint position theta(t) [rad]")
plt.title("Position servo step response (P control)")
plt.grid(True)
plt.show()
      

The same framework can be extended to include integral and derivative action in C(s), and to evaluate performance over a family of gains via parameter sweeps, as discussed in the earlier design chapters.

Embedded servo drives typically implement discrete-time controllers. The following C++ snippet simulates a discrete-time PID position loop around the continuous-time plant approximated by Euler integration:

#include <iostream>
#include <vector>

int main() {
    // Mechanical parameters (example)
    double J_eq = 0.01;
    double b_eq = 0.001;
    double K_t  = 0.1;
    double K_c  = 2.0;
    double N    = 50.0;

    double Kv    = (K_t * K_c) / (N * b_eq);
    double tau_m = J_eq / b_eq;

    // Discrete-time parameters
    double dt   = 0.0005;     // sampling period [s]
    int    Nsim = 4000;       // number of samples

    // PID gains (tuned by hand or from design rules)
    double Kp = 50.0;
    double Ki = 500.0;
    double Kd = 0.001;

    // State: x1 = theta, x2 = theta_dot
    double x1 = 0.0;
    double x2 = 0.0;

    double r     = 0.1;   // step reference [rad]
    double e     = 0.0;
    double e_prev = 0.0;
    double I     = 0.0;

    for (int k = 0; k < Nsim; ++k) {
        double t = k * dt;

        // Position error
        e = r - x1;

        // PID control law (parallel form)
        I += e * dt;
        double D = (e - e_prev) / dt;
        double u = Kp * e + Ki * I + Kd * D;

        // Plant: theta_ddot = -(b_eq/J_eq)*theta_dot + (Kv/J_eq)*u
        double x2_dot = -(b_eq / J_eq) * x2 + (Kv / J_eq) * u;
        double x1_dot = x2;

        // Euler integration
        x2 += x2_dot * dt;
        x1 += x1_dot * dt;

        e_prev = e;

        if (k % 200 == 0) {
            std::cout << "t=" << t
                      << " theta=" << x1
                      << " u=" << u << std::endl;
        }
    }

    return 0;
}
      

This code can be adapted to real-time firmware by replacing the simulation loop with an interrupt-driven task that reads encoder position, computes the control law, and writes the resulting command to the power stage.

Java can be used for high-level simulation or for control on platforms such as real-time Java virtual machines. The following snippet illustrates a simple simulation framework similar to the C++ example:

public class LinearAxisServo {

    public static void main(String[] args) {
        double J_eq = 0.01;
        double b_eq = 0.001;
        double K_t  = 0.1;
        double K_c  = 2.0;
        double N    = 50.0;

        double Kv    = (K_t * K_c) / (N * b_eq);
        double tau_m = J_eq / b_eq;

        double dt   = 0.0005;
        int    Nsim = 4000;

        double Kp = 50.0;
        double Ki = 500.0;
        double Kd = 0.001;

        double theta     = 0.0;
        double thetaDot  = 0.0;
        double ref       = 0.1;
        double e         = 0.0;
        double ePrev     = 0.0;
        double I         = 0.0;

        for (int k = 0; k < Nsim; ++k) {
            double t = k * dt;

            e = ref - theta;
            I += e * dt;
            double D = (e - ePrev) / dt;
            double u = Kp * e + Ki * I + Kd * D;

            double thetaDotDot = -(b_eq / J_eq) * thetaDot + (Kv / J_eq) * u;
            thetaDot += thetaDotDot * dt;
            theta    += thetaDot * dt;

            ePrev = e;

            if (k % 200 == 0) {
                System.out.printf("t=%.4f theta=%.4f u=%.4f%n", t, theta, u);
            }
        }
    }
}
      

In industrial settings, interfaces to hardware encoders and DAC or PWM outputs would be encapsulated in dedicated classes, while the control law remains identical to the simulation code above.

MATLAB and Simulink provide a natural environment for modeling servo axes. The script below defines \( G_p(s) \), designs a proportional gain from a desired damping ratio, and visualizes the step response. It also illustrates how to construct a simple Simulink model programmatically.

% Physical parameters
J_eq = 0.01;
b_eq = 0.001;
K_t  = 0.1;
K_c  = 2.0;
N    = 50.0;

Kv    = (K_t * K_c) / (N * b_eq);
tau_m = J_eq / b_eq;

s  = tf('s');
Gp = Kv / (s * (tau_m * s + 1));

% P-only design for desired damping ratio
zeta = 0.7;
Kp   = 1 / (4 * zeta^2 * Kv * tau_m);

C = Kp;
T = feedback(C*Gp, 1);   % unity feedback closed loop

figure;
step(T);
grid on;
title('Position servo step response (MATLAB, P control)');

% --- Simulink model creation (simple unity-feedback loop) ---
model = 'servo_axis';
new_system(model);
open_system(model);

% Add blocks
add_block('simulink/Sources/Step',        [model '/ref']);
add_block('simulink/Math Operations/Sum', [model '/sum']);
add_block('simulink/Continuous/Transfer Fcn', [model '/Gp']);
add_block('simulink/Sinks/Scope',        [model '/scope']);
add_block('simulink/Commonly Used Blocks/Gain', [model '/Kp']);

% Set parameters
set_param([model '/Gp'], 'Numerator',   mat2str(Kv), ...
                         'Denominator', mat2str([tau_m 1 0])); % tau_m*s^2 + s
set_param([model '/Kp'], 'Gain', num2str(Kp));

% Connect lines: ref -> sum(+), feedback -, sum -> Kp -> Gp -> scope
add_line(model, 'ref/1',  'sum/1');
add_line(model, 'sum/1',  'Kp/1');
add_line(model, 'Kp/1',   'Gp/1');
add_line(model, 'Gp/1',   'scope/1');
add_line(model, 'Gp/1',   'sum/2', 'autorouting','on');  % negative feedback

set_param(model, 'StopTime', '0.5');
sim(model);
      

The denominator [tau_m 1 0] corresponds to \( \tau_m s^2 + s \), consistent with the derived rigid-axis model.

Mathematica supports symbolic and numeric analysis of linear servo models via TransferFunctionModel and related functions. The code below constructs \( G_p(s) \), forms the closed-loop transfer function with proportional control, and analyzes the poles.

(* Physical parameters *)
Jeq  = 0.01;
Beq  = 0.001;
Kt   = 0.1;
Kc   = 2.0;
N    = 50.0;

Kv    = (Kt * Kc)/(N * Beq);
tauM  = Jeq/Beq;

s = LaplaceTransformVariable["s"];

Gp = TransferFunctionModel[ Kv/(s*(tauM*s + 1)), s ];

zeta = 0.7;
Kp   = 1/(4*zeta^2*Kv*tauM);

C  = Kp;
L  = Series[ C*Gp["Function"][s], {s, 0, 2} ]; (* optional approximation *)

Tcl = FeedbackConnect[C*Gp, 1];

(* Closed-loop poles and damping *)
poles = TransferFunctionPoles[Tcl];
Print["Closed-loop poles: ", poles];

(* Step response plot *)
stepPlot = OutputResponse[Tcl, UnitStep[t], {t, 0, 0.5}];
Plot[stepPlot, {t, 0, 0.5},
  AxesLabel -> {"t [s]", "theta(t)"},
  PlotLabel -> "Position servo step response"
]
      

Symbolic capabilities allow direct derivation of closed-loop eigenvalues and performance indices for parameter sweeps across \( K_p \), \( K_v \), and \( \tau_m \).

For many servo design tasks, the rigid axis with proportional position control is approximated by a standard second-order closed-loop transfer function

\[ T(s) = \frac{Y(s)}{R(s)} = \frac{\omega_n^2}{s^2 + 2 \zeta \omega_n s + \omega_n^2}. \]

By matching the coefficients of the characteristic polynomial, we relate the physical parameters to \( \zeta \) and \( \omega_n \) as in Section 3. This gives a direct mapping from position-loop performance specifications (overshoot, settling time, desired bandwidth) to a proportional gain \( K_p \) once \( K_v \) and \( \tau_m \) have been identified.

When integral action is added, the closed-loop order increases and dominant-pole approximations from earlier chapters are used: the additional pole introduced by the integral action is placed sufficiently far in the left-half plane that its effect on the main servo dynamics remains small, while still ensuring zero steady-state position error.

Problem 1 (Rigid Axis Transfer Function): A motor–gear–joint system has parameters \( J_m = 5 \times 10^{-4} \,\text{kg m}^2 \), \( J_L = 3 \times 10^{-3} \,\text{kg m}^2 \), \( b_m = 2 \times 10^{-3} \,\text{N m s/rad} \), \( b_L = 1 \times 10^{-2} \,\text{N m s/rad} \), gear ratio \( N = 50 \), \( K_t = 0.2 \,\text{N m/A} \), and current-loop gain \( K_c = 3 \,\text{A/unit} \). Derive the transfer function \( G_p(s) = \Theta(s)/U(s) \) in the form \( K_v / \bigl(s(\tau_m s + 1)\bigr) \) and compute \( K_v \) and \( \tau_m \).

Solution:

First compute the equivalent inertia and damping:

\[ J_{\text{eq}} = J_m + N^2 J_L = 5 \times 10^{-4} + 50^2 \cdot 3 \times 10^{-3} = 5 \times 10^{-4} + 2500 \cdot 3 \times 10^{-3}. \]

Since \( 2500 \cdot 3 \times 10^{-3} = 7.5 \), we have \( J_{\text{eq}} \approx 7.5005 \,\text{kg m}^2 \). Similarly for damping,

\[ b_{\text{eq}} = b_m + N^2 b_L = 2 \times 10^{-3} + 2500 \cdot 1 \times 10^{-2} \approx 25 + 0.002 = 25.002 \,\text{N m s/rad}. \]

The effective gain and mechanical time constant are

\[ K_v = \frac{K_t K_c}{N b_{\text{eq}}} = \frac{0.2 \cdot 3}{50 \cdot 25.002} \approx \frac{0.6}{1250.1} \approx 4.8 \times 10^{-4}, \]

\[ \tau_m = \frac{J_{\text{eq}}}{b_{\text{eq}}} \approx \frac{7.5005}{25.002} \approx 0.300. \]

The rigid-axis transfer function is therefore

\[ G_p(s) = \frac{4.8 \times 10^{-4}}{s(0.300 s + 1)}. \]

Problem 2 (Proportional Gain from Damping Ratio): For the plant in Problem 1, suppose we design a pure proportional position controller. Find the proportional gain \( K_p \) that yields a damping ratio \( \zeta = 0.7 \).

Solution:

Using the relation

\[ K_p = \frac{1}{4 \zeta^2 K_v \tau_m}, \]

with \( \zeta = 0.7 \), \( K_v \approx 4.8 \times 10^{-4} \) and \( \tau_m \approx 0.300 \), we obtain

\[ K_p \approx \frac{1}{4 \cdot 0.7^2 \cdot (4.8 \times 10^{-4}) \cdot 0.300} \approx \frac{1}{4 \cdot 0.49 \cdot 1.44 \times 10^{-4}} \approx \frac{1}{2.8224 \times 10^{-4}} \approx 3543. \]

Thus, a proportional gain of about \( K_p \approx 3.5 \times 10^3 \) is required for \( \zeta \approx 0.7 \).

Problem 3 (Overshoot and Settling Time): For the servo in Problem 2, compute the approximate step-response overshoot \( M_p \) and 2% settling time \( t_s \) assuming a second-order approximation.

Solution:

With \( \zeta = 0.7 \) and \( \tau_m = 0.300 \), the natural frequency is

\[ \omega_n = \frac{1}{2 \zeta \tau_m} = \frac{1}{2 \cdot 0.7 \cdot 0.300} \approx \frac{1}{0.42} \approx 2.38 \,\text{rad/s}. \]

The overshoot is

\[ M_p \approx \exp\!\left( -\frac{\pi \zeta}{\sqrt{1 - \zeta^2}} \right) = \exp\!\left( -\frac{\pi \cdot 0.7}{\sqrt{1 - 0.49}} \right) = \exp\!\left( -\frac{2.199}{\sqrt{0.51}} \right) \approx \exp(-3.08) \approx 0.046. \]

Thus the overshoot is about 4.6%. The 2% settling time is

\[ t_s \approx \frac{4}{\zeta \omega_n} \approx \frac{4}{0.7 \cdot 2.38} \approx \frac{4}{1.666} \approx 2.40 \,\text{s}. \]

Problem 4 (Effect of Gear Ratio on Dynamics): Using the expressions from Section 2, show qualitatively how increasing the gear ratio \( N \) affects \( \tau_m \) and \( K_v \), and discuss the consequences for servo performance.

Solution:

Recall

\[ J_{\text{eq}} = J_m + N^2 J_L, \quad b_{\text{eq}} = b_m + N^2 b_L, \]

\[ \tau_m = \frac{J_{\text{eq}}}{b_{\text{eq}}}, \quad K_v = \frac{K_t K_c}{N b_{\text{eq}}}. \]

As \( N \) increases, both \( J_{\text{eq}} \) and \( b_{\text{eq}} \) scale roughly as \( N^2 \), so \( \tau_m \) remains approximately constant if \( J_m \) and \( b_m \) are negligible compared to the reflected load. However, \( K_v \) scales roughly as \( 1/(N^3) \) (because \( b_{\text{eq}} \propto N^2 \) and there is an explicit \( 1/N \) factor).

Therefore, larger gear ratios reduce \( K_v \), making the axis gain smaller and requiring larger controller gains for the same closed-loop bandwidth. Additionally, large gear ratios increase reflected inertia and friction, which can reduce back-drivability and compliance, affecting both performance and safety.

Problem 5 (Conceptual Design Flow): Summarize a design procedure for a robot joint position servo using the rigid linear axis model and classical tools developed in earlier chapters.

Solution (conceptual flow):

flowchart TD
  A["Specify position specs (rise time, overshoot, bandwidth)"] --> B["Measure or estimate Jeq, beq, Kt, Kc, N"]
  B --> C["Compute Kv and tau_m; form Gp(s)=Kv/(s*(tau_m*s+1))"]
  C --> D["Translate specs to target zeta, omega_n"]
  D --> E["Choose Kp (and Ki, Kd) using second-order formulas"]
  E --> F["Verify time and frequency responses; adjust gains"]
  F --> G["Implement in drive and validate under disturbances"]
        

This lesson constructed a linear, rigid-axis model for servo-driven robot joints, starting from motor and load inertias, viscous damping, torque constants, and gearbox ratios. We derived the effective plant transfer function \( G_p(s) = K_v / \bigl(s(\tau_m s + 1)\bigr) \) and showed how proportional position feedback yields a standard second-order closed-loop characteristic equation. This allowed direct use of previously developed relationships between damping ratio, natural frequency, overshoot, and settling time to select controller gains.

We then illustrated discrete-time implementations in Python, C++, Java, MATLAB/Simulink, and Mathematica, emphasizing how the same underlying linear model supports simulation and design across different software platforms. These tools collectively enable systematic design and tuning of servo drives and robot joint controllers within the classical linear control framework.