Now we have a rather useful seemingly general purpose controller, that we call the PID regulator. And, we saw that we could use it to design a cruise controller for a car to make the car reach the, the desired velocity. what I haven't said though is how do we actually take something that looks, Looks, to be completely honest, rather awkward. You know? Integrals and derivatives and stuff. And actually turn it into executable code. Meaning, how do we go from this mathematical expression to something that's running on a platform? Well, the first thing to note is that, we always have a sample time. We're sampling at a certain rate. There's a certain clock frequency on the, on the computer. Well, what we need to do is we need to take these continuous time objects that we have here in the, in the PAD regulator and have them be defined in this discreet time. First of all here is an arrow, it doesn't matter if this is running in continuous time and discrete time, the proportional part we just read in the current's velocity. And compare it to the reference velocity, and then we get the error at time, k times delta t. So that's trivial. Now, but what do we do with derivatives and integrals? Well, let's start with the derivatives, because they are not so hard. we know that, roughly, a derivative is the new value. Minus the old value divided delta t. In fact, as delta t goes to 0, this becomes the definition of a derivative limit. So, we actually know that if I can store my old error, compute a new error, take the difference and divide it by delta t, I have a pretty good approximation of edot, which is this thing de(t)/dt, so I actually can approximate the, the derivative part in a rather direct way. Compared the latest value to the previous value divided by delta two, and we're good. Now the integral. That's where we're going to have to do a little bit of work. So, what is the integral? Well the integral is The sum under the curve right. That's the integral. Well is there some way of approximating this? Well, clearly it is. We can sum up all these little blocks. This is a rim approximation of the integral. So what this means is well we're not going to get the integral exactly, but if you can sum up these blocks somehow and the width here is going to be. what did we call it? Delta t. So the width of each base of the rectangle is delta t. So if you can do that. Then we're getting a, a reasonably good approximation. And, in fact, then the integral is simply a sum of the values at the sample time. So the value up there. The value at that time. And then we multiply it by delta T to get the rectangle, and then we sum up all the rectangles. That's a reasonable approximation and in fact what I'm going to do is I'm going to take this sum and call the sum E. So this is the same thing. So then the integral is roughly equal to delta T times E. Well, that turns out to be useful because, let's get rid of that stuff again. my next value, delta, or E delta t times e new. Well, it's delta t times the sum, but now I'm summing to n plus 1, well, let's pull out the last term. So, the error At time, n plus 1 times delta t. That's the last value that we called little e new up here. Let's pull that out, multiply it by delta t, and what's left is the sum from 1 or 0 to n, which is E old, times delta t. So, delta t. E new is equal to delta t, E old + this guy here. Or if I want to put it in a slightly more compact way, E new where E is the sum of the errors is E old + the latest error. Which is a little bit dah. The new sum is the old sum plus the latest entry. So, that gives me Enew and now, since I kne know that the integral is delta t x E, I know that, well, the integral term that I get here is simply delta t times Enew which gives me an approximation of. The interval. So, now, having said it, let's put this into, into pseudo-code here. So, every time the controller is called, well, I'm going to read in the latest error, which is the reference minus the measurement. And then, I'm going to say e _dot. E_dot is really. E minus, now we call it, let's call it e old, here. It's really divided by delta t, right? But the D part of the controller is Kd times this thing. Well, what if I just called this thing my new, let's call it kD prime. I just divided by delta t because I don't actually need to typically know delta t. Let's call this kD prime. Well, then I just got rid of delta t, and I don't have to worry about. Delta t. I do the same thing for the integral. So e new is e old plus the latest error. Again, I really have that this thing, this integral, is roughly equal to delta t. Times E. So if I have kI times that, I have this times kI, well let's take these guys and call this, this is my new kI. Then again I get rid of the T, so then if I do that, my actual controller is KP times E times KP times E dot. Which I just computed and KI times E. This is my control structure, this is how we actually implement it. And then I just need to at the end, remember to store the light, the latest E as the old E so the next time I call the controller, I have the previous value. This is the implementation of a. PID regulator. So let's do it. OK. I'm going to point out again. The coefficients include the sample times. I pointed that out already. But let's do it. Before we do it though I actually want to say that that's the end. Almost of Module 1. And in Module 2, we're going to go robotics. In the sense that we're going to see, now, how to relate some of these initial concepts to robotics. But, in the interest of full disclosure, we actually don't know why anything we did in Module. 1 actually worked. So Module 3 is we're going to revisit what we did here. But, revisit it in a much more systematic way. Okay, that's enough chitchat. Now, let's do it. We're going to do altitude control. Which means we're going to control the height, how high up in the air a Quadrotor is. And the model we're going to use is, well, x is going to be, so here's the height, here's the ground, so x is going to be how high up this thing is. And x.., which is the acceleration of the quadrotor, well g, the gravity, is pulling it down, so there has to be a -g somewhere. gravity is pulling it down, and then what we're doing is we're really controlling the velocity of the rotor collectives. So these are all the rotors of the quadrotor, all the four rotors, the angular velocity of this thing we're controlling. And that's translating into thrust and upthrust through This coefficient, c, that we don't know. And we actually really don't know what the gravitational constant is either, but this is the model we're going to use. And this is the controller we're going to use. And instead of me showing plots and simulations, why don't we get away from the Power Point presentation right here, and move over to an actual quadrotor running a PID. Regulator. So, now that we have a way of designing reasonably good controllers. In this case, PID regulators. we have some understanding of the basic performance objectives we're trying to hit. In this case, stability, tracking, and robustness. We even have a model, or at least a rudimentary model of a. Quadrotor aerial vehicle. What we did in the model is we tried to somehow connect the rotor collective speed to an up-thrust and the model included some parameters that we don't know. It even included the gravitational constant. The idea, of course, with robustness now is, we should not have to know these parameters. Exactly. Because that would actually be a rather poor and fragile control assign. So I have JP Delacroix with me here who is a graduate student at Georgia Tech. And without any further ado, JP, let's see what thee PID regulator actually looks like in action. , So what we're doing now is altitude control only. So we're trying to make this thing stay at the fixed altitude. It's going to drift a little bit sideways because we're not controlling sideways drift at all. one thing we can see right off the bat is that the system is indeed stabilized. Because if it wasn't, the quadrotor would actually fall down to the ground. The other thing we see is, when I'm pushing it a little bit like this, it's able to overcome it. I can even push it down a little bit. And the controller fights these disturbance, so robustness is, certainly achieved. In terms of tracking, it's not so clear what's actually going on because we don't exactly see what the reference height is, however we are measuring altitude with a downward facing ultrasonic sensor and, let's get this thing out of the way of JP. And the integral part or the integral term in the PID regulator is ensuring that modulatiries these extra errors in the height measurements, we are actually achieving the. The altitude we were, looking for. So with this rather simple initial experiment, we're going to declare success when it comes to PID regulation. And we now are going to move on to bigger and better problems. Thank you. ,, .