CH03메카넘 휠과 전방향 운동학
메카넘 휠의 45° 롤러가 만드는 힘을 관찰하고, 차체 속도 (vx, vy, ω) 와 네 바퀴 속도 사이의 순 · 역기구학을 Python 으로 구현합니다.
학습 목표#
- 메카넘 휠의 45° 롤러가 바닥에 대각선 방향의 힘을 만드는 이유를 설명하고, 네 바퀴 회전 조합으로 전진 · 옆걸음 · 제자리 회전 · 대각선 이동을 예측할 수 있습니다.
- 차체 속도 (vx, vy, ω) 를 네 바퀴 각속도로 바꾸는 역기구학 식을 4×3 행렬로 구현하고, 어느 바퀴가 멈추는지 · 한계를 넘는지 계산할 수 있습니다.
- 바퀴 속도가 한계를 넘을 때 같은 비율로 줄이는(스케일) 방식이 바퀴별로 자르는(클립) 방식보다 경로를 지키는 이유를 시뮬레이터로 확인할 수 있습니다.
- 네 바퀴 속도로 차체 속도를 구하는 순기구학(3×4 의사역행렬)과, 로봇 좌표 속도를 지도 좌표로 돌려 적분하는 위치 갱신을 Python 으로 구현할 수 있습니다.
- 마찰 · 롤러 마모 · 적재 무게중심이 측면 이동 오차를 키우는 원리를 측정하고, 보정 계수를 구해 오차를 줄일 수 있습니다.
이 페이지에는 브라우저에서 바로 동작하는 미니 시뮬레이터 4개가 있습니다. 시뮬레이터마다 먼저 결과를 예측해 적고, 조작해서 확인하세요. 예측이 틀린 곳이 이 차시에서 가장 많이 배우는 곳입니다. 식은 Playground에서 열기 버튼으로 numpy 코드를 바로 실행해 확인합니다. 시뮬레이터에 나온 숫자와 Playground 의 숫자가 같아야 다음으로 넘어갑니다.
바퀴 반지름 r = 0.05 m, 바퀴 위치 lx = 0.085 m (앞뒤 반길이) · ly = 0.135 m (좌우 반폭) 은 ch02 의 교육용 모델 값입니다. myAGV Plus 실물의 정확한 치수 · 펌웨어 내부 계산 방식은 확인 필요이며, 원리는 치수와 상관없이 같습니다.
1교시 · 메카넘 휠은 어떻게 옆으로 갈까?#
롤러 하나가 만드는 대각선 힘#
자동차 바퀴는 굴러가는 방향(앞뒤)으로만 바닥을 밉니다. 옆으로 밀면 고무가 버티기 때문에 차는 옆으로 가지 못합니다. 메카넘 휠(Mecanum wheel) 은 바퀴 둘레에 작은 롤러를 바퀴 축에 대해 45° 로 비스듬히 달아 이 규칙을 바꿉니다.
- 바퀴가 돌면 바닥에 닿은 롤러가 바닥을 밉니다. 그런데 롤러는 자기 축 둘레로는 공짜로 굴러가므로, 그 방향으로는 힘을 전할 수 없습니다.
- 남는 것은 롤러 축 방향의 힘뿐입니다. 그래서 바퀴 하나가 바닥에 주는 힘은 앞뒤가 아니라 대각선(45°) 입니다.
- 바퀴 하나만으로는 대각선으로 미는 것밖에 못 하지만, 롤러 방향이 다른 바퀴 네 개를 섞으면 어느 방향이든 만들 수 있습니다.
위에서 바퀴를 내려다보면 보이는 것은 위쪽 롤러이고, 힘을 만드는 것은 바닥에 닿은 롤러입니다. 둘은 서로 반대쪽으로 기울어 보입니다. 이 차시의 그림과 시뮬레이터는 모두 바닥 롤러를 투시한 방향(= 힘의 방향) 으로 그립니다. 실물 바퀴를 볼 때 위쪽 무늬만 보고 판단하면 방향을 반대로 읽게 됩니다.
네 바퀴의 힘 합성: X 배치#
myAGV Plus 처럼 메카넘 휠 4개를 쓰는 로봇은 롤러 방향이 대각선 위치끼리 같도록 끼웁니다. 위에서 바닥 롤러를 투시하면 네 롤러가 X 자를 이루므로 이 강좌에서는 X 배치라고 부릅니다(왼쪽 바퀴와 오른쪽 바퀴의 롤러가 좌우 대칭).
네 힘을 더하면 차체가 움직이는 방향이, 네 힘이 차체 중심을 돌리려는 정도(돌림힘)를 더하면 회전이 결정됩니다.
| 바퀴 회전 (FL, FR, RL, RR) | 힘의 합 | 돌림힘의 합 | 결과 |
|---|---|---|---|
| (+, +, +, +) | 대각선 성분의 좌우가 상쇄 → 앞 | 0 | 전진 |
| (−, +, +, −) | 앞뒤 성분 상쇄 → 왼쪽 | 0 | 왼쪽 옆걸음 |
| (−, +, −, +) | 0 | 반시계 | 제자리 왼쪽 회전 |
| (+, 0, 0, +) | ? | ? | 시뮬레이터 1 로 확인 |
바퀴의 + 는 "그 바퀴가 로봇을 앞으로 굴리는 쪽" 입니다. 왼쪽 · 오른쪽 바퀴는 모터가 서로 마주 보고 붙어 있어 실제 모터 축 방향은 반대지만, 이 차시는 모두 "앞으로 굴러가는 쪽 = +" 로 통일합니다. 실물 드라이버가 모터 ID 별로 어떤 부호를 쓰는지는 ch04 에서 확인합니다.
시뮬레이터 1 · 휠 연습장#
왼쪽은 창고 바닥(한 칸 0.5 m)이고, 오른쪽은 로봇을 확대해 위가 앞이 되게 그린 그림입니다. 네 바퀴 슬라이더(−1 ~ +1)를 움직이면 바퀴별 힘 화살표(빨강) 와 합성 결과 이동 화살표(파랑) · 회전 화살표(보라) 가 바로 바뀝니다. ▶ 주행을 누르면 로봇이 그 명령대로 움직입니다. u = 1 은 바퀴 둘레 속도 0.5 m/s 입니다(연습장 기준).
- 모두 + 를 누릅니다. 빨간 화살표 네 개는 모두 대각선인데 파란 화살표는 왜 똑바로 앞일까요? 화살표의 옆 성분끼리 짝을 지어 봅니다.
- 결과 가리기를 켜고 FL · RR 만 + 를 누릅니다. 로봇이 어디로 갈지 적은 뒤 가리기를 끄고 ▶ 주행으로 확인합니다.
- 좌우 반대를 누르고 주행합니다. 이동 화살표가 없는데 왜 로봇이 도나요? 네 빨간 화살표가 차체 중심을 어느 쪽으로 돌리려는지 하나씩 봅니다.
- FR 만 + 를 누릅니다. 바퀴 하나만 돌리면 로봇은 대각선으로 갈까요, 곡선으로 갈까요?
- 앞 + · 뒤 − 를 누릅니다. 바퀴는 넷 다 돌고 있는데 로봇은 어떻게 되나요? (이유는 3교시에서 계산합니다.)
- 전진은 FL 의 (+1, −1) 과 FR 의 (+1, +1) 처럼 옆 성분이 서로 지워지고 앞 성분만 남아서 생깁니다. 옆걸음은 반대로 앞 성분이 지워집니다.
- FL · RR 만 + 는 두 바퀴가 같은 앞-오른쪽 힘을 내므로 앞-오른쪽 대각선으로 갑니다. 두 바퀴가 차체 중심에 대해 정반대 위치라 돌림힘은 서로 지워져 회전이 없습니다.
- FR 만 + 는 힘이 하나뿐이라 돌림힘을 지워 줄 짝이 없습니다. 그래서 대각선으로 가면서 돌기 시작해 곡선이 됩니다. "바퀴 하나 = 한 방향" 이 아니라 네 힘의 합과 돌림힘의 합이 움직임을 정합니다.
- 앞 + · 뒤 − 는 힘의 합도 0, 돌림힘의 합도 0 이라 로봇이 움직이지 않습니다. 바퀴끼리 서로 밀어 롤러만 미끄러지고 배터리만 씁니다.
차동 구동과 비교: 옆 칸 주차#
바퀴가 좌우 둘(또는 좌우로 묶인 넷)인 차동 구동(differential drive) 로봇은 바퀴 힘이 모두 앞뒤 방향입니다. 그래서 옆으로 가는 속도 vy 를 만들 수 없습니다. 옆 칸으로 가려면 자동차 주차처럼 "돌기 → 가기 → 다시 돌기"를 여러 번 해야 합니다.
시뮬레이터 1 에서 직접 비교해 봅시다. 로봇 왼쪽 0.8 m 에 선반 사이 주차 칸이 있습니다.
- 메카넘 휠 4개 모드에서 프리셋 하나만 써서 주차 칸에 넣어 봅니다. 명령 변경 횟수는 몇 번인가요? (멈출 때 정지도 한 번으로 셉니다.)
- 차동 구동 모드로 바꾸고 같은 칸에 넣어 봅니다. 방향 차이 10° 이내로 넣으려면 명령을 몇 번 바꿔야 하나요?
- 차동 구동으로 하다가 선반에 닿았다면, 어느 단계에서 닿았나요? 회전할 때 차체 모서리가 그리는 원을 떠올려 봅니다.
차동 구동 로봇은 "지금 당장 옆으로" 움직일 수 없지만, 여러 번 움직이면 결국 옆 칸에 갈 수는 있습니다. 이렇게 순간적으로 갈 수 없는 방향이 있는 로봇을 비홀로노믹(non-holonomic), 메카넘 로봇처럼 평면의 세 방향(x, y, θ)을 동시에 독립적으로 움직일 수 있는 로봇을 전방향(omnidirectional) 또는 홀로노믹 로봇이라 부릅니다. 좁은 선반 통로가 많은 물류 창고에서 myAGV Plus 같은 전방향 로봇이 유리한 이유가 여기에 있습니다.
강좌용 myAGV Plus 모델(assets/robot/robot.json)이 준비되면 바퀴 관절 네 개의 회전축(axis)이 모두 y 축인지, 왼쪽 · 오른쪽 바퀴가 같은 축 방향으로 붙어 있는지 확인해 봅니다. 모델이 아직 없으면 뷰어에 "모델 없음" 안내가 나오므로 ch02 의 URDF 탐색기와 아래 실습 과제로 대신합니다.
실습 과제 1#
바퀴마다 "힘의 방향 × 회전 속도" 를 더해 차체 속도를 구하고, 이동 방향을 말로 출력합니다. 시뮬레이터 1 의 프리셋과 같은 조합을 넣어 결과가 같은지 확인하세요. TODO 세 줄을 채웁니다.
import numpy as np
NAMES = ["FL", "FR", "RL", "RR"]
# 바퀴를 + 로 돌릴 때 바닥에 주는 힘의 방향 (x 앞, y 왼쪽)
DIR = np.array([[1, -1], [1, 1], [1, 1], [1, -1]], dtype=float)
# 바퀴 위치 (m) - 교육용 가정
POS = np.array([[0.085, 0.135], [0.085, -0.135], [-0.085, 0.135], [-0.085, -0.135]])
L = 0.085 + 0.135
VR = 0.5 # u = 1 일 때 바퀴 둘레 속도 (m/s), 시뮬레이터 1 과 같음
def body_velocity(u):
v = np.array(u, dtype=float) * VR
# TODO 1: 힘의 x 성분의 평균 sum(v * DIR[:, 0]) / 4
vx = 0.0
# TODO 2: 힘의 y 성분의 평균
vy = 0.0
# 각 바퀴 힘이 차체 중심을 돌리는 정도 (돌림 팔): px * dy - py * dx -> -L 또는 +L
arm = POS[:, 0] * DIR[:, 1] - POS[:, 1] * DIR[:, 0]
# TODO 3: 돌림힘의 합을 4 * L * L 로 나누면 회전 속도 w
w = 0.0
return vx, vy, w
def direction_word(vx, vy, w):
if abs(vx) < 1e-9 and abs(vy) < 1e-9:
if abs(w) < 1e-9:
return "정지"
return "제자리 회전 (" + ("왼쪽" if w > 0 else "오른쪽") + ")"
ang = np.degrees(np.arctan2(vy, vx))
words = {0: "전진", 45: "앞-왼쪽 대각선", 90: "왼쪽 옆", 135: "뒤-왼쪽 대각선",
180: "후진", -180: "후진", -45: "앞-오른쪽 대각선",
-90: "오른쪽 옆", -135: "뒤-오른쪽 대각선"}
text = "비스듬히 %.0f deg" % ang
for a, wd in words.items():
if abs(ang - a) < 3:
text = wd
if abs(w) > 1e-9:
text += " + " + ("왼쪽" if w > 0 else "오른쪽") + " 회전 (곡선)"
return text
TESTS = [
("모두 +", [1, 1, 1, 1]),
("대각선 쌍 반대", [-1, 1, 1, -1]),
("좌우 반대", [-1, 1, -1, 1]),
("FL, RR 만 +", [1, 0, 0, 1]),
("FR 만 +", [0, 1, 0, 0]),
("앞 +, 뒤 -", [1, 1, -1, -1]),
]
for label, u in TESTS:
vx, vy, w = body_velocity(u)
print(label, u, "-> vx=%+.3f vy=%+.3f w=%+.3f :" % (vx, vy, w), direction_word(vx, vy, w))풀이 코드 보기
import numpy as np
NAMES = ["FL", "FR", "RL", "RR"]
# 바퀴를 + 로 돌릴 때 바닥에 주는 힘의 방향 (x 앞, y 왼쪽)
DIR = np.array([[1, -1], [1, 1], [1, 1], [1, -1]], dtype=float)
# 바퀴 위치 (m) - 교육용 가정
POS = np.array([[0.085, 0.135], [0.085, -0.135], [-0.085, 0.135], [-0.085, -0.135]])
L = 0.085 + 0.135
VR = 0.5 # u = 1 일 때 바퀴 둘레 속도 (m/s), 시뮬레이터 1 과 같음
def body_velocity(u):
v = np.array(u, dtype=float) * VR
vx = np.sum(v * DIR[:, 0]) / 4
vy = np.sum(v * DIR[:, 1]) / 4
# 각 바퀴 힘이 차체 중심을 돌리는 정도 (돌림 팔): px * dy - py * dx -> -L 또는 +L
arm = POS[:, 0] * DIR[:, 1] - POS[:, 1] * DIR[:, 0]
w = np.sum(v * arm) / (4 * L * L)
return vx, vy, w
def direction_word(vx, vy, w):
if abs(vx) < 1e-9 and abs(vy) < 1e-9:
if abs(w) < 1e-9:
return "정지"
return "제자리 회전 (" + ("왼쪽" if w > 0 else "오른쪽") + ")"
ang = np.degrees(np.arctan2(vy, vx))
words = {0: "전진", 45: "앞-왼쪽 대각선", 90: "왼쪽 옆", 135: "뒤-왼쪽 대각선",
180: "후진", -180: "후진", -45: "앞-오른쪽 대각선",
-90: "오른쪽 옆", -135: "뒤-오른쪽 대각선"}
text = "비스듬히 %.0f deg" % ang
for a, wd in words.items():
if abs(ang - a) < 3:
text = wd
if abs(w) > 1e-9:
text += " + " + ("왼쪽" if w > 0 else "오른쪽") + " 회전 (곡선)"
return text
TESTS = [
("모두 +", [1, 1, 1, 1]),
("대각선 쌍 반대", [-1, 1, 1, -1]),
("좌우 반대", [-1, 1, -1, 1]),
("FL, RR 만 +", [1, 0, 0, 1]),
("FR 만 +", [0, 1, 0, 0]),
("앞 +, 뒤 -", [1, 1, -1, -1]),
]
for label, u in TESTS:
vx, vy, w = body_velocity(u)
print(label, u, "-> vx=%+.3f vy=%+.3f w=%+.3f :" % (vx, vy, w), direction_word(vx, vy, w))실행 결과: 모두 + 는 vx = +0.5 (전진), 대각선 쌍 반대는 vy = +0.5 (왼쪽 옆), 좌우 반대는 w = +2.273 rad/s (제자리 왼쪽 회전), FL, RR 만 + 는 vx = +0.25, vy = −0.25 (앞-오른쪽 대각선), FR 만 + 는 앞-왼쪽 대각선 + 왼쪽 회전(w = +0.568), 앞 +, 뒤 − 는 정지입니다. arm 을 출력해 보면 [−0.22, 0.22, −0.22, 0.22] 로, 왼쪽 바퀴(FL · RL)가 + 로 돌면 차체를 시계 방향(−)으로 돌린다는 뜻입니다.
시뮬레이터 1 에서 FL 과 RR 만 +1 로 돌리고 나머지 두 바퀴는 멈췄습니다. 로봇의 움직임은?
- 제자리에서 오른쪽으로 회전한다
- 앞-오른쪽 대각선으로 회전 없이 이동한다
- 앞-왼쪽 대각선으로 이동하며 왼쪽으로 돈다
- 두 바퀴의 힘이 서로 지워져 움직이지 않는다
정답 보기
② — FL · RR 은 둘 다 (+1, −1) 방향, 즉 앞-오른쪽으로 밉니다. 두 바퀴는 차체 중심에 대해 정반대 위치에 있어 돌림힘이 서로 지워지므로 회전 없이 대각선으로 갑니다. ③ 은 FR 하나만 돌렸을 때(짝이 없어 회전이 생김)와 비슷한 모습입니다.시뮬레이터 1 에서 바퀴 넷을 모두 돌렸는데(앞 두 바퀴 +1, 뒤 두 바퀴 −1) 파란 화살표도 보라 화살표도 나타나지 않았습니다. 가장 알맞은 해석은?
- 시뮬레이터 오류이므로 새로고침해야 한다
- 네 힘의 합과 돌림힘의 합이 모두 0 이라 로봇은 제자리에 있고, 바퀴끼리 서로 밀며 롤러가 미끄러진다
- 로봇이 아주 빠르게 회전해서 화살표가 보이지 않는다
- 앞바퀴만 바닥에 닿아 있어 전진한다
정답 보기
② — 바퀴 4개로 움직임 3가지(x, y, θ)를 만들기 때문에 "바퀴는 도는데 차체는 안 움직이는" 조합이 하나 생깁니다. 3교시에서 이 조합을 순기구학 행렬로 다시 찾아봅니다.시뮬레이터 1 의 옆 칸 주차에서 차동 구동 모드는 명령을 여러 번 바꿔야 했습니다. 그 근본 이유는?
- 차동 구동은 바퀴가 2개라 최고 속도가 낮기 때문
- 바퀴 힘이 모두 앞뒤 방향이라 어떤 바퀴 조합으로도 옆 속도 vy 를 만들 수 없기 때문
- 차동 구동은 제자리 회전을 할 수 없기 때문
- 주차 칸이 너무 좁아서 메카넘 로봇도 같은 횟수가 필요하기 때문
정답 보기
② — 차동 구동은 "지금 이 순간" 옆으로 갈 수 없습니다(비홀로노믹). 회전은 가능하므로(③ 틀림) "돌기 → 가기 → 돌기" 로 돌아서 갑니다. 메카넘 로봇은 옆걸음 한 번 + 정지로 끝납니다.2교시 · 역기구학: 원하는 차체 속도 → 바퀴 속도#
기호 정리#
1교시는 "바퀴를 돌리면 어디로 가나"(바퀴 → 차체) 였습니다. 실제 로봇 프로그램은 반대로 "이 방향으로 이 속도로 가고 싶다"(차체 → 바퀴) 에서 출발합니다. 이것이 역기구학(inverse kinematics) 입니다.
| 기호 | 뜻 | 단위 | 이 차시의 값 |
|---|---|---|---|
| vx | 차체 앞뒤 속도 (앞 +) | m/s | 사양 최대 1.6 (ch01) |
| vy | 차체 옆 속도 (왼쪽 +) | m/s | |
| ω | 차체 회전 속도 (위에서 봐서 반시계 +) | rad/s | 사양 최대 7.27 (ch01) |
| r | 바퀴 반지름 | m | 0.05 (교육용 가정) |
| lx | 차체 중심 ~ 바퀴 축의 앞뒤 거리 (반길이) | m | 0.085 (교육용 가정) |
| ly | 차체 중심 ~ 바퀴 접지점의 좌우 거리 (반폭) | m | 0.135 (교육용 가정) |
| w_fl … w_rr | 바퀴 각속도 (앞으로 굴리는 쪽 +) | rad/s | 한계 ±32 (교육용 가정) |
(vx, vy, ω) 는 모두 로봇 기준입니다. 로봇이 지도에서 어느 쪽을 보고 있든 vx 는 "로봇의 앞", vy 는 "로봇의 왼쪽" 입니다. 지도 기준으로 바꾸는 일은 3교시에서 합니다.
역기구학 식과 4×3 행렬#
바퀴 하나의 둘레 속도(r · w)는 세 가지 움직임이 그 바퀴 위치에서 요구하는 속도를 더한 것입니다.
- 전진 vx: 네 바퀴 모두 + 로 같은 만큼 → 모든 식에
+vx - 옆걸음 vy: 대각선 쌍이 반대로 → FL · RR 은
−vy, FR · RL 은+vy - 회전 ω: 왼쪽은 뒤로, 오른쪽은 앞으로 → 왼쪽(FL · RL)
−(lx+ly)ω, 오른쪽(FR · RR)+(lx+ly)ω
w_fl = (vx − vy − (lx+ly)·ω) / r
w_fr = (vx + vy + (lx+ly)·ω) / r
w_rl = (vx + vy − (lx+ly)·ω) / r
w_rr = (vx − vy + (lx+ly)·ω) / r네 식을 한 번에 쓰면 4×3 행렬 하나입니다.
┌ w_fl ┐ ┌ 1 −1 −(lx+ly) ┐ ┌ vx ┐
│ w_fr │ = 1/r · │ 1 1 (lx+ly) │ · │ vy │
│ w_rl │ │ 1 1 −(lx+ly) │ └ ω ┘
└ w_rr ┘ └ 1 −1 (lx+ly) ┘제자리 회전에서 바퀴 접지점은 차체 중심 둘레의 원을 따라 움직입니다. 그런데 메카넘 바퀴는 롤러 방향(45°) 으로만 힘을 전하므로, 원의 접선 속도를 롤러 방향으로 나눠 보면 앞뒤 성분이 lx·ω 와 ly·ω 의 합이 됩니다. 그래서 바퀴가 차체 중심에서 앞뒤 · 좌우로 멀수록 같은 ω 에 바퀴가 더 빨리 돌아야 합니다.
ch01 의 사양표에서 최고 직선 속도는 1.6 m/s, 최고 회전 속도는 7.27 rad/s 였습니다. 1.6 ÷ 7.27 ≈ 0.22 입니다. 제자리 회전에서 바퀴 둘레 속도는 (lx+ly)·ω 이므로, "바퀴 둘레 속도 한계 1.6 m/s 를 회전에 모두 쓰면 ω = 1.6 / (lx+ly)" 라고 보면 lx + ly ≈ 0.22 m 가 됩니다. 이 차시의 교육용 치수(0.085 + 0.135)는 이 관계에 맞춘 값입니다. 실제 펌웨어가 이렇게 한계를 정하는지는 확인 필요입니다.
시뮬레이터 2 · 역기구학 계산기와 바퀴 포화#
슬라이더로 원하는 (vx, vy, ω) 를 정하면 왼쪽에 네 바퀴 각속도 막대가, 오른쪽에 2초 동안의 궤적이 그려집니다. 빨간 점선은 바퀴 각속도 한계 ±32 rad/s (둘레 속도 1.6 m/s) 입니다. 궤적은 세 가지를 겹쳐 그립니다: 이상(한계 무시, 회색 점선) · 바퀴별 자르기(빨강) · 같은 비율로 줄이기(초록).
- 바퀴 값 가리기를 켭니다. vx = 0.5, vy = 0.5, ω = 0 에서 멈추는 바퀴는 어느 것일까요? 식으로 계산해 적은 뒤 가리기를 끕니다.
- 최대 회전 7.27 을 누릅니다. 네 바퀴의 크기는 얼마이고 한계선과 어떤 관계인가요? 위의 "사양표 검산" 팁과 비교합니다.
- 포화 예제 A (vx = 1.4, vy = 0.6) 를 누릅니다. 어느 바퀴가 한계를 넘나요? 표에서 세 방식의 진행 방향(°) 을 비교합니다. 명령한 방향은 atan(0.6/1.4) ≈ 23.2° 입니다.
- 포화 예제 B (vx = 1.0, vy = 0.6, ω = 2.0) 를 누르고 막대 표시를 바꿔 봅니다. 빨강 · 초록 궤적 중 회색 점선(이상 궤적)과 같은 모양을 그리는 것은 어느 쪽인가요? 표의 회전 반경으로 확인합니다.
- ω 만 조금씩 올려 가며 어느 순간 처음으로 한계를 넘는지 찾습니다. 그때 한계를 넘는 바퀴는 왼쪽인가요, 오른쪽인가요? vy 를 바꾸면 그 바퀴가 바뀌나요?
- vx = vy = 0.5 에서는
vx − vy = 0이므로 FL 과 RR 이 멈추고, FR · RL 만 20 rad/s 로 돕니다. 1교시의 "FL · RR 만 + → 앞-오른쪽" 과 짝을 이루는 결과입니다: 앞-왼쪽 대각선은 FR · RL 이 만듭니다. - 최대 회전 7.27 rad/s 는 네 바퀴가 모두 ±32 rad/s, 즉 한계에 딱 닿습니다. 회전과 직진을 동시에 최대로 낼 수는 없습니다.
- 포화 예제 A 에서 바퀴별로 자르면 FR · RL 만 40 → 32 로 깎이고 FL · RR(16) 은 그대로라 방향이 23.2° → 18.4° 로 틀어집니다. 같은 비율(× 0.8)로 줄이면 속도만 줄고 방향은 23.2° 그대로입니다.
- 포화 예제 B 에서 자르기는 직선 속도보다 회전을 더 많이 깎아 회전 반경이 커집니다(곡선이 펴짐). 같은 비율로 줄이면 회전 반경이 이상과 같아 궤적이 같은 원 위를 더 짧게 따라갑니다.
포화(saturation): 왜 같은 비율로 줄여야 할까?#
모터에는 최고 속도가 있습니다. 역기구학으로 계산한 바퀴 속도 중 하나라도 한계를 넘으면 무엇인가 줄여야 합니다.
| 방식 | 하는 일 | 결과 |
|---|---|---|
| 바퀴별 자르기 (clip) | 넘은 바퀴만 한계값으로 바꿈 | 네 바퀴 비율이 깨져 진행 방향 · 회전 반경이 바뀜 → 경로를 벗어남 |
| 같은 비율로 줄이기 (scale) | 가장 큰 바퀴가 한계에 닿도록 네 바퀴에 같은 계수 k 를 곱함 | (vx, vy, ω) 가 모두 k 배 → 방향과 경로 모양은 그대로, 속도만 느려짐 |
역기구학 식은 선형이라서 네 바퀴에 같은 k 를 곱하면 (vx, vy, ω) 에도 똑같이 k 가 곱해집니다. 그래서 경로 모양(방향, vx : vy : ω 의 비)이 유지됩니다. 좁은 선반 통로에서 방향이 몇 도만 틀어져도 선반에 닿을 수 있으므로, 물류 로봇은 "느리더라도 정확한 방향" 을 택합니다.
이 강좌의 Playground 에는 시뮬레이터 타깃(시뮬레이터로 명령을 보내는 연결)이 있지만, 강좌 전용 시뮬레이터 창(sim/)이 준비되기 전까지는 "찾을 수 없음" 으로 표시됩니다. 이 차시에서는 Playground 의 출력 숫자와 이 페이지 시뮬레이터의 표 · 궤적을 비교하는 방식으로 확인합니다.
실습 과제 2#
4×3 행렬 J 를 완성해 여러 명령의 바퀴 속도를 구하고, 멈추는 바퀴를 찾습니다. 첫 줄(FL)은 채워 두었습니다.
import numpy as np
r = 0.05 # 바퀴 반지름 (m) - 교육용 가정
lx, ly = 0.085, 0.135 # 앞뒤 반길이, 좌우 반폭 (m) - 교육용 가정
L = lx + ly
# [w_fl, w_fr, w_rl, w_rr] = J @ [vx, vy, w]
J = np.array([
[1, -1, -L], # FL
[0, 0, 0], # TODO: FR
[0, 0, 0], # TODO: RL
[0, 0, 0], # TODO: RR
]) / r
def ik(vx, vy, w):
return J @ np.array([vx, vy, w])
NAMES = ["FL", "FR", "RL", "RR"]
CASES = [(0.5, 0, 0), (0, 0.5, 0), (0, 0, 1.0), (0.5, 0.5, 0), (1.6, 0, 0), (0, 0, 7.27)]
for vx, vy, w in CASES:
q = ik(vx, vy, w)
stopped = [n for n, a in zip(NAMES, q) if abs(a) < 1e-9]
print("(%.2f, %.2f, %.2f) -> %s rad/s, 멈춘 바퀴: %s"
% (vx, vy, w, np.round(q, 2), ", ".join(stopped) if stopped else "없음"))
print("둘레 속도 (m/s) = r * w, 1.6 m/s 전진:", np.round(ik(1.6, 0, 0) * r, 3))풀이 코드 보기
import numpy as np
r = 0.05 # 바퀴 반지름 (m) - 교육용 가정
lx, ly = 0.085, 0.135 # 앞뒤 반길이, 좌우 반폭 (m) - 교육용 가정
L = lx + ly
# [w_fl, w_fr, w_rl, w_rr] = J @ [vx, vy, w]
J = np.array([
[1, -1, -L], # FL
[1, 1, L], # FR
[1, 1, -L], # RL
[1, -1, L], # RR
]) / r
def ik(vx, vy, w):
return J @ np.array([vx, vy, w])
NAMES = ["FL", "FR", "RL", "RR"]
CASES = [(0.5, 0, 0), (0, 0.5, 0), (0, 0, 1.0), (0.5, 0.5, 0), (1.6, 0, 0), (0, 0, 7.27)]
for vx, vy, w in CASES:
q = ik(vx, vy, w)
stopped = [n for n, a in zip(NAMES, q) if abs(a) < 1e-9]
print("(%.2f, %.2f, %.2f) -> %s rad/s, 멈춘 바퀴: %s"
% (vx, vy, w, np.round(q, 2), ", ".join(stopped) if stopped else "없음"))
print("둘레 속도 (m/s) = r * w, 1.6 m/s 전진:", np.round(ik(1.6, 0, 0) * r, 3))실행 결과: 전진 0.5 m/s 는 네 바퀴 모두 10 rad/s, 왼쪽 0.5 m/s 는 [−10, 10, 10, −10], 회전 1 rad/s 는 [−4.4, 4.4, −4.4, 4.4] 입니다. (0.5, 0.5, 0) 에서는 FL · RR 이 멈추고 FR · RL 이 20 rad/s 입니다. 1.6 m/s 전진은 32 rad/s (둘레 1.6 m/s), 7.27 rad/s 회전은 약 ±31.99 rad/s 로 둘 다 한계에 닿습니다.
시뮬레이터 2 의 포화 예제 A · B 를 코드로 재현합니다. scale_all() 의 TODO 를 채우고, 세 방식의 실제 차체 속도 · 진행 방향 · 회전 반경을 비교하세요. 순기구학 FK 는 3교시 내용을 미리 빌려 씁니다.
import numpy as np
r, L = 0.05, 0.22
W_MAX = 32.0 # 바퀴 각속도 한계 (rad/s) - 교육용 가정
J = np.array([[1, -1, -L], [1, 1, L], [1, 1, -L], [1, -1, L]]) / r
FK = np.linalg.pinv(J) # 바퀴 속도 -> 차체 속도 (3교시)
def clip_each(q):
return np.clip(q, -W_MAX, W_MAX)
def scale_all(q):
m = np.max(np.abs(q))
# TODO: m 이 W_MAX 이하면 q 그대로, 넘으면 네 바퀴에 같은 계수 W_MAX / m 을 곱해 반환
return q
def describe(b):
vx, vy, w = b
v = np.hypot(vx, vy)
radius = v / abs(w) if abs(w) > 1e-9 else float("inf")
return "vx=%.3f vy=%.3f w=%.3f | 방향 %.1f deg, 회전반경 %.3f m" % (
vx, vy, w, np.degrees(np.arctan2(vy, vx)), radius)
for cmd in [(1.4, 0.6, 0.0), (1.0, 0.6, 2.0)]:
q = J @ np.array(cmd)
print("명령", cmd, "-> 바퀴", np.round(q, 1), "최대", round(float(np.max(np.abs(q))), 1))
for name, qq in [("이상", q), ("자르기", clip_each(q)), ("같은비율", scale_all(q))]:
print(" ", name, np.round(qq, 1), describe(FK @ qq))풀이 코드 보기
import numpy as np
r, L = 0.05, 0.22
W_MAX = 32.0 # 바퀴 각속도 한계 (rad/s) - 교육용 가정
J = np.array([[1, -1, -L], [1, 1, L], [1, 1, -L], [1, -1, L]]) / r
FK = np.linalg.pinv(J) # 바퀴 속도 -> 차체 속도 (3교시)
def clip_each(q):
return np.clip(q, -W_MAX, W_MAX)
def scale_all(q):
m = np.max(np.abs(q))
if m <= W_MAX:
return q
return q * (W_MAX / m)
def describe(b):
vx, vy, w = b
v = np.hypot(vx, vy)
radius = v / abs(w) if abs(w) > 1e-9 else float("inf")
return "vx=%.3f vy=%.3f w=%.3f | 방향 %.1f deg, 회전반경 %.3f m" % (
vx, vy, w, np.degrees(np.arctan2(vy, vx)), radius)
for cmd in [(1.4, 0.6, 0.0), (1.0, 0.6, 2.0)]:
q = J @ np.array(cmd)
print("명령", cmd, "-> 바퀴", np.round(q, 1), "최대", round(float(np.max(np.abs(q))), 1))
for name, qq in [("이상", q), ("자르기", clip_each(q)), ("같은비율", scale_all(q))]:
print(" ", name, np.round(qq, 1), describe(FK @ qq))실행 결과(요약):
| 명령 | 방식 | 방향 | 회전 반경 |
|---|---|---|---|
| A (1.4, 0.6, 0) | 이상 | 23.2° | 직선 |
| 자르기 | 18.4° | 직선 | |
| 같은 비율 (× 0.8) | 23.2° | 직선 | |
| B (1.0, 0.6, 2.0) | 이상 | 31.0° | 0.583 m |
| 자르기 | 28.8° | 0.677 m | |
| 같은 비율 (× 0.784) | 31.0° | 0.583 m |
자르기는 A 에서 방향을, B 에서 곡선의 크기를 바꿉니다. 같은 비율로 줄이면 두 경우 모두 이상 경로와 모양이 같습니다.
vx = 0.5 m/s, vy = 0.5 m/s, ω = 0 을 명령했습니다. 역기구학으로 계산했을 때 멈추는 바퀴는?
- FL 과 FR (앞바퀴)
- FL 과 RR
- FR 과 RL
- 멈추는 바퀴는 없고 네 바퀴가 모두 10 rad/s 로 돈다
정답 보기
② — w_fl = (vx − vy)/r = 0, w_rr = (vx − vy)/r = 0 입니다. FR · RL 은 (vx + vy)/r = 20 rad/s 로 앞-왼쪽 대각선 힘을 만듭니다. 1교시의 "FL · RR 만 + → 앞-오른쪽" 과 대칭인 결과입니다.시뮬레이터 2 의 포화 예제 B (vx = 1.0, vy = 0.6, ω = 2.0) 에서 세 궤적을 비교했습니다. 옳은 설명은?
- 자르기 궤적이 이상 궤적과 같은 원 위를 지나고, 같은 비율 궤적은 더 크게 휜다
- 같은 비율 궤적은 이상 궤적과 같은 원 위를 더 짧게 지나고, 자르기 궤적은 회전 반경이 커져 바깥으로 벗어난다
- 세 궤적이 모두 같다. 한계는 속도에만 영향을 준다
- 자르기 궤적은 회전이 사라져 직선이 된다
정답 보기
② — 같은 비율로 줄이면 (vx, vy, ω) 가 모두 0.784 배가 되어 회전 반경(v/ω)이 0.583 m 로 그대로입니다. 자르기는 FR 한 바퀴만 깎아 ω 가 직선 속도보다 더 많이 줄어(ω × 0.75, 직선 속도 × 0.87) 반경이 0.677 m 로 커집니다. 회전이 완전히 사라지지는 않습니다(④ 틀림).교육용 치수(lx + ly = 0.22 m, r = 0.05 m, 바퀴 한계 32 rad/s)에서 vx = 1.0 m/s 로 직진하면서 동시에 회전하려고 합니다. 어느 바퀴도 한계를 넘지 않는 최대 |ω| 는 약 얼마인가요? (vy = 0)
- 1.0 rad/s
- 2.7 rad/s
- 4.5 rad/s
- 7.27 rad/s
정답 보기
② — 가장 빠른 바퀴는 (vx + 0.22·|ω|)/0.05 ≤ 32 이어야 하므로 0.22·|ω| ≤ 0.6, |ω| ≤ 2.73 rad/s 입니다. 시뮬레이터 2 에서 vx = 1.0 으로 두고 ω 를 올려 확인해 보세요. 직선 속도를 쓸수록 회전에 남는 여유가 줄어듭니다.3교시 · 순기구학: 바퀴 속도 → 차체 이동#
3×4 행렬과 의사역행렬#
순기구학(forward kinematics) 은 반대 방향입니다. 엔코더로 잰 네 바퀴 속도로 차체가 실제로 어떻게 움직였는지 구합니다. 1교시의 "힘의 합 · 돌림힘의 합" 을 식으로 쓴 것입니다.
vx = r/4 · ( w_fl + w_fr + w_rl + w_rr) ← 네 바퀴의 평균 (합)
vy = r/4 · (−w_fl + w_fr + w_rl − w_rr) ← 대각선 쌍의 차
ω = r/(4(lx+ly)) · (−w_fl + w_fr − w_rl + w_rr) ← 오른쪽 − 왼쪽행렬로 쓰면 3×4 입니다. 역기구학 J 는 4×3 이라 보통의 역행렬(정사각 행렬에만 있음)이 없습니다. 대신 의사역행렬(pseudo-inverse) np.linalg.pinv(J) 를 쓰면 위의 3×4 행렬이 그대로 나옵니다.
- 식은 4개, 미지수(vx, vy, ω)는 3개입니다. 네 바퀴 값이 서로 딱 맞지 않을 때(엔코더 잡음, 미끄러짐) 의사역행렬은 가장 그럴듯한(최소제곱) 차체 속도를 줍니다.
- 반대로 차체 속도로 바꿨을 때 0 이 되는 바퀴 조합이 하나 있습니다: (+1, +1, −1, −1), 앞바퀴와 뒷바퀴가 서로 싸우는 조합입니다(1교시 해 볼 것 5). 이 조합은 차체를 움직이지 않고 롤러만 닳게 합니다.
로봇 좌표 → 지도 좌표 적분#
순기구학으로 얻은 (vx, vy, ω) 는 로봇 기준입니다. 지도 위의 위치 (x, y, θ) 를 구하려면 Δt 마다 로봇 기준 속도를 현재 방향 θ 만큼 돌려서 더해야 합니다(ch02 의 회전 행렬과 같은 계산).
x += (vx·cosθ − vy·sinθ)·Δt
y += (vx·sinθ + vy·cosθ)·Δt
θ += ω·Δt이 식을 빠뜨리고 x += vx·Δt, y += vy·Δt 로 쓰면 로봇이 돌고 있다는 사실을 무시하게 됩니다. 이 실수는 오류 메시지가 없어서 찾기 어렵습니다. 시뮬레이터 3 에서 차이를 직접 봅시다.
시뮬레이터 3 · 궤적 적분기#
일정한 (vx, vy, ω) 를 T 초 동안 줄 때의 지도 위 궤적입니다. 로봇은 원점에서 지도 X 쪽(오른쪽) 을 보고 출발합니다. 파란 선은 Δt 마다 적분한 궤적(1초마다 로봇 표시), 회색 가는 선은 정확한 해, 빨간 점선은 좌표 변환을 빠뜨린 코드의 궤적입니다.
- 궤적 가리기를 켜고 vy 0.3 · ω 0.5 · 5 s 를 누릅니다. 궤적이 직선 · 원호 · 나선 중 무엇일지 적고, 가리기를 끄고 ▶ 재생으로 확인합니다.
- 같은 설정에서 좌표 변환 빠뜨린 코드를 켭니다. 빨간 로봇은 어디에 도착하나요? 빨간 로봇의 방향과 위치는 서로 맞나요?
- vy 0.3 · ω 0.5 · 15 s 를 누릅니다. 시간을 세 배로 늘리면 나선처럼 퍼져 나가나요, 같은 원을 다시 도나요?
- vx 0.3 · ω 0.5 와 vy 0.3 · ω 0.5 를 번갈아 누릅니다. 원의 크기는 같은데 무엇이 다른가요? 각 원에서 로봇의 "앞" 은 원의 어느 쪽을 보고 있나요?
- Δt 를 0.01 → 0.5 → 1.0 s 로 키우며 끝 위치 차이(cm)를 기록합니다. Δt 가 커지면 파란 점들은 회색 정확한 해의 안쪽 · 바깥쪽 중 어디로 벗어나나요?
- vy = 0.3, ω = 0.5 를 5초 주면 반지름 0.6 m (= 0.3 / 0.5) 원의 143° 원호를 그리고 (−1.08, 0.36) 근처에 도착합니다. 로봇 기준으로는 늘 "왼쪽" 으로 가지만, 몸이 계속 돌아서 지도 위의 "왼쪽" 이 바뀌기 때문입니다.
- 일정한 (vx, vy, ω) 는 반지름 √(vx²+vy²)/|ω| 인 원만 만듭니다. 시간을 늘려도 나선이 되지 않고 같은 원을 다시 돕니다. 나선을 만들려면 속도나 ω 를 시간에 따라 바꿔야 합니다.
- 변환을 빠뜨린 코드는 (0, 1.5) 로 직선을 갑니다. 화면 속 로봇은 143° 돌아 있는데 위치는 회전하지 않은 것처럼 계산되어, 방향과 위치가 서로 맞지 않습니다.
- vx 로 도는 원에서는 로봇의 앞이 원의 접선(진행 방향)을 보고, vy 로 도는 원에서는 앞이 원의 바깥을 봅니다. 메카넘 로봇은 "어디로 가는지" 와 "어디를 보는지" 를 따로 정할 수 있습니다.
- Δt 가 크면 한 단계 동안 방향을 고정한 채 직선으로 가므로 파란 점이 원의 바깥쪽으로 조금씩 벗어납니다. 그래서 오도메트리는 짧은 주기로 갱신합니다(ch06).
회전하면서 옆으로: 왜 원호가 될까?#
로봇 기준 속도 (0, vy) 는 일정한데, θ 가 ω 로 일정하게 돌면 지도 위 속도 방향도 일정한 빠르기로 돕니다. 크기는 일정하고 방향만 일정하게 도는 속도로 움직이면 원을 그립니다. 반지름은 "속도 ÷ 도는 빠르기" = vy / ω 입니다.
선반 앞에서 "옆으로 붙으면서 방향도 맞추자" 고 vy 와 ω 를 동시에 주면 직선으로 붙지 않고 원호를 그립니다. 원하는 경로가 직선이라면, 지도 기준 목표 속도를 매 순간 로봇 기준으로 역회전해서 (vx, vy) 를 다시 계산해야 합니다. 이 계산은 ch08 의 경로 추종에서 다시 씁니다.
실습 과제 3#
손으로 쓴 3×4 순기구학 행렬이 np.linalg.pinv(J) 와 같은지 확인하고, 바퀴끼리 싸우는 조합과 잡음 섞인 엔코더 값을 넣어 봅니다. TODO 두 줄을 채웁니다.
import numpy as np
r, L = 0.05, 0.22
J = np.array([[1, -1, -L], [1, 1, L], [1, 1, -L], [1, -1, L]]) / r # 역기구학 4x3
FK_hand = (r / 4) * np.array([
[1, 1, 1, 1], # vx: 네 바퀴의 합
[0, 0, 0, 0], # TODO: vy - 대각선 쌍의 차 (-fl + fr + rl - rr)
[0, 0, 0, 0], # TODO: w - (오른쪽 - 왼쪽) / L
])
FK_pinv = np.linalg.pinv(J)
print("pinv(J) =")
print(np.round(FK_pinv, 4))
print("손으로 쓴 행렬과 같은가?", np.allclose(FK_pinv, FK_hand))
print("FK @ J (3x3) =")
print(np.round(FK_hand @ J, 6))
fight = np.array([1, 1, -1, -1]) * 10.0
print("앞 +10, 뒤 -10 ->", np.round(FK_hand @ fight, 6))
measured = np.array([-8.3, 8.1, 3.9, -3.7]) # 잡음 섞인 엔코더 값 (rad/s)
b = FK_hand @ measured
print("측정 -> vx=%.3f vy=%.3f w=%.3f" % tuple(b))
print("이 차체 속도를 다시 바퀴로 ->", np.round(J @ b, 2), "(측정값과의 차이가 잡음)")풀이 코드 보기
import numpy as np
r, L = 0.05, 0.22
J = np.array([[1, -1, -L], [1, 1, L], [1, 1, -L], [1, -1, L]]) / r # 역기구학 4x3
FK_hand = (r / 4) * np.array([
[1, 1, 1, 1], # vx: 네 바퀴의 합
[-1, 1, 1, -1], # vy: 대각선 쌍의 차
[-1 / L, 1 / L, -1 / L, 1 / L], # w: (오른쪽 - 왼쪽) / L
])
FK_pinv = np.linalg.pinv(J)
print("pinv(J) =")
print(np.round(FK_pinv, 4))
print("손으로 쓴 행렬과 같은가?", np.allclose(FK_pinv, FK_hand))
print("FK @ J (3x3) =")
print(np.round(FK_hand @ J, 6))
fight = np.array([1, 1, -1, -1]) * 10.0
print("앞 +10, 뒤 -10 ->", np.round(FK_hand @ fight, 6))
measured = np.array([-8.3, 8.1, 3.9, -3.7]) # 잡음 섞인 엔코더 값 (rad/s)
b = FK_hand @ measured
print("측정 -> vx=%.3f vy=%.3f w=%.3f" % tuple(b))
print("이 차체 속도를 다시 바퀴로 ->", np.round(J @ b, 2), "(측정값과의 차이가 잡음)")실행 결과: 두 행렬이 같고(True), FK @ J 는 3×3 단위 행렬입니다(차체 → 바퀴 → 차체 는 제자리). 앞 +10 · 뒤 −10 은 (0, 0, 0) 으로 차체가 움직이지 않습니다. 측정값은 vx = 0.000, vy = 0.300, w = 0.500 으로 "vy 0.3 · ω 0.5" 명령과 같습니다. 다시 바퀴로 바꾸면 [−8.2, 8.2, 3.8, −3.8] 로 다듬어집니다. 측정값과의 차이 [−0.1, −0.1, +0.1, +0.1] 은 정확히 바퀴끼리 싸우는 조합 (1, 1, −1, −1) 의 −0.1 배라서 차체 속도에는 아무 영향이 없습니다. 잡음 중 이 성분은 순기구학이 걸러 냅니다.
바퀴 각속도 시퀀스 [(지속 시간, [fl, fr, rl, rr]), ...] 를 받아 1초마다 지도 좌표를 출력합니다. TODO 를 채우기 전에는 좌표 변환을 빠뜨린 코드로 동작합니다. 먼저 그대로 실행해 결과를 적고, 고친 뒤 시뮬레이터 3 의 값과 비교하세요.
import numpy as np
r, L = 0.05, 0.22
FK = (r / 4) * np.array([[1, 1, 1, 1], [-1, 1, 1, -1], [-1 / L, 1 / L, -1 / L, 1 / L]])
def run(seq, dt=0.01):
x = y = th = 0.0
t = 0.0
print(" t=0.0s x=+0.000 y=+0.000 th=+0.0deg")
for dur, wheels in seq:
vx, vy, w = FK @ np.array(wheels, dtype=float)
for _ in range(int(round(dur / dt))):
# TODO: 로봇 기준 속도를 지도 기준으로 돌리세요 (c, s = cos(th), sin(th))
c, s = 1.0, 0.0
x += (vx * c - vy * s) * dt
y += (vx * s + vy * c) * dt
th += w * dt
t += dt
if abs(t - round(t)) < 1e-6:
print(" t=%.1fs x=%+.3f y=%+.3f th=%+.1fdeg" % (t, x, y, np.degrees(th)))
return x, y, th
print("A) vy=0.3, w=0.5 를 5초 (바퀴 [-8.2, 8.2, 3.8, -3.8])")
run([(5.0, [-8.2, 8.2, 3.8, -3.8])])
vy, w, T = 0.3, 0.5, 5.0
print(" 정확한 끝 위치: x=%+.3f y=%+.3f" % (vy * (np.cos(w * T) - 1) / w, vy * np.sin(w * T) / w))
print("B) 정사각형: 앞 1초, 왼쪽 1초, 뒤 1초, 오른쪽 1초 (0.5 m/s)")
run([(1.0, [10, 10, 10, 10]), (1.0, [-10, 10, 10, -10]),
(1.0, [-10, -10, -10, -10]), (1.0, [10, -10, -10, 10])])풀이 코드 보기
import numpy as np
r, L = 0.05, 0.22
FK = (r / 4) * np.array([[1, 1, 1, 1], [-1, 1, 1, -1], [-1 / L, 1 / L, -1 / L, 1 / L]])
def run(seq, dt=0.01):
x = y = th = 0.0
t = 0.0
print(" t=0.0s x=+0.000 y=+0.000 th=+0.0deg")
for dur, wheels in seq:
vx, vy, w = FK @ np.array(wheels, dtype=float)
for _ in range(int(round(dur / dt))):
c, s = np.cos(th), np.sin(th)
x += (vx * c - vy * s) * dt
y += (vx * s + vy * c) * dt
th += w * dt
t += dt
if abs(t - round(t)) < 1e-6:
print(" t=%.1fs x=%+.3f y=%+.3f th=%+.1fdeg" % (t, x, y, np.degrees(th)))
return x, y, th
print("A) vy=0.3, w=0.5 를 5초 (바퀴 [-8.2, 8.2, 3.8, -3.8])")
run([(5.0, [-8.2, 8.2, 3.8, -3.8])])
vy, w, T = 0.3, 0.5, 5.0
print(" 정확한 끝 위치: x=%+.3f y=%+.3f" % (vy * (np.cos(w * T) - 1) / w, vy * np.sin(w * T) / w))
print("B) 정사각형: 앞 1초, 왼쪽 1초, 뒤 1초, 오른쪽 1초 (0.5 m/s)")
run([(1.0, [10, 10, 10, 10]), (1.0, [-10, 10, 10, -10]),
(1.0, [-10, -10, -10, -10]), (1.0, [10, -10, -10, 10])])실행 결과: 고치기 전 A 는 1초마다 y 만 0.3 씩 늘어 (0, 1.5) 에 도착하고 θ 만 143.2° 로 돕니다(시뮬레이터 3 의 빨간 점선). 고친 뒤에는 (−1.08, 0.36) 근처, 정확한 해 (−1.081, +0.359) 와 1 cm 이내로 맞습니다. B 는 ω = 0 이라 θ = 0 이 유지되므로 고치기 전후 결과가 같고, (0.5, 0) → (0.5, 0.5) → (0, 0.5) → (0, 0) 의 정사각형을 그립니다. 회전이 없는 시험만 하면 이 버그를 못 찾는다는 점을 기억하세요.
vy = 0.3 m/s, ω = 0.5 rad/s 를 5초 동안 줍니다(vx = 0). 지도 위 궤적의 모양은?
- 왼쪽으로 1.5 m 뻗은 직선
- 반지름 0.6 m 원의 일부(약 143°)인 원호
- 점점 넓어지는 나선
- 제자리 회전 (위치는 그대로)
정답 보기
② — 로봇 기준 속도의 크기(0.3)와 회전 빠르기(0.5)가 모두 일정하므로 반지름 0.3/0.5 = 0.6 m 인 원 위를 움직입니다. 5초 동안 0.5 × 5 = 2.5 rad ≈ 143° 를 돕니다. 시간을 늘려도 같은 원을 다시 돌 뿐 나선이 되지 않습니다(해 볼 것 3). ① 은 좌표 변환을 빠뜨린 코드의 결과입니다.위치 갱신을 아래처럼 쓴 코드에 vy = 0.3, ω = 0.5 를 5초 주었습니다. 출력되는 끝 자세는?
x += vx * dt
y += vy * dt
th += w * dt- x = −1.08, y = 0.36, θ = 143°
- x = 0, y = 1.5, θ = 143°
- x = 0, y = 1.5, θ = 0°
- x = 0, y = 0, θ = 143°
정답 보기
② — θ 는 따로 적분되므로 143° 로 바뀌지만, 위치는 θ 를 쓰지 않아 직선으로 1.5 m 갑니다. 방향과 위치가 서로 맞지 않는 이 상태가 RViz 에서 "로봇은 돌았는데 옆으로 미끄러진 것처럼" 보이는 대표 증상입니다.엔코더가 네 바퀴 속도를 (FL, FR, RL, RR) = (+10, +10, −10, −10) rad/s 로 보고했습니다. 순기구학으로 계산한 차체 속도와 그 해석으로 옳은 것은?
- vx = 0.25 m/s, 전진 중이다
- ω = +2.27 rad/s, 제자리에서 돌고 있다
- (0, 0, 0) — 차체는 움직이지 않고 앞뒤 바퀴가 서로 밀고 있다. 바퀴 순서 · 부호 설정 오류나 미끄러짐을 의심해야 한다
- 4개의 값으로 3개를 구할 수 없으므로 계산이 불가능하다
정답 보기
③ — (+1, +1, −1, −1) 은 순기구학에서 0 이 되는 조합입니다. 정상 주행에서는 나오지 않는 패턴이므로 배선 · 모터 ID 순서 · 부호를 점검합니다. 의사역행렬 덕분에 4개 값으로도 계산은 가능합니다(④ 틀림).4교시 · 도전: 바닥 미끄러짐과 롤러 마모#
메카넘 휠의 약점#
지금까지의 식은 롤러가 미끄러지지 않는다고 가정했습니다. 실제 메카넘 휠은 이 가정이 잘 깨집니다.
- 측면 이동은 롤러에 의존합니다. 전진할 때는 롤러가 거의 돌지 않고 바퀴 전체가 구르지만, 옆걸음에서는 모든 롤러가 빠르게 돌며 힘을 전합니다. 롤러와 바닥 사이 접촉이 작고 짧아 측면 이동 정확도가 전진보다 낮습니다.
- 매끄러운 바닥 · 먼지 · 물기는 롤러 접지력을 떨어뜨려 같은 바퀴 회전에도 덜 움직이게 만듭니다.
- 롤러 마모 · 바퀴 하나의 효율 저하(모터 · 감속기 상태, 롤러 고무 마모, 이물질 낀 롤러)는 네 바퀴의 균형을 깨서 직선이어야 할 경로를 휘게 합니다.
- 적재 무게중심이 한쪽으로 쏠리면 그쪽 바퀴는 바닥을 세게 누르고 반대쪽은 덜 눌러 접지력이 달라집니다.
이 차시의 미끄러짐 모델 (교육용)#
실제 롤러 접촉 물리는 복잡하므로 원리를 보기 위한 단순 모델을 씁니다. 계수는 모두 교육용 가정이며 실물 측정값이 아닙니다.
| 단계 | 계산 | 뜻 |
|---|---|---|
| ① 역기구학 | 명령 (vx, vy · c_lat, 0) → 바퀴 둘레 속도, RR 에 × c_rr | c_lat · c_rr 는 보정 계수(처음엔 1) |
| ② 바퀴 효율 | 바퀴 속도 × e_i (마모 · 모터 상태, 0.5~1) | RR 의 e 를 낮춰 마모를 흉내 |
| ③ 접지 | × g_i = 1 − 0.6·(1−μ)·max(0, 1 − 하중분담_i / 0.25) | 덜 눌린 바퀴는 미끄러운 바닥에서 더 헛돎 |
| ④ 순기구학 | 3×4 행렬로 차체 속도 | 바퀴 차이가 회전 · 옆밀림으로 나타남 |
| ⑤ 롤러 미끄러짐 | vx × (0.97 + 0.03μ), vy × (0.55 + 0.40μ) | 측면 성분이 훨씬 크게 손해 |
| ⑥ 적분 | 3교시 식, Δt = 0.01 s | 지도 위 끝 위치 → 목표와의 오차 |
μ 는 바퀴-바닥 마찰 계수입니다(ch01 에서는 마른 바닥 0.6 · 젖은 바닥 0.2 를 가정했습니다). 하중 분담은 차체 5 kg 과 적재물의 무게중심 위치로 계산합니다.
시뮬레이터 4 · 측면 1 m 이동 오차 측정#
선반 사이 칸(폭 0.54 m)에 로봇을 왼쪽으로 1 m 옆걸음시켜 넣는 작업입니다. 명령은 vy = 0.3 m/s 를 3.33초 주는 것입니다. 바닥 · 마모 · 적재를 바꾸고 오차를 재 보세요. 전진 1 m 로 바꿔 같은 조건의 전진 오차와 비교할 수 있습니다.
- 마른 콘크리트 · 효율 100 % · 적재 0 에서 왼쪽 1 m 와 전진 1 m 의 오차를 각각 적습니다. 바퀴가 모두 멀쩡한데도 어느 쪽 오차가 더 큰가요?
- 실습 조건 (μ 0.4 · RR 80 %) 을 누르기 전에, 측면 1 m 이동 오차가 몇 cm 일지, 로봇이 어느 쪽으로 돌지 예측해 적습니다. 그다음 눌러서 측정하고 ▶ 재생으로 움직임을 봅니다.
- 같은 조건에서 c_rr 만 움직여 θ 가 0° 가 되는 값을 찾습니다. 그 값과 RR 효율 0.8 은 어떤 관계인가요? 이때 남은 오차는 어느 방향인가요?
- 이어서 c_lat 을 움직여 오차를 5 cm 이내로 줄입니다. 찾은 값을 실습 과제 4-1 의 계산과 비교합니다.
- 보정을 지우고 바닥을 마른 콘크리트로 되돌린 뒤, 적재 5 kg 을 왼쪽으로 10 cm 에 둡니다. 전진 1 m 와 왼쪽 1 m 를 번갈아 눌러 봅니다. 어느 명령에서 경로가 휘나요? 바닥을 물기 있는 바닥으로 바꾸면요?
- 마른 바닥에서도 측면 이동은 롤러 미끄러짐 때문에 목표보다 짧게 갑니다(이 모델에서 μ = 0.9 일 때 약 9 cm 부족). 전진 오차는 1 cm 이하입니다. 측면 이동은 전진보다 덜 정확하다는 메카넘 휠의 기본 성질입니다.
- μ 0.4 · RR 80 % 에서는 측면 이동이 약 0.7 m 에 그치고, RR 이 덜 밀어 왼쪽(반시계)으로 약 13° 돌아 칸 입구에서 멈춥니다(오차 약 33 cm). 오차 두 가지(거리 부족 + 회전)가 섞여 있습니다.
- c_rr = 1.25 (= 1 / 0.8) 이면 네 바퀴의 실제 전달이 다시 같아져 회전이 사라집니다. 남은 것은 순수한 거리 부족(약 29 cm)이고, c_lat ≈ 1.41 (= 1 / 0.71) 로 채우면 5 cm 이내로 들어옵니다. 원인마다 보정 계수를 하나씩 맞추는 것이 요령입니다.
- 적재를 왼쪽에 두면 오른쪽 바퀴가 덜 눌려 미끄러운 바닥에서 덜 밀어 줍니다. 전진할 때 오른쪽이 느려져 오른쪽으로 휘지만, 왼쪽 옆걸음에서는 네 바퀴의 효과가 대칭으로 줄어 휘지 않고 짧게만 갑니다. 마른 바닥(μ 0.9)에서는 이 효과가 작습니다.
적재와 무게중심: 경로가 휘는 이유#
바퀴의 접지력은 대략 "바퀴를 누르는 무게 × 마찰 계수" 입니다. 적재물이 한쪽으로 쏠리면 그 반대쪽 바퀴는 덜 눌려 쉽게 헛돕니다. 헛도는 바퀴는 명령보다 적게 밀고, 1교시에서 본 것처럼 네 힘의 균형이 깨지면 돌림힘이 남아 경로가 휩니다.
- 물건은 상판 가운데에 싣고, 무거운 물건은 아래 · 가운데에 둡니다. ch01 에서 정한 상판 적재 기준(5 kg)도 이 관점에서 지켜야 합니다.
- 같은 쏠림이라도 바닥 마찰이 크면 영향이 작고, 미끄러운 바닥에서는 크게 나타납니다. 그래서 적재 위치와 바닥 상태는 함께 점검합니다.
안전 수칙의 "평탄하고 마른 바닥" 을 운동학으로 읽기#
ch01 에서 정리한 공식 안전 수칙의 "실내 · 평탄하고 마른 바닥" 조건을 이 차시의 결과로 다시 읽어 봅시다.
| 수칙 | 운동학으로 본 이유 |
|---|---|
| 마른 바닥 | μ 가 낮으면 롤러가 미끄러져 측면 이동이 크게 짧아지고, 바퀴 간 접지 차이가 커져 경로가 휩니다. 역기구학 식이 맞지 않게 됩니다. |
| 평탄한 바닥 | 바닥이 울퉁불퉁하면 네 바퀴 중 하나가 순간적으로 들려 하중이 0 이 됩니다. 그 순간 그 바퀴의 힘이 사라지므로 1교시의 "FR 만 +" 처럼 균형이 깨집니다. |
| 먼지 · 이물질 관리 | 롤러 사이에 낀 머리카락 · 먼지는 롤러 회전을 막아 해당 바퀴만 효율이 떨어진 것과 같습니다(RR 80 % 실험). |
| 상판 적재 한도 · 가운데 적재 | 하중이 쏠리면 바퀴별 접지력이 달라져 경로가 휩니다. |
보정 계수는 그 바닥 · 그 적재 · 그 마모 상태에서만 맞습니다. 바닥이 바뀌거나 짐을 내리면 다시 틀어집니다. 그래서 실제 자율주행 로봇은 고정 보정 대신 센서로 실제 위치를 재서 계속 고치는 방법(IMU · LiDAR 를 섞는 오도메트리, ch06 · ch10)을 씁니다.
실습 과제 4#
시뮬레이터 4 와 같은 모델을 Python 으로 옮겼습니다. 실습 조건(μ 0.4, RR 효율 80 %)에서 측면 · 전진 오차를 재고, 보정 계수 두 개를 구해 다시 시도합니다. TODO 두 곳을 채웁니다.
import numpy as np
r, lx, ly = 0.05, 0.085, 0.135
L = lx + ly
POS = [(lx, ly), (lx, -ly), (-lx, ly), (-lx, -ly)] # FL, FR, RL, RR
M_BODY = 5.0 # 차체 질량 (kg) - 가정
def lam_x(mu): return 0.97 + 0.03 * mu # 앞뒤 롤러 전달률 (교육용 모델)
def lam_y(mu): return 0.55 + 0.40 * mu # 옆 롤러 전달률 (교육용 모델)
def shares(m, dx, dy):
cx, cy = m * dx / (M_BODY + m), m * dy / (M_BODY + m)
out = []
for px, py in POS:
sx, sy = (1 if px > 0 else -1), (1 if py > 0 else -1)
out.append(max(0.0, 0.25 * (1 + sx * cx / lx) * (1 + sy * cy / ly)))
return out
def grips(mu, sh):
return [1 - 0.6 * (1 - mu) * max(0.0, 1 - s / 0.25) for s in sh]
def run(mu, eff, cmd="lat", m=0.0, dx=0.0, dy=0.0, c_rr=1.0, c_lat=1.0, v=0.3, dt=0.01):
vx = v if cmd == "fwd" else 0.0
vy = v * c_lat if cmd == "lat" else 0.0
rim = [vx - vy, vx + vy, vx + vy, vx - vy] # 바퀴 둘레 속도 (m/s), w = 0
rim[3] *= c_rr
g = grips(mu, shares(m, dx, dy))
e = [rim[i] * eff[i] * g[i] for i in range(4)]
bx = (e[0] + e[1] + e[2] + e[3]) / 4 * lam_x(mu)
by = (-e[0] + e[1] + e[2] - e[3]) / 4 * lam_y(mu)
bw = (-e[0] + e[1] - e[2] + e[3]) / (4 * L)
x = y = th = 0.0
for _ in range(int(round(1.0 / v / dt))):
x += (bx * np.cos(th) - by * np.sin(th)) * dt
y += (bx * np.sin(th) + by * np.cos(th)) * dt
th += bw * dt
tx, ty = (1.0, 0.0) if cmd == "fwd" else (0.0, 1.0)
return x, y, th, np.hypot(x - tx, y - ty)
def report(label, res):
x, y, th, err = res
print("%s: x=%+.3f y=%+.3f th=%+.1fdeg 오차 %.1f cm" % (label, x, y, np.degrees(th), err * 100))
MU, EFF = 0.4, [1.0, 1.0, 1.0, 0.8]
report("측면 1 m, 보정 없음", run(MU, EFF, "lat"))
report("전진 1 m, 보정 없음", run(MU, EFF, "fwd"))
# TODO 1: RR 효율을 되돌리는 보정 계수
c_rr = 1.0
report("측면, c_rr 만", run(MU, EFF, "lat", c_rr=c_rr))
# TODO 2: c_rr 적용 후 측면 이동 거리 y 를 재고, 1 m 가 되도록 c_lat 을 정하세요
c_lat = 1.0
report("측면, c_rr + c_lat", run(MU, EFF, "lat", c_rr=c_rr, c_lat=c_lat))
print("c_rr = %.3f, c_lat = %.3f" % (c_rr, c_lat))풀이 코드 보기
import numpy as np
r, lx, ly = 0.05, 0.085, 0.135
L = lx + ly
POS = [(lx, ly), (lx, -ly), (-lx, ly), (-lx, -ly)] # FL, FR, RL, RR
M_BODY = 5.0 # 차체 질량 (kg) - 가정
def lam_x(mu): return 0.97 + 0.03 * mu # 앞뒤 롤러 전달률 (교육용 모델)
def lam_y(mu): return 0.55 + 0.40 * mu # 옆 롤러 전달률 (교육용 모델)
def shares(m, dx, dy):
cx, cy = m * dx / (M_BODY + m), m * dy / (M_BODY + m)
out = []
for px, py in POS:
sx, sy = (1 if px > 0 else -1), (1 if py > 0 else -1)
out.append(max(0.0, 0.25 * (1 + sx * cx / lx) * (1 + sy * cy / ly)))
return out
def grips(mu, sh):
return [1 - 0.6 * (1 - mu) * max(0.0, 1 - s / 0.25) for s in sh]
def run(mu, eff, cmd="lat", m=0.0, dx=0.0, dy=0.0, c_rr=1.0, c_lat=1.0, v=0.3, dt=0.01):
vx = v if cmd == "fwd" else 0.0
vy = v * c_lat if cmd == "lat" else 0.0
rim = [vx - vy, vx + vy, vx + vy, vx - vy] # 바퀴 둘레 속도 (m/s), w = 0
rim[3] *= c_rr
g = grips(mu, shares(m, dx, dy))
e = [rim[i] * eff[i] * g[i] for i in range(4)]
bx = (e[0] + e[1] + e[2] + e[3]) / 4 * lam_x(mu)
by = (-e[0] + e[1] + e[2] - e[3]) / 4 * lam_y(mu)
bw = (-e[0] + e[1] - e[2] + e[3]) / (4 * L)
x = y = th = 0.0
for _ in range(int(round(1.0 / v / dt))):
x += (bx * np.cos(th) - by * np.sin(th)) * dt
y += (bx * np.sin(th) + by * np.cos(th)) * dt
th += bw * dt
tx, ty = (1.0, 0.0) if cmd == "fwd" else (0.0, 1.0)
return x, y, th, np.hypot(x - tx, y - ty)
def report(label, res):
x, y, th, err = res
print("%s: x=%+.3f y=%+.3f th=%+.1fdeg 오차 %.1f cm" % (label, x, y, np.degrees(th), err * 100))
MU, EFF = 0.4, [1.0, 1.0, 1.0, 0.8]
report("측면 1 m, 보정 없음", run(MU, EFF, "lat"))
report("전진 1 m, 보정 없음", run(MU, EFF, "fwd"))
c_rr = 1.0 / EFF[3] # 80 % 로 덜 도는 바퀴를 1/0.8 배 더 돌림
report("측면, c_rr 만", run(MU, EFF, "lat", c_rr=c_rr))
y_meas = run(MU, EFF, "lat", c_rr=c_rr)[1] # 측정한 측면 이동 거리
c_lat = 1.0 / y_meas # 모델을 몰라도 측정값으로 구할 수 있음
print("측정 y = %.3f m -> c_lat = %.3f (모델 값 1/lam_y = %.3f)" % (y_meas, c_lat, 1 / lam_y(MU)))
report("측면, c_rr + c_lat", run(MU, EFF, "lat", c_rr=c_rr, c_lat=c_lat))
print("c_rr = %.3f, c_lat = %.3f" % (c_rr, c_lat))
print("-- 같은 보정을 마른 바닥(mu 0.9)에 그대로 쓰면? --")
report("측면, mu 0.9", run(0.9, EFF, "lat", c_rr=c_rr, c_lat=c_lat))실행 결과: 보정 없이 측면 1 m 는 y ≈ 0.67 m 에서 약 13° 돌아 오차 약 33 cm, 전진 1 m 는 오차 약 10 cm(같은 13° 회전이 오른쪽으로)로 측면이 훨씬 나쁩니다. c_rr = 1.25 를 넣으면 회전이 0 이 되고 y ≈ 0.71 m 만 남습니다. 측정값으로 구한 c_lat = 1/0.709 ≈ 1.41 (모델 값 1/0.71 ≈ 1.408) 을 더하면 오차가 0 에 가깝습니다. 마지막 줄처럼 같은 보정을 마른 바닥에 쓰면 이번엔 너무 멀리 갑니다(약 1.28 m). 보정 계수는 그 바닥에서만 맞습니다.
시뮬레이터 4 에서 μ 0.4 · RR 효율 80 % 조건으로 왼쪽 1 m 옆걸음을 명령했습니다(보정 없음). 결과로 옳은 것은?
- 정확히 1 m 를 가고, 회전도 없다
- 1 m 보다 짧게 가고, RR 이 덜 밀어 왼쪽(반시계)으로 돌면서 뒤쪽(−x)으로 밀린다
- 1 m 보다 멀리 가고, 오른쪽으로 돈다
- 옆으로는 가지 않고 제자리에서 돈다
정답 보기
② — 측면 롤러 전달률 0.71 때문에 거리가 짧아지고, RR 의 (−) 회전이 덜해 오른쪽 바퀴 쪽 돌림힘이 남아 반시계로 약 13° 돕니다. 몸이 돈 상태로 "로봇 기준 왼쪽" 으로 가므로 지도에서는 조금씩 뒤(−x)로 밀리며, 칸 안쪽 목표까지 약 33 cm 모자란 입구에서 멈춥니다.같은 바닥 · 같은 마모에서 측면 1 m 의 오차가 전진 1 m 의 오차보다 훨씬 큰 이유로 가장 알맞은 것은?
- 측면 이동은 바퀴가 더 빨리 돌아야 하기 때문
- 측면 이동은 롤러가 돌며 힘을 전하므로 롤러 미끄러짐의 영향을 크게 받기 때문
- 측면 이동할 때는 RR 바퀴만 쓰기 때문
- 역기구학 식이 측면 이동에서는 성립하지 않기 때문
정답 보기
② — 전진할 때는 롤러가 거의 돌지 않고 바퀴 전체가 구르지만, 옆걸음은 롤러의 접촉에 기대어 힘을 전하므로 바닥 상태에 훨씬 민감합니다. 측면이든 전진이든 바퀴 둘레 속도는 같으며(① 틀림), 역기구학 식은 미끄러짐이 없다는 가정 아래 성립합니다.물기 있는 바닥에서 적재 5 kg 을 상판 왼쪽으로 10 cm 치우치게 싣고 전진했습니다. 경로는 어떻게 되나요?
- 왼쪽으로 휜다 — 무거운 쪽으로 기울어서
- 오른쪽으로 휜다 — 오른쪽 바퀴가 덜 눌려 헛돌고 덜 밀기 때문
- 휘지 않고 짧게만 간다
- 휘지 않고 오히려 더 멀리 간다
정답 보기
② — 오른쪽 바퀴의 접지력이 줄어 전달률이 떨어지므로 왼쪽이 더 세게 밀어 시계 방향(오른쪽)으로 돕니다. ③ 은 같은 적재에서 **왼쪽 옆걸음**을 했을 때의 결과입니다(대칭으로 줄어 회전이 없음). 시뮬레이터 4 의 해 볼 것 5 로 확인하세요.자주 나는 오류와 해결#
1) 옆으로 가라고 했는데 제자리에서 돈다 (바퀴 순서 뒤바뀜)#
(오류 메시지 없음) vy = 0.3 을 보냈는데 로봇이 시계 방향으로 회전함- 원인: 역기구학 결과
[w_fl, w_fr, w_rl, w_rr]를 모터에 보낼 때 순서를 다르게 넣었습니다. 예를 들어 FL 과 FR 을 바꾸면 옆걸음 조합 (−, +, +, −) 이 (+, −, +, −) 가 되어 회전 명령이 됩니다. - 해결: 바퀴 하나씩만 천천히 돌려(1교시 "FR 만 +" 처럼) 어느 바퀴가 도는지 눈으로 확인하고, 이름 → 모터 ID 표를 만들어 씁니다. 실물의 모터 ID 와 바퀴 위치 대응은 ch04 에서 확인합니다.
2) 로봇이 20배 빠르거나 느리다 (m/s 와 rad/s 혼동)#
(오류 메시지 없음) 0.5 m/s 를 명령했는데 바퀴가 0.5 rad/s 로 돌아 거의 움직이지 않음- 원인: 역기구학에서
/ r을 빠뜨렸거나(둘레 속도 m/s 를 그대로 각속도로 보냄), 두 번 나눴습니다. r = 0.05 m 이면 두 단위는 정확히 20배 차이 납니다. - 해결: 변수 이름에 단위를 붙입니다(
rim_mps,wheel_radps). 전진 0.5 m/s → 네 바퀴 10 rad/s 를 기준 시험으로 둡니다(실습 과제 2-1).
3) Playground: 행렬 곱 크기 오류#
ValueError: matmul: Input operand 1 has a mismatch in its core dimension 0, with gufunc signature (n?,k),(k,m?)->(n?,m?) (size 4 is different from 3)- 원인: 4×3 역기구학 행렬
J에 바퀴 속도 4개짜리 벡터를 곱했습니다. 또는 3×4 순기구학 행렬에 (vx, vy, ω) 3개를 곱했습니다. - 해결: 방향을 확인합니다. 차체(3) → 바퀴(4) 는
J @ [vx, vy, w], 바퀴(4) → 차체(3) 는FK @ [fl, fr, rl, rr]입니다.print(J.shape)로 모양을 먼저 확인합니다.
4) Playground: 역행렬을 구할 수 없음#
numpy.linalg.LinAlgError: Last 2 dimensions of the array must be square- 원인: 4×3 행렬에
np.linalg.inv()를 썼습니다. 역행렬은 정사각 행렬에만 있습니다. - 해결:
np.linalg.pinv(J)(의사역행렬)를 쓰거나, 3교시의 순기구학 식을 직접 행렬로 씁니다.
5) 회전하면 궤적이 이상하다 (좌표 변환 누락)#
(오류 메시지 없음) 회전하며 옆으로 갔는데, RViz 에서 로봇 위치는 직선으로 가고 방향만 돌아 있음- 원인: 위치 적분에서
x += vx*dt; y += vy*dt처럼 로봇 기준 속도를 그대로 더했습니다. 회전이 없는 시험(전진 · 옆걸음 · 정사각형)에서는 결과가 같아 숨어 있다가, 회전이 섞이면 드러납니다. - 해결:
x += (vx*cos(th) - vy*sin(th))*dt,y += (vx*sin(th) + vy*cos(th))*dt로 고치고, vy + ω 동시 명령(원호가 나와야 함)을 시험 항목에 넣습니다(실습 과제 3-2).
6) 대각선으로 빨리 가라고 했더니 방향이 틀어진다 (바퀴별 자르기)#
(오류 메시지 없음) vx 1.4, vy 0.6 명령에 진행 방향이 23° 가 아니라 18° 로 나감- 원인: 한계를 넘은 바퀴만 잘라(clip) 네 바퀴의 비율이 깨졌습니다.
- 해결: 가장 큰 바퀴가 한계에 닿도록 네 바퀴에 같은 계수를 곱합니다(
scale_all(), 실습 과제 2-2).
7) 옆으로 가면 조금씩 돌고 거리가 모자란다 (미끄러짐 · 마모)#
(오류 메시지 없음) 측면 1 m 명령에 약 0.7 m 이동, 왼쪽으로 십여 도 회전- 원인: 바닥이 미끄럽거나(먼지 · 물기), 한 바퀴의 롤러가 닳았거나 이물질이 끼어 효율이 떨어졌습니다. 적재가 한쪽으로 쏠려 있어도 비슷한 증상이 납니다.
- 해결: 바닥을 청소하고 마른 상태에서 운용합니다. 롤러를 손으로 돌려 걸리는 바퀴를 찾습니다. 적재를 가운데로 옮기고, 그래도 남는 오차는 측정해 보정 계수로 줄이거나 센서 기반 위치 추정(ch06)으로 고칩니다.
8) 옆걸음 명령에 로봇이 거의 움직이지 않는다 (롤러 방향 잘못 조립)#
(오류 메시지 없음) 전진 · 후진은 정상인데 vy 명령에서 바퀴만 돌고 차체는 제자리에서 떨림- 원인: 바퀴를 교체 · 재조립하면서 왼쪽용 · 오른쪽용 메카넘 휠을 바꿔 끼워, 바닥 롤러가 X 배치가 아닌 반대 배치가 되었습니다. 이 경우 옆걸음 조합이 1교시의 "바퀴끼리 싸우는" 조합처럼 됩니다(이 강좌의 계산 기준이며, 제품의 바퀴 구분 표시는 공식 문서에서 확인 필요).
- 해결: 로봇을 들어 바닥 쪽 롤러 방향이 그림 "위에서 본 교육용 myAGV Plus" 와 같은 X 모양인지 확인합니다. 출고 상태에서 바퀴를 임의로 바꿔 끼우지 않습니다.
과제#
- 방향 카드 만들기: 8방향(전 · 후 · 좌 · 우 · 대각선 4개)과 제자리 좌 · 우 회전, 총 10가지 움직임의 네 바퀴 부호(+, −, 0)를 표로 만드세요. 실습 과제 1-1 의 코드로 표의 모든 칸을 검증합니다.
- 포화 보고서: vx = 0.8 m/s 로 직진하면서 ω 를 0 → 5 rad/s 로 올릴 때, 자르기 방식과 같은 비율 방식의 회전 반경을 0.5 rad/s 간격으로 표로 만들고(실습 과제 2-2 활용), 선반 통로에서 어느 방식이 안전한지 3줄로 쓰세요.
- 바닥 점검표: 시뮬레이터 4 에서 바닥 4종 × (적재 0 kg, 5 kg 왼쪽) 의 측면 1 m 오차를 측정해 표로 만들고, 오차가 10 cm 를 넘는 조건에 대해 "운용 전 점검 항목" 을 3가지 쓰세요.
참고자료#
- myAGV Plus 공식 문서 (영문): https://github.com/elephantrobotics/myagvPlus_docs/tree/main/MYAGV_PLUS_EN
- myagv_ros2 저장소 (ROS 2 패키지, 오도메트리 · 속도 명령 처리): https://github.com/elephantrobotics/myagv_ros2
- myAGV Plus 제품 사진 · 소개 (hyenc.net): https://www.hyenc.net/products/35
- Mecanum wheel (메카넘 휠 구조와 역사): https://en.wikipedia.org/wiki/Mecanum_wheel
- Lynch & Park, Modern Robotics 13장 Wheeled Mobile Robots (전방향 바퀴 로봇의 기구학): http://hades.mech.northwestern.edu/index.php/Modern_Robotics
- numpy 의사역행렬
numpy.linalg.pinv: https://numpy.org/doc/stable/reference/generated/numpy.linalg.pinv.html - REP-103 표준 단위 · 좌표 규칙 (x 앞, y 왼쪽, 반시계 +): https://www.ros.org/reps/rep-0103.html
- 이 사이트의 도구: URDF 뷰어 · Python Playground
- 이전 차시: ch02 URDF 로 보는 로봇 구조와 좌표계 · 다음 차시: ch04 pymycobot MyAGVPlus 로 이동 제어