LeRobot documentation
Robots
Robots
Cada robot en LeRobot implementa la interfaz Robot: conectar, leer una observación, enviar una acción,
desconectar. Escribir una política o un script de grabación contra esa interfaz significa que funciona con cualquier
brazo compatible sin cambios.
Esta página es la referencia generada. Para las instrucciones de cableado, calibración y primera ejecución, comience con las guías de hardware: SO-101, LeKiwi, Hope Jr, Reachy 2, OpenArm — o con Imitation Learning for Robots para el flujo de trabajo de extremo a extremo. Para los robots mantenidos por la comunidad que están fuera del conjunto principal, consulte Third-Party Robots & Teleoperators. Para agregar un robot propio, consulte Bring Your Own Hardware.
Robot
La clase base abstracta. Las subclases implementan cada uno de los métodos siguientes; el contrato descrito aquí es en lo que puede confiar una política o un bucle de grabación.
clase lerobot.robots.Robot
< source >( config: RobotConfig )
La clase abstracta base para todos los robots compatibles con LeRobot.
Esta clase proporciona una interfaz estandarizada para interactuar con robots físicos. Las subclases deben implementar todos los métodos y propiedades abstractos para ser utilizables.
connect
< source >( calibrate: bool = True )
Establecer la comunicación con el robot.
Desconéctese del robot y realice la limpieza necesaria.
Aplica cualquier configuración de una sola vez o en tiempo de ejecución al robot. Esto puede incluir la configuración de parámetros de los motores, modos de control o estado inicial.
Calibra el robot si es aplicable. Si no, esta operación no debe hacer nada.
Este método debe recopilar los datos necesarios (p. ej., compensaciones de motor) y actualizar el diccionario
:pyattr:calibration en consecuencia.
get_observation
< source >( ) → RobotObservation
Devuelve
RobotObservation
Un diccionario plano que representa el estado sensorial actual del robot. Su estructura debe coincidir con :pymeth:observation_features.
Obtén la observación actual del robot.
send_action
< source >( action: dict ) → RobotAction
Envía un comando de acción al robot.
Un diccionario que describe la estructura y los tipos de las observaciones producidas por el robot.
Su estructura (claves) debe coincidir con la estructura de lo que devuelve :pymeth:get_observation.
Los valores del diccionario deben ser:
- El tipo del valor si es un valor simple, p. ej.
floatpara un valor propioceptivo individual (la posición/velocidad de una articulación) - Una tupla que representa la forma si es un valor de tipo matriz, p. ej.
(height, width, channel)para imágenes
Nota: esta propiedad debe poder llamarse independientemente de si el robot está conectado o no.
Un diccionario que describe la estructura y los tipos de las acciones esperadas por el robot. Su estructura (claves) debe coincidir con la estructura de lo que se pasa a :pymeth:send_action. Los valores del diccionario deben ser el tipo del valor si es un valor simple, p. ej. float para un valor propioceptivo individual (posición/velocidad objetivo de una articulación)
Nota: esta propiedad debe poder llamarse independientemente de si el robot está conectado o no.
Si el robot está conectado en este momento o no. Si es False, llamar a :pymeth:get_observation o
:pymeth:send_action debe lanzar un error.
Si el robot está calibrado actualmente o no. Debe ser siempre True si no es aplicable
RobotConfig
clase lerobot.robots.RobotConfig
< source >( id: str | None = Nonecalibration_dir: pathlib.Path | None = None )
make_robot_from_config
Seguidores de SO-100 y SO-101
SO100Follower y SO101Follower son alias de la misma clase SOFollower; los dos brazos difieren en su configuración, no en su código de control. SO100FollowerConfig y SO101FollowerConfig son igualmente alias de SOFollowerRobotConfig.
Base genérica de seguidor SO que implementa la funcionalidad común para SO-100/101/10X.
Diseñada para ser subclaseada con una config_class y un name específicos para cada modelo de hardware.
Asumimos que, en el momento de la conexión, el brazo se encuentra en una posición de reposo y que el par de torsión puede desactivarse de forma segura para ejecutar la calibración.
send_action
< source >( action: dict ) → RobotAction
Devuelve
RobotAction
la acción enviada a los motores, posiblemente recortada.
Lanza
RobotDeviceNotConnectedError
RobotDeviceNotConnectedError— si el robot no está conectado.
Comanda el brazo para que se mueva a una configuración de articulaciones objetivo.
La magnitud de la acción relativa puede recortarse según el parámetro de configuración max_relative_target. En este caso, la acción enviada difiere de la acción original.
Por lo tanto, esta función siempre devuelve la acción que se envió realmente.
clase lerobot.robots.so_follower.SOFollowerRobotConfig
< source >( port: strdisable_torque_on_disconnect: bool = Truemax_relative_target: float | dict[str, float] | None = Nonecameras: dict = <factory>use_degrees: bool = Trueposition_p_coefficient: int = 16position_i_coefficient: int = 0position_d_coefficient: int = 32num_read_retries: int = 2id: str | None = Nonecalibration_dir: pathlib.Path | None = None )
BiSOFollower
Dos seguidores de SO controlados como un robot bimanual único.
Brazos seguidores bimanuales SO diseñados por TheRobotStudio
clase lerobot.robots.bi_so_follower.BiSOFollowerConfig
< source >( left_arm_config: SOFollowerConfigright_arm_config: SOFollowerConfigcameras: dict = <factory>id: str | None = Nonecalibration_dir: pathlib.Path | None = None )
Clase de configuración para robots Bi SO Follower.
KochFollower
- Koch v1.0, con y sin la expansión de muñeca a codo, desarrollado por Alexander Koch de Tau Robotics
- Koch v1.1 desarrollado por Jess Moss
Asumimos que, en el momento de la conexión, el brazo se encuentra en una posición de reposo y que el par de torsión puede desactivarse de forma segura para ejecutar la calibración.
send_action
< source >( action: dict ) → RobotAction
Comanda el brazo para que se mueva a una configuración de articulaciones objetivo.
La magnitud de la acción relativa puede recortarse según el parámetro de configuración max_relative_target. En este caso, la acción enviada difiere de la acción original.
Por lo tanto, esta función siempre devuelve la acción que se envió realmente.
clase lerobot.robots.koch_follower.KochFollowerConfig
< source >( port: strdisable_torque_on_disconnect: bool = Truemax_relative_target: float | dict[str, float] | None = Nonecameras: dict = <factory>use_degrees: bool = Falseid: str | None = Nonecalibration_dir: pathlib.Path | None = None )
LeKiwi
LeKiwi se ejecuta en el propio robot. LeKiwiClient es el proxy del lado del host que se comunica con él a través de la red y presenta la misma interfaz Robot.
El robot incluye una base móvil de tres ruedas omnidireccionales y un brazo seguidor remoto. El brazo líder se conecta localmente (en el portátil) y sus posiciones articulares se registran y luego se reenvían al brazo seguidor remoto (después de aplicar un límite de seguridad). En paralelo, la teleoperación por teclado se utiliza para generar comandos de velocidad crudos para las ruedas.
send_action
< source >( action: dict ) → RobotAction
Devuelve
RobotAction
la acción enviada a los motores, posiblemente recortada.
Lanza
RobotDeviceNotConnectedError
RobotDeviceNotConnectedError— si el robot no está conectado.
Ordena a lekiwi que se mueva a una configuración de articulaciones objetivo.
La magnitud de la acción relativa puede recortarse según el parámetro de configuración max_relative_target. En este caso, la acción enviada difiere de la acción original.
Por lo tanto, esta función siempre devuelve la acción que se envió realmente.
clase lerobot.robots.lekiwi.LeKiwiConfig
< source >( port: str = '/dev/ttyACM0'disable_torque_on_disconnect: bool = Truemax_relative_target: float | dict[str, float] | None = Nonecameras: dict = <factory>use_degrees: bool = Truenum_read_retries: int = 2id: str | None = Nonecalibration_dir: pathlib.Path | None = None )
Establece sockets ZMQ con el robot móvil remoto
Limpia las comunicaciones ZMQ
Captura observaciones del robot remoto: posiciones actuales del brazo seguidor, velocidades actuales de las ruedas (convertidas a velocidades en el marco del cuerpo: x, y, theta) y un fotograma de la cámara. Recibe por ZMQ, convierte a velocidades en el marco del
send_action
< source >( action: dict ) → np.ndarray
Ordena a lekiwi que se mueva a una configuración de articulaciones objetivo. Traduce al espacio de motores + envía a través de ZMQ
clase lerobot.robots.lekiwi.LeKiwiClientConfig
< source >( remote_ip: strport_zmq_cmd: int = 5555port_zmq_observations: int = 5556teleop_keys: dict = <factory>cameras: dict = <factory>polling_timeout_ms: int = 15connect_timeout_s: int = 5id: str | None = Nonecalibration_dir: pathlib.Path | None = None )
OpenArmFollower
Robot seguidor OpenArms que utiliza la comunicación por bus CAN para controlar un brazo de 7 GDL con una pinza. El brazo utiliza motores Damiao en modo de control MIT.
Ejecuta el procedimiento de calibración para el robot OpenArms.
El procedimiento de calibración:
- Desactivar el par
- Pídale al usuario que posicione los brazos en posición de suspensión con los agarradores cerrados
- Establecer esto como posición cero
- Registrar el rango de movimiento de cada articulación
- Guardar calibración
Configure los motores con los ajustes adecuados.
Conéctese al robot y, opcionalmente, calíbrelo.
Asumimos que, en el momento de la conexión, los brazos se encuentran en una posición de reposo segura y que el par de torsión puede desactivarse de forma segura para ejecutar la calibración si es necesario.
Desconectar del robot.
Obtén la observación actual del robot, incluida la posición, la velocidad y el par.
Lee todos los estados de los motores (posición/velocidad/torque) en un solo ciclo de actualización de CAN, en lugar de 3 lecturas separadas.
send_action
< source >( action: dictcustom_kp: dict[str, float] | None = Nonecustom_kd: dict[str, float] | None = None )
Parámetros
- action — Diccionario con las posiciones de los motores (p. ej., “joint_1.pos”, “joint_2.pos”)
- custom_kp — Ganancias kp personalizadas opcionales por motor (p. ej., {“joint_1”: 120.0, “joint_2”: 150.0})
- custom_kd — Gains kd personalizados opcionales por motor (p. ej., {“joint_1”: 1.5, “joint_2”: 2.0})
Envía un comando de acción al robot.
La magnitud de la acción puede recortarse en función de los límites de seguridad.
clase lerobot.robots.openarm_follower.OpenArmFollowerConfig
< source >( port: strside: str | None = Nonecan_interface: str = 'socketcan'use_can_fd: bool = Truecan_bitrate: int = 1000000can_data_bitrate: int = 5000000disable_torque_on_disconnect: bool = Trueuse_velocity_and_torque: bool = Falsemax_relative_target: float | dict[str, float] | None = Nonecameras: dict = <factory>motor_config: dict = <factory>position_kp: list = <factory>position_kd: list = <factory>joint_limits: dict = <factory>id: str | None = Nonecalibration_dir: pathlib.Path | None = None )
BiOpenArmFollower
clase lerobot.robots.bi_openarm_follower.BiOpenArmFollower
< source >( config: BiOpenArmFollowerConfig )
Brazos seguidor bimanuales OpenArm
clase lerobot.robots.bi_openarm_follower.BiOpenArmFollowerConfig
< source >( id: str | None = 'bi_openarm_follower'calibration_dir: pathlib.Path | None = Noneleft_arm_config: OpenArmFollowerConfigBaseright_arm_config: OpenArmFollowerConfigBasecameras: dict = <factory> )
Clase de configuración para robots Bi OpenArm Follower.
OmxFollower
Para los robots OMX que vienen precalibrados:
- Si la calibración predeterminada del paquete no coincide con los motores, lea desde los motores y guarde
- Esto permite utilizar robots precalibrados sin calibración manual
- Si no existe un archivo de calibración, use los valores predeterminados de fábrica (homing_offset=0, range_min=0, range_max=4095)
send_action
< source >( action: dict ) → RobotAction
Comanda el brazo para que se mueva a una configuración de articulaciones objetivo.
La magnitud de la acción relativa puede recortarse según el parámetro de configuración max_relative_target. En este caso, la acción enviada difiere de la acción original.
Por lo tanto, esta función siempre devuelve la acción que se envió realmente.
clase lerobot.robots.omx_follower.OmxFollowerConfig
< source >( port: strdisable_torque_on_disconnect: bool = Truemax_relative_target: float | dict[str, float] | None = Nonecameras: dict = <factory>use_degrees: bool = Falseid: str | None = Nonecalibration_dir: pathlib.Path | None = None )
Reachy2Robot
Reachy 2, de Pollen Robotics.
clase lerobot.robots.reachy2.Reachy2RobotConfig
< source >( max_relative_target: float | None = Noneip_address: str | None = 'localhost'port: int = 50065disable_torque_on_disconnect: bool = Falseuse_external_commands: bool = Falsewith_mobile_base: bool = Truewith_l_arm: bool = Truewith_r_arm: bool = Truewith_neck: bool = Truewith_antennas: bool = Truewith_left_teleop_camera: bool = Falsewith_right_teleop_camera: bool = Falsewith_torso_camera: bool = Falsecamera_width: int = 640camera_height: int = 480cameras: dict = <factory>id: str | None = Nonecalibration_dir: pathlib.Path | None = None )
UnitreeG1
clase lerobot.robots.unitree_g1.UnitreeG1Config
< source >( kp: list[float] | None = Nonekd: list[float] | None = Nonedefault_positions: list = <factory>control_dt: float = 0.004is_simulation: bool = Trueend_effector: G1EndEffector = <G1EndEffector.DEX1: 'dex1'>sim_publish_images: bool = Truesim_camera_port: int = 5555sim_onscreen: bool | None = Nonerobot_ip: str = '192.168.123.164'cameras: dict = <factory>gravity_compensation: bool = Falsecontroller: str | None = Noneembodiment: str = 'g1_29'id: str | None = Nonecalibration_dir: pathlib.Path | None = None )
Hope Jr
El humanoide Hope Jr se expone como dos robots independientes, un brazo y una mano.
Asumimos que, en el momento de la conexión, el brazo se encuentra en una posición de reposo y que el par de torsión puede desactivarse de forma segura para ejecutar la calibración.
clase lerobot.robots.hope_jr.HopeJrArmConfig
< source >( port: strdisable_torque_on_disconnect: bool = Truemax_relative_target: float | dict[str, float] | None = Nonecameras: dict = <factory>id: str | None = Nonecalibration_dir: pathlib.Path | None = None )
clase lerobot.robots.hope_jr.HopeJrHandConfig
< source >( port: strside: strdisable_torque_on_disconnect: bool = Truecameras: dict = <factory>id: str | None = Nonecalibration_dir: pathlib.Path | None = None )
RebotB601Follower
clase lerobot.robots.rebot_b601_follower.RebotB601Follower
< source >( config: RebotB601FollowerRobotConfig )
Brazo seguidor reBot B601 de Seeed Studio (6-DOF + pinza, motores CAN).
La comunicación con el motor se gestiona mediante el paquete motorbridge a través de un bus CAN, al que se accede ya sea mediante un puente serial Damiao o mediante el transporte CAN nativo de MotorBridge.
Establezca el modo de control de cada motor antes de habilitar el par.
Desactive el par del motor para que el brazo pueda moverse a mano (depuración de solo lectura).
Desconecte los motores y las cámaras del robot.
Comanda el brazo hacia una configuración de articulaciones objetivo.
Las posiciones se expresan en grados. La magnitud de la acción relativa puede recortarse en función de max_relative_target, por lo que siempre se devuelve la acción que se envía realmente.
clase lerobot.robots.rebot_b601_follower.RebotB601FollowerRobotConfig
< source >( port: strmotor_family: MotorFamily = <MotorFamily.DM: 'dm'>can_adapter: str | None = Nonedm_serial_baud: int = 921600disable_torque_on_disconnect: bool = Truemax_relative_target: float | dict[str, float] | None = Nonecameras: dict = <factory>motor_can_ids: dict[str, tuple[int, int]] | None = Nonecontrol_mode: ArmControlMode = <ArmControlMode.MIT: 'mit'>gripper_control_mode: lerobot.robots.rebot_b601_follower.motor_family.GripperControlMode | None = Nonemit_kp: float | dict[str, float] | None = Nonemit_kd: float | dict[str, float] | None = Nonepos_vel_velocity: float | dict[str, float] | None = Nonegripper_torque_ratio: float | None = Nonegripper_torque_limit: float | None = Nonegripper_hold_torque_limit: float | None = Nonejoint_limits: dict[str, tuple[float, float]] | None = Noneid: str | None = Nonecalibration_dir: pathlib.Path | None = None )
Configuración registrada para el robot seguidor reBot B601.
BiRebotB601Follower
clase lerobot.robots.bi_rebot_b601_follower.BiRebotB601Follower
< source >( config: BiRebotB601FollowerConfig )
Seguidor bimanual Seeed Studio reBot B601.
Compone dos instancias de RebotB601Follower de un solo brazo. Las claves de observación y acción de cada brazo se nombran con un prefijo left_ / right_.
clase lerobot.robots.bi_rebot_b601_follower.BiRebotB601FollowerConfig
< source >( left_arm_config: RebotB601FollowerConfigright_arm_config: RebotB601FollowerConfigcameras: dict = <factory>id: str | None = Nonecalibration_dir: pathlib.Path | None = None )
Clase de configuración para el robot seguidor bimanual reBot B601.
EarthRoverMiniPlus
clase lerobot.robots.earthrover_mini_plus.EarthRoverMiniPlus
< source >( config: EarthRoverMiniPlusConfig )
Robot EarthRover Mini Plus controlado a través de la API HTTP del SDK de Frodobots.
Este robot utiliza un control basado en la nube a través del SDK de Frodobots en lugar de una conexión directa con el hardware. Las cámaras transmiten en vivo a través de la nube de Agora mediante WebRTC, y los comandos de control se envían mediante solicitudes HTTP POST.
El robot admite:
- Cámaras duales (frontal y trasera) accedidas a través de puntos finales HTTP del SDK
- Control de velocidad lineal y angular
- Telemetría de batería y orientación
No se necesita calibración para un robot basado en SDK.
Configurar el robot (sin efecto para robots basados en SDK).
connect
< source >( calibrate: bool = True )
Conectar al robot a través del SDK de Frodobots.
desconectar
< source >( )
Lanza
DeviceNotConnectedError
DeviceNotConnectedError— Si el robot no está conectado
Desconectar del robot.
Detiene el robot y cierra la conexión con el SDK.
get_observation
< source >( ) → RobotObservation
Devuelve
RobotObservation
Observación que contiene:
- front: Imagen de la cámara frontal (480, 640, 3) en formato RGB
- rear: Imagen de la cámara trasera (480, 640, 3) en formato RGB
- speed: float - Velocidad actual (valor crudo de la SDK)
- battery_level: float - Nivel de batería (0-100)
- orientation: float - Orientación del robot en grados
- gps_latitude: float - coordenada de latitud GPS
- gps_longitude: float - coordenada de longitud GPS
- gps_signal: float - Intensidad de la señal GPS (porcentaje)
- signal_level: float - Nivel de señal de red (0-5)
- vibration: float - Lectura del sensor de vibración
- lamp: float - Estado de la lámpara (0=apagado, 1=encendido)
- accelerometer_x/y/z: float - Ejes del acelerómetro (valor crudo de la SDK)
- gyroscope_x/y/z: float - Ejes del giroscopio (valor crudo de la SDK)
- magnetometer_filtered_x/y/z: float - Ejes del magnetómetro (valor bruto de la SDK)
- wheel_rpm_0/1/2/3: float - RPM de las ruedas
Lanza
DeviceNotConnectedError
DeviceNotConnectedError— Si el robot no está conectado
Obtén la observación actual del robot desde el SDK.
Los fotogramas de la cámara se obtienen de los puntos finales de SDK /v2/front y /v2/rear. Los fotogramas se decodifican desde base64 y se convierten del formato BGR al formato RGB. La telemetría del robot se obtiene del punto final /data. Los arreglos de sensores (accels, gyros, mags, rpms) contienen cada uno entradas de [values…, timestamp]; se utiliza la lectura más reciente de cada arreglo.
Nota: Los fotogramas de la cámara se obtienen de los puntos finales de SDK /v2/front y /v2/rear. Los fotogramas se decodifican desde base64 y se convierten del formato BGR al formato RGB. La telemetría del robot se obtiene del punto final /data. Todos los valores de SDK se normalizan a los rangos apropiados para la grabación del conjunto de datos.
send_action
< source >( action: dict ) → RobotAction
Parámetros
- action — Diccionario de acción con las siguientes claves:
- linear_velocity: Velocidad lineal objetivo (-1 a 1)
- angular_velocity: Velocidad angular objetivo (-1 a 1)
Devuelve
RobotAction
La acción que se envió (coincide con las claves de action_features)
Lanza
DeviceNotConnectedError
DeviceNotConnectedError— Si el robot no está conectado
Envía la acción al robot a través del SDK.
Nota: Las acciones se envían al SDK a través del punto de acceso POST /control. El SDK espera comandos en el rango [-1, 1].
clase lerobot.robots.earthrover_mini_plus.EarthRoverMiniPlusConfig
< source >( sdk_url: str = 'http://localhost:8000'id: str | None = Nonecalibration_dir: pathlib.Path | None = None )
Configuración para el robot EarthRover Mini Plus usando el SDK de Frodobots.
Este robot utiliza control basado en la nube a través de la API HTTP del SDK de Frodobots. Los fotogramas de la cámara se acceden directamente a través de los puntos finales HTTP del SDK.