1. Modelo Matemático do Sistema

A topolgoia de um inversor fonte de tensão de dois níveis trifásico com filtro LC conectado a uma carga é apresentada. As equações do modelo no domínio contínuo, no referencial αβ, descrevem a dinâmica das correntes do indutor do filtro (i_fαβ) e das tensões de saída (v_oαβ). Os parâmetros do filtro são a indutância (L_f), capacitância (C_f) e resistência parasita (R_f). O modelo discreto, necessário para a implementação do controlador digital, é obtido utilizando o método de Euler Forward com período de amostragem T_s.

2. Algoritmo de Controle FCS-MPC

O princípio do Controle Preditivo Baseado em Modelo com Conjunto Finito (FCS-MPC) envolve a medição do estado atual, a predição do comportamento futuro do sistema para cada um dos oito possíveis vetores de tensão do inversor (seis vetores ativos e dois vetores nulos), o cálculo de uma função de custo para cada predição e a seleção do estado de chaveamento que minimiza este custo.

3. Implementação da Simulação em MATLAB

3.1 Parâmetros de Simulação

% Parâmetros do sistema
tensao_dc = 500;          % Tensão do barramento CC (V)
freq_chaveamento = 20e3;  % Frequência de chaveamento (Hz)
periodo_amostragem = 1 / freq_chaveamento;
freq_referencia = 50;     % Frequência da tensão de referência (Hz)
amplitude_ref = 200;      % Amplitude da tensão de referência (V)

% Parâmetros do filtro LC
indutancia_filtro = 2.5e-3;
capacitancia_filtro = 40e-6;
resistencia_filtro = 0.1;

% Parâmetros da carga
resistencia_carga = 100;

% Parâmetros do MPC
ganho_rastreio_tensao = 1;
ganho_limitacao_corrente = 0.1;

3.2 Função do Controlador MPC

function [chave_otima, custo_minimo] = controlador_mpc(...
    corrente_indutor_alpha, corrente_indutor_beta, ...
    tensao_saida_alpha, tensao_saida_beta, ...
    corrente_carga_alpha, corrente_carga_beta, ...
    tensao_ref_alpha, tensao_ref_beta, ...
    tensao_dc, Ts, Lf, Cf, Rf, ...
    lambda_tensao, lambda_corrente)

    % Tabela de vetores de tensão
    vetores_tensao_alpha = [0; 2/3; 1/3; -1/3; -2/3; -1/3; 1/3; 0] * tensao_dc;
    vetores_tensao_beta = [0; 0; sqrt(3)/3; sqrt(3)/3; 0; -sqrt(3)/3; -sqrt(3)/3; 0] * tensao_dc;
    tabela_estados = [0 0 0; 1 0 0; 1 1 0; 0 1 0; 0 1 1; 0 0 1; 1 0 1; 1 1 1];

    custo_minimo = inf;
    chave_otima = [0 0 0];

    for idx = 1:8
        % Predição de estado (modelo discreto)
        i_f_alpha_pred = corrente_indutor_alpha + (Ts/Lf) * (vetores_tensao_alpha(idx) - Rf*corrente_indutor_alpha - tensao_saida_alpha);
        i_f_beta_pred = corrente_indutor_beta + (Ts/Lf) * (vetores_tensao_beta(idx) - Rf*corrente_indutor_beta - tensao_saida_beta);
        v_o_alpha_pred = tensao_saida_alpha + (Ts/Cf) * (corrente_indutor_alpha - corrente_carga_alpha);
        v_o_beta_pred = tensao_saida_beta + (Ts/Cf) * (corrente_indutor_beta - corrente_carga_beta);

        % Cálculo da função de custo
        erro_tensao = (tensao_ref_alpha - v_o_alpha_pred)^2 + (tensao_ref_beta - v_o_beta_pred)^2;
        modulo_corrente = sqrt(i_f_alpha_pred^2 + i_f_beta_pred^2);
        custo_corrente = max(0, modulo_corrente - 20)^2; % Limite de corrente = 20A
        custo_total = lambda_tensao * erro_tensao + lambda_corrente * custo_corrente;

        if custo_total < custo_minimo
            custo_minimo = custo_total;
            chave_otima = tabela_estados(idx, :);
        end
    end
end

3.3 Funções de Transformação de Coordenadas

function [x_alpha, x_beta] = clarke_direta(a, b, c)
    % Transformação de Clarke: abc -> αβ
    matriz_transformacao = (2/3) * [1, -0.5, -0.5; 0, sqrt(3)/2, -sqrt(3)/2];
    resultado = matriz_transformacao * [a; b; c];
    x_alpha = resultado(1);
    x_beta = resultado(2);
end

function [a, b, c] = clarke_inversa(x_alpha, x_beta)
    % Transformação inversa de Clarke: αβ -> abc
    matriz_inversa = [1, 0; -0.5, sqrt(3)/2; -0.5, -sqrt(3)/2];
    resultado = matriz_inversa * [x_alpha; x_beta];
    a = resultado(1);
    b = resultado(2);
    c = resultado(3);
end

3.4 Script Principal de Simulação

clear; clc; close all;

% Carregar parâmetros (exemplo simplificado)
Vdc = 500; Ts = 50e-6; Lf = 2.5e-3; Cf = 40e-6; Rf = 0.1;
R_carga = 100;
lambda_v = 1; lambda_i = 0.1;
tempo_simulacao = 0.1;
num_amostras = round(tempo_simulacao / Ts);

% Vetores para armazenamento de dados
vetor_tempo = (0:num_amostras-1)' * Ts;
tensao_saida_registrada = zeros(num_amostras, 3);
chaveamento_registrado = zeros(num_amostras, 3);

% Condições iniciais
estado_atual = struct('v_o_ab', [0,0], 'i_f_ab', [0,0], 'i_o_ab', [0,0]);
chave_anterior = [0 0 0];

for k = 1:num_amostras
    tempo_atual = vetor_tempo(k);

    % Gerar referência
    angulo = 2*pi*50*tempo_atual;
    tensao_ref_a = 200 * sin(angulo);
    tensao_ref_b = 200 * sin(angulo - 2*pi/3);
    tensao_ref_c = 200 * sin(angulo + 2*pi/3);
    [ref_alpha, ref_beta] = clarke_direta(tensao_ref_a, tensao_ref_b, tensao_ref_c);

    % Estimar corrente de carga (exemplo para carga resistiva)
    corrente_carga_alpha = estado_atual.v_o_ab(1) / R_carga;
    corrente_carga_beta = estado_atual.v_o_ab(2) / R_carga;

    % Executar controlador MPC
    [chave_selecionada, ~] = controlador_mpc(...
        estado_atual.i_f_ab(1), estado_atual.i_f_ab(2), ...
        estado_atual.v_o_ab(1), estado_atual.v_o_ab(2), ...
        corrente_carga_alpha, corrente_carga_beta, ...
        ref_alpha, ref_beta, ...
        Vdc, Ts, Lf, Cf, Rf, lambda_v, lambda_i);

    chaveamento_registrado(k, :) = chave_selecionada;

    % Simulação do modelo do inversor e filtro (próximo passo)
    tensao_saida_fase = zeros(1,3);
    for fase = 1:3
        tensao_saida_fase(fase) = (2*chave_selecionada(fase) - sum(chave_selecionada) + chave_selecionada(fase)) * Vdc / 3;
    end
    [u_alpha, u_beta] = clarke_direta(tensao_saida_fase(1), tensao_saida_fase(2), tensao_saida_fase(3));

    % Atualização do estado (integração numérica simples)
    novo_i_f_alpha = estado_atual.i_f_ab(1) + (Ts/Lf) * (u_alpha - Rf*estado_atual.i_f_ab(1) - estado_atual.v_o_ab(1));
    novo_i_f_beta = estado_atual.i_f_ab(2) + (Ts/Lf) * (u_beta - Rf*estado_atual.i_f_ab(2) - estado_atual.v_o_ab(2));
    novo_v_o_alpha = estado_atual.v_o_ab(1) + (Ts/Cf) * (estado_atual.i_f_ab(1) - corrente_carga_alpha);
    novo_v_o_beta = estado_atual.v_o_ab(2) + (Ts/Cf) * (estado_atual.i_f_ab(2) - corrente_carga_beta);

    % Atualizar estado para a próxima iteração
    estado_atual.i_f_ab = [novo_i_f_alpha, novo_i_f_beta];
    estado_atual.v_o_ab = [novo_v_o_alpha, novo_v_o_beta];

    % Registrar tensão de saída
    [v_a, v_b, v_c] = clarke_inversa(novo_v_o_alpha, novo_v_o_beta);
    tensao_saida_registrada(k, :) = [v_a, v_b, v_c];
end

% Visualização dos resultados
figure;
subplot(3,1,1);
plot(vetor_tempo, tensao_saida_registrada(:,1), 'b', vetor_tempo, 200*sin(2*pi*50*vetor_tempo), 'r--');
title('Tensão de Saída - Fase A'); xlabel('Tempo (s)'); ylabel('Tensão (V)'); grid on;
subplot(3,1,2);
stairs(vetor_tempo, chaveamento_registrado(:,1));
title('Estado de Chaveamento - Fase A'); xlabel('Tempo (s)'); ylabel('Comando'); ylim([-0.1 1.1]); grid on;
subplot(3,1,3);
plot(vetor_tempo, tensao_saida_registrada);
title('Tensões de Saída Trifásicas'); xlabel('Tempo (s)'); ylabel('Tensão (V)'); grid on; legend('A','B','C');

4. Estratégias de MPC Avançadas

Para aprimorar o desempenho, pode-se implementar variações como MPC de múltiplos passos, onde a predição considera um horizonte de tempo estendido, ou MPC com compensação de atraso compuatcional, essencial para lidar com o atraso inerente ao processamento em tempo real em controladores digitais.

function [chave_otima, custo_minimo] = controlador_mpc_com_compensacao(...
    corrente_indutor_alpha, corrente_indutor_beta, ...
    tensao_saida_alpha, tensao_saida_beta, ...
    corrente_carga_alpha, corrente_carga_beta, ...
    tensao_ref_alpha, tensao_ref_beta, ...
    chave_atual, ...
    tensao_dc, Ts, Lf, Cf, Rf, ...
    lambda_tensao, lambda_corrente)

    % Passo 1: Compensar atraso - prever estado k+1 baseado na chave aplicada em k
    [u_alpha_atual, u_beta_atual] = chave_para_tensao(chave_atual, tensao_dc);
    estado_k1.i_f_ab(1) = corrente_indutor_alpha + (Ts/Lf) * (u_alpha_atual - Rf*corrente_indutor_alpha - tensao_saida_alpha);
    estado_k1.i_f_ab(2) = corrente_indutor_beta + (Ts/Lf) * (u_beta_atual - Rf*corrente_indutor_beta - tensao_saida_beta);
    estado_k1.v_o_ab(1) = tensao_saida_alpha + (Ts/Cf) * (corrente_indutor_alpha - corrente_carga_alpha);
    estado_k1.v_o_ab(2) = tensao_saida_beta + (Ts/Cf) * (corrente_indutor_beta - corrente_carga_beta);

    % Passo 2: Rodar MPC a partir do estado k+1 para determinar chave para k+2
    [chave_otima, custo_minimo] = controlador_mpc(...
        estado_k1.i_f_ab(1), estado_k1.i_f_ab(2), ...
        estado_k1.v_o_ab(1), estado_k1.v_o_ab(2), ...
        corrente_carga_alpha, corrente_carga_beta, ...
        tensao_ref_alpha, tensao_ref_beta, ...
        tensao_dc, Ts, Lf, Cf, Rf, lambda_tensao, lambda_corrente);
end

function [u_a, u_b] = chave_para_tensao(chave, Vdc)
    Sa = chave(1); Sb = chave(2); Sc = chave(3);
    van = (2*Sa - Sb - Sc) * Vdc/3;
    vbn = (-Sa + 2*Sb - Sc) * Vdc/3;
    vcn = (-Sa - Sb + 2*Sc) * Vdc/3;
    [u_a, u_b] = clarke_direta(van, vbn, vcn);
end

5. Análise de Desempenho e Considerações

A simulação demonstra a capacidade do FCS-MPC de rastrear uma referência sinusoidal com baixa distorção harmônica total (THD) e rápida resposta dinâmica, mesmo na presença de cargas não-lineares. Os principais desafios incluem o custo computacional associado à avaliação de todos os vetores de tensão possíveis e a sensibilidade do desempenho a erros nos parâmetros do modelo do filtro LC. Técnicas como redução do número de candidatos baseada na localização do vetor de referência, sintonia adaptativa de pesos na função de custo e identificação on line de parâmetros são abordagens para mitigar esses desafios em aplicações práticas.