first scenario. Okay, I'm working on what I call the mean, the duet in France. And I'm working in an engineering project that is about solving this, this problem. So let's suppose by example a market or some place that you just arrived and you

don't know it, or maybe it has some changes on the layout of the stuff, whatever. So we just picture this guy that is going to just buy wine and fish, nothing else. So you just go

into the shopping and you don't have any small clue about what, which is the layout of the place. You just start to go around trying to find something and you realize that yes, maybe I should buy that, that cheese, maybe should I buy flowers for, for someone?

Maybe. And okay, so in the end the guy spent two hours of his life, a lot of money, and he forgot about the, or maybe she, he just creep out, say okay, whatever, I will go home

and do not eat anything or eat this crap. So the proposal is to have a guidance rule that able the persons to navigate an environment that is not pretty known, or it changed because

they changed the organization of the stuff in the market, or maybe it changed because of remodelation. So maybe you just don't know, you just are new in the place and you don't

know which is the organization. So the idea is, okay, the guy comes, he has a robot for asking for the things that he needs. Maybe we can make it more flexible and talk about things that I should

need or I may need in terms of a bit more. I will not change the robot, I want fish and wine because he will point me to maybe a proper fish. I just want to talk in a more abstract way, whatever, that's implementation. So the idea is to have a robot that will guide me in the best

path that he can manage to find, make me pick the stuff that I need, go to the checkout,

pay and go away. So the idea is to take less time to do what we need to do inside the building and do not spend more money than the money that I need to spend. Do not go to buy something else, I just need to care about my time because I don't like to go into the market. I feel

really disgusting when I go into the market. So that's why I like the project because I find myself really related with it. So that's the objective. Find things, okay, we need to first make able the robot to recognize them, find things,

the product, people, facilities, whatever. So in our scenario now it's a market but actually we have two scenarios in test, one is the market and the other one is an office building or office

building. So the idea is to find things in an abstract way. Find the best way to reach them and so do it. Challenges, understand environment. So no, I didn't forget but let's just put it

in the challenge. Well, understand the environment. A robot is just a computer that run a program and

has some capabilities for sense and do something about it. In order to be able to do something about it we should have a way to understand what we are sensing. So then in order to understand environment we need to make kind of system, a mathematical system.

That is called maps, just mapping. That means that we will make a map of the place. In this project we keep it in two dimensions so it's not that difficult, it's good.

And okay, to find things to track, un-track them. So how do we put something for the robot to understand what is interesting for us and what is not. Avoid obstacles, actually when the robot is making the exploration to understand the place or when the robot is just leading us from

one place to the other. We don't want the robot to collide with columns, little kids moving around. It looks stupid but actually if the robot is just moving a bit inside the shopping mall and the kid is just going as hell against the robot and the kid collide the robot

who has the gift for the parents because these were parents. And then if we are in a shopping mall it's not just about avoid some static or eventual obstacles, it's avoid a lot of obstacles

and maybe be not able to go through. So well that is our project. So in order to do that in just one year and a half which is the amount of the time of the

robot to do everything. So what we decided to do is to integrate somehow to a platform that already has several of these problems already resolved or easy to integrate in order to resolve all

problems. That's why we choose ROS. ROS is a robotic middleware and integration framework. So it's something that will define a way for integrating processes in terms of the protocol,

how to serialize the stuff, etc. And it will give us a space of running. Then it imposes an architecture. In order to achieve this integration stuff

we need to have something to integrate, a channel to integrate this stuff, a way to integrate this stuff. So the things that we will integrate are called nodes. The nodes are processes that have some behavior and the behavior is defined in terms usually of input and

usually generates an output. What we like in that ROS actually proposed also is to have a lot of small processes that have small behaviors, small responsibilities. With this

proposal the idea is to be able to reuse a lot of processing stuff and to be able to switch one process for another process and change a bit the behavior or change the implementation and keep the same behavior without having a big impact. Actually one of the things that

is needed in robotics is we need to remember that we have a battery and the battery has an amount of charge and that matters. Actually one of the main deals with the performance is not justified. The price of the robot is also the problem of the battery. The battery

should last as much as we can and it should be predictable. So what happens if the robot is running out of battery we should be able to come to put down some services. How do we put

down services? Well here we just kill the process. That's all. It's quite easy. Okay then that is enough. The topics is a way for communicating in between different processes. There are two topics because there are connections about interest. I'm interested in

know the pulse of the robot each time. So it's a stream of constant information here. It's a published Skype mechanism. Yes. Exactly. And then the services is open. Then the services are for regularly for

the big stuff. Something that is not related with the main responsibility but may change

some configuration of the of the note or give some specific service and it comes with request and response like any service. But the topics does not it's just one way of communication. But the protocol. So why

why is that we choose ROS? Because of the existence of already developed software a lot. We have there was already SLAM algorithm implemented. There was already path planning.

There was already coalition avoidance but for not that close the spaces so we need to make some work over that. It has a growing community that is really active so you have a

lot of easy to get answers and there's a lot of know-how available just because of the growing community. So then Fado. Why Fado? Because yes because we are here right. It's a live environment. It has constant innovation. It's amazing the fact that

there are always a lot of PhD postdocs and engineers working on the platform. And it has a great programming and divine tools set of programming which what will need us to have a

really dynamic prototyping of the nodes of the process that we want to do. So we developed Faros which is not a good name but we changed it. Framework for robotic development based on ROS architecture, high level abstractions, abstracted from ROS installation. That means that we can if we want to run a Faros node without all the infrastructure

of the implement of the ROS stuff just because it's full inside the box. So

this is the role that we work with. This is why we didn't need more than two dimensions mapping is because it's a differential drive robot so we just care about this movement and this movement nothing else. This I mean it would not go up go down so we do not care about the

third dimension. We just care about the third dimension in terms of sensors like the camera is where but that is fixed. So then we have done Faros the whole controllers from the for the robot

just for all for moving the robot in a differential way for taking the laser sensors for actually we add some sensors extra this is a sensor for understanding tasks for reading marks in the environment so that's what we use for tracking places that we care about.

It can be better but it's costly. I mean we can also put some rare RFID in different products so we can make a better a better lecture of the base but what we choose is to sectorize and then configure the sectors by hand which is quite cheaper.

For a market is not doable because the market changed a lot but for the office building is quite is quite helpful. So then we have also the all the third party and robotics support

that is all developed in C++, Python, there are some things done in Java but since we have everything through TCP connection which is quite standard we can run in parallel with all that things we don't need to rewrite anything. If we need to rewrite

something we can do it but for going out of the of the problem and having a prototype and understanding the problem of the of the domain is quite useful. So where does make out run? We have the in the hardware operating system, ROS, FAROS and our application.

We run over FAROS and we touch ROS through FAROS. Okay the we already talked about ROS. What do we have in FAROS? Okay our main abstractions

are parallelism of the ROS abstractions so we have our node or we have our topic replication or service replication. We have a nice way to load and interpret the type

definition and make marshaling automatically and generate all the stuff needed for. But that is we don't have enough time to talk about that but it's nice to have. So things that are different with the ROS classical implementation.

Or image is all processed from outside or images are processed. Usually when in ROS we have one process one node. In FAROS we can have actually several nodes inside the same process inside the same image. And the funny thing with that is that the cost of communication

in between two nodes inside the image is almost free it's just message passing. We have a lot of okay we we have a cool look up for the the channels of communication. And it covers the same for the service call. We have then the service call and

inner topic connections are just message passing. Therefore the outside they look and communicate as individual nodes. So why why we do this because actually what happens is that

if we can have all the all the construction inside the image and it's not there. Okay perfect. Okay thank you. Okay

whatever. So then we have also the nodelets. The nodelets are like nodes they look like nodes behave like nodes but are not nodes. They are just seen by us as programmers we define some logic and we plug it inside the node through in the through dependency injection.

And for for ROS from ROS we are just one node one node more. The funny thing is that we we avoid a lot of of stuff that we need for okay and only

the TCP server an XMRPC server needs a lot of infrastructure so if you have inside the same image a lot of nodes with all that stuff related with for each node it's not good not when we have to I don't know to consume a laser stream which is something that it has 60 hertz of a lot of bytes so it's not it's not easy to to take it so.

Okay that I think the the main difference I I would want to talk more about nodelets but we don't have enough time. So then we have a tool for code distribution that is actually

all of this is MIT. The code distribution is cool because we have a way for deploying directly for several distributions of ROS with several distributions of Fado I mean several versions of Fado and we have okay when you need to deploy

a new type you need to make some C code some special make stuff and whatever it is all automatized so you just have the metadata of your project in your project and we load that from from a third tool and install and generate all the things needed for that it happens the

same with the scripts the scripts is the entry point of the system each script is one node actually so we can create new packages with different target so base like could array down configurations

okay so I will just show you it's very it's very bad actually you're never you're never to prepare for this kind of things because actually I burned my small robot today morning so

suddenly I will not be able to show you this one which is far better than just a small Arduino with the lead but okay if he will tell me if he let me if he does not let me it will not be able okay what's up oh you didn't put it on top of something which I don't

okay okay so

street Roscoe is running started so now we will go for okay just one second so we have an Arduino board which is quite common and unknown

we have a serial port related which is always giving me pain into wait a bit for this guy for

giving me feedback okay that's okay perfect and then we have Rose run post them

far it was so we start and we have here or the writing console okay I put the heart here because it's just to to be able to to manage the okay manage the Arduino board

from here from the same heart this is it has already configured all the stuff yeah so for doing this we are starting up one note that is inside one other note that

communicates with this node through a serial streamer actually and the third node which is all know that it's just controlling it so for doing this I just need to for the do this this

thing I just need to code a basic cool object that is alert that has a state for on off and that's all but okay what I was saying before about debugging tools and good programming tools is the fact that I can give shape to the node through a debugger for through a debugging session

having the stream there in my hand so I don't need to go to see okay which is this the shape of this data which is coming from another node which is a pretty thing on this

is just so so easy to develop there because you have already all the data in your hands you just can give feedback instantly just executing a line how long is your feedback cycle it depends on the you talk about the okay there are some nodes that need a

complete constant feedback what you do with that is just spawn it in other in other thread but actually what happens is that you first before having your output to be able to to give something you just need to understand what which is the which is the real knowledge that you have from the system actually what happens that there is a lot of knowledge inside the

system because of the different sensors and the different pre-processing of information so you need to to start to play a bit with which the information that you like more that you have that's better okay okay okay perfect yes I think so video demo doesn't matter

we have a we have a video of the demo of the shopping mall and and but this is long

we can have very short questions questions today morning yeah you don't know yeah okay yes we were having a kind of hangover

today to the morning if if you want I will I will tell all the all the secrets of the of the morning you will not you will not be so satisfied that I have no problem so any question so thank you Santiago