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:

1. 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.
2. Função PID_Init:
   • Inicializa os valores do controlador, garantindo que os estados internos sejam zerados.
3. 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.
4. 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.

The post Sistema PID e Diferenças entre Sistemas de Controle Aberto e Fechado first appeared on MCU & FPGA.