Robot Control Systems

What is Robot Control?

Robot control is the science of commanding a robot to perform desired motions while handling real-world disturbances: gravity, friction, payload changes, sensor noise, and model uncertainty. A controller computes the actuator commands (motor voltages, torques, or pressures) needed to track a desired trajectory or maintain a desired force/position relationship.

The Control Problem

Given a desired trajectory q_d(t) (joint positions over time), the controller must compute torques tau(t) so that the actual joint positions q(t) track q_d(t) as closely as possible. The tracking error e(t) = q_d(t) - q(t) should converge to zero quickly, without oscillation, and stay bounded even under disturbances.

Control Architecture Levels

• Joint-level control — each joint has its own controller (typically PID). The innermost loop, running at 1-10 kHz. Treats each joint independently.
• Task-space control — controls the end-effector position/force directly, converting to joint commands via the Jacobian. Runs at 100 Hz - 1 kHz.
• Motion planning level — generates the desired trajectory. Runs at 10-100 Hz. Covered in the Planning page.
• Task/mission level — decides what the robot should do next. Runs at 1-10 Hz or event-driven.

Open-Loop vs Closed-Loop

• Open-loop (feedforward) — compute torques from a model of the robot dynamics, without measuring the actual state. Fast but brittle: any model error or disturbance causes drift.
• Closed-loop (feedback) — measure the actual state (via encoders, IMUs, etc.) and compute corrections. Robust to model errors and disturbances. Essential for real robots.
• Feedforward + feedback — the standard approach. Feedforward handles the predictable dynamics (gravity, inertia); feedback corrects residual errors.

Feedback Control Fundamentals

The Feedback Loop

A standard feedback controller has: a reference signal r(t) (desired value), a plant (the robot), a sensor measuring the output y(t), and a controller C that computes the control signal u(t) based on the error e(t) = r(t) - y(t). The closed-loop transfer function is G_cl = C*G / (1 + C*G), where G is the plant transfer function.

Stability

A system is stable if, for any bounded input, the output remains bounded (BIBO stability). For linear systems, stability is determined by the poles of the closed-loop transfer function: all poles must have negative real parts (in the left half of the s-plane for continuous time, inside the unit circle for discrete time). Key analysis tools:

• Routh-Hurwitz criterion — algebraic test for stability without computing poles directly.
• Nyquist criterion — graphical method using the frequency response. Counts encirclements of the critical point (-1, 0).
• Bode plots — plot gain and phase vs frequency. Gain margin and phase margin quantify how close the system is to instability. Typical targets: gain margin > 6 dB, phase margin > 45 degrees.
• Root locus — plot of closed-loop poles as controller gain varies. Shows how stability changes with gain.

Performance Specifications

• Rise time — time to go from 10% to 90% of the final value. Faster = more aggressive control.
• Overshoot — how much the response exceeds the setpoint. Typically want < 5% for industrial robots.
• Settling time — time to stay within 2% (or 5%) of the final value. Determines cycle time.
• Steady-state error — the persistent offset after transients decay. Integral action eliminates it for step inputs.

PID Control

The Proportional-Integral-Derivative (PID) controller is the most widely used control algorithm in the world. Over 95% of industrial control loops use some form of PID. It computes the control signal as a weighted sum of three terms based on the tracking error.

Proportional (P) Term

The P term produces a control signal proportional to the current error: u_P = Kp * e(t). Higher Kp means faster response but can cause oscillation and instability. P-only control always has steady-state error for a constant disturbance (it needs a non-zero error to produce a non-zero output). In a robot joint, this is like a spring pulling toward the desired angle — stiffer spring (higher Kp) = faster but more oscillatory.

Integral (I) Term

The I term accumulates past errors: u_I = Ki * integral(e(t) dt). It eliminates steady-state error by building up a correction signal even for small persistent errors. Essential for compensating gravity in robot arms: without I, a joint under gravity load will sag to a position where the P term balances gravity, leaving a static error. The downside: too much Ki causes overshoot and slow oscillation ("integral windup").

Derivative (D) Term

The D term responds to the rate of change of error: u_D = Kd * de(t)/dt. It provides damping, anticipating the error trend and braking before the setpoint is reached. In robot control, this is viscous damping — it opposes rapid joint motion. Essential for stability with high Kp. The practical challenge: differentiating a noisy signal amplifies noise. Real implementations use a filtered derivative (low-pass filter on the D term) or differentiate the measurement rather than the error.

Effect of Each Gain

PD Control for Robot Joints

For a robot joint with gravity compensation, PD control is often sufficient. The equation of motion for a single joint is: I*q'' + b*q' + mgl*sin(q) = tau. A PD controller with gravity feedforward gives:

The gravity term handles the static load; the PD terms handle trajectory tracking. This is Lyapunov-stable: the error converges to zero if the desired trajectory is constant (regulation), though tracking errors persist for time-varying trajectories.

Practical PID Implementation

// Discrete PID controller (runs every dt seconds)
error = setpoint - measurement;
integral += error * dt;
integral = clamp(integral, -max_integral, max_integral);  // anti-windup
derivative = (error - prev_error) / dt;
derivative = alpha * derivative + (1-alpha) * prev_derivative;  // filter
output = Kp * error + Ki * integral + Kd * derivative;
output = clamp(output, -max_output, max_output);  // actuator saturation
prev_error = error;
prev_derivative = derivative;

Tuning Methods

Choosing Kp, Ki, and Kd values is an art informed by theory. Several systematic methods exist.

Ziegler-Nichols Method (1942)

The classic tuning method, developed by John G. Ziegler and Nathaniel B. Nichols at Taylor Instruments. Two variants:

Oscillation method (closed-loop):

• Set Ki = 0, Kd = 0. Increase Kp until the system oscillates with constant amplitude (marginal stability).
• Record the ultimate gain Ku and the oscillation period Tu.
• Apply the Ziegler-Nichols formulas:

This method produces an aggressive controller (quarter-decay ratio: ~25% overshoot). It is a starting point, not a final tuning. Real robots need refinement based on actual performance.

Step response method (open-loop):

• Apply a step input to the open-loop system and record the response.
• Measure the delay time L (time before the response starts rising) and the time constant T (time to reach 63.2% of the final value).
• Kp = 1.2*T/(K*L), Ti = 2*L, Td = 0.5*L, where K is the process gain.

Cohen-Coon Method

A refinement of Ziegler-Nichols for processes with large dead time (L/T > 0.25). Uses the same step response measurements but different formulas that give less aggressive tuning.

Tyreus-Luyben Method

Uses the ultimate gain Ku and period Tu like Ziegler-Nichols but with more conservative formulas: Kp = Ku/3.2, Ti = 2.2*Tu, Td = Tu/6.3. Produces less overshoot, commonly used in process control.

Frequency Domain Methods

Design the controller by shaping the open-loop frequency response (Bode plot). Place the crossover frequency at the desired bandwidth, ensure adequate gain and phase margins. Loop shaping is the method of choice for sophisticated single-loop controllers and is taught in every graduate control course.

Auto-Tuning

Modern industrial controllers (Siemens, ABB, Beckhoff) include auto-tuning: the controller automatically performs a relay test (oscillation method variant), identifies the process dynamics, and computes PID gains. Relay auto-tuning (introduced by Karl Astrom and Tore Hagglund in 1984) uses a relay (bang-bang) controller to induce oscillation at the ultimate frequency, which is safer than increasing gain to marginal stability.

State-Space Control

State-space representation describes a system using first-order differential equations. It is more general than transfer functions (handles MIMO systems, nonlinear systems, and time-varying systems) and is the foundation for modern control.

where x is the state vector (dimension n), u is the input vector, y is the output vector, A is the system matrix (nxn), B is the input matrix, C is the output matrix, D is the feedthrough matrix (often zero).

For a Robot Joint

A single revolute joint with motor inertia I, viscous friction b, and no gravity:

Full-State Feedback

If all states are measurable, we can use u = -K*x + r, where K is a gain matrix. The closed-loop system becomes x_dot = (A - B*K)*x + B*r. The eigenvalues of (A - B*K) determine stability and performance. Pole placement: choose desired eigenvalues (closed-loop poles) and compute K using Ackermann's formula or the place() function in MATLAB/Python.

Observability and State Estimation

If not all states are directly measurable (e.g., velocity from position-only sensors), a state observer (Luenberger observer) estimates the full state from partial measurements:

The observer gain L is designed so that the estimation error converges quickly (observer poles faster than controller poles by a factor of 2-5x). The separation principle guarantees that observer and controller can be designed independently for linear systems.

Controllability and Observability

• A system is controllable if rank([B, AB, A^2*B, ..., A^{n-1}*B]) = n. Meaning: the input can drive the state to any desired value.
• A system is observable if rank([C; CA; CA^2; ...; CA^{n-1}]) = n. Meaning: the full state can be determined from the output.
• A robot joint with position encoder is observable (position measured, velocity estimated). A flexible joint (with spring between motor and link) needs both motor and link position to be fully observable.

LQR — Linear Quadratic Regulator

LQR is the most elegant result in optimal control: it finds the state-feedback gain K that minimizes a quadratic cost function, balancing tracking performance against control effort.

Q (positive semi-definite) penalizes state deviations; R (positive definite) penalizes control effort. Large Q/R ratio = aggressive tracking. Small Q/R ratio = energy-efficient but slower.

Solution

The optimal gain is K = R^{-1} * B^T * P, where P is the unique positive-definite solution of the algebraic Riccati equation:

This is solved numerically by MATLAB's lqr(A,B,Q,R) or Python's scipy.linalg.solve_continuous_are(). The resulting closed-loop system is guaranteed stable (assuming controllability).

LQR for Robotics

• Balancing robots — LQR is the standard controller for inverted pendulum/segway-type robots. The state is [angle, angle_rate, position, velocity]; Q and R are tuned to balance stabilization (keep upright) vs position tracking.
• Quadrotor stabilization — inner-loop attitude control often uses LQR. The linearized dynamics around hover give a clean state-space model.
• Legged locomotion — linearize around a nominal trajectory, apply time-varying LQR (LTV-LQR) to stabilize walking gaits. Used in MIT Mini Cheetah and Agility Digit.

LQR Limitations

• Assumes linear dynamics — must linearize nonlinear robot dynamics around an operating point.
• Does not handle constraints (joint limits, torque limits) — the optimal control may request impossible torques.
• Full-state feedback required — need an observer if not all states are measured.
• Infinite-horizon formulation — no finite-time guarantees (use finite-horizon LQR or MPC for time-limited tasks).

Computed Torque Control

Also called inverse dynamics control or feedback linearization. This model-based approach uses knowledge of the robot dynamics to cancel nonlinear terms, then applies linear control on the linearized system.

Robot Dynamics

The equations of motion for an n-DOF robot manipulator (Euler-Lagrange formulation):

where M(q) is the inertia matrix (nxn, symmetric, positive definite), C(q,q') contains Coriolis and centrifugal terms, g(q) is the gravity vector, and tau is the vector of joint torques.

Control Law

Substituting into the dynamics equation, the nonlinear terms cancel exactly (assuming perfect model), leaving:

This is a linear, decoupled second-order system for each joint. Choose Kp and Kd to place poles as desired (e.g., critically damped: Kd = 2*sqrt(Kp)).

Requirements and Limitations

• Requires an accurate dynamic model — inertia parameters, center of mass locations, and friction models must be identified. Errors in M, C, g cause imperfect cancellation and residual tracking errors.
• Computationally expensive — computing M(q), C(q,q'), g(q) at 1 kHz requires efficient recursive algorithms (Newton-Euler).
• Sensitive to payload changes — picking up an object changes M and g. Adaptive variants estimate payload online.
• Does not handle actuator limits — the computed torque may exceed motor capabilities.

Robust Computed Torque

Adding a robust term to handle model uncertainty: tau = M_hat * (q_d'' + Kd*e' + Kp*e) + C_hat*q' + g_hat + u_robust, where u_robust is a sliding-mode or H-infinity term that bounds the effect of model errors. Spong (1992) and Slotine & Li (1991) provide thorough treatments.

Model Predictive Control (MPC)

MPC (also called receding-horizon control) is the most powerful framework for robot control when constraints matter. At each time step, it solves a finite-horizon optimal control problem online, applies the first control action, then re-solves at the next step.

Formulation

Why MPC for Robotics?

• Constraint handling — joint limits, torque limits, velocity limits, and collision avoidance are naturally incorporated as inequality constraints.
• Preview capability — the controller "looks ahead" N steps and plans accordingly. Can anticipate upcoming reference changes or obstacles.
• Nonlinear dynamics — nonlinear MPC (NMPC) uses the full nonlinear model directly, no linearization needed.
• Multi-objective — the cost function can balance tracking, energy, smoothness, and other objectives.

Computational Cost

Linear MPC (with quadratic cost and linear constraints) reduces to a Quadratic Program (QP), solvable in milliseconds with solvers like OSQP, qpOASES, or ECOS. Nonlinear MPC requires solving a Nonlinear Program (NLP) at each step — much harder but feasible for moderate-dimensional systems using CasADi, ACADOS, or Crocoddyl.

MPC in Practice

• MIT Mini Cheetah — uses convex MPC for locomotion at 30 Hz. The robot model is simplified to a single rigid body with contact forces as decision variables. Solves a QP per step. Published by Kim et al. (2019).
• Agility Digit — uses nonlinear MPC for whole-body locomotion planning. CasADi-based solver running on the robot's onboard computer.
• ANYmal (ETH Zurich / ANYbotics) — NMPC with automatic differentiation for quadrupedal locomotion over rough terrain.
• Autonomous driving — MPC controls steering and throttle to follow a planned path while respecting lane boundaries, speed limits, and vehicle dynamics constraints.

Key MPC Software

Impedance & Admittance Control

Traditional position control commands the robot to a position and resists any deviation. But for contact tasks (assembly, polishing, human-robot interaction), the robot must comply with external forces rather than fight them. Impedance and admittance control define the dynamic relationship between force and displacement.

Impedance Control

The robot behaves as a mass-spring-damper system: when pushed, it deflects proportionally. The desired impedance relationship is:

where M_d, B_d, K_d are the desired inertia, damping, and stiffness (chosen by the designer), and x_d is the reference trajectory. The controller computes joint torques to realize this dynamic relationship.

• High K_d = stiff behavior (good for free motion, position tracking)
• Low K_d = compliant behavior (good for contact, safe interaction)
• B_d provides damping to prevent oscillation at contact transitions
• M_d shapes the apparent inertia — lower M_d makes the robot feel lighter

Admittance Control

The inverse approach: measure external forces (via force/torque sensor) and compute position corrections. The admittance relationship is x - x_d = (1/Z) * F_ext, where Z is the impedance. Used when the inner loop is a stiff position controller (typical for industrial robots) and adding compliance on top.

When to Use Which

Applications

• Peg-in-hole assembly — compliance allows the peg to align with the hole despite position uncertainty. Classic problem from Whitney (1982).
• Surface finishing — maintain constant contact force while following a surface contour. Impedance control adjusts position to regulate force.
• Human-robot collaboration — the robot yields when a human pushes it (low impedance in the direction of human intent). ISO 15066 specifies force/pressure limits for collaborative robots.
• Prosthetics — impedance control of powered prosthetic joints creates natural-feeling limb behavior. Adjust stiffness and damping based on gait phase.

Adaptive Control

Adaptive control adjusts controller parameters in real-time to compensate for unknown or changing system dynamics. Essential when the robot picks up unknown payloads, wears out over time, or operates in varying conditions.

Model Reference Adaptive Control (MRAC)

Define a reference model that specifies the desired closed-loop behavior. The adaptive law adjusts controller gains so that the actual system tracks the reference model. Lyapunov-based design ensures stability. Used in aerospace (first practical application: X-15 flight control, 1960s).

Adaptive Computed Torque

The robot dynamics are linear in the dynamic parameters (masses, inertias, center of mass locations, friction coefficients): M(q)*q'' + C(q,q')*q' + g(q) = Y(q,q',q'')*theta, where Y is the regressor matrix and theta is the parameter vector. An adaptive law updates theta_hat based on tracking error:

where Gamma is a positive-definite adaptation gain matrix and s is a filtered tracking error. This guarantees convergence of the tracking error to zero even with unknown parameters. The result from Slotine and Li (1987) is one of the most important in adaptive robotics.

Challenges

• Parameter drift — without persistent excitation, parameters may drift to incorrect values while tracking error stays zero.
• Unmodeled dynamics — high-frequency dynamics (flexibility, backlash) can destabilize adaptive controllers.
• Robustness modifications — sigma-modification, e-modification, and dead zones prevent parameter drift and improve robustness.

Practical Tuning Tips

General Guidelines

• Start with Kd alone — apply velocity damping first. The robot should resist motion without oscillating. This stabilizes the system before adding position tracking.
• Add Kp gradually — increase proportional gain until the system responds quickly but does not overshoot excessively. A good starting ratio: Kd/Kp = 0.1 * (settling time you want).
• Add Ki only if needed — integral action is required for zero steady-state error under constant loads (gravity). Start with Ki very small; it integrates fast.
• Anti-windup is mandatory — always clamp the integral term. When the actuator saturates, the integral keeps growing without effect, causing massive overshoot when the error changes sign.
• Filter the derivative — never differentiate a raw encoder signal. Use a first-order low-pass filter with cutoff at 5-10x the control bandwidth.
• Sample rate matters — PID should run at 10-20x the desired closed-loop bandwidth. For a 50 Hz bandwidth, run the controller at 500-1000 Hz.

Common Pitfalls

• Tuning on the bench vs under load — a robot arm tuned with no payload will oscillate when it picks up a heavy object. Always tune under representative load conditions.
• Ignoring friction — static friction (stiction) causes limit cycles around the setpoint. Dither, integral action, or friction compensation can help.
• Ignoring backlash — gear backlash creates a dead zone in the control loop. The system oscillates between the backlash limits. Use harmonic drives or direct-drive actuators for precision applications.
• Not checking actuator saturation — if the controller requests more torque than the motor can deliver, the closed-loop behavior changes completely. Always monitor commanded vs actual torque.

Frequency Response Testing

Inject a chirp signal (sine sweep from 0.1 Hz to 100 Hz) and measure the response. Plot gain and phase vs frequency. This gives the actual closed-loop bandwidth, identifies resonances (flexible modes), and validates that gain and phase margins are adequate. Every serious robot commissioning includes this step.

References & Further Reading