So, last lecture was really satisfying because there, we finally understood how
we can do control design using the state and then at the same time, figure out
what the state is and everything works. Thanks to this fantastic principle known,
known as the separation principle. So, what it tells us is that we can
completely decouple a control and observer design, and here, I have a
rather important little parentheses that says, in theory.
Now, there is a great American thinker that has figured out that this in theory
is actually kind of important. This is Yogi Berra, the baseball player
who presumably said, in theory, theory and practice are the same. In practice,
they are not. Now, this is rather profound and it has
some implications on the fact that just because the theory tells us something, we
need to be aware of certain things at least.
So, the first thing we need to be aware of is, the controller is really only
useful once the estimate, that the estimated state is close to the actual
state, meaning, that the controller doesn't
really do anything useful until the observer has converged.
So, what we want to do is want to make sure that the observer converges quickly.
What that means is that we want the observer to be faster which in turn means
that this eigenvalues that we were picking should be larger for the observer
than the controller. Now, one thing we saw with large
eigenvalues though, is that we get large gains.
So, in the control side, this is kind of bad, because that means that we have
large actuation signals, which means that we can saturate the actuators.
In the controller side, I'm sorry, the observer side, that's no big deal because
the observer is entirely done in software.
There is nothing that's going to saturate, so we can actually make our
observer eigenvalues large without having to run into issues like saturation.
So practically, what we need to do is pick the eigenvalues typically in such a
way that the controller eigenvalues are all, first of all, they all need to have
negative real part, of course. And then, what we want to do is we want
to make the observer eigenvalues bigger because that means that the observer is
faster than what the controller is. So, here is a completely made up
eigenvalue selection. But the important thing here is that the
slowest observer eigenvalue, which really dictates how quickly the observer
converges, is significantly faster than the slowest controller eigenvalue.
So, that's something that we typically want when we're building our joint
observer control design structures. Okay.
Having said that, let's actually use this to control a humanoid robot.
And this is the Aldebaran Nao that we're going to be working on, and in fact, what
we can control on this thing are joint angles, meaning how the different angles
are, are moving. And luckily for us, we actually have
detailed models of these joint angles. In fact, for a given joint, the angular
acceleration is 1/J times Ki minus B theta dot.
And these things, well, they are physical things.
So, J is the moment of inertia, i is our input, alright, so i is actually equal to
u, here in this case. This is our input to the system.
This is the current replying at the motor.
Well, K is a torque constant that translates roughly currents into
accelerations and then there's always a friction coefficient,
the viscous friction coefficient in these motors.
Now, luckily for us when you buy a robot like this, someone has already figured
out these physical parameters and there are user manuals that describe what these
parameters are. Now, we need to put this on state base
form. And the first thing we're going to do, as always is say, well x1 is theta
and x2 is theta dot, alright?
We're also going to say that what we can match around this thing is the angle
itself. So, y is going to be equal to theta.
Well, with this choice, we get a linear time-invariance system that looks like
this. x dot is 0 1 x 0-b/Jx and then we have
this b matrix which is 0K/J times u and y is 1, 0 x is since we're pulling out the,
the, orientation. Now, one nice thing about this system is
that it is completely controllable and completely observable.
So, what we have indeed learned in this class should be applicable.
Okay. So, let's do that. The last thing we want to do though is we
actually don't want to hold or stabilize the Nao into all the angles being zero.
We want to be able to move it around. So, what we want to do is, we actually
would like to track a reference angle. We would like the, the angle of joints to
be something. So, I'm going to define a new variable e,
it stands for error. It's not the estimation error, it's
another error, which is the current angle minus the desired angle.
And then as the second variable tossing in the angular velocity.
And I would like to drive e to zero because if I have e=0, then I have theta
equal to theta desired, meaning, I'm holding it at the angle I would like.
And I have theta dot equal to zero, which means I'm actually holding it there.
I'm not moving through it only. Okay, so this is what we would like to
do. okay, then we need to write down the
dynamics for our new variable e. Well, e dot, well, it's simply, Ax+Bu,
because e dot is really, [SOUND] well, it's theta dot minus theta desired dot
theta double dot, right? But this thing is 0 because the, the desired heading is
constant, so all we're left with is theta dot, theta double dot, which is the same
as x dot, right? This is the same as x dot so what
we do is we plug in the equation for x dot and we get this.
Now, we don't want to express this in terms of x.
We want to express it in terms of e. And what we get if we plug in e is, we
get this expression instead. Now luckily for us, a times this vector
is actually equal to zero. And I encourage you to compute this so
that you trust me. But having done that, what we get is that e dot is equal to
Ae+Bu meaning we have same system dynamics as before but now, defined on
this error, where the error is the current orientation or angle of the joint
minus the desired angle of the joint. So, this is the dynamics we're caring
about. Well, we have to do the same thing to the
output. The output is Cx, well again, we replace
x with e plus this vector. So, this is Ce+C times this vector, and
remember that C was actually 1,0. So, if I take 1,0 times that, out comes
data desired. So, my output is C times e plus theta
desired. Now, this doesn't scare us one bit.
We just plug it into our standard controller and observer design
methodology. So, u is -K, not e because we don't know
e but e hat, which is our estimate of e.
And e hat dot, well,
it has the standard predictor part and it has the corrector part.
And the corrector part is the current output minus what the output would have
been. And the only difference is I have to keep
track of this little extra theta desired. But it's no big deal.
It acts exactly the same way. So, this is now my control structure.
And instead of me talking about it, why don't we move on to see an actual
humanoid robot executing this controlled strategy.
So now, that we have designed a, an observer based state feedback controller
for controlling the joint angles of this humanoid robot, the Aldebaran Nao, we're
ready to do it for real. And I'm here with Amy LaViers. She was a
graduate student at Georgia Tech. And what she has done is made the Nao
move its arms and its head, and even its upper body, in such a way that it is
executing a friendly wave towards, probably you, who are watching this right
now. And, what's happening is we're running
the same controller on all the different joints with different desired angles to
get the effect out. So, Amy, why don't we take the Nao for a
little spin there and see what it can do? So, what's going on here is that we're
sequentially running multiple desired angles and that's how we're getting this
effect. In fact, why don't we watch this again
because I think this is quite, it's quite charming to be honest.
So, here we go. Observer-based state feedback controlling
action. Oh, thank you very much,
Amy. And thank you.
