# Robôs

Cada robô no LeRobot implementa a interface `Robot`: conectar, ler uma observação, enviar uma ação, desconectar. Escrever uma política ou um script de gravação para essa interface significa que ele funciona com qualquer braço suportado sem alterações.

Esta página é a referência gerada. Para instruções de fiação, calibração e primeira execução, comece pelos guias de hardware — [SO-101](../so101), [LeKiwi](../lekiwi), [Hope Jr](../hope_jr), [Reachy 2](../reachy2), [OpenArm](../openarm) — ou [Imitation Learning for Robots](../il_robots) para o fluxo de trabalho de ponta a ponta. Para robôs mantidos pela comunidade fora do conjunto principal, consulte [Third-Party Robots & Teleoperators](../third_party_robots). Para adicionar um robô próprio, consulte [Bring Your Own Hardware](../integrate_hardware).

## Robô[[lerobot.robots.Robot]]

A classe base abstrata. As subclasses implementam todos os métodos abaixo; o contrato descrito aqui é o que uma política ou um loop de gravação pode utilizar.

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

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

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

**Parâmetros:**

config_class (RobotConfig) : A classe de configuração esperada para este robô.

name (str) : O nome único do robô usado para identificar esse tipo de robô.

A classe abstrata base para todos os robôs compatíveis com LeRobot.

Esta classe fornece uma interface padronizada para interagir com robôs físicos. As subclasses devem implementar todos os métodos e propriedades abstratos para serem utilizáveis.

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

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

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

**Parâmetros:**

calibrate (bool) : Se True, calibra automaticamente o robô após a conexão, caso ele não esteja calibrado ou precise de calibração (isso depende do hardware).

Estabeleça comunicação com o robô.

#### desconectar[[lerobot.robots.Robot.disconnect]]

```python
disconnect()
```

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

Desconecte-se do robô e execute as limpezas necessárias.

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

```python
configure()
```

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

Aplique qualquer configuração de uso único ou em tempo de execução ao robô. Isso pode incluir a definição de parâmetros dos motores, modos de controle ou estado inicial.

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

```python
calibrate()
```

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

Calibre o robô, se aplicável. Caso contrário, esta deve ser uma operação sem efeito.

Este método deve coletar quaisquer dados necessários (por exemplo, offsets do motor) e atualizar o dicionário :pyattr:`calibration` de acordo.

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

```python
get_observation()
```

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

**Retorna:** `RobotObservation`

Um dicionário plano que representa o estado sensorial atual do robô. Sua estrutura deve corresponder a :pymeth:`observation_features`.

Obtenha a observação atual do robô.

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

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

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

**Parâmetros:**

action (RobotAction) : Dicionário representando a ação desejada. Sua estrutura deve corresponder a :pymeth:`action_features`.

**Retorna:** `RobotAction`

A ação efetivamente enviada aos motores, possivelmente truncada ou modificada, por exemplo, por limites de segurança na velocidade.

Envie um comando de ação para o robô.

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

```python
observation_features()
```

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

Um dicionário que descreve a estrutura e os tipos das observações produzidas pelo robô. Sua estrutura (chaves) deve corresponder à estrutura do que é retornado por :pymeth:`get_observation`. Os valores do dicionário devem ser:
- O tipo do valor, caso seja um valor simples, por exemplo, `float` para um valor proprioceptivo único (posição/velocidade de uma articulação)
- Uma tupla representando a forma, se for um valor de tipo array, por exemplo, `(height, width, channel)` para imagens

Observação: esta propriedade deve poder ser chamada independentemente de o robô estar conectado ou não.

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

```python
action_features()
```

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

Um dicionário que descreve a estrutura e os tipos das ações esperadas pelo robô. Sua estrutura (chaves) deve corresponder à estrutura do que é passado para :pymeth:`send_action`. Os valores do dicionário devem ser o tipo do valor, se for um valor simples, por exemplo, `float` para um valor proprioceptivo único (posição/velocidade de destino de uma articulação)

Observação: esta propriedade deve poder ser chamada independentemente de o robô estar conectado ou não.

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

```python
is_connected()
```

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

Se o robô está atualmente conectado ou não. Se `False`, chamar :pymeth:`get_observation` ou :pymeth:`send_action` deve gerar um erro.

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

```python
is_calibrated()
```

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

Se o robô está atualmente calibrado ou não. Deve ser sempre `True` se não aplicável

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

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

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

[Fonte](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)
```

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

## Seguidores do SO-100 e do SO-101[[lerobot.robots.so_follower.SOFollower]]

`SO100Follower` e `SO101Follower` são aliases da mesma classe `SOFollower`; os dois braços diferem em sua configuração, não no código de controle. `SO100FollowerConfig` e `SO101FollowerConfig` são, da mesma forma, aliases de `SOFollowerRobotConfig`.

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

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

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

Base genérica de seguidor SO que implementa a funcionalidade comum para SO-100/101/10X. Projetada para ser subclasseada com uma `config_class` e um `name` específicos para cada modelo de hardware.

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

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

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

Assumimos que, no momento da conexão, o braço está em uma posição de repouso e que o torque pode ser desativado com segurança para executar a calibração.

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

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

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

**Retorna:** `RobotAction`

a ação enviada aos motores, possivelmente limitada.

**Exceções:** ``RobotDeviceNotConnectedError``

- ``RobotDeviceNotConnectedError`` -- se o robô não estiver conectado.

Comando o braço para se mover para uma configuração de juntas de destino.

A magnitude relativa da ação pode ser limitada (clipped) dependendo do parâmetro de configuração `max_relative_target`. Nesse caso, a ação enviada difere da ação original. Assim, esta função sempre retorna a ação efetivamente enviada.

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

[Fonte](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]]

Dois seguidores de SO acionados como um único robô bimanual.

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

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

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

[Braços seguidores SO bimanuais](https://github.com/TheRobotStudio/SO-ARM100) projetados por 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)
```

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

Classe de configuração para robôs 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)
```

[Fonte](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), com e sem a expansão do punho ao cotovelo, desenvolvido por Alexander Koch da [Tau Robotics](https://tau-robotics.com)
- [Koch v1.1](https://github.com/jess-moss/koch-v1-1) desenvolvido por Jess Moss

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

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

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

Assumimos que, no momento da conexão, o braço está em uma posição de repouso e que o torque pode ser desativado com segurança para executar a calibração.

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

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

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

**Parâmetros:**

action (RobotAction) : As posições de destino para os motores.

**Retorna:** `RobotAction`

A ação enviada aos motores, possivelmente limitada.

Comando o braço para se mover para uma configuração de juntas de destino.

A magnitude relativa da ação pode ser limitada (clipped) dependendo do parâmetro de configuração `max_relative_target`. Nesse caso, a ação enviada difere da ação original. Assim, esta função sempre retorna a ação efetivamente enviada.

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

[Fonte](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` roda no próprio robô. `LeKiwiClient` é o proxy do lado do host que se comunica com ele pela rede e apresenta a mesma interface `Robot`.

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

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

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

O robô inclui uma base móvel com três rodas omni e um braço seguidor remoto. O braço líder é conectado localmente (no laptop) e as posições de suas juntas são registradas e, em seguida, encaminhadas para o braço seguidor remoto (após a aplicação de um limite de segurança). Em paralelo, a teleoperação por teclado é usada para gerar comandos de velocidade bruta para as rodas.

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

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

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

**Retorna:** `RobotAction`

a ação enviada aos motores, possivelmente limitada.

**Exceções:** ``RobotDeviceNotConnectedError``

- ``RobotDeviceNotConnectedError`` -- se o robô não estiver conectado.

Comande o lekiwi para se mover para uma configuração de juntas de destino.

A magnitude relativa da ação pode ser limitada (clipped) dependendo do parâmetro de configuração `max_relative_target`. Nesse caso, a ação enviada difere da ação original. Assim, esta função sempre retorna a ação efetivamente enviada.

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

[Fonte](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)
```

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

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

```python
connect()
```

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

Estabelece sockets ZMQ com o robô móvel remoto

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

```python
disconnect()
```

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

Limpa as comunicações ZMQ

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

```python
get_observation()
```

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

Capture observações do robô remoto: posições atuais dos braços seguidores, velocidades atuais das rodas (convertidas para velocidades no referencial do corpo: x, y, theta) e um quadro da câmera. Recebe via ZMQ, converte para velocidades no referencial do

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

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

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

**Parâmetros:**

action (RobotAction) : array contendo as posições de destino para os motores.

**Retorna:** `np.ndarray`

a ação enviada aos motores, possivelmente limitada.

**Exceções:** ``RobotDeviceNotConnectedError``

- ``RobotDeviceNotConnectedError`` -- se o robô não estiver conectado.

Comande o lekiwi para se mover até uma configuração de juntas de destino. Traduz para o espaço do motor + envia 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)
```

[Fonte](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)
```

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

Robô seguidor OpenArms que usa comunicação via barramento CAN para controlar um braço de 7 graus de liberdade com uma garra. O braço usa motores Damiao no modo de controle MIT.

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

```python
calibrate()
```

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

Execute o procedimento de calibração para o robô OpenArms.

O procedimento de calibração:
1. Desativar torque
2. Peça ao usuário para posicionar os braços na posição suspensa com os garras fechadas
3. Defina isso como posição zero
4. Registre a amplitude de movimento de cada articulação
5. Salvar calibração

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

```python
configure()
```

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

Configure os motores com as configurações apropriadas.

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

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

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

Conecte-se ao robô e, opcionalmente, calibre.

Assumimos que, no momento da conexão, os braços estão em uma posição de repouso segura e que o torque pode ser desativado com segurança para executar a calibração, se necessário.

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

```python
disconnect()
```

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

Desconectar do robô.

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

```python
get_observation()
```

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

Obtém a observação atual do robô, incluindo posição, velocidade e torque.

Lê todos os estados dos motores (pos/vel/torque) em um único ciclo de atualização CAN, em vez de 3 leituras separadas.

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

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

**Parâmetros:**

action : Dicionário com as posições dos motores (por exemplo, "joint_1.pos", "joint_2.pos")

custom_kp : Ganhos de kp personalizados opcionais por motor (ex.: {"joint_1": 120.0, "joint_2": 150.0})

custom_kd : Ganhos kd personalizados opcionais por motor (ex.: {"joint_1": 1.5, "joint_2": 2.0})

**Retorna:**

A ação efetivamente enviada (possivelmente truncada)

Envie um comando de ação para o robô.

A magnitude da ação pode ser limitada com base em limites de segurança.

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

[Fonte](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)
```

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

Braços Seguidores Bimanuais 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>)
```

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

Classe de configuração para robôs 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)
```

[Fonte](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), expansão, desenvolvida por Woojin Wie e Junha Cha da [ROBOTIS](https://ai.robotis.com/)

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

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

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

Para robôs OMX que vêm pré-calibrados:
- Se a calibração padrão do pacote não corresponder aos motores, leia dos motores e salve
- Isso permite o uso de robôs pré-calibrados sem calibração manual
- Se nenhum arquivo de calibração existir, use os valores padrão de fábrica (homing_offset=0, range_min=0, range_max=4095)

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

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

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

**Parâmetros:**

action (RobotAction) : As posições de destino para os motores.

**Retorna:** `RobotAction`

A ação enviada aos motores, possivelmente limitada.

Comando o braço para se mover para uma configuração de juntas de destino.

A magnitude relativa da ação pode ser limitada (clipped) dependendo do parâmetro de configuração `max_relative_target`. Nesse caso, a ação enviada difere da ação original. Assim, esta função sempre retorna a ação efetivamente enviada.

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

[Fonte](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)
```

[Fonte](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/), da 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)
```

[Fonte](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)
```

[Fonte](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)
```

[Fonte](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]]

O humanoide Hope Jr é exposto como dois robôs independentes, um braço e uma mão.

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

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

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

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

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

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

Assumimos que, no momento da conexão, o braço está em uma posição de repouso e que o torque pode ser desativado com segurança para executar a calibração.

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

[Fonte](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)
```

[Fonte](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)
```

[Fonte](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)
```

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

Braço seguidor Seeed Studio reBot B601 (6-DOF + garra, motores CAN).

A comunicação com o motor é gerenciada pelo pacote `motorbridge` por meio de um barramento CAN, acessado seja através de uma ponte serial Damiao ou do transporte CAN nativo do MotorBridge.

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

```python
configure()
```

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

Defina o modo de controle de cada motor antes de habilitar o torque.

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

```python
disable_torque()
```

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

Desative o torque do motor para que o braço possa ser movido à mão (depuração somente leitura).

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

```python
disconnect()
```

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

Desconecte os motores e as câmeras do robô.

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

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

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

Comande o braço para uma configuração de juntas de destino.

As posições são expressas em graus. A magnitude da ação relativa pode ser limitada dependendo de `max_relative_target`, portanto, a ação efetivamente enviada é sempre retornada.

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

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

Configuração registrada para o robô seguidor 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)
```

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

Seguidor bimanual Seeed Studio reBot B601.

Compõe duas instâncias de `RebotB601Follower` de braço único. As chaves de observação e ação de cada braço são namespaced com o prefixo `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)
```

[Fonte](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 configuração para o robô seguidor bimanual 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)
```

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

**Parâmetros:**

config : Configuração do robô

sdk_base_url : URL base do servidor do SDK do Frodobots, obtida de `config.sdk_url` (padrão: http://localhost:8000)

Robô EarthRover Mini Plus controlado via API HTTP do Frodobots SDK.

Este robô usa controle baseado em nuvem por meio do Frodobots SDK, em vez de conexão direta com o hardware. As câmeras transmitem via WebRTC pela nuvem da Agora, e os comandos de controle são enviados por meio de requisições HTTP POST.

O robô suporta:
- Câmeras duplas (frontal e traseira) acessadas por meio de endpoints HTTP do SDK
- Controle de velocidade linear e angular
- Telemetria de bateria e orientação

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

```python
calibrate()
```

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

Calibração não é necessária para robôs baseados em SDK.

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

```python
configure()
```

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

Configure o robô (sem operação para robôs baseados em SDK).

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

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

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

**Parâmetros:**

calibrate : Não usado para robôs baseados em SDK (mantido para compatibilidade de API)

**Exceções:** ``DeviceAlreadyConnectedError`` ou ``DeviceNotConnectedError``

- ``DeviceAlreadyConnectedError`` -- Se o robô já estiver conectado
- ``DeviceNotConnectedError`` -- Se não for possível conectar ao servidor do SDK

Conecte-se ao robô via Frodobots SDK.

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

```python
disconnect()
```

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

**Exceções:** ``DeviceNotConnectedError``

- ``DeviceNotConnectedError`` -- Se o robô não estiver conectado

Desconectar do robô.

Interrompe o robô e fecha a conexão com o SDK.

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

```python
get_observation()
```

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

**Retorna:** `RobotObservation`

Observação contendo:
- front: Imagem da câmera frontal (480, 640, 3) no formato RGB
- rear: Imagem da câmera traseira (480, 640, 3) no formato RGB
- speed: float - Velocidade atual (valor bruto do SDK)
- battery_level: float - Nível da bateria (0-100)
- orientation: float - Orientação do robô em graus
- gps_latitude: float - coordenada de latitude do GPS
- gps_longitude: float - coordenada de longitude do GPS
- gps_signal: float - intensidade do sinal GPS (porcentagem)
- signal_level: float - Nível do sinal da rede (0-5)
- vibration: float - Leitura do sensor de vibração
- lamp: float - Estado da lâmpada (0=desligado, 1=ligado)
- accelerometer_x/y/z: float - Eixos do acelerômetro (valor bruto da SDK)
- gyroscope_x/y/z: float - Eixos do giroscópio (valor bruto da SDK)
- magnetometer_filtered_x/y/z: float - Eixos do magnetômetro (valor bruto da SDK)
- wheel_rpm_0/1/2/3: float - RPMs das rodas

**Exceções:** ``DeviceNotConnectedError``

- ``DeviceNotConnectedError`` -- Se o robô não estiver conectado

Obtenha a observação atual do robô do SDK.

Os quadros da câmera são obtidos dos endpoints de SDK /v2/front e /v2/rear. Os quadros são decodificados de base64 e convertidos do formato BGR para RGB. A telemetria do robô é obtida do endpoint /data. Os arrays de sensores (accels, gyros, mags, rpms) contêm cada um entradas de [values..., timestamp]; a leitura mais recente de cada array é utilizada.

Nota: Os quadros da câmera são obtidos dos endpoints /v2/front e /v2/rear do SDK. Os quadros são decodificados de base64 e convertidos do formato BGR para RGB. A telemetria do robô é obtida do endpoint /data. Todos os valores do SDK são normalizados para os intervalos apropriados para o registro do conjunto de dados.

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

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

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

**Parâmetros:**

action : Dicionário de ação com as chaves: - linear_velocity: Velocidade linear alvo (-1 a 1) - angular_velocity: Velocidade angular alvo (-1 a 1)

**Retorna:** `RobotAction`

A ação que foi enviada (corresponde às chaves de action_features)

**Exceções:** ``DeviceNotConnectedError``

- ``DeviceNotConnectedError`` -- Se o robô não estiver conectado

Envie ação para o robô via SDK.

Nota: As ações são enviadas ao SDK por meio do endpoint POST /control. O SDK espera comandos no intervalo [-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)
```

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

**Parâmetros:**

sdk_url : URL do servidor do SDK do Frodobots (padrão: http://localhost:8000)

Configuração para o robô EarthRover Mini Plus usando o SDK da Frodobots.

Este robô usa controle baseado em nuvem por meio da API HTTP do SDK Frodobots. Os quadros da câmera são acessados diretamente por meio dos endpoints HTTP do SDK.