CH11물류 통합 프로젝트: 자동충전과 다중 AGV
작업 상태 기계로 피킹 · 이송 · 자동충전을 묶고, 다중 AGV 교차로 규칙과 작업 배정을 설계해 창고 물류 시나리오를 팀 단위로 완성합니다.
학습 목표#
- 대기 → 픽업 이동 → 적재 → 이송 → 하역 → 복귀를 상태 기계(FSM) 로 설계하고, 경로 막힘 · 배터리 경고 · 모터 오류가 생겼을 때 어느 상태로 가야 하는지 상태 전이 표로 예측 · 확인할 수 있습니다. 상태마다 LED 색 · 펌프 상태를 정하고, 시각 · 상태 · 위치 · 전압을 CSV 로그로 남겨 사후 분석할 수 있습니다.
- 공식 자동 충전 기능(
myagv_plus_autocharge)의 두 단계(Nav2 로 도크 앞 0.35 m → 적외선 안내 직렬 도킹)를 설명하고, 접근 속도 · 정렬 허용 오차 · 측면 이동(vy)이 도킹 성공률과 시간에 주는 영향을 시뮬레이터로 찾을 수 있습니다. - 19.6 V 경고에서 "작업 마치고 충전" 과 "즉시 충전" 의 장단점을 말하고, 충전 시작 전압을 바꿨을 때 8시간 처리량이 늘지 줄지 충전 횟수 · 충전 시간 · 저전압 위험으로 설명할 수 있습니다.
- 다중 로봇의 교차로 충돌 · 좁은 통로 마주침 · 교착(deadlock) 을 구분하고, 경로 예약 · 일방통행 · 대기 지점 규칙과 작업 배정 규칙(가까운 · 한가한 · 배터리 고려)을 비교해 고를 수 있습니다. 실물 여러 대는
ROS_DOMAIN_ID· 네임스페이스로 나눌 수 있습니다. - 팀 시나리오를 설계해 시뮬레이터로 30분 실행하고, 완료 주문 · 평균 배송 시간 · 최소 장애물 거리 · 안전 정지 횟수로 평가한 뒤 실물 시연 결과와 비교해 보고할 수 있습니다.
이 페이지에는 브라우저에서 바로 동작하는 시뮬레이터 5개가 있습니다. 피킹 스테이션 상태 기계, 충전 도크 도킹, 8시간 배터리 정책, 다중 로봇 교차로, 팀 시나리오 실행기입니다. 조작하기 전에 결과를 먼저 예측해 적고 확인하세요. Playground 실습(표준 라이브러리 + numpy)은 시뮬레이터와 같은 규칙으로 만들었습니다. 시뮬레이터 1 이 내보낸 CSV 를 실습 과제 1-2 가, 시뮬레이터 3 의 8시간 모델을 실습 과제 2-2 가 그대로 씁니다. 실물 전용 코드는 "실물 전용" 블록으로 따로 둡니다.
공식 자료 기준 (myagvPlus_docs 6.1.2 · 6.2.1 · 6.2.5 · 6.2.7): 배터리 경고 19.6 V · 저전압 19.0 V, LED · 펌프 API(ch05). 자동 충전은 워크스페이스 ~/myagv_plus_ros2 의 myagv_plus_autocharge 패키지로, bringup → navigation2_active.launch.py → ros2 run myagv_plus_autocharge combined_auto_recharger 순서로 켜고 터미널에서 p 키로 시작합니다. 도크 위치는 config/charger_position.json(p_x · p_y · orien_z · orien_w)에 저장되며, Enter 키(1초 동안 자세를 모아 중앙값 저장) 또는 RViz 의 2D Goal Pose(/charger_position_update)로 기록합니다. config/nav_goal_params.yaml 의 forward_distance: 0.35(도크 앞 0.35 m) · yaw_offset_deg: 0.0. 도착하면 USB-CAN 직렬 포트로 도크의 0x182 안내 프레임을 읽어 그 x · z 속도로 /cmd_vel 을 내고, 연결되면 Charging current detected: 210.0 mA - docking complete 처럼 출력합니다. 같은 LAN 의 여러 대는 ROS_DOMAIN_ID 를 다르게 합니다(ch09). 교육용 가정: 시뮬레이터의 창고 지도 · 주문 · 거리, 배터리 소모(ch05 와 같은 60 Wh × 2 · 쉬는 전압 표 · 내부 저항 0.25 Ω, 시뮬레이터 1 에서는 10배쯤 빨리 닳게 함), 충전 전력(100 W, 80 % 넘으면 줄어듦), 도킹 모델(접점 허용 ±12 mm · ±3°, 0.15 m/s 넘으면 튕김, 정렬 후 직진), 다중 로봇의 칸 이동 · 교착 회복 · 보행자 출현 · 제동 거리(반응 0.1 s, 감속 1.0 m/s²), 평가 점수 식. 실물의 충전 전류 · 도킹 허용 오차 · 충전 시간은 확인 필요입니다.
1교시 · 작업 상태 기계: 피킹 · 이송 · 하역#
왜 상태 기계인가#
ch10 에서 Nav2 로 "어디로 가라" 는 명령은 보낼 수 있게 되었습니다. 그런데 물류 로봇의 하루는 "가라" 만으로 끝나지 않습니다. 선반 앞에서 상자를 흡착하고, 출고장에 내려놓고, 다음 주문을 받고, 중간에 통로가 막히거나 배터리가 떨어지면 다른 일을 해야 합니다. 이걸 if 문을 겹겹이 쌓아 만들면 "상자를 든 채로 충전하러 가도 되나?", "막혔을 때 몇 번까지 다시 해 보나?" 같은 질문에 코드가 답하지 못합니다.
상태 기계(FSM, Finite State Machine) 는 로봇이 할 일을 상태(지금 무엇을 하는 중인가)와 사건(무엇이 일어났나)으로 나누고, (지금 상태, 사건) → 다음 상태 를 표로 적는 방법입니다.
- 한 순간에 상태는 하나입니다. "이송 중이면서 충전 중" 은 없습니다.
- 상태마다 하는 일(LED 색, 펌프, 목표 지점)이 정해져 있습니다. 상태만 보면 로봇이 무엇을 하는지 압니다.
- 표에 없는 조합은 "무시하고 기록" 합니다. 이상한 사건이 와도 엉뚱한 동작을 하지 않습니다.
정상 흐름: 대기 → 픽업 이동 → 적재 → 이송 → 하역 → 복귀#
| 상태 | 하는 일 | LED (set_led_color) | 펌프 (set_pump_io) | 끝나는 사건 → 다음 상태 |
|---|---|---|---|---|
대기 IDLE | 주문을 기다림 | 흰색 | 끔 | order → 픽업 이동 |
픽업 이동 GO_PICK | 선반 앞으로 주행 (Nav2 목표) | 파랑 | 끔 | arrived → 적재 |
적재 LOAD | 흡착 펌프로 상자를 듦 (3 s) | 노랑 | 켬 (Low) | loaded → 이송 |
이송 GO_DROP | 출고장으로 주행 | 초록 | 켬 | arrived → 하역 |
하역 UNLOAD | 펌프를 꺼 내려놓음 (2 s) | 노랑 | 끔 | unloaded → 복귀 (또는 바로 다음 주문) |
복귀 RETURN | 대기 지점으로 주행 | 하늘색 | 끔 | arrived → 대기, order → 픽업 이동 |
- 이송 중에는 펌프가 계속 켜져 있어야 합니다. 상태가 바뀔 때만 펌프를 만지면 "펌프를 켠 채 하역 상태에 들어가는" 실수가 사라집니다(ch05 의 반전 논리
PUMP_ON = 0을 잊지 마세요). - LED 색은 사람이 멀리서 로봇의 상태를 읽는 수단입니다. ch05 에서 본 것처럼
set_led_mode(1)을 먼저 불러야 색이 바뀝니다.
예외 상태: 경로 막힘 · 배터리 경고 · 모터 오류#
| 사건 | 생기는 곳 | 가는 상태 | 하는 일 | 돌아오는 길 |
|---|---|---|---|---|
path_blocked (통로에 상자) | 이동 상태 4개 | 경로 막힘 BLOCKED (주황 깜빡) | 정지 → 정해진 시간 기다림 → 재계획 | 치워지면 cleared, 우회로가 있으면 replan → 막히기 전 상태 |
재시도 초과 (no_path) | 경로 막힘 | 안전 정지 FAULT (빨강) | 정지 · 관제에 보고 | 사람이 치우고 error_cleared → 막히기 전 상태 |
battery_warn (19.6 V 이하) | 어디서나 | 정책에 따라 다름 | "작업 마치고": 충전 예약만 / "즉시": 바로 충전 이동 | charged → 하던 주문 |
motor_error (구속 · 오류 코드) | 어디서나 | 안전 정지 FAULT | 정지 · 펌프는 유지(상자를 떨어뜨리지 않음) · 보고 | 원인 제거 → clear_motor_error → 멈추기 전 상태 |
low_voltage (주행 중 19.0 V 미만) | 이동 상태 | 안전 정지 FAULT | ch05 의 주행 잠금 | 사람이 도크로 밀어 옮김 → 충전 |
핵심은 "막히기 전 상태(PREV)" 를 기억하는 것입니다. 막힘 · 안전 정지에서 돌아올 때 어디로 돌아갈지 모르면, 상자를 든 로봇이 다시 픽업하러 가는 일이 생깁니다.
ch05 에서 본 것처럼 clear_motor_error() 는 오류 코드만 지웁니다. 바퀴를 막은 물건은 그대로입니다. FSM 에서 FAULT → 이전 상태 전이는 사람이 원인을 없앤 뒤 버튼을 누른 사건으로만 일어나게 하고, 자동으로 넘어가지 않게 만듭니다.
시뮬레이터 1 · 피킹 스테이션에서 주문 5건 처리#
ch10 의 피킹 스테이션과 같은 크기(12 m × 8 m)의 창고입니다. 로봇은 대기(왼쪽 위) 에서 출발해 선반 A → B → C → D → B 의 상자를 차례로 출고장(오른쪽) 에 옮깁니다. 오른쪽 그림이 상태 기계이고, 지금 상태가 LED 색으로 칠해지며 마지막 전이가 굵은 화살표로 표시됩니다. 아래에는 CSV 로그가 쌓입니다. 배터리는 상태 변화를 보기 쉽게 실제보다 10배쯤 빨리 닳게 했습니다(교육용 가정).
- 기본값으로 ▶ 를 눌러 주문 5건을 끝냅니다. 전체 시간과 상태 전이 순서를 적습니다. 하역 뒤 "복귀" 상태가 왜 거의 보이지 않을까요?
- ↺ 후 다시 시작하고, 로봇이 이송 중일 때 📦 앞 통로에 상자 를 누릅니다. 로봇은 어느 상태로 가서 몇 초 뒤 무엇을 할까요? 막힘 대기 를 15 s 로 바꾸고 "작업자가 10 s 뒤 상자를 치움" 을 켠 뒤 다시 해 보면 마지막 전이의 사건 이름이 어떻게 달라지나요?
- 로봇이 선반 A 로 가는 동안 선반 A 칸 자체를 클릭해 상자로 막습니다. 우회로가 없을 때 재시도 2회가 끝나면 어느 상태가 되나요? 그때까지 몇 초가 걸릴지 (막힘 대기 × (재시도 + 1)) 로 예측해 봅니다.
- 이송 중에 ⚡ 모터 오류 주입 을 누르고 펌프 표시를 봅니다. 🔧 를 누르면 어느 상태로 돌아가나요?
- 시작 배터리 15 % 로 ↺ 하고 "작업 마치고 충전" 과 "즉시 충전" 을 각각 끝까지 돌립니다. 어느 쪽이 충전 도크에 무사히 도착하나요?
- 기본값에서 주문 5건은 약 169 s 에 끝납니다. 주문이 남아 있으면 하역 직후
unloaded로 바로 픽업 이동으로 가므로 복귀 상태는 마지막 한 번만 보입니다. - 이송 중 상자를 놓으면
path_blocked로 경로 막힘에 들어가 정지합니다. 3 s 뒤 선반 반대편으로 돌아가는 우회로를 찾아replan으로 이송에 돌아갑니다(1 m 앞에서 멈추므로 상자에 닿지 않음). 대기를 15 s 로 늘리고 작업자가 치우게 하면, 10 s 쯤에cleared로 원래 경로를 그대로 갑니다. "기다릴까, 돌아갈까" 는 막힘 대기 시간 하나로 정해집니다. - 목적지 칸이 막히면 우회로가 없으므로 3 s 대기 × 3 번(처음 + 재시도 2) ≈ 9 s 뒤
no_path_report로 안전 정지가 되고 보고합니다. 영원히 기다리지 않는 것이 핵심입니다. - 모터 오류에서도 이송 중이면 펌프는 켬으로 남습니다. 🔧 를 누르면 기억해 둔 이송으로 돌아가 경로를 다시 계획합니다.
- 시작 15 % 에서 "작업 마치고" 는 약 78 s(주문 3 이송 중)에 경고를 받고도 하역까지 마친 뒤 도크로 가다가, 도크 1 m 앞(125 s)에서 19.0 V 아래로 떨어져 주행 잠금(
low_voltage)이 됩니다. "즉시 충전" 은 75 s 에 상자를 든 채로 바로 도크로 가서 84 s 에 도킹합니다. 다음 교시에서 이 두 정책을 하루 단위로 비교합니다.
로그 남기기: CSV 로 사후 분석#
FSM 이 상태를 바꿀 때마다(그리고 5 s 마다) 한 줄씩 남기면, 나중에 "어디서 시간을 썼나", "언제 전압이 떨어졌나" 를 숫자로 볼 수 있습니다. 시뮬레이터 1 의 로그 형식은 다음과 같습니다.
t_s,state,x_m,y_m,volt_V,event
43.4,GO_DROP,8.75,3.25,19.93,box_added
46.6,BLOCKED,10.25,3.25,19.81,path_blocked
49.6,GO_DROP,10.25,3.25,19.90,replan
77.9,GO_DROP,4.75,1.25,19.59,battery_warn
125.1,FAULT,0.75,1.75,19.00,low_voltage- 열 이름을 첫 줄에 두고, 값에는 쉼표를 쓰지 않습니다(상태 · 사건 이름을 영어 대문자 · 밑줄로 정한 이유).
- 시각은 로봇이 켜진 뒤 초(또는 Unix 시각), 위치는 map 좌표(m), 전압은
get_all_msg()의 주 · 보조 중 낮은 값을 씁니다. - 실물에서는
print대신 파일에a(덧붙이기) 모드로 쓰고, 한 줄 쓸 때마다flush()합니다. 전원이 갑자기 꺼져도 그 전까지의 기록이 남습니다.
실습 과제 1#
상태 전이 표를 dict 로 만들고, 주문 5건 동안 일어나는 사건 39개를 차례로 넣어 상태와 LED 색이 어떻게 바뀌는지 출력합니다. 지금 코드는 예외 전이가 빠져 있어 path_blocked 가 "무시" 됩니다. TODO 세 곳을 채우세요. 예측 먼저: 25번 motor_error(적재 중) 다음의 26번 loaded 는 어떻게 처리되어야 할까요? 27번 error_cleared 뒤에는 어느 상태가 되어야 할까요?
# 주문 5건을 처리하는 작업 상태 기계 (dict 로 만든 상태 전이 표)
LED = {"IDLE": "흰색", "GO_PICK": "파랑", "LOAD": "노랑", "GO_DROP": "초록", "UNLOAD": "노랑",
"RETURN": "하늘", "BLOCKED": "주황 깜빡", "GO_CHARGE": "보라", "CHARGE": "보라 깜빡", "FAULT": "빨강"}
MOVING = ["GO_PICK", "GO_DROP", "RETURN", "GO_CHARGE"]
# (지금 상태, 사건) -> 다음 상태. "PREV" = 막히기(멈추기) 전 상태로 돌아감
TABLE = {
("IDLE", "order"): "GO_PICK",
("GO_PICK", "arrived"): "LOAD",
("LOAD", "loaded"): "GO_DROP",
("GO_DROP", "arrived"): "UNLOAD",
("UNLOAD", "unloaded"): "RETURN",
("RETURN", "order"): "GO_PICK",
("RETURN", "arrived"): "IDLE",
("GO_CHARGE", "docked"): "CHARGE",
("CHARGE", "charged"): "IDLE",
("FAULT", "error_cleared"): "PREV",
}
# TODO 1: 이동 상태(MOVING) 네 개 모두에서 "path_blocked" -> "BLOCKED"
# TODO 2: BLOCKED 에서 "cleared" · "replan" -> "PREV", "no_path" -> "FAULT"
class Fsm:
def __init__(self):
self.state, self.prev, self.need_charge = "IDLE", None, False
self.count = {}
def fire(self, ev):
s = self.state
if ev == "battery_warn": # 정책: 지금 작업을 마치고 충전
self.need_charge = True
return s, s, "충전 예약"
if ev == "motor_error":
nxt = "FAULT" # 어느 상태에서나 안전 정지
else:
nxt = TABLE.get((s, ev))
if nxt is None:
return s, s, "무시" # 이 상태에서 의미 없는 사건
if nxt == "PREV":
nxt = self.prev
# TODO 3: 하역을 마쳤을 때(UNLOAD + unloaded) 충전 예약이 있으면 RETURN 대신 GO_CHARGE
if nxt in ("BLOCKED", "FAULT") and s not in ("BLOCKED", "FAULT"):
self.prev = s # 돌아갈 곳 기억
if nxt == "CHARGE":
self.need_charge = False
self.state = nxt
self.count[nxt] = self.count.get(nxt, 0) + 1
return s, nxt, ""
EVENTS = [
"order", "arrived", "loaded", "arrived", "unloaded", # 주문 1
"order", "path_blocked", "replan", "arrived", "loaded", "arrived", "unloaded", # 주문 2: 통로에 상자
"order", "arrived", "loaded", "battery_warn", "path_blocked", "cleared", # 주문 3: 경고 + 막힘
"arrived", "unloaded", "docked", "charged",
"order", "arrived", "motor_error", "loaded", "error_cleared", "loaded", # 주문 4: 적재 중 모터 오류
"arrived", "unloaded",
"order", "path_blocked", "no_path", "error_cleared", "arrived", "loaded", # 주문 5: 목적지 앞이 막힘
"arrived", "unloaded", "arrived",
]
f = Fsm()
for i, ev in enumerate(EVENTS, 1):
a, b, note = f.fire(ev)
print("%2d %-13s %-9s -> %-9s LED %-8s %s" % (i, ev, a, b, LED[b], note))
print()
print("마지막 상태:", f.state)
print("상태별 들어간 횟수:", ", ".join("%s %d" % kv for kv in sorted(f.count.items())))풀이 코드 보기
# 주문 5건을 처리하는 작업 상태 기계 (dict 로 만든 상태 전이 표)
LED = {"IDLE": "흰색", "GO_PICK": "파랑", "LOAD": "노랑", "GO_DROP": "초록", "UNLOAD": "노랑",
"RETURN": "하늘", "BLOCKED": "주황 깜빡", "GO_CHARGE": "보라", "CHARGE": "보라 깜빡", "FAULT": "빨강"}
MOVING = ["GO_PICK", "GO_DROP", "RETURN", "GO_CHARGE"]
# (지금 상태, 사건) -> 다음 상태. "PREV" = 막히기(멈추기) 전 상태로 돌아감
TABLE = {
("IDLE", "order"): "GO_PICK",
("GO_PICK", "arrived"): "LOAD",
("LOAD", "loaded"): "GO_DROP",
("GO_DROP", "arrived"): "UNLOAD",
("UNLOAD", "unloaded"): "RETURN",
("RETURN", "order"): "GO_PICK",
("RETURN", "arrived"): "IDLE",
("GO_CHARGE", "docked"): "CHARGE",
("CHARGE", "charged"): "IDLE",
("FAULT", "error_cleared"): "PREV",
}
for s in MOVING:
TABLE[(s, "path_blocked")] = "BLOCKED"
TABLE[("BLOCKED", "cleared")] = "PREV"
TABLE[("BLOCKED", "replan")] = "PREV"
TABLE[("BLOCKED", "no_path")] = "FAULT"
class Fsm:
def __init__(self):
self.state, self.prev, self.need_charge = "IDLE", None, False
self.count = {}
def fire(self, ev):
s = self.state
if ev == "battery_warn": # 정책: 지금 작업을 마치고 충전
self.need_charge = True
return s, s, "충전 예약"
if ev == "motor_error":
nxt = "FAULT" # 어느 상태에서나 안전 정지
else:
nxt = TABLE.get((s, ev))
if nxt is None:
return s, s, "무시" # 이 상태에서 의미 없는 사건
if nxt == "PREV":
nxt = self.prev
if s == "UNLOAD" and ev == "unloaded" and self.need_charge:
nxt = "GO_CHARGE"
if nxt in ("BLOCKED", "FAULT") and s not in ("BLOCKED", "FAULT"):
self.prev = s # 돌아갈 곳 기억
if nxt == "CHARGE":
self.need_charge = False
self.state = nxt
self.count[nxt] = self.count.get(nxt, 0) + 1
return s, nxt, ""
EVENTS = [
"order", "arrived", "loaded", "arrived", "unloaded", # 주문 1
"order", "path_blocked", "replan", "arrived", "loaded", "arrived", "unloaded", # 주문 2: 통로에 상자
"order", "arrived", "loaded", "battery_warn", "path_blocked", "cleared", # 주문 3: 경고 + 막힘
"arrived", "unloaded", "docked", "charged",
"order", "arrived", "motor_error", "loaded", "error_cleared", "loaded", # 주문 4: 적재 중 모터 오류
"arrived", "unloaded",
"order", "path_blocked", "no_path", "error_cleared", "arrived", "loaded", # 주문 5: 목적지 앞이 막힘
"arrived", "unloaded", "arrived",
]
f = Fsm()
for i, ev in enumerate(EVENTS, 1):
a, b, note = f.fire(ev)
print("%2d %-13s %-9s -> %-9s LED %-8s %s" % (i, ev, a, b, LED[b], note))
print()
print("마지막 상태:", f.state)
print("상태별 들어간 횟수:", ", ".join("%s %d" % kv for kv in sorted(f.count.items())))실행 결과:
1 order IDLE -> GO_PICK LED 파랑
2 arrived GO_PICK -> LOAD LED 노랑
3 loaded LOAD -> GO_DROP LED 초록
4 arrived GO_DROP -> UNLOAD LED 노랑
5 unloaded UNLOAD -> RETURN LED 하늘
6 order RETURN -> GO_PICK LED 파랑
7 path_blocked GO_PICK -> BLOCKED LED 주황 깜빡
8 replan BLOCKED -> GO_PICK LED 파랑
9 arrived GO_PICK -> LOAD LED 노랑
10 loaded LOAD -> GO_DROP LED 초록
11 arrived GO_DROP -> UNLOAD LED 노랑
12 unloaded UNLOAD -> RETURN LED 하늘
13 order RETURN -> GO_PICK LED 파랑
14 arrived GO_PICK -> LOAD LED 노랑
15 loaded LOAD -> GO_DROP LED 초록
16 battery_warn GO_DROP -> GO_DROP LED 초록 충전 예약
17 path_blocked GO_DROP -> BLOCKED LED 주황 깜빡
18 cleared BLOCKED -> GO_DROP LED 초록
19 arrived GO_DROP -> UNLOAD LED 노랑
20 unloaded UNLOAD -> GO_CHARGE LED 보라
21 docked GO_CHARGE -> CHARGE LED 보라 깜빡
22 charged CHARGE -> IDLE LED 흰색
23 order IDLE -> GO_PICK LED 파랑
24 arrived GO_PICK -> LOAD LED 노랑
25 motor_error LOAD -> FAULT LED 빨강
26 loaded FAULT -> FAULT LED 빨강 무시
27 error_cleared FAULT -> LOAD LED 노랑
28 loaded LOAD -> GO_DROP LED 초록
29 arrived GO_DROP -> UNLOAD LED 노랑
30 unloaded UNLOAD -> RETURN LED 하늘
31 order RETURN -> GO_PICK LED 파랑
32 path_blocked GO_PICK -> BLOCKED LED 주황 깜빡
33 no_path BLOCKED -> FAULT LED 빨강
34 error_cleared FAULT -> GO_PICK LED 파랑
35 arrived GO_PICK -> LOAD LED 노랑
36 loaded LOAD -> GO_DROP LED 초록
37 arrived GO_DROP -> UNLOAD LED 노랑
38 unloaded UNLOAD -> RETURN LED 하늘
39 arrived RETURN -> IDLE LED 흰색
마지막 상태: IDLE
상태별 들어간 횟수: BLOCKED 3, CHARGE 1, FAULT 2, GO_CHARGE 1, GO_DROP 6, GO_PICK 7, IDLE 2, LOAD 6, RETURN 4, UNLOAD 5- 7 · 8번: 이동 중 막히면
BLOCKED로 갔다가replan으로 막히기 전 상태(GO_PICK) 로 돌아옵니다.prev를 기억하지 않으면 어디로 돌아갈지 모릅니다. - 16번: "작업 마치고 충전" 정책이라 경고는 예약만 하고 상태는 그대로입니다. 20번 하역이 끝나는 순간
RETURN대신GO_CHARGE로 갑니다(TODO 3). - 26번: 안전 정지 중에 온
loaded는 표에 없는 조합이라 무시됩니다. 27번에서 적재(LOAD)로 돌아가 흡착을 다시 확인한 뒤 28번에 이송으로 갑니다. - 33번: 재시도가 끝나
no_path→ 안전 정지로 보고합니다. 34번에서 사람이 치우고 해제하면, 안전 정지 직전 상태(BLOCKED)가 아니라 막히기 전 상태(GO_PICK) 로 돌아갑니다.BLOCKED → FAULT로 갈 때는prev를 덮어쓰지 않기 때문입니다.
시뮬레이터 1 을 시작 배터리 15 %, 작업 마치고 충전, 작업자가 상자를 치움 으로 돌리고, 주문 2 이송 중에 상자를 놓은 뒤, 주행 잠금이 걸리면 10 s 뒤 🔧 를 눌러 끝까지 실행한 로그입니다(사건이 있는 줄만 남김). 상태별로 머문 시간과 주문별 처리 시간을 구하세요. TODO 두 곳. 예측 먼저: 300 s 중 충전에 쓴 시간과 실제로 상자를 옮긴(이송) 시간 중 어느 쪽이 더 길까요?
import csv
import io
# 시뮬레이터 1 에서 복사한 CSV (시작 배터리 15 %, 작업 마치고 충전, 주문 2 에서 통로에 상자)
LOG = """t_s,state,x_m,y_m,volt_V,event
0.0,IDLE,0.75,7.25,20.23,start
1.1,GO_PICK,0.75,7.25,20.22,order
10.2,LOAD,3.25,5.25,20.05,arrived
13.2,GO_DROP,3.25,5.25,20.14,loaded
31.3,UNLOAD,11.25,4.25,19.90,arrived
33.3,GO_PICK,11.25,4.25,20.00,unloaded
40.4,LOAD,8.75,3.25,19.84,arrived
43.4,GO_DROP,8.75,3.25,19.93,loaded
43.4,GO_DROP,8.75,3.25,19.93,box_added
46.6,BLOCKED,10.25,3.25,19.81,path_blocked
49.6,GO_DROP,10.25,3.25,19.90,replan
53.4,GO_DROP,10.75,4.25,19.77,box_removed
53.7,UNLOAD,11.25,4.25,19.77,arrived
55.7,GO_PICK,11.25,4.25,19.86,unloaded
74.8,LOAD,4.75,1.25,19.60,arrived
77.8,GO_DROP,4.75,1.25,19.69,loaded
77.9,GO_DROP,4.75,1.25,19.59,battery_warn
96.9,UNLOAD,11.25,4.25,19.34,arrived
98.9,GO_CHARGE,11.25,4.25,19.44,unloaded
125.1,FAULT,0.75,1.75,19.00,low_voltage
135.2,CHARGE,0.75,0.75,19.07,manual_push
209.3,GO_PICK,0.75,0.75,23.80,charged
236.4,LOAD,8.25,6.75,23.55,arrived
239.4,GO_DROP,8.25,6.75,23.63,loaded
250.5,UNLOAD,11.25,4.25,23.51,arrived
252.5,GO_PICK,11.25,4.25,23.59,unloaded
259.6,LOAD,8.75,3.25,23.48,arrived
262.6,GO_DROP,8.75,3.25,23.56,loaded
269.7,UNLOAD,11.25,4.25,23.45,arrived
271.7,RETURN,11.25,4.25,23.53,unloaded
298.8,DONE,0.75,7.25,23.35,arrived"""
rows = list(csv.DictReader(io.StringIO(LOG.strip())))
for r in rows:
r["t_s"] = float(r["t_s"])
r["volt_V"] = float(r["volt_V"])
# 1) 상태별 머문 시간: 한 줄의 상태는 다음 줄 시각까지 유지됨
stay = {}
for a, b in zip(rows, rows[1:]):
pass # TODO 1: a 의 상태에 (b 시각 - a 시각) 을 더하기
total = rows[-1]["t_s"] - rows[0]["t_s"]
print("상태별 시간 (전체 %.1f s)" % total)
for s, d in sorted(stay.items(), key=lambda kv: -kv[1]):
print(" %-10s %6.1f s %5.1f %%" % (s, d, 100 * d / total))
# 2) 주문별 처리 시간: 픽업 이동 시작 -> 하역 끝(unloaded)
starts = [r["t_s"] for r in rows if r["state"] == "GO_PICK" and r["event"] in ("order", "unloaded", "charged")]
ends = [r["t_s"] for r in rows if r["event"] == "unloaded"]
print("\n주문별 처리 시간 (픽업 이동 시작 -> 하역 끝)")
# TODO 2: starts 와 ends 를 짝지어 "주문 i: 걸린 시간" 출력
print(" (TODO 2)")
# 3) 사건과 전압
ev = {}
for r in rows:
if r["event"]:
ev[r["event"]] = ev.get(r["event"], 0) + 1
warn = [r for r in rows if r["event"] == "battery_warn"]
low = [r for r in rows if r["event"] == "low_voltage"]
print("\n사건 횟수:", ", ".join("%s %d" % kv for kv in sorted(ev.items())))
print("첫 배터리 경고: %.1f s, %.2f V" % (warn[0]["t_s"], warn[0]["volt_V"]))
if low:
r = low[0]
print("저전압 정지: %.1f s, 위치 (%.2f, %.2f) m, 경고 후 %.1f s" % (r["t_s"], float(r["x_m"]), float(r["y_m"]), r["t_s"] - warn[0]["t_s"]))
print("최저 전압 %.2f V" % min(r["volt_V"] for r in rows))풀이 코드 보기
import csv
import io
# 시뮬레이터 1 에서 복사한 CSV (시작 배터리 15 %, 작업 마치고 충전, 주문 2 에서 통로에 상자)
LOG = """t_s,state,x_m,y_m,volt_V,event
0.0,IDLE,0.75,7.25,20.23,start
1.1,GO_PICK,0.75,7.25,20.22,order
10.2,LOAD,3.25,5.25,20.05,arrived
13.2,GO_DROP,3.25,5.25,20.14,loaded
31.3,UNLOAD,11.25,4.25,19.90,arrived
33.3,GO_PICK,11.25,4.25,20.00,unloaded
40.4,LOAD,8.75,3.25,19.84,arrived
43.4,GO_DROP,8.75,3.25,19.93,loaded
43.4,GO_DROP,8.75,3.25,19.93,box_added
46.6,BLOCKED,10.25,3.25,19.81,path_blocked
49.6,GO_DROP,10.25,3.25,19.90,replan
53.4,GO_DROP,10.75,4.25,19.77,box_removed
53.7,UNLOAD,11.25,4.25,19.77,arrived
55.7,GO_PICK,11.25,4.25,19.86,unloaded
74.8,LOAD,4.75,1.25,19.60,arrived
77.8,GO_DROP,4.75,1.25,19.69,loaded
77.9,GO_DROP,4.75,1.25,19.59,battery_warn
96.9,UNLOAD,11.25,4.25,19.34,arrived
98.9,GO_CHARGE,11.25,4.25,19.44,unloaded
125.1,FAULT,0.75,1.75,19.00,low_voltage
135.2,CHARGE,0.75,0.75,19.07,manual_push
209.3,GO_PICK,0.75,0.75,23.80,charged
236.4,LOAD,8.25,6.75,23.55,arrived
239.4,GO_DROP,8.25,6.75,23.63,loaded
250.5,UNLOAD,11.25,4.25,23.51,arrived
252.5,GO_PICK,11.25,4.25,23.59,unloaded
259.6,LOAD,8.75,3.25,23.48,arrived
262.6,GO_DROP,8.75,3.25,23.56,loaded
269.7,UNLOAD,11.25,4.25,23.45,arrived
271.7,RETURN,11.25,4.25,23.53,unloaded
298.8,DONE,0.75,7.25,23.35,arrived"""
rows = list(csv.DictReader(io.StringIO(LOG.strip())))
for r in rows:
r["t_s"] = float(r["t_s"])
r["volt_V"] = float(r["volt_V"])
# 1) 상태별 머문 시간: 한 줄의 상태는 다음 줄 시각까지 유지됨
stay = {}
for a, b in zip(rows, rows[1:]):
stay[a["state"]] = stay.get(a["state"], 0.0) + (b["t_s"] - a["t_s"])
total = rows[-1]["t_s"] - rows[0]["t_s"]
print("상태별 시간 (전체 %.1f s)" % total)
for s, d in sorted(stay.items(), key=lambda kv: -kv[1]):
print(" %-10s %6.1f s %5.1f %%" % (s, d, 100 * d / total))
# 2) 주문별 처리 시간: 픽업 이동 시작 -> 하역 끝(unloaded)
starts = [r["t_s"] for r in rows if r["state"] == "GO_PICK" and r["event"] in ("order", "unloaded", "charged")]
ends = [r["t_s"] for r in rows if r["event"] == "unloaded"]
print("\n주문별 처리 시간 (픽업 이동 시작 -> 하역 끝)")
for i, (a, b) in enumerate(zip(starts, ends), 1):
print(" 주문 %d: %6.1f s" % (i, b - a))
# 3) 사건과 전압
ev = {}
for r in rows:
if r["event"]:
ev[r["event"]] = ev.get(r["event"], 0) + 1
warn = [r for r in rows if r["event"] == "battery_warn"]
low = [r for r in rows if r["event"] == "low_voltage"]
print("\n사건 횟수:", ", ".join("%s %d" % kv for kv in sorted(ev.items())))
print("첫 배터리 경고: %.1f s, %.2f V" % (warn[0]["t_s"], warn[0]["volt_V"]))
if low:
r = low[0]
print("저전압 정지: %.1f s, 위치 (%.2f, %.2f) m, 경고 후 %.1f s" % (r["t_s"], float(r["x_m"]), float(r["y_m"]), r["t_s"] - warn[0]["t_s"]))
print("최저 전압 %.2f V" % min(r["volt_V"] for r in rows))실행 결과:
상태별 시간 (전체 298.8 s)
CHARGE 74.1 s 24.8 %
GO_PICK 69.5 s 23.3 %
GO_DROP 62.7 s 21.0 %
RETURN 27.1 s 9.1 %
GO_CHARGE 26.2 s 8.8 %
LOAD 15.0 s 5.0 %
FAULT 10.1 s 3.4 %
UNLOAD 10.0 s 3.3 %
BLOCKED 3.0 s 1.0 %
IDLE 1.1 s 0.4 %
주문별 처리 시간 (픽업 이동 시작 -> 하역 끝)
주문 1: 32.2 s
주문 2: 22.4 s
주문 3: 43.2 s
주문 4: 43.2 s
주문 5: 19.2 s
사건 횟수: arrived 11, battery_warn 1, box_added 1, box_removed 1, charged 1, loaded 5, low_voltage 1, manual_push 1, order 1, path_blocked 1, replan 1, start 1, unloaded 5
첫 배터리 경고: 77.9 s, 19.59 V
저전압 정지: 125.1 s, 위치 (0.75, 1.75) m, 경고 후 47.2 s
최저 전압 19.00 V- 충전(74 s, 25 %)이 이송(63 s)보다 깁니다. 저전압 잠금 뒤 사람이 옮긴 10 s(FAULT)와 충전 이동 26 s 도 모두 "주문을 처리하지 못한 시간" 입니다.
- 주문 3 · 4 가 43 s 로 가장 깁니다. 주문 3 은 경고 뒤 전압이 떨어진 상태였고, 주문 4 는 충전 도크에서 출발해 선반 C 까지 멀었습니다. 로그가 있으면 "왜 느렸나" 를 위치 · 전압으로 짚을 수 있습니다.
- 경고(77.9 s)에서 잠금(125.1 s)까지 47 s 밖에 없었습니다. 이 로봇에게 "작업 마치고 충전" 은 남은 거리가 짧을 때만 안전합니다. 2교시에서 정책을 숫자로 비교합니다.
로봇이 이송(GO_DROP) 중일 때 앞 통로에 상자가 놓였습니다. 막힘 대기 3 s, 재시도 2회이고, 선반 반대편으로 돌아가는 길이 있습니다. FSM 이 거치는 상태 순서로 맞는 것은?
- 이송 → 안전 정지 → 이송
- 이송 → 경로 막힘 → (3 s 뒤 재계획) → 이송
- 이송 → 경로 막힘 → 픽업 이동
- 이송 → 하역 → 복귀
정답 보기
② — 이동 상태에서 `path_blocked` 는 경로 막힘으로 갑니다. 대기 시간이 지나 우회로가 있으면 `replan` 으로 **막히기 전 상태(이송)** 로 돌아갑니다. 안전 정지(①)는 우회로가 없어 재시도를 다 쓴 경우이고, 픽업 이동(③)으로 가면 상자를 든 채 다시 픽업하러 가는 버그입니다.다음 표의 빈칸 (가) · (나) 에 들어갈 것으로 맞게 짝지은 것은?
| 지금 상태 | 사건 | 다음 상태 |
|---|---|---|
| 적재 | loaded | (가) |
| 경로 막힘 | 재시도 초과 no_path | (나) |
| 안전 정지 | error_cleared | 멈추기 전 상태 |
- (가) 이송, (나) 안전 정지
- (가) 하역, (나) 대기
- (가) 이송, (나) 경로 막힘에 계속 머묾
- (가) 복귀, (나) 충전 이동
정답 보기
① — 적재가 끝나면 이송으로 갑니다. 재시도를 다 쓰면 영원히 기다리지 않고 **안전 정지 + 보고**로 갑니다(시뮬레이터 1 의 3번: 약 9 s 뒤). ③ 처럼 계속 머물면 관제는 로봇이 왜 멈췄는지 모릅니다.이송 중 모터 오류로 안전 정지가 되었습니다. 펌프는 어떻게 해야 할까요?
- 안전 정지이므로 펌프도 바로 끈다
- 펌프는 켠 채로 두고, 사람이 상자를 확인 · 처리한 뒤 해제한다
- 펌프를 껐다 켜서 흡착을 다시 시도한다
- 펌프 상태는 FSM 과 상관없다
정답 보기
② — 상자를 들고 있는 상태에서 펌프를 끄면 그 자리에 떨어뜨립니다. "정지" 는 **바퀴를 멈추는 것**이지 모든 출력을 끄는 것이 아닙니다. 시뮬레이터 1 의 4번에서 안전 정지 중에도 펌프가 켬으로 남는 이유입니다. 어떤 출력을 유지하고 어떤 출력을 끌지를 상태마다 정해 두는 것이 FSM 설계의 일부입니다.2교시 · 자동 충전: 도킹과 배터리 정책#
공식 자동 충전 기능의 흐름#
myAGV Plus 의 ROS 2 워크스페이스에는 자동 충전 패키지 myagv_plus_autocharge 가 있습니다(ch09 의 패키지 표). 공식 문서 6.2.7 "Auto Recharge Navigation" 이 설명하는 흐름은 두 단계입니다.
- 내비게이션 단계: Nav2 가 지도 위 도크 위치에서
forward_distance(기본 0.35 m) 앞 지점까지 로봇을 보냅니다. 도크 위치는config/charger_position.json, 앞 거리 · 방향 보정은config/nav_goal_params.yaml에 있습니다. - 직렬 도킹 단계: 도착하면 USB-CAN 직렬 포트를 열어 도크가 보내는
0x182안내 프레임을 읽고, 그 안의 x · z 속도로/cmd_vel을 내서 접점에 붙습니다. 충전 전류가 감지되면 끝납니다.
# 공식 문서 6.2.7 의 순서 (터미널 3개, 워크스페이스는 ~/myagv_plus_ros2)
ros2 launch myagv_plus_bringup myagv_plus_bringup.launch.py # 터미널 1
ros2 launch myagv_plus_navigation2 navigation2_active.launch.py # 터미널 2 - 2D Pose Estimate 로 위치 맞추기
ros2 run myagv_plus_autocharge combined_auto_recharger # 터미널 3 - p 키를 누르면 충전 시작Charging current detected: 210.0 mA - docking complete도크 위치를 처음 기록하는 방법은 두 가지입니다. ① 로봇을 teleop 으로 접점에 정면으로 딱 붙인 뒤 터미널 3 에서 Enter(1초 동안 자세를 모아 중앙값을 저장), ② RViz 의 2D Goal Pose 로 도크 위치 · 방향을 찍기(/charger_position_update 로 발행되도록 미리 설정됨). 공식 문서는 ① 에서 조금이라도 어긋나게 기록하면 직렬 도킹이 접점으로 안내하지 못할 수 있다고 경고합니다. 지도 위 도크 위치가 틀리면 1단계 도착점이 틀리고, 2단계는 그 오차를 다 메우지 못합니다.
0.35 m · 0x182 · 210 mA 는 공식 문서에 적힌 값과 예시 출력입니다. 적외선 안내가 허용하는 도착 오차, 접점의 폭, 충전 전류 · 충전 시간은 문서에 없으므로 확인 필요입니다. 아래 시뮬레이터는 "정렬 후 직진" 으로 단순화한 교육용 모델입니다. 실제 2단계는 도크의 안내 프레임으로 접근하는 동안에도 계속 보정합니다.
시뮬레이터 2 · 충전 도크 맵: 접근 속도 · 정렬 허용 오차 · 측면 이동#
Nav2 가 도크 앞 0.35 m 에 로봇을 세웠지만 옆으로 몇 cm, 방향으로 몇 도 어긋나 있습니다. 로봇은 먼저 정렬(옆 오차 · 방향 오차를 허용 오차 안으로)한 뒤 직진해 접점에 닿습니다. 정렬 센서에는 ±3 mm 쯤의 잡음이 있고, 직진하는 동안 바퀴 미끄럼으로 옆으로 조금 밀립니다(빠를수록 많이). 접점은 ±12 mm · ±3° 안에 닿아야 하고, 0.15 m/s 보다 빠르면 튕겨 나갑니다(교육용 가정).
메카넘 휠(ch03)의 장점은 옆으로 바로 갈 수 있다(vy) 는 것입니다. 체크를 끄면 차동 구동 로봇처럼 "돌고 → 짧게 후진 · 전진 → 다시 돌기" 로 옆 오차를 줄여야 합니다.
| 설정 | 1회 성공률 | 성공 시 평균 시간 | 실패 원인 |
|---|
- 기본값(0.08 m/s · ±8 mm · σ 5 cm · vy)으로 ▶ 한 번 도킹 을 몇 번 누릅니다. 오른쪽 그래프에서 정렬이 끝나는 순간(직진 시작)과 직진 중 옆 오차가 어떻게 변하는지 봅니다. 이어서 🎲 200회 반복 으로 성공률을 적습니다.
- 정렬 허용 오차를 3 mm 와 20 mm 로 바꿔 각각 200회 돌립니다. 성공률과 평균 시간 중 무엇이 더 크게 변할까요?
- 접근 속도를 0.02 → 0.12 → 0.15 → 0.16 m/s 로 올려 봅니다. 0.15 와 0.16 사이에서 무슨 일이 생기나요?
- 측면 이동(vy) 체크를 끄고 200회 돌립니다. 시간은 몇 배가 되고, 어떤 실패 원인이 새로 나타나나요? Nav2 도착 오차 σ 를 1 cm 와 10 cm 로 바꿔 vy 가 있을 때와 없을 때의 차이를 비교합니다.
- 기본값의 1회 성공률은 약 90 %, 성공할 때 6~7 s 입니다. 실패는 거의 "접점 빗나감" 입니다. 정렬이 끝났다고 판단한 순간에도 센서 잡음 때문에 실제 오차가 허용 오차보다 클 수 있고, 직진 중 미끄럼이 더해집니다.
- 허용 오차 20 mm 는 정렬이 빨리 끝나지만(약 1 s 단축) 성공률이 절반 아래로 떨어집니다. 3 mm 는 시간이 1 s 남짓 늘어나는 대신 성공률이 98 % 쯤 됩니다. 접점 폭(±12 mm)보다 충분히 작은 허용 오차를 써야 직진 중 밀림을 견딥니다.
- 0.02 m/s 는 거의 항상 성공하지만 직진에만 17 s 넘게 걸립니다. 0.15 m/s 까지는 성공률이 80 % 안팎으로 조금씩 떨어지다가 0.16 m/s 부터는 모두 튕김입니다. "충분히 느리면서 너무 느리지 않은" 속도가 있습니다.
- vy 를 끄면 한 번 바로잡는 데 8 s 씩 걸려 평균 시간이 약 3배(20 s 이상) 가 되고, 40 s 안에 못 맞추는 정렬 시간 초과가 새로 생깁니다. 도착 오차가 클수록(σ 10 cm) 차이가 커집니다. 메카넘 휠의 측면 이동은 도킹 같은 미세 정렬에서 가장 큰 값을 합니다.
배터리 정책: "작업 마치고 충전" vs "즉시 충전"#
ch05 의 규칙으로 19.6 V 이하이면 경고(등급 1), 19.0 V 미만이면 저전압(등급 2)입니다. 주행 중에는 부하 때문에 전압이 0.1~0.4 V 낮게 읽힙니다. 경고를 받았을 때 할 수 있는 정책은 두 가지입니다.
| 정책 | 하는 일 | 장점 | 단점 |
|---|---|---|---|
| 작업 마치고 충전 | 경고를 예약만 하고 지금 주문을 하역까지 끝낸 뒤 도크로 | 주문이 끊기지 않음. 상자를 들고 충전하러 가지 않음 | 남은 주문 + 도크까지 거리가 길면 가는 도중 저전압 잠금 (시뮬레이터 1 의 5번) |
| 즉시 충전 | 이동 중이면 바로 도크로 | 저전압 잠금 위험이 가장 낮음 | 하던 주문이 늦어지거나 처음부터 다시. 상자를 든 채 도크로 갈 수 있음 |
어느 쪽이든 경고 전압과 충전 시작 전압을 같게 둘 필요는 없습니다. 경고보다 조금 높은 전압(예: 20.0 V)에서 충전하러 가도록 정할 수 있습니다. 그러면 처리량은 어떻게 될까요?
시뮬레이터 3 · 8시간 가속: 충전 시작 전압과 하루 처리량#
로봇 한 대가 8시간 동안 주문(왕복 18~42 m, 상하차 20 s)을 쉬지 않고 처리합니다. 충전 시작 전압 아래로 내려가면 정책에 따라 도크(20 m 떨어짐)로 가서 도킹(30 s) · 충전하고 돌아옵니다. 충전은 100 W 로 하다가 80 % 를 넘으면 전력이 줄어듭니다(리튬 전지의 정전압 구간, 교육용 가정). 주행 중 19.0 V 아래로 떨어지면 저전압 잠금: 사람이 15 분 걸려 도크로 밀어 옮깁니다.
| 항목 | A (고정) | 지금 |
|---|
- 예측: 충전 시작 전압을 20.0 V 와 19.6 V 로 하면 하루 처리량은 어느 쪽이 많을까요? 이유를 한 줄 적습니다.
- 20.0 V 에서 📌 A 로 고정 → 19.6 V 로 바꿔 표를 비교합니다. 충전 횟수와 충전기에 붙어 있던 시간을 봅니다.
- 근무 시작 잔량을 70 % 로 바꿔 2번을 다시 합니다. 결과가 뒤집히나요? 그래프에서 보라 띠의 개수를 셉니다.
- 시작 잔량 100 %, 적재 5 kg · 1.0 m/s 로 바꾸고 충전 시작 전압을 19.1 V 까지 내립니다. 두 정책 중 어느 쪽에서 빨간 띠(저전압 잠금)가 생기나요?
- 충전 목표를 80 % 와 100 % 로 바꿔 봅니다. 충전 시작 전압보다 처리량에 더 큰 영향을 주나요?
- 시작 100 %, 빈 차 0.5 m/s 에서는 20.0 V 가 319 건, 19.6 V 가 316 건으로 거의 같습니다. 8시간 동안 충전을 한 번 하는 것은 같고, 언제 하느냐만 다릅니다. 충전 시작 전압은 "충전 횟수가 바뀔 때" 만 처리량을 크게 바꿉니다.
- 시작 70 % 에서는 20.0 V 가 하루에 충전을 두 번 해야 해서 301 건, 19.6 V 는 한 번으로 316 건입니다(약 5 % 차이). 충전 한 번마다 도크 왕복 · 도킹에 더해 80 % 위의 느린 충전 구간을 다시 지나야 하기 때문입니다.
- 5 kg · 1.0 m/s 에서는 19.6 V 가 20.0 V 보다 21 건 많습니다(417 vs 396). 19.1 V 로 더 낮추면 "작업 마치고" 는 저전압 잠금 1회(15 분 손실)가 생기고, "즉시" 는 잠금 없이 429 건으로 가장 많습니다. 기준을 낮출수록 즉시 정책이 필요해집니다.
- 충전 목표 100 % 는 80 % 위의 느린 구간을 끝까지 채우느라 충전 시간이 두 배 가까이 됩니다(빈 차 기준 316 → 280 건). 80 % 는 324 건입니다. "얼마나 채우나" 가 "언제 시작하나" 보다 큰 손잡이입니다.
충전 시간까지 고려한 처리량 계산#
하루 처리량은 "주문 하나에 걸리는 시간" 과 "충전에 빼앗기는 시간" 으로 어림할 수 있습니다.
- 주문 하나: 평균 왕복 29.5 m ÷ 0.5 m/s + 상하차 20 s ≈ 79 s → 쉬지 않으면 시간당 약 45.6 건.
- 주문 하나의 전력량: 28 W × 59 s + 12 W × 20 s ≈ 1.9 kJ (0.53 Wh). 배터리 120 Wh 중 90 % → 12 % 를 쓰면 약 94 Wh → 약 177 건마다 충전 한 번.
- 충전 한 번: 도크 왕복 80 s + 도킹 30 s + 충전(12 % → 90 %) 약 58 분.
- 8시간(28 800 s) 중 충전 한 번(약 3 590 s)을 빼면 25 210 s → 25 210 ÷ 79 ≈ 319 건. 시뮬레이터 3 과 같습니다.
시간당 처리량 ≈ 3600 ÷ (주문 1건 시간 + 충전 1회 시간 ÷ 충전 1회당 주문 수) — 충전 1회 시간이 같아도 충전 1회당 주문 수가 커지면(충전 시작 전압을 낮추면) 처리량이 오르지만, 그만큼 저전압 여유가 줄어듭니다.
실습 과제 2#
시뮬레이터 2 와 같은 도킹 모델을 numpy 로 옮겼습니다. 정렬 부분은 완성되어 있고, 직진 접근과 접촉 판정이 비어 있습니다(지금은 모두 성공으로 나옴). TODO 두 곳을 채우고, 접근 속도 3가지 × 허용 오차 3가지의 성공률과 "실패하면 5 s 후진 후 재시도" 를 포함한 평균 도킹 시간을 비교하세요. 예측 먼저: 재시도까지 포함하면 가장 느린 0.03 m/s 가 가장 빠른 설정이 될까요?
import numpy as np
# 시뮬레이터 2 와 같은 도킹 모델 (교육용 가정). 길이 m, 각도 rad
L0, WIN, YAW_WIN, V_BOUNCE = 0.35, 0.012, np.radians(3), 0.15 # 도킹 시작 거리, 접점 허용 폭, 허용 각, 튕김 속도
SM, SYAW, YAW_TOL, TMAX = 0.003, np.radians(0.3), np.radians(1.0), 40.0
def trial(v, tol, sig, rng):
"""측면 이동(vy)으로 정렬한 뒤 직진 접근. (성공?, 걸린 시간, 결과) 를 돌려줌"""
ey, yaw, t, good = sig * rng.normal(), np.radians(2) * rng.normal(), 0.0, 0
while True:
if t >= TMAX:
return False, t, "정렬 시간 초과"
m, my = ey + SM * rng.normal(), yaw + SYAW * rng.normal() # 센서로 잰 값 (잡음 포함)
if abs(m) < tol and abs(my) < YAW_TOL:
good += 1
if good >= 3: # 3 번 연속 허용 오차 안이면 정렬 끝
break
else:
good = 0
ey += np.clip(-0.8 * m, -0.03, 0.03) * 0.1 + 0.0003 * rng.normal() # vy 로 옆 오차 줄이기
yaw += np.clip(-1.0 * my, -0.3, 0.3) * 0.1 + 0.0005 * rng.normal() # wz 로 방향 맞추기
t += 0.1
# 직진 접근: 남은 방향 오차만큼 비스듬히 + 바퀴 미끄럼으로 옆으로 밀림 (표준편차 1.5 mm + 40 mm x v)
# TODO 1: ey 에 (L0 x sin(yaw)) 와 (0.0015 + 0.04 x v) x 정규난수 를 더하고, t 에 L0 / v 를 더하기
# TODO 2: v > V_BOUNCE 면 "튕김", |ey| > WIN 이면 "접점 빗나감", |yaw| > YAW_WIN 이면 "비스듬히 닿음" 으로 실패
return True, t, "충전 전류 감지"
def monte_carlo(v, tol, sig=0.05, n=300, seed=1):
rng = np.random.default_rng(seed)
res = [trial(v, tol, sig, rng) for _ in range(n)]
ok = [r for r in res if r[0]]
rate = len(ok) / n
t1 = np.mean([r[1] for r in ok]) if ok else float("nan")
# 실패하면 5 s 후진 후 다시 시도한다고 보면, 성공까지 평균 시간 = (평균 1 회 시간 + 5) / 성공률
t_all = (np.mean([r[1] for r in res]) + 5.0) / rate if rate else float("inf")
return rate, t1, t_all
print("v (m/s) tol (mm) 1회 성공률 성공 시 시간 재시도 포함 평균")
for v in (0.03, 0.08, 0.14):
for tol in (0.004, 0.008, 0.02):
rate, t1, t_all = monte_carlo(v, tol)
print(" %.2f %4.0f %5.1f %% %5.1f s %5.1f s" % (v, tol * 1000, rate * 100, t1, t_all))풀이 코드 보기
import numpy as np
# 시뮬레이터 2 와 같은 도킹 모델 (교육용 가정). 길이 m, 각도 rad
L0, WIN, YAW_WIN, V_BOUNCE = 0.35, 0.012, np.radians(3), 0.15 # 도킹 시작 거리, 접점 허용 폭, 허용 각, 튕김 속도
SM, SYAW, YAW_TOL, TMAX = 0.003, np.radians(0.3), np.radians(1.0), 40.0
def trial(v, tol, sig, rng):
"""측면 이동(vy)으로 정렬한 뒤 직진 접근. (성공?, 걸린 시간, 결과) 를 돌려줌"""
ey, yaw, t, good = sig * rng.normal(), np.radians(2) * rng.normal(), 0.0, 0
while True:
if t >= TMAX:
return False, t, "정렬 시간 초과"
m, my = ey + SM * rng.normal(), yaw + SYAW * rng.normal() # 센서로 잰 값 (잡음 포함)
if abs(m) < tol and abs(my) < YAW_TOL:
good += 1
if good >= 3: # 3 번 연속 허용 오차 안이면 정렬 끝
break
else:
good = 0
ey += np.clip(-0.8 * m, -0.03, 0.03) * 0.1 + 0.0003 * rng.normal() # vy 로 옆 오차 줄이기
yaw += np.clip(-1.0 * my, -0.3, 0.3) * 0.1 + 0.0005 * rng.normal() # wz 로 방향 맞추기
t += 0.1
# 직진 접근: 남은 방향 오차만큼 비스듬히 + 바퀴 미끄럼으로 옆으로 밀림 (표준편차 1.5 mm + 40 mm x v)
ey += L0 * np.sin(yaw) + (0.0015 + 0.04 * v) * rng.normal()
t += L0 / v
if v > V_BOUNCE:
return False, t, "튕김"
if abs(ey) > WIN:
return False, t, "접점 빗나감"
if abs(yaw) > YAW_WIN:
return False, t, "비스듬히 닿음"
return True, t, "충전 전류 감지"
def monte_carlo(v, tol, sig=0.05, n=300, seed=1):
rng = np.random.default_rng(seed)
res = [trial(v, tol, sig, rng) for _ in range(n)]
ok = [r for r in res if r[0]]
rate = len(ok) / n
t1 = np.mean([r[1] for r in ok]) if ok else float("nan")
# 실패하면 5 s 후진 후 다시 시도한다고 보면, 성공까지 평균 시간 = (평균 1 회 시간 + 5) / 성공률
t_all = (np.mean([r[1] for r in res]) + 5.0) / rate if rate else float("inf")
return rate, t1, t_all
print("v (m/s) tol (mm) 1회 성공률 성공 시 시간 재시도 포함 평균")
for v in (0.03, 0.08, 0.14):
for tol in (0.004, 0.008, 0.02):
rate, t1, t_all = monte_carlo(v, tol)
print(" %.2f %4.0f %5.1f %% %5.1f s %5.1f s" % (v, tol * 1000, rate * 100, t1, t_all))실행 결과:
v (m/s) tol (mm) 1회 성공률 성공 시 시간 재시도 포함 평균
0.03 4 99.0 % 14.6 s 19.8 s
0.03 8 96.3 % 13.9 s 19.6 s
0.03 20 47.3 % 12.8 s 38.1 s
0.08 4 95.7 % 7.3 s 12.9 s
0.08 8 89.0 % 6.6 s 13.0 s
0.08 20 52.3 % 5.6 s 20.6 s
0.14 4 88.3 % 5.5 s 11.9 s
0.14 8 77.0 % 4.7 s 12.6 s
0.14 20 50.0 % 3.7 s 17.8 s- 시뮬레이터 2 와 난수만 다르고 규칙은 같으므로 성공률이 몇 % 안에서 맞습니다(0.08 m/s · 8 mm 에서 89 % vs 약 90 %).
- 가장 느린 0.03 m/s 는 성공률은 높지만 직진에만 12 s 가 걸려, 재시도를 포함한 평균은 0.14 m/s · 4 mm (약 12 s) 가 가장 짧습니다. 빠르게 가되 정렬을 꼼꼼히 하는 조합입니다.
- 허용 오차 20 mm 는 어느 속도에서도 성공률이 50 % 안팎이라 재시도 때문에 평균이 가장 깁니다. 성공률과 시간을 함께 봐야 하는 이유입니다.
시뮬레이터 3 의 모델을 그대로 옮겼습니다(결과가 숫자까지 같습니다). TODO 두 곳(80 % 위 충전 전력 줄이기, "작업 마치고 충전" 판단)을 채우고 세 조건 × 두 정책 × 세 기준의 표를 만드세요. 예측 먼저: 5 kg · 1.0 m/s 에서 기준을 19.1 V 로 낮추면 두 정책 중 어느 쪽이 손해를 볼까요?
# 시뮬레이터 3 과 같은 8 시간 모델 (교육용 가정, ch05 의 배터리 모델)
OCV = [(0.00, 18.0), (0.05, 19.0), (0.10, 19.8), (0.20, 20.8), (0.50, 22.4), (0.80, 23.8), (1.00, 25.2)]
E = 120 * 3600 # 60 Wh x 2 (J)
DIST = [24, 36, 18, 30, 42, 27] # 주문마다 왕복 거리 (m), 순서대로 반복
DOCK = 20 # 도크까지 거리 (m)
def ocv(s):
s = min(1.0, max(0.0, s))
for (s0, v0), (s1, v1) in zip(OCV, OCV[1:]):
if s <= s1:
return v0 + (v1 - v0) * (s - s0) / (s1 - s0)
return OCV[-1][1]
def v_load(s, p):
e = ocv(s)
return e - (p / 2) / e * 0.25
def day(thr, policy="finish", target=0.9, v=0.5, load=0.0, soc0=1.0):
pd, ph = 12 + 25 * v * (1 + load / 5) + 15 * v * v, 12 # 주행 · 상하차 전력 (W)
soc, done, k, charges, lock, abandon, t_ch = soc0, 0, 0, 0, 0, 0, 0
st, ph_i, rem, last_v = "order", 0, DIST[0] / v, ocv(soc0)
for t in range(8 * 3600):
drive = (st == "order" and ph_i == 0) or st in ("todock", "back")
p = pd if drive else (0 if st in ("charge", "rescue") else ph)
if st == "charge":
pc = 100 # TODO 1: 80 % 넘으면 100 x (1 - soc) / 0.2 (최소 5 W) 로 줄이기
soc = min(1.0, soc + pc / E)
t_ch += 1
else:
soc = max(0.0, soc - p / E)
volt = ocv(soc) if st == "charge" else v_load(soc, p)
if drive:
last_v = volt
if volt < 19.0: # 저전압 잠금 -> 사람이 밀어 옮김 (15 분)
st, rem, lock = "rescue", 900, lock + 1
continue
if st == "order" and ph_i == 0 and policy == "now" and volt <= thr:
abandon += 1 # 즉시 충전: 하던 주문은 처음부터 다시
st, rem, charges = "todock", DOCK / v, charges + 1
continue
if st == "charge":
if soc >= target:
st, rem = "back", DOCK / v
continue
rem -= 1
if rem > 0:
continue
if st == "order":
if ph_i == 0:
ph_i, rem = 1, 20 # 상하차 20 s
else:
done, k = done + 1, k + 1
# TODO 2: 작업 마치고 충전 - last_v 가 thr 이하이면 도크로("todock", DOCK / v, 충전 횟수 + 1)
st, ph_i, rem = "order", 0, DIST[k % 6] / v
elif st == "todock":
st, rem = "dock", 30
elif st in ("dock", "rescue"):
st = "charge"
elif st == "back":
st, ph_i, rem = "order", 0, DIST[k % 6] / v
return done, charges, lock, abandon, t_ch / 60
print("조건 정책 기준 완료 충전 잠금 충전 시간(분)")
CASES = [("100 %, 빈 차, 0.5 m/s", dict(soc0=1.0)), ("70 %, 빈 차, 0.5 m/s", dict(soc0=0.7)),
("100 %, 5 kg, 1.0 m/s", dict(soc0=1.0, v=1.0, load=5))]
for label, kw in CASES:
for policy in ("finish", "now"):
for thr in (20.0, 19.6, 19.1):
d, c, l, a, tc = day(thr, policy, **kw)
print("%-22s %-6s %.1f V %4d %2d %d %4.0f" % (label, policy, thr, d, c, l, tc))풀이 코드 보기
# 시뮬레이터 3 과 같은 8 시간 모델 (교육용 가정, ch05 의 배터리 모델)
OCV = [(0.00, 18.0), (0.05, 19.0), (0.10, 19.8), (0.20, 20.8), (0.50, 22.4), (0.80, 23.8), (1.00, 25.2)]
E = 120 * 3600 # 60 Wh x 2 (J)
DIST = [24, 36, 18, 30, 42, 27] # 주문마다 왕복 거리 (m), 순서대로 반복
DOCK = 20 # 도크까지 거리 (m)
def ocv(s):
s = min(1.0, max(0.0, s))
for (s0, v0), (s1, v1) in zip(OCV, OCV[1:]):
if s <= s1:
return v0 + (v1 - v0) * (s - s0) / (s1 - s0)
return OCV[-1][1]
def v_load(s, p):
e = ocv(s)
return e - (p / 2) / e * 0.25
def day(thr, policy="finish", target=0.9, v=0.5, load=0.0, soc0=1.0):
pd, ph = 12 + 25 * v * (1 + load / 5) + 15 * v * v, 12 # 주행 · 상하차 전력 (W)
soc, done, k, charges, lock, abandon, t_ch = soc0, 0, 0, 0, 0, 0, 0
st, ph_i, rem, last_v = "order", 0, DIST[0] / v, ocv(soc0)
for t in range(8 * 3600):
drive = (st == "order" and ph_i == 0) or st in ("todock", "back")
p = pd if drive else (0 if st in ("charge", "rescue") else ph)
if st == "charge":
pc = 100 if soc < 0.8 else max(5, 100 * (1 - soc) / 0.2) # 80 % 넘으면 충전 전력이 줄어듦
soc = min(1.0, soc + pc / E)
t_ch += 1
else:
soc = max(0.0, soc - p / E)
volt = ocv(soc) if st == "charge" else v_load(soc, p)
if drive:
last_v = volt
if volt < 19.0: # 저전압 잠금 -> 사람이 밀어 옮김 (15 분)
st, rem, lock = "rescue", 900, lock + 1
continue
if st == "order" and ph_i == 0 and policy == "now" and volt <= thr:
abandon += 1 # 즉시 충전: 하던 주문은 처음부터 다시
st, rem, charges = "todock", DOCK / v, charges + 1
continue
if st == "charge":
if soc >= target:
st, rem = "back", DOCK / v
continue
rem -= 1
if rem > 0:
continue
if st == "order":
if ph_i == 0:
ph_i, rem = 1, 20 # 상하차 20 s
else:
done, k = done + 1, k + 1
if last_v <= thr: # 작업 마치고 충전
st, rem, charges = "todock", DOCK / v, charges + 1
else:
st, ph_i, rem = "order", 0, DIST[k % 6] / v
elif st == "todock":
st, rem = "dock", 30
elif st in ("dock", "rescue"):
st = "charge"
elif st == "back":
st, ph_i, rem = "order", 0, DIST[k % 6] / v
return done, charges, lock, abandon, t_ch / 60
print("조건 정책 기준 완료 충전 잠금 충전 시간(분)")
CASES = [("100 %, 빈 차, 0.5 m/s", dict(soc0=1.0)), ("70 %, 빈 차, 0.5 m/s", dict(soc0=0.7)),
("100 %, 5 kg, 1.0 m/s", dict(soc0=1.0, v=1.0, load=5))]
for label, kw in CASES:
for policy in ("finish", "now"):
for thr in (20.0, 19.6, 19.1):
d, c, l, a, tc = day(thr, policy, **kw)
print("%-22s %-6s %.1f V %4d %2d %d %4.0f" % (label, policy, thr, d, c, l, tc))실행 결과:
조건 정책 기준 완료 충전 잠금 충전 시간(분)
100 %, 빈 차, 0.5 m/s finish 20.0 V 319 1 0 58
100 %, 빈 차, 0.5 m/s finish 19.6 V 316 1 0 61
100 %, 빈 차, 0.5 m/s finish 19.1 V 315 1 0 63
100 %, 빈 차, 0.5 m/s now 20.0 V 318 1 0 58
100 %, 빈 차, 0.5 m/s now 19.6 V 316 1 0 61
100 %, 빈 차, 0.5 m/s now 19.1 V 315 1 0 63
70 %, 빈 차, 0.5 m/s finish 20.0 V 301 2 0 81
70 %, 빈 차, 0.5 m/s finish 19.6 V 316 1 0 61
70 %, 빈 차, 0.5 m/s finish 19.1 V 315 1 0 63
70 %, 빈 차, 0.5 m/s now 20.0 V 299 2 0 83
70 %, 빈 차, 0.5 m/s now 19.6 V 316 1 0 61
70 %, 빈 차, 0.5 m/s now 19.1 V 315 1 0 63
100 %, 5 kg, 1.0 m/s finish 20.0 V 396 3 0 150
100 %, 5 kg, 1.0 m/s finish 19.6 V 417 3 0 133
100 %, 5 kg, 1.0 m/s finish 19.1 V 412 2 1 124
100 %, 5 kg, 1.0 m/s now 20.0 V 393 3 0 152
100 %, 5 kg, 1.0 m/s now 19.6 V 414 3 0 135
100 %, 5 kg, 1.0 m/s now 19.1 V 429 2 0 123- 빈 차 · 시작 100 % 에서는 기준을 바꿔도 충전이 하루 한 번이라 315~319 건으로 거의 같습니다.
- 시작 70 % 에서 20.0 V 만 충전이 두 번으로 늘어 300 건 안팎으로 떨어집니다. 충전 횟수가 바뀌는 경계에서 처리량이 계단처럼 변합니다.
- 5 kg · 1.0 m/s 에서는 하루 충전이 2~3 번이라 기준의 영향이 큽니다. 19.1 V "작업 마치고" 는 잠금 1회로 412 건, "즉시" 는 잠금 없이 429 건입니다. 기준을 낮추려면 즉시 정책 같은 안전장치를 함께 바꿔야 합니다.
- TODO 1 을 빼먹으면(80 % 위에서도 100 W) 충전 시간이 짧아져 처리량이 실제보다 높게 나옵니다. 정전압 구간은 충전 계획에서 가장 많이 빠뜨리는 부분입니다.
정렬 허용 오차를 ±8 mm 에서 ±20 mm 로 넓혔더니 1회 도킹 시간은 1 s 쯤 줄었지만 성공률이 90 % 에서 50 % 아래로 떨어졌습니다. 가장 알맞은 설명은?
- 허용 오차를 넓히면 접근 속도가 빨라져 튕긴다
- 정렬을 덜 하고 출발하므로, 남은 옆 오차에 직진 중 밀림이 더해져 접점(±12 mm) 밖에 닿는다
- 허용 오차는 접점 폭과 관계없다
- 허용 오차를 넓히면 Nav2 도착 오차가 커진다
정답 보기
② — 허용 오차는 "이만큼 어긋나도 출발한다" 는 뜻입니다. 접점 폭보다 넓은 허용 오차로 출발하면 직진 중 밀림(수 mm)까지 더해져 빗나갑니다. 실패하면 후진 · 재시도로 시간이 더 들어, 재시도를 포함한 평균은 오히려 길어집니다(실습 과제 2-1).빈 차 · 0.5 m/s 로 근무를 70 % 에서 시작할 때, 충전 시작 전압을 20.0 V 에서 19.6 V 로 낮추면 하루 처리량은?
- 하루 충전 횟수가 2번에서 1번으로 줄어 약 5 % 늘어난다
- 전압을 낮췄으니 로봇이 느려져 줄어든다
- 충전 시간이 같으므로 정확히 같다
- 저전압 잠금이 생겨 크게 줄어든다
정답 보기
① — 301 건 → 316 건입니다. 충전 한 번마다 도크 왕복 · 도킹 · 80 % 위 느린 충전 구간이 다시 들어가므로, 충전 **횟수**가 줄면 처리량이 늘어납니다. 시작 100 % 에서는 두 기준 모두 하루 한 번이라 거의 같습니다(③ 에 가깝지만 정확히 같지는 않음).combined_auto_recharger 로 충전을 시작했는데 로봇이 도크 앞까지는 잘 왔지만 접점에 붙지 못하고 옆으로 비껴 멈춥니다. 가장 먼저 의심할 것은?
ROS_DOMAIN_ID가 0 이다charger_position.json에 기록한 도크 위치 · 방향이 실제 도크와 어긋나 있다- 배터리가 100 % 다
- LED 모드가 0 이다
정답 보기
② — 1단계(Nav2)는 기록된 도크 위치에서 0.35 m 앞으로 갑니다. 기록이 어긋나 있으면 2단계의 적외선 안내가 메우지 못할 만큼 비껴 도착합니다. 공식 문서도 위치를 기록할 때 **접점에 정면으로 붙인 상태**에서 하라고 경고합니다. AMCL 위치 추정이 틀린 경우(2D Pose Estimate)도 같은 증상입니다.3교시 · 다중 AGV: 교차로 · 작업 배정#
다중 로봇이 만드는 세 가지 문제#
로봇이 한 대일 때는 "막히면 기다리거나 돌아간다" 로 충분했습니다. 두 대 이상이 같은 통로를 쓰면 로봇끼리 서로의 장애물이 됩니다.
- 교차로 충돌: 두 로봇이 같은 교차로 칸에 동시에 들어가려 합니다. 각자의 LiDAR 안전 정지가 충돌은 막아 주지만, 둘 다 멈춥니다.
- 좁은 통로 마주침: 로봇 한 대 폭의 통로에서 마주 보면 둘 다 지나갈 수 없습니다. 누군가 뒤로 물러나야 합니다.
- 교착(deadlock): A 는 B 를, B 는 C 를, … 마지막이 A 를 기다리면 아무도 영원히 움직이지 못합니다. 마주침은 두 대짜리 교착입니다.
ch08 의 경로 계획기는 다른 로봇을 "움직이는 장애물" 로만 봅니다. 각 로봇이 자기 최단 경로만 고르면 교착은 저절로 풀리지 않습니다. 그래서 창고에서는 로봇들이 함께 지키는 규칙을 둡니다.
규칙 기반 해결: 예약 · 일방통행 · 대기 지점#
| 규칙 | 방법 | 막아 주는 것 | 대가 |
|---|---|---|---|
| 경로 · 교차로 예약 | 출발 전에 갈 칸들을 "그 칸을 떠나는 방향" 과 함께 예약. 같은 방향(줄지어 가기)만 함께 예약 가능. 먼저 예약한 로봇 우선 | 교차로 충돌 · 마주침 · 교착 | 예약을 못 받은 로봇은 베이에서 기다림 |
| 일방통행 통로 | 통로마다 방향을 하나로 정함 (창고 바닥의 화살표) | 마주침 · 대부분의 교착 | 목적지를 돌아서 가야 함 (경로가 길어짐) |
| 대기 지점 | 통로 밖 칸(베이 · 대피소)에서만 기다림 | 기다리는 로봇이 통로를 막는 것 | 대기 지점이 필요 (공간) |
| 교착 감지 · 회복 | 기다림의 순환을 찾으면 한 대가 후진 · 우회 | 이미 생긴 교착 | 회복하는 동안 시간 손실 |
작업 배정: 누구에게 맡길까#
주문이 들어오면 쉬고 있는 로봇 중 하나를 고릅니다.
| 배정 규칙 | 고르는 기준 | 좋은 점 | 약한 점 |
|---|---|---|---|
| 가장 가까운 로봇 | 픽업 위치까지 경로 길이가 가장 짧은 로봇 | 빈 주행이 적음 → 처리량 · 배송 시간 유리 | 같은 로봇만 계속 일함 → 배터리 · 마모 편중 |
| 가장 한가한 로봇 | 마지막으로 일을 받은 지 가장 오래된 로봇 | 일이 고르게 나뉨 | 먼 로봇이 갈 때가 있어 빈 주행이 늘어남 |
| 배터리 고려 | 거리 + 배터리 부족분 × 가중치 가 가장 작은 로봇 (충전 기준 아래는 제외) | 배터리 낮은 로봇을 아낌 → 저전압 잠금 예방 | 가중치를 정해야 함 |
시뮬레이터 4 · 다중 로봇 교차로#
교차로 창고는 가로 통로 3줄 · 세로 통로 4줄이 모두 한 칸 폭(로봇 한 대) 입니다. 통로 옆의 베이가 픽업(픽) · 출고(출) · 대기 지점(H, 로봇마다 하나, 충전 겸용)입니다. 주문은 무작위로 들어오고(픽 4곳 → 출고 4곳), 쉬는 로봇에게 배정됩니다. 로봇 위 * 는 주문을 맡고 있다는 뜻, 빨간 테두리는 3 s 넘게 기다리는 중, 칸 색은 예약된 칸입니다. 교착이 15 s 넘게 이어지면 번호가 큰 로봇이 다른 로봇을 벽으로 보고 다시 계획(후진 · 우회)합니다.
- 예측: 주문 4 건/분, 규칙 없음에서 로봇을 2대 → 4대로 늘리면 시간당 처리량은 2배가 될까요? 📊 로봇 1~4대 비교 로 확인합니다.
- 규칙 없음 · 로봇 4대로 ▶ 를 누르고 × 4 로 지켜봅니다. 빨간 테두리 로봇 두 대가 마주 보는 장면을 찾아, 15 s 뒤 누가 어떻게 물러나는지 봅니다. 교착 횟수는 몇 분에 몇 번쯤 늘어나나요?
- 교통 규칙을 경로 예약으로 바꿔 같은 비교를 합니다. 교착은? 대신 무엇이 늘었나요?
- 일방통행으로 바꿉니다. 바닥 화살표를 보고 로봇 1대일 때 처리량이 왜 줄었는지, 4대일 때는 왜 가장 좋은지 설명해 봅니다.
- 일방통행 · 로봇 4대 · 주문 2 건/분으로 놓고 작업 배정 세 가지를 바꿔 가며 × 60 으로 1시간을 돌립니다. 아래 줄의 로봇별 일한 비율은 어느 규칙에서 가장 고르게 나뉘나요? 지도를 넓은 피킹장(2차선) 으로 바꾸면 규칙 없음의 교착이 사라질까요?
- 주문 4 건/분 · 1시간 기준, 2대 → 4대의 처리량은 규칙 없음 1.22배(162 → 198 건/h), 경로 예약 1.31배(162 → 213), 일방통행 1.71배(126 → 216)입니다. 어느 규칙도 2배가 되지 않습니다. 로봇이 늘면 서로 기다리는 시간(규칙 없음 17 % → 50 %)이 늘기 때문입니다. 주문이 8 건/분으로 넘칠 때도 비슷합니다.
- 규칙 없음은 1시간에 교착이 100번 넘게(4대) 생기고, 매번 15 s 를 기다린 뒤 후진 · 우회로 풉니다. 예약은 교착이 0 이지만, 예약을 못 받은 로봇이 베이에서 기다려 기다린 비율이 58 % 까지 오릅니다.
- 일방통행은 1대일 때 경로가 길어 처리량이 93 → 64 건/h 로 줄지만, 4대에서는 마주침이 없어 기다린 비율 11 % 로 가장 많이 처리합니다. 대수가 적으면 자유 주행, 많으면 일방통행 이 유리해지는 교차점이 있습니다.
- 일방통행 · 4대 · 2 건/분에서 가장 가까운 로봇은 일한 비율이 52 / 44 / 39 / 25 % 로 한쪽에 몰리고(직전 하역 위치가 픽업 베이에 가까웠던 로봇이 계속 뽑힘), 가장 한가한 로봇은 38 / 41 / 40 / 41 % 로 고르게 나뉩니다. 완료 주문은 124 건으로 같습니다. 일이 적을 때는 배정 규칙이 처리량보다 마모 · 배터리 편중을 정합니다.
- 넓은 피킹장(2차선)에서도 규칙이 없으면 각 로봇이 같은 최단 차선을 골라 마주치므로 교착이 사라지지 않습니다. 길이 넓어도 방향 규칙이 있어야 차선을 나눠 씁니다.
실물 분리: ROS_DOMAIN_ID 와 네임스페이스#
시뮬레이터에서는 로봇이 서로를 알지만, 실물 여러 대가 같은 Wi-Fi 에 있으면 먼저 명령이 섞이지 않게 해야 합니다.
- 한 대 = 한 시스템으로 따로 운영: 로봇마다
ROS_DOMAIN_ID를 다르게 합니다(ch09). 도메인이 다르면 서로의 토픽이 아예 보이지 않으므로, 1번 팀의 teleop 이 2번 로봇을 움직이는 일이 없습니다. 대신 관제 프로그램도 로봇마다 도메인을 맞춰 따로 띄워야 합니다. - 여러 대를 한 관제에서 보기: 같은 도메인에 두고 네임스페이스로 이름을 나눕니다.
/agv1/cmd_vel,/agv2/cmd_vel처럼 토픽 · 노드 이름 앞에 로봇 이름을 붙입니다. TF 프레임도agv1/base_footprint처럼 나눠야 하고, Nav2 도 로봇마다 네임스페이스를 붙여 띄웁니다.
# 로봇마다 다른 도메인 (같은 로봇의 모든 터미널과 그 로봇을 보는 노트북에서 똑같이)
export ROS_DOMAIN_ID=1 # 1번 로봇 팀
export ROS_DOMAIN_ID=2 # 2번 로봇 팀
# 같은 도메인에서 네임스페이스로 나누기 - 일반 ROS 2 노드의 예
ros2 run teleop_twist_keyboard teleop_twist_keyboard --ros-args -r __ns:=/agv1
ros2 topic list | grep agv1myagv_plus_bringup · navigation2_active.launch.py 가 네임스페이스 인수를 받는지, TF 프레임 이름을 바꿀 수 있는지는 공식 문서에 없습니다. 교실에서는 먼저 로봇마다 ROS_DOMAIN_ID 를 다르게 하는 방법(공식 문서 6.2.1 의 안내)을 쓰고, 한 관제에서 여러 대를 보려면 launch 파일을 열어 namespace 인수와 TF 접두사를 확인합니다.
실습 과제 3#
로봇마다 (지금 칸, 가려는 다음 칸)이 주어집니다. 가려는 칸에 다른 로봇이 있으면 그 로봇을 "기다린다" 고 보고, 기다림을 따라가다 자기 자신으로 돌아오면 교착입니다. 시뮬레이터 4 의 교착 감지가 하는 일과 같습니다. TODO 를 채워 배치 A~E 를 판정하세요. 예측 먼저: E 처럼 마주친 두 대 뒤에 한 대가 더 서 있으면, 교착에 든 로봇은 몇 대일까요?
# 대기 관계(wait-for)로 교착 찾기. 칸은 (x, y), 로봇마다 (지금 칸, 가려는 다음 칸)
# 가려는 칸에 다른 로봇이 있으면 그 로봇을 "기다림". 기다림을 따라가다 자기 자신으로 돌아오면 교착(deadlock)
LAYOUTS = {
"A 좁은 통로에서 마주침": {"R1": ((2, 0), (3, 0)), "R2": ((3, 0), (2, 0))},
"B 같은 방향 줄지어 감": {"R1": ((2, 0), (3, 0)), "R2": ((3, 0), (4, 0))},
"C 교차로 네 대 맞물림": {"R1": ((0, 0), (1, 0)), "R2": ((1, 0), (1, 1)),
"R3": ((1, 1), (0, 1)), "R4": ((0, 1), (0, 0))},
"D 하역 중인 로봇 뒤 줄": {"R1": ((0, 0), (1, 0)), "R2": ((1, 0), (2, 0)), "R3": ((2, 0), None)},
"E 마주침 + 뒤에 한 대": {"R1": ((2, 0), (3, 0)), "R2": ((3, 0), (2, 0)), "R3": ((1, 0), (2, 0))},
}
def wait_for(robots):
"""로봇 -> 기다리는 로봇 (기다리지 않으면 없음)"""
at = {cell: name for name, (cell, nxt) in robots.items()}
return {name: at[nxt] for name, (cell, nxt) in robots.items() if nxt is not None and nxt in at}
def find_cycle(w):
"""기다림을 따라가며 순환을 찾음. 순환에 든 로봇 목록(없으면 [])"""
for start in w:
path, cur = [], start
# TODO: cur 가 누군가를 기다리고(cur in w) 아직 path 에 없으면 path 에 넣고 cur = w[cur]
# 반복이 끝났을 때 cur 가 path 안에 있으면 순환 -> path[path.index(cur):] 를 돌려줌
pass
return []
for name, robots in LAYOUTS.items():
w = wait_for(robots)
cyc = find_cycle(w)
waits = ", ".join("%s->%s" % kv for kv in sorted(w.items())) or "없음"
if cyc:
victim = max(cyc) # 회복: 순환 안에서 번호가 가장 큰 로봇이 물러남
print("%-16s 기다림 [%s] => 교착! 순환 %s, %s 가 후진 · 우회" % (name, waits, " -> ".join(cyc + [cyc[0]]), victim))
else:
print("%-16s 기다림 [%s] => 교착 아님 (기다리면 풀림)" % (name, waits))풀이 코드 보기
# 대기 관계(wait-for)로 교착 찾기. 칸은 (x, y), 로봇마다 (지금 칸, 가려는 다음 칸)
# 가려는 칸에 다른 로봇이 있으면 그 로봇을 "기다림". 기다림을 따라가다 자기 자신으로 돌아오면 교착(deadlock)
LAYOUTS = {
"A 좁은 통로에서 마주침": {"R1": ((2, 0), (3, 0)), "R2": ((3, 0), (2, 0))},
"B 같은 방향 줄지어 감": {"R1": ((2, 0), (3, 0)), "R2": ((3, 0), (4, 0))},
"C 교차로 네 대 맞물림": {"R1": ((0, 0), (1, 0)), "R2": ((1, 0), (1, 1)),
"R3": ((1, 1), (0, 1)), "R4": ((0, 1), (0, 0))},
"D 하역 중인 로봇 뒤 줄": {"R1": ((0, 0), (1, 0)), "R2": ((1, 0), (2, 0)), "R3": ((2, 0), None)},
"E 마주침 + 뒤에 한 대": {"R1": ((2, 0), (3, 0)), "R2": ((3, 0), (2, 0)), "R3": ((1, 0), (2, 0))},
}
def wait_for(robots):
"""로봇 -> 기다리는 로봇 (기다리지 않으면 없음)"""
at = {cell: name for name, (cell, nxt) in robots.items()}
return {name: at[nxt] for name, (cell, nxt) in robots.items() if nxt is not None and nxt in at}
def find_cycle(w):
"""기다림을 따라가며 순환을 찾음. 순환에 든 로봇 목록(없으면 [])"""
for start in w:
path, cur = [], start
while cur in w and cur not in path:
path.append(cur)
cur = w[cur]
if cur in path:
return path[path.index(cur):]
return []
for name, robots in LAYOUTS.items():
w = wait_for(robots)
cyc = find_cycle(w)
waits = ", ".join("%s->%s" % kv for kv in sorted(w.items())) or "없음"
if cyc:
victim = max(cyc) # 회복: 순환 안에서 번호가 가장 큰 로봇이 물러남
print("%-16s 기다림 [%s] => 교착! 순환 %s, %s 가 후진 · 우회" % (name, waits, " -> ".join(cyc + [cyc[0]]), victim))
else:
print("%-16s 기다림 [%s] => 교착 아님 (기다리면 풀림)" % (name, waits))실행 결과:
A 좁은 통로에서 마주침 기다림 [R1->R2, R2->R1] => 교착! 순환 R1 -> R2 -> R1, R2 가 후진 · 우회
B 같은 방향 줄지어 감 기다림 [R1->R2] => 교착 아님 (기다리면 풀림)
C 교차로 네 대 맞물림 기다림 [R1->R2, R2->R3, R3->R4, R4->R1] => 교착! 순환 R1 -> R2 -> R3 -> R4 -> R1, R4 가 후진 · 우회
D 하역 중인 로봇 뒤 줄 기다림 [R1->R2, R2->R3] => 교착 아님 (기다리면 풀림)
E 마주침 + 뒤에 한 대 기다림 [R1->R2, R2->R1, R3->R1] => 교착! 순환 R1 -> R2 -> R1, R2 가 후진 · 우회- B · D 는 기다림이 사슬일 뿐 원이 아닙니다. 맨 앞 로봇이 움직이거나(B) 하역을 마치면(D) 차례로 풀립니다. 오래 기다린다고 모두 교착은 아닙니다.
- E 에서 R3 은 기다리고 있지만 순환에는 들지 않습니다. 순환(R1 ↔ R2)만 풀면 R3 은 따라 풀립니다. 그런데 R2 가 후진하려면 뒤 칸이 비어 있어야 하므로, 시뮬레이터 4 는 순환에 든 로봇이 못 움직이면 순환을 기다리는 로봇(R3) 에게도 물러날 기회를 줍니다.
- 네 대가 맞물린 C 는 한 대만 물러나면 나머지가 모두 움직입니다. 그래서 회복은 "번호가 큰 한 대" 처럼 누가 물러날지 미리 정한 규칙으로 합니다.
로봇 3대(배터리 90 · 35 · 60 %)가 40 s 마다 들어오는 주문 8건을 처리합니다. 시뮬레이터처럼 쉬는 로봇에게만 배정합니다. "가장 한가한 로봇" 과 "배터리 고려" 의 고르는 기준을 채우고, 총 주행 거리 · 평균 픽업 대기 · 남은 배터리를 비교하세요. 예측 먼저: 배터리가 35 % 인 R2 는 어느 규칙에서 가장 많이 닳을까요? 그 규칙의 총 주행 거리는 가장 길까요, 짧을까요?
# 작업 배정 규칙 비교: 가장 가까운 로봇 / 가장 한가한 로봇 / 배터리 고려
# 바닥이 트인 창고라고 보고 거리는 맨해튼 거리(m). 속도 0.5 m/s, 상하차 6 s, 1 m 에 배터리 0.15 %
ROBOTS = {"R1": ((2, 2), 90.0), "R2": ((18, 2), 35.0), "R3": ((10, 12), 60.0)} # 위치, 배터리 %
DROP = (20, 12) # 출고장
ORDERS = [(0, (16, 4)), (40, (3, 10)), (80, (17, 6)), (120, (15, 3)), (160, (4, 4)),
(200, (18, 8)), (240, (12, 2)), (280, (16, 10))] # (들어온 시각 s, 픽업 위치)
V, T_HANDLE, PER_M, MIN_BATT, W_BATT = 0.5, 6.0, 0.15, 20.0, 1.0 # W_BATT: 배터리 1 % 부족을 몇 m 로 칠지
def dist(a, b):
return abs(a[0] - b[0]) + abs(a[1] - b[1])
def run(policy):
st = {n: {"pos": p, "batt": b, "free": 0.0, "last": 0.0, "n": 0, "m": 0.0} for n, (p, b) in ROBOTS.items()}
waits = []
for t0, pick in ORDERS:
ok = [n for n in st if st[n]["batt"] - PER_M * (dist(st[n]["pos"], pick) + dist(pick, DROP)) >= MIN_BATT]
ta = max(t0, min(st[n]["free"] for n in ok)) # 한가한 로봇이 생기는 시각 (시뮬레이터처럼 쉬는 로봇에게만 배정)
ok = [n for n in ok if st[n]["free"] <= ta]
if policy == "가까운":
best = min(ok, key=lambda n: (dist(st[n]["pos"], pick), n))
elif policy == "한가한":
best = ok[0] # TODO 1: st[n]["last"] (마지막으로 일을 받은 시각) 이 가장 작은 로봇
else:
best = ok[0] # TODO 2: 거리 + W_BATT x (100 - 배터리) 가 가장 작은 로봇
r = st[best]
d = dist(r["pos"], pick) + dist(pick, DROP)
arrive = ta + dist(r["pos"], pick) / V
waits.append(arrive - t0)
r["free"] = arrive + dist(pick, DROP) / V + 2 * T_HANDLE
r["last"], r["pos"], r["batt"] = ta, DROP, r["batt"] - PER_M * d
r["n"] += 1
r["m"] += d
total = sum(r["m"] for r in st.values())
print("%-6s 총 주행 %5.0f m 평균 픽업 대기 %5.1f s 배정 %s 남은 배터리 %s" % (
policy, total, sum(waits) / len(waits),
"/".join("%s:%d" % (n, st[n]["n"]) for n in st),
"/".join("%.1f" % st[n]["batt"] for n in st)))
for p in ("가까운", "한가한", "배터리"):
run(p)풀이 코드 보기
# 작업 배정 규칙 비교: 가장 가까운 로봇 / 가장 한가한 로봇 / 배터리 고려
# 바닥이 트인 창고라고 보고 거리는 맨해튼 거리(m). 속도 0.5 m/s, 상하차 6 s, 1 m 에 배터리 0.15 %
ROBOTS = {"R1": ((2, 2), 90.0), "R2": ((18, 2), 35.0), "R3": ((10, 12), 60.0)} # 위치, 배터리 %
DROP = (20, 12) # 출고장
ORDERS = [(0, (16, 4)), (40, (3, 10)), (80, (17, 6)), (120, (15, 3)), (160, (4, 4)),
(200, (18, 8)), (240, (12, 2)), (280, (16, 10))] # (들어온 시각 s, 픽업 위치)
V, T_HANDLE, PER_M, MIN_BATT, W_BATT = 0.5, 6.0, 0.15, 20.0, 1.0 # W_BATT: 배터리 1 % 부족을 몇 m 로 칠지
def dist(a, b):
return abs(a[0] - b[0]) + abs(a[1] - b[1])
def run(policy):
st = {n: {"pos": p, "batt": b, "free": 0.0, "last": 0.0, "n": 0, "m": 0.0} for n, (p, b) in ROBOTS.items()}
waits = []
for t0, pick in ORDERS:
ok = [n for n in st if st[n]["batt"] - PER_M * (dist(st[n]["pos"], pick) + dist(pick, DROP)) >= MIN_BATT]
ta = max(t0, min(st[n]["free"] for n in ok)) # 한가한 로봇이 생기는 시각 (시뮬레이터처럼 쉬는 로봇에게만 배정)
ok = [n for n in ok if st[n]["free"] <= ta]
if policy == "가까운":
best = min(ok, key=lambda n: (dist(st[n]["pos"], pick), n))
elif policy == "한가한":
best = min(ok, key=lambda n: (st[n]["last"], n)) # 가장 오래 전에 일을 받은 로봇
else: # 배터리 고려: 거리 + 배터리 벌점
best = min(ok, key=lambda n: (dist(st[n]["pos"], pick) + W_BATT * (100 - st[n]["batt"]), n))
r = st[best]
d = dist(r["pos"], pick) + dist(pick, DROP)
arrive = ta + dist(r["pos"], pick) / V
waits.append(arrive - t0)
r["free"] = arrive + dist(pick, DROP) / V + 2 * T_HANDLE
r["last"], r["pos"], r["batt"] = ta, DROP, r["batt"] - PER_M * d
r["n"] += 1
r["m"] += d
total = sum(r["m"] for r in st.values())
print("%-6s 총 주행 %5.0f m 평균 픽업 대기 %5.1f s 배정 %s 남은 배터리 %s" % (
policy, total, sum(waits) / len(waits),
"/".join("%s:%d" % (n, st[n]["n"]) for n in st),
"/".join("%.1f" % st[n]["batt"] for n in st)))
for p in ("가까운", "한가한", "배터리"):
run(p)실행 결과:
가까운 총 주행 188 m 평균 픽업 대기 20.0 s 배정 R1:4/R2:3/R3:1 남은 배터리 74.4/28.1/54.3
한가한 총 주행 224 m 평균 픽업 대기 29.0 s 배정 R1:4/R2:2/R3:2 남은 배터리 79.5/21.5/50.4
배터리 총 주행 210 m 평균 픽업 대기 25.5 s 배정 R1:4/R2:0/R3:4 남은 배터리 74.1/35.0/44.4- 가까운 로봇: 총 주행이 가장 짧고(188 m) 기다림도 가장 짧습니다. 대신 R3 은 1건만 하고 R1 · R2 가 일을 나눠 R2 가 28 % 까지 내려갑니다.
- 한가한 로봇: 일은 고르게 돌지만 먼 로봇을 보내 총 주행이 224 m 로 가장 길고, R2 가 21.5 % 로 가장 많이 닳습니다(최저 기준 20 % 에 가까움).
- 배터리 고려: 주행은 198 m 로 가까운 규칙과 비슷하면서 R2 에게 1건만 주어 31 % 를 지킵니다.
W_BATT = 1.0으로 올리면 R2 는 하나도 받지 않습니다(35 % 유지, 주행 210 m). 가중치는 "배터리 1 % 를 몇 m 거리와 바꿀까" 를 정하는 손잡이입니다.
교차로 창고(1차선)에서 규칙 없이 로봇을 2대에서 4대로 늘렸더니 처리량이 162 → 198 건/h(1.22배)가 되었습니다. 2배가 되지 못한 가장 큰 이유는?
- 주문이 부족해서 로봇이 놀았기 때문이다
- 좁은 통로에서 서로 기다리는 시간과 교착 회복 시간이 늘었기 때문이다
- 로봇이 많으면 속도가 자동으로 느려지기 때문이다
- 배터리가 빨리 닳기 때문이다
정답 보기
② — 4대에서는 일하는 시간의 절반(50 %)을 기다리는 데 쓰고, 교착이 1시간에 100번 넘게 생깁니다. 주문이 남아 있어도(대기 주문이 쌓임) 처리량이 늘지 않으므로 ① 은 아닙니다. 일방통행으로 바꾸면 같은 4대가 216 건/h 로 늘어납니다.화살표는 각 로봇이 가려는 다음 칸입니다. 모든 로봇이 다른 로봇이 비켜 주기 전에는 움직일 수 없는 교착은 어느 것인가요?
- 한 칸 폭 통로에서 R1 → 오른쪽, R2 (R1 의 오른쪽 칸) → 더 오른쪽 빈 칸
- R1 → R2 의 칸, R2 → R3 의 칸, R3 은 출고 베이에서 하역 중
- 2 × 2 교차로에서 R1 → R2 칸, R2 → R3 칸, R3 → R4 칸, R4 → R1 칸
- R1 은 대기 지점(베이)에서 예약을 기다리고, R2 는 예약한 경로를 달리는 중
정답 보기
③ — 기다림이 R1 → R2 → R3 → R4 → R1 로 **원**을 이룹니다(실습 과제 3-1 의 C). ① 은 R2 가 움직이면 풀리고, ② 는 사슬이라 하역이 끝나면 풀리며, ④ 는 예약 규칙이 의도한 정상 대기입니다.로봇 1~2대만 쓰는 작은 창고에서 일방통행을 도입했더니 오히려 처리량이 떨어졌습니다. 시뮬레이터 4 로 본 이유와 알맞은 대응은?
- 일방통행은 언제나 손해이므로 쓰지 않는다
- 대수가 적으면 마주칠 일이 드물어, 돌아가는 거리만 늘어난다. 대수가 적을 때는 예약이나 자유 주행, 늘어나면 일방통행을 검토한다
- 일방통행에서는 로봇 속도를 두 배로 올리면 된다
- ROS_DOMAIN_ID 를 바꾸면 해결된다
정답 보기
② — 1대일 때 93 → 64 건/h 로 줄었지만 4대에서는 일방통행이 가장 많이 처리했습니다(216 건/h). 규칙의 이득(기다림 감소)과 대가(돌아가는 거리)가 대수에 따라 뒤집힙니다. 속도를 올리면(③) 4교시에서 보듯 안전 지표가 나빠집니다.4교시 · 팀 미션: 우리 창고 물류 시스템#
팀별 시나리오 설계#
지금까지 만든 것을 하나로 묶습니다. 팀마다 "우리 창고" 의 조건을 정하고, 시뮬레이터로 30분을 돌려 평가한 뒤, 실물 한 대로 일부를 시연해 비교합니다.
| 정할 것 | 고를 수 있는 것 | 근거가 되는 교시 |
|---|---|---|
| 맵 | 교차로 창고(1차선) · 넓은 피킹장(2차선) | 3교시 |
| 주문 목록 | 주문 빈도(건/분), 픽업 · 출고 위치 | 1 · 3교시 |
| 로봇 수 · 배정 | 1~4대, 가까운 · 한가한 · 배터리 고려 | 3교시 |
| 충전 정책 | 충전 시작 전압, 작업 마치고 / 즉시 | 2교시 |
| 안전 규칙 | 교통 규칙, 속도 제한, 보행자 구역, 막힘 대기 · 재시도 | 1 · 3 · 4교시 |
평가 지표#
| 지표 | 뜻 | 좋은 방향 |
|---|---|---|
| 완료 주문 수 | 30분 동안 하역까지 끝낸 주문 | 많을수록 |
| 평균 배송 시간 | 주문이 들어온 때 → 하역 끝 | 짧을수록 |
| 최소 장애물 거리 | 보행자가 갑자기 나타났을 때 멈춘 뒤 남은 거리의 최솟값 | 클수록 (팀이 기준을 정함, 예: 0.05 m 이상) |
| 안전 정지 횟수 | 보행자 때문에 멈춘 횟수 · 그중 접촉 횟수 | 접촉은 반드시 0 |
시뮬레이터 5 의 보행자는 움직이는 로봇의 경로 앞 2~4번째 칸(선반 사이)에서 갑자기 나타나고, 앞 공간이 1 m 이하이면 안전 정지로 셉니다. 로봇은 반응 시간(0.1 s) 동안 그대로 가다가 1.0 m/s² 로 감속한다고 보고(교육용 가정), 남은 거리 = 앞 공간 − (속도 × 0.1 + 속도² ÷ 2) 로 계산합니다. 0.5 m/s 의 제동 거리는 0.175 m, 0.8 m/s 는 0.40 m 입니다. 종합 점수는 예시로 완료 − 2 × 평균 배송(분) − 20 × 접촉 − 10 × 저전압 잠금 − 5 × 사람 개입 을 씁니다. 팀이 가중치를 바꿔도 되지만, 안전 기준을 통과하지 못한 설정은 점수와 관계없이 탈락입니다.
시뮬레이터 5 · 팀 시나리오 30분 실행#
설정을 고르고 ▶ 30분 실행 을 누르면 곧바로 평가표가 나옵니다. 👀 화면으로 보기 는 같은 30분을 30배 빠르게 보여 줍니다. 팀 번호는 주문 · 보행자의 난수를 정하므로, 같은 설정 코드는 어느 컴퓨터에서나 같은 결과를 냅니다. 설정 코드를 다른 팀에 보내 결과를 예측하게 하세요.
- 기본값(교차로 창고 · 3대 · 일방통행 · 0.5 m/s · 19.6 V · 보행자 1 명/분)을 실행해 평가표를 적습니다.
- 속도 제한만 0.3 → 0.5 → 0.6 → 0.8 m/s 로 바꿔 실행합니다. 완료 주문과 최소 장애물 거리 · 접촉이 어떻게 바뀌나요? 우리 팀의 속도 제한을 정하고 이유를 씁니다.
- 충전 시작을 19.2 V 로 낮춰 실행합니다(시작 배터리 18 % 인 4번째 로봇이 있도록 로봇 4대로). 저전압 잠금이 생기나요?
- 로봇 4대 · 규칙 없음 · 0.8 m/s 처럼 "많이 · 빠르게" 만 고른 설정과, 2차선 · 4대 · 경로 예약 · 0.5 m/s 를 비교합니다. 어느 쪽이 안전 기준을 통과하나요?
- 우리 팀의 최종 설정 코드를 복사해 다른 팀에 보내고, 다른 팀의 코드를 받아 실행하기 전에 완료 주문 · 접촉 횟수를 예측해 적은 뒤 코드 불러오기 로 맞혀 봅니다.
- 팀 번호 7 · 교차로 창고 · 3대 · 일방통행에서 속도 제한을 0.3 / 0.4 / 0.5 / 0.6 / 0.8 m/s 로 바꾸면 완료 주문은 55 / 67 / 72 / 72 / 85 건, 최소 장애물 거리는 0.13 / 0.13 / 0.10 / 0.00 / 0.00 m 이고 0.6 m/s 부터 접촉이 생깁니다. 0.5 → 0.6 m/s 에서는 처리량이 늘지 않는데 위험만 커집니다. 속도 제한은 "가장 빠른 안전한 값" 을 찾는 일입니다.
- 4대 · 규칙 없음 · 0.8 m/s 는 완료 주문이 111 건으로 가장 많지만 접촉 4회로 탈락이고, 2차선 · 4대 · 경로 예약 · 0.5 m/s 는 109 건 · 접촉 0 으로 통과합니다. 처리량 차이는 2 % 뿐입니다.
- 4대 · 충전 시작 19.2 V 에서는 시작 배터리 18 % 인 로봇이 일을 계속 받다가 주행 중 19.0 V 아래로 떨어져 저전압 잠금 1회가 생깁니다. 그 로봇이 1차선 통로를 막아 뒤의 로봇들이 90 s 넘게 서 있다가 사람 개입 2회가 나오고, 완료 주문은 19.6 V 의 92 건보다 적은 84 건입니다. 한 대의 배터리 실수가 전체를 멈춥니다(2교시의 결론과 같음).
확장 아이디어#
- 로봇팔 탑재 피킹: 상판에 myCobot 270 M5 같은 로봇팔을 올리면 "선반 앞에서 집기" 가 사람 없이 됩니다(ch01 · ch02 의 URDF 합치기). FSM 의 적재 상태가 "팔로 집기 → 흡착 확인 → 팔 접기" 의 하위 상태 기계가 됩니다. 팔이 펴진 상태에서 주행하지 않도록 "팔 접힘 확인" 을 이송 상태의 진입 조건으로 둡니다.
- 카메라 보행자 추종: 카메라로 사람을 인식해 따라가는 기능(예: 작업자 뒤를 따라가며 피킹)을 FSM 의 새 상태 "추종" 으로 넣을 수 있습니다. 공식 문서의 카메라 응용 예제를 참고하되, 추종 중에도 LiDAR 안전 정지는 그대로 둡니다.
- Rtabmap 3D 지도: ch10 의 Rtabmap 으로 선반 다리 · 매달린 물체처럼 2D LiDAR 가 못 보는 장애물을 지도에 넣으면, "최소 장애물 거리" 지표가 실제에 가까워집니다.
실물 시연 체크리스트#
시뮬레이터의 결과를 실물에서 그대로 믿지 않습니다. 실물 시연은 로봇 1대 · 짧은 경로 · 저속으로 시뮬레이터의 일부를 재현해, 시뮬과 무엇이 다른지 확인하는 것이 목표입니다.
실습 과제 4#
다섯 팀이 시뮬레이터 5 를 같은 팀 번호(7)로 돌린 결과입니다. 종합 점수와 안전 기준을 계산해 순위를 매기세요. TODO 두 곳. 예측 먼저: 완료 주문이 가장 많은 B 팀은 몇 위가 될까요?
# 팀별 30분 실행 결과 (시뮬레이터 5, 팀 번호 7, 주문 4 건/분, 시작 배터리 50/35/25/18 %)
TEAMS = {
"A 1차선 · 3대 · 일방통행 · 0.5 m/s": dict(done=72, avg=394, min_clr=0.10, stops=12, contact=0, low=0, dead=0, manual=0),
"B 1차선 · 4대 · 규칙 없음 · 0.8 m/s": dict(done=111, avg=242, min_clr=0.00, stops=11, contact=4, low=0, dead=44, manual=0),
"C 2차선 · 4대 · 경로 예약 · 0.5 m/s": dict(done=109, avg=266, min_clr=0.10, stops=10, contact=0, low=0, dead=0, manual=0),
"D 1차선 · 2대 · 일방통행 · 0.3 m/s": dict(done=40, avg=688, min_clr=0.13, stops=12, contact=0, low=0, dead=0, manual=0),
"E 2차선 · 4대 · 규칙 없음 · 0.5 m/s": dict(done=109, avg=291, min_clr=0.10, stops=11, contact=0, low=0, dead=47, manual=0),
}
SAFE_CLR = 0.05 # 최소 거리 기준 (m) - 팀이 정함
def score(m):
"""시뮬레이터 5 와 같은 예시 식: 완료 - 2 x 평균 배송(분) - 20 x 접촉 - 10 x 저전압 - 5 x 사람 개입"""
return m["done"] # TODO 1: 벌점 네 가지를 빼기
def safe(m):
"""안전 기준: 접촉 0 회 그리고 최소 거리 SAFE_CLR 이상"""
return True # TODO 2: 접촉 0 회 그리고 최소 거리 SAFE_CLR 이상
rank = sorted(TEAMS.items(), key=lambda kv: (not safe(kv[1]), -score(kv[1])))
print("순위 팀 점수 안전")
for i, (name, m) in enumerate(rank, 1):
print("%2d %-34s %6.1f %s" % (i, name, score(m), "통과" if safe(m) else "미달 (접촉 %d, 최소 %.2f m)" % (m["contact"], m["min_clr"])))
# 처리량만 본 순위와 비교
best = max(TEAMS.items(), key=lambda kv: kv[1]["done"])
print("\n완료 주문만 보면 1등:", best[0], best[1]["done"], "건")풀이 코드 보기
# 팀별 30분 실행 결과 (시뮬레이터 5, 팀 번호 7, 주문 4 건/분, 시작 배터리 50/35/25/18 %)
TEAMS = {
"A 1차선 · 3대 · 일방통행 · 0.5 m/s": dict(done=72, avg=394, min_clr=0.10, stops=12, contact=0, low=0, dead=0, manual=0),
"B 1차선 · 4대 · 규칙 없음 · 0.8 m/s": dict(done=111, avg=242, min_clr=0.00, stops=11, contact=4, low=0, dead=44, manual=0),
"C 2차선 · 4대 · 경로 예약 · 0.5 m/s": dict(done=109, avg=266, min_clr=0.10, stops=10, contact=0, low=0, dead=0, manual=0),
"D 1차선 · 2대 · 일방통행 · 0.3 m/s": dict(done=40, avg=688, min_clr=0.13, stops=12, contact=0, low=0, dead=0, manual=0),
"E 2차선 · 4대 · 규칙 없음 · 0.5 m/s": dict(done=109, avg=291, min_clr=0.10, stops=11, contact=0, low=0, dead=47, manual=0),
}
SAFE_CLR = 0.05 # 최소 거리 기준 (m) - 팀이 정함
def score(m):
"""시뮬레이터 5 와 같은 예시 식: 완료 - 2 x 평균 배송(분) - 20 x 접촉 - 10 x 저전압 - 5 x 사람 개입"""
return m["done"] - 2 * m["avg"] / 60 - 20 * m["contact"] - 10 * m["low"] - 5 * m["manual"]
def safe(m):
"""안전 기준: 접촉 0 회 그리고 최소 거리 SAFE_CLR 이상"""
return m["contact"] == 0 and m["min_clr"] >= SAFE_CLR
rank = sorted(TEAMS.items(), key=lambda kv: (not safe(kv[1]), -score(kv[1])))
print("순위 팀 점수 안전")
for i, (name, m) in enumerate(rank, 1):
print("%2d %-34s %6.1f %s" % (i, name, score(m), "통과" if safe(m) else "미달 (접촉 %d, 최소 %.2f m)" % (m["contact"], m["min_clr"])))
# 처리량만 본 순위와 비교
best = max(TEAMS.items(), key=lambda kv: kv[1]["done"])
print("\n완료 주문만 보면 1등:", best[0], best[1]["done"], "건")실행 결과:
순위 팀 점수 안전
1 C 2차선 · 4대 · 경로 예약 · 0.5 m/s 100.1 통과
2 E 2차선 · 4대 · 규칙 없음 · 0.5 m/s 99.3 통과
3 A 1차선 · 3대 · 일방통행 · 0.5 m/s 58.9 통과
4 D 1차선 · 2대 · 일방통행 · 0.3 m/s 17.1 통과
5 B 1차선 · 4대 · 규칙 없음 · 0.8 m/s 22.9 미달 (접촉 4, 최소 0.00 m)
완료 주문만 보면 1등: B 1차선 · 4대 · 규칙 없음 · 0.8 m/s 111 건- B 팀은 완료 주문 1등(111 건)이지만 접촉 4회로 안전 기준 미달이라 꼴찌입니다. 정렬할 때
(not safe, -score)처럼 안전을 먼저 보고 점수를 나중에 봅니다. - C 와 E 는 완료 주문이 같지만(109 건) 경로 예약을 쓴 C 의 배송 시간이 짧아 1위입니다. E 는 교착이 47번 생겨 회복에 시간을 썼습니다.
- D 는 가장 안전하지만(최소 거리 0.13 m) 처리량이 너무 낮습니다. 안전 기준을 통과한 설정 안에서 처리량을 높이는 것이 팀 미션의 목표입니다.
팀 번호 7 · 3대 · 일방통행에서 속도 제한을 0.5 m/s 에서 0.6 m/s 로 올렸더니 완료 주문은 72 건 그대로였고 접촉이 생겼습니다. 가장 알맞은 결론은?
- 0.6 m/s 가 더 빠르므로 0.6 m/s 를 고른다
- 처리량은 교통 · 대기에 막혀 늘지 않고 제동 거리만 길어졌으므로 0.5 m/s 이하로 정한다
- 보행자를 0 명으로 설정하면 문제없다
- 접촉은 난수 때문이므로 무시한다
정답 보기
② — 제동 거리는 속도의 제곱에 비례해 늘어(0.5 m/s 0.175 m → 0.6 m/s 0.24 m), 갑자기 나타난 보행자 앞에서 남는 거리가 0 이 됩니다. 처리량이 늘지 않는 구간에서 속도를 올리는 것은 위험만 사는 일입니다. 실물에서는 보행자를 없앨 수 없으므로 ③ 은 답이 아닙니다.다른 팀이 보낸 설정 코드가 map=wide;n=4;rate=4;rule=none;as=batt;v=0.5;thr=19.2;walk=1;seed=7 입니다. 실행하기 전에 가장 그럴듯한 예측은?
- 교착이 0 이고 처리량이 가장 낮다
- 2차선이지만 규칙이 없어 교착이 수십 번 생기고, 처리량은 경로 예약을 쓴 같은 조건과 비슷하다
- 접촉이 여러 번 생긴다
- 로봇이 한 대도 움직이지 않는다
정답 보기
② — 3교시에서 본 것처럼 2차선이라도 방향 규칙이 없으면 같은 차선을 골라 마주칩니다. 실습 과제 4-1 의 E 팀과 비슷한 설정으로, 교착 47번 · 109 건이었습니다. 0.5 m/s 에서는 접촉이 생기지 않았습니다(③ 아님).목표: "주문 4 건/분이 들어오는 창고에서, 접촉 0 · 최소 장애물 거리 0.05 m 이상 · 저전압 잠금 0 을 지키면서 30분 동안 가장 많은 주문을 처리하는 설정" 을 찾고, 실물 1대로 일부를 시연해 비교 보고합니다.
- 설계 (10분): 위의 시나리오 표를 채웁니다. 설정마다 근거가 된 교시의 관찰(예: "4대 이상이면 일방통행")을 한 줄씩 씁니다.
- 시뮬 (15분): 시뮬레이터 5 로 설정을 3가지 이상 시험하고 평가표를 기록합니다. 최종 설정 코드를 정합니다.
- 예측 퀴즈 교환 (10분): 설정 코드를 다른 팀과 바꿔, 실행 전에 완료 주문 · 접촉 · 교착을 예측해 적고 맞혀 봅니다. 가장 많이 맞힌 팀이 이깁니다.
- 실물 시연 (15분): 체크리스트를 지키며 로봇 1대로 픽업 → 출고 → 복귀 한 바퀴와, 통로에 상자를 놓았을 때의 상태 전이를 재현합니다. 가능하면 자동 충전 한 번을 시연합니다.
- 보고: 시뮬레이터 결과와 실물 결과를 한 표에 놓고, 차이의 원인과 다음에 바꿀 설정 하나를 적습니다.
실습 (실물)#
실물 myAGV Plus 한 대로 ① 작업 상태 기계로 픽업 → 출고 → 복귀를 돌리고, ② 공식 자동 충전을 시연합니다. 다중 로봇은 실물에서 하지 않고 시뮬레이터로만 합니다.
① Nav2 + 작업 상태 기계 (한 대, 저속) — ch10 의 nav2_simple_commander 위에 1교시의 상태 전이 표를 얹은 뼈대입니다. Nav2 가 실행 중이고 2D Pose Estimate 로 위치를 맞춘 상태에서 실행합니다. 좌표는 여러분 지도의 map 좌표로 바꿉니다.
# fsm_demo.py - Nav2 가 실행 중일 때. 주문 목록을 FSM 으로 처리하고 CSV 로그를 남김
import csv, math, time
import rclpy
from geometry_msgs.msg import PoseStamped
from nav2_simple_commander.robot_navigator import BasicNavigator, TaskResult
SPOT = {"H": (0.0, 0.0, 0.0), "A": (2.0, 1.0, 1.57), "B": (2.5, -1.0, -1.57), "OUT": (3.5, 0.0, 0.0)} # 예시 좌표
ORDERS = ["A", "B"]
LED = {"IDLE": (255, 255, 255), "GO_PICK": (0, 0, 255), "LOAD": (255, 200, 0), "GO_DROP": (0, 255, 0),
"UNLOAD": (255, 200, 0), "RETURN": (0, 200, 255), "BLOCKED": (255, 120, 0), "FAULT": (255, 0, 0)}
def pose(nav, name):
x, y, th = SPOT[name]
p = PoseStamped()
p.header.frame_id = "map"
p.header.stamp = nav.get_clock().now().to_msg()
p.pose.position.x, p.pose.position.y = x, y
p.pose.orientation.z, p.pose.orientation.w = math.sin(th / 2), math.cos(th / 2)
return p
def main():
rclpy.init()
nav = BasicNavigator()
nav.waitUntilNav2Active()
log = open("fsm_log.csv", "a", newline="")
w = csv.writer(log)
t0 = time.time()
def enter(state, event):
# LED · 펌프는 상태가 바뀔 때만. bringup 과 같은 직렬 포트를 pymycobot 으로 또 열 수 있는지는 확인 필요 -> 여기서는 출력만
print("%-8s <- %-12s LED %s" % (state, event, LED.get(state)))
w.writerow(["%.1f" % (time.time() - t0), state, event])
log.flush()
return state
def go(target, state):
"""이동 상태: 목표를 보내고 결과에 따라 사건을 돌려줌. 실패하면 최대 2번 다시 시도"""
for attempt in range(3):
nav.goToPose(pose(nav, target))
while not nav.isTaskComplete():
time.sleep(0.2)
if nav.getResult() == TaskResult.SUCCEEDED:
return "arrived"
enter("BLOCKED", "path_blocked") # Nav2 의 복구 행동도 실패 -> 기다렸다 재시도
time.sleep(3.0)
enter(state, "replan")
return "no_path"
state = enter("IDLE", "start")
try:
for name in ORDERS:
state = enter("GO_PICK", "order")
if go(name, state) != "arrived":
state = enter("FAULT", "no_path_report")
break
state = enter("LOAD", "arrived")
time.sleep(3.0) # 실제로는 펌프 켬 + 흡착 확인
state = enter("GO_DROP", "loaded")
if go("OUT", state) != "arrived":
state = enter("FAULT", "no_path_report")
break
state = enter("UNLOAD", "arrived")
time.sleep(2.0) # 실제로는 펌프 끔
if state != "FAULT":
state = enter("RETURN", "unloaded")
go("H", state)
enter("IDLE", "arrived")
finally:
nav.cancelTask() # Ctrl + C 로 끝나도 목표를 남기지 않음
log.close()
rclpy.shutdown()
if __name__ == "__main__":
main()- 실행 중 통로에 빈 상자를 놓아 BLOCKED → replan 전이가 로그에 남는지 확인합니다. Nav2 가 먼저 우회하면 BLOCKED 가 나타나지 않을 수 있습니다(Nav2 의 복구 행동이 1차 대응을 하기 때문). 그 차이도 보고서에 적습니다.
- 배터리 판정은 ch05 의
level()을 쓰되, bringup 이 하위 보드와 통신하는 동안 전압을 어느 토픽으로 읽을 수 있는지는 확인 필요입니다(ros2 topic list로 배터리 관련 토픽을 찾아봅니다).
② 공식 자동 충전 시연 — 공식 문서 6.2.7 의 순서대로 합니다. 처음 한 번은 도크 위치를 기록해야 합니다.
# (처음 한 번) 워크스페이스 준비 - 공식 문서: 첫 전체 빌드는 약 1시간
cd ~/myagv_plus_ros2 && colcon build
# 터미널 1 · 2: bringup, 내비게이션 (RViz 에서 2D Pose Estimate 로 위치를 맞춤)
ros2 launch myagv_plus_bringup myagv_plus_bringup.launch.py
ros2 launch myagv_plus_navigation2 navigation2_active.launch.py
# 터미널 3: 자동 충전 프로그램
ros2 run myagv_plus_autocharge combined_auto_recharger
# - 도크 위치 기록: teleop 으로 접점에 정면으로 붙인 뒤 Enter (1초 동안 모은 자세의 중앙값을 저장)
# 또는 RViz 의 2D Goal Pose 로 도크 위치 · 방향을 찍음
# - 충전 시작: p 키| 기록 | 1회 | 2회 | 3회 | 시뮬레이터 2 의 같은 조건 |
|---|---|---|---|---|
| 도크 앞 도착 시 옆 오차 (눈대중 cm) | σ 설정값 | |||
| 직렬 도킹 단계 시간 (s) | 성공 시 평균 시간 | |||
| 성공 여부 · 충전 전류 출력 | 1회 성공률 | |||
| 시작 · 끝 전압 (V) | - |
모델 확인 (3D 뷰어)#
강좌용 myAGV Plus 모델(assets/robot/robot.json)이 아직 없다면 뷰어에 "모델 없음" 안내가 나옵니다. 모델이 준비되면 이 차시와 관련해 다음을 확인합니다.
base_footprint에서 차체 앞면(충전 접점이 있는 면) 까지의 거리와 높이 → 도킹할 때 "접점이 닿는 순간" 의 로봇 중심 위치.forward_distance 0.35 m가 어디서 어디까지인지 그림으로 확인합니다.- 상판에 로봇팔(270 M5)이나 상자를 올렸을 때 가장 바깥 모서리 → 다중 로봇 시뮬레이터의 "한 칸 = 로봇 한 대" 가 실제 통로 폭 몇 m 에 해당하는지.
모델이 없을 때는 아래 계산으로 통로 폭과 엇갈림 가능 여부를 확인할 수 있습니다.
import math
# 교육용 가정: 차체 0.34 m x 0.24 m (ch10 과 같은 값). Plus 의 실제 치수는 3D 뷰어 · 사양서에서 확인
def outer_radius(length, width):
return math.hypot(length / 2, width / 2)
MARGIN = 0.10 # 로봇과 벽 · 로봇 사이에 둘 여유 (m)
for name, L, W in [("로봇만", 0.34, 0.24), ("상자 적재 0.45 x 0.40", 0.45, 0.40), ("로봇팔 탑재 (가정) 0.40 x 0.30", 0.40, 0.30)]:
r = outer_radius(L, W)
one = 2 * r + 2 * MARGIN # 한 대가 돌면서 지나갈 폭
two = 4 * r + 3 * MARGIN # 두 대가 엇갈릴 폭
print("%-30s 외접 반경 %.2f m -> 1차선 %.2f m, 엇갈림(2차선) %.2f m 이상" % (name, r, one, two))- 로봇만일 때 외접 반경 0.21 m 이므로 한 대가 지나가려면 약 0.62 m, 두 대가 엇갈리려면 약 1.13 m 가 필요합니다. 폭 1 m 통로는 "한 대만 지나가는 1차선" 이라 시뮬레이터 4 의 교차로 창고와 같은 상황이 됩니다.
- 상자를 실으면 외접 반경이 0.30 m 로 커져 2차선에는 약 1.5 m 가 필요합니다. 적재 상태에 따라 통로가 "2차선 → 1차선" 으로 바뀔 수 있으므로, 교통 규칙은 가장 큰 적재 상태를 기준으로 정합니다.
자주 나는 오류와 해결#
1) 자동 충전을 시작했는데 도크 앞에서 멈추고 접점에 붙지 않음#
(터미널 3) p 를 누른 뒤 Nav2 단계는 성공, 이후 로봇이 도크 앞에서 움직이지 않거나 비껴서 멈춤- 원인:
charger_position.json의 도크 위치 · 방향이 실제와 어긋나 있거나(기록할 때 접점에 정면으로 붙이지 않음), AMCL 위치 추정이 틀려 도착점이 비껴 있습니다. 2단계는 도크의 안내 프레임을 받아야 하므로, 도크 전원이 꺼져 있어도 같은 증상입니다(확인 필요). - 해결: RViz 에서 빨간 화살표(도크 위치)가 실제 도크 앞을 가리키는지 봅니다. 접점에 정면으로 붙인 뒤 Enter 로 다시 기록하거나 2D Goal Pose 로 다시 찍습니다. 2D Pose Estimate 로 스캔이 지도와 겹치는지 먼저 확인합니다(ch10).
2) combined_auto_recharger 실행이 안 됨#
Package 'myagv_plus_autocharge' not found- 원인: 워크스페이스를 빌드하지 않았거나, 새 터미널에서
source install/setup.bash를 하지 않았습니다. 공식 문서의 의존 패키지(ros-humble-robot-localization등)가 없어 빌드가 실패했을 수도 있습니다. - 해결:
cd ~/myagv_plus_ros2 && colcon build의 오류를 확인하고, 공식 문서 6.2.7 의sudo apt install목록을 설치한 뒤 다시 빌드 · source 합니다(첫 빌드는 약 1시간, ch09 의 메모리 부족 대처 참고).
3) FSM 이 이송 중 상자를 든 채로 픽업하러 감#
12.4,BLOCKED,10.25,3.25,19.81,path_blocked
15.4,GO_PICK,10.25,3.25,19.90,replan <- 이송(GO_DROP) 이어야 함- 원인: 경로 막힘에서 돌아갈 상태를 기억하지 않고 고정값(GO_PICK)으로 돌아갔습니다. 또는 FAULT 로 갈 때
prev를 덮어써서 BLOCKED 로 돌아갔습니다. - 해결: 예외 상태에 들어갈 때
prev에 지금 상태를 저장하고, 예외 → 예외(BLOCKED → FAULT)일 때는 덮어쓰지 않습니다(실습 과제 1-1).
4) 경로가 막혔는데 로봇이 영원히 서 있음#
(로그) 46.6,BLOCKED,... 이후 몇 분 동안 같은 상태, 관제 화면에는 "이동 중" 으로 표시- 원인: BLOCKED 에서 나가는 전이가 "치워짐(cleared)" 하나뿐이라, 재계획 · 재시도 초과 전이가 없습니다. 목적지 칸 자체가 막히면 영원히 기다립니다(시뮬레이터 1 의 3번).
- 해결: 막힘 대기 시간 · 재시도 횟수를 정하고, 넘으면 FAULT 로 가서 보고합니다. 관제에는 상태 이름을 그대로 보내 "이동 중" 과 "막힘" 을 구분합니다.
5) 충전하러 가는 도중 로봇이 멈추고 움직이지 않음#
get_robot_status() -> [0, 0, 2] # 배터리 잔량 등급 2 (저전압)
move_forward(...) -> -1- 원인: "작업 마치고 충전" 정책에서 경고 뒤 남은 작업 + 도크까지 거리가 여유보다 길어 주행 중 19.0 V 아래로 떨어졌습니다(ch05 의 주행 잠금). 부하 전압은 쉬는 전압보다 0.1~0.4 V 낮습니다.
- 해결: 충전 시작 기준을 경고보다 높게 두거나(예: 20.0 V), 도크가 먼 구역에서는 즉시 충전으로 바꿉니다(시뮬레이터 1 의 5번, 시뮬레이터 3 의 4번). 멈춘 로봇은 전원을 끄고 사람이 도크로 옮겨 충전합니다.
6) 여러 대를 켰더니 한 노트북의 teleop 이 두 로봇을 같이 움직임#
ros2 topic info /cmd_vel
Publisher count: 1
Subscription count: 2- 원인: 두 로봇이 같은
ROS_DOMAIN_ID(기본 0) · 같은 토픽 이름을 씁니다. 구독자 2개가 두 로봇의 드라이버입니다. - 해결: 로봇마다
ROS_DOMAIN_ID를 다르게 하고(로봇과 그 로봇을 보는 노트북의 모든 터미널에서 같은 값), 한 관제에서 보려면 네임스페이스로 토픽 이름을 나눕니다(3교시). 바꾼 뒤ros2 topic info의 구독자 수가 1 인지 확인합니다.
7) 다중 로봇 실험에서 두 로봇이 좁은 통로에서 마주 보고 멈춰 있음#
[controller_server]: Failed to make progress
[bt_navigator]: Goal failed (두 로봇 모두, 같은 시각)- 원인: 각 로봇의 Nav2 는 상대를 장애물로만 보고 자기 최단 경로를 고집합니다. 한 칸 폭 통로의 마주침은 두 대짜리 교착입니다(시뮬레이터 4).
- 해결: 사람이 한 대를 물러나게 하고, 통로에 일방통행 규칙(바닥 표시 + 경로 순서 설계)을 두거나 통로 진입 전 대기 지점에서 예약을 받도록 관제 로직을 만듭니다. Nav2 의 Keepout · Speed 필터(ch10)로 방향별 금지 구역을 두는 방법도 있습니다.
과제#
- 상태 기계 확장: 실습 과제 1-1 의 표에 "흡착 실패(
pick_failed): 적재 → 3 s 뒤 한 번 더 적재, 두 번 실패하면 안전 정지" 를 추가하고, 사건 목록에 흡착 실패 두 번을 넣어 출력이 맞는지 확인하세요. - 충전 정책 보고서: 시뮬레이터 3 에서 빈 차 / 5 kg · 1.0 m/s 두 조건으로 충전 시작 전압 19.2 ~ 20.6 V 를 0.2 V 간격으로 바꿔 처리량 · 충전 횟수 · 저전압 잠금 표를 만들고, "우리 창고의 충전 시작 전압" 을 하나 정해 이유를 쓰세요.
- 교통 규칙 비교: 시뮬레이터 4 의 📊 비교를 규칙 세 가지 × 주문 2 · 4 · 8 건/분으로 해서, "로봇이 몇 대부터 일방통행이 유리한가" 를 표로 정리하세요.
- 팀 미션 보고서: 팀 미션의 최종 설정 코드, 평가표, 예측 퀴즈 결과, 실물 시연 기록(CSV)과 시뮬 vs 실물 비교표를 한 문서로 정리하세요.
참고자료#
- myAGV Plus 공식 문서 (영문): https://github.com/elephantrobotics/myagvPlus_docs/tree/main/MYAGV_PLUS_EN
- 6.2.7 Automatic Recharge (자동 충전: charger_position.json · nav_goal_params.yaml · combined_auto_recharger): https://github.com/elephantrobotics/myagvPlus_docs/blob/main/MYAGV_PLUS_EN/6-Software_Development_Guide/6.2-ApplicationBaseROS2/6.2.7-Automatic_recharge.md
- 6.2.5 Map Navigation (2D Pose Estimate · Nav2 Goal): https://github.com/elephantrobotics/myagvPlus_docs/blob/main/MYAGV_PLUS_EN/6-Software_Development_Guide/6.2-ApplicationBaseROS2/6.2.5-Navigation-Map_Navigation.md
- 6.2.1 ROS2 Installation (여러 대일 때 ROS_DOMAIN_ID): https://github.com/elephantrobotics/myagvPlus_docs/blob/main/MYAGV_PLUS_EN/6-Software_Development_Guide/6.2-ApplicationBaseROS2/6.2.1-ROS2_Installation.md
- myagv_plus_ros2 저장소 (Humble): https://github.com/elephantrobotics/myagv_plus_ros2
- myagv_ros2 저장소 (이전 모델 myAGV 용, Nav2 설정 참고): https://github.com/elephantrobotics/myagv_ros2
- Nav2 Simple Commander API: https://docs.nav2.org/commander_api/index.html
- Nav2 — Keepout · Speed Filter: https://docs.nav2.org/tutorials/docs/navigation2_with_keepout_filter.html
- ROS 2 문서 — 도메인 ID: https://docs.ros.org/en/humble/Concepts/Intermediate/About-Domain-ID.html
- ROS 2 문서 — 노드 · 토픽 이름 바꾸기(네임스페이스): https://docs.ros.org/en/humble/How-To-Guides/Node-arguments.html
- T. Le-Anh, M. B. M. de Koster, A review of design and control of automated guided vehicle systems (AGV 교통 제어 · 작업 배정 · 교착 개관), European Journal of Operational Research, 2006
- myAGV Plus 제품 사진 · 소개 (hyenc.net): https://www.hyenc.net/products/35
- 이 사이트의 도구: URDF 뷰어 · Python Playground
- 이전 차시: ch10 ROS 2 SLAM 과 Nav2 자율주행 · 관련 차시: ch05 상태 진단 · LED · IO · 원격 제어 · ch09 ROS 2 Humble 과 myAGV Plus 패키지