Pular para o conteúdo principal

Introdução ao Controle de Posição MIT no reBot Arm B601-RS

License: MITPython VersionPlatformMIT Mode

6+1 DOF · RobStride · CAN @ 1 Mbps · Controle de Posição MIT · Proteção de Temperatura · Retorno Seguro para Zero · API Python de Código Aberto

traj_sim_geodesic

MotorBridge é um SDK CAN em Python para motores RobStride / Damiao. O rebot_control o encapsula com uma API de controle de posição MIT para o reBot Arm B601-RS: configuração em YAML, limites de velocidade por junta, proteção de temperatura MOS em três níveis e retorno suave para zero via Esc / Ctrl+C / stop().

Este tutorial guia você por: configuração do ambiente → configuração do CAN → execução de exemplos → uso do pacote como biblioteca.

Aviso Importante de Segurança
  • Este projeto fornece apenas APIs de controle — sem limites de junta por software ou limites de espaço de trabalho. Os ângulos de destino que você definir são enviados diretamente para os motores.
  • Mantenha o braço dentro de aproximadamente 70% do seu espaço de trabalho. Permanecer além do espaço de trabalho por longos períodos pode acionar a proteção contra travamento na junta 2 e o braço pode cair.
  • No primeiro uso, teste com ângulos pequenos e baixas velocidades, e mantenha o espaço de trabalho livre de pessoas e obstáculos.

Recursos​

  1. Controle de posição MIT
    Comandos de posição MIT padrão a 200 Hz; limites de velocidade por junta com suavização no laço de controle.

  2. 6+1 motores
    J1–J6 são juntas do braço; J7 (ID CAN 7) é o gripper de extremidade, controlado via set_joint_angles / set_joint_angle.

  3. Proteção de temperatura em três níveis
    Monitoramento em tempo real da temperatura do MOS: alarme e continua → superaquecimento com retorno lento para zero e depois desabilita → desabilitação de emergência (sem retorno para zero).

  4. Saída segura e retorno para zero
    Esc / Ctrl+C / arm.stop() acionam retorno suave para zero com smoothstep; um segundo Ctrl+C durante o retorno para zero aborta imediatamente e desabilita os motores.

  5. Configuração baseada em YAML
    Canal CAN, limites de temperatura, parâmetros de retorno para zero e kp/kd dos motores ficam em config/rebotarm_rs.yaml — ajuste sem alterar código.

  6. Pronto para uso como biblioteca
    Camadas bem definidas (config / API / exemplos); importe com from rebot import ReBotRSMITController.

Especificações​

O hardware para este tutorial é fornecido pela Seeed Studio.

ParâmetroEspecificação
Modelo do braçoKit Montado reBot Arm B601-RS com Gripper
DOF6+1 (incluindo gripper)
Raio de trabalho754,7 mm (com gripper) / 587,5 mm (sem gripper)
Carga útilNominal 2,5 kg / Máx. 5 kg
Faixa das juntasJ1: ±150° / J2: 220° ~ 0° / J3: 220° ~ 0° / J4: ±90° / J5: ±90° / J6: ±180° / Gripper: 345° ~ 0°
Repetibilidade0,1 mm
Peso6,7 kg
ServomotoresRobStride 06 × 3 / RobStride 00 × 4 (incluindo gripper)
ComunicaçãoBarramento CAN @ 1 Mbps
Tensão de alimentaçãoCC 48V
Fonte de alimentaçãoCC 48V 15A
Temperatura de operação-20°C ~ 50°C
ControlePC

Mapeamento dos motores neste projeto​

JuntaID CANModeloObservações
J11RS06Base
J22RS06
J33RS06
J44RS00
J55RS00
J66RS00Punho
J77RS00Gripper de extremidade

Capacidades de software (este repositório)​

CapacidadeStatus
Controle de posição MIT✅
Limites de velocidade por junta✅
Controle do gripper (ID CAN 7)✅
Monitoramento de temperatura MOS e proteção em três níveis✅
Retorno seguro para zero / desabilitação de emergência✅
Configuração em YAML✅
API de biblioteca Python✅
Cinemática direta / inversa (Pinocchio)❌ (veja reBotArm_control_py)
Simulação MeshCat❌ (veja o repositório acima)

Parâmetros dos motores das juntas​

ParâmetroRobStride 00RobStride 06
Tensão nominal48V48V
Corrente nominal4,7 Apk ± 10%14,3 Apk ± 10%
Corrente de pico15,5 Apk ± 10%57 Apk ± 10%
Torque nominal5 N.m11 N.m
Torque de pico14 N.m36 N.m
Velocidade nominal100 rpm ± 10%100 rpm ± 10%
Velocidade máxima em vazio315 rpm ± 10%480 rpm ± 10%
Relação de redução10 : 19 : 1
Interface de controleCAN @ 1 MbpsCAN @ 1 Mbps
Modos de controleMIT / Velocidade / Posição / TorqueMIT / Velocidade / Posição / Torque

Lista de Materiais (BOM)​

ItemQtdeIncluído
reBot Arm B601-RS1✅
Adaptador CAN (CANABLE / PCAN-USB, etc.)1✅
Fonte de alimentação (CC 48V 15A)1✅
Cabo USB-C1✅
Gripper1✅

Requisitos​

ItemRequisito
Python3.10+
SOUbuntu 22.04+ (recomendado)
Interface CANcan0 padrão
AlimentaçãoCC 48V 15A
Dependênciasmotorbridge, pyyaml; opcional pynput (tecla Esc)

Instalação​

Etapa 1. Clonar o repositório​

git clone https://github.com/LAN-GER/rebot_control.git
cd rebot_control

Etapa 2. Instalar dependências​

pip install motorbridge pynput pyyaml
dica

pynput habilita a escuta da tecla Esc. Sem ele, apenas a Esc é desativada; Ctrl+C e arm.stop() ainda funcionam.

Etapa 3. Configurar a interface CAN​

# List interfaces (PCAN-USB, etc.)
sudo modprobe peak_usb   # if using a PEAK adapter
ip -br link

# Set can0 to 1 Mbps (RobStride default)
sudo ip link set can0 down 2>/dev/null
sudo ip link set can0 up type can bitrate 1000000
cuidado

Após desconectar e reconectar um adaptador CAN USB, geralmente é necessário executar novamente os comandos ip link.

Etapa 4. (Opcional) Editar o arquivo de configuração​

Edite config/rebotarm_rs.yaml:

ChaveDescriçãoPadrão
can.channelNome da interface CANcan0
can.host_idID do host0xFD
control.control_hzTaxa de comandos MIT (não é a velocidade de movimento)200 Hz
control.telemetry_hzTaxa de leitura de temperatura2 Hz
temperatures.alarm_cLimite de alarme de temperatura80°C
temperatures.return_zero_cLimite de retorno para zero por superaquecimento125°C
temperatures.disconnect_cLimite de desabilitação de emergência140°C
return_zero.max_speed_deg_sVelocidade de pico normal de retorno para zero30°/s
return_zero.thermal_max_speed_deg_sVelocidade de pico térmica de retorno para zero30°/s
return_zero.min_time_sDuração mínima do retorno para zero3,0 s
return_zero.settle_time_sTempo de permanência em zero após o retorno0,30 s
motorsID / modelo do motor / kp / kd MITVeja o YAML

Chaves ausentes usam padrões do código; chaves desconhecidas geram erro para capturar erros de digitação.

Estrutura do código​

rebot_control/
├── config/
│   └── rebotarm_rs.yaml            # CAN / motors / temperature / return-to-zero
├── rebot/
│   ├── __init__.py                 # Public API
│   ├── config.py                   # Config loading and validation
│   └── controller.py               # ReBotRSMITController
└── examples/
    ├── _bootstrap.py               # Path setup + wait-for-target helpers
    ├── quick_start.py              # Tutorial 1: quick start
    ├── custom_config.py            # Tutorial 2: custom config
    ├── monitor_status.py           # Tutorial 3: monitor status
    ├── single_joint_adjust.py      # Tutorial 4: single joint + gripper
    ├── read_joint_angles.py        # Tutorial 5: read actual positions
    ├── stop_options.py             # Tutorial 6: stop options
    ├── recommended_structure.py    # Tutorial 7: recommended structure
    └── mit_position_control.py     # Full editable demo

Camadas:

  • Arquivo de configuração: fonte única de parâmetros ajustáveis.
  • Camada de configuração: load_config() → ControllerConfig.
  • Camada de API: lógica de controle sem valores de demonstração fixos no código.
  • Camada de exemplos: ângulos de destino, velocidades e fluxo de execução.

Como funciona​

Controle MIT e suavização de velocidade​

  • control_hz (padrão 200 Hz) define apenas a taxa de envio de comandos.
  • A velocidade real de movimento vem de set_max_speeds([...]) (graus/s).
  • set_joint_angles() atualiza apenas os alvos; o laço de controle eleva as posições de comando até os alvos dentro do limite de velocidade.
dica

Se você chamar stop() imediatamente após definir os alvos, pode ver quase nenhum movimento. Os exemplos usam wait_for_command_targets() (veja examples/_bootstrap.py) para esperar até que os ângulos de comando se aproximem dos alvos antes de retornar para zero.

Sequência de conexão e habilitação​

Dentro de connect(), a ordem é: registrar motores → mudar para modo MIT → habilitar → ler posições mecânicas atuais (para inicializar os alvos e evitar um salto repentino após habilitar). O mechPos (0x7019) da RobStride é confiavelmente legível após a habilitação.

Para leitura passiva de posição (Tutorial 5), chame disable_motors() após connect() para que você possa mover o braço manualmente e continuar lendo os ângulos.

Proteção de temperatura em três níveis​

Limite (padrão)Comportamento
≥ 80°CAlarme de temperatura (uma vez por motor por borda de sobretemperatura), continua em operação
≥ 125°CPara o movimento, retorno lento para zero na velocidade térmica de pico e depois desabilita
≥ 140°CDesabilitação imediata de emergência, sem retorno para zero

Retorno seguro para zero​

O retorno para zero usa uma trajetória smoothstep. Duração:

duration = max(min_time_s, per-joint time estimated from peak speed)

A velocidade de pico é max_speed_deg_s (normal) ou thermal_max_speed_deg_s (térmico). Ambas têm padrão de 30°/s; min_time_s tem padrão de 3,0 s.

Método de saídaComportamento
Esc / primeiro Ctrl+C / arm.stop()Retorno lento para zero → desabilitar → fechar CAN
Segundo Ctrl+C durante o retorno para zeroAborta o retorno para zero e desabilita imediatamente
Erro de comunicaçãoDesabilitação de emergência, sem retorno para zero

Unidades​

ContextoUnidades
API externa (ângulos, velocidades)graus, deg/s
Internos do MotorBridge MITradianos, rad/s

Tutoriais​

Execute todos os exemplos a partir da raiz do projeto. Cada script documenta o Movimento esperado no topo e imprime uma linha [Expected / 预期] na inicialização.

TutorialArquivoComando
1. Início rápidoexamples/quick_start.pypython3 examples/quick_start.py
2. Configuração personalizadaexamples/custom_config.pypython3 examples/custom_config.py
3. Monitorar statusexamples/monitor_status.pypython3 examples/monitor_status.py
4. Única junta + garraexamples/single_joint_adjust.pypython3 examples/single_joint_adjust.py
5. Ler posiçõesexamples/read_joint_angles.pypython3 examples/read_joint_angles.py
6. Opções de paradaexamples/stop_options.pypython3 examples/stop_options.py default
7. Estrutura do programaexamples/recommended_structure.pypython3 examples/recommended_structure.py
Demonstração completaexamples/mit_position_control.pypython3 examples/mit_position_control.py

1. Início rápido (quick_start.py)​

Movimento esperado: J1 se move para +20° a ~15°/s; outras juntas e a garra permanecem em 0°; depois retorno lento para zero e desabilitar.

python3 examples/quick_start.py

Fluxo: start() → set_max_speeds() → set_joint_angles() → aguardar o movimento → stop().

2. Arquivo de configuração personalizada (custom_config.py)​

python3 examples/custom_config.py
python3 examples/custom_config.py config/rebotarm_rs.yaml

Movimento esperado: J1 → +15° (~15°/s), outras em 0°, depois retorno para zero.

3. Monitorar enquanto executa (monitor_status.py)​

python3 examples/monitor_status.py

Movimento esperado: J1 → +30°; o terminal imprime continuamente alvo / enviado / temperatura do MOS. Pressione Esc ou Ctrl+C para sair e retornar para zero.

Observações:

  • Alvo vs enviado: os ângulos enviados ficam atrás dos alvos (suavização limitada por velocidade).
  • Temperatura: leia arm.last_temperatures; não há necessidade de consultar o CAN por conta própria.

4. Ajuste de junta única e garra (single_joint_adjust.py)​

python3 examples/single_joint_adjust.py

Alvos padrão:

J1J2J3J4J5J6J7 Garra
+25°+15°+15°-15°0°0°180°

joint_id: 1–6 são juntas do braço; 7 é a garra (ID CAN 7).

5. Ler posições reais (read_joint_angles.py)​

python3 examples/read_joint_angles.py

Movimento esperado:

  1. connect(): alterna para o modo MIT e habilita (estabelece comunicação), lê os ângulos atuais como sementes de alvo.
  2. disable_motors(): desabilita imediatamente para que você possa mover o braço manualmente.
  3. O terminal imprime os ângulos reais das juntas a ~30 Hz; os valores devem mudar quando você move o braço.
  4. Pressione Ctrl+C para sair; stop(return_to_zero=False) fecha o CAN sem retorno para zero.

Este exemplo não chama start(), portanto nenhuma thread de controle MIT é executada e nenhum alvo de movimento é enviado.

Fluxo de código:

arm.connect()           # MIT → enable → read current angles
arm.disable_motors()    # disable — arm can be moved by hand

while True:
    actual = arm.read_joint_angles()  # ~30 Hz
    print(actual)

# After Ctrl+C
arm.stop(return_to_zero=False, wait=True)
dica

read_joint_angles() acessa o CAN de forma síncrona (lê mechPos de todos os 7 motores em sequência), portanto a taxa alcançável depende do tempo de ida e volta no barramento. O exemplo mira 30 Hz; se cada leitura levar mais tempo, a taxa real será menor. Enquanto o controle MIT estiver em execução, use get_command_angles() para monitorar o movimento comandado em vez de chamar read_joint_angles() em alta frequência.

6. Opções de parada segura (stop_options.py)​

Cada modo primeiro move J1 para ~+20°, depois para de acordo com o modo:

python3 examples/stop_options.py default      # slow return-to-zero (recommended)
python3 examples/stop_options.py no_return    # disable without return-to-zero
python3 examples/stop_options.py async        # stop(wait=False) + wait_until_stopped()
python3 examples/stop_options.py emergency    # emergency disable, no return-to-zero
perigo

no_return / emergency deixam o braço em uma pose diferente de zero e desabilitam os motores. Certifique-se de que a área esteja segura; apoie o braço com a mão se necessário.

Demonstra try / except / finally para que stop() seja executado mesmo em caso de erros.

python3 examples/recommended_structure.py

Demonstração completa de parâmetros (mit_position_control.py)​

Edite TARGET_ANGLES (comprimento 7) e JOINT_SPEEDS_DEG_S no topo do arquivo e então execute:

python3 examples/mit_position_control.py

Padrão: J1 → +50° (20°/s), outras juntas e garra em 0°; o terminal mostra alvo / enviado / temperatura; Esc / Ctrl+C sai com retorno para zero.

perigo

O braço pode se mover rapidamente no modo MIT. Mantenha pessoas e equipamentos afastados e permaneça dentro de aproximadamente 70% da área de trabalho.

Uso como biblioteca​

Exemplo mínimo​

from rebot import ReBotRSMITController

arm = ReBotRSMITController()  # loads config/rebotarm_rs.yaml

arm.start(enable_esc=True)
arm.set_max_speeds([15.0] * 7)
arm.set_joint_angles([20.0, 0, 0, 0, 0, 0, 0])  # J1–J6 + gripper J7

# Wait for motion to finish before stop; see examples/quick_start.py
arm.stop()  # slow return-to-zero → disable → close CAN

Configuração personalizada e garra​

from rebot import (
    ReBotRSMITController,
    load_config,
    GRIPPER_JOINT_ID,
)

arm = ReBotRSMITController(load_config("config/rebotarm_rs.yaml"))
arm.start()
arm.set_max_speeds([20.0] * 7)
arm.set_joint_angles([25, 15, 15, -15, 0, 0, 0])
arm.set_joint_angle(GRIPPER_JOINT_ID, 180.0)  # gripper = J7

Leitura passiva de posição​

from rebot import ReBotRSMITController

arm = ReBotRSMITController()
arm.connect()           # MIT → enable → read current angles
arm.disable_motors()    # disable — move arm by hand

actual = arm.read_joint_angles()
print(actual)

arm.stop(return_to_zero=False, wait=True)  # close CAN, no return-to-zero

Ciclo de vida do controlador​

Controle de movimento MIT:

create → start() → set_max_speeds() → set_joint_angles() / set_joint_angle() → … → stop()

Leitura passiva de posição (sem movimento comandado):

create → connect() → disable_motors() → read_joint_angles() → … → stop(return_to_zero=False)

API principal​

Método / atributoDescrição
connect()Conecta o CAN, modo MIT, habilita, lê os ângulos atuais; chamado automaticamente por start()
disable_motors()Desabilita todos os motores sem fechar o CAN (para leitura passiva)
start(enable_esc=True, install_signal_handlers=True)Inicia as threads de controle e de temperatura
set_joint_angles(angles_deg)Define 7 ângulos alvo (graus)
set_joint_angle(joint_id, angle_deg)Define uma junta / garra (1–7)
set_max_speeds(speeds_deg_s)Define 7 velocidades máximas (deg/s)
get_target_angles() / get_command_angles()Ângulos alvo / de comando suavizados
read_joint_angles()Leitura síncrona das posições mecânicas reais (graus); usa CAN
last_temperaturesTemperatura do MOS por motor
is_stoppedIndica se o desligamento seguro foi concluído
stop(return_to_zero=True, wait=True)Para (retorno para zero por padrão)
request_stop(..., emergency=True)Parada avançada / desabilitação de emergência

Constantes exportadas: GRIPPER_MOTOR_ID = 7, GRIPPER_JOINT_ID = 7.

Perguntas frequentes (FAQ)​

  • Permission denied / não é possível abrir can0
    Certifique-se de que a interface CAN esteja up e que seu usuário possa acessar dispositivos de rede. Use sudo para ip link se necessário ou verifique as regras do udev.

  • Nenhuma resposta do motor / falha ao habilitar

    1. Confirme que o bitrate é 1 Mbps;
    2. Confirme se channel, host_id e os IDs dos motores em config/rebotarm_rs.yaml correspondem ao hardware;
    3. Execute novamente ip link após reconectar o USB CAN.

  • Ângulos definidos, mas o braço mal se move
    set_joint_angles() apenas atualiza os alvos. Defina set_max_speeds() razoáveis e aguarde até que os ângulos de comando se aproximem dos alvos antes de stop(). Veja examples/quick_start.py.

  • A garra não se move
    A garra é J7 / CAN ID 7. Passe 7 valores para set_joint_angles (o último é a garra) ou use set_joint_angle(7, angle).

  • Tempo limite ao ler posição / não é possível ler ângulos
    mechPos pode ser lido de forma confiável no modo MIT após habilitar. O Tutorial 5 usa connect() e depois disable_motors() para que você possa mover o braço manualmente e continuar lendo. Se ensure_mode ou leituras de parâmetros atingirem tempo limite, verifique a fiação CAN, a terminação e a alimentação dos motores.

  • Spam de alarme de temperatura
    Os alarmes são disparados por borda com histerese: um alarme por motor por evento de sobretemperatura; um novo alarme só ocorre depois que a temperatura cai abaixo de alarm_c - 2°C.

  • Proteção contra travamento da junta 2 / braço cai
    Frequentemente causado por permanecer além de ~70% da extensão da área de trabalho. Desligue e ligue novamente para limpar a proteção e reduza os ângulos de destino e o tempo de permanência.

  • Comportamento após erros de comunicação
    Em caso de falha de comunicação no loop de controle, o programa desabilita de emergência sem retorno ao zero para evitar movimento sob comunicação ruim.

  • Pinocchio / MeshCat / compensação de gravidade
    Este repositório é focado no controle de posição MIT. Para cinemática, simulação e compensação de gravidade, consulte o reBotArm_control_py e o guia de Pinocchio & MeshCat no Wiki da Seeed.

Contato​

Referências​

Loading Comments...