WEBVTT

00:00.050 --> 00:04.310
At this point, movie two is configured and also supports our robot.

00:04.310 --> 00:10.310
So now we can finally start using its amazing features to move the robots and the vector from the starting

00:10.310 --> 00:11.720
point to the end point.

00:11.720 --> 00:17.720
And so to plan and execute trajectories to launch this software with the configuration that we have

00:17.720 --> 00:24.530
created in the previous lesson, we need to create a new launch file inside the Arduino Moveit package

00:24.530 --> 00:26.900
that we create in the last lesson.

00:26.900 --> 00:30.890
So let's create a new folder and let's call this one launch.

00:30.920 --> 00:38.990
And within this folder let's create a new file called move it dot launch dot pi.

00:39.050 --> 00:46.520
As this is a launch file and a Python file, its purpose is to create an object of type launch description.

00:46.520 --> 00:54.710
So let's import from the launch library the launch description class.

00:54.920 --> 01:01.290
And let's define a new function called generate Launch.

01:03.390 --> 01:10.230
Description and the purpose of this function is to declare a list of instructions that needs to be executed

01:10.230 --> 01:11.790
when we start this launch file.

01:11.790 --> 01:18.150
So when we start the application and all these instructions needs to be listed within the constructor

01:18.510 --> 01:21.600
of the launch description class.

01:21.600 --> 01:23.580
So let's call the constructor.

01:23.610 --> 01:29.670
And this receives a list of instructions or a list of application that needs to be executed.

01:30.660 --> 01:34.560
Let's start by declaring a new argument for this launch file.

01:34.560 --> 01:35.730
So here.

01:35.760 --> 01:39.480
And so let's first import the declare launch argument.

01:39.870 --> 01:51.210
So from the launch library and from the actions module let's import the declare launch argument.

01:51.210 --> 01:53.610
And now let's use this one to create a new object.

01:53.610 --> 01:57.510
Let's call it is sim arg.

01:57.510 --> 01:59.700
So is sim argument.

01:59.770 --> 02:03.580
And this is an instance of the declare launch argument.

02:04.180 --> 02:12.070
Let's use this class to declare the argument is same, which indicates whether or not we are starting

02:12.070 --> 02:17.260
the moveit functionalities for the simulation and gazebo, or for the real robot.

02:17.830 --> 02:19.540
And so let's set by default.

02:19.570 --> 02:24.790
So let's set the default value to true.

02:24.790 --> 02:29.500
And this means that basically by default we are saying that we are starting the simulation.

02:29.500 --> 02:32.410
So we are starting move it for the simulated robot.

02:33.190 --> 02:36.760
Let's also import the launch configuration class.

02:37.090 --> 02:47.140
So from launch substitutions let's import the launch configuration class.

02:47.140 --> 02:51.850
And let's use it to create a new variable called is SIM.

02:51.850 --> 02:55.180
And this is an instance of the launch configuration class.

02:55.180 --> 02:58.270
And this contains the value that we assign at runtime.

02:58.270 --> 03:02.370
So when we start the launch file to the argument is same.

03:02.460 --> 03:09.330
And so this takes the value that we assigned to the is same argument at runtime.

03:09.330 --> 03:13.140
So when we start the launch file now we can finally start to move it.

03:13.170 --> 03:16.680
But before that we need to create its configuration.

03:16.680 --> 03:22.080
So we need to basically to declare this configuration file based on the file that we created in the

03:22.080 --> 03:23.250
previous lesson.

03:23.430 --> 03:31.500
So in order to create a moved configuration let's import from the move it config util package.

03:31.830 --> 03:35.340
Let's import the move it config builder.

03:35.340 --> 03:40.710
So let's import this class here and let's use it to create a new object of this class.

03:40.770 --> 03:46.290
Let's call it for example move it config.

03:46.290 --> 03:49.560
And this is an instance of the move it config builder.

03:49.560 --> 03:54.360
And we can use this object to customize the move it launch file for our robot.

03:54.570 --> 03:59.040
So let's start by assigning the name of our robot, which is.

04:00.220 --> 04:06.160
Arduino bot, and also the name of the package that contains the Moveit configuration for our robot.

04:06.250 --> 04:11.230
So let's use a comma and then the package name.

04:11.860 --> 04:19.090
So the one that contains the Moveit configuration is the Arduino bot move it package.

04:19.120 --> 04:24.850
And also now we need to specify where is located the Urdf model of our robot.

04:25.000 --> 04:26.740
So let's use Dot.

04:27.250 --> 04:30.160
And then let's set the robot description.

04:30.190 --> 04:34.990
So now we need to set the path to the Urdf model of our robot.

04:34.990 --> 04:36.670
So where it is located.

04:36.670 --> 04:44.140
And so to declare the path where the Urdf model is located, let's start by importing the OS library

04:44.140 --> 04:45.040
of Python.

04:45.040 --> 04:49.150
And then let's set the file path.

04:49.330 --> 04:52.210
Let's take the OS path.

04:52.300 --> 04:54.430
So let's take the join function.

04:55.840 --> 04:59.000
And now we need to specify where is located.

04:59.000 --> 05:01.880
So in which package we can find our robot description.

05:01.880 --> 05:04.070
So our Urdf model.

05:04.310 --> 05:15.050
So in order to specify the package let's import from the amend index Python library and from the packages

05:15.050 --> 05:22.070
module let's import the get package share directory.

05:22.070 --> 05:25.040
And now let's use this function here within the parentheses.

05:25.040 --> 05:27.740
So get package share directory.

05:27.800 --> 05:37.610
And the Urdf model of our robot is in the Arduino bot description package.

05:37.730 --> 05:40.580
Let's make this in a new line.

05:40.760 --> 05:44.480
And also let's add some parentheses here.

05:45.650 --> 05:47.630
And let's close this one okay.

05:47.630 --> 05:49.700
So now we can read it better.

05:50.510 --> 05:52.460
So let's adjust the formatting.

05:52.460 --> 05:53.360
Perfect.

05:53.480 --> 06:00.360
So now we said that our Urdf model of the robot was in the Arduino bot description package.

06:00.720 --> 06:12.810
Then it's within the Urdf folder and then it's called Arduino bot dot Urdf dot zero.

06:13.230 --> 06:20.070
Then we also need to declare the directory where the SDF file with the robot description semantics is

06:20.070 --> 06:20.910
located.

06:20.910 --> 06:25.470
So basically this file here that we created in the previous lesson.

06:26.310 --> 06:28.470
To do so let's add also.

06:28.470 --> 06:34.440
So here at the end of this file let's add the robot description semantic.

06:34.440 --> 06:41.130
So with the robot description we set for the movie config builder the directory of our Urdf model.

06:41.130 --> 06:47.490
And now with robot description semantic we set the directory of our SDF file.

06:48.060 --> 06:49.110
We can do the same.

06:49.110 --> 06:53.340
So we can still use the Os.path.join function.

06:53.340 --> 06:56.910
And in this case we can access to the file path.

06:56.910 --> 07:06.250
So to the file which contains the RDF directly accessing to the config folder and to the Arduino bot

07:06.280 --> 07:08.560
dot s RDF.

07:08.560 --> 07:13.930
Since basically this file is in the same package in which we are creating the launch file.

07:14.590 --> 07:23.230
Next, let's also configure the robot's execution of the trajectories with the trajectory execution,

07:23.230 --> 07:30.550
and we configured the trajectory execution of the robot within the Moveit controllers YAML file.

07:30.580 --> 07:42.010
So again the file path is in the config folder and is called move it controllers dot YAML.

07:42.010 --> 07:46.510
So it is going to use this YAML file to configure the trajectory execution.

07:47.200 --> 07:50.740
Finally let's take the configuration from this class.

07:50.740 --> 07:57.310
So from this Moveit configuration builder object that we have created in order to configure move it.

07:57.330 --> 08:01.230
So let's use the function to move it.

08:01.260 --> 08:02.280
Configuration.

08:02.280 --> 08:04.950
And so basically this will convert this object.

08:04.950 --> 08:10.950
So the object of this class into a configuration that we can provide directly to the move it to node

08:10.950 --> 08:13.140
and so directly to the executable.

08:13.140 --> 08:15.210
So let's start move it.

08:15.210 --> 08:17.400
So let's start the move it executable.

08:17.520 --> 08:21.780
And first let's import from launch Ros.

08:22.080 --> 08:27.900
And from the actions module let's import the node module.

08:28.110 --> 08:31.980
And now we can start the core of move it.

08:31.980 --> 08:38.520
So the move group node of move it as a new empty node.

08:38.520 --> 08:42.420
And so this node starts from the package.

08:43.470 --> 08:45.870
Move it Ros move group.

08:45.870 --> 08:51.810
So from move it Ros move group.

08:51.810 --> 08:57.060
From this package it starts the executable that is called.

08:57.580 --> 08:59.470
move group.

08:59.470 --> 09:03.610
And as you remember, this is the core of the move with two functionalities.

09:03.640 --> 09:05.920
Then let's also display the output.

09:05.920 --> 09:09.460
So any log message that basically this node will print.

09:09.490 --> 09:12.580
Let's display all of these messages in the terminal.

09:12.610 --> 09:17.860
By setting output to screen.

09:17.950 --> 09:21.490
And then let's configure and pass some parameters.

09:21.820 --> 09:24.070
So let's pass some parameters.

09:24.070 --> 09:30.130
And these parameters are exactly the configuration parameters of move it that we have just created with

09:30.130 --> 09:31.990
the move it configuration builder.

09:31.990 --> 09:34.330
And that we have stored in the move it.

09:34.360 --> 09:39.220
So this here we are missing an E in the move it config variable.

09:39.340 --> 09:44.620
So let's copy this variable and let's paste it within the parameters.

09:45.040 --> 09:47.950
And let's take a dictionary.

09:48.970 --> 09:52.660
And then let's also set another parameter which is the parameter.

09:52.660 --> 09:55.690
Use same time.

09:56.020 --> 09:59.990
And let's set this one equal to the value is sim.

09:59.990 --> 10:06.200
So basically equal to the value that is assigned to the sim argument of the launch file.

10:06.200 --> 10:11.630
So basically if when we start this launch file we pass the argument is sim and we set it to true.

10:11.660 --> 10:16.340
Then the use sim time of the move group will be set to true as well.

10:16.370 --> 10:18.950
Otherwise it will be set to false.

10:19.490 --> 10:22.790
Let's also set one more parameter as another dictionary.

10:23.030 --> 10:29.270
And this is the publish robot description

10:31.100 --> 10:32.360
semantic.

10:32.360 --> 10:35.900
And let's set this one to true as well.

10:35.900 --> 10:41.990
And this basically will allow us the name of this parameter says this will allow to publish in our Ros2

10:42.020 --> 10:42.500
topic.

10:42.500 --> 10:43.880
Also this here.

10:43.880 --> 10:50.330
So also this configuration here that is the SDF file that we created in the previous lesson.

10:51.290 --> 10:54.110
Let's also provide some more arguments to this node.

10:54.170 --> 10:57.090
So let's use Arguments.

10:57.570 --> 11:00.210
And then let's pass the Ross arguments.

11:00.210 --> 11:07.770
So Ross args and let's set for example the Loglevel flag to info.

11:08.400 --> 11:18.210
So let's set the log level to be info so that all the informative messages that this node.

11:18.210 --> 11:22.920
So the move group node is printing are displayed correctly in the window.

11:22.920 --> 11:25.080
So are displayed correctly in the terminal.

11:25.890 --> 11:28.770
Next we can finally start also RVs.

11:28.770 --> 11:32.340
And we can do this as a normal ros2 node.

11:32.340 --> 11:35.370
So let's call this one RVs node.

11:35.460 --> 11:38.280
And this is an instance of the node class.

11:38.610 --> 11:49.890
And from the package that is called RVs two let's start the executable that is also called RVs two and

11:49.890 --> 11:50.670
let's call it.

11:50.670 --> 11:55.870
So let's give it a name that we call RVs two as well.

11:55.930 --> 12:01.390
Let's set also the output argument to be screen.

12:01.390 --> 12:04.840
In order for the log messages to be printed in the terminal.

12:04.840 --> 12:14.380
And then let's pass some more arguments to this log file, and let's use the flag minus d to to visualize

12:14.380 --> 12:15.040
by default.

12:15.040 --> 12:18.400
So when we start out with a predefined configuration.

12:18.400 --> 12:26.410
So instead of loading the empty service window it will load a Pre-created and a predefined service configuration.

12:26.410 --> 12:34.840
And so let's for example store this one within a new variable that we are going to call RV config.

12:34.840 --> 12:42.760
So now let's create this variable before using it actually here and here let's indicate the full path

12:42.760 --> 12:47.680
of the RV configuration that we want to launch at the startup of this node.

12:47.680 --> 12:53.860
So again let's use the function join from the US path library.

12:53.860 --> 12:57.120
And here let's use the Get Package share directory.

12:57.120 --> 13:03.660
In order to access to the directory of the Arduino bot move it package.

13:03.660 --> 13:07.830
So here there is a mistake Arduino bot move it package.

13:07.830 --> 13:13.680
And then within this package let's access to the config folder.

13:13.680 --> 13:18.930
And then within this config folder we want our service to be loaded with the configuration.

13:19.350 --> 13:21.750
Move it dot RVs.

13:22.230 --> 13:23.280
For this moment.

13:23.280 --> 13:25.440
This configuration is not yet created.

13:25.440 --> 13:31.590
So as we can see there is no such configuration that is called movie dot RVs in the config folder.

13:31.590 --> 13:38.040
And so at the startup, at the first startup of all these functionalities, we will see the classic

13:38.070 --> 13:39.750
empty window of RVs.

13:39.780 --> 13:45.510
And then we will save the configuration and we will save the configuration of service under the name

13:45.510 --> 13:50.760
of move it service, so that every time you are going to launch again this node in the future, you

13:50.760 --> 13:57.040
will start by using by default, this visualization instead of adding all the plugins one by one.

13:58.240 --> 14:00.730
Then let's continue the setup of the Arviz node.

14:00.730 --> 14:02.950
So here let's pass some parameters.

14:03.790 --> 14:05.200
So this is a list.

14:05.230 --> 14:10.330
And from the move it configuration that is from the move it config object.

14:10.330 --> 14:11.320
From this one.

14:11.320 --> 14:13.930
Let's pass the robot description.

14:13.930 --> 14:19.480
So here let's take this parameter and let's pass the robot description.

14:19.480 --> 14:21.190
So let's take the robot description.

14:21.190 --> 14:24.850
And also let's take the steel from the move it config.

14:24.850 --> 14:27.640
Let's take the robot description semantic.

14:27.640 --> 14:35.440
And so basically the file as RDF and also as a parameter still from the movie config.

14:35.440 --> 14:41.440
Let's take the robot description kinematics and also the joint limits.

14:41.740 --> 14:44.800
So let's take the joint limits.

14:45.730 --> 14:51.520
All of these configuration parameters that we are passing to Arviz are needed when we start RVs.

14:51.520 --> 14:56.480
And when we display the move, it to interface that is available in RVs.

14:56.930 --> 15:03.170
Now with this set, we have declared all the components that we need to start in order to use it with

15:03.170 --> 15:04.070
our robot.

15:04.070 --> 15:08.120
So all that it remains is to declare all these components.

15:08.120 --> 15:13.640
So to list all of these components here within the launch description constructor.

15:13.640 --> 15:17.720
So let's start by declaring the is sim argument.

15:17.720 --> 15:20.270
And this will be an argument of this launch file.

15:20.270 --> 15:22.610
So you can start this launch file.

15:22.640 --> 15:28.310
Setting this argument to true or false depending on whether you are starting to move it for the real

15:28.310 --> 15:30.290
robot or for the simulated one.

15:30.530 --> 15:34.670
Then let's start the move group node that is the core of move it.

15:34.670 --> 15:41.060
And then let's also start the RVs node that will allow us to interact with the graphical user interface

15:41.060 --> 15:44.600
with move it before moving on.

15:44.600 --> 15:51.740
So let's save this launch file and then let's go into the Cmakelists.txt in order to install.

15:51.740 --> 15:53.210
Also the launch folder.

15:53.210 --> 15:59.460
So in order to install the config and the launch folder and so that they these two folders are recognized

15:59.460 --> 16:00.660
in Ros2.

16:01.050 --> 16:07.350
So here before the build testing let's use a new install instruction.

16:07.350 --> 16:15.720
And let's install the directory launch and also the directory config.

16:15.720 --> 16:18.480
And then now we need to set the destination.

16:18.510 --> 16:25.470
So the destination in which we want to install these two folders is the share folder.

16:25.470 --> 16:28.620
And then the subfolder that has the same name of the package.

16:28.620 --> 16:30.630
So Arduino bot move it.

16:30.960 --> 16:37.170
And we can access to this name through the project name variable.

16:37.170 --> 16:39.210
So let's use the project name variable.

16:39.240 --> 16:46.320
Let's save this file and let's finally modify also the package dot XML file in order to add the missing

16:46.320 --> 16:47.340
dependencies.

16:47.520 --> 16:54.340
So here let's add an execution dependency from the Ros2 launch library since we have created our launch

16:54.340 --> 16:59.590
file, then another execution dependency from harvest two.

16:59.620 --> 17:09.130
Since in our launch file, we started harvest two and then another execution dependency from the move

17:09.130 --> 17:16.450
it config utils from which we have used the move it config builder.

17:16.570 --> 17:20.440
So now also the package dot XML is completed.

17:20.440 --> 17:24.970
And now we can finally build our workspace and launch this file.

17:25.630 --> 17:28.870
So let's open a new window of the terminal here.

17:28.870 --> 17:33.850
Let's go to the workspace and let's build it with Qualcomm Build.

17:33.850 --> 17:37.660
So this is compiling our Arduino bot move it package.

17:37.660 --> 17:41.080
And so it's installing the launch file that we have created.

17:41.080 --> 17:44.500
And also all the configuration files that we have created.

17:44.590 --> 17:48.370
And then we can finally start the simulation of our robot.

17:48.370 --> 17:57.450
So in a new terminal let's source the file setup bash and let's launch from the Arduino bot description

17:57.450 --> 18:00.360
package, the gazebo launch dot Pi.

18:00.390 --> 18:04.950
So this is launching the simulation of our robot in the empty environment.

18:05.520 --> 18:06.150
Here we go.

18:06.150 --> 18:11.850
And this is also loading the Ros2 control library for the simulated robot.

18:11.850 --> 18:18.330
And so basically we will be able to use this library in order to interact with the simulated motors.

18:18.330 --> 18:21.480
So with the simulated actuators in the gazebo simulation.

18:21.480 --> 18:27.810
And so to move our robot here in the simulated environment, in order to do so we also need to start

18:27.810 --> 18:29.550
the control system of the robot.

18:29.550 --> 18:37.650
So in a new terminal again let's source the workspace and let's launch with Ros2 launch and this time

18:37.650 --> 18:39.270
from the Arduino bot controller.

18:39.270 --> 18:42.240
Let's start the controller launch dot Pi.

18:42.360 --> 18:44.070
So let's press enter.

18:44.070 --> 18:47.190
So this is starting the control system of the robot.

18:47.190 --> 18:51.690
And also we have here the configuration that we have correctly configured.

18:51.720 --> 18:55.960
And activated both the ARM controller and also the gripper controller.

18:55.990 --> 18:58.090
And so finally everything is set.

18:58.120 --> 19:04.120
In order to start, move it and in fact move it will use actually these two controllers.

19:04.120 --> 19:08.590
So the gripper controller and the ARM controller in order to send commands.

19:08.590 --> 19:13.690
And so in order to move the robot from the current position to the desired one.

19:13.840 --> 19:15.940
So let's finally start to move it.

19:15.940 --> 19:23.020
So again in a new window, let's source the file setup and let's launch with Ros2.

19:23.020 --> 19:24.820
Launch from the Arduino board.

19:24.850 --> 19:25.840
Move it package.

19:25.840 --> 19:30.460
Let's start the launch file that is called move it launch dot Pi.

19:30.460 --> 19:32.260
So let's press enter.

19:33.310 --> 19:38.200
And now it is apart from starting all the move it functionalities and the configuration that we have

19:38.200 --> 19:41.800
set, it also starts the service window.

19:41.800 --> 19:48.070
And so as we can see here this is just an empty window that now we can configure in order to interact

19:48.070 --> 19:48.880
with the robot.

19:48.880 --> 19:51.910
And so in order to set the desired pose of the robot.

19:51.910 --> 19:55.730
And so to move the robot from the current pose to the desired one.

19:55.850 --> 20:01.550
To do so, the first thing that we need to do is to change the fixed frame to the world frame.

20:01.550 --> 20:06.830
So this is the starting frame that Moovit is using in order to link our robot.

20:06.830 --> 20:10.520
So this one here to the world, so to the empty world for the moment.

20:10.520 --> 20:18.440
And then we can also add from the movie cross visualization this one here the motion planning plugin.

20:18.440 --> 20:19.760
So let's add it.

20:21.890 --> 20:25.460
And this is adding quite a lot of information.

20:25.460 --> 20:31.010
So we can see that we have now here a new panel that we can use in order to interact with the robot.

20:31.010 --> 20:36.980
And also here we can already see that our robot is being displayed in the service window.

20:36.980 --> 20:39.860
So this is the model of our robot in its current position.

20:39.860 --> 20:42.680
So as we can see they perfectly match.

20:42.680 --> 20:48.290
And also we can see that here we have a sphere that is attached to the arm of the robot that we can

20:48.290 --> 20:51.290
use in order to move our robot around.

20:51.290 --> 20:57.960
And so in order to set a goal state for the robot before doing so, we need to select a planner.

20:57.960 --> 21:02.760
So let's go to the context here and let's change here.

21:02.760 --> 21:07.770
The planning library that we are going to use for our robot is the Ompl library.

21:07.770 --> 21:10.800
So take care of choosing this library here.

21:10.800 --> 21:15.450
And if you don't have it installed, you can just open a new window of the terminal.

21:15.450 --> 21:24.690
Select this and let's use the command sudo apt get install and from the Ros followed by the version

21:24.690 --> 21:26.190
of ros2 that you are using.

21:26.190 --> 21:28.230
That in my case it is Jessie.

21:28.260 --> 21:31.350
Let's install the move it planners.

21:31.350 --> 21:37.200
And then if we press tab twice we can see that here we have the move it planners ompl.

21:37.230 --> 21:41.190
So I'm not going to install it as I have already it here.

21:41.190 --> 21:42.780
So I can close this one.

21:42.780 --> 21:46.650
So here make sure that you have the Ompl library loaded.

21:46.650 --> 21:49.500
And then back in the planning.

21:49.500 --> 21:52.690
Let's also enable this checkbox here.

21:52.690 --> 21:54.040
So the approx.

21:54.040 --> 21:59.740
Inverse kinematics solution as this will make the calculation much faster.

21:59.800 --> 22:00.640
Perfect.

22:00.640 --> 22:06.160
So now we can actually grab this sphere here.

22:06.160 --> 22:10.120
And so we can see that as we grab this sphere all the robot moves.

22:10.120 --> 22:13.900
So the robot that this this one here.

22:13.900 --> 22:18.670
So the orange one is representative of the goal state of the robot.

22:18.670 --> 22:20.950
So we are moving the goal state of the robot.

22:20.950 --> 22:24.010
And this instead is the current status of the robot.

22:24.010 --> 22:26.800
So as we can see this is the current position.

22:26.800 --> 22:30.610
And this orange one here is instead the goal position.

22:30.610 --> 22:34.870
So the position in which we want the robot to be after the movement.

22:34.900 --> 22:41.830
So now once we have selected our goal position that is this one, here we can simply plan and execute

22:41.860 --> 22:42.490
a path.

22:42.490 --> 22:45.190
So let's press on plan and execute.

22:45.190 --> 22:48.520
And we can see that as we press on this button here.

22:48.520 --> 22:51.210
Both the robot here in service.

22:51.210 --> 22:53.580
And also the simulated robot are moving.

22:53.580 --> 22:56.040
And then we can see that perfectly.

22:56.040 --> 22:57.930
So the red position.

22:57.930 --> 23:02.640
So the red robot here in service perfectly matches the orange one.

23:02.640 --> 23:07.170
And so this confirms us that the movement was completed successfully.

23:07.290 --> 23:13.080
So the current position of the robot is exactly equal to the desired position.

23:13.260 --> 23:17.580
Also apart from moving the arm we can also move the gripper.

23:17.580 --> 23:19.260
And in order to do so.

23:19.260 --> 23:25.440
So if we change the visualization in order to see the gripper here, we can change the planning group.

23:25.740 --> 23:29.550
And here we have the two planning groups that we have set for move it.

23:29.550 --> 23:33.180
And so for example let's select now the planning group for the gripper.

23:33.210 --> 23:34.200
Also in gazebo.

23:34.200 --> 23:38.640
Let's visualize it a little bit better so we can see the gripper moving.

23:38.670 --> 23:41.160
And now also for the gripper.

23:41.160 --> 23:44.160
So here make sure that you have the planning group gripper.

23:44.160 --> 23:47.730
And also for the gripper we want to use as a planning library.

23:47.730 --> 23:52.210
So back in the context we want to use the Ompl library.

23:52.210 --> 23:54.070
So let's choose this library here.

23:54.100 --> 23:54.880
Perfect.

23:54.880 --> 23:56.320
And now for the gripper.

23:56.320 --> 24:00.340
For example, we can set the start state as the current state.

24:00.340 --> 24:01.810
So the gripper is closed.

24:01.810 --> 24:06.370
And as the goal state we can set just a random valid state.

24:06.370 --> 24:12.100
So let's press this one so we can see that this orange one will be the new state.

24:12.100 --> 24:14.830
So the gripper will slightly open.

24:14.830 --> 24:17.830
And this red one is the current state.

24:17.830 --> 24:24.310
So now if we press plan and execute also for the gripper we can see that in the simulation the gripper

24:24.310 --> 24:25.510
is now opening.

24:25.510 --> 24:30.040
And also here we can see that in RVs the red arm.

24:30.040 --> 24:33.730
So the red gripper is perfectly matching the orange one.

24:33.730 --> 24:39.730
So this means that the current state of the robot is perfectly matching the goal state that we have

24:39.730 --> 24:40.360
set.

24:40.390 --> 24:47.320
Now, feel free to continue playing with this tool, and to send the robot in new position, and to

24:47.350 --> 24:49.420
create your own movements.
