4.6 Adaptive control

Adaptive control overview

Adaptive control lets a robot's controller adjust its own parameters in real-time based on what's actually happening in the system and environment. Instead of relying on a fixed set of gains tuned for one specific scenario, the controller continuously monitors the system's behavior and updates itself to maintain good performance.

This matters for autonomous robots because they rarely operate under perfectly predictable conditions. Payloads change, surfaces vary, parts wear down, and disturbances show up unexpectedly. Adaptive control gives the robot a way to handle all of that without needing a human to re-tune things manually.

Adaptive vs non-adaptive control

Non-adaptive control uses fixed controller parameters designed around a nominal model of the system. Those parameters never change during operation. If the real system drifts from the model, performance degrades.

Adaptive control adjusts controller parameters online using real-time measurements and estimates of the system's current behavior. This makes it far more effective at handling:

• System uncertainties (unknown friction, mass, etc.)
• Parameter variations over time (wear, temperature changes)
• External disturbances (wind, uneven terrain, collisions)

The tradeoff is complexity. Adaptive controllers are harder to design, analyze, and implement than fixed-gain controllers.

Applications of adaptive control

Adaptive control shows up across aerospace, automotive, robotics, and process control. Some concrete examples:

• Aircraft autopilots that maintain handling quality as fuel burns off and the center of gravity shifts
• Industrial robot arms that adjust to different payloads without manual re-tuning
• Chemical process controllers that track changing reaction dynamics

For autonomous robots specifically, adaptive control enables operation in unstructured environments where the robot can't know everything about its surroundings in advance.

Types of adaptive control

The right adaptive control approach depends on how much you know about the system, what kind of uncertainties you're dealing with, and what performance you need. Here are the three main categories.

Model reference adaptive control (MRAC)

MRAC starts with a reference model that describes how you want the closed-loop system to behave. The adaptive controller then adjusts its parameters to minimize the error between the actual system output and the reference model output.

How it works:

1. Define a reference model with the desired response characteristics (rise time, overshoot, etc.)
2. Measure the actual system output
3. Compute the error between the actual output and the reference model output
4. Use an adaptation law to update the controller parameters in a direction that reduces this error

MRAC works well when you have a clear picture of the desired behavior but uncertainty in the plant parameters. A classic example is an adaptive flight control system that maintains desired handling qualities even as aircraft dynamics change with altitude, speed, or damage.

Self-tuning regulators (STR)

STR combines two tasks into one loop: system identification and control design. At each time step, the controller estimates the current system parameters, then redesigns the control law based on those estimates.

How it works:

1. Collect input-output data from the system
2. Use an online identification algorithm (like recursive least squares) to estimate the current plant parameters
3. Design or update the controller gains using the estimated parameters
4. Apply the updated control signal and repeat

STR is a good fit when the system parameters are unknown or change over time. For example, a temperature controller for a chemical reactor might use STR to estimate the process dynamics as they shift and adjust control gains to maintain the target temperature.

Dual control

Dual control tackles a subtle problem: to get good parameter estimates, you sometimes need to "excite" the system with varied inputs, but doing so can hurt tracking performance. Dual control explicitly balances these two competing goals.

• Exploration: inject enough variation into the control signal to improve parameter estimates
• Exploitation: use the best current estimates to minimize tracking error

This approach is most useful when uncertainties are large and the controller genuinely needs to learn about the system while controlling it. Think of a robot manipulator exploring different trajectories to build a better dynamic model while still keeping tracking errors small.

Adaptive control techniques

These are the building blocks that adaptive controllers use to estimate parameters, update gains, and maintain stability. Most practical adaptive controllers combine several of these techniques.

Gain scheduling

Gain scheduling is the simplest form of adaptive control. You pre-design a set of controller gains for different operating conditions, then switch or interpolate between them based on measured variables.

1. Identify the key operating regimes (e.g., low speed, medium speed, high speed)
2. Design and tune a fixed controller for each regime
3. During operation, measure the scheduling variable (e.g., vehicle speed)
4. Select or interpolate the appropriate controller gains

An automotive suspension system might adjust damping coefficients based on vehicle speed and road roughness. Gain scheduling is straightforward to implement, but it only works well when the operating regimes are well understood ahead of time. It doesn't handle truly unexpected changes.

Model identification

Model identification estimates a mathematical model of the system from input-output data. Adaptive controllers do this online, updating the model as new data arrives.

Common online identification methods include:

• Recursive least squares (RLS): efficiently updates parameter estimates as each new data point comes in
• Extended Kalman filter (EKF): handles nonlinear systems and noisy measurements

Once the model is updated, the controller uses it to redesign or adjust the control law. For instance, a robot arm controller might continuously identify the arm's dynamic model from sensor data and update the feedforward torques accordingly.

Parameter estimation

Parameter estimation is closely related to model identification but focuses on estimating specific unknown quantities (mass, friction coefficient, road grade) rather than a full system model.

Common techniques:

• Gradient descent: adjusts parameter estimates in the direction that reduces prediction error
• Least squares: minimizes the sum of squared prediction errors over a window of data

An adaptive cruise control system, for example, might estimate the vehicle's current mass and the road grade from acceleration measurements, then adjust throttle and braking commands to maintain the set speed.

Stability of adaptive systems

Stability analysis is one of the hardest parts of adaptive control. Because the controller parameters are changing over time, you can't just analyze a fixed system. You need tools that account for the adaptation dynamics themselves.

Lyapunov stability analysis

Lyapunov stability theory is the primary tool for proving that an adaptive controller will remain stable. The idea is to construct a Lyapunov function, a scalar function that acts like a measure of "energy" in the system. If you can show this function always decreases (or at least never increases), the system is stable.

In adaptive control, the Lyapunov function typically depends on both the tracking error and the parameter estimation error. The adaptation law is then derived from the requirement that the Lyapunov function decreases, which is why you'll often see the phrase "Lyapunov-based adaptation law."

For a robot manipulator, this approach can guarantee that tracking errors converge to zero (global asymptotic stability) as long as certain conditions are met.

Robust adaptive control

Standard adaptive controllers can run into trouble when there are unmodeled dynamics, persistent disturbances, or noise. Robust adaptive control adds mechanisms to prevent these issues from destabilizing the system.

Key techniques include:

• Dead-zones: stop adapting when the error is small enough that it might just be noise
• Projection operators: constrain parameter estimates to stay within known physical bounds
• $\sigma$-modification: adds a damping term to the adaptation law that pulls parameters back toward nominal values, preventing unbounded drift

These modifications sacrifice some adaptation performance in exchange for guaranteed robustness. An adaptive aircraft controller, for example, might use $\sigma$-modification to stay stable despite unmodeled aerodynamic effects.

Adaptive control limitations

Adaptive control isn't a universal solution. Key limitations to keep in mind:

• Persistent excitation requirement: Parameter estimates only converge if the system inputs are "rich enough" to distinguish between different parameter values. If the robot just sits still, the adaptive controller can't learn much.
• Unmodeled dynamics: If the real system has dynamics the adaptive model doesn't account for (flexible modes, time delays), adaptation can actually make things worse.
• Speed-robustness tradeoff: Fast adaptation tracks changes quickly but is more sensitive to noise. Slow adaptation is more robust but can't keep up with rapid changes.

Adaptive control in robotics

Adaptive control techniques apply to nearly every aspect of robot control. Here are the three main areas.

Adaptive motion control

Adaptive motion control lets a robot track desired trajectories even when its dynamic parameters are uncertain. The controller estimates quantities like mass, inertia, and friction coefficients online, then updates the control gains to minimize tracking error.

A mobile robot navigating uneven terrain is a good example. As the surface changes or the robot picks up a load, the adaptive controller re-estimates the relevant parameters and adjusts the control effort to keep the robot on its planned path.

Adaptive manipulation

When a robot handles objects with unknown properties (mass, stiffness, fragility), adaptive manipulation controllers use force and torque sensor data to estimate those properties and adjust the grasping strategy.

For example, an adaptive gripper controller might start with a conservative grip force, then gradually adjust based on estimated object fragility and surface friction. This prevents both dropping the object and crushing it.

Adaptive locomotion control

Legged robots face constantly changing contact conditions. Adaptive locomotion controllers estimate terrain properties (stiffness, friction) and the robot's own dynamic parameters (leg compliance, body inertia) to optimize gait in real time.

A quadruped robot walking from pavement onto sand, for instance, would detect the change in ground stiffness and adjust leg stiffness and gait timing to maintain stable locomotion.

Challenges in adaptive control

Real-world implementation introduces problems that don't always show up in theory. These are the main ones.

Nonlinear system modeling

Most real robots have nonlinear dynamics (nonlinear friction, backlash, coupling between joints). Linear adaptive controllers can struggle with these. Solutions include:

• Nonlinear parameterizations that capture known nonlinear structure
• Online function approximators like neural networks or fuzzy systems that learn the nonlinear mapping from data

A robot arm with significant joint friction and backlash might use a neural network within the adaptive controller to model these effects, since a simple linear model wouldn't capture them.

Unmodeled dynamics

Every model leaves something out. High-frequency vibration modes in a flexible robot arm, communication delays in a networked system, or actuator dynamics that were assumed negligible can all cause problems. If the adaptive controller tries to compensate for effects that are actually caused by unmodeled dynamics, it can destabilize the system.

Robust adaptation laws (dead-zones, projection, $\sigma$-modification) are the standard defense here.

Disturbance rejection

External disturbances like wind gusts on a drone or contact forces on a manipulator need to be rejected without corrupting the parameter estimates. Advanced techniques for this include:

• $\mathcal{L}_1$ adaptive control: separates the adaptation from the control, allowing fast adaptation without sacrificing robustness
• Sliding mode control: forces the system onto a predefined surface in state space, providing inherent disturbance rejection

A drone maintaining stable hover in gusty wind is a classic application of $\mathcal{L}_1$ adaptive control, where the controller must distinguish between wind disturbances and changes in the drone's own dynamics.

Adaptive control implementations

Getting adaptive control to work on real hardware requires attention to software design, computing resources, and timing.

Software architectures

Adaptive control software should be modular so you can swap out identification algorithms, adaptation laws, or controller structures without rewriting everything. Common approaches include:

• Model-based design (e.g., MATLAB/Simulink) for rapid prototyping and auto-code generation
• Component-based frameworks that separate estimation, adaptation, and control into independent modules
• ROS-based frameworks that enable integration across different robot platforms and sensor configurations

Hardware requirements

The hardware platform needs enough computing power, memory, and I/O bandwidth to run the adaptive algorithm at the required update rate. For simple gain scheduling, a basic microcontroller may suffice. For neural-network-based adaptive controllers on high-DOF robots, you might need an FPGA or a dedicated real-time processor to achieve the necessary speed and determinism.

Real-time constraints

Adaptive controllers must update fast enough to track changes in the system. If the control loop runs too slowly, the parameter estimates lag behind reality and performance degrades or the system goes unstable.

This creates a tension: more sophisticated adaptive algorithms give better performance but take longer to compute. Practical implementation requires balancing algorithm complexity against the available computation time per control cycle. For a high-speed robot, this might mean simplifying the identification algorithm or reducing the model order to meet strict timing deadlines.