H Infinity and Mu Synthesis | Robust Control, Part 5
From the series: Robust Control
Brian Douglas
This video walks through a controller design for an active suspension system. Actually, we design two controllers. For the first, we use H infinity synthesis to design a controller for a nominal plant model that will guarantee performance but not necessarily be robust to variation in the system. Then we build an uncertain model like we did in the last video and design a robust controller using mu synthesis.
Published: 12 Apr 2020
In this video, we're going to walk through a controller design for an active suspension system. Actually, we're going to design two controllers. For the first, we'll use each infinity synthesis to design a controller for a nominal plant model that will guarantee performance but not necessarily be robust to variation in the system.
Then, we'll build an uncertain model like we did in the last video and design a robust controller using mu synthesis. I think it'll be pretty interesting. So I hope you stick around for it. I'm Brian, and welcome to a MATLAB Tech Talk.
When a car hits a road bump, the tire absorbs some of that impact and compresses a little bit, and then it forces the whole wheel assembly up. This force transfers through the suspension and causes the body of the car to bounce. For a suspension system, we're usually interested in things like how the vehicle performs and how comfortable the ride is when it hits that bump.
Now, with an active suspension system alongside the passive springs and damping mechanisms, there's a hydraulic actuator that can inject forces into the system to fine tune the performance and comfort that we desire. And we can approximate this system with the following model. We treat the flexing of the tire as a spring, the tire assembly as a mass, which is then connected to the body mass through a spring damper system that represents the passive suspension components, and a hydraulic actuator that we treat as an input force.
With this simplified model of the plant, we can design a feedback controller, k, that will take in some measurements, which we'll call v, and produce the controlled variables u. For our system, we have I controlled variable, which is the hydraulic force that's being requested. And we'll use two measurements-- vehicle body acceleration, ab, and suspension travel, sd. Suspension travel is how compressed or expanded the suspension is.
So, this is our feedback control problem. Now let's get into how we design the controller for it. And like I said, we're going to start with h infinity synthesis.
To understand conceptually what h infinity and eventually mu synthesis is doing for us, we need to expand this block diagram. In addition to the controller input, we also have external inputs into the system that come from sources like disturbances and noise and even reference signals. We'll call these w.
And there's other outputs that we have to look at as well. These are the error signals that give us a sense of how well the system is performing. These outputs can be signals that are measured on the real system, or they can be virtual in the sense that we just use them temporarily in the model to design the controller, but we don't need them on the real system.
We'll call these error signals z. Let's say that our plant has a single external input that we care about, and that's the disturbance that comes from when we hit a bump in the road. And there are three error signals that we want to use to define performance. There's the body acceleration, suspension travel, and the requested actuator force.
So, here's the whole design problem in a nutshell. We want a controller that minimizes the error signals when a disturbance enters the system. And we can think of it this way.
When the car hits a bump, there's a disturbance. And that disturbance is amplified in some way through the tire and the springs and the dampers and moves the car up and down and stretches and compresses the suspension. The controller can modify how this disturbance impacts these signals by driving the actuator.
The goal is to drive the actuator such that the amplification of the disturbance is minimized and, in the process, uses the least amount of actuator force possible. And that's exactly what H infinity synthesis is doing for us. It's an optimization process that calculates the controller that minimizes the gain between w and z.
However, as a designer, you might not want each signal to be treated equally in this optimization problem. Therefore, we can manipulate the signals within the model by adding weighting factors to w and z to set the importance of individual signals. For example, we may lower the actuator weighting factor if we're not as concerned about actuator energy as we are about body acceleration. Or we may increase the weight if we want to drive the actuator less because we're more concerned about extending its life. And we may develop more than one controller, each with a different set of weights, and then allow the user to switch between different active suspension modes like performance and comfort or a balance between the two.
All right, now that we have an idea of how we're going to approach this, to set up and solve this problem, you can see we have a few design choices. We need to create a model of the plant. We need to determine which measured signals the controller has access to and which input variables it has control over.
We need to choose the external inputs and error signals. And then finally, we have to set up the cost function by weighting each signal. And once we have all of that, then we essentially solve a large optimization problem using H infinity synthesis.
And mathematically, it can be a bit tricky. But the point of this video is not to have you do this by hand. It's to give you a sense of how the controller works so that you can set up the problem yourself and let the tools solve the math for you.
So, let's go over to MATLAB and do just that. For the most part, this script follows along with the MathWorks example, robust control of an active suspension. But I modified it a bit for this video, and I'd recommend checking out the original example yourself if you want to dive into how to set all of this up and practice it yourself.
And this is going to look at first like a lot of confusing code, but I promise that the gist of this script is exactly what we just walked through. We start by setting up a model of the plant, which is the spring mass damper representation of the quarter car suspension. And at the moment, we'll assume that this model is perfect and there are no uncertainties in our dynamics. And we're going to come back to this assumption in just a bit.
Another thing to note here is that we're modeling the hydraulic actuator as a first order system. This means that the controller requests a force u, but the actual force that the actuator generates, fs, depends on its dynamics. Now, to continue the rest of the design setup, we set individual weighting functions for each of the external inputs and error signals. Like, for example, w road is a gain of 0.07.
But here's what's really cool. The weighting function can be frequency-dependent. So in this case, we're putting a high pass filter on the actuator signal, and this is going to penalize high frequency controller commands more than low frequency and therefore gives us a way to limit the control bandwidth. And something else to note here is that we're setting up three different sets of weights for body acceleration and suspension travel. This is how we can differentiate between performance mode and comfort mode and balanced mode. And going forward, we're actually going to solve for three different controllers, one for each of these gain sets.
Now we connect each of these blocks to create a single open loop model. This model includes the suspension dynamics and the actuator dynamics and the weighting functions, and this open loop function is called q car ic. All right, with the design problem set up, we can build the controller with the H infinity synthesis command, and it's pretty simple. It's a single command where we pass it the open loop function and tell it which signals the controller has access to.
But keep in mind that what's going on behind the scenes is that it's solving an optimization problem by finding the controller, k, that minimizes the energy transfer from the external inputs to the error signals. And actually, it's doing it three times, one for each gain set. So what we're left with is a controller that takes in two measured signals, suspension travel and body acceleration, and it outputs the actuator command u.
Let's take a look at these controllers in action by simulating the response to a five centimeter road bump. I built the closed loop system with the H infinity controllers, and here, I'm running a one second simulation for different configurations-- the uncontrolled system and the comfort balanced and performance profiles. And check this out.
The green line is the five centimeter road bump, the input, and the blue line is the open loop response. This is how the system would behave if all we had were the passive suspension components. But with a closed loop controller, we have the comfort profile, where the bump is damped out nicely like you're floating on a cloud. And we have the performance profile that damps out quickly, and you can really feel the road. And the balanced is somewhere in between the two.
So, this is all well and good, except that these controllers were designed using an imperfect model. We know that the suspension system is more complex than a simple spring mass damper system. And there's also four wheels interacting with each other, and there's noise in the sensors, and the actuator dynamics might vary, among other things.
So, the question we keep asking ourselves in this series is, how does this system handle variation? Well, let's just look at the effects of an uncertain actuator. Here, I'm varying the nominal actuator dynamics with some frequency-dependent uncertainty.
And then I'll rebuild the open loop model with this uncertain actuator. So, everything is the same as before. Just now, our plant is modeled with uncertainty. So let's see how well the nominal H infinity controller does by simulating the five centimeter road bump for 100 random actuator variations. And for simplicity, we're going to look at just the balanced controller.
Most of the actuator combinations appear to be stable and produce a reasonable response. However, some variations create an unstable response. So the H infinity controller is not a great solution if the actuator dynamics can really vary as much as I've modeled.
So, how can we improve this? Well, we could go back and tweak the weights on the different signals and try to come up with a controller that is stable across these variations. But if we already have a model of our uncertain system, why don't we just develop a controller that takes those uncertainties into account from the start?
And this is what mu synthesis does. Mu synthesis is an extension of H infinity in the sense that it's still solving the same problem, except that it tries to minimize the worst case gain across the entire uncertainty space. And the way that it does this is with an iterative process called dk iteration.
And the mathematical details of this process isn't important for this video. But essentially, what it's doing in each step is running H infinity synthesis to find a nominal controller and checking its robustness. Then, it scales the problem based on the uncertainty in the system and runs another H infinity synthesis and checks its robustness and scales again. And it keeps doing this until the robust performance stops improving.
The robust performance is the peak mu value, and in general, the lower the number, the more robust the system is. You can see that the peak mu value is decreasing over each iteration and that the final value is what is reported as the best achieved robust performance. So, in this way, we know that whatever the worst case combination of uncertainty is, it will still have at least this level of robustness.
And just like with H infinity, we can run mu synthesis with a single command where we pass it the open loop function and tell it which signals the controller has access to. It's exactly the same. It's just using a slightly different optimization under the hood.
Here, I'm running it for just the balanced gain set, set number two. All right, let's check out the difference between the balanced H infinity controller and the comparable mu synthesis controller.
This is the same response that I showed earlier except now, we can see how the mu synthesis controller produces a response with less variability due to uncertainty. Both body position and suspension travel are very consistent and, importantly, stable. And at first, it looks like body acceleration is worse. But if we look closely, the bulk of the variations are more consistent here as well. And these wild acceleration swings are only associated with the variations that deviate the most from the nominal actuator. And so if you build your suspension with an actuator that is near the variation limit, the system will be stable, but it comes at the expense of having a slightly rougher ride-- probably a good trade off in the end.
All right, hopefully, you can see the value of thinking about where you have uncertainty in your system, modeling that uncertainty, and then using that uncertain model to develop a robust controller. I definitely think it's worthwhile trying to practice this on your own because it'll allow you to tweak some of the values and see how that impacts the final controller design. And one way to do this is to just check out the MathWorks example in the description below.
But that's where I'm going to leave this video. So if you don't want to miss any other future Tech Talk videos, don't forget to subscribe to this channel. And if you want to check out my channel, Control System Lectures, I cover more control theory topics there as well. Thanks for watching, and I'll see you next time.