3.2. Características técnicas de los autómatas programables. Aplicaciones.

# ============================================================
# SIMULACIÓN DE UN PLC (AUTÓMATA PROGRAMABLE) EN PYTHON
# ============================================================
# Este programa simula el comportamiento básico de un PLC:
# - Lee entradas virtuales (desde teclado o variables internas)
# - Ejecuta un programa de usuario (lógica de control)
# - Actualiza salidas virtuales (mostradas en pantalla)
# - Mide el tiempo de ciclo para entender la velocidad de procesamiento
#
# Se puede ejecutar en Thonny y adaptar fácilmente a Raspberry Pi
# usando GPIO en lugar de entradas por teclado.
# ============================================================

import time
import random

# ------------------------------------------------------------
# 1. DEFINICIÓN DE VARIABLES (SIMULAN MEMORIA DEL PLC)
# ------------------------------------------------------------
# Entradas digitales virtuales (simulan sensores)
# Inicialmente todas a False (0)
entradas = {
    'sensor_pieza': False,   # Sensor de presencia (True = pieza detectada)
    'paro_emergencia': False, # Botón de paro de emergencia (True = activado)
    'fin_carrera': False,     # Final de carrera (True = cilindro extendido)
}

# Salidas digitales virtuales (simulan actuadores)
salidas = {
    'motor_cinta': False,     # Motor de la cinta transportadora
    'cilindro': False,        # Cilindro neumático
    'luz_alarma': False,      # Luz de alarma
}

# Variables internas del programa (memoria de datos)
contador_piezas = 0           # Cuenta las piezas procesadas
tiempo_inicio_ciclo = 0       # Para medir tiempo de ciclo
tiempo_ciclo_total = 0        # Acumulador para estadísticas

# ------------------------------------------------------------
# 2. PROGRAMA DE USUARIO (LÓGICA DE CONTROL)
# ------------------------------------------------------------
def ejecutar_programa_plc():
    """Esta función se ejecuta en cada ciclo de escaneo.
       Simula el programa en ladder o texto estructurado.
       Usa las variables globales 'entradas' y 'salidas'.
    """
    global contador_piezas
    
    # --- Lógica 1: Paro de emergencia (prioridad máxima) ---
    if entradas['paro_emergencia']:
        # Si hay paro de emergencia, detener todo inmediatamente
        salidas['motor_cinta'] = False
        salidas['cilindro'] = False
        salidas['luz_alarma'] = True   # Encender alarma
        print("🚨 ¡PARO DE EMERGENCIA ACTIVADO! Todas las salidas desactivadas.")
        return  # Salimos de la función (no ejecutar más lógica en este ciclo)
    
    # --- Lógica 2: Control de la cinta transportadora ---
    # Si hay pieza detectada, arrancar motor; si no, parar
    if entradas['sensor_pieza']:
        salidas['motor_cinta'] = True
    else:
        salidas['motor_cinta'] = False
    
    # --- Lógica 3: Secuencia del cilindro ---
    # Cuando la cinta está en marcha y hay pieza, activar cilindro
    if salidas['motor_cinta'] and entradas['sensor_pieza'] and not entradas['fin_carrera']:
        salidas['cilindro'] = True   # Avanza el cilindro
    elif entradas['fin_carrera']:
        salidas['cilindro'] = False  # Retrocede el cilindro (final de carrera)
        # Cuando el cilindro retrocede, contamos una pieza procesada
        contador_piezas += 1
        print(f"🔢 Pieza procesada. Total: {contador_piezas}")
    
    # --- Lógica 4: Apagar alarma si no hay emergencia ---
    salidas['luz_alarma'] = False

# ------------------------------------------------------------
# 3. FUNCIÓN PARA SIMULAR LA LECTURA DE ENTRADAS
# ------------------------------------------------------------
def leer_entradas():
    """En un PLC real, esto leería del hardware.
       Aquí simulamos con entrada del usuario o valores aleatorios.
    """
    print("\n--- Nuevo ciclo de escaneo ---")
    # Simulamos un sensor de pieza que se activa aleatoriamente
    entradas['sensor_pieza'] = random.choice([True, False])
    
    # Para probar, también permitimos entrada manual (descomentar la siguiente línea)
    # entradas['sensor_pieza'] = input("¿Pieza detectada? (s/n): ").lower() == 's'
    
    # Simulamos un paro de emergencia aleatorio (raro)
    entradas['paro_emergencia'] = random.random() < 0.05  # 5% de probabilidad
    
    # Simulamos final de carrera (se activa cuando el cilindro está avanzado)
    # En un PLC real, esto sería una entrada física. Aquí lo simulamos
    # basándonos en la salida del cilindro (realimentación virtual)
    entradas['fin_carrera'] = salidas['cilindro']  # Cuando el cilindro está True, se activa el final de carrera
    
    print(f"Entradas: sensor_pieza={entradas['sensor_pieza']}, paro_emergencia={entradas['paro_emergencia']}")

# ------------------------------------------------------------
# 4. FUNCIÓN PARA ACTUALIZAR SALIDAS (SIMULACIÓN)
# ------------------------------------------------------------
def actualizar_salidas():
    """Muestra el estado de las salidas en pantalla."""
    print("Salidas actualizadas:")
    for nombre, estado in salidas.items():
        print(f"  {nombre}: {'🟢 ON' if estado else '🔴 OFF'}")
    print(f"Contador de piezas: {contador_piezas}")

# ------------------------------------------------------------
# 5. CICLO PRINCIPAL (SIMULA EL CICLO DE ESCANEO DEL PLC)
# ------------------------------------------------------------
def ciclo_principal():
    global tiempo_inicio_ciclo, tiempo_ciclo_total
    num_ciclos = 10  # Ejecutaremos 10 ciclos para ver el comportamiento
    
    for ciclo in range(1, num_ciclos + 1):
        # Tomamos el tiempo al inicio del ciclo
        inicio = time.time()
        
        print(f"\n=== CICLO {ciclo} ===")
        
        # 1. Leer entradas
        leer_entradas()
        
        # 2. Ejecutar programa de usuario
        ejecutar_programa_plc()
        
        # 3. Actualizar salidas
        actualizar_salidas()
        
        # 4. Esperar un poco para no saturar la consola (simula tiempo de ciclo)
        # En un PLC real, el ciclo es continuo sin esperas.
        time.sleep(0.5)
        
        # Calcular duración del ciclo
        fin = time.time()
        duracion_ms = (fin - inicio) * 1000
        print(f"⏱️ Duración del ciclo: {duracion_ms:.2f} ms")
        tiempo_ciclo_total += duracion_ms
    
    print(f"\n📊 Duración media del ciclo: {tiempo_ciclo_total/num_ciclos:.2f} ms")

# ------------------------------------------------------------
# 6. PUNTO DE ENTRADA PRINCIPAL
# ------------------------------------------------------------
if __name__ == "__main__":
    print("🎛️ SIMULADOR DE PLC EN PYTHON")
    print("=" * 40)
    ciclo_principal()
    print("\n✅ Simulación finalizada. Observa cómo cambian las variables.")
    print("Puedes modificar el código para añadir más entradas/salidas o lógica.")

Este código simula un PLC con un ciclo de escaneo. Las variables `entradas` y `salidas` son diccionarios que representan la memoria. La función `ejecutar_programa_plc()` contiene la lógica de control (como un programa en ladder). Se mide el tiempo de cada ciclo. Ejecútalo en Thonny y observa cómo cambian las variables en cada ciclo.