The robot doesn’t move

[yuutayuuta50]

Here are two things I am currently able to do:

1. Start the micro-ROS agent and obtain the joint angles of the GP4 via ros2 topic echo /joint_states.

2. Operate the GP4 in simulation using the configuration files created with the Setup Assistant.

I don't know how to connect it with the actual robot, so if you have any reference materials, configuration files, or source code, I would appreciate it if you could share them.

[ted-miller]

Hi @yuutayuuta50
It's good to hear that the robot is successfully communicating/publishing. Unfortunately, we are not able to provide support for MoveIt2 usage in this repository.

I suggest reviewing this guide, which was created by Yaskawa Europe.
https://github.com/YaskawaEurope/ros2-starter-for-yaskawa-robots/tree/main

It steps you through the process of configuring everything and includes sample source code for basic motion.

[yuutayuuta50]

Thank you for the guidance! I’ll go through the Yaskawa Europe guide and try to configure everything accordingly.

[yuutayuuta50]

I was able to display the actual robot's joint angles in RViz using the following: https://github.com/YaskawaEurope/ros2-starter-for-yaskawa-robots/tree/main

However, the robot does not move. Is there a way to operate the robot using motoros2 alone to test whether the installation was successful? Or can we consider the installation successful if the joint states are displayed?

[ted-miller]

Since you're seeing the joints, you should be in good shape.

But if you want to verify that the robot is "motion ready", then the easiest way is to use the command line interface and manually invoke the start_traj_mode service. If it is successful, then servo power will be enabled and the robot_status topic will indicate motion_possible = TRUE.

First, build the motoros2_client_interface_dependencies workspace. Then source this environment with source install/local_setup.bash

ros2 service call /start_traj_mode motoros2_interfaces/srv/StartTrajMode
then
ros2 topic echo /robot_status

[yuutayuuta50]

I executed the following command, and the robot is now in the servo-on state:

ros2 service call /yaskawa/start_traj_mode motoros2_interfaces/srv/StartTrajMode

After running ros2 topic echo /yaskawa/robot_status, the following result was displayed:

header:
  stamp:
    sec: 1728613108
    nanosec: 204026093
  frame_id: ''
mode:
  val: 2
e_stopped:
  val: 0
drives_powered:
  val: 1
motion_possible:
  val: 1
in_motion:
  val: 0
in_error:
  val: 0
error_codes: []

[yuutayuuta50]

[yuutayuuta50]

I’m not confident about how to properly launch the controllers when using the actual robot. I would appreciate it if you could take a look at the key files, which I’ve attached. I’ll also include the controller section in this message.

I have confirmed that the robot works fine in the simulation, and when I run "ros2 control list_controllers", the controllers are listed. However, when using the actual hardware, no controllers appear.

files.zip

【.py.launch】

    moveit_config = (
        MoveItConfigsBuilder("moveit_resources_moto")
        .robot_description(file_path="config/moto.urdf.xacro")
        .robot_description_semantic(file_path="config/moto.srdf")
        .trajectory_execution(file_path="config/moveit_controllers.yaml")
        .to_moveit_configs()
    )
     planning_scene_monitor_parameters = {
        "publish_planning_scene": True,
        "publish_geometry_updates": True,
        "publish_state_updates": True,
        "publish_transforms_updates": True,
        "publish_robot_description": True,
        "publish_robot_description_semantic": True,
    }
    # Start the actual move_group node/action server
    # robot
    run_move_group_nodeX = Node(
        package="moveit_ros_move_group",
        executable="move_group",
        output="screen",
        parameters=[
            moveit_config.to_dict(),
            planning_scene_monitor_parameters,
        ],
    )
    # ↓don't use
    # Start the actual move_group node/action server
    # simulation
    run_move_group_node = Node(
        package="moveit_ros_move_group",
        executable="move_group",
        output="screen",
        parameters=[
            moveit_config.to_dict(),
            planning_scene_monitor_parameters,
        ],
        remappings=[('joint_states', '/moto_controller/joint_states'),
                    ('joint_states', '/yaskawa/joint_states')]
    )
    return LaunchDescription(
        [
            run_move_group_nodeX,
            joint_state_publisherX,
            robot_state_publisherX,
            rviz_node,
            #run_move_group_node, ### _1 #don't use
            #ros2_control_node, #don't use
        ]
    )

【moveit_controllers.yaml】

trajectory_execution:
  allowed_execution_duration_scaling: 1.2
  allowed_goal_duration_margin: 0.5
  allowed_start_tolerance: 0.01
  trajectory_duration_monitoring: true
  
moveit_controller_manager: moveit_simple_controller_manager/MoveItSimpleControllerManager

moveit_simple_controller_manager:
  controller_names:
    - /yaskawa

  /yaskawa:
    type: FollowJointTrajectory
    action_ns: follow_joint_trajectory
    default: true
    joints:
      - joint_1_s
      - joint_2_l
      - joint_3_u
      - joint_4_r
      - joint_5_b
      - joint_6_t

【ros2_controllers.yaml】

#This config file is used by ros2_control
controller_manager:
  ros__parameters:
    update_rate: 100  # Hz
    yaskawa:
      type: joint_trajectory_controller/JointTrajectoryController
    joint_state_broadcaster:
      type: joint_state_broadcaster/JointStateBroadcaster
yaskawa:
  ros__parameters:
    joints:
      - joint_1_s
      - joint_2_l
      - joint_3_u
      - joint_4_r
      - joint_5_b
      - joint_6_t
    command_interfaces:
      - position
    state_interfaces:
      - position
      - velocity

[lkaising]

Looking over your motoros2_config.yaml, was there any particular reason you set the node_namespace to yaskawa? In my current setup (I have the GP4 arm working with MoveIt), I left the node_namespace at its default value.

In your ros2_controllers.yaml, instead of using yaskawa, I used follow_joint_trajectory, which looks like this:

# This config file is used by ros2_control
controller_manager:
  ros__parameters:
    update_rate: 100  # Hz

    follow_joint_trajectory:
      type: joint_trajectory_controller/JointTrajectoryController

follow_joint_trajectory:
  ros__parameters:
    joints:
      - joint_1
      - joint_2
      - joint_3
      - joint_4
      - joint_5
      - joint_6

    command_interfaces:
      - position
      - velocity

    state_interfaces:
      - position
      - velocity

    action_monitor_rate: 20.0
    allow_partial_joints_goal: false

This change would require you to update your MoveIt controller from yaskawa to follow_joint_trajectory. I also noticed that in your moveit_controllers.yaml file, you used /yaskawa instead of yaskawa. Was there a specific reason for this? It might be causing a mismatch between your ROS controllers and MoveIt controllers.

Additionally, in my implementation of moveit_controllers.yaml, I found that setting action_ns to an empty string "" rather than follow_joint_trajectory allowed the actual robot to move. The trade-off is that setting action_ns to "" causes the RViz simulated planners to fail, but the robot does move. I accepted this compromise because I intended to interact with the robot using MoveIt directly (e.g., MoveGroup interface or MoveIt Task Constructor) rather than through RViz. Here's my implementation of moveit_controllers.yaml:

# MoveIt uses this configuration for controller management
trajectory_execution:
  allowed_execution_duration_scaling: 10.0
  allowed_goal_duration_margin: 10.0
  allowed_start_tolerance: 0.1
  trajectory_duration_monitoring: false

moveit_controller_manager: moveit_simple_controller_manager/MoveItSimpleControllerManager

moveit_simple_controller_manager:
  controller_names:
    - follow_joint_trajectory

  follow_joint_trajectory:
    type: FollowJointTrajectory
    action_ns: ""
    default: true
    joints:
      - joint_1
      - joint_2
      - joint_3
      - joint_4
      - joint_5
      - joint_6

Also, I looked over your launch file xy_start.launch.py, and it seems you're handling the loading of controllers differently than I did. Here's how I did it, and I haven't had any issues:

# Load controllers
load_controllers = []
for controller in [
    "follow_joint_trajectory",
]:
    load_controllers += [
        ExecuteProcess(
            cmd=["ros2 run controller_manager spawner {}".format(controller)],
            shell=True,
            output="screen",
        )
    ]

# Other nodes

return LaunchDescription(
    [
        rviz_node,
        static_tf,
        robot_state_publisher,
        run_move_group_node,
        ros2_control_node,
        run_core_application_node,
    ]
    + load_controllers
)

By explicitly spawning the follow_joint_trajectory controller in the launch file, you ensure that it's properly loaded and active when you start your application. This might help resolve the issue of the robot not moving.

Suggestions:

1. Consider leaving node_namespace at its default value in motoros2_config.yaml.
2. Change yaskawa to follow_joint_trajectory in both ros2_controllers.yaml and moveit_controllers.yaml to prevent potential mismatches.
3. Set action_ns to an empty string "" in moveit_controllers.yaml if you intend to interact with the robot directly rather than through RViz.
4. Modify your launch file to explicitly load the controllers, ensuring they are active when your application starts.

I hope these suggestions help you get your robot moving!

[yuutayuuta50]

Thank you very much for reviewing my files and providing such detailed explanations. I really appreciate your insights and will try your suggestions right away.

I have one additional question: Could you provide guidance on the proper way to launch the ros2_control_node? Currently, I’m using the following launch file along with a xacro file containing moto.ros2_control.xacro. While this setup works well for simulation, I’m unsure if it’s correct for the real robot.

【.launch.py】：

#ros2_control using FakeSystem as hardware
ros2_controllers_path = os.path.join(
    get_package_share_directory("moveit_resources_moto_moveit_config"),
    "config",
    "ros2_controllers.yaml",
)
ros2_control_node = Node(
    package="controller_manager",
    executable="ros2_control_node",
    parameters=[moveit_config.robot_description, ros2_controllers_path],
    output="both",
)

【.urdf.xacro】：

<xacro:include filename="moto.ros2_control.xacro" />
<xacro:moto_ros2_control name="motoFakeSystem" initial_positions_file="$(arg initial_positions_file)"/>

[lkaising]

From what I see in your code snippet, it looks mostly correct, but there might be a small issue with how the .ros2_control.xacro file is being referenced. It’s a good idea to specify the full package name where your .ros2_control.xacro file is located to avoid any path issues. You can do this by prefixing the file name with something like:

<xacro:include filename="$(find YOUR_ROBOT_MOVEIT_CONFIG)/config/YOUR_ROBOT.ros2_control.xacro" />

Here’s a general template you can use as a guideline to ensure everything is linked properly:

<?xml version="1.0"?>
<robot xmlns:xacro="http://ros.org/wiki/xacro" name="YOUR_ROBOT_NAME">
  <xacro:arg name="initial_positions_file" default="$(find YOUR_ROBOT_MOVEIT_CONFIG)/config/initial_positions.yaml" />

  <!-- Include necessary Xacro files -->
  <xacro:include filename="$(find YOUR_ROBOT_DESCRIPTION)/urdf/YOUR_ROBOT.urdf.xacro" />
  <xacro:include filename="$(find YOUR_ROBOT_MOVEIT_CONFIG)/config/YOUR_ROBOT.ros2_control.xacro" />

  <!-- Instantiate the ROS 2 control macro -->
  <xacro:YOUR_ROBOT_ROS2_CONTROL
    name="FakeSystem"
    initial_positions_file="$(arg initial_positions_file)" />
</robot>

Hope this helps!

One small note: Consider using Markdown for code snippets in discussion posts, it improves formatting and readability, just in case you weren't aware.

[yuutayuuta50]

After applying the corrections as you suggested, it seems that the controller is up and running, but the robot is not moving. The attached files are my final configuration settings. Would it be possible for you to share a complete set of files (especially ros_control.xacro, urdf.xacro, motoros2_config.yaml and launch.py) that allows the robot to move in RViz?

files.zip

[yuutayuuta50]

I've tried various approaches, and it seems that setting action_ns to "" causes issues when launching the controller. When I set action_ns to follow_joint_trajectory, the robot does not move, but the process completes without any errors.

Is it possible to use the Plan and Execute buttons in RViz's motion planning to move the actual robot?

[gavanderhoorn]

Just to clarify: ros2_control is not used by MotoROS2, nor supported. There is no MoveIt configuration using ros2_control which can communicate with MotoROS2.

All the files the MoveIt Setup Assistant generated for use with ros2_control can be ignored (I would even go so far as to remove them).

What is needed is to configure MoveIt with a FollowJointTrajectoryAction client. That's the moveit_simple_controller_manager/MoveItSimpleControllerManager configuration @lkaising shows in the second codeblock in #318 (reply in thread) does.

[yuutayuuta50]

Thank you for your response.

I still cannot get the robot to move. Based on the URL below and your advice, I have set up the moveit_controllers.yaml and launched the MoveGroup node. However, instead of using RViz, I used hello_moveit.cpp, where the planning succeeds, but it stops at the message 'sending trajectory to follow_joint_trajectory' when executing "move_group_interface.asyncExecute(plan);"

https://github.com/YaskawaEurope/ros2-starter-for-yaskawa-robots/tree/main

If a controller is necessary, is there a way to create one without using ros2_control? I haven't been able to find any information on how to do this anywhere. Alternatively, if the current setup should be sufficient, could it be that there is an issue with my yrc10000? Incidentally, when I use ROS (not ROS2), my yrc1000 works and I can move the robot.

moveit_controllers.yaml

trajectory_execution:
  allowed_execution_duration_scaling: 1.2
  allowed_goal_duration_margin: 0.5
  allowed_start_tolerance: 0.01
  trajectory_duration_monitoring: true


moveit_controller_manager: moveit_simple_controller_manager/MoveItSimpleControllerManager

moveit_simple_controller_manager:
  controller_names:
    - follow_joint_trajectory

  follow_joint_trajectory:
    type: FollowJointTrajectory
    action_ns: ""
    default: true
    joints:
      - joint_1
      - joint_2
      - joint_3
      - joint_4
      - joint_5
      - joint_6
    action_ns: ""
    default: true

launch.py

def generate_launch_description():
    motoman_directory = "robo"
    ns = ""
    # URDF
    motoman_robot_description_config = xacro.process_file(
        os.path.join(
            get_package_share_directory(motoman_directory),
            "config",
            "motoman_gp4.urdf.xacro",
        ),
        # mappings={'prefix': '/yaskawa_a1/'},
    )
    motoman_robot_description = {
        "robot_description": motoman_robot_description_config.toxml()
    }
    moveit_config = (
        MoveItConfigsBuilder("motoman_gp4", package_name="robo")
        .robot_description(file_path="config/motoman_gp4.urdf.xacro")
        .robot_description_semantic(file_path="config/motoman_gp4.srdf")
        .trajectory_execution(file_path="config/moveit_controllers.yaml")
        .to_moveit_configs()
    )
    planning_scene_monitor_parameters = {
        "publish_planning_scene": True,
        "publish_geometry_updates": True,
        "publish_state_updates": True,
        "publish_transforms_updates": True,
        "publish_robot_description": True,
        "publish_robot_description_semantic": True,
    }
    #logger.info(moveit_config.to_dict())
    # Start the actual move_group node/action server
    # simulation
    run_move_group_nodeX = Node(
        package="moveit_ros_move_group",
        executable="move_group",
        output="screen",
        namespace=ns,
        parameters=[
            moveit_config.to_dict(),
            planning_scene_monitor_parameters,
            # {"use_sim_time": True},
        ],
        # remappings=[('/moto_controller/joint_states', '/yaskawa/joint_states')]
        #remappings=[('joint_states', '/follow_joint_trajectory/joint_states')]
    )
    # RViz
    rviz_base = os.path.join(
        get_package_share_directory(
            "robo"), "launch"
    )
    rviz_full_config = os.path.join(rviz_base, "moveit.rviz")
    rviz_node = Node(
        package="rviz2",
        executable="rviz2",
        name="rviz2",
        output="log",
        arguments=["-d", rviz_full_config],
        parameters=[
            moveit_config.robot_description,
            moveit_config.robot_description_semantic,
            moveit_config.planning_pipelines,
            moveit_config.robot_description_kinematics,
            # {"use_sim_time": True},
        ],
    )
    # Publish TF
    robot_state_publisher = Node(
        package="robot_state_publisher",
        executable="robot_state_publisher",
        name="robot_state_publisher",
        output="both",
        namespace=ns,
        parameters=[moveit_config.robot_description],
        #remappings=[('joint_states', '/joint_state_broadcaster/joint_states')]
    )
    # ros2_control using FakeSystem as hardware
    ros2_controllers_path = os.path.join(
        get_package_share_directory("robo"),
        "config",
        "ros2_controllers.yaml",
    )
    ros2_control_node = Node(
        namespace=ns,
        package="controller_manager",
        executable="ros2_control_node",
        parameters=[moveit_config.robot_description, ros2_controllers_path],
        output="both",
    )
    joint_state_publisherX = Node(
        package='joint_state_publisher',
        executable='joint_state_publisher',
        name='joint_state_publisher',
        namespace=ns,
        parameters=[
            {
                "robot_description": motoman_robot_description,
                "rate": 43,
                "source_list": ['/joint_states'],
            }
        ],
    )
    robot_state_publisherX = Node(
        package="robot_state_publisher",
        executable="robot_state_publisher",
        name="robot_state_publisher",
        output="both",
        namespace=ns,
        parameters=[moveit_config.robot_description]
    )
    moto_controller_spawner = Node(
        package="controller_manager",
        executable="spawner",
        namespace=ns,
        arguments=[
            "follow_joint_trajectory",
            "--controller-manager",
            "/controller_manager",
        ],
    )
    return LaunchDescription(
        [
            # db_arg,
            # static_tf,
            # mongodb_server_node,
            run_move_group_nodeX,
            joint_state_publisherX,
            robot_state_publisherX,
            #robot_state_publisher,
            rviz_node,
            #run_move_group_node, ### _1
            #ros2_control_node,
            #joint_state_broadcaster_spawner,
            #moto_controller_spawner,
        ]
        # + load_controllers
    )

hello_moveit.cpp

#include <memory>

#include "motoros2_interfaces/srv/start_traj_mode.hpp"
#include "std_srvs/srv/trigger.hpp"

#include <rclcpp/rclcpp.hpp>
#include <moveit/move_group_interface/move_group_interface.h>

#include <rclcpp/rclcpp.hpp>
#include <moveit/moveit_cpp/moveit_cpp.h>
#include <moveit/moveit_cpp/planning_component.h>

#include <chrono>
#include <thread>

int main(int argc, char *argv[])
{
  //-----------------------------------------------------
  rclcpp::init(argc, argv);

  //-------------------controller enable-----------------------------
  auto drive = rclcpp::Node::make_shared("enable_client");

  auto enable_client = drive->create_client<motoros2_interfaces::srv::StartTrajMode>("/start_traj_mode");

  // Create a request message to send
  auto request = std::make_shared<motoros2_interfaces::srv::StartTrajMode::Request>();

  // Send the request asynchronously
  auto future = enable_client->async_send_request(request);

  std::this_thread::sleep_for(std::chrono::seconds(5));

  //-----------------------------------------------------

  auto const node = std::make_shared<rclcpp::Node>(
      "hello_moveit", rclcpp::NodeOptions().automatically_declare_parameters_from_overrides(true));

  // Create a ROS logger
  auto const logger = rclcpp::get_logger("hello_moveit");

  // Create the MoveIt MoveGroup Interface
  using moveit::planning_interface::MoveGroupInterface;
  auto move_group_interface = MoveGroupInterface(node, "flange");

  // Set a target Pose
  auto const target_pose = []
  {
    geometry_msgs::msg::Pose msg;
    msg.orientation.x = 0.0;
    msg.orientation.y = 0.0;
    msg.orientation.z = 0.0;
    msg.orientation.w = 1.0;
    msg.position.x = 0.44;  // 0.44;
    msg.position.y = 0.0;  // 0.1;
    msg.position.z = 0.60; // 0.73;
    return msg;
  }();
  move_group_interface.setPoseTarget(target_pose);

  // Create a plan to that target pose
  auto const [success, plan] = [&move_group_interface]
  {
    moveit::planning_interface::MoveGroupInterface::Plan msg;
    auto const ok = static_cast<bool>(move_group_interface.plan(msg));
    return std::make_pair(ok, msg);
  }();

  std::this_thread::sleep_for(std::chrono::seconds(5));
  // Execute the plan
  if (success)
  {
    RCLCPP_INFO(logger, "Planning OK!");
    // move_group_interface.execute(plan);
    move_group_interface.asyncExecute(plan);
    std::this_thread::sleep_for(std::chrono::seconds(10));
    RCLCPP_INFO(logger, "end of waiting");
  }
  else
  {
    RCLCPP_ERROR(logger, "Planning failed!");
  }

  rclcpp::shutdown();
  return 0;
}

[yuutayuuta50]

I have additional information. When I ran gp8_node.py, the message "Connected to trajectory action server" was displayed, but the robot did not move and remained stopped. I can't help but feel that it might not be an issue with the ROS configuration, but rather that the mr2_yrc1_h.out file is unable to control the robot's joints.

gp8_node.py

#!/usr/bin/env python

import rclpy
import math
import time
import sys
from os import times
from functools import partial
from rclpy.action import ActionClient
from rclpy.node import Node
from rclpy.qos import QoSProfile
from rclpy.qos import QoSReliabilityPolicy
from rclpy.duration import Duration
from control_msgs.action import FollowJointTrajectory
from sensor_msgs.msg import JointState
from trajectory_msgs.msg import JointTrajectory, JointTrajectoryPoint
from motoros2_interfaces.srv import StartTrajMode


class SimpleTrajectoryActionClient(Node):

    def __init__(self):
        super().__init__('simple_trajectory_action_client')
      
        self.name = []
        self.position = []
        self.velocity = []
        self.effort = []
        profile = QoSProfile(depth=1)
        profile.reliability = QoSReliabilityPolicy.BEST_EFFORT

        self.action_client = ActionClient(
            self, FollowJointTrajectory, 'follow_joint_trajectory')

        self.subscription = self.create_subscription(
            JointState, 'joint_states', self.listener_callback, profile)

        self.call_start_traj_mode_service()

    def listener_callback(self, msg: JointState):

        self.name = msg.name
        self.position = msg.position
        self.velocity = msg.velocity
        self.effort = msg.effort

    def call_start_traj_mode_service(self):
        client = self.create_client(StartTrajMode, "/start_traj_mode")
        while not client.wait_for_service(1.0):
            self.get_logger().warn("waiting fot service")

        request = StartTrajMode.Request()

        future = client.call_async(request)
        future.add_done_callback(partial(self.callback_set_start_traj_mode))

    def callback_set_start_traj_mode(self, future):
        try:
            response = future.result()
        except Exception as e:
            self.get_logger().error(" service call failed; %r" % (e,))

    def return_joint_state(self):
        
        q = []
        
        for joint in self.name:
            index = self.name.index(joint)
            position = self.position[index]
            velocity = self.velocity[index]
            effort = self.effort[index]
            q.append(position)
            print("axis:", index + 1, "position [deg]", position)

        return q

    def send_goal(self):

        # self.return_joint_state()
        goal = FollowJointTrajectory.Goal()
        goal.trajectory = JointTrajectory()

        goal.goal_time_tolerance = Duration(seconds=0.0).to_msg()

        goal.trajectory.joint_names = [
            'joint_1',
            'joint_2',
            'joint_3',
            'joint_4',
            'joint_5',
            'joint_6'
        ]

        q0 = [0.0028, 0.5277, 0.7422, 0.0, -1.8543, 0.0]
        q1 = list(q0)
        q2 = list(q0)
        q3 = list(q0)

        q1[5] -= math.radians(20)
        q1[0] -= math.radians(10)

        q2[0] += math.radians(20)
        q2[1] += math.radians(10)
        q2[2] += math.radians(10)

        q3[0] -= math.radians(10)
        q3[1] -= math.radians(10)
        q3[2] -= math.radians(10)

        # Make the robot come to a complete stop at each trajectory point (ie:
        # zero target velocity).
        qdot = [0.0] * len(goal.trajectory.joint_names)

        goal.trajectory.header.stamp = self.get_clock().now().to_msg()
       # print("-----------------")
        #print(self.get_clock().now().to_msg())

        # add points
        goal.trajectory.points.append(
            JointTrajectoryPoint(
                positions=q0,
                velocities=qdot,
                accelerations=qdot, effort=qdot,
                time_from_start=Duration(seconds=0.0).to_msg()
            )
        )

        goal.trajectory.points.append(
            JointTrajectoryPoint(
                positions=q1,
                velocities=qdot,
                accelerations=qdot, effort=qdot,
                time_from_start=Duration(seconds=5.0).to_msg()
            )
        )

        goal.trajectory.points.append(
            JointTrajectoryPoint(
                positions=q2,
                velocities=qdot,
                accelerations=qdot, effort=qdot,
                time_from_start=Duration(seconds=10.0).to_msg()
            )
        )

        goal.trajectory.points.append(
            JointTrajectoryPoint(
                positions=q3,
                velocities=qdot,
                accelerations=qdot, effort=qdot,
                time_from_start=Duration(seconds=15.0).to_msg()
            )
        )

        self.get_logger().info('Waiting for driver\'s action server to become available ..')
        self.action_client.wait_for_server()
        self.get_logger().info('Connected to trajectory action server')
        self.send_goal_future = self.action_client.send_goal_async(
            goal, feedback_callback=self.feedback_callback)
        self.send_goal_future.add_done_callback(self.goal_response_callback)

    def goal_response_callback(self, future):
        self.get_logger().info('Response callback...')
        goal_handle = future.result()

        if not goal_handle.accepted:
            self.get_logger().info('Goal rejected')
            return

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

        self.get_result_future = goal_handle.get_result_async()
        self.get_result_future.add_done_callback(self.get_result_callback)

    def get_result_callback(self, future):
        self.get_logger().info('Results callback...')
        self.return_joint_state()
        result = future.result().result
        self.get_logger().info('Result: '+str(result))

    def feedback_callback(self, feedback_msg):
       # self.get_logger().info('moving robot!')
        feedback = feedback_msg.feedback


def main(args=None):
    rclpy.init(args=args)
    action_client = SimpleTrajectoryActionClient()
    action_client.return_joint_state()
    action_client.send_goal()
    rclpy.spin(action_client)


if __name__ == '__main__':
    main()

[yuutayuuta50]

Judging by the behavior of gp8_node.py, it seems that there is no feedback coming from the action server. I suspect there may be an issue with the action server. Do you have any information regarding this? Here is the information about my YRC1000.

system : YAS4.71.00A(JP)-00
parameter:4.19
model : 1-06VX4-AO*(GP4)

[yuutayuuta50]

The robot moved on Humble. The reason it wasn't working was because the line export RMW_IMPLEMENTATION=rmw_cyclonedds_cpp was present in my .bashrc. It seems it was added during one of the installation processes.

Thank you very much to everyone who responded!

[gavanderhoorn]

Good to hear you got your problem resolved.

re: Cyclone: apologies for not asking this before, but the requirements section as well as the Known limitations section (here: Only FastDDS is supported) state the incompatibility with Cyclone.

We seem to have assumed you were aware of that.

Also: did you remove your comment about the Foxy version working? Please don't do that, as it provided an important clue.

Just so we have it here:

@yuutayuuta50 wrote:

When I switched to ROS2 Foxy and used mr2_yrc1_f.out, the robot moved as expected, just like before. As I suspected, there seems to be an issue with mr2_yrc1_h.out. Since it seems that MoveIt2 cannot be installed on Foxy, I would like to run it on Humble. However, there has been no response at all. Is anyone seeing this message?

[yuutayuuta50]

I leave the testing procedure after installation.

(1) Install motoros2_client_interface_dependencies
https://github.com/Yaskawa-Global/motoros2_client_interface_dependencies

(2) Install ros2-starter-for-yaskawa-robots
https://github.com/YaskawaEurope/ros2-starter-for-yaskawa-robots/tree/main

(3) Launch the robot and start the micro-ROS Agent
Once connected, the IP address, etc. can be checked in the micro-ROS Agent.

(4) Run ros2 action list
/follow_joint_trajectory or /xxxx/follow_joint_trajectory will be displayed.

(5) Run ros2 topic echo joint_states to retrieve the current joint angles.

(6) Modify gp8_node.py located in the gp8_interface.
Note: This can be used for robots other than GP8, as long as they are 6-axis robots.

・Change "yaskawa/follow_joint_trajectory" to the one displayed in step (4).
・Change "yaskawa/start_traj_mode" based on what was displayed in step (4):
    If /follow_joint_trajectory, then /start_traj_mode.
    If /xxxx/follow_joint_trajectory, then /xxxx/start_traj_mode.
・Update q0 = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0] to the angles from step (5).

(7) Run colcon build to apply the changes.

(8) Run ros2 run gp8_interface move_on_traj.
    If the robot moves, the test is successful.

[yuutayuuta50]

I have realized why I used export RMW_IMPLEMENTATION=rmw_cyclonedds_cpp. It was because I followed the instructions in the URL below to install MoveIt 2 Humble:
https://moveit.picknik.ai/humble/doc/tutorials/getting_started/getting_started.html

[gavanderhoorn]

Thank you for letting us know.

Unfortunately Cyclone is not compatible with micro-ROS at this time, and thus incompatible with MotoROS2.