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

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

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.
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.
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.
- Method 1 · Python SDK / OBB
- Method 2 · ROS 2 / YOLOE
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
- 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.
- 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. - 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. - 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 / 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 DC |
| 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.
- Se você encontrar problemas de permissão, execute:
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. 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.
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.
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
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
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.
- CPU (sem GPU NVIDIA)
- GPU NVIDIA (CUDA)
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())"
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"
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.
Confirme que o driver reconhece sua GPU antes de instalar o PyTorch com suporte a CUDA. O exemplo abaixo usa a build CUDA 12.8, que requer suporte tanto da arquitetura da sua GPU quanto do driver:
nvidia-smi
python -m pip install -r requirements-pytorch.txt --index-url https://download.pytorch.org/whl/cu128
python -c "import torch; print(torch.__version__, torch.__file__); print('CUDA build:', torch.version.cuda); print('CUDA available:', torch.cuda.is_available())"
nvidia-smi lista sua GPU, o caminho do PyTorch aponta para dentro do ambiente Conda ativo e CUDA available: True é impresso. Depois de verificar isso, selecione a GPU 0 em config/default.yaml:
yolo:
device: "0"
Use a lista oficial de versões do PyTorch para escolher uma build que ofereça suporte à sua GPU, ao driver e à versão do Python. Não escolha apenas pela série da GPU ou pelo número de CUDA exibido por nvidia-smi.
Se você precisar de uma versão diferente do PyTorch, atualize em conjunto todas as três versões compatíveis em requirements-pytorch.txt e no índice de download. A inferência padrão do YOLO usa wheels pré-compilados e não requer uma instalação separada do CUDA Toolkit. Um compilador CUDA correspondente é necessário ao compilar as extensões do GraspNet.
Se o CUDA não estiver disponível, verifique seu driver, a arquitetura da GPU e o wheel selecionado, ou siga a aba de CPU para verificar o fluxo de trabalho básico.
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__)"
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.
-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.
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.
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
- RealSense D435i / D405
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.
- Opção 1: Instalar via pip (recomendado)
- Opção 2: Obter a partir do GitHub
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.
Mantenha o ambiente rebotarm ativo. Instale as dependências de compilação e depois compile a extensão Python:
sudo apt-get update
sudo apt-get install -y cmake build-essential libusb-1.0-0-dev python3-dev
cd sdk
git clone https://github.com/orbbec/pyorbbecsdk.git
cd pyorbbecsdk
git checkout v2-main
python -m pip install pybind11
mkdir -p build
cd build
cmake .. -DCMAKE_BUILD_TYPE=Release \
-DPython3_EXECUTABLE="$(python -c 'import sys; print(sys.executable)')" \
-Dpybind11_DIR="$(python -m pybind11 --cmakedir)"
cmake --build . --parallel "$(nproc)"
cmake --install .
cd ..
Usuários da China continental podem substituir o comando de clone do GitHub acima por:
git clone https://gitee.com/orbbecdeveloper/pyorbbecsdk.git
Após a compilação, confirme que install/lib contém pyorbbecsdk*.so e as bibliotecas compartilhadas da Orbbec (em install/lib/pyorbbecsdk/ nas versões mais recentes) e, em seguida, instale o pacote Python. Consulte o guia oficial de compilação do Orbbec a partir do código-fonte para configuração do CMake e do conda.
pip install -e .
Configurar regras udev (Linux / Ubuntu)
Execute o seguinte a partir da raiz do repositório pyorbbecsdk clonado. Versões mais recentes usam o script de configuração de ambiente; versões mais antigas usam install_udev_rules.sh:
if [ -f scripts/env_setup/setup_env.py ]; then
python scripts/env_setup/setup_env.py
else
sudo bash scripts/install_udev_rules.sh
sudo udevadm control --reload-rules
sudo udevadm trigger
fi
Retorne à raiz do projeto antes de continuar com as etapas de verificação e execução:
cd ../..
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')"
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 do RealSense ou de regras udev, siga a documentação oficial do librealsense.
O D405 / D435i deve ser conectado a uma porta USB 3.0/3.2 (geralmente azul). Se for conectado a uma porta USB 2.0, o sintoma típico é: o sistema reconhece o dispositivo e pipeline.start() é bem-sucedido, mas os frames nunca chegam (Frame didn't arrive within ...). Verifique a velocidade negociada com:
lsusb -t # the camera line should show 5000M; 480M means it fell back to a USB 2.0 port — switch ports
O comando de verificação correspondente imprime pyorbbecsdk OK ou pyrealsense2 OK sem um ModuleNotFoundError.
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 |
| RealSense SDK | https://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.
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. 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. 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 melhorQ/Esc: sair
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:
- 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 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
- Detectar alvos sobre a mesa em tempo real.
- Estimar a pose de preensão a partir do eixo curto.
- Pressione
Gpara capturar o quadro atual e executar a preensão.
Teclas em tempo de execução:
G: agarrar o melhor alvo atualR: retomar a visualização ao vivoQ/Esc: sair
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:
- Inicialização da câmera e do braço, mover para a posição de prontidão
- Pré-visualização da câmera em tempo real + detecção de objetos YOLO e segmentação de instâncias
- Pressione
Gpara 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 levantá-la
- O braço coloca a banana na caixa e retorna à pose inicial
- Pressione
Qpara 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.
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.
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 ../../..
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 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.
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.
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 atualR: retoma a pré-visualização ao vivoQ/Esc: sair
Após a inferência, o Open3D pode visualizar a nuvem de pontos e os candidatos de preensão.
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.npznã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.
Método de preensão visual 2
1. Visão geral do projeto
Este fluxo de trabalho usa ROS 2 e YOLOE para detecção de objetos, preensão e posicionamento no reBot Arm B601-RS. Inicie o braço, a câmera de profundidade e os nós de preensão em terminais separados.
As câmeras de profundidade compatíveis são Orbbec Gemini 2 e RealSense D405 / D435i. O modelo do robô fornece extrínsecos predefinidos de montagem da câmera, portanto você pode pular a coleta de dados de calibração mão‑olho com uma placa de calibração. Use o suporte e a posição de montagem especificados para sua câmera. As tolerâncias de montagem e de peças impressas podem introduzir erros. Verifique o TF e a pose de destino antes de ajustar finamente os deslocamentos.
2. Configuração do ambiente
Este fluxo de trabalho usa Ubuntu 22.04, ROS 2 Humble, Python 3.10 do sistema e um ambiente Conda dedicado chamado yolo. Configure e compile o braço, o driver da câmera e os pacotes de preensão visual juntos no ambiente do sistema antes de criar o ambiente Conda para inferência com YOLOE.
Execute as etapas 1–4 em um terminal novo com o Conda inativo. Faça o source apenas da configuração do ROS do sistema e deixe qualquer workspace antigo sem source. Os terminais A, B, D e E também usam o ambiente do sistema. Use o ambiente yolo apenas no terminal C. Os arquivos de ambiente e comandos de instalação do fluxo de trabalho do Python SDK / OBB se aplicam somente àquele fluxo de trabalho.
Etapa 1. Instalar o workspace ROS 2 do braço robótico
Siga o guia reBot Arm B601-RS ROS 2 Integration para preparar o braço e instalar o ROS 2 Humble, as ferramentas de compilação, o workspace do braço e o SDK de baixo nível. Confirme que o workspace do braço é compilado com sucesso. Continue usando o mesmo workspace ~/rebotarm_ros2 para este guia.
source /opt/ros/humble/setup.bash
echo "$ROS_DISTRO"
sudo apt update
sudo apt install -y python3-rosdep python3-colcon-common-extensions git wget cmake build-essential
Espere que ROS_DISTRO retorne humble. Se o workspace já contiver qualquer um dos repositórios abaixo, verifique o branch e o conteúdo antes de continuar. Clone cada repositório apenas uma vez por caminho.
Etapa 2. Instalar a câmera
Expanda as instruções de configuração para sua câmera. Clone o Orbbec ROS 2 SDK no workspace e mude para o branch Instale as dependências nativas listadas no repositório do driver. A etapa 3 instala as dependências ROS em conjunto. Instale as regras udev. Esta compilação usa o backend RSUSB para evitar aplicar patches ao módulo UVC do kernel. Ela desativa exemplos e extensões GLSL. No librealsense Instale as dependências ROS do driver da câmera na etapa 3 e compile o workspace na etapa 4. Reconecte a câmera e execute Clique para expandir a configuração da Gemini 2
v2-main.cd ~/rebotarm_ros2/src
git clone https://github.com/xiehuangbao888/OrbbecSDK_ROS2.git
cd OrbbecSDK_ROS2
git checkout v2-mainsudo apt install -y libgflags-dev nlohmann-json3-dev libgoogle-glog-dev libdw-dev libssl-dev mesa-utils libgl1 \
ros-humble-image-transport-plugins ros-humble-compressed-image-transportcd ~/rebotarm_ros2/src/OrbbecSDK_ROS2/orbbec_camera/scripts
sudo bash install_udev_rules.sh
sudo udevadm control --reload-rules && sudo udevadm triggerClique para expandir a configuração da D405 / D435i
v2.58.1.sudo apt update
sudo apt install -y cmake build-essential git pkg-config libusb-1.0-0-dev libudev-dev libssl-dev v4l-utilscd ~
git clone https://github.com/realsenseai/librealsense.git
cd librealsense
git checkout v2.58.1
cd ~/librealsense
./scripts/setup_udev_rules.sh
BUILD_TOOLS=ON mantém disponíveis as ferramentas de linha de comando como rs-enumerate-devices. realsense-viewer é um exemplo gráfico.cd ~/librealsense &&
mkdir -p build && cd build &&
cmake .. -DCMAKE_BUILD_TYPE=Release \
-DFORCE_RSUSB_BACKEND=ON \
-DBUILD_EXAMPLES=OFF \
-DBUILD_TOOLS=ON \
-DBUILD_GRAPHICAL_EXAMPLES=OFF \
-DBUILD_GLSL_EXTENSIONS=OFF &&
cmake --build . --parallel 2 &&
sudo cmake --install . &&
sudo ldconfigOpenGL::GLv2.58.1, desativar apenas BUILD_GRAPHICAL_EXAMPLES ainda deixa os exemplos padrão vinculados a OpenGL::GL, o que pode impedir o CMake de gerar os arquivos de compilação. Se você encontrou esse erro com BUILD_EXAMPLES=ON, execute novamente os comandos acima para atualizar as opções no diretório build existente.
cd ~/rebotarm_ros2/src
git clone https://github.com/xiehuangbao888/realsense-ros.gitlsusb -t para verificar se ela está conectada via USB 3.x. A velocidade normalmente deve ser 5000M ou superior.
Etapa 3. Adicionar o pacote de preensão visual e instalar dependências ROS
cd ~/rebotarm_ros2/src/
git clone https://github.com/xiehuangbao888/rebot_visual_grasp.git
Inicialize o rosdep no primeiro uso. Se ele informar default sources list file already exists, prossiga diretamente para a atualização do índice.
sudo rosdep init
rosdep update
cd ~/rebotarm_ros2
rosdep install --from-paths src --ignore-src -r -y --rosdistro humble --skip-keys="librealsense2 orbbec_description realsense2_description"
Este comando instala as dependências de sistema declaradas pelos pacotes ROS clonados, incluindo diagnostic_updater, cv_bridge e xacro. A configuração do RealSense já instala librealsense2 a partir do código‑fonte. As outras duas chaves são pacotes de descrição de câmera. O código‑fonte clonado na etapa 2 fornece o pacote de descrição para sua câmera, e o pacote da outra câmera é opcional para esta configuração. Pular essas chaves evita reinstalar o SDK ou ficar bloqueado por dependências da outra câmera.
Espere ver All required rosdeps installed successfully. Resolva quaisquer erros de dependência restantes antes de compilar. Verifique a saída completa para confirmar que a instalação foi concluída com sucesso.
Etapa 4. Compilar o workspace
Use --symlink-install de forma consistente ao compilar este workspace, inclusive depois de adicionar o driver da câmera e o pacote de preensão visual.
Se você compilou anteriormente sem --symlink-install, mudar para ele pode gerar failed to create symbolic link e existing path cannot be removed: Is a directory. Diretórios da compilação anterior entram em conflito com os novos links simbólicos. Limpe os artefatos de compilação e compile novamente.
Abra um terminal novo com o Conda inativo e sem fazer source do install/setup.bash do workspace. Execute os comandos a seguir.
cd ~/rebotarm_ros2
rm -rf build install log
Isso remove os diretórios build, install e log do workspace e preserva src e outros arquivos de código‑fonte. Em seguida, compile novamente todo o workspace usando os comandos para sua câmera.
cd ~/rebotarm_ros2
source /opt/ros/humble/setup.bash
- RealSense D405 / D435i
- Orbbec Gemini 2
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release -DUSE_LIFECYCLE_NODE=OFF
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release
Depois que a compilação for bem‑sucedida, faça o source do workspace e verifique o pacote de preensão visual.
source ~/rebotarm_ros2/install/setup.bash
ros2 pkg prefix rebot_visual_grasp
Para RealSense, também execute ros2 pkg prefix realsense2_camera. Para Gemini 2, execute ros2 pkg prefix orbbec_camera. Espere ver o caminho de instalação do pacote selecionado no workspace atual.
Verificar o resultado da compilação
Verifique o Summary final. A compilação foi bem‑sucedida se todos os pacotes mostrarem Finished e nenhum mostrar Failed ou Aborted. Por exemplo, um workspace com o driver RealSense e o pacote de preensão visual pode exibir a seguinte saída.
Summary: 11 packages finished [33.8s]
4 packages had stderr output: realsense2_camera_msgs realsense2_description rebotarm_moveit_config rebotarm_msgs
As contagens de pacotes e os tempos de compilação variam conforme o workspace e o computador. packages had stderr output significa que esses pacotes escreveram na saída de erro padrão. Verifique os logs deles para ver o que aconteceu. Se a saída consistir apenas nos avisos do CMake descritos abaixo, a compilação ainda pode ser bem‑sucedida.
Se você fez source do install/setup.bash do workspace, removeu install e recompilou no mesmo terminal, talvez veja avisos sobre caminhos inexistentes em AMENT_PREFIX_PATH ou CMAKE_PREFIX_PATH. O terminal ainda mantém os caminhos de instalação anteriores. Se todos os pacotes forem compilados com sucesso, faça o source do novo install/setup.bash como mostrado acima e continue.
Para compilações subsequentes, use um terminal novo e faça source apenas de /opt/ros/humble/setup.bash antes de compilar. Se o ~/.bashrc fizer automaticamente o source do workspace, desative temporariamente essa linha antes de recompilar após uma limpeza.
Com --cmake-args -DUSE_LIFECYCLE_NODE=OFF, alguns pacotes podem informar Manually-specified variables were not used by the project: USE_LIFECYCLE_NODE. Esse aviso do CMake é esperado para pacotes fora do driver que usa a opção.
Depois de compilar o workspace ROS, crie o ambiente Conda de inferência na etapa 5. Em cada novo terminal, faça o source de ambos os arquivos de configuração antes de executar comandos ROS.
source /opt/ros/humble/setup.bash
source ~/rebotarm_ros2/install/setup.bash
Etapa 5. Configure o ambiente YOLOE
grasp_yolo chama Ultralytics YOLOE a partir do Python. Use o interpretador Python em um ambiente Conda dedicado para este nó.
Esta etapa se aplica a hosts x86_64 executando Ubuntu 22.04, ROS 2 Humble e Python 3.10. Crie o ambiente, escolha um backend PyTorch e, em seguida, instale as dependências de visão e de runtime Python para ROS. Verifique as dependências dentro do Conda separadamente, porque pacotes Python instalados via apt podem não estar disponíveis lá.
5.1 Crie o ambiente base
conda create -n yolo python=3.10
conda activate yolo
python -c "import sys; print(sys.executable)"
O caminho do Python termina em envs/yolo/bin/python dentro da sua instalação Conda. Se você já tiver um ambiente yolo, ative-o e continue com o PyTorch e as dependências do projeto abaixo.
5.2 Instale o PyTorch para o seu hardware
Ambas as abas instalam PyTorch 2.9.1, torchvision 0.24.1 e torchaudio 2.9.1 a partir de seus respectivos índices de pacotes. Selecione um backend no ambiente yolo ativo.
- CPU (sem NVIDIA GPU)
- NVIDIA GPU (CUDA)
Use esta opção em computadores com gráficos integrados Intel ou AMD, ou para verificar a configuração primeiro na CPU.
python -m pip install torch==2.9.1 torchvision==0.24.1 torchaudio==2.9.1 --index-url https://download.pytorch.org/whl/cpu
python -c "import torch; print(torch.__version__, torch.__file__); print('CUDA available:', torch.cuda.is_available()); print(torch.rand(2, 3))"
O caminho do PyTorch está dentro do ambiente Conda ativo e o comando imprime um tensor aleatório. CUDA available: False é esperado para este backend. Defina -p yolo_device:=cpu ao iniciar grasp_yolo. A taxa de quadros de inferência na CPU depende do modelo e do computador.
Verifique se o driver detecta a NVIDIA GPU antes de instalar uma build CUDA do PyTorch. O exemplo usa CUDA 12.8, que requer suporte tanto da arquitetura da GPU quanto do driver.
nvidia-smi
python -m pip install torch==2.9.1 torchvision==0.24.1 torchaudio==2.9.1 --index-url https://download.pytorch.org/whl/cu128
python -c "import torch; print(torch.__version__, torch.__file__); print('CUDA build:', torch.version.cuda); print('CUDA available:', torch.cuda.is_available()); print(torch.rand(2, 3, device='cuda'))"
nvidia-smi lista a GPU, o caminho do PyTorch está dentro do ambiente Conda ativo e o comando imprime CUDA available: True e um tensor CUDA. Use -p yolo_device:=0 ao iniciar grasp_yolo para selecionar a GPU 0.
Use a lista oficial de versões do PyTorch para escolher uma build que ofereça suporte à sua GPU, ao driver e à versão do Python. Considere os três ao selecionar uma build, já que a versão CUDA mostrada apenas por nvidia-smi é insuficiente. A wheel pré-compilada fornece o runtime CUDA para a inferência padrão do YOLOE.
Se CUDA não estiver disponível, verifique o driver, a arquitetura da GPU e a wheel selecionada, ou mude para a aba CPU para verificar a configuração básica. Se você alterar a versão do PyTorch, atualize as versões correspondentes do torchvision e torchaudio e os pins na próxima fase.
5.3 Instale e verifique as dependências do projeto
Depois de instalar um backend, mantenha yolo ativo e instale as dependências de visão e de runtime Python. O comando preserva as versões correspondentes do PyTorch e resolve em conjunto as restrições do NumPy e do OpenCV.
python -m pip install "ultralytics==8.4.202" "torch==2.9.1" "torchvision==0.24.1" "torchaudio==2.9.1" "numpy==1.26.4" "opencv-python==4.11.0.86" transforms3d pyyaml lark typeguard
# YOLOE open-vocabulary classes require the Ultralytics CLIP package.
python -m pip install git+https://github.com/ultralytics/CLIP.git
Se você já tiver feito o source do ROS 2, o pip pode informar que generate-parameter-library-py requer pyyaml e typeguard. Verifique se a linha final Successfully installed lista torch, torchvision e torchaudio. Instale ambas as dependências ausentes com o comando nesta fase e, em seguida, execute pip check e os testes de importação abaixo.
Se você compilou rebotarm_agent com a configuração padrão do workspace do braço, instale a dependência declarada dele para que pip check possa passar depois que você fizer o source do workspace completo.
python -m pip install fastmcp
fastmcp oferece suporte ao recurso Agent. Instale-o somente se o seu workspace contiver rebotarm_agent.
Este fluxo de trabalho fixa o NumPy em 1.26.4 e o OpenCV em 4.11.0.86. Mantenha esses pins e as versões correspondentes do PyTorch ao instalar ou atualizar o Ultralytics.
Se você executou pip install -U ultralytics antes de instalar separadamente o NumPy 1.26.4, o pip pode informar que opencv-python ... requires numpy>=2. Por exemplo, o OpenCV 5.0.0.93 requer NumPy 2, enquanto este fluxo de trabalho usa NumPy 1.26.4. Uma mensagem final Successfully installed ainda pode deixar dependências em conflito.
Mantenha o ambiente yolo ativo, instale as versões compatíveis e, em seguida, execute as verificações de dependência e de importação abaixo.
conda activate yolo
python -m pip install "numpy==1.26.4" "opencv-python==4.11.0.86" transforms3d
Mantenha apenas um pacote OpenCV que forneça cv2 no ambiente. Se você instalou múltiplas variantes como opencv-python, opencv-contrib-python ou os pacotes headless correspondentes, desinstale-as e reinstale o pacote fixado.
python -m pip uninstall -y opencv-python opencv-contrib-python opencv-python-headless opencv-contrib-python-headless
python -m pip install "numpy==1.26.4" "opencv-python==4.11.0.86" transforms3d
Verifique as dependências e valide o YOLOE
Faça o source da configuração ROS do sistema e do workspace compilado e, em seguida, use o Python do Conda ativo para verificar as dependências.
source /opt/ros/humble/setup.bash
source ~/rebotarm_ros2/install/setup.bash
python -m pip check
python -c "import sys, torch, torchvision, torchaudio, cv2, numpy, yaml, lark, transforms3d, clip; from ultralytics import YOLOE; print('Python:', sys.executable); print('PyTorch:', torch.__version__); print('OpenCV:', cv2.__version__); print('NumPy:', numpy.__version__); print('CUDA available:', torch.cuda.is_available()); print('YOLOE OK')"
python -c "import rclpy, cv_bridge, launch_ros; import rebot_visual_grasp.grasp_yolo; print('ROS grasp imports OK')"
pip check informa No broken requirements found. O caminho do Python está dentro do ambiente Conda ativo. A verificação de visão imprime OpenCV: 4.11.0, NumPy: 1.26.4 e YOLOE OK. A verificação de importação do ROS imprime ROS grasp imports OK. Espere CUDA available: False para o backend de CPU e True para o backend de GPU. Essas verificações apenas importam módulos e mantêm o braço inativo.
Se pip check informar launch-ros ... requires pyyaml, verifique se você instalou as dependências acima em yolo. Se informar rebotarm-agent ... requires fastmcp, instale a dependência Agent conforme descrito acima. Se as importações de rclpy, cv_bridge ou módulos do workspace falharem, verifique as dependências ROS do sistema, os resultados da compilação do workspace e ambos os comandos source. Use esses pacotes ROS a partir do sistema e do workspace.
Aguarde até que as verificações de dependência e de importação sejam aprovadas antes de baixar os pesos e iniciar os nós de grasping.
Baixe os pesos para ~/rebot_visual_model
mkdir -p ~/rebot_visual_model && cd ~/rebot_visual_model
# MobileCLIP is required by YOLOE set_classes and is about 242 MB.
wget -c https://github.com/ultralytics/assets/releases/download/v8.4.0/mobileclip2_b.ts
# The segmentation weights can download on first use. Download them here to verify the setup before launch.
wget -c https://github.com/ultralytics/assets/releases/download/v8.4.0/yoloe-26s-seg.pt
Verifique se o YOLOE consegue carregar os pesos e definir classes de texto a partir do diretório do modelo. Isso detecta arquivos de modelo ou dependências CLIP ausentes antes de você iniciar o braço.
cd ~/rebot_visual_model
python -c "from ultralytics import YOLOE; model = YOLOE('yoloe-26s-seg.pt'); model.set_classes(['cube', 'box']); print('YOLOE weights and text encoder OK')"
Espere YOLOE weights and text encoder OK. O primeiro carregamento pode levar mais tempo. Este comando carrega apenas o modelo de visão e mantém o braço desconectado. Resolva quaisquer pesos ou dependências ausentes antes de executar o projeto.
3. Execute o projeto
Antes de começar, confirme que o braço está ligado, a interface CAN é can0 e que o Gemini 2, D405 ou D435i está conectado via USB. Em seguida, ative 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
No terminal C, move_to_observation_on_start:=true move o braço para a pose de observação. O terminal D aciona o grasping e o posicionamento. Antes de começar, verifique a posição zero, o suporte de montagem, o workspace e os deslocamentos. Mantenha pessoas e obstáculos fora do caminho de movimento e esteja pronto para parar o braço.
Inicie os terminais A, B, C e D nessa ordem, mantendo os terminais anteriores em execução. Selecione os comandos de inicialização para sua câmera. Você também pode escrever um script de inicialização para lançar toda a pilha em conjunto.
Terminal A — Iniciar o braço e 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
Clique para expandir D435i
source /opt/ros/humble/setup.bash
source ~/rebotarm_ros2/install/setup.bash
ros2 launch rebot_visual_grasp bringup_with_d435i.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
source ~/rebotarm_ros2/install/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
Clique para expandir D435i
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:=640x480x30 \
rgb_camera.color_profile:=640x480x30
Terminal C — Mover para a pose de observação e iniciar a detecção YOLOE
Execute primeiro conda activate yolo ou ative o ambiente pelo nome real. O comando python usa o ambiente ativo e funciona tanto com Miniconda quanto com Miniforge. Os exemplos usam yolo_device:=cpu por padrão. Para inferência em GPU, passe na verificação de CUDA na etapa 5 e, em seguida, defina yolo_device:=0.Clique para expandir Gemini 2
conda activate yolo
source /opt/ros/humble/setup.bash
source ~/rebotarm_ros2/install/setup.bash
python -m rebot_visual_grasp.grasp_yolo --ros-args \
-p yolo_model:="$HOME/rebot_visual_model/yoloe-26s-seg.pt" \
-p target_class:="cube" \
-p place_class:="box" \
-p yolo_device:=cpu \
-p grasp_z_offset_m:=0.01 \
-p place_z_offset_m:=0.1 \
-p grasp_x_offset_m:=-0.02 \
-p grasp_y_offset_m:=0.002 \
-p move_to_observation_on_start:=true \
-p auto_publish_on_detect:=trueClique para expandir D405
conda activate yolo
source /opt/ros/humble/setup.bash
source ~/rebotarm_ros2/install/setup.bash
python -m rebot_visual_grasp.grasp_yolo --ros-args \
-p yolo_model:="$HOME/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:=cpu \
-p grasp_z_offset_m:=0.01 \
-p grasp_y_offset_m:=-0.005 \
-p place_z_offset_m:=0.1 \
-p grasp_x_offset_m:=-0.01 \
-p move_to_observation_on_start:=true \
-p auto_publish_on_detect:=trueClique para expandir D435i
conda activate yolo
source /opt/ros/humble/setup.bash
source ~/rebotarm_ros2/install/setup.bash
python -m rebot_visual_grasp.grasp_yolo --ros-args \
-p yolo_model:="$HOME/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:=cpu \
-p grasp_z_offset_m:=0.01 \
-p place_z_offset_m:=0.1 \
-p grasp_y_offset_m:=0.01 \
-p grasp_x_offset_m:=-0.04 \
-p move_to_observation_on_start:=true \
-p auto_publish_on_detect:=true
| Parameter | Description |
|---|---|
yolo_device:=cpu | Usar a CPU por padrão. Após verificar o CUDA, defina yolo_device:=0 para usar a GPU 0. |
target_class | Classe de texto YOLOE para o objeto a ser agarrado. Defina para corresponder ao objeto. As classes YOLO padrão são suportadas. |
place_class | Classe de texto YOLOE para o alvo de posicionamento. Defina para corresponder ao alvo. As classes YOLO padrão são suportadas. |
grasp_x_offset_m | Deslocamento para frente ou para trás em base_link. Um valor negativo move a preensão para trás. |
grasp_y_offset_m | Deslocamento lateral da preensão. 0.01 move a preensão 1 cm para a esquerda. Um valor negativo a move para a direita. |
grasp_z_offset_m | Ajuste da altura de preensão. O padrão é para a garra flexível, que é mais longa que a garra padrão. Ajuste esse valor para a altura da sua garra. |
place_z_offset_m | Altura extra acima do ponto de posicionamento na qual o braço solta o objeto. |
Terminal D — Acionar a preensão e o posicionamento
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, adicione o parâmetro de inicialização. Este exemplo aciona após 5 segundos.
ros2 launch rebot_visual_grasp grasp_go.launch.py trigger_delay_s:=5.0
Terminal E — Retornar para a posição inicial (opcional)
Em um desligamento normal, o controlador do braço tenta retornar o braço à sua posição inicial e desativar os motores. Após uma interrupção anormal ou falha de comunicação, o retorno automático à posição inicial não é confiável. Para retornar manualmente, mantenha o controlador em execução no terminal A e certifique-se de que o caminho de movimento esteja livre.
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
Referências
- reBot Arm B601-RS Quick Start
- reBot Arm B601-RS ROS2 Integration
- rebot_visual_grasp
- OrbbecSDK_ROS2
- Orbbec Gemini 2 Product Page
- Orbbec Development Resources
- Orbbec SDK v2
- Orbbec SDK v2 API Guide
- pyorbbecsdk Repository
- pyorbbecsdk Documentation
- Orbbec ROS2 Wrapper
- realsense-ros
- RealSense SDK
- graspnet/graspnet-baseline
- Graspnet(Anygrasp) Docs