CH05상태 진단 · LED · IO · 원격 제어
배터리 · 자이로 · 모터 상태를 읽어 로봇을 진단하고, LED · IO 핀 · 흡착 펌프로 물류 신호를 만들며, 소켓 서버로 PC 에서 원격 제어합니다.
학습 목표#
get_robot_status()와get_all_msg()가 돌려주는 값의 순서와 의미를 읽고, 배터리 판정 규칙(19.6 V 이하 경고 · 19.0 V 미만 저전압 · 두 배터리 모두 19.0 V 미만이면 주행 잠금)으로 로봇 상태를 판정할 수 있습니다.- 매번 묻는 폴링(polling) 과 ESP32 의 50 ms 자동 보고의 차이를 시간축 그림으로 설명하고, 상황에 맞는 읽기 방식을 고를 수 있습니다.
get_motor_status()·get_motor_torques()·get_motor_temps()등으로 바퀴별 상태를 표로 만들고, 바퀴 구속(stall) 고장을 진단해 안전한 순서로 복구(stop→ 원인 제거 →clear_motor_error→ 확인 → 저속 재출발)할 수 있습니다.set_led_mode·set_led_color·set_pin_output·get_pin_input·set_pump_io로 물류 상태 신호와 흡착 픽업 순서를 만들고, 펌프 IO 의 반전 논리(Low = 켬) 를 설명할 수 있습니다.- 소켓 원격 제어에서 통신 지연 · 연결 끊김이 정지 위치에 주는 영향을 계산하고, 로봇 쪽 하트비트 감시(watchdog)로 안전한 원격 제어 구조를 설계할 수 있습니다.
이 페이지에는 브라우저에서 바로 동작하는 시뮬레이터 6개가 있습니다. 조작하기 전에 결과를 먼저 예측해 적고, 슬라이더 · 버튼으로 확인하세요. ch04 와 같이 Playground 실습 코드는 pymycobot 대신 같은 메서드 이름 · 같은 반환값을 흉내 내는 교육용 클래스를 코드 맨 위에 넣어 실행합니다. 실물로 옮길 때는 import 줄과 sleep 출처만 바꿉니다.
공식 문서(myagvPlus_docs 6.1.2 API) 기준: 메서드 이름 · 인수 범위 · 반환 형식, get_all_msg() 9개 항목의 순서, 배터리 경고 19.6 V · 저전압 19.0 V, 이중 배터리 저전압 · 모터 구속 시 동작 잠금, 자동 보고 50 ms, set_pump_io 의 핀 2 또는 5 와 반전 논리, 소켓 서버 포트 9000.
교육용 가정(실물 값은 확인 필요): 배터리 용량 · 내부 저항 · 소비 전력식, 모터 번호와 바퀴 위치의 대응(M1 = 앞왼 …), 구속 판정까지 걸리는 시간 · 오류 코드 숫자, 모터 온도 상승률, IO 핀의 전류 한도 숫자, 흡착에 필요한 시간, 통신 왕복 시간. 시뮬레이터는 원리를 보여 주기 위한 것이며, 숫자는 실물에서 다시 측정해야 합니다.
1교시 · 상태 읽기: 배터리 · 자이로 · 자동 보고#
get_robot_status() 와 get_all_msg()#
ch04 에서 본 것처럼 MyAGVPlus 객체는 직렬 링크 두 개를 엽니다. 배터리 · 자이로 같은 상태 정보는 ESP32 보조 보드(115200 baud) 가 맡습니다. 상태를 읽는 메서드는 두 가지입니다.
| 메서드 | 반환 | 쓰임 |
|---|---|---|
get_robot_status() | [배터리 상태, 자이로 상태, 배터리 잔량 등급] | 한눈에 보는 요약 (모두 정수) |
get_all_msg() | 9개 항목 리스트 | 전압 · 충전 여부 · 자이로 원시 데이터까지 전부 |
get_all_msg() 의 9개 항목. 앞의 세 칸은 get_robot_status() 와 같은 내용입니다.| 번호 | 항목 | 형식 | 값의 뜻 |
|---|---|---|---|
| 0 | 배터리 상태 | int | 0 정상 · 1 이상 |
| 1 | 자이로 상태 | int | 0 정상 · 1 이상 |
| 2 | 배터리 잔량 등급 | int | 0 정상 · 1 경고(≤ 19.6 V) · 2 저전압(< 19.0 V) |
| 3 | 충전 상태 | str | 2진수 문자열 (비트 배치는 문서에 없음 — 확인 필요) |
| 4 | 주 배터리 전압 | float | V |
| 5 | 보조 배터리 전압 | float | V |
| 6 | 자이로 원시 데이터 | list[float] | 18바이트를 해석한 값 (단위 · 순서는 문서에 없음) |
| 7 | 고정밀 주 배터리 전압 | float | 지원하는 펌웨어에서만 |
| 8 | 고정밀 보조 배터리 전압 | float | 지원하는 펌웨어에서만 |
- 리스트는 번호로 읽습니다.
msg[4]가 주 배터리,msg[5]가 보조 배터리입니다. 번호를 헷갈리면 "자이로 데이터를 전압이라고 출력" 하는 일이 생깁니다. - 자이로(gyroscope) 원시 데이터는 ch06 오도메트리에서 회전 추정에 씁니다. 이 차시에서는 자이로 상태 0/1 만 확인합니다.
- 7 · 8번은 "지원하는 경우" 에만 의미 있는 값입니다. 코드에서는
len(msg) > 7을 먼저 확인하는 습관을 들입니다.
배터리 판정 규칙#
| 조건 | 등급 · 동작 |
|---|---|
| 19.6 V 초과 | 0 정상 |
| 19.6 V 이하 | 1 경고 — 충전 계획을 세움 |
| 19.0 V 미만 | 2 저전압 — 그 배터리는 거의 바닥 |
| 두 배터리 모두 19.0 V 미만 | 백그라운드 감시가 BACKGROUND VOLTAGE DETECTED! 를 띄우고 모든 이동을 잠금 (이동 명령 −1) |
19.6 V 는 이하(19.6 포함)라 경고, 19.0 V 는 미만(19.0 은 아직 경고)입니다. 판정 함수에서 <= 와 < 를 바꿔 쓰면 정확히 경계값에서 등급이 하나씩 어긋납니다. 실습 과제 1-1 에 경계값 시험이 들어 있습니다.
같은 API 문서에 충전 중(19.8 V · 20.3 V) · 방전 중(19.2 V · 19.7 V) 기준이 따로 적혀 있어 위 19.6 / 19.0 V 와 다릅니다. 펌웨어 버전에 따라 기준이 다를 수 있으므로, 실물에서는 get_robot_status() 의 등급 값과 전압을 함께 기록해 실제 경계를 확인합니다(확인 필요). 이 강좌의 판정 · 시뮬레이터는 19.6 / 19.0 V 를 씁니다.
전압은 부하에 따라 출렁입니다. 배터리 안에는 작은 저항(내부 저항)이 있어서 전류를 많이 뽑을수록 단자 전압이 내려갑니다.
주행 중 전압 = 쉬는 전압(충전량으로 정해짐) - 전류 × 내부 저항그래서 같은 충전량이라도 빠르게 · 무겁게 달릴 때 경고가 먼저 뜨고, 멈추면 전압이 조금 올라옵니다. 시뮬레이터 2 에서 이 현상을 직접 봅니다.
폴링 vs 50 ms 자동 보고#
상태를 얻는 길은 두 가지입니다.
| 방식 | 메서드 | 동작 |
|---|---|---|
| 폴링 (묻고 기다리기) | get_all_msg() · get_robot_status() | 프로그램이 요청을 보내고 응답이 올 때까지 기다림 |
| 자동 보고 (받아 둔 것 읽기) | set_auto_report_state(1) → get_auto_report_message() | ESP32 가 50 ms 마다 알아서 보내고, 프로그램은 가장 최근 패킷을 바로 가져감 |
set_auto_report_state(state): 0 끄기 · 1 켜기, 반환 1 성공 / 0 실패.get_auto_report_state()로 현재 상태를 확인합니다.get_auto_report_message()는get_all_msg()와 같은 구조의 리스트를 돌려줍니다. 그래서 판정 함수 하나를 두 방식에 모두 쓸 수 있습니다.- 자동 보고는 "가장 최근 것 하나" 만 줍니다. 그 사이에 지나간 값은 프로그램이 자주 읽지 않으면 놓칩니다.
시뮬레이터 1 · 폴링 vs 자동 보고 타임라인#
4초 동안의 실제 배터리 전압(위)과, 두 방식으로 프로그램이 읽은 값(아래)을 같은 시간축에 그립니다. 가속할 때마다 전압이 약 150 ms 동안 19.6 V 아래로 잠깐 떨어집니다(4번). 회색 막대는 프로그램이 응답을 기다리느라 멈춰 있던 시간입니다.
- 읽기 주기 500 ms 에서 폴링은 경고 강하 4번 중 몇 번을 잡을까요? 표의 "잡은 경고 강하" 로 확인합니다.
- 읽기 주기를 50 ms 로 줄입니다. 두 방식 모두 4번을 다 잡나요? 그 대신 폴링의 "프로그램이 기다린 시간" 은 몇 % 가 되나요?
- 50 ms 에서 폴링 응답 대기를 30 ms 로 올립니다. 프로그램 시간의 절반 넘게 상태를 묻느라 멈춰 있게 됩니다. 이동 · 판단 코드는 언제 돌까요?
- 자동 보고 체크를 끕니다.
get_auto_report_message()만 쓰는 코드는 어떻게 되나요? - 읽기 주기 150 ms · 200 ms · 300 ms 를 차례로 넣어 봅니다. 강하가 150 ms 동안 이어지는데, 주기가 강하 길이보다 길면 왜 놓치기 시작할까요?
- 값을 놓치는지는 얼마나 자주 읽느냐 가 정합니다. 강하가 이어지는 시간(150 ms)보다 읽기 간격이 길면, 읽는 순간이 강하 구간에 들어갈 때만 잡힙니다.
- 폴링은 읽을 때마다 응답을 기다립니다. 자주 읽을수록 프로그램 시간이 상태 확인에 묶입니다. 자동 보고는 ESP32 가 50 ms 마다 미리 보내 두므로 읽기가 거의 공짜이고, 값의 나이는 최대 약 50 ms 입니다.
- 자동 보고도 "최신 하나" 만 주므로, 50 ms 보다 드물게 읽으면 그 사이 패킷은 버려집니다. 짧은 강하까지 기록하려면 50 ms 안팎으로 자주 읽는 루프가 필요합니다.
- 짧은 강하는 가속 순간의 부하 때문이고, 그 자체로 잠금을 일으키지는 않습니다. 실제 잠금 판단은 pymycobot 내부의 백그라운드 감시가 합니다(시뮬레이터 2).
- 폴링 응답 대기 12 ms 는 교육용 가정입니다. 실물에서는
time.perf_counter()로get_all_msg()앞뒤 시간을 재어 확인합니다(실습 과제 1-1).
시뮬레이터 2 · 배터리 모델: 선반 왕복#
8 m 떨어진 선반 A ↔ B 를 왕복합니다(선반마다 3초 정지 · 상하차). 한 번 왕복할 때마다 두 배터리가 전력을 나누어 씁니다. 아래 그래프는 바퀴(왕복 횟수)마다 주행 중 전압을 찍습니다. 로봇 뒤쪽 LED 는 get_robot_status() 의 등급(초록 0 · 주황 1 · 빨강 2)을 표시합니다.
소비 전력 P = 12 + 25 · v · (1 + 적재/5) + 15 · v² [W] (12 W 는 컴퓨터 · 센서 대기 전력)
한 바퀴 에너지 = P × (2 × 8 m / v) + 12 W × (2 × 3 s) (두 배터리가 절반씩)
배터리 하나 60 Wh, 내부 저항 0.25 Ω (모두 교육용 가정)- 적재 5 kg · 1.0 m/s, 주 30 % · 보조 25 % 에서 몇 바퀴 만에 경고가 뜰지 예측해 적고 "결과 바로 보기" 로 확인합니다. 경고는 어느 배터리 때문에 떴나요?
- 그대로 비교용으로 남기고, 적재를 0 kg 으로 바꿉니다. 경고까지 바퀴 수가 몇 배가 되나요?
- 0 kg 에서 속도를 0.5 m/s 로 낮춥니다. 더 느리게 다니면 무조건 오래 갈까요? 1.0 m/s 와 비교하고, 소비 전력과 "한 바퀴 J" 를 함께 봅니다.
- 5 kg · 1.6 m/s 로 올립니다. 보라 실선(주행 중)과 보라 점선(정지 중)의 간격이 1.0 m/s 일 때보다 왜 넓어지나요?
- "왕복 시작" 으로 빨리 감으며 LED 색이 바뀌는 순간을 봅니다. 보조 배터리가 저전압(빨강)이 된 뒤에도 몇 바퀴를 더 달리나요? 잠금은 언제 걸리나요?
- 같은 충전량이라도 부하가 크면 단자 전압이 더 내려갑니다(전류 × 내부 저항). 적재 · 속도를 올리면 경고가 일찍 뜨고, 실선(주행 중)과 점선(정지 중)의 간격이 넓어집니다.
- 한 바퀴 에너지에는 대기 전력 × 시간 이 들어 있습니다. 느리게 가면 바퀴당 시간이 길어져 컴퓨터 · 센서가 쓰는 전력이 쌓이므로, "느릴수록 무조건 이득" 은 아닙니다(이 모델에서는 빈 차 1.0 m/s 가 0.5 m/s 보다 바퀴당 에너지가 적습니다).
- 이중 배터리는 한쪽이 저전압이어도 다른 쪽이 버티면 주행이 됩니다. 그 대신 경고 이후에도 달리면 결국 둘 다 내려가 선반 사이 통로 한가운데서 잠깁니다. 경고(등급 1)가 뜨면 바로 충전 계획을 세우는 이유입니다(자동 충전은 ch11).
- 이 모델의 용량 · 저항 · 전력식은 교육용 가정입니다. 실물은 같은 실험을
get_all_msg()기록으로 다시 해 보아야 합니다.
실습 과제 1#
get_all_msg() 의 9개 항목 리스트를 받아 배터리마다 등급, 주행 잠금 여부, 자이로 상태를 판정하는 judge(msg) 를 만듭니다. 교육용 클래스 SimStatus 가 여러 상황의 리스트를 돌려줍니다. 경계값(19.6 V · 19.0 V)이 들어 있는 줄을 특히 확인하세요. 예측 먼저: 5번 상황(주 19.0 V · 보조 18.9 V)은 잠금일까요?
class SimStatus:
"""교육용: get_all_msg() 와 같은 9개 항목 리스트를 상황별로 돌려줌"""
CASES = [
# [배터리상태, 자이로상태, 등급, 충전, 주V, 보조V, 자이로원시, 고정밀주V, 고정밀보조V]
[0, 0, 0, "00", 23.10, 22.95, [0.0] * 9, 23.104, 22.951],
[0, 0, 1, "00", 21.00, 19.60, [0.0] * 9, 21.003, 19.598],
[0, 0, 2, "00", 20.40, 18.95, [0.0] * 9, 20.401, 18.948],
[0, 1, 2, "00", 18.70, 18.60, [0.0] * 9, 18.702, 18.601],
[0, 0, 1, "00", 19.00, 18.90, [0.0] * 9, 19.003, 18.902],
]
def __init__(self):
self.i = -1
def get_all_msg(self):
self.i += 1
return list(self.CASES[self.i % len(self.CASES)])
def level(v):
# TODO 1: 19.0 미만 -> 2, 19.6 이하 -> 1, 그 밖 -> 0
return 0
def judge(msg):
v_main, v_sub = msg[4], msg[5]
# TODO 2: 배터리마다 level() 로 등급을 구함
# TODO 3: 두 배터리 모두 19.0 V 미만이면 locked = True
# TODO 4: msg[1] 이 1 이면 자이로 이상
lv_main, lv_sub, locked, gyro_ok = 0, 0, False, True
return lv_main, lv_sub, locked, gyro_ok
agv = SimStatus()
print("상황 주V 보조V 등급(주,보조) 잠금 자이로")
for n in range(1, 6):
msg = agv.get_all_msg()
lm, ls, locked, gyro_ok = judge(msg)
print("%d %5.2f %5.2f (%d, %d) %-5s %s"
% (n, msg[4], msg[5], lm, ls, locked, "정상" if gyro_ok else "이상"))풀이 코드 보기
class SimStatus:
"""교육용: get_all_msg() 와 같은 9개 항목 리스트를 상황별로 돌려줌"""
CASES = [
# [배터리상태, 자이로상태, 등급, 충전, 주V, 보조V, 자이로원시, 고정밀주V, 고정밀보조V]
[0, 0, 0, "00", 23.10, 22.95, [0.0] * 9, 23.104, 22.951],
[0, 0, 1, "00", 21.00, 19.60, [0.0] * 9, 21.003, 19.598],
[0, 0, 2, "00", 20.40, 18.95, [0.0] * 9, 20.401, 18.948],
[0, 1, 2, "00", 18.70, 18.60, [0.0] * 9, 18.702, 18.601],
[0, 0, 1, "00", 19.00, 18.90, [0.0] * 9, 19.003, 18.902],
]
def __init__(self):
self.i = -1
def get_all_msg(self):
self.i += 1
return list(self.CASES[self.i % len(self.CASES)])
def level(v):
if v < 19.0:
return 2
if v <= 19.6:
return 1
return 0
def judge(msg):
v_main, v_sub = msg[4], msg[5]
lv_main, lv_sub = level(v_main), level(v_sub)
locked = v_main < 19.0 and v_sub < 19.0
gyro_ok = (msg[1] == 0)
return lv_main, lv_sub, locked, gyro_ok
agv = SimStatus()
print("상황 주V 보조V 등급(주,보조) 잠금 자이로")
for n in range(1, 6):
msg = agv.get_all_msg()
lm, ls, locked, gyro_ok = judge(msg)
print("%d %5.2f %5.2f (%d, %d) %-5s %s"
% (n, msg[4], msg[5], lm, ls, locked, "정상" if gyro_ok else "이상"))실행 결과의 핵심 줄:
2 21.00 19.60 (0, 1) False 정상
3 20.40 18.95 (0, 2) False 정상
4 18.70 18.60 (2, 2) True 이상
5 19.00 18.90 (1, 2) False 정상- 2번: 19.60 V 는 "이하" 라 경고(1)입니다.
<로 쓰면 0 이 나와 틀립니다. - 5번: 주 배터리 19.00 V 는 "미만" 이 아니므로 아직 경고(1)이고, 두 배터리 모두 19.0 V 미만이 아니므로 잠금이 아닙니다. 다음 바퀴에 0.01 V 만 내려가도 잠깁니다.
msg[2](로봇이 보낸 등급)는 두 배터리 중 하나만 반영한 값일 수 있으므로, 배터리별 판정은 전압msg[4]·msg[5]로 직접 하는 편이 정보가 많습니다.
시뮬레이터 2 의 배터리 모델을 그대로 옮겼습니다. TODO 를 채워 적재 5 kg · 1.0 m/s, 주 30 % · 보조 25 % 에서 첫 경고 · 잠금이 몇 바퀴째인지 구하고, 적재 0 kg 과 비교하세요. 예측 먼저: 5 kg 일 때 경고까지 몇 바퀴일까요? 0 kg 이면 몇 배가 될까요?
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_CAP = 60.0 * 3600 # 배터리 하나 60 Wh (J)
R_PACK = 0.25 # 내부 저항 (옴)
P_IDLE = 12.0 # 대기 전력 (W)
D_AISLE, T_STOP = 8.0, 3.0
def ocv(soc):
soc = max(0.0, min(1.0, soc))
for (s0, v0), (s1, v1) in zip(OCV, OCV[1:]):
if soc <= s1:
return v0 + (v1 - v0) * (soc - s0) / (s1 - s0)
return OCV[-1][1]
def drive_power(v, load):
return P_IDLE + 25 * v * (1 + load / 5) + 15 * v * v
def loaded_v(soc, p_total):
e = ocv(soc)
return e - (p_total / 2) / e * R_PACK # 두 배터리가 절반씩
def lap_energy(v, load):
return drive_power(v, load) * 2 * D_AISLE / v + P_IDLE * 2 * T_STOP
def simulate(v, load, soc_m, soc_s, max_laps=3000):
e_half = lap_energy(v, load) / 2
p = drive_power(v, load)
warn = lock = None
for lap in range(1, max_laps + 1):
# TODO 1: 두 배터리의 충전량을 e_half / E_CAP 만큼 줄임
# TODO 2: 두 배터리의 주행 중 전압 vm, vs 를 loaded_v() 로 구함
vm, vs = ocv(soc_m), ocv(soc_s)
# TODO 3: 처음으로 min(vm, vs) <= 19.6 이 된 바퀴를 warn 에 기록
# TODO 4: vm, vs 가 모두 19.0 미만이면 lock 에 기록하고 break
return warn, lock
for load in (5, 0):
w, l = simulate(1.0, load, 0.30, 0.25)
print("적재 %d kg, 1.0 m/s: 경고 %s 바퀴, 잠금 %s 바퀴" % (load, w, l))풀이 코드 보기
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_CAP = 60.0 * 3600 # 배터리 하나 60 Wh (J)
R_PACK = 0.25 # 내부 저항 (옴)
P_IDLE = 12.0 # 대기 전력 (W)
D_AISLE, T_STOP = 8.0, 3.0
def ocv(soc):
soc = max(0.0, min(1.0, soc))
for (s0, v0), (s1, v1) in zip(OCV, OCV[1:]):
if soc <= s1:
return v0 + (v1 - v0) * (soc - s0) / (s1 - s0)
return OCV[-1][1]
def drive_power(v, load):
return P_IDLE + 25 * v * (1 + load / 5) + 15 * v * v
def loaded_v(soc, p_total):
e = ocv(soc)
return e - (p_total / 2) / e * R_PACK # 두 배터리가 절반씩
def lap_energy(v, load):
return drive_power(v, load) * 2 * D_AISLE / v + P_IDLE * 2 * T_STOP
def simulate(v, load, soc_m, soc_s, max_laps=3000):
e_half = lap_energy(v, load) / 2
p = drive_power(v, load)
warn = lock = None
for lap in range(1, max_laps + 1):
soc_m -= e_half / E_CAP
soc_s -= e_half / E_CAP
vm, vs = loaded_v(soc_m, p), loaded_v(soc_s, p)
if warn is None and min(vm, vs) <= 19.6:
warn = (lap, round(vm, 2), round(vs, 2))
if vm < 19.0 and vs < 19.0:
lock = (lap, round(vm, 2), round(vs, 2))
break
return warn, lock
for load in (5, 0):
w, l = simulate(1.0, load, 0.30, 0.25)
print("적재 %d kg, 1.0 m/s: 경고 %s 바퀴, 잠금 %s 바퀴" % (load, w, l))
print("한 바퀴 에너지 5 kg: %.0f J, 0 kg: %.0f J" % (lap_energy(1.0, 5), lap_energy(1.0, 0)))실행 결과:
적재 5 kg, 1.0 m/s: 경고 (41, 20.09, 19.58) 바퀴, 잠금 (73, 18.98, 18.08) 바퀴
적재 0 kg, 1.0 m/s: 경고 (66, 20.1, 19.59) 바퀴, 잠금 (110, 18.98, 18.04) 바퀴
한 바퀴 에너지 5 kg: 1304 J, 0 kg: 904 J5 kg 은 41 바퀴(약 15 분), 0 kg 은 66 바퀴에서 경고가 뜹니다. 바퀴당 에너지 비(1304 / 904 ≈ 1.44)보다 바퀴 수 비(66 / 41 ≈ 1.61)가 더 큰 것은, 무거울 때 전류가 커서 전압이 더 깊게 처지기 때문입니다. 경고는 충전량이 낮은 보조 배터리가 먼저 냅니다. 시뮬레이터 2 의 숫자와 같은지 확인하세요.
시뮬레이터 2 에서 적재 5 kg · 1.6 m/s 로 달리다가 선반에 멈춰 상하차하는 동안 get_all_msg()[5] 를 읽었더니 19.8 V, 다시 출발해 달리는 중에 읽었더니 19.5 V 였습니다. 가장 알맞은 해석은?
- 같은 충전량에서도 주행 중에는 큰 전류 때문에 단자 전압이 내려간 것이며, 주행 중 기준으로는 이미 경고 구간이다
- 정지 중에 배터리가 충전되었다
- 센서 오류이므로 무시해도 된다
- 19.8 V 가 진짜 값이므로 경고는 오판이다
정답 보기
① — 주행 중 전압 = 쉬는 전압 − 전류 × 내부 저항 입니다. 시뮬레이터 2 의 보라 실선(주행)과 점선(정지)의 간격이 바로 이 차이이며, 고속 · 고적재일수록 넓어집니다. 정지 중 전압만 보고 안심하면 다음 주행에서 곧 잠금에 가까워집니다. 짧은 정지로 충전되지는 않습니다(② 틀림).get_all_msg() 가 [0, 0, 2, "00", 18.8, 19.4, [...], 18.81, 19.42] 를 돌려주었습니다. 이 순간 이동 명령 move_forward(0.3) 의 반환값과 상태 해석으로 맞는 것은?
- −1 — 주 배터리가 19.0 V 미만이므로 잠금
- 0 — 등급 2 이면 명령이 무시된다
- 1 — 등급 2 는 "충전 중" 이라는 뜻이다
- 1 — 보조 배터리가 19.0 V 이상이라 잠금은 아니지만, 주는 저전압 · 보조는 경고이므로 곧바로 충전하러 가야 한다
정답 보기
④ — 잠금은 **두 배터리 모두** 19.0 V 미만일 때입니다. 보조 19.4 V 가 버티므로 주행은 되지만, 시뮬레이터 2 에서 본 것처럼 몇 바퀴 안에 보조도 내려가 잠깁니다. 등급(인덱스 2) 2 는 저전압이며 충전 여부는 인덱스 3 의 문자열로 봅니다(③ 틀림). 이동 메서드의 실패 반환은 0 이 아니라 −1 입니다(② 틀림).시뮬레이터 1 에서 읽기 주기 50 ms · 폴링 응답 대기 12 ms 일 때 폴링의 "프로그램이 기다린 시간" 이 약 24 % 였습니다. 같은 50 ms 로 상태를 보면서 이동 판단 코드에 시간을 더 주려면?
- 폴링 주기를 1000 ms 로 늘린다
get_all_msg()를 두 번씩 호출한다set_auto_report_state(1)로 자동 보고를 켜고get_auto_report_message()로 최신 패킷을 읽는다- 응답 대기를 줄이기 위해 baud 를 921600 으로 바꾼다
정답 보기
③ — 자동 보고는 ESP32 가 50 ms 마다 미리 보내 두므로 읽을 때 기다리지 않고(0 %), 값의 나이도 50 ms 이내입니다. ① 은 기다림은 줄지만 경고 강하를 놓칩니다(시뮬레이터 1 해 볼 것 1). ④ 는 ESP32 의 baud(115200)를 바꾸는 것이라 연결 자체가 깨집니다(ch04).2교시 · 모터 진단과 오류 복구#
바퀴별 상태를 읽는 메서드#
myAGV Plus 의 네 바퀴는 각각 DM 모터가 돌립니다. 모터마다 상태를 읽을 수 있습니다.
| 메서드 | 인수 | 반환 | 단위 · 뜻 |
|---|---|---|---|
get_motor_status() | 없음 | [m1, m2, m3, m4] | 하드웨어 오류 코드, 0 이 정상 (코드 숫자의 뜻은 문서에 없음) |
get_motor_enable_status() | 없음 | [m1, m2, m3, m4] | 1 활성(온라인) · 0 비활성(오프라인) |
get_motor_temps() | 없음 | [m1, m2, m3, m4] | 구동부(MOS) 온도 (단위는 문서에 없음 — 이 강좌는 °C 로 가정) |
get_motor_velocity(id) | 1~4 | float | 바퀴 각속도, rad/s |
get_motor_torque(id) | 1~4 | float | 바퀴 토크, N·m |
get_motor_torques() | 없음 | [m1, m2, m3, m4] | 네 바퀴 토크 한 번에 |
- 리스트를 돌려주는 메서드(복수형)는 한 번 호출로 네 값을 줍니다. 대시보드처럼 주기적으로 읽을 때는
get_motor_torques()처럼 한 번에 읽는 쪽이 통신 횟수가 적습니다. - ch03 의 역기구학으로 명령 바퀴 속도를 계산할 수 있습니다. 0.3 m/s 전진이면
0.3 / 0.05 = 6 rad/s(바퀴 반지름 0.05 m 는 교육용 가정). 명령값과 측정값을 나란히 놓아야 이상을 알아볼 수 있습니다.
모터 번호와 바퀴 위치#
공식 문서에는 모터 번호 1~4 가 어느 바퀴인지 적혀 있지 않습니다. 이 차시의 시뮬레이터와 실습은 다음을 가정합니다.
| 번호 | 시뮬 가정 위치 | ch03 기호 |
|---|---|---|
| M1 | 앞 왼쪽 | FL |
| M2 | 앞 오른쪽 | FR |
| M3 | 뒤 왼쪽 | RL |
| M4 | 뒤 오른쪽 | RR |
바퀴를 띄운 상태에서 move_forward(0.05) 를 보내고 get_motor_velocity(1) ~ (4) 를 차례로 읽으면서, 한 바퀴씩 손으로 살짝 잡아(장갑 착용, 저속에서만) 값이 떨어지는 번호를 기록합니다. 또는 set_motor_enable(n, 0) 으로 하나씩 끄고 멈추는 바퀴를 봅니다.
강좌용 myAGV Plus 모델(assets/robot/robot.json)이 준비되면 3D 뷰어에서 바퀴 링크 이름과 위치를 확인해 위 표와 대조해 봅니다. 모델이 아직 없으면 뷰어에 "모델 없음" 안내가 나오므로, ch02 의 URDF 트리와 위의 실물 확인 절차로 대신합니다.
모터 활성 · 오류 해제#
| 메서드 | 인수 | 하는 일 |
|---|---|---|
set_motor_enable(motor_id, state) | id 1~4, 254 = 전체 · state 0 끔 / 1 켬 | 모터에 힘을 넣거나 뺌. 반환 1 성공 |
clear_motor_error(motor_id) | id 1~4, 254 = 전체 | 그 모터를 리셋하고 다시 활성화해 오류 코드를 지움. 반환 1 성공 |
바퀴가 이물질에 걸리거나 과부하가 걸리면 모터 전류가 치솟고, 백그라운드 감시가 STALL DETECTED! 를 띄우며 모든 이동을 잠급니다. 이후 이동 명령은 −1 입니다.
clear_motor_error() 는 코드만 지웁니다. 바퀴를 막고 있는 물건은 그대로입니다. 다시 움직이면 곧바로 같은 구속이 일어나고, 그때마다 모터가 최대 토크로 버티며 열이 쌓입니다. 그리고 이동 명령이 남아 있는 상태에서 잠금이 풀리면 로봇이 갑자기 다시 움직일 수 있습니다(이 강좌의 시뮬은 안전한 쪽으로 이렇게 가정합니다 — 실물 동작은 확인 필요).
시뮬레이터 3 · 모터 진단 대시보드와 고장 주입#
왼쪽은 위에서 본 로봇(바퀴 색 = 토크 크기), 오른쪽은 최근 10초 토크 그래프입니다. 아래 표는 1초마다 대시보드가 찍는 값이며, 이상값은 칸이 주황 · 빨강으로 바뀝니다. 버튼 하나가 Python 한 줄입니다.
move_forward(0.3)로 달리게 한 뒤 M2 앞오른 · 구속 을 주입합니다. 주입 직전에 예측: 표에서 가장 먼저 이상해지는 칸은 무엇일까요(속도 · 토크 · 온도 · 상태 코드)? 그다음은? 몇 초 뒤에 잠금이 걸리나요?- 잠금이 걸린 뒤
move_forward(0.3)를 눌러 반환값을 봅니다. 이어서 원인을 치우지 않고clear_motor_error(2)를 누르면 무슨 일이 생기나요? 로그의 주황 줄을 읽어 봅니다. - 처음으로 돌아가 같은 고장을 만든 뒤, 이번에는 그림의 복구 순서(
stop()→ 원인 제거 →clear_motor_error(2)→get_motor_status()→move_forward)대로 해 봅니다. 2번과 무엇이 다른가요? - 구속 상태에서 차체 속도 · 회전 추정값을 봅니다. 앞오른 바퀴가 멈추면 로봇은 어느 쪽으로 돌려고 하나요? ch03 의 역기구학으로 설명해 봅니다.
- M3 뒤왼 · 마찰 증가 를 주입하고 10배속으로 1분 이상 달립니다. 잠금은 걸리나요? 대시보드에서 어떤 칸이 언제 경고로 바뀌나요?
- 구속은 바퀴 속도(0 으로 떨어짐)와 토크(최대치로 치솟음) 에서 거의 동시에 먼저 보입니다. 상태 코드는 최대 토크가 약 1초 이어진 뒤에야 바뀌고(시뮬 가정), 온도는 가장 늦게, 아주 조금 오릅니다. 온도만 보는 감시는 구속을 놓칩니다.
- 한 바퀴가 멈추면 나머지 세 바퀴가 끌고 가느라 토크가 같이 올라가고, 차체가 멈춘 바퀴 쪽으로 돌아갑니다(앞오른 구속 → 시계 방향 회전, 회전 추정이 음수).
- 원인을 치우지 않고 해제하면 남아 있던 명령으로 다시 출발했다가 같은 자리에서 또 잠깁니다. 반복할 때마다 모터 온도가 계단처럼 쌓입니다. 그래서 복구는 반드시
stop()과 원인 제거가 먼저입니다. - 마찰 증가는 잠금 없이 계속 달리지만 토크 칸이 계속 주황이고 온도가 천천히 오릅니다. 잠금이 안 걸리는 고장은 대시보드가 아니면 찾기 어렵습니다.
- 오류 코드 8, 구속 판정 1초, 온도 상승률은 시뮬 가정입니다. 실물의 코드 숫자 · 판정 조건은 문서에 없으므로 기록해 두세요(확인 필요).
실습 과제 2#
교육용 SimMotors 는 get_motor_velocity · get_motor_torques · get_motor_temps · get_motor_status 를 흉내 내고, t = 3 s 에 M2 구속을 스스로 일으킵니다. TODO 를 채워 1초마다 표 한 줄씩 출력하고, 이상값 뒤에 ! 를 붙이세요. 예측 먼저: 몇 초 줄에서 처음 ! 가 나오고, 그 줄에서 ! 가 붙는 항목은 무엇일까요?
class SimMotors:
"""교육용: 바퀴 4개 모터 상태를 흉내 냄 (t = 3 s 에 M2 구속, 숫자는 교육용 가정)"""
def __init__(self):
self.t, self.lock, self.cmd = 0.0, False, 0.0
self.w = [0.0] * 4
self.tau = [0.0] * 4
self.temp = [32.0] * 4
self.code = [0] * 4
self.stall_since = None
def move_forward(self, v):
if self.lock:
return -1
self.cmd = v
return 1
def stop(self):
self.cmd = 0.0
return 1
def _step(self, dt):
self.t += dt
wc = 0.0 if self.lock else self.cmd / 0.05
for i in range(4):
stalled = (i == 1 and self.t >= 3.0)
if stalled:
self.w[i] = 0.0
self.tau[i] = min(3.0, self.tau[i] + 10 * dt) if wc else max(0.0, self.tau[i] - 20 * dt)
else:
self.w[i] += (wc - self.w[i]) * min(1.0, dt / 0.15)
self.tau[i] = (0.18 * (1.8 if self.t >= 3.0 else 1.0)) if wc else 0.0
self.temp[i] += (0.12 * self.tau[i] ** 2 - 0.01 * (self.temp[i] - 30)) * dt
if self.tau[1] >= 3.0 and not self.lock:
self.stall_since = self.stall_since if self.stall_since is not None else self.t
if self.t - self.stall_since >= 1.0:
self.lock, self.code[1] = True, 8
print("STALL DETECTED! (t = %.1f s)" % self.t)
def sleep(self, sec):
for _ in range(int(round(sec / 0.01))):
self._step(0.01)
def get_motor_velocity(self, mid): return round(self.w[mid - 1], 2)
def get_motor_torques(self): return [round(x, 2) for x in self.tau]
def get_motor_temps(self): return [round(x, 1) for x in self.temp]
def get_motor_status(self): return list(self.code)
agv = SimMotors()
sleep = agv.sleep
W_CMD = 0.3 / 0.05 # 명령 바퀴 속도 6 rad/s
def flag(bad):
return "!" if bad else " "
agv.move_forward(0.3)
print(" t 속도 M1..M4 (rad/s) 토크 M1..M4 (N.m) 온도 M2 코드")
for n in range(1, 8):
sleep(1.0)
vel = [agv.get_motor_velocity(i) for i in range(1, 5)]
tq = agv.get_motor_torques()
tp = agv.get_motor_temps()
st = agv.get_motor_status()
# TODO 1: 속도가 명령의 절반보다 작으면(명령이 0 이 아닐 때) 이상 -> flag(True)
# TODO 2: |토크| > 1.5 N.m 이면 이상
# TODO 3: 상태 코드가 0 이 아니면 이상
vs = " ".join("%5.1f%s" % (v, flag(False)) for v in vel)
ts = " ".join("%5.2f%s" % (x, flag(False)) for x in tq)
print("%2d %s %s %5.1f %s" % (n, vs, ts, tp[1], st))
agv.stop()풀이 코드 보기
class SimMotors:
"""교육용: 바퀴 4개 모터 상태를 흉내 냄 (t = 3 s 에 M2 구속, 숫자는 교육용 가정)"""
def __init__(self):
self.t, self.lock, self.cmd = 0.0, False, 0.0
self.w = [0.0] * 4
self.tau = [0.0] * 4
self.temp = [32.0] * 4
self.code = [0] * 4
self.stall_since = None
def move_forward(self, v):
if self.lock:
return -1
self.cmd = v
return 1
def stop(self):
self.cmd = 0.0
return 1
def _step(self, dt):
self.t += dt
wc = 0.0 if self.lock else self.cmd / 0.05
for i in range(4):
stalled = (i == 1 and self.t >= 3.0)
if stalled:
self.w[i] = 0.0
self.tau[i] = min(3.0, self.tau[i] + 10 * dt) if wc else max(0.0, self.tau[i] - 20 * dt)
else:
self.w[i] += (wc - self.w[i]) * min(1.0, dt / 0.15)
self.tau[i] = (0.18 * (1.8 if self.t >= 3.0 else 1.0)) if wc else 0.0
self.temp[i] += (0.12 * self.tau[i] ** 2 - 0.01 * (self.temp[i] - 30)) * dt
if self.tau[1] >= 3.0 and not self.lock:
self.stall_since = self.stall_since if self.stall_since is not None else self.t
if self.t - self.stall_since >= 1.0:
self.lock, self.code[1] = True, 8
print("STALL DETECTED! (t = %.1f s)" % self.t)
def sleep(self, sec):
for _ in range(int(round(sec / 0.01))):
self._step(0.01)
def get_motor_velocity(self, mid): return round(self.w[mid - 1], 2)
def get_motor_torques(self): return [round(x, 2) for x in self.tau]
def get_motor_temps(self): return [round(x, 1) for x in self.temp]
def get_motor_status(self): return list(self.code)
agv = SimMotors()
sleep = agv.sleep
W_CMD = 0.3 / 0.05 # 명령 바퀴 속도 6 rad/s
def flag(bad):
return "!" if bad else " "
agv.move_forward(0.3)
print(" t 속도 M1..M4 (rad/s) 토크 M1..M4 (N.m) 온도 M2 코드")
for n in range(1, 8):
sleep(1.0)
vel = [agv.get_motor_velocity(i) for i in range(1, 5)]
tq = agv.get_motor_torques()
tp = agv.get_motor_temps()
st = agv.get_motor_status()
cmd = 0.0 if agv.lock else W_CMD
vs = " ".join("%5.1f%s" % (v, flag(cmd and abs(v) < 0.5 * cmd)) for v in vel)
ts = " ".join("%5.2f%s" % (x, flag(abs(x) > 1.5)) for x in tq)
alarm = " <- 코드 이상" if any(st) else ""
print("%2d %s %s %5.1f %s%s" % (n, vs, ts, tp[1], st, alarm))
agv.stop()실행 결과(요약):
3 6.0 0.0! 6.0 6.0 0.32 3.00! 0.32 0.32 32.1 [0, 0, 0, 0]
STALL DETECTED! (t = 4.3 s)
5 0.0 0.0 0.0 0.0 0.00 0.00 0.00 0.00 33.2 [0, 8, 0, 0] <- 코드 이상t = 3 s 줄에서 M2 의 속도(0.0)와 토크(3.00) 에 동시에 ! 가 붙습니다. 상태 코드는 최대 토크가 1초 이어진 뒤(t ≈ 4.3 s) 바뀌어 5초 줄에야 보이고, 온도는 7초가 지나도 약 1 °C 오를 뿐입니다. 잠금 뒤에는 명령이 0 이 되므로 속도 칸의 ! 가 사라집니다 — 그래서 대시보드는 코드 칸을 함께 봐야 합니다.
recover(agv, motor_id) 를 만듭니다. starter 는 오류부터 지우는 잘못된 순서라 다시 출발하자마자 또 잠깁니다. TODO 를 채워 그림의 순서대로 고치고, 마지막에 저속 0.1 m/s 로 2초 시험 주행해 반환값과 상태 코드를 확인합니다. agv.remove_obstacle() 은 "사람이 이물질을 치웠다" 를 흉내 내는 교육용 메서드입니다.
class SimAGV:
"""교육용: 구속 · 잠금 · 해제 흐름만 흉내 냄 (해제하면 남은 명령을 다시 따른다고 가정)"""
def __init__(self):
self.t, self.cmd, self.lock = 0.0, 0.0, True # 이미 M2 구속으로 잠긴 상태에서 시작
self.code, self.obstacle = [0, 8, 0, 0], True
self.cmd = 0.3 # 잠기기 전 마지막 명령이 남아 있음
self.log = []
def stop(self):
self.cmd = 0.0; self.log.append("stop"); return 1
def move_forward(self, v):
if self.lock:
self.log.append("move -1"); return -1
self.cmd = v; self.log.append("move %.1f" % v); return 1
def clear_motor_error(self, mid):
ids = range(4) if mid == 254 else [mid - 1]
for i in ids:
self.code[i] = 0
if not any(self.code):
self.lock = False
self.log.append("clear %d" % mid); return 1
def get_motor_status(self):
return list(self.code)
def remove_obstacle(self):
self.obstacle = False; self.log.append("remove")
def sleep(self, sec):
self.t += sec
if self.obstacle and self.cmd > 0 and not self.lock:
self.lock, self.code[1] = True, 8
self.log.append("STALL")
def recover(agv, motor_id):
# TODO: 순서를 고치세요. 1) stop 2) 원인 제거 3) 오류 해제 4) 상태 확인 5) 저속 시험
agv.clear_motor_error(motor_id)
agv.sleep(1.0)
status = agv.get_motor_status()
agv.remove_obstacle()
ret = agv.move_forward(0.1)
agv.sleep(2.0)
agv.stop()
return ret, agv.get_motor_status()
agv = SimAGV()
print("결과:", recover(agv, 2))
print("순서:", " -> ".join(agv.log))풀이 코드 보기
class SimAGV:
"""교육용: 구속 · 잠금 · 해제 흐름만 흉내 냄 (해제하면 남은 명령을 다시 따른다고 가정)"""
def __init__(self):
self.t, self.cmd, self.lock = 0.0, 0.0, True # 이미 M2 구속으로 잠긴 상태에서 시작
self.code, self.obstacle = [0, 8, 0, 0], True
self.cmd = 0.3 # 잠기기 전 마지막 명령이 남아 있음
self.log = []
def stop(self):
self.cmd = 0.0; self.log.append("stop"); return 1
def move_forward(self, v):
if self.lock:
self.log.append("move -1"); return -1
self.cmd = v; self.log.append("move %.1f" % v); return 1
def clear_motor_error(self, mid):
ids = range(4) if mid == 254 else [mid - 1]
for i in ids:
self.code[i] = 0
if not any(self.code):
self.lock = False
self.log.append("clear %d" % mid); return 1
def get_motor_status(self):
return list(self.code)
def remove_obstacle(self):
self.obstacle = False; self.log.append("remove")
def sleep(self, sec):
self.t += sec
if self.obstacle and self.cmd > 0 and not self.lock:
self.lock, self.code[1] = True, 8
self.log.append("STALL")
def recover(agv, motor_id):
agv.stop() # 1) 남은 명령부터 지움
agv.remove_obstacle() # 2) 원인 제거 (실물: 사람이 확인)
if agv.clear_motor_error(motor_id) != 1: # 3) 오류 해제
return "clear 실패", agv.get_motor_status()
status = agv.get_motor_status() # 4) 모두 0 인지 확인
if any(status):
return "아직 오류 코드 있음", status
ret = agv.move_forward(0.1) # 5) 저속 시험 주행
agv.sleep(2.0)
agv.stop()
return ret, agv.get_motor_status()
agv = SimAGV()
print("결과:", recover(agv, 2))
print("순서:", " -> ".join(agv.log))starter 결과는 결과: (-1, [0, 8, 0, 0]), 순서 clear 2 -> STALL -> move -1 -> stop 입니다. 오류를 지우자 남아 있던 0.3 m/s 명령으로 다시 출발해 1초 만에 또 구속되었습니다. 풀이 결과는 결과: (1, [0, 0, 0, 0]), 순서 stop -> remove -> clear 2 -> move 0.1 -> stop 입니다.
시뮬레이터 3 에서 0.3 m/s 전진 중 M2(앞오른) 구속을 주입했습니다. 1초 대시보드에서 처음 이상으로 표시되는 칸 조합은?
- M2 온도만
- M2 속도와 M2 토크
- M2 상태 코드만
- 네 바퀴 모두의 상태 코드
정답 보기
② — 구속 순간 바퀴 속도가 0 으로 떨어지고 토크가 0.3 초 안에 최대치로 오르므로, 다음 1초 측정에서 두 칸이 함께 바뀝니다. 상태 코드는 최대 토크가 약 1초 이어진 뒤에야 바뀌고(③ 은 나중), 온도는 거의 오르지 않습니다(①). 코드는 구속된 M2 에만 생깁니다(④ 틀림).STALL DETECTED! 로 잠긴 로봇을 복구하는 순서로 가장 안전한 것은?
stop()→ 이물질 제거 →clear_motor_error(2)→get_motor_status()가 모두 0 인지 확인 →move_forward(0.1)저속 시험clear_motor_error(254)→move_forward(0.3)→ 이물질 제거power_off()→power_on()→move_forward(0.3)set_motor_enable(2, 0)으로 M2 를 끄고 세 바퀴로 계속 주행
정답 보기
① — 남은 명령을 먼저 지우고(stop), 원인을 치운 뒤 해제 → 확인 → 저속 시험 순서입니다. ② 는 해제 순간 다시 움직이며 같은 자리에서 또 구속됩니다. ③ 은 원인을 그대로 둔 채 다시 시작합니다. ④ 는 시뮬레이터 3 에서 본 것처럼 차체가 한쪽으로 돌아가며 끌려가 더 위험합니다.시뮬레이터 3 에서 M3 마찰 증가를 넣고 10배속으로 오래 달렸습니다. 잠금은 걸리지 않았지만 대시보드의 M3 토크 칸이 계속 주황입니다. 가장 알맞은 판단은?
- 잠금이 없으니 정상이다
- 속도를 1.6 m/s 로 올려 이물질을 털어낸다
clear_motor_error(3)을 반복하면 고쳐진다- 잠금이 걸리지 않는 고장도 있으므로, 토크 · 온도 추세를 기록해 정비 대상으로 표시한다
정답 보기
④ — 마찰 증가는 오류 코드도 잠금도 만들지 않지만 토크가 높고 온도가 천천히 오릅니다. 이런 "조용한 고장" 을 잡는 것이 대시보드의 목적입니다. 오류 코드가 0 이므로 `clear_motor_error` 로 바뀌는 것은 없습니다(③).3교시 · LED · IO · 흡착 펌프로 물류 신호 만들기#
LED 모드: 배터리 표시 vs DIY#
| 메서드 | 인수 | 뜻 |
|---|---|---|
set_led_mode(mode) | 0 배터리 잔량 표시 (기본) · 1 DIY | LED 를 누가 쓰는지 정함. 반환 1 / 0 |
set_led_color(brightness, color) | 밝기 0~255, color = (R, G, B) | DIY 모드에서 색 지정. 반환 1 / 0 |
공식 문서는 set_led_color() 를 쓰려면 **먼저 set_led_mode(1) 을 호출해야 한다** 고 적고 있습니다. 기본 모드(0)에서는 LED 가 배터리 잔량을 표시하는 데 쓰이고 있어서, 색을 보내도 표시가 바뀌지 않습니다. 오류가 나지 않으므로 "코드는 맞는데 LED 가 안 바뀐다" 로만 보입니다.
상태 신호 설계#
창고의 사람과 다른 로봇이 멀리서도 알아보도록 상태마다 색을 정합니다.
| 상태 | 색 (R, G, B) | 표시 | 언제 |
|---|---|---|---|
| 대기 | 초록 (0, 255, 0) | 켜짐 | 출발 전 · 작업 완료 |
| 이동 중 | 파랑 (0, 0, 255) | 켜짐 | move_* 명령 직전 |
| 적재 중 | 노랑 (255, 200, 0) | 켜짐 | 펌프 켬 ~ 흡착 확인 |
| 오류 | 빨강 (255, 0, 0) | 깜빡임 (0.5 s 간격) | 흡착 실패 · 구속 · 저전압 |
- 깜빡임은
set_led_color(255, RED)와set_led_color(0, RED)를 번갈아 보내 만듭니다(밝기 0 = 꺼짐). - 색만으로 구분하기 어려운 사람도 있으므로 오류는 깜빡임처럼 색 외의 차이를 함께 둡니다.
IO 핀: 입력과 출력#
| 메서드 | 인수 | 반환 |
|---|---|---|
get_pin_input(pin) | 핀 번호 | 0 Low · 1 High · −1 읽기 실패 / 잘못된 핀 |
set_pin_output(pin, state) | 핀 번호, 0 Low / 1 High | 1 성공 / 0 실패 |
- 핀 번호 범위는 문서마다 다릅니다. API 문서는 0~6 (0 은 모든 입력을 한꺼번에 읽기), IO 예제 문서는 1~6 으로 적습니다. 이 강좌는 1~6 을 개별 핀으로 씁니다(확인 필요).
- 출력은 3.3 V 논리 레벨이며, 핀 하나가 낼 수 있는 전류는 작고 동시에 쓰는 핀이 많을수록 핀당 쓸 수 있는 전류가 줄어듭니다. 정확한 mA 값은 제품 문서에서 확인하세요(확인 필요). 릴레이 · 모터처럼 전류가 큰 부품은 핀에 바로 달지 않고 릴레이 모듈 · 트랜지스터를 거칩니다.
- IO 를 쓰려면 섀시 전원이 켜져 있어야 하며, 이때 모터도 함께 활성화됩니다(IO 예제 문서). 바퀴 주변을 비워 두고 시험합니다.
흡착 펌프와 반전 논리#
| 메서드 | 인수 | 뜻 |
|---|---|---|
set_pump_state(state) | 0 끔 · 1 켬 | 펌프를 켜고 끄는 명령. 반환 1 / −1 |
set_pump_io(pin, state) | pin 2 또는 5, state 0 = Low = 펌프 켬, 1 = High = 펌프 끔 | 펌프가 연결된 IO 핀의 레벨을 직접 정함. 반환 1 / −1 |
set_pump_io 는 반전 논리입니다. 핀을 Low(0)로 내려야 펌프가 돕니다. "1 = 켬" 이라고 생각하면 정확히 반대로 동작합니다.이런 배선을 액티브 로우(active-low) 라고 부릅니다. 코드에서는 숫자를 직접 쓰지 말고 이름을 붙여 둡니다.
PUMP_PIN = 2 # 펌프가 연결된 핀 (2 또는 5, 배선 확인)
PUMP_ON = 0 # Low = 켬 (반전 논리)
PUMP_OFF = 1 # High = 끔
agv.set_pump_io(PUMP_PIN, PUMP_ON)시뮬레이터 4 · 피킹 스테이션#
대기 위치 → 피킹 스테이션(상자 위에 멈춤) → 펌프로 흡착 → 출고 선반으로 이동 → 펌프를 꺼 내려놓기 → 복귀. 오른쪽 코드에서 지금 실행 중인 줄이 강조됩니다. 펌프는 핀 2 에 배선되어 있고, 흡착 압력이 충분히 올라오는 데 약 0.6 s 가 걸립니다(교육용 가정). 진공 스위치가 입력 핀 1 에 연결되어 흡착되면 1 을 냅니다.
- 기본값(모드 1 · 핀 2 · PUMP_ON 0 · 대기 1.0 s)으로 실행해 LED 색이 상태 표와 같은 순서로 바뀌는지 봅니다.
- PUMP_ON 을 1 (High) 로 바꾸기 전에 예측: 상자는 어떻게 될까요? 프로그램이 끝난 뒤 펌프는? 실행해 결과 문장과 "펌프 ON/off" 표시를 확인합니다.
- PUMP_ON 0 으로 되돌리고 흡착 대기 0.3 s 로 줄여 실행합니다. 이어서 흡착 확인 을 켜고 다시 실행합니다. 결과가 어떻게 달라지나요?
- set_led_mode(1) 호출 을 끄고 실행합니다. 동작은 같은데 무엇이 사라지나요?
- PUMP_PIN 을 5 로 바꿔 실행합니다. 오류 메시지가 나오나요? 진공 스위치(흡착 확인)가 있으면 어떻게 달라지나요?
PUMP_ON = 1이면 피킹 스테이션에서 핀을 High 로 두어 펌프가 꺼진 채 기다리고, 내려놓을 때PUMP_OFF = 0을 보내 출고 선반에서 펌프가 켜집니다. 상자는 그대로 남고, 프로그램이 끝나도 펌프가 계속 돕니다. 반전 논리를 거꾸로 쓰면 "안 되는" 것이 아니라 정확히 반대로 됩니다.- 흡착 압력이 올라오기 전에 출발하면 상자를 못 집거나 이동 중에 떨어뜨립니다. 시간을 늘리는 것보다 진공 스위치 입력으로 확인하는 것이 확실합니다. 확인이 있으면 실패해도 그 자리에서 멈추고 빨강 깜빡임으로 알립니다.
- 잘못된 핀이나 모드 0 은 오류를 내지 않습니다. 반환값도 성공입니다. 물리 결과(상자 위치 · LED 색)를 확인하는 센서나 사람의 눈이 필요합니다.
- 0.6 s 흡착 시간과 진공 스위치 배선은 이 시뮬의 가정입니다. 실물의 흡착 펌프 사양 · 배선은 제품 문서를 확인합니다.
시뮬레이터 5 · IO 핀 전류 예산#
출력 핀 여러 개에 부하를 연결합니다. 켜진 핀 수가 늘수로 핀마다 쓸 수 있는 전류가 줄어드는 모습을 막대로 봅니다. 이 시뮬의 한도(핀당 최대 20 mA · 전체 50 mA)는 원리를 보이기 위한 가정이며, 실물 수치는 제품 문서로 확인합니다.
- 처음 상태(핀 1 릴레이 모듈 · 핀 2 표시등)에서 핀 3 · 4 를 켜고 부하를 릴레이 모듈 입력으로 바꿉니다. 몇 번째 릴레이부터 빨강이 되나요?
- 릴레이 모듈 대신 표시등 LED 만 6개 켜면 모두 동작하나요?
- 핀 1 을 릴레이 코일 직결로 바꿉니다. 다른 핀을 모두 꺼도 동작하나요? 왜 릴레이 모듈(트랜지스터 내장)을 쓰는지 설명해 봅니다.
- 핀 수가 늘면 핀당 쓸 수 있는 전류가
전체 한도 / 켠 핀 수로 줄어듭니다. "핀 하나에서 되던 것" 이 여러 개를 켜면 안 될 수 있습니다. - 3.3 V · 수 mA 수준의 핀은 신호용입니다. 코일 · 모터처럼 큰 전류가 드는 부품은 반드시 드라이버(릴레이 모듈 · 트랜지스터)를 거칩니다. 큰 부하를 직결하면 핀이나 보드가 손상될 수 있습니다.
실습 과제 3#
교육용 SimPicker 는 LED · 펌프 IO · 진공 스위치 입력 · 이동을 흉내 내고 마지막에 상자 위치를 알려 줍니다. TODO 를 채워 도착 → 펌프 켬 → 1초 → 흡착 확인 → 출발 → 내려놓기 를 LED 신호와 함께 완성하세요. 맨 아래에서 PUMP_ON = 1 로 바꾼 코드도 실행됩니다. 예측 먼저: PUMP_ON = 1 일 때 상자 위치와 펌프 상태는?
class SimPicker:
"""교육용: 핀 2 에 흡착 펌프(Low = 켬), 입력 핀 1 에 진공 스위치. 흡착 0.6 s (가정)"""
def __init__(self):
self.t, self.x, self.mode = 0.0, 0.5, 0
self.pins = {1: 0, 2: 1, 5: 1}
self.vac, self.box, self.led_log = 0.0, "table", []
def set_led_mode(self, m): self.mode = m; return 1
def set_led_color(self, b, rgb):
if self.mode == 1: self.led_log.append(rgb if b else "off")
return 1
def set_pump_io(self, pin, state):
if pin not in (2, 5): return -1
self.pins[pin] = state; return 1
def get_pin_input(self, pin): return 1 if self.vac >= 1.0 else 0
def pump_on(self): return self.pins[2] == 0
def _step(self, dt):
self.t += dt
self.vac = min(1.0, self.vac + dt / 0.6) if self.pump_on() else max(0.0, self.vac - dt / 0.2)
if self.box == "table" and abs(self.x - 2.5) < 0.01 and self.vac >= 1.0: self.box = "robot"
if self.box == "robot" and self.vac < 0.5:
self.box = "shelf" if abs(self.x - 5.5) < 0.01 else ("table" if abs(self.x - 2.5) < 0.01 else "floor")
def sleep(self, s):
for _ in range(int(round(s / 0.01))): self._step(0.01)
def go(self, target, v=0.5):
while abs(target - self.x) > 1e-9:
d = max(-v * 0.01, min(v * 0.01, target - self.x))
self.x += d; self._step(0.01)
return 1
GREEN, BLUE, YELLOW, RED = (0, 255, 0), (0, 0, 255), (255, 200, 0), (255, 0, 0)
def pick_and_place(agv, PUMP_ON):
PUMP_PIN, PUMP_OFF = 2, 1 - PUMP_ON
led = lambda c: agv.set_led_color(255, c)
# TODO 1: LED 를 DIY 모드로 바꾸고 대기(초록) 표시
# TODO 2: 이동(파랑) 으로 피킹 스테이션 2.5 m 까지 go
# TODO 3: 적재(노랑) 표시 후 펌프 켬, 1초 대기
# TODO 4: get_pin_input(1) 이 1 이 아니면 오류(빨강 깜빡임 2번), 펌프 끔, "흡착 실패" 를 돌려줌
# TODO 5: 이동(파랑) 으로 출고 선반 5.5 m 까지 go, 펌프 끔, 0.5초 대기, 대기(초록)
return "완료"
for on in (0, 1):
agv = SimPicker()
r = pick_and_place(agv, PUMP_ON=on)
print("PUMP_ON=%d -> %s | 상자: %s | 끝난 뒤 펌프: %s | LED: %s"
% (on, r, agv.box, "ON" if agv.pump_on() else "off", agv.led_log))풀이 코드 보기
class SimPicker:
"""교육용: 핀 2 에 흡착 펌프(Low = 켬), 입력 핀 1 에 진공 스위치. 흡착 0.6 s (가정)"""
def __init__(self):
self.t, self.x, self.mode = 0.0, 0.5, 0
self.pins = {1: 0, 2: 1, 5: 1}
self.vac, self.box, self.led_log = 0.0, "table", []
def set_led_mode(self, m): self.mode = m; return 1
def set_led_color(self, b, rgb):
if self.mode == 1: self.led_log.append(rgb if b else "off")
return 1
def set_pump_io(self, pin, state):
if pin not in (2, 5): return -1
self.pins[pin] = state; return 1
def get_pin_input(self, pin): return 1 if self.vac >= 1.0 else 0
def pump_on(self): return self.pins[2] == 0
def _step(self, dt):
self.t += dt
self.vac = min(1.0, self.vac + dt / 0.6) if self.pump_on() else max(0.0, self.vac - dt / 0.2)
if self.box == "table" and abs(self.x - 2.5) < 0.01 and self.vac >= 1.0: self.box = "robot"
if self.box == "robot" and self.vac < 0.5:
self.box = "shelf" if abs(self.x - 5.5) < 0.01 else ("table" if abs(self.x - 2.5) < 0.01 else "floor")
def sleep(self, s):
for _ in range(int(round(s / 0.01))): self._step(0.01)
def go(self, target, v=0.5):
while abs(target - self.x) > 1e-9:
d = max(-v * 0.01, min(v * 0.01, target - self.x))
self.x += d; self._step(0.01)
return 1
GREEN, BLUE, YELLOW, RED = (0, 255, 0), (0, 0, 255), (255, 200, 0), (255, 0, 0)
def pick_and_place(agv, PUMP_ON):
PUMP_PIN, PUMP_OFF = 2, 1 - PUMP_ON
led = lambda c: agv.set_led_color(255, c)
agv.set_led_mode(1)
led(GREEN)
led(BLUE)
agv.go(2.5)
led(YELLOW)
agv.set_pump_io(PUMP_PIN, PUMP_ON)
agv.sleep(1.0)
if agv.get_pin_input(1) != 1:
for _ in range(2):
agv.set_led_color(255, RED); agv.sleep(0.5)
agv.set_led_color(0, RED); agv.sleep(0.5)
agv.set_pump_io(PUMP_PIN, PUMP_OFF)
return "흡착 실패"
led(BLUE)
agv.go(5.5)
agv.set_pump_io(PUMP_PIN, PUMP_OFF)
agv.sleep(0.5)
led(GREEN)
return "완료"
for on in (0, 1):
agv = SimPicker()
r = pick_and_place(agv, PUMP_ON=on)
print("PUMP_ON=%d -> %s | 상자: %s | 끝난 뒤 펌프: %s | LED: %s"
% (on, r, agv.box, "ON" if agv.pump_on() else "off", agv.led_log))실행 결과:
PUMP_ON=0 -> 완료 | 상자: shelf | 끝난 뒤 펌프: off | LED: [(0, 255, 0), (0, 0, 255), (255, 200, 0), (0, 0, 255), (0, 255, 0)]
PUMP_ON=1 -> 흡착 실패 | 상자: table | 끝난 뒤 펌프: ON | LED: [(0, 255, 0), (0, 0, 255), (255, 200, 0), (255, 0, 0), 'off', (255, 0, 0), 'off']흡착 확인이 있어서 PUMP_ON = 1 의 실수가 피킹 스테이션에서 바로 드러났습니다. 그런데 실패 처리에서 "끔" 이라고 보낸 PUMP_OFF = 0 이 실제로는 펌프를 켜서, 끝난 뒤에도 펌프가 돕니다. 상수 하나를 틀리면 정상 경로와 오류 경로가 함께 뒤집힌다는 점을 기억하세요.
시뮬레이터 5 와 같은 규칙(핀당 최대 20 mA · 전체 50 mA, 교육용 가정)으로, 출력 계획을 받아 동작하지 않을 핀을 찾는 check_budget(plan) 을 만듭니다.
PIN_MAX, TOTAL = 20.0, 50.0 # mA (교육용 가정)
def check_budget(plan):
"""plan: {핀번호: 필요전류 mA} (High 로 켤 핀만). 반환: (핀당 가능 전류, 부족한 핀 목록)"""
# TODO 1: 부하가 있는 핀 수 n 을 셈
# TODO 2: 핀당 가능 전류 = min(PIN_MAX, TOTAL / n)
# TODO 3: 필요 전류가 가능 전류보다 큰 핀 번호를 목록으로
return PIN_MAX, []
plans = {
"릴레이 모듈 3개": {1: 15, 3: 15, 4: 15},
"릴레이 모듈 4개": {1: 15, 3: 15, 4: 15, 6: 15},
"표시등 6개": {p: 4 for p in range(1, 7)},
"코일 직결 1개": {1: 70},
}
for name, plan in plans.items():
avail, bad = check_budget(plan)
print("%-12s 핀당 %.1f mA, 부족: %s" % (name, avail, bad))풀이 코드 보기
PIN_MAX, TOTAL = 20.0, 50.0 # mA (교육용 가정)
def check_budget(plan):
"""plan: {핀번호: 필요전류 mA} (High 로 켤 핀만). 반환: (핀당 가능 전류, 부족한 핀 목록)"""
n = sum(1 for need in plan.values() if need > 0)
avail = min(PIN_MAX, TOTAL / n) if n else PIN_MAX
bad = [pin for pin, need in sorted(plan.items()) if need > avail]
return avail, bad
plans = {
"릴레이 모듈 3개": {1: 15, 3: 15, 4: 15},
"릴레이 모듈 4개": {1: 15, 3: 15, 4: 15, 6: 15},
"표시등 6개": {p: 4 for p in range(1, 7)},
"코일 직결 1개": {1: 70},
}
for name, plan in plans.items():
avail, bad = check_budget(plan)
print("%-12s 핀당 %.1f mA, 부족: %s" % (name, avail, bad))실행 결과: 릴레이 모듈 3개는 핀당 16.7 mA 로 모두 동작, 4개는 12.5 mA 로 네 핀 모두 부족 [1, 3, 4, 6], 표시등 6개는 8.3 mA 로 모두 동작, 코일 직결은 20 mA 한도를 넘어 [1] 입니다. 하나만 더 켰을 뿐인데 이미 잘 되던 핀까지 함께 부족해지는 점이 핵심입니다.
시뮬레이터 4 에서 PUMP_ON = 1, 흡착 확인 없이 실행했습니다. 결과로 맞는 것은?
- 상자를 집어 정상적으로 내려놓는다
set_pump_io가 −1 을 돌려주며 예외가 난다- 피킹 스테이션에서 펌프가 꺼진 채라 상자를 못 집고, 내려놓기 단계에서 펌프가 켜져 프로그램이 끝난 뒤에도 돈다
- 펌프가 계속 꺼져 있을 뿐 다른 문제는 없다
정답 보기
③ — 펌프 IO 는 Low(0)일 때 켜지는 반전 논리입니다. "켬" 자리에 1(High)을 보내면 꺼지고, "끔" 자리의 0 이 펌프를 켭니다. 핀 2 · 5 와 값 0 · 1 은 모두 유효한 인수이므로 오류는 나지 않습니다(② 틀림).set_led_color(255, (255, 0, 0)) 이 1 을 돌려주었는데 LED 가 초록 그대로입니다. 가장 먼저 확인할 것은?
set_led_mode(1)로 DIY 모드를 켰는지 확인한다 — 기본 모드 0 에서는 LED 가 배터리 표시에 쓰인다- 밝기를 0 으로 바꾼다
- 배터리를 충전한다
- 색 튜플을 (0, 255, 0) 으로 바꾼다
정답 보기
① — 공식 문서는 `set_led_color()` 전에 `set_led_mode(1)` 을 요구합니다. 시뮬레이터 4 의 해 볼 것 4 처럼 동작은 같고 표시만 사라지며 오류가 없습니다. 초록은 배터리 정상 표시입니다.흡착 대기를 0.3 s 로 줄였더니 상자를 집지 못했습니다. 가장 확실한 개선은?
- 이동 속도를 1.0 m/s 로 올려 빨리 지나간다
- 대기를 0.6 s 로 맞춘다
- 펌프를
set_pump_io(5, 0)으로도 켠다 - 진공 스위치 입력(
get_pin_input)이 1 이 될 때까지 기다리고, 제한 시간 안에 안 되면 오류 신호를 낸다
정답 보기
④ — 고정 시간은 상자 표면 · 무게 · 펌프 상태에 따라 모자랄 수 있습니다. 센서로 **확인**하고 제한 시간을 두면 성공은 빨리, 실패는 그 자리에서 안전하게 처리됩니다. ② 는 시뮬의 가정값에만 맞춘 것이고, ③ 은 펌프가 연결되지 않은 핀일 수 있습니다.4교시 · 소켓 원격 제어와 통신 모드#
직렬 모드와 소켓 모드#
| 메서드 | 인수 · 반환 | 뜻 |
|---|---|---|
set_communication_state(state) | 0 직렬(기본) · 1 소켓, 반환 1 / −1 | 1 로 바꾸면 물리 직렬 포트를 안전하게 놓아 줌 |
get_communication_state() | 0 / 1 | 현재 모드 |
get_wifi_ip() | 문자열, 실패 시 빈 문자열 | 로봇의 Wi-Fi IP |
직렬 포트는 한 번에 한 프로그램만 열 수 있습니다. 로봇 안의 프로그램이 포트를 잡고 있으면 소켓 서버가 같은 포트를 열 수 없습니다. 소켓 모드로 바꾸는 것은 "이제 포트를 놓을 테니 서버가 맡아라" 는 뜻입니다.
소켓 서버와 PC 클라이언트#
MyAGVPlusSocket 이 Wi-Fi 로 로봇의 소켓 서버(포트 9000)에 명령을 보내고, 서버가 직렬 포트로 모터 · ESP32 에 전달합니다.로봇 쪽 (로봇 터미널):
python3 -c "from pymycobot import MyAGVPlus; a = MyAGVPlus('/dev/myagvplus_controller', baudrate=921600, esp32_port='/dev/myagvplus_esp32', esp32_baud=115200); print(a.get_wifi_ip())"
python3 -m pymycobot.myagvplussocket_serverPC 쪽:
from pymycobot.myagvplussocket import MyAGVPlusSocket
agv = MyAGVPlusSocket("192.168.1.132", 9000) # IP 는 get_wifi_ip() 로 확인한 값
print(agv.get_robot_status())- 서버는 공식 문서에 따르면 통신 모드를 감지해 포트 9000 을 관리합니다. 서버 모듈 이름과 클라이언트 클래스는 공식 문서(6.1.2) 기준이며, 설치한 pymycobot 버전에 실제로 들어 있는지 먼저 확인합니다(확인 필요).
- PC 와 로봇은 같은 네트워크에 있어야 합니다. IP 는 공유기가 바꿀 수 있으므로 매번
get_wifi_ip()로 확인합니다. - 클라이언트는 직렬과 같은 메서드 이름을 쓰므로, 이 차시의 코드를 거의 그대로 원격으로 실행할 수 있습니다. 그만큼 지연과 끊김을 잊기 쉽습니다.
지연이 정지에 주는 영향#
명령이 로봇에 닿는 데 d 초가 걸리면, 그동안 로봇은 원래 속도 v 로 계속 갑니다.
정지 위치 = 정지 결정 위치 + v × (명령 지연 d + 상태 보고 지연) + v² / (2 × 감속도)
───────────── ───────────────────────────────── ──────────────
PC 가 판단한 곳 지연 동안 더 간 거리 제동 거리- 감속도 2.0 m/s² 는 ch04 의 교육용 값입니다. 1.0 m/s 에서 제동 거리는
1.0² / 4 = 0.25 m입니다. - PC 가 카메라 · 위치 보고를 보고 판단한다면, 보고가 PC 에 오는 지연도 더해집니다(왕복).
끊기면 마지막 명령이 계속된다#
move_forward(v) 는 "멈추라는 말이 올 때까지 계속 가라" 는 명령입니다(ch04). 그래서 Wi-Fi 가 끊기면 정지 명령이 영영 도착하지 않고, 로봇은 마지막 명령대로 계속 달립니다. 해결책은 감시를 로봇 쪽에 두는 것입니다.
| 구조 | 끊겼을 때 |
|---|---|
| PC 가 명령만 보냄 | 로봇은 모름 → 계속 주행 |
| PC 가 연결 끊김을 감지 | PC 는 알지만 정지 명령을 보낼 길이 없음 → 계속 주행 |
로봇 쪽 하트비트 감시 (PC 가 100 ms 마다 "살아 있음" 전송, 로봇이 timeout 동안 못 받으면 스스로 stop()) | 로봇이 스스로 멈춤 |
이 감시는 공식 소켓 서버에 들어 있는 기능이 아니라 우리가 설계하는 안전 장치입니다(실물 코드는 아래 "실습 (실물)").
시뮬레이터 6 · 원격 정지와 통신 지연#
PC 가 로봇에 move_forward(v) 를 보내고, 로봇 앞쪽 끝이 정지 결정선(4.5 m) 에 닿은 것을 알면 stop() 을 보냅니다. 6.0 m 에 팔레트(장애물)가 있습니다. 위 띠의 점은 오가는 명령(파랑) · 하트비트(회색) · 위치 보고(주황)입니다. 아래 "예측" 칸은 슬라이더를 움직이는 즉시 공식으로 다시 계산됩니다.
- v = 1.0 m/s, d = 0 ms 로 실행해 정지 위치를 기록합니다. 이제 d = 300 ms 로 올리기 전에 예측: 정지 위치는 몇 cm 밀릴까요? 실행해 확인합니다.
- d = 300 ms 에서 위치 보고도 지연 을 켭니다. 밀림이 두 배가 되는 이유를 위 띠의 주황 점(보고)과 빨강 점(stop)으로 설명해 봅니다.
- 왕복 지연 그대로 v = 1.6 m/s 로 올립니다. 충돌하나요? 충돌하지 않는 최대 속도를 슬라이더로 찾습니다.
- 상황을 2.0 m 지점에서 Wi-Fi 끊김, 감시 없음 으로 실행합니다. 이어서 하트비트 감시 · timeout 300 ms 로 실행합니다. 끊긴 곳에서 얼마나 더 가서 멈추나요?
- set_communication_state(1) 을 끄고 실행합니다. 어떤 메시지가 나오나요?
- 지연 동안 로봇은 원래 속도 그대로 갑니다. 밀리는 거리 =
v × 지연이고, 제동 거리v² / (2a)는 지연과 상관없이 따로 더해집니다. 1.0 m/s · 300 ms 면 30 cm, 왕복이면 60 cm 가 더 밀립니다. - 속도를 올리면 두 항이 함께 커집니다. 지연이 큰 원격 제어일수록 속도 상한을 낮추고 정지 결정선을 멀리 둡니다.
- 끊김에서는 PC 가 무엇을 하든 소용이 없습니다. 멈추는 판단이 로봇 안에 있어야 합니다. 하트비트 감시의 밀림은
v × (d + timeout)정도입니다. timeout 을 너무 짧게 잡으면 Wi-Fi 가 잠깐 흔들릴 때마다 멈추므로, 지연 · 지터를 재어 보고 정합니다. - 실제 Wi-Fi 지연은 환경마다 다릅니다. 실물에서는
ping 로봇IP로 평균 · 최대 지연을 먼저 재어 봅니다.
실습 과제 4#
시뮬레이터 6 의 공식을 코드로 옮겨, 지연 0~500 ms 와 속도 0.5 · 1.0 · 1.6 m/s 에 대한 정지 위치 표를 만들고 충돌(6.0 m 이상)에 X 를 붙입니다. 마지막에 "왕복 지연 300 ms 에서 충돌하지 않는 최대 속도" 를 0.1 m/s 단위로 찾습니다. 예측 먼저: 1.0 m/s · 단방향 300 ms 의 정지 위치는?
LINE, OBSTACLE, DEC = 4.5, 6.0, 2.0
def stop_position(v, d, round_trip=False):
# TODO 1: 지연 합 = d (왕복이면 2d)
# TODO 2: 정지 위치 = LINE + v * 지연합 + v**2 / (2 * DEC)
return LINE
print("지연(ms) " + " ".join("v=%.1f " % v for v in (0.5, 1.0, 1.6)))
for ms in range(0, 501, 100):
cells = []
for v in (0.5, 1.0, 1.6):
p = stop_position(v, ms / 1000)
cells.append("%5.2f m%s" % (p, " X" if p >= OBSTACLE else " "))
print("%5d %s" % (ms, " ".join(cells)))
# TODO 3: 왕복 300 ms 에서 충돌하지 않는 최대 속도 (0.1 ~ 1.6, 0.1 단위)
best = None
print("왕복 300 ms 최대 속도:", best)풀이 코드 보기
LINE, OBSTACLE, DEC = 4.5, 6.0, 2.0
def stop_position(v, d, round_trip=False):
lag = d * (2 if round_trip else 1)
return LINE + v * lag + v ** 2 / (2 * DEC)
print("지연(ms) " + " ".join("v=%.1f " % v for v in (0.5, 1.0, 1.6)))
for ms in range(0, 501, 100):
cells = []
for v in (0.5, 1.0, 1.6):
p = stop_position(v, ms / 1000)
cells.append("%5.2f m%s" % (p, " X" if p >= OBSTACLE else " "))
print("%5d %s" % (ms, " ".join(cells)))
best = None
for i in range(1, 17):
v = i / 10
if stop_position(v, 0.3, round_trip=True) < OBSTACLE:
best = v
print("왕복 300 ms 최대 속도:", best)실행 결과의 핵심: 1.0 m/s 는 지연 0 ms 에서 4.75 m, 300 ms 에서 5.05 m (30 cm 밀림), 1.6 m/s 는 500 ms 에서 6.14 m 로 충돌합니다. 왕복 300 ms 에서 충돌하지 않는 최대 속도는 1.3 m/s (5.70 m) 입니다. 이 값은 시뮬레이터 6 의 예측 칸과 같습니다(시뮬 실행값은 50 ms 보고 주기 · 가속 때문에 몇 cm 다를 수 있습니다).
로봇 안에서 돌 Watchdog 클래스를 만듭니다. PC 의 메시지(명령 · 하트비트)를 받을 때마다 feed(t), 제어 루프가 20 ms 마다 expired(t) 를 물어 True 면 stop() 합니다. 아래 시험은 PC 가 100 ms 마다 하트비트를 보내다가 t = 2.0 s 에 끊기는 상황입니다(지연 50 ms).
class Watchdog:
def __init__(self, timeout):
self.timeout = timeout
self.last = None
def feed(self, t):
# TODO 1: 마지막으로 받은 시각을 기록
pass
def expired(self, t):
# TODO 2: 한 번도 받은 적이 없거나, 마지막 수신 후 timeout 이 지났으면 True
return False
def run(timeout, v=1.0, delay=0.05, drop_at=2.0):
wd = Watchdog(timeout)
arrivals = [k * 0.1 + delay for k in range(0, 200) if k * 0.1 <= drop_at] # 로봇에 도착하는 시각
x, speed, t, i = 0.0, v, 0.0, 0
while t < 10 and speed > 0:
t = round(t + 0.02, 2)
while i < len(arrivals) and arrivals[i] <= t:
wd.feed(arrivals[i]); i += 1
if wd.expired(t):
stop_t = t
speed = 0.0
x += v ** 2 / (2 * 2.0) # 제동 거리
return stop_t, x
x += speed * 0.02
return None, x
for to in (0.2, 0.3, 0.5, 1.0):
stop_t, x = run(to)
print("timeout %.1f s -> 정지 명령 t = %s s, 정지 위치 %.2f m" % (to, stop_t, x))풀이 코드 보기
class Watchdog:
def __init__(self, timeout):
self.timeout = timeout
self.last = None
def feed(self, t):
self.last = t
def expired(self, t):
if self.last is None:
return t > self.timeout # 처음부터 아무것도 안 오면 timeout 뒤 정지
return t - self.last > self.timeout
def run(timeout, v=1.0, delay=0.05, drop_at=2.0):
wd = Watchdog(timeout)
arrivals = [k * 0.1 + delay for k in range(0, 200) if k * 0.1 <= drop_at] # 로봇에 도착하는 시각
x, speed, t, i = 0.0, v, 0.0, 0
while t < 10 and speed > 0:
t = round(t + 0.02, 2)
while i < len(arrivals) and arrivals[i] <= t:
wd.feed(arrivals[i]); i += 1
if wd.expired(t):
stop_t = t
speed = 0.0
x += v ** 2 / (2 * 2.0) # 제동 거리
return stop_t, x
x += speed * 0.02
return None, x
for to in (0.2, 0.3, 0.5, 1.0):
stop_t, x = run(to)
print("timeout %.1f s -> 정지 명령 t = %s s, 정지 위치 %.2f m" % (to, stop_t, x))실행 결과: 마지막 하트비트는 t = 2.0 s 에 보내져 2.05 s 에 도착하므로, timeout 0.3 s 이면 t ≈ 2.36 s 에 스스로 멈춥니다. 끊긴 순간(2.0 m)보다 약 0.6 m(지연 + timeout 동안 0.36 m + 제동 0.25 m) 더 가서 섭니다. starter 는 expired() 가 항상 False 라 10 초 동안 멈추지 않고 10 m 를 갑니다 — 감시가 없는 것과 같습니다.
시뮬레이터 6 에서 v = 1.0 m/s 일 때, 한 방향 지연을 0 ms → 300 ms 로 올리면 정지 위치는 얼마나 밀리나요? (위치 보고는 지연 없음)
- 0 cm — 제동 거리는 지연과 상관없다
- 약 30 cm — 지연 동안 원래 속도로 더 간다
- 약 60 cm
- 약 9 cm — 0.3² 이므로
정답 보기
② — 밀림 = v × d = 1.0 × 0.3 = 0.30 m 이고, 제동 거리 0.25 m 는 그대로 따로 더해집니다. ③ 60 cm 는 위치 보고도 같은 지연을 겪는 왕복일 때입니다.PC 에서 MyAGVPlusSocket 으로 원격 주행 중 Wi-Fi 가 끊겼을 때 로봇이 스스로 멈추게 하는 구조는?
- PC 가 100 ms 마다 하트비트를 보내고, 로봇 쪽 프로그램이 timeout 동안 못 받으면 직접
stop()한다 - PC 가 연결 끊김을 감지하면
stop()을 다시 보낸다 - PC 프로그램에서
try / finally로agv.stop()을 호출한다 - 속도를 1.6 m/s 로 올려 빨리 도착하게 한다
정답 보기
① — 끊긴 뒤에는 PC 가 보내는 어떤 명령도 도착하지 않습니다(②, ③ 은 모두 PC 에서 보내는 방법). 정지 판단이 로봇 안에 있어야 합니다. 시뮬레이터 6 에서 감시 없음은 팔레트까지 계속 달렸습니다.로봇 안에서 python3 move_demo.py 가 직렬 포트를 열어 둔 채로 소켓 서버를 실행했더니 PC 가 제어하지 못했습니다. 가장 알맞은 원인과 조치는?
- 포트 9000 이 막혀 있다 — 방화벽만 끈다
- 직렬 포트는 한 프로그램만 열 수 있다 — 로컬 프로그램을 끝내거나
set_communication_state(1)로 포트를 놓아 준 뒤 서버를 실행한다 - PC 의 IP 가 틀렸다 — PC 에서
get_wifi_ip()를 호출한다 - baud 를 9000 으로 맞춘다
정답 보기
② — 소켓 모드(1)는 물리 직렬 포트를 놓아 주는 설정입니다. 서버가 모터 · ESP32 포트를 열어야 PC 의 명령을 전달할 수 있습니다. 9000 은 TCP 포트 번호이지 baud 가 아닙니다(④). `get_wifi_ip()` 는 로봇의 IP 를 알려 주는 메서드입니다(③).실습 (실물)#
① 상태 · 모터 진단 출력 — 로봇 터미널에서 diag.py 로 저장해 바퀴를 띄운 상태로 실행합니다. 10초 동안 1초마다 한 줄씩 출력합니다.
import time
from pymycobot import MyAGVPlus
agv = MyAGVPlus("/dev/myagvplus_controller", baudrate=921600,
esp32_port="/dev/myagvplus_esp32", esp32_baud=115200, debug=False)
if agv.power_on() != 1:
raise SystemExit("power_on 실패")
agv.set_auto_report_state(1) # 50 ms 자동 보고
def level(v):
return 2 if v < 19.0 else (1 if v <= 19.6 else 0)
try:
t0 = time.perf_counter()
agv.get_all_msg()
print("get_all_msg 응답 시간: %.1f ms" % ((time.perf_counter() - t0) * 1000))
agv.move_forward(0.05) # 바퀴를 띄운 상태에서만
for n in range(10):
time.sleep(1.0)
msg = agv.get_auto_report_message()
tq = agv.get_motor_torques()
tp = agv.get_motor_temps()
stt = agv.get_motor_status()
print("%2d s 주 %.2f V(%d) 보조 %.2f V(%d) 토크 %s 온도 %s 코드 %s"
% (n + 1, msg[4], level(msg[4]), msg[5], level(msg[5]), tq, tp, stt))
finally:
agv.stop()
agv.power_off()② LED 신호와 흡착 펌프 — 펌프에 빈 상자를 대고 실행합니다. 펌프 핀(2 또는 5)은 배선에 맞게 고칩니다.
import time
from pymycobot import MyAGVPlus
PUMP_PIN, PUMP_ON, PUMP_OFF = 2, 0, 1 # 반전 논리: Low = 켬
GREEN, BLUE, YELLOW, RED = (0, 255, 0), (0, 0, 255), (255, 200, 0), (255, 0, 0)
agv = MyAGVPlus("/dev/myagvplus_controller", baudrate=921600,
esp32_port="/dev/myagvplus_esp32", esp32_baud=115200)
agv.power_on()
try:
print("led mode ->", agv.set_led_mode(1))
for c in (GREEN, BLUE, YELLOW):
agv.set_led_color(255, c)
time.sleep(1)
print("pump on ->", agv.set_pump_io(PUMP_PIN, PUMP_ON))
time.sleep(2)
print("pump off ->", agv.set_pump_io(PUMP_PIN, PUMP_OFF))
for _ in range(3): # 오류 신호 시험
agv.set_led_color(255, RED); time.sleep(0.5)
agv.set_led_color(0, RED); time.sleep(0.5)
finally:
agv.set_pump_io(PUMP_PIN, PUMP_OFF)
agv.set_led_mode(0) # 배터리 표시로 되돌림
agv.stop()
agv.power_off()③ 하트비트 감시가 있는 원격 제어 (우리가 만드는 서버) — 공식 소켓 서버 대신, 로봇 안에서 직렬로 제어하면서 PC 의 짧은 문자열 명령을 받는 작은 서버입니다. 감시는 로봇 쪽에 있습니다. 포트 9100 은 공식 서버(9000)와 겹치지 않게 고른 예입니다.
# robot_server.py - 로봇에서 실행: python3 robot_server.py
import socket, threading, time
from pymycobot import MyAGVPlus
TIMEOUT, SAFE_MAX = 0.3, 0.3
agv = MyAGVPlus("/dev/myagvplus_controller", baudrate=921600,
esp32_port="/dev/myagvplus_esp32", esp32_baud=115200)
agv.power_on()
last_rx, moving, lock = time.monotonic(), False, threading.Lock()
def watchdog():
global moving
while True:
time.sleep(0.02)
with lock:
if moving and time.monotonic() - last_rx > TIMEOUT:
agv.stop(); moving = False
print("watchdog: heartbeat lost -> stop")
threading.Thread(target=watchdog, daemon=True).start()
srv = socket.socket(); srv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
srv.bind(("0.0.0.0", 9100)); srv.listen(1)
try:
while True:
conn, addr = srv.accept(); conn.settimeout(TIMEOUT)
print("connected:", addr)
try:
buf = b""
while True:
data = conn.recv(64)
if not data:
break
buf += data
while b"\n" in buf:
line, buf = buf.split(b"\n", 1)
words = line.decode().split()
with lock:
last_rx = time.monotonic()
if words and words[0] == "fwd":
agv.move_forward(max(0.01, min(SAFE_MAX, float(words[1])))); moving = True
elif words and words[0] == "stop":
agv.stop(); moving = False
except (socket.timeout, OSError):
pass
finally:
with lock:
agv.stop(); moving = False
conn.close(); print("disconnected -> stop")
finally:
agv.stop(); agv.power_off()# pc_client.py - PC 에서 실행: 0.2 m/s 로 3초, 100 ms 마다 하트비트
import socket, time
s = socket.create_connection(("192.168.1.132", 9100), timeout=2) # 로봇 IP
s.sendall(b"fwd 0.2\n")
for _ in range(30):
s.sendall(b"hb\n"); time.sleep(0.1)
s.sendall(b"stop\n"); s.close()- 진단 (①): 바퀴를 띄우고 실행해 응답 시간 · 전압 · 토크 · 온도 · 코드를 기록합니다. 손으로 바퀴 하나를 아주 살짝 눌러(장갑, 0.05 m/s 에서만) 토크가 오르는 번호를 찾아 모터 번호표(2교시)를 실물 기준으로 고칩니다.
- LED · 펌프 (②):
set_led_mode(1)줄을 주석 처리하고 한 번 더 실행해 색이 안 바뀌는 것을 확인합니다. 펌프 켬/끔을 귀로 확인하고,PUMP_ON을 1 로 바꾸면 반대로 되는지 봅니다. - 원격 (③): 바퀴를 띄운 상태에서 PC 클라이언트를 실행합니다. 3초 주행 중 PC 의 Wi-Fi 를 끄거나 클라이언트를 Ctrl+C 로 끊고, 바퀴가 0.3 s 안에 서는지 확인합니다.
ping 로봇IP의 평균 · 최대 지연도 기록합니다.
자주 나는 오류와 해결#
1) 전압 칸에 이상한 리스트가 출력됨#
주 배터리: [0.01, -0.02, 9.79, ...] V- 원인:
get_all_msg()의 인덱스를 잘못 썼습니다. 6번은 자이로 원시 데이터 리스트이고, 전압은 4 · 5번입니다. - 해결: 인덱스에 이름을 붙입니다 —
MAIN_V, SUB_V = 4, 5. 7 · 8번(고정밀 전압)은len(msg) > 8일 때만 씁니다.
2) 전압이 충분해 보이는데 이동 명령이 −1#
move_forward -> -1
BACKGROUND VOLTAGE DETECTED!- 원인: 정지 중에 읽은 전압(높게 나옴)만 보았거나, 두 배터리 모두 19.0 V 미만입니다. 또는
STALL DETECTED!잠금이 남아 있습니다. - 해결: 주 · 보조 전압을 둘 다 보고, 주행 중 전압이 더 낮다는 점을 기억합니다(시뮬레이터 2). 모터 코드가 0 이 아니면 2교시 복구 순서를 따릅니다.
3) 자동 보고 값이 바뀌지 않음#
get_auto_report_message() -> 매번 같은 값 (또는 빈 값)- 원인:
set_auto_report_state(1)을 호출하지 않았거나 실패(0 반환)했습니다. - 해결: 반환값을 확인하고
get_auto_report_state()가 1 인지 봅니다. ESP32 포트 · baud(115200)도 ch04 처럼 점검합니다.
4) 오류를 지웠더니 로봇이 갑자기 출발함#
clear_motor_error(2) -> 1
(로봇이 바로 움직이다가 다시) STALL DETECTED!- 원인: 잠기기 전 이동 명령이 남은 상태에서, 원인을 치우지 않고 오류만 지웠습니다(시뮬레이터 3 해 볼 것 2).
- 해결:
stop()→ 원인 제거 →clear_motor_error→get_motor_status()확인 → 저속 재출발 순서를 함수로 만들어 씁니다(실습 과제 2-2).
5) LED 색이 바뀌지 않음#
set_led_color -> 1 (LED 는 그대로 초록)- 원인: LED 가 기본 모드 0(배터리 표시)입니다.
- 해결: 프로그램 시작에서
set_led_mode(1), 끝날 때finally에서set_led_mode(0)으로 되돌립니다.
6) 펌프가 반대로 동작함#
set_pump_io(2, 1) -> 1 (펌프가 꺼짐)- 원인:
set_pump_io는 Low(0) = 켬의 반전 논리입니다. - 해결:
PUMP_ON = 0,PUMP_OFF = 1상수를 만들어 숫자 대신 씁니다.finally에서 반드시PUMP_OFF를 보냅니다. 펌프 핀이 2 인지 5 인지 배선을 확인합니다.
7) get_pin_input 이 −1#
get_pin_input(7) -> -1- 원인: 범위 밖 핀이거나 읽기에 실패했습니다. 문서마다 범위가 0~6 / 1~6 으로 다릅니다.
- 해결: 1~6 으로 시험하고, 0 이 "전체 읽기" 로 동작하는지는 실물에서 확인합니다. 섀시 전원(
power_on)이 켜져 있는지도 봅니다.
8) PC 에서 소켓 연결이 안 됨#
ConnectionRefusedError: [Errno 111] Connection refused
TimeoutError: timed out- 원인: (a) 로봇에서 서버를 실행하지 않음, (b) IP 가 바뀜, (c) 로컬 프로그램이 직렬 포트를 쥐고 있어 서버가 시작하지 못함, (d) 다른 네트워크.
- 해결: 로봇에서
get_wifi_ip()로 IP 를 다시 확인하고, 서버 터미널의 오류 메시지를 봅니다. 다른 직렬 프로그램을 끝내거나set_communication_state(1)로 포트를 놓아 줍니다.ping이 되는지 먼저 확인합니다.
9) Wi-Fi 가 끊겼는데 로봇이 계속 감#
(PC) BrokenPipeError: [Errno 32] Broken pipe
(로봇은 계속 주행)- 원인: 이동 명령은 다음 명령까지 유지되고, 정지 판단이 PC 에만 있습니다.
- 해결: 로봇 쪽 하트비트 감시(실습 과제 4-2, 실물 ③)를 둡니다. 원격 제어 속도 상한을 낮게 둡니다.
과제#
- 배터리 기록기: 실물 ①을 고쳐
get_auto_report_message()를 0.1 s 마다 읽어 CSV(t, 주V, 보조V, 등급)로 저장하세요. 정지 · 0.1 m/s · 0.2 m/s 구간을 번갈아 기록하고, 주행 중과 정지 중 전압 차이를 표로 정리합니다(바퀴를 띄운 상태). - 대시보드 확장: 실습 과제 2-1 의 대시보드에 전압 칸과 "경고 개수" 를 더하고, 경고가 3초 이상 이어지면 LED 를 빨강 깜빡임으로 바꾸는 코드를 시뮬 클래스로 작성하세요.
- 원격 속도 상한표:
ping으로 잰 평균 · 최대 지연으로 실습 과제 4-1 을 다시 계산해, 정지 결정선 1.5 m 앞에서 멈출 수 있는 최대 원격 속도를 정하고 근거를 3줄로 씁니다.
3~4명이 한 팀이 되어 Part 2(ch03 ~ ch05)에서 배운 것을 하나로 묶습니다.
- 목표: 대기 위치 → 피킹 스테이션(흡착 픽업) → 출고 선반(내려놓기) → 복귀를 5회 반복하는 프로그램을 시뮬 클래스로 완성합니다.
- 필수 기능
- 매 사이클 시작 전
get_all_msg()로 배터리 판정 — 경고(등급 1)면 남은 사이클을 멈추고 "충전 필요" 신호(노랑 깜빡임) - 이동은 ch04 의
safe()·checked()·try / finally구조, 측면 이동으로 선반에 접근 - 흡착은 진공 스위치 확인 + 제한 시간, 실패 시 빨강 깜빡임 · 펌프 끔 · 정지
- 사이클마다 모터 대시보드 한 줄(토크 · 온도 · 코드) 기록, 코드가 0 이 아니면 복구 함수 호출
- (선택) PC 원격 시작 · 정지 버튼 + 로봇 쪽 하트비트 감시
- 매 사이클 시작 전
- 역할 예: 이동 · 경로 / 상태 진단 · 대시보드 / LED · IO · 펌프 / 원격 · 안전 감시
- 발표: 5회 반복 로그, 일부러 넣은 고장 1개(흡착 실패 또는 구속)를 프로그램이 어떻게 처리했는지 시연, 실물로 옮길 때 확인해야 할 "가정값" 목록.
참고자료#
- myAGV Plus 공식 문서 (영문): https://github.com/elephantrobotics/myagvPlus_docs/tree/main/MYAGV_PLUS_EN
- 공식 Python API (6.1.2 — 상태 · 모터 · LED · IO · 펌프 · 통신 메서드): https://github.com/elephantrobotics/myagvPlus_docs/blob/main/MYAGV_PLUS_EN/6-Software_Development_Guide/6.1-ApplicationBasePython/6.1.2-API.md
- 공식 예제: RGB 제어(6.1.3) · 이동 제어(6.1.4) · IO 시험(6.1.5): https://github.com/elephantrobotics/myagvPlus_docs/tree/main/MYAGV_PLUS_EN/6-Software_Development_Guide/6.1-ApplicationBasePython
- pymycobot 저장소: https://github.com/elephantrobotics/pymycobot
- myagv_ros2 저장소 (ROS 2 패키지 — ch09 에서 다룸): https://github.com/elephantrobotics/myagv_ros2
- myAGV Plus 제품 사진 · 소개 (hyenc.net): https://www.hyenc.net/products/35
- Python 공식 문서 —
socket(TCP 서버 · 클라이언트, timeout): https://docs.python.org/3/library/socket.html - Python 공식 문서 —
threading: https://docs.python.org/3/library/threading.html - 이 사이트의 도구: URDF 뷰어 · Python Playground
- 이전 차시: ch04 pymycobot MyAGVPlus 로 이동 제어 · 다음 차시: ch06 오도메트리와 센서 융합