Saltar al contenido principal

Introducción a reBot Arm B601-DM basado en LeRobot y reBot 102 Leader

Consigue uno ahora 🖱️

License: MITPython VersionPlatformPinocchio

Brazo robótico de 6 GDL · Soporte multi-motor · Solucionador de cinemática · Planificación de trayectoria · Totalmente de código abierto

reBot Arm B601-DM es un proyecto de brazo robótico de código abierto lanzado por Seeed, dedicado a reducir el umbral para aprender inteligencia encarnada. Abrimos por completo todos los diseños estructurales y el código, haciendo que la tecnología robótica sea accesible para todos.

LeRobot se compromete a proporcionar modelos, conjuntos de datos y herramientas para robótica en el mundo real en PyTorch. Su objetivo es reducir la barrera de entrada a la robótica, permitiendo que todos contribuyan y se beneficien compartiendo conjuntos de datos y modelos preentrenados. LeRobot integra metodologías de vanguardia validadas para aplicaciones en el mundo real, centrándose en el aprendizaje por imitación y el aprendizaje por refuerzo. Ha proporcionado un conjunto de modelos preentrenados, conjuntos de datos con demostraciones recopiladas por humanos y entornos de simulación, lo que permite a los usuarios comenzar sin necesidad de ensamblar robots.

Star on GitHub4.2K

Este wiki proporciona tutoriales de depuración para reBot-DevArm e implementa la recopilación de datos y el entrenamiento dentro del framework LeRobot.

precaución

Los tutoriales de Seeed Studio se actualizan estrictamente de acuerdo con la documentación oficial. Si encuentras problemas de software o de entorno que no se puedan resolver, primero consulta las FAQ al final del artículo, o contacta con atención al cliente para unirte al grupo de discusión de SeeedStudio LeRobot. También puedes hacer preguntas aquí: LeRobot GitHub o en el canal de Discord.

Entorno inicial del sistema​

  • Ubuntu 22.04/Ubuntu 24.04
  • GPU NVIDIA con CUDA 12+ (opcional, para entrenamiento e inferencia acelerados por GPU)
  • Python 3.10
  • Torch 2.6 (las compilaciones para CPU pueden ejecutar flujos de trabajo básicos; se requieren compilaciones con CUDA para la aceleración por GPU)

Instalar LeRobot​

LeRobot se puede instalar y ejecutar en máquinas solo con CPU para flujos de trabajo básicos. Si necesitas entrenamiento o inferencia acelerados por GPU, confirma que tu ordenador tiene una GPU NVIDIA y luego instala las versiones de PyTorch y Torchvision que coincidan con tu versión de CUDA.

1

1. Instalar Miniforge​

cd ~
wget "https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-$(uname)-$(uname -m).sh"
bash Miniforge3-$(uname)-$(uname -m).sh

~/miniforge3/bin/conda init bash
source ~/.bashrc
2

2. Clonar el repositorio de LeRobot​

mkdir ~/rebot_lerobot
cd ~/rebot_lerobot
git clone https://github.com/Seeed-Projects/lerobot.git
3

3. Crear un entorno Conda e instalar LeRobot​

tip

Para las funciones detalladas de los paquetes de funciones, consulta:

El repositorio lerobot ya tiene un pyproject.toml. Crea un entorno conda e instala todas las dependencias.

cd ~/rebot_lerobot

# Create conda environment (Python 3.12)
conda create -y -n lerobot python=3.12

# Activate environment
conda activate lerobot

# Install lerobot main project (editable mode)
pip install -e ./lerobot

# Add dependency packages
pip install lerobot-teleoperator-rebot-arm-102
pip install lerobot-robot-seeed-b601
pip install motorbridge
4

4. Instalar dependencias de vídeo​

ffmpeg es una dependencia de decodificación de vídeo, instálala mediante conda:

conda install ffmpeg -c conda-forge
tip

Notas de versión:

  • De forma predeterminada, se instalará ffmpeg 7.X (compatible con el codificador libsvtav1)

  • Si encuentras problemas de compatibilidad de versión, puedes especificar ffmpeg 7.1.1:

    conda install ffmpeg=7.1.1 -c conda-forge

  • Puedes comprobar si el codificador libsvtav1 es compatible mediante ffmpeg -encoders | grep svtav1

Ubuntu x86 no requiere ninguna otra configuración de dependencias de vídeo. Continúa con el paso 5.

5

5. Comprobar PyTorch y Torchvision​

Instalar el entorno LeRobot con pip puede reemplazar los PyTorch y Torchvision originales por compilaciones para CPU, así que comprueba el resultado en Python.

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

Si la salida es False, el entorno actual está usando la versión de PyTorch para CPU. Esto es lo esperado en ordenadores sin GPU NVIDIA, y puedes continuar con flujos de trabajo básicos basados en CPU, aunque el entrenamiento será mucho más lento. Si tu ordenador tiene una GPU NVIDIA y necesitas aceleración por GPU, instala las versiones de PyTorch y Torchvision que coincidan con tu versión de CUDA desde la guía oficial de PyTorch. En ese caso, la comprobación final debería devolver True.

tip

Si estás usando un dispositivo Jetson, instala PyTorch y Torchvision con soporte para GPU según este tutorial.

Las GPU NVIDIA RTX serie 50 requieren la versión preliminar de PyTorch con CUDA 12.8 o posterior:

pip install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/cu128

Calibrar el brazo robótico​

A continuación, debes conectar la fuente de alimentación y el cable de datos a tu robot reBot B601-DM para la calibración, a fin de garantizar 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 reBot B601-DM funcione en otro. Si necesitas recalibrar el brazo robótico, elimina por completo los archivos en ~/.cache/huggingface/lerobot/calibration/robots o ~/.cache/huggingface/lerobot/calibration/teleoperators y vuelve a calibrar el brazo robótico. De lo contrario, aparecerá un mensaje de error. La información de calibración del brazo robótico se almacenará en los archivos JSON de este directorio.

Primero, debes otorgar permisos de interfaz ejecutando los siguientes comandos:

sudo chmod 666 /dev/ttyUSB*  # Leader arm
sudo chmod 666 /dev/ttyACM*  # Follower arm (serial bridge)

El B601-DM solo necesita calibrarse una vez después del montaje. Aquí está el comando de calibración. Consulta la figura para ver la posición cero (pinza completamente cerrada).

sudo chmod 666 /dev/ttyACM*  # follower arm (serial bridge)

lerobot-calibrate \
    --robot.type=seeed_b601_dm_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=follower1 \
    --robot.can_adapter=damiao
peligro

Durante la teleoperación, si el brazo robótico maestro-esclavo sufre una desconexión de energía, mal contacto de alimentación o desprendimiento de la línea de señal, primero debes detener el código del programa y devolver el brazo robótico a su posición cero inicial. Solo entonces vuelve a conectar la fuente de alimentación y reinicia el programa. Esto evita que el desorden de datos provoque que el brazo robótico se descontrole y cause posibles riesgos de seguridad.

Teleoperar​

peligro

Durante la teleoperación, si el brazo robótico maestro-esclavo sufre una desconexión de energía, mal contacto de alimentación o desprendimiento de la línea de señal, primero debes detener el código del programa y devolver el brazo robótico a su posición cero inicial. Solo entonces vuelve a conectar la fuente de alimentación y reinicia el programa. Esto evita que el desorden de datos provoque que el brazo robótico se descontrole y cause posibles riesgos de seguridad.

Primero otorga permisos a los puertos serie:

sudo chmod 666 /dev/ttyUSB*  # Leader arm
sudo chmod 666 /dev/ttyACM*  # Follower arm (serial bridge)

Ejecuta la teleoperación:

lerobot-teleoperate \
    --robot.type=seeed_b601_dm_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=follower1 \
    --robot.can_adapter=damiao \
    --teleop.type=rebot_arm_102_leader \
    --teleop.port=/dev/ttyUSB0 \
    --teleop.id=rebot_arm_102_leader

Añadir cámaras​

peligro

Durante la teleoperación, si el brazo robótico maestro-esclavo sufre una desconexión de energía, mal contacto de alimentación o desprendimiento de la línea de señal, primero debes detener el código del programa y devolver el brazo robótico a su posición cero inicial. Solo entonces vuelve a conectar la fuente de alimentación y reinicia el programa. Esto evita que el desorden de datos provoque que el brazo robótico se descontrole y cause posibles riesgos de seguridad.

Las cámaras de profundidad RealSense pueden proporcionar percepción RGB-D para LeRobot y son adecuadas para tareas como reconocimiento de objetos, reconstrucción de nubes de puntos y manipulación sobre mesa. Los modelos recomendados aquí son RealSense D405 y RealSense D435i.

RealSense D405

La RealSense D405 es una cámara estéreo de profundidad de corto alcance diseñada para tareas de alta precisión a corta distancia, como la manipulación robótica sobre mesa, con un rango de trabajo típico de 7 cm a 50 cm.

RealSense D435i

La RealSense D435i combina sensado de profundidad, imagen RGB y una IMU, lo que la hace adecuada para aplicaciones de rango medio a corto como reconstrucción 3D, SLAM y percepción del entorno robótico.

1

Cambiar a la rama de cámara

Paso 1

El soporte actual para cámaras está disponible en la rama DepthCameraSupport:

git checkout DepthCameraSupport
git pull origin DepthCameraSupport

Confirma la rama actual:

git branch --show-current

Salida esperada:

DepthCameraSupport
2

Instalar LeRobot en modo editable

Paso 2

Si solo utilizas RealSense:

pip install -e ".[realsense]"
3

Conceder permisos

Paso 3

sudo chmod a+rw /dev/bus/usb/*/*
4

Detectar cámaras

Paso 4

lerobot-find-cameras realsense

Este paso mostrará:

  • Modelo de la cámara
  • Número de serie
  • Información USB
  • Configuración de flujo predeterminada
5

Ejemplo de RealSense

Paso 5

Prueba con dos RealSense:

lerobot-teleoperate \
    --robot.type=seeed_b601_dm_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=follower1 \
    --robot.can_adapter=damiao \
  --robot.cameras='{
    d435i_color: {
      type: realsense_d435i_color,
      serial_number_or_name: "419522072950",
      width: 640,
      height: 480,
      fps: 30,
      color_mode: rgb,
      color_stream_format: rgb8,
      rotation: 0,
      warmup_s: 1
    },
    d435i_depth: {
      type: realsense_d435i_depth,
      serial_number_or_name: "419522072950",
      width: 640,
      height: 480,
      fps: 30,
      max_depth_m: 2.0,
      depth_alpha: 0.2,
      rotation: 0,
      warmup_s: 5
    },
    d405_color: {
      type: realsense_d405_color,
      serial_number_or_name: "409122273421",
      width: 640,
      height: 480,
      fps: 30,
      color_mode: rgb,
      color_stream_format: rgb8,
      rotation: 0,
      warmup_s: 1
    },
    d405_depth: {
      type: realsense_d405_depth,
      serial_number_or_name: "409122273421",
      width: 640,
      height: 480,
      fps: 30,
      depth_alpha: 0.03,
      rotation: 0,
      warmup_s: 5
    }
  }' \
    --teleop.type=rebot_arm_102_leader \
    --teleop.port=/dev/ttyUSB0 \
    --teleop.id=rebot_arm_102_leader \
    --display_data=true
6

Notas sobre parámetros

Paso 6

  • depth_alpha controla el factor de escala de la imagen de profundidad y se puede ajustar según el resultado de la visualización y el rango de distancia objetivo.
  • Si conectas tres o más cámaras de profundidad, se recomienda reducir fps a 15 para mejorar la estabilidad general.
  • Se recomienda mantener la resolución en 640x480 para un mejor equilibrio entre estabilidad y rendimiento en tiempo real.

Recopilación de conjuntos de datos​

peligro

Durante la teleoperación, si el brazo robótico maestro-esclavo experimenta una desconexión de energía, un mal contacto de energía o un desprendimiento de la línea de señal, primero debes detener el código del programa y devolver el brazo robótico a su posición cero de origen. Solo entonces vuelve a conectar la fuente de alimentación y reinicia el programa. Esto evita que el desorden de datos provoque que el brazo robótico se descontrole y cause posibles riesgos de seguridad.

lerobot-record \
    --robot.type=seeed_b601_dm_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.id=follower1 \
    --robot.can_adapter=damiao \
    --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30, fourcc: "MJPG"}, side: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30, fourcc: "MJPG"}}" \
    --teleop.type=rebot_arm_102_leader \
    --teleop.port=/dev/ttyUSB0 \
    --teleop.id=rebot_arm_102_leader \
    --display_data=true \
    --dataset.repo_id=seeed_rebot_b601_dm/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 de la carpeta de inicio, donde se creará la carpeta seeed_rebot_b601_dm/test mencionada anteriormente.

Función de grabación

La función record proporciona un conjunto de herramientas para capturar y gestionar datos durante el funcionamiento del robot.

1. Almacenamiento de datos

  • Los datos se almacenan usando el formato LeRobotDataset y se guardan en disco durante la grabación.
  • De forma predeterminada, el conjunto de datos se envía a tu página de Hugging Face después de la grabación.
  • Para desactivar la subida, usa: --dataset.push_to_hub=False.

2. Puntos de control y reanudación

  • Los puntos de control se crean automáticamente durante la grabación.
  • Para reanudar después de una interrupción, vuelve a ejecutar el mismo comando con: --resume=true

⚠️ Nota importante: Al reanudar, establece --dataset.num_episodes en el número de episodios adicionales que se van a grabar (no en el número total de episodios objetivo del conjunto de datos).

  • Para empezar a grabar desde cero, elimina manualmente el directorio del conjunto de datos.

3. Parámetros de grabación

Configura el flujo de grabación de datos usando argumentos de línea de comandos:

ParámetroDescripciónPredeterminado
--dataset.episode_time_sDuración por episodio de datos (segundos)60
--dataset.reset_time_sTiempo de reinicio del entorno después de cada episodio (segundos)60
--dataset.num_episodesNúmero total de episodios a grabar50

4. Controles de teclado durante la grabación

Controla el flujo de grabación de datos usando atajos de teclado:

TeclaAcción
→ (Flecha derecha)Detener anticipadamente el episodio actual/reiniciar; pasar al siguiente.
← (Flecha izquierda)Cancelar el episodio actual; volver a grabarlo.
ESCDetener la sesión inmediatamente, codificar los vídeos y subir el conjunto de datos.
tip

Si las pulsaciones de tu teclado no responden, puede que necesites hacer un downgrade de tu versión de pynput, por ejemplo instalando la versión 1.6.8.

pip install pynput==1.6.8

Consejos para recopilar datos

  • Sugerencia de tarea: Agarrar objetos en diferentes ubicaciones y colocarlos en un contenedor.
  • Escala: Grabar ≥50 episodios (10 episodios por ubicación).
  • Consistencia:
    • Mantén las cámaras fijas.
    • Mantén un comportamiento de agarre idéntico.
    • Asegúrate de que los objetos manipulados sean visibles en las imágenes de las cámaras.
  • Progresión:
    • Comienza con agarres fiables antes de añadir variaciones (nuevas ubicaciones, técnicas de agarre, ajustes de cámara).
    • Evita aumentar la complejidad demasiado rápido para prevenir fallos.

💡 Regla general: Deberías ser capaz de realizar la tarea tú mismo solo mirando las imágenes de la cámara en la pantalla.

Si quieres profundizar en este tema importante, puedes consultar la entrada de blog que escribimos sobre qué hace que un conjunto de datos sea bueno.

Solución de problemas

Problema específico de Linux: Si las teclas Flecha derecha/Flecha izquierda/ESC no responden durante la grabación:

Visualizar el conjunto de datos​

echo ${HF_USER}/rebot_test

Si subiste los datos, también puedes visualizarlos localmente con el siguiente comando:

lerobot-dataset-viz \
  --repo-id ${HF_USER}/rebot_test \
  --episode-index 0 \
  --display-compressed-images=false

Si usaste --dataset.push_to_hub=false y no subiste los datos, también puedes visualizarlos localmente con:

lerobot-dataset-viz \
  --repo-id seeed_rebot_b601_dm/test \
  --episode-index 0 \
  --display-compressed-images=false

Aquí, seeed_rebot_b601_dm/test es el nombre personalizado de repo_id definido durante la recopilación de datos.

Reproducir un episodio​

tip

Inestable, se puede omitir o probar.

Ahora, intenta reproducir el primer conjunto de datos en tu robot:

lerobot-replay \
    --robot.type=seeed_b601_dm_follower \
    --robot.port=/dev/ttyACM0 \
    --robot.can_adapter=damiao \
    --robot.id=follower1 \
    --dataset.repo_id=seeed_rebot_b601_dm/test \
    --dataset.episode=0

En este punto, el robot debería realizar las mismas acciones que cuando lo teleoperaste durante la grabación.

Entrenamiento y evaluación​

Consulta el tutorial oficial ACT

Entrenamiento

Para entrenar una política que controle tu robot, usa el script python -m lerobot.scripts.train. Algunos parámetros son obligatorios. Aquí tienes un comando de ejemplo:

lerobot-train \
  --dataset.repo_id=${HF_USER}/rebot_test \
  --policy.type=act \
  --output_dir=outputs/train/act_rebot_test \
  --job_name=act_rebot_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 nombre usado durante la recopilación de datos y añade --policy.push_to_hub=false.

lerobot-train \
  --dataset.repo_id=seeed_rebot_b601_dm/test \
  --policy.type=act \
  --output_dir=outputs/train/act_rebot_test \
  --job_name=act_rebot_test \
  --policy.device=cuda \
  --wandb.enable=false \
  --policy.push_to_hub=false \
  --steps=300000
tip

Si estás usando una GPU RTX serie 50, necesitas añadir --dataset.video_backend=pyav para evitar APIs faltantes en la versión preliminar de torchvision. El comando de entrenamiento se convierte en:

lerobot-train \
  --dataset.repo_id=seeed_rebot_b601_dm/test \
  --dataset.video_backend=pyav \
  --policy.type=act \
  --output_dir=outputs/train/act_rebot_test \
  --policy.device=cuda \
  --wandb.enable=false \
  --policy.push_to_hub=false \
  --steps=300000

Explicación del comando

  • Especificación del conjunto de datos: Proporcionamos el conjunto de datos mediante el parámetro --dataset.repo_id=${HF_USER}/rebot_test.
  • Pasos de entrenamiento: Modificamos el número de pasos de entrenamiento usando --steps=300000. El algoritmo usa por defecto 800000 pasos; ajústalo según la dificultad de tu tarea. Puedes establecerlo más alto si no estás seguro, ya que se generan puntos de control durante el entrenamiento y la evaluación puede reanudarse desde cualquier punto de control.
  • Tipo de política: Proporcionamos la política con policy.type=act. Del mismo modo, puedes cambiar entre políticas como [act, diffusion, pi0, pi0fast, sac, smolvla]. Esto cargará la configuración desde configuration_act.py. Es importante destacar que esta política se adaptará automáticamente a los estados de los motores de tu robot, a las acciones de los motores y al número de cámaras, ya que esta información ya está almacenada en tu conjunto de datos.
  • 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 las gráficas de entrenamiento usando Weights and Biases. Esto es opcional, pero si lo usas, asegúrate de haber iniciado sesión ejecutando wandb login.

Evaluación

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

lerobot-record \
  --robot.type=seeed_b601_dm_follower \
  --robot.port=/dev/ttyACM0 \
  --robot.can_adapter=damiao \
  --robot.cameras='{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30, fourcc: "MJPG"}, side: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30, fourcc: "MJPG"} }' \
  --robot.id=follower1 \
  --display_data=false \
  --dataset.repo_id=seeed/eval_test123 \
  --dataset.single_task="Put lego brick into the transparent box" \
  --policy.path=outputs/train/act_rebot_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_rebot_test/checkpoints/last/pretrained_model). Si subes el archivo de pesos de los resultados del entrenamiento del modelo al Hub, también puedes usar el repositorio del modelo (por ejemplo, ${HF_USER}/act_rebot_test).
  2. El nombre del conjunto de datos dataset.repo_id comienza con eval_. Esta operación grabará por separado vídeos y datos durante la evaluación, que se guardarán en la carpeta que comienza 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, elimina primero la carpeta que comienza con eval_ y luego ejecuta el programa de nuevo.
  4. Cuando te encuentres con mean is infinity. You should either initialize with stats as an argument or use a pretrained model, ten en cuenta que palabras clave como front y side en el parámetro --robot.cameras deben ser estrictamente coherentes con las utilizadas al recopilar el conjunto de datos.

Para reanudar el entrenamiento desde un checkpoint, aquí tienes un comando de ejemplo para reanudar desde el checkpoint last de la política act_rebot_test:

lerobot-train \
  --config_path=outputs/train/act_rebot_test/checkpoints/last/pretrained_model/train_config.json \
  --resume=true

Preguntas frecuentes (FAQ)​

  • Si estás siguiendo este tutorial de documentación, 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 última versión, lo que puede causar problemas imprevistos como diferentes versiones de conjuntos de datos, diferentes comandos, etc.

  • Si te encuentras con:

    Could not connect on port "/dev/ttyUSB0" or "/dev/ttyACM0"

    Y puedes ver que el dispositivo existe al ejecutar ls /dev/ttyUSB* o ls /dev/ttyACM*, significa que olvidaste otorgar permisos al puerto serie. Introduce sudo chmod 666 /dev/ttyUSB* /dev/ttyACM* en la terminal para solucionarlo.

  • Si te encuentras con:

    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.

  • Entrenar ACT con 50 conjuntos de datos lleva aproximadamente 6 horas en un portátil con una RTX 3060 (8GB), y alrededor de 2-3 horas en ordenadores con GPUs RTX 4090 o A100.

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

  • Para el comando de recopilación de datos, asegúrate de que el parámetro num-episodes esté configurado para recopilar suficientes datos. No pauses manualmente a mitad de camino, ya que la media y la varianza de los datos se calculan solo después de que la recopilación de datos se haya completado, lo cual es necesario para el entrenamiento.

  • Si el programa indica que no puede leer datos de imagen desde la cámara USB, asegúrate 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 alta velocidad de transmisión de imágenes.

tip

Si encuentras problemas de software o de dependencias del entorno que no puedas resolver, además de revisar la sección de Preguntas frecuentes (FAQ) al final de este tutorial, informa del problema de inmediato en la plataforma LeRobot o en el canal de Discord de LeRobot.

Referencias​

Wiki en inglés de Seeed Studio: Cómo usar el brazo robótico SO100Arm en Lerobot

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 debate sobre el producto​

¡Gracias por elegir nuestros productos! Estamos aquí para ofrecerte diferentes tipos de soporte y garantizar que tu experiencia con nuestros productos sea lo más fluida posible. Ofrecemos varios canales de comunicación para adaptarnos a diferentes preferencias y necesidades.

Loading Comments...