SCL (texto estructurado)

SCL (Structured Control Language) es el lenguaje de texto de Siemens. En la norma IEC 61131-3 se llama ST (Structured Text, texto estructurado). Se parece a lenguajes de programación como Pascal y es ideal para lo que en KOP resulta incómodo: cálculos, comparaciones encadenadas, recorrer listas de datos o programar una secuencia con muchos pasos. Un buen programador de PLC usa KOP para la lógica de señales que el técnico de planta debe poder seguir, y SCL para los cálculos y las secuencias complejas.

Lo básico: asignaciones y expresiones

Cada instrucción termina en punto y coma, y la asignación se escribe con :=. Las variables globales van entre comillas y las locales del bloque llevan almohadilla:

"Motor_Cinta" := "Marcha" AND NOT "Paro_Pulsado";
#Media := (#Valor1 + #Valor2) / 2.0;
// Esto es un comentario de una línea
(* Y esto un comentario de varias líneas *)

• Operadores lógicos: AND, OR, XOR, NOT.
• Comparaciones: =, <>, <, >, <=, >=. Ojo: la comparación es = y la asignación es :=.
• Aritmética: +, -, *, /, MOD (resto) y ** (potencia).

IF: decisiones

IF #Temperatura > 80.0 THEN
    "Ventilador" := TRUE;
ELSIF #Temperatura < 70.0 THEN
    "Ventilador" := FALSE;
END_IF;

Este ejemplo es una histéresis: el ventilador arranca por encima de 80 °C y no para hasta bajar de 70 °C. Entre 70 y 80 °C no se ejecuta ninguna rama y el ventilador mantiene su estado. Así se evita que arranque y pare continuamente cuando la temperatura ronda un único valor.

CASE: secuencias por pasos

CASE elige un bloque de instrucciones según el valor de una variable entera. Es la forma más clara de programar una secuencia en SCL: cada paso es un número, y cada paso tiene sus acciones y su condición para avanzar.

CASE #Paso OF
    0:  // Reposo
        IF "Marcha" AND "Pinza_Abierta" THEN
            #Paso := 10;
        END_IF;
    10: // Bajar la pinza
        "Pinza_Bajar" := TRUE;
        IF "Pinza_Abajo" THEN
            #Paso := 20;
        END_IF;
    20: // Cerrar la pinza
        "Pinza_Cerrar" := TRUE;
        IF "Pinza_Cerrada" THEN
            #Paso := 30;
        END_IF;
    ELSE
        #Paso := 0;
END_CASE;

En cada ciclo solo se ejecuta el paso actual. Mientras la pinza no llega abajo, el programa entra en el paso 10, comprueba el sensor y sale, y el resto del programa sigue funcionando. Numerar de 10 en 10 deja hueco para añadir pasos intermedios sin renumerar todo.

Bucles: FOR, WHILE y REPEAT

// Buscar el valor máximo de un array de 10 temperaturas
#Maximo := #Temperaturas[0];
FOR #i := 1 TO 9 DO
    IF #Temperaturas[#i] > #Maximo THEN
        #Maximo := #Temperaturas[#i];
    END_IF;
END_FOR;

Los bucles sirven para recorrer datos que ya están en memoria, como un array, y terminan en el mismo ciclo. Nunca se usan para esperar a que cambie una entrada: dentro del bucle las entradas no se actualizan, el ciclo se alarga y el PLC acaba en STOP por superar el tiempo de ciclo máximo.

• FOR: un número de vueltas conocido.
• WHILE: repite mientras se cumpla la condición; puede no ejecutarse ninguna vez.
• REPEAT … UNTIL: repite hasta que se cumpla la condición; se ejecuta al menos una vez.

Temporizadores y contadores en SCL

Se usan los mismos temporizadores y contadores IEC que en KOP, llamando a su instancia. Dentro de un FB, lo más cómodo es declararlos como variables estáticas (multiinstancia):

// En la zona Static del FB:  T_Espera : TON_TIME;
#T_Espera(IN := "Pieza_Presente", PT := T#2s);
IF #T_Espera.Q THEN
    "Empujador" := TRUE;
END_IF;

La instrucción del temporizador debe ejecutarse en cada ciclo, no dentro de un IF que a veces no se cumple; si no, el temporizador deja de actualizarse y se comporta de forma extraña.

Bloques reutilizables

SCL brilla en los FB reutilizables: un bloque «Motor» o «Válvula» con sus entradas, salidas, alarmas y memoria propia, que se llama una vez por cada equipo. Las interfaces se declaran en zonas:

¿KOP o SCL?

• KOP: lógica de señales, enclavamientos, marcha y paro, todo lo que el técnico de mantenimiento tiene que seguir con la máquina en marcha.
• SCL: cálculos, escalados, recetas, tratamiento de arrays, secuencias largas con CASE y bloques reutilizables.

Muchos programas buenos combinan los dos: bloques de equipo en SCL y la lógica de la máquina en KOP, llamando a esos bloques.

Errores típicos en SCL

• Confundir = (comparar) con := (asignar).
• Dividir enteros esperando decimales.
• Esperar dentro de un bucle a que cambie una entrada.
• Escribir una salida solo dentro de un IF y que se quede pegada.
• Llamar a un temporizador solo a veces, dentro de un IF.
• Usar variables Temp como memoria entre ciclos.

Resumen

• SCL es el texto estructurado de Siemens (ST en la IEC 61131-3). Asignación con :=, comparación con =.
• IF para decisiones, CASE para secuencias por pasos, FOR/WHILE/REPEAT para recorrer datos, nunca para esperar.
• Los temporizadores IEC se llaman en cada ciclo, mejor como multiinstancia dentro del FB.
• Static guarda memoria entre ciclos; Temp no.
• KOP para la lógica que se diagnostica en planta; SCL para cálculos y secuencias complejas.