Pular para o conteúdo principal

Primeiros Passos com os Motores MyActuator X Series

Este artigo apresentará como começar a usar os motores da série MyActuator e como utilizá-los com C++ e Python no reComputer Mini Jetson Orin.

Compre Agora 🖱

Especificações​

Aqui está a tabela completa com todos os parâmetros preenchidos para todos os modelos de motor:

ParâmetroX2-7X4-10X4-36X8-120X12-320X15-450
Relação de Engrenagem28.1712.63619.612020.25
Tensão de Entrada (V)242424484872
Velocidade em Vazio (RPM)178317111158125108
Corrente de Entrada em Vazio (A)110.91.62.73.5
Velocidade Nominal (RPM)1422388312710098
Torque Nominal (N.m)2.5410.54385145
Potência de Saída Nominal (W)371001005749001480
Corrente de Fase Nominal A(rms)37.86.117.63025
Torque de Pico (N.m)71034120320450
Corrente de Fase de Pico A(rms)8.119.521.543.810069.2
Eficiência (%)6369.563.1797582.4
Constante de Força Contraeletromotriz do Motor (Vdc/Krpm)4.36619.217.929.9
Constante de Torque do Módulo (N.m/A)0.80.81.92.43.35.8
Resistência de Fase do Motor (Ω)0.610.320.350.180.120.08
Indutância de Fase do Motor (mH)0.130.140.170.310.050.14
Par de Polos131313102020
Conexão TrifásicaY
Torque de Retorno (N.m)0.40.81.143.213.84
Folga (Arcmin)121010101010
Tipo de Rolamento de SaídaRolamentos de Esferas de Ranhura ProfundaRolamentos de Rolos Cruzados
Carga Axial (KN)0.251.21.344.55.4
Tensão Axial (KN)0.251.21.314.55.4
Carga Radial (KN)11.21.54.556
Inércia (Kg.cm²)0.170.250.31.512.931.6
Tipo de Encoder e InterfaceEncoder Duplo ABS-17BIT (Entrada) / 17-18BIT (Saída)
Precisão de Controle (Grau)<0.01
ComunicaçãoCAN BUS / EtherCAT
Peso (Kg)0.260.330.361.402.373.50
Classe de IsolaçãoF

Convenções de Nomenclatura da Série RMD-X V4​

  • RMD: Nome da marca R-Redutor M-Motor D-Drive
  • X2: X Representa o Nome da Série: Atuador Planetário Integrado, 2 representa o número do modelo do motor, por exemplo: X2 X4 X6 X8 etc.
  • P28: Relação de engrenagem planetária, por exemplo: P12 P28 P32 etc.
  • 7: Torque de pico 7N.m
  • E: Comunicação E: CAN BUS & EtherCAT

Principais Características​

  1. CAN BUS & EtherCAT
  2. Rolamentos de Rolos Cruzados
  3. Encoder Duplo
  4. Alta Densidade de Torque
  5. Alta Precisão
  6. Design Vazado

Primeiros Passos​

Preparação do Ambiente Antes do Uso​

Sistema Windows no PC

  • Baixe o manual de produto correspondente.

  • Baixe o MYACTUATOR_Setup Software_V4.0.zip

  • Extraia MYACTUATOR_Setup Software_V4.0.zip e instale o seguinte:

    • USBCAN_AllInOne_x86_x64_2.0.0.1.exe localizado no diretório Required Runtime Environment\ZLGUSBCAN_Driver
    • MSVBCRT.AIO.2019.10.19.X86 X64.exe localizado no diretório Required Microsoft Runtime Libraries

Conectar o Circuito​

Aqui selecionamos o motor X4-36, e seu diagrama de interface é mostrado abaixo.

Definição da PortaDescrição da Porta
① VCCAlimentação positiva
② GNDAlimentação negativa
③ CAN_HTerminal de sinal de rede CAN_H
④ CAN_LTerminal de sinal de rede CAN_L
⑤ EtherCAT_INTerminal de entrada EtherCAT
⑥ EtherCAT_OUTTerminal de saída EtherCAT
⑦ T+O mestre envia comandos de controle para o módulo
⑧ T-O módulo envia o feedback de status para o mestre
⑨ R+O mestre reflete os dados de status do módulo
⑩ R-O módulo reflete os comandos de controle do mestre

Aqui, usamos o método de comunicação CAN, que requer uma interface USB-CAN adicional para depuração via computador superior no Windows.

Aqui, você precisa fornecer uma fonte de alimentação separada de 24V para o motor e conectar o cabo USB ao seu computador.

Use o MYACTUATOR Setup Software 250206.exe para Testar o Motor​

Definir ID e ConexãoLer Informações do MotorCalibrar o motorCalibrar o motorExecutar um teste de rotação do motor.
fig1fig2fig3fig4fig5
O ID padrão do motor é 1. Insira o ID como 1 e clique em "Connect".Após a conexão, clique em "Read" para obter as informações atuais do motor.Para uso pela primeira vez, clique em "Calibrate Motor" para realizar a calibração.Após a calibração, clique em "Read" e "Save".Agora você pode testar diferentes modos de controle do motor na seção Motor Running.

Para mais detalhes sobre os recursos, consulte o ​Setup Software Instruction Manual - V3.0.pdf incluído no arquivo ​MYACTUATOR_Setup Software_V4.0.zip.

Controle o Motor Usando o ​reComputer Mini Jetson Orin.​

Atualmente, as interfaces de comunicação CAN mais comuns para motores no mercado usam XT30 (2+2) e conectores JST. Nossos dispositivos reComputer Mini Jetson Orin e reComputer Robotics estão equipados com duplas portas XT30 (2+2) e interfaces CAN baseadas em JST, proporcionando compatibilidade perfeita.

reComputer Mini:

reComputer Robotics

Para mais detalhes sobre o uso de CAN, você pode consultar este wiki.

Habilitar Interfaces CAN​

Passo 1: Antes de usar CAN0 e CAN1, remova a tampa inferior e ajuste ambos os resistores de terminação de 120Ω para a posição ​ON.

Passo 2: Conecte o motor diretamente ao CAN0 do reComputer Mini através da interface XT30 (2+2).

Esta é a interface CAN0 para o reComputer Mini

perigo

Esta fonte de alimentação é apenas para aprendizado e teste de um único motor. Para múltiplos motores, projete uma placa de alimentação separada e isole a fonte de alimentação do Jetson da fonte de alimentação do motor para evitar que uma corrente alta passe diretamente pelo Jetson.

Habilitar comunicação CAN do Jetson​

Abra um terminal e insira o seguinte comando para colocar o pino GPIO em nível alto e ativar o CAN0:

gpioset --mode=wait 0 43=0

Se você estiver usando o CAN1 com interface JST, coloque o pino 106 em nível alto.

gpioset --mode=wait 0 106=0

Mantenha este terminal aberto, abra um novo terminal e configure o CAN0.

sudo modprobe mttcan
sudo ip link set can0 type can bitrate 1000000
sudo ip link set can0 up

Construir ambiente Python e C++​

Passo 1: Faça o git clone do SDK.

git clone https://github.com/ZhuYaoHui1998/myactuator_rmd.git

Passo 2: Este SDK de driver requer a instalação das seguintes dependências. Para Debian Linux elas podem ser instaladas via apt da seguinte forma:

sudo apt-get install -y build-essential cmake
sudo apt install linux-modules-extra-5.15.0-1025-nvidia-tegra # For Jetson Jetpack 6.0

Caso queira usar os bindings Python, você terá que instalar adicionalmente Python 3, pip e pybind11:

sudo apt-get install -y python3 python3-pip python3-pybind11 python3-setuptools

Depois de instalar as dependências, você deverá instalar o SDK do driver como uma biblioteca C++ ou como um pacote Python, conforme descrito nos passos a seguir. Ambos usarão CMake para compilar o código C++.

Compilando a biblioteca C++​

Para compilar o SDK do driver em C++, abra um novo terminal dentro desta pasta e execute os seguintes comandos. Em versões mais antigas do Linux, a compilação pode falhar com a mensagem de erro error: 'const struct can_frame' has no member named 'len' e você terá que aplicar a modificação de código discutida na issue 5.

cd ~/myactuator_rmd
mkdir build
cd build
cmake .. -D PYTHON_BINDINGS=on
make -j $(nproc)
sudo make install

A flag PYTHON_BINDINGS (por padrão desligada) compila os bindings Python adicionalmente à biblioteca C++. Caso você esteja interessado apenas em usar a biblioteca C++, sinta-se à vontade para deixá-la desligada. Ao compilar os bindings Python desta forma, eles serão compilados como uma biblioteca compartilhada, mas não serão instalados. Isso significa que você terá que instalar a biblioteca manualmente ou só poderá importá-la localmente dentro da pasta de compilação.

Para desinstalar o pacote novamente, você pode usar o seguinte comando xargs rm < install_manifest.txt.

Compilando a biblioteca Python​

Para compilar e instalar os bindings Python para este SDK, abra um novo terminal dentro da pasta principal e execute o seguinte comando:

cd ~/myactuator_rmd
pip3 install .

Isso usará o setup.py para invocar o CMake e instalar os bindings como uma biblioteca C++. Se quiser removê-los novamente, basta executar pip3 uninstall myactuator-rmd-py.

Controle usando C++​

  1. Criar estrutura de diretórios do projeto
    Crie o diretório do seu projeto dentro do diretório src do código, por exemplo, nomeie-o como myactuator_example, e crie uma pasta src dentro deste subdiretório.
cd ~/myactuator_rmd
mkdir -p ~/myactuator_rmd/src/myactuator_example/src  
cd ~/myactuator_rmd/src/myactuator_example
  1. Escrever CMakeLists.txt
    No arquivo ~/myactuator_rmd/src/myactuator_example/CMakeLists.txt, escreva o seguinte conteúdo:
touch CMakeLists.txt
cmake_minimum_required(VERSION 3.20)  
project(myactuator_example)  

# Find the myactuator_rmd library  
find_package(myactuator_rmd REQUIRED)  

# Create executable  
add_executable(myactuator_node  
src/main.cpp  
)  

# Use C++17 standard  
target_compile_features(myactuator_node PUBLIC  
cxx_std_17  
)  

# Link the myactuator_rmd library  
target_link_libraries(myactuator_node PUBLIC  
myactuator_rmd::myactuator_rmd  
)
  1. Escrever main.cpp
    No arquivo ~/myactuator_rmd/src/myactuator_example/src/main.cpp, escreva o seguinte código:
touch src/main.cpp
#include <cstdlib>
#include <iostream>
#include <myactuator_rmd/myactuator_rmd.hpp>

int main() {
myactuator_rmd::CanDriver driver {"can0"};
myactuator_rmd::ActuatorInterface actuator {driver, 1};

std::cout << actuator.getVersionDate() << std::endl;
std::cout << actuator.sendPositionAbsoluteSetpoint(180.0, 500.0) << std::endl;
actuator.shutdownMotor();
return EXIT_SUCCESS;
}
  1. Compilar o projeto
cd ~/myactuator_rmd/src/myactuator_example
mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release
make
  1. Executar o programa
sudo ./myactuator_node

Pré-requisitos

  • A interface CAN can0 deve estar devidamente configurada (garanta que o seu motor e o barramento CAN estejam corretamente conectados).
  • A biblioteca myactuator_rmd deve estar devidamente instalada (se não estiver, instale-a primeiro).

Para mais detalhes de implementação em C++, consulte todo o conteúdo em myactuator_rmd.hpp. Forneceremos uma introdução detalhada aos métodos de uso em Python.

Controle usando Python​

Crie uma pasta chamada scripts no diretório ~/myactuator_rmd/src/myactuator_example para armazenar os scripts Python.

cd ~/myactuator_rmd/src/myactuator_example
mkdir scripts

Obter número da versão​

Crie um script Python personalizado chamado test.py no diretório scripts e preencha-o com o seguinte código.

import myactuator_rmd_py as rmd
import time

# Initialize CAN driver and actuator interface
driver = rmd.CanDriver("can0")  # Using can0
actuator = rmd.ActuatorInterface(driver, 1)  # CAN ID set to 1

# Get version number
print("Version number:", actuator.getVersionDate())

Carregue a biblioteca e continue criando um driver para uma determinada interface de rede (aqui can0) e drive (aqui 1 correspondendo ao endereço CAN 0x140 + 1 = 0x141).

Obter status do motor​

# -*- coding: gbk -*-
import myactuator_rmd_py as rmd
import time
driver = rmd.CanDriver("can0")
actuator = rmd.ActuatorInterface(driver, 1)

# Motor Status 1
status1 = actuator.getMotorStatus1()
print(f"""
Motor Status 1:
Temperature: {status1.temperature}°C
Brake Status: {'Released' if status1.is_brake_released else 'Locked'}
Voltage: {status1.voltage}V
Error Code: {status1.error_code}
""")

# Motor Status 2
status2 = actuator.getMotorStatus2()
print(f"""
Motor Status 2:
Temperature: {status2.temperature}°C
Current: {status2.current}A
Shaft Speed: {status2.shaft_speed} RPM
Shaft Angle: {status2.shaft_angle}°
""")

# Motor Status 3
status3 = actuator.getMotorStatus3()
print(f"""
Motor Status 3:
Temperature: {status3.temperature}°C
Phase A Current: {status3.current_phase_a}A
Phase B Current: {status3.current_phase_b}A
Phase C Current: {status3.current_phase_c}A
""")

## Torque Calculation

import myactuator_rmd_py as rmd
from myactuator_rmd_py.actuator_constants import X4_24  # Import according to your motor model

def get_normalized_torque(actuator):
    """Calculate normalized torque from current"""
    # Get current value
    status = actuator.getMotorStatus2()
    current = status.current

    # Calculate normalized torque (current/rated)
    torque_ratio = current / X4_24.rated_current
    actual_torque = torque_ratio * X4_24.rated_torque
    return actual_torque

# Usage example
driver = rmd.CanDriver("can0")
actuator = rmd.ActuatorInterface(driver, 1)

try:
    while True:
        torque = get_normalized_torque(actuator)
        print(f"Current Torque: {torque:.3f} Nm (Rated: {X4_24.rated_torque} Nm)", end='\r')
        time.sleep(0.1)
except KeyboardInterrupt:
    actuator.shutdownMotor()

Modo de controle​

  • Obter modo de controle atual
# -*- coding: gbk -*-
import myactuator_rmd_py as rmd
import time
driver = rmd.CanDriver("can0")
actuator = rmd.ActuatorInterface(driver, 1)
mode = actuator.getControlMode()
print(f"Current Control Mode: {mode}")
  • Controle de posição absoluta
# -*- coding: gbk -*-
import myactuator_rmd_py as rmd
import time
driver = rmd.CanDriver("can0")
actuator = rmd.ActuatorInterface(driver, 1)

# Move to 180 degree position at 100 deg/s
actuator.sendPositionAbsoluteSetpoint(180.0, 300.0)
time.sleep(5)  # Wait for motor to reach target position

# Get current position
angle = actuator.getMultiTurnAngle()
print(f"Current position: {angle}°")

time.sleep(5)
mode = actuator.getControlMode()
print(f"Current control mode: {mode}")
actuator.shutdownMotor()

Você verá o seu motor girar até a posição de 180 graus.

  • Controle de posição relativa
import myactuator_rmd_py as rmd
import time
driver = rmd.CanDriver("can0")
actuator = rmd.ActuatorInterface(driver, 1)

# Move an additional 90 degrees from current position
current_angle = actuator.getMultiTurnAngle()
target_angle = current_angle + 90.0
actuator.sendPositionAbsoluteSetpoint(target_angle, 50.0)
time.sleep(3)
angle = actuator.getMultiTurnAngle()
print(f"Current position: {angle}°")
mode = actuator.getControlMode()
print(f"Current control mode: {mode}")
actuator.shutdownMotor()

Você observará o motor girar 90 graus no sentido anti-horário.

  • Controle de velocidade
# -*- coding: gbk -*-
import myactuator_rmd_py as rmd
import time
driver = rmd.CanDriver("can0")
actuator = rmd.ActuatorInterface(driver, 1)

# Continuous rotation at 500 RPM
actuator.sendVelocitySetpoint(500.0)
time.sleep(15)

# Stop motor
actuator.stopMotor()

# Get current position
angle = actuator.getMultiTurnAngle()
print(f"Current position: {angle}°")

mode = actuator.getControlMode()
print(f"Current control mode: {mode}")
  • Controle de Torque
# -*- coding: gbk -*-
import myactuator_rmd_py as rmd
import time
driver = rmd.CanDriver("can0")
actuator = rmd.ActuatorInterface(driver, 1)

# Apply 0.5A current (torque)
actuator.sendCurrentSetpoint(0.5)
time.sleep(2)

# Stop torque output
actuator.stopMotor()

# Get current position
angle = actuator.getMultiTurnAngle()
print(f"Current position: {angle}°")

mode = actuator.getControlMode()
print(f"Current control mode: {mode}")
  • Controle de Movimento em Malha Fechada
# -*- coding: gbk -*-
import myactuator_rmd_py as rmd
import time

# Initialization
driver = rmd.CanDriver("can0")
actuator = rmd.ActuatorInterface(driver, 1)

# Position control with feedback
feedback = actuator.sendPositionAbsoluteSetpoint(180.0, 100.0)
time.sleep(5)
print(feedback)


# Velocity control with feedback
feedback = actuator.sendVelocitySetpoint(20.0)
time.sleep(5)
print(feedback)

# Torque control with feedback
torque_constant = 0.32  # Set according to motor model
feedback = actuator.sendTorqueSetpoint(1.5, torque_constant)
time.sleep(5)
print(feedback)

actuator.stopMotor()

Controle de Freio do Motor​

# -*- coding: gbk -*-
import myactuator_rmd_py as rmd
import time
driver = rmd.CanDriver("can0")
actuator = rmd.ActuatorInterface(driver, 1)

# Engage brake
actuator.lockBrake()
print("Brake engaged")

# Release brake
actuator.releaseBrake()
print("Brake released")

Controle de Alimentação do Motor​

# -*- coding: gbk -*-
import myactuator_rmd_py as rmd
import time
driver = rmd.CanDriver("can0")
actuator = rmd.ActuatorInterface(driver, 1)

# Power off motor
actuator.shutdownMotor()
print("Motor powered off")

Funções do Encoder​

  • Obter Posição do Encoder Multivoltas
# -*- coding: gbk -*-
import myactuator_rmd_py as rmd
import time
driver = rmd.CanDriver("can0")
actuator = rmd.ActuatorInterface(driver, 1)
encoder_pos = actuator.getMultiTurnEncoderPosition()
print(f"Multi-turn encoder position: {encoder_pos}")
  • Definir a Posição Atual como Ponto Zero (Requer Reinicialização)
# -*- coding: gbk -*-
import myactuator_rmd_py as rmd
import time
driver = rmd.CanDriver("can0")
actuator = rmd.ActuatorInterface(driver, 1)
actuator.setCurrentPositionAsEncoderZero()
print("Current position set as encoder zero point")
  • Definir Ponto Zero Personalizado (Requer Reinicialização)
# -*- coding: gbk -*-
import myactuator_rmd_py as rmd
import time

driver = rmd.CanDriver("can0")
actuator = rmd.ActuatorInterface(driver, 1)

# Get current position as zero point
current_pos = actuator.getMultiTurnEncoderOriginalPosition()
print(f"Raw encoder position: {current_pos}")

# Set zero offset
actuator.setEncoderZero(current_pos)
print(f"Encoder zero point set to: {current_pos}")

# Reboot to apply settings
actuator.shutdownMotor()
time.sleep(1)  # Wait for shutdown
actuator = rmd.ActuatorInterface(driver, 1)  # Reinitialize

# Verify
new_pos = actuator.getMultiTurnEncoderPosition()
print(f"Post-reboot position (should be near 0): {new_pos}")

Configurações de Aceleração​

# -*- coding: gbk -*-
import myactuator_rmd_py as rmd
import time
from myactuator_rmd_py.actuator_state import AccelerationType

# Initialization
driver = rmd.CanDriver("can0")
actuator = rmd.ActuatorInterface(driver, 1)

## Get initial acceleration
print(f"Initial acceleration: {actuator.getAcceleration()}")

actuator.setAcceleration(5000, AccelerationType.POSITION_PLANNING_ACCELERATION)

## Get modified acceleration
print(f"Modified acceleration: {actuator.getAcceleration()}")

# Set different acceleration types
actuator.setAcceleration(1000, AccelerationType.POSITION_PLANNING_ACCELERATION)
actuator.setAcceleration(800, AccelerationType.POSITION_PLANNING_DECELERATION)
actuator.setAcceleration(1200, AccelerationType.VELOCITY_PLANNING_ACCELERATION)
actuator.setAcceleration(1000, AccelerationType.VELOCITY_PLANNING_DECELERATION)

Suporte Técnico & Discussão de Produto​

Obrigado por escolher nossos produtos! Estamos aqui para fornecer 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...