Saltar al contenido principal

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

reBot Arm B601-RS
Consigue uno ahora

Licencia: MITVersión de PythonPlataformaCámaraYOLO

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

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

¿En qué se diferencian los dos métodos de agarre?​

Esta página cubre dos demostraciones de agarre visual con diferentes implementaciones. Compara sus marcos, requisitos de calibración y flujos de inicio, y luego elige un tutorial a continuación.

Método 01

Python SDK + YOLO / OBB

Utiliza YOLO, una cámara de profundidad RGB-D y el Python SDK para el flujo de trabajo completo, desde la configuración del entorno e integración de la cámara hasta la calibración mano-ojo y la depuración del agarre.

Lógica de agarre
Estima las poses de agarre a partir de cajas de detección o rectángulos de área mínima OBB; opcionalmente utiliza GraspNet para la estimación de pose 6D.
Calibración mano-ojo
Completa la calibración Eye-in-Hand con un marcador ArUco antes de la primera ejecución completa de agarre.
Inicio
Ejecuta scripts de Python para verificar paso a paso la detección, la estimación de pose y el agarre robótico.
Método 02

ROS 2 + YOLOE

Utiliza ROS 2 y YOLOE para iniciar el brazo, la cámara Gemini 2 / D405 / D435i y los nodos de agarre en terminales separadas para recoger y colocar.

Lógica de agarre
El nodo de agarre visual detecta, agarra y coloca objetos. Los nombres de clase en texto especifican los objetivos de agarre y colocación.
Calibración mano-ojo
No se requiere tablero de calibración; ajusta los parámetros de desplazamiento para compensar pequeñas tolerancias de montaje y de piezas impresas.
Inicio
Inicia el brazo, la cámara y el nodo de agarre en terminales separadas y luego dispara la recogida y colocación.

Elige un método de agarre​

Cambia de pestaña para ver el tutorial del método que elijas y sigue sus pasos de instalación y ejecución.

Método de agarre visual 1​

Esta ruta utiliza Python SDK + cámara RGB-D + YOLO / OBB sin un espacio de trabajo ROS 2. La ruta predeterminada se adapta a objetos ordinarios de sobremesa; activa el módulo opcional GraspNet más abajo cuando necesites un agarre 6D más complejo.

1. Características del proyecto​

  1. Estimación directa de la pose de agarre desde YOLO + OBB El flujo utiliza directamente cajas de detección o rectángulos de área mínima OBB y toma el eje corto como dirección de apertura de la pinza, evitando el procesamiento complejo de nubes de puntos 3D.
  2. Estimación de 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 pose de agarre 6D a partir de nubes de puntos RGB-D, usando cajas delimitadoras de YOLO para seleccionar candidatos objetivo para experimentos de agarre más complejos.
  3. 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.
  4. Código abierto y extensible Todo el código fuente es abierto y los usuarios pueden personalizar algoritmos de control y efectos según sus propias necesidades.

2. Especificaciones​

El hardware para este tutorial es proporcionado por Seeed Studio

ParámetroEspecificación
Modelo de brazo robóticoreBot Arm B601-RS
Grados de libertad6-DOF + pinza
Modelo de cámaraOrbbec Gemini 2 / RealSense D435i / D405
Método de detecciónYOLO + rectángulo de área mínima OBB
Método de comunicaciónBus CAN mediante adaptador USB2CAN; conexión de cámara USB 3.0
Tensión de funcionamiento48V CC
Plataforma hostPC con Ubuntu 22.04+
Versión recomendada de PythonPython 3.10

3. Lista de materiales (BOM)​

ComponenteCantidadIncluido
Brazo robótico reBot Arm B601-RS1✅
Pinza1✅
Puente serie USB2CAN1✅
Adaptador de corriente (48V)1✅
Cable USB-C / de comunicación1✅
Cámara de profundidad RGB-D1✅
Conector de cámara / soporte de montaje1✅

Cableado​

  1. Conecta la cámara de profundidad al host mediante USB 3.0.
  2. Conecta el adaptador USB2CAN al bus CAN del brazo.
  3. Asegúrate de que la fuente de alimentación de 48V, la cámara y el brazo robótico estén todos conectados de forma segura.
  4. Si encuentras problemas de permisos, ejecuta:
sudo chmod a+rw /dev/bus/usb/*/*
sudo chmod 666 /dev/ttyUSB0

4. Requisitos del entorno​

ElementoRequisito
Sistema operativoUbuntu 22.04+
Python3.10

5. Instalar el entorno básico​

Sigue estos pasos en orden. Los pasos 0–3 son necesarios para la ruta predeterminada; elige el SDK de cámara en el paso 4 para que coincida con tu hardware. Las instrucciones de instalación y ejecución de GraspNet están en el módulo avanzado separado más abajo.

0

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

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

1

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
2

Paso 2. Crear el entorno y elegir PyTorch para tu hardware​

Completa estas tres fases en orden: crea el entorno base, instala PyTorch para tu hardware e instala las dependencias del proyecto.

Crear el entorno base​
conda env create -f environment.yml -n rebotarm
conda activate rebotarm
Resultado esperado

El prompt de la terminal muestra rebotarm, lo que indica que el entorno está activo. PyTorch aún no está instalado; continúa con las dos fases siguientes.

Para usar un nombre de entorno diferente, reemplaza rebotarm en ambos comandos anteriores. Para un entorno existente, actívalo y ejecuta conda env update -n rebotarm -f environment.yml para actualizar las dependencias base. Este comando no elimina los paquetes de pip existentes.

Instalar PyTorch para tu hardware​

Ambas pestañas usan las mismas versiones de paquetes compatibles; solo difiere el índice de descarga. El archivo de versión actual especifica PyTorch 2.9.1, torchvision 0.24.1 y torchaudio 2.9.1 para el entorno Python 3.10, Ubuntu x86_64 utilizado en este tutorial.

Usa esta opción para ordenadores con gráficos integrados Intel / AMD, o para verificar primero el flujo de trabajo básico en CPU.

python -m pip install -r requirements-pytorch.txt --index-url https://download.pytorch.org/whl/cpu
python -c "import torch; print(torch.__version__, torch.__file__); print('CUDA available:', torch.cuda.is_available())"
Resultado esperado

La ruta de PyTorch apunta dentro del entorno Conda activo. CUDA available: False es lo esperado.

Mantén el siguiente ajuste en config/default.yaml:

yolo:
  device: "cpu"
Flujo de trabajo compatible

El flujo de trabajo básico de YOLO / OBB puede ejecutarse en CPU. La velocidad de inferencia depende del modelo y de tu ordenador. Los operadores CUDA de GraspNet de este proyecto requieren una GPU NVIDIA, así que omite el módulo avanzado de GraspNet a continuación.

Instala y verifica las dependencias del proyecto​

Después de completar cualquiera de las opciones de hardware, ejecuta lo siguiente desde la raíz del proyecto:

python -m pip install -r requirements.txt -c requirements-pytorch.txt
python -m pip check
python -c "import torch, torchvision, torchaudio, cv2; from ultralytics import YOLO; from calibration.aruco_pose import ArUcoDetector; ArUcoDetector(); print('Vision dependencies OK:', cv2.__version__)"
Resultado esperado

pip check imprime No broken requirements found., y el comando de verificación imprime Vision dependencies OK sin errores de importación. Completa estas comprobaciones antes de instalar los SDK del brazo robótico y de la cámara.

Fallos de instalación

-c requirements-pytorch.txt restringe las versiones compatibles del paquete PyTorch. Mantén este argumento y no añadas --upgrade. Si pip falla, revisa el error final y vuelve a intentar la fase correspondiente. Activar un entorno Conda no significa que todas las dependencias se hayan instalado correctamente.

Instala solo el paquete estándar de OpenCV especificado en requirements.txt. Las API ArUco del proyecto están disponibles en la versión 4.7; no instales ruedas adicionales de OpenCV junto con ella. CLIP se instala desde el repositorio Git de Ultralytics, por lo que Git debe estar disponible en tu sistema. Cargar YOLOE por primera vez también puede descargar pesos de modelo.

3

Paso 3. Instala 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 al ejecutar pip install -e . aparece 'Multiple top-level packages discovered in a flat-layout', añade una configuración explícita de descubrimiento de paquetes en el pyproject.toml de reBotArm_control_py y luego ejecuta de nuevo pip install -e .:

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

Las configuraciones B601 DM y RS se seleccionan a través de 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 del efector final correspondientes.

4

Paso 4. Instala 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.

La cámara de profundidad Orbbec Gemini 2 depende de pyorbbecsdk, el contenedor de Python para Orbbec SDK v2. Es preferible instalar primero el paquete de Python precompilado.

En Linux / Ubuntu, configura las reglas de udev antes de usar la cámara por primera vez, sea cual sea el método de instalación que elijas. Las reglas permiten que los usuarios normales accedan al dispositivo USB y se instalan a nivel de sistema, por lo que cada máquina solo necesita esta configuración una vez. Omite los comandos correspondientes si las reglas ya están configuradas.

pip install pyorbbecsdk2

Configurar reglas de udev (Linux / Ubuntu)

pyorbbecsdk2 2.1.0 y posteriores incluyen un script de configuración de entorno. Mantén tu entorno conda activo y ejecuta el script desde el paquete instalado. Solicita permisos de sudo e instala y recarga automáticamente las reglas de udev.

orbbec_sdk_dir="$(python -c 'import os, pyorbbecsdk; print(os.path.dirname(pyorbbecsdk.__file__))')"
python "$orbbec_sdk_dir/shared/setup_env.py"

Si no se puede encontrar shared/setup_env.py, ejecuta pip install --upgrade "pyorbbecsdk2>=2.1.0", y luego repite los comandos anteriores. Consulta la guía oficial de instalación de Orbbec para más detalles.

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

Verificar la instalación

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

El comando de verificación correspondiente imprime pyorbbecsdk OK o pyrealsense2 OK sin un ModuleNotFoundError.

Resumen de recursos de SDK

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

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 (source installation)
│   └── reBotArm_control_py/      # reBot Arm SDK
├── requirements-pytorch.txt      # Compatible versions installed from the CPU / CUDA index
├── requirements.txt              # Project dependencies installed after PyTorch
└── environment.yml               # Base Conda environment

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

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

Después de confirmar la configuración, ejecuta la calibración automática:

python scripts/collect_handeye_eih.py

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 cumple 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, siendo 15 o más lo recomendado.

8. Ejecución y depuración​

Verifica los escenarios en este orden: los dos primeros no se conectan al brazo robótico y ayudan a comprobar la cámara, la detección y la estimación de agarre. Los dos siguientes se conectan y controlan el brazo robótico.

1

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:

  • Que la cámara se abre correctamente
  • Que el modelo YOLO se carga correctamente
  • Que la detección de objetos con YOLO funciona como se espera
2

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

3. Ejecutar el programa principal de agarre​

python scripts/main.py

Para validar la pose objetivo omitiendo el movimiento de agarre:

python scripts/main.py --dry-run

Verifica la pose y el espacio de trabajo con --dry-run antes de ejecutar un agarre real. En este modo, el script actual aún inicializa el brazo, se mueve a la pose de listo y realiza la limpieza y el retorno a origen al salir. Para una verificación solo de visión, usa los dos primeros scripts, que no se conectan al brazo.

Flujo principal del programa:

  1. Inicializar la cámara RGB-D y confirmar que el flujo de imagen está disponible.
  2. Habilitar el brazo robótico y la garra.
  3. Mover a la pose de listo. Si quieres cambiar la pose de listo de inicio, 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
  1. Detectar en tiempo real los objetivos sobre la mesa.
  2. Estimar la pose de agarre a partir del eje corto.
  3. 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

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

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

python scripts/set.py

Flujo completado:

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

9. Módulo avanzado GraspNet (opcional)​

La ruta predeterminada del SDK de Python / OBB no requiere GraspNet. Sigue estos pasos solo cuando necesites estimación de pose de agarre 6D a partir de nubes de puntos RGB-D.

1

Paso 1. Instalar GraspNet y los operadores CUDA​

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 PointNet2/knn y un checkpoint preentrenado.

Las extensiones pointnet2 / knn de GraspNet requieren un compilador CUDA. Antes de empezar, confirma que nvcc está disponible en el entorno actual y compara su versión de CUDA con la versión usada para compilar PyTorch:

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

PyTorch se instala por separado en el Paso 2 de la instalación básica. GraspNet requiere una GPU NVIDIA y soporte CUDA funcional; omite esta sección si seguiste la opción de CPU. Completa las comprobaciones siguientes antes de configurar el compilador.

Paso 1: Confirma tu GPU

nvidia-smi

El controlador debe reconocer tu GPU NVIDIA. Instalar solo el CUDA Toolkit no permite que las gráficas integradas Intel / AMD ejecuten los operadores CUDA de este proyecto.

Paso 2: Confirmar el soporte CUDA de PyTorch

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

Si torch.cuda.is_available() imprime True, continúa con el siguiente paso. Si falta PyTorch, torch.version.cuda es None o CUDA no está disponible, vuelve al Paso 2 de la instalación básica y completa la instalación y verificación de NVIDIA. Al cambiar entre compilaciones de CPU y CUDA, elimina la compilación antigua antes de reinstalar.

Paso 3: Instalar el compilador CUDA que coincida con tu PyTorch

pointnet2 / knn son extensiones CUDA locales: la versión de CUDA reportada por nvcc --version debe coincidir con torch.version.cuda al compilar, de lo contrario la compilación falla con The detected CUDA version (...) mismatches the version that was used to compile PyTorch (...). Comprueba ambas versiones primero:

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

Tomando como ejemplo que torch.version.cuda muestre 12.8, instala el compilador correspondiente dentro del entorno conda:

conda install -c nvidia cuda-nvcc=12.8 cuda-cudart-dev=12.8

which nvcc       # should point to $CONDA_PREFIX/bin/nvcc, not /usr/bin/nvcc
nvcc --version   # should match torch.version.cuda

cuda-nvcc proporciona el compilador y cuda-cudart-dev proporciona las cabeceras de CUDA bajo targets/x86_64-linux/include; ambos son necesarios. Una vez que el entorno de conda está activado, $CONDA_PREFIX/bin precede a las rutas del sistema, por lo que el nvcc de conda sustituye automáticamente al antiguo del sistema (por ejemplo CUDA 11.5 de los repositorios de Ubuntu); no es necesario desinstalar la CUDA del sistema.

aviso

No rebajes la versión de PyTorch para que coincida con un nvcc antiguo del sistema: las versiones antiguas de CUDA pueden no ser compatibles con la arquitectura de tu GPU (CUDA 11.5 admite como máximo sm_86; la serie RTX 40 requiere CUDA 11.8+ y la serie RTX 50 requiere CUDA 12.8+), y las compilaciones antiguas de PyTorch pueden ser incompatibles con otras dependencias del proyecto, como las versiones recientes de ultralytics.

Paso 4: Verificar

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

Cuando ambas versiones de CUDA coinciden y torch.cuda.is_available() imprime True, la configuración de PyTorch está completa y puedes continuar compilando los operadores CUDA.

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.
# Note: use the conda cuda-toolkit targets directory for headers/libraries;
# do not mix in the pip nvidia/cu13 directory (a version mismatch with conda nvcc causes build errors).
export CUDA_HOME=$CONDA_PREFIX
export TORCH_CUDA_ARCH_LIST="$(python -c 'import torch; major, minor = torch.cuda.get_device_capability(); print(f"{major}.{minor}")')"
export CPATH=$CONDA_PREFIX/targets/x86_64-linux/include:$CPATH
export CPLUS_INCLUDE_PATH=$CONDA_PREFIX/targets/x86_64-linux/include:$CPLUS_INCLUDE_PATH
export LIBRARY_PATH=$CONDA_PREFIX/targets/x86_64-linux/lib:$CONDA_PREFIX/lib:$LIBRARY_PATH
export LD_LIBRARY_PATH=$CONDA_PREFIX/targets/x86_64-linux/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 contra la configuración de PyTorch y CUDA ya instalada en el entorno de 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 añade el directorio que contiene cusparse.h a CPATH / CPLUS_INCLUDE_PATH (con el cuda-toolkit de conda esto suele ser $CONDA_PREFIX/targets/x86_64-linux/include). Si obtienes errores relacionados con cabeceras como '__NV_IS_DEVICE' was not declared in this scope, normalmente se deben a mezclar las cabeceras de nvidia/cu13 instaladas por pip con la versión de nvcc de conda; cambia a las rutas targets de conda indicadas arriba y vuelve a compilar.

tip

Además, las dependencias antiguas de la API de GraspNet pueden seguir usando el nombre de paquete obsoleto sklearn. El comando sed lo sustituye 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 el modelo preentrenado

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

mkdir -p ~/rebot_grasp/sdk/graspnet-baseline/checkpoints

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.

2

Paso 2. Ejecutar la demo de estimación con cámara de GraspNet​

python scripts/graspnet_camera_demo.py

Este script ejecuta la estimación de poses 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 cajas delimitadoras de YOLO para seleccionar el área objetivo y filtra las candidatas de escena completa de GraspNet factibles según la 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 las candidatas de agarre.

3

Paso 3. Ejecutar el programa de agarre robótico de GraspNet​

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 por IK antes de ejecutar la secuencia de movimientos de pre-agarre, agarre y retirada.

Ejecutar python scripts/grasp.py inicia el flujo completo de agarre robótico de GraspNet y controla el brazo robótico. --dry-run imprime la pose objetivo y el resultado del filtrado de candidatas y omite el movimiento de agarre; el script actual aún inicializa el brazo, lo mueve a la pose de listo y realiza la limpieza y el retorno a origen al salir. --target-class "light blue coffee cup" especifica la clase objetivo de YOLO y solo filtra y agarra las candidatas de GraspNet para esa clase.

10. Preguntas frecuentes (FAQ)​

1. ModuleNotFoundError: No module named 'motorbridge'

Esto significa que las dependencias del SDK del brazo robótico no están instaladas en el entorno actual de Python. conda env update solo actualiza el entorno base; instala las dependencias del proyecto por separado. Ejecuta lo siguiente desde la raíz del proyecto:

conda activate rebotarm
conda env update -n rebotarm -f environment.yml
# Complete the PyTorch installation in basic installation Step 2 first.
python -m pip install -r requirements.txt -c requirements-pytorch.txt
cd sdk/reBotArm_control_py && python -m pip install -e .

2. Al pulsar 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 del objetivo

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

Esto normalmente significa que la extensión local de CUDA bajo sdk/graspnet-baseline/pointnet2 no se compiló en el entorno de conda activo, o que Python está resolviendo un paquete pointnet2 diferente. Asegúrate de que el entorno del proyecto esté activo y luego vuelve a compilar 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 (pointnet2_utils / knn_modules se importan como módulos de nivel superior desde los directorios fuente, que es también como los importa models/; los scripts de agarre añaden automáticamente los directorios fuente a sys.path):

cd sdk/graspnet-baseline
python -c "import sys; sys.path[:0]=['pointnet2','knn']; import pointnet2_utils, knn_modules; print('import works')"

5. Problemas de compatibilidad de arquitectura CUDA en GPUs más recientes 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 actual de CUDA/GPU y luego vuelve a compilar 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 volver a compilar. Elige el valor según 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, vuelve a compilar pointnet2 y knn.

Contacto​

Referencias​

Loading Comments...