04. ROS 2 Launch, Param, Bag

Lecture

ROS 2 Launch

Launch multiple nodes
Set arguments
Monitor running nodes
React on changes in the state of nodes
Python, XML and YAML file formats

Usage

    ros2 launch package_name file.launch
    ros2 launch irob_robot dvrk_server.launch arm_typ:=PSM1

ROS 2 Parameters

Configure nodes at startup or during runtime without changing the code
Associated with individual nodes
Consists of: key, value, descriptor
Available data types: bool, int64, float64, string, byte[], bool[], int64[], float64[] or string[].
Useful command: ros2 param

ROS 2 Bag

Record and playback ROS topics
Command line tool
API for C++ and Python

    ros2 bag record -o <file_name> <topic_name>
    ros2 bag record --all
    ros2 bag info <filename.bag>
    ros2 bag play <filename.bag>

Practice

1: Launch Turtlesim Mimic

Create the launch folder inside the ros2_course package, where the launch files can be stored:
```
cd ~/ros2_ws/src/ros2_course
mkdir launch
```

Create the turtlesim_mimic_launch.py file in the new launch folder a with the following content:

from launch import LaunchDescription
from launch_ros.actions import Node

def generate_launch_description():
    return LaunchDescription([
        Node(
            package='turtlesim',
            namespace='turtlesim1',
            executable='turtlesim_node',
            name='sim'
        ),
        Node(
            package='turtlesim',
            namespace='turtlesim2',
            executable='turtlesim_node',
            name='sim'
        ),
        Node(
            package='turtlesim',
            executable='mimic',
            name='mimic',
            remappings=[
                ('/input/pose', '/turtlesim1/turtle1/pose'),
                ('/output/cmd_vel', '/turtlesim2/turtle1/cmd_vel'),
            ]
        )
    ])

Add the followings to the setup.py file:

import os
from glob import glob

# ...

data_files=[
    ('share/ament_index/resource_index/packages',
        ['resource/' + package_name]),
    ('share/' + package_name, ['package.xml']),
    # Include all launch files.
    (os.path.join('share', package_name),
        glob('launch/*launch.[pxy][yma]*'))
],

Add the ros2launch dependency to the package.xml file:
```
<exec_depend>ros2launch</exec_depend>
```

Build the workspace:

cd ros2_ws
colcon build --symlink-install

Launch the launch file:

ros2 launch ros2_course turtlesim_mimic_launch.py

Publish to the topic from the command line, in a new terminal window:

ros2 topic pub -r 1 /turtlesim1/turtle1/cmd_vel geometry_msgs/msg/Twist "{linear: {x: 2.0, y: 0.0, z: 0.0}, angular: {x: 0.0, y: 0.0, z: -1.8}}"

Let's examine the operation of the system using rqt_gui:
```
ros2 run rqt_gui rqt_gui
```

2: Launch Turtlesim Goto

Let's make a copy of turtlesim_mimic_launch.py from a file named turtlesim_controller_launch.py.
Add the turtlesim_controller node written in the previous lesson to the launch file. The turtle to be controlled can be set using namespace or remappings.

Build the workspace:

cd ros2_ws
colcon build --symlink-install

launch the new launch file:

ros2 launch ros2_course turtlesim_controller_launch.py

3: Turtlesim controller params

Modify turtlesim_controller so that the linear velocity and angular velocity. is adjustable via ROS parameters. API example for parameters:

import rclpy
import rclpy.node

class MinimalParam(rclpy.node.Node):
    def __init__(self):
        super().__init__('minimal_param_node')
        # Declare parameter named 'my_parameter' and
        # set default value to 'world'
        self.declare_parameter('my_parameter', 'world')
        self.timer = self.create_timer(1, self.timer_callback)

    def timer_callback(self):
        my_param = self.get_parameter('my_parameter').get_parameter_value().string_value
        self.get_logger().info('Hello %s!' % my_param)


def main():
    rclpy.init()
    node = MinimalParam()
    rclpy.spin(node)

if __name__ == '__main__':
    main()

Let's run turtlesim_controller.py using the previously written launch file. Let's list the parameters.
```
ros2 launch ros2_course turtlesim_controller_launch.py
```
```
ros2 param list
```
Change the speed and angular velocity parameters from the command line using the following command:
```
ros2 param set <NODE_NAME> <PARAM_NAME> <NEW_VALUE>
ros2 param set controller speed 100.0
```

4: Turtlesim controller launch and substitutions

Let's make a copy of turtlesim_controller_launch.py as turtlesim_controller_param_launch.py. Modify the new launch file based on the example below so that the velocity and angular velocity parameters of the launch can be specified as file arguments.

from launch_ros.actions import Node
from launch import LaunchDescription
from launch.actions import DeclareLaunchArgument, ExecuteProcess, TimerAction
from launch.conditions import IfCondition
from launch.substitutions import LaunchConfiguration, PythonExpression

def generate_launch_description():
    turtlesim_ns_value = LaunchConfiguration('turtlesim_ns')
    use_provided_red_value = LaunchConfiguration('use_provided_red')
    new_background_r_value = LaunchConfiguration('new_background_r')
    background_g_value = LaunchConfiguration('background_g')
    background_b_value = LaunchConfiguration('background_b')

    turtlesim_ns_launch_arg = DeclareLaunchArgument(
        'turtlesim_ns',
        default_value='turtlesim1',
        description='Namespace for turtle 1'
    )
    use_provided_red_launch_arg = DeclareLaunchArgument(
        'use_provided_red',
        default_value='False'
    )
    new_background_r_launch_arg = DeclareLaunchArgument(
        'new_background_r',
        default_value='200'
    )
    background_g_launch_arg = DeclareLaunchArgument(
        'background_g',
        default_value='100'
    )
    background_b_launch_arg = DeclareLaunchArgument(
        'background_b',
        default_value='100'
    )

    turtlesim_node = Node(
        package='turtlesim',
        namespace=turtlesim_ns_value,
        executable='turtlesim_node',
        name='sim',
        parameters=[{
            'background_g': background_g_value,
            'background_b': background_b_value,
        }]
    )
    spawn_turtle = ExecuteProcess(
        cmd=[[
            'ros2 service call ',
            turtlesim_ns,
            '/spawn ',
            'turtlesim/srv/Spawn ',
            '"{x: 2, y: 2, theta: 0.2}"'
        ]],
        shell=True
    )
    change_background_r = ExecuteProcess(
        cmd=[[
            'ros2 param set ',
            turtlesim_ns,
            '/sim background_r ',
            '120'
        ]],
        shell=True
    )
    change_background_r_conditioned = ExecuteProcess(
        condition=IfCondition(
            PythonExpression([
                new_background_r_value,
                ' == 200',
                ' and ',
                use_provided_red
            ])
        ),
        cmd=[[
            'ros2 param set ',
            turtlesim_ns_value,
            '/sim background_r ',
            new_background_r
        ]],
        shell=True
    )

    return LaunchDescription([
        turtlesim_ns_launch_arg,
        use_provided_red_launch_arg,
        new_background_r_launch_arg,
        turtlesim_node,
        spawn_turtle,
        change_background_r,
        TimerAction(
            period=2.0,
            actions=[change_background_r_conditioned],
        )
    ])

Build the workspace and run turtlesim_controller_param_launch.py:

cd ros2_ws
colcon build --symlink-install
ros2 launch ros2_course turtlesim_controller_param_launch.py

Let's list the arguments of the new launch file:

ros2 launch ros2_course turtlesim_controller_param_launch.py --show-args

Run the launch file by setting the arguments:

ros2 launch ros2_course turtlesim_controller_param_launch.py speed:=100.0 omega:=60.0

5. Using the above example, let's set the background color also using command line argument(s).

5: Rosbag

While the program implemented in the previous exercise is running, record the contents of the topics in a rosbag file.
```
    ros2 bag record --all
```
Syntax

The filename and the topics to record can also be set, e.g.:
```
ros2 bag record -o turtle_bagfile_1 /turtle1/cmd_vel /turtle1/pose
```
Use the following command to query the properties of the bag file:
```
ros2 bag info <PATH_TO_BAGFILE>
```
Play back the bag file and plot the pose/x value of one of the turtles on a graph using rqt_gui.
```
ros2 bag info <PATH_TO_BAGFILE>
```
```
ros2 run rqt_gui rqt_gui
```