Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Design docs for manipulation #226

Open
wants to merge 17 commits into
base: development
Choose a base branch
from

Conversation

j-rivero
Copy link
Collaborator

Fixes o3de/o3de-extras#151

Draft documents about the implementation of the manipulation feature for the o3de-ros2-gem. Mostly inspired by #162.

List of files:

  • design.md: main intro file
  • analysis.md: detailed description about what we understand as manipulation, how does it applies to the o3de-ros2-gem
  • architecture.md: (TODO) class diagram for the implementation
  • features.md: list of features desired for the manipulation feature
  • manipulation.svg: informal diagram of data flow and interactions between o3de and ROS 2 for the different aspects of the manipulation.

I left thearchitecture.md to be done since I have no previous knowledge of the gem/o3de internals. Any guidance or help is very welcome. I left the PR as Draft by now but I can happy answer to any feedback on the current content.

Original draft for the manipulation feature implementation.
TODO: no architecture diagram was done yet.

Signed-off-by: Jose Luis Rivero <[email protected]>
@j-rivero j-rivero requested a review from adamdbrw September 22, 2022 23:34
Copy link
Member

@adamdbrw adamdbrw left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Nice docs!

@adamdbrw adamdbrw added the documentation Improvements or additions to documentation label Sep 26, 2022
@adamdbrw adamdbrw added this to the Milestone 2 milestone Sep 26, 2022
@@ -0,0 +1 @@
(TODO)
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This can be added in another PR

Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

.med -> .md

Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Looks like a duplicate of architecture.md

Copy link
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

sorry for that. Removed in 6b5e82d

@adamdbrw
Copy link
Member

@j-rivero I remember we spoke about the architecture. Are you working on it or should I go ahead?
I would start with implementing a skeleton of Components and classes to populate (we can divide smaller tasks easier then)

@adamdbrw
Copy link
Member

adamdbrw commented Nov 2, 2022

@j-rivero Is this PR going to be ready for review?

@adamdbrw adamdbrw modified the milestones: Milestone 2, General Backlog Nov 3, 2022
@j-rivero
Copy link
Collaborator Author

j-rivero commented Nov 3, 2022

@j-rivero Is this PR going to be ready for review?

I think that is mostly ready with the exception of the architecture. I can spend some time trying to create but we can probably go faster if someone with more experience in O3DE and the Gem code base create the initial draft.

Signed-off-by: Jose Luis Rivero <[email protected]>
Copy link
Contributor

@lgleim lgleim left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

These design docs are a great starting point for Manipulation in O3DE!
After internal discussion at Huawei, we came up with a bunch of minor editorial suggestions and a more fundamental question about the intended scope of the manipulation feature.

While the current architectural analysis/proposal is preliminary, it appears to be quite focused on open-loop manipulators / robotic arms (as is URDF & MoveIt). In terms of industrial applications, we note that many commercially employed manipulators (logistics, pick & place, farming, ...) are parallel robots (e.g. delta robots), which are closed-loop manipulators. This may be due to their comparatively low cost / high speed / high accuracy.

While the existing popular toolset for manipulation around MoveIt is a great starting point for the open source community and outreach, e.g. to academic partners, the requirements of many industrial users may not be met.

Thus, the integration, simulation, and control of parallel robots should probably also be considered in the architectural design of the Manipulation-related features, especially given that the first design goal raised is the highly customizable support of a variety of robots/manipulators.

docs/design/manipulation/features.md Outdated Show resolved Hide resolved
docs/design/manipulation/analysis.md Outdated Show resolved Hide resolved
docs/design/manipulation/analysis.md Outdated Show resolved Hide resolved
docs/design/manipulation/analysis.md Outdated Show resolved Hide resolved
docs/design/manipulation/analysis.md Outdated Show resolved Hide resolved
docs/design/manipulation/features.md Outdated Show resolved Hide resolved
Comment on lines +152 to +188
## Design considerations

### Implementation in O3DE

### Use of MoveIt 2

[MoveIt 2](https://moveit.picknik.ai/humble/index.html) is the main motion
planner framework used by ROS 2. There are many ways of interacting with it. In
this design, the `ROS2ManipulationRequester` component should act as the
interface for accepting inputs in the form of request for manipulation and call
MoveIt 2 ([see the code needed to implement a Pose for the end
effector](https://moveit.picknik.ai/humble/doc/tutorials/your_first_project/your_first_project.html))
or any other motion planner.

The `ROS2ManipulationRequester` component should also take care of controlling
the status of the request and provide internal O3DE Gem information on the
status of the execution.

### Use of controllers: ros2_control and native O3DE

The integration of the [ros2_control](https://github.com/ros-controls/ros2_control) into the
architecture have some difficulties:

- controllers are typically not modular in a sense that they handle everything
(parameters, communication and computations).
- we would like to handle some of these elements separately for more
flexibility and better UX.
- some of their design is not as flexible (likely since they have been only
used with Gazebo so far).
- for example, we would like to handle parameters in the Editor, without
running publishers/subscribers already.

The benefits are important though. It is valuable to reuse implementations
which are tried and tested, and benefit from the joint effort of the community.
There should be the option of using native O3DE controllers if there is a good
reason to do so like big performance improvements or much better integration in
the UI.
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Similar to above, I am strongly in favor of migrating this section to architecture.md

Suggested change
## Design considerations
### Implementation in O3DE
### Use of MoveIt 2
[MoveIt 2](https://moveit.picknik.ai/humble/index.html) is the main motion
planner framework used by ROS 2. There are many ways of interacting with it. In
this design, the `ROS2ManipulationRequester` component should act as the
interface for accepting inputs in the form of request for manipulation and call
MoveIt 2 ([see the code needed to implement a Pose for the end
effector](https://moveit.picknik.ai/humble/doc/tutorials/your_first_project/your_first_project.html))
or any other motion planner.
The `ROS2ManipulationRequester` component should also take care of controlling
the status of the request and provide internal O3DE Gem information on the
status of the execution.
### Use of controllers: ros2_control and native O3DE
The integration of the [ros2_control](https://github.com/ros-controls/ros2_control) into the
architecture have some difficulties:
- controllers are typically not modular in a sense that they handle everything
(parameters, communication and computations).
- we would like to handle some of these elements separately for more
flexibility and better UX.
- some of their design is not as flexible (likely since they have been only
used with Gazebo so far).
- for example, we would like to handle parameters in the Editor, without
running publishers/subscribers already.
The benefits are important though. It is valuable to reuse implementations
which are tried and tested, and benefit from the joint effort of the community.
There should be the option of using native O3DE controllers if there is a good
reason to do so like big performance improvements or much better integration in
the UI.

@@ -0,0 +1 @@
(TODO)
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Looks like a duplicate of architecture.md

@@ -0,0 +1 @@
(TODO)
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Content migrated from analysis.md

Suggested change
(TODO)
## Design considerations
### Implementation in O3DE
### Use of MoveIt 2
[MoveIt 2](https://moveit.picknik.ai/humble/index.html) is the main motion
planner framework used by ROS 2. There are many ways of interacting with it. In
this design, the `ROS2ManipulationRequester` component should act as the
interface for accepting inputs in the form of request for manipulation and call
MoveIt 2 ([see the code needed to implement a Pose for the end
effector](https://moveit.picknik.ai/humble/doc/tutorials/your_first_project/your_first_project.html))
or any other motion planner.
The `ROS2ManipulationRequester` component should also take care of controlling
the status of the request and provide internal O3DE Gem information on the
status of the execution.
### Use of controllers: ros2_control and native O3DE
The integration of the [ros2_control](https://github.com/ros-controls/ros2_control) into the
architecture have some difficulties:
- controllers are typically not modular in a sense that they handle everything
(parameters, communication and computations).
- we would like to handle some of these elements separately for more
flexibility and better UX.
- some of their design is not as flexible (likely since they have been only
used with Gazebo so far).
- for example, we would like to handle parameters in the Editor, without
running publishers/subscribers already.
The benefits are important though. It is valuable to reuse implementations
which are tried and tested, and benefit from the joint effort of the community.
There should be the option of using native O3DE controllers if there is a good
reason to do so like big performance improvements or much better integration in
the UI.
## Architecture Proposal
Diagram of input/outpus and data flows using ROS 2:
![Manipulation diagram](manipulation.svg)
To implement these set of actions, the O3DE simulator should have at least:
* The capacity of publish information about the state of the joints (**RO2JointStatePub** component):
Include the needed information from O3DE simulation related to the joints of
the simulated robot in `sensor_msgs/JointState.msg` and publish it in the `/joint_states`
topic. This is required to interact with ROS 2 packages (such as MoveIt)
See [gazebo_ros_pkgs plugin for reference](https://github.com/ros-simulation/gazebo_ros_pkgs/blob/galactic/gazebo_plugins/include/gazebo_plugins/gazebo_ros_joint_state_publisher.hpp#L44-L73)
* Receive orders to move the different joints (**ROS2PoseTrajectory** component):
Set the trajectory of points to be followed by joints in the O3DE simulation using as input
`trajectory_msgs/msg/JointTrajectory.msg`
See [gazebo_ros_pkgs plugin for reference](https://github.com/ros-simulation/gazebo_ros_pkgs/blob/galactic/gazebo_plugins/include/gazebo_plugins/gazebo_ros_joint_pose_trajectory.hpp#L26-L48)
* The ability to request picks or motion movements to external manipulation planners (**ROS2ManipulationRequester**):
Request a motion plan to external planners given different types of inputs,
a target pose for end effector or a joint state target. MoveIt `move_group_interface` interaction
is an example of this.
See [MoveIt 2 joint state target goal](https://github.com/ros-planning/moveit2/blob/main/moveit_ros/planning_interface/move_group_interface/include/moveit/move_group_interface/move_group_interface.h#L305-L320)
or [MoveIt 2](https://github.com/ros-planning/moveit2/blob/main/moveit_ros/planning_interface/move_group_interface/include/moveit/move_group_interface/move_group_interface.h#L640-L554)
* Provide data from the simulated sensors: not in the scope of this document

* The design does not consider any grasping technique although external frameworks can provide this
capability.

| In the first iteration, only support for car-like 4-wheeled robots will be targeted. |
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Left-over from the previous design-document? This does not make much sense for manipulators.

Suggested change
| In the first iteration, only support for car-like 4-wheeled robots will be targeted. |

Copy link

@danielemorra98 danielemorra98 left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

These design documents are very helpful to gain a wide view on the submodules which connected together perform the manipulation task.
For quick prototyping I have lightened the manipulation.svg diagram in order to leave only the essential modules. Moreover I specified the type of controller which could be used: indeed a velocity controller allows to control the kinematics of the robotic arm and the dynamics to be forgotten, so that to highlight the early implementation stage. Any feedback on this solution are appreciated.
manipulation_design_by_morra

Comment on lines +98 to +101
manipulation pipeline. Note that the use of controllers is optional
for quick prototyping so the manipulation planning could interact
directly with the simulator without using a controller.

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

When you mention a direct interaction between simulator and planner do you allude to a method to apply directly the angular position and velocity to joints? In other words a method which bypass the dynamics, acting only on kinematics?

Copy link
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

When you mention a direct interaction between simulator and planner do you allude to a method to apply directly the angular position and velocity to joints? In other words a method which bypass the dynamics, acting only on kinematics?

Yes, I was thinking on used directly the values of position/velocity/acceleration to inject them in the simulators to quickly test things not involving the control of dynamics or not being critical for the goal of these test.

Another possibility is to mention/change that there are fake controllers available (see ros2_control Fake Components) that are probably a better approach to bypass a controller than just skip it.

Comment on lines +119 to +122
* The ability to request picks or motion movements to external manipulation planners (**ROS2ManipulationRequester**):
Request a motion plan to external planners given different types of inputs,
a target pose for end effector or a joint state target. MoveIt `move_group_interface` interaction
is an example of this.

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Why not to leave this task to an external ROS2 package? What are the benefits of having an internal interface which orchestrates the manipulation jobs?

Copy link
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Why not to leave this task to an external ROS2 package?

The diagram could not be very clear in this area, but note that I tried to represent this by "ROS interactions" coming from SMACK/BehaviourTress used as inputs for MoveIt:

image

What are the benefits of having an internal interface which orchestrates the manipulation jobs?

It opens the door to use other orchestration implementations not in ROS or the use of very simple interactions done directly from O3DE.

Copy link
Collaborator Author

@j-rivero j-rivero left a comment

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

These design docs are a great starting point for Manipulation in O3DE!
After internal discussion at Huawei, we came up with a bunch of minor editorial suggestions and a more fundamental question about the intended scope of the manipulation feature.

Really appreciated Lars. Thanks so much.

While the current architectural analysis/proposal is preliminary, it appears to be quite focused on open-loop manipulators / robotic arms (as is URDF & MoveIt).

You are right on this since I was mainly thinking on how to use it with MoveIt.

In terms of industrial applications, we note that many commercially employed manipulators (logistics, pick & place, farming, ...) are parallel robots (e.g. delta robots), which are closed-loop manipulators. This may be due to their comparatively low cost / high speed / high accuracy.

While the existing popular toolset for manipulation around MoveIt is a great starting point for the open source community and outreach, e.g. to academic partners, the requirements of many industrial users may not be met.

Thus, the integration, simulation, and control of parallel robots should probably also be considered in the architectural design of the Manipulation-related features, especially given that the first design goal raised is the highly customizable support of a variety of robots/manipulators.

Fully agree. Please feel free to submit the changes or comment on anything inside the proposal that you want in, I think that is going to be great for the design to count with people with experience on industrial and/or closed-loop manipulators.

Comment on lines +98 to +101
manipulation pipeline. Note that the use of controllers is optional
for quick prototyping so the manipulation planning could interact
directly with the simulator without using a controller.

Copy link
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

When you mention a direct interaction between simulator and planner do you allude to a method to apply directly the angular position and velocity to joints? In other words a method which bypass the dynamics, acting only on kinematics?

Yes, I was thinking on used directly the values of position/velocity/acceleration to inject them in the simulators to quickly test things not involving the control of dynamics or not being critical for the goal of these test.

Another possibility is to mention/change that there are fake controllers available (see ros2_control Fake Components) that are probably a better approach to bypass a controller than just skip it.

Comment on lines +119 to +122
* The ability to request picks or motion movements to external manipulation planners (**ROS2ManipulationRequester**):
Request a motion plan to external planners given different types of inputs,
a target pose for end effector or a joint state target. MoveIt `move_group_interface` interaction
is an example of this.
Copy link
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Why not to leave this task to an external ROS2 package?

The diagram could not be very clear in this area, but note that I tried to represent this by "ROS interactions" coming from SMACK/BehaviourTress used as inputs for MoveIt:

image

What are the benefits of having an internal interface which orchestrates the manipulation jobs?

It opens the door to use other orchestration implementations not in ROS or the use of very simple interactions done directly from O3DE.

Comment on lines +102 to +126
Diagram of input/outpus and data flows using ROS 2:

![Manipulation diagram](manipulation.svg)

To implement these set of actions, the O3DE simulator should have at least:

* The capacity of publish information about the state of the joints (**RO2JointStatePub** component):
Include the needed information from O3DE simulation related to the joints of
the simulated robot in `sensor_msgs/JointState.msg` and publish it in the `/joint_states`
topic. This is required to interact with ROS 2 packages (such as MoveIt)
See [gazebo_ros_pkgs plugin for reference](https://github.com/ros-simulation/gazebo_ros_pkgs/blob/galactic/gazebo_plugins/include/gazebo_plugins/gazebo_ros_joint_state_publisher.hpp#L44-L73)

* Receive orders to move the different joints (**ROS2PoseTrajectory** component):
Set the trajectory of points to be followed by joints in the O3DE simulation using as input
`trajectory_msgs/msg/JointTrajectory.msg`
See [gazebo_ros_pkgs plugin for reference](https://github.com/ros-simulation/gazebo_ros_pkgs/blob/galactic/gazebo_plugins/include/gazebo_plugins/gazebo_ros_joint_pose_trajectory.hpp#L26-L48)

* The ability to request picks or motion movements to external manipulation planners (**ROS2ManipulationRequester**):
Request a motion plan to external planners given different types of inputs,
a target pose for end effector or a joint state target. MoveIt `move_group_interface` interaction
is an example of this.
See [MoveIt 2 joint state target goal](https://github.com/ros-planning/moveit2/blob/main/moveit_ros/planning_interface/move_group_interface/include/moveit/move_group_interface/move_group_interface.h#L305-L320)
or [MoveIt 2](https://github.com/ros-planning/moveit2/blob/main/moveit_ros/planning_interface/move_group_interface/include/moveit/move_group_interface/move_group_interface.h#L640-L554)

* Provide data from the simulated sensors: not in the scope of this document
Copy link
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I am strongly in favor of moving this section to the architecture.md document.

I have nothing against it and can happily accept the patch. The only reason why I put it here at the begging is because I tried to follow the vehicle_dynamics docs that were the first one in the design dir.

@adamdbrw do you have any preference?

@j-rivero
Copy link
Collaborator Author

For quick prototyping I have lightened the manipulation.svg diagram in order to leave only the essential modules. Moreover I specified the type of controller which could be used: indeed a velocity controller allows to control the kinematics of the robotic arm and the dynamics to be forgotten, so that to highlight the early implementation stage. Any feedback on this solution are appreciated.

Thanks @danielemorra98. I like the simplification and as an easy use case to implement the system and check if the design is working in the very basic looks like a great approach to me. Let me comment it internally with the team and back here if someone sees something to be fixed or to complete it.

How do you prefer to integrate it in this document? Adding to the current diagram as a variant of it or do you prefer to replace the original in this PR?

@lgleim
Copy link
Contributor

lgleim commented Nov 16, 2022

How do you prefer to integrate it in this document? Adding to the current diagram as a variant of it or do you prefer to replace the original in this PR?

@j-rivero We were discussing that it could make sense to create an implementation roadmap section as part of the proposal. As @danielemorra98 suggested, this reduced design could be a good first implementation milestone. After a review, the next implementation milestone would then be defined, e.g. based on your original architecture proposal. Looking forward to your / your team's feedback!

@j-rivero
Copy link
Collaborator Author

I like the simplification and as an easy use case to implement the system and check if the design is working in the very basic looks like a great approach to me. Let me comment it internally with the team and back here if someone sees something to be fixed or to complete it.

Team agree that the simplification looks valid to our eyes. Good work.

While the existing popular toolset for manipulation around MoveIt is a great starting point for the open source community and outreach, e.g. to academic partners, the requirements of many industrial users may not be met.

While I don't disagree that in some cases many industrial use cases requirements are hard to implement with the current infrastructure we have people at Open Robotics successfully using it for industrial projects. Did you have any bad experience with respect to the use of it in your use cases?

we were discussing that it could make sense to create an implementation roadmap section as part of the proposal.

Sounds good to me. Could you please send a PR against this one or a patch that I can apply? Thanks so much.

@j-rivero
Copy link
Collaborator Author

j-rivero commented Nov 22, 2022

As a request from @michalpelka, I've tried to document a whole integration between Gazebo + ros2_control + MoveIt. With this in hand, and regarding the controller side of things: maybe the long-term option is try to implement a GEM that replaces gazebo_ros2_control. This pkg implements a generic hardware_interface that is used by ros2 controllers like joint_trajectory_controller to know a) what the current joint values are and b) command joints to certain values. The ros2_control architecture which separates the controller and the hardware_interface allows for this nicely.

@adamdbrw
Copy link
Member

@j-rivero @lgleim anything I can assist with to move this PR forward?

@j-rivero
Copy link
Collaborator Author

@j-rivero @lgleim anything I can assist with to move this PR forward?

Would be great to have the suggestions done by @lgleim and @danielemorra98 to the document, I can take care if they don't have time but would probably be more accurate if a PR is sent against this.

As a request from @michalpelka, I've tried to document a whole integration between Gazebo + ros2_control + MoveIt. With this in hand, and regarding the controller side of things: maybe the long-term option is try to implement a GEM that replaces gz_ros2_control. This pkg implements a generic hardware_interface that is used by ros2 controllers like joint_trajectory_controller to know a) what the current joint values are and b) command joints to certain values.

With the Gazebo example in hand, we probably want to add the integration with ros2_control to the document in some degree. I think that @michalpelka was interested into providing feedback for this.

Signed-off-by: Mabel Zhang <[email protected]>
@j-rivero
Copy link
Collaborator Author

j-rivero commented Dec 9, 2022

Would be great to have the suggestions done by @lgleim and @danielemorra98 to the document, I can take care if they don't have time but would probably be more accurate if a PR is sent against this.

We submitted a PR for incorporating the feedback in #358. I'll wait until Dec 14th for merging it, @lgleim and @danielemorra98 just in case that you have time to give it a look.

@j-rivero j-rivero marked this pull request as ready for review December 16, 2022 17:38
@j-rivero
Copy link
Collaborator Author

We submitted a PR for incorporating the feedback in #358. I'll wait until Dec 14th for merging it,

Already merged.

@j-rivero
Copy link
Collaborator Author

j-rivero commented Jan 9, 2023

We submitted a PR for incorporating the feedback in #358. I'll wait until Dec 14th for merging it, @lgleim and @danielemorra98 just in case that you have time to give it a look.

A bit late but don't want to leave this unfinished. @adamdbrw could you please merge it?

@danielemorra98
Copy link

I have just a couple of question about the current status.

  • Looking at Switch vehicle dynamics to PhysX joint and Adding actuation to PhysX joints, it seems that they are switching to a dynamics model which suits better robotics applications. This demo uses the standard method to move joints (apply an angular/linear impulse to the rigid body). Are you planning to switch the current MotorizedJoint to an actuated joint?
  • Are you working on a solution similar to the one used for the krakenDemo that also works with revolute joints? I think that it would be great to have another general controller for manipulation purposes to be chosen from the Ros2RobotControl component (as it happens with Twist or Ackermann labels)

Maybe this is not the right place to comment on this and if that I apologize.

@michalpelka
Copy link
Collaborator

michalpelka commented Jan 11, 2023

Thanks, @danielemorra98 for the questions. Let me update you.
The latest changes to the O3DE PhysX gem developed were intended for manipulation.
This method of actuation is stable and easy to use, Motorized joint was a temporary solution that used available API.
We are switching the existing codebase to use PhysX actuation.
I also tested PhysX actuation against the manipulation task and performs well: https://github.com/RobotecAI/o3de-physics-test-scene. It is stable in application with PID controller and position control.
Actuation PhysX allows us at this moment :

  • apply velocity speed
  • limit force / torque
  • it works with Hinge and Prismatic joints.

@danielemorra98
Copy link

danielemorra98 commented Jan 17, 2023

I would like to develop the bridge to connect the Gem to MoveIt with the latest PhysX API update (new Joint method) and the robotic arm found in o3de-physics-test-scene project.
I found out that the requirements for a MoveIt interconnection are the following:

  • /joint_states topic: notifies MoveIt with the current joints status
  • tf: MoveIt monitors transform information (using ROS tf library) for internal use
  • Controller interface: MoveIt talks to controllers using FollowJointTrajectoryAction ROS interface. Need to implement a ROS service to server this action.
  • Sensor information: MoveIt represents the world building an occupancy map from PointClouds or DepthImages

Remarks:

  • The first two points should be easy to implement or already there (tf).
  • The last point is not necessary for first tests
  • The core part is the Controller interface: develop a server to take into account a FollowJointTrajectoryAction is not straightforward (take inspiration from the ros2_controller implementation)
    • The server will have to implement whatever implementation scheme is needed for the robot to move "smoothly" (or whatever criteria you want to use). For example that could mean interpolation between the points making up the trajectory.

What are your comments and/or suggestion on this?

@j-rivero
Copy link
Collaborator Author

What are your comments and/or suggestion on this?

Thanks for the comments Daniele. I read briefly your comments and did not find any big conceptual error. I'm afraid that I've been moved to different projects and don't have time to follow up on this one, sorry. I'm pretty sure that @michalpelka or @adamdbrw can help you more on this.

@adamdbrw
Copy link
Member

Could we move this to o3de-extras repos and merge in there?

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
documentation Improvements or additions to documentation
Projects
None yet
Development

Successfully merging this pull request may close these issues.

Design of manipulation feature
6 participants