Okay, so for the next talk, Jose Maria Kenya's plaza and Javier Esquerro Hernandez will talk us
about BTS Studio, which is a programming framework for behavioral trees.
Well, I think what's based, they come from JBA Robotics Project and Universias, really
some fun.
Thank you.
Sorry.
Okay, so we are going to present today the BTS Studio is a work tool, just for programming
Robotics applications, but Robotics applications based on BTB tree is right.
We are part of this organization, JDA Robotics and open source organization that develops
open source software for robotics and artificial intelligence.
It was started in 2018 and currently we are more or less 20 developers worldwide.
We developed a several projects, maybe the most important one is Robotics Academy, it's a
framework for learning robotics, robotics, service robotics, rom programming, artificial
intelligence programming, universities, these are web-based websites, they are also for programming
robots and we have also several tools, such as BTS Studio and BTS Studio, today we are going
to present here BTS Studio, at the same time we perform several activities on the year,
we offer interships, just to mentor someone, interested in learning more things about Robotics
and artificial intelligence and we participate in the Google Summer of Code.
So this is the last year was a ninth, the ninth one, in fact, this period was forced
to insert a white one, this is a project, the VTS Studio and software itself and that's
all mass media, social media and also the web page you can take it.
Well, so there is a train in the last years for developing robotics applications but
using BTB tree abstraction, this is quite similar to a hierarchical finite machine but
has more advantages, such a better composition, right. So being aware of that, we try to facilitate
the development of new robotics applications following that paradigm.
We before start in this project, this is a one year and a half project so far, we just took
a look at different software pieces available regarding this topic and we found good and good
too, also by trees, it's the implementation of the heavy tree in Python and also the
heavy trees, CPP from the BTB faculty and all tool is based on inspired by all of them.
So we try to take a dears from all of them and be compatible as much as possible with them.
Just focusing on this tool is completely web-based, so the using interface is just using
the browser, it supports the robotics applications in Python, not yet in C++ and we are fully
compatible with Rostool framework, in particular with hand release for now.
And the idea is to make it the reuse of behavioral trees and modification using the web
browser, right. It's completely free and open source, you have the GitHub repository in the
talk, I mean in the website for this talk and we also provide a Dockerize environment just
to run robotics applications, regardless you're operating the system, so it works for
the Linux, Windows and Mac OS. Just focusing on the features and this tool has like two
different modes, the addition mode and the execution mode. In the addition mode, the behavioral
reactions can be created with a text editor and the tool itself provides a fine navigator,
just to navigate in the collection of actions of your application. And the behavioral structure
can be defined using a graphical visual editor, right. In both in the addition mode, we
are going to see the user interface look and feel in the next slide. And the gardening
execution mode, we have one execution viewer, you can see your robot doing whatever you
have programmed to do it. And also, I'm a monitor of the behavioral tree itself, so you can
check which which actions or which nodes are active or failing or succeeding. And we
also provide in that execution mode at text console, very useful for debugging, right.
Here, we have it BTS Studio, works both for real robots and simulated robots, because in
fact, it works as on top of raw stoppigs. So regardless, it's simulated one or real one,
your application just connects to the raw stoppigs. BTS Studio supports several projects.
I mean, you are study developer, you have like one hundred or twenty projects, it supports
that and even multiple universes. I mean, multiple scenarios, simulated worlds and even robots.
So this is the look and feel of the addition mode using interface. We can see here the
final navigator, so that we are one, a text editor, using syntax highlighting. And here,
we have the visual editor of the behavioral tree. You can easily create one behavioral tree,
just add in the correct or node, whatever you need. And we got in the user interface of
the execution mode. It's pretty much similar, but it has new components. We have here the
text console. Here, we have the execution viewer. We have it in this case, the Zebo. And
here, we have a behavioral tree monitor. So you can check here the current state of each
node. All of them are intended to provide a fast feedback to the developer.
I will continue from here. I will explain in more detail how the editor of the behavioral
tree is actually is. At the top, we can find a little top bar that has the top unmanaged
with all the available documents, provided by behavioral trees itself or your own custom
options. And then a couple of battles that will add more features that I will explain later.
Then the main focus, the canvas, it will allow to add our delete, modify whatever you want.
Your behavior tree is structure, dynamically and rectally. And it will also make easier example.
You want to customize your actions to have one specific color or another things. At input
for interactions or outputs, you can do that with the canvas. Then another part. At the
bottom, you can see there is a behavioral tree execution order, a little arrow. We couldn't
decide what was the better order. So in the end, we let the user decide which one you prefer.
Turn to bottom or turn to top. We also support subtrace and composition. Subtrace
or behavioral trees that you can include inside an arbitrary behavior tree. It doesn't have
cyclical imports, but everything else is supported. In the end, this provides a speed for the developer
because you can reuse your existing behavior trees inside an R1s. And it also allows us to
create a library. We are working on it currently, but we have around 2 or 3 examples of behavior
trees. Then the execution monitor mode that you have seen previously, it allows to
debug and see the state of your behavior tree in real time. You will tell which actions are
currently executing or the ones that are executed if they fail over the R1s. You can also
move seamlessly between your subtrace. You can enter them and go whack. And also, it displayed
the content of the bugboard tags. If you know the abuse behavior trees before, you will know what
types here are, but they provide you with the ability to share your data between multiple
nodes in the same application. Here, you can see how it looks and in the demos, you
will see it better. And then the device execution. We provide you with a Docker container that
works almost everywhere that Docker can run and it allows you to use rows and already provided
universes, seamlessly and easily. You don't have to install any dependencies, just Docker.
You run it and it connects to the web page. You can hear your unique universes and
important, or just use the ones that we provide there are around 30. And it also adds
the ability to control the execution. If you don't know, if you had used simulator before,
to launch a couple of cons to make sure that you run everything. Here, there's a couple
of buttons. You can play, pause, or start your execution. Here, we will see it later, better
in the demo, how it works. It also supports downloading. It's to create our rows package,
but this is not the main topic of this part. So I will just let you know that we have
and if you want to, here it is. How it works. How we have developed with this studio.
It uses three, so far for three parts. The rotting spark that it's based on rows.
And the simulator is normally gas station classic, the old one, and the new version,
like us of our money. We use pie trees as the base for behavior trees, then from
a web part. We use for the back in Django, and for the front in, we use React with TypeScript,
and of course CSS and HTML. And for the most part, as we said, we use Docker for the
execution on all dependencies. We have seen how our heritage structure is. Now we will see
how an action works. It's the same one as you have already used by trees before. It's the same
structure, just these five methods that will make everything you want in your application.
We provide templates for a, is it start? So you can know where to go. And finally, we have
the structure. We have the actions. We combine them to a single XML file that in the
end is what will run. If you have worked with behavior structure for with rows, you
will know that in this XML file, you have a single part that is your behavior tree.
Where is the fine? Here we have two. The first part of the behavior tree is the same as
you can do. And then we have the code part. We hold all the actions in a single file,
which is easier to execute. We'll see the demos. We start with the symbols in the
simplest one. It's a simple photo person. It's running as a
look classic. And as you can see in the blue notes, the position and the black
color type, ablation real time. The same as all the actions, the status. The orange one
is running. And the ring one is successful. And of course, the red one is it failed because
it didn't detect a person. Now we go to a bump and go. It's still easy, but it has
a position. So as you can see, there's a sub tree called aboid obstacle. And we will
enter inside it. There's another one called obstacle detection. And as you can see, it updates.
It takes a little while until the state of the application changed. And it will this in
this case, it failed. And well, it's easy again. We can go back to the previous
part and note. And also, again, to where we started. Finally, we have a more complex demo.
This is based on a row cap 2022 home challenge. As you can see, there's a lot of notes.
This shows how powerful the heritage can be. And in this case, how powerful they are
can be. It changes the execution. The little orange dot will go up as the actions go.
And it shows how it is for debugging. It also uses the console part to replace both commands
because they are not possible here. And it is also running in a several harmonic
set of the classic, which is the step forward because it's newer and better supported.
Finally, to just sum it up, we did studio sub web tool. That's the development quickly and easily
of behavior tree based applications with Rustos. We do not support any other robotics
backing or anything. We support Rustos to a humble. And we are working on supporting
jazzy. It is also integrated in univotics, the website. And towards the future, we want to
present a bit of studio to more of the open source community. And also to the Rust community.
We are developing more complex demos to show even more what can be done with the
here trees. And also we are improving our sub tree library. So you can use more
complex one. And are already in a couple of clicks. And also finally, we want to update
from behavior trees 3.8 to the new standard in 4.x releases. And that's it. I hope
you enjoy it.
You can have any performance. So we have time for questions.
Any questions?
So what kind of notes we have and what are the limits on that?
And behavior trees have defined pretty fine. A couple of notes such as sequence
failure in birth. So you can have, if I know it is a so full, it can turn failure.
We also have multiple sequences. Not only the basic one. We have reactive ones.
So if one note fails, it will start again. Everything. We have a full box.
We also support asynchronous execution of multiple actions at the same time.
And there are a couple of more. There are a little more complex. And it is better
to read the documentation because it can be really complex to start.
Something else?
Thanks for watching.