We're talking about Beluga and hopefully telling you what it is and why you should care about it.
I'm going to use it going through an application.
We want to localize the Andino robot.
You see steam bioresensors based stations.
And for that, we're going to use the Beluga library.
So what do we need? We need the Andino robot.
We need the steam bioresensors based stations.
And of course, we need some type of sensor to receive the signal from the waste stations.
I was perfectly described earlier today.
The sensor, it's the bit-press lighthouse position in deck,
which receives the measures the infrared signal transmitted by the waste stations.
And provides this timing and information on angular information of where the waste stations are.
But we still need to do some math on those readings to get actually the asimuth and the elevation angles for the different waste stations.
For that, we're going to use the lighthouse ros node, which is provided by acumen, open source.
And yeah, so this competes basically where the bases are with respect to the robot.
But that's not what we want.
We want to find where the robot is with respect to the non-locations of the waste stations.
The base station calibration and position was talked in the previous meeting.
Very interesting. We're going to do that.
So how do we get where the robot is for that? We're going to use the Beluga.
So what is the Beluga?
Beluga is an open source, Monte Carlo localization toolkit, which is focused on cold quality and performance.
It is both an ANCL for being replaced by nodes.
So many people probably here familiar with ANCL node. This one will work.
Basically, it just was very similar to ANCL.
It supports both ros 1 and ros 2.
But it is also an extensible ros independent ANCL library that we can use to make other localization systems.
And that's what we want to do now.
So we're going to focus on the second aspect of Beluga.
And if we take a look under the hood, we open up the code of the Beluga ANCL node.
We'll find out that it's actually instantiating the ANCL algorithm from the Beluga library.
And configuring it to expose the sensor models and the motion models that are used in the ANCL package.
So that people are familiar with it. It has the same parameters, connects to the same roast topics, publish the same things.
So basically, it works exactly that.
So basically, if we look at the ANCL implementation inside Beluga,
we'll see that it is generic on the sensor models and the motion models.
So in our case, maybe the only thing that we need to do is a new sensor model
that will weight our particles based on the readings from the different from the light position index.
If we wanted to do something more involved, like for example, fuse the lighter that the robot has
and the light force positioning information, we could do our own ANCL like algorithm.
And for that, we might not use the entire ANCL implementation in Beluga,
but we use, like, the underlying abstraction that it has, that uses the, like, this modern style C++ range thing
to, for example, provide all the particles.
And then we can sample them and then we get estimation.
So it's pretty flexible. We can extend as much as we want, or use it as it is.
I'm going to really fast. So how do we, so what do we need now?
I think we can go for the first option and just use a create a new sensor model.
And for that, we are going to, so we can create our lighthouse sensor model to the, which is a class.
And if you look at the Beluga documentation, we'll tell us that it's a class that needs to overload the color operator
then that we receive when called the detections, which would be the sensor readings.
So this information of asymptote and elevation for the base station that it saw at that particular moment, right?
It doesn't need to be seen all the base station at some point, it would be just one, or which one it agrees.
And what we'll return is a method that gets us an argument.
The, the current state, which are the particles basically.
And what we will do, a question, this is basically some type of projection error.
And, and give us the, the probability of getting the, this detection, given this state, this particle.
So basically, the probability, the weight in the particles.
And this is the only thing that the new code that we need to write, which is a bit of math.
And that's it. Assume in some error and whatnot.
But then we package that, we can create our own light, how same seal, cross node.
We still need to write some of the extra, extra code to connect to the system.
But then we are done, and we can localize our robot, perfectly, which is just using pretty little code.
Next up.
Thank you.