Guía Completa: Identificación Empírica y Control de motores para dar un ejemplo claro puede ser de un motor de 42V

Determinar la función de transferencia de un motor de imanes permanentes, asíncronos ó brushless es un proceso esencial para diseñar controladores precisos. A continuación, se detalla el protocolo experimental para caracterizar un motor de 42V fase-fase.

1. Caracterización Eléctrica: Resistencia e Inductancia

Para obtener la respuesta eléctrica, trabajamos con el modelo equivalente en corriente continua (marco de referencia $dq$). La función de transferencia de primer orden que buscamos es:

$$G_e(s) = \frac{I(s)}{V(s)} = \frac{1/R}{\tau_e s + 1}$$

Protocolo Experimental:

1. Bloqueo del Rotor: Inmoviliza el eje para eliminar la fuerza contraelectromotriz ($BEMF$).
2. Ensayo de Escalón: Aplica un voltaje de CC (ej. 5V) entre dos fases y registra la curva de corriente con un osciloscopio.
3. Cálculos:
   
   • Resistencia ($R$): Se obtiene mediante la Ley de Ohm en estado estable: $R = \frac{V_{aplicado}}{I_{final}}$.
   • Constante de tiempo ($\tau_e$): Tiempo en el que la corriente alcanza el 63.2% de su valor máximo.
   • Inductancia ($L$): Calculada como $L = \tau_e \cdot R$.

2. La Constante de Par ($K_t$) y Fuerza Contraelectromotriz ($K_e$)

En el sistema internacional, $K_t$ (N·m/A) es numéricamente igual a $K_e$ (V·s/rad). Para medirla, usamos el motor como generador.

Procedimiento:

1. Gira el motor a una velocidad constante ($\Omega_m$) usando un motor externo o taladro.
2. Mide el voltaje pico entre dos fases ($V_{L-L(pico)}$) en el osciloscopio. ó los RPM con un tacómetro
3. Calcula la constante usando:

$$V_{fase} = \frac{V_{L-L(pico)}}{\sqrt{3}}$$

$$K_t = K_e = \frac{V_{fase}}{\Omega_m}$$

Donde $\Omega_m$ debe estar en $rad/s$ ($RPM \cdot \frac{2\pi}{60}$).

Para convertir los hercios ($Hz$) medidos en el osciloscopio a velocidad angular ($\omega_m$) en $rad/s$, debes usar la siguiente relación:

def hz_a_rad_s(frecuencia_hz, pares_de_polos):
    """
    Convierte la frecuencia eléctrica medida en Hz a velocidad angular mecánica.
    """
    omega_m = (2 * np.pi * frecuencia_hz) / pares_de_polos
    return omega_m

# Ejemplo de uso:
f_osc = 60  # Hz medidos
p_pairs = 4 # Pares de polos
velocidad = hz_a_rad_s(f_osc, p_pairs)
print(f"Velocidad: {velocidad:.2f} rad/s")

3. Caracterización Mecánica: Inercia ($J$) y Fricción ($B$)

La dinámica mecánica relaciona el torque con la velocidad angular:

$$G_m(s) = \frac{\Omega(s)}{T(s)} = \frac{1}{Js + B}$$

Método de Desaceleración (Spin-down):

1. Medir Fricción ($B$): Haz girar el motor en vacío a velocidad constante ($\Omega_{ss}$) y mide la corriente ($I_{vacio}$).

$$B = \frac{K_t \cdot I_{vacio}}{\Omega_{ss}}$$

2. Medir Inercia ($J$): Desconecta la alimentación súbitamente y mide el tiempo que tarda la velocidad en caer al 36.8% de su valor inicial. Este tiempo es la constante mecánica $\tau_m$.

$$J = \tau_m \cdot B$$

4. La Función de Transferencia Completa

Combinando la parte eléctrica y mecánica, obtenemos la relación Voltaje a Velocidad:

$$G(s) = \frac{\Omega(s)}{V(s)} = \frac{K_t}{(Ls + R)(Js + B) + K_t^2}$$

5. Implementación y Simulación (Python)

El siguiente script permite validar el modelo teórico frente a datos reales capturados en un archivo CSV.

Python

import numpy as np
import control as ct
import matplotlib.pyplot as plt
import pandas as pd

def crear_modelo_motor(R, L, Kt, J, B):
    num = [Kt]
    den = [L*J, (L*B + R*J), (R*B + Kt**2)]
    return ct.TransferFunction(num, den)

# Parámetros de ejemplo (42V)
R, L, Kt, J, B = 0.5, 0.001, 0.082, 0.00005, 0.0001
motor_tf = crear_modelo_motor(R, L, Kt, J, B)

def comparar_con_real(motor_tf, v_test, csv_path):
    # Cargar datos desde archivo
    data = pd.read_csv(csv_path)
    t_real = data['tiempo'].values
    v_real = data['velocidad'].values

    # Simular modelo con la misma base de tiempo
    t_sim, v_sim = ct.step_response(motor_tf * v_test, T=t_real)

    plt.figure(figsize=(10, 5))
    plt.plot(t_real, v_real, 'ro', label='Experimental', markersize=2)
    plt.plot(t_sim, v_sim, 'b-', label='Modelo Teórico', linewidth=2)
    plt.xlabel('Tiempo (s)')
    plt.ylabel('Velocidad (rad/s)')
    plt.legend()
    plt.grid(True)
    plt.show()

def diseñar_control_pid(motor_tf, Kp, Ki, Kd):
    # Definición del controlador: C(s) = Kp + Ki/s + Kd*s
    pid = ct.tf([Kd, Kp, Ki], [1, 0])
    
    # Sistema en lazo cerrado (Feedback)
    sistema_controlado = ct.feedback(pid * motor_tf, 1)
    return sistema_controlado

# Ejemplo de sintonización
Kp, Ki, Kd = 2.0, 20.0, 0.05
lazo_cerrado = diseñar_control_pid(motor_tf, Kp, Ki, Kd)

def simular_rechazo_carga(R, L, Kt, J, B, Kp, Ki, Kd, ref_val, load_val, t_impact):
    # Representación interna del motor (2 entradas: V y T_load)
    A = [[-R/L, -Kt/L], [Kt/J, -B/J]]
    B_mat = [[1/L, 0], [0, -1/J]]
    C_mat = [[0, 1]]
    D_mat = [[0, 0]]
    motor_ss = ct.ss(A, B_mat, C_mat, D_mat)

    # Interconexión con PID
    pid = ct.tf([Kd, Kp, Ki], [1, 0])
    sys_cl = ct.interconnect(
        [motor_ss, pid],
        connections=[[0, 0], [1, 0, -1]],
        inplist=[(1,0), (0,1)], # [Referencia, Carga]
        outlist=[(0,1)]
    )

    # Definición de señales
    t = np.linspace(0, 4, 1000)
    ref = np.ones_like(t) * ref_val
    load = np.zeros_like(t)
    load[t >= t_impact] = load_val

    t_out, y_out = ct.input_output_response(sys_cl, t, [ref, load])
    
    plt.plot(t_out, y_out[0])
    plt.axvline(x=t_impact, color='r', linestyle='--', label='Impacto de Carga')
    plt.title('Respuesta ante Carga Externa')
    plt.legend()
    plt.show() 

6. Control de Lazo Cerrado (PID)

Para asegurar que el motor mantenga la velocidad deseada ante variaciones de carga, implementamos un diagrama de bloques con retroalimentación.

Componentes del Lazo:

• Error ($e$): Diferencia entre la velocidad deseada y la real.
• PID ($C(s)$): Calcula el voltaje necesario basándose en $K_p$, $K_i$ y $K_d$.
• Rechazo de Perturbaciones: El sistema compensa automáticamente si un torque de carga ($T_L$) frena el eje.

Resumen de Variables Obtenidas