전체 과정 P1 로봇과 첫 만남 — 구조와 움직임 · 약 200분 · 중급

CH01myAGV Pro 둘러보기 — 하드웨어와 URDF

myAGV Pro 의 사양 · 구성 · 활용 사례를 살펴보고, 공식 URDF 를 3D 뷰어로 열어 링크 · 조인트 · 센서 좌표계를 확인합니다.

학습 목표#

  • AGV 와 AMR 의 차이를 설명하고, myAGV Pro 의 핵심 사양(크기 · 무게 · 적재 · 속도 · 배터리)을 숫자로 말할 수 있습니다.
  • 적재 무게와 속도를 바꾸면 정지 거리 · 주행 가능 시간이 어떻게 바뀌는지 시뮬레이터로 예측하고 확인할 수 있습니다.
  • 공식 URDF(agv_pro.urdf)에서 link · joint · origin · axis 를 읽고, 바퀴 4개(continuous)와 센서(fixed)를 구분할 수 있습니다.
  • ROS 좌표 관례(x 앞 · y 왼쪽 · z 위)로 라이다 좌표의 점을 base_link 좌표로 바꾸는 계산을 numpy 로 할 수 있습니다.
  • 실물 첫 구동 전에 비상정지(E-stop) 위치 · 상태 확인 방법을 포함한 안전 체크리스트를 작성할 수 있습니다.

이론#

1교시 · 물류로봇 AGV/AMR 과 myAGV Pro 소개#

AGV 와 AMR — 길을 따라가는가, 길을 찾는가#

AGV — 바닥의 길(테이프 · 자석 · QR)을 따라감 장애물 = 멈춤 정해진 경로 · 단순 · 경로 바꾸려면 바닥 공사 AMR — 지도 + 센서로 스스로 경로 계획 목표 라이다 스캔 장애물을 피해 돌아감 · 지도만 바꾸면 경로 변경 myAGV Pro 는 이름은 AGV 지만, 라이다 SLAM · 내비게이션으로 AMR 처럼 운용합니다 (ch06 ~ ch09 에서 직접 해 봄).
AGV 는 바닥에 깔린 길을 따라가고, AMR 은 지도와 센서로 스스로 길을 찾습니다.
구분AGV (Automated Guided Vehicle, 자동 유도 차량)AMR (Autonomous Mobile Robot, 자율 이동 로봇)
길 찾기바닥 테이프 · 자석 · QR 코드 라인 추종지도(SLAM) + 위치 추정 + 경로 계획
장애물멈추고 기다림돌아서 지나감
경로 변경바닥 공사 필요지도 · 목표점만 바꿈
필요한 것라인 센서라이다 · 카메라 · 계산용 컴퓨터

myAGV Pro 는 이름에 AGV 가 들어 있지만, 라이다와 ROS 2 내비게이션을 올리면 AMR 처럼 운용합니다. 이 강좌의 뒷부분(SLAM · 위치 추정 · 경로 계획)이 바로 "AGV 를 AMR 로 만드는 과정"입니다.

주요 사양 — 숫자부터 기억합니다#

산업 · 연구용 모바일 자율주행 물류로봇 myAGV Pro (이미지: 현영이앤씨 hyenc.net)

항목값이 숫자가 중요한 이유
크기 (L × W × H)530 × 360 × 245 mm통로 폭 · 선반 아래 통과 여부
무게40 kg혼자 들기 어렵습니다 — 옮길 때 2인
최대 적재50 kg넘으면 제동 거리 · 모터 부하 급증
최고 속도 (만재 시험)1.5 m/s (API 기준 횡이동 0 ~ 1 m/s)정지 거리는 속도의 제곱에 비례
최소 회전 반경0 m (제자리 회전)좁은 통로에서 방향 전환
최대 경사10°경사로 설계 한계
서스펜션스윙암 독립 현가바닥 요철에서 네 바퀴 접지 유지
방진 · 방수IP22실내 전용 (물 · 먼지에 약함)
배터리24 V 20 Ah 리튬인산철(LiFePO4)저장 에너지 24 × 20 = 480 Wh
주행 시간5 ~ 6 h (무부하 · 1 m/s 조건)적재 · 속도가 오르면 줄어듦
사용 온도−10 ~ 40 ℃

출처: 공식 문서 Basic Edition 사양. 최고 속도 1.5 m/s 는 사양표 값이고, 옆으로 가는 횡이동(lateral) 1 m/s 는 Python API 의 속도 범위(move_left_lateral 0 ~ 1 m/s)에서 온 값입니다.

에디션 비교 — 기본형 vs 비주얼 내비게이션형#

myAGV Pro 기본형(메카넘 휠)과 비주얼 내비게이션형(라이다 · 카메라 · 자동 충전 모듈) 비교 (이미지: hyenc.net)

항목기본형 (Basic)비주얼 내비게이션형 (Visual Navigation)
주행부메카넘 휠 섀시 · 안전 범퍼 · LED기본형과 같음
컴퓨터외부 PC 를 USB-C 로 연결내장 Jetson Orin Nano (공식 문서 4.2.3 · 6.2.1: Jetson Orin Nano Super, Ubuntu 22.04 aarch64) — ROS 2 Humble
단자DC4017 충전, XT60 24 V 5 A, XT30 12 V 5 A, USB-C 시리얼, 입력 IO 6 · 출력 IO 6기본형 + 기가비트 이더넷 · HDMI · USB 3.0 × 2
센서(옵션)2D/3D 라이다 · 깊이 카메라 · 자동 충전 모듈 옵션

센서 옵션은 다음과 같습니다.

센서모델범위
2D 라이다N10 Plus360°, 0 ~ 15 m (반사율 70 %), 6 ~ 12 Hz
3D 라이다Unitree L230 m (반사율 90 %) / 15 m (반사율 10 %)
3D 라이다Livox MID-36040 m (반사율 10 %) / 70 m (반사율 80 %)
깊이 카메라Orbbec Gemini 20.15 ~ 10 m

출처: Visual Navigation Edition 사양.

활용 사례 — 팔을 얹으면 이동형 매니퓰레이터#

물류 분류 훈련 · 가정 서비스 시뮬레이션 · 스마트 오피스 상호작용 실험 (이미지: hyenc.net)

장면조합하는 일
물류 분류 훈련장 (Logistics Sorting)myAGV Pro + myCobot 320 + 흡착 그리퍼물건을 집어 분류함으로 옮기며 데이터 수집
가정 서비스 (Home Service)myAGV Pro + myArm M750집안 환경에서 물건 정리 · 전달
스마트 오피스 (Smart Office)myAGV Pro + myCobot Pro 630 (힘 제어 그리퍼)문 열기 등 사무 공간 상호작용 실험

팔을 얹는 순간 로봇 위에 수 kg ~ 수십 kg 의 적재가 생깁니다. 그래서 다음 시뮬레이터에서 적재 무게가 무엇을 바꾸는지 먼저 봅니다.

시뮬레이터 1 · 사양 계산기#

이 계산기의 모델 (교육용 가정)
  • 정지 거리 = 반응 거리 + 제동 거리 = v · t반응 + v² / (2a), 감속도 a = F제동 / (40 kg + 적재).

최대 제동력 F제동 = 60 N 은 가정값입니다 (빈 차 감속 1.5 m/s²). 실제 값은 모터 · 바닥 · 펌웨어 설정에 따라 다릅니다.

  • 주행 시간 = 480 Wh ÷ 소비 전력, 소비 전력 P = 45 W + 1.05 · m · v (W).

공식 값 "무부하 1 m/s 에서 5 ~ 6 h" 에 맞춰 계수를 정한 근사식입니다.

먼저 예측하세요. 빈 차로 1.5 m/s 에서 정지 거리가 1.2 m 라면, 30 kg 을 실었을 때 정지 거리는 몇 m 쯤일까요? (반응 시간 0.3 s)

시뮬레이터 1 · 사양 계산기 — 적재 · 속도 · 반응 시간 → 정지 거리 · 주행 시간

해 볼 것

  1. 적재 0 kg · 1.5 m/s · 반응 0.3 s 로 놓고 정지 거리를 읽습니다. 그다음 적재만 30 kg 으로 올립니다. 예측과 비교하세요.
  2. 적재 30 kg 에서 속도를 1.5 → 0.75 m/s 로 절반으로 줄입니다. 제동 거리는 절반이 되나요, 4 분의 1 이 되나요?
  3. 반응 시간만 0.3 → 0.8 s 로 늘립니다. 주황(반응)과 빨강(제동) 중 어느 쪽이 늘어나나요?
  4. 적재 50 kg 에서 2 m 앞 사람 앞에 멈출 수 있는 최고 속도를 슬라이더로 찾아봅니다.
  5. 주행 시간 칸을 보며, 적재 0 kg · 1.0 m/s 일 때 공식 값(5 ~ 6 h)과 맞는지 확인합니다.

관찰 포인트 — 적재는 반응 거리를 바꾸지 않고 제동 거리만 늘립니다(a 가 작아지므로). 속도는 두 항을 모두 늘리고, 특히 제동 거리를 제곱으로 늘립니다. 그래서 "무겁게 싣고 최고 속도" 는 두 위험이 곱해지는 조합입니다.

확인 문제 1-1

시뮬레이터에서 반응 시간 0.3 s, 속도 1.5 m/s 로 두고 적재를 0 kg → 30 kg 으로 바꾸었더니 정지 거리가 1.20 m → 1.76 m 가 되었습니다. 늘어난 0.56 m 는 어디서 왔을까요?

  1. 반응 거리가 늘어서
  2. 제동 거리가 늘어서 (감속도가 작아짐)
  3. 반응 거리와 제동 거리가 똑같이 늘어서
  4. 배터리 전압이 떨어져서
정답 보기② — 반응 거리 v·t = 1.5 × 0.3 = 0.45 m 는 무게와 무관합니다. 질량이 40 → 70 kg 이 되면 같은 제동력으로 감속도가 1.5 → 0.86 m/s² 로 줄고, 제동 거리 v²/(2a) 가 0.75 → 1.31 m 로 늘어납니다.
확인 문제 1-2

적재 30 kg 에서 속도를 1.5 m/s → 0.75 m/s 로 절반으로 줄이면 제동 거리는 어떻게 되나요?

  1. 그대로이다
  2. 약 1/2 이 된다
  3. 약 1/4 이 된다
  4. 약 2 배가 된다
정답 보기③ — 제동 거리는 v² 에 비례하므로 (1/2)² = 1/4 이 됩니다 (1.31 m → 약 0.33 m). 반응 거리는 v 에 비례해 절반이 됩니다.

2교시 · URDF 3D 뷰어로 로봇 구조 해부하기#

URDF 의 네 단어#

URDF(Unified Robot Description Format)는 로봇의 뼈대를 XML 로 적은 파일입니다. 네 단어만 알면 읽을 수 있습니다.

태그뜻myAGV Pro 의 예
<link>단단한 몸체 하나 (모양 · 질량)base_link (19.2 kg), laser_link
<joint>두 link 의 연결. parent → childlidar_joint: base_link → laser_link
<origin xyz rpy>parent 기준으로 child 가 놓인 위치(m)와 자세(rad)xyz="0.17891 0 0.20928"
<axis xyz>회전 관절이 도는 축바퀴: 0 1 0 (y 축)

joint 의 type 이 움직임을 정합니다. continuous 는 한계 없이 계속 도는 회전(바퀴), fixed 는 움직이지 않는 고정 연결(센서 장착)입니다.

agv_pro.urdf 의 구조#

공식 저장소 elephantrobotics/agv_pro_ros2 의 agv_pro_description/urdf/agv_pro.urdf 를 그대로 옮긴 표입니다.

URDF 는 저장소에 두 벌 있습니다
파일들어 있는 것쓰는 곳
agv_pro_description/urdf/agv_pro.urdfbase · 바퀴 4 · 라이다 · 카메라 · IMU (이름에 ${namespace} 접두어)RViz 표시, 실물 bringup
agv_pro_gazebo/urdf/agv_pro.xacrobase · 바퀴 4 · 라이다 + Gazebo 마찰 · ros2_control 설정Gazebo 시뮬레이션 (ch09)

두 파일의 바퀴 · 라이다 origin 숫자는 같습니다. 이 사이트의 3D 뷰어와 시뮬레이터는 agv_pro_gazebo 의 xacro 를 펼쳐(xacro agv_pro.xacro > agv_pro.urdf) 쓰므로 camera_link · imu_link 가 없고, 이름에 ${namespace} 도 붙지 않습니다.

agv_pro.urdf 의 링크 트리 (TF 트리) — 화살표 = joint, 괄호 = origin xyz (m) base_footprint base_link base_joint · fixed · (0, 0, 0.020) left_front_wheel (0.171, 0.180, 0.052) right_front_wheel (-0.172, 0.180, 0.052) left_rear_wheel (0.171, -0.180, 0.052) right_rear_wheel (-0.172, -0.180, 0.052) laser_link fixed camera_link fixed 바퀴 4개: continuous (axis 0 1 0 = y축 둘레로 끝없이 회전) laser_link (0.179, 0, 0.209) · camera_link (0.232, 0, 0.149) · imu_link (-0.172, -0.027, 0.149, yaw 1.5707) — 모두 fixed (imu 는 칸이 좁아 생략)
base_footprint 에서 시작하는 링크 트리. 바퀴 4개는 continuous, 센서는 모두 fixed 입니다.
jointtypeparent → childorigin xyz (m)rpyaxis
base_jointfixedbase_footprint → base_link(0, 0, 0.020)0—
left_front_wheel_jointcontinuousbase_link → left_front_wheel_link(0.17128, 0.1799, 0.052)00 1 0
right_front_wheel_jointcontinuousbase_link → right_front_wheel_link(−0.17181, 0.1799, 0.051884)00 1 0
left_rear_wheel_jointcontinuousbase_link → left_rear_wheel_link(0.17128, −0.1799, 0.052)00 1 0
right_rear_wheel_jointcontinuousbase_link → right_rear_wheel_link(−0.171806, −0.1799004, 0.0518837)00 1 0
lidar_jointfixedbase_link → laser_link(0.17891, 0, 0.20928)0—
camera_jointfixedbase_link → camera_link(0.23191, 0, 0.14928)0—
imu_jointfixedbase_link → imu_link(−0.17181, −0.0270532, 0.14928)(0, 0, 1.5707)—
바퀴 이름과 좌표가 맞지 않습니다

ROS 관례(x 앞, y 왼쪽)로 읽으면 right_front_wheel_joint 는 x < 0, y > 0 → 왼쪽 뒤, left_rear_wheel_joint 는 x > 0, y < 0 → 오른쪽 앞에 있습니다. 이름만 믿고 코드를 짜면 바퀴 두 개가 뒤바뀝니다. 항상 origin 숫자로 확인하세요. (저장소 버전에 따라 고쳐졌을 수 있습니다.)

위에서 본 myAGV Pro — agv_pro.urdf 의 joint origin (base_link 기준, 단위 m) 차체 530 x 360 mm left_front_wheel (0.171, 0.180) right_front_wheel* (-0.172, 0.180) left_rear_wheel* (0.171, -0.180) right_rear_wheel (-0.172, -0.180) x (앞) y (왼쪽) base_link laser_link (0.179, 0) camera_link (0.232, 0) imu_link (-0.172, -0.027) 휠베이스 ≈ 0.343 m (앞뒤 바퀴 간격) 트레드 ≈ 0.360 m (좌우 바퀴 간격) * 이름과 위치가 다른 바퀴: 이름은 front 인데 x < 0, 이름은 rear 인데 x > 0. 이름보다 origin 을 믿습니다.
위에서 본 바퀴 · 센서 배치. 좌우 바퀴 간격(트레드)과 앞뒤 바퀴 간격(휠베이스)을 origin 에서 바로 계산할 수 있습니다.

3D 뷰어 열기#

3D 뷰어 열기

이 뷰어의 모델

공식 agv_pro_gazebo 패키지의 URDF 와 메시(STL → 면 수를 줄인 GLB)를 그대로 엽니다 (BSD 3-Clause, Elephant Robotics). 관절 슬라이더는 움직일 수 있는 joint(continuous 바퀴 4개) 에만 생깁니다. 그룹 제목의 x > 0 · x < 0 은 origin 부호입니다.

먼저 예측하세요. 슬라이더가 몇 개 생길까요? lidar_joint · base_joint 에도 슬라이더가 있을까요? 그다음 뷰어에서 확인합니다.

같은 모델로 창고 시뮬레이터 열기

시뮬레이터 2 · URDF 간이 3D 뷰#

먼저 예측하세요. 바퀴 슬라이더를 +6.28 rad 까지 돌리면 바퀴는 몇 바퀴 돌까요? lidar_joint 에는 왜 슬라이더가 없을까요?

시뮬레이터 2 · agv_pro.urdf 간이 3D 뷰 (캔버스를 끌면 회전 · 외형 상자는 근사, 좌표는 URDF 값)
   
좌표축 표시:
fixed joint (슬라이더 없음): base_joint · lidar_joint · camera_joint · imu_joint

해 볼 것

  1. left_front_wheel_joint 슬라이더를 0 → 6.28 로 끝까지 돌리고 빨간 점이 몇 바퀴 도는지 셉니다. 아래 표시줄의 "바퀴" 값과 비교합니다.
  2. 연속 회전 시작을 누르고 기다립니다. 표시값 q 가 6.28 을 넘어 계속 커지는지 확인합니다 — 이것이 continuous (한계 없음)의 뜻입니다.
  3. 캔버스를 끌어 로봇을 옆에서 봅니다. 바퀴가 도는 축이 초록(y) 축과 나란한지 확인합니다 (axis="0 1 0").
  4. 좌표축 표시에서 laser_link · camera_link · imu_link 를 켜고, 아래 표시줄에서 바닥 기준 높이를 읽습니다. imu_link 의 x 축(빨강)만 옆을 보는 이유를 rpy 값에서 찾습니다.
  5. base_footprint 와 base_link 를 함께 켜고 둘의 높이 차(0.020 m)를 확인합니다.

관찰 포인트 — continuous 조인트는 각도에 끝이 없고, fixed 조인트는 슬라이더 자체가 없습니다(움직일 값이 0 개). laser_link 는 base_link 기준 앞 0.179 m · 위 0.209 m, 바닥 기준 0.229 m 에 있습니다. 2D 라이다는 이 한 높이의 수평면만 봅니다.

시뮬레이터 3 · 라이다는 어디까지 보나 (옆에서 본 스캔 평면)#

먼저 예측하세요. 다리 높이 0.12 m 인 팔레트 다리는 라이다(바닥에서 0.229 m) 스캔에 보일까요? 바닥에서 0.30 m 높이에 떠 있는 선반 판은요?

시뮬레이터 3 · 2D 라이다 스캔 평면과 장애물 높이
예시:

해 볼 것

  1. 팔레트 다리 버튼 → 스캔에 보이나요? 결과 문구의 색을 확인합니다.
  2. 선반 판 버튼 → 보이지 않는데 왜 "지나간다" 고 나오는지 로봇 높이선(빨간 점선)과 비교합니다.
  3. 바닥 턱 · 케이블 버튼 → 어떤 위험이 생기나요?
  4. 라이다 높이를 0.229 → 0.10 m 로 낮춰 팔레트 다리를 보이게 만들어 봅니다. 그 대신 무엇을 못 보게 되나요? (선반 판 · 사람 다리로 확인)
  5. 사람 다리(0 ~ 0.90 m)는 라이다 높이를 어디에 두어도 보이는지 확인합니다.

관찰 포인트 — 2D 라이다는 장애물 아래 끝 ≤ 라이다 높이 ≤ 위 끝 일 때만 그 물체를 봅니다. 라이다 높이(0.229 m)보다 낮은 물체는 로봇 높이(0.245 m)보다 낮으니 보이지 않는데 부딪히는 사각이 됩니다. 이 문제는 ch05 라이다 차시에서 다시 다룹니다.

확인 문제 2-1

URDF 에서 lidar_joint 의 origin z 는 0.20928, base_joint 의 origin z 는 0.020 입니다. 시뮬레이터 3 에서 높이 0 ~ 0.12 m 의 팔레트 다리는 어떻게 판정되나요?

  1. 스캔에 보인다 — 라이다는 360° 를 보므로
  2. 스캔에 보이지 않지만 로봇이 아래로 지나간다
  3. 스캔에 보이지 않고, 그대로 가면 부딪힌다
  4. 라이다 높이가 0.209 m 이므로 보인다
정답 보기③ — 라이다 높이는 바닥 기준 0.020 + 0.209 = 0.229 m 입니다. 0.12 m 보다 높아 스캔 평면이 다리 위를 지나가므로 보이지 않고, 다리는 로봇 높이(0.245 m)보다 낮으므로 부딪힙니다. ④는 base_link 기준 값을 바닥 기준으로 착각한 경우입니다.
확인 문제 2-2

시뮬레이터 2 에서 바퀴 슬라이더 표시가 q = 12.57 rad 일 때, 바퀴는 0 rad 에서 몇 바퀴 돌았나요? 그리고 이렇게 큰 값이 허용되는 이유는?

  1. 2 바퀴 — continuous 조인트는 한계가 없어서
  2. 2 바퀴 — fixed 조인트라서
  3. 12 바퀴 — 슬라이더 단위가 바퀴 수라서
  4. 0 바퀴 — 6.28 을 넘으면 0 으로 고정돼서
정답 보기① — 12.57 ÷ 2π ≈ 2.0 바퀴입니다. continuous 조인트는 limit 이 없어 각도가 계속 쌓입니다. 바퀴의 누적 회전량은 ch04 오도메트리에서 이동 거리를 계산하는 재료가 됩니다.

3교시 · 좌표계와 TF 트리#

ROS 좌표 관례 — 오른손 법칙#

  • x 앞, y 왼쪽, z 위 (오른손 좌표계, ROS REP-103 관례). 위에서 내려다보면 x 를 오른쪽으로 그릴 때 y 는 위쪽입니다.
  • 회전은 축을 엄지로 잡았을 때 네 손가락이 감기는 방향이 + 입니다. 위에서 본 z 축 회전(yaw)은 반시계 방향이 + 입니다.
  • 길이는 m, 각도는 rad 입니다.

고정 변환 — 센서가 본 점을 차체 기준으로 옮기기#

라이다는 자기 자신(laser_link)을 원점으로 거리를 잽니다. 그런데 로봇이 "장애물이 내 앞 몇 m 에 있나" 를 판단하려면 그 점을 **base_link 기준**으로 바꿔야 합니다. lidar_joint 는 회전이 없는(rpy = 0) 고정 변환이므로, 2D 에서는 오프셋을 더하기만 하면 됩니다.

좌표계원점바닥 기준 높이
base_footprint차체 중심의 바닥 투영0
base_link차체 기준점0.020 m
laser_link라이다 중심 (base_link 앞 0.179 m)0.229 m
camera_link깊이 카메라 (base_link 앞 0.232 m)0.169 m

라이다 좌표의 점 (1.0, 0.5) 는 base_link 좌표로 (1.0 + 0.17891, 0.5 + 0) = (1.179, 0.5) 입니다. 회전이 있으면 p_base = R · p_laser + t 로 계산합니다. 2D 에서는 3 × 3 동차 변환 행렬 하나로 묶습니다.

python시뮬 실행 가능
import numpy as np

def T2(x, y, yaw):
    """2D 동차 변환 행렬 (parent 기준 child 의 위치 x, y 와 회전 yaw)"""
    c, s = np.cos(yaw), np.sin(yaw)
    return np.array([[c, -s, x],
                     [s,  c, y],
                     [0,  0, 1.0]])

T_base_laser = T2(0.17891, 0.0, 0.0)      # lidar_joint (URDF)
p_laser = np.array([1.0, 0.5, 1.0])       # 라이다가 본 점 (동차 좌표)
p_base = T_base_laser @ p_laser
print("base_link 기준:", np.round(p_base[:2], 3))

# 로봇이 지도 위 (2.0, 1.0) 에서 90 도 왼쪽을 보고 있다면?
T_map_base = T2(2.0, 1.0, np.deg2rad(90))
p_map = T_map_base @ p_base
print("map 기준:", np.round(p_map[:2], 3))

실행 결과는 base_link 기준: [1.179 0.5], map 기준: [1.5 2.179] 입니다. 행렬을 곱하는 순서(T_map_base @ T_base_laser)가 TF 트리의 부모 → 자식 순서와 같습니다.

시뮬레이터 4 · 센서 오프셋을 틀리게 넣으면#

먼저 예측하세요. 라이다 오프셋을 0 으로 잘못 넣으면(라이다가 차체 중심에 있다고 착각), 지도 위에 그린 벽은 실제보다 앞으로 보일까요, 뒤로 보일까요?

시뮬레이터 4 · laser_link 오프셋과 지도 위 스캔 점 (위에서 본 지도, 5.2 × 2.8 m)
   

해 볼 것

  1. 오프셋을 URDF 값(0.179)으로 두고 주황 점이 회색 벽 · 상자 테두리 위에 정확히 놓이는지 봅니다.
  2. 오프셋 0 으로 를 누르고 실제 반사 위치(초록) 를 켭니다. 주황 점이 초록 점에서 어느 쪽으로, 얼마나 밀렸나요?
  3. 오프셋 0 인 채로 로봇 방향 θ 를 0° → 90° → 180° 로 돌립니다. 지도 위에서 밀리는 방향이 어떻게 바뀌나요?
  4. 오프셋을 0.40 m 로 크게 넣어 봅니다. 이번에는 점이 어느 쪽으로 밀리나요?
  5. 라이다 점 (1.0, 0.5) 표시 를 켜고, 아래 표시줄의 base_link 좌표가 위 Playground 결과(1.179, 0.5)와 같은지 확인합니다 (θ = 0°, 오프셋 0.179).

관찰 포인트 — 오프셋이 틀리면 스캔 전체가 로봇 기준으로 같은 거리만큼 밀리고, 로봇이 돌면 밀리는 방향도 함께 돕니다. 그래서 로봇이 제자리에서 돌 때 지도 위 벽이 "두 겹" 으로 번져 보입니다 — SLAM(ch06)에서 지도가 흐려지는 흔한 원인입니다.

확인 문제 3-1

시뮬레이터 4 에서 θ = 0°(로봇이 +x 방향을 봄), 오프셋을 0 으로 넣었습니다. 로봇 정면 2.0 m 앞 벽(실제 라이다 기준 1.821 m)은 지도 위에서 어디에 그려지나요?

  1. 로봇 앞 2.0 m — 오프셋은 결과에 영향이 없다
  2. 로봇 앞 1.821 m — 0.179 m 가까이 그려진다
  3. 로봇 앞 2.179 m — 0.179 m 멀리 그려진다
  4. 로봇 옆 1.821 m — 방향이 90° 돈다
정답 보기② — 코드는 라이다가 base_link 원점에 있다고 생각하므로 측정값 1.821 m 를 base_link 에서부터 잽니다. 그래서 벽이 실제보다 0.179 m 가깝게(로봇 뒤쪽으로 밀려) 그려집니다. 정지 판단이 일찍 일어나는 쪽이라 위험해 보이지 않지만, 뒤쪽 라이다 · 회전 중 지도 작성에서는 반대로 위험해집니다.

4교시 · 안전 수칙과 전원 · 비상정지#

사용자 주의사항 (공식 문서 요약)#

항목규칙
사용 환경실내 전용 (IP22), −10 ~ 40 ℃, 평평한 바닥
경사10° 이하
적재50 kg 이하, 무게 중심은 차체 중앙 · 낮게
공간주행 경로에 사람 · 장애물 없게, 첫 구동은 넓은 곳에서 저속으로
보조자1 명은 항상 비상정지 버튼 근처에
범퍼앞 · 뒤 아래쪽 충돌 방지 범퍼 — 균열 · 이탈 점검. 범퍼는 안전거리를 대신하지 않습니다

출처: Safety Instruction

배터리 · 충전 · 전원 투입 순서#

  • 배터리: 24 V 20 Ah 리튬인산철(LiFePO4), 약 480 Wh.
  • 충전: DC4017 원형 단자(지름 4.0 mm, 길이 17 mm, 중앙 +), 정품 어댑터(25.55 V 2.8 A)만 사용. 충전 중 표시등 빨강 → 완충 초록.

충전 시간은 사양표에 5 ~ 6 시간, 관리 문서에 6 ~ 7 시간으로 적혀 있어 문서마다 다릅니다 — 넉넉히 잡습니다.

  • 충전 중에는 사람이 자리를 지키고, 가연물에서 떨어진 곳에서 0 ~ 40 ℃ 에서 충전합니다. 7 일 이상 쓰지 않으면 50 ~ 70 % 로 보관합니다.
  • 배터리 표시등: 빨강 깜빡임 ≤ 10 %, 노랑 깜빡임 10 ~ 20 %, 초록 > 20 %.

전원 투입 순서(4.1 Basic Edition):

  1. 로봇을 평평한 바닥에 둡니다 (바퀴 앞뒤 공간 확보).
  2. 비상정지 버튼을 해제(시계 방향으로 돌림)하고 전원 버튼을 누릅니다.
  3. PC 와 USB-C 케이블로 연결합니다 (CH340 드라이버 필요).
  4. 코드에서 is_power_on() 이 1 이 아니면 power_on() 을 호출합니다.

비상정지(E-stop)와 상태 확인#

비상정지 버튼은 차체 뒤쪽의 빨간 원형 버튼입니다. 누르면 구동이 끊기고, 다시 쓰려면 주변을 확인한 뒤 시계 방향으로 돌려 해제 → 재시작 → 저속 시험 순서로 복귀합니다. 버튼을 가리거나, 선을 빼거나, 소프트웨어로 무력화하면 안 되며, 최소 한 달에 한 번 동작을 시험합니다.

Python SDK(pymycobot 의 MyAGVPro)에서는 get_estop_state() 로 버튼 상태를 읽습니다. 반환값은 0 = 해제, 1 = 눌림 입니다.

text
움직이기 전
  get_estop_state() == 1 ?  ──예──> "비상정지 해제 필요" 안내 후 종료 (모터 명령 보내지 않음)
          │ 아니오
          v
  is_power_on() == 1 ?      ──아니오──> power_on()
          │ 예
          v
  저속 시험 → 작업

로봇을 실제로 움직이는 명령(move_forward 등)은 ch03 에서 다룹니다. 이번 차시는 움직이기 전 확인까지만 합니다.

시뮬레이터 5 · 사람 앞 안전거리#

먼저 예측하세요. 적재 20 kg, 1.2 m/s 로 달리다 1.8 m 앞에 사람이 나타났습니다. 보조자가 0.8 s 만에 E-stop 을 누르면 멈출 수 있을까요? (예측선은 처음에 숨겨 두었습니다.)

시뮬레이터 5 · E-stop 반응과 정지 거리 애니메이션
 

해 볼 것

  1. 예측선을 끈 채로 출발 을 누릅니다. 결과가 예측과 맞았나요? 그다음 예측선을 켜고 다시 확인합니다.
  2. 반응 시간만 0.8 → 0.3 s 로 줄여 다시 출발합니다. 보조자가 버튼 바로 옆에 있어야 하는 이유를 숫자로 말해 봅니다.
  3. 적재 50 kg · 반응 0.8 s · 거리 2.5 m 에서 맨 아래 "최고 속도" 를 읽습니다. 실물 첫 구동 속도를 몇으로 정하겠습니까?
  4. 거리를 1.0 m 로 줄이고 최고 속도를 읽습니다. 좁은 통로에서 운용 속도를 낮춰야 하는 근거가 됩니다.
  5. t 가 반응 시간에 도달하는 순간 get_estop_state() 표시가 0 → 1 로 바뀌는지, 그 뒤에도 로봇이 조금 더 가는지 관찰합니다.

관찰 포인트 — E-stop 은 누른 순간부터 제동을 시작할 뿐, 로봇을 즉시 세우지 않습니다. 사람이 반응하는 동안 로봇은 원래 속도로 계속 갑니다. 안전 속도는 v · t반응 + v² / (2a) ≤ 거리 − 여유 를 만족하는 가장 큰 v 입니다.

확인 문제 4-1

시뮬레이터 5 에서 속도 1.2 m/s, 적재 20 kg, 사람까지 1.8 m 일 때, 반응 시간 0.8 s 에서는 "겨우 멈춤" 이었다가 0.3 s 로 줄이자 "안전 정지" 가 되었습니다. 가장 알맞은 해석은?

  1. 반응 시간이 줄면 감속도 a 가 커져서
  2. 반응 시간 동안 1.2 m/s 로 가던 거리 0.6 m 가 줄어서
  3. 적재가 가벼워져서
  4. E-stop 이 빨리 눌리면 제동 거리가 0 이 되어서
정답 보기② — 반응 거리 v·t 가 1.2 × 0.8 = 0.96 m → 1.2 × 0.3 = 0.36 m 로 0.6 m 줄었습니다. 감속도 a = 60 / 60 = 1.0 m/s² 와 제동 거리 0.72 m 는 그대로입니다. 정지 거리 1.68 m → 1.08 m 가 되어 여유가 0.12 m → 0.72 m 로 늘었습니다.

실습 (시뮬레이터)#

교시마다 Playground 에서 시뮬레이터의 숫자를 직접 계산해 검증합니다. starter 의 TODO 를 채워 실행한 뒤, 풀이 와 비교하세요.

실습 1-1 · 정지 거리 함수 만들기 (1교시)

시뮬레이터 1 과 같은 모델로 정지 거리를 계산하는 함수를 완성하고, 적재 0 · 30 · 50 kg 에서 1.5 m/s 로 달릴 때의 정지 거리를 출력합니다. 결과로 "적재 30 kg 에서 1.5 m/s 가 위험한 이유" 를 한 문장으로 적어 보세요 (사람까지 2 m 기준).

python시뮬 실행 가능
M_ROBOT = 40.0   # kg (사양)
F_BRAKE = 60.0   # N  (교육용 가정값)

def stop_distance(v, load, t_react=0.3):
    m = M_ROBOT + load
    a = F_BRAKE / m
    reaction = 0.0   # TODO: 반응 시간 동안 간 거리
    braking = 0.0    # TODO: 제동 거리 v^2 / (2a)
    return reaction + braking

for load in [0, 30, 50]:
    d = stop_distance(1.5, load)
    print(f"load {load:2d} kg  stop {d:.2f} m  ->", "DANGER" if d > 2.0 else "ok")
풀이
python시뮬 실행 가능
M_ROBOT = 40.0
F_BRAKE = 60.0

def stop_distance(v, load, t_react=0.3):
    m = M_ROBOT + load
    a = F_BRAKE / m
    reaction = v * t_react
    braking = v * v / (2 * a)
    return reaction + braking

for load in [0, 30, 50]:
    d = stop_distance(1.5, load)
    print(f"load {load:2d} kg  stop {d:.2f} m  ->", "DANGER" if d > 2.0 else "ok")
# load  0 kg  stop 1.20 m  -> ok
# load 30 kg  stop 1.76 m  -> ok  (여유 0.24 m 뿐)
# load 50 kg  stop 2.14 m  -> DANGER

30 kg · 1.5 m/s 에서는 제동 거리가 빈 차의 1.75 배(0.75 → 1.31 m)가 되어, 2 m 앞 사람과의 여유가 0.24 m 밖에 남지 않습니다. 반응이 조금만 늦어도(0.5 s → 2.06 m) 부딪힙니다.

실습 1-2 · 주행 가능 시간 표 만들기 (1교시)

480 Wh 배터리와 근사식 P = 45 + 1.05 · m · v (W)로 적재 · 속도 조합별 주행 시간을 표로 만듭니다. 공식 값(무부하 1 m/s 에서 5 ~ 6 h)과 맞는 칸을 찾으세요.

python시뮬 실행 가능
E_WH = 24 * 20          # 배터리 에너지 (Wh)

def runtime_h(load, v):
    m = 40 + load
    p = 0.0             # TODO: 소비 전력 근사식
    return E_WH / p if p > 0 else float("nan")

print("load\\v   0.5    1.0    1.5")
for load in [0, 25, 50]:
    row = [runtime_h(load, v) for v in (0.5, 1.0, 1.5)]
    print(f"{load:3d} kg " + " ".join(f"{h:5.1f}h" for h in row))
풀이
python시뮬 실행 가능
E_WH = 24 * 20

def runtime_h(load, v):
    m = 40 + load
    p = 45 + 1.05 * m * v
    return E_WH / p

print("load\\v   0.5    1.0    1.5")
for load in [0, 25, 50]:
    row = [runtime_h(load, v) for v in (0.5, 1.0, 1.5)]
    print(f"{load:3d} kg " + " ".join(f"{h:5.1f}h" for h in row))
# 0 kg, 1.0 m/s -> 5.5 h  (공식 5 ~ 6 h 와 일치하도록 맞춘 식)
실습 2-1 · URDF 에서 트레드 · 휠베이스 계산 (2교시)

공식 URDF 의 바퀴 joint 부분을 xml.etree 로 읽어 각 바퀴의 origin 을 표로 출력하고, 트레드(좌우 간격)와 휠베이스(앞뒤 간격)를 계산합니다. 공식 파일은 xacro 변수 ${namespace} 가 이름 앞에 붙어 있어, 그대로 읽으면 이름이 ${namespace}left_front_wheel_joint 가 됩니다. 이것도 처리하세요.

python시뮬 실행 가능
import xml.etree.ElementTree as ET

URDF = """<robot name="AGV pro">
  <joint name="${namespace}right_rear_wheel_joint" type="continuous">
    <origin xyz="-0.171806101587598 -0.179900399999999 0.0518836514526621" rpy="0 0 0"/></joint>
  <joint name="${namespace}right_front_wheel_joint" type="continuous">
    <origin xyz="-0.17181 0.1799 0.051884" rpy="0 0 0"/></joint>
  <joint name="${namespace}left_front_wheel_joint" type="continuous">
    <origin xyz="0.17128 0.1799 0.052" rpy="0 0 0"/></joint>
  <joint name="${namespace}left_rear_wheel_joint" type="continuous">
    <origin xyz="0.17128 -0.1799 0.052" rpy="0 0 0"/></joint>
  <joint name="${namespace}lidar_joint" type="fixed">
    <origin xyz="0.17891 0 0.20928" rpy="0 0 0"/></joint>
</robot>"""

root = ET.fromstring(URDF)
wheels = {}
for j in root.findall("joint"):
    if j.get("type") != "continuous":
        continue
    name = j.get("name")              # TODO: "${namespace}" 를 지운 이름으로
    x, y, z = map(float, j.find("origin").get("xyz").split())
    wheels[name] = (x, y, z)

for name, (x, y, z) in wheels.items():
    side = "left " if y > 0 else "right"
    end = "front" if x > 0 else "rear "
    print(f"{name:26s} x={x:+.3f} y={y:+.3f}  실제 위치: {side} {end}")

xs = [p[0] for p in wheels.values()]
ys = [p[1] for p in wheels.values()]
tread = 0.0       # TODO: 좌우 바퀴 y 간격
wheelbase = 0.0   # TODO: 앞뒤 바퀴 x 간격
print(f"tread {tread:.3f} m, wheelbase {wheelbase:.3f} m")
풀이
python시뮬 실행 가능
import xml.etree.ElementTree as ET

URDF = """<robot name="AGV pro">
  <joint name="${namespace}right_rear_wheel_joint" type="continuous">
    <origin xyz="-0.171806101587598 -0.179900399999999 0.0518836514526621" rpy="0 0 0"/></joint>
  <joint name="${namespace}right_front_wheel_joint" type="continuous">
    <origin xyz="-0.17181 0.1799 0.051884" rpy="0 0 0"/></joint>
  <joint name="${namespace}left_front_wheel_joint" type="continuous">
    <origin xyz="0.17128 0.1799 0.052" rpy="0 0 0"/></joint>
  <joint name="${namespace}left_rear_wheel_joint" type="continuous">
    <origin xyz="0.17128 -0.1799 0.052" rpy="0 0 0"/></joint>
  <joint name="${namespace}lidar_joint" type="fixed">
    <origin xyz="0.17891 0 0.20928" rpy="0 0 0"/></joint>
</robot>"""

root = ET.fromstring(URDF)
wheels = {}
for j in root.findall("joint"):
    if j.get("type") != "continuous":
        continue
    name = j.get("name").replace("${namespace}", "")
    x, y, z = map(float, j.find("origin").get("xyz").split())
    wheels[name] = (x, y, z)

for name, (x, y, z) in wheels.items():
    side = "left " if y > 0 else "right"
    end = "front" if x > 0 else "rear "
    print(f"{name:26s} x={x:+.3f} y={y:+.3f}  실제 위치: {side} {end}")

xs = [p[0] for p in wheels.values()]
ys = [p[1] for p in wheels.values()]
tread = max(ys) - min(ys)
wheelbase = max(xs) - min(xs)
print(f"tread {tread:.3f} m, wheelbase {wheelbase:.3f} m")
# tread 0.360 m, wheelbase 0.343 m
# right_front / left_rear 는 이름과 실제 위치가 다릅니다.
실습 2-2 · 라이다에 보이는 장애물 판정 (2교시)

URDF 의 base_joint 와 lidar_joint 높이로 라이다 높이를 계산하고, 장애물 목록 각각이 스캔에 보이는지 · 부딪히는지 판정합니다. 시뮬레이터 3 의 결과와 같은지 확인하세요.

python시뮬 실행 가능
BASE_Z = 0.020      # base_joint origin z
LIDAR_Z = 0.20928   # lidar_joint origin z
ROBOT_TOP = 0.245   # 사양 높이

obstacles = {"pallet leg": (0.0, 0.12), "box": (0.0, 0.40),
             "shelf board": (0.30, 0.33), "cable": (0.0, 0.03)}

h = 0.0   # TODO: 바닥 기준 라이다 높이
for name, (z0, z1) in obstacles.items():
    visible = False   # TODO: z0 <= h <= z1
    hit = z0 < ROBOT_TOP
    print(f"{name:12s} visible={visible!s:5s} hit={hit!s:5s}",
          "<- BLIND SPOT" if hit and not visible else "")
풀이
python시뮬 실행 가능
BASE_Z = 0.020
LIDAR_Z = 0.20928
ROBOT_TOP = 0.245

obstacles = {"pallet leg": (0.0, 0.12), "box": (0.0, 0.40),
             "shelf board": (0.30, 0.33), "cable": (0.0, 0.03)}

h = BASE_Z + LIDAR_Z
print(f"lidar height = {h:.3f} m")
for name, (z0, z1) in obstacles.items():
    visible = z0 <= h <= z1
    hit = z0 < ROBOT_TOP
    print(f"{name:12s} visible={visible!s:5s} hit={hit!s:5s}",
          "<- BLIND SPOT" if hit and not visible else "")
# pallet leg 와 cable 이 BLIND SPOT, shelf board 는 안 보이지만 아래로 통과
실습 3-1 · laser_link → base_link → map 변환 (3교시)

라이다 좌표의 점 (1.0, 0.5) 를 base_link 로, 다시 지도(map)로 바꿉니다. 로봇은 지도 위 (1.6, 1.2) 에서 θ = 30° 를 보고 있습니다. 시뮬레이터 4 에서 같은 자세(x 1.6, y 1.2, θ 30°)로 놓고 "라이다 점 (1.0, 0.5) 표시" 의 map 좌표와 비교하세요.

python시뮬 실행 가능
import numpy as np

def T2(x, y, yaw):
    c, s = np.cos(yaw), np.sin(yaw)
    return np.array([[c, -s, x], [s, c, y], [0, 0, 1.0]])

T_base_laser = T2(0.17891, 0.0, 0.0)
T_map_base = None   # TODO: 로봇 자세 (1.6, 1.2, 30도) - 라디안 변환 주의

p_laser = np.array([1.0, 0.5, 1.0])
p_base = T_base_laser @ p_laser
p_map = None        # TODO: T_map_base 를 곱함
print("base:", np.round(p_base[:2], 3))
print("map :", p_map)
풀이
python시뮬 실행 가능
import numpy as np

def T2(x, y, yaw):
    c, s = np.cos(yaw), np.sin(yaw)
    return np.array([[c, -s, x], [s, c, y], [0, 0, 1.0]])

T_base_laser = T2(0.17891, 0.0, 0.0)
T_map_base = T2(1.6, 1.2, np.deg2rad(30))

p_laser = np.array([1.0, 0.5, 1.0])
p_base = T_base_laser @ p_laser
p_map = T_map_base @ p_base
print("base:", np.round(p_base[:2], 3))   # [1.179 0.5  ]
print("map :", np.round(p_map[:2], 3))    # [2.371 2.222]
# 한 번에: (T_map_base @ T_base_laser) @ p_laser 와 같음
print("chain:", np.round((T_map_base @ T_base_laser @ p_laser)[:2], 3))
실습 3-2 · 오프셋 0 의 오차 재현 (3교시)

라이다 오프셋을 0 으로 잘못 넣었을 때, 로봇 정면 벽 위의 점들이 실제 위치에서 얼마나 밀리는지 계산합니다. 로봇 방향 θ 를 0°, 90° 로 바꿔 밀리는 방향도 확인하세요.

python시뮬 실행 가능
import numpy as np

def T2(x, y, yaw):
    c, s = np.cos(yaw), np.sin(yaw)
    return np.array([[c, -s, x], [s, c, y], [0, 0, 1.0]])

scan = np.array([[1.821, -0.3, 1], [1.821, 0.0, 1], [1.821, 0.3, 1]]).T  # 라이다 좌표 점 3개

for deg in (0, 90):
    T_map_base = T2(1.0, 1.0, np.deg2rad(deg))
    true_pts = T_map_base @ T2(0.17891, 0, 0) @ scan
    wrong_pts = None   # TODO: 오프셋 0 으로 계산 (T2(0, 0, 0))
    # TODO: 두 결과의 차이(밀린 벡터)와 그 길이를 출력
풀이
python시뮬 실행 가능
import numpy as np

def T2(x, y, yaw):
    c, s = np.cos(yaw), np.sin(yaw)
    return np.array([[c, -s, x], [s, c, y], [0, 0, 1.0]])

scan = np.array([[1.821, -0.3, 1], [1.821, 0.0, 1], [1.821, 0.3, 1]]).T

for deg in (0, 90):
    T_map_base = T2(1.0, 1.0, np.deg2rad(deg))
    true_pts = T_map_base @ T2(0.17891, 0, 0) @ scan
    wrong_pts = T_map_base @ T2(0, 0, 0) @ scan
    shift = (wrong_pts - true_pts)[:2]
    print(f"theta {deg:3d} deg  shift per point:", np.round(shift[:, 0], 3),
          " length:", np.round(np.linalg.norm(shift[:, 0]), 3), "m")
# theta   0 -> shift [-0.179  0.   ]  (지도 -x 방향 = 로봇 뒤쪽)
# theta  90 -> shift [ 0.    -0.179]  (로봇이 돌면 밀리는 방향도 돈다)
실습 4-1 · 안전 최고 속도 구하기 (4교시)

v · t + v² / (2a) = D − 여유 를 v 에 대해 풀면 v = a · (−t + √(t² + 2(D − 여유)/a)) 입니다. 사람까지 거리 D 별로 안전 최고 속도를 계산해, 실물 첫 구동의 속도 제한을 정합니다. 시뮬레이터 5 의 "최고 속도" 와 비교하세요.

python시뮬 실행 가능
import math

def safe_vmax(D, t_react=0.8, load=20, margin=0.3, f_brake=60.0):
    a = f_brake / (40 + load)
    avail = D - margin
    if avail <= 0:
        return 0.0
    return 0.0   # TODO: 근의 공식 (사양 최고 속도 1.5 m/s 를 넘지 않게)

for D in (1.0, 2.0, 2.5, 4.0):
    print(f"D = {D:.1f} m  ->  v_max = {safe_vmax(D):.2f} m/s")
풀이
python시뮬 실행 가능
import math

def safe_vmax(D, t_react=0.8, load=20, margin=0.3, f_brake=60.0):
    a = f_brake / (40 + load)
    avail = D - margin
    if avail <= 0:
        return 0.0
    v = a * (-t_react + math.sqrt(t_react ** 2 + 2 * avail / a))
    return min(v, 1.5)   # 사양 최고 속도

for D in (1.0, 2.0, 2.5, 4.0):
    print(f"D = {D:.1f} m  ->  v_max = {safe_vmax(D):.2f} m/s")
# D = 1.0 -> 0.63, 2.0 -> 1.21, 2.5 -> 1.44, 4.0 -> 1.50 (사양 상한)
# 계산상 최고 속도일 뿐, 첫 구동은 훨씬 낮게(예: 0.2 ~ 0.3 m/s) 시작합니다.
실습 4-2 · 첫 구동 안전 체크리스트 (4교시)

실물 첫 구동 전 확인 항목을 코드로 정리하고, 하나라도 False 면 "구동 금지" 를 출력하게 만듭니다. 항목을 스스로 더 추가해 보세요 (공간 · 보조자 · E-stop 위치 · 속도 제한 · 적재 · 배터리).

python시뮬 실행 가능
checklist = {
    "주행 공간 3 m x 3 m 확보, 사람 없음": True,
    "보조자 1명이 E-stop(뒤쪽 빨간 버튼) 옆에 대기": True,
    "E-stop 눌림/해제 동작 시험 완료": False,
    "첫 구동 속도 제한 0.3 m/s 이하로 설정": True,
    # TODO: 적재 50 kg 이하, 배터리 표시등 초록, 경사 10도 이하 바닥 ... 추가
}

# TODO: False 인 항목을 모아 출력하고, 모두 True 일 때만 "OK to start" 출력
풀이
python시뮬 실행 가능
checklist = {
    "주행 공간 3 m x 3 m 확보, 사람 없음": True,
    "보조자 1명이 E-stop(뒤쪽 빨간 버튼) 옆에 대기": True,
    "E-stop 눌림/해제 동작 시험 완료": False,
    "첫 구동 속도 제한 0.3 m/s 이하로 설정": True,
    "적재 50 kg 이하, 무게중심 중앙": True,
    "배터리 표시등 초록 (> 20%)": True,
    "평평한 실내 바닥 (경사 10도 이하, 물기 없음)": True,
    "앞뒤 충돌 방지 범퍼 균열/이탈 없음": True,
}

missing = [k for k, ok in checklist.items() if not ok]
if missing:
    print("STOP - 구동 금지. 미확인 항목:")
    for k in missing:
        print("  -", k)
else:
    print("OK to start (저속부터)")

실습 (실물)#

실물 실습 전 반드시 확인

PC 에 pymycobot 을 설치하고(pip install pymycobot --upgrade), USB-C 로 연결한 뒤 비상정지 상태와 전원 상태만 읽습니다. 포트 이름은 OS 와 연결 방식에 따라 다릅니다 (Linux 예: /dev/ttyACM0 또는 CH340 드라이버를 쓰면 /dev/ttyCH341USB0(공식 문서 4.1), Windows 예: COM5 — 장치 관리자에서 확인).

python실물 전용
from pymycobot import MyAGVPro

agv = MyAGVPro("/dev/ttyACM0", baudrate=1000000, debug=False)   # 포트는 환경에 맞게

estop = agv.get_estop_state()      # 0: 해제, 1: 눌림
print("E-stop:", "PRESSED" if estop == 1 else "released")

if estop == 1:
    print("주변 확인 후 버튼을 시계 방향으로 돌려 해제하세요. 모터 명령은 보내지 않습니다.")
else:
    if agv.is_power_on() != 1:
        agv.power_on()
    print("power on:", agv.is_power_on())
    print("firmware:", agv.get_system_version())
  1. 버튼을 누른 상태와 해제한 상태에서 각각 실행해 get_estop_state() 값이 1 / 0 으로 바뀌는지 확인합니다.
  2. 결과를 실습 4-2 체크리스트의 "E-stop 동작 시험 완료" 항목에 반영합니다.

실물 실습 (비주얼 내비게이션형) · AGVPRO_UI 빠른 체험 — 공식 문서 4.2.3 · 4.2.4 요약

비주얼 내비게이션형은 내장 컴퓨터에 그래픽 도구(AGVPRO_UI)가 들어 있어, 코드 없이 상태 확인 · 조작 · 지도 저장을 해 볼 수 있습니다.

항목공식 문서 내용
원격 접속로봇 핫스팟 ElephantRobotics_AGVPro_AP_XXXX (비밀번호 Elephant) 에 접속 → VNC 10.42.0.1:5900
배터리화면에 1 초마다 배터리 정보 기록
조작키보드 · 조이스틱으로 이동 (이번 차시에서는 이동 버튼을 누르지 않습니다)
지도 저장Save Map → ~/agv_pro_ros2/src/agv_pro_navigation2/map/ 에 저장 (ch06 에서 사용)

자주 나는 오류와 해결#

1) 3D 뷰어를 열었는데 "모델 없음" 이 표시됨#

  • 원인: 뷰어가 assets/robot/robot.json 이나 그 안의 URDF(agv_pro/agv_pro.urdf)를 읽지 못했습니다. 페이지를 file:// 로 직접 열었거나, 사이트를 복사할 때 assets/robot/ 폴더가 빠진 경우가 대부분입니다.
  • 해결: python build.py --serve 로 띄운 주소(http://localhost:8000)에서 엽니다. 그래도 안 되면 F12 콘솔에서 404 가 난 파일 경로를 확인합니다. 그동안은 시뮬레이터 2(URDF 간이 3D 뷰)와 실습 2-1 로 같은 내용을 확인할 수 있습니다.

2) URDF 를 직접 띄웠더니 메시를 못 찾음#

text
Could not load resource [package://agv_pro_description/meshes/base_link.stl]
  • 원인: package:// 경로는 ROS 패키지가 설치 · 소스된 환경에서만 풀립니다. 웹 뷰어나 다른 PC 에서는 경로를 찾지 못합니다.
  • 해결: ROS 2 환경에서는 워크스페이스를 빌드하고 source install/setup.bash 후 실행합니다. 웹 뷰어용으로는 메시 경로를 URDF 파일 기준 상대 경로(meshes/base_link.stl)로 바꿉니다.

3) 링크 이름으로 찾았는데 KeyError#

text
KeyError: 'left_front_wheel_joint'
  • 원인: 공식 agv_pro.urdf 의 이름에는 xacro 변수 ${namespace} 가 붙어 있습니다. xacro 처리 없이 XML 로 읽으면 이름이 ${namespace}left_front_wheel_joint 그대로 남습니다.
  • 해결: xacro agv_pro.urdf > agv_pro_expanded.urdf 로 먼저 펼치거나, 실습 2-1 처럼 .replace("${namespace}", "") 로 지웁니다.

4) 바퀴 두 개가 뒤바뀐 것처럼 동작#

  • 원인: URDF 의 right_front_wheel_joint 는 실제로 왼쪽 뒤(x < 0, y > 0), left_rear_wheel_joint 는 오른쪽 앞(x > 0, y < 0)에 있습니다. 이름만 믿고 매핑했습니다.
  • 해결: 바퀴 매핑은 origin 좌표의 부호(x 앞뒤, y 좌우)로 정합니다. 실습 2-1 의 "실제 위치" 열을 기준표로 씁니다.

5) 좌표 변환 결과가 엉뚱한 방향#

text
map : [2.276 0.112]   (예상: [2.371 2.222])
  • 원인: T2(1.6, 1.2, 30) 처럼 도(°)를 라디안 자리에 넣었거나(위 출력이 이 경우), 행렬 곱 순서를 T_base_laser @ T_map_base 로 뒤집었습니다.
  • 해결: 각도는 np.deg2rad() 로 바꾸고, 곱셈은 TF 트리의 부모 → 자식 순서(T_map_base @ T_base_laser @ p)로 씁니다.

6) 실물에서 명령을 보내도 바퀴가 돌지 않음#

text
E-stop: PRESSED
  • 원인: 비상정지 버튼이 눌린 상태(get_estop_state() == 1)이거나 전원이 켜지지 않았습니다(is_power_on() != 1).
  • 해결: 주변을 확인하고 버튼을 시계 방향으로 돌려 해제 → power_on() → 저속 시험. 소프트웨어로 E-stop 을 우회하지 않습니다.

과제#

  1. 사양표 카드 맞추기: 크기 · 무게 · 적재 · 속도 · 경사 · IP 등급 · 배터리 · 주행 시간을 카드 8장으로 만들고, 각 카드 뒷면에 "이 숫자가 운용에 주는 제약" 을 한 줄씩 적습니다. 그중 "적재 30 kg · 1.5 m/s" 가 위험한 이유를 시뮬레이터 1 의 정지 거리 결과로 설명합니다.
  2. 바퀴 좌표표: 실습 2-1 결과로 네 바퀴의 origin · 실제 위치 · 트레드 · 휠베이스를 표로 정리합니다.
  3. 오프셋 실험 보고: 시뮬레이터 4 에서 오프셋 0 일 때 θ = 0°, 90°, 180° 의 화면을 캡처하고, 밀린 방향과 거리(0.179 m)를 화살표로 표시합니다.
  4. 첫 구동 안전 계획서: 실습 4-1 · 4-2 결과로 주행 공간 · 보조자 위치 · E-stop 위치 · 속도 제한 값을 한 쪽으로 정리합니다.

참고자료#

  • myAGV Pro 공식 문서: https://docs.elephantrobotics.com/docs/myAGV_Pro_en/
    • Basic Edition 사양: https://docs.elephantrobotics.com/docs/myAGV_Pro_en/2-ProductFeature/2.1-BasicEdition.html
    • Visual Navigation Edition 사양: https://docs.elephantrobotics.com/docs/myAGV_Pro_en/2-ProductFeature/2.2-VisualNavigationEdition.html
    • 안전 수칙: https://docs.elephantrobotics.com/docs/myAGV_Pro_en/3-UserNotes/3.1-SafetyInstruction.html
    • 충전 · 관리: https://docs.elephantrobotics.com/docs/myAGV_Pro_en/3-UserNotes/3.3-MaintenanceandCare.html
    • 첫 설치와 사용: https://docs.elephantrobotics.com/docs/myAGV_Pro_en/4-FirstInstallAndUse/4.1-BasicEdition.html
    • Python API: https://docs.elephantrobotics.com/docs/myAGV_Pro_en/6-SDKDevelopment/6.1-ApplicationBasePython/6.1.2-API.html
  • 제품 페이지: https://www.elephantrobotics.com/en/myagv-pro/
  • 제품 소개 · 이미지 (현영이앤씨): https://www.hyenc.net/products/36
  • ROS 2 패키지 · URDF: https://github.com/elephantrobotics/agv_pro_ros2 (agv_pro_description/urdf/agv_pro.urdf)
  • ROS 좌표 관례 REP-103: https://www.ros.org/reps/rep-0103.html
  • Gazebo 용 URDF · 메시 (이 사이트 3D 뷰어 · 시뮬레이터의 모델): https://github.com/elephantrobotics/agv_pro_ros2/tree/humble/agv_pro_gazebo
  • 공식 문서 원본 저장소: https://github.com/elephantrobotics/myagvPro_docs/tree/main/MYAGV_PRO_EN
  • 이 사이트의 도구: 3D 뷰어 · 시뮬레이터 · Playground
  • 다음 차시: ch02 전방향 휠 기구학