MakingRobot

Odometry 프로그래밍

MakingRobotWizard — Fri, 5 Jun 2026 00:18:10 +0900

1. ROS 2 모바일 로봇 전체 흐름

차동구동 로봇에서 ROS 2 제어 흐름은 보통 다음과 같습니다.

사용자 / Teleop / Nav2
        ↓
/cmd_vel
geometry_msgs/msg/Twist
        ↓
차동구동 역기구학
        ↓
왼쪽 바퀴 속도, 오른쪽 바퀴 속도
        ↓
모터 드라이버 / MCU / OpenCR / ros2_control
        ↓
바퀴 회전
        ↓
엔코더 피드백
        ↓
거리 변환
        ↓
Odometry 계산
        ↓
/odom
nav_msgs/msg/Odometry
        ↓
odom → base_link TF
        ↓
RViz2 / Nav2 / SLAM / Localization

먼저 아래와 같은 ROS 2 토픽을 이해해야 합니다.

토픽 메시지 타입 의미

/cmd_vel	geometry_msgs/msg/Twist	로봇 속도 명령
/odom	nav_msgs/msg/Odometry	로봇 위치/자세/속도 추정
/tf	tf2_msgs/msg/TFMessage	동적 좌표 변환
/tf_static	tf2_msgs/msg/TFMessage	고정 좌표 변환
/joint_states	sensor_msgs/msg/JointState	바퀴 조인트 상태
/scan	sensor_msgs/msg/LaserScan	LiDAR 데이터
/imu/data	sensor_msgs/msg/Imu	IMU 데이터

2. ROS 좌표계: odom, base_link, map

ROS 2 모바일 로봇에서 가장 기본적인 TF(Transform, 좌표계 변환 시스템) 구조는 다음과 같습니다.

map
 └── odom
      └── base_link
           ├── laser
           ├── imu_link
           └── wheel_link

아래의 연결을 이해하는 것이 중요합니다.

odom → base_link

odom

odom은 로봇이 출발한 지점 기준으로 부드럽게 이어지는 로컬 좌표계입니다.

특징:

연속적이다.
갑자기 튀면 안 된다.
시간이 지나면 drift가 생긴다.

base_link

base_link는 로봇 본체 중심 좌표계입니다.

ROS 모바일 로봇의 기본 방향은 다음과 같습니다.

x축: 로봇 전방
y축: 로봇 왼쪽
z축: 위쪽

map

map은 전역 지도 좌표계입니다. SLAM 또는 AMCL이 map → odom 변환을 보정합니다.

정리하면:

odom → base_link : 엔코더/IMU 기반 로컬 오도메트리
map → odom       : SLAM/AMCL 기반 전역 위치 보정

이 구조를 깨면 Nav2가 제대로 동작하지 않습니다.

3. /cmd_vel 메시지 이해

ROS 2에서 모바일 로봇 속도 명령은 보통 /cmd_vel 토픽으로 보냅니다.

메시지 타입은 다음입니다.

ros2 interface show geometry_msgs/msg/Twist

구조는 다음과 같습니다.

Vector3 linear
Vector3 angular

차동구동 로봇에서는 보통 두 값만 씁니다.

linear.x   : 전진/후진 속도 [m/s]
angular.z  : 좌회전/우회전 각속도 [rad/s]

예를 들어:

ros2 topic pub /cmd_vel geometry_msgs/msg/Twist "{
  linear: {x: 0.2, y: 0.0, z: 0.0},
  angular: {x: 0.0, y: 0.0, z: 0.5}
}"

의미는 다음입니다.

전진 속도 v = 0.2 m/s
회전 속도 omega = 0.5 rad/s

즉 로봇은 앞으로 가면서 왼쪽으로 회전합니다.

4. 엔코더 기반 Odometry 유도

이제 엔코더 tick에서 로봇 위치를 계산하는 과정을 보겠습니다.

1) tick을 거리로 변환

왼쪽과 오른쪽 엔코더 누적 tick이 있다고 가정합니다.

$$
left\_ticks,\quad right\_ticks
$$

이전 주기의 tick과 비교해서 변화량을 구합니다.

$$
\Delta left\_ticks = left\_ticks - prev\_left\_ticks
$$

$$
\Delta right\_ticks = right\_ticks - prev\_right\_ticks
$$

tick 하나당 이동 거리는 다음과 같습니다.

$$
meter\_per\_tick = \frac{2\pi r}{ticks\_per\_revolution}
$$

왼쪽, 오른쪽 바퀴 이동 거리는 다음과 같습니다.

$$
d_l = \Delta left\_ticks \times meter\_per\_tick
$$

$$
d_r = \Delta right\_ticks \times meter\_per\_tick
$$

2) 로봇 중심 이동 거리

로봇 중심 이동 거리는 좌우 바퀴 이동 거리의 평균입니다.

$$
d_{center} = \frac{d_r + d_l}{2}
$$

3) 방향 변화량

로봇의 yaw 변화량은 좌우 바퀴 이동 거리 차이를 바퀴 간 거리로 나눈 값입니다.

$$
\Delta \theta = \frac{d_r - d_l}{L}
$$

오른쪽 바퀴가 더 많이 이동하면 다음과 같습니다.

$$
d_r > d_l
$$

$$
\Delta \theta > 0
$$

ROS 좌표계 기준으로 yaw가 증가하므로 반시계 방향, 즉 왼쪽 회전입니다.

4) $x$, $y$, $\theta$ 업데이트

현재 상태가 다음이라고 하겠습니다.

$$
x,\quad y,\quad \theta
$$

한 주기 동안 이동 후 상태는 다음처럼 갱신합니다.

$$
x_{new} = x + d_{center}\cos\left(\theta + \frac{\Delta \theta}{2}\right)
$$

$$
y_{new} = y + d_{center}\sin\left(\theta + \frac{\Delta \theta}{2}\right)
$$

$$
\theta_{new} = \theta + \Delta \theta
$$

여기서 다음 항을 쓰는 이유가 중요합니다.

$$
\theta + \frac{\Delta \theta}{2}
$$

로봇은 한 주기 동안 직선으로만 이동하지 않습니다. 회전하면서 조금씩 곡선을 그립니다. 시작 방향 $\theta$만 쓰면 오차가 커질 수 있습니다. 그래서 이동 중간 방향을 사용합니다.

이 방식은 차동구동 odometry에서 가장 많이 쓰는 기본 적분 방식입니다.

5. 인터페이스 패키지에 EncoderTicks 메시지 추가

먼저 my_first_package_msgs에 다음 메시지를 추가합니다.

파일 경로:

~/ros2_study/src/my_first_package_msgs/msg/EncoderTicks.msg

내용:

int64 left_ticks
int64 right_ticks

package.xml에 메시지 빌드 의존성이 필요합니다. 이미 추가되어 있으면 생략합니다.

<buildtool_depend>ament_cmake</buildtool_depend>

<build_depend>rosidl_default_generators</build_depend>
<exec_depend>rosidl_default_runtime</exec_depend>

<member_of_group>rosidl_interface_packages</member_of_group>

CMakeLists.txt에는 다음을 추가합니다.

find_package(ament_cmake REQUIRED)
find_package(rosidl_default_generators REQUIRED)

rosidl_generate_interfaces(${PROJECT_NAME}
  "msg/EncoderTicks.msg"
)

ament_package()

빌드 후에는 다음 타입을 사용할 수 있습니다.

my_first_package_msgs/msg/EncoderTicks

6. /cmd_vel을 좌우 바퀴 속도로 변환하는 Python 노드

/cmd_vel은 로봇 중심 기준 속도 명령입니다.
하지만 실제 모터 드라이버는 왼쪽 바퀴와 오른쪽 바퀴 명령을 따로 받아야 합니다.

그래서 첫 번째로 해야 할 일은 cmd_vel을 좌우 바퀴 속도로 변환하는 것입니다.

/cmd_vel
   ↓
left wheel velocity
right wheel velocity

입력은 로봇의 목표 속도입니다.

$$
\text{입력} = v,\ \omega
$$

출력은 좌우 바퀴 속도입니다.

$$
\text{출력} = v_l,\ v_r
$$

차동 로봇의 기본 역기구학 식은 다음과 같습니다.

$$
v_r = v + \frac{\omega L}{2}
$$

$$
v_l = v - \frac{\omega L}{2}
$$

바퀴 선속도가 아니라 모터 각속도가 필요하다면 다음처럼 바꿉니다.

$$
\omega_r = \frac{v_r}{r}
$$

$$
\omega_l = \frac{v_l}{r}
$$

따라서 다음과 같이 정리할 수 있습니다.

$$
\omega_r = \frac{v + \frac{\omega L}{2}}{r}
$$

$$
\omega_l = \frac{v - \frac{\omega L}{2}}{r}
$$

파일 경로:

~/ros2_study/src/my_first_package/my_first_package/cmd_vel_to_wheel.py

소스 코드:

import rclpy
from rclpy.node import Node

from geometry_msgs.msg import Twist
from std_msgs.msg import Float64MultiArray


class CmdVelToWheel(Node):
    def __init__(self):
        super().__init__('cmd_vel_to_wheel')

        self.declare_parameter('wheel_radius', 0.033)
        self.declare_parameter('wheel_separation', 0.30)

        self.wheel_radius = self.get_parameter('wheel_radius').value
        self.wheel_separation = self.get_parameter('wheel_separation').value

        self.sub_cmd_vel = self.create_subscription(
            Twist,
            '/cmd_vel',
            self.cmd_vel_callback,
            10
        )

        self.pub_wheel_velocity = self.create_publisher(
            Float64MultiArray,
            '/wheel_velocity',
            10
        )

        self.get_logger().info('cmd_vel_to_wheel node started')
        self.get_logger().info(f'wheel_radius: {self.wheel_radius} m')
        self.get_logger().info(f'wheel_separation: {self.wheel_separation} m')

    def cmd_vel_callback(self, msg: Twist):
        linear_x = msg.linear.x
        angular_z = msg.angular.z

        left_linear_velocity = (
            linear_x - angular_z * self.wheel_separation / 2.0
        )

        right_linear_velocity = (
            linear_x + angular_z * self.wheel_separation / 2.0
        )

        left_angular_velocity = left_linear_velocity / self.wheel_radius
        right_angular_velocity = right_linear_velocity / self.wheel_radius

        out = Float64MultiArray()
        out.data = [
            left_linear_velocity,
            right_linear_velocity,
            left_angular_velocity,
            right_angular_velocity
        ]

        self.pub_wheel_velocity.publish(out)

        self.get_logger().info(
            'cmd_vel '
            f'linear.x={linear_x:.3f} m/s, '
            f'angular.z={angular_z:.3f} rad/s | '
            f'left={left_linear_velocity:.3f} m/s, '
            f'right={right_linear_velocity:.3f} m/s | '
            f'left_w={left_angular_velocity:.3f} rad/s, '
            f'right_w={right_angular_velocity:.3f} rad/s'
        )


def main(args=None):
    rclpy.init(args=args)
    node = CmdVelToWheel()
    rclpy.spin(node)
    node.destroy_node()
    rclpy.shutdown()


if __name__ == '__main__':
    main()

/cmd_vel에서 받은 linear.x는 로봇의 전진 속도이고, angular.z는 회전 속도입니다. 이 값을 이용해 좌우 바퀴의 선속도를 계산합니다.

left_linear_velocity = linear_x - angular_z * wheel_separation / 2.0
right_linear_velocity = linear_x + angular_z * wheel_separation / 2.0

이후 각 바퀴의 선속도를 바퀴 반지름으로 나누어 바퀴의 각속도(rad/s)로 변환합니다.

left_angular_velocity = left_linear_velocity / wheel_radius
right_angular_velocity = right_linear_velocity / wheel_radius

최종적으로 /wheel_velocity 토픽에는 다음 순서로 데이터가 발행됩니다.

[
    left_linear_velocity,
    right_linear_velocity,
    left_angular_velocity,
    right_angular_velocity
]

즉, 이 노드는 상위 제어기나 키보드 조종 노드에서 생성한 /cmd_vel 명령을 실제 좌우 바퀴 제어에 사용할 수 있는 속도 값으로 변환하는 역할을 합니다. 차동구동 모바일 로봇의 모터 제어 전단에서 사용하기 적합한 기본 변환 노드입니다.

setup.py의 entry_points에 추가합니다.

entry_points={
    'console_scripts': [
        'cmd_vel_to_wheel = my_first_package.cmd_vel_to_wheel:main',
    ],
},

예를 들어 다음 명령이 들어왔다고 가정합니다.

linear.x  = 0.3 m/s
angular.z = 0.5 rad/s
wheel_radius = 0.033 m
wheel_separation = 0.30 m

계산 결과는 다음과 비슷합니다.

left_linear_velocity  ≈ 0.225 m/s
right_linear_velocity ≈ 0.375 m/s

left_angular_velocity  ≈ 6.818 rad/s
right_angular_velocity ≈ 11.364 rad/s

오른쪽 바퀴가 더 빠르므로 로봇은 왼쪽으로 회전합니다.

7. 가상 Encoder Tick 발행 노드 만들기

실제 로봇에서는 엔코더 tick이 MCU, 모터 드라이버, ros2_control hardware interface 등을 통해 들어옵니다.

먼저 가상 엔코더 tick을 발행해서 odometry 원리를 이해하려고 합니다.

fake_encoder_node
        ↓
/encoder_ticks

파일 경로:

~/ros2_study/src/my_first_package/my_first_package/fake_encoder_node.py

코드:

import rclpy
from rclpy.node import Node

from my_first_package_msgs.msg import EncoderTicks


class FakeEncoderNode(Node):
    def __init__(self):
        super().__init__('fake_encoder_node')

        self.publisher = self.create_publisher(
            EncoderTicks,
            '/encoder_ticks',
            10
        )

        self.left_ticks = 0
        self.right_ticks = 0

        self.declare_parameter('left_tick_step', 5)
        self.declare_parameter('right_tick_step', 5)
        self.declare_parameter('period', 0.05)

        self.left_tick_step = self.get_parameter('left_tick_step').value
        self.right_tick_step = self.get_parameter('right_tick_step').value
        self.period = self.get_parameter('period').value

        self.timer = self.create_timer(self.period, self.timer_callback)

        self.get_logger().info('fake_encoder_node started')

    def timer_callback(self):
        self.left_ticks += int(self.left_tick_step)
        self.right_ticks += int(self.right_tick_step)

        msg = EncoderTicks()
        msg.left_ticks = self.left_ticks
        msg.right_ticks = self.right_ticks

        self.publisher.publish(msg)

        self.get_logger().info(
            f'left_ticks={self.left_ticks}, '
            f'right_ticks={self.right_ticks}'
        )


def main(args=None):
    rclpy.init(args=args)
    node = FakeEncoderNode()
    rclpy.spin(node)
    node.destroy_node()
    rclpy.shutdown()


if __name__ == '__main__':
    main()

노드가 실행되면 내부 변수 left_ticks, right_ticks가 0에서 시작합니다. 이후 타이머가 period 주기마다 실행되며, 각 tick 값에 설정된 증가량을 더합니다.

self.left_ticks += int(self.left_tick_step)
self.right_ticks += int(self.right_tick_step)

증가된 엔코더 값은 EncoderTicks 메시지에 담겨 /encoder_ticks 토픽으로 발행됩니다.

msg.left_ticks = self.left_ticks
msg.right_ticks = self.right_ticks

즉, 이 노드는 실제 엔코더 없이도 엔코더 데이터가 계속 들어오는 것처럼 테스트할 수 있게 해주는 가상 엔코더 발행 노드입니다. 주로 오도메트리 계산 노드, 속도 계산 노드, 바퀴 제어 알고리즘을 검증할 때 사용할 수 있습니다.

setup.py에 추가합니다.

entry_points={
    'console_scripts': [
        'cmd_vel_to_wheel = my_first_package.cmd_vel_to_wheel:main',
        'fake_encoder_node = my_first_package.fake_encoder_node:main',
    ],
},

기본값은 왼쪽과 오른쪽 tick이 똑같이 증가합니다.

left_ticks  += 5
right_ticks += 5

이 경우 로봇은 직진하는 상황입니다.

오른쪽을 더 빠르게 만들면 다음과 같습니다.

left_ticks  += 3
right_ticks += 7

이 경우 오른쪽 바퀴 이동량이 더 크므로 로봇은 왼쪽으로 회전합니다.

제자리 회전은 다음과 같습니다.

left_ticks  -= 5
right_ticks += 5

이 경우 중심 이동거리는 거의 0이고 회전각만 증가합니다.

8. Encoder Tick을 거리로 변환하는 Python 노드

엔코더 tick은 그 자체로는 거리 단위가 아닙니다.

바퀴 반지름과 바퀴 1회전당 tick 수를 알아야 실제 이동거리로 바꿀 수 있습니다.

바퀴 둘레는 다음 식으로 표현됩니다.

wheel_circumference = 2πr

tick 하나당 이동거리는 다음입니다.

meter_per_tick = 2πr / ticks_per_revolution

왼쪽, 오른쪽 바퀴 이동거리는 다음입니다.

d_left  = Δleft_ticks  × meter_per_tick
d_right = Δright_ticks × meter_per_tick

파일 경로:

~/ros2_study/src/my_first_package/my_first_package/tick_to_distance.py

코드:

import math

import rclpy
from rclpy.node import Node

from std_msgs.msg import Float64MultiArray
from my_first_package_msgs.msg import EncoderTicks


class TickToDistance(Node):
    def __init__(self):
        super().__init__('tick_to_distance')

        self.declare_parameter('wheel_radius', 0.033)
        self.declare_parameter('ticks_per_revolution', 2048)

        self.wheel_radius = self.get_parameter('wheel_radius').value
        self.ticks_per_revolution = self.get_parameter(
            'ticks_per_revolution'
        ).value

        self.distance_per_tick = (
            2.0 * math.pi * self.wheel_radius
            / float(self.ticks_per_revolution)
        )

        self.prev_left_ticks = None
        self.prev_right_ticks = None

        self.sub_encoder = self.create_subscription(
            EncoderTicks,
            '/encoder_ticks',
            self.encoder_callback,
            10
        )

        self.pub_wheel_distance = self.create_publisher(
            Float64MultiArray,
            '/wheel_distance',
            10
        )

        self.get_logger().info('tick_to_distance node started')
        self.get_logger().info(f'wheel_radius: {self.wheel_radius} m')
        self.get_logger().info(
            f'ticks_per_revolution: {self.ticks_per_revolution}'
        )
        self.get_logger().info(
            f'distance_per_tick: {self.distance_per_tick:.8f} m/tick'
        )

    def encoder_callback(self, msg: EncoderTicks):
        left_ticks = msg.left_ticks
        right_ticks = msg.right_ticks

        if self.prev_left_ticks is None:
            self.prev_left_ticks = left_ticks
            self.prev_right_ticks = right_ticks
            self.get_logger().info('First encoder data received')
            return

        delta_left_ticks = left_ticks - self.prev_left_ticks
        delta_right_ticks = right_ticks - self.prev_right_ticks

        self.prev_left_ticks = left_ticks
        self.prev_right_ticks = right_ticks

        left_distance = delta_left_ticks * self.distance_per_tick
        right_distance = delta_right_ticks * self.distance_per_tick

        out = Float64MultiArray()
        out.data = [
            float(delta_left_ticks),
            float(delta_right_ticks),
            left_distance,
            right_distance
        ]

        self.pub_wheel_distance.publish(out)

        self.get_logger().info(
            f'delta_ticks L={delta_left_ticks}, R={delta_right_ticks} | '
            f'distance L={left_distance:.5f} m, '
            f'R={right_distance:.5f} m'
        )


def main(args=None):
    rclpy.init(args=args)
    node = TickToDistance()
    rclpy.spin(node)
    node.destroy_node()
    rclpy.shutdown()


if __name__ == '__main__':
    main()

먼저 바퀴 한 바퀴의 둘레를 엔코더 해상도로 나누어 tick 1개당 이동 거리를 계산합니다.

distance_per_tick = 2.0 * math.pi * wheel_radius / ticks_per_revolution

엔코더 값은 누적 tick 값으로 들어오기 때문에, 현재 tick 값에서 이전 tick 값을 빼서 변화량을 구합니다.

delta_left_ticks = left_ticks - self.prev_left_ticks
delta_right_ticks = right_ticks - self.prev_right_ticks

이후 tick 변화량에 distance_per_tick을 곱해 좌우 바퀴의 이동 거리를 계산합니다.

left_distance = delta_left_ticks * self.distance_per_tick
right_distance = delta_right_ticks * self.distance_per_tick

최종적으로 /wheel_distance 토픽에는 다음 순서로 데이터가 발행됩니다.

[
    delta_left_ticks,
    delta_right_ticks,
    left_distance,
    right_distance
]

첫 번째 엔코더 데이터는 이전 값이 없기 때문에 기준값으로만 저장하고 거리 계산은 하지 않습니다. 두 번째 데이터부터 실제 tick 변화량과 이동 거리를 계산합니다.

즉, 이 노드는 엔코더의 누적 tick 값을 실제 바퀴 이동 거리로 변환하는 역할을 합니다. 차동구동 로봇에서 오도메트리 계산, 주행 거리 추정, 속도 계산 노드의 전단에 사용하기 적합합니다.

setup.py에 추가합니다.

entry_points={
    'console_scripts': [
        'cmd_vel_to_wheel = my_first_package.cmd_vel_to_wheel:main',
        'fake_encoder_node = my_first_package.fake_encoder_node:main',
        'tick_to_distance = my_first_package.tick_to_distance:main',
    ],
},

예를 들어 다음 조건이라고 가정합니다.

wheel_radius = 0.033 m
ticks_per_revolution = 2048
delta_ticks = 100

계산 결과는 다음과 같습니다.

distance_per_tick ≈ 0.0001012 m/tick
100 ticks         ≈ 0.01012 m

좌우 이동거리가 같으면 직진입니다.

오른쪽 이동거리가 더 크면 로봇은 왼쪽으로 회전한 것으로 해석합니다.

9. Python으로 Encoder Odometry 노드 구현하기

이번에는 my_first_package에 Python 노드를 만들고, /encoder_ticks를 받아서 /odom과 /tf를 발행합니다.

/encoder_ticks
      ↓
encoder_odom_node
      ↓
/odom
/tf : odom → base_link

파일 경로 예시는 다음과 같습니다.

~/ros2_study/src/my_first_package/my_first_package/encoder_odom_node.py

1) Python 코드

import math

import rclpy
from rclpy.node import Node

from nav_msgs.msg import Odometry
from geometry_msgs.msg import TransformStamped
from tf2_ros import TransformBroadcaster

from my_first_package_msgs.msg import EncoderTicks


class EncoderOdomNode(Node):
    def __init__(self):
        super().__init__('encoder_odom_node')

        self.declare_parameter('wheel_radius', 0.033)
        self.declare_parameter('wheel_separation', 0.30)
        self.declare_parameter('ticks_per_revolution', 2048)
        self.declare_parameter('odom_frame_id', 'odom')
        self.declare_parameter('base_frame_id', 'base_link')
        self.declare_parameter('publish_tf', True)

        self.wheel_radius = self.get_parameter('wheel_radius').value
        self.wheel_separation = self.get_parameter('wheel_separation').value
        self.ticks_per_revolution = self.get_parameter(
            'ticks_per_revolution'
        ).value

        self.odom_frame_id = self.get_parameter('odom_frame_id').value
        self.base_frame_id = self.get_parameter('base_frame_id').value
        self.publish_tf = self.get_parameter('publish_tf').value

        self.distance_per_tick = (
            2.0 * math.pi * self.wheel_radius
            / float(self.ticks_per_revolution)
        )

        self.prev_left_ticks = 0
        self.prev_right_ticks = 0
        self.prev_time = None
        self.has_prev_ticks = False

        self.x = 0.0
        self.y = 0.0
        self.theta = 0.0

        self.odom_pub = self.create_publisher(
            Odometry,
            '/odom',
            10
        )

        self.tf_broadcaster = TransformBroadcaster(self)

        self.encoder_sub = self.create_subscription(
            EncoderTicks,
            '/encoder_ticks',
            self.encoder_callback,
            10
        )

        self.get_logger().info('encoder_odom_node started')
        self.get_logger().info(f'wheel_radius: {self.wheel_radius:.4f} m')
        self.get_logger().info(
            f'wheel_separation: {self.wheel_separation:.4f} m'
        )
        self.get_logger().info(
            f'ticks_per_revolution: {self.ticks_per_revolution}'
        )
        self.get_logger().info(
            f'distance_per_tick: {self.distance_per_tick:.8f} m/tick'
        )

    def encoder_callback(self, msg: EncoderTicks):
        now = self.get_clock().now()

        left_ticks = msg.left_ticks
        right_ticks = msg.right_ticks

        if not self.has_prev_ticks:
            self.prev_left_ticks = left_ticks
            self.prev_right_ticks = right_ticks
            self.prev_time = now
            self.has_prev_ticks = True

            self.get_logger().info('First encoder data received')
            return

        dt = (now - self.prev_time).nanoseconds / 1e9

        if dt <= 0.0:
            return

        delta_left_ticks = left_ticks - self.prev_left_ticks
        delta_right_ticks = right_ticks - self.prev_right_ticks

        self.prev_left_ticks = left_ticks
        self.prev_right_ticks = right_ticks
        self.prev_time = now

        d_left = float(delta_left_ticks) * self.distance_per_tick
        d_right = float(delta_right_ticks) * self.distance_per_tick

        d_center = (d_right + d_left) * 0.5
        d_theta = (d_right - d_left) / self.wheel_separation

        heading_mid = self.theta + d_theta * 0.5

        self.x += d_center * math.cos(heading_mid)
        self.y += d_center * math.sin(heading_mid)
        self.theta += d_theta

        self.theta = math.atan2(
            math.sin(self.theta),
            math.cos(self.theta)
        )

        linear_velocity = d_center / dt
        angular_velocity = d_theta / dt

        qx = 0.0
        qy = 0.0
        qz = math.sin(self.theta * 0.5)
        qw = math.cos(self.theta * 0.5)

        self.publish_odometry(
            now,
            qx,
            qy,
            qz,
            qw,
            linear_velocity,
            angular_velocity
        )

        if self.publish_tf:
            self.publish_transform(
                now,
                qx,
                qy,
                qz,
                qw
            )

        self.get_logger().info(
            f'x={self.x:.3f}, y={self.y:.3f}, '
            f'theta={self.theta:.3f} | '
            f'v={linear_velocity:.3f} m/s, '
            f'w={angular_velocity:.3f} rad/s'
        )

    def publish_odometry(
        self,
        now,
        qx,
        qy,
        qz,
        qw,
        linear_velocity,
        angular_velocity
    ):
        odom_msg = Odometry()

        odom_msg.header.stamp = now.to_msg()
        odom_msg.header.frame_id = self.odom_frame_id
        odom_msg.child_frame_id = self.base_frame_id

        odom_msg.pose.pose.position.x = self.x
        odom_msg.pose.pose.position.y = self.y
        odom_msg.pose.pose.position.z = 0.0

        odom_msg.pose.pose.orientation.x = qx
        odom_msg.pose.pose.orientation.y = qy
        odom_msg.pose.pose.orientation.z = qz
        odom_msg.pose.pose.orientation.w = qw

        odom_msg.twist.twist.linear.x = linear_velocity
        odom_msg.twist.twist.linear.y = 0.0
        odom_msg.twist.twist.angular.z = angular_velocity

        odom_msg.pose.covariance = [
            0.001, 0.0,   0.0,   0.0,   0.0,   0.0,
            0.0,   0.001, 0.0,   0.0,   0.0,   0.0,
            0.0,   0.0,   999.0, 0.0,   0.0,   0.0,
            0.0,   0.0,   0.0,   999.0, 0.0,   0.0,
            0.0,   0.0,   0.0,   0.0,   999.0, 0.0,
            0.0,   0.0,   0.0,   0.0,   0.0,   0.01
        ]

        odom_msg.twist.covariance = [
            0.001, 0.0,   0.0,   0.0,   0.0,   0.0,
            0.0,   0.001, 0.0,   0.0,   0.0,   0.0,
            0.0,   0.0,   999.0, 0.0,   0.0,   0.0,
            0.0,   0.0,   0.0,   999.0, 0.0,   0.0,
            0.0,   0.0,   0.0,   0.0,   999.0, 0.0,
            0.0,   0.0,   0.0,   0.0,   0.0,   0.01
        ]

        self.odom_pub.publish(odom_msg)

    def publish_transform(
        self,
        now,
        qx,
        qy,
        qz,
        qw
    ):
        tf_msg = TransformStamped()

        tf_msg.header.stamp = now.to_msg()
        tf_msg.header.frame_id = self.odom_frame_id
        tf_msg.child_frame_id = self.base_frame_id

        tf_msg.transform.translation.x = self.x
        tf_msg.transform.translation.y = self.y
        tf_msg.transform.translation.z = 0.0

        tf_msg.transform.rotation.x = qx
        tf_msg.transform.rotation.y = qy
        tf_msg.transform.rotation.z = qz
        tf_msg.transform.rotation.w = qw

        self.tf_broadcaster.sendTransform(tf_msg)


def main(args=None):
    rclpy.init(args=args)

    node = EncoderOdomNode()

    try:
        rclpy.spin(node)
    except KeyboardInterrupt:
        pass

    node.destroy_node()
    rclpy.shutdown()


if __name__ == '__main__':
    main()

2) Python 패키지 설정

C++ 패키지에서는 CMakeLists.txt와 package.xml에 실행 파일과 의존성을 설정했지만, Python 패키지에서는 주로 setup.py, package.xml을 수정합니다.

my_first_package/package.xml에 다음 의존성이 필요합니다.

<depend>rclpy</depend>
<depend>nav_msgs</depend>
<depend>geometry_msgs</depend>
<depend>tf2_ros</depend>
<depend>my_first_package_msgs</depend>

Python 패키지라면 export 부분에 아래 내용도 확인합니다.

<export>
  <build_type>ament_python</build_type>
</export>

3) setup.py 설정

my_first_package/setup.py의 entry_points에 encoder_odom_node를 추가합니다.

entry_points={
    'console_scripts': [
        'fake_encoder_node = my_first_package.fake_encoder_node:main',
        'encoder_odom_node = my_first_package.encoder_odom_node:main',
    ],
},

launch 파일을 설치하려면 data_files에 launch 경로도 포함합니다.

import os
from glob import glob

그리고 data_files에 다음을 추가합니다.

(os.path.join('share', package_name, 'launch'), glob('launch/*.launch.py')),

예시는 다음과 같습니다.

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

4) Odometry 메시지 구조 이해

/odom 토픽은 일반적으로 다음 메시지 타입을 사용합니다.

nav_msgs/msg/Odometry

핵심 필드는 다음과 같습니다.

header.frame_id       = "odom"
child_frame_id        = "base_link"

pose.pose.position.x
pose.pose.position.y
pose.pose.orientation

twist.twist.linear.x
twist.twist.angular.z

pose.covariance
twist.covariance

pose와 twist는

pose  : header.frame_id 기준
twist : child_frame_id 기준

입니다. 즉, 다음처럼 해석합니다.

위치 pose  : odom 기준에서 base_link의 위치
속도 twist : base_link 기준에서 로봇의 속도

5) Odometry 계산 핵심 공식

엔코더 변화량은 다음처럼 계산합니다.

delta_left_ticks = left_ticks - self.prev_left_ticks
delta_right_ticks = right_ticks - self.prev_right_ticks

tick을 거리로 바꿉니다.

d_left = float(delta_left_ticks) * self.distance_per_tick
d_right = float(delta_right_ticks) * self.distance_per_tick

로봇 중심 이동거리와 회전량은 다음입니다.

d_center = (d_right + d_left) * 0.5
d_theta = (d_right - d_left) / self.wheel_separation

현재 자세가 x, y, theta일 때 위치 갱신은 다음입니다.

heading_mid = self.theta + d_theta * 0.5

self.x += d_center * math.cos(heading_mid)
self.y += d_center * math.sin(heading_mid)
self.theta += d_theta

heading_mid를 쓰는 이유는 로봇이 이동하면서 동시에 회전하기 때문입니다.

시작 방향이나 끝 방향 하나만 사용하는 것보다 중간 방향으로 적분하는 방식이 더 자연스럽습니다.

각도 theta는 다음 코드로 -pi ~ pi 범위로 정규화합니다.

self.theta = math.atan2(
    math.sin(self.theta),
    math.cos(self.theta)
)

atan2(y, x)는
점 (x, y)가 원점에서 볼 때 몇 도 방향인지를 알려주는 함수입니다.

여기서는

atan2(sin(theta), cos(theta))

이므로,

점 (cos(theta), sin(theta))를 보고
그 점이 가리키는 각도를 다시 구한다

는 뜻입니다.

즉,

원래 각도 theta를
원 위의 점 (cos(theta), sin(theta))로 바꾼 뒤
그 점의 각도를 다시 구합니다.

그런데 atan2()는 결과를 항상 보통 -π ~ π 범위로 돌려줍니다.

그래서 자동으로 각도가 정리됩니다.

점 P는 30도 방향에 있습니다.

atan2(sin(30°), cos(30°)) = 30°

그대로입니다.

390도는 한 바퀴(360도)를 돌고 다시 30도 방향입니다.

390° = 360° + 30°

이때도

atan2(sin(390°), cos(390°)) = 30°

가 됩니다.

즉,

390°라는 “긴 표현”을
30°라는 “정리된 표현”으로 바꾸는 것입니다.

190도는 π보다 큰 각도입니다.
원 위에서는 왼쪽 아래쪽 방향입니다.

190도는 사실 방향상으로는 -170°와 같습니다.

왜냐하면:

190° = -170° + 360°

즉 같은 방향입니다.

그래서

atan2(sin(190°), cos(190°)) = -170°

가 됩니다.

즉 atan2()는 같은 방향을 더 짧고 표준적인 범위로 표현해 줍니다.

로봇에서는 보통 -π ~ π를 많이 씁니다.
이유는 “좌회전/우회전” 해석이 직관적이기 때문입니다.

예를 들어,

+0.2 rad → 약간 반시계 방향
-0.2 rad → 약간 시계 방향

처럼 바로 해석하기 편합니다.

또한 각도 차이를 계산할 때도 더 자연스럽습니다.

6) odom → base_link TF 발행

/odom 토픽만 발행하면 위치와 속도 숫자는 확인할 수 있습니다.

하지만 RViz2, Nav2, SLAM, 센서 시각화에서는 TF가 중요합니다.

이번 Python 노드에서는 다음 TF를 발행합니다.

odom → base_link

의미는 다음과 같습니다.

odom 좌표계 기준에서 base_link가 어디에 있는가?

TF 메시지는 다음 타입을 사용합니다.

geometry_msgs/msg/TransformStamped

tf_msg.header.frame_id = self.odom_frame_id
tf_msg.child_frame_id = self.base_frame_id

tf_msg.transform.translation.x = self.x
tf_msg.transform.translation.y = self.y
tf_msg.transform.translation.z = 0.0

2D 로봇에서는 roll, pitch를 사용하지 않고 yaw만 사용합니다.

yaw를 quaternion으로 바꾸는 기본식은 다음과 같습니다.

qx = 0.0
qy = 0.0
qz = math.sin(self.theta * 0.5)
qw = math.cos(self.theta * 0.5)

7) covariance

covariance는 센서값이나 계산값의 불확실성을 의미합니다.

값이 작을수록:

이 값은 비교적 믿을 만하다

값이 클수록:

이 값은 신뢰도가 낮다

라는 의미입니다.

8) pose.covariance의 의미

odom_msg.pose.covariance = [...]

이 부분은 로봇의 위치와 자세에 대한 신뢰도를 설정합니다.

pose는 다음 6개 값에 대한 covariance를 가집니다.

x, y, z, roll, pitch, yaw

즉, 6x6 행렬입니다.

Python 코드에서는 6x6 행렬을 한 줄짜리 리스트 36개 값으로 넣습니다.

[0][0] = x 위치 신뢰도
[1][1] = y 위치 신뢰도
[2][2] = z 위치 신뢰도
[3][3] = roll 신뢰도
[4][4] = pitch 신뢰도
[5][5] = yaw 신뢰도

현재 코드에서는 대각선 값이 핵심입니다.

x     = 0.001
y     = 0.001
z     = 999.0
roll  = 999.0
pitch = 999.0
yaw   = 0.01

0.001은 비교적 신뢰, 999.0은 거의 사용하지 않음, 0.10은 어느 정도 신뢰를 의미합니다.

차동구동 로봇은 보통 2D 평면에서 움직이므로 x, y, yaw가 중요합니다.

반대로 z, roll, pitch는 거의 사용하지 않기 때문에 큰 값을 넣어 신뢰도가 낮다고 표시합니다.

9) twist.covariance의 의미

odom_msg.twist.covariance = [...]

이 부분은 로봇의 속도에 대한 신뢰도를 설정합니다.

twist도 6개 값에 대한 covariance를 가집니다.

linear.x, linear.y, linear.z, angular.x, angular.y, angular.z

현재 설정은 2D 이동 로봇에서 사용하는 전진 속도와 yaw 회전 속도는 비교적 신뢰하고, 3D 방향 속도나 roll/pitch 관련 속도는 신뢰하지 않는다는 뜻입니다.

linear.x   = 0.001
linear.y   = 0.001
linear.z   = 999.0
angular.x  = 999.0
angular.y  = 999.0
angular.z  = 0.01

10. Python용 Launch 파일 만들기

두 노드를 한 번에 실행하기 위해 launch 파일을 만듭니다.

파일 경로:

~/ros2_study/src/my_first_package/launch/odom_demo.launch.py

내용:

from launch import LaunchDescription
from launch_ros.actions import Node


def generate_launch_description():
    fake_encoder_node = Node(
        package='my_first_package',
        executable='fake_encoder_node',
        name='fake_encoder_node',
        output='screen',
        parameters=[
            {
                'left_tick_step': 5,
                'right_tick_step': 5,
                'period': 0.05
            }
        ]
    )

    encoder_odom_node = Node(
        package='my_first_package',
        executable='encoder_odom_node',
        name='encoder_odom_node',
        output='screen',
        parameters=[
            {
                'wheel_radius': 0.033,
                'wheel_separation': 0.30,
                'ticks_per_revolution': 2048,
                'odom_frame_id': 'odom',
                'base_frame_id': 'base_link',
                'publish_tf': True
            }
        ]
    )

    return LaunchDescription([
        fake_encoder_node,
        encoder_odom_node
    ])

11) 빌드 및 실행

패키지 루트가 포함된 워크스페이스에서 빌드합니다.

cd ~/ros2_study
colcon build --packages-select my_first_package my_first_package_msgs
source install/setup.bash

launch 파일로 실행합니다.

ros2 launch my_first_package odom_demo.launch.py

개별 실행도 가능합니다.

ros2 run my_first_package fake_encoder_node

ros2 run my_first_package encoder_odom_node

토픽 확인:

ros2 topic echo /encoder_ticks

ros2 topic echo /odom

TF 확인:

ros2 run tf2_ros tf2_echo odom base_link

12. RViz2에서 확인하는 방법

RViz2 설정은 다음처럼 합니다.

Fixed Frame : odom

Add → TF
Add → Odometry
Odometry Topic : /odom

정상이라면 base_link가 odom 기준으로 앞으로 이동합니다.

직진 조건:

left_tick_step  = 5
right_tick_step = 5

예상 결과:

x 증가
y 거의 변화 없음
theta 거의 변화 없음

왼쪽 회전 조건:

left_tick_step  = 3
right_tick_step = 7

예상 결과:

오른쪽 바퀴 이동량 > 왼쪽 바퀴 이동량
d_theta > 0
theta 증가
로봇은 반시계 방향으로 회전

제자리 회전 조건:

left_tick_step  = -5
right_tick_step = 5

예상 결과:

d_center ≈ 0
d_theta 증가
로봇이 제자리에서 회전

13. 실제 로봇 보정 절차

1) Wheel Radius 보정

실제 로봇을 1 m 직진시킵니다.
그리고 실제 이동거리와 /odom의 x 이동량을 비교합니다.

예:

명령 거리 : 1.00 m
odom 거리 : 1.00 m
실제 거리 : 0.92 m

실제 로봇이 odom보다 덜 갔습니다.

이 경우 설정된 wheel_radius가 너무 큽니다.

보정식은 다음입니다.

new_wheel_radius = old_wheel_radius × 실제 이동 거리 / odom 이동 거리

예:

new_wheel_radius = 0.033 × 0.92 / 1.00
                 = 0.03036 m

반대로 odom은 0.92m라고 나오는데 실제로는 1.0m를 갔다면, wheel radius를 키워야 합니다.

new_wheel_radius = 0.033 × 1.00 / 0.92
                 = 0.03587 m

2) Wheel Separation 보정

로봇을 제자리에서 360도 회전시킵니다.

360도 = 2π rad

예:

odom은 360도 회전했다고 표시
실제 로봇은 330도만 회전

이 경우 실제 회전이 부족합니다.

wheel_separation 설정, 마찰, 미끄러짐, 캐스터 휠 간섭 등을 의심해야 합니다.

공식은 다음입니다.

d_theta = (d_right - d_left) / wheel_separation

wheel_separation이 작으면 회전각이 크게 계산됩니다.
wheel_separation이 크면 회전각이 작게 계산됩니다.

그래서 회전 보정은 실제 회전 테스트를 반복하면서 맞추는 것이 정석입니다.

14. Odometry Drift 확인 실습

Odometry drift는 시간이 지나면서 실제 위치와 추정 위치가 달라지는 현상입니다.

1) 실습 1: wheel_radius 일부러 틀리게 넣기

실제 바퀴 반지름이 0.033m인데 코드에는 0.040m로 넣습니다.

결과:

실제 이동거리       : 1.0 m
오도메트리 추정거리 : 약 1.2 m

로봇이 실제보다 더 많이 이동했다고 추정합니다.

2) 실습 2: wheel_separation 일부러 틀리게 넣기

wheel_separation을 실제보다 작게 넣습니다.

공식은 다음입니다.

d_theta = (d_right - d_left) / wheel_separation

분모가 작아지면 d_theta가 커집니다.

결과:

실제보다 많이 회전했다고 추정
RViz2에서 방향이 과하게 돌아감

3) 실습 3: 한쪽 바퀴 tick만 다르게 만들기

가상 엔코더에서 오른쪽 tick만 조금 크게 만듭니다.

left_tick_step  = 5
right_tick_step = 6

로봇은 직진한다고 생각해도, odometry 계산상으로는 계속 회전합니다.

실제 로봇에서도 이런 일이 많이 생깁니다. 따라서 로봇의 직진성이 훼손되는 이유입니다.

원인은 다음과 같습니다.

좌우 바퀴 지름 차이
타이어 마모
모터 출력 차이
바닥 마찰 차이
엔코더 해상도 차이
기어 백래시
캐스터 휠 간섭

15. Covariance를 잘못 넣으면 생기는 문제

1) 너무 작게 넣는 경우

예:

x covariance   = 0.000001
y covariance   = 0.000001
yaw covariance = 0.000001

이렇게 하면 필터가 엔코더 오도메트리를 과신합니다.

문제:

IMU 보정값을 무시
LiDAR 보정값을 무시
SLAM 또는 localization이 불안정
위치 추정이 천천히 망가짐

2) 너무 크게 넣는 경우

예:

x covariance   = 100
y covariance   = 100
yaw covariance = 100

이렇게 하면 필터가 엔코더 오도메트리를 거의 믿지 않습니다.

문제:

속도 추정이 흔들림
센서 융합 결과가 느림
Nav2 경로 추종이 부드럽지 않음

실전에서는 샘플 데이터를 보고 조정해야 합니다.

16. 자주 발생하는 문제와 해결 방향

1) 문제 1. /cmd_vel을 줬는데 로봇이 반대로 돈다

가능한 원인:

왼쪽/오른쪽 모터 배선 반대
엔코더 방향 반대
좌우 바퀴 이름 반대
angular.z 부호 처리 반대

정상 기준:

linear.x = 0.0
angular.z = 0.5

이 명령을 주면 ROS 표준 좌표계에서는 제자리 좌회전해야 합니다.

2) 문제 2. 직진하면 /odom이 많이 틀어진다

가능한 원인:

좌우 바퀴 반지름 차이
좌우 모터 속도 차이
엔코더 해상도 설정 오류
바퀴 미끄러짐
무게중심 불균형

해결 순서:

좌우 tick 증가량 확인
바퀴 지름 실측
ticks_per_revolution 확인
PID 속도 제어 적용
wheel_radius 보정

3) 문제 3. 직진은 맞는데 회전이 틀어진다

가능한 원인:

wheel_separation 설정 오류
바닥 마찰 차이
캐스터 휠 간섭
회전 중 미끄러짐

해결 순서:

실제 좌우 바퀴 중심 간 거리 측정
제자리 360도 회전 테스트
wheel_separation 보정
저속 회전으로 테스트

4) 문제 4. encoder tick은 들어오는데 odometry가 이상하다

확인할 것:

tick 단위가 모터축 기준인지 바퀴축 기준인지
감속비가 반영되어 있는지
quadrature encoder의 x1, x2, x4 카운팅 방식
left/right 방향 부호
누적 tick overflow
시간 dt 계산

특히 감속기가 있는 DC 모터에서는 엔코더가 모터축에 붙어 있는 경우가 많습니다.

이때 바퀴축 1회전당 tick은 다음처럼 계산합니다.

wheel_ticks_per_revolution =
    motor_encoder_ticks_per_revolution
    × gear_ratio
    × quadrature_multiplier

예:

motor_encoder_ticks_per_revolution = 11
gear_ratio = 90
quadrature_multiplier = 4

wheel_ticks_per_revolution = 11 × 90 × 4
                           = 3960

--> 4채배

5) 문제 5. /odom은 나오는데 TF가 안 나온다

확인할 것:

/tf 토픽이 발행되는가?
publish_tf 파라미터가 true인가?
sendTransform()이 실행되는가?
header.frame_id가 odom인가?
child_frame_id가 base_link인가?

같은 odom → base_link TF를 여러 노드가 동시에 발행하면 안 됩니다.

예를 들어 robot_localization이 TF를 발행한다면 encoder odometry 노드의 publish_tf는 false로 두는 것이 안전합니다.

17. 실전에서 권장하는 Odometry 구조

실제 모바일 로봇에서는 다음 구조가 안정적입니다.

Wheel Encoder
      ↓
/wheel/odom
      ↓
robot_localization + IMU
      ↓
/odometry/filtered
      ↓
Nav2 / SLAM / RViz2

TF 구조는 다음입니다.

odom
 └── base_link

주의할 점은 다음입니다.

/odom을 발행하는 노드가 TF도 발행할지 결정해야 합니다.
robot_localization이 odom → base_link를 발행한다면 encoder odom node는 TF를 꺼야 합니다.
같은 TF를 여러 노드가 동시에 발행하면 안 됩니다.

18. 요약

Wheel Radius

바퀴 반지름
tick을 거리로 바꿀 때 핵심
직진 거리 정확도에 큰 영향

Wheel Separation

좌우 구동 바퀴 중심 사이 거리
좌우 바퀴 이동거리 차이를 회전각으로 바꿀 때 핵심
회전 정확도에 큰 영향

/cmd_vel

로봇 중심 속도 명령
linear.x는 전진 속도 [m/s]
angular.z는 회전 속도 [rad/s]

Wheel Velocity

v_l = v - ωL / 2
v_r = v + ωL / 2

Encoder Tick

바퀴 또는 모터 회전량
거리 변환 필요
distance = delta_ticks × 2πr / ticks_per_revolution

Odometry

d_center = (d_right + d_left) / 2
d_theta  = (d_right - d_left) / wheel_separation

odom → base_link

Drift

엔코더 기반 위치 추정 오차가 누적되는 현상
완전히 없앨 수는 없고 보정과 센서 융합으로 줄인다

Covariance

센서 추정값의 불확실성
작으면 신뢰
크면 불신

강의자료 준비

MakingRobotWizard — Thu, 4 Jun 2026 11:01:25 +0900

4) TurtleBot3 Odometry 분석

5) RViz로 모바일 로봇 상태와 토픽 확인하기

6) TurtleBot3 Waffle 시뮬레이션에서 RViz와 rqt로 카메라 토픽 확인하기

1. Wheel Radius, Wheel Separation, /cmd_vel, Encoder Tick, Odometry 기초, Encoder Odometry 계산, /odom 발행, odom → base_link TF, Drift 확인, Covariance 기초

2. 좌표계와 Frame 개념, 모바일 로봇의 map, odom, base_link 구조 완전 이해

3. 오도메트리(Odometry) 쉽게 이해하기

4. ROS 2 모바일 로봇 주행 원리, Differential Drive Kinematics

5. Map / Odom / Base_link 관계 완전 정리

1. ROS 2 Humble에서 TurtleBot3 시뮬레이션(312)

2. 차동 이동 로봇 기구학과 Odometry 쉽게 이해하기(373)

3. Odometry 프로그래밍(443)

3-2 odometry 종합(373) <--위의 내용과 비교하여 다시 정리해야 함

4. TurtleBot3 Odometry 분석(365)

5. RViz로 모바일 로봇 상태와 토픽 확인하기(318)

6. URDF 이해(352)

7. Xacro 기본 구조, Property, Macro, Include 실습(329)

8. TF#1 : 좌표계와 Frame 개념, 모바일 로봇의 map, odom, base_link 구조 완전 이해(389)

9. SLAM 기본 개념, Gazebo 기반 SLAM 실행(405)

10. GIMP를 이용한 지도 파일 .pgm 수정(438)

11. TurtleBot3 시뮬레이션으로 배우는 SLAM Toolbox(440)

extra1. ROS 2를 이용한 로봇 개발 시 시스템 설계 방법: 실무자가 바로 써먹는 전체 구조 가이드

1--> TurtleBot3 시뮬레이션으로 배우는 SLAM Toolbox

2--> ROS 2 Humble TurtleBot3 시뮬레이션에서 Cartographer SLAM 실습하기

6. ROS 2 Humble에서 TurtleBot3 시뮬레이션

7. ROS 2 Python 서비스 서버와 클라이언트 실습

4. ROS 2 강의를 위한 Linux 터미널 기본 명령어 정리

5. ROS 2 Humble C++ 서비스 서버와 클라이언트 실습 : 모바일 로봇 주행 허용 및 모드 변경 제어

6. ROS 2 C++ 패키지 설계 입문: 토픽, 서비스, 액션을 하나의 로봇 미션 시스템으로 연결하기

7. Python ROS 2 패키지 생성 정리

8. ROS 2 Python 서비스 서버와 클라이언트 실습

9. ROS2 Python 실습 강의: 토픽, 서비스, 액션으로 사칙연산 계산기 만들기

==>. 로봇 상태 Topic 발행하기 : 추가된 내용 버전(수정해서 사용할 것)

10일차 강의

MakingRobotWizard — Sun, 31 May 2026 23:17:20 +0900

1. ROS 2 C++ 파라미터 실습

2. ROS 2 C++ 실행 인자 사용하기

3. C++ Service Client 작성 실습 — 모바일 로봇 긴급정지 요청 보내기

4. ROS 2 에서 CMakeLists.txt 이해하기

5. ROS 2 package.xml 이해하기 : Python 패키지와 C++ 패키지 기준

6. ROS 2 Python 패키지의 setup.py 이해하기

launch 파일에서 실행 인자 사용하기 #2

MakingRobotWizard — Fri, 29 May 2026 18:21:53 +0900

4. launch 파일에서 remapping 사용하기

ROS 2에서 토픽 이름을 바꿔 연결해야 하는 경우가 많습니다.

이때 launch 파일에서 remapping을 사용할 수 있습니다.

예를 들어 어떤 노드가 /cmd_vel 토픽을 구독하도록 만들어져 있는데, 실제 turtlesim은 /turtle1/cmd_vel을 사용한다고 가정해 보겠습니다.

이 경우 launch 파일에서 다음처럼 remapping할 수 있습니다.

Node(
    package='my_first_package',
    executable='my_publisher',
    output='screen',
    remappings=[
        ('/cmd_vel', '/turtle1/cmd_vel')
    ]
)

형식은 다음과 같습니다.

remappings=[
    ('기존_토픽_이름', '변경할_토픽_이름')
]

먼저 패키지 폴더로 이동하여 새로운 노드 파일을 생성합니다.

cd ~/ros2_study/src/my_first_packages/my_first_packages

touch cmd_vel_publisher.py

cmd_vel_publisher.py 을 열어 다음 코드를 작성합니다.

import rclpy
from rclpy.node import Node
from geometry_msgs.msg import Twist


class CmdVelPublisher(Node):

    def __init__(self):
        super().__init__('cmd_vel_publisher')

        self.publisher_ = self.create_publisher(
            Twist,
            '/cmd_vel',
            10
        )

        self.timer = self.create_timer(1.0, self.timer_callback)

    def timer_callback(self):
        msg = Twist()

        msg.linear.x = 1.0
        msg.angular.z = 0.5

        self.publisher_.publish(msg)

        self.get_logger().info(
            'Publish velocity command to /cmd_vel'
        )


def main(args=None):
    rclpy.init(args=args)

    node = CmdVelPublisher()
    rclpy.spin(node)

    node.destroy_node()
    rclpy.shutdown()


if __name__ == '__main__':
    main()

이 노드는 /cmd_vel 토픽으로 geometry_msgs/msg/Twist 메시지를 발행합니다.

코드의 주요부분은 아래와 같습니다.

self.publisher_ = self.create_publisher(
    Twist,
    '/cmd_vel',
    10
)

위의 소스는 /cmd_vel에 publish합니다.

나중에 launch 파일에서 이 토픽 이름을 바꿀 수 있습니다.

상위 패키지 폴더로 이동합니다.

cd ~/ros2_study/src/my_first_packages

setup.py 파일을 엽니다.

entry_points 부분에 cmd_vel_publisher를 추가합니다.

기존 코드가 다음과 비슷하다면,

아래를 추가합니다.

entry_points={
    'console_scripts': [
        'cmd_vel_publisher = my_first_package.cmd_vel_publisher:main',
    ],
},

이제 ROS 2에서 다음 명령으로 새 노드를 실행할 수 있습니다.

컴파일하고 작업공간을 활성화하면 아래와 긑은 명령으로 실행할 수 있습니다.

ros2 run my_first_package cmd_vel_publisher

5. 새로운 remapping launch 파일 생성

launch 파일을 새로 만듭니다.

touch launch/cmd_vel_remap.launch.py

다음 내용을 작성합니다.

from launch import LaunchDescription
from launch_ros.actions import Node


def generate_launch_description():

    cmd_vel_publisher_node = Node(
        package='my_first_package',
        executable='cmd_vel_publisher',
        output='screen',
        remappings=[
            ('/cmd_vel', '/turtle1/cmd_vel')
        ]
    )

    return LaunchDescription([
        cmd_vel_publisher_node
    ])

아래의 코드가 주요 부분입니다.

remappings=[
    ('/cmd_vel', '/turtle1/cmd_vel')
]

뜻은 다음과 같습니다.

remappings=[
    ('기존_토픽_이름', '변경할_토픽_이름')
]

즉, cmd_vel_publisher 노드 안에서는 /cmd_vel을 사용하지만, 실제 실행할 때는 /turtle1/cmd_vel로 바뀝니다.

ros2 launch 명령으로 launch 파일을 실행하려면 setup.py에 launch 파일 설치 설정이 있어야 합니다.

setup.py 상단에 다음 import가 있는지 확인합니다.

import os
from glob import glob
from setuptools import setup

그리고 data_files에 다음 줄이 있어야 합니다.

(os.path.join('share', package_name, 'launch'), glob('launch/*.launch.py')),

예시는 다음과 같습니다.

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

없다면 추가합니다.

워크스페이스 루트로 이동합니다.

cd ~/ros2_study

빌드합니다.

colcon build --packages-select my_first_package

환경 설정을 다시 적용합니다.

source install/setup.bash

새 터미널을 열고 다음 명령을 실행합니다.

ros2 run turtlesim turtlesim_node

turtlesim_node는 기본적으로 /turtle1/cmd_vel 토픽을 구독합니다.

다른 터미널에서 다음 명령을 실행합니다.

cd ~/ros2_study
source install/setup.bash
ros2 launch my_first_package cmd_vel_remap.launch.py

그러면 cmd_vel_publisher 노드는 코드상으로는 /cmd_vel에 publish하지만, launch 파일의 remapping 때문에 실제로는

/turtle1/cmd_vel에 publish합니다.

결과적으로 turtlesim의 거북이가 움직입니다.

토픽 목록을 확인합니다.

ros2 topic list

다음 토픽이 보이면 정상입니다.

/turtle1/cmd_vel

메시지를 직접 확인하려면 다음 명령을 사용합니다.

ros2 topic echo /turtle1/cmd_vel

출력 예시는 다음과 같습니다.

linear:
  x: 1.0
  y: 0.0
  z: 0.0
angular:
  x: 0.0
  y: 0.0
  z: 0.5

이번에는 launch 파일을 사용하지 않고 노드를 직접 실행해 봅니다.

ros2 run my_first_package cmd_vel_publisher

이 경우에는 remapping이 적용되지 않습니다.

따라서 노드는 그대로 /cmd_vel 토픽에 메시지를 발행합니다.

확인 명령:

ros2 topic echo /cmd_vel

이 경우 turtlesim은 움직이지 않습니다.

이유는 turtlesim이 /cmd_vel이 아니라 /turtle1/cmd_vel을 구독하기 때문입니다.

실무에서 remapping은 매우 자주 사용됩니다.

예를 들어 모바일 로봇에서는 다음처럼 토픽 이름이 달라질 수 있습니다.

/cmd_vel
/robot1/cmd_vel
/robot2/cmd_vel
/scan
/robot1/scan
/odom
/robot1/odom

코드를 매번 수정하는 것은 좋지 않습니다.

토픽 이름만 다른 경우에는 launch 파일에서 remapping으로 해결하는 것이 더 깔끔합니다.

예를 들어 로봇 제어 노드는 /cmd_vel을 사용하도록 만들고, 실제 로봇마다 launch 파일에서 다음처럼 바꿀 수 있습니다.

remappings=[
    ('/cmd_vel', '/robot1/cmd_vel')
]

이렇게 하면 같은 제어 노드를 여러 로봇에 재사용할 수 있습니다.

5. launch 파일에서 namespace를 변수로 받기

여러 대의 모바일 로봇을 운용할 때는 namespace가 중요합니다.

예를 들어 모바일 로봇 1번과 모바일 로봇 2번이 있다고 가정하겠습니다.

/robot1/camera/image_raw
/robot1/scan
/robot1/odom
/robot1/cmd_vel
/robot1/navigation_state

/robot2/camera/image_raw
/robot2/scan
/robot2/odom
/robot2/cmd_vel
/robot2/navigation_state

이런 구조를 만들려면 launch 파일에서 namespace를 외부 인자로 받는 방식이 좋습니다.

먼저 namespace_test.launch.py 파일을 생성합니다.

cd ros2_study/src/my_first_package/launch/

touch namespace_test.launch.py

tree

새롭게 생성한 파일을 열어 아래의 내요을 작성합니다

from launch import LaunchDescription
from launch.actions import DeclareLaunchArgument
from launch.substitutions import LaunchConfiguration
from launch_ros.actions import Node


def generate_launch_description():
    namespace = LaunchConfiguration('namespace')

    return LaunchDescription([
        DeclareLaunchArgument(
            'namespace',
            default_value='robot1',
            description='Robot namespace'
        ),

        Node(
            package='turtlesim',
            executable='turtlesim_node',
            namespace=namespace,
            output='screen'
        ),

        Node(
            package='my_first_package',
            executable='my_publisher',
            namespace=namespace,
            output='screen'
        )
    ])

빌드합니다.

colcon build --packages-select my_first_package

환경 설정을 다시 적용합니다.

source install/setup.bash

새 터미널을 열고 실행은 다음처럼 합니다.

ros2 launch my_first_package namespace_test.launch.py namespace:=robot1

다른 이름으로 실행하고 싶다면 다음처럼 바꿉니다.

ros2 launch my_first_package namespace_test.launch.py namespace:=robot2

이 방식은 다중 로봇 시스템에서 거의 필수입니다.

특히 모바일 로봇, AMR, 물류 로봇, 서빙 로봇처럼 여러 대가 동시에 운용되는 시스템에서는 namespace 설계가 제대로 되어 있지 않으면 토픽이 섞이고 디버깅이 어려워집니다.

6. launch 파일에서 조건부 실행하기

항상 모든 노드를 실행해야 하는 것은 아닙니다.

예를 들어 카메라 노드는 필요할 때만 실행하고 싶을 수 있습니다.

이럴 때는 조건부 실행을 사용할 수 있습니다.

카메라 노드 파일을 생성합니다.

cd ~/ros2_study/src/my_first_package/my_first_package

touch camera_node.py

camera_node.py를 작성합니다.

import rclpy
from rclpy.node import Node


class CameraNode(Node):
    def __init__(self):
        super().__init__('camera_node')

        self.get_logger().info('camera_node has been started.')
        self.get_logger().info('This is a dummy camera node for launch condition test.')

        self.timer = self.create_timer(1.0, self.timer_callback)
        self.count = 0

    def timer_callback(self):
        self.count += 1
        self.get_logger().info(f'Dummy camera node is running... count: {self.count}')


def main(args=None):
    rclpy.init(args=args)

    node = CameraNode()

    try:
        rclpy.spin(node)
    except KeyboardInterrupt:
        node.get_logger().info('camera_node stopped by user.')
    finally:
        node.destroy_node()
        rclpy.shutdown()


if __name__ == '__main__':
    main()

setup.py를 열고 entry_points 부분에 아래 내용을 추가합니다.

entry_points={
    'console_scripts': [
        'camera_node = my_first_package.camera_node:main',
    ],
},

빌드하고 환경을 설정합니다.

cd ~/ros2_study

colcon build --packages-select my_first_package
source install/setup.bash

namespace_test.launch.py 파일을 생성합니다.

cd ros2_study/src/my_first_package/launch/

touch camera_test.launch.py

tree

새롭게 생성한 파일을 열어 아래의 내요을 작성합니다

from launch import LaunchDescription
from launch.actions import DeclareLaunchArgument
from launch.conditions import IfCondition
from launch.substitutions import LaunchConfiguration
from launch_ros.actions import Node


def generate_launch_description():
    use_camera = LaunchConfiguration('use_camera')

    return LaunchDescription([
        DeclareLaunchArgument(
            'use_camera',
            default_value='true',
            description='Whether to launch camera node'
        ),

        Node(
            package='my_first_package',
            executable='camera_node',
            output='screen',
            condition=IfCondition(use_camera)
        )
    ])

카메라 노드를 실행하려면 다음처럼 합니다.

ros2 launch my_first_package camera_test.launch.py use_camera:=true

카메라 노드를 실행하지 않으려면 다음처럼 합니다.

ros2 launch my_first_package camera_test.launch.py use_camera:=false

위의 실행결과 use_camera:=false로 실행했기 때문에 camera_node가 실행되지 않습니다. 그래서 아래처럼 launch 자체 로그만 나오고,

[INFO] [launch]: All log files can be found below ...
[INFO] [launch]: Default logging verbosity is set to INFO

camera_node 관련 로그가 안 나오는 것이 정상입니다.

모바일 로봇 시스템에서는 다음과 같은 조건부 실행이 유용합니다.

use_lidar
use_camera
use_imu
use_nav2
use_slam
use_rviz
use_robot_state_publisher
use_logger
use_sim_time

예를 들어 라이다만 테스트할 때는 카메라와 내비게이션 노드를 꺼도 됩니다.

SLAM 테스트를 할 때는 use_slam:=true, 저장된 맵 기반 주행을 할 때는 use_slam:=false로 분리할 수 있습니다.

개발 단계에서는 모든 기능을 한 번에 켜기보다 필요한 기능만 켜는 것이 안정적입니다.

7. 다른 launch 파일 포함하기

프로젝트가 커지면 launch 파일 하나에 모든 노드를 넣는 방식은 관리가 어렵습니다.

이럴 때는 launch 파일을 기능별로 나누고, 상위 launch 파일에서 다른 launch 파일을 포함할 수 있습니다.

예를 들어 다음과 같이 구성할 수 있습니다.

my_first_package/
├── launch/
│   ├── bringup.launch.py
│   ├── sensor.launch.py
│   ├── navigation.launch.py
│   └── control.launch.py

sensor.launch.py에는 센서 관련 노드를 넣습니다.

navigation.launch.py에는 경로 계획과 주행 관련 노드를 넣습니다.

control.launch.py에는 모터 제어, 속도 제어, 주행 명령 처리 노드를 넣습니다.

그리고 bringup.launch.py에서 모두 포함합니다.

import os

from ament_index_python.packages import get_package_share_directory

from launch import LaunchDescription
from launch.actions import IncludeLaunchDescription
from launch.launch_description_sources import PythonLaunchDescriptionSource


def generate_launch_description():
    package_dir = get_package_share_directory('my_first_package')

    dist_tutle_action_launch = IncludeLaunchDescription(
        PythonLaunchDescriptionSource(
            os.path.join(package_dir, 'launch', 'dist_turtle_action.launch.py')
        )
    )

    tutlesim_teleop_launch = IncludeLaunchDescription(
        PythonLaunchDescriptionSource(
            os.path.join(package_dir, 'launch', 'turtlesim_and_teleop.launch.py')
        )
    )

    return LaunchDescription([
        dist_tutle_action_launch,
        tutlesim_teleop_launch,
    ])

실행은 하나만 하면 됩니다.

ros2 launch my_first_package bringup.launch.py

이 방식은 실무에서 많이 사용됩니다.

특히 모바일 로봇 시스템이라면 다음처럼 나누는 것이 좋습니다.

robot_description.launch.py
sensors.launch.py
slam.launch.py
navigation.launch.py
control.launch.py
localization.launch.py
rviz.launch.py
bringup.launch.py

최종 실행은 다음처럼 단순해집니다.

ros2 launch mobile_robot_bringup bringup.launch.py

이렇게 구성하면 전체 시스템 실행은 bringup.launch.py 하나로 처리하고, 센서나 내비게이션만 따로 테스트할 때는 개별 launch 파일을 실행할 수 있습니다.

8. 모바일 로봇 시스템 예시 launch 구성

모바일 로봇 시스템을 예로 들면 launch 파일은 다음처럼 구성할 수 있습니다.

mobile_robot_bringup/
├── launch/
│   ├── bringup.launch.py
│   ├── robot_description.launch.py
│   ├── sensors.launch.py
│   ├── control.launch.py
│   ├── slam.launch.py
│   ├── localization.launch.py
│   ├── navigation.launch.py
│   └── rviz.launch.py
├── config/
│   ├── robot_params.yaml
│   ├── lidar_params.yaml
│   ├── controller_params.yaml
│   ├── slam_params.yaml
│   └── nav2_params.yaml
├── maps/
│   └── warehouse_map.yaml
└── urdf/
    └── mobile_robot.urdf.xacro

각 launch 파일의 역할은 다음과 같습니다.

robot_description.launch.py
- URDF 또는 Xacro 기반 로봇 모델 실행
- robot_state_publisher 실행
- joint_state_publisher 실행

sensors.launch.py
- 라이다 노드 실행
- 카메라 노드 실행
- IMU 노드 실행

control.launch.py
- 모터 제어 노드 실행
- cmd_vel 기반 속도 제어 노드 실행
- odom 발행 노드 실행

slam.launch.py
- SLAM 노드 실행
- 라이다 데이터를 이용한 지도 작성

localization.launch.py
- 저장된 map 파일 로드
- AMCL 또는 위치 추정 노드 실행

navigation.launch.py
- Nav2 관련 노드 실행
- global planner 실행
- local planner 실행
- behavior tree navigator 실행

rviz.launch.py
- RViz 실행
- 로봇 상태, 라이다, 지도, 경로 시각화

bringup.launch.py
- 전체 launch 파일을 하나로 묶어서 실행

최종 실행 명령은 다음처럼 단순하게 만들 수 있습니다.

ros2 launch mobile_robot_bringup bringup.launch.py robot_id:=robot1 use_lidar:=true use_camera:=false use_rviz:=true

이런 구조가 되면 시스템 실행이 편해집니다.

또한 문제가 생겼을 때 특정 기능만 따로 실행해서 디버깅할 수 있습니다.

예를 들어 센서만 테스트하고 싶다면 다음처럼 실행합니다.

ros2 launch mobile_robot_bringup sensors.launch.py

제어 노드만 테스트하고 싶다면 다음처럼 실행합니다.

ros2 launch mobile_robot_bringup control.launch.py

SLAM만 테스트하고 싶다면 다음처럼 실행합니다.

ros2 launch mobile_robot_bringup slam.launch.py

저장된 지도 기반 내비게이션만 테스트하고 싶다면 다음처럼 실행합니다.

ros2 launch mobile_robot_bringup navigation.launch.py map:=warehouse_map.yaml

이렇게 기능별로 launch 파일을 나누면 개발 속도가 빨라지고 문제 원인을 찾기 쉬워집니다.

GIMP를 이용한 지도 파일 .pgm 수정

MakingRobotWizard — Fri, 29 May 2026 00:18:20 +0900

1. GIMP 설치

1) Ubuntu에서 GIMP 설치

다음 명령을 실행하여 GIMP를 설치합니다.

sudo apt update
sudo apt install gimp -y

설치 확인:

gimp --version

GIMP 실행:

gimp

또는 지도 파일을 바로 열 수 있습니다.

gimp map.pgm

2. ROS 2 지도 파일 구조

1) PGM 파일

.pgm 파일은 지도 이미지입니다.

색상 의미는 다음과 같습니다.

검정색	장애물	벽, 물체, 진입 금지 구역
흰색	자유 공간	로봇이 이동 가능한 영역
회색	미확인 영역	SLAM이 확인하지 못한 영역

일반적인 픽셀 값은 다음과 같습니다.

검정색: 0
흰색: 254 또는 255
회색: 약 205

즉, GIMP에서 수정할 때 기준은 단순합니다.

검정색으로 칠하면 장애물
흰색으로 칠하면 이동 가능 공간
회색으로 칠하면 미확인 영역

2) YAML 파일

예시:

image: turtlebot3_map.pgm
mode: trinary
resolution: 0.05
origin: [-1.21, -2.4, 0]
negate: 0
occupied_thresh: 0.65
free_thresh: 0.25

a. image: turtlebot3_map.pgm

지도 이미지 파일 이름입니다.

image: turtlebot3_map.pgm

turtlebot3_map.pgm 파일을 실제 맵 이미지로 사용한다는 뜻입니다. PGM 이미지는 흑백 이미지입니다.

이 이미지를 기반으로 로봇이 갈 수 있는 곳과 갈 수 없는 곳을 판단합니다.

2. mode: trinary

이미지를 지도 값으로 변환하는 방식입니다.

mode: trinary

trinary는 맵을 세 가지 값으로만 나눕니다.

상태 Occupancy Grid 값 의미

Free	0	이동 가능
Occupied	100	장애물
Unknown	-1	알 수 없음

즉, 애매한 회색 값도 임계값 기준으로 free / occupied / unknown 중 하나로 분류합니다.

ROS Navigation에서 가장 흔히 쓰는 방식입니다.

3. resolution: 0.05

지도 이미지의 픽셀 하나가 실제 세계에서 몇 미터인지 나타냅니다.

resolution: 0.05

뜻은:

1 pixel = 0.05 m

즉,

1 pixel = 5 cm

예를 들어 이미지 크기가 400 x 400 pixel이면 실제 맵 크기는:

400 × 0.05 = 20 m

따라서 실제 공간 크기는:

20 m × 20 m

입니다.

해상도가 작을수록 정밀하지만, 맵 데이터가 커집니다.

resolution 의미

0.01	1픽셀 = 1cm, 매우 정밀
0.05	1픽셀 = 5cm, 일반적인 TurtleBot3 맵
0.10	1픽셀 = 10cm, 덜 정밀하지만 가벼움

4. origin: [-1.21, -2.4, 0]

지도 이미지의 원점이 실제 좌표계에서 어디에 위치하는지 나타냅니다.

origin: [-1.21, -2.4, 0]

형식은 다음과 같습니다.

origin: [x, y, yaw]

이 맵의 왼쪽 아래 픽셀 위치가 실제 /map 좌표계에서:

x = -1.21 m
y = -2.4 m
yaw = 0 rad

에 놓인다는 뜻입니다.

중요한 점은 origin은 보통 이미지의 왼쪽 아래 모서리 기준입니다.

PGM 이미지는 화면상으로는 왼쪽 위부터 보이지만, ROS 좌표계에서는 왼쪽 아래를 기준으로 봅니다.

5. negate: 0

이미지의 흑백 의미를 반전할지 여부입니다.

negate: 0

0이면 반전하지 않습니다.

일반적인 해석은:

색상 의미

검은색	장애물
흰색	자유 공간

만약 negate: 1이면 반대로 해석됩니다.

색상 의미

검은색	자유 공간
흰색	장애물

대부분의 SLAM으로 생성된 맵은 negate: 0을 사용합니다.

6. occupied_thresh: 0.65

장애물로 판단하는 임계값입니다.

occupied_thresh: 0.65

픽셀의 occupancy 확률이 0.65 이상이면 장애물로 판단합니다.

occupancy >= 0.65 → Occupied

즉, 장애물일 확률이 65% 이상이면 해당 셀은 장애물입니다.

Occupancy Grid에서는 보통 장애물 셀이 100으로 표현됩니다.

negate: 0일 때 occupancy 확률은 아래의 식으로 구할 수 있습니다.

occupancy = (255 - pixel_value) / 255

7. free_thresh: 0.25

이동 가능한 공간으로 판단하는 임계값입니다.

free_thresh: 0.25

픽셀의 occupancy 확률이 0.25 이하이면 자유 공간으로 판단합니다.

occupancy <= 0.25 → Free

즉, 장애물일 확률이 25% 이하이면 이동 가능한 공간입니다.

Occupancy Grid에서는 보통 자유 공간이 0으로 표현됩니다.

8. occupied_thresh와 free_thresh 사이 값

두 임계값 사이의 값은 미확인 영역으로 처리됩니다.

0.25 < occupancy < 0.65 → Unknown

즉:

occupancy 값결과

0.00 ~ 0.25	Free
0.25 ~ 0.65	Unknown
0.65 ~ 1.00	Occupied

3. GIMP로 지도 열기

터미널에서 실행:

gimp map.pgm

또는 GIMP에서 직접 열기:

File → Open → map.pgm

파일을 연 후 먼저 이미지 모드를 확인합니다.

Image → Mode → Grayscale

ROS 2 지도는 일반적으로 흑백 Grayscale 이미지로 유지해야 합니다.

4. 수정 전 백업

원본을 바로 수정하면 안 됩니다. 먼저 복사본을 만듭니다.

cp turtlebot3_map.pgm turtlebot3_map_origin.pgm
mv turtlebot3_map.pgm turtlebot3_map_modified.pgm

이후에는 map_modified.pgm만 수정합니다.

gimp ~/maps/edit/map_modified.pgm

5. GIMP에서 주로 사용하는 도구

1) Pencil Tool 사용

지도 수정에는 Brush보다 Pencil Tool이 좋습니다.

Tools → Paint Tools → Pencil

단축키:

권장 설정:

Opacity: 100%
Hardness: 100%

Pencil Tool은 가장자리를 흐리게 만들지 않아 지도 수정에 적합합니다.

2) 색상별 수정 기준

벽 추가	검정색
가상 벽 추가	검정색
노이즈 제거	흰색
잘못 생긴 벽 제거	흰색
지도 외곽 정리	회색
미확인 영역 복원	회색

6. 대표적인 지도 수정 작업

1) SLAM 노이즈 제거

SLAM 후 지도에 작은 검은 점이나 이상한 선이 생길 수 있습니다.

이런 노이즈는 로봇이 장애물로 인식할 수 있습니다.

수정 방법:

Pencil Tool 선택
흰색 선택
검은 노이즈를 흰색으로 칠함
저장

2) 잘못 생성된 벽 제거

사람, 임시 물체, 센서 오류 때문에 복도 중간에 벽처럼 생긴 선이 생길 수 있습니다.

수정 방법:

흰색 선택
잘못된 검은 선을 흰색으로 지움
실제 벽은 지우지 않도록 주의

실제 벽을 지우면 로봇이 벽을 통과하는 경로를 만들 수 있습니다.

3) 가상 벽 추가

로봇이 들어가면 안 되는 구역은 검은색으로 막을 수 있습니다.

예:

계단
위험 구역
사람 전용 공간
유리문 근처
좁은 통로

수정 방법:

검정색 선택
Pencil Tool 또는 Rectangle Select Tool 사용
진입 금지 구역 앞에 검정색 선 추가

권장 두께:

3~10 pixel 정도

너무 얇으면 Nav2 costmap에서 안정적으로 반영되지 않을 수 있습니다.

4) 지도 외곽 정리

지도 바깥이나 탐색하지 않은 영역은 흰색으로 만들지 않는 것이 좋습니다.

권장:

지도 외곽 = 회색

흰색으로 칠하면 로봇이 지도 밖을 이동 가능 영역으로 판단할 수 있습니다.

7. 저장 방법

수정 후에는 Export로 저장합니다.

File → Export As

파일명 예:

map_modified.pgm

가능하면 다음 상태를 유지합니다.

Grayscale
8-bit
PGM

레이어를 사용했다면 저장 전에 병합합니다.

Image → Flatten Image

8. YAML 파일 수정

PGM 파일명을 바꿨다면 YAML 파일의 image 항목도 수정해야 합니다.

수정 전:

image: turtlebot3_map_origin.pgm
mode: trinary
resolution: 0.05
origin: [-1.21, -2.4, 0]
negate: 0
occupied_thresh: 0.65
free_thresh: 0.25

수정 후:

image: turtlebot3_map_modified.pgm
mode: trinary
resolution: 0.05
origin: [-1.21, -2.4, 0]
negate: 0
occupied_thresh: 0.65
free_thresh: 0.25

주의할 점:

resolution 변경 금지
origin 변경 금지
이미지 크기 변경 금지

이 값들이 바뀌면 RViz에서 로봇 위치와 지도가 어긋날 수 있습니다.

9. 수정한 지도 실행

Nav2에서 수정한 지도를 사용할 때:

ros2 launch turtlebot3_navigation2 navigation2.launch.py use_sim_time:=True \
  map:=$HOME/maps/turtlebot3_map_modified.yaml

새롭게 작성한 지도 위에서 Nav2 Goal을 이용하여 주행을 시작합니다. 다양한 위치를 목표지점으로 정하고 주행하면서 주행성능을 확인하시기 바랍니다.

Cancel 테스트용 Action Client 만들기

MakingRobotWizard — Tue, 26 May 2026 23:22:20 +0900

1. Cancel 기능 실습 개요

이번 실습에서는 실행 중인 Action Goal을 중간에 취소하는 방법을 확인합니다.

ROS 2 Action은 Client가 Server에 Goal을 보내고, Server는 작업을 수행하면서 Feedback을 보내다가 마지막에 Result를 반환하는 구조입니다.

여기서 Cancel 기능은 이미 실행 중인 Goal을 중간에 취소할 때 사용합니다.

주의할 점은 일반적인 ROS 2 CLI 환경에서는 실행 중인 Action Goal을 직접 취소하는 다음 명령을 사용할 수 없는 경우가 많다는 것입니다.

ros2 action cancel /dist_turtle

따라서 이번 실습에서는 별도의 Action Client를 작성해서 Cancel 요청을 보냅니다.

Cancel 요청의 핵심 코드는 다음입니다.

self._cancel_future = self.goal_handle.cancel_goal_async()

이 코드는 현재 Client가 보낸 Goal에 대해 Action Server로 Cancel 요청을 전송합니다.

2. Cancel 테스트용 Action Client 파일 만들기

먼저 Cancel 요청을 보내는 Action Client 파일을 새로 만듭니다.

cd ~/ros2_study/src/my_first_package/my_first_package
touch dist_turtle_action_client_cancel.py

파일 이름은 다음과 같습니다.

dist_turtle_action_client_cancel.py

이 파일은 기존 Action Client와 비슷하지만, Goal을 보낸 뒤 일정 시간이 지나면 자동으로 Cancel 요청을 보내도록 작성합니다.

3. Cancel 테스트용 Action Client 전체 코드

dist_turtle_action_client_cancel.py 파일에 다음 코드를 작성합니다.

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

from my_first_package_msgs.action import DistTurtle


class DistTurtleCancelClient(Node):

    def __init__(self):
        super().__init__('dist_turtle_action_client_cancel')

        self._action_client = ActionClient(
            self,
            DistTurtle,
            'dist_turtle'
        )

        self.goal_handle = None
        self.timer = None

    def send_goal(self):
        goal_msg = DistTurtle.Goal()
        goal_msg.linear_x = 1.0
        goal_msg.angular_z = 0.0
        goal_msg.dist = 10.0

        self._action_client.wait_for_server()

        self.get_logger().info('Sending goal')

        self._send_goal_future = self._action_client.send_goal_async(
            goal_msg,
            feedback_callback=self.feedback_callback
        )

        self._send_goal_future.add_done_callback(
            self.goal_response_callback
        )

    def goal_response_callback(self, future):
        self.goal_handle = future.result()

        if not self.goal_handle.accepted:
            self.get_logger().info('Goal rejected')
            return

        self.get_logger().info('Goal accepted')

        self._get_result_future = self.goal_handle.get_result_async()
        self._get_result_future.add_done_callback(
            self.get_result_callback
        )

        self.timer = self.create_timer(2.0, self.cancel_goal)

    def feedback_callback(self, feedback_msg):
        feedback = feedback_msg.feedback

        self.get_logger().info(
            f'Received feedback: remained_dist = {feedback.remained_dist}'
        )

    def cancel_goal(self):
        self.get_logger().info('Sending cancel request')

        self.timer.cancel()

        self._cancel_future = self.goal_handle.cancel_goal_async()
        self._cancel_future.add_done_callback(
            self.cancel_done_callback
        )

    def cancel_done_callback(self, future):
        cancel_response = future.result()

        if len(cancel_response.goals_canceling) > 0:
            self.get_logger().info('Cancel request accepted')
        else:
            self.get_logger().info('Cancel request rejected')

    def get_result_callback(self, future):
        result = future.result().result
        status = future.result().status

        self.get_logger().info(f'Action finished with status: {status}')
        self.get_logger().info(f'Result distance: {result.result_dist}')

        rp.shutdown()


def main(args=None):
    rp.init(args=args)

    action_client = DistTurtleCancelClient()
    action_client.send_goal()

    rp.spin(action_client)


if __name__ == '__main__':
    main()

4. import 부분 설명

먼저 코드의 import 부분입니다.

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

from my_first_package_msgs.action import DistTurtle

다음 코드는 Action Client를 사용하기 위해 필요합니다.

from rclpy.action import ActionClient

ActionClient는 Action Server에 Goal을 보내고, Feedback과 Result를 받으며, Cancel 요청도 보낼 수 있는 클래스입니다.

마지막 import는 직접 만든 Action 인터페이스를 가져오는 부분입니다.

from my_first_package_msgs.action import DistTurtle

DistTurtle은 앞에서 만든 Action 메시지입니다.

이 안에는 다음 세 가지 타입이 포함되어 있습니다.

DistTurtle.Goal
DistTurtle.Feedback
DistTurtle.Result

이번 Client에서는 DistTurtle.Goal()을 만들어 Server로 보내고, Server가 보내는 Feedback과 Result를 받습니다.

6. 생성자 init() 설명

다음은 생성자 부분입니다.

def __init__(self):
    super().__init__('dist_turtle_action_client_cencel')

    self._action_client = ActionClient(
        self,
        DistTurtle,
        'dist_turtle'
    )

    self.goal_handle = None
    self.timer = None

먼저 다음 코드는 Node 이름을 설정합니다.

super().__init__('dist_turtle_action_client_cancel')

이 Client Node의 이름은 dist_turtle_cancel_client가 됩니다.

실행 로그에서는 이 이름으로 출력됩니다.

[INFO] [dist_turtle_action_client_cencel]: Sending goal

다음 코드는 Action Client를 생성합니다.

self._action_client = ActionClient(
    self,
    DistTurtle,
    'dist_turtle'
)

각 인자의 의미는 다음과 같습니다.

self          → 현재 Node
DistTurtle    → 사용할 Action 타입
'dist_turtle' → 접속할 Action 이름

여기서 'dist_turtle'은 Action Server에서 사용한 Action 이름과 같아야 합니다.

Server도 같은 이름으로 Action Server를 열고 있어야 Client가 연결할 수 있습니다.

다음 코드는 Goal Handle을 저장할 변수입니다.

self.goal_handle = None

Goal Handle은 Client가 보낸 Goal을 제어하기 위한 객체입니다.

Cancel 요청을 보낼 때 이 Goal Handle이 필요합니다.

다음 코드는 Timer 객체를 저장할 변수입니다.

self.timer = None

이번 실습에서는 Goal을 보낸 뒤 2초 후 Cancel 요청을 보내기 위해 Timer를 사용합니다.

7. send_goal() 함수 설명

다음 함수는 Action Server로 Goal을 보내는 함수입니다.

def send_goal(self):
    goal_msg = DistTurtle.Goal()
    goal_msg.linear_x = 0.0
    goal_msg.angular_z = 0.0
    goal_msg.dist = 10.0

    self._action_client.wait_for_server()

    self.get_logger().info('Sending goal')

    self._send_goal_future = self._action_client.send_goal_async(
        goal_msg,
        feedback_callback=self.feedback_callback
    )

    self._send_goal_future.add_done_callback(
        self.goal_response_callback
    )

먼저 Goal 메시지를 생성합니다.

goal_msg = DistTurtle.Goal()

DistTurtle.Goal()은 Action Server에 보낼 목표값입니다.

그다음 Goal 메시지 안의 값을 설정합니다.

goal_msg.linear_x = 0.0
goal_msg.angular_z = 0.0
goal_msg.dist = 10.0

각 값은 Action 정의 파일에 작성한 Goal 필드입니다.

linear_x  → 직선 속도 값
angular_z → 회전 속도 값
dist      → 목표 거리 값

이번 실습에서는 Cancel 기능 확인이 목적이므로 dist를 10.0으로 설정합니다.

다음 코드는 Action Server가 실행될 때까지 기다립니다.

self._action_client.wait_for_server()

Server가 실행되지 않은 상태에서 Goal을 보내면 정상적으로 처리할 수 없습니다.

그래서 Client는 먼저 Server가 준비될 때까지 대기합니다.

다음 코드는 Goal을 비동기 방식으로 보냅니다.

self._send_goal_future = self._action_client.send_goal_async(
    goal_msg,
    feedback_callback=self.feedback_callback
)

send_goal_async()는 Goal을 보내고 바로 다음 코드로 넘어갑니다.

작업 결과를 기다리는 동안 프로그램이 멈추지 않습니다.

여기서 feedback_callback은 Server가 Feedback을 보낼 때 실행될 함수입니다.

feedback_callback=self.feedback_callback

마지막으로 Goal 요청 결과를 받을 콜백을 등록합니다.

self._send_goal_future.add_done_callback(
    self.goal_response_callback
)

Server가 Goal을 수락했는지 거부했는지 결과가 오면 goal_response_callback() 함수가 실행됩니다.

8. goal_response_callback() 함수 설명

다음 함수는 Server가 Goal을 수락했는지 확인하는 함수입니다.

def goal_response_callback(self, future):
    self.goal_handle = future.result()

    if not self.goal_handle.accepted:
        self.get_logger().info('Goal rejected')
        return

    self.get_logger().info('Goal accepted')

    self._get_result_future = self.goal_handle.get_result_async()
    self._get_result_future.add_done_callback(
        self.get_result_callback
    )

    self.timer = self.create_timer(2.0, self.cancel_goal)

먼저 Goal Handle을 가져옵니다.

self.goal_handle = future.result()

이 Goal Handle은 이후 Cancel 요청을 보낼 때 사용합니다.

다음 코드는 Goal이 거부되었는지 확인합니다.

if not self.goal_handle.accepted:
    self.get_logger().info('Goal rejected')
    return

Server가 Goal을 거부했다면 더 이상 진행하지 않고 함수를 종료합니다.

Goal이 정상적으로 수락되면 다음 로그가 출력됩니다.

self.get_logger().info('Goal accepted')

그다음 Result를 받기 위한 요청을 등록합니다.

self._get_result_future = self.goal_handle.get_result_async()
self._get_result_future.add_done_callback(
    self.get_result_callback
)

get_result_async()는 Action이 끝났을 때 Result를 받기 위해 사용합니다.

마지막 줄이 Cancel 실습에서 중요한 부분입니다.

self.timer = self.create_timer(2.0, self.cancel_goal)

이 코드는 2초마다 cancel_goal() 함수를 실행하는 Timer를 만듭니다.

하지만 cancel_goal() 함수 안에서 바로 Timer를 취소하기 때문에 실제로는 2초 후 한 번만 Cancel 요청을 보냅니다.

9. feedback_callback() 함수 설명

다음 함수는 Server에서 Feedback을 보낼 때마다 실행됩니다.

def feedback_callback(self, feedback_msg):
    feedback = feedback_msg.feedback

    self.get_logger().info(
        f'Received feedback: remained_dist = {feedback.remained_dist}'
    )

feedback_msg.feedback에는 Server가 보낸 Feedback 데이터가 들어 있습니다.

feedback = feedback_msg.feedback

이번 예제에서는 남은 거리를 의미하는 remained_dist 값을 출력합니다.

f'Received feedback: remained_dist = {feedback.remained_dist}'

Action Server가 작업 중 Feedback을 계속 보내면 Client는 이 함수를 통해 값을 확인할 수 있습니다.

10. cancel_goal() 함수 설명

다음 함수는 실제로 Cancel 요청을 보내는 함수입니다.

def cancel_goal(self):
    self.get_logger().info('Sending cancel request')

    self.timer.cancel()

    self._cancel_future = self.goal_handle.cancel_goal_async()
    self._cancel_future.add_done_callback(
        self.cancel_done_callback
    )

먼저 Cancel 요청을 보낸다는 로그를 출력합니다.

self.get_logger().info('Sending cancel request')

다음 코드는 Timer를 중지합니다.

self.timer.cancel()

create_timer(2.0, self.cancel_goal)로 만든 Timer는 원래 2초마다 계속 실행될 수 있습니다.

하지만 Cancel 요청은 한 번만 보내면 되므로 Timer를 바로 중지합니다.

가장 중요한 코드는 다음입니다.

self._cancel_future = self.goal_handle.cancel_goal_async()

이 코드가 Action Server로 Cancel 요청을 보냅니다.

여기서 goal_handle을 사용한다는 점이 중요합니다.

Cancel 요청은 Action 이름만으로 보내는 것이 아니라, Client가 보낸 Goal의 Handle을 통해 보내야 합니다.

마지막 코드는 Cancel 요청 결과를 받을 콜백을 등록합니다.

self._cancel_future.add_done_callback(
    self.cancel_done_callback
)

Server가 Cancel 요청을 허용했는지 거부했는지 결과가 오면 cancel_done_callback() 함수가 실행됩니다.

11. cancel_done_callback() 함수 설명

다음 함수는 Cancel 요청 결과를 확인하는 함수입니다.

def cancel_done_callback(self, future):
    cancel_response = future.result()

    if len(cancel_response.goals_canceling) > 0:
        self.get_logger().info('Cancel request accepted')
    else:
        self.get_logger().info('Cancel request rejected')

먼저 Cancel 요청 결과를 가져옵니다.

cancel_response = future.result()

다음 코드는 취소 처리 중인 Goal이 있는지 확인합니다.

if len(cancel_response.goals_canceling) > 0:

goals_canceling 안에 값이 하나라도 있으면 Server가 Cancel 요청을 받아들였다는 의미입니다.

이 경우 다음 로그를 출력합니다.

self.get_logger().info('Cancel request accepted')

반대로 goals_canceling이 비어 있으면 Cancel 요청이 거부되었거나 취소할 Goal이 없는 상태입니다.

self.get_logger().info('Cancel request rejected')

12. get_result_callback() 함수 설명

다음 함수는 Action이 최종 종료되었을 때 실행됩니다.

def get_result_callback(self, future):
    result = future.result().result
    status = future.result().status

    self.get_logger().info(f'Action finished with status: {status}')
    self.get_logger().info(f'Result distance: {result.result_dist}')

    rp.shutdown()

먼저 Result 값을 가져옵니다.

result = future.result().result

그리고 Action 상태 값을 가져옵니다.

status = future.result().status

Cancel이 정상 처리되면 보통 다음과 같은 상태 값이 출력됩니다.

Action finished with status: 5

일반적으로 status: 5는 CANCELED 상태를 의미합니다.

다음 코드는 Result에 들어 있는 거리 값을 출력합니다.

self.get_logger().info(f'Result distance: {result.result_dist}')

마지막으로 ROS 2 노드를 종료합니다.

rp.shutdown()

13. main() 함수 설명

마지막은 실행 진입점입니다.

def main(args=None):
    rp.init(args=args)

    action_client = DistTurtleCancelClient()
    action_client.send_goal()

    rp.spin(action_client)


if __name__ == '__main__':
    main()

그다음 Cancel Client 객체를 생성합니다.

action_client = DistTurtleCancelClient()

다음 코드로 Goal을 전송합니다.

action_client.send_goal()

마지막으로 Node를 계속 실행하면서 콜백이 처리되도록 합니다.

rp.spin(action_client)

rp.spin(action_client)가 실행 중이기 때문에 다음 콜백들이 정상적으로 동작할 수 있습니다.

goal_response_callback()
feedback_callback()
cancel_goal()
cancel_done_callback()
get_result_callback()

14. setup.py에 실행 파일 등록하기

새로 만든 Python 파일을 ros2 run 명령으로 실행하려면 setup.py에 등록해야 합니다.

setup.py 파일을 엽니다.

cd ~/ros2_study/src/my_first_package
gedit setup.py

또는 VS Code를 사용한다면 다음처럼 열 수 있습니다.

code setup.py

entry_points의 console_scripts에 다음 줄을 추가합니다.

'dist_turtle_action_client_cancel = my_first_package.dist_turtle_action_client_cancel:main',

예시는 다음과 같습니다.

entry_points={
    'console_scripts': [
        'dist_turtle_action_server = my_first_package.dist_turtle_action_server:main',
        'dist_turtle_action_client_cancel = my_first_package.dist_turtle_action_client_cancel:main',
    ],
},

따라서 다음 명령을 실행하면

ros2 run my_first_package dist_turtle_action_client_cancel

ROS 2는 내부적으로 다음 파일의 main() 함수를 실행합니다.

my_first_package/dist_turtle_action_client_cancel.py

15. 빌드하기

코드를 수정했으므로 다시 빌드합니다.

cd ~/ros2_study
colcon build
source install/setup.bash

빌드가 완료되면 새로 등록한 실행 파일을 사용할 수 있습니다.

16. Action Server 실행하기

첫 번째 터미널에서 Action Server를 실행합니다.

cd ~/ros2_study
source install/setup.bash
ros2 run my_first_package dist_turtle_action_server

Action Server가 실행되면 Client의 Goal 요청을 기다립니다.

17. Cancel 테스트용 Action Client 실행하기

두 번째 터미널을 열고 Cancel 테스트용 Action Client를 실행합니다.

cd ~/ros2_study
source install/setup.bash
ros2 run my_first_package dist_turtle_action_client_cancel

이 Client는 Goal을 보낸 뒤 약 2초 후 자동으로 Cancel 요청을 보냅니다.

18. 실행 결과 확인하기

Client 쪽 출력은 다음과 비슷합니다.

[INFO] [dist_turtle_action_client_cancel]: Sending goal
[INFO] [dist_turtle_action_client_cancel]: Goal accepted
[INFO] [dist_turtle_action_client_cancel]: Received feedback: remained_dist = 10.0
[INFO] [dist_turtle_action_client_cancel]: Received feedback: remained_dist = 9.0
[INFO] [dist_turtle_action_client_cancel]: Sending cancel request
[INFO] [dist_turtle_action_client_cancel]: Cancel request accepted
[INFO] [dist_turtle_action_client_cancel]: Action finished with status: 5
[INFO] [dist_turtle_action_client_cancel]: Result distance: 2.0

Server 쪽 출력은 다음과 비슷합니다.

[INFO] [dist_turtle_action_server]: Goal received
[INFO] [dist_turtle_action_server]: Feedback: remained_dist = 10.0
[INFO] [dist_turtle_action_server]: Feedback: remained_dist = 9.0
[INFO] [dist_turtle_action_server]: Cancel request received
[INFO] [dist_turtle_action_server]: Goal canceled

Client에서 다음 로그가 출력되면 Cancel 요청이 Server에 의해 허용된 것입니다.

Cancel request accepted

Server에서 다음 로그가 출력되면 Server가 Cancel 요청을 받은 것입니다.

Cancel request received

Server에서 다음 로그가 출력되면 실행 중이던 Goal이 취소 처리된 것입니다.

Goal canceled

Client에서 다음 로그가 출력되면 Action이 취소 상태로 종료된 것입니다.

Action finished with status: 5

ROS 2 Python Topic 실습 : RobotStatus 메시지로 로봇 상태 주고받기

MakingRobotWizard — Tue, 26 May 2026 00:48:53 +0900

1. 최종 목표

이번 실습에서 만들 구조는 다음과 같습니다.

ros2_lab_ws
└── src
    ├── robot_interfaces
    │   └── msg
    │       └── RobotStatus.msg
    │
    └── topic_practice
        └── topic_practice
            ├── robot_status_pub.py
            └── robot_status_sub.py

전체 동작 흐름은 다음과 같습니다.

robot_status_pub
        ↓
/robot_status Topic
        ↓
robot_status_sub

Publisher는 로봇 상태를 보냅니다.

robot_id: R-001
mode: AUTO
battery_percent: 87.5
emergency_stop: false

Subscriber는 이 메시지를 받아서 출력합니다.

2. 워크스페이스 생성

먼저 ROS 2 워크스페이스를 만듭니다.

mkdir -p ~/ros2_lab_ws/src
cd ~/ros2_lab_ws/src

현재 구조는 이렇게 됩니다.

~/ros2_lab_ws
└── src

3. msg 폴더 생성

RobotStatus.msg 파일을 넣을 msg 폴더를 만듭니다.

cd ~/ros2_lab_ws/src/robot_interfaces
mkdir msg

4. RobotStatus.msg 작성

파일을 생성합니다.

touch msg/RobotStatus.msg

내용은 다음과 같이 작성합니다.

string robot_id
string mode
float32 battery_percent
bool emergency_stop

각 필드 의미는 다음과 같습니다.

필드 타입 의미

robot_id	string	로봇 ID
mode	string	현재 동작 모드
battery_percent	float32	배터리 잔량
emergency_stop	bool	비상 정지 상태

5. topic_practice 패키지 생성

이제 Publisher와 Subscriber를 만들 Python 패키지를 생성합니다.

cd ~/ros2_lab_ws/src

ros2 pkg create topic_practice --build-type ament_python --dependencies rclpy robot_interfaces

생성 후 구조는 대략 다음과 같습니다.

topic_practice
├── package.xml
├── setup.py
├── setup.cfg
├── resource
│   └── topic_practice
└── topic_practice
    └── __init__.py

6. Publisher 코드 작성

Publisher 파일을 만듭니다.

cd ~/ros2_lab_ws/src/topic_practice/topic_practice
nano robot_status_pub.py

아래 코드를 작성합니다.

import rclpy
from rclpy.node import Node

from robot_interfaces.msg import RobotStatus


class RobotStatusPublisher(Node):
    def __init__(self):
        super().__init__('robot_status_pub')

        self.publisher_ = self.create_publisher(
            RobotStatus,
            '/robot_status',
            10
        )

        self.timer = self.create_timer(1.0, self.timer_callback)

        self.count = 0
        self.modes = ['IDLE', 'MANUAL', 'AUTO', 'ERROR']

    def timer_callback(self):
        self.count += 1

        msg = RobotStatus()
        msg.robot_id = f'R-{self.count:03d}'
        msg.mode = self.modes[self.count % len(self.modes)]
        msg.battery_percent = max(0.0, 100.0 - self.count * 1.25)
        msg.emergency_stop = msg.mode == 'ERROR'

        self.publisher_.publish(msg)

        self.get_logger().info(
            f'Publish: robot_id={msg.robot_id}, '
            f'mode={msg.mode}, '
            f'battery={msg.battery_percent:.2f}, '
            f'emergency={msg.emergency_stop}'
        )


def main(args=None):
    rclpy.init(args=args)

    node = RobotStatusPublisher()

    try:
        rclpy.spin(node)
    except KeyboardInterrupt:
        pass

    node.destroy_node()
    rclpy.shutdown()


if __name__ == '__main__':
    main()

7. Subscriber 코드 작성

Subscriber 파일을 만듭니다.

nano robot_status_sub.py

아래 코드를 작성합니다.

import rclpy
from rclpy.node import Node

from robot_interfaces.msg import RobotStatus


class RobotStatusSubscriber(Node):
    def __init__(self):
        super().__init__('robot_status_sub')

        self.subscription = self.create_subscription(
            RobotStatus,
            '/robot_status',
            self.listener_callback,
            10
        )

    def listener_callback(self, msg):
        if msg.emergency_stop:
            self.get_logger().error(
                f'Emergency detected: {msg.robot_id} mode={msg.mode}'
            )
        else:
            self.get_logger().info(
                f'Receive: {msg.robot_id} | '
                f'{msg.mode} | '
                f'battery={msg.battery_percent:.2f} | '
                f'emergency={msg.emergency_stop}'
            )


def main(args=None):
    rclpy.init(args=args)

    node = RobotStatusSubscriber()

    try:
        rclpy.spin(node)
    except KeyboardInterrupt:
        pass

    node.destroy_node()
    rclpy.shutdown()


if __name__ == '__main__':
    main()

8. robot_interfaces/package.xml 수정

robot_interfaces/package.xml을 엽니다.

아래 내용을 추가합니다.

<buildtool_depend>rosidl_default_generators</buildtool_depend>
<exec_depend>rosidl_default_runtime</exec_depend>
<member_of_group>rosidl_interface_packages</member_of_group>

전체에서 중요한 부분은 이런 형태입니다.

<?xml version="1.0"?>
<package format="3">
  <name>robot_interfaces</name>
  <version>0.0.0</version>
  <description>Custom interfaces for robot examples</description>
  <maintainer email="user@example.com">user</maintainer>
  <license>Apache-2.0</license>

  <buildtool_depend>ament_cmake</buildtool_depend>

  <buildtool_depend>rosidl_default_generators</buildtool_depend>
  <exec_depend>rosidl_default_runtime</exec_depend>

  <member_of_group>rosidl_interface_packages</member_of_group>

  <test_depend>ament_lint_auto</test_depend>
  <test_depend>ament_lint_common</test_depend>

  <export>
    <build_type>ament_cmake</build_type>
  </export>
</package>

여기서 중요 포인트는 이것입니다.

<member_of_group>rosidl_interface_packages</member_of_group>

이게 빠지면 인터페이스 패키지 빌드에서 문제가 날 수 있습니다.

9. robot_interfaces/CMakeLists.txt 수정

CMakeLists.txt를 엽니다.

내용을 다음처럼 정리합니다.

cmake_minimum_required(VERSION 3.8)
project(robot_interfaces)

if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
  add_compile_options(-Wall -Wextra -Wpedantic)
endif()

find_package(ament_cmake REQUIRED)
find_package(rosidl_default_generators REQUIRED)

rosidl_generate_interfaces(${PROJECT_NAME}
  "msg/RobotStatus.msg"
)

ament_export_dependencies(rosidl_default_runtime)

ament_package()

10. setup.py 수정

ros2 run으로 실행하려면 setup.py에 실행 파일을 등록해야 합니다.

entry_points 부분을 다음처럼 수정합니다.

entry_points={
    'console_scripts': [
        'robot_status_pub = topic_practice.robot_status_pub:main',
        'robot_status_sub = topic_practice.robot_status_sub:main',
    ],
},

전체 예시는 다음과 같습니다.

from setuptools import find_packages, setup

package_name = 'topic_practice'

setup(
    name=package_name,
    version='0.0.0',
    packages=find_packages(exclude=['test']),
    data_files=[
        ('share/ament_index/resource_index/packages',
            ['resource/' + package_name]),
        ('share/' + package_name, ['package.xml']),
    ],
    install_requires=['setuptools'],
    zip_safe=True,
    maintainer='user',
    maintainer_email='user@example.com',
    description='ROS 2 topic practice package',
    license='Apache-2.0',
    tests_require=['pytest'],
    entry_points={
        'console_scripts': [
            'robot_status_pub = topic_practice.robot_status_pub:main',
            'robot_status_sub = topic_practice.robot_status_sub:main',
        ],
    },
)

11. topic_practice/package.xml 확인

topic_practice는 rclpy와 robot_interfaces를 사용합니다.

아래 의존성이 있는지 확인합니다.

<depend>rclpy</depend>
<depend>robot_interfaces</depend>

예시는 다음과 같습니다.

<?xml version="1.0"?>
<package format="3">
  <name>topic_practice</name>
  <version>0.0.0</version>
  <description>ROS 2 topic practice package</description>
  <maintainer email="user@example.com">user</maintainer>
  <license>Apache-2.0</license>

  <depend>rclpy</depend>
  <depend>robot_interfaces</depend>

  <test_depend>ament_copyright</test_depend>
  <test_depend>ament_flake8</test_depend>
  <test_depend>ament_pep257</test_depend>
  <test_depend>python3-pytest</test_depend>

  <export>
    <build_type>ament_python</build_type>
  </export>
</package>

12. 빌드하기

워크스페이스 루트로 이동합니다.

cd ~/ros2_lab_ws

빌드합니다.

colcon build --symlink-install

빌드가 끝나면 환경 설정을 적용합니다.

source install/setup.bash

매우 중요합니다.
빌드 후 source install/setup.bash를 하지 않으면 새 메시지나 실행 파일을 ROS 2가 못 찾습니다.

13. 메시지 생성 확인

사용자 정의 메시지가 정상 등록되었는지 확인합니다.

ros2 interface show robot_interfaces/msg/RobotStatus

정상이라면 다음처럼 출력됩니다.

string robot_id
string mode
float32 battery_percent
bool emergency_stop

14. Publisher 실행

첫 번째 터미널에서 실행합니다.

cd ~/ros2_lab_ws
source install/setup.bash
ros2 run topic_practice robot_status_pub

정상 출력 예시는 다음과 같습니다.

[INFO] [robot_status_pub]: Publish: robot_id=R-001, mode=MANUAL, battery=98.75, emergency=False
[INFO] [robot_status_pub]: Publish: robot_id=R-001, mode=AUTO, battery=97.50, emergency=False
[INFO] [robot_status_pub]: Publish: robot_id=R-001, mode=ERROR, battery=96.25, emergency=True
[INFO] [robot_status_pub]: Publish: robot_id=R-001, mode=IDLE, battery=95.00, emergency=False

확인할 것:

mode가 계속 바뀐다.
battery가 계속 줄어든다.
mode가 ERROR일 때 emergency_stop이 True가 된다.

15. Subscriber 실행

두 번째 터미널을 엽니다.

cd ~/ros2_lab_ws
source install/setup.bash
ros2 run topic_practice robot_status_sub

정상 출력 예시는 다음과 같습니다.

[INFO] [robot_status_sub]: Receive: R-001 | MANUAL | battery=98.75 | emergency=False
[INFO] [robot_status_sub]: Receive: R-001 | AUTO | battery=97.50 | emergency=False
[ERROR] [robot_status_sub]: Emergency detected: R-001 mode=ERROR
[INFO] [robot_status_sub]: Receive: R-001 | IDLE | battery=95.00 | emergency=False

여기서 핵심은 이것입니다.

mode=ERROR이면 Subscriber 로그가 [ERROR]로 출력된다.

즉, Subscriber가 단순 출력만 하는 게 아니라 메시지 내용을 보고 조건 판단까지 합니다.

16. CLI로 Topic 확인

Publisher가 실행 중인 상태에서 새 터미널을 엽니다.

cd ~/ros2_lab_ws
source install/setup.bash

Topic 목록 확인:

ros2 topic list

정상이라면 /robot_status가 보여야 합니다.

/robot_status
/parameter_events
/rosout

Topic 데이터 확인:

ros2 topic echo /robot_status

출력 예시:

robot_id: R-001
mode: AUTO
battery_percent: 97.5
emergency_stop: false
---
robot_id: R-001
mode: ERROR
battery_percent: 96.25
emergency_stop: true
---

Topic 주기 확인:

ros2 topic hz /robot_status

1초마다 발행하므로 약 1Hz가 나와야 합니다.

average rate: 1.000

17. 실습 확장 과제

과제 1. 배터리 20% 이하 경고 추가

Subscriber의 listener_callback()에 아래 조건을 추가합니다.

if msg.battery_percent <= 20.0:
    self.get_logger().warn(
        f'Low battery: {msg.robot_id} battery={msg.battery_percent:.2f}'
    )

과제 2. 로봇 ID 여러 개 사용

Publisher에서 로봇 ID를 리스트로 만듭니다.

self.robot_ids = ['R-001', 'R-002', 'R-003']

그리고 callback에서 바꿔가며 넣습니다.

msg.robot_id = self.robot_ids[self.count % len(self.robot_ids)]

과제 3. mode를 숫자로 바꾸기

실무에서는 문자열보다 숫자 상수를 쓰는 경우가 많습니다.

RobotStatus.msg를 다음처럼 바꿀 수 있습니다.

uint8 MODE_IDLE=0
uint8 MODE_MANUAL=1
uint8 MODE_AUTO=2
uint8 MODE_ERROR=3

string robot_id
uint8 mode
float32 battery_percent
bool emergency_stop

Publisher 예제 수정

기존에는 문자열로 이렇게 작성했을 수 있습니다.

msg.mode = "AUTO"

이제는 RobotStatus.msg에 정의한 상수를 사용합니다.

msg.mode = RobotStatus.MODE_AUTO

전체 예시는 다음과 같습니다.

import rclpy
from rclpy.node import Node

from my_robot_interfaces.msg import RobotStatus


class RobotStatusPublisher(Node):

    def __init__(self):
        super().__init__('robot_status_publisher')

        self.publisher = self.create_publisher(
            RobotStatus,
            'robot_status',
            10
        )
        
        self.robot_ids = ['R-001', 'R-002', 'R-003']

        self.timer = self.create_timer(1.0, self.publish_status)

    def publish_status(self):
        msg = RobotStatus()

        msg.robot_id = self.robot_ids[self.count % len(self.robot_ids)]
        msg.mode = RobotStatus.MODE_AUTO
        msg.battery_percent = 87.5
        msg.emergency_stop = False

        self.publisher.publish(msg)

        self.get_logger().info(
            f'Publish: robot_id={msg.robot_id}, '
            f'mode={msg.mode}, '
            f'battery={msg.battery_percent}, '
            f'emergency_stop={msg.emergency_stop}'
        )


def main(args=None):
    rclpy.init(args=args)

    node = RobotStatusPublisher()
    rclpy.spin(node)

    node.destroy_node()
    rclpy.shutdown()


if __name__ == '__main__':
    main()

Subscriber 예제 수정

Subscriber에서는 숫자 값을 직접 비교하지 말고, 메시지에 정의된 상수를 사용합니다.

if msg.mode == RobotStatus.MODE_AUTO:
    print("자동 주행 모드입니다.")

전체 예시는 다음과 같습니다.

import rclpy
from rclpy.node import Node

from my_robot_interfaces.msg import RobotStatus


class RobotStatusSubscriber(Node):

    def __init__(self):
        super().__init__('robot_status_subscriber')

        self.subscription = self.create_subscription(
            RobotStatus,
            'robot_status',
            self.status_callback,
            10
        )

    def status_callback(self, msg):
        if msg.mode == RobotStatus.MODE_IDLE:
            mode_text = 'IDLE'

        elif msg.mode == RobotStatus.MODE_MANUAL:
            mode_text = 'MANUAL'

        elif msg.mode == RobotStatus.MODE_AUTO:
            mode_text = 'AUTO'

        elif msg.mode == RobotStatus.MODE_ERROR:
            mode_text = 'ERROR'

        else:
            mode_text = 'UNKNOWN'

        self.get_logger().info(
            f'Receive: robot_id={msg.robot_id}, '
            f'mode={mode_text}, '
            f'battery={msg.battery_percent}, '
            f'emergency_stop={msg.emergency_stop}'
        )


def main(args=None):
    rclpy.init(args=args)

    node = RobotStatusSubscriber()
    rclpy.spin(node)

    node.destroy_node()
    rclpy.shutdown()


if __name__ == '__main__':
    main()

18. 전체 명령어 요약

처음부터 한 번에 정리하면 다음과 같습니다.

mkdir -p ~/ros2_lab_ws/src
cd ~/ros2_lab_ws/src

ros2 pkg create robot_interfaces --build-type ament_cmake

cd ~/ros2_lab_ws/src/robot_interfaces
mkdir msg
touch msg/RobotStatus.msg

RobotStatus.msg:

string robot_id
string mode
float32 battery_percent
bool emergency_stop

패키지 생성:

cd ~/ros2_lab_ws/src

ros2 pkg create topic_practice \
  --build-type ament_python \
  --dependencies rclpy robot_interfaces

Publisher 작성:

cd ~/ros2_lab_ws/src/topic_practice/topic_practice
gedit robot_status_pub.py

Subscriber 작성:

gedit robot_status_sub.py

빌드:

cd ~/ros2_lab_ws
colcon build --symlink-install
source install/setup.bash

메시지 확인:

ros2 interface show robot_interfaces/msg/RobotStatus

Publisher 실행:

ros2 run topic_practice robot_status_pub

Subscriber 실행:

ros2 run topic_practice robot_status_sub

Topic 확인:

ros2 topic list
ros2 topic echo /robot_status
ros2 topic hz /robot_status

Python 기본 타입 메시지 Publisher / Subscriber 예제

MakingRobotWizard — Tue, 26 May 2026 00:04:02 +0900

이번 실습에서는 직접 만든 메시지 타입을 사용해서 Publisher와 Subscriber가 통신하도록 구성합니다.

사용할 메시지 구조는 다음과 같습니다.

int32 id
float32 temperature
bool enabled
string name

최종 실행 구조는 다음과 같습니다.

basic_types_pub 노드
        ↓
/basic_types 토픽
        ↓
basic_types_sub 노드

1. 워크스페이스 생성

먼저 ROS 2 워크스페이스를 만듭니다.

mkdir -p ~/ros2_lab_ws/src
cd ~/ros2_lab_ws/src

구조는 다음과 같습니다.

~/ros2_lab_ws/
└── src/

2. 인터페이스 패키지 생성

사용자 정의 메시지는 일반 Python 패키지가 아니라 별도의 인터페이스 패키지에 두는 것이 정석입니다.

cd ~/ros2_lab_ws/src

ros2 pkg create robot_interfaces --build-type ament_cmake

생성 후 구조는 대략 다음과 같습니다.

ros2_lab_ws/src/
└── robot_interfaces/
    ├── CMakeLists.txt
    ├── package.xml
    └── include/

3. 메시지 파일 생성

robot_interfaces 패키지 안에 msg 폴더를 만듭니다.

mkdir -p ~/ros2_lab_ws/src/robot_interfaces/msg

메시지 파일을 생성합니다.

touch ~/ros2_lab_ws/src/robot_interfaces/msg/BasicTypes.msg

또는 VS Code를 사용하면 됩니다.

code ~/ros2_lab_ws/src/robot_interfaces/msg/BasicTypes.msg

다음 내용을 작성합니다.

int32 id
float32 temperature
bool enabled
string name

각 필드 의미는 다음과 같습니다.

필드 타입 의미

id	int32	로봇 번호, 데이터 순번
temperature	float32	온도, 거리, 전압 같은 실수 값
enabled	bool	활성화 여부
name	string	로봇 이름 또는 상태 이름

4. robot_interfaces 설정

1) package.xml 수정

파일을 엽니다.

gedit ~/ros2_lab_ws/src/robot_interfaces/package.xml

아래 의존성을 추가합니다.

<build_depend>rosidl_default_generators</build_depend>
<exec_depend>rosidl_default_runtime</exec_depend>

<member_of_group>rosidl_interface_packages</member_of_group>

전체 구조에서 중요한 부분은 다음과 같습니다.

<package format="3">
  <name>robot_interfaces</name>
  <version>0.0.0</version>
  <description>Custom interfaces for ROS 2 practice</description>
  <maintainer email="user@example.com">user</maintainer>
  <license>Apache-2.0</license>

  <buildtool_depend>ament_cmake</buildtool_depend>

  <build_depend>rosidl_default_generators</build_depend>
  <exec_depend>rosidl_default_runtime</exec_depend>

  <member_of_group>rosidl_interface_packages</member_of_group>

  <export>
    <build_type>ament_cmake</build_type>
  </export>
</package>

여기서 특히 중요합니다.

<member_of_group>rosidl_interface_packages</member_of_group>

이게 빠지면 인터페이스 패키지 빌드에서 문제가 날 수 있습니다.

2) CMakeLists.txt 수정

파일을 엽니다.

gedit ~/ros2_lab_ws/src/robot_interfaces/CMakeLists.txt

아래처럼 수정합니다.

cmake_minimum_required(VERSION 3.8)
project(robot_interfaces)

if(CMAKE_COMPILER_IS_GNUCXX OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
  add_compile_options(-Wall -Wextra -Wpedantic)
endif()

find_package(ament_cmake REQUIRED)
find_package(rosidl_default_generators REQUIRED)

rosidl_generate_interfaces(${PROJECT_NAME}
  "msg/BasicTypes.msg"
)

ament_package()

핵심은 이 부분입니다.

rosidl_generate_interfaces(${PROJECT_NAME}
  "msg/BasicTypes.msg"
)

이 설정이 있어야 ROS 2가 BasicTypes.msg를 실제 메시지 타입으로 생성합니다.

5. topic_practice 패키지 생성

이제 Publisher와 Subscriber를 작성할 Python 패키지를 만듭니다.

cd ~/ros2_lab_ws/src

ros2 pkg create topic_practice --build-type ament_python --dependencies rclpy robot_interfaces

생성 후 구조는 다음과 같습니다.

ros2_lab_ws/src/
├── robot_interfaces/
└── topic_practice/
    ├── package.xml
    ├── setup.py
    ├── resource/
    ├── test/
    └── topic_practice/
        └── __init__.py

6. Publisher 코드 작성

파일을 생성합니다.

cd ~/ros2_lab_ws/src/topic_practice/topic_practice
touch basic_types_pub.py

파일을 엽니다.

gedit basic_types_pub.py

아래 코드를 작성합니다.

import rclpy
from rclpy.node import Node

from robot_interfaces.msg import BasicTypes


class BasicTypesPublisher(Node):
    def __init__(self):
        super().__init__('basic_types_pub')

        self.publisher_ = self.create_publisher(
            BasicTypes,
            '/basic_types',
            10
        )

        self.timer = self.create_timer(1.0, self.timer_callback)
        self.count = 0

    def timer_callback(self):
        self.count += 1

        msg = BasicTypes()
        msg.id = self.count
        msg.temperature = 25.0 + self.count * 0.5
        msg.enabled = self.count % 2 == 1
        msg.name = f'robot_{self.count}'

        self.publisher_.publish(msg)

        self.get_logger().info(
            f'Publish: id={msg.id}, '
            f'temp={msg.temperature:.2f}, '
            f'enabled={msg.enabled}, '
            f'name={msg.name}'
        )


def main(args=None):
    rclpy.init(args=args)

    node = BasicTypesPublisher()

    rclpy.spin(node)

    node.destroy_node()
    rclpy.shutdown()


if __name__ == '__main__':
    main()

1) Publisher 코드 핵심

메시지 타입 가져오기

from robot_interfaces.msg import BasicTypes

robot_interfaces 패키지에 만든 BasicTypes.msg를 Python에서 가져옵니다.

2) Publisher 생성

self.publisher_ = self.create_publisher(
    BasicTypes,
    '/basic_types',
    10
)

의미는 다음과 같습니다.

BasicTypes 메시지를
/basic_types 토픽으로
큐 크기 10으로 발행한다

3) 1초마다 메시지 발행

self.timer = self.create_timer(1.0, self.timer_callback)

1초마다 timer_callback() 함수가 실행됩니다.

4) 메시지 값 대입

msg.id = self.count
msg.temperature = 25.0 + self.count * 0.5
msg.enabled = self.count % 2 == 1
msg.name = f'robot_{self.count}'

BasicTypes.msg에 작성한 필드 이름을 그대로 사용합니다.

BasicTypes.msg의 id          → msg.id
BasicTypes.msg의 temperature → msg.temperature
BasicTypes.msg의 enabled     → msg.enabled
BasicTypes.msg의 name        → msg.name

필드 이름이 다르면 에러가 납니다.

예를 들어 BasicTypes.msg에는 temperature가 있는데 코드에서 이렇게 쓰면 안 됩니다.

msg.temp = 25.5

올바른 코드는 다음입니다.

msg.temperature = 25.5

7. Subscriber 코드 작성

파일을 생성합니다.

cd ~/ros2_lab_ws/src/topic_practice/topic_practice
touch basic_types_sub.py

파일을 엽니다.

gedit basic_types_sub.py

아래 코드를 작성합니다.

import rclpy
from rclpy.node import Node

from robot_interfaces.msg import BasicTypes


class BasicTypesSubscriber(Node):
    def __init__(self):
        super().__init__('basic_types_sub')

        self.subscription = self.create_subscription(
            BasicTypes,
            '/basic_types',
            self.listener_callback,
            10
        )

    def listener_callback(self, msg):
        self.get_logger().info(
            f'Receive: id={msg.id}, '
            f'temp={msg.temperature:.2f}, '
            f'enabled={msg.enabled}, '
            f'name={msg.name}'
        )


def main(args=None):
    rclpy.init(args=args)

    node = BasicTypesSubscriber()

    rclpy.spin(node)

    node.destroy_node()
    rclpy.shutdown()


if __name__ == '__main__':
    main()

1) Subscriber 코드 핵심

Subscriber 생성

self.subscription = self.create_subscription(
    BasicTypes,
    '/basic_types',
    self.listener_callback,
    10
)

의미는 다음과 같습니다.

/basic_types 토픽에서
BasicTypes 메시지를 받으면
listener_callback 함수를 실행한다

2) 수신 데이터 확인

def listener_callback(self, msg):
    self.get_logger().info(
        f'Receive: id={msg.id}, '
        f'temp={msg.temperature:.2f}, '
        f'enabled={msg.enabled}, '
        f'name={msg.name}'
    )

Publisher가 보낸 메시지는 msg 변수로 들어옵니다.

8. setup.py 등록

ros2 run으로 실행하려면 setup.py에 실행 파일을 등록해야 합니다.

파일을 엽니다.

gedit ~/ros2_lab_ws/src/topic_practice/setup.py

entry_points 부분을 아래처럼 수정합니다.

entry_points={
    'console_scripts': [
        'basic_types_pub = topic_practice.basic_types_pub:main',
        'basic_types_sub = topic_practice.basic_types_sub:main',
    ],
},

전체 예시는 다음과 비슷합니다.

from setuptools import setup

package_name = 'topic_practice'

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']),
    ],
    install_requires=['setuptools'],
    zip_safe=True,
    maintainer='user',
    maintainer_email='user@example.com',
    description='ROS 2 topic practice package',
    license='Apache-2.0',
    tests_require=['pytest'],
    entry_points={
        'console_scripts': [
            'basic_types_pub = topic_practice.basic_types_pub:main',
            'basic_types_sub = topic_practice.basic_types_sub:main',
        ],
    },
)

9. topic_practice package.xml 확인

파일을 엽니다.

gedit ~/ros2_lab_ws/src/topic_practice/package.xml

아래 의존성이 들어 있어야 합니다.

<depend>rclpy</depend>
<depend>robot_interfaces</depend>

예시는 다음과 같습니다.

<package format="3">
  <name>topic_practice</name>
  <version>0.0.0</version>
  <description>ROS 2 topic practice package</description>
  <maintainer email="user@example.com">user</maintainer>
  <license>Apache-2.0</license>

  <depend>rclpy</depend>
  <depend>robot_interfaces</depend>

  <test_depend>ament_copyright</test_depend>
  <test_depend>ament_flake8</test_depend>
  <test_depend>ament_pep257</test_depend>
  <test_depend>python3-pytest</test_depend>

  <export>
    <build_type>ament_python</build_type>
  </export>
</package>

10. 빌드하기

워크스페이스 루트로 이동합니다.

cd ~/ros2_lab_ws

빌드합니다.

colcon build --symlink-install

빌드 후 환경 설정을 적용합니다.

source install/setup.bash

확실하게 하려면 메시지 인터페이스가 생성되었는지 확인합니다.

ros2 interface show robot_interfaces/msg/BasicTypes

정상 출력은 다음과 같습니다.

int32 id
float32 temperature
bool enabled
string name

11. 실행하기

터미널을 3개 열어서 확인하는 것이 좋습니다.

1) 터미널 1: Publisher 실행

cd ~/ros2_lab_ws
source install/setup.bash
ros2 run topic_practice basic_types_pub

예상 출력:

[INFO] [basic_types_pub]: Publish: id=1, temp=25.50, enabled=True, name=robot_1
[INFO] [basic_types_pub]: Publish: id=2, temp=26.00, enabled=False, name=robot_2
[INFO] [basic_types_pub]: Publish: id=3, temp=26.50, enabled=True, name=robot_3

2) 터미널 2: Subscriber 실행

cd ~/ros2_lab_ws
source install/setup.bash
ros2 run topic_practice basic_types_sub

예상 출력:

[INFO] [basic_types_sub]: Receive: id=1, temp=25.50, enabled=True, name=robot_1
[INFO] [basic_types_sub]: Receive: id=2, temp=26.00, enabled=False, name=robot_2
[INFO] [basic_types_sub]: Receive: id=3, temp=26.50, enabled=True, name=robot_3

Publisher에서 보낸 값과 Subscriber에서 받은 값이 같으면 정상입니다.

3) 터미널 3: CLI로 확인

토픽 목록 확인:

cd ~/ros2_lab_ws
source install/setup.bash
ros2 topic list

출력 목록에 아래 토픽이 있어야 합니다.

/basic_types

토픽 데이터 확인:

ros2 topic echo /basic_types

예상 출력:

id: 1
temperature: 25.5
enabled: true
name: robot_1
---
id: 2
temperature: 26.0
enabled: false
name: robot_2
---

토픽 정보 확인:

ros2 topic info /basic_types

예상 출력:

Type: robot_interfaces/msg/BasicTypes
Publisher count: 1
Subscription count: 1

여기서 봐야 할 것은 세 가지입니다.

12. 전체 폴더 구조

최종 구조는 다음과 비슷해야 합니다.

~/ros2_lab_ws/
└── src/
    ├── robot_interfaces/
    │   ├── CMakeLists.txt
    │   ├── package.xml
    │   └── msg/
    │       └── BasicTypes.msg
    │
    └── topic_practice/
        ├── package.xml
        ├── setup.py
        ├── resource/
        │   └── topic_practice
        └── topic_practice/
            ├── __init__.py
            ├── basic_types_pub.py
            └── basic_types_sub.py

13. 실습 과제

과제 1. voltage 필드 추가하기

BasicTypes.msg를 아래처럼 수정합니다.

int32 id
float32 temperature
bool enabled
string name
float32 voltage

Publisher에 추가합니다.

msg.voltage = 12.0 + self.count * 0.1

로그 출력도 수정합니다.

self.get_logger().info(
    f'Publish: id={msg.id}, '
    f'temp={msg.temperature:.2f}, '
    f'enabled={msg.enabled}, '
    f'name={msg.name}, '
    f'voltage={msg.voltage:.2f}'
)

Subscriber도 수정합니다.

self.get_logger().info(
    f'Receive: id={msg.id}, '
    f'temp={msg.temperature:.2f}, '
    f'enabled={msg.enabled}, '
    f'name={msg.name}, '
    f'voltage={msg.voltage:.2f}'
)

수정 후 반드시 다시 빌드합니다.

cd ~/ros2_lab_ws
colcon build --symlink-install
source install/setup.bash

과제 2. enabled 값에 따라 name 다르게 만들기

Publisher의 timer_callback() 안에서 아래 코드를 사용합니다.

if msg.enabled:
    msg.name = f'active_robot_{self.count}'
else:
    msg.name = f'inactive_robot_{self.count}'

예상 결과:

id=1, enabled=True, name=active_robot_1
id=2, enabled=False, name=inactive_robot_2
id=3, enabled=True, name=active_robot_3
id=4, enabled=False, name=inactive_robot_4

14. 최종 핵심 정리

사용자 정의 메시지는 robot_interfaces에 만든다.
Publisher와 Subscriber는 같은 메시지 타입을 사용해야 한다.
Publisher와 Subscriber는 같은 토픽 이름을 사용해야 한다.
setup.py에 실행 파일을 등록해야 ros2 run이 된다.
메시지 수정 후에는 반드시 colcon build와 source를 다시 한다.

최종 실행 명령어만 다시 정리하면 다음과 같습니다.

cd ~/ros2_lab_ws
colcon build --symlink-install
source install/setup.bash

Publisher:

ros2 run topic_practice basic_types_pub

Subscriber:

ros2 run topic_practice basic_types_sub

토픽 확인:

ros2 topic echo /basic_types

메시지 확인:

ros2 interface show robot_interfaces/msg/BasicTypes

ROS 2 개발자를 위한 C/C++ 기초강의 #1

MakingRobotWizard — Mon, 25 May 2026 15:56:30 +0900

ROS 2를 제대로 다루기 위해서는 C++ 문법에 대한 기본기가 필요합니다. ROS 2의 핵심 클라이언트 라이브러리인 rclcpp는 C++ 기반으로 작성되어 있으며, 실제 로봇 제어, 센서 처리, 드론 제어, 실시간 데이터 처리, 메시지 송수신 코드를 작성할 때 C++ 문법을 자연스럽게 사용하게 됩니다.

특히 ROS 2에서는 단순히 문법을 외우는 것보다 객체지향 구조, 포인터와 참조, 스마트 포인터, 클래스, 콜백 함수, 람다 함수, 템플릿, 네임스페이스, 빌드 구조를 이해하는 것이 중요합니다. 이 문법들은 ROS 2 코드에서 거의 매번 등장합니다.

1. C와 C++의 차이를 먼저 이해해야 합니다

C와 C++은 비슷해 보이지만 개발 방식에는 큰 차이가 있습니다.

C 언어는 절차지향 언어입니다. 프로그램을 함수 중심으로 구성하고, 데이터를 구조체로 묶어 사용합니다. 반면 C++은 C의 기능을 포함하면서도 클래스, 객체, 상속, 다형성, 템플릿, 스마트 포인터 같은 기능을 추가한 언어입니다.

로봇 개발에서는 아직도 C 언어가 많이 사용됩니다. 특히 MCU 펌웨어, 모터 제어, 센서 드라이버, 임베디드 제어 코드에서는 C 언어가 자주 사용됩니다.

반면 ROS 2의 상위 제어 로직, 경로 계획, 상태 관리, 센서 데이터 처리, 노드 구성 등은 C++로 작성하는 경우가 많습니다.

따라서 ROS 2 개발자는 C 문법도 어느 정도 이해해야 하고, C++ 문법도 익숙해야 합니다. 단순히 “C++만 알면 된다”가 아니라, C의 메모리 구조와 C++의 객체지향 구조를 함께 이해하는 것이 좋습니다.

2. C/C++ 실행환경 구성

a. 기본 개발 도구 확인하기

먼저 C/C++ 컴파일러와 빌드 도구가 설치되어 있는지 확인합니다.

터미널을 열고 다음 명령어를 입력합니다.

gcc --version
g++ --version
cmake --version
make --version

정상적으로 버전 정보가 출력되면 기본 도구가 설치되어 있는 것입니다.

만약 설치되어 있지 않다면 다음 명령어로 설치합니다.

sudo apt update
sudo apt install -y build-essential cmake gdb

각 도구의 역할은 다음과 같습니다.

gcc는 C 언어 컴파일러입니다.

g++는 C++ 컴파일러입니다.

cmake는 C/C++ 프로젝트 빌드 설정 도구입니다.

make는 실제 빌드 명령을 실행하는 도구입니다.

gdb는 C/C++ 디버깅 도구입니다.

b. 실습 폴더 만들기

먼저 C/C++ 문법 실습용 폴더를 만듭니다.

mkdir -p ~/cpp_practice
cd ~/cpp_practice

VSCode에서 해당 폴더를 열려면 다음 명령어를 사용합니다.

code .

이제 이 폴더 안에서 실습 파일을 만들면 됩니다.

c. 가장 간단한 C 프로그램 실습

먼저 C 언어 실습 파일을 하나 만듭니다.

파일 이름은 hello.c로 합니다.

#include <stdio.h>

int main() {
    printf("Hello C\n");
    return 0;
}

터미널에서 컴파일합니다.

gcc hello.c -o hello_c

실행합니다.

./hello_c

결과는 다음과 같습니다.

Hello C

여기서 반드시 이해해야 할 부분은 다음입니다.

gcc hello.c -o hello_c

이 명령어는 hello.c 파일을 컴파일해서 hello_c라는 실행 파일을 만들라는 뜻입니다.

./hello_c

이 명령어는 현재 폴더에 있는 hello_c 실행 파일을 실행하라는 뜻입니다.

d. 가장 간단한 C++ 프로그램 실습

이번에는 C++ 파일을 만들어 봅니다.

파일 이름은 hello.cpp로 합니다.

#include <iostream>

int main() {
    std::cout << "Hello C++" << std::endl;
    return 0;
}

컴파일합니다.

g++ hello.cpp -o hello_cpp

실행합니다.

./hello_cpp

결과는 다음과 같습니다.

Hello C++

C 파일은 gcc로 컴파일하고, C++ 파일은 g++로 컴파일합니다.

정리하면 다음과 같습니다.

gcc hello.c -o hello_c
g++ hello.cpp -o hello_cpp

3. 기본 자료형

프로그래밍에서 자료형은 데이터를 저장하는 방식입니다. C/C++에서는 변수마다 자료형을 지정해야 합니다.

대표적인 기본 자료형은 다음과 같습니다.

int age = 20;
float temperature = 36.5f;
double position = 12.345678;
char grade = 'A';
bool is_active = true;

int는 정수, float와 double은 실수, char는 문자, bool은 참 또는 거짓을 저장합니다.

로봇 개발에서는 자료형 선택이 중요합니다. 예를 들어 모터 속도, 센서 값, 좌표, 각도, 시간, 상태값 등을 저장할 때 적절한 자료형을 선택해야 합니다.

int motor_rpm = 1500;
double x_position = 1.25;
double yaw_angle = 0.785;
bool emergency_stop = false;

초보자들이 자주 하는 실수 중 하나는 모든 숫자를 무조건 int로 처리하는 것입니다. 하지만 위치, 속도, 각도, 시간처럼 소수점이 필요한 값은 float 또는 double을 사용해야 합니다.

일반적으로 PC나 ROS 2 환경에서는 정밀도가 높은 double을 많이 사용합니다. 반면 MCU 같은 임베디드 환경에서는 성능과 메모리 때문에 float를 사용하는 경우도 많습니다.

4. 변수와 상수

변수는 값이 바뀔 수 있는 저장 공간입니다.

int speed = 100;
speed = 150;

상수는 한 번 정하면 바뀌면 안 되는 값입니다. C++에서는 const를 사용합니다.

const double PI = 3.141592;
const int MAX_SPEED = 3000;

로봇 개발에서는 상수를 적극적으로 사용하는 것이 좋습니다. 예를 들어 최대 속도, 바퀴 반지름, 기어비, 제어 주기 같은 값은 코드 중간에 직접 숫자로 쓰는 것보다 상수로 정의하는 것이 안전합니다.

좋지 않은 예시는 다음과 같습니다.

double distance = rpm * 0.034 * 3.141592;

이 코드는 0.034가 무엇을 의미하는지 바로 알기 어렵습니다.

더 좋은 예시는 다음과 같습니다.

const double WHEEL_RADIUS = 0.034;
const double PI = 3.141592;

double distance = rpm * WHEEL_RADIUS * PI;

이렇게 작성하면 코드의 의미가 훨씬 분명해집니다.

5. 연산자

C/C++에서는 다양한 연산자를 사용합니다.

산술 연산자는 다음과 같습니다.

int a = 10;
int b = 3;

int sum = a + b;
int sub = a - b;
int mul = a * b;
int div = a / b;
int mod = a % b;

여기서 주의할 점은 정수끼리 나누면 결과도 정수라는 점입니다.

int a = 10;
int b = 3;

double result = a / b;

이 경우 result는 3.3333이 아니라 3.0이 됩니다. 왜냐하면 a / b가 먼저 정수 연산으로 처리되기 때문입니다.

정확한 실수 결과를 원하면 다음처럼 작성해야 합니다.

double result = static_cast<double>(a) / b;

ROS 2나 로봇 제어 코드에서는 속도, 거리, 각도, 시간 계산이 많기 때문에 정수 나눗셈 실수는 반드시 조심해야 합니다.

아래의 예제 소스를 작성하고 컴파일하여 실행결과를 확인하시기 바랍니다.

파일 이름은 01_variable.cpp입니다.

#include <iostream>
#include <string>

int main() {
    int motor_rpm = 1500;
    double battery_voltage = 12.5;
    bool is_motor_on = true;
    std::string robot_name = "mobile_robot";

    std::cout << "Robot name: " << robot_name << std::endl;
    std::cout << "Motor RPM: " << motor_rpm << std::endl;
    std::cout << "Battery voltage: " << battery_voltage << std::endl;
    std::cout << "Motor on: " << is_motor_on << std::endl;

    return 0;
}

컴파일합니다.

g++ -std=c++17 01_variable.cpp -o 01_variable
./01_variable

이 실습에서는 변수, 자료형, 문자열, 출력문을 함께 익힐 수 있습니다.

6. 조건문

조건문은 특정 조건에 따라 코드를 다르게 실행할 때 사용합니다.

int battery = 30;

if (battery < 20) {
    // 배터리 부족
} else if (battery < 50) {
    // 배터리 주의
} else {
    // 배터리 정상
}

로봇 개발에서는 조건문이 매우 많이 사용됩니다.

예를 들어 다음과 같은 상황에서 사용합니다.

if (emergency_stop == true) {
    motor_speed = 0;
}

또는 다음처럼 간단히 작성할 수 있습니다.

if (emergency_stop) {
    motor_speed = 0;
}

bool 변수는 이미 참 또는 거짓을 의미하므로 == true를 생략해도 됩니다.

조건이 복잡해질 때는 논리 연산자를 사용합니다.

if (battery_low && gps_ok) {
    // 배터리는 낮지만 GPS는 정상
}

if (obstacle_detected || emergency_stop) {
    // 장애물이 있거나 비상 정지 상태
}

&&는 AND, ||는 OR, !는 NOT을 의미합니다.

if (!sensor_ready) {
    // 센서가 준비되지 않았을 때
}

아래의 예제 소스를 작성하고 컴파일하여 실행결과를 확인하시기 바랍니다.

파일 이름은 02_if.cpp입니다.

#include <iostream>

int main() {
    double battery_voltage = 10.8;

    if (battery_voltage < 10.5) {
        std::cout << "Battery is low" << std::endl;
    } else if (battery_voltage < 11.5) {
        std::cout << "Battery warning" << std::endl;
    } else {
        std::cout << "Battery normal" << std::endl;
    }

    return 0;
}

컴파일과 실행은 다음과 같습니다.

ROS 2 Humble의 C++ 코드는 일반적으로 C++14 이상 문법을 사용하며, 실습에서는 C++17 기준으로 공부해도 괜찮습니다.

C++17 옵션을 붙여 컴파일하려면 다음처럼 작성합니다.

g++ -std=c++17 hello.cpp -o hello_cpp

앞으로 C++ 실습에서는 다음 명령어를 기본으로 사용하면 좋습니다.

g++ -std=c++17 파일이름.cpp -o 실행파일이름

g++ -std=c++17 02_if.cpp -o 02_if
./02_if

battery_voltage 값을 직접 바꿔 보면서 출력결과를 확인하시기 바랍니다.

예를 들어 다음 값으로 바꿔 봅니다.

double battery_voltage = 9.8;
double battery_voltage = 10.8;
double battery_voltage = 12.2;

값에 따라 출력 결과가 달라지는 것을 확인하면 조건문을 쉽게 이해할 수 있습니다.

7. 반복문

반복문은 같은 작업을 여러 번 수행할 때 사용합니다.

대표적으로 for, while, do-while이 있습니다.

for (int i = 0; i < 10; i++) {
    // 10번 반복
}

배열이나 벡터의 데이터를 처리할 때 많이 사용합니다.

double sensor_values[5] = {1.0, 2.0, 3.0, 4.0, 5.0};

for (int i = 0; i < 5; i++) {
    double value = sensor_values[i];
}

while문은 조건이 참인 동안 계속 반복합니다.

while (is_running) {
    // 실행 중일 때 계속 반복
}

로봇 프로그램에서는 무한 반복 구조를 자주 볼 수 있습니다. 하지만 ROS 2에서는 일반적인 while(true) 반복보다는 콜백, 타이머, executor 구조를 많이 사용합니다. 그래도 C/C++ 기본 반복문을 이해해야 ROS 2 내부 동작과 일반 제어 루프를 이해할 수 있습니다.

아래의 예제 소스를 작성하고 컴파일하여 실행결과를 확인하시기 바랍니다.

파일 이름은 03_for.cpp입니다.

#include <iostream>

int main() {
    for (int i = 0; i < 5; i++) {
        std::cout << "Control loop count: " << i << std::endl;
    }

    return 0;
}

컴파일합니다.

g++ -std=c++17 03_for.cpp -o 03_for
./03_for

로봇 제어에서는 반복문을 제어 루프와 연결해서 설명하면 좋습니다.

8. 배열

배열은 같은 자료형의 데이터를 여러 개 저장하는 구조입니다.

int numbers[5] = {1, 2, 3, 4, 5};

배열의 인덱스는 0부터 시작합니다.

int first = numbers[0];
int second = numbers[1];

초보자가 자주 하는 실수는 배열 범위를 넘어 접근하는 것입니다.

int numbers[5] = {1, 2, 3, 4, 5};

int wrong = numbers[5];

위 코드는 잘못된 코드입니다. 배열 크기가 5이면 접근 가능한 인덱스는 0부터 4까지입니다.

C 스타일 배열은 빠르고 단순하지만, 크기 관리가 불편합니다. C++에서는 보통 std::array나 std::vector를 더 많이 사용합니다.

아래의 예제 소스를 작성하고 컴파일하여 실행결과를 확인하시기 바랍니다.

04_array.cpp 파일에 다음 코드를 작성합니다.

배열의 값은 인덱스를 사용해서 변경할 수 있습니다.

motor_rpm[0] = 1500;

다음 예제를 작성해 보겠습니다.

#include <iostream>

int main() {
    int motor_rpm[4] = {1200, 1350, 1280, 1420};

    std::cout << "Before update" << std::endl;

    for (int i = 0; i < 4; i++) {
        std::cout << "Motor " << i + 1 << " RPM: "
                  << motor_rpm[i] << std::endl;
    }

    motor_rpm[0] = 1500;
    motor_rpm[1] = 1500;

    std::cout << std::endl;
    std::cout << "After update" << std::endl;

    for (int i = 0; i < 4; i++) {
        std::cout << "Motor " << i + 1 << " RPM: "
                  << motor_rpm[i] << std::endl;
    }

    return 0;
}

컴파일하고 실행합니다.

g++ -std=c++17 04_array.cpp -o 04_array
./04_array

실행 결과는 다음과 비슷합니다.

Before update
Motor 1 RPM: 1200
Motor 2 RPM: 1350
Motor 3 RPM: 1280
Motor 4 RPM: 1420

After update
Motor 1 RPM: 1500
Motor 2 RPM: 1500
Motor 3 RPM: 1280
Motor 4 RPM: 1420

이 실습을 통해 배열의 특정 위치에 있는 값을 직접 바꿀 수 있다는 것을 확인할 수 있습니다.

9. std::vector

std::vector는 C++에서 가장 많이 사용하는 동적 배열입니다. 크기를 자동으로 조절할 수 있습니다.

#include <vector>

std::vector<int> numbers;

numbers.push_back(10);
numbers.push_back(20);
numbers.push_back(30);

값을 읽을 때는 배열처럼 접근할 수 있습니다.

int value = numbers[0];

전체 데이터를 반복할 때는 다음처럼 작성할 수 있습니다.

for (int i = 0; i < numbers.size(); i++) {
    int value = numbers[i];
}

더 현대적인 C++ 문법으로는 range-based for문을 사용합니다.

for (int value : numbers) {
    // value 사용
}

값을 복사하지 않고 참조로 받고 싶다면 다음처럼 작성합니다.

for (const auto& value : numbers) {
    // value 읽기 전용 사용
}

ROS 2 개발에서는 여러 개의 좌표, 센서값, 경로점, 객체 목록 등을 다룰 때 std::vector를 자주 사용합니다. 초중급자는 반드시 익숙해져야 합니다.

아래의 예제 소스를 작성하고 컴파일하여 실행결과를 확인하시기 바랍니다.

파일 이름은 05_vector.cpp입니다.

#include <iostream>
#include <vector>

int main() {
    std::vector<double> sensor_values;

    sensor_values.push_back(1.2);
    sensor_values.push_back(2.5);
    sensor_values.push_back(3.1);

    for (const auto& value : sensor_values) {
        std::cout << "Sensor value: " << value << std::endl;
    }

    return 0;
}

컴파일합니다.

g++ -std=c++17 05_vector.cpp -o 05_vector
./05_vector

std::vector는 ROS 2 개발에서도 매우 자주 사용됩니다. 센서값 목록, 경로점 목록, 좌표 목록 등을 저장할 때 사용하기 좋습니다.

10. 문자열

C 언어에서는 문자열을 char 배열로 다룹니다.

char name[] = "robot";

C++에서는 보통 std::string을 사용합니다.

#include <string>

std::string robot_name = "mobile_robot";

문자열을 합칠 수도 있습니다.

std::string frame_id = "base_link";
std::string topic_name = "/robot/" + frame_id;

단, 문자열 리터럴끼리 바로 더하는 것은 문제가 될 수 있습니다.

std::string text = std::string("robot") + "_1";

ROS 2 개발에서는 토픽 이름, 프레임 이름, 파라미터 이름, 로그 메시지 등을 다룰 때 문자열을 많이 사용합니다. 따라서 std::string 사용법은 기본적으로 알고 있어야 합니다.

아래의 예제 소스를 작성하고 컴파일하여 실행결과를 확인하시기 바랍니다.

파일 이름은 06_string.cpp입니다.

이번에는 로봇 이름, 센서 이름, 프레임 이름을 문자열로 저장해 보겠습니다.

#include <iostream>
#include <string>

int main() {
    std::string robot_name = "delivery_robot";
    std::string sensor_name = "lidar";
    std::string frame_id = "base_link";

    std::cout << "Robot name: " << robot_name << std::endl;
    std::cout << "Sensor name: " << sensor_name << std::endl;
    std::cout << "Frame ID: " << frame_id << std::endl;

    return 0;
}

컴파일하고 실행합니다.

g++ -std=c++17 06_string.cpp -o 06_string
./06_string

실행 결과는 다음과 비슷합니다.

Robot name: delivery_robot
Sensor name: lidar
Frame ID: base_link

이 예제에서는 문자열 변수를 여러 개 만들고 출력하는 방법을 익힐 수 있습니다.

11. 함수

함수는 반복되는 코드를 하나로 묶는 방법입니다.

int add(int a, int b) {
    return a + b;
}

함수를 호출할 때는 다음처럼 사용합니다.

int result = add(3, 5);

로봇 개발에서는 계산식이나 반복 작업을 함수로 분리하는 것이 중요합니다.

double rpmToVelocity(double rpm, double wheel_radius) {
    const double PI = 3.141592;
    return (rpm / 60.0) * 2.0 * PI * wheel_radius;
}

이렇게 작성하면 속도 계산 코드를 여러 곳에서 재사용할 수 있습니다.

함수를 잘 나누면 코드가 짧아지고, 테스트하기 쉬워지고, 나중에 수정하기도 편해집니다.

아래의 예제 소스를 작성하고 컴파일하여 실행결과를 확인하시기 바랍니다.

파일 이름은 07_fuction.cpp입니다.

#include <iostream>

double rpmToVelocity(double rpm, double wheel_radius) {
    const double PI = 3.141592;
    return (rpm / 60.0) * 2.0 * PI * wheel_radius;
}

int main() {
    double rpm = 1500.0;
    double wheel_radius = 0.05;

    double velocity = rpmToVelocity(rpm, wheel_radius);

    std::cout << "Velocity: " << velocity << " m/s" << std::endl;

    return 0;
}

컴파일합니다.

g++ -std=c++17 07_function.cpp -o 07_function
./07_function

이 예제는 단순한 문법 예제보다 좋습니다. 학생들이 로봇 개발에서 자주 만나는 속도 계산과 함수 개념을 같이 배울 수 있기 때문입니다.

12. 값 전달과 참조 전달

C++ 함수에서 인자를 전달하는 방식은 매우 중요합니다.

먼저 값 전달입니다.

void changeValue(int x) {
    x = 100;
}

int a = 10;
changeValue(a);

이 경우 a의 값은 바뀌지 않습니다. 함수 안의 x는 a를 복사한 별도의 값이기 때문입니다.

참조 전달은 원본을 직접 다룹니다.

void changeValue(int& x) {
    x = 100;
}

int a = 10;
changeValue(a);

이 경우 a는 100으로 바뀝니다.

읽기만 할 때는 const 참조를 많이 사용합니다.

void printName(const std::string& name) {
    // name을 읽기만 함
}

const std::string&는 문자열을 복사하지 않고 참조하되, 함수 안에서 수정하지 못하게 합니다.

ROS 2 C++ 코드에서도 const auto&, const std::shared_ptr<...>&, const 메시지타입::SharedPtr 같은 형태가 자주 등장합니다. 그래서 참조와 const 개념은 반드시 이해해야 합니다.

13. 포인터

포인터는 메모리 주소를 저장하는 변수입니다.

int value = 10;
int* ptr = &value;

&value는 value 변수의 주소를 의미합니다. ptr은 그 주소를 저장합니다.

포인터가 가리키는 실제 값에 접근하려면 *를 사용합니다.

int data = *ptr;

포인터는 강력하지만 위험합니다. 잘못된 주소를 가리키거나 이미 해제된 메모리를 접근하면 프로그램이 비정상 종료될 수 있습니다.

int* ptr = nullptr;

nullptr은 아무것도 가리키지 않는 포인터를 의미합니다. C++에서는 예전의 NULL보다 nullptr을 사용하는 것이 좋습니다.

포인터를 사용할 때는 항상 유효한 주소인지 확인하는 습관이 필요합니다.

if (ptr != nullptr) {
    int value = *ptr;
}

ROS 2에서는 일반 포인터보다 스마트 포인터를 훨씬 많이 사용합니다. 하지만 스마트 포인터를 이해하려면 먼저 일반 포인터 개념을 알고 있어야 합니다.

아래의 예제 소스를 작성하고 컴파일하여 실행결과를 확인하시기 바랍니다.

파일 이름은 08_pointer.cpp입니다.

#include <iostream>

int main() {
    int motor_rpm = 1500;

    int* ptr = &motor_rpm;

    std::cout << "motor_rpm value: " << motor_rpm << std::endl;
    std::cout << "motor_rpm address: " << &motor_rpm << std::endl;
    std::cout << "ptr value: " << ptr << std::endl;
    std::cout << "ptr points to value: " << *ptr << std::endl;

    return 0;
}

컴파일합니다.

g++ -std=c++17 08_pointer.cpp -o 08_pointer

실행합니다.

./08_pointer

실행 결과는 다음과 비슷하게 나옵니다.

motor_rpm value: 1500
motor_rpm address: 0x7ffc1a2b3c4d
ptr value: 0x7ffc1a2b3c4d
ptr points to value: 1500

주소값은 실행 환경마다 다르게 나옵니다.

14. 구조체

구조체는 여러 데이터를 하나로 묶는 자료형입니다.

struct MotorState {
    double rpm;
    double current;
    double temperature;
};

사용할 때는 다음처럼 작성합니다.

MotorState motor;

motor.rpm = 1500.0;
motor.current = 2.5;
motor.temperature = 45.0;

구조체는 관련 있는 데이터를 묶을 때 좋습니다.

예를 들어 로봇 위치를 다음처럼 표현할 수 있습니다.

struct Position {
    double x;
    double y;
    double theta;
};

그리고 함수의 인자로 사용할 수 있습니다.

void printPosition(const Position& pos) {
    // pos.x, pos.y, pos.theta 사용
}

C에서는 구조체가 단순히 데이터 묶음에 가깝지만, C++에서는 구조체 안에 함수도 넣을 수 있습니다. C++의 struct와 class는 기본 접근 제한자가 다르다는 점을 제외하면 매우 비슷합니다.

아래의 예제 소스를 작성하고 컴파일하여 실행결과를 확인하시기 바랍니다.

파일 이름은 09_struct.cpp입니다.

#include <iostream>

struct MotorState {
    double rpm;
    double current;
    double temperature;
};

int main() {
    MotorState motor;

    motor.rpm = 1500.0;
    motor.current = 2.5;
    motor.temperature = 42.0;

    std::cout << "Motor RPM: " << motor.rpm << std::endl;
    std::cout << "Motor current: " << motor.current << std::endl;
    std::cout << "Motor temperature: " << motor.temperature << std::endl;

    return 0;
}

컴파일합니다.

g++ -std=c++17 09_struct.cpp -o 09_struct

실행합니다.

./09_struct

실행 결과는 다음과 같습니다.

Motor RPM: 1500
Motor current: 2.5
Motor temperature: 42

로봇 개발자를 위한 Python 기초 교육 #3

MakingRobotWizard — Mon, 25 May 2026 11:04:00 +0900

21. JSON 다루기

로봇 설정이나 웨이포인트 파일은 JSON 형식으로 저장하는 경우가 많습니다.

예를 들어 다음과 같은 JSON 파일이 있다고 가정합니다.

{
    "robot_name": "delivery_robot",
    "max_speed": 1.2,
    "waypoints": [
        [0.0, 0.0],
        [1.0, 0.0],
        [1.0, 1.0]
    ]
}

Python에서 JSON을 읽으려면 json 모듈을 사용합니다.

import json

with open("config.json", "r") as file:
    config = json.load(file)

print(config["robot_name"])
print(config["max_speed"])
print(config["waypoints"])

Python 딕셔너리를 JSON 파일로 저장할 수도 있습니다.

import json

config = {
    "robot_name": "delivery_robot",
    "max_speed": 1.2,
    "waypoints": [
        [0.0, 0.0],
        [1.0, 0.0],
        [1.0, 1.0]
    ]
}

with open("config.json", "w") as file:
    json.dump(config, file, indent=4)

한글이 들어간 JSON을 저장할 때는 다음처럼 쓰는 것이 좋습니다.

with open("config.json", "w", encoding="utf-8") as file:
    json.dump(config, file, indent=4, ensure_ascii=False)

a. open("config.json", "w", encoding="utf-8")

open("config.json", "w", encoding="utf-8")

config.json 파일을 엽니다.

"config.json": 저장할 파일 이름
"w": 쓰기 모드
encoding="utf-8": 한글이 깨지지 않도록 UTF-8 사용

주의할 점은 "w" 모드는 기존 파일이 있으면 내용을 지우고 새로 씁니다.

config['hangul_test']="한글입력"

입력하고 아래의 명령어로 파일을 저장합니다.

with open("config_han.json", "w", encoding="utf-8") as file:
    json.dump(config, file, indent=4)

config_han.json 파일을 노트북에서 열어 보면 한글이 저장됨을 확인할 수 있습니다. jupyter_ws폴더로 이동하여 gedit로 config_han.json을 열어보면 한글 부분에 unicode 문자가 저장되어 있습니다.

b. with ... as file

with open(...) as file:

파일을 열고 작업이 끝나면 자동으로 닫아줍니다.

원래는 파일을 열면 마지막에 이렇게 닫아야 합니다.

file.close()

하지만 with를 쓰면 자동으로 닫히기 때문에 더 안전합니다.

c. json.dump(config, file, ...)

json.dump(config, file, indent=4, ensure_ascii=False)

config 데이터를 JSON 형식으로 바꿔서 파일에 저장합니다.

예를 들어:

config = {
    "name": "드론",
    "speed": 10
}

이라면 config.json 파일에 이렇게 저장됩니다.

{
    "name": "드론",
    "speed": 10
}

d. indent=4

indent=4

JSON 파일을 보기 좋게 들여쓰기합니다. 없으면 한 줄로 저장될 수 있습니다.

{"name":"드론","speed":10}

indent=4를 쓰면 보기 좋게 저장됩니다.

{
    "name": "드론",
    "speed": 10
}

e. ensure_ascii=False

ensure_ascii=False

한글을 그대로 저장하게 합니다.

이 옵션이 없으면 한글이 이런 식으로 저장될 수 있습니다.

"\ub4dc\ub860"

ensure_ascii=False를 쓰면 이렇게 저장됩니다.

"드론"

22. None

None은 값이 없다는 뜻입니다.

target = None

아직 목표 지점이 없거나, 센서 값이 유효하지 않을 때 사용할 수 있습니다.

target_position = None

if target_position is None:
    print("No target position")
else:
    print("Move to target")

None을 비교할 때는 보통 ==보다 is를 사용합니다.

if target_position is None:
    print("target is none")

함수에서 실패를 표시할 때도 사용할 수 있습니다.

def find_nearest_obstacle(ranges):
    valid_ranges = [r for r in ranges if r > 0]

    if len(valid_ranges) == 0:
        return None

    return min(valid_ranges)

nearest = find_nearest_obstacle([-1, -1, -1])

if nearest is None:
    print("No valid obstacle data")
else:
    print(f"nearest obstacle: {nearest}")

23. Boolean 판단 규칙

Python에서는 값 자체가 참 또는 거짓처럼 평가될 수 있습니다.

다음 값들은 거짓으로 판단됩니다.

False
None
0
0.0
""
[]
{}
()

예를 들어 빈 리스트는 False처럼 동작합니다.

waypoints = []

if not waypoints:
    print("No waypoints")

값이 있으면 True처럼 동작합니다.

waypoints = [[0.0, 0.0], [1.0, 0.0]]

if waypoints:
    print("Waypoint list exists")

로봇 경로, 센서 데이터, 설정값 검사에서 자주 사용됩니다.

24. in 연산자

in은 어떤 값이 포함되어 있는지 확인할 때 사용합니다.

modes = ["manual", "auto", "emergency"]

if "auto" in modes:
    print("auto mode supported")

딕셔너리에서는 key가 있는지 확인할 때 사용합니다.

config = {
    "max_speed": 1.0,
    "wheel_radius": 0.05
}

if "max_speed" in config:
    print(config["max_speed"])

문자열에서도 사용할 수 있습니다.

message = "robot emergency stop"

if "emergency" in message:
    print("Emergency message detected")

25. min(), max(), sum()

센서 데이터 처리에 매우 자주 쓰입니다.

ranges = [1.2, 0.8, 2.0, 0.5]

print(min(ranges))  # 0.5
print(max(ranges))  # 2.0
print(sum(ranges))  # 4.5

평균값 계산:

average = sum(ranges) / len(ranges)

print(average)

라이다 거리 중 가장 가까운 장애물을 찾을 때:

lidar_ranges = [2.0, 1.5, 0.9, 0.7, 1.2]

nearest_obstacle = min(lidar_ranges)

print(f"nearest obstacle: {nearest_obstacle} m")

단, 빈 리스트에 min()을 사용하면 에러가 납니다.

ranges = []

if ranges:
    nearest = min(ranges)
    print(nearest)
else:
    print("No range data")

26. 정렬

리스트를 정렬할 때는 sort() 또는 sorted()를 사용합니다.

data = [3, 1, 4, 2]

data.sort()

print(data)

출력:

[1, 2, 3, 4]

sort()는 원본 리스트를 직접 변경합니다.

반면 sorted()는 정렬된 새 리스트를 반환합니다.

data = [3, 1, 4, 2]

sorted_data = sorted(data)

print(data)
print(sorted_data)

딕셔너리 리스트도 정렬할 수 있습니다.

robots = [
    {"name": "robot_a", "battery": 80},
    {"name": "robot_b", "battery": 50},
    {"name": "robot_c", "battery": 95}
]

robots_sorted = sorted(robots, key=lambda robot: robot["battery"])

print(robots_sorted)

sorted() 함수는 robots 리스트를 정렬합니다. 이때 key 옵션에 lambda robot: robot["battery"]를 넣었기 때문에, 각 로봇 딕셔너리의 "battery" 값을 기준으로 정렬합니다.

배터리 값은 robot_b가 50, robot_a가 80, robot_c가 95이므로 작은 값부터 정렬하면 다음과 같은 순서가 됩니다.

[
    {"name": "robot_b", "battery": 50},
    {"name": "robot_a", "battery": 80},
    {"name": "robot_c", "battery": 95}
]

마지막으로 print(robots_sorted)는 정렬된 결과를 화면에 출력합니다. 원본 robots 리스트는 그대로 두고, 정렬된 새 리스트가 robots_sorted에 저장됩니다.

배터리가 높은 순서로 정렬(내림차순)하려면 reverse=True를 사용합니다.

robots_sorted = sorted(
    robots,
    key=lambda robot: robot["battery"],
    reverse=True
)

print(robots_sorted)

27. 람다 함수

lambda는 이름 없는 짧은 함수입니다.

double = lambda x: x * 2

print(double(3))

하지만 로봇 개발 초보 단계에서는 lambda를 남발하지 않는 것이 좋습니다. 주로 sorted()의 key처럼 간단한 기준을 줄 때 사용합니다.

points = [
    {"x": 1.0, "y": 2.0},
    {"x": 0.5, "y": 1.5},
    {"x": 2.0, "y": 0.5}
]

points_sorted = sorted(points, key=lambda p: p["x"])

print(points_sorted)

28. zip()

zip()은 여러 리스트를 동시에 묶어서 반복할 때 사용합니다.

left_speeds = [1.0, 1.1, 1.2]
right_speeds = [1.0, 1.0, 1.1]

for left, right in zip(left_speeds, right_speeds):
    print(f"left={left}, right={right}")

출력:

left=1.0, right=1.0
left=1.1, right=1.0
left=1.2, right=1.1

시간과 센서 데이터를 묶을 수도 있습니다.

times = [0.0, 0.1, 0.2]
distances = [1.5, 1.4, 1.3]

for t, d in zip(times, distances):
    print(f"time={t}, distance={d}")

29. enumerate()

enumerate()는 반복하면서 인덱스도 같이 얻을 때 사용합니다.

waypoints = [
    [0.0, 0.0],
    [1.0, 0.0],
    [1.0, 1.0]
]

for index, point in enumerate(waypoints):
    print(f"{index}: {point}")

출력:

0: [0.0, 0.0]
1: [1.0, 0.0]
2: [1.0, 1.0]

시작 인덱스를 1로 바꿀 수도 있습니다.

for index, point in enumerate(waypoints, start=1):
    print(f"waypoint {index}: {point}")

출력:

waypoint 1: [0.0, 0.0]
waypoint 2: [1.0, 0.0]
waypoint 3: [1.0, 1.0]

30. 언패킹

리스트나 튜플의 값을 여러 변수에 한 번에 넣을 수 있습니다.

position = [1.0, 2.0, 0.5]

x, y, yaw = position

print(x)
print(y)
print(yaw)

웨이포인트를 처리할 때도 좋습니다.

waypoint = [3.0, 4.0]

x, y = waypoint

print(f"x={x}, y={y}")

함수 반환값에서도 자주 사용합니다.

def get_velocity():
    linear_x = 0.5
    angular_z = 0.1
    return linear_x, angular_z

linear_x, angular_z = get_velocity()

print(linear_x)
print(angular_z)

31. 가변 인자 *args

함수에 여러 개의 값을 유동적으로 전달하고 싶을 때 *args를 사용합니다. 개수는 정해지지 않아도 됩니다.

def print_values(*args):
    for value in args:
        print(value)

print_values(1, 2, 3)
print_values("x", "y", "z")

센서 값을 여러 개 받아 평균을 구할 수도 있습니다.

def average(*values):
    if not values:
        return 0.0

    return sum(values) / len(values)

print(average(1.0, 2.0, 3.0))

32. 키워드 가변 인자 **kwargs

**kwargs는 이름이 있는 여러 인자를 딕셔너리 형태로 받습니다.

def print_config(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_config(max_speed=1.0, wheel_radius=0.05, use_lidar=True)

출력:

max_speed: 1.0
wheel_radius: 0.05
use_lidar: True

설정값을 유연하게 받는 함수에서 사용할 수 있습니다.

def create_robot_config(**kwargs):
    config = {
        "max_speed": 1.0,
        "wheel_radius": 0.05,
        "use_lidar": False
    }

    config.update(kwargs)
    return config

config = create_robot_config(max_speed=1.5, use_lidar=True)

print(config)

33. 얕은 복사와 깊은 복사

리스트나 딕셔너리를 다룰 때 매우 중요합니다.

a = [1, 2, 3]
b = a

b[0] = 100

print(a)
print(b)

출력:

[100, 2, 3]
[100, 2, 3]

b = a는 복사가 아니라 같은 리스트를 가리키는 것입니다.

진짜 복사하려면 다음처럼 합니다.

a = [1, 2, 3]
b = a.copy()

b[0] = 100

print(a)
print(b)

출력:

[1, 2, 3]
[100, 2, 3]

하지만 중첩 리스트에서는 문제가 생길 수 있습니다.

path_a = [[0, 0], [1, 1]]
path_b = path_a.copy()

path_b[0][0] = 100

print(path_a)
print(path_b)

중첩 구조까지 완전히 복사하려면 copy.deepcopy()를 사용합니다.

import copy

path_a = [[0, 0], [1, 1]]
path_b = copy.deepcopy(path_a)

path_b[0][0] = 100

print(path_a)
print(path_b)

로봇 경로, 설정 딕셔너리, 센서 데이터 버퍼를 복사할 때 이 차이를 모르면 버그가 납니다.

34. 타입 힌트

타입 힌트는 변수나 함수 인자의 자료형을 표시하는 문법입니다.

def calculate_speed(distance: float, time: float) -> float:
    return distance / time

이 부분은 함수가 결과로 float 값을 반환한다는 의미입니다. 즉, 계산 결과가 소수점 숫자일 수 있다는 뜻입니다.

Python은 타입 힌트를 강제로 검사하지는 않습니다. 하지만 코드를 읽기 쉬워지고, IDE나 코드 분석 도구가 실수를 더 잘 잡아줍니다.

로봇 개발에서는 타입 힌트를 쓰는 것이 좋습니다.

def limit_speed(speed: float, max_speed: float) -> float:
    if speed > max_speed:
        return max_speed

    if speed < -max_speed:
        return -max_speed

    return speed

리스트 타입도 표시할 수 있습니다.

def average(values: list[float]) -> float:
    if not values:
        return 0.0

    return sum(values) / len(values)

딕셔너리 타입도 표시할 수 있습니다.

def print_robot_config(config: dict[str, float]) -> None:
    for key, value in config.items():
        print(key, value)

None을 반환하는 함수는 -> None으로 표시합니다.

def stop_robot() -> None:
    print("stop")

35. dataclass

클래스 문법 자체는 별도 주제지만, Python에서 설정값이나 데이터를 묶을 때 dataclass는 매우 유용합니다.

from dataclasses import dataclass

@dataclass
class RobotPose:
    x: float
    y: float
    yaw: float

사용 예시는 다음과 같습니다.

pose = RobotPose(x=1.0, y=2.0, yaw=0.5)

print(pose.x)
print(pose.y)
print(pose.yaw)

일반 클래스보다 훨씬 간단하게 데이터 구조를 만들 수 있습니다.

로봇 설정값에도 사용할 수 있습니다.

from dataclasses import dataclass

@dataclass
class MotorConfig:
    motor_id: int
    gear_ratio: float
    encoder_resolution: int
    max_rpm: float

config = MotorConfig(
    motor_id=1,
    gear_ratio=30.0,
    encoder_resolution=4096,
    max_rpm=3000.0
)

print(config)

출력 예시:

MotorConfig(motor_id=1, gear_ratio=30.0, encoder_resolution=4096, max_rpm=3000.0)

딕셔너리보다 구조가 명확하고, 오타를 줄일 수 있습니다.

36. with 문

with는 자원을 안전하게 열고 닫을 때 사용합니다.

가장 대표적인 예는 파일입니다.

with open("log.txt", "w") as file:
    file.write("robot started\n")

with를 사용하면 파일을 직접 close()하지 않아도 됩니다.

로봇 개발에서는 로그 파일, 설정 파일, 데이터 기록 파일을 자주 다루므로 with 문은 필수입니다.

나쁜 예:

file = open("log.txt", "w")
file.write("data\n")
file.close()

좋은 예:

with open("log.txt", "w") as file:
    file.write("data\n")

37. 모듈과 import: 기능 가져오기

Python은 필요한 기능을 가져와서 씁니다.

import math

angle = math.radians(90)
print(angle)

출력:

1.5707963267948966

자주 쓰는 기본 모듈:

모듈 용도

math	수학 계산
time	시간 지연, 시간 측정
random	랜덤값
os	파일, 폴더 경로
csv	CSV 파일 처리
json	JSON 파일 처리

시간 지연 예제:

import time

print("모터 ON")
time.sleep(1.0)
print("1초 후 모터 OFF")

로봇 제어 루프 예제:

import time

while True:
    print("센서 읽기")
    print("제어 계산")
    print("명령 출력")

    time.sleep(0.1)

time.sleep(0.1)은 0.1초 대기입니다.
즉, 대략 10Hz 루프입니다.

38. 모듈 실행 진입점 if name == "main"

Python 파일을 직접 실행할 때만 특정 코드가 실행되게 만들 수 있습니다.

def main():
    print("robot program start")

if __name__ == "__main__":
    main()

이 구조는 매우 중요합니다.

예를 들어 robot_utils.py 파일이 있다고 가정합니다.

def calculate_speed(distance, time):
    return distance / time

def main():
    print("test")
    print(calculate_speed(10, 2))

if __name__ == "__main__":
    main()

이 파일을 직접 실행하면 main()이 실행됩니다.

python3 robot_utils.py

하지만 다른 파일에서 import하면 main()은 실행되지 않습니다.

from robot_utils import calculate_speed

speed = calculate_speed(5, 2)
print(speed)

로봇 프로젝트에서는 테스트 코드와 실제 재사용 함수를 분리할 때 꼭 필요합니다.

39. assert

assert는 조건이 맞는지 검사하는 문법입니다.

speed = 1.0

assert speed >= 0.0

조건이 거짓이면 에러가 발생합니다.

speed = -1.0

assert speed >= 0.0

메시지를 추가할 수도 있습니다.

speed = -1.0

assert speed >= 0.0, "speed must be positive"

로봇 코드에서는 계산 함수 테스트에 유용합니다.

def clamp(value, min_value, max_value):
    if value < min_value:
        return min_value

    if value > max_value:
        return max_value

    return value

assert clamp(5, 0, 10) == 5
assert clamp(-1, 0, 10) == 0
assert clamp(15, 0, 10) == 10

단, assert를 안전 로직으로 사용하면 안 됩니다. 실제 로봇 정지, 충돌 방지, 비상 정지 같은 기능은 명시적인 조건문으로 처리해야 합니다.

40. 유용한 표준 라이브러리

Python에는 기본으로 제공되는 라이브러리가 많습니다. 로봇 개발에서 자주 쓰는 것들은 다음과 같습니다.

a. math

수학 계산에 사용합니다.

import math

angle = math.pi / 2
print(math.sin(angle))
print(math.cos(angle))

거리 계산:

import math

def distance_2d(x1, y1, x2, y2):
    dx = x2 - x1
    dy = y2 - y1
    return math.sqrt(dx * dx + dy * dy)

print(distance_2d(0, 0, 3, 4))

또는 hypot()을 사용할 수 있습니다.

import math

distance = math.hypot(3, 4)

print(distance)  # 5.0

b. time

시간 지연이나 현재 시간 확인에 사용합니다.

import time

print("start")
time.sleep(1.0)
print("after 1 second")

현재 시간:

import time

now = time.time()
print(now)

간단한 주기 실행:

import time

period = 0.1

for i in range(10):
    start_time = time.time()

    print(f"loop {i}")

    elapsed = time.time() - start_time
    sleep_time = period - elapsed

    if sleep_time > 0:
        time.sleep(sleep_time)

c. os

파일 경로, 폴더 확인, 환경 변수 등에 사용합니다.

import os

print(os.getcwd())

파일 존재 확인:

import os

if os.path.exists("config.json"):
    print("config exists")
else:
    print("config not found")

폴더 생성:

import os

os.makedirs("logs", exist_ok=True)

d. pathlib

파일 경로를 다룰 때 os.path보다 보기 좋습니다.

from pathlib import Path

log_dir = Path("logs")
log_dir.mkdir(exist_ok=True)

log_file = log_dir / "robot_log.txt"

with open(log_file, "w") as file:
    file.write("robot started\n")

파일 존재 확인:

from pathlib import Path

config_path = Path("config.json")

if config_path.exists():
    print("config file exists")

e. csv

센서 데이터나 로그 데이터를 CSV로 저장할 때 사용합니다.

import csv

data = [
    [0.0, 1.2],
    [0.1, 1.3],
    [0.2, 1.1]
]

with open("sensor_log.csv", "w", newline="") as file:
    writer = csv.writer(file)
    writer.writerow(["time", "distance"])
    writer.writerows(data)

CSV 읽기:

import csv

with open("sensor_log.csv", "r") as file:
    reader = csv.reader(file)

    for row in reader:
        print(row)

41. 초보자가 자주 하는 실수

a. =와 ==를 혼동함

speed = 1.0

=는 값을 넣는 것입니다.

if speed == 1.0:
    print("speed is 1.0")

==는 같은지 비교하는 것입니다.

b. 리스트 복사를 잘못함

a = [1, 2, 3]
b = a

이건 복사가 아닙니다. 같은 리스트를 가리키는 것입니다.

b = a.copy()

또는 중첩 구조라면:

import copy

b = copy.deepcopy(a)

c. 빈 리스트에서 min() 사용

ranges = []

nearest = min(ranges)

이 코드는 에러가 납니다.

안전하게 작성해야 합니다.

if ranges:
    nearest = min(ranges)
else:
    nearest = None

d. 파일을 닫지 않음

나쁜 예:

file = open("log.txt", "w")
file.write("data")

좋은 예:

with open("log.txt", "w") as file:
    file.write("data")

e. 예외 처리를 너무 넓게 함

나쁜 예:

try:
    value = int("abc")
except:
    print("error")

좋은 예:

try:
    value = int("abc")
except ValueError:
    print("invalid number")

무조건 except:로 모든 에러를 숨기면 실제 버그를 찾기 어렵습니다.

f. 변수 이름을 대충 지음

나쁜 예:

a = 1.0
b = 2.0
c = a / b

좋은 예:

distance = 1.0
time_sec = 2.0
speed = distance / time_sec

로봇 코드는 센서, 좌표, 속도, 시간, 각도 단위가 섞입니다. 변수 이름을 명확하게 짓지 않으면 나중에 반드시 고생합니다.

MakingRobot

Odometry 프로그래밍

1. ROS 2 모바일 로봇 전체 흐름

2. ROS 좌표계: odom, base_link, map

3. /cmd_vel 메시지 이해

4. 엔코더 기반 Odometry 유도

5. 인터페이스 패키지에 EncoderTicks 메시지 추가

6. /cmd_vel을 좌우 바퀴 속도로 변환하는 Python 노드

7. 가상 Encoder Tick 발행 노드 만들기

8. Encoder Tick을 거리로 변환하는 Python 노드

9. Python으로 Encoder Odometry 노드 구현하기

10. Python용 Launch 파일 만들기

11) 빌드 및 실행

12. RViz2에서 확인하는 방법

13. 실제 로봇 보정 절차

14. Odometry Drift 확인 실습

15. Covariance를 잘못 넣으면 생기는 문제

16. 자주 발생하는 문제와 해결 방향

17. 실전에서 권장하는 Odometry 구조

18. 요약

강의자료 준비

10일차 강의

launch 파일에서 실행 인자 사용하기 #2

4. launch 파일에서 remapping 사용하기

5. 새로운 remapping launch 파일 생성

5. launch 파일에서 namespace를 변수로 받기

6. launch 파일에서 조건부 실행하기

7. 다른 launch 파일 포함하기

8. 모바일 로봇 시스템 예시 launch 구성

GIMP를 이용한 지도 파일 .pgm 수정

1. GIMP 설치

2. ROS 2 지도 파일 구조

3. GIMP로 지도 열기

4. 수정 전 백업

5. GIMP에서 주로 사용하는 도구

6. 대표적인 지도 수정 작업

8. YAML 파일 수정

9. 수정한 지도 실행

Cancel 테스트용 Action Client 만들기

1. Cancel 기능 실습 개요

2. Cancel 테스트용 Action Client 파일 만들기

3. Cancel 테스트용 Action Client 전체 코드

4. import 부분 설명

6. 생성자 __init__() 설명

7. send_goal() 함수 설명

8. goal_response_callback() 함수 설명

9. feedback_callback() 함수 설명

10. cancel_goal() 함수 설명

11. cancel_done_callback() 함수 설명

12. get_result_callback() 함수 설명

13. main() 함수 설명

14. setup.py에 실행 파일 등록하기

15. 빌드하기

16. Action Server 실행하기

17. Cancel 테스트용 Action Client 실행하기

18. 실행 결과 확인하기

ROS 2 Python Topic 실습 : RobotStatus 메시지로 로봇 상태 주고받기

1. 최종 목표

2. 워크스페이스 생성

3. msg 폴더 생성

5. topic_practice 패키지 생성

6. Publisher 코드 작성

7. Subscriber 코드 작성

8. robot_interfaces/package.xml 수정

9. robot_interfaces/CMakeLists.txt 수정

10. setup.py 수정

11. topic_practice/package.xml 확인

12. 빌드하기

13. 메시지 생성 확인

14. Publisher 실행

15. Subscriber 실행

16. CLI로 Topic 확인

17. 실습 확장 과제

18. 전체 명령어 요약

Python 기본 타입 메시지 Publisher / Subscriber 예제

1. 워크스페이스 생성

2. 인터페이스 패키지 생성

3. 메시지 파일 생성

4. robot_interfaces 설정

5. topic_practice 패키지 생성

6. 생성자 init() 설명

38. 모듈 실행 진입점 if name == "main"