7.1.4-ROS 通信メカニズム:

トピック通信チュートリアル

トピック通信の概要

ROS では、トピック通信はノード間で情報を交換する基本的な方法の一つです。このチュートリアルでは、C++ と Python の両方を使って基本的なトピック通信のセットアップを案内します。シンプルな publisher-subscriber モデルを実装し、publisher は 10Hz の頻度でテキストメッセージを送信し、subscriber はそれを受信して表示します。

1. 理論モデル

トピック通信には主に 3 つのコンポーネントがあります。

• ROS Master: ノードの登録と接続を管理します。
• Talker(Publisher): メッセージを送信します。
• Listener(Subscriber): メッセージを受信します。

ROS Master は Talker と Listener の間で接続を確立する手助けをします。通信の流れを段階的に説明します。

• Talker の登録: Talker は ROS Master に自身を登録し、メッセージのトピック名を含めます。
• Listener の登録: Listener は ROS Master に自身を登録し、購読したいトピックを指定します。
• マッチング: ROS Master はトピック名に基づき Talker と Listener をマッチングし、必要な接続情報を送ります。
• 接続の確立: Listener は Talker への接続を要求し、Talker がそれを確認します。
• メッセージのやり取り: 接続が確立されると、Talker は Listener にメッセージを送り始めます。

ポイント:

• ROS Master は接続の確立時にだけ必要です。
• 接続が確立された後に ROS Master を停止しても通信は続きます。
• 複数の Talker と Listener が存在でき、どの順序で起動しても構いません。

2. 基本的なトピック通信(C++)

目的: 10Hz でテキストメッセージを送信する publisher ノードと、受信したメッセージを表示する subscriber ノードを作成します。

手順:

0. パッケージの作成

   bashコピー

   cd ~/seeed_ws/src/
   catkin_create_pkg listener_and_talker roscpp rospy std_msgs
   cd ~/seeed_ws/src/listener_and_talker/src
   touch listener.cpp talker.cpp

1. Publisher の実装:

   talker.cpp

   cppコピー

   #include "ros/ros.h"
   #include "std_msgs/String.h"
   #include <sstream>
   
   int main(int argc, char *argv[]) {
       // Set locale for printing messages in the local language
       setlocale(LC_ALL, "");
       // Initialize the ROS node with a unique name
       ros::init(argc, argv, "talker");
       // Create a ROS node handle
       ros::NodeHandle nh;
       // Create a publisher object
       ros::Publisher pub = nh.advertise<std_msgs::String>("chatter", 10);
   
       std_msgs::String msg;
       std::string msg_front = "Hello Seeed";
       int count = 0;
       ros::Rate r(10); // 10Hz
   
       while (ros::ok()) {
           std::stringstream ss;
           ss << msg_front << count;
           msg.data = ss.str();
           pub.publish(msg);
           ROS_INFO("Sent message: %s", msg.data.c_str());
           r.sleep();
           count++;
       }
       return 0;
   }

2. Subscriber の実装:

   listener.cpp

   cppコピー

   #include "ros/ros.h"
   #include "std_msgs/String.h"
   
   void doMsg(const std_msgs::String::ConstPtr& msg_p) {
       ROS_INFO("Heard: %s", msg_p->data.c_str());
   }
   
   int main(int argc, char *argv[]) {
       setlocale(LC_ALL, "");
       ros::init(argc, argv, "listener");
       ros::NodeHandle nh;
       ros::Subscriber sub = nh.subscribe<std_msgs::String>("chatter", 10, doMsg);
       ros::spin();
       return 0;
   }

3. CMakeLists.txt の設定:

   パッケージの CMakeLists.txt の末尾に次のコードを追加します。

   cmakeコピー

   add_executable(listener src/listener.cpp)
   add_executable(talker src/talker.cpp)
   
   target_link_libraries(listener ${catkin_LIBRARIES})
   target_link_libraries(talker ${catkin_LIBRARIES})

   

4. コードの実行:

• ターミナルを開いて roscore を起動します。

  bashコピー

  roscore

• 別のターミナルでワークスペースに移動し、publisher ノードを実行します。

  bashコピー

  rosrun listener_and_talker listener

• さらに別のターミナルで subscriber ノードを実行します。

  bashコピー

  rosrun listener_and_talker talker

  

  

ターミナルにメッセージが配信・受信されているのが見えるはずです。

3. 基本的なトピック通信(Python)

目的: 10Hz でテキストメッセージを送信する publisher ノードと、受信したメッセージを表示する subscriber ノードを作成します。

手順:

0. パッケージの作成

   bashコピー

   cd ~/seeed_ws/src/
   catkin_create_pkg listener_and_talker roscpp rospy std_msgs
   mkdir ~/seeed_ws/src/listener_and_talker/script
   cd ~/seeed_ws/src/listener_and_talker/script
   touch listener.py talker.py

1. Publisher の実装:

   talker.py

   pythonコピー

   #!/usr/bin/env python
   import rospy
   from std_msgs.msg import String
   
   if __name__ == "__main__":
       rospy.init_node("talker_p")
       pub = rospy.Publisher("chatter", String, queue_size=10)
       msg = String()
       msg_front = "hello 你好"
       count = 0
       rate = rospy.Rate(10)  # 10Hz
   
       while not rospy.is_shutdown():
           msg.data = msg_front + str(count)
           pub.publish(msg)
           rospy.loginfo("Sent message: %s", msg.data)
           rate.sleep()
           count += 1

2. Subscriber の実装:

   listener.py

   pythonコピー

   #!/usr/bin/env python
   import rospy
   from std_msgs.msg import String
   
   def doMsg(msg):
       rospy.loginfo("Heard: %s", msg.data)
   
   if __name__ == "__main__":
       rospy.init_node("listener_p")
       sub = rospy.Subscriber("chatter", String, doMsg, queue_size=10)
       rospy.spin()

3. 実行権限の付与:

   bashコピー

    sudo chmod +x *.py

4. CMakeLists.txt の設定:

   パッケージの CMakeLists.txt の末尾に次のコードを追加します。

   cmakeコピー

   catkin_install_python(PROGRAMS
     scripts/talker.py
     scripts/listener.py
     DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
   )

5. コードの実行:

   • ターミナルを開いて roscore を起動します。
     bashコピー

     roscore

   • 別のターミナルでワークスペースに移動し、publisher ノードを実行します。
     bashコピー

     rosrun listener_and_talker talker.py

   • さらに別のターミナルで subscriber ノードを実行します。
     bashコピー

     rosrun listener_and_talker listener.py

ターミナルにメッセージが配信・受信されているのが見えるはずです。

ROS トピックの主なコマンド

• rostopic bw: トピックの帯域幅使用量を表示
• rostopic delay: ヘッダ付きトピックの遅延を表示
• rostopic echo: メッセージを画面に表示
• rostopic find: 型でトピックを検索
• rostopic hz: トピックの配信頻度を表示
• rostopic info: トピック情報を表示
• rostopic list: アクティブな全トピックを一覧表示
• rostopic pub: トピックにデータを配信
• rostopic type: トピックの型を表示

サービス通信の概要

ROS のサービス通信はトピック通信と異なり双方向です。メッセージの送信だけでなくフィードバックの受信も可能です。このモデルは主に 2 つの部分から構成されます。

1. Client: リクエストを送る側。
2. Server: リクエストを処理しレスポンスを返す側。

クライアントがサーバにリクエストを送ると、サーバが処理してレスポンスを返すまで待機します。この仕組みは「リクエスト-リプライ」の構造に従って通信を完結させます。

仕組み

• Node B(サーバ)はサービスインターフェイスを提供し、通常は /service_name のような名前を付けます。
• Node A(クライアント)は Node B にリクエストを送ります。
• Node B はリクエストを処理してレスポンスを返します。

通信プロセスは次のように図示できます。

1. Talker ノードが ROS Master を介してサービスをアドバタイズ:

   • Talker ノードは ROS Master を介してサービス(例: advertiseService("bar", foo:1234))をアドバタイズし、その提供を示します。

2. Listener ノードが ROS Master を介してサービスを検索:

   • Listener ノードは ROS Master にサービスを探すリクエスト(例: lookupService("bar"))を送信します。

3. ROS Master がサービスアドレスを返す:

   • ROS Master はサービスアドレス(例: foo:3456)を返し、Listener ノードが接続できるようにします。

4. Listener ノードが Talker ノードにデータをリクエスト:

   • Listener ノードは XML/RPC を使って Talker ノードにサービスリクエストを送ります。

5. Talker ノードがリクエストされたデータで応答:

   • Talker ノードはリクエストを処理し、応答データを TCP 経由で送り返します。

   

ポイント:

• クライアントはサーバから応答を受け取るまでブロックされます。
• サービス通信は効率的で、必要なとき(リクエストが行われたとき)だけリソースを消費します。

理論モデル

サービス通信モデルには 3 つの主要コンポーネントがあります。

1. ROS Master: サーバとクライアントの登録を管理し、サービス名のマッチングに基づいて接続を確立します。
2. Server: サービスを提供します。
3. Client: サービスを要求します。

プロセス概要:

1. サーバの登録:

   • サーバは ROS Master に自身を登録し、提供するサービス名を含めます。

2. クライアントの登録:

   • クライアントは ROS Master に自身を登録し、利用したいサービスを指定します。

3. マッチングと接続:

   • ROS Master はサービス名に基づいてクライアントとサーバをマッチングし、接続を仲介します。

4. リクエスト-レスポンスサイクル:

   • クライアントがサーバにリクエストを送り、サーバはそれを処理してレスポンスを返します。

トピック通信とサービス通信の比較

最もよく使われる ROS の通信方式 2 つを比較し、理解を深めましょう。

注: リモートプロシージャコール(RPC)とは、別プロセスの関数をローカル関数のように呼び出すことです。

5. ROS でのカスタムサービス (srv) の作成

クライアントから送られた 2 つの整数を加算するカスタムサービスを作成する実践例を見てみましょう。サーバはこのリクエストを処理し、合計値をクライアントに返します。

実装手順:

1. 新しいパッケージの作成

   bashコピー

   cd ~/seeed_ws/src
   catkin_create_pkg service_communication roscpp rospy std_msgs
   cd ~/seeed_ws
   catkin_make

2. srv ファイルの定義: srv ファイルはリクエストとレスポンスの構造を定義します。今回はリクエストに 2 つの整数、レスポンスにそれらの合計が含まれます。 パッケージに srv という新しいディレクトリを作成し、AddInts.srv というファイルを追加します。

   bashコピー

    mkdir ~/seeed_ws/src/service_communication/srv
    cd ~/seeed_ws/src/service_communication/srv
    touch AddInts.srv

   次の内容を AddInts.srv にコピーします。

   srvコピー

   int32 num1
   int32 num2
   ---
   int32 sum

   

3. package.xml の更新: メッセージファイル生成に必要な依存関係をパッケージの package.xml に追加します。

   xmlコピー

   <build_depend>message_generation</build_depend>
   <exec_depend>message_runtime</exec_depend>

   

4. CMakeLists.txt の更新:

   • サービスファイル生成に必要な設定をパッケージの CMakeLists.txt に含めます。
     cmakeコピー

     find_package(catkin REQUIRED COMPONENTS
       roscpp
       rospy
       std_msgs
       message_generation
     )
     
     add_service_files(
       FILES
       AddInts.srv
     )
     
     generate_messages(
       DEPENDENCIES
       std_msgs
     )

     

5. パッケージのビルド:

   • サービスメッセージのヘッダを生成するためにパッケージをビルドします。
     bashコピー

     cd ~/seeed_ws
     catkin_make
     source devel/setup.bash

サービス通信の実装(C++)

この例では、C++ を使って ROS でサービス通信を実装する方法を示します。クライアントが指定した 2 つの整数を加算し、その合計を返すシンプルなサービスを作成します。

1. サーバの実装:

add_two_ints_server.cpp

#include "ros/ros.h"
#include "service_communication/AddInts.h"

// Callback function to handle the client's request
bool add(service_communication::AddInts::Request &req,
         service_communication::AddInts::Response &res) {
    res.sum = req.num1 + req.num2;  // Compute the sum
    ROS_INFO("Request: a=%ld, b=%ld", (long int)req.num1, (long int)req.num2);
    ROS_INFO("Sending back response: [%ld]", (long int)res.sum);
    return true;
}

int main(int argc, char **argv) {
    ros::init(argc, argv, "add_two_ints_server");
    ros::NodeHandle nh;

    // Advertise the service to the ROS master
    ros::ServiceServer service = nh.advertiseService("add_two_ints", add);
    ROS_INFO("Ready to add two integers.");
    ros::spin();

    return 0;
}

2. クライアントの実装:

add_two_ints_client.cpp

#include "ros/ros.h"
#include "service_communication/AddInts.h"
#include <cstdlib>

int main(int argc, char **argv) {
    ros::init(argc, argv, "add_two_ints_client");
    if (argc != 3) {
        ROS_INFO("Usage: add_two_ints_client X Y");
        return 1;
    }

    ros::NodeHandle nh;
    ros::ServiceClient client = nh.serviceClient<service_communication::AddInts>("add_two_ints");

    // Prepare the service request
    service_communication::AddInts srv;
    srv.request.num1 = atoll(argv[1]);
    srv.request.num2 = atoll(argv[2]);

    // Call the service and check if it was successful
    if (client.call(srv)) {
        ROS_INFO("Sum: %ld", (long int)srv.response.sum);
    } else {
        ROS_ERROR("Failed to call service add_two_ints");
        return 1;
    }

    return 0;
}

CMakeLists.txt の設定:

サーバとクライアントの両方をビルドできるよう、CMakeLists.txt の末尾に次の行を追加してください。

add_executable(add_two_ints_server src/add_two_ints_server.cpp)
add_executable(add_two_ints_client src/add_two_ints_client.cpp)

add_dependencies(add_two_ints_server ${${PROJECT_NAME}_EXPORTED_TARGETS} ${catkin_EXPORTED_TARGETS})
add_dependencies(add_two_ints_client ${${PROJECT_NAME}_EXPORTED_TARGETS} ${catkin_EXPORTED_TARGETS})

target_link_libraries(add_two_ints_server ${catkin_LIBRARIES})
target_link_libraries(add_two_ints_client ${catkin_LIBRARIES})

デモのビルドと実行

1 つのターミナルを開きます。

cd ~/seeed_ws
catkin_make
roscore

別のターミナルを開きます。

cd ~/seeed_ws
source devel/setup.bash
 rosrun service_communication server

さらに別のターミナルを開きます。

cd ~/seeed_ws
source devel/setup.bash
rosrun service_communication client 1 5

サービス通信の実装(Python)

この Python 例は C++ 例と同じ機能を実現し、サービスを使って 2 つの整数を加算します。

パッケージの下に scripts フォルダを作成し、その中に add_two_ints_server.py と add_two_ints_client.py ファイルを作成します。

cd ~/seeed/src/service_communication/
mkdir scripts
cd scripts
touch add_two_ints_server.py add_two_ints_client.py

1. サーバの実装:

add_two_ints_server.py

#!/usr/bin/env python
import rospy
from service_communication.srv import AddInts,AddIntsRequest, AddIntsResponse
def doReq(req):
    sum = req.num1 + req.num2
    rospy.loginfo("data:num1 = %d, num2 = %d, sum = %d",req.num1, req.num2, sum)
    resp = AddIntsResponse(sum)
    return resp
if __name__ == "__main__":
    rospy.init_node("addints_server_p")
    server = rospy.Service("AddInts",AddInts,doReq)
    rospy.spin()

2. クライアントの実装:

add_two_ints_client.py

#!/usr/bin/env python

import sys
import rospy
from service_communication.srv import *

if __name__ == "__main__":
    if len(sys.argv) != 3:
        rospy.logerr("error")
        sys.exit(1)
    rospy.init_node("AddInts_Client_p")
    client = rospy.ServiceProxy("AddInts",AddInts)
    client.wait_for_service()
    req = AddIntsRequest()
    req.num1 = int(sys.argv[1])
    req.num2 = int(sys.argv[2]) 
    resp = client.call(req)
    rospy.loginfo("result:%d",resp.sum)

CMakeLists.txt の設定:

Python スクリプト用に CMakeLists.txt に次の行を追加します。

catkin_install_python(PROGRAMS
  scripts/add_two_ints_server.py 
  scripts/add_two_ints_client.py
  DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
)

デモのビルドと実行

1 つのターミナルを開きます。

cd ~/seeed_ws
catkin_make
roscore

別のターミナルを開きます。

cd ~/seeed_ws
source devel/setup.bash
rosrun service_communication add_two_ints_server.py

さらに別のターミナルを開きます。

cd ~/seeed_ws
source devel/setup.bash
rosrun service_communication add_two_ints_client.py 1 5

サービス通信のコマンド

ROS のサービスを操作するには rosservice コマンドを使います。よく使う rosservice コマンドとその機能の一覧です。

• rosservice args: サービスに必要な引数を表示
• rosservice call: 指定の引数でサービスを呼び出し
• rosservice find: 型でサービスを検索
• rosservice info: サービス情報を表示
• rosservice list: アクティブな全サービスを一覧表示
• rosservice type: サービスの型を表示
• rosservice uri: サービスの ROSRPC URI を表示

ROS パラメータサーバの紹介

ROS パラメータサーバは、共有・マルチユーザー・ネットワーク経由でアクセス可能なパラメータの保存スペースです。実行時にパラメータを保存・取得する方法を提供し、ノードの設定やノード間でのデータ共有に使えます。サーバ上のパラメータは整数、ブール、文字列、double、リスト、辞書など各種データ型に対応します。パラメータサーバは ROS Master によって管理され、ノードはパラメータの設定、取得、削除を通じてやり取りします。

パラメータサーバの理論モデル

パラメータサーバには 3 つの主な役割が関わります。

1. ROS Master: パラメータサーバを管理し、パラメータの中央ストレージとして機能します。
2. Talker: サーバにパラメータを設定するノード。
3. Listener: サーバからパラメータを取得するノード。

パラメータサーバとのやり取りは通常、次のステップを伴います。

1. パラメータの設定(Talker):

   • Talker ノードは RPC(リモートプロシージャコール)経由でパラメータの名前と値をパラメータサーバに送信します。ROS Master はそのパラメータをリストに保存します。

2. パラメータの取得(Listener):

   • Listener ノードはパラメータ名を含むクエリを送ってパラメータサーバに要求します。

3. パラメータの返却(ROS Master):

   • ROS Master はストレージから要求されたパラメータを探し、対応する値を Listener に返します。

   

サポートされるデータ型:

• 32 ビット整数
• ブール値
• 文字列
• double
• ISO8601 日付
• リスト
• Base64 エンコードされたバイナリデータ
• 辞書

C++ 実装

パラメータの設定(C++):

まず、ros::NodeHandle と ros::param という 2 つの異なる API を使って、各種パラメータをパラメータサーバに設定します。

set_parameters.cpp

#include "ros/ros.h"

int main(int argc, char *argv[]) {
    ros::init(argc, argv, "set_parameters");

    std::vector<std::string> students = {"Alice", "Bob", "Charlie", "David"};
    std::map<std::string, std::string> friends = {{"John", "Doe"}, {"Jane", "Smith"}};

    // Using ros::NodeHandle to set parameters
    ros::NodeHandle nh;
    nh.setParam("int_param", 42);
    nh.setParam("double_param", 3.14159);
    nh.setParam("bool_param", true);
    nh.setParam("string_param", "Hello ROS");
    nh.setParam("vector_param", students);
    nh.setParam("map_param", friends);

    // Using ros::param to set parameters
    ros::param::set("int_param_param", 84);
    ros::param::set("double_param_param", 6.28318);
    ros::param::set("bool_param_param", false);
    ros::param::set("string_param_param", "Goodbye ROS");
    ros::param::set("vector_param_param", students);
    ros::param::set("map_param_param", friends);

    return 0;
}

パッケージの CMakeLists.txt の末尾に次のコードを追加します。

add_executable(set_parameters src/set_parameters.cpp)
target_link_libraries(set_parameters ${catkin_LIBRARIES})

この例では:

• 整数、double、ブール、文字列、ベクトル、マップなど、様々な型のパラメータをパラメータサーバに設定しています。
• パラメータの設定に ros::NodeHandle と ros::param の両方の API を使用しています。

パラメータの取得(C++):

次に、先ほどパラメータサーバに設定したパラメータを取得します。

get_parameters.cpp

#include "ros/ros.h"

int main(int argc, char *argv[]) {
    ros::init(argc, argv, "get_parameters");

    // Using ros::NodeHandle to retrieve parameters
    ros::NodeHandle nh;
    int int_value;
    double double_value;
    bool bool_value;
    std::string string_value;
    std::vector<std::string> students;
    std::map<std::string, std::string> friends;

    nh.getParam("int_param", int_value);
    nh.getParam("double_param", double_value);
    nh.getParam("bool_param", bool_value);
    nh.getParam("string_param", string_value);
    nh.getParam("vector_param", students);
    nh.getParam("map_param", friends);

    ROS_INFO("Retrieved values:");
    ROS_INFO("int_param: %d", int_value);
    ROS_INFO("double_param: %.5f", double_value);
    ROS_INFO("bool_param: %d", bool_value);
    ROS_INFO("string_param: %s", string_value.c_str());

    for (const auto &student : students) {
        ROS_INFO("Student: %s", student.c_str());
    }

    for (const auto &friend_pair : friends) {
        ROS_INFO("Friend: %s = %s", friend_pair.first.c_str(), friend_pair.second.c_str());
    }

    return 0;
}

パッケージの CMakeLists.txt の末尾に次のコードを追加します。

add_executable(get_parameters src/get_parameters.cpp)
target_link_libraries(get_parameters ${catkin_LIBRARIES})

この例では:

• ros::NodeHandle API を使ってサーバ上のパラメータを取得します。
• 取得したパラメータは確認のため ROS ログに出力されます。

パラメータの削除(C++):

最後に、パラメータサーバからパラメータを削除する方法を見ていきましょう。

delete_parameters.cpp

#include "ros/ros.h"

int main(int argc, char *argv[]) {
    ros::init(argc, argv, "delete_parameters");

    ros::NodeHandle nh;
    bool success;

    // Using ros::NodeHandle to delete parameters
    success = nh.deleteParam("int_param");
    ROS_INFO("Delete int_param: %s", success ? "Success" : "Failure");

    // Using ros::param to delete parameters
    success = ros::param::del("int_param_param");
    ROS_INFO("Delete int_param_param: %s", success ? "Success" : "Failure");

    return 0;
}

パッケージの CMakeLists.txt の末尾に次のコードを追加します。

add_executable(delete_parameters src/delete_parameters.cpp)
target_link_libraries(delete_parameters ${catkin_LIBRARIES})

この例では:

• ros::NodeHandle と ros::param の両方の API を使ってサーバからパラメータを削除します。
• 削除の成否はログに記録されます。

2.2 Python 実装

パラメータの設定(Python):

ここでは Python を使ってパラメータを設定します。手順は C++ 版と非常によく似ています。

#!/usr/bin/env python

import rospy

if __name__ == "__main__":
    rospy.init_node("set_parameters_py")

    # Setting various types of parameters
    rospy.set_param("int_param", 42)
    rospy.set_param("double_param", 3.14159)
    rospy.set_param("bool_param", True)
    rospy.set_param("string_param", "Hello ROS")
    rospy.set_param("list_param", ["apple", "banana", "cherry"])
    rospy.set_param("dict_param", {"first_name": "John", "last_name": "Doe"})

    # Modifying a parameter
    rospy.set_param("int_param", 84)

パッケージの CMakeLists.txt の末尾に次のコードを追加します。

catkin_install_python(PROGRAMS
  scripts/set_parameters_py.py
  DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
)

この例では:

• 整数、double、ブール、文字列、リスト、辞書など、様々な型のパラメータを設定しています。
• 既存パラメータの変更も併せて示しています。

パラメータの取得(Python):

次に、先ほど設定したパラメータを取得します。

#!/usr/bin/env python

import rospy

if __name__ == "__main__":
    rospy.init_node("get_parameters_py")

    # Retrieving parameters
    int_value = rospy.get_param("int_param", 0)
    double_value = rospy.get_param("double_param", 0.0)
    bool_value = rospy.get_param("bool_param", False)
    string_value = rospy.get_param("string_param", "")
    list_value = rospy.get_param("list_param", [])
    dict_value = rospy.get_param("dict_param", {})

    rospy.loginfo("Retrieved values:")
    rospy.loginfo("int_param: %d", int_value)
    rospy.loginfo("double_param: %.5f", double_value)
    rospy.loginfo("bool_param: %s", bool_value)
    rospy.loginfo("string_param: %s", string_value)
    rospy.loginfo("list_param: %s", list_value)
    rospy.loginfo("dict_param: %s", dict_value)

パッケージの CMakeLists.txt の末尾に次のコードを追加します。

catkin_install_python(PROGRAMS
  scripts/set_parameters_py.py
  scripts/get_parameters_py.py
  DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
)

この例では:

• rospy.get_param を使ってサーバに設定されたパラメータを取得します。
• 取得した値は rospy.loginfo でログ出力されます。

パラメータの削除(Python):

最後に、Python を使ってパラメータサーバからパラメータを削除します。

#!/usr/bin/env python

import rospy

if __name__ == "__main__":
    rospy.init_node("delete_parameters_py")

    try:
        rospy.delete_param("int_param")
        rospy.loginfo("int_param deleted successfully.")
    except KeyError:
        rospy.logwarn("int_param does not exist.")

    try:
        rospy.delete_param("non_existent_param")
        rospy.loginfo("non_existent_param deleted successfully.")
    except KeyError:
        rospy.logwarn("non_existent_param does not exist.")

パッケージの CMakeLists.txt の末尾に次のコードを追加します。

catkin_install_python(PROGRAMS
  scripts/set_parameters_py.py
  scripts/get_parameters_py.py
  scripts/delete_parameters_py.py
  DESTINATION ${CATKIN_PACKAGE_BIN_DESTINATION}
)

この例では:

• パラメータの削除を試み、存在しない場合は例外処理(KeyError)で対応します。

ROS パラメータサーバの主なコマンド

rosparam には、YAML エンコードされたファイルを介してパラメータサーバ上の ROS パラメータを取得・設定するためのコマンドラインツールが含まれます。

• rosparam set: パラメータを設定
• rosparam get: パラメータを取得
• rosparam load: 外部ファイルからパラメータをロード
• rosparam dump: 外部ファイルにパラメータをダンプ
• rosparam delete: パラメータを削除
• rosparam list: 全パラメータを一覧表示

例:

• rosparam list: パラメータサーバ上の全パラメータを一覧表示。
• rosparam set <param_name> <value>: 指定の値でパラメータを設定。
• rosparam get <param_name>: 特定パラメータの値を取得。
• rosparam delete <param_name>: 特定のパラメータを削除。
• rosparam load <file_name.yaml>: YAML ファイルからパラメータをロード。
• rosparam dump <file_name.yaml>: 現在のパラメータを YAML ファイルにダンプ。