Lecture4. ROS 2 Node and Parameter Programming

cd ~/ros2_ws/src
git clone https://github.com/RB2023ROS/du2023-ros2.git

# 빌드는 항상 WS의 최상단 디렉토리에서 진행합니다!!!
cd ~/ros2_ws
cbp py_node_tutorial
# or
colcon build --packages-select py_node_tutorial

# 빌드 후 항상 소싱!!!
cd ~/ros2_ws
rosfoxy
# or
source install/local_setup.bash

$ ros2 run py_node_tutorial example_node_1
[INFO] [1680692820.096342214] [example_node_1]:
==== Hello ROS 2 ====

# !/usr/bin/env python3

import rclpy
from rclpy.node import Node

if __name__ == '__main__':
    """main function"""
    main()

def main(args=None):
    """Do enter into this main function first."""
    rclpy.init(args=args)

    node = Node('node_name')
    node.get_logger().info('\n==== Hello ROS 2 ====')
    node.destroy_node()

    rclpy.shutdown()

		entry_points={
        'console_scripts': [
            'example_node_1 = py_node_tutorial.node_example_1:main',
            'example_node_2 = py_node_tutorial.node_example_2:main',
            'example_node_3 = py_node_tutorial.node_example_3:main',
            'example_node_4 = py_node_tutorial.node_example_4:main',
            'example_node_5 = py_node_tutorial.node_example_5:main',
        ],
    },

$ ros2 run py_node_tutorial example_node_2
==== Hello ROS 2 : 1====
==== Hello ROS 2 : 2====
==== Hello ROS 2 : 3====
==== Hello ROS 2 : 4====
==== Hello ROS 2 : 5====

def timer_callback():
    """Timer will run this function periodically."""
    global count
    count += 1
    print(f'==== Hello ROS 2 : {count}====')

def main(args=None):
    """Do enter into this main function first."""
    rclpy.init(args=args)

    node = Node('node_name')
    node.create_timer(0.2, timer_callback)
    rclpy.spin(node)

    node.destroy_node()

    rclpy.shutdown()

$ ros2 run py_node_tutorial example_node_3
==== Hello ROS 2 : 1====
==== Hello ROS 2 : 2====
==== Hello ROS 2 : 3====
...

def main(args=None):
    """Do enter into this main function first."""
    rclpy.init(args=args)

    node = Node('node_name')
    node.create_timer(0.2, timer_callback)

    # 1. spin_once() will run node only once.
    # timeout_sec: Seconds to wait.
    # Block forever if ``None`` or negative. Don't wait if 0.
    rclpy.spin_once(node, timeout_sec=10)

    # # 2. spin() will run node until Ctrl+C.
    rclpy.spin(node)

    # # 3. spin_once() with while loop will run node periodically.
    while True:
        rclpy.spin_once(node, timeout_sec=10)

    node.destroy_node()

    rclpy.shutdown()

$ ros2 run py_node_tutorial example_node_4
[INFO] [1657348011.971419700] [composition_example_node]: ==== Hello ROS 2 : 1====
[INFO] [1657348012.163466100] [composition_example_node]: ==== Hello ROS 2 : 2====
[INFO] [1657348012.363590700] [composition_example_node]: ==== Hello ROS 2 : 3====

class NodeClass(Node):
    """Second Node Class.
    Just print log periodically.
    """

    def __init__(self):
        """Node Initialization.
        You must type name of the node in inheritanced initializer.
        """
        super().__init__('composition_example_node')
        self.create_timer(0.2, self.timer_callback)

        self._count = 1

    def timer_callback(self):
        """Timer will run this function periodically."""
        self.get_logger().info(f'==== Hello ROS 2 : {self._count}====')
        self._count += 1

		super().__init__('node_name')
		...
    node.get_logger().info('\n==== Hello ROS 2 ====')

$ ros2 run py_node_tutorial example_node_5
[INFO] [1657348108.163389800] [node_name]: ==== Hello ROS 2 : 1====
[WARN] [1657348108.163810900] [node_name]: ==== Hello ROS 2 : 1====
[ERROR] [1657348108.164126200] [node_name]: ==== Hello ROS 2 : 1====
[FATAL] [1657348108.164514300] [node_name]: ==== Hello ROS 2 : 1====
...

$ colcon build --packages-select py_param_tutorial
$ source install/local_setup.bash
$ ros2 run py_param_tutorial param_example
[INFO] [1672390971.030532687] [param_ex_node]:
string_param: world
int_param: 119
float_param: 3.1415
arr_param: [1, 2, 3]
nested_param.string_param: Wee Woo

$ ros2 param list
/param_ex_node:
  arr_param
  float_param
  int_param
  nested_param.string_param
  string_param
  use_sim_time

$ ros2 param get /param_ex_node arr_param
Integer values are: array('q', [1, 2, 3])

$ ros2 param set /param_ex_node arr_param '[1,2,3,4]'
Set parameter successful

$ ros2 param get /param_ex_node arr_param
Integer values are: array('q', [1, 2, 3, 4])

class ParamExNode(rclpy.node.Node):
    def __init__(self):
        super().__init__('param_ex_node')

        self.declare_parameter('string_param', 'world')
        self.declare_parameter('int_param', 119)
        self.declare_parameter('float_param', 3.1415)
        self.declare_parameter('arr_param', [1,2,3])
        self.declare_parameter('nested_param.string_param', 'Wee Woo')

		string_param = self.get_parameter('string_param')
    int_param = self.get_parameter('int_param')
    float_param = self.get_parameter('float_param')
    arr_param = self.get_parameter('arr_param')
    nested_param = self.get_parameter('nested_param.string_param')

    self.get_logger().info(f"\nstring_param: {string_param.value} \
        \nint_param: {int_param.value} \
        \nfloat_param: {float_param.value} \
        \narr_param: {arr_param.value} \
        \nnested_param.string_param: {nested_param.value}"
    )

$ ros2 launch py_param_tutorial launch_with_param.launch.py
...
[param_example-1] [INFO] [1672387864.135213913] [param_example]:
[param_example-1] string_param: Hello
[param_example-1] int_param: 112
[param_example-1] float_param: 3.1415
[param_example-1] arr_param: [1, 2, 3]

$ ros2 launch py_param_tutorial launch_with_yaml.launch.py
...
[param_example-1] [INFO] [1680857428.211772092] [param_example]:
[param_example-1] string_param: Yaml Yaml
[param_example-1] int_param: 5
[param_example-1] float_param: 3.14
[param_example-1] arr_param: ['I', 'love', 'ROS 2']
[param_example-1] nested_param.string_param: Ooh Wee

def generate_launch_description():

    param_ex_node = Node(
        package='py_param_tutorial',
        executable='param_example',
        name='param_example',
        output='screen',
        parameters=[
            {'string_param': 'Hello'},
            {'int_param': 112},
        ],
    )

def generate_launch_description():

    config = os.path.join(
        get_package_share_directory('py_param_tutorial'), 'config', 'params.yaml'
    )

    param_ex_node = Node(
        package = 'py_param_tutorial',
        executable = 'param_example',
        name = 'param_example',
        output='screen',
        parameters = [config]
    )

    return LaunchDescription([
        param_ex_node
    ])

<node-name>:
	ros__parameters:
		<param-name>: <param-value>
		...
		<nested-layer-name>:
			<param-name>: <param-value>

param_example:
  ros__parameters:
    string_param: "Yaml Yaml"
    int_param: 5
    float_param: 3.14
    arr_param: ['I', 'love', 'ROS 2']
    nested_param:
      string_param: "Ooh Wee"

import os
from glob import glob
from setuptools import setup

package_name = 'py_param_tutorial'

setup(
    name=package_name,
    version='0.0.0',
    packages=[package_name],
    data_files=[
        ('share/ament_index/resource_index/packages',
            ['resource/' + package_name]),
        ('share/' + package_name, ['package.xml']),
        (os.path.join('share', package_name, 'config'), glob('config/*.yaml')),
        (os.path.join('share', package_name, 'launch'), glob('launch/*.launch.py')),
    ],

		param_ex_node = Node(
        package = 'py_param_tutorial',
				# namespace 지정!
        namespace = 'robot1',
        executable = 'param_example',
        name = 'param_example',
        output='screen',
        parameters = [config]
    )

$ ros2 launch py_param_tutorial launch_with_yaml.launch.py
...
[param_example-1] [INFO] [1680861992.330212575] [robot1.param_example]:
[param_example-1] string_param: world
[param_example-1] int_param: 119
[param_example-1] float_param: 3.1415
[param_example-1] arr_param: [1, 2, 3]
[param_example-1] nested_param.string_param: Wee Woo

robot1/param_example:
  ros__parameters:
    string_param: "Yaml Yaml"
    int_param: 5
    float_param: 3.14
    arr_param: ['I', 'love', 'ROS 2']
    nested_param:
      string_param: "Ooh Wee"

/**:
  ros__parameters:
    string_param: "Namespaced Param"
    int_param: 10
    float_param: 2.718
    arr_param: ['I', 'absolutely', 'love', 'ROS 2']
    nested_param:
      string_param: "Yeah Hee"

$ ros2 launch py_param_tutorial launch_with_namespace.launch.py
...
[param_example-1] [INFO] [1680862245.965886805] [robot1.param_example]:
[param_example-1] string_param: Namespaced Param
[param_example-1] int_param: 10
[param_example-1] float_param: 2.718
[param_example-1] arr_param: ['I', 'absolutely', 'love', 'ROS 2']
[param_example-1] nested_param.string_param: Yeah Hee

# 빌드는 항상 WS의 최상단 디렉토리에서 진행합니다!!!
cd ~/ros2_ws
cbp cpp_node_tutorial
# or
colcon build --packages-select cpp_node_tutorial

# 빌드 후 항상 소싱!!!
cd ~/ros2_ws
rosfoxy
# or
source install/local_setup.bash

$ ros2 run cpp_node_tutorial example_node_1
[INFO] [1680692820.096342214] [example_node_1]:
==== Hello ROS 2 ====

find_package(rclcpp REQUIRED)

add_executable(test_node src/test.cpp)
ament_target_dependencies(test_node rclcpp)

install(
TARGETS
test_node
DESTINATION
lib/${PROJECT_NAME}
)

# 빌드는 항상 WS의 최상단 디렉토리에서 진행합니다!!!
cd ~/ros2_ws
cbp cpp_node_tutorial
# or
colcon build --packages-select cpp_node_tutorial

# 빌드 후 항상 소싱!!!
cd ~/ros2_ws
rosfoxy
# or
source install/local_setup.bash

# 새롭게 빌드한 예시 실행
$ ros2 run cpp_node_tutorial test_node
[INFO] [1681299676.469101345] [example_node_1]: ==== Hello ROS 2 ====

#include <rclcpp/rclcpp.hpp>

int main(int argc, char **argv) {
  // Initialize ROS 2
  rclcpp::init(argc, argv);

  // Create a node
  auto node = rclcpp::Node::make_shared("example_node_1");

  // Log a message
  RCLCPP_INFO(node->get_logger(), "==== Hello ROS 2 ====");

  // Shutdown ROS 2
  rclcpp::shutdown();
  return 0;
}

#include "rclcpp/rclcpp.hpp"

using namespace std::chrono_literals;

static int count = 0;

void timer_callback(){
  std::cout << "==== Hello ROS 2 : " << count << " ====" << std::endl;
  count++;
}

int main(int argc, char **argv) {
  rclcpp::init(argc, argv);
  auto node = rclcpp::Node::make_shared("example_node_2");
  auto timer = node->create_wall_timer(200ms, timer_callback);

  rclcpp::spin(node);

  rclcpp::shutdown();
  return 0;
}

auto node => std::shared_ptr<rclcpp::Node>
auto timer => std::shared_ptr<rclcpp::Timer>

#include "rclcpp/rclcpp.hpp"

class NodeClass: public rclcpp::Node {
public:
  NodeClass(): Node("example_node_4") {}
};

int main(int argc, char **argv) {
  rclcpp::init(argc, argv);

  auto node = std::make_shared<NodeClass>();
  RCLCPP_INFO(node->get_logger(), "==== Hello ROS 2 ====");

  rclcpp::shutdown();
  return 0;
}

class NodeClass: public rclcpp::Node {
public:
  NodeClass(): Node("example_node_4") {}
};

RCLCPP_INFO(node->get_logger(), "==== Hello ROS 2 ====");

auto node = std::make_shared<NodeClass>();

class NodeClass: public rclcpp::Node {
private:
  size_t count;
  rclcpp::TimerBase::SharedPtr timer;

  void timer_callback() {
    RCLCPP_INFO(this->get_logger(), "==== Hello ROS 2 : %d ====", count);
    count++;
  }

public:
  NodeClass() : Node("example_node_5") {
    timer = this->create_wall_timer(
      std::chrono::milliseconds(200),
      // timer_callback,
      std::bind(&NodeClass::timer_callback, this)
    );
  }
};

int main(int argc, char **argv) {
  rclcpp::init(argc, argv);

  auto node = std::make_shared<NodeClass>();
  rclcpp::spin(node);

  rclcpp::shutdown();
  return 0;
}

rclcpp::spin(node);

rclcpp::TimerBase::SharedPtr timer;

class NodeClass: public rclcpp::Node {
private:
  size_t count;
  rclcpp::TimerBase::SharedPtr timer;

  void timer_callback() {
    RCLCPP_DEBUG(this->get_logger(), "==== Hello ROS 2 : %d ====", count);
    RCLCPP_INFO(this->get_logger(), "==== Hello ROS 2 : %d ====", count);
    RCLCPP_WARN(this->get_logger(), "==== Hello ROS 2 : %d ====", count);
    RCLCPP_ERROR(this->get_logger(), "==== Hello ROS 2 : %d ====", count);
    RCLCPP_FATAL(this->get_logger(), "==== Hello ROS 2 : %d ====", count);
    count++;
  }

public:
  NodeClass() : Node("example_node_5") {
    timer = this->create_wall_timer(
      std::chrono::milliseconds(200),
      std::bind(&NodeClass::timer_callback, this)
    );
  }
};

int main(int argc, char **argv) {
  rclcpp::init(argc, argv);

  auto node = std::make_shared<NodeClass>();
  rclcpp::spin(node);

  rclcpp::shutdown();
  return 0;
}

RCLCPP_DEBUG(this->get_logger(), "==== Hello ROS 2 : %d ====", count);
RCLCPP_INFO(this->get_logger(), "==== Hello ROS 2 : %d ====", count);
RCLCPP_WARN(this->get_logger(), "==== Hello ROS 2 : %d ====", count);
RCLCPP_ERROR(this->get_logger(), "==== Hello ROS 2 : %d ====", count);
RCLCPP_FATAL(this->get_logger(), "==== Hello ROS 2 : %d ====", count);

$ colcon build --packages-select cpp_param_tutorial
$ source install/local_setup.bash

$ ros2 run cpp_param_tutorial cpp_param_example
[INFO] [1681300487.037502527] [param_ex_node]:
str: world
int: 119
double: 3.141500
arr: [1, 2, 3]
nested: Wee Woo

class ParamExNode : public rclcpp::Node
{
public:
    ParamExNode() : Node("param_ex_node") {

        this->declare_parameter("string_param", "world");
				...
        rclcpp::Parameter str_param = this->get_parameter("string_param");
        ...
        std::string my_str = str_param.as_string();

this->declare_parameter("string_param", "world");
auto my_str = this->get_parameter("string_param").as_string();

$ ros2 launch cpp_param_tutorial launch_with_yaml.launch.py
...
[cpp_param_example-1] [INFO] [1681301614.005450889] [param_example]:
[cpp_param_example-1] str: Yaml Yaml
[cpp_param_example-1] int: 5
[cpp_param_example-1] double: 3.141500
[cpp_param_example-1] arr: [1, 2, 3]
[cpp_param_example-1] nested: Ooh Wee