0:00

So, we now have a general procedure for designing controllers which is pole

placement. And the whole idea there is, we pick our

k such that the desired eigenvalues line up.

We also, in the last lecture, learned when it works and when it doesn't and the

key characteristic there was controlability or complete

controlability. We can do pole placement when we have

complete controlability. If we don't, we can't.

Simple as that. And in fact, it's not just pole

placement. If we don't have complete controlability,

we can't make the system do what we want meaning, we have to buy a new one, bigger

b matrix. There's nothing else we can do.

Today, in this lecture, I would like to unleash these awesome powers that we have

on a complicated robotic system, namely a Segway robot.

And in fact, this is a robot that's balancing on these two wheels, and in

fact, here at Georgia Tech, we have a Segway robot, known as the

golem crane in Professor Mike Stillman's lab.

And basically, the way a Segway robot works is that it's a unicycle, roughly a

unicycle, on top of which there is an inverted pendulum.

And luckily for us, we know how to model unicycles and inverted pendulas.

Now, I'm writing +... there because there's a little bit more

going on, but basically we're going to be moving while balancing this thing.

so, let's start with the base. The base is a unicycle,

x1 and x2, that's the x and y position of the base.

And it's v cosine psi, where psi is the heading.

And psi dot is still omega. We've seen this repeatedly.

So, this is the dynamics of the base, almost.

And then, on top of that, we have this inverted pendulum.

And as we've seen, we need phi, which is the angle by which the pendulum is

deviating from upright position and we also need the angular velocity to

describe what is going on here. Now, the inputs to a Segway robot are

torques, wheel torques. So, the left wheel torque and the right

wheel torque. And torques translates into forces, or

torques and forces translate into accelerations, but here in the unicycle,

these are, are old control inputs. The velocities now, since we have inputs

that acts as torques, we need to actually add v dot and omega dot into the

equation. So, v and omega are going to be extra

states, that's where the +... comes from because, what I have done is I

have added v and omega as states to my, my model.

So, what I really have in terms of the state of the system, well, it's the

position of the unicycle, the translational velocity, its orientation,

the angular velocity, and then phi and phi dot associated with the upright face.

And my inputs are these wheel torques, left and right wheel torques.

And in fact, if I write down the dynamics of this thing.

Well here, I just have the unicycle dynamics.

That's all that I'm saying here, this is unicycle dynamics.

And then, I have all these other derivatives that I need to solve and

compute. And if you sit down and do the math very

carefully or you look in a book or something, you got this mess here.

Wooh, this looks kind of horrible. Well, the first thing we do, of course,

when we have something like this is we linearize it.

This looks absolutely miserable. But if we linearize it, what we end up

with is a, an LTI system and, in fact, it's x dot is Ax+Bu, and I should point

out that what I've done, is I've linearized this around (x,u)=(0,0), which

means that I have zero torques and the position of the robot is at zero.

It's looking at the x direction and the pendulum is looking straight up.

So, I'm linearizing it around 0,0. And if you do that, you get the following

A and B matrices. Obviously, I'm not going to ask anyone to

[LAUGH] memorize this. I'm just showing you.

This is where the A and B matrices came from.

Now, before we even attempt pole placement, let's make sure that we can

indeed do it. So, the first thing we have to check now

for this system is controllability. And this is too big, right? So, I'm going

to go to MatLab right away and write, here's the controllability matrix of my A

and B, here's the rank, and out comes 6. Does anyone remember what n was in this

case? Well, I do. n was equal to 7, which means that the

rank of the controlability matrix was not equal to 7.

So, this is not a completely controllable system.

And the problem here is the unicycle. We've already seen that when we linearize

the unicycle, the dynamics gets messed up, we can't move in the y direction.

I don't know if you remember that but if you say an x and y is the position of the

unicycle, then we had y dot equal to 0. What that means is we have no way of

moving sideways basically. So, the unicycle is what's making life

hard for us here, so what I'm going to do is I'm just going to ignore the unicycle.

Say, that the position and orientation of the base, I don't care about that, but

what I care about is, the velocities, how quickly it's moving and how quickly it's

turning. So, I'm going to shave off x, y, or x1,

y, x1, x2 and psi from the state space and get a smaller system that has s

states, the velocity, translational velocity, angular velocity and these phi

and phi dot associated with the pendulum. If I do that, I get a 4 by 4 system with

the following A and B matrices, again, the actual numbers aren't that, that

important. Well, I go to MatLab, I write rank

controllability matrix, I get the answer being 4.

In this case, n was equal to 4. So, if I shave off the unicycle base from

my system, I get the completely controllable system.

Now, I can start controlling it. The last twist though before I do that

is, I want my system to actually move. So, I'm not going to stabilize it to v

and omega equal to zero, because that's not what I want.

Instead, I'm going to say, I would like it to go to v desired and omega desired.

So, let's just subtract away v desired and omega desired,

and then I have a 0 here because you want to stabilize it to phi and phi dot being

zero, meaning, the pendulum being upright.

I'm going to find a new state, x tilde, which is my old state minus this

delta which is the thing I would like to stabilize it to. So, this is my delta.

6:58

So, I have a new state. Well, what's the dynamics of the new

state? Well, delta x tilde dot is x minus delta dot, delta is constant so this is 0

so this is just x dot. So, it's Ax+Bu.

Well, I can write, I can add a minus delta and add in an A delta at the end

because then I have x tilde again here. so, if I do that, I get a new system and

here is the lucky part for us. A times delta turns out to be equal to

zero because of the structure of A so I get this thing going away.

I have x tilde here so my new system dynamics is the same as my old system

dynamics. x tilde dot is Ax tilde plus Bu.

And now, I want to stabilize this system down to the origin,

which means that the velocities are actually going to end up being equal to

the desired velocities. So, we have completely control of the

system. We wish to stabilize it.

We do pole placement. And again, like we talked about last

time, it isn't entirely clear how to pick the

eigenvalues. So, I played around with the eigenvalues

and this seemed to give a good response. I didn't want oscillations, so there are

no imaginary parts, and I picked lambda 1 minus 19, lambda 2 minus 7.5, and so

forth. This is the smallest eigenvalue, it's

going to tell me how quickly, in general, the system responds.

So, with this, I'm going to pick u as -K not x but x tilde, which is the, the new

system I'm interested in. I get my close look dynamics like this.

And, in fact, the way I compute K is to use the, the place command in MatLab.

So, I type in my P and K is place A, B, and P.

So, this stabilizes the Segway robot. So now, the last thing we have to do is

to actually do it. And the reason why I'm okay with

neglecting the unicycle base and only controlling v and omega is that the

curvature of the path that's being traced by the Segway robot, actually is omega

over v. So, what I'm really controlling now is

the curvature of the path rather than where the actual robot is.

And what I can do in the simulation that I'm about to show you is basically, with

buttons, make v bigger or v smaller or omega bigger or omega smaller.

And in essence, what I'm doing when I'm changing v and omega is I'm changing v

desired and omega desired. So, that's the way I'm going to be giving

reference signals or commands to the, the unicycle robot.

So, with that, let's move to the actual, actually the simulation of an actual

Segway robot. So now, we're ready to see our developed

Segway robot controller in action. And I'm here with Greg Droge who is a

graduate student at Georgia Tech who will be showing us a simulation of the, the

Segway robot, so, Greg, what do you have to show us? Okay.

Here, we have a simulation of the Segway robot.

On the left, we have a 3D implementation of the graphics.

So, you can see that now, I'm able to drive it around changing the velocities.

Just as, just as Dr. Egerstedt mentioned with the keypad.

and you notice a few interesting things. Right here in the top right corner you

see the plot of the translational velocity.

The red line is the desired velocity and the blue line is the, the actual

velocity. And you see that it converts this very

quickly to the inputs that I give it. And on the middle, you see the rotational

velocity and you see because of the eigenvalues that we've chosen, that it

actually converges really slowly but it still converges.

And on the bottom you see that they're, the tilt angle will always keep the, the

robot stable. So, I have a question.

Are you simulating this on the linearization or on the full nonlinear

model? So, the simulation is on the full

nonlinear model. Aha, so I actually have a question.

So, linearizations are only valid locally.

do you have any sense for when this breaks? Meaning, can we make the robot

fall over, for instance? Yeah, so if you give it a really big huge step input of

the translational velocity you'll see that in the 3D simulation, it goes in a

full circle and it actually hit the ground.

Do, do that again. That was exciting.

Okay. Aha, so there, we actually get a feeling

for how good or reasonable the linearizations are.

And in this case, it's fairly reasonable, you can drive it around, but if you give

it really large desired velocities, it actually falls over.

Correct. Alright.

Thank you very much, Greg.

Yup. You're welcome.