Como engenheiro responsável pelo sistema de controle de uma usina nuclear, foi demandando o serviço de analisar a equação de um sistema de compensação que controla a temperatura do forno a fissão nuclear. O sistema de controle é baseado em um PI aplicado no set-point de temperatura, conforme equação a seguir:
m[k+1]=m[k]+kp(e[k+1]-e[k])+(ki T2)(e[k+1]+e[k])
em que e[k] representa o sinal de entrada e m[k] o sinal de saída do compensador digital, ki e kp são parâmetros.
(2,5) Faça um esboço do algoritmo que executa a EaD do PI, para ser implementado no microcontrolador do sistema de controle, considerando que o sinal de entrada é fornecido de um conversar AD, e o de saída enviado a um DA.

Passo 1

Beleza, vamos resumir o que a gente tem:
– Enunciado: um controle PI digital pra ajustar a vazão do refrigerante da usina, descrito por
m[k!+!1] ;=; m[k] ;+; kpl(e[k!+!1]-e[k]r);+;ki T2,l(e[k!+!1]+e[k]r)
onde
é o erro (entrada) em amostra ,
é a saída do compensador em amostra ,
e são ganhos proporcional e integral,
é o período de amostragem.
O que a questão pede: “faça um esboço de algoritmo (pseudo-código) para implementar isso num microcontrolador, lendo de um ADC e enviando a um DAC.”
Conteúdo da matéria:
– Sistemas de controle digital
– Discretização do controlador PI (regra trapezoidal)
– Codificação em microcontrolador: inicialização, loop de leitura-cálculo-saída
O que vamos precisar:
  1. Variáveis para armazenar valores atuais e anteriores de e .
  2. Definição de constantes , e .
  3. Rotina de leitura do ADC e de escrita no DAC.
  4. Pseudo-código com o laço infinito de controle.

Passo 2

Entendendo a teoria por trás da fórmula:
  1. Proporcional §: reage instantaneamente ao erro. É o termo kpl(e[k+1]-e[k]r) que, discretizado em “diferença”, dá uma ação proporcional à variação do erro.
  2. Integral (I): acumula o erro ao longo do tempo. Pela regra trapezoidal, o incremento integral entre duas amostras é ki T2,l(e[k+1]+e[k]r) Isso evita “drift” e faz com que o erro estacionário tenda a zero.
No final, somamos tudo ao valor anterior pra obter .

Passo 3

Definindo variáveis e inicialização no micro:
// Constantes (definidas em tempo de configuração)
float Kp = /* valor de kp */;
float Ki = /* valor de ki */;
float T  = /* período de amostragem */;

// Variáveis de memória
float e_prev = 0.0f;     // e[k]
float m_prev = 0.0f;     // m[k]
float e_curr, m_curr;    // e[k+1], m[k+1]
Antes de começar o laço principal, deixamos e_prev e m_prev com um valor inicial (normalmente zero ou o ponto de operação).

Passo 4

Esboço do loop de controle (pseudo-código comentado):
while (1) {
    // 1) Leitura do erro atual do ADC
    e_curr = ReadADC();       // e[k+1]

    // 2) Cálculo da ação proporcional (diferença de erro)
    float deltaP = Kp * (e_curr - e_prev);

    // 3) Cálculo da ação integral (regra trapezoidal)
    float deltaI = (Ki * T / 2.0f) * (e_curr + e_prev);

    // 4) Atualiza saída do compensador
    m_curr = m_prev + deltaP + deltaI;

    // 5) (Opcional) Saturação para respeitar limites do DAC
    if (m_curr > MAX_DAC) m_curr = MAX_DAC;
    else if (m_curr < MIN_DAC) m_curr = MIN_DAC;

    // 6) Envia para o DAC
    WriteDAC(m_curr);

    // 7) Atualiza estados para próxima amostra
    e_prev = e_curr;
    m_prev = m_curr;

    // 8) Espera até a próxima amostra (timer ou delay)
    WaitSamplingPeriod(T);
}
Explanação rápida das etapas:
  • Leitura (ReadADC): converte tensão em valor digital de erro.
  • deltaP e deltaI: aplicam os ganhos proporcional e integral.
  • m_curr: nova saída do PI.
  • Saturação: evita enviar valores fora da faixa do DAC.
  • Atualização de variáveis: shift de amostras para a próxima iteração.
  • Tempo de amostragem: garante que o algoritmo rode exatamente a cada segundos.

Resposta

Segue o esboço completo do algoritmo em pseudo-código, pronto pra implementar no microcontrolador:
// Configuração inicial
float Kp = /* ganho proporcional */;
float Ki = /* ganho integral */;
float T  = /* período de amostragem */;
float e_prev = 0.0f, m_prev = 0.0f;

// Loop principal de controle
while (1) {
    // Leitura do erro via ADC
    float e_curr = ReadADC();

    // Termo Proporcional
    float deltaP = Kp * (e_curr - e_prev);

    // Termo Integral (trapézio)
    float deltaI = (Ki * T / 2.0f) * (e_curr + e_prev);

    // Nova saída do PI
    float m_curr = m_prev + deltaP + deltaI;

    // Saturação para limites do DAC
    if (m_curr > MAX_DAC) m_curr = MAX_DAC;
    else if (m_curr < MIN_DAC) m_curr = MIN_DAC;

    // Envia valor ao DAC
    WriteDAC(m_curr);

    // Atualiza histórico
    e_prev = e_curr;
    m_prev = m_curr;

    // Aguarda próximo instante de amostragem
    WaitSamplingPeriod(T);
}

Exercícios relacionados