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 motor:

ParámetroX2-7X4-10X4-36X8-120X12-320X15-450
Relación de Engranajes28.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
Carga 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 engranajes planetarios ej: P12 P28 P32 etc
  • 7: Par 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 Par
  5. Alta Precisión
  6. Diseño Hueco

Introducción​

Preparación del Entorno Antes del Uso​

Sistema Windows en PC

  • Descarga el manual del producto correspondiente.

  • Descarga el MYACTUATOR_Setup Software_V4.0.zip

  • Extrae MYACTUATOR_Setup Software_V4.0.zip e instala lo siguiente:

    • USBCAN_AllInOne_x86_x64_2.0.0.1.exe ubicado en el directorio Required Runtime Environment\ZLGUSBCAN_Driver
    • MSVBCRT.AIO.2019.10.19.X86 X64.exe ubicado en el directorio Required Microsoft Runtime Libraries

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+El maestro envía comandos de control al módulo
⑧ T-El módulo envía retroalimentación de estado al maestro
⑨ R+El maestro refleja los datos de estado del módulo
⑩ R-El módulo refleja los comandos de control del maestro

Aquí, utilizamos el método de comunicación CAN, que requiere una interfaz USB-CAN adicional para 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.

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

Configurar 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, consulta el Setup Software Instruction Manual - 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 duales XT30 (2+2) e interfaces CAN basadas en JST, proporcionando compatibilidad perfecta.

reComputer Mini:

reComputer Robotics

Para más detalles sobre el uso de CAN, puedes consultar este wiki.

Habilitar Interfaces CAN​

Paso1: Antes de usar CAN0 y CAN1, por favor retira la cubierta inferior y configura ambas resistencias de terminación de 120Ω en la posición ON.

Paso2: Conecta 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

:::dangerEsta fuente de alimentación es solo para el aprendizaje y pruebas de un solo motor. Para múltiples motores, por favor 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á usando la interfaz JST CAN1, ponga el pin 106 en alto.

gpioset --mode=wait 0 106=0

Mantenga esta terminal abierta, lance una nueva terminal y configure CAN0.

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

Construir Entorno Python y C++​

Paso1: Clonar el SDK con Git.

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

Paso2: 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 quiera usar los enlaces de Python tendrá 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á que instalar el SDK del controlador ya sea como una biblioteca C++ o paquete Python como se describe en los siguientes pasos. Ambos usarán CMake para compilar el código C++.

Construir la Biblioteca C++​

Para construir el SDK del controlador C++ abra una nueva terminal dentro de esta carpeta y ejecute los siguientes comandos. En versiones más antiguas de Linux la construcción podría fallar con el mensaje de error error: 'const struct can_frame' has no member named 'len' y tendrá 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 C++. En caso de que solo esté interesado en usar la biblioteca C++ siéntase libre de dejarla desactivada. Cuando construya los enlaces de Python de esta manera serán compilados a una biblioteca compartida pero no serán instalados. Esto significa que tendrá que instalar la biblioteca manualmente o solo podrá importarlos localmente dentro de la carpeta de construcción.

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

Construir la Biblioteca Python​

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

cd ~/myactuator_rmd
pip3 install .

Esto usará el setup.py para invocar CMake e instalar los enlaces como una biblioteca C++. Si quiere removerlos nuevamente simplemente invoque pip3 uninstall myactuator-rmd-py.

Control Usando C++​

  1. Crear estructura de directorio del proyecto
    Cree su directorio de proyecto bajo el directorio src del código, por ejemplo, nómbrelo myactuator_example, y cree 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 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++, por favor 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​

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

Cargue la biblioteca y continúe para crear 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á su motor rotar 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á el motor rotando 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}")```

<div align="center">
    <img width={800}
     src="https://files.seeedstudio.com/wiki/robotics/Actuator/myactuator/13.png" />
</div>

- **Control de Par**

```python
# -*- 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 Encoder​

  • Obtener Posición del Encoder 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 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 brindarle diferentes tipos de soporte para asegurar que su experiencia con nuestros productos sea lo más fluida posible. Ofrecemos varios canales de comunicación para satisfacer diferentes preferencias y necesidades.

Loading Comments...