we're going to be a little bit more precise about what we mean when
we say control theory, and I've been throwing around this term controls quite a
bit so far, even though we've only seen one lecture. and what I want to do now is
make this a little bit more precise so that we get a slightly better
understanding ofwhat it is that we're going to be doing in the class. And,
ultimately controls, it deal with dynamical systems. These are abstractions
that describe something that changes over time. This could be a car that's moving.
This could be the price of a particular
stock. But ultimately, controls is dealing
with how can we best or how can we
influence this change of the system. And
some examples, and we're going to see all
of these examples in the class of systems
that one can control, would be robots,
epidemics, you could come up with
vaccination strategies, stock markets,
thermostat's for keeping the temperature
pleasant indoors, electrical circuits, dc
engines, power grids, or autopilots on a
aircraft and all of these will show up and
see which of these are easy to control and
which of these are actually very hard to
control. And we're also going to
understand what makes certain systems
harder to control than others. I put
robots in red though because this at the
end of the day is the main focus of the
course from the point of view.
So let's start with trying to build up a
control system in terms of the basic
needed building blocks. And the first
thing you need is some way of describing
what the system is doing or, more
importantly, where it is. If I want to
control a car, let's say I want to build a
self-driving car that drives from my home
to my office, well I need to know where
the car is, and central to this is the
notion of a state. The state represents
what the system is currently doing, what
state that it's in, and we're going to use
x to describe what the state of the system
is. This could be the position or the
velocity of a, of a, robot, this could be
the p ercentage of people that are
infected by a certain, epidemic, this
could be a number of different things, but
ultimately the state is the key thing that
describes what the system is up to. And
what it is actually doing is the dynamics.
And the dynamics is the description of the
change of the state as a function of time.
Now, this is all good. But, we want some
way of influencing this. So, we're going
to have a reference signal that is going
to. We're going to use it as a way of
telling the system what it is that we want
it to do. So the reference could be set
the cruise controller to 60 miles per
hour, or make me a certain amount of money
on the stock market, or make the
temperature in the room 70 degrees. What
do I know? now we can do that all we want,
but let's say that we want a cruise
controller to go at 60 miles per hour,
that's not going to work until we can
actually measure how fast the system is
going. So we also need an output. So we're
going to use r for the reference, y for
the output. And out-, the outputs are the
things that we're able to get out of the
system. This is telling us what the system
is doing. So we can't always measure the
state y is the output. Now this picture is
actually a blatant lie, because if I tell
the stock market to go make me a certain
amount of money there's no way it's going
to do that. If I just you know yell 65 at
my car, it's not going to go 65 miles per
hour so we need some way of mapping
reference signals into actual control
signals, the inputs. So u is going to be
the thing that takes the reference and
produces a control signal that then hits
the state of the system. Now this is all
fine and good but this control design is
not particularly good because the control
signal has nothing to do with the
measurements. So we need the final
building block which is the feedback. This
is a mapping from outputs to inputs in the
sense that what we're doing is we're
taking Y here. Oh, sorry.
We're taking y here, let's say y, and then
we're taking the refer ence and out here
comes the reference minus y, which is
going to be the error in terms of how the
system is performance. And this error is
translating into some control signal
that's then hitting the system. So this
feedback mapping is really the key to
doing any kind of controls in an effective
way. Good.
So, now that we know a little bit about
what are the basic building blocks. I want
to talk about examples just so we can try
to understand what these building blocks
actually represent. So, the state of a
robot is typically, if it's a mobile robot
on the ground, it's the position, maybe
the orientation of the robot, maybe the
velocity of the robot. The state is
ultimately what we need to describe what
it's doing. If it's a manipulator robot,
it would be the angles, the joint angles
of the various, segments of the, of the
robot. so that would be the state. The
dynamic simply says how the robot is
moving. The control signal, or the control
input, would be things like velocities or
torques or accelerations. Some ways of
moving the robots around, and the
measurements would be things like, where
is the robot? What is it seeing in the
environment? The epidemics, like I said a
state would be maybe what percentage of
the population is infected? The thing we
can control, so the input would be
vaccination strategies. In this case, the
output is tricky. It;s very hard to know
what percentage of a population is
infected for instance with, with an
infection? So, there, the output would be
some kind of measurements at hospitals of
how many people show up with this
particular disease. stockmarket state
could be, in fact no one really knows what
the state is of this stock market which is
why impart so hard to make money. the
output would be, well, the prices of the
stock and the input is simply buy or sell.
Thermostats, temperature, outputs
temperature, the thing we control is
turning things on and off. Circuits
typically the state would be currents
voltages and, and currents, and the inputs
are typically voltages that you're
applying and the outputs are measured
currents of voltages in the circuits.
Engines you can apply, typically voltages
and out comes a torque. the power grid,
well the state there somehow is power
consumption across the different modules.
The things you can control are putting
loads and generators onto the grid, maybe
same thing with autopilots on aircraft,
the states would be positions and
velocities, the things you can control are
accelerations or change the, the control
surfaces of the aircraft, and the
measurements are a whole bunch of things,
how fast is it going, where is it going,
what's the altitude? What's the wind
resistance and things like that. So, what
we need to do is come up with a rather
general way of describing all of these
systems, in a way that makes sense, that
we can use. And, that more importantly,
can use to control mobile robots.
EmoticonEmoticon