0:00

So now we know not only that the first order business is to make the system

Â stable meaning it shouldn't blow up, it should behave well, but we also know what

Â this means, namely that the Eigen values of the system should have negative real

Â part and even though we saw some critically stable cases last time.

Â Including a rather awesome, set of robots slamming into each other. We typically

Â don't want critical stability. We want asymptotic stability. Which means that we

Â need to have strictly negative real part of all the eigenvalues here. And today,

Â we're going to actually achieve that, or try to achieve it, by designing a

Â controller. Because remember this picture. , Speaker:We have our system, x dot is Ax

Â plus Bu where u is the input, and then y is equal to Cx. So, whatever we do to our

Â control choice has to depend on the things that we have access to, which is why we

Â don't know the state of the system. But, we certainly know the output. So, today

Â we're going to try something called 'output feedback,' which means we're going

Â to take the output of the system. And use it to feed directly back in as a way of

Â controlling it. And we're going to start by returning to our old friend, the

Â world's simplest robot, which is just a point on a line that we can control the

Â acceleration of and, as you hopefully recall, we can write this in state space

Â form as x dot is. This a matrix, 0100x. plus a b matrix that's 01. And then, the

Â output is 10x. This means that the output is the position of the point mass. And x1,

Â the first component of x is the position. The second component of x is. The velocity

Â and then u immediately gives us the, the acceleration. So now our job is to somehow

Â connect y to u meaning pick our input in such a way that this system behaviors and

Â in fact here is an idea, we want to drive. The system to zero, which means stabilize

Â it. So, why don't we move towards the origin? meaning, the position of the robot

Â is what it is. And let's say that, here is the origin. And our job is to drive it to

Â the origin. So if the position is negative. Meaning we're on the left on the

Â origin. We should probably move in this direction. If the.

Â Robot is over there, we should move it to the left, which is in a negative

Â direction. So that's a very, very simple idea. And in fact if we turn it into math,

Â we see that if y is negative, so y negative again, corresponds if the origin

Â is here, us being on this side, then u should be positive, which means moving

Â this. Direction, and similarly if Y is positive than U should be negative. And

Â here's some suggestion. Right. Let's pick the world's simplest controller

Â that achieves this. Simply, the negative of Y. So Y positive means negative U, Y

Â negative means positive U. u. So let's try this, and see what it actually does. And

Â what we need to do first is understand. How does this change the system dynamics?

Â Because what we really did now, is, we had u equal to well, we had minus y. So k, in

Â our example, was just a1. But in general, k here could be. It's a more rich

Â structure, and if used in the y's or multidimensional, then this needs to be a

Â vector. Now, we know that y is equal to C times x, so we can write this as u being

Â equal to negative KCx. So, now let's plug this into our differential equation that

Â we have. So, x dot is Ax plus Bu, and now instead of u. We're plugging in this term

Â right. So then we get a minus BKCx or if you plug everything together, we get A

Â minus BKCx. And this, we can write if you want to as a hat times x. So this is just

Â a new system matrix and of course our job is to pick k now so that's the real Part

Â of the eigenvalues of A hat is strictly negative. In other words, pick if possible

Â K such that the real part of lambda is strictly negative for all lambda that is,

Â that is an eigenvalue to this new system matrix A minus BKC. So that's really our,

Â our job here and in a way already picked K, we said K was equal to one. Well let's

Â see what's happening if that's the case, then we have x dot is, this is A, this is

Â B, this is K a nd this is C. So this is what we have in terms of the. The system

Â matrix for our, robot. And one thing to note, first of all. That 1 times 1, 0 is

Â just 1, 0. And if I multiply this by 0, 1, then I get, what do I get? I get 0 times

Â 1, then 0 times 0 1 times 1. And 0 times 1. So this is what this whole expression

Â is equal to. So now I can just take this matrix, and subtract away this matrix to

Â get the, the right answer. And if I do that, I get x. is 0, 1, negative 1, 0, x.

Â And this is for my particular choice of k. And let's check out what, what the

Â eigenvalues are of this thing. Well, you write eig in MATLAB and you get the

Â answer. Or, as we will see in future lectures, you can actually compute it and,

Â and say something about the clever choice of k in that way. But, for now, we're just

Â going to immediately plug this into our favorite software system, and we find out

Â that the eigenvalues are plus and minus j. Where j is square root to negative 1. So

Â is this system asymptotically stable? Well, the real part of lamda for both

Â lamdas so we have two lamdas. The real part is zero, because this is a purely

Â imaginary system. And, as I said last time, if I have two. Imaginary eigenvalues

Â and all the others are well behaved, in this case I don't have any others, then I

Â have a critically stable system. And in fact since I have imaginary components, we

Â have already hinted at this that what we actually end up with are oscillations. So

Â this is a critically stable system and if I simulate with this role, what it's

Â doing, it's going to look like this. Really what's happening is this thing is

Â just going back and forth, back and forth. So, what's the problem? We clearly did not

Â stabilize it, we know it's not asymptotically stable in fact it's just

Â going back and forth back and forth well here is the problem, When the robot is

Â let's say on it's way. Away from the origin, then we're pushing it, correctly

Â so, towards the origin. But when it's on it's way back, we're still pushing it

Â equally hard, even thou gh it's actually going there almost by itself. So, we're

Â kind of not taking the direction in which the robot is going. Into account.

Â What this actually means is that we are not looking at the velocity because the

Â velocity is going to tell you which direction it is going in. So the problem

Â is that we do not take velocity into account. Remember what the state is? The

Â state is position and velocity. So the problem is that we need all of it to

Â stabilize and we need the full state information not just the output. So output

Â feedback like this doesn't quiet Work, but instead we want to operate on x instead of

Â y. But here of course is the problem. How do we do that? And the corollary to that

Â is, we don't even know x. We only know y. How in the world can we design controllers

Â for things that we don't know? Well, as we will see in the next module, it's possible

Â to figure out x from y a lot of times. If you just think of y in this case as being

Â the position And x being y, as x being position in velocity. Then velocity,

Â right, we can get by measuring two positions after each other, and dividing

Â it by the time in between the measurements. Then we get an estimate of

Â the velocity. So, it's clearly possible in this case to at least get an estimate of

Â state from the, the From the output. So like I said this is the next module but in

Â the next lecture which is the last lecture of this module will pretend that we

Â actually have x and revisits the world's simplest robot and see how can we actually

Â stabilize it if we have all of x and not just y.

Â