DockServo action not working, while Undock works

[framlin]

Hello,
I have looked at the examples on https://edu.irobot.com/learning-library/intro-to-ros-2-writing-action-clients and try to add docking and undocking to it.
Undocking works fine, but docking does nothing.

Before I post my sourcecode in full length, I want to ask, if there are major differences between a dock- and an undock-service-client.
Is there anything, I havt to have in mind, if I want to implement a dock-client vs an undock-client?

[shamlian]

To be sure -- are you running the same version of ROS 2 on both your robot and your host machine? The docking API changed between Galactic and Humble.

[framlin]

Yes, I do, at least I think so.
How can I double check this?

and ....
ros2 action send_goal /dock irobot_create_msgs/action/DockServo "{}"
works fine on my host-machine

[shamlian]

If that works, then I'm sure they match, but fwiw you can printenv ROS_DISTRO on the host to get the ROS distribution, and you can check the first character of the robot's version number to get its distro (G = galactic, H = humble).

[framlin]

printenv ROS_DISTRO results in galactic
Robot Version is VERSION: G.3.1

[framlin]

Here is my source-code:

import rclpy
from rclpy.action import ActionClient
from rclpy.node import Node

from irobot_create_msgs.action import DockServo


class DockActionClient(Node):

    def __init__(self):
        super().__init__('dock_action_client')
        self.dock = ActionClient(self, DockServo, '/dock')

    def send_goal(self):
        goal_msg = DockServo.Goal()
        self.dock.wait_for_server()

        self._dock_future = self.dock.send_goal_async(goal_msg)
        self._dock_future.add_done_callback(self.dock_response_callback)

    def dock_response_callback(self, future):
        goal_handle = future.result()
        if not goal_handle.accepted:
            self.get_logger().info('Goal rejected')
            return

        self.get_logger().info('Goal accepted')

        self._result_future = goal_handle.get_result_async()
        self._result_future.add_done_callback(self.undock_result_callback)

    def undock_result_callback(self, future):
        result = future.result().result
        self.get_logger().info('Result: {0}'.format(result))


def main(args=None):
    rclpy.init(args=args)

    dock_action_client = DockActionClient()
    dock_action_client.send_goal()

    rclpy.spin(dock_action_client)

    dock_action_client.destroy_node()
    rclpy.shutdown()


if __name__ == '__main__':
    main()

[framlin]

Ok, I found my mistake.
One must NOT clone the main-branch of irobot_create_msgs. One must checkout the version of the robot and the host-syste, which is in my case galactic.

BUT ... it is a pitfall, to provide a main-thread, that is not compatible with the last stable version, which is galactic .....

[shamlian]

Out of curiosity, why aren't you just using the package manager to install irobot_create_msgs? The proper one will come down with your ROS 2 install.

[framlin]

Because I do not know that I have to do it and how I have to do it. This is my first week with ROS/ROS2 ;-)
I read in the source-code, that I have to import from irobot_create_msgs, so I looked, where I can find them and pulled it from github ...
What is the correct way to do this?

[shamlian]

That's fair! I appreciate the questions and the criticism. it helps us to make our documentation better.

I think the "right way" to do this is to make a package, following an example like this one, which uses a package.xml to pull dependencies. But I've asked another person on the team to validate this answer -- I likewise have a lot to learn, and there may be something else I don't know!

[alsora]

Hi @framlin, as @shamlian mentioned above, it is always recommended to define ROS 2 packages (C++ or Python) using an appropriate structure, which includes the creation of a package.xml file listing the depdencies.
You can find details about ROS 2 packages here https://docs.ros.org/en/rolling/Tutorials/Beginner-Client-Libraries/Creating-Your-First-ROS2-Package.html

Then, there are essentially 3 ways to handle ROS dependencies.

1. Clone the source code in your workspace and build it with colcon build together with your other ROS packages. If you do this, you will need to make sure that you clone the right version of the repositories. It's common practice for ROS 2 repositories that the main (or default) branch targets the latest development version of ROS 2 while released versions are in their dedicated branches. Indeed many projects rename their default branch to rolling which is the name for the ROS 2 "rolling" distribution.
   Note that if you have multiple packages in the same ROS workspace, colcon will look at the package.xml files to define the order in which to build them.
2. Manually install dependencies, for example using sudo apt-get update && sudo apt-get install ros-galactic-irobot-create-msgs.
3. Use rosdep tool. This is an OS-agnostic tool that reads the package.xml file and calls install commands (such as the one in point 2 above) for all the packages defined there. To use that, from the root of your ROS 2 workspace rosdep install --from-path src --ignore-src -yi

[framlin]

Thank you very very much for your help!