So, congratulations, all that hard work paid off. Or at least, congratulations if you managed to hang in there this far. and claiming all that hard work paid off. My job now in this module is to show that it indeed did pay, Because we're going to unleash our Newfound powers on mobile robots. And this entire module is, dedicated to, what's known as the Navigation Problem, which means how do you make a robot drive around in a world populated by obstacles without slamming into things, and getting safely to landmarks or goal positions. So, in the first lecture, we're going to return to this idea of behaviors. And we're going to use control theory, now, to describe what's actually going on. And I don't know if you remember. But, we actually talked about behaviors before. These were these atomic primitive things that the robots should be doing. And then, by connecting them all together we get the overall navigation system. Now we probably know that behavior is just code for a sub-system or a controller, and connecting them up together is code for a hybrid system. So this is really what we need to do, we need to revisit behaviors in the context of control failure. So first we need a model and in fact almost always it pays off to start simple so we're going to start with old friend this point. So the position of the robot is X, so X is in R2, and I mean its a plain [INAUDIBLE]. And I'm saying that I can control that velocity, of this robots direction. Now to compare us, as we've seen are differential drive robots. You can't really do this. Instead, you have to control translational velocities and rotational velocities. So, we can think of this really as for the purpose of planning how we want the robot to go. And then we have to couple this to the actual dynamics. But, to start with, let's just say that x. is equal to U, well first of all what does that look like in the ax plus bu paradigm. Well A is equal to zero so this is my A matrix simply go to zero and my B matrix is simply the identity matrix. Well before we do anything else we need to see whether or not we can actually control this system and we formed a controllability matrix B AB. Well, A is zero, so this term is zero. B is the identity matrix, so this is the identity matrix. The identity matrix is as full rank as any matrix anywhere come. So, clearly the rank of gamma is equal to 2, which by the way is the dimension of the system. So, we have a completely controllable system. We should be able to make the system do What we would like it to do. So we're going to start with what I call the dynamic duo. These are the key behaviors that you always need. No matter what your robot is going to do, you always need to be able to go to a goal location. Or a landmark, or a waypoint. You always need to be able to go to somewhere, and you need to be able to do it without slamming into things. Without either one of those two, your robot just ain't going to be able to do what you want it to do. So our job now is to design these two behaviors using What we've already learned. So, we're going to do it rather simply. We're going to actually simply say, you know what, if my robot is here, and I want to go in this direction, well, why don't I simply say that this is equal to my u, because that's equal to x dot. So that's going to tell me, this is the direction in which The robot is actually going to do. It's going to be moving or using my handwriting but some pretty graphics. This is what we are going to do. We're going to figure out the direction in which we want to move and then set u equal to that desired direction. Okay, let's start with Go-To-Goal. This is where the robot is. Let's say their goal is located at x of g. Well, I want to go to the goal, so it's really clear where I would like to go. I would like to go in this direction, xg-x is this vector, and I'm going to call it e. So, why don't I just put u=e, or u equal to some constant k? Times Z, well let's see what E dot in this case, actually becomes. Well, E dots is X gold dot, which is 0, minus X dot. And X dot, well, that's equal to U which is equal to KE so E-dot becomes -ke. Well, that's kind of good so if I have E dot is -ke, does this work, does it drive error down to zero. Well, we know we have to check the eigenvalues. So, if k is just a scalar, as long as this scalar is positive, we're fine. If we want, for some reason, the matrix k. We just have to pick a matrix k that has positive eigenvalues. So, if k is a scaler and positive, we know that the system is asymptotically [INAUDIBLE] stable. If we pick k as a matrix. For instance, it could be a diagonal matrix, you know? 10, and A 1000, say seems silly, but why not. This is a positive, definite matrix means that the eigen values are all positive. I have a minus sign here so I need to worry about the negative of K in this case the eigen values would be all negative. So, if you have that I would go with K constant but if you have this you will indeed drive the error to 0 which means that we have solved the go to go problem. There are some concerns, though in fact there's just one. A linear controller means that you have a bigger vector the further away you are, which means that you're going to go faster towards the goal. The further away you are. Which doesn't, to be honest, make complete sense. So what we should do, is we should, in practice, moderate this. To make, maybe the game smaller, when we're far away. Or make the game constant somehow. Because we don't want to go faster when we're far away. That doesn't quite make sense. And you can play around with this. As long as K is positive we're actually fine. And what we're going to implement on the robot is this choice of K. It's a K that makes the norm of U reach some Vnot, so here is Vnot when you're kind of far away, and then it's going to not go faster when you further way, and then when you get closer to the goal, meaning when the arrow goes down You start slowing down, and in fact, if you try to be a little creative in how you pick your K, this K here is the K that corresponds to this plot then. That's the K that we're going to be looking at, but you don't have to do that. in fact, a lot of robotics involves clever parameter tuning and Tuning of these weights. But the whole thing, point here, I want to make is that you want to make sure that you don't go faster when you're further away because that actually doesn't make entirely sense. Okay, we know how to go, you to go to goal. Let's avoid obstacles. Well, if I wanted to go towards the obstacle, I would simply pick xo-x=u, or some scaled version of that. Well, now I want to avoid the obstacle. Why don't I just flip it? And that's now x-xo, instead, so flipping it means, I'm just going to avoid the obstacle. And in fact, that's what we're going to do. Let's just pick u=K*e, where K is a positive constant, and e, now, is x obstacle minus x. Well, if I do that, I get E dot is ke, which is actually an unstable system. And it's unstable in the sense that the error is not stabilized. 'Cuz the error is the distance to the obstacle instead. We're avoiding the obstacle. Obstacle. Now it's a little scary to have on purpose an unstable system in there but as you will see we don't worry too much about it because we need to make sure that the robot actually does not drive off to infinity which it would if we were was unstable. the other thing that a little weird, so this is if I use u=k(x-x0). The other is, that it's, it's a rather cautious system in that we seem to be avoiding obstacles that are also behind us even that doesn't entirely make sense and we also cared less about the obstacle the closer we get which. Absolutely makes no sense, because we should care more the closer we get. Well, the solution is again, make k dependent on e, or actually the distances, so the normal e. And to aviod this being overly cautious, we are actually going to switch between behaviors, and in fact, what we're going to do is using something like a induced mode, the sliding mode to very gracefully Combine goal to goal and avoid obstacles but for now let me just point out that one clever thing for instances is say that you want to care more about to obstacle u closer you get, so you want u to be bigger the closer to the, the obstacle you get. So in this case this was the K that we used, then in fact this is that K that I'm going to use to implement things but, again I want to point out that you want something that you don't care so much when you far away. And you care a lot when you close. The reason I have an Epsilon here which is a small number is just to make sure that this thing doesn't go up to infinity when they normally is 0. Things going off to infinity is typically not that good of an idea. Okay so we know how to build the individual control modes. Now we also saw that choice of weights matter. you should be aware, again, that there isn't a right answer in how to pick these weights, and depending on the application, you may have to tweak the weights to make your robot more or less skittish or cautious. But the structure still is there. What's missing, though first of all, is to couple this X dot is equal to U model to the actual robot dynamics. And we're going to ignore that question all through this module. And devote the last module of the course to that question. But what we do need to do is make transitions between goal to goal and avoid obstacles. And that's the topic of the next lecture. Before we conclude, though, let's actually deploy. This dynamic duo on our old friend, tho compare robots, to see what would happen in real life. So, now we've seen, in theory, how to design this dynamic duo of, robot controllers. In par-, in particular, we've seen these 2 key behaviors, goal to goal and avoid obstacles. And, now, let's actually deploy them. For real on our old friend, the [UNKNOWN] mobile robot. As always, I'm joined by with Sean Pierre Delacroix here, who will conduct the affairs. And, first we're going to see the go to gold behavior in action. And. What we now know is that what this behavior really is doing is looking at the error between where the robot is, right there, and where the robot wants to be, in this case this turquoise piece of tape. And then globally asymptotically stabilizing this error in the sense that it's driving the error down to zeros. So, JP why don't we see the [INAUDIBLE] make the error go away. So, as you can see, the robot is going straight for the goal, and the error is indeed, decaying down to zero. And this is how you encode things like getting to a point. You make the error vanish. Very nice. Thank you. So now, we're going to run act two of this drama. now the robot's sole ambition in life is not driving into things, and things, in this case, is going to be me. one thing that's going to be slightly different from what I did in the lecture, is that I am not a point, meaning it's not just a point but in fact an obstacle with some spread that the robot is going to avoid. In fact, what we're going to do is we're going to first of all ignore everything that's behind the robot because it doesn't care about avoiding things that are behind it. And the things in front of it, it's going to sum up the contributions from all the sensors and it's going to care a little bit more about things ahead of it than on. Its sight, so J.P., let's take it away. Let's see what can happen here. So, here I am. Oh, no. All right. Very nice. Don't hit me. Thank you. [SOUND] Perfect. We have a perfectly safe robot that is not driving into professors at all. and with that I think we compute. Thank you.