전체 과정 P1 로봇과 첫 만남 — 구조와 움직임 · 약 200분 · 중급

CH02전방향 휠 기구학 — 옆으로 가는 로봇의 비밀

메카넘(전방향) 휠 4개가 각자 속도를 내면 차체가 어떻게 움직이는지, 역기구학 · 순기구학 식을 시뮬레이터로 발견합니다.

선수 챕터: CH01

학습 목표#

  • 차동 구동 로봇이 옆으로 바로 갈 수 없는 이유(비홀로노믹 구속)를 설명하고, 같은 "옆 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 magv_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 m, 방향은 그대로" — 차동 구동 vs 전방향 구동 (위에서 본 그림, 위쪽이 로봇 앞) ① 차동 구동 (좌/우 바퀴 속도차) 선반 선반 제자리 회전이 쓸고 가는 원 (지름 0.64 m) 1) 왼쪽 90° 회전 → 2) 1 m 전진 → 3) 오른쪽 90° 회전 옆으로 바로 갈 수 없어 3 동작 (vy = 0 구속) ② 전방향 구동 (myAGV Pro, 메카넘 휠) vy 만 주면 한 동작으로 평행이동 vx · vy · ω 를 독립적으로 고름 (홀로노믹) 선반과 간격이 좁아도 회전 원이 필요 없음
같은 "왼쪽 1 m 평행이동" 목표. 차동 구동은 회전-전진-회전 세 동작이 필요하고, 제자리 회전이 쓸고 가는 원이 선반에 닿을 수 있습니다.

시뮬레이터 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°" 를 하면 어떻게 될까요? 전방향 로봇보다 몇 배 오래 걸릴까요?

시뮬레이터 1 · 차동 구동 vs 전방향 구동 — 목표: 왼쪽 1 m, 방향 그대로 (위쪽이 로봇 앞)
차동 로봇 명령 추가:

해 볼 것

  1. 버튼으로 차동 로봇이 목표(점선 상자)에 정확히 도착하는 순서를 직접 만들어 봅니다. "목표 도달" 이 나오는 가장 짧은 순서는 동작 몇 개인가요?
  2. 기본값(0.5 m/s · 1.0 rad/s)에서 차동/전방향 시간 비를 읽습니다. 그다음 최고 회전 속도만 2.0 rad/s 로 올리면 비는 얼마까지 줄어드나요?
  3. 선반과의 간격을 0.20 → 0.10 m 로 줄이고 다시 실행합니다. 차동 로봇은 언제 빨개지나요? 전방향 로봇은?
  4. 간격 슬라이더를 천천히 움직여 차동 로봇이 충돌하지 않는 최소 간격을 찾고, 0.32 − 0.18 = 0.14 m 와 비교합니다.
  5. 좌회전 45° 를 섞어 "비스듬히 가는" 순서도 만들어 봅니다. 회전을 줄이면 시간은 줄지만 무엇이 생기나요?

관찰 포인트 — 차동 구동은 옆으로 가려면 회전이 반드시 두 번 들어갑니다(가는 방향으로 돌기, 원래 방향으로 돌아오기). 회전 시간 2 × (π/2) / ω_max 는 거리와 상관없이 붙는 고정 비용이고, 제자리 회전은 차체 대각선 반지름(0.32 m)만큼의 빈 공간을 요구합니다. 전방향 구동은 vy 하나로 끝나므로 시간도 공간도 덜 듭니다. 좁은 창고 통로에서 선반 옆에 붙는 동작이 전방향 휠을 쓰는 가장 큰 이유입니다.

확인 문제 1-1

시뮬레이터 1 기본값(최고 직진 0.5 m/s, 최고 회전 1.0 rad/s)에서 "좌회전 90° → 전진 1 m → 우회전 90°" 를 실행하면 차동 로봇의 시간은 약 5.14 s, 전방향 로봇은 2.00 s 입니다. 차이 3.14 s 는 어디서 왔을까요?

  1. 차동 로봇이 더 느린 속도로 전진해서
  2. 90° 회전 두 번 (π/2 ÷ 1.0 rad/s × 2 = π s)
  3. 전방향 로봇이 대각선으로 지름길을 가서
  4. 차동 로봇의 바퀴가 2개뿐이라 출력이 약해서
정답 보기② — 전진 1 m 는 두 로봇 모두 0.5 m/s 로 2 s 입니다. 차동 로봇에만 회전 2번(각 π/2 ÷ 1.0 = 1.57 s)이 붙어 π ≈ 3.14 s 가 더 걸립니다. 이 회전 비용은 이동 거리가 짧을수록 비율이 커집니다.
확인 문제 1-2

선반과의 간격을 0.10 m 로 줄였더니 차동 로봇이 첫 회전 중에 빨갛게 변했습니다. 가장 알맞은 해석은?

  1. 회전 속도가 너무 빨라서 미끄러졌다
  2. 제자리 회전에는 반지름 약 0.32 m 공간이 필요한데, 중심에서 선반까지는 0.18 + 0.10 = 0.28 m 뿐이다
  3. 차동 로봇은 원래 선반 근처에서 움직일 수 없다
  4. 목표 위치가 선반 안쪽에 있어서
정답 보기② — 회전하면 차체 모서리가 중심에서 √(0.265² + 0.18²) ≈ 0.32 m 까지 나갑니다. 간격이 0.14 m 보다 좁으면 제자리 회전 자체가 불가능합니다. 전방향 로봇은 회전 없이 vy 로만 움직이므로 간격과 상관없이 목표에 갑니다.

2교시 · 메카넘 휠의 롤러와 힘의 방향#

45° 롤러 — 힘은 대각선으로만 전달됩니다#

메카넘 휠(Mecanum wheel)은 바퀴 둘레에 작은 롤러가 45° 기울어져 달려 있습니다. 롤러는 자기 축 방향으로는 자유롭게 굴러가 버리므로, 바퀴가 바닥을 밀어도 힘은 롤러 축에 수직인 대각선 방향으로만 차체에 전달됩니다.

바닥에 닿는 롤러의 축이 만드는 X — 바퀴가 앞으로 돌 때 차체가 받는 힘의 방향 앞 (x) FL 왼쪽 앞FR 오른쪽 앞 RL 왼쪽 뒤RR 오른쪽 뒤 읽는 법 바닥에 닿은 롤러의 축 (아래에서 본 방향) 바퀴를 "앞으로" 돌릴 때 차체가 받는 힘 · 롤러는 축 방향으로 자유롭게 굴러 힘은 축에 수직인 대각선으로만 전달됩니다. · FL · RR → 오른쪽 앞 대각선 (1, −1) · FR · RL → 왼쪽 앞 대각선 (1, +1) · 네 힘의 옆 성분은 서로 상쇄 → 앞으로 직진 · 위에서 보이는 롤러 무늬는 이와 거울 대칭이라 문헌마다 "X 배치 / O 배치" 이름이 엇갈립니다. 이름보다 힘 방향으로 확인하세요.
바닥에 닿는 롤러의 축 4개는 차체 중심을 지나는 X 를 이룹니다. 바퀴를 앞으로 돌리면 FL · RR 은 오른쪽 앞, FR · RL 은 왼쪽 앞 대각선으로 차체를 밉니다.

바퀴 하나가 차체에 주는 효과는 두 가지입니다.

  • 밀기(병진): 대각선 방향 (1, ∓1) 의 힘.
  • 돌리기(회전): 그 힘이 차체 중심에서 떨어진 곳에 작용하므로 생기는 돌림힘(토크). 팔 길이는 결국 lx + ly 로 정리됩니다.

네 바퀴의 힘을 더한 합력의 방향으로 차체가 가고, 돌림힘의 합만큼 돕니다. 어떤 패턴이 어떤 움직임을 만드는지는 직접 조작해서 찾아봅니다.

시뮬레이터 2 · 바퀴 힘 화살표#

이 시뮬레이터의 모델
  • 왼쪽: 차체 확대도. 파란 빗금은 바닥에 닿은 롤러의 축, 주황 화살표는 각 바퀴가 차체에 주는 힘(바퀴 속도에 비례), 초록 화살표는 합력(= 차체 속도 방향), 보라 호는 회전.
  • 오른쪽: 4 × 4 m 바닥에서 실제로 움직이는 모습 (위쪽이 출발 시 로봇 앞). 차체 속도는 3교시의 순기구학 식으로 계산합니다 (r = 0.05 m, lx + ly = 0.3514 m, 미끄러짐 없음).
  • 바퀴 속도 + 는 그 바퀴가 로봇을 앞으로 굴리는 방향입니다.

먼저 예측하세요. 왼쪽 앞(FL)과 오른쪽 뒤(RR) 바퀴만 +10 rad/s 로 돌리고 나머지는 0 이면, 로봇은 어느 방향으로 갈까요? 돌기도 할까요?

시뮬레이터 2 · 바퀴 4개 속도 → 바퀴별 힘 · 합력 · 실제 움직임

해 볼 것

  1. 예측 문제 버튼(FL · RR 만 +10)을 누릅니다. 예측과 같은 방향인가요? 보라 회전 호가 나타나나요?
  2. 네 바퀴를 모두 + 로 놓아 직진을 확인한 뒤, 두 바퀴의 부호만 바꿔서 왼쪽 옆으로 가는 패턴을 찾습니다. 어느 두 바퀴인가요?
  3. 제자리에서 반시계 방향으로 도는 패턴을 찾습니다. 왼쪽 두 바퀴와 오른쪽 두 바퀴의 부호가 어떤가요? (차동 구동과 비교)
  4. 직진 패턴(모두 +10)에서 FR 만 +20 으로 올립니다. 합력은 어디로 기울고, 회전은 어느 쪽으로 생기나요?
  5. 실습 2-1 의 부호표 10칸(8방향 + 회전 2)을 이 시뮬레이터로 모두 채웁니다.

관찰 포인트 — 주황 화살표의 옆 성분이 서로 상쇄되면 앞뒤로, 앞뒤 성분이 상쇄되면 옆으로 갑니다. FL · RR 은 같은 대각선 (1, −1), FR · RL 은 반대 대각선 (1, +1) 을 맡습니다. 그래서 대각선 이동은 바퀴 2개만 돌리고 나머지 2개는 0 입니다. 회전은 왼쪽 두 바퀴와 오른쪽 두 바퀴가 반대로 도는 것으로, 차동 구동의 제자리 회전과 같은 원리입니다.

확인 문제 2-1

시뮬레이터 2 에서 FL · RR 만 +10 rad/s 로 돌렸더니 초록 합력이 오른쪽 앞 45° 를 가리키고, 회전(ω)은 0 이었습니다. 회전이 생기지 않은 이유는?

  1. 바퀴가 2개만 돌아서 힘이 약하기 때문
  2. FL 과 RR 은 차체 중심에 대해 서로 반대편에 있어, 같은 방향의 힘이 만드는 돌림힘이 크기는 같고 방향은 반대라 상쇄되기 때문
  3. 메카넘 휠은 원래 회전을 만들 수 없기 때문
  4. 앞바퀴만 회전을 만들 수 있기 때문
정답 보기② — FL(+lx, +ly) 의 힘 (1, −1) 은 시계 방향, RR(−lx, −ly) 의 같은 힘은 반시계 방향 돌림힘을 만듭니다. 둘이 상쇄되어 ω = 0 이고, 합력만 남아 오른쪽 앞 대각선(vx = vy 크기 0.25 m/s)으로 갑니다.
확인 문제 2-2

시뮬레이터에서 왼쪽 옆 이동 패턴을 찾았더니 "FL − · FR + · RL + · RR −" 였습니다. 그렇다면 오른쪽 옆 이동의 패턴은?

  1. FL + · FR − · RL − · RR +
  2. FL + · FR + · RL − · RR −
  3. FL − · FR + · RL − · RR +
  4. 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 / maxw` 를 곱함방향 · 곡률은 그대로, 속도만 느려짐

시뮬레이터 3 · 역기구학과 포화#

이 시뮬레이터의 모델
  • 위 표의 역기구학으로 바퀴 속도를 구하고, 고른 처리 방법(그대로 · 자르기 · 정규화)을 거친 바퀴 속도를 다시 순기구학으로 차체 속도로 바꿔 3 초 동안 움직인 궤적을 그립니다.
  • 회색 점선 = 명령한 궤적(한계 무시), 빨강 = 바퀴별 자르기, 파랑 = 비율 정규화. 오른쪽 그림은 위쪽이 출발 시 로봇 앞입니다.
  • 바퀴 아이콘의 회전은 눈으로 보기 쉽게 실제의 1/10 속도로 그립니다.

먼저 예측하세요. vx = 1.0, vy = 0.5, ω = 0.8 을 넣으면 네 바퀴 중 어느 바퀴가 가장 빨리 돌까요? 그 바퀴만 30 rad/s 로 자르면 로봇은 명령보다 왼쪽으로 덜 갈까요, 더 갈까요?

시뮬레이터 3 · (vx, vy, ω) → 바퀴 4개 rad/s · 포화 처리 · 3 초 궤적
바퀴에 보내는 값:  

해 볼 것

  1. 실습 값 버튼을 누르고 네 바퀴 값을 읽습니다. 어느 바퀴가 30 rad/s 를 넘나요? 예측과 같나요?
  2. "바퀴별 자르기" 와 "비율 정규화" 를 번갈아 고르며 빨강 · 파랑 궤적을 회색 점선(명령)과 비교합니다. 어느 쪽이 같은 모양을 따라가나요?
  3. 출력 줄의 "방향" 과 "곡률 ω/v" 를 비교합니다. 정규화는 두 값이 명령과 같고, 자르기는 다릅니다. 왜일까요?
  4. vy 와 ω 를 0 으로 놓고 vx 만 1.5 까지 올립니다. 이때는 자르기와 정규화의 궤적이 왜 같아지나요?
  5. 바퀴 최고 속도를 40 으로 올리면 포화가 사라지는 지점을 찾습니다. 실습 값에서 필요한 최소 한계는 얼마인가요?

관찰 포인트 — 바퀴 속도와 차체 속도는 선형 관계입니다. 그래서 네 바퀴에 같은 배율을 곱하면 차체 속도도 같은 배율로 줄어들 뿐 방향 · 곡률은 그대로입니다. 반면 한 바퀴만 자르면 바퀴 사이 비율이 깨져, 차체가 받는 "옆 · 회전 성분" 이 바뀌고 궤적 모양 자체가 달라집니다. 경로를 따라가야 하는 물류로봇에서는 정규화가 기본입니다.

확인 문제 3-1

시뮬레이터 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 값은?

  1. s ≈ 0.842, FR = 30.0 rad/s
  2. s ≈ 1.187, FR = 42.3 rad/s
  3. s = 1, FR 만 30.0 rad/s 로 바뀜
  4. s ≈ 0.842, FR = 35.62 rad/s 그대로
정답 보기① — s = 30 / 35.62 ≈ 0.842 를 네 바퀴 모두에 곱합니다. 가장 빠른 FR 이 정확히 30 rad/s 가 되고 나머지는 [3.69, 20.53, 13.16] 이 됩니다. ③ 은 "바퀴별 자르기" 입니다.
확인 문제 3-2

같은 값에서 "바퀴별 자르기" 를 고르면 실제 차체 속도가 약 (0.930, 0.430, 0.600) 이 됩니다. 명령 (1.0, 0.5, 0.8) 과 비교한 해석으로 옳은 것은?

  1. 모든 성분이 같은 비율로 줄어 경로 모양은 그대로다
  2. 회전 ω 가 25 % 나 줄고 vx 는 7 % 만 줄어, 궤적이 명령보다 덜 휘어진다
  3. 자르기는 회전만 줄이고 직진 성분은 늘린다
  4. 차이가 없다
정답 보기② — 비율은 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 에서 멀면 어느 바퀴가 미끄러지고 있다는 신호입니다.

미끄러짐 — 오도메트리는 실제를 모릅니다#

순기구학은 "바퀴가 돈 만큼 차체가 갔다" 고 가정합니다. 바퀴가 미끄러지면 엔코더 값은 그대로인데 차체는 덜 갑니다. 메카넘 휠은 옆으로 갈 때 롤러가 계속 구르며 힘을 대각선으로 나누어 전달하므로, 횡이동에서 미끄러짐이 가장 큽니다.

시뮬레이터 4 의 미끄러짐 모델 (교육용 가정)

슬립 계수 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번 하면 더 정확할까요?

시뮬레이터 4 · 계획 경로(=오도메트리가 믿는 경로) vs 실제 경로
바닥:
경로:  

해 볼 것

  1. 슬립 0 % 에서 세 경로가 모두 출발점으로 정확히 돌아오는지 확인합니다 (오차 0.0 cm).
  2. 슬립 10 % · 평행이동 사각형에서 ▶ 주행 보기 를 누르고 오른쪽 패널을 봅니다. 순기구학(파랑)과 실제(빨강) 중 어느 성분이 가장 많이 다른가요?
  3. 같은 10 % 에서 "회전 사각형" 으로 바꿉니다. 출발점과의 거리는 평행이동 사각형보다 큰가요, 작은가요? 이유를 회전 성분에서 찾아봅니다.
  4. 바닥 프리셋(에폭시 · 타일 · 카펫)을 바꾸며 평행이동 사각형의 오차와 "옆 변 길이" 를 표로 적습니다.
  5. "옆 왕복" 을 고르고 슬립을 0 → 30 % 로 올립니다. 왕복이라 거리는 상쇄되는데 왜 오차가 0 이 아닌가요?

관찰 포인트 — 바퀴는 명령대로 돌았으므로 순기구학(엔코더) 값은 항상 계획과 똑같습니다. 로봇 스스로는 정사각형을 정확히 돌았다고 믿습니다. 실제로는 옆 변이 1 − s 만큼 짧아지고, 옆으로 갈 때 생긴 작은 방향 틀어짐이 다음 변을 비스듬하게 만들어 끝점이 벌어집니다. 회전이 들어가는 경로는 회전 슬립이 방향 오차로 쌓여 더 크게 벌어집니다. 이렇게 바퀴만 세어서 위치를 추정하는 것(오도메트리) 의 한계는 ch04 에서 본격적으로 다룹니다.

확인 문제 4-1

시뮬레이터 4 에서 슬립 10 % · 평행이동 사각형을 돌았더니, 오른쪽 패널의 "순기구학" 은 vy = 0.300, "실제" 는 vy = 0.270 이었습니다. 로봇의 오도메트리는 끝 위치를 어디로 계산할까요?

  1. 실제 끝 위치와 똑같이
  2. 출발점 (0, 0) — 엔코더는 바퀴가 돈 만큼만 세므로 미끄러짐을 모른다
  3. 옆 변이 짧아진 것을 알고 (0, −0.1)
  4. 계산할 수 없다
정답 보기② — 순기구학은 바퀴 회전량만으로 계산하므로 미끄러짐이 있어도 계획과 같은 값을 냅니다. 실제 끝점은 출발점에서 약 4.8 cm 떨어져 있는데, 로봇은 이를 알지 못합니다. 이 차이를 줄이려면 IMU · 라이다 같은 다른 센서가 필요합니다.
확인 문제 4-2

슬립 10 % 에서 평행이동 사각형의 오차는 약 4.8 cm, 회전 사각형은 약 22.3 cm 였습니다. 회전 사각형이 크게 벌어진 주된 이유는?

  1. 회전 사각형이 이동 거리가 더 길어서
  2. 90° 회전마다 회전 슬립(ω 가 5 % 덜 돎)으로 방향이 틀어지고, 그 틀어진 방향으로 다음 1 m 를 가서 오차가 쌓이므로
  3. 회전 사각형은 옆 이동을 하지 않아서 오차가 없어야 하는데 시뮬레이터 오류다
  4. 전진 슬립이 옆 슬립보다 커서
정답 보기② — 90° × 5 % = 4.5° 씩 덜 돌아 네 번이면 약 18° 가 틀어집니다. 방향 오차는 그 뒤의 모든 이동을 비스듬하게 만들어 거리 오차보다 훨씬 크게 쌓입니다. 이동 거리는 둘 다 4 m 로 같습니다.

실습 (시뮬레이터)#

교시마다 Playground 에서 시뮬레이터의 숫자를 직접 계산해 검증합니다. starter 의 TODO 를 채워 실행한 뒤, 풀이 와 비교하세요.

Playground 열기

3D 뷰어로 바퀴 배치 다시 보기

3D 뷰어 열기

3D 뷰어에는 공식 agv_pro_gazebo URDF 가 들어 있습니다. 바퀴 joint 4개를 하나씩 +값으로 돌려 보며 실습 2-1 의 부호표(어느 쪽이 "앞으로" 도는 방향인가)를 확인합니다. 축이 0 1 0 이므로 +회전은 네 바퀴 모두 로봇을 앞(+x)으로 굴리는 방향입니다.

실습 1-1 · 차동 구동 vs 전방향, 옆 1 m 의 시간 (1교시)

차동 로봇이 "좌회전 90° → 전진 d → 우회전 90°" 로 옆 d 만큼 가는 시간과, 전방향 로봇이 vy 로 바로 가는 시간을 계산하는 함수를 완성합니다. 옆 거리 0.25 · 0.5 · 1 · 3 m 에 대해 시간 비를 출력하고, "짧은 거리일수록 전방향이 유리한 이유" 를 한 문장으로 적어 보세요.

python시뮬 실행 가능
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}")
풀이
python시뮬 실행 가능
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 배 넘게 느립니다.

실습 1-2 · 제자리 회전에 필요한 통로 폭 (1교시)

차체 0.53 × 0.36 m 로봇이 제자리 회전할 때 모서리가 그리는 원의 반지름을 구하고, 선반 사이 통로 폭이 얼마 이상이어야 회전할 수 있는지 계산합니다. 통로 폭 0.6 · 0.7 · 0.8 m 에서 회전 가능 여부를 출력하세요.

python시뮬 실행 가능
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)")
풀이
python시뮬 실행 가능
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 · 바퀴 부호표 완성 (2교시)

시뮬레이터 2 에서 찾은 패턴을 코드로 확인합니다. 각 바퀴가 "앞으로" 돌 때 차체에 주는 대각선 방향 (1, s_i) 와 회전 기여 c_i 를 채우면, 원하는 움직임 10가지의 바퀴 부호(+/−/0)를 출력합니다.

python시뮬 실행 가능
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))
풀이
python시뮬 실행 가능
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-2 · 바퀴 하나만 돌리면? (2교시)

시뮬레이터 2 에서 바퀴를 하나만 돌리면 차체는 이동과 회전을 동시에 합니다. FL 만 +10 rad/s 일 때 차체 속도 (vx, vy, ω) 와, 그 운동이 그리는 원의 반지름 |v| / |ω| 를 계산해 시뮬레이터 2 의 궤적과 비교하세요.

python시뮬 실행 가능
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")
풀이
python시뮬 실행 가능
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 CW

FL 의 힘은 오른쪽 앞 대각선이고, 중심 왼쪽 앞에서 밀기 때문에 시계 방향 돌림힘도 생깁니다. 그래서 약 0.5 m 반지름의 원을 시계 방향으로 돕니다.

실습 3-1 · 역기구학 함수 (3교시)

(vx, vy, ω) 를 넣으면 바퀴 4개 rad/s 를 돌려주는 함수를 numpy 행렬로 만듭니다. 시뮬레이터 3 의 값과 같은지 세 경우로 확인하세요.

python시뮬 실행 가능
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))
풀이
python시뮬 실행 가능
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 씩 돕니다.

실습 3-2 · 포화 바퀴 찾기와 정규화 (3교시)

vx = 1.0, vy = 0.5, ω = 0.8 에서 30 rad/s 를 넘는 바퀴를 찾고, 정규화 · 자르기 두 방법으로 처리한 뒤 3 초 동안의 궤적 끝점을 비교합니다. 정규화 끝점이 명령 궤적 위에 있는지(곡률이 같은지) 확인하세요.

python시뮬 실행 가능
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)}")
풀이
python시뮬 실행 가능
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 배

정규화는 곡률이 명령과 같아서 끝점이 명령 궤적 위(조금 덜 간 지점)에 있습니다. 자르기는 곡률이 달라 다른 원 위로 갑니다.

실습 4-1 · 순기구학 = 의사역행렬 (4교시)

np.linalg.pinv(J) 가 위 표의 순기구학 식(r/4, r/(4k))과 같은지 확인하고, 바퀴 하나가 미끄러져 엔코더 값이 서로 맞지 않을 때 최소제곱 답과 "남는 식(불일치)" 을 계산합니다.

python시뮬 실행 가능
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))
풀이
python시뮬 실행 가능
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-2 · 슬립 10 % 정사각형 오차 측정 (4교시)

시뮬레이터 4 와 같은 미끄러짐 모델로 1 m 정사각형 두 가지(평행이동 · 회전)를 돌아 출발점과의 거리를 계산합니다. 슬립 0 · 3 · 6 · 10 · 15 % 표를 만들고 시뮬레이터 값과 비교하세요.

python시뮬 실행 가능
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}")
풀이
python시뮬 실행 가능
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)으로 바퀴 속도를 계산하고, 오른쪽 바퀴 (역기구학) 표에 실시간으로 보여 줍니다.

시뮬레이터 열기 (빈 바닥)

실습 5-1 · 키보드로 바퀴 부호 맞히기 (시뮬레이터)

먼저 예측하세요. A(왼쪽 옆 이동)를 누르고 있을 때 바퀴 표의 FL · FR · RL · RR 부호는 각각 어떻게 될까요? 3교시의 표에 vx = 0, vy = +0.4, ω = 0 을 넣어 종이에 먼저 적습니다.

  1. 전원 켜기 → 화면을 한 번 누르고 A 를 누른 채 바퀴 표를 읽습니다. 예측과 같나요?
  2. Q(제자리 왼쪽 회전)도 같은 방법으로 예측 → 확인합니다.
  3. 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 만 대각선으로 밉니다.
실습 5-2 · Playground 에서 바퀴 속도 검증 (시뮬레이터)

agvsim.cmd_vel(vx, vy, w) 는 세 속도를 한 번에 거는 시뮬레이터 전용 함수입니다 (실물에서는 ROS 2 /cmd_vel 이 같은 역할 — ch09). 시뮬레이터가 보고한 바퀴 속도와 내 역기구학 함수의 값이 같은지 비교합니다.

python시뮬 실행 가능
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 의 정규화가 왜 필요한지 생각해 보세요.
실습 5-3 · 미끄러짐을 켜고 사각형 돌기 (시뮬레이터)

패널의 바퀴 미끄러짐 을 10 % 로 올리고, 키보드로 1 m 사각형을 (가) 옆 이동만으로, (나) 전진 + 90° 회전으로 한 바퀴 돕니다. 화면의 초록(참값)과 주황(오도메트리) 궤적이 어느 쪽에서 더 벌어지는지, HUD 의 오차 값으로 기록합니다. 4교시 실습의 계산(약 4.8 cm vs 22 cm)과 경향이 맞나요?

자주 나는 오류와 해결#

1) 옆으로 가라고 했는데 제자리에서 돈다#

text
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) 회전 속도가 엄청 빠르거나 느리다#

text
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 · r m/s 입니다. 반지름 r 을 실물과 다르게 넣어도 같은 증상입니다.
  • 해결: 드라이버 단위를 확인하고 변환합니다. 반지름은 10 바퀴 굴린 거리 ÷ (10 · 2π) 로 실측합니다.

5) 정규화했는데도 경로가 휜다#

text
normalize: s = -0.842  -> robot goes backward
  • 원인: 최댓값을 max(w) 로 구해 음수 바퀴를 놓쳤거나, 부호가 있는 값으로 나눴습니다. 또는 한 바퀴만 정규화했습니다.
  • 해결: m = np.max(np.abs(w)) 로 크기의 최댓값을 구하고, m > w_max 일 때만 네 바퀴 모두에 w_max / m 을 곱합니다.

6) 의사역행렬 계산에서 모양 오류#

text
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 로 먼저 출력해 확인합니다.

과제#

  1. 부호표 카드: 실습 2-1 의 10가지 움직임 부호표를 카드로 만들고, 각 칸 옆에 시뮬레이터 2 의 힘 화살표 스케치를 붙입니다. "대각선은 왜 바퀴 2개만 도는가" 를 한 문장으로 적습니다.
  2. 통로 설계 메모: 실습 1-1 · 1-2 결과로 "선반 간격이 0.10 m 인 통로에서 차동 구동 대신 전방향 구동을 써야 하는 이유" 를 시간 · 공간 두 측면에서 3줄로 씁니다.
  3. 포화 보고서: 시뮬레이터 3 에서 실습 값의 자르기 · 정규화 궤적을 캡처하고, 곡률(0.586 vs 0.716)의 차이를 근거로 어떤 방법을 쓸지 결론을 적습니다.
  4. 바닥별 오차표: 실습 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 으로 움직이기