🎯 Controle PID na prática

O controle mais simples é o liga/desliga: abaixo do alvo, motor no máximo; acima, motor desligado. Funciona num ferro de passar, que esquenta devagar. Num robô, que reage rápido, o resultado é um vaivém sem fim: a roda passa do alvo, freia, fica abaixo, acelera tudo de novo. O seguidor de linha "dança" na pista e perde as curvas. Falta uma resposta proporcional: corrigir pouco quando o erro é pequeno e muito quando é grande.

Como ler: a linha âmbar é o alvo nos dois gráficos. À esquerda, a velocidade bate no alvo e já passa, porque o motor só conhece "tudo" ou "nada". À direita, o PID reduz a força conforme chega perto: um pequeno passo além do alvo e depois fica em cima dele.

Por que aprender

O PID está no controle de velocidade de carro, no drone, na impressora 3D e no braço da Trilha 5. Entender por que o liga/desliga falha é entender o problema que o PID resolve.

Conceitos-chave

Imagine que você dirige e quer ficar no meio da faixa. O P (proporcional) é girar o volante conforme a distância do meio: longe, gira muito; perto, pouco. Só com ele, você zigue-zagueia. O D (derivativo) olha a velocidade com que você se aproxima do meio e alivia o volante antes de passar: amortece o zigue-zague. O I (integral) percebe que, com vento lateral, você sempre fica um pouco à direita, e vai somando esse erro até compensar.

Como ler: as três curvas respondem ao mesmo pedido de "acelere até o alvo". A cinza (só P) para antes: sobra um erro fixo. A ciano (P + I) elimina esse erro, mas a soma passa do ponto e balança. A azul (PID) usa o D para frear a chegada e assenta mais cedo.

Por que aprender

Quem entende o papel de cada letra sintoniza olhando o gráfico: "passou demais, mais D"; "ficou abaixo, mais I". Quem não entende fica trocando números ao acaso.

Conceitos-chave

Em código, o PID é uma função chamada sempre no mesmo intervalo, como a cada 10 ms. O intervalo fixo importa: a integral soma erro × tempo e a derivada divide por tempo; se o intervalo variar, os ganhos mudam de efeito sozinhos. Por isso o laço usa micros() e um "próximo instante" marcado, em vez de delay().

Como ler: siga as setas azuis da esquerda para a direita: alvo, erro, PID, PWM, motor. A seta ciano tracejada é a medida voltando. No código abaixo, o "motor + encoder" é uma simulação de duas linhas, para você brincar com os ganhos sem hardware; no tópico 6 ela vira o motor de verdade.

Objetivo: rodar um PID completo a 100 Hz contra um motor simulado, com alvo alternando entre 120 e 220 RPM a cada 4 s e uma "subida" que freia a roda a partir de 12 s. Você muda os ganhos digitando no Serial Monitor (ex.: p3, i5, d0.05). Roda no Wokwi com um ESP32 sozinho.

// PID contra um motor simulado: entenda os ganhos sem hardware (pacote esp32 3.x)
struct PID {
  float kp = 1.0, ki = 0.0, kd = 0.0;          // comece só com P
  float saidaMin = 0, saidaMax = 255;           // limites do PWM
  float integral = 0, dFiltrada = 0, medidaAnt = 0;
  bool primeira = true;
  float calcula(float alvo, float medida, float dt) {
    float erro = alvo - medida;
    if (primeira) { medidaAnt = medida; primeira = false; }
    float dBruta = -(medida - medidaAnt) / dt;   // derivada da MEDIDA: sem tranco quando o alvo muda
    medidaAnt = medida;
    dFiltrada += 0.2 * (dBruta - dFiltrada);       // filtro passa-baixa na derivada
    float novaIntegral = integral + ki * erro * dt;
    float saida = kp * erro + novaIntegral + kd * dFiltrada;
    if (saida > saidaMax) { saida = saidaMax; if (erro < 0) integral = novaIntegral; }  // anti-windup
    else if (saida < saidaMin) { saida = saidaMin; if (erro > 0) integral = novaIntegral; }
    else integral = novaIntegral;
    return saida;
  }
};

PID pid;
const unsigned long PERIODO_US = 10000;       // 10 ms = 100 Hz
const float DT = PERIODO_US / 1e6;
float vel = 0;                                 // velocidade simulada, em RPM

void motorSimulado(float pwm) {                  // motor de 1ª ordem: tende a 1,2 x PWM em ~0,3 s
  float carga = (millis() > 12000) ? 40 : 0;    // a partir de 12 s, uma subida freia a roda
  vel += ((1.2 * pwm - carga) - vel) * DT / 0.3;
}

void setup() {
  Serial.begin(115200);
  Serial.setTimeout(20);
  Serial.println("Digite p, i ou d seguido do valor. Ex.: p3");
}

void loop() {
  static unsigned long proximo = micros();
  if ((long)(micros() - proximo) < 0) return;  // ainda não chegou o próximo instante
  proximo += PERIODO_US;
  if (Serial.available()) {
    char g = Serial.read();
    float v = Serial.parseFloat();
    if (g == 'p') pid.kp = v; else if (g == 'i') pid.ki = v; else if (g == 'd') pid.kd = v;
  }
  float alvo = ((millis() / 4000) % 2) ? 220 : 120;
  float pwm = pid.calcula(alvo, vel, DT);
  motorSimulado(pwm);
  static int n = 0;
  if (++n % 5 == 0) Serial.printf("alvo:%.0f,vel:%.1f,pwm:%.0f\n", alvo, vel, pwm);
}

Por que aprender

Esta estrutura de PID é a que você vai copiar para o seguidor de linha do 2.6, para o giro do robô que segue objetos no 3.6 e para qualquer coisa que precise "chegar e ficar". Testar com simulação primeiro separa erro de código de erro de montagem.

Conceitos-chave

Sintonizar é escolher Kp, Ki e Kd para o seu robô. Não existe número universal: depende do motor, da roda, do peso e da bateria. Há dois caminhos que se completam. O método Ziegler-Nichols dá um ponto de partida a partir de um único teste; o ajuste na mão, olhando o Serial Plotter, faz o acabamento.

Ajuste na mão, na ordem certa

Ziegler-Nichols simplificado: com I e D em zero, suba o Kp até a velocidade oscilar num ritmo constante, sem crescer nem morrer. Esse é o ganho crítico Ku. Meça o tempo de uma oscilação completa no Serial Plotter: é o período Tu, em segundos. A tabela dá os ganhos iniciais.

Por que aprender

Um PID mal sintonizado é pior que nenhum: oscila, gasta bateria e esquenta o motor. Com um método, a sintonia de um seguidor de linha cai de uma tarde de tentativa e erro para alguns testes organizados.

Conceitos-chave

O PID "de livro" tem três armadilhas no mundo real, e o código do tópico 3 já trata as três. Saturação: o PWM não passa de 255; pedir 400 dá na mesma. Windup: enquanto a saída está presa no máximo, a integral continua somando erro; quando o robô finalmente chega, essa soma gigante o faz passar muito do alvo. Ruído na derivada: o D amplifica cada pulinho da medida e faz o motor tremer.

Como ler: na faixa vermelha a roda está segura pela mão: velocidade zero, saída no máximo. Quando você solta, a curva vermelha (sem proteção) dispara para muito além do alvo, gastando a integral acumulada. A azul (com proteção) não acumulou nada enquanto estava saturada e chega limpa.

Por que aprender

A diferença entre um PID que funciona na simulação e um que funciona no robô está nestas quatro linhas. Bibliotecas prontas de PID fazem o mesmo; agora você sabe o que procurar nelas.

Conceitos-chave

Dois motores "iguais" nunca são iguais: com o mesmo PWM, um gira mais que o outro e o rover puxa para um lado. A solução é dar um PID para cada roda, os dois com o mesmo alvo em RPM, cada um medindo o próprio encoder. O PID da roda mais fraca simplesmente manda mais PWM até as duas baterem.

Como ler: o mesmo alvo âmbar alimenta dois laços que não se conhecem. Cada linha ciano tracejada é o encoder de uma roda voltando para o seu próprio PID. Se a roda direita for mais fraca, só o laço de baixo aumenta o PWM.

Objetivo: manter as duas rodas no RPM que você digitar no Serial Monitor (ex.: 150; 0 para parar), com um PI em cada uma a 50 Hz. Pinos do driver iguais aos do 2.1 e dos encoders iguais aos do 2.2.

// Duas rodas na mesma velocidade: um PID por roda (TB6612FNG + encoders, pacote esp32 3.x)
const int PWMA = 25, AIN1 = 26, AIN2 = 27, PWMB = 14, BIN1 = 16, BIN2 = 17;   // STBY no 3V3
const int ENC_E_A = 18, ENC_E_B = 19, ENC_D_A = 34, ENC_D_B = 35;
const float PULSOS_VOLTA = 1400;            // o valor medido no 2.2
const unsigned long PERIODO_US = 20000;     // 20 ms = 50 Hz
const float DT = PERIODO_US / 1e6;
volatile long pulsosE = 0, pulsosD = 0;

void IRAM_ATTR isrE() { if (digitalRead(ENC_E_A) == digitalRead(ENC_E_B)) pulsosE++; else pulsosE--; }
void IRAM_ATTR isrD() { if (digitalRead(ENC_D_A) == digitalRead(ENC_D_B)) pulsosD--; else pulsosD++; }

struct PID {
  float kp = 0.8, ki = 4.0, kd = 0.0, saidaMin = 0, saidaMax = 255;   // ponto de partida: ajuste o seu
  float integral = 0, dFiltrada = 0, medidaAnt = 0;
  float calcula(float alvo, float medida, float dt) {
    float erro = alvo - medida;
    dFiltrada += 0.2 * (-(medida - medidaAnt) / dt - dFiltrada);
    medidaAnt = medida;
    float novaIntegral = integral + ki * erro * dt;
    float saida = kp * erro + novaIntegral + kd * dFiltrada;
    if (saida > saidaMax) { saida = saidaMax; if (erro < 0) integral = novaIntegral; }
    else if (saida < saidaMin) { saida = saidaMin; if (erro > 0) integral = novaIntegral; }
    else integral = novaIntegral;
    return saida;
  }
  void zera() { integral = 0; dFiltrada = 0; }
};

PID pidE, pidD;
float alvoRPM = 0, rpmE = 0, rpmD = 0;

void frente(int pwm, int in1, int in2, int v) { digitalWrite(in1, v > 0); digitalWrite(in2, LOW); ledcWrite(pwm, v); }

void setup() {
  Serial.begin(115200);
  Serial.setTimeout(20);
  int saidas[] = {AIN1, AIN2, BIN1, BIN2};
  for (int p : saidas) pinMode(p, OUTPUT);
  ledcAttach(PWMA, 20000, 8);
  ledcAttach(PWMB, 20000, 8);
  pinMode(ENC_E_A, INPUT_PULLUP); pinMode(ENC_E_B, INPUT_PULLUP);
  pinMode(ENC_D_A, INPUT); pinMode(ENC_D_B, INPUT);
  attachInterrupt(digitalPinToInterrupt(ENC_E_A), isrE, CHANGE);
  attachInterrupt(digitalPinToInterrupt(ENC_D_A), isrD, CHANGE);
  Serial.println("Digite o alvo em RPM (ex.: 150). 0 para parar.");
}

void loop() {
  static unsigned long proximo = micros();
  static long antE = 0, antD = 0;
  if ((long)(micros() - proximo) < 0) return;
  proximo += PERIODO_US;
  if (Serial.available()) alvoRPM = constrain(Serial.parseFloat(), 0, 250);
  noInterrupts(); long e = pulsosE, d = pulsosD; interrupts();
  rpmE = 0.7 * rpmE + 0.3 * ((e - antE) / PULSOS_VOLTA / DT * 60);   // filtro leve na medida
  rpmD = 0.7 * rpmD + 0.3 * ((d - antD) / PULSOS_VOLTA / DT * 60);
  antE = e; antD = d;
  if (alvoRPM < 1) {                                        // parar de verdade e limpar a integral
    frente(PWMA, AIN1, AIN2, 0); frente(PWMB, BIN1, BIN2, 0);
    pidE.zera(); pidD.zera();
  } else {
    frente(PWMA, AIN1, AIN2, (int)pidE.calcula(alvoRPM, rpmE, DT));
    frente(PWMB, BIN1, BIN2, (int)pidD.calcula(alvoRPM, rpmD, DT));
  }
  static int n = 0;
  if (++n % 5 == 0) Serial.printf("alvo:%.0f,esq:%.1f,dir:%.1f\n", alvoRPM, rpmE, rpmD);
}

Por que aprender

Andar reto parece trivial até você tentar. Com velocidade controlada nas duas rodas, a odometria do 2.2 fica mais confiável, o seguidor de linha do 2.6 tem uma base estável para somar a correção de direção, e o comando /cmd_vel do ROS 2 na Trilha 4 vira exatamente isso: um alvo de velocidade por roda.

Conceitos-chave