.. index:: chat .. _skill-chat: Skill ``chat`` ----------------------------------------------------------- - **Version**: 1.0.0 - **Default path**: ``/skill/chat`` - **Datatype**: :action:`communication_skills/action/Chat` - **Definition source**: ``package.xml`` in `ros4hri/communication_skills `_ Start a dialogue with a defined purpose. See :ref:`dialogue_management` for details. Input parameters ~~~~~~~~~~~~~~~~ - **role** ``string``, default: ``__default__``, *required* The name and configuration for the dialogue purpose (chatbot-dependent). - **initiate** ``boolean``, default: ``False`` If true, the dialogue is opened and the robot initiates the conversation. - **initial_input** ``string``, default: ``""`` Optionally specify the utterance the chatbot initiates the conversation with. Otherwise, the chatbot may generate one based on the role. It is ignored if ``initiate`` is false. - **person_id** ``string``, default: ``""`` If targeting a specific person, the ID of the person. - **group_id** ``string``, default: ``""`` If targeting a group of people, the ID of the group *(currently not supported)*. - **meta.priority** ``integer``, default: ``128`` Between 0 and 255. Higher value means that this skill invokation will have higher priority. Output fields ~~~~~~~~~~~~~ - **role_result** ``string`` A machine-readable serialized JSON object containing the result, depending on the role. Quick snippets ~~~~~~~~~~~~~~ .. tabs:: .. tab:: Command-line Call the skill from the command-line .. code-block:: sh $ ros2 action send_goal /skill/chat communication_skills/action/Chat # then press Tab to complete the message prototype .. tab:: ROS 2 action (Python) Call the action from a Python script: .. code-block:: python #!/usr/bin/env python import rclpy from rclpy.action import ActionClient from rclpy.node import Node from communication_skills.action import class ChatActionClient(Node): def __init__(self): super().__init__('chat_client') self._action_client = ActionClient(self, , '/skill/chat') def send_goal(self, a, b): goal_msg = .Goal() # TODO: adapt to the action's parameters # check the ChatGoal 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() .. tab:: ROS 2 action (C++) Call the action from a C++ program: .. code-block:: cpp #include #include #include #include #include #include #include "communication_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 ChatActionClient : public rclcpp::Node { public: using = communication_skills::action::; using GoalHandle = rclcpp_action::ClientGoalHandle<>; explicit ChatActionClient(const rclcpp::NodeOptions & options) : Node("chat_action_client", options) { this->client_ptr_ = rclcpp_action::create_client<>( this, ""); this->timer_ = this->create_wall_timer( 500ms, bind(&ChatActionClient::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 ChatGoal 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(&ChatActionClient::goal_response_callback, this, _1); send_goal_options.feedback_callback = bind(&ChatActionClient::feedback_callback, this, _1, _2); send_goal_options.result_callback = bind(&ChatActionClient::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 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 ChatActionClient RCLCPP_COMPONENTS_REGISTER_NODE(ChatActionClient) .. tab:: QML You can call this skill from QML using the following code snippet. See :ref:`ros_qml_plugin` to learn more. .. code-block:: qml import Ros 2.0 // ... ChatSkill { id: mySkill onResult: { console.log("Skill result: " + result); } onFeedback: { console.log("Skill feedback: " + feedback); } } // Call the skill mySkill.chat(); See also ~~~~~~~~ * List of other :ref:`communication_skills` skills