# Isaac Teleop

Robotunuzu, çok modlu teleoperasyon çerçevesi olan NVIDIA [Isaac Teleop](https://github.com/NVIDIA/IsaacTeleop) ile kontrol edin. Isaac Teleop, tek bir `TeleopSession` nesnesini çeşitli giriş cihazlarından sürer: XR (VR) kumandaları, el takibi, tam vücut takibi, Manus eldivenleri, ayak pedalları ve daha fazlası.

LeRobot'ta Isaac Teleop, [`examples/isaac_teleop_to_so101/`](https://github.com/huggingface/lerobot/tree/main/examples/isaac_teleop_to_so101) altında bağımsız bir örnek olarak sunulur. Örnekteki `isaac_teleop` paketinde her Isaac Teleop giriş cihazı kendi `Teleoperator` alt sınıfıdır ve tek bir oturum yaşam döngüsünü paylaşır (bkz. `IsaacTeleopTeleoperator`). Bugün mevcut cihazlar **XR kontrolcüsü** (`XRController`) ve geri sürülebilir bir **SO-101 lider kol** (`SO101LeaderArm`); Manus eldivenler ve el/tam vütakibi doğal olarak sonraki cihazlardır. Bu kılavuz XR kontrolcüsüne odaklanır; SO-101 lider kol [Örneği çalıştır](#step-3-run-the-example) altında özetlenir.

**Bu kılavuzda şunları öğreneceksiniz:**

- Isaac Teleop cihazının bir robotun uç efektor (EE) hedefini nasıl sürdüğü
- XR kontrolcüsündeki _clutch_'un (sıkma/tutma) kolu sarsmadan teleoperasyonu nasıl devreye aldığı
- SO‑101 teleoperation örneğini çalıştırma ve hareket / gripper / IK ayarlarını yapma

## Kurulum

Örnek, LeRobot deposunda yer alır (`lerobot` pip paketi bir parçası değildir), bu nedenle depoyu klonlayıp kaynak kodundan kurulum yapın. Güncel ve resmi kurulum ve kullanım referansı, örneğin [`README.md`](https://github.com/huggingface/lerobot/tree/main/examples/isaac_teleop_to_so101/README.md) dosyasıdır; kısaca:

```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`, herkese açık PyPI üzerinde yayımlanmıştır (yalnızca Linux). `cloudxr` ek paketi, CloudXR çalışma zamanı bağlamalarını getirir; `retargeters-lite`, hem x86_64 hem de ARM (aarch64 — örneğin bir DGX Spark — üzerinde) çözümlenen, scipy tabanlı retargeter yoludur (aarch64'te, `dex-retargeting`/`nlopt` sabitlemeleri nedeniyle tam `retargeters` ek paketi çözümlenmediğinden, burada varsayılan olarak kullanılmamaktadır). x86_64 üzerinde ayrıca tam retargeter yığınını da yükleyebilirsiniz:

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

### CloudXR'ı yapılandırın ve bir başlık bağlayın

Isaac Teleop, oturumun bağlandığı OpenXR çalışma zamanını sağlayan **NVIDIA CloudXR** üzerinden kulaklığı makinenize aktarır. Varsayılan olarak LeTeleop, `teleop_device.connect()` çağrıldığında **CloudXR çalışma zamanını sizin için otomatik olarak başlatır**; artık ayrı bir kabukta `python -m isaacteleop.cloudxr` ve `source cloudxr.env` komutlarını çalıştırmanıza gerek yoktur. Tek ihtiyacınız, bağlı bir desteklenen kulaklık ve açık CloudXR güvenlik duvarı portlarıdır. Kulaklık eşleştirme ve güvenlik duvarı ayrıntıları için Isaac Teleop [Hızlı Başlangıç](https://nvidia.github.io/IsaacCapture/main/getting_started/quick_start.html) kılavuzunu izleyin.

**İlk çalıştırma (EULA).** İlk çalıştırma, NVIDIA CloudXR EULA'sını kabul etmelidir. Otomatik başlatma, bunu **stdin üzerinden** ister; bu nedenle başsız (headless) bir makinede girdi beklerken takılı kalır. EULA'yı bir kez, etkileşimli olarak şu komutla başlatın:

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

Bunun ardından, `connect()` çalışma zamanını etkileşimsiz olarak başlatır. Çalışma zamanı ayağa kalkarken başlatma işlemi **~30 sn boyunca** bekler.

**Yapılandırma.** `IsaacTeleopConfig` içindeki (tüm cihazlar tarafından paylaşılan) iki alan bunu kontrol eder:

- `auto_launch_cloudxr` (varsayılan `True`) — `connect()` işlevinin çalışma zamanını başlatıp başlatmayacağını belirtir. CloudXR zaten harici olarak çalışıyorsa `False` olarak ayarlayın.
- `cloudxr_env_file` (varsayılan `None`) — kulaklık taşıma yöntemini (ör. bir Apple Vision Pro profili) seçen isteğe bağlı bir CloudXR cihaz profili `.env`. Bu, başlatıcının **girdisi**dir; eski manuel akışın `source` etmenizi söylediği `~/.cloudxr/run/cloudxr.env` **çıktı** dosyası değildir. `None`, varsayılan otomatik WebRTC profilini korur — ancak SO-101 örneği, `--teleop.cloudxr_env_file` parametresini geçirmediğiniz sürece, `teleoperate.py` dosyasının yanında yer alan `default.env` dosyasıyla bunu geçersiz kılar.

**Devre dışı bırakma.** Otomatik başlatmayı atlamak için (CloudXR zaten çalışıyorsa) `auto_launch_cloudxr=False` değerini ayarlayın veya şu komutu dışa aktarın:

```bash
export LEROBOT_CLOUDXR_SKIP_AUTOLAUNCH=1
```

**Ortam değişkeni, yapılandırma alanına göre önceliklidir**: `LEROBOT_CLOUDXR_SKIP_AUTOLAUNCH=1` ayarlandığında, `auto_launch_cloudxr=True` olsa bile otomatik başlatma atlanır. Bu değişken, Isaac Lab'ın `ISAACLAB_CXR_SKIP_AUTOLAUNCH` değişkeninden **bağımsızdır** — birini ayarlamak diğerini etkilemez.

**Her işlem için tek bir teleoperatör.** CloudXR çalışma zamanı ortamı işlem düzeyinde yapılandırır (tekil), bu nedenle işlem başına tek bir Isaac Teleop teleoperatörü çalıştırın.

**Kapanıyor.** Çıkışta her zaman `teleop_device.disconnect()` çağrılmalıdır — Ctrl-C dahil. Teleoperasyon döngünüzü `try/finally` ile sarın ve `finally` bloğunda `disconnect()` çağrın. Bu işlem, OpenXR oturumunu CloudXR çalışma zamanından **önce** sonlandırır; bu, gerekli sıralamadır. Başlatıcının `atexit` kancası yalnızca çalışma zamanını toplar ve oturumun `__exit__` metodunu çalıştırmaz; bu nedenle açık bir `disconnect()` çağrısı yapılmazsa, yarıda kesilen bir çalıştırma yanlış sırayla kapanır.

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

Desteklenen OS / GPU / CloudXR sürümleri ve kulaklıklar için [Sistem Gereksinimleri](https://nvidia.github.io/IsaacCapture/main/references/requirements.html) bölümüne bakın.

## Nasıl çalışır

XR denetleyicisi, Isaac Teleop **giriş** cihazlarından biridir. `XRController` bilinçli olarak ince bir okuyucudur: robot taban çerçevesine statik olarak yeniden tabanlanmış **ham** denetleyici kavrama duruşunu, ayrıca sıkıştırma ve tetik analog değerlerini açığa çıkarır. Kendine ait **hiç** yeniden hedefleyicisi ve **hiç** kavrama mantığı yoktur. Kavrama (kilit + EE üzerine delta yeniden tabanlama) ve gripper eşlemesi, örnek döngünün içindeki aşağı akışta yer alır; bu döngü de LeRobot'un mevcut kapalı döngülü Kartezyen IK hattına besleme yapar — telefon teleoperatörünün kullandığı aynı hat. Cihaza özgü parçalar `XRController`, döngünün `Clutch` bileşeni ve `MapXRControllerActionToRobotAction`'dir; aşağı akıştaki her şey (`EEBoundsAndSafety`, `InverseKinematicsEEToJoints`) paylaşıldır ve gelecekteki bir cihaz (ör. Manus eldivenleri) kendi `teleop_<device>.py` + işlemcisini takarak geri kalanını yeniden kullanacaktır.

`XRController._build_pipeline`, Isaac Teleop'un `ControllersSource` bileşenini — yerel `ControllerTransform` (`base_T_anchor`) tarafından robot taban çerçevesine statik olarak yeniden tabanlanan — bağlar ve dönüştürülmüş denetleyici akışını olduğu gibi dışa açar. `get_action()`, kavrama duruşunu, sıkma ve tetik değerlerini doğrudan bu akıştan okur; oturum her zaman `RUNNING` olarak ilerletilir (kapı görevi üstlenecek bir clutch retargeter yoktur).

`Clutch` sınıfı (`examples/isaac_teleop_to_so101/isaac_teleop/clutch.py` içinde, `common.py` içindeki döngü tarafından yönetilir) Isaac Teleop'un `SO101ClutchRetargeter` bileşenini yansıtır ancak cihazın ince bir okuyucu olarak kalabilmesi için döngü içinde yer alır:

- Sıkıştırma **devreye alma kenarı**’nda (sıkıştırmanın `clutch_threshold`’i ilk kez aştığı kare) devreye alma orijinini kilitleyerek hem konumu hem de yönelimi bu nokta etrafında yeniden tabanlandırır; böylece devreye alma kolu teleporte etmez. `Clutch.rebase`, işlemciye beslenen 7 boyutlu `ee_pose`’e döngü tarafından birleştirilen mutlak taban çerçevesi hedefini `(pos, quat)` çifti olarak döndürür.
- Analog tetik, `[0, 1]` aralığında (0 = açık, 1 = kapalı) tetiğin çekilme miktarıyla orantılı bir `closedness` değerine dönüşür; bu değer `MapXRControllerActionToRobotAction` tarafından çene hedefine eşlenir.

Kaynak düğümlerin ve yeniden hedefleyicilerin nasıl bir araya geldiğini görmek için Isaac Teleop [Yeniden Hedefleme arayüzüne](https://nvidia.github.io/IsaacCapture/main/references/retargeting/index.html) ve [mimari genel bakışına](https://nvidia.github.io/IsaacCapture/main/overview/architecture.html) bakın.

```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
```

### Kavrama: örnek döngü tarafından yönetilir

Telefon hattından farklı olarak (kilit, `MapPhoneActionToRobotAction` ve `EEReferenceAndDelta` arasında bölünür), XR kilidi tamamen örnek döngüsündeki `Clutch` sınıfında yaşar. **Mutlak** bir EE duruşu yaydığı için `EEReferenceAndDelta` aşaması ve işlemcide delta biriktirme yoktur — `MapXRControllerActionToRobotAction` saf, durum içermeyen bir kare başına eşlemedir.

Kavrama, sıkıştırma **devreye alma kenarı** (sıkıştırmanın `clutch_threshold` değerini aştığı an) üzerinde devreye alma başlangıcını kilitleyerek EE'yi bu başlangıca göre hareket _göreli_ olarak sürer; böylece kol devreye alınırken ışınlanmaz. **Her** devreye almada — hem açılış hem de görev ortasında yeniden kavrama — ana _konum_, kolun **ölçülen eklemlerinden** ileri kinematik üzerinden kilitlenir; bu sayede kol devre dışıyken hareket etmiş olsa bile ana konum, kolun fiziksel olarak bulunduğu noktaya eşittir ve devreye alma sıçramasız gerçekleşir. Ana _yön_, son komut edilen dönmeyi korur: 5-DOF kol yalnızca yumuşak bir şekilde yönü takip eder, bu nedenle ölçülen bilek yönünün kilitlenmesi, her yeniden kavramada takip ofsetini komuta enjekte ederdi.

## Kontroller

- **Sıkıştırma / kavrama** — **clutch** (deadman). Teleoperasyonu başlatmak için `clutch_threshold` değerinin üzerinde tutun; duraklatmak için bırakın. Her başlatma işlemi orijini yeniden yakalar, böylece duraklatma sırasında elinizi yeniden konumlandırabilir ve kolun sıçramasına neden olmadan yeniden başlatabilirsiniz (index/clutch stili).
- **Tetik** — **analog** olarak kontrol edilen **gripper**. Çene, `[0, 1]` aralığındaki (0 = açık, 1 = kapalı) bir kapanma değeri aracılığıyla, mutlak gripper eklem hedefine eşlenen, tetiğe orantılı olarak takip eder — yarı basılı bir tetik, çeneyi yarı kapalı bırakır.
- **Kontrolcü yönelimi** — **bilek**. Clutch, kontrolcü yönelimini (engage‑göreli, taban‑çerçeve) bileğin konumla birlikte takip ettiği yumuşak bir IK yönelim hedefine yeniden tabanlar. 5‑DOF SO‑101'de bilek, tasarım gereği eli yalnızca kısmen takip eder — aşağıdaki `orientation_weight` değerine bakın.

## Başlayın

### Adım 1: Teleoperatörü oluşturun

```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()`, kavrama yeniden tabanlanmış bir hedef değil, **ham** taban çerçevesi denetleyici duruşunu döndürür: `grip_pos` (3,) `[x, y, z]` [m] ve `grip_quat` (4,) `[qx, qy, qz, qw]` robot taban çerçevesinde, ayrıca `[0, 1]` aralığında `squeeze` ve `trigger` skaler analog değerleri. Örnek döngüsünün `Clutch` bileşeni, bunları mutlak `ee_pose` değerine dönüştürür ve kavrama, döngü tarafından `clutch_threshold` eşiğine karşı eşiklenerek devreye alınır.

### Adım 2: Bağlan

Önce `teleop_device.connect()` çağrıldığında CloudXR çalışma zamanı otomatik olarak başlatılır (bunu devre dışı bıraktıysanız — bkz. [CloudXR'i yapılandırın ve bir başlık bağlayın](#set-up-cloudxr-and-connect-a-headset); bu işlem yaklaşık 30 saniye sürer ve ilk çalıştırmada stdin üzerinden EULA onayı ister), ardından Isaac Teleop [`TeleopSession`](https://nvidia.github.io/IsaacCapture/main/getting_started/teleop_session.html) başlatılır (OpenXR oturumunu açar ve denetleyicileri keşfeder). XR denetleyicileri kendini kalibre eder, bu nedenle manuel bir kalibrasyon adımı yoktur — kilit, her devreye aldığınızda yeniden merkezlemeyi ele alır. Oturumun çıkışta/Ctrl-C'de çalışma zamanından önce sonlandırılmasını sağlamak için `connect()` çağrısını, `disconnect()` çağıran bir `try/finally` bloğuyla eşleştirin.

### Adım 3: Örneği çalıştırın

Örnek, robotunuzu (SO‑101 takipçi) yapılandırdığınızı ve doğru seri portu ayarladığınızı varsayar.

İlk çalıştırmada **robot URDF'si ve mesh'leri otomatik olarak alınır**: XR cihazı, SO-101 URDF'sini [`lerobot/robot-urdfs` Hugging Face kovasından](https://huggingface.co/buckets/lerobot/robot-urdfs/tree/so101) LeRobot önbelleğine (`HF_LEROBOT_HOME/robot-urdfs/so101/`) indirir ve sonrasında yeniden kullanır; bu nedenle ayrı bir indirme adımı yoktur:

```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, `lerobot-teleoperate` tarzındadır (draccus): `--robot.*` SO-101 takipçisini yapılandırır, `--teleop.type` ise Isaac giriş cihazını seçer (`xr_controller` | `so101_leader`); cihaz ayarları `--teleop.*` ile yapılır. `--teleop.type=xr_controller`, yukarıda açıklanan XR denetleyici yolunu çalıştırır. Başlangıç güvenlik sözleşmesi: varsayılan olarak tüm eklemler, `--reset_duration` saniye boyunca varsayılan sıfırlama duruşuna doğru hareket ettirilir (`--reset_to_origin=false` kolu mevcut konumunda bırakır), ardından kavramanın ana konumu, koldan ölçülen duruşla tohumlanır ki ilk kavrama sıçramasız olsun; takipçi yalnızca kavrama bağlıyken komut alır.

**Sıfırlama pozunu özelleştirme.** Sıfırlama pozu, yerleşik bir varsayılan olarak (rahat bir orta aralıkta poz) gelir ve kutudan çıktığı gibi çalışır — herhangi bir şey kaydetmenize gerek **yoktur**. Bunu kendi kurulumunuza uyarlamak için, kolu istediğiniz poza geri sürükleyin ve `python -m examples.isaac_teleop_to_so101.override_reset_pose --id <robot.id>` komutunu çalıştırın; bu komut, mevcut eklem değerlerini LeRobot önbelleğindeki kol başına bir dosyaya yazar (`HF_LEROBOT_HOME/reset_poses/<robot.name>/<robot.id>.json`, kalibrasyon gibi anahtarlanır) ve bu dosya, sonraki çalıştırmada yerleşik varsayılanın önceliğini alır. Kullanıcıya özel önbellekte (depo dışında) barındığı için, geçersiz kılma ayarınız makinenizde kalır ve hem `teleoperate` hem de `record`, aynı `--robot.id` ile başlatıldığında bu ayarı dikkate alır.

Diğer cihaz, `--teleop.type=so101_leader`, geri sürülebilir bir SO-101 _lider kolunun_ eklemlerini Isaac Teleop'un yerel `so101_leader` eklentisi üzerinden akışa alarak takipçiyi 1:1 oranında yansıtır (kavrama yok, IK yok — lider ve takipçi SO-101 kinematiğini paylaşır).

`so101_leader_plugin` ikili dosyası, `isaacteleop` pip paketinin **parçası olmayan** bir C++ eklentisidir — Isaac Teleop kaynak ağacından derlenir. [Isaac Teleop'u kaynaktan derleme](https://nvidia.github.io/IsaacCapture/main/getting_started/build_from_source/index.html) başlığındaki adımları izleyin (kısa özetle, Isaac Teleop klonunuzdan: `cmake -B build && cmake --build build --parallel && cmake --install build`); derleme, eklentileri `/install/plugins/` altında kurar, bu nedenle ikili dosya `install/plugins/so101_leader/so101_leader_plugin` konumuna yerleşir — aşağıdaki `--launch_plugin` yolu. Seri/calibrasyon detayları için eklentinin kendi `README.md` dosyasına (ikili dosyanın yanında) bakın.

`--teleop.port` noktasını fiziksel liderin seri portuna ve `--launch_plugin` noktasını o eklenti ikili dosyasına yönlendirin; böylece betik, CloudXR ayağa kalktıktan sonra onu başlatır:

```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
```

(Not: burada `so101_leader`, _Isaac_ lideridir ve Isaac Teleop cihaz kayıt defterine göre çözümlenir; `lerobot-teleoperate`'nin `so101_leader` seri numarasından farklıdır.) `--teleop.port` ayarlandığında, eklentinin tick→radyan kalibrasyonu `--teleop.id`'den çıkarılır ve eklentiye üçüncü konumsal argüman olarak iletilir — `HF_LEROBOT_CALIBRATION/teleoperators/so_leader/<id>.json` adresindeki LeRobot biçimli JSON dosyası, seri SO-101 liderinin kullandığı aynı dosyadır (`lerobot-calibrate --teleop.type=so101_leader --teleop.id=<id>`). Dosya eksikse betik uyarı verir ve eklenti yerleşik varsayılanları kullanır. Tüm bayraklar için `python -m examples.isaac_teleop_to_so101.teleoperate --help` komutunu çalıştırın. Başlangıç güvenlik sözleşmesi: varsayılan olarak takipçi, aynalama başladığında kolun aniden sıçramaması için ilk lider okumasına `--align_duration` saniye içinde (`--align=false` ile atlanabilir) hizalanır ve lider akışı bayatken takipçi, ölçülen pozisyonunda tutulur.

URDF indirme işlemi, herkese açık `lerobot/robot-urdfs` kovasına karşı `huggingface_hub` (zaten bir LeRobot bağımlılığı) kullanır, bu nedenle giriş gerektirmez. `HF_LEROBOT_HOME/robot-urdfs/so101/` altında önbelleğe alınır; yeniden indirmeyi zorlamak için bu klasörü silin.

Ardından, kulaklığınızda: kavramayı sıkıp basılı tutarak etkinleştirin, kolu hareket ettirmek için kontrolcüyü hareket ettirin, bileği konumlandırmak için döndürün/egzayın ve kavrayıcıyı kapatmak için tetiğe basın (orantılı olarak — açmak için bırakın).

Bir veri seti kaydetmek için (yalnızca teleoperasyon yapmak için değil), aynı klasördeki `record.py` dosyasını kullanın. `--teleop.type` (`xr_controller` | `so101_leader`) parametresine, `teleoperate.py` ile birebir aynı şekilde yönlendirme yapar; bu sayede her iki cihaz da takipçiyi sürdürebilir ve komut verilen eklem değerlerini bir LeRobot veri setine kaydeder (`lerobot-record` tarzında `--dataset.*` bayrakları). Tam CLI ve klavye ile kayıt kısayolları için modül docstring'ine bakın.

## Önemli iş akışı adımları ve seçenekleri

Clutch zaten mutlak bir taban çerçevesi duruşu (pose) üretir, bu nedenle işlemci tarafı ince bir **mutlak-duruş** yoludur — çerçeve yeniden eşleme, delta biriktirme veya `EEReferenceAndDelta` aşaması yoktur.

- `MapXRControllerActionToRobotAction`, cihaz çıktısından IK giriş sözleşmesine yapılan durum içermeyen kare başına bir eşleştirmedir. Mutlak taban çerçevesi konumunu yazar, mutlak yönelimi bir rotvec hedefi olarak kodlar ve kapalılığı tersine çevirerek motorlu kavrama hedefi oluşturur:

  ```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
  ```

  Gripper polaritesi (`100 = open, 0 = closed`) kaynakta bir donanım kalibrasyonu sözleşmesidir — çene kapanması gerektiği halde açılıyorsa orada tersine çevirin.

- `EEBoundsAndSafety`, EE'yi bir çalışma alanına sınırlar ve kare başına sıçramaları hız sınırlar. Kavranın (clutch) teleport-olmama özelliği kareleri küçük tuttuğu için `max_ee_step_m` çoğunlukla geçici denetleyici takip hatalarını yakalar. z alt sınırı `0.0`'dır (masa düzlemi) böylece saplanmış bir hedef EE'yi masanın altına sürükleyemez; x/y ise gevşek `[-1, 1]` m kutusunda kalır. Sınırı aşan bir kare hata fırlatmak yerine **sınırlandırılıp uyarılsın** diye `raise_on_jump=False` ayarlayın — döngünün ortasında bir çökme, kolu kontrolsüz bırakır:

  ```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)` kapalı döngülü Placo IK'yi çözer. SO‑101 bir 5‑DOF koldur, bu nedenle IK konum ağırlıklıdır; küçük `orientation_weight` değeri, `ee.w*` içinde taşınan yönelim hedefini yumuşak bir şekilde takip etmesine izin vererek bileğin eli izlemesini sağlar, belirsiz kalan roll ise tasarım gereği kısmi kalır. `GripperVelocityToJoint` **yoktur**: mutlak `ee.gripper_pos` değeri doğrudan `gripper.pos`'a iletilir. `initial_guess_current_joints=False` parametresi, her çözümü ölçülen eklemlerden yeniden başlatmak yerine **önceki IK çözümünden** başlatır, böylece eklem yörüngesi kare kare arası süreklilik gösterir. `orientation_weight` değerini donanımda ayarlayın — çok yüksekse konum takibiyle çelişir, çok düşükse yönelim komutunu görmezden gelir.

Örnek, güvenlik kontrolünü döngü düzeyinde de uygular: açılış sıfırlama rampasından (varsayılan olarak açıktır — kolu mevcut konumunda tutmak için `--reset_to_origin=false` parametresini geçirin) sonra, robot **yalnızca kavrama bağlıyken** komut alır ve kavrama kopukken ölçülen eklem değerlerini yeniden gönderir; böylece kavramayı bırakmak kolu yerinde dondurur.

Diğer robotlara uyarlamaya ilişkin daha fazla bilgi için [Robotlar ve Teleoperatörler için İşleyiciler](./processors_robots_teleop) kılavuzuna bakın.

## Sorun Giderme

- **`ModuleNotFoundError: isaacteleop`** — `isaacteleop` paketi etkin ortamda yüklü değil. Bu kılavuzun başındaki kurulum komutunu yeniden çalıştırın: `uv pip install "isaacteleop[cloudxr,retargeters-lite]~=1.3.131"`.
- **Denetleyici bulunamadı** — CloudXR çalışma zamanının çalıştığından, güvenlik duvarı portlarının beyaz listeye eklendiğinden ve başlığın bağlı olduğundan emin olun (bkz. [CloudXR'i yapılandırın ve bir başlık bağlayın](#set-up-cloudxr-and-connect-a-headset) ve Isaac Teleop [Hızlı Başlangıç](https://nvidia.github.io/IsaacCapture/main/getting_started/quick_start.html)).
- **CloudXR otomatik başlatma başarısız oldu** — çalışma zamanı, başlatma zaman aşımı içinde ayağa kalkmazsa `connect()` bir `RuntimeError` fırlatır. Başlatıcı günlüklerini `~/.cloudxr/logs` altında kontrol edin. Yaygın nedenler: EULA hiç kabul edilmedi (bir kez, etkileşimli olarak `python -m isaacteleop.cloudxr --accept-eula` çalıştırın — otomatik başlatma stdin üzerinde istek yapar ve headless ortamda takılır) veya çalışma zamanı zaten harici olarak çalışıyor (`LEROBOT_CLOUDXR_SKIP_AUTOLAUNCH=1` veya `auto_launch_cloudxr=False` ayarlayarak otomatik başlatmayı atlayın).
- **Kol hareket etmiyor** — kavrama bir ölü adam (deadman) mekanizmasıdır: `clutch_threshold` değerini aşacak şekilde sıkma/tutma işlemini sürdürmeniz gerekir. Kontrolcünüzün sıkma değeri düşük raporlanıyorsa eşiği düşürün.
- **Hareket hizasız görünüyor** — başlığın/oynama alanının yönelimini doğrulayın. Kontrolcü akışı, `XRControllerConfig` üzerindeki `base_T_anchor` dönüşümü ile robot taban çerçevesine yeniden tabanlanır (varsayılan: standart OpenXR → robot eksen kuralı); çapa çerçeveniz farklıysa bunu ayarlayın.

## Daha fazla bilgi edinin

NVIDIA Isaac Teleop belgeleri ([belgeler ana sayfası](https://nvidia.github.io/IsaacCapture/), [GitHub](https://github.com/NVIDIA/IsaacTeleop)):

- [Hızlı Başlangıç](https://nvidia.github.io/IsaacCapture/main/getting_started/quick_start.html) — kurulum, CloudXR sunucusunu çalıştırma, bir başlık takma ve bir teleop örneğini çalıştırma.
- [TeleopSession](https://nvidia.github.io/IsaacCapture/main/getting_started/teleop_session.html) — `XRController`'ın sarmaladığı oturum API'si.
- [Yeniden hedefleme arayüzü](https://nvidia.github.io/IsaacCapture/main/references/retargeting/index.html) ve [mimari genel bakış](https://nvidia.github.io/IsaacCapture/main/overview/architecture.html) — kaynak düğümlerin ve yeniden hedefleyicilerin bir iş akışına nasıl birleştirildiği.
- [Kaynaktan derle](https://nvidia.github.io/IsaacCapture/main/getting_started/build_from_source/index.html) — `isaacteleop`'u (ve yukarıda kullanılan `so101_leader` eklentisi dahil C++ eklentilerini) yerel bir kopyadan derleyin.
- [Sistem Gereksinimleri](https://nvidia.github.io/IsaacCapture/main/references/requirements.html) ve [CloudXR SDK belgeleri](https://docs.nvidia.com/cloudxr-sdk) — desteklenen platformlar, GPU'lar, CloudXR/OpenXR çalışma zamanı sürümleri ve kulaklıklar.