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. ,, .