Fundamentos · 14 min de lectura

Control PID con Arduino: Qué es y cómo ajustar Kp, Ki y Kd

¿Qué es el control PID? Términos P, I y D, librería PID de Arduino, ajuste de Kp/Ki/Kd y ejemplos de temperatura y robot seguidor de línea con código.

El control PID es un método de realimentación que calcula continuamente la diferencia (el error) entre el valor medido y el objetivo, y ajusta la salida según ese error para mantener un sistema en el valor que quieres. En proyectos con Arduino se usa para mantener un calentador justo a 45 °C, hacer girar un motor a velocidad constante o conducir un robot seguidor de línea justo por el centro de la línea. Su nombre viene de sus tres componentes: el término Proporcional (P) mira el error presente, el Integral (I) el error acumulado en el pasado y el Derivativo (D) la rapidez con la que cambia el error. La suma ponderada de los tres determina el valor PWM que irá al motor o al calentador.

Aunque las fórmulas asusten al principio, la lógica del PID se parece mucho a lo que haces sin pensar cuando conduces. En este artículo verás primero por qué el control simple todo o nada oscila y luego conocerás los tres términos con ejemplos intuitivos. Después harás un control de temperatura con la librería PID de Arduino usando un NTC y un MOSFET, aprenderás a ajustar Kp, Ki y Kd paso a paso y conducirás un robot seguidor de línea con un PID escrito sin librería. Por último, ejecutaremos el mismo algoritmo en el ESP32 y en la Raspberry Pi Pico con MicroPython.

¿Por qué no basta el control todo o nada?

El método de control más simple es el todo o nada (on-off): si la temperatura está por debajo del objetivo, enciendes el calentador a máxima potencia; si está por encima, lo apagas. El termostato de una caldera doméstica o el calentador de un acuario funcionan en gran parte así. El problema es que, al apagarse el calentador, el calor almacenado en él sigue pasando al ambiente, así que la temperatura supera el objetivo en unos grados. Cuando empieza a enfriarse, la temperatura baja por debajo del objetivo hasta que el calentador vuelve a encenderse y calienta. El resultado es un diente de sierra que sube y baja alrededor del objetivo. Para suavizarlo se deja un margen (histéresis) entre dos umbrales; el relé conmuta menos, pero la amplitud de la oscilación crece. Si necesitas mantener el objetivo dentro de ±0,5 °C, por ejemplo en la cama de una impresora 3D, en una incubadora o en un motor que debe girar a velocidad fija, esto no es suficiente. El PID, en cambio, genera una salida gradual entre la potencia máxima y cero, y reduce la potencia con antelación a medida que el sistema se acerca al objetivo.

MétodoCómo decideVentajaInconvenienteUso típico
Todo o nada (on-off)Potencia máxima si está por debajo del objetivo, apagado si está por encimaMuy simple, se puede hacer incluso con un reléOscilación y sobreoscilación constantes, desgaste del reléTermostato de caldera, calentador de acuario
PSalida proporcional al errorRespuesta suave, ajuste fácilQueda un error permanenteControl sencillo de posición y nivel
PIProporcional + error acumuladoElimina el error permanenteMás sobreoscilación, acumulación de integralControl de temperatura, caudal y velocidad de motor
PIDProporcional + error acumulado + velocidad de cambioRápido, poca sobreoscilación, precisoDifícil de ajustar, sensible al ruidoImpresora 3D, dron, robot equilibrista, robot seguidor de línea

¿Qué es el control PID y cómo funciona?

En cada ciclo, el PID calcula primero el error: error = valor objetivo (setpoint) − valor medido (input). Luego evalúa ese error de tres maneras distintas y las suma: salida = Kp·e + Ki·∫e·dt + Kd·de/dt. Aquí Kp, Ki y Kd son los coeficientes que ajustas tú; determinan cuánto contribuye cada término a la salida. En un microcontrolador, la integral se calcula sumando en cada muestreo el producto del error por el tiempo de muestreo, y la derivada dividiendo la diferencia entre las dos últimas medidas por el tiempo de muestreo. Por eso, para que el PID funcione bien es importante que las medidas se hagan a intervalos fijos, por ejemplo cada 10 ms o cada 500 ms. Imagina que sigues un carril en coche: cuanto más lejos estás del carril, más giras el volante (P); si el viento lateral te empuja constantemente, aprendes a mantener el volante ligeramente girado (I); y cuando te acercas rápido al carril, deshaces el giro antes de tiempo (D).

TérminoQué miraAnalogía intuitivaSi es excesivo
P (Proporcional)El error presenteCuanto más lejos estás del carril, más giras el volanteOscilación rápida, temblores
I (Integral)El error acumulado con el tiempoSi hay viento lateral, aprendes a mantener el volante algo giradoOscilación lenta y amplia, gran sobreoscilación
D (Derivativo)La velocidad de cambio del errorCuando te acercas rápido al carril, deshaces el giro antes de tiempoReacción exagerada al ruido, salida temblorosa

Término proporcional (P): respuesta proporcional al error

El término proporcional ajusta la salida en proporción directa a la magnitud del error. Si Kp = 20, un error de 3 °C produce 60 unidades PWM y un error de 1 °C produce 20; al acercarte al objetivo, la potencia baja sola. Cuanto más subes Kp, más rápido responde el sistema, pero a partir de cierto punto empieza a pasarse del objetivo y a volver, es decir, a oscilar. El control solo con P tiene una debilidad importante: el error permanente (steady-state error). Supón que, para mantener el calentador a 45 °C, hace falta una potencia continua de 80 unidades que compense el calor que se escapa al ambiente. Con solo el término P, esas 80 unidades solo pueden generarse si existe un error: 80 / 20 = 4 °C. Es decir, el sistema se estabiliza hacia los 41 °C y nunca llega al objetivo. Aumentar Kp reduce esa diferencia, pero también aumenta la oscilación.

Término integral (I): elimina el error permanente

El término integral suma el error a lo largo del tiempo. Incluso un error pequeño, si dura mucho, hace crecer la suma y la salida aumenta poco a poco hasta que el error desaparece. En el ejemplo anterior, ahora es el término integral el que aporta las 80 unidades de potencia necesarias, el término P baja a cero y la temperatura se asienta justo en 45 °C. Cuanto mayor es Ki, más rápido se cierra el error permanente; si es demasiado grande, el sistema hace oscilaciones lentas y amplias. Una trampa conocida de la integral es la acumulación de integral (windup): si el calentador ya está a plena potencia y no consigue llegar al objetivo, la integral sigue creciendo en vano y, cuando por fin se alcanza el objetivo, ese valor acumulado mantiene la temperatura por encima durante mucho tiempo. La solución es limitar la integral con los límites de salida; la librería PID de Arduino lo hace automáticamente con SetOutputLimits.

Término derivativo (D): frena al acercarte al objetivo

El término derivativo mira la rapidez con la que cambia el error y aporta una especie de anticipación. Si la temperatura se acerca rápido al objetivo, el error disminuye rápido; el término D contribuye en sentido contrario a ese cambio, corta la potencia antes de tiempo y reduce la sobreoscilación (overshoot). En un robot pasa lo mismo: si gira rápido hacia la línea, suaviza el giro antes de cruzarla. El punto débil del término D es su sensibilidad al ruido. Si la lectura de un sensor analógico salta unas unidades en cada medida, la derivada ve esos pequeños saltos como grandes cambios y la salida tiembla. Por eso conviene promediar o filtrar la lectura del sensor; para más detalles puedes consultar el artículo sobre filtrado de datos de sensores. Además, las buenas implementaciones de PID calculan la derivada a partir de la medida y no del error; así, cuando cambias el objetivo bruscamente, no aparece un salto repentino en la salida (derivative kick).

Ejemplo 1: control de temperatura con la librería PID de Arduino

En el primer ejemplo mantendremos un pequeño calentador (una almohadilla calefactora de 12 V o una resistencia de potencia) a 45 °C. Mediremos la temperatura con un divisor de tensión formado por un termistor NTC de 10 kΩ y una resistencia fija de 10 kΩ, y controlaremos el calentador con PWM a través de un MOSFET de canal N de nivel lógico (p. ej. IRLZ44N). En el Arduino IDE abre el Gestor de bibliotecas, busca PID e instala la librería PID de Brett Beauregard (PID_v1). Esta librería se encarga por ti de detalles como la gestión del tiempo de muestreo, la limitación de la salida, la protección contra la acumulación de integral y el cálculo de la derivada sobre la medida. Para los detalles de la conexión del MOSFET, echa un vistazo al artículo Uso del MOSFET con Arduino.

Sensor de temperatura termistor NTC
Termistor NTC de 10 kΩ: su resistencia baja al subir la temperatura; se usa como elemento de medida en el control de temperatura con PID.
ConexiónArduino UnoESP32Raspberry Pi Pico
Alimentación del divisor (extremo superior de la resistencia fija de 10 kΩ)5V3V33V3
Unión entre el NTC y la resistencia fijaA0GPIO 34GP26 (ADC0)
Extremo inferior del NTCGNDGNDGND
Gate del MOSFET (a través de 220 Ω, con 10 kΩ a GND)D9GPIO 25GP15
Source del MOSFETGNDGNDGND
CalentadorEntre +12 V y el drain del MOSFETEntre +12 V y el drain del MOSFETEntre +12 V y el drain del MOSFET
No alimentes nunca el calentador directamente desde un pin de Arduino; un pin solo puede dar unos 20–40 mA como máximo, mientras que un calentador consume amperios. El negativo del adaptador de 12 V debe ser común con el GND del Arduino, o el MOSFET no se activará bien. Como el ESP32 y la Pico dan salidas de 3,3 V, elige en lugar del IRLZ44N un MOSFET que conduzca por completo a 3,3 V (p. ej. AO3400); y si controlas una carga inductiva como un ventilador o un motor, añade un diodo en antiparalelo con la 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}

En el código, la función readTemperature() reduce el ruido promediando 16 medidas, calcula la resistencia del NTC con la fórmula del divisor (R = 10 kΩ · adc / (1023 − adc)) y la convierte a grados centígrados con la ecuación Beta (B = 3950). SetOutputLimits(0, 255) mantiene la salida en el rango de analogWrite e impide que la integral se salga de esos límites. SetSampleTime(500) hace que el PID calcule cada medio segundo; como el calor es una magnitud que cambia despacio, es suficiente. Compute() solo devuelve true cuando llega el momento del muestreo, así que no debes usar delay() dentro de loop(). Si abres los tres valores enviados por el puerto serie en el Serial Plotter del menú Herramientas, verás en la misma gráfica el objetivo, la temperatura y la potencia del calentador en porcentaje, y podrás observar al instante el efecto de tu ajuste. En un sistema de refrigeración (p. ej. enfriar con un ventilador), la salida debe aumentar cuando sube la temperatura; en ese caso usa REVERSE en lugar de DIRECT.

¿Cómo se ajustan Kp, Ki y Kd? Paso a paso

  1. Pon Ki y Kd a cero, empieza con un Kp pequeño (p. ej. 2) y abre el Serial Plotter.
  2. Duplica Kp paso a paso; para cuando el sistema se acerque rápido al objetivo y empiece a oscilar continuamente a su alrededor. Usa aproximadamente la mitad de ese valor como Kp.
  3. Añade Kd: empieza con un valor pequeño y auméntalo hasta que la sobreoscilación y la oscilación se apaguen. Si la salida empieza a temblar o el motor a chirriar, Kd es excesivo o el sensor tiene ruido.
  4. Añade Ki al final: auméntalo despacio hasta que el error permanente se cierre en un tiempo razonable. Si la temperatura dibuja ondas lentas y amplias alrededor del objetivo, reduce Ki.
  5. Pruébalo con una perturbación: cambia el objetivo 5 °C, sopla sobre el calentador o empuja suavemente el robot con la mano; observa cuánto tarda el sistema en recuperarse y con cuánta sobreoscilación.
  6. Si quieres, usa el método de Ziegler-Nichols como punto de partida: mide con solo P la ganancia que provoca una oscilación sostenida (Ku) y el periodo de oscilación (Tu, en segundos); empieza con Kp = 0,6·Ku, Ki = 1,2·Ku / Tu, Kd = 0,075·Ku·Tu y haz el ajuste fino a mano.
Al aumentar el coeficienteTiempo de subidaSobreoscilación (overshoot)Tiempo de establecimientoError permanente
KpSe acortaAumentaCambia pocoDisminuye
KiSe acortaAumentaSe alargaSe anula
KdCambia pocoDisminuyeSe acortaEn teoría no lo afecta

Ejemplo 2: PID en un robot seguidor de línea

Sensor de línea infrarrojo TCRT5000
Sensor reflectivo infrarrojo TCRT5000: distingue el suelo negro del blanco; proporciona la entrada del PID en el robot seguidor de línea.

En un robot seguidor de línea, el objetivo es que la línea quede justo en el centro del robot. Con un promedio ponderado de las lecturas de tres sensores analógicos TCRT5000 colocados a la izquierda, en el centro y a la derecha, convertimos la posición de la línea en un número entre 0 (totalmente a la izquierda) y 2000 (totalmente a la derecha); 1000 es el centro exacto. El error es la diferencia entre la posición y 1000. La corrección que genera el PID se suma a la velocidad del motor izquierdo y se resta de la del derecho, de modo que el robot gira suavemente hacia la línea. Mientras que los robots con lógica todo o nada (si la línea está a la izquierda gira a la izquierda, si está a la derecha gira a la derecha) avanzan haciendo eses y despacio, un robot con PID recorre la misma pista a mucha más velocidad y con un trazado limpio. En este ejemplo escribimos el PID desde cero, sin librería; los motores se controlan con un 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}

Los sensores van a A0, A1 y A2, los pines ENA y ENB del L298N a los pines PWM D5 y D6, y los pines IN1–IN4 a D7, D8, D9 y D10; no olvides quitar los puentes (jumpers) de ENA y ENB. El bucle se ejecuta cada 10 ms con millis(); así dt se mantiene constante y los coeficientes se comportan de forma coherente. Por qué usamos millis() en vez de delay() lo encontrarás en el artículo millis y delay. Si el error es negativo, la línea está a la izquierda: la corrección es negativa, el motor izquierdo se frena, el derecho se acelera y el robot gira a la izquierda. Como la magnitud del error es como máximo 1000, Kp = 0,1 significa una corrección de unas 100 unidades PWM en el error máximo. Como la derivada se calcula por segundo, es normal que Kd parezca pequeño, como 0,004. En un seguidor de línea, Ki suele dejarse en cero o muy pequeño; la integral solo resulta útil si el robot se desvía constantemente hacia un lado (p. ej. si un motor es más débil que el otro). Si tus sensores leen un valor alto sobre fondo blanco y bajo sobre la línea negra, invierte la lectura con 1023 − v.

PID con ESP32 y Raspberry Pi Pico

Como la librería PID_v1 está escrita en C++ puro, funciona tal cual también en el ESP32; basta con conectar el NTC al GPIO 34 y el gate del MOSFET al GPIO 25. Las diferencias están en el hardware: el ADC del ESP32 es de 12 bits (0–4095) y no es lineal cerca de los extremos; mantener la tensión medida entre 0,3 y 2,8 V mejora el resultado. Para el PWM se usa la unidad LEDC en lugar de analogWrite, y como esta API cambió con el core 3.x, el código incluye una comprobación de versión. Gracias a ser rápido y de doble núcleo, el ESP32 puede ejecutar el bucle PID y, al mismo tiempo, recibir desde una página web una nueva temperatura objetivo.

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}

Como en MicroPython para la Raspberry Pi Pico no hay un módulo PID listo, escribimos el algoritmo como una pequeña clase. Esta clase imita tres cosas importantes que hace la librería de Arduino: mantiene la integral dentro de los límites de salida (anti-windup), calcula la derivada sobre la medida y tiene en cuenta el tiempo de muestreo (dt). El ADC de la Pico devuelve valores de 0 a 65535 con read_u16(); la salida del PID se calcula en el rango 0–255 y se multiplica por 257 para escalarla a 16 bits para duty_u16(). Así, los valores de Kp, Ki y Kd que encuentres en Arduino puedes usarlos igual en la Pico. El divisor del NTC va a GP26 y el gate del MOSFET a GP15. Si eres nuevo en MicroPython, puedes empezar con el artículo 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))

Ideas de proyectos con control PID

  • Termostato preciso: en un proyecto de termostato con Arduino, usa PID en lugar de todo o nada para mantener una incubadora o un armario de fermentación dentro de ±0,3 °C.
  • Velocidad del ventilador según la temperatura: en un proyecto de control de ventilador, maneja el ventilador con un PID en modo REVERSE para lograr una refrigeración silenciosa y estable.
  • Robot seguidor de línea rápido: añade 5 sensores y PID a tu proyecto de robot seguidor de línea y llévalo a velocidad de competición.
  • Robot autoequilibrado: mide el ángulo de inclinación con un MPU-6050 y mantén en pie un robot de dos ruedas; es una de las aplicaciones más didácticas del PID.
  • Seguidor solar: en un proyecto de seguidor solar, usa la diferencia entre dos LDR como error y gira el panel con suavidad.
  • Estación de soldadura o minihorno: mide altas temperaturas con un termopar MAX6675 y controla el calentador con PID.
  • Motor a velocidad constante: mantén en el objetivo las revoluciones de un motor DC con reductora y encoder, aunque cambie la carga.

Errores frecuentes y cómo solucionarlos

SíntomaCausa probableSolución
El sistema oscila rápida y continuamente alrededor del objetivoKp demasiado alto o Kd insuficienteBaja Kp un 30–50 % y sube un poco Kd
Nunca llega al objetivo, se queda unos grados por debajoKi es cero o muy pequeñoSube Ki poco a poco; comprueba que la potencia del calentador es suficiente
Sobreoscilación grande y prolongada al final del calentamientoAcumulación de integral (windup)Limita la salida con SetOutputLimits, restringe la integral y baja Ki
La salida tiembla, el motor chirríaSensor con ruido y Kd altoPromedia o filtra la medida y baja Kd
La salida aumenta al subir la temperaturaSentido de control invertidoUsa REVERSE en refrigeración o invierte el signo del error
Los mismos coeficientes a veces funcionan bien y a veces malMuestreo irregular, delay() dentro de loopUsa millis() con un dt fijo y evita delay()
El calentador está siempre a plena potencia pero la temperatura no subeHardware insuficiente (potencia, aislamiento, MOSFET)El PID no puede compensar un hardware deficiente; revisa la potencia y las conexiones
Ajustar los coeficientes recargando el código cada vez resulta agotador. Si añades unas líneas que lean por el puerto serie comandos como "p2.5" o "d0.8" y actualicen los coeficientes en marcha con SetTunings(Kp, Ki, Kd), encontrarás un buen ajuste en minutos mirando la gráfica del Serial Plotter. Para conservar los valores que encuentres, puedes guardarlos en la EEPROM.

El control PID es un método que combina el ciclo medir-comparar-corregir con tres ideas simples, y se usa en todas partes, desde proyectos de aficionados hasta hornos industriales. Primero comprueba los límites del control todo o nada, luego empieza con P, frena con D y cierra el error permanente con I; la gráfica del Serial Plotter te guiará en cada paso. En la app de BlueGrays puedes ver paso a paso, con esquemas y código, proyectos que usan las piezas de este artículo, como la medición de temperatura con NTC, la detección de suelo con TCRT5000, el coche robot con L298N y el control PWM con potenciómetro, y empezar desde ahí a añadir PID a tu propio proyecto.

Preguntas frecuentes

¿Qué es el control PID y para qué sirve?

El control PID es un método de realimentación que calcula continuamente el error para mantener un valor medido en el objetivo y ajusta la salida en consecuencia. El término proporcional reacciona al error presente, el integral al error acumulado y el derivativo a la velocidad de cambio del error. En control de temperatura, velocidad de motor, posición y equilibrio da resultados mucho más estables y precisos que el método todo o nada.

¿Cómo se encuentran los valores de Kp, Ki y Kd?

La forma más práctica es el ajuste manual: pon Ki y Kd a cero, sube Kp hasta que el sistema oscile y redúcelo a la mitad, añade Kd para frenar la sobreoscilación y, por último, añade Ki para cerrar el error permanente. El método de Ziegler-Nichols da un buen punto de partida, pero el ajuste fino casi siempre se hace a mano. Los valores son específicos de cada sistema; los coeficientes copiados de otro proyecto pueden no funcionar en tu circuito.

¿Cuál es la diferencia entre PID y control todo o nada?

El control todo o nada solo pone la salida totalmente encendida o totalmente apagada, por lo que provoca oscilación y sobreoscilación constantes alrededor del objetivo. El PID, en cambio, ajusta la salida de forma gradual, reduce la potencia con antelación al acercarse al objetivo y elimina el error permanente con el término integral. El todo o nada es más simple y barato; el PID es más preciso, pero requiere ajuste.

¿Cuál es la librería PID de Arduino y cómo se instala?

La más extendida es la librería PID de Brett Beauregard (PID_v1). Puedes instalarla buscando "PID" en el Gestor de bibliotecas del Arduino IDE y usarla incluyendo el archivo de cabecera PID_v1.h en tu código. La librería gestiona por sí sola el tiempo de muestreo, la limitación de la salida y la protección contra la acumulación de integral.

¿Qué es el windup de la integral y cómo se evita?

El windup de la integral ocurre cuando el error sigue acumulándose en la integral aunque la salida ya esté en su límite (p. ej. con el calentador a plena potencia). Al alcanzar el objetivo, ese valor acumulado hace que el sistema se pase del objetivo durante mucho tiempo. Para evitarlo hay que mantener la integral dentro de los límites de salida; en la librería PID de Arduino, SetOutputLimits lo hace automáticamente.

¿Se puede hacer control PID con un relé?

Sí, con el método de proporción de tiempo (time proportioning): por ejemplo, en una ventana de 5 segundos, si la salida del PID es del 40 %, el relé se mantiene 2 segundos encendido y 3 apagado. Como los relés mecánicos se desgastan rápido con conmutaciones frecuentes, para esto es más adecuado un relé de estado sólido (SSR). En sistemas de respuesta lenta, como un calentador, este método da resultados tan buenos como el PWM.

Ver todos los proyectos
Temperatura y humedad con DHT11
AR-55Intermedio

Temperatura y humedad con DHT11

¿Qué temperatura hace en tu habitación, y el aire está húmedo o seco? El sensor DHT11 mide la temperatura y la humedad, y el Arduino escribe los valores en una pantalla LCD de dos líneas…

4.7(47)
83
HC-SR04 Medición de distancia (pantalla en serie)
AR-27Principiante

HC-SR04 Medición de distancia (pantalla en serie)

El sensor HC-SR04 funciona igual que un murciélago que se orienta en la oscuridad: emite un sonido que no puedes oír, escucha el eco y mide a qué distancia está el objeto que tiene delante.

4.6(50)
82
Medición de temperatura con NTC y pantalla LCD 2x16
AR-44Principiante
Premium

Medición de temperatura con NTC y pantalla LCD 2x16

Mide la temperatura del ambiente con un sensor que parece una pequeña cuenta. Esta pieza, llamada NTC, deja pasar la electricidad con más facilidad cuanto más se calienta; el Arduino lee ese cambio…

4.5(33)
44
TCRT5000 Detección de superficie blanca y negra
AR-78Intermedio
Premium

TCRT5000 Detección de superficie blanca y negra

Con el pequeño sensor que hace de ojo en los robots sigue líneas, sabrás si el suelo es negro o blanco.

4.7(40)
49
Lectura de reflexión (proximidad) con TCRT5000
AR-77Intermedio
Premium

Lectura de reflexión (proximidad) con TCRT5000

Con un pequeño sensor que emite luz invisible y mide cuánta rebota, detectas la superficie que tiene delante.

4.6(33)
43
Robot para evitar obstáculos
AR-81Avanzado
Premium

Robot para evitar obstáculos

¿Qué le parece construir un vehículo inteligente que encuentre su propio camino? El Robot Evitador de Obstáculos explora constantemente su entorno gracias al sensor ultrasónico que lleva delante.

5.0(38)
49
Coche controlado por Bluetooth con L298N
AR-80Avanzado
Premium

Coche controlado por Bluetooth con L298N

Convierte tu móvil en un mando y conduce tu propio coche robot. El Arduino recibe por un módulo Bluetooth las órdenes de una app de control remoto en el móvil y mueve las ruedas con un controlador de…

5.0(39)
66
Brillo de LED con Potenciómetro en ESP32 (Analógico → PWM)
ES-13Intermedio
Premium

Brillo de LED con Potenciómetro en ESP32 (Analógico → PWM)

En este proyecto controlamos el brillo de un LED de forma analógica mediante un potenciómetro. El pin ADC del ESP32 lee la tensión de 0-3,3 V procedente del potenciómetro y este valor se convierte en una señal PWM (modulación por ancho de pulso) que se envía al LED. Al girar el potenciómetro, el LED se enciende y se apaga gradualmente. Con Arduino Core 3.0+ se usa directamente analogWrite(); en el ESP32-S2/S3, la resolución del ADC es de 12 bits.

4.5(19)
32