# Robots

Chaque robot dans LeRobot implémente l'interface `Robot` : connexion, lecture d'une observation, envoi d'une action, déconnexion. Écrire une politique ou un script d'enregistrement en s'appuyant sur cette interface garantit qu'il fonctionne avec n'importe quel bras pris en charge, sans modification.

Cette page est la référence générée. Pour le câblage, l'étalonnage et les instructions de première exécution, commencez par les guides matériels — [SO-101](../so101), [LeKiwi](../lekiwi), [Hope Jr](../hope_jr), [Reachy 2](../reachy2), [OpenArm](../openarm) — ou [Imitation Learning for Robots](../il_robots) pour le flux de travail de bout en bout. Pour les robots maintenus par la communauté en dehors du jeu de base, consultez [Third-Party Robots & Teleoperators](../third_party_robots). Pour ajouter votre propre robot, consultez [Bring Your Own Hardware](../integrate_hardware).

## Robot[[lerobot.robots.Robot]]

La classe de base abstraite. Les sous-classes implémentent chaque méthode ci-dessous ; le contrat décrit ici est ce sur quoi une politique ou une boucle d’enregistrement peut s’appuyer.

#### lerobot.robots.Robot[[lerobot.robots.Robot]]

```python
lerobot.robots.Robot(config: RobotConfig)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/robot.py#L33)

**Paramètres :**

config_class (RobotConfig) : La classe de configuration attendue pour ce robot.

name (str) : Le nom unique du robot utilisé pour identifier ce type de robot.

Classe abstraite de base pour tous les robots compatibles LeRobot.

Cette classe fournit une interface standardisée pour interagir avec des robots physiques. Les sous-classes doivent implémenter toutes les méthodes et propriétés abstraites pour être utilisables.

#### connect[[lerobot.robots.Robot.connect]]

```python
connect(calibrate: bool = True)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/robot.py#L136)

**Paramètres :**

calibrate (bool) : Si True, calibre automatiquement le robot après la connexion s'il n'est pas calibré ou a besoin d'un recalibrage (dépendant du matériel).

Établir la communication avec le robot.

#### déconnecter[[lerobot.robots.Robot.disconnect]]

```python
disconnect()
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/robot.py#L237)

Déconnectez-vous du robot et effectuez le nettoyage nécessaire.

#### configurer[[lerobot.robots.Robot.configure]]

```python
configure()
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/robot.py#L202)

Appliquez toute configuration à usage unique ou d'exécution au robot. Cela peut inclure la définition des paramètres des moteurs, des modes de contrôle ou de l'état initial.

#### calibrer[[lerobot.robots.Robot.calibrate]]

```python
calibrate()
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/robot.py#L153)

Calibrez le robot le cas échéant. Sinon, cette opération ne doit rien faire.

Cette méthode doit collecter les données nécessaires (par exemple, les décalages moteurs) et mettre à jour le dictionnaire :pyattr:`calibration` en conséquence.

#### get_observation[[lerobot.robots.Robot.get_observation]]

```python
get_observation()
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/robot.py#L210)

**Retourne :** `RobotObservation`

Un dictionnaire plat représentant l'état sensoriel actuel du robot. Sa structure doit correspondre à :pymeth:`observation_features`.

Récupérer l'observation actuelle du robot.

#### send_action[[lerobot.robots.Robot.send_action]]

```python
send_action(action: dict)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/robot.py#L222)

**Paramètres :**

action (RobotAction) : dictionnaire représentant l’action souhaitée. Sa structure doit correspondre à :pymeth:`action_features`.

**Retourne :** `RobotAction`

L'action réellement envoyée aux moteurs, potentiellement tronquée ou modifiée, par exemple par des limites de sécurité sur la vitesse.

Envoyer une commande d'action au robot.

#### observation_features[[lerobot.robots.Robot.observation_features]]

```python
observation_features()
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/robot.py#L100)

Un dictionnaire décrivant la structure et les types des observations produites par le robot. Sa structure (clés) doit correspondre à celle de ce qui est renvoyé par :pymeth:`get_observation`. Les valeurs du dictionnaire doivent être :
- Le type de la valeur s'il s'agit d'une valeur simple, par exemple `float` pour une valeur proprioceptive unique (position/vitesse d'une articulation)
- Un tuple représentant la forme s'il s'agit d'une valeur de type tableau, par exemple `(height, width, channel)` pour les images

Note : cette propriété doit pouvoir être appelée, que le robot soit connecté ou non.

#### action_features[[lerobot.robots.Robot.action_features]]

```python
action_features()
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/robot.py#L114)

Un dictionnaire décrivant la structure et les types des actions attendues par le robot. Sa structure (clés) doit correspondre à celle de ce qui est transmis à :pymeth:`send_action`. Les valeurs du dictionnaire doivent être le type de la valeur s'il s'agit d'une valeur simple, par exemple `float` pour une valeur proprioceptive unique (position/vitesse cible d'une articulation)

Note : cette propriété doit pouvoir être appelée, que le robot soit connecté ou non.

#### is_connected[[lerobot.robots.Robot.is_connected]]

```python
is_connected()
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/robot.py#L127)

Indique si le robot est actuellement connecté ou non. Si `False`, l'appel de :pymeth:`get_observation` ou de :pymeth:`send_action` doit lever une erreur.

#### is_calibrated[[lerobot.robots.Robot.is_calibrated]]

```python
is_calibrated()
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/robot.py#L147)

Indique si le robot est actuellement calibré ou non. Doit toujours être `True` si non applicable

## RobotConfig[[lerobot.robots.RobotConfig]]

#### lerobot.robots.RobotConfig[[lerobot.robots.RobotConfig]]

```python
lerobot.robots.RobotConfig(id: str | None = None, calibration_dir: pathlib.Path | None = None)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/config.py#L23)

## make_robot_from_config[[lerobot.robots.make_robot_from_config]]

#### lerobot.robots.make_robot_from_config[[lerobot.robots.make_robot_from_config]]

```python
lerobot.robots.make_robot_from_config(config: RobotConfig)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/utils.py#L28)

## Les adeptes du SO-100 et du SO-101[[lerobot.robots.so_follower.SOFollower]]

`SO100Follower` et `SO101Follower` sont des alias de la même classe `SOFollower` ; les deux bras diffèrent par leur configuration, et non par leur code de contrôle. `SO100FollowerConfig` et `SO101FollowerConfig` sont de même des alias de `SOFollowerRobotConfig`.

#### lerobot.robots.so_follower.SOFollower[[lerobot.robots.so_follower.SOFollower]]

```python
lerobot.robots.so_follower.SOFollower(config: SOFollowerRobotConfig)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/so_follower/so_follower.py#L54)

Base générique de follower SO implémentant les fonctionnalités communes pour SO-100/101/10X. Conçue pour être sous-classée avec une `config_class` et un `name` spécifiques à chaque modèle de matériel.

#### connect[[lerobot.robots.so_follower.SOFollower.connect]]

```python
connect(calibrate: bool = True)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/so_follower/so_follower.py#L110)

Nous supposons qu'au moment de la connexion, le bras est en position de repos et que le couple peut être désactivé en toute sécurité pour exécuter l'étalonnage.

#### send_action[[lerobot.robots.so_follower.SOFollower.send_action]]

```python
send_action(action: dict)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/so_follower/so_follower.py#L187)

**Retourne :** `RobotAction`

l'action envoyée aux moteurs, potentiellement tronquée.

**Levée :** ``RobotDeviceNotConnectedError``

- ``RobotDeviceNotConnectedError`` -- si le robot n'est pas connecté.

Commander le bras pour se déplacer vers une configuration articulaire cible.

L'amplitude relative de l'action peut être tronquée en fonction du paramètre de configuration `max_relative_target`. Dans ce cas, l'action envoyée diffère de l'action d'origine. Ainsi, cette fonction renvoie toujours l'action réellement envoyée.

#### lerobot.robots.so_follower.SOFollowerRobotConfig[[lerobot.robots.so_follower.SOFollowerRobotConfig]]

```python
lerobot.robots.so_follower.SOFollowerRobotConfig(port: str, disable_torque_on_disconnect: bool = True, max_relative_target: float | dict[str, float] | None = None, cameras: dict = <factory>, use_degrees: bool = True, position_p_coefficient: int = 16, position_i_coefficient: int = 0, position_d_coefficient: int = 32, num_read_retries: int = 2, id: str | None = None, calibration_dir: pathlib.Path | None = None)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/so_follower/config_so_follower.py#L59)

## BiSOFollower[[lerobot.robots.bi_so_follower.BiSOFollower]]

Deux adeptes de SO pilotés comme un robot bimane unique.

#### lerobot.robots.bi_so_follower.BiSOFollower[[lerobot.robots.bi_so_follower.BiSOFollower]]

```python
lerobot.robots.bi_so_follower.BiSOFollower(config: BiSOFollowerConfig)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/bi_so_follower/bi_so_follower.py#L31)

[Bras suiveurs SO bimanuels](https://github.com/TheRobotStudio/SO-ARM100) conçus par TheRobotStudio

#### lerobot.robots.bi_so_follower.BiSOFollowerConfig[[lerobot.robots.bi_so_follower.BiSOFollowerConfig]]

```python
lerobot.robots.bi_so_follower.BiSOFollowerConfig(left_arm_config: SOFollowerConfig, right_arm_config: SOFollowerConfig, cameras: dict = <factory>, id: str | None = None, calibration_dir: pathlib.Path | None = None)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/bi_so_follower/config_bi_so_follower.py#L27)

Classe de configuration pour les robots Bi SO Follower.

## KochFollower[[lerobot.robots.koch_follower.KochFollower]]

#### lerobot.robots.koch_follower.KochFollower[[lerobot.robots.koch_follower.KochFollower]]

```python
lerobot.robots.koch_follower.KochFollower(config: KochFollowerConfig)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/koch_follower/koch_follower.py#L33)

- [Koch v1.0](https://github.com/AlexanderKoch-Koch/low_cost_robot), avec et sans l'extension poignet-coude, développé par Alexander Koch de [Tau Robotics](https://tau-robotics.com)
- [Koch v1.1](https://github.com/jess-moss/koch-v1-1) développé par Jess Moss

#### connect[[lerobot.robots.koch_follower.KochFollower.connect]]

```python
connect(calibrate: bool = True)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/koch_follower/koch_follower.py#L89)

Nous supposons qu'au moment de la connexion, le bras est en position de repos et que le couple peut être désactivé en toute sécurité pour exécuter l'étalonnage.

#### send_action[[lerobot.robots.koch_follower.KochFollower.send_action]]

```python
send_action(action: dict)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/koch_follower/koch_follower.py#L176)

**Paramètres :**

action (RobotAction) : Les positions cibles pour les moteurs.

**Retourne :** `RobotAction`

L'action envoyée aux moteurs, potentiellement tronquée.

Commander le bras pour se déplacer vers une configuration articulaire cible.

L'amplitude relative de l'action peut être tronquée en fonction du paramètre de configuration `max_relative_target`. Dans ce cas, l'action envoyée diffère de l'action d'origine. Ainsi, cette fonction renvoie toujours l'action réellement envoyée.

#### lerobot.robots.koch_follower.KochFollowerConfig[[lerobot.robots.koch_follower.KochFollowerConfig]]

```python
lerobot.robots.koch_follower.KochFollowerConfig(port: str, disable_torque_on_disconnect: bool = True, max_relative_target: float | dict[str, float] | None = None, cameras: dict = <factory>, use_degrees: bool = False, id: str | None = None, calibration_dir: pathlib.Path | None = None)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/koch_follower/config_koch_follower.py#L24)

## LeKiwi[[lerobot.robots.lekiwi.LeKiwi]]

`LeKiwi` s’exécute directement sur le robot. `LeKiwiClient` est le proxy côté hôte qui communique avec lui via le réseau et expose la même interface `Robot`.

#### lerobot.robots.lekiwi.LeKiwi[[lerobot.robots.lekiwi.LeKiwi]]

```python
lerobot.robots.lekiwi.LeKiwi(config: LeKiwiConfig)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/lekiwi/lekiwi.py#L36)

Le robot comprend une base mobile à trois roues omni et un bras suiveur distant. Le bras leader est connecté localement (sur le portable) et ses positions articulaires sont enregistrées puis transmises au bras suiveur distant (après application d'une limite de sécurité). En parallèle, la téléopération au clavier est utilisée pour générer des commandes de vitesse brutes pour les roues.

#### send_action[[lerobot.robots.lekiwi.LeKiwi.send_action]]

```python
send_action(action: dict)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/lekiwi/lekiwi.py#L339)

**Retourne :** `RobotAction`

l'action envoyée aux moteurs, potentiellement tronquée.

**Levée :** ``RobotDeviceNotConnectedError``

- ``RobotDeviceNotConnectedError`` -- si le robot n'est pas connecté.

Commandez lekiwi pour qu'il se déplace vers une configuration articulaire cible.

L'amplitude relative de l'action peut être tronquée en fonction du paramètre de configuration `max_relative_target`. Dans ce cas, l'action envoyée diffère de l'action d'origine. Ainsi, cette fonction renvoie toujours l'action réellement envoyée.

#### lerobot.robots.lekiwi.LeKiwiConfig[[lerobot.robots.lekiwi.LeKiwiConfig]]

```python
lerobot.robots.lekiwi.LeKiwiConfig(port: str = '/dev/ttyACM0', disable_torque_on_disconnect: bool = True, max_relative_target: float | dict[str, float] | None = None, cameras: dict = <factory>, use_degrees: bool = True, num_read_retries: int = 2, id: str | None = None, calibration_dir: pathlib.Path | None = None)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/lekiwi/config_lekiwi.py#L47)

#### lerobot.robots.lekiwi.LeKiwiClient[[lerobot.robots.lekiwi.LeKiwiClient]]

```python
lerobot.robots.lekiwi.LeKiwiClient(config: LeKiwiClientConfig)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/lekiwi/lekiwi_client.py#L40)

#### connect[[lerobot.robots.lekiwi.LeKiwiClient.connect]]

```python
connect()
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/lekiwi/lekiwi_client.py#L129)

Établit des sockets ZMQ avec le robot mobile distant

#### déconnecter[[lerobot.robots.lekiwi.LeKiwiClient.disconnect]]

```python
disconnect()
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/lekiwi/lekiwi_client.py#L351)

Nettoie les communications ZMQ

#### get_observation[[lerobot.robots.lekiwi.LeKiwiClient.get_observation]]

```python
get_observation()
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/lekiwi/lekiwi_client.py#L269)

Capture les observations du robot distant : positions actuelles des bras suiveurs, vitesses actuelles des roues (converties en vitesses dans le repère du corps : x, y, theta) et une image de la caméra. Reçoit via ZMQ, convertit en vitesses dans le

#### send_action[[lerobot.robots.lekiwi.LeKiwiClient.send_action]]

```python
send_action(action: dict)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/lekiwi/lekiwi_client.py#L323)

**Paramètres :**

action (RobotAction) : tableau contenant les positions cibles pour les moteurs.

**Retourne :** `np.ndarray`

l'action envoyée aux moteurs, potentiellement tronquée.

**Levée :** ``RobotDeviceNotConnectedError``

- ``RobotDeviceNotConnectedError`` -- si le robot n'est pas connecté.

Commandez lekiwi pour se déplacer vers une configuration articulaire cible. Traduit vers l'espace moteur + envoie via ZMQ

#### lerobot.robots.lekiwi.LeKiwiClientConfig[[lerobot.robots.lekiwi.LeKiwiClientConfig]]

```python
lerobot.robots.lekiwi.LeKiwiClientConfig(remote_ip: str, port_zmq_cmd: int = 5555, port_zmq_observations: int = 5556, teleop_keys: dict = <factory>, cameras: dict = <factory>, polling_timeout_ms: int = 15, connect_timeout_s: int = 5, id: str | None = None, calibration_dir: pathlib.Path | None = None)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/lekiwi/config_lekiwi.py#L87)

## OpenArmFollower[[lerobot.robots.openarm_follower.OpenArmFollower]]

#### lerobot.robots.openarm_follower.OpenArmFollower[[lerobot.robots.openarm_follower.OpenArmFollower]]

```python
lerobot.robots.openarm_follower.OpenArmFollower(config: OpenArmFollowerConfig)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/openarm_follower/openarm_follower.py#L40)

Robot suiveur OpenArms qui utilise la communication par bus CAN pour contrôler un bras à 7 degrés de liberté avec une pince. Le bras utilise des moteurs Damiao en mode de contrôle MIT.

#### calibrer[[lerobot.robots.openarm_follower.OpenArmFollower.calibrate]]

```python
calibrate()
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/openarm_follower/openarm_follower.py#L164)

Exécuter la procédure de calibration pour le robot OpenArms.

La procédure de calibration :
1. Désactiver le couple
2. Demander à l'utilisateur de positionner les bras en position suspendue avec les pinces fermées
3. Définir ceci comme position zéro
4. Enregistrer l'amplitude de mouvement de chaque articulation
5. Enregistrer l'étalonnage

#### configurer[[lerobot.robots.openarm_follower.OpenArmFollower.configure]]

```python
configure()
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/openarm_follower/openarm_follower.py#L215)

Configurez les moteurs avec les paramètres appropriés.

#### connect[[lerobot.robots.openarm_follower.OpenArmFollower.connect]]

```python
connect(calibrate: bool = True)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/openarm_follower/openarm_follower.py#L130)

Connectez-vous au robot et, le cas échéant, effectuez une calibration.

Nous supposons qu'au moment de la connexion, les bras sont dans une position de repos sûre et que le couple peut être désactivé en toute sécurité pour effectuer une calibration si nécessaire.

#### déconnecter[[lerobot.robots.openarm_follower.OpenArmFollower.disconnect]]

```python
disconnect()
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/openarm_follower/openarm_follower.py#L345)

Déconnectez-vous du robot.

#### get_observation[[lerobot.robots.openarm_follower.OpenArmFollower.get_observation]]

```python
get_observation()
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/openarm_follower/openarm_follower.py#L226)

Obtenir l'observation actuelle du robot, y compris la position, la vitesse et le couple.

Lit tous les états des moteurs (pos/vel/torque) dans un seul cycle de rafraîchissement CAN au lieu de 3 lectures séparées.

#### send_action[[lerobot.robots.openarm_follower.OpenArmFollower.send_action]]

```python
send_action(action: dict, custom_kp: dict[str, float] | None = None, custom_kd: dict[str, float] | None = None)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/openarm_follower/openarm_follower.py#L266)

**Paramètres :**

action : Dictionnaire des positions des moteurs (par exemple, "joint_1.pos", "joint_2.pos")

custom_kp : Gains kp personnalisés optionnels par moteur (par exemple, {"joint_1": 120.0, "joint_2": 150.0})

custom_kd : Gains kd personnalisés optionnels par moteur (par exemple, {"joint_1": 1.5, "joint_2": 2.0})

**Retourne :**

L'action réellement envoyée (éventuellement tronquée)

Envoyer une commande d'action au robot.

L'amplitude de l'action peut être limitée en fonction des limites de sécurité.

#### lerobot.robots.openarm_follower.OpenArmFollowerConfig[[lerobot.robots.openarm_follower.OpenArmFollowerConfig]]

```python
lerobot.robots.openarm_follower.OpenArmFollowerConfig(port: str, side: str | None = None, can_interface: str = 'socketcan', use_can_fd: bool = True, can_bitrate: int = 1000000, can_data_bitrate: int = 5000000, disable_torque_on_disconnect: bool = True, use_velocity_and_torque: bool = False, max_relative_target: float | dict[str, float] | None = None, cameras: dict = <factory>, motor_config: dict = <factory>, position_kp: list = <factory>, position_kd: list = <factory>, joint_limits: dict = <factory>, id: str | None = None, calibration_dir: pathlib.Path | None = None)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/openarm_follower/config_openarm_follower.py#L125)

## BiOpenArmFollower[[lerobot.robots.bi_openarm_follower.BiOpenArmFollower]]

#### lerobot.robots.bi_openarm_follower.BiOpenArmFollower[[lerobot.robots.bi_openarm_follower.BiOpenArmFollower]]

```python
lerobot.robots.bi_openarm_follower.BiOpenArmFollower(config: BiOpenArmFollowerConfig)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/bi_openarm_follower/bi_openarm_follower.py#L31)

Bras suiveurs bimanuels OpenArm

#### lerobot.robots.bi_openarm_follower.BiOpenArmFollowerConfig[[lerobot.robots.bi_openarm_follower.BiOpenArmFollowerConfig]]

```python
lerobot.robots.bi_openarm_follower.BiOpenArmFollowerConfig(id: str | None = 'bi_openarm_follower', calibration_dir: pathlib.Path | None = None, left_arm_config: OpenArmFollowerConfigBase, right_arm_config: OpenArmFollowerConfigBase, cameras: dict = <factory>)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/bi_openarm_follower/config_bi_openarm_follower.py#L27)

Classe de configuration pour les robots Bi OpenArm Follower.

## OmxFollower[[lerobot.robots.omx_follower.OmxFollower]]

#### lerobot.robots.omx_follower.OmxFollower[[lerobot.robots.omx_follower.OmxFollower]]

```python
lerobot.robots.omx_follower.OmxFollower(config: OmxFollowerConfig)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/omx_follower/omx_follower.py#L33)

- [OMX](https://github.com/ROBOTIS-GIT/open_manipulator), expansion, développée par Woojin Wie et Junha Cha de [ROBOTIS](https://ai.robotis.com/)

#### connect[[lerobot.robots.omx_follower.OmxFollower.connect]]

```python
connect(calibrate: bool = True)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/omx_follower/omx_follower.py#L89)

Pour les robots OMX livrés pré-calibrés :
- Si l'étalonnage par défaut du package ne correspond pas aux moteurs, lisez depuis les moteurs et enregistrez
- Cela permet d'utiliser des robots pré-calibrés sans calibration manuelle
- Si aucun fichier de calibration n'existe, utilisez les valeurs par défaut d'usine (homing_offset=0, range_min=0, range_max=4095)

#### send_action[[lerobot.robots.omx_follower.OmxFollower.send_action]]

```python
send_action(action: dict)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/omx_follower/omx_follower.py#L190)

**Paramètres :**

action (RobotAction) : Les positions cibles pour les moteurs.

**Retourne :** `RobotAction`

L'action envoyée aux moteurs, potentiellement tronquée.

Commander le bras pour se déplacer vers une configuration articulaire cible.

L'amplitude relative de l'action peut être tronquée en fonction du paramètre de configuration `max_relative_target`. Dans ce cas, l'action envoyée diffère de l'action d'origine. Ainsi, cette fonction renvoie toujours l'action réellement envoyée.

#### lerobot.robots.omx_follower.OmxFollowerConfig[[lerobot.robots.omx_follower.OmxFollowerConfig]]

```python
lerobot.robots.omx_follower.OmxFollowerConfig(port: str, disable_torque_on_disconnect: bool = True, max_relative_target: float | dict[str, float] | None = None, cameras: dict = <factory>, use_degrees: bool = False, id: str | None = None, calibration_dir: pathlib.Path | None = None)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/omx_follower/config_omx_follower.py#L24)

## Reachy2Robot[[lerobot.robots.reachy2.Reachy2Robot]]

#### lerobot.robots.reachy2.Reachy2Robot[[lerobot.robots.reachy2.Reachy2Robot]]

```python
lerobot.robots.reachy2.Reachy2Robot(config: Reachy2RobotConfig)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/reachy2/robot_reachy2.py#L75)

[Reachy 2](https://www.pollen-robotics.com/reachy/), de Pollen Robotics.

#### lerobot.robots.reachy2.Reachy2RobotConfig[[lerobot.robots.reachy2.Reachy2RobotConfig]]

```python
lerobot.robots.reachy2.Reachy2RobotConfig(max_relative_target: float | None = None, ip_address: str | None = 'localhost', port: int = 50065, disable_torque_on_disconnect: bool = False, use_external_commands: bool = False, with_mobile_base: bool = True, with_l_arm: bool = True, with_r_arm: bool = True, with_neck: bool = True, with_antennas: bool = True, with_left_teleop_camera: bool = False, with_right_teleop_camera: bool = False, with_torso_camera: bool = False, camera_width: int = 640, camera_height: int = 480, cameras: dict = <factory>, id: str | None = None, calibration_dir: pathlib.Path | None = None)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/reachy2/configuration_reachy2.py#L25)

## UnitreeG1[[lerobot.robots.unitree_g1.UnitreeG1]]

#### lerobot.robots.unitree_g1.UnitreeG1[[lerobot.robots.unitree_g1.UnitreeG1]]

```python
lerobot.robots.unitree_g1.UnitreeG1(config: UnitreeG1Config)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/unitree_g1/unitree_g1.py#L155)

#### lerobot.robots.unitree_g1.UnitreeG1Config[[lerobot.robots.unitree_g1.UnitreeG1Config]]

```python
lerobot.robots.unitree_g1.UnitreeG1Config(kp: list[float] | None = None, kd: list[float] | None = None, default_positions: list = <factory>, control_dt: float = 0.004, is_simulation: bool = True, end_effector: G1EndEffector = <G1EndEffector.DEX1: 'dex1'>, sim_publish_images: bool = True, sim_camera_port: int = 5555, sim_onscreen: bool | None = None, robot_ip: str = '192.168.123.164', cameras: dict = <factory>, gravity_compensation: bool = False, controller: str | None = None, embodiment: str = 'g1_29', id: str | None = None, calibration_dir: pathlib.Path | None = None)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/unitree_g1/config_unitree_g1.py#L30)

## Hope Jr[[lerobot.robots.hope_jr.HopeJrArm]]

Le humanoïde Hope Jr est exposé sous la forme de deux robots indépendants, un bras et une main.

#### lerobot.robots.hope_jr.HopeJrArm[[lerobot.robots.hope_jr.HopeJrArm]]

```python
lerobot.robots.hope_jr.HopeJrArm(config: HopeJrArmConfig)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/hope_jr/hope_jr_arm.py#L34)

#### connect[[lerobot.robots.hope_jr.HopeJrArm.connect]]

```python
connect(calibrate: bool = True)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/hope_jr/hope_jr_arm.py#L88)

Nous supposons qu'au moment de la connexion, le bras est en position de repos et que le couple peut être désactivé en toute sécurité pour exécuter l'étalonnage.

#### lerobot.robots.hope_jr.HopeJrArmConfig[[lerobot.robots.hope_jr.HopeJrArmConfig]]

```python
lerobot.robots.hope_jr.HopeJrArmConfig(port: str, disable_torque_on_disconnect: bool = True, max_relative_target: float | dict[str, float] | None = None, cameras: dict = <factory>, id: str | None = None, calibration_dir: pathlib.Path | None = None)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/hope_jr/config_hope_jr.py#L42)

#### lerobot.robots.hope_jr.HopeJrHand[[lerobot.robots.hope_jr.HopeJrHand]]

```python
lerobot.robots.hope_jr.HopeJrHand(config: HopeJrHandConfig)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/hope_jr/hope_jr_hand.py#L58)

#### lerobot.robots.hope_jr.HopeJrHandConfig[[lerobot.robots.hope_jr.HopeJrHandConfig]]

```python
lerobot.robots.hope_jr.HopeJrHandConfig(port: str, side: str, disable_torque_on_disconnect: bool = True, cameras: dict = <factory>, id: str | None = None, calibration_dir: pathlib.Path | None = None)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/hope_jr/config_hope_jr.py#L26)

## RebotB601Follower[[lerobot.robots.rebot_b601_follower.RebotB601Follower]]

#### lerobot.robots.rebot_b601_follower.RebotB601Follower[[lerobot.robots.rebot_b601_follower.RebotB601Follower]]

```python
lerobot.robots.rebot_b601_follower.RebotB601Follower(config: RebotB601FollowerRobotConfig)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/rebot_b601_follower/rebot_b601_follower.py#L62)

Bras suiveur Seeed Studio reBot B601 (6-DOF + pince, moteurs CAN).

La communication avec les moteurs est gérée par le package `motorbridge` via un bus CAN, accessible soit par un pont série Damiao, soit par le transport CAN natif de MotorBridge.

#### configurer[[lerobot.robots.rebot_b601_follower.RebotB601Follower.configure]]

```python
configure()
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/rebot_b601_follower/rebot_b601_follower.py#L224)

Définissez le mode de contrôle de chaque moteur avant d'activer le couple.

#### disable_torque[[lerobot.robots.rebot_b601_follower.RebotB601Follower.disable_torque]]

```python
disable_torque()
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/rebot_b601_follower/rebot_b601_follower.py#L245)

Désactiver le couple du moteur afin que le bras puisse être déplacé à la main (débogage en lecture seule).

#### déconnecter[[lerobot.robots.rebot_b601_follower.RebotB601Follower.disconnect]]

```python
disconnect()
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/rebot_b601_follower/rebot_b601_follower.py#L444)

Débranchez les moteurs et les caméras du robot.

#### send_action[[lerobot.robots.rebot_b601_follower.RebotB601Follower.send_action]]

```python
send_action(action: dict)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/rebot_b601_follower/rebot_b601_follower.py#L313)

Commander le bras vers une configuration articulaire cible.

Les positions sont exprimées en degrés. L'amplitude de l'action relative peut être limitée en fonction de `max_relative_target`, de sorte que l'action réellement envoyée est toujours renvoyée.

#### lerobot.robots.rebot_b601_follower.RebotB601FollowerRobotConfig[[lerobot.robots.rebot_b601_follower.RebotB601FollowerRobotConfig]]

```python
lerobot.robots.rebot_b601_follower.RebotB601FollowerRobotConfig(port: str, motor_family: MotorFamily = <MotorFamily.DM: 'dm'>, can_adapter: str | None = None, dm_serial_baud: int = 921600, disable_torque_on_disconnect: bool = True, max_relative_target: float | dict[str, float] | None = None, cameras: dict = <factory>, motor_can_ids: dict[str, tuple[int, int]] | None = None, control_mode: ArmControlMode = <ArmControlMode.MIT: 'mit'>, gripper_control_mode: lerobot.robots.rebot_b601_follower.motor_family.GripperControlMode | None = None, mit_kp: float | dict[str, float] | None = None, mit_kd: float | dict[str, float] | None = None, pos_vel_velocity: float | dict[str, float] | None = None, gripper_torque_ratio: float | None = None, gripper_torque_limit: float | None = None, gripper_hold_torque_limit: float | None = None, joint_limits: dict[str, tuple[float, float]] | None = None, id: str | None = None, calibration_dir: pathlib.Path | None = None)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/rebot_b601_follower/config_rebot_b601_follower.py#L119)

Configuration enregistrée pour le robot suiveur reBot B601.

## BiRebotB601Follower[[lerobot.robots.bi_rebot_b601_follower.BiRebotB601Follower]]

#### lerobot.robots.bi_rebot_b601_follower.BiRebotB601Follower[[lerobot.robots.bi_rebot_b601_follower.BiRebotB601Follower]]

```python
lerobot.robots.bi_rebot_b601_follower.BiRebotB601Follower(config: BiRebotB601FollowerConfig)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/bi_rebot_b601_follower/bi_rebot_b601_follower.py#L28)

Suiveur bimanuel Seeed Studio reBot B601.

Compose deux instances `RebotB601Follower` à un seul bras. Les clés d'observation et d'action de chaque bras sont préfixées par `left_` / `right_`.

#### lerobot.robots.bi_rebot_b601_follower.BiRebotB601FollowerConfig[[lerobot.robots.bi_rebot_b601_follower.BiRebotB601FollowerConfig]]

```python
lerobot.robots.bi_rebot_b601_follower.BiRebotB601FollowerConfig(left_arm_config: RebotB601FollowerConfig, right_arm_config: RebotB601FollowerConfig, cameras: dict = <factory>, id: str | None = None, calibration_dir: pathlib.Path | None = None)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/bi_rebot_b601_follower/config_bi_rebot_b601_follower.py#L27)

Classe de configuration pour le robot suiveur bimanuel reBot B601.

## EarthRoverMiniPlus[[lerobot.robots.earthrover_mini_plus.EarthRoverMiniPlus]]

#### lerobot.robots.earthrover_mini_plus.EarthRoverMiniPlus[[lerobot.robots.earthrover_mini_plus.EarthRoverMiniPlus]]

```python
lerobot.robots.earthrover_mini_plus.EarthRoverMiniPlus(config: EarthRoverMiniPlusConfig)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/earthrover_mini_plus/robot_earthrover_mini_plus.py#L73)

**Paramètres :**

config : Configuration du robot

sdk_base_url : URL de base du serveur du SDK Frodobots, issue de `config.sdk_url` (par défaut : http://localhost:8000)

Robot EarthRover Mini Plus contrôlé via l'API HTTP du SDK Frodobots.

Ce robot utilise un contrôle basé sur le cloud via le SDK Frodobots au lieu d'une connexion matérielle directe. Les flux vidéo des caméras transitent par WebRTC via le cloud Agora, et les commandes de contrôle sont envoyées via des requêtes HTTP POST.

Le robot prend en charge :
- Deux caméras (avant et arrière) accessibles via des points de terminaison HTTP du SDK
- Contrôle de la vitesse linéaire et angulaire
- Télémétrie de la batterie et de l'orientation

#### calibrer[[lerobot.robots.earthrover_mini_plus.EarthRoverMiniPlus.calibrate]]

```python
calibrate()
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/earthrover_mini_plus/robot_earthrover_mini_plus.py#L153)

Aucune calibration n'est nécessaire pour un robot basé sur un SDK.

#### configurer[[lerobot.robots.earthrover_mini_plus.EarthRoverMiniPlus.configure]]

```python
configure()
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/earthrover_mini_plus/robot_earthrover_mini_plus.py#L166)

Configurer le robot (sans effet pour un robot basé sur le SDK).

#### connect[[lerobot.robots.earthrover_mini_plus.EarthRoverMiniPlus.connect]]

```python
connect(calibrate: bool = True)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/earthrover_mini_plus/robot_earthrover_mini_plus.py#L124)

**Paramètres :**

calibrate : Non utilisé pour les robots basés sur le SDK (conservé pour la compatibilité de l'API)

**Exceptions levées :** ``DeviceAlreadyConnectedError`` ou ``DeviceNotConnectedError``

- ``DeviceAlreadyConnectedError`` -- Si le robot est déjà connecté
- ``DeviceNotConnectedError`` -- Si la connexion au serveur SDK est impossible

Connectez-vous au robot via le SDK Frodobots.

#### déconnecter[[lerobot.robots.earthrover_mini_plus.EarthRoverMiniPlus.disconnect]]

```python
disconnect()
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/earthrover_mini_plus/robot_earthrover_mini_plus.py#L366)

**Levée :** ``DeviceNotConnectedError``

- ``DeviceNotConnectedError`` -- Si le robot n'est pas connecté

Déconnectez-vous du robot.

Arrête le robot et ferme la connexion à l'SDK.

#### get_observation[[lerobot.robots.earthrover_mini_plus.EarthRoverMiniPlus.get_observation]]

```python
get_observation()
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/earthrover_mini_plus/robot_earthrover_mini_plus.py#L248)

**Retourne :** `RobotObservation`

Observation contenant :
- front : Image de la caméra avant (480, 640, 3) au format RGB
- rear : Image de la caméra arrière (480, 640, 3) au format RGB
- speed: float - Vitesse actuelle (valeur brute du SDK)
- battery_level: float - Niveau de la batterie (0-100)
- orientation: float - Orientation du robot en degrés
- gps_latitude: float - Coordonnée de latitude GPS
- gps_longitude: float - Coordonnée de longitude GPS
- gps_signal: float - Intensité du signal GPS (pourcentage)
- signal_level: float - Niveau du signal réseau (0-5)
- vibration: float - Lecture du capteur de vibration
- lamp: float - État de la lampe (0=éteinte, 1=allumée)
- accelerometer_x/y/z: float - Axes de l'accéléromètre (valeur brute du SDK)
- gyroscope_x/y/z: float - Axes du gyroscope (valeur brute du SDK)
- magnetometer_filtered_x/y/z: float - Axes du magnétomètre (valeur brute du SDK)
- wheel_rpm_0/1/2/3: float - Tournage des roues

**Levée :** ``DeviceNotConnectedError``

- ``DeviceNotConnectedError`` -- Si le robot n'est pas connecté

Obtenir l'observation actuelle du robot depuis le SDK.

Les images de la caméra sont récupérées depuis les points de terminaison SDK /v2/front et /v2/rear. Les images sont décodées depuis base64 et converties du format BGR au format RGB. La télémétrie du robot est récupérée depuis le point de terminaison /data. Les tableaux de capteurs (accels, gyros, mags, rpms) contiennent chacun des entrées de la forme [values..., timestamp] ; la dernière lecture de chaque tableau est utilisée.

Note : Les images de la caméra sont récupérées depuis les points de terminaison /v2/front et /v2/rear de l’SDK. Les images sont décodées depuis le format base64 et converties du format BGR au format RGB. La télémétrie du robot est récupérée depuis le point de terminaison /data. Toutes les valeurs de l’SDK sont normalisées dans les plages appropriées pour l’enregistrement du jeu de données.

#### send_action[[lerobot.robots.earthrover_mini_plus.EarthRoverMiniPlus.send_action]]

```python
send_action(action: dict)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/earthrover_mini_plus/robot_earthrover_mini_plus.py#L334)

**Paramètres :**

action : Dictionnaire d'action avec les clés suivantes : - linear_velocity : Vitesse linéaire cible (-1 à 1) - angular_velocity : Vitesse angulaire cible (-1 à 1)

**Retourne :** `RobotAction`

L'action qui a été envoyée (correspond aux clés de action_features)

**Levée :** ``DeviceNotConnectedError``

- ``DeviceNotConnectedError`` -- Si le robot n'est pas connecté

Envoyer une action au robot via le SDK.

Note : Les actions sont envoyées au SDK via le point de terminaison POST /control. Le SDK s'attend à des commandes dans l'intervalle [-1, 1].

#### lerobot.robots.earthrover_mini_plus.EarthRoverMiniPlusConfig[[lerobot.robots.earthrover_mini_plus.EarthRoverMiniPlusConfig]]

```python
lerobot.robots.earthrover_mini_plus.EarthRoverMiniPlusConfig(sdk_url: str = 'http://localhost:8000', id: str | None = None, calibration_dir: pathlib.Path | None = None)
```

[Source](https://github.com/huggingface/lerobot/blob/v0.7.0/src/lerobot/robots/earthrover_mini_plus/config_earthrover_mini_plus.py#L25)

**Paramètres :**

sdk_url : URL du serveur du SDK Frodobots (par défaut : http://localhost:8000)

Configuration du robot EarthRover Mini Plus à l'aide du SDK Frodobots.

Ce robot utilise un contrôle basé sur le cloud via l'API HTTP du SDK Frodobots. Les images de la caméra sont accédées directement via les points de terminaison HTTP du SDK.