전체 과정 P4 물류 현장으로 — ROS 2 운용과 미션 통합 · 약 200분 · 중급

CH10물류 미션 통합 프로젝트

창고 레이아웃 · 작업 배정 · 교통 관리 · 로봇팔 연동을 하나로 묶어, 시뮬레이터 창고에서 처리량을 최대로 끌어올리는 물류 시스템을 설계합니다.

선수 챕터: CH03 CH05 CH08 CH09
Python Playground시뮬레이터

학습 목표#

  • 입고장 · 보관 선반 · 피킹 스테이션 · 출고장 · 충전대로 창고를 나누고, 통로 폭 · 선반 방향 · 입출고장 위치를 바꿀 때 평균 편도 시간과 1대당 시간당 처리량이 어떻게 변하는지 시뮬레이터로 확인해 근거를 들어 배치를 고를 수 있습니다.
  • 미션을 대기 → 이동 → 적재 → 이동 → 하역 → 복귀/충전 과 오류 상태로 나눈 상태 머신으로 설계하고, 중복 · 순서가 뒤바뀐 이벤트를 무시하는 Python 클래스를 작성할 수 있습니다.
  • 가장 가까운 로봇 · 배터리 우선 · 라운드로빈 배정 규칙과 구역 예약(뮤텍스) · 일방통행 · 대기 구역 통행 규칙을 조합해, AGV 대수를 늘릴 때 처리량이 왜 비례해서 늘지 않는지와 교착(deadlock)이 어디서 생기는지 히트맵으로 설명할 수 있습니다.
  • myAGV Pro 위에 myCobot 320 · myCobot Pro 630 · myArm M750 을 얹는 구성에서 XT60 24 V 전원 예산과 디지털 IO 핸드셰이크(set_pin_output → 팔 작업 → get_pin_input)를 설계하고, 도킹 위치 오차가 집기 성공률과 작업 시간에 주는 영향을 숫자로 비교할 수 있습니다.
  • Part 1 ~ 4 에서 배운 기구학 · 안전 영역 · 지도 · 위치 추정 · 경로 계획 · 미션 관리를 한 설정표로 묶어, 평가판 점수(처리량 · 주행 거리 · 안전 위반 · 에너지)로 팀 설계를 비교하고 실물 시연 계획서를 쓸 수 있습니다.

이론#

ch01 에서 myAGV Pro 를 처음 열어 본 뒤로, 바퀴(ch02) → 명령(ch03) → 위치 세기(ch04) → 안전 센싱(ch05) → 지도(ch06) → 위치 추정(ch07) → 경로(ch08) → ROS 2 · Nav2 운용(ch09) 순서로 로봇 한 대가 한 지점에 가는 방법 을 쌓아 왔습니다. 마지막 차시의 질문은 다릅니다.

로봇 여러 대가 주문 수십 건을 받아, 사람과 같은 공간에서, 배터리가 떨어지지 않게, 시간당 몇 건 을 처리할 수 있을까?

이 질문의 답은 로봇 한 대의 성능보다 창고 배치 · 작업 배정 · 교통 규칙 · 주변 장치(로봇팔)와의 약속 에서 더 크게 갈립니다. 이번 차시는 그 네 가지를 시뮬레이터로 하나씩 바꿔 보고, 마지막에 하나의 설정표로 묶어 점수를 냅니다.

교시질문시뮬레이터실습
1선반을 어떻게 놓고, 미션을 어떤 상태로 나눌까?레이아웃 · 처리량 계산기, 미션 상태 머신 콘솔배치 3후보 평가, 상태 머신 클래스
2로봇을 늘리면 처리량도 늘까?다중 AGV 교통 (배정 규칙 · 통행 규칙 · 히트맵)배정 규칙 구현, 교착 탐지기
3팔을 얹으면 무엇이 달라질까?도킹 오차와 집기 성공률, IO 핸드셰이크 타이밍보정 방법 비교, 핸드셰이크 상태 머신
4우리 팀 창고는 몇 점일까?스마트 창고 평가판채점기, 시연 계획서 검사기
미션 관리자 (ch10) 창고 레이아웃1교시 주문 큐 · 배정 규칙2교시 교통 규칙 · 상태 머신1 · 2교시 팔 핸드셰이크 (IO)3교시 목표 지점 · 속도 제한Nav2 액션 (ch09)set_pin_output / get_pin_input 로봇 한 대 (Part 1 ~ 3) 경로 계획 · 추종ch08 위치 추정 AMCLch07 지도 SLAMch06 라이다 · 안전 영역ch05 ROS 2 · Nav2ch09 오도메트리ch04 Python API · 전방향 기구학ch02 · ch03 하드웨어 · URDF · 배터리ch01
이 차시가 묶는 것. 아래층(Part 1 ~ 3: 기구학 · 센서 · 지도 · 위치 · 경로)은 로봇 한 대를 움직이고, 위층(미션 관리자)은 주문을 받아 어느 로봇이 무엇을 언제 할지 정합니다. 위층의 결정이 처리량을 가장 크게 바꿉니다.
이 차시의 값과 시뮬레이터에 대해
  • 로봇 사양(530 × 360 mm, 최대 적재 50 kg, 24 V 20 Ah ≈ 480 Wh, IO 입력 6 · 출력 6, XT60 24 V 5 A)은 ch01 에서 공식 문서로 확인한 값입니다. 소비 전력은 ch01 의 근사식 P = 45 W + 1.05 · m · v 를 그대로 씁니다.
  • 창고 크기 · 적재 · 하역 시간 · 통로 감속 비율 · 충전 속도 · 도킹 오차 크기 · 그리퍼 허용 오차 등은 원리를 보이기 위한 가정값 입니다. 실제 현장은 측정해서 바꿔 넣어야 합니다.
  • 시뮬레이터 1 ~ 6 은 이 강좌가 만든 교육용 모델 입니다. 다중 AGV 교통은 1 m 칸 위에서 움직이는 단순화 모델이며 Nav2 의 실제 경로 · 속도 제어를 흉내 내지 않습니다. 대신 "규칙을 바꾸면 무엇이 달라지는가" 를 같은 조건에서 반복해 비교할 수 있습니다.
  • 로봇팔 사양(작업 반경 · 가반 하중)은 각 제품 페이지의 값이며, 전원 · IO 배선은 조합마다 다르므로 실물에서는 제조사 문서를 먼저 확인합니다(확인 필요 표시).

1교시 · 창고 레이아웃과 미션 상태 머신#

창고의 다섯 구역#

물류 창고는 물건이 흐르는 순서대로 구역을 나눕니다. AGV 는 이 구역 사이를 오가는 "발" 입니다.

구역하는 일AGV 에게 필요한 것앞 차시
입고장 (Receiving)트럭에서 내린 상자를 받아 검수적재 · 하역 위치가 지도에 고정ch06 지도
보관 선반 (Storage)상자를 칸(slot)에 보관좁은 통로 주행, 칸 앞 정밀 정지ch02 횡이동, ch08 코스트맵
피킹 스테이션 (Picking)사람이나 로봇팔이 주문 물건을 꺼냄도킹 정밀도, 팔과의 신호 약속3교시
출고장 (Shipping)포장 · 출하. 작업자가 많은 곳사람 구역 감속, 안전 영역ch05 안전 영역
충전대 (Charging)배터리 충전충전 시작 임계값, 도킹ch09 자동 충전
통로 w 보관 선반 (깊이 1 m · 칸 1 m · 3단) 입고장 피킹 스테이션 출고장 (사람 구역) 충전대 20 m12 m 주통로 2 m 선반 구역10 m 칸까지 편도 = 주통로 + 선반 통로
이 차시의 기준 창고(20 × 12 m). 아래쪽 2 m 띠가 주통로(입출고장 · 피킹 · 충전대)이고, 위쪽 10 m 에 선반을 놓습니다. 선반 하나의 깊이는 1 m, 칸 간격은 1 m, 3단입니다.

선반 배치를 고를 때는 두 가지가 서로 당깁니다.

  • 보관량 — 통로가 좁고 적을수록 같은 면적에 칸이 많아집니다.
  • 처리량 — 통로가 넓을수록 로봇이 빨리 달리고(ch08 의 팽창 · 속도 제한), 입출고장에서 가까운 칸이 많을수록 평균 거리가 짧아집니다.

1대가 미션 하나에 쓰는 시간(사이클)은 다음과 같이 나눕니다.

사이클 = 2 × 평균 편도 시간 + 적재 시간 + 하역 시간, 1대 처리량 (건/h) = 3600 ÷ 사이클

편도 시간은 주통로 구간(주통로 속도 v)과 선반 통로 구간(통로 속도 v통로)을 따로 더합니다. 이 차시의 모델에서 통로 속도는 통로 폭 w 에 따라 v통로 = v × (0.3 + 0.7 × clamp((w − 0.6) / 0.8, 0, 1)) 로 정합니다. 폭 0.6 m(로봇 폭 0.36 m + 양쪽 0.12 m)에서는 주통로의 30 % 로 기어가고, 1.4 m 이상이면 주통로와 같은 속도를 냅니다. ch08 에서 좁은 통로일수록 코스트맵 비용이 높고 제어기가 감속하던 것을 한 줄로 줄인 가정식 입니다.

예측하기: 통로를 넓히면 처리량은 계속 오를까?#

시뮬레이터를 열기 전에 공책에 적어 보세요.

  1. 배치 A(세로 열)에서 통로 폭을 0.6 m → 1.0 m → 2.0 m 로 넓히면, 보관 칸 수와 처리량은 각각 어떻게 될까요?
  2. 입출고장이 창고 가운데 에 있을 때와 왼쪽 구석 에 있을 때, 가장 좋은 배치는 같을까요?
  3. 자주 나가는 물건 20 % 를 입출고장 가까이 두면(ABC 배치), 처리량이 몇 % 쯤 오를까요?

시뮬레이터 1 · 통로 폭 · 선반 배치와 처리량#

지도 위 칸의 색은 입출고장에서 그 칸까지의 편도 시간 입니다(초록 = 가까움, 빨강 = 멂). 칸을 클릭 하면 그 칸까지의 경로와 시간이 나옵니다. 오른쪽 막대는 지금 조건에서 세 배치의 1대 처리량입니다.

시뮬레이터 1 · 창고 레이아웃 계산기 (20 × 12 m, 선반 깊이 1 m · 3단, 적재 15 s + 하역 15 s, AGV 1대)

해 볼 것

  1. 예측 확인 — 배치 A · 입출고장 가운데 · 주통로 1.0 m/s 에서 통로 폭을 0.6 → 1.0 → 1.4 → 2.0 m 로 바꾸며 보관 칸과 처리량을 표로 적습니다. 처리량이 가장 높은 폭은 어디이고, 그 뒤로 넓히면 왜 오히려 줄어드나요?
  2. 통로 폭 1.0 m 에서 오른쪽 막대로 A · B · C 를 비교합니다. B 가 가장 낮은 이유를 B 의 가장 먼 칸을 클릭해 "주통로 몇 m + 선반 통로 몇 m" 로 설명합니다.
  3. 입출고장을 왼쪽 구석 으로 옮깁니다. 이제 어느 배치가 1등인가요? C 의 가운데 세로 통로가 왜 손해가 되었나요?
  4. ABC 배치 를 켭니다. 굵은 테두리 칸(A 품목)이 어디에 몰리는지 보고, 처리량이 몇 % 오르는지 계산합니다. 통로 폭을 넓히는 것과 비교하면 어느 쪽이 "공짜" 인가요?
  5. 주통로 속도를 0.5 m/s 로 낮추면 세 배치의 순위가 바뀌나요? 사람 구역 감속(4교시)이 처리량에 주는 영향을 미리 생각해 봅니다.

관찰 포인트 — 처리량은 3600 ÷ (2 × 평균 편도 + 적재 + 하역) 이라서, 평균 거리를 줄이는 것 과 느린 구간(좁은 통로)을 줄이는 것 두 가지로만 오릅니다. 통로를 넓히면 통로 속도가 오르지만 같은 면적에 통로가 덜 들어가 칸이 줄고, 1.4 m 를 넘으면 속도 이득은 없고 칸 사이 거리만 벌어져 처리량이 다시 떨어집니다. 가장 좋은 배치는 입출고장 위치에 따라 달라집니다. 가운데 입출고장에는 가운데 세로 통로(C)가 잘 맞고, 구석 입출고장에는 주통로에서 바로 들어가는 세로 열(A)이 유리합니다. ABC 배치는 선반을 하나도 옮기지 않고 물건의 자리만 바꿔 처리량을 20 % 이상 올립니다.

확인 문제 1-1

입출고장 가운데, 주통로 1.0 m/s, 통로 폭 1.0 m 에서 시뮬레이터 1 의 결과가 A 63.8 건/h (360 칸), B 40.6 건/h (324 칸), C 63.3 건/h (324 칸) 입니다. 같은 면적에서 하나를 고른다면 가장 근거가 좋은 답은?

  1. C — 가운데 세로 통로가 있으니 항상 가장 빠르다
  2. A — 처리량은 C 와 거의 같으면서 보관 칸이 36 칸 더 많다
  3. B — 칸이 가로로 길게 늘어서 한 통로에 칸이 가장 많다
  4. 세 배치의 차이는 계산 오차 수준이라 아무것이나 같다
정답 보기② — A 와 C 의 처리량 차이는 0.5 건/h(1 % 안쪽)이지만 A 의 보관량이 11 % 많습니다. C 가 "항상" 빠르지는 않습니다(①). 해 볼 것 3 처럼 입출고장을 구석으로 옮기면 C 가 꼴찌가 됩니다. B 는 가장 먼 칸까지 주통로 18.5 m + 선반 통로 17.5 m 를 가야 해서 평균 편도 시간이 A 의 두 배가 넘습니다(③). 차이는 오차가 아니라 구조에서 나옵니다(④).
확인 문제 1-2

배치 A 에서 통로 폭을 1.4 m → 2.0 m 로 넓혔더니 처리량이 70.9 → 69.8 건/h 로 오히려 조금 줄었습니다. 가장 알맞은 설명은?

  1. 통로가 넓어지면 로봇이 통로 가운데를 찾느라 느려진다
  2. 1.4 m 부터 통로 속도가 이미 주통로와 같아 더 빨라지지 않고, 통로 사이 간격(2D + w)이 벌어져 주통로를 더 많이 달린다
  3. 통로가 넓으면 칸이 늘어나 평균 거리가 길어진다
  4. 적재 · 하역 시간이 통로 폭에 비례해 늘어난다
정답 보기② — 통로 속도 식은 w ≥ 1.4 m 에서 1.0 이 되어 더 오르지 않습니다. 반면 통로 사이 간격이 3.4 m → 4.0 m 로 벌어지면 통로 수는 5개로 같아 칸도 300 개 그대로인데, 입출고장에서 바깥쪽 통로까지 주통로 거리가 늘어납니다. ① 같은 효과는 이 모델에 없고, ③ 칸은 늘지 않으며, ④ 적재 · 하역 시간은 15 s 로 고정입니다.

미션 상태 머신#

창고 배치가 "어디로" 를 정한다면, 상태 머신은 "지금 무엇을 하는 중이고, 다음에 무엇을 받아들일지" 를 정합니다. ch03 에서 라이트 커튼 정지 · 재출발을 상태 머신으로 짰던 것을 미션 전체로 넓힙니다.

대기이동적재이동하역충전 이동충전오류 IDLETO_PICKLOADINGTO_DROPUNLOADINGTO_CHARGECHARGINGERROR 주문 배정도착적재 완료도착 하역 완료 [배터리 < 임계]도착충전 완료 하역 완료 [배터리 >= 임계]취소 (짐 없을 때만) 막힘 30 s · 비상정지 (모든 상태) → 오류, 오류 해제 → 멈춘 상태로
이 차시의 미션 상태 머신. 위쪽 줄이 정상 흐름이고, 하역이 끝날 때 배터리가 임계값보다 낮으면 충전으로 갑니다. 주행 중 경로 막힘 · 비상정지는 어느 상태에서든 오류로 가며, 오류 해제 후에는 멈췄던 상태로 돌아갑니다.
상태뜻받는 이벤트 → 다음 상태
IDLE 대기주문을 기다림 (대기 구역 또는 제자리)주문 배정 → TO_PICK
TO_PICK 이동선반 칸으로 Nav2 목표 전송 (ch09)도착 → LOADING, 취소 → IDLE, 막힘 30 s → ERROR
LOADING 적재선반에서 상자를 싣는 중 (사람 · 팔)적재 완료 → TO_DROP
TO_DROP 이동출고장으로 이동 (짐 실음)도착 → UNLOADING, 막힘 30 s → ERROR (취소 불가)
UNLOADING 하역상자를 내림하역 완료 → 배터리 < 임계값 ? TO_CHARGE : IDLE
TO_CHARGE · CHARGING충전대로 이동 · 충전 (ch09)도착 → CHARGING, 충전 완료 → IDLE
ERROR 오류사람의 확인을 기다림오류 해제 → 멈췄던 상태

상태 머신의 핵심은 표에 없는 조합은 무시한다 는 것입니다. 실제 시스템에서는 같은 "도착" 이벤트가 두 번 오기도 하고(재전송), 적재 완료 신호가 도착보다 먼저 오기도 합니다(배선 · 지연). 표에 없는 이벤트를 받아들이면 짐을 싣지도 않고 출고장으로 떠나는 사고가 납니다.

시뮬레이터 2 · 미션 상태 머신 이벤트 콘솔#

버튼이 시뮬레이터(또는 Nav2 · 센서)가 보내는 이벤트 입니다. 순서를 일부러 틀리게 눌러 보세요. 현재 상태는 굵은 테두리, 방금 일어난 전이는 굵은 화살표로 보입니다.

시뮬레이터 2 · 미션 상태 머신 (이벤트를 눌러 상태 전환, 표에 없는 이벤트는 무시)
시나리오 재생: ·

해 볼 것

  1. 정상 미션 2건 을 재생합니다. 두 번째 미션의 하역이 끝날 때 배터리가 18 % 라서 어디로 가나요? 임계값 슬라이더를 15 % 로 낮추고 다시 재생하면 무엇이 달라지나요?
  2. 중복 · 뒤바뀐 이벤트 를 재생합니다. 빨간 줄(무시한 이벤트)은 몇 개이고, 각각 무시하지 않았다면 어떤 사고가 났을까요? (예: 도착 전에 받은 적재 완료)
  3. 짐 실은 채 비상정지 를 재생합니다. ERROR 에서 "주문 배정" · "주문 취소" 는 왜 무시되나요? 오류 해제 후 로봇은 어느 상태로 돌아가나요?
  4. 직접 눌러 봅니다: TO_PICK 에서는 취소가 되는데 TO_DROP 에서는 왜 안 되게 설계했을까요? 취소를 허용하려면 어떤 상태를 하나 더 만들어야 할까요?
  5. 배터리를 11 % 로 낮춘 뒤 미션을 처음부터 끝까지 눌러 봅니다. 이 상태 머신은 미션을 시작하기 전에 배터리를 확인하나요? 확인 문제 1-3 과 연결됩니다.

관찰 포인트 — 상태 머신은 "현재 상태 + 이벤트 → 다음 상태" 표 하나로 동작하며, 표에 없는 칸은 모두 무시 합니다. 그래서 중복 이벤트(도착 두 번)와 순서가 뒤바뀐 이벤트(도착 전 적재 완료)가 와도 상태가 꼬이지 않습니다. 오류 상태는 "어디서 멈췄는지" 를 저장해 두어야 재개할 수 있고, 짐을 실은 상태에서의 취소처럼 물리적으로 되돌릴 수 없는 전이는 표에서 빼는 것 이 안전한 설계입니다. 충전 판단은 하역이 끝나는 순간 한 번만 하므로, 배터리가 거의 없는 로봇도 IDLE 에서 새 주문을 받을 수 있다는 빈틈이 있습니다.

확인 문제 1-3

시뮬레이터 2 에서 배터리 11 %, 임계값 25 % 인 로봇이 IDLE 에서 "주문 배정" 을 받으면 TO_PICK 으로 갑니다. 이 빈틈을 막는 가장 알맞은 수정은?

  1. UNLOADING 의 충전 조건을 bat < thr 에서 bat <= thr 로 바꾼다
  2. IDLE 의 "주문 배정" 전이에 조건(guard) bat ≥ thr 를 달고, 아니면 TO_CHARGE 로 보낸다
  3. 오류 해제 버튼을 없앤다
  4. 임계값을 50 % 로 올린다
정답 보기② — 전이에 조건을 붙이는 것을 guard 라고 합니다. 충전 판단이 "하역 직후" 한 번뿐이면, 시작할 때부터 배터리가 낮았거나 대기 중에 떨어진 로봇이 걸러지지 않습니다. 배정 전에 한 번 더 확인하면 빈틈이 닫힙니다(2교시의 배정기도 충전이 필요한 로봇을 후보에서 뺍니다). ①은 경계값 하나만 바꾸고, ④는 빈틈은 그대로 둔 채 로봇을 자주 쉬게 만들어 처리량만 줄입니다.

2교시 · 작업 배정과 다중 AGV 교통 관리#

주문 큐와 배정 규칙#

주문은 큐(queue) 에 도착 순서대로 쌓이고, 미션 관리자는 "놀고 있는 로봇" 이 생길 때마다 큐 맨 앞의 주문을 누구에게 줄지 정합니다. 이 결정 규칙이 배정 규칙(dispatching rule)입니다.

규칙고르는 방법좋은 점약한 점
가장 가까운 로봇 (nearest)대기 로봇 중 주문 칸까지 경로가 가장 짧은 로봇빈 차 주행이 짧음한 로봇만 계속 일해 배터리가 한쪽으로 쏠림
배터리 우선 (battery)대기 로봇 중 배터리가 가장 많은 로봇충전 횟수가 고르게 퍼짐먼 로봇을 부를 수 있음
라운드로빈 (round-robin)로봇 1 → 2 → 3 … 차례로, 바쁜 로봇은 건너뜀단순, 일이 고르게 나뉨거리 · 배터리를 보지 않음

배정 규칙의 차이는 대기 로봇이 둘 이상일 때만 나타납니다. 주문이 로봇보다 훨씬 많아 늘 한 대씩만 비는 상황이라면, 누구에게 줄지 고를 여지가 없기 때문입니다.

로봇이 늘면 생기는 일 — 정체와 교착#

로봇이 한 대일 때는 경로 계획(ch08)만 잘하면 됩니다. 두 대부터는 같은 공간을 나눠 쓰는 문제 가 생깁니다.

  • 정체(congestion) — 앞 로봇이 적재 중이라 뒤 로봇이 기다립니다. 시간이 지나면 풀립니다.
  • 교착(deadlock) — 두 로봇이 서로 상대가 비켜 주기를 기다려 영원히 풀리지 않습니다. 폭 1 m 통로 한가운데서 마주 보고 선 두 로봇, 하역장 안의 로봇이 나오려는데 그 앞 칸을 하역장에 들어가려는 로봇들이 막고 있는 상황이 대표적입니다.

교착은 네 조건(상호 배제 · 점유하며 대기 · 빼앗을 수 없음 · 순환 대기)이 동시에 성립할 때만 생깁니다. 그래서 하나를 깨면 막을 수 있습니다.

1 2 규칙 없음: 정면 대치 서로의 칸을 기다림 = 순환 대기 2 1 한 칸 전에서 대기구역 예약: 통로 전체를 2 가 빌림 1 3 2 일방통행: 같은 방향으로 줄서기 대신 돌아가는 길이 생김
왼쪽: 좁은 통로에서 마주친 두 로봇은 서로가 가진 칸을 기다리는 순환 대기에 빠집니다. 가운데: 구역 예약은 통로 전체를 한 대에게만 빌려주어 "점유하며 대기" 를 깹니다. 오른쪽: 일방통행은 마주 보는 방향 자체를 없애 "순환 대기" 를 깹니다.
통행 규칙하는 일깨는 조건대가
구역 예약 (뮤텍스, mutex)좁은 통로 · 하역장 · 충전대를 하나의 구역으로 묶고, 들어가기 한 칸 전에 예약. 예약한 로봇이 구역을 빠져나가야 다음 로봇이 들어감점유하며 대기통로 하나에 한 대만 → 로봇이 많으면 입구 대기 증가
일방통행통로마다 방향을 정함 (이 모델: 1 · 3 번째 통로 위로, 2 · 4 번째 통로 아래로)순환 대기 (통로 안)돌아가는 길이 생겨 주행 거리 증가
대기 구역일을 마친 로봇이 하역장에 서 있지 않고 대기 칸(P)으로 비켜 감— (교착 원인 제거)대기 칸까지 빈 차 주행

교착을 완전히 막지 못하는 시스템은 탐지 후 복구 를 합니다. 이 차시의 시뮬레이터는 "서로를 5 s 이상 기다리는 순환" 을 찾으면 운영자가 로봇 한 대를 가까운 주통로로 옮기고 20 s 를 잃는 것으로 셉니다. 실제 현장에서는 이 20 s 가 사람이 달려가 로봇을 미는 시간입니다.

예측하기: 5대면 5배일까?#

1대가 시간당 74 건을 처리한다면, 아무 규칙 없이 5대를 넣으면 시간당 몇 건일까요? 370 건? 300 건? 200 건? 그리고 교착은 몇 대부터 생길까요? 공책에 적고 시뮬레이터를 엽니다.

시뮬레이터 3 · 다중 AGV 교통 — 배정 규칙 · 통행 규칙 · 정체 히트맵#

12 × 9 칸(1 칸 = 1 m) 창고에서 AGV 가 30 분 동안 주문을 처리합니다. 주문은 무작위 시각에 도착하고(평균 도착률은 슬라이더), 한 건은 선반 칸에서 적재 8 s → 출고장(출고) 두 곳 중 하나에서 하역 8 s 입니다. 주통로(위 · 아래 가로줄)는 두 대가 비켜 갈 수 있고, 선반 통로(세로줄)는 한 대만 지나갑니다. 오른쪽 출고장 주변 주황 칸은 포장 작업자가 있는 사람 구역 이라 0.3 m/s 로 감속합니다. 설정을 바꾸면 30 분을 바로 계산하고, ▶ 로 다시 볼 수 있습니다.

시뮬레이터 3 · 다중 AGV 교통 (30 분, 최고 1.0 m/s, 시작 배터리 80 · 65 · 50 · 35 · 90 %, 충전 임계값 25 %)
통행 규칙: · · ·
· 배속 · 빠른 설정:

해 볼 것

  1. 예측 확인 — "규칙 없음", 도착률 6 건/분(주문이 처리 능력보다 많은 상태)에서 대수를 1 → 5 로 올리며 오른쪽 그래프를 봅니다. 1대 74 건/h 의 5배(점선)와 비교해 5대는 몇 % 인가요? 교착(빨강 X)은 몇 대부터 생기나요?
  2. 3대 · 규칙 없음에서 ▶ 재생해 X 가 생기는 곳을 찾습니다. 선반 통로 안 인가요, 출고장 앞 인가요? 히트맵의 가장 진한 칸은 어디인가요?
  3. 3대에서 빠른 설정 버튼 네 개(규칙 없음 · 구역 예약 · 일방통행 · 모두)를 차례로 누르며 처리량 · 교착 · 총 주행 거리를 표로 적습니다. 교착이 0 이면서 처리량이 가장 높은 조합은? 일방통행은 왜 주행 거리가 늘어나나요?
  4. 대수를 5대로 올리고 같은 비교를 합니다. 순위가 바뀌나요? 일방통행이 3대일 때보다 상대적으로 좋아지는 이유를 "통로 하나에 몇 대가 동시에 들어갈 수 있나" 로 설명합니다.
  5. 도착률을 3 건/분 으로 낮추고(로봇이 놀 때가 생김) 4대 · 구역 예약에서 대기 구역 을 켜고 끕니다. 교착 · 평균 배정 대기가 어떻게 바뀌나요? 이어 배정 규칙 세 가지를 바꿔 봅니다. 처리량 차이가 교통 규칙만큼 큰가요?

관찰 포인트 — 대수를 늘리면 처리량은 늘지만 비례하지 않습니다. 같은 통로 · 같은 출고장 · 같은 사람 구역을 나눠 쓰므로 기다리는 시간이 생기고(히트맵), 아무 규칙이 없으면 좁은 통로 정면 대치와 출고장 앞 막힘으로 교착이 대수의 제곱에 가깝게 늘어납니다. 구역 예약은 교착을 거의 없애지만 통로를 한 대씩만 쓰게 하고, 일방통행은 통로 안 정면 대치를 원천적으로 없애는 대신 돌아가는 거리 를 치릅니다. 로봇이 적을 때는 거리 손해가, 많을 때는 통로를 여러 대가 함께 쓰는 이득이 더 큽니다. 배정 규칙은 놀고 있는 로봇이 여럿일 때만 차이를 만들어서, 주문이 넘치는 상황에서는 교통 규칙보다 효과가 훨씬 작습니다.

확인 문제 2-1

시뮬레이터 3 의 "규칙 없음" · 도착률 6 건/분에서 1대 74 건/h, 3대 200 건/h (교착 8번), 5대 274 건/h (교착 42번) 이 나왔습니다. 5대가 이상적인 370 건/h 의 74 % 에 그친 이유로 가장 알맞은 것은?

  1. 주문이 부족해서 로봇이 놀았다
  2. 로봇이 많아질수록 배터리가 빨리 닳아 충전하러 갔다
  3. 좁은 통로 · 출고장 · 사람 구역을 나눠 쓰며 기다리는 시간이 늘고, 교착이 생길 때마다 운영자 개입으로 20 s 씩 잃었다
  4. 로봇이 많으면 경로 계획(BFS)이 느려져 출발이 늦어진다
정답 보기③ — 도착률 6 건/분은 360 건/h 라서 5대가 처리하는 274 건/h 보다 많습니다. 30 분 뒤에도 주문이 남아 있으므로 ①은 아닙니다. 시작 배터리 중 가장 낮은 35 % 도 30 분 동안 약 6 % 만 줄어 25 % 임계값에 닿지 않으므로 ②도 아닙니다. 히트맵에서 기다림은 출고장 앞과 통로 입구에 몰립니다. 교착 42번 × 20 s 만 해도 약 14 분의 로봇 시간을 잃습니다. 계획 계산 시간(④)은 이 모델의 시간에 들어가지 않습니다.
확인 문제 2-2

3대 · 도착률 6 건/분에서 "구역 예약" 은 204 건/h (교착 0), "일방통행" 은 184 건/h (교착 1), 총 주행 거리는 각각 약 1 590 m · 2 110 m 였습니다. 일방통행의 처리량이 더 낮은 까닭은?

  1. 일방통행에서는 통로마다 한 대씩만 들어갈 수 있어서
  2. 아래로 가는 통로의 칸에 가려면 위 통로로 올라가 위 주통로를 돌아 들어와야 해서, 같은 주문을 처리하는 데 더 먼 길을 달린다
  3. 일방통행에서는 사람 구역 감속이 꺼져서
  4. 일방통행이 교착을 더 많이 만들어서
정답 보기② — 1대만 있어도 일방통행은 74 → 62 건/h 로 떨어집니다. 교통과 상관없는 순수한 "돌아가는 거리" 손해입니다(주행 거리 약 +33 %). 일방통행은 오히려 한 통로에 여러 대가 같은 방향으로 줄지어 들어가게 해 줍니다(①은 구역 예약의 특징). 그래서 5대에서는 일방통행 280 건/h 가 구역 예약 278 건/h 와 비슷해집니다. 그래도 출고장 앞 교착은 일방통행만으로 막지 못하므로 ④가 아니라, 구역 예약과 함께 쓰는 이유가 됩니다.

3교시 · 로봇팔 연동 — 이동 매니퓰레이션#

myAGV Pro + 로봇팔 조합#

AGV 위에 팔을 얹으면 "물건이 있는 곳으로 가서 직접 집는" 이동 매니퓰레이션(mobile manipulation) 이 됩니다. ch01 에서 본 공식 응용 사례를 다시 정리합니다.

조합팔의 작업 반경 · 가반 하중사례 (ch01)이 차시 모델의 집는 거리 L (가정)
myAGV Pro + myCobot 320약 350 mm · 1 kg물류 분류 훈련장 (흡착 그리퍼)0.25 m
myAGV Pro + myCobot Pro 630약 630 mm · 2 kg스마트 오피스 (문 열기)0.40 m
myAGV Pro + myArm M750약 750 mm 급 (확인 필요)가정 서비스0.45 m

팔의 사양은 각 제품 페이지 값이며 모델 · 버전에 따라 다를 수 있습니다. 집는 거리 L 은 "팔 베이스에서 물건까지" 의 이 차시 가정값입니다.

팔을 얹을 때 확인할 것은 세 가지입니다.

  1. 무게 — 팔 + 그리퍼 + 집을 물건이 최대 적재 50 kg 안에 들어오고, 무게 중심이 차체 가운데 · 낮게 있어야 합니다(ch01). 팔이 옆으로 뻗으면 무게 중심이 움직이므로 팔이 움직이는 동안 AGV 는 서 있어야 합니다.
  2. 전원 — myAGV Pro 뒷면의 XT60 단자는 24 V · 최대 5 A (= 120 W) 입니다(ch01). 팔의 정격 · 최대 전류가 이보다 크면 별도 전원이나 DC-DC 변환기가 필요합니다. 팔이 쓰는 전력은 같은 480 Wh 배터리에서 나가므로 주행 시간도 줄어듭니다.
  3. 신호 — 팔과 AGV 가 "도착했다 · 다 집었다" 를 주고받을 약속이 필요합니다. 가장 단순한 방법이 ch03 의 디지털 IO (입력 6 · 출력 6) 입니다.
전원 계산은 최대 전류로

팔이 평균 40 W 를 쓰더라도 관절이 동시에 가속하는 순간에는 몇 배의 전류가 흐를 수 있습니다. XT60 출력에 보호 회로가 있는지, 팔의 최대(peak) 전류 가 5 A 를 넘는지는 제조사 사양서로 확인합니다(확인 필요). 넘거나 모르면 처음 시험은 팔 전용 전원으로 합니다.

예를 들어 팔이 평균 40 W 를 더 쓰면, ch01 의 근사식으로 빈 차 0.5 m/s 주행(45 + 1.05 × 40 × 0.5 ≈ 66 W)에 40 W 가 더해져 106 W 가 됩니다. 480 Wh ÷ 66 W ≈ 7.3 h 이던 주행 가능 시간이 480 ÷ 106 ≈ 4.5 h 로 줄어듭니다. 2교시의 충전 임계값은 이 소비 전력으로 다시 계산해야 합니다.

공식 복합 키트 예제 실행하기 (공식 문서 7.1 ~ 7.3)#

공식 문서는 세 가지 팔 조합을 무선 게임패드로 조종하는 창고 화물 운반 예제로 제공합니다. 하드웨어는 고정판 · M5 슬라이더 너트로 팔을 myAGV Pro 의 2040 프로파일에 고정하고, XT60 어댑터 케이블로 AGV 의 XT60 전원 단자에서 팔 전원을 받으며, 팔과 AGV 를 USB-C 로 잇는 구성입니다 (myCobot 320 은 흡착 펌프를 팔의 Basic IO 출력에 연결).

bash
git clone https://github.com/elephantrobotics/pymycobot.git
cd pymycobot/demo/myAGVPro_Composite_Kit
pip install -r requirements.txt
# main.py 의 설정을 바꾼 뒤
python main.py
설정 (main.py)myArm M750 · myCobot 320myCobot Pro 630
COMPOSITE_KIT_TYPE"MyArmM750" · "MyCobot320""MyCobotPro630"
연결직렬 COMPOSITE_KIT_COMPORT = "/dev/ttyACM2" (ls /dev/tty* 로 확인)TCP COMPOSITE_KIT_HOST = 팔의 IP, COMPOSITE_KIT_PORT = 5001
먼저 할 일팔 펌웨어 확인팔에서 RoboFlow 프로그램이 실행 중이어야 함
전원을 켜는 순서와 게임패드

문서의 순서는 AGV 비상정지 해제 → AGV 전원 → 팔 비상정지 해제 → 팔 전원 → 팔이 다 켜질 때까지 대기 입니다. 게임패드 수신기는 프로그램을 켜기 전에 AGV 의 USB 에 꽂아야 하고, 실행 중 수신기가 빠지면 프로그램이 스스로 종료됩니다 — 종료 순간 팔 · AGV 의 마지막 동작이 어떻게 되는지 실물에서 반드시 먼저 확인합니다 (확인 필요).

도킹 정밀도 → 팔의 집기 성공률#

팔은 보통 "AGV 가 정확히 그 자리에 섰다" 고 믿고, 미리 가르친(teaching) 좌표로 손을 뻗습니다. AGV 가 x · y 로 몇 cm, 방향 θ 로 몇 도 어긋나게 서면, 팔 기준으로 물건의 위치가 그만큼 움직입니다.

  • 앞뒤 오차 ex → 물건이 팔 기준으로 ex 만큼 움직임
  • 좌우 오차 ey 와 방향 오차 θ → 좌우로 ey + L · θ 만큼 움직임 (θ 는 rad)

방향 오차는 팔이 길수록(L 이 클수록) 크게 불어납니다. 2° (0.035 rad) 만 틀어져도 L = 0.25 m 에서 0.9 cm, L = 0.45 m 에서 1.6 cm 입니다. 그리퍼가 물건을 잡을 수 있는 허용 오차(그리퍼가 벌어진 폭에서 물건 폭을 뺀 절반)가 1 cm 안팎이라면 이 차이가 성공과 실패를 가릅니다.

오차를 줄이는 방법은 세 가지입니다.

방법원리이 차시 모델 (가정)
저속 접근마지막 구간을 천천히 와서 제동 · 미끄러짐 오차를 줄임 (ch01 정지 거리 ∝ v²)x · y · θ 오차 절반, +4 s
횡이동 미세 보정도착 후 옆면 거리 센서 · 라이다로 벽까지 거리를 재고, 전방향 바퀴로 옆으로만 움직여 맞춤 (ch02)y 오차 σ 0.3 cm, θ 오차 σ 0.2° 로 줄임, x 는 그대로, +3 s
마커 (카메라)팔 카메라로 선반의 마커(ArUco 등)를 보고 팔이 직접 위치를 고쳐 잡음남는 오차 σ 0.2 cm, 단 어긋남이 4 cm 를 넘으면 마커가 시야 밖 → 실패, +2 s

예측하기: 마커 하나면 끝일까?#

도킹 오차 ±5 cm 에서 마커만 쓰면 성공률이 100 % 에 가까울까요? 저속 접근만 쓰면? 둘을 함께 쓰면? 시간당 성공 피킹 수로 비교하면 "가장 정확한 방법" 과 "가장 많이 처리하는 방법" 이 같을까요?

시뮬레이터 4 · 도킹 오차와 피킹 성공률#

점 하나가 도킹 한 번입니다. 가운데 원이 그리퍼 허용 오차이고, 원 안(초록)이면 성공, 밖(빨강)이면 실패입니다. 실패하면 사람이 와서 고치는 데 60 s 가 걸린다고 봅니다. 오른쪽 표는 지금 오차 · 팔에서 보정 방법 8가지 조합을 모두 계산한 결과입니다.

시뮬레이터 4 · 도킹 오차 → 팔 기준 물건 위치 (도킹 + 집기 기본 18 s, 실패 복구 60 s, 400번 도킹)
보정: · · · 오차 빠른 선택 ·

해 볼 것

  1. 예측 확인 — myCobot 320, 그리퍼 허용 1.0 cm, 보정 없음에서 오차 ±1 · ±3 · ±5 cm 버튼을 차례로 누릅니다. 성공률은 어떻게 떨어지나요? 오차가 3배가 될 때 성공률도 3분의 1 이 되나요?
  2. ±3 cm 에서 팔을 myCobot 320 → myArm M750 으로 바꿉니다. 점 구름이 어느 방향으로 늘어나나요? 앞뒤(dx)와 좌우(dy) 중 어느 쪽이 팔 길이의 영향을 받는지 식 ey + L · θ 로 설명합니다.
  3. ±5 cm 에서 마커만 켭니다. 점선 원(마커 시야) 밖의 점은 몇 개이고, 성공률은? 이어 저속 접근 + 마커 를 켭니다. 왜 마커가 저속 접근과 짝을 이룰 때 강해지나요?
  4. ±1 cm 에서 오른쪽 표의 ★ 는 어느 조합인가요? ±5 cm 에서는? "보정을 모두 켜기" 가 언제나 1등이 아닌 이유를 1회 시간과 함께 설명합니다.
  5. 그리퍼 허용 오차를 0.5 → 2.0 cm 로 넓혀 봅니다(더 넓게 벌어지는 그리퍼, 흡착 그리퍼). 같은 성공률을 얻으려면 도킹을 고치는 것과 그리퍼를 바꾸는 것 중 무엇이 싸게 먹힐지 토론합니다.

관찰 포인트 — 도킹 오차가 그리퍼 허용 오차보다 커지는 순간 성공률은 선형이 아니라 급격히 무너집니다(2차원 정규분포가 원 안에 들어올 확률). 방향 오차는 팔 길이만큼 불어나 좌우로만 퍼지므로, 긴 팔일수록 횡이동 보정의 값어치가 큽니다. 마커는 남는 오차를 거의 없애지만 마커가 보여야 하므로, 큰 오차에서는 저속 접근으로 시야 안에 먼저 들여놓아야 합니다. 처리량으로 보면 오차가 작을 때는 가장 싼 보정 하나가, 오차가 클 때는 둘의 조합이 1등이고, 셋 다 켜면 시간만 늘어나는 구간이 있습니다.

확인 문제 3-1

myCobot 320, 그리퍼 허용 1.0 cm, 도킹 오차 ±5 cm 에서 시뮬레이터 4 의 표가 "마커만: 성공률 약 65 %", "저속 + 마커: 약 98 %" 를 보였습니다. 이 차이를 가장 잘 설명하는 것은?

  1. 저속 접근을 하면 카메라 노출이 좋아져 마커 인식이 정확해진다
  2. 마커는 시야(4 cm) 안에 들어온 경우에만 보정할 수 있는데, ±5 cm 오차에서는 약 35 % 가 시야 밖으로 나가고, 저속 접근이 오차를 절반으로 줄여 거의 모두를 시야 안에 넣는다
  3. 저속 접근 자체가 성공률을 99 % 로 만든다
  4. 마커는 1 회 시간을 2 s 늘려서 성공률이 떨어진다
정답 보기② — 마커가 일단 보이면 남는 오차는 σ 0.2 cm 라 1.0 cm 허용 안에 거의 다 들어옵니다. 실패는 전부 "시야 밖" 에서 나옵니다. 저속 접근만 쓰면 성공률은 약 24 % 에 그치므로(③ 아님), 두 방법은 각자 다른 일을 합니다: 저속 접근은 **큰 오차를 줄이고**, 마커는 **남은 작은 오차를 지웁니다**. 시간은 성공률이 아니라 처리량에 영향을 줍니다(④). 이 모델에는 노출 효과가 없습니다(①).

AGV ↔ 팔 핸드셰이크#

AGV 와 팔은 서로의 프로그램 안을 들여다볼 수 없으므로 전선 몇 가닥 으로 약속합니다. myAGV Pro 의 Python API(ch03)로는 다음과 같습니다.

  • AGV → 팔 : set_pin_output(1, 1) "도착해서 섰다 (작업 요청 REQ)"
  • 팔 → AGV : 팔 컨트롤러의 출력이 AGV 입력 1 번에 연결 → get_pin_input(1) 이 1 이면 "다 집었다 (DONE)"
REQAGV 출력 1 DONEAGV 입력 1 팔 작업 (집기) 1 2 3 4 1 도착 · 정지 → set_pin_output(1, 1) 2 작업 끝 → DONE = 1 (유지) 3 get_pin_input(1) == 1 확인 → set_pin_output(1, 0) 4 팔: REQ 0 확인 → DONE = 0 → AGV 출발 출발 허가
4단계 핸드셰이크. AGV 가 REQ 를 올리고, 팔은 작업을 마치면 DONE 을 올립니다. AGV 는 DONE 을 본 뒤 REQ 를 내리고, 팔이 그것을 보고 DONE 을 내린 뒤에야 AGV 가 출발합니다. 어느 쪽이 신호를 놓쳐도 다음 단계로 넘어가지 않습니다.

ch03 에서 본 것처럼 get_pin_input 은 폴링 입니다. 폴링 주기 사이에 잠깐 올라갔다 내려간 신호(펄스)는 읽지 못할 수 있습니다. 그래서 산업 현장의 신호 약속은 대개 "상대가 확인했다고 답할 때까지 신호를 유지 한다" 는 4단계 핸드셰이크를 씁니다.

시뮬레이터 5 · IO 핸드셰이크 타이밍#

AGV 가 t = 1.0 s 에 도착해 REQ 를 올립니다. 팔은 50 ms 마다 입력을 보고, REQ 를 보면 작업을 시작합니다. 세 가지 약속 방식을 비교하세요.

시뮬레이터 5 · AGV ↔ 팔 IO 핸드셰이크 (0 ~ 10 s, 도착 t = 1.0 s, 팔 폴링 50 ms)
약속 방식 · ·

해 볼 것

  1. 펄스 방식 에서 AGV 폴링 200 ms · 펄스 폭 100 ms 로 두고 "위상 200가지로 성공률 계산" 을 누릅니다. 놓침은 몇 번인가요? 펄스 폭을 200 ms, 300 ms 로 늘리면? 놓치지 않으려면 펄스 폭 ≥ 폴링 주기 가 필요한 이유를 그림의 초록 점으로 설명합니다.
  2. 펄스 폭 300 ms 에서 잡음 을 켭니다. 위험 출발이 생기나요? 폴링 주기를 20 ms 로 줄이면 잡음을 더 잘 잡을까요, 더 잘 속을까요? 디바운스 를 켜면?
  3. 레벨 + 응답 으로 바꿉니다. 폴링 주기를 1000 ms 까지 늘려도 놓침이 생기나요? 대신 무엇을 잃나요(출발 시각)?
  4. 신호 없이 타이머 로 바꾸고 팔 작업 시간을 1.5 → 2.5 → 3.5 s 로 늘립니다. 어느 순간부터 "위험 - 팔이 작업 중인데 출발" 이 나오나요? 팔이 물건을 들고 AGV 위로 뻗어 있을 때 AGV 가 출발하면 무슨 일이 생길까요?
  5. 레벨 + 응답에서 팔 작업 시간을 5 s, 타임아웃을 4 s 로 둡니다. 결과를 보고 "타임아웃은 얼마로 정해야 하는가" 를 팔 작업 시간 · 폴링 주기로 한 줄 규칙으로 씁니다.

관찰 포인트 — 폴링은 주기 사이의 일을 보지 못하므로, 펄스는 폭이 폴링 주기보다 짧으면 위상에 따라 놓칩니다. 놓친 AGV 는 타임아웃까지 서 있다가 오류로 갑니다(사람 호출). 잡음은 폴링이 빠를수록 더 잘 "읽혀서" 오히려 속기 쉽고, 디바운스(연속 n번 확인)가 이를 막습니다. 4단계 핸드셰이크는 각 신호를 상대가 확인할 때까지 유지 하므로 폴링 주기 · 위상과 상관없이 놓치지 않으며, 대가는 응답 단계만큼의 시간입니다. 타이머 방식은 팔이 느려지는 날 바로 사고가 납니다. 타임아웃은 팔 작업 최대 시간 + 핸드셰이크 왕복(폴링 주기 몇 개) + 여유 보다 길어야 합니다.

확인 문제 3-2

AGV 폴링 200 ms, 펄스 방식에서 펄스 폭 100 ms 로 200가지 위상을 돌렸더니 약 절반이 "놓침(타임아웃)" 이었습니다. 위상 · 지연과 상관없이 놓침을 0 으로 만드는 가장 확실한 방법은?

  1. 펄스 폭을 150 ms 로 늘린다
  2. AGV 폴링 주기를 150 ms 로 줄인다
  3. 팔이 DONE 을 AGV 가 REQ 를 내릴 때까지 유지하는 4단계 핸드셰이크로 바꾼다
  4. 타임아웃을 6 s 에서 9 s 로 늘린다
정답 보기③ — 펄스 폭 100 ms 와 폴링 200 ms 면 폴링 시각이 펄스 안에 떨어질 확률이 100/200 = 50 % 입니다. ①, ② 는 폭 / 주기 비율을 75 % 로 올릴 뿐 0 이 되지 않으며, 폭 ≥ 주기 로 맞춰도 폴링이 밀리면(ch03 의 지연 · 흔들림) 다시 놓칩니다. 4단계 핸드셰이크는 "확인할 때까지 유지" 라서 위상과 상관이 없습니다. 타임아웃을 늘리면(④) 놓친 뒤 기다리는 시간만 길어집니다.

4교시 · 최종 프로젝트 — 스마트 창고 시스템#

요구사항#

팀마다 같은 창고 · 같은 주문 20건을 받아 설정표 하나를 제출합니다. 설정표는 1 ~ 3교시에서 다룬 선택지와 Part 1 ~ 3 의 파라미터로 이루어집니다.

요구사항기준어긋나면
주문 20건 처리제한 시간 10 분 안에 하역까지 완료못 끝낸 건은 점수 없음
충돌 0로봇끼리 · 로봇과 선반이 부딪히지 않음 (이 모델은 칸 점유로 보장, 실물은 ch05 안전 영역)실물 시연 즉시 중단
방전 0배터리 10 % 보호 하한에 닿아 길 위에 서는 로봇이 없음1대마다 −20 점, 그 로봇이 들고 있던 주문은 미완료
사람 구역 감속출고장 2 주변(주황 칸)에서 0.3 m/s 이하들어갈 때마다 −10 점
교착운영자가 로봇을 옮기는 일이 없어야 함1번마다 −5 점 + 20 s 손실

평가판의 채점 규칙(이 강좌가 정한 예시)은 다음과 같습니다. 주문 순서 3가지(같은 20개 칸을 다른 순서로)로 돌려 평균을 냅니다. 운 좋은 순서 하나에만 맞춘 설정을 걸러 내기 위해서입니다.

  • 처리 = 2 점 × 10 분 안에 완료한 건수 (최대 40)
  • 시간 보너스 = 20건을 모두 끝냈을 때 30 × (600 s − 끝낸 시각) ÷ 600 s (최대 30)
  • 에너지 = 20 × min(1, 0.75 Wh ÷ 1건당 사용 에너지) (최대 20) — 에너지는 ch01 의 P = 45 W + 1.05 · m · v 를 로봇마다 적분
  • 안전 감점 = 사람 구역 과속 10 · 방전 20 · 교착 5 (회당)

Part 1 ~ 4 기술 통합 — 설정표의 각 칸은 어디서 왔나#

설정이 평가판의 선택지근거가 된 차시
선반 배치A 좁은 통로 4개 + 순환 / B 막다른 통로 / C 넓은 통로 3개1교시 시뮬레이터 1, ch08 코스트맵
AGV 대수1 ~ 52교시 시뮬레이터 3
배정 규칙가장 가까운 · 배터리 우선 · 라운드로빈2교시
통행 규칙구역 예약 · 일방통행 · 대기 구역2교시
최고 속도0.5 ~ 1.5 m/sch01 정지 거리, ch02 기구학, ch08 max_vel_x
사람 구역 감속지킴 / 안 지킴ch05 안전 영역 · 감속 영역
충전 시작 임계값10 ~ 40 %ch09 시뮬레이터 4
위치 추정 · 경로(이 모델에서는 완벽하다고 가정)ch04 · ch06 · ch07 · ch08 — 실물 시연에서 검증

시작 배터리는 로봇 1 ~ 5 가 11 · 64 · 47 · 82 · 29 % 입니다. 로봇 1 은 거의 비어 있고, 로봇 5 는 임계값을 어디에 두느냐에 따라 바로 충전하러 갈 수도 있습니다. 충전 속도는 분당 1 % 이고(가정), 충전을 시작하면 임계값 + 15 % 까지 채운 뒤 돌아옵니다.

예측하기: 무엇이 가장 큰 점수 차이를 만들까?#

구역 예약 + 대기 구역 · 3대 · 1.0 m/s · 감속 준수 · 임계값 20 % 를 기준으로, 다음 중 하나만 바꾼다면 점수가 가장 크게 오르는 것과 가장 크게 떨어지는 것은 무엇일까요? ① 대수 3 → 4 ② 속도 1.0 → 1.5 m/s ③ 사람 구역 감속 끄기 ④ 임계값 20 → 10 % ⑤ 배치 A → C

시뮬레이터 6 · 스마트 창고 평가판#

설정을 바꾸면 주문 순서 3가지를 바로 계산합니다. 지도는 첫 번째 순서를 재생합니다. 마음에 드는 설정은 팀 이름을 적고 팀 기록에 추가 를 눌러 아래 표에 모읍니다(이 페이지를 닫으면 지워집니다).

시뮬레이터 6 · 스마트 창고 평가판 (주문 20건, 제한 10 분, 적재 · 하역 각 8 s, 시작 배터리 11 · 64 · 47 · 82 · 29 %)
통행 규칙: · · · 안전:
배속 ·

해 볼 것

  1. 기준 만들기 — 처음 설정(A · 3대 · 규칙 없음 · 1.0 m/s · 감속 · 20 %)의 점수를 적고 ▶ 로 재생합니다. 끝까지 못 끝낸 주문 순서가 있나요? 마지막에 서 있는 로봇이 어디에 있는지 봅니다.
  2. 구역 예약 만 켜고, 이어 대기 구역 도 켭니다. 대기 구역을 켜야 20건이 모두 끝나는 이유를 재생 화면에서 찾습니다. (힌트: 주문이 다 배정된 뒤 일이 없는 로봇은 어디에 서 있나요?)
  3. 예측하기의 ① ~ ⑤ 를 하나씩 바꿔 점수를 표로 적습니다. 예측과 맞았나요? ③ 사람 구역 감속을 끄면 시간 보너스는 오르는데 합계는 어떻게 되나요?
  4. 4대 · 임계값 10 % 와 20 % 를 비교합니다. 10 % 가 점수는 높은데, 3대 · 10 % 에서는 무슨 일이 생기나요? 실제 현장이라면 어느 쪽을 제출하겠습니까?
  5. 팀별로 "교착 · 과속 · 방전 0" 을 지키면서 가장 높은 점수를 찾아 팀 기록에 추가 합니다. 같은 점수라면 총 주행 거리 · 에너지가 적은 설정이 더 좋은 설정입니다.

관찰 포인트 — 점수를 가장 크게 바꾸는 것은 로봇의 최고 속도가 아니라 시스템 규칙 입니다. 일 없는 로봇이 출고장에 서 있으면 마지막 주문이 영원히 끝나지 않고(대기 구역), 임계값 하나로 로봇 한 대가 일하거나 길 위에서 멈춥니다. 속도 1.0 → 1.5 m/s 는 적재 · 하역 · 사람 구역 감속 시간이 그대로라 몇 점밖에 오르지 않지만, 사람 구역 감속을 어기면 시간 보너스로 얻는 것보다 수십 배를 잃습니다. 대수를 늘리면 점수가 오르지만 5대부터는 이득이 줄어듭니다. 그리고 주문 순서 3가지 평균으로 보면 "한 번 운 좋게 통과한" 설정이 걸러집니다.

확인 문제 4-1

기준(A · 3대 · 구역 예약 + 대기 구역 · 1.0 m/s · 감속 · 20 %)은 57.8 점입니다. 속도를 1.5 m/s 로 올리면 59.8 점, 거기에 사람 구역 감속을 끄면 −128.8 점이 되었습니다. 이 결과에서 끌어낼 수 있는 가장 알맞은 결론은?

  1. 속도 1.5 m/s 는 위험하므로 처리량이 오히려 떨어진다
  2. 1건의 시간 대부분이 적재 · 하역 · 사람 구역 통과라서 최고 속도의 효과는 작고, 감속을 어기면 시간은 줄지만 위반 20번(−200 점)이 모든 이득을 지운다
  3. 채점 규칙이 잘못되었으니 감점을 없애야 한다
  4. 사람 구역 감속을 끄면 에너지 점수가 떨어져서 합계가 낮아진다
정답 보기② — 1.5 m/s 에서도 20건을 끝내는 시각은 484 → 455 s 정도로만 당겨집니다. 주행 외 시간(적재 8 s + 하역 8 s, 0.3 m/s 구간)이 그대로이기 때문입니다. 감속을 끄면 끝내는 시각이 약 340 s 로 크게 당겨지고 에너지 점수도 오히려 오르지만(④ 아님), 주문마다 사람 구역에 과속으로 들어가 위반이 20번 쌓입니다. 평가판의 감점은 "실물에서 이러면 시연을 멈춘다" 는 뜻이며(③), 안전 규칙은 점수와 바꾸는 값이 아닙니다.
확인 문제 4-2

4대 · 구역 예약 + 대기 구역에서 임계값 10 % 는 72.3 점, 20 % 는 66.7 점입니다. 그런데 3대에서 10 % 로 바꾸면 27.6 점으로 떨어지고 방전이 1번 생깁니다. 가장 알맞은 해석은?

  1. 10 % 가 언제나 더 좋으니 10 % 를 제출한다
  2. 11 % 로 시작한 로봇 1 이 일을 계속하므로, 4대일 때는 일이 빨리 끝나 운 좋게 버티지만 3대일 때는 오래 일하다 보호 하한에 닿는다 — 여유가 없는 설정이므로 실물에는 20 % 처럼 여유 있는 값을 쓴다
  3. 3대에서는 구역 예약이 꺼져서 방전된다
  4. 임계값은 처리량과 상관이 없다
정답 보기② — 임계값 10 % 면 11 % 로 시작한 로봇 1 이 충전하러 가지 않습니다. 4대일 때는 20건이 약 4.7 분 만에 끝나 로봇 1 이 10 % 에 닿기 전에 멈추지만, 3대일 때는 일이 길어져 방전 정지(−20 점)가 나고 그 로봇의 주문도 끝나지 않습니다. 점수가 높아도 "조금만 더 길어지면 방전" 인 설정은 실물에서 쓰지 않습니다. ch09 에서처럼 임계값은 `하한 + 최악의 미션 1회 + 충전대까지` 보다 높게 잡습니다.

실물 시연 계획서#

평가판 점수가 좋아도 실물 시연은 안전 계획서 가 통과해야 합니다. 팀마다 아래 표를 채워 제출합니다.

항목적을 것예
시연 공간크기, 바닥, 출입 통제 방법4 × 3 m, 매끈한 바닥, 출입구 1곳에 안내판
대수 · 속도 제한실물 대수, max_vel_x, 사람 구역 속도2대, 0.3 m/s, 사람 구역 0.2 m/s
비상정지 담당자로봇마다 한 명, 버튼 위치로봇 1 = 김OO (본체 버튼), 로봇 2 = 이OO
안전 영역ch05 감속 · 정지 영역 거리감속 0.6 m, 정지 0.3 m
배터리시작 전 전압, 충전 임계값25 V 이상에서 시작, 임계값 30 %
팔 연동핸드셰이크 방식, 타임아웃, 팔 작업 반경 출입 금지4단계, 타임아웃 8 s, 팔 주변 0.8 m 접근 금지
중단 기준무엇이 보이면 멈추는가위치 추정 점프, 경로 이탈 0.3 m, 사람 진입

평가판의 속도 1.0 ~ 1.5 m/s 는 시뮬레이터 안에서만 쓰는 값입니다. 실물 첫 시연은 ch09 의 Nav2 기본값(0.26 m/s) 근처에서 시작하고, 사람이 많은 교실에서는 더 낮춥니다.

실습 (시뮬레이터)#

교시마다 Playground 에서 코드를 직접 돌립니다. starter 의 TODO 를 채워 실행한 뒤 풀이 와 비교하세요. 모든 코드는 표준 라이브러리 + numpy 만 쓰며, 시뮬레이터 1 ~ 6 과 같은 모델 · 같은 가정값을 씁니다. starter 는 TODO 를 채우지 않아도 오류 없이 실행되지만 결과가 틀리게 나옵니다.

Playground 열기

실습 1-1 · 같은 면적, 세 가지 선반 배치 평가 (1교시)

시뮬레이터 1 과 같은 모델로 배치 A · B · C 의 보관 칸 · 평균 편도 시간 · 처리량을 계산하고, 입출고장 위치 두 가지에서 1등을 고릅니다. 교시 계획의 실습 "처리량이 가장 높은 선반 배치를 3가지 후보 중 고르고 근거 제시" 를 숫자로 합니다.

  • TODO 1 주문 확률 weights — 고르게(1/n) 또는 ABC(가까운 20 % 칸이 80 %)
  • TODO 2 사이클 = 2 × 평균 편도 + 적재 15 s + 하역 15 s, 처리량 = 3600 ÷ 사이클
  • 합격 조건: 입출고장 가운데에서 A 63.8 · B 40.6 · C 63.3 건/h, ABC 배치로 A 가 79.0 건/h

예측 먼저 — 입출고장을 구석으로 옮기면 C 는 몇 등일까요?

python시뮬 실행 가능
import numpy as np

AREA_W, AREA_H = 20.0, 12.0   # 창고 (m)
D = 1.0                       # 선반 깊이 (m), 칸 간격 1 m, 3단
T_HANDLE = 15.0               # 적재 15 s + 하역 15 s

def aisle_speed(w, v):
    # 통로 폭 w 에 따른 통로 속도: 0.6 m 에서 v 의 30 %, 1.4 m 이상에서 v
    f = 0.3 + 0.7 * min(1.0, max(0.0, (w - 0.6) / 0.8))
    return v * f

def slot_times(layout, w, xd, v):
    """칸마다 (편도 시간 s, 편도 거리 m) 목록. 한 통로 양쪽 두 면이므로 두 번씩 넣는다."""
    va = aisle_speed(w, v)
    m = 2 * D + w                 # 통로 하나 + 양쪽 선반 = 한 모듈 폭
    out = []
    k = 0
    if layout == "A":             # 세로 열, 아래 주통로에서 바로 진입
        while D + w / 2 + k * m + w / 2 + D <= AREA_W + 1e-9:
            xa = D + w / 2 + k * m
            for j in range(10):
                y = 2.5 + j
                dm, da = abs(xa - xd) + 1.0, y - 2.0
                out += [(dm / v + da / va, dm + da)] * 2
            k += 1
    elif layout == "B":           # 가로 열, 왼쪽 세로 통로로만 진입
        while 2 + D + w / 2 + k * m + w / 2 + D <= AREA_H + 1e-9:
            ya = 2 + D + w / 2 + k * m
            for j in range(18):
                x = 2.5 + j
                dm, da = abs(xd - 1.0) + (ya - 1.0) + 1.0, x - 2.0
                out += [(dm / v + da / va, dm + da)] * 2
            k += 1
    else:                         # C: 가로 열 + 가운데 세로 통로 (x 9 ~ 11 m)
        while 2 + D + w / 2 + k * m + w / 2 + D <= AREA_H + 1e-9:
            yb = 2 + D + w / 2 + k * m
            for j in range(9):
                for x in (0.5 + j, 11.5 + j):
                    dm, da = abs(xd - 10.0) + (yb - 1.0) + 1.0, abs(x - 10.0) - 1.0
                    out += [(dm / v + da / va, dm + da)] * 2
            k += 1
    return np.array(out)

def evaluate(layout, w=1.0, xd=10.0, v=1.0, abc=False):
    st = slot_times(layout, w, xd, v)
    order = np.argsort(st[:, 0])
    t, d = st[order, 0], st[order, 1]
    n = len(t)
    # TODO 1: 주문 확률 weights 만들기
    #   abc=False -> 모든 칸 1/n
    #   abc=True  -> 가장 가까운 20 % 칸(k 개)이 주문의 80 %, 나머지가 20 %
    weights = np.zeros(n)
    t_avg = float((t * weights).sum())
    d_avg = float((d * weights).sum())
    # TODO 2: 사이클 = 2 x 평균 편도 + 적재 + 하역, 처리량 = 3600 / 사이클
    cycle = 1.0
    throughput = 0.0
    return {"cap": n * 3, "t": t_avg, "d": d_avg, "cycle": cycle, "th": throughput}

print("배치 |  칸 | 평균 편도(s) | 사이클(s) | 처리량(건/h)")
for xd, name in ((10.0, "입출고장 가운데"), (1.0, "입출고장 왼쪽 구석")):
    print("--", name)
    best = None
    for L in "ABC":
        r = evaluate(L, w=1.0, xd=xd)
        print(f"  {L}  | {r['cap']:3d} | {r['t']:11.1f} | {r['cycle']:8.1f} | {r['th']:10.1f}")
        if best is None or r["th"] > best[1]["th"]:
            best = (L, r)
    print("  -> 처리량 1등:", best[0])

base = evaluate("A")["th"]
abc = evaluate("A", abc=True)["th"]
print(f"ABC 배치 효과 (A, 가운데): {base:.1f} -> {abc:.1f} 건/h")
  • starter 를 그대로 돌리면 평균 편도가 0, 처리량이 0 으로 나옵니다. weights 가 모두 0 이기 때문입니다.
풀이
python시뮬 실행 가능
import numpy as np

AREA_W, AREA_H = 20.0, 12.0   # 창고 (m)
D = 1.0                       # 선반 깊이 (m), 칸 간격 1 m, 3단
T_HANDLE = 15.0               # 적재 15 s + 하역 15 s

def aisle_speed(w, v):
    # 통로 폭 w 에 따른 통로 속도: 0.6 m 에서 v 의 30 %, 1.4 m 이상에서 v
    f = 0.3 + 0.7 * min(1.0, max(0.0, (w - 0.6) / 0.8))
    return v * f

def slot_times(layout, w, xd, v):
    """칸마다 (편도 시간 s, 편도 거리 m) 목록. 한 통로 양쪽 두 면이므로 두 번씩 넣는다."""
    va = aisle_speed(w, v)
    m = 2 * D + w                 # 통로 하나 + 양쪽 선반 = 한 모듈 폭
    out = []
    k = 0
    if layout == "A":             # 세로 열, 아래 주통로에서 바로 진입
        while D + w / 2 + k * m + w / 2 + D <= AREA_W + 1e-9:
            xa = D + w / 2 + k * m
            for j in range(10):
                y = 2.5 + j
                dm, da = abs(xa - xd) + 1.0, y - 2.0
                out += [(dm / v + da / va, dm + da)] * 2
            k += 1
    elif layout == "B":           # 가로 열, 왼쪽 세로 통로로만 진입
        while 2 + D + w / 2 + k * m + w / 2 + D <= AREA_H + 1e-9:
            ya = 2 + D + w / 2 + k * m
            for j in range(18):
                x = 2.5 + j
                dm, da = abs(xd - 1.0) + (ya - 1.0) + 1.0, x - 2.0
                out += [(dm / v + da / va, dm + da)] * 2
            k += 1
    else:                         # C: 가로 열 + 가운데 세로 통로 (x 9 ~ 11 m)
        while 2 + D + w / 2 + k * m + w / 2 + D <= AREA_H + 1e-9:
            yb = 2 + D + w / 2 + k * m
            for j in range(9):
                for x in (0.5 + j, 11.5 + j):
                    dm, da = abs(xd - 10.0) + (yb - 1.0) + 1.0, abs(x - 10.0) - 1.0
                    out += [(dm / v + da / va, dm + da)] * 2
            k += 1
    return np.array(out)

def evaluate(layout, w=1.0, xd=10.0, v=1.0, abc=False):
    st = slot_times(layout, w, xd, v)
    order = np.argsort(st[:, 0])
    t, d = st[order, 0], st[order, 1]
    n = len(t)
    if abc:
        k = max(1, int(round(n * 0.2)))
        weights = np.r_[np.full(k, 0.8 / k), np.full(n - k, 0.2 / (n - k))]
    else:
        weights = np.full(n, 1.0 / n)
    t_avg = float((t * weights).sum())
    d_avg = float((d * weights).sum())
    cycle = 2 * t_avg + 2 * T_HANDLE
    throughput = 3600.0 / cycle
    return {"cap": n * 3, "t": t_avg, "d": d_avg, "cycle": cycle, "th": throughput}

print("배치 |  칸 | 평균 편도(s) | 사이클(s) | 처리량(건/h)")
for xd, name in ((10.0, "입출고장 가운데"), (1.0, "입출고장 왼쪽 구석")):
    print("--", name)
    best = None
    for L in "ABC":
        r = evaluate(L, w=1.0, xd=xd)
        print(f"  {L}  | {r['cap']:3d} | {r['t']:11.1f} | {r['cycle']:8.1f} | {r['th']:10.1f}")
        if best is None or r["th"] > best[1]["th"]:
            best = (L, r)
    print("  -> 처리량 1등:", best[0])

base = evaluate("A")["th"]
abc = evaluate("A", abc=True)["th"]
print(f"ABC 배치 효과 (A, 가운데): {base:.1f} -> {abc:.1f} 건/h")
  • 예시 결과: 가운데 A 63.8 / B 40.6 / C 63.3, 구석 A 56.8 / B 50.9 / C 48.1 건/h. 두 경우 모두 A 가 1등이지만 이유가 다릅니다. 가운데에서는 C 와 거의 같고 칸이 더 많아서, 구석에서는 주통로에서 바로 들어가는 통로 덕분에 주통로 이동이 짧아서입니다.
  • 근거 쓰기 예: "같은 20 × 12 m 에서 A 는 C 와 처리량이 1 % 안쪽으로 같고 보관 칸이 11 % 많다. 입출고장 위치가 바뀌어도 1등을 지키므로 배치 변경 위험이 작다."
  • ABC 배치는 선반을 옮기지 않고 63.8 → 79.0 건/h (+24 %) 입니다. 통로를 넓히는 공사(1.0 → 1.4 m, +11 %)보다 효과가 큽니다.
실습 1-2 · 미션 상태 머신 클래스 (1교시)

시뮬레이터 2 의 표를 Python 클래스로 옮기고, 시뮬레이터가 보내는 이벤트 목록(중복 · 뒤바뀜 · 비상정지 포함)을 넣어 상태가 꼬이지 않는지 확인합니다. 확인 문제 1-3 의 guard 도 넣습니다.

  • TODO 1 비상정지 · 경로 막힘 → ERROR (멈춘 상태 저장), ERROR 에서는 reset 만 받아 저장한 상태로
  • TODO 2 표에 없는 이벤트는 무시하고 횟수 세기
  • TODO 3 IDLE 의 주문 배정에 배터리 guard — 임계값보다 낮으면 TO_CHARGE
  • 합격 조건: 출력 맨 아래 검사 세 줄이 모두 "통과"

예측 먼저 — 시나리오 [1] 에서 무시되는 이벤트는 몇 개일까요? 시뮬레이터 2 의 빨간 줄 수와 같을까요?

python시뮬 실행 가능
class MissionFSM:
    """myAGV Pro 미션 상태 머신 (시뮬레이터 2 와 같은 표)."""
    MOVING = ("TO_PICK", "TO_DROP", "TO_CHARGE")

    def __init__(self, battery=60.0, threshold=25.0):
        self.state = "IDLE"
        self.saved = None          # ERROR 에서 돌아갈 상태
        self.loaded = False
        self.battery = battery
        self.threshold = threshold
        self.done = 0
        self.ignored = 0
        self.log = []

    def next_state(self, event):
        """다음 상태를 돌려준다. 표에 없으면 None."""
        st = self.state
        # TODO 1: 비상정지(estop)는 어느 상태에서든 ERROR (이미 ERROR 면 무시)
        #         경로 막힘(blocked)은 이동 중(MOVING)일 때만 ERROR
        #         ERROR 에서는 reset 만 받아서 self.saved 로 돌아감
        low = self.battery < self.threshold
        table = {
            "IDLE": {"assign": "TO_PICK"},   # TODO 3: low 이면 TO_CHARGE (guard)
            "TO_PICK": {"arrive": "LOADING", "cancel": "IDLE"},
            "LOADING": {"loaded": "TO_DROP"},
            "TO_DROP": {"arrive": "UNLOADING"},
            "UNLOADING": {"unloaded": "TO_CHARGE" if low else "IDLE"},
            "TO_CHARGE": {"arrive": "CHARGING"},
            "CHARGING": {"charged": "IDLE"},
        }
        return table.get(st, {}).get(event)

    def handle(self, event):
        st, nx = self.state, self.next_state(event)
        if nx is None:
            # TODO 2: 무시한 횟수(self.ignored)를 세고 로그를 남긴 뒤 False 를 돌려주기
            nx = st
        if nx == "ERROR":
            self.saved = st
        if st == "LOADING" and nx == "TO_DROP":
            self.loaded = True
        if st == "UNLOADING":
            self.loaded = False
            self.done += 1
        if st in self.MOVING:
            self.battery = max(10.0, self.battery - 4.0)   # 이동 한 번에 4 % (가정)
        if st == "CHARGING":
            self.battery = 90.0
        self.state = nx
        self.log.append(f"{event:9s}: {st} -> {nx}  (배터리 {self.battery:.0f} %)")
        return True


def run(events, **kw):
    fsm = MissionFSM(**kw)
    for e in events:
        fsm.handle(e)
    for line in fsm.log:
        print("  " + line)
    print(f"  => 상태 {fsm.state}, 완료 {fsm.done}건, 무시 {fsm.ignored}번, 짐 {'있음' if fsm.loaded else '없음'}")
    return fsm


print("[1] 중복 - 뒤바뀐 이벤트 (시뮬레이터 2 시나리오 2)")
f1 = run(["assign", "loaded", "arrive", "arrive", "loaded", "cancel", "arrive", "unloaded", "unloaded"])
print("[2] 짐 실은 채 비상정지 (시나리오 3)")
f2 = run(["assign", "arrive", "loaded", "estop", "assign", "cancel", "reset", "blocked", "reset", "arrive", "unloaded"])
print("[3] 배터리 11 % 에서 주문 배정 (확인 문제 1-3)")
f3 = run(["assign", "arrive", "charged"], battery=11)

checks = [
    ("[1] 완료 1건 - 무시 4번", (f1.done, f1.ignored, f1.state) == (1, 4, "IDLE")),
    ("[2] 오류 해제 후 TO_DROP 재개 - 무시 2번", (f2.done, f2.ignored, f2.state) == (1, 2, "IDLE")),
    ("[3] 배터리 부족이면 충전부터", f3.done == 0 and f3.battery == 90.0),
]
for name, ok in checks:
    print(("통과  " if ok else "실패  ") + name)
  • starter 는 실행되지만 무시해야 할 이벤트에서 상태가 그대로 남고(TO_PICK -> TO_PICK), 비상정지를 처리하지 못해 검사 세 줄이 모두 "실패" 입니다.
풀이
python시뮬 실행 가능
class MissionFSM:
    """myAGV Pro 미션 상태 머신 (시뮬레이터 2 와 같은 표)."""
    MOVING = ("TO_PICK", "TO_DROP", "TO_CHARGE")

    def __init__(self, battery=60.0, threshold=25.0):
        self.state = "IDLE"
        self.saved = None          # ERROR 에서 돌아갈 상태
        self.loaded = False
        self.battery = battery
        self.threshold = threshold
        self.done = 0
        self.ignored = 0
        self.log = []

    def next_state(self, event):
        """다음 상태를 돌려준다. 표에 없으면 None."""
        st = self.state
        if event == "estop":
            return None if st == "ERROR" else "ERROR"
        if event == "blocked":
            return "ERROR" if st in self.MOVING else None
        if st == "ERROR":
            return self.saved if event == "reset" else None
        low = self.battery < self.threshold
        table = {
            "IDLE": {"assign": "TO_CHARGE" if low else "TO_PICK"},   # guard
            "TO_PICK": {"arrive": "LOADING", "cancel": "IDLE"},
            "LOADING": {"loaded": "TO_DROP"},
            "TO_DROP": {"arrive": "UNLOADING"},
            "UNLOADING": {"unloaded": "TO_CHARGE" if low else "IDLE"},
            "TO_CHARGE": {"arrive": "CHARGING"},
            "CHARGING": {"charged": "IDLE"},
        }
        return table.get(st, {}).get(event)

    def handle(self, event):
        st, nx = self.state, self.next_state(event)
        if nx is None:
            self.ignored += 1
            self.log.append(f"{event:9s}: {st} 에서 정의되지 않음 -> 무시")
            return False
        if nx == "ERROR":
            self.saved = st
        if st == "LOADING" and nx == "TO_DROP":
            self.loaded = True
        if st == "UNLOADING":
            self.loaded = False
            self.done += 1
        if st in self.MOVING:
            self.battery = max(10.0, self.battery - 4.0)   # 이동 한 번에 4 % (가정)
        if st == "CHARGING":
            self.battery = 90.0
        self.state = nx
        self.log.append(f"{event:9s}: {st} -> {nx}  (배터리 {self.battery:.0f} %)")
        return True


def run(events, **kw):
    fsm = MissionFSM(**kw)
    for e in events:
        fsm.handle(e)
    for line in fsm.log:
        print("  " + line)
    print(f"  => 상태 {fsm.state}, 완료 {fsm.done}건, 무시 {fsm.ignored}번, 짐 {'있음' if fsm.loaded else '없음'}")
    return fsm


print("[1] 중복 - 뒤바뀐 이벤트 (시뮬레이터 2 시나리오 2)")
f1 = run(["assign", "loaded", "arrive", "arrive", "loaded", "cancel", "arrive", "unloaded", "unloaded"])
print("[2] 짐 실은 채 비상정지 (시나리오 3)")
f2 = run(["assign", "arrive", "loaded", "estop", "assign", "cancel", "reset", "blocked", "reset", "arrive", "unloaded"])
print("[3] 배터리 11 % 에서 주문 배정 (확인 문제 1-3)")
f3 = run(["assign", "arrive", "charged"], battery=11)

checks = [
    ("[1] 완료 1건 - 무시 4번", (f1.done, f1.ignored, f1.state) == (1, 4, "IDLE")),
    ("[2] 오류 해제 후 TO_DROP 재개 - 무시 2번", (f2.done, f2.ignored, f2.state) == (1, 2, "IDLE")),
    ("[3] 배터리 부족이면 충전부터", f3.done == 0 and f3.battery == 90.0),
]
for name, ok in checks:
    print(("통과  " if ok else "실패  ") + name)
  • [1] 에서 무시되는 이벤트는 4개(도착 전 적재 완료 · 중복 도착 · 짐 실은 채 취소 · 중복 하역 완료)로 시뮬레이터 2 와 같습니다.
  • [2] 에서 오류 해제 후 TO_DROP 으로 돌아가는 것이 핵심입니다. 짐을 실은 로봇을 IDLE 로 보내면 짐이 실린 채 새 주문을 받습니다.
  • 실제 미션 관리자는 이 클래스를 로봇마다 하나씩 두고, Nav2 액션 결과(ch09: 성공 → "도착", 실패 · 취소 → "경로 막힘")와 IO 입력을 이벤트로 바꿔 handle() 에 넣습니다.
실습 2-1 · 배정 규칙 세 가지 구현과 비교 (2교시)

교통(서로 막는 일)을 뺀 단순 모델로 3시간 운용을 돌려, 배정 규칙만의 차이를 봅니다. 도착률 3 건/분은 로봇 3대가 처리할 수 있는 양이라 대기 로봇이 자주 둘 이상 생깁니다.

  • TODO 1 ~ 3 pick_robot() — 가장 가까운 로봇 · 배터리 우선 · 라운드로빈
  • 합격 조건: 세 규칙의 줄이 서로 다르고, 빈 차 주행은 nearest 가, 배터리 차는 battery 가, 로봇별 건수의 고르기는 rr 가 가장 좋음

예측 먼저 — 완료 건수는 세 규칙에서 얼마나 다를까요?

python시뮬 실행 가능
import random

# 시뮬레이터 3 과 같은 12 x 9 창고를 좌표로만 단순화 (교통 없음: 서로 막지 않음)
SLOTS = [(x, y) for x in (1, 4, 7, 10) for y in range(2, 7)]   # 선반 통로 칸 20개
DOCKS = [(3, 0), (8, 0)]                                       # 출고장 2곳
LOAD = UNLOAD = 8.0                                            # s
V = 1.0                                                        # m/s

def dist(a, b):
    # 주통로를 따라가는 맨해튼 거리 (아래 주통로 y = 1 을 거친다고 가정)
    if a[0] == b[0]:
        return abs(a[1] - b[1])
    return abs(a[1] - 1) + abs(a[0] - b[0]) + abs(b[1] - 1)

def power(moving, loaded):
    # ch01 근사식 P = 45 + 1.05 * m * v  (W), 빈 차 40 kg, 짐 20 kg
    return 45.0 + (1.05 * (40 + (20 if loaded else 0)) * V if moving else 0.0)

class Robot:
    def __init__(self, rid, pos, bat):
        self.id, self.pos, self.bat = rid, pos, bat
        self.busy_until = 0.0
        self.empty_m = 0.0
        self.done = 0

def pick_robot(rule, idle, order, rr_state):
    """대기 로봇 목록 idle 에서 주문 order 를 맡을 로봇을 고른다."""
    slot = order["slot"]
    # TODO 1: rule == "nearest" -> dist(r.pos, slot) 가 가장 작은 로봇 (같으면 id 작은 쪽)
    # TODO 2: rule == "battery" -> r.bat 가 가장 큰 로봇
    # TODO 3: rule == "rr"      -> rr_state["next"] 번부터 차례로 보며 대기 중인 첫 로봇,
    #                              고른 뒤 rr_state["next"] = (그 id + 1) % n
    return idle[0]

def simulate(rule, n_robots=3, rate_per_min=3.0, T=3 * 3600, seed=11):
    rnd = random.Random(seed)
    robots = [Robot(i, DOCKS[i % 2], b) for i, b in zip(range(n_robots), (80, 65, 50, 35, 90))]
    orders, t = [], 0.0
    while True:
        t += rnd.expovariate(rate_per_min / 60.0)
        if t > T:
            break
        orders.append({"t": t, "slot": rnd.choice(SLOTS), "dock": rnd.choice(DOCKS)})
    queue, oi, waits, rr = [], 0, [], {"next": 0, "n": n_robots}
    for step in range(T):
        now = float(step)
        while oi < len(orders) and orders[oi]["t"] <= now:
            queue.append(orders[oi]); oi += 1
        while queue:
            idle = [r for r in robots if r.busy_until <= now]
            if not idle:
                break
            o = queue.pop(0)
            r = pick_robot(rule, idle, o, rr)
            d1, d2 = dist(r.pos, o["slot"]), dist(o["slot"], o["dock"])
            dur = d1 / V + LOAD + d2 / V + UNLOAD
            # 배터리: 빈 차 이동 + 짐 실은 이동 + 적재 · 하역 동안 정지 (480 Wh = 100 %)
            wh = (power(True, False) * d1 / V + power(True, True) * d2 / V + power(False, False) * (LOAD + UNLOAD)) / 3600
            r.bat -= wh / 480 * 100
            r.busy_until = now + dur
            r.empty_m += d1
            r.pos = o["dock"]
            r.done += 1
            waits.append(now - o["t"])
        for r in robots:                       # 대기 중 소비 45 W
            if r.busy_until <= now:
                r.bat -= 45.0 / 3600 / 480 * 100
    done = sum(r.done for r in robots)
    return {
        "done": done,
        "wait": sum(waits) / max(1, len(waits)),
        "empty": sum(r.empty_m for r in robots),
        "spread": max(r.bat for r in robots) - min(r.bat for r in robots),
        "per": [r.done for r in robots],
        "bat": [round(r.bat, 1) for r in robots],
    }

print("규칙      | 완료 | 평균 대기(s) | 빈 차 주행(m) | 배터리 차(%) | 로봇별 건수 | 끝 배터리")
for rule in ("nearest", "battery", "rr"):
    r = simulate(rule)
    print(f"{rule:9s} | {r['done']:4d} | {r['wait']:11.1f} | {r['empty']:12.0f} | {r['spread']:11.1f} | {r['per']} | {r['bat']}")
  • starter 는 늘 첫 번째 대기 로봇을 고르므로 세 줄이 똑같이 나옵니다.
풀이
python시뮬 실행 가능
import random

# 시뮬레이터 3 과 같은 12 x 9 창고를 좌표로만 단순화 (교통 없음: 서로 막지 않음)
SLOTS = [(x, y) for x in (1, 4, 7, 10) for y in range(2, 7)]   # 선반 통로 칸 20개
DOCKS = [(3, 0), (8, 0)]                                       # 출고장 2곳
LOAD = UNLOAD = 8.0                                            # s
V = 1.0                                                        # m/s

def dist(a, b):
    # 주통로를 따라가는 맨해튼 거리 (아래 주통로 y = 1 을 거친다고 가정)
    if a[0] == b[0]:
        return abs(a[1] - b[1])
    return abs(a[1] - 1) + abs(a[0] - b[0]) + abs(b[1] - 1)

def power(moving, loaded):
    # ch01 근사식 P = 45 + 1.05 * m * v  (W), 빈 차 40 kg, 짐 20 kg
    return 45.0 + (1.05 * (40 + (20 if loaded else 0)) * V if moving else 0.0)

class Robot:
    def __init__(self, rid, pos, bat):
        self.id, self.pos, self.bat = rid, pos, bat
        self.busy_until = 0.0
        self.empty_m = 0.0
        self.done = 0

def pick_robot(rule, idle, order, rr_state):
    """대기 로봇 목록 idle 에서 주문 order 를 맡을 로봇을 고른다."""
    slot = order["slot"]
    if rule == "nearest":
        return min(idle, key=lambda r: (dist(r.pos, slot), r.id))
    if rule == "battery":
        return max(idle, key=lambda r: (r.bat, -r.id))
    # round-robin: rr_state["next"] 번부터 차례로 보고, 대기 중인 첫 로봇
    n = rr_state["n"]
    for k in range(n):
        rid = (rr_state["next"] + k) % n
        for r in idle:
            if r.id == rid:
                rr_state["next"] = (rid + 1) % n
                return r
    return idle[0]

def simulate(rule, n_robots=3, rate_per_min=3.0, T=3 * 3600, seed=11):
    rnd = random.Random(seed)
    robots = [Robot(i, DOCKS[i % 2], b) for i, b in zip(range(n_robots), (80, 65, 50, 35, 90))]
    orders, t = [], 0.0
    while True:
        t += rnd.expovariate(rate_per_min / 60.0)
        if t > T:
            break
        orders.append({"t": t, "slot": rnd.choice(SLOTS), "dock": rnd.choice(DOCKS)})
    queue, oi, waits, rr = [], 0, [], {"next": 0, "n": n_robots}
    for step in range(T):
        now = float(step)
        while oi < len(orders) and orders[oi]["t"] <= now:
            queue.append(orders[oi]); oi += 1
        while queue:
            idle = [r for r in robots if r.busy_until <= now]
            if not idle:
                break
            o = queue.pop(0)
            r = pick_robot(rule, idle, o, rr)
            d1, d2 = dist(r.pos, o["slot"]), dist(o["slot"], o["dock"])
            dur = d1 / V + LOAD + d2 / V + UNLOAD
            # 배터리: 빈 차 이동 + 짐 실은 이동 + 적재 · 하역 동안 정지 (480 Wh = 100 %)
            wh = (power(True, False) * d1 / V + power(True, True) * d2 / V + power(False, False) * (LOAD + UNLOAD)) / 3600
            r.bat -= wh / 480 * 100
            r.busy_until = now + dur
            r.empty_m += d1
            r.pos = o["dock"]
            r.done += 1
            waits.append(now - o["t"])
        for r in robots:                       # 대기 중 소비 45 W
            if r.busy_until <= now:
                r.bat -= 45.0 / 3600 / 480 * 100
    done = sum(r.done for r in robots)
    return {
        "done": done,
        "wait": sum(waits) / max(1, len(waits)),
        "empty": sum(r.empty_m for r in robots),
        "spread": max(r.bat for r in robots) - min(r.bat for r in robots),
        "per": [r.done for r in robots],
        "bat": [round(r.bat, 1) for r in robots],
    }

print("규칙      | 완료 | 평균 대기(s) | 빈 차 주행(m) | 배터리 차(%) | 로봇별 건수 | 끝 배터리")
for rule in ("nearest", "battery", "rr"):
    r = simulate(rule)
    print(f"{rule:9s} | {r['done']:4d} | {r['wait']:11.1f} | {r['empty']:12.0f} | {r['spread']:11.1f} | {r['per']} | {r['bat']}")
  • 예시 결과: 완료 572 ~ 573 건으로 거의 같습니다(주문 수가 정해져 있으므로). 빈 차 주행 nearest 3 898 m < battery 4 236 m < rr 4 280 m, 끝 배터리 차 battery 24.9 % < nearest 27.0 % < rr 29.6 %, 로봇별 건수는 rr 가 190 · 189 · 194 로 가장 고릅니다.
  • 라운드로빈은 일을 "건수" 로 고르게 나누지만 시작 배터리가 다른 것을 보지 않아, 가장 낮던 로봇이 가장 많이 떨어집니다(13.2 %).
  • 결론: 처리량이 같다면 빈 차 주행(= 에너지 · 혼잡)을 줄이는 nearest 를 기본으로, 배터리 조건을 guard 로 거는 조합이 실무에서 많이 쓰입니다. 시뮬레이터 3 에서 주문이 넘칠 때 규칙 차이가 거의 없던 것과 비교하세요.
실습 2-2 · 교착 탐지기와 구역 예약 검사 (2교시)

시뮬레이터 3 의 한 순간을 "로봇 → 기다리는 로봇" 그래프(wait-for graph)로 바꾸고, 순환이 있으면 교착으로 판정합니다. 이어 구역 예약 규칙("두 칸 앞에 남의 구역이 있으면 지금 칸에서 기다린다")을 함수로 만듭니다.

  • TODO 1 find_cycle() — DFS 로 순환 찾기 (보는 중인 곳으로 돌아오면 순환)
  • TODO 2 needs_reservation() — 앞 두 칸 안의 구역이 다른 로봇 것이면 (True, 구역)
  • 합격 조건: 네 장면 중 "적재 중인 로봇 뒤에서 대기" 만 교착이 아니고, 마지막 두 줄이 (True, 'aisle1'), (False, None)

예측 먼저 — "출고장 앞 막힘" 은 로봇 셋 중 누구와 누구의 순환일까요?

python시뮬 실행 가능
# 교착 탐지기: "누가 누구를 기다리는가(wait-for)" 그래프에서 순환을 찾는다.
# 시뮬레이터 3 의 한 순간을 글로 옮긴 장면 4개.
# 칸 이름: A1-3 = 1번 통로 3번째 칸, C(4,1) = 아래 주통로 x=4, D2 = 출고장 2
SCENES = {
    "통로 정면 대치": {
        "pos": {1: "A1-3", 2: "A1-4"},
        "want": {1: "A1-4", 2: "A1-3"},
    },
    "적재 중인 로봇 뒤에서 대기 (정체)": {
        "pos": {1: "A2-2", 2: "A2-3"},
        "want": {1: "A2-3", 2: None},          # 2 는 적재 중 (움직일 생각 없음)
    },
    "출고장 앞 막힘": {
        "pos": {1: "D2", 2: "C(8,1)", 3: "C(8,1)"},
        "want": {1: "C(8,1)", 2: "D2", 3: "D2"},
    },
    "세 대 순환": {
        "pos": {1: "X", 2: "Y", 3: "Z"},
        "want": {1: "Y", 2: "Z", 3: "X"},
    },
}
CAP = {"C(8,1)": 2}            # 주통로 칸은 두 대, 나머지는 한 대

def wait_for(scene):
    """로봇 -> 기다리는 로봇들 (원하는 칸이 꽉 찼을 때 그 칸에 있는 로봇)."""
    pos, want = scene["pos"], scene["want"]
    g = {r: [] for r in pos}
    for r, cell in want.items():
        if cell is None:
            continue
        occupants = [o for o, c in pos.items() if c == cell and o != r]
        if len(occupants) >= CAP.get(cell, 1):
            g[r] = occupants
    return g

def find_cycle(g):
    """순환이 있으면 순환에 든 로봇 목록, 없으면 []. (DFS + 방문 중 표시)"""
    # TODO 1: 깊이 우선 탐색(DFS)으로 순환 찾기
    #   color: 0 = 안 봄, 1 = 보는 중(스택에 있음), 2 = 끝
    #   u 에서 v 로 갈 때 color[v] == 1 이면 스택의 v 부터 끝까지가 순환
    return []

def needs_reservation(path, zones, holder, me):
    """구역 예약 규칙: 다음 두 칸 안에 들어갈 구역이 다른 로봇 것이면 지금 칸에서 기다린다."""
    # TODO 2: path 의 앞 두 칸 중 구역(zones)에 속한 칸이 있고,
    #         그 구역의 holder 가 None 도 me 도 아니면 (True, 구역) 을 돌려주기
    return False, None

for name, sc in SCENES.items():
    g = wait_for(sc)
    cyc = find_cycle(g)
    edges = ", ".join(f"{r}->{v}" for r, vs in g.items() for v in vs) or "(없음)"
    print(f"{name:22s} wait-for: {edges:22s} => " + (f"교착! 순환 {cyc}" if cyc else "교착 아님"))

zones = {"A1-2": "aisle1", "A1-3": "aisle1", "A1-4": "aisle1"}
print(needs_reservation(["C(1,1)", "A1-2"], zones, {"aisle1": 2}, me=1))
print(needs_reservation(["C(1,1)", "A1-2"], zones, {"aisle1": None}, me=1))
  • starter 는 모든 장면을 "교착 아님" 으로, 예약 검사를 모두 (False, None) 으로 냅니다.
풀이
python시뮬 실행 가능
# 교착 탐지기: "누가 누구를 기다리는가(wait-for)" 그래프에서 순환을 찾는다.
# 시뮬레이터 3 의 한 순간을 글로 옮긴 장면 4개.
# 칸 이름: A1-3 = 1번 통로 3번째 칸, C(4,1) = 아래 주통로 x=4, D2 = 출고장 2
SCENES = {
    "통로 정면 대치": {
        "pos": {1: "A1-3", 2: "A1-4"},
        "want": {1: "A1-4", 2: "A1-3"},
    },
    "적재 중인 로봇 뒤에서 대기 (정체)": {
        "pos": {1: "A2-2", 2: "A2-3"},
        "want": {1: "A2-3", 2: None},          # 2 는 적재 중 (움직일 생각 없음)
    },
    "출고장 앞 막힘": {
        "pos": {1: "D2", 2: "C(8,1)", 3: "C(8,1)"},
        "want": {1: "C(8,1)", 2: "D2", 3: "D2"},
    },
    "세 대 순환": {
        "pos": {1: "X", 2: "Y", 3: "Z"},
        "want": {1: "Y", 2: "Z", 3: "X"},
    },
}
CAP = {"C(8,1)": 2}            # 주통로 칸은 두 대, 나머지는 한 대

def wait_for(scene):
    """로봇 -> 기다리는 로봇들 (원하는 칸이 꽉 찼을 때 그 칸에 있는 로봇)."""
    pos, want = scene["pos"], scene["want"]
    g = {r: [] for r in pos}
    for r, cell in want.items():
        if cell is None:
            continue
        occupants = [o for o, c in pos.items() if c == cell and o != r]
        if len(occupants) >= CAP.get(cell, 1):
            g[r] = occupants
    return g

def find_cycle(g):
    """순환이 있으면 순환에 든 로봇 목록, 없으면 []. (DFS + 방문 중 표시)"""
    color = {r: 0 for r in g}          # 0 = 안 봄, 1 = 보는 중, 2 = 끝
    stack = []

    def dfs(u):
        color[u] = 1
        stack.append(u)
        for v in g[u]:
            if color[v] == 1:                      # 보는 중인 곳으로 돌아옴 = 순환
                return stack[stack.index(v):]
            if color[v] == 0:
                c = dfs(v)
                if c:
                    return c
        stack.pop()
        color[u] = 2
        return []

    for r in g:
        if color[r] == 0:
            c = dfs(r)
            if c:
                return c
    return []

def needs_reservation(path, zones, holder, me):
    """구역 예약 규칙: 다음 두 칸 안에 들어갈 구역이 다른 로봇 것이면 지금 칸에서 기다린다."""
    for cell in path[:2]:
        z = zones.get(cell)
        if z is not None and holder.get(z) not in (None, me):
            return True, z
    return False, None

for name, sc in SCENES.items():
    g = wait_for(sc)
    cyc = find_cycle(g)
    edges = ", ".join(f"{r}->{v}" for r, vs in g.items() for v in vs) or "(없음)"
    print(f"{name:22s} wait-for: {edges:22s} => " + (f"교착! 순환 {cyc}" if cyc else "교착 아님"))

zones = {"A1-2": "aisle1", "A1-3": "aisle1", "A1-4": "aisle1"}
print(needs_reservation(["C(1,1)", "A1-2"], zones, {"aisle1": 2}, me=1))
print(needs_reservation(["C(1,1)", "A1-2"], zones, {"aisle1": None}, me=1))
  • 정체와 교착의 차이: "적재 중인 로봇 뒤" 는 1 → 2 화살표만 있고 2 는 아무도 기다리지 않으므로 시간이 지나면 풀립니다. 순환이 있어야 교착입니다.
  • "출고장 앞 막힘" 은 1 이 주통로 칸(두 대 꽉 참)을 기다리고 그 칸의 2 · 3 이 출고장(1 이 있음)을 기다리므로 1 ↔ 2 (그리고 1 ↔ 3) 순환입니다. 시뮬레이터 3 에서 X 가 출고장 앞에 많이 찍히던 이유입니다.
  • 시뮬레이터 3 의 엔진도 같은 방법(5 s 이상 서로 기다리는 순환)으로 교착을 세고, 구역 예약은 needs_reservation 처럼 들어가기 한 칸 전에 검사합니다. 입구 칸에서 기다리면 그 칸이 막혀 나오려는 로봇과 새 교착이 생기기 때문입니다.
실습 3-1 · 도킹 보정 방법 8가지 비교 (3교시)

시뮬레이터 4 와 같은 모델을 numpy 로 2만 번 돌려, 오차 ±1 · ±3 · ±5 cm 에서 보정 조합 8가지를 "시간당 성공 피킹" 으로 순위 매깁니다. 교시 계획의 실습 "도킹 오차를 줄이기 위한 방법(저속 접근 · 횡이동 미세 보정 · 마커) 효과 비교" 입니다.

  • TODO 1 저속 접근: 오차 σ 절반, +4 s
  • TODO 2 횡이동 미세 보정: 좌우 σ 0.3 cm, 방향 σ 0.2°, +3 s
  • TODO 3 마커: +2 s, 어긋남이 4 cm(시야) 이내일 때만 남은 오차 σ 0.2 cm 로 판정
  • 합격 조건: 오차별 1등이 서로 다르게 나오고(±1: 마커, ±3: 횡이동 + 마커, ±5: 저속 + 마커), 팔이 길수록 보정 없음 성공률이 낮음

예측 먼저 — "세 가지 모두" 는 몇 등일까요?

python시뮬 실행 가능
import numpy as np

T_BASE, T_RECOVER, FOV = 18.0, 60.0, 4.0     # s, s, cm  (시뮬레이터 4 와 같은 가정)
ARMS = {"myCobot 320": 25.0, "myCobot Pro 630": 40.0, "myArm M750": 45.0}   # 집는 거리 L (cm)

def docking(e_cm, L_cm, grip_cm, slow=False, lateral=False, marker=False, n=20000, seed=0):
    """도킹 n 번 -> (성공률, 1회 시간 s, 시간당 성공 피킹)."""
    rng = np.random.default_rng(seed)
    s = e_cm / 2.0                           # ±e 가 95 % -> sigma = e / 2
    sth = np.radians(0.8 * e_cm)             # 방향 오차 sigma (가정: 1 cm 당 0.8 도)
    t = T_BASE
    # TODO 1: slow 이면 s, sth 를 절반으로, t 에 4 s 더하기
    ex, ey, th = rng.normal(0, s, n), rng.normal(0, s, n), rng.normal(0, sth, n)
    # TODO 2: lateral 이면 ey 를 sigma 0.3 cm, th 를 sigma 0.2 도로 다시 뽑고 t += 3
    dx, dy = ex, ey + L_cm * th               # 팔 기준 물건이 움직인 양
    off = np.hypot(dx, dy)
    # TODO 3: marker 이면 t += 2, off <= FOV 인 경우만 남은 오차(sigma 0.2 cm)로 판정
    ok = off <= grip_cm
    p = float(ok.mean())
    per_hour = 3600.0 * p / (t + (1.0 - p) * T_RECOVER)
    return p, t, per_hour

COMBOS = [(0, 0, 0), (1, 0, 0), (0, 1, 0), (0, 0, 1), (1, 1, 0), (1, 0, 1), (0, 1, 1), (1, 1, 1)]
NAME = ("저속", "횡이동", "마커")

def table(arm, e, grip=1.0):
    L = ARMS[arm]
    rows = []
    for c in COMBOS:
        p, t, ph = docking(e, L, grip, *map(bool, c))
        label = " + ".join(n for n, on in zip(NAME, c) if on) or "보정 없음"
        rows.append((ph, label, p, t))
    rows.sort(reverse=True)
    print(f"--- {arm}, 오차 +-{e} cm, 그리퍼 허용 {grip} cm")
    for ph, label, p, t in rows:
        print(f"  {label:14s} 성공 {p*100:5.1f} %  {t:4.0f} s  -> {ph:6.1f} 건/h")
    return rows[0][1]

best = {}
for e in (1, 3, 5):
    best[e] = table("myCobot 320", e)
print("오차별 1등:", best)

# 팔 길이 효과: 보정 없음, +-3 cm
for arm in ARMS:
    p, _, _ = docking(3, ARMS[arm], 1.0)
    print(f"{arm:16s} 보정 없음 +-3 cm 성공률 {p*100:5.1f} %")
  • starter 는 보정을 켜도 아무것도 바뀌지 않아 8줄의 성공률이 같고, 시간만 18 s 로 같습니다.
풀이
python시뮬 실행 가능
import numpy as np

T_BASE, T_RECOVER, FOV = 18.0, 60.0, 4.0     # s, s, cm  (시뮬레이터 4 와 같은 가정)
ARMS = {"myCobot 320": 25.0, "myCobot Pro 630": 40.0, "myArm M750": 45.0}   # 집는 거리 L (cm)

def docking(e_cm, L_cm, grip_cm, slow=False, lateral=False, marker=False, n=20000, seed=0):
    """도킹 n 번 -> (성공률, 1회 시간 s, 시간당 성공 피킹)."""
    rng = np.random.default_rng(seed)
    s = e_cm / 2.0                           # ±e 가 95 % -> sigma = e / 2
    sth = np.radians(0.8 * e_cm)             # 방향 오차 sigma (가정: 1 cm 당 0.8 도)
    t = T_BASE
    if slow:
        s, sth, t = s * 0.5, sth * 0.5, t + 4.0
    ex, ey, th = rng.normal(0, s, n), rng.normal(0, s, n), rng.normal(0, sth, n)
    if lateral:
        ey = rng.normal(0, 0.3, n)
        th = rng.normal(0, np.radians(0.2), n)
        t += 3.0
    dx, dy = ex, ey + L_cm * th               # 팔 기준 물건이 움직인 양
    off = np.hypot(dx, dy)
    if marker:
        t += 2.0
        resid = np.hypot(rng.normal(0, 0.2, n), rng.normal(0, 0.2, n))
        ok = (off <= FOV) & (resid <= grip_cm)
    else:
        ok = off <= grip_cm
    p = float(ok.mean())
    per_hour = 3600.0 * p / (t + (1.0 - p) * T_RECOVER)
    return p, t, per_hour

COMBOS = [(0, 0, 0), (1, 0, 0), (0, 1, 0), (0, 0, 1), (1, 1, 0), (1, 0, 1), (0, 1, 1), (1, 1, 1)]
NAME = ("저속", "횡이동", "마커")

def table(arm, e, grip=1.0):
    L = ARMS[arm]
    rows = []
    for c in COMBOS:
        p, t, ph = docking(e, L, grip, *map(bool, c))
        label = " + ".join(n for n, on in zip(NAME, c) if on) or "보정 없음"
        rows.append((ph, label, p, t))
    rows.sort(reverse=True)
    print(f"--- {arm}, 오차 +-{e} cm, 그리퍼 허용 {grip} cm")
    for ph, label, p, t in rows:
        print(f"  {label:14s} 성공 {p*100:5.1f} %  {t:4.0f} s  -> {ph:6.1f} 건/h")
    return rows[0][1]

best = {}
for e in (1, 3, 5):
    best[e] = table("myCobot 320", e)
print("오차별 1등:", best)

# 팔 길이 효과: 보정 없음, +-3 cm
for arm in ARMS:
    p, _, _ = docking(3, ARMS[arm], 1.0)
    print(f"{arm:16s} 보정 없음 +-3 cm 성공률 {p*100:5.1f} %")
  • 예시 결과(±5 cm): 저속 + 마커 98.2 % · 141 건/h 가 1등, 세 가지 모두 99.9 % · 133 건/h 가 2등, 마커만 64.5 % · 56 건/h. 세 가지를 다 켜면 성공률은 가장 높지만 1회 27 s 라서 1등이 아닙니다.
  • 오차가 작을수록 "가장 싼 보정 하나" 가, 클수록 "큰 오차를 줄이는 것 + 작은 오차를 지우는 것" 의 조합이 이깁니다. 횡이동은 방향 오차까지 줄이므로 팔이 길수록(M750) 가치가 커집니다.
  • 실물에서는 이 표의 가정값(σ, 시간)을 직접 재서 바꿔 넣습니다. 실물 실습 2 가 그 측정입니다.
실습 3-2 · AGV 쪽 핸드셰이크 상태 머신 (3교시)

시뮬레이터 5 를 1 ms 단위 Python 으로 옮기고, AGV 쪽 규칙(디바운스 · 4단계 응답)을 직접 써 넣습니다. 폴링 위상 200가지로 놓침 · 위험 출발을 셉니다.

  • TODO 1 디바운스: DONE 이 연속 debounce 번 1 이어야 인정
  • TODO 2 level 모드: DONE 을 보면 바로 떠나지 말고 ACK 로 가서 REQ 를 내리고, DONE 이 내려가면 출발
  • 합격 조건: 펄스 100 ms · 폴링 200 ms 에서 놓침이 절반쯤, level 은 폴링 1 000 ms 에서도 놓침 0, 잡음 + 디바운스 2번에서 위험 0

예측 먼저 — 폴링 1 000 ms · 펄스 300 ms 이면 200가지 중 몇 번 성공할까요?

python시뮬 실행 가능
import random

def simulate(mode, poll_ms, pulse_ms=100, arm_ms=2000, timeout_ms=6000, phase=0, glitch=False, debounce=1):
    """1 ms 단위 핸드셰이크 시뮬레이션 (시뮬레이터 5 와 같은 모델).
    mode: "pulse" | "level"   반환: ("ok" | "timeout" | "danger", 출발 시각 ms)"""
    TA = 1000                         # AGV 도착 (REQ = 1)
    req, done = 0, 0
    arm_start = arm_end = done_off = -1
    agv = "WAIT"                       # WAIT -> (ACK) -> GONE / ERR
    seen, req_off = 0, -1
    for t in range(0, 10001):
        if t == TA:
            req = 1                                   # agv.set_pin_output(1, 1)
        if t == req_off:
            req = 0                                   # agv.set_pin_output(1, 0)
        if t % 50 == 0:                               # 팔 컨트롤러 50 ms 폴링
            if arm_start < 0 and req == 1:
                arm_start, arm_end = t, t + arm_ms
            if mode == "level" and done == 1 and req == 0 and done_off < 0:
                done_off = t                          # 팔: REQ 내려감 확인 -> DONE 내림
        if t == arm_end:
            done = 1
            if mode == "pulse":
                done_off = t + pulse_ms
        if done_off >= 0 and t >= done_off:
            done = 0
        line = 1 if (glitch and 1600 <= t < 1620) else done
        if agv in ("WAIT", "ACK") and t >= TA + phase and (t - TA - phase) % poll_ms == 0:
            v = line                                  # agv.get_pin_input(1)
            if agv == "WAIT":
                # TODO 1: 디바운스 - v 가 연속 debounce 번 1 일 때만 인정 (seen 으로 세기)
                # TODO 2: level 모드면 바로 떠나지 말고 agv = "ACK", req_off = t + 1 (REQ 내림)
                if v:
                    return ("danger" if t < arm_end else "ok"), t
            else:                                     # ACK: DONE 이 내려가길 기다림
                seen = seen + 1 if not v else 0
                if seen >= debounce:
                    return ("danger" if t < arm_end else "ok"), t
        if agv in ("WAIT", "ACK") and t >= TA + timeout_ms:
            return "timeout", t
    return "timeout", 10000

def sweep(mode, poll_ms, n=200, **kw):
    rnd = random.Random(1)
    c = {"ok": 0, "timeout": 0, "danger": 0}
    for _ in range(n):
        r, _ = simulate(mode, poll_ms, phase=rnd.randrange(poll_ms), **kw)
        c[r] += 1
    return c

print("방식   폴링  펄스폭  | 정상 / 놓침 / 위험 (위상 200가지)")
for poll, pulse in ((200, 100), (200, 200), (200, 300), (1000, 300)):
    print(f"pulse  {poll:4d}  {pulse:4d}   |", sweep("pulse", poll, pulse_ms=pulse))
for poll in (200, 1000):
    print(f"level  {poll:4d}    -    |", sweep("level", poll))
print("잡음 + 펄스 300, 폴링 20 ms :", sweep("pulse", 20, pulse_ms=300, glitch=True))
print("  + 디바운스 2번          :", sweep("pulse", 20, pulse_ms=300, glitch=True, debounce=2))
  • starter 는 level 모드도 펄스처럼 DONE 을 보자마자 떠나고, 디바운스가 없어 잡음에 200번 모두 "위험" 이 납니다.
풀이
python시뮬 실행 가능
import random

def simulate(mode, poll_ms, pulse_ms=100, arm_ms=2000, timeout_ms=6000, phase=0, glitch=False, debounce=1):
    """1 ms 단위 핸드셰이크 시뮬레이션 (시뮬레이터 5 와 같은 모델).
    mode: "pulse" | "level"   반환: ("ok" | "timeout" | "danger", 출발 시각 ms)"""
    TA = 1000                         # AGV 도착 (REQ = 1)
    req, done = 0, 0
    arm_start = arm_end = done_off = -1
    agv = "WAIT"                       # WAIT -> (ACK) -> GONE / ERR
    seen, req_off = 0, -1
    for t in range(0, 10001):
        if t == TA:
            req = 1                                   # agv.set_pin_output(1, 1)
        if t == req_off:
            req = 0                                   # agv.set_pin_output(1, 0)
        if t % 50 == 0:                               # 팔 컨트롤러 50 ms 폴링
            if arm_start < 0 and req == 1:
                arm_start, arm_end = t, t + arm_ms
            if mode == "level" and done == 1 and req == 0 and done_off < 0:
                done_off = t                          # 팔: REQ 내려감 확인 -> DONE 내림
        if t == arm_end:
            done = 1
            if mode == "pulse":
                done_off = t + pulse_ms
        if done_off >= 0 and t >= done_off:
            done = 0
        line = 1 if (glitch and 1600 <= t < 1620) else done
        if agv in ("WAIT", "ACK") and t >= TA + phase and (t - TA - phase) % poll_ms == 0:
            v = line                                  # agv.get_pin_input(1)
            if agv == "WAIT":
                seen = seen + 1 if v else 0
                if seen >= debounce:
                    if mode == "pulse":
                        return ("danger" if t < arm_end else "ok"), t
                    agv, req_off, seen = "ACK", t + 1, 0
            else:                                     # ACK: DONE 이 내려가길 기다림
                seen = seen + 1 if not v else 0
                if seen >= debounce:
                    return ("danger" if t < arm_end else "ok"), t
        if agv in ("WAIT", "ACK") and t >= TA + timeout_ms:
            return "timeout", t
    return "timeout", 10000

def sweep(mode, poll_ms, n=200, **kw):
    rnd = random.Random(1)
    c = {"ok": 0, "timeout": 0, "danger": 0}
    for _ in range(n):
        r, _ = simulate(mode, poll_ms, phase=rnd.randrange(poll_ms), **kw)
        c[r] += 1
    return c

print("방식   폴링  펄스폭  | 정상 / 놓침 / 위험 (위상 200가지)")
for poll, pulse in ((200, 100), (200, 200), (200, 300), (1000, 300)):
    print(f"pulse  {poll:4d}  {pulse:4d}   |", sweep("pulse", poll, pulse_ms=pulse))
for poll in (200, 1000):
    print(f"level  {poll:4d}    -    |", sweep("level", poll))
print("잡음 + 펄스 300, 폴링 20 ms :", sweep("pulse", 20, pulse_ms=300, glitch=True))
print("  + 디바운스 2번          :", sweep("pulse", 20, pulse_ms=300, glitch=True, debounce=2))
  • 예시 결과: 펄스 100 ms · 폴링 200 ms 는 정상 89 / 놓침 111, 펄스 300 ms · 폴링 1 000 ms 는 정상 47 / 놓침 153 (성공 약 24 %, 폭 ÷ 주기 = 30 % 보다 조금 낮음 - 펄스가 폴링 시작 전에 끝나는 경우 포함). level 은 폴링과 상관없이 200 / 0 / 0 입니다.
  • 실물 코드에서는 simulate() 안의 line 읽기가 agv.get_pin_input(1), req = 1 / 0 이 agv.set_pin_output(1, 1 / 0) 이 됩니다(아래 실물 실습 1).
  • 폴링 20 ms 는 잡음을 오히려 더 잘 읽습니다. 빠르게 읽는 것보다 몇 번 연속으로 확인 하는 것이 잡음에 강합니다(ch03 디바운스).
실습 4-1 · 평가판 채점기 (4교시)

시뮬레이터 6 의 결과(주문 순서 3가지)를 옮겨 적은 팀 기록으로 채점 규칙을 직접 구현하고 순위를 냅니다. 발표 때 "점수가 왜 이렇게 나왔는지" 를 항목별로 설명하는 데 씁니다.

  • TODO 1 시간 보너스, TODO 2 에너지 점수, TODO 3 안전 감점
  • 합격 조건: 3조 72.3 · 1조 57.7 · 4조 46.2 · 2조 −128.8 순서, "안전 규칙을 지킨 팀 중 1등" 이 3조

예측 먼저 — 2조는 처리 · 시간 · 에너지에서 모두 1조보다 높습니다. 몇 점 차이로 꼴찌가 될까요?

python시뮬 실행 가능
LIMIT = 600.0          # 제한 시간 10 분 (s)
E_REF = 0.75           # 에너지 기준 Wh / 건

def score_one(run):
    """주문 순서 하나의 결과 -> 점수 dict (시뮬레이터 6 과 같은 규칙)."""
    done = sum(1 for t in run["finish"] if t <= LIMIT)
    s_done = 2.0 * done
    # TODO 1: 20건을 모두 LIMIT 안에 끝냈으면 30 x (LIMIT - 마지막 완료 시각) / LIMIT, 아니면 0
    s_time = 0.0
    # TODO 2: 에너지 = 20 x min(1, E_REF / (energy_wh / done)), done 이 0 이면 0
    s_energy = 0.0
    # TODO 3: 감점 = 과속 10 + 방전 20 + 교착 5 (회당)
    penalty = 0
    return {"done": done, "s_done": s_done, "s_time": s_time, "s_energy": s_energy,
            "penalty": penalty, "total": s_done + s_time + s_energy - penalty}

def score_team(runs):
    rs = [score_one(r) for r in runs]
    avg = {k: sum(r[k] for r in rs) / len(rs) for k in rs[0]}
    avg["safe"] = all(r["speeding"] == 0 and r["dead"] == 0 and r["deadlock"] == 0 for r in runs)
    return avg

def finish_times(last, n=20):
    # 마지막 주문 완료 시각 last 까지 고르게 끝났다고 보는 단순한 목록
    return [last * (i + 1) / n for i in range(n)]

# 시뮬레이터 6 에서 옮겨 적은 팀 결과 (주문 순서 3가지)
TEAMS = {
    "1조 A-3대-예약+대기-1.0-20%": [
        {"finish": finish_times(484), "energy_wh": 22.4, "speeding": 0, "dead": 0, "deadlock": 0},
        {"finish": finish_times(520), "energy_wh": 23.2, "speeding": 0, "dead": 0, "deadlock": 0},
        {"finish": finish_times(518), "energy_wh": 23.1, "speeding": 0, "dead": 0, "deadlock": 0},
    ],
    "2조 A-3대-예약+대기-1.5-과속": [
        {"finish": finish_times(345), "energy_wh": 16.4, "speeding": 20, "dead": 0, "deadlock": 0},
        {"finish": finish_times(341), "energy_wh": 16.4, "speeding": 20, "dead": 0, "deadlock": 0},
        {"finish": finish_times(341), "energy_wh": 16.4, "speeding": 20, "dead": 0, "deadlock": 0},
    ],
    "3조 A-4대-예약+대기-1.0-10%": [
        {"finish": finish_times(275), "energy_wh": 17.8, "speeding": 0, "dead": 0, "deadlock": 0},
        {"finish": finish_times(299), "energy_wh": 18.4, "speeding": 0, "dead": 0, "deadlock": 0},
        {"finish": finish_times(284), "energy_wh": 18.1, "speeding": 0, "dead": 0, "deadlock": 0},
    ],
    "4조 A-3대-규칙 없음-1.0-20%": [
        {"finish": finish_times(489), "energy_wh": 29.0, "speeding": 0, "dead": 0, "deadlock": 1},
        {"finish": finish_times(450)[:19] + [900], "energy_wh": 34.0, "speeding": 0, "dead": 0, "deadlock": 0},
        {"finish": finish_times(470)[:19] + [900], "energy_wh": 34.2, "speeding": 0, "dead": 0, "deadlock": 1},
    ],
}

rows = sorted(((score_team(r), name) for name, r in TEAMS.items()), key=lambda x: -x[0]["total"])
print("순위 | 팀 설정                         | 합계  | 처리 시간 에너지 감점 | 안전")
for i, (s, name) in enumerate(rows, 1):
    print(f"{i:4d} | {name:30s} | {s['total']:5.1f} | {s['s_done']:4.1f} {s['s_time']:4.1f} {s['s_energy']:5.1f} {s['penalty']:5.1f} | {'OK' if s['safe'] else '위반'}")
safe = [n for s, n in rows if s["safe"]]
print("안전 규칙을 지킨 팀 중 1등:", safe[0] if safe else "없음")
  • starter 는 처리 점수만 계산하므로 1 · 2 · 3조가 40.0 점으로 같아집니다. 과속한 2조와 안전한 1조를 구별하지 못합니다.
풀이
python시뮬 실행 가능
LIMIT = 600.0          # 제한 시간 10 분 (s)
E_REF = 0.75           # 에너지 기준 Wh / 건

def score_one(run):
    """주문 순서 하나의 결과 -> 점수 dict (시뮬레이터 6 과 같은 규칙)."""
    done = sum(1 for t in run["finish"] if t <= LIMIT)
    s_done = 2.0 * done
    if done == 20 and max(run["finish"]) <= LIMIT:
        s_time = 30.0 * (LIMIT - max(run["finish"])) / LIMIT
    else:
        s_time = 0.0
    s_energy = 20.0 * min(1.0, E_REF / (run["energy_wh"] / done)) if done else 0.0
    penalty = 10 * run["speeding"] + 20 * run["dead"] + 5 * run["deadlock"]
    return {"done": done, "s_done": s_done, "s_time": s_time, "s_energy": s_energy,
            "penalty": penalty, "total": s_done + s_time + s_energy - penalty}

def score_team(runs):
    rs = [score_one(r) for r in runs]
    avg = {k: sum(r[k] for r in rs) / len(rs) for k in rs[0]}
    avg["safe"] = all(r["speeding"] == 0 and r["dead"] == 0 and r["deadlock"] == 0 for r in runs)
    return avg

def finish_times(last, n=20):
    # 마지막 주문 완료 시각 last 까지 고르게 끝났다고 보는 단순한 목록
    return [last * (i + 1) / n for i in range(n)]

# 시뮬레이터 6 에서 옮겨 적은 팀 결과 (주문 순서 3가지)
TEAMS = {
    "1조 A-3대-예약+대기-1.0-20%": [
        {"finish": finish_times(484), "energy_wh": 22.4, "speeding": 0, "dead": 0, "deadlock": 0},
        {"finish": finish_times(520), "energy_wh": 23.2, "speeding": 0, "dead": 0, "deadlock": 0},
        {"finish": finish_times(518), "energy_wh": 23.1, "speeding": 0, "dead": 0, "deadlock": 0},
    ],
    "2조 A-3대-예약+대기-1.5-과속": [
        {"finish": finish_times(345), "energy_wh": 16.4, "speeding": 20, "dead": 0, "deadlock": 0},
        {"finish": finish_times(341), "energy_wh": 16.4, "speeding": 20, "dead": 0, "deadlock": 0},
        {"finish": finish_times(341), "energy_wh": 16.4, "speeding": 20, "dead": 0, "deadlock": 0},
    ],
    "3조 A-4대-예약+대기-1.0-10%": [
        {"finish": finish_times(275), "energy_wh": 17.8, "speeding": 0, "dead": 0, "deadlock": 0},
        {"finish": finish_times(299), "energy_wh": 18.4, "speeding": 0, "dead": 0, "deadlock": 0},
        {"finish": finish_times(284), "energy_wh": 18.1, "speeding": 0, "dead": 0, "deadlock": 0},
    ],
    "4조 A-3대-규칙 없음-1.0-20%": [
        {"finish": finish_times(489), "energy_wh": 29.0, "speeding": 0, "dead": 0, "deadlock": 1},
        {"finish": finish_times(450)[:19] + [900], "energy_wh": 34.0, "speeding": 0, "dead": 0, "deadlock": 0},
        {"finish": finish_times(470)[:19] + [900], "energy_wh": 34.2, "speeding": 0, "dead": 0, "deadlock": 1},
    ],
}

rows = sorted(((score_team(r), name) for name, r in TEAMS.items()), key=lambda x: -x[0]["total"])
print("순위 | 팀 설정                         | 합계  | 처리 시간 에너지 감점 | 안전")
for i, (s, name) in enumerate(rows, 1):
    print(f"{i:4d} | {name:30s} | {s['total']:5.1f} | {s['s_done']:4.1f} {s['s_time']:4.1f} {s['s_energy']:5.1f} {s['penalty']:5.1f} | {'OK' if s['safe'] else '위반'}")
safe = [n for s, n in rows if s["safe"]]
print("안전 규칙을 지킨 팀 중 1등:", safe[0] if safe else "없음")
  • 점수는 시뮬레이터 6 과 0.1 점 안쪽으로 같습니다(완료 시각을 고르게 나눈 단순화 때문). 4조는 한 주문 순서에서 교착 · 미완료가 나서 처리 점수부터 깎입니다.
  • 3조(임계값 10 %)는 1등이지만 확인 문제 4-2 처럼 여유 없는 설정 입니다. 발표에서는 점수와 함께 "다른 주문 순서 · 대수에서도 방전 0 인가" 를 꼭 보여 줍니다.
실습 4-2 · 실물 시연 계획서 검사기 (4교시)

실물 시연 계획서를 dict 로 적고, 이 강좌에서 배운 공식으로 항목을 자동 검사합니다. 정지 거리는 ch01, 충전 임계값은 ch09, 타임아웃은 3교시 규칙입니다.

  • TODO 1 정지 영역 ≥ 정지 거리 v · t반응 + v² / (2a), a = 60 N / (40 kg + 적재)
  • TODO 2 충전 임계값 ≥ 10 % + 최악 미션 1회 + 충전대까지
  • 합격 조건: 처음 계획서는 6개 실패(속도 · 담당자 · 정지 영역 · 핸드셰이크 · 타임아웃 · 시작 배터리), 고친 계획서는 모두 통과

예측 먼저 — 0.6 m/s · 적재 20 kg 의 정지 거리는 정지 영역 0.3 m 보다 길까요?

python시뮬 실행 가능
# 실물 시연 계획서 검사기 - 계획서(dict)를 받아 항목별 통과/실패를 출력한다.
F_BRAKE = 60.0          # N, ch01 의 제동력 가정값
T_REACT = 0.3           # s, 반응 시간 가정
BATTERY_WH = 480.0

def stop_distance(v, load_kg):
    a = F_BRAKE / (40.0 + load_kg)
    return v * T_REACT + v * v / (2 * a)

def mission_percent(dist_m, v, load_kg):
    # ch01 근사식 P = 45 + 1.05 * m * v, 절반은 짐을 싣고 달린다고 봄
    t = dist_m / v
    p_empty = 45 + 1.05 * 40 * v
    p_full = 45 + 1.05 * (40 + load_kg) * v
    wh = (p_empty + p_full) / 2 * t / 3600
    return wh / BATTERY_WH * 100

def check(plan):
    res = []
    def item(name, ok, detail):
        res.append((ok, name, detail))
    item("실물 최고 속도 0.5 m/s 이하", plan["max_vel"] <= 0.5, f"{plan['max_vel']} m/s")
    item("사람 구역 0.3 m/s 이하", plan["human_vel"] <= 0.3, f"{plan['human_vel']} m/s")
    people = plan["estop_people"]
    item("로봇마다 비상정지 담당자 (서로 다른 사람)", len(set(people)) >= plan["robots"], f"로봇 {plan['robots']}대, 담당 {len(set(people))}명")
    # TODO 1: stop_distance(max_vel, load_kg) 를 계산해 정지 영역(stop_zone_m)이 그보다 큰지 검사
    #         item("정지 영역 >= 정지 거리", ok, 설명)
    need_to = plan["arm_max_s"] + 3 * plan["poll_s"] + 1.0
    item("핸드셰이크 4단계(level)", plan["handshake"] == "level", plan["handshake"])
    item("타임아웃 >= 팔 최대 작업 + 폴링 3번 + 1 s", plan["timeout_s"] >= need_to, f"{plan['timeout_s']} s (필요 {need_to:.1f} s)")
    worst = mission_percent(plan["worst_mission_m"], plan["max_vel"], plan["load_kg"])
    to_chg = mission_percent(plan["to_charger_m"], plan["max_vel"], 0)
    # TODO 2: 필요 임계값 = 10 + worst + to_chg, charge_thr 가 그 이상인지 검사
    item("시작 배터리 >= 임계값 + 20 %", plan["start_battery"] >= plan["charge_thr"] + 20, f"{plan['start_battery']} %")
    return res

DRAFT = {   # 처음 낸 계획서
    "robots": 2, "max_vel": 0.6, "human_vel": 0.3, "load_kg": 20,
    "estop_people": ["김OO", "김OO"], "stop_zone_m": 0.3,
    "handshake": "pulse", "arm_max_s": 6.0, "poll_s": 0.2, "timeout_s": 6.0,
    "worst_mission_m": 60, "to_charger_m": 15, "charge_thr": 30, "start_battery": 40,
}
FIXED = dict(DRAFT, max_vel=0.3, estop_people=["김OO", "이OO"], handshake="level",
             timeout_s=8.0, start_battery=70)

for name, plan in (("처음 계획서", DRAFT), ("고친 계획서", FIXED)):
    print("---", name)
    result = check(plan)
    for ok, item_name, detail in result:
        print(("통과  " if ok else "실패  ") + f"{item_name:40s} {detail}")
    fails = [n for ok, n, _ in result if not ok]
    print("=> 시연 " + ("가능" if not fails else f"불가 - 고칠 것 {len(fails)}개"))
  • starter 는 정지 영역과 충전 임계값 줄이 빠져 있어, 처음 계획서에서 정지 영역 실패를 찾지 못합니다.
풀이
python시뮬 실행 가능
# 실물 시연 계획서 검사기 - 계획서(dict)를 받아 항목별 통과/실패를 출력한다.
F_BRAKE = 60.0          # N, ch01 의 제동력 가정값
T_REACT = 0.3           # s, 반응 시간 가정
BATTERY_WH = 480.0

def stop_distance(v, load_kg):
    a = F_BRAKE / (40.0 + load_kg)
    return v * T_REACT + v * v / (2 * a)

def mission_percent(dist_m, v, load_kg):
    # ch01 근사식 P = 45 + 1.05 * m * v, 절반은 짐을 싣고 달린다고 봄
    t = dist_m / v
    p_empty = 45 + 1.05 * 40 * v
    p_full = 45 + 1.05 * (40 + load_kg) * v
    wh = (p_empty + p_full) / 2 * t / 3600
    return wh / BATTERY_WH * 100

def check(plan):
    res = []
    def item(name, ok, detail):
        res.append((ok, name, detail))
    item("실물 최고 속도 0.5 m/s 이하", plan["max_vel"] <= 0.5, f"{plan['max_vel']} m/s")
    item("사람 구역 0.3 m/s 이하", plan["human_vel"] <= 0.3, f"{plan['human_vel']} m/s")
    people = plan["estop_people"]
    item("로봇마다 비상정지 담당자 (서로 다른 사람)", len(set(people)) >= plan["robots"], f"로봇 {plan['robots']}대, 담당 {len(set(people))}명")
    d = stop_distance(plan["max_vel"], plan["load_kg"])
    item("정지 영역 >= 정지 거리", plan["stop_zone_m"] >= d, f"정지 영역 {plan['stop_zone_m']} m, 정지 거리 {d:.2f} m")
    need_to = plan["arm_max_s"] + 3 * plan["poll_s"] + 1.0
    item("핸드셰이크 4단계(level)", plan["handshake"] == "level", plan["handshake"])
    item("타임아웃 >= 팔 최대 작업 + 폴링 3번 + 1 s", plan["timeout_s"] >= need_to, f"{plan['timeout_s']} s (필요 {need_to:.1f} s)")
    worst = mission_percent(plan["worst_mission_m"], plan["max_vel"], plan["load_kg"])
    to_chg = mission_percent(plan["to_charger_m"], plan["max_vel"], 0)
    need_thr = 10 + worst + to_chg
    item("충전 임계값 >= 10 + 최악 미션 + 충전대까지 (ch09)", plan["charge_thr"] >= need_thr, f"{plan['charge_thr']} % (필요 {need_thr:.1f} %)")
    item("시작 배터리 >= 임계값 + 20 %", plan["start_battery"] >= plan["charge_thr"] + 20, f"{plan['start_battery']} %")
    return res

DRAFT = {   # 처음 낸 계획서
    "robots": 2, "max_vel": 0.6, "human_vel": 0.3, "load_kg": 20,
    "estop_people": ["김OO", "김OO"], "stop_zone_m": 0.3,
    "handshake": "pulse", "arm_max_s": 6.0, "poll_s": 0.2, "timeout_s": 6.0,
    "worst_mission_m": 60, "to_charger_m": 15, "charge_thr": 30, "start_battery": 40,
}
FIXED = dict(DRAFT, max_vel=0.3, estop_people=["김OO", "이OO"], handshake="level",
             timeout_s=8.0, start_battery=70)

for name, plan in (("처음 계획서", DRAFT), ("고친 계획서", FIXED)):
    print("---", name)
    result = check(plan)
    for ok, item_name, detail in result:
        print(("통과  " if ok else "실패  ") + f"{item_name:40s} {detail}")
    fails = [n for ok, n, _ in result if not ok]
    print("=> 시연 " + ("가능" if not fails else f"불가 - 고칠 것 {len(fails)}개"))
  • 0.6 m/s · 60 kg 이면 감속도 a = 60 ÷ 60 = 1.0 m/s², 반응 0.6 × 0.3 = 0.18 m + 제동 0.6² ÷ (2 × 1.0) = 0.18 m 로 정지 거리 0.36 m 가 정지 영역 0.3 m 보다 깁니다. 속도를 0.3 m/s 로 낮추면 0.09 + 0.045 ≈ 0.14 m 로 줄어 통과합니다(제동 거리는 속도의 제곱).
  • 이 검사기는 필요 조건 만 봅니다. 통과해도 실물 실습의 :::safety 체크리스트(사람 확인)는 따로 해야 합니다.

창고 시뮬레이터로 확인하기#

Playground 의 타깃을 Simulator 로 두면 공식 URDF 로 만든 3D 창고 시뮬레이터에 from pymycobot import MyAGVPro 가 그대로 연결됩니다. agvsim 은 참값 위치 · 스캔 · 지도처럼 실물에는 없는 정보를 읽는 시뮬레이터 전용 모듈입니다 (실물에서는 ROS 2 토픽이 그 역할). 가속 한계 · 미끄러짐 · 보호 영역 거리 등은 교육용 가정입니다. 작업장 장면에는 스테이션 A · B · C 와 충전 독이 바닥에 표시되어 있습니다 (agvsim.get_map()["stations"] 으로 좌표를 읽을 수 있음).

Playground (시뮬레이터 · 방) 열기

실습 6-1 · 미니 미션 — HOME → C(집기) → A(내려놓기) → HOME (1교시 복습)

1교시의 미션 상태 머신을 진짜 API 로 돌립니다. 이동 중 파랑 · 작업 중 주황 · 대기 초록 · 오류 빨강 LED 를 켜고, 범퍼가 눌리면 미션을 멈춥니다. 위치는 AMCL 대신 agvsim.get_pose() 를 씁니다.

python시뮬 실행 가능
from pymycobot import MyAGVPro
import agvsim, time, math

agv = MyAGVPro("/dev/agvpro_controller", baudrate=1000000)
if agv.is_power_on() != 1:
    agv.power_on()
agv.set_auto_report_state(1)

COLORS = {"IDLE": (0, 255, 0), "MOVING": (0, 0, 255), "WORKING": (255, 160, 0), "ERROR": (255, 0, 0)}
ROUTES = {                                     # 작업장(room) 장면의 통로를 따라 미리 정한 경유점
    ("HOME", "C"): [(0, 2.0), (2.3, 2.0), (2.3, 2.6)],
    ("C", "A"): [(2.3, 2.0), (5.5, 2.0), (5.5, 2.6)],
    ("A", "HOME"): [(5.5, 2.0), (2.5, 2.0), (2.5, 0.0), (0.0, 0.0)],
}
MISSION = [("C", "PICK"), ("A", "DROP"), ("HOME", "PARK")]

def led(state):
    agv.set_led_color(0, 255, COLORS[state]); agv.set_led_color(1, 255, COLORS[state])

def go_to(points, vmax=0.6, timeout=30):
    t0 = time.time()
    for i, (gx, gy) in enumerate(points):
        tol = 0.04 if i == len(points) - 1 else 0.12
        while True:
            if time.time() - t0 > timeout:
                agvsim.stop(); return False
            if agv.get_robot_status()[2:4] != [0, 0]:      # 범퍼
                agvsim.stop(); return False
            x, y, th = agvsim.get_pose()
            ex, ey = gx - x, gy - y
            d = math.hypot(ex, ey)
            if d < tol:
                break
            bx = ex * math.cos(th) + ey * math.sin(th)
            by = -ex * math.sin(th) + ey * math.cos(th)
            v = min(vmax, 1.5 * d)
            agvsim.cmd_vel(v * bx / d, v * by / d, -1.5 * th)
            time.sleep(0.05)
    agvsim.stop()
    return True

agvsim.set_pose(0, 0, 0)
where, t_start = "HOME", time.time()
for target, job in MISSION:
    led("MOVING")
    print(f"{time.time() - t_start:5.1f}s  {where} -> {target}")
    if not go_to(ROUTES[(where, target)]):
        led("ERROR"); print("FAILED on the way to", target); break
    where = target
    led("WORKING"); print(f"{time.time() - t_start:5.1f}s  {job} at {target}"); time.sleep(1.0)
led("IDLE")
volt = agv.get_auto_report_message()[5]
print(f"mission done in {time.time() - t_start:.1f} s, battery {volt} V")

바꿔 보기

  1. MISSION 에 ("B", "PICK") 을 넣고 ROUTES 에 필요한 구간(예: ("A", "B"): [(5.5, 2.0), (5.5, -1.7)], ("B", "HOME"))을 더합니다. 경로가 상자(4.6, −0.3) · 선반(6.6, 0.6)과 얼마나 떨어져 있는지 agvsim.get_map() 으로 먼저 계산하세요.
  2. 일부러 경유점 하나를 기둥(3.5, 0.9) 위로 옮겨 실행합니다. 보호 영역 때문에 멈춘 채 timeout 이 나는지, 범퍼로 FAILED 가 나는지 보고, 2교시의 교통 관리 · 재계획 규칙을 어디에 넣을지 정합니다.
  3. 미션 끝의 배터리 전압을 4교시 프로젝트의 충전 정책(ch09)에 넣어, 몇 번 돌면 충전 독으로 가야 하는지 계산합니다.

실습 (실물)#

myAGV Pro 한 대(가능하면 로봇팔 또는 팔 대신 스위치 · 버튼을 IO 에 연결한 상자)로 합니다. 실물 실습은 시뮬레이터의 가정값을 실제 값으로 바꾸는 측정 이 목적이며, 다중 AGV 시연은 4교시 계획서가 통과한 팀만 합니다.

실물 시연 전 확인

실물 실습 1 — IO 핸드셰이크 (3교시)

팔 대신 스위치 하나로 시작합니다. AGV 출력 1 에 LED(또는 팔의 입력), AGV 입력 1 에 스위치(또는 팔의 출력)를 연결합니다. 배선 전압 · 극성은 공식 문서의 IO 핀 설명을 먼저 확인합니다(확인 필요). 아래 코드는 실습 3-2 의 level 모드를 실물 API 로 옮긴 것입니다.

python실물 전용
import time
from pymycobot import MyAGVPro

agv = MyAGVPro("/dev/agvpro_controller", baudrate=1000000)
POLL, TIMEOUT, DEBOUNCE = 0.05, 8.0, 2

def wait_input(pin, want, timeout):
    """입력이 want 로 DEBOUNCE 번 연속 읽힐 때까지 기다림. 시간 초과면 False."""
    t0, seen = time.time(), 0
    while time.time() - t0 < timeout:
        seen = seen + 1 if agv.get_pin_input(pin) == want else 0
        if seen >= DEBOUNCE:
            return True
        time.sleep(POLL)
    return False

try:
    agv.stop()                              # 도착했다고 가정: 반드시 정지 상태에서 시작
    agv.set_pin_output(1, 1)                # REQ = 1 "도착, 작업하세요"
    print("REQ=1, 팔(스위치)의 DONE 을 기다림")
    if not wait_input(1, 1, TIMEOUT):
        print("타임아웃 - ERROR 상태, 사람 호출")
    else:
        agv.set_pin_output(1, 0)            # REQ = 0 "확인했어요"
        if wait_input(1, 0, TIMEOUT):       # DONE 이 내려가야 출발 허가
            print("핸드셰이크 완료 - 출발 가능")
        else:
            print("DONE 이 내려가지 않음 - ERROR")
finally:
    agv.set_pin_output(1, 0)
    agv.stop()
  • 스위치를 0.1 s 만 눌렀다 떼 보고(펄스), 눌렀다가 LED 가 꺼진 뒤 떼 보세요(4단계). 어느 쪽이 확실히 인식되나요?
  • POLL 을 0.5 s 로 늘리고 같은 실험을 합니다. 시뮬레이터 5 의 결과와 비교합니다.

실물 실습 2 — 도킹 오차 재기 (3교시)

바닥에 테이프로 "도킹 목표" 를 표시하고, 1 m 뒤에서 출발해 목표에 서는 것을 10번 반복합니다. 매번 로봇 앞모서리와 테이프의 x · y 차이(cm)와 각도를 자로 잽니다.

조건접근 속도x 오차 평균 · 표준편차y 오차각도 오차
기본 (Nav2 목표 또는 시간 기반 정지)0.3 m/s
저속 접근0.1 m/s (마지막 0.3 m)
저속 + 횡이동 보정 (move_left_lateral · move_right_lateral 로 테이프에 맞춤)0.1 m/s

잰 표준편차 σ 를 실습 3-1 의 docking() 에 넣어(σ = e / 2 이므로 e = 2σ) 우리 로봇의 성공률 표를 다시 만듭니다.

실물 실습 3 — 2대 시연 (4교시, 계획서 통과 팀)

ch09 의 namespace · ROS_DOMAIN_ID 설정으로 로봇 2대를 띄우고, 실습 1-2 의 상태 머신을 로봇마다 하나씩 돌려 웨이포인트 순회(입고장 → 선반 → 출고장)를 합니다. 좁은 구간 하나를 정해 구역 예약 을 사람이 직접 합니다(종이 깃발 하나: 깃발을 든 로봇만 들어감). 처리 건수 · 걸린 시간 · 비상정지 횟수를 기록해 시뮬레이터 6 의 같은 설정 점수와 비교합니다.

자주 나는 오류와 해결#

1) 마지막 주문 하나가 끝나지 않음#

text
[mission] order 20 assigned to agv_2, state=TO_DROP ... (10 분 뒤에도 같은 줄)
  • 원인: 일을 마친 다른 로봇이 출고장 칸에 IDLE 로 서 있고, 남은 주문이 없어 영원히 비켜 주지 않습니다(시뮬레이터 6 의 "규칙 없음" · "구역 예약만"). 교착이 아니라서 탐지기에도 걸리지 않습니다.
  • 해결: 하역이 끝나면 대기 구역으로 가는 것까지 를 미션의 일부로 넣습니다. 대기 칸이 출고장 · 통로 입구를 막지 않는지 지도에서 확인합니다.

2) 상태 머신이 짐 없이 출고장으로 감#

text
[agv_1] LOADING -> TO_DROP (event=loaded)   # 그런데 선반 앞에 도착한 적이 없음
  • 원인: 이벤트를 표 없이 if event == "loaded": state = "TO_DROP" 처럼 처리해, 도착 전에 들어온 적재 완료 신호(배선 잡음 · 이전 미션의 늦은 신호)를 받아들였습니다.
  • 해결: "현재 상태 + 이벤트" 표에 있는 조합만 받습니다(실습 1-2). IO 신호는 디바운스하고, 미션마다 번호를 붙여 이전 미션의 신호를 버립니다.

3) 로봇이 늘었는데 처리량이 그대로이거나 줄어듦#

text
agents=3 throughput=204/h   agents=4 throughput=250/h   agents=5 throughput=278/h (operator interventions: 6)
  • 원인: 공유 자원(좁은 통로 · 출고장 · 사람 구역)이 병목입니다. 대수를 늘리면 그 앞의 대기만 늘어납니다.
  • 해결: 히트맵에서 가장 진한 칸을 찾아 그 자원을 늘리거나(출고장 하나 더, 통로 넓히기) 일방통행 · 구역 예약으로 흐름을 정리합니다. 대수를 늘리기 전에 1대 처리량 × 대수 대비 몇 % 인지 먼저 봅니다.

4) 구역 예약을 켰는데도 통로 입구에서 서로 멈춤#

text
[traffic] agv_2 waiting zone aisle_1 (holder agv_1) at cell (1,1)
[traffic] agv_1 waiting cell (1,1) occupied (agv_2, agv_3)
  • 원인: 예약을 입구 칸에 도착해서 확인하면, 기다리는 로봇들이 입구 칸을 채워 구역에서 나오려는 로봇의 길을 막습니다. 예약 자체가 새 교착을 만듭니다.
  • 해결: 입구 한 칸 전 에서 예약을 확인하고(실습 2-2 needs_reservation), 기다리는 로봇은 입구를 비워 둡니다. 시뮬레이터 3 의 엔진이 이 방식입니다.

5) 팔이 집는 중인데 AGV 가 출발함#

text
[agv] DONE=1 detected -> departing   # 팔 로그: t=1.61s grasp in progress
  • 원인: DONE 선의 짧은 잡음을 완료 신호로 읽었거나, 신호 없이 타이머로 출발했습니다(시뮬레이터 5).
  • 해결: 디바운스(연속 2번 이상) + 4단계 핸드셰이크를 씁니다. 출발 조건에 "DONE 이 1 이었다가 0 으로 내려감" 을 넣고, 팔이 홈 자세임을 알리는 신호를 하나 더 두면 더 안전합니다.

6) 핸드셰이크가 가끔 타임아웃 남#

text
[agv] handshake timeout after 6.0 s (REQ=1, DONE never seen)
  • 원인: 팔이 DONE 을 펄스로 짧게 내고, AGV 폴링 주기가 그보다 깁니다. 위상에 따라 확률적으로 놓칩니다. 팔 작업이 타임아웃보다 길어지는 날(무거운 물건, 재시도)에도 납니다.
  • 해결: DONE 을 레벨로 유지하게 팔 쪽 프로그램을 고칩니다. 타임아웃은 팔 최대 작업 시간 + 폴링 몇 주기 + 여유 로 잡습니다(실습 4-2).

7) 도킹은 맞는 것 같은데 긴 팔에서만 집기 실패가 잦음#

text
pick failed: object offset dy=+1.6 cm (tolerance 1.0 cm)
  • 원인: 방향 오차 θ 가 팔 길이 L 만큼 불어나 좌우로 어긋납니다(ey + L · θ). 위치(x · y)만 보고 각도를 무시했습니다.
  • 해결: 도킹 후 각도를 따로 재서 보정하거나(횡이동 · 제자리 회전 미세 보정), 마커로 팔이 직접 보정합니다. 각도 오차를 측정표에 꼭 넣습니다(실물 실습 2).

8) 평가판 점수가 주문 순서마다 크게 다름#

text
seed 2026: 72.3   seed 7: 27.6   seed 42: 70.1
  • 원인: 임계값을 낮춰 배터리가 거의 없는 로봇이 일하게 했거나, 교착이 일부 순서에서만 나는 등 여유 없는 설정 입니다.
  • 해결: 평균보다 가장 나쁜 순서 의 점수를 봅니다. 방전 · 교착 · 과속이 한 번이라도 나는 설정은 제출하지 않습니다.

9) Playground 에서 출력 한글이 깨지거나 실습 코드가 멈춘 것처럼 보임#

text
(30초 넘게 출력 없음)
  • 원인: 실습 2-1 (3시간 × 1 s 단계) · 3-2 (1 ms 단계 × 위상 200가지 × 여러 조건)는 브라우저 Python 에서 수 초 ~ 수십 초 걸릴 수 있습니다.
  • 해결: 기다리거나, T · n 을 줄여 먼저 돌려 봅니다. 결과의 경향은 같습니다.

과제#

팀 미션 · 우리 창고 설계 발표 (Part 4 마무리)

3 ~ 4명이 한 팀입니다. 발표 10 분, 질문 5 분.

  1. 설정표 — 시뮬레이터 6 의 설정(배치 · 대수 · 배정 규칙 · 통행 규칙 · 속도 · 감속 · 임계값)과 점수(항목별), 주문 순서 3가지 중 가장 나쁜 점수를 제출합니다. 교착 · 과속 · 방전이 0 이어야 합니다.
  2. 근거 세 가지 — 1교시(배치 · 처리량), 2교시(대수 · 교통 규칙), 3교시(도킹 · 핸드셰이크) 시뮬레이터에서 하나씩, "이 값을 바꾸면 이렇게 나빠진다" 를 숫자로 보입니다.
  3. 실물 측정 반영 — 실물 실습 2 에서 잰 도킹 오차로 실습 3-1 의 표를 다시 만들고, 우리 팀이 쓸 보정 방법을 고릅니다.
  4. 시연 계획서 — 4교시 표와 실습 4-2 검사 결과(모두 통과)를 붙입니다. 비상정지 담당자 이름을 적습니다.
  5. 한계 — 이 평가판이 무시한 것(위치 추정 오차, 경로 계획 시간, 사람의 움직임, 실제 충전 시간)을 두 가지 이상 들고, 실물에서 어떻게 확인할지 씁니다.

개인 과제:

  1. 레이아웃 보고서: 실습 1-1 로 통로 폭 0.6 ~ 2.0 m · 입출고장 두 위치 · ABC 유무 표(3 × 8 × 2 × 2)를 만들고, "보관 칸 300 이상에서 처리량 최대" 인 조건을 찾아 한 문단으로 씁니다.
  2. 교통 규칙 표: 시뮬레이터 3 에서 대수 1 ~ 5 × 통행 규칙 5가지의 처리량 · 교착 표를 채우고, 대수마다 1등 규칙을 표시합니다. 순위가 바뀌는 대수와 그 이유를 씁니다.
  3. 상태 머신 확장: 실습 1-2 에 TO_PARK (대기 구역 이동) 상태와 "주문 취소(짐 실음)" 를 처리할 RETURN (선반으로 되돌려 놓기) 상태를 넣고, 표와 테스트 이벤트 목록을 만듭니다.
  4. ch01 ~ ch10 지도: 이 강좌의 10개 차시가 미션 상태 머신의 어느 상태 · 어느 전이에서 쓰이는지 한 장의 그림으로 그립니다(예: TO_PICK = ch08 경로 계획 + ch07 위치 추정 + ch05 안전 영역).

참고자료#

  • myAGV Pro 공식 문서: https://docs.elephantrobotics.com/docs/myAGV_Pro_en/
    • Python API (이동 · 상태 · LED · IO 함수): https://docs.elephantrobotics.com/docs/myAGV_Pro_en/6-SDKDevelopment/6.1-ApplicationBasePython/6.1.2-API.html
    • ROS2 응용 (Navigation2 · 다중 제어 · 자동 충전): https://docs.elephantrobotics.com/docs/myAGV_Pro_en/6-SDKDevelopment/6.2-ApplicationBaseROS2/6.2.1-ROS2_Introduction.html
  • myAGV Pro ROS 2 저장소: https://github.com/elephantrobotics/agv_pro_ros2
  • 제품 페이지 (사양 · 응용 사례): https://www.elephantrobotics.com/en/myagv-pro/
  • 제품 소개 · 이미지 (현영이앤씨): https://www.hyenc.net/products/36
  • 로봇팔 제품 페이지 (사양 확인): https://www.elephantrobotics.com/en/mycobot-320/ · https://www.elephantrobotics.com/en/mycobot-pro-630/ · https://www.elephantrobotics.com/en/myarm-m750/
  • pymycobot (MyAGVPro Python 라이브러리): https://github.com/elephantrobotics/pymycobot
  • Nav2 Simple Commander (웨이포인트 · 여러 목표): https://docs.nav2.org/commander_api/index.html
  • Open-RMF (여러 로봇의 교통 · 작업 배정을 다루는 ROS 2 프레임워크): https://www.open-rmf.org/
  • 교착의 네 조건 (Coffman 조건) 해설: https://en.wikipedia.org/wiki/Deadlock_(computer_science)
  • 이 사이트의 도구: Playground · 물류창고 시뮬레이터 · 3D 뷰어