# YAM

[YAM](https://doc.i2rt.com/products/yam) est un bras 6-DOF de [I2RT Robotics](https://i2rt.com/) destiné à l’apprentissage par imitation et à l’IA incarnée. Dans LeRobot, `yam_follower` pilote un bras YAM v1 standard équipé de la pince linéaire DM4310, et `bi_yam_follower` en pilote deux. Utilisez-les avec `lerobot-calibrate`, `lerobot-rollout` et `lerobot-replay`. LeRobot ne dispose pas encore de bras YAM leader, de sorte qu’un YAM est piloté par une politique ou par la rejouée d’un jeu de données.

Assemblez et câblez les bras en suivant les guides d'I2RT ; cette page couvre le côté LeRobot.

| Guide                                                           | Ce qu'il couvre                                  |
| --------------------------------------------------------------- | ----------------------------------------------- |
| [Série de bras YAM](https://doc.i2rt.com/products/yam)             | Déballage, montage, câblage, moteurs et pinces |
| [Configuration logicielle](https://doc.i2rt.com/getting-started/sw-setup) | Adaptateurs CAN, débit et noms d’interface fixes |
| [YAM Cell](https://doc.i2rt.com/products/yam-cell)              | Station bimanuelle avec deux suiveurs et meneurs |

  <img
    src="https://doc.i2rt.com/images/yam-standard/YAM-ST-GP-1.webp"
    alt="YAM follower arm with the linear gripper"
    width="48%"
  />
  <img
    src="https://doc.i2rt.com/images/yam-station/DS-ST-1.webp"
    alt="YAM Cell bimanual station"
    width="48%"
  />

_Suiveur YAM (à gauche) et station bimanuelle YAM Cell (à droite). LeRobot pilote les suiveurs. Images fournies par I2RT Robotics._

## Matériel et sécurité

Chaque bras est équipé de sept moteurs aux identifiants 1 à 7 : DM4340 pour les articulations 1 à 3, et DM4310 pour les articulations 4 à 6 ainsi que la pince. YAM Pro, Ultra, BIG YAM et les autres pinces ne sont pas encore pris en charge.

Vous avez besoin de :

- Linux, et un adaptateur USB vers CAN par bras (SocketCAN, CAN classique à 1 Mbit/s).
- Le timeout CAN de chaque moteur est réglé sur au plus 400 ms (`8000` ticks, la valeur de I2RT), par exemple avec `set_timeout.py --timeout` du [I2RT SDK](https://github.com/i2rt-robotics/i2rt). Le timeout est le dernier filet de sécurité si LeRobot cesse d'envoyer des commandes, donc LeRobot n'activera pas le couple sans lui.
- Accès à Internet lors de la première connexion : la compensation de gravité télécharge le modèle YAM depuis le bucket [`lerobot/robot-urdfs`](https://huggingface.co/buckets/lerobot/robot-urdfs/tree/yam/v1) et le met en cache sous `HF_LEROBOT_HOME/robot-urdfs/yam/v1`.

> [!WARNING]
> Fixez le bras à une surface stable et gardez son espace de travail dégagé. Le débranchement désactive le couple et le bras tombe sous l’effet de la gravité : soutenez-le d’abord. Si l’alimentation ou un adaptateur CAN se débranche pendant son fonctionnement, arrêtez le programme, soutenez le bras, puis reconnectez.

## Installer LeRobot 🤗

Suivez le [Guide d'installation](./installation), puis installez la prise en charge de YAM :

```bash
pip install -e ".[yam]"
```

Cela installe `motorbridge` et `python-can` pour le bras, ainsi que `placo` pour la compensation de gravité.

## Connecter le matériel

Chaque bras nécessite sa propre interface CAN, car les deux bras utilisent les mêmes identifiants de moteurs.

```bash
lerobot-setup-can --mode=setup --interfaces=can0 --use_fd=false
```

Utilisez `--interfaces=can0,can1` pour deux bras. La commande configure les interfaces Linux avec `sudo ip link` et n’envoie aucune commande aux moteurs. Avec deux bras, `can0` et `can1` peuvent être intervertis après un redémarrage : vérifiez quel bras chaque interface pilote, ou attribuez-leur des noms fixes tels que `can_follower_l` via la [configuration logicielle](https://doc.i2rt.com/getting-started/sw-setup) d’I2RT, et utilisez ces noms comme port.

## Types de périphériques

| Type              | Appareil            |
| ----------------- | ----------------- |
| `yam_follower`    | Un seul suiveur   |
| `bi_yam_follower` | Suiveur bimanuel |

Avec deux bras, définissez les options de chaque bras avec `--robot.left_arm_config.<option>` et `--robot.right_arm_config.<option>`.

## Calibration

La calibration ne mesure que les limites de la pince, entièrement fermée et entièrement ouverte : les articulations conservent leurs zéros d'usine. Plier le bras d'abord, comme indiqué ci-dessous. Le couple est désactivé pendant la mesure : soutenir le bras, ne déplacer que la pince à la main, et appuyer sur Entrée à chaque invite. Si une calibration existe déjà, la connexion démarre le contrôle : appuyer sur Entrée pour la réutiliser, ou taper `c` pour mesurer à nouveau, et LeRobot vous demande de soutenir le bras avant de désactiver le couple.

  <img
    src="https://doc.i2rt.com/images/yam-standard/YAM-ST-GP-2.webp"
    alt="YAM arm in its folded position"
    width="48%"
  />
  <img
    src="https://doc.i2rt.com/images/linear-gripper-4310/GP-4310-CTR-1.webp"
    alt="Linear DM4310 gripper"
    width="48%"
  />

_Position repliée, avec chaque articulation à zéro (à gauche), et le pinceur linéaire DM4310 (à droite). Images fournies par I2RT Robotics._

```bash
lerobot-calibrate --robot.type=yam_follower --robot.port=can0 --robot.id=yam
```

Le gaucher est mesuré en premier, puis le droit, dans les fichiers `<id>_left` et `<id>_right`.

```bash
lerobot-calibrate --robot.type=bi_yam_follower --robot.id=bimanual_yam \
  --robot.left_arm_config.port=can0 --robot.right_arm_config.port=can1
```

Utilisez le même `--robot.id` dans les commandes suivantes afin que LeRobot charge le fichier enregistré.

## Observations et actions

Un bras possède `joint_1.pos` à `joint_6.pos`, puis `gripper.pos`, pour les observations et les actions. Les articulations sont des angles absolus en degrés, et la pince va de 0 (fermée) à 100 (ouverte). `use_degrees=false` bascule sur les radians et de 0 à 1, comme utilisé par les données I2RT et MolmoAct2. `use_velocity_and_torque=true` ajoute les observations `.vel` et `.torque`. Les actions sont des cibles absolues d'articulation, limitées aux bornes des articulations.

Les deux bras utilisent les mêmes noms avec les préfixes `left_` et `right_`. Les caméras positionnées sur un bras sont également préfixées, tandis que les `--robot.cameras` de premier niveau conservent leurs noms.

## Exécuter une politique

Placez le bras dans sa position repliée, avec chaque articulation à zéro, avant de le connecter : LeRobot vérifie que chaque articulation est à moins de 11,5° de cette position, puis démarre le contrôle à partir de la position mesurée. Rien ne bouge tant que la politique n’envoie pas une action.

```bash
lerobot-rollout \
  --robot.type=yam_follower --robot.port=can0 --robot.id=yam \
  --robot.cameras='{"wrist": {"type": "opencv", "index_or_path": 0, "width": 640, "height": 480, "fps": 30}}' \
  --policy.path=<user>/<policy> \
  --task="Pick up the cube"
```

Pour deux bras, utilisez `--robot.type=bi_yam_follower --robot.id=bimanual_yam --robot.left_arm_config.port=can0 --robot.right_arm_config.port=can1`. Ajoutez `--dataset.repo_id=<user>/rollout_<name>` pour enregistrer le déroulement ; voir [Exécuter l’inférence et évaluer votre politique](./il_robots#run-inference-and-evaluate-your-policy). `lerobot-replay` rejoue un épisode enregistré avec les mêmes options `--robot.*`.

Avant la première action, et lorsqu’aucune action n’arrive pendant `command_timeout_s` (1 s), le bras maintient sa position. Avec `idle_mode=float`, les articulations sont au contraire compensées par la gravité et légèrement amorties, ce qui permet de déplacer le bras à la main, tandis que la pince conserve son ouverture ; le suivi reprend à l’endroit où vous l’avez déplacé.

## Sécurité

- Une panne du moteur ou l'absence de retour d'information arrête toutes les commandes. Avec deux bras, une panne sur l'un d'eux arrête les deux. Débranchez puis rebranchez pour continuer.
- Le modèle de gravité couvre le bras standard sans caméras ni charges utiles. Après en avoir ajouté, vérifiez que le bras ne dérive pas en mode flottant et ajustez `gravity_factors` si c'est le cas.

## Options de configuration

| Option                    | Par défaut                          | Description                                                |
| ------------------------- | -------------------------------- | ---------------------------------------------------------- |
| `port`                    | requis                         | Interface SocketCAN, par exemple `can0`                    |
| `use_degrees`             | `true`                           | Degrés et pince 0–100 ; `false` donne des radians et 0–1 |
| `use_velocity_and_torque` | `false`                          | Ajouter les observations `.vel` et `.torque`                      |
| `idle_mode`               | `hold`                           | `hold` la position ou `float` lorsqu'aucune action n'arrive      |
| `command_timeout_s`       | `1.0`                            | Secondes sans action avant le mode inactif             |
| `initial_position_deg`    | tous des zéros                        | Position initiale requise ; `None` ignore la vérification          |
| `initial_tolerance_deg`   | `11.5`                           | Distance autorisée par rapport à la position initiale                 |
| `gripper_force_limit_n`   | `50.0`                           | Force des doigts une fois que le préhenseur est bloqué sur un objet      |
| `gravity_factors`         | `[1.0, 1.1, 1.1, 1.2, 1.0, 1.0]` | Multiplicateurs par articulation de la compensation de la gravité          |
| `cameras`                 | `{}`                             | Caméras fixées au bras                                |

## Exemple : MolmoAct2

[`lerobot/MolmoAct2-BimanualYAM-LeRobot`](https://huggingface.co/lerobot/MolmoAct2-BimanualYAM-LeRobot) est `allenai/MolmoAct2-BimanualYAM` au format LeRobot, avec ses statistiques de normalisation publiées. Il a été entraîné sur deux bras YAM en radians et une pince de 0 à 1, avec trois caméras dans l’ordre haut, gauche, droite ; voir [MolmoAct2](./molmoact2).

```bash
pip install -e ".[yam,molmoact2,dataset]"

lerobot-rollout \
  --robot.type=bi_yam_follower --robot.id=bimanual_yam \
  --robot.left_arm_config.port=can0 --robot.right_arm_config.port=can1 \
  --robot.left_arm_config.use_degrees=false --robot.right_arm_config.use_degrees=false \
  --robot.cameras='{
    "top": {"type": "opencv", "index_or_path": "/dev/v4l/by-id/TOP_CAMERA", "width": 640, "height": 480, "fps": 30},
    "left": {"type": "opencv", "index_or_path": "/dev/v4l/by-id/LEFT_CAMERA", "width": 640, "height": 480, "fps": 30, "fourcc": "MJPG"},
    "right": {"type": "opencv", "index_or_path": "/dev/v4l/by-id/RIGHT_CAMERA", "width": 640, "height": 480, "fps": 30, "fourcc": "MJPG"}
  }' \
  --policy.path=lerobot/MolmoAct2-BimanualYAM-LeRobot \
  --inference.type=rtc --inference.rtc.execution_horizon=20 --inference.queue_threshold=20 \
  --device=cuda --interpolation_multiplier=2 \
  --interactive=true --play_sounds=false \
  --task="Pick up the red block and place it in the green bin"
```

Tapez `/start` pour exécuter la politique, `/subtask <text>` pour modifier l'instruction, `/reset` pour revenir à la position initiale et `/stop` pour quitter. Le retour dure un temps fixe et la limite de vitesse de YAM s'applique toujours, de sorte qu'un bras éloigné de sa position initiale peut s'arrêter avant d'y parvenir.

Le mode Float permet de démarrer la politique depuis n’importe quelle position : ajoutez `--robot.left_arm_config.idle_mode=float --robot.right_arm_config.idle_mode=float`. Avant le premier `/start`, et 1 s après la fin d’un `/reset`, placez les bras manuellement à l’endroit souhaité, puis tapez `/start` pour exécuter la politique depuis cette position. N’utilisez pas `/stop` pour cela : cela met fin à la session et désactive le couple.

## Dépannage

| Problème                                         | Vérifier                                                                                                        |
| ----------------------------------------------- | ------------------------------------------------------------------------------------------------------------ |
| L'interface CAN est absente ou hors service            | Vérifiez l'alimentation et le câble USB de l'adaptateur, ainsi que `ip link show`. Exécutez à nouveau `lerobot-setup-can`.                  |
| `missing or stale motor feedback`               | Vérifiez l'alimentation 24 V, le câblage CAN et la terminaison, les identifiants des moteurs 1 à 7, et que `port` est l'interface de ce bras. |
| Le mauvais bras se déplace                             | Vérifiez quel bras chaque interface pilote, ou attribuez des noms fixes aux interfaces.                                   |
| `unsafe motor CAN timeout`                      | Définissez le délai d'attente CAN de chaque moteur sur au plus 400 ms avec le SDK I2RT.                                           |
| `not within initial_tolerance_deg`              | Plier le bras, avec chaque articulation à zéro, avant de le connecter.                                                   |
| La connexion vous demande de recalibrer          | Utilisez le même `--robot.id` que lors de l'étalonnage.                                                             |
| Le bras dérive en mode flottant                    | Ajustez `gravity_factors` pour les caméras ou la charge utile du bras.                                              |
| MolmoAct2 déplace les bras vers les mauvaises positions | Définissez `use_degrees=false` sur les deux bras : le modèle utilise des radians et une pince de 0 à 1.                              |

## Références

- [Série de bras YAM](https://doc.i2rt.com/products/yam) : matériel, moteurs et pinces
- [Configuration logicielle](https://doc.i2rt.com/getting-started/sw-setup) : vitesse du bus CAN et noms d'interface fixes
- [YAM Cell](https://doc.i2rt.com/products/yam-cell) : station bimanuelle
- [I2RT SDK](https://github.com/i2rt-robotics/i2rt) : outils de motorisation, modèle URDF et modèle MuJoCo
- [Page produit YAM](https://i2rt.com/products/yam-6-dof-arm)
- [MolmoAct2](./molmoact2) : chargement de la politique dans LeRobot

