3.1. Conceptos de hardware: CPU, módulos de E/S y módulos especiales

# ------------------------------------------------
# Simulación del ciclo de escaneo de un PLC
# ------------------------------------------------

# --- Definición de variables de entrada (simuladas) ---
# Inicialmente, suponemos que un sensor de presencia (entrada digital) está activo (1)
sensor_presencia = 1   # 1 = objeto detectado, 0 = no detectado

# Un sensor de temperatura (entrada analógica) nos da un valor de 350 grados
temperatura_actual = 350   # en grados Celsius (simulado)

# --- Definición de variables internas del programa ---
# Estas variables almacenan estados intermedios (como "marcas" internas en un PLC)
proceso_activo = False     # Indica si el proceso principal está en marcha
contador_piezas = 0        # Contador de piezas procesadas

# --- Definición de variables de salida ---
# Inicialmente, todas las salidas están apagadas (0)
motor_cinta = 0            # Salida digital que activa la cinta transportadora
valvula_calentador = 0     # Salida analógica (0-100%) para el calentador

# --- CICLO PRINCIPAL DEL PROGRAMA (simula el escaneo continuo de un PLC) ---
# En un PLC real, este ciclo se ejecuta indefinidamente mientras el autómata está en RUN.

for ciclo in range(1, 6):  # Simulamos 5 ciclos de escaneo
    print(f"\n--- CICLO DE ESCANEO NÚMERO {ciclo} ---")

    # ------------------------------------------------
    # 1. LECTURA DE ENTRADAS (Input Scan)
    # ------------------------------------------------
    # En un PLC real, aquí se actualizan las imágenes de las entradas.
    # En nuestra simulación, leemos las variables que representan los sensores.
    print("🔍 Leyendo entradas.")
    print(f"   - Sensor de presencia: {sensor_presencia} (1=detectado)")
    print(f"   - Temperatura actual: {temperatura_actual} °C")

    # ------------------------------------------------
    # 2. EJECUCIÓN DEL PROGRAMA DE USUARIO (Program Scan)
    # ------------------------------------------------
    # Aquí implementamos la lógica de control, similar a un programa en ladder o texto estructurado.

    print("⚙️ Ejecutando lógica de control.")

    # Lógica para la cinta transportadora (basada en el sensor de presencia)
    if sensor_presencia == 1:
        motor_cinta = 1   # Activar cinta si hay una pieza
        print("   - Se detecta pieza: ACTIVANDO motor de cinta.")
    else:
        motor_cinta = 0   # Detener cinta si no hay pieza
        print("   - No se detecta pieza: DETENIENDO motor de cinta.")

    # Lógica para el control de temperatura (simula un lazo PID simple)
    TEMPERATURA_CONSIGNA = 300   # Temperatura deseada en grados
    if temperatura_actual < TEMPERATURA_CONSIGNA:
        # Si la temperatura es inferior a la consigna, aumentamos la salida analógica
        valvula_calentador = 80   # Abrimos la válvula al 80%
        print(f"   - Temp. {temperatura_actual}°C < consigna {TEMPERATURA_CONSIGNA}°C. Aumentando calefacción al {valvula_calentador}%.")
    elif temperatura_actual > TEMPERATURA_CONSIGNA + 20:
        # Si la temperatura supera la consigna + 20, reducimos
        valvula_calentador = 30
        print(f"   - Temp. {temperatura_actual}°C > consigna+20. Reduciendo calefacción al {valvula_calentador}%.")
    else:
        # En un rango cercano, mantenemos un valor medio
        valvula_calentador = 50
        print(f"   - Temp. en rango. Manteniendo calefacción al {valvula_calentador}%.")

    # Lógica de contador de piezas
    if sensor_presencia == 1 and motor_cinta == 1:
        # Simulamos que cada ciclo con sensor activo cuenta como una pieza procesada
        contador_piezas += 1
        print(f"   - Pieza contabilizada. Total piezas: {contador_piezas}")

    # ------------------------------------------------
    # 3. ACTUALIZACIÓN DE SALIDAS (Output Scan)
    # ------------------------------------------------
    # En un PLC real, aquí se escriben los valores calculados en las salidas físicas.
    print("🔧 Actualizando salidas.")
    print(f"   - Estado del motor de cinta: {'ACTIVADO' if motor_cinta else 'DETENIDO'}")
    print(f"   - Apertura de válvula calentador: {valvula_calentador}%")

    # ------------------------------------------------
    # 4. SIMULACIÓN DE CAMBIO EN LAS ENTRADAS (para ver evolución)
    # ------------------------------------------------
    # En un PLC real, las entradas cambian por el entorno. Aquí las modificamos para ver la evolución.
    if ciclo == 2:
        sensor_presencia = 0   # La pieza se retira
        print("   (Simulación: sensor de presencia se desactiva)")
    elif ciclo == 3:
        sensor_presencia = 1   # Llega una nueva pieza
        temperatura_actual = 280   # La temperatura ha bajado
        print("   (Simulación: nueva pieza detectada, temperatura ha bajado)")
    elif ciclo == 4:
        temperatura_actual = 330   # La temperatura sube
        print("   (Simulación: temperatura aumenta)")
    elif ciclo == 5:
        sensor_presencia = 0
        print("   (Simulación: última pieza, sensor desactivado)")

# ------------------------------------------------
# 5. FIN DE LA SIMULACIÓN
# ------------------------------------------------
print("\n--- SIMULACIÓN FINALIZADA ---")
print(f"Resumen: Se procesaron un total de {contador_piezas} piezas.")

Este código simula los ciclos de escaneo de un PLC: lectura de entradas (sensor de presencia, temperatura), ejecución de la lógica de control (cinta, temperatura, contador) y actualización de salidas. Las variables cambian para mostrar la evolución del proceso. Se puede probar en Thonny y entender el flujo típico de un autómata.