3.5. Lenguajes de programación (IEC 61131-3)

# ============================================================
# SIMULACIÓN DE UN ALGORITMO PID EN PYTHON (ESTILO ST)
# ============================================================
# Este programa implementa un controlador PID simple, similar
# a cómo se programaría en Texto Estructurado (ST) en un PLC.
#
# Se definen las variables (muchas de ellas persistentes, como
# en un PLC). El bucle principal simula el ciclo de escaneo.
#
# Ejecútalo en Thonny para ver cómo evoluciona la salida ante
# cambios en la consigna y en la variable de proceso.
# ============================================================

import time
import matplotlib.pyplot as plt
from collections import deque

# ------------------------------------------------------------
# 1. DEFINICIÓN DE VARIABLES (SIMULA MEMORIA DEL PLC)
# ------------------------------------------------------------
# Variables de entrada (desde sensores)
setpoint = 50.0          # Consigna (temperatura deseada, por ejemplo)
proceso = 20.0           # Variable de proceso (temperatura actual)
                          # En un PLC real, esto se leería de una entrada analógica

# Variables de salida (hacia actuador)
salida = 0.0             # Señal de control (por ejemplo, 0-100%)

# Parámetros del PID (ajustados manualmente)
Kp = 2.0                 # Ganancia proporcional
Ki = 0.5                 # Ganancia integral
Kd = 1.0                 # Ganancia derivativa

# Variables internas del PID (persistentes entre ciclos)
error_anterior = 0.0
integral = 0.0
derivada = 0.0
tiempo_anterior = time.time()

# Para registrar el comportamiento (no es parte del PID, solo para visualización)
historial_tiempo = []
historial_proceso = []
historial_salida = []
historial_setpoint = []

# ------------------------------------------------------------
# 2. FUNCIÓN PID (SIMULA UN BLOQUE FUNCIONAL EN ST)
# ------------------------------------------------------------
def calcular_pid(setpoint, proceso, dt):
    """Calcula la salida PID en función de la consigna y el proceso.
       Equivalente a un bloque funcional en FBD o ST.
       Utiliza variables persistentes: error_anterior, integral.
       Se llama en cada ciclo de escaneo.
    """
    global error_anterior, integral
    
    # Error actual
    error = setpoint - proceso
    
    # Término proporcional
    P = Kp * error
    
    # Término integral (acumulación con anti-windup simple)
    integral += error * dt
    I = Ki * integral
    
    # Término derivativo (usamos diferencia finita)
    if dt > 0:
        derivada = (error - error_anterior) / dt
    else:
        derivada = 0
    D = Kd * derivada
    
    # Salida total
    salida = P + I + D
    
    # Saturación de la salida (ej. 0-100%)
    if salida > 100:
        salida = 100
        # Anti-windup: no acumular si estamos saturados
        integral -= error * dt
    elif salida < 0:
        salida = 0
        integral -= error * dt
    
    # Actualizar error anterior para el próximo ciclo
    error_anterior = error
    
    return salida

# ------------------------------------------------------------
# 3. SIMULACIÓN DE UN PROCESO SIMPLE (PLANTA)
# ------------------------------------------------------------
def simular_planta(salida_control):
    """Simula la respuesta de una planta térmica simple.
       En un PLC real, la planta sería el sistema físico.
    """
    global proceso
    # Modelo muy simple: la temperatura cambia según la salida de control
    # con una inercia y tiempo muerto
    proceso = proceso + (salida_control - proceso) * 0.05
    return proceso

# ------------------------------------------------------------
# 4. CICLO PRINCIPAL (SIMULA EL CICLO DE ESCANEO DEL PLC)
# ------------------------------------------------------------
def ciclo_principal(duracion_total=60, dt_ciclo=0.1):
    """Ejecuta el control PID durante 'duracion_total' segundos,
       con un tiempo de ciclo de 'dt_ciclo' segundos.
    """
    global tiempo_anterior, setpoint, proceso, salida
    
    print("🎛️ INICIO DE SIMULACIÓN PID")
    print("="*50)
    
    # Número de ciclos
    num_ciclos = int(duracion_total / dt_ciclo)
    
    for i in range(num_ciclos):
        # Tomar tiempo actual para cálculo de dt
        tiempo_actual = i * dt_ciclo
        
        # Calcular dt (en un PLC real, esto sería el tiempo de ciclo)
        dt = dt_ciclo
        
        # 1. Leer entradas (simulado)
        # Aquí podríamos cambiar la consigna en cierto momento
        if tiempo_actual > 20 and tiempo_actual < 40:
            setpoint = 70.0   # Cambio de consigna
        else:
            setpoint = 50.0
        
        # 2. Ejecutar PID
        salida = calcular_pid(setpoint, proceso, dt)
        
        # 3. Actualizar planta con la salida de control
        proceso = simular_planta(salida)
        
        # 4. Registrar datos para gráfica
        historial_tiempo.append(tiempo_actual)
        historial_proceso.append(proceso)
        historial_salida.append(salida)
        historial_setpoint.append(setpoint)
        
        # Mostrar cada cierto tiempo
        if i % 100 == 0:
            print(f"Tiempo: {tiempo_actual:.1f}s | SP: {setpoint:.1f} | PV: {proceso:.2f} | Salida: {salida:.2f}")
        
        # Esperar para simular el tiempo de ciclo (solo para no saturar)
        # En un PLC real no hay sleep, es continuo.
        time.sleep(dt * 0.01)  # Reducido para que la simulación sea rápida
    
    print("="*50)
    print("✅ SIMULACIÓN FINALIZADA")
    
    # Opcional: mostrar gráfica
    plt.figure(figsize=(10,5))
    plt.plot(historial_tiempo, historial_setpoint, 'r--', label='Setpoint')
    plt.plot(historial_tiempo, historial_proceso, 'b-', label='Proceso')
    plt.plot(historial_tiempo, historial_salida, 'g-', label='Salida PID')
    plt.xlabel('Tiempo (s)')
    plt.ylabel('Valor')
    plt.legend()
    plt.title('Simulación de control PID')
    plt.grid(True)
    plt.show()

# ------------------------------------------------------------
# 5. PUNTO DE ENTRADA PRINCIPAL
# ------------------------------------------------------------
if __name__ == "__main__":
    ciclo_principal(duracion_total=60, dt_ciclo=0.1)

Este código implementa un controlador PID en Python, simulando la estructura que se usaría en Texto Estructurado (ST) dentro de un PLC. Se definen variables persistentes (como la integral), se calcula la salida en cada ciclo y se actualiza la planta. Ejecútalo en Thonny para ver la evolución de las variables y la gráfica final.