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étodo | Como decide | Vantagens | Desvantagens | Uso típico |
|---|---|---|---|---|
| Liga-desliga (on-off) | Potência máxima abaixo do alvo, desligado acima dele | Muito simples, dá para fazer até com um relé | Oscilação constante e sobressinal, desgaste do relé | Termostato de aquecedor, aquecedor de aquário |
| P | Saída proporcional ao erro | Resposta suave, fácil de ajustar | Deixa um erro em regime permanente | Controle simples de posição e nível |
| PI | Proporcional + erro acumulado | Elimina o erro em regime permanente | Mais sobressinal, acúmulo da integral (windup) | Controle de temperatura, vazão e velocidade de motor |
| PID | Proporcional + erro acumulado + taxa de variação | Rápido, pouco sobressinal, preciso | Difícil de ajustar, sensível a ruído | Impressora 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).
| Termo | Para o que olha | Analogia intuitiva | Se for alto demais |
|---|---|---|---|
| P (Proporcional) | O erro atual | Quanto mais longe da faixa, mais você gira o volante | Oscilação rápida, tremedeira |
| I (Integral) | O erro acumulado ao longo do tempo | Com vento lateral, você aprende a manter o volante levemente virado | Oscilação lenta e ampla, grande sobressinal |
| D (Derivativo) | A taxa de variação do erro | Ao se aproximar rápido da faixa, você desfaz a curva antes | Reaçã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.

| Ligação | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Alimentação do divisor (terminal superior do resistor fixo de 10 kΩ) | 5V | 3V3 | 3V3 |
| Ponto de junção do NTC com o resistor fixo | A0 | GPIO 34 | GP26 (ADC0) |
| Terminal inferior do NTC | GND | GND | GND |
| Gate do MOSFET (via 220 Ω, com 10 kΩ para o GND) | D9 | GPIO 25 | GP15 |
| Terminal fonte (source) do MOSFET | GND | GND | GND |
| Aquecedor | Entre +12 V e o dreno do MOSFET | Entre +12 V e o dreno do MOSFET | Entre +12 V e o dreno do MOSFET |
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
- Zere Ki e Kd, comece Kp com um valor pequeno (por exemplo, 2) e abra o Plotter Serial.
- 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.
- 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.
- 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.
- 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.
- 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 coeficiente | Tempo de subida | Sobressinal (overshoot) | Tempo de acomodação | Erro em regime permanente |
|---|---|---|---|---|
| Kp | Diminui | Aumenta | Muda pouco | Diminui |
| Ki | Diminui | Aumenta | Aumenta | É eliminado |
| Kd | Muda pouco | Diminui | Diminui | Em teoria, nenhum efeito |
Exemplo 2: 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.
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.
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.
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
| Sintoma | Causa provável | Solução |
|---|---|---|
| O sistema oscila de forma constante e rápida em torno do alvo | Kp alto demais ou Kd insuficiente | Reduza o Kp em 30–50% e aumente um pouco o Kd |
| Nunca chega ao alvo e fica alguns graus abaixo | Ki é zero ou pequeno demais | Aumente o Ki devagar; confira se a potência do aquecedor é suficiente |
| Sobressinal grande e demorado no fim do aquecimento | Acúmulo da integral (windup) | Limite a saída com SetOutputLimits, limite a integral, reduza o Ki |
| A saída treme, o motor chia | Sensor ruidoso e Kd alto | Tire a média ou filtre a medição, reduza o Kd |
| A saída sobe quando a temperatura sobe | O sentido do controle está invertido | Use REVERSE para resfriamento ou inverta o sinal do erro |
| Os mesmos coeficientes às vezes funcionam bem, às vezes mal | Amostragem irregular, delay() no loop | Use um dt fixo com millis(), evite delay() |
| O aquecedor está sempre na potência máxima, mas a temperatura não sobe | Hardware insuficiente (potência, isolamento, MOSFET) | O PID não compensa a falta de hardware; confira a potência e as ligações |
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.
Projetos para montar depois desta leitura
Ver todos os projetos
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…

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.

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…

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.

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.

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.

Carrinho controlado por Bluetooth com L298N
Transforme seu celular em um controle remoto e dirija seu próprio carrinho robô.

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.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

