which means we're taking out the first component of the state. So, C is 1,0.

Similarly, this equation still holds so what we're controlling is the acceleration

through the Cm and what remains is my A matrix where the 1 here simply says, that

the time derivative of position is velocity and then, this gamma is the same

gamma as we got before. So, the impo rtant point to note here is that the model we

end up with, to a certain degree, depends on what we care about and what are the

things that we can, can measure. Now, let's take another model. Here is a

pendulum. And the pendulum is attached up here on the ceiling somewhere. And it's

swinging with an angle theta. It has length l. And the acceleration of this

angle, this angular acceleration, turns out to be minus gravity over the length

times sine of this angle plus Cu. And the way we should interpret this is that what

we're doing is we're actually applying a torque up here that allows us to swing the

pendulum a certain way. okay. Let's write this as an LTI system. Ouch.

Sine theta is not linear. So, we actually cannot write this as an LTI system. But,

here is something we can observe. For a very, for small thetas, then sine theta is

actually roughly equal to theta. so what we can do for small angles, is actually

replace this thing by theta. So, let's do that. For small angles then,

what we get is, wellm if we measure the angle, then y is simply 1, 0, where we're

taking out the angle and not the angle or velocity. Because the state, in this case,

is theta, theta dot. Well, similarly, we're having a C here, so

the C shows up there in the B matrix, and the A matrix looks like this. 0,1 here,

which means that the time derivative of the angle is the angle of velocity, and

this g over l term here is the same as the g over l term up there. So, this would be

the a, b, and c matrices for this pendulum.

And again, I want to encourage you to go through the math and perform this matrix

multiplications so that you indeed trust that this is correct. Okay, let's do

another example. Two simple robots. Let's say that we have two robots on a line and

what we can do is we can control the velocities of these robots. So, x1 is the

position of robot 1, x2 is the position of robot 2, and we want to somehow control

them. Well, first of all, what we get is that x dot is 1 0, 0 1 u. We have no A

matri x in this case, A is equal to 0 and the B matrix is simply the identity

matrix. let's say that we can match where the robots are, too, so in that case, y

would simply be the identity matrix times x, or just x itself, right? So, this would

be, our, our model of this. Now, let's solve the problem here. Let's solve what's

called the rendezvous problem. the rendezvous problem is the problem we'll

have when the robots meet. And, you know what, why don't we actually have them

drive towards each other? So, here's an idea one can have. Where we say that u1 is

x2 minus x1, which is simply code for saying that x1 is going to move towards

x2. And similarly, u2, let's make that x1 minus x2. Then, that means that robot 2 is

aiming towards robot 1. Well, what we've actually done now, is we've designed a

closed loop feedback law, where we have written control inputs in terms of the

states in this case, but since the outputs are the same as the states, we're actually

writing them in terms of the outputs. Well, if I do that, I get a new system. X

dot is negative 1, 1, 1, negative 1, x, and what this corresponds to is instead of

writing u here, I'm plugging in these things there, and then you end up with a

new system dynamics that's what's called a closed loop system dynamics. And, in fact,

if I run this, and let's run it for not 2 robots but a gazillion robots here, then

as you will see, running exactly this simple controller makes the robots

actually meet on a same, on the same point, so that's kind of cool. let's do

another example now. This is the unicycle robot we looked at that when we modeled

the differential drive robot. Again, sines and cosines are unpleasant. This is not

linear, alright? , But cosine for small angles is equal to 1. So, let's assume

we're dealing with small angles. And sine, for small angles, is equal to the angle

itself. So, using that, we get this. But look at this. This is still not linear

because here, we have a multiplication. So, even when we made a simplification, wh

ich by the way is a completely stupid simplification because the pendulum may

swing at small angles, but why does the car have to drive in only direction where

we are having small angles? That doesn't make any sense. But the point there is

that this kind of simplification didn't do anything. Still not linear. So, we need to

be a little bit more systematic when we generate linear time invariant models

from, for, from these kinds of non-linear systems because just saying that let the

angle be small and hope for the best, won't actually give us all that much. And

in the next lecture, we will be systematic in our generation of these linear

time-invariant models.