0:00

The outcome of the last lecture was, in some sense, quite glorious.

Â We ended up with this beautiful hybrid atomaton that solves the general

Â navigation problem. And it had all these cool things in it.

Â Now, the problem is that, after we have solved the general navigation problem i

Â said, but it doesn't work. It was a kind of annoying to be

Â completely honest and today I want to make it work by dealing with some of the

Â practical considerations that we really have to, to think about.

Â the first is that we have this notion of XO everywhere.

Â Now, its hard to see, but this is the distance.

Â Or the point where the obstacle is. Well, obstacles aren't points.

Â And it's not entirely, clear how we should translate these, real world

Â obstacles that aren't points, into something that we can deal with here.

Â The other is what I call fat guards. Here for instance, we're saying that the

Â distance to the obstacle should be exactly equal to delta.

Â Well We're never going to be exactly = to delta, because sensors are noisy.

Â So what we need to do is, we need to say, you know what? The distance is delta +

Â -epsilon. So we basically just need to just fact ta

Â fi the guards, make them larger. So that instead of switching exactly when

Â we're at the distance delta, we're building some slack into the system.

Â [INAUDIBLE]. And then, I have a third bullet here,

Â that I'm calling tweak, tweak, tweak. And the point with that one, is that,

Â even if you have dealt with non point obstacles.

Â And we have fat a fi our goal, guards. There are parameters.

Â There are things like, CGTG. Which is the coefficient in front of the

Â goal to goal behavior. We have things like, delta and epsilons.

Â And there are all these Parameters that we have chosen.

Â That, mathematically, they're all fine. But, in practice, there is no way out of

Â the fact that you need to test, test, test, and tweak your parameters.

Â And this is, in some sense, why robotics is so hard.

Â And that's, how do you actually transition from your beautiful

Â theoretical design, into something that works on the actual robots.

Â Well, lets start with obstacles that aren't points.

Â Green ball is the robot, red thingy is the obstacle,

Â it's not a point. Now the first thing to note is that

Â almost all actual sensors they're really the return points.

Â Point [UNKNOWN], laser scaners, Infrared, ultrasonic sensors, all of them measure

Â distances to things in certain directions.

Â So, here are the points that I'm actually detecting on this obstacle.

Â So now the question is, how do I actually deal with this situation?

Â Where I have not one obstacle, where I have one obstacle but for the purpose of

Â robot these are let's see, 1, 2, 3, 4, 5, 6 obstacle points.

Â So, I have 6 points all of a sudden. Then I somehow need to deal with.

Â So how do I do that. Well, We have some options.

Â One options is, you know what? I'm really not interested in driving into this

Â obstacle, so, the point in my algorithm that I'm going to care about, is simply

Â the closest obstacle. In this case, it's this point, right? So,

Â I'm simply going to say that xo is there, that's actually not bad, it's not a bad

Â idea at all and then this is supposed to be straight line.

Â you avoid obstacle would simply take me in this direction, just straight away

Â from the closest point. That's not bad at all.

Â But you know what, we have all this other information.

Â Why don't we take that information into account a little bit more? So, another

Â option would be to, weigh and add obstacle vectors together, depending on

Â the distances. Right so, here it's closer, so I'm going

Â to get more in this direction. And I'm kind fo far away so I'm going to

Â get little in that direction. And then I'm going to weigh these

Â together and maybe, get something out like this.

Â That's better. So, there are different ways of weighing

Â them. Let's say that I get these weighed or

Â scaled obstacle vectors. And then my obstacle avoidance is simply

Â going to be some scaled version, or weighted and scaled version of that.

Â So this would be, U avoid obstacle now. And what you now need to do, to find x

Â obstacle which we need, is to backtrack this thing, and say that this point here,

Â would be x o. Now x o is not necessarily a point that

Â we're measuring now. It's the scaled and weighted version of

Â the other points but, this is a much better way of Of doing.Now the last thing

Â I should point out this you know what , you should weigh these things depending

Â on the distance.But then you should also weigh depending on the direction of

Â travel, [COUGH] excuse me and what do I mean by that.Well you know what, if I'm

Â really on my way In this direction [NOISE].

Â What do I care about obstacles behind me. Why should I care about that.

Â I really shouldn't right? So, what I really want to do is weigh it also based

Â on the direction of travel and in that case I would get a weighted obstacle

Â avoidance vector out like this. So this is almost a I would say the best

Â way of doing it. And that's in fact how we're going to do

Â it. Now, the last thing I want to point out,

Â though, you know, there's another option. I should be able to collect all the

Â points I'm getting, building a map of it, so here is the obstacle service.

Â And then, you know what? Instead of just dealing with the questions, like you

Â know, sliding, or snow sliding. Maybe I can, plan my way around this

Â obstacle. Now, what I want to point out , this, in

Â this class, we don't say things like most bestest,

Â because it's grammatical nonsense. we stay with grammatically correct

Â things, which means that Ultra4 is out. what I really want to say is that

Â building maps is an entirely different type of topic, and all that we are

Â learning in this class is still very much applicable.

Â So, I just want to point out that there are ways of building maps and then

Â planning in those maps and then you're goal to goal behavior, for instance,

Â wouldn't aim at the goal point but aim at following planned path based on these

Â obstacle maps. So want to point out option 4 but its

Â really not part of what we're going to pursue in, in the class.

Â Now the last thing or did the second thing I said is we need to allow for fat

Â guards and this is because no sensor is perfect, no actuator is perfect.

Â Robots aren't prefect, right? So if I have this as my navigation hybrid

Â automaton, when I'm doing f1 for some reason until g is negative, then I'm

Â doing f2. And then when g becomes positive I'm

Â doing f1 again. This is not sufficiently fat.

Â Because I may end up actually switching a lot, I may do C note for instance or I

Â may not but, the point is that what I really should do is replace these guys

Â with this, right?

Â Instead of saying G less than 0, I should say G less than negative epsilon.

Â And instead of saying g positive, I should say g greater than epsilon.

Â so Instead of having this as my switching surface, I'm actually building this

Â little corridor here where I'm saying, I'm going to use f1 until I've gone

Â through the entire corridor and so here's f1.

Â And then I'm going to use f2 until I've gone through that corridor.

Â And this factification not only reduces chattering but it also allows us to

Â switch not when we're exactly delta away from an ob, obstacle but in somewhere

Â delta plus minus epsilon. So always build fat guards as a practical

Â precaution against the fact that de, deployed real world is not as clean as

Â the theoretical world on my powerpoint slides.

Â And then, like I said, the final advice, when it comes to practical

Â considerations, is even though you have built a beautiful hybrid automotan,

Â you've thought about everything, you have dealt with practical considerations and

Â that you deal with point obstacles or non point obstacles as susceptible points

Â since [UNKNOWN]. you are using sufficiently [UNKNOWN]

Â guards, you still have to tweak, tweak, tweak.

Â You have to test these parameters. You have to do it over and over again and

Â Like I said, this is what makes robotics hard and why it's a little frustrating at

Â times, but at the end of it, it's also what makes it satisfying when you get it

Â right. So what I'm going to do in the next

Â lecture is not talk at you or to you at all.

Â Instead, what we are going to do is to actually going to build this system that

Â we now have and tweak parameters until we are satisfied with our glorious, great,

Â unifying navigation system.

Â