Fundamentos de la carga y transferencia de datos

En los sistemas de automatización industrial, la carga y transferencia de datos constituye la columna vertebral que permite mover información entre los diferentes elementos del controlador: desde la lectura de sensores hasta la escritura en actuadores, pasando por el procesamiento interno y la comunicación con dispositivos externos (HMI, variadores, SCADA). La correcta gestión de estos flujos asegura la coherencia del proceso y la fiabilidad del sistema.

Las operaciones de transferencia se ejecutan en cada ciclo de scan del PLC. Comienzan con la actualización de la imagen de proceso de entradas (PII), luego el programa transfiere datos entre registros, marcas y bloques de datos, y finalmente se actualiza la imagen de proceso de salidas (PIQ). Este flujo garantiza que todas las operaciones trabajen con un estado consistente durante el ciclo.

Ejemplo industrial: en una máquina de inyección de plástico, un sensor analógico de presión (0‑10 V) se lee en el módulo de entrada (dirección IW0). Mediante una instrucción MOV se copia ese valor a una variable interna (MD10) donde se aplica un escalado. Posteriormente, el resultado se transfiere a la salida analógica (QW0) que controla la apertura de la válvula proporcional. Todo ello ocurre en milisegundos.

Instrucciones básicas para mover datos

Los lenguajes de programación estandarizados por la IEC 61131-3 ofrecen diversas instrucciones de transferencia. Las más comunes son:

  • MOV Move: copia el contenido de un operando origen a un destino. Soporta bits, bytes, palabras (16 bits), dobles palabras (32 bits) y números reales. Ejemplo en ST: MW10 := 100; o en IL: LD 100 ST MW10.
  • LD / ST (Load / Store): típicas de la programación en Lista de Instrucciones (IL). LD carga un valor en el acumulador, ST lo almacena en una dirección.
  • SWAP (o XCHG): intercambia los valores de dos operandos. Útil para ordenar datos o implementar algoritmos de intercambio rápido.
  • BLKMOV (Block Move) / COP (Copy): transfiere bloques contiguos de datos (arrays, estructuras) de una zona a otra. Por ejemplo, copiar una receta de 10 valores desde DB1[0] a DB2[0].

Ejemplo adicional: en un sistema de control de temperatura, se desea inicializar un conjunto de consignas almacenadas en un array. Con BLKMOV podemos copiar los valores desde una constante (tabla en memoria de programa) al bloque de datos de trabajo en una sola operación, ahorrando tiempo de ciclo.

Áreas de memoria y registros

La arquitectura de memoria de un PLC define las zonas donde se almacenan y transfieren los datos:

  • Entradas y salidas (I/Q): reflejan el estado físico de los sensores y actuadores. Solo se puede leer de entradas y escribir en salidas.
  • Marcas (M) / Flags: memoria interna de uso general, accesible en bit, byte, palabra o doble palabra (MB, MW, MD).
  • Bloques de datos (DB): áreas estructuradas que pueden contener variables de distintos tipos. Son retentivas o no según configuración.
  • Acumuladores (ACCU): registros internos de la CPU donde se realizan las operaciones aritméticas y lógicas. Las instrucciones de transferencia suelen usar el acumulador como puente.

Dato técnico: en la familia Siemens S7-1500, los accesos a memoria pueden realizarse de forma directa (por ejemplo, %IW0) o simbólica ("Sensor_presion"). Las instrucciones de transferencia manejan ambos modos.

Estructuración de la transferencia

La organización de los movimientos de datos depende del tipo y volumen de información:

  • Transferencias simples (bit/word): se realizan con MOV o asignaciones directas. Ejemplo: Q0.0 := I0.0 AND M0.0; (en ST).
  • Transferencias de bloques: para arrays o estructuras se emplean instrucciones como BLKMOV o COP. En CODESYS, la función MemCpy (de la librería Standard) permite copiar cualquier bloque de memoria.
  • Transferencias condicionales: solo se ejecutan si se cumple una condición (por ejemplo, un flanco). Así se evitan escrituras innecesarias y se optimiza el ciclo.

Además, es habitual encapsular la lógica de transferencia en bloques funcionales (FB) o funciones (FC). Por ejemplo, un FB que cada vez que recibe una petición copia una receta desde una base de datos a las variables de trabajo, gestionando también la confirmación.

Transferencia con dispositivos externos

El PLC no trabaja aislado; a menudo debe intercambiar datos con paneles HMI, variadores de frecuencia, sensores inteligentes o sistemas SCADA a través de buses de campo (Profinet, Modbus TCP, EtherNet/IP, Profibus). En estos casos:

  • Se definen áreas de memoria compartida (por ejemplo, un bloque de datos mapeado como “imagen de proceso”).
  • El programa del PLC utiliza instrucciones de transferencia para leer/escribir en esas áreas; el sistema de comunicación se encarga de sincronizarlas con el dispositivo externo.
  • Para grandes volúmenes de datos (por ejemplo, cargar una receta desde un servidor), se emplean bloques de función de comunicación específicos (como TCON, TSEND, TRCV en Siemens) que internamente realizan transferencias de datos.

Ejemplo real: un variador de frecuencia conectado por Modbus RTU. El PLC escribe la consigna de velocidad (un entero de 16 bits) en un registro holding del variador mediante una función Modbus. Para ello, el programa mueve el valor de una variable interna (por ejemplo, MW20) a un buffer de comunicación y luego activa el envío.

Esquema de la estructura de memoria de un PLC con áreas de entrada, salida, marcas y bloques de datos. Flechas indican transferencias mediante MOV (simple) y BLKMOV (bloque), así como comunicación con un panel HMI vía bus de campo.
Figura 6: Organización de la memoria y operaciones de transferencia típicas en un PLC. Fuente: tecnoplc.com / Licencia: © tecnoplc.com — uso educativo (verificar permiso)

Consideraciones importantes

Para garantizar la fiabilidad y mantenibilidad del sistema, se deben tener en cuenta:

  • Coherencia y sincronización: cuando se transfieren bloques de datos grandes, es posible que el destino se actualice durante varios ciclos. Se recomienda usar mecanismos de consistencia (por ejemplo, doble buffer o semáforos) si otras partes del programa acceden a esos datos.
  • Tipo y formato de datos: evitar conversiones implícitas no deseadas. En lenguajes textuales como ST, asignar un entero a un booleano puede generar error o truncamiento. Usar funciones de conversión (INT_TO_REAL, WORD_TO_BOOL, etc.).
  • Gestión de errores: en transferencias con dispositivos externos, implementar timeouts y reintentos. En internas, verificar que los índices de arrays no estén fuera de rango.
  • Nomenclatura clara: usar nombres simbólicos que reflejen la función (por ejemplo, "Consigna_Velocidad" en lugar de MW20) facilita la comprensión y reduce errores.

Consejo práctico: documentar cada transferencia significativa con comentarios que indiquen origen, destino, tipo de dato y propósito. Esto es vital durante el mantenimiento futuro.

🐍 Simulación de transferencia de datos estilo PLC en Python (con áreas de memoria y MOV/BLKMOV)
# plc_transfer_sim.py - Simula memoria de PLC y operaciones de transferencia
# Se puede probar en Thonny y adaptar para leer/escribir en GPIO o en archivos.

class PLCMemory:
    """Representa la memoria de un PLC: entradas, salidas, marcas y bloques de datos."""
    def __init__(self):
        self.inputs = {'I0.0': False, 'IW0': 0}          # entradas digitales/analógicas
        self.outputs = {'Q0.0': False, 'QW0': 0}
        self.marks = {'M0.0': False, 'MB0': 0, 'MW10': 0, 'MD20': 0.0}
        self.data_blocks = {'DB1': [0]*10, 'DB2': [0]*10}   # bloques de datos como listas

    def mov(self, src, dst):
        """Simula MOV: copia src a dst (soporta constantes, variables o elementos de DB)."""
        # Obtener valor origen
        if isinstance(src, (int, float, bool)):
            val = src
        elif isinstance(src, str):
            val = self._get(src)
        else:
            raise TypeError("Origen no soportado")
        # Escribir en destino
        self._set(dst, val)
        print(f"MOV {src} -> {dst}  (valor={val})")

    def blkmov(self, src_block, src_start, dst_block, dst_start, count):
        """Copia count elementos de src_block a dst_block (listas)."""
        src = self.data_blocks[src_block]
        dst = self.data_blocks[dst_block]
        for i in range(count):
            dst[dst_start + i] = src[src_start + i]
        print(f"BLKMOV {count} elem: {src_block}[{src_start}] -> {dst_block}[{dst_start}]")

    def swap(self, var1, var2):
        """Intercambia los valores de dos variables."""
        v1 = self._get(var1)
        v2 = self._get(var2)
        self._set(var1, v2)
        self._set(var2, v1)
        print(f"SWAP {var1} <-> {var2}")

    def _get(self, name):
        # Búsqueda en entradas, salidas, marcas y data_blocks (notación DB1[2])
        if name in self.inputs:
            return self.inputs[name]
        if name in self.outputs:
            return self.outputs[name]
        if name in self.marks:
            return self.marks[name]
        if name.startswith('DB') and '[' in name and ']' in name:
            db, idx = name.split('[')
            idx = int(idx.strip(']'))
            return self.data_blocks[db][idx]
        raise KeyError(f"Variable {name} no encontrada")

    def _set(self, name, value):
        if name in self.outputs:
            self.outputs[name] = value
        elif name in self.marks:
            self.marks[name] = value
        elif name.startswith('DB') and '[' in name:
            db, idx = name.split('[')
            idx = int(idx.strip(']'))
            self.data_blocks[db][idx] = value
        else:
            print(f"Advertencia: {name} no es escribible, se ignora")

# --- Simulación de un ciclo de programa ---
plc = PLCMemory()

# 1. Leer entrada analógica (simulada) y transferir a marca MW10
plc.inputs['IW0'] = 1234
plc.mov('IW0', 'MW10')                # MOV IW0, MW10

# 2. Copiar constante de consigna a DB1[0]
plc.mov(350, 'DB1[0]')

# 3. Transferir bloque de receta desde DB1 (posiciones 0-2) a DB2 (posiciones 3-5)
plc.blkmov('DB1', 0, 'DB2', 3, 3)

# 4. Intercambiar valores de MW10 y DB1[1] (supongamos que DB1[1] tenía otro valor)
plc.data_blocks['DB1'][1] = 5678
plc.swap('MW10', 'DB1[1]')

# Mostrar estado final
print("\n--- Estado final ---")
print("MW10 =", plc.marks['MW10'])
print("DB1 =", plc.data_blocks['DB1'])
print("DB2 =", plc.data_blocks['DB2'])

Este código simúa las operaciones MOV, BLKMOV y SWAP sobre una memoria de PLC ficticia. Se puede ejecutar en Thonny para entender el flujo de transferencia y después adaptarlo para interactuar con GPIO de Raspberry Pi (leyendo entradas y escribiendo salidas).

Tendencias Actuales 2026

Los PLC más recientes incorporan instrucciones de transferencia optimizadas para trabajar con datos estructurados (STRUCT, ARRAY) y con comunicación OPC UA integrada. La nueva versión de la IEC 61131-3 (edición 4) estandariza los bloques de transferencia para manejo de strings de longitud variable y datos de diagnóstico. Además, los entornos de desarrollo permiten la generación automática de código de transferencia a partir de conexiones gráficas entre bloques de datos.

Aplicaciones con Raspberry Pi

En una Raspberry Pi, podemos implementar un pequeño PLC soft utilizando Python y librerías como python‑snap7 para comunicarnos con PLC Siemens reales, o bien simular nuestra propia memoria. Las operaciones de transferencia se convierten en simples asignaciones o en el uso de copy.deepcopy para listas. Además, para comunicaciones externas, se pueden usar librerías Modbus (pymodbus) que internamente transfieren datos entre el bus y variables Python.

Aplicaciones con Arduino

En el entorno Arduino PLC IDE, las instrucciones de transferencia están disponibles como bloques gráficos (MOVE, COPY) o en texto estructurado. Por ejemplo, %MW10 := %IW0; para copiar una entrada analógica a una marca. En Arduino estándar, la transferencia se realiza mediante asignaciones: int valor = analogRead(A0);.

💼 Caso Práctico Industrial

Contexto: En una línea de envasado, se utiliza un sensor de nivel analógico conectado a la entrada IW0. El valor leído (0‑27648) debe transferirse a la variable interna Nivel_Actual (MD10) para ser usado en el control. Además, una consigna de nivel deseado está almacenada en DB_Receta.Nivel_Objetivo (DB1.DBW0). Se desea que, al activarse una marca M0.0, se copie la consigna a la variable Consigna_Trabajo (MW20).

Pregunta: ¿Qué instrucciones de transferencia serían las más adecuadas para implementar estas operaciones?

🍓 Raspberry Pi + Python

Contexto: En una Raspberry Pi con Python, se tiene un sensor de distancia conectado a un GPIO analógico (via ADS1115) que proporciona un valor entero. Se desea almacenar ese valor en una variable dist_cm y también copiarlo a una lista historial que guarda las últimas 10 lecturas. Se implementa un bucle que cada segundo lee el sensor.

Pregunta: ¿Qué método de transferencia (copia) es el adecuado para asegurar que el historial contenga valores independientes y no referencias al mismo objeto?

🐍 Compatibilidad de tipos

Contexto: En un PLC, se tiene una variable de tipo REAL (32 bits) que almacena una temperatura (por ejemplo, 23.5). Se desea transferir ese valor a una variable de tipo INT (entero de 16 bits) mediante una instrucción MOV. En muchos PLC, esto provocaría una conversión implícita (truncamiento). En Python, hacemos temp_int = int(temp_real).

Pregunta: ¿Qué valor tendrá temp_int si temp_real = 23.5?

Tabla 1: Comparativa de instrucciones de transferencia en diferentes familias de PLC
InstrucciónSiemens S7 (TIA)Rockwell (RSLogix)CODESYSDescripción
MOVMOVEMOVMOVECopia valor origen a destino
BLKMOVBLKMOVCOPMemCpy (librería)Copia bloque de memoria
SWAPSWAPSWPSWAPIntercambia dos operandos
LD/STL TLSTLD STCarga y almacena (IL)

📚 Recursos Técnicos y Normativos 2026

Normativas y Estándares

Recursos Raspberry Pi y Python