As I've already said, the world is fundementally dynamic and changing and

unknown to the robot, so it does not make sense to overplan and think very hardly

about how do you act optimally given these assumptions about what the world looks

like. That may make sense if your designing controllers for an industrial

robot at a manufacturing plant where the robot is going to repeat the same. Motion

over and over and over again. You're going to do spot welding, and you're going to

produce the same motion 10,000 times in a single day. Then you'll overplan. Then

you'll make sure that you're optimal. But if a robot is out exploring an area where

it doesn't know exactly what's going on, you don't want to spend all your

computational money on Finding the best possible way to move. Because, it's not

actually going to be best. Because the world is not what you thought it was. So

the key idea to overcome this that's quite standard in robotics, is to simply develop

a library of useful controllers. So these are controllers that do different things.

Like going to landmarks, avoiding obstacles. We saw one that tried to make

robots drive through center of gravity of their neighbors. Basically, we can have a

library of these useful controllers, behaviors if you will, and then we switch

among these behaviors in response to what the environment throws at us. If all of a

sudden an obstacle appears, then we avoid it. Then if we see a power outlet and

we're low on battery then we go and recharge. So we're switching to different

controllers in response to what is going on. So what I would like to do is to start

designing some Behaviors just to see how what we learned in module one, a little

bit about control design can be used to build some behaviors. So let's assume we

have our differential-drive mobile robot. And to make matters a little easier up

front, we're going to assume that the velocity. The speed is, is constant. So v

not. We're not going to change how quickly the robot is moving. So what we can change

i s how we're steering. So you're basically sitting in a car on cruise

control, where the velocities are changing, and you steer it. That's your

job. And the question is, how should you actually. >> Steer the robot around. So,

this is the equation then, that's governing how the input Omega, it's the

state that we're interested in, in this case pi, which is the heading of the

robot. So, pi dot is equal to Omega. Okay, so, let's say that we have our. >> Yellow

triangle robot, it's a unicycle or differential-drive robot. It's headed in

direction five, so this is the direction it's in. And, for some reason, we have

figured out that we want to go in this direction, five desired or 5 sum D. Maybe

there is something interesting over here, that were interested in. So, we want to

drive in this direction. Well, how should we actually do this? Well, pi dot is equal

to Omega. So, our job clearly is that of figuring out what Omega is equal to, which

is the control input. Alright, so, how do we do that? Well, you know what? We have a

reference, pi desired. Well, in module one. we called references r. Right? We

have an error, meaning, that compares the reference pi desired to what the system is

doing. In this case, pi. So it's comparing the headings. So we have an error, we have

a reference. You know what? We have a dynamics. pi dot is equal to Omega. So we

have everything we had towards the end of module one. So we even know how to design

controllers for that. How should we do that? Well, we saw PID, right? That's the

only controller we've actually seen. So, why don't we try a PID regulator? That

seems like a perfectly useful way of building a controller. So, you know what,

Omega is Kp times e, where Kp was the proportional gain. So this response to

what the error is right now. You make Kp large it responds quicker but you may

induce oscillations, then you have the integral of the error. So you take the e

of tau, the tau times k sub i, which is the integral gain. And this thing, this

integral, has the nice property that it's integrating up all these tiny little

tracking errors that we may have, and after a while this integral becomes large

enough that it pushes the system Up to no tracking errors, that's a very good

feature of the, the interval. Even though as we saw we need to be aware of the fact

that a big KI can actually also induce oscillations and then we could have a d

terms. A KD times e dot and that where KD is the, the gain for derivative part. This

makes the system. Very responsive but can become a little bit oversensitive to

noise. So will this work? No it won't. And I will now tell you why. In this case

we're dealing with angles. And angles are. Rather peculiar beasts. Let's say that phi

desired a 0 radiance. And my actual heading now, phi is 100 radiance. Then the

error is minus 100 radiance. Which means that this is a really, really large error.

So Omega is going to be ginormous. But, that doesn't seem right. Because 100 pi

radius is the same as zero radius, right? So, the error should actually be zero, so

we should not be niave when we're dealing with angles. And, in fact this is

something we should be aware of. Is angles are rather peculiar beasts. And we need to

be, be dealing with them. And there are famous robotic crashes that have been

caused by this. When the robot starts spinning like crazy. Even though it

shouldn't. But it's doing it because it thinks it's 200 pi off instead of zero

radius off. So what do we do about it? Well the solution is to ensure that the

error is always between minus pi and pi. So minus 100 pi, well that's the same

thing as zero. So we need to ensure that whatever we're doing is we're staying

within minus pi and pi. And there is a really easy way of doing that. We can use

a function, arc tangents two. Any language there is a library with and it operates in

the same way. It's a way of producing angles between minus pi and pi. C plus,

plus has it, Java has it, MATLAB has it, whatever you, Python has it. So you c an

always do this and how do you do that? Well you take the angle that's now

1,000,000 pi right and You take sine of it comma cosine of it. So this is the same as

saying that we're really doing arc tan. So I'm going to write this as tan inverse

sine e over cosine e. But arc tan or tan inverse. Doesn't, it's not clear what that

always returns but arc tan 2, where you have a coma in it, you always get

something that's within minus Pi and Pi. So here's what you need to do, whenever

you're dealing with angles and you're acting on them, it's not a bad idea to

wrap one of these arc tan two lines around it to ensure That you are indeed having

values that aren't crazy. So, with a little caveate that we're going to use e

prime instead of e, the PID regulator will work like a charm. Okay, so here is an

example problem. We've already seen this picture. this is the problem of driving

the robot, which is the little blue ball, to. The goal, which is the sun,

apparently, and lets see if we can use this PID control design on Omega to design

controllers that take us to the sun, or to the goal. and since we're dealing with

obstacles and we're dealing with goal locations, and we're also talking about

behaviors. at the minmum we really need two behaviors. Goal to goal, and avoid

obstacles. So what we're going to do over the next couple of lectures, is develop

these behaviors, and then deploy them on a robot and see if there any good or not.