El mundo analógico en la automatización industrial

Los procesos industriales son inherentemente analógicos: la temperatura de un horno, la presión en una tubería, el caudal de un fluido o la velocidad de una cinta transportadora varían de forma continua. Para que un PLC pueda supervisar y controlar estas magnitudes, es necesario convertirlas en señales eléctricas estándar (0-10V, 4-20mA) y posteriormente digitalizarlas. Este proceso, junto con el escalado lineal para obtener valores en unidades físicas, constituye la base de las operaciones analógicas.

La correcta interpretación de las señales analógicas es crítica: un error de escalado puede provocar lecturas incorrectas, falsas alarmas o incluso daños en equipos. En esta sección se aborda el tratamiento completo, desde la adquisición hasta la generación de señales de salida, incluyendo bloques de función específicos y buenas prácticas de ingeniería.

Adquisición de señales analógicas y digitalización

Un sensor o transductor convierte una magnitud física en una señal eléctrica proporcional. Las señales más comunes en entornos industriales son:

  • 0-10 V (tensión) – simple pero susceptible a caídas por distancia.
  • 4-20 mA (corriente) – más robusta, permite detectar rotura de cable (0 mA = fallo).
  • 0-20 mA – variante sin el offset de 4 mA.

El módulo de entrada analógica del PLC contiene un conversor analógico-digital (ADC) que transforma la señal en un valor entero proporcional. La resolución (número de bits) determina la precisión:

  • 12 bits → rango 04095
  • 16 bits → rango 065535
  • En PLC Siemens S7-1200, la resolución por defecto es 12 bits + signo (0-27648 para rangos unipolares).

Este valor entero (raw) es el que el programa de control recibe en la imagen de proceso de entradas (PII). Por sí solo no es útil; necesita ser escalado.

Escalado lineal: de raw a unidades físicas

La relación entre el valor digital (X) y la magnitud física (Y) suele ser lineal. La fórmula general es:

Y = Ymin + (X - Xmin) · (Ymax - Ymin) / (Xmax - Xmin)

Donde:

  • X = valor leído por el PLC (raw)
  • Xmin, Xmax = límites del rango lógico (ej. 0 y 27648)
  • Ymin, Ymax = límites del rango físico (ej. 0 y 10 bar)
  • Y = resultado escalado (presión real en bar)

Ejemplo paso a paso: Sensor de presión 4-20 mA, rango 0-10 bar. PLC Siemens con rango 0-27648 (4 mA = 5530, 20 mA = 27648). Si leemos X = 15000, ¿qué presión tenemos?

Primero: calcular el valor en mA equivalente: (15000/27648)*16 + 4 = 12.68 mA.
O directamente con la fórmula:
Y = 0 + (15000 - 5530) * (10 - 0) / (27648 - 5530) = (9470 * 10) / 22118 ≈ 4.28 bar.

En la práctica, los fabricantes proporcionan bloques que realizan este cálculo automáticamente (SCALE, NORM_X, etc.).

Escalado inverso: de unidades físicas a raw (salidas analógicas)

Para controlar actuadores analógicos (válvulas proporcionales, variadores de frecuencia) partimos de un valor físico deseado (por ejemplo, 5 bar) y necesitamos el valor raw que enviar al módulo de salida. La fórmula es la inversa:

X = Xmin + (Y - Ymin) · (Xmax - Xmin) / (Ymax - Ymin)

En TIA Portal, el bloque UNSCALE (o NORM_X + SCALE_X) realiza esta conversión. Es fundamental asegurar que el valor físico está dentro de los límites para evitar saturación.

Bloques de función en PLC: SCALE, UNSCALE, NORM_X

Los entornos de programación como TIA Portal, CODESYS o RSLogix incluyen bloques estandarizados para facilitar el escalado:

  • SCALE_X (TIA) / SCALE (CODESYS): escalado con límites configurables.
  • NORM_X: normaliza un valor a un rango 0.0-1.0 (real).
  • UNSCALE: realiza la operación inversa.

Ejemplo en FBD con SCALE_X: conectar la entrada raw (INT) al bloque, indicar los límites físicos (0.0-10.0) y obtener la salida en REAL.

Además, es común incluir filtros paso bajo (suavizado) para eliminar ruido de alta frecuencia, implementados mediante medias móviles o filtros de primer orden (PT1).

Editor FBD de TIA Portal – Network 1: bloque NORM_X con parámetros MIN=0, VALUE=MW10 (valor analógico crudo 0-27648), MAX=27648, OUT=MW12 (valor normalizado 0-1).
Figura 9a: Bloque NORM_X en TIA Portal – normaliza el valor analógico (0–27648) a rango 0–1. Fuente: PLC SCADA Academy / Licencia: Uso educativo, todos los derechos del autor.
Editor FBD de TIA Portal – Network 2: bloque SCALE_X con parámetros MIN=0, VALUE=MW12 (valor normalizado de NORM_X), MAX=100, OUT=MW14 (valor escalado 0-100).
Figura 9b: Bloque SCALE_X en TIA Portal – escala el valor normalizado (0–1) al rango físico deseado (0–100). Fuente: PLC SCADA Academy / Licencia: Uso educativo, todos los derechos del autor.

Operaciones complementarias: filtrado, limitación y corrección

Una vez escalada la señal, pueden aplicarse operaciones para mejorar la calidad y seguridad:

  • Filtro de media móvil: promedia las últimas N lecturas para reducir ruido. Útil en señales con pequeñas fluctuaciones.
  • Filtro paso bajo (PT1): implementa la ecuación Y(n) = Y(n-1) + K·(X(n) - Y(n-1)). Suavizado exponencial.
  • Limitación (CLAMP): asegura que la señal no supere valores de seguridad (ej. temperatura máxima).
  • Corrección no lineal: mediante tablas o polinomios para sensores con respuesta no lineal (termopares, caudalímetros).

Ejemplo de filtro de media móvil en ST:

// Buffer circular de 10 posiciones
IF indice < 10 THEN
    buffer[indice] := valor_raw;
    indice := indice + 1;
ELSE
    indice := 0;
END_IF;
// Calcular media
suma := 0;
FOR i := 0 TO 9 DO
    suma := suma + buffer[i];
END_FOR;
valor_filtrado := suma / 10;
🐍 Simulación de escalado analógico y filtro en Python (Raspberry Pi)
# analog_scaling.py - Lectura analógica simulada, escalado y filtrado
# Puede ejecutarse en Thonny y adaptarse a un ADC real (MCP3008, etc.)

import time
import math

class AnalogInput:
    """Simula una entrada analógica con escalado y filtro."""
    def __init__(self, raw_min=0, raw_max=27648, eng_min=0.0, eng_max=10.0, filter_size=5):
        self.raw_min = raw_min
        self.raw_max = raw_max
        self.eng_min = eng_min
        self.eng_max = eng_max
        self.filter_size = filter_size
        self.buffer = []          # buffer para media móvil
        self.raw_value = 0

    def set_raw(self, raw):
        """Actualiza el valor raw (simula lectura del ADC)."""
        self.raw_value = raw

    def scale(self, raw=None):
        """Aplica escalado lineal: raw -> ingeniería."""
        if raw is None:
            raw = self.raw_value
        # Asegurar que raw está dentro del rango
        raw = max(self.raw_min, min(self.raw_max, raw))
        # Fórmula de escalado
        eng = self.eng_min + (raw - self.raw_min) * (self.eng_max - self.eng_min) / (self.raw_max - self.raw_min)
        return eng

    def scale_inverse(self, eng):
        """Escalado inverso: ingeniería -> raw."""
        eng = max(self.eng_min, min(self.eng_max, eng))
        raw = self.raw_min + (eng - self.eng_min) * (self.raw_max - self.raw_min) / (self.eng_max - self.eng_min)
        return int(round(raw))

    def filter_add(self, raw):
        """Añade valor al buffer y devuelve media móvil."""
        self.buffer.append(raw)
        if len(self.buffer) > self.filter_size:
            self.buffer.pop(0)
        return sum(self.buffer) / len(self.buffer)

    def read_filtered_eng(self):
        """Obtiene valor raw, aplica filtro y escala."""
        raw_filt = self.filter_add(self.raw_value)
        return self.scale(raw_filt)

# --- Simulación de lectura de un sensor (p.ej., potenciómetro) ---
import random

sensor = AnalogInput(raw_min=0, raw_max=1023, eng_min=0.0, eng_max=100.0, filter_size=10)
print("Raw simulado | Escalado directo | Filtrado + escalado")
for ciclo in range(20):
    # Simulamos una señal ruidosa (raw con variación)
    raw = int(500 + 50 * math.sin(ciclo * 0.5) + random.gauss(0, 20))
    sensor.set_raw(raw)
    eng_directo = sensor.scale()
    eng_filtrado = sensor.read_filtered_eng()
    print(f"{raw:6d}      | {eng_directo:7.2f}        | {eng_filtrado:7.2f}")
    time.sleep(0.3)

# El filtrado suaviza las fluctuaciones (útil para control PID)

Este código simula una entrada analógica ruidosa, aplica escalado lineal y un filtro de media móvil. Se puede probar en Thonny y después usar con un ADC real (MCP3008) para leer sensores analógicos en Raspberry Pi.

Tendencias Actuales 2026

Los módulos analógicos modernos incorporan procesado digital integrado, permitiendo configurar el escalado y filtrado directamente en el hardware (sin consumo de CPU). Además, la comunicación vía IO-Link transmite directamente valores físicos, eliminando la necesidad de escalado en el programa. En PLC de última generación, los bloques SCALE_X aceptan rangos en unidades de ingeniería con etiquetas (por ejemplo, "°C", "bar") y ajustan automáticamente la conversión según el tipo de sensor.

Aplicaciones con Raspberry Pi

Con un conversor ADC (MCP3008, ADS1115) y Python, podemos replicar todo el proceso: leer señal analógica, escalar con la fórmula, aplicar filtros y generar salidas PWM (simulando analógicas). El código del recuadro Python es directamente usable con librerías como gpiozero o Adafruit_ADS1x15.

Aplicaciones con Arduino

En Arduino, la lectura analógica se obtiene con analogRead() (0-1023). El escalado se realiza con la función map() o con aritmética de punto flotante. Ejemplo: temperatura = map(lectura, 0, 1023, 0, 500) / 10.0;. El Arduino PLC IDE proporciona bloques gráficos para escalado y filtrado.

💼 Caso Práctico Industrial

Contexto: Un sensor de presión con salida 4-20 mA está conectado a un PLC Siemens S7-1200 (rango 0-27648). El sensor mide de 0 a 16 bar. Se lee un valor raw de 13824.

Pregunta: ¿Cuál es la presión aproximada en bar (considerando 4 mA = 5530, 20 mA = 27648)?

🍓 Raspberry Pi + ADC

Contexto: En una Raspberry Pi, se usa un MCP3008 (10 bits, 0-1023) para leer un sensor de temperatura LM35 (10 mV/°C). El LM35 entrega 0 mV a 0°C y 1000 mV a 100°C. El ADC referencia 3.3V.

Pregunta: ¿Qué fórmula de escalado convierte la lectura raw (0-1023) a grados Celsius?

🐍 Filtro paso bajo

Contexto: Se implementa un filtro paso bajo de primer orden: y[n] = y[n-1] + K * (x[n] - y[n-1]) con K=0.1. Si la entrada x da un salto de 0 a 100 en el instante n, y el valor anterior y[n-1] era 0, ¿cuál será y[n]?

Pregunta: Calcula y[n] según la fórmula.

Tabla 1: Rangos típicos en automatización
Tipo de señalRango eléctricoRango lógico (12 bits)Rango lógico (16 bits Siemens)
0-10 V0 – 10 V0 – 40950 – 27648
0-20 mA0 – 20 mA0 – 40950 – 27648
4-20 mA4 – 20 mA819 – 4095 (aprox)5530 – 27648

📚 Recursos Técnicos y Normativos 2026

Normativas y Estándares

Recursos Raspberry Pi y Python