So now we have seen that controls deals
with dynamical systems in generality. And
robotics is one facet of this. Now what we
haven't done is actually try to make any
sense of what this means in any precise or
mathematical was. And one thing that we're
going to need in order to do this is. Come
up with, with models. And models are gong
to be an approximation, and an abstraction
of what the actual system is doing. And
the control design is going to be made,
rather done, relative to that model and
then deployed on the real system. But,
without models we can't really do much in
terms of control design. We would just be
stabbing in the dark without knowing
really what, what's going on. So, models
are actually Key when it comes to
designing controllers, because if you
remember that the question is really how
in control theory, is how do we pick the
input signal u. So u again, takes the
reference, compares it to the output, the
measurement and comes up with a
corresponding Course correction to what
the system is doing. And the objectives
when you pick this kind of control input,
well, there are a number of different
kinds of, of objectives. The first one is
always stability. Stability, loosely
speaking, means that the system doesn't
blow up. So, if you decide a controller
that makes the system go unstable, then no
other objectives matter cause you have
failed. If your robots drive into walls or
your aerial robots fall to the ground,
basically control stability is always
control objective number one. Now, once
you have that, the system doesn't blow up.
You may want it to do something more than
not blow up, and something that we're
going to deal with is tracking a lot.
Which means, here is a reference either of
value. 14, how do we make our system do 14
or here is a path how do I make my robot
follow this path or how do I make my
autonomous self driving car follow a road.
So tracking reference signals is another
kind of objective. assert important type
of objective is robustness in the sense
that. ,, . Since we are dealing with
models when we're doing our design. And
models are never going to be perfect. We
can't overcommit to a particular model.
And we can't have our controller be too
highly dependent on what the particular
parameters in the model. R, model r. So,
what we need to do is to design
controllers that are somewhat immune to
variations across parameters in the model,
for instance. So this is very important.
I'm calling it robustness. a companion to
robustness, in fact one can ague that it's
an aspect of robustness. It's disturbance
rejection, because, at the end of the day.
We are going to be acting on measurements.
And sensors have measurement noise. things
always happen if you're flying a in the
air, all of a sudden you get a wind gust.
Now that's a disturbance. if you're
driving a robot, all of a sudden you're
going from Linoleum floored carpet, now
the friction changed. So all of a sudden
you have these disturbances that enter
into the system and your controllers have
to be able to overcome them. at least,
reasonable disturbances for the, the
controllers to be To be effective. Now
once you have that we can wrap other
questions around it like optimality, which
is not only how do we do something but how
do we do it in the best possible way. And
best can mean many different things, it
could mean how do I drive from point A to
point B as quickly as possible, Possible
or as using as little fuel as possible or
while staying as centered into the middle
of the road as possible. So optimality can
mean different things and this is
typically something we can do on top of
all these other things and in other to do
any of this we really need a model to, to
be a. Effective.
So effective controlled strategies rely on
predictive models. Because without them,
we have no way of knowing what our control
actions are, are actually going to do. So,
what do these models look like? Let's
start in discrete time. this means that,
what's happening is that, that Distinct
time instances, thi ngs happen.
In discrete time, what we have typically,
is that the state of the system, remember
that x is the state. So this is at time
instance, k plus 1. Well, it's some
function of what the state was like,
yesterday, the time, k, and, what they did
yesterday. So, the position of the robot,
position of the robot tomorrow, is a
function of where the robot is today, and
what I did today. And then, f, somehow
tells me how to go from today's state and
controlling to tomorrow's state. This is
known as a difference equation because it
tells you the difference between different
values across, different time instances.
So, that's in, in discrete time. and
here's an example of this. This is the
world's simplest discrete time system.
It's a clock, or a calendar. This is the
time today. Now I'm adding one second. And
this is the time one second later. So the
time right now plus 1 second is the time 1
second later. This is clearly a completely
trivial discreet time system, but it is a
difference equation. It's a clock, so if
you plot this we see that here is, this is
the 8, which is what time it is As a
function of time. So it's silly. But at 1
o' clock, the state is one. At 2 o' clock,
the state is two, and so forth. And you
get this thing with slope one. So, this
would be the world's simplest model. There
are no control signals or anything in
there. But it least it is a dynamic
discrete time model that describes. How a
clock would work. Now the problem we have
with this though is that the Laws of
Physics are all in continuous time. And
when we're controlling robots we are going
to have to deal with the Laws of Physics.
Newton is going to tell us that the force
is equal to the mass times acceleration.
Or, if we're doing circuits, Kirchoff's
Laws is going to relate various properties
to capacitances and resistances in the, in
the, in the circuit. So, we're going to
have to deal with things in continuous
time, and in continuous time, there is no
notion of next. But we have something
almost be tter, and that's the notion of a
derivative, which is, it's not next, but
it tells us How is the time change? The
change with respect to time. So in
continuous time, we don't have difference
equations. What we have are these things
called differential equations. And right
here you see that the derivative of the
state with respect to time. Is some
function of x and u. So this not telling
me what the next value it is. It's telling
me, what's the change? Instantaneous
change. And here, it's the same thing. But
now I'm written, I've written x. instead
of dx, dt. and time derivatives, a lot of
times, is written with a dot. And I'm
going to use that in this. Class and this
actually traces back to the, the slight
controversy between Newton and Leibniz.
Leibniz, so in 1684, Newton said, oh I
have this idea that I call it
differential, and Leibniz at the same time
had the same idea. Well, this is Leibniz's
notation and this is Newton's notation,
and we're going to use the dot for time
derivatives here. The point is that these
are both the same equations and they are
differential equations, because They are
relating changes to the values of the
states. so if you go back to our clock,
what would the differential equation of a
clock look like? Well, it would be very,
very simple it would say that the, the
change, the rate of change of the time is
one. Which basically means The clock
changes a second every second. That's what
it means. So when I drew this picture of
the discrete time clock. Or, I drew this
line diagonally across it. What I was
really doing was describing this. So this
is the continuous time clock. x dot is
equal to 1 And.
We are going to need, almost always,
continuous time. Models for, for our
systems. And next couple of lectures,
we're going to start developing models of
particular systems. But, before we do
this, I want to say a few words about how
to go from continuous time to discrete
time. Because our models are going to be
continuous time differential equations.
But th en, when we're putting this on a
robot, we're going to put it on a
computer. The computer runs in discrete
time, so somehow we need to map continuous
time models onto discrete time models. So
now if I say that x at time k, well it's x
at time k times delta t, where delta t is
some sample time. So we've sampled k
measurements. Well if I, use this. What is
x at time K plus 1 which is at the x.k
plus first sample time. Well, I need to
relate this thing somehow to the
differential equation. So how do I do
this? Well, this is not always easy to do
exactly but what you can note is that.
This is known as a tailor approximation.
So x at time k times delta t plus a little
delta t which is exactly the next state.
Well it's roughly what it was last time
times the length of the time interval,
delta t times the derivative. So this is a
an approximation but the cool thing here
is that this x at time k plus delta t,
well that's, xk. So these things are the
same. x dot at time k equals delta t, well
that's f. So this are the same things, and
then I just have to multiply my delta t
there. So this is a way of getting a
discrete time model from the continuous
time model. And, this is how we're going
to have to take the things we do in
continuous time, and map it onto the
actual Implementations of computers that
ultimately run in discrete time.
EmoticonEmoticon