Hello everybody here at Firstum Lightning Talks. I want to introduce to you Jean Miguel Solay and Felix
Feitach and they are talking about a logra mesh on library for a logra mesh network.
Give them a warm applause and welcome.
Thank you so much.
Hi everyone. We are going to present you about the logra mesher. We are working with
the Polytechnical University of Catalonia and we are Felix and Dan or so on whatever.
And Juno's about logra. Okay, good.
So one. Well, and logra meshers, somebody knows about it. Yeah. Okay, good.
Well, we are going to present logra mesher with his an open source network. It's a no-to-no communication
and it worked with a distant vector protocol. We are going beyond logra one.
A lot of restrictions about what you can do about the routing protocols and the mesh.
And we tried to develop something that the people could use it and open source it and
do something about it.
We developed it at the UPC since 2021 and I'm currently the main developer.
And we are using C++ and the Git repository is here.
A logra mesher, logra mesher, good name.
And well, we have some applications that they are currently working with the logra mesher.
We have an application that's called logra chat that works in the upper layers of the logra mesher.
Now, logra chat has been converted in something that is an application manager that you could use it.
And you can use for sending messages between between nodes or sending data, whatever data,
sensors, GPS.
And you could use the logra chat and you program the upper layers.
And although our chat will redirect the nodes to the gateway, if you want to add it, or between the nodes.
You can use to one device, one mobile to talk to the devices.
We are using right now DTGOL DBIMS that's our main devices because they are pretty cheap and they are pretty good.
And we are working with SAX1272.
And we have been adding a lot of models.
You can ask for it, we can just start it. It's pretty simple.
Okay, how to work with Laura Meshcher. It's pretty straightforward.
You could just go to the examples of the GitHub repository.
And it's just a set of Laura Meshcher creates in messages and it should be pretty straightforward.
If you just copy and paste it, it will work straightforward.
One of the things is you need to pin the correct pin out of the module.
That is something that I have a lot of issues in the repository that people are a little bit confusing.
Well, we are working with the environment SP2 SP32 microcontrollers.
We have to talk about the DTGOL DBIMS and we use to platform.
That we strongly recommend you. If you are using Arduino or something like that, we strongly recommend using it because it's open source and it's pretty good.
And how you could see if the network is working, if the messages are arriving to your devices and everything.
When Laura Meshcher starts, it will start about the one task that is the routing protocol and it will send messages politically.
At some point one device will receive the message there and you could.
When the messages is processed, you will see the routing table.
At this case, we have two devices.
With that, it's a straightforward device, I don't know how to say it.
And we have a metric that this point is the hub count, only the hub count.
You see one and two and finally it's a roll.
What's the roll? In our Laura chat, we are using what we have defined default mode for gateway device.
And it will be propagated to the mesh.
When one node is connected to the internet, you can say, hey, use this roll and it will be propagated.
Everybody will know where to find a gateway.
You could use another roll, you could configure whatever roll you want, if to propagate through an error.
Okay, we have different tasks in this implementation.
We have the received tasks, send us processed packets, routing protocol and user centers.
You will receive tasks in the middle task.
We will, well, when a packet is detected, the an accessor accessor.
Well, and it will receive an notification for the Laura model.
And it will start the receive tasks that will get the packet from the model.
And then this task will put it in a queue to be processed by the processed packet task.
At this time, you can send packets to that it's another queue.
Well, we have five, five, no, three, three queue.
That once the queue received packet, the queries in packet and the queue user received packets.
When you receive one packet from the Laura model, it will send it to the queue received packet.
And the received task will get all the packets and it will be processed.
There are some different types of packets that I will not go street portfolio that.
And we, the received task just gets the packet and process the packet for different types of packet.
And it will do, it will process it.
The same part is like when you want to send some packet, it will, we have a function that at any time you send the packet.
And it will add it to the queue, send packet.
We have an option with this program that you can use to this cycle.
Or at the time we are using a band that uses, that we can use 100% due to cycle.
And maybe you could use that or it depends on your network.
And finally, the queue user received packets that just want, once some note receives a packet, that's it from the, it's for the upper layers.
It just will be put it in this queue user received packets and it will need to find the user.
Well, the upper layers.
We have a task in the examples you will see that you could just get the packet and process it whatever you want.
Okay.
I'm happy more slides.
So yes, so with these queue, actually, we don't lose packets.
If they cannot be processed at this moment, the note has these queues or buffers.
And the message to the packet stays there until the task becomes ready to, or it's started to process the packet.
So on this slide, we want to show that it works, what we have presented.
It's in this theater repository. You have the examples that you want to comment it and it should be straightforward to try these examples.
But with this, we don't know really if it works, but so we have made this demonstrator application.
These are eight Laura measure notes that are deployed in our campus.
And two or three of them are gateway notes, but all are in the Laura mission network.
They sent periodically data about the routing table to the gateway notes and then we collect the data and make the graphics with this web application.
So this helps us to see that the notes are stable. They are alive. They have the routing table.
We can click on each note and look at the neighbors.
So here we have the eight notes, three are gateway notes.
And one of them is highlighted. This is one in my office and this has, we can see the routing table that it has and some metrics from the routing table.
But this application shows us that the software is operational. It runs, it's not breaking after some time.
So it's operational. It works and this is a demonstration for this and actually it's alive and with this link, it could access now and see the data update.
One more slide. So what we want to do next.
One interesting feature of Laura Meshis that we can talk from the internet to a specific note in the Laura mission network.
Like you see with these arrows. We can ask a note, give us some values or do some operation.
So this is like the other way. Typically it's monitoring, but you know from Laura one, where we receive data periodically, but here with Laura Meshis we can actually query a note and ask for information or give instructions what to do.
And this be it by direction of communication. I think it's interesting to exploit more. We don't know to well what could be good for but we think it's an interesting feature.
And yes, maybe we can think that we could offer services within from inside of the Laura Mesh network that could be requested from the internet because you can really ask for a note for some data.
Of course, it will be much slower than asking a service in the internet, but it's some similar idea.
Another thing to do is we should look at what are the industrial solutions that also offer Laura Mesh network.
We have seen two or three, they're not many, and they are all a property. We have no code about this from these commercial solutions.
And also the technical information is limited, so we don't know very well what is there and there are very few solutions.
And the other dominant player within Laura is the Laura one architecture that everybody uses.
We have to maybe find more examples where Laura Mesh networks are better or more useful than making the Laura one infrastructure.
Also, well it's now a code that we have been working on for a few years, but still we need to do experimentation.
There's a lot of big configuration space with different spreading factors, message sizes, amount of traffic, so we have only looked at certain points in this space for our research, but there's more to try and to test.
And finally, well with this monitoring application from the previous slide, we have this demonstration, but we need more applications where Laura Mesh networks could be useful.
And John is more in contact with developers that we know from the get-to-pository, I'm not so much, so we know people use Laura Mesh her, but we have not really public information that tells us well what they're doing or when is it useful. So this also we need to do more.