Skip to main content

Cómo usar el brazo robótico SO-ARM100 y SO-ARM101 en la versión antigua de Lerobot

tip

Este repositorio de tutoriales mantiene la versión estable verificada de Lerobot al 5 de junio de 2025. Actualmente, ​Hugging Face​ ha lanzado una ​actualización importante​ a Lerobot, introduciendo muchas características nuevas. Si deseas experimentar los tutoriales más recientes, por favor sigue la ​documentación oficial​ para orientación.

Introducción​

El SO-10xARM es un proyecto de brazo robótico completamente de código abierto lanzado por TheRobotStudio. Incluye el brazo seguidor y el brazo robótico líder, y también proporciona archivos detallados de impresión 3D y guías de operación. LeRobot está comprometido a proporcionar modelos, conjuntos de datos y herramientas para robótica del mundo real en PyTorch. Su objetivo es reducir la barrera de entrada de la robótica, permitiendo que todos contribuyan y se beneficien del intercambio de conjuntos de datos y modelos preentrenados. LeRobot integra metodologías de vanguardia validadas para aplicación en el mundo real, centrándose en el aprendizaje por imitación. Ha proporcionado un conjunto de modelos preentrenados, conjuntos de datos con demostraciones recopiladas por humanos y entornos de simulación, permitiendo a los usuarios comenzar sin la necesidad de ensamblar robots. En las próximas semanas, la intención es aumentar el soporte para robótica del mundo real en los robots más rentables y competentes actualmente accesibles.

Introducción del Proyecto​

El kit de robot inteligente SO-ARM10x y reComputer Jetson AI combina perfectamente el control de brazo robótico de alta precisión con una potente plataforma de computación AI, proporcionando una solución integral de desarrollo de robots. Este kit está basado en la plataforma Jetson Orin o AGX Orin, combinado con el brazo robótico SO-ARM10x y el marco AI LeRobot, ofreciendo a los usuarios un sistema de robot inteligente aplicable a múltiples escenarios como educación, investigación y automatización industrial. Este wiki proporciona el tutorial de ensamblaje y depuración para el SO ARM10x y realiza la recopilación de datos y entrenamiento dentro del marco de Lerobot.

Obtener Uno Ahora 🖱️

Características Principales​

  1. Código abierto y bajo costo: Es una solución de brazo robótico de código abierto y bajo costo de TheRobotStudio
  2. Integración con LeRobot: Diseñado para integración con la plataforma LeRobot
  3. Abundantes recursos de aprendizaje: Proporciona recursos de aprendizaje de código abierto integrales como guías de ensamblaje y calibración, y tutoriales para pruebas, recopilación de datos, entrenamiento y despliegue para ayudar a los usuarios a comenzar rápidamente y desarrollar aplicaciones robóticas.
  4. Compatible con Nvidia: Despliega este kit de brazo con reComputer Mini J4012 Orin NX 16 GB.
  5. Aplicación Multi-Escenario: Es aplicable a campos como educación, investigación científica, producción automatizada y robótica, ayudando a los usuarios a lograr operaciones de robot eficientes y precisas en varias tareas complejas.

Novedades​

  • Optimización del cableado: Comparado con SO-ARM100, SO-ARM101 presenta un cableado mejorado que previene problemas de desconexión previamente vistos en la articulación 3. El nuevo diseño de cableado también ya no limita el rango de movimiento de las articulaciones.
  • Diferentes relaciones de engranajes para el brazo líder: El brazo líder ahora usa motores con relaciones de engranajes optimizadas, mejorando el rendimiento y eliminando la necesidad de cajas de engranajes externas.
  • Soporte de nueva funcionalidad: El brazo líder ahora puede seguir al brazo seguidor en tiempo real, lo cual es crucial para la próxima política de aprendizaje, donde un humano puede intervenir y corregir las acciones del robot.
caution

Seeed Studio solo es responsable de la calidad del hardware en sí. Los tutoriales se actualizan estrictamente de acuerdo con la documentación oficial. Si encuentras problemas de software o problemas de dependencias del entorno que no se pueden resolver, además de verificar la sección de FAQ al final de este tutorial, por favor reporta el problema oportunamente a la plataforma LeRobot o al canal Discord de LeRobot.

Especificaciones​

TipoSO-ARM100SO-ARM101
Kit de BrazoKit de Brazo ProKit de BrazoKit de Brazo Pro
Brazo Líder12x motores ST-3215-C001 (7.4V) con relación de engranajes 1:345 para todas las articulaciones12x motores ST-3215-C018/ST-3215-C047 (12V) con relación de engranajes 1:345 para todas las articulaciones

1x motor ST-3215-C001 (7.4V) con relación de engranajes 1:345 solo para la articulación 2
2x motores ST-3215-C044 (7.4V) con relación de engranajes 1:191 para las articulaciones 1 y 3
3x motores ST-3215-C046 (7.4V) con relación de engranajes 1:147 para las articulaciones 4, 5 y pinza (articulación 6)

Brazo SeguidorIgual que SO-ARM100
Fuente de Alimentación5.5 mm × 2.1 mm DC 5 V 4 A5.5 mm × 2.1 mm DC 12 V 2 A5.5 mm × 2.1 mm DC 5 V 4 A

5.5 mm × 2.1 mm DC 12 V 2 A (Brazo Seguidor)
5.5 mm × 2.1 mm DC 5 V 4 A (Brazo Líder)

Sensor de ÁnguloCodificador magnético de 12 bits
Temperatura de Operación Recomendada0 °C a 40 °C
ComunicaciónUART
Método de ControlPC
danger

Si compras la versión Arm Kit, ambas fuentes de alimentación son de 5V. Si compras la versión Arm Kit Pro, por favor usa la fuente de alimentación de 5V para la calibración y cada paso del brazo robótico Líder, y la fuente de alimentación de 12V para la calibración y cada paso del brazo robótico Seguidor.

Lista de Materiales (BOM)​

ParteCantidadIncluido
Motores Servo12✅
Placa de Control de Motor2✅
Cable USB-C 2 piezas1✅
Fuente de Alimentación22✅
Abrazadera de Mesa4✅
Partes impresas en 3D del brazo1Opción

Entorno del Sistema Inicial​

Para Ubuntu x86:

  • Ubuntu 22.04
  • CUDA 12+
  • Python 3.10
  • Torch 2.6

Para Jetson Orin:

  • Jetson JetPack 6.2
  • Python 3.10
  • Torch 2.6

Tabla de Contenidos​

A. Guía de Impresión 3D

B. Instalar LeRobot

C. Configurar los motores

D. Ensamblaje

E. Calibrar

F. Teleoperar

G. Agregar cámaras

H. Grabar el conjunto de datos

I. Visualizar el conjunto de datos

J. Reproducir un episodio

K. Entrenar una política

L. Evaluar tu política

Guía de Impresión 3D​

caution

Siguiendo la actualización oficial de SO101, SO100 ya no lo soportará y los archivos fuente serán eliminados según lo oficial, pero los archivos fuente aún se pueden encontrar en nuestro Makerworld. Sin embargo, para usuarios que han comprado previamente SO100, los tutoriales y métodos de instalación siguen siendo compatibles. La impresión de SO101 es completamente compatible con la instalación del kit de motor de SO100.

Paso 1: Elegir una impresora​

Los archivos STL proporcionados están listos para imprimir en muchas impresoras FDM. A continuación se muestran las configuraciones probadas y sugeridas aunque otras pueden funcionar.

  • Material: PLA+
  • Diámetro de Boquilla y Precisión: diámetro de boquilla de 0.4mm a altura de capa de 0.2mm o boquilla de 0.6mm a altura de capa de 0.4mm.
  • Densidad de Relleno: 15%

Paso 2: Configurar la impresora​

  • Asegúrese de que la impresora esté calibrada y el nivel de la cama esté configurado correctamente usando las instrucciones específicas de la impresora.
  • Limpie la cama de impresión, asegurándose de que esté libre de polvo o grasa. Si limpia la cama con agua u otro líquido, seque la cama.
  • Si su impresora lo recomienda, use una barra de pegamento estándar y aplique una capa delgada y uniforme de pegamento en el área de impresión de la cama. Evite la acumulación o aplicación desigual.
  • Cargue el filamento de la impresora usando las instrucciones específicas de la impresora.
  • Asegúrese de que la configuración de la impresora coincida con las sugeridas anteriormente (la mayoría de las impresoras tienen múltiples configuraciones, así que elija las que más se acerquen).
  • Configure para soportes en todas partes pero ignore pendientes mayores a 45 grados respecto a la horizontal.
  • No debe haber soportes en los agujeros de tornillos con ejes horizontales.

Paso 3: Imprimir las piezas​

Todas las piezas para el líder o seguidor están para impresión 3D fácil ya contenidas en un solo archivo, correctamente orientadas para z hacia arriba para minimizar soportes.

  • Para tamaños de cama de impresora de 220mmx220mm (como la Ender), imprima estos archivos:

  • Para tamaños de cama de impresora de 205mm x 250mm (como la Prusa/Up):

Instalar LeRobot​

Entornos como pytorch y torchvision necesitan ser instalados basándose en su CUDA.

  1. Instalar Miniconda: Para Jetson:
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-aarch64.sh
chmod +x Miniconda3-latest-Linux-aarch64.sh
./Miniconda3-latest-Linux-aarch64.sh
source ~/.bashrc

O, Para X86 Ubuntu 22.04:

mkdir -p ~/miniconda3
cd miniconda3
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -O ~/miniconda3/miniconda.sh
bash ~/miniconda3/miniconda.sh -b -u -p ~/miniconda3
rm ~/miniconda3/miniconda.sh
source ~/miniconda3/bin/activate
conda init --all
  1. Crear y activar un entorno conda fresco para lerobot
conda create -y -n lerobot python=3.10 && conda activate lerobot
  1. Clonar Lerobot:
git clone https://github.com/ZhuYaoHui1998/lerobot.git ~/lerobot

Adaptamos la cámara de profundidad Orbbec Gemini2 y encontramos que una sola cámara de profundidad funciona mejor que dos cámaras RGB. Si también está usando esta cámara, por favor clone la rama del repositorio de conversión a Orbbec y siga nuestros pasos posteriores para configurar la cámara.

cd ~/lerobot  
git checkout orbbec

Si solo está usando RGB, no cambie de rama, de lo contrario pueden ocurrir errores relacionados con dependencias. Si ya cambió a orbbec y quiere volver a la versión original:

cd ~/lerobot  
git checkout main
  1. Cuando use miniconda, instale ffmpeg en su entorno:
conda install ffmpeg -c conda-forge
tip

Esto usualmente instala ffmpeg 7.X para su plataforma compilado con el codificador libsvtav1. Si libsvtav1 no es compatible (verifique los codificadores compatibles con ffmpeg -encoders), puede:

  • [En cualquier plataforma] Instalar explícitamente ffmpeg 7.X usando:
conda install ffmpeg=7.1.1 -c conda-forge
  • [Solo en Linux] Instalar dependencias de compilación de ffmpeg y compilar ffmpeg desde el código fuente con libsvtav1, y asegúrese de usar el binario ffmpeg correspondiente a su instalación con which ffmpeg.
  1. Instalar LeRobot con dependencias para los motores feetech:
cd ~/lerobot && pip install -e ".[feetech]"
  1. (Este paso se puede omitir en el lado de la computadora X86 Ubuntu.) Para dispositivos Jetson Jetpack (por favor asegúrese de instalar Pytorch-gpu y Torchvision del paso 5 antes de ejecutar este paso):
conda install -y -c conda-forge "opencv>=4.10.0.84"  # Install OpenCV and other dependencies through conda, this step is only for Jetson Jetpack 6.0+
conda remove opencv   # Uninstall OpenCV 
pip3 install opencv-python==4.10.0.84  # Then install opencv-python via pip3
conda install -y -c conda-forge ffmpeg
conda uninstall numpy
pip3 install numpy==1.26.0  # This should match torchvision
  1. Verificar Pytorch y Torchvision

Dado que instalar el entorno lerobot vía pip desinstalará el Pytorch y Torchvision originales e instalará las versiones CPU de Pytorch y Torchvision, necesita realizar una verificación en Python.

import torch
print(torch.cuda.is_available())

Si el resultado impreso es False, necesita reinstalar Pytorch y Torchvision según el tutorial del sitio web oficial.

Si está usando un dispositivo Jetson, instale Pytorch y Torchvision según este tutorial.

Configurar los motores​

danger

Debido a actualizaciones del código oficial y firmware del fabricante de servos, usuarios antes del 30 de junio de 2025, por favor descarguen primero el software de computadora host oficial de Feetech (para sistemas Windows). Encienda y conecte todos los servos, seleccione el Número de Puerto correspondiente -> Baudrate 1000000 -> Abrir -> Buscar. Después de detectar todos los servos, haga clic en Actualizar -> Detección en Línea -> Actualizar Firmware para asegurar que la versión del firmware se actualice de 3.9 a 3.10 para evitar problemas posteriores.

note

Si el servo no puede ser reconocido nuevamente después de una actualización de firmware fallida, puede conectar otro servo detectable directamente a la computadora host, luego realizar un escaneo de motor y detección de firmware en línea. Mantenga la ventana actual abierta, desconecte inmediatamente el servo actual, y conecte el servo no reconocido en su lugar. Haga clic en "Actualización en Línea" dentro de 1 segundo. Si falla, puede reintentar múltiples veces.

El proceso de calibración e inicialización del servo para SO-ARM101 es el mismo que el de SO-ARM100 en términos de método y código. Sin embargo, tenga en cuenta que las relaciones de engranajes para las primeras tres articulaciones del Brazo Líder SO-ARM101 difieren de las de SO-ARM100, por lo que es importante distinguir y calibrarlas cuidadosamente.

Para configurar los motores designe un adaptador de servo de bus y 6 motores para su brazo líder, y de manera similar el otro adaptador de servo de bus y 6 motores para el brazo seguidor. Es conveniente etiquetarlos y escribir en cada motor si es para el seguidor F o para el líder L y su ID del 1 al 6. Usamos F1–F6 para representar las articulaciones 1 a 6 del Brazo Seguidor, y L1–L6 para representar las articulaciones 1 a 6 del Brazo Líder. Los detalles correspondientes del modelo de servo, asignaciones de articulaciones y relación de engranajes son los siguientes:

Modelo de ServoRelación de EngranajesArticulaciones Correspondientes
ST-3215-C044(7.4V)1:191L1
ST-3215-C001(7.4V)1:345L2
ST-3215-C044(7.4V)1:191L3
ST-3215-C046(7.4V)1:147L4–L6
ST-3215-C001(7.4V) / C018(12V) / C047(12V)1:345F1–F6
danger

Ahora debe conectar la fuente de alimentación de 5V o 12V al bus del motor. 5V para los motores STS3215 7.4V y 12V para los motores STS3215 12V. Tenga en cuenta que el brazo líder siempre usa los motores de 7.4V, así que tenga cuidado de conectar la fuente de alimentación correcta si tiene motores de 12V y 7.4V, ¡de lo contrario podría quemar sus motores! Ahora, conecte el bus del motor a su computadora vía USB. Tenga en cuenta que el USB no proporciona energía, y tanto la fuente de alimentación como el USB deben estar conectados.

Encontrar puertos USB asociados a sus brazos Para encontrar los puertos correctos para cada brazo, ejecute el script de utilidad dos veces:

python lerobot/scripts/find_motors_bus_port.py

Salida de ejemplo al identificar el puerto del brazo líder (ej., /dev/tty.usbmodem575E0031751 en Mac, o posiblemente /dev/ttyACM0 en Linux):

Salida de ejemplo al identificar el puerto del brazo seguidor (ej., /dev/tty.usbmodem575E0032081, o posiblemente /dev/ttyACM1 en Linux):

Solución de problemas: En Linux, podría necesitar dar acceso a los puertos USB ejecutando:

sudo chmod 666 /dev/ttyACM0
sudo chmod 666 /dev/ttyACM1

Configurar sus motores

danger

Por favor use una fuente de alimentación de 5V para calibrar los motores Líder (ST-3215-C046, C044, 001).

Calibración Articulación 6 Brazo LíderCalibración Articulación 5 Brazo LíderCalibración Articulación 4 Brazo LíderCalibración Articulación 3 Brazo LíderCalibración Articulación 2 Brazo LíderCalibración Articulación 1 Brazo Líder
fig1fig2fig3fig4fig5fig6
danger

Si compras la versión Arm Kit (ST-3215-C001), usa una fuente de alimentación de 5V. Si compras la versión Arm Kit Pro, por favor usa una fuente de alimentación de 12V para calibrar el servo (ST-3215-C047/ST-3215-C018).

Calibración Articulación 6 Brazo SeguidorCalibración Articulación 5 Brazo SeguidorCalibración Articulación 4 Brazo SeguidorCalibración Articulación 3 Brazo SeguidorCalibración Articulación 2 Brazo SeguidorCalibración Articulación 1 Brazo Seguidor
fig1fig2fig3fig4fig5fig6

También puedes consultar nuestro video de calibración de servos SO-ARM100, pero asegúrate de que los IDs de las articulaciones del servo y las relaciones de engranajes correspondan estrictamente a los del SO-ARM101.

Conecta tu primer motor y ejecuta este script para establecer su ID a 1. También establecerá su posición actual a 2048, así que espera que tu motor rote:

python lerobot/scripts/configure_motor.py \
  --port /dev/ttyACM0 \
  --brand feetech \
  --model sts3215 \
  --baudrate 1000000 \
  --ID 1

Nota: Estos motores están actualmente limitados. Solo pueden tomar valores entre 0 y 4096, lo que corresponde a una vuelta completa. No pueden girar más que eso. 2048 está en el medio de este rango, por lo que podemos tomar -2048 pasos (180 grados en sentido antihorario) y alcanzar el rango máximo, o tomar +2048 pasos (180 grados en sentido horario) y alcanzar el rango máximo. El paso de configuración también establece el offset de inicio a 0, para que si ensamblaste mal el brazo, siempre puedas actualizar el offset de inicio para compensar un desplazamiento de hasta ± 2048 pasos (± 180 grados).

Luego desconecta tu motor y conecta el segundo motor y establece su ID a 2.

python lerobot/scripts/configure_motor.py \
  --port /dev/ttyACM0 \
  --brand feetech \
  --model sts3215 \
  --baudrate 1000000 \
  --ID 2

Repite el proceso para todos tus motores hasta el ID 6. Haz lo mismo para los 6 motores del brazo líder.

Ensamblaje​

tip

  • El proceso de ensamblaje de brazo dual del SO-ARM101 es el mismo que el del SO-ARM100. Las únicas diferencias son la adición de clips de cable en el SO-ARM101 y las diferentes relaciones de engranajes de los servos de articulación en el Brazo Líder. Así que tanto SO100 como SO101 pueden instalarse consultando el siguiente contenido

  • Después de calibrar los servos, no los rotes antes de apretar los tornillos. Asegúrate de que la orientación de las piezas impresas en 3D coincida con la dirección de referencia en las imágenes y que los motores estén en sus posiciones medias.

  • Antes del ensamblaje, por favor verifica nuevamente tu modelo de motor y relación de reducción. Si has comprado SO100, puedes ignorar este paso. Si has comprado SO101, por favor verifica la siguiente tabla para distinguir F1 a F6 y L1 a L6.

Modelo de ServoRelación de EngranajesArticulaciones Correspondientes
ST-3215-C044(7.4V)1:191L1
ST-3215-C001(7.4V)1:345L2
ST-3215-C044(7.4V)1:191L3
ST-3215-C046(7.4V)1:147L4–L6
ST-3215-C001(7.4V) / C018(12V) / C047(12V)1:345F1–F6
danger

Si compraste la Edición Estándar SO101 Arm Kit, todas las fuentes de alimentación son de 5V. Si compraste la Edición Pro SO101 Arm Kit, el Brazo Líder debe calibrarse y operarse en cada paso usando una fuente de alimentación de 5V, mientras que el Brazo Seguidor debe calibrarse y operarse en cada paso usando una fuente de alimentación de 12V.

Ensamblar Brazo Líder

Paso 1Paso 2Paso 3Paso 4Paso 5Paso 6
fig1fig2fig3fig4fig5fig6
Paso 7Paso 8Paso 9Paso 10Paso 11Paso 12
fig1fig2fig3fig4fig5fig6
Paso 13Paso 14Paso 15Paso 16Paso 17Paso 18
fig1fig2fig3fig4fig5fig6
Paso 19Paso 20
fig1fig2

Ensamblar Brazo Seguidor

tip
  • Los pasos para ensamblar el Brazo Seguidor son generalmente los mismos que los del Brazo Líder. La única diferencia radica en el método de instalación del efector final (pinza y mango) después del Paso 12.
Paso 1Paso 2Paso 3Paso 4Paso 5Paso 6
fig1fig2fig3fig4fig5fig6
Paso 7Paso 8Paso 9Paso 10Paso 11Paso 12
fig1fig2fig3fig4fig5fig6
Paso 13Paso 14Paso 15Paso 16Paso 17
fig1fig2fig3fig4fig5

Calibrar​

tip

Los códigos SO100 y SO101 son compatibles. Los usuarios de SO100 pueden utilizar directamente los parámetros y código de SO101 para la operación.

danger

Si compraste el SO101 Arm Kit Standard Edition, todas las fuentes de alimentación son de 5V. Si compraste el SO101 Arm Kit Pro Edition, el Brazo Líder debe calibrarse y operarse en cada paso usando una fuente de alimentación de 5V, mientras que el Brazo Seguidor debe calibrarse y operarse en cada paso usando una fuente de alimentación de 12V.

A continuación, necesitas conectar la fuente de alimentación y el cable de datos a tu robot SO-10x para la calibración para asegurar que los brazos líder y seguidor tengan los mismos valores de posición cuando estén en la misma posición física. Esta calibración es esencial porque permite que una red neuronal entrenada en un robot SO-10x funcione en otro. Si necesitas recalibrar el brazo robótico, elimina la carpeta ~/lerobot/.cache/huggingface/calibration/so101.

Calibración manual del brazo seguidor

IMPORTANTE: Ahora que tienes tus puertos, actualiza los valores predeterminados del puerto de SO101RobotConfig (lerobot/lerobot/common/robot_devices/robots/configs.py). Encontrarás algo como:

@RobotConfig.register_subclass("so101")
@dataclass
class So101RobotConfig(ManipulatorRobotConfig):
    calibration_dir: str = ".cache/calibration/so101"
    # `max_relative_target` limits the magnitude of the relative positional target vector for safety purposes.
    # Set this to a positive scalar to have the same value for all motors, or a list that is the same length as
    # the number of motors in your follower arms.
    max_relative_target: int | None = None

    leader_arms: dict[str, MotorsBusConfig] = field(
        default_factory=lambda: {
            "main": FeetechMotorsBusConfig(
                port="/dev/ttyACM0",  <-- UPDATE HERE
                motors={
                    # name: (index, model)
                    "shoulder_pan": [1, "sts3215"],
                    "shoulder_lift": [2, "sts3215"],
                    "elbow_flex": [3, "sts3215"],
                    "wrist_flex": [4, "sts3215"],
                    "wrist_roll": [5, "sts3215"],
                    "gripper": [6, "sts3215"],
                },
            ),
        }
    )

    follower_arms: dict[str, MotorsBusConfig] = field(
        default_factory=lambda: {
            "main": FeetechMotorsBusConfig(
                port="/dev//dev/ttyACM1",  <-- UPDATE HERE
                motors={
                    # name: (index, model)
                    "shoulder_pan": [1, "sts3215"],
                    "shoulder_lift": [2, "sts3215"],
                    "elbow_flex": [3, "sts3215"],
                    "wrist_flex": [4, "sts3215"],
                    "wrist_roll": [5, "sts3215"],
                    "gripper": [6, "sts3215"],
                },
            ),
        }
    )
Teleoperación de Brazo Dual. (Opción)

Si quieres implementar teleoperación de brazo dual, significa que necesitas dos brazos robóticos Líder y dos brazos robóticos Seguidor. Por lo tanto, necesitas agregar los nombres de clase de los brazos robóticos y sus números de puerto correspondientes en el leader_arms dick y follower_arms dick, por ejemplo:

@RobotConfig.register_subclass("so101")
@dataclass
class So101RobotConfig(ManipulatorRobotConfig):
    calibration_dir: str = ".cache/calibration/so101"
    # `max_relative_target` limits the magnitude of the relative positional target vector for safety purposes.
    # Set this to a positive scalar to have the same value for all motors, or a list that is the same length as
    # the number of motors in your follower arms.
    max_relative_target: int | None = None

    leader_arms: dict[str, MotorsBusConfig] = field(
        default_factory=lambda: {
            "left": FeetechMotorsBusConfig(
                port="/dev/ttyACM0",  <-- UPDATE HERE
                motors={
                    # name: (index, model)
                    "shoulder_pan": [1, "sts3215"],
                    "shoulder_lift": [2, "sts3215"],
                    "elbow_flex": [3, "sts3215"],
                    "wrist_flex": [4, "sts3215"],
                    "wrist_roll": [5, "sts3215"],
                    "gripper": [6, "sts3215"],
                },
            ),
            "right": FeetechMotorsBusConfig(
                port="/dev/ttyACM1",  <-- UPDATE HERE
                motors={
                    # name: (index, model)
                    "shoulder_pan": [1, "sts3215"],
                    "shoulder_lift": [2, "sts3215"],
                    "elbow_flex": [3, "sts3215"],
                    "wrist_flex": [4, "sts3215"],
                    "wrist_roll": [5, "sts3215"],
                    "gripper": [6, "sts3215"],
                },
            ),
        }
    )

    follower_arms: dict[str, MotorsBusConfig] = field(
        default_factory=lambda: {
            "left": FeetechMotorsBusConfig(
                port="/dev//dev/ttyACM2",  <-- UPDATE HERE
                motors={
                    # name: (index, model)
                    "shoulder_pan": [1, "sts3215"],
                    "shoulder_lift": [2, "sts3215"],
                    "elbow_flex": [3, "sts3215"],
                    "wrist_flex": [4, "sts3215"],
                    "wrist_roll": [5, "sts3215"],
                    "gripper": [6, "sts3215"],
                },
            ),
            "right": FeetechMotorsBusConfig(
                port="/dev//dev/ttyACM3",  <-- UPDATE HERE
                motors={
                    # name: (index, model)
                    "shoulder_pan": [1, "sts3215"],
                    "shoulder_lift": [2, "sts3215"],
                    "elbow_flex": [3, "sts3215"],
                    "wrist_flex": [4, "sts3215"],
                    "wrist_roll": [5, "sts3215"],
                    "gripper": [6, "sts3215"],
                },
            ),
        }
    )

caution

Necesitas hacer coincidir correctamente los nombres izquierdo y derecho de los brazos duales y asegurar que el número de puerto serie de cada brazo robótico en el dispositivo esté asignado correctamente.

En el siguiente paso, al calibrar los brazos robóticos, necesitas calibrar los cuatro brazos individualmente. El comando es el siguiente:

sudo chmod 666 /dev/ttyACM*
python lerobot/scripts/control_robot.py \
  --robot.type=so101 \
  --robot.cameras='{}' \
  --control.type=calibrate \
  --control.arms='["left_follower"]'
  #  --control.arms='["right_follower"]'
  #  --control.arms='["left_leader"]'
  #  --control.arms='["right_leader"]'

Después de que se complete la calibración, puedes ver los resultados en el directorio .cache/calibration/so101.

`-- calibration
    `-- so101
        |-- left_follower.json
        |-- left_leader.json
        |-- right_follower.json
        `-- right_leader.json

Los pasos posteriores son los mismos que para la configuración de brazo único.

sudo chmod 666 /dev/ttyACM*

Calibración manual del brazo Seguidor

python lerobot/scripts/control_robot.py \
  --robot.type=so101 \
  --robot.cameras='{}' \
  --control.type=calibrate \
  --control.arms='["main_follower"]'

Calibración manual del brazo líder

python lerobot/scripts/control_robot.py \
  --robot.type=so101 \
  --robot.cameras='{}' \
  --control.type=calibrate \
  --control.arms='["main_leader"]'
Posición Media del SeguidorPosición Cero del SeguidorPosición Rotada del SeguidorPosición de Reposo del Seguidor
fig7fig1fig2fig3
Posición Media del LíderPosición Cero del LíderPosición Rotada del LíderPosición de Reposo del Líder
fig8fig4fig5fig6

Teleoperar​

Teleoperación simple ¡Entonces estás listo para teleoperar tu robot! Ejecuta este script simple (no se conectará ni mostrará las cámaras):

python lerobot/scripts/control_robot.py \
  --robot.type=so101 \
  --robot.cameras='{}' \
  --control.type=teleoperate

Agregar cámaras​

tip

Los códigos SO100 y SO101 son compatibles. Los usuarios de SO100 pueden utilizar directamente los parámetros y código de SO101 para la operación.

Después de insertar tus dos cámaras USB, ejecuta el siguiente script para verificar los números de puerto de las cámaras. Es importante recordar que la cámara no debe estar conectada a un Hub USB; en su lugar, debe conectarse directamente al dispositivo. La velocidad más lenta de un Hub USB puede resultar en la incapacidad de leer datos de imagen.

python lerobot/common/robot_devices/cameras/opencv.py \
    --images-dir outputs/images_from_opencv_cameras

La terminal imprimirá la siguiente información.

Mac or X86 Ubuntu detected. Finding available camera indices through scanning all indices from 0 to 60
[...]
Camera found at index 2
Camera found at index 4
[...]
Connecting cameras
OpenCVCamera(2, fps=30.0, width=640, height=480, color_mode=rgb)
OpenCVCamera(4, fps=30.0, width=640, height=480, color_mode=rgb)
Saving images to outputs/images_from_opencv_cameras
Frame: 0000 Latency (ms): 39.52
[...]
Frame: 0046 Latency (ms): 40.07
Images have been saved to outputs/images_from_opencv_cameras

Puedes encontrar las imágenes tomadas por cada cámara en el directorio outputs/images_from_opencv_cameras, y confirmar la información del índice de puerto correspondiente a las cámaras en diferentes posiciones. Luego completa la alineación de los parámetros de la cámara en el archivo lerobot/lerobot/common/robot_devices/robots/configs.py.

@RobotConfig.register_subclass("so101")
@dataclass
class So101RobotConfig(ManipulatorRobotConfig):
    calibration_dir: str = ".cache/calibration/so101"
    ''''''''''''''''
          .
          .
    ''''''''''''''''
    cameras: dict[str, CameraConfig] = field(
        default_factory=lambda: {
            "laptop": OpenCVCameraConfig(
                camera_index=0,             ##### UPDATE HEARE
                fps=30,
                width=640,
                height=480,
            ),
            "phone": OpenCVCameraConfig(
                camera_index=1,             ##### UPDATE HEARE
                fps=30,
                width=640,
                height=480,
            ),
        }
    )

    mock: bool = False

Details

Agregar dos o más cámaras adicionales. (Opcional) Si quieres agregar más cámaras, puedes continuar agregando diferentes nombres de cámara y valores de camera_index en el diccionario de cámaras, siempre que la entrada USB lo permita. Ten en cuenta que no se recomienda usar un hub USB para las cámaras.

@RobotConfig.register_subclass("so101")
@dataclass
class So101RobotConfig(ManipulatorRobotConfig):
    calibration_dir: str = ".cache/calibration/so101"
    ''''''''''''''''
          .
          .
    ''''''''''''''''
    cameras: dict[str, CameraConfig] = field(
        default_factory=lambda: {
            "laptop": OpenCVCameraConfig(
                camera_index=0,             ##### UPDATE HEARE
                fps=30,
                width=640,
                height=480,
            ),
            "phone": OpenCVCameraConfig(
                camera_index=1,             ##### UPDATE HEARE
                fps=30,
                width=640,
                height=480,
            ),
            "new_camera": OpenCVCameraConfig( ##### UPDATE HEARE
                camera_index=3,             ##### UPDATE HEARE
                fps=30,
                width=640,
                height=480,
            ),
        }
    )

    mock: bool = False

Usando una Sola Cámara de Profundidad Orbbec Gemini 2
tip

Este proyecto fue iniciado por Orbbec con valiosa orientación, e implementado por Jiaquan Zhang, Wenzhao Wang y Jinpeng Huang de la Universidad Normal del Sur de China. Permite el uso de cámaras Orbbec para recopilar datos de profundidad dentro del marco lerobot, enriqueciendo así la percepción ambiental de los brazos robóticos. Si ya tienes una cámara de profundidad Orbbec Gemini2, nuestra configuración de prueba actual coloca la cámara de profundidad en la posición frontal superior. Por favor, sigue las instrucciones de instalación a continuación.

Instalar y Compilar el SDK de Python de la Cámara de Profundidad Gemini 2

  1. Clonar pyOrbbecsdk
cd ~/
git clone https://github.com/orbbec/pyorbbecsdk.git
cd pyorbbecsdk
  1. Instalar dependencias y compilar pyOrbbecsdk
conda activate lerobot
sudo apt-get install python3-dev python3-venv python3-pip python3-opencv
pip3 install -r requirements.txt
mkdir build
cd build
cmake -Dpybind11_DIR=`pybind11-config --cmakedir` ..
make -j4
make install
cd ~/pyorbbecsdk
pip install -e .
  1. Probar si la cámara de profundidad funciona correctamente
cd ~/pyorbbecsdk 
pip install -e .
export PYTHONPATH=$PYTHONPATH:~/pyorbbecsdk/install/lib/
sudo bash ./scripts/install_udev_rules.sh
sudo udevadm control --reload-rules && sudo udevadm trigger
python3 examples/depth.py

Sin embargo, necesitas ejecutar estos comandos nuevamente al abrir una nueva terminal:

cd ~/pyorbbecsdk 
export PYTHONPATH=$PYTHONPATH:~/pyorbbecsdk/install/lib/
sudo bash ./scripts/install_udev_rules.sh
sudo udevadm control --reload-rules && sudo udevadm trigger

También puedes agregar lo siguiente al final de tu archivo .bashrc:

export PYTHONPATH=$PYTHONPATH:~/pyorbbecsdk/install/lib/
sudo bash ~/pyorbbecsdk/scripts/install_udev_rules.sh
sudo udevadm control --reload-rules && sudo udevadm trigger

Esto cargará automáticamente el entorno de la cámara de profundidad al iniciar una terminal.

Después de conectar tu cámara de profundidad Orbbec, ejecuta el siguiente script para verificar el flujo de datos de profundidad y el flujo de datos de color. Aparecerán dos ventanas, permitiéndote ajustar la posición de la cámara. Usa Ctrl+C en la terminal para salir. Importante: La cámara debe estar conectada directamente a tu dispositivo, no a través de un hub USB, ya que el ancho de banda del hub puede ser demasiado lento para la transmisión de datos de imagen.

Después de ajustar la cámara, alinea los parámetros de la cámara en el archivo de configuración en lerobot/lerobot/common/robot_devices/robots/configs.py.

@RobotConfig.register_subclass("so101")  # Also compatible with so100
@dataclass
class So101RobotConfig(ManipulatorRobotConfig):
    calibration_dir: str = ".cache/calibration/so101"
    ''''''''''''''''
          .
          .
    ''''''''''''''''
    cameras: dict[str, CameraConfig] = field(
        default_factory=lambda: {
            "Orbbec":OrbbecCameraConfig(    # Add Orbbec camera configuration here
                fps=30,
                use_depth=True,             # Whether to use depth
                width = 640,                # Resolution automatically adapts to width. Only 640 or 1280 (untested) are valid values
                Hi_resolution_mode = False, # High resolution mode (may reduce visualization quality but improves depth data resolution)
            ),

        }
    )

    mock: bool = False

Entonces podrás mostrar las cámaras en tu computadora mientras estés teleoperando ejecutando el siguiente código. Esto es útil para preparar tu configuración antes de grabar tu primer conjunto de datos.

python lerobot/scripts/control_robot.py \
  --robot.type=so101 \
  --control.type=teleoperate \
  --control.display_data=true

Grabar el conjunto de datos​

tip

Los códigos SO100 y SO101 son compatibles. Los usuarios de SO100 pueden utilizar directamente los parámetros y código de SO101 para la operación.

Una vez que estés familiarizado con la teleoperación, puedes grabar tu primer conjunto de datos con SO-10x.

Si quieres usar las funciones del hub de Hugging Face para subir tu conjunto de datos y no lo has hecho previamente, asegúrate de haber iniciado sesión usando un token de acceso de escritura, que se puede generar desde la configuración de Hugging Face:

huggingface-cli login --token ${HUGGINGFACE_TOKEN} --add-to-git-credential

Almacena el nombre de tu repositorio de Hugging Face en una variable para ejecutar estos comandos:

HF_USER=$(huggingface-cli whoami | head -n 1)
echo $HF_USER

Graba 2 episodios y sube tu conjunto de datos al hub:

python lerobot/scripts/control_robot.py \
  --robot.type=so101 \
  --control.type=record \
  --control.fps=30 \
  --control.single_task="Grasp a lego block and put it in the bin." \
  --control.repo_id=${HF_USER}/so101_test \
  --control.tags='["so101","tutorial"]' \
  --control.warmup_time_s=5 \
  --control.episode_time_s=30 \
  --control.reset_time_s=30 \
  --control.num_episodes=2 \
  --control.display_data=true \
  --control.push_to_hub=true

Verás muchas líneas apareciendo como esta:

INFO 2024-08-10 15:02:58 ol_robot.py:219 dt:33.34 (30.0hz) dtRlead: 5.06 (197.5hz) dtWfoll: 0.25 (3963.7hz) dtRfoll: 6.22 (160.7hz) dtRlaptop: 32.57 (30.7hz) dtRphone: 33.84 (29.5hz)

Explicaciones de Parámetros

  • wormup-time-s: Se refiere al tiempo de inicialización.
  • episode-time-s: Representa el tiempo para recopilar datos cada vez.
  • reset-time-s: Es el tiempo de preparación entre cada recopilación de datos.
  • num-episodes: Indica cuántos grupos de datos se espera recopilar.
  • push-to-hub: Determina si subir los datos al Hub de HuggingFace.
tip

  • "Si quieres guardar los datos localmente (--control.push_to_hub=false), reemplaza --control.repo_id=${HF_USER}/so101_test con un nombre de carpeta local personalizado, como --control.repo_id=seeed_123/so101_test. Entonces se almacenará en el directorio home del sistema en ~/.cache/huggingface/lerobot."

  • Si subiste tu conjunto de datos al hub con --control.push_to_hub=true, puedes visualizar tu conjunto de datos en línea copiando y pegando tu id de repositorio dado por:

  • Presiona la flecha derecha → en cualquier momento durante la grabación del episodio para detener temprano e ir al reinicio. Lo mismo durante el reinicio, para detener temprano e ir al siguiente episodio de grabación.

  • Presiona la flecha izquierda ← en cualquier momento durante la grabación del episodio o el reinicio para detener temprano, cancelar el episodio actual y volver a grabarlo.

  • Presiona escape ESC en cualquier momento durante la grabación del episodio para terminar la sesión temprano e ir directamente a la codificación de video y subida del conjunto de datos.

  • Nota: Puedes reanudar la grabación agregando --control.resume=true. También si aún no subiste tu conjunto de datos, agrega --control.local_files_only=true. Necesitarás eliminar manualmente el directorio del conjunto de datos si quieres empezar a grabar desde cero.

  • Una vez que te sientas cómodo con la grabación de datos, puedes crear un conjunto de datos más grande para el entrenamiento. Una buena tarea inicial es agarrar un objeto en diferentes ubicaciones y colocarlo en un contenedor. Sugerimos grabar al menos 50 episodios, con 10 episodios por ubicación. Mantén las cámaras fijas y conserva un comportamiento de agarre consistente durante todas las grabaciones. También asegúrate de que el objeto que estás manipulando sea visible en las cámaras. Una buena regla general es que deberías poder realizar la tarea tú mismo solo mirando las imágenes de la cámara.

  • En las siguientes secciones, entrenarás tu red neuronal. Después de lograr un rendimiento de agarre confiable, puedes comenzar a introducir más variaciones durante la recolección de datos, como ubicaciones de agarre adicionales, diferentes técnicas de agarre y alteración de las posiciones de la cámara.

  • Evita agregar demasiada variación muy rápidamente, ya que puede obstaculizar tus resultados.

  • En Linux, si las teclas de flecha izquierda y derecha y la tecla escape no tienen ningún efecto durante la grabación de datos, asegúrate de haber configurado la variable de entorno $DISPLAY. Ver limitaciones de pynput.

Visualizar el conjunto de datos​

tip

Los códigos SO100 y SO101 son compatibles. Los usuarios de SO100 pueden utilizar directamente los parámetros y código de SO101 para la operación.

echo ${HF_USER}/so101_test

Si no subiste con --control.push_to_hub=false, también puedes visualizarlo localmente con:

python lerobot/scripts/visualize_dataset_html.py \
  --repo-id ${HF_USER}/so101_test \

Si subes con --control.push_to_hub=false, también puedes visualizarlo localmente con:

python lerobot/scripts/visualize_dataset_html.py \
  --repo-id seeed_123/so101_test \

Aquí, seeed_123 es el nombre personalizado de repo_id definido al recopilar datos.

Reproducir un episodio​

tip

Los códigos SO100 y SO101 son compatibles. Los usuarios de SO100 pueden utilizar directamente los parámetros y código de SO101 para la operación.

Ahora intenta reproducir el primer episodio en tu robot:

python lerobot/scripts/control_robot.py \
  --robot.type=so101 \
  --control.type=replay \
  --control.fps=30 \
  --control.repo_id=${HF_USER}/so101_test \
  --control.episode=0

Nota: Si aún no has subido tu conjunto de datos, agrega --control.local_files_only=true .

Entrenar una política​

tip

Los códigos SO100 y SO101 son compatibles. Los usuarios de SO100 pueden utilizar directamente los parámetros y código de SO101 para la operación.

Para entrenar una política para controlar tu robot, usa el script python lerobot/scripts/train.py. Se requieren algunos argumentos. Aquí hay un comando de ejemplo:

python lerobot/scripts/train.py \
  --dataset.repo_id=${HF_USER}/so101_test \
  --policy.type=act \
  --output_dir=outputs/train/act_so101_test \
  --job_name=act_so101_test \
  --policy.device=cuda \
  --wandb.enable=true

Si quieres entrenar en un conjunto de datos local, asegúrate de que el repo_id coincida con el usado durante la recolección de datos.

Vamos a explicarlo:

  1. Proporcionamos el conjunto de datos como argumento con --dataset.repo_id=${HF_USER}/so101_test.
  2. Proporcionamos la política usando policy.type=act, que cargará la configuración desde lerobot/lerobot/common/policies/act/configuration_act.py. Actualmente, ACT ha sido probado, pero también puedes probar otras políticas como diffusion, pi0, pi0fast, tdmpc y vqbet.
  3. Proporcionamos policy.device=cuda ya que estamos entrenando en una GPU Nvidia, pero podrías usar policy.device=mps para entrenar en silicio de Apple.
  4. Proporcionamos wandb.enable=true para usar Weights and Biases para visualizar gráficos de entrenamiento. Esto es opcional pero si lo usas, asegúrate de estar conectado ejecutando wandb login.

El entrenamiento debería tomar varias horas. Encontrarás puntos de control en outputs/train/act_so100_test/checkpoints.

Para reanudar el entrenamiento desde un punto de control, a continuación hay un comando de ejemplo para reanudar desde el último punto de control de la política act_so101_test:

python lerobot/scripts/train.py \
  --config_path=outputs/train/act_so101_test/checkpoints/last/pretrained_model/train_config.json \
  --resume=true

Subir puntos de control de política Una vez que el entrenamiento esté terminado, sube el último punto de control con:

huggingface-cli upload ${HF_USER}/act_so101_test \
  outputs/train/act_so101_test/checkpoints/last/pretrained_model

Evaluar tu política​

tip

Los códigos SO100 y SO101 son compatibles. Los usuarios de SO100 pueden utilizar directamente los parámetros y código de SO101 para la operación.

Puedes usar la función record de lerobot/scripts/control_robot.py pero con un punto de control de política como entrada. Por ejemplo, ejecuta este comando para grabar 10 episodios de evaluación:

python lerobot/scripts/control_robot.py \
  --robot.type=so101 \
  --control.type=record \
  --control.fps=30 \
  --control.single_task="Grasp a lego block and put it in the bin." \
  --control.repo_id=${HF_USER}/eval_act_so101_test \
  --control.tags='["tutorial"]' \
  --control.warmup_time_s=5 \
  --control.episode_time_s=30 \
  --control.reset_time_s=30 \
  --control.num_episodes=10 \
  --control.push_to_hub=true \
  --control.policy.path=outputs/train/act_so101_test/checkpoints/last/pretrained_model

Como puedes ver, es casi el mismo comando que se usó anteriormente para grabar tu conjunto de datos de entrenamiento. Dos cosas cambiaron:

  1. Hay un argumento adicional --control.policy.path que indica la ruta a tu punto de control de política con (ej. outputs/train/eval_act_so100_test/checkpoints/last/pretrained_model). También puedes usar el repositorio del modelo si subiste un punto de control del modelo al hub (ej. ${HF_USER}/act_so100_test).
  2. El nombre del conjunto de datos comienza por eval para reflejar que estás ejecutando inferencia (ej. ${HF_USER}/eval_act_so100_test).

FAQ​

  • Si estás siguiendo esta documentación/tutorial, por favor clona el repositorio de GitHub recomendado https://github.com/ZhuYaoHui1998/lerobot.git. El repositorio recomendado en esta documentación es una versión estable verificada; el repositorio oficial de Lerobot se actualiza continuamente a la última versión, lo que puede causar problemas imprevistos como diferentes versiones de conjuntos de datos, diferentes comandos, etc.

  • Si encuentras el siguiente error, necesitas verificar si el brazo robótico conectado al puerto correspondiente está encendido y si los servos del bus tienen cables sueltos o desconectados.

    ConnectionError: Read failed due to comunication eror on port /dev/ttyACM0 for group key Present_Position_Shoulder_pan_Shoulder_lift_elbow_flex_wrist_flex_wrist_roll_griper: [TxRxResult] There is no status packet!

  • Si has reparado o reemplazado cualquier parte del brazo robótico, por favor elimina completamente la carpeta ~/lerobot/.cache/huggingface/calibration/so100 y recalibra el brazo robótico.

  • Si el control remoto funciona normalmente pero el control remoto con cámara no logra mostrar la interfaz de imagen, puedes encontrar aquí

  • Si encuentras problemas con libtiff durante la operación remota del conjunto de datos, por favor actualiza la versión de libtiff.

    conda install libtiff==4.5.0  #for Ubuntu 22.04 is libtiff==4.5.1

  • Después de ejecutar la Instalación de Lerobot, la versión GPU de pytorch puede desinstalarse automáticamente, por lo que necesitas instalar manualmente torch-gpu.

  • Para Jetson, por favor instala primero Pytorch y Torchvsion antes de ejecutar conda install -y -c conda-forge ffmpeg, de lo contrario, al compilar torchvision, puede ocurrir un problema de incompatibilidad de versión de ffmpeg.

  • Si ocurre el siguiente problema, significa que tu computadora no soporta este formato de códec de video. Necesitas modificar la línea 134 en el archivo lerobot/lerobot/common/datasets/video_utils.py cambiando el valor de vcodec: str = "libsvtav1" a libx264 o libopenh264. Diferentes computadoras pueden requerir diferentes parámetros, por lo que puedes probar varias opciones. Issues 705

    [vost#0:0 @ 0x13207240] Unknown encoder 'libsvtav1' [vost#0:0 @ 0x13207240] Error selecting an encoder Error opening output file /home/han/.cache/huggingface/lerobot/lyhhan/so100_test/videos/chunk-000/observation.images.laptop/episode_000000.mp4. Error opening output files: Encoder not found

  • ¡¡¡Importante!!! Si durante la ejecución el cable del servo se afloja, por favor restaura el servo a su posición inicial y luego reconecta el cable del servo. También puedes calibrar individualmente un servo usando el Comando de Inicialización del Servo, asegurándote de que solo un cable esté conectado entre el servo y la placa del controlador durante la calibración individual. Si encuentras

    Auto-correct calibration of motor 'wrist roll' by shifting value by 1 full turns, from '-270 < -312.451171875 < 270degrees' to'-270<-312.451171875 < 270 degrees'.

    u otros errores durante el proceso de calibración del brazo robótico relacionados con ángulos y valores que exceden los límites, este método sigue siendo aplicable.

  • Entrenar 50 conjuntos de datos ACT en una laptop 8G 3060 toma aproximadamente 6 horas, mientras que en una computadora 4090 o A100, entrenar 50 conjuntos de datos toma alrededor de 2–3 horas.

  • Durante la recolección de datos, asegúrese de que la posición, ángulo e iluminación ambiental de la cámara permanezcan estables, y minimice la captura de fondos inestables excesivos y peatones; de lo contrario, cambios ambientales significativos durante el despliegue pueden causar que el brazo robótico falle al agarrar correctamente.

  • Asegúrese de que el parámetro num-episodes en el comando de recolección de datos esté configurado para recopilar datos suficientes, y no pause manualmente a la mitad. Esto se debe a que la media y varianza de los datos se calculan solo después de que se complete la recolección de datos, lo cual es necesario para el entrenamiento.

  • Si el programa indica que no puede leer los datos de imagen de la cámara USB, asegúrese de que la cámara USB no esté conectada a un hub. La cámara USB debe estar conectada directamente al dispositivo para garantizar una velocidad de transmisión de imagen rápida.

tip

Si encuentra problemas de software o problemas de dependencias del entorno que no se pueden resolver, además de verificar la sección de FAQ al final de este tutorial, por favor reporte el problema oportunamente a la plataforma LeRobot o al canal Discord de LeRobot.

Citas​

中文文档

Proyecto TheRobotStudio: SO-ARM10x

Proyecto Huggingface: Lerobot

Dnsty: Jetson Containers

Jetson AI Lab

Diffusion Policy

ACT or ALOHA

TDMPC

VQ-BeT

Soporte Técnico y Discusión de Productos​

¡Gracias por elegir nuestros productos! Estamos aquí para brindarle diferentes tipos de soporte para asegurar que su experiencia con nuestros productos sea lo más fluida posible. Ofrecemos varios canales de comunicación para satisfacer diferentes preferencias y necesidades.

Loading Comments...