Skip to main content

Introducción a los Motores de la Serie MyActuator X

Este artículo presentará cómo comenzar con los motores de la serie MyActuator y cómo usarlos con C++ y Python en el reComputer Mini Jetson Orin.

Obtener Uno Ahora 🖱

Especificaciones​

Aquí está la tabla completa con todos los parámetros completados para todos los modelos de motores:

ParámetroX2-7X4-10X4-36X8-120X12-320X15-450
Relación de Engranaje28.1712.63619.612020.25
Voltaje de Entrada (V)242424484872
Velocidad Sin Carga (RPM)178317111158125108
Corriente de Entrada Sin Carga (A)110.91.62.73.5
Velocidad Nominal (RPM)1422388312710098
Par Nominal (N.m)2.5410.54385145
Potencia de Salida Nominal (W)371001005749001480
Corriente de Fase Nominal A(rms)37.86.117.63025
Par Máximo (N.m)71034120320450
Corriente de Fase Máxima A(rms)8.119.521.543.810069.2
Eficiencia (%)6369.563.1797582.4
Constante de FEM del Motor (Vdc/Krpm)4.36619.217.929.9
Constante de Par del Módulo (N.m/A)0.80.81.92.43.35.8
Resistencia de Fase del Motor (Ω)0.610.320.350.180.120.08
Inductancia de Fase del Motor (mH)0.130.140.170.310.050.14
Par de Polos131313102020
Conexión de 3 FasesY
Par de Retroceso (N.m)0.40.81.143.213.84
Holgura (Arcmin)121010101010
Tipo de Rodamiento de SalidaRodamientos de Bolas de Ranura ProfundaRodamientos de Rodillos Cruzados
Resistencia Axial (KN)0.251.21.344.55.4
Esfuerzo Axial (KN)0.251.21.314.55.4
Carga Radial (KN)11.21.54.556
Inercia (Kg.cm²)0.170.250.31.512.931.6
Tipo de Codificador e InterfazCodificador Dual ABS-17BIT (Entrada) / 17-18BIT (Salida)
Precisión de Control (Grados)<0.01
ComunicaciónCAN BUS / EtherCAT
Peso (Kg)0.260.330.361.402.373.50
Grado de AislamientoF

Convenciones de Nomenclatura de la Serie RMD-X V4​

  • RMD: Nombre de Marca R-Reductor M-Motor D-Accionamiento
  • X2: X Representa el Nombre de la Serie: Actuador Planetario Integrado, 2 representa el número de modelo del motor ej:X2 X4 X6 X8 etc
  • P28: Relación de engranaje planetario ej:P12 P28 P32 etc
  • 7: Torque máximo 7N.m
  • E: Comunicación E: CAN BUS & EtherCAT

Características Principales​

  1. CAN BUS & EtherCAT
  2. Rodamientos de Rodillos Cruzados
  3. Codificador Dual
  4. Alta Densidad de Torque
  5. Alta Precisión
  6. Diseño Hueco

Comenzar​

Preparación del Entorno Antes del Uso​

Sistema Windows en PC

Conectar el Circuito​

Aquí hemos seleccionado el motor X4-36, y su diagrama de interfaz se muestra a continuación.

Definición del PuertoDescripción del Puerto
① VCCPositivo de alimentación
② GNDNegativo de alimentación
③ CAN_HTerminal de señal de red CAN_H
④ CAN_LTerminal de señal de red CAN_L
⑤ EtherCAT_INTerminal de entrada EtherCAT
⑥ EtherCAT_OUTTerminal de salida EtherCAT
⑦ T+Maestro envía comandos de control al módulo
⑧ T-Módulo envía retroalimentación de estado al maestro
⑨ R+Maestro refleja datos de estado del módulo
⑩ R-Módulo refleja comandos de control del maestro

Aquí, utilizamos el método de comunicación CAN, que requiere una interfaz USB-CAN adicional para la depuración a través de una computadora superior en Windows.

Aquí, necesitas proporcionar una fuente de alimentación de 24V separada para el motor y conectar el USB a tu computadora.

Usa el MYACTUATOR Setup Software 250206.exe para Probar el Motor​

Establecer ID y ConexiónLeer Información del MotorCalibrar el motorCalibrar el motorEjecutar una prueba de rotación del motor.
fig1fig2fig3fig4fig5
El ID predeterminado del motor es 1. Ingresa ID como 1 y haz clic en "Connect".Después de conectar, haz clic en "Read" para recuperar la información actual del motor.Para el primer uso, haz clic en "Calibrate Motor" para realizar la calibración.Después de la calibración, haz clic en "Read" y "Save".Ahora puedes probar diferentes modos de control del motor en la sección Motor Running.

Para más características detalladas, consulte el Manual de Instrucciones del Software de Configuración - V3.0.pdf incluido en el archivo MYACTUATOR_Setup Software_V4.0.zip.

Controlar el Motor Usando el ​reComputer Mini Jetson Orin.​

Actualmente, las interfaces de comunicación CAN más comunes para motores en el mercado utilizan XT30 (2+2) y conectores JST. Nuestro dispositivo reComputer Mini Jetson Orin y reComputer Robotics está equipado con puertos XT30 (2+2) duales e interfaces CAN basadas en JST, proporcionando compatibilidad perfecta.

reComputer Mini:

reComputer Robotics

Para más detalles sobre el uso de CAN, puede consultar esta wiki.

Habilitar Interfaces CAN​

Paso1: Antes de usar CAN0 y CAN1, retire la cubierta inferior y configure ambas resistencias de terminación de 120Ω en la posición ON.

Paso2: Conecte el motor directamente al CAN0 del reComputer Mini a través de la interfaz XT30 (2+2).

Esta es la interfaz CAN0 para reComputer Mini

danger

Esta fuente de alimentación es solo para aprendizaje y pruebas de un solo motor. Para múltiples motores, diseñe una placa de alimentación separada y aísle la fuente de alimentación del Jetson de la fuente de alimentación del motor para evitar que pase alta corriente directamente a través del Jetson.

Habilitar comunicación CAN del Jetson​

Abra una terminal e ingrese el siguiente comando para poner el pin GPIO en alto y activar CAN0:

gpioset --mode=wait 0 43=0

Si estás usando la interfaz JST CAN1, pon el pin 106 en alto.

gpioset --mode=wait 0 106=0

Mantén esta terminal abierta, abre una nueva terminal y configura CAN0.

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

Construir el Entorno de Python y C++​

Paso1: Clonar el SDK con Git.

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

Paso 2: Este SDK del controlador requiere que se instalen las siguientes dependencias. Para Debian Linux se pueden instalar a través de apt de la siguiente manera:

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

En caso de que quieras usar los enlaces de Python, tendrás que instalar adicionalmente Python 3, pip y pybind11:

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

Después de haber instalado sus dependencias, tendrás que instalar el SDK del controlador ya sea como una biblioteca de C++ o un paquete de Python como se describe en los siguientes pasos. Ambos usarán CMake para compilar el código de C++.

Compilando la Biblioteca de C++​

Para compilar el SDK del controlador de C++, abre una nueva terminal dentro de esta carpeta y ejecuta los siguientes comandos. En versiones más antiguas de Linux, la compilación podría fallar con el mensaje de error error: 'const struct can_frame' has no member named 'len' y tendrás que aplicar la modificación de código discutida en issue 5.

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

La bandera PYTHON_BINDINGS (por defecto desactivada) construye los enlaces de Python adicionalmente a la biblioteca de C++. En caso de que solo estés interesado en usar la biblioteca de C++, siéntete libre de dejarla desactivada. Cuando construyas los enlaces de Python de esta manera, se compilarán a una biblioteca compartida pero no se instalarán. Esto significa que tendrás que instalar la biblioteca manualmente o solo podrás importarlos localmente dentro de la carpeta de construcción.

Para desinstalar el paquete nuevamente puedes usar el siguiente comando xargs rm < install_manifest.txt.

Construyendo la Biblioteca de Python​

Para construir e instalar los enlaces de Python para este SDK, abre una nueva terminal dentro de la carpeta principal y ejecuta el siguiente comando:

cd ~/myactuator_rmd
pip3 install .

Esto utilizará el setup.py para invocar CMake e instalar los enlaces como una biblioteca de C++. Si deseas eliminarlos nuevamente, simplemente ejecuta pip3 uninstall myactuator-rmd-py.

Control Usando C++​

  1. Crear la estructura del directorio del proyecto
    Crea tu directorio de proyecto bajo el directorio src del código, por ejemplo, nómbralo myactuator_example, y crea una carpeta src bajo el subdirectorio.
cd ~/myactuator_rmd
mkdir -p ~/myactuator_rmd/src/myactuator_example/src  
cd ~/myactuator_rmd/src/myactuator_example
  1. Escribir CMakeLists.txt
    En el archivo ~/myactuator_rmd/src/myactuator_example/CMakeLists.txt, escriba el siguiente contenido:
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. Escribir main.cpp
    En el archivo ~/myactuator_rmd/src/myactuator_example/src/main.cpp, escriba el siguiente 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. Construir el proyecto
cd ~/myactuator_rmd/src/myactuator_example
mkdir build && cd build
cmake .. -DCMAKE_BUILD_TYPE=Release
make
  1. Ejecutar el programa
sudo ./myactuator_node

Prerrequisitos

  • La interfaz CAN can0 debe estar configurada correctamente (asegúrese de que su motor y el bus CAN estén conectados correctamente).
  • La biblioteca myactuator_rmd debe estar instalada correctamente (si no, instálela primero).

Para más detalles de implementación en C++, consulte todo el contenido en myactuator_rmd.hpp. Proporcionaremos una introducción detallada a los métodos de uso de Python.

Control Usando Python​

Cree una carpeta llamada scripts bajo el directorio ~/myactuator_rmd/src/myactuator_example para almacenar scripts de Python.

cd ~/myactuator_rmd/src/myactuator_example
mkdir scripts

Obtener número de versión​

Crea un script personalizado de Python llamado test.py bajo el directorio scripts y llénalo con el siguiente 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())

Carga la biblioteca y continúa creando un controlador para una interfaz de red particular (aquí can0) y unidad (aquí 1 correspondiente a la dirección CAN 0x140 + 1 = 0x141).

Obtener Estado del 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 Control​

  • Obtener Modo de Control Actual
# -*- 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}")
  • Control de Posición 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()

Verás que tu motor gira a la posición de 180 grados.

  • Control de Posición 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()

Observarás que el motor gira 90 grados en sentido antihorario.

  • Control de Velocidad
# -*- 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}")
  • Control de Par
# -*- 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}")
  • Control de Movimiento en Bucle Cerrado
# -*- 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()

Control de Freno del 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")

Control de Energía del 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")

Funciones del Codificador​

  • Obtener Posición del Codificador Multi-vuelta
# -*- 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}")
  • Establecer la Posición Actual como Punto Cero (Requiere Reinicio)
# -*- 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")
  • Establecer Punto Cero Personalizado (Requiere Reinicio)
# -*- 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}")

Configuración de Aceleración​

# -*- 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)

Soporte Técnico y Discusión de Productos​

¡Gracias por elegir nuestros productos! Estamos aquí para brindarte diferentes tipos de soporte para asegurar que tu experiencia con nuestros productos sea lo más fluida posible. Ofrecemos varios canales de comunicación para satisfacer diferentes preferencias y necesidades.

Loading Comments...