La gestión de inversores conectados a la red mediante control de potencia activa y reactiva (PQ) es fundamental para una integración energética eficiente y estable. Este artículo detalla una implementación que utiliza un inversor de dos niveles con un control de lazo cerrado para mantener un factor de potencia unitario, asegurando que la coriente de red esté en fase con el voltaje de la misma. Para lograr una sincronización robusta y veloz con la fase de la red, se emplea un lazo de seguimiento de fase (PLL) basado en integradores generalizados de segundo orden duales (DSOGI).

Arquitectura del Inversor y Principios de Operación

La base de nuestro sistema es un inversor de dos niveles, una configuración común y eficaz en la conversión de energía. Este tipo de inversor utiliza semiconductores de potencia para transformar corriente continua en corriente alterna, modulando los estados de encendido/apagado para generar una forma de onda de voltaje alterna. En un sistema trifásico, cada rama del inversor consta de dos interruptores, lo que permite la generación de voltajes positivos, negativos o cero en sus terminales.

Estrategia de Control PQ y Corrección del Factor de Potencia

Para asegurar que la energía se inyecte a la red con un factor de potencia unitario, lo que implica una alineación de fase entre la corriente y el voltaje de la red, se implementa un esquema de control de lazo cerrado. El objetivo es ajustar la potencia activa (P) y reactiva (Q) inyectadas según valores de referencia específicos. Por ejemplo, si se desea inyectar 10 kW de potencia activa y 0 kVAR de potencia reactiva, el controlador actúa sobre los lazos de corriente.

Consideremos un ejemplo simplificado de cómo un controlador PI podría ajustar las corrientes de referencia:

# Configuración de referencias de potencia
potencia_activa_ref = 10000.0  # W
potencia_reactiva_ref = 0.0   # VAR

# Valores de potencia medidos en tiempo real
potencia_activa_medida = 9850.0
potencia_reactiva_medida = 50.0

# Parámetros del regulador PI
ganancia_proporcional = 0.6
ganancia_integral = 0.15

# Variables para la integración (acumuladores)
integral_pa = 0.0
integral_pr = 0.0

# Cálculo del error y la salida del controlador PI
error_pa = potencia_activa_ref - potencia_activa_medida
integral_pa += error_pa  # Acumulación para el término integral
corriente_d_ref = ganancia_proporcional * error_pa + ganancia_integral * integral_pa

error_pr = potencia_reactiva_ref - potencia_reactiva_medida
integral_pr += error_pr  # Acumulación para el término integral
corriente_q_ref = ganancia_proporcional * error_pr + ganancia_integral * integral_pr

# Las corrientes_d_ref y corrientes_q_ref son usadas por el controlador interno del inversor
# para generar las señales PWM.

Este fragmento ilustra la lógica de un control PI que, basándose en la diferencia entre las potencias deseadas y las medidas, genera las componentes de corriente de referencia (i_d_ref e i_q_ref) en el marco de referencia síncrono, que son posteriormente convertidas y empleadas para modular el inversor.

Sincronización de Fase con la Red Eléctrica: PLL DSOGI

Una sincronización precisa con la fase del voltaje de la red es indispensable para el control PQ. Para este propósito, se implementa un lazo de seguimiento de fase (PLL) que utiliza integradores generalizados de segundo orden duales (DSOGI). Este método se distingue por su capacidad para determinar la fase de la red de manera rápida y precisa, incluso desde el inicio de la operación, superando en rendimiento a otras aproximaciones de PLL convencionales.

A continuación, se presenta un esquema básico de un PLL DSOGI en Python, que omite algunos detalles de implementación para mayor claridad:

import numpy as np

class SincronizadorDSOGI:
    def __init__(self, frecuencia_angular_nominal, kp_pll, ki_pll, periodo_muestreo):
        self.omega_nominal = frecuencia_angular_nominal # Frecuencia angular de la red (rad/s)
        self.kp = kp_pll
        self.ki = ki_pll
        self.dt = periodo_muestreo # Paso de tiempo para la integración

        self.fase_estimada = 0.0 # Acumulador de fase (radianes)
        self.error_integral_pll = 0.0 # Integral del error para el PI del PLL

        # Estados internos del filtro DSOGI (componentes alfa y beta ortogonales)
        self.v_alfa_filtro = 0.0
        self.v_beta_filtro = 0.0
        self.v_alfa_derivado = 0.0
        self.v_beta_derivado = 0.0

    def actualizar(self, voltaje_entrada_alfa):
        # Implementación discreta del DSOGI
        # Generación de componentes ortogonales (alpha/beta)
        v_alfa_prima = voltaje_entrada_alfa - self.v_alfa_filtro
        self.v_alfa_derivado += self.omega_nominal * v_alfa_prima * self.dt
        self.v_alfa_filtro += self.v_alfa_derivado * self.dt

        v_beta_prima = self.v_alfa_derivado - self.v_beta_filtro
        self.v_beta_derivado += self.omega_nominal * v_beta_prima * self.dt
        self.v_beta_filtro += self.v_beta_derivado * self.dt

        # Control del PLL (basado en el componente q del voltaje en el marco d-q)
        # El error es proporcional a v_q en el marco síncrono, que en este contexto
        # se simplifica como la componente ortogonal "beta" del DSOGI.
        error_pll = -self.v_beta_filtro # Negativo para buscar fase cero

        # Regulador PI para ajustar la frecuencia y, por ende, la fase
        self.error_integral_pll += error_pll * self.dt
        delta_omega = self.kp * error_pll + self.ki * self.error_integral_pll

        # Actualización de la fase estimada
        self.fase_estimada += (self.omega_nominal + delta_omega) * self.dt
        self.fase_estimada = np.fmod(self.fase_estimada, 2 * np.pi) # Mantener la fase entre 0 y 2pi

        return self.fase_estimada

# Ejemplo de uso (inicialización)
# pll_instance = SincronizadorDSOGI(omega_nominal=314.159, kp_pll=1.0, ki_pll=10.0, periodo_muestreo=1e-5)
# fase_actual = pll_instance.actualizar(voltaje_de_red_alfa)

El objeto SincronizadorDSOGI permite una determinación continua de la fase fase_estimada de la red, información crítica para las transformaciones de coordenadas y la modulación del inversor.

Simulación Discreta: Un Enfoque Realista

Un aspecto distintivo de esta metodología es la simulación completamente discreta del sistema, abarcando tanto el muestreo como las operaciones de control. A diferencia de enfoques más idealizados, el circuito de potencia y los algoritmos de control operan con pasos de tiempo distintos, imitando con mayor fidelidad el comportamiento de un sistema físico. Además, todos los componentes de control y muestreo se han implementado manualmente, sin recurrir a bloques predefinidos de entornos de simulación.

Un bucle de simulación que refleje estos diferentes pasos de tiempo podría estructurarse de la siguiente manera:

# Definición de los pasos de tiempo
paso_principal_simulacion = 5e-6   # 5 microsegundos para el circuito de potencia
paso_control_discreto = 1e-4      # 100 microsegundos para el controlador (muestreo y cálculo)

tiempo_simulacion = 0.0
tiempo_final = 0.5  # Duración total de la simulación en segundos

# Instancias de los controladores y sincronizadores (previamente inicializados)
# controlador_pq = ControladorPQ(...)
# sincronizador_pll = SincronizadorDSOGI(...)

while tiempo_simulacion < tiempo_final:
    # 1. Simulación del circuito de potencia (modelo discretizado)
    # Se actualizan voltajes, corrientes, estados de interruptores, etc.,
    # utilizando el 'paso_principal_simulacion'.
    # (Código del modelo del inversor y red eléctrica aquí)
    # ejemplo: tension_red_medida = obtener_tension_red_actual(tiempo_simulacion)

    # 2. Lógica de control (ejecutada a un paso de tiempo más lento)
    # Se comprueba si es el momento de ejecutar el control
    if (tiempo_simulacion % paso_control_discreto) < paso_principal_simulacion:
        # a. Muestreo de las variables del circuito
        # por ejemplo, mediciones_potencia = obtener_potencias_medidas()
        # tension_para_pll = obtener_voltaje_red_para_pll()

        # b. Actualización del PLL para obtener la fase actual de la red
        # fase_actual_red = sincronizador_pll.actualizar(tension_para_pll)

        # c. Cálculo de referencias de corriente basado en el control PQ
        # corriente_d_ref, corriente_q_ref = controlador_pq.calcular_referencias(
        #     mediciones_potencia, fase_actual_red
        # )

        # d. Aplicación de señales de control al inversor (PWM)
        # Esto implicaría la generación de las señales de conmutación
        # para los interruptores del inversor.
        pass # Placeholder para la lógica de control

    tiempo_simulacion += paso_principal_simulacion

Este enfoque discreto, aunque más complejo en su implementación, proporciona una representación mucho más fiel de la dinámica de un sistema real, permitiendo una evaluación más precisa del rendimiento del control PQ en inversores conectados a la red. El meticuloso diseño de cada etapa del control y la simulación refuerza la robustez de la solución propuesta.