Pular para o conteúdo principal

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

reBot Arm B601-RS

License: MITPython VersionPlatformCameraYOLO

Percepção de profundidade · Detecção de objetos · Calibração mão-olho · Preensão autônoma · Totalmente open source

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

Em que as duas formas de preensão são diferentes?​

Esta página apresenta duas demonstrações de preensão visual com diferentes implementações. Compare seus frameworks, requisitos de calibração e fluxos de inicialização e, em seguida, escolha um tutorial abaixo.

Method 01

Python SDK + YOLO / OBB

Use YOLO, uma câmera de profundidade RGB-D e o Python SDK para o fluxo de trabalho completo, desde a configuração do ambiente e integração da câmera até a calibração mão-olho e depuração da preensão.

Lógica de preensão
Estime poses de preensão a partir de caixas de detecção ou retângulos de área mínima OBB; opcionalmente use GraspNet para estimação de pose 6D.
Calibração mão-olho
Conclua a calibração Eye-in-Hand com um marcador ArUco antes da primeira execução completa de preensão.
Inicialização
Execute scripts Python para verificar detecção, estimação de pose e preensão robótica passo a passo.
Method 02

ROS 2 + YOLOE

Use ROS 2 e YOLOE para iniciar o braço, a câmera Gemini 2 / D405 / D435i e os nós de preensão em terminais separados para pegar e posicionar objetos.

Lógica de preensão
O nó de preensão visual detecta, agarra e posiciona objetos. Nomes de classes em texto especificam os alvos de preensão e posicionamento.
Calibração mão-olho
Não é necessário quadro de calibração; ajuste parâmetros de deslocamento para compensar pequenas tolerâncias de montagem e de peças impressas.
Inicialização
Inicie o braço, a câmera e o nó de preensão em terminais separados e, em seguida, acione a coleta e o posicionamento.

Escolha um método de preensão​

Alterne as abas para ver o tutorial do método escolhido e siga suas etapas de instalação e execução.

Método de Preensão Visual 1​

Esta rota usa Python SDK + câmera RGB-D + YOLO / OBB sem um workspace ROS 2. A rota padrão é adequada para objetos comuns de mesa; ative o módulo opcional GraspNet abaixo quando precisar de uma preensão 6D mais complexa.

1. Recursos do projeto​

  1. Estimação direta da 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.
  2. Estimação de pose de preensão 6D GraspNet-Baseline (opcional) O projeto também oferece suporte ao GraspNet-Baseline (graspnet/graspnet-baseline) para estimação 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.
  3. Integração do driver do braço robótico e do gripper O script principal de preensão é baseado no braço robótico e no controlador 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.
  4. 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âmetroEspecificação
Modelo do braço robóticoreBot Arm B601-RS
Graus de liberdade6-DOF + Gripper
Modelo da câmeraOrbbec Gemini 2 / RealSense D435i / D405
Método de detecçãoYOLO + retângulo de área mínima OBB
Método de comunicaçãoBarramento CAN via adaptador USB2CAN; conexão de câmera USB 3.0
Tensão de operação48V DC
Plataforma hostPC com Ubuntu 22.04+
Versão recomendada do PythonPython 3.10

3. Lista de materiais (BOM)​

ComponenteQuantidadeIncluído
Braço robótico reBot Arm B601-RS1✅
Gripper1✅
Ponte serial USB2CAN1✅
Adaptador de energia (48V)1✅
Cabo USB-C / comunicação1✅
Câmera de profundidade RGB-D1✅
Conector da câmera / suporte de montagem1✅

Fiação​

  1. Conecte a câmera de profundidade ao host via USB 3.0.
  2. Conecte o adaptador USB2CAN ao barramento CAN do braço.
  3. 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.
  4. Se você encontrar problemas de permissão, execute:
sudo chmod a+rw /dev/bus/usb/*/*
sudo chmod 666 /dev/ttyUSB0

4. Requisitos de ambiente​

ItemRequisito
Sistema operacionalUbuntu 22.04+
Python3.10

5. Instale o ambiente básico​

Siga estas etapas na ordem. As etapas 0–3 são necessárias para a rota padrão; escolha o SDK da câmera na etapa 4 para corresponder ao seu hardware. As instruções de instalação e execução do GraspNet estão no módulo avançado separado abaixo.

0

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 Quick Start, 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.

1

Etapa 1. Clone 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
2

Etapa 2. Crie o ambiente e escolha o PyTorch para o seu hardware​

Conclua estas três fases na ordem: crie o ambiente base, instale o PyTorch para o seu hardware e instale as dependências do projeto.

Crie o ambiente base​
conda env create -f environment.yml -n rebotarm
conda activate rebotarm
Resultado esperado

O prompt do terminal mostra rebotarm, indicando que o ambiente está ativo. O PyTorch ainda não está instalado; continue com as duas próximas fases.

Para usar um nome de ambiente diferente, substitua rebotarm em ambos os comandos acima. Para um ambiente existente, ative-o e execute conda env update -n rebotarm -f environment.yml para atualizar as dependências básicas. Este comando não remove pacotes pip existentes.

Instale o PyTorch para o seu hardware​

Ambas as abas usam as mesmas versões de pacotes compatíveis; apenas o índice de download é diferente. O arquivo de versão atual especifica PyTorch 2.9.1, torchvision 0.24.1 e torchaudio 2.9.1 para o ambiente Python 3.10, Ubuntu x86_64 usado neste tutorial.

Use esta opção para computadores com gráficos integrados Intel / AMD ou para verificar primeiro o fluxo de trabalho básico na 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

O caminho do PyTorch aponta para dentro do ambiente Conda ativo. CUDA available: False é o comportamento esperado.

Mantenha a seguinte configuração em config/default.yaml:

yolo:
device: "cpu"
Fluxo de trabalho compatível

O fluxo de trabalho básico de YOLO / OBB pode ser executado em CPU. A velocidade de inferência depende do modelo e do seu computador. Os operadores CUDA do GraspNet deste projeto exigem uma GPU NVIDIA, portanto, pule o módulo avançado do GraspNet abaixo.

Instale e verifique as dependências do projeto​

Após concluir qualquer uma das opções de hardware, execute o seguinte a partir da raiz do projeto:

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., e o comando de verificação imprime Vision dependencies OK sem erros de importação. Conclua essas verificações antes de instalar os SDKs do braço robótico e da câmera.

Falhas de instalação

-c requirements-pytorch.txt restringe as versões compatíveis do pacote PyTorch. Mantenha esse argumento e não adicione --upgrade. Se o pip falhar, revise o erro final e tente novamente a fase correspondente. Ativar um ambiente Conda não significa que todas as dependências foram instaladas com sucesso.

Instale apenas o pacote OpenCV padrão especificado em requirements.txt. As APIs ArUco do projeto estão disponíveis na versão 4.7; não instale wheels adicionais do OpenCV junto com ela. O CLIP é instalado a partir do repositório Git da Ultralytics, portanto o Git deve estar disponível no seu sistema. Carregar o YOLOE pela primeira vez também pode fazer o download dos pesos do modelo.

3

Etapa 3. Instale 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 executar pip install -e . retornar 'Multiple top-level packages discovered in a flat-layout', adicione uma configuração explícita de descoberta de pacotes em pyproject.toml de 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 B601-RS, confirme o seguinte em sdk/reBotArm_control_py/config/rebotarm.yaml:

hardware_yaml: rebotarm_rs.yaml

Os programas de apreensã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.

4

Etapa 4. Instale 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á conseguir importar o driver da câmera, você pode pular esta etapa.

A câmera de profundidade Orbbec Gemini 2 depende de pyorbbecsdk, o wrapper Python para o Orbbec SDK v2. Dê preferência a instalar primeiro o pacote Python pré-compilado.

No Linux / Ubuntu, configure as regras udev antes de usar a câmera pela primeira vez, qualquer que seja o método de instalação escolhido. As regras permitem que usuários comuns acessem o dispositivo USB e são instaladas em todo o sistema, portanto cada máquina precisa dessa configuração apenas uma vez. Pule os comandos correspondentes se as regras já estiverem configuradas.

pip install pyorbbecsdk2

Configurar regras udev (Linux / Ubuntu)

pyorbbecsdk2 2.1.0 e posteriores incluem um script de configuração de ambiente. Mantenha seu ambiente conda ativo e execute o script a partir do pacote instalado. Ele solicita permissão de sudo e instala e recarrega automaticamente as regras udev.

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

Se shared/setup_env.py não puder ser encontrado, execute pip install --upgrade "pyorbbecsdk2>=2.1.0", depois repita os comandos acima. Consulte o guia oficial de instalação da Orbbec para mais detalhes.

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

Verificar instalação

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

O comando de verificação correspondente imprime pyorbbecsdk OK ou pyrealsense2 OK sem um ModuleNotFoundError.

Resumo de recursos do SDK

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

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 (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. 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

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

Após confirmar a configuração, execute a calibração automática:

python scripts/collect_handeye_eih.py

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 visualizaçã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 em 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​

Verifique os cenários nesta ordem: os dois primeiros não se conectam ao braço robótico e ajudam a verificar a câmera, a detecção e a estimativa de preensão. Os dois seguintes se conectam e controlam o braço robótico.

1

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

python scripts/object_detection.py

Se você precisar alterar o modelo de detecção ou as classes, 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:

  • A câmera abre corretamente
  • O modelo YOLO é carregado corretamente
  • A detecção de objetos com YOLO funciona conforme o esperado
2

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 fica 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

3. Executar o programa principal de preensão​

python scripts/main.py

Para validar a pose do alvo enquanto pula o movimento de preensão:

python scripts/main.py --dry-run

Verifique a pose e a área de trabalho com --dry-run antes de executar uma preensão real. Nesse modo, o script atual ainda inicializa o braço, move para a pose de prontidão e realiza limpeza e retorno à origem ao sair. Para verificação apenas de visão, use os dois primeiros scripts, que não se conectam ao braço.

Fluxo principal do programa:

  1. Inicializar a câmera RGB-D e confirmar que o fluxo de imagem está disponível.
  2. Habilitar o braço robótico e a garra.
  3. Mover para a pose de prontidão. Se você quiser alterar a pose de prontidão na inicializaçã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
  1. Detectar alvos sobre a mesa em tempo real.
  2. Estimar a pose de preensão a partir do eixo curto.
  3. Pressione 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

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

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

python scripts/set.py

Fluxo concluído:

  1. Inicialização da câmera e do braço, mover para a posição de prontidão
  2. Pré-visualização da câmera em tempo real + detecção de objetos YOLO e segmentação de instâncias
  3. Pressione G para congelar o quadro, calcular a pose alvo do braço via transformação mão-olho
  4. O braço se move para agarrar a banana e levantá-la
  5. O braço coloca a banana na caixa e retorna à pose inicial
  6. Pressione Q para sair do sistema, o braço retorna à posição zero

9. Módulo avançado GraspNet (Opcional)​

O SDK Python / rota OBB padrão não requer GraspNet. Siga estas etapas apenas quando você precisar de estimativa de pose de preensão 6D a partir de nuvens de pontos RGB-D.

1

Etapa 1. Instalar GraspNet e operadores CUDA​

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, confirme que nvcc está disponível no ambiente atual e compare sua versão CUDA com a versão usada para compilar o PyTorch:

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

O PyTorch é instalado separadamente na Etapa 2 da instalação básica. O GraspNet requer uma GPU NVIDIA e suporte CUDA funcional; pule esta seção se você tiver seguido a opção de CPU. Conclua as verificações abaixo antes de configurar o compilador.

Etapa 1: Confirmar sua GPU

nvidia-smi

O driver deve reconhecer sua GPU NVIDIA. Instalar apenas o CUDA Toolkit não permite que gráficos integrados Intel / AMD executem os operadores CUDA deste projeto.

Etapa 2: Confirmar o suporte CUDA do PyTorch

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

Se torch.cuda.is_available() imprimir True, continue para a próxima etapa. Se o PyTorch estiver ausente, torch.version.cuda for None ou o CUDA estiver indisponível, volte para a Etapa 2 da instalação básica e conclua a instalação e verificação da NVIDIA. Ao alternar entre builds de CPU e CUDA, remova o build antigo antes de reinstalar.

Etapa 3: Instalar o compilador CUDA correspondente ao seu PyTorch

pointnet2 / knn são extensões CUDA locais: a versão CUDA reportada por nvcc --version deve corresponder a torch.version.cuda durante a compilação, caso contrário a compilação falha com The detected CUDA version (...) mismatches the version that was used to compile PyTorch (...). Verifique ambas as versões primeiro:

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

Tomando torch.version.cuda mostrando 12.8 como exemplo, instale o compilador correspondente dentro do ambiente 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 fornece o compilador e cuda-cudart-dev fornece os headers CUDA em targets/x86_64-linux/include; ambos são necessários. Quando o ambiente conda é ativado, $CONDA_PREFIX/bin precede os caminhos do sistema, então o nvcc do conda automaticamente sombreia o antigo do sistema (por exemplo, CUDA 11.5 dos repositórios do Ubuntu) — não é necessário desinstalar o CUDA do sistema.

atenção

Não faça downgrade do PyTorch para corresponder a um nvcc antigo do sistema: versões antigas do CUDA podem não suportar a arquitetura da sua GPU (CUDA 11.5 suporta no máximo sm_86; a série RTX 40 requer CUDA 11.8+ e a série RTX 50 requer CUDA 12.8+), e builds antigos do PyTorch podem ser incompatíveis com outras dependências do projeto, como versões recentes do ultralytics.

Etapa 4: Verificar

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

Quando ambas as versões do CUDA corresponderem e torch.cuda.is_available() imprimir True, a configuração do PyTorch estará completa e você poderá continuar compilando os 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 ../../..
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 base na 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 adicione o diretório que contém cusparse.h a CPATH / CPLUS_INCLUDE_PATH (com o cuda-toolkit do conda isso geralmente é $CONDA_PREFIX/targets/x86_64-linux/include). Se você obtiver erros relacionados a headers como '__NV_IS_DEVICE' was not declared in this scope, eles geralmente são causados por misturar os headers nvidia/cu13 do pip com a versão nvcc do conda — mude para os caminhos targets do conda acima e recompile.

dica

Além disso, dependências mais antigas da GraspNet API 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 mais antigas da GraspNet API, 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 da GraspNet a partir do repositório oficial graspnet-baseline Google, Baidu, depois coloque checkpoint-rs.tar em:

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

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.

2

Etapa 2. Execute a demonstração de estimativa de câmera da GraspNet​

python scripts/graspnet_camera_demo.py

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

Controles principais:

  • G / Space: executa a inferência da GraspNet no quadro atual
  • R: retoma a pré-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.

3

Etapa 3. Execute o programa de preensão robótica da GraspNet​

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 da GraspNet ao fluxo de execução do braço robótico. O YOLO seleciona o alvo, a 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 por IK antes de executar a sequência de movimentos de pré-preensão, preensão e retirada.

Executar python scripts/grasp.py inicia todo o fluxo de preensão robótica da GraspNet e controla o braço robótico. --dry-run imprime a pose alvo e o resultado da filtragem de candidatos e pula o movimento de preensão; o script atual ainda inicializa o braço, move para a pose de pronto e realiza limpeza e homing ao sair. --target-class "light blue coffee cup" especifica a classe alvo do YOLO e apenas filtra e realiza preensões em candidatos da GraspNet para essa classe.

10. FAQ​

1. ModuleNotFoundError: No module named 'motorbridge'

Isso significa que as dependências do SDK do braço robótico não estão instaladas no ambiente Python atual. conda env update atualiza apenas o ambiente base; instale as dependências do projeto separadamente. Execute o seguinte a partir da raiz do projeto:

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. 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 por 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
  • Propriedades reflexivas da superfície do alvo

4. A 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 então recompile tanto pointnet2 quanto 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 (pointnet2_utils / knn_modules são importados como módulos de nível superior a partir dos diretórios de origem, que é também como models/ os importa; os scripts de preensão adicionam automaticamente os diretórios de origem ao 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 compatibilidade de arquitetura CUDA em GPUs mais recentes ao executar a 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 um build do PyTorch que suporte sua arquitetura atual de CUDA/GPU e então recompile as extensões CUDA locais da 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. A inferência da GraspNet informa RuntimeError: CPU not supported

Os operadores de amostragem em pointnet2 suportam apenas 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, recompile pointnet2 e knn.

Contato​

Referências​

Loading Comments...