OMX 모터 트러블슈팅 가이드

ROBOTIS OpenManipulator-X의 Dynamixel 모터가 과열되거나 캘리브레이션이 맞지 않을 때 참고하는 문서입니다.

OMX + LeRobot 모방학습 실습을 위해 시행착오했던 과정 중에 효과가 있었던 방법만 정리했습니다.

1~3장은 제어 소프트웨어와 무관하게 Dynamixel Protocol 2.0을 쓰는 모든 환경에 적용됩니다. 4장과 5장 일부는 LeRobot 전용입니다.

증상	가는 곳
무엇이 문제인지 모르겠다	1장
빨간불이 켜지고 Overload(에러 32)가 뜬다	2장
아무것도 실행하지 않는데 모터가 뜨겁다	1-3절
큰 목표는 따라가는데 작게 움직이면 멈춘다	2-2절
특정 구간에서만 안 움직인다	2-4절
설정이 실행할 때마다 되돌아간다	2-5절, 3-3절
나사를 조였더니 가동 범위가 달라졌다	3장
리더암과 팔로워암 자세가 안 맞는다	4장
팔로워 그립퍼가 충분히 안 열린다	4-4절
제어 루프가 느리다, 카메라 설정이 안 먹는다	5장
옵션을 줬는데 무시된다	5장

장 구성

준비 (모터 상태 읽기, 어디로 갈지 판정, 에러 지우고 토크 끄기)
그립퍼에 Overload(에러 32)가 반복될 때
가동 범위를 측정해 반영하기
리더암과 팔로워암이 안 맞을 때 (LeRobot)
그 밖에 자주 걸리는 것
참고: 이 로봇에서 측정된 값
참고 메모

이 저장소

ROBOTIS OMX + LeRobot 환경에서 팔로워 그립퍼(ID 16) 과부하를 해결한 설정과, 그 과정에서 효과가 있었던 방법을 담았습니다.

핵심 설정은 Current_Limit 600, Goal_Current 100(이동 시 200), Position 게인 P 800 / I 0 / D 0, 가동 범위 2123 ~ 2873 입니다. 명령줄 옵션으로 --teleop.gripper_open_pos=95 를 썼습니다. 전체 값은 6장에 있습니다.

파일	내용
`omx_patches.diff`	LeRobot 소스 수정 내역. `git apply` 로 적용
`omx_calibration.tar.gz`	`~/.cache/huggingface/lerobot/calibration` 전체
`omx_calibration/`	위 아카이브를 펼친 것. 웹에서 바로 읽을 수 있음

이 저장소의 숫자는 우리의 측정 결과입니다. 그대로 쓰는 것보다, 같은 절차로 본인 로봇을 측정하는 것이 좋습니다. 아래에 가이드가 있습니다.

아래 방법들을 따라하기 위해서는 dynamixel-sdk 가 필요하니 설치해주세요.

다음 명령을 shell에서 실행해 설치하세요.

pip install dynamixel-sdk

대부분은 터미널에 그대로 붙여넣으면 실행되는 블록입니다. 포트는 모든 블록이 자동으로 찾으므로, 모터 ID와 값만 확인하면 됩니다.

여러 번 반복해서 쓰는 세 개(motor_status.py, watch_motor.py, compare_pos.py)만 파일로 만들어 두고 인자를 바꿔 호출합니다.

1. 준비

1-1. 모터 상태 읽기

문제가 생기면 가장 먼저 실행합니다. 진단과 검증에 계속 쓰므로 파일로 만들어 두세요.

# motor_status.py
import sys, glob
from dynamixel_sdk import PortHandler, PacketHandler, COMM_SUCCESS

USAGE = """사용법: python motor_status.py [port]
  예: python motor_status.py                  (연결된 모든 포트 훑기)
      python motor_status.py /dev/ttyUSB0     (특정 포트만)"""

if len(sys.argv) > 2:
    sys.exit(USAGE)
PORTS = ([sys.argv[1]] if len(sys.argv) == 2
         else sorted(glob.glob('/dev/ttyUSB*') + glob.glob('/dev/ttyACM*')))
if not PORTS:
    sys.exit('시리얼 포트를 찾지 못했습니다. USB 연결과 전원을 확인하세요.')

ERR_BITS = {0: 'InputVoltage', 2: 'Overheating', 3: 'EncoderError',
            4: 'ElectricalShock', 5: 'Overload'}
HEADER = (f'{"ID":>3} {"model":>6} {"pos":>6} {"cur":>5} '
          f'{"temp":>5} {"tq":>3}  error')

ph = PacketHandler(2.0)


def rd(p, mid, addr, nb, signed=False):
    fn = {1: ph.read1ByteTxRx, 2: ph.read2ByteTxRx, 4: ph.read4ByteTxRx}[nb]
    v, r, _ = fn(p, mid, addr)
    if r != COMM_SUCCESS:
        return None
    if signed and v >= 2 ** (8 * nb - 1):
        v -= 2 ** (8 * nb)
    return v


total = 0
for dev in PORTS:
    p = PortHandler(dev)
    if not p.openPort():
        print(f'{dev}: 열기 실패 (dialout 그룹 권한을 확인하세요)')
        continue
    p.setBaudRate(1_000_000)

    ids = [mid for mid in range(1, 31) if ph.ping(p, mid)[1] == COMM_SUCCESS]
    if ids:
        print(f'=== {dev} ===')
        print(HEADER)
        for mid in ids:
            err = rd(p, mid, 70, 1)
            names = [n for b, n in ERR_BITS.items() if err and err >> b & 1]
            print(f'{mid:>3} {ph.ping(p, mid)[0]:>6} {rd(p, mid, 132, 4, True):>6} '
                  f'{rd(p, mid, 126, 2, True):>5} {rd(p, mid, 146, 1):>5} '
                  f'{rd(p, mid, 64, 1):>3}  {err} {names}')
        print()
        total += len(ids)
    p.closePort()

if total == 0:
    sys.exit('모터를 찾지 못했습니다. 전원, 배선, 포트 권한을 확인하세요.')
print(f'모터 {total}개 발견')

다음 명령을 shell에서 실행하세요.

python motor_status.py

출력 예시:

=== /dev/ttyUSB0 ===
 ID  model    pos   cur  temp  tq  error
 11   1060   2048     0    30   0  0 []
 12   1060   1024     3    31   0  0 []
 16   1200   2338  -162    44   1  32 ['Overload']

=== /dev/ttyUSB1 ===
 ID  model    pos   cur  temp  tq  error
  1   1200   2048     0    29   0  0 []
  6   1190   1187     2    30   1  0 []

모터 12개 발견

모터를 못 찾으면 포트가 보이는지부터 확인하세요.

ls /dev/ttyUSB* /dev/ttyACM*
lerobot-find-port

포트는 보이는데 모터가 없으면 전원과 배선을, 포트가 아예 없으면 USB 연결을 확인합니다. 열기 실패가 나오면 시리얼 포트 접근 권한이 없는 것입니다.

1-2. 어디로 갈지 판정

error 열로 결정합니다.

error	의미	할 일
0	에러 없음	자세가 안 맞으면 4장, 움직이지 않으면 2-2절
32	Overload (최대 출력 지속)	2장
4	Overheating (온도 한계 초과)	식을 때까지 기다린 뒤 2장
그 외	괄호 안의 비트 이름 참고	전원, 배선, 모터 상태 점검

여러 비트가 동시에 설 수 있습니다. 36이면 Overload와 Overheating이 함께 선 것입니다.

에러가 0이 아닌 모터는 토크를 켜거나 끌 수 없고 EEPROM 쓰기도 거부되므로, 무엇을 하든 1-3절을 먼저 실행하세요.

1-3. 에러 지우고 토크 끄기

에러는 자동으로 지워지지 않고 reboot이나 전원 재투입까지 유지되므로 명시적으로 지워야 합니다.

제어 프로그램을 비정상 종료한 뒤 아무것도 실행하지 않는데 모터가 뜨거운 경우에도 이걸 쓰세요. 과부하가 난 모터는 토크 끄기 쓰기가 거부되어 토크가 켜진 채 남습니다.

연결된 모든 모터를 처리하므로 고칠 것이 없습니다. 다음 스크립트를 shell에 그대로 붙여넣으세요.

python - <<'EOF'
import glob, time
from dynamixel_sdk import PortHandler, PacketHandler, COMM_SUCCESS

ph = PacketHandler(2.0)
done = 0
for dev in sorted(glob.glob('/dev/ttyUSB*') + glob.glob('/dev/ttyACM*')):
    p = PortHandler(dev)
    if not p.openPort():
        continue
    p.setBaudRate(1_000_000)
    for mid in range(1, 31):
        if ph.ping(p, mid)[1] != COMM_SUCCESS:
            continue
        err, _, _ = ph.read1ByteTxRx(p, mid, 70)
        if err:                                      # 에러가 있을 때만 reboot
            ph.reboot(p, mid); time.sleep(1.5)
        ph.write1ByteTxRx(p, mid, 64, 0)             # Torque_Enable = 0
        err, _, _ = ph.read1ByteTxRx(p, mid, 70)
        tq, _, _ = ph.read1ByteTxRx(p, mid, 64)
        print(f'{dev} id {mid}: error={err} torque={tq}')
        done += 1
    p.closePort()
print(f'\n모터 {done}개 처리')
EOF

모두 error=0 torque=0이면 다음 단계로 갑니다. error가 그대로 남으면 로봇 전원을 껐다 켜고 다시 실행하세요.

reboot은 RAM도 초기화하므로, 에러가 걸렸던 모터는 Position 게인과 Goal_Current가 기본값으로 돌아갑니다. 2장에서 그 값들을 조정한 뒤라면 다시 써야 합니다. 멀쩡한 모터는 reboot하지 않으므로 설정이 유지됩니다.

2. 그립퍼에 Overload(에러 32)가 반복될 때

Overload는 전류가 Current_Limit을 넘는 것이 아니라 최대 출력(PWM)이 지속될 때 발생하므로, Current_Limit을 올리는 것으로는 해결되지 않습니다. PWM이 포화되는지부터 확인하세요.

2-1. PWM 확인

조치마다 다시 실행하므로 파일로 만들어 두세요.

# watch_motor.py
import sys, glob, time
from dynamixel_sdk import PortHandler, PacketHandler, COMM_SUCCESS

USAGE = """사용법: python watch_motor.py <id> <goal_position> [seconds]
  예: python watch_motor.py 16 2400
      python watch_motor.py 16 2400 60
  포트는 자동으로 찾습니다.
  주의: 토크를 켜고 모터를 움직입니다. 주변을 비우고 실행하세요."""

if len(sys.argv) not in (3, 4):
    sys.exit(USAGE)
try:
    MOTOR_ID = int(sys.argv[1])
    GOAL = int(sys.argv[2])
    SECONDS = float(sys.argv[3]) if len(sys.argv) == 4 else 10.0
except ValueError:
    sys.exit(USAGE)

ph = PacketHandler(2.0)
p = None
for dev in sorted(glob.glob('/dev/ttyUSB*') + glob.glob('/dev/ttyACM*')):
    q = PortHandler(dev)
    if not q.openPort():
        continue
    q.setBaudRate(1_000_000)
    if ph.ping(q, MOTOR_ID)[1] == COMM_SUCCESS:
        p = q
        print(f'{dev} 에서 id {MOTOR_ID} 발견')
        break
    q.closePort()
if p is None:
    sys.exit(f'id {MOTOR_ID} 를 찾지 못했습니다. motor_status.py 로 ID를 확인하세요.')


def rd(addr, nb, signed=False):
    fn = {1: ph.read1ByteTxRx, 2: ph.read2ByteTxRx, 4: ph.read4ByteTxRx}[nb]
    v, r, _ = fn(p, MOTOR_ID, addr)
    if r != COMM_SUCCESS:
        return None
    if signed and v >= 2 ** (8 * nb - 1):
        v -= 2 ** (8 * nb)
    return v


pwm_limit = rd(36, 2)
print(f'시작: pos={rd(132, 4, True)} mode={rd(11, 1)} '
      f'CurrentLimit={rd(38, 2)} GoalCurrent={rd(102, 2)} PWMLimit={pwm_limit}')
print(f'      P={rd(84, 2)} I={rd(82, 2)} D={rd(80, 2)} error={rd(70, 1)}\n')

ph.write1ByteTxRx(p, MOTOR_ID, 64, 1)                # Torque on
ph.write4ByteTxRx(p, MOTOR_ID, 116, GOAL)            # Goal_Position

t0 = time.perf_counter()
peak_cur = peak_pwm = 0
try:
    while time.perf_counter() - t0 < SECONDS:
        pos, cur = rd(132, 4, True), rd(126, 2, True)
        pwm, err = rd(124, 2, True), rd(70, 1)
        peak_cur = max(peak_cur, abs(cur or 0))
        peak_pwm = max(peak_pwm, abs(pwm or 0))
        print(f'  t={time.perf_counter() - t0:5.2f} pos={pos:5d} '
              f'cur={cur:5d} pwm={pwm:5d} err={err}')
        if err:
            print(f'\n>>> 에러 {err} 발생')
            break
        time.sleep(0.04)
except KeyboardInterrupt:
    pass

ph.write1ByteTxRx(p, MOTOR_ID, 64, 0)                # Torque off
p.closePort()

print(f'\n전류 최대 {peak_cur}')
print(f'PWM  최대 {peak_pwm} / PWM_Limit {pwm_limit}')
if pwm_limit and peak_pwm >= pwm_limit * 0.95:
    print('→ PWM 포화. 2-2절과 2-3절로 가세요.')
else:
    print('→ PWM 포화 아님. 2-2절을 먼저 보고, 게인이 정상이면 2-4절로 가세요.')

다음 명령을 shell에서 실행하세요.

python watch_motor.py 16 2400

샘플링이 느리면 피크를 놓치므로 40 ms 간격으로 기록합니다. 마지막 줄의 판정에 따라 다음 절로 가세요.

2-2. Position 게인 조정

큰 목표값은 따라가는데 작은 단계로 올리면 중간에 멈추는 경우입니다. Current-Based Position Control에서 전류 지령은 위치 오차에 P 게인을 곱해 만들어지므로, P가 낮거나 D가 P보다 크면 전류가 충분히 올라가지 않습니다.

2-1절 출력의 P= 와 D= 를 보세요. D가 P보다 크면 이 경우입니다.

문제가 되는 모터 하나에만 쓰세요. 다른 관절의 게인은 건드리지 않습니다.

다음 스크립트를 shell에 붙여넣으세요.

python - <<'EOF'
# ─── 이 두 줄만 확인하세요 ───
MOTOR_ID = 16                 # 1-1절 출력에서 그립퍼 모터의 ID
P, I, D = 800, 0, 0           # P는 800에서 시작. 더 올리면 목표를 지나쳐 흔들립니다
# ─────────────────────────────
import glob
from dynamixel_sdk import PortHandler, PacketHandler, COMM_SUCCESS

ph = PacketHandler(2.0)
p = None
for dev in sorted(glob.glob('/dev/ttyUSB*') + glob.glob('/dev/ttyACM*')):
    q = PortHandler(dev)
    if not q.openPort():
        continue
    q.setBaudRate(1_000_000)
    if ph.ping(q, MOTOR_ID)[1] == COMM_SUCCESS:
        p = q
        print(f'{dev} 에서 id {MOTOR_ID} 발견\n')
        break
    q.closePort()
if p is None:
    raise SystemExit(f'id {MOTOR_ID} 를 찾지 못했습니다.')

for addr, val, name in [(84, P, 'P_Gain'), (82, I, 'I_Gain'), (80, D, 'D_Gain')]:
    r, e = ph.write2ByteTxRx(p, MOTOR_ID, addr, val)
    back, _, _ = ph.read2ByteTxRx(p, MOTOR_ID, addr)
    print(f'{name}({addr}) <- {val}: {"OK" if back == val else "실패"} '
          f'(읽기 {back}) {ph.getTxRxResult(r)} {ph.getRxPacketError(e)}')
p.closePort()
EOF

세 줄 모두 OK여야 합니다. RAM 영역이라 전원을 끄면 초기화됩니다.

바꾼 뒤 2-1절을 다시 실행해 위치 오차가 몇 카운트 이내로 줄었는지 확인하세요.

2-3. Goal_Current 내리기

2-1절에서 PWM이 포화된 경우입니다. PWM이 포화된 상태에서 나온 전류값이 그 모터의 전류 천장이고, Goal_Current를 천장보다 높게 잡으면 전류가 목표값에 영영 닿지 못해 PWM이 최대에 붙은 채로 남습니다.

2-1절 출력의 전류 최대 값을 천장으로 보고, 그 60% 정도에서 시작하세요.

다음 스크립트를 shell에 붙여넣으세요.

python - <<'EOF'
# ─── 이 두 줄만 확인하세요 ───
MOTOR_ID = 16
GOAL_CURRENT = 100            # watch_motor.py 로 잰 전류 천장의 60% 정도
# ─────────────────────────────
import glob
from dynamixel_sdk import PortHandler, PacketHandler, COMM_SUCCESS

ph = PacketHandler(2.0)
p = None
for dev in sorted(glob.glob('/dev/ttyUSB*') + glob.glob('/dev/ttyACM*')):
    q = PortHandler(dev)
    if not q.openPort():
        continue
    q.setBaudRate(1_000_000)
    if ph.ping(q, MOTOR_ID)[1] == COMM_SUCCESS:
        p = q
        print(f'{dev} 에서 id {MOTOR_ID} 발견\n')
        break
    q.closePort()
if p is None:
    raise SystemExit(f'id {MOTOR_ID} 를 찾지 못했습니다.')

r, e = ph.write2ByteTxRx(p, MOTOR_ID, 102, GOAL_CURRENT)
back, _, _ = ph.read2ByteTxRx(p, MOTOR_ID, 102)
limit, _, _ = ph.read2ByteTxRx(p, MOTOR_ID, 38)
print(f'Goal_Current(102) <- {GOAL_CURRENT}: '
      f'{"OK" if back == GOAL_CURRENT else "실패"} (읽기 {back}) '
      f'{ph.getTxRxResult(r)} {ph.getRxPacketError(e)}')
print(f'참고: Current_Limit(38) = {limit}')
p.closePort()
EOF

실패면 그 모델의 허용 범위를 벗어난 값입니다. 범위 밖의 값은 예외 없이 거부되고 이전 값이 남으므로 출력으로 확인하세요.

물체를 못 쥘 만큼 약하면 조금씩 올리되, 천장에 가까워지면 다시 포화합니다.

2-4. 특정 위치에서만 안 움직일 때

PWM에 여유가 있고 게인도 고쳤는데 특정 구간에서만 멈추는 경우는 기구 문제입니다. 아래 세 가지가 함께 나타나면 거의 확실합니다.

위치 의존성: 특정 구간에서만 걸리고 다른 구간은 정상
방향 의존성: 닫히는 건 되는데 열리지 않는 식으로 한 방향만 걸림
전류 차이 10배 이상: 자유롭게 움직일 때와 걸렸을 때의 전류가 한 자리 수와 세 자리 수로 벌어짐

나사와 연결부를 전부 점검하고 조이세요. 100 mA 수준의 저항은 사람 손으로 구분되지 않으므로 손으로 만져서 찾으려 하지 말고 측정값을 믿으세요.

나사를 조이면 가동 범위가 달라지므로 3장으로 가서 다시 측정하세요.

2-5. 설정이 유지되지 않을 때 (LeRobot)

Position 게인과 Goal_Current는 RAM 영역이고 LeRobot이 연결할 때마다 소스의 값을 다시 쓰므로, LeRobot 소스에 직접 넣어야 유지됩니다. src/lerobot/robots/omx_follower/omx_follower.py의 configure()를 고치기 위해 아래 스크립트를 shell에서 실행하세요.

python - <<'EOF'
# ─── 이 세 줄만 확인하세요 ───
P, I, D = 800, 0, 0           # 2-2절에서 정한 게인
GOAL_CURRENT = 100            # 2-3절에서 정한 값
CURRENT_LIMIT = 600           # 바꿀 이유가 없으면 그대로
# ─────────────────────────────
import importlib.util, pathlib

MARK = '# omx-guide'

spec = importlib.util.find_spec('lerobot.robots.omx_follower.omx_follower')
if spec is None or not spec.origin:
    raise SystemExit('omx_follower 모듈을 찾지 못했습니다. '
                     'lerobot 이 설치된 환경에서 실행하세요.')
src = pathlib.Path(spec.origin)
text = src.read_text()
if MARK in text:
    raise SystemExit(f'이미 적용되어 있습니다: {src}')

lines = text.splitlines(keepends=True)
start = next((i for i, ln in enumerate(lines)
              if ln.lstrip().startswith('with ') and 'torque_disabled()' in ln), None)
if start is None:
    raise SystemExit('torque_disabled 블록을 찾지 못했습니다. 소스를 직접 고치세요.')

wi = len(lines[start]) - len(lines[start].lstrip())   # with 줄의 들여쓰기
bi = ' ' * (wi + 4)                                   # 블록 안
oi = ' ' * wi                                         # 블록 밖

end = len(lines)                                      # 블록이 끝나는 줄
for j in range(start + 1, len(lines)):
    if lines[j].strip() and len(lines[j]) - len(lines[j].lstrip()) <= wi:
        end = j
        break

inside = [
    f'{bi}self.bus.write("Operating_Mode", "gripper", '
    f'OperatingMode.CURRENT_POSITION.value)  {MARK}\n',
    f'{bi}self.bus.write("Current_Limit", "gripper", {CURRENT_LIMIT})  {MARK}\n',
    f'{bi}self.bus.write("Position_P_Gain", "gripper", {P})  {MARK}\n',
    f'{bi}self.bus.write("Position_I_Gain", "gripper", {I})  {MARK}\n',
    f'{bi}self.bus.write("Position_D_Gain", "gripper", {D})  {MARK}\n',
]
outside = [
    f'{oi}self.bus.write("Goal_Current", "gripper", {GOAL_CURRENT})  {MARK}\n',
]

src.write_text(''.join(lines[:end] + inside + outside + lines[end:]))

if 'OperatingMode' not in text:
    print('경고: 이 파일에 OperatingMode import 가 없습니다.')
    print('      Operating_Mode 줄을 지우거나 import 를 추가하세요.\n')

print(f'수정: {src}\n')
print(f'torque_disabled 블록 안 {len(inside)}줄, 블록 밖 {len(outside)}줄 추가:')
for ln in inside + outside:
    print('  +', ln.rstrip())
EOF

수정이 제대로 됐는지 확인하세요. 다음 명령을 shell에서 실행하세요.

python -c "import lerobot.robots.omx_follower.omx_follower"

아무 출력도 없으면 문법이 정상입니다. 에러가 나면 삽입 위치가 어긋난 것이니 파일을 열어 # omx-guide 가 붙은 줄을 확인하세요. 해당 줄을 삭제하면 이전으로 복구할 수 있습니다.

업스트림 소스는 elbow_flex의 게인만 설정하고 gripper는 손대지 않으므로, 그립퍼는 기본 게인으로 동작합니다.

2-6. 검증

다음 명령을 shell에서 실행하세요.

python watch_motor.py 16 2400 60

세 가지를 확인하세요.

err가 끝까지 0
마지막 줄이 PWM 포화 아님
온도가 계속 오르지 않고 몇 도 안에서 안정

물체를 쥐는 상황도 시험하세요. 쥐는 순간 PWM이 일시적으로 포화되는 것은 괜찮고, 2초 넘게 지속되면 과부하가 납니다.

2-7. 이동 중에만 전류를 높이기 (선택)

2-4절의 기구 걸림이 완전히 해결됐는지 확신할 수 없을 때 쓰는 안전장치입니다. 물체를 쥐는 것은 영구 스톨이지만 이동은 도달 가능한 과도 동작이므로, 방향이 바뀔 때 한 번만 전류를 올리고 1초간 진척이 없으면 되돌립니다.

*스톨: 모터가 회전 명령을 받았지만 물리적으로 막혀 회전하지 못하고 힘만 계속 쓰는 상태

omx_follower.py에 메서드로 추가하고, send_action()에서 모터에 목표를 쓰기 직전에 호출하세요. configure()에 self._gstate = None을 넣어 초기화합니다.

def _gripper_current_policy(self, goal_pos) -> None:
    if "gripper" not in goal_pos:
        return
    GC_HOLD, GC_BOOST = 100, 200
    MARGIN, PROGRESS, TIMEOUT = 2.0, 1.0, 1.0
    now = time.perf_counter()
    st = getattr(self, "_gstate", None)
    if st is None:
        st = self._gstate = {"mode": "hold", "dir": 0, "armed": True,
                             "since": 0.0, "ref": 0.0}
    g = float(goal_pos["gripper"])
    cur = float(self.bus.read("Present_Position", "gripper"))
    err = g - cur
    if abs(err) <= MARGIN:
        if st["mode"] == "boost":
            self.bus.write("Goal_Current", "gripper", GC_HOLD)
        st.update(mode="hold", dir=0, armed=True)
        return
    d = 1 if err > 0 else -1
    if d != st["dir"]:
        st.update(dir=d, since=now, ref=cur)
        st["armed"] = st["mode"] == "hold"
    if st["mode"] == "hold":
        if st["armed"]:
            self.bus.write("Goal_Current", "gripper", GC_BOOST)
            st.update(mode="boost", armed=False, since=now, ref=cur)
    elif (cur - st["ref"]) * d > PROGRESS:
        st.update(since=now, ref=cur)
    elif now - st["since"] > TIMEOUT:
        self.bus.write("Goal_Current", "gripper", GC_HOLD)
        st["mode"] = "hold"

매 틱 serial read가 추가되어 제어 루프 비용이 늘어나므로, 루프가 이미 목표 FPS에 빡빡하면 넣지 마세요.

3. 가동 범위를 측정해 반영하기

나사를 조이거나 모터 관절을 다시 조립한 뒤에는 가동 범위가 달라지므로 측정부터 다시 하세요.

3-1. 토크를 끄고 손으로 측정

모터 힘으로 재면 모터가 밀어낸 위치가 섞여 실제 기구 한계보다 넓게 나옵니다.

토크가 꺼지면 암이 중력으로 내려앉을 수 있으니 손으로 받친 상태에서 실행하세요.

다음 스크립트를 shell에 붙여넣으세요.

python - <<'EOF'
# ─── 이 줄만 확인하세요 ───
MOTOR_ID = 16
# ──────────────────────────
import glob, time
from dynamixel_sdk import PortHandler, PacketHandler, COMM_SUCCESS

ph = PacketHandler(2.0)
p = None
for dev in sorted(glob.glob('/dev/ttyUSB*') + glob.glob('/dev/ttyACM*')):
    q = PortHandler(dev)
    if not q.openPort():
        continue
    q.setBaudRate(1_000_000)
    if ph.ping(q, MOTOR_ID)[1] == COMM_SUCCESS:
        p = q
        break
    q.closePort()
if p is None:
    raise SystemExit(f'id {MOTOR_ID} 를 찾지 못했습니다.')

ph.write1ByteTxRx(p, MOTOR_ID, 64, 0)                # Torque off
print('토크 OFF. 손으로 끝까지 닫기 → 끝까지 열기를 천천히 3번 하고 Ctrl+C')
lo = hi = None
try:
    while True:
        v, r, _ = ph.read4ByteTxRx(p, MOTOR_ID, 132)
        if r == COMM_SUCCESS:
            if v >= 2 ** 31: v -= 2 ** 32
            lo = v if lo is None else min(lo, v)
            hi = v if hi is None else max(hi, v)
            print(f'\r  현재 {v:5d}  최소 {lo:5d}  최대 {hi:5d}  ', end='', flush=True)
        time.sleep(0.05)
except KeyboardInterrupt:
    print(f'\n\n범위 {lo} ~ {hi}  (폭 {hi - lo})' if lo is not None else '\n측정값 없음')
p.closePort()
EOF

빠르게 움직이면 끝점을 놓칩니다. 3번 반복해서 최소와 최대가 수렴하는지 보세요.

3-2. EEPROM에 쓰기

EEPROM 쓰기는 Torque_Enable=0이고 Hardware_Error=0일 때만 되고, 조건이 어긋나거나 범위를 벗어난 값은 예외 없이 조용히 거부되므로 반환값과 읽기값을 둘 다 확인합니다.

LeRobot을 쓰면 이 블록을 건너뛰고 3-3절로 바로 가세요. EEPROM만 고치면 다음 실행에서 되돌아갑니다.

다음 스크립트를 shell에 붙여넣으세요.

python - <<'EOF'
# ─── 이 세 줄만 확인하세요 ───
MOTOR_ID = 16
MIN_POS, MAX_POS = 2123, 2873     # 3-1절에서 잰 값
HOMING_OFFSET = 0                 # 영점 보정이 필요 없으면 0
# ─────────────────────────────
import glob, time
from dynamixel_sdk import PortHandler, PacketHandler, COMM_SUCCESS

ph = PacketHandler(2.0)
p = None
for dev in sorted(glob.glob('/dev/ttyUSB*') + glob.glob('/dev/ttyACM*')):
    q = PortHandler(dev)
    if not q.openPort():
        continue
    q.setBaudRate(1_000_000)
    if ph.ping(q, MOTOR_ID)[1] == COMM_SUCCESS:
        p = q
        print(f'{dev} 에서 id {MOTOR_ID} 발견\n')
        break
    q.closePort()
if p is None:
    raise SystemExit(f'id {MOTOR_ID} 를 찾지 못했습니다.')

ph.reboot(p, MOTOR_ID); time.sleep(1.5)              # Hardware_Error 해제
ph.write1ByteTxRx(p, MOTOR_ID, 64, 0)                # Torque off
for addr, val, name in [(20, HOMING_OFFSET, 'Homing_Offset'),
                        (52, MIN_POS, 'Min_Position_Limit'),
                        (48, MAX_POS, 'Max_Position_Limit')]:
    r, e = ph.write4ByteTxRx(p, MOTOR_ID, addr, val)
    back, _, _ = ph.read4ByteTxRx(p, MOTOR_ID, addr)
    if back >= 2 ** 31: back -= 2 ** 32
    print(f'{name}({addr}) <- {val}: {"OK" if back == val else "실패"} '
          f'(읽기 {back}) {ph.getTxRxResult(r)} {ph.getRxPacketError(e)}')
p.closePort()
EOF

세 줄 모두 OK여야 합니다. 실패가 있으면 1-3절을 먼저 실행하세요.

주소 48이 Max, 52가 Min입니다. 설정을 바꾸지 않은 다른 모터를 읽어 addr48=4095 addr52=0이 나오는 것으로 확인할 수 있습니다.

3-3. 캘리브레이션 파일도 함께 쓰기 (LeRobot)

LeRobot은 연결할 때 캘리브레이션 JSON과 모터 EEPROM의 값을 비교하고, 어긋나면 calibrate()를 호출해 하드코딩된 0과 4095를 양쪽에 다시 씁니다. 그래서 한쪽만 고치면 다음 실행에서 되돌아갑니다.

둘을 함께 쓰면 일치 판정이 되어 calibrate()가 호출되지 않습니다.

캘리브레이션 파일은 관절 이름과 모터 ID로 찾아내므로 경로를 입력할 필요가 없습니다.

다음 스크립트를 shell에 붙여넣으세요.

python - <<'EOF'
# ─── 이 네 줄만 확인하세요 ───
MOTOR_ID = 16
JOINT = 'gripper'                 # 캘리브레이션 JSON 안의 관절 이름
MIN_POS, MAX_POS = 2123, 2873     # 3-1절에서 잰 값
HOMING_OFFSET = 0
# ─────────────────────────────
import glob, json, pathlib, time
from dynamixel_sdk import PortHandler, PacketHandler, COMM_SUCCESS

# 1. 캘리브레이션 파일 찾기 (관절 이름 + 모터 ID로 특정)
root = pathlib.Path.home() / '.cache/huggingface/lerobot/calibration'
hits = []
for f in root.rglob('*.json'):
    try:
        d = json.loads(f.read_text())
    except Exception:
        continue
    if isinstance(d, dict) and JOINT in d and d[JOINT].get('id') == MOTOR_ID:
        hits.append(f)
if len(hits) != 1:
    raise SystemExit(f'캘리브레이션 파일을 특정할 수 없습니다. 후보 {len(hits)}개: '
                     f'{[str(h) for h in hits]}')
cal = hits[0]
data = json.loads(cal.read_text())
print(f'캘리브레이션 파일: {cal}')
print(f'현재 값: {data[JOINT]}\n')

# 2. 모터 EEPROM
ph = PacketHandler(2.0)
p = None
for dev in sorted(glob.glob('/dev/ttyUSB*') + glob.glob('/dev/ttyACM*')):
    q = PortHandler(dev)
    if not q.openPort():
        continue
    q.setBaudRate(1_000_000)
    if ph.ping(q, MOTOR_ID)[1] == COMM_SUCCESS:
        p = q
        print(f'{dev} 에서 id {MOTOR_ID} 발견')
        break
    q.closePort()
if p is None:
    raise SystemExit(f'id {MOTOR_ID} 를 찾지 못했습니다.')

ph.reboot(p, MOTOR_ID); time.sleep(1.5)
ph.write1ByteTxRx(p, MOTOR_ID, 64, 0)
fail = False
for addr, val, name in [(20, HOMING_OFFSET, 'Homing_Offset'),
                        (52, MIN_POS, 'Min_Position_Limit'),
                        (48, MAX_POS, 'Max_Position_Limit')]:
    ph.write4ByteTxRx(p, MOTOR_ID, addr, val)
    back, _, _ = ph.read4ByteTxRx(p, MOTOR_ID, addr)
    if back >= 2 ** 31: back -= 2 ** 32
    fail = fail or back != val
    print(f'{name}({addr}) <- {val}: {"OK" if back == val else "실패"} (읽기 {back})')
p.closePort()
if fail:
    raise SystemExit('\nEEPROM 쓰기 실패. JSON은 건드리지 않았습니다. '
                     '1-3절을 먼저 실행하세요.')

# 3. JSON (백업 먼저)
cal.with_name(cal.name + '.bak').write_text(cal.read_text())
data[JOINT].update(homing_offset=HOMING_OFFSET, range_min=MIN_POS, range_max=MAX_POS)
cal.write_text(json.dumps(data, indent=4))
print(f'\n백업: {cal}.bak')
print(f'JSON: {data[JOINT]}')
EOF

EEPROM 쓰기가 실패하면 JSON을 건드리지 않고 멈춥니다. 한쪽만 바뀌어 불일치가 되는 것을 막기 위한 것입니다.

후보가 0개로 나오면 그 관절 이름이나 ID가 캘리브레이션 파일에 없는 것입니다. 파일을 직접 열어 이름을 확인하세요. 리더 암은 teleoperators/ 아래, 팔로워 암은 robots/ 아래에 있습니다.

find ~/.cache/huggingface/lerobot -path "*calibration*" -name "*.json"

3-4. 검증

teleop을 한 번 실행하세요. 카메라 옵션은 빼고 그립퍼만 확인하면 됩니다.

lerobot-teleoperate \
  --robot.type=omx_follower \
  --robot.port=/dev/ttyUSB0 \
  --robot.id=omx_follower_arm \
  --teleop.type=omx_leader \
  --teleop.port=/dev/ttyUSB1 \
  --teleop.id=omx_leader_arm

아래 문장이 뜨지 않으면 성공입니다.

Mismatch between calibration values in the motor and the calibration file
Using factory default calibration values

뜨면 EEPROM과 JSON이 여전히 어긋난 것입니다. 3-3절 출력에 실패가 있었는지, 관절 이름이 맞는지 확인하세요.

종료한 뒤 motor_status.py로 EEPROM 값이 유지됐는지도 확인하세요.

4. 리더암과 팔로워암이 안 맞을 때 (LeRobot)

4-1. 위치 비교

두 암을 같은 자세로 두고 재세요. 그러지 않으면 전부 어긋나 보입니다. 기준 자세를 잡기 어려우면 양쪽 토크를 끄고 손으로 최대한 비슷하게 맞춘 뒤 재세요.

조정할 때마다 다시 재야 하므로 파일로 만들어 두세요.

# compare_pos.py
import sys, glob
from dynamixel_sdk import PortHandler, PacketHandler, COMM_SUCCESS

USAGE = """사용법: python compare_pos.py [id_offset]
  예: python compare_pos.py        (팔로워 ID = 리더 ID + 10)
      python compare_pos.py 10
  포트는 자동으로 찾습니다. 리더는 ID 1, 팔로워는 ID 1+offset 으로 판별합니다."""

OFFSET = 10
if len(sys.argv) == 2:
    try:
        OFFSET = int(sys.argv[1])
    except ValueError:
        sys.exit(USAGE)
elif len(sys.argv) > 2:
    sys.exit(USAGE)

JOINTS = 6
ph = PacketHandler(2.0)


def scan():
    found = {}
    for dev in sorted(glob.glob('/dev/ttyUSB*') + glob.glob('/dev/ttyACM*')):
        p = PortHandler(dev)
        if not p.openPort():
            continue
        p.setBaudRate(1_000_000)
        ids = {mid for mid in range(1, 31) if ph.ping(p, mid)[1] == COMM_SUCCESS}
        p.closePort()
        if ids:
            found[dev] = ids
    return found


def read_positions(dev, ids):
    p = PortHandler(dev)
    p.openPort()
    p.setBaudRate(1_000_000)
    out = {}
    for mid in ids:
        v, r, _ = ph.read4ByteTxRx(p, mid, 132)
        if r == COMM_SUCCESS:
            out[mid] = v - 2 ** 32 if v >= 2 ** 31 else v
    p.closePort()
    return out


ports = scan()
leader = next((d for d, ids in ports.items() if 1 in ids), None)
follower = next((d for d, ids in ports.items() if 1 + OFFSET in ids), None)
if leader is None or follower is None:
    sys.exit(f'리더(id 1) 또는 팔로워(id {1 + OFFSET}) 를 찾지 못했습니다.\n'
             f'발견된 포트: { {d: sorted(i) for d, i in ports.items()} }')
print(f'리더 {leader} / 팔로워 {follower}\n')

L = read_positions(leader, [n for n in range(1, 1 + JOINTS) if n in ports[leader]])
F = read_positions(follower, [n for n in range(1 + OFFSET, 1 + OFFSET + JOINTS)
                              if n in ports[follower]])

print(f'{"joint":>5} {"leader":>8} {"follower":>9} {"diff":>7}  판정')
for n in range(1, 1 + JOINTS):
    lv, fv = L.get(n), F.get(n + OFFSET)
    if lv is None or fv is None:
        miss = 'leader' if lv is None else 'follower'
        print(f'{n:>5} {"-" if lv is None else lv:>8} '
              f'{"-" if fv is None else fv:>9} {"":>7}  {miss} 응답 없음')
        continue
    d = fv - lv
    if abs(d) <= 10:
        verdict = '정상'
    elif abs(d) >= 1000:
        verdict = '모터 관절 조립 각도 (4-3절)'
    else:
        verdict = '영점 차이 (4-2절 참고)'
    print(f'{n:>5} {lv:>8} {fv:>9} {d:>7}  {verdict}')

print('\n그립퍼는 모델이 달라 가동 폭 자체가 다를 수 있습니다. 그 경우 3장으로 가세요.')

다음 명령을 shell에서 실행하세요.

python compare_pos.py

출력 예시:

리더 /dev/ttyUSB1 / 팔로워 /dev/ttyUSB0

joint   leader  follower    diff  판정
    1     2048      2051       3  정상
    2     1024      1030       6  정상
    3     3072      3068      -4  정상
    4     1033      1125      92  영점 차이 (4-2절 참고)
    5     2048      2044      -4  정상
    6     1187      2338    1151  모터 관절 조립 각도 (4-3절)

4-2. 차이 해석

diff 크기	원인	대응
10 이하	정상	조치 불필요
수십 ~ 수백	영점 차이	조치하지 않아도 됩니다
1000 이상	모터 관절 조립 각도가 다름	4-3절
그립퍼만 큰 차이	가동 폭 자체가 다름	3장

수십에서 수백 카운트 차이는 보정하지 않고 진행했고 데이터 수집에 문제가 없었습니다.

92 카운트가 약 8도입니다. EEPROM 의 Homing_Offset 으로 상쇄할 수도 있지만 시험해보지 않았으므로 절차를 싣지 않습니다.

그립퍼는 이 장으로 해결되지 않습니다. 리더와 팔로워의 모델이 달라 가동 폭 자체가 다르기 때문입니다. 폭이 다르면 영점 보정으로는 맞출 수 없고, 양쪽의 실제 가동 범위를 재서 캘리브레이션에 등록해야 합니다.

그립퍼 문제라면 3장으로 가세요.

4-3. 모터 관절 다시 조립하기

diff가 1000을 넘으면 모터 관절의 조립 각도가 다른 것이니 물리적으로 다시 맞춰야 합니다.

양쪽 토크를 끄고, 팔로워의 해당 모터에서 고정 나사를 풀고, 관절 부품을 빼서 돌려 다시 끼우고, 나사를 조이고, compare_pos.py로 다시 재세요. diff가 줄었으면 맞는 방향이고, 늘었으면 반대 방향입니다. 한 번에 맞추려 하지 말고 재면서 접근하세요.

방향과 각도는 이렇게 어림잡을 수 있습니다. diff = follower - leader가 양수면 팔로워가 리더보다 큰 값에 있으므로 값이 작아지는 방향으로 돌립니다. 일반적으로 + 방향이 오른쪽이나 앞쪽, - 방향이 왼쪽이나 뒤쪽입니다. 각도는 diff × 360 / 4096도이고, diff가 2048이면 180도입니다. 계산이 힘들면 AI에게 물어보는 것이 편합니다!!

모터 출력축과 관절 부품은 나사 구멍 위치가 정해져 있어 임의의 각도로 조립할 수 없습니다. 가장 가까운 위치로 끼우면 수십에서 수백 카운트가 남는데, 그 정도는 4-2절대로 그냥 두면 됩니다.

4-4. 팔로워 그립퍼가 충분히 열리지 않을 때

teleop 로그에서 리더의 정규화 출력값이 0~100 범위인데 62 근처에서 천장이면 이 경우입니다.

t=44.59  lead 62.4  goal 2338

LeRobot이 리더 그립퍼에 토크를 걸어 정규화 위치 gripper_open_pos(기본값 60)로 끌고 가기 때문에 팔로워에 전달되는 최대 목표가 제한됩니다. 리더 그립퍼가 시작할 때 확 벌어지는 것도 스프링이 아니라 이 토크 때문입니다.

range_max를 넓혀도 해결되지 않으므로, teleop과 record 명령에 아래 옵션을 추가하세요.

--teleop.gripper_open_pos=95

양쪽 모두에 넣어야 합니다. 한쪽에만 넣으면 다른 쪽에서 기본값으로 돌아갑니다.

5. 그 밖에 자주 걸리는 것

옵션이 조용히 무시될 때

역슬래시 뒤에 #이 오면 그 줄의 나머지와 줄 이어주기까지 주석으로 버려지므로, 명령이 그 지점에서 끝나고 뒤의 옵션들은 기본값이 쓰입니다. 역슬래시 뒤의 공백도 같은 문제를 일으킵니다.

아래는 잘못된 예시입니다. 이렇게 쓰면 reset_time_s부터 전부 무시됩니다.

--dataset.episode_time_s=60 \ # 한 동작의 총 시간
--dataset.reset_time_s=10 \
--dataset.push_to_hub=false

주석은 명령 블록 위로 분리하고, 복사해 붙일 때 줄 끝 공백을 확인하세요. 옵션이 전달됐는지는 실행 직후의 설정 덤프로 확인합니다.

제어 루프가 목표 FPS를 못 맞출 때 (LeRobot)

Control loop is running slower (22.0 Hz) than the target FPS (30 Hz).

에피소드 종료 시 출력되는 cadence summary에서 telemetry가 작업 시간의 큰 비중을 차지하면 --display_data=true의 rerun 시각화가 원인입니다. GPU가 없는 환경에서는 소프트웨어 렌더링으로 돌아 비용이 큽니다.

본 녹화에서는 아래 옵션으로 끄세요.

--display_data=false

카메라가 MJPG로 설정되지 않을 때 (LeRobot)

failed to set fourcc=mjpg (actual=YUYV, success=True). Continuing with default format.

소문자는 거부되므로 대문자 MJPG와 backend: V4L2를 함께 지정하세요.

그 전에 카메라가 해당 해상도를 MJPG로 지원하는지 확인합니다. 다음 명령을 shell에서 실행하세요.

v4l2-ctl --device=/dev/video0 --list-formats-ext

적용 확인은 설정 덤프의 'fourcc': 'MJPG'와 'backend': <Cv2Backends.V4L2: 200>로 합니다.

YUYV는 비압축이라 640x480 30fps에 약 18 MB/s를 요구하므로, USB2에서 카메라 두 대를 돌리면 프레임이 떨어집니다.

6. 참고: 이 로봇에서 측정된 값

그대로 쓰지 마세요. 조립 공차와 나사 조립 상태에 따라 달라집니다. 같은 절차로 본인 로봇을 재세요. 어떤 값을 재야 하고 정상 범위가 어느 정도인지 참고하기 위한 자료입니다.

구성

리더 암 ID 1~~6, 팔로워 암 ID 11~~16입니다. 모델은 리더 1~~5가 1200, 리더 6이 1190, 팔로워 11~~13이 1060, 팔로워 14~16이 1200입니다.

최종 설정값

팔로워 그립퍼 ID 16, Operating Mode 5(Current-Based Position Control)입니다.

레지스터	주소	값	영역
Current_Limit	38	600	EEPROM
Min_Position_Limit	52	2123	EEPROM
Max_Position_Limit	48	2873	EEPROM
Homing_Offset	20	0	EEPROM
Goal_Current (유지)	102	100	RAM
Goal_Current (이동 부스트)	102	200	RAM
Position_P_Gain	84	800	RAM
Position_I_Gain	82	0	RAM
Position_D_Gain	80	0	RAM

리더 그립퍼 ID 6은 Homing_Offset 100, 범위 917 ~ 2577입니다.

명령줄 옵션은 --teleop.gripper_open_pos=95를 teleop과 record 양쪽에, 본 녹화에서 --display_data=false를 썼습니다.

Overload가 전류 초과가 아니라는 근거 (2장)

Current_Limit 600, Goal_Current 250 설정에서 전류가 162일 때 Overload가 발생했습니다. PWM이 상한 885에 붙은 채 2.5초 지속된 직후입니다.

t=12.19  goal 2336  pos 2340  cur   -8   pwm    -6   정상
t=12.79  goal 2295  pos 2338  cur -105   pwm  -363   물체에 닿음
t=13.36  goal 1999  pos 2338  cur -162   pwm  -885   PWM 상한 고정
         (2.5초간 pwm -885, cur -162, pos 2338 전부 고정)
t=15.82                                    err 32

Goal_Current를 100으로 내린 뒤 72초간 에러 없이 유지됐습니다. 전류가 101에서 규제되고 PWM이 285에 머물렀습니다.

t=43.99  goal 2333  pos 2300  cur 101  pwm 285

측정된 전류 천장은 약 160, PWM_Limit은 885였습니다. Goal_Current 150은 천장에 너무 가까워 몇 초 만에 과부하가 났고, 100은 안정적이었습니다. 온도는 72초 동안 29도에서 32도로 올랐습니다.

Position 게인 (2-2절)

기본값이 P 250, I 0, D 600이었습니다. D가 P의 2.4배인 상태에서 Goal_Current를 300에서 500으로 올려도 전류가 300에 못 미치고 2100대에서 막혔습니다.

Goal_Current	전류 최대	결과
300	161	2188에서 막힘
500	160	2110에서 막힘

P 800, I 0, D 0으로 바꾼 뒤 위치 오차가 몇 카운트 이내로 줄고 전류가 2~60에 머물렀습니다. P 1500은 오히려 나빠져 2450 목표에서 2344에 멈추고 전류가 160까지 올랐습니다.

기구 걸림 (2-4절)

자유롭게 움직일 때 3~18 mA, 걸렸을 때 150 mA 이상이었습니다. 손으로는 전혀 빡빡하게 느껴지지 않았습니다. 100 mA가 이 모터 최대 토크의 7% 수준이기 때문입니다.

그립퍼 측 나사 하나가 열림을 막고 있었고, 조인 뒤 열림 끝이 2573에서 2902로 330 카운트 넓어졌습니다.

리더와 팔로워 불일치 (4장)

14번 모터가 대응되는 4번과 어긋나 있었습니다. 모터 관절을 180도 돌려 다시 조립해 차이를 92 카운트까지 줄였고, 남은 92는 보정하지 않고 진행했습니다. 그 상태로 50 에피소드를 녹화했으며 문제가 없었습니다.

그립퍼는 모델이 달라 가동 폭 자체가 달랐습니다.

모터	모델	범위	폭
리더 6	1190	897 ~ 2597	1700
팔로워 16	1200	2083 ~ 2602	519

제어 루프 (5장)

--display_data=true일 때 작업 시간 13.9 ms, false일 때 5.2 ms였습니다. 끈 뒤 틱당 평균 28.4 ms의 여유가 생겼습니다.

저장소의 다른 파일

우리 설정을 그대로 가져다 쓰려면 아래 두 파일을 쓸 수 있습니다. 로봇이 다르면 값이 맞지 않으니 참고용으로만 보세요.

omx_patches.diff 는 LeRobot 소스 수정 내역입니다. 2-5절과 2-7절의 내용이 들어 있습니다.

cd ~/lerobot
git apply /내려받은/경로/omx_patches.diff
git diff --stat

omx_calibration.tar.gz 는 캘리브레이션 디렉터리 전체입니다. 아카이브 루트가 calibration/ 이므로 그 상위 경로에 풀어야 합니다.

tar xzf omx_calibration.tar.gz -C ~/.cache/huggingface/lerobot

omx_calibration/ 에는 같은 내용이 펼쳐져 있어 웹에서 바로 읽을 수 있습니다. .bak 과 .bak2 는 고치기 전 상태입니다.

7. 참고 메모

Dynamixel은 RS-485 반이중 통신이라 한 선으로 송수신을 번갈아 하므로 마스터는 하나여야 합니다. 제어 프로그램이 돌아가는 중에 별도 터미널에서 같은 포트를 읽으면 양쪽 패킷이 섞여 체크섬 오류와 쓰레기값이 나옵니다. 리눅스는 tty를 여러 프로세스가 열도록 허용하므로 포트 열기는 성공하고 그 다음에 깨집니다. 실시간 로그가 필요하면 이미 버스를 쥔 프로세스 안에서 읽으세요.

레지스터는 RAM과 EEPROM으로 나뉩니다. RAM 값은 전원을 끄거나 reboot하면 초기화되고, EEPROM 값은 유지됩니다. EEPROM에 쓰려면 Torque_Enable=0이고 Hardware Error가 0이어야 합니다.

레지스터	주소	영역
Position_P/I/D_Gain	84 / 82 / 80	RAM
Goal_Current	102	RAM
Current_Limit	38	EEPROM
Min/Max_Position_Limit	52 / 48	EEPROM
Homing_Offset	20	EEPROM

레지스터 쓰기는 반환값과 읽기값을 둘 다 확인하세요. 허용 범위를 벗어난 값은 예외 없이 거부되고 이전 값이 남으므로, 읽기만으로는 "상한으로 잘렸다"와 "쓰기가 거부됐다"를 구분할 수 없습니다.

Hardware_Error_Status(주소 70)는 한 번 뜨면 reboot이나 전원을 끌 때까지 유지되므로, 매 테스트 시작 전에 명시적으로 지우고 지워졌는지 확인하세요. 온도가 정상인데 Overload가 떠 있으면 그 에러는 방금 생긴 것이 아닙니다.

임계값을 판정할 때는 평균이 아니라 피크가 필요하고, 샘플링 간격이 현상의 시간 규모보다 짧아야 합니다. 1.2초 간격에서는 보이지 않던 PWM 포화가 40 ms 간격에서 드러났습니다.

Downloads last month: -; Downloads are not tracked for this model. How to track

Video Preview

Robotics

lerobot-omx
/

omx-setup

OMX 모터 트러블슈팅 가이드

목차

이 저장소

1. 준비

1-1. 모터 상태 읽기

1-2. 어디로 갈지 판정

1-3. 에러 지우고 토크 끄기

2. 그립퍼에 Overload(에러 32)가 반복될 때

2-1. PWM 확인

2-2. Position 게인 조정

2-3. Goal_Current 내리기

2-4. 특정 위치에서만 안 움직일 때

2-5. 설정이 유지되지 않을 때 (LeRobot)

2-6. 검증

2-7. 이동 중에만 전류를 높이기 (선택)

3. 가동 범위를 측정해 반영하기

3-1. 토크를 끄고 손으로 측정

3-2. EEPROM에 쓰기

3-3. 캘리브레이션 파일도 함께 쓰기 (LeRobot)

3-4. 검증

4. 리더암과 팔로워암이 안 맞을 때 (LeRobot)

4-1. 위치 비교

4-2. 차이 해석

4-3. 모터 관절 다시 조립하기

4-4. 팔로워 그립퍼가 충분히 열리지 않을 때

5. 그 밖에 자주 걸리는 것

옵션이 조용히 무시될 때

제어 루프가 목표 FPS를 못 맞출 때 (LeRobot)

카메라가 MJPG로 설정되지 않을 때 (LeRobot)

6. 참고: 이 로봇에서 측정된 값

구성

최종 설정값

Overload가 전류 초과가 아니라는 근거 (2장)

Position 게인 (2-2절)

기구 걸림 (2-4절)

리더와 팔로워 불일치 (4장)

제어 루프 (5장)

저장소의 다른 파일

7. 참고 메모