Demostración de agarre visual con reBot Arm B601-RS

Percepción de profundidad · Detección de objetos · Calibración mano-ojo · Agarre autónomo · Totalmente de código abierto

Esta página cubre dos demostraciones de agarre visual con diferentes implementaciones:

Método de agarre visual 1: Un flujo de trabajo YOLO + RGB-D + Python SDK que cubre la configuración del entorno, integración de la cámara, calibración mano-ojo y depuración del agarre.
Método de agarre visual 2: Un flujo de trabajo ROS2 + YOLOE que inicia el brazo, la cámara Gemini 2 / D405 / D435i y los nodos de agarre en múltiples terminales para recoger y colocar objetos.

Método de agarre visual 1

1. Características del proyecto

Estimación directa de la pose de agarre a partir de YOLO + OBB El flujo de trabajo utiliza directamente las cajas de detección o los rectángulos de área mínima OBB y toma el eje corto como la dirección de apertura de la pinza, evitando el procesamiento complejo de nubes de puntos 3D.
Estimación de la pose de agarre 6D con GraspNet-Baseline (opcional) El proyecto también es compatible con GraspNet-Baseline (graspnet/graspnet-baseline) para la estimación de la pose de agarre 6D a partir de nubes de puntos RGB-D, usando las cajas delimitadoras de YOLO para seleccionar candidatos objetivo para experimentos de agarre más complejos.
Integración del controlador del brazo robótico y la pinza El script principal de agarre se basa en el brazo robótico y el controlador de pose final de reBotArm_control_py, con un asistente de agarre ligero para la apertura de la pinza, el agarre controlado por fuerza y la lectura de la pose TCP.
Código abierto y extensible Todo el código fuente es abierto y los usuarios pueden personalizar los algoritmos de control y los efectos según sus propias necesidades.

2. Especificaciones

El hardware para este tutorial es proporcionado por Seeed Studio

Parámetro	Especificación
Modelo de brazo robótico	reBot Arm B601-RS
Grados de libertad	6-DOF + pinza
Modelo de cámara	Orbbec Gemini 2 / RealSense D435i / D405
Método de detección	YOLO + rectángulo de área mínima OBB
Método de comunicación	Bus CAN mediante adaptador USB2CAN; conexión de cámara USB 3.0
Tensión de funcionamiento	48V CC
Plataforma host	PC con Ubuntu 22.04+
Versión recomendada de Python	Python 3.10

3. Lista de materiales (BOM)

Componente	Cantidad	Incluido
Brazo robótico reBot Arm B601-RS	1	✅
Pinza	1	✅
Puente serie USB2CAN	1	✅
Adaptador de corriente (48V)	1	✅
Cable USB-C / de comunicación	1	✅
Cámara de profundidad RGB-D	1	✅
Conector de cámara / soporte de montaje	1	✅

Cableado

Conecta la cámara de profundidad al host mediante USB 3.0.
Conecta el adaptador USB2CAN al bus CAN del brazo.
Asegúrate de que la fuente de alimentación de 48V, la cámara y el brazo robótico estén conectados de forma segura.
Establece los permisos:

sudo chmod a+rw /dev/bus/usb/*/*
sudo chmod 666 /dev/ttyUSB0

4. Requisitos del entorno

Elemento	Requisito
Sistema operativo	Ubuntu 22.04+
Python	3.10

5. Pasos de instalación

Paso 0. Completa primero la preparación básica del brazo robótico

Antes de comenzar este tutorial, termina el contenido de reBot Arm B601-RS Quick Start, incluyendo el montaje del brazo robótico, la inicialización del punto cero, la configuración de los ID de los motores y las comprobaciones básicas de conectividad.

Paso 1. Clonar el repositorio

Da preferencia al repositorio oficial Seeed-Projects:

git clone https://github.com/Seeed-Projects/reBot-DevArm-Grasp.git rebot_grasp
cd rebot_grasp

Paso 2. Crear y configurar el entorno conda

conda env create -f environment.yml -n rebotarm
conda activate rebotarm

Si quieres usar un nombre de entorno diferente, reemplaza rebotarm en el comando por tu propio nombre.

Paso 3. Instalar el SDK del brazo robótico

git clone https://github.com/Seeed-Projects/reBotArm_control_py.git sdk/reBotArm_control_py
cd sdk/reBotArm_control_py
pip install -e .
cd ../..

Si pip install -e . muestra Multiple top-level packages discovered in a flat-layout, añade una detección explícita de paquetes a pyproject.toml en reBotArm_control_py y luego ejecuta pip install -e . de nuevo:

[tool.setuptools.packages.find]
include = ["reBotArm_control_py*"]

Las configuraciones B601 DM y RS se seleccionan mediante los archivos de configuración del SDK. Para B601-RS, confirma lo siguiente en sdk/reBotArm_control_py/config/rebotarm.yaml:

hardware_yaml: rebotarm_rs.yaml

Los programas de agarre visual leen esta configuración del SDK y seleccionan automáticamente el modo de control del brazo y los parámetros de la pinza correspondientes.

Paso 4. Instalar el SDK de la cámara de profundidad

Este proyecto es compatible con cámaras de profundidad RGB-D como Orbbec Gemini 2 y RealSense D435i / D405. Instala el SDK que coincida con tu cámara; si tu entorno ya puede importar el controlador de la cámara, puedes omitir este paso.

Orbbec Gemini 2

La cámara de profundidad Orbbec Gemini 2 depende de pyorbbecsdk, el contenedor de Python para Orbbec SDK v2. Primero intenta instalar el paquete de Python precompilado:

Opción 1: Instalar desde pip (recomendado)

pip install pyorbbecsdk2

Opción 2: Obtenerlo desde GitHub

sudo apt-get update
sudo apt-get install -y cmake build-essential libusb-1.0-0-dev

cd sdk
git clone https://github.com/orbbec/pyorbbecsdk.git
cd pyorbbecsdk
pip install -e .

Los usuarios de China continental pueden usar:

git clone https://gitee.com/orbbecdeveloper/pyorbbecsdk.git

Al instalar desde el código fuente, asegúrate de que la extensión nativa se haya compilado primero con CMake, de modo que install/lib contenga pyorbbecsdk*.so y las bibliotecas compartidas de Orbbec antes de ejecutar pip install -e ..

Si todos los métodos de instalación anteriores fallan, consulta la documentación oficial de Orbbec a continuación.

Verificar la instalación

python -c "import pyorbbecsdk; print('pyorbbecsdk OK')"

Para el primer uso, se recomienda instalar las reglas udev:

sudo bash scripts/install_udev_rules.sh
sudo udevadm control --reload-rules
sudo udevadm trigger

RealSense D435i / D405

Las cámaras RealSense dependen de pyrealsense2. Normalmente puedes instalarlo directamente con pip:

pip install pyrealsense2
python -c "import pyrealsense2; print('pyrealsense2 OK')"

Si tu sistema necesita la cadena de herramientas completa de RealSense o las reglas udev, instala librealsense2 siguiendo la documentación oficial del SDK de RealSense.

Resumen de recursos del SDK

Recurso	Enlace
Página de producto de Gemini 2	https://www.orbbec.com.cn/index/Product/info.html?cate=38&id=51
Recursos de desarrollo	https://www.orbbec.com.cn/index/Download2025/info.html?cate=121&id=1
Orbbec SDK v2	https://github.com/orbbec/OrbbecSDK_v2
Documentación de la API del SDK v2	https://orbbec.github.io/docs/OrbbecSDKv2_API_User_Guide/
pyorbbecsdk	https://github.com/orbbec/pyorbbecsdk
Documentación de pyorbbecsdk	https://orbbec.github.io/pyorbbecsdk/index.html
Wrapper ROS2	https://github.com/orbbec/OrbbecSDK_ROS2/tree/v2-main
RealSense SDK	https://github.com/realsenseai/librealsense

Paso 5. Configurar GraspNet (opcional)

No necesitas GraspNet para scripts/main.py o scripts/ordinary_grasp_pipeline.py. Configúralo solo cuando quieras ejecutar scripts/graspnet_camera_demo.py o scripts/grasp.py, que requieren GraspNet, PyTorch con CUDA habilitado, los operadores CUDA de PointNet2/knn y un checkpoint preentrenado.

Las extensiones pointnet2 / knn de GraspNet requieren un compilador CUDA. Antes de empezar, asegúrate de que el entorno activo pueda encontrar nvcc y comprueba que la versión de CUDA que informa nvcc coincida con la versión de CUDA usada para compilar PyTorch:

nvcc --version
python -c "import torch; print(torch.__version__, torch.version.cuda)"

Si falta nvcc, o si la versión de CUDA que informa nvcc no coincide con torch.version.cuda, instala un compilador CUDA que coincida con la versión CUDA actual de PyTorch. Por ejemplo, si PyTorch informa 13.0:

conda install -c nvidia cuda-nvcc=13.0

También puedes instalar en su lugar una compilación de PyTorch que coincida con tu versión actual de nvcc. Las dos versiones deben coincidir, de lo contrario la compilación de pointnet2 / knn fallará con The detected CUDA version (...) mismatches the version that was used to compile PyTorch (...).

cd sdk
git clone https://github.com/graspnet/graspnet-baseline.git
cd graspnet-baseline

# Install PyTorch for your CUDA version first, then install GraspNet runtime dependencies
pip install open3d tensorboard Pillow tqdm

# Configure CUDA build paths before building the local operators.
export CUDA_HOME=$CONDA_PREFIX
export TORCH_CUDA_ARCH_LIST="12.0"
export CPATH=$CONDA_PREFIX/lib/python3.10/site-packages/nvidia/cu13/include:$CPATH
export CPLUS_INCLUDE_PATH=$CONDA_PREFIX/lib/python3.10/site-packages/nvidia/cu13/include:$CPLUS_INCLUDE_PATH
export LD_LIBRARY_PATH=$CONDA_PREFIX/lib/python3.10/site-packages/nvidia/cu13/lib:$CONDA_PREFIX/lib:$LD_LIBRARY_PATH

# Build CUDA operators
cd pointnet2
pip install . --no-build-isolation
cd ../knn
pip install . --no-build-isolation
cd ..

# Install GraspNet API
git clone https://github.com/graspnet/graspnetAPI.git
cd graspnetAPI
sed -i "s/'sklearn'/'scikit-learn'/" setup.py
pip install .
cd ../../..

tip

Nota: Si sigues la documentación del repositorio oficial graspnet-baseline y usas python setup.py install, pueden producirse errores relacionados con CUDA / PyTorch. Recomendamos usar pip install . --no-build-isolation para que la extensión se compile con la configuración de PyTorch y CUDA ya instalada en el entorno conda activo.

tip

Si la compilación falla con fatal error: cusparse.h: No such file or directory, ejecuta find $CONDA_PREFIX -name cusparse.h y asegúrate de que el directorio que contiene cusparse.h esté incluido en CPATH / CPLUS_INCLUDE_PATH. Si instalaste las cabeceras de CUDA desde el paquete conda cuda-toolkit, la ruta de inclusión suele ser $CONDA_PREFIX/targets/x86_64-linux/include en lugar de la ruta de pip nvidia/cu13/include mostrada arriba.

tip

Además, las dependencias antiguas de la API de GraspNet pueden seguir usando el nombre de paquete obsoleto sklearn. El comando sed lo reemplaza por el nombre de paquete actualmente recomendado scikit-learn para evitar The 'sklearn' PyPI package is deprecated durante la instalación. A menos que también actualices las dependencias antiguas de la API de GraspNet, mantén su restricción numpy==1.23.4 porque transforms3d==0.3.1 sigue usando alias antiguos de NumPy como np.float.

Configurar modelo preentrenado

Descarga los pesos preentrenados oficiales de GraspNet desde el repositorio oficial graspnet-baseline Google, Baidu, luego coloca checkpoint-rs.tar en:

sdk/graspnet-baseline/checkpoints/checkpoint-rs.tar

Luego verifica en config/default.yaml:

graspnet:
  checkpoint: "checkpoint-rs.tar"

El campo checkpoint admite tres formas: un nombre de archivo se resuelve bajo sdk/graspnet-baseline/checkpoints/; una ruta relativa se resuelve desde la raíz del proyecto; una ruta absoluta se usa directamente.

6. Estructura de directorios

rebot_grasp/
├── config/
│   ├── default.yaml              # Main configuration file
│   └── calibration/
│       └── <camera_type>/
│           ├── intrinsics.npz    # Camera intrinsics
│           └── hand_eye.npz      # Hand-eye calibration results
├── drivers/
│   ├── camera/
│   │   ├── base.py               # Camera abstract base class
│   │   ├── orbbec_gemini2.py     # Gemini 2 driver
│   │   └── realsense.py          # RealSense driver (alternative)
│   └── robot/
│       └── grasp_driver.py       # Lightweight grasp helper based on arm SDK
├── calibration/
│   ├── aruco_pose.py             # ArUco pose estimation
│   └── hand_eye.py               # Hand-eye calibration solver
├── utils/
│   ├── ordinary_grasp.py         # OBB grasp pose estimation and visualization
│   └── transforms.py             # Coordinate transformation utilities
├── scripts/
│   ├── main.py                   # Main grasping program
│   ├── set.py                    # Grasp and place program
│   ├── ordinary_grasp_pipeline.py
│   ├── object_detection.py
│   └── collect_handeye_eih.py
├── sdk/
│   ├── pyorbbecsdk/              # Orbbec SDK Python wrapper
│   └── reBotArm_control_py/      # reBot Arm SDK
└── environment.yml               # Recommended conda environment file

7. Calibración mano-ojo

Antes de ejecutar el flujo completo de agarre, completa primero la calibración mano-ojo Eye-in-Hand.

Antes de ejecutar el script de calibración, levanta y verifica la interfaz CAN:

sudo ip link set can0 down 2>/dev/null
sudo ip link set can0 type can bitrate 1000000
sudo ip link set can0 up
ip -details link show can0

python scripts/collect_handeye_eih.py

Antes de ejecutarlo, asegúrate de que el siguiente parámetro de tamaño de ArUco en config/default.yaml coincida con el marcador impreso real:

calibration:
  aruco:
    marker_length_m: 0.1

En el modo automático, el brazo recorre 50 poses preestablecidas y registra una muestra siempre que el marcador ArUco se detecta de forma estable. Incluso si interrumpes el proceso con c o q, el script sigue intentando calcular el resultado de calibración a partir de las muestras recopiladas.

Si quieres mover el brazo robótico manualmente durante la recopilación, usa el modo manual:

python scripts/collect_handeye_eih.py --manual

En el modo manual, el brazo entra en modo de compensación de gravedad. Mueve el efector final a un ángulo de visión adecuado, pulsa Enter para capturar y pulsa c o q para finalizar y calcular el resultado.

tip

Si después de la calibración descubres que la precisión de agarre del brazo robótico no puede satisfacer tus requisitos, puedes establecer los parámetros X (adelante-atrás), Y (izquierda-derecha), Z (arriba-abajo) en config/default.yaml bajo calibration.hand_eye_compensation_m para proporcionar compensación de posición.

El resultado de la calibración se guarda en:

config/calibration/<camera_type>/hand_eye.npz

Se recomienda un recuento de muestras de al menos 5 muestras, siendo 15 o más lo recomendado.

8. Ejecución y depuración

1. Verificar solo la detección de objetos

python scripts/object_detection.py

Si necesitas cambiar el modelo de detección o las clases, modifica config/default.yaml:

yolo:
  model_name: "yoloe-26l-seg.pt"
  device: "cpu"
  use_world: true
  custom_classes:
    - "yellow banana"
    - "water bottle"
    - "cup"

Este paso es útil para confirmar:

La cámara se abre correctamente
El modelo YOLO se carga correctamente
La detección de objetos con YOLO funciona como se espera

2. Verificar solo la estimación de agarre

python scripts/ordinary_grasp_pipeline.py

Si necesitas ajustar la frecuencia de inferencia de agarre o la distancia de retirada previa al agarre, modifica:

grasp_pipeline:
  infer_every_live: 3
  grasp:
    depth_quantile: 0.5
    pregrasp_offset_m: 0.080
    insertion_depth_m: 0.015
    min_base_z_m: 0.00

Este script no se conecta al brazo robótico. Solo se utiliza para verificar:

Si el OBB o el rectángulo de área mínima es razonable
Si el punto de agarre se encuentra cerca del área central del objetivo
Si la dirección del eje corto coincide con la dirección esperada de apertura de la garra

Controles clave:

Botón izquierdo del ratón: inspeccionar la profundidad en el píxel seleccionado
G: imprimir la pose de agarre actual óptima
Q / Esc: salir

3. Ejecutar el programa principal de agarre

python scripts/main.py

Si solo quieres validar la pose objetivo sin mover el brazo robótico:

python scripts/main.py --dry-run

Se recomienda verificar primero la pose y el espacio de trabajo alcanzable con --dry-run antes de ejecutar un agarre real.

Flujo principal del programa:

Inicializar la cámara RGB-D y confirmar que el flujo de imágenes está disponible.
Habilitar el brazo robótico y la garra.
Mover a la pose de listo. Si quieres cambiar la pose inicial de listo, modifica config/default.yaml:

robot:
  ready_pose:
    x: 0.3
    y: 0.0
    z: 0.3
    roll: 0.0
    pitch: 0.7
    duration: 3.0

Detectar en tiempo real los objetivos sobre la mesa.
Estimar la pose de agarre a partir del eje corto.
Pulsa G para capturar el fotograma actual y ejecutar el agarre.

Teclas en tiempo de ejecución:

G: agarrar el mejor objetivo actual
R: reanudar la vista previa en vivo
Q / Esc: salir

4. `scripts/set.py` — Programa de agarre y colocación

Función: Agarrar el plátano y colocarlo en la caja.

Flujo completado:

Inicialización de cámara y brazo, mover a la posición de listo
Vista previa de cámara en tiempo real + detección de objetos YOLO y segmentación de instancias
Pulsar G para congelar el fotograma, calcular la pose objetivo del brazo mediante la transformación mano-ojo
El brazo se mueve para agarrar el plátano y levantarlo
El brazo coloca el plátano en la caja y vuelve a la pose inicial
Pulsar Q para salir del sistema, el brazo vuelve a la posición cero

5. Demo de estimación con cámara GraspNet (opcional)

python scripts/graspnet_camera_demo.py

Este script ejecuta la estimación de pose de agarre 6D de GraspNet solo con la cámara RGB-D, sin conectar al brazo robótico. Mantiene una vista previa en vivo de la cámara, usa los cuadros delimitadores de YOLO para seleccionar el área objetivo y filtra los candidatos de escena completa de GraspNet factibles mediante el bbox objetivo.

Controles clave:

G / Space: ejecutar la inferencia de GraspNet en el fotograma actual
R: reanudar la vista previa en vivo
Q / Esc: salir

Después de la inferencia, Open3D puede visualizar la nube de puntos y los candidatos de agarre.

6. Programa de agarre robótico GraspNet (opcional)

python scripts/grasp.py
python scripts/grasp.py --dry-run
python scripts/grasp.py --target-class "light blue coffee cup"

Este script conecta la estimación de GraspNet con el flujo de ejecución del brazo robótico. YOLO selecciona el objetivo, GraspNet produce una pose de agarre 6D, la calibración mano-ojo la transforma al marco base del robot y el script comprueba la alcanzabilidad IK antes de ejecutar la secuencia de movimiento de pre-agarre, agarre y retirada.

Ejecutar python scripts/grasp.py inicia el flujo completo de agarre robótico de GraspNet y controla realmente el brazo robótico. --dry-run solo imprime la pose objetivo y el resultado del filtrado de candidatos sin ejecutar el movimiento de agarre. --target-class "light blue coffee cup" especifica la clase objetivo de YOLO y solo filtra y agarra candidatos de GraspNet para esa clase.

9. Preguntas frecuentes (FAQ)

1. `ModuleNotFoundError: No module named 'motorbridge'`

Esto normalmente significa que las dependencias del SDK del brazo robótico no están instaladas en el entorno actual de Python. Por favor, comprueba:

conda activate rebotarm
conda env update -n rebotarm -f environment.yml
cd sdk/reBotArm_control_py && pip install -e .

2. Al presionar `G` no se ejecuta el agarre

Causas comunes:

hand_eye.npz no existe
El modo de calibración mano-ojo no es eye_in_hand
La pose objetivo no es alcanzable por IK

Se recomienda ejecutar:

python scripts/main.py --dry-run

3. La profundidad de agarre es inestable

Puedes intentar ajustar:

grasp_pipeline.grasp.depth_quantile
La altura de instalación de la cámara con respecto al área de trabajo
Las propiedades reflectantes de la superficie objetivo

4. GraspNet informa que `pointnet2_utils` no se puede importar desde `pointnet2`

Esto normalmente significa que la extensión local de CUDA en sdk/graspnet-baseline/pointnet2 no se compiló en el entorno conda activo, o que Python está resolviendo un paquete pointnet2 diferente. Asegúrate de que el entorno del proyecto esté activo y luego recompila tanto pointnet2 como knn en ese mismo entorno:

conda activate rebotarm
cd sdk/graspnet-baseline/pointnet2
pip install . --no-build-isolation

cd ../knn
pip install . --no-build-isolation

Verifica:

python -c "from pointnet2 import pointnet2_utils; print('Submodule import works')"

5. Problemas de compatibilidad de arquitectura CUDA en GPUs más nuevas al ejecutar GraspNet

Si ves no kernel image is available for execution on the device, o PyTorch informa que la capacidad CUDA de la GPU actual no es compatible, es probable que la rueda de PyTorch instalada no incluya kernels CUDA para esa arquitectura de GPU. Instala una compilación de PyTorch que admita tu arquitectura CUDA/GPU actual y luego recompila las extensiones locales de CUDA de GraspNet.

python -c "import torch; print(torch.__version__, torch.version.cuda, torch.cuda.get_device_name(0))"

cd sdk/graspnet-baseline/pointnet2
pip install . --no-build-isolation

cd ../knn
pip install . --no-build-isolation

Si necesitas especificar manualmente la arquitectura de compilación, establece TORCH_CUDA_ARCH_LIST antes de recompilar. Elige el valor de acuerdo con la arquitectura de tu GPU y la versión de PyTorch/CUDA.

6. La inferencia de GraspNet informa `RuntimeError: CPU not supported`

Los operadores de muestreo en pointnet2 solo admiten tensores CUDA. Confirma que CUDA está disponible, que la red de GraspNet y la nube de puntos de entrada están en la GPU, y que pointnet2 / knn se compilaron contra la versión de PyTorch en el entorno activo.

python -c "import torch; print(torch.cuda.is_available())"

Si la salida es False, corrige primero la instalación de CUDA / PyTorch. Si es True pero el error persiste, recompila pointnet2 y knn.

Método de agarre visual 2

1. Descripción general del proyecto

Esta solución utiliza ROS2 y YOLO en el reBot Arm B601-RS para la detección, el agarre y la colocación de objetos. El sistema inicia el brazo, la cámara de profundidad y los nodos de agarre en terminales separadas.

La cámara de profundidad actualmente es compatible con Orbbec Gemini 2 y RealSense D405 / D435i. Este flujo de trabajo no requiere un tablero de calibración para la calibración mano-ojo. Debido a las tolerancias de montaje y de las piezas impresas, cada brazo puede mostrar un pequeño desplazamiento en el agarre.

2. Configuración del entorno

Paso 1. Instalar el espacio de trabajo ROS2 del brazo robótico

Primero completa la instalación y compilación del espacio de trabajo rebotarm_ros2 siguiendo reBot Arm B601-RS ROS2 Integration.

Paso 2. Instalar la cámara

Elige una de las configuraciones de cámara siguientes y despliega la sección correspondiente.

Haz clic para desplegar la configuración de Gemini 2

Clona el SDK de Orbbec ROS2 en el espacio de trabajo y cambia a la rama v2-main:

cd ~/rebotarm_ros2/src
git clone https://github.com/xiehuangbao888/OrbbecSDK_ROS2.git
cd OrbbecSDK_ROS2
git checkout v2-main

Compila el espacio de trabajo:

cd ~/rebotarm_ros2
colcon build --event-handlers console_direct+ --cmake-args -DCMAKE_BUILD_TYPE=Release

Instala las reglas de udev:

cd ~/rebotarm_ros2/src/OrbbecSDK_ROS2/orbbec_camera/scripts
sudo bash install_udev_rules.sh
sudo udevadm control --reload-rules && sudo udevadm trigger

Haz clic para desplegar los pasos de instalación de D405 / D435i

Clona el SDK de RealSense y cambia a v2.58.1:

cd ~
git clone https://github.com/realsenseai/librealsense.git
cd librealsense
git checkout v2.58.1

Instala las reglas de udev:

sudo apt install -y v4l-utils
cd ~/librealsense
./scripts/setup_udev_rules.sh

Compila e instala el SDK:

tip

Si hay un proxy habilitado, desactívalo antes de volver a configurar:

unset http_proxy https_proxy HTTP_PROXY HTTPS_PROXY all_proxy ALL_PROXY

cd ~/librealsense
mkdir -p build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release
make -j$(nproc)
sudo make install
sudo ldconfig

Compila el paquete RealSense ROS2:

cd ~/rebotarm_ros2/src
git clone https://github.com/xiehuangbao888/realsense-ros.git
cd ~/rebotarm_ros2
colcon build --cmake-args -DUSE_LIFECYCLE_NODE=OFF

Paso 3. Importar el paquete de agarre visual

cd ~/rebotarm_ros2/src/
git clone https://github.com/xiehuangbao888/rebot_visual_grasp.git
cd ~/rebotarm_ros2
colcon build --symlink-install

Paso 4. Instalar el entorno de YOLO / YOLOE

grasp_yolo llama a Ultralytics YOLOE desde Python. Usa un entorno conda dedicado y no uses el /usr/bin/python3 del sistema.

Crear el entorno

conda create -n yolo python=3.10
conda activate yolo

pip install -U ultralytics
pip install "numpy==1.26.4" transforms3d

# YOLOE open-vocabulary classes require the Ultralytics CLIP package, not the PyPI clip package
pip install git+https://github.com/ultralytics/CLIP.git

Si tienes una GPU NVIDIA, primero confirma que CUDA está disponible. Si la salida es False, instala una compilación de CUDA / PyTorch compatible. También puedes continuar en CPU, pero la tasa de fotogramas de detección será menor:

python -c "import torch; print(torch.cuda.is_available())"

Verifica YOLOE:

python -c "from ultralytics import YOLOE; print('YOLOE OK')"

Descargar pesos en ~/rebot_visual_model

mkdir -p ~/rebot_visual_model && cd ~/rebot_visual_model

# MobileCLIP (required by YOLOE set_classes, about 242MB)
wget -c https://github.com/ultralytics/assets/releases/download/v8.4.0/mobileclip2_b.ts

# YOLOE segmentation weights can also download on first run; placing them here is recommended
wget -c https://github.com/ultralytics/assets/releases/download/v8.4.0/yoloe-26s-seg.pt

Paso 5. Compilar el espacio de trabajo

cd ~/rebotarm_ros2
source /opt/ros/humble/setup.bash
colcon build --symlink-install
source ~/rebotarm_ros2/install/setup.bash

El entorno de agarre visual ya está listo. En cada nueva terminal, ejecuta el siguiente comando antes de lanzar órdenes de agarre visual:

source /opt/ros/humble/setup.bash
source ~/rebotarm_ros2/install/setup.bash

3. Ejecutar el proyecto

Antes de comenzar, confirma que el brazo está encendido, que la interfaz CAN es can0, y que Gemini 2, D405 o D435i están conectadas por USB. Luego levanta CAN:

sudo ip link set can0 down 2>/dev/null
sudo ip link set can0 type can bitrate 1000000
sudo ip link set can0 up

Inicia la pila en terminales separadas para que la lógica de agarre sea más fácil de seguir. Gemini 2, D405 y D435i usan diferentes comandos de lanzamiento; elige los correspondientes a tu cámara. Si quieres un lanzamiento con un solo clic, puedes escribir tu propio script de inicio.

Terminal A — Iniciar el brazo + RViz

Haz clic para desplegar Gemini 2

source /opt/ros/humble/setup.bash
source ~/rebotarm_ros2/install/setup.bash

ros2 launch rebot_visual_grasp bringup_with_camera.launch.py model:=rs channel:=can0 use_rviz:=true

Haz clic para desplegar D405

source /opt/ros/humble/setup.bash
source ~/rebotarm_ros2/install/setup.bash

ros2 launch rebot_visual_grasp bringup_with_d405.launch.py model:=rs channel:=can0 use_rviz:=true

Haz clic para desplegar D435i

source /opt/ros/humble/setup.bash
source ~/rebotarm_ros2/install/setup.bash

ros2 launch rebot_visual_grasp bringup_with_d435i.launch.py model:=rs channel:=can0 use_rviz:=true

Terminal B — Iniciar la cámara

Haz clic para desplegar Gemini 2

source /opt/ros/humble/setup.bash

ros2 launch orbbec_camera gemini2.launch.py

Haz clic para desplegar D405

source /opt/ros/humble/setup.bash
source ~/rebotarm_ros2/install/setup.bash

ros2 launch realsense2_camera rs_launch.py \
  align_depth.enable:=true \
  depth_module.depth_profile:=640x360x30 \
  depth_module.color_profile:=640x360x30

Haz clic para desplegar D435i

source /opt/ros/humble/setup.bash
source ~/rebotarm_ros2/install/setup.bash

ros2 launch realsense2_camera rs_launch.py \
  align_depth.enable:=true \
  depth_module.depth_profile:=640x360x30 \
  depth_module.color_profile:=640x360x30

Terminal C — Mover a la pose de observación + detección con YOLO

Activa primero tu entorno conda con conda activate yolo. Si el nombre del entorno no es yolo, sustitúyelo por el nombre real de tu entorno conda.

Haz clic para desplegar Gemini 2

Cambia la ruta de Python al entorno YOLO que creaste.

source /opt/ros/humble/setup.bash
source ~/rebotarm_ros2/install/setup.bash

~/miniconda3/envs/yolov8/bin/python -m rebot_visual_grasp.grasp_yolo --ros-args \
  -p yolo_model:=~/rebot_visual_model/yoloe-26s-seg.pt \
  -p target_class:="cube" \
  -p place_class:="box" \
  -p yolo_device:=gpu \
  -p grasp_z_offset_m:=0.02 \
  -p place_z_offset_m:=0.1 \
  -p grasp_x_offset_m:=-0.04 \
  -p move_to_observation_on_start:=true \
  -p auto_publish_on_detect:=true

Haz clic para desplegar D405

Cambia la ruta de Python al entorno YOLO que creaste.

source /opt/ros/humble/setup.bash
source ~/rebotarm_ros2/install/setup.bash

~/miniconda3/envs/yolov8/bin/python -m rebot_visual_grasp.grasp_yolo --ros-args 
-p yolo_model:=~/rebot_visual_model/yoloe-26s-seg.pt 
-p color_topic:=/camera/camera/color/image_raw 
-p depth_topic:=/camera/camera/aligned_depth_to_color/image_raw 
-p color_info_topic:=/camera/camera/color/camera_info 
-p optical_frame:=camera_color_optical_frame 
-p target_class:="cube" 
-p place_class:="box" 
-p yolo_device:=gpu 
-p grasp_z_offset_m:=0.01 
-p place_z_offset_m:=0.1 
-p grasp_x_offset_m:=-0.04 
-p move_to_observation_on_start:=true 
-p auto_publish_on_detect:=true

Haz clic para desplegar D435i

Cambia la ruta de Python al entorno YOLO que creaste.

source /opt/ros/humble/setup.bash
source ~/rebotarm_ros2/install/setup.bash

~/miniconda3/envs/yolov8/bin/python -m rebot_visual_grasp.grasp_yolo --ros-args \
  -p yolo_model:=~/rebot_visual_model/yoloe-26s-seg.pt \
  -p color_topic:=/camera/camera/color/image_raw \
  -p depth_topic:=/camera/camera/aligned_depth_to_color/image_raw \
  -p color_info_topic:=/camera/camera/color/camera_info \
  -p optical_frame:=camera_color_optical_frame \
  -p target_class:="cube" \
  -p place_class:="box" \
  -p yolo_device:=gpu \
  -p grasp_z_offset_m:=0.01 \
  -p place_z_offset_m:=0.1 \
  -p grasp_y_offset_m:=0.01 \
  -p grasp_x_offset_m:=-0.04 \
  -p move_to_observation_on_start:=true \
  -p auto_publish_on_detect:=true

Parámetro	Descripción
`yolo_device:=gpu`	Usar la GPU; establece `cpu` si no tienes una GPU dedicada. También puedes usar `yolo_device:=0` para la GPU 0
`target_class`	Nombre de clase de texto YOLOE del objeto a agarrar; cámbialo para que coincida con el objeto real. Admite las clases YOLO predeterminadas
`place_class`	Nombre de clase de texto YOLOE del objetivo de colocación; cámbialo para que coincida con el objeto real. Admite las clases YOLO predeterminadas
`grasp_x_offset_m`	Desplazamiento hacia adelante/atrás en `base_link`; un valor negativo tira la pose hacia atrás
`grasp_y_offset_m`	Desplazamiento de agarre izquierda/derecha. `0.01` desplaza 1 cm a la izquierda; un valor negativo desplaza a la derecha
`grasp_z_offset_m`	Ajuste fino de la altura de agarre. El valor predeterminado es para el gripper flexible, que es más largo que el gripper estándar
`place_z_offset_m`	Elevación extra usada al colocar, para controlar a qué altura se suelta el objeto por encima del punto de colocación

Terminal D — Agarre y colocación con un clic

El retardo de activación predeterminado es de 3 segundos.

source /opt/ros/humble/setup.bash
source ~/rebotarm_ros2/install/setup.bash

ros2 launch rebot_visual_grasp grasp_go.launch.py

Para cambiar el retardo, añade un parámetro. Por ejemplo, activar después de 5 segundos:

ros2 launch rebot_visual_grasp grasp_go.launch.py trigger_delay_s:=5.0

Terminal E — Volver a la posición inicial (opcional)

En la versión más reciente de rebotarm, al pulsar Ctrl + C en la terminal el brazo vuelve automáticamente a la posición inicial. Para llevarlo a home manualmente:

source /opt/ros/humble/setup.bash
source ~/rebotarm_ros2/install/setup.bash
ros2 service call /rebotarm/safe_home std_srvs/srv/Trigger {}

Contacto

Soporte técnico: Submit an Issue
Página del proyecto: GitHub
Foro: Seeed Studio Forum

Método de agarre visual 1​

1. Características del proyecto​

2. Especificaciones​

3. Lista de materiales (BOM)​

Cableado​

4. Requisitos del entorno​

5. Pasos de instalación​

Paso 0. Completa primero la preparación básica del brazo robótico​

Paso 1. Clonar el repositorio​

Paso 2. Crear y configurar el entorno conda​

Paso 3. Instalar el SDK del brazo robótico​

Paso 4. Instalar el SDK de la cámara de profundidad​

Paso 5. Configurar GraspNet (opcional)​

6. Estructura de directorios​

7. Calibración mano-ojo​

8. Ejecución y depuración​

1. Verificar solo la detección de objetos​

2. Verificar solo la estimación de agarre​

3. Ejecutar el programa principal de agarre​

4. scripts/set.py — Programa de agarre y colocación​

5. Demo de estimación con cámara GraspNet (opcional)​

6. Programa de agarre robótico GraspNet (opcional)​

9. Preguntas frecuentes (FAQ)​

1. ModuleNotFoundError: No module named 'motorbridge'

2. Al presionar G no se ejecuta el agarre

3. La profundidad de agarre es inestable

4. GraspNet informa que pointnet2_utils no se puede importar desde pointnet2

5. Problemas de compatibilidad de arquitectura CUDA en GPUs más nuevas al ejecutar GraspNet

6. La inferencia de GraspNet informa RuntimeError: CPU not supported

Método de agarre visual 2​

1. Descripción general del proyecto​

2. Configuración del entorno​

Paso 1. Instalar el espacio de trabajo ROS2 del brazo robótico​

Paso 2. Instalar la cámara​

Paso 3. Importar el paquete de agarre visual​

Paso 4. Instalar el entorno de YOLO / YOLOE​

Paso 5. Compilar el espacio de trabajo​

3. Ejecutar el proyecto​

Terminal A — Iniciar el brazo + RViz​

Terminal B — Iniciar la cámara​

Terminal C — Mover a la pose de observación + detección con YOLO​

Terminal D — Agarre y colocación con un clic​

Terminal E — Volver a la posición inicial (opcional)​

Contacto​

Referencias​

Método de agarre visual 1

1. Características del proyecto

2. Especificaciones

3. Lista de materiales (BOM)

Cableado

4. Requisitos del entorno

5. Pasos de instalación

Paso 0. Completa primero la preparación básica del brazo robótico

Paso 1. Clonar el repositorio

Paso 2. Crear y configurar el entorno conda

Paso 3. Instalar el SDK del brazo robótico

Paso 4. Instalar el SDK de la cámara de profundidad

Paso 5. Configurar GraspNet (opcional)

6. Estructura de directorios

7. Calibración mano-ojo

8. Ejecución y depuración

1. Verificar solo la detección de objetos

2. Verificar solo la estimación de agarre

3. Ejecutar el programa principal de agarre

4. `scripts/set.py` — Programa de agarre y colocación

5. Demo de estimación con cámara GraspNet (opcional)

6. Programa de agarre robótico GraspNet (opcional)

9. Preguntas frecuentes (FAQ)

1. `ModuleNotFoundError: No module named 'motorbridge'`

2. Al presionar `G` no se ejecuta el agarre

4. GraspNet informa que `pointnet2_utils` no se puede importar desde `pointnet2`

6. La inferencia de GraspNet informa `RuntimeError: CPU not supported`

Método de agarre visual 2

1. Descripción general del proyecto

2. Configuración del entorno

Paso 1. Instalar el espacio de trabajo ROS2 del brazo robótico

Paso 2. Instalar la cámara

Paso 3. Importar el paquete de agarre visual

Paso 4. Instalar el entorno de YOLO / YOLOE

Paso 5. Compilar el espacio de trabajo

3. Ejecutar el proyecto

Terminal A — Iniciar el brazo + RViz

Terminal B — Iniciar la cámara

Terminal C — Mover a la pose de observación + detección con YOLO

Terminal D — Agarre y colocación con un clic

Terminal E — Volver a la posición inicial (opcional)

Contacto

Referencias