WEBVTT

00:00.000 --> 00:24.000
Okay, so for the next talk, Jose Maria Kenya's plaza and Javier Esquerro Hernandez will talk us

00:24.000 --> 00:28.480
about BTS Studio, which is a programming framework for behavioral trees.

00:28.480 --> 00:36.560
Well, I think what's based, they come from JBA Robotics Project and Universias, really

00:36.560 --> 00:37.560
some fun.

00:37.560 --> 00:38.560
Thank you.

00:38.560 --> 00:39.560
Sorry.

00:39.560 --> 01:01.120
Okay, so we are going to present today the BTS Studio is a work tool, just for programming

01:01.200 --> 01:09.680
Robotics applications, but Robotics applications based on BTB tree is right.

01:09.680 --> 01:16.680
We are part of this organization, JDA Robotics and open source organization that develops

01:16.680 --> 01:20.080
open source software for robotics and artificial intelligence.

01:20.080 --> 01:27.480
It was started in 2018 and currently we are more or less 20 developers worldwide.

01:27.480 --> 01:33.240
We developed a several projects, maybe the most important one is Robotics Academy, it's a

01:33.240 --> 01:39.480
framework for learning robotics, robotics, service robotics, rom programming, artificial

01:39.480 --> 01:46.920
intelligence programming, universities, these are web-based websites, they are also for programming

01:46.920 --> 01:52.920
robots and we have also several tools, such as BTS Studio and BTS Studio, today we are going

01:53.000 --> 01:59.000
to present here BTS Studio, at the same time we perform several activities on the year,

01:59.000 --> 02:05.760
we offer interships, just to mentor someone, interested in learning more things about Robotics

02:05.760 --> 02:09.440
and artificial intelligence and we participate in the Google Summer of Code.

02:09.440 --> 02:17.760
So this is the last year was a ninth, the ninth one, in fact, this period was forced

02:17.840 --> 02:22.840
to insert a white one, this is a project, the VTS Studio and software itself and that's

02:22.840 --> 02:28.280
all mass media, social media and also the web page you can take it.

02:28.280 --> 02:36.000
Well, so there is a train in the last years for developing robotics applications but

02:36.000 --> 02:42.400
using BTB tree abstraction, this is quite similar to a hierarchical finite machine but

02:42.480 --> 02:51.680
has more advantages, such a better composition, right. So being aware of that, we try to facilitate

02:51.680 --> 02:57.840
the development of new robotics applications following that paradigm.

02:57.840 --> 03:03.520
We before start in this project, this is a one year and a half project so far, we just took

03:03.520 --> 03:10.240
a look at different software pieces available regarding this topic and we found good and good

03:10.240 --> 03:17.240
too, also by trees, it's the implementation of the heavy tree in Python and also the

03:17.240 --> 03:24.200
heavy trees, CPP from the BTB faculty and all tool is based on inspired by all of them.

03:24.200 --> 03:33.200
So we try to take a dears from all of them and be compatible as much as possible with them.

03:33.200 --> 03:40.200
Just focusing on this tool is completely web-based, so the using interface is just using

03:40.200 --> 03:49.200
the browser, it supports the robotics applications in Python, not yet in C++ and we are fully

03:49.200 --> 03:55.840
compatible with Rostool framework, in particular with hand release for now.

03:55.840 --> 04:02.640
And the idea is to make it the reuse of behavioral trees and modification using the web

04:02.640 --> 04:10.080
browser, right. It's completely free and open source, you have the GitHub repository in the

04:10.080 --> 04:16.560
talk, I mean in the website for this talk and we also provide a Dockerize environment just

04:16.560 --> 04:21.080
to run robotics applications, regardless you're operating the system, so it works for

04:21.080 --> 04:30.280
the Linux, Windows and Mac OS. Just focusing on the features and this tool has like two

04:30.280 --> 04:36.720
different modes, the addition mode and the execution mode. In the addition mode, the behavioral

04:36.760 --> 04:43.760
reactions can be created with a text editor and the tool itself provides a fine navigator,

04:43.760 --> 04:51.160
just to navigate in the collection of actions of your application. And the behavioral structure

04:51.160 --> 04:59.960
can be defined using a graphical visual editor, right. In both in the addition mode, we

04:59.960 --> 05:06.640
are going to see the user interface look and feel in the next slide. And the gardening

05:06.640 --> 05:13.040
execution mode, we have one execution viewer, you can see your robot doing whatever you

05:13.040 --> 05:18.640
have programmed to do it. And also, I'm a monitor of the behavioral tree itself, so you can

05:18.640 --> 05:27.240
check which which actions or which nodes are active or failing or succeeding. And we

05:27.240 --> 05:33.680
also provide in that execution mode at text console, very useful for debugging, right.

05:33.680 --> 05:39.040
Here, we have it BTS Studio, works both for real robots and simulated robots, because in

05:39.040 --> 05:46.360
fact, it works as on top of raw stoppigs. So regardless, it's simulated one or real one,

05:46.360 --> 05:54.920
your application just connects to the raw stoppigs. BTS Studio supports several projects.

05:54.920 --> 06:02.280
I mean, you are study developer, you have like one hundred or twenty projects, it supports

06:02.280 --> 06:09.080
that and even multiple universes. I mean, multiple scenarios, simulated worlds and even robots.

06:09.080 --> 06:15.600
So this is the look and feel of the addition mode using interface. We can see here the

06:15.600 --> 06:22.760
final navigator, so that we are one, a text editor, using syntax highlighting. And here,

06:22.760 --> 06:29.600
we have the visual editor of the behavioral tree. You can easily create one behavioral tree,

06:29.600 --> 06:35.920
just add in the correct or node, whatever you need. And we got in the user interface of

06:35.920 --> 06:42.360
the execution mode. It's pretty much similar, but it has new components. We have here the

06:42.360 --> 06:50.440
text console. Here, we have the execution viewer. We have it in this case, the Zebo. And

06:50.440 --> 06:59.240
here, we have a behavioral tree monitor. So you can check here the current state of each

06:59.240 --> 07:06.240
node. All of them are intended to provide a fast feedback to the developer.

07:06.240 --> 07:11.540
I will continue from here. I will explain in more detail how the editor of the behavioral

07:11.540 --> 07:21.280
tree is actually is. At the top, we can find a little top bar that has the top unmanaged

07:21.280 --> 07:26.280
with all the available documents, provided by behavioral trees itself or your own custom

07:26.320 --> 07:33.320
options. And then a couple of battles that will add more features that I will explain later.

07:33.320 --> 07:40.320
Then the main focus, the canvas, it will allow to add our delete, modify whatever you want.

07:40.320 --> 07:48.600
Your behavior tree is structure, dynamically and rectally. And it will also make easier example.

07:48.600 --> 07:55.600
You want to customize your actions to have one specific color or another things. At input

07:55.640 --> 08:01.520
for interactions or outputs, you can do that with the canvas. Then another part. At the

08:01.520 --> 08:06.400
bottom, you can see there is a behavioral tree execution order, a little arrow. We couldn't

08:06.400 --> 08:13.400
decide what was the better order. So in the end, we let the user decide which one you prefer.

08:13.400 --> 08:21.400
Turn to bottom or turn to top. We also support subtrace and composition. Subtrace

08:21.440 --> 08:26.400
or behavioral trees that you can include inside an arbitrary behavior tree. It doesn't have

08:26.400 --> 08:35.400
cyclical imports, but everything else is supported. In the end, this provides a speed for the developer

08:35.400 --> 08:42.400
because you can reuse your existing behavior trees inside an R1s. And it also allows us to

08:42.400 --> 08:49.400
create a library. We are working on it currently, but we have around 2 or 3 examples of behavior

08:49.400 --> 08:58.400
trees. Then the execution monitor mode that you have seen previously, it allows to

08:58.400 --> 09:05.200
debug and see the state of your behavior tree in real time. You will tell which actions are

09:05.200 --> 09:12.640
currently executing or the ones that are executed if they fail over the R1s. You can also

09:12.640 --> 09:19.640
move seamlessly between your subtrace. You can enter them and go whack. And also, it displayed

09:19.640 --> 09:24.640
the content of the bugboard tags. If you know the abuse behavior trees before, you will know what

09:24.640 --> 09:34.640
types here are, but they provide you with the ability to share your data between multiple

09:35.640 --> 09:43.640
nodes in the same application. Here, you can see how it looks and in the demos, you

09:43.640 --> 09:51.640
will see it better. And then the device execution. We provide you with a Docker container that

09:51.640 --> 09:58.640
works almost everywhere that Docker can run and it allows you to use rows and already provided

09:58.640 --> 10:05.640
universes, seamlessly and easily. You don't have to install any dependencies, just Docker.

10:05.640 --> 10:13.640
You run it and it connects to the web page. You can hear your unique universes and

10:13.640 --> 10:20.640
important, or just use the ones that we provide there are around 30. And it also adds

10:20.640 --> 10:25.640
the ability to control the execution. If you don't know, if you had used simulator before,

10:25.640 --> 10:31.640
to launch a couple of cons to make sure that you run everything. Here, there's a couple

10:31.640 --> 10:38.640
of buttons. You can play, pause, or start your execution. Here, we will see it later, better

10:38.640 --> 10:46.640
in the demo, how it works. It also supports downloading. It's to create our rows package,

10:46.640 --> 10:52.640
but this is not the main topic of this part. So I will just let you know that we have

10:52.640 --> 10:59.640
and if you want to, here it is. How it works. How we have developed with this studio.

10:59.640 --> 11:07.640
It uses three, so far for three parts. The rotting spark that it's based on rows.

11:07.640 --> 11:13.640
And the simulator is normally gas station classic, the old one, and the new version,

11:13.640 --> 11:21.640
like us of our money. We use pie trees as the base for behavior trees, then from

11:21.640 --> 11:28.640
a web part. We use for the back in Django, and for the front in, we use React with TypeScript,

11:28.640 --> 11:35.640
and of course CSS and HTML. And for the most part, as we said, we use Docker for the

11:35.640 --> 11:42.640
execution on all dependencies. We have seen how our heritage structure is. Now we will see

11:42.640 --> 11:48.640
how an action works. It's the same one as you have already used by trees before. It's the same

11:48.640 --> 11:56.640
structure, just these five methods that will make everything you want in your application.

11:56.640 --> 12:06.640
We provide templates for a, is it start? So you can know where to go. And finally, we have

12:06.640 --> 12:11.640
the structure. We have the actions. We combine them to a single XML file that in the

12:11.640 --> 12:18.640
end is what will run. If you have worked with behavior structure for with rows, you

12:18.640 --> 12:24.640
will know that in this XML file, you have a single part that is your behavior tree.

12:24.640 --> 12:29.640
Where is the fine? Here we have two. The first part of the behavior tree is the same as

12:29.640 --> 12:34.640
you can do. And then we have the code part. We hold all the actions in a single file,

12:34.640 --> 12:42.640
which is easier to execute. We'll see the demos. We start with the symbols in the

12:42.640 --> 12:49.640
simplest one. It's a simple photo person. It's running as a

12:49.640 --> 12:56.640
look classic. And as you can see in the blue notes, the position and the black

12:56.640 --> 13:04.640
color type, ablation real time. The same as all the actions, the status. The orange one

13:04.640 --> 13:11.640
is running. And the ring one is successful. And of course, the red one is it failed because

13:11.640 --> 13:23.640
it didn't detect a person. Now we go to a bump and go. It's still easy, but it has

13:23.640 --> 13:30.640
a position. So as you can see, there's a sub tree called aboid obstacle. And we will

13:30.640 --> 13:36.640
enter inside it. There's another one called obstacle detection. And as you can see, it updates.

13:36.640 --> 13:42.640
It takes a little while until the state of the application changed. And it will this in

13:42.640 --> 13:49.640
this case, it failed. And well, it's easy again. We can go back to the previous

13:49.640 --> 14:01.640
part and note. And also, again, to where we started. Finally, we have a more complex demo.

14:01.640 --> 14:08.640
This is based on a row cap 2022 home challenge. As you can see, there's a lot of notes.

14:08.640 --> 14:14.640
This shows how powerful the heritage can be. And in this case, how powerful they are

14:15.640 --> 14:23.640
can be. It changes the execution. The little orange dot will go up as the actions go.

14:23.640 --> 14:36.640
And it shows how it is for debugging. It also uses the console part to replace both commands

14:36.640 --> 14:42.640
because they are not possible here. And it is also running in a several harmonic

14:42.640 --> 14:54.640
set of the classic, which is the step forward because it's newer and better supported.

14:54.640 --> 15:04.640
Finally, to just sum it up, we did studio sub web tool. That's the development quickly and easily

15:04.640 --> 15:13.640
of behavior tree based applications with Rustos. We do not support any other robotics

15:13.640 --> 15:21.640
backing or anything. We support Rustos to a humble. And we are working on supporting

15:21.640 --> 15:30.640
jazzy. It is also integrated in univotics, the website. And towards the future, we want to

15:30.640 --> 15:36.640
present a bit of studio to more of the open source community. And also to the Rust community.

15:36.640 --> 15:42.640
We are developing more complex demos to show even more what can be done with the

15:42.640 --> 15:49.640
here trees. And also we are improving our sub tree library. So you can use more

15:50.640 --> 15:56.640
complex one. And are already in a couple of clicks. And also finally, we want to update

15:56.640 --> 16:04.640
from behavior trees 3.8 to the new standard in 4.x releases. And that's it. I hope

16:04.640 --> 16:09.640
you enjoy it.

16:10.640 --> 16:19.640
You can have any performance. So we have time for questions.

16:19.640 --> 16:25.640
Any questions?

16:25.640 --> 16:33.640
So what kind of notes we have and what are the limits on that?

16:33.640 --> 16:40.640
And behavior trees have defined pretty fine. A couple of notes such as sequence

16:40.640 --> 16:47.640
failure in birth. So you can have, if I know it is a so full, it can turn failure.

16:47.640 --> 16:54.640
We also have multiple sequences. Not only the basic one. We have reactive ones.

16:54.640 --> 17:01.640
So if one note fails, it will start again. Everything. We have a full box.

17:01.640 --> 17:10.640
We also support asynchronous execution of multiple actions at the same time.

17:10.640 --> 17:16.640
And there are a couple of more. There are a little more complex. And it is better

17:16.640 --> 17:23.640
to read the documentation because it can be really complex to start.

17:23.640 --> 17:33.640
Something else?

17:53.640 --> 18:00.640
Thanks for watching.

