Sistema PID e Diferenças entre Sistemas de Controle Aberto e Fechado

O controle PID (Proporcional-Integral-Derivativo) é um dos métodos mais amplamente utilizados na automação e controle de processos industriais. Sua aplicação se dá em sistemas onde se deseja controlar uma variável de saída a partir de uma entrada desejada, minimizando erros e garantindo estabilidade. Este artigo apresenta os fundamentos do controle PID, explora as diferenças entre sistemas de controle aberto e fechado e fornece uma implementação prática do algoritmo em linguagem C, com explicações detalhadas e documentação apropriada.

Introdução aos Sistemas de Controle

Os sistemas de controle são fundamentais em diversas áreas da engenharia, permitindo a automação de processos mecânicos, elétricos e químicos. De maneira geral, esses sistemas podem ser classificados em controle aberto e controle fechado, cada um com características e aplicações distintas.

Sistemas de Controle Aberto

Um sistema de controle aberto é aquele no qual a saída não influencia diretamente a ação de controle. Ou seja, a entrada é aplicada ao sistema e a saída é gerada sem qualquer tipo de realimentação. Esse tipo de controle é simples, mas apresenta limitações significativas, pois não se ajusta automaticamente às variações externas ou internas do sistema.

Exemplo de Sistema de Controle Aberto

Torradeira elétrica: Uma torradeira aplica calor ao pão por um tempo pré-determinado sem medir se ele realmente atingiu o nível de tostagem desejado.

Vantagens:

Simplicidade na implementação;
Baixo custo.

Desvantagens:

Sensibilidade a perturbações externas;
Incapacidade de correção automática de erros.

Sistemas de Controle Fechado

Diferente dos sistemas abertos, um sistema de controle fechado utiliza realimentação (feedback) para ajustar automaticamente a saída conforme a necessidade. Um sensor mede a variável de saída e compara com o valor desejado (setpoint), ajustando o sinal de controle para minimizar o erro.

Exemplo de Sistema de Controle Fechado

Controle de temperatura de um forno: Um sensor mede a temperatura interna do forno e ajusta a potência do aquecedor para manter a temperatura desejada.

Vantagens:

Maior precisão no controle da variável de interesse;
Capacidade de compensação de perturbações externas;
Melhor estabilidade do sistema.

Desvantagens:

Maior complexidade e custo;
Necessidade de calibração e ajuste dos parâmetros.

Fundamentos do Controle PID

O controlador PID é um tipo de controlador de realimentação que utiliza três componentes matemáticos principais para ajustar a resposta do sistema: Proporcional (P), Integral (I) e Derivativo (D). A equação geral do PID pode ser expressa como: u(t)=Kpe(t)+Ki∫e(t)dt+Kdde(t)dtu(t) = K_p e(t) + K_i \int e(t) dt + K_d \frac{d e(t)}{dt}

Onde:

u(t)u(t) é o sinal de controle;
e(t)e(t) é o erro, definido como a diferença entre o valor desejado e o valor atual;
KpK_p é o ganho proporcional;
KiK_i é o ganho integral;
KdK_d é o ganho derivativo.

Cada um desses termos tem um papel fundamental no comportamento do sistema:

Proporcional (P): Controla a resposta imediata do sistema ao erro, ajustando a intensidade do sinal de controle proporcionalmente ao erro.
Integral (I): Acumula os erros passados para eliminar erros de estado estacionário.
Derivativo (D): Prever tendências futuras de erro e atuar para minimizar oscilações.

Implementação do Algoritmo PID em C

Para demonstrar o funcionamento do controlador PID, implementamos um algoritmo em C, documentado e estruturado para ser usado em sistemas embarcados e aplicações de controle industrial.

A implementação abaixo utiliza uma estrutura de dados para armazenar os parâmetros do controlador PID e inclui uma função para calcular a saída do controlador com base no erro de entrada.

Código em C

#include <stdio.h>

// Definição da estrutura do controlador PID
typedef struct {
    double Kp;  // Ganho Proporcional
    double Ki;  // Ganho Integral
    double Kd;  // Ganho Derivativo
    double prevError; // Erro anterior
    double integral;  // Acumulador do termo integral
    double dt;  // Tempo de amostragem
} PIDController;

// Função para inicializar o controlador PID
void PID_Init(PIDController *pid, double Kp, double Ki, double Kd, double dt) {
    pid->Kp = Kp;
    pid->Ki = Ki;
    pid->Kd = Kd;
    pid->prevError = 0.0;
    pid->integral = 0.0;
    pid->dt = dt;
}

// Função para calcular a saída do controlador PID
double PID_Compute(PIDController *pid, double setpoint, double measuredValue) {
    double error = setpoint - measuredValue;  // Calcula o erro
    pid->integral += error * pid->dt;  // Calcula o termo integral
    double derivative = (error - pid->prevError) / pid->dt;  // Calcula o termo derivativo

    // Calcula a saída do PID
    double output = (pid->Kp * error) + (pid->Ki * pid->integral) + (pid->Kd * derivative);

    // Atualiza o erro anterior para a próxima iteração
    pid->prevError = error;

    return output;
}

// Exemplo de uso do controlador PID
int main() {
    PIDController pid;
    PID_Init(&pid, 1.2, 0.01, 0.5, 0.1);  // Inicializa o PID com valores arbitrários

    double setpoint = 100.0;  // Valor desejado
    double measuredValue = 90.0;  // Valor real medido

    for (int i = 0; i < 10; i++) {  // Simulação de 10 iterações
        double controlSignal = PID_Compute(&pid, setpoint, measuredValue);
        measuredValue += controlSignal * 0.1;  // Simula um sistema reagindo ao controle

        printf("Iteração %d - Controle: %.2f - Medida Atual: %.2f\n", i + 1, controlSignal, measuredValue);
    }

    return 0;
}

Explicação do Código

O código acima segue uma estrutura modular e bem documentada:

Estrutura PIDController:
- Armazena os parâmetros do controlador (Kp, Ki, Kd).
- Mantém o erro anterior e o termo integral acumulado.
- Inclui o tempo de amostragem (dt), necessário para cálculos diferenciais.
Função PID_Init:
- Inicializa os valores do controlador, garantindo que os estados internos sejam zerados.
Função PID_Compute:
- Calcula o erro entre o valor desejado (setpoint) e o valor real (measuredValue).
- Atualiza o termo integral e computa a derivada do erro.
- Gera a saída do controlador PID.
Função main:
- Cria um controlador PID e o inicializa com ganhos arbitrários.
- Simula um sistema onde a saída do PID afeta diretamente a variável controlada.
- Exibe os valores de controle ao longo das iterações.