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.
