Skill `replay_motion`

Version: 1.1.0
Default path: /skill/replay_motion
Datatype: motion_skills_action_ReplayMotion.action
Definition source: package.xml in ros4hri/motions_skills

Execute a pre-recorded motion. Can be used, for instance, to perform prerecorded gestures, or going to preset postures.

Input parameters

name std_msgs/msg/String, required

The name of the motion to execute. The name must be one of the names returned by the skill list_motions.
unsafe bool, default: False

If true, skip collision checks. If false (default), the skill implementation is expected to ensure that the motion execution is safe (for instance, it does not generate collisions).
meta.priority integer, default: 128

Between 0 and 255. Higher means this skill request will be prioritized.

Quick snippets

Call the skill from the command-line

$ ros2 action send_goal /skill/replay_motion motion_skills/action/ReplayMotion.action # then press Tab to complete the message prototype

Call the action from a Python script:

#!/usr/bin/env python

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

from motion_skills.action import

class Replaymotion.actionActionClient(Node):

    def __init__(self):
        super().__init__('replay_motion_client')
        self._action_client = ActionClient(self, , '/skill/replay_motion')

    def send_goal(self, a, b):
        goal_msg = .Goal()

        # TODO: adapt to the action's parameters

        # check the ReplayMotion.actionGoal message
        # definition for the possible goal parameters

        # goal_msg.a = a
        # goal_msg.b = b

        self._action_client.wait_for_server()

        return self._action_client.send_goal_async(goal_msg)

if __name__ == '__main__':
    rclpy.init(args=args)

    action_client = ActionClient()

    # TODO: adapt to your action's parameters
    future = action_client.send_goal(a, b)

    rclpy.spin_until_future_complete(action_client, future)

    rclpy.shutdown()

Call the action from a C++ program:

#include <functional>
#include <future>
#include <memory>
#include <string>
#include <sstream>
#include <chrono>

#include "motion_skills/action/.hpp"

#include "rclcpp/rclcpp.hpp"
#include "rclcpp_action/rclcpp_hpp"
#include "rclcpp_components/register_node_macro.hpp"

using namespace std::chrono_literals;
using namespace std;

class Replaymotion.actionActionClient : public rclcpp::Node
{
public:
  using  = motion_skills::action::;
  using GoalHandle = rclcpp_action::ClientGoalHandle<>;

  explicit Replaymotion.actionActionClient(const rclcpp::NodeOptions & options)
  : Node("replay_motion_action_client", options)
  {
    this->client_ptr_ = rclcpp_action::create_client<>(
            this,
            "");

    this->timer_ = this->create_wall_timer(
            500ms,
            bind(&Replaymotion.actionActionClient::send_goal, this));
  }

  void send_goal()
  {
    using namespace std::placeholders;

    this->timer_->cancel();

    if (!this->client_ptr_->wait_for_action_server()) {
      RCLCPP_ERROR(this->get_logger(), "Action server not available after waiting");
      rclcpp::shutdown();
    }

    auto goal_msg = ::Goal();


    // check the ReplayMotion.actionGoal message
    // definition for the possible goal parameters

    // goal_msg.... = ...;

    RCLCPP_INFO(this->get_logger(), "Sending goal");

    auto send_goal_options = rclcpp_action::Client<>::SendGoalOptions();

    send_goal_options.goal_response_callback =
        bind(&Replaymotion.actionActionClient::goal_response_callback, this, _1);

    send_goal_options.feedback_callback =
        bind(&Replaymotion.actionActionClient::feedback_callback, this, _1, _2);

    send_goal_options.result_callback =
        bind(&Replaymotion.actionActionClient::result_callback, this, _1);


    this->client_ptr_->async_send_goal(goal_msg, send_goal_options);
  }

private:
  rclcpp_action::Client<>::SharedPtr client_ptr_;
  rclcpp::TimerBase::SharedPtr timer_;

  void goal_response_callback(const GoalHandle::SharedPtr & goal_handle)
  {
    if (!goal_handle) {
      RCLCPP_ERROR(this->get_logger(), "Goal was rejected by server");
    } else {
      RCLCPP_INFO(this->get_logger(), "Goal accepted by server, waiting for result");
    }
  }

  void feedback_callback(
      GoalHandle::SharedPtr,
      const shared_ptr<const ::Feedback> feedback)
  {
    stringstream ss;
    ss << "Next number in sequence received: ";
    for (auto number : feedback->partial_sequence) {
      ss << number << " ";
    }
    RCLCPP_INFO(this->get_logger(), ss.str().c_str());
  }

  void result_callback(const GoalHandle::WrappedResult & result)
  {
    switch (result.code) {
      case rclcpp_action::ResultCode::SUCCEEDED:
          break;
      case rclcpp_action::ResultCode::ABORTED:
          RCLCPP_ERROR(this->get_logger(), "Goal was aborted");
          return;
      case rclcpp_action::ResultCode::CANCELED:
          RCLCPP_ERROR(this->get_logger(), "Goal was canceled");
          return;
      default:
          RCLCPP_ERROR(this->get_logger(), "Unknown result code");
          return;
    }
    stringstream ss;
    ss << "Result received: ";
    for (auto number : result.result->sequence) {
      ss << number << " ";
    }
    RCLCPP_INFO(this->get_logger(), ss.str().c_str());
    rclcpp::shutdown();
  }
};  // class Replaymotion.actionActionClient


RCLCPP_COMPONENTS_REGISTER_NODE(Replaymotion.actionActionClient)

You can call this skill from QML using the following code snippet. See ros_qml_plugin to learn more.

import Ros 2.0

// ...
ReplayMotionSkill {
    id: mySkill

    onResult: {
        console.log("Skill result: " + result);
    }
    onFeedback: {
        console.log("Skill feedback: " + feedback);
    }

}

// Call the skill
mySkill.replay_motion();

Skill replay_motion

Input parameters

Quick snippets

See also

Skill `replay_motion`