3.5.1. Lista de instrucciones

Introducción a Instruction List (IL)

IL (Instruction List) es uno de los lenguajes textuales estandarizados por la norma IEC 61131-3. Su estructura secuencial y el uso de un acumulador implícito lo asemejan al lenguaje ensamblador de los microprocesadores. Aunque en la actualidad lenguajes gráficos como diagrama de contactos (KOP) o FBD son más intuitivos, IL sigue siendo indispensable en tareas de optimización de código, librerías de bajo nivel y migración de sistemas legacy. Su capacidad para expresar operaciones lógicas y aritméticas de forma compacta lo mantiene vigente en entornos CODESYS, Siemens Step 5/7 y PLCopen.

Cada instrucción ocupa normalmente una línea y consta de un código de operación (opcode) y, opcionalmente, uno o varios operandos (variables, constantes o etiquetas). El resultado de las operaciones se almacena en un registro interno llamado acumulador (ACU). Este enfoque de máquina de pila simplificada permite ejecutar complejas redes de contactos con muy pocas instrucciones.

Instrucciones básicas y flujo de datos

Las instrucciones fundamentales manipulan el acumulador y las variables de entrada/salida. A continuación se detallan las más usadas, con ejemplos paso a paso.

Carga y almacenamiento: LD / ST

LD (Load) copia el valor del operando al acumulador. ST (Store) guarda el valor del acumulador en la variable destino. Por ejemplo:

LD  X1   (* carga el estado de la entrada X1 *)
ST  Y1   (* el acumulador se transfiere a la salida Y1 *)

| | Simbología normalizada IEC 60617: contacto NA (X1) y bobina (Y1). En IL, una red de contactos serie se traduce en LD X1 seguido de AND X2.

Operaciones lógicas: AND, OR, NOT

Estas instrucciones combinan el acumulador con el operando y dejan el resultado en el acumulador. Ejemplo de enclavamiento:

LD  X0       (* arranque *)
OR  Y0       (* autoretención *)
ANDN X1      (* X1 normalmente cerrado – paro *)
ST  Y0

Esta secuencia implementa un arranque/paro con prioridad al paro. Nótese el uso de ANDN (AND NOT) para contactos NC.

Aritméticas básicas: ADD, SUB, MUL, DIV

IL también soporta operaciones aritméticas. El acumulador actúa como primer operando; el segundo se toma de la variable o constante. Ejemplo de cálculo de presión diferencial:

LD  P_ALTA
SUB P_BAJA
ST  DIFERENCIAL

Estas operaciones trabajan con enteros o flotantes según el tipo de dato declarado.

Saltos condicionales y control de flujo

La potencia de IL reside en las instrucciones de salto que permiten modificar la secuencia de ejecución en función del acumulador.

JMP, JMPC, JMPNC

• JMP ETIQUETA – salto incondicional.
• JMPC ETIQUETA – salto si el acumulador es verdadero (1 lógico).
• JMPNC ETIQUETA – salto si el acumulador es falso (0 lógico).

Ejemplo de temporización simulada con saltos (espera activa, solo ilustrativo):

inicio:
LD  T1.Q
JMPC  fin_temporizador
LD  X1
AND T1.QN
JMPC inicio
.
fin_temporizador:
ST  Y2

Las etiquetas (inicio:, fin_temporizador:) deben terminar en dos puntos. Así se construyen bucles y bifurcaciones complejas.

# sim_il.py - Ejemplo didáctico para Thonny/Raspberry Pi
# Implementa un bucle de ejecución de instrucciones IL con etiquetas y saltos

programa = [
    ("LD", "X1"),
    ("JMPC", "SALTO"),
    ("LD", "X2"),
    ("ST", "Y1"),
    ("SALTO", None),    # etiqueta
    ("LD", "X3"),
    ("ST", "Y2")
]

# Estado de entradas/salidas (simula %I y %Q)
entradas = {"X1": True, "X2": False, "X3": True}
salidas = {"Y1": False, "Y2": False}
acumulador = False

# Construir mapa de etiquetas (direcciones)
etiquetas = {}
for i, (op, arg) in enumerate(programa):
    if op.endswith(":") or (arg is None and op != "SALTO"):  # detecta etiquetas tipo "SALTO:"
        etiquetas[op.rstrip(":")] = i

pc = 0  # program counter
while pc < len(programa):
    op, arg = programa[pc]
    # Saltar etiquetas (no son instrucciones ejecutables)
    if op.endswith(":") or (arg is None and op != "SALTO"):
        pc += 1
        continue

    if op == "LD":
        acumulador = entradas.get(arg, False)
    elif op == "ST":
        salidas[arg] = acumulador
    elif op == "AND":
        acumulador = acumulador and entradas.get(arg, False)
    elif op == "JMPC":
        if acumulador:
            pc = etiquetas[arg]
            continue  # saltar incremento normal
    # . se pueden añadir más instrucciones
    pc += 1

print("Salidas:", salidas)  # Esperado: Y1=False (porque X1=True saltó), Y2=True