# Isaac Teleop

Kendalikan robot Anda dengan NVIDIA [Isaac Teleop](https://github.com/NVIDIA/IsaacTeleop), sebuah kerangka kerja teleoperasi multi-modal. Isaac Teleop menggerakkan satu `TeleopSession` dari berbagai perangkat input — kontroler XR (VR), pelacakan tangan, pelacakan seluruh tubuh, sarung tangan Manus, pedal kaki, dan lainnya.

Di LeRobot, Isaac Teleop tersedia sebagai contoh mandiri di bawah [`examples/isaac_teleop_to_so101/`](https://github.com/huggingface/lerobot/tree/main/examples/isaac_teleop_to_so101). Setiap perangkat input Isaac Teleop merupakan subclass `Teleoperator` tersendiri dalam paket `isaac_teleop` dari contoh tersebut, berbagi satu siklus hidup sesi (lihat `IsaacTeleopTeleoperator`). Perangkat yang tersedia saat ini adalah **XR controller** (`XRController`) dan lengan pemimpin **SO-101 leader arm** yang dapat digerakkan mundur (`SO101LeaderArm`); sarung tangan Manus dan pelacakan tangan/tubuh penuh adalah perangkat alami berikutnya. Panduan ini berfokus pada XR controller; lengan pemimpin SO-101 dirangkum di bawah [Jalankan contoh](#step-3-run-the-example).

**Panduan ini akan mengajarkan Anda:**

- Bagaimana perangkat Isaac Teleop menggerakkan target end-effector (EE) robot
- Cara _clutch_ (jepit/genggaman pada pengendali XR) mengaktifkan teleoperasi tanpa membuat lengan bergerak tersentak
- Cara menjalankan contoh teleoperasi SO‑101 dan menyesuaikan gerakan / gripper / IK

## Instalasi

Contoh ini terdapat di repositori LeRobot (bukan bagian dari paket pip `lerobot`), jadi klon repositori dan instal dari sumber. Referensi instalasi dan penggunaan yang resmi serta selalu mutakhir adalah [`README.md`](https://github.com/huggingface/lerobot/tree/main/examples/isaac_teleop_to_so101/README.md) dari contoh tersebut; singkatnya:

```bash
git clone https://github.com/huggingface/lerobot.git
cd lerobot
uv pip install -e ".[feetech,kinematics,dataset]" "huggingface_hub>=1.5"
uv pip install "isaacteleop[cloudxr,retargeters-lite]~=1.3.131" "scipy>=1.14"
```

`isaacteleop` dipublikasikan di PyPI publik (hanya untuk Linux). Ekstra `cloudxr` menyediakan binding runtime CloudXR; `retargeters-lite` adalah jalur retargeter berbasis scipy yang dapat di-resolve di arsitektur x86_64 maupun ARM (pada aarch64 — misalnya DGX Spark — ekstra `retargeters` penuh tidak dapat di-resolve karena pin `dex-retargeting`/`nlopt`-nya, itulah mengapa ini bukan default di sini). Pada x86_64, Anda juga dapat menginstal stack retargeter penuh:

```bash
uv pip install "isaacteleop[retargeters]~=1.3.131"
```

### Set up CloudXR dan hubungkan headset

Isaac Teleop mengalirkan headset ke mesin Anda melalui **NVIDIA CloudXR**, yang menyediakan runtime OpenXR tempat sesi terhubung. Secara default, LeTeleop **meluncurkan runtime CloudXR secara otomatis untuk Anda** saat Anda memanggil `teleop_device.connect()` — Anda tidak perlu lagi menjalankan `python -m isaacteleop.cloudxr` dan `source cloudxr.env` di shell terpisah. Yang Anda butuhkan hanyalah headset yang didukung dan port firewall CloudXR yang terbuka. Ikuti [Quick Start](https://nvidia.github.io/IsaacCapture/main/getting_started/quick_start.html) Isaac Teleop untuk detail pairing headset dan firewall.

**Eksekusi pertama (EULA).** Peluncuran pertama kali harus menerima EULA NVIDIA CloudXR. Peluncuran otomatis meminta persetujuan **di stdin**, sehingga pada mesin headless proses akan menggantung menunggu input. Bootstrap EULA sekali, secara interaktif, dengan:

```bash
python -m isaacteleop.cloudxr --accept-eula   # one-time: accept the CloudXR EULA
```

Setelah itu, `connect()` meluncurkan runtime secara non-interaktif. Peluncuran **terblokir selama ~30 detik** saat runtime berjalan.

**Konfigurasi.** Dua field pada `IsaacTeleopConfig` (dibagikan oleh setiap perangkat) mengontrol hal ini:

- `auto_launch_cloudxr` (default `True`) — apakah `connect()` memulai runtime. Atur `False` jika CloudXR sudah berjalan secara eksternal.
- `cloudxr_env_file` (default `None`) — profil perangkat CloudXR opsional `.env` yang memilih transport headset (misalnya profil Apple Vision Pro). Ini adalah **input** launcher; bukan file **output** `~/.cloudxr/run/cloudxr.env` yang alur manual lama menyuruh Anda untuk `source`. `None` mempertahankan profil auto-WebRTC default — meskipun contoh SO-101 menimpanya menjadi `default.env` yang disertakan di samping `teleoperate.py` kecuali Anda meneruskan `--teleop.cloudxr_env_file`.

**Opt out.** Untuk melewati auto-launch (CloudXR sudah berjalan), atur `auto_launch_cloudxr=False` atau export:

```bash
export LEROBOT_CLOUDXR_SKIP_AUTOLAUNCH=1
```

**variabel lingkungan memiliki prioritas di atas field konfigurasi**: jika `LEROBOT_CLOUDXR_SKIP_AUTOLAUNCH=1` disetel, auto-launch akan dilewati meskipun `auto_launch_cloudxr=True`. Variabel ini **tidak bergantung** pada `ISAACLAB_CXR_SKIP_AUTOLAUNCH` dari Isaac Lab — menyetel salah satunya tidak memengaruhi yang lain.

**Satu teleoperator per proses.** Runtime CloudXR mengonfigurasi lingkungan secara keseluruhan proses (singleton), sehingga jalankan satu teleoperator Isaac Teleop per proses.

**Menutup.** Selalu panggil `teleop_device.disconnect()` saat keluar — termasuk saat Ctrl-C. Bungkus loop teleoperation Anda dengan `try/finally` dan panggil `disconnect()` di dalam `finally`. Ini akan membongkar sesi OpenXR **sebelum** runtime CloudXR, yang merupakan urutan yang diperlukan; hook `atexit` launcher hanya membersihkan runtime dan tidak menjalankan `__exit__` sesi, sehingga tanpa `disconnect()` yang eksplisit, eksekusi yang terputus akan ditutup dengan urutan yang salah.

```python
teleop_device.connect()
try:
    while True:
        action = teleop_device.get_action()
        # ... drive the robot ...
finally:
    teleop_device.disconnect()
```

Lihat [Syarat Sistem](https://nvidia.github.io/IsaacCapture/main/references/requirements.html) untuk versi OS / GPU / CloudXR dan headset yang didukung.

## Cara kerjanya

The XR controller is one Isaac Teleop **input** device. `XRController` is a deliberately thin reader: it exposes the **raw** controller grip pose — already statically rebased into the robot base frame — plus the squeeze and trigger analog values. It has **no** retargeters and **no** clutch logic of its own. The clutch (engage latch + delta rebasing onto the EE) and the gripper mapping live downstream in the example loop, which then feeds LeRobot's existing closed‑loop Cartesian IK pipeline — the same one the phone teleoperator uses. The device‑specific pieces are `XRController`, the loop's `Clutch`, and `MapXRControllerActionToRobotAction`; everything downstream (`EEBoundsAndSafety`, `InverseKinematicsEEToJoints`) is shared, and a future device (e.g. Manus gloves) would swap in its own `teleop_<device>.py` + processor while reusing the rest.

`XRController._build_pipeline` menghubungkan `ControllersSource` dari Isaac Teleop — yang direbase secara statis ke kerangka dasar robot oleh `ControllerTransform` asli (`base_T_anchor`) — dan mengekspos aliran controller yang telah ditransformasikan apa adanya. `get_action()` membaca pose grip, squeeze, dan trigger langsung darinya; sesi selalu di-step `RUNNING` (tidak ada clutch retargeter untuk gating).

Kelas `Clutch` (di `examples/isaac_teleop_to_so101/isaac_teleop/clutch.py`, yang dijalankan oleh loop di `common.py`) meniru `SO101ClutchRetargeter` dari Isaac Teleop, tetapi berada di dalam loop sehingga perangkat dapat tetap menjadi pembaca yang tipis:

- Itu mengunci titik awal engage pada **tepi engage** (frame di mana squeeze pertama kali melampaui `clutch_threshold`) dan melakukan rebase pada posisi maupun orientasi di sekitarnya, sehingga engage tidak membuat lengan berpindah secara instan. `Clutch.rebase` mengembalikan target frame basis absolut sebagai pasangan `(pos, quat)`, yang kemudian digabungkan oleh loop menjadi `ee_pose` 7D yang diberikan ke processor.
- Pemicu analog menjadi `closedness` gripper dalam `[0, 1]` (0 = terbuka, 1 = tertutup), yang proporsional terhadap penarikan pemicu, dan dipetakan oleh `MapXRControllerActionToRobotAction` ke target rahang.

Lihat [Antarmuka Retargeting](https://nvidia.github.io/IsaacCapture/main/references/retargeting/index.html) dan [ringkasan arsitektur](https://nvidia.github.io/IsaacCapture/main/overview/architecture.html) Isaac Teleop untuk memahami bagaimana node sumber dan retargeter dikomposisikan.

```text
  VR controller (OpenXR)
        │
        ▼
  XRController.get_action()          ── raw base-frame grip_pos / grip_quat + squeeze + trigger
        │                                (TeleopSession always stepped RUNNING; clutch lives downstream)
        ▼
  Clutch.rebase(grip_pos, grip_quat) ── engage-relative delta applied to the EE home (pos + orient)
        │  ee_pose (7) / closedness       → absolute ee_pose; closedness = trigger
        ▼
  MapXRControllerActionToRobotAction ── absolute ee.x/y/z; ee.w* = orientation rotvec target;
        │  ee.x/y/z / ee.w* / ee.gripper_pos   ee.gripper_pos = (1 - closedness) * 100
        ▼
  EEBoundsAndSafety                ── workspace clip + per-frame step clamp (clamp+warn)
        │
        ▼
  InverseKinematicsEEToJoints      ── closed-loop Placo IK; position + soft-orientation
        │  (orientation_weight=0.01)   (passes ee.gripper_pos → gripper.pos)
        ▼
  SO-101 follower joint targets
```

### Klutch: dimiliki oleh loop contoh

Berbeda dengan pipeline telepon (yang membagi clutch di antara `MapPhoneActionToRobotAction` dan `EEReferenceAndDelta`), clutch XR sepenuhnya berada di kelas `Clutch` pada loop contoh. Kelas ini mengeluarkan pose EE **absolut**, sehingga tidak ada tahap `EEReferenceAndDelta` dan tidak ada akumulasi delta di prosesor — `MapXRControllerActionToRobotAction` adalah pemetaan per-frame yang murni dan stateless.

Clutch mengunci titik awal engage pada **tepi engage** dari squeeze (saat squeeze melewati `clutch_threshold`) dan menggerakkan EE dari gerakan _relatif_ terhadap titik asal tersebut, sehingga lengan tidak teleport saat engage. Pada **setiap** engage — baik saat startup maupun re-clutch di tengah tugas — posisi _home_ dikunci dari kinematika maju pada **sendi terukur** lengan, sehingga home sama dengan posisi fisik lengan bahkan jika lengan bergerak saat disengaged, dan engage bebas lompatan. Orientasi _home_ mempertahankan rotasi terakhir yang diperintahkan: lengan 5-DOF hanya melacak orientasi secara lunak, sehingga mengunci orientasi wrist yang terukur akan menyuntikkan offset pelacakannya ke perintah pada setiap re-clutch.

## Kontrol

- **Squeeze / grip** — **clutch** (deadman). Tahan melewati `clutch_threshold` untuk mengaktifkan teleoperation; lepaskan untuk jeda. Setiap pengaktifan menangkap ulang titik asal, sehingga Anda dapat memosisikan ulang tangan Anda saat jeda dan mengaktifkan kembali tanpa lengan melompat (gaya index/clutch).
- **Pemicu** — **cengkeram**, dikendalikan secara **analog**. Rahang mengikuti pemicu secara proporsional — pemicu yang ditekan setengah membuat rahang tertutup setengah — melalui tingkat penutupan dalam `[0, 1]` (0 = terbuka, 1 = tertutup) yang dipetakan ke target sendi cengkeram absolut.
- **Orientasi controller** — **pergelangan**. Clutch melakukan rebase orientasi controller (engage‑relative, base‑frame) menjadi target orientasi IK lunak yang diikuti oleh pergelangan bersama dengan posisi. Pada 5‑DOF SO‑101, pergelangan hanya mengikuti tangan secara parsial sesuai desain — lihat `orientation_weight` di bawah.

## Mulai

### Langkah 1: Buat teleoperator

```python
# Run from the repo root so the `examples` package is importable.
from examples.isaac_teleop_to_so101.isaac_teleop import XRController, XRControllerConfig

teleop_config = XRControllerConfig(
    hand_side="right",      # "left" or "right" controller
    clutch_threshold=0.5,   # squeeze value above which the clutch engages
)
teleop_device = XRController(teleop_config)
```

`XRController.get_action()` mengembalikan pose pengendali bingkai dasar **mentah**, bukan target yang di-rebase oleh clutch: `grip_pos` (3,) `[x, y, z]` [m] dan `grip_quat` (4,) `[qx, qy, qz, qw]` dalam bingkai dasar robot, serta nilai analog skalar `squeeze` dan `trigger` dalam `[0, 1]`. `Clutch` pada loop contoh mengubah nilai-nilai ini menjadi `ee_pose` absolut, dan squeeze di-threshold oleh loop terhadap `clutch_threshold` untuk mengaktifkannya.

### Langkah 2: Hubungkan

Memanggil `teleop_device.connect()` terlebih dahulu akan secara otomatis meluncurkan runtime CloudXR (kecuali Anda memilih untuk tidak mengaktifkannya — lihat [Set up CloudXR and connect a headset](#set-up-cloudxr-and-connect-a-headset); proses ini akan memblokir selama sekitar 30 detik dan pada eksekusi pertama akan meminta persetujuan EULA di stdin), kemudian memulai [`TeleopSession`](https://nvidia.github.io/IsaacCapture/main/getting_started/teleop_session.html) Isaac Teleop (membuka sesi OpenXR dan mendeteksi controller). Controller XR bersifat self-calibrating, sehingga tidak ada langkah kalibrasi manual — clutch menangani re-centering setiap kali Anda mengaktifkannya. Gunakan `connect()` bersama dengan `try/finally` yang memanggil `disconnect()` agar sesi diakhiri sebelum runtime saat keluar/Ctrl-C.

### Langkah 3: Jalankan contoh

Contoh ini mengasumsikan Anda telah mengonfigurasi robot Anda (SO‑101 follower) dan mengatur port serial yang benar.

**URDF robot dan mesh-nya diambil secara otomatis** pada eksekusi pertama: perangkat XR mengunduh URDF SO-101 dari [bucket Hugging Face `lerobot/robot-urdfs`](https://huggingface.co/buckets/lerobot/robot-urdfs/tree/so101) ke cache LeRobot (`HF_LEROBOT_HOME/robot-urdfs/so101/`) dan memakainya kembali setelahnya, sehingga tidak ada langkah unduhan terpisah:

```bash
python -m examples.isaac_teleop_to_so101.teleoperate --robot.type=so101_follower --robot.port=/dev/ttyACM0 \
    --robot.id=so101_follower_arm --teleop.type=xr_controller
```

CLI-nya bergaya `lerobot-teleoperate` (draccus): `--robot.*` mengonfigurasi pengikut SO-101 dan `--teleop.type` memilih perangkat input Isaac (`xr_controller` | `so101_leader`), dengan `--teleop.*` sebagai pengaturan perangkatnya. `--teleop.type=xr_controller` menjalankan jalur XR-controller yang dijelaskan di atas. Kontrak keselamatan saat startup: secara bawaan, semua sendi digeser ke pose reset bawaan selama `--reset_duration` detik (`--reset_to_origin=false` mempertahankan posisi lengan saat itu), kemudian benih rumah kopling diambil dari pose terukur lengan agar pengaktifan pertama bebas lompatan; pengikut hanya diberi perintah selama kopling aktif.

**Menyesuaikan pose reset.** Pose reset disertakan sebagai bawaan default (pose mid-range yang nyaman) dan langsung berfungsi — Anda **tidak** perlu merekam apa pun. Untuk menyesuaikannya dengan setup Anda, gerakkan lengan ke pose yang diinginkan lalu jalankan `python -m examples.isaac_teleop_to_so101.override_reset_pose --id <robot.id>`; perintah ini menulis joint saat ini ke file per-lengan di cache LeRobot (`HF_LEROBOT_HOME/reset_poses/<robot.name>/<robot.id>.json`, dengan kunci seperti kalibrasi), yang kemudian memiliki prioritas lebih tinggi daripada bawaan default pada eksekusi berikutnya. Karena file ini berada di cache lokal pengguna (bukan di repo), override Anda tetap tersimpan di mesin Anda, dan baik `teleoperate` maupun `record` akan menghormatinya saat diluncurkan dengan `--robot.id` yang sama.

Perangkat lainnya, `--teleop.type=so101_leader`, mencerminkan pengikut secara 1:1 dari lengan pemimpin SO-101 _leader arm_ yang dapat digerakkan mundur, di mana sendi-sendi di dalamnya dialirkan oleh plugin `so101_leader` bawaan Isaac Teleop (tanpa kopling, tanpa IK — pemimpin dan pengikut berbagi kinematika SO-101).

Binary `so101_leader_plugin` adalah plugin C++ yang **tidak** termasuk dalam paket pip `isaacteleop` — Anda membangunnya dari pohon sumber Isaac Teleop. Ikuti [Membangun Isaac Teleop dari sumber](https://nvidia.github.io/IsaacCapture/main/getting_started/build_from_source/index.html) (secara singkat, dari checkout Isaac Teleop Anda: `cmake -B build && cmake --build build --parallel && cmake --install build`); proses build menginstal plugin di bawah `/install/plugins/`, sehingga binary berada di `install/plugins/so101_leader/so101_leader_plugin` — jalur `--launch_plugin` di bawah ini. Lihat `README.md` milik plugin itu sendiri (di sebelah binary) untuk detail serial/kalibrasinya.

Arahkan `--teleop.port` ke port serial fisik leader dan `--launch_plugin` ke binari plugin tersebut agar skrip memunculkannya setelah CloudXR siap:

```bash
python -m examples.isaac_teleop_to_so101.teleoperate --robot.type=so101_follower --robot.port=/dev/ttyACM0 \
    --robot.id=so101_follower_arm --teleop.type=so101_leader \
    --teleop.port=/dev/ttyACM1 --teleop.id=so101_leader_arm \
    --launch_plugin=/code/Teleop/install/plugins/so101_leader/so101_leader_plugin
```

(Catatan: `so101_leader` di sini adalah leader _Isaac_, yang diselesaikan terhadap registri perangkat Isaac Teleop, berbeda dari serial `so101_leader` milik `lerobot-teleoperate`.) Ketika `--teleop.port` diset, kalibrasi tick→radian dari plugin disimpulkan dari `--teleop.id` dan diteruskan ke plugin sebagai argumen posisional ketiganya — yaitu JSON format LeRobot di `HF_LEROBOT_CALIBRATION/teleoperators/so_leader/<id>.json`, file yang sama yang digunakan oleh leader SO-101 serial (`lerobot-calibrate --teleop.type=so101_leader --teleop.id=<id>`). Jika file tersebut tidak ada, skrip akan memberikan peringatan dan plugin menggunakan nilai bawaan. Jalankan `python -m examples.isaac_teleop_to_so101.teleoperate --help` untuk melihat semua flag. Kontrak keselamatan saat startup-nya: secara default, follower digeser ke pembacaan pertama leader selama `--align_duration` detik (`--align=false` untuk dilewati) agar lengan tidak bergerak mendadak saat mirror dimulai, dan selama stream leader tidak aktif, follower ditahan pada pose terukurnya.

Pengambilan URDF menggunakan `huggingface_hub` (yang sudah menjadi dependensi LeRobot) terhadap bucket publik `lerobot/robot-urdfs`, sehingga tidak memerlukan login. Hasilnya di-cache di bawah `HF_LEROBOT_HOME/robot-urdfs/so101/`; hapus folder tersebut untuk memaksa unduhan ulang.

Lalu, di headset Anda: jepit dan tahan grip untuk mengaktifkan, gerakkan controller untuk menggerakkan lengan, putar/miringkan untuk mengarahkan pergelangan tangan, dan tekan trigger untuk menutup gripper (secara proporsional — lepaskan untuk membuka).

Untuk merekam dataset (bukan hanya teleoperasi), gunakan `record.py` di folder yang sama. Skrip ini mendispatch berdasarkan `--teleop.type` (`xr_controller` | `so101_leader`) persis seperti `teleoperate.py`, sehingga perangkat mana pun dapat menggerakkan follower, dan menyimpan sendi yang diperintahkan ke dataset LeRobot (flag `--dataset.*` bergaya `lerobot-record`). Lihat docstring modulnya untuk CLI lengkap dan pintasan keyboard untuk perekaman.

## Langkah dan opsi pipeline penting

Clutch sudah menghasilkan pose base-frame absolut, sehingga sisi processor adalah jalur **pose-absolut** yang tipis — tidak ada pemetaan ulang frame, tidak ada akumulasi delta, dan tidak ada tahap `EEReferenceAndDelta`.

- `MapXRControllerActionToRobotAction` adalah pemetaan per-frame tanpa status dari output perangkat ke kontrak input IK. Kelas ini menulis posisi absolut pada base-frame, mengkodekan orientasi absolut sebagai target rotvec, dan membalikkan closedness menjadi target gripper motor:

  ```python
  action["ee.x"], action["ee.y"], action["ee.z"] = ee_pose[:3]   # absolute, base frame [m]
  action["ee.wx"], action["ee.wy"], action["ee.wz"] = orient_rotvec  # orientation target (rotvec)
  action["ee.gripper_pos"] = (1 - closedness) * 100   # motor units; SO-101 calibrates 100 = open
  ```

  Polaritas gripper (`100 = open, 0 = closed`) adalah konvensi kalibrasi perangkat keras di sumber — balikkan di sana jika rahang terbuka saat seharusnya tertutup.

- `EEBoundsAndSafety` membatasi EE ke dalam area kerja dan membatasi laju lompatan per frame. Fitur no-teleport pada clutch menjaga agar frame tetap kecil, sehingga `max_ee_step_m` terutama menangkap gangguan pelacakan pengendali yang bersifat sementara. Lantai z adalah `0.0` (bidang meja) sehingga target yang tersesat tidak dapat mendorong EE di bawah meja; x/y tetap berada di kotak longgar `[-1, 1]` m. Atur `raise_on_jump=False` sehingga frame yang melebihi batas akan **dibatasi dan diberi peringatan** alih-alih memicu error — crash di tengah loop akan meninggalkan lengan tanpa kendali:

  ```python
  EEBoundsAndSafety(
      end_effector_bounds={"min": [-1.0, -1.0, 0.0], "max": [1.0, 1.0, 1.0]},
      max_ee_step_m=0.10,
      raise_on_jump=False,
  )
  ```

- `InverseKinematicsEEToJoints(initial_guess_current_joints=False, orientation_weight=0.01)` menyelesaikan IK Placo closed‑loop. SO‑101 adalah lengan 5‑DOF, sehingga IK bersifat dominan posisi; `orientation_weight` yang kecil memungkinkannya melacak target orientasi yang dibawa dalam `ee.w*` secara lembut agar pergelangan mengikuti tangan, sementara roll yang under‑determined tetap parsial sesuai desain. Tidak ada **node** `GripperVelocityToJoint`: nilai absolut `ee.gripper_pos` diteruskan langsung ke `gripper.pos`. `initial_guess_current_joints=False` melakukan warm‑start setiap penyelesaian dari **solusi IK sebelumnya** alih‑alih menanam ulang dari sendi yang diukur, sehingga trajektori sendi tetap kontinu antar‑frame. Sesuaikan `orientation_weight` pada perangkat keras — terlalu tinggi akan mengganggu pelacakan posisi, terlalu rendah akan mengabaikan perintah orientasi.

Contoh ini juga mengunci keamanan pada level loop: setelah slew reset saat startup (aktif secara default — berikan `--reset_to_origin=false` untuk menjaga lengan tetap di posisinya), robot diperintahkan **hanya saat clutch terhubung**, dan sendi yang diukur dikirim ulang saat clutch dilepas, sehingga melepas clutch akan membekukan lengan di tempatnya.

Lihat panduan [Processors for Robots and Teleoperators](./processors_robots_teleop) untuk informasi lebih lanjut tentang cara menyesuaikan pipeline untuk robot lain.

## Pemecahan Masalah

- **`ModuleNotFoundError: isaacteleop`** — paket `isaacteleop` tidak terpasang di lingkungan aktif. Jalankan ulang perintah instalasi di bagian atas panduan ini: `uv pip install "isaacteleop[cloudxr,retargeters-lite]~=1.3.131"`.
- **Tidak ada controller yang ditemukan** — pastikan runtime CloudXR sedang berjalan, port firewall sudah di-whitelist, dan headset terhubung (lihat [Set up CloudXR and connect a headset](#set-up-cloudxr-and-connect-a-headset) dan [Quick Start](https://nvidia.github.io/IsaacCapture/main/getting_started/quick_start.html) Isaac Teleop).
- **Gagal auto-launch CloudXR** — `connect()` akan melempar `RuntimeError` jika runtime tidak berhasil dimulai dalam batas waktu startup. Periksa log launcher di `~/.cloudxr/logs`. Penyebab umum: EULA belum pernah diterima (jalankan `python -m isaacteleop.cloudxr --accept-eula` sekali, secara interaktif — auto-launch akan meminta konfirmasi di stdin dan menggantung jika headless), atau runtime sudah berjalan secara eksternal (setel `LEROBOT_CLOUDXR_SKIP_AUTOLAUNCH=1` atau `auto_launch_cloudxr=False` untuk melewati auto-launch).
- **Lengan tidak bergerak** — kopling bersifat deadman: Anda harus menahan jepit/genggaman melewati `clutch_threshold`. Turunkan ambang batasnya jika jepit pada kontroler Anda dilaporkan secara lemah.
- **Motion terasa tidak selaras** — pastikan orientasi headset/ruang bermain. Aliran controller di-rebase ke dalam kerangka dasar robot oleh transformasi `base_T_anchor` pada `XRControllerConfig` (default: konvensi sumbu OpenXR standar → robot); sesuaikan jika kerangka anchor Anda berbeda.

## Pelajari lebih lanjut

Dokumentasi NVIDIA Isaac Teleop ([beranda dokumen](https://nvidia.github.io/IsaacCapture/), [GitHub](https://github.com/NVIDIA/IsaacTeleop)):

- [Pemulaan Cepat](https://nvidia.github.io/IsaacCapture/main/getting_started/quick_start.html) — instal, jalankan server CloudXR, sambungkan headset, jalankan contoh teleop.
- [TeleopSession](https://nvidia.github.io/IsaacCapture/main/getting_started/teleop_session.html) — API sesi yang dibungkus oleh `XRController`.
- [Antarmuka retargeting](https://nvidia.github.io/IsaacCapture/main/references/retargeting/index.html) dan [ringkasan arsitektur](https://nvidia.github.io/IsaacCapture/main/overview/architecture.html) — bagaimana node sumber dan retargeter disusun menjadi pipeline.
- [Membangun dari sumber](https://nvidia.github.io/IsaacCapture/main/getting_started/build_from_source/index.html) — bangun `isaacteleop` (dan plugin C++-nya, termasuk plugin `so101_leader` yang digunakan di atas) dari checkout lokal.
- [System Requirements](https://nvidia.github.io/IsaacCapture/main/references/requirements.html) dan [CloudXR SDK docs](https://docs.nvidia.com/cloudxr-sdk) — platform yang didukung, GPU, versi runtime CloudXR/OpenXR, dan headset.

