Okay. So, so far in the course, we have mainly chit-chatted about things. We've seen some models and we have now a model of a, a cruise controller or at least how the controller input affects the velocity of a car. We see it here, x dot was c over m times u. Where x was the velocity, u was the applied input, and c was some unknown parameter, and m was the mass of the vehicle. We also talked a little bit about what we wanted the controller to do. So now, let's start designing controllers. Let's actually do it. No more excuses. What we want, of course, is that x should approach r. And recall, again, that r was the reference velocity that we wanted the car to get to. And x is the actual velocity. And typically, in control design, you talk about asymptotic properties, which is fancy speak for when t goes to infinity. So, what we want, is, after a while x should approach r. The velocity should approach the reference velocity. Or another way of saying that is that the error, so the mismatch or imbalance between the 2 two velocities should approach 0. That's what we want. So, I am going to give you a controller here. This is attempt 1. I have picked some values for, you know, how hard I want to hit the gas pedal. And I'm going to say that, if the error is positive, so positive error means that the reference is bigger than the state, which means that we're driving slower than we should. Then, let's hit the gas. And if the error is negative, meaning that the velocity, the actual velocity of the car is greater than the reference velocity, which means we're going too fast, let's brake. And if we're perfect, let's do nothing. Fine. So, take a second to stare at this and see what you think. Is this going to work or not? Okay, a second is up let's take a look. Yeah, it works beautifully. I put the reference velocity to 70 so it's up here, here is 70. This is the actual velocity of the car and look at what the car is doing. It's basically starting down somewhere and then increasing up to 70 and then it's remaining flat around 70. So, that's, that's awesome. It's doing what it should be doing. Now, I'm calling this bang-bang control and that's actually a technical term from doing things like u max and negative u max. You're switching between two extremes. so this seems to be easy peasy and there's no need to take a course on controls and mobile robots. Now, let's see what the control signals is actually doing. Let's see what the control values were that generated this nice and pretty plot. Well, they look like this. This ladies and gentlemen is miserable. Even though the car was doing the right thing in terms of the velocity, I had u max be a 100, so negative max is minus a 100 and first of all, we are accelerating up for a while, until we hit the right velocity. And then, we start switching wildly between plus and minus a 100. Well, when the error was 0, the u was supposed to be 0, but the error is never going to be exactly 0. Just ain't going to happen, and this is bad, because what's going on? Well, first of all, we get a really bumpy ride. We're going to be tossed around in the car, backwards, forwards, backwards, forwards, because of all these accelerations that are being induced by these, these extreme control signals. We're also burning out the actuators. We're asking the car to respond extremely aggressive and for no good reason. I mean, we're basically doing a lot of work when we're very close to perfect. So, this is actually not a particularly good control design. And the problem is exactly this of overreaction to small errors. Even though the error is tiny, as long as it's positive, we're slamming gas as hard as we can. so we somehow need to change this design. So, how shall we do that? Well, the easiest thing to do is to say, you know what, when error is small, let's have the control signal be small. In fact, here's my second attempt. u is k times e, for some positive k, e is the error. Positive error means we're going too slow, u should be positive. Negati ve error means we're going to fast, u should be negative. So this is a much cleaner design. It's what's called it's, it's a smooth feedback law. It's actually linear feedback in the error, and this seems to be much more reasonable because small error yields small control signals, which is what we wanted. Nice and smooth. We're not going to wildly fluctuate in our controller. And, in fact, this is called a P regulator, where P stands for proportional because the control signal, the input, u, is directly proportional to the error through this k controlled gain. So, here is a completely different and possibly better way of doing it. This is what the P-regulator in action looks like. So, it's nice and smooth, right? It seems even stable. Stable, again, we haven't really defined it, but it's clearly we're not blowing up the course. So, nice and smooth and stable. Now, here is a little problem. You see what it says up here? It says 60 and I had my reference be 70. So, even though we're nice and smooth, we actually did not hit the target value. The reference signal was supposed to be 70, and we got to 58 or so. so even though we're stable and smooth, we're not achieving tracking. And here is the problem. I actually added a term to the model and this is a term that really reflects wind resistance because here is the acceleration of the car, this is our term. Well, if we're going really, really fast, we're going to encounter wind resistance. So, add it a little bit of wind resistance. This says that if we're going positive and fast, then we're getting a negative force, we, meaning, we're being slow down a little bit and gamma is some term or some coefficient that again we don't know. And this was the model I used when I simulated the controller. and somehow, the P-regulator wasn't strong enough to, to deal with this, and in fact, let's see what happens. At steady state, so steady state means when nothing changes anymore, and if for your call from the plot, after awhile, x stopped varying. At steady state, x is not varying. Well, another way of saying that, is that the time derivative of x is 0. So, at steady state, x is not varying, which means that this term here has to be equal to 0. And this is the model right? Well, I know what u is. u is equal to k times error, which is r minus x. So, I'm plugging in u there. And I'm saying that this thing has to be equal to 0. Well, if I write down the corresponding equation now that says that, this term here has to be equal to 0, then I get this. Well, I can do even better than that. What I get is that x, let me get rid of the red stuff there, x is now going to be, ck divided by ck plus m gamma times r, and this, for all these coefficients being positive, is always strictly less than r. Which means, that at steady state, the velocity is not going to be, it's not going to make it up to the reference velocity. And we can see that if we make k really, really, really big, then these two terms are going to dominate and we're going to get closer and closer to having this complicated thing, go to r. So, as k becomes bigger, we're getting closer to r, which means we're having a stronger gain. But we're never, for any finite value of the gain, going to actually make it up to the reference. So, something is lacking and next time, we're going to see what it is that is lacking to actually achieve tracking and stability.