CH10물류 미션 통합 프로젝트
창고 레이아웃 · 작업 배정 · 교통 관리 · 로봇팔 연동을 하나로 묶어, 시뮬레이터 창고에서 처리량을 최대로 끌어올리는 물류 시스템을 설계합니다.
학습 목표#
- 입고장 · 보관 선반 · 피킹 스테이션 · 출고장 · 충전대로 창고를 나누고, 통로 폭 · 선반 방향 · 입출고장 위치를 바꿀 때 평균 편도 시간과 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 | 우리 팀 창고는 몇 점일까? | 스마트 창고 평가판 | 채점기, 시연 계획서 검사기 |
- 로봇 사양(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 자동 충전 |
선반 배치를 고를 때는 두 가지가 서로 당깁니다.
- 보관량 — 통로가 좁고 적을수록 같은 면적에 칸이 많아집니다.
- 처리량 — 통로가 넓을수록 로봇이 빨리 달리고(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 에서 좁은 통로일수록 코스트맵 비용이 높고 제어기가 감속하던 것을 한 줄로 줄인 가정식 입니다.
예측하기: 통로를 넓히면 처리량은 계속 오를까?#
시뮬레이터를 열기 전에 공책에 적어 보세요.
- 배치 A(세로 열)에서 통로 폭을 0.6 m → 1.0 m → 2.0 m 로 넓히면, 보관 칸 수와 처리량은 각각 어떻게 될까요?
- 입출고장이 창고 가운데 에 있을 때와 왼쪽 구석 에 있을 때, 가장 좋은 배치는 같을까요?
- 자주 나가는 물건 20 % 를 입출고장 가까이 두면(ABC 배치), 처리량이 몇 % 쯤 오를까요?
시뮬레이터 1 · 통로 폭 · 선반 배치와 처리량#
지도 위 칸의 색은 입출고장에서 그 칸까지의 편도 시간 입니다(초록 = 가까움, 빨강 = 멂). 칸을 클릭 하면 그 칸까지의 경로와 시간이 나옵니다. 오른쪽 막대는 지금 조건에서 세 배치의 1대 처리량입니다.
해 볼 것
- 예측 확인 — 배치 A · 입출고장 가운데 · 주통로 1.0 m/s 에서 통로 폭을 0.6 → 1.0 → 1.4 → 2.0 m 로 바꾸며 보관 칸과 처리량을 표로 적습니다. 처리량이 가장 높은 폭은 어디이고, 그 뒤로 넓히면 왜 오히려 줄어드나요?
- 통로 폭 1.0 m 에서 오른쪽 막대로 A · B · C 를 비교합니다. B 가 가장 낮은 이유를 B 의 가장 먼 칸을 클릭해 "주통로 몇 m + 선반 통로 몇 m" 로 설명합니다.
- 입출고장을 왼쪽 구석 으로 옮깁니다. 이제 어느 배치가 1등인가요? C 의 가운데 세로 통로가 왜 손해가 되었나요?
- ABC 배치 를 켭니다. 굵은 테두리 칸(A 품목)이 어디에 몰리는지 보고, 처리량이 몇 % 오르는지 계산합니다. 통로 폭을 넓히는 것과 비교하면 어느 쪽이 "공짜" 인가요?
- 주통로 속도를 0.5 m/s 로 낮추면 세 배치의 순위가 바뀌나요? 사람 구역 감속(4교시)이 처리량에 주는 영향을 미리 생각해 봅니다.
관찰 포인트 — 처리량은 3600 ÷ (2 × 평균 편도 + 적재 + 하역) 이라서, 평균 거리를 줄이는 것 과 느린 구간(좁은 통로)을 줄이는 것 두 가지로만 오릅니다. 통로를 넓히면 통로 속도가 오르지만 같은 면적에 통로가 덜 들어가 칸이 줄고, 1.4 m 를 넘으면 속도 이득은 없고 칸 사이 거리만 벌어져 처리량이 다시 떨어집니다. 가장 좋은 배치는 입출고장 위치에 따라 달라집니다. 가운데 입출고장에는 가운데 세로 통로(C)가 잘 맞고, 구석 입출고장에는 주통로에서 바로 들어가는 세로 열(A)이 유리합니다. ABC 배치는 선반을 하나도 옮기지 않고 물건의 자리만 바꿔 처리량을 20 % 이상 올립니다.
입출고장 가운데, 주통로 1.0 m/s, 통로 폭 1.0 m 에서 시뮬레이터 1 의 결과가 A 63.8 건/h (360 칸), B 40.6 건/h (324 칸), C 63.3 건/h (324 칸) 입니다. 같은 면적에서 하나를 고른다면 가장 근거가 좋은 답은?
- C — 가운데 세로 통로가 있으니 항상 가장 빠르다
- A — 처리량은 C 와 거의 같으면서 보관 칸이 36 칸 더 많다
- B — 칸이 가로로 길게 늘어서 한 통로에 칸이 가장 많다
- 세 배치의 차이는 계산 오차 수준이라 아무것이나 같다
정답 보기
② — A 와 C 의 처리량 차이는 0.5 건/h(1 % 안쪽)이지만 A 의 보관량이 11 % 많습니다. C 가 "항상" 빠르지는 않습니다(①). 해 볼 것 3 처럼 입출고장을 구석으로 옮기면 C 가 꼴찌가 됩니다. B 는 가장 먼 칸까지 주통로 18.5 m + 선반 통로 17.5 m 를 가야 해서 평균 편도 시간이 A 의 두 배가 넘습니다(③). 차이는 오차가 아니라 구조에서 나옵니다(④).배치 A 에서 통로 폭을 1.4 m → 2.0 m 로 넓혔더니 처리량이 70.9 → 69.8 건/h 로 오히려 조금 줄었습니다. 가장 알맞은 설명은?
- 통로가 넓어지면 로봇이 통로 가운데를 찾느라 느려진다
- 1.4 m 부터 통로 속도가 이미 주통로와 같아 더 빨라지지 않고, 통로 사이 간격(2D + w)이 벌어져 주통로를 더 많이 달린다
- 통로가 넓으면 칸이 늘어나 평균 거리가 길어진다
- 적재 · 하역 시간이 통로 폭에 비례해 늘어난다
정답 보기
② — 통로 속도 식은 w ≥ 1.4 m 에서 1.0 이 되어 더 오르지 않습니다. 반면 통로 사이 간격이 3.4 m → 4.0 m 로 벌어지면 통로 수는 5개로 같아 칸도 300 개 그대로인데, 입출고장에서 바깥쪽 통로까지 주통로 거리가 늘어납니다. ① 같은 효과는 이 모델에 없고, ③ 칸은 늘지 않으며, ④ 적재 · 하역 시간은 15 s 로 고정입니다.미션 상태 머신#
창고 배치가 "어디로" 를 정한다면, 상태 머신은 "지금 무엇을 하는 중이고, 다음에 무엇을 받아들일지" 를 정합니다. ch03 에서 라이트 커튼 정지 · 재출발을 상태 머신으로 짰던 것을 미션 전체로 넓힙니다.
| 상태 | 뜻 | 받는 이벤트 → 다음 상태 |
|---|---|---|
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건 을 재생합니다. 두 번째 미션의 하역이 끝날 때 배터리가 18 % 라서 어디로 가나요? 임계값 슬라이더를 15 % 로 낮추고 다시 재생하면 무엇이 달라지나요?
- 중복 · 뒤바뀐 이벤트 를 재생합니다. 빨간 줄(무시한 이벤트)은 몇 개이고, 각각 무시하지 않았다면 어떤 사고가 났을까요? (예: 도착 전에 받은 적재 완료)
- 짐 실은 채 비상정지 를 재생합니다.
ERROR에서 "주문 배정" · "주문 취소" 는 왜 무시되나요? 오류 해제 후 로봇은 어느 상태로 돌아가나요? - 직접 눌러 봅니다:
TO_PICK에서는 취소가 되는데TO_DROP에서는 왜 안 되게 설계했을까요? 취소를 허용하려면 어떤 상태를 하나 더 만들어야 할까요? - 배터리를 11 % 로 낮춘 뒤 미션을 처음부터 끝까지 눌러 봅니다. 이 상태 머신은 미션을 시작하기 전에 배터리를 확인하나요? 확인 문제 1-3 과 연결됩니다.
관찰 포인트 — 상태 머신은 "현재 상태 + 이벤트 → 다음 상태" 표 하나로 동작하며, 표에 없는 칸은 모두 무시 합니다. 그래서 중복 이벤트(도착 두 번)와 순서가 뒤바뀐 이벤트(도착 전 적재 완료)가 와도 상태가 꼬이지 않습니다. 오류 상태는 "어디서 멈췄는지" 를 저장해 두어야 재개할 수 있고, 짐을 실은 상태에서의 취소처럼 물리적으로 되돌릴 수 없는 전이는 표에서 빼는 것 이 안전한 설계입니다. 충전 판단은 하역이 끝나는 순간 한 번만 하므로, 배터리가 거의 없는 로봇도 IDLE 에서 새 주문을 받을 수 있다는 빈틈이 있습니다.
시뮬레이터 2 에서 배터리 11 %, 임계값 25 % 인 로봇이 IDLE 에서 "주문 배정" 을 받으면 TO_PICK 으로 갑니다. 이 빈틈을 막는 가장 알맞은 수정은?
UNLOADING의 충전 조건을bat < thr에서bat <= thr로 바꾼다IDLE의 "주문 배정" 전이에 조건(guard)bat ≥ thr를 달고, 아니면TO_CHARGE로 보낸다- 오류 해제 버튼을 없앤다
- 임계값을 50 % 로 올린다
정답 보기
② — 전이에 조건을 붙이는 것을 guard 라고 합니다. 충전 판단이 "하역 직후" 한 번뿐이면, 시작할 때부터 배터리가 낮았거나 대기 중에 떨어진 로봇이 걸러지지 않습니다. 배정 전에 한 번 더 확인하면 빈틈이 닫힙니다(2교시의 배정기도 충전이 필요한 로봇을 후보에서 뺍니다). ①은 경계값 하나만 바꾸고, ④는 빈틈은 그대로 둔 채 로봇을 자주 쉬게 만들어 처리량만 줄입니다.2교시 · 작업 배정과 다중 AGV 교통 관리#
주문 큐와 배정 규칙#
주문은 큐(queue) 에 도착 순서대로 쌓이고, 미션 관리자는 "놀고 있는 로봇" 이 생길 때마다 큐 맨 앞의 주문을 누구에게 줄지 정합니다. 이 결정 규칙이 배정 규칙(dispatching rule)입니다.
| 규칙 | 고르는 방법 | 좋은 점 | 약한 점 |
|---|---|---|---|
| 가장 가까운 로봇 (nearest) | 대기 로봇 중 주문 칸까지 경로가 가장 짧은 로봇 | 빈 차 주행이 짧음 | 한 로봇만 계속 일해 배터리가 한쪽으로 쏠림 |
| 배터리 우선 (battery) | 대기 로봇 중 배터리가 가장 많은 로봇 | 충전 횟수가 고르게 퍼짐 | 먼 로봇을 부를 수 있음 |
| 라운드로빈 (round-robin) | 로봇 1 → 2 → 3 … 차례로, 바쁜 로봇은 건너뜀 | 단순, 일이 고르게 나뉨 | 거리 · 배터리를 보지 않음 |
배정 규칙의 차이는 대기 로봇이 둘 이상일 때만 나타납니다. 주문이 로봇보다 훨씬 많아 늘 한 대씩만 비는 상황이라면, 누구에게 줄지 고를 여지가 없기 때문입니다.
로봇이 늘면 생기는 일 — 정체와 교착#
로봇이 한 대일 때는 경로 계획(ch08)만 잘하면 됩니다. 두 대부터는 같은 공간을 나눠 쓰는 문제 가 생깁니다.
- 정체(congestion) — 앞 로봇이 적재 중이라 뒤 로봇이 기다립니다. 시간이 지나면 풀립니다.
- 교착(deadlock) — 두 로봇이 서로 상대가 비켜 주기를 기다려 영원히 풀리지 않습니다. 폭 1 m 통로 한가운데서 마주 보고 선 두 로봇, 하역장 안의 로봇이 나오려는데 그 앞 칸을 하역장에 들어가려는 로봇들이 막고 있는 상황이 대표적입니다.
교착은 네 조건(상호 배제 · 점유하며 대기 · 빼앗을 수 없음 · 순환 대기)이 동시에 성립할 때만 생깁니다. 그래서 하나를 깨면 막을 수 있습니다.
| 통행 규칙 | 하는 일 | 깨는 조건 | 대가 |
|---|---|---|---|
| 구역 예약 (뮤텍스, 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 분을 바로 계산하고, ▶ 로 다시 볼 수 있습니다.
해 볼 것
- 예측 확인 — "규칙 없음", 도착률 6 건/분(주문이 처리 능력보다 많은 상태)에서 대수를 1 → 5 로 올리며 오른쪽 그래프를 봅니다. 1대 74 건/h 의 5배(점선)와 비교해 5대는 몇 % 인가요? 교착(빨강 X)은 몇 대부터 생기나요?
- 3대 · 규칙 없음에서 ▶ 재생해 X 가 생기는 곳을 찾습니다. 선반 통로 안 인가요, 출고장 앞 인가요? 히트맵의 가장 진한 칸은 어디인가요?
- 3대에서 빠른 설정 버튼 네 개(규칙 없음 · 구역 예약 · 일방통행 · 모두)를 차례로 누르며 처리량 · 교착 · 총 주행 거리를 표로 적습니다. 교착이 0 이면서 처리량이 가장 높은 조합은? 일방통행은 왜 주행 거리가 늘어나나요?
- 대수를 5대로 올리고 같은 비교를 합니다. 순위가 바뀌나요? 일방통행이 3대일 때보다 상대적으로 좋아지는 이유를 "통로 하나에 몇 대가 동시에 들어갈 수 있나" 로 설명합니다.
- 도착률을 3 건/분 으로 낮추고(로봇이 놀 때가 생김) 4대 · 구역 예약에서 대기 구역 을 켜고 끕니다. 교착 · 평균 배정 대기가 어떻게 바뀌나요? 이어 배정 규칙 세 가지를 바꿔 봅니다. 처리량 차이가 교통 규칙만큼 큰가요?
관찰 포인트 — 대수를 늘리면 처리량은 늘지만 비례하지 않습니다. 같은 통로 · 같은 출고장 · 같은 사람 구역을 나눠 쓰므로 기다리는 시간이 생기고(히트맵), 아무 규칙이 없으면 좁은 통로 정면 대치와 출고장 앞 막힘으로 교착이 대수의 제곱에 가깝게 늘어납니다. 구역 예약은 교착을 거의 없애지만 통로를 한 대씩만 쓰게 하고, 일방통행은 통로 안 정면 대치를 원천적으로 없애는 대신 돌아가는 거리 를 치릅니다. 로봇이 적을 때는 거리 손해가, 많을 때는 통로를 여러 대가 함께 쓰는 이득이 더 큽니다. 배정 규칙은 놀고 있는 로봇이 여럿일 때만 차이를 만들어서, 주문이 넘치는 상황에서는 교통 규칙보다 효과가 훨씬 작습니다.
시뮬레이터 3 의 "규칙 없음" · 도착률 6 건/분에서 1대 74 건/h, 3대 200 건/h (교착 8번), 5대 274 건/h (교착 42번) 이 나왔습니다. 5대가 이상적인 370 건/h 의 74 % 에 그친 이유로 가장 알맞은 것은?
- 주문이 부족해서 로봇이 놀았다
- 로봇이 많아질수록 배터리가 빨리 닳아 충전하러 갔다
- 좁은 통로 · 출고장 · 사람 구역을 나눠 쓰며 기다리는 시간이 늘고, 교착이 생길 때마다 운영자 개입으로 20 s 씩 잃었다
- 로봇이 많으면 경로 계획(BFS)이 느려져 출발이 늦어진다
정답 보기
③ — 도착률 6 건/분은 360 건/h 라서 5대가 처리하는 274 건/h 보다 많습니다. 30 분 뒤에도 주문이 남아 있으므로 ①은 아닙니다. 시작 배터리 중 가장 낮은 35 % 도 30 분 동안 약 6 % 만 줄어 25 % 임계값에 닿지 않으므로 ②도 아닙니다. 히트맵에서 기다림은 출고장 앞과 통로 입구에 몰립니다. 교착 42번 × 20 s 만 해도 약 14 분의 로봇 시간을 잃습니다. 계획 계산 시간(④)은 이 모델의 시간에 들어가지 않습니다.3대 · 도착률 6 건/분에서 "구역 예약" 은 204 건/h (교착 0), "일방통행" 은 184 건/h (교착 1), 총 주행 거리는 각각 약 1 590 m · 2 110 m 였습니다. 일방통행의 처리량이 더 낮은 까닭은?
- 일방통행에서는 통로마다 한 대씩만 들어갈 수 있어서
- 아래로 가는 통로의 칸에 가려면 위 통로로 올라가 위 주통로를 돌아 들어와야 해서, 같은 주문을 처리하는 데 더 먼 길을 달린다
- 일방통행에서는 사람 구역 감속이 꺼져서
- 일방통행이 교착을 더 많이 만들어서
정답 보기
② — 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 은 "팔 베이스에서 물건까지" 의 이 차시 가정값입니다.
팔을 얹을 때 확인할 것은 세 가지입니다.
- 무게 — 팔 + 그리퍼 + 집을 물건이 최대 적재 50 kg 안에 들어오고, 무게 중심이 차체 가운데 · 낮게 있어야 합니다(ch01). 팔이 옆으로 뻗으면 무게 중심이 움직이므로 팔이 움직이는 동안 AGV 는 서 있어야 합니다.
- 전원 — myAGV Pro 뒷면의 XT60 단자는 24 V · 최대 5 A (= 120 W) 입니다(ch01). 팔의 정격 · 최대 전류가 이보다 크면 별도 전원이나 DC-DC 변환기가 필요합니다. 팔이 쓰는 전력은 같은 480 Wh 배터리에서 나가므로 주행 시간도 줄어듭니다.
- 신호 — 팔과 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 출력에 연결).
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 320 | myCobot 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가지 조합을 모두 계산한 결과입니다.
해 볼 것
- 예측 확인 — myCobot 320, 그리퍼 허용 1.0 cm, 보정 없음에서 오차 ±1 · ±3 · ±5 cm 버튼을 차례로 누릅니다. 성공률은 어떻게 떨어지나요? 오차가 3배가 될 때 성공률도 3분의 1 이 되나요?
- ±3 cm 에서 팔을 myCobot 320 → myArm M750 으로 바꿉니다. 점 구름이 어느 방향으로 늘어나나요? 앞뒤(dx)와 좌우(dy) 중 어느 쪽이 팔 길이의 영향을 받는지 식
ey + L · θ로 설명합니다. - ±5 cm 에서 마커만 켭니다. 점선 원(마커 시야) 밖의 점은 몇 개이고, 성공률은? 이어 저속 접근 + 마커 를 켭니다. 왜 마커가 저속 접근과 짝을 이룰 때 강해지나요?
- ±1 cm 에서 오른쪽 표의 ★ 는 어느 조합인가요? ±5 cm 에서는? "보정을 모두 켜기" 가 언제나 1등이 아닌 이유를 1회 시간과 함께 설명합니다.
- 그리퍼 허용 오차를 0.5 → 2.0 cm 로 넓혀 봅니다(더 넓게 벌어지는 그리퍼, 흡착 그리퍼). 같은 성공률을 얻으려면 도킹을 고치는 것과 그리퍼를 바꾸는 것 중 무엇이 싸게 먹힐지 토론합니다.
관찰 포인트 — 도킹 오차가 그리퍼 허용 오차보다 커지는 순간 성공률은 선형이 아니라 급격히 무너집니다(2차원 정규분포가 원 안에 들어올 확률). 방향 오차는 팔 길이만큼 불어나 좌우로만 퍼지므로, 긴 팔일수록 횡이동 보정의 값어치가 큽니다. 마커는 남는 오차를 거의 없애지만 마커가 보여야 하므로, 큰 오차에서는 저속 접근으로 시야 안에 먼저 들여놓아야 합니다. 처리량으로 보면 오차가 작을 때는 가장 싼 보정 하나가, 오차가 클 때는 둘의 조합이 1등이고, 셋 다 켜면 시간만 늘어나는 구간이 있습니다.
myCobot 320, 그리퍼 허용 1.0 cm, 도킹 오차 ±5 cm 에서 시뮬레이터 4 의 표가 "마커만: 성공률 약 65 %", "저속 + 마커: 약 98 %" 를 보였습니다. 이 차이를 가장 잘 설명하는 것은?
- 저속 접근을 하면 카메라 노출이 좋아져 마커 인식이 정확해진다
- 마커는 시야(4 cm) 안에 들어온 경우에만 보정할 수 있는데, ±5 cm 오차에서는 약 35 % 가 시야 밖으로 나가고, 저속 접근이 오차를 절반으로 줄여 거의 모두를 시야 안에 넣는다
- 저속 접근 자체가 성공률을 99 % 로 만든다
- 마커는 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)"
ch03 에서 본 것처럼 get_pin_input 은 폴링 입니다. 폴링 주기 사이에 잠깐 올라갔다 내려간 신호(펄스)는 읽지 못할 수 있습니다. 그래서 산업 현장의 신호 약속은 대개 "상대가 확인했다고 답할 때까지 신호를 유지 한다" 는 4단계 핸드셰이크를 씁니다.
시뮬레이터 5 · IO 핸드셰이크 타이밍#
AGV 가 t = 1.0 s 에 도착해 REQ 를 올립니다. 팔은 50 ms 마다 입력을 보고, REQ 를 보면 작업을 시작합니다. 세 가지 약속 방식을 비교하세요.
해 볼 것
- 펄스 방식 에서 AGV 폴링 200 ms · 펄스 폭 100 ms 로 두고 "위상 200가지로 성공률 계산" 을 누릅니다. 놓침은 몇 번인가요? 펄스 폭을 200 ms, 300 ms 로 늘리면? 놓치지 않으려면
펄스 폭 ≥ 폴링 주기가 필요한 이유를 그림의 초록 점으로 설명합니다. - 펄스 폭 300 ms 에서 잡음 을 켭니다. 위험 출발이 생기나요? 폴링 주기를 20 ms 로 줄이면 잡음을 더 잘 잡을까요, 더 잘 속을까요? 디바운스 를 켜면?
- 레벨 + 응답 으로 바꿉니다. 폴링 주기를 1000 ms 까지 늘려도 놓침이 생기나요? 대신 무엇을 잃나요(출발 시각)?
- 신호 없이 타이머 로 바꾸고 팔 작업 시간을 1.5 → 2.5 → 3.5 s 로 늘립니다. 어느 순간부터 "위험 - 팔이 작업 중인데 출발" 이 나오나요? 팔이 물건을 들고 AGV 위로 뻗어 있을 때 AGV 가 출발하면 무슨 일이 생길까요?
- 레벨 + 응답에서 팔 작업 시간을 5 s, 타임아웃을 4 s 로 둡니다. 결과를 보고 "타임아웃은 얼마로 정해야 하는가" 를 팔 작업 시간 · 폴링 주기로 한 줄 규칙으로 씁니다.
관찰 포인트 — 폴링은 주기 사이의 일을 보지 못하므로, 펄스는 폭이 폴링 주기보다 짧으면 위상에 따라 놓칩니다. 놓친 AGV 는 타임아웃까지 서 있다가 오류로 갑니다(사람 호출). 잡음은 폴링이 빠를수록 더 잘 "읽혀서" 오히려 속기 쉽고, 디바운스(연속 n번 확인)가 이를 막습니다. 4단계 핸드셰이크는 각 신호를 상대가 확인할 때까지 유지 하므로 폴링 주기 · 위상과 상관없이 놓치지 않으며, 대가는 응답 단계만큼의 시간입니다. 타이머 방식은 팔이 느려지는 날 바로 사고가 납니다. 타임아웃은 팔 작업 최대 시간 + 핸드셰이크 왕복(폴링 주기 몇 개) + 여유 보다 길어야 합니다.
AGV 폴링 200 ms, 펄스 방식에서 펄스 폭 100 ms 로 200가지 위상을 돌렸더니 약 절반이 "놓침(타임아웃)" 이었습니다. 위상 · 지연과 상관없이 놓침을 0 으로 만드는 가장 확실한 방법은?
- 펄스 폭을 150 ms 로 늘린다
- AGV 폴링 주기를 150 ms 로 줄인다
- 팔이 DONE 을 AGV 가 REQ 를 내릴 때까지 유지하는 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 ~ 5 | 2교시 시뮬레이터 3 |
| 배정 규칙 | 가장 가까운 · 배터리 우선 · 라운드로빈 | 2교시 |
| 통행 규칙 | 구역 예약 · 일방통행 · 대기 구역 | 2교시 |
| 최고 속도 | 0.5 ~ 1.5 m/s | ch01 정지 거리, 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가지를 바로 계산합니다. 지도는 첫 번째 순서를 재생합니다. 마음에 드는 설정은 팀 이름을 적고 팀 기록에 추가 를 눌러 아래 표에 모읍니다(이 페이지를 닫으면 지워집니다).
해 볼 것
- 기준 만들기 — 처음 설정(A · 3대 · 규칙 없음 · 1.0 m/s · 감속 · 20 %)의 점수를 적고 ▶ 로 재생합니다. 끝까지 못 끝낸 주문 순서가 있나요? 마지막에 서 있는 로봇이 어디에 있는지 봅니다.
- 구역 예약 만 켜고, 이어 대기 구역 도 켭니다. 대기 구역을 켜야 20건이 모두 끝나는 이유를 재생 화면에서 찾습니다. (힌트: 주문이 다 배정된 뒤 일이 없는 로봇은 어디에 서 있나요?)
- 예측하기의 ① ~ ⑤ 를 하나씩 바꿔 점수를 표로 적습니다. 예측과 맞았나요? ③ 사람 구역 감속을 끄면 시간 보너스는 오르는데 합계는 어떻게 되나요?
- 4대 · 임계값 10 % 와 20 % 를 비교합니다. 10 % 가 점수는 높은데, 3대 · 10 % 에서는 무슨 일이 생기나요? 실제 현장이라면 어느 쪽을 제출하겠습니까?
- 팀별로 "교착 · 과속 · 방전 0" 을 지키면서 가장 높은 점수를 찾아 팀 기록에 추가 합니다. 같은 점수라면 총 주행 거리 · 에너지가 적은 설정이 더 좋은 설정입니다.
관찰 포인트 — 점수를 가장 크게 바꾸는 것은 로봇의 최고 속도가 아니라 시스템 규칙 입니다. 일 없는 로봇이 출고장에 서 있으면 마지막 주문이 영원히 끝나지 않고(대기 구역), 임계값 하나로 로봇 한 대가 일하거나 길 위에서 멈춥니다. 속도 1.0 → 1.5 m/s 는 적재 · 하역 · 사람 구역 감속 시간이 그대로라 몇 점밖에 오르지 않지만, 사람 구역 감속을 어기면 시간 보너스로 얻는 것보다 수십 배를 잃습니다. 대수를 늘리면 점수가 오르지만 5대부터는 이득이 줄어듭니다. 그리고 주문 순서 3가지 평균으로 보면 "한 번 운 좋게 통과한" 설정이 걸러집니다.
기준(A · 3대 · 구역 예약 + 대기 구역 · 1.0 m/s · 감속 · 20 %)은 57.8 점입니다. 속도를 1.5 m/s 로 올리면 59.8 점, 거기에 사람 구역 감속을 끄면 −128.8 점이 되었습니다. 이 결과에서 끌어낼 수 있는 가장 알맞은 결론은?
- 속도 1.5 m/s 는 위험하므로 처리량이 오히려 떨어진다
- 1건의 시간 대부분이 적재 · 하역 · 사람 구역 통과라서 최고 속도의 효과는 작고, 감속을 어기면 시간은 줄지만 위반 20번(−200 점)이 모든 이득을 지운다
- 채점 규칙이 잘못되었으니 감점을 없애야 한다
- 사람 구역 감속을 끄면 에너지 점수가 떨어져서 합계가 낮아진다
정답 보기
② — 1.5 m/s 에서도 20건을 끝내는 시각은 484 → 455 s 정도로만 당겨집니다. 주행 외 시간(적재 8 s + 하역 8 s, 0.3 m/s 구간)이 그대로이기 때문입니다. 감속을 끄면 끝내는 시각이 약 340 s 로 크게 당겨지고 에너지 점수도 오히려 오르지만(④ 아님), 주문마다 사람 구역에 과속으로 들어가 위반이 20번 쌓입니다. 평가판의 감점은 "실물에서 이러면 시연을 멈춘다" 는 뜻이며(③), 안전 규칙은 점수와 바꾸는 값이 아닙니다.4대 · 구역 예약 + 대기 구역에서 임계값 10 % 는 72.3 점, 20 % 는 66.7 점입니다. 그런데 3대에서 10 % 로 바꾸면 27.6 점으로 떨어지고 방전이 1번 생깁니다. 가장 알맞은 해석은?
- 10 % 가 언제나 더 좋으니 10 % 를 제출한다
- 11 % 로 시작한 로봇 1 이 일을 계속하므로, 4대일 때는 일이 빨리 끝나 운 좋게 버티지만 3대일 때는 오래 일하다 보호 하한에 닿는다 — 여유가 없는 설정이므로 실물에는 20 % 처럼 여유 있는 값을 쓴다
- 3대에서는 구역 예약이 꺼져서 방전된다
- 임계값은 처리량과 상관이 없다
정답 보기
② — 임계값 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 를 채우지 않아도 오류 없이 실행되지만 결과가 틀리게 나옵니다.
시뮬레이터 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 는 몇 등일까요?
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 이기 때문입니다.
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 %)보다 효과가 큽니다.
시뮬레이터 2 의 표를 Python 클래스로 옮기고, 시뮬레이터가 보내는 이벤트 목록(중복 · 뒤바뀜 · 비상정지 포함)을 넣어 상태가 꼬이지 않는지 확인합니다. 확인 문제 1-3 의 guard 도 넣습니다.
- TODO 1 비상정지 · 경로 막힘 →
ERROR(멈춘 상태 저장),ERROR에서는reset만 받아 저장한 상태로 - TODO 2 표에 없는 이벤트는 무시하고 횟수 세기
- TODO 3
IDLE의 주문 배정에 배터리 guard — 임계값보다 낮으면TO_CHARGE - 합격 조건: 출력 맨 아래 검사 세 줄이 모두 "통과"
예측 먼저 — 시나리오 [1] 에서 무시되는 이벤트는 몇 개일까요? 시뮬레이터 2 의 빨간 줄 수와 같을까요?
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), 비상정지를 처리하지 못해 검사 세 줄이 모두 "실패" 입니다.
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()에 넣습니다.
교통(서로 막는 일)을 뺀 단순 모델로 3시간 운용을 돌려, 배정 규칙만의 차이를 봅니다. 도착률 3 건/분은 로봇 3대가 처리할 수 있는 양이라 대기 로봇이 자주 둘 이상 생깁니다.
- TODO 1 ~ 3
pick_robot()— 가장 가까운 로봇 · 배터리 우선 · 라운드로빈 - 합격 조건: 세 규칙의 줄이 서로 다르고, 빈 차 주행은 nearest 가, 배터리 차는 battery 가, 로봇별 건수의 고르기는 rr 가 가장 좋음
예측 먼저 — 완료 건수는 세 규칙에서 얼마나 다를까요?
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 는 늘 첫 번째 대기 로봇을 고르므로 세 줄이 똑같이 나옵니다.
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 에서 주문이 넘칠 때 규칙 차이가 거의 없던 것과 비교하세요.
시뮬레이터 3 의 한 순간을 "로봇 → 기다리는 로봇" 그래프(wait-for graph)로 바꾸고, 순환이 있으면 교착으로 판정합니다. 이어 구역 예약 규칙("두 칸 앞에 남의 구역이 있으면 지금 칸에서 기다린다")을 함수로 만듭니다.
- TODO 1
find_cycle()— DFS 로 순환 찾기 (보는 중인 곳으로 돌아오면 순환) - TODO 2
needs_reservation()— 앞 두 칸 안의 구역이 다른 로봇 것이면(True, 구역) - 합격 조건: 네 장면 중 "적재 중인 로봇 뒤에서 대기" 만 교착이 아니고, 마지막 두 줄이
(True, 'aisle1'),(False, None)
예측 먼저 — "출고장 앞 막힘" 은 로봇 셋 중 누구와 누구의 순환일까요?
# 교착 탐지기: "누가 누구를 기다리는가(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)으로 냅니다.
# 교착 탐지기: "누가 누구를 기다리는가(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처럼 들어가기 한 칸 전에 검사합니다. 입구 칸에서 기다리면 그 칸이 막혀 나오려는 로봇과 새 교착이 생기기 때문입니다.
시뮬레이터 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: 저속 + 마커), 팔이 길수록 보정 없음 성공률이 낮음
예측 먼저 — "세 가지 모두" 는 몇 등일까요?
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 로 같습니다.
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 가 그 측정입니다.
시뮬레이터 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가지 중 몇 번 성공할까요?
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번 모두 "위험" 이 납니다.
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 디바운스).
시뮬레이터 6 의 결과(주문 순서 3가지)를 옮겨 적은 팀 기록으로 채점 규칙을 직접 구현하고 순위를 냅니다. 발표 때 "점수가 왜 이렇게 나왔는지" 를 항목별로 설명하는 데 씁니다.
- TODO 1 시간 보너스, TODO 2 에너지 점수, TODO 3 안전 감점
- 합격 조건: 3조 72.3 · 1조 57.7 · 4조 46.2 · 2조 −128.8 순서, "안전 규칙을 지킨 팀 중 1등" 이 3조
예측 먼저 — 2조는 처리 · 시간 · 에너지에서 모두 1조보다 높습니다. 몇 점 차이로 꼴찌가 될까요?
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조를 구별하지 못합니다.
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 인가" 를 꼭 보여 줍니다.
실물 시연 계획서를 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 보다 길까요?
# 실물 시연 계획서 검사기 - 계획서(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 는 정지 영역과 충전 임계값 줄이 빠져 있어, 처음 계획서에서 정지 영역 실패를 찾지 못합니다.
# 실물 시연 계획서 검사기 - 계획서(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"] 으로 좌표를 읽을 수 있음).
1교시의 미션 상태 머신을 진짜 API 로 돌립니다. 이동 중 파랑 · 작업 중 주황 · 대기 초록 · 오류 빨강 LED 를 켜고, 범퍼가 눌리면 미션을 멈춥니다. 위치는 AMCL 대신 agvsim.get_pose() 를 씁니다.
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")바꿔 보기
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()으로 먼저 계산하세요.- 일부러 경유점 하나를 기둥(3.5, 0.9) 위로 옮겨 실행합니다. 보호 영역 때문에 멈춘 채
timeout이 나는지, 범퍼로FAILED가 나는지 보고, 2교시의 교통 관리 · 재계획 규칙을 어디에 넣을지 정합니다. - 미션 끝의 배터리 전압을 4교시 프로젝트의 충전 정책(ch09)에 넣어, 몇 번 돌면 충전 독으로 가야 하는지 계산합니다.
실습 (실물)#
myAGV Pro 한 대(가능하면 로봇팔 또는 팔 대신 스위치 · 버튼을 IO 에 연결한 상자)로 합니다. 실물 실습은 시뮬레이터의 가정값을 실제 값으로 바꾸는 측정 이 목적이며, 다중 AGV 시연은 4교시 계획서가 통과한 팀만 합니다.
실물 실습 1 — IO 핸드셰이크 (3교시)
팔 대신 스위치 하나로 시작합니다. AGV 출력 1 에 LED(또는 팔의 입력), AGV 입력 1 에 스위치(또는 팔의 출력)를 연결합니다. 배선 전압 · 극성은 공식 문서의 IO 핀 설명을 먼저 확인합니다(확인 필요). 아래 코드는 실습 3-2 의 level 모드를 실물 API 로 옮긴 것입니다.
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) 마지막 주문 하나가 끝나지 않음#
[mission] order 20 assigned to agv_2, state=TO_DROP ... (10 분 뒤에도 같은 줄)- 원인: 일을 마친 다른 로봇이 출고장 칸에
IDLE로 서 있고, 남은 주문이 없어 영원히 비켜 주지 않습니다(시뮬레이터 6 의 "규칙 없음" · "구역 예약만"). 교착이 아니라서 탐지기에도 걸리지 않습니다. - 해결: 하역이 끝나면 대기 구역으로 가는 것까지 를 미션의 일부로 넣습니다. 대기 칸이 출고장 · 통로 입구를 막지 않는지 지도에서 확인합니다.
2) 상태 머신이 짐 없이 출고장으로 감#
[agv_1] LOADING -> TO_DROP (event=loaded) # 그런데 선반 앞에 도착한 적이 없음- 원인: 이벤트를 표 없이
if event == "loaded": state = "TO_DROP"처럼 처리해, 도착 전에 들어온 적재 완료 신호(배선 잡음 · 이전 미션의 늦은 신호)를 받아들였습니다. - 해결: "현재 상태 + 이벤트" 표에 있는 조합만 받습니다(실습 1-2). IO 신호는 디바운스하고, 미션마다 번호를 붙여 이전 미션의 신호를 버립니다.
3) 로봇이 늘었는데 처리량이 그대로이거나 줄어듦#
agents=3 throughput=204/h agents=4 throughput=250/h agents=5 throughput=278/h (operator interventions: 6)- 원인: 공유 자원(좁은 통로 · 출고장 · 사람 구역)이 병목입니다. 대수를 늘리면 그 앞의 대기만 늘어납니다.
- 해결: 히트맵에서 가장 진한 칸을 찾아 그 자원을 늘리거나(출고장 하나 더, 통로 넓히기) 일방통행 · 구역 예약으로 흐름을 정리합니다. 대수를 늘리기 전에 1대 처리량 × 대수 대비 몇 % 인지 먼저 봅니다.
4) 구역 예약을 켰는데도 통로 입구에서 서로 멈춤#
[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 가 출발함#
[agv] DONE=1 detected -> departing # 팔 로그: t=1.61s grasp in progress- 원인: DONE 선의 짧은 잡음을 완료 신호로 읽었거나, 신호 없이 타이머로 출발했습니다(시뮬레이터 5).
- 해결: 디바운스(연속 2번 이상) + 4단계 핸드셰이크를 씁니다. 출발 조건에 "DONE 이 1 이었다가 0 으로 내려감" 을 넣고, 팔이 홈 자세임을 알리는 신호를 하나 더 두면 더 안전합니다.
6) 핸드셰이크가 가끔 타임아웃 남#
[agv] handshake timeout after 6.0 s (REQ=1, DONE never seen)- 원인: 팔이 DONE 을 펄스로 짧게 내고, AGV 폴링 주기가 그보다 깁니다. 위상에 따라 확률적으로 놓칩니다. 팔 작업이 타임아웃보다 길어지는 날(무거운 물건, 재시도)에도 납니다.
- 해결: DONE 을 레벨로 유지하게 팔 쪽 프로그램을 고칩니다. 타임아웃은
팔 최대 작업 시간 + 폴링 몇 주기 + 여유로 잡습니다(실습 4-2).
7) 도킹은 맞는 것 같은데 긴 팔에서만 집기 실패가 잦음#
pick failed: object offset dy=+1.6 cm (tolerance 1.0 cm)- 원인: 방향 오차 θ 가 팔 길이 L 만큼 불어나 좌우로 어긋납니다(
ey + L · θ). 위치(x · y)만 보고 각도를 무시했습니다. - 해결: 도킹 후 각도를 따로 재서 보정하거나(횡이동 · 제자리 회전 미세 보정), 마커로 팔이 직접 보정합니다. 각도 오차를 측정표에 꼭 넣습니다(실물 실습 2).
8) 평가판 점수가 주문 순서마다 크게 다름#
seed 2026: 72.3 seed 7: 27.6 seed 42: 70.1- 원인: 임계값을 낮춰 배터리가 거의 없는 로봇이 일하게 했거나, 교착이 일부 순서에서만 나는 등 여유 없는 설정 입니다.
- 해결: 평균보다 가장 나쁜 순서 의 점수를 봅니다. 방전 · 교착 · 과속이 한 번이라도 나는 설정은 제출하지 않습니다.
9) Playground 에서 출력 한글이 깨지거나 실습 코드가 멈춘 것처럼 보임#
(30초 넘게 출력 없음)- 원인: 실습 2-1 (3시간 × 1 s 단계) · 3-2 (1 ms 단계 × 위상 200가지 × 여러 조건)는 브라우저 Python 에서 수 초 ~ 수십 초 걸릴 수 있습니다.
- 해결: 기다리거나,
T·n을 줄여 먼저 돌려 봅니다. 결과의 경향은 같습니다.
과제#
3 ~ 4명이 한 팀입니다. 발표 10 분, 질문 5 분.
- 설정표 — 시뮬레이터 6 의 설정(배치 · 대수 · 배정 규칙 · 통행 규칙 · 속도 · 감속 · 임계값)과 점수(항목별), 주문 순서 3가지 중 가장 나쁜 점수를 제출합니다. 교착 · 과속 · 방전이 0 이어야 합니다.
- 근거 세 가지 — 1교시(배치 · 처리량), 2교시(대수 · 교통 규칙), 3교시(도킹 · 핸드셰이크) 시뮬레이터에서 하나씩, "이 값을 바꾸면 이렇게 나빠진다" 를 숫자로 보입니다.
- 실물 측정 반영 — 실물 실습 2 에서 잰 도킹 오차로 실습 3-1 의 표를 다시 만들고, 우리 팀이 쓸 보정 방법을 고릅니다.
- 시연 계획서 — 4교시 표와 실습 4-2 검사 결과(모두 통과)를 붙입니다. 비상정지 담당자 이름을 적습니다.
- 한계 — 이 평가판이 무시한 것(위치 추정 오차, 경로 계획 시간, 사람의 움직임, 실제 충전 시간)을 두 가지 이상 들고, 실물에서 어떻게 확인할지 씁니다.
개인 과제:
- 레이아웃 보고서: 실습 1-1 로 통로 폭 0.6 ~ 2.0 m · 입출고장 두 위치 · ABC 유무 표(3 × 8 × 2 × 2)를 만들고, "보관 칸 300 이상에서 처리량 최대" 인 조건을 찾아 한 문단으로 씁니다.
- 교통 규칙 표: 시뮬레이터 3 에서 대수 1 ~ 5 × 통행 규칙 5가지의 처리량 · 교착 표를 채우고, 대수마다 1등 규칙을 표시합니다. 순위가 바뀌는 대수와 그 이유를 씁니다.
- 상태 머신 확장: 실습 1-2 에
TO_PARK(대기 구역 이동) 상태와 "주문 취소(짐 실음)" 를 처리할RETURN(선반으로 되돌려 놓기) 상태를 넣고, 표와 테스트 이벤트 목록을 만듭니다. - 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 뷰어