Pular para o conteúdo principal

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

reBot Arm B601-RS
Adquira agora

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 com reBot Arm B601-RS

Qual é a diferença entre os dois métodos de preensão?​

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

Método 01

Python SDK + YOLO / OBB

Use YOLO, uma câmera de profundidade RGB-D e o SDK Python para o fluxo completo, da configuração do ambiente e da integração da câmera até a calibração mão-olho e a 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 o GraspNet para estimativa 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 passo a passo a detecção, a estimativa de pose e a preensão robótica.
Método 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 colocar objetos.

Lógica de preensão
O nó de preensão visual detecta, pega e coloca objetos. Os nomes de classe em texto especificam os alvos de preensão e de colocação.
Calibração mão-olho
Não é necessária uma placa de calibração; ajuste os parâmetros de deslocamento para compensar pequenas tolerâncias de montagem e das 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 pegada e a colocação.

Escolha um método de preensão​

Alterne as abas para ver o tutorial do método escolhido e siga as 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 sobre a mesa; ative o módulo opcional GraspNet abaixo quando precisar de uma preensão 6D mais complexa.

1. Recursos do projeto​

  1. Estimativa direta de pose de preensão a partir de YOLO + OBB O pipeline usa caixas de detecção ou retângulos de área mínima OBB diretamente e toma o eixo curto como direção de abertura do gripper, evitando o processamento complexo de nuvens de pontos 3D.
  2. 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 do 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 fixação1✅

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 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. Instalar o ambiente básico​

Siga estas etapas em ordem. As etapas 0–3 são obrigatórias para a rota padrão; na etapa 4, escolha o SDK da câmera de acordo com o hardware. A instalação e a 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 e configure o ambiente conda​

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

O prompt do terminal mostra rebotarm, indicando que este ambiente está ativo e que as dependências seguintes serão instaladas nele.

Se quiser usar um nome de ambiente diferente, substitua rebotarm no comando pelo nome que preferir.

Verifique o PyTorch imediatamente

environment.yml instala o PyTorch automaticamente por meio das dependências de ultralytics / torchaudio. Se a instalação for interrompida por um problema de rede, o PyTorch pode ficar ausente em silêncio, e o erro só aparece ao executar main.py. Verifique-o logo após criar o ambiente:

python -c "import torch; print(torch.__version__, torch.__file__)"
  • O caminho deve mostrar .../miniforge3/envs/rebotarm/... (dentro do ambiente conda). Se ocorrer ModuleNotFoundError, ou se o caminho apontar para ~/.local/... (diretório do usuário), a instalação está incompleta ou no lugar errado. Execute:
pip install --force-reinstall torch torchvision
  • Com uma GPU NVIDIA, confirme também que o CUDA está disponível:
python -c "import torch; print(torch.cuda.is_available())"
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 pip install -e . relatar Multiple top-level packages discovered in a flat-layout, adicione descoberta explícita de pacotes em 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.

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.

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 do 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 desta configuração apenas uma vez. Ignore os comandos correspondentes se as regras já estiverem configuradas.

pip install pyorbbecsdk2

Configurar as regras udev (Linux / Ubuntu)

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

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 for encontrado, execute pip install --upgrade "pyorbbecsdk2>=2.1.0" e repita os comandos acima. Consulte o guia oficial de instalação da Orbbec para mais detalhes.

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

Verificar instalação

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

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')"
Use uma porta USB 3.x

A D405 / D435i deve ser conectada a uma porta USB 3.0/3.2 (geralmente azul). Se for conectada a uma porta USB 2.0, o sintoma típico é: o sistema reconhece o dispositivo e pipeline.start() é bem-sucedido, mas os quadros nunca chegam (Frame didn't arrive within ...). Verifique a velocidade negociada com:

lsusb -t   # a linha da câmera deve mostrar 5000M; 480M significa que caiu para uma porta USB 2.0 — troque de porta

Se o seu sistema precisar da cadeia de ferramentas completa do RealSense ou de regras udev, siga a documentação oficial do librealsense.

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
└── 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, inicie 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

Depois de 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 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ê achar que a precisão de preensão do braço robótico não atende aos seus requisitos, você 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 recomendado.

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 conferir a câmera, a detecção e a estimativa de preensão. Os dois seguintes se conectam ao braço robótico e o controlam.

1

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:

  • A câmera abre corretamente
  • O modelo YOLO é carregado corretamente
  • A detecção de objetos com YOLO funciona como 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 está próximo da área central do alvo
  • Se a direção do eixo curto corresponde à direção esperada de abertura do gripper

Controles principais:

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

3. Executar o programa principal de preensão​

python scripts/main.py

Para validar a pose alvo ignorando o movimento de preensão:

python scripts/main.py --dry-run

Verifique a pose e o espaço de trabalho com --dry-run antes de executar uma preensão real. Neste modo, o script atual ainda inicializa o braço, move-se para a pose de prontidão e faz a limpeza e o retorno à posição inicial ao sair. Para verificação apenas da 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 o gripper.
  3. 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
  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 pegar e colocar​

Função: pegar 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. Visualização em tempo real da câmera + 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 erguer
  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)​

A rota padrão Python SDK / OBB não exige o GraspNet. Siga estas etapas somente quando precisar estimar poses de preensão 6D a partir de nuvens de pontos RGB-D.

1

Etapa 1. Instalar o GraspNet e os 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.

Ao configurar este ambiente pela primeira vez, a entrada torchaudio em environment.yml normalmente instala o PyTorch junto com ela. Se estiver ausente (ou se apenas a compilação para CPU tiver sido instalada), siga as etapas abaixo para instalar e verificar explicitamente um PyTorch com CUDA. As extensões pointnet2 / knn do GraspNet dependem do PyTorch e de um compilador CUDA com a versão correspondente — conclua todas as etapas antes de compilar.

Etapa 1: Confirme sua GPU

nvidia-smi

Continue apenas se uma GPU NVIDIA estiver listada. Sem uma GPU NVIDIA, você só pode usar a compilação de PyTorch para CPU, e os operadores CUDA do GraspNet não podem ser compilados nem executados.

Etapa 2: Verifique / instale o PyTorch

Primeiro verifique se o PyTorch já existe no ambiente atual:

python -c "import torch; print(torch.__version__, torch.version.cuda, torch.cuda.is_available())"
  • Se estiver instalado e torch.cuda.is_available() imprimir True, pule a instalação e vá para a Etapa 3.
  • Se ocorrer ModuleNotFoundError (não instalado), ou se torch.version.cuda for None (foi instalada a compilação para CPU), instale a compilação CUDA conforme mostrado abaixo. Use CUDA 13.0 como exemplo:
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu130

Escolha a versão CUDA em --index-url de acordo com a sua GPU:

GPUCompilação CUDA do PyTorch recomendada
Série RTX 50 (Blackwell, p. ex. RTX 5070 / 5090)cu128 ou mais recente (p. ex. cu130)
Séries RTX 40 / 30 (Ada / Ampere)cu121 ou cu118
Sem GPU NVIDIAcpu (somente CPU; o GraspNet não será executado)

Etapa 3: Instale o compilador CUDA correspondente ao seu PyTorch

pointnet2 / knn são extensões CUDA locais: a versão CUDA relatada 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 primeiro as duas versões:

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

Use como exemplo torch.version.cuda exibindo 13.0 e instale o compilador correspondente dentro do ambiente conda:

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

which nvcc       # deve apontar para $CONDA_PREFIX/bin/nvcc, não para /usr/bin/nvcc
nvcc --version   # deve corresponder a torch.version.cuda

cuda-nvcc fornece o compilador e cuda-cudart-dev fornece os cabeçalhos CUDA em targets/x86_64-linux/include; ambos são necessários. Depois que o ambiente conda é ativado, $CONDA_PREFIX/bin precede os caminhos do sistema, de modo que o nvcc do conda encobre automaticamente o nvcc 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 oferecer suporte à arquitetura da sua GPU (o CUDA 11.5 oferece suporte no máximo a sm_86; a série RTX 40 exige CUDA 11.8 ou posterior e a série RTX 50 exige CUDA 12.8 ou posterior), e compilações antigas do PyTorch podem ser incompatíveis com outras dependências do projeto, como versões recentes do ultralytics.

Etapa 4: Verifique

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

Quando as duas versões CUDA corresponderem e torch.cuda.is_available() imprimir True, a configuração do PyTorch está concluída e você pode 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.
# Observação: use o diretório targets do cuda-toolkit do conda para os cabeçalhos e as bibliotecas.
# Não misture o diretório nvidia/cu13 do pip (uma incompatibilidade de versão com o nvcc do conda causa erros de compilação).
export CUDA_HOME=$CONDA_PREFIX
export TORCH_CUDA_ARCH_LIST="12.0"
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 ao 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 (com o cuda-toolkit do conda, isso geralmente é $CONDA_PREFIX/targets/x86_64-linux/include). Se ocorrerem erros de cabeçalhos como '__NV_IS_DEVICE' was not declared in this scope, eles geralmente são causados pela mistura dos cabeçalhos nvidia/cu13 do pip com a versão do nvcc do conda — mude para os caminhos targets do conda acima e compile novamente.

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. Executar a demonstração de estimativa de câmera do GraspNet​

python scripts/graspnet_camera_demo.py

Este script executa a estimativa de pose de preensão 6D da 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 da GraspNet pela bbox do alvo.

Controles principais:

  • G / Space: executar inferência 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.

3

Etapa 3. Executar o programa de preensão robótica do 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 de IK antes de executar a sequência de movimentos de pré-preensão, preensão e recuo.

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

10. 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 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 (pointnet2_utils / knn_modules são importados como módulos de nível superior a partir dos diretórios de código-fonte, que também é a forma como models/ os importa; os scripts de preensão adicionam automaticamente os diretórios de código-fonte 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 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 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. A inferência do GraspNet informa RuntimeError: CPU not supported

Os operadores de amostragem em pointnet2 só suportam 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.

Contato​

Referências​

Loading Comments...