Fundamentos de la regulación PID en automatización

El controlador PID (Proporcional-Integral-Derivativo) es el algoritmo de control más extendido en la industria. Su misión es mantener una variable de proceso (PV) (temperatura, presión, caudal, nivel, velocidad) lo más cerca posible de un valor de consigna (SP), a pesar de perturbaciones externas. Los PLC modernos integran bloques PID como funciones estándar (por ejemplo, CONT_CPU en Siemens, PID en CODESYS), que simplifican su implementación y sintonización.

El bloque PID compara continuamente PV con SP, calcula el error e(t) = SP - PV y genera una señal de control MV(t) que actúa sobre un actuador (válvula, variador de frecuencia, resistencia calefactora). La combinación de las tres acciones permite:

  • Proporcional (P): respuesta inmediata proporcional al error.
  • Integral (I): elimina el error en estado estacionario (offset).
  • Derivativa (D): anticipa la tendencia del error, mejorando la estabilidad y reduciendo sobreimpulsos.

Acciones proporcional, integral y derivativa

La ecuación del PID en tiempo continuo es:

MV(t) = Kp · e(t) + Ki · ∫e(t) dt + Kd · de(t)/dt

En PLC, la implementación es discreta (tiempo de muestreo Ts). Los parámetros se ajustan según el proceso:

  • Ganancia proporcional (Kp): a mayor Kp, respuesta más rápida pero riesgo de oscilaciones. Si es demasiado baja, la respuesta es lenta y puede haber error residual.
  • Ganancia integral (Ki) o tiempo integral (Ti): la acción integral acumula el error en el tiempo. Un Ki alto elimina rápido el offset pero puede causar inestabilidad (efecto windup).
  • Ganancia derivativa (Kd) o tiempo derivativo (Td): actúa como "freno" predictivo. Muy sensible al ruido de medición; a menudo se desactiva (D=0) si la señal es ruidosa.

Ejemplo paso a paso: Control de temperatura de un horno. Si la temperatura (PV) está por debajo de la consigna (SP), el error es positivo. La acción proporcional aumenta la potencia; si el error persiste, la integral incrementa gradualmente la potencia hasta alcanzar SP. Si la temperatura se acerca rápidamente, la derivativa reduce la potencia para evitar sobrepaso.

Configuración de un bloque PID en PLC

Un bloque PID típico (por ejemplo, FB 41 "CONT_C" en Siemens) dispone de las siguientes entradas/salidas principales:

  • Entradas:
    • PV_IN / PV_PER: variable de proceso (analógica o valor normalizado).
    • SP_INT: consigna interna (puede venir de HMI o de un bloque superior).
    • MAN / AUT: modos manual/automático.
    • GAIN, TI, TD: parámetros de sintonización.
  • Salidas:
    • LMN: salida de control (valor analógico normalizado).
    • QLMN_HLM, QLMN_LLM: indicadores de límite de salida.
    • PV: valor de proceso escalado (para depuración).

Además, se debe configurar el tiempo de muestreo (normalmente el tiempo de ciclo del bloque) y los límites de la salida (para evitar saturación del actuador). Muchos PLC incluyen funciones de anti‑windup que detienen la acción integral cuando la salida está saturada.

Bloque PID_Compact en TIA Portal (FBD): entradas Setpoint (equivalente SP_INT) e Input/Input_PER (equivalente PV_IN); salidas Output (equivalente LMN), Output_PER, State y Error. CPU S7-1512C-1 PN con árbol de proyecto visible.
Figura 11a: Bloque PID estándar en TIA Portal (PID_Compact) — entradas Setpoint (SP) e Input (PV), salidas Output (LMN). Fuente: InstrumentationTools.com / Licencia: Uso educativo — todos los derechos del autor.
Pestaña 'PID Parameters' del bloque PID_Compact en TIA Portal: campos Proportional gain (GAIN), Integral action time (TI), Derivative action time (TD) y Tuning rule con estructura PID seleccionable.
Figura 11b: Pestaña de sintonización del controlador PID — parámetros Ganancia (Kp), Tiempo integral (Ti) y Tiempo derivativo (Td). Fuente: InstrumentationTools.com / Licencia: Uso educativo — todos los derechos del autor.

Sintonización de parámetros: métodos y herramientas

El ajuste de Kp, Ti, Td es crítico. Existen varios enfoques:

  • Método empírico de Ziegler‑Nichols en lazo abierto o cerrado. Por ejemplo, en lazo cerrado se aumenta Kp hasta que el sistema oscile de forma sostenida (ganancia última Ku y período último Tu). Luego se aplican fórmulas para obtener Kp, Ti, Td.
  • Método de tanteo (prueba y error): se ajusta Kp para una respuesta rápida sin oscilaciones, luego se añade acción integral para eliminar offset, y finalmente derivativa si es necesario.
  • Autoajuste (autotuning): muchos PLC modernos (Siemens S7-1500, Rockwell) incorporan asistentes que inyectan una perturbación y calculan automáticamente los parámetros óptimos.

Datos técnicos: En procesos lentos (temperatura) se usan tiempos de muestreo de 1-5 segundos; en procesos rápidos (caudal, presión) pueden ser de 0.1-0.5 segundos. Los valores típicos de Kp pueden variar desde 0.5 hasta 10 según el rango de la variable.

🐍 Implementación de un regulador PID en Python (para pruebas y Raspberry Pi)
# pid_controller.py - Clase PID genérica para simulación o control real
# Se puede ejecutar en Thonny y adaptar a GPIO con PWM o salidas analógicas

import time

class PID:
    """Regulador PID discreto con anti-windup y límites de salida."""
    def __init__(self, Kp=1.0, Ki=0.0, Kd=0.0, setpoint=0.0, sample_time=0.1, output_limits=(None, None)):
        self.Kp = Kp
        self.Ki = Ki
        self.Kd = Kd
        self.setpoint = setpoint
        self.sample_time = sample_time   # tiempo entre llamadas (s)
        self.output_limits = output_limits

        # Variables internas
        self.last_error = 0.0
        self.integral = 0.0
        self.last_time = None
        self.last_output = 0.0

    def reset(self):
        """Reinicia el estado del integrador y derivador."""
        self.integral = 0.0
        self.last_error = 0.0
        self.last_time = None

    def set_setpoint(self, sp):
        self.setpoint = sp

    def update(self, feedback, dt=None):
        """
        Calcula la salida del PID a partir de la realimentación (feedback).
        dt: opcional, si no se proporciona usa sample_time.
        """
        error = self.setpoint - feedback

        # Tiempo transcurrido
        if dt is None:
            dt = self.sample_time

        # Acción proporcional
        P = self.Kp * error

        # Acción integral (con anti-windup simple)
        self.integral += error * dt
        I = self.Ki * self.integral

        # Acción derivativa (evita diferenciación del ruido)
        D = self.Kd * (error - self.last_error) / dt if dt > 0 else 0.0

        # Salida total
        output = P + I + D

        # Limitar salida
        if self.output_limits[0] is not None:
            output = max(self.output_limits[0], output)
        if self.output_limits[1] is not None:
            output = min(self.output_limits[1], output)

        # Anti-windup: si la salida está limitada, congelar la integral
        if output != P + I + D:
            # Deshacer la adición integral de este ciclo
            self.integral -= error * dt

        self.last_error = error
        self.last_output = output
        return output

# --- Simulación de un proceso simple (primer orden con retardo) ---
import matplotlib.pyplot as plt
import numpy as np

if __name__ == "__main__":
    # Parámetros del proceso (simulado)
    K = 2.0          # ganancia estática
    tau = 1.0        # constante de tiempo
    theta = 0.2      # retardo
    dt = 0.1

    pid = PID(Kp=2.5, Ki=1.5, Kd=0.2, setpoint=10.0, sample_time=dt, output_limits=(0, 100))
    t = np.arange(0, 20, dt)
    pv = np.zeros_like(t)
    mv = np.zeros_like(t)

    # Inicial
    pv[0] = 0.0
    pid.reset()
    pid.set_setpoint(10.0)

    # Buffer para retardo
    delay_buffer = [0.0] * int(theta/dt + 1)
    delay_index = 0

    for i in range(1, len(t)):
        # Calcula la salida del PID con la PV actual
        mv[i] = pid.update(pv[i-1])

        # Aplica el retardo: la salida del PID afecta al proceso después de theta
        delay_buffer[delay_index] = mv[i]
        delay_index = (delay_index + 1) % len(delay_buffer)
        mv_delayed = delay_buffer[delay_index]

        # Modelo del proceso: primer orden
        pv[i] = pv[i-1] + (dt/tau) * (K * mv_delayed - pv[i-1])

    # Graficar
    plt.figure(figsize=(10,5))
    plt.subplot(2,1,1)
    plt.plot(t, pv, label='PV (temperatura)')
    plt.axhline(y=10.0, color='r', linestyle='--', label='Setpoint')
    plt.ylabel('PV')
    plt.legend()
    plt.subplot(2,1,2)
    plt.plot(t, mv, label='MV (salida control)')
    plt.ylabel('MV')
    plt.xlabel('Tiempo (s)')
    plt.legend()
    plt.tight_layout()
    plt.show()

Esta clase PID implementa un regulador discreto con anti‑windup y límites. El ejemplo simula un proceso de primer orden con retardo, mostrando la respuesta típica. Se puede probar en Thonny (requiere matplotlib) y luego adaptar a Raspberry Pi usando PWM para control real.

Aplicaciones típicas: temperatura, presión, caudal

  • Control de temperatura: Hornos, intercambiadores, inyectores de plástico. El PID ajusta la potencia de calefacción o refrigeración. Los termopares o PT100 proporcionan PV. Importante: procesos con gran inercia térmica requieren tiempos integrales grandes (Ti altos).
  • Control de presión: En tanques o tuberías, el PID actúa sobre válvulas o bombas. La presión puede variar rápidamente; a menudo se usa solo PI (sin derivativa) para evitar inestabilidad por ruido.
  • Control de caudal: El PID mantiene el flujo constante ajustando una válvula de control. Es un proceso rápido; se requiere un tiempo de muestreo pequeño y buena calidad de señal (filtrado).
  • Estrategias avanzadas: Control en cascada (maestro‑esclavo), PID con realimentación de modelo, adaptativo, etc.
Tendencias Actuales 2026

Los PLC de última generación incorporan bloques PID con autoajuste predictivo basado en inteligencia artificial, que analiza la respuesta del proceso y ajusta los parámetros en tiempo real. Además, se integran con gemelos digitales para simular el lazo antes de la puesta en marcha. La norma IEC 61131-3 edición 4 incluye un bloque PID estándar con funciones de diagnóstico y comunicación OPC UA.

Aplicaciones con Raspberry Pi

Con Python y la clase PID anterior, se puede implementar un regulador en tiempo real leyendo sensores (por ejemplo, temperatura con DS18B20) y actuando sobre un PWM (para control de potencia). El lazo se ejecuta con un temporizador y se pueden visualizar las variables con matplotlib o enviarlas a un panel web.

Aplicaciones con Arduino

La librería ArduinoPID (de Brett Beauregard) es ampliamente usada. En el Arduino PLC IDE, se dispone de bloques PID gráficos con ajuste de parámetros. Es ideal para controlar temperatura, nivel o velocidad en proyectos educativos o industriales pequeños.

💼 Caso Práctico Industrial: Horno

Contexto: Se desea controlar la temperatura de un horno industrial mediante un PID. Tras sintonizar, se obtiene una respuesta con un pequeño error estacionario (offset) y un tiempo de establecimiento aceptable, pero el operador desea eliminar ese offset sin aumentar el sobreimpulso.

Pregunta: ¿Qué acción del PID debe modificarse y cómo?

🍓 Raspberry Pi + Python

Contexto: En una Raspberry Pi se ha implementado la clase PID del ejemplo. Se conecta un sensor de temperatura DS18B20 (lectura cada segundo) y un relé mediante GPIO para controlar una resistencia. El bucle principal lee la temperatura, llama a pid.update(temp) y si la salida supera un umbral, activa el relé.

Pregunta: ¿Qué precaución es fundamental al usar la acción derivativa con este sensor?

🐍 Cálculo de acción PID

Contexto: Un PID tiene parámetros Kp=2.0, Ki=0.5, Kd=0.1, tiempo de muestreo dt=0.1 s. En un instante, el error actual es 3.0, el error anterior era 2.5, y la integral acumulada (sin contar este ciclo) es 1.2.

Pregunta: ¿Cuál es la salida (P+I+D) antes de limitar?

Tabla 1: Efecto de las acciones P, I, D en la respuesta
AcciónParámetroEfecto en respuesta rápidaEfecto en error estacionarioEfecto en estabilidad
Proporcional (P)Kp ↑Aumenta velocidadDisminuye pero no eliminaPuede causar oscilaciones
Integral (I)Ki ↑ / Ti ↓Puede reducir velocidadElimina offsetPuede aumentar sobreimpulso
Derivativa (D)Kd ↑ / Td ↑Mejora anticipaciónNo afectaReduce sobreimpulso, pero sensible al ruido

📚 Recursos Técnicos y Normativos 2026

Normativas y Estándares

Recursos Raspberry Pi y Python