We have a model of a robot, we know how
the robot can get position information, in
this case we used the wheel encoders but
there are other ways we talked about
compasses and accele accelerometers but
the robot also needs to know what the
world around. It looks like. And for that
you need sensors. And we are not going to
be spending too much time modeling
different kinds of sensors, and see what
is the difference between an infrared and
an ultrasonic range sensor. Instead.
We're going to come up with an abstraction
that captures what a lot of different
sensing modalities can do. And, it's going
to be based on what's called the, the
range sensor skirt. This is the standard
sensor suite in a lot, on a lot of robots.
And, it's basically a. Collection of
sensors that are. The collection that is,
gathered around the robot. That measures
distances in different directions. So,
infra red skirts, ultrasound. LIDAR, which
are laser scanners. These are all examples
of these range sensors. They're going to
show up a lot. Now there are other
standard external sensors of course,
vision, or tactile sensors, we have
bumpers or other ways of physically
interacting with the world or "GPS" or I'm
putting them in quotation because there
are other ways of faking GPS. For
instance, in my lab I'm using a motioning,
or motion captioning system to pretend
that I have GPS. But what we're going to
do, mainly. It's assumed that we have this
kind of setup. Where a skirt around the
robot that can measure distances to, to
other to things in the environment. And in
fact, here is the Chipera It's a
simulation of the Chipera. And the Chipera
in this case, has a number of infrared
sensors. And Well you see the cones, you
have blue and red cones, and then you have
red rectangles. The red rectangles are
obstacles and what we're going to be able
to do is measure the direction and
distance to obstacles. So this is what
type of information we're going to get out
of these range-sensor skirts. over here on
the right you see two pictures of the
sensing modalities that we had on The
self-driving car that was developed at
Georgia Tech. And we have laser scanners
and radar and vision. but the point is the
skirt doesn't always have to be uniform or
even homogeneous across the sensors. Here
we have a skirt that is heterogeneous
across different sensing modalities. But,
roughly you have the same kind of
abstraction for a car like this, as well
as for. Hey, Chipera, little mobile
differential drive, robot. Okay, so,
that's fine, but we don't actually want to
worry about particular sensors. We need to
come up with an abstraction of this,
sensor skirt, that, that makes sense, that
we can reason about when we design our
controller. So, what we're going to do is,
we're going to do some, or perform what's
called a disk abstract. Abstraction.
So here's the robot, sitting here in the
middle. around it are sensors. And in
fact, if you look at this picture here,
here are little infrared sensors. And in
fact, here are ultrasonic sensors.You see
that scattered around this robot are. It's
a skirt of range censors. We're, they
typically have an effective range, and
we're going to extract that and say there
is a disk around the robot, of a certain
radius, where the robot can see what's
going on, right, so this is this, this
pinkish disk around the robot and it can
detect obstacles that are. Around it.
So the two red symbols there are the
obstacles. What we can do is we can figure
out how far away are the two obstacles.
So, D1 is the distance to obstacle one,
which is this guy. And this is obstacle
two, well, okay. join with ratts of ensure
and Pi one is the angle to that obstacle,
similarly d2 is the distance to obstacle
2. Phi 2 is the angle to obstacle two. One
thing to keep in mind though is that robot
has its own coordinate system in the sense
that this, if this is the x axis of the
robot right now, then Pi one is measure
relative to. The robot's x axis, so the
robot's heading, right. So we need to take
that into account if we want to know
globally where the obstacles are. So let's
do that. If you have that, and if you know
our own pose, so we know x, y and Pi. Then
since the measured headings to the
obstacles. So this is Pi one which is
measuring and we're measuring this
relative to our orientation. Lets say that
our orientation is this right. So here is
phi and here is Pi two say, then of course
the actual. direction to obstacle two is
going to be Pi 2 plus Pi. So, what we
could do, is we could take this into
account and compute the global position's
of these obstacles if we know where the
robot is. So, for instance, the global
position for obstacle one x1 and y1. Well,
it's the position of the robot plus the
distance to that obstacle times cosine and
sine of this Pi 1 plus Pi term. So we
actually know globally where the obstacles
are if we know where The robot actually
is. So this is an assumption we're going
to make. We're going to assume that we
know x, y and Pi. And as a corollary to
that, we're going to assume that we know
the position of obstacles around this in
the environment. So that's the abstraction
that we're going to be designing our
controllers around. And I just want to
show you a. And I'm using an example of
this, this is known as the rendezvous
problem in multi agent robotics, where you
have lots of robots that are supposed to
meet at the common location but they're
not allowed to talk, they're not allowed
to agree on where this would be by
chatting instead they have to move in such
a way that. They end up meeting in same
location and one way of doing this is to
assume you have a rain sensor disk around
you and then when you see other robots in
that disk instead of thinking of them as
obsticles we think of them as buddies so
what we are going to do is each robot is
going to aim toward the center of gravity
of all it's neighboors so everyone that is
in that disk, Disk, and because of the
disk assumption or disk abstraction we
just talked about, we can actually compute
where the center of gravi ty is of our
neighbors. So here's an example of what
this looks like. Every robot is shrinking
down. Two, all the robots shrink down to
meet at the same point, without any
communication, simply by taking the disk
around them, looking where are my
neighbors in that disk, and now we know
how to compute that. And, then, computing
the center of gravity of my neighbors, and
aiming towards said center of gravity.
Okay, now we have a robot model. We have a
model for figuring out how to know where
the robot is, we have a model for how do
we know where obstacles and things in
environment are. Now we can use these
things of course to actually start
designing controllers, so that's what
we're going to have to do next. I do want
to point out though that the model The
real encoder, and the disk abstraction.
These are but an example of what you can
do, and how you should make these kinds of
abstractions. But for different kinds of
robots, different types of models and
abstractions may be appropriate.
EmoticonEmoticon