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

Adquira agora 🖱️

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

YOLO é uma família amplamente utilizada de modelos de detecção de objetos em tempo real que podem localizar e classificar alvos em uma única passagem direta. Este tutorial usa YOLO juntamente com a câmera de profundidade Orbbec Gemini 2 para construir uma demonstração funcional de preensão visual em desktop para o reBot Arm B601-DM, cobrindo preparação de ambiente, integração da câmera, calibração mão-olho e validação da preensão.

Funcionalidades 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 YOLO usadas para selecionar candidatos-alvo para experimentos de preensão mais complexos.

3. Integração leve de braço robótico e gripper
   O script principal de preensão reutiliza a interface RebotArm e integra IK, controle de trajetória e a máquina de estados do gripper.

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.

Especificações

O hardware para este tutorial é fornecido pela Seeed Studio

Parâmetro	Especificação
Modelo do Braço Robótico	reBot Arm B601-DM
Graus de Liberdade	6-DOF + Gripper
Modelo da Câmera	Orbbec Gemini 2
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	24V DC
Plataforma Host	PC com Ubuntu 22.04+
Versão Recomendada do Python	Python 3.10

Lista de Materiais (BOM)

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

Fiação

1. Conecte a Gemini 2 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 24V, a câmera e o braço robótico estejam todos conectados com segurança.
4. Defina as permissões:

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

Requisitos de Ambiente

Item	Requisito
Sistema Operacional	Ubuntu 22.04+
Python	3.10
Ambiente Recomendado	conda
Pasta de Trabalho Recomendada	rebot_grasp
Ambiente conda Recomendado	rebotarm

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

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

Você também pode usar o repositório de desenvolvimento atual:

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

Etapa 2. Crie e configure 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. Instale o SDK do braço robótico

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

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

Este projeto usa a câmera de profundidade Orbbec Gemini2. Se você usar uma câmera de profundidade diferente, instale o SDK correspondente à sua câmera e pule esta etapa.

A câmera de profundidade Orbbec Gemini2 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.

Para o primeiro uso, é recomendável instalar as regras udev:

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

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 reportada 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 reportada 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 reportar 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 ../../..

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.

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.

Além disso, dependências 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 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.

Consulte o repositório oficial graspnet-baseline para baixar o peso pré-treinado oficial da GraspNet e, em seguida, coloque checkpoint-rs.tar em:

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

Em seguida, verifique 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.

Etapa 6. Verificar as dependências

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

Para o uso inicial da câmera Orbbec, é recomendado executar scripts/install_udev_rules.sh dentro do diretório pyorbbecsdk instalado, caso contrário a câmera pode não abrir corretamente.

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.

python scripts/collect_handeye_eih.py

Antes de executá-la, 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.

O resultado da calibração é salvo em:

config/calibration/orbbec_gemini2/hand_eye.npz

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

Execução e Depuração

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 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.6
    pregrasp_offset_m: 0.080

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 do gripper

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ê só quiser validar a pose alvo sem mover o braço robótico:

python scripts/main.py --dry-run

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

Se reBotArm_control_py não estiver no local padrão, especifique-o em config/default.yaml:

robot:
  repo_root: null

Manter como null geralmente é suficiente porque o programa tentará detectar automaticamente sdk/reBotArm_control_py primeiro.

Fluxo principal do programa:

1. Inicializar o braço robótico e o gripper
2. Mover para a pose de pronto. Se você quiser alterar a pose inicial de pronto, modifique config/default.yaml:

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

3. Detectar alvos sobre a mesa em tempo real
4. Estimar a pose de preensão a partir do eixo curto
5. 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. 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 da GraspNet usando apenas a câmera RGB-D, sem se 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 a inferência da 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.

5. 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 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 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 da GraspNet para essa classe.

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 por IK

É recomendado 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 ao espaço de trabalho
• As 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, em seguida, reconstrua 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:

python -c "from pointnet2 import pointnet2_utils; print('Submodule 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 uma compilação do PyTorch que suporte sua arquitetura atual de CUDA/GPU e, em seguida, reconstrua 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 contra 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

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

Referências

• Guia Rápido do reBot Arm B601-DM
• Introdução ao Pinocchio e MeshCat para reBot Arm B601-DM
• Introdução ao reBot Arm B601-DM baseado em LeRobot e reBot 102 Leader
• Página de Produto Orbbec Gemini 2
• Orbbec SDK v2
• Guia da API do Orbbec SDK v2
• Repositório pyorbbecsdk
• Documentação do pyorbbecsdk
• Wrapper Orbbec ROS2
• graspnet/graspnet-baseline
• Graspnet(Anygrasp) Docs