Skip to main content

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

tip

El mantenimiento de este tutorial ha sido actualizado a la última versión de lerobot, si quieres consultar el tutorial de la versión anterior, por favor haz clic aquí.

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 que presentan 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 framework 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 recolección de datos y entrenamiento dentro del framework 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 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, recolecció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 robóticas eficientes y precisas en varias tareas complejas.

Qué hay de nuevo：​

  • 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 Leader, y la fuente de alimentación de 12V para la calibración y cada paso del brazo robótico Follower.

Lista de Materiales (BOM)​

ParteCantidadIncluido
Servomotores12✅
Placa de Control de Motor2✅
Cable USB-C 2 piezas1✅
Fuente de Alimentación22✅
Abrazadera de Mesa4✅
Piezas 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.0 y 6.1, no soporta 6.1
  • Python 3.10
  • Torch 2.3+

Tabla de Contenidos​

A. Guía de Impresión 3D

B. Instalar LeRobot

C. Configurar los motores

D. Ensamblaje

E. Calibrar

F. Teleoperar

G. Añadir 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 los 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 motores 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úrate de que la impresora esté calibrada y el nivel de la cama esté correctamente configurado usando las instrucciones específicas de la impresora.
  • Limpia la cama de impresión, asegurándote de que esté libre de polvo o grasa. Si limpias la cama usando agua u otro líquido, seca la cama.
  • Si tu impresora lo recomienda, usa una barra de pegamento estándar y aplica una capa delgada y uniforme de pegamento en el área de impresión de la cama. Evita aglomeraciones o aplicación desigual.
  • Carga el filamento de la impresora usando las instrucciones específicas de la impresora.
  • Asegúrate de que las configuraciones de la impresora coincidan con las sugeridas arriba (la mayoría de las impresoras tienen múltiples configuraciones, así que elige las que más se acerquen).
  • Configura para soportes en todas partes pero ignora pendientes mayores a 45 grados respecto a la horizontal.
  • No debería 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 fácil impresión 3D 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), imprime estos archivos:

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

Instalar LeRobot​

Los entornos como pytorch y torchvision necesitan ser instalados basándose en tu 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. Create and activate a fresh conda environment for lerobot
conda create -y -n lerobot python=3.10 && conda activate lerobot
  1. Clona Lerobot:
git clone https://github.com/Seeed-Projects/lerobot.git ~/lerobot
  1. Cuando uses miniconda, instala ffmpeg en tu entorno:
conda install ffmpeg -c conda-forge
tip

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

  • [En cualquier plataforma] Instalar explícitamente ffmpeg 7.X usando:
conda install ffmpeg=7.1.1 -c conda-forge
  • [Solo en Linux] Instala las dependencias de compilación de ffmpeg y compila ffmpeg desde el código fuente con libsvtav1, y asegúrate de usar el binario de ffmpeg correspondiente a tu instalación con which ffmpeg.

Si encuentras un error como este, también puedes usar este comando.

  1. Instala LeRobot con dependencias para los motores feetech:
cd ~/lerobot && pip install -e ".[feetech]"

Para dispositivos Jetson Jetpack 6.0+ (por favor asegúrate 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 a través de pip desinstalará el Pytorch y Torchvision originales e instalará las versiones CPU de Pytorch y Torchvision, necesitas realizar una verificación en Python.

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

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

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

Configurar los motores​

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

Para configurar los motores, designa un adaptador de servo de bus y 6 motores para tu 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 engranaje son los siguientes:

Modelo de ServoRelación de EngranajeArticulaciones 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 debes conectar la fuente de alimentación de 5V o 12V al bus del motor. 5V para los motores STS3215 de 7.4V y 12V para los motores STS3215 de 12V. Ten en cuenta que el brazo líder siempre usa los motores de 7.4V, así que asegúrate de conectar la fuente de alimentación correcta si tienes motores de 12V y 7.4V, ¡de lo contrario podrías quemar tus motores! Ahora, conecta el bus del motor a tu computadora vía USB. Ten en cuenta que el USB no proporciona energía, y tanto la fuente de alimentación como el USB deben estar conectados.

Los siguientes son los pasos de calibración del código, por favor calibra con el servo de cableado de referencia en la imagen de arriba

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

python -m lerobot.find_port

Ejemplo de salida:

Finding all available ports for the MotorBus.
['/dev/ttyACM0', '/dev/ttyACM1']
Remove the usb cable from your MotorsBus and press Enter when done.

[...Disconnect corresponding leader or follower arm and press Enter...]

The port of this MotorsBus is /dev/ttyACM1
Reconnect the USB cable.
tip

Recuerda quitar el USB, de lo contrario la interfaz no será detectada.

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

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

Es posible que necesites dar acceso a los puertos USB ejecutando:

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

Configura tus motores

danger

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

Calibración Articulación 6 Brazo LeaderCalibración Articulación 5 Brazo LeaderCalibración Articulación 4 Brazo LeaderCalibración Articulación 3 Brazo LeaderCalibración Articulación 2 Brazo LeaderCalibración Articulación 1 Brazo Leader
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
tip

Nuevamente, por favor asegúrate de que los IDs de las articulaciones del servo y las relaciones de engranajes correspondan estrictamente a los del SO-ARM101.

Conecta el cable USB desde tu computadora y la fuente de alimentación a la placa controladora del brazo seguidor. Luego, ejecuta el siguiente comando.

python -m lerobot.setup_motors \
    --robot.type=so101_follower \
    --robot.port=/dev/ttyACM0  # <- paste here the port found at previous step

Deberías ver la siguiente instrucción.

Connect the controller board to the 'gripper' motor only and press enter.

Como se indica, conecta el motor de la pinza. Asegúrate de que sea el único motor conectado a la placa, y que el motor en sí no esté aún conectado en cadena a ningún otro motor. Al presionar [Enter], el script establecerá automáticamente el id y la velocidad de baudios para ese motor.

Entonces deberías ver el siguiente mensaje:

'gripper' motor id set to 6

Seguido de la siguiente instrucción:

Connect the controller board to the 'wrist_roll' motor only and press enter.

Puedes desconectar el cable de 3 pines de la placa controladora, pero puedes dejarlo conectado al motor de la pinza en el otro extremo, ya que ya estará en el lugar correcto. Ahora, conecta otro cable de 3 pines al motor de giro de la muñeca y conéctalo a la placa controladora. Al igual que con el motor anterior, asegúrate de que sea el único motor conectado a la placa y que el motor en sí no esté conectado a ningún otro.

caution

Repite la operación para cada motor según las instrucciones.

Verifica tu cableado en cada paso antes de presionar Enter. Por ejemplo, el cable de alimentación podría desconectarse mientras manipulas la placa.

Cuando hayas terminado, el script simplemente finalizará, momento en el cual los motores estarán listos para ser utilizados. Ahora puedes conectar el cable de 3 pines de cada motor al siguiente, y el cable del primer motor (el 'giro del hombro' con id=1) a la placa controladora, que ahora puede ser fijada a la base del brazo.

Realiza los mismos pasos para el brazo líder.

python -m lerobot.setup_motors \
    --teleop.type=so101_leader \
    --teleop.port=/dev/ttyACM0  # <- paste here the port found at previous step

Ensamblaje​

tip
  • El proceso de ensamblaje de doble brazo del SO-ARM101 es el mismo que el del SO-ARM100. Las únicas diferencias son la adición de clips para cables en el SO-ARM101 y las diferentes relaciones de engranajes de los servos de las articulaciones en el Brazo Líder. Por lo tanto, tanto el SO100 como el SO101 se pueden instalar siguiendo el siguiente contenido
  • Antes del ensamblaje, por favor verifique nuevamente el modelo de su motor y la relación de reducción. Si ha comprado el SO100, puede ignorar este paso. Si ha comprado el SO101, por favor verifique 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 compró el SO101 Arm Kit Edición Estándar, todas las fuentes de alimentación son de 5V. Si compró el SO101 Arm Kit Edición Pro, 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 los archivos bajo ~/.cache/huggingface/lerobot/calibration/robots o ~/.cache/huggingface/lerobot/calibration/teleoperators y recalibra el brazo robótico. De lo contrario, aparecerá un mensaje de error. La información de calibración para el brazo robótico se almacenará en los archivos JSON bajo este directorio.

Calibración manual del brazo seguidor

Por favor conecta las interfaces de los 6 servos del robot mediante un cable de 3 pines y conecta el servo del chasis a la placa de control de servos, luego ejecuta el siguiente comando o ejemplo de API para calibrar el brazo robótico:

Los permisos de interfaz se otorgan primero

sudo chmod 666 /dev/ttyACM*

Luego calibra el brazo seguidor

python -m lerobot.calibrate \
    --robot.type=so101_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=my_awesome_follower_arm

El video a continuación muestra cómo realizar la calibración. Primero necesitas mover el robot a la posición donde todas las articulaciones estén en el medio de sus rangos. Luego, después de presionar enter, tienes que mover cada articulación a través de su rango completo de movimiento.

Calibración manual del brazo líder

Realiza los mismos pasos para calibrar el brazo líder, ejecuta el siguiente comando o ejemplo de API:

python -m lerobot.calibrate \
    --teleop.type=so101_leader \
    --teleop.port=/dev/ttyACM0 \
    --teleop.id=my_awesome_leader_arm

Teleoperar​

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

Ten en cuenta que el id asociado con un robot se usa para almacenar el archivo de calibración. Es importante usar el mismo id al teleoperar, grabar y evaluar cuando uses la misma configuración.

sudo chmod 666 /dev/ttyACM*
python -m lerobot.teleoperate \
    --robot.type=so101_follower \
    --robot.port=/dev/ttyACM1 \
    --robot.id=my_awesome_follower_arm \
    --teleop.type=so101_leader \
    --teleop.port=/dev/ttyACM0 \
    --teleop.id=my_awesome_leader_arm

El comando teleoperate automáticamente:

  1. Identificará cualquier calibración faltante e iniciará el procedimiento de calibración.
  2. Conectará el robot y el dispositivo de teleoperación e iniciará la teleoperación.

Añadir 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.

Para instanciar una cámara, necesitas un identificador de cámara. Este identificador podría cambiar si reinicias tu computadora o reconectas tu cámara, un comportamiento que depende principalmente de tu sistema operativo.

Para encontrar los índices de cámara de las cámaras conectadas a tu sistema, ejecuta el siguiente script:

python -m lerobot.find_cameras opencv # or realsense for Intel Realsense cameras

La terminal imprimirá la siguiente información.

--- Detected Cameras ---
Camera #0:
  Name: OpenCV Camera @ 0
  Type: OpenCV
  Id: 0
  Backend api: AVFOUNDATION
  Default stream profile:
    Format: 16.0
    Width: 1920
    Height: 1080
    Fps: 15.0
--------------------
(more cameras ...)

Puedes encontrar las imágenes tomadas por cada cámara en el directorio outputs/captured_images.

warning

Al usar cámaras Intel RealSense en , podrías obtener este error: , esto se puede resolver ejecutando el mismo comando con permisos. Ten en cuenta que usar cámaras RealSense en es inestable.macOSError finding RealSense cameras: failed to set power statesudomacOS.

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 -m lerobot.teleoperate \
    --robot.type=so101_follower \
    --robot.port=/dev/ttyACM1 \
    --robot.id=my_awesome_follower_arm \
    --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30}}" \
    --teleop.type=so101_leader \
    --teleop.port=/dev/ttyACM0 \
    --teleop.id=my_awesome_leader_arm \
    --display_data=true

Si tienes más cámaras, puedes cambiar --robot.cameras para añadir cámaras. Debes tener en cuenta el formato del index_or_path, que está determinado por el último dígito del ID de la cámara que muestra python -m lerobot.find_cameras opencv.

Por ejemplo, quieres añadir una cámara lateral:

python -m lerobot.teleoperate \
    --robot.type=so101_follower \
    --robot.port=/dev/ttyACM1 \
    --robot.id=my_awesome_follower_arm \
    --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30}, side: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30}}" \
    --teleop.type=so101_leader \
    --teleop.port=/dev/ttyACM0 \
    --teleop.id=my_awesome_leader_arm \
    --display_data=true
tip

Si encuentras un error como este.

Puedes degradar la versión de rerun para resolver el problema.

pip3 install rerun-sdk==0.23

Grabar el conjunto de datos​

  • Si deseas guardar el conjunto de datos localmente, puedes ejecutarlo directamente:
python -m lerobot.record \
    --robot.type=so101_follower \
    --robot.port=/dev/ttyACM1 \
    --robot.id=my_awesome_follower_arm \
    --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30}, side: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30}}" \
    --teleop.type=so101_leader \
    --teleop.port=/dev/ttyACM0 \
    --teleop.id=my_awesome_leader_arm \
    --display_data=true \
    --dataset.repo_id=seeedstudio123/test \
    --dataset.num_episodes=5 \
    --dataset.single_task="Grab the black cube" \
    --dataset.push_to_hub=false \
    --dataset.episode_time_s=30 \
    --dataset.reset_time_s=30

Entre ellos, repo_id se puede modificar de forma personalizada, y push_to_hub=false. Finalmente, el conjunto de datos se guardará en el directorio ~/.cache/huggingface/lerobot en la carpeta de inicio, donde se creará la carpeta seeedstudio123/test mencionada anteriormente.

  • 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 5 episodios y sube tu conjunto de datos al hub:

python -m lerobot.record \
    --robot.type=so101_follower \
    --robot.port=/dev/ttyACM1 \
    --robot.id=my_awesome_follower_arm \
    --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30}, side: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30}}" \
    --teleop.type=so101_leader \
    --teleop.port=/dev/ttyACM0 \
    --teleop.id=my_awesome_leader_arm \
    --display_data=true \
    --dataset.repo_id=${HF_USER}/record-test \
    --dataset.num_episodes=5 \
    --dataset.single_task="Grab the black cube" \
    --dataset.push_to_hub=true \
    --dataset.episode_time_s=30 \
    --dataset.reset_time_s=30

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

  • 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 HuggingFace Hub.
tip

  • "Si quieres guardar los datos localmente (--dataset.push_to_hub=false), reemplaza --dataset.repo_id=${HF_USER}/so101_test con un nombre de carpeta local personalizado, como --dataset.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 --dataset.push_to_hub=true, puedes visualizar tu conjunto de datos en línea copiando y pegando tu repo id 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 a la siguiente grabación de episodio.

  • Presiona la flecha izquierda ← en cualquier momento durante la grabación del episodio o 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: Los puntos de control se crean automáticamente durante la grabación. Si ocurre un problema, puedes reanudar ejecutando nuevamente el mismo comando con --resume=true. Para comenzar a grabar desde cero, elimina manualmente el directorio del conjunto de datos.

  • Una vez que te sientas cómodo con la grabación de datos, puedes crear un conjunto de datos más grande para 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 mantén un comportamiento de agarre consistente durante 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 hacer 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 recopilación de datos, como ubicaciones de agarre adicionales, diferentes técnicas de agarre, y alterar las posiciones de la cámara.

  • Evita añadir 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 --dataset.push_to_hub=false, también puedes visualizarlo localmente con:

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

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

python -m lerobot.scripts.visualize_dataset_html \
  --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 -m lerobot.replay \
    --robot.type=so101_follower \
    --robot.port=/dev/ttyACM1 \
    --robot.id=my_awesome_follower_arm \
    --dataset.repo_id=${HF_USER}/record-test \
    --dataset.episode=0

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 -m lerobot.scripts.train. Se requieren algunos argumentos. Aquí tienes un comando de ejemplo:

python -m lerobot.scripts.train \
  --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=false \
  --steps=300000

Si quieres entrenar en un conjunto de datos local, asegúrate de que el repo_id coincida con el utilizado durante la recolección de datos y añade --policy.push_to_hub=False.

python -m lerobot.scripts.train \
  --dataset.repo_id=seeedstudio123/test \
  --policy.type=act \
  --output_dir=outputs/train/act_so101_test \
  --job_name=act_so101_test \
  --policy.device=cuda \
  --wandb.enable=false \
  --policy.push_to_hub=false\
  --steps=300000

Vamos a explicarlo:

  • Especificación del dataset: Proporcionamos el dataset a través del parámetro --dataset.repo_id=${HF_USER}/so101_test.
  • Pasos de entrenamiento: Modificamos el número de pasos de entrenamiento usando --steps=300000. El algoritmo por defecto usa 800000 pasos, y puedes ajustarlo basándote en la dificultad de tu tarea y observando la pérdida durante el entrenamiento.
  • Tipo de política: Proporcionamos la política con policy.type=act. De manera similar, puedes cambiar entre políticas como [act, diffusion, pi0, pi0fast, pi0fast, sac, smolvla]., lo cual cargará la configuración desde configuration_act.py. Importante, esta política se adaptará automáticamente a los estados del motor de tu robot (ej., laptop y phone), acciones del motor, y el número de cámaras, ya que esta información ya está almacenada en tu dataset.
  • Selección de dispositivo: Proporcionamos policy.device=cuda porque estamos entrenando en una GPU Nvidia, pero puedes usar policy.device=mps para entrenar en Apple Silicon.
  • Herramienta de visualización: Proporcionamos wandb.enable=true para visualizar gráficos de entrenamiento usando Weights and Biases. Esto es opcional, pero si lo usas, asegúrate de haber iniciado sesión ejecutando wandb login.

Si encuentras el siguiente error:

Intenta ejecutar el siguiente comando para resolverlo:

pip install datasets==2.19

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 se muestra un comando de ejemplo para reanudar desde el último punto de control de la política act_so101_test:

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

Subir checkpoints de política

Una vez que el entrenamiento haya terminado, sube el último checkpoint con:

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

También puedes subir checkpoints intermedios con:

CKPT=010000
huggingface-cli upload ${HF_USER}/act_so101_test${CKPT} \
  outputs/train/act_so101_test/checkpoints/${CKPT}/pretrained_model

Evalúa 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/record.py pero con un checkpoint de política como entrada. Por ejemplo, ejecuta este comando para grabar 10 episodios de evaluación:

python -m lerobot.record  \
  --robot.type=so100_follower \
  --robot.port=/dev/ttyACM1 \
  --robot.cameras="{ up: {type: opencv, index_or_path: /dev/video10, width: 640, height: 480, fps: 30}, side: {type: intelrealsense, serial_number_or_name: 233522074606, width: 640, height: 480, fps: 30}}" \
  --robot.id=my_awesome_follower_arm \
  --display_data=false \
  --dataset.repo_id=${HF_USER}/eval_so100 \
  --dataset.single_task="Put lego brick into the transparent box" \
  --policy.path=${HF_USER}/my_policy

como por ejemplo:

python -m lerobot.record  \
  --robot.type=so101_follower \
  --robot.port=/dev/ttyACM1 \
  --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30},   side: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30}}" \
  --robot.id=my_awesome_follower_arm \
  --display_data=false \
  --dataset.repo_id=seeed/eval_test123 \
  --dataset.single_task="Put lego brick into the transparent box" \
  --policy.path=outputs/train/act_so101_test/checkpoints/last/pretrained_model

  1. El parámetro --policy.path indica la ruta al archivo de pesos de los resultados de entrenamiento de tu política (por ejemplo, outputs/train/act_so101_test/checkpoints/last/pretrained_model). Si subes el archivo de pesos del resultado del entrenamiento del modelo a Hub, también puedes usar el repositorio del modelo (por ejemplo, ${HF_USER}/act_so100_test).

  2. El nombre del conjunto de datos dataset.repo_id comienza con eval_. Esta operación registrará por separado videos y datos durante la evaluación, que se guardarán en la carpeta que comience con eval_, como seeed/eval_test123.

  3. Si encuentras File exists: 'home/xxxx/.cache/huggingface/lerobot/xxxxx/seeed/eval_xxxx' durante la fase de evaluación, por favor elimina primero la carpeta que comience con eval_ y luego ejecuta el programa nuevamente.

  4. Cuando encuentres mean is infinity. You should either initialize with stats as an argument or use a pretrained model, ten en cuenta que las palabras clave como front y side en el parámetro --robot.cameras deben ser estrictamente consistentes con las utilizadas al recopilar el conjunto de datos.

FAQ​

  • Si estás siguiendo esta documentación/tutorial, por favor haz git clone del repositorio de GitHub recomendado https://github.com/Seeed-Projects/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 versión más reciente, lo que puede causar problemas imprevistos como diferentes versiones de conjuntos de datos, diferentes comandos, etc.

  • Si encuentras el siguiente error al calibrar los IDs de los servos:

    `Motor ‘gripper’ was not found, Make sure it is connected`

    Por favor, verifique cuidadosamente si el cable de comunicación está conectado correctamente al servo y si la fuente de alimentación está proporcionando el voltaje correcto.

  • Si encuentra:

    Could not connect on port "/dev/ttyACM0"

    Y puedes ver que ACM0 existe cuando ejecutas ls /dev/ttyACM*, significa que olvidaste otorgar permisos al puerto serie. Ingresa sudo chmod 666 /dev/ttyACM* en la terminal para solucionarlo.

  • Si encuentras:

    No valid stream found in input file. Is -1 of the desired media type?

    Por favor instala ffmpeg 7.1.1 usando conda install ffmpeg=7.1.1 -c conda-forge.

  • Si encuentras:

    ConnectionError: Failed to sync read 'Present_Position' on ids=[1,2,3,4,5,6] after 1 tries. [TxRxResult] There is no status packet!

    Necesitas verificar si el brazo robótico en el puerto correspondiente está encendido, y si los cables de datos de los servos del bus están sueltos o desconectados. Si la luz de un servo no está encendida, significa que el cable del servo anterior está suelto.

  • Si encuentras el siguiente error al calibrar el brazo robótico:

    Magnitude 30841 exceeds 2047 (max for sign_bit_index=11)

    Apaga y reinicia el brazo robótico, luego intenta calibrar nuevamente. Este método también se puede usar si el ángulo MAX alcanza un valor de decenas de miles durante la calibración. Si esto no funciona, necesitas recalibrar los servos correspondientes, incluyendo la calibración mediana y la escritura de ID.

  • Si encuentras durante la fase de evaluación:

    File exists: 'home/xxxx/.cache/huggingface/lerobot/xxxxx/seeed/eval_xxxx'

    Por favor, elimina primero la carpeta que comienza con eval_ y luego ejecuta el programa nuevamente.

  • Si encuentras durante la fase de evaluación:

    `mean` is infinity. You should either initialize with `stats` as an argument or use a pretrained model

    Tenga en cuenta que las palabras clave como "front" y "side" en el parámetro --robot.cameras deben ser estrictamente consistentes con las utilizadas al recopilar el conjunto de datos.

  • Si ha reparado o reemplazado partes del brazo robótico, elimine completamente los archivos bajo ~/.cache/huggingface/lerobot/calibration/robots o ~/.cache/huggingface/lerobot/calibration/teleoperators y recalibre el brazo robótico. De lo contrario, pueden aparecer mensajes de error, ya que la información de calibración se almacena en archivos JSON en estos directorios.

  • Entrenar ACT con 50 conjuntos de datos toma aproximadamente 6 horas en una laptop con RTX 3060 (8GB), y alrededor de 2-3 horas en computadoras con GPUs RTX 4090 o A100.

  • Durante la recopilación de datos, asegúrese de que la posición de la cámara, el ángulo y la iluminación ambiental sean estables. Reduzca la cantidad de fondo inestable y peatones capturados por la cámara, ya que cambios excesivos en el entorno de despliegue pueden causar que el brazo robótico falle al agarrar correctamente.

  • Para el comando de recopilación de datos, asegúrese de que el parámetro num-episodes esté configurado para recopilar datos suficientes. No pause manualmente a la mitad, ya que la media y la varianza de los datos se calculan solo después de que se complete la recopilación de datos, las cuales son necesarias para el entrenamiento.

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

  • Si encuentra un error como AttributeError: module 'rerun' has no attribute 'scalar'. Did you mean: 'scalars'?, puede degradar la versión de rerun para resolver el problema.

pip3 install rerun-sdk==0.23
tip

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

Cita​

中文文档

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 brindarte diferentes tipos de soporte para asegurar que tu experiencia con nuestros productos sea lo más fluida posible. Ofrecemos varios canales de comunicación para satisfacer diferentes preferencias y necesidades.

Loading Comments...