0:00

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.