Demonstração de Preensão Visual com reBot Arm B601-RS

Adquira agora 🖱️

Percepção de Profundidade · Detecção de Objetos · Calibração Mão-Olho · Preensão Autônoma · Totalmente Open Source

Esta página aborda duas demonstrações de preensão visual com implementações diferentes:

Método 1 de preensão visual: um pipeline YOLO + RGB-D + SDK Python que cobre configuração de ambiente, integração da câmera, calibração mão-olho e depuração da preensão.
Método 2 de preensão visual: um fluxo ROS2 + YOLOE que inicia o braço, a câmera Gemini 2 / D405 e os nós de preensão em vários terminais para pegar e colocar objetos.

Demonstração de preensão visual com reBot Arm B601-RS

Método 1 de preensão visual

1. Características do projeto

Estimativa direta de pose de preensão a partir de YOLO + OBB O pipeline usa diretamente caixas de detecção ou retângulos de área mínima OBB e toma o eixo curto como direção de abertura do gripper, evitando o processamento complexo de nuvens de pontos 3D.
Estimativa de pose de preensão 6D com GraspNet-Baseline (opcional) O projeto também oferece suporte ao GraspNet-Baseline (graspnet/graspnet-baseline) para estimativa de pose de preensão 6D a partir de nuvens de pontos RGB-D, com caixas delimitadoras YOLO usadas para selecionar candidatos-alvo para experimentos de preensão mais complexos.
Integração do driver do braço robótico e do gripper O script principal de preensão é baseado no controlador de braço robótico e de pose final de reBotArm_control_py, com um auxiliar de preensão leve para abertura do gripper, preensão com controle de força e leitura da pose TCP.
Open Source e Extensível Todo o código-fonte é aberto, e os usuários podem personalizar algoritmos de controle e efeitos com base em suas próprias necessidades.

2. Especificações

O hardware para este tutorial é fornecido pela Seeed Studio

Parâmetro	Especificação
Modelo do Braço Robótico	reBot Arm B601-RS
Graus de Liberdade	6-DOF + Gripper
Modelo da Câmera	Orbbec Gemini 2 / Intel RealSense D435i / D405
Método de Detecção	YOLO + Retângulo de Área Mínima OBB
Método de Comunicação	Barramento CAN via adaptador USB2CAN; conexão de câmera USB 3.0
Tensão de Operação	48V CC
Plataforma Host	PC com Ubuntu 22.04+
Versão Recomendada do Python	Python 3.10

3. Lista de materiais (BOM)

Componente	Quantidade	Incluído
Braço Robótico reBot Arm B601-RS	1	✅
Gripper	1	✅
Ponte Serial USB2CAN	1	✅
Adaptador de Energia (48V)	1	✅
Cabo USB-C / Comunicação	1	✅
Câmera de Profundidade RGB-D	1	✅
Conector da Câmera / Suporte de Montagem	1	✅

Fiação

Conecte a câmera de profundidade ao host via USB 3.0.
Conecte o adaptador USB2CAN ao barramento CAN do braço.
Certifique-se de que a fonte de alimentação de 48V, a câmera e o braço robótico estejam todos conectados com segurança.
Defina as permissões:

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

4. Requisitos de ambiente

Item	Requisito
Sistema Operacional	Ubuntu 22.04+
Python	3.10

5. Etapas de instalação

Etapa 0. Conclua primeiro a preparação básica do braço robótico

Antes de iniciar este tutorial, conclua o conteúdo em reBot Arm B601-RS Guia de início rápido, incluindo montagem do braço robótico, inicialização do ponto zero, configuração de ID dos motores e verificações básicas de conectividade.

Etapa 1. Clonar o repositório

Dê preferência ao repositório oficial Seeed-Projects:

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

Etapa 2. Criar e configurar o ambiente conda

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

Se você quiser usar um nome de ambiente diferente, substitua rebotarm no comando pelo nome de sua preferência.

Etapa 3. Instalar o SDK do braço 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 ../..

Se pip install -e . relatar Multiple top-level packages discovered in a flat-layout, adicione descoberta explícita de pacotes a pyproject.toml em reBotArm_control_py e, em seguida, execute pip install -e . novamente:

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

As configurações B601 DM e RS são selecionadas por meio dos arquivos de configuração do SDK. Para o B601-RS, confirme o seguinte em sdk/reBotArm_control_py/config/rebotarm.yaml:

hardware_yaml: rebotarm_rs.yaml

Os programas de preensão visual leem essa configuração do SDK e selecionam automaticamente o modo de controle do braço e os parâmetros do gripper correspondentes.

Etapa 4. Instalar o SDK da câmera de profundidade

Este projeto oferece suporte a câmeras de profundidade RGB-D como Orbbec Gemini 2 e RealSense D435i / D405. Instale o SDK que corresponde à sua câmera; se o seu ambiente já consegue importar o driver da câmera, você pode pular esta etapa.

Orbbec Gemini 2

A câmera de profundidade Orbbec Gemini 2 depende de pyorbbecsdk, o wrapper Python para o Orbbec SDK v2. Dê preferência à instalação primeiro do pacote Python pré-compilado:

Opção 1: Instalar via pip (recomendado)

pip install pyorbbecsdk2

Opção 2: Obter a partir do 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 .

Usuários da China continental podem usar:

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

Ao instalar a partir do código-fonte, certifique-se de que a extensão nativa tenha sido compilada com CMake primeiro, de modo que install/lib contenha pyorbbecsdk*.so e as bibliotecas compartilhadas Orbbec antes de executar pip install -e ..

Se todos os métodos de instalação acima falharem, consulte a documentação oficial da Orbbec abaixo.

Verificar instalação

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

Para uso pela primeira vez, é recomendável instalar as regras udev:

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

RealSense D435i / D405

As câmeras RealSense dependem de pyrealsense2. Normalmente você pode instalá-lo diretamente com pip:

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

Se o seu sistema precisar da cadeia de ferramentas completa RealSense ou de regras udev, instale librealsense2 seguindo a documentação oficial do RealSense SDK.

Resumo de Recursos do SDK

Recurso	Link
Página do Produto Gemini 2	https://www.orbbec.com.cn/index/Product/info.html?cate=38&id=51
Recursos de Desenvolvimento	https://www.orbbec.com.cn/index/Download2025/info.html?cate=121&id=1
Orbbec SDK v2	https://github.com/orbbec/OrbbecSDK_v2
Documentação da API do SDK v2	https://orbbec.github.io/docs/OrbbecSDKv2_API_User_Guide/
pyorbbecsdk	https://github.com/orbbec/pyorbbecsdk
Documentação do pyorbbecsdk	https://orbbec.github.io/pyorbbecsdk/index.html
Wrapper ROS2	https://github.com/orbbec/OrbbecSDK_ROS2/tree/v2-main
Intel RealSense SDK	https://github.com/realsenseai/librealsense

Etapa 5. Configurar o GraspNet (opcional)

Você não precisa do GraspNet para scripts/main.py ou scripts/ordinary_grasp_pipeline.py. Configure-o apenas quando quiser executar scripts/graspnet_camera_demo.py ou scripts/grasp.py, que exigem GraspNet, PyTorch com suporte a CUDA, os operadores CUDA PointNet2/knn e um checkpoint pré-treinado.

As extensões pointnet2 / knn do GraspNet exigem um compilador CUDA. Antes de começar, certifique-se de que o ambiente ativo consiga encontrar nvcc e verifique se a versão CUDA relatada por nvcc corresponde à versão CUDA usada para compilar o PyTorch:

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

Se nvcc estiver ausente ou se a versão CUDA relatada por nvcc não corresponder a torch.version.cuda, instale um compilador CUDA que corresponda à versão CUDA atual do seu PyTorch. Por exemplo, se o PyTorch relatar 13.0:

conda install -c nvidia cuda-nvcc=13.0

Você também pode instalar uma compilação do PyTorch que corresponda à sua versão atual do nvcc. As duas versões devem corresponder, caso contrário, a compilação de pointnet2 / knn falhará com 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 ../../..

dica

Observação: se você seguir a documentação do repositório oficial graspnet-baseline e usar python setup.py install, podem ocorrer erros relacionados a CUDA / PyTorch. Recomendamos usar pip install . --no-build-isolation para que a extensão seja compilada com a configuração de PyTorch e CUDA já instalada no ambiente conda ativo.

dica

Se a compilação falhar com fatal error: cusparse.h: No such file or directory, execute find $CONDA_PREFIX -name cusparse.h e certifique-se de que o diretório que contém cusparse.h esteja incluído em CPATH / CPLUS_INCLUDE_PATH. Se você instalou os cabeçalhos CUDA a partir do pacote conda cuda-toolkit, o caminho de include geralmente é $CONDA_PREFIX/targets/x86_64-linux/include em vez do caminho nvidia/cu13/include do pip mostrado acima.

dica

Além disso, dependências antigas da API do GraspNet ainda podem usar o nome de pacote obsoleto sklearn. O comando sed o substitui pelo nome de pacote atualmente recomendado scikit-learn para evitar The 'sklearn' PyPI package is deprecated durante a instalação. A menos que você também atualize as dependências antigas da API do GraspNet, mantenha a restrição numpy==1.23.4 porque transforms3d==0.3.1 ainda usa aliases antigos do NumPy como np.float.

Configurar modelo pré-treinado

Baixe os pesos oficiais pré-treinados do GraspNet a partir do repositório oficial graspnet-baseline Google, Baidu e então coloque checkpoint-rs.tar em:

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

Em seguida, verifique em config/default.yaml:

graspnet:
  checkpoint: "checkpoint-rs.tar"

O campo checkpoint suporta três formas: um nome de arquivo é resolvido em sdk/graspnet-baseline/checkpoints/; um caminho relativo é resolvido a partir da raiz do projeto; um caminho absoluto é usado diretamente.

6. Estrutura de diretórios

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. Calibração mão-olho

Antes de executar o pipeline completo de preensão, conclua primeiro a calibração mão-olho Eye-in-Hand.

Antes de executar o script de calibração, inicialize e verifique a interface 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 executá-lo, certifique-se de que o seguinte parâmetro de tamanho do ArUco em config/default.yaml corresponda ao marcador impresso real:

calibration:
  aruco:
    marker_length_m: 0.1

No modo automático, o braço percorre 50 poses predefinidas e registra uma amostra sempre que o marcador ArUco é detectado de forma estável. Mesmo que você interrompa o processo com c ou q, o script ainda tenta calcular o resultado da calibração a partir das amostras coletadas.

Se você quiser mover o braço robótico manualmente durante a coleta, use o modo manual:

python scripts/collect_handeye_eih.py --manual

No modo manual, o braço entra em modo de compensação de gravidade. Mova o efetuador final para um ângulo de visão adequado, pressione Enter para capturar e pressione c ou q para finalizar e calcular o resultado.

dica

Se, após a calibração, você perceber que a precisão de preensão do braço robótico não atende aos seus requisitos, pode definir os parâmetros X (frente-trás), Y (esquerda-direita), Z (cima-baixo) em config/default.yaml sob calibration.hand_eye_compensation_m para fornecer compensação de posição.

O resultado da calibração é salvo em:

config/calibration/<camera_type>/hand_eye.npz

A contagem de amostras recomendada é de pelo menos 5 amostras, sendo 15 ou mais o ideal.

8. Execução e depuração

1. Verificar apenas a detecção de objetos

python scripts/object_detection.py

Se você precisar alterar o modelo ou as classes de detecção, modifique config/default.yaml:

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

Esta etapa é útil para confirmar:

Se a câmera abre corretamente
Se o modelo YOLO é carregado corretamente
Se a detecção de objetos com YOLO funciona como esperado

2. Verificar apenas a estimativa de preensão

python scripts/ordinary_grasp_pipeline.py

Se você precisar ajustar a frequência de inferência de preensão ou a distância de recuo pré-preensão, modifique:

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 não se conecta ao braço robótico. Ele é usado apenas para verificar:

Se o OBB ou o retângulo de área mínima é razoável
Se o ponto de preensão está próximo da área central do alvo
Se a direção do eixo curto corresponde à direção esperada de abertura da garra

Controles principais:

Botão esquerdo do mouse: inspecionar a profundidade no pixel selecionado
G: imprimir a pose de preensão atual considerada a melhor
Q / Esc: sair

3. Executar o programa principal de preensão

python scripts/main.py

Se você quiser apenas validar a pose alvo sem mover o braço robótico:

python scripts/main.py --dry-run

Recomenda-se verificar primeiro a pose e o espaço de trabalho alcançável com --dry-run antes de executar uma preensão real.

Fluxo principal do programa:

Inicializar a câmera RGB-D e confirmar que o fluxo de imagem está disponível.
Habilitar o braço robótico e a garra.
Mover para a pose de prontidão. Se você quiser alterar a pose inicial de prontidão, modifique 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 alvos sobre a mesa em tempo real.
Estimar a pose de preensão a partir do eixo curto.
Pressionar G para capturar o quadro atual e executar a preensão.

Teclas em tempo de execução:

G: agarrar o melhor alvo atual
R: retomar a visualização ao vivo
Q / Esc: sair

4. `scripts/set.py` — Programa de pegar e colocar

Função: pegar a banana e colocá-la na caixa.

Fluxo concluído:

Inicialização da câmera e do braço, mover para a posição de prontidão
Visualização em tempo real da câmera + detecção de objetos YOLO e segmentação por instância
Pressionar G para congelar o quadro, calcular a pose alvo do braço via transformação mão-olho
O braço se move para agarrar a banana e erguer
O braço coloca a banana na caixa e retorna à pose inicial
Pressionar Q para sair do sistema, o braço retorna à posição zero

5. Demo de estimativa de câmera com GraspNet (opcional)

python scripts/graspnet_camera_demo.py

Este script executa a estimativa de pose de preensão 6D do GraspNet usando apenas a câmera RGB-D, sem conectar ao braço robótico. Ele mantém uma visualização ao vivo da câmera, usa caixas delimitadoras do YOLO para selecionar a área alvo e filtra candidatos de cena completa viáveis do GraspNet pela bbox do alvo.

Controles principais:

G / Space: executar inferência do GraspNet no quadro atual
R: retomar a visualização ao vivo
Q / Esc: sair

Após a inferência, o Open3D pode visualizar a nuvem de pontos e os candidatos de preensão.

6. Programa de preensão robótica com 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 a estimativa do GraspNet ao fluxo de execução do braço robótico. O YOLO seleciona o alvo, o GraspNet gera uma pose de preensão 6D, a calibração mão-olho a transforma para o referencial da base do robô e o script verifica a alcançabilidade de IK antes de executar a sequência de movimentos de pré-preensão, preensão e recuo.

Executar python scripts/grasp.py inicia o fluxo completo de preensão robótica com GraspNet e de fato controla o braço robótico. --dry-run apenas imprime a pose alvo e o resultado de filtragem de candidatos sem executar o movimento de preensão. --target-class "light blue coffee cup" especifica a classe alvo do YOLO e apenas filtra e agarra candidatos do GraspNet para essa classe.

9. FAQ

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

Isso geralmente significa que as dependências do SDK do braço robótico não estão instaladas no ambiente Python atual. Verifique:

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

2. Pressionar `G` não executa a preensão

Causas comuns:

hand_eye.npz não existe
O modo de calibração mão-olho não é eye_in_hand
A pose alvo não é alcançável pelo IK

Recomenda-se executar:

python scripts/main.py --dry-run

3. A profundidade de preensão é instável

Você pode tentar ajustar:

grasp_pipeline.grasp.depth_quantile
A altura de instalação da câmera em relação à área de trabalho
As propriedades reflexivas da superfície do alvo

4. O GraspNet informa que `pointnet2_utils` não pode ser importado de `pointnet2`

Isso geralmente significa que a extensão CUDA local em sdk/graspnet-baseline/pointnet2 não foi compilada no ambiente conda ativo, ou que o Python está resolvendo um pacote pointnet2 diferente. Certifique-se de que o ambiente do projeto esteja ativo e, em seguida, reconstrua pointnet2 e knn nesse mesmo ambiente:

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

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

Verifique:

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

5. Problemas de compatibilidade de arquitetura CUDA em GPUs mais recentes ao executar o GraspNet

Se você vir no kernel image is available for execution on the device, ou se o PyTorch informar que a capacidade CUDA da GPU atual não é suportada, é provável que o wheel do PyTorch instalado não inclua kernels CUDA para essa arquitetura de GPU. Instale uma compilação do PyTorch que ofereça suporte à sua arquitetura atual de CUDA/GPU e, em seguida, reconstrua as extensões CUDA locais do 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

Se você precisar especificar manualmente a arquitetura de compilação, defina TORCH_CUDA_ARCH_LIST antes de recompilar. Escolha o valor de acordo com a arquitetura da sua GPU e a versão do PyTorch/CUDA.

6. Inferência do GraspNet informa `RuntimeError: CPU not supported`

Os operadores de amostragem em pointnet2 oferecem suporte apenas a tensores CUDA. Confirme que o CUDA está disponível, que a rede GraspNet e a nuvem de pontos de entrada estão na GPU e que pointnet2 / knn foram compilados com a versão do PyTorch no ambiente ativo.

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

Se a saída for False, corrija primeiro a instalação do CUDA / PyTorch. Se for True, mas o erro permanecer, reconstrua pointnet2 e knn.

Método 2 de preensão visual

1. Apresentação do projeto

Esta solução usa ROS2 e YOLO no reBot Arm B601-RS para detecção de objetos, preensão e colocação. O sistema inicia o braço, a câmera de profundidade e os nós de preensão em terminais separados.

A câmera de profundidade atualmente oferece suporte à Orbbec Gemini 2 e à Intel RealSense D405. Este fluxo não exige uma placa de calibração para a calibração mão-olho. Devido a tolerâncias de montagem e das peças impressas, cada braço pode apresentar um pequeno deslocamento na preensão.

2. Instalação do ambiente

Etapa 1. Instalar o workspace ROS2 do braço robótico

Primeiro, conclua a instalação e a compilação do workspace rebotarm_ros2 seguindo Integração ROS2 do reBot Arm B601-RS.

Etapa 2. Instalar a câmera

Escolha uma das câmeras abaixo e expanda a seção correspondente.

Clique para expandir a instalação do Gemini 2

Clone o SDK ROS2 da Orbbec no workspace e mude para o branch v2-main:

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

Compile o workspace:

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

Instale as regras udev:

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

Clique para expandir a instalação da D405

Clone o SDK RealSense e mude para v2.58.1:

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

Instale as regras udev:

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

Compile e instale o SDK:

dica

Se houver proxy, desative-o antes de configurar novamente:

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

Compile o pacote ROS2 do RealSense:

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

Etapa 3. Importar o pacote de preensão visual

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

Etapa 4. Instalar o ambiente YOLO / YOLOE

grasp_yolo chama o Ultralytics YOLOE a partir do Python. Use um ambiente conda separado e não use o /usr/bin/python3 do sistema.

Criar o ambiente

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

Se você tiver uma GPU NVIDIA, primeiro confirme que o CUDA está disponível. Se a saída for False, instale uma combinação compatível de CUDA / PyTorch. Também é possível continuar na CPU, mas a taxa de quadros da detecção será menor:

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

Verifique o YOLOE:

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

Baixar os pesos para ~/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

Etapa 5. Compilar o workspace

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

O ambiente de preensão visual está pronto. Em cada novo terminal, faça source do seguinte antes dos comandos de preensão visual:

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

3. Executar o projeto

Antes de iniciar, confirme que o braço está ligado, que a interface CAN é can0 e que a Gemini 2 ou a D405 está conectada via USB. Em seguida, suba o 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

Inicie cada parte em um terminal separado para deixar a lógica de preensão mais clara. Gemini 2 e D405 usam comandos de inicialização diferentes; escolha os da sua câmera. Se quiser inicialização em um clique, você pode escrever o próprio script.

Terminal A — Iniciar o braço + RViz

Clique para expandir 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

Clique para expandir 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

Terminal B — Iniciar a câmera

Clique para expandir Gemini 2

source /opt/ros/humble/setup.bash

ros2 launch orbbec_camera gemini2.launch.py

Clique para expandir 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

Terminal C — Ir para a pose de observação + detecção YOLO

Primeiro execute conda activate yolo. Se o nome do ambiente não for yolo, troque pelo nome real do seu ambiente conda.

Clique para expandir Gemini 2

Altere o caminho do Python para o ambiente YOLO que você criou.

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:=0 \
  -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

Clique para expandir D405

Altere o caminho do Python para o ambiente YOLO que você criou.

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

Parâmetro	Descrição
`yolo_device:=gpu`	Usa a GPU; mude para `cpu` se não houver GPU dedicada. Também pode usar `yolo_device:=0` para a GPU 0
`target_class`	Nome de classe de texto YOLOE do objeto a ser pego; altere conforme o objeto real. Suporta as classes padrão do YOLO
`place_class`	Nome de classe de texto YOLOE do alvo de colocação; altere conforme o objeto real. Suporta as classes padrão do YOLO
`grasp_x_offset_m`	Deslocamento frente/trás em `base_link`; valor negativo puxa para trás
`grasp_z_offset_m`	Ajuste fino da altura de preensão. O padrão é para o gripper flexível, mais longo que o gripper comum
`place_z_offset_m`	Elevação extra na colocação, para controlar a que altura o objeto é solto

Terminal D — Preensão e colocação em um clique

O atraso padrão do gatilho é 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 alterar o atraso, acrescente um parâmetro. Por exemplo, disparar após 5 segundos:

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

Terminal E — Retornar à posição inicial (opcional)

Na versão mais nova do rebotarm, pressionar Ctrl + C no terminal faz o braço voltar automaticamente à posição inicial. Para fazer isso manualmente:

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

Contato

Suporte técnico: Submit an Issue
Página do projeto: GitHub
Fórum: Seeed Studio Forum

Método 1 de preensão visual​

1. Características do projeto​

2. Especificações​

3. Lista de materiais (BOM)​

Fiação​

4. Requisitos de ambiente​

5. Etapas de instalação​

Etapa 0. Conclua primeiro a preparação básica do braço robótico​

Etapa 1. Clonar o repositório​

Etapa 2. Criar e configurar o ambiente conda​

Etapa 3. Instalar o SDK do braço robótico​

Etapa 4. Instalar o SDK da câmera de profundidade​

Etapa 5. Configurar o GraspNet (opcional)​

6. Estrutura de diretórios​

7. Calibração mão-olho​

8. Execução e depuração​

1. Verificar apenas a detecção de objetos​

2. Verificar apenas a estimativa de preensão​

3. Executar o programa principal de preensão​

4. scripts/set.py — Programa de pegar e colocar​

5. Demo de estimativa de câmera com GraspNet (opcional)​

6. Programa de preensão robótica com GraspNet (opcional)​

9. FAQ​

1. ModuleNotFoundError: No module named 'motorbridge'

2. Pressionar G não executa a preensão

3. A profundidade de preensão é instável

4. O GraspNet informa que pointnet2_utils não pode ser importado de pointnet2

5. Problemas de compatibilidade de arquitetura CUDA em GPUs mais recentes ao executar o GraspNet

6. Inferência do GraspNet informa RuntimeError: CPU not supported

Método 2 de preensão visual​

1. Apresentação do projeto​

2. Instalação do ambiente​

Etapa 1. Instalar o workspace ROS2 do braço robótico​

Etapa 2. Instalar a câmera​

Etapa 3. Importar o pacote de preensão visual​

Etapa 4. Instalar o ambiente YOLO / YOLOE​

Etapa 5. Compilar o workspace​

3. Executar o projeto​

Terminal A — Iniciar o braço + RViz​

Terminal B — Iniciar a câmera​

Terminal C — Ir para a pose de observação + detecção YOLO​

Terminal D — Preensão e colocação em um clique​

Terminal E — Retornar à posição inicial (opcional)​

Contato​

Referências​

Método 1 de preensão visual

1. Características do projeto

2. Especificações

3. Lista de materiais (BOM)

Fiação

4. Requisitos de ambiente

5. Etapas de instalação

Etapa 0. Conclua primeiro a preparação básica do braço robótico

Etapa 1. Clonar o repositório

Etapa 2. Criar e configurar o ambiente conda

Etapa 3. Instalar o SDK do braço robótico

Etapa 4. Instalar o SDK da câmera de profundidade

Etapa 5. Configurar o GraspNet (opcional)

6. Estrutura de diretórios

7. Calibração mão-olho

8. Execução e depuração

1. Verificar apenas a detecção de objetos

2. Verificar apenas a estimativa de preensão

3. Executar o programa principal de preensão

4. `scripts/set.py` — Programa de pegar e colocar

5. Demo de estimativa de câmera com GraspNet (opcional)

6. Programa de preensão robótica com GraspNet (opcional)

9. FAQ

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

2. Pressionar `G` não executa a preensão

4. O GraspNet informa que `pointnet2_utils` não pode ser importado de `pointnet2`

6. Inferência do GraspNet informa `RuntimeError: CPU not supported`

Método 2 de preensão visual

1. Apresentação do projeto

2. Instalação do ambiente

Etapa 1. Instalar o workspace ROS2 do braço robótico

Etapa 2. Instalar a câmera

Etapa 3. Importar o pacote de preensão visual

Etapa 4. Instalar o ambiente YOLO / YOLOE

Etapa 5. Compilar o workspace

3. Executar o projeto

Terminal A — Iniciar o braço + RViz

Terminal B — Iniciar a câmera

Terminal C — Ir para a pose de observação + detecção YOLO

Terminal D — Preensão e colocação em um clique

Terminal E — Retornar à posição inicial (opcional)

Contato

Referências