Sistemas de Controle — Teoria, PID e Controle Moderno

Fundamentos de teoria de controle: sistemas dinâmicos, controlador PID, espaço de estados, controle ótimo (LQR), sistemas de tempo discreto e aplicações em engenharia e software.

Teoria de controle é a disciplina que estuda como fazer sistemas dinâmicos se comportarem de forma desejada. De termostatos a foguetes, de reguladores de tensão a redes de computadores — controle está em todo lugar onde um sistema precisa ser mantido em um estado alvo ou conduzido de um estado para outro.

A intersecção com software e IA é crescente: algoritmos de controle aparecem em robótica, sistemas autônomos, otimização de recursos computacionais e até no treinamento de modelos de machine learning.

Papers de referência: arXiv eess.SY — Systems and Control

Fundamentos: sistemas dinâmicos

O que é um sistema de controle?

Um sistema de controle tem três componentes fundamentais:

Referência (setpoint)
        ↓
   [Controlador] → Sinal de controle → [Planta/Sistema] → Saída
        ↑                                                    |
        └──────────────── Feedback ──────────────────────────┘

Planta: o sistema físico sendo controlado (motor, processo, robô)
Controlador: algoritmo que calcula o sinal de controle
Sensor: mede a saída real
Erro: diferença entre referência e saída real

Malha aberta (open-loop): controlador não usa feedback da saída. Simples mas sensível a perturbações e incertezas.

Malha fechada (closed-loop/feedback): controlador usa a saída medida para corrigir o sinal de controle. Robusto a perturbações.

Modelo matemático de sistemas

Função de transferência (domínio da frequência)

Representa a relação entre entrada e saída via Transformada de Laplace:

G(s) = Saída(s) / Entrada(s)

Exemplos:
- Integrador: G(s) = 1/s
- Atraso de primeira ordem: G(s) = K / (τs + 1)
- Sistema de segunda ordem: G(s) = ωₙ² / (s² + 2ζωₙs + ωₙ²)

Parâmetros de um sistema de segunda ordem:

ωₙ: frequência natural (velocidade de resposta)
ζ: coeficiente de amortecimento
- ζ < 1: subamortecido (oscila)
- ζ = 1: criticamente amortecido (mais rápido sem overshoot)
- ζ > 1: superamortecido (lento, sem overshoot)

Espaço de estados (domínio do tempo)

Representação mais geral, especialmente para sistemas MIMO (múltiplas entradas, múltiplas saídas):

ẋ = Ax + Bu    (equação de estado)
y  = Cx + Du   (equação de saída)

Onde:
- x: vetor de estados (variáveis internas)
- u: vetor de entradas (sinal de controle)
- y: vetor de saídas (medidas)
- A, B, C, D: matrizes do sistema

Controlador PID

O Proporcional-Integral-Derivativo (PID) é o controlador mais usado na indústria — estima-se que 90%+ dos loops de controle industriais usam alguma variante de PID.

A lei de controle

u(t) = Kp × e(t) + Ki × ∫e(t)dt + Kd × de(t)/dt

Onde:
- e(t) = referência(t) - saída(t)  (erro)
- Kp: ganho proporcional
- Ki: ganho integral
- Kd: ganho derivativo

Contribuição de cada termo

P — Proporcional:

Responde proporcionalmente ao erro atual
Maior Kp → resposta mais rápida, mas pode oscilar
Sozinho deixa erro em regime permanente (offset)

I — Integral:

Responde ao erro acumulado no tempo
Elimina o offset do termo P
Pode causar integral windup (acumulação quando saturado)

D — Derivativo:

Responde à taxa de variação do erro
Atenua overshoots, adiciona amortecimento
Sensível a ruído (geralmente aplicado com filtro)

Implementação digital

class PIDController:
    def __init__(self, Kp, Ki, Kd, dt, output_min=-1e9, output_max=1e9):
        self.Kp = Kp
        self.Ki = Ki
        self.Kd = Kd
        self.dt = dt
        self.output_min = output_min
        self.output_max = output_max

        self._integral = 0.0
        self._prev_error = 0.0

    def compute(self, setpoint, measurement):
        error = setpoint - measurement

        # Proporcional
        P = self.Kp * error

        # Integral com anti-windup
        self._integral += error * self.dt
        I = self.Ki * self._integral

        # Derivativo (com filtro implícito pela discretização)
        derivative = (error - self._prev_error) / self.dt
        D = self.Kd * derivative
        self._prev_error = error

        # Soma e saturação
        output = P + I + D
        output = max(self.output_min, min(self.output_max, output))

        # Anti-windup: congela integrador se saturado
        if output != (P + I + D):
            self._integral -= error * self.dt

        return output

# Simulação simples
pid = PIDController(Kp=1.2, Ki=0.5, Kd=0.1, dt=0.01)
setpoint = 100.0
temperatura = 20.0

for step in range(1000):
    u = pid.compute(setpoint, temperatura)
    # Planta simples de primeira ordem: τ=10s, K=1
    temperatura += (u - temperatura) * 0.01 / 10

Sintonia de PID

Método	Tipo	Característica
Ziegler-Nichols	Experimental	Agressivo, bom ponto de partida
Cohen-Coon	Analítico	Baseado em resposta ao degrau
IMC (Internal Model Control)	Baseado em modelo	Robusto, ajuste por parâmetro único λ
Auto-tune	Automático	Perturbação de relé para estimar planta

Análise de estabilidade

Critério de Routh-Hurwitz

Determina estabilidade sem resolver as raízes do polinômio característico — verifica se todos os coeficientes têm o mesmo sinal e satisfazem condições da tabela de Routh.

Lugar das raízes (Root Locus)

Mostra como os polos do sistema em malha fechada se movem com a variação do ganho K. Fundamental para projeto gráfico de controladores.

Margens de ganho e fase (Diagrama de Bode)

import control
import numpy as np
import matplotlib.pyplot as plt

# Sistema: planta de segunda ordem
num = [1]
den = [1, 2, 1]
G = control.tf(num, den)

# Diagrama de Bode
mag, phase, omega = control.bode(G, plot=True)

# Margens
gm, pm, wgc, wpc = control.margin(G)
print(f"Margem de Ganho: {20*np.log10(gm):.1f} dB")  # Ideal: > 6 dB
print(f"Margem de Fase: {pm:.1f}°")                   # Ideal: 30-60°

Controle Moderno

Controle Ótimo — LQR

O Regulador Linear Quadrático (LQR) encontra o ganho de estado K que minimiza uma função de custo:

J = ∫₀^∞ (xᵀQx + uᵀRu) dt

Onde:
- Q: peso nos estados (quanto se penaliza desvio dos estados)
- R: peso nas entradas (quanto se penaliza esforço de controle)

Sinal de controle ótimo: u = -Kx
K encontrado resolvendo a Equação de Riccati

import control
import numpy as np

# Sistema em espaço de estados
A = np.array([[-1, 0], [0, -2]])
B = np.array([[1], [1]])
C = np.eye(2)
D = np.zeros((2, 1))

sys = control.ss(A, B, C, D)

# Matrizes de custo
Q = np.eye(2)        # penaliza estados igualmente
R = np.array([[1]])  # penaliza esforço de controle

# Calcula ganho LQR
K, S, E = control.lqr(sys, Q, R)
print(f"Ganho LQR K: {K}")

Filtro de Kalman — estimação de estado

Quando não é possível medir todos os estados, o Filtro de Kalman estima os estados a partir de medidas ruidosas — combinando o modelo do sistema com as observações de forma ótima (minimiza variância do erro de estimação).

# Filtro de Kalman - loop de estimação
class KalmanFilter:
    def __init__(self, A, B, C, Q_noise, R_noise, x0, P0):
        self.A = A  # Dinâmica do sistema
        self.B = B  # Entrada
        self.C = C  # Saída
        self.Q = Q_noise   # Covariância do ruído de processo
        self.R = R_noise   # Covariância do ruído de medição
        self.x = x0        # Estimativa inicial do estado
        self.P = P0        # Covariância inicial do erro

    def predict(self, u):
        """Predição (a priori)"""
        self.x = self.A @ self.x + self.B @ u
        self.P = self.A @ self.P @ self.A.T + self.Q

    def update(self, z):
        """Atualização com medição (a posteriori)"""
        S = self.C @ self.P @ self.C.T + self.R
        K = self.P @ self.C.T @ np.linalg.inv(S)  # Ganho de Kalman
        self.x = self.x + K @ (z - self.C @ self.x)
        self.P = (np.eye(len(self.x)) - K @ self.C) @ self.P
        return self.x

Aplicações do Filtro de Kalman:

GPS (fusão de sensores)
Rastreamento de alvos (radar)
Navegação inercial
Finanças: estimação de volatilidade, filtro de Kalman em modelos de fator dinâmico

Controle de sistemas discretos

Em sistemas digitais, o controlador opera com amostras periódicas da saída:

x[k+1] = A_d × x[k] + B_d × u[k]   (equação de estado discreta)
y[k]   = C × x[k]

Onde:
A_d = e^(A×Ts)   (matriz de transição de estado)
B_d = ∫₀^Ts e^(A×τ) B dτ
Ts: período de amostragem

Critério de Nyquist: Ts ≤ 1/(2×f_max) — frequência de amostragem deve ser pelo menos 2× a frequência mais alta do sistema.

Aplicações em Software e IA

Autoescalonamento de infraestrutura

Kubernetes HPA (Horizontal Pod Autoscaler) usa um controlador proporcional simples:

# Lógica simplificada do HPA
def hpa_controller(cpu_utilization, target_utilization, current_replicas):
    desired_replicas = current_replicas * (cpu_utilization / target_utilization)
    return round(desired_replicas)

Rate limiting adaptativo

class AdaptiveRateLimiter:
    """PID para controlar taxa de requisições"""
    def __init__(self, target_latency_ms):
        self.pid = PIDController(Kp=0.1, Ki=0.01, Kd=0.0, dt=1.0)
        self.target = target_latency_ms
        self.max_rps = 1000

    def update(self, current_latency_ms):
        error_signal = self.pid.compute(self.target, current_latency_ms)
        new_rps = self.max_rps + error_signal
        return max(1, int(new_rps))

Otimização de hiperparâmetros de ML

Bayesian Optimization pode ser vista como controle: navega pelo espaço de hiperparâmetros para encontrar o ótimo, similar a como um controlador navega pelo espaço de estados.

Controle em Robótica

# Controlador de posição para robô simples (1 DOF)
class RobotArmController:
    def __init__(self):
        self.pid = PIDController(Kp=10.0, Ki=0.1, Kd=2.0, dt=0.001,
                                  output_min=-100, output_max=100)

    def move_to(self, target_angle, current_angle):
        torque = self.pid.compute(target_angle, current_angle)
        return torque  # aplicar ao motor

Conexões com outras seções

Aprendizado por Reforço — RL como controle ótimo; política = controlador aprendido
Séries Temporais com ML — Filtro de Kalman em modelos de séries temporais
Infraestrutura e DevOps — controle de recursos em sistemas distribuídos
Algoritmos — algoritmos de controle como componente de sistemas de software

Referências:

Aviso Legal: Conteúdo educativo. Sistemas de controle em aplicações críticas (aeronáutica, medicina, energia) requerem validação especializada.

Sistemas de Controle — Teoria, PID e Controle Moderno

On this page