Fundamentos · 14 min de leitura

Controle PID com Arduino: como ajustar Kp, Ki e Kd com exemplos de código

O que é um controlador PID e como ele funciona? Termos P, I e D, a biblioteca PID do Arduino, ajuste de Kp/Ki/Kd e códigos de controle de temperatura e robô seguidor de linha.

O controle PID é um método de realimentação que mantém um sistema no valor que você quer: ele calcula continuamente a diferença entre o valor medido e o alvo (o erro) e ajusta a saída de acordo. Em projetos com Arduino, ele é usado para manter um aquecedor em exatamente 45 °C, girar um motor a uma velocidade constante ou conduzir um robô seguidor de linha bem no meio da linha. O nome vem de suas três partes: o termo Proporcional (P) olha para o erro atual, o termo Integral (I) para o erro acumulado no passado e o termo Derivativo (D) para a rapidez com que o erro está mudando. A soma ponderada dos três define o valor de PWM enviado ao motor ou ao aquecedor.

As fórmulas assustam no começo, mas a lógica do PID é muito parecida com o que você já faz sem pensar quando dirige um carro. Neste post, você vai ver primeiro por que o controle liga-desliga simples oscila e depois conhecer os três termos com exemplos intuitivos. Em seguida, vai montar um controle de temperatura com a biblioteca PID do Arduino usando um NTC e um MOSFET, aprender a ajustar Kp, Ki e Kd passo a passo e conduzir um robô seguidor de linha com um PID escrito sem biblioteca. Por fim, vamos rodar o mesmo algoritmo no ESP32 e no Raspberry Pi Pico com MicroPython.

Por que o controle liga-desliga não basta?

O método de controle mais simples é o liga-desliga (on-off): se a temperatura está abaixo do alvo, liga o aquecedor na potência máxima; se está acima, desliga. O termostato do aquecedor de casa e o aquecedor de aquário funcionam basicamente assim. O problema é que, quando o aquecedor desliga, o calor armazenado nele continua passando para o ambiente, então a temperatura ultrapassa o alvo em alguns graus. Quando começa a esfriar, o aquecedor liga de novo, mas a temperatura cai abaixo do alvo até ele esquentar. O resultado é um dente de serra que sobe e desce sem parar em torno do alvo. Para suavizar isso, deixa-se uma folga (histerese) entre dois limites; o relé estala menos vezes, mas a amplitude da oscilação aumenta. Numa mesa de impressora 3D, numa chocadeira ou num motor que precisa girar a velocidade constante, onde é preciso ficar dentro de ±0,5 °C, isso não é suficiente. O PID, por outro lado, produz uma saída gradual entre a potência máxima e zero e reduz a potência antecipadamente à medida que o sistema se aproxima do alvo.

MétodoComo decideVantagensDesvantagensUso típico
Liga-desliga (on-off)Potência máxima abaixo do alvo, desligado acima deleMuito simples, dá para fazer até com um reléOscilação constante e sobressinal, desgaste do reléTermostato de aquecedor, aquecedor de aquário
PSaída proporcional ao erroResposta suave, fácil de ajustarDeixa um erro em regime permanenteControle simples de posição e nível
PIProporcional + erro acumuladoElimina o erro em regime permanenteMais sobressinal, acúmulo da integral (windup)Controle de temperatura, vazão e velocidade de motor
PIDProporcional + erro acumulado + taxa de variaçãoRápido, pouco sobressinal, precisoDifícil de ajustar, sensível a ruídoImpressora 3D, drone, robô equilibrista, robô seguidor de linha

O que é controle PID e como ele funciona?

A cada ciclo, o PID primeiro calcula o erro: erro = valor-alvo (setpoint) − valor medido (input). Depois avalia esse erro de três maneiras diferentes e soma os resultados: saída = Kp·e + Ki·∫e·dt + Kd·de/dt. Aqui Kp, Ki e Kd são coeficientes que você define; eles determinam quanto cada termo contribui para a saída. Num microcontrolador, a integral é calculada somando, a cada amostra, o produto do erro pelo tempo de amostragem a um total acumulado, e a derivada dividindo a diferença entre as duas últimas medições pelo tempo de amostragem. Por isso, para o PID funcionar direito, é importante fazer as medições em intervalos fixos, por exemplo a cada 10 ms ou a cada 500 ms. Pense em seguir uma faixa da estrada com o carro: quanto mais longe você está da faixa, mais gira o volante (P); se um vento lateral fica empurrando você, aprende a manter o volante levemente virado (I); e, quando se aproxima da faixa rapidamente, desfaz a curva antes (D).

TermoPara o que olhaAnalogia intuitivaSe for alto demais
P (Proporcional)O erro atualQuanto mais longe da faixa, mais você gira o volanteOscilação rápida, tremedeira
I (Integral)O erro acumulado ao longo do tempoCom vento lateral, você aprende a manter o volante levemente viradoOscilação lenta e ampla, grande sobressinal
D (Derivativo)A taxa de variação do erroAo se aproximar rápido da faixa, você desfaz a curva antesReação exagerada ao ruído, saída trêmula

Termo proporcional (P): uma resposta proporcional ao erro

O termo proporcional ajusta a saída em proporção direta ao tamanho do erro. Com Kp = 20, um erro de 3 °C produz 60 unidades de PWM e um erro de 1 °C produz 20 unidades; conforme você se aproxima do alvo, a potência cai automaticamente. Aumentando Kp, o sistema responde mais rápido, mas a partir de certo ponto começa a ultrapassar o alvo e voltar, ou seja, a oscilar. O controle só com P tem uma fraqueza importante: o erro em regime permanente (steady-state error). Digamos que, para manter o aquecedor em 45 °C, seja preciso uma potência contínua de 80 unidades para compensar o calor que escapa para o ambiente. Só com o termo P, essas 80 unidades só podem ser produzidas enquanto houver erro: 80 / 20 = 4 °C. Assim, o sistema se estabiliza por volta de 41 °C e nunca chega ao alvo. Aumentar Kp diminui essa diferença, mas também aumenta a oscilação.

Termo integral (I): elimina o erro em regime permanente

O termo integral soma o erro ao longo do tempo. Mesmo um erro pequeno, se persistir por muito tempo, faz o total crescer, e a saída sobe devagar até o erro chegar a zero. No exemplo acima, agora é o termo integral que fornece as 80 unidades de potência necessárias, o termo P cai a zero e a temperatura se estabiliza em exatamente 45 °C. Quanto maior o Ki, mais rápido o erro em regime permanente se fecha; se for grande demais, o sistema faz oscilações lentas e amplas. Uma armadilha conhecida da integral é a situação chamada acúmulo da integral (integral windup): se o aquecedor já está na potência máxima e não consegue alcançar o alvo, a integral continua crescendo à toa e, quando o alvo é atingido, esse valor acumulado mantém a temperatura acima do alvo por muito tempo. A solução é limitar a integral com os limites da saída; a biblioteca PID do Arduino faz isso automaticamente com SetOutputLimits.

Termo derivativo (D): freia ao se aproximar do alvo

O termo derivativo olha para a rapidez com que o erro está mudando e oferece uma espécie de previsão. Se a temperatura está se aproximando rápido do alvo, o erro diminui rápido; o termo D contribui no sentido oposto a essa mudança, corta a potência antes e reduz o sobressinal (overshoot). O mesmo acontece num robô: um robô que gira rápido em direção à linha suaviza a curva antes de cruzá-la. A fraqueza do termo D é a sensibilidade ao ruído. Se a leitura de um sensor analógico pula algumas unidades a cada medição, a derivada enxerga esses pequenos saltos como grandes mudanças e a saída fica trêmula. Por isso é preciso tirar a média ou filtrar a leitura do sensor; veja os detalhes no post sobre filtragem de dados de sensores. Além disso, boas implementações de PID calculam a derivada a partir da medição, e não do erro; assim, quando você muda o alvo de repente, não há um salto brusco na saída (derivative kick).

Exemplo 1: controle de temperatura com a biblioteca PID do Arduino

No primeiro exemplo, vamos manter um pequeno aquecedor (uma manta térmica de 12 V ou um resistor de potência) em 45 °C. Vamos medir a temperatura com um divisor de tensão formado por um termistor NTC de 10 kΩ e um resistor fixo de 10 kΩ, e acionar o aquecedor com PWM por meio de um MOSFET canal N de nível lógico (por exemplo, IRLZ44N). No Arduino IDE, abra o Gerenciador de Bibliotecas, busque por PID e instale a biblioteca PID de Brett Beauregard (PID_v1). Essa biblioteca cuida para você de detalhes como o gerenciamento do tempo de amostragem, a limitação da saída, a proteção contra o acúmulo da integral e o cálculo da derivada a partir da medição. Para os detalhes da ligação do MOSFET, dê uma olhada no post Como usar MOSFET com Arduino.

Sensor de temperatura com termistor NTC
Termistor NTC de 10 kΩ: sua resistência cai quando a temperatura sobe; é usado como elemento de medição no controle PID de temperatura.
LigaçãoArduino UnoESP32Raspberry Pi Pico
Alimentação do divisor (terminal superior do resistor fixo de 10 kΩ)5V3V33V3
Ponto de junção do NTC com o resistor fixoA0GPIO 34GP26 (ADC0)
Terminal inferior do NTCGNDGNDGND
Gate do MOSFET (via 220 Ω, com 10 kΩ para o GND)D9GPIO 25GP15
Terminal fonte (source) do MOSFETGNDGNDGND
AquecedorEntre +12 V e o dreno do MOSFETEntre +12 V e o dreno do MOSFETEntre +12 V e o dreno do MOSFET
Nunca alimente o aquecedor diretamente por um pino do Arduino; um pino fornece no máximo cerca de 20–40 mA, enquanto um aquecedor puxa amperes. O terminal negativo da fonte de 12 V precisa ter o GND comum com o do Arduino; caso contrário, o MOSFET não liga direito. Como o ESP32 e o Pico têm saída de 3,3 V, escolha um MOSFET que conduza totalmente com 3,3 V (por exemplo, AO3400) em vez do IRLZ44N; e, se você estiver acionando uma carga indutiva, como uma ventoinha ou um motor, adicione um diodo de roda livre (flyback) em paralelo com a carga.
C++ (Arduino IDE)
1#include <PID_v1.h>
2
3const int NTC_PIN = A0;        // NTC bölücü orta noktası / NTC divider midpoint
4const int HEATER_PIN = 9;      // MOSFET gate (PWM) / MOSFET gate (PWM)
5
6const float R_FIXED = 10000.0; // sabit direnç / fixed resistor
7const float R0 = 10000.0;      // NTC'nin 25 °C direnci / NTC resistance at 25 °C
8const float T0 = 298.15;       // 25 °C kelvin cinsinden / 25 °C in kelvin
9const float BETA = 3950.0;     // NTC Beta katsayısı / NTC beta coefficient
10
11double setpoint = 45.0;        // hedef sıcaklık / target temperature
12double input = 0;              // ölçülen sıcaklık / measured temperature
13double output = 0;             // ısıtıcı gücü 0-255 / heater power 0-255
14
15double Kp = 20.0, Ki = 0.5, Kd = 10.0;   // başlangıç değerleri / starting values
16PID heaterPID(&input, &output, &setpoint, Kp, Ki, Kd, DIRECT);
17
18float readTemperature() {
19  long sum = 0;
20  for (int i = 0; i < 16; i++) {
21    sum += analogRead(NTC_PIN);            // 16 ölçüm ortalaması / average of 16 readings
22  }
23  float adc = sum / 16.0;
24  adc = constrain(adc, 1.0, 1022.0);       // sıfıra bölmeyi önle / avoid division by zero
25  float r = R_FIXED * adc / (1023.0 - adc);                // NTC direnci / NTC resistance
26  float kelvin = 1.0 / (1.0 / T0 + log(r / R0) / BETA);    // Beta denklemi / beta equation
27  return kelvin - 273.15;
28}
29
30void setup() {
31  Serial.begin(115200);
32  pinMode(HEATER_PIN, OUTPUT);
33  input = readTemperature();
34  heaterPID.SetOutputLimits(0, 255);       // analogWrite aralığı / analogWrite range
35  heaterPID.SetSampleTime(500);            // 500 ms'de bir hesapla / compute every 500 ms
36  heaterPID.SetMode(AUTOMATIC);            // PID'yi başlat / start the PID
37}
38
39void loop() {
40  input = readTemperature();
41  if (heaterPID.Compute()) {               // yeni çıkış hazırsa / if a new output is ready
42    analogWrite(HEATER_PIN, (int)output);
43    Serial.print(setpoint);                // Seri Çizici için / for the Serial Plotter
44    Serial.print(' ');
45    Serial.print(input);
46    Serial.print(' ');
47    Serial.println(output / 255.0 * 100.0); // güç yüzdesi / power percent
48  }
49}

No código, a função readTemperature() reduz o ruído tirando a média de 16 leituras, calcula a resistência do NTC pela fórmula do divisor (R = 10 kΩ · adc / (1023 − adc)) e a converte em graus Celsius com a equação Beta (B = 3950). SetOutputLimits(0, 255) mantém a saída na faixa do analogWrite e impede que a integral ultrapasse esses limites. SetSampleTime(500) faz o PID calcular a cada meio segundo; como o calor é uma grandeza que muda devagar, isso é suficiente. Compute() só retorna true quando chega a hora de amostrar, por isso você não deve usar delay() dentro do loop(). Se abrir os três valores enviados à porta serial no Plotter Serial, no menu Ferramentas, você verá o alvo, a temperatura e a potência do aquecedor em porcentagem no mesmo gráfico e acompanhará na hora o efeito do seu ajuste. Num sistema de resfriamento (por exemplo, com ventoinha), a saída precisa aumentar quando a temperatura sobe; nesse caso, use REVERSE em vez de DIRECT.

Como ajustar Kp, Ki e Kd: passo a passo

  1. Zere Ki e Kd, comece Kp com um valor pequeno (por exemplo, 2) e abra o Plotter Serial.
  2. Dobre Kp passo a passo; pare quando o sistema se aproximar rápido do alvo e começar a oscilar continuamente em torno dele. Use cerca da metade desse valor como Kp.
  3. Adicione Kd: comece com um valor pequeno e aumente até o sobressinal e a oscilação desaparecerem. Se a saída começar a tremer ou o motor começar a chiar, o Kd está alto demais ou o sensor está ruidoso.
  4. Adicione Ki por último: aumente devagar até o erro em regime permanente se fechar num tempo razoável. Se a temperatura desenhar ondas lentas e amplas em torno do alvo, reduza o Ki.
  5. Teste com uma perturbação: mude o alvo em 5 °C, sopre o aquecedor ou dê um leve empurrão no robô com a mão; observe quanto tempo o sistema leva para se recuperar e com quanto sobressinal.
  6. Se quiser, use o método de Ziegler-Nichols como ponto de partida: só com P, meça o ganho que inicia uma oscilação sustentada (Ku) e o período da oscilação (Tu, em segundos); comece com Kp = 0,6·Ku, Ki = 1,2·Ku / Tu, Kd = 0,075·Ku·Tu e faça o ajuste fino à mão.
Ao aumentar o coeficienteTempo de subidaSobressinal (overshoot)Tempo de acomodaçãoErro em regime permanente
KpDiminuiAumentaMuda poucoDiminui
KiDiminuiAumentaAumentaÉ eliminado
KdMuda poucoDiminuiDiminuiEm teoria, nenhum efeito

Exemplo 2: PID num robô seguidor de linha

Sensor de linha infravermelho TCRT5000
Sensor óptico reflexivo infravermelho TCRT5000: distingue superfícies pretas de brancas; fornece a entrada do PID num robô seguidor de linha.

Num robô seguidor de linha, o objetivo é que a linha fique exatamente no meio do robô. Tirando uma média ponderada das leituras de três sensores analógicos TCRT5000 colocados à esquerda, no centro e à direita, transformamos a posição da linha num número entre 0 (totalmente à esquerda) e 2000 (totalmente à direita); 1000 é o centro exato. O erro é a diferença entre a posição e 1000. A correção produzida pelo PID é somada à velocidade do motor esquerdo e subtraída da velocidade do motor direito, então o robô vira suavemente em direção à linha. Um robô com lógica liga-desliga simples (vira à esquerda se a linha está à esquerda, à direita se está à direita) anda balançando e devagar, enquanto um robô com PID percorre a mesma pista muito mais rápido e numa trajetória suave. Neste exemplo, escrevemos o PID do zero, sem biblioteca; os motores são controlados por um driver L298N.

C++ (Arduino IDE)
1const int SENSOR_PINS[3] = {A0, A1, A2};   // sol, orta, sağ / left, center, right
2
3const int ENA = 5, IN1 = 7, IN2 = 8;       // sol motor / left motor
4const int ENB = 6, IN3 = 9, IN4 = 10;      // sağ motor / right motor
5
6const int BASE_SPEED = 150;                // düz giderken hız / cruising speed
7float Kp = 0.1, Ki = 0.0, Kd = 0.004;      // robota göre ayarla / tune for your robot
8
9float lastError = 0;
10float integral = 0;
11int lastPosition = 1000;
12unsigned long lastTime = 0;
13
14int readPosition() {
15  long sum = 0, weighted = 0;
16  int maxValue = 0;
17  for (int i = 0; i < 3; i++) {
18    int v = analogRead(SENSOR_PINS[i]);    // siyah çizgi = yüksek değer / black line = high value
19    weighted += (long)v * i * 1000L;
20    sum += v;
21    if (v > maxValue) maxValue = v;
22  }
23  if (maxValue > 500) {                    // çizgi görülüyor / line is visible
24    lastPosition = weighted / sum;         // 0 sol, 1000 orta, 2000 sağ / 0 left, 1000 center, 2000 right
25  }
26  return lastPosition;                     // çizgi kaybolursa son konum / last position if line is lost
27}
28
29void setMotor(int en, int inA, int inB, int speed) {
30  speed = constrain(speed, -255, 255);
31  if (speed >= 0) {
32    digitalWrite(inA, HIGH);               // ileri / forward
33    digitalWrite(inB, LOW);
34  } else {
35    digitalWrite(inA, LOW);                // geri / backward
36    digitalWrite(inB, HIGH);
37    speed = -speed;
38  }
39  analogWrite(en, speed);
40}
41
42void setup() {
43  int pins[] = {ENA, IN1, IN2, ENB, IN3, IN4};
44  for (int i = 0; i < 6; i++) {
45    pinMode(pins[i], OUTPUT);
46  }
47  lastTime = millis();
48}
49
50void loop() {
51  unsigned long now = millis();
52  if (now - lastTime < 10) return;         // 10 ms örnekleme / 10 ms sampling
53  float dt = (now - lastTime) / 1000.0;    // saniye cinsinden / in seconds
54  lastTime = now;
55
56  float error = readPosition() - 1000;     // negatif = çizgi solda / negative = line on the left
57  integral += error * dt;
58  integral = constrain(integral, -500.0, 500.0);   // windup sınırı / windup limit
59  float derivative = (error - lastError) / dt;
60  lastError = error;
61
62  float correction = Kp * error + Ki * integral + Kd * derivative;
63  setMotor(ENA, IN1, IN2, (int)(BASE_SPEED + correction));
64  setMotor(ENB, IN3, IN4, (int)(BASE_SPEED - correction));
65}

Os sensores estão ligados em A0, A1 e A2, os pinos ENA e ENB do L298N nos pinos PWM D5 e D6, e os pinos IN1–IN4 em D7, D8, D9 e D10; não se esqueça de tirar os jumpers de ENA e ENB. O loop roda a cada 10 ms usando millis(); assim o dt fica constante e os coeficientes se comportam de forma consistente. Você encontra o motivo de usarmos millis() em vez de delay() no post millis e delay. Se o erro é negativo, a linha está à esquerda: a correção fica negativa, o motor esquerdo desacelera, o direito acelera e o robô vira à esquerda. Como o erro é no máximo 1000, Kp = 0,1 significa uma correção de cerca de 100 unidades de PWM no maior erro. Como a derivada é calculada por segundo, é normal o Kd parecer tão pequeno quanto 0,004. Num seguidor de linha, o Ki geralmente fica em zero ou bem pequeno; a integral só é útil se o robô desvia constantemente para um lado (por exemplo, um motor é mais fraco que o outro). Se os seus sensores leem valores altos na superfície branca e baixos na linha preta, inverta a leitura com 1023 − v.

PID com ESP32 e Raspberry Pi Pico

Como a biblioteca PID_v1 é escrita em C++ puro, ela funciona no ESP32 do jeito que está; basta ligar o NTC no GPIO 34 e o gate do MOSFET no GPIO 25. As diferenças estão no hardware: o ADC do ESP32 é de 12 bits (0–4095) e não é linear perto dos extremos da faixa; manter a tensão medida entre 0,3 e 2,8 V melhora o resultado. Para o PWM, usa-se o periférico LEDC em vez do analogWrite e, como essa API mudou com o core 3.x, o código inclui uma verificação de versão. Por ser rápido e dual-core, o ESP32 consegue receber uma nova temperatura-alvo por uma página web ao mesmo tempo em que roda o laço do PID.

C++ (Arduino IDE)
1#include <PID_v1.h>
2
3const int NTC_PIN = 34;        // ADC1 girişi / ADC1 input
4const int HEATER_PIN = 25;     // MOSFET gate / MOSFET gate
5const int PWM_FREQ = 1000;     // 1 kHz PWM / 1 kHz PWM
6const int PWM_BITS = 8;        // 0-255 çözünürlük / 0-255 resolution
7
8double setpoint = 45.0, input = 0, output = 0;
9PID heaterPID(&input, &output, &setpoint, 20.0, 0.5, 10.0, DIRECT);
10
11float readTemperature() {
12  long sum = 0;
13  for (int i = 0; i < 16; i++) {
14    sum += analogRead(NTC_PIN);            // 12 bit: 0-4095 / 12-bit: 0-4095
15  }
16  double adc = constrain(sum / 16.0, 1.0, 4094.0);
17  double r = 10000.0 * adc / (4095.0 - adc);                     // NTC direnci / NTC resistance
18  return 1.0 / (1.0 / 298.15 + log(r / 10000.0) / 3950.0) - 273.15;
19}
20
21void setup() {
22  Serial.begin(115200);
23  analogReadResolution(12);
24#if ESP_ARDUINO_VERSION_MAJOR >= 3
25  ledcAttach(HEATER_PIN, PWM_FREQ, PWM_BITS);   // çekirdek 3.x / core 3.x
26#else
27  ledcSetup(0, PWM_FREQ, PWM_BITS);             // çekirdek 2.x, kanal 0 / core 2.x, channel 0
28  ledcAttachPin(HEATER_PIN, 0);
29#endif
30  input = readTemperature();
31  heaterPID.SetOutputLimits(0, 255);
32  heaterPID.SetSampleTime(500);
33  heaterPID.SetMode(AUTOMATIC);
34}
35
36void loop() {
37  input = readTemperature();
38  if (heaterPID.Compute()) {
39#if ESP_ARDUINO_VERSION_MAJOR >= 3
40    ledcWrite(HEATER_PIN, (uint32_t)output);    // pin ile yaz / write by pin
41#else
42    ledcWrite(0, (uint32_t)output);             // kanal ile yaz / write by channel
43#endif
44    Serial.printf("%.1f %.2f %.0f\n", setpoint, input, output / 255.0 * 100.0);
45  }
46}

Não existe um módulo PID pronto para MicroPython no Raspberry Pi Pico, então escrevemos o algoritmo como uma pequena classe. Essa classe imita três coisas importantes que a biblioteca do Arduino faz: mantém a integral dentro dos limites da saída (anti-windup), calcula a derivada a partir da medição e leva em conta o tempo de amostragem (dt). O ADC do Pico retorna valores na faixa 0–65535 com read_u16(); a saída do PID é calculada na faixa 0–255 e multiplicada por 257 para ser escalada para 16 bits no duty_u16(). Assim, você pode usar no Pico os mesmos valores de Kp, Ki e Kd que encontrou no Arduino. O divisor do NTC está ligado no GP26 e o gate do MOSFET no GP15. Se você é novo no MicroPython, pode começar pelo post Fundamentos de MicroPython.

MicroPython
1from machine import ADC, Pin, PWM
2import math
3import time
4
5ntc = ADC(26)                     # GP26 = ADC0, NTC bölücüsü / NTC divider
6heater = PWM(Pin(15))             # MOSFET gate / MOSFET gate
7heater.freq(1000)                 # 1 kHz PWM / 1 kHz PWM
8
9R_FIXED = 10000                   # sabit direnç / fixed resistor
10R0 = 10000                        # NTC'nin 25 °C direnci / NTC resistance at 25 °C
11T0 = 298.15                       # 25 °C kelvin cinsinden / 25 °C in kelvin
12BETA = 3950                       # Beta katsayısı / beta coefficient
13SETPOINT = 45.0                   # hedef sıcaklık / target temperature
14
15def read_temp():
16    total = 0
17    for _ in range(16):
18        total += ntc.read_u16()   # 16 ölçüm ortalaması / average of 16 readings
19    adc = min(max(total / 16, 1), 65534)
20    r = R_FIXED * adc / (65535 - adc)
21    return 1 / (1 / T0 + math.log(r / R0) / BETA) - 273.15
22
23class PID:
24    def __init__(self, kp, ki, kd, out_min, out_max):
25        self.kp, self.ki, self.kd = kp, ki, kd
26        self.out_min, self.out_max = out_min, out_max
27        self.i_term = 0
28        self.last_input = None
29
30    def compute(self, setpoint, measurement, dt):
31        error = setpoint - measurement
32        self.i_term += self.ki * error * dt                               # biriken hata / accumulated error
33        self.i_term = min(max(self.i_term, self.out_min), self.out_max)  # integral sınırı / anti-windup
34        if self.last_input is None:
35            d_input = 0
36        else:
37            d_input = (measurement - self.last_input) / dt                # ölçümden türev / derivative on measurement
38        self.last_input = measurement
39        out = self.kp * error + self.i_term - self.kd * d_input
40        return min(max(out, self.out_min), self.out_max)
41
42pid = PID(20, 0.5, 10, 0, 255)    # Arduino ile aynı katsayılar / same gains as Arduino
43last = time.ticks_ms()
44
45while True:
46    now = time.ticks_ms()
47    if time.ticks_diff(now, last) >= 500:                                 # 500 ms örnekleme / 500 ms sampling
48        dt = time.ticks_diff(now, last) / 1000
49        last = now
50        temp = read_temp()
51        power = pid.compute(SETPOINT, temp, dt)
52        heater.duty_u16(int(power * 257))                                 # 0-255 -> 0-65535
53        print(SETPOINT, round(temp, 2), round(power))

Ideias de projetos com controle PID

  • Termostato de precisão: num projeto de termostato com Arduino, use PID em vez de liga-desliga para manter uma chocadeira ou um armário de fermentação dentro de ±0,3 °C.
  • Velocidade da ventoinha pela temperatura: num projeto de controle de ventoinha, acione a ventoinha com um PID em modo REVERSE para ter um resfriamento silencioso e estável.
  • Robô seguidor de linha rápido: adicione 5 sensores e PID a um projeto de robô seguidor de linha para chegar à velocidade de competição.
  • Robô autoequilibrado: meça o ângulo de inclinação com um MPU-6050 e mantenha em pé um robô de duas rodas; é uma das aplicações mais didáticas do PID.
  • Seguidor solar: num projeto de seguidor solar, use a diferença entre dois LDRs como erro e gire o painel suavemente.
  • Estação de solda ou miniforno: meça altas temperaturas com um termopar MAX6675 e acione o aquecedor com PID.
  • Motor de velocidade constante: mantenha no alvo a rotação de um motor CC com redução equipado com encoder, mesmo quando a carga muda.

Erros comuns e como resolvê-los

SintomaCausa provávelSolução
O sistema oscila de forma constante e rápida em torno do alvoKp alto demais ou Kd insuficienteReduza o Kp em 30–50% e aumente um pouco o Kd
Nunca chega ao alvo e fica alguns graus abaixoKi é zero ou pequeno demaisAumente o Ki devagar; confira se a potência do aquecedor é suficiente
Sobressinal grande e demorado no fim do aquecimentoAcúmulo da integral (windup)Limite a saída com SetOutputLimits, limite a integral, reduza o Ki
A saída treme, o motor chiaSensor ruidoso e Kd altoTire a média ou filtre a medição, reduza o Kd
A saída sobe quando a temperatura sobeO sentido do controle está invertidoUse REVERSE para resfriamento ou inverta o sinal do erro
Os mesmos coeficientes às vezes funcionam bem, às vezes malAmostragem irregular, delay() no loopUse um dt fixo com millis(), evite delay()
O aquecedor está sempre na potência máxima, mas a temperatura não sobeHardware insuficiente (potência, isolamento, MOSFET)O PID não compensa a falta de hardware; confira a potência e as ligações
Mudar os coeficientes carregando o código de novo toda vez fica cansativo durante o ajuste. Se você adicionar algumas linhas que leem comandos como “p2.5” ou “d0.8” pela porta serial e atualizam os coeficientes com o programa rodando usando SetTunings(Kp, Ki, Kd), consegue achar um bom ajuste em minutos olhando o gráfico no Plotter Serial. Para tornar permanentes os valores encontrados, você pode salvá-los na EEPROM.

O controle PID combina o ciclo medir-comparar-corrigir com três ideias simples e é usado em todo lugar, de projetos de hobby a fornos industriais. Primeiro veja os limites do controle liga-desliga, depois comece com P, freie com D e feche o erro em regime permanente com I; o gráfico no Plotter Serial vai guiar você em cada passo. No app BlueGrays, você pode ver passo a passo, com esquemas do circuito e código, projetos que usam as peças deste post, como medição de temperatura com NTC, detecção de superfície com TCRT5000, carrinho robô com L298N e controle PWM com potenciômetro, e começar dali a adicionar PID ao seu próprio projeto.

Perguntas frequentes

O que é controle PID e para que serve?

O controle PID é um método de realimentação que calcula o erro continuamente para manter um valor medido num valor-alvo e ajusta a saída de acordo. O termo proporcional reage ao erro atual, o termo integral ao erro acumulado e o termo derivativo à taxa de variação do erro. No controle de temperatura, velocidade de motor, posição e equilíbrio, ele dá resultados muito mais estáveis e precisos que o controle liga-desliga.

Como encontrar os valores de Kp, Ki e Kd?

O jeito mais prático é o ajuste manual: zere Ki e Kd, aumente o Kp até o sistema oscilar e depois reduza pela metade, adicione Kd para suprimir o sobressinal e adicione Ki por último para fechar o erro em regime permanente. O método de Ziegler-Nichols dá um bom ponto de partida, mas o ajuste fino quase sempre é feito à mão. Os valores são específicos de cada sistema; coeficientes copiados de outro projeto podem não funcionar no seu circuito.

Qual é a diferença entre PID e controle liga-desliga?

O controle liga-desliga deixa a saída totalmente ligada ou totalmente desligada, por isso surgem oscilação constante e sobressinal em torno do alvo. O PID ajusta a saída de forma gradual, reduz a potência antecipadamente ao se aproximar do alvo e elimina o erro em regime permanente com o termo integral. O liga-desliga é mais simples e barato; o PID é mais preciso, mas precisa de ajuste.

Qual biblioteca PID do Arduino devo usar e como instalar?

A mais comum é a biblioteca PID de Brett Beauregard (PID_v1). No Arduino IDE, busque por “PID” no Gerenciador de Bibliotecas para instalá-la e depois inclua o arquivo de cabeçalho PID_v1.h no seu código. A biblioteca cuida sozinha do tempo de amostragem, da limitação da saída e da proteção contra o acúmulo da integral.

O que é integral windup e como evitar?

Integral windup é quando o erro continua se acumulando na integral enquanto a saída já está no limite (por exemplo, o aquecedor está na potência máxima). Quando o alvo é atingido, esse valor acumulado faz o sistema ultrapassar o alvo por muito tempo. Para evitar, é preciso manter a integral dentro dos limites da saída; na biblioteca PID do Arduino, SetOutputLimits faz isso automaticamente.

Dá para fazer controle PID com relé?

Sim, usando o método de proporção de tempo (time proportioning): por exemplo, numa janela de 5 segundos, se a saída do PID é 40 por cento, o relé fica ligado por 2 segundos e desligado por 3 segundos. Como relés mecânicos se desgastam rápido com chaveamentos frequentes, um relé de estado sólido (SSR) é mais adequado para essa tarefa. Em sistemas de resposta lenta, como aquecedores, esse método funciona tão bem quanto o PWM.

Ver todos os projetos
Temperatura e umidade com DHT11
AR-55Intermediário

Temperatura e umidade com DHT11

Qual é a temperatura do seu quarto? O ar está úmido ou seco? O sensor DHT11 mede a temperatura e a umidade, e o Arduino mostra os valores em um display LCD de duas linhas, atualizando a cada poucos…

4.7(47)
83
Medição de distância com HC-SR04 (Monitor Serial)
AR-27Iniciante

Medição de distância com HC-SR04 (Monitor Serial)

O sensor HC-SR04 funciona como um morcego que se orienta no escuro: emite um som que você não consegue ouvir, escuta o eco e mede a distância até o objeto à sua frente.

4.6(50)
82
Medição de temperatura com NTC e display LCD 2x16
AR-44Iniciante
Premium

Medição de temperatura com NTC e display LCD 2x16

Meça a temperatura ao seu redor com um sensor que parece uma pequena conta. Esse componente, chamado NTC, deixa a eletricidade passar com mais facilidade à medida que aquece; o Arduino lê essa…

4.5(33)
44
Detecção de superfícies pretas e brancas com TCRT5000
AR-78Intermediário
Premium

Detecção de superfícies pretas e brancas com TCRT5000

Com o pequeno sensor que funciona como o olho dos robôs seguidores de linha, você identifica se o piso é preto ou branco.

4.7(40)
49
Leitura de reflexão (proximidade) com TCRT5000
AR-77Intermediário
Premium

Leitura de reflexão (proximidade) com TCRT5000

Com um pequeno sensor que emite luz invisível e mede quanto dela é refletido, você detecta a superfície à frente dele.

4.6(33)
43
Robô que desvia de obstáculos
AR-81Avançado
Premium

Robô que desvia de obstáculos

Que tal construir um veículo inteligente que encontra seu próprio caminho? O robô que desvia de obstáculos monitora o ambiente constantemente com o sensor ultrassônico na parte da frente.

5.0(38)
49
Carrinho controlado por Bluetooth com L298N
AR-80Avançado
Premium

Carrinho controlado por Bluetooth com L298N

Transforme seu celular em um controle remoto e dirija seu próprio carrinho robô.

5.0(39)
66
Brilho do LED com potenciômetro no ESP32 (analógico → PWM)
ES-13Intermediário
Premium

Brilho do LED com potenciômetro no ESP32 (analógico → PWM)

Neste projeto, controlamos o brilho de um LED de forma analógica com um potenciômetro. O pino ADC do ESP32 lê a tensão de 0-3,3V do potenciômetro e converte esse valor em um sinal PWM (modulação por largura de pulso), enviado ao LED. Assim, ao girar o potenciômetro, o brilho do LED aumenta e diminui gradualmente. Com Arduino Core 3.0+, você pode usar analogWrite() diretamente; no ESP32-S2/S3, a resolução do ADC é fixada em 12 bits.

4.5(19)
32