← Volver al blog

Qué es un control PID y cómo implementarlo en firmware

14 junio 2026 · 8 min de lectura

Si tu producto tiene que mantener una variable en un valor objetivo —la velocidad de un motor, la temperatura de un horno, la posición de un brazo, la presión de una bomba— tarde o temprano te toparás con el control PID. Es el algoritmo de control más usado de la industria, y entenderlo bien marca la diferencia entre un producto que responde con suavidad y otro que oscila, se pasa de largo o reacciona tarde.

Qué es un control PID

Un controlador PID (Proporcional-Integral-Derivativo) es un algoritmo que ajusta de forma continua una salida para que una medida real se acerque a un valor deseado, llamado referencia o setpoint. Lo hace calculando el error (la diferencia entre lo que quieres y lo que hay) y corrigiéndolo a partir de tres componentes que trabajan juntas.

Referencia Σ + − error e(t) Controlador P · I · D u(t) Proceso / Planta salida y(t) Sensor
Lazo de control en bucle cerrado: el sensor mide la salida real, se compara con la referencia y el PID corrige el error.

Las tres componentes: P, I y D

  • Proporcional (P): reacciona al error actual. Cuanto más lejos estás del objetivo, más fuerte corrige. Sube la velocidad de respuesta, pero por sí sola deja un pequeño error permanente y, si es muy alta, provoca oscilaciones.
  • Integral (I): acumula el error pasado. Es la que elimina ese error permanente: mientras quede diferencia, sigue empujando hasta clavar el valor. A cambio, si te pasas, ralentiza y puede provocar sobreoscilación (overshoot).
  • Derivativa (D): anticipa el error futuro mirando lo rápido que cambia. Actúa como un freno que suaviza la respuesta y reduce el overshoot, pero amplifica el ruido del sensor, así que hay que usarla con cuidado.

La salida del controlador es la suma de las tres: u(t) = Kp·e + Ki·∫e·dt + Kd·de/dt. Ajustar las ganancias Kp, Ki y Kd es lo que define el carácter del sistema.

Un ejemplo sencillo: la velocidad de un motor

Imagina un motor que debe girar a 1.000 rpm. Mides las rpm reales con un encoder, las restas a las 1.000 deseadas y obtienes el error. El PID convierte ese error en una señal PWM que alimenta el motor: si va lento, sube el PWM; si se pasa, lo baja. El encoder vuelve a medir y el ciclo se repite decenas o cientos de veces por segundo. El resultado es un motor que mantiene la velocidad aunque cambie la carga —exactamente lo mismo que hace el control de crucero de un coche en una cuesta—.

Cómo se implementa en firmware

En un microcontrolador, el PID se calcula en un bucle a intervalo fijo (por ejemplo, cada 10 ms desde una interrupción de temporizador). Una implementación discreta básica en C es así:

typedef struct {
    float kp, ki, kd;
    float integral, prev_error;
    float out_min, out_max;   // límites de la salida
} pid_t;

float pid_update(pid_t *pid, float setpoint, float measured, float dt) {
    float error = setpoint - measured;
    pid->integral += error * dt;
    float derivative = (error - pid->prev_error) / dt;
    pid->prev_error = error;

    float out = pid->kp * error
              + pid->ki * pid->integral
              + pid->kd * derivative;

    // Saturación + anti-windup: no dejes crecer la integral sin límite
    if (out > pid->out_max) { out = pid->out_max; pid->integral -= error * dt; }
    if (out < pid->out_min) { out = pid->out_min; pid->integral -= error * dt; }
    return out;
}

Los detalles que separan un PID de juguete de uno profesional están en lo que rodea a esa fórmula: un dt constante y bien medido, la saturación de la salida con anti-windup (para que la integral no se dispare cuando el actuador llega al máximo), el filtrado del término derivativo y el uso de aritmética adecuada (entera o de punto fijo) en MCUs sin unidad de coma flotante.

Cómo ajustar (tunear) un PID

  • Empieza solo con P: súbela hasta que el sistema responda rápido pero justo antes de que empiece a oscilar.
  • Añade I poco a poco para eliminar el error permanente, sin pasarte (provoca sobreoscilación).
  • Usa D con moderación para amortiguar, solo si el ruido del sensor lo permite.
  • Métodos como Ziegler-Nichols dan un punto de partida, pero el ajuste fino casi siempre es empírico y depende de tu hardware real.

Errores comunes

  • Calcular el PID con un dt variable (por ejemplo dentro de un loop() sin control de tiempo): los resultados se vuelven impredecibles.
  • Olvidar el anti-windup: el sistema responde con un retardo enorme tras saturar.
  • Aplicar la derivada directamente sobre una señal ruidosa, lo que mete vibraciones en el actuador.
  • Querer resolverlo todo con PID cuando el proceso tiene grandes retardos o no linealidades: a veces hace falta otra estrategia.

Conclusión

Un control PID bien implementado es la diferencia entre un producto que se siente sólido y uno que vibra, se calienta o responde tarde. El concepto es sencillo, pero hacerlo robusto en un microcontrolador real —con su temporización, su ruido y los límites del actuador— es un trabajo de firmware fino. En Regular Solids diseñamos e implementamos lazos de control para motores, temperatura, potencia y movimiento en productos embebidos. Si tienes un producto que necesita controlar algo con precisión, cuéntanoslo.

Sigue leyendo