CH02전방향 휠 기구학 — 옆으로 가는 로봇의 비밀
메카넘(전방향) 휠 4개가 각자 속도를 내면 차체가 어떻게 움직이는지, 역기구학 · 순기구학 식을 시뮬레이터로 발견합니다.
학습 목표#
- 차동 구동 로봇이 옆으로 바로 갈 수 없는 이유(비홀로노믹 구속)를 설명하고, 같은 "옆 1 m 이동" 을 차동 · 전방향 구동으로 할 때의 동작 수와 시간을 비교할 수 있습니다.
- 메카넘 휠의 45° 롤러가 만드는 대각선 힘을 근거로, 앞뒤 · 좌우 · 대각선 · 제자리 회전에 필요한 바퀴 부호 패턴을 찾아 표로 만들 수 있습니다.
- 역기구학 식으로 원하는 차체 속도
(vx, vy, ω)를 바퀴 4개의 각속도(rad/s)로 바꾸고, 한 바퀴가 한계를 넘을 때 비율 정규화로 방향을 지킬 수 있습니다. - 순기구학(의사역행렬, 최소제곱)으로 바퀴 속도에서 차체 속도를 되계산하고, 미끄러짐(slip)이 계획 경로와 실제 경로를 어떻게 벌리는지 측정할 수 있습니다.
이론#
이번 차시의 기준 값은 ch01 에서 읽은 공식 URDF 숫자입니다.
| 기호 | 뜻 | 값 | 출처 |
|---|---|---|---|
lx | 차체 중심 → 바퀴 축, 앞뒤 거리 | 0.1715 m (0.17128 / 0.17181 의 평균) | agv_pro.urdf 바퀴 joint origin x |
ly | 차체 중심 → 바퀴, 좌우 거리 | 0.1799 m | agv_pro.urdf 바퀴 joint origin y |
lx + ly | 회전 팔 길이 (기구학 식에 들어가는 합) | 0.3514 m | 계산 |
r | 바퀴 반지름 | 0.05 m (지름 0.1 m) | Gazebo 설정 기준 — 실물은 확인 필요 |
ω_max | 바퀴 최고 각속도 | 30 rad/s | 교육용 가정값 (바퀴 둘레 속도 1.5 m/s = 사양 최고 속도) |
URDF 에서 바퀴 축은 base_footprint 위 0.020 + 0.052 = 0.072 m 높이에 있습니다. 바닥이 base_footprint 라면 실제 반지름은 0.05 m 보다 클 수 있습니다. 이 차시의 식은 모두 r 을 변수로 두므로, 실물 값을 재면(바퀴 지름을 자로 재거나 10 바퀴 굴려 거리 ÷ 10π) 그 값으로 바꿔 쓰면 됩니다.
실제로 agv_pro_gazebo/meshes/wheel_*.stl 의 경계 상자를 재 보면 바퀴 메시는 지름 약 0.152 m(반지름 약 0.076 m)입니다. 설정값 0.05 m 와 1.5 배 차이가 나므로, 3D 뷰어에서 바퀴를 격자와 비교해 보세요. 이 강좌의 시뮬레이터는 ROS 설정과 같게 r = 0.05 로 계산합니다 (교육용 — 실물 값은 확인 필요).
바퀴 이름은 실제 위치로 부릅니다: FL(왼쪽 앞) · FR(오른쪽 앞) · RL(왼쪽 뒤) · RR(오른쪽 뒤). ch01 에서 본 것처럼 URDF 의 joint 이름 두 개는 실제 위치와 엇갈려 있으므로, 이름이 아니라 origin 좌표의 부호(x 앞뒤, y 좌우)로 매핑합니다.
1교시 · 차동 구동 vs 전방향 구동#
자유도 셋, 그런데 고를 수 있는 것은 몇 개?#
바닥 위 로봇의 자세는 (x, y, θ) 세 숫자이고, 속도도 차체 기준 (vx, vy, ω) 세 개입니다 — 앞 속도, 옆 속도, 회전 속도.
| 구동 방식 | 바퀴 | 고를 수 있는 속도 | 구속 |
|---|---|---|---|
| 차동 구동 (differential drive) | 좌 · 우 바퀴 2개 (+ 보조 바퀴) | vx, ω 두 개 | **vy = 0** — 바퀴가 옆으로 미끄러지지 않으므로 |
| 전방향 구동 (omnidirectional, 메카넘) | 메카넘 휠 4개 | vx, vy, ω 세 개 모두 독립 | 없음 (홀로노믹) |
차동 구동의 vy = 0 은 속도에 걸린 구속입니다. 위치로는 결국 옆으로 갈 수 있지만(돌고, 가고, 다시 돌면), 그 순간에 옆으로 미끄러질 수는 없습니다. 이처럼 "갈 수 있는 곳" 이 아니라 "그 순간 낼 수 있는 속도" 를 막는 구속을 비홀로노믹(nonholonomic) 구속이라고 합니다. 전방향 구동은 이 구속이 없어서 세 속도를 마음대로 고를 수 있습니다 — 홀로노믹(holonomic) 구동입니다.
시뮬레이터 1 · 옆 1 m 평행이동 대결#
- 두 로봇 모두 myAGV Pro 와 같은 크기(0.53 × 0.36 m)로 그리고, 가감속 없이 최고 속도로 바로 움직인다고 가정합니다.
- 차동 로봇은
전진/후진(vx) 과회전(ω) 명령만 있습니다. 회전은 차체 중심에서 제자리로 합니다. - 제자리 회전에는 반지름 √(0.265² + 0.18²) ≈ 0.32 m 의 원이 필요합니다. 선반(회색 벽)에 모서리가 닿으면 빨간색으로 표시합니다.
먼저 예측하세요. 선반과의 간격이 0.10 m 밖에 없는 통로에서, 차동 로봇이 "좌회전 90° → 전진 1 m → 우회전 90°" 를 하면 어떻게 될까요? 전방향 로봇보다 몇 배 오래 걸릴까요?
해 볼 것
- 버튼으로 차동 로봇이 목표(점선 상자)에 정확히 도착하는 순서를 직접 만들어 봅니다. "목표 도달" 이 나오는 가장 짧은 순서는 동작 몇 개인가요?
- 기본값(0.5 m/s · 1.0 rad/s)에서 차동/전방향 시간 비를 읽습니다. 그다음 최고 회전 속도만 2.0 rad/s 로 올리면 비는 얼마까지 줄어드나요?
- 선반과의 간격을 0.20 → 0.10 m 로 줄이고 다시 실행합니다. 차동 로봇은 언제 빨개지나요? 전방향 로봇은?
- 간격 슬라이더를 천천히 움직여 차동 로봇이 충돌하지 않는 최소 간격을 찾고, 0.32 − 0.18 = 0.14 m 와 비교합니다.
- 좌회전 45° 를 섞어 "비스듬히 가는" 순서도 만들어 봅니다. 회전을 줄이면 시간은 줄지만 무엇이 생기나요?
관찰 포인트 — 차동 구동은 옆으로 가려면 회전이 반드시 두 번 들어갑니다(가는 방향으로 돌기, 원래 방향으로 돌아오기). 회전 시간 2 × (π/2) / ω_max 는 거리와 상관없이 붙는 고정 비용이고, 제자리 회전은 차체 대각선 반지름(0.32 m)만큼의 빈 공간을 요구합니다. 전방향 구동은 vy 하나로 끝나므로 시간도 공간도 덜 듭니다. 좁은 창고 통로에서 선반 옆에 붙는 동작이 전방향 휠을 쓰는 가장 큰 이유입니다.
시뮬레이터 1 기본값(최고 직진 0.5 m/s, 최고 회전 1.0 rad/s)에서 "좌회전 90° → 전진 1 m → 우회전 90°" 를 실행하면 차동 로봇의 시간은 약 5.14 s, 전방향 로봇은 2.00 s 입니다. 차이 3.14 s 는 어디서 왔을까요?
- 차동 로봇이 더 느린 속도로 전진해서
- 90° 회전 두 번 (π/2 ÷ 1.0 rad/s × 2 = π s)
- 전방향 로봇이 대각선으로 지름길을 가서
- 차동 로봇의 바퀴가 2개뿐이라 출력이 약해서
정답 보기
② — 전진 1 m 는 두 로봇 모두 0.5 m/s 로 2 s 입니다. 차동 로봇에만 회전 2번(각 π/2 ÷ 1.0 = 1.57 s)이 붙어 π ≈ 3.14 s 가 더 걸립니다. 이 회전 비용은 이동 거리가 짧을수록 비율이 커집니다.선반과의 간격을 0.10 m 로 줄였더니 차동 로봇이 첫 회전 중에 빨갛게 변했습니다. 가장 알맞은 해석은?
- 회전 속도가 너무 빨라서 미끄러졌다
- 제자리 회전에는 반지름 약 0.32 m 공간이 필요한데, 중심에서 선반까지는 0.18 + 0.10 = 0.28 m 뿐이다
- 차동 로봇은 원래 선반 근처에서 움직일 수 없다
- 목표 위치가 선반 안쪽에 있어서
정답 보기
② — 회전하면 차체 모서리가 중심에서 √(0.265² + 0.18²) ≈ 0.32 m 까지 나갑니다. 간격이 0.14 m 보다 좁으면 제자리 회전 자체가 불가능합니다. 전방향 로봇은 회전 없이 vy 로만 움직이므로 간격과 상관없이 목표에 갑니다.2교시 · 메카넘 휠의 롤러와 힘의 방향#
45° 롤러 — 힘은 대각선으로만 전달됩니다#
메카넘 휠(Mecanum wheel)은 바퀴 둘레에 작은 롤러가 45° 기울어져 달려 있습니다. 롤러는 자기 축 방향으로는 자유롭게 굴러가 버리므로, 바퀴가 바닥을 밀어도 힘은 롤러 축에 수직인 대각선 방향으로만 차체에 전달됩니다.
바퀴 하나가 차체에 주는 효과는 두 가지입니다.
- 밀기(병진): 대각선 방향
(1, ∓1)의 힘. - 돌리기(회전): 그 힘이 차체 중심에서 떨어진 곳에 작용하므로 생기는 돌림힘(토크). 팔 길이는 결국
lx + ly로 정리됩니다.
네 바퀴의 힘을 더한 합력의 방향으로 차체가 가고, 돌림힘의 합만큼 돕니다. 어떤 패턴이 어떤 움직임을 만드는지는 직접 조작해서 찾아봅니다.
시뮬레이터 2 · 바퀴 힘 화살표#
- 왼쪽: 차체 확대도. 파란 빗금은 바닥에 닿은 롤러의 축, 주황 화살표는 각 바퀴가 차체에 주는 힘(바퀴 속도에 비례), 초록 화살표는 합력(= 차체 속도 방향), 보라 호는 회전.
- 오른쪽: 4 × 4 m 바닥에서 실제로 움직이는 모습 (위쪽이 출발 시 로봇 앞). 차체 속도는 3교시의 순기구학 식으로 계산합니다 (
r = 0.05 m,lx + ly = 0.3514 m, 미끄러짐 없음). - 바퀴 속도
+는 그 바퀴가 로봇을 앞으로 굴리는 방향입니다.
먼저 예측하세요. 왼쪽 앞(FL)과 오른쪽 뒤(RR) 바퀴만 +10 rad/s 로 돌리고 나머지는 0 이면, 로봇은 어느 방향으로 갈까요? 돌기도 할까요?
해 볼 것
- 예측 문제 버튼(FL · RR 만 +10)을 누릅니다. 예측과 같은 방향인가요? 보라 회전 호가 나타나나요?
- 네 바퀴를 모두
+로 놓아 직진을 확인한 뒤, 두 바퀴의 부호만 바꿔서 왼쪽 옆으로 가는 패턴을 찾습니다. 어느 두 바퀴인가요? - 제자리에서 반시계 방향으로 도는 패턴을 찾습니다. 왼쪽 두 바퀴와 오른쪽 두 바퀴의 부호가 어떤가요? (차동 구동과 비교)
- 직진 패턴(모두 +10)에서 FR 만 +20 으로 올립니다. 합력은 어디로 기울고, 회전은 어느 쪽으로 생기나요?
- 실습 2-1 의 부호표 10칸(8방향 + 회전 2)을 이 시뮬레이터로 모두 채웁니다.
관찰 포인트 — 주황 화살표의 옆 성분이 서로 상쇄되면 앞뒤로, 앞뒤 성분이 상쇄되면 옆으로 갑니다. FL · RR 은 같은 대각선 (1, −1), FR · RL 은 반대 대각선 (1, +1) 을 맡습니다. 그래서 대각선 이동은 바퀴 2개만 돌리고 나머지 2개는 0 입니다. 회전은 왼쪽 두 바퀴와 오른쪽 두 바퀴가 반대로 도는 것으로, 차동 구동의 제자리 회전과 같은 원리입니다.
시뮬레이터 2 에서 FL · RR 만 +10 rad/s 로 돌렸더니 초록 합력이 오른쪽 앞 45° 를 가리키고, 회전(ω)은 0 이었습니다. 회전이 생기지 않은 이유는?
- 바퀴가 2개만 돌아서 힘이 약하기 때문
- FL 과 RR 은 차체 중심에 대해 서로 반대편에 있어, 같은 방향의 힘이 만드는 돌림힘이 크기는 같고 방향은 반대라 상쇄되기 때문
- 메카넘 휠은 원래 회전을 만들 수 없기 때문
- 앞바퀴만 회전을 만들 수 있기 때문
정답 보기
② — FL(+lx, +ly) 의 힘 (1, −1) 은 시계 방향, RR(−lx, −ly) 의 같은 힘은 반시계 방향 돌림힘을 만듭니다. 둘이 상쇄되어 ω = 0 이고, 합력만 남아 오른쪽 앞 대각선(vx = vy 크기 0.25 m/s)으로 갑니다.시뮬레이터에서 왼쪽 옆 이동 패턴을 찾았더니 "FL − · FR + · RL + · RR −" 였습니다. 그렇다면 오른쪽 옆 이동의 패턴은?
- FL + · FR − · RL − · RR +
- FL + · FR + · RL − · RR −
- FL − · FR + · RL − · RR +
- FL 0 · FR + · RL + · RR 0
정답 보기
① — 방향을 정반대로 바꾸려면 모든 바퀴의 부호를 뒤집으면 됩니다(식이 선형이므로). ③ 은 반시계 제자리 회전, ④ 는 왼쪽 앞 대각선 이동, ② 는 힘이 모두 상쇄되어 움직이지 않습니다 (앞뒤 · 옆 · 회전 성분이 모두 0).3교시 · 역기구학: 원하는 속도 → 바퀴 속도#
역기구학 식#
2교시에서 찾은 부호 패턴을 식으로 쓰면 다음과 같습니다. 원하는 차체 속도 (vx, vy, ω) 를 넣으면 바퀴 각속도(rad/s)가 나옵니다.
| 바퀴 | 위치 (x, y) | 역기구학 |
|---|---|---|
| FL 왼쪽 앞 | (+lx, +ly) | w_FL = (vx − vy − (lx+ly)·ω) / r |
| FR 오른쪽 앞 | (+lx, −ly) | w_FR = (vx + vy + (lx+ly)·ω) / r |
| RL 왼쪽 뒤 | (−lx, +ly) | w_RL = (vx + vy − (lx+ly)·ω) / r |
| RR 오른쪽 뒤 | (−lx, −ly) | w_RR = (vx − vy + (lx+ly)·ω) / r |
- 단위:
vx, vy는 m/s,ω는 rad/s,lx, ly, r는 m → 결과는 rad/s. (lx+ly)·ω는 "회전 때문에 바퀴 자리에서 생기는 속도" 입니다. myAGV Pro 는lx + ly = 0.3514 m,r = 0.05 m이므로 ω = 1 rad/s 회전에 바퀴가 0.3514 / 0.05 ≈ 7.0 rad/s 씩 돕니다.- 행렬로 쓰면
w = J · [vx, vy, ω],J는 4 × 3 행렬입니다. 행 하나가 바퀴 하나입니다.
vy 앞의 부호(− + + −)는 2교시 "왼쪽 옆 이동" 패턴, ω 앞의 부호(− + − +)는 "반시계 회전" 패턴과 같습니다. 식을 외우기보다 시뮬레이터 2 에서 찾은 패턴으로 다시 만들 수 있으면 충분합니다.
바퀴 최고 속도와 포화(saturation)#
바퀴 모터에는 최고 속도가 있습니다. 이 차시에서는 ω_max = 30 rad/s(바퀴 둘레 1.5 m/s, 교육용 가정)로 둡니다. 식으로 나온 값이 한계를 넘으면 두 가지로 처리할 수 있습니다.
| 방법 | 하는 일 | 결과 | ||||
|---|---|---|---|---|---|---|
| 바퀴별 자르기 (clipping) | 넘은 바퀴만 ±ω_max 로 자름 | 바퀴 사이 비율이 깨져 차체가 엉뚱한 방향 · 곡률로 감 | ||||
| 비율 정규화 (normalization) | 가장 큰 ` | w | 가 ω_max 가 되도록 4개 모두에 같은 배율 s = ω_max / max | w | ` 를 곱함 | 방향 · 곡률은 그대로, 속도만 느려짐 |
시뮬레이터 3 · 역기구학과 포화#
- 위 표의 역기구학으로 바퀴 속도를 구하고, 고른 처리 방법(그대로 · 자르기 · 정규화)을 거친 바퀴 속도를 다시 순기구학으로 차체 속도로 바꿔 3 초 동안 움직인 궤적을 그립니다.
- 회색 점선 = 명령한 궤적(한계 무시), 빨강 = 바퀴별 자르기, 파랑 = 비율 정규화. 오른쪽 그림은 위쪽이 출발 시 로봇 앞입니다.
- 바퀴 아이콘의 회전은 눈으로 보기 쉽게 실제의 1/10 속도로 그립니다.
먼저 예측하세요. vx = 1.0, vy = 0.5, ω = 0.8 을 넣으면 네 바퀴 중 어느 바퀴가 가장 빨리 돌까요? 그 바퀴만 30 rad/s 로 자르면 로봇은 명령보다 왼쪽으로 덜 갈까요, 더 갈까요?
해 볼 것
- 실습 값 버튼을 누르고 네 바퀴 값을 읽습니다. 어느 바퀴가 30 rad/s 를 넘나요? 예측과 같나요?
- "바퀴별 자르기" 와 "비율 정규화" 를 번갈아 고르며 빨강 · 파랑 궤적을 회색 점선(명령)과 비교합니다. 어느 쪽이 같은 모양을 따라가나요?
- 출력 줄의 "방향" 과 "곡률 ω/v" 를 비교합니다. 정규화는 두 값이 명령과 같고, 자르기는 다릅니다. 왜일까요?
vy와ω를 0 으로 놓고vx만 1.5 까지 올립니다. 이때는 자르기와 정규화의 궤적이 왜 같아지나요?- 바퀴 최고 속도를 40 으로 올리면 포화가 사라지는 지점을 찾습니다. 실습 값에서 필요한 최소 한계는 얼마인가요?
관찰 포인트 — 바퀴 속도와 차체 속도는 선형 관계입니다. 그래서 네 바퀴에 같은 배율을 곱하면 차체 속도도 같은 배율로 줄어들 뿐 방향 · 곡률은 그대로입니다. 반면 한 바퀴만 자르면 바퀴 사이 비율이 깨져, 차체가 받는 "옆 · 회전 성분" 이 바뀌고 궤적 모양 자체가 달라집니다. 경로를 따라가야 하는 물류로봇에서는 정규화가 기본입니다.
시뮬레이터 3 에 vx = 1.0, vy = 0.5, ω = 0.8 을 넣었더니 바퀴 값이 [4.38, 35.62, 24.38, 15.62] rad/s 였습니다 (FL, FR, RL, RR). 한계 30 rad/s 에서 정규화 배율 s 와 정규화 후 FR 값은?
- s ≈ 0.842, FR = 30.0 rad/s
- s ≈ 1.187, FR = 42.3 rad/s
- s = 1, FR 만 30.0 rad/s 로 바뀜
- s ≈ 0.842, FR = 35.62 rad/s 그대로
정답 보기
① — s = 30 / 35.62 ≈ 0.842 를 네 바퀴 모두에 곱합니다. 가장 빠른 FR 이 정확히 30 rad/s 가 되고 나머지는 [3.69, 20.53, 13.16] 이 됩니다. ③ 은 "바퀴별 자르기" 입니다.같은 값에서 "바퀴별 자르기" 를 고르면 실제 차체 속도가 약 (0.930, 0.430, 0.600) 이 됩니다. 명령 (1.0, 0.5, 0.8) 과 비교한 해석으로 옳은 것은?
- 모든 성분이 같은 비율로 줄어 경로 모양은 그대로다
- 회전 ω 가 25 % 나 줄고 vx 는 7 % 만 줄어, 궤적이 명령보다 덜 휘어진다
- 자르기는 회전만 줄이고 직진 성분은 늘린다
- 차이가 없다
정답 보기
② — 비율은 vx 0.93, vy 0.86, ω 0.75 로 제각각입니다. 곡률 ω/v 가 명령(0.716)보다 작아져(약 0.586) 빨간 궤적이 회색 점선보다 덜 휘어집니다. 정규화는 세 성분이 모두 0.842 배라 곡률이 그대로입니다.4교시 · 순기구학과 미끄러짐#
순기구학: 바퀴 4개 → 차체 3개#
반대로 바퀴 엔코더가 잰 속도 4개로 차체 속도 3개를 구하는 것이 순기구학입니다. 식이 4개, 모르는 값이 3개라 식이 하나 남습니다. 네 바퀴가 서로 딱 맞지 않을 때(미끄러짐 · 측정 잡음) 가장 그럴듯한 답은 최소제곱(least squares), 즉 J 의 의사역행렬(pseudo-inverse) J⁺ 로 구합니다.
| 차체 속도 | 순기구학 (J⁺ · w 를 풀어 쓴 것) |
|---|---|
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) |
남는 식 하나는 w_FL + w_FR − w_RL − w_RR (앞 두 바퀴 합 − 뒤 두 바퀴 합)으로, 미끄러짐이 없으면 항상 0 이 되며, 바퀴 4개가 "서로 맞지 않는 정도" 를 알려 줍니다. 이 값이 0 에서 멀면 어느 바퀴가 미끄러지고 있다는 신호입니다.
미끄러짐 — 오도메트리는 실제를 모릅니다#
순기구학은 "바퀴가 돈 만큼 차체가 갔다" 고 가정합니다. 바퀴가 미끄러지면 엔코더 값은 그대로인데 차체는 덜 갑니다. 메카넘 휠은 옆으로 갈 때 롤러가 계속 구르며 힘을 대각선으로 나누어 전달하므로, 횡이동에서 미끄러짐이 가장 큽니다.
슬립 계수 s 를 정하면 실제 차체 속도를 다음처럼 줄입니다. 계수 · 프리셋 값은 경향을 보이기 위한 가정이며 실측값이 아닙니다.
- 옆 속도:
vy · (1 − s)· 앞 속도:vx · (1 − s/3)· 회전:ω · (1 − s/2) - 옆으로 갈 때 앞뒤 롤러의 미끄러짐이 달라 생기는 방향 틀어짐: 추가 회전
0.5 · s · vy(rad/s) - 바닥 프리셋: 에폭시 s = 3 % · 타일 s = 6 % · 카펫 s = 15 %
- 로봇은 엔코더(순기구학)로 "1 m 갔다" 고 판단할 때까지 0.3 m/s 로 갑니다(회전은 0.5 rad/s 로 90°).
먼저 예측하세요. 슬립 10 % 에서 "앞 1 m → 왼쪽 1 m → 뒤 1 m → 오른쪽 1 m" 정사각형을 돌면, 출발점에서 얼마나 벌어질까요? 옆으로 가는 대신 "1 m 전진 + 90° 회전" 을 4번 하면 더 정확할까요?
해 볼 것
- 슬립 0 % 에서 세 경로가 모두 출발점으로 정확히 돌아오는지 확인합니다 (오차 0.0 cm).
- 슬립 10 % · 평행이동 사각형에서 ▶ 주행 보기 를 누르고 오른쪽 패널을 봅니다. 순기구학(파랑)과 실제(빨강) 중 어느 성분이 가장 많이 다른가요?
- 같은 10 % 에서 "회전 사각형" 으로 바꿉니다. 출발점과의 거리는 평행이동 사각형보다 큰가요, 작은가요? 이유를 회전 성분에서 찾아봅니다.
- 바닥 프리셋(에폭시 · 타일 · 카펫)을 바꾸며 평행이동 사각형의 오차와 "옆 변 길이" 를 표로 적습니다.
- "옆 왕복" 을 고르고 슬립을 0 → 30 % 로 올립니다. 왕복이라 거리는 상쇄되는데 왜 오차가 0 이 아닌가요?
관찰 포인트 — 바퀴는 명령대로 돌았으므로 순기구학(엔코더) 값은 항상 계획과 똑같습니다. 로봇 스스로는 정사각형을 정확히 돌았다고 믿습니다. 실제로는 옆 변이 1 − s 만큼 짧아지고, 옆으로 갈 때 생긴 작은 방향 틀어짐이 다음 변을 비스듬하게 만들어 끝점이 벌어집니다. 회전이 들어가는 경로는 회전 슬립이 방향 오차로 쌓여 더 크게 벌어집니다. 이렇게 바퀴만 세어서 위치를 추정하는 것(오도메트리) 의 한계는 ch04 에서 본격적으로 다룹니다.
시뮬레이터 4 에서 슬립 10 % · 평행이동 사각형을 돌았더니, 오른쪽 패널의 "순기구학" 은 vy = 0.300, "실제" 는 vy = 0.270 이었습니다. 로봇의 오도메트리는 끝 위치를 어디로 계산할까요?
- 실제 끝 위치와 똑같이
- 출발점 (0, 0) — 엔코더는 바퀴가 돈 만큼만 세므로 미끄러짐을 모른다
- 옆 변이 짧아진 것을 알고 (0, −0.1)
- 계산할 수 없다
정답 보기
② — 순기구학은 바퀴 회전량만으로 계산하므로 미끄러짐이 있어도 계획과 같은 값을 냅니다. 실제 끝점은 출발점에서 약 4.8 cm 떨어져 있는데, 로봇은 이를 알지 못합니다. 이 차이를 줄이려면 IMU · 라이다 같은 다른 센서가 필요합니다.슬립 10 % 에서 평행이동 사각형의 오차는 약 4.8 cm, 회전 사각형은 약 22.3 cm 였습니다. 회전 사각형이 크게 벌어진 주된 이유는?
- 회전 사각형이 이동 거리가 더 길어서
- 90° 회전마다 회전 슬립(ω 가 5 % 덜 돎)으로 방향이 틀어지고, 그 틀어진 방향으로 다음 1 m 를 가서 오차가 쌓이므로
- 회전 사각형은 옆 이동을 하지 않아서 오차가 없어야 하는데 시뮬레이터 오류다
- 전진 슬립이 옆 슬립보다 커서
정답 보기
② — 90° × 5 % = 4.5° 씩 덜 돌아 네 번이면 약 18° 가 틀어집니다. 방향 오차는 그 뒤의 모든 이동을 비스듬하게 만들어 거리 오차보다 훨씬 크게 쌓입니다. 이동 거리는 둘 다 4 m 로 같습니다.실습 (시뮬레이터)#
교시마다 Playground 에서 시뮬레이터의 숫자를 직접 계산해 검증합니다. starter 의 TODO 를 채워 실행한 뒤, 풀이 와 비교하세요.
3D 뷰어에는 공식 agv_pro_gazebo URDF 가 들어 있습니다. 바퀴 joint 4개를 하나씩 +값으로 돌려 보며 실습 2-1 의 부호표(어느 쪽이 "앞으로" 도는 방향인가)를 확인합니다. 축이 0 1 0 이므로 +회전은 네 바퀴 모두 로봇을 앞(+x)으로 굴리는 방향입니다.
차동 로봇이 "좌회전 90° → 전진 d → 우회전 90°" 로 옆 d 만큼 가는 시간과, 전방향 로봇이 vy 로 바로 가는 시간을 계산하는 함수를 완성합니다. 옆 거리 0.25 · 0.5 · 1 · 3 m 에 대해 시간 비를 출력하고, "짧은 거리일수록 전방향이 유리한 이유" 를 한 문장으로 적어 보세요.
import math
def t_diff(d, v_max=0.5, w_max=1.0):
# 회전 2번 + 전진 d
t_turn = 0.0 # TODO: 90도(pi/2 rad) 회전 한 번의 시간
t_move = 0.0 # TODO: d 를 v_max 로 가는 시간
return 2 * t_turn + t_move
def t_omni(d, v_max=0.5):
return 0.0 # TODO: vy = v_max 로 d 를 가는 시간
for d in [0.25, 0.5, 1.0, 3.0]:
a, b = t_diff(d), t_omni(d)
ratio = a / b if b > 0 else float("nan")
print(f"d={d:4.2f} m diff {a:5.2f} s omni {b:5.2f} s ratio {ratio:4.2f}")import math
def t_diff(d, v_max=0.5, w_max=1.0):
t_turn = (math.pi / 2) / w_max
t_move = d / v_max
return 2 * t_turn + t_move
def t_omni(d, v_max=0.5):
return d / v_max
for d in [0.25, 0.5, 1.0, 3.0]:
a, b = t_diff(d), t_omni(d)
print(f"d={d:4.2f} m diff {a:5.2f} s omni {b:5.2f} s ratio {a / b:4.2f}")
# d=0.25 m diff 3.64 s omni 0.50 s ratio 7.28
# d=1.00 m diff 5.14 s omni 2.00 s ratio 2.57
# d=3.00 m diff 9.14 s omni 6.00 s ratio 1.52회전 2번(π s)은 거리와 상관없는 고정 비용이라, 선반 옆으로 0.25 m 붙는 것 같은 짧은 옆 이동에서 차동 구동은 7 배 넘게 느립니다.
차체 0.53 × 0.36 m 로봇이 제자리 회전할 때 모서리가 그리는 원의 반지름을 구하고, 선반 사이 통로 폭이 얼마 이상이어야 회전할 수 있는지 계산합니다. 통로 폭 0.6 · 0.7 · 0.8 m 에서 회전 가능 여부를 출력하세요.
import math
L, W = 0.53, 0.36
def turn_radius(L, W):
return 0.0 # TODO: 중심에서 모서리까지 거리
def can_turn(aisle):
return False # TODO: 통로 폭이 지름 이상인가
R = turn_radius(L, W)
print(f"turn radius {R:.3f} m -> need aisle >= {2 * R:.3f} m")
for aisle in [0.6, 0.7, 0.8]:
print(f"aisle {aisle:.1f} m : diff {'turn OK' if can_turn(aisle) else 'CANNOT turn'}, omni always OK (vy)")import math
L, W = 0.53, 0.36
def turn_radius(L, W):
return math.hypot(L / 2, W / 2)
def can_turn(aisle):
return aisle >= 2 * turn_radius(L, W)
R = turn_radius(L, W)
print(f"turn radius {R:.3f} m -> need aisle >= {2 * R:.3f} m")
for aisle in [0.6, 0.7, 0.8]:
print(f"aisle {aisle:.1f} m : diff {'turn OK' if can_turn(aisle) else 'CANNOT turn'}, omni always OK (vy)")
# turn radius 0.320 m -> need aisle >= 0.641 m실제 운용에서는 여기에 안전 여유를 더합니다. 시뮬레이터 1 의 "최소 간격 0.14 m" 는 (0.320 − 0.18) 과 같은 값입니다.
시뮬레이터 2 에서 찾은 패턴을 코드로 확인합니다. 각 바퀴가 "앞으로" 돌 때 차체에 주는 대각선 방향 (1, s_i) 와 회전 기여 c_i 를 채우면, 원하는 움직임 10가지의 바퀴 부호(+/−/0)를 출력합니다.
import numpy as np
r, k = 0.05, 0.3514
# 바퀴 순서: FL, FR, RL, RR
# 행 하나 = 바퀴 하나: w = (vx + s*vy + c*k*w) / r
s = np.array([0, 0, 0, 0]) # TODO: 왼쪽 옆 이동 패턴의 부호 (FL - , FR + , RL + , RR -)
c = np.array([0, 0, 0, 0]) # TODO: 반시계 회전 패턴의 부호
J = np.column_stack([np.ones(4), s, c * k]) / r
motions = {
"forward": (1, 0, 0), "backward": (-1, 0, 0),
"left": (0, 1, 0), "right": (0, -1, 0),
"front-left": (1, 1, 0), "front-right": (1, -1, 0),
"back-left": (-1, 1, 0), "back-right": (-1, -1, 0),
"rotate CCW": (0, 0, 1), "rotate CW": (0, 0, -1),
}
def sign(x):
return "+" if x > 1e-9 else "-" if x < -1e-9 else "0"
print(f"{'motion':12s} FL FR RL RR")
for name, v in motions.items():
w = J @ np.array(v, dtype=float)
print(f"{name:12s} " + " ".join(sign(x) for x in w))import numpy as np
r, k = 0.05, 0.3514
s = np.array([-1, 1, 1, -1])
c = np.array([-1, 1, -1, 1])
J = np.column_stack([np.ones(4), s, c * k]) / r
motions = {
"forward": (1, 0, 0), "backward": (-1, 0, 0),
"left": (0, 1, 0), "right": (0, -1, 0),
"front-left": (1, 1, 0), "front-right": (1, -1, 0),
"back-left": (-1, 1, 0), "back-right": (-1, -1, 0),
"rotate CCW": (0, 0, 1), "rotate CW": (0, 0, -1),
}
def sign(x):
return "+" if x > 1e-9 else "-" if x < -1e-9 else "0"
print(f"{'motion':12s} FL FR RL RR")
for name, v in motions.items():
w = J @ np.array(v, dtype=float)
print(f"{name:12s} " + " ".join(sign(x) for x in w))
# front-left 0 + + 0 <- 대각선은 바퀴 2개만
# front-right + 0 0 + <- FL, RR 만 (예측 문제의 답)
# rotate CCW - + - + <- 왼쪽 두 바퀴 -, 오른쪽 두 바퀴 +대각선 이동에서 0 이 되는 두 바퀴는 그 방향과 수직인 대각선을 맡는 바퀴입니다.
시뮬레이터 2 에서 바퀴를 하나만 돌리면 차체는 이동과 회전을 동시에 합니다. FL 만 +10 rad/s 일 때 차체 속도 (vx, vy, ω) 와, 그 운동이 그리는 원의 반지름 |v| / |ω| 를 계산해 시뮬레이터 2 의 궤적과 비교하세요.
import numpy as np
r, k = 0.05, 0.3514
s = np.array([-1, 1, 1, -1])
c = np.array([-1, 1, -1, 1])
def body_twist(w):
w = np.asarray(w, dtype=float)
vx = 0.0 # TODO: r/4 * (네 바퀴 합)
vy = 0.0 # TODO: r/4 * (s 로 부호 붙인 합)
om = 0.0 # TODO: r/(4k) * (c 로 부호 붙인 합)
return vx, vy, om
vx, vy, om = body_twist([10, 0, 0, 0])
v = np.hypot(vx, vy)
print(f"vx {vx:.3f} vy {vy:.3f} w {om:.3f} rad/s")
if abs(om) > 1e-9:
print(f"circle radius {v / abs(om):.3f} m, direction", "CCW" if om > 0 else "CW")import numpy as np
r, k = 0.05, 0.3514
s = np.array([-1, 1, 1, -1])
c = np.array([-1, 1, -1, 1])
def body_twist(w):
w = np.asarray(w, dtype=float)
vx = r / 4 * w.sum()
vy = r / 4 * (s @ w)
om = r / (4 * k) * (c @ w)
return vx, vy, om
vx, vy, om = body_twist([10, 0, 0, 0])
v = np.hypot(vx, vy)
print(f"vx {vx:.3f} vy {vy:.3f} w {om:.3f} rad/s")
if abs(om) > 1e-9:
print(f"circle radius {v / abs(om):.3f} m, direction", "CCW" if om > 0 else "CW")
# vx 0.125 vy -0.125 w -0.356 rad/s
# circle radius 0.497 m, direction CWFL 의 힘은 오른쪽 앞 대각선이고, 중심 왼쪽 앞에서 밀기 때문에 시계 방향 돌림힘도 생깁니다. 그래서 약 0.5 m 반지름의 원을 시계 방향으로 돕니다.
(vx, vy, ω) 를 넣으면 바퀴 4개 rad/s 를 돌려주는 함수를 numpy 행렬로 만듭니다. 시뮬레이터 3 의 값과 같은지 세 경우로 확인하세요.
import numpy as np
LX, LY, R = 0.1715, 0.1799, 0.05 # URDF 값, 반지름은 Gazebo 기준 (실물 확인 필요)
K = LX + LY
# 행: FL, FR, RL, RR / 열: vx, vy, w
J = np.array([
[1, -1, -K],
[1, 1, K],
[0, 0, 0], # TODO: RL 행
[0, 0, 0], # TODO: RR 행
]) / R
def inverse_kinematics(vx, vy, om):
return J @ np.array([vx, vy, om])
for cmd in [(0.5, 0, 0), (0, 0.5, 0), (0, 0, 1.0)]:
w = inverse_kinematics(*cmd)
print(cmd, "->", np.round(w, 2))import numpy as np
LX, LY, R = 0.1715, 0.1799, 0.05
K = LX + LY
J = np.array([
[1, -1, -K],
[1, 1, K],
[1, 1, -K],
[1, -1, K],
]) / R
def inverse_kinematics(vx, vy, om):
return J @ np.array([vx, vy, om])
for cmd in [(0.5, 0, 0), (0, 0.5, 0), (0, 0, 1.0)]:
w = inverse_kinematics(*cmd)
print(cmd, "->", np.round(w, 2))
# (0.5, 0, 0) -> [10. 10. 10. 10.]
# (0, 0.5, 0) -> [-10. 10. 10. -10.]
# (0, 0, 1.0) -> [-7.03 7.03 -7.03 7.03]ω = 1 rad/s 회전에 바퀴가 (lx+ly)/r ≈ 7.03 rad/s 씩 돕니다.
vx = 1.0, vy = 0.5, ω = 0.8 에서 30 rad/s 를 넘는 바퀴를 찾고, 정규화 · 자르기 두 방법으로 처리한 뒤 3 초 동안의 궤적 끝점을 비교합니다. 정규화 끝점이 명령 궤적 위에 있는지(곡률이 같은지) 확인하세요.
import numpy as np
R, K, W_MAX = 0.05, 0.3514, 30.0
J = np.array([[1, -1, -K], [1, 1, K], [1, 1, -K], [1, -1, K]]) / R
J_pinv = np.linalg.pinv(J)
NAMES = ["FL", "FR", "RL", "RR"]
def normalize(w, w_max=W_MAX):
# TODO: 가장 큰 |w| 가 w_max 를 넘으면 모두에 같은 배율을 곱한다
return w
def clip(w, w_max=W_MAX):
return np.clip(w, -w_max, w_max)
def rollout(twist, T=3.0, dt=0.01):
x = y = th = 0.0
vx, vy, om = twist
for _ in range(int(round(T / dt))):
x += (vx * np.cos(th) - vy * np.sin(th)) * dt
y += (vx * np.sin(th) + vy * np.cos(th)) * dt
th += om * dt
return np.array([x, y, th])
cmd = np.array([1.0, 0.5, 0.8])
w = J @ cmd
print("wheels", np.round(w, 2), "saturated:", [n for n, x in zip(NAMES, w) if abs(x) > W_MAX])
for name, wa in [("command", w), ("clip", clip(w)), ("normalize", normalize(w))]:
tw = J_pinv @ wa
curv = tw[2] / np.hypot(tw[0], tw[1])
print(f"{name:9s} twist {np.round(tw, 3)} curvature {curv:.3f} end {np.round(rollout(tw), 3)}")import numpy as np
R, K, W_MAX = 0.05, 0.3514, 30.0
J = np.array([[1, -1, -K], [1, 1, K], [1, 1, -K], [1, -1, K]]) / R
J_pinv = np.linalg.pinv(J)
NAMES = ["FL", "FR", "RL", "RR"]
def normalize(w, w_max=W_MAX):
m = np.max(np.abs(w))
return w * (w_max / m) if m > w_max else w
def clip(w, w_max=W_MAX):
return np.clip(w, -w_max, w_max)
def rollout(twist, T=3.0, dt=0.01):
x = y = th = 0.0
vx, vy, om = twist
for _ in range(int(round(T / dt))):
x += (vx * np.cos(th) - vy * np.sin(th)) * dt
y += (vx * np.sin(th) + vy * np.cos(th)) * dt
th += om * dt
return np.array([x, y, th])
cmd = np.array([1.0, 0.5, 0.8])
w = J @ cmd
print("wheels", np.round(w, 2), "saturated:", [n for n, x in zip(NAMES, w) if abs(x) > W_MAX])
for name, wa in [("command", w), ("clip", clip(w)), ("normalize", normalize(w))]:
tw = J_pinv @ wa
curv = tw[2] / np.hypot(tw[0], tw[1])
print(f"{name:9s} twist {np.round(tw, 3)} curvature {curv:.3f} end {np.round(rollout(tw), 3)}")
# saturated: ['FR'] (35.62 rad/s)
# command curvature 0.716
# clip curvature 0.586 <- 덜 휘어짐, 다른 길
# normalize curvature 0.716 <- 같은 길, 속도만 0.842 배정규화는 곡률이 명령과 같아서 끝점이 명령 궤적 위(조금 덜 간 지점)에 있습니다. 자르기는 곡률이 달라 다른 원 위로 갑니다.
np.linalg.pinv(J) 가 위 표의 순기구학 식(r/4, r/(4k))과 같은지 확인하고, 바퀴 하나가 미끄러져 엔코더 값이 서로 맞지 않을 때 최소제곱 답과 "남는 식(불일치)" 을 계산합니다.
import numpy as np
R, K = 0.05, 0.3514
J = np.array([[1, -1, -K], [1, 1, K], [1, 1, -K], [1, -1, K]]) / R
J_pinv = None # TODO: 의사역행렬
F = np.array([
[ 1, 1, 1, 1],
[-1, 1, 1, -1],
[-1 / K, 1 / K, -1 / K, 1 / K],
]) * R / 4
print("pinv == formula ?", J_pinv is not None and np.allclose(J_pinv, F))
w_true = J @ np.array([0.0, 0.3, 0.0]) # 왼쪽 옆 0.3 m/s
w_meas = w_true.copy()
w_meas[0] *= 0.8 # FL 이 20% 덜 돈 것처럼 측정됨
mismatch = 0.0 # TODO: w_FL + w_FR - w_RL - w_RR
print("wheels", np.round(w_meas, 2))
if J_pinv is not None:
print("least-squares twist", np.round(J_pinv @ w_meas, 4))
print("mismatch", round(mismatch, 3))import numpy as np
R, K = 0.05, 0.3514
J = np.array([[1, -1, -K], [1, 1, K], [1, 1, -K], [1, -1, K]]) / R
J_pinv = np.linalg.pinv(J)
F = np.array([
[ 1, 1, 1, 1],
[-1, 1, 1, -1],
[-1 / K, 1 / K, -1 / K, 1 / K],
]) * R / 4
print("pinv == formula ?", np.allclose(J_pinv, F))
w_true = J @ np.array([0.0, 0.3, 0.0])
w_meas = w_true.copy()
w_meas[0] *= 0.8
mismatch = w_meas[0] + w_meas[1] - w_meas[2] - w_meas[3]
print("wheels", np.round(w_meas, 2))
print("least-squares twist", np.round(J_pinv @ w_meas, 4))
print("mismatch", round(mismatch, 3))
# pinv == formula ? True
# least-squares twist [ 0.015 0.285 -0.0427] <- 없던 vx, ω 가 섞여 나옴
# mismatch 1.2 (정상이면 0)바퀴 하나의 오차가 vx · vy · ω 세 성분에 골고루 퍼집니다. 불일치 값이 0 이 아니면 "어딘가 미끄러짐" 이라는 경고로 쓸 수 있습니다.
시뮬레이터 4 와 같은 미끄러짐 모델로 1 m 정사각형 두 가지(평행이동 · 회전)를 돌아 출발점과의 거리를 계산합니다. 슬립 0 · 3 · 6 · 10 · 15 % 표를 만들고 시뮬레이터 값과 비교하세요.
import numpy as np
V, WR, NS = 0.3, 0.5, 200
def legs(mode):
if mode == "trans":
return [(V, 0, 0, 1 / V), (0, V, 0, 1 / V), (-V, 0, 0, 1 / V), (0, -V, 0, 1 / V)]
out = []
for _ in range(4):
out += [(V, 0, 0, 1 / V), (0, 0, WR, (np.pi / 2) / WR)]
return out
def run(mode, s):
x = y = th = 0.0
for vx, vy, om, T in legs(mode):
dt = T / NS
for _ in range(NS):
ax = vx # TODO: 앞 슬립 s/3 반영
ay = vy # TODO: 옆 슬립 s 반영
aw = om # TODO: 회전 슬립 s/2 + 방향 틀어짐 0.5*s*vy
x += (ax * np.cos(th) - ay * np.sin(th)) * dt
y += (ax * np.sin(th) + ay * np.cos(th)) * dt
th += aw * dt
return x, y, th
print(" slip trans(cm) rot(cm)")
for s in [0, 0.03, 0.06, 0.10, 0.15]:
e1 = np.hypot(*run("trans", s)[:2]) * 100
e2 = np.hypot(*run("rot", s)[:2]) * 100
print(f"{s * 100:4.0f}% {e1:7.1f} {e2:7.1f}")import numpy as np
V, WR, NS = 0.3, 0.5, 200
def legs(mode):
if mode == "trans":
return [(V, 0, 0, 1 / V), (0, V, 0, 1 / V), (-V, 0, 0, 1 / V), (0, -V, 0, 1 / V)]
out = []
for _ in range(4):
out += [(V, 0, 0, 1 / V), (0, 0, WR, (np.pi / 2) / WR)]
return out
def run(mode, s):
x = y = th = 0.0
for vx, vy, om, T in legs(mode):
dt = T / NS
for _ in range(NS):
ax = vx * (1 - s / 3)
ay = vy * (1 - s)
aw = om * (1 - s / 2) + 0.5 * s * vy
x += (ax * np.cos(th) - ay * np.sin(th)) * dt
y += (ax * np.sin(th) + ay * np.cos(th)) * dt
th += aw * dt
return x, y, th
print(" slip trans(cm) rot(cm)")
for s in [0, 0.03, 0.06, 0.10, 0.15]:
e1 = np.hypot(*run("trans", s)[:2]) * 100
e2 = np.hypot(*run("rot", s)[:2]) * 100
print(f"{s * 100:4.0f}% {e1:7.1f} {e2:7.1f}")슬립 10 % 에서 평행이동 사각형은 약 4.8 cm, 회전 사각형은 약 22 cm 벌어집니다. 오도메트리는 두 경우 모두 "오차 0" 이라고 믿습니다.
창고 시뮬레이터로 확인하기#
지금까지 numpy 로 계산한 역기구학 · 미끄러짐을 공식 URDF 로 만든 3D 시뮬레이터에서 눈으로 확인합니다. 시뮬레이터는 이 차시의 식(lx = 0.1715, ly = 0.1799, r = 0.05)으로 바퀴 속도를 계산하고, 오른쪽 바퀴 (역기구학) 표에 실시간으로 보여 줍니다.
먼저 예측하세요. A(왼쪽 옆 이동)를 누르고 있을 때 바퀴 표의 FL · FR · RL · RR 부호는 각각 어떻게 될까요? 3교시의 표에 vx = 0, vy = +0.4, ω = 0 을 넣어 종이에 먼저 적습니다.
- 전원 켜기 → 화면을 한 번 누르고
A를 누른 채 바퀴 표를 읽습니다. 예측과 같나요? Q(제자리 왼쪽 회전)도 같은 방법으로 예측 → 확인합니다.W와A를 함께 누르면 대각선으로 갑니다. 이때 0 에 가까워지는 바퀴 두 개는 어느 것이고, 왜 그럴까요?
확인
A: FL −, FR +, RL +, RR − (크기 8 rad/s). Q(0.5 rad/s): FL −, FR +, RL −, RR + (크기 약 3.5 rad/s). W+A: vx = vy 이므로 FL · RR 은 vx − vy = 0 — 롤러 방향 때문에 두 바퀴는 쉬고 FR · RL 만 대각선으로 밉니다.agvsim.cmd_vel(vx, vy, w) 는 세 속도를 한 번에 거는 시뮬레이터 전용 함수입니다 (실물에서는 ROS 2 /cmd_vel 이 같은 역할 — ch09). 시뮬레이터가 보고한 바퀴 속도와 내 역기구학 함수의 값이 같은지 비교합니다.
from pymycobot import MyAGVPro
import agvsim, time
LX, LY, R = 0.1715, 0.1799, 0.05
K = LX + LY
def ik(vx, vy, w):
# TODO: 3교시 표대로 FL, FR, RL, RR 순서의 바퀴 각속도(rad/s)를 돌려주세요
return [0.0, 0.0, 0.0, 0.0]
agv = MyAGVPro("/dev/agvpro_controller", baudrate=1000000)
if agv.is_power_on() != 1:
agv.power_on()
for vx, vy, w in [(0.3, 0, 0), (0, 0.3, 0), (0, 0, 0.5), (0.2, 0.2, 0.3)]:
agvsim.cmd_vel(vx, vy, w)
time.sleep(1.0) # 가속이 끝날 때까지 기다림
sim = agvsim.get_wheel_speeds()
mine = [round(v, 2) for v in ik(vx, vy, w)]
print((vx, vy, w), "sim", sim, "mine", mine)
agv.stop()
agvsim.stop()풀이
`return [(vx - vy - K*w)/R, (vx + vy + K*w)/R, (vx + vy - K*w)/R, (vx - vy + K*w)/R]` — 네 경우 모두 시뮬레이터 값과 소수 둘째 자리까지 같습니다. 바퀴 속도가 ±30 rad/s 를 넘는 명령을 넣어 보면, 이 시뮬레이터는 포화를 처리하지 않고 공식 속도 상한(앞뒤 1.5, 옆 1.0 m/s)만 자릅니다 — 실습 3 의 정규화가 왜 필요한지 생각해 보세요.패널의 바퀴 미끄러짐 을 10 % 로 올리고, 키보드로 1 m 사각형을 (가) 옆 이동만으로, (나) 전진 + 90° 회전으로 한 바퀴 돕니다. 화면의 초록(참값)과 주황(오도메트리) 궤적이 어느 쪽에서 더 벌어지는지, HUD 의 오차 값으로 기록합니다. 4교시 실습의 계산(약 4.8 cm vs 22 cm)과 경향이 맞나요?
자주 나는 오류와 해결#
1) 옆으로 가라고 했는데 제자리에서 돈다#
cmd (0, 0.3, 0) -> robot rotates CCW instead of moving left- 원인: 바퀴 순서 매핑이 틀렸습니다. 특히 URDF 의
right_front_wheel_joint(실제 왼쪽 뒤) ·left_rear_wheel_joint(실제 오른쪽 앞) 처럼 이름과 위치가 엇갈린 바퀴를 이름대로 매핑하면, 옆 이동 패턴(− + + −)이 회전 패턴(− + − +)으로 바뀝니다. - 해결: 바퀴는 origin 좌표의 부호로 FL · FR · RL · RR 을 정하고, 실습 2-1 부호표로 "왼쪽 옆" 과 "반시계 회전" 을 각각 시험합니다.
2) 옆 이동 방향이 반대로 나온다#
- 원인: 메카넘 휠의 왼손 · 오른손 바퀴를 바꿔 끼웠거나(롤러 방향이 반대), 식의
vy부호를 다른 좌표 관례(y 오른쪽)로 썼습니다. 직진은 정상이라 발견이 늦습니다. - 해결: 위에서 보이는 롤러 무늬가 아니라 힘 방향으로 확인합니다 — 바퀴 하나만 앞으로 돌렸을 때 FL · RR 은 오른쪽 앞, FR · RL 은 왼쪽 앞으로 가야 합니다. ROS 관례는 y 가 왼쪽입니다.
3) 회전 속도가 엄청 빠르거나 느리다#
cmd w=90 -> wheels [-632.6 632.6 -632.6 632.6] rad/s- 원인:
ω자리에 도(°/s)를 넣었습니다(90 → 90 rad/s). 또는lx + ly대신lx하나만, 혹은 바퀴 간격 전체(0.36 m)를 넣었습니다. - 해결:
np.deg2rad()로 바꾸고, 회전 팔은 중심 → 바퀴 거리 두 개의 합lx + ly = 0.3514 m를 씁니다.
4) 바퀴 속도를 모터에 넣었더니 너무 느리다 / 빠르다#
- 원인: 역기구학 결과는 rad/s 인데, 드라이버가 rpm 이나 m/s 를 받습니다. 1 rad/s = 60 / (2π) ≈ 9.55 rpm, 바퀴 둘레 속도는
w · rm/s 입니다. 반지름r을 실물과 다르게 넣어도 같은 증상입니다. - 해결: 드라이버 단위를 확인하고 변환합니다. 반지름은 10 바퀴 굴린 거리 ÷ (10 · 2π) 로 실측합니다.
5) 정규화했는데도 경로가 휜다#
normalize: s = -0.842 -> robot goes backward- 원인: 최댓값을
max(w)로 구해 음수 바퀴를 놓쳤거나, 부호가 있는 값으로 나눴습니다. 또는 한 바퀴만 정규화했습니다. - 해결:
m = np.max(np.abs(w))로 크기의 최댓값을 구하고,m > w_max일 때만 네 바퀴 모두에w_max / m을 곱합니다.
6) 의사역행렬 계산에서 모양 오류#
ValueError: matmul: Input operand 1 has a mismatch in its core dimension 0, with gufunc signature (n?,k),(k,m?)->(n?,m?) (size 3 is different from 4)- 원인: 순기구학에
J @ w(4×3 · 4) 를 썼습니다.J는 차체 → 바퀴 방향입니다. - 해결: 바퀴 → 차체는
np.linalg.pinv(J) @ w(3×4 · 4 → 3) 입니다. 모양을J.shape,w.shape로 먼저 출력해 확인합니다.
과제#
- 부호표 카드: 실습 2-1 의 10가지 움직임 부호표를 카드로 만들고, 각 칸 옆에 시뮬레이터 2 의 힘 화살표 스케치를 붙입니다. "대각선은 왜 바퀴 2개만 도는가" 를 한 문장으로 적습니다.
- 통로 설계 메모: 실습 1-1 · 1-2 결과로 "선반 간격이 0.10 m 인 통로에서 차동 구동 대신 전방향 구동을 써야 하는 이유" 를 시간 · 공간 두 측면에서 3줄로 씁니다.
- 포화 보고서: 시뮬레이터 3 에서 실습 값의 자르기 · 정규화 궤적을 캡처하고, 곡률(0.586 vs 0.716)의 차이를 근거로 어떤 방법을 쓸지 결론을 적습니다.
- 바닥별 오차표: 실습 4-2 를 확장해 에폭시 · 타일 · 카펫 프리셋에서 두 정사각형의 오차표를 만들고, "횡이동이 많은 경로는 어떤 바닥에서 피해야 하는가" 를 정리합니다 (가정 모델임을 명시).
참고자료#
- myAGV Pro 공식 문서: https://docs.elephantrobotics.com/docs/myAGV_Pro_en/
- Basic Edition 사양 (속도 · 크기): https://docs.elephantrobotics.com/docs/myAGV_Pro_en/2-ProductFeature/2.1-BasicEdition.html
- Python API (횡이동 · 회전 명령의 속도 범위): https://docs.elephantrobotics.com/docs/myAGV_Pro_en/6-SDKDevelopment/6.1-ApplicationBasePython/6.1.2-API.html
- 제품 페이지: https://www.elephantrobotics.com/en/myagv-pro/
- 제품 소개 · 이미지 (현영이앤씨): https://www.hyenc.net/products/36
- ROS 2 패키지 · URDF: https://github.com/elephantrobotics/agv_pro_ros2 (
agv_pro_description/urdf/agv_pro.urdf— 바퀴 joint origin) - ROS 좌표 관례 REP-103: https://www.ros.org/reps/rep-0103.html
- 메카넘 휠 기구학 해설: H. Taheri, B. Qiao, N. Ghaeminezhad, "Kinematic Model of a Four Mecanum Wheeled Mobile Robot", International Journal of Computer Applications, 113(3), 2015.
- K. M. Lynch, F. C. Park, Modern Robotics, 13장 "Wheeled Mobile Robots" (홀로노믹 · 비홀로노믹, 전방향 로봇의 기구학): http://hades.mech.northwestern.edu/index.php/Modern_Robotics
- 이 사이트의 도구: 3D 뷰어 · Playground
- 앞 차시: ch01 myAGV Pro 둘러보기 · 다음 차시: ch03 Python 으로 움직이기