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