Pular para o conteúdo principal

reBot Arm B601-RS no LeRobot

Adquira agora

License: MITPython VersionPlatformPinocchio

Braço robótico de 6 DOF · Suporte a múltiplos motores · Solucionador de cinemática · Planejamento de trajetória · Totalmente open source

reBot Arm B601-RS é um projeto de braço robótico open source lançado pela Seeed, dedicado a reduzir a barreira para o aprendizado de inteligência incorporada. Abrimos todo o design estrutural e o código sem reservas, tornando a tecnologia de robótica acessível a todos.

LeRobot se dedica a fornecer modelos, conjuntos de dados e ferramentas para robótica no mundo real em PyTorch. Seu objetivo é reduzir a barreira de entrada da robótica, permitindo que todos contribuam e se beneficiem do compartilhamento de conjuntos de dados e modelos pré-treinados. O LeRobot integra metodologias de ponta validadas para aplicação no mundo real, com foco em aprendizado por imitação e aprendizado por reforço. Ele fornece um conjunto de modelos pré-treinados, conjuntos de dados com demonstrações coletadas por humanos e ambientes de simulação, permitindo que os usuários comecem sem a necessidade de montar um robô.

Star on GitHub4.2K

Este wiki fornece tutoriais de depuração para o reBot-DevArm e implementa coleta de dados e treinamento dentro do framework LeRobot.

cuidado

Os tutoriais da Seeed Studio são rigorosamente atualizados de acordo com a documentação oficial. Se você encontrar problemas de software ou de ambiente que não possam ser resolvidos, verifique primeiro o FAQ no final do artigo ou entre em contato com o atendimento ao cliente para entrar no grupo de discussão SeeedStudio LeRobot. Você também pode fazer perguntas aqui: LeRobot GitHub ou Discord Channel.

Ambiente inicial do sistema​

  • Ubuntu 22.04/Ubuntu 24.04
  • GPU NVIDIA com CUDA 12+ (opcional, para treinamento e inferência acelerados por GPU)
  • Python 3.12
  • Torch 2.6 (compilações para CPU podem executar fluxos de trabalho básicos; compilações com CUDA são necessárias para aceleração por GPU)

Instalar o LeRobot​

O LeRobot pode ser instalado e executado em máquinas apenas com CPU para fluxos de trabalho básicos. Se você precisar de treinamento ou inferência acelerados por GPU, confirme que seu computador possui uma GPU NVIDIA e, em seguida, instale as versões do PyTorch e Torchvision correspondentes à sua versão do CUDA.

1

1. Instalar o Miniforge​

cd ~
wget "https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-$(uname)-$(uname -m).sh"
bash Miniforge3-$(uname)-$(uname -m).sh

~/miniforge3/bin/conda init bash
source ~/.bashrc
2

2. Clonar o repositório LeRobot​

mkdir ~/rebot_lerobot
cd ~/rebot_lerobot
git clone https://github.com/Seeed-Projects/lerobot.git
3

3. Criar um ambiente Conda e instalar o LeRobot​

dica

Para detalhes sobre os pacotes de funções, consulte:

O repositório LeRobot inclui um pyproject.toml. Crie um ambiente Conda e instale todas as dependências.

cd ~/rebot_lerobot

# Create the conda environment (Python 3.12)
conda create -y -n lerobot python=3.12

# Activate the environment
conda activate lerobot

# Install the main LeRobot project in editable mode
pip install -e ./lerobot

# Add the dependency packages
pip install lerobot-teleoperator-rebot-arm-102
pip install lerobot-robot-seeed-b601
pip install motorbridge
4

4. Instalar dependências de vídeo​

ffmpeg é uma dependência de decodificação de vídeo. Instale-o com Conda:

conda install ffmpeg -c conda-forge
dica

Notas de versão:

  • Por padrão, o ffmpeg 7.X será instalado, o qual suporta o codificador libsvtav1.

  • Se você encontrar problemas de compatibilidade de versão, instale o ffmpeg 7.1.1:

    conda install ffmpeg=7.1.1 -c conda-forge

  • Verifique se o codificador libsvtav1 é suportado com ffmpeg -encoders | grep svtav1.

O Ubuntu x86 não requer nenhuma outra configuração de dependência de vídeo. Continue com o passo 5.

5

5. Verificar o PyTorch e o Torchvision​

Instalar o ambiente LeRobot com pip pode substituir o PyTorch e o Torchvision originais por compilações para CPU, portanto verifique o resultado no Python.

python3
import torch
print(torch.cuda.is_available())
exit()

Se a saída for False, o ambiente atual está usando a versão para CPU do PyTorch. Isso é esperado em computadores sem GPU NVIDIA, e você pode continuar com fluxos de trabalho básicos baseados em CPU, embora o treinamento seja muito mais lento. Se o seu computador tiver uma GPU NVIDIA e você precisar de aceleração por GPU, instale as versões do PyTorch e Torchvision correspondentes à sua versão do CUDA a partir do guia oficial do PyTorch. Nesse caso, a verificação final deve retornar True.

dica

Se você estiver usando um dispositivo Jetson, instale o PyTorch e o Torchvision com suporte a GPU de acordo com este tutorial.

As GPUs NVIDIA RTX série 50 exigem a versão de prévia do PyTorch com CUDA 12.8 ou posterior:

pip install --pre torch torchvision torchaudio --index-url https://download.pytorch.org/whl/nightly/cu128

Calibrar o braço robótico​

Em seguida, você precisa conectar a fonte de alimentação e o cabo de dados ao seu robô reBot B601-RS para calibração, a fim de garantir que os braços líder e seguidor tenham os mesmos valores de posição quando estiverem na mesma posição física. Essa calibração é essencial porque permite que uma rede neural treinada em um robô reBot B601-RS funcione em outro. Se você precisar recalibrar o braço robótico, exclua completamente os arquivos em ~/.cache/huggingface/lerobot/calibration/robots ou ~/.cache/huggingface/lerobot/calibration/teleoperators e recalibre o braço robótico. Caso contrário, aparecerá uma mensagem de erro. As informações de calibração do braço robótico serão armazenadas nos arquivos JSON neste diretório.

dica

Se você não conseguir se conectar ao seguidor, acesse o wiki de primeiros passos e tente usar a interface fornecida pelo motorbridge para testar se o braço robótico está funcionando corretamente.

O B601-RS só precisa ser calibrado uma vez após a montagem. Aqui está o comando de calibração. Consulte a figura para a posição zero (garra totalmente fechada).


# follower
sudo ip link set can0 down 2>/dev/null
sudo ip link set can0 type can bitrate 1000000
sudo ip link set can0 up

lerobot-calibrate \
    --robot.type=seeed_b601_rs_follower \
    --robot.port=can0 \
    --robot.id=follower1 \
    --robot.can_adapter=socketcan

Se você usar Jetson (Jetpack 6.x), use as instruções a seguir para encontrar o número da porta CAN correspondente ao seu Jetson.

for i in /sys/class/net/can*; do
    [ "$(basename "$(readlink -f "$i/device/driver" 2>/dev/null)")" = "pcan" ] && basename "$i"
done

saída:

cam2  # also maybe can0,can1,can x

O número da porta para todos os comandos subsequentes do seguidor deve corresponder à saída aqui.

Se o seu Jetson não tiver o driver PCAN, a comunicação falhará constantemente. Consulte o guia de instalação do driver PCAN para Jetson na seção Quick Start.

Teleoperar​

perigo

Todos os cenários de movimento do braço robótico exigem a mesma atenção!

Durante a teleoperação, se o braço robótico mestre-escravo sofrer desligamento de energia, mau contato de energia ou desconexão da linha de sinal, você deve primeiro parar o código do programa e retornar o braço robótico à sua posição inicial zero. Só então reconecte a fonte de alimentação e reinicie o programa. Isso evita que a desordem de dados cause fuga do braço robótico e possíveis riscos de segurança.

Primeiro conceda permissões às portas seriais:

# leader
sudo chmod 666 /dev/ttyUSB*
# follower
sudo ip link set can0 down 2>/dev/null
sudo ip link set can0 type can bitrate 1000000
sudo ip link set can0 up

Execute a teleoperação:

lerobot-teleoperate \
    --robot.type=seeed_b601_rs_follower \
    --robot.port=can0 \
    --robot.id=follower1 \
    --robot.can_adapter=socketcan \
    --teleop.type=rebot_arm_102_leader \
    --teleop.port=/dev/ttyUSB0 \
    --teleop.id=rebot_arm_102_leader

Adicionar câmeras​

As câmeras de profundidade RealSense podem fornecer percepção RGB-D para o LeRobot e são adequadas para tarefas como reconhecimento de objetos, reconstrução de nuvens de pontos e manipulação em mesa. Os modelos recomendados aqui são RealSense D405 e RealSense D435i.

RealSense D405

A RealSense D405 é uma câmera estéreo de profundidade de curto alcance projetada para tarefas de alta precisão em curta distância, como manipulação robótica em mesa, com faixa de trabalho típica de 7 cm a 50 cm.

RealSense D435i

A RealSense D435i combina detecção de profundidade, imagem RGB e um IMU, tornando-a adequada para aplicações de médio a curto alcance, como reconstrução 3D, SLAM e percepção de ambiente robótico.

1

Alternar para o branch da câmera

Etapa 1

O suporte atual à câmera está disponível no branch DepthCameraSupport:

git checkout DepthCameraSupport
git pull origin DepthCameraSupport

Confirme o branch atual:

git branch --show-current

Saída esperada:

DepthCameraSupport
2

Instalar RealSense

Etapa 2

Se você usar apenas RealSense:

pip install -e ".[realsense]"
3

Conceder permissões ao dispositivo USB

Etapa 3

sudo chmod a+rw /dev/bus/usb/*/*
4

Detectar câmeras

Etapa 4

lerobot-find-cameras realsense

Esta etapa exibirá:

  • Modelo da câmera
  • Número de série
  • Informações de USB
  • Configuração padrão de stream
5

Executar o exemplo RealSense

Etapa 5

Teste com duas RealSense:

lerobot-teleoperate \
    --robot.type=seeed_b601_rs_follower \
    --robot.port=can0 \
    --robot.id=follower1 \
    --robot.can_adapter=socketcan \
    --robot.cameras='{
    d435i_color: {
      type: realsense_d435i_color,
      serial_number_or_name: "419522072950",
      width: 640,
      height: 480,
      fps: 30,
      color_mode: rgb,
      color_stream_format: rgb8,
      rotation: 0,
      warmup_s: 1
    },
    d435i_depth: {
      type: realsense_d435i_depth,
      serial_number_or_name: "419522072950",
      width: 640,
      height: 480,
      fps: 30,
      max_depth_m: 2.0,
      depth_alpha: 0.2,
      rotation: 0,
      warmup_s: 5
    },
    d405_color: {
      type: realsense_d405_color,
      serial_number_or_name: "409122273421",
      width: 640,
      height: 480,
      fps: 30,
      color_mode: rgb,
      color_stream_format: rgb8,
      rotation: 0,
      warmup_s: 1
    },
    d405_depth: {
      type: realsense_d405_depth,
      serial_number_or_name: "409122273421",
      width: 640,
      height: 480,
      fps: 30,
      depth_alpha: 0.03,
      rotation: 0,
      warmup_s: 5
    }
  }' \
    --teleop.type=rebot_arm_102_leader \
    --teleop.port=/dev/ttyUSB0 \
    --teleop.id=rebot_arm_102_leader \
    --display_data=true
6

Revisar as configurações de parâmetros

Etapa 6

  • depth_alpha controla o fator de escala da imagem de profundidade e pode ser ajustado com base no resultado de exibição e na faixa de distância do alvo.
  • Se você conectar três ou mais câmeras de profundidade, é recomendável reduzir fps para 15 para melhorar a estabilidade geral.
  • Recomenda-se manter a resolução em 640x480 para um melhor equilíbrio entre estabilidade e desempenho em tempo real.

Coleta de conjunto de dados​

lerobot-record \
    --robot.type=seeed_b601_rs_follower \
    --robot.port=can0 \
    --robot.id=follower1 \
    --robot.can_adapter=socketcan \
    --robot.cameras="{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30, fourcc: "MJPG"}, side: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30, fourcc: "MJPG"}}" \
    --teleop.type=rebot_arm_102_leader \
    --teleop.port=/dev/ttyUSB0 \
    --teleop.id=rebot_arm_102_leader \
    --display_data=true \
    --dataset.repo_id=seeed_rebot_b601_rs/test \
    --dataset.num_episodes=5 \
    --dataset.single_task="Grab the black cube" \
    --dataset.push_to_hub=false \
    --dataset.episode_time_s=30 \
    --dataset.reset_time_s=30

Entre eles, repo_id pode ser modificado de forma personalizada, e push_to_hub=false. Por fim, o conjunto de dados será salvo no diretório ~/.cache/huggingface/lerobot na pasta inicial, onde a pasta seeed_rebot_b601_rs/test mencionada acima será criada.

Função Record

A função record fornece um conjunto de ferramentas para capturar e gerenciar dados durante a operação do robô.

1. Armazenamento de dados

  • Os dados são armazenados usando o formato LeRobotDataset e são gravados em disco durante a gravação.
  • Por padrão, o conjunto de dados é enviado para a sua página no Hugging Face após a gravação.
  • Para desativar o envio, use: --dataset.push_to_hub=False.

2. Checkpoint e retomada

  • Checkpoints são criados automaticamente durante a gravação.
  • Para retomar após uma interrupção, execute novamente o mesmo comando com: --resume=true

⚠️ Nota importante: Ao retomar, defina --dataset.num_episodes para o número de episódios adicionais a serem gravados (não o número total de episódios desejado no conjunto de dados).

  • Para começar a gravação do zero, exclua manualmente o diretório do conjunto de dados.

3. Parâmetros de gravação

Defina o fluxo da gravação de dados usando argumentos de linha de comando:

ParâmetroDescriçãoPadrão
--dataset.episode_time_sDuração por episódio de dados (segundos)60
--dataset.reset_time_sTempo de reset do ambiente após cada episódio (segundos)60
--dataset.num_episodesTotal de episódios a gravar50

4. Controles de teclado durante a gravação

Controle o fluxo de gravação de dados usando atalhos de teclado:

TeclaAção
→ (Seta para a direita)Encerrar antecipadamente o episódio atual/resetar; ir para o próximo.
← (Seta para a esquerda)Cancelar o episódio atual; regravá-lo.
ESCParar a sessão imediatamente, codificar os vídeos e enviar o conjunto de dados.
dica

Se as teclas do seu teclado não estiverem respondendo, talvez seja necessário fazer o downgrade da sua versão do pynput, por exemplo instalando a versão 1.6.8.

pip install pynput==1.6.8

Dicas para coletar dados

  • Sugestão de tarefa: Agarrar objetos em diferentes locais e colocá-los em uma caixa.
  • Escala: Grave ≥50 episódios (10 episódios por local).
  • Consistência:
    • Mantenha as câmeras fixas.
    • Mantenha o mesmo comportamento de preensão.
    • Garanta que os objetos manipulados estejam visíveis nas imagens das câmeras.
  • Progressão:
    • Comece com preensões confiáveis antes de adicionar variações (novos locais, técnicas de preensão, ajustes de câmera).
    • Evite aumentar a complexidade rapidamente para prevenir falhas.

💡 Regra geral: Você deve ser capaz de executar a tarefa apenas olhando para as imagens da câmera na tela.

Se quiser se aprofundar neste tópico importante, você pode conferir o post no blog que escrevemos sobre o que torna um conjunto de dados bom.

Solução de problemas

Problema específico do Linux: Se as teclas Seta para a direita/Seta para a esquerda/ESC não responderem durante a gravação:

Visualizar o conjunto de dados​

echo ${HF_USER}/rebot_test

Se você enviou os dados, também pode visualizá-los localmente com o seguinte comando:

lerobot-dataset-viz \
  --repo-id ${HF_USER}/rebot_test \
  --episode-index 0 \
  --display-compressed-images=false

Se você usou --dataset.push_to_hub=false e não enviou os dados, também pode visualizá-los localmente com:

lerobot-dataset-viz \
  --repo-id seeed_rebot_b601_rs/test \
  --episode-index 0 \
  --display-compressed-images=false

Aqui, seeed_rebot_b601_rs/test é o nome personalizado de repo_id definido durante a coleta de dados.

Reproduzir um episódio​

dica

Instável, pode ser ignorado ou testado.

Agora, tente reproduzir o primeiro conjunto de dados no seu robô:

lerobot-replay \
    --robot.type=seeed_b601_rs_follower \
    --robot.port=can0 \
    --robot.can_adapter=socketcan \
    --robot.id=follower1 \
    --dataset.repo_id=seeed_rebot_b601_rs/test \
    --dataset.episode=0

Neste ponto, o robô deve executar as mesmas ações que você realizou durante a teleoperação na gravação.

Treinamento e avaliação​

Consulte o tutorial oficial ACT

Treinamento

Para treinar uma política para controlar seu robô, use o script python -m lerobot.scripts.train. Alguns parâmetros são obrigatórios. Aqui está um comando de exemplo:

lerobot-train \
  --dataset.repo_id=${HF_USER}/rebot_test \
  --policy.type=act \
  --output_dir=outputs/train/act_rebot_test \
  --job_name=act_rebot_test \
  --policy.device=cuda \
  --wandb.enable=false \
  --steps=300000

Se você quiser treinar em um conjunto de dados local, certifique-se de que o repo_id corresponda ao nome usado durante a coleta de dados e adicione --policy.push_to_hub=false.

lerobot-train \
  --dataset.repo_id=seeed_rebot_b601_rs/test \
  --policy.type=act \
  --output_dir=outputs/train/act_rebot_test \
  --job_name=act_rebot_test \
  --policy.device=cuda \
  --wandb.enable=false \
  --policy.push_to_hub=false \
  --steps=300000
dica

Se você estiver usando uma GPU RTX série 50, precisa adicionar --dataset.video_backend=pyav para contornar APIs ausentes na versão de prévia do torchvision. O comando de treinamento fica:

lerobot-train \
  --dataset.repo_id=seeed_rebot_b601_rs/test \
  --dataset.video_backend=pyav \
  --policy.type=act \
  --output_dir=outputs/train/act_rebot_test \
  --policy.device=cuda \
  --wandb.enable=false \
  --policy.push_to_hub=false \
  --steps=300000

Explicação do comando

  • Especificação do conjunto de dados: Fornecemos o conjunto de dados por meio do parâmetro --dataset.repo_id=${HF_USER}/rebot_test.
  • Passos de treinamento: Modificamos o número de passos de treinamento usando --steps=300000. O algoritmo usa por padrão 800000 passos; ajuste com base na dificuldade da sua tarefa. Você pode defini-lo como um valor maior se não tiver certeza, pois checkpoints são gerados durante o treinamento e a avaliação pode ser retomada a partir de qualquer checkpoint.
  • Tipo de política: Fornecemos a política com policy.type=act. Da mesma forma, você pode alternar entre políticas como [act, diffusion, pi0, pi0fast, sac, smolvla]. Isso carregará a configuração de configuration_act.py. Importante: essa política se adaptará automaticamente aos estados dos motores do seu robô, às ações dos motores e ao número de câmeras, pois essas informações já estão armazenadas no seu conjunto de dados.
  • Seleção de dispositivo: Fornecemos policy.device=cuda porque estamos treinando em uma GPU Nvidia, mas você pode usar policy.device=mps para treinar em Apple Silicon.
  • Ferramenta de visualização: Fornecemos wandb.enable=true para visualizar gráficos de treinamento usando o Weights and Biases. Isso é opcional, mas, se você usar, certifique-se de ter feito login executando wandb login.

Avaliação

Você pode usar a função record de lerobot/record.py, mas com um checkpoint de política como entrada. Por exemplo, execute este comando para gravar 10 episódios de avaliação:

lerobot-record \
  --robot.type=seeed_b601_rs_follower \
  --robot.port=can0 \
  --robot.can_adapter=socketcan \
  --robot.cameras='{ front: {type: opencv, index_or_path: 0, width: 640, height: 480, fps: 30, fourcc: "MJPG"}, side: {type: opencv, index_or_path: 2, width: 640, height: 480, fps: 30, fourcc: "MJPG"} }' \
  --robot.id=follower1 \
  --display_data=false \
  --dataset.repo_id=seeed/eval_test123 \
  --dataset.single_task="Put lego brick into the transparent box" \
  --policy.path=outputs/train/act_rebot_test/checkpoints/last/pretrained_model
  1. O parâmetro --policy.path indica o caminho para o arquivo de pesos dos resultados do treinamento da sua política (por exemplo, outputs/train/act_rebot_test/checkpoints/last/pretrained_model). Se você enviar o arquivo de pesos do resultado do treinamento do modelo para o Hub, também poderá usar o repositório do modelo (por exemplo, ${HF_USER}/act_rebot_test).
  2. O nome do conjunto de dados dataset.repo_id começa com eval_. Essa operação gravará separadamente vídeos e dados durante a avaliação, que serão salvos na pasta que começa com eval_, como seeed/eval_test123.
  3. Se você encontrar File exists: 'home/xxxx/.cache/huggingface/lerobot/xxxxx/seeed/eval_xxxx' durante a fase de avaliação, exclua primeiro a pasta que começa com eval_ e depois execute o programa novamente.
  4. Ao encontrar mean is infinity. You should either initialize with stats as an argument or use a pretrained model, observe que palavras-chave como front e side no parâmetro --robot.cameras devem ser estritamente consistentes com as usadas ao coletar o conjunto de dados.

FAQ​

  • Se você estiver seguindo este tutorial de documentação, faça o git clone do repositório GitHub recomendado https://github.com/Seeed-Projects/lerobot.git. O repositório recomendado nesta documentação é uma versão estável verificada; o repositório oficial do LeRobot é continuamente atualizado para a versão mais recente, o que pode causar problemas imprevistos, como versões de conjunto de dados diferentes, comandos diferentes, etc.

  • Se você encontrar:

    Could not connect on port "/dev/ttyUSB0" or "/dev/ttyACM0"

    E você conseguir ver que o dispositivo existe ao executar ls /dev/ttyUSB* ou ls /dev/ttyACM*, isso significa que você esqueceu de conceder permissões à porta serial. Digite sudo chmod 666 /dev/ttyUSB* /dev/ttyACM* no terminal para corrigir isso.

  • Se você encontrar:

    No valid stream found in input file. Is -1 of the desired media type?

    Instale o ffmpeg 7.1.1 usando conda install ffmpeg=7.1.1 -c conda-forge.

  • Treinar ACT em 50 conjuntos de dados leva aproximadamente 6 horas em um laptop com uma RTX 3060 (8GB), e cerca de 2–3 horas em computadores com GPUs RTX 4090 ou A100.

  • Durante a coleta de dados, garanta que a posição da câmera, o ângulo e a iluminação ambiente sejam estáveis. Reduza a quantidade de fundo instável e de pedestres capturados pela câmera, pois mudanças excessivas no ambiente de implantação podem fazer com que o braço robótico não consiga agarrar corretamente.

  • Para o comando de coleta de dados, certifique-se de que o parâmetro num-episodes esteja configurado para coletar dados suficientes. Não pause manualmente no meio do processo, pois a média e a variância dos dados são calculadas somente após a conclusão da coleta, e são necessárias para o treinamento.

  • Se o programa indicar que não consegue ler dados de imagem da câmera USB, certifique-se de que a câmera USB não esteja conectada por meio de um hub. A câmera USB deve estar conectada diretamente ao dispositivo para garantir alta velocidade de transmissão de imagem.

dica

Se você encontrar problemas de software ou de dependências de ambiente que não consiga resolver, além de verificar a seção de FAQ no final deste tutorial, relate o problema prontamente na plataforma LeRobot ou no canal LeRobot no Discord.

Referências​

Seeed Studio Wiki em inglês: Como usar o braço robótico SO100Arm no Lerobot

Projeto TheRobotStudio: SO-ARM10x

Projeto Huggingface: LeRobot

Dnsty: Jetson Containers

Jetson AI Lab

Diffusion Policy

ACT or ALOHA

TDMPC

VQ-BeT

Suporte técnico e discussão sobre o produto​

Obrigado por escolher nossos produtos! Estamos aqui para oferecer diferentes tipos de suporte para garantir que sua experiência com nossos produtos seja a mais tranquila possível. Oferecemos vários canais de comunicação para atender a diferentes preferências e necessidades.

Loading Comments...