CH09ROS 2 Humble 과 myAGV Plus 패키지
노드 · 토픽 · 메시지로 이루어진 ROS 2 의 구조를 익히고, myagv_plus_ros2 워크스페이스를 빌드해 bringup · 키보드 · 조이스틱 제어와 rclpy 노드를 만듭니다.
학습 목표#
- 노드 · 토픽 · 메시지 · 퍼블리셔 · 서브스크라이버 · 서비스 · 파라미터를 구분하고, 퍼블리시 주기 · 큐 크기 · 처리 시간이 메시지 누락과 지연을 어떻게 바꾸는지 시뮬레이터로 예측 · 확인할 수 있습니다.
geometry_msgs/Twist의 linear.x · linear.y · angular.z 를 ch03 의 vx · vy · ω 와 짝짓고, Twist 한 개가 네 바퀴 속도로 바뀌는 과정을 계산할 수 있습니다.- myAGV Plus 전용 저장소 myagv_plus_ros2 (humble 브랜치) 를 clone → rosdep → colcon build → source 순서로 빌드하고, 빌드가 메모리 부족으로 실패할 때
MAKEFLAGS=-j5·--parallel-workers 1로 고칠 수 있습니다. - bringup 을 실행한 뒤
ros2 node list·topic list·topic hz로 상태를 확인하고, 키보드(teleop_twist_keyboard) · 조이스틱으로 로봇을 조종하며 Shift(옆 · 대각 평행 이동) 의 의미를 설명할 수 있습니다. - rclpy 로 퍼블리셔 노드(2 m 전진 후 정지)와 안전 정지 노드(전방 ±15° 최소 거리)를 만들고,
ROS_DOMAIN_ID·ROS_LOCALHOST_ONLY로 여러 대의 로봇이 서로 간섭하지 않게 할 수 있습니다.
이 페이지에는 브라우저에서 바로 동작하는 시뮬레이터 6개가 있습니다. ROS 2 가 설치되지 않은 컴퓨터에서도 토픽 · 큐 · 빌드 · 키보드 조종 · 안전 정지 · 도메인 ID 를 직접 조작해 볼 수 있습니다. 조작하기 전에 결과를 먼저 예측해 적고, 확인하세요. Playground 실습(표준 라이브러리 + numpy)은 시뮬레이터와 같은 규칙으로 만들었습니다. 실습 1-1 은 시뮬레이터 1 의 "📊 10초 측정" 과, 실습 4-2 는 시뮬레이터 5 의 "📊 비교" 와 같은 숫자가 나옵니다. 실제 ROS 2 코드(rclpy)는 "실물 전용" 블록으로 따로 둡니다.
공식 자료 기준 (myagvPlus_docs 6.2.1 · 6.2.3, myagv_plus_ros2 README): myAGV Plus 는 Jetson Orin Nano Super · Ubuntu 22.04 · ROS 2 Humble. 소스는 myagv_plus_ros2 저장소의 humble 브랜치이며 출고 시 미리 빌드되어 있음. 처음 빌드는 약 30 분. 빌드 오류 시 export MAKEFLAGS="-j5" 와 colcon build --parallel-workers 1 --cmake-args -DCMAKE_BUILD_TYPE=Release. 실행 전 source ~/myagv_plus_ros2/install/local_setup.bash. bringup 명령 ros2 launch myagv_plus_bringup myagv_plus_bringup.launch.py. 키보드 ros2 run teleop_twist_keyboard teleop_twist_keyboard, 조이스틱 ros2 run myagv_plus_joystick_control joystick_controller (빨간 불만 켜지면 MODE 3초). DDS 도메인 ID 기본값 0, 로봇마다 다르게 하거나 ROS_LOCALHOST_ONLY=1. 확인 필요: bringup 이 띄우는 노드 · 토픽의 정확한 이름, LiDAR 주기, 베이스 드라이버가 /cmd_vel 이 끊겼을 때 멈추는지(타임아웃), 조이스틱 노드가 메시지를 계속 보내는지. 이 페이지는 이런 값을 로봇에서 직접 확인하는 방법을 가르칩니다. 교육용 가정: 시뮬레이터의 네트워크 지연(5 ms) · 재전송 지연, 빌드 메모리 · 시간 모델, 피킹 스테이션 · 혼잡 통로 지도, 사람의 움직임, 가감속 한계(1 m/s²), 바퀴 치수(ch03 과 같음 r = 0.05 m, lx + ly = 0.22 m).
1교시 · ROS 2 의 구조: 노드 · 토픽 · 메시지#
왜 ROS 2 인가#
ch04 · ch05 에서는 pymycobot 의 MyAGVPlus 로 Python 프로그램 하나가 로봇을 직접 움직였습니다. 자율주행 로봇은 LiDAR 읽기, 오도메트리 계산, 지도 만들기, 경로 계획, 바퀴 제어가 동시에 돌아야 합니다. 이걸 프로그램 하나에 다 넣으면 한 곳이 멈출 때 전부 멈추고, 남이 만든 SLAM · 내비게이션 코드를 가져다 쓰기도 어렵습니다.
ROS 2(Robot Operating System 2)는 기능을 작은 프로그램(노드)으로 나누고, 노드끼리 이름 붙은 통로(토픽)로 메시지를 주고받게 하는 미들웨어입니다. myAGV Plus 는 Ubuntu 22.04 위에서 ROS 2 Humble 을 씁니다(ch01).
노드 · 토픽 · 메시지 · 서비스 · 파라미터#
| 개념 | 뜻 | myAGV Plus 예 | 확인 명령 |
|---|---|---|---|
| 노드(node) | 한 가지 일을 하는 실행 중인 프로그램 | 베이스 드라이버, LiDAR 드라이버, teleop | ros2 node list |
| 토픽(topic) | 이름 붙은 메시지 통로 (1 : N, N : 1 가능) | /cmd_vel, /scan | ros2 topic list |
| 메시지(message) | 토픽에 흐르는 데이터의 형식 | geometry_msgs/msg/Twist | ros2 interface show <타입> |
| 퍼블리셔(publisher) | 토픽에 메시지를 보내는 쪽 | teleop → /cmd_vel | ros2 topic info /cmd_vel -v |
| 서브스크라이버(subscriber) | 토픽의 메시지를 받는 쪽 | 베이스 드라이버 ← /cmd_vel | 같음 |
| 서비스(service) | 요청 1번 → 응답 1번 (함수 호출처럼) | 지도 저장, 설정 바꾸기 등 | ros2 service list |
| 파라미터(parameter) | 노드 안의 설정값 (실행 중에도 바꿀 수 있음) | 속도 한계, 프레임 이름 | ros2 param list |
- 토픽은 계속 흐르는 데이터(센서 · 속도 명령)에, 서비스는 가끔 하는 요청에 씁니다. 오래 걸리고 중간 경과가 필요한 일(목표 지점까지 주행)은 액션(action) 으로 하며 ch10 의 Nav2 에서 다룹니다.
- 토픽에는 "마지막 값" 이 저장되어 있지 않습니다. 메시지는 한 번 보내지고 끝입니다. 받는 쪽이 그 값을 얼마나 오래 쓰는지는 받는 노드가 정합니다. 이 사실이 시뮬레이터 1 의 핵심입니다.
DDS 와 ROS_DOMAIN_ID#
ROS 2 에는 중앙 서버(ROS 1 의 roscore)가 없습니다. 노드는 DDS(Data Distribution Service)라는 통신 규격으로 같은 네트워크의 다른 노드를 자동으로 찾아 직접 연결합니다. 편리하지만, 같은 Wi-Fi 에 로봇이 여러 대면 남의 로봇 노드까지 찾아 버립니다.
이를 나누는 번호가 ROS_DOMAIN_ID 입니다(기본값 0). 번호가 같은 노드끼리만 서로 봅니다. 공식 문서도 같은 LAN 에 로봇이 두 대면 export ROS_DOMAIN_ID=1, =2 처럼 다르게 하라고 안내합니다. 4교시 시뮬레이터 6 에서 직접 확인합니다.
이동 로봇의 핵심 토픽#
| 토픽(대표 이름) | 메시지 타입 | 방향 | 내용 | 관련 차시 |
|---|---|---|---|---|
/cmd_vel | geometry_msgs/msg/Twist | 나 → 로봇 | 속도 명령 (vx, vy, ω) | ch03 · ch04 |
/odom | nav_msgs/msg/Odometry | 로봇 → 나 | 바퀴로 추정한 위치 · 속도 | ch06 |
/scan | sensor_msgs/msg/LaserScan | 로봇 → 나 | LiDAR 한 바퀴 거리 배열 | ch07 |
/imu | sensor_msgs/msg/Imu | 로봇 → 나 | 각속도 · 가속도 · 자세 | ch06 |
/tf, /tf_static | tf2_msgs/msg/TFMessage | 로봇 → 나 | 좌표계 사이 변환 (map → odom → base_footprint → 센서) | ch02 |
위 표는 ROS 의 관례적인 이름입니다. myAGV Plus 의 bringup 이 실제로 어떤 이름을 쓰는지(예: /imu 인지 /imu/data 인지)는 이 페이지에서 단정하지 않습니다. 로봇에서 ros2 topic list -t 로 이름과 타입을 함께 확인하고, 다르면 여러분 코드의 토픽 이름을 맞춥니다.
시뮬레이터 1 · ROS 2 토픽 시뮬레이터: 주기 · 큐 · 지연#
teleop(퍼블리셔)이 /cmd_vel 에 Twist 를 보내고, 베이스 드라이버(서브스크라이버)가 받아 로봇을 움직입니다. 메시지는 네트워크를 지나 구독자 큐에 쌓였다가, 콜백이 하나씩 꺼내 처리합니다. 큐가 꽉 찼는데 새 메시지가 오면 가장 오래된 것을 버립니다(KEEP_LAST). 1 ms 단위로 흉내 냅니다.
- 기본값(10 Hz · 타임아웃 없음)에서 로봇이 움직이는 중에 ⏹ 퍼블리셔 끄기 를 누르기 전에 예측합니다: 로봇은 멈출까요, 계속 갈까요? 확인한 뒤 ↺ 처음부터 → 드라이버 타임아웃을 0.5 s 로 바꾸고 다시 해 봅니다.
- 퍼블리시 주기를 30 Hz, 콜백 처리 시간을 50 ms 로 바꿉니다. 1초에 몇 개를 처리할 수 있을까요? "최근 1초 수신" 과 "큐에서 버림" 을 봅니다.
- 2번 상태에서 큐 크기를 10 → 1 → 50 으로 바꾸며 매번 ■ 정지 명령 을 누르고 "정지 명령 → 실제 정지" 시간을 잽니다(또는 📊 10초 측정). 큐가 클수록 좋을까요?
- 기본값으로 돌아가 네트워크 손실을 20 % 로 올리고, 신뢰성을 RELIABLE ↔ BEST_EFFORT 로 바꿔 봅니다. 노란 점(다시 보낸 메시지)과 "손실" 칸이 어떻게 달라지나요?
- 주기를 2 Hz, 타임아웃을 0.5 s 로 하면 로봇이 어떻게 움직일까요? 타임아웃과 퍼블리시 주기 사이에 지켜야 할 관계를 한 문장으로 적어 봅니다.
- 토픽에는 "현재 값" 이 저장되지 않습니다. 퍼블리셔가 꺼지면 메시지가 더 오지 않을 뿐이고, 타임아웃이 없는 드라이버는 마지막으로 받은 0.3 m/s 를 계속 써서 벽까지 갑니다. 타임아웃 0.5 s 면 약 0.5 s 뒤에 멈춥니다. 실제 myAGV Plus 드라이버가 어느 쪽인지는 확인 필요이므로, 여러분의 노드는 끝날 때 반드시 0 을 한 번 이상 보내도록 만듭니다(4교시).
- 콜백이 50 ms 걸리면 1초에 최대 20개만 처리합니다. 30 Hz 로 보내면 남는 10개/s 는 큐에서 버려집니다. 📊 10초 측정: 30 Hz · 50 ms 에서 depth 1 → 정지 지연 55 ms, depth 10 → 355 ms, depth 50 → 1705 ms. 큐가 크면 덜 버리지만 오래된 명령을 줄 서서 처리하느라 정지가 늦어집니다. 속도 명령처럼 "최신 값만 중요한" 토픽은 큐를 작게 둡니다.
- BEST_EFFORT 는 잃어버린 메시지를 그냥 버리고(손실 칸 증가), RELIABLE 은 다시 보내느라 늦게 도착합니다(노란 점). 센서 데이터(
/scan)는 보통 BEST_EFFORT, 명령 · 지도는 RELIABLE 을 씁니다. 둘이 맞지 않으면 통신이 아예 안 됩니다(자주 나는 오류 7). - 2 Hz 로 보내는데 타임아웃이 0.5 s 면 메시지 사이 간격(0.5 s)마다 멈췄다 갔다 합니다. 타임아웃 > 퍼블리시 간격 × 2~3 이 되게 잡습니다.
Twist 메시지와 메카넘 로봇#
/cmd_vel 의 메시지 타입 geometry_msgs/msg/Twist 는 선속도 3개 · 각속도 3개로 이루어져 있습니다. 지상 로봇은 그중 세 개만 씁니다.
| Twist 필드 | ch03 기호 | 단위 | 뜻 (로봇 기준) |
|---|---|---|---|
linear.x | vx | m/s | 앞(+) · 뒤(−) |
linear.y | vy | m/s | 왼쪽(+) · 오른쪽(−) — 메카넘만 의미 있음 |
angular.z | ω | rad/s | 위에서 봐서 반시계(+) |
# 메시지 구조 보기
ros2 interface show geometry_msgs/msg/Twist
# 한 번만 보내 보기 (왼쪽 옆걸음 0.1 m/s) - 로봇이 움직입니다. 공간 확보 후 실행!
ros2 topic pub --once /cmd_vel geometry_msgs/msg/Twist "{linear: {x: 0.0, y: 0.1, z: 0.0}, angular: {x: 0.0, y: 0.0, z: 0.0}}"베이스 드라이버는 Twist 를 받아 ch03 의 역기구학으로 네 바퀴 속도를 만듭니다. 차동 구동 로봇(이전 모델 myAGV 의 Nav2 설정은 max_vel_y: 0.0, ch08)은 linear.y 를 무시하지만, myAGV Plus 는 세 값을 모두 독립적으로 씁니다.
시뮬레이터 2 · Twist → 네 바퀴 속도#
- i 와 Shift+J 버튼을 차례로 누르기 전에, 네 바퀴가 각각 어느 방향으로 돌지 예측합니다. ch03 의 "대각선 바퀴 쌍" 규칙과 맞나요?
- u(전진 + 왼쪽 회전)와 Shift+U(왼쪽 앞 대각 평행 이동)의 3초 궤적을 비교합니다. 몸의 방향(빨간 삼각형)은 어떻게 다른가요?
- 차동 구동 로봇이라면 을 켜고 Shift+J 를 누르면? 같은
/cmd_vel메시지가 로봇 종류에 따라 다르게 해석되는 것을 확인합니다. - 빠른 대각 + 회전(1.2, 1.0, 3.0)을 누릅니다. 어느 바퀴가 한계를 넘나요? 줄인 뒤에도 궤적의 모양은 같고 속도만 줄어드는지 확인합니다.
- i(0.5, 0, 0): 네 바퀴 모두 +0.50 m/s(10 rad/s). Shift+J(0, 0.5, 0): FL · RR 은 −0.5, FR · RL 은 +0.5 — 대각선 쌍이 서로 반대로 돕니다(ch03).
- Shift+U(0.5, 0.5, 0): FL · RR 은 0, FR · RL 은 +1.0 m/s. 대각 이동은 두 바퀴만 일합니다. u 는 몸이 돌며 원호를 그리고, Shift+U 는 몸 방향을 유지한 채 45° 로 미끄러지듯 갑니다.
- 빠른 대각 + 회전: FR 이 1.6 m/s 를 넘어(줄이기 전 약 2.86 m/s) 네 바퀴를 모두 약 56 % 로 줄입니다. 한 바퀴만 자르면 비율이 깨져 엉뚱한 방향으로 가므로 모두 같은 비율로 줄입니다(ch03 2교시와 같은 원리). 실제 드라이버의 한계 처리 방식은 확인 필요입니다.
실습 과제 1#
시뮬레이터 1 의 규칙(1 ms 단위, 네트워크 5 ms, KEEP_LAST 큐, 콜백 처리 시간)을 Python 으로 옮겼습니다. TODO 두 곳을 채워 10초 동안 0.3 m/s 를 보내다가 5초에 0 으로 바꿨을 때 보낸 · 받은 · 버린 수, 평균 지연, 정지 지연을 구하세요. 예측 먼저: 30 Hz · 콜백 50 ms 에서 depth 를 1 → 10 → 50 으로 키우면 정지 지연은 어떻게 될까요?
from collections import deque
def measure(f_hz, depth, proc_ms, net_ms=5, T=10000, switch_at=5000):
next_pub, seq = 0.0, 0
flying, queue, busy = [], deque(), None
cmd, v_pub = 0.0, 0.3
sent = rx = drop = 0
lat_sum, stop_delay = 0, None
for t in range(T): # 1 ms 씩
if t == switch_at:
v_pub = 0.0 # 5 초에 정지 명령으로 바꿈
if t >= next_pub: # 퍼블리시
seq += 1
sent += 1
flying.append({"seq": seq, "stamp": t, "v": v_pub, "arrive": t + net_ms})
next_pub += 1000 / f_hz
for m in [m for m in flying if m["arrive"] <= t]: # 도착 -> 큐
flying.remove(m)
# TODO 1: 큐가 꽉 찼으면(len(queue) >= depth) 가장 오래된 것을 버리고 drop 을 1 늘립니다
queue.append(m)
if busy and t >= busy["end"]: # 콜백 끝 -> 드라이버 명령 갱신
cmd = busy["v"]
rx += 1
# TODO 2: 지연(t - 보낸 시각)을 lat_sum 에 더합니다
busy = None
if busy is None and queue: # 다음 메시지 처리 시작
busy = queue.popleft()
busy["end"] = t + proc_ms
if t >= switch_at and stop_delay is None and cmd == 0:
stop_delay = t - switch_at
return sent, rx, drop, (lat_sum / rx if rx else 0), stop_delay
print(" 주기 depth 처리 보냄 받음 버림 평균지연 정지지연")
for f, d, p in [(10, 10, 20), (30, 10, 50), (30, 1, 50), (30, 50, 50), (10, 10, 150)]:
s, r, dr, lat, sd = measure(f, d, p)
print("%3d Hz %5d %4d ms %5d %5d %5d %7.1f ms %6s ms" % (f, d, p, s, r, dr, lat, sd))풀이 코드 보기
from collections import deque
def measure(f_hz, depth, proc_ms, net_ms=5, T=10000, switch_at=5000):
next_pub, seq = 0.0, 0
flying, queue, busy = [], deque(), None
cmd, v_pub = 0.0, 0.3
sent = rx = drop = 0
lat_sum, stop_delay = 0, None
for t in range(T): # 1 ms 씩
if t == switch_at:
v_pub = 0.0 # 5 초에 정지 명령으로 바꿈
if t >= next_pub: # 퍼블리시
seq += 1
sent += 1
flying.append({"seq": seq, "stamp": t, "v": v_pub, "arrive": t + net_ms})
next_pub += 1000 / f_hz
for m in [m for m in flying if m["arrive"] <= t]: # 도착 -> 큐
flying.remove(m)
if len(queue) >= depth: # KEEP_LAST: 가장 오래된 것을 버림
queue.popleft()
drop += 1
queue.append(m)
if busy and t >= busy["end"]: # 콜백 끝 -> 드라이버 명령 갱신
cmd = busy["v"]
rx += 1
lat_sum += t - busy["stamp"]
busy = None
if busy is None and queue: # 다음 메시지 처리 시작
busy = queue.popleft()
busy["end"] = t + proc_ms
if t >= switch_at and stop_delay is None and cmd == 0:
stop_delay = t - switch_at
return sent, rx, drop, (lat_sum / rx if rx else 0), stop_delay
print(" 주기 depth 처리 보냄 받음 버림 평균지연 정지지연")
for f, d, p in [(10, 10, 20), (30, 10, 50), (30, 1, 50), (30, 50, 50), (10, 10, 150)]:
s, r, dr, lat, sd = measure(f, d, p)
print("%3d Hz %5d %4d ms %5d %5d %5d %7.1f ms %6s ms" % (f, d, p, s, r, dr, lat, sd))실행 결과:
주기 depth 처리 보냄 받음 버림 평균지연 정지지연
10 Hz 10 20 ms 100 100 0 25.0 ms 25 ms
30 Hz 10 50 ms 300 199 90 352.2 ms 355 ms
30 Hz 1 50 ms 300 199 99 67.9 ms 55 ms
30 Hz 50 50 ms 300 199 50 1286.0 ms 1705 ms
10 Hz 10 150 ms 100 66 24 943.6 ms 1155 ms- 시뮬레이터 1 의 📊 10초 측정 과 같은 숫자가 나옵니다(손실 0 %).
- 처리 능력(1000 / 50 = 20 Hz)보다 빨리 보내면 받는 수는 약 200개로 같고, depth 에 따라 버리는 수와 지연만 달라집니다. depth 1 은 많이 버리지만 항상 최신 명령을 처리해 55 ms 만에 멈춥니다.
- depth 50 은 덜 버리지만 오래된 0.3 m/s 명령 50개가 줄 서 있어 정지가 1.7 s 늦어집니다. 0.5 m/s 로 달리던 로봇이라면 약 0.85 m 더 갑니다.
- 콜백이 느린(150 ms) 노드는 주기가 10 Hz 로 낮아도 밀립니다. 콜백 안에서 오래 걸리는 일(파일 저장,
time.sleep)을 하지 않는 것이 중요합니다.
(1) twist_to_wheels() 의 TODO 를 채워 Twist(dict) 를 네 바퀴 각속도로 바꾸고, 한 바퀴라도 둘레 속도 1.6 m/s 를 넘으면 모두 같은 비율로 줄이세요. (2) mine 딕셔너리에 토픽별 메시지 타입을 적어 채점해 보세요. 예측 먼저: Shift+U(0.5, 0.5, 0) 에서 멈추는 바퀴는 어느 것일까요?
import numpy as np
R = 0.05 # 바퀴 반지름 (m) - ch03 과 같은 교육용 치수
LXY = 0.22 # lx + ly (m)
RIM_MAX = 1.6 # 바퀴 둘레 속도 한계 (m/s)
# [w_fl, w_fr, w_rl, w_rr] = J @ [vx, vy, wz]
J = np.array([[1, -1, -LXY],
[1, 1, LXY],
[1, 1, -LXY],
[1, -1, LXY]]) / R
def twist_to_wheels(msg):
# TODO 1: msg["linear"]["x"], msg["linear"]["y"], msg["angular"]["z"] 로 벡터 v 를 만들고 w = J @ v
w = np.zeros(4)
scale = 1.0
# TODO 2: 둘레 속도 |w| * R 의 최댓값이 RIM_MAX 를 넘으면 scale = RIM_MAX / 최댓값
return w * scale, scale
def twist(x=0.0, y=0.0, th=0.0):
return {"linear": {"x": x, "y": y, "z": 0.0}, "angular": {"x": 0.0, "y": 0.0, "z": th}}
cases = [("i", twist(0.5)), ("Shift+J", twist(0, 0.5)), ("Shift+U", twist(0.5, 0.5)),
("j", twist(0, 0, 1.0)), ("u", twist(0.5, 0, 1.0)), ("빠른 대각+회전", twist(1.2, 1.0, 3.0))]
print("명령 FL FR RL RR (rad/s)")
for name, m in cases:
w, s = twist_to_wheels(m)
print("%-12s %6.1f %6.1f %6.1f %6.1f %s" % (name, *w, "" if s == 1 else "-> %.0f %% 로 줄임" % (s * 100)))
answer_key = {"/cmd_vel": "geometry_msgs/msg/Twist", "/odom": "nav_msgs/msg/Odometry",
"/scan": "sensor_msgs/msg/LaserScan", "/imu": "sensor_msgs/msg/Imu", "/tf": "tf2_msgs/msg/TFMessage"}
# TODO 3: 표를 보지 말고 먼저 적어 보세요
mine = {"/cmd_vel": "?", "/odom": "?", "/scan": "?", "/imu": "?", "/tf": "?"}
for k, v in answer_key.items():
print("%-9s %-28s %s" % (k, mine[k], "O" if mine[k] == v else "X (정답: %s)" % v))풀이 코드 보기
import numpy as np
R = 0.05 # 바퀴 반지름 (m) - ch03 과 같은 교육용 치수
LXY = 0.22 # lx + ly (m)
RIM_MAX = 1.6 # 바퀴 둘레 속도 한계 (m/s)
# [w_fl, w_fr, w_rl, w_rr] = J @ [vx, vy, wz]
J = np.array([[1, -1, -LXY],
[1, 1, LXY],
[1, 1, -LXY],
[1, -1, LXY]]) / R
def twist_to_wheels(msg):
v = np.array([msg["linear"]["x"], msg["linear"]["y"], msg["angular"]["z"]])
w = J @ v
scale = 1.0
rim = np.abs(w) * R
if rim.max() > RIM_MAX: # 한 바퀴라도 넘으면 네 바퀴를 같은 비율로
scale = RIM_MAX / rim.max()
return w * scale, scale
def twist(x=0.0, y=0.0, th=0.0):
return {"linear": {"x": x, "y": y, "z": 0.0}, "angular": {"x": 0.0, "y": 0.0, "z": th}}
cases = [("i", twist(0.5)), ("Shift+J", twist(0, 0.5)), ("Shift+U", twist(0.5, 0.5)),
("j", twist(0, 0, 1.0)), ("u", twist(0.5, 0, 1.0)), ("빠른 대각+회전", twist(1.2, 1.0, 3.0))]
print("명령 FL FR RL RR (rad/s)")
for name, m in cases:
w, s = twist_to_wheels(m)
print("%-12s %6.1f %6.1f %6.1f %6.1f %s" % (name, *w, "" if s == 1 else "-> %.0f %% 로 줄임" % (s * 100)))
answer_key = {"/cmd_vel": "geometry_msgs/msg/Twist", "/odom": "nav_msgs/msg/Odometry",
"/scan": "sensor_msgs/msg/LaserScan", "/imu": "sensor_msgs/msg/Imu", "/tf": "tf2_msgs/msg/TFMessage"}
mine = {"/cmd_vel": "geometry_msgs/msg/Twist", "/odom": "nav_msgs/msg/Odometry",
"/scan": "sensor_msgs/msg/LaserScan", "/imu": "sensor_msgs/msg/Imu", "/tf": "tf2_msgs/msg/TFMessage"}
for k, v in answer_key.items():
print("%-9s %-28s %s" % (k, mine[k], "O" if mine[k] == v else "X (정답: %s)" % v))실행 결과:
명령 FL FR RL RR (rad/s)
i 10.0 10.0 10.0 10.0
Shift+J -10.0 10.0 10.0 -10.0
Shift+U 0.0 20.0 20.0 0.0
j -4.4 4.4 -4.4 4.4
u 5.6 14.4 5.6 14.4
빠른 대각+회전 -5.1 32.0 17.2 9.6 -> 56 % 로 줄임
/cmd_vel geometry_msgs/msg/Twist O
/odom nav_msgs/msg/Odometry O
/scan sensor_msgs/msg/LaserScan O
/imu sensor_msgs/msg/Imu O
/tf tf2_msgs/msg/TFMessage O- Shift+U 에서 FL · RR 이 0 입니다. 시뮬레이터 2 의 막대와 같습니다.
- 메시지 타입의 가운데
msg는 ROS 2 의 정식 표기입니다(geometry_msgs/msg/Twist). 명령에 따라geometry_msgs/Twist로 줄여 써도 받아 줍니다.
드라이버 타임아웃이 "없음" 인 상태에서 0.3 m/s 로 가던 중 teleop 노드를 Ctrl+C 로 껐습니다. 로봇은?
- 토픽에 마지막 값이 지워지므로 즉시 멈춘다
- ROS 2 가 퍼블리셔가 사라진 것을 알고 자동으로 0 을 보낸다
- 드라이버가 마지막으로 받은 0.3 m/s 를 계속 써서 계속 간다
- 큐에 남은 메시지가 없으므로 뒤로 간다
정답 보기
③ — 토픽은 값을 저장하는 변수가 아니라 메시지가 지나가는 통로입니다. 새 메시지가 오지 않으면 드라이버는 마지막 명령을 그대로 씁니다(타임아웃이 없다면). 그래서 직접 만든 노드는 끝날 때 0 을 보내고, 드라이버에는 타임아웃을 두는 것이 안전합니다. 실제 myAGV Plus 드라이버의 동작은 바퀴를 띄운 상태에서 확인합니다.속도 명령 토픽을 30 Hz 로 보내는데, 받는 노드의 콜백이 가끔 50 ms 씩 걸립니다. 정지 명령이 가장 빨리 반영되게 하려면?
- 큐 크기(depth)를 50 으로 크게 한다 — 버리는 메시지가 줄어 안전하다
- 큐 크기를 1 처럼 작게 한다 — 오래된 명령을 버리고 최신 명령을 처리한다
- RELIABLE 을 BEST_EFFORT 로 바꾸면 처리 시간이 0 이 된다
- 퍼블리시 주기를 100 Hz 로 올린다
정답 보기
② — 처리 능력(20 Hz)보다 빨리 오면 어차피 일부는 버려집니다. 큐가 크면 오래된 명령을 줄 서서 처리하느라 정지가 늦어집니다(depth 50 → 1705 ms, depth 1 → 55 ms). 주기를 올리면(④) 더 밀립니다.LiDAR 드라이버가 발행하는 토픽과 그 타입으로 옳은 짝은?
/scan—geometry_msgs/msg/Twist/scan—sensor_msgs/msg/LaserScan/odom—sensor_msgs/msg/LaserScan/cmd_vel—nav_msgs/msg/Odometry
정답 보기
② — LaserScan 은 각도 범위(angle_min · angle_max · angle_increment)와 거리 배열(ranges)을 담습니다(ch07). Twist 는 속도 명령, Odometry 는 위치 · 속도 추정입니다.2교시 · 워크스페이스 빌드와 bringup#
myagv_plus_ros2 저장소 둘러보기#
myAGV Plus 의 ROS 2 코드는 전용 저장소 myagv_plus_ros2 의 기본 브랜치 **humble** 에 있습니다(BSD-3-Clause). 출고 이미지에는 ~/myagv_plus_ros2 에 이미 빌드되어 들어 있으므로, 새로 빌드하는 것은 소스를 고쳤거나 git pull 로 갱신했거나 SD/SSD 를 새로 만들었을 때입니다.
| 폴더(패키지) | 하는 일 (이름과 공식 문서로 본 역할) | 이 강좌 |
|---|---|---|
myagv_plus_bringup | 로봇 기본 기동: LiDAR 와 하위 보드 통신을 한 번에 띄움 | ch09 |
myagv_plus_navigation2 | Nav2 지도 기반 내비게이션 실행 | ch10 |
myagv_plus_applications/myagv_plus_joystick_control | 블루투스 조이스틱으로 조종 | ch09 |
myagv_plus_description | 로봇 모델(URDF) | ch02 |
myagv_plus_esp32_driver · myagv_plus_hardware_interfaces · myagv_plus_controller | 하위 보드(ESP32) 통신 · 하드웨어 · 제어 | (참고) |
myagv_plus_sensors · myagv_plus_calibration · myagv_plus_msgs | 센서 · 보정 · 전용 메시지 | (참고) |
myagv_plus_autocharge | 자동 충전 | ch11 |
표의 역할 설명 중 bringup · navigation2 · joystick 은 공식 문서(6.2.1 · 6.2.3 · 6.2.5)에 근거하고, 나머지는 폴더 이름으로 짐작한 것입니다. 정확한 내용은 각 패키지의 package.xml · launch 파일을 열어 확인합니다.
구형 myagv_ros2 와의 차이: 참고용으로 읽는 법#
ch02 · ch06 · ch08 에서 인용한 myagv_ros2 는 이전 모델 myAGV(Jetson Nano)용 저장소입니다. 공개 설정 파일이 많아 원리를 배우기 좋지만, 그대로 myAGV Plus 에 쓰면 안 됩니다.
| 항목 | myagv_ros2 (이전 모델) | myagv_plus_ros2 (myAGV Plus) |
|---|---|---|
| 브랜치 | galactic-JN (기본) · galactic-JN-devel | humble (기본) · humble-dev |
| 컴퓨터 · OS | Jetson Nano · JetPack 4.6 | Jetson Orin Nano Super · Ubuntu 22.04 |
| ROS 2 배포판 | Galactic (지원 종료) | Humble (LTS) |
| 기동 | ros2 launch myagv_odometry myagv_active.launch.py (오도메트리 + EKF + ydlidar 드라이버, ch06) | ros2 launch myagv_plus_bringup myagv_plus_bringup.launch.py |
| 패키지 이름 | myagv_*, ydlidar_ros2_driver, robot_localization 등을 저장소에 함께 넣음 | myagv_plus_* |
| 키보드 조종 | 저장소 안에 teleop_twist_keyboard 폴더 포함 | 문서는 ros2 run teleop_twist_keyboard teleop_twist_keyboard 로 실행 |
- 원리는 가져오고 숫자는 의심합니다. EKF 를 쓰는 구조(ch06), 코스트맵 파라미터의 뜻(ch08)은 같지만 로봇 크기 · 속도 한계 · 센서 위치는 다를 수 있습니다.
- 이름은 로봇에서 확인합니다. 패키지 · 노드 · 토픽 이름이
myagv_→myagv_plus_처럼 바뀌었을 수 있습니다.ros2 pkg list | grep myagv로 확인합니다. - 배포판을 섞지 않습니다. Galactic 용 패키지를 Humble 워크스페이스에 넣으면 API 차이로 빌드가 깨질 수 있습니다.
빌드 순서: clone → rosdep → colcon build → source#
공식 문서(6.2.1)의 처음 설치 순서입니다. 홈 폴더(~)에서 시작합니다.
# ① 소스 받기: 저장소를 myagv_plus_ros2/src 폴더로 받습니다 (기본 브랜치 humble)
cd ~
git clone https://github.com/elephantrobotics/myagv_plus_ros2.git myagv_plus_ros2/src
# ② 의존 패키지 설치: package.xml 에 적힌 것 중 없는 것을 apt 로 설치
cd ~/myagv_plus_ros2
rosdep install --from-paths src --ignore-src -r -y
# ③ 빌드: Jetson Orin Nano Super 에서 처음에는 약 30 분
cd ~/myagv_plus_ros2
colcon build
# ④ 이 터미널에 워크스페이스 등록
source ~/myagv_plus_ros2/install/local_setup.bash이미 있는 워크스페이스를 최신으로 바꿀 때:
cd ~/myagv_plus_ros2/src
git pull
cd ..
colcon buildrtabmap · nav2 처럼 큰 패키지가 컴파일 중 실패하면, 공식 문서는 동시에 하는 일을 줄이라고 안내합니다.
cd ~/myagv_plus_ros2
export MAKEFLAGS="-j5"
colcon build --parallel-workers 1 --cmake-args -DCMAKE_BUILD_TYPE=Release| 옵션 | 뜻 |
|---|---|
--parallel-workers 1 | colcon 이 패키지를 한 번에 1개씩만 빌드 |
MAKEFLAGS="-j5" | 패키지 하나 안에서 파일을 최대 5개 동시에 컴파일 |
-DCMAKE_BUILD_TYPE=Release | 최적화 빌드 (실행이 빠르고 디버그 정보가 적음) |
--packages-select 이름 | 그 패키지만 빌드 (내 패키지만 고쳤을 때 4교시) |
source 는 왜 필요할까#
ROS 2 는 underlay(/opt/ros/humble, ROS 2 본체) 위에 overlay(여러분의 워크스페이스)를 겹쳐 씁니다. source .../install/local_setup.bash 는 그 터미널의 환경 변수(AMENT_PREFIX_PATH 등)에 "패키지를 여기서도 찾아라" 를 추가합니다.
- source 는 그 터미널에만 적용됩니다. 새 터미널을 열면 처음부터 다시 해야 합니다.
- 그래서 공식 문서는 홈 폴더의 숨김 파일
.bashrc끝에 source 줄을 넣으라고 안내합니다(파일 관리자에서 Ctrl+H 로 숨김 파일 표시). 터미널이 열릴 때마다 자동으로 실행됩니다. local_setup.bash는 이 워크스페이스만 등록하고,setup.bash는 이 워크스페이스를 빌드할 때 쓴 underlay 까지 함께 등록합니다. underlay(/opt/ros/humble/setup.bash)가.bashrc에 이미 있다면 공식 문서대로local_setup.bash로 충분합니다.
echo "source ~/myagv_plus_ros2/install/local_setup.bash" >> ~/.bashrc
source ~/.bashrc # 지금 터미널에도 바로 적용시뮬레이터 3 · 빌드 · 실행 터미널#
명령 버튼을 원하는 순서로 눌러 보세요. 순서가 틀리면 실제와 비슷한 오류가 납니다. 오른쪽 아래 빌드 설정은 colcon build 를 누를 때 적용됩니다. 출력은 교육용으로 줄였고, 노드 · 토픽 이름 중 <…> 는 로봇에서 확인할 부분입니다.
- clone → rosdep → colcon build → launch 순서로 누릅니다(source 를 일부러 뺌). 어떤 오류가 날지 먼저 적어 보세요. 그 뒤 source 를 누르고 다시 launch 합니다.
- bringup 이 실행 중인 터미널에서
ros2 node list를 누르면? 새 터미널을 열고 다시 눌러 봅니다. 새 터미널은 워크스페이스를 source 하지 않았는데 노드 목록이 나오는 이유는 무엇일까요? - ↺ 처음부터 → 브라우저 · RViz 를 켜 둔 채 빌드 를 체크하고 기본값으로
colcon build를 해 봅니다. 결과를 예측한 뒤, 공식 권장 (workers 1, -j5) 으로 바꿔 다시 빌드합니다. 시간은 어떻게 달라지나요? - 스왑을 4 GB 로 켜고 3번의 기본값 빌드를 다시 해 봅니다. 성공했지만 무엇이 나빠졌나요?
.bashrc등록 → 새 터미널 → launch 순서도 해 봅니다. 어느 방법이 실수가 적을까요?
- source 없이 launch 하면
Package 'myagv_plus_bringup' not found ... searching: ['/opt/ros/humble']가 납니다. "찾아본 곳" 목록에 내 워크스페이스가 없다는 것이 원인을 알려 줍니다. ros2 node list·topic list는 DDS 로 실행 중인 노드를 찾아 보여 주므로, 워크스페이스를 source 하지 않은 새 터미널에서도 됩니다(같은 ROS_DOMAIN_ID 라면). 반대로ros2 launch·ros2 run은 패키지 파일을 찾아야 하므로 source 가 필요합니다.- 기본값(workers 6, -j6)은 큰 C++ 패키지 3개 × 6파일 = 18개를 동시에 컴파일해 최대 7.9 GB 로 아슬아슬합니다. 브라우저 · RViz 를 켜 두면 9.1 GB 가 되어 Killed 로 실패합니다. 공식 권장값(workers 1, -j5)은 3.4 GB 로 안전하지만 42 분 걸립니다(교육용 모델).
- 스왑을 켜면 성공하지만 디스크를 메모리처럼 쓰느라 42 분으로 느려집니다. 빌드할 때는 다른 프로그램을 끄는 것이 가장 쉬운 해결입니다.
bringup 후 확인하기#
bringup 은 LiDAR 와 하위 보드 통신을 띄우는 기본 기동입니다. 키보드 · 조이스틱 · SLAM · Nav2 는 모두 bringup 이 켜져 있다는 전제에서 다른 터미널로 실행합니다.
# 터미널 1: 기본 기동 (이 터미널은 계속 차지됨)
ros2 launch myagv_plus_bringup myagv_plus_bringup.launch.py
# 터미널 2: 확인
ros2 node list # 어떤 노드가 떴나
ros2 topic list -t # 토픽 이름과 타입
ros2 topic hz /scan # LiDAR 가 일정한 주기로 나오나 (Ctrl+C 로 멈춤)
ros2 topic echo /odom --once # 오도메트리 한 개 보기 (토픽 이름은 list 결과에 맞춤)
ros2 topic info /cmd_vel -v # 누가 퍼블리시 · 서브스크라이브하나, QoS 는 무엇인가
rqt_graph # 노드 그래프 창 (화면이 있을 때)| 확인 | 정상 | 이상하면 |
|---|---|---|
ros2 node list | bringup 의 노드들이 보임 | launch 터미널의 빨간 [ERROR] 줄을 먼저 읽음 |
ros2 topic hz /scan | 일정한 주기 (std dev 작음) | LiDAR 케이블 · 전원, 드라이버 오류 |
ros2 topic info /cmd_vel -v | Subscription count ≥ 1 (베이스 드라이버) | 드라이버가 안 떴거나 토픽 이름이 다름 |
rqt_graph | teleop → /cmd_vel → 드라이버 연결선 | 연결선 없음 = 이름 · 도메인 · QoS 불일치 |
실습 과제 2#
카드 7장(clone, rosdep, build, source, newterm, launch, topic)을 순서대로 "실행" 하는 작은 흉내 프로그램입니다. 시뮬레이터 3 과 같은 규칙입니다. TODO 를 채워 source 와 newterm 의 효과를 넣고, 여러 순서를 시험하세요. 예측 먼저: "빌드 후 새 터미널" 순서는 몇 번째 카드에서 어떤 오류로 멈출까요?
def run(order):
st = {"cloned": False, "deps": False, "built": False, "sourced": False, "launched": False}
for i, c in enumerate(order, 1):
if c == "clone":
st["cloned"] = True
elif c == "rosdep":
if not st["cloned"]:
return i, c, "src 폴더가 없음 - 먼저 clone"
st["deps"] = True
elif c == "build":
if not st["cloned"]:
return i, c, "빌드할 패키지가 없음 (src 가 비어 있음)"
if not st["deps"]:
return i, c, "CMake Error: Could not find a package configuration file ... (의존성 없음)"
st["built"] = True
elif c == "source":
# TODO 1: 빌드가 안 됐으면 "No such file or directory" 오류, 됐으면 sourced = True
pass
elif c == "newterm":
# TODO 2: 새 터미널은 source 를 물려받지 않습니다 (.bashrc 에 넣지 않았다면)
pass
elif c == "launch":
if not st["sourced"]:
return i, c, "Package 'myagv_plus_bringup' not found"
st["launched"] = True
elif c == "topic":
if not st["launched"]:
return i, c, "WARNING: topic [/scan] does not appear to be published yet"
return None
tests = {
"정답 순서": ["clone", "rosdep", "build", "source", "launch", "newterm", "topic"],
"source 빠뜨림": ["clone", "rosdep", "build", "launch", "topic"],
"rosdep 빠뜨림": ["clone", "build", "source", "launch"],
"빌드 후 새 터미널": ["clone", "rosdep", "build", "source", "newterm", "launch"],
"launch 없이 확인": ["clone", "rosdep", "build", "source", "topic"],
}
for name, order in tests.items():
r = run(order)
print("%-12s ->" % name, "성공" if r is None else "%d번째 '%s' 에서 실패: %s" % r)풀이 코드 보기
def run(order):
st = {"cloned": False, "deps": False, "built": False, "sourced": False, "launched": False}
for i, c in enumerate(order, 1):
if c == "clone":
st["cloned"] = True
elif c == "rosdep":
if not st["cloned"]:
return i, c, "src 폴더가 없음 - 먼저 clone"
st["deps"] = True
elif c == "build":
if not st["cloned"]:
return i, c, "빌드할 패키지가 없음 (src 가 비어 있음)"
if not st["deps"]:
return i, c, "CMake Error: Could not find a package configuration file ... (의존성 없음)"
st["built"] = True
elif c == "source":
if not st["built"]:
return i, c, "bash: .../install/local_setup.bash: No such file or directory"
st["sourced"] = True
elif c == "newterm":
st["sourced"] = False # 새 터미널은 환경 변수를 물려받지 않음
elif c == "launch":
if not st["sourced"]:
return i, c, "Package 'myagv_plus_bringup' not found"
st["launched"] = True
elif c == "topic":
if not st["launched"]:
return i, c, "WARNING: topic [/scan] does not appear to be published yet"
return None
tests = {
"정답 순서": ["clone", "rosdep", "build", "source", "launch", "newterm", "topic"],
"source 빠뜨림": ["clone", "rosdep", "build", "launch", "topic"],
"rosdep 빠뜨림": ["clone", "build", "source", "launch"],
"빌드 후 새 터미널": ["clone", "rosdep", "build", "source", "newterm", "launch"],
"launch 없이 확인": ["clone", "rosdep", "build", "source", "topic"],
}
for name, order in tests.items():
r = run(order)
print("%-12s ->" % name, "성공" if r is None else "%d번째 '%s' 에서 실패: %s" % r)실행 결과:
정답 순서 -> 성공
source 빠뜨림 -> 4번째 'launch' 에서 실패: Package 'myagv_plus_bringup' not found
rosdep 빠뜨림 -> 2번째 'build' 에서 실패: CMake Error: Could not find a package configuration file ... (의존성 없음)
빌드 후 새 터미널 -> 6번째 'launch' 에서 실패: Package 'myagv_plus_bringup' not found
launch 없이 확인 -> 5번째 'topic' 에서 실패: WARNING: topic [/scan] does not appear to be published yet- "정답 순서" 에서
newterm뒤의topic은 성공합니다.ros2 topic hz는 실행 중인 노드를 DDS 로 찾으므로 source 가 필요 없습니다. 이 흉내 프로그램도topic에서sourced를 검사하지 않습니다. - "빌드 후 새 터미널" 은 source 를 했는데도 실패합니다. 가장 자주 하는 실수이며,
.bashrc에 source 줄을 넣으면 사라집니다.
시뮬레이터 3 의 빌드 모델(교육용 가정)을 함수로 만들었습니다. TODO 를 채워 여러 설정의 최대 메모리와 시간을 표로 만들고, 브라우저를 켠 채 스왑 없이 가장 빠른 조합을 찾으세요. 예측 먼저: workers 1 · -j5(공식 권장)와 workers 2 · -j3 중 어느 쪽이 더 빠를까요?
RAM = 8.0 # Jetson Orin Nano Super 8GB (GPU 와 같이 씀)
BASE = 1.6 # OS + 데스크톱 (GB, 가정)
GUI = 1.2 # 브라우저 · RViz 를 켜 두면 더 쓰는 메모리 (GB, 가정)
JOB = 0.35 # C++ 컴파일 작업 1개의 최대 메모리 (GB, 가정)
HEAVY = 3 # 동시에 컴파일될 수 있는 무거운 C++ 패키지 수 (가정)
CORES = 6
WORK = 120 # 전체 컴파일 일의 양 (코어 x 분, 가정)
def plan(workers, j, gui=False, swap=0.0):
jobs = min(workers, HEAVY) * j # 동시에 도는 컴파일 작업 수
# TODO 1: peak = BASE + (gui 면 GUI) + jobs * JOB
peak = 0.0
# TODO 2: minutes = WORK / min(CORES, jobs) + (workers 가 1 이면 18, 아니면 10)
minutes = 0.0
if peak > RAM + swap:
return jobs, peak, None # 메모리 부족 -> Killed
if peak > RAM:
minutes *= 1 + 3 * (peak - RAM) / RAM # 스왑을 쓰면 느려짐
return jobs, peak, minutes
print("workers -j 동시작업 최대메모리 시간")
for w, j in [(6, 6), (1, 5), (1, 1), (2, 3), (3, 2), (6, 8)]:
jobs, peak, m = plan(w, j)
print("%5d %5d %7d %9.1f GB %s" % (w, j, jobs, peak, "실패 (Killed)" if m is None else "%.0f 분" % m))
# TODO 3: gui=True, swap=0 에서 workers 1~6, j 1~8 을 모두 시험해 가장 빠른 조합을 출력풀이 코드 보기
RAM = 8.0 # Jetson Orin Nano Super 8GB (GPU 와 같이 씀)
BASE = 1.6 # OS + 데스크톱 (GB, 가정)
GUI = 1.2 # 브라우저 · RViz 를 켜 두면 더 쓰는 메모리 (GB, 가정)
JOB = 0.35 # C++ 컴파일 작업 1개의 최대 메모리 (GB, 가정)
HEAVY = 3 # 동시에 컴파일될 수 있는 무거운 C++ 패키지 수 (가정)
CORES = 6
WORK = 120 # 전체 컴파일 일의 양 (코어 x 분, 가정)
def plan(workers, j, gui=False, swap=0.0):
jobs = min(workers, HEAVY) * j
peak = BASE + (GUI if gui else 0) + jobs * JOB
minutes = WORK / min(CORES, jobs) + (18 if workers == 1 else 10)
if peak > RAM + swap:
return jobs, peak, None
if peak > RAM:
minutes *= 1 + 3 * (peak - RAM) / RAM
return jobs, peak, minutes
print("workers -j 동시작업 최대메모리 시간")
for w, j in [(6, 6), (1, 5), (1, 1), (2, 3), (3, 2), (6, 8)]:
jobs, peak, m = plan(w, j)
print("%5d %5d %7d %9.1f GB %s" % (w, j, jobs, peak, "실패 (Killed)" if m is None else "%.0f 분" % m))
print("\n브라우저 · RViz 를 켜 둔 채 기본값으로 빌드:")
for swap in (0, 4):
jobs, peak, m = plan(6, 6, gui=True, swap=swap)
print(" 스왑 %d GB: 최대 %.1f GB -> %s" % (swap, peak, "실패 (Killed)" if m is None else "%.0f 분" % m))
best = None
for w in range(1, 7):
for j in range(1, 9):
jobs, peak, m = plan(w, j, gui=True)
if m is not None and (best is None or m < best[0] - 1e-9):
best = (m, w, j, peak)
print("\n브라우저를 켠 채 스왑 없이 가장 빠른 조합: workers %d, -j%d (%.1f GB, %.0f 분)" % (best[1], best[2], best[3], best[0]))실행 결과:
workers -j 동시작업 최대메모리 시간
6 6 18 7.9 GB 30 분
1 5 5 3.4 GB 42 분
1 1 1 2.0 GB 138 분
2 3 6 3.7 GB 30 분
3 2 6 3.7 GB 30 분
6 8 24 10.0 GB 실패 (Killed)
브라우저 · RViz 를 켜 둔 채 기본값으로 빌드:
스왑 0 GB: 최대 9.1 GB -> 실패 (Killed)
스왑 4 GB: 최대 9.1 GB -> 42 분
브라우저를 켠 채 스왑 없이 가장 빠른 조합: workers 2, -j3 (4.9 GB, 30 분)- 동시 작업 수가 코어 수(6) 이상이면 더 늘려도 빨라지지 않고 메모리만 늘어납니다. 이 모델에서는 동시 작업 6개 근처가 가장 좋습니다.
- 공식 권장값(workers 1, -j5)은 "가장 빠른" 값이 아니라 어떤 상황에서도 실패하지 않는 값입니다. 처음 빌드가 실패했을 때 고민 없이 쓰기 좋습니다.
- 이 숫자들은 교육용 모델입니다. 실제로는
free -h나htop으로 빌드 중 메모리를 보며 조절합니다.
새 터미널을 열고 ros2 launch myagv_plus_bringup myagv_plus_bringup.launch.py 를 실행했더니 다음이 나왔습니다. Package 'myagv_plus_bringup' not found: "package 'myagv_plus_bringup' not found, searching: ['/opt/ros/humble']" 가장 알맞은 원인과 해결은?
- LiDAR 가 연결되지 않았다 → USB 케이블을 다시 꽂는다
- 이 터미널에서 워크스페이스를 source 하지 않았다 →
source ~/myagv_plus_ros2/install/local_setup.bash(또는.bashrc에 등록) - ROS_DOMAIN_ID 가 다르다 → 0 으로 맞춘다
- 메모리가 부족하다 →
MAKEFLAGS="-j5"로 다시 빌드한다
정답 보기
② — "searching" 목록에 `/opt/ros/humble` 만 있고 내 워크스페이스가 없습니다. 하드웨어(①) 문제라면 패키지는 찾고 노드 실행 중에 오류가 납니다. 도메인 ID(③)는 패키지 찾기와 관계없습니다.colcon build 중 c++: fatal error: Killed signal terminated program cc1plus 가 나며 실패했습니다. 시뮬레이터 3 에서 본 원리로 가장 알맞은 조치는?
rosdep install을 다시 실행한다git pull로 소스를 최신으로 받는다- 브라우저 등 다른 프로그램을 끄고,
export MAKEFLAGS="-j5"와--parallel-workers 1로 동시 컴파일 수를 줄여 다시 빌드한다 source install/local_setup.bash를 먼저 한다
정답 보기
③ — Killed 는 메모리가 모자라 커널이 컴파일러를 강제로 끈 것입니다. 동시에 컴파일하는 파일 수를 줄이면 최대 메모리가 줄어듭니다(시뮬레이터 3: 9.1 GB → 3.4 GB). 의존성(①) 문제라면 CMake 단계에서 "Could not find a package" 가 납니다.3교시 · 키보드 · 조이스틱으로 조종하기#
teleop_twist_keyboard 의 키 배치#
bringup 을 켠 상태에서 새 터미널을 열고 실행합니다(공식 문서 6.2.3).
ros2 run teleop_twist_keyboard teleop_twist_keyboard공식 문서의 키 표를 teleop_twist_keyboard 원본 코드의 실제 값(speed = 0.5, turn = 1.0 일 때)과 나란히 놓았습니다.
| 키 | 공식 문서 설명 | 보내는 Twist (linear.x, linear.y, angular.z) |
|---|---|---|
i / , | 전진 / 후진 | (+0.5, 0, 0) / (−0.5, 0, 0) |
j / l | Move Left / Move Right | (0, 0, +1.0) / (0, 0, −1.0) — 제자리 회전 |
u / o | 왼쪽 앞 / 오른쪽 앞 | (+0.5, 0, +1.0) / (+0.5, 0, −1.0) — 전진하며 회전 |
m / . | 왼쪽 뒤 / 오른쪽 뒤 | (−0.5, 0, −1.0) / (−0.5, 0, +1.0) — 후진하며 회전 |
k | 정지 | (0, 0, 0) — 표에 없는 아무 키나 정지 |
Shift+J / Shift+L | 왼쪽 / 오른쪽으로 이동 | (0, +0.5, 0) / (0, −0.5, 0) — 옆걸음 |
Shift+U / Shift+O | 왼쪽 앞 / 오른쪽 앞 | (+0.5, +0.5, 0) / (+0.5, −0.5, 0) |
Shift+M / Shift+. | 왼쪽 뒤 / 오른쪽 뒤 | (−0.5, +0.5, 0) / (−0.5, −0.5, 0) |
q / z | 직선 · 회전 속도 모두 ×1.1 / ×0.9 | 다음 메시지부터 적용 |
w / x | 직선 속도만 ×1.1 / ×0.9 | |
e / c | 회전 속도만 ×1.1 / ×0.9 |
공식 표는 j 를 "Move Left" 로 적었지만, teleop_twist_keyboard 원본 코드에서 j 는 angular.z = +1 (제자리에서 왼쪽으로 돌기)이고, 옆으로 평행 이동은 Shift+J (linear.y = +1)입니다. 문서 표현과 코드가 다르게 읽힐 때는 메시지를 직접 봅니다. 다른 터미널에서 ros2 topic echo /cmd_vel 을 켜 두고 j 와 Shift+J 를 눌러 어떤 필드가 바뀌는지 확인하세요.
speed 0.5는 myAGV Plus 에게 결코 느린 속도가 아닙니다(사람이 걷는 속도의 절반 정도). 처음에는 z 를 여러 번 눌러 속도를 낮춘 뒤 움직입니다. z 를 7번 누르면 0.5 × 0.9⁷ ≈ 0.24 m/s 입니다.- ROS 2 판 teleop_twist_keyboard 는 키를 누를 때마다 메시지를 한 번 보냅니다. 키를 누르고 있으면 운영체제의 키 반복으로 여러 번 보내집니다. 키를 떼도 "정지" 메시지는 자동으로 가지 않으므로, 멈추려면 k 를 누릅니다.
teleop 터미널에 포커스가 있어야 키가 먹는 이유#
teleop 은 자기 터미널의 키 입력(표준 입력) 을 읽는 프로그램입니다. 다른 창(브라우저, RViz, 다른 터미널)을 클릭하면 키 입력이 그쪽으로 가서 teleop 은 아무것도 받지 못합니다. 로봇이 계속 가는데 k 가 "안 먹는" 가장 흔한 이유입니다.
- 로봇을 움직이는 동안에는 teleop 터미널을 맨 앞에 두고, 다른 창을 보려면 먼저 k 로 멈춥니다.
- 비상시를 위해 teleop 말고도 멈출 방법(조이스틱, 로봇의 전원 · 비상정지)을 정해 둡니다.
조이스틱으로 조종하기#
공식 문서(6.2.3 Handle control)의 순서입니다.
- bringup 을 실행합니다.
- 블루투스 조이스틱의 USB 수신기를 로봇에 꽂고, 새 터미널에서 실행합니다.
ros2 run myagv_plus_joystick_control joystick_controller- 조이스틱에 초록 · 빨간 불이 함께 켜지면 준비된 것입니다.
- 빨간 불만 켜져 있으면 MODE 버튼을 3초 길게 눌러 모드를 바꿉니다.
- 스틱 · 버튼과 속도의 대응, 최고 속도는 공식 문서에 표로 나와 있지 않습니다(확인 필요). 처음에는 바퀴를 띄우거나 넓은 공간에서 스틱을 살짝만 밀어 보며 대응을 표로 적습니다.
- 조이스틱 노드와 teleop 을 동시에 켜면
/cmd_vel에 퍼블리셔가 둘이 됩니다. 드라이버는 마지막으로 온 메시지를 쓰므로, 한쪽이 0 을 계속 보내면 다른 쪽 명령이 끊깁니다(시뮬레이터 4 · 실습 3-2). 한 번에 하나만 켭니다.
시뮬레이터 4 · 피킹 스테이션 키보드 주행#
7 m × 4.2 m 창고에서 A → B → C → 도크 순서로 피킹 스테이션에 정차합니다. 스테이션 사각형 안(중심 0.15 m 이내)에서 멈추고, 몸 방향이 오른쪽(+x, ±15°) 을 보고 있어야 도착으로 인정합니다. 지도를 한 번 클릭해 포커스를 준 뒤 키보드로 조종하세요. 화면의 버튼으로도 됩니다(버튼을 누르면 포커스가 버튼으로 옮겨 가는 것도 관찰해 보세요).
- j 를 한 번 누를 때와 Shift+J 를 한 번 누를 때 로봇이 어떻게 움직일지 예측하고 확인합니다(k 로 멈춤). 아래 "드라이버가 쓰는 명령" 의 어느 칸이 바뀌나요?
- A 스테이션까지 회전 없이(Shift 키만) 가 보고, 다음에는 회전 키(j · l · u · o)만 으로 가 봅니다. 도착 조건(방향 ±15°) 때문에 어느 쪽이 쉬운가요? 시간과 충돌 횟수를 비교합니다.
- 로봇이 가는 중에 화면의 ↺ 처음부터 가 아닌 아무 버튼(예: q)을 마우스로 누른 뒤 키보드 k 를 눌러 봅니다. 왜 멈추지 않을까요? 맨 위 포커스 표시를 보세요.
- 베이스 드라이버를 0.5 s 동안 명령 없으면 정지 로 바꾸고 i 를 한 번만 눌러 봅니다. 키를 누르고 있으면 어떻게 되나요?
- 조이스틱 노드도 실행 을 켜고 i 를 한 번 누르거나 누르고 있어 봅니다. 아래 rqt_graph 그림과 메시지 기록을 보고 이유를 설명합니다.
- j 는
angular.z만, Shift+J 는linear.y만 바뀝니다. 메카넘 로봇은 Shift 키로 몸 방향을 유지한 채 옆 · 대각으로 움직일 수 있어 선반 앞에 나란히 정차하기 쉽습니다. 회전 키만 쓰면 스테이션에서 방향을 다시 맞춰야 합니다. - 버튼을 클릭하면 포커스가 버튼으로 옮겨 가 키보드 입력이 지도(teleop)로 오지 않습니다. 실제 teleop 터미널도 같습니다.
- "마지막 명령 유지" 드라이버에서는 i 한 번으로 계속 갑니다. 타임아웃 드라이버에서는 한 번 누르면 0.5 s 만 가고, 누르고 있으면 키 반복 메시지가 계속 와서 계속 갑니다. 손을 떼면 멈추므로 더 안전합니다.
- 조이스틱 노드가 0 을 10 Hz 로 보내면 teleop 의 명령이 최대 0.1 s 만에 덮어써져, 로봇이 거의 안 가거나 툭툭 끊깁니다.
/cmd_vel퍼블리셔가 둘이면 마지막에 온 것이 이깁니다. 실제 조이스틱 노드가 0 을 계속 보내는지는 확인 필요이며,ros2 topic info /cmd_vel -v의 Publisher count 로 확인할 수 있습니다.
rqt_graph 로 노드 연결 확인#
공식 문서(6.2.2)는 노드 · 토픽 그래프를 보는 도구로 rqt_graph, TF 트리를 보는 도구로 rqt_tf_tree 를 소개합니다.
rqt_graph # 노드 · 토픽 연결 그림 (화면이 있는 PC 또는 VNC)
ros2 run rqt_tf_tree rqt_tf_tree # TF 트리 (ch02 의 프레임 사슬)
ros2 topic info /cmd_vel -v # 화면이 없을 때: 퍼블리셔 · 서브스크라이버 목록과 QoS- teleop 을 켠 뒤 rqt_graph 에
/teleop_twist_keyboard → /cmd_vel → (베이스 드라이버)연결이 보여야 합니다. 화살표가 끊겨 있으면 토픽 이름(/cmd_velvscmd_vel_raw), 도메인 ID, QoS 를 의심합니다. - 4교시의 안전 정지 노드를 넣으면 그래프가
teleop → /cmd_vel_raw → safety_stop → /cmd_vel → 드라이버로 바뀝니다. 그림으로 확인하면 연결 실수가 바로 보입니다.
실습 과제 3#
teleop_twist_keyboard 의 키 표로 Teleop.press() 를 완성하고, 키 순서(키, 유지 시간)를 넣으면 로봇이 어디에 도착하는지 계산하세요. 드라이버는 마지막 명령을 유지한다고 가정합니다. 예측 먼저: "i 2 s → J 1 s" 와 "i 2 s → j 1.6 s → i 1 s" 는 거의 같은 곳에 도착합니다. 무엇이 다를까요? q 를 두 번 누른 뒤 i 의 속도는?
import math
MOVE = {
"i": (1, 0, 0, 0), "o": (1, 0, 0, -1), "j": (0, 0, 0, 1), "l": (0, 0, 0, -1),
"u": (1, 0, 0, 1), ",": (-1, 0, 0, 0), ".": (-1, 0, 0, 1), "m": (-1, 0, 0, -1),
"O": (1, -1, 0, 0), "I": (1, 0, 0, 0), "J": (0, 1, 0, 0), "L": (0, -1, 0, 0),
"U": (1, 1, 0, 0), "<": (-1, 0, 0, 0), ">": (-1, -1, 0, 0), "M": (-1, 1, 0, 0),
}
SPEED = {"q": (1.1, 1.1), "z": (0.9, 0.9), "w": (1.1, 1.0), "x": (0.9, 1.0), "e": (1.0, 1.1), "c": (1.0, 0.9)}
class Teleop:
def __init__(self, speed=0.5, turn=1.0):
self.speed, self.turn = speed, turn
self.x = self.y = self.th = 0
def press(self, key):
"""키 하나 -> 보낼 Twist (linear.x, linear.y, angular.z)"""
if key in MOVE:
self.x, self.y, _, self.th = MOVE[key]
# TODO 1: SPEED 키면 speed, turn 에 배수를 곱합니다
# TODO 2: 그 밖의 키는 모두 정지 (x = y = th = 0)
return (self.x * self.speed, self.y * self.speed, self.th * self.turn)
def drive(seq, dt=0.05):
t = Teleop()
px = py = yaw = 0.0
for key, sec in seq:
vx, vy, wz = t.press(key)
for _ in range(round(sec / dt)):
# TODO 3: 로봇 기준 속도 (vx, vy) 를 지도 기준으로 돌려 px, py 에 더하고 yaw 에 wz*dt 를 더합니다
pass
return px, py, math.degrees(yaw)
t = Teleop()
for k in ["i", "j", "J", "u", "U", ".", ">", "k", "q", "q", "i"]:
print("%s -> linear.x %+.3f linear.y %+.3f angular.z %+.3f" % ((k,) + t.press(k)))
print()
for name, seq in [("i 2 s -> J 1 s -> k", [("i", 2), ("J", 1), ("k", 0)]),
("i 2 s -> j 1.6 s -> i 1 s -> k", [("i", 2), ("j", 1.6), ("i", 1), ("k", 0)]),
("U 2 s -> k", [("U", 2), ("k", 0)])]:
x, y, yaw = drive(seq)
print("%-30s 위치 (%.2f, %.2f) m, 방향 %.0f 도" % (name, x, y, yaw))풀이 코드 보기
import math
MOVE = {
"i": (1, 0, 0, 0), "o": (1, 0, 0, -1), "j": (0, 0, 0, 1), "l": (0, 0, 0, -1),
"u": (1, 0, 0, 1), ",": (-1, 0, 0, 0), ".": (-1, 0, 0, 1), "m": (-1, 0, 0, -1),
"O": (1, -1, 0, 0), "I": (1, 0, 0, 0), "J": (0, 1, 0, 0), "L": (0, -1, 0, 0),
"U": (1, 1, 0, 0), "<": (-1, 0, 0, 0), ">": (-1, -1, 0, 0), "M": (-1, 1, 0, 0),
}
SPEED = {"q": (1.1, 1.1), "z": (0.9, 0.9), "w": (1.1, 1.0), "x": (0.9, 1.0), "e": (1.0, 1.1), "c": (1.0, 0.9)}
class Teleop:
def __init__(self, speed=0.5, turn=1.0):
self.speed, self.turn = speed, turn
self.x = self.y = self.th = 0
def press(self, key):
"""키 하나 -> 보낼 Twist (linear.x, linear.y, angular.z)"""
if key in MOVE:
self.x, self.y, _, self.th = MOVE[key]
elif key in SPEED:
self.speed *= SPEED[key][0]
self.turn *= SPEED[key][1]
else: # 그 밖의 키(k 등)는 모두 정지
self.x = self.y = self.th = 0
return (self.x * self.speed, self.y * self.speed, self.th * self.turn)
def drive(seq, dt=0.05):
t = Teleop()
px = py = yaw = 0.0
for key, sec in seq:
vx, vy, wz = t.press(key)
for _ in range(round(sec / dt)):
px += (vx * math.cos(yaw) - vy * math.sin(yaw)) * dt
py += (vx * math.sin(yaw) + vy * math.cos(yaw)) * dt
yaw += wz * dt
return px, py, math.degrees(yaw)
t = Teleop()
for k in ["i", "j", "J", "u", "U", ".", ">", "k", "q", "q", "i"]:
print("%s -> linear.x %+.3f linear.y %+.3f angular.z %+.3f" % ((k,) + t.press(k)))
print()
for name, seq in [("i 2 s -> J 1 s -> k", [("i", 2), ("J", 1), ("k", 0)]),
("i 2 s -> j 1.6 s -> i 1 s -> k", [("i", 2), ("j", 1.6), ("i", 1), ("k", 0)]),
("U 2 s -> k", [("U", 2), ("k", 0)])]:
x, y, yaw = drive(seq)
print("%-30s 위치 (%.2f, %.2f) m, 방향 %.0f 도" % (name, x, y, yaw))실행 결과:
i -> linear.x +0.500 linear.y +0.000 angular.z +0.000
j -> linear.x +0.000 linear.y +0.000 angular.z +1.000
J -> linear.x +0.000 linear.y +0.500 angular.z +0.000
u -> linear.x +0.500 linear.y +0.000 angular.z +1.000
U -> linear.x +0.500 linear.y +0.500 angular.z +0.000
. -> linear.x -0.500 linear.y +0.000 angular.z +1.000
> -> linear.x -0.500 linear.y -0.500 angular.z +0.000
k -> linear.x +0.000 linear.y +0.000 angular.z +0.000
q -> linear.x +0.000 linear.y +0.000 angular.z +0.000
q -> linear.x +0.000 linear.y +0.000 angular.z +0.000
i -> linear.x +0.605 linear.y +0.000 angular.z +0.000i 2 s -> J 1 s -> k 위치 (1.00, 0.50) m, 방향 0 도
i 2 s -> j 1.6 s -> i 1 s -> k 위치 (0.99, 0.50) m, 방향 92 도
U 2 s -> k 위치 (1.00, 1.00) m, 방향 0 도- 두 방법 모두 (1.0, 0.5) 근처에 도착하지만, 회전을 쓴 쪽은 몸이 92° 돌아가 있습니다. 피킹 스테이션처럼 방향까지 맞춰야 하는 곳에서는 Shift(평행 이동)가 유리합니다.
- q 를 누르면 그 순간 현재 방향(정지 상태) 으로 메시지가 한 번 가고, 속도 배수만 바뀝니다. q 두 번 뒤 i 는 0.5 × 1.1 × 1.1 = 0.605 m/s 입니다.
.는 (−0.5, 0, +1.0) 입니다. 후진하며 반시계로 돌면 로봇의 뒤쪽이 오른쪽으로 휘어 "오른쪽 뒤" 로 갑니다(공식 표와 같음).
teleop(키를 누를 때 또는 30 Hz 키 반복)과 조이스틱 노드(가정: 손대지 않으면 0 을 계속 보냄)가 같은 /cmd_vel 에 보낼 때, "마지막 메시지가 이긴다" 는 규칙으로 5초 동안 로봇이 얼마나 가는지 계산합니다. TODO 를 채우세요. 예측 먼저: teleop 을 누르고 있어도(30 Hz) 조이스틱이 50 Hz 로 0 을 보내면 몇 % 의 시간 동안 움직일까요?
def simulate(key_rate_hz, joy_rate_hz, T_ms=5000, v=0.5):
events = [] # (시각 ms, 값)
if key_rate_hz is None: # 한 번만 누름
events.append((0, v))
elif key_rate_hz > 0:
step = 1000 / key_rate_hz
t = 0.0
while t < T_ms:
events.append((round(t), v))
t += step
# TODO 1: joy_rate_hz > 0 이면 50 ms 부터 1000/joy_rate_hz 간격으로 (시각, 0.0) 을 events 에 넣습니다
events.sort(key=lambda e: e[0])
cmd, k, dist, moving = 0.0, 0, 0.0, 0
for ms in range(T_ms):
# TODO 2: events[k] 의 시각이 ms 이하인 것을 모두 적용해 cmd 를 갱신합니다 (마지막 것이 이김)
dist += cmd / 1000
moving += cmd > 0
return dist, moving / T_ms * 100
print("teleop 키 조이스틱 5초 이동 거리 움직인 시간")
for kr, jr in [(None, 0), (None, 10), (30, 0), (30, 10), (30, 50)]:
d, p = simulate(kr, jr)
name = "한 번 누름" if kr is None else "누르고 있음 %d Hz" % kr
print("%-16s %5d Hz %8.2f m %6.1f %%" % (name, jr, d, p))풀이 코드 보기
def simulate(key_rate_hz, joy_rate_hz, T_ms=5000, v=0.5):
events = [] # (시각 ms, 값)
if key_rate_hz is None: # 한 번만 누름
events.append((0, v))
elif key_rate_hz > 0:
step = 1000 / key_rate_hz
t = 0.0
while t < T_ms:
events.append((round(t), v))
t += step
if joy_rate_hz > 0:
step = 1000 / joy_rate_hz
t = 50.0 # 조이스틱 노드는 50 ms 어긋나게 시작
while t < T_ms:
events.append((round(t), 0.0))
t += step
events.sort(key=lambda e: e[0])
cmd, k, dist, moving = 0.0, 0, 0.0, 0
for ms in range(T_ms):
while k < len(events) and events[k][0] <= ms:
cmd = events[k][1]
k += 1
dist += cmd / 1000
moving += cmd > 0
return dist, moving / T_ms * 100
print("teleop 키 조이스틱 5초 이동 거리 움직인 시간")
for kr, jr in [(None, 0), (None, 10), (30, 0), (30, 10), (30, 50)]:
d, p = simulate(kr, jr)
name = "한 번 누름" if kr is None else "누르고 있음 %d Hz" % kr
print("%-16s %5d Hz %8.2f m %6.1f %%" % (name, jr, d, p))실행 결과:
teleop 키 조이스틱 5초 이동 거리 움직인 시간
한 번 누름 0 Hz 2.50 m 100.0 %
한 번 누름 10 Hz 0.03 m 1.0 %
누르고 있음 30 Hz 0 Hz 2.50 m 100.0 %
누르고 있음 30 Hz 10 Hz 2.07 m 83.0 %
누르고 있음 30 Hz 50 Hz 0.76 m 30.5 %- 한 번 누른 명령은 50 ms 뒤 조이스틱의 0 에 덮여 0.03 m 만 갑니다. 키를 누르고 있어도 조이스틱 주기가 빠를수록 덮이는 시간이 늘어 툭툭 끊깁니다(가감속까지 넣으면 실제로는 거의 못 갑니다).
- 해결은 한 번에 한 퍼블리셔만 켜거나, 두 입력을 우선순위로 골라 주는 노드(멀티플렉서, 예: twist_mux)를 두는 것입니다.
teleop_twist_keyboard 에서 speed 0.5, turn 1.0 일 때, j 와 Shift+J 가 보내는 Twist 로 옳은 것은?
- j = (0, +0.5, 0), Shift+J = (0, 0, +1.0)
- j = (0, 0, +1.0), Shift+J = (0, +0.5, 0)
- j = (−0.5, 0, 0), Shift+J = (0, −0.5, 0)
- 둘 다 (0, +0.5, 0) 이고 Shift 는 속도만 두 배로 한다
정답 보기
② — j 는 angular.z = +turn 으로 제자리 왼쪽 회전, Shift+J 는 linear.y = +speed 로 몸 방향을 유지한 왼쪽 옆걸음입니다. 시뮬레이터 4 의 "드라이버가 쓰는 명령" 과 `ros2 topic echo /cmd_vel` 로 확인할 수 있습니다.시뮬레이터 4 에서 "조이스틱 노드도 실행" 을 켰더니 i 를 눌러도 로봇이 거의 움직이지 않았습니다. 가장 알맞은 설명은?
- 조이스틱 수신기가 꽂혀 있으면 키보드가 꺼진다
/cmd_vel에 퍼블리셔가 둘이고, 조이스틱 노드가 0 을 계속 보내 teleop 의 명령을 바로 덮어쓴다- 큐 크기가 1 이라서 teleop 메시지가 버려진다
- 조이스틱 노드가 ROS_DOMAIN_ID 를 바꿨다
정답 보기
② — 드라이버는 누가 보냈는지 구분하지 않고 마지막 메시지를 씁니다. rqt_graph 에서 `/cmd_vel` 로 들어가는 화살표가 둘인지 확인하고, 한 번에 하나만 켭니다.teleop 으로 로봇을 움직이다가 RViz 창을 클릭한 뒤 k 를 눌렀는데 로봇이 멈추지 않습니다. 가장 먼저 할 일은?
- ROS_DOMAIN_ID 를 바꾼다
- teleop 터미널 창을 클릭해 포커스를 돌려준 뒤 k 를 누른다 (위급하면 로봇 전원 · 비상정지)
- bringup 을 다시 빌드한다
- q 를 눌러 속도를 올린다
정답 보기
② — teleop 은 자기 터미널의 키 입력만 읽습니다. 다른 창에 포커스가 있으면 k 는 그 창으로 갑니다. 그래서 주행 중에는 teleop 터미널을 맨 앞에 두고, 다른 창을 보기 전에 먼저 멈춥니다.4교시 · rclpy 로 나만의 노드 만들기#
내 패키지 만들기#
출고 워크스페이스(~/myagv_plus_ros2)는 git pull 로 갱신되므로, 내 코드는 따로 워크스페이스를 만들어 그 위에 겹칩니다(overlay 위의 overlay).
mkdir -p ~/agv_lab_ws/src && cd ~/agv_lab_ws/src
ros2 pkg create --build-type ament_python agv_lab --dependencies rclpy geometry_msgs sensor_msgs
# agv_lab/agv_lab/ 폴더에 drive_forward.py, safety_stop.py 를 만들고 setup.py 에 등록(아래)
cd ~/agv_lab_ws
colcon build --packages-select agv_lab
source ~/myagv_plus_ros2/install/local_setup.bash # 아래층 먼저
source ~/agv_lab_ws/install/local_setup.bash # 내 워크스페이스를 그 위에setup.py 의 entry_points 에 실행 이름을 등록해야 ros2 run agv_lab drive_forward 가 됩니다.
entry_points={
'console_scripts': [
'drive_forward = agv_lab.drive_forward:main',
'safety_stop = agv_lab.safety_stop:main',
],
},퍼블리셔 노드: 10 Hz 로 2 m 전진 후 정지#
# agv_lab/agv_lab/drive_forward.py - Twist 를 10 Hz 로 보내 distance(m) 만큼 전진한 뒤 정지
import rclpy
from rclpy.node import Node
from geometry_msgs.msg import Twist
class DriveForward(Node):
def __init__(self):
super().__init__('drive_forward')
self.declare_parameter('distance', 2.0) # m
self.declare_parameter('speed', 0.2) # m/s (처음에는 느리게)
self.distance = self.get_parameter('distance').value
self.speed = self.get_parameter('speed').value
self.pub = self.create_publisher(Twist, 'cmd_vel', 10)
self.t0 = self.get_clock().now()
self.done = False
self.timer = self.create_timer(0.1, self.on_timer) # 10 Hz
self.get_logger().info('%.2f m 를 %.2f m/s 로 전진합니다' % (self.distance, self.speed))
def on_timer(self):
elapsed = (self.get_clock().now() - self.t0).nanoseconds * 1e-9
msg = Twist() # 모든 값 0 으로 시작
if elapsed < self.distance / self.speed:
msg.linear.x = self.speed
else:
self.done = True # 0 을 보내고 끝냄
self.pub.publish(msg)
def main():
rclpy.init()
node = DriveForward()
try:
while rclpy.ok() and not node.done:
rclpy.spin_once(node, timeout_sec=0.1)
except KeyboardInterrupt:
pass
finally:
if rclpy.ok():
for _ in range(3): # 끝날 때 정지 명령을 확실히 몇 번 더
node.pub.publish(Twist())
node.destroy_node()
if rclpy.ok():
rclpy.shutdown()
if __name__ == '__main__':
main()ros2 run agv_lab drive_forward --ros-args -p distance:=2.0 -p speed:=0.2- 시간 × 속도 로 거리를 정하는 개루프(open-loop) 방식입니다. 가속 시간 · 바퀴 미끄러짐 때문에 실제 이동 거리는 2 m 와 조금 다릅니다(ch06).
/odom을 구독해 이동 거리가 2 m 가 되면 멈추는 폐루프로 바꾸는 것이 과제 2 입니다. - 끝날 때 0 을 보내는 이유는 1교시 시뮬레이터 1 에서 본 그대로입니다. 드라이버가 마지막 명령을 유지한다면, 0 없이 끝난 노드는 로봇을 계속 가게 합니다.
- Ctrl+C 로 끄면 신호 처리 때문에 rclpy 가 먼저 종료되어 마지막 0 을 못 보낼 수 있습니다(
rclpy.ok()확인). 그래서 드라이버의 타임아웃과 사람이 누를 수 있는 정지 수단을 함께 둡니다.
서브스크라이버: 전방 ±15° 안전 정지 노드#
설계: teleop 의 출력 토픽 이름을 cmd_vel_raw 로 바꾸고(remap), 안전 정지 노드가 그것을 받아 안전할 때만 /cmd_vel 로 넘깁니다(필터). 후진 · 옆걸음 · 회전은 그대로 허용해 사람이 로봇을 빼낼 수 있게 합니다.
teleop ──/cmd_vel_raw──▶ safety_stop ──/cmd_vel──▶ 베이스 드라이버
▲
LiDAR ──────/scan───────────┘Playground 에서 먼저 검증 → rclpy 콜백에 옮기기#
로봇 위에서 디버깅하면 매번 로봇을 움직여야 합니다. 판단 로직을 ROS 와 무관한 순수 함수로 만들어 Playground 에서 가짜 스캔으로 시험한 뒤, 콜백에서 그 함수를 부르기만 합니다(실습 4-1).
| Playground (순수 Python) | rclpy 노드 |
|---|---|
scan = {"angle_min": ..., "ranges": [...]} (dict) | msg.angle_min, msg.ranges (LaserScan 속성) |
front_min(scan, 15, front) 를 직접 호출 | on_scan(self, msg) 콜백 안에서 호출, 결과를 self.dist 에 저장 |
SafetyFilter.filter(vx, vy, wz, dist) | on_cmd(self, msg) 콜백에서 호출 → 결과를 Twist 로 퍼블리시 |
make_scan() 으로 만든 시험용 스캔 | ros2 bag 녹화 또는 실제 /scan |
# agv_lab/agv_lab/safety_stop.py - /scan 의 전방 최소 거리로 /cmd_vel_raw 를 걸러 /cmd_vel 로 보냄
import math
import rclpy
from rclpy.node import Node
from rclpy.qos import qos_profile_sensor_data
from geometry_msgs.msg import Twist
from sensor_msgs.msg import LaserScan
def front_min(msg, half_deg, front):
"""실습 4-1 에서 검증한 함수 - dict 대신 LaserScan 속성을 씀"""
n, inc = len(msg.ranges), msg.angle_increment
k = int(math.ceil(math.radians(half_deg) / inc - 1e-9))
i0 = round((front - msg.angle_min) / inc)
best = math.inf
for d in range(-k, k + 1):
if abs(d * inc) > math.radians(half_deg) + 1e-9:
continue
r = msg.ranges[(i0 + d) % n]
if math.isnan(r) or r < msg.range_min or r > msg.range_max:
continue
best = min(best, r)
return best
class SafetyStop(Node):
def __init__(self):
super().__init__('safety_stop')
self.declare_parameter('stop_distance', 0.5) # m
self.declare_parameter('hysteresis', 0.1) # m
self.declare_parameter('half_angle_deg', 15.0)
self.declare_parameter('front_angle', 0.0) # LiDAR 가 180 도 돌려 달렸으면 3.14159 (ch02, 확인 필요)
self.dist, self.blocked, self.last_scan = math.inf, False, None
self.create_subscription(LaserScan, 'scan', self.on_scan, qos_profile_sensor_data) # 센서 QoS (BEST_EFFORT)
self.create_subscription(Twist, 'cmd_vel_raw', self.on_cmd, 10)
self.pub = self.create_publisher(Twist, 'cmd_vel', 10)
def on_scan(self, msg):
p = lambda name: self.get_parameter(name).value
self.dist = front_min(msg, p('half_angle_deg'), p('front_angle'))
self.last_scan = self.get_clock().now()
def on_cmd(self, msg):
stop = self.get_parameter('stop_distance').value
hyst = self.get_parameter('hysteresis').value
stale = (self.last_scan is None or
(self.get_clock().now() - self.last_scan).nanoseconds > 0.5e9) # 스캔이 끊기면 위험으로 봄
if not self.blocked and (self.dist < stop or stale):
self.blocked = True
self.get_logger().warn('전방 %.2f m - 전진 차단' % self.dist)
elif self.blocked and self.dist > stop + hyst and not stale:
self.blocked = False
self.get_logger().info('전방 %.2f m - 차단 해제' % self.dist)
out = Twist()
out.linear.x = 0.0 if (self.blocked and msg.linear.x > 0) else msg.linear.x
out.linear.y = msg.linear.y
out.angular.z = msg.angular.z
self.pub.publish(out)
def main():
rclpy.init()
node = SafetyStop()
try:
rclpy.spin(node)
except KeyboardInterrupt:
pass
finally:
node.destroy_node()
if rclpy.ok():
rclpy.shutdown()
if __name__ == '__main__':
main()# 터미널 2: 안전 정지 노드
ros2 run agv_lab safety_stop --ros-args -p stop_distance:=0.5
# 터미널 3: teleop 의 출력을 cmd_vel_raw 로 바꿔(remap) 실행
ros2 run teleop_twist_keyboard teleop_twist_keyboard --ros-args -r cmd_vel:=cmd_vel_raw/scan구독에qos_profile_sensor_data(BEST_EFFORT)를 쓰는 이유: LiDAR 드라이버가 BEST_EFFORT 로 보내는데 구독자가 RELIABLE 을 요구하면 QoS 가 맞지 않아 메시지를 하나도 못 받습니다(자주 나는 오류 7). 실제 QoS 는ros2 topic info /scan -v로 확인합니다.- 이 노드는 teleop 처럼 명령이 올 때만 내보냅니다. 키를 한 번 눌러 놓고 가는 중에 장애물이 나타나도, 다음 명령이 와야 0 이 나갑니다. 실제로는 타이머로 마지막 명령을 주기적으로 다시 검사해 보내도록 고칩니다(과제 3).
- 안전 정지 노드는 보조 장치입니다. LiDAR 높이보다 낮거나 높은 물체, 유리 · 검은 물체는 놓칠 수 있습니다(ch07). 물리적 비상정지 · 속도 제한을 대신하지 못합니다.
시뮬레이터 5 · 사람 혼잡 구역에서 안전 정지#
12 m × 3 m 통로를 로봇이 직진합니다. 사람 7명이 정해진 시각에 통로를 가로지르고(그중 한 명은 통로 가운데서 3초 멈춰 섬), 통로 가장자리에 작업자 2명이 서 있습니다. 사람은 로봇 몸통이 자기 길을 막을 때만 멈춰 기다립니다. 안전 정지 노드는 10 Hz 로 전방 원뿔의 최소 거리를 보고, 임계 거리 미만이면 정지, 임계 + 히스테리시스 를 넘으면 다시 출발합니다. 가감속 한계 1 m/s².
- 임계 거리를 0.3 m 와 0.8 m 로 바꾸기 전에 예측합니다: 정지 횟수와 도착 시간은 어느 쪽이 더 많고 길까요? 📊 비교 로 확인합니다.
- 임계 거리를 0.2 m 로 내려 재생합니다. 멈춰 선 사람(노랑) 앞에서 무슨 일이 생기나요? 속도 0.5 m/s, 가감속 1 m/s² 일 때 제동 거리(v²/2a)와 반응 거리(v × 0.1 s), LiDAR ~ 범퍼 거리(0.105 m)를 더해 보세요.
- 원뿔을 ±45° 로 넓히고 임계 0.5 m 로 재생합니다. 로봇이 어디서 왜 멈춰 버리나요? "통로 옆 작업자" 를 끄면 어떻게 되나요?
- 히스테리시스를 0 으로 하고 재생 속도를 × 1 로 하여, 멈춰 선 사람이 떠날 때 로봇의 출발 · 정지가 어떻게 되는지 봅니다.
- 속도를 0.8 m/s 로 올리고 📊 비교를 누릅니다. 임계 거리를 늘려도 접촉이 남는 이유는 무엇일까요?
- 기본(±15°, 0.5 m/s): 0.3 m → 22.9 s · 정지 1회, 0.5 m → 23.4 s · 2회, 0.8 m → 24.1 s · 4회. 임계 거리가 클수록 앞을 지나가는 사람에게도 멈춰 정지가 늘고 도착이 늦어집니다. 대신 최소 간격은 0.08 → 0.18 m 로 넓어집니다.
- 0.2 m 에서는 멈춰 선 사람과 접촉합니다. 0.5 m/s 의 제동 거리 0.125 m + 반응 0.05 m + LiDAR ~ 범퍼 0.105 m ≈ 0.28 m > 0.2 m 이기 때문입니다. 임계 거리 > 반응 거리 + 제동 거리 + 센서 ~ 범퍼 거리 가 최소 조건입니다.
- ±45° 원뿔에 0.5 m 이상이면 통로 옆에 가만히 서 있는 작업자가 원뿔에 들어와 로봇이 그 앞에서 영원히 멈춥니다(120 s 실패). 원뿔을 넓히면 옆에서 들어오는 사람은 빨리 보지만, 길을 막지 않는 것까지 장애물로 봅니다. 그래서 원뿔 대신 로봇이 지나갈 띠(폭) 를 검사하는 방법도 씁니다(과제 3).
- 히스테리시스 0 이면 거리가 임계값 근처에서 흔들릴 때 출발 · 정지를 반복할 수 있습니다(채터링). 0.1 m 정도의 여유가 그것을 막습니다.
- 0.8 m/s 에서는 옆에서 갑자기 들어오는 사람을 전방 원뿔이 늦게 봐서 임계 거리를 늘려도 접촉이 남습니다. 혼잡 구역의 답은 속도를 낮추는 것입니다(ch08 의 DWA, ch10 Nav2 의 속도 제한 구역).
멀티 로봇 충돌 방지: ROS_DOMAIN_ID · ROS_LOCALHOST_ONLY#
교실에 myAGV Plus 가 여러 대 있으면, 모두 기본값 ROS_DOMAIN_ID=0 이라 한 팀의 teleop 이 모든 로봇을 움직일 수 있습니다. 공식 문서(6.2.1 Notes-2)의 방법은 두 가지입니다.
# 방법 1: 로봇마다 다른 도메인 ID (로봇과 그 로봇을 조종하는 노트북을 같은 번호로)
export ROS_DOMAIN_ID=1 # 1번 팀 로봇 · 노트북 모두
# 영구 적용
echo "export ROS_DOMAIN_ID=1" >> ~/.bashrc
# 방법 2: 이 컴퓨터 안의 노드끼리만 통신 (다른 컴퓨터와 아예 안 통함)
export ROS_LOCALHOST_ONLY=1- 도메인 ID 는 0 ~ 101 사이를 권장합니다(그 이상은 운영체제 포트 범위와 겹칠 수 있음, ROS 2 문서). 교실에서는 팀 번호 = 도메인 ID 처럼 정해 두고 로봇 스티커에 적습니다.
ROS_LOCALHOST_ONLY=1은 노트북에서 RViz 로 로봇을 보는 것까지 막습니다. 로봇에 SSH 로 접속해 로봇 안에서 teleop 을 실행할 때 적합합니다.- 환경 변수는 노드를 실행하기 전에 정해야 합니다. 이미 떠 있는 노드에는 적용되지 않으므로, 바꾼 뒤 bringup 부터 다시 실행합니다. 데몬이 이전 값을 기억할 수 있으니
ros2 daemon stop도 해 줍니다.
시뮬레이터 6 · 도메인 ID 교실#
세 팀의 노트북과 로봇이 같은 Wi-Fi 에 있습니다. 각 기기의 ROS_DOMAIN_ID 와 ROS_LOCALHOST_ONLY 를 정하고 "i 보내기" 를 눌러, 어느 로봇이 명령을 받는지 보세요.
- 모두 기본값 (0) 에서 A팀 노트북으로 i 를 보내기 전에, 몇 대의 로봇이 움직일지 예측합니다.
- 팀마다 1 · 2 · 3 으로 바꾸고 세 팀 노트북에서 차례로 보냅니다.
- 로봇만 바꾸고 노트북은 0 으로 하면? 수업에서 가장 흔한 실수입니다. 어느 기기의 무엇을 고쳐야 하나요?
- 모두 LOCALHOST_ONLY=1 에서 노트북으로 보낼 때와 로봇 안(SSH) 에서 보낼 때를 비교합니다.
- A팀 로봇의 ID 를 2 로 잘못 적으면 어떤 일이 생길까요? B팀 노트북으로 보내 확인합니다.
- 모두 0 이면 한 노트북의 명령이 세 대 모두에 갑니다. 같은 도메인의 노드는 서로를 자동으로 찾기 때문입니다.
- 로봇만 바꾸면 노트북(ID 0)의 명령은 아무 로봇에도 가지 않습니다. 노트북과 로봇의 ID 를 짝으로 맞춰야 합니다. 노트북 쪽
ros2 topic list에 로봇 토픽이 안 보이는 것으로도 알 수 있습니다. - LOCALHOST_ONLY 는 같은 컴퓨터 안에서만 통합니다. 노트북 → 로봇은 막히지만, SSH 로 로봇에 들어가 로봇 안에서 teleop 을 실행하면 됩니다. 다른 팀과 절대 섞이지 않는 가장 확실한 방법입니다.
실습 과제 4#
가짜 360° 스캔으로 front_min() 을 완성하세요. 무효값(NaN, inf, range_min 미만)은 건너뛰고, 배열 끝을 넘어가는 칸은 반대쪽 끝으로 돌아가야 합니다(정면이 ±π 일 때). 이어서 히스테리시스가 있는 SafetyFilter 를 시험합니다. 예측 먼저: LiDAR 가 180° 돌려 달려 front=pi 를 써야 하는데 0 으로 두면, 정면 0.40 m 의 사람을 볼까요?
import math
def front_min(scan, half_deg=15.0, front=0.0):
n = len(scan["ranges"])
inc = scan["angle_increment"]
best = math.inf
k = int(math.ceil(math.radians(half_deg) / inc - 1e-9))
i0 = round((front - scan["angle_min"]) / inc) # 정면에 해당하는 칸
for d in range(-k, k + 1):
if abs(d * inc) > math.radians(half_deg) + 1e-9:
continue
# TODO 1: 칸 번호 (i0 + d) 를 n 으로 나눈 나머지로 돌려 r 을 읽습니다
r = math.inf
# TODO 2: NaN, range_min 미만, range_max 초과는 건너뜁니다 (continue)
best = min(best, r)
return best
class SafetyFilter:
def __init__(self, stop=0.5, hyst=0.1):
self.stop, self.hyst, self.blocked = stop, hyst, False
def filter(self, vx, vy, wz, dist):
# TODO 3: dist < stop 이면 blocked, dist > stop + hyst 이면 해제
if self.blocked and vx > 0: # 앞으로 가는 성분만 막음
return 0.0, vy, wz
return vx, vy, wz
def make_scan(obstacles, n=360):
"""정면이 0 도인 360 칸 가짜 스캔. obstacles = {각도(도): 거리}"""
inc = 2 * math.pi / n
ranges = [math.inf] * n
for deg, r in obstacles.items():
ranges[round((math.radians(deg) + math.pi) / inc) % n] = r
return {"angle_min": -math.pi, "angle_max": math.pi - inc, "angle_increment": inc,
"range_min": 0.12, "range_max": 8.0, "ranges": ranges}
tests = [("정면 0.40 m", {0: 0.40}), ("왼쪽 14 도 0.45 m", {14: 0.45}), ("왼쪽 20 도 0.30 m", {20: 0.30}),
("정면 NaN + 10 도 0.9 m", {0: float("nan"), 10: 0.9}), ("정면 0.05 m (최소 거리 미만)", {0: 0.05}),
("뒤쪽 180 도 0.35 m", {180: 0.35})]
for name, ob in tests:
s = make_scan(ob)
print("%-28s 앞(front=0) %5s front=pi 일 때 %5s" % (name, "%.2f" % front_min(s), "%.2f" % front_min(s, front=math.pi)))
f = SafetyFilter(0.5, 0.1)
print()
for d in [1.2, 0.8, 0.49, 0.55, 0.58, 0.61, 0.9]:
print("거리 %.2f m -> 명령" % d, f.filter(0.3, 0.0, 0.2, d))풀이 코드 보기
import math
def front_min(scan, half_deg=15.0, front=0.0):
n = len(scan["ranges"])
inc = scan["angle_increment"]
best = math.inf
k = int(math.ceil(math.radians(half_deg) / inc - 1e-9))
i0 = round((front - scan["angle_min"]) / inc) # 정면에 해당하는 칸
for d in range(-k, k + 1):
if abs(d * inc) > math.radians(half_deg) + 1e-9:
continue
r = scan["ranges"][(i0 + d) % n] # 끝을 넘으면 반대쪽 끝으로
if math.isnan(r) or r < scan["range_min"] or r > scan["range_max"]:
continue # 무효값 (inf 도 range_max 초과로 걸러짐)
best = min(best, r)
return best
class SafetyFilter:
def __init__(self, stop=0.5, hyst=0.1):
self.stop, self.hyst, self.blocked = stop, hyst, False
def filter(self, vx, vy, wz, dist):
if not self.blocked and dist < self.stop:
self.blocked = True
elif self.blocked and dist > self.stop + self.hyst:
self.blocked = False
if self.blocked and vx > 0: # 앞으로 가는 성분만 막음
return 0.0, vy, wz
return vx, vy, wz
def make_scan(obstacles, n=360):
"""정면이 0 도인 360 칸 가짜 스캔. obstacles = {각도(도): 거리}"""
inc = 2 * math.pi / n
ranges = [math.inf] * n
for deg, r in obstacles.items():
ranges[round((math.radians(deg) + math.pi) / inc) % n] = r
return {"angle_min": -math.pi, "angle_max": math.pi - inc, "angle_increment": inc,
"range_min": 0.12, "range_max": 8.0, "ranges": ranges}
tests = [("정면 0.40 m", {0: 0.40}), ("왼쪽 14 도 0.45 m", {14: 0.45}), ("왼쪽 20 도 0.30 m", {20: 0.30}),
("정면 NaN + 10 도 0.9 m", {0: float("nan"), 10: 0.9}), ("정면 0.05 m (최소 거리 미만)", {0: 0.05}),
("뒤쪽 180 도 0.35 m", {180: 0.35})]
for name, ob in tests:
s = make_scan(ob)
print("%-28s 앞(front=0) %5s front=pi 일 때 %5s" % (name, "%.2f" % front_min(s), "%.2f" % front_min(s, front=math.pi)))
f = SafetyFilter(0.5, 0.1)
print()
for d in [1.2, 0.8, 0.49, 0.55, 0.58, 0.61, 0.9]:
print("거리 %.2f m -> 명령" % d, f.filter(0.3, 0.0, 0.2, d))실행 결과:
정면 0.40 m 앞(front=0) 0.40 front=pi 일 때 inf
왼쪽 14 도 0.45 m 앞(front=0) 0.45 front=pi 일 때 inf
왼쪽 20 도 0.30 m 앞(front=0) inf front=pi 일 때 inf
정면 NaN + 10 도 0.9 m 앞(front=0) 0.90 front=pi 일 때 inf
정면 0.05 m (최소 거리 미만) 앞(front=0) inf front=pi 일 때 inf
뒤쪽 180 도 0.35 m 앞(front=0) inf front=pi 일 때 0.35
거리 1.20 m -> 명령 (0.3, 0.0, 0.2)
거리 0.80 m -> 명령 (0.3, 0.0, 0.2)
거리 0.49 m -> 명령 (0.0, 0.0, 0.2)
거리 0.55 m -> 명령 (0.0, 0.0, 0.2)
거리 0.58 m -> 명령 (0.0, 0.0, 0.2)
거리 0.61 m -> 명령 (0.3, 0.0, 0.2)
거리 0.90 m -> 명령 (0.3, 0.0, 0.2)front를 잘못 두면 정면의 사람은 못 보고 뒤쪽 물체에 멈춥니다(마지막 줄). LiDAR 장착 방향은 ch02 처럼 TF(base_link → laser)에서 확인합니다.- 0.05 m(최소 거리 미만)는 "무효" 로 버려져 inf 가 됩니다. 너무 가까워서 못 잰 것일 수도 있으므로, 실제 노드에서는 무효 칸이 정면에 많으면 위험으로 보는 규칙을 더하는 것이 안전합니다.
- 0.49 m 에서 막힌 뒤 0.55 · 0.58 m 에서도 계속 막혀 있다가 0.61 m(> 0.5 + 0.1)에서 풀립니다. 이것이 히스테리시스입니다. 회전(0.2 rad/s)은 막는 중에도 그대로 통과합니다.
시뮬레이터 5 와 같은 지도 · 같은 사람 · 같은 순서로 만든 Python 시뮬레이션입니다. TODO(정지 · 재출발 판단)를 채우고, 임계 거리별 도착 시간 · 정지 횟수 · 최소 간격 · 접촉을 표로 만드세요. 예측 먼저: 0.3 m 와 0.8 m 중 어느 쪽이 정지가 많고 도착이 늦을까요? 원뿔 ±45° 에서 0.5 m 는?
import math
H = 3.0 # 통로 폭 (m)
HL, HW = 0.17, 0.12 # 로봇 반길이 · 반폭 (m)
LIDAR_X = 0.065 # 로봇 중심 -> LiDAR (m)
PR = 0.25 # 사람 반지름 (m)
DT = 0.1 # 제어 주기 10 Hz
ACC = 1.0 # 가감속 한계 (m/s^2)
GOAL_X = 11.4
D2R = math.pi / 180
MID = 1.9 # 출발점(y = -0.4)에서 통로 가운데까지 거리
# 건너는 사람: (x, 출발 시각 s, 방향 +1, 속도 m/s, 가운데서 멈춰 서는 시간 s)
CROSS = [(2.7, 0.6, 1, 1.0, 0.0), (3.6, 2.8, 1, 1.1, 0.0), (4.4, 4.6, 1, 1.0, 0.0),
(7.0, 7.4, 1, 0.9, 3.0), (8.5, 11.4, 1, 1.2, 0.0), (9.4, 13.4, 1, 0.9, 0.0),
(10.4, 16.4, 1, 0.9, 0.0)]
WORKERS = [(4.0, 0.95), (8.0, 2.05)] # 통로 옆에 서 있는 작업자
def rect_gap(rx, px, py):
dx = max(abs(px - rx) - HL, 0.0)
dy = max(abs(py - 1.5) - HW, 0.0)
return math.sqrt(dx * dx + dy * dy) - PR
def scan_min(rx, people, cone):
lx, ly = rx + LIDAR_X, 1.5
best = math.inf
for k in range(-cone, cone + 1): # 1 도 간격 빔
a = k * D2R
c, s = math.cos(a), math.sin(a)
r = math.inf
if s > 0:
r = (H - ly) / s # 위쪽 벽
elif s < 0:
r = (0.0 - ly) / s # 아래쪽 벽
for (px, py) in people: # 빔과 원(사람)의 교점
dx, dy = px - lx, py - ly
b = dx * c + dy * s
d2 = dx * dx + dy * dy - b * b
if b > 0 and d2 < PR * PR:
t = b - math.sqrt(PR * PR - d2)
if t < r:
r = t
if r > 8.0:
r = math.inf
if r < best:
best = r
return best
class Crowd:
def __init__(self):
self.w = [0.0] * len(CROSS) # 걸은 거리
self.p = [c[4] for c in CROSS] # 남은 멈춤 시간
def pos(self, t):
out = []
for i, (px, t0, d, sp, ps) in enumerate(CROSS):
if t >= t0:
py = (-0.4 if d > 0 else H + 0.4) + d * self.w[i]
if -0.5 < py < H + 0.5:
out.append((px, py))
return out
def step(self, t, rx):
for i, (px, t0, d, sp, ps) in enumerate(CROSS):
if t < t0:
continue
w = self.w[i]
if w >= MID and self.p[i] > 0: # 가운데서 멈춰 서 있음
self.p[i] = round(self.p[i] - DT, 1)
continue
w1 = w + sp * DT
if w < MID and w1 > MID and self.p[i] > 0:
w1 = MID
y0 = (-0.4 if d > 0 else H + 0.4) + d * w
y1 = (-0.4 if d > 0 else H + 0.4) + d * w1
g0, g1 = rect_gap(rx, px, y0), rect_gap(rx, px, y1)
if g0 >= 0 and g1 < 0.02 and g1 < g0: # 로봇 몸통으로 걸어 들어가지는 않음
continue
self.w[i] = w1
def run(d_stop, v_nom=0.5, cone=15, hyst=0.1, workers=True):
cr = Crowd()
x, v, t, state = 0.6, 0.0, 0.0, "go"
stops, contacts, in_c, min_gap, stop_time = 0, 0, False, math.inf, 0.0
while True:
m = scan_min(x, cr.pos(t) + (WORKERS if workers else []), cone)
# TODO: state 가 "go" 이고 m < d_stop 이면 "stop" 으로 바꾸고 stops 를 1 늘립니다
# state 가 "stop" 이고 m > d_stop + hyst 이면 "go" 로 바꿉니다
cmd = v_nom if state == "go" else 0.0
v = min(cmd, v + ACC * DT) if cmd > v else max(cmd, v - ACC * DT)
x += v * DT
t = round(t + DT, 1)
cr.step(t, x)
people = cr.pos(t) + (WORKERS if workers else [])
g = min([rect_gap(x, px, py) for (px, py) in people] + [math.inf])
min_gap = min(min_gap, g)
if g < 0:
if not in_c:
contacts += 1
in_c = True
else:
in_c = False
if v < 0.01:
stop_time += DT
if x >= GOAL_X or t >= 120:
return x >= GOAL_X, t, stops, stop_time, min_gap, contacts
print("원뿔 임계 도착 정지 멈춘시간 최소간격 접촉")
for cone, ds in [(15, 0.2), (15, 0.3), (15, 0.5), (15, 0.8), (45, 0.3), (45, 0.5)]:
ok, t, st, stt, gap, ct = run(ds, cone=cone)
print("+-%2d %.1f m %8s %3d %6.1f s %7.3f m %3d" % (cone, ds, "%.1f s" % t if ok else "실패", st, stt, gap, ct))풀이 코드 보기
import math
H = 3.0 # 통로 폭 (m)
HL, HW = 0.17, 0.12 # 로봇 반길이 · 반폭 (m)
LIDAR_X = 0.065 # 로봇 중심 -> LiDAR (m)
PR = 0.25 # 사람 반지름 (m)
DT = 0.1 # 제어 주기 10 Hz
ACC = 1.0 # 가감속 한계 (m/s^2)
GOAL_X = 11.4
D2R = math.pi / 180
MID = 1.9 # 출발점(y = -0.4)에서 통로 가운데까지 거리
# 건너는 사람: (x, 출발 시각 s, 방향 +1, 속도 m/s, 가운데서 멈춰 서는 시간 s)
CROSS = [(2.7, 0.6, 1, 1.0, 0.0), (3.6, 2.8, 1, 1.1, 0.0), (4.4, 4.6, 1, 1.0, 0.0),
(7.0, 7.4, 1, 0.9, 3.0), (8.5, 11.4, 1, 1.2, 0.0), (9.4, 13.4, 1, 0.9, 0.0),
(10.4, 16.4, 1, 0.9, 0.0)]
WORKERS = [(4.0, 0.95), (8.0, 2.05)] # 통로 옆에 서 있는 작업자
def rect_gap(rx, px, py):
dx = max(abs(px - rx) - HL, 0.0)
dy = max(abs(py - 1.5) - HW, 0.0)
return math.sqrt(dx * dx + dy * dy) - PR
def scan_min(rx, people, cone):
lx, ly = rx + LIDAR_X, 1.5
best = math.inf
for k in range(-cone, cone + 1): # 1 도 간격 빔
a = k * D2R
c, s = math.cos(a), math.sin(a)
r = math.inf
if s > 0:
r = (H - ly) / s # 위쪽 벽
elif s < 0:
r = (0.0 - ly) / s # 아래쪽 벽
for (px, py) in people: # 빔과 원(사람)의 교점
dx, dy = px - lx, py - ly
b = dx * c + dy * s
d2 = dx * dx + dy * dy - b * b
if b > 0 and d2 < PR * PR:
t = b - math.sqrt(PR * PR - d2)
if t < r:
r = t
if r > 8.0:
r = math.inf
if r < best:
best = r
return best
class Crowd:
def __init__(self):
self.w = [0.0] * len(CROSS) # 걸은 거리
self.p = [c[4] for c in CROSS] # 남은 멈춤 시간
def pos(self, t):
out = []
for i, (px, t0, d, sp, ps) in enumerate(CROSS):
if t >= t0:
py = (-0.4 if d > 0 else H + 0.4) + d * self.w[i]
if -0.5 < py < H + 0.5:
out.append((px, py))
return out
def step(self, t, rx):
for i, (px, t0, d, sp, ps) in enumerate(CROSS):
if t < t0:
continue
w = self.w[i]
if w >= MID and self.p[i] > 0: # 가운데서 멈춰 서 있음
self.p[i] = round(self.p[i] - DT, 1)
continue
w1 = w + sp * DT
if w < MID and w1 > MID and self.p[i] > 0:
w1 = MID
y0 = (-0.4 if d > 0 else H + 0.4) + d * w
y1 = (-0.4 if d > 0 else H + 0.4) + d * w1
g0, g1 = rect_gap(rx, px, y0), rect_gap(rx, px, y1)
if g0 >= 0 and g1 < 0.02 and g1 < g0: # 로봇 몸통으로 걸어 들어가지는 않음
continue
self.w[i] = w1
def run(d_stop, v_nom=0.5, cone=15, hyst=0.1, workers=True):
cr = Crowd()
x, v, t, state = 0.6, 0.0, 0.0, "go"
stops, contacts, in_c, min_gap, stop_time = 0, 0, False, math.inf, 0.0
while True:
m = scan_min(x, cr.pos(t) + (WORKERS if workers else []), cone)
if state == "go" and m < d_stop:
state, stops = "stop", stops + 1
elif state == "stop" and m > d_stop + hyst:
state = "go"
cmd = v_nom if state == "go" else 0.0
v = min(cmd, v + ACC * DT) if cmd > v else max(cmd, v - ACC * DT)
x += v * DT
t = round(t + DT, 1)
cr.step(t, x)
people = cr.pos(t) + (WORKERS if workers else [])
g = min([rect_gap(x, px, py) for (px, py) in people] + [math.inf])
min_gap = min(min_gap, g)
if g < 0:
if not in_c:
contacts += 1
in_c = True
else:
in_c = False
if v < 0.01:
stop_time += DT
if x >= GOAL_X or t >= 120:
return x >= GOAL_X, t, stops, stop_time, min_gap, contacts
print("원뿔 임계 도착 정지 멈춘시간 최소간격 접촉")
for cone, ds in [(15, 0.2), (15, 0.3), (15, 0.5), (15, 0.8), (45, 0.3), (45, 0.5)]:
ok, t, st, stt, gap, ct = run(ds, cone=cone)
print("+-%2d %.1f m %8s %3d %6.1f s %7.3f m %3d" % (cone, ds, "%.1f s" % t if ok else "실패", st, stt, gap, ct))실행 결과:
원뿔 임계 도착 정지 멈춘시간 최소간격 접촉
+-15 0.2 m 22.7 s 1 0.5 s -0.020 m 1
+-15 0.3 m 22.9 s 1 0.7 s 0.080 m 0
+-15 0.5 m 23.4 s 2 0.8 s 0.180 m 0
+-15 0.8 m 24.1 s 4 1.0 s 0.180 m 0
+-45 0.3 m 23.1 s 1 0.9 s 0.080 m 0
+-45 0.5 m 실패 2 113.5 s 0.258 m 0- 시뮬레이터 5 의 📊 비교 와 같은 숫자가 나옵니다.
- 임계 거리를 0.3 → 0.8 m 로 늘리면 정지가 1 → 4회로 늘고 도착이 22.9 → 24.1 s 로 늦어지지만, 최소 간격은 0.08 → 0.18 m 로 넓어집니다. 0.2 m 는 제동 거리가 모자라 접촉합니다.
- ±45° 에서 0.5 m 는 통로 옆 작업자 때문에 멈춘 채 120 s 를 넘깁니다. 원뿔 각도와 임계 거리는 함께 정해야 합니다.
시뮬레이터 5(±15°, 0.5 m/s)에서 임계 거리를 0.3 m 에서 0.8 m 로 늘렸을 때의 변화로 옳은 것은?
- 정지 횟수가 줄고 도착이 빨라진다
- 정지 횟수가 늘고 도착이 늦어지지만, 사람과의 최소 간격이 넓어진다
- 아무 변화가 없다 — 임계 거리는 정면에 멈춰 선 사람에게만 적용된다
- 접촉이 늘어난다
정답 보기
② — 0.3 m: 1회 · 22.9 s · 최소 0.08 m, 0.8 m: 4회 · 24.1 s · 최소 0.18 m. 앞을 지나가기만 하는 사람에게도 멈추기 때문에 정지가 늘어납니다. 안전과 효율의 맞바꿈(trade-off)입니다.로봇이 1.0 m/s 로 달리고, 감속 한계가 1.0 m/s², 제어 주기(반응 지연)가 0.1 s, LiDAR 에서 범퍼 앞까지 0.1 m 입니다. 정면에 멈춰 선 사람과 부딪히지 않으려면 임계 거리는 적어도 얼마보다 커야 할까요?
- 0.2 m
- 0.4 m
- 0.7 m
- 1.5 m
정답 보기
③ — 반응 거리 1.0 × 0.1 = 0.1 m, 제동 거리 1.0² / (2 × 1.0) = 0.5 m, LiDAR ~ 범퍼 0.1 m 를 더하면 0.7 m 입니다. 속도가 두 배가 되면 제동 거리는 네 배가 되므로, 빠르게 다니는 구역일수록 임계 거리를 크게(또는 속도를 낮게) 잡아야 합니다.교실의 세 로봇을 각각 ROS_DOMAIN_ID=1, 2, 3 으로 바꿨는데, 노트북은 그대로 두었습니다. A팀 노트북에서 teleop 을 실행하면?
- 세 로봇이 모두 움직인다
- A팀 로봇만 움직인다
- 어느 로봇도 움직이지 않는다 — 노트북도 로봇과 같은 ID 로 바꿔야 한다
- 노트북이 자동으로 가장 가까운 로봇의 ID 로 바뀐다
정답 보기
③ — 노트북은 기본값 0 이라 1 · 2 · 3 번 도메인의 로봇과 서로를 찾지 못합니다. 노트북 쪽 `ros2 topic list` 에 로봇 토픽이 보이지 않는 것으로 확인할 수 있습니다. 노트북에도 `export ROS_DOMAIN_ID=1` 을 하고 teleop 을 다시 실행합니다.실습 (실물)#
- bringup 과 확인: 터미널 1 에서 bringup, 터미널 2 에서
ros2 node list,ros2 topic list -t,ros2 topic hz /scan,ros2 topic info /cmd_vel -v결과를 기록합니다. 이 페이지에서 "확인 필요" 였던 이름 · 주기를 표로 채웁니다. - 타임아웃 확인: 바퀴를 띄운 채
ros2 topic pub -r 10 /cmd_vel geometry_msgs/msg/Twist "{linear: {x: 0.1}}"를 실행하고 Ctrl+C 로 끕니다. 바퀴가 멈출 때까지 시간을 잽니다(멈추지 않으면 k 키 · 0 메시지로 멈추고 기록). - 키보드: teleop 에서 j 와 Shift+J 를 눌러 보며 다른 터미널의
ros2 topic echo /cmd_vel로 값을 확인합니다. 바닥에 테이프로 만든 "피킹 스테이션" 세 곳을 A → B → C 순서로 정차합니다. - 조이스틱: 수신기를 꽂고
ros2 run myagv_plus_joystick_control joystick_controller. 불빛 상태(초록 · 빨강)를 확인하고, 빨간 불만이면 MODE 3초. 스틱 방향과/cmd_vel값의 대응을 표로 적습니다. - 내 노드:
drive_forward로 2 m 전진 후 줄자로 실제 거리를 잽니다(속도 0.1 · 0.2 · 0.3 m/s 비교).safety_stop을 켜고 teleop 을cmd_vel_raw로 remap 한 뒤, 상자를 0.5 m 앞에 놓고 전진이 막히는지, 후진 · 옆걸음은 되는지 확인합니다. 사람으로 시험하지 않습니다.
모델 확인 (3D 뷰어)#
강좌용 myAGV Plus 모델(assets/robot/robot.json)이 아직 없다면 뷰어에 "모델 없음" 안내가 나옵니다. myagv_plus_ros2 의 myagv_plus_description 패키지에 로봇 모델이 있으며, 모델이 준비되면 다음을 확인합니다.
- LiDAR 링크(laser 프레임)가 로봇 정면을 기준으로 어느 방향으로 돌아가 달려 있는지 → 안전 정지 노드의
front_angle값. - LiDAR 에서 차체 앞 범퍼까지 거리 → 확인 문제 4-2 의 "LiDAR ~ 범퍼" 값.
모델이 없을 때는 아래 계산으로 LiDAR 장착 방향이 "정면 각도" 를 어떻게 바꾸는지 확인할 수 있습니다. 실물에서는 ros2 run tf2_ros tf2_echo base_link <laser 프레임> 으로 확인합니다(ch02, 프레임 이름은 로봇에서 확인).
import numpy as np
# 교육용 가정: LiDAR 가 로봇 중심 앞 0.065 m 에 yaw 만큼 돌려 달림 (myagv_ros2 의 값, Plus 는 확인 필요)
def laser_to_base(r, ang, x=0.065, yaw=np.pi):
p_laser = np.array([r * np.cos(ang), r * np.sin(ang)])
R = np.array([[np.cos(yaw), -np.sin(yaw)], [np.sin(yaw), np.cos(yaw)]])
return R @ p_laser + np.array([x, 0.0])
for yaw in (0.0, np.pi):
print("LiDAR yaw = %3.0f 도" % np.degrees(yaw))
for deg in (0, 90, 180):
bx, by = laser_to_base(1.0, np.radians(deg), yaw=yaw)
side = "앞" if bx > 0.5 else ("뒤" if bx < -0.5 else "옆")
print(" 레이저 각도 %3d 도, 거리 1.0 m -> 로봇 기준 (%+.3f, %+.3f) m [%s]" % (deg, bx, by, side))- yaw = 180° 로 달린 LiDAR 는 레이저 각도 0° 가 로봇 뒤(−0.935 m)입니다. 이때 로봇 정면은 레이저 각도 180° 이므로
front_angle = π를 씁니다(실습 4-1).
자주 나는 오류와 해결#
1) launch · run 이 패키지를 못 찾음#
Package 'myagv_plus_bringup' not found: "package 'myagv_plus_bringup' not found, searching: ['/opt/ros/humble']"- 원인: 이 터미널에서 워크스페이스를 source 하지 않았습니다. 새 터미널을 열었거나, 빌드가 실패해
install/에 패키지가 없습니다. - 해결:
source ~/myagv_plus_ros2/install/local_setup.bash를 하고, 계속 쓸 것이면.bashrc끝에 넣습니다. 그래도 안 되면ls ~/myagv_plus_ros2/install에 패키지 폴더가 있는지 보고, 없으면 빌드 로그(log/latest_build)를 확인합니다.
2) 빌드 중 컴파일러가 강제 종료됨#
c++: fatal error: Killed signal terminated program cc1plus
compilation terminated.
Failed <<< (패키지 이름)- 원인: 동시에 컴파일하는 파일이 많아 메모리가 모자랐습니다(시뮬레이터 3). rtabmap · nav2 같은 큰 패키지에서 잘 납니다.
- 해결: 브라우저 · RViz 를 끄고, 공식 권장대로
export MAKEFLAGS="-j5"후colcon build --parallel-workers 1 --cmake-args -DCMAKE_BUILD_TYPE=Release. 내 패키지만 고쳤다면--packages-select로 그것만 빌드합니다.
3) rosdep 이 의존성을 못 찾음#
ERROR: the following packages/stacks could not have their rosdep keys resolved
to system dependencies:- 원인: rosdep 데이터베이스를 초기화 · 갱신하지 않았거나, 인터넷 연결이 없습니다.
- 해결: 처음 한 번
sudo rosdep init(이미 했다면 오류가 나도 무시), 그리고rosdep update후 다시rosdep install --from-paths src --ignore-src -r -y.
4) teleop 을 실행할 수 없음#
Package 'teleop_twist_keyboard' not found- 원인: teleop_twist_keyboard 가 설치되어 있지 않습니다(myagv_plus_ros2 저장소에 들어 있지 않음 — 출고 이미지 설치 여부는 확인 필요).
- 해결:
sudo apt install ros-humble-teleop-twist-keyboard.
5) 키를 눌러도 로봇이 안 움직임 / 키를 떼도 계속 감#
(teleop 화면) currently: speed 0.5 turn 1.0 ← 키에 반응은 하는데 로봇은 그대로- 원인: (a) teleop 터미널에 포커스가 없음, (b) bringup 이 꺼져 있음, (c) 노트북과 로봇의
ROS_DOMAIN_ID가 다름, (d) 드라이버가 구독하는 토픽 이름이/cmd_vel과 다름, (e) 다른 노드(조이스틱 등)가 0 을 계속 보냄. 키를 떼도 계속 가는 것은 드라이버가 마지막 명령을 유지하기 때문입니다(시뮬레이터 1 · 4). - 해결:
ros2 topic echo /cmd_vel로 메시지가 실제로 나가는지,ros2 topic info /cmd_vel -v로 퍼블리셔 · 서브스크라이버 수를 봅니다. 멈출 때는 k. 퍼블리셔는 한 번에 하나만 켭니다.
6) 옆 팀 로봇이 같이 움직임#
(ros2 node list) 같은 이름의 노드가 여러 개 보임
WARNING: Be aware that there are nodes in the graph that share an exact name, which can have unintended side effects.- 원인: 모든 로봇 · 노트북이 기본
ROS_DOMAIN_ID=0입니다(시뮬레이터 6). - 해결: 팀마다 다른 ID 를 로봇 · 노트북 양쪽에
export ROS_DOMAIN_ID=팀번호로 정하고(.bashrc),ros2 daemon stop후 노드를 다시 실행합니다. 로봇 안에서만 실행한다면ROS_LOCALHOST_ONLY=1도 됩니다.
7) 안전 정지 노드가 /scan 을 하나도 못 받음#
[WARN] [safety_stop]: New publisher discovered on topic '/scan', offering incompatible QoS.
No messages will be received from it. Last incompatible policy: RELIABILITY- 원인: LiDAR 드라이버는 BEST_EFFORT 로 보내는데, 구독자가 기본값(RELIABLE)을 요구했습니다. QoS 가 맞지 않으면 연결 자체가 안 됩니다(시뮬레이터 1 의 신뢰성 설정). 경고 문구는 버전에 따라 조금 다를 수 있습니다.
- 해결:
ros2 topic info /scan -v로 퍼블리셔의 QoS 를 보고, 구독에qos_profile_sensor_data를 씁니다. 또front_angle을 잘못 두면 받기는 해도 뒤쪽을 보고 멈춥니다(실습 4-1).
8) 내 노드를 Ctrl+C 로 껐는데 로봇이 계속 감#
^C[INFO] [drive_forward]: ...
(로봇은 마지막 속도로 계속 이동)- 원인: 노드가 마지막 0 을 보내기 전에 rclpy 가 종료되었고, 드라이버는 마지막 명령을 유지합니다.
- 해결: 정상 종료 경로에서 0 을 여러 번 보내고(drive_forward 의
finally), 실물에서는 항상 k 또는ros2 topic pub --once /cmd_vel geometry_msgs/msg/Twist "{}"를 준비해 둡니다. 드라이버의 타임아웃 동작을 실습 (실물) 2번으로 확인합니다.
과제 / 팀 미션#
- 확인 필요 채우기: 실습 (실물) 1 · 2번으로 우리 로봇의 bringup 노드 이름, 토픽 이름 · 타입,
/scan주기,/cmd_velQoS, 드라이버 타임아웃 유무를 표로 만들어 제출하세요. 이 페이지의 "확인 필요" 를 몇 개 지웠는지 세어 봅니다. - 폐루프 2 m:
drive_forward를 고쳐/odom을 구독하고, 출발 위치에서 2.0 m 를 이동하면 멈추게 하세요. 시간 기반과 오도메트리 기반의 실제 이동 거리(줄자)를 속도 0.1 · 0.2 · 0.3 m/s 에서 비교합니다(ch06). - 안전 정지 개선: (a) 타이머로 10 Hz 마다 마지막 명령을 다시 검사해 보내기, (b) 원뿔 대신 "로봇 폭 + 여유 0.1 m 의 띠" 안의 점만 보기, (c) 정면 무효값이 많으면 정지. 실습 4-2 의 시뮬레이션에 (b) 를 넣어 ±45° 원뿔에서 작업자 때문에 갇히는 문제가 사라지는지 확인하세요.
- 교실 도메인 표: 우리 반 로봇 · 노트북 · 도메인 ID 배정표와, 새 학생이 따라 할 3줄짜리 설정 안내문을 만드세요.
참고자료#
- myAGV Plus 공식 문서 (영문): https://github.com/elephantrobotics/myagvPlus_docs/tree/main/MYAGV_PLUS_EN
- 6.2.1 ROS2 Installation (빌드 · source · 도메인 ID): https://github.com/elephantrobotics/myagvPlus_docs/blob/main/MYAGV_PLUS_EN/6-Software_Development_Guide/6.2-ApplicationBaseROS2/6.2.1-ROS2_Installation.md
- 6.2.2 Using Common ROS2 Tools (rviz2 · rqt_graph · rqt_tf_tree · launch 파일): https://github.com/elephantrobotics/myagvPlus_docs/blob/main/MYAGV_PLUS_EN/6-Software_Development_Guide/6.2-ApplicationBaseROS2/6.2.2-Using_Common_ROS2_Tools.md
- 6.2.3 Basic Control Based on ROS2 (bringup · 키보드 · 조이스틱): https://github.com/elephantrobotics/myagvPlus_docs/blob/main/MYAGV_PLUS_EN/6-Software_Development_Guide/6.2-ApplicationBaseROS2/6.2.3-Basic_Control_Based_on_ROS2.md
- myagv_plus_ros2 저장소 (
humble브랜치): https://github.com/elephantrobotics/myagv_plus_ros2 - myagv_ros2 저장소 (이전 모델 myAGV 용,
galactic-JN브랜치): https://github.com/elephantrobotics/myagv_ros2 - teleop_twist_keyboard (ROS 2): https://github.com/ros2/teleop_twist_keyboard
- ROS 2 Humble 문서 — 노드 · 토픽 · 서비스 · 파라미터 튜토리얼: https://docs.ros.org/en/humble/Tutorials/Beginner-CLI-Tools.html
- ROS 2 Humble 문서 — 간단한 퍼블리셔 · 서브스크라이버 (Python): https://docs.ros.org/en/humble/Tutorials/Beginner-Client-Libraries/Writing-A-Simple-Py-Publisher-And-Subscriber.html
- ROS 2 Humble 문서 — ROS_DOMAIN_ID: https://docs.ros.org/en/humble/Concepts/Intermediate/About-Domain-ID.html
- ROS 2 Humble 문서 — QoS 설정: https://docs.ros.org/en/humble/Concepts/Intermediate/About-Quality-of-Service-Settings.html
- ROS 2 Humble 문서 — colcon 사용법: https://docs.ros.org/en/humble/Tutorials/Beginner-Client-Libraries/Colcon-Tutorial.html
- REP-103 (단위 · 좌표 규칙): https://www.ros.org/reps/rep-0103.html
- myAGV Plus 제품 사진 · 소개 (hyenc.net): https://www.hyenc.net/products/35
- 이 사이트의 도구: URDF 뷰어 · Python Playground
- 이전 차시: ch08 경로 계획과 장애물 회피 · 다음 차시: ch10 ROS 2 SLAM 과 Nav2 자율주행