3.3. Interconexión con los elementos de campo. Buses de comunicaciones.

# ============================================================
# SIMULACIÓN DE UNA RED MODBUS (MAESTRO-ESCLAVO) EN PYTHON
# ============================================================
# Este programa simula la comunicación entre un maestro (PLC)
# y varios esclavos (dispositivos de campo) usando el protocolo
# Modbus RTU. Cada esclavo tiene una dirección única y registros
# internos que el maestro puede leer o escribir.
#
# Se puede ejecutar en Thonny y entender el flujo de mensajes.
# Para una implementación real, se usarían librerías como 'pymodbus'.
# ============================================================

import time
import random

# ------------------------------------------------------------
# 1. DEFINICIÓN DE LA CLASE 'DISPOSITIVO_ESCLAVO'
# ------------------------------------------------------------
class DispositivoEsclavo:
    """Simula un dispositivo de campo (sensor/actuador) con dirección Modbus.
       Cada esclavo tiene:
       - Una dirección única (1-247)
       - Registros internos (holding registers) de 16 bits (simulados como enteros)
    """
    def __init__(self, direccion, nombre):
        self.direccion = direccion      # Dirección Modbus (ID del esclavo)
        self.nombre = nombre            # Nombre descriptivo (ej. 'Sensor Temp')
        # Inicializamos algunos registros de ejemplo
        self.registros = {
            0: 25,      # Registro 0: temperatura actual (°C)
            1: 50,      # Registro 1: humedad (%)
            2: 0,       # Registro 2: estado del actuador (0=OFF, 1=ON)
            3: 100,     # Registro 3: consigna de temperatura
        }
        print(f"   [Esclavo creado] Dir:{direccion} - {nombre}")

    def leer_registro(self, direccion_registro):
        """Simula la lectura de un registro (respuesta a petición Modbus)."""
        if direccion_registro in self.registros:
            valor = self.registros[direccion_registro]
            print(f"      📤 Esclavo {self.direccion} envía: registro {direccion_registro} = {valor}")
            return valor
        else:
            print(f"      ⚠️ Esclavo {self.direccion} error: registro {direccion_registro} no existe")
            return None

    def escribir_registro(self, direccion_registro, valor):
        """Simula la escritura de un registro (petición de escritura Modbus)."""
        if direccion_registro in self.registros:
            viejo_valor = self.registros[direccion_registro]
            self.registros[direccion_registro] = valor
            print(f"      📥 Esclavo {self.direccion} escribe: registro {direccion_registro} = {valor} (antes {viejo_valor})")
            return True
        else:
            print(f"      ⚠️ Esclavo {self.direccion} error: registro {direccion_registro} no existe")
            return False

# ------------------------------------------------------------
# 2. DEFINICIÓN DE LA CLASE 'MAESTRO_MODBUS'
# ------------------------------------------------------------
class MaestroModbus:
    """Simula un maestro Modbus (por ejemplo, un PLC) que puede
       enviar peticiones de lectura/escritura a los esclavos.
    """
    def __init__(self):
        self.esclavos = {}      # Diccionario de esclavos indexados por dirección
        print("🎛️ Maestro Modbus inicializado.")

    def agregar_esclavo(self, esclavo):
        """Añade un esclavo a la red."""
        self.esclavos[esclavo.direccion] = esclavo
        print(f"   + Esclavo {esclavo.direccion} añadido a la red.")

    def leer_holding_register(self, dir_esclavo, dir_registro):
        """Simula una petición de lectura Modbus (función 03)."""
        print(f"\n🔍 Maestro solicita lectura: esclavo {dir_esclavo}, registro {dir_registro}")
        if dir_esclavo in self.esclavos:
            esclavo = self.esclavos[dir_esclavo]
            valor = esclavo.leer_registro(dir_registro)
            if valor is not None:
                print(f"   ✅ Lectura completada: valor = {valor}")
                return valor
            else:
                print(f"   ❌ Error de lectura: registro no válido")
                return None
        else:
            print(f"   ❌ Error: esclavo {dir_esclavo} no encontrado en la red.")
            return None

    def escribir_holding_register(self, dir_esclavo, dir_registro, valor):
        """Simula una petición de escritura Modbus (función 06)."""
        print(f"\n✍️ Maestro solicita escritura: esclavo {dir_esclavo}, registro {dir_registro} = {valor}")
        if dir_esclavo in self.esclavos:
            esclavo = self.esclavos[dir_esclavo]
            exito = esclavo.escribir_registro(dir_registro, valor)
            if exito:
                print(f"   ✅ Escritura completada.")
            else:
                print(f"   ❌ Error de escritura.")
            return exito
        else:
            print(f"   ❌ Error: esclavo {dir_esclavo} no encontrado.")
            return False

# ------------------------------------------------------------
# 3. SIMULACIÓN DE UNA RED CON VARIOS DISPOSITIVOS
# ------------------------------------------------------------
def simulacion_red_modbus():
    print("=" * 60)
    print("INICIO DE SIMULACIÓN DE RED MODBUS")
    print("=" * 60)

    # 1. Crear el maestro (PLC)
    plc = MaestroModbus()

    # 2. Crear y añadir esclavos (dispositivos de campo)
    sensor_temp = DispositivoEsclavo(1, "Sensor de temperatura")
    sensor_humedad = DispositivoEsclavo(2, "Sensor de humedad")
    actuador_valvula = DispositivoEsclavo(3, "Válvula de control")

    plc.agregar_esclavo(sensor_temp)
    plc.agregar_esclavo(sensor_humedad)
    plc.agregar_esclavo(actuador_valvula)

    print("\n" + "-" * 40)
    print("CICLO DE COMUNICACIÓN 1: Lecturas")
    print("-" * 40)

    # El maestro lee la temperatura del esclavo 1, registro 0
    temp = plc.leer_holding_register(1, 0)
    # El maestro lee la humedad del esclavo 2, registro 1
    hum = plc.leer_holding_register(2, 1)

    print("\n" + "-" * 40)
    print("CICLO DE COMUNICACIÓN 2: Escrituras (control)")
    print("-" * 40)

    # El maestro escribe una nueva consigna de temperatura en esclavo 1, registro 3
    plc.escribir_holding_register(1, 3, 110)  # Nueva consigna: 110°C
    # El maestro activa la válvula (esclavo 3, registro 2 = 1)
    plc.escribir_holding_register(3, 2, 1)    # Abrir válvula

    print("\n" + "-" * 40)
    print("CICLO DE COMUNICACIÓN 3: Verificaciones")
    print("-" * 40)

    # Leemos de nuevo para confirmar cambios
    plc.leer_holding_register(1, 3)  # Debería ser 110
    plc.leer_holding_register(3, 2)  # Debería ser 1

    print("\n" + "=" * 60)
    print("FIN DE SIMULACIÓN")
    print("=" * 60)

# ------------------------------------------------------------
# 4. PUNTO DE ENTRADA PRINCIPAL
# ------------------------------------------------------------
if __name__ == "__main__":
    simulacion_red_modbus()

Este código simula una red Modbus con un maestro (PLC) y tres esclavos (sensores/actuadores). Se definen las clases para el maestro y los esclavos, y se simulan peticiones de lectura y escritura. Al ejecutarlo en Thonny, se verán los mensajes de comunicación y cómo cambian los registros internos. Es una base para entender el funcionamiento de un bus de campo con protocolo maestro-esclavo.