Synapsys Blog

PID com Anti-Windup: Teoria, Ajuste e Validação Experimental

2026-04-23T00:00:00.000Z

O windup integral é um dos modos de falha mais comuns em controladores PID em produção. Este post cobre o problema a partir dos primeiros princípios, deriva o esquema de anti-windup por back-calculation, mostra como o Synapsys o implementa e valida o projeto contra uma planta simulada de segunda ordem.

O problema do windup

Um controlador PID com saturação na saída tem uma interação problemática: quando o atuador está saturado, o integrador continua acumulando erro mesmo que a saída esteja limitada. Quando o sinal do erro se inverte, o integrador leva muito tempo para "desacumular" antes que a saída saia da saturação — causando sobressinal e oscilação.

Anti-windup por back-calculation

O esquema de back-calculation realimenta o erro de saturação para o integrador com ganho $1/T_t$ :

\dot{I}(t) = K_i \cdot e(t) + \frac{1}{T_t}\bigl[u_{sat}(t) - u_{uns}(t)\bigr]

Quando a saída não está saturada, $u_{sat} = u_{uns}$ e o termo de correção é zero — o integrador se comporta normalmente.

Implementação no Synapsys

from synapsys.algorithms import PID

pid = PID(
    Kp    = 5.0,
    Ki    = 2.0,
    Kd    = 0.1,
    dt    = 0.01,
    u_min = -1.0,
    u_max =  1.0,
    # anti_windup=True é o padrão
)

u = pid.compute(setpoint=5.0, measurement=y)

Simulação comparativa

Simulação
Resultados

import numpy as np
from synapsys.algorithms import PID
from synapsys.api import ss, c2d

planta = c2d(ss([[-0.5]], [[1]], [[1]], [[0]]), dt=0.01)

def rodar_sim(anti_windup: bool, n_passos: int = 800):
    pid = PID(Kp=5.0, Ki=2.0, Kd=0.05, dt=0.01,
              u_min=-1.0, u_max=1.0, anti_windup=anti_windup)
    x = np.zeros(1)
    ys = []
    for i in range(n_passos):
        setpoint = 3.0 if i < 400 else -3.0
        y = float(x[0])
        u = np.array([pid.compute(setpoint, y)])
        x, _ = planta.evolve(x, u)
        ys.append(y)
    return np.array(ys)

y_sem = rodar_sim(anti_windup=False)
y_com = rodar_sim(anti_windup=True)

Diretrizes de ajuste para pesquisa

Parâmetro	Efeito	Ponto de partida
$K_p$	Velocidade de resposta	FOPDT: $K_p = 0,6 / (K_{planta} \cdot \tau)$
$K_i = K_p / T_i$	Eliminação de erro em regime permanente	$T_i = 2\tau$
$K_d = K_p \cdot T_d$	Amortecimento, amplificação de ruído	$T_d = \tau / 4$
$u_{min}, u_{max}$	Limites do atuador	Especificação física do atuador

Conexão com a literatura

O esquema de back-calculation usado no Synapsys segue Åström & Hägglund (2006) Advanced PID Control, Capítulo 6.

@book{astrom2006advanced,
  author    = {Åström, Karl Johan and Hägglund, Tore},
  title     = {Advanced PID Control},
  publisher = {ISA — The Instrumentation, Systems, and Automation Society},
  year      = {2006},
  isbn      = {978-1556175169},
}

A referência completa da API está em synapsys.algorithms →.

Do Modelo ao Hardware: MIL → SIL → HIL em Três Etapas

2026-04-22T00:00:00.000Z

MIL → SIL → HIL é a progressão padrão do modelo-V para controle embarcado: simule tudo primeiro, depois substitua o modelo da planta por hardware real uma camada de cada vez. Com Synapsys, a transição é uma troca de uma linha porque a camada de transporte é totalmente abstraída do algoritmo.

As três etapas

Etapa	Planta	Controlador	Transporte	Objetivo
MIL	Simulada (`StateSpace`)	Código do algoritmo	Memória compartilhada	Iteração rápida, testes unitários
SIL	Simulada	Binário compilado / processo externo	ZeroMQ	Testes de integração, perfil de latência
HIL	Dispositivo real	Código do algoritmo ou firmware MCU	`HardwareInterface`	Testes de aceitação na planta real

Etapa 1 — MIL: tudo em um processo

from synapsys.api import ss, c2d
from synapsys.agents import PlantAgent, ControllerAgent, SyncEngine, SyncMode
from synapsys.algorithms import PID
from synapsys.transport import SharedMemoryTransport
import numpy as np

planta_d = c2d(ss([[-1]], [[1]], [[1]], [[0]]), dt=0.01)
pid = PID(Kp=4.0, Ki=1.0, dt=0.01)

def lei(y: np.ndarray) -> np.ndarray:
    return np.array([pid.compute(setpoint=3.0, measurement=y[0])])

with SharedMemoryTransport("demo", {"y": 1, "u": 1}, create=True) as bus:
    bus.write("y", np.zeros(1))
    bus.write("u", np.zeros(1))
    sync = SyncEngine(SyncMode.LOCK_STEP, dt=0.01)
    PlantAgent("planta", planta_d, bus, sync).start(blocking=False)
    ControllerAgent("ctrl", lei, bus, sync).start(blocking=True)

Etapa 2 — SIL: dois processos via ZeroMQ

A função lei não muda. Apenas o transporte é trocado:

processo_planta.py
processo_controlador.py

from synapsys.api import ss, c2d
from synapsys.agents import PlantAgent, SyncEngine, SyncMode
from synapsys.transport import ZMQTransport

planta_d = c2d(ss([[-1]], [[1]], [[1]], [[0]]), dt=0.01)
pub = ZMQTransport("tcp://*:5555", mode="pub")
sub = ZMQTransport("tcp://localhost:5556", mode="sub")
sync = SyncEngine(SyncMode.WALL_CLOCK, dt=0.01)
PlantAgent("planta", planta_d, pub, sync, sub_transport=sub).start(blocking=True)

from synapsys.agents import ControllerAgent, SyncEngine, SyncMode
from synapsys.algorithms import PID
from synapsys.transport import ZMQTransport
import numpy as np

pid = PID(Kp=4.0, Ki=1.0, dt=0.01)

def lei(y: np.ndarray) -> np.ndarray:
    return np.array([pid.compute(setpoint=3.0, measurement=y[0])])

sub = ZMQTransport("tcp://localhost:5555", mode="sub")
pub = ZMQTransport("tcp://*:5556", mode="pub")
sync = SyncEngine(SyncMode.WALL_CLOCK, dt=0.01)
ControllerAgent("ctrl", lei, sub, sync, pub_transport=pub).start(blocking=True)

Etapa 3 — HIL: hardware real

from synapsys.agents import HardwareAgent, SyncEngine, SyncMode
from synapsys.hw import HardwareInterface
from synapsys.transport import ZMQTransport
import numpy as np

class MinhaInterfaceDAQ(HardwareInterface):
    def __init__(self):
        super().__init__(n_inputs=1, n_outputs=1)

    def read_outputs(self, timeout_ms: float = 100.0) -> np.ndarray:
        # return np.array([self.daq.read_channel(0)])
        return np.array([0.0])   # stub

    def write_inputs(self, u: np.ndarray, timeout_ms: float = 100.0) -> None:
        # self.daq.write_channel(0, float(u[0]))
        pass

sub = ZMQTransport("tcp://localhost:5556", mode="sub")
pub = ZMQTransport("tcp://*:5555", mode="pub")
sync = SyncEngine(SyncMode.WALL_CLOCK, dt=0.01)
HardwareAgent("hw", MinhaInterfaceDAQ(), pub, sync, sub_transport=sub).start(blocking=True)

O processo controlador não muda. A troca é cirúrgica.

Resumo

Etapa	O que muda
MIL → SIL	`SharedMemoryTransport` → `ZMQTransport`, dividir em dois processos
SIL → HIL	`PlantAgent` → `HardwareAgent(MinhaInterfaceDAQ())`
Algoritmo de controle	Não muda

Veja o exemplo SIL completo em examples/advanced/02_sil_ai_controller/.

Controle MIMO de um Quadrotor com Neural-LQR

2026-04-21T00:00:00.000Z

Um quadrotor possui quatro rotores, seis graus de liberdade de corpo rígido e dinâmica rotacional totalmente acoplada — é o benchmark MIMO da robótica aérea. Este post percorre o pipeline completo de projeto: física → linearização → LQR → residual Neural-LQR → simulação 3D.

Modelo em espaço de estados

A linearização de 12 estados em torno do equilíbrio de hover utiliza posição $(x, y, z)$ , velocidade $(\dot x, \dot y, \dot z)$ , ângulos de Euler $(\phi, \theta, \psi)$ e taxas angulares $(p, q, r)$ .

import numpy as np
from synapsys.api import ss, c2d
from synapsys.algorithms import lqr
from quadcopter_dynamics import build_matrices

A, B, C, D = build_matrices()    # A: 12×12, B: 12×4
planta = ss(A, B, C, D)

print(f"Estável: {planta.is_stable()}")  # False — integradores na posição

Projeto LQR MIMO

Q = np.diag([
    10.0, 10.0, 20.0,    # x, y, z
    1.0,  1.0,  1.0,     # ẋ, ẏ, ż
    20.0, 20.0, 10.0,    # φ, θ, ψ
    2.0,  2.0,  2.0,     # p, q, r
])
R = np.eye(4) * 0.5

K, P = lqr(A, B, Q, R)
print(f"Shape de K: {K.shape}")   # (4, 12)

A_cl = A - B @ K
print(f"Estável em malha fechada: {np.all(np.real(np.linalg.eigvals(A_cl)) < 0)}")

Neural-LQR Residual

u = -Ke + \underbrace{\text{MLP}(e)}_{\text{residual}}

A camada de saída do MLP é inicializada com zeros — na inicialização, o controlador é exatamente LQR. O residual adiciona correção apenas após treinamento, garantindo estabilidade provável desde o início.

import torch
import torch.nn as nn

class MLPResidual(nn.Module):
    def __init__(self, n_estados: int, n_entradas: int):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(n_estados, 64), nn.Tanh(),
            nn.Linear(64, 64),        nn.Tanh(),
            nn.Linear(64, n_entradas),
        )
        nn.init.zeros_(self.net[-1].weight)
        nn.init.zeros_(self.net[-1].bias)

    def forward(self, e: torch.Tensor) -> torch.Tensor:
        return self.net(e)

mlp = MLPResidual(n_estados=12, n_entradas=4)

def lei_neural_lqr(e: np.ndarray) -> np.ndarray:
    with torch.no_grad():
        e_t = torch.tensor(e, dtype=torch.float32)
        return (-K @ e) + mlp(e_t).numpy()

Simulação em malha fechada

from synapsys.api import c2d
from synapsys.agents import PlantAgent, ControllerAgent, SyncEngine, SyncMode
from synapsys.broker import MessageBroker, Topic, SharedMemoryBackend

dt = 0.02
planta_d = c2d(planta, dt=dt)

topics = [Topic("quad/estado", shape=(12,)), Topic("quad/u", shape=(4,))]
broker = MessageBroker()
for t in topics:
    broker.declare_topic(t)
broker.add_backend(SharedMemoryBackend("quad_bus", topics, create=True))

ref = np.array([0, 0, 1.5, 0, 0, 0, 0, 0, 0, 0, 0, 0])

def lei(y: np.ndarray) -> np.ndarray:
    return lei_neural_lqr(ref - y)

sync = SyncEngine(SyncMode.LOCK_STEP, dt=dt)
PlantAgent("quad", planta_d, None, sync,
           channel_y="quad/estado", channel_u="quad/u", broker=broker).start(blocking=False)
ControllerAgent("ctrl", lei, None, sync,
                channel_y="quad/estado", channel_u="quad/u", broker=broker).start(blocking=True)
broker.close()

Resultados

Erro de posição < 0,08 m RMS após a primeira órbita
Ângulos de Euler dentro de ±5° durante manobras agressivas
Entradas de controle suaves — o custo do atuador em $R$ funcionou

O código completo está em examples/advanced/06_quadcopter_mimo/.

Estabilizando um Pêndulo Invertido com LQR

2026-04-20T00:00:00.000Z

O pêndulo invertido é o benchmark canônico do controle não-linear — instável, simples o suficiente para modelar analiticamente, mas rico o suficiente para revelar todo o fluxo de projeto LQR. Este post deriva o modelo linearizado a partir da física e mostra como estabilizá-lo com Synapsys em poucas dezenas de linhas de Python.

Física e linearização

Uma haste rígida de massa $m$ e comprimento $L$ é articulada em um carrinho. Seja $\theta$ o ângulo em relação à vertical. Linearizando em torno de $\theta = 0$ :

\ddot{\theta} = \frac{g}{L}\theta - \frac{1}{mL^2}u

Escolhendo o vetor de estados $x = [\theta,\; \dot{\theta}]^\top$ e a força do carrinho $u$ :

\dot{x} = \underbrace{\begin{bmatrix}0 & 1 \\ g/L & 0\end{bmatrix}}_{A}\, x + \underbrace{\begin{bmatrix}0 \\ -1/(mL^2)\end{bmatrix}}_{B}\, u, \qquad y = \begin{bmatrix}1 & 0\end{bmatrix} x

Para $m = 0,5$ kg, $L = 0,3$ m, $g = 9,81$ m/s²:

import numpy as np
from synapsys.api import ss

m, L, g = 0.5, 0.3, 9.81

A = np.array([[0,      1   ],
              [g/L,    0   ]])
B = np.array([[0           ],
              [-1/(m*L**2) ]])
C = np.array([[1, 0]])
D = np.zeros((1, 1))

planta = ss(A, B, C, D)
print(planta.is_stable())      # False — polos em ±√(g/L) = ±5,72 rad/s

Projeto LQR

O LQR encontra o ganho de realimentação de estados $K$ que minimiza:

J = \int_0^\infty \left(x^\top Q\, x + u^\top R\, u\right)\mathrm{d}t

$Q$ grande penaliza erro de estado (rápido, agressivo). $R$ grande penaliza esforço de controle (lento, conservador):

from synapsys.algorithms import lqr

Q = np.diag([100.0, 1.0])   # penaliza ângulo pesadamente
R = np.array([[0.1]])

K, P = lqr(A, B, Q, R)
print(f"K = {K}")            # K = [[33.2  5.8]]

A_cl = A - B @ K
print(np.linalg.eigvals(A_cl))   # autovalores no semiplano esquerdo

Simulação

from synapsys.api import c2d
import matplotlib.pyplot as plt

cl = ss(A_cl, B, C, D)

t = np.linspace(0, 3, 600)
x0 = np.array([0.2, 0.0])       # θ₀ = 0,2 rad (≈ 11°)
u_zero = np.zeros((len(t), 1))
t_out, y = cl.simulate(t, u_zero, x0=x0)

plt.plot(t_out, y)
plt.xlabel("Tempo (s)"); plt.ylabel("θ (rad)")
plt.title("Pêndulo Invertido — estabilização LQR de θ₀ = 0,2 rad")
plt.grid(True); plt.show()

O ângulo retorna a zero em aproximadamente 1,5 s sem sobressinal.

Discretização para deployment embarcado

dt = 0.01  # 100 Hz
planta_d = c2d(planta, dt=dt)

# Redesenhar K no tempo discreto
K_d, _ = lqr(planta_d.A, planta_d.B, Q, R)

# Laço de controle embarcado
x = np.zeros(2)
for _ in range(n_steps):
    u = -K_d @ x
    x, y = planta_d.evolve(x, u)

Resumo das APIs

Etapa	API Synapsys
Modelagem	`ss(A, B, C, D)`
Verificação de estabilidade	`planta.is_stable()`, `planta.poles()`
Projeto LQR	`lqr(A, B, Q, R)` → retorna `(K, P)`
Simulação	`cl.simulate(t, u, x0=x0)`
Discretização	`c2d(planta, dt=0.01)`
Laço embarcado	`planta_d.evolve(x, u)`

O notebook completo está em examples/quickstart_en.ipynb.

Bem-vindo ao Blog Synapsys

2026-04-19T00:00:00.000Z

Bem-vindo ao Blog Synapsys — um espaço dedicado à engenharia de sistemas de controle, pesquisa acadêmica e aplicações reais da biblioteca Synapsys.

O que você encontrará aqui

Este blog é voltado para pesquisadores, estudantes de pós-graduação e engenheiros que trabalham na interseção da teoria clássica de controle com software moderno. Cada post focará em um problema concreto e mostrará como resolvê-lo do início ao fim com Synapsys.

Séries planejadas

Série	O que cobre
Teoria de Controle na Prática	Modelagem, análise e projeto a partir dos primeiros princípios
Da Simulação ao Hardware	MIL → SIL → HIL passo a passo
Controle Aumentado por IA	Neural-LQR, políticas RL e integração com PyTorch
Snippets de Pesquisa	Posts curtos conectando funcionalidades da biblioteca a artigos publicados
Notas de Release	O que há de novo em cada versão com exemplos práticos

Gostinho rápido: resposta ao degrau em 5 linhas

from synapsys.api import tf, feedback, step

G = tf([1], [1, 2, 1])   # G(s) = 1 / (s² + 2s + 1)
T = feedback(G)           # realimentação negativa unitária
t, y = step(T)            # simula resposta ao degrau

O ganho DC da malha fechada converge para 1,0, com frequência natural $\omega_n = 1$ rad/s e $\zeta = 1$ (criticamente amortecido) — como esperado pelo denominador.

Instalar

pip install synapsys   # ou: uv add synapsys

Por que Synapsys?

A maioria das bibliotecas Python de controle foca em análise. Synapsys adiciona uma camada de simulação e deployment: agentes que rodam em tempo real, um barramento de comunicação independente de transporte, e uma abstração de hardware que torna MIL/SIL/HIL uma mudança de configuração, não uma reescrita.

Foi construída junto com pesquisa de pós-graduação em sistemas de controle multi-agente e é projetada para ser legível, testável e citável academicamente.

Fique conectado

Dê um watch no repositório no GitHub para novos releases
Abra uma issue se tiver um tema que gostaria de ver abordado

O primeiro post técnico — Estabilizando um Pêndulo Invertido com LQR — vem a seguir.

Synapsys Blog

PID com Anti-Windup: Teoria, Ajuste e Validação Experimental

O problema do windup​

Anti-windup por back-calculation​

Implementação no Synapsys​

Simulação comparativa​

Diretrizes de ajuste para pesquisa​

Conexão com a literatura​

Do Modelo ao Hardware: MIL → SIL → HIL em Três Etapas

As três etapas​

Etapa 1 — MIL: tudo em um processo​

Etapa 2 — SIL: dois processos via ZeroMQ​

Etapa 3 — HIL: hardware real​

Resumo​

Controle MIMO de um Quadrotor com Neural-LQR

Modelo em espaço de estados​

Projeto LQR MIMO​

Neural-LQR Residual​

Simulação em malha fechada​

Resultados​